From c182340e80a42cafd727ef4674c4247b8fdbded8 Mon Sep 17 00:00:00 2001 From: lingsheng <860373352@qq.com> Date: Thu, 29 Aug 2024 08:47:20 +0000 Subject: [PATCH] update libpng 1.6.36 to fix CVE-2011-2501 CVE-2011-2690 CVE-2011-2691 CVE-2011-2692 CVE-2011-3045 CVE-2011-3048 CVE-2012-3425 CVE-2015-7981 CVE-2015-8126 CVE-2015-8472 CVE-2015-8540 CVE-2016-10087 CVE-2017-12652 --- backport-libpng-update-to-1.6.36.patch | 72223 +++++++++++++++++++++++ syslinux.spec | 8 +- 2 files changed, 72230 insertions(+), 1 deletion(-) create mode 100644 backport-libpng-update-to-1.6.36.patch diff --git a/backport-libpng-update-to-1.6.36.patch b/backport-libpng-update-to-1.6.36.patch new file mode 100644 index 0000000..96fd7fe --- /dev/null +++ b/backport-libpng-update-to-1.6.36.patch @@ -0,0 +1,72223 @@ +From 137c47d2355adc79d6987c62b63dbf848f67c15e Mon Sep 17 00:00:00 2001 +From: "H. Peter Anvin" +Date: Mon, 4 Feb 2019 13:33:55 -0800 +Subject: [PATCH] libpng: update to 1.6.36 + +Update libpng to version 1.6.36 due to errata in earlier versions. + +Signed-off-by: H. Peter Anvin +--- + com32/include/png.h | 5131 ++++++++++++--------------- + com32/include/pngconf.h | 2050 +++-------- + com32/include/pngdebug.h | 153 + + com32/include/pnginfo.h | 267 ++ + com32/include/pnglibconf.h | 219 ++ + com32/include/pngpriv.h | 2152 ++++++++++++ + com32/include/pngstruct.h | 487 +++ + com32/lib/libpng/ANNOUNCE | 112 +- + com32/lib/libpng/CHANGES | 5744 ++++++++++++++++++++++++------- + com32/lib/libpng/LICENSE | 199 +- + com32/lib/libpng/README | 254 +- + com32/lib/libpng/TODO | 44 +- + com32/lib/libpng/example.c | 650 ++-- + com32/lib/libpng/libpng.3 | 4636 ++++++++++++++++--------- + com32/lib/libpng/libpngpf.3 | 816 +---- + com32/lib/libpng/png.5 | 74 +- + com32/lib/libpng/png.c | 4804 ++++++++++++++++++++++---- + com32/lib/libpng/pngerror.c | 929 ++++- + com32/lib/libpng/pngget.c | 1003 ++++-- + com32/lib/libpng/pngmem.c | 675 +--- + com32/lib/libpng/pngpread.c | 1430 ++------ + com32/lib/libpng/pngread.c | 4571 +++++++++++++++++++----- + com32/lib/libpng/pngrio.c | 116 +- + com32/lib/libpng/pngrtran.c | 5569 ++++++++++++++++-------------- + com32/lib/libpng/pngrutil.c | 4985 +++++++++++++++++---------- + com32/lib/libpng/pngset.c | 1804 ++++++---- + com32/lib/libpng/pngtest.c | 1853 ++++++---- + com32/lib/libpng/pngtrans.c | 641 ++-- + com32/lib/libpng/pngwio.c | 170 +- + com32/lib/libpng/pngwrite.c | 2709 ++++++++++----- + com32/lib/libpng/pngwtran.c | 359 +- + com32/lib/libpng/pngwutil.c | 3241 +++++++++-------- + com32/lib/sys/vesa/background.c | 21 +- + mk/lib.mk | 7 +- + 34 files changed, 36811 insertions(+), 21064 deletions(-) + create mode 100644 com32/include/pngdebug.h + create mode 100644 com32/include/pnginfo.h + create mode 100644 com32/include/pnglibconf.h + create mode 100644 com32/include/pngpriv.h + create mode 100644 com32/include/pngstruct.h + +diff --git a/com32/include/png.h b/com32/include/png.h +index cc1915df..8e272a05 100644 +--- a/com32/include/png.h ++++ b/com32/include/png.h +@@ -1,398 +1,182 @@ ++ + /* png.h - header file for PNG reference library + * +- * libpng version 1.2.44 - June 26, 2010 +- * Copyright (c) 1998-2010 Glenn Randers-Pehrson +- * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) +- * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) ++ * libpng version 1.6.36 - December 1, 2018 + * +- * This code is released under the libpng license (See LICENSE, below) ++ * Copyright (c) 2018 Cosmin Truta ++ * Copyright (c) 1998-2002,2004,2006-2018 Glenn Randers-Pehrson ++ * Copyright (c) 1996-1997 Andreas Dilger ++ * Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc. + * +- * Authors and maintainers: +- * libpng versions 0.71, May 1995, through 0.88, January 1996: Guy Schalnat +- * libpng versions 0.89c, June 1996, through 0.96, May 1997: Andreas Dilger +- * libpng versions 0.97, January 1998, through 1.2.44 - June 26, 2010: Glenn +- * See also "Contributing Authors", below. ++ * This code is released under the libpng license. (See LICENSE, below.) + * +- * Note about libpng version numbers: ++ * Authors and maintainers: ++ * libpng versions 0.71, May 1995, through 0.88, January 1996: Guy Schalnat ++ * libpng versions 0.89, June 1996, through 0.96, May 1997: Andreas Dilger ++ * libpng versions 0.97, January 1998, through 1.6.35, July 2018: ++ * Glenn Randers-Pehrson. ++ * libpng version 1.6.36, December 1, 2018: Cosmin Truta ++ * See also "Contributing Authors", below. ++ */ ++ ++/* ++ * COPYRIGHT NOTICE, DISCLAIMER, and LICENSE ++ * ========================================= + * +- * Due to various miscommunications, unforeseen code incompatibilities +- * and occasional factors outside the authors' control, version numbering +- * on the library has not always been consistent and straightforward. +- * The following table summarizes matters since version 0.89c, which was +- * the first widely used release: ++ * PNG Reference Library License version 2 ++ * --------------------------------------- + * +- * source png.h png.h shared-lib +- * version string int version +- * ------- ------ ----- ---------- +- * 0.89c "1.0 beta 3" 0.89 89 1.0.89 +- * 0.90 "1.0 beta 4" 0.90 90 0.90 [should have been 2.0.90] +- * 0.95 "1.0 beta 5" 0.95 95 0.95 [should have been 2.0.95] +- * 0.96 "1.0 beta 6" 0.96 96 0.96 [should have been 2.0.96] +- * 0.97b "1.00.97 beta 7" 1.00.97 97 1.0.1 [should have been 2.0.97] +- * 0.97c 0.97 97 2.0.97 +- * 0.98 0.98 98 2.0.98 +- * 0.99 0.99 98 2.0.99 +- * 0.99a-m 0.99 99 2.0.99 +- * 1.00 1.00 100 2.1.0 [100 should be 10000] +- * 1.0.0 (from here on, the 100 2.1.0 [100 should be 10000] +- * 1.0.1 png.h string is 10001 2.1.0 +- * 1.0.1a-e identical to the 10002 from here on, the shared library +- * 1.0.2 source version) 10002 is 2.V where V is the source code +- * 1.0.2a-b 10003 version, except as noted. +- * 1.0.3 10003 +- * 1.0.3a-d 10004 +- * 1.0.4 10004 +- * 1.0.4a-f 10005 +- * 1.0.5 (+ 2 patches) 10005 +- * 1.0.5a-d 10006 +- * 1.0.5e-r 10100 (not source compatible) +- * 1.0.5s-v 10006 (not binary compatible) +- * 1.0.6 (+ 3 patches) 10006 (still binary incompatible) +- * 1.0.6d-f 10007 (still binary incompatible) +- * 1.0.6g 10007 +- * 1.0.6h 10007 10.6h (testing xy.z so-numbering) +- * 1.0.6i 10007 10.6i +- * 1.0.6j 10007 2.1.0.6j (incompatible with 1.0.0) +- * 1.0.7beta11-14 DLLNUM 10007 2.1.0.7beta11-14 (binary compatible) +- * 1.0.7beta15-18 1 10007 2.1.0.7beta15-18 (binary compatible) +- * 1.0.7rc1-2 1 10007 2.1.0.7rc1-2 (binary compatible) +- * 1.0.7 1 10007 (still compatible) +- * 1.0.8beta1-4 1 10008 2.1.0.8beta1-4 +- * 1.0.8rc1 1 10008 2.1.0.8rc1 +- * 1.0.8 1 10008 2.1.0.8 +- * 1.0.9beta1-6 1 10009 2.1.0.9beta1-6 +- * 1.0.9rc1 1 10009 2.1.0.9rc1 +- * 1.0.9beta7-10 1 10009 2.1.0.9beta7-10 +- * 1.0.9rc2 1 10009 2.1.0.9rc2 +- * 1.0.9 1 10009 2.1.0.9 +- * 1.0.10beta1 1 10010 2.1.0.10beta1 +- * 1.0.10rc1 1 10010 2.1.0.10rc1 +- * 1.0.10 1 10010 2.1.0.10 +- * 1.0.11beta1-3 1 10011 2.1.0.11beta1-3 +- * 1.0.11rc1 1 10011 2.1.0.11rc1 +- * 1.0.11 1 10011 2.1.0.11 +- * 1.0.12beta1-2 2 10012 2.1.0.12beta1-2 +- * 1.0.12rc1 2 10012 2.1.0.12rc1 +- * 1.0.12 2 10012 2.1.0.12 +- * 1.1.0a-f - 10100 2.1.1.0a-f (branch abandoned) +- * 1.2.0beta1-2 2 10200 2.1.2.0beta1-2 +- * 1.2.0beta3-5 3 10200 3.1.2.0beta3-5 +- * 1.2.0rc1 3 10200 3.1.2.0rc1 +- * 1.2.0 3 10200 3.1.2.0 +- * 1.2.1beta1-4 3 10201 3.1.2.1beta1-4 +- * 1.2.1rc1-2 3 10201 3.1.2.1rc1-2 +- * 1.2.1 3 10201 3.1.2.1 +- * 1.2.2beta1-6 12 10202 12.so.0.1.2.2beta1-6 +- * 1.0.13beta1 10 10013 10.so.0.1.0.13beta1 +- * 1.0.13rc1 10 10013 10.so.0.1.0.13rc1 +- * 1.2.2rc1 12 10202 12.so.0.1.2.2rc1 +- * 1.0.13 10 10013 10.so.0.1.0.13 +- * 1.2.2 12 10202 12.so.0.1.2.2 +- * 1.2.3rc1-6 12 10203 12.so.0.1.2.3rc1-6 +- * 1.2.3 12 10203 12.so.0.1.2.3 +- * 1.2.4beta1-3 13 10204 12.so.0.1.2.4beta1-3 +- * 1.0.14rc1 13 10014 10.so.0.1.0.14rc1 +- * 1.2.4rc1 13 10204 12.so.0.1.2.4rc1 +- * 1.0.14 10 10014 10.so.0.1.0.14 +- * 1.2.4 13 10204 12.so.0.1.2.4 +- * 1.2.5beta1-2 13 10205 12.so.0.1.2.5beta1-2 +- * 1.0.15rc1-3 10 10015 10.so.0.1.0.15rc1-3 +- * 1.2.5rc1-3 13 10205 12.so.0.1.2.5rc1-3 +- * 1.0.15 10 10015 10.so.0.1.0.15 +- * 1.2.5 13 10205 12.so.0.1.2.5 +- * 1.2.6beta1-4 13 10206 12.so.0.1.2.6beta1-4 +- * 1.0.16 10 10016 10.so.0.1.0.16 +- * 1.2.6 13 10206 12.so.0.1.2.6 +- * 1.2.7beta1-2 13 10207 12.so.0.1.2.7beta1-2 +- * 1.0.17rc1 10 10017 10.so.0.1.0.17rc1 +- * 1.2.7rc1 13 10207 12.so.0.1.2.7rc1 +- * 1.0.17 10 10017 10.so.0.1.0.17 +- * 1.2.7 13 10207 12.so.0.1.2.7 +- * 1.2.8beta1-5 13 10208 12.so.0.1.2.8beta1-5 +- * 1.0.18rc1-5 10 10018 10.so.0.1.0.18rc1-5 +- * 1.2.8rc1-5 13 10208 12.so.0.1.2.8rc1-5 +- * 1.0.18 10 10018 10.so.0.1.0.18 +- * 1.2.8 13 10208 12.so.0.1.2.8 +- * 1.2.9beta1-3 13 10209 12.so.0.1.2.9beta1-3 +- * 1.2.9beta4-11 13 10209 12.so.0.9[.0] +- * 1.2.9rc1 13 10209 12.so.0.9[.0] +- * 1.2.9 13 10209 12.so.0.9[.0] +- * 1.2.10beta1-8 13 10210 12.so.0.10[.0] +- * 1.2.10rc1-3 13 10210 12.so.0.10[.0] +- * 1.2.10 13 10210 12.so.0.10[.0] +- * 1.2.11beta1-4 13 10211 12.so.0.11[.0] +- * 1.0.19rc1-5 10 10019 10.so.0.19[.0] +- * 1.2.11rc1-5 13 10211 12.so.0.11[.0] +- * 1.0.19 10 10019 10.so.0.19[.0] +- * 1.2.11 13 10211 12.so.0.11[.0] +- * 1.0.20 10 10020 10.so.0.20[.0] +- * 1.2.12 13 10212 12.so.0.12[.0] +- * 1.2.13beta1 13 10213 12.so.0.13[.0] +- * 1.0.21 10 10021 10.so.0.21[.0] +- * 1.2.13 13 10213 12.so.0.13[.0] +- * 1.2.14beta1-2 13 10214 12.so.0.14[.0] +- * 1.0.22rc1 10 10022 10.so.0.22[.0] +- * 1.2.14rc1 13 10214 12.so.0.14[.0] +- * 1.0.22 10 10022 10.so.0.22[.0] +- * 1.2.14 13 10214 12.so.0.14[.0] +- * 1.2.15beta1-6 13 10215 12.so.0.15[.0] +- * 1.0.23rc1-5 10 10023 10.so.0.23[.0] +- * 1.2.15rc1-5 13 10215 12.so.0.15[.0] +- * 1.0.23 10 10023 10.so.0.23[.0] +- * 1.2.15 13 10215 12.so.0.15[.0] +- * 1.2.16beta1-2 13 10216 12.so.0.16[.0] +- * 1.2.16rc1 13 10216 12.so.0.16[.0] +- * 1.0.24 10 10024 10.so.0.24[.0] +- * 1.2.16 13 10216 12.so.0.16[.0] +- * 1.2.17beta1-2 13 10217 12.so.0.17[.0] +- * 1.0.25rc1 10 10025 10.so.0.25[.0] +- * 1.2.17rc1-3 13 10217 12.so.0.17[.0] +- * 1.0.25 10 10025 10.so.0.25[.0] +- * 1.2.17 13 10217 12.so.0.17[.0] +- * 1.0.26 10 10026 10.so.0.26[.0] +- * 1.2.18 13 10218 12.so.0.18[.0] +- * 1.2.19beta1-31 13 10219 12.so.0.19[.0] +- * 1.0.27rc1-6 10 10027 10.so.0.27[.0] +- * 1.2.19rc1-6 13 10219 12.so.0.19[.0] +- * 1.0.27 10 10027 10.so.0.27[.0] +- * 1.2.19 13 10219 12.so.0.19[.0] +- * 1.2.20beta01-04 13 10220 12.so.0.20[.0] +- * 1.0.28rc1-6 10 10028 10.so.0.28[.0] +- * 1.2.20rc1-6 13 10220 12.so.0.20[.0] +- * 1.0.28 10 10028 10.so.0.28[.0] +- * 1.2.20 13 10220 12.so.0.20[.0] +- * 1.2.21beta1-2 13 10221 12.so.0.21[.0] +- * 1.2.21rc1-3 13 10221 12.so.0.21[.0] +- * 1.0.29 10 10029 10.so.0.29[.0] +- * 1.2.21 13 10221 12.so.0.21[.0] +- * 1.2.22beta1-4 13 10222 12.so.0.22[.0] +- * 1.0.30rc1 10 10030 10.so.0.30[.0] +- * 1.2.22rc1 13 10222 12.so.0.22[.0] +- * 1.0.30 10 10030 10.so.0.30[.0] +- * 1.2.22 13 10222 12.so.0.22[.0] +- * 1.2.23beta01-05 13 10223 12.so.0.23[.0] +- * 1.2.23rc01 13 10223 12.so.0.23[.0] +- * 1.2.23 13 10223 12.so.0.23[.0] +- * 1.2.24beta01-02 13 10224 12.so.0.24[.0] +- * 1.2.24rc01 13 10224 12.so.0.24[.0] +- * 1.2.24 13 10224 12.so.0.24[.0] +- * 1.2.25beta01-06 13 10225 12.so.0.25[.0] +- * 1.2.25rc01-02 13 10225 12.so.0.25[.0] +- * 1.0.31 10 10031 10.so.0.31[.0] +- * 1.2.25 13 10225 12.so.0.25[.0] +- * 1.2.26beta01-06 13 10226 12.so.0.26[.0] +- * 1.2.26rc01 13 10226 12.so.0.26[.0] +- * 1.2.26 13 10226 12.so.0.26[.0] +- * 1.0.32 10 10032 10.so.0.32[.0] +- * 1.2.27beta01-06 13 10227 12.so.0.27[.0] +- * 1.2.27rc01 13 10227 12.so.0.27[.0] +- * 1.0.33 10 10033 10.so.0.33[.0] +- * 1.2.27 13 10227 12.so.0.27[.0] +- * 1.0.34 10 10034 10.so.0.34[.0] +- * 1.2.28 13 10228 12.so.0.28[.0] +- * 1.2.29beta01-03 13 10229 12.so.0.29[.0] +- * 1.2.29rc01 13 10229 12.so.0.29[.0] +- * 1.0.35 10 10035 10.so.0.35[.0] +- * 1.2.29 13 10229 12.so.0.29[.0] +- * 1.0.37 10 10037 10.so.0.37[.0] +- * 1.2.30beta01-04 13 10230 12.so.0.30[.0] +- * 1.0.38rc01-08 10 10038 10.so.0.38[.0] +- * 1.2.30rc01-08 13 10230 12.so.0.30[.0] +- * 1.0.38 10 10038 10.so.0.38[.0] +- * 1.2.30 13 10230 12.so.0.30[.0] +- * 1.0.39rc01-03 10 10039 10.so.0.39[.0] +- * 1.2.31rc01-03 13 10231 12.so.0.31[.0] +- * 1.0.39 10 10039 10.so.0.39[.0] +- * 1.2.31 13 10231 12.so.0.31[.0] +- * 1.2.32beta01-02 13 10232 12.so.0.32[.0] +- * 1.0.40rc01 10 10040 10.so.0.40[.0] +- * 1.2.32rc01 13 10232 12.so.0.32[.0] +- * 1.0.40 10 10040 10.so.0.40[.0] +- * 1.2.32 13 10232 12.so.0.32[.0] +- * 1.2.33beta01-02 13 10233 12.so.0.33[.0] +- * 1.2.33rc01-02 13 10233 12.so.0.33[.0] +- * 1.0.41rc01 10 10041 10.so.0.41[.0] +- * 1.2.33 13 10233 12.so.0.33[.0] +- * 1.0.41 10 10041 10.so.0.41[.0] +- * 1.2.34beta01-07 13 10234 12.so.0.34[.0] +- * 1.0.42rc01 10 10042 10.so.0.42[.0] +- * 1.2.34rc01 13 10234 12.so.0.34[.0] +- * 1.0.42 10 10042 10.so.0.42[.0] +- * 1.2.34 13 10234 12.so.0.34[.0] +- * 1.2.35beta01-03 13 10235 12.so.0.35[.0] +- * 1.0.43rc01-02 10 10043 10.so.0.43[.0] +- * 1.2.35rc01-02 13 10235 12.so.0.35[.0] +- * 1.0.43 10 10043 10.so.0.43[.0] +- * 1.2.35 13 10235 12.so.0.35[.0] +- * 1.2.36beta01-05 13 10236 12.so.0.36[.0] +- * 1.2.36rc01 13 10236 12.so.0.36[.0] +- * 1.0.44 10 10044 10.so.0.44[.0] +- * 1.2.36 13 10236 12.so.0.36[.0] +- * 1.2.37beta01-03 13 10237 12.so.0.37[.0] +- * 1.2.37rc01 13 10237 12.so.0.37[.0] +- * 1.2.37 13 10237 12.so.0.37[.0] +- * 1.2.45 10 10045 12.so.0.45[.0] +- * 1.0.46 10 10046 10.so.0.46[.0] +- * 1.2.38beta01 13 10238 12.so.0.38[.0] +- * 1.2.38rc01-03 13 10238 12.so.0.38[.0] +- * 1.0.47 10 10047 10.so.0.47[.0] +- * 1.2.38 13 10238 12.so.0.38[.0] +- * 1.2.39beta01-05 13 10239 12.so.0.39[.0] +- * 1.2.39rc01 13 10239 12.so.0.39[.0] +- * 1.0.48 10 10048 10.so.0.48[.0] +- * 1.2.39 13 10239 12.so.0.39[.0] +- * 1.2.40beta01 13 10240 12.so.0.40[.0] +- * 1.2.40rc01 13 10240 12.so.0.40[.0] +- * 1.0.49 10 10049 10.so.0.49[.0] +- * 1.2.40 13 10240 12.so.0.40[.0] +- * 1.2.41beta01-18 13 10241 12.so.0.41[.0] +- * 1.0.51rc01 10 10051 10.so.0.51[.0] +- * 1.2.41rc01-03 13 10241 12.so.0.41[.0] +- * 1.0.51 10 10051 10.so.0.51[.0] +- * 1.2.41 13 10241 12.so.0.41[.0] +- * 1.2.42beta01-02 13 10242 12.so.0.42[.0] +- * 1.2.42rc01-05 13 10242 12.so.0.42[.0] +- * 1.0.52 10 10052 10.so.0.52[.0] +- * 1.2.42 13 10242 12.so.0.42[.0] +- * 1.2.43beta01-05 13 10243 12.so.0.43[.0] +- * 1.0.53rc01-02 10 10053 10.so.0.53[.0] +- * 1.2.43rc01-02 13 10243 12.so.0.43[.0] +- * 1.0.53 10 10053 10.so.0.53[.0] +- * 1.2.43 13 10243 12.so.0.43[.0] +- * 1.2.44beta01-03 13 10244 12.so.0.44[.0] +- * 1.2.44rc01-03 13 10244 12.so.0.44[.0] +- * 1.2.44 13 10244 12.so.0.44[.0] +- * +- * Henceforth the source version will match the shared-library major +- * and minor numbers; the shared-library major version number will be +- * used for changes in backward compatibility, as it is intended. The +- * PNG_LIBPNG_VER macro, which is not used within libpng but is available +- * for applications, is an unsigned integer of the form xyyzz corresponding +- * to the source version x.y.z (leading zeros in y and z). Beta versions +- * were given the previous public release number plus a letter, until +- * version 1.0.6j; from then on they were given the upcoming public +- * release number plus "betaNN" or "rcNN". ++ * * Copyright (c) 1995-2018 The PNG Reference Library Authors. ++ * * Copyright (c) 2018 Cosmin Truta. ++ * * Copyright (c) 2000-2002, 2004, 2006-2018 Glenn Randers-Pehrson. ++ * * Copyright (c) 1996-1997 Andreas Dilger. ++ * * Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc. + * +- * Binary incompatibility exists only when applications make direct access +- * to the info_ptr or png_ptr members through png.h, and the compiled +- * application is loaded with a different version of the library. ++ * The software is supplied "as is", without warranty of any kind, ++ * express or implied, including, without limitation, the warranties ++ * of merchantability, fitness for a particular purpose, title, and ++ * non-infringement. In no even shall the Copyright owners, or ++ * anyone distributing the software, be liable for any damages or ++ * other liability, whether in contract, tort or otherwise, arising ++ * from, out of, or in connection with the software, or the use or ++ * other dealings in the software, even if advised of the possibility ++ * of such damage. + * +- * DLLNUM will change each time there are forward or backward changes +- * in binary compatibility (e.g., when a new feature is added). ++ * Permission is hereby granted to use, copy, modify, and distribute ++ * this software, or portions hereof, for any purpose, without fee, ++ * subject to the following restrictions: + * +- * See libpng.txt or libpng.3 for more information. The PNG specification +- * is available as a W3C Recommendation and as an ISO Specification, +- * + */ + + #ifndef PNG_H + #define PNG_H + +-/* This is not the place to learn how to use libpng. The file libpng.txt ++/* 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 ++ * ++ * ++ * 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.2.44" +-#define PNG_HEADER_VERSION_STRING \ +- " libpng version 1.2.44 - June 26, 2010\n" ++#define PNG_LIBPNG_VER_STRING "1.6.36" ++#define PNG_HEADER_VERSION_STRING " libpng version 1.6.36 - December 1, 2018\n" + +-#define PNG_LIBPNG_VER_SONUM 0 +-#define PNG_LIBPNG_VER_DLLNUM 13 ++#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 2 +-#define PNG_LIBPNG_VER_RELEASE 44 ++#define PNG_LIBPNG_VER_MINOR 6 ++#define PNG_LIBPNG_VER_RELEASE 36 ++ + /* This should match the numeric part of the final component of + * PNG_LIBPNG_VER_STRING, omitting any leading zero: + */ +@@ -501,25 +311,34 @@ + + #define PNG_LIBPNG_BUILD_BASE_TYPE PNG_LIBPNG_BUILD_STABLE + +-/* Careful here. At one time, Guy wanted to use 082, but that would be octal. +- * We must not include leading zeros. +- * Versions 0.7 through 1.0.0 were in the range 0 to 100 here (only +- * version 1.0.0 was mis-numbered 100 instead of 10000). From +- * version 1.0.1 it's xxyyzz, where x=major, y=minor, z=release ++/* Careful here. At one time, Guy wanted to use 082, but that ++ * would be octal. We must not include leading zeros. ++ * Versions 0.7 through 1.0.0 were in the range 0 to 100 here ++ * (only version 1.0.0 was mis-numbered 100 instead of 10000). ++ * From version 1.0.1 it is: ++ * XXYYZZ, where XX=major, YY=minor, ZZ=release + */ +-#define PNG_LIBPNG_VER 10244 /* 1.2.44 */ ++#define PNG_LIBPNG_VER 10636 /* 1.6.36 */ + +-#ifndef PNG_VERSION_INFO_ONLY +-/* Include the compression library's header */ +-#include "zlib.h" ++/* Library configuration: these options cannot be changed after ++ * the library has been built. ++ */ ++#ifndef PNGLCONF_H ++/* If pnglibconf.h is missing, you can ++ * copy scripts/pnglibconf.h.prebuilt to pnglibconf.h ++ */ ++# include "pnglibconf.h" + #endif + +-/* Include all user configurable info, including optional assembler routines */ +-#include "pngconf.h" ++#ifndef PNG_VERSION_INFO_ONLY ++/* Machine specific configuration. */ ++# include "pngconf.h" ++#endif + + /* +- * Added at libpng-1.2.8 */ +-/* Ref MSDN: Private as priority over Special ++ * Added at libpng-1.2.8 ++ * ++ * Ref MSDN: Private as priority over Special + * VS_FF_PRIVATEBUILD File *was not* built using standard release + * procedures. If this value is given, the StringFileInfo block must + * contain a PrivateBuild string. +@@ -530,13 +349,13 @@ + * StringFileInfo block must contain a SpecialBuild string. + */ + +-#ifdef PNG_USER_PRIVATEBUILD ++#ifdef PNG_USER_PRIVATEBUILD /* From pnglibconf.h */ + # define PNG_LIBPNG_BUILD_TYPE \ +- (PNG_LIBPNG_BUILD_BASE_TYPE | PNG_LIBPNG_BUILD_PRIVATE) ++ (PNG_LIBPNG_BUILD_BASE_TYPE | PNG_LIBPNG_BUILD_PRIVATE) + #else + # ifdef PNG_LIBPNG_SPECIALBUILD + # define PNG_LIBPNG_BUILD_TYPE \ +- (PNG_LIBPNG_BUILD_BASE_TYPE | PNG_LIBPNG_BUILD_SPECIAL) ++ (PNG_LIBPNG_BUILD_BASE_TYPE | PNG_LIBPNG_BUILD_SPECIAL) + # else + # define PNG_LIBPNG_BUILD_TYPE (PNG_LIBPNG_BUILD_BASE_TYPE) + # endif +@@ -549,73 +368,108 @@ + extern "C" { + #endif /* __cplusplus */ + +-/* This file is arranged in several sections. The first section contains +- * structure and type definitions. The second section contains the external +- * library functions, while the third has the internal library functions, +- * which applications aren't expected to use directly. +- */ +- +-#ifndef PNG_NO_TYPECAST_NULL +-#define int_p_NULL (int *)NULL +-#define png_bytep_NULL (png_bytep)NULL +-#define png_bytepp_NULL (png_bytepp)NULL +-#define png_doublep_NULL (png_doublep)NULL +-#define png_error_ptr_NULL (png_error_ptr)NULL +-#define png_flush_ptr_NULL (png_flush_ptr)NULL +-#define png_free_ptr_NULL (png_free_ptr)NULL +-#define png_infopp_NULL (png_infopp)NULL +-#define png_malloc_ptr_NULL (png_malloc_ptr)NULL +-#define png_read_status_ptr_NULL (png_read_status_ptr)NULL +-#define png_rw_ptr_NULL (png_rw_ptr)NULL +-#define png_structp_NULL (png_structp)NULL +-#define png_uint_16p_NULL (png_uint_16p)NULL +-#define png_voidp_NULL (png_voidp)NULL +-#define png_write_status_ptr_NULL (png_write_status_ptr)NULL +-#else +-#define int_p_NULL NULL +-#define png_bytep_NULL NULL +-#define png_bytepp_NULL NULL +-#define png_doublep_NULL NULL +-#define png_error_ptr_NULL NULL +-#define png_flush_ptr_NULL NULL +-#define png_free_ptr_NULL NULL +-#define png_infopp_NULL NULL +-#define png_malloc_ptr_NULL NULL +-#define png_read_status_ptr_NULL NULL +-#define png_rw_ptr_NULL NULL +-#define png_structp_NULL NULL +-#define png_uint_16p_NULL NULL +-#define png_voidp_NULL NULL +-#define png_write_status_ptr_NULL NULL +-#endif +- +-/* Variables declared in png.c - only it needs to define PNG_NO_EXTERN */ +-#if !defined(PNG_NO_EXTERN) || defined(PNG_ALWAYS_EXTERN) + /* Version information for C files, stored in png.c. This had better match + * the version above. + */ +-#ifdef PNG_USE_GLOBAL_ARRAYS +-PNG_EXPORT_VAR (PNG_CONST char) png_libpng_ver[18]; +- /* Need room for 99.99.99beta99z */ +-#else + #define png_libpng_ver png_get_header_ver(NULL) +-#endif + +-#ifdef PNG_USE_GLOBAL_ARRAYS +-/* This was removed in version 1.0.5c */ +-/* Structures to facilitate easy interlacing. See png.c for more details */ +-PNG_EXPORT_VAR (PNG_CONST int FARDATA) png_pass_start[7]; +-PNG_EXPORT_VAR (PNG_CONST int FARDATA) png_pass_inc[7]; +-PNG_EXPORT_VAR (PNG_CONST int FARDATA) png_pass_ystart[7]; +-PNG_EXPORT_VAR (PNG_CONST int FARDATA) png_pass_yinc[7]; +-PNG_EXPORT_VAR (PNG_CONST int FARDATA) png_pass_mask[7]; +-PNG_EXPORT_VAR (PNG_CONST int FARDATA) png_pass_dsp_mask[7]; +-/* This isn't currently used. If you need it, see png.c for more details. +-PNG_EXPORT_VAR (PNG_CONST int FARDATA) png_pass_height[7]; +-*/ +-#endif ++/* This file is arranged in several sections: ++ * ++ * 1. [omitted] ++ * 2. Any configuration options that can be specified by for the application ++ * code when it is built. (Build time configuration is in pnglibconf.h) ++ * 3. Type definitions (base types are defined in pngconf.h), structure ++ * definitions. ++ * 4. Exported library functions. ++ * 5. Simplified API. ++ * 6. Implementation options. ++ * ++ * The library source code has additional files (principally pngpriv.h) that ++ * allow configuration of the library. ++ */ ++ ++/* Section 1: [omitted] */ ++ ++/* Section 2: run time configuration ++ * See pnglibconf.h for build time configuration ++ * ++ * Run time configuration allows the application to choose between ++ * implementations of certain arithmetic APIs. The default is set ++ * at build time and recorded in pnglibconf.h, but it is safe to ++ * override these (and only these) settings. Note that this won't ++ * change what the library does, only application code, and the ++ * settings can (and probably should) be made on a per-file basis ++ * by setting the #defines before including png.h ++ * ++ * Use macros to read integers from PNG data or use the exported ++ * functions? ++ * PNG_USE_READ_MACROS: use the macros (see below) Note that ++ * the macros evaluate their argument multiple times. ++ * PNG_NO_USE_READ_MACROS: call the relevant library function. ++ * ++ * Use the alternative algorithm for compositing alpha samples that ++ * does not use division? ++ * PNG_READ_COMPOSITE_NODIV_SUPPORTED: use the 'no division' ++ * algorithm. ++ * PNG_NO_READ_COMPOSITE_NODIV: use the 'division' algorithm. ++ * ++ * How to handle benign errors if PNG_ALLOW_BENIGN_ERRORS is ++ * false? ++ * PNG_ALLOW_BENIGN_ERRORS: map calls to the benign error ++ * APIs to png_warning. ++ * Otherwise the calls are mapped to png_error. ++ */ ++ ++/* Section 3: type definitions, including structures and compile time ++ * constants. ++ * See pngconf.h for base types that vary by machine/system ++ */ ++ ++/* This triggers a compiler error in png.c, if png.c and png.h ++ * do not agree upon the version number. ++ */ ++typedef char* png_libpng_version_1_6_36; + +-#endif /* PNG_NO_EXTERN */ ++/* 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 +@@ -627,8 +481,9 @@ typedef struct png_color_struct + png_byte green; + png_byte blue; + } png_color; +-typedef png_color FAR * png_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 + { +@@ -638,8 +493,9 @@ typedef struct png_color_16_struct + png_uint_16 blue; + png_uint_16 gray; /* for use in grayscale files */ + } png_color_16; +-typedef png_color_16 FAR * png_color_16p; +-typedef png_color_16 FAR * FAR * png_color_16pp; ++typedef 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 + { +@@ -649,8 +505,9 @@ typedef struct png_color_8_struct + png_byte gray; /* for use in grayscale files */ + png_byte alpha; /* for alpha channel files */ + } png_color_8; +-typedef png_color_8 FAR * png_color_8p; +-typedef png_color_8 FAR * FAR * png_color_8pp; ++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 +@@ -664,8 +521,9 @@ typedef struct png_sPLT_entry_struct + png_uint_16 alpha; + png_uint_16 frequency; + } png_sPLT_entry; +-typedef png_sPLT_entry FAR * png_sPLT_entryp; +-typedef png_sPLT_entry FAR * FAR * png_sPLT_entrypp; ++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 +@@ -679,17 +537,27 @@ typedef struct png_sPLT_struct + png_sPLT_entryp entries; /* palette entries */ + png_int_32 nentries; /* number of palette entries */ + } png_sPLT_t; +-typedef png_sPLT_t FAR * png_sPLT_tp; +-typedef png_sPLT_t FAR * FAR * png_sPLT_tpp; ++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. +- * 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. ++ * 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 ++ * 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 + { +@@ -701,22 +569,20 @@ typedef struct png_text_struct + png_charp key; /* keyword, 1-79 character description of "text" */ + png_charp text; /* comment, may be an empty string (ie "") + or a NULL pointer */ +- png_size_t text_length; /* length of the text string */ +-#ifdef PNG_iTXt_SUPPORTED +- png_size_t itxt_length; /* length of the itxt string */ ++ size_t text_length; /* length of the text string */ ++ size_t itxt_length; /* length of the itxt string */ + png_charp lang; /* language code, 0-79 characters + or a NULL pointer */ + png_charp lang_key; /* keyword translated UTF-8 string, 0 or more + chars or a NULL pointer */ +-#endif + } png_text; +-typedef png_text FAR * png_textp; +-typedef png_text FAR * FAR * png_textpp; ++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). +- * The values of the PNG_TEXT_COMPRESSION_ defines should NOT be changed. +- */ ++ * The values of the PNG_TEXT_COMPRESSION_ defines should NOT be changed. */ + #define PNG_TEXT_COMPRESSION_NONE_WR -3 + #define PNG_TEXT_COMPRESSION_zTXt_WR -2 + #define PNG_TEXT_COMPRESSION_NONE -1 +@@ -740,320 +606,57 @@ typedef struct png_time_struct + png_byte minute; /* minute of hour, 0 - 59 */ + png_byte second; /* second of minute, 0 - 60 (for leap seconds) */ + } png_time; +-typedef png_time FAR * png_timep; +-typedef png_time FAR * FAR * png_timepp; ++typedef png_time * png_timep; ++typedef const png_time * png_const_timep; ++typedef png_time * * png_timepp; + +-#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED) || \ +- defined(PNG_HANDLE_AS_UNKNOWN_SUPPORTED) ++#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. + */ +-#define PNG_CHUNK_NAME_LENGTH 5 + typedef struct png_unknown_chunk_t + { +- png_byte name[PNG_CHUNK_NAME_LENGTH]; +- png_byte *data; +- png_size_t size; +- +- /* libpng-using applications should NOT directly modify this byte. */ +- png_byte location; /* mode of operation at read time */ ++ png_byte name[5]; /* Textual chunk name with '\0' terminator */ ++ png_byte *data; /* Data, should not be modified on read! */ ++ size_t size; ++ ++ /* 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_unknown_chunk FAR * FAR * png_unknown_chunkpp; +-#endif +- +-/* png_info is a structure that holds the information in a PNG file so +- * that the application can find out the characteristics of the image. +- * If you are reading the file, this structure will tell you what is +- * in the PNG file. If you are writing the file, fill in the information +- * you want to put into the PNG file, then call png_write_info(). +- * The names chosen should be very close to the PNG specification, so +- * consult that document for information about the meaning of each field. +- * +- * With libpng < 0.95, it was only possible to directly set and read the +- * the values in the png_info_struct, which meant that the contents and +- * order of the values had to remain fixed. With libpng 0.95 and later, +- * however, there are now functions that abstract the contents of +- * png_info_struct from the application, so this makes it easier to use +- * libpng with dynamic libraries, and even makes it possible to use +- * libraries that don't have all of the libpng ancillary chunk-handing +- * functionality. +- * +- * In any case, the order of the parameters in png_info_struct should NOT +- * be changed for as long as possible to keep compatibility with applications +- * that use the old direct-access method with png_info_struct. +- * +- * The following members may have allocated storage attached that should be +- * cleaned up before the structure is discarded: palette, trans, text, +- * pcal_purpose, pcal_units, pcal_params, hist, iccp_name, iccp_profile, +- * splt_palettes, scal_unit, row_pointers, and unknowns. By default, these +- * are automatically freed when the info structure is deallocated, if they were +- * allocated internally by libpng. This behavior can be changed by means +- * of the png_data_freer() function. +- * +- * More allocation details: all the chunk-reading functions that +- * change these members go through the corresponding png_set_* +- * functions. A function to clear these members is available: see +- * png_free_data(). The png_set_* functions do not depend on being +- * able to point info structure members to any of the storage they are +- * passed (they make their own copies), EXCEPT that the png_set_text +- * functions use the same storage passed to them in the text_ptr or +- * itxt_ptr structure argument, and the png_set_rows and png_set_unknowns +- * functions do not make their own copies. +- */ +-typedef struct png_info_struct +-{ +- /* The following are necessary for every PNG file */ +- png_uint_32 width PNG_DEPSTRUCT; /* width of image in pixels (from IHDR) */ +- png_uint_32 height PNG_DEPSTRUCT; /* height of image in pixels (from IHDR) */ +- png_uint_32 valid PNG_DEPSTRUCT; /* valid chunk data (see PNG_INFO_ below) */ +- png_uint_32 rowbytes PNG_DEPSTRUCT; /* bytes needed to hold an untransformed row */ +- png_colorp palette PNG_DEPSTRUCT; /* array of color values (valid & PNG_INFO_PLTE) */ +- png_uint_16 num_palette PNG_DEPSTRUCT; /* number of color entries in "palette" (PLTE) */ +- png_uint_16 num_trans PNG_DEPSTRUCT; /* number of transparent palette color (tRNS) */ +- png_byte bit_depth PNG_DEPSTRUCT; /* 1, 2, 4, 8, or 16 bits/channel (from IHDR) */ +- png_byte color_type PNG_DEPSTRUCT; /* see PNG_COLOR_TYPE_ below (from IHDR) */ +- /* The following three should have been named *_method not *_type */ +- png_byte compression_type PNG_DEPSTRUCT; /* must be PNG_COMPRESSION_TYPE_BASE (IHDR) */ +- png_byte filter_type PNG_DEPSTRUCT; /* must be PNG_FILTER_TYPE_BASE (from IHDR) */ +- png_byte interlace_type PNG_DEPSTRUCT; /* One of PNG_INTERLACE_NONE, PNG_INTERLACE_ADAM7 */ +- +- /* The following is informational only on read, and not used on writes. */ +- png_byte channels PNG_DEPSTRUCT; /* number of data channels per pixel (1, 2, 3, 4) */ +- png_byte pixel_depth PNG_DEPSTRUCT; /* number of bits per pixel */ +- png_byte spare_byte PNG_DEPSTRUCT; /* to align the data, and for future use */ +- png_byte signature[8] PNG_DEPSTRUCT; /* magic bytes read by libpng from start of file */ +- +- /* The rest of the data is optional. If you are reading, check the +- * valid field to see if the information in these are valid. If you +- * are writing, set the valid field to those chunks you want written, +- * and initialize the appropriate fields below. +- */ +- +-#if defined(PNG_gAMA_SUPPORTED) && defined(PNG_FLOATING_POINT_SUPPORTED) +- /* The gAMA chunk describes the gamma characteristics of the system +- * on which the image was created, normally in the range [1.0, 2.5]. +- * Data is valid if (valid & PNG_INFO_gAMA) is non-zero. +- */ +- float gamma PNG_DEPSTRUCT; /* gamma value of image, if (valid & PNG_INFO_gAMA) */ +-#endif +- +-#ifdef PNG_sRGB_SUPPORTED +- /* GR-P, 0.96a */ +- /* Data valid if (valid & PNG_INFO_sRGB) non-zero. */ +- png_byte srgb_intent PNG_DEPSTRUCT; /* sRGB rendering intent [0, 1, 2, or 3] */ +-#endif +- +-#ifdef PNG_TEXT_SUPPORTED +- /* The tEXt, and zTXt chunks contain human-readable textual data in +- * uncompressed, compressed, and optionally compressed forms, respectively. +- * The data in "text" is an array of pointers to uncompressed, +- * null-terminated C strings. Each chunk has a keyword that describes the +- * textual data contained in that chunk. Keywords are not required to be +- * unique, and the text string may be empty. Any number of text chunks may +- * be in an image. +- */ +- int num_text PNG_DEPSTRUCT; /* number of comments read/to write */ +- int max_text PNG_DEPSTRUCT; /* current size of text array */ +- png_textp text PNG_DEPSTRUCT; /* array of comments read/to write */ +-#endif /* PNG_TEXT_SUPPORTED */ +- +-#ifdef PNG_tIME_SUPPORTED +- /* The tIME chunk holds the last time the displayed image data was +- * modified. See the png_time struct for the contents of this struct. +- */ +- png_time mod_time PNG_DEPSTRUCT; +-#endif +- +-#ifdef PNG_sBIT_SUPPORTED +- /* The sBIT chunk specifies the number of significant high-order bits +- * in the pixel data. Values are in the range [1, bit_depth], and are +- * only specified for the channels in the pixel data. The contents of +- * the low-order bits is not specified. Data is valid if +- * (valid & PNG_INFO_sBIT) is non-zero. +- */ +- png_color_8 sig_bit PNG_DEPSTRUCT; /* significant bits in color channels */ +-#endif +- +-#if defined(PNG_tRNS_SUPPORTED) || defined(PNG_READ_EXPAND_SUPPORTED) || \ +-defined(PNG_READ_BACKGROUND_SUPPORTED) +- /* The tRNS chunk supplies transparency data for paletted images and +- * other image types that don't need a full alpha channel. There are +- * "num_trans" transparency values for a paletted image, stored in the +- * same order as the palette colors, starting from index 0. Values +- * for the data are in the range [0, 255], ranging from fully transparent +- * to fully opaque, respectively. For non-paletted images, there is a +- * single color specified that should be treated as fully transparent. +- * Data is valid if (valid & PNG_INFO_tRNS) is non-zero. +- */ +- png_bytep trans PNG_DEPSTRUCT; /* transparent values for paletted image */ +- png_color_16 trans_values PNG_DEPSTRUCT; /* transparent color for non-palette image */ +-#endif +- +-#if defined(PNG_bKGD_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) +- /* The bKGD chunk gives the suggested image background color if the +- * display program does not have its own background color and the image +- * is needs to composited onto a background before display. The colors +- * in "background" are normally in the same color space/depth as the +- * pixel data. Data is valid if (valid & PNG_INFO_bKGD) is non-zero. +- */ +- png_color_16 background PNG_DEPSTRUCT; +-#endif +- +-#ifdef PNG_oFFs_SUPPORTED +- /* The oFFs chunk gives the offset in "offset_unit_type" units rightwards +- * and downwards from the top-left corner of the display, page, or other +- * application-specific co-ordinate space. See the PNG_OFFSET_ defines +- * below for the unit types. Valid if (valid & PNG_INFO_oFFs) non-zero. +- */ +- png_int_32 x_offset PNG_DEPSTRUCT; /* x offset on page */ +- png_int_32 y_offset PNG_DEPSTRUCT; /* y offset on page */ +- png_byte offset_unit_type PNG_DEPSTRUCT; /* offset units type */ +-#endif +- +-#ifdef PNG_pHYs_SUPPORTED +- /* The pHYs chunk gives the physical pixel density of the image for +- * display or printing in "phys_unit_type" units (see PNG_RESOLUTION_ +- * defines below). Data is valid if (valid & PNG_INFO_pHYs) is non-zero. +- */ +- png_uint_32 x_pixels_per_unit PNG_DEPSTRUCT; /* horizontal pixel density */ +- png_uint_32 y_pixels_per_unit PNG_DEPSTRUCT; /* vertical pixel density */ +- png_byte phys_unit_type PNG_DEPSTRUCT; /* resolution type (see PNG_RESOLUTION_ below) */ +-#endif +- +-#ifdef PNG_hIST_SUPPORTED +- /* The hIST chunk contains the relative frequency or importance of the +- * various palette entries, so that a viewer can intelligently select a +- * reduced-color palette, if required. Data is an array of "num_palette" +- * values in the range [0,65535]. Data valid if (valid & PNG_INFO_hIST) +- * is non-zero. +- */ +- png_uint_16p hist PNG_DEPSTRUCT; +-#endif +- +-#ifdef PNG_cHRM_SUPPORTED +- /* The cHRM chunk describes the CIE color characteristics of the monitor +- * on which the PNG was created. This data allows the viewer to do gamut +- * mapping of the input image to ensure that the viewer sees the same +- * colors in the image as the creator. Values are in the range +- * [0.0, 0.8]. Data valid if (valid & PNG_INFO_cHRM) non-zero. +- */ +-#ifdef PNG_FLOATING_POINT_SUPPORTED +- float x_white PNG_DEPSTRUCT; +- float y_white PNG_DEPSTRUCT; +- float x_red PNG_DEPSTRUCT; +- float y_red PNG_DEPSTRUCT; +- float x_green PNG_DEPSTRUCT; +- float y_green PNG_DEPSTRUCT; +- float x_blue PNG_DEPSTRUCT; +- float y_blue PNG_DEPSTRUCT; +-#endif +-#endif +- +-#ifdef PNG_pCAL_SUPPORTED +- /* The pCAL chunk describes a transformation between the stored pixel +- * values and original physical data values used to create the image. +- * The integer range [0, 2^bit_depth - 1] maps to the floating-point +- * range given by [pcal_X0, pcal_X1], and are further transformed by a +- * (possibly non-linear) transformation function given by "pcal_type" +- * and "pcal_params" into "pcal_units". Please see the PNG_EQUATION_ +- * defines below, and the PNG-Group's PNG extensions document for a +- * complete description of the transformations and how they should be +- * implemented, and for a description of the ASCII parameter strings. +- * Data values are valid if (valid & PNG_INFO_pCAL) non-zero. +- */ +- png_charp pcal_purpose PNG_DEPSTRUCT; /* pCAL chunk description string */ +- png_int_32 pcal_X0 PNG_DEPSTRUCT; /* minimum value */ +- png_int_32 pcal_X1 PNG_DEPSTRUCT; /* maximum value */ +- png_charp pcal_units PNG_DEPSTRUCT; /* Latin-1 string giving physical units */ +- png_charpp pcal_params PNG_DEPSTRUCT; /* ASCII strings containing parameter values */ +- png_byte pcal_type PNG_DEPSTRUCT; /* equation type (see PNG_EQUATION_ below) */ +- png_byte pcal_nparams PNG_DEPSTRUCT; /* number of parameters given in pcal_params */ +-#endif +- +-/* New members added in libpng-1.0.6 */ +-#ifdef PNG_FREE_ME_SUPPORTED +- png_uint_32 free_me PNG_DEPSTRUCT; /* flags items libpng is responsible for freeing */ +-#endif +- +-#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED) || \ +- defined(PNG_HANDLE_AS_UNKNOWN_SUPPORTED) +- /* Storage for unknown chunks that the library doesn't recognize. */ +- png_unknown_chunkp unknown_chunks PNG_DEPSTRUCT; +- png_size_t unknown_chunks_num PNG_DEPSTRUCT; +-#endif +- +-#ifdef PNG_iCCP_SUPPORTED +- /* iCCP chunk data. */ +- png_charp iccp_name PNG_DEPSTRUCT; /* profile name */ +- png_charp iccp_profile PNG_DEPSTRUCT; /* International Color Consortium profile data */ +- /* Note to maintainer: should be png_bytep */ +- png_uint_32 iccp_proflen PNG_DEPSTRUCT; /* ICC profile data length */ +- png_byte iccp_compression PNG_DEPSTRUCT; /* Always zero */ +-#endif +- +-#ifdef PNG_sPLT_SUPPORTED +- /* Data on sPLT chunks (there may be more than one). */ +- png_sPLT_tp splt_palettes PNG_DEPSTRUCT; +- png_uint_32 splt_palettes_num PNG_DEPSTRUCT; +-#endif + +-#ifdef PNG_sCAL_SUPPORTED +- /* The sCAL chunk describes the actual physical dimensions of the +- * subject matter of the graphic. The chunk contains a unit specification +- * a byte value, and two ASCII strings representing floating-point +- * values. The values are width and height corresponsing to one pixel +- * in the image. This external representation is converted to double +- * here. Data values are valid if (valid & PNG_INFO_sCAL) is non-zero. +- */ +- png_byte scal_unit PNG_DEPSTRUCT; /* unit of physical scale */ +-#ifdef PNG_FLOATING_POINT_SUPPORTED +- double scal_pixel_width PNG_DEPSTRUCT; /* width of one pixel */ +- double scal_pixel_height PNG_DEPSTRUCT; /* height of one pixel */ +-#endif +-#ifdef PNG_FIXED_POINT_SUPPORTED +- png_charp scal_s_width PNG_DEPSTRUCT; /* string containing height */ +- png_charp scal_s_height PNG_DEPSTRUCT; /* string containing width */ +-#endif +-#endif +- +-#ifdef PNG_INFO_IMAGE_SUPPORTED +- /* Memory has been allocated if (valid & PNG_ALLOCATED_INFO_ROWS) non-zero */ +- /* Data valid if (valid & PNG_INFO_IDAT) non-zero */ +- png_bytepp row_pointers PNG_DEPSTRUCT; /* the image bits */ +-#endif +- +-#if defined(PNG_FIXED_POINT_SUPPORTED) && defined(PNG_gAMA_SUPPORTED) +- png_fixed_point int_gamma PNG_DEPSTRUCT; /* gamma of image, if (valid & PNG_INFO_gAMA) */ +-#endif +- +-#if defined(PNG_cHRM_SUPPORTED) && defined(PNG_FIXED_POINT_SUPPORTED) +- png_fixed_point int_x_white PNG_DEPSTRUCT; +- png_fixed_point int_y_white PNG_DEPSTRUCT; +- png_fixed_point int_x_red PNG_DEPSTRUCT; +- png_fixed_point int_y_red PNG_DEPSTRUCT; +- png_fixed_point int_x_green PNG_DEPSTRUCT; +- png_fixed_point int_y_green PNG_DEPSTRUCT; +- png_fixed_point int_x_blue PNG_DEPSTRUCT; +- png_fixed_point int_y_blue PNG_DEPSTRUCT; ++typedef png_unknown_chunk * png_unknown_chunkp; ++typedef const png_unknown_chunk * png_const_unknown_chunkp; ++typedef png_unknown_chunk * * png_unknown_chunkpp; + #endif + +-} png_info; +- +-typedef png_info FAR * png_infop; +-typedef png_info FAR * FAR * png_infopp; ++/* Flag values for the unknown chunk location byte. */ ++#define PNG_HAVE_IHDR 0x01 ++#define PNG_HAVE_PLTE 0x02 ++#define PNG_AFTER_IDAT 0x08 + + /* Maximum positive integer used in PNG is (2^31)-1 */ + #define PNG_UINT_31_MAX ((png_uint_32)0x7fffffffL) + #define PNG_UINT_32_MAX ((png_uint_32)(-1)) +-#define PNG_SIZE_MAX ((png_size_t)(-1)) +-#if defined(PNG_1_0_X) || defined (PNG_1_2_X) +-/* PNG_MAX_UINT is deprecated; use PNG_UINT_31_MAX instead. */ +-#define PNG_MAX_UINT PNG_UINT_31_MAX +-#endif ++#define PNG_SIZE_MAX ((size_t)(-1)) ++ ++/* These are constants for fixed point values encoded in the ++ * PNG specification manner (x100000) ++ */ ++#define PNG_FP_1 100000 ++#define PNG_FP_HALF 50000 ++#define PNG_FP_MAX ((png_fixed_point)0x7fffffffL) ++#define PNG_FP_MIN (-PNG_FP_MAX) + + /* These describe the color_type field in png_info. */ + /* color type masks */ +@@ -1126,22 +729,23 @@ typedef png_info FAR * FAR * png_infopp; + * data in the info_struct to be written into the output file. The values + * of the PNG_INFO_ defines should NOT be changed. + */ +-#define PNG_INFO_gAMA 0x0001 +-#define PNG_INFO_sBIT 0x0002 +-#define PNG_INFO_cHRM 0x0004 +-#define PNG_INFO_PLTE 0x0008 +-#define PNG_INFO_tRNS 0x0010 +-#define PNG_INFO_bKGD 0x0020 +-#define PNG_INFO_hIST 0x0040 +-#define PNG_INFO_pHYs 0x0080 +-#define PNG_INFO_oFFs 0x0100 +-#define PNG_INFO_tIME 0x0200 +-#define PNG_INFO_pCAL 0x0400 +-#define PNG_INFO_sRGB 0x0800 /* GR-P, 0.96a */ +-#define PNG_INFO_iCCP 0x1000 /* ESR, 1.0.6 */ +-#define PNG_INFO_sPLT 0x2000 /* ESR, 1.0.6 */ +-#define PNG_INFO_sCAL 0x4000 /* ESR, 1.0.6 */ +-#define PNG_INFO_IDAT 0x8000L /* ESR, 1.0.6 */ ++#define PNG_INFO_gAMA 0x0001U ++#define PNG_INFO_sBIT 0x0002U ++#define PNG_INFO_cHRM 0x0004U ++#define PNG_INFO_PLTE 0x0008U ++#define PNG_INFO_tRNS 0x0010U ++#define PNG_INFO_bKGD 0x0020U ++#define PNG_INFO_hIST 0x0040U ++#define PNG_INFO_pHYs 0x0080U ++#define PNG_INFO_oFFs 0x0100U ++#define PNG_INFO_tIME 0x0200U ++#define PNG_INFO_pCAL 0x0400U ++#define PNG_INFO_sRGB 0x0800U /* GR-P, 0.96a */ ++#define PNG_INFO_iCCP 0x1000U /* ESR, 1.0.6 */ ++#define PNG_INFO_sPLT 0x2000U /* ESR, 1.0.6 */ ++#define PNG_INFO_sCAL 0x4000U /* ESR, 1.0.6 */ ++#define PNG_INFO_IDAT 0x8000U /* ESR, 1.0.6 */ ++#define PNG_INFO_eXIf 0x10000U /* GR-P, 1.6.31 */ + + /* This is used for the transformation routines, as some of them + * change these values for the row. It also should enable using +@@ -1149,53 +753,79 @@ typedef png_info FAR * FAR * png_infopp; + */ + typedef struct png_row_info_struct + { +- png_uint_32 width; /* width of row */ +- png_uint_32 rowbytes; /* number of bytes in row */ +- png_byte color_type; /* color type of row */ +- png_byte bit_depth; /* bit depth of row */ +- png_byte channels; /* number of channels (1, 2, 3, or 4) */ ++ png_uint_32 width; /* width of row */ ++ size_t rowbytes; /* number of bytes in row */ ++ png_byte color_type; /* color type of row */ ++ png_byte bit_depth; /* bit depth of row */ ++ png_byte channels; /* number of channels (1, 2, 3, or 4) */ + png_byte pixel_depth; /* bits per pixel (depth * channels) */ + } png_row_info; + +-typedef png_row_info FAR * png_row_infop; +-typedef png_row_info FAR * FAR * png_row_infopp; ++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 + * own. The png_error_ptr type should match that of user-supplied warning + * and error functions, while the png_rw_ptr type should match that of the +- * user read/write data functions. +- */ +-typedef struct png_struct_def png_struct; +-typedef png_struct FAR * png_structp; +- +-typedef void (PNGAPI *png_error_ptr) PNGARG((png_structp, png_const_charp)); +-typedef void (PNGAPI *png_rw_ptr) PNGARG((png_structp, png_bytep, png_size_t)); +-typedef void (PNGAPI *png_flush_ptr) PNGARG((png_structp)); +-typedef void (PNGAPI *png_read_status_ptr) PNGARG((png_structp, png_uint_32, +- int)); +-typedef void (PNGAPI *png_write_status_ptr) PNGARG((png_structp, png_uint_32, +- int)); ++ * user read/write data functions. Note that the 'write' function must not ++ * modify the buffer it is passed. The 'read' function, on the other hand, is ++ * expected to return the read data in the buffer. ++ */ ++typedef PNG_CALLBACK(void, *png_error_ptr, (png_structp, png_const_charp)); ++typedef PNG_CALLBACK(void, *png_rw_ptr, (png_structp, png_bytep, size_t)); ++typedef PNG_CALLBACK(void, *png_flush_ptr, (png_structp)); ++typedef PNG_CALLBACK(void, *png_read_status_ptr, (png_structp, png_uint_32, ++ int)); ++typedef PNG_CALLBACK(void, *png_write_status_ptr, (png_structp, png_uint_32, ++ int)); + + #ifdef PNG_PROGRESSIVE_READ_SUPPORTED +-typedef void (PNGAPI *png_progressive_info_ptr) PNGARG((png_structp, png_infop)); +-typedef void (PNGAPI *png_progressive_end_ptr) PNGARG((png_structp, png_infop)); +-typedef void (PNGAPI *png_progressive_row_ptr) PNGARG((png_structp, png_bytep, +- png_uint_32, int)); ++typedef PNG_CALLBACK(void, *png_progressive_info_ptr, (png_structp, png_infop)); ++typedef PNG_CALLBACK(void, *png_progressive_end_ptr, (png_structp, png_infop)); ++ ++/* The following callback receives png_uint_32 row_number, int pass for the ++ * png_bytep data of the row. When transforming an interlaced image the ++ * row number is the row number within the sub-image of the interlace pass, so ++ * the value will increase to the height of the sub-image (not the full image) ++ * then reset to 0 for the next pass. ++ * ++ * Use PNG_ROW_FROM_PASS_ROW(row, pass) and PNG_COL_FROM_PASS_COL(col, pass) to ++ * find the output pixel (x,y) given an interlaced sub-image pixel ++ * (row,col,pass). (See below for these macros.) ++ */ ++typedef PNG_CALLBACK(void, *png_progressive_row_ptr, (png_structp, png_bytep, ++ png_uint_32, int)); + #endif + + #if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \ +- defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) || \ +- defined(PNG_LEGACY_SUPPORTED) +-typedef void (PNGAPI *png_user_transform_ptr) PNGARG((png_structp, +- png_row_infop, png_bytep)); ++ defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) ++typedef PNG_CALLBACK(void, *png_user_transform_ptr, (png_structp, png_row_infop, ++ png_bytep)); + #endif + + #ifdef PNG_USER_CHUNKS_SUPPORTED +-typedef int (PNGAPI *png_user_chunk_ptr) PNGARG((png_structp, png_unknown_chunkp)); ++typedef PNG_CALLBACK(int, *png_user_chunk_ptr, (png_structp, ++ png_unknown_chunkp)); + #endif + #ifdef PNG_UNKNOWN_CHUNKS_SUPPORTED +-typedef void (PNGAPI *png_unknown_chunk_ptr) PNGARG((png_structp)); ++/* not used anywhere */ ++/* typedef PNG_CALLBACK(void, *png_unknown_chunk_ptr, (png_structp)); */ ++#endif ++ ++#ifdef PNG_SETJMP_SUPPORTED ++/* This must match the function definition in , and the application ++ * must include this before png.h to obtain the definition of jmp_buf. The ++ * function is required to be PNG_NORETURN, but this is not checked. If the ++ * function does return the application will crash via an abort() or similar ++ * system level call. ++ * ++ * If you get a warning here while building the library you may need to make ++ * changes to ensure that pnglibconf.h records the calling convention used by ++ * your compiler. This may be very difficult - try using a different compiler ++ * to build the library! ++ */ ++PNG_FUNCTION(void, (PNGCAPI *png_longjmp_ptr), PNGARG((jmp_buf, int)), typedef); + #endif + + /* Transform masks for the high-level interface */ +@@ -1211,690 +841,590 @@ typedef void (PNGAPI *png_unknown_chunk_ptr) PNGARG((png_structp)); + #define PNG_TRANSFORM_SWAP_ALPHA 0x0100 /* read and write */ + #define PNG_TRANSFORM_SWAP_ENDIAN 0x0200 /* read and write */ + #define PNG_TRANSFORM_INVERT_ALPHA 0x0400 /* read and write */ +-#define PNG_TRANSFORM_STRIP_FILLER 0x0800 /* write only, deprecated */ ++#define PNG_TRANSFORM_STRIP_FILLER 0x0800 /* write only */ + /* Added to libpng-1.2.34 */ +-#define PNG_TRANSFORM_STRIP_FILLER_BEFORE 0x0800 /* write only */ +-#define PNG_TRANSFORM_STRIP_FILLER_AFTER 0x1000 /* write only */ +-/* Added to libpng-1.2.41 */ ++#define PNG_TRANSFORM_STRIP_FILLER_BEFORE PNG_TRANSFORM_STRIP_FILLER ++#define PNG_TRANSFORM_STRIP_FILLER_AFTER 0x1000 /* write only */ ++/* Added to libpng-1.4.0 */ + #define PNG_TRANSFORM_GRAY_TO_RGB 0x2000 /* read only */ ++/* Added to libpng-1.5.4 */ ++#define PNG_TRANSFORM_EXPAND_16 0x4000 /* read only */ ++#if INT_MAX >= 0x8000 /* else this might break */ ++#define PNG_TRANSFORM_SCALE_16 0x8000 /* read only */ ++#endif + + /* Flags for MNG supported features */ + #define PNG_FLAG_MNG_EMPTY_PLTE 0x01 + #define PNG_FLAG_MNG_FILTER_64 0x04 + #define PNG_ALL_MNG_FEATURES 0x05 + +-typedef png_voidp (*png_malloc_ptr) PNGARG((png_structp, png_size_t)); +-typedef void (*png_free_ptr) PNGARG((png_structp, png_voidp)); +- +-/* The structure that holds the information to read and write PNG files. +- * The only people who need to care about what is inside of this are the +- * people who will be modifying the library for their own special needs. +- * It should NOT be accessed directly by an application, except to store +- * the jmp_buf. ++/* NOTE: prior to 1.5 these functions had no 'API' style declaration, ++ * this allowed the zlib default functions to be used on Windows ++ * platforms. In 1.5 the zlib default malloc (which just calls malloc and ++ * ignores the first argument) should be completely compatible with the ++ * following. + */ ++typedef PNG_CALLBACK(png_voidp, *png_malloc_ptr, (png_structp, ++ png_alloc_size_t)); ++typedef PNG_CALLBACK(void, *png_free_ptr, (png_structp, png_voidp)); + +-struct png_struct_def +-{ +-#ifdef PNG_SETJMP_SUPPORTED +- jmp_buf jmpbuf; /* used in png_error */ +-#endif +- png_error_ptr error_fn PNG_DEPSTRUCT; /* function for printing errors and aborting */ +- png_error_ptr warning_fn PNG_DEPSTRUCT; /* function for printing warnings */ +- png_voidp error_ptr PNG_DEPSTRUCT; /* user supplied struct for error functions */ +- png_rw_ptr write_data_fn PNG_DEPSTRUCT; /* function for writing output data */ +- png_rw_ptr read_data_fn PNG_DEPSTRUCT; /* function for reading input data */ +- png_voidp io_ptr PNG_DEPSTRUCT; /* ptr to application struct for I/O functions */ ++/* Section 4: 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 ++ * full explanation, see example.c for the summary. This just provides ++ * a simple one line description of the use of each function. ++ * ++ * The PNG_EXPORT() and PNG_EXPORTA() macros used below are defined in ++ * pngconf.h and in the *.dfn files in the scripts directory. ++ * ++ * PNG_EXPORT(ordinal, type, name, (args)); ++ * ++ * ordinal: ordinal that is used while building ++ * *.def files. The ordinal value is only ++ * relevant when preprocessing png.h with ++ * the *.dfn files for building symbol table ++ * entries, and are removed by pngconf.h. ++ * type: return type of the function ++ * name: function name ++ * args: function arguments, with types ++ * ++ * When we wish to append attributes to a function prototype we use ++ * the PNG_EXPORTA() macro instead. ++ * ++ * PNG_EXPORTA(ordinal, type, name, (args), attributes); ++ * ++ * ordinal, type, name, and args: same as in PNG_EXPORT(). ++ * attributes: function attributes ++ */ + +-#ifdef PNG_READ_USER_TRANSFORM_SUPPORTED +- png_user_transform_ptr read_user_transform_fn PNG_DEPSTRUCT; /* user read transform */ +-#endif ++/* Returns the version number of the library */ ++PNG_EXPORT(1, png_uint_32, png_access_version_number, (void)); + +-#ifdef PNG_WRITE_USER_TRANSFORM_SUPPORTED +- png_user_transform_ptr write_user_transform_fn PNG_DEPSTRUCT; /* user write transform */ +-#endif +- +-/* These were added in libpng-1.0.2 */ +-#ifdef PNG_USER_TRANSFORM_PTR_SUPPORTED +-#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \ +- defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) +- png_voidp user_transform_ptr PNG_DEPSTRUCT; /* user supplied struct for user transform */ +- png_byte user_transform_depth PNG_DEPSTRUCT; /* bit depth of user transformed pixels */ +- png_byte user_transform_channels PNG_DEPSTRUCT; /* channels in user transformed pixels */ +-#endif +-#endif +- +- png_uint_32 mode PNG_DEPSTRUCT; /* tells us where we are in the PNG file */ +- png_uint_32 flags PNG_DEPSTRUCT; /* flags indicating various things to libpng */ +- png_uint_32 transformations PNG_DEPSTRUCT; /* which transformations to perform */ +- +- z_stream zstream PNG_DEPSTRUCT; /* pointer to decompression structure (below) */ +- png_bytep zbuf PNG_DEPSTRUCT; /* buffer for zlib */ +- png_size_t zbuf_size PNG_DEPSTRUCT; /* size of zbuf */ +- int zlib_level PNG_DEPSTRUCT; /* holds zlib compression level */ +- int zlib_method PNG_DEPSTRUCT; /* holds zlib compression method */ +- int zlib_window_bits PNG_DEPSTRUCT; /* holds zlib compression window bits */ +- int zlib_mem_level PNG_DEPSTRUCT; /* holds zlib compression memory level */ +- int zlib_strategy PNG_DEPSTRUCT; /* holds zlib compression strategy */ +- +- png_uint_32 width PNG_DEPSTRUCT; /* width of image in pixels */ +- png_uint_32 height PNG_DEPSTRUCT; /* height of image in pixels */ +- png_uint_32 num_rows PNG_DEPSTRUCT; /* number of rows in current pass */ +- png_uint_32 usr_width PNG_DEPSTRUCT; /* width of row at start of write */ +- png_uint_32 rowbytes PNG_DEPSTRUCT; /* size of row in bytes */ +-#if 0 /* Replaced with the following in libpng-1.2.43 */ +- png_size_t irowbytes PNG_DEPSTRUCT; +-#endif +-/* Added in libpng-1.2.43 */ +-#ifdef PNG_USER_LIMITS_SUPPORTED +- /* Added in libpng-1.4.0: Total number of sPLT, text, and unknown +- * chunks that can be stored (0 means unlimited). +- */ +- png_uint_32 user_chunk_cache_max PNG_DEPSTRUCT; +-#endif +- png_uint_32 iwidth PNG_DEPSTRUCT; /* width of current interlaced row in pixels */ +- png_uint_32 row_number PNG_DEPSTRUCT; /* current row in interlace pass */ +- png_bytep prev_row PNG_DEPSTRUCT; /* buffer to save previous (unfiltered) row */ +- png_bytep row_buf PNG_DEPSTRUCT; /* buffer to save current (unfiltered) row */ +-#ifndef PNG_NO_WRITE_FILTER +- png_bytep sub_row PNG_DEPSTRUCT; /* buffer to save "sub" row when filtering */ +- png_bytep up_row PNG_DEPSTRUCT; /* buffer to save "up" row when filtering */ +- png_bytep avg_row PNG_DEPSTRUCT; /* buffer to save "avg" row when filtering */ +- png_bytep paeth_row PNG_DEPSTRUCT; /* buffer to save "Paeth" row when filtering */ +-#endif +- png_row_info row_info PNG_DEPSTRUCT; /* used for transformation routines */ +- +- png_uint_32 idat_size PNG_DEPSTRUCT; /* current IDAT size for read */ +- png_uint_32 crc PNG_DEPSTRUCT; /* current chunk CRC value */ +- png_colorp palette PNG_DEPSTRUCT; /* palette from the input file */ +- png_uint_16 num_palette PNG_DEPSTRUCT; /* number of color entries in palette */ +- png_uint_16 num_trans PNG_DEPSTRUCT; /* number of transparency values */ +- png_byte chunk_name[5] PNG_DEPSTRUCT; /* null-terminated name of current chunk */ +- png_byte compression PNG_DEPSTRUCT; /* file compression type (always 0) */ +- png_byte filter PNG_DEPSTRUCT; /* file filter type (always 0) */ +- png_byte interlaced PNG_DEPSTRUCT; /* PNG_INTERLACE_NONE, PNG_INTERLACE_ADAM7 */ +- png_byte pass PNG_DEPSTRUCT; /* current interlace pass (0 - 6) */ +- png_byte do_filter PNG_DEPSTRUCT; /* row filter flags (see PNG_FILTER_ below ) */ +- png_byte color_type PNG_DEPSTRUCT; /* color type of file */ +- png_byte bit_depth PNG_DEPSTRUCT; /* bit depth of file */ +- png_byte usr_bit_depth PNG_DEPSTRUCT; /* bit depth of users row */ +- png_byte pixel_depth PNG_DEPSTRUCT; /* number of bits per pixel */ +- png_byte channels PNG_DEPSTRUCT; /* number of channels in file */ +- png_byte usr_channels PNG_DEPSTRUCT; /* channels at start of write */ +- png_byte sig_bytes PNG_DEPSTRUCT; /* magic bytes read/written from start of file */ +- +-#if defined(PNG_READ_FILLER_SUPPORTED) || defined(PNG_WRITE_FILLER_SUPPORTED) +-#ifdef PNG_LEGACY_SUPPORTED +- png_byte filler PNG_DEPSTRUCT; /* filler byte for pixel expansion */ +-#else +- png_uint_16 filler PNG_DEPSTRUCT; /* filler bytes for pixel expansion */ +-#endif +-#endif +- +-#ifdef PNG_bKGD_SUPPORTED +- png_byte background_gamma_type PNG_DEPSTRUCT; +-# ifdef PNG_FLOATING_POINT_SUPPORTED +- float background_gamma PNG_DEPSTRUCT; +-# endif +- png_color_16 background PNG_DEPSTRUCT; /* background color in screen gamma space */ +-#ifdef PNG_READ_GAMMA_SUPPORTED +- png_color_16 background_1 PNG_DEPSTRUCT; /* background normalized to gamma 1.0 */ +-#endif +-#endif /* PNG_bKGD_SUPPORTED */ +- +-#ifdef PNG_WRITE_FLUSH_SUPPORTED +- png_flush_ptr output_flush_fn PNG_DEPSTRUCT; /* Function for flushing output */ +- png_uint_32 flush_dist PNG_DEPSTRUCT; /* how many rows apart to flush, 0 - no flush */ +- png_uint_32 flush_rows PNG_DEPSTRUCT; /* number of rows written since last flush */ +-#endif +- +-#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) +- int gamma_shift PNG_DEPSTRUCT; /* number of "insignificant" bits 16-bit gamma */ +-#ifdef PNG_FLOATING_POINT_SUPPORTED +- float gamma PNG_DEPSTRUCT; /* file gamma value */ +- float screen_gamma PNG_DEPSTRUCT; /* screen gamma value (display_exponent) */ +-#endif +-#endif +- +-#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) +- png_bytep gamma_table PNG_DEPSTRUCT; /* gamma table for 8-bit depth files */ +- png_bytep gamma_from_1 PNG_DEPSTRUCT; /* converts from 1.0 to screen */ +- png_bytep gamma_to_1 PNG_DEPSTRUCT; /* converts from file to 1.0 */ +- png_uint_16pp gamma_16_table PNG_DEPSTRUCT; /* gamma table for 16-bit depth files */ +- png_uint_16pp gamma_16_from_1 PNG_DEPSTRUCT; /* converts from 1.0 to screen */ +- png_uint_16pp gamma_16_to_1 PNG_DEPSTRUCT; /* converts from file to 1.0 */ +-#endif +- +-#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_sBIT_SUPPORTED) +- png_color_8 sig_bit PNG_DEPSTRUCT; /* significant bits in each available channel */ +-#endif +- +-#if defined(PNG_READ_SHIFT_SUPPORTED) || defined(PNG_WRITE_SHIFT_SUPPORTED) +- png_color_8 shift PNG_DEPSTRUCT; /* shift for significant bit tranformation */ +-#endif +- +-#if defined(PNG_tRNS_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) \ +- || defined(PNG_READ_EXPAND_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) +- png_bytep trans PNG_DEPSTRUCT; /* transparency values for paletted files */ +- png_color_16 trans_values PNG_DEPSTRUCT; /* transparency values for non-paletted files */ +-#endif +- +- png_read_status_ptr read_row_fn PNG_DEPSTRUCT; /* called after each row is decoded */ +- png_write_status_ptr write_row_fn PNG_DEPSTRUCT; /* called after each row is encoded */ +-#ifdef PNG_PROGRESSIVE_READ_SUPPORTED +- png_progressive_info_ptr info_fn PNG_DEPSTRUCT; /* called after header data fully read */ +- png_progressive_row_ptr row_fn PNG_DEPSTRUCT; /* called after each prog. row is decoded */ +- png_progressive_end_ptr end_fn PNG_DEPSTRUCT; /* called after image is complete */ +- png_bytep save_buffer_ptr PNG_DEPSTRUCT; /* current location in save_buffer */ +- png_bytep save_buffer PNG_DEPSTRUCT; /* buffer for previously read data */ +- png_bytep current_buffer_ptr PNG_DEPSTRUCT; /* current location in current_buffer */ +- png_bytep current_buffer PNG_DEPSTRUCT; /* buffer for recently used data */ +- png_uint_32 push_length PNG_DEPSTRUCT; /* size of current input chunk */ +- png_uint_32 skip_length PNG_DEPSTRUCT; /* bytes to skip in input data */ +- png_size_t save_buffer_size PNG_DEPSTRUCT; /* amount of data now in save_buffer */ +- png_size_t save_buffer_max PNG_DEPSTRUCT; /* total size of save_buffer */ +- png_size_t buffer_size PNG_DEPSTRUCT; /* total amount of available input data */ +- png_size_t current_buffer_size PNG_DEPSTRUCT; /* amount of data now in current_buffer */ +- int process_mode PNG_DEPSTRUCT; /* what push library is currently doing */ +- int cur_palette PNG_DEPSTRUCT; /* current push library palette index */ +- +-# ifdef PNG_TEXT_SUPPORTED +- png_size_t current_text_size PNG_DEPSTRUCT; /* current size of text input data */ +- png_size_t current_text_left PNG_DEPSTRUCT; /* how much text left to read in input */ +- png_charp current_text PNG_DEPSTRUCT; /* current text chunk buffer */ +- png_charp current_text_ptr PNG_DEPSTRUCT; /* current location in current_text */ +-# endif /* PNG_TEXT_SUPPORTED */ +-#endif /* PNG_PROGRESSIVE_READ_SUPPORTED */ +- +-#if defined(__TURBOC__) && !defined(_Windows) && !defined(__FLAT__) +-/* for the Borland special 64K segment handler */ +- png_bytepp offset_table_ptr PNG_DEPSTRUCT; +- png_bytep offset_table PNG_DEPSTRUCT; +- png_uint_16 offset_table_number PNG_DEPSTRUCT; +- png_uint_16 offset_table_count PNG_DEPSTRUCT; +- png_uint_16 offset_table_count_free PNG_DEPSTRUCT; +-#endif +- +-#ifdef PNG_READ_DITHER_SUPPORTED +- png_bytep palette_lookup PNG_DEPSTRUCT; /* lookup table for dithering */ +- png_bytep dither_index PNG_DEPSTRUCT; /* index translation for palette files */ +-#endif +- +-#if defined(PNG_READ_DITHER_SUPPORTED) || defined(PNG_hIST_SUPPORTED) +- png_uint_16p hist PNG_DEPSTRUCT; /* histogram */ +-#endif +- +-#ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED +- png_byte heuristic_method PNG_DEPSTRUCT; /* heuristic for row filter selection */ +- png_byte num_prev_filters PNG_DEPSTRUCT; /* number of weights for previous rows */ +- png_bytep prev_filters PNG_DEPSTRUCT; /* filter type(s) of previous row(s) */ +- png_uint_16p filter_weights PNG_DEPSTRUCT; /* weight(s) for previous line(s) */ +- png_uint_16p inv_filter_weights PNG_DEPSTRUCT; /* 1/weight(s) for previous line(s) */ +- png_uint_16p filter_costs PNG_DEPSTRUCT; /* relative filter calculation cost */ +- png_uint_16p inv_filter_costs PNG_DEPSTRUCT; /* 1/relative filter calculation cost */ +-#endif +- +-#ifdef PNG_TIME_RFC1123_SUPPORTED +- png_charp time_buffer PNG_DEPSTRUCT; /* String to hold RFC 1123 time text */ +-#endif +- +-/* New members added in libpng-1.0.6 */ +- +-#ifdef PNG_FREE_ME_SUPPORTED +- png_uint_32 free_me PNG_DEPSTRUCT; /* flags items libpng is responsible for freeing */ +-#endif +- +-#ifdef PNG_USER_CHUNKS_SUPPORTED +- png_voidp user_chunk_ptr PNG_DEPSTRUCT; +- png_user_chunk_ptr read_user_chunk_fn PNG_DEPSTRUCT; /* user read chunk handler */ +-#endif +- +-#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED +- int num_chunk_list PNG_DEPSTRUCT; +- png_bytep chunk_list PNG_DEPSTRUCT; +-#endif +- +-/* New members added in libpng-1.0.3 */ +-#ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED +- png_byte rgb_to_gray_status PNG_DEPSTRUCT; +- /* These were changed from png_byte in libpng-1.0.6 */ +- png_uint_16 rgb_to_gray_red_coeff PNG_DEPSTRUCT; +- png_uint_16 rgb_to_gray_green_coeff PNG_DEPSTRUCT; +- png_uint_16 rgb_to_gray_blue_coeff PNG_DEPSTRUCT; +-#endif +- +-/* New member added in libpng-1.0.4 (renamed in 1.0.9) */ +-#if defined(PNG_MNG_FEATURES_SUPPORTED) || \ +- defined(PNG_READ_EMPTY_PLTE_SUPPORTED) || \ +- defined(PNG_WRITE_EMPTY_PLTE_SUPPORTED) +-/* Changed from png_byte to png_uint_32 at version 1.2.0 */ +-#ifdef PNG_1_0_X +- png_byte mng_features_permitted PNG_DEPSTRUCT; +-#else +- png_uint_32 mng_features_permitted PNG_DEPSTRUCT; +-#endif /* PNG_1_0_X */ +-#endif +- +-/* New member added in libpng-1.0.7 */ +-#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) +- png_fixed_point int_gamma PNG_DEPSTRUCT; +-#endif +- +-/* New member added in libpng-1.0.9, ifdef'ed out in 1.0.12, enabled in 1.2.0 */ +-#ifdef PNG_MNG_FEATURES_SUPPORTED +- png_byte filter_type PNG_DEPSTRUCT; +-#endif +- +-#ifdef PNG_1_0_X +-/* New member added in libpng-1.0.10, ifdef'ed out in 1.2.0 */ +- png_uint_32 row_buf_size PNG_DEPSTRUCT; +-#endif +- +-/* New members added in libpng-1.2.0 */ +-#ifdef PNG_ASSEMBLER_CODE_SUPPORTED +-# ifndef PNG_1_0_X +-# ifdef PNG_MMX_CODE_SUPPORTED +- png_byte mmx_bitdepth_threshold PNG_DEPSTRUCT; +- png_uint_32 mmx_rowbytes_threshold PNG_DEPSTRUCT; +-# endif +- png_uint_32 asm_flags PNG_DEPSTRUCT; +-# endif +-#endif +- +-/* New members added in libpng-1.0.2 but first enabled by default in 1.2.0 */ +-#ifdef PNG_USER_MEM_SUPPORTED +- png_voidp mem_ptr PNG_DEPSTRUCT; /* user supplied struct for mem functions */ +- png_malloc_ptr malloc_fn PNG_DEPSTRUCT; /* function for allocating memory */ +- png_free_ptr free_fn PNG_DEPSTRUCT; /* function for freeing memory */ +-#endif +- +-/* New member added in libpng-1.0.13 and 1.2.0 */ +- png_bytep big_row_buf PNG_DEPSTRUCT; /* buffer to save current (unfiltered) row */ +- +-#ifdef PNG_READ_DITHER_SUPPORTED +-/* The following three members were added at version 1.0.14 and 1.2.4 */ +- png_bytep dither_sort PNG_DEPSTRUCT; /* working sort array */ +- png_bytep index_to_palette PNG_DEPSTRUCT; /* where the original index currently is */ +- /* in the palette */ +- png_bytep palette_to_index PNG_DEPSTRUCT; /* which original index points to this */ +- /* palette color */ +-#endif +- +-/* New members added in libpng-1.0.16 and 1.2.6 */ +- png_byte compression_type PNG_DEPSTRUCT; +- +-#ifdef PNG_USER_LIMITS_SUPPORTED +- png_uint_32 user_width_max PNG_DEPSTRUCT; +- png_uint_32 user_height_max PNG_DEPSTRUCT; +-#endif +- +-/* New member added in libpng-1.0.25 and 1.2.17 */ +-#ifdef PNG_UNKNOWN_CHUNKS_SUPPORTED +- /* Storage for unknown chunk that the library doesn't recognize. */ +- png_unknown_chunk unknown_chunk PNG_DEPSTRUCT; +-#endif +- +-/* New members added in libpng-1.2.26 */ +- png_uint_32 old_big_row_buf_size PNG_DEPSTRUCT; +- png_uint_32 old_prev_row_size PNG_DEPSTRUCT; +- +-/* New member added in libpng-1.2.30 */ +- png_charp chunkdata PNG_DEPSTRUCT; /* buffer for reading chunk data */ +- +- +-}; +- +- +-/* This triggers a compiler error in png.c, if png.c and png.h +- * do not agree upon the version number. +- */ +-typedef png_structp version_1_2_44; +- +-typedef png_struct FAR * FAR * png_structpp; +- +-/* Here are the function definitions most commonly used. This is not +- * the place to find out how to use libpng. See libpng.txt for the +- * full explanation, see example.c for the summary. This just provides +- * a simple one line description of the use of each function. +- */ +- +-/* Returns the version number of the library */ +-extern PNG_EXPORT(png_uint_32,png_access_version_number) PNGARG((void)); +- +-/* Tell lib we have already handled the first magic bytes. +- * Handling more than 8 bytes from the beginning of the file is an error. +- */ +-extern PNG_EXPORT(void,png_set_sig_bytes) PNGARG((png_structp png_ptr, +- int num_bytes)); ++/* Tell lib we have already handled the first 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_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 + * signature, and non-zero otherwise. Having num_to_check == 0 or + * start > 7 will always fail (ie return non-zero). + */ +-extern PNG_EXPORT(int,png_sig_cmp) PNGARG((png_bytep sig, png_size_t start, +- png_size_t num_to_check)); ++PNG_EXPORT(3, int, png_sig_cmp, (png_const_bytep sig, size_t start, ++ size_t num_to_check)); + + /* Simple signature checking function. This is the same as calling + * png_check_sig(sig, n) := !png_sig_cmp(sig, 0, n). + */ +-extern PNG_EXPORT(int,png_check_sig) PNGARG((png_bytep sig, int num)) PNG_DEPRECATED; ++#define png_check_sig(sig, n) !png_sig_cmp((sig), 0, (n)) + + /* Allocate and initialize png_ptr struct for reading, and any other memory. */ +-extern PNG_EXPORT(png_structp,png_create_read_struct) +- PNGARG((png_const_charp user_png_ver, png_voidp error_ptr, +- png_error_ptr error_fn, png_error_ptr warn_fn)) PNG_ALLOCATED; ++PNG_EXPORTA(4, png_structp, 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); + + /* Allocate and initialize png_ptr struct for writing, and any other memory */ +-extern PNG_EXPORT(png_structp,png_create_write_struct) +- PNGARG((png_const_charp user_png_ver, png_voidp error_ptr, +- png_error_ptr error_fn, png_error_ptr warn_fn)) PNG_ALLOCATED; ++PNG_EXPORTA(5, png_structp, 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_WRITE_SUPPORTED +-extern PNG_EXPORT(png_uint_32,png_get_compression_buffer_size) +- PNGARG((png_structp png_ptr)); +-#endif ++PNG_EXPORT(6, size_t, png_get_compression_buffer_size, ++ (png_const_structrp png_ptr)); + +-#ifdef PNG_WRITE_SUPPORTED +-extern PNG_EXPORT(void,png_set_compression_buffer_size) +- PNGARG((png_structp png_ptr, png_uint_32 size)); ++PNG_EXPORT(7, void, png_set_compression_buffer_size, (png_structrp png_ptr, ++ size_t size)); ++ ++/* Moved from pngconf.h in 1.4.0 and modified to ensure setjmp/longjmp ++ * match up. ++ */ ++#ifdef PNG_SETJMP_SUPPORTED ++/* This function returns the jmp_buf built in to *png_ptr. It must be ++ * supplied with an appropriate 'longjmp' function to use on that jmp_buf ++ * unless the default error function is overridden in which case NULL is ++ * acceptable. The size of the jmp_buf is checked against the actual size ++ * allocated by the library - the call will return NULL on a mismatch ++ * indicating an ABI mismatch. ++ */ ++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)))) ++#else ++# define png_jmpbuf(png_ptr) \ ++ (LIBPNG_WAS_COMPILED_WITH__PNG_NO_SETJMP) + #endif ++/* This function should be used by libpng applications in place of ++ * longjmp(png_ptr->jmpbuf, val). If longjmp_fn() has been set, it ++ * 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_const_structrp png_ptr, int val), ++ PNG_NORETURN); + ++#ifdef PNG_READ_SUPPORTED + /* Reset the compression stream */ +-extern PNG_EXPORT(int,png_reset_zstream) PNGARG((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) */ + #ifdef PNG_USER_MEM_SUPPORTED +-extern PNG_EXPORT(png_structp,png_create_read_struct_2) +- PNGARG((png_const_charp user_png_ver, png_voidp error_ptr, +- png_error_ptr error_fn, png_error_ptr warn_fn, png_voidp mem_ptr, +- png_malloc_ptr malloc_fn, png_free_ptr free_fn)) PNG_ALLOCATED; +-extern PNG_EXPORT(png_structp,png_create_write_struct_2) +- PNGARG((png_const_charp user_png_ver, png_voidp error_ptr, +- png_error_ptr error_fn, png_error_ptr warn_fn, png_voidp mem_ptr, +- png_malloc_ptr malloc_fn, png_free_ptr free_fn)) PNG_ALLOCATED; ++PNG_EXPORTA(11, png_structp, png_create_read_struct_2, ++ (png_const_charp user_png_ver, png_voidp error_ptr, png_error_ptr error_fn, ++ png_error_ptr warn_fn, ++ png_voidp mem_ptr, png_malloc_ptr malloc_fn, png_free_ptr free_fn), ++ PNG_ALLOCATED); ++PNG_EXPORTA(12, png_structp, 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 + ++/* Write the PNG file signature. */ ++PNG_EXPORT(13, void, png_write_sig, (png_structrp png_ptr)); ++ + /* Write a PNG chunk - size, type, (optional) data, CRC. */ +-extern PNG_EXPORT(void,png_write_chunk) PNGARG((png_structp png_ptr, +- png_bytep chunk_name, png_bytep data, png_size_t length)); ++PNG_EXPORT(14, void, png_write_chunk, (png_structrp png_ptr, png_const_bytep ++ chunk_name, png_const_bytep data, size_t length)); + + /* Write the start of a PNG chunk - length and chunk name. */ +-extern PNG_EXPORT(void,png_write_chunk_start) PNGARG((png_structp png_ptr, +- png_bytep chunk_name, png_uint_32 length)); ++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(). */ +-extern PNG_EXPORT(void,png_write_chunk_data) PNGARG((png_structp png_ptr, +- png_bytep data, png_size_t length)); ++PNG_EXPORT(16, void, png_write_chunk_data, (png_structrp png_ptr, ++ png_const_bytep data, size_t length)); + + /* Finish a chunk started with png_write_chunk_start() (includes CRC). */ +-extern PNG_EXPORT(void,png_write_chunk_end) PNGARG((png_structp png_ptr)); ++PNG_EXPORT(17, void, png_write_chunk_end, (png_structrp png_ptr)); + + /* Allocate and initialize the info structure */ +-extern PNG_EXPORT(png_infop,png_create_info_struct) +- PNGARG((png_structp png_ptr)) PNG_ALLOCATED; +- +-#if defined(PNG_1_0_X) || defined (PNG_1_2_X) +-/* Initialize the info structure (old interface - DEPRECATED) */ +-extern PNG_EXPORT(void,png_info_init) PNGARG((png_infop info_ptr)) +- PNG_DEPRECATED; +-#undef png_info_init +-#define png_info_init(info_ptr) png_info_init_3(&info_ptr,\ +- png_sizeof(png_info)); +-#endif ++PNG_EXPORTA(18, png_infop, png_create_info_struct, (png_const_structrp png_ptr), ++ PNG_ALLOCATED); + +-extern PNG_EXPORT(void,png_info_init_3) PNGARG((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, ++ size_t png_info_struct_size), PNG_DEPRECATED); + + /* Writes all the PNG information before the image. */ +-extern PNG_EXPORT(void,png_write_info_before_PLTE) PNGARG((png_structp png_ptr, +- png_infop info_ptr)); +-extern PNG_EXPORT(void,png_write_info) PNGARG((png_structp png_ptr, +- png_infop info_ptr)); ++PNG_EXPORT(20, void, png_write_info_before_PLTE, ++ (png_structrp png_ptr, png_const_inforp info_ptr)); ++PNG_EXPORT(21, void, png_write_info, ++ (png_structrp png_ptr, png_const_inforp info_ptr)); + + #ifdef PNG_SEQUENTIAL_READ_SUPPORTED + /* Read the information before the actual image data. */ +-extern PNG_EXPORT(void,png_read_info) PNGARG((png_structp png_ptr, +- png_infop info_ptr)); ++PNG_EXPORT(22, void, png_read_info, ++ (png_structrp png_ptr, png_inforp info_ptr)); + #endif + + #ifdef PNG_TIME_RFC1123_SUPPORTED +-extern PNG_EXPORT(png_charp,png_convert_to_rfc1123) +- PNGARG((png_structp png_ptr, png_timep ptime)); ++ /* 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 */ +-extern PNG_EXPORT(void,png_convert_from_struct_tm) PNGARG((png_timep ptime, +- struct tm FAR * ttime)); ++PNG_EXPORT(24, void, png_convert_from_struct_tm, (png_timep ptime, ++ const struct tm * ttime)); + + /* Convert from time_t to png_time. Uses gmtime() */ +-extern PNG_EXPORT(void,png_convert_from_time_t) PNGARG((png_timep ptime, +- time_t ttime)); +-#endif /* PNG_CONVERT_tIME_SUPPORTED */ ++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. */ +-extern PNG_EXPORT(void,png_set_expand) PNGARG((png_structp png_ptr)); +-#ifndef PNG_1_0_X +-extern PNG_EXPORT(void,png_set_expand_gray_1_2_4_to_8) PNGARG((png_structp +- png_ptr)); +-#endif +-extern PNG_EXPORT(void,png_set_palette_to_rgb) PNGARG((png_structp png_ptr)); +-extern PNG_EXPORT(void,png_set_tRNS_to_alpha) PNGARG((png_structp png_ptr)); +-#if defined(PNG_1_0_X) || defined (PNG_1_2_X) +-/* Deprecated */ +-extern PNG_EXPORT(void,png_set_gray_1_2_4_to_8) PNGARG((png_structp +- png_ptr)) PNG_DEPRECATED; ++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_structrp png_ptr)); + #endif + + #if defined(PNG_READ_BGR_SUPPORTED) || defined(PNG_WRITE_BGR_SUPPORTED) + /* Use blue, green, red order for pixels. */ +-extern PNG_EXPORT(void,png_set_bgr) PNGARG((png_structp png_ptr)); ++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. */ +-extern PNG_EXPORT(void,png_set_gray_to_rgb) PNGARG((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. */ +-#ifdef PNG_FLOATING_POINT_SUPPORTED +-extern PNG_EXPORT(void,png_set_rgb_to_gray) PNGARG((png_structp png_ptr, +- int error_action, double red, double green )); ++#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 +-extern PNG_EXPORT(void,png_set_rgb_to_gray_fixed) PNGARG((png_structp png_ptr, +- int error_action, png_fixed_point red, png_fixed_point green )); +-extern PNG_EXPORT(png_byte,png_get_rgb_to_gray_status) PNGARG((png_structp +- png_ptr)); ++ ++#ifdef PNG_BUILD_GRAYSCALE_PALETTE_SUPPORTED ++PNG_EXPORT(35, void, png_build_grayscale_palette, (int bit_depth, ++ png_colorp palette)); + #endif + +-extern PNG_EXPORT(void,png_build_grayscale_palette) PNGARG((int bit_depth, +- png_colorp palette)); ++#ifdef PNG_READ_ALPHA_MODE_SUPPORTED ++/* 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 ++ * with the alpha samples. ++ * ++ * 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, 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 re-encode ++ * 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. ++ * image. These are the 'STANDARD', 'ASSOCIATED' or 'PREMULTIPLIED' modes ++ * (the latter being the two common names for associated alpha color channels). ++ * ++ * 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 ++ * correctly undoes the encoding before handling alpha composition. Use this ++ * choice only if other serious errors in the software or hardware you use ++ * mandate it; the typical serious error is for dark halos to appear around ++ * opaque areas of the composited PNG image because of arithmetic overflow. ++ * ++ * The API function png_set_alpha_mode specifies which of these choices to use ++ * with an enumerated 'mode' value and the gamma of the required output: ++ */ ++#define PNG_ALPHA_PNG 0 /* according to the PNG standard */ ++#define PNG_ALPHA_STANDARD 1 /* according to Porter/Duff */ ++#define PNG_ALPHA_ASSOCIATED 1 /* as above; this is the normal practice */ ++#define PNG_ALPHA_PREMULTIPLIED 1 /* as above */ ++#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_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_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. ++ */ ++#define PNG_DEFAULT_sRGB -1 /* sRGB gamma and color space */ ++#define PNG_GAMMA_MAC_18 -2 /* Old Mac '1.8' gamma and color space */ ++#define PNG_GAMMA_sRGB 220000 /* Television standards--matches sRGB gamma */ ++#define PNG_GAMMA_LINEAR PNG_FP_1 /* Linear */ ++#endif ++ ++/* The following are examples of calls to png_set_alpha_mode to achieve the ++ * required overall gamma correction and, where necessary, alpha ++ * premultiplication. ++ * ++ * png_set_alpha_mode(pp, PNG_ALPHA_PNG, PNG_DEFAULT_sRGB); ++ * This is the default libpng handling of the alpha channel - it is not ++ * pre-multiplied into the color components. In addition the call states ++ * that the output is for a sRGB system and causes all PNG files without gAMA ++ * chunks to be assumed to be encoded using sRGB. ++ * ++ * png_set_alpha_mode(pp, PNG_ALPHA_PNG, PNG_GAMMA_MAC); ++ * In this case the output is assumed to be something like an sRGB conformant ++ * display preceded by a power-law lookup table of power 1.45. This is how ++ * early Mac systems behaved. ++ * ++ * png_set_alpha_mode(pp, PNG_ALPHA_STANDARD, PNG_GAMMA_LINEAR); ++ * This is the classic Jim Blinn approach and will work in academic ++ * environments where everything is done by the book. It has the shortcoming ++ * of assuming that input PNG data with no gamma information is linear - this ++ * is unlikely to be correct unless the PNG files where generated locally. ++ * Most of the time the output precision will be so low as to show ++ * significant banding in dark areas of the image. ++ * ++ * png_set_expand_16(pp); ++ * png_set_alpha_mode(pp, PNG_ALPHA_STANDARD, PNG_DEFAULT_sRGB); ++ * This is a somewhat more realistic Jim Blinn inspired approach. PNG files ++ * are assumed to have the sRGB encoding if not marked with a gamma value and ++ * the output is always 16 bits per component. This permits accurate scaling ++ * and processing of the data. If you know that your input PNG files were ++ * generated locally you might need to replace PNG_DEFAULT_sRGB with the ++ * correct value for your system. ++ * ++ * png_set_alpha_mode(pp, PNG_ALPHA_OPTIMIZED, PNG_DEFAULT_sRGB); ++ * If you just need to composite the PNG image onto an existing background ++ * and if you control the code that does this you can use the optimization ++ * setting. In this case you just copy completely opaque pixels to the ++ * output. For pixels that are not completely transparent (you just skip ++ * those) you do the composition math using png_composite or png_composite_16 ++ * below then encode the resultant 8-bit or 16-bit values to match the output ++ * encoding. ++ * ++ * Other cases ++ * If neither the PNG nor the standard linear encoding work for you because ++ * of the software or hardware you use then you have a big problem. The PNG ++ * case will probably result in halos around the image. The linear encoding ++ * will probably result in a washed out, too bright, image (it's actually too ++ * contrasty.) Try the ALPHA_OPTIMIZED mode above - this will probably ++ * substantially reduce the halos. Alternatively try: ++ * ++ * png_set_alpha_mode(pp, PNG_ALPHA_BROKEN, PNG_DEFAULT_sRGB); ++ * This option will also reduce the halos, but there will be slight dark ++ * halos round the opaque parts of the image where the background is light. ++ * In the OPTIMIZED mode the halos will be light halos where the background ++ * is dark. Take your pick - the halos are unavoidable unless you can get ++ * your hardware/software fixed! (The OPTIMIZED approach is slightly ++ * faster.) ++ * ++ * 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 ++ * 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 ++ * default if it is not already set: ++ * ++ * png_set_alpha_mode(pp, PNG_ALPHA_PNG, PNG_DEFAULT_sRGB); ++ * png_set_alpha_mode(pp, PNG_ALPHA_PNG, PNG_GAMMA_MAC); ++ * The first call sets both the default and the output gamma values, the ++ * second call overrides the output gamma without changing the default. This ++ * is easier than achieving the same effect with png_set_gamma. You must use ++ * PNG_ALPHA_PNG for the first call - internal checking in png_set_alpha will ++ * fire if more than one call to png_set_alpha_mode and png_set_background is ++ * made in the same read operation, however multiple calls with PNG_ALPHA_PNG ++ * are ignored. ++ */ + + #ifdef PNG_READ_STRIP_ALPHA_SUPPORTED +-extern PNG_EXPORT(void,png_set_strip_alpha) PNGARG((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) +-extern PNG_EXPORT(void,png_set_swap_alpha) PNGARG((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) +-extern PNG_EXPORT(void,png_set_invert_alpha) PNGARG((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. */ +-extern PNG_EXPORT(void,png_set_filler) PNGARG((png_structp png_ptr, +- png_uint_32 filler, int flags)); ++/* Add a filler byte to 8-bit or 16-bit Gray or 24-bit or 48-bit RGB images. */ ++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. */ +-#ifndef PNG_1_0_X +-extern PNG_EXPORT(void,png_set_add_alpha) PNGARG((png_structp png_ptr, +- png_uint_32 filler, int flags)); +-#endif +-#endif /* PNG_READ_FILLER_SUPPORTED || PNG_WRITE_FILLER_SUPPORTED */ ++# define PNG_FILLER_BEFORE 0 ++# define PNG_FILLER_AFTER 1 ++/* Add an alpha byte to 8-bit or 16-bit Gray or 24-bit or 48-bit RGB images. */ ++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. */ +-extern PNG_EXPORT(void,png_set_swap) PNGARG((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. */ +-extern PNG_EXPORT(void,png_set_packing) PNGARG((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) ++#if defined(PNG_READ_PACKSWAP_SUPPORTED) || \ ++ defined(PNG_WRITE_PACKSWAP_SUPPORTED) + /* Swap packing order of pixels in bytes. */ +-extern PNG_EXPORT(void,png_set_packswap) PNGARG((png_structp png_ptr)); ++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. */ +-extern PNG_EXPORT(void,png_set_shift) PNGARG((png_structp png_ptr, +- png_color_8p true_bits)); ++PNG_EXPORT(44, void, png_set_shift, (png_structrp png_ptr, png_const_color_8p ++ true_bits)); + #endif + + #if defined(PNG_READ_INTERLACING_SUPPORTED) || \ + defined(PNG_WRITE_INTERLACING_SUPPORTED) +-/* Have the code handle the interlacing. Returns the number of passes. */ +-extern PNG_EXPORT(int,png_set_interlace_handling) PNGARG((png_structp png_ptr)); ++/* Have the code handle the interlacing. Returns the number of passes. ++ * MUST be called before png_read_update_info or png_start_read_image, ++ * otherwise it will not have the desired effect. Note that it is still ++ * 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_structrp png_ptr)); + #endif + + #if defined(PNG_READ_INVERT_SUPPORTED) || defined(PNG_WRITE_INVERT_SUPPORTED) + /* Invert monochrome files */ +-extern PNG_EXPORT(void,png_set_invert_mono) PNGARG((png_structp png_ptr)); ++PNG_EXPORT(46, void, png_set_invert_mono, (png_structrp png_ptr)); + #endif + + #ifdef PNG_READ_BACKGROUND_SUPPORTED +-/* Handle alpha and tRNS by replacing with a background color. */ +-#ifdef PNG_FLOATING_POINT_SUPPORTED +-extern PNG_EXPORT(void,png_set_background) PNGARG((png_structp png_ptr, +- png_color_16p background_color, int background_gamma_code, +- int need_expand, double background_gamma)); ++/* Handle alpha and tRNS by replacing with a background color. Prior to ++ * libpng-1.5.4 this API must not be called before the PNG file header has been ++ * 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_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_structrp png_ptr, ++ png_const_color_16p background_color, int background_gamma_code, ++ int need_expand, png_fixed_point background_gamma)) ++#endif ++#ifdef PNG_READ_BACKGROUND_SUPPORTED ++# define PNG_BACKGROUND_GAMMA_UNKNOWN 0 ++# define PNG_BACKGROUND_GAMMA_SCREEN 1 ++# define PNG_BACKGROUND_GAMMA_FILE 2 ++# define PNG_BACKGROUND_GAMMA_UNIQUE 3 + #endif +-#define PNG_BACKGROUND_GAMMA_UNKNOWN 0 +-#define PNG_BACKGROUND_GAMMA_SCREEN 1 +-#define PNG_BACKGROUND_GAMMA_FILE 2 +-#define PNG_BACKGROUND_GAMMA_UNIQUE 3 ++ ++#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_structrp png_ptr)); + #endif + +-#ifdef PNG_READ_16_TO_8_SUPPORTED ++#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. */ +-extern PNG_EXPORT(void,png_set_strip_16) PNGARG((png_structp png_ptr)); ++PNG_EXPORT(48, void, png_set_strip_16, (png_structrp png_ptr)); + #endif + +-#ifdef PNG_READ_DITHER_SUPPORTED +-/* Turn on dithering, and reduce the palette to the number of colors available. */ +-extern PNG_EXPORT(void,png_set_dither) PNGARG((png_structp png_ptr, +- png_colorp palette, int num_palette, int maximum_colors, +- png_uint_16p histogram, int full_dither)); ++#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_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 +-/* Handle gamma correction. Screen_gamma=(display_exponent) */ +-#ifdef PNG_FLOATING_POINT_SUPPORTED +-extern PNG_EXPORT(void,png_set_gamma) PNGARG((png_structp png_ptr, +- double screen_gamma, double default_file_gamma)); +-#endif +-#endif ++/* The threshold on gamma processing is configurable but hard-wired into the ++ * library. The following is the floating point variant. ++ */ ++#define PNG_GAMMA_THRESHOLD (PNG_GAMMA_THRESHOLD_FIXED*.00001) + +-#if defined(PNG_1_0_X) || defined (PNG_1_2_X) +-#if defined(PNG_READ_EMPTY_PLTE_SUPPORTED) || \ +- defined(PNG_WRITE_EMPTY_PLTE_SUPPORTED) +-/* Permit or disallow empty PLTE (0: not permitted, 1: permitted) */ +-/* Deprecated and will be removed. Use png_permit_mng_features() instead. */ +-extern PNG_EXPORT(void,png_permit_empty_plte) PNGARG((png_structp png_ptr, +- int empty_plte_permitted)) PNG_DEPRECATED; +-#endif ++/* Handle gamma correction. Screen_gamma=(display_exponent). ++ * NOTE: this API simply sets the screen and file gamma values. It will ++ * therefore override the value for gamma in a PNG file if it is called after ++ * the file header has been read - use with care - call before reading the PNG ++ * file for best results! ++ * ++ * These routines accept the same gamma values as png_set_alpha_mode (described ++ * above). The PNG_GAMMA_ defines and PNG_DEFAULT_sRGB can be passed to either ++ * 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_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 */ +-extern PNG_EXPORT(void,png_set_flush) PNGARG((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 */ +-extern PNG_EXPORT(void,png_write_flush) PNGARG((png_structp png_ptr)); ++PNG_EXPORT(52, void, png_write_flush, (png_structrp png_ptr)); + #endif + + /* Optional update palette with requested transformations */ +-extern PNG_EXPORT(void,png_start_read_image) PNGARG((png_structp png_ptr)); ++PNG_EXPORT(53, void, png_start_read_image, (png_structrp png_ptr)); + + /* Optional call to update the users info structure */ +-extern PNG_EXPORT(void,png_read_update_info) PNGARG((png_structp png_ptr, +- png_infop info_ptr)); ++PNG_EXPORT(54, void, png_read_update_info, (png_structrp png_ptr, ++ png_inforp info_ptr)); + +-#ifndef PNG_NO_SEQUENTIAL_READ_SUPPORTED ++#ifdef PNG_SEQUENTIAL_READ_SUPPORTED + /* Read one or more rows of image data. */ +-extern PNG_EXPORT(void,png_read_rows) PNGARG((png_structp png_ptr, +- png_bytepp row, png_bytepp display_row, png_uint_32 num_rows)); ++PNG_EXPORT(55, void, png_read_rows, (png_structrp png_ptr, png_bytepp row, ++ png_bytepp display_row, png_uint_32 num_rows)); + #endif + +-#ifndef PNG_NO_SEQUENTIAL_READ_SUPPORTED ++#ifdef PNG_SEQUENTIAL_READ_SUPPORTED + /* Read a row of data. */ +-extern PNG_EXPORT(void,png_read_row) PNGARG((png_structp png_ptr, +- png_bytep row, +- png_bytep display_row)); ++PNG_EXPORT(56, void, png_read_row, (png_structrp png_ptr, png_bytep row, ++ png_bytep display_row)); + #endif + +-#ifndef PNG_NO_SEQUENTIAL_READ_SUPPORTED ++#ifdef PNG_SEQUENTIAL_READ_SUPPORTED + /* Read the whole image into memory at once. */ +-extern PNG_EXPORT(void,png_read_image) PNGARG((png_structp png_ptr, +- png_bytepp image)); ++PNG_EXPORT(57, void, png_read_image, (png_structrp png_ptr, png_bytepp image)); + #endif + + /* Write a row of image data */ +-extern PNG_EXPORT(void,png_write_row) PNGARG((png_structp png_ptr, +- png_bytep row)); ++PNG_EXPORT(58, void, png_write_row, (png_structrp png_ptr, ++ png_const_bytep row)); + +-/* Write a few rows of image data */ +-extern PNG_EXPORT(void,png_write_rows) PNGARG((png_structp png_ptr, +- png_bytepp row, png_uint_32 num_rows)); ++/* Write 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_structrp png_ptr, png_bytepp row, ++ png_uint_32 num_rows)); + + /* Write the image data */ +-extern PNG_EXPORT(void,png_write_image) PNGARG((png_structp png_ptr, +- png_bytepp image)); ++PNG_EXPORT(60, void, png_write_image, (png_structrp png_ptr, png_bytepp image)); + +-/* Writes the end of the PNG file. */ +-extern PNG_EXPORT(void,png_write_end) PNGARG((png_structp png_ptr, +- png_infop info_ptr)); ++/* Write the end of the PNG file. */ ++PNG_EXPORT(61, void, png_write_end, (png_structrp png_ptr, ++ png_inforp info_ptr)); + +-#ifndef PNG_NO_SEQUENTIAL_READ_SUPPORTED ++#ifdef PNG_SEQUENTIAL_READ_SUPPORTED + /* Read the end of the PNG file. */ +-extern PNG_EXPORT(void,png_read_end) PNGARG((png_structp png_ptr, +- png_infop info_ptr)); ++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 */ +-extern PNG_EXPORT(void,png_destroy_info_struct) PNGARG((png_structp png_ptr, +- png_infopp info_ptr_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 */ +-extern PNG_EXPORT(void,png_destroy_read_struct) PNGARG((png_structpp +- png_ptr_ptr, png_infopp info_ptr_ptr, png_infopp end_info_ptr_ptr)); +- +-/* Free all memory used by the read (old method - NOT DLL EXPORTED) */ +-extern void png_read_destroy PNGARG((png_structp png_ptr, png_infop info_ptr, +- png_infop end_info_ptr)) PNG_DEPRECATED; ++PNG_EXPORT(64, void, png_destroy_read_struct, (png_structpp png_ptr_ptr, ++ png_infopp info_ptr_ptr, png_infopp end_info_ptr_ptr)); + + /* Free any memory associated with the png_struct and the png_info_structs */ +-extern PNG_EXPORT(void,png_destroy_write_struct) +- PNGARG((png_structpp png_ptr_ptr, png_infopp info_ptr_ptr)); +- +-/* Free any memory used in png_ptr struct (old method - NOT DLL EXPORTED) */ +-extern void png_write_destroy PNGARG((png_structp png_ptr)) PNG_DEPRECATED; ++PNG_EXPORT(65, void, png_destroy_write_struct, (png_structpp png_ptr_ptr, ++ png_infopp info_ptr_ptr)); + + /* Set the libpng method of handling chunk CRC errors */ +-extern PNG_EXPORT(void,png_set_crc_action) PNGARG((png_structp png_ptr, +- int crit_action, int ancil_action)); ++PNG_EXPORT(66, void, png_set_crc_action, (png_structrp png_ptr, int crit_action, ++ int ancil_action)); + +-/* Values for png_set_crc_action() to say how to handle CRC errors in ++/* Values for png_set_crc_action() say how to handle CRC errors in + * ancillary and critical chunks, and whether to use the data contained + * therein. Note that it is impossible to "discard" data in a critical + * chunk. For versions prior to 0.90, the action was always error/quit, +@@ -1910,6 +1440,7 @@ extern PNG_EXPORT(void,png_set_crc_action) PNGARG((png_structp png_ptr, + #define PNG_CRC_QUIET_USE 4 /* quiet/use data quiet/use data */ + #define PNG_CRC_NO_CHANGE 5 /* use current value use current value */ + ++#ifdef PNG_WRITE_SUPPORTED + /* These functions give the user control over the scan-line filtering in + * libpng and the compression methods used by zlib. These functions are + * mainly useful for testing, as the defaults should work with most users. +@@ -1921,8 +1452,9 @@ extern PNG_EXPORT(void,png_set_crc_action) PNGARG((png_structp png_ptr, + /* Set the filtering method(s) used by libpng. Currently, the only valid + * value for "method" is 0. + */ +-extern PNG_EXPORT(void,png_set_filter) PNGARG((png_structp png_ptr, int method, +- int filters)); ++PNG_EXPORT(67, void, png_set_filter, (png_structrp png_ptr, int method, ++ int filters)); ++#endif /* WRITE */ + + /* 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 +@@ -1935,8 +1467,8 @@ extern PNG_EXPORT(void,png_set_filter) PNGARG((png_structp png_ptr, int method, + #define PNG_FILTER_UP 0x20 + #define PNG_FILTER_AVG 0x40 + #define PNG_FILTER_PAETH 0x80 +-#define PNG_ALL_FILTERS (PNG_FILTER_NONE | PNG_FILTER_SUB | PNG_FILTER_UP | \ +- PNG_FILTER_AVG | PNG_FILTER_PAETH) ++#define PNG_FAST_FILTERS (PNG_FILTER_NONE | PNG_FILTER_SUB | PNG_FILTER_UP) ++#define PNG_ALL_FILTERS (PNG_FAST_FILTERS | PNG_FILTER_AVG | PNG_FILTER_PAETH) + + /* Filter values (not flags) - used in pngwrite.c, pngwutil.c for now. + * These defines should NOT be changed. +@@ -1948,45 +1480,18 @@ extern PNG_EXPORT(void,png_set_filter) PNGARG((png_structp png_ptr, int method, + #define PNG_FILTER_VALUE_PAETH 4 + #define PNG_FILTER_VALUE_LAST 5 + +-#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED) /* EXPERIMENTAL */ +-/* The "heuristic_method" is given by one of the PNG_FILTER_HEURISTIC_ +- * defines, either the default (minimum-sum-of-absolute-differences), or +- * the experimental method (weighted-minimum-sum-of-absolute-differences). +- * +- * Weights are factors >= 1.0, indicating how important it is to keep the +- * filter type consistent between rows. Larger numbers mean the current +- * filter is that many times as likely to be the same as the "num_weights" +- * previous filters. This is cumulative for each previous row with a weight. +- * There needs to be "num_weights" values in "filter_weights", or it can be +- * NULL if the weights aren't being specified. Weights have no influence on +- * the selection of the first row filter. Well chosen weights can (in theory) +- * improve the compression for a given image. +- * +- * Costs are factors >= 1.0 indicating the relative decoding costs of a +- * filter type. Higher costs indicate more decoding expense, and are +- * therefore less likely to be selected over a filter with lower computational +- * costs. There needs to be a value in "filter_costs" for each valid filter +- * type (given by PNG_FILTER_VALUE_LAST), or it can be NULL if you aren't +- * setting the costs. Costs try to improve the speed of decompression without +- * unduly increasing the compressed image size. +- * +- * A negative weight or cost indicates the default value is to be used, and +- * values in the range [0.0, 1.0) indicate the value is to remain unchanged. +- * The default values for both weights and costs are currently 1.0, but may +- * change if good general weighting/cost heuristics can be found. If both +- * the weights and costs are set to 1.0, this degenerates the WEIGHTED method +- * to the UNWEIGHTED method, but with added encoding time/computation. +- */ +-#ifdef PNG_FLOATING_POINT_SUPPORTED +-extern PNG_EXPORT(void,png_set_filter_heuristics) PNGARG((png_structp png_ptr, +- int heuristic_method, int num_weights, png_doublep filter_weights, +- png_doublep filter_costs)); +-#endif +-#endif /* PNG_WRITE_WEIGHTED_FILTER_SUPPORTED */ +- +-/* Heuristic used for row filter selection. These defines should NOT be +- * changed. +- */ ++#ifdef PNG_WRITE_SUPPORTED ++#ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED /* DEPRECATED */ ++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_FIXED_EXPORT(209, void, 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)) ++#endif /* WRITE_WEIGHTED_FILTER */ ++ ++/* The following are no longer used and will be removed from libpng-1.7: */ + #define PNG_FILTER_HEURISTIC_DEFAULT 0 /* Currently "UNWEIGHTED" */ + #define PNG_FILTER_HEURISTIC_UNWEIGHTED 1 /* Used by libpng < 0.95 */ + #define PNG_FILTER_HEURISTIC_WEIGHTED 2 /* Experimental feature */ +@@ -1999,33 +1504,60 @@ extern PNG_EXPORT(void,png_set_filter_heuristics) PNGARG((png_structp png_ptr, + * for PNG images, and do considerably fewer caclulations. In the future, + * these values may not correspond directly to the zlib compression levels. + */ +-extern PNG_EXPORT(void,png_set_compression_level) PNGARG((png_structp png_ptr, +- int level)); ++#ifdef PNG_WRITE_CUSTOMIZE_COMPRESSION_SUPPORTED ++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_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_structrp png_ptr, ++ int window_bits)); ++ ++PNG_EXPORT(73, void, png_set_compression_method, (png_structrp png_ptr, ++ int method)); ++#endif /* WRITE_CUSTOMIZE_COMPRESSION */ + +-extern PNG_EXPORT(void,png_set_compression_mem_level) +- PNGARG((png_structp png_ptr, int mem_level)); ++#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_structrp png_ptr, ++ int level)); + +-extern PNG_EXPORT(void,png_set_compression_strategy) +- PNGARG((png_structp png_ptr, int strategy)); ++PNG_EXPORT(223, void, png_set_text_compression_mem_level, (png_structrp png_ptr, ++ int mem_level)); + +-extern PNG_EXPORT(void,png_set_compression_window_bits) +- PNGARG((png_structp png_ptr, int window_bits)); ++PNG_EXPORT(224, void, png_set_text_compression_strategy, (png_structrp png_ptr, ++ int strategy)); + +-extern PNG_EXPORT(void,png_set_compression_method) PNGARG((png_structp png_ptr, +- int method)); ++/* 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_structrp png_ptr, int window_bits)); ++ ++PNG_EXPORT(226, void, png_set_text_compression_method, (png_structrp png_ptr, ++ int method)); ++#endif /* WRITE_CUSTOMIZE_ZTXT_COMPRESSION */ ++#endif /* WRITE */ + + /* These next functions are called for input/output, memory, and error + * handling. They are in the file pngrio.c, pngwio.c, and pngerror.c, + * and call standard C I/O routines such as fread(), fwrite(), and + * fprintf(). These functions can be made to use other I/O routines + * at run time for those applications that need to handle I/O in a +- * different manner by calling png_set_???_fn(). See libpng.txt for ++ * different manner by calling png_set_???_fn(). See libpng-manual.txt for + * more information. + */ + + #ifdef PNG_STDIO_SUPPORTED + /* Initialize the input/output for the PNG file to the default functions. */ +-extern PNG_EXPORT(void,png_init_io) PNGARG((png_structp png_ptr, png_FILE_p fp)); ++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 +@@ -2036,11 +1568,11 @@ extern PNG_EXPORT(void,png_init_io) PNGARG((png_structp png_ptr, png_FILE_p fp)) + * default function will be used. + */ + +-extern PNG_EXPORT(void,png_set_error_fn) PNGARG((png_structp png_ptr, +- png_voidp error_ptr, png_error_ptr error_fn, png_error_ptr warning_fn)); ++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 */ +-extern PNG_EXPORT(png_voidp,png_get_error_ptr) PNGARG((png_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. +@@ -2052,178 +1584,243 @@ extern PNG_EXPORT(png_voidp,png_get_error_ptr) PNGARG((png_structp png_ptr)); + * default flush function, which uses the standard *FILE structure, will + * be used. + */ +-extern PNG_EXPORT(void,png_set_write_fn) PNGARG((png_structp png_ptr, +- png_voidp io_ptr, png_rw_ptr write_data_fn, png_flush_ptr output_flush_fn)); ++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. */ +-extern PNG_EXPORT(void,png_set_read_fn) PNGARG((png_structp png_ptr, +- png_voidp io_ptr, png_rw_ptr read_data_fn)); ++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 */ +-extern PNG_EXPORT(png_voidp,png_get_io_ptr) PNGARG((png_structp png_ptr)); ++PNG_EXPORT(79, png_voidp, png_get_io_ptr, (png_const_structrp png_ptr)); + +-extern PNG_EXPORT(void,png_set_read_status_fn) PNGARG((png_structp png_ptr, +- png_read_status_ptr read_row_fn)); ++PNG_EXPORT(80, void, png_set_read_status_fn, (png_structrp png_ptr, ++ png_read_status_ptr read_row_fn)); + +-extern PNG_EXPORT(void,png_set_write_status_fn) PNGARG((png_structp png_ptr, +- png_write_status_ptr write_row_fn)); ++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). */ +-extern PNG_EXPORT(void,png_set_mem_fn) PNGARG((png_structp png_ptr, +- png_voidp mem_ptr, png_malloc_ptr malloc_fn, png_free_ptr free_fn)); ++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 */ +-extern PNG_EXPORT(png_voidp,png_get_mem_ptr) PNGARG((png_structp png_ptr)); ++PNG_EXPORT(83, png_voidp, png_get_mem_ptr, (png_const_structrp png_ptr)); + #endif + +-#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \ +- defined(PNG_LEGACY_SUPPORTED) +-extern PNG_EXPORT(void,png_set_read_user_transform_fn) PNGARG((png_structp +- png_ptr, png_user_transform_ptr read_user_transform_fn)); ++#ifdef PNG_READ_USER_TRANSFORM_SUPPORTED ++PNG_EXPORT(84, void, png_set_read_user_transform_fn, (png_structrp png_ptr, ++ png_user_transform_ptr read_user_transform_fn)); + #endif + +-#if defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) || \ +- defined(PNG_LEGACY_SUPPORTED) +-extern PNG_EXPORT(void,png_set_write_user_transform_fn) PNGARG((png_structp +- png_ptr, png_user_transform_ptr write_user_transform_fn)); ++#ifdef PNG_WRITE_USER_TRANSFORM_SUPPORTED ++PNG_EXPORT(85, void, png_set_write_user_transform_fn, (png_structrp png_ptr, ++ png_user_transform_ptr write_user_transform_fn)); + #endif + +-#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \ +- defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) || \ +- defined(PNG_LEGACY_SUPPORTED) +-extern PNG_EXPORT(void,png_set_user_transform_info) PNGARG((png_structp +- png_ptr, png_voidp user_transform_ptr, int user_transform_depth, +- int user_transform_channels)); ++#ifdef PNG_USER_TRANSFORM_PTR_SUPPORTED ++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 */ +-extern PNG_EXPORT(png_voidp,png_get_user_transform_ptr) +- PNGARG((png_structp png_ptr)); ++PNG_EXPORT(87, png_voidp, png_get_user_transform_ptr, ++ (png_const_structrp png_ptr)); ++#endif ++ ++#ifdef PNG_USER_TRANSFORM_INFO_SUPPORTED ++/* Return information about the row currently being processed. Note that these ++ * APIs do not fail but will return unexpected results if called outside a user ++ * transform callback. Also note that when transforming an interlaced image the ++ * row number is the row number within the sub-image of the interlace pass, so ++ * the value will increase to the height of the sub-image (not the full image) ++ * then reset to 0 for the next pass. ++ * ++ * Use PNG_ROW_FROM_PASS_ROW(row, pass) and PNG_COL_FROM_PASS_COL(col, pass) to ++ * 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_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 occurred; 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 WITH 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 +-extern PNG_EXPORT(void,png_set_read_user_chunk_fn) PNGARG((png_structp png_ptr, +- png_voidp user_chunk_ptr, png_user_chunk_ptr read_user_chunk_fn)); +-extern PNG_EXPORT(png_voidp,png_get_user_chunk_ptr) PNGARG((png_structp +- png_ptr)); ++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. + */ +-extern PNG_EXPORT(void,png_set_progressive_read_fn) PNGARG((png_structp png_ptr, +- png_voidp progressive_ptr, +- png_progressive_info_ptr info_fn, png_progressive_row_ptr row_fn, +- png_progressive_end_ptr end_fn)); ++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 */ +-extern PNG_EXPORT(png_voidp,png_get_progressive_ptr) +- PNGARG((png_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 */ +-extern PNG_EXPORT(void,png_process_data) PNGARG((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, size_t buffer_size)); + +-/* Function that combines rows. Not very much different than the +- * png_combine_row() call. Is this even used????? ++/* 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 ++ * remaining, excluding any that libpng has cached internally. A subsequent ++ * call to png_process_data must supply these bytes again. If the argument ++ * 'save' is set to true the routine will first save all the pending data and ++ * will always return 0. + */ +-extern PNG_EXPORT(void,png_progressive_combine_row) PNGARG((png_structp png_ptr, +- png_bytep old_row, png_bytep new_row)); +-#endif /* PNG_PROGRESSIVE_READ_SUPPORTED */ ++PNG_EXPORT(219, size_t, png_process_data_pause, (png_structrp, int save)); + +-extern PNG_EXPORT(png_voidp,png_malloc) PNGARG((png_structp png_ptr, +- png_uint_32 size)) PNG_ALLOCATED; ++/* 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 ++ * input. Normally it will return 0, but if it returns a non-zero value the ++ * 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_structrp)); + +-#ifdef PNG_1_0_X +-# define png_malloc_warn png_malloc +-#else +-/* Added at libpng version 1.2.4 */ +-extern PNG_EXPORT(png_voidp,png_malloc_warn) PNGARG((png_structp png_ptr, +- png_uint_32 size)) PNG_ALLOCATED; +-#endif ++/* 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_const_structrp png_ptr, ++ png_bytep old_row, png_const_bytep new_row)); ++#endif /* PROGRESSIVE_READ */ + +-/* Frees a pointer allocated by png_malloc() */ +-extern PNG_EXPORT(void,png_free) PNGARG((png_structp png_ptr, png_voidp ptr)); ++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_const_structrp png_ptr, ++ png_alloc_size_t size), PNG_ALLOCATED); + +-#ifdef PNG_1_0_X +-/* Function to allocate memory for zlib. */ +-extern PNG_EXPORT(voidpf,png_zalloc) PNGARG((voidpf png_ptr, uInt items, +- uInt size)); ++/* Added at libpng version 1.2.4 */ ++PNG_EXPORTA(96, png_voidp, png_malloc_warn, (png_const_structrp png_ptr, ++ png_alloc_size_t size), PNG_ALLOCATED); + +-/* Function to free memory for zlib */ +-extern PNG_EXPORT(void,png_zfree) PNGARG((voidpf png_ptr, voidpf ptr)); +-#endif ++/* Frees a pointer allocated by png_malloc() */ ++PNG_EXPORT(97, void, png_free, (png_const_structrp png_ptr, png_voidp ptr)); + + /* Free data that was allocated internally */ +-extern PNG_EXPORT(void,png_free_data) PNGARG((png_structp png_ptr, +- png_infop info_ptr, png_uint_32 free_me, int num)); +-#ifdef PNG_FREE_ME_SUPPORTED ++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 ++ * 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. + */ +-extern PNG_EXPORT(void,png_data_freer) PNGARG((png_structp png_ptr, +- png_infop info_ptr, int freer, png_uint_32 mask)); +-#endif ++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 + #define PNG_SET_WILL_FREE_DATA 1 + #define PNG_USER_WILL_FREE_DATA 2 + /* Flags for png_ptr->free_me and info_ptr->free_me */ +-#define PNG_FREE_HIST 0x0008 +-#define PNG_FREE_ICCP 0x0010 +-#define PNG_FREE_SPLT 0x0020 +-#define PNG_FREE_ROWS 0x0040 +-#define PNG_FREE_PCAL 0x0080 +-#define PNG_FREE_SCAL 0x0100 +-#define PNG_FREE_UNKN 0x0200 +-#define PNG_FREE_LIST 0x0400 +-#define PNG_FREE_PLTE 0x1000 +-#define PNG_FREE_TRNS 0x2000 +-#define PNG_FREE_TEXT 0x4000 +-#define PNG_FREE_ALL 0x7fff +-#define PNG_FREE_MUL 0x4220 /* PNG_FREE_SPLT|PNG_FREE_TEXT|PNG_FREE_UNKN */ ++#define PNG_FREE_HIST 0x0008U ++#define PNG_FREE_ICCP 0x0010U ++#define PNG_FREE_SPLT 0x0020U ++#define PNG_FREE_ROWS 0x0040U ++#define PNG_FREE_PCAL 0x0080U ++#define PNG_FREE_SCAL 0x0100U ++#ifdef PNG_STORE_UNKNOWN_CHUNKS_SUPPORTED ++# define PNG_FREE_UNKN 0x0200U ++#endif ++/* PNG_FREE_LIST 0x0400U removed in 1.6.0 because it is ignored */ ++#define PNG_FREE_PLTE 0x1000U ++#define PNG_FREE_TRNS 0x2000U ++#define PNG_FREE_TEXT 0x4000U ++#define PNG_FREE_EXIF 0x8000U /* Added at libpng-1.6.31 */ ++#define PNG_FREE_ALL 0xffffU ++#define PNG_FREE_MUL 0x4220U /* PNG_FREE_SPLT|PNG_FREE_TEXT|PNG_FREE_UNKN */ + + #ifdef PNG_USER_MEM_SUPPORTED +-extern PNG_EXPORT(png_voidp,png_malloc_default) PNGARG((png_structp png_ptr, +- png_uint_32 size)) PNG_ALLOCATED; +-extern PNG_EXPORT(void,png_free_default) PNGARG((png_structp png_ptr, +- png_voidp ptr)); ++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 + +-extern PNG_EXPORT(png_voidp,png_memcpy_check) PNGARG((png_structp png_ptr, +- png_voidp s1, png_voidp s2, png_uint_32 size)) PNG_DEPRECATED; +- +-extern PNG_EXPORT(png_voidp,png_memset_check) PNGARG((png_structp png_ptr, +- png_voidp s1, int value, png_uint_32 size)) PNG_DEPRECATED; +- +-#if defined(USE_FAR_KEYWORD) /* memory model conversion function */ +-extern void *png_far_to_near PNGARG((png_structp png_ptr,png_voidp ptr, +- int check)); +-#endif /* USE_FAR_KEYWORD */ +- +-#ifndef PNG_NO_ERROR_TEXT ++#ifdef PNG_ERROR_TEXT_SUPPORTED + /* Fatal error in PNG image of libpng - can't continue */ +-extern PNG_EXPORT(void,png_error) PNGARG((png_structp png_ptr, +- png_const_charp error_message)) PNG_NORETURN; ++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. */ +-extern PNG_EXPORT(void,png_chunk_error) PNGARG((png_structp png_ptr, +- png_const_charp error_message)) PNG_NORETURN; ++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 */ +-extern PNG_EXPORT(void,png_err) PNGARG((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 + +-#ifndef PNG_NO_WARNINGS ++#ifdef PNG_WARNINGS_SUPPORTED + /* Non-fatal error in libpng. Can continue, but may have a problem. */ +-extern PNG_EXPORT(void,png_warning) PNGARG((png_structp png_ptr, +- png_const_charp warning_message)); ++PNG_EXPORT(105, void, png_warning, (png_const_structrp png_ptr, ++ png_const_charp warning_message)); + +-#ifdef PNG_READ_SUPPORTED + /* Non-fatal error in libpng, chunk name is prepended to message. */ +-extern PNG_EXPORT(void,png_chunk_warning) PNGARG((png_structp png_ptr, +- png_const_charp warning_message)); +-#endif /* PNG_READ_SUPPORTED */ +-#endif /* PNG_NO_WARNINGS */ ++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. */ ++PNG_EXPORT(107, void, png_benign_error, (png_const_structrp png_ptr, ++ png_const_charp warning_message)); ++ ++#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_structrp png_ptr, int allowed)); ++#else ++# ifdef PNG_ALLOW_BENIGN_ERRORS ++# define png_benign_error png_warning ++# define png_chunk_benign_error png_chunk_warning ++# else ++# define png_benign_error png_error ++# define png_chunk_benign_error png_chunk_error ++# endif ++#endif + + /* The png_set_ functions are for storing values in the png_info_struct. + * Similarly, the png_get_ calls are used to read values from the +@@ -2238,480 +1835,510 @@ extern PNG_EXPORT(void,png_chunk_warning) PNGARG((png_structp png_ptr, + * png_info_struct. + */ + /* Returns "flag" if chunk data is valid in info_ptr. */ +-extern PNG_EXPORT(png_uint_32,png_get_valid) PNGARG((png_structp png_ptr, +-png_infop info_ptr, png_uint_32 flag)); ++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. */ +-extern PNG_EXPORT(png_uint_32,png_get_rowbytes) PNGARG((png_structp png_ptr, +-png_infop info_ptr)); ++PNG_EXPORT(111, 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(). + */ +-extern PNG_EXPORT(png_bytepp,png_get_rows) PNGARG((png_structp png_ptr, +-png_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(). + */ +-extern PNG_EXPORT(void,png_set_rows) PNGARG((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. */ +-extern PNG_EXPORT(png_byte,png_get_channels) PNGARG((png_structp png_ptr, +-png_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. */ +-extern PNG_EXPORT(png_uint_32, png_get_image_width) PNGARG((png_structp +-png_ptr, png_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. */ +-extern PNG_EXPORT(png_uint_32, png_get_image_height) PNGARG((png_structp +-png_ptr, png_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. */ +-extern PNG_EXPORT(png_byte, png_get_bit_depth) PNGARG((png_structp +-png_ptr, png_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. */ +-extern PNG_EXPORT(png_byte, png_get_color_type) PNGARG((png_structp +-png_ptr, png_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. */ +-extern PNG_EXPORT(png_byte, png_get_filter_type) PNGARG((png_structp +-png_ptr, png_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. */ +-extern PNG_EXPORT(png_byte, png_get_interlace_type) PNGARG((png_structp +-png_ptr, png_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. */ +-extern PNG_EXPORT(png_byte, png_get_compression_type) PNGARG((png_structp +-png_ptr, png_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. */ +-extern PNG_EXPORT(png_uint_32, png_get_pixels_per_meter) PNGARG((png_structp +-png_ptr, png_infop info_ptr)); +-extern PNG_EXPORT(png_uint_32, png_get_x_pixels_per_meter) PNGARG((png_structp +-png_ptr, png_infop info_ptr)); +-extern PNG_EXPORT(png_uint_32, png_get_y_pixels_per_meter) PNGARG((png_structp +-png_ptr, png_infop info_ptr)); ++PNG_EXPORT(122, png_uint_32, png_get_pixels_per_meter, ++ (png_const_structrp png_ptr, png_const_inforp info_ptr)); ++PNG_EXPORT(123, png_uint_32, png_get_x_pixels_per_meter, ++ (png_const_structrp png_ptr, png_const_inforp info_ptr)); ++PNG_EXPORT(124, png_uint_32, png_get_y_pixels_per_meter, ++ (png_const_structrp png_ptr, png_const_inforp info_ptr)); + + /* Returns pixel aspect ratio, computed from pHYs chunk data. */ +-#ifdef PNG_FLOATING_POINT_SUPPORTED +-extern PNG_EXPORT(float, png_get_pixel_aspect_ratio) PNGARG((png_structp +-png_ptr, png_infop info_ptr)); +-#endif ++PNG_FP_EXPORT(125, float, png_get_pixel_aspect_ratio, ++ (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_structrp png_ptr, png_const_inforp info_ptr)) + + /* Returns image x, y offset in pixels or microns, from oFFs chunk data. */ +-extern PNG_EXPORT(png_int_32, png_get_x_offset_pixels) PNGARG((png_structp +-png_ptr, png_infop info_ptr)); +-extern PNG_EXPORT(png_int_32, png_get_y_offset_pixels) PNGARG((png_structp +-png_ptr, png_infop info_ptr)); +-extern PNG_EXPORT(png_int_32, png_get_x_offset_microns) PNGARG((png_structp +-png_ptr, png_infop info_ptr)); +-extern PNG_EXPORT(png_int_32, png_get_y_offset_microns) PNGARG((png_structp +-png_ptr, png_infop info_ptr)); ++PNG_EXPORT(126, png_int_32, png_get_x_offset_pixels, ++ (png_const_structrp png_ptr, png_const_inforp info_ptr)); ++PNG_EXPORT(127, png_int_32, png_get_y_offset_pixels, ++ (png_const_structrp png_ptr, png_const_inforp info_ptr)); ++PNG_EXPORT(128, png_int_32, png_get_x_offset_microns, ++ (png_const_structrp png_ptr, png_const_inforp info_ptr)); ++PNG_EXPORT(129, png_int_32, png_get_y_offset_microns, ++ (png_const_structrp png_ptr, png_const_inforp info_ptr)); + +-#endif /* PNG_EASY_ACCESS_SUPPORTED */ ++#endif /* EASY_ACCESS */ + ++#ifdef PNG_READ_SUPPORTED + /* Returns pointer to signature string read from PNG header */ +-extern PNG_EXPORT(png_bytep,png_get_signature) PNGARG((png_structp png_ptr, +-png_infop info_ptr)); ++PNG_EXPORT(130, png_const_bytep, png_get_signature, (png_const_structrp png_ptr, ++ png_const_inforp info_ptr)); ++#endif + + #ifdef PNG_bKGD_SUPPORTED +-extern PNG_EXPORT(png_uint_32,png_get_bKGD) PNGARG((png_structp png_ptr, +- png_infop info_ptr, png_color_16p *background)); ++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 +-extern PNG_EXPORT(void,png_set_bKGD) PNGARG((png_structp png_ptr, +- png_infop info_ptr, png_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 +-#ifdef PNG_FLOATING_POINT_SUPPORTED +-extern PNG_EXPORT(png_uint_32,png_get_cHRM) PNGARG((png_structp png_ptr, +- png_infop info_ptr, double *white_x, double *white_y, double *red_x, +- double *red_y, double *green_x, double *green_y, double *blue_x, +- double *blue_y)); +-#endif +-#ifdef PNG_FIXED_POINT_SUPPORTED +-extern PNG_EXPORT(png_uint_32,png_get_cHRM_fixed) PNGARG((png_structp png_ptr, +- png_infop info_ptr, png_fixed_point *int_white_x, png_fixed_point +- *int_white_y, png_fixed_point *int_red_x, png_fixed_point *int_red_y, +- png_fixed_point *int_green_x, png_fixed_point *int_green_y, png_fixed_point +- *int_blue_x, png_fixed_point *int_blue_y)); +-#endif ++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)) ++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_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 + + #ifdef PNG_cHRM_SUPPORTED +-#ifdef PNG_FLOATING_POINT_SUPPORTED +-extern PNG_EXPORT(void,png_set_cHRM) PNGARG((png_structp png_ptr, +- png_infop info_ptr, double white_x, double white_y, double red_x, +- double red_y, double green_x, double green_y, double blue_x, double blue_y)); +-#endif +-#ifdef PNG_FIXED_POINT_SUPPORTED +-extern PNG_EXPORT(void,png_set_cHRM_fixed) PNGARG((png_structp png_ptr, +- png_infop info_ptr, png_fixed_point int_white_x, png_fixed_point int_white_y, +- png_fixed_point int_red_x, png_fixed_point int_red_y, png_fixed_point +- int_green_x, png_fixed_point int_green_y, png_fixed_point int_blue_x, +- png_fixed_point int_blue_y)); +-#endif ++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_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_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_eXIf_SUPPORTED ++PNG_EXPORT(246, png_uint_32, png_get_eXIf, (png_const_structrp png_ptr, ++ png_inforp info_ptr, png_bytep *exif)); ++PNG_EXPORT(247, void, png_set_eXIf, (png_const_structrp png_ptr, ++ png_inforp info_ptr, png_bytep exif)); ++ ++PNG_EXPORT(248, png_uint_32, png_get_eXIf_1, (png_const_structrp png_ptr, ++ png_const_inforp info_ptr, png_uint_32 *num_exif, png_bytep *exif)); ++PNG_EXPORT(249, void, png_set_eXIf_1, (png_const_structrp png_ptr, ++ png_inforp info_ptr, png_uint_32 num_exif, png_bytep exif)); + #endif + + #ifdef PNG_gAMA_SUPPORTED +-#ifdef PNG_FLOATING_POINT_SUPPORTED +-extern PNG_EXPORT(png_uint_32,png_get_gAMA) PNGARG((png_structp png_ptr, +- png_infop info_ptr, double *file_gamma)); +-#endif +-extern PNG_EXPORT(png_uint_32,png_get_gAMA_fixed) PNGARG((png_structp png_ptr, +- png_infop info_ptr, png_fixed_point *int_file_gamma)); ++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_structrp png_ptr, png_const_inforp info_ptr, ++ png_fixed_point *int_file_gamma)) + #endif + + #ifdef PNG_gAMA_SUPPORTED +-#ifdef PNG_FLOATING_POINT_SUPPORTED +-extern PNG_EXPORT(void,png_set_gAMA) PNGARG((png_structp png_ptr, +- png_infop info_ptr, double file_gamma)); +-#endif +-extern PNG_EXPORT(void,png_set_gAMA_fixed) PNGARG((png_structp png_ptr, +- png_infop info_ptr, png_fixed_point int_file_gamma)); +-#endif +- +-#ifdef PNG_hIST_SUPPORTED +-extern PNG_EXPORT(png_uint_32,png_get_hIST) PNGARG((png_structp png_ptr, +- png_infop info_ptr, png_uint_16p *hist)); ++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 +-extern PNG_EXPORT(void,png_set_hIST) PNGARG((png_structp png_ptr, +- png_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)); ++PNG_EXPORT(142, void, png_set_hIST, (png_const_structrp png_ptr, ++ png_inforp info_ptr, png_const_uint_16p hist)); + #endif + +-extern PNG_EXPORT(png_uint_32,png_get_IHDR) PNGARG((png_structp png_ptr, +- png_infop info_ptr, png_uint_32 *width, png_uint_32 *height, +- int *bit_depth, int *color_type, int *interlace_method, +- int *compression_method, int *filter_method)); ++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)); + +-extern PNG_EXPORT(void,png_set_IHDR) PNGARG((png_structp png_ptr, +- png_infop info_ptr, png_uint_32 width, png_uint_32 height, int bit_depth, +- int color_type, int interlace_method, int compression_method, +- int filter_method)); ++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 +-extern PNG_EXPORT(png_uint_32,png_get_oFFs) PNGARG((png_structp png_ptr, +- png_infop info_ptr, png_int_32 *offset_x, png_int_32 *offset_y, ++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 +-extern PNG_EXPORT(void,png_set_oFFs) PNGARG((png_structp png_ptr, +- png_infop info_ptr, png_int_32 offset_x, png_int_32 offset_y, +- int unit_type)); ++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 +-extern PNG_EXPORT(png_uint_32,png_get_pCAL) PNGARG((png_structp png_ptr, +- png_infop info_ptr, png_charp *purpose, png_int_32 *X0, png_int_32 *X1, +- int *type, int *nparams, png_charp *units, png_charpp *params)); ++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 +-extern PNG_EXPORT(void,png_set_pCAL) PNGARG((png_structp png_ptr, +- png_infop info_ptr, png_charp purpose, png_int_32 X0, png_int_32 X1, +- int type, int nparams, png_charp units, png_charpp params)); ++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 +-extern PNG_EXPORT(png_uint_32,png_get_pHYs) PNGARG((png_structp png_ptr, +- png_infop info_ptr, png_uint_32 *res_x, png_uint_32 *res_y, int *unit_type)); ++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 +-extern PNG_EXPORT(void,png_set_pHYs) PNGARG((png_structp png_ptr, +- png_infop info_ptr, png_uint_32 res_x, png_uint_32 res_y, int unit_type)); ++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 + +-extern PNG_EXPORT(png_uint_32,png_get_PLTE) PNGARG((png_structp png_ptr, +- png_infop info_ptr, png_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)); + +-extern PNG_EXPORT(void,png_set_PLTE) PNGARG((png_structp png_ptr, +- png_infop 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 +-extern PNG_EXPORT(png_uint_32,png_get_sBIT) PNGARG((png_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 +-extern PNG_EXPORT(void,png_set_sBIT) PNGARG((png_structp png_ptr, +- png_infop info_ptr, png_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 +-extern PNG_EXPORT(png_uint_32,png_get_sRGB) PNGARG((png_structp png_ptr, +- png_infop info_ptr, int *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 +-extern PNG_EXPORT(void,png_set_sRGB) PNGARG((png_structp png_ptr, +- png_infop info_ptr, int intent)); +-extern PNG_EXPORT(void,png_set_sRGB_gAMA_and_cHRM) PNGARG((png_structp png_ptr, +- png_infop info_ptr, int intent)); ++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 +-extern PNG_EXPORT(png_uint_32,png_get_iCCP) PNGARG((png_structp png_ptr, +- png_infop info_ptr, png_charpp name, int *compression_type, +- png_charpp profile, png_uint_32 *proflen)); +- /* Note to maintainer: profile should be png_bytepp */ ++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 +-extern PNG_EXPORT(void,png_set_iCCP) PNGARG((png_structp png_ptr, +- png_infop info_ptr, png_charp name, int compression_type, +- png_charp profile, png_uint_32 proflen)); +- /* Note to maintainer: profile should be png_bytep */ ++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 +-extern PNG_EXPORT(png_uint_32,png_get_sPLT) PNGARG((png_structp png_ptr, +- png_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 +-extern PNG_EXPORT(void,png_set_sPLT) PNGARG((png_structp png_ptr, +- png_infop info_ptr, png_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 */ +-extern PNG_EXPORT(png_uint_32,png_get_text) PNGARG((png_structp png_ptr, +- png_infop info_ptr, png_textp *text_ptr, int *num_text)); ++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, +- * language, and translated keywords are NULL pointers, the structure +- * returned by png_get_text will always contain regular +- * zero-terminated C strings. They might be empty strings but +- * they will never be NULL pointers. ++/* Note while png_set_text() will accept a structure whose text, ++ * language, and translated keywords are NULL pointers, the structure ++ * returned by png_get_text will always contain regular ++ * zero-terminated C strings. They might be empty strings but ++ * they will never be NULL pointers. + */ + + #ifdef PNG_TEXT_SUPPORTED +-extern PNG_EXPORT(void,png_set_text) PNGARG((png_structp png_ptr, +- png_infop info_ptr, png_textp text_ptr, int num_text)); ++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 +-extern PNG_EXPORT(png_uint_32,png_get_tIME) PNGARG((png_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 +-extern PNG_EXPORT(void,png_set_tIME) PNGARG((png_structp png_ptr, +- png_infop info_ptr, png_timep mod_time)); +-#endif +- +-#ifdef PNG_tRNS_SUPPORTED +-extern PNG_EXPORT(png_uint_32,png_get_tRNS) PNGARG((png_structp png_ptr, +- png_infop info_ptr, png_bytep *trans, int *num_trans, +- png_color_16p *trans_values)); ++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 +-extern PNG_EXPORT(void,png_set_tRNS) PNGARG((png_structp png_ptr, +- png_infop info_ptr, png_bytep trans, int num_trans, +- png_color_16p trans_values)); ++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_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 +-#ifdef PNG_FLOATING_POINT_SUPPORTED +-extern PNG_EXPORT(png_uint_32,png_get_sCAL) PNGARG((png_structp png_ptr, +- png_infop info_ptr, int *unit, double *width, double *height)); +-#else +-#ifdef PNG_FIXED_POINT_SUPPORTED +-extern PNG_EXPORT(png_uint_32,png_get_sCAL_s) PNGARG((png_structp png_ptr, +- png_infop info_ptr, int *unit, png_charpp swidth, png_charpp sheight)); +-#endif +-#endif +-#endif /* PNG_sCAL_SUPPORTED */ ++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_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_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 WITH 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. ++ */ ++#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED ++PNG_EXPORT(172, void, png_set_keep_unknown_chunks, (png_structrp png_ptr, ++ int keep, png_const_bytep chunk_list, int num_chunks)); ++#endif /* HANDLE_AS_UNKNOWN */ ++ ++/* 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 /* SET_UNKNOWN_CHUNKS */ ++ ++#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. ++ */ + +-#ifdef PNG_sCAL_SUPPORTED +-#ifdef PNG_FLOATING_POINT_SUPPORTED +-extern PNG_EXPORT(void,png_set_sCAL) PNGARG((png_structp png_ptr, +- png_infop info_ptr, int unit, double width, double height)); +-#else +-#ifdef PNG_FIXED_POINT_SUPPORTED +-extern PNG_EXPORT(void,png_set_sCAL_s) PNGARG((png_structp png_ptr, +- png_infop info_ptr, int unit, png_charp swidth, png_charp sheight)); +-#endif +-#endif +-#endif /* PNG_sCAL_SUPPORTED || PNG_WRITE_sCAL_SUPPORTED */ ++PNG_EXPORT(175, void, png_set_unknown_chunk_location, ++ (png_const_structrp png_ptr, png_inforp info_ptr, int chunk, int location)); + +-#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED +-/* Provide a list of chunks and how they are to be handled, if the built-in +- handling or default unknown chunk handling is not desired. Any chunks not +- listed will be handled in the default manner. The IHDR and IEND chunks +- must not be listed. +- keep = 0: follow default behaviour +- = 1: do not keep +- = 2: keep only if safe-to-copy +- = 3: keep even if unsafe-to-copy +-*/ +-extern PNG_EXPORT(void, png_set_keep_unknown_chunks) PNGARG((png_structp +- png_ptr, int keep, png_bytep chunk_list, int num_chunks)); +-PNG_EXPORT(int,png_handle_as_unknown) PNGARG((png_structp png_ptr, png_bytep +- chunk_name)); +-#endif +-#ifdef PNG_UNKNOWN_CHUNKS_SUPPORTED +-extern PNG_EXPORT(void, png_set_unknown_chunks) PNGARG((png_structp png_ptr, +- png_infop info_ptr, png_unknown_chunkp unknowns, int num_unknowns)); +-extern PNG_EXPORT(void, png_set_unknown_chunk_location) +- PNGARG((png_structp png_ptr, png_infop info_ptr, int chunk, int location)); +-extern PNG_EXPORT(png_uint_32,png_get_unknown_chunks) PNGARG((png_structp +- png_ptr, png_infop info_ptr, png_unknown_chunkpp entries)); ++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); + */ +-extern PNG_EXPORT(void, png_set_invalid) PNGARG((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. */ +-extern PNG_EXPORT(void, png_read_png) PNGARG((png_structp png_ptr, +- png_infop info_ptr, +- int transforms, +- png_voidp params)); +-extern PNG_EXPORT(void, png_write_png) PNGARG((png_structp png_ptr, +- png_infop info_ptr, +- int transforms, +- png_voidp params)); +-#endif +- +-/* Define PNG_DEBUG at compile time for debugging information. Higher +- * numbers for PNG_DEBUG mean more debugging information. This has +- * only been added since version 0.95 so it is not implemented throughout +- * libpng yet, but more support will be added as needed. +- */ +-#ifdef PNG_DEBUG +-#if (PNG_DEBUG > 0) +-#if !defined(PNG_DEBUG_FILE) && defined(_MSC_VER) +-#include +-#if (PNG_DEBUG > 1) +-#ifndef _DEBUG +-# define _DEBUG +-#endif +-#ifndef png_debug +-#define png_debug(l,m) _RPT0(_CRT_WARN,m PNG_STRING_NEWLINE) +-#endif +-#ifndef png_debug1 +-#define png_debug1(l,m,p1) _RPT1(_CRT_WARN,m PNG_STRING_NEWLINE,p1) +-#endif +-#ifndef png_debug2 +-#define png_debug2(l,m,p1,p2) _RPT2(_CRT_WARN,m PNG_STRING_NEWLINE,p1,p2) +-#endif +-#endif +-#else /* PNG_DEBUG_FILE || !_MSC_VER */ +-#ifndef PNG_DEBUG_FILE +-#define PNG_DEBUG_FILE stderr +-#endif /* PNG_DEBUG_FILE */ +- +-#if (PNG_DEBUG > 1) +-/* Note: ["%s"m PNG_STRING_NEWLINE] probably does not work on non-ISO +- * compilers. +- */ +-# ifdef __STDC__ +-# ifndef png_debug +-# define png_debug(l,m) \ +- { \ +- int num_tabs=l; \ +- fprintf(PNG_DEBUG_FILE,"%s"m PNG_STRING_NEWLINE,(num_tabs==1 ? "\t" : \ +- (num_tabs==2 ? "\t\t":(num_tabs>2 ? "\t\t\t":"")))); \ +- } +-# endif +-# ifndef png_debug1 +-# define png_debug1(l,m,p1) \ +- { \ +- int num_tabs=l; \ +- fprintf(PNG_DEBUG_FILE,"%s"m PNG_STRING_NEWLINE,(num_tabs==1 ? "\t" : \ +- (num_tabs==2 ? "\t\t":(num_tabs>2 ? "\t\t\t":""))),p1); \ +- } +-# endif +-# ifndef png_debug2 +-# define png_debug2(l,m,p1,p2) \ +- { \ +- int num_tabs=l; \ +- fprintf(PNG_DEBUG_FILE,"%s"m PNG_STRING_NEWLINE,(num_tabs==1 ? "\t" : \ +- (num_tabs==2 ? "\t\t":(num_tabs>2 ? "\t\t\t":""))),p1,p2); \ +- } +-# endif +-# else /* __STDC __ */ +-# ifndef png_debug +-# define png_debug(l,m) \ +- { \ +- int num_tabs=l; \ +- char format[256]; \ +- snprintf(format,256,"%s%s%s",(num_tabs==1 ? "\t" : \ +- (num_tabs==2 ? "\t\t":(num_tabs>2 ? "\t\t\t":""))), \ +- m,PNG_STRING_NEWLINE); \ +- fprintf(PNG_DEBUG_FILE,format); \ +- } +-# endif +-# ifndef png_debug1 +-# define png_debug1(l,m,p1) \ +- { \ +- int num_tabs=l; \ +- char format[256]; \ +- snprintf(format,256,"%s%s%s",(num_tabs==1 ? "\t" : \ +- (num_tabs==2 ? "\t\t":(num_tabs>2 ? "\t\t\t":""))), \ +- m,PNG_STRING_NEWLINE); \ +- fprintf(PNG_DEBUG_FILE,format,p1); \ +- } +-# endif +-# ifndef png_debug2 +-# define png_debug2(l,m,p1,p2) \ +- { \ +- int num_tabs=l; \ +- char format[256]; \ +- snprintf(format,256,"%s%s%s",(num_tabs==1 ? "\t" : \ +- (num_tabs==2 ? "\t\t":(num_tabs>2 ? "\t\t\t":""))), \ +- m,PNG_STRING_NEWLINE); \ +- fprintf(PNG_DEBUG_FILE,format,p1,p2); \ +- } +-# endif +-# endif /* __STDC __ */ +-#endif /* (PNG_DEBUG > 1) */ +- +-#endif /* _MSC_VER */ +-#endif /* (PNG_DEBUG > 0) */ +-#endif /* PNG_DEBUG */ +-#ifndef png_debug +-#define png_debug(l, m) +-#endif +-#ifndef png_debug1 +-#define png_debug1(l, m, p1) +-#endif +-#ifndef png_debug2 +-#define png_debug2(l, m, p1, p2) +-#endif +- +-extern PNG_EXPORT(png_charp,png_get_copyright) PNGARG((png_structp png_ptr)); +-extern PNG_EXPORT(png_charp,png_get_header_ver) PNGARG((png_structp png_ptr)); +-extern PNG_EXPORT(png_charp,png_get_header_version) PNGARG((png_structp png_ptr)); +-extern PNG_EXPORT(png_charp,png_get_libpng_ver) PNGARG((png_structp png_ptr)); ++#ifdef PNG_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_structrp png_ptr)); ++PNG_EXPORT(181, png_const_charp, png_get_header_ver, ++ (png_const_structrp png_ptr)); ++PNG_EXPORT(182, png_const_charp, png_get_header_version, ++ (png_const_structrp png_ptr)); ++PNG_EXPORT(183, png_const_charp, png_get_libpng_ver, ++ (png_const_structrp png_ptr)); + + #ifdef PNG_MNG_FEATURES_SUPPORTED +-extern PNG_EXPORT(png_uint_32,png_permit_mng_features) PNGARG((png_structp +- png_ptr, png_uint_32 mng_features_permitted)); ++PNG_EXPORT(184, png_uint_32, png_permit_mng_features, (png_structrp png_ptr, ++ png_uint_32 mng_features_permitted)); + #endif + + /* For use in png_set_keep_unknown, added to version 1.2.6 */ +@@ -2719,95 +2346,151 @@ extern PNG_EXPORT(png_uint_32,png_permit_mng_features) PNGARG((png_structp + #define PNG_HANDLE_CHUNK_NEVER 1 + #define PNG_HANDLE_CHUNK_IF_SAFE 2 + #define PNG_HANDLE_CHUNK_ALWAYS 3 +- +-/* Added to version 1.2.0 */ +-#ifdef PNG_ASSEMBLER_CODE_SUPPORTED +-#ifdef PNG_MMX_CODE_SUPPORTED +-#define PNG_ASM_FLAG_MMX_SUPPORT_COMPILED 0x01 /* not user-settable */ +-#define PNG_ASM_FLAG_MMX_SUPPORT_IN_CPU 0x02 /* not user-settable */ +-#define PNG_ASM_FLAG_MMX_READ_COMBINE_ROW 0x04 +-#define PNG_ASM_FLAG_MMX_READ_INTERLACE 0x08 +-#define PNG_ASM_FLAG_MMX_READ_FILTER_SUB 0x10 +-#define PNG_ASM_FLAG_MMX_READ_FILTER_UP 0x20 +-#define PNG_ASM_FLAG_MMX_READ_FILTER_AVG 0x40 +-#define PNG_ASM_FLAG_MMX_READ_FILTER_PAETH 0x80 +-#define PNG_ASM_FLAGS_INITIALIZED 0x80000000 /* not user-settable */ +- +-#define PNG_MMX_READ_FLAGS ( PNG_ASM_FLAG_MMX_READ_COMBINE_ROW \ +- | PNG_ASM_FLAG_MMX_READ_INTERLACE \ +- | PNG_ASM_FLAG_MMX_READ_FILTER_SUB \ +- | PNG_ASM_FLAG_MMX_READ_FILTER_UP \ +- | PNG_ASM_FLAG_MMX_READ_FILTER_AVG \ +- | PNG_ASM_FLAG_MMX_READ_FILTER_PAETH ) +-#define PNG_MMX_WRITE_FLAGS ( 0 ) +- +-#define PNG_MMX_FLAGS ( PNG_ASM_FLAG_MMX_SUPPORT_COMPILED \ +- | PNG_ASM_FLAG_MMX_SUPPORT_IN_CPU \ +- | PNG_MMX_READ_FLAGS \ +- | PNG_MMX_WRITE_FLAGS ) +- +-#define PNG_SELECT_READ 1 +-#define PNG_SELECT_WRITE 2 +-#endif /* PNG_MMX_CODE_SUPPORTED */ +- +-#ifndef PNG_1_0_X +-/* pngget.c */ +-extern PNG_EXPORT(png_uint_32,png_get_mmx_flagmask) +- PNGARG((int flag_select, int *compilerID)); +- +-/* pngget.c */ +-extern PNG_EXPORT(png_uint_32,png_get_asm_flagmask) +- PNGARG((int flag_select)); +- +-/* pngget.c */ +-extern PNG_EXPORT(png_uint_32,png_get_asm_flags) +- PNGARG((png_structp png_ptr)); +- +-/* pngget.c */ +-extern PNG_EXPORT(png_byte,png_get_mmx_bitdepth_threshold) +- PNGARG((png_structp png_ptr)); +- +-/* pngget.c */ +-extern PNG_EXPORT(png_uint_32,png_get_mmx_rowbytes_threshold) +- PNGARG((png_structp png_ptr)); +- +-/* pngset.c */ +-extern PNG_EXPORT(void,png_set_asm_flags) +- PNGARG((png_structp png_ptr, png_uint_32 asm_flags)); +- +-/* pngset.c */ +-extern PNG_EXPORT(void,png_set_mmx_thresholds) +- PNGARG((png_structp png_ptr, png_byte mmx_bitdepth_threshold, +- png_uint_32 mmx_rowbytes_threshold)); +- +-#endif /* PNG_1_0_X */ +- +-#ifndef PNG_1_0_X +-/* png.c, pnggccrd.c, or pngvcrd.c */ +-extern PNG_EXPORT(int,png_mmx_support) PNGARG((void)); +-#endif /* PNG_1_0_X */ +-#endif /* PNG_ASSEMBLER_CODE_SUPPORTED */ ++#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 +-extern PNG_EXPORT(void,png_set_strip_error_numbers) PNGARG((png_structp +- png_ptr, png_uint_32 strip_mode)); ++PNG_EXPORT(185, void, png_set_strip_error_numbers, (png_structrp png_ptr, ++ png_uint_32 strip_mode)); + #endif + +-/* Added at libpng-1.2.6 */ ++/* Added in libpng-1.2.6 */ + #ifdef PNG_SET_USER_LIMITS_SUPPORTED +-extern PNG_EXPORT(void,png_set_user_limits) PNGARG((png_structp +- png_ptr, png_uint_32 user_width_max, png_uint_32 user_height_max)); +-extern PNG_EXPORT(png_uint_32,png_get_user_width_max) PNGARG((png_structp +- png_ptr)); +-extern PNG_EXPORT(png_uint_32,png_get_user_height_max) PNGARG((png_structp +- png_ptr)); +-#endif +-/* Maintainer: Put new public prototypes here ^, in libpng.3, and in +- * project defs +- */ ++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_structrp png_ptr)); ++PNG_EXPORT(188, png_uint_32, png_get_user_height_max, ++ (png_const_structrp png_ptr)); ++/* Added in libpng-1.4.0 */ ++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_structrp png_ptr)); ++/* Added in libpng-1.4.1 */ ++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_structrp png_ptr)); ++#endif ++ ++#if defined(PNG_INCH_CONVERSIONS_SUPPORTED) ++PNG_EXPORT(193, png_uint_32, png_get_pixels_per_inch, ++ (png_const_structrp png_ptr, png_const_inforp info_ptr)); ++ ++PNG_EXPORT(194, png_uint_32, png_get_x_pixels_per_inch, ++ (png_const_structrp png_ptr, png_const_inforp info_ptr)); ++ ++PNG_EXPORT(195, png_uint_32, png_get_y_pixels_per_inch, ++ (png_const_structrp png_ptr, png_const_inforp info_ptr)); ++ ++PNG_FP_EXPORT(196, float, png_get_x_offset_inches, ++ (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_const_structrp png_ptr, png_const_inforp info_ptr)) ++#endif ++ ++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_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_structrp png_ptr, ++ png_const_inforp info_ptr, png_uint_32 *res_x, png_uint_32 *res_y, ++ int *unit_type)); ++# 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_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_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 */ ++# define PNG_IO_READING 0x0001 /* currently reading */ ++# define PNG_IO_WRITING 0x0002 /* currently writing */ ++# define PNG_IO_SIGNATURE 0x0010 /* currently at the file signature */ ++# define PNG_IO_CHUNK_HDR 0x0020 /* currently at the chunk header */ ++# define PNG_IO_CHUNK_DATA 0x0040 /* currently at the chunk data */ ++# define PNG_IO_CHUNK_CRC 0x0080 /* currently at the chunk crc */ ++# define PNG_IO_MASK_OP 0x000f /* current operation: reading/writing */ ++# define PNG_IO_MASK_LOC 0x00f0 /* current location: sig/hdr/data/crc */ ++#endif /* 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 ++ * interlaced images within the application. ++ */ ++#define PNG_INTERLACE_ADAM7_PASSES 7 ++ ++/* Two macros to return the first row and first column of the original, ++ * 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) (((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 ++ * rows or columns in each 8x8 tile of the original image. ++ */ ++#define PNG_PASS_ROW_SHIFT(pass) ((pass)>2?(8-(pass))>>1:3) ++#define PNG_PASS_COL_SHIFT(pass) ((pass)>1?(7-(pass))>>1:3) ++ ++/* Hence two macros to determine the number of rows or columns in a given ++ * pass of an image given its height or width. In fact these macros may ++ * return non-zero even though the sub-image is empty, because the other ++ * dimension may be empty for a small image. ++ */ ++#define PNG_PASS_ROWS(height, pass) (((height)+(((1<>PNG_PASS_ROW_SHIFT(pass)) ++#define PNG_PASS_COLS(width, pass) (((width)+(((1<>PNG_PASS_COL_SHIFT(pass)) ++ ++/* For the reader row callbacks (both progressive and sequential) it is ++ * 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(y_in, pass) \ ++ (((y_in)<>(((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) ++#define PNG_COL_IN_INTERLACE_PASS(x, pass) \ ++ ((PNG_PASS_MASK(pass,1) >> ((x)&7)) & 1) + + #ifdef PNG_READ_COMPOSITE_NODIV_SUPPORTED + /* With these routines we avoid an integer divide, which will be slower on +@@ -2822,963 +2505,739 @@ extern PNG_EXPORT(png_uint_32,png_get_user_height_max) PNGARG((png_structp + * [Optimized code by Greg Roelofs and Mark Adler...blame us for bugs. :-) ] + */ + +- /* fg and bg should be in `gamma 1.0' space; alpha is the opacity */ ++ /* fg and bg should be in `gamma 1.0' space; alpha is the opacity */ + +-# define png_composite(composite, fg, alpha, bg) \ +- { png_uint_16 temp = (png_uint_16)((png_uint_16)(fg) * (png_uint_16)(alpha) \ +- + (png_uint_16)(bg)*(png_uint_16)(255 - \ +- (png_uint_16)(alpha)) + (png_uint_16)128); \ +- (composite) = (png_byte)((temp + (temp >> 8)) >> 8); } ++# define png_composite(composite, fg, alpha, bg) \ ++ { \ ++ png_uint_16 temp = (png_uint_16)((png_uint_16)(fg) \ ++ * (png_uint_16)(alpha) \ ++ + (png_uint_16)(bg)*(png_uint_16)(255 \ ++ - (png_uint_16)(alpha)) + 128); \ ++ (composite) = (png_byte)(((temp + (temp >> 8)) >> 8) & 0xff); \ ++ } + +-# define png_composite_16(composite, fg, alpha, bg) \ +- { png_uint_32 temp = (png_uint_32)((png_uint_32)(fg) * (png_uint_32)(alpha) \ +- + (png_uint_32)(bg)*(png_uint_32)(65535L - \ +- (png_uint_32)(alpha)) + (png_uint_32)32768L); \ +- (composite) = (png_uint_16)((temp + (temp >> 16)) >> 16); } ++# 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)*(65535 \ ++ - (png_uint_32)(alpha)) + 32768); \ ++ (composite) = (png_uint_16)(0xffff & ((temp + (temp >> 16)) >> 16)); \ ++ } + + #else /* Standard method using integer division */ + +-# define png_composite(composite, fg, alpha, bg) \ +- (composite) = (png_byte)(((png_uint_16)(fg) * (png_uint_16)(alpha) + \ +- (png_uint_16)(bg) * (png_uint_16)(255 - (png_uint_16)(alpha)) + \ +- (png_uint_16)127) / 255) +- +-# define png_composite_16(composite, fg, alpha, bg) \ +- (composite) = (png_uint_16)(((png_uint_32)(fg) * (png_uint_32)(alpha) + \ +- (png_uint_32)(bg)*(png_uint_32)(65535L - (png_uint_32)(alpha)) + \ +- (png_uint_32)32767) / (png_uint_32)65535L) +- +-#endif /* PNG_READ_COMPOSITE_NODIV_SUPPORTED */ +- +-/* Inline macros to do direct reads of bytes from the input buffer. These +- * require that you are using an architecture that uses PNG byte ordering +- * (MSB first) and supports unaligned data storage. I think that PowerPC +- * in big-endian mode and 680x0 are the only ones that will support this. +- * The x86 line of processors definitely do not. The png_get_int_32() +- * routine also assumes we are using two's complement format for negative +- * values, which is almost certainly true. +- */ +-#ifdef PNG_READ_BIG_ENDIAN_SUPPORTED +-# define png_get_uint_32(buf) ( *((png_uint_32p) (buf))) +-# define png_get_uint_16(buf) ( *((png_uint_16p) (buf))) +-# define png_get_int_32(buf) ( *((png_int_32p) (buf))) +-#else +-extern PNG_EXPORT(png_uint_32,png_get_uint_32) PNGARG((png_bytep buf)); +-extern PNG_EXPORT(png_uint_16,png_get_uint_16) PNGARG((png_bytep buf)); +-extern PNG_EXPORT(png_int_32,png_get_int_32) PNGARG((png_bytep buf)); +-#endif /* !PNG_READ_BIG_ENDIAN_SUPPORTED */ +-extern PNG_EXPORT(png_uint_32,png_get_uint_31) +- PNGARG((png_structp png_ptr, png_bytep buf)); +-/* No png_get_int_16 -- may be added if there's a real need for it. */ +- +-/* Place a 32-bit number into a buffer in PNG byte order (big-endian). +- */ +-extern PNG_EXPORT(void,png_save_uint_32) +- PNGARG((png_bytep buf, png_uint_32 i)); +-extern PNG_EXPORT(void,png_save_int_32) +- PNGARG((png_bytep buf, png_int_32 i)); +- +-/* Place a 16-bit number into a buffer in PNG byte order. +- * The parameter is declared unsigned int, not png_uint_16, +- * just to avoid potential problems on pre-ANSI C compilers. +- */ +-extern PNG_EXPORT(void,png_save_uint_16) +- PNGARG((png_bytep buf, unsigned int i)); +-/* No png_save_int_16 -- may be added if there's a real need for it. */ ++# define png_composite(composite, fg, alpha, bg) \ ++ (composite) = \ ++ (png_byte)(0xff & (((png_uint_16)(fg) * (png_uint_16)(alpha) + \ ++ (png_uint_16)(bg) * (png_uint_16)(255 - (png_uint_16)(alpha)) + \ ++ 127) / 255)) + +-/* ************************************************************************* */ +- +-/* These next functions are used internally in the code. They generally +- * shouldn't be used unless you are writing code to add or replace some +- * functionality in libpng. More information about most functions can +- * be found in the files where the functions are located. +- */ +- +- +-/* Various modes of operation, that are visible to applications because +- * they are used for unknown chunk location. +- */ +-#define PNG_HAVE_IHDR 0x01 +-#define PNG_HAVE_PLTE 0x02 +-#define PNG_HAVE_IDAT 0x04 +-#define PNG_AFTER_IDAT 0x08 /* Have complete zlib datastream */ +-#define PNG_HAVE_IEND 0x10 +- +-#ifdef PNG_INTERNAL +- +-/* More modes of operation. Note that after an init, mode is set to +- * zero automatically when the structure is created. +- */ +-#define PNG_HAVE_gAMA 0x20 +-#define PNG_HAVE_cHRM 0x40 +-#define PNG_HAVE_sRGB 0x80 +-#define PNG_HAVE_CHUNK_HEADER 0x100 +-#define PNG_WROTE_tIME 0x200 +-#define PNG_WROTE_INFO_BEFORE_PLTE 0x400 +-#define PNG_BACKGROUND_IS_GRAY 0x800 +-#define PNG_HAVE_PNG_SIGNATURE 0x1000 +-#define PNG_HAVE_CHUNK_AFTER_IDAT 0x2000 /* Have another chunk after IDAT */ +- +-/* Flags for the transformations the PNG library does on the image data */ +-#define PNG_BGR 0x0001 +-#define PNG_INTERLACE 0x0002 +-#define PNG_PACK 0x0004 +-#define PNG_SHIFT 0x0008 +-#define PNG_SWAP_BYTES 0x0010 +-#define PNG_INVERT_MONO 0x0020 +-#define PNG_DITHER 0x0040 +-#define PNG_BACKGROUND 0x0080 +-#define PNG_BACKGROUND_EXPAND 0x0100 +- /* 0x0200 unused */ +-#define PNG_16_TO_8 0x0400 +-#define PNG_RGBA 0x0800 +-#define PNG_EXPAND 0x1000 +-#define PNG_GAMMA 0x2000 +-#define PNG_GRAY_TO_RGB 0x4000 +-#define PNG_FILLER 0x8000L +-#define PNG_PACKSWAP 0x10000L +-#define PNG_SWAP_ALPHA 0x20000L +-#define PNG_STRIP_ALPHA 0x40000L +-#define PNG_INVERT_ALPHA 0x80000L +-#define PNG_USER_TRANSFORM 0x100000L +-#define PNG_RGB_TO_GRAY_ERR 0x200000L +-#define PNG_RGB_TO_GRAY_WARN 0x400000L +-#define PNG_RGB_TO_GRAY 0x600000L /* two bits, RGB_TO_GRAY_ERR|WARN */ +- /* 0x800000L Unused */ +-#define PNG_ADD_ALPHA 0x1000000L /* Added to libpng-1.2.7 */ +-#define PNG_EXPAND_tRNS 0x2000000L /* Added to libpng-1.2.9 */ +-#define PNG_PREMULTIPLY_ALPHA 0x4000000L /* Added to libpng-1.2.41 */ +- /* by volker */ +- /* 0x8000000L unused */ +- /* 0x10000000L unused */ +- /* 0x20000000L unused */ +- /* 0x40000000L unused */ +- +-/* Flags for png_create_struct */ +-#define PNG_STRUCT_PNG 0x0001 +-#define PNG_STRUCT_INFO 0x0002 +- +-/* Scaling factor for filter heuristic weighting calculations */ +-#define PNG_WEIGHT_SHIFT 8 +-#define PNG_WEIGHT_FACTOR (1<<(PNG_WEIGHT_SHIFT)) +-#define PNG_COST_SHIFT 3 +-#define PNG_COST_FACTOR (1<<(PNG_COST_SHIFT)) +- +-/* Flags for the png_ptr->flags rather than declaring a byte for each one */ +-#define PNG_FLAG_ZLIB_CUSTOM_STRATEGY 0x0001 +-#define PNG_FLAG_ZLIB_CUSTOM_LEVEL 0x0002 +-#define PNG_FLAG_ZLIB_CUSTOM_MEM_LEVEL 0x0004 +-#define PNG_FLAG_ZLIB_CUSTOM_WINDOW_BITS 0x0008 +-#define PNG_FLAG_ZLIB_CUSTOM_METHOD 0x0010 +-#define PNG_FLAG_ZLIB_FINISHED 0x0020 +-#define PNG_FLAG_ROW_INIT 0x0040 +-#define PNG_FLAG_FILLER_AFTER 0x0080 +-#define PNG_FLAG_CRC_ANCILLARY_USE 0x0100 +-#define PNG_FLAG_CRC_ANCILLARY_NOWARN 0x0200 +-#define PNG_FLAG_CRC_CRITICAL_USE 0x0400 +-#define PNG_FLAG_CRC_CRITICAL_IGNORE 0x0800 +-#define PNG_FLAG_FREE_PLTE 0x1000 +-#define PNG_FLAG_FREE_TRNS 0x2000 +-#define PNG_FLAG_FREE_HIST 0x4000 +-#define PNG_FLAG_KEEP_UNKNOWN_CHUNKS 0x8000L +-#define PNG_FLAG_KEEP_UNSAFE_CHUNKS 0x10000L +-#define PNG_FLAG_LIBRARY_MISMATCH 0x20000L +-#define PNG_FLAG_STRIP_ERROR_NUMBERS 0x40000L +-#define PNG_FLAG_STRIP_ERROR_TEXT 0x80000L +-#define PNG_FLAG_MALLOC_NULL_MEM_OK 0x100000L +-#define PNG_FLAG_ADD_ALPHA 0x200000L /* Added to libpng-1.2.8 */ +-#define PNG_FLAG_STRIP_ALPHA 0x400000L /* Added to libpng-1.2.8 */ +- /* 0x800000L unused */ +- /* 0x1000000L unused */ +- /* 0x2000000L unused */ +- /* 0x4000000L unused */ +- /* 0x8000000L unused */ +- /* 0x10000000L unused */ +- /* 0x20000000L unused */ +- /* 0x40000000L unused */ +- +-#define PNG_FLAG_CRC_ANCILLARY_MASK (PNG_FLAG_CRC_ANCILLARY_USE | \ +- PNG_FLAG_CRC_ANCILLARY_NOWARN) +- +-#define PNG_FLAG_CRC_CRITICAL_MASK (PNG_FLAG_CRC_CRITICAL_USE | \ +- PNG_FLAG_CRC_CRITICAL_IGNORE) +- +-#define PNG_FLAG_CRC_MASK (PNG_FLAG_CRC_ANCILLARY_MASK | \ +- PNG_FLAG_CRC_CRITICAL_MASK) +- +-/* Save typing and make code easier to understand */ +- +-#define PNG_COLOR_DIST(c1, c2) (abs((int)((c1).red) - (int)((c2).red)) + \ +- abs((int)((c1).green) - (int)((c2).green)) + \ +- abs((int)((c1).blue) - (int)((c2).blue))) +- +-/* Added to libpng-1.2.6 JB */ +-#define PNG_ROWBYTES(pixel_bits, width) \ +- ((pixel_bits) >= 8 ? \ +- ((width) * (((png_uint_32)(pixel_bits)) >> 3)) : \ +- (( ((width) * ((png_uint_32)(pixel_bits))) + 7) >> 3) ) +- +-/* PNG_OUT_OF_RANGE returns true if value is outside the range +- * ideal-delta..ideal+delta. Each argument is evaluated twice. +- * "ideal" and "delta" should be constants, normally simple +- * integers, "value" a variable. Added to libpng-1.2.6 JB +- */ +-#define PNG_OUT_OF_RANGE(value, ideal, delta) \ +- ( (value) < (ideal)-(delta) || (value) > (ideal)+(delta) ) +- +-/* Variables declared in png.c - only it needs to define PNG_NO_EXTERN */ +-#if !defined(PNG_NO_EXTERN) || defined(PNG_ALWAYS_EXTERN) +-/* Place to hold the signature string for a PNG file. */ +-#ifdef PNG_USE_GLOBAL_ARRAYS +- PNG_EXPORT_VAR (PNG_CONST png_byte FARDATA) png_sig[8]; +-#else +-#endif +-#endif /* PNG_NO_EXTERN */ +- +-/* Constant strings for known chunk types. If you need to add a chunk, +- * define the name here, and add an invocation of the macro in png.c and +- * wherever it's needed. +- */ +-#define PNG_IHDR png_byte png_IHDR[5] = { 73, 72, 68, 82, '\0'} +-#define PNG_IDAT png_byte png_IDAT[5] = { 73, 68, 65, 84, '\0'} +-#define PNG_IEND png_byte png_IEND[5] = { 73, 69, 78, 68, '\0'} +-#define PNG_PLTE png_byte png_PLTE[5] = { 80, 76, 84, 69, '\0'} +-#define PNG_bKGD png_byte png_bKGD[5] = { 98, 75, 71, 68, '\0'} +-#define PNG_cHRM png_byte png_cHRM[5] = { 99, 72, 82, 77, '\0'} +-#define PNG_gAMA png_byte png_gAMA[5] = {103, 65, 77, 65, '\0'} +-#define PNG_hIST png_byte png_hIST[5] = {104, 73, 83, 84, '\0'} +-#define PNG_iCCP png_byte png_iCCP[5] = {105, 67, 67, 80, '\0'} +-#define PNG_iTXt png_byte png_iTXt[5] = {105, 84, 88, 116, '\0'} +-#define PNG_oFFs png_byte png_oFFs[5] = {111, 70, 70, 115, '\0'} +-#define PNG_pCAL png_byte png_pCAL[5] = {112, 67, 65, 76, '\0'} +-#define PNG_sCAL png_byte png_sCAL[5] = {115, 67, 65, 76, '\0'} +-#define PNG_pHYs png_byte png_pHYs[5] = {112, 72, 89, 115, '\0'} +-#define PNG_sBIT png_byte png_sBIT[5] = {115, 66, 73, 84, '\0'} +-#define PNG_sPLT png_byte png_sPLT[5] = {115, 80, 76, 84, '\0'} +-#define PNG_sRGB png_byte png_sRGB[5] = {115, 82, 71, 66, '\0'} +-#define PNG_tEXt png_byte png_tEXt[5] = {116, 69, 88, 116, '\0'} +-#define PNG_tIME png_byte png_tIME[5] = {116, 73, 77, 69, '\0'} +-#define PNG_tRNS png_byte png_tRNS[5] = {116, 82, 78, 83, '\0'} +-#define PNG_zTXt png_byte png_zTXt[5] = {122, 84, 88, 116, '\0'} +- +-#ifdef PNG_USE_GLOBAL_ARRAYS +-PNG_EXPORT_VAR (png_byte FARDATA) png_IHDR[5]; +-PNG_EXPORT_VAR (png_byte FARDATA) png_IDAT[5]; +-PNG_EXPORT_VAR (png_byte FARDATA) png_IEND[5]; +-PNG_EXPORT_VAR (png_byte FARDATA) png_PLTE[5]; +-PNG_EXPORT_VAR (png_byte FARDATA) png_bKGD[5]; +-PNG_EXPORT_VAR (png_byte FARDATA) png_cHRM[5]; +-PNG_EXPORT_VAR (png_byte FARDATA) png_gAMA[5]; +-PNG_EXPORT_VAR (png_byte FARDATA) png_hIST[5]; +-PNG_EXPORT_VAR (png_byte FARDATA) png_iCCP[5]; +-PNG_EXPORT_VAR (png_byte FARDATA) png_iTXt[5]; +-PNG_EXPORT_VAR (png_byte FARDATA) png_oFFs[5]; +-PNG_EXPORT_VAR (png_byte FARDATA) png_pCAL[5]; +-PNG_EXPORT_VAR (png_byte FARDATA) png_sCAL[5]; +-PNG_EXPORT_VAR (png_byte FARDATA) png_pHYs[5]; +-PNG_EXPORT_VAR (png_byte FARDATA) png_sBIT[5]; +-PNG_EXPORT_VAR (png_byte FARDATA) png_sPLT[5]; +-PNG_EXPORT_VAR (png_byte FARDATA) png_sRGB[5]; +-PNG_EXPORT_VAR (png_byte FARDATA) png_tEXt[5]; +-PNG_EXPORT_VAR (png_byte FARDATA) png_tIME[5]; +-PNG_EXPORT_VAR (png_byte FARDATA) png_tRNS[5]; +-PNG_EXPORT_VAR (png_byte FARDATA) png_zTXt[5]; +-#endif /* PNG_USE_GLOBAL_ARRAYS */ +- +-#if defined(PNG_1_0_X) || defined (PNG_1_2_X) +-/* Initialize png_ptr struct for reading, and allocate any other memory. +- * (old interface - DEPRECATED - use png_create_read_struct instead). +- */ +-extern PNG_EXPORT(void,png_read_init) PNGARG((png_structp png_ptr)) +- PNG_DEPRECATED; +-#undef png_read_init +-#define png_read_init(png_ptr) png_read_init_3(&png_ptr, \ +- PNG_LIBPNG_VER_STRING, png_sizeof(png_struct)); +-#endif +- +-extern PNG_EXPORT(void,png_read_init_3) PNGARG((png_structpp ptr_ptr, +- png_const_charp user_png_ver, png_size_t png_struct_size)); +-#if defined(PNG_1_0_X) || defined (PNG_1_2_X) +-extern PNG_EXPORT(void,png_read_init_2) PNGARG((png_structp png_ptr, +- png_const_charp user_png_ver, png_size_t png_struct_size, png_size_t +- png_info_size)); +-#endif +- +-#if defined(PNG_1_0_X) || defined (PNG_1_2_X) +-/* Initialize png_ptr struct for writing, and allocate any other memory. +- * (old interface - DEPRECATED - use png_create_write_struct instead). +- */ +-extern PNG_EXPORT(void,png_write_init) PNGARG((png_structp png_ptr)) +- PNG_DEPRECATED; +-#undef png_write_init +-#define png_write_init(png_ptr) png_write_init_3(&png_ptr, \ +- PNG_LIBPNG_VER_STRING, png_sizeof(png_struct)); +-#endif +- +-extern PNG_EXPORT(void,png_write_init_3) PNGARG((png_structpp ptr_ptr, +- png_const_charp user_png_ver, png_size_t png_struct_size)); +-extern PNG_EXPORT(void,png_write_init_2) PNGARG((png_structp png_ptr, +- png_const_charp user_png_ver, png_size_t png_struct_size, png_size_t +- png_info_size)); +- +-/* Allocate memory for an internal libpng struct */ +-PNG_EXTERN png_voidp png_create_struct PNGARG((int type)) PNG_PRIVATE; +- +-/* Free memory from internal libpng struct */ +-PNG_EXTERN void png_destroy_struct PNGARG((png_voidp struct_ptr)) PNG_PRIVATE; +- +-PNG_EXTERN png_voidp png_create_struct_2 PNGARG((int type, png_malloc_ptr +- malloc_fn, png_voidp mem_ptr)) PNG_PRIVATE; +-PNG_EXTERN void png_destroy_struct_2 PNGARG((png_voidp struct_ptr, +- png_free_ptr free_fn, png_voidp mem_ptr)) PNG_PRIVATE; +- +-/* Free any memory that info_ptr points to and reset struct. */ +-PNG_EXTERN void png_info_destroy PNGARG((png_structp png_ptr, +- png_infop info_ptr)) PNG_PRIVATE; +- +-#ifndef PNG_1_0_X +-/* Function to allocate memory for zlib. */ +-PNG_EXTERN voidpf png_zalloc PNGARG((voidpf png_ptr, uInt items, +- uInt size)) PNG_PRIVATE; +- +-/* Function to free memory for zlib */ +-PNG_EXTERN void png_zfree PNGARG((voidpf png_ptr, voidpf ptr)) PNG_PRIVATE; +- +-#ifdef PNG_SIZE_T +-/* Function to convert a sizeof an item to png_sizeof item */ +- PNG_EXTERN png_size_t PNGAPI png_convert_size PNGARG((size_t size)) +- PNG_PRIVATE; +-#endif +- +-/* Next four functions are used internally as callbacks. PNGAPI is required +- * but not PNG_EXPORT. PNGAPI added at libpng version 1.2.3. +- */ +- +-PNG_EXTERN void PNGAPI png_default_read_data PNGARG((png_structp png_ptr, +- png_bytep data, png_size_t length)) PNG_PRIVATE; ++# define png_composite_16(composite, fg, alpha, bg) \ ++ (composite) = \ ++ (png_uint_16)(0xffff & (((png_uint_32)(fg) * (png_uint_32)(alpha) + \ ++ (png_uint_32)(bg)*(png_uint_32)(65535 - (png_uint_32)(alpha)) + \ ++ 32767) / 65535)) ++#endif /* READ_COMPOSITE_NODIV */ + +-#ifdef PNG_PROGRESSIVE_READ_SUPPORTED +-PNG_EXTERN void PNGAPI png_push_fill_buffer PNGARG((png_structp png_ptr, +- png_bytep buffer, png_size_t length)) PNG_PRIVATE; ++#ifdef PNG_READ_INT_FUNCTIONS_SUPPORTED ++PNG_EXPORT(201, png_uint_32, png_get_uint_32, (png_const_bytep buf)); ++PNG_EXPORT(202, png_uint_16, png_get_uint_16, (png_const_bytep buf)); ++PNG_EXPORT(203, png_int_32, png_get_int_32, (png_const_bytep buf)); + #endif + +-PNG_EXTERN void PNGAPI png_default_write_data PNGARG((png_structp png_ptr, +- png_bytep data, png_size_t length)) PNG_PRIVATE; ++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. */ + +-#ifdef PNG_WRITE_FLUSH_SUPPORTED +-#ifdef PNG_STDIO_SUPPORTED +-PNG_EXTERN void PNGAPI png_default_flush PNGARG((png_structp png_ptr)) +- PNG_PRIVATE; ++/* Place a 32-bit number into a buffer in PNG byte order (big-endian). */ ++#ifdef PNG_WRITE_INT_FUNCTIONS_SUPPORTED ++PNG_EXPORT(205, void, png_save_uint_32, (png_bytep buf, png_uint_32 i)); + #endif +-#endif +-#else /* PNG_1_0_X */ +-#ifdef PNG_PROGRESSIVE_READ_SUPPORTED +-PNG_EXTERN void png_push_fill_buffer PNGARG((png_structp png_ptr, +- png_bytep buffer, png_size_t length)) PNG_PRIVATE; +-#endif +-#endif /* PNG_1_0_X */ +- +-/* Reset the CRC variable */ +-PNG_EXTERN void png_reset_crc PNGARG((png_structp png_ptr)) PNG_PRIVATE; +- +-/* Write the "data" buffer to whatever output you are using. */ +-PNG_EXTERN void png_write_data PNGARG((png_structp png_ptr, png_bytep data, +- png_size_t length)) PNG_PRIVATE; +- +-/* Read data from whatever input you are using into the "data" buffer */ +-PNG_EXTERN void png_read_data PNGARG((png_structp png_ptr, png_bytep data, +- png_size_t length)) PNG_PRIVATE; +- +-/* Read bytes into buf, and update png_ptr->crc */ +-PNG_EXTERN void png_crc_read PNGARG((png_structp png_ptr, png_bytep buf, +- png_size_t length)) PNG_PRIVATE; +- +-/* Decompress data in a chunk that uses compression */ +-#if defined(PNG_zTXt_SUPPORTED) || defined(PNG_iTXt_SUPPORTED) || \ +- defined(PNG_iCCP_SUPPORTED) || defined(PNG_sPLT_SUPPORTED) +-PNG_EXTERN void png_decompress_chunk PNGARG((png_structp png_ptr, +- int comp_type, png_size_t chunklength, +- png_size_t prefix_length, png_size_t *data_length)) PNG_PRIVATE; ++#ifdef PNG_SAVE_INT_32_SUPPORTED ++PNG_EXPORT(206, void, png_save_int_32, (png_bytep buf, png_int_32 i)); + #endif + +-/* Read "skip" bytes, read the file crc, and (optionally) verify png_ptr->crc */ +-PNG_EXTERN int png_crc_finish PNGARG((png_structp png_ptr, png_uint_32 skip) +- PNG_PRIVATE); +- +-/* Read the CRC from the file and compare it to the libpng calculated CRC */ +-PNG_EXTERN int png_crc_error PNGARG((png_structp png_ptr)) PNG_PRIVATE; +- +-/* Calculate the CRC over a section of data. Note that we are only +- * passing a maximum of 64K on systems that have this as a memory limit, +- * since this is the maximum buffer size we can specify. ++/* 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. + */ +-PNG_EXTERN void png_calculate_crc PNGARG((png_structp png_ptr, png_bytep ptr, +- png_size_t length)) PNG_PRIVATE; +- +-#ifdef PNG_WRITE_FLUSH_SUPPORTED +-PNG_EXTERN void png_flush PNGARG((png_structp png_ptr)) PNG_PRIVATE; ++#ifdef PNG_WRITE_INT_FUNCTIONS_SUPPORTED ++PNG_EXPORT(207, void, png_save_uint_16, (png_bytep buf, unsigned int i)); ++/* No png_save_int_16 -- may be added if there's a real need for it. */ + #endif + +-/* Simple function to write the signature */ +-PNG_EXTERN void png_write_sig PNGARG((png_structp png_ptr)) PNG_PRIVATE; +- +-/* Write various chunks */ +- +-/* Write the IHDR chunk, and update the png_struct with the necessary +- * information. ++#ifdef PNG_USE_READ_MACROS ++/* Inline macros to do direct reads of bytes from the input buffer. ++ * The png_get_int_32() routine assumes we are using two's complement ++ * format for negative values, which is almost certainly true. + */ +-PNG_EXTERN void png_write_IHDR PNGARG((png_structp png_ptr, png_uint_32 width, +- png_uint_32 height, +- int bit_depth, int color_type, int compression_method, int filter_method, +- int interlace_method)) PNG_PRIVATE; +- +-PNG_EXTERN void png_write_PLTE PNGARG((png_structp png_ptr, png_colorp palette, +- png_uint_32 num_pal)) PNG_PRIVATE; +- +-PNG_EXTERN void png_write_IDAT PNGARG((png_structp png_ptr, png_bytep data, +- png_size_t length)) PNG_PRIVATE; ++# define PNG_get_uint_32(buf) \ ++ (((png_uint_32)(*(buf)) << 24) + \ ++ ((png_uint_32)(*((buf) + 1)) << 16) + \ ++ ((png_uint_32)(*((buf) + 2)) << 8) + \ ++ ((png_uint_32)(*((buf) + 3)))) + +-PNG_EXTERN void png_write_IEND PNGARG((png_structp png_ptr)) PNG_PRIVATE; +- +-#ifdef PNG_WRITE_gAMA_SUPPORTED +-#ifdef PNG_FLOATING_POINT_SUPPORTED +-PNG_EXTERN void png_write_gAMA PNGARG((png_structp png_ptr, double file_gamma)) +- PNG_PRIVATE; +-#endif +-#ifdef PNG_FIXED_POINT_SUPPORTED +-PNG_EXTERN void png_write_gAMA_fixed PNGARG((png_structp png_ptr, +- png_fixed_point file_gamma)) PNG_PRIVATE; +-#endif +-#endif +- +-#ifdef PNG_WRITE_sBIT_SUPPORTED +-PNG_EXTERN void png_write_sBIT PNGARG((png_structp png_ptr, png_color_8p sbit, +- int color_type)) PNG_PRIVATE; +-#endif +- +-#ifdef PNG_WRITE_cHRM_SUPPORTED +-#ifdef PNG_FLOATING_POINT_SUPPORTED +-PNG_EXTERN void png_write_cHRM PNGARG((png_structp png_ptr, +- double white_x, double white_y, +- double red_x, double red_y, double green_x, double green_y, +- double blue_x, double blue_y)) PNG_PRIVATE; +-#endif +-#ifdef PNG_FIXED_POINT_SUPPORTED +-PNG_EXTERN void png_write_cHRM_fixed PNGARG((png_structp png_ptr, +- png_fixed_point int_white_x, png_fixed_point int_white_y, +- png_fixed_point int_red_x, png_fixed_point int_red_y, png_fixed_point +- int_green_x, png_fixed_point int_green_y, png_fixed_point int_blue_x, +- png_fixed_point int_blue_y)) PNG_PRIVATE; +-#endif +-#endif +- +-#ifdef PNG_WRITE_sRGB_SUPPORTED +-PNG_EXTERN void png_write_sRGB PNGARG((png_structp png_ptr, +- int intent)) PNG_PRIVATE; +-#endif +- +-#ifdef PNG_WRITE_iCCP_SUPPORTED +-PNG_EXTERN void png_write_iCCP PNGARG((png_structp png_ptr, +- png_charp name, int compression_type, +- png_charp profile, int proflen)) PNG_PRIVATE; +- /* Note to maintainer: profile should be png_bytep */ +-#endif +- +-#ifdef PNG_WRITE_sPLT_SUPPORTED +-PNG_EXTERN void png_write_sPLT PNGARG((png_structp png_ptr, +- png_sPLT_tp palette)) PNG_PRIVATE; +-#endif +- +-#ifdef PNG_WRITE_tRNS_SUPPORTED +-PNG_EXTERN void png_write_tRNS PNGARG((png_structp png_ptr, png_bytep trans, +- png_color_16p values, int number, int color_type)) PNG_PRIVATE; +-#endif +- +-#ifdef PNG_WRITE_bKGD_SUPPORTED +-PNG_EXTERN void png_write_bKGD PNGARG((png_structp png_ptr, +- png_color_16p values, int color_type)) PNG_PRIVATE; +-#endif +- +-#ifdef PNG_WRITE_hIST_SUPPORTED +-PNG_EXTERN void png_write_hIST PNGARG((png_structp png_ptr, png_uint_16p hist, +- int num_hist)) PNG_PRIVATE; +-#endif +- +-#if defined(PNG_WRITE_TEXT_SUPPORTED) || defined(PNG_WRITE_pCAL_SUPPORTED) || \ +- defined(PNG_WRITE_iCCP_SUPPORTED) || defined(PNG_WRITE_sPLT_SUPPORTED) +-PNG_EXTERN png_size_t png_check_keyword PNGARG((png_structp png_ptr, +- png_charp key, png_charpp new_key)) PNG_PRIVATE; +-#endif +- +-#ifdef PNG_WRITE_tEXt_SUPPORTED +-PNG_EXTERN void png_write_tEXt PNGARG((png_structp png_ptr, png_charp key, +- png_charp text, png_size_t text_len)) PNG_PRIVATE; +-#endif +- +-#ifdef PNG_WRITE_zTXt_SUPPORTED +-PNG_EXTERN void png_write_zTXt PNGARG((png_structp png_ptr, png_charp key, +- png_charp text, png_size_t text_len, int compression)) PNG_PRIVATE; +-#endif +- +-#ifdef PNG_WRITE_iTXt_SUPPORTED +-PNG_EXTERN void png_write_iTXt PNGARG((png_structp png_ptr, +- int compression, png_charp key, png_charp lang, png_charp lang_key, +- png_charp text)) PNG_PRIVATE; +-#endif +- +-#ifdef PNG_TEXT_SUPPORTED /* Added at version 1.0.14 and 1.2.4 */ +-PNG_EXTERN int png_set_text_2 PNGARG((png_structp png_ptr, +- png_infop info_ptr, png_textp text_ptr, int num_text)) PNG_PRIVATE; +-#endif +- +-#ifdef PNG_WRITE_oFFs_SUPPORTED +-PNG_EXTERN void png_write_oFFs PNGARG((png_structp png_ptr, +- png_int_32 x_offset, png_int_32 y_offset, int unit_type)) PNG_PRIVATE; +-#endif +- +-#ifdef PNG_WRITE_pCAL_SUPPORTED +-PNG_EXTERN void png_write_pCAL PNGARG((png_structp png_ptr, png_charp purpose, +- png_int_32 X0, png_int_32 X1, int type, int nparams, +- png_charp units, png_charpp params)) PNG_PRIVATE; +-#endif +- +-#ifdef PNG_WRITE_pHYs_SUPPORTED +-PNG_EXTERN void png_write_pHYs PNGARG((png_structp png_ptr, +- png_uint_32 x_pixels_per_unit, png_uint_32 y_pixels_per_unit, +- int unit_type)) PNG_PRIVATE; +-#endif +- +-#ifdef PNG_WRITE_tIME_SUPPORTED +-PNG_EXTERN void png_write_tIME PNGARG((png_structp png_ptr, +- png_timep mod_time)) PNG_PRIVATE; +-#endif +- +-#ifdef PNG_WRITE_sCAL_SUPPORTED +-#if defined(PNG_FLOATING_POINT_SUPPORTED) && !defined(PNG_NO_STDIO) +-PNG_EXTERN void png_write_sCAL PNGARG((png_structp png_ptr, +- int unit, double width, double height)) PNG_PRIVATE; ++ /* 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) \ ++ ((png_uint_16) \ ++ (((unsigned int)(*(buf)) << 8) + \ ++ ((unsigned int)(*((buf) + 1))))) ++ ++# define PNG_get_int_32(buf) \ ++ ((png_int_32)((*(buf) & 0x80) \ ++ ? -((png_int_32)(((png_get_uint_32(buf)^0xffffffffU)+1U)&0x7fffffffU)) \ ++ : (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_FIXED_POINT_SUPPORTED +-PNG_EXTERN void png_write_sCAL_s PNGARG((png_structp png_ptr, +- int unit, png_charp width, png_charp height)) PNG_PRIVATE; +-#endif +-#endif +-#endif +- +-/* Called when finished processing a row of data */ +-PNG_EXTERN void png_write_finish_row PNGARG((png_structp png_ptr)) PNG_PRIVATE; +- +-/* Internal use only. Called before first row of data */ +-PNG_EXTERN void png_write_start_row PNGARG((png_structp png_ptr)) PNG_PRIVATE; +- +-#ifdef PNG_READ_GAMMA_SUPPORTED +-PNG_EXTERN void png_build_gamma_table PNGARG((png_structp png_ptr)) PNG_PRIVATE; ++# 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 + +-/* Combine a row of data, dealing with alpha, etc. if requested */ +-PNG_EXTERN void png_combine_row PNGARG((png_structp png_ptr, png_bytep row, +- int mask)) PNG_PRIVATE; ++#ifdef PNG_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 */ + +-#ifdef PNG_READ_INTERLACING_SUPPORTED +-/* Expand an interlaced row */ +-/* OLD pre-1.0.9 interface: +-PNG_EXTERN void png_do_read_interlace PNGARG((png_row_infop row_info, +- png_bytep row, int pass, png_uint_32 transformations)) PNG_PRIVATE; ++/******************************************************************************* ++ * Section 5: 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 accommodate 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, set the ++ * version field to PNG_IMAGE_VERSION and the 'opaque' pointer to NULL ++ * (this is REQUIRED, your program may crash if you don't do it.) ++ * 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: + */ +-PNG_EXTERN void png_do_read_interlace PNGARG((png_structp png_ptr)) PNG_PRIVATE; +-#endif +- +-/* GRR TO DO (2.0 or whenever): simplify other internal calling interfaces */ +- +-#ifdef PNG_WRITE_INTERLACING_SUPPORTED +-/* Grab pixels out of a row for an interlaced pass */ +-PNG_EXTERN void png_do_write_interlace PNGARG((png_row_infop row_info, +- png_bytep row, int pass)) PNG_PRIVATE; +-#endif +- +-/* Unfilter a row */ +-PNG_EXTERN void png_read_filter_row PNGARG((png_structp png_ptr, +- png_row_infop row_info, png_bytep row, png_bytep prev_row, +- int filter)) PNG_PRIVATE; +- +-/* Choose the best filter to use and filter the row data */ +-PNG_EXTERN void png_write_find_filter PNGARG((png_structp png_ptr, +- png_row_infop row_info)) PNG_PRIVATE; +- +-/* Write out the filtered row. */ +-PNG_EXTERN void png_write_filtered_row PNGARG((png_structp png_ptr, +- png_bytep filtered_row)) PNG_PRIVATE; +-/* Finish a row while reading, dealing with interlacing passes, etc. */ +-PNG_EXTERN void png_read_finish_row PNGARG((png_structp png_ptr)); +- +-/* Initialize the row buffers, etc. */ +-PNG_EXTERN void png_read_start_row PNGARG((png_structp png_ptr)) PNG_PRIVATE; +-/* Optional call to update the users info structure */ +-PNG_EXTERN void png_read_transform_info PNGARG((png_structp png_ptr, +- png_infop info_ptr)) PNG_PRIVATE; +- +-/* These are the functions that do the transformations */ +-#ifdef PNG_READ_FILLER_SUPPORTED +-PNG_EXTERN void png_do_read_filler PNGARG((png_row_infop row_info, +- png_bytep row, png_uint_32 filler, png_uint_32 flags)) PNG_PRIVATE; +-#endif +- +-#ifdef PNG_READ_SWAP_ALPHA_SUPPORTED +-PNG_EXTERN void png_do_read_swap_alpha PNGARG((png_row_infop row_info, +- png_bytep row)) PNG_PRIVATE; +-#endif +- +-#ifdef PNG_WRITE_SWAP_ALPHA_SUPPORTED +-PNG_EXTERN void png_do_write_swap_alpha PNGARG((png_row_infop row_info, +- png_bytep row)) PNG_PRIVATE; +-#endif +- +-#ifdef PNG_READ_INVERT_ALPHA_SUPPORTED +-PNG_EXTERN void png_do_read_invert_alpha PNGARG((png_row_infop row_info, +- png_bytep row)) PNG_PRIVATE; +-#endif +- +-#ifdef PNG_WRITE_INVERT_ALPHA_SUPPORTED +-PNG_EXTERN void png_do_write_invert_alpha PNGARG((png_row_infop row_info, +- png_bytep row)) PNG_PRIVATE; +-#endif ++#if defined(PNG_SIMPLIFIED_READ_SUPPORTED) || \ ++ defined(PNG_SIMPLIFIED_WRITE_SUPPORTED) + +-#if defined(PNG_WRITE_FILLER_SUPPORTED) || \ +- defined(PNG_READ_STRIP_ALPHA_SUPPORTED) +-PNG_EXTERN void png_do_strip_filler PNGARG((png_row_infop row_info, +- png_bytep row, png_uint_32 flags)) PNG_PRIVATE; +-#endif +- +-#if defined(PNG_READ_SWAP_SUPPORTED) || defined(PNG_WRITE_SWAP_SUPPORTED) +-PNG_EXTERN void png_do_swap PNGARG((png_row_infop row_info, +- png_bytep row)) PNG_PRIVATE; +-#endif +- +-#if defined(PNG_READ_PACKSWAP_SUPPORTED) || defined(PNG_WRITE_PACKSWAP_SUPPORTED) +-PNG_EXTERN void png_do_packswap PNGARG((png_row_infop row_info, +- png_bytep row)) PNG_PRIVATE; +-#endif +- +-#ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED +-PNG_EXTERN int png_do_rgb_to_gray PNGARG((png_structp png_ptr, png_row_infop +- row_info, png_bytep row)) PNG_PRIVATE; +-#endif +- +-#ifdef PNG_READ_GRAY_TO_RGB_SUPPORTED +-PNG_EXTERN void png_do_gray_to_rgb PNGARG((png_row_infop row_info, +- png_bytep row)) PNG_PRIVATE; +-#endif +- +-#ifdef PNG_READ_PACK_SUPPORTED +-PNG_EXTERN void png_do_unpack PNGARG((png_row_infop row_info, +- png_bytep row)) PNG_PRIVATE; +-#endif +- +-#ifdef PNG_READ_SHIFT_SUPPORTED +-PNG_EXTERN void png_do_unshift PNGARG((png_row_infop row_info, png_bytep row, +- png_color_8p sig_bits)) PNG_PRIVATE; +-#endif ++#define PNG_IMAGE_VERSION 1 + +-#if defined(PNG_READ_INVERT_SUPPORTED) || defined(PNG_WRITE_INVERT_SUPPORTED) +-PNG_EXTERN void png_do_invert PNGARG((png_row_infop row_info, +- png_bytep row)) PNG_PRIVATE; +-#endif +- +-#ifdef PNG_READ_16_TO_8_SUPPORTED +-PNG_EXTERN void png_do_chop PNGARG((png_row_infop row_info, +- png_bytep row)) PNG_PRIVATE; +-#endif +- +-#ifdef PNG_READ_DITHER_SUPPORTED +-PNG_EXTERN void png_do_dither PNGARG((png_row_infop row_info, +- png_bytep row, png_bytep palette_lookup, +- png_bytep dither_lookup)) PNG_PRIVATE; ++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) + +-# ifdef PNG_CORRECT_PALETTE_SUPPORTED +-PNG_EXTERN void png_correct_palette PNGARG((png_structp png_ptr, +- png_colorp palette, int num_palette)) PNG_PRIVATE; +-# endif +-#endif ++ png_uint_32 warning_or_error; + +-#if defined(PNG_READ_BGR_SUPPORTED) || defined(PNG_WRITE_BGR_SUPPORTED) +-PNG_EXTERN void png_do_bgr PNGARG((png_row_infop row_info, +- png_bytep row)) PNG_PRIVATE; +-#endif ++ char message[64]; ++} png_image, *png_imagep; + +-#ifdef PNG_WRITE_PACK_SUPPORTED +-PNG_EXTERN void png_do_pack PNGARG((png_row_infop row_info, +- png_bytep row, png_uint_32 bit_depth)) PNG_PRIVATE; +-#endif ++/* 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 ) 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. ++ */ + +-#ifdef PNG_WRITE_SHIFT_SUPPORTED +-PNG_EXTERN void png_do_shift PNGARG((png_row_infop row_info, png_bytep row, +- png_color_8p bit_depth)) PNG_PRIVATE; +-#endif ++/* 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_READ_BACKGROUND_SUPPORTED +-#ifdef PNG_READ_GAMMA_SUPPORTED +-PNG_EXTERN void png_do_background PNGARG((png_row_infop row_info, png_bytep row, +- png_color_16p trans_values, png_color_16p background, +- png_color_16p background_1, +- png_bytep gamma_table, png_bytep gamma_from_1, png_bytep gamma_to_1, +- png_uint_16pp gamma_16, png_uint_16pp gamma_16_from_1, +- png_uint_16pp gamma_16_to_1, int gamma_shift)) PNG_PRIVATE; +-#else +-PNG_EXTERN void png_do_background PNGARG((png_row_infop row_info, png_bytep row, +- png_color_16p trans_values, png_color_16p background)) PNG_PRIVATE; +-#endif ++#ifdef PNG_FORMAT_BGR_SUPPORTED ++# define PNG_FORMAT_FLAG_BGR 0x10U /* BGR colors, else order is RGB */ + #endif + +-#ifdef PNG_READ_GAMMA_SUPPORTED +-PNG_EXTERN void png_do_gamma PNGARG((png_row_infop row_info, png_bytep row, +- png_bytep gamma_table, png_uint_16pp gamma_16_table, +- int gamma_shift)) PNG_PRIVATE; ++#ifdef PNG_FORMAT_AFIRST_SUPPORTED ++# define PNG_FORMAT_FLAG_AFIRST 0x20U /* alpha channel comes first */ + #endif + +-#ifdef PNG_READ_EXPAND_SUPPORTED +-PNG_EXTERN void png_do_expand_palette PNGARG((png_row_infop row_info, +- png_bytep row, png_colorp palette, png_bytep trans, +- int num_trans)) PNG_PRIVATE; +-PNG_EXTERN void png_do_expand PNGARG((png_row_infop row_info, +- png_bytep row, png_color_16p trans_value)) PNG_PRIVATE; +-#endif ++#define PNG_FORMAT_FLAG_ASSOCIATED_ALPHA 0x40U /* alpha channel is associated */ + +-/* The following decodes the appropriate chunks, and does error correction, +- * then calls the appropriate callback for the chunk if it is valid. ++/* 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 */ + +-/* Decode the IHDR chunk */ +-PNG_EXTERN void png_handle_IHDR PNGARG((png_structp png_ptr, png_infop info_ptr, +- png_uint_32 length)) PNG_PRIVATE; +-PNG_EXTERN void png_handle_PLTE PNGARG((png_structp png_ptr, png_infop info_ptr, +- png_uint_32 length)); +-PNG_EXTERN void png_handle_IEND PNGARG((png_structp png_ptr, png_infop info_ptr, +- png_uint_32 length)); ++#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. ++ */ + +-#ifdef PNG_READ_bKGD_SUPPORTED +-PNG_EXTERN void png_handle_bKGD PNGARG((png_structp png_ptr, png_infop info_ptr, +- png_uint_32 length)) PNG_PRIVATE; +-#endif ++#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. ++ */ + +-#ifdef PNG_READ_cHRM_SUPPORTED +-PNG_EXTERN void png_handle_cHRM PNGARG((png_structp png_ptr, png_infop info_ptr, +- png_uint_32 length)) PNG_PRIVATE; +-#endif ++#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. ++ */ + +-#ifdef PNG_READ_gAMA_SUPPORTED +-PNG_EXTERN void png_handle_gAMA PNGARG((png_structp png_ptr, png_infop info_ptr, +- png_uint_32 length)) PNG_PRIVATE; +-#endif ++/* Corresponding information about the pixels */ ++#define PNG_IMAGE_PIXEL_(test,fmt)\ ++ (((fmt)&PNG_FORMAT_FLAG_COLORMAP)?1:test(fmt)) + +-#ifdef PNG_READ_hIST_SUPPORTED +-PNG_EXTERN void png_handle_hIST PNGARG((png_structp png_ptr, png_infop info_ptr, +- png_uint_32 length)) PNG_PRIVATE; +-#endif ++#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. ++ */ + +-#ifdef PNG_READ_iCCP_SUPPORTED +-extern void png_handle_iCCP PNGARG((png_structp png_ptr, png_infop info_ptr, +- png_uint_32 length)); +-#endif /* PNG_READ_iCCP_SUPPORTED */ ++#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. ++ */ + +-#ifdef PNG_READ_iTXt_SUPPORTED +-PNG_EXTERN void png_handle_iTXt PNGARG((png_structp png_ptr, png_infop info_ptr, +- png_uint_32 length)) PNG_PRIVATE; +-#endif ++#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. ++ * ++ * WARNING: this macro overflows for some images with more than one component ++ * and very large image widths. libpng will refuse to process an image where ++ * this macro would overflow. ++ */ + +-#ifdef PNG_READ_oFFs_SUPPORTED +-PNG_EXTERN void png_handle_oFFs PNGARG((png_structp png_ptr, png_infop info_ptr, +- png_uint_32 length)) PNG_PRIVATE; +-#endif ++#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. ++ * ++ * WARNING: this macro overflows a 32-bit integer for some large PNG images, ++ * libpng will refuse to process an image where such an overflow would occur. ++ */ + +-#ifdef PNG_READ_pCAL_SUPPORTED +-PNG_EXTERN void png_handle_pCAL PNGARG((png_structp png_ptr, png_infop info_ptr, +- png_uint_32 length)) PNG_PRIVATE; +-#endif ++#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. ++ */ + +-#ifdef PNG_READ_pHYs_SUPPORTED +-PNG_EXTERN void png_handle_pHYs PNGARG((png_structp png_ptr, png_infop info_ptr, +- png_uint_32 length)) PNG_PRIVATE; +-#endif ++#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. ++ */ + +-#ifdef PNG_READ_sBIT_SUPPORTED +-PNG_EXTERN void png_handle_sBIT PNGARG((png_structp png_ptr, png_infop info_ptr, +- png_uint_32 length)) PNG_PRIVATE; +-#endif ++/* 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 that the RGB values of the in-memory bitmap do not ++ * correspond to the red, green and blue end-points defined by sRGB. ++ */ + +-#ifdef PNG_READ_sCAL_SUPPORTED +-PNG_EXTERN void png_handle_sCAL PNGARG((png_structp png_ptr, png_infop info_ptr, +- png_uint_32 length)) PNG_PRIVATE; +-#endif ++#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. ++ */ + +-#ifdef PNG_READ_sPLT_SUPPORTED +-extern void png_handle_sPLT PNGARG((png_structp png_ptr, png_infop info_ptr, +- png_uint_32 length)) PNG_PRIVATE; +-#endif /* PNG_READ_sPLT_SUPPORTED */ ++#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_READ_sRGB_SUPPORTED +-PNG_EXTERN void png_handle_sRGB PNGARG((png_structp png_ptr, png_infop info_ptr, +- png_uint_32 length)) PNG_PRIVATE; +-#endif ++#ifdef PNG_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. ++ */ + +-#ifdef PNG_READ_tEXt_SUPPORTED +-PNG_EXTERN void png_handle_tEXt PNGARG((png_structp png_ptr, png_infop info_ptr, +- png_uint_32 length)) PNG_PRIVATE; +-#endif ++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, 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. ++ */ + +-#ifdef PNG_READ_tIME_SUPPORTED +-PNG_EXTERN void png_handle_tIME PNGARG((png_structp png_ptr, png_infop info_ptr, +- png_uint_32 length)) PNG_PRIVATE; +-#endif ++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 ++/* 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) ++ */ ++#ifdef PNG_SIMPLIFIED_WRITE_STDIO_SUPPORTED ++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*). */ ++#endif /* SIMPLIFIED_WRITE_STDIO */ ++ ++/* With all 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. If row_stride is ++ * zero, libpng will calculate it for you from the image width and number of ++ * channels. ++ * ++ * Note that the write API does not support interlacing, sub-8-bit pixels or ++ * most ancillary chunks. If you need to write text chunks (e.g. for copyright ++ * notices) you need to use one of the other APIs. ++ */ ++ ++PNG_EXPORT(245, int, png_image_write_to_memory, (png_imagep image, void *memory, ++ png_alloc_size_t * PNG_RESTRICT memory_bytes, int convert_to_8_bit, ++ const void *buffer, png_int_32 row_stride, const void *colormap)); ++ /* Write the image to the given memory buffer. The function both writes the ++ * whole PNG data stream to *memory and updates *memory_bytes with the count ++ * of bytes written. ++ * ++ * 'memory' may be NULL. In this case *memory_bytes is not read however on ++ * success the number of bytes which would have been written will still be ++ * stored in *memory_bytes. On failure *memory_bytes will contain 0. ++ * ++ * If 'memory' is not NULL it must point to memory[*memory_bytes] of ++ * writeable memory. ++ * ++ * If the function returns success memory[*memory_bytes] (if 'memory' is not ++ * NULL) contains the written PNG data. *memory_bytes will always be less ++ * than or equal to the original value. ++ * ++ * If the function returns false and *memory_bytes was not changed an error ++ * occurred during write. If *memory_bytes was changed, or is not 0 if ++ * 'memory' was NULL, the write would have succeeded but for the memory ++ * buffer being too small. *memory_bytes contains the required number of ++ * bytes and will be bigger that the original value. ++ */ + +-#ifdef PNG_READ_tRNS_SUPPORTED +-PNG_EXTERN void png_handle_tRNS PNGARG((png_structp png_ptr, png_infop info_ptr, +- png_uint_32 length)) PNG_PRIVATE; +-#endif ++#define png_image_write_get_memory_size(image, size, convert_to_8_bit, buffer,\ ++ row_stride, colormap)\ ++ png_image_write_to_memory(&(image), 0, &(size), convert_to_8_bit, buffer,\ ++ row_stride, colormap) ++ /* Return the amount of memory in 'size' required to compress this image. ++ * The png_image structure 'image' must be filled in as in the above ++ * function and must not be changed before the actual write call, the buffer ++ * and all other parameters must also be identical to that in the final ++ * write call. The 'size' variable need not be initialized. ++ * ++ * NOTE: the macro returns true/false, if false is returned 'size' will be ++ * set to zero and the write failed and probably will fail if tried again. ++ */ + +-#ifdef PNG_READ_zTXt_SUPPORTED +-PNG_EXTERN void png_handle_zTXt PNGARG((png_structp png_ptr, png_infop info_ptr, +- png_uint_32 length)) PNG_PRIVATE; ++/* You can pre-allocate the buffer by making sure it is of sufficient size ++ * regardless of the amount of compression achieved. The buffer size will ++ * always be bigger than the original image and it will never be filled. The ++ * following macros are provided to assist in allocating the buffer. ++ */ ++#define PNG_IMAGE_DATA_SIZE(image) (PNG_IMAGE_SIZE(image)+(image).height) ++ /* The number of uncompressed bytes in the PNG byte encoding of the image; ++ * uncompressing the PNG IDAT data will give this number of bytes. ++ * ++ * NOTE: while PNG_IMAGE_SIZE cannot overflow for an image in memory this ++ * macro can because of the extra bytes used in the PNG byte encoding. You ++ * need to avoid this macro if your image size approaches 2^30 in width or ++ * height. The same goes for the remainder of these macros; they all produce ++ * bigger numbers than the actual in-memory image size. ++ */ ++#ifndef PNG_ZLIB_MAX_SIZE ++# define PNG_ZLIB_MAX_SIZE(b) ((b)+(((b)+7U)>>3)+(((b)+63U)>>6)+11U) ++ /* An upper bound on the number of compressed bytes given 'b' uncompressed ++ * bytes. This is based on deflateBounds() in zlib; different ++ * implementations of zlib compression may conceivably produce more data so ++ * if your zlib implementation is not zlib itself redefine this macro ++ * appropriately. ++ */ + #endif + +-PNG_EXTERN void png_handle_unknown PNGARG((png_structp png_ptr, +- png_infop info_ptr, png_uint_32 length)) PNG_PRIVATE; +- +-PNG_EXTERN void png_check_chunk_name PNGARG((png_structp png_ptr, +- png_bytep chunk_name)) PNG_PRIVATE; +- +-/* Handle the transformations for reading and writing */ +-PNG_EXTERN void png_do_read_transformations +- PNGARG((png_structp png_ptr)) PNG_PRIVATE; +-PNG_EXTERN void png_do_write_transformations +- PNGARG((png_structp png_ptr)) PNG_PRIVATE; +- +-PNG_EXTERN void png_init_read_transformations +- PNGARG((png_structp png_ptr)) PNG_PRIVATE; +- +-#ifdef PNG_PROGRESSIVE_READ_SUPPORTED +-PNG_EXTERN void png_push_read_chunk PNGARG((png_structp png_ptr, +- png_infop info_ptr)) PNG_PRIVATE; +-PNG_EXTERN void png_push_read_sig PNGARG((png_structp png_ptr, +- png_infop info_ptr)) PNG_PRIVATE; +-PNG_EXTERN void png_push_check_crc PNGARG((png_structp png_ptr)) PNG_PRIVATE; +-PNG_EXTERN void png_push_crc_skip PNGARG((png_structp png_ptr, +- png_uint_32 length)) PNG_PRIVATE; +-PNG_EXTERN void png_push_crc_finish PNGARG((png_structp png_ptr)) PNG_PRIVATE; +-PNG_EXTERN void png_push_save_buffer PNGARG((png_structp png_ptr)) PNG_PRIVATE; +-PNG_EXTERN void png_push_restore_buffer PNGARG((png_structp png_ptr, +- png_bytep buffer, png_size_t buffer_length)) PNG_PRIVATE; +-PNG_EXTERN void png_push_read_IDAT PNGARG((png_structp png_ptr)) PNG_PRIVATE; +-PNG_EXTERN void png_process_IDAT_data PNGARG((png_structp png_ptr, +- png_bytep buffer, png_size_t buffer_length)) PNG_PRIVATE; +-PNG_EXTERN void png_push_process_row PNGARG((png_structp png_ptr)) PNG_PRIVATE; +-PNG_EXTERN void png_push_handle_unknown PNGARG((png_structp png_ptr, +- png_infop info_ptr, png_uint_32 length)) PNG_PRIVATE; +-PNG_EXTERN void png_push_have_info PNGARG((png_structp png_ptr, +- png_infop info_ptr)) PNG_PRIVATE; +-PNG_EXTERN void png_push_have_end PNGARG((png_structp png_ptr, +- png_infop info_ptr)) PNG_PRIVATE; +-PNG_EXTERN void png_push_have_row PNGARG((png_structp png_ptr, +- png_bytep row)) PNG_PRIVATE; +-PNG_EXTERN void png_push_read_end PNGARG((png_structp png_ptr, +- png_infop info_ptr)) PNG_PRIVATE; +-PNG_EXTERN void png_process_some_data PNGARG((png_structp png_ptr, +- png_infop info_ptr)) PNG_PRIVATE; +-PNG_EXTERN void png_read_push_finish_row +- PNGARG((png_structp png_ptr)) PNG_PRIVATE; +-#ifdef PNG_READ_tEXt_SUPPORTED +-PNG_EXTERN void png_push_handle_tEXt PNGARG((png_structp png_ptr, +- png_infop info_ptr, png_uint_32 length)) PNG_PRIVATE; +-PNG_EXTERN void png_push_read_tEXt PNGARG((png_structp png_ptr, +- png_infop info_ptr)) PNG_PRIVATE; +-#endif +-#ifdef PNG_READ_zTXt_SUPPORTED +-PNG_EXTERN void png_push_handle_zTXt PNGARG((png_structp png_ptr, +- png_infop info_ptr, png_uint_32 length)) PNG_PRIVATE; +-PNG_EXTERN void png_push_read_zTXt PNGARG((png_structp png_ptr, +- png_infop info_ptr)) PNG_PRIVATE; +-#endif +-#ifdef PNG_READ_iTXt_SUPPORTED +-PNG_EXTERN void png_push_handle_iTXt PNGARG((png_structp png_ptr, +- png_infop info_ptr, png_uint_32 length)) PNG_PRIVATE; +-PNG_EXTERN void png_push_read_iTXt PNGARG((png_structp png_ptr, +- png_infop info_ptr)) PNG_PRIVATE; +-#endif +- +-#endif /* PNG_PROGRESSIVE_READ_SUPPORTED */ ++#define PNG_IMAGE_COMPRESSED_SIZE_MAX(image)\ ++ PNG_ZLIB_MAX_SIZE((png_alloc_size_t)PNG_IMAGE_DATA_SIZE(image)) ++ /* An upper bound on the size of the data in the PNG IDAT chunks. */ ++ ++#define PNG_IMAGE_PNG_SIZE_MAX_(image, image_size)\ ++ ((8U/*sig*/+25U/*IHDR*/+16U/*gAMA*/+44U/*cHRM*/+12U/*IEND*/+\ ++ (((image).format&PNG_FORMAT_FLAG_COLORMAP)?/*colormap: PLTE, tRNS*/\ ++ 12U+3U*(image).colormap_entries/*PLTE data*/+\ ++ (((image).format&PNG_FORMAT_FLAG_ALPHA)?\ ++ 12U/*tRNS*/+(image).colormap_entries:0U):0U)+\ ++ 12U)+(12U*((image_size)/PNG_ZBUF_SIZE))/*IDAT*/+(image_size)) ++ /* A helper for the following macro; if your compiler cannot handle the ++ * following macro use this one with the result of ++ * PNG_IMAGE_COMPRESSED_SIZE_MAX(image) as the second argument (most ++ * compilers should handle this just fine.) ++ */ + +-#ifdef PNG_MNG_FEATURES_SUPPORTED +-PNG_EXTERN void png_do_read_intrapixel PNGARG((png_row_infop row_info, +- png_bytep row)) PNG_PRIVATE; +-PNG_EXTERN void png_do_write_intrapixel PNGARG((png_row_infop row_info, +- png_bytep row)) PNG_PRIVATE; ++#define PNG_IMAGE_PNG_SIZE_MAX(image)\ ++ PNG_IMAGE_PNG_SIZE_MAX_(image, PNG_IMAGE_COMPRESSED_SIZE_MAX(image)) ++ /* An upper bound on the total length of the PNG data stream for 'image'. ++ * The result is of type png_alloc_size_t, on 32-bit systems this may ++ * overflow even though PNG_IMAGE_DATA_SIZE does not overflow; the write will ++ * run out of buffer space but return a corrected size which should work. ++ */ ++#endif /* SIMPLIFIED_WRITE */ ++/******************************************************************************* ++ * END OF SIMPLIFIED API ++ ******************************************************************************/ ++#endif /* SIMPLIFIED_{READ|WRITE} */ ++ ++/******************************************************************************* ++ * Section 6: 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 capabilities, 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 +- +-#ifdef PNG_ASSEMBLER_CODE_SUPPORTED +-#ifdef PNG_MMX_CODE_SUPPORTED +-/* png.c */ /* PRIVATE */ +-PNG_EXTERN void png_init_mmx_flags PNGARG((png_structp png_ptr)) PNG_PRIVATE; ++#define PNG_MAXIMUM_INFLATE_WINDOW 2 /* SOFTWARE: force maximum window */ ++#define PNG_SKIP_sRGB_CHECK_PROFILE 4 /* SOFTWARE: Check ICC profile for sRGB */ ++#ifdef PNG_MIPS_MSA_API_SUPPORTED ++# define PNG_MIPS_MSA 6 /* HARDWARE: MIPS Msa SIMD instructions supported */ + #endif ++#define PNG_IGNORE_ADLER32 8 ++#ifdef PNG_POWERPC_VSX_API_SUPPORTED ++# define PNG_POWERPC_VSX 10 /* HARDWARE: PowerPC VSX SIMD instructions supported */ + #endif ++#define PNG_OPTION_NEXT 12 /* 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 + +-/* The following six functions will be exported in libpng-1.4.0. */ +-#if defined(PNG_INCH_CONVERSIONS) && defined(PNG_FLOATING_POINT_SUPPORTED) +-PNG_EXTERN png_uint_32 png_get_pixels_per_inch PNGARG((png_structp png_ptr, +-png_infop info_ptr)); +- +-PNG_EXTERN png_uint_32 png_get_x_pixels_per_inch PNGARG((png_structp png_ptr, +-png_infop info_ptr)); ++PNG_EXPORT(244, int, png_set_option, (png_structrp png_ptr, int option, ++ int onoff)); ++#endif /* SET_OPTION */ + +-PNG_EXTERN png_uint_32 png_get_y_pixels_per_inch PNGARG((png_structp png_ptr, +-png_infop info_ptr)); ++/******************************************************************************* ++ * END OF HARDWARE AND SOFTWARE OPTIONS ++ ******************************************************************************/ + +-PNG_EXTERN float png_get_x_offset_inches PNGARG((png_structp png_ptr, +-png_infop info_ptr)); +- +-PNG_EXTERN float png_get_y_offset_inches PNGARG((png_structp png_ptr, +-png_infop info_ptr)); +- +-#ifdef PNG_pHYs_SUPPORTED +-PNG_EXTERN png_uint_32 png_get_pHYs_dpi PNGARG((png_structp png_ptr, +-png_infop info_ptr, png_uint_32 *res_x, png_uint_32 *res_y, int *unit_type)); +-#endif /* PNG_pHYs_SUPPORTED */ +-#endif /* PNG_INCH_CONVERSIONS && PNG_FLOATING_POINT_SUPPORTED */ +- +-/* Read the chunk header (length + type name) */ +-PNG_EXTERN png_uint_32 png_read_chunk_header +- PNGARG((png_structp png_ptr)) PNG_PRIVATE; +- +-/* Added at libpng version 1.2.34 */ +-#ifdef PNG_cHRM_SUPPORTED +-PNG_EXTERN int png_check_cHRM_fixed PNGARG((png_structp png_ptr, +- png_fixed_point int_white_x, png_fixed_point int_white_y, +- png_fixed_point int_red_x, png_fixed_point int_red_y, png_fixed_point +- int_green_x, png_fixed_point int_green_y, png_fixed_point int_blue_x, +- png_fixed_point int_blue_y)) PNG_PRIVATE; +-#endif ++/* Maintainer: Put new public prototypes here ^, in libpng.3, in project ++ * defs, and in scripts/symbols.def. ++ */ + +-#ifdef PNG_cHRM_SUPPORTED +-#ifdef PNG_CHECK_cHRM_SUPPORTED +-/* Added at libpng version 1.2.34 */ +-PNG_EXTERN void png_64bit_product PNGARG((long v1, long v2, +- unsigned long *hi_product, unsigned long *lo_product)) PNG_PRIVATE; +-#endif ++/* The last ordinal number (this is the *last* one already used; the next ++ * one to use is one more than this.) ++ */ ++#ifdef PNG_EXPORT_LAST_ORDINAL ++ PNG_EXPORT_LAST_ORDINAL(249); + #endif + +-/* Added at libpng version 1.2.41 */ +-PNG_EXTERN void png_check_IHDR PNGARG((png_structp png_ptr, +- png_uint_32 width, png_uint_32 height, int bit_depth, +- int color_type, int interlace_type, int compression_type, +- int filter_type)) PNG_PRIVATE; +- +-/* Added at libpng version 1.2.41 */ +-PNG_EXTERN png_voidp png_calloc PNGARG((png_structp png_ptr, +- png_uint_32 size)); +- +-/* Maintainer: Put new private prototypes here ^ and in libpngpf.3 */ +- +-#endif /* PNG_INTERNAL */ +- + #ifdef __cplusplus + } + #endif +diff --git a/com32/include/pngconf.h b/com32/include/pngconf.h +index defc16d9..5e641b25 100644 +--- a/com32/include/pngconf.h ++++ b/com32/include/pngconf.h +@@ -1,17 +1,18 @@ + + /* pngconf.h - machine configurable file for libpng + * +- * libpng version 1.2.44 - June 26, 2010 +- * Copyright (c) 1998-2010 Glenn Randers-Pehrson +- * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) +- * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) ++ * libpng version 1.6.36 ++ * ++ * Copyright (c) 2018 Cosmin Truta ++ * Copyright (c) 1998-2002,2004,2006-2016,2018 Glenn Randers-Pehrson ++ * Copyright (c) 1996-1997 Andreas Dilger ++ * Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc. + * + * This code is released under the libpng license. + * For conditions of distribution and use, see the disclaimer + * and license in png.h +- */ +- +-/* Any machine specific code is near the front of this file, so if you ++ * ++ * Any machine specific code is near the front of this file, so if you + * are configuring libpng for a machine, you may want to read the section + * starting here down to where it starts to typedef png_color, png_text, + * and png_info. +@@ -20,1646 +21,603 @@ + #ifndef PNGCONF_H + #define PNGCONF_H + +-#define PNG_1_2_X ++#ifndef PNG_BUILDING_SYMBOL_TABLE /* else includes may cause problems */ + +-/* +- * PNG_USER_CONFIG has to be defined on the compiler command line. This +- * includes the resource compiler for Windows DLL configurations. ++/* 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. + */ +-#ifdef PNG_USER_CONFIG +-# ifndef PNG_USER_PRIVATEBUILD +-# define PNG_USER_PRIVATEBUILD +-# endif +-#include "pngusr.h" +-#endif +- +-/* PNG_CONFIGURE_LIBPNG is set by the "configure" script. */ +-#ifdef PNG_CONFIGURE_LIBPNG +-#ifdef HAVE_CONFIG_H +-#include "config.h" +-#endif +-#endif ++#include ++#include + +-/* +- * Added at libpng-1.2.8 +- * +- * If you create a private DLL you need to define in "pngusr.h" the followings: +- * #define PNG_USER_PRIVATEBUILD +- * e.g. #define PNG_USER_PRIVATEBUILD "Build by MyCompany for xyz reasons." +- * #define PNG_USER_DLLFNAME_POSTFIX +- * e.g. // private DLL "libpng13gx.dll" +- * #define PNG_USER_DLLFNAME_POSTFIX "gx" ++/* 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. + * +- * The following macros are also at your disposal if you want to complete the +- * DLL VERSIONINFO structure. +- * - PNG_USER_VERSIONINFO_COMMENTS +- * - PNG_USER_VERSIONINFO_COMPANYNAME +- * - PNG_USER_VERSIONINFO_LEGALTRADEMARKS ++ * 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 __STDC__ +-#ifdef SPECIALBUILD +-# pragma message("PNG_LIBPNG_SPECIALBUILD (and deprecated SPECIALBUILD)\ +- are now LIBPNG reserved macros. Use PNG_USER_PRIVATEBUILD instead.") +-#endif +- +-#ifdef PRIVATEBUILD +-# pragma message("PRIVATEBUILD is deprecated.\ +- Use PNG_USER_PRIVATEBUILD instead.") +-# define PNG_USER_PRIVATEBUILD PRIVATEBUILD ++#ifdef PNG_STDIO_SUPPORTED ++ /* Required for the definition of FILE: */ ++# include + #endif +-#endif /* __STDC__ */ + +-#ifndef PNG_VERSION_INFO_ONLY +- +-/* End of material added to libpng-1.2.8 */ +- +-/* Added at libpng-1.2.19, removed at libpng-1.2.20 because it caused trouble +- Restored at libpng-1.2.21 */ +-#if !defined(PNG_NO_WARN_UNINITIALIZED_ROW) && \ +- !defined(PNG_WARN_UNINITIALIZED_ROW) +-# define PNG_WARN_UNINITIALIZED_ROW 1 ++#ifdef PNG_SETJMP_SUPPORTED ++ /* Required for the definition of jmp_buf and the declaration of longjmp: */ ++# include + #endif +-/* End of material added at libpng-1.2.19/1.2.21 */ + +-/* This is the size of the compression buffer, and thus the size of +- * an IDAT chunk. Make this whatever size you feel is best for your +- * machine. One of these will be allocated per png_struct. When this +- * is full, it writes the data to the disk, and does some other +- * calculations. Making this an extremely small size will slow +- * the library down, but you may want to experiment to determine +- * where it becomes significant, if you are concerned with memory +- * usage. Note that zlib allocates at least 32Kb also. For readers, +- * this describes the size of the buffer available to read the data in. +- * Unless this gets smaller than the size of a row (compressed), +- * it should not make much difference how big this is. +- */ +- +-#ifndef PNG_ZBUF_SIZE +-# define PNG_ZBUF_SIZE 8192 ++#ifdef PNG_CONVERT_tIME_SUPPORTED ++ /* Required for struct tm: */ ++# include + #endif + +-/* Enable if you want a write-only libpng */ +- +-#ifndef PNG_NO_READ_SUPPORTED +-# define PNG_READ_SUPPORTED +-#endif ++#endif /* PNG_BUILDING_SYMBOL_TABLE */ + +-/* Enable if you want a read-only libpng */ ++/* Prior to 1.6.0, it was possible to turn off 'const' in declarations, ++ * using PNG_NO_CONST. This is no longer supported. ++ */ ++#define PNG_CONST const /* backward compatibility only */ + +-#ifndef PNG_NO_WRITE_SUPPORTED +-# define PNG_WRITE_SUPPORTED ++/* This controls optimization of the reading of 16-bit 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 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 ++# define PNG_USE_READ_MACROS + #endif +- +-/* Enabled in 1.2.41. */ +-#ifdef PNG_ALLOW_BENIGN_ERRORS +-# define png_benign_error png_warning +-# define png_chunk_benign_error png_chunk_warning +-#else +-# ifndef PNG_BENIGN_ERRORS_SUPPORTED +-# define png_benign_error png_error +-# define png_chunk_benign_error png_chunk_error ++#if !defined(PNG_NO_USE_READ_MACROS) && !defined(PNG_USE_READ_MACROS) ++# if PNG_DEFAULT_READ_MACROS ++# define PNG_USE_READ_MACROS + # endif + #endif + +-/* Added in libpng-1.2.41 */ +-#if !defined(PNG_NO_WARNINGS) && !defined(PNG_WARNINGS_SUPPORTED) +-# define PNG_WARNINGS_SUPPORTED +-#endif +- +-#if !defined(PNG_NO_ERROR_TEXT) && !defined(PNG_ERROR_TEXT_SUPPORTED) +-# define PNG_ERROR_TEXT_SUPPORTED +-#endif +- +-#if !defined(PNG_NO_CHECK_cHRM) && !defined(PNG_CHECK_cHRM_SUPPORTED) +-# define PNG_CHECK_cHRM_SUPPORTED +-#endif +- +-/* Enabled by default in 1.2.0. You can disable this if you don't need to +- * support PNGs that are embedded in MNG datastreams ++/* COMPILER SPECIFIC OPTIONS. ++ * ++ * These options are provided so that a variety of difficult compilers ++ * can be used. Some are fixed at build time (e.g. PNG_API_RULE ++ * below) but still have compiler specific implementations, others ++ * may be changed on a per-file basis when compiling against libpng. + */ +-#if !defined(PNG_1_0_X) && !defined(PNG_NO_MNG_FEATURES) +-# ifndef PNG_MNG_FEATURES_SUPPORTED +-# define PNG_MNG_FEATURES_SUPPORTED +-# endif +-#endif +- +-#ifndef PNG_NO_FLOATING_POINT_SUPPORTED +-# ifndef PNG_FLOATING_POINT_SUPPORTED +-# define PNG_FLOATING_POINT_SUPPORTED +-# endif +-#endif + +-/* If you are running on a machine where you cannot allocate more +- * than 64K of memory at once, uncomment this. While libpng will not +- * normally need that much memory in a chunk (unless you load up a very +- * large file), zlib needs to know how big of a chunk it can use, and +- * libpng thus makes sure to check any memory allocation to verify it +- * will fit into memory. +-#define PNG_MAX_MALLOC_64K ++/* 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. + */ +-#if defined(MAXSEG_64K) && !defined(PNG_MAX_MALLOC_64K) +-# define PNG_MAX_MALLOC_64K ++#ifndef PNGARG ++# define PNGARG(arglist) arglist + #endif + +-/* Special munging to support doing things the 'cygwin' way: +- * 'Normal' png-on-win32 defines/defaults: +- * PNG_BUILD_DLL -- building dll +- * PNG_USE_DLL -- building an application, linking to dll +- * (no define) -- building static library, or building an +- * application and linking to the static lib +- * 'Cygwin' defines/defaults: +- * PNG_BUILD_DLL -- (ignored) building the dll +- * (no define) -- (ignored) building an application, linking to the dll +- * PNG_STATIC -- (ignored) building the static lib, or building an +- * application that links to the static lib. +- * ALL_STATIC -- (ignored) building various static libs, or building an +- * application that links to the static libs. +- * Thus, +- * a cygwin user should define either PNG_BUILD_DLL or PNG_STATIC, and +- * this bit of #ifdefs will define the 'correct' config variables based on +- * that. If a cygwin user *wants* to define 'PNG_USE_DLL' that's okay, but +- * unnecessary. ++/* Function calling conventions. ++ * ============================= ++ * Normally it is not necessary to specify to the compiler how to call ++ * a function - it just does it - however on x86 systems derived from ++ * Microsoft and Borland C compilers ('IBM PC', 'DOS', 'Windows' systems ++ * and some others) there are multiple ways to call a function and the ++ * default can be changed on the compiler command line. For this reason ++ * libpng specifies the calling convention of every exported function and ++ * every function called via a user supplied function pointer. This is ++ * done in this file by defining the following macros: + * +- * Also, the precedence order is: +- * ALL_STATIC (since we can't #undef something outside our namespace) +- * PNG_BUILD_DLL +- * PNG_STATIC +- * (nothing) == PNG_USE_DLL ++ * PNGAPI Calling convention for exported functions. ++ * PNGCBAPI Calling convention for user provided (callback) functions. ++ * PNGCAPI Calling convention used by the ANSI-C library (required ++ * for longjmp callbacks and sometimes used internally to ++ * specify the calling convention for zlib). + * +- * CYGWIN (2002-01-20): The preceding is now obsolete. With the advent +- * of auto-import in binutils, we no longer need to worry about +- * __declspec(dllexport) / __declspec(dllimport) and friends. Therefore, +- * we don't need to worry about PNG_STATIC or ALL_STATIC when it comes +- * to __declspec() stuff. However, we DO need to worry about +- * PNG_BUILD_DLL and PNG_STATIC because those change some defaults +- * such as CONSOLE_IO and whether GLOBAL_ARRAYS are allowed. +- */ +-#ifdef __CYGWIN__ +-# ifdef ALL_STATIC +-# ifdef PNG_BUILD_DLL +-# undef PNG_BUILD_DLL ++ * These macros should never be overridden. If it is necessary to ++ * change calling convention in a private build this can be done ++ * by setting PNG_API_RULE (which defaults to 0) to one of the values ++ * below to select the correct 'API' variants. ++ * ++ * PNG_API_RULE=0 Use PNGCAPI - the 'C' calling convention - throughout. ++ * This is correct in every known environment. ++ * PNG_API_RULE=1 Use the operating system convention for PNGAPI and ++ * the 'C' calling convention (from PNGCAPI) for ++ * callbacks (PNGCBAPI). This is no longer required ++ * in any known environment - if it has to be used ++ * please post an explanation of the problem to the ++ * libpng mailing list. ++ * ++ * These cases only differ if the operating system does not use the C ++ * calling convention, at present this just means the above cases ++ * (x86 DOS/Windows systems) and, even then, this does not apply to ++ * Cygwin running on those systems. ++ * ++ * Note that the value must be defined in pnglibconf.h so that what ++ * the application uses to call the library matches the conventions ++ * set when building the library. ++ */ ++ ++/* Symbol export ++ * ============= ++ * When building a shared library it is almost always necessary to tell ++ * the compiler which symbols to export. The png.h macro 'PNG_EXPORT' ++ * is used to mark the symbols. On some systems these symbols can be ++ * extracted at link time and need no special processing by the compiler, ++ * on other systems the symbols are flagged by the compiler and just ++ * the declaration requires a special tag applied (unfortunately) in a ++ * compiler dependent way. Some systems can do either. ++ * ++ * A small number of older systems also require a symbol from a DLL to ++ * be flagged to the program that calls it. This is a problem because ++ * we do not know in the header file included by application code that ++ * the symbol will come from a shared library, as opposed to a statically ++ * linked one. For this reason the application must tell us by setting ++ * the magic flag PNG_USE_DLL to turn on the special processing before ++ * it includes png.h. ++ * ++ * Four additional macros are used to make this happen: ++ * ++ * PNG_IMPEXP The magic (if any) to cause a symbol to be exported from ++ * the build or imported if PNG_USE_DLL is set - compiler ++ * and system specific. ++ * ++ * PNG_EXPORT_TYPE(type) A macro that pre or appends PNG_IMPEXP to ++ * 'type', compiler specific. ++ * ++ * PNG_DLL_EXPORT Set to the magic to use during a libpng build to ++ * 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 ++ * PNG_USE_DLL is set. ++ */ ++ ++/* System specific discovery. ++ * ========================== ++ * 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 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__) ++ /* 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 ++ * understood or because of a redefine just below you cannot use *this* ++ * build of the library with the compiler you are using. *This* build was ++ * build using Watcom and applications must also be built using Watcom! ++ */ ++# define PNGCAPI __watcall ++# endif ++ ++# 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 +-# ifdef PNG_USE_DLL +-# undef PNG_USE_DLL ++# else ++ /* An older compiler, or one not detected (erroneously) above, ++ * if necessary override on the command line to get the correct ++ * variants for the compiler. ++ */ ++# ifndef PNGCAPI ++# define PNGCAPI _cdecl + # endif +-# ifdef PNG_DLL +-# undef PNG_DLL ++# if PNG_API_RULE == 1 && !defined(PNGAPI) ++# define PNGAPI _stdcall + # endif +-# ifndef PNG_STATIC +-# define PNG_STATIC ++# 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" ++# endif ++ ++# if (defined(_MSC_VER) && _MSC_VER < 800) ||\ ++ (defined(__BORLANDC__) && __BORLANDC__ < 0x500) ++ /* older Borland and MSC ++ * compilers used '__export' and required this to be after ++ * the type. ++ */ ++# ifndef PNG_EXPORT_TYPE ++# define PNG_EXPORT_TYPE(type) type PNG_IMPEXP + # endif +-# else +-# ifdef PNG_BUILD_DLL +-# ifdef PNG_STATIC +-# undef PNG_STATIC +-# endif +-# ifdef PNG_USE_DLL +-# undef PNG_USE_DLL +-# endif +-# ifndef PNG_DLL +-# define PNG_DLL +-# endif +-# else +-# ifdef PNG_STATIC +-# ifdef PNG_USE_DLL +-# undef PNG_USE_DLL +-# endif +-# ifdef PNG_DLL +-# undef PNG_DLL +-# endif +-# else +-# ifndef PNG_USE_DLL +-# define PNG_USE_DLL +-# endif +-# ifndef PNG_DLL +-# define PNG_DLL +-# endif +-# endif ++# define PNG_DLL_EXPORT __export ++# else /* newer compiler */ ++# define PNG_DLL_EXPORT __declspec(dllexport) ++# ifndef PNG_DLL_IMPORT ++# define PNG_DLL_IMPORT __declspec(dllimport) + # endif +-# endif +-#endif ++# endif /* compiler */ + +-/* This protects us against compilers that run on a windowing system +- * and thus don't have or would rather us not use the stdio types: +- * stdin, stdout, and stderr. The only one currently used is stderr +- * in png_error() and png_warning(). #defining PNG_NO_CONSOLE_IO will +- * prevent these from being compiled and used. #defining PNG_NO_STDIO +- * will also prevent these, plus will prevent the entire set of stdio +- * macros and functions (FILE *, printf, etc.) from being compiled and used, +- * unless (PNG_DEBUG > 0) has been #defined. +- * +- * #define PNG_NO_CONSOLE_IO +- * #define PNG_NO_STDIO +- */ ++#else /* !Windows */ ++# if (defined(__IBMC__) || defined(__IBMCPP__)) && defined(__OS2__) ++# define PNGAPI _System ++# else /* !Windows/x86 && !OS/2 */ ++ /* Use the defaults, or define PNG*API on the command line (but ++ * this will have to be done for every compile!) ++ */ ++# endif /* other system, !OS/2 */ ++#endif /* !Windows/x86 */ + +-#if !defined(PNG_NO_STDIO) && !defined(PNG_STDIO_SUPPORTED) +-# define PNG_STDIO_SUPPORTED ++/* Now do all the defaulting . */ ++#ifndef PNGCAPI ++# define PNGCAPI + #endif +- +-#ifdef _WIN32_WCE +-# include +- /* Console I/O functions are not supported on WindowsCE */ +-# define PNG_NO_CONSOLE_IO +- /* abort() may not be supported on some/all Windows CE platforms */ +-# define PNG_ABORT() exit(-1) +-# ifdef PNG_DEBUG +-# undef PNG_DEBUG +-# endif ++#ifndef PNGCBAPI ++# define PNGCBAPI PNGCAPI + #endif +- +-#ifdef PNG_BUILD_DLL +-# ifndef PNG_CONSOLE_IO_SUPPORTED +-# ifndef PNG_NO_CONSOLE_IO +-# define PNG_NO_CONSOLE_IO +-# endif +-# endif ++#ifndef PNGAPI ++# define PNGAPI PNGCAPI + #endif + +-# ifdef PNG_NO_STDIO +-# ifndef PNG_NO_CONSOLE_IO +-# define PNG_NO_CONSOLE_IO +-# endif +-# ifdef PNG_DEBUG +-# if (PNG_DEBUG > 0) +-# include +-# endif +-# endif +-# else +-# ifndef _WIN32_WCE +-/* "stdio.h" functions are not supported on WindowsCE */ +-# include +-# endif ++/* 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 ++# 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_NO_CONSOLE_IO) && !defined(PNG_CONSOLE_IO_SUPPORTED) +-# define PNG_CONSOLE_IO_SUPPORTED ++# ifndef PNG_IMPEXP ++# define PNG_IMPEXP ++# endif + #endif + +-/* This macro protects us against machines that don't have function +- * prototypes (ie K&R style headers). If your compiler does not handle +- * function prototypes, define this macro and use the included ansi2knr. +- * I've always been able to use _NO_PROTO as the indicator, but you may +- * need to drag the empty declaration out in front of here, or change the +- * ifdef to suit your own needs. ++/* In 1.5.2 the definition of PNG_FUNCTION has been changed to always treat ++ * 'attributes' as a storage class - the attributes go at the start of the ++ * function definition, and attributes are always appended regardless of the ++ * compiler. This considerably simplifies these macros but may cause problems ++ * if any compilers both need function attributes and fail to handle them as ++ * a storage class (this is unlikely.) + */ +-#ifndef PNGARG +- +-#ifdef OF /* zlib prototype munger */ +-# define PNGARG(arglist) OF(arglist) +-#else +- +-#ifdef _NO_PROTO +-# define PNGARG(arglist) () +-# ifndef PNG_TYPECAST_NULL +-# define PNG_TYPECAST_NULL +-# endif +-#else +-# define PNGARG(arglist) arglist +-#endif /* _NO_PROTO */ ++#ifndef PNG_FUNCTION ++# define PNG_FUNCTION(type, name, args, attributes) attributes type name args ++#endif + ++#ifndef PNG_EXPORT_TYPE ++# define PNG_EXPORT_TYPE(type) PNG_IMPEXP type ++#endif + +-#endif /* OF */ ++ /* The ordinal value is only relevant when preprocessing png.h for symbol ++ * table entries, so we discard it here. See the .dfn files in the ++ * scripts directory. ++ */ + +-#endif /* PNGARG */ ++#ifndef PNG_EXPORTA ++# define PNG_EXPORTA(ordinal, type, name, args, attributes) \ ++ PNG_FUNCTION(PNG_EXPORT_TYPE(type), (PNGAPI name), PNGARG(args), \ ++ PNG_LINKAGE_API attributes) ++#endif + +-/* Try to determine if we are compiling on a Mac. Note that testing for +- * just __MWERKS__ is not good enough, because the Codewarrior is now used +- * on non-Mac platforms. ++/* ANSI-C (C90) does not permit a macro to be invoked with an empty argument, ++ * so make something non-empty to satisfy the requirement: + */ +-#ifndef MACOS +-# if (defined(__MWERKS__) && defined(macintosh)) || defined(applec) || \ +- defined(THINK_C) || defined(__SC__) || defined(TARGET_OS_MAC) +-# define MACOS +-# endif +-#endif ++#define PNG_EMPTY /*empty list*/ + +-/* enough people need this for various reasons to include it here */ +-#if !defined(MACOS) && !defined(RISCOS) && !defined(_WIN32_WCE) +-# include ++#define PNG_EXPORT(ordinal, type, name, args) \ ++ PNG_EXPORTA(ordinal, type, name, args, PNG_EMPTY) ++ ++/* Use PNG_REMOVED to comment out a removed interface. */ ++#ifndef PNG_REMOVED ++# define PNG_REMOVED(ordinal, type, name, args, attributes) + #endif + +-#if !defined(PNG_SETJMP_NOT_SUPPORTED) && !defined(PNG_NO_SETJMP_SUPPORTED) +-# define PNG_SETJMP_SUPPORTED ++#ifndef PNG_CALLBACK ++# define PNG_CALLBACK(type, name, args) type (PNGCBAPI name) PNGARG(args) + #endif + +-#ifdef PNG_SETJMP_SUPPORTED +-/* This is an attempt to force a single setjmp behaviour on Linux. If +- * the X config stuff didn't define _BSD_SOURCE we wouldn't need this. ++/* Support for compiler specific function attributes. These are used ++ * so that where compiler support is available incorrect use of API ++ * functions in png.h will generate compiler warnings. + * +- * You can bypass this test if you know that your application uses exactly +- * the same setjmp.h that was included when libpng was built. Only define +- * PNG_SKIP_SETJMP_CHECK while building your application, prior to the +- * application's '#include "png.h"'. Don't define PNG_SKIP_SETJMP_CHECK +- * while building a separate libpng library for general use. ++ * Added at libpng-1.2.41. + */ + +-# ifndef PNG_SKIP_SETJMP_CHECK +-# ifdef __linux__ +-# ifdef _BSD_SOURCE +-# define PNG_SAVE_BSD_SOURCE +-# undef _BSD_SOURCE +-# endif +-# ifdef _SETJMP_H +- /* If you encounter a compiler error here, see the explanation +- * near the end of INSTALL. +- */ +- __pngconf.h__ in libpng already includes setjmp.h; +- __dont__ include it again.; +-# endif +-# endif /* __linux__ */ +-# endif /* PNG_SKIP_SETJMP_CHECK */ +- +- /* include setjmp.h for error handling */ +-# include ++#ifndef PNG_NO_PEDANTIC_WARNINGS ++# ifndef PNG_PEDANTIC_WARNINGS_SUPPORTED ++# define PNG_PEDANTIC_WARNINGS_SUPPORTED ++# endif ++#endif + +-# ifdef __linux__ +-# ifdef PNG_SAVE_BSD_SOURCE +-# ifndef _BSD_SOURCE +-# define _BSD_SOURCE ++#ifdef PNG_PEDANTIC_WARNINGS_SUPPORTED ++ /* Support for compiler specific function attributes. These are used ++ * so that where compiler support is available, incorrect use of API ++ * functions in png.h will generate compiler warnings. Added at libpng ++ * version 1.2.41. Disabling these removes the warnings but may also produce ++ * less efficient code. ++ */ ++# 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 +-# undef PNG_SAVE_BSD_SOURCE + # endif +-# endif /* __linux__ */ +-#endif /* PNG_SETJMP_SUPPORTED */ +- +-#ifdef BSD +-# include +-#else +-# include +-#endif +- +-/* Other defines for things like memory and the like can go here. */ +-#ifdef PNG_INTERNAL +- +-#include ++# ifndef PNG_RESTRICT ++# define PNG_RESTRICT __restrict ++# endif + +-/* The functions exported by PNG_EXTERN are PNG_INTERNAL functions, which +- * aren't usually used outside the library (as far as I know), so it is +- * debatable if they should be exported at all. In the future, when it is +- * possible to have run-time registry of chunk-handling functions, some of +- * these will be made available again. +-#define PNG_EXTERN extern +- */ +-#define PNG_EXTERN ++# 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 ++# if __GNUC__ >= 3 ++# ifndef PNG_ALLOCATED ++# define PNG_ALLOCATED __attribute__((__malloc__)) ++# endif ++# ifndef PNG_DEPRECATED ++# define PNG_DEPRECATED __attribute__((__deprecated__)) ++# endif ++# ifndef PNG_PRIVATE ++# if 0 /* Doesn't work so we use deprecated instead*/ ++# define PNG_PRIVATE \ ++ __attribute__((warning("This function is not exported by libpng."))) ++# else ++# define PNG_PRIVATE \ ++ __attribute__((__deprecated__)) ++# endif ++# endif ++# 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 */ + +-/* Other defines specific to compilers can go here. Try to keep +- * them inside an appropriate ifdef/endif pair for portability. +- */ ++# elif defined(_MSC_VER) && (_MSC_VER >= 1300) ++# ifndef PNG_USE_RESULT ++# define PNG_USE_RESULT /* not supported */ ++# endif ++# ifndef PNG_NORETURN ++# define PNG_NORETURN __declspec(noreturn) ++# endif ++# ifndef PNG_ALLOCATED ++# if (_MSC_VER >= 1400) ++# 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 + +-#ifdef PNG_FLOATING_POINT_SUPPORTED +-# ifdef MACOS +- /* We need to check that hasn't already been included earlier +- * as it seems it doesn't agree with , yet we should really use +- * if possible. +- */ +-# if !defined(__MATH_H__) && !defined(__MATH_H) && !defined(__cmath__) +-# include ++# elif defined(__WATCOMC__) ++# ifndef PNG_RESTRICT ++# define PNG_RESTRICT __restrict + # endif +-# else +-# include +-# endif +-# if defined(_AMIGA) && defined(__SASC) && defined(_M68881) +- /* Amiga SAS/C: We must include builtin FPU functions when compiling using +- * MATH=68881 +- */ +-# include + # endif +-#endif +- +-/* Codewarrior on NT has linking problems without this. */ +-#if (defined(__MWERKS__) && defined(WIN32)) || defined(__STDC__) +-# define PNG_ALWAYS_EXTERN +-#endif +- +-/* This provides the non-ANSI (far) memory allocation routines. */ +-#if defined(__TURBOC__) && defined(__MSDOS__) +-# include +-# include +-#endif +- +-/* I have no idea why is this necessary... */ +-#if defined(_MSC_VER) && (defined(WIN32) || defined(_Windows) || \ +- defined(_WINDOWS) || defined(_WIN32) || defined(__WIN32__)) +-# include +-#endif ++#endif /* PNG_PEDANTIC_WARNINGS */ + +-/* This controls how fine the dithering gets. As this allocates +- * a largish chunk of memory (32K), those who are not as concerned +- * with dithering quality can decrease some or all of these. +- */ +-#ifndef PNG_DITHER_RED_BITS +-# define PNG_DITHER_RED_BITS 5 ++#ifndef PNG_DEPRECATED ++# define PNG_DEPRECATED /* Use of this function is deprecated */ + #endif +-#ifndef PNG_DITHER_GREEN_BITS +-# define PNG_DITHER_GREEN_BITS 5 ++#ifndef PNG_USE_RESULT ++# define PNG_USE_RESULT /* The result of this function must be checked */ + #endif +-#ifndef PNG_DITHER_BLUE_BITS +-# define PNG_DITHER_BLUE_BITS 5 ++#ifndef PNG_NORETURN ++# define PNG_NORETURN /* This function does not return */ + #endif +- +-/* This controls how fine the gamma correction becomes when you +- * are only interested in 8 bits anyway. Increasing this value +- * results in more memory being used, and more pow() functions +- * being called to fill in the gamma tables. Don't set this value +- * less then 8, and even that may not work (I haven't tested it). +- */ +- +-#ifndef PNG_MAX_GAMMA_8 +-# define PNG_MAX_GAMMA_8 11 ++#ifndef PNG_ALLOCATED ++# define PNG_ALLOCATED /* The result of the function is new memory */ + #endif +- +-/* This controls how much a difference in gamma we can tolerate before +- * we actually start doing gamma conversion. +- */ +-#ifndef PNG_GAMMA_THRESHOLD +-# define PNG_GAMMA_THRESHOLD 0.05 ++#ifndef PNG_PRIVATE ++# define PNG_PRIVATE /* This is a private libpng function */ + #endif +- +-#endif /* PNG_INTERNAL */ +- +-/* The following uses const char * instead of char * for error +- * and warning message functions, so some compilers won't complain. +- * If you do not want to use const, define PNG_NO_CONST here. +- */ +- +-#ifndef PNG_NO_CONST +-# define PNG_CONST const +-#else +-# define PNG_CONST ++#ifndef PNG_RESTRICT ++# define PNG_RESTRICT /* The C99 "restrict" feature */ + #endif + +-/* The following defines give you the ability to remove code from the +- * library that you will not be using. I wish I could figure out how to +- * automate this, but I can't do that without making it seriously hard +- * on the users. So if you are not using an ability, change the #define +- * to and #undef, and that part of the library will not be compiled. If +- * your linker can't find a function, you may want to make sure the +- * ability is defined here. Some of these depend upon some others being +- * defined. I haven't figured out all the interactions here, so you may +- * have to experiment awhile to get everything to compile. If you are +- * creating or using a shared library, you probably shouldn't touch this, +- * as it will affect the size of the structures, and this will cause bad +- * things to happen if the library and/or application ever change. +- */ +- +-/* Any features you will not be using can be undef'ed here */ +- +-/* GR-P, 0.96a: Set "*TRANSFORMS_SUPPORTED as default but allow user +- * to turn it off with "*TRANSFORMS_NOT_SUPPORTED" or *PNG_NO_*_TRANSFORMS +- * on the compile line, then pick and choose which ones to define without +- * having to edit this file. It is safe to use the *TRANSFORMS_NOT_SUPPORTED +- * if you only want to have a png-compliant reader/writer but don't need +- * any of the extra transformations. This saves about 80 kbytes in a +- * typical installation of the library. (PNG_NO_* form added in version +- * 1.0.1c, for consistency) +- */ +- +-/* The size of the png_text structure changed in libpng-1.0.6 when +- * iTXt support was added. iTXt support was turned off by default through +- * libpng-1.2.x, to support old apps that malloc the png_text structure +- * instead of calling png_set_text() and letting libpng malloc it. It +- * will be turned on by default in libpng-1.4.0. +- */ +- +-#if defined(PNG_1_0_X) || defined (PNG_1_2_X) +-# ifndef PNG_NO_iTXt_SUPPORTED +-# define PNG_NO_iTXt_SUPPORTED +-# endif +-# ifndef PNG_NO_READ_iTXt +-# define PNG_NO_READ_iTXt +-# endif +-# ifndef PNG_NO_WRITE_iTXt +-# define PNG_NO_WRITE_iTXt ++#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); ++# else /* No floating point APIs */ ++# define PNG_FP_EXPORT(ordinal, type, name, args) + # endif + #endif +- +-#if !defined(PNG_NO_iTXt_SUPPORTED) +-# if !defined(PNG_READ_iTXt_SUPPORTED) && !defined(PNG_NO_READ_iTXt) +-# define PNG_READ_iTXt +-# endif +-# if !defined(PNG_WRITE_iTXt_SUPPORTED) && !defined(PNG_NO_WRITE_iTXt) +-# define PNG_WRITE_iTXt ++#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); ++# else /* No fixed point APIs */ ++# define PNG_FIXED_EXPORT(ordinal, type, name, args) + # endif + #endif + +-/* The following support, added after version 1.0.0, can be turned off here en +- * masse by defining PNG_LEGACY_SUPPORTED in case you need binary compatibility +- * with old applications that require the length of png_struct and png_info +- * to remain unchanged. ++#ifndef PNG_BUILDING_SYMBOL_TABLE ++/* Some typedefs to get us started. These should be safe on most of the common ++ * platforms. ++ * ++ * 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. + */ +- +-#ifdef PNG_LEGACY_SUPPORTED +-# define PNG_NO_FREE_ME +-# define PNG_NO_READ_UNKNOWN_CHUNKS +-# define PNG_NO_WRITE_UNKNOWN_CHUNKS +-# define PNG_NO_HANDLE_AS_UNKNOWN +-# define PNG_NO_READ_USER_CHUNKS +-# define PNG_NO_READ_iCCP +-# define PNG_NO_WRITE_iCCP +-# define PNG_NO_READ_iTXt +-# define PNG_NO_WRITE_iTXt +-# define PNG_NO_READ_sCAL +-# define PNG_NO_WRITE_sCAL +-# define PNG_NO_READ_sPLT +-# define PNG_NO_WRITE_sPLT +-# define PNG_NO_INFO_IMAGE +-# define PNG_NO_READ_RGB_TO_GRAY +-# define PNG_NO_READ_USER_TRANSFORM +-# define PNG_NO_WRITE_USER_TRANSFORM +-# define PNG_NO_USER_MEM +-# define PNG_NO_READ_EMPTY_PLTE +-# define PNG_NO_MNG_FEATURES +-# define PNG_NO_FIXED_POINT_SUPPORTED ++#if CHAR_BIT == 8 && UCHAR_MAX == 255 ++ typedef unsigned char png_byte; ++#else ++# error "libpng requires 8-bit bytes" + #endif + +-/* Ignore attempt to turn off both floating and fixed point support */ +-#if !defined(PNG_FLOATING_POINT_SUPPORTED) || \ +- !defined(PNG_NO_FIXED_POINT_SUPPORTED) +-# define PNG_FIXED_POINT_SUPPORTED ++#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 + +-#ifndef PNG_NO_FREE_ME +-# define PNG_FREE_ME_SUPPORTED ++#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 + +-#ifdef PNG_READ_SUPPORTED +- +-#if !defined(PNG_READ_TRANSFORMS_NOT_SUPPORTED) && \ +- !defined(PNG_NO_READ_TRANSFORMS) +-# define PNG_READ_TRANSFORMS_SUPPORTED ++#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 + +-#ifdef PNG_READ_TRANSFORMS_SUPPORTED +-# ifndef PNG_NO_READ_EXPAND +-# define PNG_READ_EXPAND_SUPPORTED +-# endif +-# ifndef PNG_NO_READ_SHIFT +-# define PNG_READ_SHIFT_SUPPORTED +-# endif +-# ifndef PNG_NO_READ_PACK +-# define PNG_READ_PACK_SUPPORTED +-# endif +-# ifndef PNG_NO_READ_BGR +-# define PNG_READ_BGR_SUPPORTED +-# endif +-# ifndef PNG_NO_READ_SWAP +-# define PNG_READ_SWAP_SUPPORTED +-# endif +-# ifndef PNG_NO_READ_PACKSWAP +-# define PNG_READ_PACKSWAP_SUPPORTED +-# endif +-# ifndef PNG_NO_READ_INVERT +-# define PNG_READ_INVERT_SUPPORTED +-# endif +-# ifndef PNG_NO_READ_DITHER +-# define PNG_READ_DITHER_SUPPORTED +-# endif +-# ifndef PNG_NO_READ_BACKGROUND +-# define PNG_READ_BACKGROUND_SUPPORTED +-# endif +-# ifndef PNG_NO_READ_16_TO_8 +-# define PNG_READ_16_TO_8_SUPPORTED +-# endif +-# ifndef PNG_NO_READ_FILLER +-# define PNG_READ_FILLER_SUPPORTED +-# endif +-# ifndef PNG_NO_READ_GAMMA +-# define PNG_READ_GAMMA_SUPPORTED +-# endif +-# ifndef PNG_NO_READ_GRAY_TO_RGB +-# define PNG_READ_GRAY_TO_RGB_SUPPORTED +-# endif +-# ifndef PNG_NO_READ_SWAP_ALPHA +-# define PNG_READ_SWAP_ALPHA_SUPPORTED +-# endif +-# ifndef PNG_NO_READ_INVERT_ALPHA +-# define PNG_READ_INVERT_ALPHA_SUPPORTED +-# endif +-# ifndef PNG_NO_READ_STRIP_ALPHA +-# define PNG_READ_STRIP_ALPHA_SUPPORTED +-# endif +-# ifndef PNG_NO_READ_USER_TRANSFORM +-# define PNG_READ_USER_TRANSFORM_SUPPORTED +-# endif +-# ifndef PNG_NO_READ_RGB_TO_GRAY +-# define PNG_READ_RGB_TO_GRAY_SUPPORTED +-# endif +-#endif /* PNG_READ_TRANSFORMS_SUPPORTED */ +- +-/* PNG_PROGRESSIVE_READ_NOT_SUPPORTED is deprecated. */ +-#if !defined(PNG_NO_PROGRESSIVE_READ) && \ +- !defined(PNG_PROGRESSIVE_READ_NOT_SUPPORTED) /* if you don't do progressive */ +-# define PNG_PROGRESSIVE_READ_SUPPORTED /* reading. This is not talking */ +-#endif /* about interlacing capability! You'll */ +- /* still have interlacing unless you change the following define: */ +-#define PNG_READ_INTERLACING_SUPPORTED /* required for PNG-compliant decoders */ +- +-/* PNG_NO_SEQUENTIAL_READ_SUPPORTED is deprecated. */ +-#if !defined(PNG_NO_SEQUENTIAL_READ) && \ +- !defined(PNG_SEQUENTIAL_READ_SUPPORTED) && \ +- !defined(PNG_NO_SEQUENTIAL_READ_SUPPORTED) +-# define PNG_SEQUENTIAL_READ_SUPPORTED ++#if UINT_MAX > 4294967294U ++ typedef unsigned int png_uint_32; ++#elif ULONG_MAX > 4294967294U ++ typedef unsigned long int png_uint_32; ++#else ++# error "libpng requires an unsigned 32-bit (or more) type" + #endif + +-#define PNG_READ_INTERLACING_SUPPORTED /* required in PNG-compliant decoders */ ++/* Prior to 1.6.0, it was possible to disable the use of size_t and ptrdiff_t. ++ * From 1.6.0 onwards, an ISO C90 compiler, as well as a standard-compliant ++ * behavior of sizeof and ptrdiff_t are required. ++ * The legacy typedefs are provided here for backwards compatibility. ++ */ ++typedef size_t png_size_t; ++typedef ptrdiff_t png_ptrdiff_t; + +-#ifndef PNG_NO_READ_COMPOSITE_NODIV +-# ifndef PNG_NO_READ_COMPOSITED_NODIV /* libpng-1.0.x misspelling */ +-# define PNG_READ_COMPOSITE_NODIV_SUPPORTED /* well tested on Intel, SGI */ ++/* 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 + +-#if defined(PNG_1_0_X) || defined (PNG_1_2_X) +-/* Deprecated, will be removed from version 2.0.0. +- Use PNG_MNG_FEATURES_SUPPORTED instead. */ +-#ifndef PNG_NO_READ_EMPTY_PLTE +-# define PNG_READ_EMPTY_PLTE_SUPPORTED +-#endif +-#endif +- +-#endif /* PNG_READ_SUPPORTED */ +- +-#ifdef PNG_WRITE_SUPPORTED +- +-# if !defined(PNG_WRITE_TRANSFORMS_NOT_SUPPORTED) && \ +- !defined(PNG_NO_WRITE_TRANSFORMS) +-# define PNG_WRITE_TRANSFORMS_SUPPORTED ++/* png_alloc_size_t is guaranteed to be no smaller than size_t, and no smaller ++ * than png_uint_32. Casts from 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 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 size_t png_alloc_size_t; + #endif + +-#ifdef PNG_WRITE_TRANSFORMS_SUPPORTED +-# ifndef PNG_NO_WRITE_SHIFT +-# define PNG_WRITE_SHIFT_SUPPORTED +-# endif +-# ifndef PNG_NO_WRITE_PACK +-# define PNG_WRITE_PACK_SUPPORTED +-# endif +-# ifndef PNG_NO_WRITE_BGR +-# define PNG_WRITE_BGR_SUPPORTED +-# endif +-# ifndef PNG_NO_WRITE_SWAP +-# define PNG_WRITE_SWAP_SUPPORTED +-# endif +-# ifndef PNG_NO_WRITE_PACKSWAP +-# define PNG_WRITE_PACKSWAP_SUPPORTED +-# endif +-# ifndef PNG_NO_WRITE_INVERT +-# define PNG_WRITE_INVERT_SUPPORTED +-# endif +-# ifndef PNG_NO_WRITE_FILLER +-# define PNG_WRITE_FILLER_SUPPORTED /* same as WRITE_STRIP_ALPHA */ +-# endif +-# ifndef PNG_NO_WRITE_SWAP_ALPHA +-# define PNG_WRITE_SWAP_ALPHA_SUPPORTED +-# endif +-#ifndef PNG_1_0_X +-# ifndef PNG_NO_WRITE_INVERT_ALPHA +-# define PNG_WRITE_INVERT_ALPHA_SUPPORTED +-# endif +-#endif +-# ifndef PNG_NO_WRITE_USER_TRANSFORM +-# define PNG_WRITE_USER_TRANSFORM_SUPPORTED +-# endif +-#endif /* PNG_WRITE_TRANSFORMS_SUPPORTED */ ++/* 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(PNG_NO_WRITE_INTERLACING_SUPPORTED) && \ +- !defined(PNG_WRITE_INTERLACING_SUPPORTED) +-#define PNG_WRITE_INTERLACING_SUPPORTED /* not required for PNG-compliant +- encoders, but can cause trouble +- if left undefined */ +-#endif ++/* 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; + +-#if !defined(PNG_NO_WRITE_WEIGHTED_FILTER) && \ +- !defined(PNG_WRITE_WEIGHTED_FILTER) && \ +- defined(PNG_FLOATING_POINT_SUPPORTED) +-# define PNG_WRITE_WEIGHTED_FILTER_SUPPORTED ++/* Add typedefs for pointers */ ++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 size_t * png_size_tp; ++typedef const size_t * png_const_size_tp; ++ ++#ifdef PNG_STDIO_SUPPORTED ++typedef FILE * png_FILE_p; + #endif + +-#ifndef PNG_NO_WRITE_FLUSH +-# define PNG_WRITE_FLUSH_SUPPORTED ++#ifdef PNG_FLOATING_POINT_SUPPORTED ++typedef double * png_doublep; ++typedef const double * png_const_doublep; + #endif + +-#if defined(PNG_1_0_X) || defined (PNG_1_2_X) +-/* Deprecated, see PNG_MNG_FEATURES_SUPPORTED, above */ +-#ifndef PNG_NO_WRITE_EMPTY_PLTE +-# define PNG_WRITE_EMPTY_PLTE_SUPPORTED +-#endif +-#endif +- +-#endif /* PNG_WRITE_SUPPORTED */ +- +-#ifndef PNG_1_0_X +-# ifndef PNG_NO_ERROR_NUMBERS +-# define PNG_ERROR_NUMBERS_SUPPORTED +-# endif +-#endif /* PNG_1_0_X */ +- +-#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \ +- defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) +-# ifndef PNG_NO_USER_TRANSFORM_PTR +-# define PNG_USER_TRANSFORM_PTR_SUPPORTED +-# endif +-#endif +- +-#ifndef PNG_NO_STDIO +-# define PNG_TIME_RFC1123_SUPPORTED +-#endif +- +-/* This adds extra functions in pngget.c for accessing data from the +- * info pointer (added in version 0.99) +- * png_get_image_width() +- * png_get_image_height() +- * png_get_bit_depth() +- * png_get_color_type() +- * png_get_compression_type() +- * png_get_filter_type() +- * png_get_interlace_type() +- * png_get_pixel_aspect_ratio() +- * png_get_pixels_per_meter() +- * png_get_x_offset_pixels() +- * png_get_y_offset_pixels() +- * png_get_x_offset_microns() +- * png_get_y_offset_microns() +- */ +-#if !defined(PNG_NO_EASY_ACCESS) && !defined(PNG_EASY_ACCESS_SUPPORTED) +-# define PNG_EASY_ACCESS_SUPPORTED +-#endif +- +-/* PNG_ASSEMBLER_CODE was enabled by default in version 1.2.0 +- * and removed from version 1.2.20. The following will be removed +- * from libpng-1.4.0 +-*/ +- +-#if defined(PNG_READ_SUPPORTED) && !defined(PNG_NO_OPTIMIZED_CODE) +-# ifndef PNG_OPTIMIZED_CODE_SUPPORTED +-# define PNG_OPTIMIZED_CODE_SUPPORTED +-# endif +-#endif +- +-#if defined(PNG_READ_SUPPORTED) && !defined(PNG_NO_ASSEMBLER_CODE) +-# ifndef PNG_ASSEMBLER_CODE_SUPPORTED +-# define PNG_ASSEMBLER_CODE_SUPPORTED +-# endif +- +-# if defined(__GNUC__) && defined(__x86_64__) && (__GNUC__ < 4) +- /* work around 64-bit gcc compiler bugs in gcc-3.x */ +-# if !defined(PNG_MMX_CODE_SUPPORTED) && !defined(PNG_NO_MMX_CODE) +-# define PNG_NO_MMX_CODE +-# endif +-# endif +- +-# ifdef __APPLE__ +-# if !defined(PNG_MMX_CODE_SUPPORTED) && !defined(PNG_NO_MMX_CODE) +-# define PNG_NO_MMX_CODE +-# endif +-# endif +- +-# if (defined(__MWERKS__) && ((__MWERKS__ < 0x0900) || macintosh)) +-# if !defined(PNG_MMX_CODE_SUPPORTED) && !defined(PNG_NO_MMX_CODE) +-# define PNG_NO_MMX_CODE +-# endif +-# endif +- +-# if !defined(PNG_MMX_CODE_SUPPORTED) && !defined(PNG_NO_MMX_CODE) +-# define PNG_MMX_CODE_SUPPORTED +-# endif +- +-#endif +-/* end of obsolete code to be removed from libpng-1.4.0 */ +- +-/* Added at libpng-1.2.0 */ +-#ifndef PNG_1_0_X +-#if !defined(PNG_NO_USER_MEM) && !defined(PNG_USER_MEM_SUPPORTED) +-# define PNG_USER_MEM_SUPPORTED +-#endif +-#endif /* PNG_1_0_X */ +- +-/* Added at libpng-1.2.6 */ +-#ifndef PNG_1_0_X +-# ifndef PNG_SET_USER_LIMITS_SUPPORTED +-# ifndef PNG_NO_SET_USER_LIMITS +-# define PNG_SET_USER_LIMITS_SUPPORTED +-# endif +-# endif +-#endif /* PNG_1_0_X */ +- +-/* Added at libpng-1.0.53 and 1.2.43 */ +-#ifndef PNG_USER_LIMITS_SUPPORTED +-# ifndef PNG_NO_USER_LIMITS +-# define PNG_USER_LIMITS_SUPPORTED +-# endif +-#endif +- +-/* Added at libpng-1.0.16 and 1.2.6. To accept all valid PNGS no matter +- * how large, set these limits to 0x7fffffffL +- */ +-#ifndef PNG_USER_WIDTH_MAX +-# define PNG_USER_WIDTH_MAX 1000000L +-#endif +-#ifndef PNG_USER_HEIGHT_MAX +-# define PNG_USER_HEIGHT_MAX 1000000L +-#endif +- +-/* Added at libpng-1.2.43. To accept all valid PNGs no matter +- * how large, set these two limits to 0. +- */ +-#ifndef PNG_USER_CHUNK_CACHE_MAX +-# define PNG_USER_CHUNK_CACHE_MAX 0 +-#endif +- +-/* Added at libpng-1.2.43 */ +-#ifndef PNG_USER_CHUNK_MALLOC_MAX +-# define PNG_USER_CHUNK_MALLOC_MAX 0 +-#endif +- +-#ifndef PNG_LITERAL_SHARP +-# define PNG_LITERAL_SHARP 0x23 +-#endif +-#ifndef PNG_LITERAL_LEFT_SQUARE_BRACKET +-# define PNG_LITERAL_LEFT_SQUARE_BRACKET 0x5b +-#endif +-#ifndef PNG_LITERAL_RIGHT_SQUARE_BRACKET +-# define PNG_LITERAL_RIGHT_SQUARE_BRACKET 0x5d +-#endif +- +-/* Added at libpng-1.2.34 */ +-#ifndef PNG_STRING_NEWLINE +-#define PNG_STRING_NEWLINE "\n" +-#endif +- +-/* These are currently experimental features, define them if you want */ +- +-/* very little testing */ +-/* +-#ifdef PNG_READ_SUPPORTED +-# ifndef PNG_READ_16_TO_8_ACCURATE_SCALE_SUPPORTED +-# define PNG_READ_16_TO_8_ACCURATE_SCALE_SUPPORTED +-# endif +-#endif +-*/ +- +-/* This is only for PowerPC big-endian and 680x0 systems */ +-/* some testing */ +-/* +-#ifndef PNG_READ_BIG_ENDIAN_SUPPORTED +-# define PNG_READ_BIG_ENDIAN_SUPPORTED +-#endif +-*/ +- +-/* Buggy compilers (e.g., gcc 2.7.2.2) need this */ +-/* +-#define PNG_NO_POINTER_INDEXING +-*/ +- +-#if !defined(PNG_NO_POINTER_INDEXING) && \ +- !defined(PNG_POINTER_INDEXING_SUPPORTED) +-# define PNG_POINTER_INDEXING_SUPPORTED +-#endif +- +-/* These functions are turned off by default, as they will be phased out. */ +-/* +-#define PNG_USELESS_TESTS_SUPPORTED +-#define PNG_CORRECT_PALETTE_SUPPORTED +-*/ +- +-/* Any chunks you are not interested in, you can undef here. The +- * ones that allocate memory may be expecially important (hIST, +- * tEXt, zTXt, tRNS, pCAL). Others will just save time and make png_info +- * a bit smaller. +- */ +- +-#if defined(PNG_READ_SUPPORTED) && \ +- !defined(PNG_READ_ANCILLARY_CHUNKS_NOT_SUPPORTED) && \ +- !defined(PNG_NO_READ_ANCILLARY_CHUNKS) +-# define PNG_READ_ANCILLARY_CHUNKS_SUPPORTED +-#endif +- +-#if defined(PNG_WRITE_SUPPORTED) && \ +- !defined(PNG_WRITE_ANCILLARY_CHUNKS_NOT_SUPPORTED) && \ +- !defined(PNG_NO_WRITE_ANCILLARY_CHUNKS) +-# define PNG_WRITE_ANCILLARY_CHUNKS_SUPPORTED +-#endif +- +-#ifdef PNG_READ_ANCILLARY_CHUNKS_SUPPORTED +- +-#ifdef PNG_NO_READ_TEXT +-# define PNG_NO_READ_iTXt +-# define PNG_NO_READ_tEXt +-# define PNG_NO_READ_zTXt +-#endif +-#ifndef PNG_NO_READ_bKGD +-# define PNG_READ_bKGD_SUPPORTED +-# define PNG_bKGD_SUPPORTED +-#endif +-#ifndef PNG_NO_READ_cHRM +-# define PNG_READ_cHRM_SUPPORTED +-# define PNG_cHRM_SUPPORTED +-#endif +-#ifndef PNG_NO_READ_gAMA +-# define PNG_READ_gAMA_SUPPORTED +-# define PNG_gAMA_SUPPORTED +-#endif +-#ifndef PNG_NO_READ_hIST +-# define PNG_READ_hIST_SUPPORTED +-# define PNG_hIST_SUPPORTED +-#endif +-#ifndef PNG_NO_READ_iCCP +-# define PNG_READ_iCCP_SUPPORTED +-# define PNG_iCCP_SUPPORTED +-#endif +-#ifndef PNG_NO_READ_iTXt +-# ifndef PNG_READ_iTXt_SUPPORTED +-# define PNG_READ_iTXt_SUPPORTED +-# endif +-# ifndef PNG_iTXt_SUPPORTED +-# define PNG_iTXt_SUPPORTED +-# endif +-#endif +-#ifndef PNG_NO_READ_oFFs +-# define PNG_READ_oFFs_SUPPORTED +-# define PNG_oFFs_SUPPORTED +-#endif +-#ifndef PNG_NO_READ_pCAL +-# define PNG_READ_pCAL_SUPPORTED +-# define PNG_pCAL_SUPPORTED +-#endif +-#ifndef PNG_NO_READ_sCAL +-# define PNG_READ_sCAL_SUPPORTED +-# define PNG_sCAL_SUPPORTED +-#endif +-#ifndef PNG_NO_READ_pHYs +-# define PNG_READ_pHYs_SUPPORTED +-# define PNG_pHYs_SUPPORTED +-#endif +-#ifndef PNG_NO_READ_sBIT +-# define PNG_READ_sBIT_SUPPORTED +-# define PNG_sBIT_SUPPORTED +-#endif +-#ifndef PNG_NO_READ_sPLT +-# define PNG_READ_sPLT_SUPPORTED +-# define PNG_sPLT_SUPPORTED +-#endif +-#ifndef PNG_NO_READ_sRGB +-# define PNG_READ_sRGB_SUPPORTED +-# define PNG_sRGB_SUPPORTED +-#endif +-#ifndef PNG_NO_READ_tEXt +-# define PNG_READ_tEXt_SUPPORTED +-# define PNG_tEXt_SUPPORTED +-#endif +-#ifndef PNG_NO_READ_tIME +-# define PNG_READ_tIME_SUPPORTED +-# define PNG_tIME_SUPPORTED +-#endif +-#ifndef PNG_NO_READ_tRNS +-# define PNG_READ_tRNS_SUPPORTED +-# define PNG_tRNS_SUPPORTED +-#endif +-#ifndef PNG_NO_READ_zTXt +-# define PNG_READ_zTXt_SUPPORTED +-# define PNG_zTXt_SUPPORTED +-#endif +-#ifndef PNG_NO_READ_OPT_PLTE +-# define PNG_READ_OPT_PLTE_SUPPORTED /* only affects support of the */ +-#endif /* optional PLTE chunk in RGB and RGBA images */ +-#if defined(PNG_READ_iTXt_SUPPORTED) || defined(PNG_READ_tEXt_SUPPORTED) || \ +- defined(PNG_READ_zTXt_SUPPORTED) +-# define PNG_READ_TEXT_SUPPORTED +-# define PNG_TEXT_SUPPORTED +-#endif +- +-#endif /* PNG_READ_ANCILLARY_CHUNKS_SUPPORTED */ +- +-#ifndef PNG_NO_READ_UNKNOWN_CHUNKS +-# define PNG_READ_UNKNOWN_CHUNKS_SUPPORTED +-# ifndef PNG_UNKNOWN_CHUNKS_SUPPORTED +-# define PNG_UNKNOWN_CHUNKS_SUPPORTED +-# endif +-#endif +-#if !defined(PNG_NO_READ_USER_CHUNKS) && \ +- defined(PNG_READ_UNKNOWN_CHUNKS_SUPPORTED) +-# define PNG_READ_USER_CHUNKS_SUPPORTED +-# define PNG_USER_CHUNKS_SUPPORTED +-# ifdef PNG_NO_READ_UNKNOWN_CHUNKS +-# undef PNG_NO_READ_UNKNOWN_CHUNKS +-# endif +-# ifdef PNG_NO_HANDLE_AS_UNKNOWN +-# undef PNG_NO_HANDLE_AS_UNKNOWN +-# endif +-#endif +- +-#ifndef PNG_NO_HANDLE_AS_UNKNOWN +-# ifndef PNG_HANDLE_AS_UNKNOWN_SUPPORTED +-# define PNG_HANDLE_AS_UNKNOWN_SUPPORTED +-# endif +-#endif +- +-#ifdef PNG_WRITE_SUPPORTED +-#ifdef PNG_WRITE_ANCILLARY_CHUNKS_SUPPORTED +- +-#ifdef PNG_NO_WRITE_TEXT +-# define PNG_NO_WRITE_iTXt +-# define PNG_NO_WRITE_tEXt +-# define PNG_NO_WRITE_zTXt +-#endif +-#ifndef PNG_NO_WRITE_bKGD +-# define PNG_WRITE_bKGD_SUPPORTED +-# ifndef PNG_bKGD_SUPPORTED +-# define PNG_bKGD_SUPPORTED +-# endif +-#endif +-#ifndef PNG_NO_WRITE_cHRM +-# define PNG_WRITE_cHRM_SUPPORTED +-# ifndef PNG_cHRM_SUPPORTED +-# define PNG_cHRM_SUPPORTED +-# endif +-#endif +-#ifndef PNG_NO_WRITE_gAMA +-# define PNG_WRITE_gAMA_SUPPORTED +-# ifndef PNG_gAMA_SUPPORTED +-# define PNG_gAMA_SUPPORTED +-# endif +-#endif +-#ifndef PNG_NO_WRITE_hIST +-# define PNG_WRITE_hIST_SUPPORTED +-# ifndef PNG_hIST_SUPPORTED +-# define PNG_hIST_SUPPORTED +-# endif +-#endif +-#ifndef PNG_NO_WRITE_iCCP +-# define PNG_WRITE_iCCP_SUPPORTED +-# ifndef PNG_iCCP_SUPPORTED +-# define PNG_iCCP_SUPPORTED +-# endif +-#endif +-#ifndef PNG_NO_WRITE_iTXt +-# ifndef PNG_WRITE_iTXt_SUPPORTED +-# define PNG_WRITE_iTXt_SUPPORTED +-# endif +-# ifndef PNG_iTXt_SUPPORTED +-# define PNG_iTXt_SUPPORTED +-# endif +-#endif +-#ifndef PNG_NO_WRITE_oFFs +-# define PNG_WRITE_oFFs_SUPPORTED +-# ifndef PNG_oFFs_SUPPORTED +-# define PNG_oFFs_SUPPORTED +-# endif +-#endif +-#ifndef PNG_NO_WRITE_pCAL +-# define PNG_WRITE_pCAL_SUPPORTED +-# ifndef PNG_pCAL_SUPPORTED +-# define PNG_pCAL_SUPPORTED +-# endif +-#endif +-#ifndef PNG_NO_WRITE_sCAL +-# define PNG_WRITE_sCAL_SUPPORTED +-# ifndef PNG_sCAL_SUPPORTED +-# define PNG_sCAL_SUPPORTED +-# endif +-#endif +-#ifndef PNG_NO_WRITE_pHYs +-# define PNG_WRITE_pHYs_SUPPORTED +-# ifndef PNG_pHYs_SUPPORTED +-# define PNG_pHYs_SUPPORTED +-# endif +-#endif +-#ifndef PNG_NO_WRITE_sBIT +-# define PNG_WRITE_sBIT_SUPPORTED +-# ifndef PNG_sBIT_SUPPORTED +-# define PNG_sBIT_SUPPORTED +-# endif +-#endif +-#ifndef PNG_NO_WRITE_sPLT +-# define PNG_WRITE_sPLT_SUPPORTED +-# ifndef PNG_sPLT_SUPPORTED +-# define PNG_sPLT_SUPPORTED +-# endif +-#endif +-#ifndef PNG_NO_WRITE_sRGB +-# define PNG_WRITE_sRGB_SUPPORTED +-# ifndef PNG_sRGB_SUPPORTED +-# define PNG_sRGB_SUPPORTED +-# endif +-#endif +-#ifndef PNG_NO_WRITE_tEXt +-# define PNG_WRITE_tEXt_SUPPORTED +-# ifndef PNG_tEXt_SUPPORTED +-# define PNG_tEXt_SUPPORTED +-# endif +-#endif +-#ifndef PNG_NO_WRITE_tIME +-# define PNG_WRITE_tIME_SUPPORTED +-# ifndef PNG_tIME_SUPPORTED +-# define PNG_tIME_SUPPORTED +-# endif +-#endif +-#ifndef PNG_NO_WRITE_tRNS +-# define PNG_WRITE_tRNS_SUPPORTED +-# ifndef PNG_tRNS_SUPPORTED +-# define PNG_tRNS_SUPPORTED +-# endif +-#endif +-#ifndef PNG_NO_WRITE_zTXt +-# define PNG_WRITE_zTXt_SUPPORTED +-# ifndef PNG_zTXt_SUPPORTED +-# define PNG_zTXt_SUPPORTED +-# endif +-#endif +-#if defined(PNG_WRITE_iTXt_SUPPORTED) || defined(PNG_WRITE_tEXt_SUPPORTED) || \ +- defined(PNG_WRITE_zTXt_SUPPORTED) +-# define PNG_WRITE_TEXT_SUPPORTED +-# ifndef PNG_TEXT_SUPPORTED +-# define PNG_TEXT_SUPPORTED +-# endif +-#endif +- +-#ifdef PNG_WRITE_tIME_SUPPORTED +-# ifndef PNG_NO_CONVERT_tIME +-# ifndef _WIN32_WCE +-/* The "tm" structure is not supported on WindowsCE */ +-# ifndef PNG_CONVERT_tIME_SUPPORTED +-# define PNG_CONVERT_tIME_SUPPORTED +-# endif +-# endif +-# endif +-#endif +- +-#endif /* PNG_WRITE_ANCILLARY_CHUNKS_SUPPORTED */ +- +-#if !defined(PNG_NO_WRITE_FILTER) && !defined(PNG_WRITE_FILTER_SUPPORTED) +-# define PNG_WRITE_FILTER_SUPPORTED +-#endif +- +-#ifndef PNG_NO_WRITE_UNKNOWN_CHUNKS +-# define PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED +-# ifndef PNG_UNKNOWN_CHUNKS_SUPPORTED +-# define PNG_UNKNOWN_CHUNKS_SUPPORTED +-# endif +-#endif +- +-#ifndef PNG_NO_HANDLE_AS_UNKNOWN +-# ifndef PNG_HANDLE_AS_UNKNOWN_SUPPORTED +-# define PNG_HANDLE_AS_UNKNOWN_SUPPORTED +-# endif +-#endif +-#endif /* PNG_WRITE_SUPPORTED */ +- +-/* Turn this off to disable png_read_png() and +- * png_write_png() and leave the row_pointers member +- * out of the info structure. +- */ +-#ifndef PNG_NO_INFO_IMAGE +-# define PNG_INFO_IMAGE_SUPPORTED +-#endif +- +-/* Need the time information for converting tIME chunks */ +-#ifdef PNG_CONVERT_tIME_SUPPORTED +- /* "time.h" functions are not supported on WindowsCE */ +-# include +-#endif +- +-/* Some typedefs to get us started. These should be safe on most of the +- * common platforms. The typedefs should be at least as large as the +- * numbers suggest (a png_uint_32 must be at least 32 bits long), but they +- * don't have to be exactly that size. Some compilers dislike passing +- * unsigned shorts as function parameters, so you may be better off using +- * unsigned int for png_uint_16. Likewise, for 64-bit systems, you may +- * want to have unsigned int for png_uint_32 instead of unsigned long. +- */ +- +-typedef unsigned long png_uint_32; +-typedef long png_int_32; +-typedef unsigned short png_uint_16; +-typedef short png_int_16; +-typedef unsigned char png_byte; +- +-/* This is usually size_t. It is typedef'ed just in case you need it to +- change (I'm not sure if you will or not, so I thought I'd be safe) */ +-#ifdef PNG_SIZE_T +- typedef PNG_SIZE_T png_size_t; +-# define png_sizeof(x) png_convert_size(sizeof(x)) +-#else +- typedef size_t png_size_t; +-# define png_sizeof(x) sizeof(x) +-#endif +- +-/* The following is needed for medium model support. It cannot be in the +- * PNG_INTERNAL section. Needs modification for other compilers besides +- * MSC. Model independent support declares all arrays and pointers to be +- * large using the far keyword. The zlib version used must also support +- * model independent data. As of version zlib 1.0.4, the necessary changes +- * have been made in zlib. The USE_FAR_KEYWORD define triggers other +- * changes that are needed. (Tim Wegner) +- */ +- +-/* Separate compiler dependencies (problem here is that zlib.h always +- defines FAR. (SJT) */ +-#ifdef __BORLANDC__ +-# if defined(__LARGE__) || defined(__HUGE__) || defined(__COMPACT__) +-# define LDATA 1 +-# else +-# define LDATA 0 +-# endif +- /* GRR: why is Cygwin in here? Cygwin is not Borland C... */ +-# if !defined(__WIN32__) && !defined(__FLAT__) && !defined(__CYGWIN__) +-# define PNG_MAX_MALLOC_64K +-# if (LDATA != 1) +-# ifndef FAR +-# define FAR __far +-# endif +-# define USE_FAR_KEYWORD +-# endif /* LDATA != 1 */ +- /* Possibly useful for moving data out of default segment. +- * Uncomment it if you want. Could also define FARDATA as +- * const if your compiler supports it. (SJT) +-# define FARDATA FAR +- */ +-# endif /* __WIN32__, __FLAT__, __CYGWIN__ */ +-#endif /* __BORLANDC__ */ +- +- +-/* Suggest testing for specific compiler first before testing for +- * FAR. The Watcom compiler defines both __MEDIUM__ and M_I86MM, +- * making reliance oncertain keywords suspect. (SJT) +- */ +- +-/* MSC Medium model */ +-#ifdef FAR +-# ifdef M_I86MM +-# define USE_FAR_KEYWORD +-# define FARDATA FAR +-# include +-# endif +-#endif +- +-/* SJT: default case */ +-#ifndef FAR +-# define FAR +-#endif +- +-/* At this point FAR is always defined */ +-#ifndef FARDATA +-# define FARDATA +-#endif +- +-/* Typedef for floating-point numbers that are converted +- to fixed-point with a multiple of 100,000, e.g., int_gamma */ +-typedef png_int_32 png_fixed_point; +- +-/* Add typedefs for pointers */ +-typedef void FAR * png_voidp; +-typedef png_byte FAR * png_bytep; +-typedef png_uint_32 FAR * png_uint_32p; +-typedef png_int_32 FAR * png_int_32p; +-typedef png_uint_16 FAR * png_uint_16p; +-typedef png_int_16 FAR * png_int_16p; +-typedef PNG_CONST char FAR * png_const_charp; +-typedef char FAR * png_charp; +-typedef png_fixed_point FAR * png_fixed_point_p; +- +-#ifndef PNG_NO_STDIO +-#ifdef _WIN32_WCE +-typedef HANDLE png_FILE_p; +-#else +-typedef FILE * png_FILE_p; +-#endif +-#endif +- +-#ifdef PNG_FLOATING_POINT_SUPPORTED +-typedef double FAR * png_doublep; +-#endif +- +-/* Pointers to pointers; i.e. arrays */ +-typedef png_byte FAR * FAR * png_bytepp; +-typedef png_uint_32 FAR * FAR * png_uint_32pp; +-typedef png_int_32 FAR * FAR * png_int_32pp; +-typedef png_uint_16 FAR * FAR * png_uint_16pp; +-typedef png_int_16 FAR * FAR * png_int_16pp; +-typedef PNG_CONST char FAR * FAR * png_const_charpp; +-typedef char FAR * FAR * png_charpp; +-typedef png_fixed_point FAR * FAR * png_fixed_point_pp; +-#ifdef PNG_FLOATING_POINT_SUPPORTED +-typedef double FAR * FAR * png_doublepp; ++/* Pointers to pointers; i.e. arrays */ ++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 * * png_doublepp; + #endif + + /* Pointers to pointers to pointers; i.e., pointer to array */ +-typedef char FAR * FAR * FAR * png_charppp; +- +-#if defined(PNG_1_0_X) || defined(PNG_1_2_X) +-/* SPC - Is this stuff deprecated? */ +-/* It'll be removed as of libpng-1.4.0 - GR-P */ +-/* libpng typedefs for types in zlib. If zlib changes +- * or another compression library is used, then change these. +- * Eliminates need to change all the source files. +- */ +-typedef charf * png_zcharp; +-typedef charf * FAR * png_zcharpp; +-typedef z_stream FAR * png_zstreamp; +-#endif /* (PNG_1_0_X) || defined(PNG_1_2_X) */ +- +-/* +- * Define PNG_BUILD_DLL if the module being built is a Windows +- * LIBPNG DLL. +- * +- * Define PNG_USE_DLL if you want to *link* to the Windows LIBPNG DLL. +- * It is equivalent to Microsoft predefined macro _DLL that is +- * automatically defined when you compile using the share +- * version of the CRT (C Run-Time library) +- * +- * The cygwin mods make this behavior a little different: +- * Define PNG_BUILD_DLL if you are building a dll for use with cygwin +- * Define PNG_STATIC if you are building a static library for use with cygwin, +- * -or- if you are building an application that you want to link to the +- * static library. +- * PNG_USE_DLL is defined by default (no user action needed) unless one of +- * the other flags is defined. +- */ +- +-#if !defined(PNG_DLL) && (defined(PNG_BUILD_DLL) || defined(PNG_USE_DLL)) +-# define PNG_DLL +-#endif +-/* If CYGWIN, then disallow GLOBAL ARRAYS unless building a static lib. +- * When building a static lib, default to no GLOBAL ARRAYS, but allow +- * command-line override +- */ +-#ifdef __CYGWIN__ +-# ifndef PNG_STATIC +-# ifdef PNG_USE_GLOBAL_ARRAYS +-# undef PNG_USE_GLOBAL_ARRAYS +-# endif +-# ifndef PNG_USE_LOCAL_ARRAYS +-# define PNG_USE_LOCAL_ARRAYS +-# endif +-# else +-# if defined(PNG_USE_LOCAL_ARRAYS) || defined(PNG_NO_GLOBAL_ARRAYS) +-# ifdef PNG_USE_GLOBAL_ARRAYS +-# undef PNG_USE_GLOBAL_ARRAYS +-# endif +-# endif +-# endif +-# if !defined(PNG_USE_LOCAL_ARRAYS) && !defined(PNG_USE_GLOBAL_ARRAYS) +-# define PNG_USE_LOCAL_ARRAYS +-# endif +-#endif +- +-/* Do not use global arrays (helps with building DLL's) +- * They are no longer used in libpng itself, since version 1.0.5c, +- * but might be required for some pre-1.0.5c applications. +- */ +-#if !defined(PNG_USE_LOCAL_ARRAYS) && !defined(PNG_USE_GLOBAL_ARRAYS) +-# if defined(PNG_NO_GLOBAL_ARRAYS) || \ +- (defined(__GNUC__) && defined(PNG_DLL)) || defined(_MSC_VER) +-# define PNG_USE_LOCAL_ARRAYS +-# else +-# define PNG_USE_GLOBAL_ARRAYS +-# endif +-#endif +- +-#ifdef __CYGWIN__ +-# undef PNGAPI +-# define PNGAPI __cdecl +-# undef PNG_IMPEXP +-# define PNG_IMPEXP +-#endif +- +-/* If you define PNGAPI, e.g., with compiler option "-DPNGAPI=__stdcall", +- * you may get warnings regarding the linkage of png_zalloc and png_zfree. +- * Don't ignore those warnings; you must also reset the default calling +- * convention in your compiler to match your PNGAPI, and you must build +- * zlib and your applications the same way you build libpng. +- */ +- +-#if defined(__MINGW32__) && !defined(PNG_MODULEDEF) +-# ifndef PNG_NO_MODULEDEF +-# define PNG_NO_MODULEDEF +-# endif +-#endif +- +-#if !defined(PNG_IMPEXP) && defined(PNG_BUILD_DLL) && !defined(PNG_NO_MODULEDEF) +-# define PNG_IMPEXP +-#endif +- +-#if defined(PNG_DLL) || defined(_DLL) || defined(__DLL__ ) || \ +- (( defined(_Windows) || defined(_WINDOWS) || \ +- defined(WIN32) || defined(_WIN32) || defined(__WIN32__) )) +- +-# ifndef PNGAPI +-# if defined(__GNUC__) || (defined (_MSC_VER) && (_MSC_VER >= 800)) +-# define PNGAPI __cdecl +-# else +-# define PNGAPI _cdecl +-# endif +-# endif +- +-# if !defined(PNG_IMPEXP) && (!defined(PNG_DLL) || \ +- 0 /* WINCOMPILER_WITH_NO_SUPPORT_FOR_DECLIMPEXP */) +-# define PNG_IMPEXP +-# endif +- +-# ifndef PNG_IMPEXP +- +-# define PNG_EXPORT_TYPE1(type,symbol) PNG_IMPEXP type PNGAPI symbol +-# define PNG_EXPORT_TYPE2(type,symbol) type PNG_IMPEXP PNGAPI symbol +- +- /* Borland/Microsoft */ +-# if defined(_MSC_VER) || defined(__BORLANDC__) +-# if (_MSC_VER >= 800) || (__BORLANDC__ >= 0x500) +-# define PNG_EXPORT PNG_EXPORT_TYPE1 +-# else +-# define PNG_EXPORT PNG_EXPORT_TYPE2 +-# ifdef PNG_BUILD_DLL +-# define PNG_IMPEXP __export +-# else +-# define PNG_IMPEXP /*__import */ /* doesn't exist AFAIK in +- VC++ */ +-# endif /* Exists in Borland C++ for +- C++ classes (== huge) */ +-# endif +-# endif +- +-# ifndef PNG_IMPEXP +-# ifdef PNG_BUILD_DLL +-# define PNG_IMPEXP __declspec(dllexport) +-# else +-# define PNG_IMPEXP __declspec(dllimport) +-# endif +-# endif +-# endif /* PNG_IMPEXP */ +-#else /* !(DLL || non-cygwin WINDOWS) */ +-# if (defined(__IBMC__) || defined(__IBMCPP__)) && defined(__OS2__) +-# ifndef PNGAPI +-# define PNGAPI _System +-# endif +-# else +-# if 0 /* ... other platforms, with other meanings */ +-# endif +-# endif +-#endif +- +-#ifndef PNGAPI +-# define PNGAPI +-#endif +-#ifndef PNG_IMPEXP +-# define PNG_IMPEXP +-#endif +- +-#ifdef PNG_BUILDSYMS +-# ifndef PNG_EXPORT +-# define PNG_EXPORT(type,symbol) PNG_FUNCTION_EXPORT symbol END +-# endif +-# ifdef PNG_USE_GLOBAL_ARRAYS +-# ifndef PNG_EXPORT_VAR +-# define PNG_EXPORT_VAR(type) PNG_DATA_EXPORT +-# endif +-# endif +-#endif +- +-#ifndef PNG_EXPORT +-# define PNG_EXPORT(type,symbol) PNG_IMPEXP type PNGAPI symbol +-#endif +- +-#ifdef PNG_USE_GLOBAL_ARRAYS +-# ifndef PNG_EXPORT_VAR +-# define PNG_EXPORT_VAR(type) extern PNG_IMPEXP type +-# endif +-#endif +- +-#ifdef PNG_PEDANTIC_WARNINGS +-# ifndef PNG_PEDANTIC_WARNINGS_SUPPORTED +-# define PNG_PEDANTIC_WARNINGS_SUPPORTED +-# endif +-#endif +- +-#ifdef PNG_PEDANTIC_WARNINGS_SUPPORTED +-/* Support for compiler specific function attributes. These are used +- * so that where compiler support is available incorrect use of API +- * functions in png.h will generate compiler warnings. Added at libpng +- * version 1.2.41. +- */ +-# ifdef __GNUC__ +-# ifndef PNG_USE_RESULT +-# define PNG_USE_RESULT __attribute__((__warn_unused_result__)) +-# endif +-# ifndef PNG_NORETURN +-# define PNG_NORETURN __attribute__((__noreturn__)) +-# endif +-# ifndef PNG_ALLOCATED +-# define PNG_ALLOCATED __attribute__((__malloc__)) +-# endif +- +- /* This specifically protects structure members that should only be +- * accessed from within the library, therefore should be empty during +- * a library build. +- */ +-# ifndef PNG_DEPRECATED +-# define PNG_DEPRECATED __attribute__((__deprecated__)) +-# endif +-# ifndef PNG_DEPSTRUCT +-# define PNG_DEPSTRUCT __attribute__((__deprecated__)) +-# endif +-# ifndef PNG_PRIVATE +-# if 0 /* Doesn't work so we use deprecated instead*/ +-# define PNG_PRIVATE \ +- __attribute__((warning("This function is not exported by libpng."))) +-# else +-# define PNG_PRIVATE \ +- __attribute__((__deprecated__)) +-# endif +-# endif /* PNG_PRIVATE */ +-# endif /* __GNUC__ */ +-#endif /* PNG_PEDANTIC_WARNINGS */ +- +-#ifndef PNG_DEPRECATED +-# define PNG_DEPRECATED /* Use of this function is deprecated */ +-#endif +-#ifndef PNG_USE_RESULT +-# define PNG_USE_RESULT /* The result of this function must be checked */ +-#endif +-#ifndef PNG_NORETURN +-# define PNG_NORETURN /* This function does not return */ +-#endif +-#ifndef PNG_ALLOCATED +-# define PNG_ALLOCATED /* The result of the function is new memory */ +-#endif +-#ifndef PNG_DEPSTRUCT +-# define PNG_DEPSTRUCT /* Access to this struct member is deprecated */ +-#endif +-#ifndef PNG_PRIVATE +-# define PNG_PRIVATE /* This is a private libpng function */ +-#endif +- +-/* User may want to use these so they are not in PNG_INTERNAL. Any library +- * functions that are passed far data must be model independent. +- */ +- +-#ifndef PNG_ABORT +-# define PNG_ABORT() abort() +-#endif +- +-#ifdef PNG_SETJMP_SUPPORTED +-# define png_jmpbuf(png_ptr) ((png_ptr)->jmpbuf) +-#else +-# define png_jmpbuf(png_ptr) \ +- (LIBPNG_WAS_COMPILED_WITH__PNG_SETJMP_NOT_SUPPORTED) +-#endif +- +-#ifdef USE_FAR_KEYWORD /* memory model independent fns */ +-/* Use this to make far-to-near assignments */ +-# define CHECK 1 +-# define NOCHECK 0 +-# define CVT_PTR(ptr) (png_far_to_near(png_ptr,ptr,CHECK)) +-# define CVT_PTR_NOCHECK(ptr) (png_far_to_near(png_ptr,ptr,NOCHECK)) +-# define png_snprintf _fsnprintf /* Added to v 1.2.19 */ +-# define png_strlen _fstrlen +-# define png_memcmp _fmemcmp /* SJT: added */ +-# define png_memcpy _fmemcpy +-# define png_memset _fmemset +-#else /* Use the usual functions */ +-# define CVT_PTR(ptr) (ptr) +-# define CVT_PTR_NOCHECK(ptr) (ptr) +-# ifndef PNG_NO_SNPRINTF +-# ifdef _MSC_VER +-# define png_snprintf _snprintf /* Added to v 1.2.19 */ +-# define png_snprintf2 _snprintf +-# define png_snprintf6 _snprintf +-# else +-# define png_snprintf snprintf /* Added to v 1.2.19 */ +-# define png_snprintf2 snprintf +-# define png_snprintf6 snprintf +-# endif +-# else +- /* You don't have or don't want to use snprintf(). Caution: Using +- * sprintf instead of snprintf exposes your application to accidental +- * or malevolent buffer overflows. If you don't have snprintf() +- * as a general rule you should provide one (you can get one from +- * Portable OpenSSH). +- */ +-# define png_snprintf(s1,n,fmt,x1) sprintf(s1,fmt,x1) +-# define png_snprintf2(s1,n,fmt,x1,x2) sprintf(s1,fmt,x1,x2) +-# define png_snprintf6(s1,n,fmt,x1,x2,x3,x4,x5,x6) \ +- sprintf(s1,fmt,x1,x2,x3,x4,x5,x6) +-# endif +-# define png_strlen strlen +-# define png_memcmp memcmp /* SJT: added */ +-# define png_memcpy memcpy +-# define png_memset memset +-#endif +-/* End of memory model independent support */ +- +-/* Just a little check that someone hasn't tried to define something +- * contradictory. +- */ +-#if (PNG_ZBUF_SIZE > 65536L) && defined(PNG_MAX_MALLOC_64K) +-# undef PNG_ZBUF_SIZE +-# define PNG_ZBUF_SIZE 65536L +-#endif ++typedef char * * * png_charppp; + +-/* Added at libpng-1.2.8 */ +-#endif /* PNG_VERSION_INFO_ONLY */ ++#endif /* PNG_BUILDING_SYMBOL_TABLE */ + + #endif /* PNGCONF_H */ +diff --git a/com32/include/pngdebug.h b/com32/include/pngdebug.h +new file mode 100644 +index 00000000..00d5a456 +--- /dev/null ++++ b/com32/include/pngdebug.h +@@ -0,0 +1,153 @@ ++ ++/* pngdebug.h - Debugging macros for libpng, also used in pngtest.c ++ * ++ * Copyright (c) 2018 Cosmin Truta ++ * Copyright (c) 1998-2002,2004,2006-2013 Glenn Randers-Pehrson ++ * Copyright (c) 1996-1997 Andreas Dilger ++ * Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc. ++ * ++ * This code is released under the libpng license. ++ * For conditions of distribution and use, see the disclaimer ++ * and license in png.h ++ */ ++ ++/* Define PNG_DEBUG at compile time for debugging information. Higher ++ * numbers for PNG_DEBUG mean more debugging information. This has ++ * only been added since version 0.95 so it is not implemented throughout ++ * libpng yet, but more support will be added as needed. ++ * ++ * png_debug[1-2]?(level, message ,arg{0-2}) ++ * Expands to a statement (either a simple expression or a compound ++ * do..while(0) statement) that outputs a message with parameter ++ * substitution if PNG_DEBUG is defined to 2 or more. If PNG_DEBUG ++ * is undefined, 0 or 1 every png_debug expands to a simple expression ++ * (actually ((void)0)). ++ * ++ * level: level of detail of message, starting at 0. A level 'n' ++ * 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 ++ * to the message. ++ * arg: 0 to 2 arguments for printf(3) style substitution in message. ++ */ ++#ifndef PNGDEBUG_H ++#define PNGDEBUG_H ++/* These settings control the formatting of messages in png.c and pngerror.c */ ++/* Moved to pngdebug.h at 1.5.0 */ ++# ifndef PNG_LITERAL_SHARP ++# define PNG_LITERAL_SHARP 0x23 ++# endif ++# ifndef PNG_LITERAL_LEFT_SQUARE_BRACKET ++# define PNG_LITERAL_LEFT_SQUARE_BRACKET 0x5b ++# endif ++# ifndef PNG_LITERAL_RIGHT_SQUARE_BRACKET ++# define PNG_LITERAL_RIGHT_SQUARE_BRACKET 0x5d ++# endif ++# ifndef PNG_STRING_NEWLINE ++# define PNG_STRING_NEWLINE "\n" ++# endif ++ ++#ifdef PNG_DEBUG ++# if (PNG_DEBUG > 0) ++# if !defined(PNG_DEBUG_FILE) && defined(_MSC_VER) ++# include ++# if (PNG_DEBUG > 1) ++# ifndef _DEBUG ++# define _DEBUG ++# endif ++# ifndef png_debug ++# define png_debug(l,m) _RPT0(_CRT_WARN,m PNG_STRING_NEWLINE) ++# endif ++# ifndef png_debug1 ++# define png_debug1(l,m,p1) _RPT1(_CRT_WARN,m PNG_STRING_NEWLINE,p1) ++# endif ++# ifndef png_debug2 ++# define png_debug2(l,m,p1,p2) \ ++ _RPT2(_CRT_WARN,m PNG_STRING_NEWLINE,p1,p2) ++# endif ++# endif ++# else /* PNG_DEBUG_FILE || !_MSC_VER */ ++# ifndef PNG_STDIO_SUPPORTED ++# include /* not included yet */ ++# endif ++# ifndef PNG_DEBUG_FILE ++# define PNG_DEBUG_FILE stderr ++# endif /* PNG_DEBUG_FILE */ ++ ++# if (PNG_DEBUG > 1) ++# 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 ? " " : \ ++ (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 ? " " : \ ++ (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 ? " " : \ ++ (num_tabs==2 ? " " : (num_tabs>2 ? " " : ""))),p1,p2);\ ++ } while (0) ++# endif ++# else /* __STDC __ */ ++# ifndef png_debug ++# define png_debug(l,m) \ ++ do { \ ++ int num_tabs=l; \ ++ char format[256]; \ ++ snprintf(format,256,"%s%s%s",(num_tabs==1 ? "\t" : \ ++ (num_tabs==2 ? "\t\t":(num_tabs>2 ? "\t\t\t":""))), \ ++ m,PNG_STRING_NEWLINE); \ ++ fprintf(PNG_DEBUG_FILE,format); \ ++ } while (0) ++# endif ++# ifndef png_debug1 ++# define png_debug1(l,m,p1) \ ++ do { \ ++ int num_tabs=l; \ ++ char format[256]; \ ++ snprintf(format,256,"%s%s%s",(num_tabs==1 ? "\t" : \ ++ (num_tabs==2 ? "\t\t":(num_tabs>2 ? "\t\t\t":""))), \ ++ m,PNG_STRING_NEWLINE); \ ++ fprintf(PNG_DEBUG_FILE,format,p1); \ ++ } while (0) ++# endif ++# ifndef png_debug2 ++# define png_debug2(l,m,p1,p2) \ ++ do { \ ++ int num_tabs=l; \ ++ char format[256]; \ ++ snprintf(format,256,"%s%s%s",(num_tabs==1 ? "\t" : \ ++ (num_tabs==2 ? "\t\t":(num_tabs>2 ? "\t\t\t":""))), \ ++ m,PNG_STRING_NEWLINE); \ ++ fprintf(PNG_DEBUG_FILE,format,p1,p2); \ ++ } while (0) ++# endif ++# endif /* __STDC __ */ ++# endif /* (PNG_DEBUG > 1) */ ++ ++# endif /* _MSC_VER */ ++# endif /* (PNG_DEBUG > 0) */ ++#endif /* PNG_DEBUG */ ++#ifndef png_debug ++# define png_debug(l, m) ((void)0) ++#endif ++#ifndef png_debug1 ++# define png_debug1(l, m, p1) ((void)0) ++#endif ++#ifndef png_debug2 ++# define png_debug2(l, m, p1, p2) ((void)0) ++#endif ++#endif /* PNGDEBUG_H */ +diff --git a/com32/include/pnginfo.h b/com32/include/pnginfo.h +new file mode 100644 +index 00000000..1f98dedc +--- /dev/null ++++ b/com32/include/pnginfo.h +@@ -0,0 +1,267 @@ ++ ++/* pnginfo.h - header file for PNG reference library ++ * ++ * Copyright (c) 2018 Cosmin Truta ++ * Copyright (c) 1998-2002,2004,2006-2013,2018 Glenn Randers-Pehrson ++ * Copyright (c) 1996-1997 Andreas Dilger ++ * Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc. ++ * ++ * This code is released under the libpng license. ++ * For conditions of distribution and use, see the disclaimer ++ * and license in png.h ++ */ ++ ++ /* png_info is a structure that holds the information in a PNG file so ++ * that the application can find out the characteristics of the image. ++ * If you are reading the file, this structure will tell you what is ++ * in the PNG file. If you are writing the file, fill in the information ++ * you want to put into the PNG file, using png_set_*() functions, then ++ * call png_write_info(). ++ * ++ * The names chosen should be very close to the PNG specification, so ++ * consult that document for information about the meaning of each field. ++ * ++ * With libpng < 0.95, it was only possible to directly set and read the ++ * the values in the png_info_struct, which meant that the contents and ++ * order of the values had to remain fixed. With libpng 0.95 and later, ++ * however, there are now functions that abstract the contents of ++ * png_info_struct from the application, so this makes it easier to use ++ * libpng with dynamic libraries, and even makes it possible to use ++ * libraries that don't have all of the libpng ancillary chunk-handing ++ * functionality. In libpng-1.5.0 this was moved into a separate private ++ * file that is not visible to applications. ++ * ++ * The following members may have allocated storage attached that should be ++ * cleaned up before the structure is discarded: palette, trans, text, ++ * pcal_purpose, pcal_units, pcal_params, hist, iccp_name, iccp_profile, ++ * splt_palettes, scal_unit, row_pointers, and unknowns. By default, these ++ * are automatically freed when the info structure is deallocated, if they were ++ * allocated internally by libpng. This behavior can be changed by means ++ * of the png_data_freer() function. ++ * ++ * More allocation details: all the chunk-reading functions that ++ * change these members go through the corresponding png_set_* ++ * functions. A function to clear these members is available: see ++ * png_free_data(). The png_set_* functions do not depend on being ++ * able to point info structure members to any of the storage they are ++ * passed (they make their own copies), EXCEPT that the png_set_text ++ * functions use the same storage passed to them in the text_ptr or ++ * itxt_ptr structure argument, and the png_set_rows and png_set_unknowns ++ * functions do not make their own copies. ++ */ ++#ifndef PNGINFO_H ++#define PNGINFO_H ++ ++struct png_info_def ++{ ++ /* 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) */ ++ size_t rowbytes; /* bytes needed to hold an untransformed row */ ++ png_colorp palette; /* array of color values (valid & PNG_INFO_PLTE) */ ++ png_uint_16 num_palette; /* number of color entries in "palette" (PLTE) */ ++ png_uint_16 num_trans; /* number of transparent palette color (tRNS) */ ++ png_byte bit_depth; /* 1, 2, 4, 8, or 16 bits/channel (from IHDR) */ ++ png_byte color_type; /* see PNG_COLOR_TYPE_ below (from IHDR) */ ++ /* The following three should have been named *_method not *_type */ ++ png_byte compression_type; /* must be PNG_COMPRESSION_TYPE_BASE (IHDR) */ ++ png_byte filter_type; /* must be PNG_FILTER_TYPE_BASE (from IHDR) */ ++ png_byte interlace_type; /* One of PNG_INTERLACE_NONE, PNG_INTERLACE_ADAM7 */ ++ ++ /* The following 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 ++ * are writing, set the valid field to those chunks you want written, ++ * and initialize the appropriate fields below. ++ */ ++ ++#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_colorspace colorspace; ++#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 */ ++#endif ++ ++#ifdef PNG_TEXT_SUPPORTED ++ /* The tEXt, and zTXt chunks contain human-readable textual data in ++ * uncompressed, compressed, and optionally compressed forms, respectively. ++ * The data in "text" is an array of pointers to uncompressed, ++ * null-terminated C strings. Each chunk has a keyword that describes the ++ * textual data contained in that chunk. Keywords are not required to be ++ * unique, and the text string may be empty. Any number of text chunks may ++ * be in an image. ++ */ ++ int num_text; /* 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 /* TEXT */ ++ ++#ifdef PNG_tIME_SUPPORTED ++ /* The tIME chunk holds the last time the displayed image data was ++ * modified. See the png_time struct for the contents of this struct. ++ */ ++ png_time mod_time; ++#endif ++ ++#ifdef PNG_sBIT_SUPPORTED ++ /* The sBIT chunk specifies the number of significant high-order bits ++ * in the pixel data. Values are in the range [1, bit_depth], and are ++ * only specified for the channels in the pixel data. The contents of ++ * the low-order bits is not specified. Data is valid if ++ * (valid & PNG_INFO_sBIT) is non-zero. ++ */ ++ png_color_8 sig_bit; /* significant bits in color channels */ ++#endif ++ ++#if defined(PNG_tRNS_SUPPORTED) || defined(PNG_READ_EXPAND_SUPPORTED) || \ ++defined(PNG_READ_BACKGROUND_SUPPORTED) ++ /* The tRNS chunk supplies transparency data for paletted images and ++ * other image types that don't need a full alpha channel. There are ++ * "num_trans" transparency values for a paletted image, stored in the ++ * same order as the palette colors, starting from index 0. Values ++ * for the data are in the range [0, 255], ranging from fully transparent ++ * to fully opaque, respectively. For non-paletted images, there is a ++ * single color specified that should be treated as fully transparent. ++ * Data is valid if (valid & PNG_INFO_tRNS) is non-zero. ++ */ ++ png_bytep trans_alpha; /* alpha values for paletted image */ ++ png_color_16 trans_color; /* transparent color for non-palette image */ ++#endif ++ ++#if defined(PNG_bKGD_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) ++ /* The bKGD chunk gives the suggested image background color if the ++ * display program does not have its own background color and the image ++ * is needs to composited onto a background before display. The colors ++ * in "background" are normally in the same color space/depth as the ++ * pixel data. Data is valid if (valid & PNG_INFO_bKGD) is non-zero. ++ */ ++ png_color_16 background; ++#endif ++ ++#ifdef PNG_oFFs_SUPPORTED ++ /* The oFFs chunk gives the offset in "offset_unit_type" units rightwards ++ * and downwards from the top-left corner of the display, page, or other ++ * application-specific co-ordinate space. See the PNG_OFFSET_ defines ++ * below for the unit types. Valid if (valid & PNG_INFO_oFFs) non-zero. ++ */ ++ png_int_32 x_offset; /* x offset on page */ ++ png_int_32 y_offset; /* y offset on page */ ++ png_byte offset_unit_type; /* offset units type */ ++#endif ++ ++#ifdef PNG_pHYs_SUPPORTED ++ /* The pHYs chunk gives the physical pixel density of the image for ++ * display or printing in "phys_unit_type" units (see PNG_RESOLUTION_ ++ * defines below). Data is valid if (valid & PNG_INFO_pHYs) is non-zero. ++ */ ++ png_uint_32 x_pixels_per_unit; /* horizontal pixel density */ ++ png_uint_32 y_pixels_per_unit; /* vertical pixel density */ ++ png_byte phys_unit_type; /* resolution type (see PNG_RESOLUTION_ below) */ ++#endif ++ ++#ifdef PNG_eXIf_SUPPORTED ++ int num_exif; /* Added at libpng-1.6.31 */ ++ png_bytep exif; ++# ifdef PNG_READ_eXIf_SUPPORTED ++ png_bytep eXIf_buf; /* Added at libpng-1.6.32 */ ++# endif ++#endif ++ ++#ifdef PNG_hIST_SUPPORTED ++ /* The hIST chunk contains the relative frequency or importance of the ++ * various palette entries, so that a viewer can intelligently select a ++ * reduced-color palette, if required. Data is an array of "num_palette" ++ * values in the range [0,65535]. Data valid if (valid & PNG_INFO_hIST) ++ * is non-zero. ++ */ ++ png_uint_16p hist; ++#endif ++ ++#ifdef PNG_pCAL_SUPPORTED ++ /* The pCAL chunk describes a transformation between the stored pixel ++ * values and original physical data values used to create the image. ++ * The integer range [0, 2^bit_depth - 1] maps to the floating-point ++ * range given by [pcal_X0, pcal_X1], and are further transformed by a ++ * (possibly non-linear) transformation function given by "pcal_type" ++ * and "pcal_params" into "pcal_units". Please see the PNG_EQUATION_ ++ * defines below, and the PNG-Group's PNG extensions document for a ++ * complete description of the transformations and how they should be ++ * implemented, and for a description of the ASCII parameter strings. ++ * Data values are valid if (valid & PNG_INFO_pCAL) non-zero. ++ */ ++ png_charp pcal_purpose; /* pCAL chunk description string */ ++ png_int_32 pcal_X0; /* minimum value */ ++ png_int_32 pcal_X1; /* maximum value */ ++ png_charp pcal_units; /* Latin-1 string giving physical units */ ++ png_charpp pcal_params; /* ASCII strings containing parameter values */ ++ png_byte pcal_type; /* equation type (see PNG_EQUATION_ below) */ ++ png_byte pcal_nparams; /* number of parameters given in pcal_params */ ++#endif ++ ++/* New members added in libpng-1.0.6 */ ++ png_uint_32 free_me; /* flags items libpng is responsible for freeing */ ++ ++#ifdef PNG_STORE_UNKNOWN_CHUNKS_SUPPORTED ++ /* Storage for unknown chunks that the library doesn't recognize. */ ++ png_unknown_chunkp unknown_chunks; ++ ++ /* 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; ++ int splt_palettes_num; /* Match type returned by png_get API */ ++#endif ++ ++#ifdef PNG_sCAL_SUPPORTED ++ /* The sCAL chunk describes the actual physical dimensions of the ++ * subject matter of the graphic. The chunk contains a unit specification ++ * a byte value, and two ASCII strings representing floating-point ++ * values. The values are width and height corresponding to one pixel ++ * in the image. Data values are valid if (valid & PNG_INFO_sCAL) is ++ * non-zero. ++ */ ++ png_byte scal_unit; /* unit of physical scale */ ++ png_charp scal_s_width; /* string containing height */ ++ png_charp scal_s_height; /* string containing width */ ++#endif ++ ++#ifdef PNG_INFO_IMAGE_SUPPORTED ++ /* Memory has been allocated if (valid & PNG_ALLOCATED_INFO_ROWS) ++ non-zero */ ++ /* Data valid if (valid & PNG_INFO_IDAT) non-zero */ ++ png_bytepp row_pointers; /* the image bits */ ++#endif ++ ++}; ++#endif /* PNGINFO_H */ +diff --git a/com32/include/pnglibconf.h b/com32/include/pnglibconf.h +new file mode 100644 +index 00000000..5aab178f +--- /dev/null ++++ b/com32/include/pnglibconf.h +@@ -0,0 +1,219 @@ ++/* pnglibconf.h - library build configuration */ ++ ++/* libpng version 1.6.36 */ ++ ++/* Copyright (c) 2018 Cosmin Truta */ ++/* Copyright (c) 1998-2002,2004,2006-2018 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 */ ++#ifndef PNGLCONF_H ++#define PNGLCONF_H ++/* options */ ++#define PNG_16BIT_SUPPORTED ++/*#undef PNG_ALIGNED_MEMORY_SUPPORTED*/ ++/*#undef PNG_ARM_NEON_API_SUPPORTED*/ ++/*#undef PNG_ARM_NEON_CHECK_SUPPORTED*/ ++#define PNG_BENIGN_ERRORS_SUPPORTED ++#define PNG_BENIGN_READ_ERRORS_SUPPORTED ++#define PNG_BENIGN_WRITE_ERRORS_SUPPORTED ++/*#undef PNG_BUILD_GRAYSCALE_PALETTE_SUPPORTED*/ ++#define PNG_CHECK_FOR_INVALID_INDEX_SUPPORTED ++#define PNG_COLORSPACE_SUPPORTED ++/*#undef PNG_CONSOLE_IO_SUPPORTED*/ ++/*#undef PNG_CONVERT_tIME_SUPPORTED*/ ++#define PNG_EASY_ACCESS_SUPPORTED ++/*#undef PNG_ERROR_NUMBERS_SUPPORTED*/ ++/*#undef PNG_ERROR_TEXT_SUPPORTED */ ++#define PNG_FIXED_POINT_SUPPORTED ++/*#undef PNG_FLOATING_ARITHMETIC_SUPPORTED*/ ++/*#undef PNG_FLOATING_POINT_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*/ ++/*#undef PNG_INCH_CONVERSIONS_SUPPORTED*/ ++/*#undef PNG_INFO_IMAGE_SUPPORTED*/ ++#define PNG_IO_STATE_SUPPORTED ++/* #undef PNG_MNG_FEATURES_SUPPORTED */ ++#define PNG_POINTER_INDEXING_SUPPORTED ++/*#undef PNG_POWERPC_VSX_API_SUPPORTED*/ ++/*#undef PNG_POWERPC_VSX_CHECK_SUPPORTED*/ ++/*#undef PNG_PROGRESSIVE_READ_SUPPORTED*/ ++#define PNG_READ_16BIT_SUPPORTED ++#define PNG_READ_ALPHA_MODE_SUPPORTED ++#define PNG_READ_ANCILLARY_CHUNKS_SUPPORTED ++#define PNG_READ_BACKGROUND_SUPPORTED ++#define PNG_READ_BGR_SUPPORTED ++#define PNG_READ_CHECK_FOR_INVALID_INDEX_SUPPORTED ++#define PNG_READ_COMPOSITE_NODIV_SUPPORTED ++/*#undef PNG_READ_COMPRESSED_TEXT_SUPPORTED*/ ++#define PNG_READ_EXPAND_16_SUPPORTED ++#define PNG_READ_EXPAND_SUPPORTED ++#define PNG_READ_FILLER_SUPPORTED ++#define PNG_READ_GAMMA_SUPPORTED ++#define PNG_READ_GET_PALETTE_MAX_SUPPORTED ++#define PNG_READ_GRAY_TO_RGB_SUPPORTED ++#define PNG_READ_INTERLACING_SUPPORTED ++#define PNG_READ_INT_FUNCTIONS_SUPPORTED ++/*#undef PNG_READ_INVERT_ALPHA_SUPPORTED*/ ++/*#undef define PNG_READ_INVERT_SUPPORTED*/ ++/*#undef PNG_READ_OPT_PLTE_SUPPORTED*/ ++#define PNG_READ_PACKSWAP_SUPPORTED ++#define PNG_READ_PACK_SUPPORTED ++/*#undef PNG_READ_QUANTIZE_SUPPORTED*/ ++#define PNG_READ_RGB_TO_GRAY_SUPPORTED ++#define PNG_READ_SCALE_16_TO_8_SUPPORTED ++#define PNG_READ_SHIFT_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 ++/*#undef PNG_READ_TEXT_SUPPORTED*/ ++#define PNG_READ_TRANSFORMS_SUPPORTED ++/*#undef PNG_READ_UNKNOWN_CHUNKS_SUPPORTED*/ ++/*#undef PNG_READ_USER_CHUNKS_SUPPORTED*/ ++/*#undef PNG_READ_USER_TRANSFORM_SUPPORTED*/ ++#define PNG_READ_bKGD_SUPPORTED ++/*#define PNG_READ_cHRM_SUPPORTED*/ ++/*#undef PNG_READ_eXIf_SUPPORTED*/ ++#define PNG_READ_gAMA_SUPPORTED ++/*#undef PNG_READ_hIST_SUPPORTED*/ ++/*#undef PNG_READ_iCCP_SUPPORTED*/ ++/*#undef PNG_READ_iTXt_SUPPORTED*/ ++/*#undef PNG_READ_oFFs_SUPPORTED*/ ++/*#undef PNG_READ_pCAL_SUPPORTED*/ ++/*#undef PNG_READ_pHYs_SUPPORTED*/ ++#define PNG_READ_sBIT_SUPPORTED ++/*#undef PNG_READ_sCAL_SUPPORTED*/ ++/*#undef PNG_READ_sPLT_SUPPORTED*/ ++#define PNG_READ_sRGB_SUPPORTED ++/*#undef PNG_READ_tEXt_SUPPORTED*/ ++/*#undef PNG_READ_tIME_SUPPORTED*/ ++#define PNG_READ_tRNS_SUPPORTED ++/*#undef PNG_READ_zTXt_SUPPORTED*/ ++/*#undef PNG_SAVE_INT_32_SUPPORTED*/ ++/*#undef PNG_SAVE_UNKNOWN_CHUNKS_SUPPORTED*/ ++#define PNG_SEQUENTIAL_READ_SUPPORTED ++#define PNG_SETJMP_SUPPORTED ++#define PNG_SET_OPTION_SUPPORTED ++/*#undef PNG_SET_UNKNOWN_CHUNKS_SUPPORTED*/ ++#define PNG_SET_USER_LIMITS_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_STDIO_SUPPORTED*/ ++/*#undef PNG_SIMPLIFIED_WRITE_SUPPORTED*/ ++#define PNG_STDIO_SUPPORTED ++/*#undef PNG_STORE_UNKNOWN_CHUNKS_SUPPORTED*/ ++/*#undef PNG_TEXT_SUPPORTED*/ ++/*#undef PNG_TIME_RFC1123_SUPPORTED*/ ++/*#undef PNG_UNKNOWN_CHUNKS_SUPPORTED*/ ++/*#undef PNG_USER_CHUNKS_SUPPORTED*/ ++#define PNG_USER_LIMITS_SUPPORTED ++/*#undef PNG_USER_MEM_SUPPORTED*/ ++/*#undef PNG_USER_TRANSFORM_INFO_SUPPORTED*/ ++/*#undef PNG_USER_TRANSFORM_PTR_SUPPORTED*/ ++/*#undef 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_COMPRESSION_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_eXIf_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 ++/*#undef PNG_cHRM_SUPPORTED*/ ++/*#undef PNG_eXIf_SUPPORTED*/ ++#define PNG_gAMA_SUPPORTED ++/*#undef PNG_hIST_SUPPORTED*/ ++/*#undef PNG_iCCP_SUPPORTED*/ ++/*#undef PNG_iTXt_SUPPORTED*/ ++/*#undef PNG_oFFs_SUPPORTED*/ ++/*#undef PNG_pCAL_SUPPORTED*/ ++/*#undef PNG_pHYs_SUPPORTED*/ ++#define PNG_sBIT_SUPPORTED ++/*#undef PNG_sCAL_SUPPORTED*/ ++/*#undef PNG_sPLT_SUPPORTED*/ ++#define PNG_sRGB_SUPPORTED ++/*#undef PNG_tEXt_SUPPORTED*/ ++/*#undef PNG_tIME_SUPPORTED*/ ++#define PNG_tRNS_SUPPORTED ++/*#undef PNG_zTXt_SUPPORTED*/ ++/* end of options */ ++/* settings */ ++#define PNG_API_RULE 0 ++#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_LINKAGE_API extern ++#define PNG_LINKAGE_CALLBACK extern ++#define PNG_LINKAGE_DATA extern ++#define PNG_LINKAGE_FUNCTION extern ++#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 1000 ++#define PNG_USER_CHUNK_MALLOC_MAX 8000000 ++#define PNG_USER_HEIGHT_MAX 1000000 ++#define PNG_USER_WIDTH_MAX 1000000 ++#define PNG_ZBUF_SIZE 8192 ++#define PNG_ZLIB_VERNUM 0 /* unknown */ ++#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 */ +diff --git a/com32/include/pngpriv.h b/com32/include/pngpriv.h +new file mode 100644 +index 00000000..973c3eac +--- /dev/null ++++ b/com32/include/pngpriv.h +@@ -0,0 +1,2152 @@ ++ ++/* pngpriv.h - private declarations for use inside libpng ++ * ++ * Copyright (c) 2018 Cosmin Truta ++ * Copyright (c) 1998-2002,2004,2006-2018 Glenn Randers-Pehrson ++ * Copyright (c) 1996-1997 Andreas Dilger ++ * Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc. ++ * ++ * This code is released under the libpng license. ++ * For conditions of distribution and use, see the disclaimer ++ * and license in png.h ++ */ ++ ++/* The symbols declared in this file (including the functions declared ++ * 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. ++ * Although the libpng users are not forbidden to include this header, ++ * they should be well aware of the issues that may arise from doing so. ++ */ ++ ++#ifndef PNGPRIV_H ++#define PNGPRIV_H ++ ++/* Feature Test Macros. The following are defined here to ensure that correctly ++ * implemented libraries reveal the APIs libpng needs to build and hide those ++ * that are not needed and potentially damaging to the compilation. ++ * ++ * Feature Test Macros must be defined before any system header is included (see ++ * POSIX 1003.1 2.8.2 "POSIX Symbols." ++ * ++ * These macros only have an effect if the operating system supports either ++ * POSIX 1003.1 or C99, or both. On other operating systems (particularly ++ * Windows/Visual Studio) there is no effect; the OS specific tests below are ++ * still required (as of 2011-05-02.) ++ */ ++#ifndef _POSIX_SOURCE ++# define _POSIX_SOURCE 1 /* Just the POSIX 1003.1 and C89 APIs */ ++#endif ++ ++#ifndef PNG_VERSION_INFO_ONLY ++/* Standard library headers not required by png.h: */ ++# include ++# include ++#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. ++ */ ++#if defined(HAVE_CONFIG_H) && !defined(PNG_NO_CONFIG_H) ++# include ++ ++ /* 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 */ ++# ifndef PNG_USER_PRIVATEBUILD ++# define PNG_USER_PRIVATEBUILD "Custom libpng build" ++# endif ++# ifndef PNG_USER_DLLFNAME_POSTFIX ++# 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 the deprecated ++ * __ARM_NEON__, so we check both variants. ++ * ++ * To disable ARM_NEON optimizations entirely, and skip compiling the ++ * associated assembler code, pass --enable-arm-neon=no to configure ++ * or put -DPNG_ARM_NEON_OPT=0 in CPPFLAGS. ++ */ ++# 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: ++ */ ++# if !defined(__aarch64__) ++ /* The assembler code currently does not work on ARM64 */ ++# define PNG_ARM_NEON_IMPLEMENTATION 2 ++# endif /* __aarch64__ */ ++# 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 */ ++ ++#ifndef PNG_MIPS_MSA_OPT ++# if defined(__mips_msa) && (__mips_isa_rev >= 5) && defined(PNG_ALIGNED_MEMORY_SUPPORTED) ++# define PNG_MIPS_MSA_OPT 2 ++# else ++# define PNG_MIPS_MSA_OPT 0 ++# endif ++#endif ++ ++#ifndef PNG_POWERPC_VSX_OPT ++# if defined(__PPC64__) && defined(__ALTIVEC__) && defined(__VSX__) ++# define PNG_POWERPC_VSX_OPT 2 ++# else ++# define PNG_POWERPC_VSX_OPT 0 ++# endif ++#endif ++ ++#ifndef PNG_INTEL_SSE_OPT ++# ifdef PNG_INTEL_SSE ++ /* Only check for SSE if the build configuration has been modified to ++ * enable SSE optimizations. This means that these optimizations will ++ * be off by default. See contrib/intel for more details. ++ */ ++# if defined(__SSE4_1__) || defined(__AVX__) || defined(__SSSE3__) || \ ++ defined(__SSE2__) || defined(_M_X64) || defined(_M_AMD64) || \ ++ (defined(_M_IX86_FP) && _M_IX86_FP >= 2) ++# define PNG_INTEL_SSE_OPT 1 ++# else ++# define PNG_INTEL_SSE_OPT 0 ++# endif ++# else ++# define PNG_INTEL_SSE_OPT 0 ++# endif ++#endif ++ ++#if PNG_INTEL_SSE_OPT > 0 ++# ifndef PNG_INTEL_SSE_IMPLEMENTATION ++# if defined(__SSE4_1__) || defined(__AVX__) ++ /* We are not actually using AVX, but checking for AVX is the best ++ way we can detect SSE4.1 and SSSE3 on MSVC. ++ */ ++# define PNG_INTEL_SSE_IMPLEMENTATION 3 ++# elif defined(__SSSE3__) ++# define PNG_INTEL_SSE_IMPLEMENTATION 2 ++# elif defined(__SSE2__) || defined(_M_X64) || defined(_M_AMD64) || \ ++ (defined(_M_IX86_FP) && _M_IX86_FP >= 2) ++# define PNG_INTEL_SSE_IMPLEMENTATION 1 ++# else ++# define PNG_INTEL_SSE_IMPLEMENTATION 0 ++# endif ++# endif ++ ++# if PNG_INTEL_SSE_IMPLEMENTATION > 0 ++# define PNG_FILTER_OPTIMIZATIONS png_init_filter_functions_sse2 ++# endif ++#else ++# define PNG_INTEL_SSE_IMPLEMENTATION 0 ++#endif ++ ++#if PNG_MIPS_MSA_OPT > 0 ++# define PNG_FILTER_OPTIMIZATIONS png_init_filter_functions_msa ++# ifndef PNG_MIPS_MSA_IMPLEMENTATION ++# if defined(__mips_msa) ++# if defined(__clang__) ++# elif defined(__GNUC__) ++# if __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 7) ++# define PNG_MIPS_MSA_IMPLEMENTATION 2 ++# endif /* no GNUC support */ ++# endif /* __GNUC__ */ ++# else /* !defined __mips_msa */ ++# define PNG_MIPS_MSA_IMPLEMENTATION 2 ++# endif /* __mips_msa */ ++# endif /* !PNG_MIPS_MSA_IMPLEMENTATION */ ++ ++# ifndef PNG_MIPS_MSA_IMPLEMENTATION ++# define PNG_MIPS_MSA_IMPLEMENTATION 1 ++# endif ++#endif /* PNG_MIPS_MSA_OPT > 0 */ ++ ++#if PNG_POWERPC_VSX_OPT > 0 ++# define PNG_FILTER_OPTIMIZATIONS png_init_filter_functions_vsx ++# define PNG_POWERPC_VSX_IMPLEMENTATION 1 ++#endif ++ ++ ++/* 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) PNG_LINKAGE_DATA type name array ++#endif ++ ++#ifndef PNG_INTERNAL_FUNCTION ++# define PNG_INTERNAL_FUNCTION(type, name, args, attributes)\ ++ PNG_LINKAGE_FUNCTION PNG_FUNCTION(type, name, args, PNG_EMPTY attributes) ++#endif ++ ++#ifndef PNG_INTERNAL_CALLBACK ++# define PNG_INTERNAL_CALLBACK(type, name, args, attributes)\ ++ PNG_LINKAGE_CALLBACK 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" ++ ++/* pngconf.h does not set PNG_DLL_EXPORT unless it is required, so: */ ++#ifndef PNG_DLL_EXPORT ++# define PNG_DLL_EXPORT ++#endif ++ ++/* This is a global switch to set the compilation for an installed system ++ * (a release build). It can be set for testing debug builds to ensure that ++ * they will compile when the build type is switched to RC or STABLE, the ++ * default is just to use PNG_LIBPNG_BUILD_BASE_TYPE. Set this in CPPFLAGS ++ * with either: ++ * ++ * -DPNG_RELEASE_BUILD Turns on the release compile path ++ * -DPNG_RELEASE_BUILD=0 Turns it off ++ * or in your pngusr.h with ++ * #define PNG_RELEASE_BUILD=1 Turns on the release compile path ++ * #define PNG_RELEASE_BUILD=0 Turns it off ++ */ ++#ifndef PNG_RELEASE_BUILD ++# define PNG_RELEASE_BUILD (PNG_LIBPNG_BUILD_BASE_TYPE >= PNG_LIBPNG_BUILD_RC) ++#endif ++ ++/* SECURITY and SAFETY: ++ * ++ * libpng is built with support for internal limits on image dimensions and ++ * memory usage. These are documented in scripts/pnglibconf.dfa of the ++ * source and recorded in the machine generated header file pnglibconf.h. ++ */ ++ ++/* If you are running on a machine where you cannot allocate more ++ * than 64K of memory at once, uncomment this. While libpng will not ++ * normally need that much memory in a chunk (unless you load up a very ++ * large file), zlib needs to know how big of a chunk it can use, and ++ * libpng thus makes sure to check any memory allocation to verify it ++ * will fit into memory. ++ * ++ * zlib provides 'MAXSEG_64K' which, if defined, indicates the ++ * same limit and pngconf.h (already included) sets the limit ++ * if certain operating systems are detected. ++ */ ++#if defined(MAXSEG_64K) && !defined(PNG_MAX_MALLOC_64K) ++# define PNG_MAX_MALLOC_64K ++#endif ++ ++#ifndef PNG_UNUSED ++/* Unused formal parameter warnings are silenced using the following macro ++ * which is expected to have no bad effects on performance (optimizing ++ * compilers will probably remove it entirely). Note that if you replace ++ * it with something other than whitespace, you must include the terminating ++ * semicolon. ++ */ ++# define PNG_UNUSED(param) (void)param; ++#endif ++ ++/* Just a little check that someone hasn't tried to define something ++ * contradictory. ++ */ ++#if (PNG_ZBUF_SIZE > 65536L) && defined(PNG_MAX_MALLOC_64K) ++# undef PNG_ZBUF_SIZE ++# define PNG_ZBUF_SIZE 65536L ++#endif ++ ++/* 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. ++ */ ++#ifdef PNG_WARNINGS_SUPPORTED ++# define PNG_WARNING_PARAMETERS(p) png_warning_parameters p; ++#else ++# 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) ++# define png_formatted_warning(pp,p,message) ((void)(pp)) ++# define PNG_WARNING_PARAMETERS(p) ++#endif ++#ifndef PNG_ERROR_TEXT_SUPPORTED ++# define png_fixed_error(s1,s2) png_err(s1) ++#endif ++ ++/* Some fixed point APIs are still required even if not exported because ++ * they get used by the corresponding floating point APIs. This magic ++ * deals with this: ++ */ ++#ifdef PNG_FIXED_POINT_SUPPORTED ++# define PNGFAPI PNGAPI ++#else ++# 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. ++ */ ++ ++/* 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. ++ */ ++#ifdef __cplusplus ++# define png_voidcast(type, value) static_cast(value) ++# define png_constcast(type, value) const_cast(value) ++# define png_aligncast(type, value) \ ++ static_cast(static_cast(value)) ++# define png_aligncastconst(type, value) \ ++ static_cast(static_cast(value)) ++#else ++# define png_voidcast(type, value) (value) ++# ifdef _WIN64 ++# ifdef __GNUC__ ++ typedef unsigned long long png_ptruint; ++# else ++ typedef unsigned __int64 png_ptruint; ++# endif ++# else ++ typedef unsigned long png_ptruint; ++# endif ++# define png_constcast(type, value) ((type)(png_ptruint)(const void*)(value)) ++# define png_aligncast(type, value) ((void*)(value)) ++# define png_aligncastconst(type, value) ((const void*)(value)) ++#endif /* __cplusplus */ ++ ++#if defined(PNG_FLOATING_POINT_SUPPORTED) ||\ ++ defined(PNG_FLOATING_ARITHMETIC_SUPPORTED) ++ /* png.c requires the following ANSI-C constants if the conversion of ++ * floating point to ASCII is implemented therein: ++ * ++ * DBL_DIG Maximum number of decimal digits (can be set to any constant) ++ * DBL_MIN Smallest normalized fp number (can be set to an arbitrary value) ++ * DBL_MAX Maximum floating point number (can be set to an arbitrary value) ++ */ ++# include ++ ++# if (defined(__MWERKS__) && defined(macintosh)) || defined(applec) || \ ++ defined(THINK_C) || defined(__SC__) || defined(TARGET_OS_MAC) ++ /* We need to check that hasn't already been included earlier ++ * as it seems it doesn't agree with , yet we should really use ++ * if possible. ++ */ ++# if !defined(__MATH_H__) && !defined(__MATH_H) && !defined(__cmath__) ++# include ++# endif ++# else ++# include ++# endif ++# if defined(_AMIGA) && defined(__SASC) && defined(_M68881) ++ /* Amiga SAS/C: We must include builtin FPU functions when compiling using ++ * MATH=68881 ++ */ ++# include ++# endif ++#endif ++ ++/* This provides the non-ANSI (far) memory allocation routines. */ ++#if defined(__TURBOC__) && defined(__MSDOS__) ++# include ++# include ++#endif ++ ++#if defined(WIN32) || defined(_Windows) || defined(_WINDOWS) || \ ++ defined(_WIN32) || defined(__WIN32__) ++# include /* 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 ++ * functions that are passed far data must be model-independent. ++ */ ++ ++/* Memory model/platform independent fns */ ++#ifndef PNG_ABORT ++# ifdef _WINDOWS_ ++# define PNG_ABORT() ExitProcess(0) ++# else ++# define PNG_ABORT() abort() ++# endif ++#endif ++ ++/* 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 ++# 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 ++# 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)\ ++ (((type)((const char*)ptr-(const char*)0) & \ ++ (type)(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 */ ++ ++/* CONSTANTS and UTILITY MACROS ++ * These are used internally by libpng and not exposed in the API ++ */ ++ ++/* Various modes of operation. Note that after an init, mode is set to ++ * zero automatically when the structure is created. Three of these ++ * are defined in png.h because they need to be visible to applications ++ * that call png_set_unknown_chunk(). ++ */ ++/* #define PNG_HAVE_IHDR 0x01U (defined in png.h) */ ++/* #define PNG_HAVE_PLTE 0x02U (defined in png.h) */ ++#define PNG_HAVE_IDAT 0x04U ++/* #define PNG_AFTER_IDAT 0x08U (defined in png.h) */ ++#define PNG_HAVE_IEND 0x10U ++ /* 0x20U (unused) */ ++ /* 0x40U (unused) */ ++ /* 0x80U (unused) */ ++#define PNG_HAVE_CHUNK_HEADER 0x100U ++#define PNG_WROTE_tIME 0x200U ++#define PNG_WROTE_INFO_BEFORE_PLTE 0x400U ++#define PNG_BACKGROUND_IS_GRAY 0x800U ++#define PNG_HAVE_PNG_SIGNATURE 0x1000U ++#define PNG_HAVE_CHUNK_AFTER_IDAT 0x2000U /* Have another chunk after IDAT */ ++ /* 0x4000U (unused) */ ++#define PNG_IS_READ_STRUCT 0x8000U /* Else is a write struct */ ++ ++/* Flags for the transformations the PNG library does on the image data */ ++#define PNG_BGR 0x0001U ++#define PNG_INTERLACE 0x0002U ++#define PNG_PACK 0x0004U ++#define PNG_SHIFT 0x0008U ++#define PNG_SWAP_BYTES 0x0010U ++#define PNG_INVERT_MONO 0x0020U ++#define PNG_QUANTIZE 0x0040U ++#define PNG_COMPOSE 0x0080U /* Was PNG_BACKGROUND */ ++#define PNG_BACKGROUND_EXPAND 0x0100U ++#define PNG_EXPAND_16 0x0200U /* Added to libpng 1.5.2 */ ++#define PNG_16_TO_8 0x0400U /* Becomes 'chop' in 1.5.4 */ ++#define PNG_RGBA 0x0800U ++#define PNG_EXPAND 0x1000U ++#define PNG_GAMMA 0x2000U ++#define PNG_GRAY_TO_RGB 0x4000U ++#define PNG_FILLER 0x8000U ++#define PNG_PACKSWAP 0x10000U ++#define PNG_SWAP_ALPHA 0x20000U ++#define PNG_STRIP_ALPHA 0x40000U ++#define PNG_INVERT_ALPHA 0x80000U ++#define PNG_USER_TRANSFORM 0x100000U ++#define PNG_RGB_TO_GRAY_ERR 0x200000U ++#define PNG_RGB_TO_GRAY_WARN 0x400000U ++#define PNG_RGB_TO_GRAY 0x600000U /* two bits, RGB_TO_GRAY_ERR|WARN */ ++#define PNG_ENCODE_ALPHA 0x800000U /* Added to libpng-1.5.4 */ ++#define PNG_ADD_ALPHA 0x1000000U /* Added to libpng-1.2.7 */ ++#define PNG_EXPAND_tRNS 0x2000000U /* Added to libpng-1.2.9 */ ++#define PNG_SCALE_16_TO_8 0x4000000U /* Added to libpng-1.5.4 */ ++ /* 0x8000000U unused */ ++ /* 0x10000000U unused */ ++ /* 0x20000000U unused */ ++ /* 0x40000000U unused */ ++/* Flags for png_create_struct */ ++#define PNG_STRUCT_PNG 0x0001U ++#define PNG_STRUCT_INFO 0x0002U ++ ++/* Flags for the png_ptr->flags rather than declaring a byte for each one */ ++#define PNG_FLAG_ZLIB_CUSTOM_STRATEGY 0x0001U ++#define PNG_FLAG_ZSTREAM_INITIALIZED 0x0002U /* Added to libpng-1.6.0 */ ++ /* 0x0004U unused */ ++#define PNG_FLAG_ZSTREAM_ENDED 0x0008U /* Added to libpng-1.6.0 */ ++ /* 0x0010U unused */ ++ /* 0x0020U unused */ ++#define PNG_FLAG_ROW_INIT 0x0040U ++#define PNG_FLAG_FILLER_AFTER 0x0080U ++#define PNG_FLAG_CRC_ANCILLARY_USE 0x0100U ++#define PNG_FLAG_CRC_ANCILLARY_NOWARN 0x0200U ++#define PNG_FLAG_CRC_CRITICAL_USE 0x0400U ++#define PNG_FLAG_CRC_CRITICAL_IGNORE 0x0800U ++#define PNG_FLAG_ASSUME_sRGB 0x1000U /* Added to libpng-1.5.4 */ ++#define PNG_FLAG_OPTIMIZE_ALPHA 0x2000U /* Added to libpng-1.5.4 */ ++#define PNG_FLAG_DETECT_UNINITIALIZED 0x4000U /* Added to libpng-1.5.4 */ ++/* #define PNG_FLAG_KEEP_UNKNOWN_CHUNKS 0x8000U */ ++/* #define PNG_FLAG_KEEP_UNSAFE_CHUNKS 0x10000U */ ++#define PNG_FLAG_LIBRARY_MISMATCH 0x20000U ++#define PNG_FLAG_STRIP_ERROR_NUMBERS 0x40000U ++#define PNG_FLAG_STRIP_ERROR_TEXT 0x80000U ++#define PNG_FLAG_BENIGN_ERRORS_WARN 0x100000U /* Added to libpng-1.4.0 */ ++#define PNG_FLAG_APP_WARNINGS_WARN 0x200000U /* Added to libpng-1.6.0 */ ++#define PNG_FLAG_APP_ERRORS_WARN 0x400000U /* Added to libpng-1.6.0 */ ++ /* 0x800000U unused */ ++ /* 0x1000000U unused */ ++ /* 0x2000000U unused */ ++ /* 0x4000000U unused */ ++ /* 0x8000000U unused */ ++ /* 0x10000000U unused */ ++ /* 0x20000000U unused */ ++ /* 0x40000000U unused */ ++ ++#define PNG_FLAG_CRC_ANCILLARY_MASK (PNG_FLAG_CRC_ANCILLARY_USE | \ ++ PNG_FLAG_CRC_ANCILLARY_NOWARN) ++ ++#define PNG_FLAG_CRC_CRITICAL_MASK (PNG_FLAG_CRC_CRITICAL_USE | \ ++ PNG_FLAG_CRC_CRITICAL_IGNORE) ++ ++#define PNG_FLAG_CRC_MASK (PNG_FLAG_CRC_ANCILLARY_MASK | \ ++ PNG_FLAG_CRC_CRITICAL_MASK) ++ ++/* Save typing and make code easier to understand */ ++ ++#define PNG_COLOR_DIST(c1, c2) (abs((int)((c1).red) - (int)((c2).red)) + \ ++ abs((int)((c1).green) - (int)((c2).green)) + \ ++ abs((int)((c1).blue) - (int)((c2).blue))) ++ ++/* Added to libpng-1.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 ? \ ++ ((size_t)(width) * (((size_t)(pixel_bits)) >> 3)) : \ ++ (( ((size_t)(width) * ((size_t)(pixel_bits))) + 7) >> 3) ) ++ ++/* This returns the number of trailing bits in the last byte of a row, 0 if the ++ * last byte is completely full of pixels. It is, in principle, (pixel_bits x ++ * width) % 8, but that would overflow for large 'width'. The second macro is ++ * the same except that it returns the number of unused bits in the last byte; ++ * (8-TRAILBITS), but 0 when TRAILBITS is 0. ++ * ++ * NOTE: these macros are intended to be self-evidently correct and never ++ * overflow on the assumption that pixel_bits is in the range 0..255. The ++ * arguments are evaluated only once and they can be signed (e.g. as a result of ++ * the integral promotions). The result of the expression always has type ++ * (png_uint_32), however the compiler always knows it is in the range 0..7. ++ */ ++#define PNG_TRAILBITS(pixel_bits, width) \ ++ (((pixel_bits) * ((width) % (png_uint_32)8)) % 8) ++ ++#define PNG_PADBITS(pixel_bits, width) \ ++ ((8 - PNG_TRAILBITS(pixel_bits, width)) % 8) ++ ++/* PNG_OUT_OF_RANGE returns true if value is outside the range ++ * ideal-delta..ideal+delta. Each argument is evaluated twice. ++ * "ideal" and "delta" should be constants, normally simple ++ * integers, "value" a variable. Added to libpng-1.2.6 JB ++ */ ++#define PNG_OUT_OF_RANGE(value, ideal, delta) \ ++ ( (value) < (ideal)-(delta) || (value) > (ideal)+(delta) ) ++ ++/* Conversions between fixed and floating point, only defined if ++ * required (to make sure the code doesn't accidentally use float ++ * when it is supposedly disabled.) ++ */ ++#ifdef PNG_FLOATING_POINT_SUPPORTED ++/* The floating point conversion can't overflow, though it can and ++ * does lose accuracy relative to the original fixed point value. ++ * In practice this doesn't matter because png_fixed_point only ++ * stores numbers with very low precision. The png_ptr and s ++ * arguments are unused by default but are there in case error ++ * checking becomes a requirement. ++ */ ++#define png_float(png_ptr, fixed, s) (.00001 * (fixed)) ++ ++/* The fixed point conversion performs range checking and evaluates ++ * its argument multiple times, so must be used with care. The ++ * range checking uses the PNG specification values for a signed ++ * 32-bit fixed point value except that the values are deliberately ++ * rounded-to-zero to an integral value - 21474 (21474.83 is roughly ++ * (2^31-1) * 100000). 's' is a string that describes the value being ++ * converted. ++ * ++ * NOTE: this macro will raise a png_error if the range check fails, ++ * therefore it is normally only appropriate to use this on values ++ * that come from API calls or other sources where an out of range ++ * error indicates a programming error, not a data error! ++ * ++ * NOTE: by default this is off - the macro is not used - because the ++ * function call saves a lot of code. ++ */ ++#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)) ++#endif ++/* else the corresponding function is defined below, inside the scope of the ++ * cplusplus test. ++ */ ++#endif ++ ++/* 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_; 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_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_; 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_eXIf PNG_U32(101, 88, 73, 102) /* registered July 2017 */ ++#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) & 0xff), \ ++ ((char*)(s))[1]=(char)(((c)>>16) & 0xff),\ ++ ((char*)(s))[2]=(char)(((c)>>8) & 0xff), \ ++ ((char*)(s))[3]=(char)((c & 0xff))) ++ ++/* 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 directives 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)(0xff & ((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 */ ++ ++/* 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_INTERNAL_FUNCTION(int,png_user_version_check,(png_structrp png_ptr, ++ png_const_charp user_png_ver),PNG_EMPTY); ++ ++/* 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); ++ ++/* Function to free memory for zlib. PNGAPI is disallowed. */ ++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_INTERNAL_FUNCTION(void PNGCBAPI,png_default_read_data,(png_structp png_ptr, ++ png_bytep data, size_t length),PNG_EMPTY); ++ ++#ifdef PNG_PROGRESSIVE_READ_SUPPORTED ++PNG_INTERNAL_FUNCTION(void PNGCBAPI,png_push_fill_buffer,(png_structp png_ptr, ++ png_bytep buffer, size_t length),PNG_EMPTY); ++#endif ++ ++PNG_INTERNAL_FUNCTION(void PNGCBAPI,png_default_write_data,(png_structp png_ptr, ++ png_bytep data, size_t length),PNG_EMPTY); ++ ++#ifdef PNG_WRITE_FLUSH_SUPPORTED ++# ifdef PNG_STDIO_SUPPORTED ++PNG_INTERNAL_FUNCTION(void PNGCBAPI,png_default_flush,(png_structp png_ptr), ++ PNG_EMPTY); ++# endif ++#endif ++ ++/* Reset the CRC variable */ ++PNG_INTERNAL_FUNCTION(void,png_reset_crc,(png_structrp png_ptr),PNG_EMPTY); ++ ++/* Write the "data" buffer to whatever output you are using */ ++PNG_INTERNAL_FUNCTION(void,png_write_data,(png_structrp png_ptr, ++ png_const_bytep data, size_t length),PNG_EMPTY); ++ ++/* Read and check the PNG file signature */ ++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_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_INTERNAL_FUNCTION(void,png_read_data,(png_structrp png_ptr, png_bytep data, ++ size_t length),PNG_EMPTY); ++ ++/* Read bytes into buf, and update png_ptr->crc */ ++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_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_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_INTERNAL_FUNCTION(void,png_calculate_crc,(png_structrp png_ptr, ++ png_const_bytep ptr, size_t length),PNG_EMPTY); ++ ++#ifdef PNG_WRITE_FLUSH_SUPPORTED ++PNG_INTERNAL_FUNCTION(void,png_flush,(png_structrp png_ptr),PNG_EMPTY); ++#endif ++ ++/* Write various chunks */ ++ ++/* Write the IHDR chunk, and update the png_struct with the necessary ++ * information. ++ */ ++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_INTERNAL_FUNCTION(void,png_write_PLTE,(png_structrp png_ptr, ++ png_const_colorp palette, png_uint_32 num_pal),PNG_EMPTY); ++ ++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_INTERNAL_FUNCTION(void,png_write_IEND,(png_structrp png_ptr),PNG_EMPTY); ++ ++#ifdef PNG_WRITE_gAMA_SUPPORTED ++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_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 ++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_INTERNAL_FUNCTION(void,png_write_sRGB,(png_structrp png_ptr, ++ int intent),PNG_EMPTY); ++#endif ++ ++#ifdef PNG_WRITE_eXIf_SUPPORTED ++PNG_INTERNAL_FUNCTION(void,png_write_eXIf,(png_structrp png_ptr, ++ png_bytep exif, int num_exif),PNG_EMPTY); ++#endif ++ ++#ifdef PNG_WRITE_iCCP_SUPPORTED ++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_INTERNAL_FUNCTION(void,png_write_sPLT,(png_structrp png_ptr, ++ png_const_sPLT_tp palette),PNG_EMPTY); ++#endif ++ ++#ifdef PNG_WRITE_tRNS_SUPPORTED ++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),PNG_EMPTY); ++#endif ++ ++#ifdef PNG_WRITE_bKGD_SUPPORTED ++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_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 */ ++#ifdef PNG_WRITE_tEXt_SUPPORTED ++PNG_INTERNAL_FUNCTION(void,png_write_tEXt,(png_structrp png_ptr, ++ png_const_charp key, png_const_charp text, size_t text_len),PNG_EMPTY); ++#endif ++ ++#ifdef PNG_WRITE_zTXt_SUPPORTED ++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_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_EMPTY); ++#endif ++ ++#ifdef PNG_TEXT_SUPPORTED /* Added at version 1.0.14 and 1.2.4 */ ++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_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_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_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),PNG_EMPTY); ++#endif ++ ++#ifdef PNG_WRITE_tIME_SUPPORTED ++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_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_INTERNAL_FUNCTION(void,png_write_finish_row,(png_structrp png_ptr), ++ PNG_EMPTY); ++ ++/* Internal use only. Called before first row of data */ ++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. '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: 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_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_INTERNAL_FUNCTION(void,png_do_write_interlace,(png_row_infop row_info, ++ png_bytep row, int pass),PNG_EMPTY); ++#endif ++ ++/* 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); ++ ++#if PNG_ARM_NEON_OPT > 0 ++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); ++#endif ++ ++#if PNG_MIPS_MSA_OPT > 0 ++PNG_INTERNAL_FUNCTION(void,png_read_filter_row_up_msa,(png_row_infop row_info, ++ png_bytep row, png_const_bytep prev_row),PNG_EMPTY); ++PNG_INTERNAL_FUNCTION(void,png_read_filter_row_sub3_msa,(png_row_infop ++ row_info, png_bytep row, png_const_bytep prev_row),PNG_EMPTY); ++PNG_INTERNAL_FUNCTION(void,png_read_filter_row_sub4_msa,(png_row_infop ++ row_info, png_bytep row, png_const_bytep prev_row),PNG_EMPTY); ++PNG_INTERNAL_FUNCTION(void,png_read_filter_row_avg3_msa,(png_row_infop ++ row_info, png_bytep row, png_const_bytep prev_row),PNG_EMPTY); ++PNG_INTERNAL_FUNCTION(void,png_read_filter_row_avg4_msa,(png_row_infop ++ row_info, png_bytep row, png_const_bytep prev_row),PNG_EMPTY); ++PNG_INTERNAL_FUNCTION(void,png_read_filter_row_paeth3_msa,(png_row_infop ++ row_info, png_bytep row, png_const_bytep prev_row),PNG_EMPTY); ++PNG_INTERNAL_FUNCTION(void,png_read_filter_row_paeth4_msa,(png_row_infop ++ row_info, png_bytep row, png_const_bytep prev_row),PNG_EMPTY); ++#endif ++ ++#if PNG_POWERPC_VSX_OPT > 0 ++PNG_INTERNAL_FUNCTION(void,png_read_filter_row_up_vsx,(png_row_infop row_info, ++ png_bytep row, png_const_bytep prev_row),PNG_EMPTY); ++PNG_INTERNAL_FUNCTION(void,png_read_filter_row_sub3_vsx,(png_row_infop ++ row_info, png_bytep row, png_const_bytep prev_row),PNG_EMPTY); ++PNG_INTERNAL_FUNCTION(void,png_read_filter_row_sub4_vsx,(png_row_infop ++ row_info, png_bytep row, png_const_bytep prev_row),PNG_EMPTY); ++PNG_INTERNAL_FUNCTION(void,png_read_filter_row_avg3_vsx,(png_row_infop ++ row_info, png_bytep row, png_const_bytep prev_row),PNG_EMPTY); ++PNG_INTERNAL_FUNCTION(void,png_read_filter_row_avg4_vsx,(png_row_infop ++ row_info, png_bytep row, png_const_bytep prev_row),PNG_EMPTY); ++PNG_INTERNAL_FUNCTION(void,png_read_filter_row_paeth3_vsx,(png_row_infop ++ row_info, png_bytep row, png_const_bytep prev_row),PNG_EMPTY); ++PNG_INTERNAL_FUNCTION(void,png_read_filter_row_paeth4_vsx,(png_row_infop ++ row_info, png_bytep row, png_const_bytep prev_row),PNG_EMPTY); ++#endif ++ ++#if PNG_INTEL_SSE_IMPLEMENTATION > 0 ++PNG_INTERNAL_FUNCTION(void,png_read_filter_row_sub3_sse2,(png_row_infop ++ row_info, png_bytep row, png_const_bytep prev_row),PNG_EMPTY); ++PNG_INTERNAL_FUNCTION(void,png_read_filter_row_sub4_sse2,(png_row_infop ++ row_info, png_bytep row, png_const_bytep prev_row),PNG_EMPTY); ++PNG_INTERNAL_FUNCTION(void,png_read_filter_row_avg3_sse2,(png_row_infop ++ row_info, png_bytep row, png_const_bytep prev_row),PNG_EMPTY); ++PNG_INTERNAL_FUNCTION(void,png_read_filter_row_avg4_sse2,(png_row_infop ++ row_info, png_bytep row, png_const_bytep prev_row),PNG_EMPTY); ++PNG_INTERNAL_FUNCTION(void,png_read_filter_row_paeth3_sse2,(png_row_infop ++ row_info, png_bytep row, png_const_bytep prev_row),PNG_EMPTY); ++PNG_INTERNAL_FUNCTION(void,png_read_filter_row_paeth4_sse2,(png_row_infop ++ row_info, png_bytep row, png_const_bytep prev_row),PNG_EMPTY); ++#endif ++ ++/* Choose the best filter to use and filter the row data */ ++PNG_INTERNAL_FUNCTION(void,png_write_find_filter,(png_structrp png_ptr, ++ png_row_infop row_info),PNG_EMPTY); ++ ++#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_INTERNAL_FUNCTION(void,png_read_start_row,(png_structrp png_ptr),PNG_EMPTY); ++ ++#if ZLIB_VERNUM >= 0x1240 ++PNG_INTERNAL_FUNCTION(int,png_zlib_inflate,(png_structrp png_ptr, int flush), ++ PNG_EMPTY); ++# define PNG_INFLATE(pp, flush) png_zlib_inflate(pp, flush) ++#else /* Zlib < 1.2.4 */ ++# define PNG_INFLATE(pp, flush) inflate(&(pp)->zstream, flush) ++#endif /* Zlib < 1.2.4 */ ++ ++#ifdef PNG_READ_TRANSFORMS_SUPPORTED ++/* Optional call to update the users info structure */ ++PNG_INTERNAL_FUNCTION(void,png_read_transform_info,(png_structrp png_ptr, ++ png_inforp info_ptr),PNG_EMPTY); ++#endif ++ ++/* Shared transform functions, defined in pngtran.c */ ++#if defined(PNG_WRITE_FILLER_SUPPORTED) || \ ++ defined(PNG_READ_STRIP_ALPHA_SUPPORTED) ++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_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_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_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_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, ++ * then calls the appropriate callback for the chunk if it is valid. ++ */ ++ ++/* Decode the IHDR chunk */ ++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_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_INTERNAL_FUNCTION(void,png_handle_cHRM,(png_structrp png_ptr, ++ png_inforp info_ptr, png_uint_32 length),PNG_EMPTY); ++#endif ++ ++#ifdef PNG_READ_eXIf_SUPPORTED ++PNG_INTERNAL_FUNCTION(void,png_handle_eXIf,(png_structrp png_ptr, ++ png_inforp info_ptr, png_uint_32 length),PNG_EMPTY); ++#endif ++ ++#ifdef PNG_READ_gAMA_SUPPORTED ++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_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_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_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_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_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_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_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_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_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_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_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_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_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_INTERNAL_FUNCTION(void,png_handle_zTXt,(png_structrp png_ptr, ++ png_inforp info_ptr, png_uint_32 length),PNG_EMPTY); ++#endif ++ ++PNG_INTERNAL_FUNCTION(void,png_check_chunk_name,(png_const_structrp png_ptr, ++ png_uint_32 chunk_name),PNG_EMPTY); ++ ++PNG_INTERNAL_FUNCTION(void,png_check_chunk_length,(png_const_structrp png_ptr, ++ png_uint_32 chunk_length),PNG_EMPTY); ++ ++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_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_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_INTERNAL_FUNCTION(void,png_init_read_transformations,(png_structrp png_ptr), ++ PNG_EMPTY); ++#endif ++ ++#ifdef PNG_PROGRESSIVE_READ_SUPPORTED ++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_save_buffer,(png_structrp png_ptr), ++ PNG_EMPTY); ++PNG_INTERNAL_FUNCTION(void,png_push_restore_buffer,(png_structrp png_ptr, ++ png_bytep buffer, 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, 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_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_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_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 /* PROGRESSIVE_READ */ ++ ++/* 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_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. */ ++#ifdef PNG_READ_iCCP_SUPPORTED ++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); ++#endif /* READ_iCCP */ ++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 ++ ++#if defined(PNG_FLOATING_POINT_SUPPORTED) && defined(PNG_ERROR_TEXT_SUPPORTED) ++PNG_INTERNAL_FUNCTION(void,png_fixed_error,(png_const_structrp png_ptr, ++ png_const_charp name),PNG_NORETURN); ++#endif ++ ++/* Puts 'string' into 'buffer' at buffer[pos], taking care never to overwrite ++ * the end. Always leaves the buffer nul terminated. Never errors out (and ++ * there is no error code.) ++ */ ++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. ++ */ ++#if defined(PNG_WARNINGS_SUPPORTED) || defined(PNG_TIME_RFC1123_SUPPORTED) ++/* Utility to dump an unsigned value into a buffer, given a start pointer and ++ * and end pointer (which should point just *beyond* the end of the buffer!) ++ * Returns the pointer to the start of the formatted string. This utility only ++ * does unsigned values. ++ */ ++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) \ ++ png_format_number(buffer, buffer + (sizeof buffer), format, number) ++ ++/* Suggested size for a number buffer (enough for 64 bits and a sign!) */ ++#define PNG_NUMBER_BUFFER_SIZE 24 ++ ++/* These are the integer formats currently supported, the name is formed from ++ * the standard printf(3) format string. ++ */ ++#define PNG_NUMBER_FORMAT_u 1 /* chose unsigned API! */ ++#define PNG_NUMBER_FORMAT_02u 2 ++#define PNG_NUMBER_FORMAT_d 1 /* chose signed API! */ ++#define PNG_NUMBER_FORMAT_02d 2 ++#define PNG_NUMBER_FORMAT_x 3 ++#define PNG_NUMBER_FORMAT_02x 4 ++#define PNG_NUMBER_FORMAT_fixed 5 /* choose the signed API */ ++#endif ++ ++#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 /* 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. ++ */ ++typedef char png_warning_parameters[PNG_WARNING_PARAMETER_COUNT][ ++ PNG_WARNING_PARAMETER_SIZE]; ++ ++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_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_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 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_INTERNAL_FUNCTION(void,png_ascii_from_fp,(png_const_structrp png_ptr, ++ png_charp ascii, size_t size, double fp, unsigned int precision), ++ PNG_EMPTY); ++#endif /* FLOATING_POINT */ ++ ++#ifdef PNG_FIXED_POINT_SUPPORTED ++PNG_INTERNAL_FUNCTION(void,png_ascii_from_fixed,(png_const_structrp png_ptr, ++ png_charp ascii, size_t size, png_fixed_point fp),PNG_EMPTY); ++#endif /* FIXED_POINT */ ++#endif /* sCAL */ ++ ++#if defined(PNG_sCAL_SUPPORTED) || defined(PNG_pCAL_SUPPORTED) ++/* An internal API to validate the format of a floating point number. ++ * The result is the index of the next character. If the number is ++ * not valid it will be the index of a character in the supposed number. ++ * ++ * The format of a number is defined in the PNG extensions specification ++ * and this API is strictly conformant to that spec, not anyone elses! ++ * ++ * The format as a regular expression is: ++ * ++ * [+-]?[0-9]+.?([Ee][+-]?[0-9]+)? ++ * ++ * or: ++ * ++ * [+-]?.[0-9]+(.[0-9]+)?([Ee][+-]?[0-9]+)? ++ * ++ * The complexity is that either integer or fraction must be present and the ++ * fraction is permitted to have no digits only if the integer is present. ++ * ++ * NOTE: The dangling E problem. ++ * There is a PNG valid floating point number in the following: ++ * ++ * 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 ++ * doesn't matter for PNG sCAL chunk values, but it requires more care ++ * if the value were ever to be embedded in something more complex. Use ++ * ANSI-C strtod if you need the lookahead. ++ */ ++/* State table for the parser. */ ++#define PNG_FP_INTEGER 0 /* before or in integer */ ++#define PNG_FP_FRACTION 1 /* before or in fraction */ ++#define PNG_FP_EXPONENT 2 /* before or in exponent */ ++#define PNG_FP_STATE 3 /* mask for the above */ ++#define PNG_FP_SAW_SIGN 4 /* Saw +/- in current state */ ++#define PNG_FP_SAW_DIGIT 8 /* Saw a digit in current state */ ++#define PNG_FP_SAW_DOT 16 /* Saw a dot in current state */ ++#define PNG_FP_SAW_E 32 /* Saw an E (or e) in current state */ ++#define PNG_FP_SAW_ANY 60 /* Saw any of the above 4 */ ++ ++/* These three values don't affect the parser. They are set but not used. ++ */ ++#define PNG_FP_WAS_VALID 64 /* Preceding substring is a valid fp number */ ++#define PNG_FP_NEGATIVE 128 /* A negative number, including "-0" */ ++#define PNG_FP_NONZERO 256 /* A non-zero value */ ++#define PNG_FP_STICKY 448 /* The above three flags */ ++ ++/* This is available for the caller to store in 'state' if required. Do not ++ * call the parser after setting it (the parser sometimes clears it.) ++ */ ++#define PNG_FP_INVALID 512 /* Available for callers as a distinct value */ ++ ++/* Result codes for the parser (boolean - true meants ok, false means ++ * not ok yet.) ++ */ ++#define PNG_FP_MAYBE 0 /* The number may be valid in the future */ ++#define PNG_FP_OK 1 /* The number is valid */ ++ ++/* Tests on the sticky non-zero and negative flags. To pass these checks ++ * the state must also indicate that the whole number is valid - this is ++ * achieved by testing PNG_FP_SAW_DIGIT (see the implementation for why this ++ * is equivalent to PNG_FP_OK above.) ++ */ ++#define PNG_FP_NZ_MASK (PNG_FP_SAW_DIGIT | PNG_FP_NEGATIVE | PNG_FP_NONZERO) ++ /* NZ_MASK: the string is valid and a non-zero negative value */ ++#define PNG_FP_Z_MASK (PNG_FP_SAW_DIGIT | PNG_FP_NONZERO) ++ /* Z MASK: the string is valid and a non-zero value. */ ++ /* PNG_FP_SAW_DIGIT: the string is valid. */ ++#define PNG_FP_IS_ZERO(state) (((state) & PNG_FP_Z_MASK) == PNG_FP_SAW_DIGIT) ++#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 index into the string and the state variable (which must ++ * 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+ 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 ++ * the parser again (from the start, with state 0) but with a string ++ * 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_INTERNAL_FUNCTION(int,png_check_fp_number,(png_const_charp string, ++ 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 ++ * function also returns the state at the end of parsing the number if ++ * it was valid (otherwise it returns 0.) This can be used for testing ++ * for negative or zero values using the sticky flag. ++ */ ++PNG_INTERNAL_FUNCTION(int,png_check_fp_string,(png_const_charp string, ++ size_t size),PNG_EMPTY); ++#endif /* pCAL || sCAL */ ++ ++#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 ++ * if there is an overflow. The result is a boolean - false (0) ++ * for overflow, true (1) if no overflow, in which case *res ++ * holds the result. ++ */ ++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_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_GAMMA_SUPPORTED ++/* Calculate a reciprocal - used for gamma values. This returns ++ * 0 if the argument is 0 in order to maintain an undefined value; ++ * there are no warnings. ++ */ ++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. Only required at present on read. ++ */ ++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 ++/* Internal fixed point gamma correction. These APIs are called as ++ * required to convert single values - they don't need to be fast, ++ * they are not used when processing image pixel values. ++ * ++ * While the input is an 'unsigned' value it must actually be the ++ * correct bit value - 0..255 or 0..65535 as required. ++ */ ++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 ++ ++/* 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. */ ++ 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. ++ */ ++# if PNG_ARM_NEON_OPT > 0 ++PNG_INTERNAL_FUNCTION(void, png_init_filter_functions_neon, ++ (png_structp png_ptr, unsigned int bpp), PNG_EMPTY); ++#endif ++ ++#if PNG_MIPS_MSA_OPT > 0 ++PNG_INTERNAL_FUNCTION(void, png_init_filter_functions_msa, ++ (png_structp png_ptr, unsigned int bpp), PNG_EMPTY); ++#endif ++ ++# if PNG_INTEL_SSE_IMPLEMENTATION > 0 ++PNG_INTERNAL_FUNCTION(void, png_init_filter_functions_sse2, ++ (png_structp png_ptr, unsigned int bpp), PNG_EMPTY); ++# endif ++#endif ++ ++PNG_INTERNAL_FUNCTION(png_uint_32, png_check_keyword, (png_structrp png_ptr, ++ png_const_charp key, png_bytep new_key), PNG_EMPTY); ++ ++#if PNG_ARM_NEON_IMPLEMENTATION == 1 ++PNG_INTERNAL_FUNCTION(void, ++ png_riffle_palette_rgba, ++ (png_structrp, png_row_infop), ++ PNG_EMPTY); ++PNG_INTERNAL_FUNCTION(int, ++ png_do_expand_palette_neon_rgba, ++ (png_structrp, ++ png_row_infop, ++ png_const_bytep, ++ const png_bytepp, ++ const png_bytepp), ++ PNG_EMPTY); ++PNG_INTERNAL_FUNCTION(int, ++ png_do_expand_palette_neon_rgb, ++ (png_structrp, ++ png_row_infop, ++ png_const_bytep, ++ const png_bytepp, ++ const png_bytepp), ++ PNG_EMPTY); ++#endif ++ ++/* Maintainer: Put new private prototypes here ^ */ ++ ++#include "pngdebug.h" ++ ++#ifdef __cplusplus ++} ++#endif ++ ++#endif /* PNG_VERSION_INFO_ONLY */ ++#endif /* PNGPRIV_H */ +diff --git a/com32/include/pngstruct.h b/com32/include/pngstruct.h +new file mode 100644 +index 00000000..94a6d041 +--- /dev/null ++++ b/com32/include/pngstruct.h +@@ -0,0 +1,487 @@ ++ ++/* pngstruct.h - header file for PNG reference library ++ * ++ * Copyright (c) 2018 Cosmin Truta ++ * Copyright (c) 1998-2002,2004,2006-2018 Glenn Randers-Pehrson ++ * Copyright (c) 1996-1997 Andreas Dilger ++ * Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc. ++ * ++ * This code is released under the libpng license. ++ * For conditions of distribution and use, see the disclaimer ++ * and license in png.h ++ */ ++ ++/* The structure that holds the information to read and write PNG files. ++ * The only people who need to care about what is inside of this are the ++ * people who will be modifying the library for their own special needs. ++ * It should NOT be accessed directly by an application. ++ */ ++ ++#ifndef PNGSTRUCT_H ++#define PNGSTRUCT_H ++/* zlib.h defines the structure z_stream, an instance of which is included ++ * 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 ++ * maximum for size_t. The value can be overridden 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 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 ++ png_error_ptr warning_fn; /* function for printing warnings */ ++#endif ++ png_voidp error_ptr; /* user supplied struct for error functions */ ++ png_rw_ptr write_data_fn; /* function for writing output data */ ++ png_rw_ptr read_data_fn; /* function for reading input data */ ++ png_voidp io_ptr; /* ptr to application struct for I/O functions */ ++ ++#ifdef PNG_READ_USER_TRANSFORM_SUPPORTED ++ png_user_transform_ptr read_user_transform_fn; /* user read transform */ ++#endif ++ ++#ifdef PNG_WRITE_USER_TRANSFORM_SUPPORTED ++ png_user_transform_ptr write_user_transform_fn; /* user write transform */ ++#endif ++ ++/* These were added in libpng-1.0.2 */ ++#ifdef PNG_USER_TRANSFORM_PTR_SUPPORTED ++#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \ ++ defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) ++ png_voidp user_transform_ptr; /* user supplied struct for user transform */ ++ png_byte user_transform_depth; /* bit depth of user transformed pixels */ ++ png_byte user_transform_channels; /* channels in user transformed pixels */ ++#endif ++#endif ++ ++ png_uint_32 mode; /* tells us where we are in the PNG file */ ++ png_uint_32 flags; /* flags indicating various things to libpng */ ++ png_uint_32 transformations; /* which transformations to perform */ ++ ++ png_uint_32 zowner; /* ID (chunk type) of zstream owner, 0 if none */ ++ z_stream zstream; /* decompression structure */ ++ ++#ifdef PNG_WRITE_SUPPORTED ++ 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 */ ++ int zlib_window_bits; /* holds zlib compression window bits */ ++ int zlib_mem_level; /* holds zlib compression memory level */ ++ int zlib_strategy; /* holds zlib compression strategy */ ++#endif ++/* Added at libpng 1.5.4 */ ++#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 */ ++ int zlib_text_mem_level; /* holds zlib compression memory level */ ++ 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 */ ++ png_uint_32 num_rows; /* number of rows in current pass */ ++ png_uint_32 usr_width; /* width of row at start of write */ ++ 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_uint_32 chunk_name; /* PNG_CHUNK() id of current chunk */ ++ png_bytep prev_row; /* buffer to save previous (unfiltered) row. ++ * While reading this is a pointer into ++ * big_prev_row; while writing it is separately ++ * allocated if needed. ++ */ ++ png_bytep row_buf; /* buffer to save current (unfiltered) row. ++ * While reading, this is a pointer into ++ * big_row_buf; while writing it is separately ++ * allocated. ++ */ ++#ifdef PNG_READ_EXPAND_SUPPORTED ++ /* Buffer to accelerate palette transformations. */ ++ png_bytep riffled_palette; ++#endif ++#ifdef PNG_WRITE_FILTER_SUPPORTED ++ png_bytep try_row; /* buffer to save trial row when filtering */ ++ png_bytep tst_row; /* buffer to save best trial row when filtering */ ++#endif ++ 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 compression; /* file compression type (always 0) */ ++ png_byte filter; /* file filter type (always 0) */ ++ png_byte interlaced; /* PNG_INTERLACE_NONE, PNG_INTERLACE_ADAM7 */ ++ png_byte pass; /* current interlace pass (0 - 6) */ ++ png_byte do_filter; /* row filter flags (see PNG_FILTER_ in png.h ) */ ++ 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: write only */ ++ png_byte pixel_depth; /* number of bits per pixel */ ++ png_byte channels; /* number of channels in file */ ++#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 ZLIB_VERNUM >= 0x1240 ++ png_byte zstream_start; /* at start of an input zlib stream */ ++#endif /* Zlib >= 1.2.4 */ ++#if defined(PNG_READ_FILLER_SUPPORTED) || defined(PNG_WRITE_FILLER_SUPPORTED) ++ png_uint_16 filler; /* filler bytes for pixel expansion */ ++#endif ++ ++#if defined(PNG_bKGD_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) ||\ ++ defined(PNG_READ_ALPHA_MODE_SUPPORTED) ++ png_byte background_gamma_type; ++ png_fixed_point background_gamma; ++ png_color_16 background; /* background color in screen gamma space */ ++#ifdef PNG_READ_GAMMA_SUPPORTED ++ png_color_16 background_1; /* background normalized to gamma 1.0 */ ++#endif ++#endif /* bKGD */ ++ ++#ifdef PNG_WRITE_FLUSH_SUPPORTED ++ png_flush_ptr output_flush_fn; /* Function for flushing output */ ++ png_uint_32 flush_dist; /* how many rows apart to flush, 0 - no flush */ ++ png_uint_32 flush_rows; /* number of rows written since last flush */ ++#endif ++ ++#ifdef PNG_READ_GAMMA_SUPPORTED ++ int gamma_shift; /* number of "insignificant" bits in 16-bit gamma */ ++ png_fixed_point screen_gamma; /* screen gamma value (display_exponent) */ ++ ++ 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_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) ++ png_color_8 sig_bit; /* significant bits in each available channel */ ++#endif ++ ++#if defined(PNG_READ_SHIFT_SUPPORTED) || defined(PNG_WRITE_SHIFT_SUPPORTED) ++ png_color_8 shift; /* shift for significant bit transformation */ ++#endif ++ ++#if defined(PNG_tRNS_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) \ ++ || defined(PNG_READ_EXPAND_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) ++ png_bytep trans_alpha; /* alpha values for paletted files */ ++ png_color_16 trans_color; /* transparent color for non-paletted files */ ++#endif ++ ++ png_read_status_ptr read_row_fn; /* called after each row is decoded */ ++ png_write_status_ptr write_row_fn; /* called after each row is encoded */ ++#ifdef PNG_PROGRESSIVE_READ_SUPPORTED ++ png_progressive_info_ptr info_fn; /* called after header data fully read */ ++ png_progressive_row_ptr row_fn; /* called after a prog. row is decoded */ ++ png_progressive_end_ptr end_fn; /* called after image is complete */ ++ png_bytep save_buffer_ptr; /* current location in save_buffer */ ++ png_bytep save_buffer; /* buffer for previously read data */ ++ png_bytep current_buffer_ptr; /* current location in current_buffer */ ++ png_bytep current_buffer; /* buffer for recently used data */ ++ png_uint_32 push_length; /* size of current input chunk */ ++ png_uint_32 skip_length; /* bytes to skip in input data */ ++ size_t save_buffer_size; /* amount of data now in save_buffer */ ++ size_t save_buffer_max; /* total size of save_buffer */ ++ size_t buffer_size; /* total amount of available input data */ ++ size_t current_buffer_size; /* amount of data now in current_buffer */ ++ int process_mode; /* what push library is currently doing */ ++ int cur_palette; /* current push library palette index */ ++ ++#endif /* PROGRESSIVE_READ */ ++ ++#if defined(__TURBOC__) && !defined(_Windows) && !defined(__FLAT__) ++/* For the Borland special 64K segment handler */ ++ png_bytepp offset_table_ptr; ++ png_bytep offset_table; ++ png_uint_16 offset_table_number; ++ png_uint_16 offset_table_count; ++ png_uint_16 offset_table_count_free; ++#endif ++ ++#ifdef PNG_READ_QUANTIZE_SUPPORTED ++ png_bytep palette_lookup; /* lookup table for quantizing */ ++ png_bytep quantize_index; /* index translation for palette files */ ++#endif ++ ++/* Options */ ++#ifdef PNG_SET_OPTION_SUPPORTED ++ png_uint_32 options; /* On/off state (up to 16 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 */ ++ ++ png_uint_32 free_me; /* flags items libpng is responsible for freeing */ ++ ++#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_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; ++ /* 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) ++/* Changed from png_byte to png_uint_32 at version 1.2.0 */ ++ png_uint_32 mng_features_permitted; ++#endif ++ ++/* New member added in libpng-1.0.9, ifdef'ed out in 1.0.12, enabled in 1.2.0 */ ++#ifdef PNG_MNG_FEATURES_SUPPORTED ++ png_byte filter_type; ++#endif ++ ++/* New members added in libpng-1.2.0 */ ++ ++/* New members added in libpng-1.0.2 but first enabled by default in 1.2.0 */ ++#ifdef PNG_USER_MEM_SUPPORTED ++ png_voidp mem_ptr; /* user supplied struct for mem functions */ ++ png_malloc_ptr malloc_fn; /* function for allocating memory */ ++ png_free_ptr free_fn; /* function for freeing memory */ ++#endif ++ ++/* New member added in libpng-1.0.13 and 1.2.0 */ ++ png_bytep big_row_buf; /* buffer to save current (unfiltered) row */ ++ ++#ifdef PNG_READ_QUANTIZE_SUPPORTED ++/* The following three members were added at version 1.0.14 and 1.2.4 */ ++ png_bytep quantize_sort; /* working sort array */ ++ png_bytep index_to_palette; /* where the original index currently is ++ in the palette */ ++ png_bytep palette_to_index; /* which original index points to this ++ palette color */ ++#endif ++ ++/* New members added in libpng-1.0.16 and 1.2.6 */ ++ png_byte compression_type; ++ ++#ifdef PNG_USER_LIMITS_SUPPORTED ++ png_uint_32 user_width_max; ++ png_uint_32 user_height_max; ++ ++ /* Added in libpng-1.4.0: Total number of sPLT, text, and unknown ++ * chunks that can be stored (0 means unlimited). ++ */ ++ png_uint_32 user_chunk_cache_max; ++ ++ /* Total memory that a zTXt, sPLT, iTXt, iCCP, or unknown chunk ++ * can occupy when decompressed. 0 means unlimited. ++ */ ++ png_alloc_size_t user_chunk_malloc_max; ++#endif ++ ++/* New member added in libpng-1.0.25 and 1.2.17 */ ++#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 member added in libpng-1.2.26 */ ++ size_t old_big_row_buf_size; ++ ++#ifdef PNG_READ_SUPPORTED ++/* New member added in libpng-1.2.30 */ ++ 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 */ +diff --git a/com32/lib/libpng/ANNOUNCE b/com32/lib/libpng/ANNOUNCE +index b0824ee7..f1724c0d 100644 +--- a/com32/lib/libpng/ANNOUNCE ++++ b/com32/lib/libpng/ANNOUNCE +@@ -1,57 +1,77 @@ ++libpng 1.6.36 - December 1, 2018 ++================================ + +-Libpng 1.2.44 - June 26, 2010 ++This is a public release of libpng, intended for use in production code. + +-This is a public release of libpng, intended for use in production codes. + +-Files available for download: ++Files available for download ++---------------------------- + +-Source files with LF line endings (for Unix/Linux) and with a +-"configure" script ++Source files with LF line endings (for Unix/Linux): + +- libpng-1.2.44.tar.xz (LZMA-compressed, recommended) +- libpng-1.2.44.tar.gz +- libpng-1.2.44.tar.bz2 ++ * libpng-1.6.36.tar.xz (LZMA-compressed, recommended) ++ * libpng-1.6.36.tar.gz + +-Source files with LF line endings (for Unix/Linux) without the +-"configure" script ++Source files with CRLF line endings (for Windows): + +- libpng-1.2.44-no-config.tar.xz (LZMA-compressed, recommended) +- libpng-1.2.44-no-config.tar.gz +- libpng-1.2.44-no-config.tar.bz2 +- +-Source files with CRLF line endings (for Windows), without the +-"configure" script +- +- lpng1244.zip +- lpng1244.7z +- lpng1244.tar.bz2 +- +-Project files +- +- libpng-1.2.44-project-netware.zip +- libpng-1.2.44-project-wince.zip ++ * lp1636.7z (LZMA-compressed, recommended) ++ * lp1636.zip + + Other information: + +- libpng-1.2.44-README.txt +- libpng-1.2.44-KNOWNBUGS.txt +- libpng-1.2.44-LICENSE.txt +- libpng-1.2.44-Y2K-compliance.txt +- libpng-1.2.44-[previous version]-diff.txt +- +-Changes since the last public release (1.2.43): +- +-version 1.2.44 [June 26, 2010] +- +- Rewrote png_process_IDAT_data to consistently treat extra data as warnings +- and handle end conditions more cleanly. +- Removed the now-redundant check for out-of-bounds new_row from example.c +- +- +-Send comments/corrections/commendations to png-mng-implement at lists.sf.net +- +-(subscription required; visit ++ * README.md ++ * LICENSE.md ++ * AUTHORS.md ++ * TRADEMARK.md ++ ++ ++IMPORTANT licensing update: libpng license v2 ++--------------------------------------------- ++ ++The new libpng license comprises the terms and conditions from the zlib ++license, and the disclaimer from the Boost license. ++ ++The legacy libpng license, used until libpng-1.6.35, is appended to the ++new license, following the precedent established in the Python Software ++Foundation License version 2. ++ ++From now on, the list of contributing authors shall be maintained in a ++separate AUTHORS file. The lists of previous contributing authors, ++mentioned in the legacy libpng license and considered to be an integral ++part of that license, are kept intact, with no further updates. ++ ++ ++Changes since the previous public release (version 1.6.35) ++---------------------------------------------------------- ++ ++ * Optimized png_do_expand_palette for ARM processors. ++ Improved performance by around 10-22% on a recent ARM Chromebook. ++ (Contributed by Richard Townsend, ARM Holdings) ++ * Fixed manipulation of machine-specific optimization options. ++ (Contributed by Vicki Pfau) ++ * Used memcpy instead of manual pointer arithmetic on Intel SSE2. ++ (Contributed by Samuel Williams) ++ * Fixed build errors with MSVC on ARM64. ++ (Contributed by Zhijie Liang) ++ * Fixed detection of libm in CMakeLists. ++ (Contributed by Cameron Cawley) ++ * Fixed incorrect creation of pkg-config file in CMakeLists. ++ (Contributed by Kyle Bentley) ++ * Fixed the CMake build on Windows MSYS by avoiding symlinks. ++ * Fixed a build warning on OpenBSD. ++ (Contributed by Theo Buehler) ++ * Fixed various typos in comments. ++ (Contributed by "luz.paz") ++ * Raised the minimum required CMake version from 3.0.2 to 3.1. ++ * Removed yet more of the vestigial support for pre-ANSI C compilers. ++ * Removed ancient makefiles for ancient systems that have been broken ++ across all previous libpng-1.6.x versions. ++ * Removed the Y2K compliance statement and the export control ++ information. ++ * Applied various code style and documentation fixes. ++ ++ ++Send comments/corrections/commendations to png-mng-implement at lists.sf.net. ++Subscription is required; visit + https://lists.sourceforge.net/lists/listinfo/png-mng-implement +-to subscribe) or to glennrp at users.sourceforge.net +- +-Glenn R-P ++to subscribe. +diff --git a/com32/lib/libpng/CHANGES b/com32/lib/libpng/CHANGES +index 90a3e2be..bdd44806 100644 +--- a/com32/lib/libpng/CHANGES ++++ b/com32/lib/libpng/CHANGES +@@ -1,11 +1,13 @@ +-/* + CHANGES - changes for libpng + +-version 0.2 ++version 0.1 [March 29, 1995] ++ initial work-in-progress release ++ ++version 0.2 [April 1, 1995] + added reader into png.h + fixed small problems in stub file + +-version 0.3 ++version 0.3 [April 8, 1995] + added pull reader + split up pngwrite.c to several files + added pnglib.txt +@@ -16,7 +18,7 @@ version 0.3 + added K&R support + added check for 64 KB blocks for 16 bit machines + +-version 0.4 ++version 0.4 [April 26, 1995] + cleaned up code and commented code + simplified time handling into png_time + created png_color_16 and png_color_8 to handle color needs +@@ -27,28 +29,29 @@ version 0.4 + cleaned up zTXt reader and writer (using zlib's Reset functions) + split transformations into pngrtran.c and pngwtran.c + +-version 0.5 ++version 0.5 [April 30, 1995] + interfaced with zlib 0.8 + fixed many reading and writing bugs + saved using 3 spaces instead of tabs + +-version 0.6 ++version 0.6 [May 1, 1995] ++ first beta release + added png_large_malloc() and png_large_free() + added png_size_t + cleaned up some compiler warnings + added png_start_read_image() + +-version 0.7 ++version 0.7 [June 24, 1995] + cleaned up lots of bugs + finished dithering and other stuff + added test program + changed name from pnglib to libpng + +-version 0.71 [June, 1995] ++version 0.71 [June 26, 1995] + changed pngtest.png for zlib 0.93 + fixed error in libpng.txt and example.c + +-version 0.8 ++version 0.8 [August 20, 1995] + cleaned up some bugs + added png_set_filler() + split up pngstub.c into pngmem.c, pngio.c, and pngerror.c +@@ -62,191 +65,199 @@ version 0.8 + changed external functions passing floats to doubles (k&r problems?) + put all the configurable stuff in pngconf.h + enabled png_set_shift to work with paletted images on read +- added png_read_update_info() - updates info structure with +- transformations ++ added png_read_update_info() - updates info structure with transformations + +-version 0.81 [August, 1995] ++Version 0.81 [August, 1995] + incorporated Tim Wegner's medium model code (thanks, Tim) + +-version 0.82 [September, 1995] ++Version 0.82 [September, 1995] + [unspecified changes] + +-version 0.85 [December, 1995] ++Version 0.85 [December, 1995] + added more medium model code (almost everything's a far) + added i/o, error, and memory callback functions +- fixed some bugs (16 bit, 4 bit interlaced, etc.) ++ fixed some bugs (16-bit, 4-bit interlaced, etc.) + added first run progressive reader (barely tested) + +-version 0.86 [January, 1996] ++Version 0.86 [January, 1996] + fixed bugs + improved documentation + +-version 0.87 [January, 1996] ++Version 0.87 [January, 1996] + fixed medium model bugs + fixed other bugs introduced in 0.85 and 0.86 + added some minor documentation + +-version 0.88 [January, 1996] ++Version 0.88 [January, 1996] + fixed progressive bugs + replaced tabs with spaces + cleaned up documentation + added callbacks for read/write and warning/error functions + +-version 0.89 [July, 1996] +- added new initialization API to make libpng work better with shared libs +- we now have png_create_read_struct(), png_create_write_struct(), +- png_create_info_struct(), png_destroy_read_struct(), and +- png_destroy_write_struct() instead of the separate calls to +- malloc and png_read_init(), png_info_init(), and png_write_init() +- changed warning/error callback functions to fix bug - this means you +- should use the new initialization API if you were using the old +- png_set_message_fn() calls, and that the old API no longer exists +- so that people are aware that they need to change their code +- changed filter selection API to allow selection of multiple filters +- since it didn't work in previous versions of libpng anyways +- optimized filter selection code +- fixed png_set_background() to allow using an arbitrary RGB color for +- paletted images +- fixed gamma and background correction for paletted images, so +- png_correct_palette is not needed unless you are correcting an +- external palette (you will need to #define PNG_CORRECT_PALETTE_SUPPORTED +- in pngconf.h) - if nobody uses this, it may disappear in the future. +- fixed bug with Borland 64K memory allocation (Alexander Lehmann) +- fixed bug in interlace handling (Smarasderagd, I think) +- added more error checking for writing and image to reduce invalid files +- separated read and write functions so that they won't both be linked +- into a binary when only reading or writing functionality is used +- new pngtest image also has interlacing and zTXt +- updated documentation to reflect new API +- +-version 0.90 [January, 1997] +- made CRC errors/warnings on critical and ancillary chunks configurable ++Version 0.89 [June 5, 1996] ++ Added new initialization API to make libpng work better with shared libs ++ we now have png_create_read_struct(), png_create_write_struct(), ++ png_create_info_struct(), png_destroy_read_struct(), and ++ png_destroy_write_struct() instead of the separate calls to ++ malloc and png_read_init(), png_info_init(), and png_write_init() ++ Changed warning/error callback functions to fix bug - this means you ++ should use the new initialization API if you were using the old ++ png_set_message_fn() calls, and that the old API no longer exists ++ so that people are aware that they need to change their code ++ Changed filter selection API to allow selection of multiple filters ++ since it didn't work in previous versions of libpng anyways ++ Optimized filter selection code ++ Fixed png_set_background() to allow using an arbitrary RGB color for ++ paletted images ++ Fixed gamma and background correction for paletted images, so ++ png_correct_palette is not needed unless you are correcting an ++ external palette (you will need to #define PNG_CORRECT_PALETTE_SUPPORTED ++ in pngconf.h) - if nobody uses this, it may disappear in the future. ++ Fixed bug with Borland 64K memory allocation (Alexander Lehmann) ++ Fixed bug in interlace handling (Smarasderagd, I think) ++ Added more error checking for writing and image to reduce invalid files ++ Separated read and write functions so that they won't both be linked ++ into a binary when only reading or writing functionality is used ++ New pngtest image also has interlacing and zTXt ++ Updated documentation to reflect new API ++ ++Version 0.89c [June 17, 1996] ++ Bug fixes. ++ ++Version 0.90 [January, 1997] ++ Made CRC errors/warnings on critical and ancillary chunks configurable + libpng will use the zlib CRC routines by (compile-time) default +- changed DOS small/medium model memory support - needs zlib 1.04 (Tim Wegner) +- added external C++ wrapper statements to png.h (Gilles Dauphin) +- allow PNG file to be read when some or all of file signature has already +- been read from the beginning of the stream. ****This affects the size +- of info_struct and invalidates all programs that use a shared libpng**** +- fixed png_filler() declarations +- fixed? background color conversions +- fixed order of error function pointers to match documentation +- current chunk name is now available in png_struct to reduce the number +- of nearly identical error messages (will simplify multi-lingual +- support when available) +- try to get ready for unknown-chunk callback functions: +- - previously read critical chunks are flagged, so the chunk handling +- routines can determine if the chunk is in the right place +- - all chunk handling routines have the same prototypes, so we will +- be able to handle all chunks via a callback mechanism +- try to fix Linux "setjmp" buffer size problems +- removed png_large_malloc, png_large_free, and png_realloc functions. +- +-version 0.95 [March, 1997] +- fixed bug in pngwutil.c allocating "up_row" twice and "avg_row" never +- fixed bug in PNG file signature compares when start != 0 +- changed parameter type of png_set_filler(...filler...) from png_byte +- to png_uint_32 +- added test for MACOS to ensure that both math.h and fp.h are not #included +- added macros for libpng to be compiled as a Windows DLL (Andreas Kupries) +- added "packswap" transformation, which changes the endianness of +- packed-pixel bytes (Kevin Bracey) +- added "strip_alpha" transformation, which removes the alpha channel of +- input images without using it (not necessarily a good idea) +- added "swap_alpha" transformation, which puts the alpha channel in front +- of the color bytes instead of after +- removed all implicit variable tests which assume NULL == 0 (I think) +- changed several variables to "png_size_t" to show 16/32-bit limitations +- added new pCAL chunk read/write support +- added experimental filter selection weighting (Greg Roelofs) +- removed old png_set_rgbx() and png_set_xrgb() functions that have been +- obsolete for about 2 years now (use png_set_filler() instead) +- added macros to read 16- and 32-bit ints directly from buffer, to be +- used only on those systems that support it (namely PowerPC and 680x0) +- With some testing, this may become the default for MACOS/PPC systems. +- only calculate CRC on data if we are going to use it +- added macros for zTXt compression type PNG_zTXt_COMPRESSION_??? +- added macros for simple libpng debugging output selectable at compile time +- removed PNG_READ_END_MODE in progressive reader (Smarasderagd) +- more description of info_struct in libpng.txt and png.h +- more instructions in example.c +- more chunk types tested in pngtest.c +- renamed pngrcb.c to pngset.c, and all png_read_ functions to be +- png_set_. We now have corresponding png_get_ +- functions in pngget.c to get information in info_ptr. This isolates +- the application from the internal organization of png_info_struct +- (good for shared library implementations). +- +-version 0.96 [May, 1997] +- 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 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) +- added typecasts to quiet compiler errors +- added more debugging info +- +-version 0.97 [January, 1998] +- removed PNG_USE_OWN_CRC capability +- relocated png_set_crc_action from pngrutil.c to pngrtran.c +- fixed typecasts of "new_key", etc. (Andreas Dilger) +- added RFC 1152 [sic] date support +- fixed bug in gamma handling of 4-bit grayscale +- added 2-bit grayscale gamma handling (Glenn R-P) +- 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; +- 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) +- 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 0.98 [January, 1998] +- cleaned up some typos in libpng.txt and in code documentation +- fixed memory leaks in pCAL chunk processing (Glenn R-P and John Bowler) +- cosmetic change "display_gamma" to "screen_gamma" in pngrtran.c +- changed recommendation about file_gamma for PC images to .51 from .45, +- in example.c and libpng.txt, added comments to distinguish between +- screen_gamma, viewing_gamma, and display_gamma. +- changed all references to RFC1152 to read RFC1123 and changed the +- PNG_TIME_RFC1152_SUPPORTED macro to PNG_TIME_RFC1123_SUPPORTED +- added png_invert_alpha capability (Glenn R-P -- suggestion by Jon Vincent) +- changed srgb_intent from png_byte to int to avoid compiler bugs +- +-version 0.99 [January 30, 1998] +- free info_ptr->text instead of end_info_ptr->text in pngread.c (John Bowler) +- fixed a longstanding "packswap" bug in pngtrans.c +- fixed some inconsistencies in pngconf.h that prevented compiling with +- PNG_READ_GAMMA_SUPPORTED and PNG_READ_hIST_SUPPORTED undefined +- fixed some typos and made other minor rearrangement of libpng.txt (Andreas) +- changed recommendation about file_gamma for PC images to .50 from .51 in +- example.c and libpng.txt, and changed file_gamma for sRGB images to .45 +- added a number of functions to access information from the png structure +- png_get_image_height(), etc. (Glenn R-P, suggestion by Brad Pettit) +- added TARGET_MACOS similar to zlib-1.0.8 +- define PNG_ALWAYS_EXTERN when __MWERKS__ && WIN32 are defined +- added type casting to all png_malloc() function calls +-version 0.99a [January 31, 1998] ++ Changed DOS small/medium model memory support - needs zlib 1.04 (Tim Wegner) ++ Added external C++ wrapper statements to png.h (Gilles Dauphin) ++ Allow PNG file to be read when some or all of file signature has already ++ been read from the beginning of the stream. ****This affects the size ++ of info_struct and invalidates all programs that use a shared libpng**** ++ Fixed png_filler() declarations ++ Fixed? background color conversions ++ Fixed order of error function pointers to match documentation ++ Current chunk name is now available in png_struct to reduce the number ++ of nearly identical error messages (will simplify multi-lingual ++ support when available) ++ Try to get ready for unknown-chunk callback functions: ++ - previously read critical chunks are flagged, so the chunk handling ++ routines can determine if the chunk is in the right place ++ - all chunk handling routines have the same prototypes, so we will ++ be able to handle all chunks via a callback mechanism ++ Try to fix Linux "setjmp" buffer size problems ++ Removed png_large_malloc, png_large_free, and png_realloc functions. ++ ++Version 0.95 [March, 1997] ++ Fixed bug in pngwutil.c allocating "up_row" twice and "avg_row" never ++ Fixed bug in PNG file signature compares when start != 0 ++ Changed parameter type of png_set_filler(...filler...) from png_byte ++ to png_uint_32 ++ Added test for MACOS to ensure that both math.h and fp.h are not #included ++ Added macros for libpng to be compiled as a Windows DLL (Andreas Kupries) ++ Added "packswap" transformation, which changes the endianness of ++ packed-pixel bytes (Kevin Bracey) ++ Added "strip_alpha" transformation, which removes the alpha channel of ++ input images without using it (not necessarily a good idea) ++ Added "swap_alpha" transformation, which puts the alpha channel in front ++ of the color bytes instead of after ++ Removed all implicit variable tests which assume NULL == 0 (I think) ++ Changed several variables to "png_size_t" to show 16/32-bit limitations ++ Added new pCAL chunk read/write support ++ Added experimental filter selection weighting (Greg Roelofs) ++ Removed old png_set_rgbx() and png_set_xrgb() functions that have been ++ obsolete for about 2 years now (use png_set_filler() instead) ++ Added macros to read 16- and 32-bit ints directly from buffer, to be ++ used only on those systems that support it (namely PowerPC and 680x0) ++ With some testing, this may become the default for MACOS/PPC systems. ++ Only calculate CRC on data if we are going to use it ++ Added macros for zTXt compression type PNG_zTXt_COMPRESSION_??? ++ Added macros for simple libpng debugging output selectable at compile time ++ Removed PNG_READ_END_MODE in progressive reader (Smarasderagd) ++ More description of info_struct in libpng.txt and png.h ++ More instructions in example.c ++ More chunk types tested in pngtest.c ++ Renamed pngrcb.c to pngset.c, and all png_read_ functions to be ++ png_set_. We now have corresponding png_get_ ++ functions in pngget.c to get information in info_ptr. This isolates ++ the application from the internal organization of png_info_struct ++ (good for shared library implementations). ++ ++Version 0.96 [May, 1997] ++ 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() 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) ++ Added typecasts to quiet compiler errors ++ Added more debugging info ++ ++Version 0.97 [January, 1998] ++ Removed PNG_USE_OWN_CRC capability ++ Relocated png_set_crc_action from pngrutil.c to pngrtran.c ++ Fixed typecasts of "new_key", etc. (Andreas Dilger) ++ Added RFC 1152 [sic] date support ++ Fixed bug in gamma handling of 4-bit grayscale ++ Added 2-bit grayscale gamma handling (Glenn R-P) ++ 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; ++ 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 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 0.98 [January, 1998] ++ Cleaned up some typos in libpng.txt and in code documentation ++ Fixed memory leaks in pCAL chunk processing (Glenn R-P and John Bowler) ++ Cosmetic change "display_gamma" to "screen_gamma" in pngrtran.c ++ Changed recommendation about file_gamma for PC images to .51 from .45, ++ in example.c and libpng.txt, added comments to distinguish between ++ screen_gamma, viewing_gamma, and display_gamma. ++ Changed all references to RFC1152 to read RFC1123 and changed the ++ PNG_TIME_RFC1152_SUPPORTED macro to PNG_TIME_RFC1123_SUPPORTED ++ Added png_invert_alpha capability (Glenn R-P -- suggestion by Jon Vincent) ++ Changed srgb_intent from png_byte to int to avoid compiler bugs ++ ++Version 0.99 [January 30, 1998] ++ Free info_ptr->text instead of end_info_ptr->text in pngread.c (John Bowler) ++ Fixed a longstanding "packswap" bug in pngtrans.c ++ Fixed some inconsistencies in pngconf.h that prevented compiling with ++ PNG_READ_GAMMA_SUPPORTED and PNG_READ_hIST_SUPPORTED undefined ++ Fixed some typos and made other minor rearrangement of libpng.txt (Andreas) ++ Changed recommendation about file_gamma for PC images to .50 from .51 in ++ example.c and libpng.txt, and changed file_gamma for sRGB images to .45 ++ Added a number of functions to access information from the png structure ++ png_get_image_height(), etc. (Glenn R-P, suggestion by Brad Pettit) ++ Added TARGET_MACOS similar to zlib-1.0.8 ++ Define PNG_ALWAYS_EXTERN when __MWERKS__ && WIN32 are defined ++ Added type casting to all png_malloc() function calls ++ ++Version 0.99a [January 31, 1998] + Added type casts and parentheses to all returns that return a value.(Tim W.) +-version 0.99b [February 4, 1998] ++ ++Version 0.99b [February 4, 1998] + Added type cast png_uint_32 on malloc function calls where needed. + Changed type of num_hist from png_uint_32 to int (same as num_palette). + Added checks for rowbytes overflow, in case png_size_t is less than 32 bits. + Renamed makefile.elf to makefile.lnx. +-version 0.99c [February 7, 1998] ++ ++Version 0.99c [February 7, 1998] + More type casting. Removed erroneous overflow test in pngmem.c. + Added png_buffered_memcpy() and png_buffered_memset(), apply them to rowbytes. + Added UNIX manual pages libpng.3 (incorporating libpng.txt) and png.5. +-version 0.99d [February 11, 1998] ++ ++Version 0.99d [February 11, 1998] + Renamed "far_to_near()" "png_far_to_near()" + Revised libpng.3 + Version 99c "buffered" operations didn't work as intended. Replaced them +@@ -256,7 +267,8 @@ version 0.99d [February 11, 1998] + Check for overlength tRNS chunk present when indexed-color PLTE is read. + Cleaned up spelling errors in libpng.3/libpng.txt + Corrected a problem with png_get_tRNS() which returned undefined trans array +-version 0.99e [February 28, 1998] ++ ++Version 0.99e [February 28, 1998] + Corrected png_get_tRNS() again. + Add parentheses for easier reading of pngget.c, fixed "||" should be "&&". + Touched up example.c to make more of it compileable, although the entire +@@ -266,53 +278,59 @@ version 0.99e [February 28, 1998] + Replaced pngtest.png with one created with zlib 1.1.1 + Changed pngtest to report PASS even when file size is different (Jean-loup G.) + Corrected some logic errors in png_do_invert_alpha() (Chris Patterson) +-version 0.99f [March 5, 1998] ++ ++Version 0.99f [March 5, 1998] + Corrected a bug in pngpread() introduced in version 99c (Kevin Bracey) + Moved makefiles into a "scripts" directory, and added INSTALL instruction file + Added makefile.os2 and pngos2.def (A. Zabolotny) and makefile.s2x (W. Sebok) + Added pointers to "note on libpng versions" in makefile.lnx and README + Added row callback feature when reading and writing nonprogressive rows +- and added a test of this feature in pngtest.c ++ and added a test of this feature in pngtest.c + Added user transform callbacks, with test of the feature in pngtest.c +-version 0.99g [March 6, 1998, morning] ++ ++Version 0.99g [March 6, 1998, morning] + Minor changes to pngtest.c to suppress compiler warnings. + Removed "beta" language from documentation. +-version 0.99h [March 6, 1998, evening] ++ ++Version 0.99h [March 6, 1998, evening] + Minor changes to previous minor changes to pngtest.c + Changed PNG_READ_NOT_FULLY_SUPPORTED to PNG_READ_TRANSFORMS_NOT_SUPPORTED +- and added PNG_PROGRESSIVE_READ_NOT_SUPPORTED macro ++ and added PNG_PROGRESSIVE_READ_NOT_SUPPORTED macro + Added user transform capability + +-version 1.00 [March 7, 1998] ++Version 1.00 [March 7, 1998] + Changed several typedefs in pngrutil.c + Added makefile.wat (Pawel Mrochen), updated makefile.tc3 (Willem van Schaik) +- replaced "while(1)" with "for(;;)" +- added PNGARG() to prototypes in pngtest.c and removed some prototypes +- updated some of the makefiles (Tom Lane) +- changed some typedefs (s_start, etc.) in pngrutil.c +- fixed dimensions of "short_months" array in pngwrite.c ++ Replaced "while(1)" with "for(;;)" ++ Added PNGARG() to prototypes in pngtest.c and removed some prototypes ++ Updated some of the makefiles (Tom Lane) ++ Changed some typedefs (s_start, etc.) in pngrutil.c ++ Fixed dimensions of "short_months" array in pngwrite.c + Replaced ansi2knr.c with the one from jpeg-v6 + +-version 1.0.0 [March 8, 1998] ++Version 1.0.0 [March 8, 1998] + Changed name from 1.00 to 1.0.0 (Adam Costello) + Added smakefile.ppc (with SCOPTIONS.ppc) for Amiga PPC (Andreas Kleinert) +-version 1.0.0a [March 9, 1998] ++ ++Version 1.0.0a [March 9, 1998] + Fixed three bugs in pngrtran.c to make gamma+background handling consistent +- (Greg Roelofs) ++ (Greg Roelofs) + Changed format of the PNG_LIBPNG_VER integer to xyyzz instead of xyz +- for major, minor, and bugfix releases. This is 10001. (Adam Costello, +- Tom Lane) ++ for major, minor, and bugfix releases. This is 10001. (Adam Costello, ++ Tom Lane) + Make months range from 1-12 in png_convert_to_rfc1123 +-version 1.0.0b [March 13, 1998] ++ ++Version 1.0.0b [March 13, 1998] + Quieted compiler complaints about two empty "for" loops in pngrutil.c + Minor changes to makefile.s2x + Removed #ifdef/#endif around a png_free() in pngread.c + +-version 1.0.1 [March 14, 1998] ++Version 1.0.1 [March 14, 1998] + Changed makefile.s2x to reduce security risk of using a relative pathname + Fixed some typos in the documentation (Greg). + Fixed a problem with value of "channels" returned by png_read_update_info() +-version 1.0.1a [April 21, 1998] ++ ++Version 1.0.1a [April 21, 1998] + Optimized Paeth calculations by replacing abs() function calls with intrinsics + plus other loop optimizations. Improves avg decoding speed by about 20%. + Commented out i386istic "align" compiler flags in makefile.lnx. +@@ -326,19 +344,24 @@ version 1.0.1a [April 21, 1998] + Moved a misplaced pngrutil code block that truncates tRNS if it has more + than num_palette entries -- test was done before num_palette was defined. + Fixed a png_convert_to_rfc1123() bug that converts day 31 to 0 (Steve Eddins). +- Changed compiler flags in makefile.wat for better optimization (Pawel Mrochen). +-version 1.0.1b [May 2, 1998] ++ Changed compiler flags in makefile.wat for better optimization ++ (Pawel Mrochen). ++ ++Version 1.0.1b [May 2, 1998] + Relocated png_do_gray_to_rgb() within png_do_read_transformations() (Greg). + Relocated the png_composite macros from pngrtran.c to png.h (Greg). + Added makefile.sco (contributed by Mike Hopkirk). + Fixed two bugs (missing definitions of "istop") introduced in libpng-1.0.1a. + Fixed a bug in pngrtran.c that would set channels=5 under some circumstances. +- More work on the Paeth-filtering, achieving imperceptible speedup (A Kleinert). +- More work on loop optimization which may help when compiled with C++ compilers. ++ More work on the Paeth-filtering, achieving imperceptible speedup ++ (A Kleinert). ++ More work on loop optimization which may help when compiled with C++ ++ compilers. + Added warnings when people try to use transforms they've defined out. + Collapsed 4 "i" and "c" loops into single "i" loops in pngrtran and pngwtran. + Revised paragraph about png_set_expand() in libpng.txt and libpng.3 (Greg) +-version 1.0.1c [May 11, 1998] ++ ++Version 1.0.1c [May 11, 1998] + Fixed a bug in pngrtran.c (introduced in libpng-1.0.1a) where the masks for + filler bytes should have been 0xff instead of 0xf. + Added max_pixel_depth=32 in pngrutil.c when using FILLER with palette images. +@@ -350,7 +373,8 @@ version 1.0.1c [May 11, 1998] + to remove unwanted capabilities via the compile line + Made some corrections to grammar (which, it's) in documentation (Greg). + Corrected example.c, use of row_pointers in png_write_image(). +-version 1.0.1d [May 24, 1998] ++ ++Version 1.0.1d [May 24, 1998] + Corrected several statements that used side effects illegally in pngrutil.c + and pngtrans.c, that were introduced in version 1.0.1b + Revised png_read_rows() to avoid repeated if-testing for NULL (A Kleinert) +@@ -360,7 +384,8 @@ version 1.0.1d [May 24, 1998] + Bob Dellaca, to make a png32bd.dll with Borland C++ 4.5 + Fixed error in example.c with png_set_text: num_text is 3, not 2 (Guido V.) + Changed several loops from count-down to count-up, for consistency. +-version 1.0.1e [June 6, 1998] ++ ++Version 1.0.1e [June 6, 1998] + Revised libpng.txt and libpng.3 description of png_set_read|write_fn(), and + added warnings when people try to set png_read_fn and png_write_fn in + the same structure. +@@ -377,9 +402,10 @@ version 1.0.1e [June 6, 1998] + PNGTEST_DEBUG_MEM feature. + Added makefile.w32, for Microsoft C++ 4.0 and later (Tim Wegner). + +-version 1.0.2 [June 14, 1998] ++Version 1.0.2 [June 14, 1998] + Fixed two bugs in makefile.bor . +-version 1.0.2a [December 30, 1998] ++ ++Version 1.0.2a [December 30, 1998] + Replaced and extended code that was removed from png_set_filler() in 1.0.1a. + Fixed a bug in png_do_filler() that made it fail to write filler bytes in + the left-most pixel of each row (Kevin Bracey). +@@ -401,23 +427,26 @@ version 1.0.2a [December 30, 1998] + Added png_get_copyright() and png_get_header_version() functions. + Revised comments on png_set_progressive_read_fn() in libpng.txt and example.c + Added information about debugging in libpng.txt and libpng.3 . +- Changed "ln -sf" to "ln -s -f" in makefile.s2x, makefile.lnx, and makefile.sco. ++ Changed "ln -sf" to "ln -s -f" in makefile.s2x, makefile.lnx, and ++ makefile.sco. + Removed lines after Dynamic Dependencies" in makefile.aco . + Revised makefile.dec to make a shared library (Jeremie Petit). + Removed trailing blanks from all files. +-version 1.0.2a [January 6, 1999] ++ ++Version 1.0.2a [January 6, 1999] + Removed misplaced #endif and #ifdef PNG_NO_EXTERN near the end of png.h + Added "if" tests to silence complaints about unused png_ptr in png.h and png.c + Changed "check_if_png" function in example.c to return true (nonzero) if PNG. + Changed libpng.txt to demonstrate png_sig_cmp() instead of png_check_sig() + which is obsolete. + +-version 1.0.3 [January 14, 1999] ++Version 1.0.3 [January 14, 1999] + Added makefile.hux, for Hewlett Packard HPUX 10.20 and 11.00 (Jim Rice) + Added a statement of Y2K compliance in png.h, libpng.3, and Y2KINFO. +-version 1.0.3a [August 12, 1999] ++ ++Version 1.0.3a [August 12, 1999] + Added check for PNG_READ_INTERLACE_SUPPORTED in pngread.c; issue a warning +- if an attempt is made to read an interlaced image when it's not supported. ++ if an attempt is made to read an interlaced image when it's not supported. + Added check if png_ptr->trans is defined before freeing it in pngread.c + Modified the Y2K statement to include versions back to version 0.71 + Fixed a bug in the check for valid IHDR bit_depth/color_types in pngrutil.c +@@ -425,7 +454,7 @@ version 1.0.3a [August 12, 1999] + Replaced leading blanks with tab characters in makefile.hux + Changed "dworkin.wustl.edu" to "ccrc.wustl.edu" in various documents. + Changed (float)red and (float)green to (double)red, (double)green +- in png_set_rgb_to_gray() to avoid "promotion" problems in AIX. ++ in png_set_rgb_to_gray() to avoid "promotion" problems in AIX. + Fixed a bug in pngconf.h that omitted when PNG_DEBUG==0 (K Bracey). + Reformatted libpng.3 and libpngpf.3 with proper fonts (script by J. vanZandt). + Updated documentation to refer to the PNG-1.2 specification. +@@ -442,13 +471,15 @@ version 1.0.3a [August 12, 1999] + Correct gamma with srgb is 45455 instead of 45000 in pngrutil.c, to be + consistent with PNG-1.2, and allow variance of 500 before complaining. + Added assembler code contributed by Intel in file pngvcrd.c and modified +- makefile.w32 to use it (Nirav Chhatrapati, INTEL Corporation, Gilles Vollant) ++ makefile.w32 to use it (Nirav Chhatrapati, INTEL Corporation, ++ Gilles Vollant) + Changed "ln -s -f" to "ln -f -s" in the makefiles to make Solaris happy. + Added some aliases for png_set_expand() in pngrtran.c, namely + png_set_expand_PLTE(), png_set_expand_depth(), and png_set_expand_tRNS() + (Greg Roelofs, in "PNG: The Definitive Guide"). + Added makefile.beo for BEOS on X86, contributed by Sander Stok. +-version 1.0.3b [August 26, 1999] ++ ++Version 1.0.3b [August 26, 1999] + Replaced 2147483647L several places with PNG_MAX_UINT macro, defined in png.h + Changed leading blanks to tabs in all makefiles. + Define PNG_USE_PNGVCRD in makefile.w32, to get MMX assembler code. +@@ -460,12 +491,13 @@ version 1.0.3b [August 26, 1999] + negative shift distance, whose results are undefined in the C language. + Added a check in pngset.c to prevent writing multiple tIME chunks. + Added a check in pngwrite.c to detect invalid small window_bits sizes. +-version 1.0.3d [September 4, 1999] ++ ++Version 1.0.3d [September 4, 1999] + Fixed type casting of igamma in pngrutil.c + Added new png_expand functions to scripts/pngdef.pas and pngos2.def + Added a demo read_user_transform_fn that examines the row filters in pngtest.c + +-version 1.0.4 [September 24, 1999] ++Version 1.0.4 [September 24, 1999, not distributed publicly] + Define PNG_ALWAYS_EXTERN in pngconf.h if __STDC__ is defined + Delete #define PNG_INTERNAL and include "png.h" from pngasmrd.h + Made several minor corrections to pngtest.c +@@ -479,24 +511,31 @@ version 1.0.4 [September 24, 1999] + assembler code) and makefile.vcwin32 (doesn't). + Added a CPU timing report to pngtest.c (enabled by defining PNGTEST_TIMING) + Added a copy of pngnow.png to the distribution. +-version 1.0.4a [September 25, 1999] ++ ++Version 1.0.4a [September 25, 1999] + Increase max_pixel_depth in pngrutil.c if a user transform needs it. + Changed several division operations to right-shifts in pngvcrd.c +-version 1.0.4b [September 30, 1999] ++ ++Version 1.0.4b [September 30, 1999] + Added parentheses in line 3732 of pngvcrd.c + Added a comment in makefile.linux warning about buggy -O3 in pgcc 2.95.1 +-version 1.0.4c [October 1, 1999] ++ ++Version 1.0.4c [October 1, 1999] + Added a "png_check_version" function in png.c and pngtest.c that will generate + a helpful compiler error if an old png.h is found in the search path. + Changed type of png_user_transform_depth|channels from int to png_byte. +-version 1.0.4d [October 6, 1999] ++ Added "Libpng is OSI Certified Open Source Software" statement to png.h ++ ++Version 1.0.4d [October 6, 1999] + Changed 0.45 to 0.45455 in png_set_sRGB() + Removed unused PLTE entries from pngnow.png + Re-enabled some parts of pngvcrd.c (png_combine_row) that work properly. +-version 1.0.4e [October 10, 1999] ++ ++Version 1.0.4e [October 10, 1999] + Fixed sign error in pngvcrd.c (Greg Roelofs) + Replaced some instances of memcpy with simple assignments in pngvcrd (GR-P) +-version 1.0.4f [October 15, 1999] ++ ++Version 1.0.4f [October 15, 1999] + Surrounded example.c code with #if 0 .. #endif to prevent people from + inadvertently trying to compile it. + Changed png_get_header_version() from a function to a macro in png.h +@@ -504,9 +543,10 @@ version 1.0.4f [October 15, 1999] + Removed some pointless "ptr = NULL" in pngmem.c + Added a "contrib" directory containing the source code from Greg's book. + +-version 1.0.5 [October 15, 1999] ++Version 1.0.5 [October 15, 1999] + Minor editing of the INSTALL and README files. +-version 1.0.5a [October 23, 1999] ++ ++Version 1.0.5a [October 23, 1999] + Added contrib/pngsuite and contrib/pngminus (Willem van Schaik) + Fixed a typo in the png_set_sRGB() function call in example.c (Jan Nijtmans) + Further optimization and bugfix of pngvcrd.c +@@ -514,14 +554,16 @@ version 1.0.5a [October 23, 1999] + text_ptr structure. Instead, it makes its own copy. + Created separate write_end_info_struct in pngtest.c for a more severe test. + Added code in pngwrite.c to free info_ptr->text[i].key to stop a memory leak. +-version 1.0.5b [November 23, 1999] ++ ++Version 1.0.5b [November 23, 1999] + Moved PNG_FLAG_HAVE_CHUNK_HEADER, PNG_FLAG_BACKGROUND_IS_GRAY and + PNG_FLAG_WROTE_tIME from flags to mode. + Added png_write_info_before_PLTE() function. + Fixed some typecasting in contrib/gregbook/*.c + Updated scripts/makevms.com and added makevms.com to contrib/gregbook + and contrib/pngminus (Martin Zinser) +-version 1.0.5c [November 26, 1999] ++ ++Version 1.0.5c [November 26, 1999] + Moved png_get_header_version from png.h to png.c, to accommodate ansi2knr. + Removed all global arrays (according to PNG_NO_GLOBAL_ARRAYS macro), to + accommodate making DLL's: Moved usr_png_ver from global variable to function +@@ -534,21 +576,23 @@ version 1.0.5c [November 26, 1999] + Removed some extraneous "-I" from contrib/pngminus/makefile.std + Changed the PNG_sRGB_INTENT macros in png.h to be consistent with PNG-1.2. + Change PNG_SRGB_INTENT to PNG_sRGB_INTENT in libpng.txt and libpng.3 +-version 1.0.5d [November 29, 1999] ++ ++Version 1.0.5d [November 29, 1999] + Add type cast (png_const_charp) two places in png.c + Eliminated pngtypes.h; use macros instead to declare PNG_CHNK arrays. + Renamed "PNG_GLOBAL_ARRAYS" to "PNG_USE_GLOBAL_ARRAYS" and made available + to applications a macro "PNG_USE_LOCAL_ARRAYS". +- Remove all the new declarations with #ifdef/#endif when ++ comment out (with #ifdef) all the new declarations when + PNG_USE_GLOBAL_ARRAYS is defined. + Added PNG_EXPORT_VAR macro to accommodate making DLL's. +-version 1.0.5e [November 30, 1999] ++ ++Version 1.0.5e [November 30, 1999] + Added iCCP, iTXt, and sPLT support; added "lang" member to the png_text + structure; refactored the inflate/deflate support to make adding new chunks + with trailing compressed parts easier in the future, and added new functions + png_free_iCCP, png_free_pCAL, png_free_sPLT, png_free_text, png_get_iCCP, + png_get_spalettes, png_set_iCCP, png_set_spalettes (Eric S. Raymond). +- NOTE: Applications that write text chunks MUST define png_text->lang ++ NOTE: Applications that write text chunks MUST define png_text->lang + before calling png_set_text(). It must be set to NULL if you want to + write tEXt or zTXt chunks. If you want your application to be able to + run with older versions of libpng, use +@@ -563,18 +607,21 @@ version 1.0.5e [November 30, 1999] + PNG_cHNK_SUPPORTED and combined the three types of PNG_text_SUPPORTED + macros, leaving the separate macros also available. + Removed comments on #endifs at the end of many short, non-nested #if-blocks. +-version 1.0.5f [December 6, 1999] ++ ++Version 1.0.5f [December 6, 1999] + Changed makefile.solaris to issue a warning about potential problems when + the ucb "ld" is in the path ahead of the ccs "ld". + Removed "- [date]" from the "synopsis" line in libpng.3 and libpngpf.3. + Added sCAL chunk support (Eric S. Raymond). +-version 1.0.5g [December 7, 1999] ++ ++Version 1.0.5g [December 7, 1999] + Fixed "png_free_spallettes" typo in png.h + Added code to handle new chunks in pngpread.c + Moved PNG_CHNK string macro definitions outside of PNG_NO_EXTERN block + Added "translated_key" to png_text structure and png_write_iTXt(). + Added code in pngwrite.c to work around a newly discovered zlib bug. +-version 1.0.5h [December 10, 1999] ++ ++Version 1.0.5h [December 10, 1999] + NOTE: regarding the note for version 1.0.5e, the following must also + be included in your code: + png_text[i].translated_key = NULL; +@@ -582,7 +629,8 @@ version 1.0.5h [December 10, 1999] + Option to eliminate all floating point support was added. Some new + fixed-point functions such as png_set_gAMA_fixed() were added. + Expanded tabs and removed trailing blanks in source files. +-version 1.0.5i [December 13, 1999] ++ ++Version 1.0.5i [December 13, 1999] + Added some type casts to silence compiler warnings. + Renamed "png_free_spalette" to "png_free_spalettes" for consistency. + Removed leading blanks from a #define in pngvcrd.c +@@ -594,7 +642,8 @@ version 1.0.5i [December 13, 1999] + Added png_free_hIST() function. + Various patches to fix bugs in the sCAL and integer cHRM processing, + and to add some convenience macros for use with sCAL. +-version 1.0.5j [December 21, 1999] ++ ++Version 1.0.5j [December 21, 1999] + Changed "unit" parameter of png_write_sCAL from png_byte to int, to work + around buggy compilers. + Added new type "png_fixed_point" for integers that hold float*100000 values +@@ -610,7 +659,8 @@ version 1.0.5j [December 21, 1999] + and to write the iTXt chunk after IDAT if it appears in the end_ptr. + Added pnggccrd.c, version of pngvcrd.c Intel assembler for gcc (Greg Roelofs) + Reversed the order of trying to write floating-point and fixed-point gAMA. +-version 1.0.5k [December 27, 1999] ++ ++Version 1.0.5k [December 27, 1999] + Added many parentheses, e.g., "if (a && b & c)" becomes "if (a && (b & c))" + Added png_handle_as_unknown() function (Glenn) + Added png_free_chunk_list() function and chunk_list and num_chunk_list members +@@ -621,33 +671,41 @@ version 1.0.5k [December 27, 1999] + Added png_free_tRNS(); png_set_tRNS() now malloc's its own trans array (ESR). + Define png_get_int_32 when oFFs chunk is supported as well as when pCAL is. + Changed type of proflen from png_int_32 to png_uint_32 in png_get_iCCP(). +-version 1.0.5l [January 1, 2000] ++ ++Version 1.0.5l [January 1, 2000] + Added functions png_set_read_user_chunk_fn() and png_get_user_chunk_ptr() + for setting a callback function to handle unknown chunks and for + retrieving the associated user pointer (Glenn). +-version 1.0.5m [January 7, 2000] ++ ++Version 1.0.5m [January 7, 2000] + Added high-level functions png_read_png(), png_write_png(), png_free_pixels(). +-version 1.0.5n [January 9, 2000] ++ ++Version 1.0.5n [January 9, 2000] + Added png_free_PLTE() function, and modified png_set_PLTE() to malloc its + own memory for info_ptr->palette. This makes it safe for the calling + application to free its copy of the palette any time after it calls + png_set_PLTE(). +-version 1.0.5o [January 20, 2000] ++ ++Version 1.0.5o [January 20, 2000] + Cosmetic changes only (removed some trailing blanks and TABs) +-version 1.0.5p [January 31, 2000] ++ ++Version 1.0.5p [January 31, 2000] + Renamed pngdll.mak to makefile.bd32 + Cosmetic changes in pngtest.c +-version 1.0.5q [February 5, 2000] ++ ++Version 1.0.5q [February 5, 2000] + Relocated the makefile.solaris warning about PATH problems. + Fixed pngvcrd.c bug by pushing/popping registers in mmxsupport (Bruce Oberg) + Revised makefile.gcmmx + Added PNG_SETJMP_SUPPORTED, PNG_SETJMP_NOT_SUPPORTED, and PNG_ABORT() macros +-version 1.0.5r [February 7, 2000] ++ ++Version 1.0.5r [February 7, 2000] + Removed superfluous prototype for png_get_itxt from png.h + Fixed a bug in pngrtran.c that improperly expanded the background color. + Return *num_text=0 from png_get_text() when appropriate, and fix documentation + of png_get_text() in libpng.txt/libpng.3. +-version 1.0.5s [February 18, 2000] ++ ++Version 1.0.5s [February 18, 2000] + Added "png_jmp_env()" macro to pngconf.h, to help people migrate to the + new error handler that's planned for the next libpng release, and changed + example.c, pngtest.c, and contrib programs to use this macro. +@@ -666,7 +724,8 @@ version 1.0.5s [February 18, 2000] + Added png_set_rows() and png_get_rows(), for use with png_read|write_png(). + Modified png_read_png() to allocate info_ptr->row_pointers only if it + hasn't already been allocated. +-version 1.0.5t [March 4, 2000] ++ ++Version 1.0.5t [March 4, 2000] + Changed png_jmp_env() migration aiding macro to png_jmpbuf(). + Fixed "interlace" typo (should be "interlaced") in contrib/gregbook/read2-x.c + Fixed bug with use of PNG_BEFORE_IHDR bit in png_ptr->mode, introduced when +@@ -675,13 +734,15 @@ version 1.0.5t [March 4, 2000] + a 24-bit visual if one is available, and to allow abbreviated options. + Files in contrib/pngminus were revised to use the png_jmpbuf() macro. + Removed spaces in makefile.linux and makefile.gcmmx, introduced in 1.0.5s +-version 1.0.5u [March 5, 2000] ++ ++Version 1.0.5u [March 5, 2000] + Simplified the code that detects old png.h in png.c and pngtest.c + Renamed png_spalette (_p, _pp) to png_sPLT_t (_tp, _tpp) + Increased precision of rgb_to_gray calculations from 8 to 15 bits and + added png_set_rgb_to_gray_fixed() function. + Added makefile.bc32 (32-bit Borland C++, C mode) +-version 1.0.5v [March 11, 2000] ++ ++Version 1.0.5v [March 11, 2000] + Added some parentheses to the png_jmpbuf macro definition. + Updated references to the zlib home page, which has moved to freesoftware.com. + Corrected bugs in documentation regarding png_read_row() and png_write_row(). +@@ -689,10 +750,11 @@ version 1.0.5v [March 11, 2000] + Renamed makefile.borland,turboc3 back to makefile.bor,tc3 as in version 1.0.3, + revised borland makefiles; added makefile.ibmvac3 and makefile.gcc (Cosmin) + +-version 1.0.6 [March 20, 2000] ++Version 1.0.6 [March 20, 2000] + Minor revisions of makefile.bor, libpng.txt, and gregbook/rpng2-win.c + Added makefile.sggcc (SGI IRIX with gcc) +-version 1.0.6d [April 7, 2000] ++ ++Version 1.0.6d [April 7, 2000] + Changed sprintf() to strcpy() in png_write_sCAL_s() to work without STDIO + Added data_length parameter to png_decompress_chunk() function + Revised documentation to remove reference to abandoned png_free_chnk functions +@@ -701,7 +763,8 @@ version 1.0.6d [April 7, 2000] + Renamed makefile.ibmvac3 to makefile.ibmc, added libpng.icc IBM project file + Added a check for info_ptr->free_me&PNG_FREE_TEXT when freeing text in png.c + Simplify png_sig_bytes() function to remove use of non-ISO-C strdup(). +-version 1.0.6e [April 9, 2000] ++ ++Version 1.0.6e [April 9, 2000] + Added png_data_freer() function. + In the code that checks for over-length tRNS chunks, added check of + info_ptr->num_trans as well as png_ptr->num_trans (Matthias Benckmann) +@@ -712,25 +775,29 @@ version 1.0.6e [April 9, 2000] + is defined. + Changed several instances of PNG_NO_CONSOLE_ID to PNG_NO_STDIO in pngrutil.c + and mentioned the purposes of the two macros in libpng.txt/libpng.3. +-version 1.0.6f [April 14, 2000] ++ ++Version 1.0.6f [April 14, 2000] + Revised png_set_iCCP() and png_set_rows() to avoid prematurely freeing data. + Add checks in png_set_text() for NULL members of the input text structure. + Revised libpng.txt/libpng.3. +- Removed superfluous prototype for png_set_itxt from png.h ++ Removed superfluous prototype for png_set_iTXt from png.h + Removed "else" from pngread.c, after png_error(), and changed "0" to "length". + Changed several png_errors about malformed ancillary chunks to png_warnings. +-version 1.0.6g [April 24, 2000] ++ ++Version 1.0.6g [April 24, 2000] + Added png_pass-* arrays to pnggccrd.c when PNG_USE_LOCAL_ARRAYS is defined. + Relocated paragraph about png_set_background() in libpng.3/libpng.txt + and other revisions (Matthias Benckmann) + Relocated info_ptr->free_me, png_ptr->free_me, and other info_ptr and + png_ptr members to restore binary compatibility with libpng-1.0.5 + (breaks compatibility with libpng-1.0.6). +-version 1.0.6h [April 24, 2000] ++ ++Version 1.0.6h [April 24, 2000] + Changed shared library so-number pattern from 2.x.y.z to xy.z (this builds + libpng.so.10 & libpng.so.10.6h instead of libpng.so.2 & libpng.so.2.1.0.6h) + This is a temporary change for test purposes. +-version 1.0.6i [May 2, 2000] ++ ++Version 1.0.6i [May 2, 2000] + Rearranged some members at the end of png_info and png_struct, to put + unknown_chunks_num and free_me within the original size of the png_structs + and free_me, png_read_user_fn, and png_free_fn within the original png_info, +@@ -755,22 +822,25 @@ version 1.0.6i [May 2, 2000] + generate a libpng error if the modes aren't set and PNG_LEGACY_SUPPORTED + was not defined. + Added makefile.intel and updated makefile.watcom (Pawel Mrochen) +-version 1.0.6j [May 3, 2000] ++ ++Version 1.0.6j [May 3, 2000] + Overloaded png_read_init() and png_write_init() with macros that convert + calls to png_read_init_2() or png_write_init_2() that check the version + and structure sizes. +-version 1.0.7beta11 [May 7, 2000] ++ ++Version 1.0.7beta11 [May 7, 2000] + Removed the new PNG_CREATED_READ_STRUCT and PNG_CREATED_WRITE_STRUCT modes + which are no longer used. + Eliminated the three new members of png_text when PNG_LEGACY_SUPPORTED is +- defined or when neither PNG_READ_iTXt_SUPPORTED nor PNG_WRITE_iTXT_SUPPORTED ++ defined or when neither PNG_READ_iTXt_SUPPORTED nor PNG_WRITE_iTXt_SUPPORTED + is defined. + Made PNG_NO_READ|WRITE_iTXt the default setting, to avoid memory + overrun when old applications fill the info_ptr->text structure directly. + Added PNGAPI macro, and added it to the definitions of all exported functions. + Relocated version macro definitions ahead of the includes of zlib.h and + pngconf.h in png.h. +-version 1.0.7beta12 [May 12, 2000] ++ ++Version 1.0.7beta12 [May 12, 2000] + Revised pngset.c to avoid a problem with expanding the png_debug macro. + Deleted some extraneous defines from pngconf.h + Made PNG_NO_CONSOLE_IO the default condition when PNG_BUILD_DLL is defined. +@@ -778,7 +848,8 @@ version 1.0.7beta12 [May 12, 2000] + Added png_access_version_number() function. + Check for mask&PNG_FREE_CHNK (for TEXT, SCAL, PCAL) in png_free_data(). + Expanded libpng.3/libpng.txt information about png_data_freer(). +-version 1.0.7beta14 [May 17, 2000] (beta13 was not published) ++ ++Version 1.0.7beta14 [May 17, 2000] (beta13 was not published) + Changed pnggccrd.c and pngvcrd.c to handle bad adaptive filter types as + warnings instead of errors, as pngrutil.c does. + Set the PNG_INFO_IDAT valid flag in png_set_rows() so png_write_png() +@@ -790,7 +861,8 @@ version 1.0.7beta14 [May 17, 2000] (beta13 was not published) + Removed info_ptr->valid tests from png_free_data(), as in version 1.0.5. + Added png_set_invalid() function. + Fixed incorrect illustrations of png_destroy_write_struct() in example.c. +-version 1.0.7beta15 [May 30, 2000] ++ ++Version 1.0.7beta15 [May 30, 2000] + Revised the deliberately erroneous Linux setjmp code in pngconf.h to produce + fewer error messages. + Rearranged checks for Z_OK to check the most likely path first in pngpread.c +@@ -802,9 +874,11 @@ version 1.0.7beta15 [May 30, 2000] + Fixed some bugs in the unused PNG_INCH_CONVERSIONS functions in pngget.c + Set each pointer to NULL after freeing it in png_free_data(). + Worked around a problem in pngconf.h; AIX's strings.h defines an "index" +- macro that conflicts with libpng's png_color_16.index. (Dimitri Papadapoulos) ++ macro that conflicts with libpng's png_color_16.index. (Dimitri ++ Papadapoulos) + Added "msvc" directory with MSVC++ project files (Simon-Pierre Cadieux). +-version 1.0.7beta16 [June 4, 2000] ++ ++Version 1.0.7beta16 [June 4, 2000] + Revised the workaround of AIX string.h "index" bug. + Added a check for overlength PLTE chunk in pngrutil.c. + Added PNG_NO_POINTER_INDEXING macro to use array-indexing instead of pointer +@@ -814,49 +888,58 @@ version 1.0.7beta16 [June 4, 2000] + Added PNG_USE_DLL macro. + Revised the copyright/disclaimer/license notice. + Added contrib/msvctest directory +-version 1.0.7rc1 [June 9, 2000] ++ ++Version 1.0.7rc1 [June 9, 2000] + Corrected the definition of PNG_TRANSFORM_INVERT_ALPHA (0x0400 not 0x0200) + Added contrib/visupng directory (Willem van Schaik) +-version 1.0.7beta18 [June 23, 2000] ++ ++Version 1.0.7beta18 [June 23, 2000] + Revised PNGAPI definition, and pngvcrd.c to work with __GCC__ + and do not redefine PNGAPI if it is passed in via a compiler directive. + Revised visupng/PngFile.c to remove returns from within the Try block. + Removed leading underscores from "_PNG_H" and "_PNG_SAVE_BSD_SOURCE" macros. + Updated contrib/visupng/cexcept.h to version 1.0.0. + Fixed bugs in pngwrite.c and pngwutil.c that prevented writing iCCP chunks. +-version 1.0.7rc2 [June 28, 2000] ++ ++Version 1.0.7rc2 [June 28, 2000] + Updated license to include disclaimers required by UCITA. + Fixed "DJBPP" typo in pnggccrd.c introduced in beta18. + +-version 1.0.7 [July 1, 2000] ++Version 1.0.7 [July 1, 2000] + Revised the definition of "trans_values" in libpng.3/libpng.txt +-version 1.0.8beta1 [July 8, 2000] ++ ++Version 1.0.8beta1 [July 8, 2000] + Added png_free(png_ptr, key) two places in pngpread.c to stop memory leaks. + Changed PNG_NO_STDIO to PNG_NO_CONSOLE_IO, several places in pngrutil.c and +- pngwutil.c. ++ pngwutil.c. + Changed PNG_EXPORT_VAR to use PNG_IMPEXP, in pngconf.h. + Removed unused "#include " from png.c + Added WindowsCE support. + Revised pnggccrd.c to work with gcc-2.95.2 and in the Cygwin environment. +-version 1.0.8beta2 [July 10, 2000] ++ ++Version 1.0.8beta2 [July 10, 2000] + Added project files to the wince directory and made further revisions +- of pngtest.c, pngrio.c, and pngwio.c in support of WindowsCE. +-version 1.0.8beta3 [July 11, 2000] ++ of pngtest.c, pngrio.c, and pngwio.c in support of WindowsCE. ++ ++Version 1.0.8beta3 [July 11, 2000] + Only set the PNG_FLAG_FREE_TRNS or PNG_FREE_TRNS flag in png_handle_tRNS() +- for indexed-color input files to avoid potential double-freeing trans array +- under some unusual conditions; problem was introduced in version 1.0.6f. ++ for indexed-color input files to avoid potential double-freeing trans array ++ under some unusual conditions; problem was introduced in version 1.0.6f. + Further revisions to pngtest.c and files in the wince subdirectory. +-version 1.0.8beta4 [July 14, 2000] ++ ++Version 1.0.8beta4 [July 14, 2000] + Added the files pngbar.png and pngbar.jpg to the distribution. + Added makefile.cygwin, and cygwin support in pngconf.h + Added PNG_NO_ZALLOC_ZERO macro (makes png_zalloc skip zeroing memory) +-version 1.0.8rc1 [July 16, 2000] ++ ++Version 1.0.8rc1 [July 16, 2000] + Revised png_debug() macros and statements to eliminate compiler warnings. + +-version 1.0.8 [July 24, 2000] ++Version 1.0.8 [July 24, 2000] + Added png_flush() in pngwrite.c, after png_write_IEND(). + Updated makefile.hpux to build a shared library. +-version 1.0.9beta1 [November 10, 2000] ++ ++Version 1.0.9beta1 [November 10, 2000] + Fixed typo in scripts/makefile.hpux + Updated makevms.com in scripts and contrib/* and contrib/* (Martin Zinser) + Fixed seqence-point bug in contrib/pngminus/png2pnm (Martin Zinser) +@@ -875,59 +958,72 @@ version 1.0.9beta1 [November 10, 2000] + Revised makefile.cygwin + Fixed bugs in iCCP support in pngrutil.c and pngwutil.c. + Replaced png_set_empty_plte_permitted() with png_permit_mng_features(). +-version 1.0.9beta2 [November 19, 2000] ++ ++Version 1.0.9beta2 [November 19, 2000] + Renamed the "dll" subdirectory "projects". + Added borland project files to "projects" subdirectory. + Set VS_FF_PRERELEASE and VS_FF_PATCHED flags in msvc/png.rc when appropriate. + Add error message in png_set_compression_buffer_size() when malloc fails. +-version 1.0.9beta3 [November 23, 2000] ++ ++Version 1.0.9beta3 [November 23, 2000] + Revised PNG_LIBPNG_BUILD_TYPE macro in png.h, used in the msvc project. + Removed the png_flush() in pngwrite.c that crashes some applications + that don't set png_output_flush_fn. + Added makefile.macosx and makefile.aix to scripts directory. +-version 1.0.9beta4 [December 1, 2000] ++ ++Version 1.0.9beta4 [December 1, 2000] + Change png_chunk_warning to png_warning in png_check_keyword(). + Increased the first part of msg buffer from 16 to 18 in png_chunk_error(). +-version 1.0.9beta5 [December 15, 2000] ++ ++Version 1.0.9beta5 [December 15, 2000] + Added support for filter method 64 (for PNG datastreams embedded in MNG). +-version 1.0.9beta6 [December 18, 2000] ++ ++Version 1.0.9beta6 [December 18, 2000] + Revised png_set_filter() to accept filter method 64 when appropriate. + Added new PNG_HAVE_PNG_SIGNATURE bit to png_ptr->mode and use it to + help prevent applications from using MNG features in PNG datastreams. + Added png_permit_mng_features() function. + Revised libpng.3/libpng.txt. Changed "filter type" to "filter method". +-version 1.0.9rc1 [December 23, 2000] ++ ++Version 1.0.9rc1 [December 23, 2000] + Revised test for PNG_HAVE_PNG_SIGNATURE in pngrutil.c + Fixed error handling of unknown compression type in png_decompress_chunk(). + In pngconf.h, define __cdecl when _MSC_VER is defined. +-version 1.0.9beta7 [December 28, 2000] ++ ++Version 1.0.9beta7 [December 28, 2000] + Changed PNG_TEXT_COMPRESSION_zTXt to PNG_COMPRESSION_TYPE_BASE several places. + Revised memory management in png_set_hIST and png_handle_hIST in a backward + compatible manner. PLTE and tRNS were revised similarly. + Revised the iCCP chunk reader to ignore trailing garbage. +-version 1.0.9beta8 [January 12, 2001] ++ ++Version 1.0.9beta8 [January 12, 2001] + Moved pngasmrd.h into pngconf.h. + Improved handling of out-of-spec garbage iCCP chunks generated by PhotoShop. +-version 1.0.9beta9 [January 15, 2001] ++ ++Version 1.0.9beta9 [January 15, 2001] + Added png_set_invalid, png_permit_mng_features, and png_mmx_supported to + wince and msvc project module definition files. + Minor revision of makefile.cygwin. + Fixed bug with progressive reading of narrow interlaced images in pngpread.c +-version 1.0.9beta10 [January 16, 2001] ++ ++Version 1.0.9beta10 [January 16, 2001] + Do not typedef png_FILE_p in pngconf.h when PNG_NO_STDIO is defined. + Fixed "png_mmx_supported" typo in project definition files. +-version 1.0.9beta11 [January 19, 2001] ++ ++Version 1.0.9beta11 [January 19, 2001] + Updated makefile.sgi to make shared library. + Removed png_mmx_support() function and disabled PNG_MNG_FEATURES_SUPPORTED + by default, for the benefit of DLL forward compatibility. These will + be re-enabled in version 1.2.0. +-version 1.0.9rc2 [January 22, 2001] ++ ++Version 1.0.9rc2 [January 22, 2001] + Revised cygwin support. + +-version 1.0.9 [January 31, 2001] ++Version 1.0.9 [January 31, 2001] + Added check of cygwin's ALL_STATIC in pngconf.h + Added "-nommx" parameter to contrib/gregbook/rpng2-win and rpng2-x demos. +-version 1.0.10beta1 [March 14, 2001] ++ ++Version 1.0.10beta1 [March 14, 2001] + Revised makefile.dec, makefile.sgi, and makefile.sggcc; added makefile.hpgcc. + Reformatted libpng.3 to eliminate bad line breaks. + Added checks for _mmx_supported in the read_filter_row function of pnggccrd.c +@@ -940,33 +1036,39 @@ version 1.0.10beta1 [March 14, 2001] + Fixed bugs in png_combine_row() in pnggccrd.c and pngvcrd.c (C version) + Added warnings when retrieving or setting gamma=0. + Increased the first part of msg buffer from 16 to 18 in png_chunk_warning(). +-version 1.0.10rc1 [March 23, 2001] ++ ++Version 1.0.10rc1 [March 23, 2001] + Changed all instances of memcpy, strcpy, and strlen to png_memcpy, png_strcpy, + and png_strlen. + Revised png_mmx_supported() function in pnggccrd.c to return proper value. + Fixed bug in progressive reading (pngpread.c) with small images (height < 8). + +-version 1.0.10 [March 30, 2001] ++Version 1.0.10 [March 30, 2001] + Deleted extraneous space (introduced in 1.0.9) from line 42 of makefile.cygwin + Added beos project files (Chris Herborth) +-version 1.0.11beta1 [April 3, 2001] ++ ++Version 1.0.11beta1 [April 3, 2001] + Added type casts on several png_malloc() calls (Dimitri Papadapoulos). + Removed a no-longer needed AIX work-around from pngconf.h + Changed several "//" single-line comments to C-style in pnggccrd.c +-version 1.0.11beta2 [April 11, 2001] ++ ++Version 1.0.11beta2 [April 11, 2001] + Removed PNGAPI from several functions whose prototypes did not have PNGAPI. + Updated scripts/pngos2.def +-version 1.0.11beta3 [April 14, 2001] ++ ++Version 1.0.11beta3 [April 14, 2001] + Added checking the results of many instances of png_malloc() for NULL +-version 1.0.11beta4 [April 20, 2001] ++ ++Version 1.0.11beta4 [April 20, 2001] + Undid the changes from version 1.0.11beta3. Added a check for NULL return + from user's malloc_fn(). + Removed some useless type casts of the NULL pointer. + Added makefile.netbsd + +-version 1.0.11 [April 27, 2001] ++Version 1.0.11 [April 27, 2001] + Revised makefile.netbsd +-version 1.0.12beta1 [May 14, 2001] ++ ++Version 1.0.12beta1 [May 14, 2001] + Test for Windows platform in pngconf.h when including malloc.h (Emmanuel Blot) + Updated makefile.cygwin and handling of Cygwin's ALL_STATIC in pngconf.h + Added some never-to-be-executed code in pnggccrd.c to quiet compiler warnings. +@@ -974,66 +1076,76 @@ version 1.0.12beta1 [May 14, 2001] + libpng will reallocate the png_struct and info_struct if they are too small. + This retains future binary compatibility for old applications written for + libpng-0.88 and earlier. +-version 1.2.0beta1 [May 6, 2001] ++ ++Version 1.2.0beta1 [May 6, 2001] + Bumped DLLNUM to 2. + Re-enabled PNG_MNG_FEATURES_SUPPORTED and enabled PNG_ASSEMBLER_CODE_SUPPORTED + by default. + Added runtime selection of MMX features. + Added png_set_strip_error_numbers function and related macros. +-version 1.2.0beta2 [May 7, 2001] ++ ++Version 1.2.0beta2 [May 7, 2001] + Finished merging 1.2.0beta1 with version 1.0.11 + Added a check for attempts to read or write PLTE in grayscale PNG datastreams. +-version 1.2.0beta3 [May 17, 2001] ++ ++Version 1.2.0beta3 [May 17, 2001] + Enabled user memory function by default. + Modified png_create_struct so it passes user mem_ptr to user memory allocator. + Increased png_mng_features flag from png_byte to png_uint_32. + Bumped shared-library (so-number) and dll-number to 3. +-version 1.2.0beta4 [June 23, 2001] ++ ++Version 1.2.0beta4 [June 23, 2001] + Check for missing profile length field in iCCP chunk and free chunk_data +- in case of truncated iCCP chunk. ++ in case of truncated iCCP chunk. + Bumped shared-library number to 3 in makefile.sgi and makefile.sggcc + Bumped dll-number from 2 to 3 in makefile.cygwin + Revised contrib/gregbook/rpng*-x.c to avoid a memory leak and to exit cleanly +- if user attempts to run it on an 8-bit display. ++ if user attempts to run it on an 8-bit display. + Updated contrib/gregbook + Use png_malloc instead of png_zalloc to allocate palette in pngset.c + Updated makefile.ibmc + Added some typecasts to eliminate gcc 3.0 warnings. Changed prototypes +- of png_write_oFFS width and height from png_uint_32 to png_int_32. ++ of png_write_oFFS width and height from png_uint_32 to png_int_32. + Updated example.c + Revised prototypes for png_debug_malloc and png_debug_free in pngtest.c +-version 1.2.0beta5 [August 8, 2001] ++ ++Version 1.2.0beta5 [August 8, 2001] + Revised contrib/gregbook + Revised makefile.gcmmx + Revised pnggccrd.c to conditionally compile some thread-unsafe code only +- when PNG_THREAD_UNSAFE_OK is defined. ++ when PNG_THREAD_UNSAFE_OK is defined. + Added tests to prevent pngwutil.c from writing a bKGD or tRNS chunk with +- value exceeding 2^bit_depth-1 ++ value exceeding 2^bit_depth-1 + Revised makefile.sgi and makefile.sggcc + Replaced calls to fprintf(stderr,...) with png_warning() in pnggccrd.c + Removed restriction that do_invert_mono only operate on 1-bit opaque files + +-version 1.2.0 [September 1, 2001] ++Version 1.2.0 [September 1, 2001] + Changed a png_warning() to png_debug() in pnggccrd.c + Fixed contrib/gregbook/rpng-x.c, rpng2-x.c to avoid crash with XFreeGC(). +-version 1.2.1beta1 [October 19, 2001] ++ ++Version 1.2.1beta1 [October 19, 2001] + Revised makefile.std in contrib/pngminus + Include background_1 in png_struct regardless of gamma support. + Revised makefile.netbsd and makefile.macosx, added makefile.darwin. + Revised example.c to provide more details about using row_callback(). +-version 1.2.1beta2 [October 25, 2001] ++ ++Version 1.2.1beta2 [October 25, 2001] + Added type cast to each NULL appearing in a function call, except for + WINCE functions. + Added makefile.so9. +-version 1.2.1beta3 [October 27, 2001] ++ ++Version 1.2.1beta3 [October 27, 2001] + Removed type casts from all NULLs. + Simplified png_create_struct_2(). +-version 1.2.1beta4 [November 7, 2001] ++ ++Version 1.2.1beta4 [November 7, 2001] + Revised png_create_info_struct() and png_creat_struct_2(). + Added error message if png_write_info() was omitted. + Type cast NULLs appearing in function calls when _NO_PROTO or + PNG_TYPECAST_NULL is defined. +-version 1.2.1rc1 [November 24, 2001] ++ ++Version 1.2.1rc1 [November 24, 2001] + Type cast NULLs appearing in function calls except when PNG_NO_TYPECAST_NULL + is defined. + Changed typecast of "size" argument to png_size_t in pngmem.c calls to +@@ -1042,14 +1154,16 @@ version 1.2.1rc1 [November 24, 2001] + Updated makefile.sgi to recognize LIBPATH and INCPATH. + Updated various makefiles so "make clean" does not remove previous major + version of the shared library. +-version 1.2.1rc2 [December 4, 2001] ++ ++Version 1.2.1rc2 [December 4, 2001] + Always allocate 256-entry internal palette, hist, and trans arrays, to + avoid out-of-bounds memory reference caused by invalid PNG datastreams. + Added a check for prefix_length > data_length in iCCP chunk handler. + +-version 1.2.1 [December 7, 2001] ++Version 1.2.1 [December 7, 2001] + None. +-version 1.2.2beta1 [February 22, 2002] ++ ++Version 1.2.2beta1 [February 22, 2002] + Fixed a bug with reading the length of iCCP profiles (Larry Reeves). + Revised makefile.linux, makefile.gcmmx, and makefile.sgi to generate + libpng.a, libpng12.so (not libpng.so.3), and libpng12/png.h +@@ -1059,13 +1173,15 @@ version 1.2.2beta1 [February 22, 2002] + Revised calls to png_create_read_struct() and png_create_write_struct() + for simpler debugging. + Revised png_zalloc() so zlib handles errors (uses PNG_FLAG_MALLOC_NULL_MEM_OK) +-version 1.2.2beta2 [February 23, 2002] ++ ++Version 1.2.2beta2 [February 23, 2002] + Check chunk_length and idat_size for invalid (over PNG_MAX_UINT) lengths. + Check for invalid image dimensions in png_get_IHDR. + Added missing "fi;" in the install target of the SGI makefiles. + Added install-static to all makefiles that make shared libraries. + Always do gamma compensation when image is partially transparent. +-version 1.2.2beta3 [March 7, 2002] ++ ++Version 1.2.2beta3 [March 7, 2002] + Compute background.gray and background_1.gray even when color_type is RGB + in case image gets reduced to gray later. + Modified shared-library makefiles to install pkgconfig/libpngNN.pc. +@@ -1075,12 +1191,14 @@ version 1.2.2beta3 [March 7, 2002] + Added install-shared target to all makefiles that make shared libraries. + Stopped a double free of palette, hist, and trans when not using free_me. + Added makefile.32sunu for Sun Ultra 32 and makefile.64sunu for Sun Ultra 64. +-version 1.2.2beta4 [March 8, 2002] ++ ++Version 1.2.2beta4 [March 8, 2002] + Compute background.gray and background_1.gray even when color_type is RGB + in case image gets reduced to gray later (Jason Summers). + Relocated a misplaced /bin/rm in the "install-shared" makefile targets + Added PNG_1_0_X macro which can be used to build a 1.0.x-compatible library. +-version 1.2.2beta5 [March 26, 2002] ++ ++Version 1.2.2beta5 [March 26, 2002] + Added missing PNGAPI to several function definitions. + Check for invalid bit_depth or color_type in png_get_IHDR(), and + check for missing PLTE or IHDR in png_push_read_chunk() (Matthias Clasen). +@@ -1089,33 +1207,45 @@ version 1.2.2beta5 [March 26, 2002] + Changed "()" to "{}" in scripts/libpng.pc.in. + Revised makefiles to put png.h and pngconf.h only in $prefix/include/libpngNN + Revised makefiles to make symlink to libpng.so.NN in addition to libpngNN.so +-version 1.2.2beta6 [March 31, 2002] +-version 1.0.13beta1 [March 31, 2002] ++ ++Version 1.2.2beta6 [March 31, 2002] ++ ++Version 1.0.13beta1 [March 31, 2002] + Prevent png_zalloc() from trying to memset memory that it failed to acquire. + Add typecasts of PNG_MAX_UINT in pngset_cHRM_fixed() (Matt Holgate). + Ensure that the right function (user or default) is used to free the + png_struct after an error in png_create_read_struct_2(). +-version 1.2.2rc1 [April 7, 2002] +-version 1.0.13rc1 [April 7, 2002] ++ ++Version 1.2.2rc1 [April 7, 2002] ++ ++Version 1.0.13rc1 [April 7, 2002] + Save the ebx register in pnggccrd.c (Sami Farin) + Add "mem_ptr = png_ptr->mem_ptr" in png_destroy_write_struct() (Paul Gardner). + Updated makefiles to put headers in include/libpng and remove old include/*.h. + +-version 1.2.2 [April 15, 2002] +-version 1.0.13 [April 15, 2002] ++Version 1.2.2 [April 15, 2002] ++ ++Version 1.0.13 [April 15, 2002] + Revised description of png_set_filter() in libpng.3/libpng.txt. + Revised makefile.netbsd and added makefile.neNNbsd and makefile.freebsd +-version 1.0.13patch01 [April 17, 2002] +-version 1.2.2patch01 [April 17, 2002] +- Changed ${PNGMAJ}.${PNGVER} bug to ${PNGVER} in makefile.sgi and makefile.sggcc +- Fixed VER -> PNGVER typo in makefile.macosx and added install-static to install ++ ++Version 1.0.13patch01 [April 17, 2002] ++ ++Version 1.2.2patch01 [April 17, 2002] ++ Changed ${PNGMAJ}.${PNGVER} bug to ${PNGVER} in makefile.sgi and ++ makefile.sggcc ++ Fixed VER -> PNGVER typo in makefile.macosx and added install-static to ++ install + Added install: target to makefile.32sunu and makefile.64sunu +-version 1.0.13patch03 [April 18, 2002] +-version 1.2.2patch03 [April 18, 2002] ++ ++Version 1.0.13patch03 [April 18, 2002] ++ ++Version 1.2.2patch03 [April 18, 2002] + Revised 15 makefiles to link libpng.a to libpngNN.a and the include libpng + subdirectory to libpngNN subdirectory without the full pathname. + Moved generation of libpng.pc from "install" to "all" in 15 makefiles. +-version 1.2.3rc1 [April 28, 2002] ++ ++Version 1.2.3rc1 [April 28, 2002] + Added install-man target to 15 makefiles (Dimitri Papadopolous-Orfanos). + Added $(DESTDIR) feature to 24 makefiles (Tim Mooney) + Fixed bug with $prefix, should be $(prefix) in makefile.hpux. +@@ -1127,70 +1257,83 @@ version 1.2.3rc1 [April 28, 2002] + to put one in their application. + Restored png_zalloc() and png_zfree() prototypes to version 1.2.1 and + removed them from module definition files. +-version 1.2.3rc2 [May 1, 2002] ++ ++Version 1.2.3rc2 [May 1, 2002] + Fixed bug in reporting number of channels in pngget.c and pngset.c, + that was introduced in version 1.2.2beta5. + Exported png_zalloc(), png_zfree(), png_default_read(), png_default_write(), + png_default_flush(), and png_push_fill_buffer() and included them in + module definition files. + Added "libpng.pc" dependency to the "install-shared" target in 15 makefiles. +-version 1.2.3rc3 [May 1, 2002] ++ ++Version 1.2.3rc3 [May 1, 2002] + Revised prototype for png_default_flush() + Remove old libpng.pc and libpngNN.pc before installing new ones. +-version 1.2.3rc4 [May 2, 2002] ++ ++Version 1.2.3rc4 [May 2, 2002] + Typos in *.def files (png_default_read|write -> png_default_read|write_data) + In makefiles, changed rm libpng.NN.pc to rm libpngNN.pc +- Added libpng-config and libpngNN-config and modified makefiles to install them. ++ Added libpng-config and libpngNN-config and modified makefiles to install ++ them. + Changed $(MANPATH) to $(DESTDIR)$(MANPATH) in makefiles + Added "Win32 DLL VB" configuration to projects/msvc/libpng.dsp +-version 1.2.3rc5 [May 11, 2002] ++ ++Version 1.2.3rc5 [May 11, 2002] + Changed "error" and "message" in prototypes to "error_message" and + "warning_message" to avoid namespace conflict. + Revised 15 makefiles to build libpng-config from libpng-config-*.in + Once more restored png_zalloc and png_zfree to regular nonexported form. + Restored png_default_read|write_data, png_default_flush, png_read_fill_buffer +- to nonexported form, but with PNGAPI, and removed them from module def files. +-version 1.2.3rc6 [May 14, 2002] ++ to nonexported form, but with PNGAPI, and removed them from module def ++ files. ++ ++Version 1.2.3rc6 [May 14, 2002] + Removed "PNGAPI" from png_zalloc() and png_zfree() in png.c + Changed "Gz" to "Gd" in projects/msvc/libpng.dsp and zlib.dsp. + Removed leftover libpng-config "sed" script from four makefiles. + Revised libpng-config creating script in 16 makefiles. + +-version 1.2.3 [May 22, 2002] ++Version 1.2.3 [May 22, 2002] + Revised libpng-config target in makefile.cygwin. + Removed description of png_set_mem_fn() from documentation. + Revised makefile.freebsd. + Minor cosmetic changes to 15 makefiles, e.g., $(DI) = $(DESTDIR)/$(INCDIR). + Revised projects/msvc/README.txt + Changed -lpng to -lpngNN in LDFLAGS in several makefiles. +-version 1.2.4beta1 [May 24, 2002] ++ ++Version 1.2.4beta1 [May 24, 2002] + Added libpng.pc and libpng-config to "all:" target in 16 makefiles. + Fixed bug in 16 makefiles: $(DESTDIR)/$(LIBPATH) to $(DESTDIR)$(LIBPATH) + Added missing "\" before closing double quote in makefile.gcmmx. + Plugged various memory leaks; added png_malloc_warn() and png_set_text_2() + functions. +-version 1.2.4beta2 [June 25, 2002] ++ ++Version 1.2.4beta2 [June 25, 2002] + Plugged memory leak of png_ptr->current_text (Matt Holgate). + Check for buffer overflow before reading CRC in pngpread.c (Warwick Allison) + Added -soname to the loader flags in makefile.dec, makefile.sgi, and + makefile.sggcc. + Added "test-installed" target to makefile.linux, makefile.gcmmx, + makefile.sgi, and makefile.sggcc. +-version 1.2.4beta3 [June 28, 2002] ++ ++Version 1.2.4beta3 [June 28, 2002] + Plugged memory leak of row_buf in pngtest.c when there is a png_error(). + Detect buffer overflow in pngpread.c when IDAT is corrupted with extra data. + Added "test-installed" target to makefile.32sunu, makefile.64sunu, + makefile.beos, makefile.darwin, makefile.dec, makefile.macosx, + makefile.solaris, makefile.hpux, makefile.hpgcc, and makefile.so9. +-version 1.2.4rc1 and 1.0.14rc1 [July 2, 2002] ++ ++Version 1.2.4rc1 and 1.0.14rc1 [July 2, 2002] + Added "test-installed" target to makefile.cygwin and makefile.sco. + Revised pnggccrd.c to be able to back out version 1.0.x via PNG_1_0_X macro. + +-version 1.2.4 and 1.0.14 [July 8, 2002] ++Version 1.2.4 and 1.0.14 [July 8, 2002] + Changed png_warning() to png_error() when width is too large to process. +-version 1.2.4patch01 [July 20, 2002] ++ ++Version 1.2.4patch01 [July 20, 2002] + Revised makefile.cygwin to use DLL number 12 instead of 13. +-version 1.2.5beta1 [August 6, 2002] ++ ++Version 1.2.5beta1 [August 6, 2002] + Added code to contrib/gregbook/readpng2.c to ignore unused chunks. + Replaced toucan.png in contrib/gregbook (it has been corrupt since 1.0.11) + Removed some stray *.o files from contrib/gregbook. +@@ -1199,36 +1342,43 @@ version 1.2.5beta1 [August 6, 2002] + Prevent png_ptr->pass from exceeding 7 in png_push_finish_row(). + Updated makefile.hpgcc + Updated png.c and pnggccrd.c handling of return from png_mmx_support() +-version 1.2.5beta2 [August 15, 2002] ++ ++Version 1.2.5beta2 [August 15, 2002] + Only issue png_warning() about "Too much data" in pngpread.c when avail_in + is nonzero. + Updated makefiles to install a separate libpng.so.3 with its own rpath. +-version 1.2.5rc1 and 1.0.15rc1 [August 24, 2002] ++ ++Version 1.2.5rc1 and 1.0.15rc1 [August 24, 2002] + Revised makefiles to not remove previous minor versions of shared libraries. +-version 1.2.5rc2 and 1.0.15rc2 [September 16, 2002] ++ ++Version 1.2.5rc2 and 1.0.15rc2 [September 16, 2002] + Revised 13 makefiles to remove "-lz" and "-L$(ZLIBLIB)", etc., from shared + library loader directive. + Added missing "$OBJSDLL" line to makefile.gcmmx. + Added missing "; fi" to makefile.32sunu. +-version 1.2.5rc3 and 1.0.15rc3 [September 18, 2002] ++ ++Version 1.2.5rc3 and 1.0.15rc3 [September 18, 2002] + Revised libpng-config script. + +-version 1.2.5 and 1.0.15 [October 3, 2002] ++Version 1.2.5 and 1.0.15 [October 3, 2002] + Revised makefile.macosx, makefile.darwin, makefile.hpgcc, and makefile.hpux, + and makefile.aix. + Relocated two misplaced PNGAPI lines in pngtest.c +-version 1.2.6beta1 [October 22, 2002] ++ ++Version 1.2.6beta1 [October 22, 2002] + Commented out warning about uninitialized mmx_support in pnggccrd.c. + Changed "IBMCPP__" flag to "__IBMCPP__" in pngconf.h. + Relocated two more misplaced PNGAPI lines in pngtest.c + Fixed memory overrun bug in png_do_read_filler() with 16-bit datastreams, + introduced in version 1.0.2. + Revised makefile.macosx, makefile.dec, makefile.aix, and makefile.32sunu. +-version 1.2.6beta2 [November 1, 2002] ++ ++Version 1.2.6beta2 [November 1, 2002] + Added libpng-config "--ldopts" output. + Added "AR=ar" and "ARFLAGS=rc" and changed "ar rc" to "$(AR) $(ARFLAGS)" + in makefiles. +-version 1.2.6beta3 [July 18, 2004] ++ ++Version 1.2.6beta3 [July 18, 2004] + Reverted makefile changes from version 1.2.6beta2 and some of the changes + from version 1.2.6beta1; these will be postponed until version 1.2.7. + Version 1.2.6 is going to be a simple bugfix release. +@@ -1281,7 +1431,8 @@ version 1.2.6beta3 [July 18, 2004] + Updated contrib/visupng/VisualPng.dsp (Cosmin). + Updated contrib/visupng/cexcept.h to version 2.0.0 (Cosmin). + Added a separate distribution with "configure" and supporting files (Junichi). +-version 1.2.6beta4 [July 28, 2004] ++ ++Version 1.2.6beta4 [July 28, 2004] + Added user ability to change png_size_t via a PNG_SIZE_T macro. + Added png_sizeof() and png_convert_size() functions. + Added PNG_SIZE_MAX (maximum value of a png_size_t variable. +@@ -1301,11 +1452,13 @@ version 1.2.6beta4 [July 28, 2004] + Added PNG_NO_SEQUENTIAL_READ_SUPPORTED macro to conditionally remove + sequential read support. + Added some "#if PNG_WRITE_SUPPORTED" blocks. +- Removed some redundancy with #ifdef/#endif in png_malloc_default(). +- Use png_malloc instead of png_zalloc to allocate the pallete. +-version 1.0.16rc1 and 1.2.6rc1 [August 4, 2004] +- Fixed buffer overflow vulnerability in png_handle_tRNS() +- Fixed integer arithmetic overflow vulnerability in png_read_png(). ++ Added #ifdef to remove some redundancy in png_malloc_default(). ++ Use png_malloc instead of png_zalloc to allocate the palette. ++ ++Version 1.0.16rc1 and 1.2.6rc1 [August 4, 2004] ++ Fixed buffer overflow vulnerability (CVE-2004-0597) in png_handle_tRNS(). ++ Fixed NULL dereference vulnerability (CVE-2004-0598) in png_handle_iCCP(). ++ Fixed integer overflow vulnerability (CVE-2004-0599) in png_read_png(). + Fixed some harmless bugs in png_handle_sBIT, etc, that would cause + duplicate chunk types to go undetected. + Fixed some timestamps in the -config version +@@ -1318,7 +1471,8 @@ version 1.0.16rc1 and 1.2.6rc1 [August 4, 2004] + Fixed wrong cast of returns from png_get_user_width|height_max(). + Changed some "keep the compiler happy" from empty statements to returns, + Revised libpng.txt to remove 1.2.x stuff from the 1.0.x distribution +-version 1.0.16rc2 and 1.2.6rc2 [August 7, 2004] ++ ++Version 1.0.16rc2 and 1.2.6rc2 [August 7, 2004] + Revised makefile.darwin and makefile.solaris. Removed makefile.macosx. + Revised pngtest's png_debug_malloc() to use png_malloc() instead of + png_malloc_default() which is not supposed to be exported. +@@ -1332,91 +1486,106 @@ version 1.0.16rc2 and 1.2.6rc2 [August 7, 2004] + Changed "HANDLE_CHUNK_*" to "PNG_HANDLE_CHUNK_*" (Cosmin) + Added "-@/bin/rm -f $(DL)/$(LIBNAME).so.$(PNGMAJ)" to 15 *NIX makefiles. + Added code to update the row_info->colortype in png_do_read_filler() (MSB). +-version 1.0.16rc3 and 1.2.6rc3 [August 9, 2004] ++ ++Version 1.0.16rc3 and 1.2.6rc3 [August 9, 2004] + Eliminated use of "abs()" in testing cHRM and gAMA values, to avoid + trouble with some 64-bit compilers. Created PNG_OUT_OF_RANGE() macro. + Revised documentation of png_set_keep_unknown_chunks(). + Check handle_as_unknown status in pngpread.c, as in pngread.c previously. + Moved "PNG_HANDLE_CHUNK_*" macros out of PNG_INTERNAL section of png.h + Added "rim" definitions for CONST4 and CONST6 in pnggccrd.c +-version 1.0.16rc4 and 1.2.6rc4 [August 10, 2004] ++ ++Version 1.0.16rc4 and 1.2.6rc4 [August 10, 2004] + Fixed mistake in pngtest.c introduced in 1.2.6rc2 (declaration of + "pinfo" was out of place). +-version 1.0.16rc5 and 1.2.6rc5 [August 10, 2004] ++ ++Version 1.0.16rc5 and 1.2.6rc5 [August 10, 2004] + Moved "PNG_HANDLE_CHUNK_*" macros out of PNG_ASSEMBLER_CODE_SUPPORTED +- section of png.h where they were inadvertently placed in version rc3. ++ section of png.h where they were inadvertently placed in version rc3. + +-version 1.2.6 and 1.0.16 [August 15, 2004] ++Version 1.2.6 and 1.0.16 [August 15, 2004] + Revised pngtest so memory allocation testing is only done when PNG_DEBUG==1. +-version 1.2.7beta1 [August 26, 2004] ++ ++Version 1.2.7beta1 [August 26, 2004] + Removed unused pngasmrd.h file. + Removed references to uu.net for archived files. Added references to + PNG Spec (second edition) and the PNG ISO/IEC Standard. + Added "test-dd" target in 15 makefiles, to run pngtest in DESTDIR. + Fixed bug with "optimized window size" in the IDAT datastream, that + causes libpng to write PNG files with incorrect zlib header bytes. +-version 1.2.7beta2 [August 28, 2004] ++ ++Version 1.2.7beta2 [August 28, 2004] + Fixed bug with sCAL chunk and big-endian machines (David Munro). + Undid new code added in 1.2.6rc2 to update the color_type in + png_set_filler(). + Added png_set_add_alpha() that updates color type. +-version 1.0.17rc1 and 1.2.7rc1 [September 4, 2004] ++ ++Version 1.0.17rc1 and 1.2.7rc1 [September 4, 2004] + Revised png_set_strip_filler() to not remove alpha if color_type has alpha. + +-version 1.2.7 and 1.0.17 [September 12, 2004] ++Version 1.2.7 and 1.0.17 [September 12, 2004] + Added makefile.hp64 + Changed projects/msvc/png32ms.def to scripts/png32ms.def in makefile.cygwin +-version 1.2.8beta1 [November 1, 2004] ++ ++Version 1.2.8beta1 [November 1, 2004] + Fixed bug in png_text_compress() that would fail to complete a large block. + Fixed bug, introduced in libpng-1.2.7, that overruns a buffer during + strip alpha operation in png_do_strip_filler(). + Added PNG_1_2_X definition in pngconf.h +- Comment out with #ifdef/#endif png_info_init in png.c and png_read_init +- in pngread.c (as of 1.3.0) +-version 1.2.8beta2 [November 2, 2004] ++ Use #ifdef to comment out png_info_init in png.c and png_read_init in ++ pngread.c (as of 1.3.0) ++ ++Version 1.2.8beta2 [November 2, 2004] + Reduce color_type to a nonalpha type after strip alpha operation in + png_do_strip_filler(). +-version 1.2.8beta3 [November 3, 2004] ++ ++Version 1.2.8beta3 [November 3, 2004] + Revised definitions of PNG_MAX_UINT_32, PNG_MAX_SIZE, and PNG_MAXSUM +-version 1.2.8beta4 [November 12, 2004] ++ ++Version 1.2.8beta4 [November 12, 2004] + Fixed (again) definition of PNG_LIBPNG_VER_DLLNUM in png.h (Cosmin). + Added PNG_LIBPNG_BUILD_PRIVATE in png.h (Cosmin). + Set png_ptr->zstream.data_type to Z_BINARY, to avoid unnecessary detection + of data type in deflate (Cosmin). + Deprecated but continue to support SPECIALBUILD and PRIVATEBUILD in favor of + PNG_LIBPNG_BUILD_SPECIAL_STRING and PNG_LIBPNG_BUILD_PRIVATE_STRING. +-version 1.2.8beta5 [November 20, 2004] ++ ++Version 1.2.8beta5 [November 20, 2004] + Use png_ptr->flags instead of png_ptr->transformations to pass + PNG_STRIP_ALPHA info to png_do_strip_filler(), to preserve ABI + compatibility. + Revised handling of SPECIALBUILD, PRIVATEBUILD, + PNG_LIBPNG_BUILD_SPECIAL_STRING and PNG_LIBPNG_BUILD_PRIVATE_STRING. +-version 1.2.8rc1 [November 24, 2004] ++ ++Version 1.2.8rc1 [November 24, 2004] + Moved handling of BUILD macros from pngconf.h to png.h + Added definition of PNG_LIBPNG_BASE_TYPE in png.h, inadvertently + omitted from beta5. + Revised scripts/pngw32.rc + Despammed mailing addresses by masking "@" with "at". + Inadvertently installed a supposedly faster test version of pngrutil.c +-version 1.2.8rc2 [November 26, 2004] ++ ++Version 1.2.8rc2 [November 26, 2004] + Added two missing "\" in png.h + Change tests in pngread.c and pngpread.c to + if (png_ptr->transformations || (png_ptr->flags&PNG_FLAG_STRIP_ALPHA)) + png_do_read_transformations(png_ptr); +-version 1.2.8rc3 [November 28, 2004] ++ ++Version 1.2.8rc3 [November 28, 2004] + Reverted pngrutil.c to version libpng-1.2.8beta5. + Added scripts/makefile.elf with supporting code in pngconf.h for symbol + versioning (John Bowler). +-version 1.2.8rc4 [November 29, 2004] ++ ++Version 1.2.8rc4 [November 29, 2004] + Added projects/visualc7 (Simon-pierre). +-version 1.2.8rc5 [November 29, 2004] ++ ++Version 1.2.8rc5 [November 29, 2004] + Fixed new typo in scripts/pngw32.rc + +-version 1.2.8 [December 3, 2004] ++Version 1.2.8 [December 3, 2004] + Removed projects/visualc7, added projects/visualc71. + +-version 1.2.9beta1 [February 21, 2006] +- ++Version 1.2.9beta1 [February 21, 2006] + Initialized some structure members in pngwutil.c to avoid gcc-4.0.0 complaints + Revised man page and libpng.txt to make it clear that one should not call + png_read_end or png_write_end after png_read_png or png_write_png. +@@ -1438,8 +1607,7 @@ version 1.2.9beta1 [February 21, 2006] + Fixed scripts/makefile.cygwin (Christian Biesinger, Cosmin). + Default iTXt support was inadvertently enabled. + +-version 1.2.9beta2 [February 21, 2006] +- ++Version 1.2.9beta2 [February 21, 2006] + Check for png_rgb_to_gray and png_gray_to_rgb read transformations before + checking for png_read_dither in pngrtran.c + Revised checking of chromaticity limits to accommodate extended RGB +@@ -1452,8 +1620,7 @@ version 1.2.9beta2 [February 21, 2006] + Eliminated distributions without the "configure" script. + Updated INSTALL instructions. + +-version 1.2.9beta3 [February 24, 2006] +- ++Version 1.2.9beta3 [February 24, 2006] + Fixed CRCRLF line endings in contrib/visupng/VisualPng.dsp + Made libpng.pc respect EXEC_PREFIX (D. P. Kreil, J. Bowler) + Removed reference to pngasmrd.h from Makefile.am +@@ -1462,8 +1629,7 @@ version 1.2.9beta3 [February 24, 2006] + Renamed ANNOUNCE to NEWS. + Created AUTHORS file. + +-version 1.2.9beta4 [March 3, 2006] +- ++Version 1.2.9beta4 [March 3, 2006] + Changed definition of PKGCONFIG from $prefix/lib to $libdir in configure.ac + Reverted to filenames LICENSE and ANNOUNCE; removed AUTHORS and COPYING. + Removed newline from the end of some error and warning messages. +@@ -1474,17 +1640,17 @@ version 1.2.9beta4 [March 3, 2006] + Added "OS2" to list of systems that don't need underscores, in pnggccrd.c + Removed libpng version and date from *.c files. + +-version 1.2.9beta5 [March 4, 2006] ++Version 1.2.9beta5 [March 4, 2006] + Removed trailing blanks from source files. + Put version and date of latest change in each source file, and changed + copyright year accordingly. +- More cleanup of configure.ac, Makefile.ac, and associated scripts. ++ More cleanup of configure.ac, Makefile.am, and associated scripts. + Restored scripts/makefile.elf which was inadvertently deleted. + +-version 1.2.9beta6 [March 6, 2006] ++Version 1.2.9beta6 [March 6, 2006] + Fixed typo (RELEASE) in configuration files. + +-version 1.2.9beta7 [March 7, 2006] ++Version 1.2.9beta7 [March 7, 2006] + Removed libpng.vers and libpng.sym from libpng12_la_SOURCES in Makefile.am + Fixed inconsistent #ifdef's around png_sig_bytes() and png_set_sCAL_s() + in png.h. +@@ -1492,7 +1658,7 @@ version 1.2.9beta7 [March 7, 2006] + Made cosmetic changes to some makefiles, adding LN_SF and other macros. + Made some makefiles accept "exec_prefix". + +-version 1.2.9beta8 [March 9, 2006] ++Version 1.2.9beta8 [March 9, 2006] + Fixed some "#if defined (..." which should be "#if defined(..." + Bug introduced in libpng-1.2.8. + Fixed inconsistency in definition of png_default_read_data() +@@ -1503,82 +1669,82 @@ version 1.2.9beta8 [March 9, 2006] + Added png_set_expand_gray_1_2_4_to_8() and deprecated + png_set_gray_1_2_4_to_8() which also expands tRNS to alpha. + +-version 1.2.9beta9 [March 10, 2006] ++Version 1.2.9beta9 [March 10, 2006] + Include "config.h" in pngconf.h when available. + Added some checks for NULL png_ptr or NULL info_ptr (timeless) + +-version 1.2.9beta10 [March 20, 2006] ++Version 1.2.9beta10 [March 20, 2006] + Removed extra CR from contrib/visualpng/VisualPng.dsw (Cosmin) + Made pnggccrd.c PIC-compliant (Christian Aichinger). + Added makefile.mingw (Wolfgang Glas). + Revised pngconf.h MMX checking. + +-version 1.2.9beta11 [March 22, 2006] ++Version 1.2.9beta11 [March 22, 2006] + Fixed out-of-order declaration in pngwrite.c that was introduced in beta9 + Simplified some makefiles by using LIBSO, LIBSOMAJ, and LIBSOVER macros. + +-version 1.2.9rc1 [March 31, 2006] ++Version 1.2.9rc1 [March 31, 2006] + Defined PNG_USER_PRIVATEBUILD when including "pngusr.h" (Cosmin). + Removed nonsensical assertion check from pngtest.c (Cosmin). + +-version 1.2.9 [April 14, 2006] ++Version 1.2.9 [April 14, 2006] + Revised makefile.beos and added "none" selector in ltmain.sh + +-version 1.2.10beta1 [April 15, 2006] ++Version 1.2.10beta1 [April 15, 2006] + Renamed "config.h" to "png_conf.h" and revised Makefile.am to add + -DPNG_BUILDING_LIBPNG to compile directive, and modified pngconf.h + to include png_conf.h only when PNG_BUILDING_LIBPNG is defined. + +-version 1.2.10beta2 [April 15, 2006] ++Version 1.2.10beta2 [April 15, 2006] + Manually updated Makefile.in and configure. Changed png_conf.h.in + back to config.h. + +-version 1.2.10beta3 [April 15, 2006] ++Version 1.2.10beta3 [April 15, 2006] + Change png_conf.h back to config.h in pngconf.h. + +-version 1.2.10beta4 [April 16, 2006] ++Version 1.2.10beta4 [April 16, 2006] + Change PNG_BUILDING_LIBPNG to PNG_CONFIGURE_LIBPNG in config/Makefile*. + +-version 1.2.10beta5 [April 16, 2006] ++Version 1.2.10beta5 [April 16, 2006] + Added a configure check for compiling assembler code in pnggccrd.c + +-version 1.2.10beta6 [April 17, 2006] ++Version 1.2.10beta6 [April 17, 2006] + Revised the configure check for pnggccrd.c + Moved -DPNG_CONFIGURE_LIBPNG into @LIBPNG_DEFINES@ + Added @LIBPNG_DEFINES@ to arguments when building libpng.sym + +-version 1.2.10beta7 [April 18, 2006] ++Version 1.2.10beta7 [April 18, 2006] + Change "exec_prefix=$prefix" to "exec_prefix=$(prefix)" in makefiles. + +-version 1.2.10rc1 [April 19, 2006] ++Version 1.2.10rc1 [April 19, 2006] + Ensure pngconf.h doesn't define both PNG_USE_PNGGCCRD and PNG_USE_PNGVCRD + Fixed "LN_FS" typo in makefile.sco and makefile.solaris. + +-version 1.2.10rc2 [April 20, 2006] ++Version 1.2.10rc2 [April 20, 2006] + Added a backslash between -DPNG_CONFIGURE_LIBPNG and -DPNG_NO_ASSEMBLER_CODE + in configure.ac and configure + Made the configure warning about versioned symbols less arrogant. + +-version 1.2.10rc3 [April 21, 2006] ++Version 1.2.10rc3 [April 21, 2006] + Added a note in libpng.txt that png_set_sig_bytes(8) can be used when + writing an embedded PNG without the 8-byte signature. + Revised makefiles and configure to avoid making links to libpng.so.* + +-version 1.2.10 [April 23, 2006] ++Version 1.2.10 [April 23, 2006] + Reverted configure to "rc2" state. + +-version 1.2.11beta1 [May 31, 2006] ++Version 1.2.11beta1 [May 31, 2006] + scripts/libpng.pc.in contained "configure" style version info and would + not work with makefiles. + The shared-library makefiles were linking to libpng.so.0 instead of + libpng.so.3 compatibility as the library. + +-version 1.2.11beta2 [June 2, 2006] ++Version 1.2.11beta2 [June 2, 2006] + Increased sprintf buffer from 50 to 52 chars in pngrutil.c to avoid + buffer overflow. + Fixed bug in example.c (png_set_palette_rgb -> png_set_palette_to_rgb) + +-version 1.2.11beta3 [June 5, 2006] ++Version 1.2.11beta3 [June 5, 2006] + Prepended "#! /bin/sh" to ltmail.sh and contrib/pngminus/*.sh (Cosmin). + Removed the accidental leftover Makefile.in~ (Cosmin). + Avoided potential buffer overflow and optimized buffer in +@@ -1586,116 +1752,116 @@ version 1.2.11beta3 [June 5, 2006] + Removed the include directories and libraries from CFLAGS and LDFLAGS + in scripts/makefile.gcc (Nelson A. de Oliveira, Cosmin). + +-version 1.2.11beta4 [June 6, 2006] ++Version 1.2.11beta4 [June 6, 2006] + Allow zero-length IDAT chunks after the entire zlib datastream, but not + after another intervening chunk type. + +-version 1.0.19rc1, 1.2.11rc1 [June 13, 2006] ++Version 1.0.19rc1, 1.2.11rc1 [June 13, 2006] + Deleted extraneous square brackets from [config.h] in configure.ac + +-version 1.0.19rc2, 1.2.11rc2 [June 14, 2006] ++Version 1.0.19rc2, 1.2.11rc2 [June 14, 2006] + Added prototypes for PNG_INCH_CONVERSIONS functions to png.h + Revised INSTALL and autogen.sh + Fixed typo in several makefiles (-W1 should be -Wl) + Added typedef for png_int_32 and png_uint_32 on 64-bit systems. + +-version 1.0.19rc3, 1.2.11rc3 [June 15, 2006] ++Version 1.0.19rc3, 1.2.11rc3 [June 15, 2006] + Removed the new typedefs for 64-bit systems (delay until version 1.4.0) + Added one zero element to png_gamma_shift[] array in pngrtran.c to avoid + reading out of bounds. + +-version 1.0.19rc4, 1.2.11rc4 [June 15, 2006] ++Version 1.0.19rc4, 1.2.11rc4 [June 15, 2006] + Really removed the new typedefs for 64-bit systems. + +-version 1.0.19rc5, 1.2.11rc5 [June 22, 2006] ++Version 1.0.19rc5, 1.2.11rc5 [June 22, 2006] + Removed png_sig_bytes entry from scripts/pngw32.def + +-version 1.0.19, 1.2.11 [June 26, 2006] ++Version 1.0.19, 1.2.11 [June 26, 2006] + None. + +-version 1.0.20, 1.2.12 [June 27, 2006] ++Version 1.0.20, 1.2.12 [June 27, 2006] + Really increased sprintf buffer from 50 to 52 chars in pngrutil.c to avoid + buffer overflow. + +-version 1.2.13beta1 [October 2, 2006] ++Version 1.2.13beta1 [October 2, 2006] + 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] ++Version 1.0.21, 1.2.13 [November 14, 2006] + Fix potential buffer overflow in sPLT chunk handler. + Fix Makefile.am to not try to link to noexistent files. + Check all exported functions for NULL png_ptr. + +-version 1.2.14beta1 [November 17, 2006] ++Version 1.2.14beta1 [November 17, 2006] + Relocated three misplaced tests for NULL png_ptr. + Built Makefile.in with automake-1.9.6 instead of 1.9.2. + Build configure with autoconf-2.60 instead of 2.59 + +-version 1.2.14beta2 [November 17, 2006] ++Version 1.2.14beta2 [November 17, 2006] + Added some typecasts in png_zalloc(). + +-version 1.2.14rc1 [November 20, 2006] ++Version 1.2.14rc1 [November 20, 2006] + Changed "strtod" to "png_strtod" in pngrutil.c + +-version 1.0.22, 1.2.14 [November 27, 2006] ++Version 1.0.22, 1.2.14 [November 27, 2006] + Added missing "$(srcdir)" in Makefile.am and Makefile.in + +-version 1.2.15beta1 [December 3, 2006] ++Version 1.2.15beta1 [December 3, 2006] + Generated configure with autoconf-2.61 instead of 2.60 + Revised configure.ac to update libpng.pc and libpng-config. + +-version 1.2.15beta2 [December 3, 2006] ++Version 1.2.15beta2 [December 3, 2006] + Always export MMX asm functions, just stubs if not building pnggccrd.c + +-version 1.2.15beta3 [December 4, 2006] ++Version 1.2.15beta3 [December 4, 2006] + Add "png_bytep" typecast to profile while calculating length in pngwutil.c + +-version 1.2.15beta4 [December 7, 2006] ++Version 1.2.15beta4 [December 7, 2006] + Added scripts/CMakeLists.txt + Changed PNG_NO_ASSEMBLER_CODE to PNG_NO_MMX_CODE in scripts, like 1.4.0beta + +-version 1.2.15beta5 [December 7, 2006] ++Version 1.2.15beta5 [December 7, 2006] + Changed some instances of PNG_ASSEMBLER_* to PNG_MMX_* in pnggccrd.c + Revised scripts/CMakeLists.txt + +-version 1.2.15beta6 [December 13, 2006] ++Version 1.2.15beta6 [December 13, 2006] + Revised scripts/CMakeLists.txt and configure.ac + +-version 1.2.15rc1 [December 18, 2006] ++Version 1.2.15rc1 [December 18, 2006] + Revised scripts/CMakeLists.txt + +-version 1.2.15rc2 [December 21, 2006] ++Version 1.2.15rc2 [December 21, 2006] + Added conditional #undef jmpbuf in pngtest.c to undo #define in AIX headers. + Added scripts/makefile.nommx + +-version 1.2.15rc3 [December 25, 2006] ++Version 1.2.15rc3 [December 25, 2006] + Fixed shared library numbering error that was introduced in 1.2.15beta6. + +-version 1.2.15rc4 [December 27, 2006] ++Version 1.2.15rc4 [December 27, 2006] + Fixed handling of rgb_to_gray when png_ptr->color.gray isn't set. + +-version 1.2.15rc5 [December 31, 2006] ++Version 1.2.15rc5 [December 31, 2006] + Revised handling of rgb_to_gray. + +-version 1.0.23, 1.2.15 [January 5, 2007] ++Version 1.2.15 [January 5, 2007] + Added some (unsigned long) typecasts in pngtest.c to avoid printing errors. + +-version 1.2.16beta1 [January 6, 2007] ++Version 1.2.16beta1 [January 6, 2007] + Fix bugs in makefile.nommx + +-version 1.2.16beta2 [January 16, 2007] ++Version 1.2.16beta2 [January 16, 2007] + Revised scripts/CMakeLists.txt + +-version 1.0.24, 1.2.16 [January 31, 2007] ++Version 1.2.16 [January 31, 2007] + No changes. + +-version 1.2.17beta1 [March 6, 2007] ++Version 1.2.17beta1 [March 6, 2007] + Revised scripts/CMakeLists.txt to install both shared and static libraries. + Deleted a redundant line from pngset.c. + +-version 1.2.17beta2 [April 26, 2007] ++Version 1.2.17beta2 [April 26, 2007] + Relocated misplaced test for png_ptr == NULL in pngpread.c + Change "==" to "&" for testing PNG_RGB_TO_GRAY_ERR & PNG_RGB_TO_GRAY_WARN + flags. +@@ -1704,10 +1870,10 @@ version 1.2.17beta2 [April 26, 2007] + Added "const" to some array declarations. + Mention examples of libpng usage in the libpng*.txt and libpng.3 documents. + +-version 1.2.17rc1 [May 4, 2007] ++Version 1.2.17rc1 [May 4, 2007] + No changes. + +-version 1.2.17rc2 [May 8, 2007] ++Version 1.2.17rc2 [May 8, 2007] + Moved several PNG_HAVE_* macros out of PNG_INTERNAL because applications + calling set_unknown_chunk_location() need them. + Changed transformation flag from PNG_EXPAND_tRNS to PNG_EXPAND in +@@ -1716,693 +1882,445 @@ version 1.2.17rc2 [May 8, 2007] + can be free'ed in case of error. Revised unknown chunk handling in + pngrutil.c and pngpread.c to use this structure. + +-version 1.2.17rc3 [May 8, 2007] ++Version 1.2.17rc3 [May 8, 2007] + Revised symbol-handling in configure script. + +-version 1.2.17rc4 [May 10, 2007] ++Version 1.2.17rc4 [May 10, 2007] + Revised unknown chunk handling to avoid storing unknown critical chunks. + +-version 1.0.25 [May 15, 2007] +-version 1.2.17 [May 15, 2007] ++Version 1.0.25 [May 15, 2007] ++Version 1.2.17 [May 15, 2007] + Added "png_ptr->num_trans=0" before error return in png_handle_tRNS, + to eliminate a vulnerability (CVE-2007-2445, CERT VU#684664) + +-version 1.0.26 [May 15, 2007] +-version 1.2.18 [May 15, 2007] ++Version 1.0.26 [May 15, 2007] ++Version 1.2.18 [May 15, 2007] + Reverted the libpng-1.2.17rc3 change to symbol-handling in configure script + +-version 1.2.19beta1 [May 18, 2007] ++Version 1.2.19beta1 [May 18, 2007] + Changed "const static" to "static PNG_CONST" everywhere, mostly undoing + change of libpng-1.2.17beta2. Changed other "const" to "PNG_CONST" + Changed some handling of unused parameters, to avoid compiler warnings. + "if (unused == NULL) return;" becomes "unused = unused". + +-version 1.2.19beta2 [May 18, 2007] ++Version 1.2.19beta2 [May 18, 2007] + Only use the valid bits of tRNS value in png_do_expand() (Brian Cartier) + +-version 1.2.19beta3 [May 19, 2007] ++Version 1.2.19beta3 [May 19, 2007] + Add some "png_byte" typecasts in png_check_keyword() and write new_key + instead of key in zTXt chunk (Kevin Ryde). + +-version 1.2.19beta4 [May 21, 2007] ++Version 1.2.19beta4 [May 21, 2007] + Add png_snprintf() function and use it in place of sprint() for improved + defense against buffer overflows. + +-version 1.2.19beta5 [May 21, 2007] ++Version 1.2.19beta5 [May 21, 2007] + Fixed png_handle_tRNS() to only use the valid bits of tRNS value. + Changed handling of more unused parameters, to avoid compiler warnings. + Removed some PNG_CONST in pngwutil.c to avoid compiler warnings. + +-version 1.2.19beta6 [May 22, 2007] ++Version 1.2.19beta6 [May 22, 2007] + Added some #ifdef PNG_MMX_CODE_SUPPORTED where needed in pngvcrd.c + Added a special "_MSC_VER" case that defines png_snprintf to _snprintf + +-version 1.2.19beta7 [May 22, 2007] ++Version 1.2.19beta7 [May 22, 2007] + Squelched png_squelch_warnings() in pnggccrd.c and added +- an #ifdef PNG_MMX_CODE_SUPPORTED/#endif block around the declarations +- that caused the warnings that png_squelch_warnings was squelching. ++ an #ifdef PNG_MMX_CODE_SUPPORTED block around the declarations that caused ++ the warnings that png_squelch_warnings was squelching. + +-version 1.2.19beta8 [May 22, 2007] ++Version 1.2.19beta8 [May 22, 2007] + Removed __MMX__ from test in pngconf.h. + +-version 1.2.19beta9 [May 23, 2007] ++Version 1.2.19beta9 [May 23, 2007] + Made png_squelch_warnings() available via PNG_SQUELCH_WARNINGS macro. + Revised png_squelch_warnings() so it might work. + Updated makefile.sgcc and makefile.solaris; added makefile.solaris-x86. + +-version 1.2.19beta10 [May 24, 2007] ++Version 1.2.19beta10 [May 24, 2007] + Resquelched png_squelch_warnings(), use "__attribute__((used))" instead. + +-version 1.2.19beta11 [May 28, 2007] +- Return 0 from png_get_sPLT() and png_get_unknown_chunks() if png_ptr is NULL; +- changed three remaining instances of png_strcpy() to png_strncpy() (David +- Hill). +- Make test for NULL row_buf at the beginning of png_do_read_transformations +- unconditional. +- +-version 1.2.19beta12 [May 28, 2007] +- Revised pnggccrd.c. +- +-version 1.2.19beta13 [June 14, 2007] +- Prefer PNG_USE_PNGVCRD when _MSC_VER is defined in pngconf.h +- +-version 1.2.19beta14 [June 16, 2007] +- Fix bug with handling of 16-bit transparency, introduced in 1.2.19beta2 +- +-version 1.2.19beta15 [June 17, 2007] +- Revised pnggccrd.c. +- +-version 1.2.19beta16 [June 18, 2007] +- Revised pnggccrd.c again. +- Updated contrib/gregbook. +- Changed '#include "pnggccrd.c"' to 'include "$srcdir/pnggccrd.c"' +- in configure.ac +- +-version 1.2.19beta17 [June 19, 2007] +- Revised many of the makefiles, to set -DPNG_NO_MMX_CODE where needed +- and to not use -O3 unless -DPNG_NO_MMX_CODE is also set. +- +-version 1.2.19beta18 [June 23, 2007] +- Replaced some C++ style comments with C style comments in pnggccrd.c. +- Copied optimized C code from pnggccrd.c to pngrutil.c, removed dependency +- on pnggccrd.o from many makefiles. +- Added sl and dylib to list of extensions be installed by Makefile.am +- +-version 1.2.19beta19 [June 28, 2007] +- Fixed testing PNG_RGB_TO_GRAY_ERR & PNG_RGB_TO_GRAY_WARN in pngrtran.c +- More cleanup of pnggccrd.c and pngvcrd.c +- +-version 1.2.19beta20 [June 29, 2007] +- Rebuilt Makefile.in and configure using libtool-1.5.24. +- Fixed typo in pnggccrd.c +- +-version 1.2.19beta21 [June 30, 2007] +- More revision of pnggccrd.c +- Added "test" target to Makefile.in and Makefile.am +- +-version 1.2.19beta22 [July 3, 2007] +- Added info about pngrutil/pnggccrd/pngvcrd to png_get_header_version() +- Fix type definition of dummy_value_a, b in pnggccrd.c +- +-version 1.2.19beta23 [July 10, 2007] +- Revert change to type definition of dummy_value_a, b in pnggccrd.c +- Make sure __PIC__ is defined in pnggccrd.c when PIC is defined. +- Require gcc-4.1 or better to use PNG_HAVE_MMX_FILTER_ROW on x86_64 platforms +- +-version 1.2.19beta24 [July 14, 2007] +- Added PNG_NO_READ_FILTER, PNG_NO_WRITE_FILTER, PNG_NO_WARNING macros. +- Added contrib/pngminim to demonstrate building minimal encoder and decoder +- +-version 1.2.19beta25 [July 15, 2007] +- Removed the new PNG_NO_READ_FILTER macro since it would make the library +- unable to read valid PNG files, and filtering is at the heart of the +- PNG format. +- +-version 1.2.19beta26 [July 16, 2007] +- Changed "png_free(str)" to "png_free(png_ptr,str)" in pngrutil.c WinCE +- code (Yves Piguet). This bug was introduced in libpng-1.2.14. +- Updated scripts/CMakeLists.txt +- Relocated a misplaced #endif in pnggccrd.c +- +-version 1.2.19beta27 [July 17, 2007] +- Fixed incorrect stride and number of bytes copied (was 4 instead of +- 6 bytes) in the cleanup loop of pnggccrd.c and pngvcrd.c for handling +- the end of 48-bit interlaced rows (Glenn R-P). +- +-version 1.2.19beta28 [July 19, 2007] +- Removed requirement for gcc-4.1 or better to use PNG_HAVE_MMX_FILTER_ROW +- on x86_64 platforms +- Added png_warning() in pngrutil.c for short iCCP, iTXt, sPLT, or zTXT chunks. +- Revised pngtest.c so warnings are displayed regardless of PNG_NO_STDIO. +- +-version 1.2.19beta29 [July 20, 2007] +- Fix typo in pnggccrd.c (%%eax should be %%ax in secondloop48) +- +-version 1.2.19beta30 [July 26, 2007] +- Revised pnggccrd.c +- +-version 1.2.19beta31 [July 27, 2007] +- Fix typos in pnggccrd.c +- +-version 1.0.27rc1 and 1.2.19rc1 [July 31, 2007] +- Disable PNG_MMX_CODE_SUPPORTED when PNG_ASSEMBLER_CODE_SUPPORTED is off. +- Enable PNG_MMX_READ_FILTER_* by default, except when gcc-3.x is being +- used (they were inadvertently disabled in libpng-1.2.19beta23). +- Fix some debugging statements in pnggccrd.c and pngrutil.c +- Added information about disabling the MMX code in libpng documentation. +- +-version 1.0.27rc2 and 1.2.19rc2 [August 4, 2007] +- Removed some "#if 0" blocks. +- Made a global struct local in pngvcrd.c to make it thread safe. +- Issue a png_error() if application attempts to transform a row tht +- has not been initialized. +- +-version 1.0.27rc3 and 1.2.19rc3 [August 9, 2007] +- Slightly revised pngvcrd.c +- +-version 1.0.27rc4 and 1.2.19rc4 [August 9, 2007] +- Revised pnggccrd.c debugging change of rc1, which was broken. +- Revised scripts/CMakeLists.txt +- Change default to PNG_NO_GLOBAL_ARRAYS for MSVC. +- Turn off PNG_FLAG_ROW_INIT flag when setting transforms that expand pixels. +- +-version 1.0.27rc5 and 1.2.19rc5 [August 10, 2007] +- Fix typo (missing '"') in pnggccrd.c +- Revise handling of png_strtod in recent versions of WINCE +- +-version 1.0.27rc6 and 1.2.19rc6 [August 15, 2007] +- Fix typo (missing ',') in contrib/gregbook/readpng2.c +- Undid row initialization error exit added to rc2 and rc4. +- +-version 1.0.27 and 1.2.19 [August 18, 2007] +- Conditionally restored row initialization error exit. +- +-version 1.2.20beta01 [August 19, 2007] +- Fixed problem with compiling pnggccrd.c on Intel-Apple platforms. +- Changed png_malloc() to png_malloc_warn() in png_set_sPLT(). +- Added PNG_NO_ERROR_TEXT feature, with demo in contrib/pngminim +- Removed define PNG_WARN_UNINITIALIZED_ROW 1 /* 0: warning; 1: error */ +- because it caused some trouble. +- +-version 1.2.20beta02 [August 20, 2007] +- Avoid compiling pnggccrd.c on Intel-Apple platforms. +- +-version 1.2.20beta03 [August 20, 2007] +- Added "/D PNG_NO_MMX_CODE" to the non-mmx builds of projects/visualc6 +- and visualc71. +- +-version 1.2.20beta04 [August 21, 2007] +- Revised pngvcrd.c for improved efficiency (Steve Snyder). +- +-version 1.2.20rc1 [August 23, 2007] +- Revised pngconf.h to set PNG_NO_MMX_CODE for gcc-3.x compilers. +- +-version 1.2.20rc2 [August 27, 2007] +- Revised scripts/CMakeLists.txt +- Revised #ifdefs to ensure one and only one of pnggccrd.c, pngvcrd.c, +- or part of pngrutil.c is selected. +- +-version 1.2.20rc3 [August 30, 2007] +- Remove a little more code in pngwutil.c when PNG_NO_WRITE_FILTER is selected. +- Added /D _CRT_SECURE_NO_WARNINGS to visual6c and visualc71 projects. +- Compile png_mmx_support() in png.c even when PNG_NO_MMX_CODE is defined. +- Restored a "superfluous" #ifdef that was removed from 1.2.20rc2 pnggccrd.c, +- breaking the png_mmx_support() function. +- +-version 1.2.20rc4 [September 1, 2007] +- Removed Intel contributions (MMX, Optimized C). +- +-version 1.2.20rc5 [September 2, 2007] +- Restored configure and Makefile.in to rc3 and put a snippet of code in +- pnggccrd.c, to ensure configure makes the same PNG_NO_MMX_CODE selection +- +-version 1.2.20rc6 [September 2, 2007] +- Fixed bugs in scripts/CMakeLists.txt +- Removed pngvcrd.c references from msvc projects. +- +-version 1.0.28 and 1.2.20 [September 8, 2007] +- Removed "(NO READ SUPPORT)" from png_get_header_version() string. +- +-version 1.2.21beta1 [September 14, 2007] +- Fixed various mistakes reported by George Cook and Jeff Phillips: +- logical vs bitwise NOT in pngrtran.c, bug introduced in 1.2.19rc2 +- 16-bit cheap transparency expansion, bug introduced in 1.2.19beta2 +- errors with sizeof(unknown_chunk.name), bugs introduced in 1.2.19beta11 +- <= compare with unsigned var in pngset.c, should be ==. +- +-version 1.2.21beta2 [September 18, 2007] +- Removed some extraneous typecasts. +- +-version 1.2.21rc1 [September 25, 2007] +- Fixed potential out-of-bounds reads in png_handle_pCAL() and +- png_handle_ztXt() ("flayer" results reported by Tavis Ormandy). +- +-version 1.2.21rc2 [September 26, 2007] +- Fixed potential out-of-bounds reads in png_handle_sCAL(), +- png_handle_iTXt(), and png_push_read_tEXt(). +- Remove some PNG_CONST declarations from pngwutil.c to avoid compiler warnings +- Revised makefiles to update paths in libpng.pc properly. +- +-version 1.2.21rc3 [September 27, 2007] +- Revised makefiles to update "Libs" in libpng.pc properly. +- +-version 1.0.29 and 1.2.21rc3 [October 4, 2007] +- No changes. +- +-version 1.2.22beta1 [October 4, 2007] +- Again, fixed logical vs bitwise NOT in pngrtran.c, bug introduced +- in 1.2.19rc2 +- +-version 1.2.22beta2 [October 5, 2007] +- Fixed string length error in pngset.c (caused crashes while decoding iCCP) +- Add terminating NULL after each instance of png_strncpy(). +- +-version 1.2.22beta3 [October 6, 2007] +- Fix two off-by-one terminating NULL after png_strncpy(). +- +-version 1.2.22beta4 [October 7, 2007] +- Changed some 0 to '\0'. +- +-version 1.0.30rc1 and 1.2.22rc1 [October 8, 2007] +- No changes. +- +-version 1.0.30 and 1.2.22 [October 13, 2007] +- No changes. +- +-version 1.2.23beta01 [October 15, 2007] +- Reduced number of invocations of png_strlen() in pngset.c. +- Changed [azAZ09_] to [_abcde...89] in Makefile.am for better localization. +- +-version 1.2.23beta02 [October 16, 2007] +- Eliminated png_strncpy() and png_strcpy() (Pierre Poissinger) +- Changed $AN to $(AN) in Makefile.am. +- +-version 1.2.23beta03 [October 16, 2007] +- Fixed off-by-one error in pngset.c +- Restore statement to set last character of buffer to \0 in pngerror.c +- +-version 1.2.23beta04 [October 23, 2007] +- Reject attempt to set all-zero cHRM values. +- +-version 1.2.23beta05 [October 26, 2007] +- Add missing quotes in projects/visualc6, lost in version 1.2.20rc3 +- +-version 1.2.23rc01 [November 2, 2007] +- No changes. +- +-version 1.2.23 [November 6, 2007] +- No changes. +- +-version 1.2.24beta01 [November 19, 2007] +- Moved misplaced test for malloc failure in png_set_sPLT(). This bug was +- introduced in libpng-1.2.20beta01. +- Ifdef out avg_row etc from png.h and pngwrite.c when PNG_NO_WRITE_FILTER +- Do not use png_ptr->free_fn and png_ptr->mem_fn in png_destroy_read_struct() +- when png_ptr is NULL (Marshall Clow). +- Updated handling of symbol prefixes in Makefile.am and configure.ac (Mike +- Frysinger). +- +-version 1.2.24beta02 [November 30, 2007] +- Removed a useless test and fixed incorrect test in png_set_cHRM_fixed() +- (David Hill). +- +-version 1.2.24rc01 [December 7, 2007] +- No changes. +- +-version 1.2.24 [December 14, 2007] +- Make sure not to redefine _BSD_SOURCE in pngconf.h +- Revised gather.sh and makefile.std in contrib/pngminim to avoid compiling +- unused files. +- +-version 1.2.25beta01 [January 7, 2008] +- Fixed bug with unknown chunk handling, introduced in version 1.2.17rc2 +- +-version 1.2.25beta02 [January 10, 2008] +- Prevent gamma from being applied twice. +- +-version 1.2.25rc01 [January 17, 2008] +- No changes. +- +-version 1.2.25beta03 [January 22, 2008] +- Fixed some continue-after-malloc-failure errors in pngset.c (David Hill) +- Check for info_ptr == NULL in png_read_info() and png_process_data(). +- Check for possible use of NULL user_png_ver[] in png_create_read_struct(). +- Change "if (swidth == NULL)" to "if (sheight == NULL)" in png_handle_sCAL +- (bug introduced in libpng-1.2.4/1.0.13). +- Return from png_destroy_read_struct() if png_ptr_ptr is NULL. +- Fix overflow of "msg" in png_decompress_chunk(). +- +-version 1.2.25beta04 [January 26, 2008] +- Work around Coverity bug report by slightly refactoring +- png_read_push_finish_row() +- +-version 1.2.25beta05 [January 31, 2008] +- Added libpng-1.2.25beta05.tar.lzma to distribution. Get the lzma codec +- from . +- Added lp1225b05.7z to distribution. Get the 7-zip decoder from +- from . +- Fixed some broken links in the README file. +- +-version 1.2.25beta06 [February 6, 2008] +- Refactored png_read_push_finish_row() again, trying to satisfy Coverity. +- Fixed potential NULL dereference of png_ptr in png_destroy_write_struct(); +- clarified potential NULL dereference of png_ptr in png_destroy_read_struct(); +- fixed potential NULL dereference of info_ptr in png_handle_bKGD(); +- fixed potential NULL dereference of user_png_ver[] in +- png_create_write_struct_2(). (Coverity) +- +-version 1.2.25rc02 [February 10, 2008] +- Reset png_ptr->pass in png_read_push_finish_row() before break. +- Changed "pass" from png_byte to int. +- +-version 1.2.25 and 1.0.31 [February 18, 2008] +- No changes. +- +-version 1.2.26beta01 [February 21, 2008] +- Added missing "(" in pngmem.c. Bug introduced in libpng-1.2.2/1.0.13 +- +-version 1.2.26beta02 [March 12, 2008] +- Refined error message returned from deflateInit2 in pngwutil.c +- Check IHDR length in png_push_read_chunk() before saving it. +- +-version 1.2.26beta03 [March 16, 2008] +- Revised contrib/gregbook to handle premature end-of-file and file +- read errors correctly. +- +-version 1.2.26beta04 [March 18, 2008] +- Free png_ptr->big_row_buf and png_ptr->prev_row before allocating +- new copies in png_read_start_row(). Bug introduced in libpng-1.2.22. +- +-version 1.2.26beta05 [March 19, 2008] +- Removed extra png_free() added in libpng-1.2.26beta04. +- +-version 1.2.26beta06 [March 19, 2008] +- Avoid reallocating big_row_buf and prev_row when the size does not increase. +- +-version 1.2.26rc01 [March 26, 2008] +- Ifdef out some code that is unused when interlacing is not supported. +- +-versions 1.0.32 and 1.2.26 [April 2, 2008] +- No changes. +- +-version 1.2.27beta01 [April 12, 2008] +- Fixed bug (introduced in libpng-1.0.5h) with handling zero-length +- unknown chunks. +- Added more information about png_set_keep_unknown_chunks() to the +- documentation. +- Reject tRNS chunk with out-of-range samples instead of masking off +- the invalid high bits as done in since libpng-1.2.19beta5. +- +-version 1.2.27beta02 [April 13, 2008] +- Revised documentation about unknown chunk and user chunk handling. +- Keep tRNS chunk with out-of-range samples and issue a png_warning(). +- +-version 1.2.27beta03 [April 14, 2008] +- Added check for NULL ptr in TURBOC version of png_free_default(). +- Removed several unnecessary checks for NULL before calling png_free(). +- Revised png_set_tRNS() so that calling it twice removes and invalidates +- the previous call. +- Revised pngtest to check for out-of-range tRNS samples. +- +-version 1.2.27beta04 [April 18, 2008] +- Added AC_LIBTOOL_WIN32_DLL to configure.ac +- Rebuilt Makefile.in, aclocal.m4, and configure with autoconf-2.62 +- +-version 1.2.27beta05 [April 19, 2008] +- Added MAINTAINERCLEANFILES variable to Makefile.am +- +-version 1.2.27beta06 [April 21, 2008] +- Avoid changing color_type from GRAY to RGB by +- png_set_expand_gray_1_2_4_to_8(). +- +-version 1.2.27rc01 [April 23, 2008] +- Fix broken URL for rfc2083 in png.5 and libpng-*.txt ++Version 1.4.0beta1 [April 20, 2006] ++ Enabled iTXt support (changes png_struct, thus requires so-number change). ++ Cleaned up PNG_ASSEMBLER_CODE_SUPPORTED vs PNG_MMX_CODE_SUPPORTED ++ Eliminated PNG_1_0_X and PNG_1_2_X macros. ++ Removed deprecated functions png_read_init, png_write_init, png_info_init, ++ png_permit_empty_plte, png_set_gray_1_2_4_to_8, png_check_sig, and ++ removed the deprecated macro PNG_MAX_UINT. ++ Moved "PNG_INTERNAL" parts of png.h and pngconf.h into pngintrn.h ++ Removed many WIN32_WCE #ifdefs (Cosmin). ++ Reduced dependency on C-runtime library when on Windows (Simon-Pierre) ++ Replaced sprintf() with png_sprintf() (Simon-Pierre) ++ ++Version 1.4.0beta2 [April 20, 2006] ++ Revised makefiles and configure to avoid making links to libpng.so.* ++ Moved some leftover MMX-related defines from pngconf.h to pngintrn.h ++ Updated scripts/pngos2.def, pngw32.def, and projects/wince/png32ce.def + +-version 1.0.33 and 1.2.27 [April 30, 2008] +- No changes. ++Version 1.4.0beta3 [May 10, 2006] ++ Updated scripts/pngw32.def to comment out MMX functions. ++ Added PNG_NO_GET_INT_32 and PNG_NO_SAVE_INT_32 macros. ++ Scripts/libpng.pc.in contained "configure" style version info and would ++ not work with makefiles. ++ Revised pngconf.h and added pngconf.h.in, so makefiles and configure can ++ pass defines to libpng and applications. + +-version 1.0.34 and 1.2.28 [April 30, 2008] +- Rebuilt Makefile.in, aclocal.m4, and configure with autoconf-2.61 +- due to backward incompatibilities. +- Removed a stray object file from contrib/gregbook ++Version 1.4.0beta4 [May 11, 2006] ++ Revised configure.ac, Makefile.am, and many of the makefiles to write ++ their defines in pngconf.h. + +-version 1.2.29beta01 [May 1, 2008] +- Removed some stray *.diff and *.orig files ++Version 1.4.0beta5 [May 15, 2006] ++ Added a missing semicolon in Makefile.am and Makefile.in ++ Deleted extraneous square brackets from configure.ac + +-version 1.2.29beta02 [May 1, 2008] +- Reverted Makefile.in, aclocal.m4, and configure to the libpng-1.2.26 +- versions. ++Version 1.4.0beta6 [June 2, 2006] ++ Increased sprintf buffer from 50 to 52 chars in pngrutil.c to avoid ++ buffer overflow. ++ Changed sonum from 0 to 1. ++ Removed unused prototype for png_check_sig() from png.h ++ ++Version 1.4.0beta7 [June 16, 2006] ++ Exported png_write_sig (Cosmin). ++ Optimized buffer in png_handle_cHRM() (Cosmin). ++ Set pHYs = 2835 x 2835 pixels per meter, and added ++ sCAL = 0.352778e-3 x 0.352778e-3 meters, in pngtest.png (Cosmin). ++ Added png_set_benign_errors(), png_benign_error(), png_chunk_benign_error(). ++ Added typedef for png_int_32 and png_uint_32 on 64-bit systems. ++ Added "(unsigned long)" typecast on png_uint_32 variables in printf lists. ++ ++Version 1.4.0beta8 [June 22, 2006] ++ Added demonstration of user chunk support in pngtest.c, to support the ++ public sTER chunk and a private vpAg chunk. ++ ++Version 1.4.0beta9 [July 3, 2006] ++ Removed ordinals from scripts/pngw32.def and removed png_info_int and ++ png_set_gray_1_2_4_to_8 entries. ++ Inline call of png_get_uint_32() in png_get_uint_31(). ++ Use png_get_uint_31() to get vpAg width and height in pngtest.c ++ Removed WINCE and Netware projects. ++ Removed standalone Y2KINFO file. ++ ++Version 1.4.0beta10 [July 12, 2006] ++ Eliminated automatic copy of pngconf.h to pngconf.h.in from configure and ++ some makefiles, because it was not working reliably. Instead, distribute ++ pngconf.h.in along with pngconf.h and cause configure and some of the ++ makefiles to update pngconf.h from pngconf.h.in. ++ Added pngconf.h to DEPENDENCIES in Makefile.am ++ ++Version 1.4.0beta11 [August 19, 2006] ++ Removed AC_FUNC_MALLOC from configure.ac. ++ Added a warning when writing iCCP profile with mismatched profile length. ++ Patched pnggccrd.c to assemble on x86_64 platforms. ++ Moved chunk header reading into a separate function png_read_chunk_header() ++ in pngrutil.c. The chunk header (len+sig) is now serialized in a single ++ operation (Cosmin). ++ Implemented support for I/O states. Added png_ptr member io_state, and ++ functions png_get_io_chunk_name() and png_get_io_state() in pngget.c ++ (Cosmin). ++ Added png_get_io_chunk_name and png_get_io_state to scripts/*.def (Cosmin). ++ Renamed scripts/pngw32.* to scripts/pngwin.* (Cosmin). ++ Removed the include directories and libraries from CFLAGS and LDFLAGS ++ in scripts/makefile.gcc (Cosmin). ++ Used png_save_uint_32() to set vpAg width and height in pngtest.c (Cosmin). ++ Cast to proper type when getting/setting vpAg units in pngtest.c (Cosmin). ++ Added pngintrn.h to the Visual C++ projects (Cosmin). ++ Removed scripts/list (Cosmin). ++ Updated copyright year in scripts/pngwin.def (Cosmin). ++ Removed PNG_TYPECAST_NULL and used standard NULL consistently (Cosmin). ++ Disallowed the user to redefine png_size_t, and enforced a consistent use ++ of png_size_t across libpng (Cosmin). ++ Changed the type of png_ptr->rowbytes, PNG_ROWBYTES() and friends ++ to png_size_t (Cosmin). ++ Removed png_convert_size() and replaced png_sizeof with sizeof (Cosmin). ++ Removed some unnecessary type casts (Cosmin). ++ Changed prototype of png_get_compression_buffer_size() and ++ png_set_compression_buffer_size() to work with png_size_t instead of ++ png_uint_32 (Cosmin). ++ Removed png_memcpy_check() and png_memset_check() (Cosmin). ++ Fixed a typo (png_byte --> png_bytep) in libpng.3 and libpng.txt (Cosmin). ++ Clarified that png_zalloc() does not clear the allocated memory, ++ and png_zalloc() and png_zfree() cannot be PNGAPI (Cosmin). ++ Renamed png_mem_size_t to png_alloc_size_t, fixed its definition in ++ pngconf.h, and used it in all memory allocation functions (Cosmin). ++ Renamed pngintrn.h to pngpriv.h, added a comment at the top of the file ++ mentioning that the symbols declared in that file are private, and ++ updated the scripts and the Visual C++ projects accordingly (Cosmin). ++ Removed circular references between pngconf.h and pngconf.h.in in ++ scripts/makefile.vc*win32 (Cosmin). ++ Removing trailing '.' from the warning and error messages (Cosmin). ++ Added pngdefs.h that is built by makefile or configure, instead of ++ pngconf.h.in (Glenn). ++ Detect and fix attempt to write wrong iCCP profile length. + +-version 1.2.29beta03 [May 2, 2008] +- Added --force to autogen libtoolize options and --force-missing to +- automake options. +- Changed $(ECHO) to echo in Makefile.am and Makefile.in +- Updated all configure files to autoconf-2.62 +- Comment out pnggcrd.c code with #ifdef/#endif if using MSC_VER ++Version 1.4.0beta12 [October 19, 2006] ++ Changed "logical" to "bitwise" in the documentation. ++ Work around Intel-Mac compiler bug by setting PNG_NO_MMX_CODE in pngconf.h ++ Add a typecast to stifle compiler warning in pngrutil.c + +-version 1.2.29rc01 [May 4, 2008] +- No changes. ++Version 1.4.0beta13 [November 10, 2006] ++ Fix potential buffer overflow in sPLT chunk handler. ++ Fix Makefile.am to not try to link to noexistent files. + +-version 1.0.35 and 1.2.29 [May 8, 2008] +- No changes. ++Version 1.4.0beta14 [November 15, 2006] ++ Check all exported functions for NULL png_ptr. + +-version 1.0.37 [May 9, 2008] +- Updated Makefile.in and configure (omitted version 1.0.36). ++Version 1.4.0beta15 [November 17, 2006] ++ Relocated two misplaced tests for NULL png_ptr. ++ Built Makefile.in with automake-1.9.6 instead of 1.9.2. ++ Build configure with autoconf-2.60 instead of 2.59 ++ Add "install: all" in Makefile.am so "configure; make install" will work. + +-version 1.2.30beta01 [May 29, 2008] +- Updated libpng.pc-configure.in and libpng-config.in per debian bug reports. ++Version 1.4.0beta16 [November 17, 2006] ++ Added a typecast in png_zalloc(). + +-version 1.2.30beta02 [June 25, 2008] +- Restored png_flush(png_ptr) at the end of png_write_end(), that was +- removed from libpng-1.0.9beta03. ++Version 1.4.0beta17 [December 4, 2006] ++ Changed "new_key[79] = '\0';" to "(*new_key)[79] = '\0';" in pngwutil.c ++ Add "png_bytep" typecast to profile while calculating length in pngwutil.c + +-version 1.2.30beta03 [July 6, 2008] +- Merged some cosmetic whitespace changes from libpng-1.4.0beta19. +- Inline call of png_get_uint_32() in png_get_uint_31(), as in 1.4.0beta19. +- Added demo of decoding vpAg and sTER chunks to pngtest.c, from 1.4.0beta19. +- Changed PNGMAJ from 0 to 12 in makefile.darwin, which does not like 0. +- Added new private function png_read_chunk_header() from 1.4.0beta19. +- Merge reading of chunk length and chunk type into a single 8-byte read. +- Merge writing of chunk length and chunk type into a single 8-byte write. ++Version 1.4.0beta18 [December 7, 2006] ++ Added scripts/CMakeLists.txt + +-version 1.2.30beta04 [July 10, 2008] +- Merged more cosmetic whitespace changes from libpng-1.4.0beta19. ++Version 1.4.0beta19 [May 16, 2007] ++ Revised scripts/CMakeLists.txt ++ Rebuilt configure and Makefile.in with newer tools. ++ Added conditional #undef jmpbuf in pngtest.c to undo #define in AIX headers. ++ Added scripts/makefile.nommx + +-version 1.0.38rc01, 1.2.30rc01 [July 18, 2008] +- No changes. ++Version 1.4.0beta20 [July 9, 2008] ++ Moved several PNG_HAVE_* macros from pngpriv.h to png.h because applications ++ calling set_unknown_chunk_location() need them. ++ Moved several macro definitions from pngpriv.h to pngconf.h ++ Merge with changes to the 1.2.X branch, as of 1.2.30beta04. ++ Deleted all use of the MMX assembler code and Intel-licensed optimizations. ++ Revised makefile.mingw + +-version 1.0.38rc02, 1.2.30rc02 [July 21, 2008] ++Version 1.4.0beta21 [July 21, 2008] + Moved local array "chunkdata" from pngrutil.c to the png_struct, so + it will be freed by png_read_destroy() in case of a read error (Kurt + Christensen). + +-version 1.0.38rc03, 1.2.30rc03 [July 21, 2008] +- Changed "purpose" and "buffer" to png_ptr->chunkdata to avoid memory leaking. ++Version 1.4.0beta22 [July 21, 2008] ++ Change "purpose" and "buffer" to png_ptr->chunkdata to avoid memory leaking. + +-version 1.0.38rc04, 1.2.30rc04 [July 22, 2008] +- Changed "chunkdata = NULL" to "png_ptr->chunkdata = NULL" several places in ++Version 1.4.0beta23 [July 22, 2008] ++ Change "chunkdata = NULL" to "png_ptr->chunkdata = NULL" several places in + png_decompress_chunk(). + +-version 1.0.38rc05, 1.2.30rc05 [July 25, 2008] +- Changed all remaining "chunkdata" to "png_ptr->chunkdata" in +- png_decompress_chunk() and remove chunkdata from parameter list. ++Version 1.4.0beta24 [July 25, 2008] ++ Change all remaining "chunkdata" to "png_ptr->chunkdata" in ++ 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() occuring later in the process. ++ Removed two calls to png_check_chunk_name() occurring later in the process. ++ Define PNG_NO_ERROR_NUMBERS by default in pngconf.h + +-version 1.0.38rc06, 1.2.30rc06 [July 29, 2008] ++Version 1.4.0beta25 [July 30, 2008] + Added a call to png_check_chunk_name() in pngpread.c + Reverted png_check_chunk_name() to accept a name with a lowercase 3rd byte. ++ Added png_push_have_buffer() function to pngpread.c ++ Eliminated PNG_BIG_ENDIAN_SUPPORTED and associated png_get_* macros. ++ Made inline expansion of png_get_*() optional with PNG_USE_READ_MACROS. ++ Eliminated all PNG_USELESS_TESTS and PNG_CORRECT_PALETTE_SUPPORTED code. ++ Synced contrib directory and configure files with libpng-1.2.30beta06. ++ Eliminated no-longer-used pngdefs.h (but it's still built in the makefiles) ++ Relocated a misplaced "#endif /* PNG_NO_WRITE_FILTER */" in pngwutil.c + +-version 1.0.38r07, 1.2.30r07 [August 2, 2008] ++Version 1.4.0beta26 [August 4, 2008] ++ Removed png_push_have_buffer() function in pngpread.c. It increased the ++ compiled library size slightly. + Changed "-Wall" to "-W -Wall" in the CFLAGS in all makefiles (Cosmin Truta) + Declared png_ptr "volatile" in pngread.c and pngwrite.c to avoid warnings. +- Added code in pngset.c to quiet compiler warnings. + Updated contrib/visupng/cexcept.h to version 2.0.1 +- Relocated a misplaced "#endif /* PNG_NO_WRITE_FILTER */" in pngwutil.c ++ Added PNG_LITERAL_CHARACTER macros for #, [, and ]. + +-version 1.0.38r08, 1.2.30r08 [August 2, 2008] +- Enclose "volatile" declarations in #ifdef PNG_SETJMP_SUPPORTED (Cosmin). ++Version 1.4.0beta27 [August 5, 2008] ++ Revised usage of PNG_LITERAL_SHARP in pngerror.c. ++ Moved newline character from individual png_debug messages into the ++ png_debug macros. ++ Allow user to #define their own png_debug, png_debug1, and png_debug2. + +-version 1.0.38, 1.2.30 [August 14, 2008] +- No changes. ++Version 1.4.0beta28 [August 5, 2008] ++ Revised usage of PNG_LITERAL_SHARP in pngerror.c. ++ Added PNG_STRING_NEWLINE macro ++ ++Version 1.4.0beta29 [August 9, 2008] ++ Revised usage of PNG_STRING_NEWLINE to work on non-ISO compilers. ++ Added PNG_STRING_COPYRIGHT macro. ++ Added non-ISO versions of png_debug macros. + +-version 1.2.31rc01 [August 19, 2008] ++Version 1.4.0beta30 [August 14, 2008] ++ Added premultiplied alpha feature (Volker Wiendl). ++ ++Version 1.4.0beta31 [August 18, 2008] ++ Moved png_set_premultiply_alpha from pngtrans.c to pngrtran.c + Removed extra crc check at the end of png_handle_cHRM(). Bug introduced +- in libpng-1.2.30beta03 (Heiko Nitzsche). ++ in libpng-1.4.0beta20. + +-version 1.2.31rc02 [August 19, 2008] ++Version 1.4.0beta32 [August 19, 2008] + Added PNG_WRITE_FLUSH_SUPPORTED block around new png_flush() call. ++ Revised PNG_NO_STDIO version of png_write_flush() + +-version 1.2.31rc03 [August 19, 2008] +- Added PNG_WRITE_FLUSH_AFTER_IEND_SUPPORTED block, off by default, around +- new png_flush(). ++Version 1.4.0beta33 [August 20, 2008] ++ Added png_get|set_chunk_cache_max() to limit the total number of sPLT, ++ text, and unknown chunks that can be stored. + +-version 1.0.39, 1.2.31 [August 21, 2008] +- No changes. +- +-version 1.2.32beta01 [September 6, 2008] +- Shortened tIME_string to 29 bytes in pngtest.c (bug introduced in +- libpng-1.2.22). ++Version 1.4.0beta34 [September 6, 2008] ++ Shortened tIME_string to 29 bytes in pngtest.c + Fixed off-by-one error introduced in png_push_read_zTXt() function in + libpng-1.2.30beta04/pngpread.c (Harald van Dijk) +- These bugs have been given the vulnerability id CVE-2008-3964. +- +-version 1.0.40, 1.2.32 [September 18, 2008] +- No changes. + +-version 1.2.33beta01 [October 6, 2008] ++Version 1.4.0beta35 [October 6, 2008] ++ Changed "trans_values" to "trans_color". ++ Changed so-number from 0 to 14. Some OS do not like 0. + Revised makefile.darwin to fix shared library numbering. + Change png_set_gray_1_2_4_to_8() to png_set_expand_gray_1_2_4_to_8() + in example.c (debian bug report) + +-version 1.2.33rc01 [October 15, 2008] +- No changes. ++Version 1.4.0beta36 [October 25, 2008] ++ Sync with tEXt vulnerability fix in libpng-1.2.33rc02. + +-version 1.0.41rc01, version 1.2.33rc02 [October 23, 2008] +- Changed remaining "key" to "png_ptr->chunkdata" in png_handle_tEXt() +- to avoid memory leak after memory failure while reading tEXt chunk.` ++Version 1.4.0beta37 [November 13, 2008] ++ Added png_check_cHRM in png.c and moved checking from pngget.c, pngrutil.c, ++ and pngwrite.c + +-version 1.2.33 [October 31, 2008] +- No changes. ++Version 1.4.0beta38 [November 22, 2008] ++ Added check for zero-area RGB cHRM triangle in png_check_cHRM() and ++ png_check_cHRM_fixed(). + +-version 1.2.34beta01 [November 27, 2008] +- Revised png_warning() to write its message on standard output by default +- when warning_fn is NULL. This was the behavior prior to libpng-1.2.9beta9. +- Fixed string vs pointer-to-string error in png_check_keyword(). +- Added png_check_cHRM_fixed() in png.c and moved checking from pngget.c, +- pngrutil.c, and pngwrite.c, and eliminated floating point cHRM checking. +- Added check for zero-area RGB cHRM triangle in png_check_cHRM_fixed(). +- In png_check_cHRM_fixed(), ensure white_y is > 0, and removed redundant +- check for all-zero coordinates that is detected by the triangle check. ++Version 1.4.0beta39 [November 23, 2008] + Revised png_warning() to write its message on standard output by default + when warning_fn is NULL. + +-version 1.2.34beta02 [November 28, 2008] +- Corrected off-by-one error in bKGD validity check in png_write_bKGD() +- and in png_handle_bKGD(). ++Version 1.4.0beta40 [November 24, 2008] ++ Eliminated png_check_cHRM(). Instead, always use png_check_cHRM_fixed(). ++ In png_check_cHRM_fixed(), ensure white_y is > 0, and removed redundant ++ check for all-zero coordinates that is detected by the triangle check. + +-version 1.2.34beta03 [December 1, 2008] +- Revised bKGD validity check to use >= x instead of > x + 1 +- Merged with png_debug from libpng-1.4.0 to remove newlines. ++Version 1.4.0beta41 [November 26, 2008] ++ Fixed string vs pointer-to-string error in png_check_keyword(). ++ Rearranged test expressions in png_check_cHRM_fixed() to avoid internal ++ overflows. ++ Added PNG_NO_CHECK_cHRM conditional. + +-version 1.2.34beta04 [December 2, 2008] +- More merging with png_debug from libpng-1.4.0 to remove newlines. ++Version 1.4.0beta42, 43 [December 1, 2008] ++ Merge png_debug with version 1.2.34beta04. + +-version 1.2.34beta05 [December 5, 2008] ++Version 1.4.0beta44 [December 6, 2008] + Removed redundant check for key==NULL before calling png_check_keyword() + to ensure that new_key gets initialized and removed extra warning +- (Arvan Pritchard). ++ (Merge with version 1.2.34beta05 -- Arvan Pritchard). + +-version 1.2.34beta06 [December 9, 2008] ++Version 1.4.0beta45 [December 9, 2008] + In png_write_png(), respect the placement of the filler bytes in an earlier + call to png_set_filler() (Jim Barry). + +-version 1.2.34beta07 [December 9, 2008] ++Version 1.4.0beta46 [December 10, 2008] + Undid previous change and added PNG_TRANSFORM_STRIP_FILLER_BEFORE and + PNG_TRANSFORM_STRIP_FILLER_AFTER conditionals and deprecated + PNG_TRANSFORM_STRIP_FILLER (Jim Barry). + +-version 1.0.42rc01, 1.2.34rc01 [December 11, 2008] +- No changes. +- +-version 1.0.42, 1.2.34 [December 18, 2008] +- No changes. +- +-version 1.2.35beta01 [February 4, 2009] +- Zero out some arrays of pointers after png_malloc(). (Tavis Ormandy) +- +-version 1.2.35beta02 [February 4, 2009] +- Zero out more arrays of pointers after png_malloc(). +- +-version 1.2.35beta03 [February 5, 2009] +- Use png_memset() instead of a loop to intialize pointers. We realize +- this will not work on platforms where the NULL pointer is not all zeroes. +- +-version 1.2.35rc01 [February 11, 2009] +- No changes. ++Version 1.4.0beta47 [December 15, 2008] ++ Support for dithering was disabled by default, because it has never ++ been well tested and doesn't work very well. The code has not ++ been removed, however, and can be enabled by building libpng with ++ PNG_READ_DITHER_SUPPORTED defined. ++ ++Version 1.4.0beta48 [February 14, 2009] ++ Added new exported function png_calloc(). ++ Combined several instances of png_malloc(); png_memset() into png_calloc(). ++ Removed prototype for png_freeptr() that was added in libpng-1.4.0beta24 ++ but was never defined. ++ ++Version 1.4.0beta49 [February 28, 2009] ++ Added png_fileno() macro to pngconf.h, used in pngwio.c ++ Corrected order of #ifdef's in png_debug definition in png.h ++ Fixed bug introduced in libpng-1.4.0beta48 with the memset arguments ++ for pcal_params. ++ Fixed order of #ifdef directives in the png_debug defines in png.h ++ (bug introduced in libpng-1.2.34/1.4.0beta29). ++ Revised comments in png_set_read_fn() and png_set_write_fn(). + +-version 1.2.35rc02 [February 12, 2009] +- Fix typo in new png_memset call in pngset.c (png_color should be png_charp) ++Version 1.4.0beta50 [March 18, 2009] ++ Use png_calloc() instead of png_malloc() to allocate big_row_buf when ++ reading an interlaced file, to avoid a possible UMR. ++ Undid revision of PNG_NO_STDIO version of png_write_flush(). Users ++ having trouble with fflush() can build with PNG_NO_WRITE_FLUSH defined ++ or supply their own flush_fn() replacement. ++ Revised libpng*.txt and png.h documentation about use of png_write_flush() ++ and png_set_write_fn(). ++ Removed fflush() from pngtest.c. ++ Added "#define PNG_NO_WRITE_FLUSH" to contrib/pngminim/encoder/pngusr.h + +-version 1.0.43 and 1.2.35 [February 14, 2009] +- No changes. ++Version 1.4.0beta51 [March 21, 2009] ++ Removed new png_fileno() macro from pngconf.h . + +-version 1.2.36beta01 [February 28, 2009] +- Revised comments in png_set_read_fn() and png_set_write_fn(). +- Revised order of #ifdef's and indentation in png_debug definitions of png.h +- bug introduced in libpng-1.2.34. +- +-version 1.2.36beta02 [March 21, 2009] +- Use png_memset() after png_malloc() of big_row_buf when reading an +- interlaced file, to avoid a possible UMR. +- Undid recent revision of PNG_NO_STDIO version of png_write_flush(). Users +- having trouble with fflush() can build with PNG_NO_WRITE_FLUSH defined. +- Revised libpng*.txt documentation about use of png_write_flush(). ++Version 1.4.0beta52 [March 27, 2009] ++ Relocated png_do_chop() ahead of building gamma tables in pngrtran.c ++ This avoids building 16-bit gamma tables unnecessarily. + Removed fflush() from pngtest.c. + Added "#define PNG_NO_WRITE_FLUSH" to contrib/pngminim/encoder/pngusr.h +- +-version 1.2.36beta03 [March 27, 2009] +- Relocated misplaced PNG_1_0_X define in png.h that caused the prototype +- for png_set_strip_error_numbers() to be omitted from PNG_NO_ASSEMBLER_CODE +- builds. This bug was introduced in libpng-1.2.15beta4. + Added a section on differences between 1.0.x and 1.2.x to libpng.3/libpng.txt + +-version 1.2.36beta04 [April 5, 2009] ++Version 1.4.0beta53 [April 1, 2009] ++ Removed some remaining MMX macros from pngpriv.h + Fixed potential memory leak of "new_name" in png_write_iCCP() (Ralph Giles) + +-version 1.2.36beta05 [April 24, 2009] ++Version 1.4.0beta54 [April 13, 2009] + Added "ifndef PNG_SKIP_SETJMP_CHECK" block in pngconf.h to allow + application code writers to bypass the check for multiple inclusion + of setjmp.h when they know that it is safe to ignore the situation. +- Made some cosmetic changes to whitespace in pngtest output. ++ Eliminated internal use of setjmp() in pngread.c and pngwrite.c ++ Reordered ancillary chunks in pngtest.png to be the same as what ++ pngtest now produces, and made some cosmetic changes to pngtest output. ++ Eliminated deprecated png_read_init_3() and png_write_init_3() functions. ++ ++Version 1.4.0beta55 [April 15, 2009] ++ Simplified error handling in pngread.c and pngwrite.c by putting ++ the new png_read_cleanup() and png_write_cleanup() functions inline. ++ ++Version 1.4.0beta56 [April 25, 2009] + Renamed "user_chunk_data" to "my_user_chunk_data" in pngtest.c to suppress + "shadowed declaration" warning from gcc-4.3.3. + Renamed "gamma" to "png_gamma" in pngset.c to avoid "shadowed declaration" + warning about a global "gamma" variable in math.h on some platforms. + +-version 1.2.36rc01 [April 30, 2009] +- No changes. +- +-version 1.0.44 and 1.2.36 [May 7, 2009] +- No changes. ++Version 1.4.0beta57 [May 2, 2009] ++ Removed prototype for png_freeptr() that was added in libpng-1.4.0beta24 ++ but was never defined (again). ++ Rebuilt configure scripts with autoconf-2.63 instead of 2.62 ++ Removed pngprefs.h and MMX from makefiles + +-version 1.2.37beta01 [May 14, 2009] +- Fixed inconsistency in pngrutil.c, introduced in libpng-1.2.36. The +- memset() was using "png_ptr->rowbytes" instead of "row_bytes", which +- the corresponding png_malloc() uses (Joe Drew). ++Version 1.4.0beta58 [May 14, 2009] ++ Changed pngw32.def to pngwin.def in makefile.mingw (typo was introduced ++ in beta57). + Clarified usage of sig_bit versus sig_bit_p in example.c (Vincent Torri) +- Updated some of the makefiles in the scripts directory (merged with +- those in libpng-1.4.0beta57). + +-version 1.2.37beta02 [May 19, 2009] +- Fixed typo in libpng documentation (FILTER_AVE should be FILTER_AVG) ++Version 1.4.0beta59 [May 15, 2009] ++ Reformated sources in libpng style (3-space intentation, comment format) ++ Fixed typo in libpng docs (PNG_FILTER_AVE should be PNG_FILTER_AVG) ++ Added sections about the git repository and our coding style to the ++ documentation + Relocated misplaced #endif in pngwrite.c, sCAL chunk handler. ++ ++Version 1.4.0beta60 [May 19, 2009] + Conditionally compile png_read_finish_row() which is not used by + progressive readers. + Added contrib/pngminim/preader to demonstrate building minimal progressive + decoder, based on contrib/gregbook with embedded libpng and zlib. + +-version 1.2.37beta03 [May 20, 2009] ++Version 1.4.0beta61 [May 20, 2009] + In contrib/pngminim/*, renamed "makefile.std" to "makefile", since there + is only one makefile in those directories, and revised the README files + accordingly. +- Reformated sources in libpng style (3-space indentation, comment format) ++ More reformatting of comments, mostly to capitalize sentences. + +-version 1.2.37rc01 [May 27, 2009] +- No changes. +- +-versions 1.2.37 and 1.0.45 [June 4, 2009] +- Reformatted several remaining "else statement;" and "if () statement;" into +- two lines. ++Version 1.4.0beta62 [June 2, 2009] + Added "#define PNG_NO_WRITE_SWAP" to contrib/pngminim/encoder/pngusr.h + and "define PNG_NO_READ_SWAP" to decoder/pngusr.h and preader/pngusr.h +- Added sections about the git repository and our coding style to the +- documentation (merged from libpng-1.4.0beta62) ++ Reformatted several remaining "else statement" into two lines. + Added a section to the libpng documentation about using png_get_io_ptr() + in configure scripts to detect the presence of libpng. + +-version 1.2.38beta01 [June 17, 2009] ++Version 1.4.0beta63 [June 15, 2009] + Revised libpng*.txt and libpng.3 to mention calling png_set_IHDR() + multiple times and to specify the sample order in the tRNS chunk, + because the ISO PNG specification has a typo in the tRNS table. +@@ -2411,154 +2329,143 @@ version 1.2.38beta01 [June 17, 2009] + available for ignoring known chunks even when not saving unknown chunks. + Adopted preference for consistent use of "#ifdef" and "#ifndef" versus + "#if defined()" and "if !defined()" where possible. +- Added PNG_NO_HANDLE_AS_UNKNOWN in the PNG_LEGACY_SUPPORTED block of +- pngconf.h, and moved the various unknown chunk macro definitions +- outside of the PNG_READ|WRITE_ANCILLARY_CHUNK_SUPPORTED blocks. + +-version 1.0.46 [June 18, 2009] +- Removed some editing cruft from scripts/libpng.pc.in and some makefiles. ++Version 1.4.0beta64 [June 24, 2009] ++ Eliminated PNG_LEGACY_SUPPORTED code. ++ Moved the various unknown chunk macro definitions outside of the ++ PNG_READ|WRITE_ANCILLARY_CHUNK_SUPPORTED blocks. + +-version 1.2.38rc01 [June 24, 2009] +- No changes. ++Version 1.4.0beta65 [June 26, 2009] ++ Added a reference to the libpng license in each file. + +-version 1.2.38rc02 [June 29, 2009] +- Added a reference to the libpng license in each source file. ++Version 1.4.0beta66 [June 27, 2009] ++ Refer to the libpng license instead of the libpng license in each file. + +-version 1.2.38rc03 [July 11, 2009] +- Revised references to the libpng license in pngconf.h and contrib/visupng +- source files. +- Rebuilt configure scripts with autoconf-2.63. ++Version 1.4.0beta67 [July 6, 2009] ++ Relocated INVERT_ALPHA within png_read_png() and png_write_png(). ++ Added high-level API transform PNG_TRANSFORM_GRAY_TO_RGB. ++ Added an "xcode" project to the projects directory (Alam Arias). + +-version 1.0.47 and 1.2.38 [July 16, 2009] +- No changes. ++Version 1.4.0beta68 [July 19, 2009] ++ Avoid some tests in filter selection in pngwutil.c + +-version 1.2.39beta01 [July 25, 2009] ++Version 1.4.0beta69 [July 25, 2009] ++ Simplified the new filter-selection test. This runs faster in the ++ common "PNG_ALL_FILTERS" and PNG_FILTER_NONE cases. ++ Removed extraneous declaration from the new call to png_read_gray_to_rgb() ++ (bug introduced in libpng-1.4.0beta67). ++ Fixed up xcode project (Alam Arias) + Added a prototype for png_64bit_product() in png.c + +-version 1.2.39beta02 [July 27, 2009] ++Version 1.4.0beta70 [July 27, 2009] + Avoid a possible NULL dereference in debug build, in png_set_text_2(). + (bug introduced in libpng-0.95, discovered by Evan Rouault) + +-version 1.2.39beta03 [July 29, 2009] +- Relocated new png_64_bit_product() prototype into png.h +- Expanded the information about prototypes in the libpng style section of +- the documentation. ++Version 1.4.0beta71 [July 29, 2009] + Rebuilt configure scripts with autoconf-2.64. + +-version 1.2.39beta04 [August 1, 2009] +- Replaced *.tar.lzma with *.txz in distribution. Get the xz codec ++Version 1.4.0beta72 [August 1, 2009] ++ Replaced *.tar.lzma with *.tar.xz in distribution. Get the xz codec + from . + +-version 1.2.39beta05 [August 1, 2009] ++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.2.39c01 [August 6, 2009] +- No changes. ++Version 1.4.0beta74 [August 8, 2009] ++ Changed png_ptr and info_ptr member "trans" to "trans_alpha". + +-version 1.2.39 and 1.0.48 [August 13, 2009] +- No changes. +- +-version 1.2.40beta01 [August 20, 2009] ++Version 1.4.0beta75 [August 21, 2009] + Removed an extra png_debug() recently added to png_write_find_filter(). + Fixed incorrect #ifdef in pngset.c regarding unknown chunk support. + +-version 1.2.40rc01 [September 2, 2009] +- Various bugfixes and improvements to CMakeLists.txt (Philip Lowman) ++Version 1.4.0beta76 [August 22, 2009] ++ Moved an incorrectly located test in png_read_row() in pngread.c + +-version 1.2.40 and 1.0.49 [September 2, 2009] +- No changes. ++Version 1.4.0beta77 [August 27, 2009] ++ Removed lpXYZ.tar.bz2 (with CRLF), KNOWNBUG, libpng-x.y.z-KNOWNBUG.txt, ++ and the "noconfig" files from the distribution. ++ Moved CMakeLists.txt from scripts into the main libpng directory. ++ Various bugfixes and improvements to CMakeLists.txt (Philip Lowman) + +-version 1.0.50 [September 10, 2009] +- Removed some editing cruft from pngset.c and pngwutil.c. ++Version 1.4.0beta78 [August 31, 2009] ++ Converted all PNG_NO_* tests to PNG_*_SUPPORTED everywhere except pngconf.h ++ Eliminated PNG_NO_FREE_ME and PNG_FREE_ME_SUPPORTED macros. ++ Use png_malloc plus a loop instead of png_calloc() to initialize ++ row_pointers in png_read_png(). ++ ++Version 1.4.0beta79 [September 1, 2009] ++ Eliminated PNG_GLOBAL_ARRAYS and PNG_LOCAL_ARRAYS; always use local arrays. ++ Eliminated PNG_CALLOC_SUPPORTED macro and always provide png_calloc(). ++ ++Version 1.4.0beta80 [September 17, 2009] ++ Removed scripts/libpng.icc ++ Changed typecast of filler from png_byte to png_uint_16 in png_set_filler(). ++ (Dennis Gustafsson) ++ Fixed typo introduced in beta78 in pngtest.c ("#if def " should be "#ifdef ") ++ ++Version 1.4.0beta81 [September 23, 2009] ++ Eliminated unused PNG_FLAG_FREE_* defines from pngpriv.h ++ Expanded TAB characters in pngrtran.c ++ Removed PNG_CONST from all "PNG_CONST PNG_CHNK" declarations to avoid ++ compiler complaints about doubly declaring things "const". ++ Changed all "#if [!]defined(X)" to "if[n]def X" where possible. ++ Eliminated unused png_ptr->row_buf_size + +-version 1.2.41beta01 [September 25, 2009] ++Version 1.4.0beta82 [September 25, 2009] + Moved redundant IHDR checking into new png_check_IHDR() in png.c + and report all errors found in the IHDR data. + Eliminated useless call to png_check_cHRM() from pngset.c +- Expanded TAB characters in pngrtran.c + +-version 1.2.41beta02 [September 30, 2009] +- Revised png_check_IHDR(). ++Version 1.4.0beta83 [September 25, 2009] ++ Revised png_check_IHDR() to eliminate bogus complaint about filter_type. ++ ++Version 1.4.0beta84 [September 30, 2009] ++ Fixed some inconsistent indentation in pngconf.h ++ Revised png_check_IHDR() to add a test for width variable less than 32-bit. + +-version 1.2.41beta03 [October 1, 2009] ++Version 1.4.0beta85 [October 1, 2009] + Revised png_check_IHDR() again, to check info_ptr members instead of + the contents of the returned parameters. + +-version 1.2.41beta04 [October 7, 2009] +- Added "xcode" project similar one already in libpng-1.4.0beta (Alam Arias). +- Ported some cosmetic changes from libpng-1.4.0beta86. ++Version 1.4.0beta86 [October 9, 2009] ++ Updated the "xcode" project (Alam Arias). + Eliminated a shadowed declaration of "pp" in png_handle_sPLT(). + +-version 1.2.41beta05 [October 17, 2009] +- Revised pngconf.h to make it easier to enable iTXt support. From libpng +- version 1.2.9 through 1.2.40, defining PNG_iTXt_SUPPORTED did not work +- as expected. +- Ported some cosmetic changes from libpng-1.4.0beta87, changing +- many "#if defined(x)" to "#ifdef x". ++Version 1.4.0rc01 [October 19, 2009] ++ Trivial cosmetic changes. + +-version 1.2.41beta06 [October 18, 2009] +- Restored PNG_USE_LOCAL_ARRAYS code in pngread.c that was inadvertently +- deleted in libpng-1.2.41beta05. +- Converted all PNG_NO_* tests to PNG_*_SUPPORTED everywhere except pngconf.h +- as in libpng-1.4.0beta78 and later. ++Version 1.4.0beta87 [October 30, 2009] ++ Moved version 1.4.0 back into beta. + +-version 1.2.41beta07 [October 21, 2009] +- Ported some cosmetic changes from libpng-1.4.0rc01, changing +- many "#if defined(x)" to "#ifdef x" in png.h and pngconf.h. ++Version 1.4.0beta88 [October 30, 2009] ++ Revised libpng*.txt section about differences between 1.2.x and 1.4.0 ++ because most of the new features have now been ported back to 1.2.41 + +-version 1.2.41beta08 [October 30, 2009] +- Ported from libpng-1.4.0rc01: png_calloc(), png_get_io_chunk_name(), +- png_get_io_state(), png_set_user_cache_max(), png_get_user_cache_max(), +- png_set_premultiply_alpha, and png_do_read_premultiply_alpha(). +- Relocated png_do_chop() ahead of building gamma tables in pngrtran.c +- This avoids building 16-bit gamma tables unnecessarily. +- +-version 1.2.41beta09 [November 1, 2009] +- Removed a harmless extra png_set_invert_alpha() from pngwrite.c ++Version 1.4.0beta89 [November 1, 2009] + More bugfixes and improvements to CMakeLists.txt (Philip Lowman) +- Moved CMakeLists.txt from scripts into the main libpng directory. ++ Removed a harmless extra png_set_invert_alpha() from pngwrite.c + Apply png_user_chunk_cache_max within png_decompress_chunk(). + Merged libpng-1.2.41.txt with libpng-1.4.0.txt where appropriate. + +-version 1.2.41beta10 [November 1, 2009] +- Enabled iTXt support by default. To ensure binary compatibility with +- previous versions, the "lang" and "lang_key" members will be assumed +- to be omitted from previous versions unless the current libpng +- version was built with PNG_iTXt_SUPPORTED (which is otherwise no +- longer necessary to gain iTXt support), as a signal that the user has +- been building previous versions with PNG_iTXt_SUPPORTED as well. +- +-version 1.2.41beta11 [November 2, 2009] +- Store user's user_png_ver in new png_ptr->user_png_ver element. +- Revised iTXt support. To ensure binary compatibility with +- previous versions, the "lang" and "lang_key" members will be assumed +- to be omitted from versions prior to 1.2.41beta11 whenever there is a +- library mismatch. +- +-version 1.2.41beta12 [November 2, 2009] +- Free png_ptr->user_png_ver when destroying png_ptr. +- +-version 1.2.41beta13 [November 3, 2009] ++Version 1.4.0beta90 [November 2, 2009] ++ Removed all remaining WIN32_WCE #ifdefs except those involving the ++ time.h "tm" structure ++ ++Version 1.4.0beta91 [November 3, 2009] + Updated scripts/pngw32.def and projects/wince/png32ce.def + Copied projects/wince/png32ce.def to the scripts directory. + Added scripts/makefile.wce + Patched ltmain.sh for wince support. + Added PNG_CONVERT_tIME_SUPPORTED macro. + +-version 1.2.41beta14 [November 8, 2009] +- versions 1.2.41beta05 through 1.2.41beta13 were abandoned. +- The 1.0.x/1.2.x series will only receive security updates from now on. ++Version 1.4.0beta92 [November 4, 2009] + Make inclusion of time.h in pngconf.h depend on PNG_CONVERT_tIME_SUPPORTED + Make #define PNG_CONVERT_tIME_SUPPORTED depend on PNG_WRITE_tIME_SUPPORTED +- Reverted iTXt compatibility stuff from 1.2.41beta05, 1.2.41beta11, and +- 1.2.41beta12. +- Reverted IOSTATE feature, user_cache_max, and premultiply_alpha features +- from 1.2.41beta08. +- Retained png_calloc() from 1.2.41beta08 but as a non-exported function, +- and removed reference to png_calloc from scripts/*.def +- +-version 1.2.41beta15 [November 8, 2009] ++ Revised libpng*.txt to describe differences from 1.2.40 to 1.4.0 (instead ++ of differences from 1.2.41 to 1.4.0) ++ ++Version 1.4.0beta93 [November 7, 2009] + Added PNG_DEPSTRUCT, PNG_DEPRECATED, PNG_USE_RESULT, PNG_NORETURN, and + PNG_ALLOCATED macros to detect deprecated direct access to the + png_struct or info_struct members and other deprecated usage in +@@ -2568,147 +2475,3622 @@ version 1.2.41beta15 [November 8, 2009] + functions while building libpng. They need to be tested, especially + those using compilers other than gcc. + Updated projects/visualc6 and visualc71 with "/d PNG_CONFIGURE_LIBPNG". +- +-version 1.2.41beta16 [November 9, 2009] ++ They should work but still need to be updated to remove ++ references to pnggccrd.c or pngvcrd.c and ASM building. ++ Added README.txt to the beos, cbuilder5, netware, and xcode projects warning ++ that they need to be updated, to remove references to pnggccrd.c and ++ pngvcrd.c and to depend on pngpriv.h + Removed three direct references to read_info_ptr members in pngtest.c + that were detected by the new PNG_DEPSTRUCT macro. ++ Moved the png_debug macro definitions and the png_read_destroy(), ++ png_write_destroy() and png_far_to_near() prototypes from png.h ++ to pngpriv.h (John Bowler) ++ Moved the synopsis lines for png_read_destroy(), png_write_destroy() ++ png_debug(), png_debug1(), and png_debug2() from libpng.3 to libpngpf.3. ++ ++Version 1.4.0beta94 [November 9, 2009] ++ Removed the obsolete, unused pnggccrd.c and pngvcrd.c files. ++ Updated CMakeLists.txt to add "-DPNG_CONFIGURE_LIBPNG" to the definitions. ++ Removed dependency of pngtest.o on pngpriv.h in the makefiles. + Only #define PNG_DEPSTRUCT, etc. in pngconf.h if not already defined. + +-version 1.2.41beta17 [November 10, 2009] +- Updated CMakeLists.txt to add "-DPNG_CONFIGURE_LIBPNG" to the definitions. +- Marked deprecated function prototypes with PNG_DEPRECATED. +- Marked memory allocation function prototypes with PNG_ALLOCATED. ++Version 1.4.0beta95 [November 10, 2009] ++ Changed png_check_sig() to !png_sig_cmp() in contrib programs. ++ Added -DPNG_CONFIGURE_LIBPNG to contrib/pngminm/*/makefile + Changed png_check_sig() to !png_sig_cmp() in contrib programs. + Corrected the png_get_IHDR() call in contrib/gregbook/readpng2.c +- Added "-DPNG_CONFIGURE_LIBPNG" to the contrib/pngminum makefiles. ++ Changed pngminim/*/gather.sh to stop trying to remove pnggccrd.c and pngvcrd.c ++ Added dependency on pngpriv.h in contrib/pngminim/*/makefile + +-version 1.2.41beta18 [November 11, 2009] ++Version 1.4.0beta96 [November 12, 2009] + Renamed scripts/makefile.wce to scripts/makefile.cegcc +- Marked nonexported functions with PNG_PRIVATE macro. +- +-version 1.2.41rc01 and 1.0.51rc01 [November 18, 2009] +- Revised scripts/*.def to reflect functions actually exported by libpng. +- Updated the copyright year in scripts/pngw32.rc from 2004 to 2009. ++ Revised Makefile.am to use libpng.sys while building libpng.so ++ so that only PNG_EXPORT functions are exported. ++ Removed the deprecated png_check_sig() function/macro. ++ Removed recently removed function names from scripts/*.def ++ Revised pngtest.png to put chunks in the same order written by pngtest ++ (evidently the same change made in libpng-1.0beta54 was lost). ++ Added PNG_PRIVATE macro definition in pngconf.h for possible future use. ++ ++Version 1.4.0beta97 [November 13, 2009] ++ Restored pngtest.png to the libpng-1.4.0beta7 version. ++ Removed projects/beos and netware.txt; no one seems to be supporting them. ++ Revised Makefile.in ++ ++Version 1.4.0beta98 [November 13, 2009] ++ Added the "xcode" project to zip distributions, ++ Fixed a typo in scripts/pngwin.def introduced in beta97. ++ ++Version 1.4.0beta99 [November 14, 2009] ++ Moved libpng-config.in and libpng.pc-configure.in out of the scripts ++ directory, to libpng-config.in and libpng-pc.in, respectively, and ++ modified Makefile.am and configure.ac accordingly. Now "configure" ++ needs nothing from the "scripts" directory. ++ Avoid redefining PNG_CONST in pngconf.h ++ ++Version 1.4.0beta100 [November 14, 2009] ++ Removed ASM builds from projects/visualc6 and projects/visualc71 ++ Removed scripts/makefile.nommx and makefile.vcawin32 ++ Revised CMakeLists.txt to account for new location of libpng-config.in ++ and libpng-pc.in ++ Updated INSTALL to reflect removal and relocation of files. ++ ++Version 1.4.0beta101 [November 14, 2009] ++ Restored the binary files (*.jpg, *.png, some project files) that were ++ accidentally deleted from the zip and 7z distributions when the xcode ++ project was added. ++ ++Version 1.4.0beta102 [November 18, 2009] ++ Added libpng-config.in and libpng-pc.in to the zip and 7z distributions. ++ Fixed a typo in projects/visualc6/pngtest.dsp, introduced in beta100. + Moved descriptions of makefiles and other scripts out of INSTALL into + scripts/README.txt +- +-version 1.2.41rc02 [November 22, 2009] +- Rebuilt the configure scripts with autoconf-2.65 +- +-version 1.2.41rc03 [November 25, 2009] +- Disabled the new pedantic warnings about deprecated function use +- and deprecated structure access unless the user defines +- PNG_PEDANTIC_WARNINGS. ++ Updated the copyright year in scripts/pngwin.rc from 2006 to 2009. ++ ++Version 1.4.0beta103 [November 21, 2009] ++ Removed obsolete comments about ASM from projects/visualc71/README_zlib.txt ++ Align row_buf on 16-byte boundary in memory. ++ Restored the PNG_WRITE_FLUSH_AFTER_IEND_SUPPORTED guard around the call ++ to png_flush() after png_write_IEND(). See 1.4.0beta32, 1.4.0beta50 ++ changes above and 1.2.30, 1.2.30rc01 and rc03 in 1.2.41 CHANGES. Someone ++ needs this feature. ++ Make the 'png_jmpbuf' macro expand to a call that records the correct ++ longjmp function as well as returning a pointer to the setjmp ++ jmp_buf buffer, and marked direct access to jmpbuf 'deprecated'. ++ (John Bowler) ++ ++Version 1.4.0beta104 [November 22, 2009] ++ Removed png_longjmp_ptr from scripts/*.def and libpng.3 ++ Rebuilt configure scripts with autoconf-2.65 ++ ++Version 1.4.0beta105 [November 25, 2009] ++ Use fast integer PNG_DIVIDE_BY_255() or PNG_DIVIDE_BY_65535() ++ to accomplish alpha premultiplication when ++ PNG_READ_COMPOSITE_NODIV_SUPPORTED is defined. ++ Changed "/255" to "/255.0" in background calculations to make it clear ++ that the 255 is used as a double. ++ ++Version 1.4.0beta106 [November 27, 2009] ++ Removed premultiplied alpha feature. ++ ++Version 1.4.0beta107 [December 4, 2009] ++ Updated README + Added "#define PNG_NO_PEDANTIC_WARNINGS" in the libpng source files. + Removed "-DPNG_CONFIGURE_LIBPNG" from the makefiles and projects. +- +-version 1.2.41 and 1.0.51 [December 3, 2009] +- Updated the list of files and made some cosmetic changes in README. +- +-version 1.2.42beta01 [December 4, 2009] +- Removed "#define PNG_NO_ERROR_NUMBERS" that was inadvertently added +- to pngconf.h in version 1.2.41. + Revised scripts/makefile.netbsd, makefile.openbsd, and makefile.sco + to put png.h and pngconf.h in $prefix/include, like the other scripts, + instead of in $prefix/include/libpng. Also revised makefile.sco +- to put them in $prefix/include/libpng12 instead of in +- $prefix/include/libpng/libpng12. +- Removed leftover "-DPNG_CONFIGURE_LIBPNG" from scripts/makefile.darwin ++ to put them in $prefix/include/libpng15 instead of in ++ $prefix/include/libpng/libpng15. + +-version 1.2.42beta02 [December 11, 2009] ++Version 1.4.0beta108 [December 11, 2009] + Removed leftover "-DPNG_CONFIGURE_LIBPNG" from contrib/pngminim/*/makefile +- Relocated png_do_chop() to its original position in pngrtran.c. The ++ Relocated png_do_chop() to its original position in pngrtran.c; the + change in version 1.2.41beta08 caused transparency to be handled wrong + in some 16-bit datastreams (Yusaku Sugai). + +-version 1.2.42rc01 [December 17, 2009] +- No changes. ++Version 1.4.0beta109 [December 13, 2009] ++ Added "bit_depth" parameter to the private png_build_gamma_table() function. ++ Pass bit_depth=8 to png_build_gamma_table() when bit_depth is 16 but the ++ PNG_16_TO_8 transform has been set, to avoid unnecessary build of 16-bit ++ tables. ++ ++Version 1.4.0rc02 [December 20, 2009] ++ Declared png_cleanup_needed "volatile" in pngread.c and pngwrite.c + +-version 1.2.42rc02 [December 22, 2009] ++Version 1.4.0rc03 [December 22, 2009] + Renamed libpng-pc.in back to libpng.pc.in and revised CMakeLists.txt +- (revising changes made in 1.2.41beta17 and 1.2.41rc01) ++ (revising the change in 1.4.0beta99) + +-version 1.2.42rc03 [December 25, 2009] ++Version 1.4.0rc04 [December 25, 2009] + Swapped PNG_UNKNOWN_CHUNKS_SUPPORTED and PNG_HANDLE_AS_UNKNOWN_SUPPORTED + in pngset.c to be consistent with other changes in version 1.2.38. + +-version 1.2.42rc04 [January 1, 2010] +- Marked png_memcpy_check() and png_memset_check() PNG_DEPRECATED. +- Updated copyright year. ++Version 1.4.0rc05 [December 25, 2009] ++ Changed "libpng-pc.in" to "libpng.pc.in" in configure.ac, configure, and ++ Makefile.in to be consistent with changes in libpng-1.4.0rc03 ++ ++Version 1.4.0rc06 [December 29, 2009] ++ Reverted the gamma_table changes from libpng-1.4.0beta109. ++ Fixed some indentation errors. ++ ++Version 1.4.0rc07 [January 1, 2010] ++ Revised libpng*.txt and libpng.3 about 1.2.x->1.4.x differences. ++ Use png_calloc() instead of png_malloc(); png_memset() in pngrutil.c ++ Update copyright year to 2010. + +-version 1.2.42rc05 [January 2, 2010] ++Version 1.4.0rc08 [January 2, 2010] + Avoid deprecated references to png_ptr-io_ptr and png_ptr->error_ptr + in pngtest.c + +-version 1.2.42 and 1.0.52 [January 3, 2010] ++Version 1.4.0 [January 3, 2010] + No changes. + +-version 1.2.43beta01 [January 27, 2010] ++Version 1.4.1beta01 [January 8, 2010] + Updated CMakeLists.txt for consistent indentation and to avoid an + unclosed if-statement warning (Philip Lowman). +- Removed "#ifdef PNG_1_0_X / #endif" surrounding +- PNG_READ_16_TO_8_SUPPORTED and PNG_READ_GRAY_TO_RGB_SUPPORTED +- in pngconf.h. These were added in libpng-1.2.41beta08 and libpng-1.0.51, +- which introduced a binary incompatibility with libpng-1.0.50. +- Backported new png_decompress_chunk() algorithm from libpng-1.4.1. +- +-version 1.2.43beta02 [February 1, 2010] +- Backported two-pass png_decompress_chunk() algorithm from libpng-1.4.1. +- +-version 1.2.43beta03 [February 6, 2010] +- Backported fast png_push_save_buffer() algorithm from libpng-1.4.1. +- Backported some cosmetic changes from libpng-1.4.1. +- +-version 1.2.43beta04 [February 8, 2010] +- Reverted recent changes to png_push_save-buffer(). +- Removed PNGAPI declaration of png_calloc() and png_write_sig() in +- 1ibpng-1.2.X, introduced by mistake in libpng-1.2.41. +- Return allocated "old_buffer" in png_push_save_buffer() before png_error() +- to avoid a potential memory leak. +- +-version 1.2.43beta05 [February 8, 2010] +- Ported rewritten png_decompress_chunk() by John Bowler from libpng-1.4.1. +- +-version 1.0.53rc01 and 1.2.43rc01 [February 18, 2010] ++ Revised Makefile.am and Makefile.in to remove references to Y2KINFO, ++ KNOWNBUG, and libpng.la (Robert Schwebel). ++ Revised the makefiles to install the same files and symbolic ++ links as configure, except for libpng.la and libpng14.la. ++ Make png_set|get_compression_buffer_size() available even when ++ PNG_WRITE_SUPPORTED is not enabled. ++ Revised Makefile.am and Makefile.in to simplify their maintenance. ++ Revised scripts/makefile.linux to install a link to libpng14.so.14.1 ++ ++Version 1.4.1beta02 [January 9, 2010] ++ Revised the rest of the makefiles to install a link to libpng14.so.14.1 ++ ++Version 1.4.1beta03 [January 10, 2010] ++ Removed png_set_premultiply_alpha() from scripts/*.def ++ ++Version 1.4.1rc01 [January 16, 2010] + No changes. + +-version 1.0.53rc02 and 1.2.43rc02 [February 19, 2010] +- Define _ALL_SOURCE in configure.ac, makefile.aix, and CMakeLists.txt +- when using AIX compiler. +- +-version 1.0.53 and 1.2.43 [February 25, 2010] ++Version 1.4.1beta04 [January 23, 2010] ++ Revised png_decompress_chunk() to improve speed and memory usage when ++ decoding large chunks. ++ Added png_set|get_chunk_malloc_max() functions. ++ ++Version 1.4.1beta05 [January 26, 2010] ++ Relocated "int k" declaration in pngtest.c to minimize its scope. ++ ++Version 1.4.1beta06 [January 28, 2010] ++ Revised png_decompress_chunk() to use a two-pass method suggested by ++ John Bowler. ++ ++Version 1.4.1beta07 [February 6, 2010] ++ Folded some long lines in the source files. ++ Added defineable PNG_USER_CHUNK_CACHE_MAX, PNG_USER_CHUNK_MALLOC_MAX, ++ and a PNG_USER_LIMITS_SUPPORTED flag. ++ Eliminated use of png_ptr->irowbytes and reused the slot in png_ptr as ++ png_ptr->png_user_chunk_malloc_max. ++ Revised png_push_save_buffer() to do fewer but larger png_malloc() calls. ++ ++Version 1.4.1beta08 [February 6, 2010] ++ Minor cleanup and updating of dates and copyright year. ++ ++Version 1.5.0beta01 [February 7, 2010] ++ Moved declaration of png_struct into private pngstruct.h and png_info ++ into pnginfo.h ++ ++Version 1.4.1beta09 and 1.5.0beta02 [February 7, 2010] ++ Reverted to original png_push_save_buffer() code. ++ ++Version 1.4.1beta10 and 1.5.0beta03 [February 8, 2010] ++ Return allocated "old_buffer" in png_push_save_buffer() before ++ calling png_error(), to avoid a potential memory leak. ++ Updated configure script to use SO number 15. ++ ++Version 1.5.0beta04 [February 9, 2010] ++ Removed malformed "incomplete struct declaration" of png_info from png.h ++ ++Version 1.5.0beta05 [February 12, 2010] ++ Removed PNG_DEPSTRUCT markup in pngstruct.h and pnginfo.h, and undid the ++ linewrapping that it entailed. ++ Revised comments in pngstruct.h and pnginfo.h and added pointers to ++ the libpng license. ++ Changed PNG_INTERNAL to PNG_EXPOSE_INTERNAL_STRUCTURES ++ Removed the cbuilder5 project, which has not been updated to 1.4.0. ++ ++Version 1.4.1beta12 and 1.5.0beta06 [February 14, 2010] ++ Fixed type declaration of png_get_chunk_malloc_max() in pngget.c (Daisuke ++ Nishikawa) ++ ++Version 1.5.0beta07 [omitted] ++ ++Version 1.5.0beta08 [February 19, 2010] ++ Changed #ifdef PNG_NO_STDIO_SUPPORTED to #ifdef PNG_NO_CONSOLE_IO_SUPPORTED ++ wherever png_snprintf() is used to construct error and warning messages. ++ Noted in scripts/makefile.mingw that it expects to be run under MSYS. ++ Removed obsolete unused MMX-querying support from contrib/gregbook ++ Added exported png_longjmp() function. ++ Removed the AIX redefinition of jmpbuf in png.h ++ Added -D_ALLSOURCE in configure.ac, makefile.aix, and CMakeLists.txt ++ when building on AIX. ++ ++Version 1.5.0beta09 [February 19, 2010] ++ Removed -D_ALLSOURCE from configure.ac, makefile.aix, and CMakeLists.txt. ++ Changed the name of png_ptr->jmpbuf to png_ptr->png_jmpbuf in pngstruct.h ++ ++Version 1.5.0beta10 [February 25, 2010] + Removed unused gzio.c from contrib/pngminim gather and makefile scripts +- +-version 1.2.44beta01 [June 18, 2010] ++ Removed replacement error handlers from contrib/gregbook. Because of ++ the new png_longjmp() function they are no longer needed. ++ ++Version 1.5.0beta11 [March 6, 2010] ++ Removed checking for already-included setjmp.h from pngconf.h ++ Fixed inconsistent indentations and made numerous cosmetic changes. ++ Revised the "SEE ALSO" style of libpng.3, libpngpf.3, and png.5 ++ ++Version 1.5.0beta12 [March 9, 2010] ++ Moved "#include png.h" inside pngpriv.h and removed "#include png.h" from ++ the source files, along with "#define PNG_EXPOSE_INTERNAL_STRUCTURES" ++ and "#define PNG_NO_PEDANTIC_WARNINGS" (John Bowler). ++ Created new pngdebug.h and moved debug definitions there. ++ ++Version 1.5.0beta13 [March 10, 2010] ++ Protect pngstruct.h, pnginfo.h, and pngdebug.h from being included twice. ++ Revise the "#ifdef" blocks in png_inflate() so it will compile when neither ++ PNG_USER_CHUNK_MALLOC_MAX nor PNG_SET_CHUNK_MALLOC_LIMIT_SUPPORTED ++ is defined. ++ Removed unused png_measure_compressed_chunk() from pngpriv.h and libpngpf.3 ++ Moved the 'config.h' support from pngconf.h to pngpriv.h ++ Removed PNGAPI from the png_longjmp_ptr typedef. ++ Eliminated dependence of pngtest.c on the private pngdebug.h file. ++ Make all png_debug macros into *unterminated* statements or ++ expressions (i.e. a trailing ';' must always be added) and correct ++ the format statements in various png_debug messages. ++ ++Version 1.5.0beta14 [March 14, 2010] ++ Removed direct access to png_ptr->io_ptr from the Windows code in pngtest.c ++ Revised Makefile.am to account for recent additions and replacements. ++ Corrected CE and OS/2 DEF files (scripts/png*def) for symbols removed and ++ added ordinal numbers to the Windows DEF file and corrected the duplicated ++ ordinal numbers on CE symbols that are commented out. ++ Added back in export symbols that can be present in the Windows build but ++ are disabled by default. ++ PNG_EXPORT changed to include an 'ordinal' field for DEF file generation. ++ PNG_CALLBACK added to make callback definitions uniform. PNGAPI split ++ into PNGCAPI (base C form), PNGAPI (exports) and PNGCBAPI (callbacks), ++ and appropriate changes made to all files. Cygwin builds re-hinged to ++ allow procedure call standard changes and to remove the need for the DEF ++ file (fixes build on Cygwin). ++ Enabled 'attribute' warnings that are relevant to library APIs and callbacks. ++ Changed rules for generation of the various symbol files and added a new ++ rule for a DEF file (which is also added to the distribution). ++ Updated the symbol file generation to stop it adding spurious spaces ++ to EOL (coming from preprocessor macro expansion). Added a facility ++ to join tokens in the output and rewrite *.dfn to use this. ++ Eliminated scripts/*.def in favor of libpng.def; updated projects/visualc71 ++ and removed scripts/makefile.cygwin. ++ Made PNG_BUILD_DLL safe: it can be set whenever a DLL is being built. ++ Removed the include of sys/types.h - apparently unnecessary now on the ++ platforms on which it happened (all but Mac OS and RISC OS). ++ Moved the Mac OS test into pngpriv.h (the only place it is used.) ++ ++Version 1.5.0beta15 [March 17, 2010] ++ Added symbols.chk target to Makefile.am to validate the symbols in png.h ++ against the new DEF file scripts/symbols.def. ++ Changed the default DEF file back to pngwin.def. ++ Removed makefile.mingw. ++ Eliminated PNG_NO_EXTERN and PNG_ALL_EXTERN ++ ++Version 1.5.0beta16 [April 1, 2010] ++ Make png_text_struct independent of PNG_iTXt_SUPPORTED, so that ++ fields are initialized in all configurations. The READ/WRITE ++ macros (PNG_(READ|WRITE)_iTXt_SUPPORTED) still function as ++ before to disable code to actually read or write iTXt chunks ++ and iTXt_SUPPORTED can be used to detect presence of either ++ read or write support (but it is probably better to check for ++ the one actually required - read or write.) ++ Combined multiple png_warning() calls for a single error. ++ Restored the macro definition of png_check_sig(). ++ ++Version 1.5.0beta17 [April 17, 2010] ++ Added some "(long)" typecasts to printf calls in png_handle_cHRM(). ++ Documented the fact that png_set_dither() was disabled since libpng-1.4.0. ++ Reenabled png_set_dither() but renamed it to png_set_quantize() to reflect ++ more accurately what it actually does. At the same time, renamed ++ the PNG_DITHER_[RED,GREEN_BLUE]_BITS macros to ++ PNG_QUANTIZE_[RED,GREEN,BLUE]_BITS. ++ Added some "(long)" typecasts to printf calls in png_handle_cHRM(). ++ Freeze build-time only configuration in the build. ++ In all prior versions of libpng most configuration options ++ controlled by compiler #defines had to be repeated by the ++ application code that used libpng. This patch changes this ++ so that compilation options that can only be changed at build ++ time are frozen in the build. Options that are compiler ++ dependent (and those that are system dependent) are evaluated ++ each time - pngconf.h holds these. Options that can be changed ++ per-file in the application are in png.h. Frozen options are ++ in the new installed header file pnglibconf.h (John Bowler) ++ Removed the xcode project because it has not been updated to work ++ with libpng-1.5.0. ++ Removed the ability to include optional pngusr.h ++ ++Version 1.5.0beta18 [April 17, 2010] ++ Restored the ability to include optional pngusr.h ++ Moved replacements for png_error() and png_warning() from the ++ contrib/pngminim project to pngerror.c, for use when warnings or ++ errors are disabled via PNG_NO_WARN or PNG_NO_ERROR_TEXT, to avoid ++ storing unneeded error/warning text. ++ Updated contrib/pngminim project to work with the new pnglibconf.h ++ Added some PNG_NO_* defines to contrib/pngminim/*/pngusr.h to save space. ++ ++Version 1.5.0beta19 [April 24, 2010] ++ Added PNG_{READ,WRITE}_INT_FUNCTIONS_SUPPORTED. This allows the functions ++ to read and write ints to be disabled independently of PNG_USE_READ_MACROS, ++ which allows libpng to be built with the functions even though the default ++ is to use the macros - this allows applications to choose at app build ++ time whether or not to use macros (previously impossible because the ++ functions weren't in the default build.) ++ Changed Windows calling convention back to __cdecl for API functions. ++ For Windows/x86 platforms only: ++ __stdcall is no longer needed for Visual Basic, so libpng-1.5.0 uses ++ __cdecl throughout (both API functions and callbacks) on Windows/x86 ++ platforms. ++ Replaced visualc6 and visualc71 projects with new vstudio project ++ Relaxed the overly-restrictive permissions of some files. ++ ++Version 1.5.0beta20 [April 24, 2010] ++ Relaxed more overly-restrictive permissions of some files. ++ ++Version 1.5.0beta21 [April 27, 2010] ++ Removed some unwanted binary bytes and changed CRLF to NEWLINE in the new ++ vstudio project files, and some trivial editing of some files in the ++ scripts directory. ++ Set PNG_NO_READ_BGR, PNG_NO_IO_STATE, and PNG_NO_TIME_RFC1123 in ++ contrib/pngminim/decoder/pngusr.h to make a smaller decoder application. ++ ++Version 1.5.0beta22 [April 28, 2010] ++ Fixed dependencies of GET_INT_32 - it does not require READ_INT_FUNCTIONS ++ because it has a macro equivalent. ++ Improved the options.awk script; added an "everything off" option. ++ Revised contrib/pngminim to use the "everything off" option in pngusr.dfa. ++ ++Version 1.5.0beta23 [April 29, 2010] ++ Corrected PNG_REMOVED macro to take five arguments. ++ The macro was documented with two arguments (name,ordinal), however ++ the symbol checking .dfn files assumed five arguments. The five ++ argument form seems more useful so it is changed to that. ++ Corrected PNG_UNKNOWN_CHUNKS_SUPPORTED to PNG_HANDLE_AS_UNKNOWN_SUPPORTED ++ in gregbook/readpng2.c ++ Corrected protection of png_get_user_transform_ptr. The API declaration in ++ png.h is removed if both READ and WRITE USER_TRANSFORM are turned off ++ but was left defined in pngtrans.c ++ Added logunsupported=1 to cause pnglibconf.h to document disabled options. ++ This makes the installed pnglibconf.h more readable but causes no ++ other change. The intention is that users of libpng will find it ++ easier to understand if an API they need is missing. ++ Include png_reset_zstream() in png.c only when PNG_READ_SUPPORTED is defined. ++ Removed dummy_inflate.c from contrib/pngminim/encoder ++ Removed contrib/pngminim/*/gather.sh; gathering is now done in the makefile. ++ ++Version 1.5.0beta24 [May 7, 2010] ++ Use bitwise "&" instead of arithmetic mod in pngrutil.c calculation of the ++ offset of the png_ptr->rowbuf pointer into png_ptr->big_row_buf. ++ Added more blank lines for readability. ++ ++Version 1.5.0beta25 [June 18, 2010] + In pngpread.c: png_push_have_row() add check for new_row > height + Removed the now-redundant check for out-of-bounds new_row from example.c + +-version 1.2.44beta02 [June 19, 2010] ++Version 1.5.0beta26 [June 18, 2010] + In pngpread.c: png_push_process_row() add check for too many rows. +- Removed the now-redundant check for new_row > height in png_push_have_row(). + +-version 1.2.44beta03 [June 20, 2010] +- Rewrote png_process_IDAT_data() to consistently treat extra data as warnings ++Version 1.5.0beta27 [June 18, 2010] ++ Removed the check added in beta25 as it is now redundant. ++ ++Version 1.5.0beta28 [June 20, 2010] ++ Rewrote png_process_IDAT_data to consistently treat extra data as warnings + and handle end conditions more cleanly. +- Removed the new (beta02) check in png_push_process_row(). ++ Removed the new (beta26) check in png_push_process_row(). + +-version 1.2.44rc01 [June 21, 2010] +- Revised some comments in png_process_IDAT_data(). ++Version 1.5.0beta29 [June 21, 2010] ++ Revised scripts/options.awk to work on Sunos (but still doesn't work) ++ Added comment to options.awk and contrib/pngminim/*/makefile to try nawk. + +-version 1.2.44rc02 [June 22, 2010] ++Version 1.5.0beta30 [June 22, 2010] + Stop memory leak when reading a malformed sCAL chunk. + +-version 1.2.44rc03 [June 23, 2010] +- Revised pngpread.c patch of beta05 to avoid an endless loop. ++Version 1.5.0beta31 [June 26, 2010] ++ Revised pngpread.c patch of beta28 to avoid an endless loop. ++ Removed some trailing blanks. ++ ++Version 1.5.0beta32 [June 26, 2010] ++ Removed leftover scripts/options.patch and scripts/options.rej ++ ++Version 1.5.0beta33 [July 6, 3010] ++ Made FIXED and FLOATING options consistent in the APIs they enable and ++ disable. Corrected scripts/options.awk to handle both command line ++ options and options specified in the .dfa files. ++ Changed char *msg to PNG_CONST char *msg in pngrutil.c ++ Make png_set_sRGB_gAMA_and_cHRM set values using either the fixed or ++ floating point APIs, but not both. ++ Reversed patch to remove error handler when the jmp_buf is stored in the ++ main program structure, not the png_struct. ++ The error handler is needed because the default handler in libpng will ++ always use the jmp_buf in the library control structure; this is never ++ set. The gregbook code is a useful example because, even though it ++ uses setjmp/longjmp, it shows how error handling can be implemented ++ using control mechanisms not directly supported by libpng. The ++ technique will work correctly with mechanisms such as Microsoft ++ Structure Exceptions or C++ exceptions (compiler willing - note that gcc ++ does not by default support interworking of C and C++ error handling.) ++ Reverted changes to call png_longjmp in contrib/gregbook where it is not ++ appropriate. If mainprog->jmpbuf is used by setjmp, then png_longjmp ++ cannot be used. ++ Changed "extern PNG_EXPORT" to "PNG_EXPORT" in png.h (Jan Nijtmans) ++ Changed "extern" to "PNG_EXTERN" in pngpriv.h (except for the 'extern "C" {') ++ ++Version 1.5.0beta34 [July 12, 2010] ++ Put #ifndef PNG_EXTERN, #endif around the define PNG_EXTERN in pngpriv.h ++ ++Version 1.5.0beta35 [July 24, 2010] ++ Removed some newly-added TAB characters. ++ Added -DNO_PNG_SNPRINTF to CFLAGS in scripts/makefile.dj2 ++ Moved the definition of png_snprintf() outside of the enclosing ++ #ifdef blocks in pngconf.h ++ ++Version 1.5.0beta36 [July 29, 2010] ++ Patches by John Bowler: ++ Fixed point APIs are now supported throughout (no missing APIs). ++ Internal fixed point arithmetic support exists for all internal floating ++ point operations. ++ sCAL validates the floating point strings it is passed. ++ Safe, albeit rudimentary, Watcom support is provided by PNG_API_RULE==2 ++ Two new APIs exist to get the number of passes without turning on the ++ PNG_INTERLACE transform and to get the number of rows in the current ++ pass. ++ A new test program, pngvalid.c, validates the gamma code. ++ Errors in the 16-bit gamma correction (overflows) have been corrected. ++ cHRM chunk testing is done consistently (previously the floating point ++ API bypassed it, because the test really didn't work on FP, now the test ++ is performed on the actual values to be stored in the PNG file so it ++ works in the FP case too.) ++ Most floating point APIs now simply call the fixed point APIs after ++ converting the values to the fixed point form used in the PNG file. ++ The standard headers no longer include zlib.h, which is currently only ++ required for pngstruct.h and can therefore be internal. ++ Revised png_get_int_32 to undo the PNG two's complement representation of ++ negative numbers. ++ ++Version 1.5.0beta37 [July 30, 2010] ++ Added a typecast in png_get_int_32() in png.h and pngrutil.h to avoid ++ a compiler warning. ++ Replaced oFFs 0,0 with oFFs -10,20 in pngtest.png ++ ++Version 1.5.0beta38 [July 31, 2010] ++ Implemented remaining "_fixed" functions. ++ Corrected a number of recently introduced warnings mostly resulting from ++ safe but uncast assignments to shorter integers. Also added a zlib ++ VStudio release library project because the latest zlib Official Windows ++ build does not include such a thing. ++ Revised png_get_int_16() to be similar to png_get_int_32(). ++ Restored projects/visualc71. ++ ++Version 1.5.0beta39 [August 2, 2010] ++ VisualC/GCC warning fixes, VisualC build fixes ++ The changes include support for function attributes in VC in addition to ++ those already present in GCC - necessary because without these some ++ warnings are unavoidable. Fixes include signed/unsigned fixes in ++ pngvalid and checks with gcc -Wall -Wextra -Wunused. ++ VC requires function attributes on function definitions as well as ++ declarations, PNG_FUNCTION has been added to enable this and the ++ relevant function definitions changed. ++ ++Version 1.5.0beta40 [August 6, 2010] ++ Correct use of _WINDOWS_ in pngconf.h ++ Removed png_mem_ #defines; they are no longer used. ++ Added the sRGB chunk to pngtest.png ++ ++Version 1.5.0beta41 [August 11, 2010] ++ Added the cHRM chunk to pngtest.png ++ Don't try to use version-script with cygwin/mingw. ++ Revised contrib/gregbook to work under cygwin/mingw. ++ ++Version 1.5.0beta42 [August 18, 2010] ++ Add .dll.a to the list of extensions to be symlinked by Makefile.am (Yaakov) ++ Made all API functions that have const arguments and constant string ++ literal pointers declare them (John Bowler). ++ ++Version 1.5.0beta43 [August 20, 2010] ++ Removed spurious tabs, shorten long lines (no source change) ++ Also added scripts/chkfmt to validate the format of all the files that can ++ reasonably be validated (it is suggested to run "make distclean" before ++ checking, because some machine generated files have long lines.) ++ Reformatted the CHANGES file to be more consistent throughout. ++ Made changes to address various issues identified by GCC, mostly ++ signed/unsigned and shortening problems on assignment but also a few ++ difficult to optimize (for GCC) loops. ++ Fixed non-GCC fixed point builds. In png.c a declaration was misplaced ++ in an earlier update. Fixed to declare the auto variables at the head. ++ Use cexcept.h in pngvalid.c. ++ ++Version 1.5.0beta44 [August 24, 2010] ++ Updated CMakeLists.txt to use CMAKE_INSTALL_LIBDIR variable; useful for ++ installing libpng in /usr/lib64 (Funda Wang). ++ Revised CMakeLists.txt to put the man pages in share/man/man* not man/man* ++ Revised CMakeLists.txt to make symlinks instead of copies when installing. ++ Changed PNG_LIB_NAME from pngNN to libpngNN in CMakeLists.txt (Philip Lowman) ++ Implemented memory checks within pngvalid ++ Reformatted/rearranged pngvalid.c to assist use of progressive reader. ++ Check interlaced images in pngvalid ++ Clarified pngusr.h comments in pnglibconf.dfa ++ Simplified the pngvalid error-handling code now that cexcept.h is in place. ++ Implemented progressive reader in pngvalid.c for standard tests ++ Implemented progressive read in pngvalid.c gamma tests ++ Turn on progressive reader in pngvalid.c by default and tidy code. ++ ++Version 1.5.0beta45 [August 26, 2010] ++ Added an explicit make step to projects/vstudio for pnglibconf.h ++ Also corrected zlib.vcxproj into which Visual Studio had introduced ++ what it calls an "authoring error". The change to make pnglibconf.h ++ simply copies the file; in the future it may actually generate the ++ file from scripts/pnglibconf.dfa as the other build systems do. ++ Changed pngvalid to work when floating point APIs are disabled ++ Renamed the prebuilt scripts/pnglibconf.h to scripts/pnglibconf.h.prebuilt ++ Supply default values for PNG_USER_PRIVATEBUILD and PNG_USER_DLLFNAME_POSTFIX ++ in pngpriv.h in case the user neglected to define them in their pngusr.h ++ ++Version 1.5.0beta46 [August 28, 2010] ++ Added new private header files to libpng_sources in CMakeLists.txt ++ Added PNG_READ_16BIT, PNG_WRITE_16BIT, and PNG_16BIT options. ++ Added reference to scripts/pnglibconf.h.prebuilt in the visualc71 project. ++ ++Version 1.5.0beta47 [September 11, 2010] ++ Fixed a number of problems with 64-bit compilation reported by Visual ++ Studio 2010 (John Bowler). ++ ++Version 1.5.0beta48 [October 4, 2010] ++ Updated CMakeLists.txt (Philip Lowman). ++ Revised autogen.sh to recognize and use $AUTOCONF, $AUTOMAKE, $AUTOHEADER, ++ $AUTOPOINT, $ACLOCAL and $LIBTOOLIZE ++ Fixed problem with symbols creation in Makefile.am which was assuming that ++ all versions of ccp write to standard output by default (Martin Banky). The ++ bug was introduced in libpng-1.2.9beta5. ++ Removed unused mkinstalldirs. ++ ++Version 1.5.0beta49 [October 8, 2010] ++ Undid Makefile.am revision of 1.5.0beta48. ++ ++Version 1.5.0beta50 [October 14, 2010] ++ Revised Makefile.in to account for mkinstalldirs being removed. ++ Added some "(unsigned long)" typecasts in printf statements in pngvalid.c. ++ Suppressed a compiler warning in png_handle_sPLT(). ++ Check for out-of-range text compression mode in png_set_text(). ++ ++Version 1.5.0beta51 [October 15, 2010] ++ Changed embedded dates to "(PENDING RELEASE) in beta releases (and future ++ rc releases) to minimize the difference between releases. ++ ++Version 1.5.0beta52 [October 16, 2010] ++ Restored some of the embedded dates (in png.h, png.c, documentation, etc.) ++ ++Version 1.5.0beta53 [October 18, 2010] ++ Updated INSTALL to mention using "make maintainer-clean" and to remove ++ obsolete statement about a custom ltmain.sh ++ Disabled "color-tests" by default in Makefile.am so it will work with ++ automake versions earlier than 1.11.1 ++ Use document name "libpng-manual.txt" instead of "libpng-.txt" ++ to simplify version differences. ++ Removed obsolete remarks about setjmp handling from INSTALL. ++ Revised and renamed the typedef in png.h and png.c that was designed ++ to catch library and header mismatch. ++ ++Version 1.5.0beta54 [November 10, 2010] ++ Require 48 bytes, not 64 bytes, for big_row_buf in overflow checks. ++ Used a consistent structure for the pngget.c functions. ++ ++Version 1.5.0beta55 [November 21, 2010] ++ Revised png_get_uint_32, png_get_int_32, png_get_uint_16 (Cosmin) ++ Moved reading of file signature into png_read_sig (Cosmin) ++ Fixed atomicity of chunk header serialization (Cosmin) ++ Added test for io_state in pngtest.c (Cosmin) ++ Added "#!/bin/sh" at the top of contrib/pngminim/*/gather.sh scripts. ++ Changes to remove gcc warnings (John Bowler) ++ Certain optional gcc warning flags resulted in warnings in libpng code. ++ With these changes only -Wconversion and -Wcast-qual cannot be turned on. ++ Changes are trivial rearrangements of code. -Wconversion is not possible ++ for pngrutil.c (because of the widespread use of += et al on variables ++ smaller than (int) or (unsigned int)) and -Wcast-qual is not possible ++ with pngwio.c and pngwutil.c because the 'write' callback and zlib ++ compression both fail to declare their input buffers with 'const'. ++ ++Version 1.5.0beta56 [December 7, 2010] ++ Added the private PNG_UNUSED() macro definition in pngpriv.h. ++ Added some commentary about PNG_EXPORT in png.h and pngconf.h ++ Revised PNG_EXPORT() macro and added PNG_EXPORTA() macro, with the ++ objective of simplifying and improving the cosmetic appearance of png.h. ++ Fixed some incorrect "=" macro names in pnglibconf.dfa ++ Included documentation of changes in 1.5.0 from 1.4.x in libpng-manual.txt ++ ++Version 1.5.0beta57 [December 9, 2010] ++ Documented the pngvalid gamma error summary with additional comments and ++ print statements. ++ Improved missing symbol handling in checksym.awk; symbols missing in both ++ the old and new files can now be optionally ignored, treated as errors ++ or warnings. ++ Removed references to pngvcrd.c and pnggccrd.c from the vstudio project. ++ Updated "libpng14" to "libpng15" in the visualc71 project. ++ Enabled the strip16 tests in pngvalid.` ++ Don't display test results (except PASS/FAIL) when running "make test". ++ Instead put them in pngtest-log.txt ++ Added "--with-zprefix=" to configure.ac ++ Updated the prebuilt configuration files to autoconf version 2.68 ++ ++Version 1.5.0beta58 [December 19, 2010] ++ Fixed interlace image handling and add test cases (John Bowler) ++ Fixed the clean rule in Makefile.am to remove pngtest-log.txt ++ Made minor changes to work around warnings in gcc 3.4 ++ ++Version 1.5.0rc01 [December 27, 2010] ++ No changes. ++ ++Version 1.5.0rc02 [December 27, 2010] ++ Eliminated references to the scripts/*.def files in project/visualc71. ++ ++Version 1.5.0rc03 [December 28, 2010] ++ Eliminated scripts/*.def and revised Makefile.am accordingly ++ ++Version 1.5.0rc04 [December 29, 2010] ++ Fixed bug in background transformation handling in pngrtran.c (it was ++ looking for the flag in png_ptr->transformations instead of in ++ png_ptr->flags) (David Raymond). ++ ++Version 1.5.0rc05 [December 31, 2010] ++ Fixed typo in a comment in CMakeLists.txt (libpng14 => libpng15) (Cosmin) ++ ++Version 1.5.0rc06 [January 4, 2011] ++ Changed the new configure option "zprefix=string" to "zlib-prefix=string" ++ ++Version 1.5.0rc07 [January 4, 2011] ++ Updated copyright year. ++ ++Version 1.5.0 [January 6, 2011] ++ No changes. ++ ++version 1.5.1beta01 [January 8, 2011] ++ Added description of png_set_crc_action() to the manual. ++ Added a note in the manual that the type of the iCCP profile was changed ++ from png_charpp to png_bytepp in png_get_iCCP(). This change happened ++ 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, 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). ++ Updated CMakeLists.txt (Clifford Yapp) ++ ++Version 1.5.1beta03 [January 14, 2011] ++ Fixed typecasting of some png_debug() statements (Cosmin) ++ ++Version 1.5.1beta04 [January 16, 2011] ++ Updated documentation of png_set|get_tRNS() (Thomas Klausner). ++ Mentioned in the documentation that applications must #include "zlib.h" ++ if they need access to anything in zlib.h, and that a number of ++ macros such as png_memset() are no longer accessible by applications. ++ Corrected pngvalid gamma test "sample" function to access all of the color ++ samples of each pixel, instead of sampling the red channel three times. ++ Prefixed variable names index, div, exp, gamma with "png_" to avoid "shadow" ++ warnings, and (mistakenly) changed png_exp() to exp(). ++ ++Version 1.5.1beta05 [January 16, 2011] ++ Changed variable names png_index, png_div, png_exp, and png_gamma to ++ char_index, divisor, exp_b10, and gamma_val, respectively, and ++ changed exp() back to png_exp(). ++ ++Version 1.5.1beta06 [January 20, 2011] ++ Prevent png_push_crc_skip() from hanging while reading an unknown chunk ++ or an over-large compressed zTXt chunk with the progressive reader. ++ Eliminated more GCC "shadow" warnings. ++ Revised png_fixed() in png.c to avoid compiler warning about reaching the ++ end without returning anything. ++ ++Version 1.5.1beta07 [January 22, 2011] ++ In the manual, describe the png_get_IHDR() arguments in the correct order. ++ Added const_png_structp and const_png_infop types, and used them in ++ prototypes for most png_get_*() functions. ++ ++Version 1.5.1beta08 [January 23, 2011] ++ Added png_get_io_chunk_type() and deprecated png_get_io_chunk_name() ++ Added synopses for the IO_STATE functions and other missing synopses ++ to the manual. Removed the synopses from libpngpf.3 because they ++ were out of date and no longer useful. Better information can be ++ obtained by reading the prototypes and comments in pngpriv.h ++ Attempted to fix cpp on Solaris with S. Studio 12 cc, fix build ++ Added a make macro DFNCPP that is a CPP that will accept the tokens in ++ a .dfn file and adds configure stuff to test for such a CPP. ./configure ++ should fail if one is not available. ++ Corrected const_png_ in png.h to png_const_ to avoid polluting the namespace. ++ Added png_get_current_row_number and png_get_current_pass_number for the ++ benefit of the user transform callback. ++ Added png_process_data_pause and png_process_data_skip for the benefit of ++ progressive readers that need to stop data processing or want to optimize ++ skipping of unread data (e.g., if the reader marks a chunk to be skipped.) ++ ++Version 1.5.1beta09 [January 24, 2011] ++ Enhanced pngvalid, corrected an error in gray_to_rgb, corrected doc error. ++ pngvalid contains tests of transforms, which tests are currently disabled ++ because they are incompletely tested. gray_to_rgb was failing to expand ++ the bit depth for smaller bit depth images; this seems to be a long ++ standing error and resulted, apparently, in invalid output ++ (CVE-2011-0408, CERT VU#643140). The documentation did not accurately ++ describe what libpng really does when converting RGB to gray. ++ ++Version 1.5.1beta10 [January 27, 2010] ++ Fixed incorrect examples of callback prototypes in the manual, that were ++ introduced in libpng-1.0.0. ++ In addition the order of the png_get_uint macros with respect to the ++ relevant function definitions has been reversed. This helps the ++ preprocessing of the symbol files be more robust. Furthermore, the ++ symbol file preprocessing now uses -DPNG_NO_USE_READ_MACROS even when ++ the library may actually be built with PNG_USE_READ_MACROS; this stops ++ the read macros interfering with the symbol file format. ++ Made the manual, synopses, and function prototypes use the function ++ argument names file_gamma, int_file_gamma, and srgb_intent consistently. ++ ++Version 1.5.1beta11 [January 28, 2011] ++ Changed PNG_UNUSED from "param=param;" to "{if(param){}}". ++ Corrected local variable type in new API png_process_data_skip() ++ The type was self-evidently incorrect but only causes problems on 64-bit ++ architectures. ++ Added transform tests to pngvalid and simplified the arguments. ++ ++Version 1.5.1rc01 [January 29, 2011] ++ No changes. ++ ++Version 1.5.1rc02 [January 31, 2011] ++ Added a request in the manual that applications do not use "png_" or ++ "PNG_" to begin any of their own symbols. ++ Changed PNG_UNUSED to "(void)param;" and updated the commentary in pngpriv.h ++ ++Version 1.5.1 [February 3, 2011] ++ No changes. ++ ++Version 1.5.2beta01 [February 13, 2011] ++ More -Wshadow fixes for older gcc compilers. Older gcc versions apparently ++ check formal parameters names in function declarations (as well as ++ definitions) to see if they match a name in the global namespace. ++ Revised PNG_EXPORTA macro to not use an empty parameter, to accommodate the ++ old VisualC++ preprocessor. ++ Turned on interlace handling in png_read_png(). ++ Fixed gcc pedantic warnings. ++ Handle longjmp in Cygwin. ++ Fixed png_get_current_row_number() in the interlaced case. ++ Cleaned up ALPHA flags and transformations. ++ Implemented expansion to 16 bits. ++ ++Version 1.5.2beta02 [February 19, 2011] ++ Fixed mistake in the descriptions of user read_transform and write_transform ++ function prototypes in the manual. The row_info struct is png_row_infop. ++ Reverted png_get_current_row_number() to previous (1.5.2beta01) behavior. ++ Corrected png_get_current_row_number documentation ++ Fixed the read/write row callback documentation. ++ This documents the current behavior, where the callback is called after ++ every row with information pertaining to the next row. ++ ++Version 1.5.2beta03 [March 3, 2011] ++ Fixed scripts/makefile.vcwin32 ++ Updated contrib/pngsuite/README to add the word "modify". ++ Define PNG_ALLOCATED to blank when _MSC_VER<1300. ++ ++Version 1.5.2rc01 [March 19, 2011] ++ Define remaining attributes to blank when MSC_VER<1300. ++ ifdef out mask arrays in pngread.c when interlacing is not supported. ++ ++Version 1.5.2rc02 [March 22, 2011] ++ Added a hint to try CPP=/bin/cpp if "cpp -E" fails in scripts/pnglibconf.mak ++ and in contrib/pngminim/*/makefile, eg., on SunOS 5.10, and removed "strip" ++ from the makefiles. ++ Fixed a bug (present since libpng-1.0.7) that makes png_handle_sPLT() fail ++ to compile when PNG_NO_POINTER_INDEXING is defined (Chubanov Kirill) ++ ++Version 1.5.2rc03 [March 24, 2011] ++ Don't include standard header files in png.h while building the symbol table, ++ to avoid cpp failure on SunOS (introduced PNG_BUILDING_SYMBOL_TABLE macro). ++ ++Version 1.5.2 [March 31, 2011] ++ No changes. ++ ++Version 1.5.3beta01 [April 1, 2011] ++ Re-initialize the zlib compressor before compressing 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. ++ Only compile the new zlib re-initializing code when text or iCCP is ++ supported, using PNG_WRITE_COMPRESSED_TEXT_SUPPORTED macro. ++ Improved the optimization of the zlib CMF byte (see libpng-1.2.6beta03). ++ Optimize the zlib CMF byte in non-IDAT compressed chunks ++ ++Version 1.5.3beta03 [April 16, 2011] ++ Fixed gcc -ansi -pedantic compile. A strict ANSI system does not have ++ snprintf, and the "__STRICT_ANSI__" detects that condition more reliably ++ than __STDC__ (John Bowler). ++ Removed the PNG_PTR_NORETURN attribute because it too dangerous. It tells ++ the compiler that a user supplied callback (the error handler) does not ++ return, yet there is no guarantee in practice that the application code ++ will correctly implement the error handler because the compiler only ++ issues a warning if there is a mistake (John Bowler). ++ Removed the no-longer-used PNG_DEPSTRUCT macro. ++ Updated the zlib version to 1.2.5 in the VStudio project. ++ Fixed 64-bit builds where png_uint_32 is smaller than png_size_t in ++ pngwutil.c (John Bowler). ++ Fixed bug with stripping the filler or alpha channel when writing, that ++ was introduced in libpng-1.5.2beta01 (bug report by Andrew Church). ++ ++Version 1.5.3beta04 [April 27, 2011] ++ Updated pngtest.png with the new zlib CMF optimization. ++ Cleaned up conditional compilation code and of background/gamma handling ++ Internal changes only except a new option to avoid compiling the ++ png_build_grayscale_palette API (which is not used at all internally.) ++ The main change is to move the transform tests (READ_TRANSFORMS, ++ WRITE_TRANSFORMS) up one level to the caller of the APIs. This avoids ++ calls to spurious functions if all transforms are disabled and slightly ++ simplifies those functions. Pngvalid modified to handle this. ++ A minor change is to stop the strip_16 and expand_16 interfaces from ++ disabling each other; this allows the future alpha premultiplication ++ code to use 16-bit intermediate values while still producing 8-bit output. ++ png_do_background and png_do_gamma have been simplified to take a single ++ pointer to the png_struct rather than pointers to every item required ++ from the png_struct. This makes no practical difference to the internal ++ code. ++ A serious bug in the pngvalid internal routine 'standard_display_init' has ++ been fixed - this failed to initialize the red channel and accidentally ++ initialized the alpha channel twice. ++ Changed png_struct jmp_buf member name from png_jmpbuf to tmp_jmpbuf to ++ avoid a possible clash with the png_jmpbuf macro on some platforms. ++ ++Version 1.5.3beta05 [May 6, 2011] ++ Added the "_POSIX_SOURCE" feature test macro to ensure libpng sees the ++ correct API. _POSIX_SOURCE is defined in pngpriv.h, pngtest.c and ++ pngvalid.c to ensure that POSIX conformant systems disable non-POSIX APIs. ++ Removed png_snprintf and added formatted warning messages. This change adds ++ internal APIs to allow png_warning messages to have parameters without ++ requiring the host OS to implement snprintf. As a side effect the ++ 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. This fixes CVE-2011-2691. ++ Added PNG_WRITE_OPTIMIZE_CMF_SUPPORTED macro to make the zlib "CMF" byte ++ optimization configurable. ++ IDAT compression failed if preceded by a compressed text chunk (bug ++ introduced in libpng-1.5.3beta01-02). This was because the attempt to ++ reset the zlib stream in png_write_IDAT happened after the first IDAT ++ chunk had been deflated - much too late. In this change internal ++ functions were added to claim/release the z_stream and, hopefully, make ++ the code more robust. Also deflateEnd checking is added - previously ++ libpng would ignore an error at the end of the stream. ++ ++Version 1.5.3beta06 [May 8, 2011] ++ Removed the -D_ALL_SOURCE from definitions for AIX in CMakeLists.txt ++ Implemented premultiplied alpha support: png_set_alpha_mode API ++ ++Version 1.5.3beta07 [May 11, 2011] ++ Added expand_16 support to the high level interface. ++ Added named value and 'flag' gamma support to png_set_gamma. Made a minor ++ change from the previous (unreleased) ABI/API to hide the exact value used ++ for Macs - it's not a good idea to embed this in the ABI! ++ Moved macro definitions for PNG_HAVE_IHDR, PNG_HAVE_PLTE, and PNG_AFTER_IDAT ++ from pngpriv.h to png.h because they must be visible to applications ++ that call png_set_unknown_chunks(). ++ Check for up->location !PNG_AFTER_IDAT when writing unknown chunks ++ before IDAT. ++ ++Version 1.5.3beta08 [May 16, 2011] ++ Improved "pngvalid --speed" to exclude more of pngvalid from the time. ++ 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. 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 ++ the default anyway. ++ Added memory overwrite and palette image checks to pngvalid.c ++ Previously palette image code was poorly checked. Since the transformation ++ code has a special palette path in most cases this was a severe weakness. ++ Minor cleanup and some extra checking in pngrutil.c and pngrtran.c. When ++ expanding an indexed image, always expand to RGBA if transparency is ++ present. ++ ++Version 1.5.3beta09 [May 17, 2011] ++ Reversed earlier 1.5.3 change of transformation order; move png_expand_16 ++ back where it was. The change doesn't work because it requires 16-bit ++ gamma tables when the code only generates 8-bit ones. This fails ++ silently; the libpng code just doesn't do any gamma correction. Moving ++ the tests back leaves the old, inaccurate, 8-bit gamma calculations, but ++ these are clearly better than none! ++ ++Version 1.5.3beta10 [May 20, 2011] ++ ++ png_set_background() and png_expand_16() did not work together correctly. ++ This problem is present in 1.5.2; if png_set_background is called with ++ need_expand false and the matching 16 bit color libpng erroneously just ++ treats it as an 8-bit color because of where png_do_expand_16 is in the ++ transform list. This simple fix reduces the supplied colour to 8-bits, ++ so it gets smashed, but this is better than the current behavior. ++ Added tests for expand16, more fixes for palette image tests to pngvalid. ++ Corrects the code for palette image tests and disables attempts to ++ validate palette colors. ++ ++Version 1.5.3rc01 [June 3, 2011] ++ No changes. ++ ++Version 1.5.3rc02 [June 8, 2011] ++ Fixed uninitialized memory read in png_format_buffer() (Bug report by ++ 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. 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 ++ limit beyond the PNG_USER_WIDTH|HEIGHT_MAX; previously it could only ++ reduce it. ++ Make the 16-to-8 scaling accurate. Dividing by 256 with no rounding is ++ wrong (high by one) 25% of the time. Dividing by 257 with rounding is ++ wrong in 128 out of 65536 cases. Getting the right answer all the time ++ without division is easy. ++ Added "_SUPPORTED" to the PNG_WRITE_CUSTOMIZE_ZTXT_COMPRESSION macro. ++ Added projects/owatcom, an IDE project for OpenWatcom to replace ++ scripts/makefile.watcom. This project works with OpenWatcom 1.9. The ++ IDE autogenerates appropriate makefiles (libpng.mk) for batch processing. ++ The project is configurable, unlike the Visual Studio project, so long ++ as the developer has an awk. ++ Changed png_set_gAMA to limit the gamma value range so that the inverse ++ of the stored value cannot overflow the fixed point representation, ++ and changed other things OpenWatcom warns about. ++ Revised pngvalid.c to test PNG_ALPHA_MODE_SUPPORTED correctly. This allows ++ pngvalid to build when ALPHA_MODE is not supported, which is required if ++ it is to build on libpng 1.4. ++ 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 ++ and there will be no libpng-1.5.3 release. ++ ++Version 1.5.4beta01 [June 14, 2011] ++ Made it possible to undefine PNG_READ_16_TO_8_ACCURATE_SCALE_SUPPORTED ++ to get the same (inaccurate) output as libpng-1.5.2 and earlier. ++ Moved definitions of PNG_HAVE_IHDR, PNG_AFTER_IDAT, and PNG_HAVE_PLTE ++ outside of an unknown-chunk block in png.h because they are also ++ needed for other uses. ++ ++Version 1.5.4beta02 [June 14, 2011] ++ Fixed and clarified LEGACY 16-to-8 scaling code. ++ Added png_set_chop_16() API, to match inaccurate results from previous ++ libpng versions. ++ Removed the ACCURATE and LEGACY options (they are no longer useable) ++ Use the old scaling method for background if png_set_chop_16() was ++ called. ++ Made png_set_chop_16() API removeable by disabling PNG_CHOP_16_TO_8_SUPPORTED ++ ++Version 1.5.4beta03 [June 15, 2011] ++ Fixed a problem in png_do_expand_palette() exposed by optimization in ++ 1.5.3beta06 ++ Also removed a spurious and confusing "trans" member ("trans") from png_info. ++ The palette expand optimization prevented expansion to an intermediate RGBA ++ form if tRNS was present but alpha was marked to be stripped; this exposed ++ a check for tRNS in png_do_expand_palette() which is inconsistent with the ++ code elsewhere in libpng. ++ Correction to the expand_16 code; removed extra instance of ++ png_set_scale_16_to_8 from pngpriv.h ++ ++Version 1.5.4beta04 [June 16, 2011] ++ Added a missing "#ifdef PNG_READ_BACKGROUND_SUPPORTED/#endif" in pngrtran.c ++ Added PNG_TRANSFORM_CHOP_16 to the high-level read transforms. ++ Made PNG_READ_16_TO_8_ACCURATE_SCALE configurable again. If this is ++ not enabled, png_set_strip_16() and png_do_scale_16_to_8() aren't built. ++ Revised contrib/visupng, gregbook, and pngminim to demonstrate chop_16_to_8 ++ ++Version 1.5.4beta05 [June 16, 2011] ++ Renamed png_set_strip_16() to png_set_scale_16() and renamed ++ png_set_chop_16() to png_set_strip(16) in an attempt to minimize the ++ behavior changes between libpng14 and libpng15. ++ ++Version 1.5.4beta06 [June 18, 2011] ++ Fixed new bug that was causing both strip_16 and scale_16 to be applied. ++ ++Version 1.5.4beta07 [June 19, 2011] ++ Fixed pngvalid, simplified macros, added checking for 0 in sCAL. ++ The ACCURATE scale macro is no longer defined in 1.5 - call the ++ png_scale_16_to_8 API. Made sure that PNG_READ_16_TO_8 is still defined ++ if the png_strip_16_to_8 API is present. png_check_fp_number now ++ maintains some state so that positive, negative and zero values are ++ identified. sCAL uses these to be strictly spec conformant. ++ ++Version 1.5.4beta08 [June 23, 2011] ++ Fixed pngvalid if ACCURATE_SCALE is defined. ++ Updated scripts/pnglibconf.h.prebuilt. ++ ++Version 1.5.4rc01 [June 30, 2011] ++ Define PNG_ALLOCATED to "restrict" only if MSC_VER >= 1400. ++ ++Version 1.5.4 [July 7, 2011] ++ No changes. + +-version 1.2.44 [June 26, 2010] +- Updated some of the "last changed" dates. ++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 uninitialized 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 concatenation ++ 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 desirable 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 png_set_tIME() and png_convert_to_rfc1123() ++ (Frank Busse). Note: This prevented CVE-2015-7981 from affecting ++ libpng-1.5.7 and later. ++ 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. ++ Dropped support for 16-bit platforms. 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 ancillary 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 unnecessary 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 desirable 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. ++ Added 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. It also makes those tests compile and link on Android. ++ Added an API png_set_option() to set optimization options externally, ++ providing an alternative and general solution for the non-portable ++ run-time tests used by the ARM Neon code, using the PNG_ARM_NEON option. ++ 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, via a new PNG_MAXIMUM_INFLATE_WINDOW ++ option for png_set_options(). ++ 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 usage. ++ 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 ). 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 " 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. ++ Fixed an out-of-range read in png_user_version_check() (Bug report from ++ Qixue Xiao, CVE-2015-8540). ++ 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, CVE-2015-0973). ++ ++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 ++ (Bug report and fix by John Bowler, CVE-2014-9495). ++ ++Version 1.6.16 [December 22, 2014] ++ No changes. ++ ++Version 1.6.17beta01 [January 29, 2015] ++ Removed duplicate PNG_SAFE_LIMITS_SUPPORTED handling from pngconf.h ++ Corrected the width limit calculation in png_check_IHDR(). ++ Removed user limits from pngfix. Also pass NULL pointers to ++ png_read_row to skip the unnecessary row de-interlace stuff. ++ Added testing of png_set_packing() to pngvalid.c ++ Regenerated configure scripts in the *.tar distributions with libtool-2.4.4 ++ Implement previously untested cases of libpng transforms in pngvalid.c ++ Fixed byte order in png_do_read_filler() with 16-bit input. Previously ++ the high and low bytes of the filler, from png_set_filler() or from ++ png_set_add_alpha(), were read in the wrong order. ++ Made the check for out-of-range values in png_set_tRNS() detect ++ values that are exactly 2^bit_depth, and work on 16-bit platforms. ++ Merged some parts of libpng-1.6.17beta01 and libpng-1.7.0beta47. ++ Added #ifndef __COVERITY__ where needed in png.c, pngrutil.c and ++ pngset.c to avoid warnings about dead code. ++ Added "& 0xff" to many instances of expressions that are typecast ++ to (png_byte), to avoid Coverity warnings. ++ ++Version 1.6.17beta02 [February 7, 2015] ++ Work around one more Coverity-scan dead-code warning. ++ Do not build png_product2() when it is unused. ++ ++Version 1.6.17beta03 [February 17, 2015] ++ Display user limits in the output from pngtest. ++ Eliminated the PNG_SAFE_LIMITS macro and restored the 1-million-column ++ and 1-million-row default limits in pnglibconf.dfa, that can be reset ++ by the user at build time or run time. This provides a more robust ++ defense against DOS and as-yet undiscovered overflows. ++ ++Version 1.6.17beta04 [February 21, 2015] ++ Added PNG_WRITE_CUSTOMIZE_COMPRESSION_SUPPORTED macro, on by default. ++ Allow user to call png_get_IHDR() with NULL arguments (Reuben Hawkins). ++ Rebuilt configure scripts with automake-1.15 and libtool-2.4.6 ++ ++Version 1.6.17beta05 [February 25, 2015] ++ Restored compiling of png_reciprocal2 with PNG_NO_16BIT. ++ ++Version 1.6.17beta06 [February 27, 2015] ++ Moved png_set_filter() prototype into a PNG_WRITE_SUPPORTED block ++ of png.h. ++ Avoid runtime checks when converting integer to png_byte with ++ Visual Studio (Sergey Kosarevsky) ++ ++Version 1.6.17rc01 [March 4, 2015] ++ No changes. ++ ++Version 1.6.17rc02 [March 9, 2015] ++ Removed some comments that the configure script did not handle ++ properly from scripts/pnglibconf.dfa and pnglibconf.h.prebuilt. ++ Free the unknown_chunks structure even when it contains no data. ++ ++Version 1.6.17rc03 [March 12, 2015] ++ Updated CMakeLists.txt to add OSX framework, change YES/NO to ON/OFF ++ for consistency, and remove some useless tests (Alexey Petruchik). ++ ++Version 1.6.17rc04 [March 16, 2015] ++ Remove pnglibconf.h, pnglibconf.c, and pnglibconf.out instead of ++ pnglibconf.* in "make clean" (Cosmin). ++ Fix bug in calculation of maxbits, in png_write_sBIT, introduced ++ in libpng-1.6.17beta01 (John Bowler). ++ ++Version 1.6.17rc05 [March 21, 2015] ++ Define PNG_FILTER_* and PNG_FILTER_VALUE_* in png.h even when WRITE ++ is not supported (John Bowler). This fixes an error introduced in ++ libpng-1.6.17beta06. ++ Reverted "& 0xff" additions of version 1.6.17beta01. Libpng passes ++ the Coverity scan without them. ++ ++Version 1.6.17rc06 [March 23, 2015] ++ Remove pnglibconf.dfn and pnglibconf.pre with "make clean". ++ Reformatted some "&0xff" instances to "& 0xff". ++ Fixed simplified 8-bit-linear to sRGB alpha. The calculated alpha ++ value was wrong. It's not clear if this affected the final stored ++ value; in the obvious code path the upper and lower 8-bits of the ++ alpha value were identical and the alpha was truncated to 8-bits ++ rather than dividing by 257 (John Bowler). ++ ++Version 1.6.17 [March 26, 2015] ++ No changes. ++ ++Version 1.6.18beta01 [April 1, 2015] ++ Removed PNG_SET_CHUNK_[CACHE|MALLOC]_LIMIT_SUPPORTED macros. They ++ have been combined with PNG_SET_USER_LIMITS_SUPPORTED (resolves ++ bug report by Andrew Church). ++ Fixed rgb_to_gray checks and added tRNS checks to pngvalid.c. This ++ fixes some arithmetic errors that caused some tests to fail on ++ some 32-bit platforms (Bug reports by Peter Breitenlohner [i686] ++ and Petr Gajdos [i586]). ++ ++Version 1.6.18beta02 [April 26, 2015] ++ Suppressed some warnings from the Borland C++ 5.5.1/5.82 compiler ++ (Bug report by Viktor Szakats). ++ ++Version 1.6.18beta03 [May 6, 2015] ++ Replaced "unexpected" with an integer (0xabadca11) in pngset.c ++ where a long was expected, to avoid a compiler warning when PNG_DEBUG > 1. ++ Added contrib/examples/simpleover.c, to demonstrate how to handle ++ alpha compositing of multiple images, using the "simplified API" ++ and an example PNG generation tool, contrib/examples/genpng.c ++ (John Bowler). ++ ++Version 1.6.18beta04 [May 20, 2015] ++ PNG_RELEASE_BUILD replaces tests where the code depended on the build base ++ type and can be defined on the command line, allowing testing in beta ++ builds (John Bowler). ++ Avoid Coverity issue 80858 (REVERSE NULL) in pngtest.c PNG_DEBUG builds. ++ Avoid a harmless potential integer overflow in png_XYZ_from_xy() (Bug ++ report from Christopher Ferris). ++ ++Version 1.6.18beta05 [May 31, 2015] ++ Backport filter selection code from libpng-1.7.0beta51, to combine ++ sub_row, up_row, avg_row, and paeth_row into try_row and tst_row. ++ Changed png_voidcast(), etc., to voidcast(), etc., in contrib/tools/pngfix.c ++ to avoid confusion with the libpng private macros. ++ Fixed old cut&paste bug in the weighted filter selection code in ++ pngwutil.c, introduced in libpng-0.95, March 1997. ++ ++Version 1.6.18beta06 [June 1, 2015] ++ Removed WRITE_WEIGHTED_FILTERED code, to save a few kbytes of the ++ compiled library size. It never worked properly and as far as we can ++ tell, no one uses it. The png_set_filter_heuristics() and ++ png_set_filter_heuristics_fixed() APIs are retained but deprecated ++ and do nothing. ++ ++Version 1.6.18beta07 [June 6, 2015] ++ Removed non-working progressive reader 'skip' function. This ++ function has apparently never been used. It was implemented ++ to support back-door modification of png_struct in libpng-1.4.x ++ but (because it does nothing and cannot do anything) was apparently ++ never tested (John Bowler). ++ Fixed cexcept.h in which GCC 5 now reports that one of the auto ++ variables in the Try macro needs to be volatile to prevent value ++ being lost over the setjmp (John Bowler). ++ Fixed NO_WRITE_FILTER and -Wconversion build breaks (John Bowler). ++ Fix g++ build breaks (John Bowler). ++ Quieted some Coverity issues in pngfix.c, png-fix-itxt.c, pngvalid.c, ++ pngstest.c, and pngimage.c. Most seem harmless, but png-fix-itxt ++ would only work with iTXt chunks with length 255 or less. ++ Added #ifdef's to contrib/examples programs so people don't try ++ to compile them without the minimum required support enabled ++ (suggested by Flavio Medeiros). ++ ++Version 1.6.18beta08 [June 30, 2015] ++ Eliminated the final two Coverity defects (insecure temporary file ++ handling in contrib/libtests/pngstest.c; possible overflow of ++ unsigned char in contrib/tools/png-fix-itxt.c). To use the "secure" ++ file handling, define PNG_USE_MKSTEMP, otherwise "tmpfile()" will ++ be used. ++ Removed some unused WEIGHTED_FILTER macros from png.h and pngstruct.h ++ ++Version 1.6.18beta09 [July 5, 2015] ++ Removed some useless typecasts from contrib/tools/png-fix-itxt.c ++ Fixed a new signed-unsigned comparison in pngrtran.c (Max Stepin). ++ Replaced arbitrary use of 'extern' with #define PNG_LINKAGE_*. To ++ preserve API compatibility, the new defines all default to "extern" ++ (requested by Jan Nijtmans). ++ ++Version 1.6.18rc01 [July 9, 2015] ++ Belatedly added Mans Rullgard and James Yu to the list of Contributing ++ Authors. ++ ++Version 1.6.18rc02 [July 12, 2015] ++ Restored unused FILTER_HEURISTIC macros removed at libpng-1.6.18beta08 ++ to png.h to avoid compatibility warnings. ++ ++Version 1.6.18rc03 [July 15, 2015] ++ Minor changes to the man page ++ ++Version 1.6.18 [July 23, 2015] ++ No changes. ++ ++Version 1.6.19beta01 [July 30, 2015] ++ Updated obsolete information about the simplified API macros in the ++ manual pages (Bug report by Arc Riley). ++ Avoid potentially dereferencing NULL info_ptr in png_info_init_3(). ++ Rearranged png.h to put the major sections in the same order as ++ in libpng17. ++ Eliminated unused PNG_COST_SHIFT, PNG_WEIGHT_SHIFT, PNG_COST_FACTOR, and ++ PNG_WEIGHT_FACTOR macros. ++ Suppressed some warnings from the Borland C++ 5.5.1/5.82 compiler ++ (Bug report by Viktor Szakats). Several warnings remain and are ++ unavoidable, where we test for overflow. ++ Fixed potential leak of png_pixels in contrib/pngminus/pnm2png.c ++ Fixed uninitialized variable in contrib/gregbook/rpng2-x.c ++ ++Version 1.6.19beta02 [August 19, 2015] ++ Moved config.h.in~ from the "libpng_autotools_files" list to the ++ "libpng_autotools_extra" list in autogen.sh because it was causing a ++ false positive for missing files (bug report by Robert C. Seacord). ++ Removed unreachable "break" statements in png.c, pngread.c, and pngrtran.c ++ to suppress clang warnings (Bug report by Viktor Szakats). ++ Fixed some bad links in the man page. ++ Changed "n bit" to "n-bit" in comments. ++ Added signed/unsigned 16-bit safety net. This removes the dubious ++ 0x8000 flag definitions on 16-bit systems. They aren't supported ++ yet the defs *probably* work, however it seems much safer to do this ++ and be advised if anyone, contrary to advice, is building libpng 1.6 ++ on a 16-bit system. It also adds back various switch default clauses ++ for GCC; GCC errors out if they are not present (with an appropriately ++ high level of warnings). ++ Safely convert num_bytes to a png_byte in png_set_sig_bytes() (Robert ++ Seacord). ++ Fixed the recently reported 1's complement security issue by replacing ++ the value that is illegal in the PNG spec, in both signed and unsigned ++ values, with 0. Illegal unsigned values (anything greater than or equal ++ to 0x80000000) can still pass through, but since these are not illegal ++ in ANSI-C (unlike 0x80000000 in the signed case) the checking that ++ occurs later can catch them (John Bowler). ++ ++Version 1.6.19beta03 [September 26, 2015] ++ Fixed png_save_int_32 when int is not 2's complement (John Bowler). ++ Updated libpng16 with all the recent test changes from libpng17, ++ including changes to pngvalid.c to ensure that the original, ++ distributed, version of contrib/visupng/cexcept.h can be used ++ (John Bowler). ++ pngvalid contains the correction to the use of SAVE/STORE_ ++ UNKNOWN_CHUNKS; a bug revealed by changes in libpng 1.7. More ++ tests contain the --strict option to detect warnings and the ++ pngvalid-standard test has been corrected so that it does not ++ turn on progressive-read. There is a separate test which does ++ that. (John Bowler) ++ Also made some signed/unsigned fixes. ++ Make pngstest error limits version specific. Splitting the machine ++ generated error structs out to a file allows the values to be updated ++ without changing pngstest.c itself. Since libpng 1.6 and 1.7 have ++ slightly different error limits this simplifies maintenance. The ++ makepngs.sh script has also been updated to more accurately reflect ++ current problems in libpng 1.7 (John Bowler). ++ Incorporated new test PNG files into make check. tests/pngstest-* ++ are changed so that the new test files are divided into 8 groups by ++ gamma and alpha channel. These tests have considerably better code ++ and pixel-value coverage than contrib/pngsuite; however,coverage is ++ still incomplete (John Bowler). ++ Removed the '--strict' in 1.6 because of the double-gamma-correction ++ warning, updated pngstest-errors.h for the errors detected with the ++ new contrib/testspngs PNG test files (John Bowler). ++ ++Version 1.6.19beta04 [October 15, 2015] ++ Worked around rgb-to-gray issues in libpng 1.6. The previous ++ attempts to ignore the errors in the code aren't quite enough to ++ deal with the 'channel selection' encoding added to libpng 1.7; abort. ++ pngvalid.c is changed to drop this encoding in prior versions. ++ Fixed 'pow' macros in pngvalid.c. It is legal for 'pow' to be a ++ macro, therefore the argument list cannot contain preprocessing ++ directives. Make sure pow is a function where this happens. This is ++ a minimal safe fix, the issue only arises in non-performance-critical ++ code (bug report by Curtis Leach, fix by John Bowler). ++ Added sPLT support to pngtest.c ++ ++Version 1.6.19rc01 [October 23, 2015] ++ No changes. ++ ++Version 1.6.19rc02 [October 31, 2015] ++ Prevent setting or writing over-length PLTE chunk (Cosmin Truta). ++ Silently truncate over-length PLTE chunk while reading. ++ Libpng incorrectly calculated the output rowbytes when the application ++ decreased either the number of channels or the bit depth (or both) in ++ a user transform. This was safe; libpng overallocated buffer space ++ (potentially by quite a lot; up to 4 times the amount required) but, ++ from 1.5.4 on, resulted in a png_error (John Bowler). ++ ++Version 1.6.19rc03 [November 3, 2015] ++ Fixed some inconsequential cut-and-paste typos in png_set_cHRM_XYZ_fixed(). ++ Clarified COPYRIGHT information to state explicitly that versions ++ are derived from previous versions. ++ Removed much of the long list of previous versions from png.h and ++ libpng.3. ++ ++Version 1.6.19rc04 [November 5, 2015] ++ Fixed new bug with CRC error after reading an over-length palette ++ (bug report by Cosmin Truta) (CVE-2015-8126). ++ ++Version 1.6.19 [November 12, 2015] ++ Cleaned up coding style in png_handle_PLTE(). ++ ++Version 1.6.20beta01 [November 20, 2015] ++ Avoid potential pointer overflow/underflow in png_handle_sPLT() and ++ png_handle_pCAL() (Bug report by John Regehr). ++ ++Version 1.6.20beta02 [November 23, 2015] ++ Fixed incorrect implementation of png_set_PLTE() that uses png_ptr ++ not info_ptr, that left png_set_PLTE() open to the CVE-2015-8126 ++ vulnerability. Fixes CVE-2015-8472. ++ ++Version 1.6.20beta03 [November 24, 2015] ++ Backported tests from libpng-1.7.0beta69. ++ ++Version 1.6.20rc01 [November 26, 2015] ++ Fixed an error in handling of bad zlib CMINFO field in pngfix, found by ++ American Fuzzy Lop, reported by Brian Carpenter. inflate() doesn't ++ immediately fault a bad CMINFO field; instead a 'too far back' error ++ happens later (at least some times). pngfix failed to limit CMINFO to ++ the allowed values but then assumed that window_bits was in range, ++ triggering an assert. The bug is mostly harmless; the PNG file cannot ++ be fixed. ++ ++Version 1.6.20rc02 [November 29, 2015] ++ In libpng 1.6 zlib initialization was changed to use the window size ++ in the zlib stream, not a fixed value. This causes some invalid images, ++ where CINFO is too large, to display 'correctly' if the rest of the ++ data is valid. This provides a workaround for zlib versions where the ++ error arises (ones that support the API change to use the window size ++ in the stream). ++ ++Version 1.6.20 [December 3, 2015] ++ No changes. ++ ++Version 1.6.21beta01 [December 11, 2015] ++ Fixed syntax "$(command)" in tests/pngstest that some shells other than ++ bash could not parse (Bug report by Nelson Beebe). Use `command` instead. ++ ++Version 1.6.21beta02 [December 14, 2015] ++ Moved png_check_keyword() from pngwutil.c to pngset.c ++ Removed LE/BE dependencies in pngvalid, to 'fix' the current problem ++ in the BigEndian tests by not testing it, making the BE code the same ++ as the LE version. ++ Fixes to pngvalid for various reduced build configurations (eliminate unused ++ statics) and a fix for the case in rgb_to_gray when the digitize option ++ reduces graylo to 0, producing a large error. ++ ++Version 1.6.21beta03 [December 18, 2015] ++ Widened the 'limit' check on the internally calculated error limits in ++ the 'DIGITIZE' case (the code used prior to 1.7 for rgb_to_gray error ++ checks) and changed the check to only operate in non-release builds ++ (base build type not RC or RELEASE.) ++ Fixed undefined behavior in pngvalid.c, undefined because ++ (png_byte) << shift is undefined if it changes the signed bit ++ (because png_byte is promoted to int). The libpng exported functions ++ png_get_uint_32 and png_get_uint_16 handle this. (Bug reported by ++ David Drysdale as a result of reports from UBSAN in clang 3.8). ++ This changes pngvalid to use BE random numbers; this used to produce ++ errors but these should not be fixed as a result of the previous changes. ++ ++Version 1.6.21rc01 [January 4, 2016] ++ In projects/vstudio, combined readme.txt and WARNING into README.txt ++ ++Version 1.6.21rc02 [January 7, 2016] ++ Relocated assert() in contrib/tools/pngfix.c, bug found by American ++ Fuzzy Lop, reported by Brian Carpenter. ++ Marked 'limit' UNUSED in transform_range_check(). This only affects ++ release builds. ++ ++Version 1.6.21 [January 15, 2016] ++ Worked around a false-positive Coverity issue in pngvalid.c. ++ ++Version 1.6.22beta01 [January 23, 2016] ++ Changed PNG_USE_MKSTEMP to __COVERITY__ to select alternate ++ "tmpfile()" implementation in contrib/libtests/pngstest.c ++ Fixed NO_STDIO build of pngunknown.c to skip calling png_init_io() ++ if there is no stdio.h support. ++ Added a png_image_write_to_memory() API and a number of assist macros ++ to allow an application that uses the simplified API write to bypass ++ stdio and write directly to memory. ++ Added some warnings (png.h) and some check code to detect *possible* ++ overflow in the ROW_STRIDE and simplified image SIZE macros. This ++ disallows image width/height/format that *might* overflow. This is ++ a quiet API change that limits in-memory image size (uncompressed) to ++ less than 4GByte and image row size (stride) to less than 2GByte. ++ Revised workaround for false-positive Coverity issue in pngvalid.c. ++ ++Version 1.6.22beta02 [February 8, 2016] ++ Only use exit(77) in configure builds. ++ Corrected error in PNG_IMAGE_PNG_SIZE_MAX. This new macro underreported ++ the palette size because it failed to take into account that the memory ++ palette has to be expanded to full RGB when it is written to PNG. ++ Updated CMakeLists.txt, added supporting scripts/gen*.cmake.in ++ and test.cmake.in (Roger Leigh). ++ Relaxed limit checks on gamma values in pngrtran.c. As suggested in ++ the comments gamma values outside the range currently permitted ++ by png_set_alpha_mode are useful for HDR data encoding. These values ++ are already permitted by png_set_gamma so it is reasonable caution to ++ extend the png_set_alpha_mode range as HDR imaging systems are starting ++ to emerge. ++ ++Version 1.6.22beta03 [March 9, 2016] ++ Added a common-law trademark notice and export control information ++ to the LICENSE file, png.h, and the man page. ++ Restored "& 0xff" in png_save_uint_16() and png_save_uint_32() that ++ were accidentally removed from libpng-1.6.17. ++ Changed PNG_INFO_cHNK and PNG_FREE_cHNK from 0xnnnn to 0xnnnnU in png.h ++ (Robert C. Seacord). ++ Removed dubious "#if INT_MAX" test from png.h that was added to ++ libpng-1.6.19beta02 (John Bowler). ++ Add ${INCLUDES} in scripts/genout.cmake.in (Bug report by Nixon Kwok). ++ Updated LICENSE to say files in the contrib directory are not ++ necessarily under the libpng license, and that some makefiles have ++ other copyright owners. ++ Added INTEL-SSE2 support (Mike Klein and Matt Sarett, Google, Inc.). ++ Made contrib/libtests/timepng more robust. The code no longer gives ++ up/fails on invalid PNG data, it just skips it (with error messages). ++ The code no longer fails on PNG files with data beyond IEND. Options ++ exist to use png_read_png (reading the whole image, not by row) and, in ++ that case, to apply any of the supported transforms. This makes for ++ more realistic testing; the decoded data actually gets used in a ++ meaningful fashion (John Bowler). ++ Fixed some misleading indentation (Krishnaraj Bhat). ++ ++Version 1.6.22beta04 [April 5, 2016] ++ Force GCC compilation to C89 if needed (Dagobert Michelsen). ++ SSE filter speed improvements for bpp=3: ++ memcpy-free implementations of load3() / store3(). ++ call load3() only when needed at the end of a scanline. ++ ++Version 1.6.22beta05 [April 27, 2016] ++ Added PNG_FAST_FILTERS macro (defined as ++ PNG_FILTER_NONE|PNG_FILTER_SUB|PNG_FILTER_UP). ++ Various fixes for contrib/libtests/timepng.c ++ Moved INTEL-SSE code from pngpriv.h into contrib/intel/intel_sse.patch. ++ Fixed typo (missing underscore) in #define PNG_READ_16_TO_8_SUPPORTED ++ (Bug report by Y.Ohashik). ++ ++Version 1.6.22beta06 [May 5, 2016] ++ Rebased contrib/intel_sse.patch. ++ Quieted two Coverity issues in contrib/libtests/timepng.c. ++ Fixed issues with scripts/genout.cmake.in (David Capello, Nixon Kwok): ++ Added support to use multiple directories in ZLIBINCDIR variable, ++ Fixed CMAKE_C_FLAGS with multiple values when genout is compiled on MSVC, ++ Fixed pnglibconf.c compilation on OS X including the sysroot path. ++ ++Version 1.6.22rc01 [May 14, 2016] ++ No changes. ++ ++Version 1.6.22rc02 [May 16, 2016] ++ Removed contrib/timepng from default build; it does not build on platforms ++ that don't supply clock_gettime(). ++ ++Version 1.6.22rc03 [May 17, 2016] ++ Restored contrib/timepng to default build but check for the presence ++ of clock_gettime() in configure.ac and Makefile.am. ++ ++Version 1.6.22 [May 26, 2016] ++ No changes. ++ ++Version 1.6.23beta01 [May 29, 2016] ++ Stop a potential memory leak in png_set_tRNS() (Bug report by Ted Ying). ++ Fixed the progressive reader to handle empty first IDAT chunk properly ++ (patch by Timothy Nikkel). This bug was introduced in libpng-1.6.0 and ++ only affected the libpng16 branch. ++ Added tests in pngvalid.c to check zero-length IDAT chunks in various ++ positions. Fixed the sequential reader to handle these more robustly ++ (John Bowler). ++ ++Version 1.6.23rc01 [June 2, 2016] ++ Corrected progressive read input buffer in pngvalid.c. The previous version ++ the code invariably passed just one byte at a time to libpng. The intent ++ was to pass a random number of bytes in the range 0..511. ++ Moved sse2 prototype from pngpriv.h to contrib/intel/intel_sse.patch. ++ Added missing ")" in pngerror.c (Matt Sarrett). ++ ++Version 1.6.23rc02 [June 4, 2016] ++ Fixed undefined behavior in png_push_save_buffer(). Do not call ++ memcpy() with a null source, even if count is zero (Leon Scroggins III). ++ ++Version 1.6.23 [June 9, 2016] ++ Fixed bad link to RFC2083 in png.5 (Nikola Forro). ++ ++Version 1.6.24beta01 [June 11, 2016] ++ Avoid potential overflow of the PNG_IMAGE_SIZE macro. This macro ++ is not used within libpng, but is used in some of the examples. ++ ++Version 1.6.24beta02 [June 23, 2016] ++ Correct filter heuristic overflow handling. This was broken when the ++ write filter code was moved out-of-line; if there is a single filter and ++ the heuristic sum overflows the calculation of the filtered line is not ++ completed. In versions prior to 1.6 the code was duplicated in-line ++ and the check not performed, so the filter operation completed; however, ++ in the multi-filter case where the sum is performed the 'none' filter would ++ be selected if all the sums overflowed, even if it wasn't in the filter ++ list. The fix to the first problem is simply to provide PNG_SIZE_MAX as ++ the current lmins sum value; this means the sum can never exceed it and ++ overflows silently. A reasonable compiler that does choose to inline ++ the code will simply eliminate the sum check. ++ The fix to the second problem is to use high precision arithmetic (this is ++ implemented in 1.7), however a simple safe fix here is to chose the lowest ++ numbered filter in the list from png_set_filter (this only works if the ++ first problem is also fixed) (John Bowler). ++ Use a more efficient absolute value calculation on SSE2 (Matthieu Darbois). ++ Fixed the case where PNG_IMAGE_BUFFER_SIZE can overflow in the application ++ as a result of the application using an increased 'row_stride'; previously ++ png_image_finish_read only checked for overflow on the base calculation of ++ components. (I.e. it checked for overflow of a 32-bit number on the total ++ number of pixel components in the output format, not the possibly padded row ++ length and not the number of bytes, which for linear formats is twice the ++ number of components.) ++ MSVC does not like '-(unsigned)', so replaced it with 0U-(unsigned) ++ MSVC does not like (uInt) = -(unsigned) (i.e. as an initializer), unless ++ the conversion is explicitly invoked by a cast. ++ Put the SKIP definition in the correct place. It needs to come after the ++ png.h include (see all the other .c files in contrib/libtests) because it ++ depends on PNG_LIBPNG_VER. ++ Removed the three compile warning options from the individual project ++ files into the zlib.props globals. It increases the warning level from 4 ++ to All and adds a list of the warnings that need to be turned off. This is ++ semi-documentary; the intent is to tell libpng users which warnings have ++ been examined and judged non-fixable at present. The warning about ++ structure padding is fixable, but it would be a significant change (moving ++ structure members around). ++ ++Version 1.6.24beta03 [July 4, 2016] ++ Optimized absolute value calculation in filter selection, similar to ++ code in the PAETH decoder in pngrutil.c. Build with PNG_USE_ABS to ++ use this. ++ Added pngcp to the build together with a pngcp.dfa configuration test. ++ Added high resolution timing to pngcp. ++ Added "Common linking failures" section to INSTALL. ++ Relocated misplaced #endif in png.c sRGB profile checking. ++ Fixed two Coverity issues in pngcp.c. ++ ++Version 1.6.24beta04 [July 8, 2016] ++ Avoid filter-selection heuristic sum calculations in cases where only one ++ filter is a candidate for selection. This trades off code size (added ++ private png_setup_*_row_only() functions) for speed. ++ ++Version 1.6.24beta05 [July 13, 2016] ++ Fixed some indentation to comply with our coding style. ++ Added contrib/tools/reindent. ++ ++Version 1.6.24beta06 [July 18, 2016] ++ Fixed more indentation to comply with our coding style. ++ Eliminated unnecessary tests of boolean png_isaligned() vs 0. ++ ++Version 1.6.24rc01 [July 25, 2016] ++ No changes. ++ ++Version 1.6.24rc02 [August 1, 2016] ++ Conditionally compile SSE2 headers in contrib/intel/intel_sse.patch ++ Conditionally compile png_decompress_chunk(). ++ ++Version 1.6.24rc03 [August 2, 2016] ++ Conditionally compile ARM_NEON headers in pngpriv.h ++ Updated contrib/intel/intel_sse.patch ++ ++Version 1.6.24[August 4, 2016] ++ No changes. ++ ++Version 1.6.25beta01 [August 12, 2016] ++ Reject oversized iCCP profile immediately. ++ Cleaned up PNG_DEBUG compile of pngtest.c. ++ Conditionally compile png_inflate(). ++ ++Version 1.6.25beta02 [August 18, 2016] ++ Don't install pngcp; it conflicts with pngcp in the pngtools package. ++ Minor editing of INSTALL, (whitespace, added copyright line) ++ ++Version 1.6.25rc01 [August 24, 2016] ++ No changes. ++ ++Version 1.6.25rc02 [August 29, 2016] ++ Added MIPS support (Mandar Sahastrabuddhe ). ++ Only the UP filter is currently implemented. ++ ++Version 1.6.25rc03 [August 29, 2016] ++ Rebased contrib/intel/intel_sse.patch after the MIPS implementation. ++ ++Version 1.6.25rc04 [August 30, 2016] ++ Added MIPS support for SUB, AVG, and PAETH filters (Mandar Sahastrabuddhe). ++ ++Version 1.6.25rc05 [August 30, 2016] ++ Rebased contrib/intel/intel_sse.patch after the MIPS implementation update.. ++ ++Version 1.6.25 [September 1, 2016] ++ No changes. ++ ++Version 1.6.26beta01 [September 26, 2016] ++ Fixed handling zero length IDAT in pngfix (bug report by Agostino Sarubbo, ++ bugfix by John Bowler). ++ Do not issue a png_error() on read in png_set_pCAL() because png_handle_pCAL ++ has allocated memory that libpng needs to free. ++ Conditionally compile png_set_benign_errors() in pngread.c and pngtest.c ++ Issue a png_benign_error instead of a png_error on ADLER32 mismatch ++ while decoding compressed data chunks. ++ Changed PNG_ZLIB_VERNUM to ZLIB_VERNUM in pngpriv.h, pngstruct.h, and ++ pngrutil.c. ++ If CRC handling of critical chunks has been set to PNG_CRC_QUIET_USE, ++ ignore the ADLER32 checksum in the IDAT chunk as well as the chunk CRCs. ++ Issue png_benign_error() on ADLER32 checksum mismatch instead of png_error(). ++ Add tests/badcrc.png and tests/badadler.png to tests/pngtest. ++ Merged pngtest.c with libpng-1.7.0beta84/pngtest.c ++ ++Version 1.6.26beta02 [October 1, 2016] ++ Updated the documentation about CRC and ADLER32 handling. ++ Quieted 117 warnings from clang-3.8 in pngtrans.c, pngread.c, ++ pngwrite.c, pngunknown.c, and pngvalid.c. ++ Quieted 58 (out of 144) -Wconversion compiler warnings by changing ++ flag definitions in pngpriv.h from 0xnnnn to 0xnnnnU and trivial changes ++ in png.c, pngread.c, and pngwutil.c. ++ ++Version 1.6.26beta03 [October 2, 2016] ++ Removed contrib/libtests/*.orig and *.rej that slipped into the tarballs. ++ Quieted the 86 remaining -Wconversion compiler warnings by ++ revising the png_isaligned() macro and trivial changes in png.c, ++ pngerror.c, pngget.c, pngmem.c, pngset.c, pngrtran.c, pngrutil.c, ++ pngwtran.c, pngwrite.c, and pngwutil.c. ++ ++Version 1.6.26beta04 [October 3, 2016] ++ Quieted (bogus?) clang warnings about "absolute value has no effect" ++ when PNG_USE_ABS is defined. ++ Fixed offsets in contrib/intel/intel_sse.patch ++ ++Version 1.6.26beta05 [October 6, 2016] ++ Changed integer constant 4294967294 to unsigned 4294967294U in pngconf.h ++ to avoid a signed/unsigned compare in the preprocessor. ++ ++Version 1.6.26beta06 [October 7, 2016] ++ Use zlib-1.2.8.1 inflateValidate() instead of inflateReset2() to ++ optionally avoid ADLER32 evaluation. ++ ++Version 1.6.26rc01 [October 12, 2016] ++ No changes. ++ ++Version 1.6.26 [October 20, 2016] ++ Cosmetic change, "ptr != 0" to "ptr != NULL" in png.c and pngrutil.c ++ Despammed email addresses (replaced "@" with " at "). ++ ++Version 1.6.27beta01 [November 2, 2016] ++ Restrict the new ADLER32-skipping to IDAT chunks. It broke iCCP chunk ++ handling: an erroneous iCCP chunk would throw a png_error and reject the ++ entire PNG image instead of rejecting just the iCCP chunk with a warning, ++ if built with zlib-1.2.8.1. ++ ++Version 1.6.27rc01 [December 27, 2016] ++ Control ADLER32 checking with new PNG_IGNORE_ADLER32 option. Fixes ++ an endless loop when handling erroneous ADLER32 checksums; bug ++ introduced in libpng-1.6.26. ++ Removed the use of a macro containing the pre-processor 'defined' ++ operator. It is unclear whether this is valid; a macro that ++ "generates" 'defined' is not permitted, but the use of the word ++ "generates" within the C90 standard seems to imply more than simple ++ substitution of an expression itself containing a well-formed defined ++ operation. ++ Added ARM support to CMakeLists.txt (Andreas Franek). ++ ++Version 1.6.27 [December 29, 2016] ++ Fixed a potential null pointer dereference in png_set_text_2() (bug report ++ and patch by Patrick Keshishian, CVE-2016-10087). ++ ++Version 1.6.28rc01 [January 3, 2017] ++ Fixed arm/aarch64 detection in CMakeLists.txt (Gianfranco Costamagna). ++ Added option to Cmake build allowing a custom location of zlib to be ++ specified in a scenario where libpng is being built as a subproject ++ alongside zlib by another project (Sam Serrels). ++ Changed png_ptr->options from a png_byte to png_uint_32, to accommodate ++ up to 16 options. ++ ++Version 1.6.28rc02 [January 4, 2017] ++ Added "include(GNUInstallDirs)" to CMakeLists.txt (Gianfranco Costamagna). ++ Moved SSE2 optimization code into the main libpng source directory. ++ Configure libpng with "configure --enable-intel-sse" or compile ++ libpng with "-DPNG_INTEL_SSE" in CPPFLAGS to enable it. ++ ++Version 1.6.28rc03 [January 4, 2017] ++ Backed out the SSE optimization and last CMakeLists.txt to allow time for QA. ++ ++Version 1.6.28 [January 5, 2017] ++ No changes. ++ ++Version 1.6.29beta01 [January 12, 2017] ++ Readded "include(GNUInstallDirs)" to CMakeLists.txt (Gianfranco Costamagna). ++ Moved SSE2 optimization code into the main libpng source directory. ++ Configure libpng with "configure --enable-intel-sse" or compile ++ libpng with "-DPNG_INTEL_SSE" in CPPFLAGS to enable it. ++ Simplified conditional compilation in pngvalid.c, for AIX (Michael Felt). ++ ++Version 1.6.29beta02 [February 22, 2017] ++ Avoid conditional directives that break statements in pngrutil.c (Romero ++ Malaquias) ++ The contrib/examples/pngtopng.c recovery code was in the wrong "if" ++ branches; the comments were correct. ++ Added code for PowerPC VSX optimisation (Vadim Barkov). ++ ++Version 1.6.29beta03 [March 1, 2017] ++ Avoid potential overflow of shift operations in png_do_expand() (Aaron Boxer). ++ Change test ZLIB_VERNUM >= 0x1281 to ZLIB_VERNUM >= 0x1290 in pngrutil.c ++ because Solaris 11 distributes zlib-1.2.8.f that is older than 1.2.8.1, ++ as suggested in zlib FAQ, item 24. ++ Suppress clang warnings about implicit sign changes in png.c ++ ++Version 1.6.29 [March 16, 2017] ++ No changes. ++ ++Version 1.6.30beta01 [April 1, 2017] ++ Added missing "$(CPPFLAGS)" to the compile line for c.pic.o in ++ makefile.linux and makefile.solaris-x86 (Cosmin). ++ Revised documentation of png_get_error_ptr() in the libpng manual. ++ Silence clang -Wcomma and const drop warnings (Viktor Szakats). ++ Update Sourceforge URLs in documentation (https instead of http). ++ ++Version 1.6.30beta02 [April 22, 2017] ++ Document need to check for integer overflow when allocating a pixel ++ buffer for multiple rows in contrib/gregbook, contrib/pngminus, ++ example.c, and in the manual (suggested by Jaeseung Choi). This ++ is similar to the bug reported against pngquant in CVE-2016-5735. ++ Removed reference to the obsolete PNG_SAFE_LIMITS macro in the documentation. ++ ++Version 1.6.30beta03 [May 22, 2017] ++ Check for integer overflow in contrib/visupng and contrib/tools/genpng. ++ Do not double evaluate CMAKE_SYSTEM_PROCESSOR in CMakeLists.txt. ++ Test CMAKE_HOST_WIN32 instead of WIN32 in CMakeLists.txt. ++ Fix some URL in documentation. ++ ++Version 1.6.30beta04 [June 7, 2017] ++ Avoid writing an empty IDAT when the last IDAT exactly fills the ++ compression buffer (bug report by Brian Baird). This bug was ++ introduced in libpng-1.6.0. ++ ++Version 1.6.30rc01 [June 14, 2017] ++ No changes. ++ ++Version 1.6.30rc02 [June 25, 2017] ++ Update copyright year in pnglibconf.h, make ltmain.sh executable. ++ Add a reference to the libpng.download site in README. ++ ++Version 1.6.30 [June 28, 2017] ++ No changes. ++ ++Version 1.6.31beta01 [July 5, 2017] ++ Guard the definition of _POSIX_SOURCE in pngpriv.h (AIX already defines it; ++ bug report by Michael Felt). ++ Revised pngpriv.h to work around failure to compile arm/filter_neon.S ++ ("typedef" directive is unrecognized by the assembler). The problem ++ was introduced in libpng-1.6.30beta01. ++ Added "Requires: zlib" to libpng.pc.in (Pieter Neerincx). ++ Added special case for FreeBSD in arm/filter_neon.S (Maya Rashish). ++ ++Version 1.6.31beta02 [July 8, 2017] ++ Added instructions for disabling hardware optimizations in INSTALL. ++ Added "--enable-hardware-optimizations" configuration flag to enable ++ or disable all hardware optimizations with one flag. ++ ++Version 1.6.31beta03 [July 9, 2017] ++ Updated CMakeLists.txt to add INTEL_SSE and MIPS_MSA platforms. ++ Changed "int" to "png_size_t" in intel/filter_sse2.c to prevent ++ possible integer overflow (Bug report by John Bowler). ++ Quieted "declaration after statement" warnings in intel/filter_sse2.c. ++ Added scripts/makefile-linux-opt, which has hardware optimizations enabled. ++ ++Version 1.6.31beta04 [July 11, 2017] ++ Removed one of the GCC-7.1.0 'strict-overflow' warnings that result when ++ integers appear on both sides of a compare. Worked around the others by ++ forcing the strict-overflow setting in the relevant functions to a level ++ where they are not reported (John Bowler). ++ Changed "FALL THROUGH" comments to "FALLTHROUGH" because GCC doesn't like ++ the space. ++ Worked around some C-style casts from (void*) because g++ 5.4.0 objects ++ to them. ++ Increased the buffer size for 'sprint' to pass the gcc 7.1.0 'sprint ++ overflow' check that is on by default with -Wall -Wextra. ++ ++Version 1.6.31beta05 [July 13, 2017] ++ Added eXIf chunk support. ++ ++Version 1.6.31beta06 [July 17, 2017] ++ Added a minimal eXIf chunk (with Orientation and FocalLengthIn35mmFilm ++ tags) to pngtest.png. ++ ++Version 1.6.31beta07 [July 18, 2017] ++ Revised the eXIf chunk in pngtest.png to fix "Bad IFD1 Directory" warning. ++ ++Version 1.6.31rc01 [July 19, 2017] ++ No changes. ++ ++Version 1.6.31rc02 [July 25, 2017] ++ Fixed typo in example.c (png_free_image should be png_image_free) (Bug ++ report by John Smith) ++ ++Version 1.6.31 [July 27, 2017] ++ No changes. ++ ++Version 1.6.32beta01 [July 31, 2017] ++ Avoid possible NULL dereference in png_handle_eXIf when benign_errors ++ are allowed. Avoid leaking the input buffer "eXIf_buf". ++ Eliminated png_ptr->num_exif member from pngstruct.h and added num_exif ++ to arguments for png_get_eXIf() and png_set_eXIf(). ++ Added calls to png_handle_eXIf(() in pngread.c and png_write_eXIf() in ++ pngwrite.c, and made various other fixes to png_write_eXIf(). ++ Changed name of png_get_eXIF and png_set_eXIf() to png_get_eXIf_1() and ++ png_set_eXIf_1(), respectively, to avoid breaking API compatibility ++ with libpng-1.6.31. ++ ++Version 1.6.32beta02 [August 1, 2017] ++ Updated contrib/libtests/pngunknown.c with eXIf chunk. ++ ++Version 1.6.32beta03 [August 2, 2017] ++ Initialized btoa[] in pngstest.c ++ Stop memory leak when returning from png_handle_eXIf() with an error ++ (Bug report from the OSS-fuzz project). ++ ++Version 1.6.32beta04 [August 2, 2017] ++ Replaced local eXIf_buf with info_ptr-eXIf_buf in png_handle_eXIf(). ++ Update libpng.3 and libpng-manual.txt about eXIf functions. ++ ++Version 1.6.32beta05 [August 2, 2017] ++ Restored png_get_eXIf() and png_set_eXIf() to maintain API compatibility. ++ ++Version 1.6.32beta06 [August 2, 2017] ++ Removed png_get_eXIf_1() and png_set_eXIf_1(). ++ ++Version 1.6.32beta07 [August 3, 2017] ++ Check length of all chunks except IDAT against user limit to fix an ++ OSS-fuzz issue (Fixes CVE-2017-12652). ++ ++Version 1.6.32beta08 [August 3, 2017] ++ Check length of IDAT against maximum possible IDAT size, accounting ++ for height, rowbytes, interlacing and zlib/deflate overhead. ++ Restored png_get_eXIf_1() and png_set_eXIf_1(), because strlen(eXIf_buf) ++ does not work (the eXIf chunk data can contain zeroes). ++ ++Version 1.6.32beta09 [August 3, 2017] ++ Require cmake-2.8.8 in CMakeLists.txt. Revised symlink creation, ++ no longer using deprecated cmake LOCATION feature (Clifford Yapp). ++ Fixed five-byte error in the calculation of IDAT maximum possible size. ++ ++Version 1.6.32beta10 [August 5, 2017] ++ Moved chunk-length check into a png_check_chunk_length() private ++ function (Suggested by Max Stepin). ++ Moved bad pngs from tests to contrib/libtests/crashers ++ Moved testing of bad pngs into a separate tests/pngtest-badpngs script ++ Added the --xfail (expected FAIL) option to pngtest.c. It writes XFAIL ++ in the output but PASS for the libpng test. ++ Require cmake-3.0.2 in CMakeLists.txt (Clifford Yapp). ++ Fix "const" declaration info_ptr argument to png_get_eXIf_1() and the ++ num_exif argument to png_get_eXIf_1() (Github Issue 171). ++ ++Version 1.6.32beta11 [August 7, 2017] ++ Added "eXIf" to "chunks_to_ignore[]" in png_set_keep_unknown_chunks(). ++ Added huge_IDAT.png and empty_ancillary_chunks.png to testpngs/crashers. ++ Make pngtest --strict, --relax, --xfail options imply -m (multiple). ++ Removed unused chunk_name parameter from png_check_chunk_length(). ++ Relocated setting free_me for eXIf data, to stop an OSS-fuzz leak. ++ Initialize profile_header[] in png_handle_iCCP() to fix OSS-fuzz issue. ++ Initialize png_ptr->row_buf[0] to 255 in png_read_row() to fix OSS-fuzz UMR. ++ Attempt to fix a UMR in png_set_text_2() to fix OSS-fuzz issue. ++ Increase minimum zlib stream from 9 to 14 in png_handle_iCCP(), to account ++ for the minimum 'deflate' stream, and relocate the test to a point ++ after the keyword has been read. ++ Check that the eXIf chunk has at least 2 bytes and begins with "II" or "MM". ++ ++Version 1.6.32rc01 [August 18, 2017] ++ Added a set of "huge_xxxx_chunk.png" files to contrib/testpngs/crashers, ++ one for each known chunk type, with length = 2GB-1. ++ Check for 0 return from png_get_rowbytes() and added some (size_t) typecasts ++ in contrib/pngminus/*.c to stop some Coverity issues (162705, 162706, ++ and 162707). ++ Renamed chunks in contrib/testpngs/crashers to avoid having files whose ++ names differ only in case; this causes problems with some platforms ++ (github issue #172). ++ ++Version 1.6.32rc02 [August 22, 2017] ++ Added contrib/oss-fuzz directory which contains files used by the oss-fuzz ++ project (https://github.com/google/oss-fuzz/tree/master/projects/libpng). ++ ++Version 1.6.32 [August 24, 2017] ++ No changes. ++ ++Version 1.6.33beta01 [August 28, 2017] ++ Added PNGMINUS_UNUSED macro to contrib/pngminus/p*.c and added missing ++ parenthesis in contrib/pngminus/pnm2png.c (bug report by Christian Hesse). ++ Fixed off-by-one error in png_do_check_palette_indexes() (Bug report ++ by Mick P., Source Forge Issue #269). ++ ++Version 1.6.33beta02 [September 3, 2017] ++ Initialize png_handler.row_ptr in contrib/oss-fuzz/libpng_read_fuzzer.cc ++ to fix shortlived oss-fuzz issue 3234. ++ Compute a larger limit on IDAT because some applications write a deflate ++ buffer for each row (Bug report by Andrew Church). ++ Use current date (DATE) instead of release-date (RDATE) in last ++ changed date of contrib/oss-fuzz files. ++ Enabled ARM support in CMakeLists.txt (Bernd Kuhls). ++ ++Version 1.6.33beta03 [September 14, 2017] ++ Fixed incorrect typecast of some arguments to png_malloc() and ++ png_calloc() that were png_uint_32 instead of png_alloc_size_t ++ (Bug report by "irwir" in Github libpng issue #175). ++ Use pnglibconf.h.prebuilt when building for ANDROID with cmake (Github ++ issue 162, by rcdailey). ++ ++Version 1.6.33rc01 [September 20, 2017] ++ Initialize memory allocated by png_inflate to zero, using memset, to ++ stop an oss-fuzz "use of uninitialized value" detection in png_set_text_2() ++ due to truncated iTXt or zTXt chunk. ++ Initialize memory allocated by png_read_buffer to zero, using memset, to ++ stop an oss-fuzz "use of uninitialized value" detection in ++ png_icc_check_tag_table() due to truncated iCCP chunk. ++ Removed a redundant test (suggested by "irwir" in Github issue #180). ++ ++Version 1.6.33rc02 [September 23, 2017] ++ Added an interlaced version of each file in contrib/pngsuite. ++ Relocate new memset() call in pngrutil.c. ++ Removed more redundant tests (suggested by "irwir" in Github issue #180). ++ Add support for loading images with associated alpha in the Simplified ++ API (Samuel Williams). ++ ++Version 1.6.33 [September 28, 2017] ++ Revert contrib/oss-fuzz/libpng_read_fuzzer.cc to libpng-1.6.32 state. ++ Initialize png_handler.row_ptr in contrib/oss-fuzz/libpng_read_fuzzer.cc ++ Add end_info structure and png_read_end() to the libpng fuzzer. ++ ++Version 1.6.34 [September 29, 2017] ++ Removed contrib/pngsuite/i*.png; some of them caused test failures. ++ ++Version 1.6.35beta01 [March 6, 2018] ++ Restored 21 of the contrib/pngsuite/i*.png, which do not cause test ++ failures. Placed the remainder in contrib/pngsuite/interlaced/i*.png. ++ Added calls to png_set_*() transforms commonly used by browsers to ++ the fuzzer. ++ Removed some unnecessary brackets in pngrtran.c ++ Fixed miscellaneous typos (Patch by github user "luzpaz"). ++ Change "ASM C" to "C ASM" in CMakeLists.txt ++ Fixed incorrect handling of bKGD chunk in sub-8-bit files (Cosmin) ++ Added hardware optimization directories to zip and 7z distributions. ++ Fixed incorrect bitmask for options. ++ Fixed many spelling typos. ++ ++Version 1.6.35beta02 [March 28, 2018] ++ Make png_get_iCCP consistent with man page (allow compression-type argument ++ to be NULL, bug report by Lenard Szolnoki). ++ ++Version 1.6.35 [July 15, 2018] ++ Replaced the remaining uses of png_size_t with size_t (Cosmin) ++ Fixed the calculation of row_factor in png_check_chunk_length ++ (reported by Thuan Pham in SourceForge issue #278) ++ Added missing parentheses to a macro definition ++ (suggested by "irwir" in GitHub issue #216) ++ ++Version 1.6.36 [December 1, 2018] ++ Optimized png_do_expand_palette for ARM processors. ++ Improved performance by around 10-22% on a recent ARM Chromebook. ++ (Contributed by Richard Townsend, ARM Holdings) ++ Fixed manipulation of machine-specific optimization options. ++ (Contributed by Vicki Pfau) ++ Used memcpy instead of manual pointer arithmetic on Intel SSE2. ++ (Contributed by Samuel Williams) ++ Fixed build errors with MSVC on ARM64. ++ (Contributed by Zhijie Liang) ++ Fixed detection of libm in CMakeLists. ++ (Contributed by Cameron Cawley) ++ Fixed incorrect creation of pkg-config file in CMakeLists. ++ (Contributed by Kyle Bentley) ++ Fixed the CMake build on Windows MSYS by avoiding symlinks. ++ Fixed a build warning on OpenBSD. ++ (Contributed by Theo Buehler) ++ Fixed various typos in comments. ++ (Contributed by "luz.paz") ++ Raised the minimum required CMake version from 3.0.2 to 3.1. ++ Removed yet more of the vestigial support for pre-ANSI C compilers. ++ Removed ancient makefiles for ancient systems that have been broken ++ across all previous libpng-1.6.x versions. ++ Removed the Y2K compliance statement and the export control ++ information. ++ Applied various code style and documentation fixes. + + Send comments/corrections/commendations to png-mng-implement at lists.sf.net + (subscription required; visit + https://lists.sourceforge.net/lists/listinfo/png-mng-implement +-to subscribe) +-or to glennrp at users.sourceforge.net +- +-Glenn R-P +-*/ ++to subscribe). +diff --git a/com32/lib/libpng/LICENSE b/com32/lib/libpng/LICENSE +index e5561c22..62ab8e48 100644 +--- a/com32/lib/libpng/LICENSE ++++ b/com32/lib/libpng/LICENSE +@@ -1,111 +1,134 @@ +- +-This copy of the libpng notices is provided for your convenience. In case of +-any discrepancy between this copy and the notices in the file png.h that is +-included in the libpng distribution, the latter shall prevail. +- +-COPYRIGHT NOTICE, DISCLAIMER, and LICENSE: +- +-If you modify libpng you may insert additional notices immediately following +-this sentence. +- +-This code is released under the libpng license. +- +-libpng versions 1.2.6, August 15, 2004, through 1.2.44, June 26, 2010, are +-Copyright (c) 2004, 2006-2009 Glenn Randers-Pehrson, and are +-distributed according to the same disclaimer and license as libpng-1.2.5 +-with the following individual added to the list of Contributing Authors +- +- Cosmin Truta +- +-libpng versions 1.0.7, July 1, 2000, through 1.2.5 - October 3, 2002, are +-Copyright (c) 2000-2002 Glenn Randers-Pehrson, and are +-distributed according to the same disclaimer and license as libpng-1.0.6 +-with the following individuals added to the list of Contributing Authors +- +- Simon-Pierre Cadieux +- Eric S. Raymond +- Gilles Vollant ++COPYRIGHT NOTICE, DISCLAIMER, and LICENSE ++========================================= ++ ++PNG Reference Library License version 2 ++--------------------------------------- ++ ++ * Copyright (c) 1995-2018 The PNG Reference Library Authors. ++ * Copyright (c) 2018 Cosmin Truta. ++ * Copyright (c) 2000-2002, 2004, 2006-2018 Glenn Randers-Pehrson. ++ * Copyright (c) 1996-1997 Andreas Dilger. ++ * Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc. ++ ++The software is supplied "as is", without warranty of any kind, ++express or implied, including, without limitation, the warranties ++of merchantability, fitness for a particular purpose, title, and ++non-infringement. In no even shall the Copyright owners, or ++anyone distributing the software, be liable for any damages or ++other liability, whether in contract, tort or otherwise, arising ++from, out of, or in connection with the software, or the use or ++other dealings in the software, even if advised of the possibility ++of such damage. ++ ++Permission is hereby granted to use, copy, modify, and distribute ++this software, or portions hereof, for any purpose, without fee, ++subject to the following restrictions: ++ ++ 1. The origin of this software must not be misrepresented; you ++ must not claim that you wrote the original software. If you ++ use this software in a product, an acknowledgment in the product ++ documentation would be appreciated, but is not required. ++ ++ 2. Altered source versions must be plainly marked as such, and must ++ not be misrepresented as being the original software. ++ ++ 3. This Copyright notice may not be removed or altered from any ++ source or altered source distribution. ++ ++ ++PNG Reference Library License version 1 (for libpng 0.5 through 1.6.35) ++----------------------------------------------------------------------- ++ ++libpng versions 1.0.7, July 1, 2000 through 1.6.35, July 15, 2018 are ++Copyright (c) 2000-2002, 2004, 2006-2018 Glenn Randers-Pehrson, are ++derived from libpng-1.0.6, and are distributed according to the same ++disclaimer and license as libpng-1.0.6 with the following individuals ++added to the list of Contributing Authors: ++ ++ Simon-Pierre Cadieux ++ Eric S. Raymond ++ Mans Rullgard ++ Cosmin Truta ++ Gilles Vollant ++ James Yu ++ Mandar Sahastrabuddhe ++ Google Inc. ++ Vadim Barkov + + and with the following additions to the disclaimer: + +- There is no warranty against interference with your enjoyment of the +- library or against infringement. There is no warranty that our +- efforts or the library will fulfill any of your particular purposes +- or needs. This library is provided with all faults, and the entire +- risk of satisfactory quality, performance, accuracy, and effort is with +- the user. ++ There is no warranty against interference with your enjoyment of ++ the library or against infringement. There is no warranty that our ++ efforts or the library will fulfill any of your particular purposes ++ or needs. This library is provided with all faults, and the entire ++ risk of satisfactory quality, performance, accuracy, and effort is ++ with the user. ++ ++Some files in the "contrib" directory and some configure-generated ++files that are distributed with libpng have other copyright owners, and ++are released under other open source licenses. + + libpng versions 0.97, January 1998, through 1.0.6, March 20, 2000, are +-Copyright (c) 1998, 1999 Glenn Randers-Pehrson, and are +-distributed according to the same disclaimer and license as libpng-0.96, +-with the following individuals added to the list of Contributing Authors: ++Copyright (c) 1998-2000 Glenn Randers-Pehrson, are derived from ++libpng-0.96, and are distributed according to the same disclaimer and ++license as libpng-0.96, with the following individuals added to the ++list of Contributing Authors: + +- Tom Lane +- Glenn Randers-Pehrson +- Willem van Schaik ++ Tom Lane ++ Glenn Randers-Pehrson ++ Willem van Schaik + + libpng versions 0.89, June 1996, through 0.96, May 1997, are +-Copyright (c) 1996, 1997 Andreas Dilger +-Distributed according to the same disclaimer and license as libpng-0.88, +-with the following individuals added to the list of Contributing Authors: ++Copyright (c) 1996-1997 Andreas Dilger, are derived from libpng-0.88, ++and are distributed according to the same disclaimer and license as ++libpng-0.88, with the following individuals added to the list of ++Contributing Authors: + +- John Bowler +- Kevin Bracey +- Sam Bushell +- Magnus Holmgren +- Greg Roelofs +- Tom Tanner ++ John Bowler ++ Kevin Bracey ++ Sam Bushell ++ Magnus Holmgren ++ Greg Roelofs ++ Tom Tanner ++ ++Some files in the "scripts" directory have other copyright owners, ++but are released under this license. + + libpng versions 0.5, May 1995, through 0.88, January 1996, are +-Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc. ++Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc. + + For the purposes of this copyright and license, "Contributing Authors" + is defined as the following set of individuals: + +- Andreas Dilger +- Dave Martindale +- Guy Eric Schalnat +- Paul Schmidt +- Tim Wegner +- +-The PNG Reference Library is supplied "AS IS". The Contributing Authors +-and Group 42, Inc. disclaim all warranties, expressed or implied, +-including, without limitation, the warranties of merchantability and of +-fitness for any purpose. The Contributing Authors and Group 42, Inc. +-assume no liability for direct, indirect, incidental, special, exemplary, +-or consequential damages, which may result from the use of the PNG +-Reference Library, even if advised of the possibility of such damage. ++ Andreas Dilger ++ Dave Martindale ++ Guy Eric Schalnat ++ Paul Schmidt ++ Tim Wegner ++ ++The PNG Reference Library is supplied "AS IS". The Contributing ++Authors and Group 42, Inc. disclaim all warranties, expressed or ++implied, including, without limitation, the warranties of ++merchantability and of fitness for any purpose. The Contributing ++Authors and Group 42, Inc. assume no liability for direct, indirect, ++incidental, special, exemplary, or consequential damages, which may ++result from the use of the PNG Reference Library, even if advised of ++the possibility of such damage. + + Permission is hereby granted to use, copy, modify, and distribute this + source code, or portions hereof, for any purpose, without fee, subject + to the following restrictions: + +-1. The origin of this source code must not be misrepresented. +- +-2. Altered versions must be plainly marked as such and must not +- be misrepresented as being the original source. +- +-3. This Copyright notice may not be removed or altered from any +- source or altered source distribution. +- +-The Contributing Authors and Group 42, Inc. specifically permit, without +-fee, and encourage the use of this source code as a component to +-supporting the PNG file format in commercial products. If you use this +-source code in a product, acknowledgment is not required but would be +-appreciated. +- +- +-A "png_get_copyright" function is available, for convenient use in "about" +-boxes and the like: +- +- printf("%s",png_get_copyright(NULL)); ++ 1. The origin of this source code must not be misrepresented. + +-Also, the PNG logo (in PNG format, of course) is supplied in the +-files "pngbar.png" and "pngbar.jpg (88x31) and "pngnow.png" (98x31). ++ 2. Altered versions must be plainly marked as such and must not ++ be misrepresented as being the original source. + +-Libpng is OSI Certified Open Source Software. OSI Certified Open Source is a +-certification mark of the Open Source Initiative. ++ 3. This Copyright notice may not be removed or altered from any ++ source or altered source distribution. + +-Glenn Randers-Pehrson +-glennrp at users.sourceforge.net +-June 26, 2010 ++The Contributing Authors and Group 42, Inc. specifically permit, ++without fee, and encourage the use of this source code as a component ++to supporting the PNG file format in commercial products. If you use ++this source code in a product, acknowledgment is not required but would ++be appreciated. +diff --git a/com32/lib/libpng/README b/com32/lib/libpng/README +index ff7ac1f1..e41e0f54 100644 +--- a/com32/lib/libpng/README ++++ b/com32/lib/libpng/README +@@ -1,19 +1,16 @@ +-README for libpng version 1.2.44 - June 26, 2010 (shared library 12.0) +-See the note about version numbers near the top of png.h ++README for libpng version 1.6.36 - December 1, 2018 ++=================================================== + ++See the note about version numbers near the top of png.h. + See INSTALL for instructions on how to install libpng. + +-Libpng comes in several distribution formats. Get libpng-*.tar.gz, +-libpng-*.tar.xz, or libpng-*.tar.bz2 if you want UNIX-style line +-endings in the text files, or lpng*.7z or lpng*.zip if you want DOS-style +-line endings. You can get UNIX-style line endings from the *.zip file +-by using "unzip -a" but there seems to be no simple way to recover +-UNIX-style line endings from the *.7z file. The *.tar.xz file is +-recommended for *NIX users instead. ++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 +-extensive use and testing since mid-1995. By late 1997 it had ++fact that it's the first release fool you. The libpng library has been ++in extensive use and testing since mid-1995. By late 1997 it had + finally gotten to the stage where there hadn't been significant + changes to the API in some time, and people have a bad feeling about + libraries with versions < 1.0. Version 1.0.0 was released in +@@ -27,18 +24,25 @@ earlier versions if you are using a shared library. The type of the + 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 the 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_ and + png_get_ 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 +@@ -57,101 +61,71 @@ the library action on the detection of chunk CRC errors. It is possible + to set different actions based on whether the CRC error occurred in a + critical or an ancillary chunk. + +-The changes made to the library, and bugs fixed are based on discussions +-on the png-mng-implement mailing list and not on material submitted +-privately to Guy, Andreas, or Glenn. They will forward any good +-suggestions to the list. +- +-For a detailed description on using libpng, read libpng.txt. For +-examples of libpng in a program, see example.c and pngtest.c. For usage +-information and restrictions (what little they are) on libpng, see +-png.h. For a description on using zlib (the compression library used by +-libpng) and zlib's restrictions, see zlib.h ++For a detailed description on using libpng, read libpng-manual.txt. ++For examples of libpng in a program, see example.c and pngtest.c. For ++usage information and restrictions (what little they are) on libpng, ++see png.h. For a description on using zlib (the compression library ++used by libpng) and zlib's restrictions, see zlib.h + + I have included a general makefile, as well as several machine and +-compiler specific ones, but you may have to modify one for your own needs. ++compiler specific ones, but you may have to modify one for your own ++needs. + + You should use zlib 1.0.4 or later to run this, but it MAY work with + versions as old as zlib 0.95. Even so, there are bugs in older zlib + versions which can cause the output of invalid compression streams for +-some images. You will definitely need zlib 1.0.4 or later if you are +-taking advantage of the MS-DOS "far" structure allocation for the small +-and medium memory models. You should also note that zlib is a +-compression library that is useful for more things than just PNG files. +-You can use zlib as a drop-in replacement for fread() and fwrite() if +-you are so inclined. ++some images. ++ ++You should also note that zlib is a compression library that is useful ++for more things than just PNG files. You can use zlib as a drop-in ++replacement for fread() and fwrite(), if you are so inclined. + + zlib should be available at the same place that libpng is, or at +-ftp://ftp.simplesystems.org/pub/png/src/ ++https://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/pngdocs.html ++these at http://www.libpng.org/pub/png/pngdocs.html . + +-This code is currently being archived at libpng.sf.net in the +-[DOWNLOAD] area, and on CompuServe, Lib 20 (PNG SUPPORT) +-at GO GRAPHSUP. If you can't find it in any of those places, +-e-mail me, and I'll help you find it. ++This code is currently being archived at libpng.sourceforge.io in the ++[DOWNLOAD] area, and at http://libpng.download/src . + +-If you have any code changes, requests, problems, etc., please e-mail +-them to me. Also, I'd appreciate any make files or project files, +-and any modifications you needed to make to get libpng to compile, +-along with a #define variable to tell what compiler/system you are on. +-If you needed to add transformations to libpng, or wish libpng would +-provide the image in a different way, drop me a note (and code, if +-possible), so I can consider supporting the transformation. +-Finally, if you get any warning messages when compiling libpng +-(note: not zlib), and they are easy to fix, I'd appreciate the +-fix. Please mention "libpng" somewhere in the subject line. Thanks. +- +-This release was created and will be supported by myself (of course +-based in a large way on Guy's and Andreas' earlier work), and the PNG ++This release, based in a large way on Glenn's, Guy's and Andreas' ++earlier work, was created and will be supported by myself and the PNG + development group. + +-Send comments/corrections/commendations to png-mng-implement at lists.sf.net +-(subscription required; visit ++Send comments/corrections/commendations to png-mng-implement at ++lists.sourceforge.net (subscription required; visit + https://lists.sourceforge.net/lists/listinfo/png-mng-implement +-to subscribe) or to glennrp at users.sourceforge.net +- +-You can't reach Guy, the original libpng author, at the addresses +-given in previous versions of this document. He and Andreas will +-read mail addressed to the png-mng-implement list, however. ++to subscribe). + +-Please do not send general questions about PNG. Send them to +-the (png-mng-misc at lists.sourceforge.net, subscription required, visit ++Send general questions about the PNG specification to png-mng-misc ++at lists.sourceforge.net (subscription required; visit + https://lists.sourceforge.net/lists/listinfo/png-mng-misc to +-subscribe). On the other hand, please do not send libpng questions to +-that address, send them to me or to the png-mng-implement list. I'll +-get them in the end anyway. If you have a question about something +-in the PNG specification that is related to using libpng, send it +-to me. Send me any questions that start with "I was using libpng, +-and ...". If in doubt, send questions to me. I'll bounce them +-to others, if necessary. +- +-Please do not send suggestions on how to change PNG. We have +-been discussing PNG for twelve years now, and it is official and +-finished. If you have suggestions for libpng, however, I'll +-gladly listen. Even if your suggestion is not used immediately, +-it may be used later. ++subscribe). + + Files in this distribution: + + ANNOUNCE => Announcement of this version, with recent changes ++ AUTHORS => List of contributing authors + CHANGES => Description of changes between libpng versions + KNOWNBUG => List of known bugs and deficiencies + LICENSE => License to use and redistribute libpng + README => This file + TODO => Things not implemented in the current library +- Y2KINFO => Statement of Y2K compliance ++ TRADEMARK => Trademark information + example.c => Example code for using libpng functions +- libpng-*-*-diff.txt => Diff from previous release +- libpng.3 => manual page for libpng (includes libpng.txt) +- libpng.txt => Description of libpng and its functions ++ libpng.3 => manual page for libpng (includes libpng-manual.txt) ++ libpng-manual.txt => Description of libpng and its functions + libpngpf.3 => manual page for libpng's private functions + png.5 => manual page for the PNG format + png.c => Basic interface functions common to library +- png.h => Library function and interface declarations +- pngconf.h => System specific library configuration ++ png.h => Library function and interface declarations (public) ++ pngpriv.h => Library function and interface declarations (private) ++ pngconf.h => System specific library configuration (public) ++ pngstruct.h => png_struct declaration (private) ++ pnginfo.h => png_info struct declaration (private) ++ pngdebug.h => debugging macros (private) + pngerror.c => Error/warning message I/O functions + pngget.c => Functions for retrieving info from struct + pngmem.c => Memory handling functions +@@ -170,106 +144,40 @@ Files in this distribution: + pngwrite.c => High-level write functions + pngwtran.c => Write data transformations + pngwutil.c => Write utility functions ++ arm => Contains optimized code for the ARM platform ++ powerpc => Contains optimized code for the PowerPC platform + contrib => Contributions ++ arm-neon => Optimized code for ARM-NEON platform ++ powerpc-vsx => Optimized code for POWERPC-VSX platform ++ 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 +- pngminim => Simple pnm2pngm and png2pnmm programs +- pngminus => Simple pnm2png and png2pnm programs +- pngsuite => Test images +- visupng => Contains a MSVC workspace for VisualPng ++ libtests => Test programs ++ mips-msa => Optimized code for MIPS-MSA platform ++ pngminim => Minimal decoder, encoder, and progressive decoder ++ programs demonstrating use of pngusr.dfa ++ pngminus => Simple pnm2png and png2pnm programs ++ pngsuite => Test images ++ testpngs ++ tools => Various tools ++ visupng => Contains a MSVC workspace for VisualPng ++ intel => Optimized code for INTEL-SSE2 platform ++ mips => Optimized code for MIPS platform + projects => Contains project files and workspaces for + building a DLL +- beos => Contains a Beos workspace for building libpng +- c5builder => Contains a Borland workspace for building +- libpng and zlib +- netware.txt => Contains instructions for downloading a set +- of project files for building libpng and +- zlib on Netware. +- visualc6 => Contains a Microsoft Visual C++ (MSVC) ++ owatcom => Contains a WATCOM project for building libpng ++ visualc71 => Contains a Microsoft Visual C++ (MSVC) ++ workspace for building libpng and zlib ++ vstudio => Contains a Microsoft Visual C++ (MSVC) + workspace for building libpng and zlib +- wince.txt => Contains instructions for downloading a +- Microsoft Visual C++ (Windows CD Toolkit) +- workspace for building libpng and zlib on +- WindowsCE +- xcode => Contains xcode project files + scripts => Directory containing scripts for building libpng: +- descrip.mms => VMS makefile for MMS or MMK +- makefile.std => Generic UNIX makefile (cc, creates static +- libpng.a) +- makefile.elf => Linux/ELF gcc makefile symbol versioning, +- creates libpng12.so.0.1.2.44) +- makefile.linux => Linux/ELF makefile (gcc, creates +- libpng12.so.0.1.2.44) +- makefile.gcmmx => Linux/ELF makefile (gcc, creates +- libpng12.so.0.1.2.44, previously +- used assembler code tuned for Intel MMX +- platform) +- makefile.gcc => Generic makefile (gcc, creates static +- libpng.a) +- makefile.knr => Archaic UNIX Makefile that converts files +- with ansi2knr (Requires ansi2knr.c from +- ftp://ftp.cs.wisc.edu/ghost) +- makefile.aix => AIX makefile +- makefile.cygwin => Cygwin/gcc makefile +- makefile.darwin => Darwin makefile +- makefile.dec => DEC Alpha UNIX makefile +- makefile.freebsd => FreeBSD makefile +- makefile.hpgcc => HPUX makefile using gcc +- makefile.hpux => HPUX (10.20 and 11.00) makefile +- makefile.hp64 => HPUX (10.20 and 11.00) makefile, 64 bit +- makefile.ibmc => IBM C/C++ version 3.x for Win32 and OS/2 +- (static) +- makefile.intel => Intel C/C++ version 4.0 and later +- libpng.icc => Project file, IBM VisualAge/C++ 4.0 or later +- makefile.netbsd => NetBSD/cc makefile, makes libpng.so. +- makefile.ne12bsd => NetBSD/cc makefile, makes libpng12.so +- makefile.openbsd => OpenBSD makefile +- makefile.sgi => Silicon Graphics IRIX (cc, creates static lib) +- makefile.sggcc => Silicon Graphics +- (gcc, creates libpng12.so.0.1.2.44) +- makefile.sunos => Sun makefile +- makefile.solaris => Solaris 2.X makefile +- (gcc, creates libpng12.so.0.1.2.44) +- makefile.so9 => Solaris 9 makefile +- (gcc, creates libpng12.so.0.1.2.44) +- makefile.32sunu => Sun Ultra 32-bit makefile +- makefile.64sunu => Sun Ultra 64-bit makefile +- makefile.sco => For SCO OSr5 ELF and Unixware 7 with Native cc +- makefile.mips => MIPS makefile +- makefile.acorn => Acorn makefile +- makefile.amiga => Amiga makefile +- smakefile.ppc => AMIGA smakefile for SAS C V6.58/7.00 PPC +- compiler (Requires SCOPTIONS, copied from +- scripts/SCOPTIONS.ppc) +- makefile.atari => Atari makefile +- makefile.beos => BEOS makefile for X86 +- makefile.bor => Borland makefile (uses bcc) +- makefile.bc32 => 32-bit Borland C++ (all modules compiled in C mode) +- makefile.tc3 => Turbo C 3.0 makefile +- makefile.dj2 => DJGPP 2 makefile +- makefile.msc => Microsoft C makefile +- makefile.vcawin32=> makefile for Microsoft Visual C++ 5.0 and +- later (previously used assembler code tuned +- for Intel MMX platform) +- makefile.vcwin32 => makefile for Microsoft Visual C++ 4.0 and +- later (does not use assembler code) +- makefile.os2 => OS/2 Makefile (gcc and emx, requires pngos2.def) +- pngos2.def => OS/2 module definition file used by makefile.os2 +- makefile.watcom => Watcom 10a+ Makefile, 32-bit flat memory model +- makevms.com => VMS build script +- SCOPTIONS.ppc => Used with smakefile.ppc +- +-Good luck, and happy coding. +- +--Glenn Randers-Pehrson (current maintainer, since 1998) +- Internet: glennrp at users.sourceforge.net ++ (see scripts/README.txt for the list of scripts) + +--Andreas Eric Dilger (former maintainer, 1996-1997) +- Internet: adilger at enel.ucalgary.ca +- Web: http://members.shaw.ca/adilger/ ++Good luck, and happy coding! + +--Guy Eric Schalnat (original author and former maintainer, 1995-1996) +- (formerly of Group 42, Inc) +- Internet: gschal at infinet.com ++ * Cosmin Truta (current maintainer, since 2018) ++ * Glenn Randers-Pehrson (former maintainer, 1998-2018) ++ * Andreas Eric Dilger (former maintainer, 1996-1997) ++ * Guy Eric Schalnat (original author and former maintainer, 1995-1996) ++ (formerly of Group 42, Inc.) +diff --git a/com32/lib/libpng/TODO b/com32/lib/libpng/TODO +index face7658..562dab06 100644 +--- a/com32/lib/libpng/TODO ++++ b/com32/lib/libpng/TODO +@@ -1,25 +1,23 @@ + TODO - list of things to do for libpng: + +-Final bug fixes. +-Improve API by hiding the png_struct and png_info structs. +-Finish work on the no-floating-point version (including gamma compensation) +-Better C++ wrapper/full C++ implementation? +-Fix problem with C++ and EXTERN "C". +-cHRM transformation. +-Improve setjmp/longjmp usage or remove it in favor of returning error codes. +-Add "grayscale->palette" transformation and "palette->grayscale" detection. +-Improved dithering. +-Multi-lingual error and warning message support. +-Complete sRGB transformation (presently it simply uses gamma=0.45455). +-Man pages for function calls. +-Better documentation. +-Better filter selection +- (counting huffman bits/precompression? filter inertia? filter costs?). +-Histogram creation. +-Text conversion between different code pages (Latin-1 -> Mac and DOS). +-Should we always malloc 2^bit_depth PLTE/tRNS/hIST entries for safety? +-Build gamma tables using fixed point (and do away with floating point entirely). +-Use greater precision when changing to linear gamma for compositing against +- background and doing rgb-to-gray transformation. +-Investigate pre-incremented loop counters and other loop constructions. +-Add interpolated method of handling interlacing. ++* Fix all defects (duh!) ++* Better C++ wrapper / full C++ implementation (?) ++* Fix the problems with C++ and 'extern "C"'. ++* cHRM transformation. ++* Palette creation. ++* "grayscale->palette" transformation and "palette->grayscale" detection. ++* Improved dithering. ++* Multi-lingual error and warning message support. ++* Complete sRGB transformation. (Currently it simply uses gamma=0.45455.) ++* Man pages for function calls. ++* Better documentation. ++* Better filter selection ++ (e.g., counting huffman bits/precompression; filter inertia; filter costs). ++* Histogram creation. ++* Text conversion between different code pages (e.g., Latin-1 -> Mac). ++* Avoid building gamma tables whenever possible. ++* Greater precision in changing to linear gamma for compositing against ++ background, and in doing rgb-to-gray transformations. ++* Investigate pre-incremented loop counters and other loop constructions. ++* Interpolated method of handling interlacing. ++* More validations for libpng transformations. +diff --git a/com32/lib/libpng/example.c b/com32/lib/libpng/example.c +index 49b87242..2e2afaaf 100644 +--- a/com32/lib/libpng/example.c ++++ b/com32/lib/libpng/example.c +@@ -2,16 +2,20 @@ + #if 0 /* in case someone actually tries to compile this */ + + /* example.c - an example of using libpng +- * Last changed in libpng 1.2.37 [June 4, 2009] +- * This file has been placed in the public domain by the authors. +- * Maintained 1998-2010 Glenn Randers-Pehrson +- * Maintained 1996, 1997 Andreas Dilger) +- * Written 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) ++ * ++ * Maintained 2018 Cosmin Truta ++ * Maintained 1998-2016 Glenn Randers-Pehrson ++ * Maintained 1996-1997 Andreas Dilger ++ * Written 1995-1996 Guy Eric Schalnat, Group 42, Inc. ++ * ++ * To the extent possible under law, the authors have waived ++ * all copyright and related or neighboring rights to this file. ++ * This work is published from: United States, Canada. + */ + + /* This is an example of how to use libpng to read and write PNG files. +- * The file libpng.txt is much more verbose then this. If you have not +- * read it, do so first. This was designed to be a starting point of an ++ * The file libpng-manual.txt is much more verbose then this. If you have ++ * not read it, do so first. This was designed to be a starting point of an + * implementation. This is not officially part of libpng, is hereby placed + * in the public domain, and therefore does not require a copyright notice. + * +@@ -22,23 +26,209 @@ + * see also the programs in the contrib directory. + */ + +-#include "png.h" ++/* The simple, but restricted approach to reading a PNG file or data stream ++ * requires just two function calls, as in the following complete program. ++ * Writing a file needs just one function call, so long as the data has an ++ * appropriate layout. ++ * ++ * The following code reads PNG image data from a file and writes it, in a ++ * potentially new format, to a new file. While this code will compile, there ++ * is minimal (insufficient) error checking. For a more realistic version, ++ * see contrib/examples/pngtopng.c ++ */ ++ ++#include ++#include ++#include ++#include ++#include ++#include ++ ++int main(int argc, const char **argv) ++{ ++ if (argc == 3) ++ { ++ png_image image; /* The control structure used by libpng */ ++ ++ /* Initialize the 'png_image' structure. */ ++ memset(&image, 0, (sizeof image)); ++ image.version = PNG_IMAGE_VERSION; ++ ++ /* The first argument is the file to read: */ ++ if (png_image_begin_read_from_file(&image, argv[1]) != 0) ++ { ++ png_bytep buffer; ++ ++ /* Set the format in which to read the PNG file; this code chooses a ++ * simple sRGB format with a non-associated alpha channel, adequate to ++ * store most images. ++ */ ++ image.format = PNG_FORMAT_RGBA; ++ ++ /* Now allocate enough memory to hold the image in this format; the ++ * PNG_IMAGE_SIZE macro uses the information about the image (width, ++ * height and format) stored in 'image'. ++ */ ++ buffer = malloc(PNG_IMAGE_SIZE(image)); ++ ++ /* If enough memory was available, read the image in the desired ++ * format, then write the result out to the new file. 'background' is ++ * not necessary when reading the image, because the alpha channel is ++ * preserved; if it were to be removed, for example if we requested ++ * PNG_FORMAT_RGB, then either a solid background color would have to ++ * be supplied, or the output buffer would have to be initialized to ++ * the actual background of the image. ++ * ++ * The fourth argument to png_image_finish_read is the 'row_stride' - ++ * this is the number of components allocated for the image in each ++ * row. It has to be at least as big as the value returned by ++ * PNG_IMAGE_ROW_STRIDE, but if you just allocate space for the ++ * default, minimum size, using PNG_IMAGE_SIZE as above, you can pass ++ * zero. ++ * ++ * The final argument is a pointer to a buffer for the colormap; ++ * colormaps have exactly the same format as a row of image pixels ++ * (so you choose what format to make the colormap by setting ++ * image.format). A colormap is only returned if ++ * PNG_FORMAT_FLAG_COLORMAP is also set in image.format, so in this ++ * case NULL is passed as the final argument. If you do want to force ++ * all images into an index/color-mapped format, then you can use: ++ * ++ * PNG_IMAGE_COLORMAP_SIZE(image) ++ * ++ * to find the maximum size of the colormap in bytes. ++ */ ++ if (buffer != NULL && ++ png_image_finish_read(&image, NULL/*background*/, buffer, ++ 0/*row_stride*/, NULL/*colormap*/) != 0) ++ { ++ /* Now write the image out to the second argument. In the write ++ * call 'convert_to_8bit' allows 16-bit data to be squashed down to ++ * 8 bits; this isn't necessary here because the original read was ++ * to the 8-bit format. ++ */ ++ if (png_image_write_to_file(&image, argv[2], 0/*convert_to_8bit*/, ++ buffer, 0/*row_stride*/, NULL/*colormap*/) != 0) ++ { ++ /* The image has been written successfully. */ ++ exit(0); ++ } ++ } ++ else ++ { ++ /* Calling png_image_free is optional unless the simplified API was ++ * not run to completion. In this case, if there wasn't enough ++ * memory for 'buffer', we didn't complete the read, so we must ++ * free the image: ++ */ ++ if (buffer == NULL) ++ png_image_free(&image); ++ else ++ free(buffer); ++ } ++ ++ /* Something went wrong reading or writing the image. libpng stores a ++ * textual message in the 'png_image' structure: ++ */ ++ fprintf(stderr, "pngtopng: error: %s\n", image.message); ++ exit(1); ++ } ++ ++ fprintf(stderr, "pngtopng: usage: pngtopng input-file output-file\n"); ++ exit(2); ++} ++ ++/* That's it ;-) Of course you probably want to do more with PNG files than ++ * just converting them all to 32-bit RGBA PNG files; you can do that between ++ * the call to png_image_finish_read and png_image_write_to_file. You can also ++ * ask for the image data to be presented in a number of different formats. ++ * You do this by simply changing the 'format' parameter set before allocating ++ * the buffer. ++ * ++ * The format parameter consists of five flags that define various aspects of ++ * the image. You can simply add these together to get the format, or you can ++ * use one of the predefined macros from png.h (as above): ++ * ++ * PNG_FORMAT_FLAG_COLOR: if set, the image will have three color components ++ * per pixel (red, green and blue); if not set, the image will just have one ++ * luminance (grayscale) component. ++ * ++ * PNG_FORMAT_FLAG_ALPHA: if set, each pixel in the image will have an ++ * additional alpha value; a linear value that describes the degree the ++ * image pixel covers (overwrites) the contents of the existing pixel on the ++ * display. ++ * ++ * PNG_FORMAT_FLAG_LINEAR: if set, the components of each pixel will be ++ * returned as a series of 16-bit linear values; if not set, the components ++ * will be returned as a series of 8-bit values encoded according to the ++ * sRGB standard. The 8-bit format is the normal format for images intended ++ * for direct display, because almost all display devices do the inverse of ++ * the sRGB transformation to the data they receive. The 16-bit format is ++ * more common for scientific data and image data that must be further ++ * processed; because it is linear, simple math can be done on the component ++ * values. Regardless of the setting of this flag, the alpha channel is ++ * always linear, although it will be 8 bits or 16 bits wide as specified by ++ * the flag. ++ * ++ * PNG_FORMAT_FLAG_BGR: if set, the components of a color pixel will be ++ * returned in the order blue, then green, then red. If not set, the pixel ++ * components are in the order red, then green, then blue. ++ * ++ * PNG_FORMAT_FLAG_AFIRST: if set, the alpha channel (if present) precedes the ++ * color or grayscale components. If not set, the alpha channel follows the ++ * components. ++ * ++ * You do not have to read directly from a file. You can read from memory or, ++ * on systems that support it, from a FILE*. This is controlled by ++ * the particular png_image_read_from_ function you call at the start. ++ * Likewise, on write, you can write to a FILE* if your system supports it. ++ * Check the macro PNG_STDIO_SUPPORTED to see if stdio support has been ++ * included in your libpng build. ++ * ++ * If you read 16-bit (PNG_FORMAT_FLAG_LINEAR) data, you may need to write it ++ * in the 8-bit format for display. You do this by setting the convert_to_8bit ++ * flag to 'true'. ++ * ++ * Don't repeatedly convert between the 8-bit and 16-bit forms. There is ++ * significant data loss when 16-bit data is converted to the 8-bit encoding, ++ * and the current libpng implementation of conversion to 16-bit is also ++ * significantly lossy. The latter will be fixed in the future, but the former ++ * is unavoidable - the 8-bit format just doesn't have enough resolution. ++ */ ++ ++/* If your program needs more information from the PNG data it reads, or if you ++ * need to do more complex transformations, or minimize transformations, on the ++ * data you read, then you must use one of the several lower level libpng ++ * interfaces. ++ * ++ * All these interfaces require that you do your own error handling - your ++ * program must be able to arrange for control to return to your own code, any ++ * time libpng encounters a problem. There are several ways to do this, but ++ * the standard way is to use the interface to establish a return ++ * point within your own code. You must do this if you do not use the ++ * simplified interface (above). ++ * ++ * The first step is to include the header files you need, including the libpng ++ * header file. Include any standard headers and feature test macros your ++ * program requires before including png.h: ++ */ ++#include + + /* The png_jmpbuf() macro, used in error handling, became available in + * libpng version 1.0.6. If you want to be able to run your code with older + * versions of libpng, you must define the macro yourself (but only if it +- * is not already defined by libpng!). ++ * is not already defined by libpng!) + */ + + #ifndef png_jmpbuf +-# define png_jmpbuf(png_ptr) ((png_ptr)->jmpbuf) ++# define png_jmpbuf(png_ptr) ((png_ptr)->png_jmpbuf) + #endif + + /* Check to see if a file is a PNG file using png_sig_cmp(). png_sig_cmp() +- * returns zero if the image is a PNG and nonzero if it isn't a PNG. ++ * returns zero if the image is a PNG, and nonzero otherwise. + * + * The function check_if_png() shown here, but not used, returns nonzero (true) +- * if the file can be opened and is a PNG, 0 (false) otherwise. ++ * if the file can be opened and is a PNG, and 0 (false) otherwise. + * + * If this call is successful, and you are going to keep the file open, + * you should call png_set_sig_bytes(png_ptr, PNG_BYTES_TO_CHECK); once +@@ -51,7 +241,7 @@ + * + * Many applications already read the first 2 or 4 bytes from the start + * of the image to determine the file type, so it would be easiest just +- * to pass the bytes to png_sig_cmp() or even skip that if you know ++ * to pass the bytes to png_sig_cmp(), or even skip that if you know + * you have a PNG file, and call png_set_sig_bytes(). + */ + #define PNG_BYTES_TO_CHECK 4 +@@ -63,14 +253,14 @@ int check_if_png(char *file_name, FILE **fp) + if ((*fp = fopen(file_name, "rb")) == NULL) + return 0; + +- /* Read in some of the signature bytes */ ++ /* Read in some of the signature bytes. */ + if (fread(buf, 1, PNG_BYTES_TO_CHECK, *fp) != PNG_BYTES_TO_CHECK) + return 0; + + /* Compare the first PNG_BYTES_TO_CHECK bytes of the signature. +- Return nonzero (true) if they match */ +- +- return(!png_sig_cmp(buf, (png_size_t)0, PNG_BYTES_TO_CHECK)); ++ * Return nonzero (true) if they match. ++ */ ++ return(!png_sig_cmp(buf, 0, PNG_BYTES_TO_CHECK)); + } + + /* Read a PNG file. You may want to return an error code if the read +@@ -80,11 +270,11 @@ int check_if_png(char *file_name, FILE **fp) + * some or all of the magic bytes read - see comments above). + */ + #ifdef open_file /* prototype 1 */ +-void read_png(char *file_name) /* We need to open the file */ ++void read_png(char *file_name) /* We need to open the file */ + { + png_structp png_ptr; + png_infop info_ptr; +- unsigned int sig_read = 0; ++ int sig_read = 0; + png_uint_32 width, height; + int bit_depth, color_type, interlace_type; + FILE *fp; +@@ -93,7 +283,7 @@ void read_png(char *file_name) /* We need to open the file */ + return (ERROR); + + #else no_open_file /* prototype 2 */ +-void read_png(FILE *fp, unsigned int sig_read) /* File is already open */ ++void read_png(FILE *fp, int sig_read) /* File is already open */ + { + png_structp png_ptr; + png_infop info_ptr; +@@ -105,10 +295,10 @@ void read_png(FILE *fp, unsigned int sig_read) /* File is already open */ + * functions. If you want to use the default stderr and longjump method, + * you can supply NULL for the last three parameters. We also supply the + * the compiler header file version, so that we know if the application +- * was compiled with a compatible version of the library. REQUIRED ++ * was compiled with a compatible version of the library. REQUIRED. + */ + png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, +- png_voidp user_error_ptr, user_error_fn, user_warning_fn); ++ png_voidp user_error_ptr, user_error_fn, user_warning_fn); + + if (png_ptr == NULL) + { +@@ -121,7 +311,7 @@ void read_png(FILE *fp, unsigned int sig_read) /* File is already open */ + if (info_ptr == NULL) + { + fclose(fp); +- png_destroy_read_struct(&png_ptr, png_infopp_NULL, png_infopp_NULL); ++ png_destroy_read_struct(&png_ptr, NULL, NULL); + return (ERROR); + } + +@@ -129,53 +319,51 @@ void read_png(FILE *fp, unsigned int sig_read) /* File is already open */ + * the normal method of doing things with libpng). REQUIRED unless you + * set up your own error handlers in the png_create_read_struct() earlier. + */ +- + if (setjmp(png_jmpbuf(png_ptr))) + { +- /* Free all of the memory associated with the png_ptr and info_ptr */ +- png_destroy_read_struct(&png_ptr, &info_ptr, png_infopp_NULL); ++ /* Free all of the memory associated with the png_ptr and info_ptr. */ ++ png_destroy_read_struct(&png_ptr, &info_ptr, NULL); + fclose(fp); +- /* If we get here, we had a problem reading the file */ ++ /* If we get here, we had a problem reading the file. */ + return (ERROR); + } + +- /* One of the following I/O initialization methods is REQUIRED */ ++ /* One of the following I/O initialization methods is REQUIRED. */ + #ifdef streams /* PNG file I/O method 1 */ +- /* Set up the input control if you are using standard C streams */ ++ /* Set up the input control if you are using standard C streams. */ + png_init_io(png_ptr, fp); + + #else no_streams /* PNG file I/O method 2 */ + /* If you are using replacement read functions, instead of calling +- * png_init_io() here you would call: ++ * png_init_io(), you would call: + */ + png_set_read_fn(png_ptr, (void *)user_io_ptr, user_read_fn); +- /* where user_io_ptr is a structure you want available to the callbacks */ ++ /* where user_io_ptr is a structure you want available to the callbacks. */ + #endif no_streams /* Use only one I/O method! */ + + /* If we have already read some of the signature */ + png_set_sig_bytes(png_ptr, sig_read); + + #ifdef hilevel +- /* +- * If you have enough memory to read in the entire image at once, ++ /* If you have enough memory to read in the entire image at once, + * and you need to specify only transforms that can be controlled + * with one of the PNG_TRANSFORM_* bits (this presently excludes +- * dithering, filling, setting background, and doing gamma ++ * quantizing, filling, setting background, and doing gamma + * adjustment), then you can read the entire image (including + * pixels) into the info structure with this call: + */ +- png_read_png(png_ptr, info_ptr, png_transforms, png_voidp_NULL); ++ png_read_png(png_ptr, info_ptr, png_transforms, NULL); + + #else +- /* OK, you're doing it the hard way, with the lower-level functions */ ++ /* OK, you're doing it the hard way, with the lower-level functions. */ + + /* The call to png_read_info() gives us all of the information from the +- * PNG file before the first IDAT (image data chunk). REQUIRED ++ * PNG file before the first IDAT (image data chunk). REQUIRED. + */ + png_read_info(png_ptr, info_ptr); + + png_get_IHDR(png_ptr, info_ptr, &width, &height, &bit_depth, &color_type, +- &interlace_type, int_p_NULL, int_p_NULL); ++ &interlace_type, NULL, NULL); + + /* Set up the data transformations you want. Note that these are all + * optional. Only call them if you want/need them. Many of the +@@ -183,221 +371,219 @@ void read_png(FILE *fp, unsigned int sig_read) /* File is already open */ + * are mutually exclusive. + */ + +- /* Tell libpng to strip 16 bit/color files down to 8 bits/color */ ++ /* Tell libpng to strip 16 bits/color files down to 8 bits/color. ++ * Use accurate scaling if it's available, otherwise just chop off the ++ * low byte. ++ */ ++#ifdef PNG_READ_SCALE_16_TO_8_SUPPORTED ++ png_set_scale_16(png_ptr); ++#else + png_set_strip_16(png_ptr); ++#endif + + /* Strip alpha bytes from the input data without combining with the + * background (not recommended). + */ + png_set_strip_alpha(png_ptr); + +- /* Extract multiple pixels with bit depths of 1, 2, and 4 from a single ++ /* Extract multiple pixels with bit depths of 1, 2 or 4 from a single + * byte into separate bytes (useful for paletted and grayscale images). + */ + png_set_packing(png_ptr); + + /* Change the order of packed pixels to least significant bit first +- * (not useful if you are using png_set_packing). */ ++ * (not useful if you are using png_set_packing). ++ */ + png_set_packswap(png_ptr); + +- /* Expand paletted colors into true RGB triplets */ ++ /* Expand paletted colors into true RGB triplets. */ + if (color_type == PNG_COLOR_TYPE_PALETTE) + png_set_palette_to_rgb(png_ptr); + +- /* Expand grayscale images to the full 8 bits from 1, 2, or 4 bits/pixel */ ++ /* Expand grayscale images to the full 8 bits from 1, 2 or 4 bits/pixel. */ + if (color_type == PNG_COLOR_TYPE_GRAY && bit_depth < 8) + png_set_expand_gray_1_2_4_to_8(png_ptr); + + /* Expand paletted or RGB images with transparency to full alpha channels + * so the data will be available as RGBA quartets. + */ +- if (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS)) ++ if (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS) != 0) + png_set_tRNS_to_alpha(png_ptr); + + /* Set the background color to draw transparent and alpha images over. +- * It is possible to set the red, green, and blue components directly +- * for paletted images instead of supplying a palette index. Note that ++ * It is possible to set the red, green and blue components directly ++ * for paletted images, instead of supplying a palette index. Note that, + * even if the PNG file supplies a background, you are not required to + * use it - you should use the (solid) application background if it has one. + */ +- + png_color_16 my_background, *image_background; + +- if (png_get_bKGD(png_ptr, info_ptr, &image_background)) ++ if (png_get_bKGD(png_ptr, info_ptr, &image_background) != 0) + png_set_background(png_ptr, image_background, +- PNG_BACKGROUND_GAMMA_FILE, 1, 1.0); ++ PNG_BACKGROUND_GAMMA_FILE, 1, 1.0); + else + png_set_background(png_ptr, &my_background, +- PNG_BACKGROUND_GAMMA_SCREEN, 0, 1.0); ++ PNG_BACKGROUND_GAMMA_SCREEN, 0, 1.0); + +- /* Some suggestions as to how to get a screen gamma value ++ /* Some suggestions as to how to get a screen gamma value. + * + * Note that screen gamma is the display_exponent, which includes +- * the CRT_exponent and any correction for viewing conditions ++ * the CRT_exponent and any correction for viewing conditions. + */ + if (/* We have a user-defined screen gamma value */) +- { + screen_gamma = user-defined screen_gamma; +- } +- /* This is one way that applications share the same screen gamma value */ ++ /* This is one way that applications share the same screen gamma value. */ + else if ((gamma_str = getenv("SCREEN_GAMMA")) != NULL) +- { + screen_gamma = atof(gamma_str); +- } + /* If we don't have another value */ + else + { +- screen_gamma = 2.2; /* A good guess for a PC monitor in a dimly +- lit room */ +- screen_gamma = 1.7 or 1.0; /* A good guess for Mac systems */ ++ screen_gamma = PNG_DEFAULT_sRGB; /* A good guess for a PC monitor ++ in a dimly lit room */ ++ screen_gamma = PNG_GAMMA_MAC_18 or 1.0; /* Good guesses for Mac ++ systems */ + } + + /* Tell libpng to handle the gamma conversion for you. The final call + * is a good guess for PC generated images, but it should be configurable +- * by the user at run time by the user. It is strongly suggested that +- * your application support gamma correction. ++ * by the user at run time. Gamma correction support in your application ++ * is strongly recommended. + */ + + int intent; + +- if (png_get_sRGB(png_ptr, info_ptr, &intent)) +- png_set_gamma(png_ptr, screen_gamma, 0.45455); ++ if (png_get_sRGB(png_ptr, info_ptr, &intent) != 0) ++ png_set_gamma(png_ptr, screen_gamma, PNG_DEFAULT_sRGB); + else + { + double image_gamma; +- if (png_get_gAMA(png_ptr, info_ptr, &image_gamma)) ++ if (png_get_gAMA(png_ptr, info_ptr, &image_gamma) != 0) + png_set_gamma(png_ptr, screen_gamma, image_gamma); + else + png_set_gamma(png_ptr, screen_gamma, 0.45455); + } + +- /* Dither RGB files down to 8 bit palette or reduce palettes ++#ifdef PNG_READ_QUANTIZE_SUPPORTED ++ /* Quantize RGB files down to 8-bit palette, or reduce palettes + * to the number of colors available on your screen. + */ +- if (color_type & PNG_COLOR_MASK_COLOR) ++ if ((color_type & PNG_COLOR_MASK_COLOR) != 0) + { + int num_palette; + png_colorp palette; + +- /* This reduces the image to the application supplied palette */ ++ /* This reduces the image to the application-supplied palette. */ + if (/* We have our own palette */) + { +- /* An array of colors to which the image should be dithered */ ++ /* An array of colors to which the image should be quantized. */ + png_color std_color_cube[MAX_SCREEN_COLORS]; +- +- png_set_dither(png_ptr, std_color_cube, MAX_SCREEN_COLORS, +- MAX_SCREEN_COLORS, png_uint_16p_NULL, 0); ++ png_set_quantize(png_ptr, std_color_cube, MAX_SCREEN_COLORS, ++ MAX_SCREEN_COLORS, NULL, 0); + } +- /* This reduces the image to the palette supplied in the file */ +- else if (png_get_PLTE(png_ptr, info_ptr, &palette, &num_palette)) ++ /* This reduces the image to the palette supplied in the file. */ ++ else if (png_get_PLTE(png_ptr, info_ptr, &palette, &num_palette) != 0) + { + png_uint_16p histogram = NULL; +- + png_get_hIST(png_ptr, info_ptr, &histogram); +- +- png_set_dither(png_ptr, palette, num_palette, +- max_screen_colors, histogram, 0); ++ png_set_quantize(png_ptr, palette, num_palette, ++ max_screen_colors, histogram, 0); + } + } ++#endif /* READ_QUANTIZE */ + +- /* Invert monochrome files to have 0 as white and 1 as black */ ++ /* Invert monochrome files to have 0 as white and 1 as black. */ + png_set_invert_mono(png_ptr); + + /* 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 (png_get_valid(png_ptr, info_ptr, PNG_INFO_sBIT)) ++ if (png_get_valid(png_ptr, info_ptr, PNG_INFO_sBIT) != 0) + { + png_color_8p sig_bit_p; +- + png_get_sBIT(png_ptr, info_ptr, &sig_bit_p); + png_set_shift(png_ptr, sig_bit_p); + } + +- /* Flip the RGB pixels to BGR (or RGBA to BGRA) */ +- if (color_type & PNG_COLOR_MASK_COLOR) ++ /* Flip the RGB pixels to BGR (or RGBA to BGRA). */ ++ if ((color_type & PNG_COLOR_MASK_COLOR) != 0) + png_set_bgr(png_ptr); + +- /* Swap the RGBA or GA data to ARGB or AG (or BGRA to ABGR) */ ++ /* Swap the RGBA or GA data to ARGB or AG (or BGRA to ABGR). */ + png_set_swap_alpha(png_ptr); + +- /* Swap bytes of 16 bit files to least significant byte first */ ++ /* Swap bytes of 16-bit files to least significant byte first. */ + png_set_swap(png_ptr); + +- /* Add filler (or alpha) byte (before/after each RGB triplet) */ +- png_set_filler(png_ptr, 0xff, PNG_FILLER_AFTER); ++ /* Add filler (or alpha) byte (before/after each RGB triplet). */ ++ png_set_filler(png_ptr, 0xffff, PNG_FILLER_AFTER); + ++#ifdef PNG_READ_INTERLACING_SUPPORTED + /* Turn on interlace handling. REQUIRED if you are not using + * png_read_image(). To see how to handle interlacing passes, + * see the png_read_row() method below: + */ + number_passes = png_set_interlace_handling(png_ptr); ++#else /* !READ_INTERLACING */ ++ number_passes = 1; ++#endif /* READ_INTERLACING */ + + /* Optional call to gamma correct and add the background to the palette + * and update info structure. REQUIRED if you are expecting libpng to +- * update the palette for you (ie you selected such a transform above). ++ * update the palette for you (i.e. you selected such a transform above). + */ + png_read_update_info(png_ptr, info_ptr); + + /* Allocate the memory to hold the image using the fields of info_ptr. */ +- +- /* The easiest way to read the image: */ + png_bytep row_pointers[height]; +- +- /* Clear the pointer array */ + for (row = 0; row < height; row++) +- row_pointers[row] = NULL; +- ++ row_pointers[row] = NULL; /* Clear the pointer array */ + for (row = 0; row < height; row++) + row_pointers[row] = png_malloc(png_ptr, png_get_rowbytes(png_ptr, +- info_ptr)); ++ info_ptr)); + +- /* Now it's time to read the image. One of these methods is REQUIRED */ ++ /* Now it's time to read the image. One of these methods is REQUIRED. */ + #ifdef entire /* Read the entire image in one go */ + png_read_image(png_ptr, row_pointers); + + #else no_entire /* Read the image one or more scanlines at a time */ + /* The other way to read images - deal with interlacing: */ +- + for (pass = 0; pass < number_passes; pass++) + { + #ifdef single /* Read the image a single row at a time */ + for (y = 0; y < height; y++) +- { +- png_read_rows(png_ptr, &row_pointers[y], png_bytepp_NULL, 1); +- } ++ png_read_rows(png_ptr, &row_pointers[y], NULL, 1); + + #else no_single /* Read the image several rows at a time */ + for (y = 0; y < height; y += number_of_rows) + { + #ifdef sparkle /* Read the image using the "sparkle" effect. */ +- png_read_rows(png_ptr, &row_pointers[y], png_bytepp_NULL, +- number_of_rows); ++ png_read_rows(png_ptr, &row_pointers[y], NULL, ++ number_of_rows); + #else no_sparkle /* Read the image using the "rectangle" effect */ +- png_read_rows(png_ptr, png_bytepp_NULL, &row_pointers[y], +- number_of_rows); ++ png_read_rows(png_ptr, NULL, &row_pointers[y], ++ number_of_rows); + #endif no_sparkle /* Use only one of these two methods */ + } + +- /* If you want to display the image after every pass, do so here */ ++ /* If you want to display the image after every pass, do so here. */ + #endif no_single /* Use only one of these two methods */ + } + #endif no_entire /* Use only one of these two methods */ + +- /* Read rest of file, and get additional chunks in info_ptr - REQUIRED */ ++ /* Read rest of file, and get additional chunks in info_ptr. REQUIRED. */ + png_read_end(png_ptr, info_ptr); + #endif hilevel + +- /* At this point you have read the entire image */ ++ /* At this point you have read the entire image. */ + +- /* Clean up after the read, and free any memory allocated - REQUIRED */ +- png_destroy_read_struct(&png_ptr, &info_ptr, png_infopp_NULL); ++ /* Clean up after the read, and free any memory allocated. REQUIRED. */ ++ png_destroy_read_struct(&png_ptr, &info_ptr, NULL); + +- /* Close the file */ ++ /* Close the file. */ + fclose(fp); + +- /* That's it */ ++ /* That's it! */ + return (OK); + } + +@@ -409,34 +595,30 @@ initialize_png_reader(png_structp *png_ptr, png_infop *info_ptr) + /* Create and initialize the png_struct with the desired error handler + * functions. If you want to use the default stderr and longjump method, + * you can supply NULL for the last three parameters. We also check that +- * the library version is compatible in case we are using dynamically ++ * the library version is compatible, in case we are using dynamically + * linked libraries. + */ + *png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, +- png_voidp user_error_ptr, user_error_fn, user_warning_fn); +- ++ png_voidp user_error_ptr, user_error_fn, user_warning_fn); + if (*png_ptr == NULL) + { + *info_ptr = NULL; + return (ERROR); + } +- + *info_ptr = png_create_info_struct(png_ptr); +- + if (*info_ptr == NULL) + { +- png_destroy_read_struct(png_ptr, info_ptr, png_infopp_NULL); ++ png_destroy_read_struct(png_ptr, info_ptr, NULL); + return (ERROR); + } +- + if (setjmp(png_jmpbuf((*png_ptr)))) + { +- png_destroy_read_struct(png_ptr, info_ptr, png_infopp_NULL); ++ png_destroy_read_struct(png_ptr, info_ptr, NULL); + return (ERROR); + } + +- /* This one's new. You will need to provide all three +- * function callbacks, even if you aren't using them all. ++ /* You will need to provide all three function callbacks, ++ * even if you aren't using all of them. + * If you aren't using all functions, you can specify NULL + * parameters. Even when all three functions are NULL, + * you need to call png_set_progressive_read_fn(). +@@ -448,29 +630,28 @@ initialize_png_reader(png_structp *png_ptr, png_infop *info_ptr) + * the function png_get_progressive_ptr(png_ptr). + */ + png_set_progressive_read_fn(*png_ptr, (void *)stream_data, +- info_callback, row_callback, end_callback); +- ++ info_callback, row_callback, end_callback); + return (OK); + } + + int + process_data(png_structp *png_ptr, png_infop *info_ptr, +- png_bytep buffer, png_uint_32 length) ++ png_bytep buffer, png_uint_32 length) + { + if (setjmp(png_jmpbuf((*png_ptr)))) + { +- /* Free the png_ptr and info_ptr memory on error */ +- png_destroy_read_struct(png_ptr, info_ptr, png_infopp_NULL); ++ /* Free the png_ptr and info_ptr memory on error. */ ++ png_destroy_read_struct(png_ptr, info_ptr, NULL); + return (ERROR); + } + +- /* This one's new also. Simply give it chunks of data as +- * they arrive from the data stream (in order, of course). ++ /* Give chunks of data as they arrive from the data stream ++ * (in order, of course). + * On segmented machines, don't give it any more than 64K. + * The library seems to run fine with sizes of 4K, although +- * you can give it much less if necessary (I assume you can ++ * you can give it much less if necessary. (I assume you can + * give it chunks of 1 byte, but I haven't tried with less +- * than 256 bytes yet). When this function returns, you may ++ * than 256 bytes yet.) When this function returns, you may + * want to display any rows that were generated in the row + * callback, if you aren't already displaying them there. + */ +@@ -490,10 +671,9 @@ info_callback(png_structp png_ptr, png_infop info) + } + + row_callback(png_structp png_ptr, png_bytep new_row, +- png_uint_32 row_num, int pass) ++ png_uint_32 row_num, int pass) + { +- /* +- * This function is called for every row in the image. If the ++ /* This function is called for every row in the image. If the + * image is interlaced, and you turned on the interlace handler, + * this function will be called for every row in every pass. + * +@@ -504,24 +684,22 @@ row_callback(png_structp png_ptr, png_bytep new_row, + * The new row data pointer "new_row" may be NULL, indicating there is + * no new data to be replaced (in cases of interlace loading). + * +- * If new_row is not NULL then you need to call +- * png_progressive_combine_row() to replace the corresponding row as ++ * If new_row is not NULL, then you need to call ++ * png_progressive_combine_row(), to replace the corresponding row as + * shown below: + */ + +- /* Get pointer to corresponding row in our +- * PNG read buffer. +- */ ++ /* Get pointer to corresponding row in our PNG read buffer. */ + png_bytep old_row = ((png_bytep *)our_data)[row_num]; + +- /* If both rows are allocated then copy the new row ++#ifdef PNG_READ_INTERLACING_SUPPORTED ++ /* If both rows are allocated, then copy the new row + * data to the corresponding row data. + */ +- if ((old_row != NULL) && (new_row != NULL)) +- png_progressive_combine_row(png_ptr, old_row, new_row); ++ if (old_row != NULL && new_row != NULL) ++ png_progressive_combine_row(png_ptr, old_row, new_row); + +- /* +- * The rows and passes are called in order, so you don't really ++ /* The rows and passes are called in order, so you don't really + * need the row_num and pass, but I'm supplying them because it + * may make your life easier. + * +@@ -529,10 +707,9 @@ row_callback(png_structp png_ptr, png_bytep new_row, + * png_progressive_combine_row() passing in the new row and the + * old row, as demonstrated above. You can call this function for + * NULL rows (it will just return) and for non-interlaced images +- * (it just does the png_memcpy for you) if it will make the code ++ * (it just does the memcpy for you) if it will make the code + * easier. Thus, you can just do this for all cases: + */ +- + png_progressive_combine_row(png_ptr, old_row, new_row); + + /* where old_row is what was displayed for previous rows. Note +@@ -542,6 +719,7 @@ row_callback(png_structp png_ptr, png_bytep new_row, + * to pass the current row as new_row, and the function will combine + * the old row and the new row. + */ ++#endif /* READ_INTERLACING */ + } + + end_callback(png_structp png_ptr, png_infop info) +@@ -577,47 +755,46 @@ void write_png(char *file_name /* , ... other image information ... */) + * in case we are using dynamically linked libraries. REQUIRED. + */ + png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, +- png_voidp user_error_ptr, user_error_fn, user_warning_fn); +- ++ png_voidp user_error_ptr, user_error_fn, user_warning_fn); + if (png_ptr == NULL) + { + fclose(fp); + return (ERROR); + } + +- /* Allocate/initialize the image information data. REQUIRED */ ++ /* Allocate/initialize the image information data. REQUIRED. */ + info_ptr = png_create_info_struct(png_ptr); + if (info_ptr == NULL) + { + fclose(fp); +- png_destroy_write_struct(&png_ptr, png_infopp_NULL); ++ png_destroy_write_struct(&png_ptr, NULL); + return (ERROR); + } + +- /* Set error handling. REQUIRED if you aren't supplying your own ++ /* Set up error handling. REQUIRED if you aren't supplying your own + * error handling functions in the png_create_write_struct() call. + */ + if (setjmp(png_jmpbuf(png_ptr))) + { +- /* If we get here, we had a problem writing the file */ ++ /* If we get here, we had a problem writing the file. */ + fclose(fp); + png_destroy_write_struct(&png_ptr, &info_ptr); + return (ERROR); + } + +- /* One of the following I/O initialization functions is REQUIRED */ ++ /* One of the following I/O initialization functions is REQUIRED. */ + + #ifdef streams /* I/O initialization method 1 */ +- /* Set up the output control if you are using standard C streams */ ++ /* Set up the output control if you are using standard C streams. */ + png_init_io(png_ptr, fp); + + #else no_streams /* I/O initialization method 2 */ + /* If you are using replacement write functions, instead of calling +- * png_init_io() here you would call ++ * png_init_io(), you would call: + */ + png_set_write_fn(png_ptr, (void *)user_io_ptr, user_write_fn, +- user_IO_flush_function); +- /* where user_io_ptr is a structure you want available to the callbacks */ ++ user_IO_flush_function); ++ /* where user_io_ptr is a structure you want available to the callbacks. */ + #endif no_streams /* Only use one initialization method */ + + #ifdef hilevel +@@ -625,75 +802,97 @@ void write_png(char *file_name /* , ... other image information ... */) + * image info living in the structure. You could "|" many + * PNG_TRANSFORM flags into the png_transforms integer here. + */ +- png_write_png(png_ptr, info_ptr, png_transforms, png_voidp_NULL); ++ png_write_png(png_ptr, info_ptr, png_transforms, NULL); + + #else +- /* This is the hard way */ ++ /* This is the hard way. */ + + /* Set the image information here. Width and height are up to 2^31, +- * bit_depth is one of 1, 2, 4, 8, or 16, but valid values also depend on +- * the color_type selected. color_type is one of PNG_COLOR_TYPE_GRAY, ++ * bit_depth is one of 1, 2, 4, 8 or 16, but valid values also depend on ++ * the color_type selected. color_type is one of PNG_COLOR_TYPE_GRAY, + * PNG_COLOR_TYPE_GRAY_ALPHA, PNG_COLOR_TYPE_PALETTE, PNG_COLOR_TYPE_RGB, + * or PNG_COLOR_TYPE_RGB_ALPHA. interlace is either PNG_INTERLACE_NONE or + * PNG_INTERLACE_ADAM7, and the compression_type and filter_type MUST +- * currently be PNG_COMPRESSION_TYPE_BASE and PNG_FILTER_TYPE_BASE. REQUIRED ++ * currently be PNG_COMPRESSION_TYPE_BASE and PNG_FILTER_TYPE_BASE. ++ * REQUIRED. + */ +- png_set_IHDR(png_ptr, info_ptr, width, height, bit_depth, PNG_COLOR_TYPE_???, +- PNG_INTERLACE_????, PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE); ++ png_set_IHDR(png_ptr, info_ptr, width, height, bit_depth, ++ PNG_COLOR_TYPE_???, PNG_INTERLACE_????, ++ PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE); + +- /* Set the palette if there is one. REQUIRED for indexed-color images */ +- palette = (png_colorp)png_malloc(png_ptr, PNG_MAX_PALETTE_LENGTH +- * png_sizeof(png_color)); ++ /* Set the palette if there is one. REQUIRED for indexed-color images. */ ++ palette = (png_colorp)png_malloc(png_ptr, ++ PNG_MAX_PALETTE_LENGTH * (sizeof (png_color))); + /* ... Set palette colors ... */ + png_set_PLTE(png_ptr, info_ptr, palette, PNG_MAX_PALETTE_LENGTH); +- /* You must not free palette here, because png_set_PLTE only makes a link to +- * the palette that you malloced. Wait until you are about to destroy ++ /* You must not free palette here, because png_set_PLTE only makes a link ++ * to the palette that you allocated. Wait until you are about to destroy + * the png structure. + */ + +- /* Optional significant bit (sBIT) chunk */ ++ /* Optional significant bit (sBIT) chunk. */ + png_color_8 sig_bit; ++ + /* If we are dealing with a grayscale image then */ + sig_bit.gray = true_bit_depth; ++ + /* Otherwise, if we are dealing with a color image then */ + sig_bit.red = true_red_bit_depth; + sig_bit.green = true_green_bit_depth; + sig_bit.blue = true_blue_bit_depth; ++ + /* If the image has an alpha channel then */ + sig_bit.alpha = true_alpha_bit_depth; +- png_set_sBIT(png_ptr, info_ptr, &sig_bit); + ++ png_set_sBIT(png_ptr, info_ptr, &sig_bit); + + /* Optional gamma chunk is strongly suggested if you have any guess + * as to the correct gamma of the image. + */ + png_set_gAMA(png_ptr, info_ptr, gamma); + +- /* Optionally write comments into the image */ +- text_ptr[0].key = "Title"; +- text_ptr[0].text = "Mona Lisa"; +- text_ptr[0].compression = PNG_TEXT_COMPRESSION_NONE; +- text_ptr[1].key = "Author"; +- text_ptr[1].text = "Leonardo DaVinci"; +- text_ptr[1].compression = PNG_TEXT_COMPRESSION_NONE; +- text_ptr[2].key = "Description"; +- text_ptr[2].text = ""; +- text_ptr[2].compression = PNG_TEXT_COMPRESSION_zTXt; +-#ifdef PNG_iTXt_SUPPORTED +- text_ptr[0].lang = NULL; +- text_ptr[1].lang = NULL; +- text_ptr[2].lang = NULL; +-#endif +- png_set_text(png_ptr, info_ptr, text_ptr, 3); ++ /* Optionally write comments into the image. */ ++ { ++ png_text text_ptr[3]; ++ ++ char key0[] = "Title"; ++ char text0[] = "Mona Lisa"; ++ text_ptr[0].key = key0; ++ text_ptr[0].text = text0; ++ text_ptr[0].compression = PNG_TEXT_COMPRESSION_NONE; ++ text_ptr[0].itxt_length = 0; ++ text_ptr[0].lang = NULL; ++ text_ptr[0].lang_key = NULL; ++ ++ char key1[] = "Author"; ++ char text1[] = "Leonardo DaVinci"; ++ text_ptr[1].key = key1; ++ text_ptr[1].text = text1; ++ text_ptr[1].compression = PNG_TEXT_COMPRESSION_NONE; ++ text_ptr[1].itxt_length = 0; ++ text_ptr[1].lang = NULL; ++ text_ptr[1].lang_key = NULL; ++ ++ char key2[] = "Description"; ++ char text2[] = ""; ++ text_ptr[2].key = key2; ++ text_ptr[2].text = text2; ++ text_ptr[2].compression = PNG_TEXT_COMPRESSION_zTXt; ++ text_ptr[2].itxt_length = 0; ++ text_ptr[2].lang = NULL; ++ text_ptr[2].lang_key = NULL; ++ ++ png_set_text(write_ptr, write_info_ptr, text_ptr, 3); ++ } + +- /* Other optional chunks like cHRM, bKGD, tRNS, tIME, oFFs, pHYs */ ++ /* Other optional chunks like cHRM, bKGD, tRNS, tIME, oFFs, pHYs. */ + +- /* Note that if sRGB is present the gAMA and cHRM chunks must be ignored ++ /* Note that if sRGB is present, the gAMA and cHRM chunks must be ignored + * on read and, if your application chooses to write them, they must +- * be written in accordance with the sRGB profile ++ * be written in accordance with the sRGB profile. + */ + +- /* Write the file header information. REQUIRED */ ++ /* Write the file header information. REQUIRED. */ + png_write_info(png_ptr, info_ptr); + + /* If you want, you can write the info in two steps, in case you need to +@@ -708,7 +907,7 @@ void write_png(char *file_name /* , ... other image information ... */) + */ + + /* Once we write out the header, the compression type on the text +- * chunks gets changed to PNG_TEXT_COMPRESSION_NONE_WR or ++ * chunk gets changed to PNG_TEXT_COMPRESSION_NONE_WR or + * PNG_TEXT_COMPRESSION_zTXt_WR, so it doesn't get written out again + * at the end. + */ +@@ -717,7 +916,7 @@ void write_png(char *file_name /* , ... other image information ... */) + * all optional. Only call them if you want them. + */ + +- /* Invert monochrome pixels */ ++ /* Invert monochrome pixels. */ + png_set_invert_mono(png_ptr); + + /* Shift the pixels up to a legal bit depth and fill in +@@ -725,28 +924,28 @@ void write_png(char *file_name /* , ... other image information ... */) + */ + png_set_shift(png_ptr, &sig_bit); + +- /* Pack pixels into bytes */ ++ /* Pack pixels into bytes. */ + png_set_packing(png_ptr); + +- /* Swap location of alpha bytes from ARGB to RGBA */ ++ /* Swap location of alpha bytes from ARGB to RGBA. */ + png_set_swap_alpha(png_ptr); + + /* Get rid of filler (OR ALPHA) bytes, pack XRGB/RGBX/ARGB/RGBA into +- * RGB (4 channels -> 3 channels). The second parameter is not used. ++ * RGB (4 channels -> 3 channels). The second parameter is not used. + */ + png_set_filler(png_ptr, 0, PNG_FILLER_BEFORE); + +- /* Flip BGR pixels to RGB */ ++ /* Flip BGR pixels to RGB. */ + png_set_bgr(png_ptr); + +- /* Swap bytes of 16-bit files to most significant byte first */ ++ /* Swap bytes of 16-bit files to most significant byte first. */ + png_set_swap(png_ptr); + +- /* Swap bits of 1, 2, 4 bit packed pixel formats */ ++ /* Swap bits of 1-bit, 2-bit, 4-bit packed pixel formats. */ + png_set_packswap(png_ptr); + +- /* Turn on interlace handling if you are not using png_write_image() */ +- if (interlacing) ++ /* Turn on interlace handling if you are not using png_write_image(). */ ++ if (interlacing != 0) + number_passes = png_set_interlace_handling(png_ptr); + else + number_passes = 1; +@@ -756,21 +955,29 @@ void write_png(char *file_name /* , ... other image information ... */) + * use the first method if you aren't handling interlacing yourself. + */ + png_uint_32 k, height, width; +- png_byte image[height][width*bytes_per_pixel]; ++ ++ /* In this example, "image" is a one-dimensional array of bytes. */ ++ ++ /* Guard against integer overflow. */ ++ if (height > PNG_SIZE_MAX / (width * bytes_per_pixel)) ++ png_error(png_ptr, "Image data buffer would be too large"); ++ ++ png_byte image[height * width * bytes_per_pixel]; + png_bytep row_pointers[height]; + +- if (height > PNG_UINT_32_MAX/png_sizeof(png_bytep)) +- png_error (png_ptr, "Image is too tall to process in memory"); ++ if (height > PNG_UINT_32_MAX / (sizeof (png_bytep))) ++ png_error(png_ptr, "Image is too tall to process in memory"); + ++ /* Set up pointers into your "image" byte array. */ + for (k = 0; k < height; k++) +- row_pointers[k] = image + k*width*bytes_per_pixel; ++ row_pointers[k] = image + k * width * bytes_per_pixel; + +- /* One of the following output methods is REQUIRED */ ++ /* One of the following output methods is REQUIRED. */ + + #ifdef entire /* Write out the entire image data in one call */ + png_write_image(png_ptr, row_pointers); + +- /* The other way to write the image - deal with interlacing */ ++ /* The other way to write the image - deal with interlacing. */ + + #else no_entire /* Write out the image data by one or more scanlines */ + +@@ -782,27 +989,27 @@ void write_png(char *file_name /* , ... other image information ... */) + /* Write a few rows at a time. */ + png_write_rows(png_ptr, &row_pointers[first_row], number_of_rows); + +- /* If you are only writing one row at a time, this works */ ++ /* If you are only writing one row at a time, this works. */ + for (y = 0; y < height; y++) + png_write_rows(png_ptr, &row_pointers[y], 1); + } + #endif no_entire /* Use only one output method */ + + /* You can write optional chunks like tEXt, zTXt, and tIME at the end +- * as well. Shouldn't be necessary in 1.2.0 and up as all the public +- * chunks are supported and you can use png_set_unknown_chunks() to ++ * as well. Shouldn't be necessary in 1.2.0 and up, as all the public ++ * chunks are supported, and you can use png_set_unknown_chunks() to + * register unknown chunks into the info structure to be written out. + */ + +- /* It is REQUIRED to call this to finish writing the rest of the file */ ++ /* It is REQUIRED to call this to finish writing the rest of the file. */ + png_write_end(png_ptr, info_ptr); + #endif hilevel + +- /* If you png_malloced a palette, free it here (don't free info_ptr->palette, +- * as recommended in versions 1.0.5m and earlier of this example; if +- * libpng mallocs info_ptr->palette, libpng will free it). If you +- * allocated it with malloc() instead of png_malloc(), use free() instead +- * of png_free(). ++ /* If you png_malloced a palette, free it here. ++ * (Don't free info_ptr->palette, as shown in versions 1.0.5m and earlier of ++ * this example; if libpng mallocs info_ptr->palette, libpng will free it). ++ * If you allocated it with malloc() instead of png_malloc(), use free() ++ * instead of png_free(). + */ + png_free(png_ptr, palette); + palette = NULL; +@@ -813,19 +1020,20 @@ void write_png(char *file_name /* , ... other image information ... */) + */ + png_free(png_ptr, trans); + trans = NULL; +- /* Whenever you use png_free() it is a good idea to set the pointer to ++ ++ /* Whenever you use png_free(), it is a good idea to set the pointer to + * NULL in case your application inadvertently tries to png_free() it +- * again. When png_free() sees a NULL it returns without action, thus +- * avoiding the double-free security problem. ++ * again. When png_free() sees a NULL it returns without action, avoiding ++ * the double-free problem. + */ + +- /* Clean up after the write, and free any memory allocated */ ++ /* Clean up after the write, and free any allocated memory. */ + png_destroy_write_struct(&png_ptr, &info_ptr); + +- /* Close the file */ ++ /* Close the file. */ + fclose(fp); + +- /* That's it */ ++ /* That's it! */ + return (OK); + } + +diff --git a/com32/lib/libpng/libpng.3 b/com32/lib/libpng/libpng.3 +index 93139a7f..9757debc 100644 +--- a/com32/lib/libpng/libpng.3 ++++ b/com32/lib/libpng/libpng.3 +@@ -1,814 +1,511 @@ +-.TH LIBPNG 3 "June 26, 2010" ++.TH LIBPNG 3 "December 1, 2018" + .SH NAME +-libpng \- Portable Network Graphics (PNG) Reference Library 1.2.44 +-.SH SYNOPSIS +-\fI\fB ++libpng \- Portable Network Graphics (PNG) Reference Library 1.6.36 + ++.SH SYNOPSIS + \fB#include \fP + +-\fI\fB ++\fBpng_uint_32 png_access_version_number (void);\fP + +-\fBpng_uint_32 png_access_version_number \fI(void\fP\fB);\fP ++\fBvoid png_benign_error (png_structp \fP\fIpng_ptr\fP\fB, png_const_charp \fIerror\fP\fB);\fP + +-\fI\fB ++\fBvoid png_build_grayscale_palette (int \fP\fIbit_depth\fP\fB, png_colorp \fIpalette\fP\fB);\fP + +-\fBint png_check_sig (png_bytep \fP\fIsig\fP\fB, int \fInum\fP\fB);\fP ++\fBpng_voidp png_calloc (png_structp \fP\fIpng_ptr\fP\fB, png_alloc_size_t \fIsize\fP\fB);\fP + +-\fI\fB ++\fBvoid png_chunk_benign_error (png_structp \fP\fIpng_ptr\fP\fB, png_const_charp \fIerror\fP\fB);\fP + + \fBvoid png_chunk_error (png_structp \fP\fIpng_ptr\fP\fB, png_const_charp \fIerror\fP\fB);\fP + +-\fI\fB +- + \fBvoid png_chunk_warning (png_structp \fP\fIpng_ptr\fP\fB, png_const_charp \fImessage\fP\fB);\fP + +-\fI\fB +- + \fBvoid png_convert_from_struct_tm (png_timep \fP\fIptime\fP\fB, struct tm FAR * \fIttime\fP\fB);\fP + +-\fI\fB +- + \fBvoid png_convert_from_time_t (png_timep \fP\fIptime\fP\fB, time_t \fIttime\fP\fB);\fP + +-\fI\fB +- + \fBpng_charp png_convert_to_rfc1123 (png_structp \fP\fIpng_ptr\fP\fB, png_timep \fIptime\fP\fB);\fP + +-\fI\fB +- + \fBpng_infop png_create_info_struct (png_structp \fIpng_ptr\fP\fB);\fP + +-\fI\fB +- + \fBpng_structp png_create_read_struct (png_const_charp \fP\fIuser_png_ver\fP\fB, png_voidp \fP\fIerror_ptr\fP\fB, png_error_ptr \fP\fIerror_fn\fP\fB, png_error_ptr \fIwarn_fn\fP\fB);\fP + +-\fI\fB +- +-\fBpng_structp png_create_read_struct_2(png_const_charp \fP\fIuser_png_ver\fP\fB, png_voidp \fP\fIerror_ptr\fP\fB, png_error_ptr \fP\fIerror_fn\fP\fB, png_error_ptr \fP\fIwarn_fn\fP\fB, png_voidp \fP\fImem_ptr\fP\fB, png_malloc_ptr \fP\fImalloc_fn\fP\fB, png_free_ptr \fIfree_fn\fP\fB);\fP +- +-\fI\fB ++\fBpng_structp png_create_read_struct_2 (png_const_charp \fP\fIuser_png_ver\fP\fB, png_voidp \fP\fIerror_ptr\fP\fB, png_error_ptr \fP\fIerror_fn\fP\fB, png_error_ptr \fP\fIwarn_fn\fP\fB, png_voidp \fP\fImem_ptr\fP\fB, png_malloc_ptr \fP\fImalloc_fn\fP\fB, png_free_ptr \fIfree_fn\fP\fB);\fP + + \fBpng_structp png_create_write_struct (png_const_charp \fP\fIuser_png_ver\fP\fB, png_voidp \fP\fIerror_ptr\fP\fB, png_error_ptr \fP\fIerror_fn\fP\fB, png_error_ptr \fIwarn_fn\fP\fB);\fP + +-\fI\fB +- +-\fBpng_structp png_create_write_struct_2(png_const_charp \fP\fIuser_png_ver\fP\fB, png_voidp \fP\fIerror_ptr\fP\fB, png_error_ptr \fP\fIerror_fn\fP\fB, png_error_ptr \fP\fIwarn_fn\fP\fB, png_voidp \fP\fImem_ptr\fP\fB, png_malloc_ptr \fP\fImalloc_fn\fP\fB, png_free_ptr \fIfree_fn\fP\fB);\fP +- +-\fI\fB +- +-\fBint png_debug(int \fP\fIlevel\fP\fB, png_const_charp \fImessage\fP\fB);\fP +- +-\fI\fB +- +-\fBint png_debug1(int \fP\fIlevel\fP\fB, png_const_charp \fP\fImessage\fP\fB, \fIp1\fP\fB);\fP +- +-\fI\fB ++\fBpng_structp png_create_write_struct_2 (png_const_charp \fP\fIuser_png_ver\fP\fB, png_voidp \fP\fIerror_ptr\fP\fB, png_error_ptr \fP\fIerror_fn\fP\fB, png_error_ptr \fP\fIwarn_fn\fP\fB, png_voidp \fP\fImem_ptr\fP\fB, png_malloc_ptr \fP\fImalloc_fn\fP\fB, png_free_ptr \fIfree_fn\fP\fB);\fP + +-\fBint png_debug2(int \fP\fIlevel\fP\fB, png_const_charp \fP\fImessage\fP\fB, \fP\fIp1\fP\fB, \fIp2\fP\fB);\fP +- +-\fI\fB ++\fBvoid png_data_freer (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, int \fP\fIfreer\fP\fB, png_uint_32 \fImask\fP\fB);\fP + + \fBvoid png_destroy_info_struct (png_structp \fP\fIpng_ptr\fP\fB, png_infopp \fIinfo_ptr_ptr\fP\fB);\fP + +-\fI\fB +- + \fBvoid png_destroy_read_struct (png_structpp \fP\fIpng_ptr_ptr\fP\fB, png_infopp \fP\fIinfo_ptr_ptr\fP\fB, png_infopp \fIend_info_ptr_ptr\fP\fB);\fP + +-\fI\fB +- + \fBvoid png_destroy_write_struct (png_structpp \fP\fIpng_ptr_ptr\fP\fB, png_infopp \fIinfo_ptr_ptr\fP\fB);\fP + +-\fI\fB ++\fBvoid png_err (png_structp \fIpng_ptr\fP\fB);\fP + + \fBvoid png_error (png_structp \fP\fIpng_ptr\fP\fB, png_const_charp \fIerror\fP\fB);\fP + +-\fI\fB +- + \fBvoid png_free (png_structp \fP\fIpng_ptr\fP\fB, png_voidp \fIptr\fP\fB);\fP + +-\fI\fB +- + \fBvoid png_free_chunk_list (png_structp \fIpng_ptr\fP\fB);\fP + +-\fI\fB +- +-\fBvoid png_free_default(png_structp \fP\fIpng_ptr\fP\fB, png_voidp \fIptr\fP\fB);\fP +- +-\fI\fB ++\fBvoid png_free_default (png_structp \fP\fIpng_ptr\fP\fB, png_voidp \fIptr\fP\fB);\fP + + \fBvoid png_free_data (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, int \fInum\fP\fB);\fP + +-\fI\fB +- +-\fBpng_byte png_get_bit_depth (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fIinfo_ptr\fP\fB);\fP ++\fBpng_byte png_get_bit_depth (png_const_structp \fP\fIpng_ptr\fP\fB, png_const_infop \fIinfo_ptr\fP\fB);\fP + +-\fI\fB ++\fBpng_uint_32 png_get_bKGD (png_const_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_color_16p \fI*background\fP\fB);\fP + +-\fBpng_uint_32 png_get_bKGD (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_color_16p \fI*background\fP\fB);\fP ++\fBpng_byte png_get_channels (png_const_structp \fP\fIpng_ptr\fP\fB, png_const_infop \fIinfo_ptr\fP\fB);\fP + +-\fI\fB ++\fBpng_uint_32 png_get_cHRM (png_const_structp \fP\fIpng_ptr\fP\fB, png_const_infop \fP\fIinfo_ptr\fP\fB, double \fP\fI*white_x\fP\fB, double \fP\fI*white_y\fP\fB, double \fP\fI*red_x\fP\fB, double \fP\fI*red_y\fP\fB, double \fP\fI*green_x\fP\fB, double \fP\fI*green_y\fP\fB, double \fP\fI*blue_x\fP\fB, double \fI*blue_y\fP\fB);\fP + +-\fBpng_byte png_get_channels (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fIinfo_ptr\fP\fB);\fP ++\fBpng_uint_32 png_get_cHRM_fixed (png_const_structp \fP\fIpng_ptr\fP\fB, png_const_infop \fP\fIinfo_ptr\fP\fB, png_uint_32 \fP\fI*white_x\fP\fB, png_uint_32 \fP\fI*white_y\fP\fB, png_uint_32 \fP\fI*red_x\fP\fB, png_uint_32 \fP\fI*red_y\fP\fB, png_uint_32 \fP\fI*green_x\fP\fB, png_uint_32 \fP\fI*green_y\fP\fB, png_uint_32 \fP\fI*blue_x\fP\fB, png_uint_32 \fI*blue_y\fP\fB);\fP + +-\fI\fB ++\fBpng_uint_32 png_get_cHRM_XYZ (png_structp \fP\fIpng_ptr\fP\fB, png_const_infop \fP\fIinfo_ptr\fP\fB, double \fP\fI*red_X\fP\fB, double \fP\fI*red_Y\fP\fB, double \fP\fI*red_Z\fP\fB, double \fP\fI*green_X\fP\fB, double \fP\fI*green_Y\fP\fB, double \fP\fI*green_Z\fP\fB, double \fP\fI*blue_X\fP\fB, double \fP\fI*blue_Y\fP\fB, double \fI*blue_Z\fP\fB);\fP + +-\fBpng_uint_32 png_get_cHRM (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, double \fP\fI*white_x\fP\fB, double \fP\fI*white_y\fP\fB, double \fP\fI*red_x\fP\fB, double \fP\fI*red_y\fP\fB, double \fP\fI*green_x\fP\fB, double \fP\fI*green_y\fP\fB, double \fP\fI*blue_x\fP\fB, double \fI*blue_y\fP\fB);\fP ++\fBpng_uint_32 png_get_cHRM_XYZ_fixed (png_structp \fP\fIpng_ptr\fP\fB, png_const_infop \fP\fIinfo_ptr\fP\fB, png_fixed_point \fP\fI*int_red_X\fP\fB, png_fixed_point \fP\fI*int_red_Y\fP\fB, png_fixed_point \fP\fI*int_red_Z\fP\fB, png_fixed_point \fP\fI*int_green_X\fP\fB, png_fixed_point \fP\fI*int_green_Y\fP\fB, png_fixed_point \fP\fI*int_green_Z\fP\fB, png_fixed_point \fP\fI*int_blue_X\fP\fB, png_fixed_point \fP\fI*int_blue_Y\fP\fB, png_fixed_point \fI*int_blue_Z\fP\fB);\fP + +-\fI\fB ++\fBpng_uint_32 png_get_chunk_cache_max (png_const_structp \fIpng_ptr\fP\fB);\fP + +-\fBpng_uint_32 png_get_cHRM_fixed (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_uint_32 \fP\fI*white_x\fP\fB, png_uint_32 \fP\fI*white_y\fP\fB, png_uint_32 \fP\fI*red_x\fP\fB, png_uint_32 \fP\fI*red_y\fP\fB, png_uint_32 \fP\fI*green_x\fP\fB, png_uint_32 \fP\fI*green_y\fP\fB, png_uint_32 \fP\fI*blue_x\fP\fB, png_uint_32 \fI*blue_y\fP\fB);\fP ++\fBpng_alloc_size_t png_get_chunk_malloc_max (png_const_structp \fIpng_ptr\fP\fB);\fP + +-\fI\fB ++\fBpng_byte png_get_color_type (png_const_structp \fP\fIpng_ptr\fP\fB, png_const_infop \fIinfo_ptr\fP\fB);\fP + +-\fBpng_byte png_get_color_type (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fIinfo_ptr\fP\fB);\fP ++\fBpng_uint_32 png_get_compression_buffer_size (png_const_structp \fIpng_ptr\fP\fB);\fP + +-\fI\fB ++\fBpng_byte png_get_compression_type (png_const_structp \fP\fIpng_ptr\fP\fB, png_const_infop \fIinfo_ptr\fP\fB);\fP + +-\fBpng_byte png_get_compression_type (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fIinfo_ptr\fP\fB);\fP ++\fBpng_byte png_get_copyright (png_const_structp \fIpng_ptr\fP\fB);\fP + +-\fI\fB ++\fBpng_uint_32 png_get_current_row_number \fI(png_const_structp\fP\fB);\fP + +-\fBpng_byte png_get_copyright (png_structp \fIpng_ptr\fP\fB);\fP ++\fBpng_byte png_get_current_pass_number \fI(png_const_structp\fP\fB);\fP + +-\fI\fB ++\fBpng_voidp png_get_error_ptr (png_const_structp \fIpng_ptr\fP\fB);\fP + +-\fBpng_voidp png_get_error_ptr (png_structp \fIpng_ptr\fP\fB);\fP ++\fBpng_byte png_get_filter_type (png_const_structp \fP\fIpng_ptr\fP\fB, png_const_infop \fIinfo_ptr\fP\fB);\fP + +-\fI\fB ++\fBpng_uint_32 png_get_gAMA (png_const_structp \fP\fIpng_ptr\fP\fB, png_const_infop \fP\fIinfo_ptr\fP\fB, double \fI*file_gamma\fP\fB);\fP + +-\fBpng_byte png_get_filter_type (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fIinfo_ptr\fP\fB);\fP ++\fBpng_uint_32 png_get_gAMA_fixed (png_const_structp \fP\fIpng_ptr\fP\fB, png_const_infop \fP\fIinfo_ptr\fP\fB, png_uint_32 \fI*int_file_gamma\fP\fB);\fP + +-\fI\fB ++\fBpng_byte png_get_header_ver (png_const_structp \fIpng_ptr\fP\fB);\fP + +-\fBpng_uint_32 png_get_gAMA (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, double \fI*file_gamma\fP\fB);\fP ++\fBpng_byte png_get_header_version (png_const_structp \fIpng_ptr\fP\fB);\fP + +-\fI\fB ++\fBpng_uint_32 png_get_eXIf (png_const_structp \fP\fIpng_ptr\fP\fB, png_const_infop \fP\fIinfo_ptr\fP\fB, png_bytep \fI*exif\fP\fB);\fP + +-\fBpng_uint_32 png_get_gAMA_fixed (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_uint_32 \fI*int_file_gamma\fP\fB);\fP ++\fBpng_uint_32 png_get_eXIf_1 (png_const_structp \fP\fIpng_ptr\fP\fB, png_const_infop \fP\fIinfo_ptr\fP\fB, png_unit_32 \fP\fI*num_exif\fP\fB, png_bytep \fI*exif\fP\fB);\fP + +-\fI\fB ++\fBpng_uint_32 png_get_hIST (png_const_structp \fP\fIpng_ptr\fP\fB, png_const_infop \fP\fIinfo_ptr\fP\fB, png_uint_16p \fI*hist\fP\fB);\fP + +-\fBpng_byte png_get_header_ver (png_structp \fIpng_ptr\fP\fB);\fP +- +-\fI\fB +- +-\fBpng_byte png_get_header_version (png_structp \fIpng_ptr\fP\fB);\fP +- +-\fI\fB +- +-\fBpng_uint_32 png_get_hIST (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_uint_16p \fI*hist\fP\fB);\fP +- +-\fI\fB +- +-\fBpng_uint_32 png_get_iCCP (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_charpp \fP\fIname\fP\fB, int \fP\fI*compression_type\fP\fB, png_charpp \fP\fIprofile\fP\fB, png_uint_32 \fI*proflen\fP\fB);\fP +- +-\fI\fB ++\fBpng_uint_32 png_get_iCCP (png_const_structp \fP\fIpng_ptr\fP\fB, png_const_infop \fP\fIinfo_ptr\fP\fB, png_charpp \fP\fIname\fP\fB, int \fP\fI*compression_type\fP\fB, png_bytepp \fP\fIprofile\fP\fB, png_uint_32 \fI*proflen\fP\fB);\fP + + \fBpng_uint_32 png_get_IHDR (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_uint_32 \fP\fI*width\fP\fB, png_uint_32 \fP\fI*height\fP\fB, int \fP\fI*bit_depth\fP\fB, int \fP\fI*color_type\fP\fB, int \fP\fI*interlace_type\fP\fB, int \fP\fI*compression_type\fP\fB, int \fI*filter_type\fP\fB);\fP + +-\fI\fB +- +-\fBpng_uint_32 png_get_image_height (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fIinfo_ptr\fP\fB);\fP ++\fBpng_uint_32 png_get_image_height (png_const_structp \fP\fIpng_ptr\fP\fB, png_const_infop \fIinfo_ptr\fP\fB);\fP + +-\fI\fB +- +-\fBpng_uint_32 png_get_image_width (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fIinfo_ptr\fP\fB);\fP +- +-\fI\fB +- +-\fB#if \fI!defined(PNG_1_0_X) ++\fBpng_uint_32 png_get_image_width (png_const_structp \fP\fIpng_ptr\fP\fB, png_const_infop \fIinfo_ptr\fP\fB);\fP + + \fBpng_int_32 png_get_int_32 (png_bytep \fIbuf\fP\fB);\fP + +-\fI\fB#endif +- +-\fI\fB ++\fBpng_byte png_get_interlace_type (png_const_structp \fP\fIpng_ptr\fP\fB, png_const_infop \fIinfo_ptr\fP\fB);\fP + +-\fBpng_byte png_get_interlace_type (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fIinfo_ptr\fP\fB);\fP +- +-\fI\fB ++\fBpng_uint_32 png_get_io_chunk_type (png_const_structp \fIpng_ptr\fP\fB);\fP + + \fBpng_voidp png_get_io_ptr (png_structp \fIpng_ptr\fP\fB);\fP + +-\fI\fB +- +-\fBpng_byte png_get_libpng_ver (png_structp \fIpng_ptr\fP\fB);\fP +- +-\fI\fB +- +-\fBpng_voidp png_get_mem_ptr(png_structp \fIpng_ptr\fP\fB);\fP +- +-\fI\fB +- +-\fBpng_uint_32 png_get_oFFs (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_uint_32 \fP\fI*offset_x\fP\fB, png_uint_32 \fP\fI*offset_y\fP\fB, int \fI*unit_type\fP\fB);\fP +- +-\fI\fB +- +-\fBpng_uint_32 png_get_pCAL (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_charp \fP\fI*purpose\fP\fB, png_int_32 \fP\fI*X0\fP\fB, png_int_32 \fP\fI*X1\fP\fB, int \fP\fI*type\fP\fB, int \fP\fI*nparams\fP\fB, png_charp \fP\fI*units\fP\fB, png_charpp \fI*params\fP\fB);\fP +- +-\fI\fB +- +-\fBpng_uint_32 png_get_pHYs (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_uint_32 \fP\fI*res_x\fP\fB, png_uint_32 \fP\fI*res_y\fP\fB, int \fI*unit_type\fP\fB);\fP +- +-\fI\fB +- +-\fBfloat png_get_pixel_aspect_ratio (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fIinfo_ptr\fP\fB);\fP ++\fBpng_uint_32 png_get_io_state (png_structp \fIpng_ptr\fP\fB);\fP + +-\fI\fB ++\fBpng_byte png_get_libpng_ver (png_const_structp \fIpng_ptr\fP\fB);\fP + +-\fBpng_uint_32 png_get_pixels_per_meter (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fIinfo_ptr\fP\fB);\fP ++\fBint png_get_palette_max(png_const_structp \fP\fIpng_ptr\fP\fB, png_const_infop \fIinfo_ptr\fP\fB);\fP + +-\fI\fB ++\fBpng_voidp png_get_mem_ptr (png_const_structp \fIpng_ptr\fP\fB);\fP + +-\fBpng_voidp png_get_progressive_ptr (png_structp \fIpng_ptr\fP\fB);\fP ++\fBpng_uint_32 png_get_oFFs (png_const_structp \fP\fIpng_ptr\fP\fB, png_const_infop \fP\fIinfo_ptr\fP\fB, png_uint_32 \fP\fI*offset_x\fP\fB, png_uint_32 \fP\fI*offset_y\fP\fB, int \fI*unit_type\fP\fB);\fP + +-\fI\fB ++\fBpng_uint_32 png_get_pCAL (png_const_structp \fP\fIpng_ptr\fP\fB, png_const_infop \fP\fIinfo_ptr\fP\fB, png_charp \fP\fI*purpose\fP\fB, png_int_32 \fP\fI*X0\fP\fB, png_int_32 \fP\fI*X1\fP\fB, int \fP\fI*type\fP\fB, int \fP\fI*nparams\fP\fB, png_charp \fP\fI*units\fP\fB, png_charpp \fI*params\fP\fB);\fP + +-\fBpng_uint_32 png_get_PLTE (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_colorp \fP\fI*palette\fP\fB, int \fI*num_palette\fP\fB);\fP ++\fBpng_uint_32 png_get_pHYs (png_const_structp \fP\fIpng_ptr\fP\fB, png_const_infop \fP\fIinfo_ptr\fP\fB, png_uint_32 \fP\fI*res_x\fP\fB, png_uint_32 \fP\fI*res_y\fP\fB, int \fI*unit_type\fP\fB);\fP + +-\fI\fB ++\fBfloat png_get_pixel_aspect_ratio (png_const_structp \fP\fIpng_ptr\fP\fB, png_const_infop \fIinfo_ptr\fP\fB);\fP + +-\fBpng_byte png_get_rgb_to_gray_status (png_structp \fIpng_ptr) ++\fBpng_uint_32 png_get_pHYs_dpi (png_const_structp \fP\fIpng_ptr\fP\fB, png_const_infop \fP\fIinfo_ptr\fP\fB, png_uint_32 \fP\fI*res_x\fP\fB, png_uint_32 \fP\fI*res_y\fP\fB, int \fI*unit_type\fP\fB);\fP + +-\fBpng_uint_32 png_get_rowbytes (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fIinfo_ptr\fP\fB);\fP ++\fBpng_fixed_point png_get_pixel_aspect_ratio_fixed (png_const_structp \fP\fIpng_ptr\fP\fB, png_const_infop \fIinfo_ptr\fP\fB);\fP + +-\fI\fB ++\fBpng_uint_32 png_get_pixels_per_inch (png_const_structp \fP\fIpng_ptr\fP\fB, png_const_infop \fIinfo_ptr\fP\fB);\fP + +-\fBpng_bytepp png_get_rows (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fIinfo_ptr\fP\fB);\fP ++\fBpng_uint_32 png_get_pixels_per_meter (png_const_structp \fP\fIpng_ptr\fP\fB, png_const_infop \fIinfo_ptr\fP\fB);\fP + +-\fI\fB ++\fBpng_voidp png_get_progressive_ptr (png_const_structp \fIpng_ptr\fP\fB);\fP + +-\fBpng_uint_32 png_get_sBIT (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_color_8p \fI*sig_bit\fP\fB);\fP ++\fBpng_uint_32 png_get_PLTE (png_const_structp \fP\fIpng_ptr\fP\fB, png_const_infop \fP\fIinfo_ptr\fP\fB, png_colorp \fP\fI*palette\fP\fB, int \fI*num_palette\fP\fB);\fP + +-\fI\fB ++\fBpng_byte png_get_rgb_to_gray_status (png_const_structp \fIpng_ptr\fP\fB);\fP + +-\fBpng_bytep png_get_signature (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fIinfo_ptr\fP\fB);\fP ++\fBpng_uint_32 png_get_rowbytes (png_const_structp \fP\fIpng_ptr\fP\fB, png_const_infop \fIinfo_ptr\fP\fB);\fP + +-\fI\fB ++\fBpng_bytepp png_get_rows (png_const_structp \fP\fIpng_ptr\fP\fB, png_const_infop \fIinfo_ptr\fP\fB);\fP + +-\fBpng_uint_32 png_get_sPLT (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_spalette_p \fI*splt_ptr\fP\fB);\fP ++\fBpng_uint_32 png_get_sBIT (png_const_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_color_8p \fI*sig_bit\fP\fB);\fP + +-\fI\fB ++\fBvoid png_get_sCAL (png_const_structp \fP\fIpng_ptr\fP\fB, png_const_infop \fP\fIinfo_ptr\fP\fB, int* \fP\fIunit\fP\fB, double* \fP\fIwidth\fP\fB, double* \fIheight\fP\fB);\fP + +-\fBpng_uint_32 png_get_sRGB (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, int \fI*intent\fP\fB);\fP ++\fBvoid png_get_sCAL_fixed (png_const_structp \fP\fIpng_ptr\fP\fB, png_const_infop \fP\fIinfo_ptr\fP\fB, int* \fP\fIunit\fP\fB, png_fixed_pointp \fP\fIwidth\fP\fB, png_fixed_pointp \fIheight\fP\fB);\fP + +-\fI\fB ++\fBvoid png_get_sCAL_s (png_const_structp \fP\fIpng_ptr\fP\fB, png_const_infop \fP\fIinfo_ptr\fP\fB, int* \fP\fIunit\fP\fB, png_charpp \fP\fIwidth\fP\fB, png_charpp \fIheight\fP\fB);\fP + +-\fBpng_uint_32 png_get_text (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_textp \fP\fI*text_ptr\fP\fB, int \fI*num_text\fP\fB);\fP ++\fBpng_bytep png_get_signature (png_const_structp \fP\fIpng_ptr\fP\fB, png_infop \fIinfo_ptr\fP\fB);\fP + +-\fI\fB ++\fBpng_uint_32 png_get_sPLT (png_const_structp \fP\fIpng_ptr\fP\fB, png_const_infop \fP\fIinfo_ptr\fP\fB, png_spalette_p \fI*splt_ptr\fP\fB);\fP + +-\fBpng_uint_32 png_get_tIME (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_timep \fI*mod_time\fP\fB);\fP ++\fBpng_uint_32 png_get_sRGB (png_const_structp \fP\fIpng_ptr\fP\fB, png_const_infop \fP\fIinfo_ptr\fP\fB, int \fI*file_srgb_intent\fP\fB);\fP + +-\fI\fB ++\fBpng_uint_32 png_get_text (png_const_structp \fP\fIpng_ptr\fP\fB, png_const_infop \fP\fIinfo_ptr\fP\fB, png_textp \fP\fI*text_ptr\fP\fB, int \fI*num_text\fP\fB);\fP + +-\fBpng_uint_32 png_get_tRNS (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_bytep \fP\fI*trans\fP\fB, int \fP\fI*num_trans\fP\fB, png_color_16p \fI*trans_values\fP\fB);\fP ++\fBpng_uint_32 png_get_tIME (png_const_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_timep \fI*mod_time\fP\fB);\fP + +-\fI\fB ++\fBpng_uint_32 png_get_tRNS (png_const_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_bytep \fP\fI*trans_alpha\fP\fB, int \fP\fI*num_trans\fP\fB, png_color_16p \fI*trans_color\fP\fB);\fP + +-\fB#if \fI!defined(PNG_1_0_X) ++\fB/* This function is really an inline macro. \fI*/ + + \fBpng_uint_16 png_get_uint_16 (png_bytep \fIbuf\fP\fB);\fP + +-\fI\fB ++\fBpng_uint_32 png_get_uint_31 (png_structp \fP\fIpng_ptr\fP\fB, png_bytep \fIbuf\fP\fB);\fP + +-\fBpng_uint_32 png_get_uint_31 (png_bytep \fIbuf\fP\fB);\fP +- +-\fI\fB ++\fB/* This function is really an inline macro. \fI*/ + + \fBpng_uint_32 png_get_uint_32 (png_bytep \fIbuf\fP\fB);\fP + +-\fI\fB#endif +- +-\fI\fB +- +-\fBpng_uint_32 png_get_unknown_chunks (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_unknown_chunkpp \fIunknowns\fP\fB);\fP +- +-\fI\fB +- +-\fBpng_voidp png_get_user_chunk_ptr (png_structp \fIpng_ptr\fP\fB);\fP +- +-\fI\fB +- +-\fBpng_uint_32 png_get_user_height_max( png_structp \fIpng_ptr\fP\fB);\fP +- +-\fI\fB ++\fBpng_uint_32 png_get_unknown_chunks (png_const_structp \fP\fIpng_ptr\fP\fB, png_const_infop \fP\fIinfo_ptr\fP\fB, png_unknown_chunkpp \fIunknowns\fP\fB);\fP + +-\fBpng_voidp png_get_user_transform_ptr (png_structp \fIpng_ptr\fP\fB);\fP ++\fBpng_voidp png_get_user_chunk_ptr (png_const_structp \fIpng_ptr\fP\fB);\fP + +-\fI\fB ++\fBpng_uint_32 png_get_user_height_max (png_const_structp \fIpng_ptr\fP\fB);\fP + +-\fBpng_uint_32 png_get_user_width_max (png_structp \fIpng_ptr\fP\fB);\fP ++\fBpng_voidp png_get_user_transform_ptr (png_const_structp \fIpng_ptr\fP\fB);\fP + +-\fI\fB ++\fBpng_uint_32 png_get_user_width_max (png_const_structp \fIpng_ptr\fP\fB);\fP + +-\fBpng_uint_32 png_get_valid (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_uint_32 \fIflag\fP\fB);\fP ++\fBpng_uint_32 png_get_valid (png_const_structp \fP\fIpng_ptr\fP\fB, png_const_infop \fP\fIinfo_ptr\fP\fB, png_uint_32 \fIflag\fP\fB);\fP + +-\fI\fB ++\fBfloat png_get_x_offset_inches (png_const_structp \fP\fIpng_ptr\fP\fB, png_const_infop \fIinfo_ptr\fP\fB);\fP + +-\fBpng_int_32 png_get_x_offset_microns (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fIinfo_ptr\fP\fB);\fP ++\fBpng_fixed_point png_get_x_offset_inches_fixed (png_structp \fP\fIpng_ptr\fP\fB, png_const_infop \fIinfo_ptr\fP\fB);\fP + +-\fI\fB ++\fBpng_int_32 png_get_x_offset_microns (png_const_structp \fP\fIpng_ptr\fP\fB, png_const_infop \fIinfo_ptr\fP\fB);\fP + +-\fBpng_int_32 png_get_x_offset_pixels (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fIinfo_ptr\fP\fB);\fP ++\fBpng_int_32 png_get_x_offset_pixels (png_const_structp \fP\fIpng_ptr\fP\fB, png_const_infop \fIinfo_ptr\fP\fB);\fP + +-\fI\fB ++\fBpng_uint_32 png_get_x_pixels_per_inch (png_const_structp \fP\fIpng_ptr\fP\fB, png_const_infop \fIinfo_ptr\fP\fB);\fP + +-\fBpng_uint_32 png_get_x_pixels_per_meter (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fIinfo_ptr\fP\fB);\fP ++\fBpng_uint_32 png_get_x_pixels_per_meter (png_const_structp \fP\fIpng_ptr\fP\fB, png_const_infop \fIinfo_ptr\fP\fB);\fP + +-\fI\fB ++\fBfloat png_get_y_offset_inches (png_const_structp \fP\fIpng_ptr\fP\fB, png_const_infop \fIinfo_ptr\fP\fB);\fP + +-\fBpng_int_32 png_get_y_offset_microns (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fIinfo_ptr\fP\fB);\fP ++\fBpng_fixed_point png_get_y_offset_inches_fixed (png_structp \fP\fIpng_ptr\fP\fB, png_const_infop \fIinfo_ptr\fP\fB);\fP + +-\fI\fB ++\fBpng_int_32 png_get_y_offset_microns (png_const_structp \fP\fIpng_ptr\fP\fB, png_const_infop \fIinfo_ptr\fP\fB);\fP + +-\fBpng_int_32 png_get_y_offset_pixels (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fIinfo_ptr\fP\fB);\fP ++\fBpng_int_32 png_get_y_offset_pixels (png_const_structp \fP\fIpng_ptr\fP\fB, png_const_infop \fIinfo_ptr\fP\fB);\fP + +-\fI\fB ++\fBpng_uint_32 png_get_y_pixels_per_inch (png_const_structp \fP\fIpng_ptr\fP\fB, png_const_infop \fIinfo_ptr\fP\fB);\fP + +-\fBpng_uint_32 png_get_y_pixels_per_meter (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fIinfo_ptr\fP\fB);\fP +- +-\fI\fB +- +-\fBpng_uint_32 png_get_compression_buffer_size (png_structp \fIpng_ptr\fP\fB);\fP +- +-\fI\fB ++\fBpng_uint_32 png_get_y_pixels_per_meter (png_const_structp \fP\fIpng_ptr\fP\fB, png_const_infop \fIinfo_ptr\fP\fB);\fP + + \fBint png_handle_as_unknown (png_structp \fP\fIpng_ptr\fP\fB, png_bytep \fIchunk_name\fP\fB);\fP + +-\fI\fB +- +-\fBvoid png_init_io (png_structp \fP\fIpng_ptr\fP\fB, FILE \fI*fp\fP\fB);\fP +- +-\fI\fB +- +-\fBDEPRECATED: void png_info_init (png_infop \fIinfo_ptr\fP\fB);\fP ++\fBint png_image_begin_read_from_file (png_imagep \fP\fIimage\fP\fB, const char \fI*file_name\fP\fB);\fP + +-\fI\fB ++\fBint png_image_begin_read_from_stdio (png_imagep \fP\fIimage\fP\fB, FILE* \fIfile\fP\fB);\fP + +-\fBDEPRECATED: void png_info_init_2 (png_infopp \fP\fIptr_ptr\fP\fB, png_size_t \fIpng_info_struct_size\fP\fB);\fP ++\fBint, png_image_begin_read_from_memory (png_imagep \fP\fIimage\fP\fB, png_const_voidp \fP\fImemory\fP\fB, size_t \fIsize\fP\fB);\fP + +-\fI\fB ++\fBint png_image_finish_read (png_imagep \fP\fIimage\fP\fB, png_colorp \fP\fIbackground\fP\fB, void \fP\fI*buffer\fP\fB, png_int_32 \fP\fIrow_stride\fP\fB, void \fI*colormap\fP\fB);\fP + +-\fBpng_voidp png_malloc (png_structp \fP\fIpng_ptr\fP\fB, png_uint_32 \fIsize\fP\fB);\fP ++\fBvoid png_image_free (png_imagep \fIimage\fP\fB);\fP + +-\fI\fB ++\fBint png_image_write_to_file (png_imagep \fP\fIimage\fP\fB, const char \fP\fI*file\fP\fB, int \fP\fIconvert_to_8bit\fP\fB, const void \fP\fI*buffer\fP\fB, png_int_32 \fP\fIrow_stride\fP\fB, void \fI*colormap\fP\fB);\fP + +-\fBpng_voidp png_malloc_default(png_structp \fP\fIpng_ptr\fP\fB, png_uint_32 \fIsize\fP\fB);\fP ++\fBint png_image_write_to_memory (png_imagep \fP\fIimage\fP\fB, void \fP\fI*memory\fP\fB, png_alloc_size_t * PNG_RESTRICT \fP\fImemory_bytes\fP\fB, int \fP\fIconvert_to_8_bit\fP\fB, const void \fP\fI*buffer\fP\fB, png_int_32 \fP\fIrow_stride\fP\fB, const void \fI*colormap\fP\fB);\fP + +-\fI\fB ++\fBint png_image_write_to_stdio (png_imagep \fP\fIimage\fP\fB, FILE \fP\fI*file\fP\fB, int \fP\fIconvert_to_8_bit\fP\fB, const void \fP\fI*buffer\fP\fB, png_int_32 \fP\fIrow_stride\fP\fB, void \fI*colormap\fP\fB);\fP + +-\fBvoidp png_memcpy (png_voidp \fP\fIs1\fP\fB, png_voidp \fP\fIs2\fP\fB, png_size_t \fIsize\fP\fB);\fP ++\fBvoid png_info_init_3 (png_infopp \fP\fIinfo_ptr\fP\fB, size_t \fIpng_info_struct_size\fP\fB);\fP + +-\fI\fB +- +-\fBpng_voidp png_memcpy_check (png_structp \fP\fIpng_ptr\fP\fB, png_voidp \fP\fIs1\fP\fB, png_voidp \fP\fIs2\fP\fB, png_uint_32 \fIsize\fP\fB);\fP +- +-\fI\fB ++\fBvoid png_init_io (png_structp \fP\fIpng_ptr\fP\fB, FILE \fI*fp\fP\fB);\fP + +-\fBvoidp png_memset (png_voidp \fP\fIs1\fP\fB, int \fP\fIvalue\fP\fB, png_size_t \fIsize\fP\fB);\fP ++\fBvoid png_longjmp (png_structp \fP\fIpng_ptr\fP\fB, int \fIval\fP\fB);\fP + +-\fI\fB ++\fBpng_voidp png_malloc (png_structp \fP\fIpng_ptr\fP\fB, png_alloc_size_t \fIsize\fP\fB);\fP + +-\fBpng_voidp png_memset_check (png_structp \fP\fIpng_ptr\fP\fB, png_voidp \fP\fIs1\fP\fB, int \fP\fIvalue\fP\fB, png_uint_32 \fIsize\fP\fB);\fP ++\fBpng_voidp png_malloc_default (png_structp \fP\fIpng_ptr\fP\fB, png_alloc_size_t \fIsize\fP\fB);\fP + +-\fI\fB ++\fBpng_voidp png_malloc_warn (png_structp \fP\fIpng_ptr\fP\fB, png_alloc_size_t \fIsize\fP\fB);\fP + +-\fBDEPRECATED: void png_permit_empty_plte (png_structp \fP\fIpng_ptr\fP\fB, int \fIempty_plte_permitted\fP\fB);\fP ++\fBpng_uint_32 png_permit_mng_features (png_structp \fP\fIpng_ptr\fP\fB, png_uint_32 \fImng_features_permitted\fP\fB);\fP + +-\fI\fB ++\fBvoid png_process_data (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_bytep \fP\fIbuffer\fP\fB, size_t \fIbuffer_size\fP\fB);\fP + +-\fBvoid png_process_data (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_bytep \fP\fIbuffer\fP\fB, png_size_t \fIbuffer_size\fP\fB);\fP ++\fBsize_t png_process_data_pause (png_structp \fP\fIpng_ptr\fP\fB, int \fIsave\fP\fB);\fP + +-\fI\fB ++\fBpng_uint_32 png_process_data_skip (png_structp \fP\fIpng_ptr\fP\fB);\fP + + \fBvoid png_progressive_combine_row (png_structp \fP\fIpng_ptr\fP\fB, png_bytep \fP\fIold_row\fP\fB, png_bytep \fInew_row\fP\fB);\fP + +-\fI\fB +- +-\fBvoid png_read_destroy (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_infop \fIend_info_ptr\fP\fB);\fP +- +-\fI\fB +- + \fBvoid png_read_end (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fIinfo_ptr\fP\fB);\fP + +-\fI\fB +- + \fBvoid png_read_image (png_structp \fP\fIpng_ptr\fP\fB, png_bytepp \fIimage\fP\fB);\fP + +-\fI\fB +- +-\fBDEPRECATED: void png_read_init (png_structp \fIpng_ptr\fP\fB);\fP +- +-\fI\fB +- +-\fBDEPRECATED: void png_read_init_2 (png_structpp \fP\fIptr_ptr\fP\fB, png_const_charp \fP\fIuser_png_ver\fP\fB, png_size_t \fP\fIpng_struct_size\fP\fB, png_size_t \fIpng_info_size\fP\fB);\fP +- +-\fI\fB +- + \fBvoid png_read_info (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fIinfo_ptr\fP\fB);\fP + +-\fI\fB +- + \fBvoid png_read_png (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, int \fP\fItransforms\fP\fB, png_voidp \fIparams\fP\fB);\fP + +-\fI\fB +- + \fBvoid png_read_row (png_structp \fP\fIpng_ptr\fP\fB, png_bytep \fP\fIrow\fP\fB, png_bytep \fIdisplay_row\fP\fB);\fP + +-\fI\fB +- + \fBvoid png_read_rows (png_structp \fP\fIpng_ptr\fP\fB, png_bytepp \fP\fIrow\fP\fB, png_bytepp \fP\fIdisplay_row\fP\fB, png_uint_32 \fInum_rows\fP\fB);\fP + +-\fI\fB +- + \fBvoid png_read_update_info (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fIinfo_ptr\fP\fB);\fP + +-\fI\fB ++\fBint png_reset_zstream (png_structp \fIpng_ptr\fP\fB);\fP + +-\fB#if \fI!defined(PNG_1_0_X) +- +-\fBpng_save_int_32 (png_bytep \fP\fIbuf\fP\fB, png_int_32 \fIi\fP\fB);\fP +- +-\fI\fB ++\fBvoid png_save_int_32 (png_bytep \fP\fIbuf\fP\fB, png_int_32 \fIi\fP\fB);\fP + + \fBvoid png_save_uint_16 (png_bytep \fP\fIbuf\fP\fB, unsigned int \fIi\fP\fB);\fP + +-\fI\fB +- + \fBvoid png_save_uint_32 (png_bytep \fP\fIbuf\fP\fB, png_uint_32 \fIi\fP\fB);\fP + +-\fI\fB +- + \fBvoid png_set_add_alpha (png_structp \fP\fIpng_ptr\fP\fB, png_uint_32 \fP\fIfiller\fP\fB, int \fIflags\fP\fB);\fP + +-\fI\fB#endif ++\fBvoid png_set_alpha_mode (png_structp \fP\fIpng_ptr\fP\fB, int \fP\fImode\fP\fB, double \fIoutput_gamma\fP\fB);\fP + +-\fI\fB ++\fBvoid png_set_alpha_mode_fixed (png_structp \fP\fIpng_ptr\fP\fB, int \fP\fImode\fP\fB, png_fixed_point \fIoutput_gamma\fP\fB);\fP + + \fBvoid png_set_background (png_structp \fP\fIpng_ptr\fP\fB, png_color_16p \fP\fIbackground_color\fP\fB, int \fP\fIbackground_gamma_code\fP\fB, int \fP\fIneed_expand\fP\fB, double \fIbackground_gamma\fP\fB);\fP + +-\fI\fB ++\fBvoid png_set_background_fixed (png_structp \fP\fIpng_ptr\fP\fB, png_color_16p \fP\fIbackground_color\fP\fB, int \fP\fIbackground_gamma_code\fP\fB, int \fP\fIneed_expand\fP\fB, png_uint_32 \fIbackground_gamma\fP\fB);\fP + +-\fBvoid png_set_bgr (png_structp \fIpng_ptr\fP\fB);\fP ++\fBvoid png_set_benign_errors (png_structp \fP\fIpng_ptr\fP\fB, int \fIallowed\fP\fB);\fP + +-\fI\fB ++\fBvoid png_set_bgr (png_structp \fIpng_ptr\fP\fB);\fP + + \fBvoid png_set_bKGD (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_color_16p \fIbackground\fP\fB);\fP + +-\fI\fB ++\fBvoid png_set_check_for_invalid_index (png_structrp \fP\fIpng_ptr\fP\fB, int \fIallowed\fP\fB);\fP + + \fBvoid png_set_cHRM (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, double \fP\fIwhite_x\fP\fB, double \fP\fIwhite_y\fP\fB, double \fP\fIred_x\fP\fB, double \fP\fIred_y\fP\fB, double \fP\fIgreen_x\fP\fB, double \fP\fIgreen_y\fP\fB, double \fP\fIblue_x\fP\fB, double \fIblue_y\fP\fB);\fP + +-\fI\fB +- + \fBvoid png_set_cHRM_fixed (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_uint_32 \fP\fIwhite_x\fP\fB, png_uint_32 \fP\fIwhite_y\fP\fB, png_uint_32 \fP\fIred_x\fP\fB, png_uint_32 \fP\fIred_y\fP\fB, png_uint_32 \fP\fIgreen_x\fP\fB, png_uint_32 \fP\fIgreen_y\fP\fB, png_uint_32 \fP\fIblue_x\fP\fB, png_uint_32 \fIblue_y\fP\fB);\fP + +-\fI\fB ++\fBvoid png_set_cHRM_XYZ (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, double \fP\fIred_X\fP\fB, double \fP\fIred_Y\fP\fB, double \fP\fIred_Z\fP\fB, double \fP\fIgreen_X\fP\fB, double \fP\fIgreen_Y\fP\fB, double \fP\fIgreen_Z\fP\fB, double \fP\fIblue_X\fP\fB, double \fP\fIblue_Y\fP\fB, double \fIblue_Z\fP\fB);\fP + +-\fBvoid png_set_compression_level (png_structp \fP\fIpng_ptr\fP\fB, int \fIlevel\fP\fB);\fP ++\fBvoid png_set_cHRM_XYZ_fixed (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_fixed_point \fP\fIint_red_X\fP\fB, png_fixed_point \fP\fIint_red_Y\fP\fB, png_fixed_point \fP\fIint_red_Z\fP\fB, png_fixed_point \fP\fIint_green_X\fP\fB, png_fixed_point \fP\fIint_green_Y\fP\fB, png_fixed_point \fP\fIint_green_Z\fP\fB, png_fixed_point \fP\fIint_blue_X\fP\fB, png_fixed_point \fP\fIint_blue_Y\fP\fB, png_fixed_point \fIint_blue_Z\fP\fB);\fP + +-\fI\fB ++\fBvoid png_set_chunk_cache_max (png_structp \fP\fIpng_ptr\fP\fB, png_uint_32 \fIuser_chunk_cache_max\fP\fB);\fP + +-\fBvoid png_set_compression_mem_level (png_structp \fP\fIpng_ptr\fP\fB, int \fImem_level\fP\fB);\fP ++\fBvoid png_set_compression_level (png_structp \fP\fIpng_ptr\fP\fB, int \fIlevel\fP\fB);\fP + +-\fI\fB ++\fBvoid png_set_compression_mem_level (png_structp \fP\fIpng_ptr\fP\fB, int \fImem_level\fP\fB);\fP + + \fBvoid png_set_compression_method (png_structp \fP\fIpng_ptr\fP\fB, int \fImethod\fP\fB);\fP + +-\fI\fB +- + \fBvoid png_set_compression_strategy (png_structp \fP\fIpng_ptr\fP\fB, int \fIstrategy\fP\fB);\fP + +-\fI\fB +- + \fBvoid png_set_compression_window_bits (png_structp \fP\fIpng_ptr\fP\fB, int \fIwindow_bits\fP\fB);\fP + +-\fI\fB +- + \fBvoid png_set_crc_action (png_structp \fP\fIpng_ptr\fP\fB, int \fP\fIcrit_action\fP\fB, int \fIancil_action\fP\fB);\fP + +-\fI\fB +- +-\fBvoid png_set_dither (png_structp \fP\fIpng_ptr\fP\fB, png_colorp \fP\fIpalette\fP\fB, int \fP\fInum_palette\fP\fB, int \fP\fImaximum_colors\fP\fB, png_uint_16p \fP\fIhistogram\fP\fB, int \fIfull_dither\fP\fB);\fP +- +-\fI\fB +- + \fBvoid png_set_error_fn (png_structp \fP\fIpng_ptr\fP\fB, png_voidp \fP\fIerror_ptr\fP\fB, png_error_ptr \fP\fIerror_fn\fP\fB, png_error_ptr \fIwarning_fn\fP\fB);\fP + +-\fI\fB +- + \fBvoid png_set_expand (png_structp \fIpng_ptr\fP\fB);\fP + +-\fI\fB ++\fBvoid png_set_expand_16 (png_structp \fIpng_ptr\fP\fB);\fP + +-\fBvoid png_set_expand_gray_1_2_4_to_8(png_structp \fIpng_ptr\fP\fB);\fP +- +-\fI\fB ++\fBvoid png_set_expand_gray_1_2_4_to_8 (png_structp \fIpng_ptr\fP\fB);\fP + + \fBvoid png_set_filler (png_structp \fP\fIpng_ptr\fP\fB, png_uint_32 \fP\fIfiller\fP\fB, int \fIflags\fP\fB);\fP + +-\fI\fB +- + \fBvoid png_set_filter (png_structp \fP\fIpng_ptr\fP\fB, int \fP\fImethod\fP\fB, int \fIfilters\fP\fB);\fP + +-\fI\fB +- + \fBvoid png_set_filter_heuristics (png_structp \fP\fIpng_ptr\fP\fB, int \fP\fIheuristic_method\fP\fB, int \fP\fInum_weights\fP\fB, png_doublep \fP\fIfilter_weights\fP\fB, png_doublep \fIfilter_costs\fP\fB);\fP + +-\fI\fB ++\fBvoid png_set_filter_heuristics_fixed (png_structp \fP\fIpng_ptr\fP\fB, int \fP\fIheuristic_method\fP\fB, int \fP\fInum_weights\fP\fB, png_fixed_point_p \fP\fIfilter_weights\fP\fB, png_fixed_point_p \fIfilter_costs\fP\fB);\fP + + \fBvoid png_set_flush (png_structp \fP\fIpng_ptr\fP\fB, int \fInrows\fP\fB);\fP + +-\fI\fB +- + \fBvoid png_set_gamma (png_structp \fP\fIpng_ptr\fP\fB, double \fP\fIscreen_gamma\fP\fB, double \fIdefault_file_gamma\fP\fB);\fP + +-\fI\fB ++\fBvoid png_set_gamma_fixed (png_structp \fP\fIpng_ptr\fP\fB, png_uint_32 \fP\fIscreen_gamma\fP\fB, png_uint_32 \fIdefault_file_gamma\fP\fB);\fP + + \fBvoid png_set_gAMA (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, double \fIfile_gamma\fP\fB);\fP + +-\fI\fB +- + \fBvoid png_set_gAMA_fixed (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_uint_32 \fIfile_gamma\fP\fB);\fP + +-\fI\fB +- +-\fBvoid png_set_gray_1_2_4_to_8(png_structp \fIpng_ptr\fP\fB);\fP +- +-\fI\fB ++\fBvoid png_set_gray_1_2_4_to_8 (png_structp \fIpng_ptr\fP\fB);\fP + + \fBvoid png_set_gray_to_rgb (png_structp \fIpng_ptr\fP\fB);\fP + +-\fI\fB +- +-\fBvoid png_set_hIST (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_uint_16p \fIhist\fP\fB);\fP ++\fBvoid png_set_eXIf (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_bytep \fIexif\fP\fB);\fP + +-\fI\fB ++\fBvoid png_set_eXIf_1 (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_uint_32 \fP\fInum_exif\fP\fB, png_bytep \fIexif\fP\fB);\fP + +-\fBvoid png_set_iCCP (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_charp \fP\fIname\fP\fB, int \fP\fIcompression_type\fP\fB, png_charp \fP\fIprofile\fP\fB, png_uint_32 \fIproflen\fP\fB);\fP ++\fBvoid png_set_hIST (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_uint_16p \fIhist\fP\fB);\fP + +-\fI\fB ++\fBvoid png_set_iCCP (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_const_charp \fP\fIname\fP\fB, int \fP\fIcompression_type\fP\fB, png_const_bytep \fP\fIprofile\fP\fB, png_uint_32 \fIproflen\fP\fB);\fP + + \fBint png_set_interlace_handling (png_structp \fIpng_ptr\fP\fB);\fP + +-\fI\fB +- + \fBvoid png_set_invalid (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, int \fImask\fP\fB);\fP + +-\fI\fB +- + \fBvoid png_set_invert_alpha (png_structp \fIpng_ptr\fP\fB);\fP + +-\fI\fB +- + \fBvoid png_set_invert_mono (png_structp \fIpng_ptr\fP\fB);\fP + +-\fI\fB +- + \fBvoid png_set_IHDR (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_uint_32 \fP\fIwidth\fP\fB, png_uint_32 \fP\fIheight\fP\fB, int \fP\fIbit_depth\fP\fB, int \fP\fIcolor_type\fP\fB, int \fP\fIinterlace_type\fP\fB, int \fP\fIcompression_type\fP\fB, int \fIfilter_type\fP\fB);\fP + +-\fI\fB +- + \fBvoid png_set_keep_unknown_chunks (png_structp \fP\fIpng_ptr\fP\fB, int \fP\fIkeep\fP\fB, png_bytep \fP\fIchunk_list\fP\fB, int \fInum_chunks\fP\fB);\fP + +-\fI\fB ++\fBjmp_buf* png_set_longjmp_fn (png_structp \fP\fIpng_ptr\fP\fB, png_longjmp_ptr \fP\fIlongjmp_fn\fP\fB, size_t \fIjmp_buf_size\fP\fB);\fP ++ ++\fBvoid png_set_chunk_malloc_max (png_structp \fP\fIpng_ptr\fP\fB, png_alloc_size_t \fIuser_chunk_cache_max\fP\fB);\fP + +-\fBvoid png_set_mem_fn(png_structp \fP\fIpng_ptr\fP\fB, png_voidp \fP\fImem_ptr\fP\fB, png_malloc_ptr \fP\fImalloc_fn\fP\fB, png_free_ptr \fIfree_fn\fP\fB);\fP ++\fBvoid png_set_compression_buffer_size (png_structp \fP\fIpng_ptr\fP\fB, png_uint_32 \fIsize\fP\fB);\fP + +-\fI\fB ++\fBvoid png_set_mem_fn (png_structp \fP\fIpng_ptr\fP\fB, png_voidp \fP\fImem_ptr\fP\fB, png_malloc_ptr \fP\fImalloc_fn\fP\fB, png_free_ptr \fIfree_fn\fP\fB);\fP + + \fBvoid png_set_oFFs (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_uint_32 \fP\fIoffset_x\fP\fB, png_uint_32 \fP\fIoffset_y\fP\fB, int \fIunit_type\fP\fB);\fP + +-\fI\fB ++\fBint png_set_option(png_structrp \fP\fIpng_ptr\fP\fB, int \fP\fIoption\fP\fB, int \fIonoff\fP\fB);\fP + + \fBvoid png_set_packing (png_structp \fIpng_ptr\fP\fB);\fP + +-\fI\fB +- + \fBvoid png_set_packswap (png_structp \fIpng_ptr\fP\fB);\fP + +-\fI\fB +- +-\fBvoid png_set_palette_to_rgb(png_structp \fIpng_ptr\fP\fB);\fP +- +-\fI\fB ++\fBvoid png_set_palette_to_rgb (png_structp \fIpng_ptr\fP\fB);\fP + + \fBvoid png_set_pCAL (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_charp \fP\fIpurpose\fP\fB, png_int_32 \fP\fIX0\fP\fB, png_int_32 \fP\fIX1\fP\fB, int \fP\fItype\fP\fB, int \fP\fInparams\fP\fB, png_charp \fP\fIunits\fP\fB, png_charpp \fIparams\fP\fB);\fP + +-\fI\fB +- + \fBvoid png_set_pHYs (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_uint_32 \fP\fIres_x\fP\fB, png_uint_32 \fP\fIres_y\fP\fB, int \fIunit_type\fP\fB);\fP + +-\fI\fB +- + \fBvoid png_set_progressive_read_fn (png_structp \fP\fIpng_ptr\fP\fB, png_voidp \fP\fIprogressive_ptr\fP\fB, png_progressive_info_ptr \fP\fIinfo_fn\fP\fB, png_progressive_row_ptr \fP\fIrow_fn\fP\fB, png_progressive_end_ptr \fIend_fn\fP\fB);\fP + +-\fI\fB +- + \fBvoid png_set_PLTE (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_colorp \fP\fIpalette\fP\fB, int \fInum_palette\fP\fB);\fP + +-\fI\fB ++\fBvoid png_set_quantize (png_structp \fP\fIpng_ptr\fP\fB, png_colorp \fP\fIpalette\fP\fB, int \fP\fInum_palette\fP\fB, int \fP\fImaximum_colors\fP\fB, png_uint_16p \fP\fIhistogram\fP\fB, int \fIfull_quantize\fP\fB);\fP + + \fBvoid png_set_read_fn (png_structp \fP\fIpng_ptr\fP\fB, png_voidp \fP\fIio_ptr\fP\fB, png_rw_ptr \fIread_data_fn\fP\fB);\fP + +-\fI\fB +- + \fBvoid png_set_read_status_fn (png_structp \fP\fIpng_ptr\fP\fB, png_read_status_ptr \fIread_row_fn\fP\fB);\fP + +-\fI\fB ++\fBvoid png_set_read_user_chunk_fn (png_structp \fP\fIpng_ptr\fP\fB, png_voidp \fP\fIuser_chunk_ptr\fP\fB, png_user_chunk_ptr \fIread_user_chunk_fn\fP\fB);\fP + + \fBvoid png_set_read_user_transform_fn (png_structp \fP\fIpng_ptr\fP\fB, png_user_transform_ptr \fIread_user_transform_fn\fP\fB);\fP + +-\fI\fB +- + \fBvoid png_set_rgb_to_gray (png_structp \fP\fIpng_ptr\fP\fB, int \fP\fIerror_action\fP\fB, double \fP\fIred\fP\fB, double \fIgreen\fP\fB);\fP + +-\fI\fB +- +-\fBvoid png_set_rgb_to_gray_fixed (png_structp \fP\fIpng_ptr\fP\fB, int error_action png_fixed_point \fP\fIred\fP\fB, png_fixed_point \fIgreen\fP\fB);\fP +- +-\fI\fB ++\fBvoid png_set_rgb_to_gray_fixed (png_structp \fP\fIpng_ptr\fP\fB, int error_action png_uint_32 \fP\fIred\fP\fB, png_uint_32 \fIgreen\fP\fB);\fP + + \fBvoid png_set_rows (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_bytepp \fIrow_pointers\fP\fB);\fP + +-\fI\fB +- + \fBvoid png_set_sBIT (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_color_8p \fIsig_bit\fP\fB);\fP + +-\fI\fB ++\fBvoid png_set_sCAL (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, int \fP\fIunit\fP\fB, double \fP\fIwidth\fP\fB, double \fIheight\fP\fB);\fP + +-\fBvoid png_set_sCAL (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_charp \fP\fIunit\fP\fB, double \fP\fIwidth\fP\fB, double \fIheight\fP\fB);\fP ++\fBvoid png_set_sCAL_fixed (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, int \fP\fIunit\fP\fB, png_fixed_point \fP\fIwidth\fP\fB, png_fixed_point \fIheight\fP\fB);\fP + +-\fI\fB ++\fBvoid png_set_sCAL_s (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, int \fP\fIunit\fP\fB, png_charp \fP\fIwidth\fP\fB, png_charp \fIheight\fP\fB);\fP + +-\fBvoid png_set_shift (png_structp \fP\fIpng_ptr\fP\fB, png_color_8p \fItrue_bits\fP\fB);\fP ++\fBvoid png_set_scale_16 (png_structp \fIpng_ptr\fP\fB);\fP + +-\fI\fB ++\fBvoid png_set_shift (png_structp \fP\fIpng_ptr\fP\fB, png_color_8p \fItrue_bits\fP\fB);\fP + + \fBvoid png_set_sig_bytes (png_structp \fP\fIpng_ptr\fP\fB, int \fInum_bytes\fP\fB);\fP + +-\fI\fB +- + \fBvoid png_set_sPLT (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_spalette_p \fP\fIsplt_ptr\fP\fB, int \fInum_spalettes\fP\fB);\fP + +-\fI\fB +- +-\fBvoid png_set_sRGB (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, int \fIintent\fP\fB);\fP +- +-\fI\fB ++\fBvoid png_set_sRGB (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, int \fIsrgb_intent\fP\fB);\fP + +-\fBvoid png_set_sRGB_gAMA_and_cHRM (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, int \fIintent\fP\fB);\fP +- +-\fI\fB ++\fBvoid png_set_sRGB_gAMA_and_cHRM (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, int \fIsrgb_intent\fP\fB);\fP + + \fBvoid png_set_strip_16 (png_structp \fIpng_ptr\fP\fB);\fP + +-\fI\fB +- + \fBvoid png_set_strip_alpha (png_structp \fIpng_ptr\fP\fB);\fP + +-\fI\fB ++\fBvoid png_set_strip_error_numbers (png_structp \fP\fIpng_ptr\fP\fB, png_uint_32 \fIstrip_mode\fP\fB);\fP + + \fBvoid png_set_swap (png_structp \fIpng_ptr\fP\fB);\fP + +-\fI\fB +- + \fBvoid png_set_swap_alpha (png_structp \fIpng_ptr\fP\fB);\fP + +-\fI\fB +- + \fBvoid png_set_text (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_textp \fP\fItext_ptr\fP\fB, int \fInum_text\fP\fB);\fP + +-\fI\fB ++\fBvoid png_set_text_compression_level (png_structp \fP\fIpng_ptr\fP\fB, int \fIlevel\fP\fB);\fP + +-\fBvoid png_set_tIME (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_timep \fImod_time\fP\fB);\fP +- +-\fI\fB +- +-\fBvoid png_set_tRNS (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_bytep \fP\fItrans\fP\fB, int \fP\fInum_trans\fP\fB, png_color_16p \fItrans_values\fP\fB);\fP +- +-\fI\fB ++\fBvoid png_set_text_compression_mem_level (png_structp \fP\fIpng_ptr\fP\fB, int \fImem_level\fP\fB);\fP + +-\fBvoid png_set_tRNS_to_alpha(png_structp \fIpng_ptr\fP\fB);\fP ++\fBvoid png_set_text_compression_strategy (png_structp \fP\fIpng_ptr\fP\fB, int \fIstrategy\fP\fB);\fP + +-\fI\fB ++\fBvoid png_set_text_compression_window_bits (png_structp \fP\fIpng_ptr\fP\fB, int \fIwindow_bits\fP\fB);\fP + +-\fBpng_uint_32 png_set_unknown_chunks (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_unknown_chunkp \fP\fIunknowns\fP\fB, int \fP\fInum\fP\fB, int \fIlocation\fP\fB);\fP ++\fBvoid png_set_text_compression_method (png_structp \fP\fIpng_ptr\fP\fB, int \fImethod\fP\fB);\fP + +-\fI\fB ++\fBvoid png_set_tIME (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_timep \fImod_time\fP\fB);\fP + +-\fBvoid png_set_unknown_chunk_location(png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, int \fP\fIchunk\fP\fB, int \fIlocation\fP\fB);\fP ++\fBvoid png_set_tRNS (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_bytep \fP\fItrans_alpha\fP\fB, int \fP\fInum_trans\fP\fB, png_color_16p \fItrans_color\fP\fB);\fP + +-\fI\fB ++\fBvoid png_set_tRNS_to_alpha (png_structp \fIpng_ptr\fP\fB);\fP + +-\fBvoid png_set_read_user_chunk_fn (png_structp \fP\fIpng_ptr\fP\fB, png_voidp \fP\fIuser_chunk_ptr\fP\fB, png_user_chunk_ptr \fIread_user_chunk_fn\fP\fB);\fP ++\fBpng_uint_32 png_set_unknown_chunks (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_unknown_chunkp \fP\fIunknowns\fP\fB, int \fP\fInum\fP\fB, int \fIlocation\fP\fB);\fP + +-\fI\fB ++\fBvoid png_set_unknown_chunk_location (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, int \fP\fIchunk\fP\fB, int \fIlocation\fP\fB);\fP + + \fBvoid png_set_user_limits (png_structp \fP\fIpng_ptr\fP\fB, png_uint_32 \fP\fIuser_width_max\fP\fB, png_uint_32 \fIuser_height_max\fP\fB);\fP + +-\fI\fB +- + \fBvoid png_set_user_transform_info (png_structp \fP\fIpng_ptr\fP\fB, png_voidp \fP\fIuser_transform_ptr\fP\fB, int \fP\fIuser_transform_depth\fP\fB, int \fIuser_transform_channels\fP\fB);\fP + +-\fI\fB +- + \fBvoid png_set_write_fn (png_structp \fP\fIpng_ptr\fP\fB, png_voidp \fP\fIio_ptr\fP\fB, png_rw_ptr \fP\fIwrite_data_fn\fP\fB, png_flush_ptr \fIoutput_flush_fn\fP\fB);\fP + +-\fI\fB +- + \fBvoid png_set_write_status_fn (png_structp \fP\fIpng_ptr\fP\fB, png_write_status_ptr \fIwrite_row_fn\fP\fB);\fP + +-\fI\fB +- + \fBvoid png_set_write_user_transform_fn (png_structp \fP\fIpng_ptr\fP\fB, png_user_transform_ptr \fIwrite_user_transform_fn\fP\fB);\fP + +-\fI\fB +- +-\fBvoid png_set_compression_buffer_size(png_structp \fP\fIpng_ptr\fP\fB, png_uint_32 \fIsize\fP\fB);\fP +- +-\fI\fB +- +-\fBint png_sig_cmp (png_bytep \fP\fIsig\fP\fB, png_size_t \fP\fIstart\fP\fB, png_size_t \fInum_to_check\fP\fB);\fP +- +-\fI\fB ++\fBint png_sig_cmp (png_bytep \fP\fIsig\fP\fB, size_t \fP\fIstart\fP\fB, size_t \fInum_to_check\fP\fB);\fP + + \fBvoid png_start_read_image (png_structp \fIpng_ptr\fP\fB);\fP + +-\fI\fB +- + \fBvoid png_warning (png_structp \fP\fIpng_ptr\fP\fB, png_const_charp \fImessage\fP\fB);\fP + +-\fI\fB +- +-\fBvoid png_write_chunk (png_structp \fP\fIpng_ptr\fP\fB, png_bytep \fP\fIchunk_name\fP\fB, png_bytep \fP\fIdata\fP\fB, png_size_t \fIlength\fP\fB);\fP +- +-\fI\fB +- +-\fBvoid png_write_chunk_data (png_structp \fP\fIpng_ptr\fP\fB, png_bytep \fP\fIdata\fP\fB, png_size_t \fIlength\fP\fB);\fP ++\fBvoid png_write_chunk (png_structp \fP\fIpng_ptr\fP\fB, png_bytep \fP\fIchunk_name\fP\fB, png_bytep \fP\fIdata\fP\fB, size_t \fIlength\fP\fB);\fP + +-\fI\fB ++\fBvoid png_write_chunk_data (png_structp \fP\fIpng_ptr\fP\fB, png_bytep \fP\fIdata\fP\fB, size_t \fIlength\fP\fB);\fP + + \fBvoid png_write_chunk_end (png_structp \fIpng_ptr\fP\fB);\fP + +-\fI\fB +- + \fBvoid png_write_chunk_start (png_structp \fP\fIpng_ptr\fP\fB, png_bytep \fP\fIchunk_name\fP\fB, png_uint_32 \fIlength\fP\fB);\fP + +-\fI\fB +- +-\fBvoid png_write_destroy (png_structp \fIpng_ptr\fP\fB);\fP +- +-\fI\fB +- + \fBvoid png_write_end (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fIinfo_ptr\fP\fB);\fP + +-\fI\fB +- + \fBvoid png_write_flush (png_structp \fIpng_ptr\fP\fB);\fP + +-\fI\fB +- + \fBvoid png_write_image (png_structp \fP\fIpng_ptr\fP\fB, png_bytepp \fIimage\fP\fB);\fP + +-\fI\fB +- +-\fBDEPRECATED: void png_write_init (png_structp \fIpng_ptr\fP\fB);\fP +- +-\fI\fB +- +-\fBDEPRECATED: void png_write_init_2 (png_structpp \fP\fIptr_ptr\fP\fB, png_const_charp \fP\fIuser_png_ver\fP\fB, png_size_t \fP\fIpng_struct_size\fP\fB, png_size_t \fIpng_info_size\fP\fB);\fP +- +-\fI\fB +- + \fBvoid png_write_info (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fIinfo_ptr\fP\fB);\fP + +-\fI\fB +- + \fBvoid png_write_info_before_PLTE (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fIinfo_ptr\fP\fB);\fP + +-\fI\fB +- + \fBvoid png_write_png (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, int \fP\fItransforms\fP\fB, png_voidp \fIparams\fP\fB);\fP + +-\fI\fB +- + \fBvoid png_write_row (png_structp \fP\fIpng_ptr\fP\fB, png_bytep \fIrow\fP\fB);\fP + +-\fI\fB +- + \fBvoid png_write_rows (png_structp \fP\fIpng_ptr\fP\fB, png_bytepp \fP\fIrow\fP\fB, png_uint_32 \fInum_rows\fP\fB);\fP + +-\fI\fB +- +-\fBvoidpf png_zalloc (voidpf \fP\fIpng_ptr\fP\fB, uInt \fP\fIitems\fP\fB, uInt \fIsize\fP\fB);\fP +- +-\fI\fB +- +-\fBvoid png_zfree (voidpf \fP\fIpng_ptr\fP\fB, voidpf \fIptr\fP\fB);\fP +- +-\fI\fB ++\fBvoid png_write_sig (png_structp \fIpng_ptr\fP\fB);\fP + + .SH DESCRIPTION + The +@@ -817,14 +514,13 @@ library supports encoding, decoding, and various manipulations of + the Portable Network Graphics (PNG) format image files. It uses the + .IR zlib(3) + compression library. +-Following is a copy of the libpng.txt file that accompanies libpng. ++Following is a copy of the libpng-manual.txt file that accompanies libpng. ++ + .SH LIBPNG.TXT +-libpng.txt - A description on how to use and modify libpng ++libpng-manual.txt - A description on how to use and modify libpng + +- libpng version 1.2.44 - June 26, 2010 +- Updated and distributed by Glenn Randers-Pehrson +- +- Copyright (c) 1998-2009 Glenn Randers-Pehrson ++ Copyright (c) 2018 Cosmin Truta ++ Copyright (c) 1998-2018 Glenn Randers-Pehrson + + This document is released under the libpng license. + For conditions of distribution and use, see the disclaimer +@@ -832,15 +528,19 @@ libpng.txt - A description on how to use and modify libpng + + Based on: + +- libpng versions 0.97, January 1998, through 1.2.44 - June 26, 2010 ++ libpng version 1.6.36 - December 1, 2018 ++ Updated and distributed by Cosmin Truta ++ Copyright (c) 2018 Cosmin Truta ++ ++ libpng versions 0.97, January 1998, through 1.6.35 - July 15, 2018 + Updated and distributed by Glenn Randers-Pehrson +- Copyright (c) 1998-2009 Glenn Randers-Pehrson ++ Copyright (c) 1998-2018 Glenn Randers-Pehrson + +- libpng 1.0 beta 6 version 0.96 May 28, 1997 ++ libpng 1.0 beta 6 - version 0.96 - May 28, 1997 + Updated and distributed by Andreas Dilger + Copyright (c) 1996, 1997 Andreas Dilger + +- libpng 1.0 beta 2 - version 0.88 January 26, 1996 ++ libpng 1.0 beta 2 - version 0.88 - January 26, 1996 + For conditions of distribution and use, see copyright + notice in png.h. Copyright (c) 1995, 1996 Guy Eric + Schalnat, Group 42, Inc. +@@ -849,16 +549,32 @@ libpng.txt - A description on how to use and modify libpng + Copyright (c) 1995, 1996 Frank J. T. Wojcik + December 18, 1995 & January 20, 1996 + ++ TABLE OF CONTENTS ++ ++ I. Introduction ++ II. Structures ++ III. Reading ++ IV. Writing ++ V. Simplified API ++ VI. Modifying/Customizing libpng ++ VII. MNG support ++ VIII. Changes to Libpng from version 0.88 ++ IX. Changes to Libpng from version 1.0.x to 1.2.x ++ X. Changes to Libpng from version 1.0.x/1.2.x to 1.4.x ++ XI. Changes to Libpng from version 1.4.x to 1.5.x ++ XII. Changes to Libpng from version 1.5.x to 1.6.x ++ XIII. Detecting libpng ++ XIV. Source code repository ++ XV. Coding style ++ + .SH I. Introduction + + This file describes how to use and modify the PNG reference library +-(known as libpng) for your own use. There are five sections to this +-file: introduction, structures, reading, writing, and modification and +-configuration notes for various special platforms. In addition to this ++(known as libpng) for your own use. In addition to this + file, example.c is a good starting point for using the library, as + it is heavily commented and should include everything most people + will need. We assume that libpng is already installed; see the +-INSTALL file for instructions on how to install libpng. ++INSTALL file for instructions on how to configure and install libpng. + + For examples of libpng usage, see the files "example.c", "pngtest.c", + and the files in the "contrib" directory, all of which are included in +@@ -869,20 +585,21 @@ of reducing the amount of time and effort it takes to support the PNG + file format in application programs. + + The PNG specification (second edition), November 2003, is available as +-a W3C Recommendation and as an ISO Standard (ISO/IEC 15948:2003 (E)) at +-. + The W3C and ISO documents have identical technical content. + + The PNG-1.2 specification is available at +-. It is technically equivalent ++. ++It is technically equivalent + to the PNG specification (second edition) but has some additional material. + +-The PNG-1.0 specification is available +-as RFC 2083 and as a +-W3C Recommendation . ++The PNG-1.0 specification is available as RFC 2083 at ++ and as a ++W3C Recommendation at . + + Some additional chunks are described in the special-purpose public chunks +-documents at . ++documents at + + Other information + about PNG, and the latest version of libpng, can be found at the PNG home +@@ -904,7 +621,7 @@ majority of the needs of its users. + + Libpng uses zlib for its compression and decompression of PNG files. + Further information about zlib, and the latest version of zlib, can +-be found at the zlib home page, . ++be found at the zlib home page, . + The zlib compression utility is a general purpose utility that is + useful for more than PNG files, and can be used without libpng. + See the documentation delivered with zlib for more details. +@@ -920,34 +637,203 @@ same instance of a structure. + .SH II. Structures + + There are two main structures that are important to libpng, png_struct +-and png_info. The first, png_struct, is an internal structure that +-will not, for the most part, be used by a user except as the first +-variable passed to every libpng function call. ++and png_info. Both are internal structures that are no longer exposed ++in the libpng interface (as of libpng 1.5.0). + + The png_info structure is designed to provide information about the + PNG file. At one time, the fields of png_info were intended to be + directly accessible to the user. However, this tended to cause problems + with applications using dynamically loaded libraries, and as a result + a set of interface functions for png_info (the png_get_*() and png_set_*() +-functions) was developed. The fields of png_info are still available for +-older applications, but it is suggested that applications use the new +-interfaces if at all possible. +- +-Applications that do make direct access to the members of png_struct (except +-for png_ptr->jmpbuf) must be recompiled whenever the library is updated, +-and applications that make direct access to the members of png_info must +-be recompiled if they were compiled or loaded with libpng version 1.0.6, +-in which the members were in a different order. In version 1.0.7, the +-members of the png_info structure reverted to the old order, as they were +-in versions 0.97c through 1.0.5. Starting with version 2.0.0, both +-structures are going to be hidden, and the contents of the structures will +-only be accessible through the png_get/png_set functions. ++functions) was developed, and direct access to the png_info fields was ++deprecated.. ++ ++The png_struct structure is the object used by the library to decode a ++single image. As of 1.5.0 this structure is also not exposed. ++ ++Almost all libpng APIs require a pointer to a png_struct as the first argument. ++Many (in particular the png_set and png_get APIs) also require a pointer ++to png_info as the second argument. Some application visible macros ++defined in png.h designed for basic data access (reading and writing ++integers in the PNG format) don't take a png_info pointer, but it's almost ++always safe to assume that a (png_struct*) has to be passed to call an API ++function. ++ ++You can have more than one png_info structure associated with an image, ++as illustrated in pngtest.c, one for information valid prior to the ++IDAT chunks and another (called "end_info" below) for things after them. + + The png.h header file is an invaluable reference for programming with libpng. + And while I'm on the topic, make sure you include the libpng header file: + + #include + ++and also (as of libpng-1.5.0) the zlib header file, if you need it: ++ ++#include ++ ++.SS Types ++ ++The png.h header file defines a number of integral types used by the ++APIs. Most of these are fairly obvious; for example types corresponding ++to integers of particular sizes and types for passing color values. ++ ++One exception is how non-integral numbers are handled. For application ++convenience most APIs that take such numbers have C (double) arguments; ++however, internally PNG, and libpng, use 32 bit signed integers and encode ++the value by multiplying by 100,000. As of libpng 1.5.0 a convenience ++macro PNG_FP_1 is defined in png.h along with a type (png_fixed_point) ++which is simply (png_int_32). ++ ++All APIs that take (double) arguments also have a matching API that ++takes the corresponding fixed point integer arguments. The fixed point ++API has the same name as the floating point one with "_fixed" appended. ++The actual range of values permitted in the APIs is frequently less than ++the full range of (png_fixed_point) (\-21474 to +21474). When APIs require ++a non-negative argument the type is recorded as png_uint_32 above. Consult ++the header file and the text below for more information. ++ ++Special care must be take with sCAL chunk handling because the chunk itself ++uses non-integral values encoded as strings containing decimal floating point ++numbers. See the comments in the header file. ++ ++.SS Configuration ++ ++The main header file function declarations are frequently protected by C ++preprocessing directives of the form: ++ ++ #ifdef PNG_feature_SUPPORTED ++ declare-function ++ #endif ++ ... ++ #ifdef PNG_feature_SUPPORTED ++ use-function ++ #endif ++ ++The library can be built without support for these APIs, although a ++standard build will have all implemented APIs. Application programs ++should check the feature macros before using an API for maximum ++portability. From libpng 1.5.0 the feature macros set during the build ++of libpng are recorded in the header file "pnglibconf.h" and this file ++is always included by png.h. ++ ++If you don't need to change the library configuration from the default, skip to ++the next section ("Reading"). ++ ++Notice that some of the makefiles in the 'scripts' directory and (in 1.5.0) all ++of the build project files in the 'projects' directory simply copy ++scripts/pnglibconf.h.prebuilt to pnglibconf.h. This means that these build ++systems do not permit easy auto-configuration of the library - they only ++support the default configuration. ++ ++The easiest way to make minor changes to the libpng configuration when ++auto-configuration is supported is to add definitions to the command line ++using (typically) CPPFLAGS. For example: ++ ++CPPFLAGS=\-DPNG_NO_FLOATING_ARITHMETIC ++ ++will change the internal libpng math implementation for gamma correction and ++other arithmetic calculations to fixed point, avoiding the need for fast ++floating point support. The result can be seen in the generated pnglibconf.h - ++make sure it contains the changed feature macro setting. ++ ++If you need to make more extensive configuration changes - more than one or two ++feature macro settings - you can either add \-DPNG_USER_CONFIG to the build ++command line and put a list of feature macro settings in pngusr.h or you can set ++DFA_XTRA (a makefile variable) to a file containing the same information in the ++form of 'option' settings. ++ ++A. Changing pnglibconf.h ++ ++A variety of methods exist to build libpng. Not all of these support ++reconfiguration of pnglibconf.h. To reconfigure pnglibconf.h it must either be ++rebuilt from scripts/pnglibconf.dfa using awk or it must be edited by hand. ++ ++Hand editing is achieved by copying scripts/pnglibconf.h.prebuilt to ++pnglibconf.h and changing the lines defining the supported features, paying ++very close attention to the 'option' information in scripts/pnglibconf.dfa ++that describes those features and their requirements. This is easy to get ++wrong. ++ ++B. Configuration using DFA_XTRA ++ ++Rebuilding from pnglibconf.dfa is easy if a functioning 'awk', or a later ++variant such as 'nawk' or 'gawk', is available. The configure build will ++automatically find an appropriate awk and build pnglibconf.h. ++The scripts/pnglibconf.mak file contains a set of make rules for doing the ++same thing if configure is not used, and many of the makefiles in the scripts ++directory use this approach. ++ ++When rebuilding simply write a new file containing changed options and set ++DFA_XTRA to the name of this file. This causes the build to append the new file ++to the end of scripts/pnglibconf.dfa. The pngusr.dfa file should contain lines ++of the following forms: ++ ++everything = off ++ ++This turns all optional features off. Include it at the start of pngusr.dfa to ++make it easier to build a minimal configuration. You will need to turn at least ++some features on afterward to enable either reading or writing code, or both. ++ ++option feature on ++option feature off ++ ++Enable or disable a single feature. This will automatically enable other ++features required by a feature that is turned on or disable other features that ++require a feature which is turned off. Conflicting settings will cause an error ++message to be emitted by awk. ++ ++setting feature default value ++ ++Changes the default value of setting 'feature' to 'value'. There are a small ++number of settings listed at the top of pnglibconf.h, they are documented in the ++source code. Most of these values have performance implications for the library ++but most of them have no visible effect on the API. Some can also be overridden ++from the API. ++ ++This method of building a customized pnglibconf.h is illustrated in ++contrib/pngminim/*. See the "$(PNGCONF):" target in the makefile and ++pngusr.dfa in these directories. ++ ++C. Configuration using PNG_USER_CONFIG ++ ++If \-DPNG_USER_CONFIG is added to the CPPFLAGS when pnglibconf.h is built, ++the file pngusr.h will automatically be included before the options in ++scripts/pnglibconf.dfa are processed. Your pngusr.h file should contain only ++macro definitions turning features on or off or setting settings. ++ ++Apart from the global setting "everything = off" all the options listed above ++can be set using macros in pngusr.h: ++ ++#define PNG_feature_SUPPORTED ++ ++is equivalent to: ++ ++option feature on ++ ++#define PNG_NO_feature ++ ++is equivalent to: ++ ++option feature off ++ ++#define PNG_feature value ++ ++is equivalent to: ++ ++setting feature default value ++ ++Notice that in both cases, pngusr.dfa and pngusr.h, the contents of the ++pngusr file you supply override the contents of scripts/pnglibconf.dfa ++ ++If confusing or incomprehensible behavior results it is possible to ++examine the intermediate file pnglibconf.dfn to find the full set of ++dependency information for each setting and option. Simply locate the ++feature in the file and read the C comments that precede it. ++ ++This method is also illustrated in the contrib/pngminim/* makefiles and ++pngusr.h. ++ + .SH III. Reading + + We'll now walk you through the possible functions to call when reading +@@ -971,7 +857,7 @@ prediction. + + If you are intending to keep the file pointer open for use in libpng, + you must ensure you don't read more than 8 bytes from the beginning +-of the file, and you also have to make a call to png_set_sig_bytes_read() ++of the file, and you also have to make a call to png_set_sig_bytes() + with the number of bytes you read from the beginning. Libpng will + then only check the bytes (if any) that your program didn't read. + +@@ -979,20 +865,23 @@ then only check the bytes (if any) that your program didn't read. + to replace them with custom functions. See the discussion under + Customizing libpng. + +- + FILE *fp = fopen(file_name, "rb"); + if (!fp) + { +- return (ERROR); ++ return ERROR; + } +- fread(header, 1, number, fp); ++ ++ if (fread(header, 1, number, fp) != number) ++ { ++ return ERROR; ++ } ++ + is_png = !png_sig_cmp(header, 0, number); + if (!is_png) + { +- return (NOT_PNG); ++ return NOT_PNG; + } + +- + Next, png_struct and png_info need to be allocated and initialized. In + order to ensure that the size of these structures is correct even with a + dynamically linked libpng, there are functions to initialize and +@@ -1005,33 +894,27 @@ The structure allocation functions quietly return NULL if they fail to + create the structure, so your application should check for that. + + png_structp png_ptr = png_create_read_struct +- (PNG_LIBPNG_VER_STRING, (png_voidp)user_error_ptr, ++ (PNG_LIBPNG_VER_STRING, (png_voidp)user_error_ptr, + user_error_fn, user_warning_fn); ++ + if (!png_ptr) +- return (ERROR); ++ return ERROR; + + png_infop info_ptr = png_create_info_struct(png_ptr); ++ + if (!info_ptr) + { +- png_destroy_read_struct(&png_ptr, ++ png_destroy_read_struct(&png_ptr, + (png_infopp)NULL, (png_infopp)NULL); +- return (ERROR); +- } +- +- png_infop end_info = png_create_info_struct(png_ptr); +- if (!end_info) +- { +- png_destroy_read_struct(&png_ptr, &info_ptr, +- (png_infopp)NULL); +- return (ERROR); ++ return ERROR; + } + + If you want to use your own memory allocation routines, +-define PNG_USER_MEM_SUPPORTED and use ++use a libpng that was built with PNG_USER_MEM_SUPPORTED defined, and use + png_create_read_struct_2() instead of png_create_read_struct(): + + png_structp png_ptr = png_create_read_struct_2 +- (PNG_LIBPNG_VER_STRING, (png_voidp)user_error_ptr, ++ (PNG_LIBPNG_VER_STRING, (png_voidp)user_error_ptr, + user_error_fn, user_warning_fn, (png_voidp) + user_mem_ptr, user_malloc_fn, user_free_fn); + +@@ -1043,7 +926,7 @@ handling and memory alloc/free functions. + When libpng encounters an error, it expects to longjmp back + to your routine. Therefore, you will need to call setjmp and pass + your png_jmpbuf(png_ptr). If you read the file from different +-routines, you will need to update the jmpbuf field every time you enter ++routines, you will need to update the longjmp buffer every time you enter + a new routine that will call a png_*() function. + + See your documentation of setjmp/longjmp for your compiler for more +@@ -1055,16 +938,23 @@ free any memory. + + if (setjmp(png_jmpbuf(png_ptr))) + { +- png_destroy_read_struct(&png_ptr, &info_ptr, ++ png_destroy_read_struct(&png_ptr, &info_ptr, + &end_info); +- fclose(fp); +- return (ERROR); ++ fclose(fp); ++ return ERROR; + } + ++Pass (png_infopp)NULL instead of &end_info if you didn't create ++an end_info structure. ++ + If you would rather avoid the complexity of setjmp/longjmp issues, +-you can compile libpng with PNG_SETJMP_NOT_SUPPORTED, in which case ++you can compile libpng with PNG_NO_SETJMP, in which case + errors will result in a call to PNG_ABORT() which defaults to abort(). + ++You can #define PNG_ABORT() to a function that does something ++more useful than abort(), as long as your function does not ++return. ++ + Now you need to set up the input code. The default for libpng is to + use the C function fread(). If you use this, you will need to pass a + valid FILE * in the function png_init_io(). Be sure that the file is +@@ -1081,12 +971,50 @@ libpng know that there are some bytes missing from the start of the file. + + png_set_sig_bytes(png_ptr, number); + ++You can change the zlib compression buffer size to be used while ++reading compressed data with ++ ++ png_set_compression_buffer_size(png_ptr, buffer_size); ++ ++where the default size is 8192 bytes. Note that the buffer size ++is changed immediately and the buffer is reallocated immediately, ++instead of setting a flag to be acted upon later. ++ ++If you want CRC errors to be handled in a different manner than ++the default, use ++ ++ png_set_crc_action(png_ptr, crit_action, ancil_action); ++ ++The values for png_set_crc_action() say how libpng is to handle CRC errors in ++ancillary and critical chunks, and whether to use the data contained ++therein. Starting with libpng-1.6.26, this also governs how an ADLER32 error ++is handled while reading the IDAT chunk. Note that it is impossible to ++"discard" data in a critical chunk. ++ ++Choices for (int) crit_action are ++ PNG_CRC_DEFAULT 0 error/quit ++ PNG_CRC_ERROR_QUIT 1 error/quit ++ PNG_CRC_WARN_USE 3 warn/use data ++ PNG_CRC_QUIET_USE 4 quiet/use data ++ PNG_CRC_NO_CHANGE 5 use the current value ++ ++Choices for (int) ancil_action are ++ PNG_CRC_DEFAULT 0 error/quit ++ PNG_CRC_ERROR_QUIT 1 error/quit ++ PNG_CRC_WARN_DISCARD 2 warn/discard data ++ PNG_CRC_WARN_USE 3 warn/use data ++ PNG_CRC_QUIET_USE 4 quiet/use data ++ PNG_CRC_NO_CHANGE 5 use the current value ++ ++When the setting for crit_action is PNG_CRC_QUIET_USE, the CRC and ADLER32 ++checksums are not only ignored, but they are not evaluated. ++ + .SS Setting up callback code + + You can set up a callback function to handle any unknown chunks in the + input stream. You must supply the function + +- read_chunk_callback(png_ptr ptr, ++ read_chunk_callback(png_structp png_ptr, + png_unknown_chunkp chunk); + { + /* The unknown chunk structure contains your +@@ -1095,7 +1023,7 @@ input stream. You must supply the function + + png_byte name[5]; + png_byte *data; +- png_size_t size; ++ size_t size; + + /* Note that libpng has already taken care of + the CRC handling */ +@@ -1104,9 +1032,9 @@ input stream. You must supply the function + unknown chunk structure, process it, and return one + of the following: */ + +- return (-n); /* chunk had an error */ +- return (0); /* did not recognize */ +- return (n); /* success */ ++ return \-n; /* chunk had an error */ ++ return 0; /* did not recognize */ ++ return n; /* success */ + } + + (You can give your function another name that you like instead of +@@ -1123,17 +1051,22 @@ you can retrieve with + png_get_user_chunk_ptr(png_ptr); + + If you call the png_set_read_user_chunk_fn() function, then all unknown +-chunks will be saved when read, in case your callback function will need +-one or more of them. This behavior can be changed with the +-png_set_keep_unknown_chunks() function, described below. ++chunks which the callback does not handle will be saved when read. You can ++cause them to be discarded by returning '1' ("handled") instead of '0'. This ++behavior will change in libpng 1.7 and the default handling set by the ++png_set_keep_unknown_chunks() function, described below, will be used when the ++callback returns 0. If you want the existing behavior you should set the global ++default to PNG_HANDLE_CHUNK_IF_SAFE now; this is compatible with all current ++versions of libpng and with 1.7. Libpng 1.6 issues a warning if you keep the ++default, or PNG_HANDLE_CHUNK_NEVER, and the callback returns 0. + + At this point, you can set up a callback function that will be + called after each row has been read, which you can use to control + a progress meter or the like. It's demonstrated in pngtest.c. + You must supply a function + +- void read_row_callback(png_ptr ptr, png_uint_32 row, +- int pass); ++ void read_row_callback(png_structp png_ptr, ++ png_uint_32 row, int pass); + { + /* put your code here */ + } +@@ -1144,6 +1077,19 @@ To inform libpng about your function, use + + png_set_read_status_fn(png_ptr, read_row_callback); + ++When this function is called the row has already been completely processed and ++the 'row' and 'pass' refer to the next row to be handled. For the ++non-interlaced case the row that was just handled is simply one less than the ++passed in row number, and pass will always be 0. For the interlaced case the ++same applies unless the row value is 0, in which case the row just handled was ++the last one from one of the preceding passes. Because interlacing may skip a ++pass you cannot be sure that the preceding pass is just 'pass\-1'; if you really ++need to know what the last pass is record (row,pass) from the callback and use ++the last recorded value each time. ++ ++As with the user transform you can find the output row using the ++PNG_ROW_FROM_PASS_ROW macro. ++ + .SS Unknown-chunk handling + + Now you get to set the way the library processes unknown chunks in the +@@ -1155,21 +1101,30 @@ chunk types. To change this, you can call: + + png_set_keep_unknown_chunks(png_ptr, keep, + chunk_list, num_chunks); ++ + keep - 0: default unknown chunk handling + 1: ignore; do not keep + 2: keep only if safe-to-copy + 3: keep even if unsafe-to-copy ++ + You can use these definitions: + PNG_HANDLE_CHUNK_AS_DEFAULT 0 + PNG_HANDLE_CHUNK_NEVER 1 + PNG_HANDLE_CHUNK_IF_SAFE 2 + PNG_HANDLE_CHUNK_ALWAYS 3 ++ + chunk_list - list of chunks affected (a byte string, + five bytes per chunk, NULL or '\0' if +- num_chunks is 0) ++ num_chunks is positive; ignored if ++ numchunks <= 0). ++ + num_chunks - number of chunks affected; if 0, all +- unknown chunks are affected. If nonzero, +- only the chunks in the list are affected ++ unknown chunks are affected. If positive, ++ only the chunks in the list are affected, ++ and if negative all unknown chunks and ++ all known chunks except for the IHDR, ++ PLTE, tRNS, IDAT, and IEND chunks are ++ affected. + + Unknown chunks declared in this way will be saved as raw data onto a + list of png_unknown_chunk structures. If a chunk that is normally +@@ -1178,6 +1133,8 @@ according to the "keep" directive. If a chunk is named in successive + instances of png_set_keep_unknown_chunks(), the final instance will + take precedence. The IHDR and IEND chunks should not be named in + chunk_list; if they are, libpng will process them normally anyway. ++If you know that your application will never make use of some particular ++chunks, use PNG_HANDLE_CHUNK_NEVER (or 1) as demonstrated below. + + Here is an example of the usage of png_set_keep_unknown_chunks(), + where the private "vpAg" chunk will later be processed by a user chunk +@@ -1200,40 +1157,49 @@ callback function: + ... + + #if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED) +- /* ignore all unknown chunks: */ +- png_set_keep_unknown_chunks(read_ptr, 1, NULL, 0); ++ /* ignore all unknown chunks ++ * (use global setting "2" for libpng16 and earlier): ++ */ ++ png_set_keep_unknown_chunks(read_ptr, 2, NULL, 0); ++ + /* except for vpAg: */ + png_set_keep_unknown_chunks(read_ptr, 2, vpAg, 1); ++ + /* also ignore unused known chunks: */ + png_set_keep_unknown_chunks(read_ptr, 1, unused_chunks, +- (int)sizeof(unused_chunks)/5); ++ (int)(sizeof unused_chunks)/5); + #endif + + .SS User limits + + The PNG specification allows the width and height of an image to be as +-large as 2^31-1 (0x7fffffff), or about 2.147 billion rows and columns. +-Since very few applications really need to process such large images, +-we have imposed an arbitrary 1-million limit on rows and columns. ++large as 2^(31\-1 (0x7fffffff), or about 2.147 billion rows and columns. ++For safety, libpng imposes a default limit of 1 million rows and columns. + Larger images will be rejected immediately with a png_error() call. If +-you wish to override this limit, you can use ++you wish to change these limits, you can use + + png_set_user_limits(png_ptr, width_max, height_max); + +-to set your own limits, or use width_max = height_max = 0x7fffffffL +-to allow all valid dimensions (libpng may reject some very large images ++to set your own limits (libpng may reject some very wide images + anyway because of potential buffer overflow conditions). + + You should put this statement after you create the PNG structure and + before calling png_read_info(), png_read_png(), or png_process_data(). ++ ++When writing a PNG datastream, put this statement before calling ++png_write_info() or png_write_png(). ++ + If you need to retrieve the limits that are being applied, use + + width_max = png_get_user_width_max(png_ptr); + height_max = png_get_user_height_max(png_ptr); + + The PNG specification sets no limit on the number of ancillary chunks +-allowed in a PNG datastream. You can impose a limit on the total number +-of sPLT, tEXt, iTXt, zTXt, and unknown chunks that will be stored, with ++allowed in a PNG datastream. By default, libpng imposes a limit of ++a total of 1000 sPLT, tEXt, iTXt, zTXt, and unknown chunks to be stored. ++If you have set up both info_ptr and end_info_ptr, the limit applies ++separately to each. You can change the limit on the total number of such ++chunks that will be stored, with + + png_set_chunk_cache_max(png_ptr, user_chunk_cache_max); + +@@ -1241,8 +1207,436 @@ where 0x7fffffffL means unlimited. You can retrieve this limit with + + chunk_cache_max = png_get_chunk_cache_max(png_ptr); + +-This limit also applies to the number of buffers that can be allocated +-by png_decompress_chunk() while decompressing iTXt, zTXt, and iCCP chunks. ++Libpng imposes a limit of 8 Megabytes (8,000,000 bytes) on the amount of ++memory that any chunk other than IDAT can occupy, originally or when ++decompressed (prior to libpng-1.6.32 the limit was only applied to compressed ++chunks after decompression). You can change this limit with ++ ++ png_set_chunk_malloc_max(png_ptr, user_chunk_malloc_max); ++ ++and you can retrieve the limit with ++ ++ chunk_malloc_max = png_get_chunk_malloc_max(png_ptr); ++ ++Any chunks that would cause either of these limits to be exceeded will ++be ignored. ++ ++.SS Information about your system ++ ++If you intend to display the PNG or to incorporate it in other image data you ++need to tell libpng information about your display or drawing surface so that ++libpng can convert the values in the image to match the display. ++ ++From libpng-1.5.4 this information can be set before reading the PNG file ++header. In earlier versions png_set_gamma() existed but behaved incorrectly if ++called before the PNG file header had been read and png_set_alpha_mode() did not ++exist. ++ ++If you need to support versions prior to libpng-1.5.4 test the version number ++as illustrated below using "PNG_LIBPNG_VER >= 10504" and follow the procedures ++described in the appropriate manual page. ++ ++You give libpng the encoding expected by your system expressed as a 'gamma' ++value. You can also specify a default encoding for the PNG file in ++case the required information is missing from the file. By default libpng ++assumes that the PNG data matches your system, to keep this default call: ++ ++ png_set_gamma(png_ptr, screen_gamma, output_gamma); ++ ++or you can use the fixed point equivalent: ++ ++ png_set_gamma_fixed(png_ptr, PNG_FP_1*screen_gamma, ++ PNG_FP_1*output_gamma); ++ ++If you don't know the gamma for your system it is probably 2.2 - a good ++approximation to the IEC standard for display systems (sRGB). If images are ++too contrasty or washed out you got the value wrong - check your system ++documentation! ++ ++Many systems permit the system gamma to be changed via a lookup table in the ++display driver, a few systems, including older Macs, change the response by ++default. As of 1.5.4 three special values are available to handle common ++situations: ++ ++ PNG_DEFAULT_sRGB: Indicates that the system conforms to the ++ IEC 61966-2-1 standard. This matches almost ++ all systems. ++ PNG_GAMMA_MAC_18: Indicates that the system is an older ++ (pre Mac OS 10.6) Apple Macintosh system with ++ the default settings. ++ PNG_GAMMA_LINEAR: Just the fixed point value for 1.0 - indicates ++ that the system expects data with no gamma ++ encoding. ++ ++You would use the linear (unencoded) value if you need to process the pixel ++values further because this avoids the need to decode and re-encode each ++component value whenever arithmetic is performed. A lot of graphics software ++uses linear values for this reason, often with higher precision component values ++to preserve overall accuracy. ++ ++ ++The output_gamma value 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 values can be passed to either the fixed or floating ++point APIs, but the floating point API will also accept floating point ++values. ++ ++The second thing you may need to tell libpng about is how your system handles ++alpha channel information. Some, but not all, PNG files contain an alpha ++channel. To display these files correctly you need to compose the data onto a ++suitable background, as described in the PNG specification. ++ ++Libpng only supports composing onto a single color (using png_set_background; ++see below). Otherwise you must do the composition yourself and, in this case, ++you may need to call png_set_alpha_mode: ++ ++ #if PNG_LIBPNG_VER >= 10504 ++ png_set_alpha_mode(png_ptr, mode, screen_gamma); ++ #else ++ png_set_gamma(png_ptr, screen_gamma, 1.0/screen_gamma); ++ #endif ++ ++The screen_gamma value is the same as the argument to png_set_gamma; however, ++how it affects the output depends on the mode. png_set_alpha_mode() sets the ++file gamma default to 1/screen_gamma, so normally you don't need to call ++png_set_gamma. If you need different defaults call png_set_gamma() before ++png_set_alpha_mode() - if you call it after it will override the settings made ++by png_set_alpha_mode(). ++ ++The mode is as follows: ++ ++ PNG_ALPHA_PNG: The data is encoded according to the PNG ++specification. Red, green and blue, or gray, components are ++gamma encoded color values and are not premultiplied by the ++alpha value. The alpha value is a linear measure of the ++contribution of the pixel to the corresponding final output pixel. ++ ++You should normally use this format if you intend to perform ++color correction on the color values; most, maybe all, color ++correction software has no handling for the alpha channel and, ++anyway, the math to handle pre-multiplied component values is ++unnecessarily complex. ++ ++Before you do any arithmetic on the component values you need ++to remove the gamma encoding and multiply out the alpha ++channel. See the PNG specification for more detail. It is ++important to note that when an image with an alpha channel is ++scaled, linear encoded, pre-multiplied component values must ++be used! ++ ++The remaining modes assume you don't need to do any further color correction or ++that if you do, your color correction software knows all about alpha (it ++probably doesn't!). They '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. These are the 'STANDARD', 'ASSOCIATED' or 'PREMULTIPLIED' modes ++described below (the latter being the two common names for associated alpha ++color channels). Note that PNG files always contain non-associated color ++channels; png_set_alpha_mode() with one of the modes causes the decoder to ++convert the pixels to an associated form before returning them to your ++application. ++ ++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. ++ ++ PNG_ALPHA_STANDARD: The data libpng produces is encoded in the ++standard way assumed by most correctly written graphics software. ++The gamma encoding will be removed by libpng and the ++linear component values will be pre-multiplied by the ++alpha channel. ++ ++With this format the final image must be re-encoded to ++match the display gamma before the image is displayed. ++If your system doesn't do that, yet still seems to ++perform arithmetic on the pixels without decoding them, ++it is broken - check out the modes below. ++ ++With PNG_ALPHA_STANDARD libpng always produces linear ++component values, whatever screen_gamma you supply. The ++screen_gamma value is, however, used as a default for ++the file gamma if the PNG file has no gamma information. ++ ++If you call png_set_gamma() after png_set_alpha_mode() you ++will override the linear encoding. Instead the ++pre-multiplied pixel values will be gamma encoded but ++the alpha channel will still be linear. This may ++actually match the requirements of some broken software, ++but it is unlikely. ++ ++While linear 8-bit data is often used it has ++insufficient precision for any image with a reasonable ++dynamic range. To avoid problems, and if your software ++supports it, use png_set_expand_16() to force all ++components to 16 bits. ++ ++ PNG_ALPHA_OPTIMIZED: This mode is the same as PNG_ALPHA_STANDARD ++except that completely opaque pixels are gamma encoded according to ++the screen_gamma value. Pixels with alpha less than 1.0 ++will still have linear components. ++ ++Use this format if you have control over your ++compositing software and so don't do other arithmetic ++(such as scaling) on the data you get from libpng. Your ++compositing software can simply copy opaque pixels to ++the output but still has linear values for the ++non-opaque pixels. ++ ++In normal compositing, where the alpha channel encodes ++partial pixel coverage (as opposed to broad area ++translucency), the inaccuracies of the 8-bit ++representation of non-opaque pixels are irrelevant. ++ ++You can also try this format if your software is broken; ++it might look better. ++ ++ PNG_ALPHA_BROKEN: This is PNG_ALPHA_STANDARD; however, all component ++values, including the alpha channel are gamma encoded. This is ++broken because, in practice, no implementation that uses this choice ++correctly undoes the encoding before handling alpha composition. Use this ++choice only if other serious errors in the software or hardware you use ++mandate it. In most cases of broken software or hardware the bug in the ++final display manifests as a subtle halo around composited parts of the ++image. You may not even perceive this as a halo; the composited part of ++the image may simply appear separate from the background, as though it had ++been cut out of paper and pasted on afterward. ++ ++If you don't have to deal with bugs in software or hardware, or if you can fix ++them, there are three recommended ways of using png_set_alpha_mode(): ++ ++ png_set_alpha_mode(png_ptr, PNG_ALPHA_PNG, ++ screen_gamma); ++ ++You can do color correction on the result (libpng does not currently ++support color correction internally). When you handle the alpha channel ++you need to undo the gamma encoding and multiply out the alpha. ++ ++ png_set_alpha_mode(png_ptr, PNG_ALPHA_STANDARD, ++ screen_gamma); ++ png_set_expand_16(png_ptr); ++ ++If you are using the high level interface, don't call png_set_expand_16(); ++instead pass PNG_TRANSFORM_EXPAND_16 to the interface. ++ ++With this mode you can't do color correction, but you can do arithmetic, ++including composition and scaling, on the data without further processing. ++ ++ png_set_alpha_mode(png_ptr, PNG_ALPHA_OPTIMIZED, ++ screen_gamma); ++ ++You can avoid the expansion to 16-bit components with this mode, but you ++lose the ability to scale the image or perform other linear arithmetic. ++All you can do is compose the result onto a matching output. Since this ++mode is libpng-specific you also need to write your own composition ++software. ++ ++The following are examples of calls to png_set_alpha_mode to achieve the ++required overall gamma correction and, where necessary, alpha ++premultiplication. ++ ++ png_set_alpha_mode(pp, PNG_ALPHA_PNG, PNG_DEFAULT_sRGB); ++ ++Choices for the alpha_mode are ++ ++ PNG_ALPHA_PNG 0 /* according to the PNG standard */ ++ PNG_ALPHA_STANDARD 1 /* according to Porter/Duff */ ++ PNG_ALPHA_ASSOCIATED 1 /* as above; this is the normal practice */ ++ PNG_ALPHA_PREMULTIPLIED 1 /* as above */ ++ PNG_ALPHA_OPTIMIZED 2 /* 'PNG' for opaque pixels, else 'STANDARD' */ ++ PNG_ALPHA_BROKEN 3 /* the alpha channel is gamma encoded */ ++ ++PNG_ALPHA_PNG is the default libpng handling of the alpha channel. It is not ++pre-multiplied into the color components. In addition the call states ++that the output is for a sRGB system and causes all PNG files without gAMA ++chunks to be assumed to be encoded using sRGB. ++ ++ png_set_alpha_mode(pp, PNG_ALPHA_PNG, PNG_GAMMA_MAC); ++ ++In this case the output is assumed to be something like an sRGB conformant ++display preceded by a power-law lookup table of power 1.45. This is how ++early Mac systems behaved. ++ ++ png_set_alpha_mode(pp, PNG_ALPHA_STANDARD, PNG_GAMMA_LINEAR); ++ ++This is the classic Jim Blinn approach and will work in academic ++environments where everything is done by the book. It has the shortcoming ++of assuming that input PNG data with no gamma information is linear - this ++is unlikely to be correct unless the PNG files were generated locally. ++Most of the time the output precision will be so low as to show ++significant banding in dark areas of the image. ++ ++ png_set_expand_16(pp); ++ png_set_alpha_mode(pp, PNG_ALPHA_STANDARD, PNG_DEFAULT_sRGB); ++ ++This is a somewhat more realistic Jim Blinn inspired approach. PNG files ++are assumed to have the sRGB encoding if not marked with a gamma value and ++the output is always 16 bits per component. This permits accurate scaling ++and processing of the data. If you know that your input PNG files were ++generated locally you might need to replace PNG_DEFAULT_sRGB with the ++correct value for your system. ++ ++ png_set_alpha_mode(pp, PNG_ALPHA_OPTIMIZED, PNG_DEFAULT_sRGB); ++ ++If you just need to composite the PNG image onto an existing background ++and if you control the code that does this you can use the optimization ++setting. In this case you just copy completely opaque pixels to the ++output. For pixels that are not completely transparent (you just skip ++those) you do the composition math using png_composite or png_composite_16 ++below then encode the resultant 8-bit or 16-bit values to match the output ++encoding. ++ ++ Other cases ++ ++If neither the PNG nor the standard linear encoding work for you because ++of the software or hardware you use then you have a big problem. The PNG ++case will probably result in halos around the image. The linear encoding ++will probably result in a washed out, too bright, image (it's actually too ++contrasty.) Try the ALPHA_OPTIMIZED mode above - this will probably ++substantially reduce the halos. Alternatively try: ++ ++ png_set_alpha_mode(pp, PNG_ALPHA_BROKEN, PNG_DEFAULT_sRGB); ++ ++This option will also reduce the halos, but there will be slight dark ++halos round the opaque parts of the image where the background is light. ++In the OPTIMIZED mode the halos will be light halos where the background ++is dark. Take your pick - the halos are unavoidable unless you can get ++your hardware/software fixed! (The OPTIMIZED approach is slightly ++faster.) ++ ++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 ++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 ++default if it is not already set: ++ ++ png_set_alpha_mode(pp, PNG_ALPHA_PNG, PNG_DEFAULT_sRGB); ++ png_set_alpha_mode(pp, PNG_ALPHA_PNG, PNG_GAMMA_MAC); ++ ++The first call sets both the default and the output gamma values, the ++second call overrides the output gamma without changing the default. This ++is easier than achieving the same effect with png_set_gamma. You must use ++PNG_ALPHA_PNG for the first call - internal checking in png_set_alpha will ++fire if more than one call to png_set_alpha_mode and png_set_background is ++made in the same read operation, however multiple calls with PNG_ALPHA_PNG ++are ignored. ++ ++If you don't need, or can't handle, the alpha channel you can call ++png_set_background() to remove it by compositing against a fixed color. Don't ++call png_set_strip_alpha() to do this - it will leave spurious pixel values in ++transparent parts of this image. ++ ++ png_set_background(png_ptr, &background_color, ++ PNG_BACKGROUND_GAMMA_SCREEN, 0, 1); ++ ++The background_color is an RGB or grayscale value according to the data format ++libpng will produce for you. Because you don't yet know the format of the PNG ++file, if you call png_set_background at this point you must arrange for the ++format produced by libpng to always have 8-bit or 16-bit components and then ++store the color as an 8-bit or 16-bit color as appropriate. The color contains ++separate gray and RGB component values, so you can let libpng produce gray or ++RGB output according to the input format, but low bit depth grayscale images ++must always be converted to at least 8-bit format. (Even though low bit depth ++grayscale images can't have an alpha channel they can have a transparent ++color!) ++ ++You set the transforms you need later, either as flags to the high level ++interface or libpng API calls for the low level interface. For reference the ++settings and API calls required are: ++ ++8-bit values: ++ PNG_TRANSFORM_SCALE_16 | PNG_EXPAND ++ png_set_expand(png_ptr); png_set_scale_16(png_ptr); ++ ++ If you must get exactly the same inaccurate results ++ produced by default in versions prior to libpng-1.5.4, ++ use PNG_TRANSFORM_STRIP_16 and png_set_strip_16(png_ptr) ++ instead. ++ ++16-bit values: ++ PNG_TRANSFORM_EXPAND_16 ++ png_set_expand_16(png_ptr); ++ ++In either case palette image data will be expanded to RGB. If you just want ++color data you can add PNG_TRANSFORM_GRAY_TO_RGB or png_set_gray_to_rgb(png_ptr) ++to the list. ++ ++Calling png_set_background before the PNG file header is read will not work ++prior to libpng-1.5.4. Because the failure may result in unexpected warnings or ++errors it is therefore much safer to call png_set_background after the head has ++been read. Unfortunately this means that prior to libpng-1.5.4 it cannot be ++used with the high level interface. + + .SS The high-level read interface + +@@ -1253,8 +1647,10 @@ the entire image into memory, and (b) the input transformations + you want to do are limited to the following set: + + PNG_TRANSFORM_IDENTITY No transformation +- PNG_TRANSFORM_STRIP_16 Strip 16-bit samples to +- 8 bits ++ PNG_TRANSFORM_SCALE_16 Strip 16-bit samples to ++ 8-bit accurately ++ PNG_TRANSFORM_STRIP_16 Chop 16-bit samples to ++ 8-bit less accurately + PNG_TRANSFORM_STRIP_ALPHA Discard the alpha channel + PNG_TRANSFORM_PACKING Expand 1, 2 and 4-bit + samples to bytes +@@ -1273,9 +1669,10 @@ you want to do are limited to the following set: + PNG_TRANSFORM_SWAP_ENDIAN Byte-swap 16-bit samples + PNG_TRANSFORM_GRAY_TO_RGB Expand grayscale samples + to RGB (or GA to RGBA) ++ PNG_TRANSFORM_EXPAND_16 Expand samples to 16 bits + + (This excludes setting a background color, doing gamma transformation, +-dithering, and setting filler.) If this is the case, simply do this: ++quantizing, and setting filler.) If this is the case, simply do this: + + png_read_png(png_ptr, info_ptr, png_transforms, NULL) + +@@ -1302,29 +1699,47 @@ where row_pointers is an array of pointers to the pixel data for each row: + If you know your image size and pixel size ahead of time, you can allocate + row_pointers prior to calling png_read_png() with + +- if (height > PNG_UINT_32_MAX/png_sizeof(png_byte)) ++ if (height > PNG_UINT_32_MAX/(sizeof (png_byte))) + png_error (png_ptr, +- "Image is too tall to process in memory"); ++ "Image is too tall to process in memory"); ++ + if (width > PNG_UINT_32_MAX/pixel_size) + png_error (png_ptr, +- "Image is too wide to process in memory"); ++ "Image is too wide to process in memory"); ++ + row_pointers = png_malloc(png_ptr, +- height*png_sizeof(png_bytep)); ++ height*(sizeof (png_bytep))); ++ + for (int i=0; i PNG_SIZE_MAX/(width*pixel_size)) { ++ png_error(png_ptr,"image_data buffer would be too large"); ++ } ++ ++ png_bytep buffer=png_malloc(png_ptr,height*width*pixel_size); ++ ++ for (int i=0; i are set directly if they are simple data types, or a + pointer into the info_ptr is returned for any complex types. + ++The colorspace data from gAMA, cHRM, sRGB, iCCP, and sBIT chunks ++is simply returned to give the application information about how the ++image was encoded. Libpng itself only does transformations using the file ++gamma when combining semitransparent pixels with the background color, and, ++since libpng-1.6.0, when converting between 8-bit sRGB and 16-bit linear pixels ++within the simplified API. Libpng also uses the file gamma when converting ++RGB to gray, beginning with libpng-1.0.5, if the application calls ++png_set_rgb_to_gray()). ++ + png_get_PLTE(png_ptr, info_ptr, &palette, + &num_palette); ++ + palette - the palette for the file + (array of png_color) ++ + num_palette - number of entries in the palette + +- png_get_gAMA(png_ptr, info_ptr, &gamma); +- gamma - the gamma the file is written +- at (PNG_INFO_gAMA) ++ png_get_gAMA(png_ptr, info_ptr, &file_gamma); ++ png_get_gAMA_fixed(png_ptr, info_ptr, &int_file_gamma); ++ ++ file_gamma - the gamma at which the file is ++ written (PNG_INFO_gAMA) ++ ++ int_file_gamma - 100,000 times the gamma at which the ++ file is written ++ ++ png_get_cHRM(png_ptr, info_ptr, &white_x, &white_y, &red_x, ++ &red_y, &green_x, &green_y, &blue_x, &blue_y) ++ png_get_cHRM_XYZ(png_ptr, info_ptr, &red_X, &red_Y, &red_Z, ++ &green_X, &green_Y, &green_Z, &blue_X, &blue_Y, ++ &blue_Z) ++ png_get_cHRM_fixed(png_ptr, info_ptr, &int_white_x, ++ &int_white_y, &int_red_x, &int_red_y, ++ &int_green_x, &int_green_y, &int_blue_x, ++ &int_blue_y) ++ png_get_cHRM_XYZ_fixed(png_ptr, info_ptr, &int_red_X, &int_red_Y, ++ &int_red_Z, &int_green_X, &int_green_Y, ++ &int_green_Z, &int_blue_X, &int_blue_Y, ++ &int_blue_Z) ++ ++ {white,red,green,blue}_{x,y} ++ A color space encoding specified using the ++ chromaticities of the end points and the ++ white point. (PNG_INFO_cHRM) ++ ++ {red,green,blue}_{X,Y,Z} ++ A color space encoding specified using the ++ encoding end points - the CIE tristimulus ++ specification of the intended color of the red, ++ green and blue channels in the PNG RGB data. ++ The white point is simply the sum of the three ++ end points. (PNG_INFO_cHRM) + + png_get_sRGB(png_ptr, info_ptr, &srgb_intent); +- srgb_intent - the rendering intent (PNG_INFO_sRGB) ++ ++ srgb_intent - the rendering intent (PNG_INFO_sRGB) + The presence of the sRGB chunk + means that the pixel data is in the + sRGB color space. This chunk also +@@ -1454,75 +1949,108 @@ pointer into the info_ptr is returned for any complex types. + + png_get_iCCP(png_ptr, info_ptr, &name, + &compression_type, &profile, &proflen); +- name - The profile name. +- compression - The compression type; always +- PNG_COMPRESSION_TYPE_BASE for PNG 1.0. +- You may give NULL to this argument to +- ignore it. +- profile - International Color Consortium color +- profile data. May contain NULs. +- proflen - length of profile data in bytes. ++ ++ name - The profile name. ++ ++ compression_type - The compression type; always ++ PNG_COMPRESSION_TYPE_BASE for PNG 1.0. ++ You may give NULL to this argument to ++ ignore it. ++ ++ profile - International Color Consortium color ++ profile data. May contain NULs. ++ ++ proflen - length of profile data in bytes. + + png_get_sBIT(png_ptr, info_ptr, &sig_bit); ++ + sig_bit - the number of significant bits for + (PNG_INFO_sBIT) each of the gray, + red, green, and blue channels, + whichever are appropriate for the + given color type (png_color_16) + +- png_get_tRNS(png_ptr, info_ptr, &trans, &num_trans, +- &trans_values); +- trans - array of transparent ++ png_get_tRNS(png_ptr, info_ptr, &trans_alpha, ++ &num_trans, &trans_color); ++ ++ trans_alpha - array of alpha (transparency) + entries for palette (PNG_INFO_tRNS) +- trans_values - graylevel or color sample values of +- the single transparent color for +- non-paletted images (PNG_INFO_tRNS) ++ + num_trans - number of transparent entries + (PNG_INFO_tRNS) + ++ trans_color - graylevel or color sample values of ++ the single transparent color for ++ non-paletted images (PNG_INFO_tRNS) ++ ++ png_get_eXIf_1(png_ptr, info_ptr, &num_exif, &exif); ++ (PNG_INFO_eXIf) ++ ++ exif - Exif profile (array of png_byte) ++ + png_get_hIST(png_ptr, info_ptr, &hist); + (PNG_INFO_hIST) ++ + hist - histogram of palette (array of + png_uint_16) + + png_get_tIME(png_ptr, info_ptr, &mod_time); ++ + mod_time - time image was last modified + (PNG_VALID_tIME) + + png_get_bKGD(png_ptr, info_ptr, &background); +- background - background color (PNG_VALID_bKGD) ++ ++ background - background color (of type ++ png_color_16p) (PNG_VALID_bKGD) + valid 16-bit red, green and blue + values, regardless of color_type + + num_comments = png_get_text(png_ptr, info_ptr, + &text_ptr, &num_text); ++ + num_comments - number of comments ++ + text_ptr - array of png_text holding image + comments ++ + text_ptr[i].compression - type of compression used + on "text" PNG_TEXT_COMPRESSION_NONE + PNG_TEXT_COMPRESSION_zTXt + PNG_ITXT_COMPRESSION_NONE + PNG_ITXT_COMPRESSION_zTXt ++ + text_ptr[i].key - keyword for comment. Must contain + 1-79 characters. ++ + text_ptr[i].text - text comments for current + keyword. Can be empty. ++ + text_ptr[i].text_length - length of text string, + after decompression, 0 for iTXt ++ + text_ptr[i].itxt_length - length of itxt string, + after decompression, 0 for tEXt/zTXt ++ + text_ptr[i].lang - language of comment (empty + string for unknown). ++ + text_ptr[i].lang_key - keyword in UTF-8 + (empty string for unknown). ++ + Note that the itxt_length, lang, and lang_key +- members of the text_ptr structure only exist +- when the library is built with iTXt chunk support. ++ members of the text_ptr 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, ++ they contain NULL pointers when the "compression" ++ field contains PNG_TEXT_COMPRESSION_NONE or ++ PNG_TEXT_COMPRESSION_zTXt. + + num_text - number of comments (same as + num_comments; you can put NULL here + to avoid the duplication) ++ + Note while png_set_text() will accept text, language, + and translated keywords that can be NULL pointers, the + structure returned by png_get_text will always contain +@@ -1531,90 +2059,137 @@ pointer into the info_ptr is returned for any complex types. + + num_spalettes = png_get_sPLT(png_ptr, info_ptr, + &palette_ptr); ++ ++ num_spalettes - number of sPLT chunks read. ++ + palette_ptr - array of palette structures holding + contents of one or more sPLT chunks + read. +- num_spalettes - number of sPLT chunks read. + + png_get_oFFs(png_ptr, info_ptr, &offset_x, &offset_y, + &unit_type); ++ + offset_x - positive offset from the left edge +- of the screen ++ of the screen (can be negative) ++ + offset_y - positive offset from the top edge +- of the screen ++ of the screen (can be negative) ++ + unit_type - PNG_OFFSET_PIXEL, PNG_OFFSET_MICROMETER + + png_get_pHYs(png_ptr, info_ptr, &res_x, &res_y, + &unit_type); ++ + res_x - pixels/unit physical resolution in + x direction ++ + res_y - pixels/unit physical resolution in + x direction ++ + unit_type - PNG_RESOLUTION_UNKNOWN, + PNG_RESOLUTION_METER + + png_get_sCAL(png_ptr, info_ptr, &unit, &width, + &height) ++ + unit - physical scale units (an integer) ++ + width - width of a pixel in physical scale units ++ + height - height of a pixel in physical scale units + (width and height are doubles) + + png_get_sCAL_s(png_ptr, info_ptr, &unit, &width, + &height) ++ + unit - physical scale units (an integer) ++ + width - width of a pixel in physical scale units ++ (expressed as a string) ++ + height - height of a pixel in physical scale units + (width and height are strings like "2.54") + + num_unknown_chunks = png_get_unknown_chunks(png_ptr, + info_ptr, &unknowns) ++ + unknowns - array of png_unknown_chunk + structures holding unknown chunks ++ + unknowns[i].name - name of unknown chunk ++ + unknowns[i].data - data of unknown chunk ++ + unknowns[i].size - size of unknown chunk's data ++ + unknowns[i].location - position of chunk in file + + The value of "i" corresponds to the order in which the + chunks were read from the PNG file or inserted with the + png_set_unknown_chunks() function. + ++ The value of "location" is a bitwise "or" of ++ ++ PNG_HAVE_IHDR (0x01) ++ PNG_HAVE_PLTE (0x02) ++ PNG_AFTER_IDAT (0x08) ++ + The data from the pHYs chunk can be retrieved in several convenient + forms: + + res_x = png_get_x_pixels_per_meter(png_ptr, + info_ptr) ++ + res_y = png_get_y_pixels_per_meter(png_ptr, + info_ptr) ++ + res_x_and_y = png_get_pixels_per_meter(png_ptr, + info_ptr) ++ + res_x = png_get_x_pixels_per_inch(png_ptr, + info_ptr) ++ + res_y = png_get_y_pixels_per_inch(png_ptr, + info_ptr) ++ + res_x_and_y = png_get_pixels_per_inch(png_ptr, + info_ptr) ++ + aspect_ratio = png_get_pixel_aspect_ratio(png_ptr, + info_ptr) + +- (Each of these returns 0 [signifying "unknown"] if ++ Each of these returns 0 [signifying "unknown"] if + the data is not present or if res_x is 0; +- res_x_and_y is 0 if res_x != res_y) ++ res_x_and_y is 0 if res_x != res_y ++ ++ Note that because of the way the resolutions are ++ stored internally, the inch conversions won't ++ come out to exactly even number. For example, ++ 72 dpi is stored as 0.28346 pixels/meter, and ++ when this is retrieved it is 71.9988 dpi, so ++ be sure to round the returned value appropriately ++ if you want to display a reasonable-looking result. + + The data from the oFFs chunk can be retrieved in several convenient + forms: + + x_offset = png_get_x_offset_microns(png_ptr, info_ptr); ++ + y_offset = png_get_y_offset_microns(png_ptr, info_ptr); ++ + x_offset = png_get_x_offset_inches(png_ptr, info_ptr); ++ + y_offset = png_get_y_offset_inches(png_ptr, info_ptr); + +- (Each of these returns 0 [signifying "unknown" if both ++ Each of these returns 0 [signifying "unknown" if both + x and y are 0] if the data is not present or if the +- chunk is present but the unit is the pixel) ++ chunk is present but the unit is the pixel. The ++ remark about inexact inch conversions applies here ++ as well, because a value in inches can't always be ++ converted to microns and back without some loss ++ of precision. + +-For more information, see the png_info definition in png.h and the ++For more information, see the + PNG specification for chunk contents. Be careful with trusting + rowbytes, as some of the transformations could increase the space + needed to hold a row (expand, filler, gray_to_rgb, etc.). +@@ -1649,32 +2224,36 @@ to handle any special transformations of the image data. The various + ways to transform the data will be described in the order that they + should occur. This is important, as some of these change the color + type and/or bit depth of the data, and some others only work on +-certain color types and bit depths. Even though each transformation +-checks to see if it has data that it can do something with, you should +-make sure to only enable a transformation if it will be valid for the +-data. For example, don't swap red and blue on grayscale data. ++certain color types and bit depths. ++ ++Transformations you request are ignored if they don't have any meaning for a ++particular input data format. However some transformations can have an effect ++as a result of a previous transformation. If you specify a contradictory set of ++transformations, for example both adding and removing the alpha channel, you ++cannot predict the final result. + +-The colors used for the background and transparency values should be +-supplied in the same format/depth as the current image data. They +-are stored in the same format/depth as the image data in a bKGD or tRNS +-chunk, so this is what libpng expects for this data. The colors are +-transformed to keep in sync with the image data when an application +-calls the png_read_update_info() routine (see below). ++The color used for the transparency values should be supplied in the same ++format/depth as the current image data. It is stored in the same format/depth ++as the image data in a tRNS chunk, so this is what libpng expects for this data. ++ ++The color used for the background value depends on the need_expand argument as ++described below. + + Data will be decoded into the supplied row buffers packed into bytes + unless the library has been told to transform it into another format. + For example, 4 bit/pixel paletted or grayscale data will be returned +-2 pixels/byte with the leftmost pixel in the high-order bits of the +-byte, unless png_set_packing() is called. 8-bit RGB data will be stored ++2 pixels/byte with the leftmost pixel in the high-order bits of the byte, ++unless png_set_packing() is called. 8-bit RGB data will be stored + in RGB RGB RGB format unless png_set_filler() or png_set_add_alpha() + is called to insert filler bytes, either before or after each RGB triplet. ++ + 16-bit RGB data will be returned RRGGBB RRGGBB, with the most significant +-byte of the color value first, unless png_set_strip_16() is called to ++byte of the color value first, unless png_set_scale_16() is called to + transform it to regular RGB RGB triplets, or png_set_filler() or +-png_set_add alpha() is called to insert filler bytes, either before or +-after each RRGGBB triplet. Similarly, 8-bit or 16-bit grayscale data can +-be modified with +-png_set_filler(), png_set_add_alpha(), or png_set_strip_16(). ++png_set_add alpha() is called to insert two filler bytes, either before ++or after each RRGGBB triplet. Similarly, 8-bit or 16-bit grayscale data can ++be modified with png_set_filler(), png_set_add_alpha(), png_set_strip_16(), ++or png_set_scale_16(). + + The following code transforms grayscale images of less than 8 to 8 bits, + changes paletted images to RGB, and adds a full alpha channel if there is +@@ -1685,13 +2264,13 @@ viewing application that wishes to treat all images in the same way. + if (color_type == PNG_COLOR_TYPE_PALETTE) + png_set_palette_to_rgb(png_ptr); + +- if (color_type == PNG_COLOR_TYPE_GRAY && +- bit_depth < 8) png_set_expand_gray_1_2_4_to_8(png_ptr); +- + if (png_get_valid(png_ptr, info_ptr, + PNG_INFO_tRNS)) png_set_tRNS_to_alpha(png_ptr); + +-These three functions are actually aliases for png_set_expand(), added ++ if (color_type == PNG_COLOR_TYPE_GRAY && ++ bit_depth < 8) png_set_expand_gray_1_2_4_to_8(png_ptr); ++ ++The first two functions are actually aliases for png_set_expand(), added + in libpng version 1.0.4, with the function names expanded to improve code + readability. In some future version they may actually do different + things. +@@ -1699,56 +2278,93 @@ things. + As of libpng version 1.2.9, png_set_expand_gray_1_2_4_to_8() was + added. It expands the sample depth without changing tRNS to alpha. + +-As of libpng version 1.2.44, not all possible expansions are supported. ++As of libpng version 1.5.2, png_set_expand_16() was added. It behaves as ++png_set_expand(); however, the resultant channels have 16 bits rather than 8. ++Use this when the output color or gray channels are made linear to avoid fairly ++severe accuracy loss. ++ ++ if (bit_depth < 16) ++ png_set_expand_16(png_ptr); ++ ++PNG can have files with 16 bits per channel. If you only can handle ++8 bits per channel, this will strip the pixels down to 8-bit. ++ ++ if (bit_depth == 16) ++#if PNG_LIBPNG_VER >= 10504 ++ png_set_scale_16(png_ptr); ++#else ++ png_set_strip_16(png_ptr); ++#endif ++ ++(The more accurate "png_set_scale_16()" API became available in libpng version ++1.5.4). ++ ++If you need to process the alpha channel on the image separately from the image ++data (for example if you convert it to a bitmap mask) it is possible to have ++libpng strip the channel leaving just RGB or gray data: ++ ++ if (color_type & PNG_COLOR_MASK_ALPHA) ++ png_set_strip_alpha(png_ptr); ++ ++If you strip the alpha channel you need to find some other way of dealing with ++the information. If, instead, you want to convert the image to an opaque ++version with no alpha channel use png_set_background; see below. ++ ++As of libpng version 1.5.2, almost all useful expansions are supported, the ++major ommissions are conversion of grayscale to indexed images (which can be ++done trivially in the application) and conversion of indexed to grayscale (which ++can be done by a trivial manipulation of the palette.) + + In the following table, the 01 means grayscale with depth<8, 31 means + indexed with depth<8, other numerals represent the color type, "T" means + the tRNS chunk is present, A means an alpha channel is present, and O + means tRNS or alpha is present but all pixels in the image are opaque. + +- FROM 01 31 0 0T 0O 2 2T 2O 3 3T 3O 4A 4O 6A 6O ++ FROM 01 31 0 0T 0O 2 2T 2O 3 3T 3O 4A 4O 6A 6O + TO +- 01 - +- 31 - +- 0 1 - +- 0T - +- 0O - +- 2 GX - +- 2T - +- 2O - +- 3 1 - +- 3T - +- 3O - +- 4A T - +- 4O - +- 6A GX TX TX - +- 6O GX TX - ++ 01 - [G] - - - - - - - - - - - - - ++ 31 [Q] Q [Q] [Q] [Q] Q Q Q Q Q Q [Q] [Q] Q Q ++ 0 1 G + . . G G G G G G B B GB GB ++ 0T lt Gt t + . Gt G G Gt G G Bt Bt GBt GBt ++ 0O lt Gt t . + Gt Gt G Gt Gt G Bt Bt GBt GBt ++ 2 C P C C C + . . C - - CB CB B B ++ 2T Ct - Ct C C t + t - - - CBt CBt Bt Bt ++ 2O Ct - Ct C C t t + - - - CBt CBt Bt Bt ++ 3 [Q] p [Q] [Q] [Q] Q Q Q + . . [Q] [Q] Q Q ++ 3T [Qt] p [Qt][Q] [Q] Qt Qt Qt t + t [Qt][Qt] Qt Qt ++ 3O [Qt] p [Qt][Q] [Q] Qt Qt Qt t t + [Qt][Qt] Qt Qt ++ 4A lA G A T T GA GT GT GA GT GT + BA G GBA ++ 4O lA GBA A T T GA GT GT GA GT GT BA + GBA G ++ 6A CA PA CA C C A T tT PA P P C CBA + BA ++ 6O CA PBA CA C C A tT T PA P P CBA C BA + + + Within the matrix, ++ "+" identifies entries where 'from' and 'to' are the same. + "-" means the transformation is not supported. ++ "." means nothing is necessary (a tRNS chunk can just be ignored). ++ "t" means the transformation is obtained by png_set_tRNS. ++ "A" means the transformation is obtained by png_set_add_alpha(). + "X" means the transformation is obtained by png_set_expand(). + "1" means the transformation is obtained by +- png_set_expand_gray_1_2_4_to_8 +- "G" means the transformation is obtained by +- png_set_gray_to_rgb(). ++ png_set_expand_gray_1_2_4_to_8() (and by png_set_expand() ++ if there is no transparency in the original or the final ++ format). ++ "C" means the transformation is obtained by png_set_gray_to_rgb(). ++ "G" means the transformation is obtained by png_set_rgb_to_gray(). + "P" means the transformation is obtained by + png_set_expand_palette_to_rgb(). ++ "p" means the transformation is obtained by png_set_packing(). ++ "Q" means the transformation is obtained by png_set_quantize(). + "T" means the transformation is obtained by + png_set_tRNS_to_alpha(). ++ "B" means the transformation is obtained by ++ png_set_background(), or png_strip_alpha(). + +-PNG can have files with 16 bits per channel. If you only can handle +-8 bits per channel, this will strip the pixels down to 8 bit. +- +- if (bit_depth == 16) +- png_set_strip_16(png_ptr); +- +-If, for some reason, you don't need the alpha channel on an image, +-and you want to remove it rather than combining it with the background +-(but the image author certainly had in mind that you *would* combine +-it with the background, so that's what you should probably do): +- +- if (color_type & PNG_COLOR_MASK_ALPHA) +- png_set_strip_alpha(png_ptr); ++When an entry has multiple transforms listed all are required to cause the ++right overall transformation. When two transforms are separated by a comma ++either will do the job. When transforms are enclosed in [] the transform should ++do the job but this is currently unimplemented - a different format will result ++if the suggested transformations are used. + + In PNG files, the alpha channel in an image + is the level of opacity. If you need the alpha channel in an image to +@@ -1759,22 +2375,13 @@ images) is fully transparent, with + + png_set_invert_alpha(png_ptr); + +-The PNG format only supports pixels with postmultiplied alpha. +-If you want to replace the pixels, after reading them, with pixels +-that have premultiplied color samples, you can do this with +- +- png_set_premultiply_alpha(png_ptr); +- +-If you do this, any input with a tRNS chunk will be expanded to +-have an alpha channel. +- + PNG files pack pixels of bit depths 1, 2, and 4 into bytes as small as + they can, resulting in, for example, 8 pixels per byte for 1 bit + files. This code expands to 1 pixel per byte without changing the + values of the pixels: + + if (bit_depth < 8) +- png_set_packing(png_ptr); ++ png_set_packing(png_ptr); + + PNG files have possible bit depths of 1, 2, 4, 8, and 16. All pixels + stored in a PNG image have been "scaled" or "shifted" up to the next +@@ -1786,217 +2393,201 @@ image. This call reduces the pixels back down to the original bit depth: + png_color_8p sig_bit; + + if (png_get_sBIT(png_ptr, info_ptr, &sig_bit)) +- png_set_shift(png_ptr, sig_bit); ++ png_set_shift(png_ptr, sig_bit); + + PNG files store 3-color pixels in red, green, blue order. This code + changes the storage of the pixels to blue, green, red: + + if (color_type == PNG_COLOR_TYPE_RGB || + color_type == PNG_COLOR_TYPE_RGB_ALPHA) +- png_set_bgr(png_ptr); ++ png_set_bgr(png_ptr); + + PNG files store RGB pixels packed into 3 or 6 bytes. This code expands them + into 4 or 8 bytes for windowing systems that need them in this format: + + if (color_type == PNG_COLOR_TYPE_RGB) +- png_set_filler(png_ptr, filler, PNG_FILLER_BEFORE); ++ png_set_filler(png_ptr, filler, PNG_FILLER_BEFORE); + +-where "filler" is the 8 or 16-bit number to fill with, and the location is +-either PNG_FILLER_BEFORE or PNG_FILLER_AFTER, depending upon whether +-you want the filler before the RGB or after. This transformation +-does not affect images that already have full alpha channels. To add an +-opaque alpha channel, use filler=0xff or 0xffff and PNG_FILLER_AFTER which +-will generate RGBA pixels. ++where "filler" is the 8-bit or 16-bit number to fill with, and the location ++is either PNG_FILLER_BEFORE or PNG_FILLER_AFTER, depending upon whether ++you want the filler before the RGB or after. When filling an 8-bit pixel, ++the least significant 8 bits of the number are used, if a 16-bit number is ++supplied. This transformation does not affect images that already have full ++alpha channels. To add an opaque alpha channel, use filler=0xffff and ++PNG_FILLER_AFTER which will generate RGBA pixels. + + Note that png_set_filler() does not change the color type. If you want + to do that, you can add a true alpha channel with + + if (color_type == PNG_COLOR_TYPE_RGB || +- color_type == PNG_COLOR_TYPE_GRAY) +- png_set_add_alpha(png_ptr, filler, PNG_FILLER_AFTER); ++ color_type == PNG_COLOR_TYPE_GRAY) ++ png_set_add_alpha(png_ptr, filler, PNG_FILLER_AFTER); + + where "filler" contains the alpha value to assign to each pixel. +-This function was added in libpng-1.2.7. ++The png_set_add_alpha() function was added in libpng-1.2.7. + + If you are reading an image with an alpha channel, and you need the + data as ARGB instead of the normal PNG format RGBA: + + if (color_type == PNG_COLOR_TYPE_RGB_ALPHA) +- png_set_swap_alpha(png_ptr); ++ png_set_swap_alpha(png_ptr); + + For some uses, you may want a grayscale image to be represented as + RGB. This code will do that conversion: + + if (color_type == PNG_COLOR_TYPE_GRAY || + color_type == PNG_COLOR_TYPE_GRAY_ALPHA) +- png_set_gray_to_rgb(png_ptr); ++ png_set_gray_to_rgb(png_ptr); + + Conversely, you can convert an RGB or RGBA image to grayscale or grayscale + with alpha. + + if (color_type == PNG_COLOR_TYPE_RGB || + color_type == PNG_COLOR_TYPE_RGB_ALPHA) +- png_set_rgb_to_gray_fixed(png_ptr, error_action, +- int red_weight, int green_weight); ++ png_set_rgb_to_gray(png_ptr, error_action, ++ double red_weight, double green_weight); + + error_action = 1: silently do the conversion ++ + error_action = 2: issue a warning if the original + image has any pixel where + red != green or red != blue ++ + error_action = 3: issue an error and abort the + conversion if the original + image has any pixel where + red != green or red != blue + +- red_weight: weight of red component times 100000 +- green_weight: weight of green component times 100000 ++ red_weight: weight of red component ++ ++ green_weight: weight of green component + If either weight is negative, default +- weights (21268, 71514) are used. ++ weights are used. ++ ++In the corresponding fixed point API the red_weight and green_weight values are ++simply scaled by 100,000: ++ ++ png_set_rgb_to_gray(png_ptr, error_action, ++ png_fixed_point red_weight, ++ png_fixed_point green_weight); + + If you have set error_action = 1 or 2, you can + later check whether the image really was gray, after processing + the image rows, with the png_get_rgb_to_gray_status(png_ptr) function. + It will return a png_byte that is zero if the image was gray or +-1 if there were any non-gray pixels. bKGD and sBIT data ++1 if there were any non-gray pixels. Background and sBIT data + will be silently converted to grayscale, using the green channel +-data, regardless of the error_action setting. +- +-With red_weight+green_weight<=100000, +-the normalized graylevel is computed: ++data for sBIT, regardless of the error_action setting. + +- int rw = red_weight * 65536; +- int gw = green_weight * 65536; +- int bw = 65536 - (rw + gw); +- gray = (rw*red + gw*green + bw*blue)/65536; ++The default values come from the PNG file cHRM chunk if present; otherwise, the ++defaults correspond to the ITU-R recommendation 709, and also the sRGB color ++space, as recommended in the Charles Poynton's Colour FAQ, ++Copyright (c) 2006-11-28 Charles Poynton, in section 9: + +-The default values approximate those recommended in the Charles +-Poynton's Color FAQ, +-Copyright (c) 1998-01-04 Charles Poynton ++ + +- Y = 0.212671 * R + 0.715160 * G + 0.072169 * B ++ Y = 0.2126 * R + 0.7152 * G + 0.0722 * B + +-Libpng approximates this with ++Previous versions of this document, 1998 through 2002, recommended a slightly ++different formula: + +- Y = 0.21268 * R + 0.7151 * G + 0.07217 * B ++ Y = 0.212671 * R + 0.715160 * G + 0.072169 * B + +-which can be expressed with integers as ++Libpng uses an integer approximation: + +- Y = (6969 * R + 23434 * G + 2365 * B)/32768 ++ Y = (6968 * R + 23434 * G + 2366 * B)/32768 + + The calculation is done in a linear colorspace, if the image gamma +-is known. ++can be determined. + +-If you have a grayscale and you are using png_set_expand_depth(), +-png_set_expand(), or png_set_gray_to_rgb to change to truecolor or to +-a higher bit-depth, you must either supply the background color as a gray +-value at the original file bit-depth (need_expand = 1) or else supply the +-background color as an RGB triplet at the final, expanded bit depth +-(need_expand = 0). Similarly, if you are reading a paletted image, you +-must either supply the background color as a palette index (need_expand = 1) +-or as an RGB triplet that may or may not be in the palette (need_expand = 0). ++The png_set_background() function has been described already; it tells libpng to ++composite images with alpha or simple transparency against the supplied ++background color. For compatibility with versions of libpng earlier than ++libpng-1.5.4 it is recommended that you call the function after reading the file ++header, even if you don't want to use the color in a bKGD chunk, if one exists. ++ ++If the PNG file contains a bKGD chunk (PNG_INFO_bKGD valid), ++you may use this color, or supply another color more suitable for ++the current display (e.g., the background color from a web page). You ++need to tell libpng how the color is represented, both the format of the ++component values in the color (the number of bits) and the gamma encoding of the ++color. The function takes two arguments, background_gamma_mode and need_expand ++to convey this information; however, only two combinations are likely to be ++useful: + + png_color_16 my_background; + png_color_16p image_background; + + if (png_get_bKGD(png_ptr, info_ptr, &image_background)) +- png_set_background(png_ptr, image_background, +- PNG_BACKGROUND_GAMMA_FILE, 1, 1.0); ++ png_set_background(png_ptr, image_background, ++ PNG_BACKGROUND_GAMMA_FILE, 1/*needs to be expanded*/, 1); + else +- png_set_background(png_ptr, &my_background, +- PNG_BACKGROUND_GAMMA_SCREEN, 0, 1.0); ++ png_set_background(png_ptr, &my_background, ++ PNG_BACKGROUND_GAMMA_SCREEN, 0/*do not expand*/, 1); ++ ++The second call was described above - my_background is in the format of the ++final, display, output produced by libpng. Because you now know the format of ++the PNG it is possible to avoid the need to choose either 8-bit or 16-bit ++output and to retain palette images (the palette colors will be modified ++appropriately and the tRNS chunk removed.) However, if you are doing this, ++take great care not to ask for transformations without checking first that ++they apply! ++ ++In the first call the background color has the original bit depth and color type ++of the PNG file. So, for palette images the color is supplied as a palette ++index and for low bit greyscale images the color is a reduced bit value in ++image_background->gray. ++ ++If you didn't call png_set_gamma() before reading the file header, for example ++if you need your code to remain compatible with older versions of libpng prior ++to libpng-1.5.4, this is the place to call it. ++ ++Do not call it if you called png_set_alpha_mode(); doing so will damage the ++settings put in place by png_set_alpha_mode(). (If png_set_alpha_mode() is ++supported then you can certainly do png_set_gamma() before reading the PNG ++header.) ++ ++This API unconditionally sets the screen and file gamma values, so it will ++override the value in the PNG file unless it is called before the PNG file ++reading starts. For this reason you must always call it with the PNG file ++value when you call it in this position: ++ ++ if (png_get_gAMA(png_ptr, info_ptr, &file_gamma)) ++ png_set_gamma(png_ptr, screen_gamma, file_gamma); + +-The png_set_background() function tells libpng to composite images +-with alpha or simple transparency against the supplied background +-color. If the PNG file contains a bKGD chunk (PNG_INFO_bKGD valid), +-you may use this color, or supply another color more suitable for +-the current display (e.g., the background color from a web page). You +-need to tell libpng whether the color is in the gamma space of the +-display (PNG_BACKGROUND_GAMMA_SCREEN for colors you supply), the file +-(PNG_BACKGROUND_GAMMA_FILE for colors from the bKGD chunk), or one +-that is neither of these gammas (PNG_BACKGROUND_GAMMA_UNIQUE - I don't +-know why anyone would use this, but it's here). +- +-To properly display PNG images on any kind of system, the application needs +-to know what the display gamma is. Ideally, the user will know this, and +-the application will allow them to set it. One method of allowing the user +-to set the display gamma separately for each system is to check for a +-SCREEN_GAMMA or DISPLAY_GAMMA environment variable, which will hopefully be +-correctly set. +- +-Note that display_gamma is the overall gamma correction required to produce +-pleasing results, which depends on the lighting conditions in the surrounding +-environment. In a dim or brightly lit room, no compensation other than +-the physical gamma exponent of the monitor is needed, while in a dark room +-a slightly smaller exponent is better. +- +- double gamma, screen_gamma; +- +- if (/* We have a user-defined screen +- gamma value */) +- { +- screen_gamma = user_defined_screen_gamma; +- } +- /* One way that applications can share the same +- screen gamma value */ +- else if ((gamma_str = getenv("SCREEN_GAMMA")) +- != NULL) +- { +- screen_gamma = (double)atof(gamma_str); +- } +- /* If we don't have another value */ +- else +- { +- screen_gamma = 2.2; /* A good guess for a +- PC monitor in a bright office or a dim room */ +- screen_gamma = 2.0; /* A good guess for a +- PC monitor in a dark room */ +- screen_gamma = 1.7 or 1.0; /* A good +- guess for Mac systems */ +- } +- +-The png_set_gamma() function handles gamma transformations of the data. +-Pass both the file gamma and the current screen_gamma. If the file does +-not have a gamma value, you can pass one anyway if you have an idea what +-it is (usually 0.45455 is a good guess for GIF images on PCs). Note +-that file gammas are inverted from screen gammas. See the discussions +-on gamma in the PNG specification for an excellent description of what +-gamma is, and why all applications should support it. It is strongly +-recommended that PNG viewers support gamma correction. +- +- if (png_get_gAMA(png_ptr, info_ptr, &gamma)) +- png_set_gamma(png_ptr, screen_gamma, gamma); + else + png_set_gamma(png_ptr, screen_gamma, 0.45455); + + If you need to reduce an RGB file to a paletted file, or if a paletted +-file has more entries then will fit on your screen, png_set_dither() +-will do that. Note that this is a simple match dither that merely ++file has more entries than will fit on your screen, png_set_quantize() ++will do that. Note that this is a simple match quantization that merely + finds the closest color available. This should work fairly well with +-optimized palettes, and fairly badly with linear color cubes. If you +-pass a palette that is larger then maximum_colors, the file will ++optimized palettes, but fairly badly with linear color cubes. If you ++pass a palette that is larger than maximum_colors, the file will + reduce the number of colors in the palette so it will fit into +-maximum_colors. If there is a histogram, it will use it to make ++maximum_colors. If there is a histogram, libpng will use it to make + more intelligent choices when reducing the palette. If there is no + histogram, it may not do as good a job. + + if (color_type & PNG_COLOR_MASK_COLOR) + { + if (png_get_valid(png_ptr, info_ptr, +- PNG_INFO_PLTE)) ++ PNG_INFO_PLTE)) + { + png_uint_16p histogram = NULL; + + png_get_hIST(png_ptr, info_ptr, +- &histogram); +- png_set_dither(png_ptr, palette, num_palette, ++ &histogram); ++ png_set_quantize(png_ptr, palette, num_palette, + max_screen_colors, histogram, 1); + } ++ + else + { + png_color std_color_cube[MAX_SCREEN_COLORS] = + { ... colors ... }; + +- png_set_dither(png_ptr, std_color_cube, ++ png_set_quantize(png_ptr, std_color_cube, + MAX_SCREEN_COLORS, MAX_SCREEN_COLORS, + NULL,0); + } +@@ -2012,16 +2603,16 @@ zero): + This function can also be used to invert grayscale and gray-alpha images: + + if (color_type == PNG_COLOR_TYPE_GRAY || +- color_type == PNG_COLOR_TYPE_GRAY_ALPHA) ++ color_type == PNG_COLOR_TYPE_GRAY_ALPHA) + png_set_invert_mono(png_ptr); + +-PNG files store 16 bit pixels in network byte order (big-endian, ++PNG files store 16-bit pixels in network byte order (big-endian, + ie. most significant bits first). This code changes the storage to the + other way (little-endian, i.e. least significant bits first, the + way PCs store them): + + if (bit_depth == 16) +- png_set_swap(png_ptr); ++ png_set_swap(png_ptr); + + If you are using packed-pixel images (1, 2, or 4 bits/pixel), and you + need to change the order the pixels are packed into bytes, you can use: +@@ -2034,15 +2625,36 @@ the existing ones meets your needs. This is done by setting a callback + with + + png_set_read_user_transform_fn(png_ptr, +- read_transform_fn); ++ read_transform_fn); + + You must supply the function + +- void read_transform_fn(png_ptr ptr, row_info_ptr +- row_info, png_bytep data) ++ void read_transform_fn(png_structp png_ptr, png_row_infop ++ row_info, png_bytep data) + + See pngtest.c for a working example. Your function will be called +-after all of the other transformations have been processed. ++after all of the other transformations have been processed. Take care with ++interlaced images if you do the interlace yourself - the width of the row is the ++width in 'row_info', not the overall image width. ++ ++If supported, libpng provides two information routines that you can use to find ++where you are in processing the image: ++ ++ png_get_current_pass_number(png_structp png_ptr); ++ png_get_current_row_number(png_structp png_ptr); ++ ++Don't try using these outside a transform callback - firstly they are only ++supported if user transforms are supported, secondly they may well return ++unexpected results unless the row is actually being processed at the moment they ++are called. ++ ++With interlaced ++images the value returned is the row in the input sub-image image. Use ++PNG_ROW_FROM_PASS_ROW(row, pass) and PNG_COL_FROM_PASS_COL(col, pass) to ++find the output pixel (x,y) given an interlaced sub-image pixel (row,col,pass). ++ ++The discussion of interlace handling above contains more information on how to ++use these values. + + You can also set up a pointer to a user structure for use by your + callback function, and you can inform libpng that your transform +@@ -2050,7 +2662,7 @@ function will change the number of channels or bit depth with the + function + + png_set_user_transform_info(png_ptr, user_ptr, +- user_depth, user_channels); ++ user_depth, user_channels); + + The user's application, not libpng, is responsible for allocating and + freeing any memory required for the user structure. +@@ -2059,7 +2671,7 @@ You can retrieve the pointer via the function + png_get_user_transform_ptr(). For example: + + voidp read_user_transform_ptr = +- png_get_user_transform_ptr(png_ptr); ++ png_get_user_transform_ptr(png_ptr); + + The last thing to handle is interlacing; this is covered in detail below, + but you must call the function here if you want libpng to handle expansion +@@ -2069,13 +2681,16 @@ of the interlaced image. + + After setting the transformations, libpng can update your png_info + structure to reflect any transformations you've requested with this +-call. This is most useful to update the info structure's rowbytes +-field so you can use it to allocate your image memory. This function +-will also update your palette with the correct screen_gamma and +-background if these have been given with the calls above. ++call. + + png_read_update_info(png_ptr, info_ptr); + ++This is most useful to update the info structure's rowbytes ++field so you can use it to allocate your image memory. This function ++will also update your palette with the correct screen_gamma and ++background if these have been given with the calls above. You may ++only call png_read_update_info() once with a particular info_ptr. ++ + After you call png_read_update_info(), you can allocate any + memory you need to hold the image. The row data is simply + raw byte data for all forms of images. As the actual allocation +@@ -2084,6 +2699,25 @@ are allocating one large chunk, you will need to build an + array of pointers to each row, as it will be needed for some + of the functions below. + ++Be sure that your platform can allocate the buffer that you'll need. ++libpng internally checks for oversize width, but you'll need to ++do your own check for number_of_rows*width*pixel_size if you are using ++a multiple-row buffer: ++ ++ /* Guard against integer overflow */ ++ if (number_of_rows > PNG_SIZE_MAX/(width*pixel_size)) { ++ png_error(png_ptr,"image_data buffer would be too large"); ++ } ++ ++Remember: Before you call png_read_update_info(), the png_get_*() ++functions return the values corresponding to the original PNG image. ++After you call png_read_update_info the values refer to the image ++that libpng will output. Consequently you must call all the png_set_ ++functions before you call png_read_update_info(). This is particularly ++important for png_set_interlace_handling() - if you are going to call ++png_read_update_info() you must call png_set_interlace_handling() before ++it unless you want to receive interlaced output. ++ + .SS Reading image data + + After you've allocated memory, you can read the image data. +@@ -2093,9 +2727,10 @@ call png_read_image() and libpng will read in all the image data + and put it in the memory area supplied. You will need to pass in + an array of pointers to each row. + +-This function automatically handles interlacing, so you don't need +-to call png_set_interlace_handling() or call this function multiple +-times, or any of that other stuff necessary with png_read_rows(). ++This function automatically handles interlacing, so you don't ++need to call png_set_interlace_handling() (unless you call ++png_read_update_info()) or call this function multiple times, or any ++of that other stuff necessary with png_read_rows(). + + png_read_image(png_ptr, row_pointers); + +@@ -2110,7 +2745,7 @@ use png_read_rows() instead. If there is no interlacing (check + interlace_type == PNG_INTERLACE_NONE), this is simple: + + png_read_rows(png_ptr, row_pointers, NULL, +- number_of_rows); ++ number_of_rows); + + where row_pointers is the same as in the png_read_image() call. + +@@ -2122,13 +2757,15 @@ a single row_pointer instead of an array of row_pointers: + + If the file is interlaced (interlace_type != 0 in the IHDR chunk), things + get somewhat harder. The only current (PNG Specification version 1.2) +-interlacing type for PNG is (interlace_type == PNG_INTERLACE_ADAM7) +-is a somewhat complicated 2D interlace scheme, known as Adam7, that ++interlacing type for PNG is (interlace_type == PNG_INTERLACE_ADAM7); ++a somewhat complicated 2D interlace scheme, known as Adam7, that + breaks down an image into seven smaller images of varying size, based +-on an 8x8 grid. ++on an 8x8 grid. This number is defined (from libpng 1.5) as ++PNG_INTERLACE_ADAM7_PASSES in png.h + + libpng can fill out those images or it can give them to you "as is". +-If you want them filled out, there are two ways to do that. The one ++It is almost always better to have libpng handle the interlacing for you. ++If you want the images filled out, there are two ways to do that. The one + mentioned in the PNG specification is to expand each pixel to cover + those pixels that have not been read yet (the "rectangle" method). + This results in a blocky image for the first pass, which gradually +@@ -2138,37 +2775,20 @@ rest of the image remaining whatever colors they were initialized to + before the start of the read. The first method usually looks better, + but tends to be slower, as there are more pixels to put in the rows. + +-If you don't want libpng to handle the interlacing details, just call +-png_read_rows() seven times to read in all seven images. Each of the +-images is a valid image by itself, or they can all be combined on an +-8x8 grid to form a single image (although if you intend to combine them +-you would be far better off using the libpng interlace handling). +- +-The first pass will return an image 1/8 as wide as the entire image +-(every 8th column starting in column 0) and 1/8 as high as the original +-(every 8th row starting in row 0), the second will be 1/8 as wide +-(starting in column 4) and 1/8 as high (also starting in row 0). The +-third pass will be 1/4 as wide (every 4th pixel starting in column 0) and +-1/8 as high (every 8th row starting in row 4), and the fourth pass will +-be 1/4 as wide and 1/4 as high (every 4th column starting in column 2, +-and every 4th row starting in row 0). The fifth pass will return an +-image 1/2 as wide, and 1/4 as high (starting at column 0 and row 2), +-while the sixth pass will be 1/2 as wide and 1/2 as high as the original +-(starting in column 1 and row 0). The seventh and final pass will be as +-wide as the original, and 1/2 as high, containing all of the odd +-numbered scanlines. Phew! +- +-If you want libpng to expand the images, call this before calling +-png_start_read_image() or png_read_update_info(): ++If, as is likely, you want libpng to expand the images, call this before ++calling png_start_read_image() or png_read_update_info(): + + if (interlace_type == PNG_INTERLACE_ADAM7) +- number_of_passes ++ number_of_passes + = png_set_interlace_handling(png_ptr); + +-This will return the number of passes needed. Currently, this +-is seven, but may change if another interlace type is added. +-This function can be called even if the file is not interlaced, +-where it will return one pass. ++This will return the number of passes needed. Currently, this is seven, ++but may change if another interlace type is added. This function can be ++called even if the file is not interlaced, where it will return one pass. ++You then need to read the whole image 'number_of_passes' times. Each time ++will distribute the pixels from the current pass to the correct place in ++the output image, so you need to supply the same rows to png_read_rows in ++each pass. + + If you are not going to display the image after each pass, but are + going to wait until the entire image is read in, use the sparkle +@@ -2177,7 +2797,8 @@ is exactly the same. If you are planning on displaying the image + after each pass, the "rectangle" effect is generally considered the + better looking one. + +-If you only want the "sparkle" effect, just call png_read_rows() as ++If you only want the "sparkle" effect, just call png_read_row() or ++png_read_rows() as + normal, with the third parameter NULL. Make sure you make pass over + the image number_of_passes times, and you don't change the data in the + rows between calls. You can change the locations of the data, just +@@ -2185,35 +2806,162 @@ not the data. Each pass only writes the pixels appropriate for that + pass, and assumes the data from previous passes is still valid. + + png_read_rows(png_ptr, row_pointers, NULL, +- number_of_rows); ++ number_of_rows); ++ or ++ png_read_row(png_ptr, row_pointers, NULL); + + If you only want the first effect (the rectangles), do the same as + before except pass the row buffer in the third parameter, and leave + the second parameter NULL. + + png_read_rows(png_ptr, NULL, row_pointers, +- number_of_rows); ++ number_of_rows); ++ or ++ png_read_row(png_ptr, NULL, row_pointers); ++ ++If you don't want libpng to handle the interlacing details, just call ++png_read_rows() PNG_INTERLACE_ADAM7_PASSES times to read in all the images. ++Each of the images is a valid image by itself; however, you will almost ++certainly need to distribute the pixels from each sub-image to the ++correct place. This is where everything gets very tricky. ++ ++If you want to retrieve the separate images you must pass the correct ++number of rows to each successive call of png_read_rows(). The calculation ++gets pretty complicated for small images, where some sub-images may ++not even exist because either their width or height ends up zero. ++libpng provides two macros to help you in 1.5 and later versions: ++ ++ png_uint_32 width = PNG_PASS_COLS(image_width, pass_number); ++ png_uint_32 height = PNG_PASS_ROWS(image_height, pass_number); ++ ++Respectively these tell you the width and height of the sub-image ++corresponding to the numbered pass. 'pass' is in in the range 0 to 6 - ++this can be confusing because the specification refers to the same passes ++as 1 to 7! Be careful, you must check both the width and height before ++calling png_read_rows() and not call it for that pass if either is zero. ++ ++You can, of course, read each sub-image row by row. If you want to ++produce optimal code to make a pixel-by-pixel transformation of an ++interlaced image this is the best approach; read each row of each pass, ++transform it, and write it out to a new interlaced image. ++ ++If you want to de-interlace the image yourself libpng provides further ++macros to help that tell you where to place the pixels in the output image. ++Because the interlacing scheme is rectangular - sub-image pixels are always ++arranged on a rectangular grid - all you need to know for each pass is the ++starting column and row in the output image of the first pixel plus the ++spacing between each pixel. As of libpng 1.5 there are four macros to ++retrieve this information: ++ ++ png_uint_32 x = PNG_PASS_START_COL(pass); ++ png_uint_32 y = PNG_PASS_START_ROW(pass); ++ png_uint_32 xStep = 1U << PNG_PASS_COL_SHIFT(pass); ++ png_uint_32 yStep = 1U << PNG_PASS_ROW_SHIFT(pass); ++ ++These allow you to write the obvious loop: ++ ++ png_uint_32 input_y = 0; ++ png_uint_32 output_y = PNG_PASS_START_ROW(pass); ++ ++ while (output_y < output_image_height) ++ { ++ png_uint_32 input_x = 0; ++ png_uint_32 output_x = PNG_PASS_START_COL(pass); ++ ++ while (output_x < output_image_width) ++ { ++ image[output_y][output_x] = ++ subimage[pass][input_y][input_x++]; ++ ++ output_x += xStep; ++ } ++ ++ ++input_y; ++ output_y += yStep; ++ } ++ ++Notice that the steps between successive output rows and columns are ++returned as shifts. This is possible because the pixels in the subimages ++are always a power of 2 apart - 1, 2, 4 or 8 pixels - in the original ++image. In practice you may need to directly calculate the output coordinate ++given an input coordinate. libpng provides two further macros for this ++purpose: ++ ++ png_uint_32 output_x = PNG_COL_FROM_PASS_COL(input_x, pass); ++ png_uint_32 output_y = PNG_ROW_FROM_PASS_ROW(input_y, pass); ++ ++Finally a pair of macros are provided to tell you if a particular image ++row or column appears in a given pass: ++ ++ int col_in_pass = PNG_COL_IN_INTERLACE_PASS(output_x, pass); ++ int row_in_pass = PNG_ROW_IN_INTERLACE_PASS(output_y, pass); ++ ++Bear in mind that you will probably also need to check the width and height ++of the pass in addition to the above to be sure the pass even exists! ++ ++With any luck you are convinced by now that you don't want to do your own ++interlace handling. In reality normally the only good reason for doing this ++is if you are processing PNG files on a pixel-by-pixel basis and don't want ++to load the whole file into memory when it is interlaced. ++ ++libpng includes a test program, pngvalid, that illustrates reading and ++writing of interlaced images. If you can't get interlacing to work in your ++code and don't want to leave it to libpng (the recommended approach), see ++how pngvalid.c does it. + + .SS Finishing a sequential read + + After you are finished reading the image through the +-low-level interface, you can finish reading the file. If you are +-interested in comments or time, which may be stored either before or +-after the image data, you should pass the separate png_info struct if +-you want to keep the comments from before and after the image +-separate. If you are not interested, you can pass NULL. ++low-level interface, you can finish reading the file. ++ ++If you want to use a different crc action for handling CRC errors in ++chunks after the image data, you can call png_set_crc_action() ++again at this point. ++ ++If you are interested in comments or time, which may be stored either ++before or after the image data, you should pass the separate png_info ++struct if you want to keep the comments from before and after the image ++separate. ++ ++ png_infop end_info = png_create_info_struct(png_ptr); ++ ++ if (!end_info) ++ { ++ png_destroy_read_struct(&png_ptr, &info_ptr, ++ (png_infopp)NULL); ++ return ERROR; ++ } + + png_read_end(png_ptr, end_info); + ++If you are not interested, you should still call png_read_end() ++but you can pass NULL, avoiding the need to create an end_info structure. ++If you do this, libpng will not process any chunks after IDAT other than ++skipping over them and perhaps (depending on whether you have called ++png_set_crc_action) checking their CRCs while looking for the IEND chunk. ++ ++ png_read_end(png_ptr, (png_infop)NULL); ++ ++If you don't call png_read_end(), then your file pointer will be ++left pointing to the first chunk after the last IDAT, which is probably ++not what you want if you expect to read something beyond the end of ++the PNG datastream. ++ + When you are done, you can free all memory allocated by libpng like this: + + png_destroy_read_struct(&png_ptr, &info_ptr, + &end_info); + ++or, if you didn't create an end_info structure, ++ ++ png_destroy_read_struct(&png_ptr, &info_ptr, ++ (png_infopp)NULL); ++ + It is also possible to individually free the info_ptr members that + point to libpng-allocated storage with the following function: + + png_free_data(png_ptr, info_ptr, mask, seq) ++ + mask - identifies data to be freed, a mask + containing the bitwise OR of one or + more of +@@ -2223,30 +2971,33 @@ point to libpng-allocated storage with the following function: + PNG_FREE_SCAL, PNG_FREE_SPLT, + PNG_FREE_TEXT, PNG_FREE_UNKN, + or simply PNG_FREE_ALL ++ + seq - sequence number of item to be freed +- (-1 for all items) ++ (\-1 for all items) + + This function may be safely called when the relevant storage has + already been freed, or has not yet been allocated, or was allocated + by the user and not by libpng, and will in those cases do nothing. + The "seq" parameter is ignored if only one item of the selected data +-type, such as PLTE, is allowed. If "seq" is not -1, and multiple items ++type, such as PLTE, is allowed. If "seq" is not \-1, and multiple items + are allowed for the data type identified in the mask, such as text or + sPLT, only the n'th item in the structure is freed, where n is "seq". + + The default behavior is only to free data that was allocated internally + by libpng. This can be changed, so that libpng will not free the data, + or so that it will free data that was allocated by the user with png_malloc() +-or png_zalloc() and passed in via a png_set_*() function, with ++or png_calloc() and passed in via a png_set_*() function, with + + png_data_freer(png_ptr, info_ptr, freer, mask) +- mask - which data elements are affected +- same choices as in png_free_data() ++ + freer - one of + PNG_DESTROY_WILL_FREE_DATA + PNG_SET_WILL_FREE_DATA + PNG_USER_WILL_FREE_DATA + ++ mask - which data elements are affected ++ same choices as in png_free_data() ++ + This function only affects data that has already been allocated. + You can call this function after reading the PNG data but before calling + any png_set_*() functions, to control whether the user or the png_set_*() +@@ -2256,7 +3007,7 @@ or png_destroy_*() is supposed to free the data. When the user assumes + responsibility for libpng-allocated data, the application must use + png_free() to free it, and when the user transfers responsibility to libpng + for data that the user has allocated, the user must have used png_malloc() +-or png_zalloc() to allocate it. ++or png_calloc() to allocate it. + + If you allocated your row_pointers in a single block, as suggested above in + the description of the high level read interface, you must not transfer +@@ -2275,12 +3026,14 @@ it frees. If you need to turn the flag off for a chunk that was freed by + your application instead of by libpng, you can use + + png_set_invalid(png_ptr, info_ptr, mask); ++ + mask - identifies the chunks to be made invalid, + containing the bitwise OR of one or + more of + PNG_INFO_gAMA, PNG_INFO_sBIT, + PNG_INFO_cHRM, PNG_INFO_PLTE, + PNG_INFO_tRNS, PNG_INFO_bKGD, ++ PNG_INFO_eXIf, + PNG_INFO_hIST, PNG_INFO_pHYs, + PNG_INFO_oFFs, PNG_INFO_tIME, + PNG_INFO_pCAL, PNG_INFO_sRGB, +@@ -2291,7 +3044,7 @@ For a more compact example of reading a PNG image, see the file example.c. + + .SS Reading PNG files progressively + +-The progressive reader is slightly different then the non-progressive ++The progressive reader is slightly different from the non-progressive + reader. Instead of calling png_read_info(), png_read_rows(), and + png_read_end(), you make one call to png_process_data(), which calls + callbacks when it has the info, a row, or the end of the image. You +@@ -2314,21 +3067,24 @@ png_infop info_ptr; + png_ptr = png_create_read_struct + (PNG_LIBPNG_VER_STRING, (png_voidp)user_error_ptr, + user_error_fn, user_warning_fn); ++ + if (!png_ptr) +- return (ERROR); ++ return ERROR; ++ + info_ptr = png_create_info_struct(png_ptr); ++ + if (!info_ptr) + { +- png_destroy_read_struct(&png_ptr, (png_infopp)NULL, +- (png_infopp)NULL); +- return (ERROR); ++ png_destroy_read_struct(&png_ptr, ++ (png_infopp)NULL, (png_infopp)NULL); ++ return ERROR; + } + + if (setjmp(png_jmpbuf(png_ptr))) + { +- png_destroy_read_struct(&png_ptr, &info_ptr, +- (png_infopp)NULL); +- return (ERROR); ++ png_destroy_read_struct(&png_ptr, &info_ptr, ++ (png_infopp)NULL); ++ return ERROR; + } + + /* This one's new. You can provide functions +@@ -2360,9 +3116,9 @@ png_infop info_ptr; + { + if (setjmp(png_jmpbuf(png_ptr))) + { +- png_destroy_read_struct(&png_ptr, &info_ptr, ++ png_destroy_read_struct(&png_ptr, &info_ptr, + (png_infopp)NULL); +- return (ERROR); ++ return ERROR; + } + + /* This one's new also. Simply give it a chunk +@@ -2372,13 +3128,19 @@ png_infop info_ptr; + 64K. The library seems to run fine with sizes + of 4K. Although you can give it much less if + necessary (I assume you can give it chunks of +- 1 byte, I haven't tried less then 256 bytes ++ 1 byte, I haven't tried less than 256 bytes + yet). When this function returns, you may + want to display any rows that were generated + in the row callback if you don't already do + so there. + */ + png_process_data(png_ptr, info_ptr, buffer, length); ++ ++ /* At this point you can call png_process_data_skip if ++ you want to handle data the library will skip yourself; ++ it simply returns the number of bytes to skip (and stops ++ libpng skipping that number of bytes on the next ++ png_process_data call). + return 0; + } + +@@ -2399,6 +3161,19 @@ png_infop info_ptr; + any). You may start getting rows before + png_process_data() returns, so this is your + last chance to prepare for that. ++ ++ This is where you turn on interlace handling, ++ assuming you don't want to do it yourself. ++ ++ If you need to you can stop the processing of ++ your original input data at this point by calling ++ png_process_data_pause. This returns the number ++ of unprocessed bytes from the last png_process_data ++ call - it is up to you to ensure that the next call ++ sees these bytes again. If you don't want to bother ++ with this you can get libpng to cache the unread ++ bytes by setting the 'save' parameter (see png.h) but ++ then libpng will have to copy the data internally. + */ + } + +@@ -2419,20 +3194,28 @@ png_infop info_ptr; + supplying them because it may make your life + easier. + +- For the non-NULL rows of interlaced images, ++ If you did not turn on interlace handling then ++ the callback is called for each row of each ++ sub-image when the image is interlaced. In this ++ case 'row_num' is the row in the sub-image, not ++ the row in the output image as it is in all other ++ cases. ++ ++ For the non-NULL rows of interlaced images when ++ you have switched on libpng interlace handling, + you must call png_progressive_combine_row() + passing in the row and the old row. You can + call this function for NULL rows (it will just + return) and for non-interlaced images (it just + does the memcpy for you) if it will make the + code easier. Thus, you can just do this for +- all cases: ++ all cases if you switch on interlace handling; + */ + + png_progressive_combine_row(png_ptr, old_row, + new_row); + +- /* where old_row is what was displayed for ++ /* where old_row is what was displayed + previously for the row. Note that the first + pass (pass == 0, really) will completely cover + the old row, so the rows do not have to be +@@ -2440,6 +3223,9 @@ png_infop info_ptr; + for interlaced images), you will have to pass + the current row, and the function will combine + the old row and the new row. ++ ++ You can also call png_process_data_pause in this ++ callback - see above. + */ + } + +@@ -2474,10 +3260,9 @@ using the standard I/O functions, you will need to replace them with + custom writing functions. See the discussion under Customizing libpng. + + FILE *fp = fopen(file_name, "wb"); ++ + if (!fp) +- { +- return (ERROR); +- } ++ return ERROR; + + Next, png_struct and png_info need to be allocated and initialized. + As these can be both relatively large, you may not want to store these +@@ -2490,15 +3275,16 @@ both "png_ptr"; you can call them anything you like, such as + png_structp png_ptr = png_create_write_struct + (PNG_LIBPNG_VER_STRING, (png_voidp)user_error_ptr, + user_error_fn, user_warning_fn); ++ + if (!png_ptr) +- return (ERROR); ++ return ERROR; + + png_infop info_ptr = png_create_info_struct(png_ptr); + if (!info_ptr) + { + png_destroy_write_struct(&png_ptr, +- (png_infopp)NULL); +- return (ERROR); ++ (png_infopp)NULL); ++ return ERROR; + } + + If you want to use your own memory allocation routines, +@@ -2523,17 +3309,35 @@ section below for more information on the libpng error handling. + + if (setjmp(png_jmpbuf(png_ptr))) + { +- png_destroy_write_struct(&png_ptr, &info_ptr); ++ png_destroy_write_struct(&png_ptr, &info_ptr); + fclose(fp); +- return (ERROR); ++ return ERROR; + } + ... + return; + + If you would rather avoid the complexity of setjmp/longjmp issues, +-you can compile libpng with PNG_SETJMP_NOT_SUPPORTED, in which case ++you can compile libpng with PNG_NO_SETJMP, in which case + errors will result in a call to PNG_ABORT() which defaults to abort(). + ++You can #define PNG_ABORT() to a function that does something ++more useful than abort(), as long as your function does not ++return. ++ ++Checking for invalid palette index on write was added at libpng ++1.5.10. If a pixel contains an invalid (out-of-range) index libpng issues ++a benign error. This is enabled by default because this condition is an ++error according to the PNG specification, Clause 11.3.2, but the error can ++be ignored in each png_ptr with ++ ++ png_set_check_for_invalid_index(png_ptr, 0); ++ ++If the error is ignored, or if png_benign_error() treats it as a warning, ++any invalid pixels are written as-is by the encoder, resulting in an ++invalid PNG datastream as output. In this case the application is ++responsible for ensuring that the pixel indexes are in range when it writes ++a PLTE chunk with fewer entries than the bit depth would allow. ++ + Now you need to set up the output code. The default for libpng is to + use the C function fwrite(). If you use this, you will need to pass a + valid FILE * in the function png_init_io(). Be sure that the file is +@@ -2558,7 +3362,7 @@ called after each row has been written, which you can use to control + a progress meter or the like. It's demonstrated in pngtest.c. + You must supply a function + +- void write_row_callback(png_ptr, png_uint_32 row, ++ void write_row_callback(png_structp png_ptr, png_uint_32 row, + int pass); + { + /* put your code here */ +@@ -2570,6 +3374,20 @@ To inform libpng about your function, use + + png_set_write_status_fn(png_ptr, write_row_callback); + ++When this function is called the row has already been completely processed and ++it has also been written out. The 'row' and 'pass' refer to the next row to be ++handled. For the ++non-interlaced case the row that was just handled is simply one less than the ++passed in row number, and pass will always be 0. For the interlaced case the ++same applies unless the row value is 0, in which case the row just handled was ++the last one from one of the preceding passes. Because interlacing may skip a ++pass you cannot be sure that the preceding pass is just 'pass\-1', if you really ++need to know what the last pass is record (row,pass) from the callback and use ++the last recorded value each time. ++ ++As with the user transform you can find the output row using the ++PNG_ROW_FROM_PASS_ROW macro. ++ + You now have the option of modifying how the compression library will + run. The following functions are mainly for testing, but may be useful + in some cases, like if you need to write PNG files extremely fast and +@@ -2589,20 +3407,20 @@ filter types. + /* turn on or off filtering, and/or choose + specific filters. You can use either a single + PNG_FILTER_VALUE_NAME or the bitwise OR of one +- or more PNG_FILTER_NAME masks. */ ++ or more PNG_FILTER_NAME masks. ++ */ + png_set_filter(png_ptr, 0, + PNG_FILTER_NONE | PNG_FILTER_VALUE_NONE | + PNG_FILTER_SUB | PNG_FILTER_VALUE_SUB | + PNG_FILTER_UP | PNG_FILTER_VALUE_UP | + PNG_FILTER_AVG | PNG_FILTER_VALUE_AVG | + PNG_FILTER_PAETH | PNG_FILTER_VALUE_PAETH| +- PNG_ALL_FILTERS); ++ PNG_ALL_FILTERS | PNG_FAST_FILTERS); + +-If an application +-wants to start and stop using particular filters during compression, +-it should start out with all of the filters (to ensure that the previous +-row of pixels will be stored in case it's needed later), and then add +-and remove them after the start of compression. ++If an application wants to start and stop using particular filters during ++compression, it should start out with all of the filters (to ensure that ++the previous row of pixels will be stored in case it's needed later), ++and then add and remove them after the start of compression. + + If you are writing a PNG datastream that is to be embedded in a MNG + datastream, the second parameter can be either 0 or 64. +@@ -2614,11 +3432,13 @@ which changes how much time zlib spends on trying to compress the image + data. See the Compression Library (zlib.h and algorithm.txt, distributed + with zlib) for details on the compression levels. + +- /* set the zlib compression level */ ++ #include zlib.h ++ ++ /* Set the zlib compression level */ + png_set_compression_level(png_ptr, + Z_BEST_COMPRESSION); + +- /* set other zlib parameters */ ++ /* Set other zlib parameters for compressing IDAT */ + png_set_compression_mem_level(png_ptr, 8); + png_set_compression_strategy(png_ptr, + Z_DEFAULT_STRATEGY); +@@ -2626,7 +3446,15 @@ with zlib) for details on the compression levels. + png_set_compression_method(png_ptr, 8); + png_set_compression_buffer_size(png_ptr, 8192) + +-extern PNG_EXPORT(void,png_set_zbuf_size) ++ /* Set zlib parameters for text compression ++ * If you don't call these, the parameters ++ * fall back on those defined for IDAT chunks ++ */ ++ png_set_text_compression_mem_level(png_ptr, 8); ++ png_set_text_compression_strategy(png_ptr, ++ Z_DEFAULT_STRATEGY); ++ png_set_text_compression_window_bits(png_ptr, 15); ++ png_set_text_compression_method(png_ptr, 8); + + .SS Setting the contents of info for output + +@@ -2646,16 +3474,20 @@ Some of the more important parts of the png_info are: + png_set_IHDR(png_ptr, info_ptr, width, height, + bit_depth, color_type, interlace_type, + compression_type, filter_method) ++ + width - holds the width of the image + in pixels (up to 2^31). ++ + height - holds the height of the image + in pixels (up to 2^31). ++ + bit_depth - holds the bit depth of one of the + image channels. + (valid values are 1, 2, 4, 8, 16 + and depend also on the + color_type. See also significant + bits (sBIT) below). ++ + color_type - describes which color/alpha + channels are present. + PNG_COLOR_TYPE_GRAY +@@ -2675,8 +3507,10 @@ Some of the more important parts of the png_info are: + + interlace_type - PNG_INTERLACE_NONE or + PNG_INTERLACE_ADAM7 ++ + compression_type - (must be + PNG_COMPRESSION_TYPE_DEFAULT) ++ + filter_method - (must be PNG_FILTER_TYPE_DEFAULT + or, if you are writing a PNG to + be embedded in a MNG datastream, +@@ -2694,15 +3528,45 @@ width, height, bit_depth, and color_type must be the same in each call. + + png_set_PLTE(png_ptr, info_ptr, palette, + num_palette); ++ + palette - the palette for the file + (array of png_color) + num_palette - number of entries in the palette + +- png_set_gAMA(png_ptr, info_ptr, gamma); +- gamma - the gamma the image was created +- at (PNG_INFO_gAMA) ++ ++ png_set_gAMA(png_ptr, info_ptr, file_gamma); ++ png_set_gAMA_fixed(png_ptr, info_ptr, int_file_gamma); ++ ++ file_gamma - the gamma at which the image was ++ created (PNG_INFO_gAMA) ++ ++ int_file_gamma - 100,000 times the gamma at which ++ the image was created ++ ++ png_set_cHRM(png_ptr, info_ptr, white_x, white_y, red_x, red_y, ++ green_x, green_y, blue_x, blue_y) ++ png_set_cHRM_XYZ(png_ptr, info_ptr, red_X, red_Y, red_Z, green_X, ++ green_Y, green_Z, blue_X, blue_Y, blue_Z) ++ png_set_cHRM_fixed(png_ptr, info_ptr, int_white_x, int_white_y, ++ int_red_x, int_red_y, int_green_x, int_green_y, ++ int_blue_x, int_blue_y) ++ png_set_cHRM_XYZ_fixed(png_ptr, info_ptr, int_red_X, int_red_Y, ++ int_red_Z, int_green_X, int_green_Y, int_green_Z, ++ int_blue_X, int_blue_Y, int_blue_Z) ++ ++ {white,red,green,blue}_{x,y} ++ A color space encoding specified using the chromaticities ++ of the end points and the white point. ++ ++ {red,green,blue}_{X,Y,Z} ++ A color space encoding specified using the encoding end ++ points - the CIE tristimulus specification of the intended ++ color of the red, green and blue channels in the PNG RGB ++ data. The white point is simply the sum of the three end ++ points. + + png_set_sRGB(png_ptr, info_ptr, srgb_intent); ++ + srgb_intent - the rendering intent + (PNG_INFO_sRGB) The presence of + the sRGB chunk means that the pixel +@@ -2722,6 +3586,7 @@ width, height, bit_depth, and color_type must be the same in each call. + + png_set_sRGB_gAMA_and_cHRM(png_ptr, info_ptr, + srgb_intent); ++ + srgb_intent - the rendering intent + (PNG_INFO_sRGB) The presence of the + sRGB chunk means that the pixel +@@ -2732,49 +3597,67 @@ width, height, bit_depth, and color_type must be the same in each call. + written. + + png_set_iCCP(png_ptr, info_ptr, name, compression_type, +- profile, proflen); +- name - The profile name. +- compression - The compression type; always +- PNG_COMPRESSION_TYPE_BASE for PNG 1.0. +- You may give NULL to this argument to +- ignore it. +- profile - International Color Consortium color +- profile data. May contain NULs. +- proflen - length of profile data in bytes. ++ profile, proflen); ++ ++ name - The profile name. ++ ++ compression_type - The compression type; always ++ PNG_COMPRESSION_TYPE_BASE for PNG 1.0. ++ You may give NULL to this argument to ++ ignore it. ++ ++ profile - International Color Consortium color ++ profile data. May contain NULs. ++ ++ proflen - length of profile data in bytes. + + png_set_sBIT(png_ptr, info_ptr, sig_bit); ++ + sig_bit - the number of significant bits for + (PNG_INFO_sBIT) each of the gray, red, + green, and blue channels, whichever are + appropriate for the given color type + (png_color_16) + +- png_set_tRNS(png_ptr, info_ptr, trans, num_trans, +- trans_values); +- trans - array of transparent ++ png_set_tRNS(png_ptr, info_ptr, trans_alpha, ++ num_trans, trans_color); ++ ++ trans_alpha - array of alpha (transparency) + entries for palette (PNG_INFO_tRNS) +- trans_values - graylevel or color sample values ++ ++ num_trans - number of transparent entries ++ (PNG_INFO_tRNS) ++ ++ trans_color - graylevel or color sample values + (in order red, green, blue) of the + single transparent color for + non-paletted images (PNG_INFO_tRNS) +- num_trans - number of transparent entries +- (PNG_INFO_tRNS) ++ ++ png_set_eXIf_1(png_ptr, info_ptr, num_exif, exif); ++ ++ exif - Exif profile (array of ++ png_byte) (PNG_INFO_eXIf) + + png_set_hIST(png_ptr, info_ptr, hist); +- (PNG_INFO_hIST) ++ + hist - histogram of palette (array of +- png_uint_16) ++ png_uint_16) (PNG_INFO_hIST) + + png_set_tIME(png_ptr, info_ptr, mod_time); ++ + mod_time - time image was last modified + (PNG_VALID_tIME) + + png_set_bKGD(png_ptr, info_ptr, background); +- background - background color (PNG_VALID_bKGD) ++ ++ background - background color (of type ++ png_color_16p) (PNG_VALID_bKGD) + + png_set_text(png_ptr, info_ptr, text_ptr, num_text); ++ + text_ptr - array of png_text holding image + comments ++ + text_ptr[i].compression - type of compression used + on "text" PNG_TEXT_COMPRESSION_NONE + PNG_TEXT_COMPRESSION_zTXt +@@ -2792,14 +3675,21 @@ width, height, bit_depth, and color_type must be the same in each call. + empty for unknown). + text_ptr[i].translated_keyword - keyword in UTF-8 (NULL + or empty for unknown). ++ + Note that the itxt_length, lang, and lang_key +- members of the text_ptr structure only exist +- when the library is built with iTXt chunk support. ++ members of the text_ptr 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, ++ they contain NULL pointers when the "compression" ++ field contains PNG_TEXT_COMPRESSION_NONE or ++ PNG_TEXT_COMPRESSION_zTXt. + + num_text - number of comments + + png_set_sPLT(png_ptr, info_ptr, &palette_ptr, + num_spalettes); ++ + palette_ptr - array of png_sPLT_struct structures + to be added to the list of palettes + in the info structure. +@@ -2808,35 +3698,49 @@ width, height, bit_depth, and color_type must be the same in each call. + + png_set_oFFs(png_ptr, info_ptr, offset_x, offset_y, + unit_type); ++ + offset_x - positive offset from the left + edge of the screen ++ + offset_y - positive offset from the top + edge of the screen ++ + unit_type - PNG_OFFSET_PIXEL, PNG_OFFSET_MICROMETER + + png_set_pHYs(png_ptr, info_ptr, res_x, res_y, + unit_type); ++ + res_x - pixels/unit physical resolution + in x direction ++ + res_y - pixels/unit physical resolution + in y direction ++ + unit_type - PNG_RESOLUTION_UNKNOWN, + PNG_RESOLUTION_METER + + png_set_sCAL(png_ptr, info_ptr, unit, width, height) ++ + unit - physical scale units (an integer) ++ + width - width of a pixel in physical scale units ++ + height - height of a pixel in physical scale units + (width and height are doubles) + + png_set_sCAL_s(png_ptr, info_ptr, unit, width, height) ++ + unit - physical scale units (an integer) ++ + width - width of a pixel in physical scale units ++ expressed as a string ++ + height - height of a pixel in physical scale units + (width and height are strings like "2.54") + + png_set_unknown_chunks(png_ptr, info_ptr, &unknowns, + num_unknowns) ++ + unknowns - array of png_unknown_chunk + structures holding unknown chunks + unknowns[i].name - name of unknown chunk +@@ -2871,25 +3775,34 @@ Because tEXt and zTXt chunks don't have a language field, if you + specify PNG_TEXT_COMPRESSION_NONE or PNG_TEXT_COMPRESSION_zTXt + any language code or translated keyword will not be written out. + +-Until text gets around 1000 bytes, it is not worth compressing it. ++Until text gets around a few hundred bytes, it is not worth compressing it. + After the text has been written out to the file, the compression type + is set to PNG_TEXT_COMPRESSION_NONE_WR or PNG_TEXT_COMPRESSION_zTXt_WR, + so that it isn't written out again at the end (in case you are calling +-png_write_end() with the same struct. ++png_write_end() with the same struct). + + The keywords that are given in the PNG Specification are: + + Title Short (one line) title or + caption for image ++ + Author Name of image's creator ++ + Description Description of image (possibly long) ++ + Copyright Copyright notice ++ + Creation Time Time of original image creation + (usually RFC 1123 format, see below) ++ + Software Software used to create the image ++ + Disclaimer Legal disclaimer ++ + Warning Warning of nature of content ++ + Source Device used to create the image ++ + Comment Miscellaneous comment; conversion + from other image format + +@@ -2933,18 +3846,53 @@ tEXt chunk use RFC 1123 format dates (e.g. "22 May 1997 18:07:10 GMT"), + although this isn't a requirement. Unlike the tIME chunk, the + "Creation Time" tEXt chunk is not expected to be automatically changed + by the software. To facilitate the use of RFC 1123 dates, a function +-png_convert_to_rfc1123(png_timep) is provided to convert from PNG +-time to an RFC 1123 format string. ++png_convert_to_rfc1123_buffer(buffer, png_timep) is provided to ++convert from PNG time to an RFC 1123 format string. The caller must provide ++a writeable buffer of at least 29 bytes. + + .SS Writing unknown chunks + +-You can use the png_set_unknown_chunks function to queue up chunks +-for writing. You give it a chunk name, raw data, and a size; that's +-all there is to it. The chunks will be written by the next following +-png_write_info_before_PLTE, png_write_info, or png_write_end function. +-Any chunks previously read into the info structure's unknown-chunk +-list will also be written out in a sequence that satisfies the PNG +-specification's ordering rules. ++You can use the png_set_unknown_chunks function to queue up private chunks ++for writing. You give it a chunk name, location, raw data, and a size. You ++also must use png_set_keep_unknown_chunks() to ensure that libpng will ++handle them. That's all there is to it. The chunks will be written by the ++next following png_write_info_before_PLTE, png_write_info, or png_write_end ++function, depending upon the specified location. Any chunks previously ++read into the info structure's unknown-chunk list will also be written out ++in a sequence that satisfies the PNG specification's ordering rules. ++ ++Here is an example of writing two private chunks, prVt and miNE: ++ ++ #ifdef PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED ++ /* Set unknown chunk data */ ++ png_unknown_chunk unk_chunk[2]; ++ strcpy((char *) unk_chunk[0].name, "prVt"; ++ unk_chunk[0].data = (unsigned char *) "PRIVATE DATA"; ++ unk_chunk[0].size = strlen(unk_chunk[0].data)+1; ++ unk_chunk[0].location = PNG_HAVE_IHDR; ++ strcpy((char *) unk_chunk[1].name, "miNE"; ++ unk_chunk[1].data = (unsigned char *) "MY CHUNK DATA"; ++ unk_chunk[1].size = strlen(unk_chunk[0].data)+1; ++ unk_chunk[1].location = PNG_AFTER_IDAT; ++ png_set_unknown_chunks(write_ptr, write_info_ptr, ++ unk_chunk, 2); ++ /* Needed because miNE is not safe-to-copy */ ++ png_set_keep_unknown_chunks(png, PNG_HANDLE_CHUNK_ALWAYS, ++ (png_bytep) "miNE", 1); ++ # if PNG_LIBPNG_VER < 10600 ++ /* Deal with unknown chunk location bug in 1.5.x and earlier */ ++ png_set_unknown_chunk_location(png, info, 0, PNG_HAVE_IHDR); ++ png_set_unknown_chunk_location(png, info, 1, PNG_AFTER_IDAT); ++ # endif ++ # if PNG_LIBPNG_VER < 10500 ++ /* PNG_AFTER_IDAT writes two copies of the chunk prior to libpng-1.5.0, ++ * one before IDAT and another after IDAT, so don't use it; only use ++ * PNG_HAVE_IHDR location. This call resets the location previously ++ * set by assignment and png_set_unknown_chunk_location() for chunk 1. ++ */ ++ png_set_unknown_chunk_location(png, info, 1, PNG_HAVE_IHDR); ++ # endif ++ #endif + + .SS The high-level write interface + +@@ -3059,17 +4007,19 @@ file so that decoders can recover the original data if desired. + /* Set the true bit depth of the image data */ + if (color_type & PNG_COLOR_MASK_COLOR) + { +- sig_bit.red = true_bit_depth; +- sig_bit.green = true_bit_depth; +- sig_bit.blue = true_bit_depth; ++ sig_bit.red = true_bit_depth; ++ sig_bit.green = true_bit_depth; ++ sig_bit.blue = true_bit_depth; + } ++ + else + { +- sig_bit.gray = true_bit_depth; ++ sig_bit.gray = true_bit_depth; + } ++ + if (color_type & PNG_COLOR_MASK_ALPHA) + { +- sig_bit.alpha = true_bit_depth; ++ sig_bit.alpha = true_bit_depth; + } + + png_set_sBIT(png_ptr, info_ptr, &sig_bit); +@@ -3081,7 +4031,7 @@ is required by PNG. + + png_set_shift(png_ptr, &sig_bit); + +-PNG files store 16 bit pixels in network byte order (big-endian, ++PNG files store 16-bit pixels in network byte order (big-endian, + ie. most significant bits first). This code would be used if they are + supplied the other way (little-endian, i.e. least significant bits + first, the way PCs store them): +@@ -3115,11 +4065,24 @@ with + + You must supply the function + +- void write_transform_fn(png_ptr ptr, row_info_ptr ++ void write_transform_fn(png_structp png_ptr, png_row_infop + row_info, png_bytep data) + + See pngtest.c for a working example. Your function will be called +-before any of the other transformations are processed. ++before any of the other transformations are processed. If supported ++libpng also supplies an information routine that may be called from ++your callback: ++ ++ png_get_current_row_number(png_ptr); ++ png_get_current_pass_number(png_ptr); ++ ++This returns the current row passed to the transform. With interlaced ++images the value returned is the row in the input sub-image image. Use ++PNG_ROW_FROM_PASS_ROW(row, pass) and PNG_COL_FROM_PASS_COL(col, pass) to ++find the output pixel (x,y) given an interlaced sub-image pixel (row,col,pass). ++ ++The discussion of interlace handling above contains more information on how to ++use these values. + + You can also set up a pointer to a user structure for use by your + callback function. +@@ -3201,25 +4164,39 @@ for details of which pixels to write when. + + If you don't want libpng to handle the interlacing details, just + use png_set_interlace_handling() and call png_write_rows() the +-correct number of times to write all seven sub-images. ++correct number of times to write all the sub-images ++(png_set_interlace_handling() returns the number of sub-images.) + + If you want libpng to build the sub-images, call this before you start + writing any rows: + +- number_of_passes = +- png_set_interlace_handling(png_ptr); ++ number_of_passes = png_set_interlace_handling(png_ptr); + + This will return the number of passes needed. Currently, this is seven, + but may change if another interlace type is added. + + Then write the complete image number_of_passes times. + +- png_write_rows(png_ptr, row_pointers, +- number_of_rows); ++ png_write_rows(png_ptr, row_pointers, number_of_rows); ++ ++Think carefully before you write an interlaced image. Typically code that ++reads such images reads all the image data into memory, uncompressed, before ++doing any processing. Only code that can display an image on the fly can ++take advantage of the interlacing and even then the image has to be exactly ++the correct size for the output device, because scaling an image requires ++adjacent pixels and these are not available until all the passes have been ++read. + +-As some of these rows are not used, and thus return immediately, you may +-want to read about interlacing in the PNG specification, and only update +-the rows that are actually used. ++If you do write an interlaced image you will hardly ever need to handle ++the interlacing yourself. Call png_set_interlace_handling() and use the ++approach described above. ++ ++The only time it is conceivable that you will really need to write an ++interlaced image pass-by-pass is when you have read one pass by pass and ++made some pixel-by-pixel transformation to it, as described in the read ++code above. In this case use the PNG_PASS_ROWS and PNG_PASS_COLS macros ++to determine the size of each sub-image in turn and simply write the rows ++you obtained from the read code. + + .SS Finishing a sequential write + +@@ -3238,6 +4215,7 @@ It is also possible to individually free the info_ptr members that + point to libpng-allocated storage with the following function: + + png_free_data(png_ptr, info_ptr, mask, seq) ++ + mask - identifies data to be freed, a mask + containing the bitwise OR of one or + more of +@@ -3247,14 +4225,15 @@ point to libpng-allocated storage with the following function: + PNG_FREE_SCAL, PNG_FREE_SPLT, + PNG_FREE_TEXT, PNG_FREE_UNKN, + or simply PNG_FREE_ALL ++ + seq - sequence number of item to be freed +- (-1 for all items) ++ (\-1 for all items) + + This function may be safely called when the relevant storage has + already been freed, or has not yet been allocated, or was allocated + by the user and not by libpng, and will in those cases do nothing. + The "seq" parameter is ignored if only one item of the selected data +-type, such as PLTE, is allowed. If "seq" is not -1, and multiple items ++type, such as PLTE, is allowed. If "seq" is not \-1, and multiple items + are allowed for the data type identified in the mask, such as text or + sPLT, only the n'th item in the structure is freed, where n is "seq". + +@@ -3265,22 +4244,25 @@ png_destroy_write_struct(). + The default behavior is only to free data that was allocated internally + by libpng. This can be changed, so that libpng will not free the data, + or so that it will free data that was allocated by the user with png_malloc() +-or png_zalloc() and passed in via a png_set_*() function, with ++or png_calloc() and passed in via a png_set_*() function, with + + png_data_freer(png_ptr, info_ptr, freer, mask) +- mask - which data elements are affected +- same choices as in png_free_data() ++ + freer - one of + PNG_DESTROY_WILL_FREE_DATA + PNG_SET_WILL_FREE_DATA + PNG_USER_WILL_FREE_DATA + ++ mask - which data elements are affected ++ same choices as in png_free_data() ++ + For example, to transfer responsibility for some data from a read structure + to a write structure, you could use + + png_data_freer(read_ptr, read_info_ptr, + PNG_USER_WILL_FREE_DATA, + PNG_FREE_PLTE|PNG_FREE_tRNS|PNG_FREE_hIST) ++ + png_data_freer(write_ptr, write_info_ptr, + PNG_DESTROY_WILL_FREE_DATA, + PNG_FREE_PLTE|PNG_FREE_tRNS|PNG_FREE_hIST) +@@ -3298,7 +4280,7 @@ When the user assumes responsibility for libpng-allocated data, the + application must use + png_free() to free it, and when the user transfers responsibility to libpng + for data that the user has allocated, the user must have used png_malloc() +-or png_zalloc() to allocate it. ++or png_calloc() to allocate it. + + If you allocated text_ptr.text, text_ptr.lang, and text_ptr.translated_keyword + separately, do not transfer responsibility for freeing text_ptr to libpng, +@@ -3308,7 +4290,424 @@ if you transfer responsibility for free'ing text_ptr from libpng to your + application, your application must not separately free those members. + For a more compact example of writing a PNG image, see the file example.c. + +-.SH V. Modifying/Customizing libpng: ++.SH V. Simplified API ++ ++The simplified API, which became available in libpng-1.6.0, 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 accommodate 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, set the ++ version field to PNG_IMAGE_VERSION and the 'opaque' pointer to NULL ++ (this is REQUIRED, your program may crash if you don't do it.) ++ ++ 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. The "png_image" structure contains the following members: ++ ++ 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 ++ png_uint_32 warning_or_error; ++ char message[64]; ++ ++In the event of an error or warning the "warning_or_error" ++field will be set to a non-zero value and the 'message' field will contain ++a '\0' terminated string with the libpng error or warning message. If both ++warnings and an error were encountered, only the error is recorded. If there ++are multiple warnings, only the first one is recorded. ++ ++The upper 30 bits of the "warning_or_error" value are reserved; the low two ++bits contain 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 ++ ++The pixels (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 channels 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, in ++the native byte order of the platform on which the application is running. ++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 https://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_* ++ ++The #defines to be used in png_image::format. Each #define identifies a ++particular layout of channel 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 ++ ++ PNG_FORMAT_FLAG_ALPHA format with an alpha channel ++ PNG_FORMAT_FLAG_COLOR color format: otherwise grayscale ++ PNG_FORMAT_FLAG_LINEAR 2-byte channels else 1-byte ++ PNG_FORMAT_FLAG_COLORMAP image data is color-mapped ++ PNG_FORMAT_FLAG_BGR BGR colors, else order is RGB ++ PNG_FORMAT_FLAG_AFIRST alpha channel comes first ++ ++Supported formats are as follows. Future versions of libpng may support more ++formats; for compatibility with older versions simply check if the format ++macro is defined using #ifdef. These defines describe the in-memory layout ++of the components of the pixels of the image. ++ ++First the single byte (sRGB) formats: ++ ++ PNG_FORMAT_GRAY ++ PNG_FORMAT_GA ++ PNG_FORMAT_AG ++ PNG_FORMAT_RGB ++ PNG_FORMAT_BGR ++ PNG_FORMAT_RGBA ++ PNG_FORMAT_ARGB ++ PNG_FORMAT_BGRA ++ PNG_FORMAT_ABGR ++ ++Then the linear 2-byte formats. When naming these "Y" is used to ++indicate a luminance (gray) channel. The component order within the pixel ++is always the same - there is no provision for swapping the order of the ++components in the linear format. The components are 16-bit integers in ++the native byte order for your platform, and there is no provision for ++swapping the bytes to a different endian condition. ++ ++ PNG_FORMAT_LINEAR_Y ++ PNG_FORMAT_LINEAR_Y_ALPHA ++ PNG_FORMAT_LINEAR_RGB ++ PNG_FORMAT_LINEAR_RGB_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. ++ ++ PNG_FORMAT_RGB_COLORMAP ++ PNG_FORMAT_BGR_COLORMAP ++ PNG_FORMAT_RGBA_COLORMAP ++ PNG_FORMAT_ARGB_COLORMAP ++ PNG_FORMAT_BGRA_COLORMAP ++ PNG_FORMAT_ABGR_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. ++ ++ PNG_IMAGE_SAMPLE_CHANNELS(fmt) ++ Returns the total number of channels in a given format: 1..4 ++ ++ PNG_IMAGE_SAMPLE_COMPONENT_SIZE(fmt) ++ Returns the size in bytes of a single component of a pixel or color-map ++ entry (as appropriate) in the image: 1 or 2. ++ ++ PNG_IMAGE_SAMPLE_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. ++ ++ PNG_IMAGE_MAXIMUM_COLORMAP_COMPONENTS(fmt) ++ 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. ++ ++ PNG_IMAGE_COLORMAP_SIZE(fmt) ++ The size of the color-map required by the format; this is the size of the ++ color-map buffer passed to the png_image_{read,write}_colormap APIs. It is ++ a fixed number determined by the format so can easily be allocated on the ++ stack if necessary. ++ ++Corresponding information about the pixels ++ ++ PNG_IMAGE_PIXEL_CHANNELS(fmt) ++ The number of separate channels (components) in a pixel; 1 for a ++ color-mapped image. ++ ++ PNG_IMAGE_PIXEL_COMPONENT_SIZE(fmt)\ ++ The size, in bytes, of each component in a pixel; 1 for a color-mapped ++ image. ++ ++ PNG_IMAGE_PIXEL_SIZE(fmt) ++ The size, in bytes, of a complete pixel; 1 for a color-mapped image. ++ ++Information about the whole row, or whole image ++ ++ PNG_IMAGE_ROW_STRIDE(image) ++ Returns 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. ++ ++ If you need the stride measured in bytes, row_stride_bytes is ++ PNG_IMAGE_ROW_STRIDE(image) * PNG_IMAGE_PIXEL_COMPONENT_SIZE(fmt) ++ plus any padding bytes that your application might need, for example ++ to start the next row on a 4-byte boundary. ++ ++ PNG_IMAGE_BUFFER_SIZE(image, 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. ++ ++ PNG_IMAGE_SIZE(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. ++ ++ PNG_IMAGE_COLORMAP_SIZE(image) ++ 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. ++ ++ PNG_IMAGE_FLAG_COLORSPACE_NOT_sRGB == 0x01 ++ This indicates that the RGB values of the in-memory bitmap do not ++ correspond to the red, green and blue end-points defined by sRGB. ++ ++ 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. ++ ++ 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. ++ ++READ APIs ++ ++ The png_image passed to the read APIs must have been initialized by setting ++ the png_controlp field 'opaque' to NULL (or, better, memset the whole thing.) ++ ++ 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. ++ ++ int png_image_begin_read_from_stdio (png_imagep image, ++ FILE* file) ++ ++ The PNG header is read from the stdio FILE object. ++ ++ int png_image_begin_read_from_memory(png_imagep image, ++ png_const_voidp memory, size_t size) ++ ++ The PNG header is read from the given memory buffer. ++ ++ int png_image_finish_read(png_imagep image, ++ png_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 png_byte or png_uint_16 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. ++ ++ For linear output removing the alpha channel is always done ++ by compositing on black. ++ ++ 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. ++ ++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 https://en.wikipedia.org/wiki/SRGB) is used, not the gamma=1/2.2 ++approximation used elsewhere in libpng. ++ ++WRITE APIS ++ ++For write you must initialize a png_image structure to describe the image to ++be written: ++ ++ 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 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) ++ ++ 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. ++ ++ int png_image_write_to_memory (png_imagep image, void *memory, ++ png_alloc_size_t * PNG_RESTRICT memory_bytes, ++ int convert_to_8_bit, const void *buffer, ptrdiff_t row_stride, ++ const void *colormap)); ++ ++ Write the image to memory. ++ ++ 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 all write APIs if image is in one of the linear formats with ++(png_uint_16) data then setting convert_to_8_bit will cause the output to be ++a (png_byte) PNG gamma encoded according to the sRGB specification, otherwise ++a 16-bit linear encoded PNG file is written. ++ ++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 (float) and if negative ++indicates a bottom-up row layout in the buffer. If you pass zero, libpng will ++calculate the row_stride for you from the width and number of channels. ++ ++Note that the write API does not support interlacing, sub-8-bit pixels, ++indexed (paletted) images, or most ancillary chunks. ++ ++.SH VI. Modifying/Customizing libpng + + There are two issues here. The first is changing how libpng does + standard things like memory allocation, input/output, and error handling. +@@ -3326,24 +4725,25 @@ in pngmem.c, pngrio.c, pngwio.c, and pngerror.c, respectively. To change + these functions, call the appropriate png_set_*_fn() function. + + Memory allocation is done through the functions png_malloc(), png_calloc(), +-and png_free(). These currently just call the standard C functions. +-png_calloc() calls png_malloc() and then png_memset() to clear the newly +-allocated memory to zero. If your pointers can't access more then 64K +-at a time, you will want to set MAXSEG_64K in zlib.h. Since it is +-unlikely that the method of handling memory allocation on a platform +-will change between applications, these functions must be modified in +-the library at compile time. If you prefer to use a different method +-of allocating and freeing data, you can use png_create_read_struct_2() or +-png_create_write_struct_2() to register your own functions as described +-above. These functions also provide a void pointer that can be retrieved +-via ++and png_free(). The png_malloc() and png_free() functions currently just ++call the standard C functions and png_calloc() calls png_malloc() and then ++clears the newly allocated memory to zero; note that png_calloc(png_ptr, size) ++is not the same as the calloc(number, size) function provided by stdlib.h. ++There is limited support for certain systems with segmented memory ++architectures and the types of pointers declared by png.h match this; you ++will have to use appropriate pointers in your application. If you prefer ++to use a different method of allocating and freeing data, you can use ++png_create_read_struct_2() or png_create_write_struct_2() to register your ++own functions as described above. These functions also provide a void ++pointer that can be retrieved via + + mem_ptr=png_get_mem_ptr(png_ptr); + + Your replacement memory functions must have prototypes as follows: + + png_voidp malloc_fn(png_structp png_ptr, +- png_size_t size); ++ png_alloc_size_t size); ++ + void free_fn(png_structp png_ptr, png_voidp ptr); + + Your malloc_fn() must return NULL in case of failure. The png_malloc() +@@ -3375,9 +4775,11 @@ png_get_io_ptr(). For example: + The replacement I/O functions must have prototypes as follows: + + void user_read_data(png_structp png_ptr, +- png_bytep data, png_size_t length); ++ png_bytep data, size_t length); ++ + void user_write_data(png_structp png_ptr, +- png_bytep data, png_size_t length); ++ png_bytep data, size_t length); ++ + void user_flush_data(png_structp png_ptr); + + The user_read_data() function is responsible for detecting and +@@ -3394,8 +4796,9 @@ Error handling in libpng is done through png_error() and png_warning(). + Errors handled through png_error() are fatal, meaning that png_error() + should never return to its caller. Currently, this is handled via + setjmp() and longjmp() (unless you have compiled libpng with +-PNG_SETJMP_NOT_SUPPORTED, in which case it is handled via PNG_ABORT()), +-but you could change this to do things like exit() if you should wish. ++PNG_NO_SETJMP, in which case it is handled via PNG_ABORT()), ++but you could change this to do things like exit() if you should wish, ++as long as your function does not return. + + On non-fatal errors, png_warning() is called + to print a warning message, and then control returns to the calling code. +@@ -3412,8 +4815,6 @@ functions after png_create_*_struct() has been called by calling: + png_voidp error_ptr, png_error_ptr error_fn, + png_error_ptr warning_fn); + +- png_voidp error_ptr = png_get_error_ptr(png_ptr); +- + If NULL is supplied for either error_fn or warning_fn, then the libpng + default function will be used, calling fprintf() and/or longjmp() if a + problem is encountered. The replacement error functions should have +@@ -3421,9 +4822,15 @@ parameters as follows: + + void user_error_fn(png_structp png_ptr, + png_const_charp error_msg); ++ + void user_warning_fn(png_structp png_ptr, + png_const_charp warning_msg); + ++Then, within your user_error_fn or user_warning_fn, you can retrieve ++the error_ptr if you need it, by calling ++ ++ png_voidp error_ptr = png_get_error_ptr(png_ptr); ++ + The motivation behind using setjmp() and longjmp() is the C++ throw and + catch exception handling methods. This makes the code much easier to write, + as there is no need to check every return code of every function call. +@@ -3431,7 +4838,20 @@ However, there are some uncertainties about the status of local variables + after a longjmp, so the user may want to be careful about doing anything + after setjmp returns non-zero besides returning itself. Consult your + compiler documentation for more details. For an alternative approach, you +-may wish to use the "cexcept" facility (see http://cexcept.sourceforge.net). ++may wish to use the "cexcept" facility (see https://cexcept.sourceforge.io/), ++which is illustrated in pngvalid.c and in contrib/visupng. ++ ++Beginning in libpng-1.4.0, the png_set_benign_errors() API became available. ++You can use this to handle certain errors (normally handled as errors) ++as warnings. ++ ++ png_set_benign_errors (png_ptr, int allowed); ++ ++ allowed: 0: treat png_benign_error() as an error. ++ 1: treat png_benign_error() as a warning. ++ ++As of libpng-1.6.0, the default condition is to treat benign errors as ++warnings while reading and as errors while writing. + + .SS Custom chunks + +@@ -3449,8 +4869,11 @@ and look at how other chunks were designed, so you can do things + similarly. Second, check out the sections of libpng that read and + write chunks. Try to find a chunk that is similar to yours and use + it as a template. More details can be found in the comments inside +-the code. It is best to handle unknown chunks in a generic method, +-via callback functions, instead of by modifying libpng functions. ++the code. It is best to handle private or unknown chunks in a generic method, ++via callback functions, instead of by modifying libpng functions. This ++is illustrated in pngtest.c, which uses a callback function to handle a ++private "vpAg" chunk and the new "sTER" chunk, which are both unknown to ++libpng. + + If you wish to write your own transformation for the data, look through + the part of the code that does the transformations, and check out some of +@@ -3458,29 +4881,6 @@ the simpler ones to get an idea of how they work. Try to find a similar + transformation to the one you want to add and copy off of it. More details + can be found in the comments inside the code itself. + +-.SS Configuring for 16 bit platforms +- +-You will want to look into zconf.h to tell zlib (and thus libpng) that +-it cannot allocate more then 64K at a time. Even if you can, the memory +-won't be accessible. So limit zlib and libpng to 64K by defining MAXSEG_64K. +- +-.SS Configuring for DOS +- +-For DOS users who only have access to the lower 640K, you will +-have to limit zlib's memory usage via a png_set_compression_mem_level() +-call. See zlib.h or zconf.h in the zlib library for more information. +- +-.SS Configuring for Medium Model +- +-Libpng's support for medium model has been tested on most of the popular +-compilers. Make sure MAXSEG_64K gets defined, USE_FAR_KEYWORD gets +-defined, and FAR gets defined to far in pngconf.h, and you should be +-all set. Everything in the library (except for zlib's structure) is +-expecting far data. You must use the typedefs with the p or pp on +-the end for pointers (or at least look at them and be careful). Make +-note that the rows of data are defined as png_bytepp, which is an +-unsigned char far * far *. +- + .SS Configuring for gui/windowing platforms: + + You will need to write new error and warning functions that use the GUI +@@ -3490,15 +4890,6 @@ in order to have them available during the structure initialization. + They can be changed later via png_set_error_fn(). On some compilers, + you may also have to change the memory allocators (png_malloc, etc.). + +-.SS Configuring for compiler xxx: +- +-All includes for libpng are in pngconf.h. If you need to add, change +-or delete an include, this is the place to do it. +-The includes that are not needed outside libpng are protected by the +-PNG_INTERNAL definition, which is only defined for those routines inside +-libpng itself. The files in libpng proper only include png.h, which +-includes pngconf.h. +- + .SS Configuring zlib: + + There are special functions to configure the compression. Perhaps the +@@ -3513,6 +4904,7 @@ specify no compression (Z_NO_COMPRESSION = 0), but this would create + files larger than just storing the raw bitmap. You can specify the + compression level by calling: + ++ #include zlib.h + png_set_compression_level(png_ptr, level); + + Another useful one is to reduce the memory level used by the library. +@@ -3523,19 +4915,45 @@ other things, lower levels will result in sections of incompressible + data being emitted in smaller stored blocks, with a correspondingly + larger relative overhead of up to 15% in the worst case. + ++ #include zlib.h + png_set_compression_mem_level(png_ptr, level); + + The other functions are for configuring zlib. They are not recommended + for normal use and may result in writing an invalid PNG file. See + zlib.h for more information on what these mean. + ++ #include zlib.h + png_set_compression_strategy(png_ptr, + strategy); ++ + png_set_compression_window_bits(png_ptr, + window_bits); ++ + png_set_compression_method(png_ptr, method); ++ ++This controls the size of the IDAT chunks (default 8192): ++ + png_set_compression_buffer_size(png_ptr, size); + ++As of libpng version 1.5.4, additional APIs became ++available to set these separately for non-IDAT ++compressed chunks such as zTXt, iTXt, and iCCP: ++ ++ #include zlib.h ++ #if PNG_LIBPNG_VER >= 10504 ++ png_set_text_compression_level(png_ptr, level); ++ ++ png_set_text_compression_mem_level(png_ptr, level); ++ ++ png_set_text_compression_strategy(png_ptr, ++ strategy); ++ ++ png_set_text_compression_window_bits(png_ptr, ++ window_bits); ++ ++ png_set_text_compression_method(png_ptr, method); ++ #endif ++ + .SS Controlling row filtering + + If you want to control whether libpng uses filtering or not, which +@@ -3550,8 +4968,9 @@ for any images with bit depths less than 8 bits/pixel. + The 'method' parameter sets the main filtering method, which is + currently only '0' in the PNG 1.2 specification. The 'filters' + parameter sets which filter(s), if any, should be used for each +-scanline. Possible values are PNG_ALL_FILTERS and PNG_NO_FILTERS +-to turn filtering on and off, respectively. ++scanline. Possible values are PNG_ALL_FILTERS, PNG_NO_FILTERS, ++or PNG_FAST_FILTERS to turn filtering on and off, or to turn on ++just the fast-decoding subset of filters, respectively. + + Individual filter types are PNG_FILTER_NONE, PNG_FILTER_SUB, + PNG_FILTER_UP, PNG_FILTER_AVG, PNG_FILTER_PAETH, which can be bitwise +@@ -3565,12 +4984,19 @@ means the first row must always be adaptively filtered, because libpng + currently does not allocate the filter buffers until png_write_row() + is called for the first time.) + +- filters = PNG_FILTER_NONE | PNG_FILTER_SUB ++ filters = PNG_NO_FILTERS; ++ filters = PNG_ALL_FILTERS; ++ filters = PNG_FAST_FILTERS; ++ ++ or ++ ++ filters = PNG_FILTER_NONE | PNG_FILTER_SUB | + PNG_FILTER_UP | PNG_FILTER_AVG | +- PNG_FILTER_PAETH | PNG_ALL_FILTERS; ++ PNG_FILTER_PAETH; + + png_set_filter(png_ptr, PNG_FILTER_TYPE_BASE, + filters); ++ + The second parameter can also be + PNG_INTRAPIXEL_DIFFERENCING if you are + writing a PNG to be embedded in a MNG +@@ -3578,79 +5004,6 @@ is called for the first time.) + same as the value of filter_method used + in png_set_IHDR(). + +-It is also possible to influence how libpng chooses from among the +-available filters. This is done in one or both of two ways - by +-telling it how important it is to keep the same filter for successive +-rows, and by telling it the relative computational costs of the filters. +- +- double weights[3] = {1.5, 1.3, 1.1}, +- costs[PNG_FILTER_VALUE_LAST] = +- {1.0, 1.3, 1.3, 1.5, 1.7}; +- +- png_set_filter_heuristics(png_ptr, +- PNG_FILTER_HEURISTIC_WEIGHTED, 3, +- weights, costs); +- +-The weights are multiplying factors that indicate to libpng that the +-row filter should be the same for successive rows unless another row filter +-is that many times better than the previous filter. In the above example, +-if the previous 3 filters were SUB, SUB, NONE, the SUB filter could have a +-"sum of absolute differences" 1.5 x 1.3 times higher than other filters +-and still be chosen, while the NONE filter could have a sum 1.1 times +-higher than other filters and still be chosen. Unspecified weights are +-taken to be 1.0, and the specified weights should probably be declining +-like those above in order to emphasize recent filters over older filters. +- +-The filter costs specify for each filter type a relative decoding cost +-to be considered when selecting row filters. This means that filters +-with higher costs are less likely to be chosen over filters with lower +-costs, unless their "sum of absolute differences" is that much smaller. +-The costs do not necessarily reflect the exact computational speeds of +-the various filters, since this would unduly influence the final image +-size. +- +-Note that the numbers above were invented purely for this example and +-are given only to help explain the function usage. Little testing has +-been done to find optimum values for either the costs or the weights. +- +-.SS Removing unwanted object code +- +-There are a bunch of #define's in pngconf.h that control what parts of +-libpng are compiled. All the defines end in _SUPPORTED. If you are +-never going to use a capability, you can change the #define to #undef +-before recompiling libpng and save yourself code and data space, or +-you can turn off individual capabilities with defines that begin with +-PNG_NO_. +- +-You can also turn all of the transforms and ancillary chunk capabilities +-off en masse with compiler directives that define +-PNG_NO_READ[or WRITE]_TRANSFORMS, or PNG_NO_READ[or WRITE]_ANCILLARY_CHUNKS, +-or all four, +-along with directives to turn on any of the capabilities that you do +-want. The PNG_NO_READ[or WRITE]_TRANSFORMS directives disable the extra +-transformations but still leave the library fully capable of reading +-and writing PNG files with all known public chunks. Use of the +-PNG_NO_READ[or WRITE]_ANCILLARY_CHUNKS directive produces a library +-that is incapable of reading or writing ancillary chunks. If you are +-not using the progressive reading capability, you can turn that off +-with PNG_NO_PROGRESSIVE_READ (don't confuse this with the INTERLACING +-capability, which you'll still have). +- +-All the reading and writing specific code are in separate files, so the +-linker should only grab the files it needs. However, if you want to +-make sure, or if you are building a stand alone library, all the +-reading files start with pngr and all the writing files start with +-pngw. The files that don't match either (like png.c, pngtrans.c, etc.) +-are used for both reading and writing, and always need to be included. +-The progressive reader is in pngpread.c +- +-If you are creating or distributing a dynamically linked library (a .so +-or DLL file), you should not remove or disable any parts of the library, +-as this will cause applications linked with different versions of the +-library to fail if they call functions not available in your library. +-The size of the library itself should not be an issue, because only +-those sections that are actually used will be loaded into memory. +- + .SS Requesting debug printout + + The macro definition PNG_DEBUG can be used to request debugging +@@ -3670,12 +5023,12 @@ the message, "message" is the formatted string to be printed, + and p1 and p2 are parameters that are to be embedded in the string + according to printf-style formatting directives. For example, + +- png_debug1(2, "foo=%d\n", foo); ++ png_debug1(2, "foo=%d", foo); + + is expanded to + +- if(PNG_DEBUG > 2) +- fprintf(PNG_DEBUG_FILE, "foo=%d\n", foo); ++ if (PNG_DEBUG > 2) ++ fprintf(PNG_DEBUG_FILE, "foo=%d\en", foo); + + When PNG_DEBUG is defined but is zero, the macros aren't defined, but you + can still use PNG_DEBUG to control your own debugging: +@@ -3688,7 +5041,7 @@ When PNG_DEBUG = 1, the macros are defined, but only png_debug statements + having level = 0 will be printed. There aren't any such statements in + this version of libpng, but if you insert some they will be printed. + +-.SH VI. MNG support ++.SH VII. MNG support + + The MNG specification (available at http://www.libpng.org/pub/mng) allows + certain extensions to PNG for PNG images that are embedded in MNG datastreams. +@@ -3696,11 +5049,13 @@ Libpng can support some of these extensions. To enable them, use the + png_permit_mng_features() function: + + feature_set = png_permit_mng_features(png_ptr, mask) ++ + mask is a png_uint_32 containing the bitwise OR of the + features you want to enable. These include + PNG_FLAG_MNG_EMPTY_PLTE + PNG_FLAG_MNG_FILTER_64 + PNG_ALL_MNG_FEATURES ++ + feature_set is a png_uint_32 that is the bitwise AND of + your mask with the set of MNG features that is + supported by the version of libpng that you are using. +@@ -3711,9 +5066,9 @@ in a MNG datastream. As a minimum, it must have the MNG 8-byte signature + and the MHDR and MEND chunks. Libpng does not provide support for these + or any other MNG chunks; your application must provide its own support for + them. You may wish to consider using libmng (available at +-http://www.libmng.com) instead. ++https://www.libmng.com/) instead. + +-.SH VII. Changes to Libpng from version 0.88 ++.SH VIII. Changes to Libpng from version 0.88 + + It should be noted that versions of libpng later than 0.96 are not + distributed by the original libpng author, Guy Schalnat, nor by +@@ -3725,7 +5080,7 @@ still alive and well, but they have moved on to other things. + The old libpng functions png_read_init(), png_write_init(), + png_info_init(), png_read_destroy(), and png_write_destroy() have been + moved to PNG_INTERNAL in version 0.95 to discourage their use. These +-functions will be removed from libpng version 2.0.0. ++functions will be removed from libpng version 1.4.0. + + The preferred method of creating and initializing the libpng structures is + via the png_create_read_struct(), png_create_write_struct(), and +@@ -3748,6 +5103,9 @@ png_set_error_fn(), which is essentially the same function, but with a new + name to force compilation errors with applications that try to use the old + method. + ++Support for the sCAL, iCCP, iTXt, and sPLT chunks was added at libpng-1.0.6; ++however, iTXt support was not enabled by default. ++ + Starting with version 1.0.7, you can find out which version of the library + you are using at run-time: + +@@ -3757,12 +5115,15 @@ The number libpng_vn is constructed from the major version, minor + version with leading zero, and release number with leading zero, + (e.g., libpng_vn for version 1.0.7 is 10007). + ++Note that this function does not take a png_ptr, so you can call it ++before you've created one. ++ + You can also check which version of png.h you used when compiling your + application: + + png_uint_32 application_vn = PNG_LIBPNG_VER; + +-.SH VIII. Changes to Libpng from version 1.0.x to 1.2.x ++.SH IX. Changes to Libpng from version 1.0.x to 1.2.x + + Support for user memory management was enabled by default. To + accomplish this, the functions png_create_read_struct_2(), +@@ -3859,10 +5220,538 @@ which also expands tRNS to alpha was replaced with + png_set_expand_gray_1_2_4_to_8() + which does not. It has been deprecated since libpng-1.0.18 and 1.2.9. + +-.SH IX. (Omitted) ++.SH X. Changes to Libpng from version 1.0.x/1.2.x to 1.4.x ++ ++Private libpng prototypes and macro definitions were moved from ++png.h and pngconf.h into a new pngpriv.h header file. ++ ++Functions png_set_benign_errors(), png_benign_error(), and ++png_chunk_benign_error() were added. ++ ++Support for setting the maximum amount of memory that the application ++will allocate for reading chunks was added, as a security measure. ++The functions png_set_chunk_cache_max() and png_get_chunk_cache_max() ++were added to the library. ++ ++We implemented support for I/O states by adding png_ptr member io_state ++and functions png_get_io_chunk_name() and png_get_io_state() in pngget.c ++ ++We added PNG_TRANSFORM_GRAY_TO_RGB to the available high-level ++input transforms. ++ ++Checking for and reporting of errors in the IHDR chunk is more thorough. ++ ++Support for global arrays was removed, to improve thread safety. ++ ++Some obsolete/deprecated macros and functions have been removed. ++ ++Typecasted NULL definitions such as ++ #define png_voidp_NULL (png_voidp)NULL ++were eliminated. If you used these in your application, just use ++NULL instead. ++ ++The png_struct and info_struct members "trans" and "trans_values" were ++changed to "trans_alpha" and "trans_color", respectively. ++ ++The obsolete, unused pnggccrd.c and pngvcrd.c files and related makefiles ++were removed. ++ ++The PNG_1_0_X and PNG_1_2_X macros were eliminated. ++ ++The PNG_LEGACY_SUPPORTED macro was eliminated. ++ ++Many WIN32_WCE #ifdefs were removed. ++ ++The functions png_read_init(info_ptr), png_write_init(info_ptr), ++png_info_init(info_ptr), png_read_destroy(), and png_write_destroy() ++have been removed. They have been deprecated since libpng-0.95. ++ ++The png_permit_empty_plte() was removed. It has been deprecated ++since libpng-1.0.9. Use png_permit_mng_features() instead. ++ ++We removed the obsolete stub functions png_get_mmx_flagmask(), ++png_set_mmx_thresholds(), png_get_asm_flags(), ++png_get_mmx_bitdepth_threshold(), png_get_mmx_rowbytes_threshold(), ++png_set_asm_flags(), and png_mmx_supported() + ++We removed the obsolete png_check_sig(), png_memcpy_check(), and ++png_memset_check() functions. Instead use !png_sig_cmp(), memcpy(), ++and memset(), respectively. + +-.SH X. Detecting libpng ++The function png_set_gray_1_2_4_to_8() was removed. It has been ++deprecated since libpng-1.0.18 and 1.2.9, when it was replaced with ++png_set_expand_gray_1_2_4_to_8() because the former function also ++expanded any tRNS chunk to an alpha channel. ++ ++Macros for png_get_uint_16, png_get_uint_32, and png_get_int_32 ++were added and are used by default instead of the corresponding ++functions. Unfortunately, ++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. ++ ++We changed the prototype for png_malloc() from ++ png_malloc(png_structp png_ptr, png_uint_32 size) ++to ++ png_malloc(png_structp png_ptr, png_alloc_size_t size) ++ ++This also applies to the prototype for the user replacement malloc_fn(). ++ ++The png_calloc() function was added and is used in place of ++of "png_malloc(); memset();" except in the case in png_read_png() ++where the array consists of pointers; in this case a "for" loop is used ++after the png_malloc() to set the pointers to NULL, to give robust. ++behavior in case the application runs out of memory part-way through ++the process. ++ ++We changed the prototypes of png_get_compression_buffer_size() and ++png_set_compression_buffer_size() to work with size_t instead of ++png_uint_32. ++ ++Support for numbered error messages was removed by default, since we ++never got around to actually numbering the error messages. The function ++png_set_strip_error_numbers() was removed from the library by default. ++ ++The png_zalloc() and png_zfree() functions are no longer exported. ++The png_zalloc() function no longer zeroes out the memory that it ++allocates. Applications that called png_zalloc(png_ptr, number, size) ++can call png_calloc(png_ptr, number*size) instead, and can call ++png_free() instead of png_zfree(). ++ ++Support for dithering was disabled by default in libpng-1.4.0, because ++it has not been well tested and doesn't actually "dither". ++The code was not ++removed, however, and could be enabled by building libpng with ++PNG_READ_DITHER_SUPPORTED defined. In libpng-1.4.2, this support ++was re-enabled, but the function was renamed png_set_quantize() to ++reflect more accurately what it actually does. At the same time, ++the PNG_DITHER_[RED,GREEN_BLUE]_BITS macros were also renamed to ++PNG_QUANTIZE_[RED,GREEN,BLUE]_BITS, and PNG_READ_DITHER_SUPPORTED ++was renamed to PNG_READ_QUANTIZE_SUPPORTED. ++ ++We removed the trailing '.' from the warning and error messages. ++ ++.SH XI. Changes to Libpng from version 1.4.x to 1.5.x ++ ++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. ++The incorrect macro was removed from libpng-1.4.5. ++ ++Checking for invalid palette index on write was added at libpng ++1.5.10. If a pixel contains an invalid (out-of-range) index libpng issues ++a benign error. This is enabled by default because this condition is an ++error according to the PNG specification, Clause 11.3.2, but the error can ++be ignored in each png_ptr with ++ ++ png_set_check_for_invalid_index(png_ptr, allowed); ++ ++ allowed - one of ++ 0: disable benign error (accept the ++ invalid data without warning). ++ 1: enable benign error (treat the ++ invalid data as an error or a ++ warning). ++ ++If the error is ignored, or if png_benign_error() treats it as a warning, ++any invalid pixels are decoded as opaque black by the decoder and written ++as-is by the encoder. ++ ++Retrieving the maximum palette index found was added at libpng-1.5.15. ++This statement must appear after png_read_png() or png_read_image() while ++reading, and after png_write_png() or png_write_image() while writing. ++ ++ int max_palette = png_get_palette_max(png_ptr, info_ptr); ++ ++This will return the maximum palette index found in the image, or "\-1" if ++the palette was not checked, or "0" if no palette was found. Note that this ++does not account for any palette index used by ancillary chunks such as the ++bKGD chunk; you must check those separately to determine the maximum ++palette index actually used. ++ ++There are no substantial API changes between the non-deprecated parts of ++the 1.4.5 API and the 1.5.0 API; however, the ability to directly access ++members of the main libpng control structures, png_struct and png_info, ++deprecated in earlier versions of libpng, has been completely removed from ++libpng 1.5, and new private "pngstruct.h", "pnginfo.h", and "pngdebug.h" ++header files were created. ++ ++We no longer include zlib.h in png.h. The include statement has been moved ++to pngstruct.h, where it is not accessible by applications. Applications that ++need access to information in zlib.h will need to add the '#include "zlib.h"' ++directive. It does not matter whether this is placed prior to or after ++the '"#include png.h"' directive. ++ ++The png_sprintf(), png_strcpy(), and png_strncpy() macros are no longer used ++and were removed. ++ ++We moved the png_strlen(), png_memcpy(), png_memset(), and png_memcmp() ++macros into a private header file (pngpriv.h) that is not accessible to ++applications. ++ ++In png_get_iCCP, the type of "profile" was changed from png_charpp ++to png_bytepp, and in png_set_iCCP, from png_charp to png_const_bytep. ++ ++There are changes of form in png.h, including new and changed macros to ++declare parts of the API. Some API functions with arguments that are ++pointers to data not modified within the function have been corrected to ++declare these arguments with const. ++ ++Much of the internal use of C macros to control the library build has also ++changed and some of this is visible in the exported header files, in ++particular the use of macros to control data and API elements visible ++during application compilation may require significant revision to ++application code. (It is extremely rare for an application to do this.) ++ ++Any program that compiled against libpng 1.4 and did not use deprecated ++features or access internal library structures should compile and work ++against libpng 1.5, except for the change in the prototype for ++png_get_iCCP() and png_set_iCCP() API functions mentioned above. ++ ++libpng 1.5.0 adds PNG_ PASS macros to help in the reading and writing of ++interlaced images. The macros return the number of rows and columns in ++each pass and information that can be used to de-interlace and (if ++absolutely necessary) interlace an image. ++ ++libpng 1.5.0 adds an API png_longjmp(png_ptr, value). This API calls ++the application-provided png_longjmp_ptr on the internal, but application ++initialized, longjmp buffer. It is provided as a convenience to avoid ++the need to use the png_jmpbuf macro, which had the unnecessary side ++effect of resetting the internal png_longjmp_ptr value. ++ ++libpng 1.5.0 includes a complete fixed point API. By default this is ++present along with the corresponding floating point API. In general the ++fixed point API is faster and smaller than the floating point one because ++the PNG file format used fixed point, not floating point. This applies ++even if the library uses floating point in internal calculations. A new ++macro, PNG_FLOATING_ARITHMETIC_SUPPORTED, reveals whether the library ++uses floating point arithmetic (the default) or fixed point arithmetic ++internally for performance critical calculations such as gamma correction. ++In some cases, the gamma calculations may produce slightly different ++results. This has changed the results in png_rgb_to_gray and in alpha ++composition (png_set_background for example). This applies even if the ++original image was already linear (gamma == 1.0) and, therefore, it is ++not necessary to linearize the image. This is because libpng has *not* ++been changed to optimize that case correctly, yet. ++ ++Fixed point support for the sCAL chunk comes with an important caveat; ++the sCAL specification uses a decimal encoding of floating point values ++and the accuracy of PNG fixed point values is insufficient for ++representation of these values. Consequently a "string" API ++(png_get_sCAL_s and png_set_sCAL_s) is the only reliable way of reading ++arbitrary sCAL chunks in the absence of either the floating point API or ++internal floating point calculations. Starting with libpng-1.5.0, both ++of these functions are present when PNG_sCAL_SUPPORTED is defined. Prior ++to libpng-1.5.0, their presence also depended upon PNG_FIXED_POINT_SUPPORTED ++being defined and PNG_FLOATING_POINT_SUPPORTED not being defined. ++ ++Applications no longer need to include the optional distribution header ++file pngusr.h or define the corresponding macros during application ++build in order to see the correct variant of the libpng API. From 1.5.0 ++application code can check for the corresponding _SUPPORTED macro: ++ ++#ifdef PNG_INCH_CONVERSIONS_SUPPORTED ++ /* code that uses the inch conversion APIs. */ ++#endif ++ ++This macro will only be defined if the inch conversion functions have been ++compiled into libpng. The full set of macros, and whether or not support ++has been compiled in, are available in the header file pnglibconf.h. ++This header file is specific to the libpng build. Notice that prior to ++1.5.0 the _SUPPORTED macros would always have the default definition unless ++reset by pngusr.h or by explicit settings on the compiler command line. ++These settings may produce compiler warnings or errors in 1.5.0 because ++of macro redefinition. ++ ++Applications can now choose whether to use these macros or to call the ++corresponding function by defining PNG_USE_READ_MACROS or ++PNG_NO_USE_READ_MACROS before including png.h. Notice that this is ++only supported from 1.5.0; defining PNG_NO_USE_READ_MACROS prior to 1.5.0 ++will lead to a link failure. ++ ++Prior to libpng-1.5.4, the zlib compressor used the same set of parameters ++when compressing the IDAT data and textual data such as zTXt and iCCP. ++In libpng-1.5.4 we reinitialized the zlib stream for each type of data. ++We added five png_set_text_*() functions for setting the parameters to ++use with textual data. ++ ++Prior to libpng-1.5.4, the PNG_READ_16_TO_8_ACCURATE_SCALE_SUPPORTED ++option was off by default, and slightly inaccurate scaling occurred. ++This option can no longer be turned off, and the choice of accurate ++or inaccurate 16-to-8 scaling is by using the new png_set_scale_16_to_8() ++API for accurate scaling or the old png_set_strip_16_to_8() API for simple ++chopping. In libpng-1.5.4, the PNG_READ_16_TO_8_ACCURATE_SCALE_SUPPORTED ++macro became PNG_READ_SCALE_16_TO_8_SUPPORTED, and the PNG_READ_16_TO_8 ++macro became PNG_READ_STRIP_16_TO_8_SUPPORTED, to enable the two ++png_set_*_16_to_8() functions separately. ++ ++Prior to libpng-1.5.4, the png_set_user_limits() function could only be ++used to reduce the width and height limits from the value of ++PNG_USER_WIDTH_MAX and PNG_USER_HEIGHT_MAX, although this document said ++that it could be used to override them. Now this function will reduce or ++increase the limits. ++ ++Starting in libpng-1.5.22, default user limits were established. These ++can be overridden by application calls to png_set_user_limits(), ++png_set_user_chunk_cache_max(), and/or png_set_user_malloc_max(). ++The limits are now ++ max possible default ++ png_user_width_max 0x7fffffff 1,000,000 ++ png_user_height_max 0x7fffffff 1,000,000 ++ png_user_chunk_cache_max 0 (unlimited) 1000 ++ png_user_chunk_malloc_max 0 (unlimited) 8,000,000 ++ ++The png_set_option() function (and the "options" member of the png struct) was ++added to libpng-1.5.15, with option PNG_ARM_NEON. ++ ++The library now supports a complete fixed point implementation and can ++thus be used on systems that have no floating point support or very ++limited or slow support. Previously gamma correction, an essential part ++of complete PNG support, required reasonably fast floating point. ++ ++As part of this the choice of internal implementation has been made ++independent of the choice of fixed versus floating point APIs and all the ++missing fixed point APIs have been implemented. ++ ++The exact mechanism used to control attributes of API functions has ++changed, as described in the INSTALL file. ++ ++A new test program, pngvalid, is provided in addition to pngtest. ++pngvalid validates the arithmetic accuracy of the gamma correction ++calculations and includes a number of validations of the file format. ++A subset of the full range of tests is run when "make check" is done ++(in the 'configure' build.) pngvalid also allows total allocated memory ++usage to be evaluated and performs additional memory overwrite validation. ++ ++Many changes to individual feature macros have been made. The following ++are the changes most likely to be noticed by library builders who ++configure libpng: ++ ++1) All feature macros now have consistent naming: ++ ++#define PNG_NO_feature turns the feature off ++#define PNG_feature_SUPPORTED turns the feature on ++ ++pnglibconf.h contains one line for each feature macro which is either: ++ ++#define PNG_feature_SUPPORTED ++ ++if the feature is supported or: ++ ++/*#undef PNG_feature_SUPPORTED*/ ++ ++if it is not. Library code consistently checks for the 'SUPPORTED' macro. ++It does not, and libpng applications should not, check for the 'NO' macro ++which will not normally be defined even if the feature is not supported. ++The 'NO' macros are only used internally for setting or not setting the ++corresponding 'SUPPORTED' macros. ++ ++Compatibility with the old names is provided as follows: ++ ++PNG_INCH_CONVERSIONS turns on PNG_INCH_CONVERSIONS_SUPPORTED ++ ++And the following definitions disable the corresponding feature: ++ ++PNG_SETJMP_NOT_SUPPORTED disables SETJMP ++PNG_READ_TRANSFORMS_NOT_SUPPORTED disables READ_TRANSFORMS ++PNG_NO_READ_COMPOSITED_NODIV disables READ_COMPOSITE_NODIV ++PNG_WRITE_TRANSFORMS_NOT_SUPPORTED disables WRITE_TRANSFORMS ++PNG_READ_ANCILLARY_CHUNKS_NOT_SUPPORTED disables READ_ANCILLARY_CHUNKS ++PNG_WRITE_ANCILLARY_CHUNKS_NOT_SUPPORTED disables WRITE_ANCILLARY_CHUNKS ++ ++Library builders should remove use of the above, inconsistent, names. ++ ++2) Warning and error message formatting was previously conditional on ++the STDIO feature. The library has been changed to use the ++CONSOLE_IO feature instead. This means that if CONSOLE_IO is disabled ++the library no longer uses the printf(3) functions, even though the ++default read/write implementations use (FILE) style stdio.h functions. ++ ++3) Three feature macros now control the fixed/floating point decisions: ++ ++PNG_FLOATING_POINT_SUPPORTED enables the floating point APIs ++ ++PNG_FIXED_POINT_SUPPORTED enables the fixed point APIs; however, in ++practice these are normally required internally anyway (because the PNG ++file format is fixed point), therefore in most cases PNG_NO_FIXED_POINT ++merely stops the function from being exported. ++ ++PNG_FLOATING_ARITHMETIC_SUPPORTED chooses between the internal floating ++point implementation or the fixed point one. Typically the fixed point ++implementation is larger and slower than the floating point implementation ++on a system that supports floating point; however, it may be faster on a ++system which lacks floating point hardware and therefore uses a software ++emulation. ++ ++4) Added PNG_{READ,WRITE}_INT_FUNCTIONS_SUPPORTED. This allows the ++functions to read and write ints to be disabled independently of ++PNG_USE_READ_MACROS, which allows libpng to be built with the functions ++even though the default is to use the macros - this allows applications ++to choose at app buildtime whether or not to use macros (previously ++impossible because the functions weren't in the default build.) ++ ++.SH XII. Changes to Libpng from version 1.5.x to 1.6.x ++ ++A "simplified API" has been added (see documentation in png.h and a simple ++example in contrib/examples/pngtopng.c). The new publicly visible API ++includes the following: ++ ++ macros: ++ PNG_FORMAT_* ++ PNG_IMAGE_* ++ structures: ++ png_control ++ png_image ++ read functions ++ png_image_begin_read_from_file() ++ png_image_begin_read_from_stdio() ++ png_image_begin_read_from_memory() ++ png_image_finish_read() ++ png_image_free() ++ write functions ++ png_image_write_to_file() ++ png_image_write_to_memory() ++ png_image_write_to_stdio() ++ ++Starting with libpng-1.6.0, you can configure libpng to prefix all exported ++symbols, using the PNG_PREFIX macro. ++ ++We no longer include string.h in png.h. The include statement has been moved ++to pngpriv.h, where it is not accessible by applications. Applications that ++need access to information in string.h must add an '#include ' ++directive. It does not matter whether this is placed prior to or after ++the '#include "png.h"' directive. ++ ++The following API are now DEPRECATED: ++ png_info_init_3() ++ png_convert_to_rfc1123() which has been replaced ++ with png_convert_to_rfc1123_buffer() ++ png_malloc_default() ++ png_free_default() ++ png_reset_zstream() ++ ++The following have been removed: ++ png_get_io_chunk_name(), which has been replaced ++ with png_get_io_chunk_type(). The new ++ function returns a 32-bit integer instead of ++ a string. ++ The png_sizeof(), png_strlen(), png_memcpy(), png_memcmp(), and ++ png_memset() macros are no longer used in the libpng sources and ++ have been removed. These had already been made invisible to applications ++ (i.e., defined in the private pngpriv.h header file) since libpng-1.5.0. ++ ++The signatures of many exported functions were changed, such that ++ png_structp became png_structrp or png_const_structrp ++ png_infop became png_inforp or png_const_inforp ++where "rp" indicates a "restricted pointer". ++ ++Dropped support for 16-bit platforms. The support for FAR/far types 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. ++ ++Error detection in some chunks has improved; in particular the iCCP chunk ++reader now does pretty complete validation of the basic format. Some bad ++profiles that were previously accepted are now accepted with a warning or ++rejected, depending upon the png_set_benign_errors() setting, in particular ++the very old broken Microsoft/HP 3144-byte sRGB profile. Starting with ++libpng-1.6.11, recognizing and checking sRGB profiles can be avoided by ++means of ++ ++ #if defined(PNG_SKIP_sRGB_CHECK_PROFILE) && \ ++ defined(PNG_SET_OPTION_SUPPORTED) ++ png_set_option(png_ptr, PNG_SKIP_sRGB_CHECK_PROFILE, ++ PNG_OPTION_ON); ++ #endif ++ ++It's not a good idea to do this if you are using the "simplified API", ++which needs to be able to recognize sRGB profiles conveyed via the iCCP ++chunk. ++ ++The PNG spec requirement that only grayscale profiles may appear in images ++with color type 0 or 4 and that even if the image only contains gray pixels, ++only RGB profiles may appear in images with color type 2, 3, or 6, is now ++enforced. The sRGB chunk is allowed to appear in images with any color type ++and is interpreted by libpng to convey a one-tracer-curve gray profile or a ++three-tracer-curve RGB profile as appropriate. ++ ++Libpng 1.5.x erroneously used /MD for Debug DLL builds; if you used the debug ++builds in your app and you changed your app to use /MD you will need to ++change it back to /MDd for libpng 1.6.x. ++ ++Prior to libpng-1.6.0 a warning would be issued if the iTXt chunk contained ++an empty language field or an empty translated keyword. Both of these ++are allowed by the PNG specification, so these warnings are no longer issued. ++ ++The library now issues an error if the application attempts to set a ++transform after it calls png_read_update_info() or if it attempts to call ++both png_read_update_info() and png_start_read_image() or to call either ++of them more than once. ++ ++The default condition for benign_errors is now to treat benign errors as ++warnings while reading and as errors while writing. ++ ++The library now issues a warning if both background processing and RGB to ++gray are used when gamma correction happens. As with previous versions of ++the library the results are numerically very incorrect in this case. ++ ++There are some minor arithmetic changes in some transforms such as ++png_set_background(), that might be detected by certain regression tests. ++ ++Unknown chunk handling has been improved internally, without any API change. ++This adds more correct option control of the unknown handling, corrects ++a pre-existing bug where the per-chunk 'keep' setting is ignored, and makes ++it possible to skip IDAT chunks in the sequential reader. ++ ++The machine-generated configure files are no longer included in branches ++libpng16 and later of the GIT repository. They continue to be included ++in the tarball releases, however. ++ ++Libpng-1.6.0 through 1.6.2 used the CMF bytes at the beginning of the IDAT ++stream to set the size of the sliding window for reading instead of using the ++default 32-kbyte sliding window size. It was discovered that there are ++hundreds of PNG files in the wild that have incorrect CMF bytes that caused ++zlib to issue the "invalid distance too far back" error and reject the file. ++Libpng-1.6.3 and later calculate their own safe CMF from the image dimensions, ++provide a way to revert to the libpng-1.5.x behavior (ignoring the CMF bytes ++and using a 32-kbyte sliding window), by using ++ ++ png_set_option(png_ptr, PNG_MAXIMUM_INFLATE_WINDOW, ++ PNG_OPTION_ON); ++ ++and provide a tool (contrib/tools/pngfix) for rewriting a PNG file while ++optimizing the CMF bytes in its IDAT chunk correctly. ++ ++Libpng-1.6.0 and libpng-1.6.1 wrote uncompressed iTXt chunks with the wrong ++length, which resulted in PNG files that cannot be read beyond the bad iTXt ++chunk. This error was fixed in libpng-1.6.3, and a tool (called ++contrib/tools/png-fix-itxt) has been added to the libpng distribution. ++ ++Starting with libpng-1.6.17, the PNG_SAFE_LIMITS macro was eliminated ++and safe limits are used by default (users who need larger limits ++can still override them at compile time or run time, as described above). ++ ++The new limits are ++ default spec limit ++ png_user_width_max 1,000,000 2,147,483,647 ++ png_user_height_max 1,000,000 2,147,483,647 ++ png_user_chunk_cache_max 128 unlimited ++ png_user_chunk_malloc_max 8,000,000 unlimited ++ ++Starting with libpng-1.6.18, a PNG_RELEASE_BUILD macro was added, which allows ++library builders to control compilation for an installed system (a release build). ++It can be set for testing debug or beta builds to ensure that they will compile ++when the build type is switched to RC or STABLE. In essence this overrides the ++PNG_LIBPNG_BUILD_BASE_TYPE definition which is not directly user controllable. ++ ++Starting with libpng-1.6.19, attempting to set an over-length PLTE chunk ++is an error. Previously this requirement of the PNG specification was not ++enforced, and the palette was always limited to 256 entries. An over-length ++PLTE chunk found in an input PNG is silently truncated. ++ ++Starting with libpng-1.6.31, the eXIf chunk is supported. Libpng does not ++attempt to decode the Exif profile; it simply returns a byte array ++containing the profile to the calling application which must do its own ++decoding. ++ ++.SH XIII. Detecting libpng + + The png_get_io_ptr() function has been present since libpng-0.88, has never + changed, and is unaffected by conditional compilation macros. It is the +@@ -3871,28 +5760,39 @@ libpng version since 0.88. In an autoconf "configure.in" you could use + + AC_CHECK_LIB(png, png_get_io_ptr, ... + +-.SH XI. Source code repository ++.SH XV. Source code repository + + Since about February 2009, version 1.2.34, libpng has been under "git" source + control. The git repository was built from old libpng-x.y.z.tar.gz files + going back to version 0.70. You can access the git repository (read only) + at + +- git://libpng.git.sourceforge.net/gitroot/libpng ++ https://github.com/glennrp/libpng or ++ https://git.code.sf.net/p/libpng/code.git ++ ++or you can browse it with a web browser at ++ ++ https://github.com/glennrp/libpng or ++ https://sourceforge.net/p/libpng/code/ci/libpng16/tree/ + +-or you can browse it via "gitweb" at ++Patches can be sent to png-mng-implement at lists.sourceforge.net or ++uploaded to the libpng bug tracker at + +- http://libpng.git.sourceforge.net/git/gitweb.cgi?p=libpng ++ https://libpng.sourceforge.io/ + +-Patches can be sent to glennrp at users.sourceforge.net or to +-png-mng-implement at lists.sourceforge.net or you can upload them to +-the libpng bug tracker at ++or as a "pull request" to + +- http://libpng.sourceforge.net ++ https://github.com/glennrp/libpng/pulls + +-.SH XII. Coding style ++We also accept patches built from the tar or zip distributions, and ++simple verbal descriptions of bug fixes, reported either to the ++SourceForge bug tracker, to the png-mng-implement at lists.sf.net ++mailing list, as github issues. + +-Our coding style is similar to the "Allman" style, with curly ++.SH XV. Coding style ++ ++Our coding style is similar to the "Allman" style ++(See https://en.wikipedia.org/wiki/Indent_style#Allman_style), with curly + braces on separate lines: + + if (condition) +@@ -3908,7 +5808,7 @@ braces on separate lines: + The braces can be omitted from simple one-line actions: + + if (condition) +- return (0); ++ return 0; + + We use 3-space indentation, except for continued statements which + are usually indented the same as the first line of the statement +@@ -3929,12 +5829,12 @@ the statement that follows the comment: + /* Single-line comment */ + statement; + +- /* Multiple-line +- * comment ++ /* This is a multiple-line ++ * comment. + */ + statement; + +-Very short comments can be placed at the end of the statement ++Very short comments can be placed after the end of the statement + to which they pertain: + + statement; /* comment */ +@@ -3947,7 +5847,7 @@ Functions and their curly braces are not indented, and + exported functions are marked with PNGAPI: + + /* This is a public function that is visible to +- * application programers. It does thus-and-so. ++ * application programmers. It does thus-and-so. + */ + void PNGAPI + png_exported_function(png_ptr, png_info, foo) +@@ -3955,6 +5855,9 @@ exported functions are marked with PNGAPI: + body; + } + ++The return type and decorations are placed on a separate line ++ahead of the function name, as illustrated above. ++ + The prototypes for all exported functions appear in png.h, + above the comment that says + +@@ -3969,90 +5872,60 @@ We mark all non-exported functions with "/* PRIVATE */"": + } + + The prototypes for non-exported functions (except for those in +-pngtest) appear in +-the PNG_INTERNAL section of png.h +-above the comment that says +- +- /* Maintainer: Put new private prototypes here ^ and in libpngpf.3 */ ++pngtest) appear in pngpriv.h above the comment that says + +-The names of all exported functions and variables begin +-with "png_", and all publicly visible C preprocessor +-macros begin with "PNG_". ++ /* Maintainer: Put new private prototypes here ^ */ + +-We put a space after each comma and after each semicolon +-in "for" statments, and we put spaces before and after each +-C binary operator and after "for" or "while". We don't +-put a space between a typecast and the expression being +-cast, nor do we put one between a function name and the +-left parenthesis that follows it: +- +- for (i = 2; i > 0; --i) +- y[i] = a(x) + (int)b; +- +-We prefer #ifdef and #ifndef to #if defined() and if !defined() +-when there is only one macro being tested. +- +-We do not use the TAB character for indentation in the C sources. +- +-Lines do not exceed 80 characters. +- +-Other rules can be inferred by inspecting the libpng source. +- +-.SH XIII. Y2K Compliance in libpng ++To avoid polluting the global namespace, the names of all exported ++functions and variables begin with "png_", and all publicly visible C ++preprocessor macros begin with "PNG". We request that applications that ++use libpng *not* begin any of their own symbols with either of these strings. + +-June 26, 2010 ++We put a space after the "sizeof" operator and we omit the ++optional parentheses around its argument when the argument ++is an expression, not a type name, and we always enclose the ++sizeof operator, with its argument, in parentheses: + +-Since the PNG Development group is an ad-hoc body, we can't make +-an official declaration. ++ (sizeof (png_uint_32)) ++ (sizeof array) + +-This is your unofficial assurance that libpng from version 0.71 and +-upward through 1.2.44 are Y2K compliant. It is my belief that earlier +-versions were also Y2K compliant. ++Prior to libpng-1.6.0 we used a "png_sizeof()" macro, formatted as ++though it were a function. + +-Libpng only has three year fields. One is a 2-byte unsigned integer that +-will hold years up to 65535. The other two hold the date in text +-format, and will hold years up to 9999. ++Control keywords if, for, while, and switch are always followed by a space ++to distinguish them from function calls, which have no trailing space. + +-The integer is +- "png_uint_16 year" in png_time_struct. ++We put a space after each comma and after each semicolon ++in "for" statements, and we put spaces before and after each ++C binary operator and after "for" or "while", and before ++"?". We don't put a space between a typecast and the expression ++being cast, nor do we put one between a function name and the ++left parenthesis that follows it: + +-The strings are +- "png_charp time_buffer" in png_struct and +- "near_time_buffer", which is a local character string in png.c. ++ for (i = 2; i > 0; \-\-i) ++ y[i] = a(x) + (int)b; + +-There are seven time-related functions: ++We prefer #ifdef and #ifndef to #if defined() and #if !defined() ++when there is only one macro being tested. We always use parentheses ++with "defined". + +- png_convert_to_rfc_1123() in png.c +- (formerly png_convert_to_rfc_1152() in error) +- png_convert_from_struct_tm() in pngwrite.c, called +- in pngwrite.c +- png_convert_from_time_t() in pngwrite.c +- png_get_tIME() in pngget.c +- png_handle_tIME() in pngrutil.c, called in pngread.c +- png_set_tIME() in pngset.c +- png_write_tIME() in pngwutil.c, called in pngwrite.c ++We express integer constants that are used as bit masks in hex format, ++with an even number of lower-case hex digits, and to make them unsigned ++(e.g., 0x00U, 0xffU, 0x0100U) and long if they are greater than 0x7fff ++(e.g., 0xffffUL). + +-All appear to handle dates properly in a Y2K environment. The +-png_convert_from_time_t() function calls gmtime() to convert from system +-clock time, which returns (year - 1900), which we properly convert to +-the full 4-digit year. There is a possibility that applications using +-libpng are not passing 4-digit years into the png_convert_to_rfc_1123() +-function, or that they are incorrectly passing only a 2-digit year +-instead of "year - 1900" into the png_convert_from_struct_tm() function, +-but this is not under our control. The libpng documentation has always +-stated that it works with 4-digit years, and the APIs have been +-documented as such. ++We prefer to use underscores rather than camelCase in names, except ++for a few type names that we inherit from zlib.h. + +-The tIME chunk itself is also Y2K compliant. It uses a 2-byte unsigned +-integer to hold the year, and can hold years as large as 65535. ++We prefer "if (something != 0)" and "if (something == 0)" over ++"if (something)" and if "(!something)", respectively, and for pointers ++we prefer "if (some_pointer != NULL)" or "if (some_pointer == NULL)". + +-zlib, upon which libpng depends, is also Y2K compliant. It contains +-no date-related code. ++We do not use the TAB character for indentation in the C sources. + ++Lines do not exceed 80 characters. + +- Glenn Randers-Pehrson +- libpng maintainer +- PNG Development Group ++Other rules can be inferred by inspecting the libpng source. + + .SH NOTE + +@@ -4064,266 +5937,69 @@ on the library has not always been consistent and straightforward. + The following table summarizes matters since version 0.89c, which was + the first widely used release: + +- source png.h png.h shared-lib +- version string int version +- ------- ------ ----- ---------- +- 0.89c ("beta 3") 0.89 89 1.0.89 +- 0.90 ("beta 4") 0.90 90 0.90 +- 0.95 ("beta 5") 0.95 95 0.95 +- 0.96 ("beta 6") 0.96 96 0.96 +- 0.97b ("beta 7") 1.00.97 97 1.0.1 +- 0.97c 0.97 97 2.0.97 +- 0.98 0.98 98 2.0.98 +- 0.99 0.99 98 2.0.99 +- 0.99a-m 0.99 99 2.0.99 +- 1.00 1.00 100 2.1.0 +- 1.0.0 1.0.0 100 2.1.0 +- 1.0.0 (from here on, the 100 2.1.0 +- 1.0.1 png.h string is 10001 2.1.0 +- 1.0.1a-e identical to the 10002 from here on, the +- 1.0.2 source version) 10002 shared library is 2.V +- 1.0.2a-b 10003 where V is the source +- 1.0.1 10001 code version except as +- 1.0.1a-e 10002 2.1.0.1a-e noted. +- 1.0.2 10002 2.1.0.2 +- 1.0.2a-b 10003 2.1.0.2a-b +- 1.0.3 10003 2.1.0.3 +- 1.0.3a-d 10004 2.1.0.3a-d +- 1.0.4 10004 2.1.0.4 +- 1.0.4a-f 10005 2.1.0.4a-f +- 1.0.5 (+ 2 patches) 10005 2.1.0.5 +- 1.0.5a-d 10006 2.1.0.5a-d +- 1.0.5e-r 10100 2.1.0.5e-r +- 1.0.5s-v 10006 2.1.0.5s-v +- 1.0.6 (+ 3 patches) 10006 2.1.0.6 +- 1.0.6d-g 10007 2.1.0.6d-g +- 1.0.6h 10007 10.6h +- 1.0.6i 10007 10.6i +- 1.0.6j 10007 2.1.0.6j +- 1.0.7beta11-14 DLLNUM 10007 2.1.0.7beta11-14 +- 1.0.7beta15-18 1 10007 2.1.0.7beta15-18 +- 1.0.7rc1-2 1 10007 2.1.0.7rc1-2 +- 1.0.7 1 10007 2.1.0.7 +- 1.0.8beta1-4 1 10008 2.1.0.8beta1-4 +- 1.0.8rc1 1 10008 2.1.0.8rc1 +- 1.0.8 1 10008 2.1.0.8 +- 1.0.9beta1-6 1 10009 2.1.0.9beta1-6 +- 1.0.9rc1 1 10009 2.1.0.9rc1 +- 1.0.9beta7-10 1 10009 2.1.0.9beta7-10 +- 1.0.9rc2 1 10009 2.1.0.9rc2 +- 1.0.9 1 10009 2.1.0.9 +- 1.0.10beta1 1 10010 2.1.0.10beta1 +- 1.0.10rc1 1 10010 2.1.0.10rc1 +- 1.0.10 1 10010 2.1.0.10 +- 1.0.11beta1-3 1 10011 2.1.0.11beta1-3 +- 1.0.11rc1 1 10011 2.1.0.11rc1 +- 1.0.11 1 10011 2.1.0.11 +- 1.0.12beta1-2 2 10012 2.1.0.12beta1-2 +- 1.0.12rc1 2 10012 2.1.0.12rc1 +- 1.0.12 2 10012 2.1.0.12 +- 1.1.0a-f - 10100 2.1.1.0a-f abandoned +- 1.2.0beta1-2 2 10200 2.1.2.0beta1-2 +- 1.2.0beta3-5 3 10200 3.1.2.0beta3-5 +- 1.2.0rc1 3 10200 3.1.2.0rc1 +- 1.2.0 3 10200 3.1.2.0 +- 1.2.1beta-4 3 10201 3.1.2.1beta1-4 +- 1.2.1rc1-2 3 10201 3.1.2.1rc1-2 +- 1.2.1 3 10201 3.1.2.1 +- 1.2.2beta1-6 12 10202 12.so.0.1.2.2beta1-6 +- 1.0.13beta1 10 10013 10.so.0.1.0.13beta1 +- 1.0.13rc1 10 10013 10.so.0.1.0.13rc1 +- 1.2.2rc1 12 10202 12.so.0.1.2.2rc1 +- 1.0.13 10 10013 10.so.0.1.0.13 +- 1.2.2 12 10202 12.so.0.1.2.2 +- 1.2.3rc1-6 12 10203 12.so.0.1.2.3rc1-6 +- 1.2.3 12 10203 12.so.0.1.2.3 +- 1.2.4beta1-3 13 10204 12.so.0.1.2.4beta1-3 +- 1.2.4rc1 13 10204 12.so.0.1.2.4rc1 +- 1.0.14 10 10014 10.so.0.1.0.14 +- 1.2.4 13 10204 12.so.0.1.2.4 +- 1.2.5beta1-2 13 10205 12.so.0.1.2.5beta1-2 +- 1.0.15rc1 10 10015 10.so.0.1.0.15rc1 +- 1.0.15 10 10015 10.so.0.1.0.15 +- 1.2.5 13 10205 12.so.0.1.2.5 +- 1.2.6beta1-4 13 10206 12.so.0.1.2.6beta1-4 +- 1.2.6rc1-5 13 10206 12.so.0.1.2.6rc1-5 +- 1.0.16 10 10016 10.so.0.1.0.16 +- 1.2.6 13 10206 12.so.0.1.2.6 +- 1.2.7beta1-2 13 10207 12.so.0.1.2.7beta1-2 +- 1.0.17rc1 10 10017 10.so.0.1.0.17rc1 +- 1.2.7rc1 13 10207 12.so.0.1.2.7rc1 +- 1.0.17 10 10017 10.so.0.1.0.17 +- 1.2.7 13 10207 12.so.0.1.2.7 +- 1.2.8beta1-5 13 10208 12.so.0.1.2.8beta1-5 +- 1.0.18rc1-5 10 10018 10.so.0.1.0.18rc1-5 +- 1.2.8rc1-5 13 10208 12.so.0.1.2.8rc1-5 +- 1.0.18 10 10018 10.so.0.1.0.18 +- 1.2.8 13 10208 12.so.0.1.2.8 +- 1.2.9beta1-3 13 10209 12.so.0.1.2.9beta1-3 +- 1.2.9beta4-11 13 10209 12.so.0.9[.0] +- 1.2.9rc1 13 10209 12.so.0.9[.0] +- 1.2.9 13 10209 12.so.0.9[.0] +- 1.2.10beta1-8 13 10210 12.so.0.10[.0] +- 1.2.10rc1-3 13 10210 12.so.0.10[.0] +- 1.2.10 13 10210 12.so.0.10[.0] +- 1.2.11beta1-4 13 10211 12.so.0.11[.0] +- 1.0.19rc1-5 10 10019 10.so.0.19[.0] +- 1.2.11rc1-5 13 10211 12.so.0.11[.0] +- 1.0.19 10 10019 10.so.0.19[.0] +- 1.2.11 13 10211 12.so.0.11[.0] +- 1.0.20 10 10020 10.so.0.20[.0] +- 1.2.12 13 10212 12.so.0.12[.0] +- 1.2.13beta1 13 10213 12.so.0.13[.0] +- 1.0.21 10 10021 10.so.0.21[.0] +- 1.2.13 13 10213 12.so.0.13[.0] +- 1.2.14beta1-2 13 10214 12.so.0.14[.0] +- 1.0.22rc1 10 10022 10.so.0.22[.0] +- 1.2.14rc1 13 10214 12.so.0.14[.0] +- 1.2.15beta1-6 13 10215 12.so.0.15[.0] +- 1.0.23rc1-5 10 10023 10.so.0.23[.0] +- 1.2.15rc1-5 13 10215 12.so.0.15[.0] +- 1.0.23 10 10023 10.so.0.23[.0] +- 1.2.15 13 10215 12.so.0.15[.0] +- 1.2.16beta1-2 13 10216 12.so.0.16[.0] +- 1.2.16rc1 13 10216 12.so.0.16[.0] +- 1.0.24 10 10024 10.so.0.24[.0] +- 1.2.16 13 10216 12.so.0.16[.0] +- 1.2.17beta1-2 13 10217 12.so.0.17[.0] +- 1.0.25rc1 10 10025 10.so.0.25[.0] +- 1.2.17rc1-3 13 10217 12.so.0.17[.0] +- 1.0.25 10 10025 10.so.0.25[.0] +- 1.2.17 13 10217 12.so.0.17[.0] +- 1.0.26 10 10026 10.so.0.26[.0] +- 1.2.18 13 10218 12.so.0.18[.0] +- 1.2.19beta1-31 13 10219 12.so.0.19[.0] +- 1.0.27rc1-6 10 10027 10.so.0.27[.0] +- 1.2.19rc1-6 13 10219 12.so.0.19[.0] +- 1.0.27 10 10027 10.so.0.27[.0] +- 1.2.19 13 10219 12.so.0.19[.0] +- 1.2.20beta01-04 13 10220 12.so.0.20[.0] +- 1.0.28rc1-6 10 10028 10.so.0.28[.0] +- 1.2.20rc1-6 13 10220 12.so.0.20[.0] +- 1.0.28 10 10028 10.so.0.28[.0] +- 1.2.20 13 10220 12.so.0.20[.0] +- 1.2.21beta1-2 13 10221 12.so.0.21[.0] +- 1.2.21rc1-3 13 10221 12.so.0.21[.0] +- 1.0.29 10 10029 10.so.0.29[.0] +- 1.2.21 13 10221 12.so.0.21[.0] +- 1.2.22beta1-4 13 10222 12.so.0.22[.0] +- 1.0.30rc1 13 10030 10.so.0.30[.0] +- 1.2.22rc1 13 10222 12.so.0.22[.0] +- 1.0.30 10 10030 10.so.0.30[.0] +- 1.2.22 13 10222 12.so.0.22[.0] +- 1.2.23beta01-05 13 10223 12.so.0.23[.0] +- 1.2.23rc01 13 10223 12.so.0.23[.0] +- 1.2.23 13 10223 12.so.0.23[.0] +- 1.2.24beta01-02 13 10224 12.so.0.24[.0] +- 1.2.24rc01 13 10224 12.so.0.24[.0] +- 1.2.24 13 10224 12.so.0.24[.0] +- 1.2.25beta01-06 13 10225 12.so.0.25[.0] +- 1.2.25rc01-02 13 10225 12.so.0.25[.0] +- 1.0.31 10 10031 10.so.0.31[.0] +- 1.2.25 13 10225 12.so.0.25[.0] +- 1.2.26beta01-06 13 10226 12.so.0.26[.0] +- 1.2.26rc01 13 10226 12.so.0.26[.0] +- 1.2.26 13 10226 12.so.0.26[.0] +- 1.0.32 10 10032 10.so.0.32[.0] +- 1.2.27beta01-06 13 10227 12.so.0.27[.0] +- 1.2.27rc01 13 10227 12.so.0.27[.0] +- 1.0.33 10 10033 10.so.0.33[.0] +- 1.2.27 13 10227 12.so.0.27[.0] +- 1.0.34 10 10034 10.so.0.34[.0] +- 1.2.28 13 10228 12.so.0.28[.0] +- 1.2.29beta01-03 13 10229 12.so.0.29[.0] +- 1.2.29rc01 13 10229 12.so.0.29[.0] +- 1.0.35 10 10035 10.so.0.35[.0] +- 1.2.29 13 10229 12.so.0.29[.0] +- 1.0.37 10 10037 10.so.0.37[.0] +- 1.2.30beta01-04 13 10230 12.so.0.30[.0] +- 1.0.38rc01-08 10 10038 10.so.0.38[.0] +- 1.2.30rc01-08 13 10230 12.so.0.30[.0] +- 1.0.38 10 10038 10.so.0.38[.0] +- 1.2.30 13 10230 12.so.0.30[.0] +- 1.0.39rc01-03 10 10039 10.so.0.39[.0] +- 1.2.31rc01-03 13 10231 12.so.0.31[.0] +- 1.0.39 10 10039 10.so.0.39[.0] +- 1.2.31 13 10231 12.so.0.31[.0] +- 1.2.32beta01-02 13 10232 12.so.0.32[.0] +- 1.0.40rc01 10 10040 10.so.0.40[.0] +- 1.2.32rc01 13 10232 12.so.0.32[.0] +- 1.0.40 10 10040 10.so.0.40[.0] +- 1.2.32 13 10232 12.so.0.32[.0] +- 1.2.33beta01-02 13 10233 12.so.0.33[.0] +- 1.2.33rc01-02 13 10233 12.so.0.33[.0] +- 1.0.41rc01 10 10041 10.so.0.41[.0] +- 1.2.33 13 10233 12.so.0.33[.0] +- 1.0.41 10 10041 10.so.0.41[.0] +- 1.2.34beta01-07 13 10234 12.so.0.34[.0] +- 1.0.42rc01 10 10042 10.so.0.42[.0] +- 1.2.34rc01 13 10234 12.so.0.34[.0] +- 1.0.42 10 10042 10.so.0.42[.0] +- 1.2.34 13 10234 12.so.0.34[.0] +- 1.2.35beta01-03 13 10235 12.so.0.35[.0] +- 1.0.43rc01-02 10 10043 10.so.0.43[.0] +- 1.2.35rc01-02 13 10235 12.so.0.35[.0] +- 1.0.43 10 10043 10.so.0.43[.0] +- 1.2.35 13 10235 12.so.0.35[.0] +- 1.2.36beta01-05 13 10236 12.so.0.36[.0] +- 1.2.36rc01 13 10236 12.so.0.36[.0] +- 1.0.44 10 10044 10.so.0.44[.0] +- 1.2.36 13 10236 12.so.0.36[.0] +- 1.2.37beta01-03 13 10237 12.so.0.37[.0] +- 1.2.37rc01 13 10237 12.so.0.37[.0] +- 1.2.37 13 10237 12.so.0.37[.0] +- 1.2.45 10 10045 12.so.0.45[.0] +- 1.0.46 10 10046 10.so.0.46[.0] +- 1.2.38beta01 13 10238 12.so.0.38[.0] +- 1.2.38rc01-03 13 10238 12.so.0.38[.0] +- 1.0.47 10 10047 10.so.0.47[.0] +- 1.2.38 13 10238 12.so.0.38[.0] +- 1.2.39beta01-05 13 10239 12.so.0.39[.0] +- 1.2.39rc01 13 10239 12.so.0.39[.0] +- 1.0.48 10 10048 10.so.0.48[.0] +- 1.2.39 13 10239 12.so.0.39[.0] +- 1.2.40beta01 13 10240 12.so.0.40[.0] +- 1.2.40rc01 13 10240 12.so.0.40[.0] +- 1.0.49 10 10049 10.so.0.49[.0] +- 1.2.40 13 10240 12.so.0.40[.0] +- 1.0.50 10 10050 10.so.0.50[.0] +- 1.2.41beta01-18 13 10241 12.so.0.41[.0] +- 1.0.51rc01 10 10051 10.so.0.51[.0] +- 1.2.41rc01-03 13 10241 12.so.0.41[.0] +- 1.0.51 10 10051 10.so.0.51[.0] +- 1.2.41 13 10241 12.so.0.41[.0] +- 1.2.42beta01-02 13 10242 12.so.0.42[.0] +- 1.2.42rc01-05 13 10242 12.so.0.42[.0] +- 1.0.52 10 10052 10.so.0.52[.0] +- 1.2.42 13 10242 12.so.0.42[.0] +- 1.2.43beta01-05 13 10243 12.so.0.43[.0] +- 1.0.53rc01-02 10 10053 10.so.0.53[.0] +- 1.2.43rc01-02 13 10243 12.so.0.43[.0] +- 1.0.53 10 10053 10.so.0.53[.0] +- 1.2.43 13 10243 12.so.0.43[.0] +- 1.2.44beta01-03 13 10244 12.so.0.44[.0] +- 1.2.44rc01-03 13 10244 12.so.0.44[.0] +- 1.2.44 13 10244 12.so.0.44[.0] +- +-Henceforth the source version will match the shared-library minor +-and patch numbers; the shared-library major version number will be +-used for changes in backward compatibility, as it is intended. The +-PNG_PNGLIB_VER macro, which is not used within libpng but is available +-for applications, is an unsigned integer of the form xyyzz corresponding +-to the source version x.y.z (leading zeros in y and z). Beta versions +-were given the previous public release number plus a letter, until +-version 1.0.6j; from then on they were given the upcoming public +-release number plus "betaNN" or "rcN". ++ source png.h png.h shared-lib ++ version string int version ++ ------- ------ ----- ---------- ++ 0.89c "1.0 beta 3" 0.89 89 1.0.89 ++ 0.90 "1.0 beta 4" 0.90 90 0.90 [should have been 2.0.90] ++ 0.95 "1.0 beta 5" 0.95 95 0.95 [should have been 2.0.95] ++ 0.96 "1.0 beta 6" 0.96 96 0.96 [should have been 2.0.96] ++ 0.97b "1.00.97 beta 7" 1.00.97 97 1.0.1 [should have been 2.0.97] ++ 0.97c 0.97 97 2.0.97 ++ 0.98 0.98 98 2.0.98 ++ 0.99 0.99 98 2.0.99 ++ 0.99a-m 0.99 99 2.0.99 ++ 1.00 1.00 100 2.1.0 [100 should be 10000] ++ 1.0.0 (from here on, the 100 2.1.0 [100 should be 10000] ++ 1.0.1 png.h string is 10001 2.1.0 ++ 1.0.1a-e identical to the 10002 from here on, the shared library ++ 1.0.2 source version) 10002 is 2.V where V is the source code ++ 1.0.2a-b 10003 version, except as noted. ++ 1.0.3 10003 ++ 1.0.3a-d 10004 ++ 1.0.4 10004 ++ 1.0.4a-f 10005 ++ 1.0.5 (+ 2 patches) 10005 ++ 1.0.5a-d 10006 ++ 1.0.5e-r 10100 (not source compatible) ++ 1.0.5s-v 10006 (not binary compatible) ++ 1.0.6 (+ 3 patches) 10006 (still binary incompatible) ++ 1.0.6d-f 10007 (still binary incompatible) ++ 1.0.6g 10007 ++ 1.0.6h 10007 10.6h (testing xy.z so-numbering) ++ 1.0.6i 10007 10.6i ++ 1.0.6j 10007 2.1.0.6j (incompatible with 1.0.0) ++ 1.0.7beta11-14 DLLNUM 10007 2.1.0.7beta11-14 (binary compatible) ++ 1.0.7beta15-18 1 10007 2.1.0.7beta15-18 (binary compatible) ++ 1.0.7rc1-2 1 10007 2.1.0.7rc1-2 (binary compatible) ++ 1.0.7 1 10007 (still compatible) ++ ... ++ 1.0.69 10 10069 10.so.0.69[.0] ++ ... ++ 1.2.59 13 10259 12.so.0.59[.0] ++ ... ++ 1.4.20 14 10420 14.so.0.20[.0] ++ ... ++ 1.5.30 15 10530 15.so.15.30[.0] ++ ... ++ 1.6.35 16 10635 16.so.16.35[.0] ++ ++Henceforth the source version will match the shared-library minor and ++patch numbers; the shared-library major version number will be used for ++changes in backward compatibility, as it is intended. ++The PNG_PNGLIB_VER macro, which is not used within libpng but is ++available for applications, is an unsigned integer of the form XYYZZ ++corresponding to the source version X.Y.Z (leading zeros in Y and Z). ++Beta versions were given the previous public release number plus a ++letter, until version 1.0.6j; from then on they were given the upcoming ++public release number plus "betaNN" or "rcNN". + + .SH "SEE ALSO" + .IR libpngpf(3) ", " png(5) + .LP + .IR libpng : + .IP +-http://libpng.sourceforge.net (follow the [DOWNLOAD] link) ++https://libpng.sourceforge.io/ (follow the [DOWNLOAD] link) + http://www.libpng.org/pub/png + + .LP +@@ -4333,7 +6009,7 @@ http://www.libpng.org/pub/png + .I libpng + or at + .br +-ftp://ftp.info-zip.org/pub/infozip/zlib ++https://zlib.net/ + + .LP + .IR PNG specification: RFC 2083 +@@ -4342,19 +6018,20 @@ ftp://ftp.info-zip.org/pub/infozip/zlib + .I libpng + or at + .br +-ftp://ftp.rfc-editor.org:/in-notes/rfc2083.txt ++https://www.ietf.org/rfc/rfc2083.txt + .br + or (as a W3C Recommendation) at + .br +-http://www.w3.org/TR/REC-png.html ++https://www.w3.org/TR/REC-png.html + + .LP + In the case of any inconsistency between the PNG specification + and this library, the specification takes precedence. + + .SH AUTHORS +-This man page: Glenn Randers-Pehrson +- ++This man page: ++Initially created by Glenn Randers-Pehrson. ++Maintained by Cosmin Truta. + + The contributing authors would like to thank all those who helped + with testing, bug fixes, and patience. This wouldn't have been +@@ -4362,9 +6039,9 @@ possible without all of you. + + Thanks to Frank J. T. Wojcik for helping with the documentation. + +-Libpng version 1.2.44 - June 26, 2010: ++Libpng: + Initially created in 1995 by Guy Eric Schalnat, then of Group 42, Inc. +-Currently maintained by Glenn Randers-Pehrson (glennrp at users.sourceforge.net). ++Maintained by Cosmin Truta. + + Supported by the PNG development group + .br +@@ -4374,117 +6051,4 @@ png-mng-implement at lists.sourceforge.net (subscription required; visit + https://lists.sourceforge.net/lists/listinfo/png-mng-implement + to subscribe). + +-.SH COPYRIGHT NOTICE, DISCLAIMER, and LICENSE: +- +-(This copy of the libpng notices is provided for your convenience. In case of +-any discrepancy between this copy and the notices in the file png.h that is +-included in the libpng distribution, the latter shall prevail.) +- +-If you modify libpng you may insert additional notices immediately following +-this sentence. +- +-This code is released under the libpng license. +- +-libpng versions 1.2.6, August 15, 2004, through 1.2.44, June 26, 2010, are +-Copyright (c) 2004,2006-2008 Glenn Randers-Pehrson, and are +-distributed according to the same disclaimer and license as libpng-1.2.5 +-with the following individual added to the list of Contributing Authors +- +- Cosmin Truta +- +-libpng versions 1.0.7, July 1, 2000, through 1.2.5 - October 3, 2002, are +-Copyright (c) 2000-2002 Glenn Randers-Pehrson, and are +-distributed according to the same disclaimer and license as libpng-1.0.6 +-with the following individuals added to the list of Contributing Authors +- +- Simon-Pierre Cadieux +- Eric S. Raymond +- Gilles Vollant +- +-and with the following additions to the disclaimer: +- +- There is no warranty against interference with your +- enjoyment of the library or against infringement. +- There is no warranty that our efforts or the library +- will fulfill any of your particular purposes or needs. +- This library is provided with all faults, and the entire +- risk of satisfactory quality, performance, accuracy, and +- effort is with the user. +- +-libpng versions 0.97, January 1998, through 1.0.6, March 20, 2000, are +-Copyright (c) 1998, 1999 Glenn Randers-Pehrson +-Distributed according to the same disclaimer and license as libpng-0.96, +-with the following individuals added to the list of Contributing Authors: +- +- Tom Lane +- Glenn Randers-Pehrson +- Willem van Schaik +- +-libpng versions 0.89, June 1996, through 0.96, May 1997, are +-Copyright (c) 1996, 1997 Andreas Dilger +-Distributed according to the same disclaimer and license as libpng-0.88, +-with the following individuals added to the list of Contributing Authors: +- +- John Bowler +- Kevin Bracey +- Sam Bushell +- Magnus Holmgren +- Greg Roelofs +- Tom Tanner +- +-libpng versions 0.5, May 1995, through 0.88, January 1996, are +-Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc. +- +-For the purposes of this copyright and license, "Contributing Authors" +-is defined as the following set of individuals: +- +- Andreas Dilger +- Dave Martindale +- Guy Eric Schalnat +- Paul Schmidt +- Tim Wegner +- +-The PNG Reference Library is supplied "AS IS". The Contributing Authors +-and Group 42, Inc. disclaim all warranties, expressed or implied, +-including, without limitation, the warranties of merchantability and of +-fitness for any purpose. The Contributing Authors and Group 42, Inc. +-assume no liability for direct, indirect, incidental, special, exemplary, +-or consequential damages, which may result from the use of the PNG +-Reference Library, even if advised of the possibility of such damage. +- +-Permission is hereby granted to use, copy, modify, and distribute this +-source code, or portions hereof, for any purpose, without fee, subject +-to the following restrictions: +- +-1. The origin of this source code must not be misrepresented. +- +-2. Altered versions must be plainly marked as such and +- must not be misrepresented as being the original source. +- +-3. This Copyright notice may not be removed or altered from +- any source or altered source distribution. +- +-The Contributing Authors and Group 42, Inc. specifically permit, without +-fee, and encourage the use of this source code as a component to +-supporting the PNG file format in commercial products. If you use this +-source code in a product, acknowledgment is not required but would be +-appreciated. +- +- +-A "png_get_copyright" function is available, for convenient use in "about" +-boxes and the like: +- +- printf("%s",png_get_copyright(NULL)); +- +-Also, the PNG logo (in PNG format, of course) is supplied in the +-files "pngbar.png" and "pngbar.jpg (88x31) and "pngnow.png" (98x31). +- +-Libpng is OSI Certified Open Source Software. OSI Certified Open Source is a +-certification mark of the Open Source Initiative. +- +-Glenn Randers-Pehrson +-glennrp at users.sourceforge.net +-June 26, 2010 +- + .\" end of man page +- +diff --git a/com32/lib/libpng/libpngpf.3 b/com32/lib/libpng/libpngpf.3 +index c2da624d..b736d82c 100644 +--- a/com32/lib/libpng/libpngpf.3 ++++ b/com32/lib/libpng/libpngpf.3 +@@ -1,806 +1,24 @@ +-.TH LIBPNGPF 3 "June 26, 2010" ++.TH LIBPNGPF 3 "December 1, 2018" + .SH NAME +-libpng \- Portable Network Graphics (PNG) Reference Library 1.2.44 ++libpng \- Portable Network Graphics (PNG) Reference Library 1.6.36 + (private functions) +-.SH SYNOPSIS +-\fB#include \fP +- +-\fI\fB +- +-\fBvoid png_64bit_product (long \fP\fIv1\fP\fB, long \fP\fIv2\fP\fB, unsigned long \fI*hi_product, +- +-\fBunsigned long \fI*lo_product\fP\fB);\fP +- +-\fI\fB +- +-\fBvoid png_build_gamma_table (png_structp \fIpng_ptr\fP\fB);\fP +- +-\fI\fB +- +-\fI\fB +- +-\fBvoid png_build_grayscale_palette (int \fP\fIbit_depth\fP\fB, png_colorp \fIpalette\fP\fB);\fP +- +-\fI\fB +- +-\fI\fB +- +-\fBvoid png_calculate_crc (png_structp \fP\fIpng_ptr\fP\fB, png_bytep \fP\fIptr\fP\fB, png_size_t \fIlength\fP\fB);\fP +- +-\fI\fB +- +-\fI\fB +- +-\fBint png_check_cHRM_fixed (png_structp \fP\fIpng_ptr\fP\fB, png_fixed_point \fP\fIint_white_x\fP\fB, png_fixed_point \fP\fIint_white_y\fP\fB, png_fixed_point \fP\fIint_red_x\fP\fB, png_fixed_point \fP\fIint_red_y\fP\fB, png_fixed_point \fP\fIint_green_x\fP\fB, png_fixed_point \fP\fIint_green_y\fP\fB, png_fixed_point \fP\fIint_blue_x\fP\fB, png_fixed_point \fIint_blue_y\fP\fB);\fP +- +-\fI\fB +- +-\fI\fB +- +-\fBvoid png_check_IHDR (png_structp \fP\fIpng_ptr\fP\fB, png_uint_32 \fP\fIwidth\fP\fB, png_uint_32 \fP\fIheight\fP\fB, int \fP\fIbit_depth\fP\fB, int \fP\fIcolor_type\fP\fB, int \fP\fIinterlace_type\fP\fB, int \fP\fIcompression_type\fP\fB, int \fIfilter_type\fP\fB);\fP +- +-\fI\fB +- +-\fI\fB +- +-\fBvoid png_check_chunk_name (png_structp \fP\fIpng_ptr\fP\fB, png_bytep \fIchunk_name\fP\fB);\fP +- +-\fI\fB +- +-\fI\fB +- +-\fBpng_size_t png_check_keyword (png_structp \fP\fIpng_ptr\fP\fB, png_charp \fP\fIkey\fP\fB, png_charpp \fInew_key\fP\fB);\fP +- +-\fI\fB +- +-\fI\fB +- +-\fBvoid png_combine_row (png_structp \fP\fIpng_ptr\fP\fB, png_bytep \fP\fIrow\fP\fB, int \fImask\fP\fB);\fP +- +-\fI\fB +- +-\fI\fB +- +-\fBvoid png_correct_palette (png_structp \fP\fIpng_ptr\fP\fB, png_colorp \fP\fIpalette\fP\fB, int \fInum_palette\fP\fB);\fP +- +-\fI\fB +- +-\fI\fB +- +-\fBint png_crc_error (png_structp \fIpng_ptr\fP\fB);\fP +- +-\fI\fB +- +-\fI\fB +- +-\fBint png_crc_finish (png_structp \fP\fIpng_ptr\fP\fB, png_uint_32 \fIskip\fP\fB);\fP +- +-\fI\fB +- +-\fI\fB +- +-\fBvoid png_crc_read (png_structp \fP\fIpng_ptr\fP\fB, png_bytep \fP\fIbuf\fP\fB, png_size_t \fIlength\fP\fB);\fP +- +-\fI\fB +- +-\fI\fB +- +-\fBpng_voidp png_create_struct (int \fItype\fP\fB);\fP +- +-\fI\fB +- +-\fI\fB +- +-\fBpng_voidp png_create_struct_2 (int \fP\fItype\fP\fB, png_malloc_ptr \fP\fImalloc_fn\fP\fB, png_voidp \fImem_ptr\fP\fB);\fP +- +-\fI\fB +- +-\fI\fB +- +-\fBvoid png_decompress_chunk (png_structp \fP\fIpng_ptr\fP\fB, int \fP\fIcomp_type\fP\fB, png_charp \fP\fIchunkdata\fP\fB, png_size_t \fP\fIchunklength\fP\fB, png_size_t \fP\fIprefix_length\fP\fB, png_size_t \fI*data_length\fP\fB);\fP +- +-\fI\fB +- +-\fI\fB +- +-\fBvoid png_destroy_struct (png_voidp \fIstruct_ptr\fP\fB);\fP +- +-\fI\fB +- +-\fI\fB +- +-\fBvoid png_destroy_struct_2 (png_voidp \fP\fIstruct_ptr\fP\fB, png_free_ptr \fP\fIfree_fn\fP\fB, png_voidp \fImem_ptr\fP\fB);\fP +- +-\fI\fB +- +-\fI\fB +- +-\fBvoid png_do_background (png_row_infop \fP\fIrow_info\fP\fB, png_bytep \fP\fIrow\fP\fB, png_color_16p \fP\fItrans_values\fP\fB, png_color_16p \fP\fIbackground\fP\fB, png_color_16p \fP\fIbackground_1\fP\fB, png_bytep \fP\fIgamma_table\fP\fB, png_bytep \fP\fIgamma_from_1\fP\fB, png_bytep \fP\fIgamma_to_1\fP\fB, png_uint_16pp \fP\fIgamma_16\fP\fB, png_uint_16pp \fP\fIgamma_16_from_1\fP\fB, png_uint_16pp \fP\fIgamma_16_to_1\fP\fB, int \fIgamma_shift\fP\fB);\fP +- +-\fI\fB +- +-\fI\fB +- +-\fBvoid png_do_bgr (png_row_infop \fP\fIrow_info\fP\fB, png_bytep \fIrow\fP\fB);\fP +- +-\fI\fB +- +-\fI\fB +- +-\fBvoid png_do_chop (png_row_infop \fP\fIrow_info\fP\fB, png_bytep \fIrow\fP\fB);\fP +- +-\fI\fB +- +-\fI\fB +- +-\fBvoid png_do_dither (png_row_infop \fP\fIrow_info\fP\fB, png_bytep \fP\fIrow\fP\fB, png_bytep \fP\fIpalette_lookup\fP\fB, png_bytep \fIdither_lookup\fP\fB);\fP +- +-\fI\fB +- +-\fI\fB +- +-\fBvoid png_do_expand (png_row_infop \fP\fIrow_info\fP\fB, png_bytep \fP\fIrow\fP\fB, png_color_16p \fItrans_value\fP\fB);\fP +- +-\fI\fB +- +-\fI\fB +- +-\fBvoid png_do_expand_palette (png_row_infop \fP\fIrow_info\fP\fB, png_bytep \fP\fIrow\fP\fB, png_colorp \fP\fIpalette\fP\fB, png_bytep \fP\fItrans\fP\fB, int \fInum_trans\fP\fB);\fP +- +-\fI\fB +- +-\fI\fB +- +-\fBvoid png_do_gamma (png_row_infop \fP\fIrow_info\fP\fB, png_bytep \fP\fIrow\fP\fB, png_bytep \fP\fIgamma_table\fP\fB, png_uint_16pp \fP\fIgamma_16_table\fP\fB, int \fIgamma_shift\fP\fB);\fP +- +-\fI\fB +- +-\fI\fB +- +-\fBvoid png_do_gray_to_rgb (png_row_infop \fP\fIrow_info\fP\fB, png_bytep \fIrow\fP\fB);\fP +- +-\fI\fB +- +-\fI\fB +- +-\fBvoid png_do_invert (png_row_infop \fP\fIrow_info\fP\fB, png_bytep \fIrow\fP\fB);\fP +- +-\fI\fB +- +-\fI\fB +- +-\fBvoid png_do_pack (png_row_infop \fP\fIrow_info\fP\fB, png_bytep \fP\fIrow\fP\fB, png_uint_32 \fIbit_depth\fP\fB);\fP +- +-\fI\fB +- +-\fI\fB +- +-\fBvoid png_do_packswap (png_row_infop \fP\fIrow_info\fP\fB, png_bytep \fIrow\fP\fB);\fP +- +-\fI\fB +- +-\fI\fB +- +-\fBvoid png_do_read_filler (png_row_infop \fP\fIrow_info\fP\fB, png_bytep \fP\fIrow\fP\fB, png_uint_32 \fP\fIfiller\fP\fB, png_uint_32 \fIflags\fP\fB);\fP +- +-\fI\fB +- +-\fI\fB +- +-\fBvoid png_do_read_interlace (png_row_infop \fP\fIrow_info\fP\fB, png_bytep \fP\fIrow\fP\fB, int \fP\fIpass\fP\fB, png_uint_32 \fItransformations\fP\fB);\fP +- +-\fI\fB +- +-\fI\fB +- +-\fBvoid png_do_read_invert_alpha (png_row_infop \fP\fIrow_info\fP\fB, png_bytep \fIrow\fP\fB);\fP +- +-\fI\fB +- +-\fI\fB +- +-\fBvoid png_do_read_swap_alpha (png_row_infop \fP\fIrow_info\fP\fB, png_bytep \fIrow\fP\fB);\fP +- +-\fI\fB +- +-\fI\fB +- +-\fBvoid png_do_read_transformations (png_structp \fIpng_ptr\fP\fB);\fP +- +-\fI\fB +- +-\fI\fB +- +-\fBint png_do_rgb_to_gray (png_row_infop \fP\fIrow_info\fP\fB, png_bytep \fIrow\fP\fB);\fP +- +-\fI\fB +- +-\fI\fB +- +-\fBvoid png_do_shift (png_row_infop \fP\fIrow_info\fP\fB, png_bytep \fP\fIrow\fP\fB, png_color_8p \fIbit_depth\fP\fB);\fP +- +-\fI\fB +- +-\fI\fB +- +-\fBvoid png_do_strip_filler (png_row_infop \fP\fIrow_info\fP\fB, png_bytep \fP\fIrow\fP\fB, png_uint_32 \fIflags\fP\fB);\fP +- +-\fI\fB +- +-\fI\fB +- +-\fBvoid png_do_swap (png_row_infop \fP\fIrow_info\fP\fB, png_bytep \fIrow\fP\fB);\fP +- +-\fI\fB +- +-\fI\fB +- +-\fBvoid png_do_unpack (png_row_infop \fP\fIrow_info\fP\fB, png_bytep \fIrow\fP\fB);\fP +- +-\fI\fB +- +-\fI\fB +- +-\fBvoid png_do_unshift (png_row_infop \fP\fIrow_info\fP\fB, png_bytep \fP\fIrow\fP\fB, png_color_8p \fIsig_bits\fP\fB);\fP +- +-\fI\fB +- +-\fI\fB +- +-\fBvoid png_do_write_interlace (png_row_infop \fP\fIrow_info\fP\fB, png_bytep \fP\fIrow\fP\fB, int \fIpass\fP\fB);\fP +- +-\fI\fB +- +-\fI\fB +- +-\fBvoid png_do_write_invert_alpha (png_row_infop \fP\fIrow_info\fP\fB, png_bytep \fIrow\fP\fB);\fP +- +-\fI\fB +- +-\fI\fB +- +-\fBvoid png_do_write_swap_alpha (png_row_infop \fP\fIrow_info\fP\fB, png_bytep \fIrow\fP\fB);\fP +- +-\fI\fB +- +-\fI\fB +- +-\fBvoid png_do_write_transformations (png_structp \fIpng_ptr\fP\fB);\fP +- +-\fI\fB +- +-\fI\fB +- +-\fBvoid *png_far_to_near (png_structp png_ptr,png_voidp \fP\fIptr\fP\fB, int \fIcheck\fP\fB);\fP +- +-\fI\fB +- +-\fI\fB +- +-\fBvoid png_flush (png_structp \fIpng_ptr\fP\fB);\fP +- +-\fI\fB +- +-\fI\fB +- +-\fBvoid png_handle_bKGD (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_uint_32 \fIlength\fP\fB);\fP +- +-\fI\fB +- +-\fI\fB +- +-\fBvoid png_handle_cHRM (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_uint_32 \fIlength\fP\fB);\fP +- +-\fI\fB +- +-\fI\fB +- +-\fBvoid png_handle_gAMA (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_uint_32 \fIlength\fP\fB);\fP +- +-\fI\fB +- +-\fI\fB +- +-\fBvoid png_handle_hIST (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_uint_32 \fIlength\fP\fB);\fP +- +-\fI\fB +- +-\fI\fB +- +-\fBvoid png_handle_IEND (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_uint_32 \fIlength\fP\fB);\fP +- +-\fI\fB +- +-\fI\fB +- +-\fBvoid png_handle_IHDR (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_uint_32 \fIlength\fP\fB);\fP +- +-\fI\fB +- +-\fI\fB +- +-\fBvoid png_handle_iCCP (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_uint_32 \fIlength\fP\fB);\fP +- +-\fI\fB +- +-\fI\fB +- +-\fBvoid png_handle_iTXt (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_uint_32 \fIlength\fP\fB);\fP +- +-\fI\fB +- +-\fI\fB +- +-\fBvoid png_handle_oFFs (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_uint_32 \fIlength\fP\fB);\fP +- +-\fI\fB +- +-\fI\fB +- +-\fBvoid png_handle_pCAL (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_uint_32 \fIlength\fP\fB);\fP +- +-\fI\fB +- +-\fI\fB +- +-\fBvoid png_handle_pHYs (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_uint_32 \fIlength\fP\fB);\fP +- +-\fI\fB +- +-\fI\fB +- +-\fBvoid png_handle_PLTE (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_uint_32 \fIlength\fP\fB);\fP +- +-\fI\fB +- +-\fI\fB +- +-\fBvoid png_handle_sBIT (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_uint_32 \fIlength\fP\fB);\fP +- +-\fI\fB +- +-\fI\fB +- +-\fBvoid png_handle_sCAL (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_uint_32 \fIlength\fP\fB);\fP +- +-\fI\fB +- +-\fI\fB +- +-\fBvoid png_handle_sPLT (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_uint_32 \fIlength\fP\fB);\fP +- +-\fI\fB +- +-\fI\fB +- +-\fBvoid png_handle_sRGB (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_uint_32 \fIlength\fP\fB);\fP +- +-\fI\fB +- +-\fI\fB +- +-\fBvoid png_handle_tEXt (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_uint_32 \fIlength\fP\fB);\fP +- +-\fI\fB +- +-\fI\fB +- +-\fBvoid png_handle_tIME (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_uint_32 \fIlength\fP\fB);\fP +- +-\fI\fB +- +-\fI\fB +- +-\fBvoid png_handle_tRNS (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_uint_32 \fIlength\fP\fB);\fP +- +-\fI\fB +- +-\fI\fB +- +-\fBvoid png_handle_unknown (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_uint_32 \fIlength\fP\fB);\fP + +-\fI\fB +- +-\fI\fB +- +-\fBvoid png_handle_zTXt (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_uint_32 \fIlength\fP\fB);\fP +- +-\fI\fB +- +-\fI\fB +- +-\fBvoid png_info_destroy (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fIinfo_ptr\fP\fB);\fP +- +-\fI\fB +- +-\fI\fB +- +-\fBvoid png_init_mmx_flags (png_structp \fIpng_ptr\fP\fB);\fP +- +-\fI\fB +- +-\fI\fB +- +-\fBvoid png_init_read_transformations (png_structp \fIpng_ptr\fP\fB);\fP +- +-\fI\fB +- +-\fI\fB +- +-\fBvoid png_process_IDAT_data (png_structp \fP\fIpng_ptr\fP\fB, png_bytep \fP\fIbuffer\fP\fB, png_size_t \fIbuffer_length\fP\fB);\fP +- +-\fI\fB +- +-\fI\fB +- +-\fBvoid png_process_some_data (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fIinfo_ptr\fP\fB);\fP +- +-\fI\fB +- +-\fI\fB +- +-\fBvoid png_push_check_crc (png_structp \fIpng_ptr\fP\fB);\fP +- +-\fI\fB +- +-\fI\fB +- +-\fBvoid png_push_crc_finish (png_structp \fIpng_ptr\fP\fB);\fP +- +-\fI\fB +- +-\fI\fB +- +-\fBvoid png_push_crc_skip (png_structp \fP\fIpng_ptr\fP\fB, png_uint_32 \fIlength\fP\fB);\fP +- +-\fI\fB +- +-\fI\fB +- +-\fBvoid png_push_fill_buffer (png_structp \fP\fIpng_ptr\fP\fB, png_bytep \fP\fIbuffer\fP\fB, png_size_t \fIlength\fP\fB);\fP +- +-\fI\fB +- +-\fI\fB +- +-\fBvoid png_push_handle_tEXt (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_uint_32 \fIlength\fP\fB);\fP +- +-\fI\fB +- +-\fI\fB +- +-\fBvoid png_push_handle_unknown (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_uint_32 \fIlength\fP\fB);\fP +- +-\fI\fB +- +-\fI\fB +- +-\fBvoid png_push_handle_zTXt (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_uint_32 \fIlength\fP\fB);\fP +- +-\fI\fB +- +-\fI\fB +- +-\fBvoid png_push_have_end (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fIinfo_ptr\fP\fB);\fP +- +-\fI\fB +- +-\fI\fB +- +-\fBvoid png_push_have_info (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fIinfo_ptr\fP\fB);\fP +- +-\fI\fB +- +-\fI\fB +- +-\fBvoid png_push_have_row (png_structp \fP\fIpng_ptr\fP\fB, png_bytep \fIrow\fP\fB);\fP +- +-\fI\fB +- +-\fI\fB +- +-\fBvoid png_push_process_row (png_structp \fIpng_ptr\fP\fB);\fP +- +-\fI\fB +- +-\fI\fB +- +-\fBvoid png_push_read_chunk (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fIinfo_ptr\fP\fB);\fP +- +-\fI\fB +- +-\fI\fB +- +-\fBvoid png_push_read_end (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fIinfo_ptr\fP\fB);\fP +- +-\fI\fB +- +-\fI\fB +- +-\fBvoid png_push_read_IDAT (png_structp \fIpng_ptr\fP\fB);\fP +- +-\fI\fB +- +-\fI\fB +- +-\fBvoid png_push_read_sig (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fIinfo_ptr\fP\fB);\fP +- +-\fI\fB +- +-\fI\fB +- +-\fBvoid png_push_read_tEXt (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fIinfo_ptr\fP\fB);\fP +- +-\fI\fB +- +-\fI\fB +- +-\fBvoid png_push_read_zTXt (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fIinfo_ptr\fP\fB);\fP +- +-\fI\fB +- +-\fI\fB +- +-\fBvoid png_push_restore_buffer (png_structp \fP\fIpng_ptr\fP\fB, png_bytep \fP\fIbuffer\fP\fB, png_size_t \fIbuffer_length\fP\fB);\fP +- +-\fI\fB +- +-\fI\fB +- +-\fBvoid png_push_save_buffer (png_structp \fIpng_ptr\fP\fB);\fP +- +-\fI\fB +- +-\fI\fB +- +-\fBpng_uint_32 png_read_chunk_header (png_structp \fIpng_ptr\fP\fB);\fP +- +-\fI\fB +- +-\fI\fB +- +-\fBvoid png_read_data (png_structp \fP\fIpng_ptr\fP\fB, png_bytep \fP\fIdata\fP\fB, png_size_t \fIlength\fP\fB);\fP +- +-\fI\fB +- +-\fI\fB +- +-\fBvoid png_read_filter_row (png_structp \fP\fIpng_ptr\fP\fB, png_row_infop \fP\fIrow_info\fP\fB, png_bytep \fP\fIrow\fP\fB, png_bytep \fP\fIprev_row\fP\fB, int \fIfilter\fP\fB);\fP +- +-\fI\fB +- +-\fI\fB +- +-\fBvoid png_read_finish_row (png_structp \fIpng_ptr\fP\fB);\fP +- +-\fI\fB +- +-\fI\fB +- +-\fBvoid png_read_push_finish_row (png_structp \fIpng_ptr\fP\fB);\fP +- +-\fI\fB +- +-\fI\fB +- +-\fBvoid png_read_start_row (png_structp \fIpng_ptr\fP\fB);\fP +- +-\fI\fB +- +-\fI\fB +- +-\fBvoid png_read_transform_info (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fIinfo_ptr\fP\fB);\fP +- +-\fI\fB +- +-\fI\fB +- +-\fBvoid png_reset_crc (png_structp \fIpng_ptr\fP\fB);\fP +- +-\fI\fB +- +-\fI\fB +- +-\fBint png_set_text_2 (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_textp \fP\fItext_ptr\fP\fB, int \fInum_text\fP\fB);\fP +- +-\fI\fB +- +-\fI\fB +- +-\fBvoid png_write_cHRM (png_structp \fP\fIpng_ptr\fP\fB, double \fP\fIwhite_x\fP\fB, double \fP\fIwhite_y\fP\fB, double \fP\fIred_x\fP\fB, double \fP\fIred_y\fP\fB, double \fP\fIgreen_x\fP\fB, double \fP\fIgreen_y\fP\fB, double \fP\fIblue_x\fP\fB, double \fIblue_y\fP\fB);\fP +- +-\fI\fB +- +-\fI\fB +- +-\fBvoid png_write_cHRM_fixed (png_structp \fP\fIpng_ptr\fP\fB, png_uint_32 \fP\fIwhite_x\fP\fB, png_uint_32 \fP\fIwhite_y\fP\fB, png_uint_32 \fP\fIred_x\fP\fB, png_uint_32 \fP\fIred_y\fP\fB, png_uint_32 \fP\fIgreen_x\fP\fB, png_uint_32 \fP\fIgreen_y\fP\fB, png_uint_32 \fP\fIblue_x\fP\fB, png_uint_32 \fIblue_y\fP\fB);\fP +- +-\fI\fB +- +-\fI\fB +- +-\fBvoid png_write_data (png_structp \fP\fIpng_ptr\fP\fB, png_bytep \fP\fIdata\fP\fB, png_size_t \fIlength\fP\fB);\fP +- +-\fI\fB +- +-\fI\fB +- +-\fBvoid png_write_filtered_row (png_structp \fP\fIpng_ptr\fP\fB, png_bytep \fIfiltered_row\fP\fB);\fP +- +-\fI\fB +- +-\fI\fB +- +-\fBvoid png_write_find_filter (png_structp \fP\fIpng_ptr\fP\fB, png_row_infop \fIrow_info\fP\fB);\fP +- +-\fI\fB +- +-\fI\fB +- +-\fBvoid png_write_finish_row (png_structp \fIpng_ptr\fP\fB);\fP +- +-\fI\fB +- +-\fI\fB +- +-\fBvoid png_write_gAMA (png_structp \fP\fIpng_ptr\fP\fB, double \fIfile_gamma\fP\fB);\fP +- +-\fI\fB +- +-\fI\fB +- +-\fBvoid png_write_gAMA_fixed (png_structp \fP\fIpng_ptr\fP\fB, png_uint_32 \fIint_file_gamma\fP\fB);\fP +- +-\fI\fB +- +-\fI\fB +- +-\fBvoid png_write_hIST (png_structp \fP\fIpng_ptr\fP\fB, png_uint_16p \fP\fIhist\fP\fB, int \fInum_hist\fP\fB);\fP +- +-\fI\fB +- +-\fI\fB +- +-\fBvoid png_write_iCCP (png_structp \fP\fIpng_ptr\fP\fB, png_charp \fP\fIname\fP\fB, int \fP\fIcompression_type\fP\fB, png_charp \fP\fIprofile\fP\fB, int \fIproflen\fP\fB);\fP +- +-\fI\fB +- +-\fI\fB +- +-\fBvoid png_write_IDAT (png_structp \fP\fIpng_ptr\fP\fB, png_bytep \fP\fIdata\fP\fB, png_size_t \fIlength\fP\fB);\fP +- +-\fI\fB +- +-\fI\fB +- +-\fBvoid png_write_IEND (png_structp \fIpng_ptr\fP\fB);\fP +- +-\fI\fB +- +-\fI\fB +- +-\fBvoid png_write_IHDR (png_structp \fP\fIpng_ptr\fP\fB, png_uint_32 \fP\fIwidth\fP\fB, png_uint_32 \fP\fIheight\fP\fB, int \fP\fIbit_depth\fP\fB, int \fP\fIcolor_type\fP\fB, int \fP\fIcompression_type\fP\fB, int \fP\fIfilter_type\fP\fB, int \fIinterlace_type\fP\fB);\fP +- +-\fI\fB +- +-\fI\fB +- +-\fBvoid png_write_iTXt (png_structp \fP\fIpng_ptr\fP\fB, int \fP\fIcompression\fP\fB, png_charp \fP\fIkey\fP\fB, png_charp \fP\fIlang\fP\fB, png_charp \fP\fItranslated_key\fP\fB, png_charp \fItext\fP\fB);\fP +- +-\fI\fB +- +-\fI\fB +- +-\fBvoid png_write_oFFs (png_structp \fP\fIpng_ptr\fP\fB, png_uint_32 \fP\fIx_offset\fP\fB, png_uint_32 \fP\fIy_offset\fP\fB, int \fIunit_type\fP\fB);\fP +- +-\fI\fB +- +-\fI\fB +- +-\fBvoid png_write_pCAL (png_structp \fP\fIpng_ptr\fP\fB, png_charp \fP\fIpurpose\fP\fB, png_int_32 \fP\fIX0\fP\fB, png_int_32 \fP\fIX1\fP\fB, int \fP\fItype\fP\fB, int \fP\fInparams\fP\fB, png_charp \fP\fIunits\fP\fB, png_charpp \fIparams\fP\fB);\fP +- +-\fI\fB +- +-\fI\fB +- +-\fBvoid png_write_pHYs (png_structp \fP\fIpng_ptr\fP\fB, png_uint_32 \fP\fIx_pixels_per_unit\fP\fB, png_uint_32 \fP\fIy_pixels_per_unit\fP\fB, int \fIunit_type\fP\fB);\fP +- +-\fI\fB +- +-\fI\fB +- +-\fBvoid png_write_PLTE (png_structp \fP\fIpng_ptr\fP\fB, png_colorp \fP\fIpalette\fP\fB, png_uint_32 \fInum_pal\fP\fB);\fP +- +-\fI\fB +- +-\fI\fB +- +-\fBvoid png_write_sBIT (png_structp \fP\fIpng_ptr\fP\fB, png_color_8p \fP\fIsbit\fP\fB, int \fIcolor_type\fP\fB);\fP +- +-\fI\fB +- +-\fI\fB +- +-\fBvoid png_write_sCAL (png_structp \fP\fIpng_ptr\fP\fB, png_charp \fP\fIunit\fP\fB, double \fP\fIwidth\fP\fB, double \fIheight\fP\fB);\fP +- +-\fI\fB +- +-\fI\fB +- +-\fBvoid png_write_sCAL_s (png_structp \fP\fIpng_ptr\fP\fB, png_charp \fP\fIunit\fP\fB, png_charp \fP\fIwidth\fP\fB, png_charp \fIheight\fP\fB);\fP +- +-\fI\fB +- +-\fI\fB +- +-\fBvoid png_write_sig (png_structp \fIpng_ptr\fP\fB);\fP +- +-\fI\fB +- +-\fI\fB +- +-\fBvoid png_write_sRGB (png_structp \fP\fIpng_ptr\fP\fB, int \fIintent\fP\fB);\fP +- +-\fI\fB +- +-\fI\fB +- +-\fBvoid png_write_sPLT (png_structp \fP\fIpng_ptr\fP\fB, png_spalette_p \fIpalette\fP\fB);\fP +- +-\fI\fB +- +-\fI\fB +- +-\fBvoid png_write_start_row (png_structp \fIpng_ptr\fP\fB);\fP +- +-\fI\fB +- +-\fI\fB +- +-\fBvoid png_write_tEXt (png_structp \fP\fIpng_ptr\fP\fB, png_charp \fP\fIkey\fP\fB, png_charp \fP\fItext\fP\fB, png_size_t \fItext_len\fP\fB);\fP +- +-\fI\fB +- +-\fI\fB +- +-\fBvoid png_write_tIME (png_structp \fP\fIpng_ptr\fP\fB, png_timep \fImod_time\fP\fB);\fP +- +-\fI\fB +- +-\fI\fB +- +-\fBvoid png_write_tRNS (png_structp \fP\fIpng_ptr\fP\fB, png_bytep \fP\fItrans\fP\fB, png_color_16p \fP\fIvalues\fP\fB, int \fP\fInumber\fP\fB, int \fIcolor_type\fP\fB);\fP +- +-\fI\fB +- +-\fI\fB +- +-\fBvoid png_write_zTXt (png_structp \fP\fIpng_ptr\fP\fB, png_charp \fP\fIkey\fP\fB, png_charp \fP\fItext\fP\fB, png_size_t \fP\fItext_len\fP\fB, int \fIcompression\fP\fB);\fP +- +-\fI\fB +- +-\fI\fB +- +-\fBvoidpf png_zalloc (voidpf \fP\fIpng_ptr\fP\fB, uInt \fP\fIitems\fP\fB, uInt \fIsize\fP\fB);\fP +- +-\fI\fB +- +-\fI\fB +- +-\fBvoid png_zfree (voidpf \fP\fIpng_ptr\fP\fB, voidpf \fIptr\fP\fB);\fP +- +-\fI\fB ++.SH SYNOPSIS ++\fB#include \fI"pngpriv.h" + +-\fI\fB ++\fBAs of libpng version \fP\fI1.5.1\fP\fB, this section is no longer ++\fP\fImaintained\fP\fB, now that the private function prototypes are hidden in ++\fP\fIpngpriv.h\fP\fB and not accessible to applications. Look in ++\fP\fIpngpriv.h\fP\fB for the prototypes and a short description of each ++function. + + .SH DESCRIPTION +-The functions listed above are used privately by libpng +-and are not recommended for use by applications. They are +-not "exported" to applications using shared libraries. They +-are listed alphabetically here as an aid to libpng maintainers. +-See png.h for more information on these functions. ++The functions previously listed here are used privately by libpng and are not ++available for use by applications. They are not "exported" to applications ++using shared libraries. ++ ++.SH "SEE ALSO" ++.BR "png"(5), " libpng"(3), " zlib"(3), " deflate"(5), " " and " zlib"(5) + +-.SH SEE ALSO +-.IR libpng(3) ", " png(5) +-.SH AUTHOR +-Glenn Randers-Pehrson ++.SH AUTHORS ++Cosmin Truta, Glenn Randers-Pehrson +diff --git a/com32/lib/libpng/png.5 b/com32/lib/libpng/png.5 +index 645c80c1..2077d1f2 100644 +--- a/com32/lib/libpng/png.5 ++++ b/com32/lib/libpng/png.5 +@@ -1,47 +1,49 @@ +-.TH PNG 5 "June 26, 2010" ++.TH PNG 5 "December 1, 2018" + .SH NAME + png \- Portable Network Graphics (PNG) format ++ + .SH DESCRIPTION + PNG (Portable Network Graphics) is an extensible file format for the +-lossless, portable, well-compressed storage of raster images. PNG provides +-a patent-free replacement for GIF and can also replace many ++lossless, portable, well-compressed storage of raster images. PNG ++provides a patent-free replacement for GIF, and can also replace many + common uses of TIFF. Indexed-color, grayscale, and truecolor images are +-supported, plus an optional alpha channel. Sample depths range from ++supported, plus an optional alpha channel. Sample depths range from + 1 to 16 bits. + .br +- +-PNG is designed to work well in online viewing applications, such as the +-World Wide Web, so it is fully streamable with a progressive display +-option. PNG is robust, providing both full file integrity checking and +-fast, simple detection of common transmission errors. Also, PNG can store +-gamma and chromaticity data for improved color matching on heterogeneous +-platforms. ++PNG is designed to work well in online viewing applications, such ++as the World Wide Web, so it is fully streamable with a progressive ++display option. PNG is robust, providing both full file integrity ++checking and fast, simple detection of common transmission errors. ++Also, PNG can store gamma and chromaticity data for improved color ++matching on heterogeneous platforms. + + .SH "SEE ALSO" +-.IR libpng(3) ", " zlib(3) ", " deflate(5) ", and " zlib(5) ++.BR "libpng"(3), " libpngpf"(3), " zlib"(3), " deflate"(5), " " and " zlib"(5) + .LP +-PNG specification (second edition), November 2003: ++PNG Specification (Second Edition), November 2003: + .IP + .br +- 8) +- png_error(png_ptr, "Too many bytes for PNG signature."); ++ if (num_bytes < 0) ++ nb = 0; ++ ++ if (nb > 8) ++ png_error(png_ptr, "Too many bytes for PNG signature"); + +- png_ptr->sig_bytes = (png_byte)(num_bytes < 0 ? 0 : num_bytes); ++ png_ptr->sig_bytes = (png_byte)nb; + } + + /* Checks whether the supplied bytes match the PNG signature. We allow +@@ -115,14 +68,16 @@ png_set_sig_bytes(png_structp png_ptr, int num_bytes) + * 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_bytep sig, png_size_t start, png_size_t num_to_check) ++png_sig_cmp(png_const_bytep sig, size_t start, size_t num_to_check) + { + png_byte png_signature[8] = {137, 80, 78, 71, 13, 10, 26, 10}; ++ + if (num_to_check > 8) + num_to_check = 8; ++ + else if (num_to_check < 1) + return (-1); + +@@ -132,85 +87,47 @@ png_sig_cmp(png_bytep sig, png_size_t start, png_size_t num_to_check) + 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))); + } + +-#if defined(PNG_1_0_X) || defined(PNG_1_2_X) +-/* (Obsolete) function to check signature bytes. It does not allow one +- * to check a partial signature. This function might be removed in the +- * future - use png_sig_cmp(). Returns true (nonzero) if the file is PNG. +- */ +-int PNGAPI +-png_check_sig(png_bytep sig, int num) +-{ +- return ((int)!png_sig_cmp(sig, (png_size_t)0, (png_size_t)num)); +-} +-#endif +-#endif /* PNG_READ_SUPPORTED */ ++#endif /* READ */ + + #if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED) +-/* Function to allocate memory for zlib and clear it to 0. */ +-#ifdef PNG_1_0_X +-voidpf PNGAPI +-#else +-voidpf /* PRIVATE */ +-#endif +-png_zalloc(voidpf png_ptr, uInt items, uInt size) ++/* 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_uint_32 num_bytes; ++ png_alloc_size_t num_bytes = size; + + if (png_ptr == NULL) +- return (NULL); +- if (items > PNG_UINT_32_MAX/size) +- { +- png_warning (p, "Potential overflow in png_zalloc()"); +- return (NULL); +- } +- num_bytes = (png_uint_32)items * size; +- +- p->flags|=PNG_FLAG_MALLOC_NULL_MEM_OK; +- ptr = (png_voidp)png_malloc((png_structp)png_ptr, num_bytes); +- p->flags=save_flags; +- +-#if defined(PNG_1_0_X) && !defined(PNG_NO_ZALLOC_ZERO) +- if (ptr == NULL) +- return ((voidpf)ptr); ++ return NULL; + +- if (num_bytes > (png_uint_32)0x8000L) ++ if (items >= (~(png_alloc_size_t)0)/size) + { +- png_memset(ptr, 0, (png_size_t)0x8000L); +- png_memset((png_bytep)ptr + (png_size_t)0x8000L, 0, +- (png_size_t)(num_bytes - (png_uint_32)0x8000L)); ++ png_warning (png_voidcast(png_structrp, png_ptr), ++ "Potential overflow in png_zalloc()"); ++ return NULL; + } +- else +- { +- png_memset(ptr, 0, (png_size_t)num_bytes); +- } +-#endif +- return ((voidpf)ptr); ++ ++ num_bytes *= items; ++ return png_malloc_warn(png_voidcast(png_structrp, png_ptr), num_bytes); + } + + /* Function to free memory for zlib */ +-#ifdef PNG_1_0_X +-void PNGAPI +-#else + void /* PRIVATE */ +-#endif + png_zfree(voidpf png_ptr, voidpf ptr) + { +- png_free((png_structp)png_ptr, (png_voidp)ptr); ++ 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 +@@ -219,63 +136,256 @@ png_reset_crc(png_structp png_ptr) + * trouble of calculating it. + */ + void /* PRIVATE */ +-png_calculate_crc(png_structp png_ptr, png_bytep ptr, png_size_t length) ++png_calculate_crc(png_structrp png_ptr, png_const_bytep ptr, 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; ++#ifndef __COVERITY__ ++ if (safe_length == 0) ++ safe_length = (uInt)-1; /* evil, but safe */ ++#endif ++ ++ 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. ++ */ ++int ++png_user_version_check(png_structrp png_ptr, png_const_charp 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 = -1; ++ int found_dots = 0; ++ ++ do ++ { ++ i++; ++ if (user_png_ver[i] != PNG_LIBPNG_VER_STRING[i]) ++ png_ptr->flags |= PNG_FLAG_LIBRARY_MISMATCH; ++ 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) != 0) ++ { ++#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_STRING); ++ PNG_UNUSED(pos) ++ ++ png_warning(png_ptr, m); ++#endif ++ ++#ifdef PNG_ERROR_NUMBERS_SUPPORTED ++ png_ptr->flags = 0; ++#endif ++ ++ 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_infop PNGAPI +-png_create_info_struct(png_structp png_ptr) ++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)) ++# endif ++ { ++# ifdef PNG_SETJMP_SUPPORTED ++ /* 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; ++# 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_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); ++ 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))); + +-#ifdef PNG_USER_MEM_SUPPORTED +- info_ptr = (png_infop)png_create_struct_2(PNG_STRUCT_INFO, +- png_ptr->malloc_fn, png_ptr->mem_ptr); +-#else +- info_ptr = (png_infop)png_create_struct(PNG_STRUCT_INFO); +-#endif + if (info_ptr != NULL) +- png_info_init_3(&info_ptr, png_sizeof(png_info)); ++ memset(info_ptr, 0, (sizeof *info_ptr)); + +- return (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"); + +@@ -287,57 +397,60 @@ png_destroy_info_struct(png_structp png_ptr, png_infopp info_ptr_ptr) + + if (info_ptr != NULL) + { +- png_info_destroy(png_ptr, info_ptr); +- +-#ifdef PNG_USER_MEM_SUPPORTED +- png_destroy_struct_2((png_voidp)info_ptr, png_ptr->free_fn, +- png_ptr->mem_ptr); +-#else +- png_destroy_struct((png_voidp)info_ptr); +-#endif ++ /* 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. + */ +-#if defined(PNG_1_0_X) || defined(PNG_1_2_X) +-#undef png_info_init +-void PNGAPI +-png_info_init(png_infop info_ptr) +-{ +- /* We only come here via pre-1.0.12-compiled applications */ +- png_info_init_3(&info_ptr, 0); +-} +-#endif +- +-void PNGAPI +-png_info_init_3(png_infopp ptr_ptr, png_size_t png_info_struct_size) ++PNG_FUNCTION(void,PNGAPI ++png_info_init_3,(png_infopp ptr_ptr, 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))); ++ if (info_ptr == NULL) ++ return; + *ptr_ptr = info_ptr; + } + + /* Set everything to 0 */ +- png_memset(info_ptr, 0, png_sizeof(png_info)); ++ memset(info_ptr, 0, (sizeof *info_ptr)); + } + +-#ifdef PNG_FREE_ME_SUPPORTED ++/* The following API is not called internally */ + void PNGAPI +-png_data_freer(png_structp png_ptr, png_infop info_ptr, +- int freer, png_uint_32 mask) ++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"); + +@@ -346,17 +459,17 @@ png_data_freer(png_structp png_ptr, png_infop info_ptr, + + if (freer == PNG_DESTROY_WILL_FREE_DATA) + info_ptr->free_me |= mask; ++ + else if (freer == PNG_USER_WILL_FREE_DATA) + info_ptr->free_me &= ~mask; ++ + else +- png_warning(png_ptr, +- "Unknown freer parameter in png_data_freer."); ++ png_error(png_ptr, "Unknown freer parameter in png_data_freer"); + } +-#endif + + void PNGAPI +-png_free_data(png_structp png_ptr, png_infop info_ptr, png_uint_32 mask, +- int num) ++png_free_data(png_const_structrp png_ptr, png_inforp info_ptr, png_uint_32 mask, ++ int num) + { + png_debug(1, "in png_free_data"); + +@@ -365,87 +478,69 @@ png_free_data(png_structp png_ptr, png_infop info_ptr, png_uint_32 mask, + + #ifdef PNG_TEXT_SUPPORTED + /* Free text item num or (if num == -1) all text items */ +-#ifdef PNG_FREE_ME_SUPPORTED +- if ((mask & PNG_FREE_TEXT) & info_ptr->free_me) +-#else +- if (mask & PNG_FREE_TEXT) +-#endif ++ if (info_ptr->text != NULL && ++ ((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; ++ info_ptr->max_text = 0; + } + } + #endif + + #ifdef PNG_tRNS_SUPPORTED + /* Free any tRNS entry */ +-#ifdef PNG_FREE_ME_SUPPORTED +- if ((mask & PNG_FREE_TRNS) & info_ptr->free_me) +-#else +- if ((mask & PNG_FREE_TRNS) && (png_ptr->flags & PNG_FLAG_FREE_TRNS)) +-#endif ++ if (((mask & PNG_FREE_TRNS) & info_ptr->free_me) != 0) + { +- png_free(png_ptr, info_ptr->trans); +- info_ptr->trans = NULL; + info_ptr->valid &= ~PNG_INFO_tRNS; +-#ifndef PNG_FREE_ME_SUPPORTED +- png_ptr->flags &= ~PNG_FLAG_FREE_TRNS; +-#endif ++ png_free(png_ptr, info_ptr->trans_alpha); ++ info_ptr->trans_alpha = NULL; ++ info_ptr->num_trans = 0; + } + #endif + + #ifdef PNG_sCAL_SUPPORTED + /* Free any sCAL entry */ +-#ifdef PNG_FREE_ME_SUPPORTED +- if ((mask & PNG_FREE_SCAL) & info_ptr->free_me) +-#else +- if (mask & PNG_FREE_SCAL) +-#endif ++ if (((mask & PNG_FREE_SCAL) & info_ptr->free_me) != 0) + { +-#if defined(PNG_FIXED_POINT_SUPPORTED) && !defined(PNG_FLOATING_POINT_SUPPORTED) + png_free(png_ptr, info_ptr->scal_s_width); + png_free(png_ptr, info_ptr->scal_s_height); + info_ptr->scal_s_width = NULL; + info_ptr->scal_s_height = NULL; +-#endif + info_ptr->valid &= ~PNG_INFO_sCAL; + } + #endif + + #ifdef PNG_pCAL_SUPPORTED + /* Free any pCAL entry */ +-#ifdef PNG_FREE_ME_SUPPORTED +- if ((mask & PNG_FREE_PCAL) & info_ptr->free_me) +-#else +- if (mask & PNG_FREE_PCAL) +-#endif ++ 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; + } +@@ -454,12 +549,8 @@ png_free_data(png_structp png_ptr, png_infop info_ptr, png_uint_32 mask, + #endif + + #ifdef PNG_iCCP_SUPPORTED +- /* Free any iCCP entry */ +-#ifdef PNG_FREE_ME_SUPPORTED +- if ((mask & PNG_FREE_ICCP) & info_ptr->free_me) +-#else +- if (mask & PNG_FREE_ICCP) +-#endif ++ /* 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); +@@ -471,126 +562,108 @@ png_free_data(png_structp png_ptr, png_infop info_ptr, png_uint_32 mask, + + #ifdef PNG_sPLT_SUPPORTED + /* Free a given sPLT entry, or (if num == -1) all sPLT entries */ +-#ifdef PNG_FREE_ME_SUPPORTED +- if ((mask & PNG_FREE_SPLT) & info_ptr->free_me) +-#else +- if (mask & PNG_FREE_SPLT) +-#endif ++ if (info_ptr->splt_palettes != NULL && ++ ((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) +- { +- int i; +- for (i = 0; i < (int)info_ptr->splt_palettes_num; i++) +- png_free_data(png_ptr, info_ptr, PNG_FREE_SPLT, i); ++ int i; + +- png_free(png_ptr, info_ptr->splt_palettes); +- info_ptr->splt_palettes = NULL; +- info_ptr->splt_palettes_num = 0; ++ 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; ++ info_ptr->splt_palettes_num = 0; + info_ptr->valid &= ~PNG_INFO_sPLT; + } + } + #endif + +-#ifdef PNG_UNKNOWN_CHUNKS_SUPPORTED +- if (png_ptr->unknown_chunk.data) +- { +- png_free(png_ptr, png_ptr->unknown_chunk.data); +- png_ptr->unknown_chunk.data = NULL; +- } +- +-#ifdef PNG_FREE_ME_SUPPORTED +- if ((mask & PNG_FREE_UNKN) & info_ptr->free_me) +-#else +- if (mask & PNG_FREE_UNKN) +-#endif ++#ifdef PNG_STORE_UNKNOWN_CHUNKS_SUPPORTED ++ if (info_ptr->unknown_chunks != NULL && ++ ((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) +- { +- for (i = 0; i < (int)info_ptr->unknown_chunks_num; i++) +- png_free_data(png_ptr, info_ptr, PNG_FREE_UNKN, i); ++ for (i = 0; i < info_ptr->unknown_chunks_num; i++) ++ png_free(png_ptr, info_ptr->unknown_chunks[i].data); + +- png_free(png_ptr, info_ptr->unknown_chunks); +- info_ptr->unknown_chunks = NULL; +- info_ptr->unknown_chunks_num = 0; +- } ++ png_free(png_ptr, info_ptr->unknown_chunks); ++ info_ptr->unknown_chunks = NULL; ++ info_ptr->unknown_chunks_num = 0; ++ } ++ } ++#endif ++ ++#ifdef PNG_eXIf_SUPPORTED ++ /* Free any eXIf entry */ ++ if (((mask & PNG_FREE_EXIF) & info_ptr->free_me) != 0) ++ { ++# ifdef PNG_READ_eXIf_SUPPORTED ++ if (info_ptr->eXIf_buf) ++ { ++ png_free(png_ptr, info_ptr->eXIf_buf); ++ info_ptr->eXIf_buf = NULL; ++ } ++# endif ++ if (info_ptr->exif) ++ { ++ png_free(png_ptr, info_ptr->exif); ++ info_ptr->exif = NULL; + } ++ info_ptr->valid &= ~PNG_INFO_eXIf; + } + #endif + + #ifdef PNG_hIST_SUPPORTED + /* Free any hIST entry */ +-#ifdef PNG_FREE_ME_SUPPORTED +- if ((mask & PNG_FREE_HIST) & info_ptr->free_me) +-#else +- if ((mask & PNG_FREE_HIST) && (png_ptr->flags & PNG_FLAG_FREE_HIST)) +-#endif ++ if (((mask & PNG_FREE_HIST) & info_ptr->free_me) != 0) + { + png_free(png_ptr, info_ptr->hist); + info_ptr->hist = NULL; + info_ptr->valid &= ~PNG_INFO_hIST; +-#ifndef PNG_FREE_ME_SUPPORTED +- png_ptr->flags &= ~PNG_FLAG_FREE_HIST; +-#endif + } + #endif + + /* Free any PLTE entry that was internally allocated */ +-#ifdef PNG_FREE_ME_SUPPORTED +- if ((mask & PNG_FREE_PLTE) & info_ptr->free_me) +-#else +- if ((mask & PNG_FREE_PLTE) && (png_ptr->flags & PNG_FLAG_FREE_PLTE)) +-#endif ++ 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; +-#ifndef PNG_FREE_ME_SUPPORTED +- png_ptr->flags &= ~PNG_FLAG_FREE_PLTE; +-#endif + info_ptr->num_palette = 0; + } + + #ifdef PNG_INFO_IMAGE_SUPPORTED + /* Free any image bits attached to the info structure */ +-#ifdef PNG_FREE_ME_SUPPORTED +- if ((mask & PNG_FREE_ROWS) & info_ptr->free_me) +-#else +- if (mask & PNG_FREE_ROWS) +-#endif ++ if (((mask & PNG_FREE_ROWS) & info_ptr->free_me) != 0) + { +- if (info_ptr->row_pointers) ++ if (info_ptr->row_pointers != NULL) + { +- 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; + } +@@ -598,60 +671,36 @@ png_free_data(png_structp png_ptr, png_infop info_ptr, png_uint_32 mask, + } + #endif + +-#ifdef PNG_FREE_ME_SUPPORTED +- if (num == -1) +- info_ptr->free_me &= ~mask; +- else +- info_ptr->free_me &= ~(mask & ~PNG_FREE_MUL); +-#endif +-} +- +-/* This is an internal routine to free any memory that the info struct is +- * pointing to before re-using it or freeing the struct itself. Recall +- * that png_free() checks for NULL pointers for us. +- */ +-void /* PRIVATE */ +-png_info_destroy(png_structp png_ptr, png_infop info_ptr) +-{ +- png_debug(1, "in png_info_destroy"); +- +- png_free_data(png_ptr, info_ptr, PNG_FREE_ALL, -1); +- +-#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED +- if (png_ptr->num_chunk_list) +- { +- png_free(png_ptr, png_ptr->chunk_list); +- png_ptr->chunk_list = NULL; +- png_ptr->num_chunk_list = 0; +- } +-#endif ++ if (num != -1) ++ mask &= ~PNG_FREE_MUL; + +- png_info_init_3(&info_ptr, png_sizeof(png_info)); ++ info_ptr->free_me &= ~mask; + } +-#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); ++ + return (png_ptr->io_ptr); + } + + #if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED) +-#ifdef PNG_STDIO_SUPPORTED ++# ifdef PNG_STDIO_SUPPORTED + /* Initialize the default input/output functions for the PNG file. If you + * use your own read or write routines, you can call either png_set_read_fn() + * or png_set_write_fn() instead of png_init_io(). If you have defined +- * PNG_NO_STDIO, you must use a function of your own because "FILE *" isn't +- * necessarily available. ++ * 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"); + +@@ -660,81 +709,119 @@ png_init_io(png_structp png_ptr, png_FILE_p fp) + + png_ptr->io_ptr = (png_voidp)fp; + } +-#endif ++# endif ++ ++# ifdef PNG_SAVE_INT_32_SUPPORTED ++/* PNG signed integers are saved in 32-bit 2's complement format. ANSI C-90 ++ * defines a cast of a signed integer to an unsigned integer either to preserve ++ * the value, if it is positive, or to calculate: ++ * ++ * (UNSIGNED_MAX+1) + integer ++ * ++ * Where UNSIGNED_MAX is the appropriate maximum unsigned value, so when the ++ * negative integral value is added the result will be an unsigned value ++ * correspnding to the 2's complement representation. ++ */ ++void PNGAPI ++png_save_int_32(png_bytep buf, png_int_32 i) ++{ ++ png_save_uint_32(buf, (png_uint_32)i); ++} ++# endif + +-#ifdef PNG_TIME_RFC1123_SUPPORTED ++# ifdef PNG_TIME_RFC1123_SUPPORTED + /* Convert the supplied time into an RFC 1123 string suitable for use in + * a "Creation Time" or other text-based time string. + */ +-png_charp PNGAPI +-png_convert_to_rfc1123(png_structp png_ptr, png_timep ptime) ++int PNGAPI ++png_convert_to_rfc1123_buffer(char out[29], png_const_timep ptime) + { +- static PNG_CONST char short_months[12][4] = ++ static const char short_months[12][4] = + {"Jan", "Feb", "Mar", "Apr", "May", "Jun", + "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"}; + +- if (png_ptr == NULL) +- return (NULL); +- if (png_ptr->time_buffer == NULL) +- { +- png_ptr->time_buffer = (png_charp)png_malloc(png_ptr, (png_uint_32)(29* +- png_sizeof(char))); +- } ++ 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; + +-#ifdef _WIN32_WCE + { +- wchar_t time_buf[29]; +- wsprintf(time_buf, TEXT("%d %S %d %02d:%02d:%02d +0000"), +- ptime->day % 32, short_months[(ptime->month - 1) % 12], +- ptime->year, ptime->hour % 24, ptime->minute % 60, +- ptime->second % 61); +- WideCharToMultiByte(CP_ACP, 0, time_buf, -1, png_ptr->time_buffer, +- 29, NULL, NULL); ++ size_t pos = 0; ++ 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 < 28) out[pos++] = (ch) ++ ++ APPEND_NUMBER(PNG_NUMBER_FORMAT_u, (unsigned)ptime->day); ++ APPEND(' '); ++ 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); ++ APPEND(':'); ++ APPEND_NUMBER(PNG_NUMBER_FORMAT_02u, (unsigned)ptime->minute); ++ APPEND(':'); ++ APPEND_NUMBER(PNG_NUMBER_FORMAT_02u, (unsigned)ptime->second); ++ APPEND_STRING(" +0000"); /* This reliably terminates the buffer */ ++ PNG_UNUSED (pos) ++ ++# undef APPEND ++# undef APPEND_NUMBER ++# undef APPEND_STRING + } +-#else +-#ifdef USE_FAR_KEYWORD ++ ++ return 1; ++} ++ ++# 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_convert_to_rfc1123(png_structrp png_ptr, png_const_timep ptime) ++{ ++ if (png_ptr != NULL) + { +- char near_time_buf[29]; +- png_snprintf6(near_time_buf, 29, "%d %s %d %02d:%02d:%02d +0000", +- ptime->day % 32, short_months[(ptime->month - 1) % 12], +- ptime->year, ptime->hour % 24, ptime->minute % 60, +- ptime->second % 61); +- png_memcpy(png_ptr->time_buffer, near_time_buf, +- 29*png_sizeof(char)); ++ /* 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; + } +-#else +- png_snprintf6(png_ptr->time_buffer, 29, "%d %s %d %02d:%02d:%02d +0000", +- ptime->day % 32, short_months[(ptime->month - 1) % 12], +- ptime->year, ptime->hour % 24, ptime->minute % 60, +- ptime->second % 61); +-#endif +-#endif /* _WIN32_WCE */ +- return ((png_charp)png_ptr->time_buffer); ++ ++ return NULL; + } +-#endif /* PNG_TIME_RFC1123_SUPPORTED */ ++# endif /* LIBPNG_VER < 10700 */ ++# endif /* TIME_RFC1123 */ + +-#endif /* defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED) */ ++#endif /* READ || WRITE */ + +-png_charp PNGAPI +-png_get_copyright(png_structp png_ptr) ++png_const_charp PNGAPI ++png_get_copyright(png_const_structrp png_ptr) + { +- png_ptr = png_ptr; /* Silence compiler warning about unused png_ptr */ ++ PNG_UNUSED(png_ptr) /* Silence compiler warning about unused png_ptr */ + #ifdef PNG_STRING_COPYRIGHT +- return PNG_STRING_COPYRIGHT +-#else +-#ifdef __STDC__ +- return ((png_charp) PNG_STRING_NEWLINE \ +- "libpng version 1.2.44 - June 26, 2010" PNG_STRING_NEWLINE \ +- "Copyright (c) 1998-2010 Glenn Randers-Pehrson" PNG_STRING_NEWLINE \ +- "Copyright (c) 1996-1997 Andreas Dilger" PNG_STRING_NEWLINE \ +- "Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc." \ +- PNG_STRING_NEWLINE); ++ return PNG_STRING_COPYRIGHT + #else +- return ((png_charp) "libpng version 1.2.44 - June 26, 2010\ +- Copyright (c) 1998-2010 Glenn Randers-Pehrson\ +- Copyright (c) 1996-1997 Andreas Dilger\ +- Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc."); +-#endif ++ return PNG_STRING_NEWLINE \ ++ "libpng version 1.6.36" PNG_STRING_NEWLINE \ ++ "Copyright (c) 2018 Cosmin Truta" PNG_STRING_NEWLINE \ ++ "Copyright (c) 1998-2002,2004,2006-2018 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; + #endif + } + +@@ -746,355 +833,3774 @@ png_get_copyright(png_structp png_ptr) + * png_get_header_ver(). Due to the version_nn_nn_nn typedef guard, + * it is guaranteed that png.c uses the correct version of png.h. + */ +-png_charp PNGAPI +-png_get_libpng_ver(png_structp png_ptr) ++png_const_charp PNGAPI ++png_get_libpng_ver(png_const_structrp png_ptr) + { + /* Version of *.c files used when building libpng */ +- png_ptr = png_ptr; /* Silence compiler warning about unused png_ptr */ +- return ((png_charp) PNG_LIBPNG_VER_STRING); ++ return png_get_header_ver(png_ptr); + } + +-png_charp PNGAPI +-png_get_header_ver(png_structp png_ptr) ++png_const_charp PNGAPI ++png_get_header_ver(png_const_structrp png_ptr) + { + /* Version of *.h files used when building libpng */ +- png_ptr = png_ptr; /* Silence compiler warning about unused png_ptr */ +- return ((png_charp) PNG_LIBPNG_VER_STRING); ++ PNG_UNUSED(png_ptr) /* Silence compiler warning about unused png_ptr */ ++ return PNG_LIBPNG_VER_STRING; + } + +-png_charp PNGAPI +-png_get_header_version(png_structp png_ptr) ++png_const_charp PNGAPI ++png_get_header_version(png_const_structrp png_ptr) + { + /* Returns longer string containing both version and date */ +- png_ptr = png_ptr; /* Silence compiler warning about unused png_ptr */ ++ PNG_UNUSED(png_ptr) /* Silence compiler warning about unused png_ptr */ + #ifdef __STDC__ +- return ((png_charp) PNG_HEADER_VERSION_STRING +-#ifndef PNG_READ_SUPPORTED +- " (NO READ SUPPORT)" +-#endif +- PNG_STRING_NEWLINE); ++ return PNG_HEADER_VERSION_STRING ++# ifndef PNG_READ_SUPPORTED ++ " (NO READ SUPPORT)" ++# endif ++ PNG_STRING_NEWLINE; + #else +- return ((png_charp) PNG_HEADER_VERSION_STRING); ++ return PNG_HEADER_VERSION_STRING; + #endif + } + +-#if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED) +-#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED +-int PNGAPI +-png_handle_as_unknown(png_structp png_ptr, png_bytep chunk_name) ++#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) + { +- /* Check chunk_name and return "keep" value if it's on the list, else 0 */ ++ int num_palette; ++ int color_inc; + 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; ++ 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 & 0xff); ++ palette[i].green = (png_byte)(v & 0xff); ++ palette[i].blue = (png_byte)(v & 0xff); ++ } + } + #endif + ++#ifdef PNG_SET_UNKNOWN_CHUNKS_SUPPORTED ++int PNGAPI ++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 */ ++ 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 correctly. ++ */ ++ 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; ++} ++ ++#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 /* defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED) */ ++#endif /* READ */ + + /* This function was added to libpng-1.0.7 */ + png_uint_32 PNGAPI + png_access_version_number(void) + { + /* Version of *.c files used when building libpng */ +- return((png_uint_32) PNG_LIBPNG_VER); ++ return((png_uint_32)PNG_LIBPNG_VER); + } + +- +-#if defined(PNG_READ_SUPPORTED) && defined(PNG_ASSEMBLER_CODE_SUPPORTED) +-#ifndef PNG_1_0_X +-/* This function was added to libpng 1.2.0 */ +-int PNGAPI +-png_mmx_support(void) ++#if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED) ++/* 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) + { +- /* Obsolete, to be removed from libpng-1.4.0 */ +- return -1; ++ /* 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_1_0_X */ +-#endif /* PNG_READ_SUPPORTED && PNG_ASSEMBLER_CODE_SUPPORTED */ + +-#if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED) +-#ifdef PNG_SIZE_T +-/* Added at libpng version 1.2.6 */ +- PNG_EXTERN png_size_t PNGAPI png_convert_size PNGARG((size_t size)); +-png_size_t PNGAPI +-png_convert_size(size_t size) ++/* 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_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(>est, 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 asymmetrical 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 /* GAMMA */ ++ ++#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). We check ++ * xy->whitey against 5, not 0, to avoid a possible integer overflow. ++ */ ++ 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 < 5 || 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_colorspace_set_chromaticities(png_const_structrp png_ptr, ++ png_colorspacerp colorspace, const png_xy *xy, int preferred) ++{ ++ /* 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"); ++ } ++ ++ 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"); ++ } ++ ++ 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; ++ ++ /* 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 (intent < 0 || intent >= PNG_sRGB_INTENT_LAST) ++ return png_icc_profile_error(png_ptr, colorspace, "sRGB", ++ (png_alloc_size_t)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", ++ (png_alloc_size_t)intent, "inconsistent rendering intents"); ++ ++ if ((colorspace->flags & PNG_COLORSPACE_FROM_sRGB) != 0) ++ { ++ png_benign_error(png_ptr, "duplicate sRGB information ignored"); ++ return 0; ++ } ++ ++ /* 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 }; ++ ++static int /* bool */ ++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; ++} ++ ++#ifdef PNG_READ_iCCP_SUPPORTED ++int /* PRIVATE */ ++png_icc_check_length(png_const_structrp png_ptr, png_colorspacerp colorspace, ++ png_const_charp name, png_uint_32 profile_length) ++{ ++ if (!icc_check_length(png_ptr, colorspace, name, profile_length)) ++ return 0; ++ ++ /* This needs to be here because the 'normal' check is in ++ * png_decompress_chunk, yet this happens after the attempt to ++ * png_malloc_base the required data. We only need this on read; on write ++ * the caller supplies the profile buffer so libpng doesn't allocate it. See ++ * the call to icc_check_length below (the write case). ++ */ ++# ifdef PNG_SET_USER_LIMITS_SUPPORTED ++ else if (png_ptr->user_chunk_malloc_max > 0 && ++ png_ptr->user_chunk_malloc_max < profile_length) ++ return png_icc_profile_error(png_ptr, colorspace, name, profile_length, ++ "exceeds application limits"); ++# elif PNG_USER_CHUNK_MALLOC_MAX > 0 ++ else if (PNG_USER_CHUNK_MALLOC_MAX < profile_length) ++ return png_icc_profile_error(png_ptr, colorspace, name, profile_length, ++ "exceeds libpng limits"); ++# else /* !SET_USER_LIMITS */ ++ /* This will get compiled out on all 32-bit and better systems. */ ++ else if (PNG_SIZE_MAX < profile_length) ++ return png_icc_profile_error(png_ptr, colorspace, name, profile_length, ++ "exceeds system limits"); ++# endif /* !SET_USER_LIMITS */ ++ ++ return 1; ++} ++#endif /* READ_iCCP */ ++ ++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 accommodate 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) ++ { ++ 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"); ++ } ++ ++ /* 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) ++ { ++ 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; ++ } ++ ++ /* 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) ++ { ++ case 0x58595a20: /* 'XYZ ' */ ++ case 0x4c616220: /* 'Lab ' */ ++ break; ++ ++ default: ++ return png_icc_profile_error(png_ptr, colorspace, name, temp, ++ "unexpected ICC PCS encoding"); ++ } ++ ++ 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_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. ++ */ ++ ++ /* 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"); ++ ++ 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"); ++ } ++ } ++ ++ return 1; /* success, maybe with warnings */ ++} ++ ++#ifdef PNG_sRGB_SUPPORTED ++#if 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) ++ { ++ 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_uint_32) png_sRGB_checks[i].length && ++ intent == (png_uint_32) 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 0; /* no match */ ++} ++ ++void /* PRIVATE */ ++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_compare_ICC_profile_with_sRGB(png_ptr, profile, adler) != 0) ++ (void)png_colorspace_set_sRGB(png_ptr, colorspace, ++ (int)/*already checked*/png_get_uint_32(profile+64)); ++} ++#endif /* PNG_sRGB_PROFILE_CHECKS >= 0 */ ++#endif /* 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 (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) ++ { ++# if defined(PNG_sRGB_SUPPORTED) && PNG_sRGB_PROFILE_CHECKS >= 0 ++ /* 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 /* READ_RGB_TO_GRAY */ ++ ++#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) ++{ ++ int error = 0; ++ ++ /* Check for width and height valid values */ ++ if (width == 0) ++ { ++ png_warning(png_ptr, "Image width is zero in IHDR"); ++ error = 1; ++ } ++ ++ if (width > PNG_UINT_31_MAX) ++ { ++ png_warning(png_ptr, "Invalid image width in IHDR"); ++ error = 1; ++ } ++ ++ if (png_gt(((width + 7) & (~7U)), ++ ((PNG_SIZE_MAX ++ - 48 /* big_row_buf hack */ ++ - 1) /* filter byte */ ++ / 8) /* 8-byte RGBA pixels */ ++ - 1)) /* 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; ++ } ++ ++#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; ++ } ++ ++ if (height > PNG_UINT_31_MAX) ++ { ++ png_warning(png_ptr, "Invalid image height 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; ++ } ++ ++ /* Check other values */ ++ if (bit_depth != 1 && bit_depth != 2 && bit_depth != 4 && ++ bit_depth != 8 && bit_depth != 16) ++ { ++ png_warning(png_ptr, "Invalid bit depth in IHDR"); ++ error = 1; ++ } ++ ++ if (color_type < 0 || color_type == 1 || ++ color_type == 5 || color_type > 6) ++ { ++ png_warning(png_ptr, "Invalid color type in IHDR"); ++ error = 1; ++ } ++ ++ if (((color_type == PNG_COLOR_TYPE_PALETTE) && bit_depth > 8) || ++ ((color_type == PNG_COLOR_TYPE_RGB || ++ color_type == PNG_COLOR_TYPE_GRAY_ALPHA || ++ color_type == PNG_COLOR_TYPE_RGB_ALPHA) && bit_depth < 8)) ++ { ++ png_warning(png_ptr, "Invalid color type/bit depth combination in IHDR"); ++ error = 1; ++ } ++ ++ if (interlace_type >= PNG_INTERLACE_LAST) ++ { ++ png_warning(png_ptr, "Unknown interlace method in IHDR"); ++ error = 1; ++ } ++ ++ if (compression_type != PNG_COMPRESSION_TYPE_BASE) ++ { ++ png_warning(png_ptr, "Unknown compression method in IHDR"); ++ error = 1; ++ } ++ ++#ifdef PNG_MNG_FEATURES_SUPPORTED ++ /* Accept filter_method 64 (intrapixel differencing) only if ++ * 1. Libpng was compiled with PNG_MNG_FEATURES_SUPPORTED and ++ * 2. Libpng did not read a PNG signature (this filter_method is only ++ * used in PNG datastreams that are embedded in MNG datastreams) and ++ * 3. The application called png_permit_mng_features with a mask that ++ * included PNG_FLAG_MNG_FILTER_64 and ++ * 4. The filter_method is 64 and ++ * 5. The color_type is RGB or RGBA ++ */ ++ if ((png_ptr->mode & PNG_HAVE_PNG_SIGNATURE) != 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) != 0 && ++ (filter_type == PNG_INTRAPIXEL_DIFFERENCING) && ++ ((png_ptr->mode & PNG_HAVE_PNG_SIGNATURE) == 0) && ++ (color_type == PNG_COLOR_TYPE_RGB || ++ color_type == PNG_COLOR_TYPE_RGB_ALPHA))) ++ { ++ png_warning(png_ptr, "Unknown filter method in IHDR"); ++ error = 1; ++ } ++ ++ if ((png_ptr->mode & PNG_HAVE_PNG_SIGNATURE) != 0) ++ { ++ png_warning(png_ptr, "Invalid filter method in IHDR"); ++ error = 1; ++ } ++ } ++ ++#else ++ if (filter_type != PNG_FILTER_TYPE_BASE) ++ { ++ png_warning(png_ptr, "Unknown filter method in IHDR"); ++ error = 1; ++ } ++#endif ++ ++ if (error == 1) ++ png_error(png_ptr, "Invalid IHDR data"); ++} ++ ++#if defined(PNG_sCAL_SUPPORTED) || defined(PNG_pCAL_SUPPORTED) ++/* ASCII to fp functions */ ++/* Check an ASCII formatted floating point value, see the more detailed ++ * comments in pngpriv.h ++ */ ++/* The following is used internally to preserve the sticky flags */ ++#define png_fp_add(state, flags) ((state) |= (flags)) ++#define png_fp_set(state, value) ((state) = (value) | ((state) & PNG_FP_STICKY)) ++ ++int /* PRIVATE */ ++png_check_fp_number(png_const_charp string, size_t size, int *statep, ++ png_size_tp whereami) ++{ ++ int state = *statep; ++ size_t i = *whereami; ++ ++ while (i < size) ++ { ++ int type; ++ /* First find the type of the next character */ ++ switch (string[i]) ++ { ++ case 43: type = PNG_FP_SAW_SIGN; break; ++ case 45: type = PNG_FP_SAW_SIGN + PNG_FP_NEGATIVE; break; ++ case 46: type = PNG_FP_SAW_DOT; break; ++ case 48: type = PNG_FP_SAW_DIGIT; break; ++ case 49: case 50: case 51: case 52: ++ case 53: case 54: case 55: case 56: ++ case 57: type = PNG_FP_SAW_DIGIT + PNG_FP_NONZERO; break; ++ case 69: ++ case 101: type = PNG_FP_SAW_E; break; ++ default: goto PNG_FP_End; ++ } ++ ++ /* Now deal with this type according to the current ++ * state, the type is arranged to not overlap the ++ * bits of the PNG_FP_STATE. ++ */ ++ switch ((state & PNG_FP_STATE) + (type & PNG_FP_SAW_ANY)) ++ { ++ case PNG_FP_INTEGER + PNG_FP_SAW_SIGN: ++ if ((state & PNG_FP_SAW_ANY) != 0) ++ goto PNG_FP_End; /* not a part of the number */ ++ ++ png_fp_add(state, type); ++ break; ++ ++ case PNG_FP_INTEGER + PNG_FP_SAW_DOT: ++ /* Ok as trailer, ok as lead of fraction. */ ++ if ((state & PNG_FP_SAW_DOT) != 0) /* two dots */ ++ goto PNG_FP_End; ++ ++ else if ((state & PNG_FP_SAW_DIGIT) != 0) /* trailing dot? */ ++ png_fp_add(state, type); ++ ++ else ++ png_fp_set(state, PNG_FP_FRACTION | type); ++ ++ break; ++ ++ case PNG_FP_INTEGER + PNG_FP_SAW_DIGIT: ++ 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); ++ ++ break; ++ ++ case PNG_FP_INTEGER + PNG_FP_SAW_E: ++ if ((state & PNG_FP_SAW_DIGIT) == 0) ++ goto PNG_FP_End; ++ ++ png_fp_set(state, PNG_FP_EXPONENT); ++ ++ break; ++ ++ /* case PNG_FP_FRACTION + PNG_FP_SAW_SIGN: ++ goto PNG_FP_End; ** no sign in fraction */ ++ ++ /* case PNG_FP_FRACTION + PNG_FP_SAW_DOT: ++ goto PNG_FP_End; ** Because SAW_DOT is always set */ ++ ++ case PNG_FP_FRACTION + PNG_FP_SAW_DIGIT: ++ png_fp_add(state, type | PNG_FP_WAS_VALID); ++ break; ++ ++ case PNG_FP_FRACTION + PNG_FP_SAW_E: ++ /* This is correct because the trailing '.' on an ++ * integer is handled above - so we can only get here ++ * with the sequence ".E" (with no preceding digits). ++ */ ++ if ((state & PNG_FP_SAW_DIGIT) == 0) ++ goto PNG_FP_End; ++ ++ png_fp_set(state, PNG_FP_EXPONENT); ++ ++ break; ++ ++ case PNG_FP_EXPONENT + PNG_FP_SAW_SIGN: ++ 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); ++ ++ break; ++ ++ /* case PNG_FP_EXPONENT + PNG_FP_SAW_DOT: ++ goto PNG_FP_End; */ ++ ++ case PNG_FP_EXPONENT + PNG_FP_SAW_DIGIT: ++ png_fp_add(state, PNG_FP_SAW_DIGIT | PNG_FP_WAS_VALID); ++ ++ break; ++ ++ /* case PNG_FP_EXPONEXT + PNG_FP_SAW_E: ++ goto PNG_FP_End; */ ++ ++ default: goto PNG_FP_End; /* I.e. break 2 */ ++ } ++ ++ /* The character seems ok, continue. */ ++ ++i; ++ } ++ ++PNG_FP_End: ++ /* Here at the end, update the state and return the correct ++ * return code. ++ */ ++ *statep = state; ++ *whereami = i; ++ ++ return (state & PNG_FP_SAW_DIGIT) != 0; ++} ++ ++ ++/* The same but for a complete string. */ ++int ++png_check_fp_string(png_const_charp string, size_t size) ++{ ++ int state=0; ++ size_t char_index=0; ++ ++ 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 || sCAL */ ++ ++#ifdef PNG_sCAL_SUPPORTED ++# ifdef PNG_FLOATING_POINT_SUPPORTED ++/* Utility used below - a simple accurate power of ten from an integral ++ * exponent. ++ */ ++static double ++png_pow10(int power) ++{ ++ int recip = 0; ++ double d = 1; ++ ++ /* Handle negative exponent with a reciprocal at the end because ++ * 10 is exact whereas .1 is inexact in base 2 ++ */ ++ if (power < 0) ++ { ++ if (power < DBL_MIN_10_EXP) return 0; ++ recip = 1; power = -power; ++ } ++ ++ if (power > 0) ++ { ++ /* Decompose power bitwise. */ ++ double mult = 10; ++ do ++ { ++ if (power & 1) d *= mult; ++ mult *= mult; ++ power >>= 1; ++ } ++ while (power > 0); ++ ++ if (recip != 0) d = 1/d; ++ } ++ /* else power is 0 and d is 1 */ ++ ++ return d; ++} ++ ++/* Function to format a floating point value in ASCII with a given ++ * precision. ++ */ ++#if GCC_STRICT_OVERFLOW ++#pragma GCC diagnostic push ++/* The problem arises below with exp_b10, which can never overflow because it ++ * comes, originally, from frexp and is therefore limited to a range which is ++ * typically +/-710 (log2(DBL_MAX)/log2(DBL_MIN)). ++ */ ++#pragma GCC diagnostic warning "-Wstrict-overflow=2" ++#endif /* GCC_STRICT_OVERFLOW */ ++void /* PRIVATE */ ++png_ascii_from_fp(png_const_structrp png_ptr, png_charp ascii, size_t size, ++ double fp, unsigned int precision) ++{ ++ /* We use standard functions from math.h, but not printf because ++ * that would require stdio. The caller must supply a buffer of ++ * sufficient size or we will png_error. The tests on size and ++ * the space in ascii[] consumed are indicated below. ++ */ ++ if (precision < 1) ++ precision = DBL_DIG; ++ ++ /* Enforce the limit of the implementation precision too. */ ++ if (precision > DBL_DIG+1) ++ precision = DBL_DIG+1; ++ ++ /* Basic sanity checks */ ++ if (size >= precision+5) /* See the requirements below. */ ++ { ++ if (fp < 0) ++ { ++ fp = -fp; ++ *ascii++ = 45; /* '-' PLUS 1 TOTAL 1 */ ++ --size; ++ } ++ ++ if (fp >= DBL_MIN && fp <= DBL_MAX) ++ { ++ int exp_b10; /* A base 10 exponent */ ++ double base; /* 10^exp_b10 */ ++ ++ /* First extract a base 10 exponent of the number, ++ * the calculation below rounds down when converting ++ * from base 2 to base 10 (multiply by log10(2) - ++ * 0.3010, but 77/256 is 0.3008, so exp_b10 needs to ++ * be increased. Note that the arithmetic shift ++ * performs a floor() unlike C arithmetic - using a ++ * C multiply would break the following for negative ++ * exponents. ++ */ ++ (void)frexp(fp, &exp_b10); /* exponent to base 2 */ ++ ++ exp_b10 = (exp_b10 * 77) >> 8; /* <= exponent to base 10 */ ++ ++ /* Avoid underflow here. */ ++ base = png_pow10(exp_b10); /* May underflow */ ++ ++ while (base < DBL_MIN || base < fp) ++ { ++ /* And this may overflow. */ ++ double test = png_pow10(exp_b10+1); ++ ++ if (test <= DBL_MAX) ++ { ++ ++exp_b10; base = test; ++ } ++ ++ else ++ break; ++ } ++ ++ /* Normalize fp and correct exp_b10, after this fp is in the ++ * range [.1,1) and exp_b10 is both the exponent and the digit ++ * *before* which the decimal point should be inserted ++ * (starting with 0 for the first digit). Note that this ++ * works even if 10^exp_b10 is out of range because of the ++ * test on DBL_MAX above. ++ */ ++ fp /= base; ++ while (fp >= 1) ++ { ++ fp /= 10; ++exp_b10; ++ } ++ ++ /* Because of the code above fp may, at this point, be ++ * less than .1, this is ok because the code below can ++ * handle the leading zeros this generates, so no attempt ++ * is made to correct that here. ++ */ ++ ++ { ++ unsigned int czero, clead, cdigits; ++ char exponent[10]; ++ ++ /* Allow up to two leading zeros - this will not lengthen ++ * the number compared to using E-n. ++ */ ++ if (exp_b10 < 0 && exp_b10 > -3) /* PLUS 3 TOTAL 4 */ ++ { ++ czero = 0U-exp_b10; /* PLUS 2 digits: TOTAL 3 */ ++ exp_b10 = 0; /* Dot added below before first output. */ ++ } ++ else ++ czero = 0; /* No zeros to add */ ++ ++ /* Generate the digit list, stripping trailing zeros and ++ * inserting a '.' before a digit if the exponent is 0. ++ */ ++ clead = czero; /* Count of leading zeros */ ++ cdigits = 0; /* Count of digits in list. */ ++ ++ do ++ { ++ double d; ++ ++ fp *= 10; ++ /* Use modf here, not floor and subtract, so that ++ * the separation is done in one step. At the end ++ * of the loop don't break the number into parts so ++ * that the final digit is rounded. ++ */ ++ if (cdigits+czero+1 < precision+clead) ++ fp = modf(fp, &d); ++ ++ else ++ { ++ d = floor(fp + .5); ++ ++ if (d > 9) ++ { ++ /* Rounding up to 10, handle that here. */ ++ if (czero > 0) ++ { ++ --czero; d = 1; ++ if (cdigits == 0) --clead; ++ } ++ else ++ { ++ while (cdigits > 0 && d > 9) ++ { ++ int ch = *--ascii; ++ ++ if (exp_b10 != (-1)) ++ ++exp_b10; ++ ++ else if (ch == 46) ++ { ++ ch = *--ascii; ++size; ++ /* Advance exp_b10 to '1', so that the ++ * decimal point happens after the ++ * previous digit. ++ */ ++ exp_b10 = 1; ++ } ++ ++ --cdigits; ++ d = ch - 47; /* I.e. 1+(ch-48) */ ++ } ++ ++ /* Did we reach the beginning? If so adjust the ++ * exponent but take into account the leading ++ * decimal point. ++ */ ++ if (d > 9) /* cdigits == 0 */ ++ { ++ if (exp_b10 == (-1)) ++ { ++ /* Leading decimal point (plus zeros?), if ++ * we lose the decimal point here it must ++ * be reentered below. ++ */ ++ int ch = *--ascii; ++ ++ if (ch == 46) ++ { ++ ++size; exp_b10 = 1; ++ } ++ ++ /* Else lost a leading zero, so 'exp_b10' is ++ * still ok at (-1) ++ */ ++ } ++ else ++ ++exp_b10; ++ ++ /* In all cases we output a '1' */ ++ d = 1; ++ } ++ } ++ } ++ fp = 0; /* Guarantees termination below. */ ++ } ++ ++ if (d == 0) ++ { ++ ++czero; ++ if (cdigits == 0) ++clead; ++ } ++ else ++ { ++ /* Included embedded zeros in the digit count. */ ++ cdigits += czero - clead; ++ clead = 0; ++ ++ while (czero > 0) ++ { ++ /* exp_b10 == (-1) means we just output the decimal ++ * place - after the DP don't adjust 'exp_b10' any ++ * more! ++ */ ++ if (exp_b10 != (-1)) ++ { ++ if (exp_b10 == 0) ++ { ++ *ascii++ = 46; --size; ++ } ++ /* PLUS 1: TOTAL 4 */ ++ --exp_b10; ++ } ++ *ascii++ = 48; --czero; ++ } ++ ++ if (exp_b10 != (-1)) ++ { ++ if (exp_b10 == 0) ++ { ++ *ascii++ = 46; --size; /* counted above */ ++ } ++ ++ --exp_b10; ++ } ++ *ascii++ = (char)(48 + (int)d); ++cdigits; ++ } ++ } ++ while (cdigits+czero < precision+clead && fp > DBL_MIN); ++ ++ /* The total output count (max) is now 4+precision */ ++ ++ /* Check for an exponent, if we don't need one we are ++ * done and just need to terminate the string. At this ++ * point, exp_b10==(-1) is effectively a flag: it got ++ * to '-1' because of the decrement, after outputting ++ * the decimal point above. (The exponent required is ++ * *not* -1.) ++ */ ++ if (exp_b10 >= (-1) && exp_b10 <= 2) ++ { ++ /* The following only happens if we didn't output the ++ * leading zeros above for negative exponent, so this ++ * doesn't add to the digit requirement. Note that the ++ * two zeros here can only be output if the two leading ++ * zeros were *not* output, so this doesn't increase ++ * the output count. ++ */ ++ while (exp_b10-- > 0) *ascii++ = 48; ++ ++ *ascii = 0; ++ ++ /* Total buffer requirement (including the '\0') is ++ * 5+precision - see check at the start. ++ */ ++ return; ++ } ++ ++ /* Here if an exponent is required, adjust size for ++ * the digits we output but did not count. The total ++ * digit output here so far is at most 1+precision - no ++ * decimal point and no leading or trailing zeros have ++ * been output. ++ */ ++ size -= cdigits; ++ ++ *ascii++ = 69; --size; /* 'E': PLUS 1 TOTAL 2+precision */ ++ ++ /* 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. ++ */ ++ { ++ unsigned int uexp_b10; ++ ++ if (exp_b10 < 0) ++ { ++ *ascii++ = 45; --size; /* '-': PLUS 1 TOTAL 3+precision */ ++ uexp_b10 = 0U-exp_b10; ++ } ++ ++ else ++ uexp_b10 = 0U+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 ++ * this need not be considered above. ++ */ ++ if (size > cdigits) ++ { ++ while (cdigits > 0) *ascii++ = exponent[--cdigits]; ++ ++ *ascii = 0; ++ ++ return; ++ } ++ } ++ } ++ else if (!(fp >= DBL_MIN)) ++ { ++ *ascii++ = 48; /* '0' */ ++ *ascii = 0; ++ return; ++ } ++ else ++ { ++ *ascii++ = 105; /* 'i' */ ++ *ascii++ = 110; /* 'n' */ ++ *ascii++ = 102; /* 'f' */ ++ *ascii = 0; ++ return; ++ } ++ } ++ ++ /* Here on buffer too small. */ ++ png_error(png_ptr, "ASCII conversion buffer too small"); ++} ++#if GCC_STRICT_OVERFLOW ++#pragma GCC diagnostic pop ++#endif /* GCC_STRICT_OVERFLOW */ ++ ++# endif /* FLOATING_POINT */ ++ ++# ifdef PNG_FIXED_POINT_SUPPORTED ++/* Function to format a fixed point value in ASCII. ++ */ ++void /* PRIVATE */ ++png_ascii_from_fixed(png_const_structrp png_ptr, png_charp ascii, ++ 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: ++ */ ++ if (size > 12) ++ { ++ png_uint_32 num; ++ ++ /* Avoid overflow here on the minimum integer. */ ++ if (fp < 0) ++ { ++ *ascii++ = 45; num = (png_uint_32)(-fp); ++ } ++ else ++ num = (png_uint_32)fp; ++ ++ if (num <= 0x80000000) /* else overflowed */ ++ { ++ unsigned int ndigits = 0, first = 16 /* flag value */; ++ char digits[10]; ++ ++ while (num) ++ { ++ /* Split the low digit off num: */ ++ unsigned int tmp = num/10; ++ num -= tmp*10; ++ digits[ndigits++] = (char)(48 + num); ++ /* Record the first non-zero digit, note that this is a number ++ * starting at 1, it's not actually the array index. ++ */ ++ if (first == 16 && num > 0) ++ first = ndigits; ++ num = tmp; ++ } ++ ++ if (ndigits > 0) ++ { ++ while (ndigits > 5) *ascii++ = digits[--ndigits]; ++ /* The remaining digits are fractional digits, ndigits is '5' or ++ * smaller at this point. It is certainly not zero. Check for a ++ * non-zero fractional digit: ++ */ ++ if (first <= 5) ++ { ++ unsigned int i; ++ *ascii++ = 46; /* decimal point */ ++ /* ndigits may be <5 for small numbers, output leading zeros ++ * then ndigits digits to first: ++ */ ++ i = 5; ++ while (ndigits < i) ++ { ++ *ascii++ = 48; --i; ++ } ++ while (ndigits >= first) *ascii++ = digits[--ndigits]; ++ /* Don't output the trailing zeros! */ ++ } ++ } ++ else ++ *ascii++ = 48; ++ ++ /* And null terminate the string: */ ++ *ascii = 0; ++ return; ++ } ++ } ++ ++ /* Here on buffer too small. */ ++ png_error(png_ptr, "ASCII conversion buffer too small"); ++} ++# endif /* FIXED_POINT */ ++#endif /* SCAL */ ++ ++#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_fixed_point ++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_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 ++ * the nearest .00001). Overflow and divide by zero are signalled in ++ * the result, a boolean - true on success, false on overflow. ++ */ ++#if GCC_STRICT_OVERFLOW /* from above */ ++/* It is not obvious which comparison below gets optimized in such a way that ++ * signed overflow would change the result; looking through the code does not ++ * reveal any tests which have the form GCC complains about, so presumably the ++ * optimizer is moving an add or subtract into the 'if' somewhere. ++ */ ++#pragma GCC diagnostic push ++#pragma GCC diagnostic warning "-Wstrict-overflow=2" ++#endif /* GCC_STRICT_OVERFLOW */ ++int ++png_muldiv(png_fixed_point_p res, png_fixed_point a, png_int_32 times, ++ png_int_32 divisor) ++{ ++ /* Return a * times / divisor, rounded. */ ++ if (divisor != 0) ++ { ++ if (a == 0 || times == 0) ++ { ++ *res = 0; ++ return 1; ++ } ++ else ++ { ++#ifdef PNG_FLOATING_ARITHMETIC_SUPPORTED ++ double r = a; ++ r *= times; ++ r /= divisor; ++ r = floor(r+.5); ++ ++ /* A png_fixed_point is a 32-bit integer. */ ++ if (r <= 2147483647. && r >= -2147483648.) ++ { ++ *res = (png_fixed_point)r; ++ return 1; ++ } ++#else ++ int negative = 0; ++ png_uint_32 A, T, D; ++ png_uint_32 s16, s32, s00; ++ ++ if (a < 0) ++ negative = 1, A = -a; ++ else ++ A = a; ++ ++ if (times < 0) ++ negative = !negative, T = -times; ++ else ++ T = times; ++ ++ if (divisor < 0) ++ negative = !negative, D = -divisor; ++ else ++ D = divisor; ++ ++ /* Following can't overflow because the arguments only ++ * have 31 bits each, however the result may be 32 bits. ++ */ ++ s16 = (A >> 16) * (T & 0xffff) + ++ (A & 0xffff) * (T >> 16); ++ /* Can't overflow because the a*times bit is only 30 ++ * bits at most. ++ */ ++ s32 = (A >> 16) * (T >> 16) + (s16 >> 16); ++ s00 = (A & 0xffff) * (T & 0xffff); ++ ++ s16 = (s16 & 0xffff) << 16; ++ s00 += s16; ++ ++ if (s00 < s16) ++ ++s32; /* carry */ ++ ++ if (s32 < D) /* else overflow */ ++ { ++ /* s32.s00 is now the 64-bit product, do a standard ++ * division, we know that s32 < D, so the maximum ++ * required shift is 31. ++ */ ++ int bitshift = 32; ++ png_fixed_point result = 0; /* NOTE: signed */ ++ ++ while (--bitshift >= 0) ++ { ++ png_uint_32 d32, d00; ++ ++ if (bitshift > 0) ++ d32 = D >> (32-bitshift), d00 = D << bitshift; ++ ++ else ++ d32 = 0, d00 = D; ++ ++ if (s32 > d32) ++ { ++ if (s00 < d00) --s32; /* carry */ ++ s32 -= d32, s00 -= d00, result += 1<= d00) ++ s32 = 0, s00 -= d00, result += 1<= (D >> 1)) ++ ++result; ++ ++ if (negative != 0) ++ result = -result; ++ ++ /* Check for overflow. */ ++ if ((negative != 0 && result <= 0) || ++ (negative == 0 && result >= 0)) ++ { ++ *res = result; ++ return 1; ++ } ++ } ++#endif ++ } ++ } ++ ++ return 0; ++} ++#if GCC_STRICT_OVERFLOW ++#pragma GCC diagnostic pop ++#endif /* GCC_STRICT_OVERFLOW */ ++#endif /* READ_GAMMA || INCH_CONVERSIONS */ ++ ++#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_INCH_CONVERSIONS_SUPPORTED) ++/* The following is for when the caller doesn't much care about the ++ * result. ++ */ ++png_fixed_point ++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) != 0) ++ return result; ++ ++ png_warning(png_ptr, "fixed point overflow ignored"); ++ return 0; ++} ++#endif ++ ++#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) ++{ ++#ifdef PNG_FLOATING_ARITHMETIC_SUPPORTED ++ double r = floor(1E10/a+.5); ++ ++ if (r <= 2147483647. && r >= -2147483648.) ++ return (png_fixed_point)r; ++#else ++ png_fixed_point res; ++ ++ 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 ++/* A local convenience routine. */ ++static png_fixed_point ++png_product2(png_fixed_point a, png_fixed_point b) + { +- 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); ++ /* The required result is 1/a * 1/b; the following preserves accuracy. */ ++#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 ++ png_fixed_point res; ++ ++ if (png_muldiv(&res, a, b, 100000) != 0) ++ return res; ++#endif ++ ++ return 0; /* overflow */ ++} ++ ++/* The inverse of the above. */ ++png_fixed_point ++png_reciprocal2(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 ++ if (a != 0 && b != 0) ++ { ++ double r = 1E15/a; ++ r /= b; ++ r = floor(r+.5); ++ ++ if (r <= 2147483647. && r >= -2147483648.) ++ return (png_fixed_point)r; ++ } ++#else ++ /* This may overflow because the range of png_fixed_point isn't symmetric, ++ * but this API is only used for the product of file and screen gamma so it ++ * doesn't matter that the smallest number it can produce is 1/21474, not ++ * 1/100000 ++ */ ++ png_fixed_point res = png_product2(a, b); ++ ++ if (res != 0) ++ return png_reciprocal(res); ++#endif ++ ++ return 0; /* overflow */ ++} ++#endif /* READ_GAMMA */ ++ ++#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. ++ * ++ * 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 const png_uint_32 ++png_8bit_l2[128] = ++{ ++ 4270715492U, 4222494797U, 4174646467U, 4127164793U, 4080044201U, 4033279239U, ++ 3986864580U, 3940795015U, 3895065449U, 3849670902U, 3804606499U, 3759867474U, ++ 3715449162U, 3671346997U, 3627556511U, 3584073329U, 3540893168U, 3498011834U, ++ 3455425220U, 3413129301U, 3371120137U, 3329393864U, 3287946700U, 3246774933U, ++ 3205874930U, 3165243125U, 3124876025U, 3084770202U, 3044922296U, 3005329011U, ++ 2965987113U, 2926893432U, 2888044853U, 2849438323U, 2811070844U, 2772939474U, ++ 2735041326U, 2697373562U, 2659933400U, 2622718104U, 2585724991U, 2548951424U, ++ 2512394810U, 2476052606U, 2439922311U, 2404001468U, 2368287663U, 2332778523U, ++ 2297471715U, 2262364947U, 2227455964U, 2192742551U, 2158222529U, 2123893754U, ++ 2089754119U, 2055801552U, 2022034013U, 1988449497U, 1955046031U, 1921821672U, ++ 1888774511U, 1855902668U, 1823204291U, 1790677560U, 1758320682U, 1726131893U, ++ 1694109454U, 1662251657U, 1630556815U, 1599023271U, 1567649391U, 1536433567U, ++ 1505374214U, 1474469770U, 1443718700U, 1413119487U, 1382670639U, 1352370686U, ++ 1322218179U, 1292211689U, 1262349810U, 1232631153U, 1203054352U, 1173618059U, ++ 1144320946U, 1115161701U, 1086139034U, 1057251672U, 1028498358U, 999877854U, ++ 971388940U, 943030410U, 914801076U, 886699767U, 858725327U, 830876614U, ++ 803152505U, 775551890U, 748073672U, 720716771U, 693480120U, 666362667U, ++ 639363374U, 612481215U, 585715177U, 559064263U, 532527486U, 506103872U, ++ 479792461U, 453592303U, 427502463U, 401522014U, 375650043U, 349885648U, ++ 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 ++ * log (about 1.2 as opposed to 0.7 absolute error in the final value). To ++ * use these all the shifts below must be adjusted appropriately. ++ */ ++ 65166, 64430, 63700, 62976, 62257, 61543, 60835, 60132, 59434, 58741, 58054, ++ 57371, 56693, 56020, 55352, 54689, 54030, 53375, 52726, 52080, 51439, 50803, ++ 50170, 49542, 48918, 48298, 47682, 47070, 46462, 45858, 45257, 44661, 44068, ++ 43479, 42894, 42312, 41733, 41159, 40587, 40020, 39455, 38894, 38336, 37782, ++ 37230, 36682, 36137, 35595, 35057, 34521, 33988, 33459, 32932, 32408, 31887, ++ 31369, 30854, 30341, 29832, 29325, 28820, 28319, 27820, 27324, 26830, 26339, ++ 25850, 25364, 24880, 24399, 23920, 23444, 22970, 22499, 22029, 21562, 21098, ++ 20636, 20175, 19718, 19262, 18808, 18357, 17908, 17461, 17016, 16573, 16132, ++ 15694, 15257, 14822, 14390, 13959, 13530, 13103, 12678, 12255, 11834, 11415, ++ 10997, 10582, 10168, 9756, 9346, 8937, 8531, 8126, 7723, 7321, 6921, 6523, ++ 6127, 5732, 5339, 4947, 4557, 4169, 3782, 3397, 3014, 2632, 2251, 1872, 1495, ++ 1119, 744, 372 ++#endif ++}; ++ ++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 -1 for the overflow (log 0) case, - so the result is ++ * always at most 19 bits. ++ */ ++ if ((x &= 0xff) == 0) ++ return -1; ++ ++ if ((x & 0xf0) == 0) ++ lg2 = 4, x <<= 4; ++ ++ if ((x & 0xc0) == 0) ++ lg2 += 2, x <<= 2; ++ ++ if ((x & 0x80) == 0) ++ lg2 += 1, x <<= 1; ++ ++ /* result is at most 19 bits, so this cast is safe: */ ++ return (png_int_32)((lg2 << 16) + ((png_8bit_l2[x-128]+32768)>>16)); + } +-#endif /* PNG_SIZE_T */ + +-/* Added at libpng version 1.2.34 and 1.4.0 (moved from pngset.c) */ +-#ifdef PNG_cHRM_SUPPORTED +-#ifdef PNG_CHECK_cHRM_SUPPORTED ++/* The above gives exact (to 16 binary places) log2 values for 8-bit images, ++ * for 16-bit images we use the most significant 8 bits of the 16-bit value to ++ * get an approximation then multiply the approximation by a correction factor ++ * determined by the remaining up to 8 bits. This requires an additional step ++ * in the 16-bit case. ++ * ++ * We want log2(value/65535), we have log2(v'/255), where: ++ * ++ * value = v' * 256 + v'' ++ * = v' * f ++ * ++ * So f is value/v', which is equal to (256+v''/v') since v' is in the range 128 ++ * to 255 and v'' is in the range 0 to 255 f will be in the range 256 to less ++ * than 258. The final factor also needs to correct for the fact that our 8-bit ++ * value is scaled by 255, whereas the 16-bit values must be scaled by 65535. ++ * ++ * This gives a final formula using a calculated value 'x' which is value/v' and ++ * scaling by 65536 to match the above table: ++ * ++ * log2(x/257) * 65536 ++ * ++ * Since these numbers are so close to '1' we can use simple linear ++ * interpolation between the two end values 256/257 (result -368.61) and 258/257 ++ * (result 367.179). The values used below are scaled by a further 64 to give ++ * 16-bit precision in the interpolation: ++ * ++ * Start (256): -23591 ++ * Zero (257): 0 ++ * End (258): 23499 ++ */ ++#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 -1; ++ ++ if ((x & 0xff00) == 0) ++ lg2 = 8, x <<= 8; ++ ++ if ((x & 0xf000) == 0) ++ lg2 += 4, x <<= 4; ++ ++ if ((x & 0xc000) == 0) ++ lg2 += 2, x <<= 2; ++ ++ if ((x & 0x8000) == 0) ++ lg2 += 1, x <<= 1; ++ ++ /* Calculate the base logarithm from the top 8 bits as a 28-bit fractional ++ * value. ++ */ ++ lg2 <<= 28; ++ lg2 += (png_8bit_l2[(x>>8)-128]+8) >> 4; ++ ++ /* Now we need to interpolate the factor, this requires a division by the top ++ * 8 bits. Do this with maximum precision. ++ */ ++ x = ((x << 16) + (x >> 9)) / (x >> 8); ++ ++ /* Since we divided by the top 8 bits of 'x' there will be a '1' at 1<<24, ++ * the value at 1<<16 (ignoring this) will be 0 or 1; this gives us exactly ++ * 16 bits to interpolate to get the low bits of the result. Round the ++ * answer. Note that the end point values are scaled by 64 to retain overall ++ * precision and that 'lg2' is current scaled by an extra 12 bits, so adjust ++ * the overall scaling by 6-12. Round at every step. ++ */ ++ x -= 1U << 24; ++ ++ if (x <= 65536U) /* <= '257' */ ++ lg2 += ((23591U * (65536U-x)) + (1U << (16+6-12-1))) >> (16+6-12); ++ ++ else ++ lg2 -= ((23499U * (x-65536U)) + (1U << (16+6-12-1))) >> (16+6-12); ++ ++ /* Safe, because the result can't have more than 20 bits: */ ++ return (png_int_32)((lg2 + 2048) >> 12); ++} ++#endif /* 16BIT */ + +-/* +- * Multiply two 32-bit numbers, V1 and V2, using 32-bit +- * arithmetic, to produce a 64 bit result in the HI/LO words. ++/* 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. + * +- * A B +- * x C D +- * ------ +- * AD || BD +- * AC || CB || 0 ++ * 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. + * +- * 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. +-*/ ++ * To deal with this the following exp() function works out the exponent of the ++ * fractional part of the logarithm by using an accurate 32-bit value from the ++ * top four fractional bits then multiplying in the remaining bits. ++ */ ++static const png_uint_32 ++png_32bit_exp[16] = ++{ ++ /* 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, ++ 2553802834U, 2445529972U, 2341847524U, 2242560872U ++}; ++ ++/* Adjustment table; provided to explain the numbers in the code below. */ ++#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 ++ 9 45303.31936980687359311872 ++ 8 45364.65110595323018870784 ++ 7 45395.35850361789624614912 ++ 6 45410.72259715102037508096 ++ 5 45418.40724413220722311168 ++ 4 45422.25021786898173001728 ++ 3 45424.17186732298419044352 ++ 2 45425.13273269940811464704 ++ 1 45425.61317555035558641664 ++ 0 45425.85339951654943850496 ++#endif + +-void /* PRIVATE */ +-png_64bit_product (long v1, long v2, unsigned long *hi_product, +- unsigned long *lo_product) ++static png_uint_32 ++png_exp(png_fixed_point x) + { +- int a, b, c, d; +- long lo, hi, x, y; ++ if (x > 0 && x <= 0xfffff) /* Else overflow or zero (underflow) */ ++ { ++ /* Obtain a 4-bit approximation */ ++ png_uint_32 e = png_32bit_exp[(x >> 12) & 0x0f]; ++ ++ /* Incorporate the low 12 bits - these decrease the returned value by ++ * multiplying by a number less than 1 if the bit is set. The multiplier ++ * is determined by the above table and the shift. Notice that the values ++ * converge on 45426 and this is used to allow linear interpolation of the ++ * low bits. ++ */ ++ if (x & 0x800) ++ e -= (((e >> 16) * 44938U) + 16U) >> 5; ++ ++ if (x & 0x400) ++ e -= (((e >> 16) * 45181U) + 32U) >> 6; + +- a = (v1 >> 16) & 0xffff; +- b = v1 & 0xffff; +- c = (v2 >> 16) & 0xffff; +- d = v2 & 0xffff; ++ if (x & 0x200) ++ e -= (((e >> 16) * 45303U) + 64U) >> 7; + +- lo = b * d; /* BD */ +- x = a * d + c * b; /* AD + CB */ +- y = ((lo >> 16) & 0xffff) + x; ++ if (x & 0x100) ++ e -= (((e >> 16) * 45365U) + 128U) >> 8; + +- lo = (lo & 0xffff) | ((y & 0xffff) << 16); +- hi = (y >> 16) & 0xffff; ++ if (x & 0x080) ++ e -= (((e >> 16) * 45395U) + 256U) >> 9; + +- hi += a * c; /* AC */ ++ if (x & 0x040) ++ e -= (((e >> 16) * 45410U) + 512U) >> 10; + +- *hi_product = (unsigned long)hi; +- *lo_product = (unsigned long)lo; ++ /* And handle the low 6 bits in a single block. */ ++ e -= (((e >> 16) * 355U * (x & 0x3fU)) + 256U) >> 9; ++ ++ /* Handle the upper bits of x. */ ++ e >>= x >> 16; ++ return e; ++ } ++ ++ /* Check for overflow */ ++ if (x <= 0) ++ return png_32bit_exp[0]; ++ ++ /* Else underflow */ ++ return 0; + } + +-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) ++static png_byte ++png_exp8bit(png_fixed_point lg2) + { +- int ret = 1; +- unsigned long xy_hi,xy_lo,yx_hi,yx_lo; ++ /* 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 ++ * second, rounding, step can't overflow because of the first, subtraction, ++ * step. ++ */ ++ x -= x >> 8; ++ return (png_byte)(((x + 0x7fffffU) >> 24) & 0xff); ++} + +- png_debug(1, "in function png_check_cHRM_fixed"); ++#ifdef PNG_16BIT_SUPPORTED ++static png_uint_16 ++png_exp16bit(png_fixed_point lg2) ++{ ++ /* Get a 32-bit value: */ ++ png_uint_32 x = png_exp(lg2); + +- if (png_ptr == NULL) +- return 0; ++ /* Convert the 32-bit value to 0..65535 by multiplying by 65536-1: */ ++ x -= x >> 16; ++ return (png_uint_16)((x + 32767U) >> 16); ++} ++#endif /* 16BIT */ ++#endif /* FLOATING_ARITHMETIC */ + +- if (white_x < 0 || white_y <= 0 || +- red_x < 0 || red_y < 0 || +- green_x < 0 || green_y < 0 || +- blue_x < 0 || blue_y < 0) +- { +- png_warning(png_ptr, +- "Ignoring attempt to set negative chromaticity value"); +- ret = 0; +- } +- if (white_x > (png_fixed_point) PNG_UINT_31_MAX || +- white_y > (png_fixed_point) PNG_UINT_31_MAX || +- red_x > (png_fixed_point) PNG_UINT_31_MAX || +- red_y > (png_fixed_point) PNG_UINT_31_MAX || +- green_x > (png_fixed_point) PNG_UINT_31_MAX || +- green_y > (png_fixed_point) PNG_UINT_31_MAX || +- blue_x > (png_fixed_point) PNG_UINT_31_MAX || +- blue_y > (png_fixed_point) PNG_UINT_31_MAX ) ++png_byte ++png_gamma_8bit_correct(unsigned int value, png_fixed_point gamma_val) ++{ ++ if (value > 0 && value < 255) + { +- png_warning(png_ptr, +- "Ignoring attempt to set chromaticity value exceeding 21474.83"); +- ret = 0; ++# ifdef PNG_FLOATING_ARITHMETIC_SUPPORTED ++ /* '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) != 0) ++ return png_exp8bit(res); ++ ++ /* Overflow. */ ++ value = 0; ++# endif + } +- if (white_x > 100000L - white_y) ++ ++ return (png_byte)(value & 0xff); ++} ++ ++#ifdef PNG_16BIT_SUPPORTED ++png_uint_16 ++png_gamma_16bit_correct(unsigned int value, png_fixed_point gamma_val) ++{ ++ if (value > 0 && value < 65535) + { +- png_warning(png_ptr, "Invalid cHRM white point"); +- ret = 0; ++# ifdef PNG_FLOATING_ARITHMETIC_SUPPORTED ++ /* 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) != 0) ++ return png_exp16bit(res); ++ ++ /* Overflow. */ ++ value = 0; ++# endif + } +- if (red_x > 100000L - red_y) ++ ++ 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 ++ * is nominally a 16-bit value if bit depth is 8 then the result is ++ * 8-bit (as are the arguments.) ++ */ ++png_uint_16 /* PRIVATE */ ++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 */ ++} ++ ++#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). ++ * ++ * The caller is responsible for ensuring that the table gets cleaned up on ++ * png_error (i.e. if one of the mallocs below fails) - i.e. the *table argument ++ * should be somewhere that will be cleaned. ++ */ ++static void ++png_build_16bit_table(png_structrp png_ptr, png_uint_16pp *ptable, ++ unsigned int shift, png_fixed_point gamma_val) ++{ ++ /* Various values derived from 'shift': */ ++ 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.) ++ */ ++ double fmax = 1.0 / (((png_int_32)1 << (16U - shift)) - 1); ++#endif ++ unsigned int max = (1U << (16U - shift)) - 1U; ++ unsigned int max_by_2 = 1U << (15U - shift); ++ unsigned int i; ++ ++ png_uint_16pp table = *ptable = ++ (png_uint_16pp)png_calloc(png_ptr, num * (sizeof (png_uint_16p))); ++ ++ for (i = 0; i < num; i++) + { +- png_warning(png_ptr, "Invalid cHRM red point"); +- ret = 0; ++ png_uint_16p sub_table = table[i] = ++ (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) != 0) ++ { ++ /* The old code would overflow at the end and this would cause the ++ * 'pow' function to return a result >1, resulting in an ++ * arithmetic error. This code follows the spec exactly; ig is ++ * the recovered input sample, it always has 8-16 bits. ++ * ++ * We want input * 65535/max, rounded, the arithmetic fits in 32 ++ * bits (unsigned) so long as max <= 32767. ++ */ ++ unsigned int j; ++ for (j = 0; j < 256; j++) ++ { ++ png_uint_32 ig = (j << (8-shift)) + i; ++# ifdef PNG_FLOATING_ARITHMETIC_SUPPORTED ++ /* Inline the 'max' scaling operation: */ ++ /* 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 != 0) ++ ig = (ig * 65535U + max_by_2)/max; ++ ++ sub_table[j] = png_gamma_16bit_correct(ig, gamma_val); ++# endif ++ } ++ } ++ else ++ { ++ /* We must still build a table, but do it the fast way. */ ++ unsigned int j; ++ ++ for (j = 0; j < 256; j++) ++ { ++ png_uint_32 ig = (j << (8-shift)) + i; ++ ++ if (shift != 0) ++ ig = (ig * 65535U + max_by_2)/max; ++ ++ sub_table[j] = (png_uint_16)ig; ++ } ++ } + } +- if (green_x > 100000L - green_y) ++} ++ ++/* NOTE: this function expects the *inverse* of the overall gamma transformation ++ * required. ++ */ ++static void ++png_build_16to8_table(png_structrp png_ptr, png_uint_16pp *ptable, ++ unsigned int shift, png_fixed_point gamma_val) ++{ ++ unsigned int num = 1U << (8U - shift); ++ unsigned int max = (1U << (16U - shift))-1U; ++ unsigned int i; ++ png_uint_32 last; ++ ++ png_uint_16pp table = *ptable = ++ (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 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 * (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. ++ * ++ * In the loop 'i' is used to find output values. Since the output is ++ * 8-bit there are only 256 possible values. The tables are set up to ++ * select the closest possible output value for each input by finding ++ * the input value at the boundary between each pair of output values ++ * and filling the table up to that boundary with the lower output ++ * value. ++ * ++ * The boundary values are 0.5,1.5..253.5,254.5. Since these are 9-bit ++ * values the code below uses a 16-bit value in i; the values start at ++ * 128.5 (for 0.5) and step by 257, for a total of 254 values (the last ++ * entries are filled with 255). Start i at 128 and fill all 'last' ++ * table entries <= 'max' ++ */ ++ last = 0; ++ for (i = 0; i < 255; ++i) /* 8-bit output value */ + { +- png_warning(png_ptr, "Invalid cHRM green point"); +- ret = 0; ++ /* Find the corresponding maximum input value */ ++ png_uint_16 out = (png_uint_16)(i * 257U); /* 16-bit output value */ ++ ++ /* Find the boundary value in 16 bits: */ ++ png_uint_32 bound = png_gamma_16bit_correct(out+128U, gamma_val); ++ ++ /* Adjust (round) to (16-shift) bits: */ ++ bound = (bound * max + 32768U)/65535U + 1U; ++ ++ while (last < bound) ++ { ++ table[last & (0xffU >> shift)][last >> (8U - shift)] = out; ++ last++; ++ } + } +- if (blue_x > 100000L - blue_y) ++ ++ /* And fill in the final entries. */ ++ while (last < (num << 8)) + { +- png_warning(png_ptr, "Invalid cHRM blue point"); +- ret = 0; ++ table[last & (0xff >> shift)][last >> (8U - shift)] = 65535U; ++ last++; + } ++} ++#endif /* 16BIT */ + +- 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); ++/* 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. ++ */ ++static void ++png_build_8bit_table(png_structrp png_ptr, png_bytepp ptable, ++ png_fixed_point gamma_val) ++{ ++ unsigned int i; ++ png_bytep table = *ptable = (png_bytep)png_malloc(png_ptr, 256); + +- if (xy_hi == yx_hi && xy_lo == yx_lo) +- { +- png_warning(png_ptr, +- "Ignoring attempt to set cHRM RGB triangle with zero area"); +- ret = 0; +- } ++ if (png_gamma_significant(gamma_val) != 0) ++ for (i=0; i<256; i++) ++ table[i] = png_gamma_8bit_correct(i, gamma_val); + +- return ret; ++ else ++ for (i=0; i<256; ++i) ++ table[i] = (png_byte)(i & 0xff); + } +-#endif /* PNG_CHECK_cHRM_SUPPORTED */ +-#endif /* PNG_cHRM_SUPPORTED */ + ++/* Used from png_read_destroy and below to release the memory used by the gamma ++ * tables. ++ */ + void /* PRIVATE */ +-png_check_IHDR(png_structp png_ptr, +- png_uint_32 width, png_uint_32 height, int bit_depth, +- int color_type, int interlace_type, int compression_type, +- int filter_type) ++png_destroy_gamma_table(png_structrp png_ptr) + { +- int error = 0; ++ png_free(png_ptr, png_ptr->gamma_table); ++ png_ptr->gamma_table = NULL; + +- /* Check for width and height valid values */ +- if (width == 0) ++#ifdef PNG_16BIT_SUPPORTED ++ if (png_ptr->gamma_16_table != NULL) + { +- png_warning(png_ptr, "Image width is zero in IHDR"); +- error = 1; ++ 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; + } +- +- if (height == 0) ++#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) + { +- png_warning(png_ptr, "Image height is zero in IHDR"); +- error = 1; ++ 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; + } +- +-#ifdef PNG_SET_USER_LIMITS_SUPPORTED +- if (width > png_ptr->user_width_max || width > PNG_USER_WIDTH_MAX) +-#else +- if (width > PNG_USER_WIDTH_MAX) +-#endif ++ if (png_ptr->gamma_16_to_1 != NULL) + { +- png_warning(png_ptr, "Image width exceeds user limit in IHDR"); +- error = 1; ++ 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 */ ++} + +-#ifdef PNG_SET_USER_LIMITS_SUPPORTED +- if (height > png_ptr->user_height_max || height > PNG_USER_HEIGHT_MAX) +-#else +- if (height > PNG_USER_HEIGHT_MAX) +-#endif +- { +- png_warning(png_ptr, "Image height exceeds user limit in IHDR"); +- error = 1; +- } ++/* We build the 8- or 16-bit gamma tables here. Note that for 16-bit ++ * tables, we don't make a full table if we are reducing to 8-bit in ++ * the future. Note also how the gamma_16 tables are segmented so that ++ * we don't need to allocate > 64K chunks for a full 16-bit table. ++ */ ++void /* PRIVATE */ ++png_build_gamma_table(png_structrp png_ptr, int bit_depth) ++{ ++ png_debug(1, "in png_build_gamma_table"); + +- if (width > PNG_UINT_31_MAX) ++ /* 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, "Invalid image width in IHDR"); +- error = 1; ++ png_warning(png_ptr, "gamma table being rebuilt"); ++ png_destroy_gamma_table(png_ptr); + } + +- if ( height > PNG_UINT_31_MAX) ++ if (bit_depth <= 8) + { +- png_warning(png_ptr, "Invalid image height in IHDR"); +- error = 1; ++ png_build_8bit_table(png_ptr, &png_ptr->gamma_table, ++ 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)) != 0) ++ { ++ png_build_8bit_table(png_ptr, &png_ptr->gamma_to_1, ++ 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->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 ( width > (PNG_UINT_32_MAX +- >> 3) /* 8-byte RGBA pixels */ +- - 64 /* bigrowbuf hack */ +- - 1 /* filter byte */ +- - 7*8 /* rounding of width to multiple of 8 pixels */ +- - 8) /* extra max_pixel_depth pad */ +- png_warning(png_ptr, "Width is too large for libpng to process pixels"); ++ if ((png_ptr->color_type & PNG_COLOR_MASK_COLOR) != 0) ++ { ++ sig_bit = png_ptr->sig_bit.red; + +- /* Check other values */ +- if (bit_depth != 1 && bit_depth != 2 && bit_depth != 4 && +- bit_depth != 8 && bit_depth != 16) +- { +- png_warning(png_ptr, "Invalid bit depth in IHDR"); +- error = 1; +- } ++ if (png_ptr->sig_bit.green > sig_bit) ++ sig_bit = png_ptr->sig_bit.green; + +- if (color_type < 0 || color_type == 1 || +- color_type == 5 || color_type > 6) +- { +- png_warning(png_ptr, "Invalid color type in IHDR"); +- error = 1; +- } ++ if (png_ptr->sig_bit.blue > sig_bit) ++ sig_bit = png_ptr->sig_bit.blue; ++ } ++ else ++ sig_bit = png_ptr->sig_bit.gray; ++ ++ /* 16-bit gamma code uses this equation: ++ * ++ * ov = table[(iv & 0xff) >> gamma_shift][iv >> 8] ++ * ++ * 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 ++ * 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: ++ * ++ * table[low bits][high 8 bits] ++ * ++ * So the table 'n' corresponds to all those 'iv' of: ++ * ++ * ..<(n+1 << gamma_shift)-1> ++ * ++ */ ++ if (sig_bit > 0 && sig_bit < 16U) ++ /* shift == insignificant bits */ ++ shift = (png_byte)((16U - sig_bit) & 0xff); + +- if (((color_type == PNG_COLOR_TYPE_PALETTE) && bit_depth > 8) || +- ((color_type == PNG_COLOR_TYPE_RGB || +- color_type == PNG_COLOR_TYPE_GRAY_ALPHA || +- color_type == PNG_COLOR_TYPE_RGB_ALPHA) && bit_depth < 8)) +- { +- png_warning(png_ptr, "Invalid color type/bit depth combination in IHDR"); +- error = 1; +- } ++ else ++ shift = 0; /* keep all 16 bits */ + +- if (interlace_type >= PNG_INTERLACE_LAST) +- { +- png_warning(png_ptr, "Unknown interlace method in IHDR"); +- error = 1; ++ 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 ++ * eventually be 8 bits. By default it is 11. ++ */ ++ if (shift < (16U - PNG_MAX_GAMMA_8)) ++ shift = (16U - PNG_MAX_GAMMA_8); ++ } ++ ++ if (shift > 8U) ++ shift = 8U; /* Guarantees at least one table! */ ++ ++ png_ptr->gamma_shift = shift; ++ ++ /* 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)) != 0) ++ png_build_16to8_table(png_ptr, &png_ptr->gamma_16_table, shift, ++ png_ptr->screen_gamma > 0 ? png_product2(png_ptr->colorspace.gamma, ++ png_ptr->screen_gamma) : PNG_FP_1); ++ ++ else ++ png_build_16bit_table(png_ptr, &png_ptr->gamma_16_table, shift, ++ 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)) != 0) ++ { ++ png_build_16bit_table(png_ptr, &png_ptr->gamma_16_to_1, shift, ++ 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. ++ * TODO: fix this. ++ */ ++ 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->colorspace.gamma/* Probably doing rgb_to_gray */); ++ } ++#endif /* READ_BACKGROUND || READ_ALPHA_MODE || RGB_TO_GRAY */ + } ++#endif /* 16BIT */ ++} ++#endif /* READ_GAMMA */ + +- if (compression_type != PNG_COMPRESSION_TYPE_BASE) ++/* 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) + { +- png_warning(png_ptr, "Unknown compression method in IHDR"); +- error = 1; ++ png_uint_32 mask = 3U << option; ++ png_uint_32 setting = (2U + (onoff != 0)) << option; ++ png_uint_32 current = png_ptr->options; ++ ++ png_ptr->options = (png_uint_32)((current & ~mask) | setting); ++ ++ return (int)(current & mask) >> option; + } + +-#ifdef PNG_MNG_FEATURES_SUPPORTED +- /* Accept filter_method 64 (intrapixel differencing) only if +- * 1. Libpng was compiled with PNG_MNG_FEATURES_SUPPORTED and +- * 2. Libpng did not read a PNG signature (this filter_method is only +- * used in PNG datastreams that are embedded in MNG datastreams) and +- * 3. The application called png_permit_mng_features with a mask that +- * included PNG_FLAG_MNG_FILTER_64 and +- * 4. The filter_method is 64 and +- * 5. The color_type is RGB or RGBA ++ 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 https://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 ((png_ptr->mode & PNG_HAVE_PNG_SIGNATURE) && +- png_ptr->mng_features_permitted) +- png_warning(png_ptr, "MNG features are not allowed in a PNG datastream"); ++ if (cp->png_ptr == NULL) ++ return 0; + +- if (filter_type != PNG_FILTER_TYPE_BASE) +- { +- if (!((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) && +- (filter_type == PNG_INTRAPIXEL_DIFFERENCING) && +- ((png_ptr->mode & PNG_HAVE_PNG_SIGNATURE) == 0) && +- (color_type == PNG_COLOR_TYPE_RGB || +- color_type == PNG_COLOR_TYPE_RGB_ALPHA))) ++ /* First free any data held in the control structure. */ ++# ifdef PNG_STDIO_SUPPORTED ++ if (cp->owned_file != 0) + { +- png_warning(png_ptr, "Unknown filter method in IHDR"); +- error = 1; +- } ++ FILE *fp = png_voidcast(FILE*, cp->png_ptr->io_ptr); ++ cp->owned_file = 0; + +- if (png_ptr->mode & PNG_HAVE_PNG_SIGNATURE) +- { +- png_warning(png_ptr, "Invalid filter method in IHDR"); +- error = 1; ++ /* 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 + } + +-#else +- if (filter_type != PNG_FILTER_TYPE_BASE) ++ /* 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) + { +- png_warning(png_ptr, "Unknown filter method in IHDR"); +- error = 1; ++ /* Ignore errors here: */ ++ (void)png_safe_execute(image, png_image_free_function, image); ++ image->opaque = NULL; + } +-#endif ++} + +- if (error == 1) +- png_error(png_ptr, "Invalid IHDR data"); ++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 /* defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED) */ ++ ++#endif /* SIMPLIFIED READ/WRITE */ ++#endif /* READ || WRITE */ +diff --git a/com32/lib/libpng/pngerror.c b/com32/lib/libpng/pngerror.c +index 7bc98fb1..ec3a709b 100644 +--- a/com32/lib/libpng/pngerror.c ++++ b/com32/lib/libpng/pngerror.c +@@ -1,10 +1,10 @@ + + /* pngerror.c - stub functions for i/o and memory allocation + * +- * Last changed in libpng 1.2.41 [December 3, 2009] +- * Copyright (c) 1998-2009 Glenn Randers-Pehrson +- * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) +- * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) ++ * Copyright (c) 2018 Cosmin Truta ++ * Copyright (c) 1998-2002,2004,2006-2017 Glenn Randers-Pehrson ++ * Copyright (c) 1996-1997 Andreas Dilger ++ * Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc. + * + * This code is released under the libpng license. + * For conditions of distribution and use, see the disclaimer +@@ -16,19 +16,18 @@ + * at each function. + */ + +-#define PNG_INTERNAL +-#define PNG_NO_PEDANTIC_WARNINGS +-#include "png.h" ++#include "pngpriv.h" ++ + #if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED) + +-static void /* PRIVATE */ +-png_default_error PNGARG((png_structp png_ptr, +- png_const_charp error_message)) PNG_NORETURN; ++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_const_charp warning_message)); +-#endif /* PNG_WARNINGS_SUPPORTED */ ++png_default_warning PNGARG((png_const_structrp png_ptr, ++ png_const_charp warning_message)); ++#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, +@@ -36,65 +35,176 @@ png_default_warning PNGARG((png_structp png_ptr, + * to replace the error function at run-time. + */ + #ifdef PNG_ERROR_TEXT_SUPPORTED +-void PNGAPI +-png_error(png_structp png_ptr, png_const_charp error_message) ++PNG_FUNCTION(void,PNGAPI ++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 (*error_message == PNG_LITERAL_SHARP) +- { +- /* Strip "#nnnn " from beginning of error message. */ +- int offset; +- for (offset = 1; offset<15; offset++) +- if (error_message[offset] == ' ') ++ if ((png_ptr->flags & ++ (PNG_FLAG_STRIP_ERROR_NUMBERS|PNG_FLAG_STRIP_ERROR_TEXT)) != 0) ++ { ++ if (*error_message == PNG_LITERAL_SHARP) ++ { ++ /* Strip "#nnnn " from beginning of error message. */ ++ int offset; ++ for (offset = 1; offset<15; offset++) ++ if (error_message[offset] == ' ') + break; +- if (png_ptr->flags&PNG_FLAG_STRIP_ERROR_TEXT) +- { +- int i; +- for (i = 0; i < offset - 1; i++) +- msg[i] = error_message[i + 1]; +- msg[i - 1] = '\0'; +- error_message = msg; +- } +- else +- error_message += offset; +- } +- else +- { +- if (png_ptr->flags&PNG_FLAG_STRIP_ERROR_TEXT) +- { +- msg[0] = '0'; +- msg[1] = '\0'; +- error_message = msg; +- } +- } +- } ++ ++ if ((png_ptr->flags & PNG_FLAG_STRIP_ERROR_TEXT) != 0) ++ { ++ int i; ++ for (i = 0; i < offset - 1; i++) ++ msg[i] = error_message[i + 1]; ++ msg[i - 1] = '\0'; ++ error_message = msg; ++ } ++ ++ else ++ error_message += offset; ++ } ++ ++ else ++ { ++ if ((png_ptr->flags & PNG_FLAG_STRIP_ERROR_TEXT) != 0) ++ { ++ msg[0] = '0'; ++ msg[1] = '\0'; ++ error_message = msg; ++ } ++ } ++ } + } + #endif + if (png_ptr != NULL && png_ptr->error_fn != NULL) +- (*(png_ptr->error_fn))(png_ptr, error_message); ++ (*(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. */ + png_default_error(png_ptr, error_message); + } + #else +-void PNGAPI +-png_err(png_structp png_ptr) ++PNG_FUNCTION(void,PNGAPI ++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 ++ * apparently an error, introduced in libpng-1.2.20, and png_default_error ++ * will crash in this case. ++ */ + if (png_ptr != NULL && png_ptr->error_fn != NULL) +- (*(png_ptr->error_fn))(png_ptr, '\0'); ++ (*(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, '\0'); ++ png_default_error(png_ptr, ""); ++} ++#endif /* ERROR_TEXT */ ++ ++/* Utility to safely appends strings to a buffer. This never errors out so ++ * error checking is not required in the caller. ++ */ ++size_t ++png_safecat(png_charp buffer, size_t bufsize, size_t pos, ++ png_const_charp string) ++{ ++ if (buffer != NULL && pos < bufsize) ++ { ++ if (string != NULL) ++ while (*string != '\0' && pos < bufsize-1) ++ buffer[pos++] = *string++; ++ ++ buffer[pos] = '\0'; ++ } ++ ++ return pos; ++} ++ ++#if defined(PNG_WARNINGS_SUPPORTED) || defined(PNG_TIME_RFC1123_SUPPORTED) ++/* Utility to dump an unsigned value into a buffer, given a start pointer and ++ * and end pointer (which should point just *beyond* the end of the buffer!) ++ * Returns the pointer to the start of the formatted string. ++ */ ++png_charp ++png_format_number(png_const_charp start, png_charp end, int format, ++ png_alloc_size_t number) ++{ ++ int count = 0; /* number of digits output */ ++ int mincount = 1; /* minimum number required */ ++ int output = 0; /* digit output (for the fixed point format) */ ++ ++ *--end = '\0'; ++ ++ /* This is written so that the loop always runs at least once, even with ++ * number zero. ++ */ ++ while (end > start && (number != 0 || count < mincount)) ++ { ++ ++ static const char digits[] = "0123456789ABCDEF"; ++ ++ switch (format) ++ { ++ case PNG_NUMBER_FORMAT_fixed: ++ /* Needs five digits (the fraction) */ ++ mincount = 5; ++ if (output != 0 || number % 10 != 0) ++ { ++ *--end = digits[number % 10]; ++ output = 1; ++ } ++ number /= 10; ++ break; ++ ++ case PNG_NUMBER_FORMAT_02u: ++ /* Expects at least 2 digits. */ ++ mincount = 2; ++ /* FALLTHROUGH */ ++ ++ case PNG_NUMBER_FORMAT_u: ++ *--end = digits[number % 10]; ++ number /= 10; ++ break; ++ ++ case PNG_NUMBER_FORMAT_02x: ++ /* This format expects at least two digits */ ++ mincount = 2; ++ /* FALLTHROUGH */ ++ ++ case PNG_NUMBER_FORMAT_x: ++ *--end = digits[number & 0xf]; ++ number >>= 4; ++ break; ++ ++ default: /* an error */ ++ number = 0; ++ break; ++ } ++ ++ /* Keep track of the number of digits added */ ++ ++count; ++ ++ /* Float a fixed number here: */ ++ 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 != 0) ++ *--end = '.'; ++ else if (number == 0) /* and !output */ ++ *--end = '0'; ++ } ++ } ++ ++ return end; + } +-#endif /* PNG_ERROR_TEXT_SUPPORTED */ ++#endif + + #ifdef PNG_WARNINGS_SUPPORTED + /* This function is called whenever there is a non-fatal error. This function +@@ -103,195 +213,566 @@ png_err(png_structp png_ptr) + * 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) +- { +- for (offset = 1; offset < 15; offset++) +- if (warning_message[offset] == ' ') ++ { ++ if (*warning_message == PNG_LITERAL_SHARP) ++ { ++ for (offset = 1; offset < 15; offset++) ++ if (warning_message[offset] == ' ') + break; +- } +- } ++ } ++ } + } + if (png_ptr != NULL && png_ptr->warning_fn != NULL) +- (*(png_ptr->warning_fn))(png_ptr, warning_message + offset); ++ (*(png_ptr->warning_fn))(png_constcast(png_structrp,png_ptr), ++ warning_message + offset); + else + png_default_warning(png_ptr, warning_message + offset); + } +-#endif /* PNG_WARNINGS_SUPPORTED */ ++ ++/* These functions support 'formatted' warning messages with up to ++ * PNG_WARNING_PARAMETER_COUNT parameters. In the format string the parameter ++ * is introduced by @, where 'number' starts at 1. This follows the ++ * standard established by X/Open for internationalizable error messages. ++ */ ++void ++png_warning_parameter(png_warning_parameters p, int number, ++ png_const_charp string) ++{ ++ if (number > 0 && number <= PNG_WARNING_PARAMETER_COUNT) ++ (void)png_safecat(p[number-1], (sizeof p[number-1]), 0, string); ++} ++ ++void ++png_warning_parameter_unsigned(png_warning_parameters p, int number, int format, ++ png_alloc_size_t value) ++{ ++ char buffer[PNG_NUMBER_BUFFER_SIZE]; ++ png_warning_parameter(p, number, PNG_FORMAT_NUMBER(buffer, format, value)); ++} ++ ++void ++png_warning_parameter_signed(png_warning_parameters p, int number, int format, ++ png_int_32 value) ++{ ++ png_alloc_size_t u; ++ png_charp str; ++ char buffer[PNG_NUMBER_BUFFER_SIZE]; ++ ++ /* Avoid overflow by doing the negate in a png_alloc_size_t: */ ++ u = (png_alloc_size_t)value; ++ if (value < 0) ++ u = ~u + 1; ++ ++ str = PNG_FORMAT_NUMBER(buffer, format, u); ++ ++ if (value < 0 && str > buffer) ++ *--str = '-'; ++ ++ png_warning_parameter(p, number, str); ++} ++ ++void ++png_formatted_warning(png_const_structrp png_ptr, png_warning_parameters p, ++ png_const_charp message) ++{ ++ /* 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 = 0; /* Index in the msg[] buffer: */ ++ char msg[192]; ++ ++ /* 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') ++ { ++ /* '@' 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_char = *++message; /* Consume the '@' */ ++ static const char valid_parameters[] = "123456789"; ++ int parameter = 0; ++ ++ /* 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; ++ ++ /* 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]; ++ png_const_charp pend = p[parameter] + (sizeof p[parameter]); ++ ++ /* No need to copy the trailing '\0' here, but there is no guarantee ++ * that parm[] has been initialized, so there is no guarantee of a ++ * trailing '\0': ++ */ ++ 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. 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++; ++ } ++ ++ /* i is always less than (sizeof msg), so: */ ++ msg[i] = '\0'; ++ ++ /* 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 /* 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) +- png_warning(png_ptr, error_message); +- else +- png_error(png_ptr, error_message); ++ 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 + } +-#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 ++} ++ ++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)) +-static PNG_CONST char png_digit[16] = { ++static const char png_digit[16] = { + '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', + 'A', 'B', 'C', 'D', 'E', 'F' + }; + +-#define PNG_MAX_ERROR_TEXT 64 +-#if defined(PNG_WARNINGS_SUPPORTED) || defined(PNG_ERROR_TEXT_SUPPORTED) + static void /* PRIVATE */ +-png_format_buffer(png_structp png_ptr, png_charp buffer, png_const_charp +- error_message) ++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]; + buffer[iout++] = png_digit[c & 0x0f]; + buffer[iout++] = PNG_LITERAL_RIGHT_SQUARE_BRACKET; + } ++ + else + { +- buffer[iout++] = (png_byte)c; ++ buffer[iout++] = (char)c; + } + } + + if (error_message == NULL) + buffer[iout] = '\0'; ++ + else + { ++ int iin = 0; ++ + buffer[iout++] = ':'; + buffer[iout++] = ' '; +- png_memcpy(buffer + iout, error_message, PNG_MAX_ERROR_TEXT); +- buffer[iout + PNG_MAX_ERROR_TEXT - 1] = '\0'; ++ ++ while (iin < PNG_MAX_ERROR_TEXT-1 && error_message[iin] != '\0') ++ buffer[iout++] = error_message[iin++]; ++ ++ /* iin < PNG_MAX_ERROR_TEXT, so the following is safe: */ ++ buffer[iout] = '\0'; + } + } ++#endif /* WARNINGS || ERROR_TEXT */ + +-#ifdef PNG_READ_SUPPORTED +-void PNGAPI +-png_chunk_error(png_structp png_ptr, png_const_charp error_message) ++#if defined(PNG_READ_SUPPORTED) && defined(PNG_ERROR_TEXT_SUPPORTED) ++PNG_FUNCTION(void,PNGAPI ++png_chunk_error,(png_const_structrp png_ptr, png_const_charp error_message), ++ PNG_NORETURN) + { + char msg[18+PNG_MAX_ERROR_TEXT]; + if (png_ptr == NULL) +- png_error(png_ptr, error_message); ++ png_error(png_ptr, error_message); ++ + else + { +- png_format_buffer(png_ptr, msg, error_message); +- png_error(png_ptr, msg); ++ png_format_buffer(png_ptr, msg, error_message); ++ png_error(png_ptr, msg); + } + } +-#endif /* PNG_READ_SUPPORTED */ +-#endif /* PNG_WARNINGS_SUPPORTED || PNG_ERROR_TEXT_SUPPORTED */ ++#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) +- png_warning(png_ptr, warning_message); ++ png_warning(png_ptr, warning_message); ++ + else + { +- png_format_buffer(png_ptr, msg, warning_message); +- png_warning(png_ptr, msg); ++ png_format_buffer(png_ptr, msg, warning_message); ++ 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) +- png_chunk_warning(png_ptr, error_message); +- else +- png_chunk_error(png_ptr, error_message); ++ 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 /* 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_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) ++ unsigned int iin; ++ char msg[fixed_message_ln+PNG_MAX_ERROR_TEXT]; ++ 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; ++ } ++ msg[fixed_message_ln + iin] = 0; ++ png_error(png_ptr, msg); ++} ++#endif ++#endif ++ ++#ifdef PNG_SETJMP_SUPPORTED ++/* This API only exists if ANSI-C style error handling is used, ++ * otherwise it is necessary for png_default_error to be overridden. ++ */ ++jmp_buf* PNGAPI ++png_set_longjmp_fn(png_structrp png_ptr, png_longjmp_ptr longjmp_fn, ++ size_t jmp_buf_size) ++{ ++ /* 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->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 +-#endif /* PNG_READ_SUPPORTED */ + + /* This is the default error handling function. Note that replacements for + * this function MUST NOT RETURN, or the program will likely crash. This + * function is used by default, or if the program supplies NULL for the + * error function pointer in png_set_error_fn(). + */ +-static void /* PRIVATE */ +-png_default_error(png_structp png_ptr, png_const_charp error_message) ++static PNG_FUNCTION(void /* PRIVATE */, ++png_default_error,(png_const_structrp png_ptr, png_const_charp error_message), ++ PNG_NORETURN) + { + #ifdef PNG_CONSOLE_IO_SUPPORTED + #ifdef PNG_ERROR_NUMBERS_SUPPORTED +- if (*error_message == PNG_LITERAL_SHARP) ++ /* Check on NULL only added in 1.5.4 */ ++ if (error_message != NULL && *error_message == PNG_LITERAL_SHARP) + { +- /* Strip "#nnnn " from beginning of error message. */ +- int offset; +- char error_number[16]; +- for (offset = 0; offset<15; offset++) +- { ++ /* Strip "#nnnn " from beginning of error message. */ ++ int offset; ++ char error_number[16]; ++ for (offset = 0; offset<15; offset++) ++ { + error_number[offset] = error_message[offset + 1]; + if (error_message[offset] == ' ') +- break; +- } +- if ((offset > 1) && (offset < 15)) +- { +- error_number[offset - 1] = '\0'; +- fprintf(stderr, "libpng error no. %s: %s", +- error_number, error_message + offset + 1); +- fprintf(stderr, PNG_STRING_NEWLINE); +- } +- else +- { +- fprintf(stderr, "libpng error: %s, offset=%d", +- error_message, offset); +- fprintf(stderr, PNG_STRING_NEWLINE); +- } ++ break; ++ } ++ ++ if ((offset > 1) && (offset < 15)) ++ { ++ error_number[offset - 1] = '\0'; ++ fprintf(stderr, "libpng error no. %s: %s", ++ error_number, error_message + offset + 1); ++ fprintf(stderr, PNG_STRING_NEWLINE); ++ } ++ ++ else ++ { ++ fprintf(stderr, "libpng error: %s, offset=%d", ++ error_message, offset); ++ fprintf(stderr, PNG_STRING_NEWLINE); ++ } + } + else + #endif + { +- fprintf(stderr, "libpng error: %s", error_message); ++ fprintf(stderr, "libpng error: %s", error_message ? error_message : ++ "undefined"); + fprintf(stderr, PNG_STRING_NEWLINE); + } ++#else ++ PNG_UNUSED(error_message) /* Make compiler happy */ + #endif ++ png_longjmp(png_ptr, 1); ++} + ++PNG_FUNCTION(void,PNGAPI ++png_longjmp,(png_const_structrp png_ptr, int val),PNG_NORETURN) ++{ + #ifdef PNG_SETJMP_SUPPORTED +- if (png_ptr) +- { +-# ifdef USE_FAR_KEYWORD +- { +- jmp_buf jmpbuf; +- png_memcpy(jmpbuf, png_ptr->jmpbuf, png_sizeof(jmp_buf)); +- longjmp(jmpbuf,1); +- } +-# else +- longjmp(png_ptr->jmpbuf, 1); +-# endif +- } ++ 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 +- /* 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(); +-#ifndef PNG_CONSOLE_IO_SUPPORTED +- error_message = error_message; /* Make compiler happy */ +-#endif + } + + #ifdef PNG_WARNINGS_SUPPORTED +@@ -301,61 +782,69 @@ png_default_error(png_structp png_ptr, png_const_charp error_message) + * 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 + if (*warning_message == PNG_LITERAL_SHARP) + { +- int offset; +- char warning_number[16]; +- for (offset = 0; offset < 15; offset++) +- { +- warning_number[offset] = warning_message[offset + 1]; +- if (warning_message[offset] == ' ') ++ int offset; ++ char warning_number[16]; ++ for (offset = 0; offset < 15; offset++) ++ { ++ warning_number[offset] = warning_message[offset + 1]; ++ if (warning_message[offset] == ' ') + break; +- } +- if ((offset > 1) && (offset < 15)) +- { +- warning_number[offset + 1] = '\0'; +- fprintf(stderr, "libpng warning no. %s: %s", +- warning_number, warning_message + offset); +- fprintf(stderr, PNG_STRING_NEWLINE); +- } +- else +- { +- fprintf(stderr, "libpng warning: %s", +- warning_message); +- fprintf(stderr, PNG_STRING_NEWLINE); +- } ++ } ++ ++ if ((offset > 1) && (offset < 15)) ++ { ++ warning_number[offset + 1] = '\0'; ++ fprintf(stderr, "libpng warning no. %s: %s", ++ warning_number, warning_message + offset); ++ fprintf(stderr, PNG_STRING_NEWLINE); ++ } ++ ++ else ++ { ++ fprintf(stderr, "libpng warning: %s", ++ warning_message); ++ fprintf(stderr, PNG_STRING_NEWLINE); ++ } + } + else + # endif ++ + { +- fprintf(stderr, "libpng warning: %s", warning_message); +- fprintf(stderr, PNG_STRING_NEWLINE); ++ fprintf(stderr, "libpng warning: %s", warning_message); ++ fprintf(stderr, PNG_STRING_NEWLINE); + } + #else +- warning_message = warning_message; /* Make compiler happy */ ++ PNG_UNUSED(warning_message) /* Make compiler happy */ + #endif +- png_ptr = png_ptr; /* Make compiler happy */ ++ 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->jmpbuf, 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_error_ptr error_fn, png_error_ptr warning_fn) ++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) + return; ++ + png_ptr->error_ptr = error_ptr; + png_ptr->error_fn = error_fn; ++#ifdef PNG_WARNINGS_SUPPORTED + png_ptr->warning_fn = warning_fn; ++#else ++ PNG_UNUSED(warning_fn) ++#endif + } + + +@@ -364,23 +853,111 @@ png_set_error_fn(png_structp png_ptr, png_voidp error_ptr, + * pointer before png_write_destroy and png_read_destroy are called. + */ + png_voidp PNGAPI +-png_get_error_ptr(png_structp png_ptr) ++png_get_error_ptr(png_const_structrp png_ptr) + { + if (png_ptr == NULL) + return NULL; ++ + return ((png_voidp)png_ptr->error_ptr); + } + + + #ifdef PNG_ERROR_NUMBERS_SUPPORTED + void PNGAPI +-png_set_strip_error_numbers(png_structp png_ptr, png_uint_32 strip_mode) ++png_set_strip_error_numbers(png_structrp png_ptr, png_uint_32 strip_mode) + { + if (png_ptr != NULL) + { +- png_ptr->flags &= +- ((~(PNG_FLAG_STRIP_ERROR_NUMBERS|PNG_FLAG_STRIP_ERROR_TEXT))&strip_mode); ++ png_ptr->flags &= ++ ((~(PNG_FLAG_STRIP_ERROR_NUMBERS | ++ PNG_FLAG_STRIP_ERROR_TEXT))&strip_mode); + } + } + #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) ++{ ++ 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) ++{ ++ 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 */ +diff --git a/com32/lib/libpng/pngget.c b/com32/lib/libpng/pngget.c +index d397329a..5abf1efd 100644 +--- a/com32/lib/libpng/pngget.c ++++ b/com32/lib/libpng/pngget.c +@@ -1,10 +1,10 @@ + + /* pngget.c - retrieval of values from info struct + * +- * Last changed in libpng 1.2.43 [February 25, 2010] +- * Copyright (c) 1998-2010 Glenn Randers-Pehrson +- * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) +- * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) ++ * Copyright (c) 2018 Cosmin Truta ++ * Copyright (c) 1998-2002,2004,2006-2018 Glenn Randers-Pehrson ++ * Copyright (c) 1996-1997 Andreas Dilger ++ * Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc. + * + * This code is released under the libpng license. + * For conditions of distribution and use, see the disclaimer +@@ -12,47 +12,44 @@ + * + */ + +-#define PNG_INTERNAL +-#define PNG_NO_PEDANTIC_WARNINGS +-#include "png.h" ++#include "pngpriv.h" ++ + #if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED) + + png_uint_32 PNGAPI +-png_get_valid(png_structp png_ptr, png_infop info_ptr, png_uint_32 flag) ++png_get_valid(png_const_structrp png_ptr, png_const_inforp info_ptr, ++ png_uint_32 flag) + { + if (png_ptr != NULL && info_ptr != NULL) + return(info_ptr->valid & flag); + +- else +- return(0); ++ return(0); + } + +-png_uint_32 PNGAPI +-png_get_rowbytes(png_structp png_ptr, png_infop info_ptr) ++size_t PNGAPI ++png_get_rowbytes(png_const_structrp png_ptr, png_const_inforp info_ptr) + { + if (png_ptr != NULL && info_ptr != NULL) + return(info_ptr->rowbytes); + +- else +- return(0); ++ return(0); + } + + #ifdef PNG_INFO_IMAGE_SUPPORTED + png_bytepp PNGAPI +-png_get_rows(png_structp png_ptr, png_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); + +- else +- return(0); ++ return(0); + } + #endif + + #ifdef PNG_EASY_ACCESS_SUPPORTED + /* Easy access to info, added in libpng-0.99 */ + png_uint_32 PNGAPI +-png_get_image_width(png_structp png_ptr, png_infop info_ptr) ++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; +@@ -61,7 +58,7 @@ png_get_image_width(png_structp png_ptr, png_infop info_ptr) + } + + png_uint_32 PNGAPI +-png_get_image_height(png_structp png_ptr, png_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; +@@ -70,7 +67,7 @@ png_get_image_height(png_structp png_ptr, png_infop info_ptr) + } + + png_byte PNGAPI +-png_get_bit_depth(png_structp png_ptr, png_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; +@@ -79,7 +76,7 @@ png_get_bit_depth(png_structp png_ptr, png_infop info_ptr) + } + + png_byte PNGAPI +-png_get_color_type(png_structp png_ptr, png_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; +@@ -88,7 +85,7 @@ png_get_color_type(png_structp png_ptr, png_infop info_ptr) + } + + png_byte PNGAPI +-png_get_filter_type(png_structp png_ptr, png_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; +@@ -97,7 +94,7 @@ png_get_filter_type(png_structp png_ptr, png_infop info_ptr) + } + + png_byte PNGAPI +-png_get_interlace_type(png_structp png_ptr, png_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; +@@ -106,7 +103,7 @@ png_get_interlace_type(png_structp png_ptr, png_infop info_ptr) + } + + png_byte PNGAPI +-png_get_compression_type(png_structp png_ptr, png_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; +@@ -115,226 +112,319 @@ png_get_compression_type(png_structp png_ptr, png_infop info_ptr) + } + + png_uint_32 PNGAPI +-png_get_x_pixels_per_meter(png_structp png_ptr, png_infop info_ptr) ++png_get_x_pixels_per_meter(png_const_structrp png_ptr, png_const_inforp ++ info_ptr) + { +- if (png_ptr != NULL && info_ptr != NULL) + #ifdef PNG_pHYs_SUPPORTED +- if (info_ptr->valid & PNG_INFO_pHYs) +- { +- png_debug1(1, "in %s retrieval function", "png_get_x_pixels_per_meter"); +- +- if (info_ptr->phys_unit_type != PNG_RESOLUTION_METER) +- return (0); ++ 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"); + +- else +- return (info_ptr->x_pixels_per_unit); +- } ++ if (info_ptr->phys_unit_type == PNG_RESOLUTION_METER) ++ return (info_ptr->x_pixels_per_unit); ++ } + #else +- return (0); ++ PNG_UNUSED(png_ptr) ++ PNG_UNUSED(info_ptr) + #endif ++ + return (0); + } + + png_uint_32 PNGAPI +-png_get_y_pixels_per_meter(png_structp png_ptr, png_infop info_ptr) ++png_get_y_pixels_per_meter(png_const_structrp png_ptr, png_const_inforp ++ info_ptr) + { +- if (png_ptr != NULL && info_ptr != NULL) + #ifdef PNG_pHYs_SUPPORTED +- if (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"); +- +- if (info_ptr->phys_unit_type != PNG_RESOLUTION_METER) +- return (0); ++ png_debug1(1, "in %s retrieval function", ++ "png_get_y_pixels_per_meter"); + +- else +- return (info_ptr->y_pixels_per_unit); ++ if (info_ptr->phys_unit_type == PNG_RESOLUTION_METER) ++ return (info_ptr->y_pixels_per_unit); + } + #else +- return (0); ++ PNG_UNUSED(png_ptr) ++ PNG_UNUSED(info_ptr) + #endif ++ + return (0); + } + + png_uint_32 PNGAPI +-png_get_pixels_per_meter(png_structp png_ptr, png_infop info_ptr) ++png_get_pixels_per_meter(png_const_structrp png_ptr, png_const_inforp info_ptr) + { +- if (png_ptr != NULL && info_ptr != NULL) + #ifdef PNG_pHYs_SUPPORTED +- if (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"); + +- if (info_ptr->phys_unit_type != PNG_RESOLUTION_METER || +- info_ptr->x_pixels_per_unit != info_ptr->y_pixels_per_unit) +- return (0); +- +- else +- return (info_ptr->x_pixels_per_unit); ++ if (info_ptr->phys_unit_type == PNG_RESOLUTION_METER && ++ info_ptr->x_pixels_per_unit == info_ptr->y_pixels_per_unit) ++ return (info_ptr->x_pixels_per_unit); + } + #else +- return (0); ++ PNG_UNUSED(png_ptr) ++ PNG_UNUSED(info_ptr) + #endif ++ + return (0); + } + + #ifdef PNG_FLOATING_POINT_SUPPORTED + float PNGAPI +-png_get_pixel_aspect_ratio(png_structp png_ptr, png_infop info_ptr) +- { +- if (png_ptr != NULL && info_ptr != NULL) +-#ifdef PNG_pHYs_SUPPORTED +- +- if (info_ptr->valid & PNG_INFO_pHYs) ++png_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) != 0) + { + png_debug1(1, "in %s retrieval function", "png_get_aspect_ratio"); + +- if (info_ptr->x_pixels_per_unit == 0) +- return ((float)0.0); +- +- else ++ if (info_ptr->x_pixels_per_unit != 0) + return ((float)((float)info_ptr->y_pixels_per_unit +- /(float)info_ptr->x_pixels_per_unit)); ++ /(float)info_ptr->x_pixels_per_unit)); + } + #else +- return (0.0); ++ PNG_UNUSED(png_ptr) ++ PNG_UNUSED(info_ptr) + #endif ++ + return ((float)0.0); + } + #endif + ++#ifdef PNG_FIXED_POINT_SUPPORTED ++png_fixed_point PNGAPI ++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) != 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; ++ ++ png_debug1(1, "in %s retrieval function", "png_get_aspect_ratio_fixed"); ++ ++ /* The following casts work because a PNG 4 byte integer only has a valid ++ * 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) != 0) ++ return res; ++ } ++#else ++ PNG_UNUSED(png_ptr) ++ PNG_UNUSED(info_ptr) ++#endif ++ ++ return 0; ++} ++#endif ++ + png_int_32 PNGAPI +-png_get_x_offset_microns(png_structp png_ptr, png_infop info_ptr) ++png_get_x_offset_microns(png_const_structrp png_ptr, png_const_inforp info_ptr) + { +- if (png_ptr != NULL && info_ptr != NULL) + #ifdef PNG_oFFs_SUPPORTED +- +- if (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 (0); +- +- else +- return (info_ptr->x_offset); ++ if (info_ptr->offset_unit_type == PNG_OFFSET_MICROMETER) ++ return (info_ptr->x_offset); + } + #else +- return (0); ++ PNG_UNUSED(png_ptr) ++ PNG_UNUSED(info_ptr) + #endif ++ + return (0); + } + + png_int_32 PNGAPI +-png_get_y_offset_microns(png_structp png_ptr, png_infop info_ptr) ++png_get_y_offset_microns(png_const_structrp png_ptr, png_const_inforp info_ptr) + { +- if (png_ptr != NULL && info_ptr != NULL) +- + #ifdef PNG_oFFs_SUPPORTED +- if (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 (0); +- +- else +- return (info_ptr->y_offset); ++ if (info_ptr->offset_unit_type == PNG_OFFSET_MICROMETER) ++ return (info_ptr->y_offset); + } + #else +- return (0); ++ PNG_UNUSED(png_ptr) ++ PNG_UNUSED(info_ptr) + #endif ++ + return (0); + } + + png_int_32 PNGAPI +-png_get_x_offset_pixels(png_structp png_ptr, png_infop info_ptr) ++png_get_x_offset_pixels(png_const_structrp png_ptr, png_const_inforp info_ptr) + { +- if (png_ptr != NULL && info_ptr != NULL) +- + #ifdef PNG_oFFs_SUPPORTED +- if (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_PIXEL) +- return (0); ++ png_debug1(1, "in %s retrieval function", "png_get_x_offset_pixels"); + +- else +- return (info_ptr->x_offset); ++ if (info_ptr->offset_unit_type == PNG_OFFSET_PIXEL) ++ return (info_ptr->x_offset); + } + #else +- return (0); ++ PNG_UNUSED(png_ptr) ++ PNG_UNUSED(info_ptr) + #endif ++ + return (0); + } + + png_int_32 PNGAPI +-png_get_y_offset_pixels(png_structp png_ptr, png_infop info_ptr) ++png_get_y_offset_pixels(png_const_structrp png_ptr, png_const_inforp info_ptr) + { +- if (png_ptr != NULL && info_ptr != NULL) +- + #ifdef PNG_oFFs_SUPPORTED +- if (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_PIXEL) +- return (0); ++ png_debug1(1, "in %s retrieval function", "png_get_y_offset_pixels"); + +- else +- return (info_ptr->y_offset); ++ if (info_ptr->offset_unit_type == PNG_OFFSET_PIXEL) ++ return (info_ptr->y_offset); + } + #else +- return (0); ++ PNG_UNUSED(png_ptr) ++ PNG_UNUSED(info_ptr) + #endif ++ + return (0); + } + +-#if defined(PNG_INCH_CONVERSIONS) && defined(PNG_FLOATING_POINT_SUPPORTED) ++#ifdef PNG_INCH_CONVERSIONS_SUPPORTED ++static png_uint_32 ++ppi_from_ppm(png_uint_32 ppm) ++{ ++#if 0 ++ /* The conversion is *(2.54/100), in binary (32 digits): ++ * .00000110100000001001110101001001 ++ */ ++ png_uint_32 t1001, t1101; ++ ppm >>= 1; /* .1 */ ++ t1001 = ppm + (ppm >> 3); /* .1001 */ ++ t1101 = t1001 + (ppm >> 1); /* .1101 */ ++ ppm >>= 20; /* .000000000000000000001 */ ++ t1101 += t1101 >> 15; /* .1101000000000001101 */ ++ t1001 >>= 11; /* .000000000001001 */ ++ t1001 += t1001 >> 12; /* .000000000001001000000001001 */ ++ ppm += t1001; /* .000000000001001000001001001 */ ++ ppm += t1101; /* .110100000001001110101001001 */ ++ return (ppm + 16) >> 5;/* .00000110100000001001110101001001 */ ++#else ++ /* The argument is a PNG unsigned integer, so it is not permitted ++ * to be bigger than 2^31. ++ */ ++ png_fixed_point result; ++ if (ppm <= PNG_UINT_31_MAX && png_muldiv(&result, (png_int_32)ppm, 127, ++ 5000) != 0) ++ return (png_uint_32)result; ++ ++ /* Overflow. */ ++ return 0; ++#endif ++} ++ + png_uint_32 PNGAPI +-png_get_pixels_per_inch(png_structp png_ptr, png_infop info_ptr) ++png_get_pixels_per_inch(png_const_structrp png_ptr, png_const_inforp info_ptr) + { +- return ((png_uint_32)((float)png_get_pixels_per_meter(png_ptr, info_ptr) +- *.0254 +.5)); ++ return ppi_from_ppm(png_get_pixels_per_meter(png_ptr, info_ptr)); + } + + png_uint_32 PNGAPI +-png_get_x_pixels_per_inch(png_structp png_ptr, png_infop info_ptr) ++png_get_x_pixels_per_inch(png_const_structrp png_ptr, png_const_inforp info_ptr) + { +- return ((png_uint_32)((float)png_get_x_pixels_per_meter(png_ptr, info_ptr) +- *.0254 +.5)); ++ 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_structp png_ptr, png_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_const_structrp png_ptr, png_int_32 microns) ++{ ++ /* Convert from meters * 1,000,000 to inches * 100,000, meters to ++ * inches is simply *(100/2.54), so we want *(10/2.54) == 500/127. ++ * Notice that this can overflow - a warning is output and 0 is ++ * returned. ++ */ ++ return png_muldiv_warn(png_ptr, microns, 500, 127); ++} ++ ++png_fixed_point PNGAPI ++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)); ++} ++#endif ++ ++#ifdef PNG_FIXED_POINT_SUPPORTED ++png_fixed_point PNGAPI ++png_get_y_offset_inches_fixed(png_const_structrp png_ptr, ++ png_const_inforp info_ptr) + { +- return ((png_uint_32)((float)png_get_y_pixels_per_meter(png_ptr, info_ptr) +- *.0254 +.5)); ++ return png_fixed_inches_from_microns(png_ptr, ++ png_get_y_offset_microns(png_ptr, info_ptr)); + } ++#endif + ++#ifdef PNG_FLOATING_POINT_SUPPORTED + float PNGAPI +-png_get_x_offset_inches(png_structp png_ptr, png_infop info_ptr) ++png_get_x_offset_inches(png_const_structrp png_ptr, png_const_inforp info_ptr) + { +- return ((float)png_get_x_offset_microns(png_ptr, info_ptr) +- *.00003937); ++ /* To avoid the overflow do the conversion directly in floating ++ * point. ++ */ ++ return (float)(png_get_x_offset_microns(png_ptr, info_ptr) * .00003937); + } ++#endif + ++#ifdef PNG_FLOATING_POINT_SUPPORTED + float PNGAPI +-png_get_y_offset_inches(png_structp png_ptr, png_infop info_ptr) ++png_get_y_offset_inches(png_const_structrp png_ptr, png_const_inforp info_ptr) + { +- return ((float)png_get_y_offset_microns(png_ptr, info_ptr) +- *.00003937); ++ /* To avoid the overflow do the conversion directly in floating ++ * point. ++ */ ++ return (float)(png_get_y_offset_microns(png_ptr, info_ptr) * .00003937); + } ++#endif + + #ifdef PNG_pHYs_SUPPORTED + png_uint_32 PNGAPI +-png_get_pHYs_dpi(png_structp png_ptr, png_infop info_ptr, +- png_uint_32 *res_x, png_uint_32 *res_y, int *unit_type) ++png_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"); + +@@ -343,15 +433,18 @@ png_get_pHYs_dpi(png_structp png_ptr, png_infop info_ptr, + *res_x = info_ptr->x_pixels_per_unit; + retval |= PNG_INFO_pHYs; + } ++ + if (res_y != NULL) + { + *res_y = info_ptr->y_pixels_per_unit; + retval |= PNG_INFO_pHYs; + } ++ + if (unit_type != NULL) + { + *unit_type = (int)info_ptr->phys_unit_type; + retval |= PNG_INFO_pHYs; ++ + if (*unit_type == 1) + { + if (res_x != NULL) *res_x = (png_uint_32)(*res_x * .0254 + .50); +@@ -359,237 +452,397 @@ png_get_pHYs_dpi(png_structp png_ptr, png_infop info_ptr, + } + } + } ++ + return (retval); + } +-#endif /* PNG_pHYs_SUPPORTED */ +-#endif /* PNG_INCH_CONVERSIONS && PNG_FLOATING_POINT_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_structp png_ptr, png_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); +- else +- return (0); ++ ++ return (0); + } + +-png_bytep PNGAPI +-png_get_signature(png_structp png_ptr, png_infop info_ptr) ++#ifdef PNG_READ_SUPPORTED ++png_const_bytep PNGAPI ++png_get_signature(png_const_structrp png_ptr, png_const_inforp info_ptr) + { + if (png_ptr != NULL && info_ptr != NULL) + return(info_ptr->signature); +- else +- return (NULL); ++ ++ return (NULL); + } ++#endif + + #ifdef PNG_bKGD_SUPPORTED + png_uint_32 PNGAPI +-png_get_bKGD(png_structp png_ptr, png_infop info_ptr, +- png_color_16p *background) ++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"); + + *background = &(info_ptr->background); + return (PNG_INFO_bKGD); + } ++ + return (0); + } + #endif + + #ifdef PNG_cHRM_SUPPORTED +-#ifdef PNG_FLOATING_POINT_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_structp png_ptr, png_infop info_ptr, +- double *white_x, double *white_y, double *red_x, double *red_y, +- double *green_x, double *green_y, double *blue_x, double *blue_y) ++png_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 = (double)info_ptr->x_white; ++ *white_x = png_float(png_ptr, ++ info_ptr->colorspace.end_points_xy.whitex, "cHRM white X"); + if (white_y != NULL) +- *white_y = (double)info_ptr->y_white; ++ *white_y = png_float(png_ptr, ++ info_ptr->colorspace.end_points_xy.whitey, "cHRM white Y"); + if (red_x != NULL) +- *red_x = (double)info_ptr->x_red; ++ *red_x = png_float(png_ptr, info_ptr->colorspace.end_points_xy.redx, ++ "cHRM red X"); + if (red_y != NULL) +- *red_y = (double)info_ptr->y_red; ++ *red_y = png_float(png_ptr, info_ptr->colorspace.end_points_xy.redy, ++ "cHRM red Y"); + if (green_x != NULL) +- *green_x = (double)info_ptr->x_green; ++ *green_x = png_float(png_ptr, ++ info_ptr->colorspace.end_points_xy.greenx, "cHRM green X"); + if (green_y != NULL) +- *green_y = (double)info_ptr->y_green; ++ *green_y = png_float(png_ptr, ++ info_ptr->colorspace.end_points_xy.greeny, "cHRM green Y"); + if (blue_x != NULL) +- *blue_x = (double)info_ptr->x_blue; ++ *blue_x = png_float(png_ptr, info_ptr->colorspace.end_points_xy.bluex, ++ "cHRM blue X"); + if (blue_y != NULL) +- *blue_y = (double)info_ptr->y_blue; ++ *blue_y = png_float(png_ptr, info_ptr->colorspace.end_points_xy.bluey, ++ "cHRM blue Y"); + return (PNG_INFO_cHRM); + } ++ + return (0); + } +-#endif +-#ifdef PNG_FIXED_POINT_SUPPORTED ++ + png_uint_32 PNGAPI +-png_get_cHRM_fixed(png_structp png_ptr, png_infop info_ptr, +- png_fixed_point *white_x, png_fixed_point *white_y, png_fixed_point *red_x, +- png_fixed_point *red_y, png_fixed_point *green_x, png_fixed_point *green_y, +- png_fixed_point *blue_x, png_fixed_point *blue_y) ++png_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); ++ } ++ ++ return (0); ++} ++# endif ++ ++# ifdef PNG_FIXED_POINT_SUPPORTED ++png_uint_32 PNGAPI ++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->int_x_white; ++ *white_x = info_ptr->colorspace.end_points_xy.whitex; + if (white_y != NULL) +- *white_y = info_ptr->int_y_white; ++ *white_y = info_ptr->colorspace.end_points_xy.whitey; + if (red_x != NULL) +- *red_x = info_ptr->int_x_red; ++ *red_x = info_ptr->colorspace.end_points_xy.redx; + if (red_y != NULL) +- *red_y = info_ptr->int_y_red; ++ *red_y = info_ptr->colorspace.end_points_xy.redy; + if (green_x != NULL) +- *green_x = info_ptr->int_x_green; ++ *green_x = info_ptr->colorspace.end_points_xy.greenx; + if (green_y != NULL) +- *green_y = info_ptr->int_y_green; ++ *green_y = info_ptr->colorspace.end_points_xy.greeny; + if (blue_x != NULL) +- *blue_x = info_ptr->int_x_blue; ++ *blue_x = info_ptr->colorspace.end_points_xy.bluex; + if (blue_y != NULL) +- *blue_y = info_ptr->int_y_blue; ++ *blue_y = info_ptr->colorspace.end_points_xy.bluey; + return (PNG_INFO_cHRM); + } ++ + return (0); + } +-#endif ++# endif + #endif + + #ifdef PNG_gAMA_SUPPORTED +-#ifdef PNG_FLOATING_POINT_SUPPORTED ++# ifdef PNG_FIXED_POINT_SUPPORTED + png_uint_32 PNGAPI +-png_get_gAMA(png_structp png_ptr, png_infop info_ptr, double *file_gamma) ++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 = (double)info_ptr->gamma; ++ *file_gamma = info_ptr->colorspace.gamma; + return (PNG_INFO_gAMA); + } ++ + return (0); + } +-#endif +-#ifdef PNG_FIXED_POINT_SUPPORTED ++# endif ++ ++# ifdef PNG_FLOATING_POINT_SUPPORTED + png_uint_32 PNGAPI +-png_get_gAMA_fixed(png_structp png_ptr, png_infop info_ptr, +- png_fixed_point *int_file_gamma) ++png_get_gAMA(png_const_structrp png_ptr, png_const_inforp info_ptr, ++ double *file_gamma) + { +- png_debug1(1, "in %s retrieval function", "gAMA"); ++ png_debug1(1, "in %s retrieval function", "gAMA(float)"); + +- if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_gAMA) +- && int_file_gamma != NULL) ++ if (png_ptr != NULL && info_ptr != NULL && ++ (info_ptr->colorspace.flags & PNG_COLORSPACE_HAVE_GAMMA) != 0 && ++ file_gamma != NULL) + { +- *int_file_gamma = info_ptr->int_gamma; ++ *file_gamma = png_float(png_ptr, info_ptr->colorspace.gamma, ++ "png_get_gAMA"); + return (PNG_INFO_gAMA); + } ++ + return (0); + } +-#endif ++# endif + #endif + + #ifdef PNG_sRGB_SUPPORTED + png_uint_32 PNGAPI +-png_get_sRGB(png_structp png_ptr, png_infop info_ptr, int *file_srgb_intent) ++png_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); + } ++ + return (0); + } + #endif + + #ifdef PNG_iCCP_SUPPORTED + png_uint_32 PNGAPI +-png_get_iCCP(png_structp png_ptr, png_infop info_ptr, +- png_charpp name, int *compression_type, +- png_charpp profile, png_uint_32 *proflen) ++png_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 && 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; ++ if (compression_type != NULL) ++ *compression_type = PNG_COMPRESSION_TYPE_BASE; + return (PNG_INFO_iCCP); + } ++ + return (0); ++ + } + #endif + + #ifdef PNG_sPLT_SUPPORTED +-png_uint_32 PNGAPI +-png_get_sPLT(png_structp png_ptr, png_infop info_ptr, +- png_sPLT_tpp spalettes) ++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); ++ *spalettes = info_ptr->splt_palettes; ++ return info_ptr->splt_palettes_num; ++ } ++ ++ return (0); ++} ++#endif ++ ++#ifdef PNG_eXIf_SUPPORTED ++png_uint_32 PNGAPI ++png_get_eXIf(png_const_structrp png_ptr, png_inforp info_ptr, ++ png_bytep *exif) ++{ ++ png_warning(png_ptr, "png_get_eXIf does not work; use png_get_eXIf_1"); ++ PNG_UNUSED(info_ptr) ++ PNG_UNUSED(exif) ++ return 0; ++} ++ ++png_uint_32 PNGAPI ++png_get_eXIf_1(png_const_structrp png_ptr, png_const_inforp info_ptr, ++ png_uint_32 *num_exif, png_bytep *exif) ++{ ++ png_debug1(1, "in %s retrieval function", "eXIf"); ++ ++ if (png_ptr != NULL && info_ptr != NULL && ++ (info_ptr->valid & PNG_INFO_eXIf) != 0 && exif != NULL) ++ { ++ *num_exif = info_ptr->num_exif; ++ *exif = info_ptr->exif; ++ return (PNG_INFO_eXIf); + } ++ + return (0); + } + #endif + + #ifdef PNG_hIST_SUPPORTED + png_uint_32 PNGAPI +-png_get_hIST(png_structp png_ptr, png_infop info_ptr, png_uint_16p *hist) ++png_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); + } ++ + return (0); + } + #endif + + png_uint_32 PNGAPI +-png_get_IHDR(png_structp png_ptr, png_infop info_ptr, +- png_uint_32 *width, png_uint_32 *height, int *bit_depth, +- int *color_type, int *interlace_type, int *compression_type, +- int *filter_type) +- ++png_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"); + +- if (png_ptr == NULL || info_ptr == NULL || width == NULL || +- height == NULL || bit_depth == NULL || color_type == NULL) ++ if (png_ptr == NULL || info_ptr == NULL) + return (0); + +- *width = info_ptr->width; +- *height = info_ptr->height; +- *bit_depth = info_ptr->bit_depth; +- *color_type = info_ptr->color_type; ++ if (width != NULL) ++ *width = info_ptr->width; ++ ++ if (height != NULL) ++ *height = info_ptr->height; ++ ++ if (bit_depth != NULL) ++ *bit_depth = info_ptr->bit_depth; ++ ++ if (color_type != NULL) ++ *color_type = info_ptr->color_type; + + if (compression_type != NULL) + *compression_type = info_ptr->compression_type; +@@ -605,7 +858,7 @@ png_get_IHDR(png_structp png_ptr, png_infop info_ptr, + * 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); + +@@ -614,33 +867,36 @@ png_get_IHDR(png_structp png_ptr, png_infop info_ptr, + + #ifdef PNG_oFFs_SUPPORTED + png_uint_32 PNGAPI +-png_get_oFFs(png_structp png_ptr, png_infop info_ptr, +- png_int_32 *offset_x, png_int_32 *offset_y, int *unit_type) ++png_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; + *unit_type = (int)info_ptr->offset_unit_type; + return (PNG_INFO_oFFs); + } ++ + return (0); + } + #endif + + #ifdef PNG_pCAL_SUPPORTED + png_uint_32 PNGAPI +-png_get_pCAL(png_structp png_ptr, png_infop info_ptr, +- png_charp *purpose, png_int_32 *X0, png_int_32 *X1, int *type, int *nparams, +- png_charp *units, png_charpp *params) ++png_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; +@@ -652,57 +908,82 @@ png_get_pCAL(png_structp png_ptr, png_infop info_ptr, + *params = info_ptr->pcal_params; + return (PNG_INFO_pCAL); + } ++ + return (0); + } + #endif + + #ifdef PNG_sCAL_SUPPORTED +-#ifdef PNG_FLOATING_POINT_SUPPORTED ++# ifdef PNG_FIXED_POINT_SUPPORTED ++# if defined(PNG_FLOATING_ARITHMETIC_SUPPORTED) || \ ++ defined(PNG_FLOATING_POINT_SUPPORTED) + png_uint_32 PNGAPI +-png_get_sCAL(png_structp png_ptr, png_infop info_ptr, +- int *unit, double *width, double *height) ++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)) +- { +- *unit = info_ptr->scal_unit; +- *width = info_ptr->scal_pixel_width; +- *height = info_ptr->scal_pixel_height; +- return (PNG_INFO_sCAL); +- } +- return(0); ++ if (png_ptr != NULL && info_ptr != NULL && ++ (info_ptr->valid & PNG_INFO_sCAL) != 0) ++ { ++ *unit = info_ptr->scal_unit; ++ /*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"); ++ return (PNG_INFO_sCAL); ++ } ++ ++ return(0); + } +-#else +-#ifdef PNG_FIXED_POINT_SUPPORTED ++# endif /* FLOATING_ARITHMETIC */ ++# endif /* FIXED_POINT */ ++# ifdef PNG_FLOATING_POINT_SUPPORTED + png_uint_32 PNGAPI +-png_get_sCAL_s(png_structp png_ptr, png_infop info_ptr, +- int *unit, png_charpp width, png_charpp height) ++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)) +- { +- *unit = info_ptr->scal_unit; +- *width = info_ptr->scal_s_width; +- *height = info_ptr->scal_s_height; +- return (PNG_INFO_sCAL); +- } +- return(0); ++ if (png_ptr != NULL && info_ptr != NULL && ++ (info_ptr->valid & PNG_INFO_sCAL) != 0) ++ { ++ *unit = info_ptr->scal_unit; ++ *width = atof(info_ptr->scal_s_width); ++ *height = atof(info_ptr->scal_s_height); ++ return (PNG_INFO_sCAL); ++ } ++ ++ return(0); + } +-#endif +-#endif +-#endif ++# endif /* FLOATING POINT */ ++png_uint_32 PNGAPI ++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) != 0) ++ { ++ *unit = info_ptr->scal_unit; ++ *width = info_ptr->scal_s_width; ++ *height = info_ptr->scal_s_height; ++ return (PNG_INFO_sCAL); ++ } ++ ++ return(0); ++} ++#endif /* sCAL */ + + #ifdef PNG_pHYs_SUPPORTED + png_uint_32 PNGAPI +-png_get_pHYs(png_structp png_ptr, png_infop info_ptr, +- png_uint_32 *res_x, png_uint_32 *res_y, int *unit_type) ++png_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; + + 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) + { +@@ -722,53 +1003,56 @@ png_get_pHYs(png_structp png_ptr, png_infop info_ptr, + retval |= PNG_INFO_pHYs; + } + } ++ + return (retval); + } +-#endif ++#endif /* pHYs */ + + png_uint_32 PNGAPI +-png_get_PLTE(png_structp png_ptr, png_infop info_ptr, png_colorp *palette, +- int *num_palette) ++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; + png_debug1(3, "num_palette = %d", *num_palette); + return (PNG_INFO_PLTE); + } ++ + return (0); + } + + #ifdef PNG_sBIT_SUPPORTED + png_uint_32 PNGAPI +-png_get_sBIT(png_structp png_ptr, png_infop info_ptr, png_color_8p *sig_bit) ++png_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); + } ++ + return (0); + } + #endif + + #ifdef PNG_TEXT_SUPPORTED +-png_uint_32 PNGAPI +-png_get_text(png_structp png_ptr, png_infop info_ptr, png_textp *text_ptr, +- int *num_text) ++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; +@@ -776,169 +1060,190 @@ png_get_text(png_structp png_ptr, png_infop info_ptr, png_textp *text_ptr, + if (num_text != NULL) + *num_text = info_ptr->num_text; + +- return ((png_uint_32)info_ptr->num_text); ++ return info_ptr->num_text; + } ++ + if (num_text != NULL) +- *num_text = 0; ++ *num_text = 0; ++ + return(0); + } + #endif + + #ifdef PNG_tIME_SUPPORTED + png_uint_32 PNGAPI +-png_get_tIME(png_structp png_ptr, png_infop info_ptr, png_timep *mod_time) ++png_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); + } ++ + return (0); + } + #endif + + #ifdef PNG_tRNS_SUPPORTED + png_uint_32 PNGAPI +-png_get_tRNS(png_structp png_ptr, png_infop info_ptr, +- png_bytep *trans, int *num_trans, png_color_16p *trans_values) ++png_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"); + + if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE) + { +- if (trans != NULL) +- { +- *trans = info_ptr->trans; +- retval |= PNG_INFO_tRNS; +- } +- +- if (trans_values != NULL) +- *trans_values = &(info_ptr->trans_values); ++ if (trans_alpha != NULL) ++ { ++ *trans_alpha = info_ptr->trans_alpha; ++ retval |= PNG_INFO_tRNS; ++ } ++ ++ if (trans_color != NULL) ++ *trans_color = &(info_ptr->trans_color); + } ++ + else /* if (info_ptr->color_type != PNG_COLOR_TYPE_PALETTE) */ + { +- if (trans_values != NULL) +- { +- *trans_values = &(info_ptr->trans_values); +- retval |= PNG_INFO_tRNS; +- } +- +- if (trans != NULL) +- *trans = NULL; ++ if (trans_color != NULL) ++ { ++ *trans_color = &(info_ptr->trans_color); ++ retval |= PNG_INFO_tRNS; ++ } ++ ++ if (trans_alpha != NULL) ++ *trans_alpha = NULL; + } ++ + if (num_trans != NULL) + { + *num_trans = info_ptr->num_trans; + retval |= PNG_INFO_tRNS; + } + } ++ + return (retval); + } + #endif + +-#ifdef PNG_UNKNOWN_CHUNKS_SUPPORTED +-png_uint_32 PNGAPI +-png_get_unknown_chunks(png_structp png_ptr, png_infop info_ptr, +- png_unknown_chunkpp unknowns) ++#ifdef PNG_STORE_UNKNOWN_CHUNKS_SUPPORTED ++int PNGAPI ++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) + { +- *unknowns = info_ptr->unknown_chunks; +- return ((png_uint_32)info_ptr->unknown_chunks_num); ++ *unknowns = info_ptr->unknown_chunks; ++ return info_ptr->unknown_chunks_num; + } ++ + return (0); + } + #endif + + #ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED + png_byte PNGAPI +-png_get_rgb_to_gray_status (png_structp png_ptr) ++png_get_rgb_to_gray_status (png_const_structrp png_ptr) + { +- return (png_byte)(png_ptr? png_ptr->rgb_to_gray_status : 0); ++ return (png_byte)(png_ptr ? png_ptr->rgb_to_gray_status : 0); + } + #endif + + #ifdef PNG_USER_CHUNKS_SUPPORTED + png_voidp PNGAPI +-png_get_user_chunk_ptr(png_structp png_ptr) ++png_get_user_chunk_ptr(png_const_structrp png_ptr) + { +- return (png_ptr? png_ptr->user_chunk_ptr : NULL); ++ return (png_ptr ? png_ptr->user_chunk_ptr : NULL); + } + #endif + +-png_uint_32 PNGAPI +-png_get_compression_buffer_size(png_structp png_ptr) ++size_t PNGAPI ++png_get_compression_buffer_size(png_const_structrp png_ptr) + { +- return (png_uint_32)(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_ASSEMBLER_CODE_SUPPORTED +-#ifndef PNG_1_0_X +-/* This function was added to libpng 1.2.0 and should exist by default */ ++#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_asm_flags (png_structp png_ptr) ++png_get_user_width_max (png_const_structrp png_ptr) + { +- /* Obsolete, to be removed from libpng-1.4.0 */ +- return (png_ptr? 0L: 0L); ++ return (png_ptr ? png_ptr->user_width_max : 0); + } + +-/* This function was added to libpng 1.2.0 and should exist by default */ + png_uint_32 PNGAPI +-png_get_asm_flagmask (int flag_select) ++png_get_user_height_max (png_const_structrp png_ptr) + { +- /* Obsolete, to be removed from libpng-1.4.0 */ +- flag_select=flag_select; +- return 0L; ++ return (png_ptr ? png_ptr->user_height_max : 0); + } + +- /* GRR: could add this: && defined(PNG_MMX_CODE_SUPPORTED) */ +-/* This function was added to libpng 1.2.0 */ ++/* This function was added to libpng 1.4.0 */ + png_uint_32 PNGAPI +-png_get_mmx_flagmask (int flag_select, int *compilerID) ++png_get_chunk_cache_max (png_const_structrp png_ptr) + { +- /* Obsolete, to be removed from libpng-1.4.0 */ +- flag_select=flag_select; +- *compilerID = -1; /* unknown (i.e., no asm/MMX code compiled) */ +- return 0L; ++ return (png_ptr ? png_ptr->user_chunk_cache_max : 0); + } + +-/* This function was added to libpng 1.2.0 */ +-png_byte PNGAPI +-png_get_mmx_bitdepth_threshold (png_structp png_ptr) ++/* This function was added to libpng 1.4.1 */ ++png_alloc_size_t PNGAPI ++png_get_chunk_malloc_max (png_const_structrp png_ptr) + { +- /* Obsolete, to be removed from libpng-1.4.0 */ +- return (png_ptr? 0: 0); ++ return (png_ptr ? png_ptr->user_chunk_malloc_max : 0); + } ++#endif /* SET_USER_LIMITS */ + +-/* This function was added to libpng 1.2.0 */ ++/* These functions were added to libpng 1.4.0 */ ++#ifdef PNG_IO_STATE_SUPPORTED + png_uint_32 PNGAPI +-png_get_mmx_rowbytes_threshold (png_structp png_ptr) ++png_get_io_state (png_const_structrp png_ptr) + { +- /* Obsolete, to be removed from libpng-1.4.0 */ +- return (png_ptr? 0L: 0L); ++ return png_ptr->io_state; + } +-#endif /* ?PNG_1_0_X */ +-#endif /* ?PNG_ASSEMBLER_CODE_SUPPORTED */ + +-#ifdef PNG_SET_USER_LIMITS_SUPPORTED +-/* These functions were added to libpng 1.2.6 but not enabled +-* by default. They will be enabled in libpng-1.4.0 */ + png_uint_32 PNGAPI +-png_get_user_width_max (png_structp png_ptr) ++png_get_io_chunk_type (png_const_structrp png_ptr) + { +- return (png_ptr? png_ptr->user_width_max : 0); ++ return png_ptr->chunk_name; + } +-png_uint_32 PNGAPI +-png_get_user_height_max (png_structp png_ptr) ++#endif /* IO_STATE */ ++ ++#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) + { +- return (png_ptr? png_ptr->user_height_max : 0); ++ if (png_ptr != NULL && info_ptr != NULL) ++ return png_ptr->num_palette_max; ++ ++ return (-1); + } +-#endif /* ?PNG_SET_USER_LIMITS_SUPPORTED */ ++# endif ++#endif + +-#endif /* PNG_READ_SUPPORTED || PNG_WRITE_SUPPORTED */ ++#endif /* READ || WRITE */ +diff --git a/com32/lib/libpng/pngmem.c b/com32/lib/libpng/pngmem.c +index 91f27654..09ed9c1c 100644 +--- a/com32/lib/libpng/pngmem.c ++++ b/com32/lib/libpng/pngmem.c +@@ -1,10 +1,10 @@ + + /* pngmem.c - stub functions for memory allocation + * +- * Last changed in libpng 1.2.41 [February 25, 2010] +- * Copyright (c) 1998-2010 Glenn Randers-Pehrson +- * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) +- * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) ++ * Copyright (c) 2018 Cosmin Truta ++ * Copyright (c) 1998-2002,2004,2006-2014,2016 Glenn Randers-Pehrson ++ * Copyright (c) 1996-1997 Andreas Dilger ++ * Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc. + * + * This code is released under the libpng license. + * For conditions of distribution and use, see the disclaimer +@@ -17,597 +17,239 @@ + * identify the replacement functions. + */ + +-#define PNG_INTERNAL +-#define PNG_NO_PEDANTIC_WARNINGS +-#include "png.h" +-#if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED) +- +-/* Borland DOS special memory handler */ +-#if defined(__TURBOC__) && !defined(_Windows) && !defined(__FLAT__) +-/* If you change this, be sure to change the one in png.h also */ +- +-/* Allocate memory for a png_struct. The malloc and memset can be replaced +- by a single call to calloc() if this is thought to improve performance. */ +-png_voidp /* PRIVATE */ +-png_create_struct(int type) +-{ +-#ifdef PNG_USER_MEM_SUPPORTED +- return (png_create_struct_2(type, png_malloc_ptr_NULL, png_voidp_NULL)); +-} +- +-/* Alternate version of png_create_struct, for use with user-defined malloc. */ +-png_voidp /* PRIVATE */ +-png_create_struct_2(int type, png_malloc_ptr malloc_fn, png_voidp mem_ptr) +-{ +-#endif /* PNG_USER_MEM_SUPPORTED */ +- png_size_t size; +- png_voidp struct_ptr; +- +- if (type == PNG_STRUCT_INFO) +- size = png_sizeof(png_info); +- else if (type == PNG_STRUCT_PNG) +- size = png_sizeof(png_struct); +- else +- return (png_get_copyright(NULL)); +- +-#ifdef PNG_USER_MEM_SUPPORTED +- if (malloc_fn != NULL) +- { +- png_struct dummy_struct; +- png_structp png_ptr = &dummy_struct; +- png_ptr->mem_ptr=mem_ptr; +- struct_ptr = (*(malloc_fn))(png_ptr, (png_uint_32)size); +- } +- else +-#endif /* PNG_USER_MEM_SUPPORTED */ +- struct_ptr = (png_voidp)farmalloc(size); +- if (struct_ptr != NULL) +- png_memset(struct_ptr, 0, size); +- return (struct_ptr); +-} +- +-/* Free memory allocated by a png_create_struct() call */ +-void /* PRIVATE */ +-png_destroy_struct(png_voidp struct_ptr) +-{ +-#ifdef PNG_USER_MEM_SUPPORTED +- png_destroy_struct_2(struct_ptr, png_free_ptr_NULL, png_voidp_NULL); +-} ++#include "pngpriv.h" + +-/* Free memory allocated by a png_create_struct() call */ ++#if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED) ++/* Free a png_struct */ + void /* PRIVATE */ +-png_destroy_struct_2(png_voidp struct_ptr, png_free_ptr free_fn, +- png_voidp mem_ptr) ++png_destroy_png_struct(png_structrp png_ptr) + { +-#endif +- if (struct_ptr != NULL) ++ if (png_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); ++ /* 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); ++ ++# ifdef PNG_SETJMP_SUPPORTED ++ /* We may have a jmp_buf left to deallocate. */ ++ png_free_jmpbuf(&dummy_struct); ++# endif + } + } + + /* Allocate memory. For reasonable files, size should never exceed +- * 64K. However, zlib may allocate more then 64K if you don't tell +- * it not to. See zconf.h and png.h for more information. zlib does ++ * 64K. However, zlib may allocate more than 64K if you don't tell ++ * it not to. See zconf.h and png.h for more information. zlib does + * need to allocate exactly 64K, so whatever you call here must + * have the ability to do that. +- * +- * Borland seems to have a problem in DOS mode for exactly 64K. +- * It gives you a segment with an offset of 8 (perhaps to store its +- * memory stuff). zlib doesn't like this at all, so we have to +- * detect and deal with it. This code should not be needed in +- * Windows or OS/2 modes, and only in 16 bit mode. This code has +- * been updated by Alexander Lehmann for version 0.89 to waste less +- * memory. +- * +- * Note that we can't use png_size_t for the "size" declaration, +- * since on some systems a png_size_t is a 16-bit quantity, and as a +- * result, we would be truncating potentially larger memory requests +- * (which should cause a fatal error) and introducing major problems. + */ +-png_voidp /* PRIVATE */ +-png_calloc(png_structp png_ptr, png_uint_32 size) ++PNG_FUNCTION(png_voidp,PNGAPI ++png_calloc,(png_const_structrp 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_voidp PNGAPI +-png_malloc(png_structp png_ptr, png_uint_32 size) +-{ +- png_voidp ret; ++ ret = png_malloc(png_ptr, size); + +- if (png_ptr == NULL || size == 0) +- return (NULL); ++ if (ret != NULL) ++ memset(ret, 0, size); + +-#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); ++ return ret; + } + +-png_voidp PNGAPI +-png_malloc_default(png_structp png_ptr, png_uint_32 size) ++/* 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) + { +- png_voidp ret; +-#endif /* PNG_USER_MEM_SUPPORTED */ +- +- if (png_ptr == NULL || size == 0) +- return (NULL); +- +-#ifdef PNG_MAX_MALLOC_64K +- if (size > (png_uint_32)65536L) +- { +- png_warning(png_ptr, "Cannot Allocate > 64K"); +- ret = NULL; +- } +- else +-#endif +- +- if (size != (size_t)size) +- ret = NULL; +- else if (size == (png_uint_32)65536L) +- { +- if (png_ptr->offset_table == NULL) +- { +- /* Try to see if we need to do any of this fancy stuff */ +- ret = farmalloc(size); +- if (ret == NULL || ((png_size_t)ret & 0xffff)) +- { +- int num_blocks; +- png_uint_32 total_size; +- png_bytep table; +- int i; +- png_byte huge * hptr; +- +- if (ret != NULL) +- { +- farfree(ret); +- ret = NULL; +- } +- +- if (png_ptr->zlib_window_bits > 14) +- num_blocks = (int)(1 << (png_ptr->zlib_window_bits - 14)); +- else +- num_blocks = 1; +- if (png_ptr->zlib_mem_level >= 7) +- num_blocks += (int)(1 << (png_ptr->zlib_mem_level - 7)); +- else +- num_blocks++; +- +- total_size = ((png_uint_32)65536L) * (png_uint_32)num_blocks+16; +- +- table = farmalloc(total_size); +- +- if (table == NULL) +- { +-#ifndef PNG_USER_MEM_SUPPORTED +- if ((png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0) +- png_error(png_ptr, "Out Of Memory."); /* Note "O", "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) +- { ++ /* 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 +- 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."); ++ PNG_UNUSED(png_ptr) + #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) ++ /* Some compilers complain that this is always true. However, it ++ * can be false when integer overflow happens. ++ */ ++ if (size > 0 && size <= PNG_SIZE_MAX ++# ifdef PNG_MAX_MALLOC_64K ++ && size <= 65536U ++# endif ++ ) + { +- if ((png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0) +- png_error(png_ptr, "Out of memory."); /* Note "o" and "m" */ ++#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 +- png_warning(png_ptr, "Out of memory."); /* Note "o" and "m" */ +- } + #endif ++ return malloc((size_t)size); /* checked for truncation above */ ++ } + +- return (ret); ++ else ++ return NULL; + } + +-/* 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. ++#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. + */ +-void PNGAPI +-png_free(png_structp png_ptr, png_voidp ptr) ++static png_voidp ++png_malloc_array_checked(png_const_structrp png_ptr, int nelements, ++ size_t element_size) + { +- if (png_ptr == NULL || ptr == NULL) +- return; ++ png_alloc_size_t req = (png_alloc_size_t)nelements; /* known to be > 0 */ + +-#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); ++ 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; + } + +-void PNGAPI +-png_free_default(png_structp png_ptr, png_voidp ptr) ++PNG_FUNCTION(png_voidp /* PRIVATE */, ++png_malloc_array,(png_const_structrp png_ptr, int nelements, ++ size_t element_size),PNG_ALLOCATED) + { +-#endif /* PNG_USER_MEM_SUPPORTED */ ++ if (nelements <= 0 || element_size == 0) ++ png_error(png_ptr, "internal error: array alloc"); + +- if (png_ptr == NULL || ptr == NULL) +- return; ++ return png_malloc_array_checked(png_ptr, nelements, element_size); ++} + +- if (png_ptr->offset_table != NULL) ++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) + { +- int i; ++ png_voidp new_array = png_malloc_array_checked(png_ptr, ++ old_elements+add_elements, element_size); + +- for (i = 0; i < png_ptr->offset_table_count; i++) ++ if (new_array != NULL) + { +- 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; +- } +- } ++ /* 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); + +- if (ptr != NULL) +- { +- farfree(ptr); +- } +-} ++ memset((char*)new_array + element_size*(unsigned)old_elements, 0, ++ element_size*(unsigned)add_elements); + +-#else /* Not the Borland DOS special memory handler */ ++ return new_array; ++ } ++ } + +-/* Allocate memory for a png_struct or a png_info. The malloc and +- memset can be replaced by a single call to calloc() if this is thought +- to improve performance noticably. */ +-png_voidp /* PRIVATE */ +-png_create_struct(int type) +-{ +-#ifdef PNG_USER_MEM_SUPPORTED +- return (png_create_struct_2(type, png_malloc_ptr_NULL, png_voidp_NULL)); ++ return NULL; /* error */ + } ++#endif /* TEXT || sPLT || STORE_UNKNOWN_CHUNKS */ + +-/* Allocate memory for a png_struct or a png_info. The malloc and +- memset can be replaced by a single call to calloc() if this is thought +- to improve performance noticably. */ +-png_voidp /* PRIVATE */ +-png_create_struct_2(int type, png_malloc_ptr malloc_fn, png_voidp mem_ptr) ++/* 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_const_structrp png_ptr, png_alloc_size_t size),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); ++ png_voidp ret; + +-#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); ++ if (png_ptr == NULL) ++ return NULL; + +- return (struct_ptr); +-} ++ ret = png_malloc_base(png_ptr, size); + ++ if (ret == NULL) ++ png_error(png_ptr, "Out of memory"); /* 'm' means png_malloc */ + +-/* Free memory allocated by a png_create_struct() call */ +-void /* PRIVATE */ +-png_destroy_struct(png_voidp struct_ptr) +-{ +-#ifdef PNG_USER_MEM_SUPPORTED +- png_destroy_struct_2(struct_ptr, png_free_ptr_NULL, png_voidp_NULL); ++ return ret; + } + +-/* Free memory allocated by a png_create_struct() call */ +-void /* PRIVATE */ +-png_destroy_struct_2(png_voidp struct_ptr, png_free_ptr free_fn, +- png_voidp mem_ptr) +-{ +-#endif /* PNG_USER_MEM_SUPPORTED */ +- if (struct_ptr != NULL) +- { + #ifdef PNG_USER_MEM_SUPPORTED +- if (free_fn != NULL) +- { +- png_struct dummy_struct; +- png_structp png_ptr = &dummy_struct; +- png_ptr->mem_ptr=mem_ptr; +- (*(free_fn))(png_ptr, struct_ptr); +- return; +- } +-#endif /* PNG_USER_MEM_SUPPORTED */ +-#if defined(__TURBOC__) && !defined(__FLAT__) +- farfree(struct_ptr); +-#else +-# if defined(_MSC_VER) && defined(MAXSEG_64K) +- hfree(struct_ptr); +-# else +- free(struct_ptr); +-# endif +-#endif +- } +-} +- +-/* Allocate memory. For reasonable files, size should never exceed +- * 64K. However, zlib may allocate more then 64K if you don't tell +- * it not to. See zconf.h and png.h for more information. zlib does +- * need to allocate exactly 64K, so whatever you call here must +- * have the ability to do that. +- */ +- +-png_voidp PNGAPI +-png_calloc(png_structp png_ptr, png_uint_32 size) ++PNG_FUNCTION(png_voidp,PNGAPI ++png_malloc_default,(png_const_structrp png_ptr, png_alloc_size_t size), ++ PNG_ALLOCATED PNG_DEPRECATED) + { + png_voidp ret; + +- ret = (png_malloc(png_ptr, size)); +- if (ret != NULL) +- png_memset(ret,0,(png_size_t)size); +- return (ret); +-} ++ if (png_ptr == NULL) ++ return NULL; + +-png_voidp PNGAPI +-png_malloc(png_structp png_ptr, png_uint_32 size) +-{ +- png_voidp ret; ++ /* Passing 'NULL' here bypasses the application provided memory handler. */ ++ ret = png_malloc_base(NULL/*use malloc*/, size); + +-#ifdef PNG_USER_MEM_SUPPORTED +- if (png_ptr == NULL || size == 0) +- return (NULL); ++ if (ret == NULL) ++ png_error(png_ptr, "Out of Memory"); /* 'M' means png_malloc_default */ + +- 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); ++ return ret; + } ++#endif /* USER_MEM */ + +-png_voidp PNGAPI +-png_malloc_default(png_structp png_ptr, png_uint_32 size) ++/* 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) + { +- 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) ++ 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"); +- else +-#endif +- return NULL; +- } +-#endif ++ png_voidp ret = png_malloc_base(png_ptr, size); + +- /* 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 ++ if (ret != NULL) ++ return ret; + +-#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 ++ png_warning(png_ptr, "Out of memory"); ++ } + +- 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 + 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 */ +- +-#ifdef PNG_1_0_X +-# define png_malloc_warn png_malloc +-#else +-/* This function was added at libpng version 1.2.3. The png_malloc_warn() +- * function will set up png_malloc() to issue a png_warning and return NULL +- * instead of issuing a png_error, if it fails to allocate the requested +- * memory. +- */ +-png_voidp PNGAPI +-png_malloc_warn(png_structp png_ptr, png_uint_32 size) +-{ +- png_voidp ptr; +- png_uint_32 save_flags; +- if (png_ptr == NULL) +- return (NULL); +- +- save_flags = png_ptr->flags; +- png_ptr->flags|=PNG_FLAG_MALLOC_NULL_MEM_OK; +- ptr = (png_voidp)png_malloc((png_structp)png_ptr, size); +- png_ptr->flags=save_flags; +- return(ptr); +-} +-#endif +- +-png_voidp PNGAPI +-png_memcpy_check (png_structp png_ptr, png_voidp s1, png_voidp s2, +- png_uint_32 length) +-{ +- png_size_t size; +- +- size = (png_size_t)length; +- if ((png_uint_32)size != length) +- png_error(png_ptr, "Overflow in png_memcpy_check."); +- +- return(png_memcpy (s1, s2, size)); +-} +- +-png_voidp PNGAPI +-png_memset_check (png_structp png_ptr, png_voidp s1, int value, +- png_uint_32 length) +-{ +- png_size_t size; +- +- size = (png_size_t)length; +- if ((png_uint_32)size != length) +- png_error(png_ptr, "Overflow in png_memset_check."); +- +- return (png_memset (s1, value, size)); +- + } + + #ifdef PNG_USER_MEM_SUPPORTED +@@ -615,7 +257,7 @@ png_memset_check (png_structp png_ptr, png_voidp s1, int value, + * 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) +@@ -631,11 +273,12 @@ png_set_mem_fn(png_structp png_ptr, png_voidp mem_ptr, png_malloc_ptr + * pointer before png_write_destroy and png_read_destroy are called. + */ + png_voidp PNGAPI +-png_get_mem_ptr(png_structp png_ptr) ++png_get_mem_ptr(png_const_structrp png_ptr) + { + if (png_ptr == NULL) +- return (NULL); +- return ((png_voidp)png_ptr->mem_ptr); ++ return NULL; ++ ++ return png_ptr->mem_ptr; + } +-#endif /* PNG_USER_MEM_SUPPORTED */ +-#endif /* PNG_READ_SUPPORTED || PNG_WRITE_SUPPORTED */ ++#endif /* USER_MEM */ ++#endif /* READ || WRITE */ +diff --git a/com32/lib/libpng/pngpread.c b/com32/lib/libpng/pngpread.c +index d066944c..e283627b 100644 +--- a/com32/lib/libpng/pngpread.c ++++ b/com32/lib/libpng/pngpread.c +@@ -1,35 +1,40 @@ + + /* pngpread.c - read a png file in push mode + * +- * Last changed in libpng 1.2.44 [June 26, 2010] +- * Copyright (c) 1998-2010 Glenn Randers-Pehrson +- * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) +- * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) ++ * Copyright (c) 2018 Cosmin Truta ++ * Copyright (c) 1998-2002,2004,2006-2018 Glenn Randers-Pehrson ++ * Copyright (c) 1996-1997 Andreas Dilger ++ * Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc. + * + * This code is released under the libpng license. + * For conditions of distribution and use, see the disclaimer + * and license in png.h + */ + +-#define PNG_INTERNAL +-#define PNG_NO_PEDANTIC_WARNINGS +-#include "png.h" ++#include "pngpriv.h" ++ + #ifdef PNG_PROGRESSIVE_READ_SUPPORTED + + /* Push model modes */ + #define PNG_READ_SIG_MODE 0 + #define PNG_READ_CHUNK_MODE 1 + #define PNG_READ_IDAT_MODE 2 +-#define PNG_SKIP_MODE 3 + #define PNG_READ_tEXt_MODE 4 + #define PNG_READ_zTXt_MODE 5 + #define PNG_READ_DONE_MODE 6 + #define PNG_READ_iTXt_MODE 7 + #define PNG_ERROR_MODE 8 + ++#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_bytep buffer, png_size_t buffer_size) ++png_process_data(png_structrp png_ptr, png_inforp info_ptr, ++ png_bytep buffer, size_t buffer_size) + { + if (png_ptr == NULL || info_ptr == NULL) + return; +@@ -42,11 +47,51 @@ png_process_data(png_structp png_ptr, png_infop info_ptr, + } + } + ++size_t PNGAPI ++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 ++ * have to supply the same data again: ++ */ ++ if (save != 0) ++ png_push_save_buffer(png_ptr); ++ else ++ { ++ /* This includes any pending saved bytes: */ ++ size_t remaining = png_ptr->buffer_size; ++ png_ptr->buffer_size = 0; ++ ++ /* So subtract the saved buffer size, unless all the data ++ * is actually 'saved', in which case we just return 0 ++ */ ++ if (png_ptr->save_buffer_size < remaining) ++ return remaining - png_ptr->save_buffer_size; ++ } ++ } ++ ++ return 0; ++} ++ ++png_uint_32 PNGAPI ++png_process_data_skip(png_structrp png_ptr) ++{ ++/* TODO: Deprecate and remove this API. ++ * Somewhere the implementation of this seems to have been lost, ++ * or abandoned. It was only to support some internal back-door access ++ * to png_struct) in libpng-1.4.x. ++ */ ++ png_app_warning(png_ptr, ++"png_process_data_skip is not implemented in any current version of libpng"); ++ return 0; ++} ++ + /* What we do with the incoming data depends on what we were previously + * doing before we ran out of data... + */ + void /* PRIVATE */ +-png_process_some_data(png_structp png_ptr, png_infop info_ptr) ++png_process_some_data(png_structrp png_ptr, png_inforp info_ptr) + { + if (png_ptr == NULL) + return; +@@ -71,36 +116,6 @@ png_process_some_data(png_structp png_ptr, png_infop info_ptr) + break; + } + +-#ifdef PNG_READ_tEXt_SUPPORTED +- case PNG_READ_tEXt_MODE: +- { +- png_push_read_tEXt(png_ptr, info_ptr); +- break; +- } +- +-#endif +-#ifdef PNG_READ_zTXt_SUPPORTED +- case PNG_READ_zTXt_MODE: +- { +- png_push_read_zTXt(png_ptr, info_ptr); +- break; +- } +- +-#endif +-#ifdef PNG_READ_iTXt_SUPPORTED +- case PNG_READ_iTXt_MODE: +- { +- png_push_read_iTXt(png_ptr, info_ptr); +- break; +- } +- +-#endif +- case PNG_SKIP_MODE: +- { +- png_push_crc_finish(png_ptr); +- break; +- } +- + default: + { + png_ptr->buffer_size = 0; +@@ -116,10 +131,10 @@ png_process_some_data(png_structp png_ptr, png_infop info_ptr) + * 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, +- num_to_check = 8 - num_checked; ++ size_t num_checked = png_ptr->sig_bytes; /* SAFE, does not exceed 8 */ ++ size_t num_to_check = 8 - num_checked; + + if (png_ptr->buffer_size < num_to_check) + { +@@ -127,7 +142,7 @@ png_push_read_sig(png_structp png_ptr, png_infop info_ptr) + } + + png_push_fill_buffer(png_ptr, &(info_ptr->signature[num_checked]), +- num_to_check); ++ num_to_check); + png_ptr->sig_bytes = (png_byte)(png_ptr->sig_bytes + num_to_check); + + if (png_sig_cmp(info_ptr->signature, num_checked, num_to_check)) +@@ -135,6 +150,7 @@ png_push_read_sig(png_structp png_ptr, png_infop info_ptr) + if (num_checked < 4 && + png_sig_cmp(info_ptr->signature, num_checked, num_to_check - 4)) + png_error(png_ptr, "Not a PNG file"); ++ + else + png_error(png_ptr, "PNG file corrupted by ASCII conversion"); + } +@@ -148,116 +164,78 @@ png_push_read_sig(png_structp png_ptr, png_infop info_ptr) + } + + 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) + { +-#ifdef PNG_USE_LOCAL_ARRAYS +- PNG_CONST PNG_IHDR; +- PNG_CONST PNG_IDAT; +- PNG_CONST PNG_IEND; +- PNG_CONST PNG_PLTE; +-#ifdef PNG_READ_bKGD_SUPPORTED +- PNG_CONST PNG_bKGD; +-#endif +-#ifdef PNG_READ_cHRM_SUPPORTED +- PNG_CONST PNG_cHRM; +-#endif +-#ifdef PNG_READ_gAMA_SUPPORTED +- PNG_CONST PNG_gAMA; +-#endif +-#ifdef PNG_READ_hIST_SUPPORTED +- PNG_CONST PNG_hIST; +-#endif +-#ifdef PNG_READ_iCCP_SUPPORTED +- PNG_CONST PNG_iCCP; +-#endif +-#ifdef PNG_READ_iTXt_SUPPORTED +- PNG_CONST PNG_iTXt; +-#endif +-#ifdef PNG_READ_oFFs_SUPPORTED +- PNG_CONST PNG_oFFs; +-#endif +-#ifdef PNG_READ_pCAL_SUPPORTED +- PNG_CONST PNG_pCAL; +-#endif +-#ifdef PNG_READ_pHYs_SUPPORTED +- PNG_CONST PNG_pHYs; +-#endif +-#ifdef PNG_READ_sBIT_SUPPORTED +- PNG_CONST PNG_sBIT; +-#endif +-#ifdef PNG_READ_sCAL_SUPPORTED +- PNG_CONST PNG_sCAL; +-#endif +-#ifdef PNG_READ_sRGB_SUPPORTED +- PNG_CONST PNG_sRGB; +-#endif +-#ifdef PNG_READ_sPLT_SUPPORTED +- PNG_CONST PNG_sPLT; +-#endif +-#ifdef PNG_READ_tEXt_SUPPORTED +- PNG_CONST PNG_tEXt; +-#endif +-#ifdef PNG_READ_tIME_SUPPORTED +- PNG_CONST PNG_tIME; +-#endif +-#ifdef PNG_READ_tRNS_SUPPORTED +- PNG_CONST PNG_tRNS; +-#endif +-#ifdef PNG_READ_zTXt_SUPPORTED +- PNG_CONST PNG_zTXt; ++ png_uint_32 chunk_name; ++#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED ++ int keep; /* unknown handling method */ + #endif +-#endif /* PNG_USE_LOCAL_ARRAYS */ + +- /* First we make sure we have enough data for the 4 byte chunk name +- * and the 4 byte chunk length before proceeding with decoding the ++ /* 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_check_chunk_length(png_ptr, png_ptr->push_length); + png_ptr->mode |= PNG_HAVE_CHUNK_HEADER; + } + +- if (!png_memcmp(png_ptr->chunk_name, png_IDAT, 4)) +- if (png_ptr->mode & PNG_AFTER_IDAT) +- png_ptr->mode |= PNG_HAVE_CHUNK_AFTER_IDAT; ++ chunk_name = png_ptr->chunk_name; + +- if (!png_memcmp(png_ptr->chunk_name, png_IHDR, 4)) ++ if (chunk_name == png_IDAT) ++ { ++ if ((png_ptr->mode & PNG_AFTER_IDAT) != 0) ++ png_ptr->mode |= PNG_HAVE_CHUNK_AFTER_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) == 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->process_mode = PNG_READ_IDAT_MODE; ++ ++ if ((png_ptr->mode & PNG_HAVE_IDAT) != 0) ++ if ((png_ptr->mode & PNG_HAVE_CHUNK_AFTER_IDAT) == 0) ++ if (png_ptr->push_length == 0) ++ return; ++ ++ png_ptr->mode |= PNG_HAVE_IDAT; ++ ++ 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; +@@ -265,70 +243,25 @@ png_push_read_chunk(png_structp png_ptr, png_infop info_ptr) + } + + #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; +- +- png_handle_unknown(png_ptr, info_ptr, png_ptr->push_length); +- +- if (!png_memcmp(png_ptr->chunk_name, png_PLTE, 4)) ++ if (chunk_name == png_PLTE) + 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_error(png_ptr, "Too many IDAT's found"); +- } +- + png_ptr->idat_size = png_ptr->push_length; +- png_ptr->mode |= PNG_HAVE_IDAT; + png_ptr->process_mode = PNG_READ_IDAT_MODE; + png_push_have_info(png_ptr, info_ptr); + png_ptr->zstream.avail_out = +@@ -339,296 +272,153 @@ png_push_read_chunk(png_structp png_ptr, png_infop info_ptr) + } + + #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_handle_iTXt(png_ptr, info_ptr, png_ptr->push_length); ++ PNG_PUSH_SAVE_BUFFER_IF_FULL ++ png_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_ptr->process_mode = PNG_SKIP_MODE; +- png_ptr->skip_length = skip; +-} +- +-void /* PRIVATE */ +-png_push_crc_finish(png_structp png_ptr) +-{ +- if (png_ptr->skip_length && png_ptr->save_buffer_size) +- { +- png_size_t save_size; +- +- if (png_ptr->skip_length < (png_uint_32)png_ptr->save_buffer_size) +- save_size = (png_size_t)png_ptr->skip_length; +- else +- save_size = png_ptr->save_buffer_size; +- +- png_calculate_crc(png_ptr, png_ptr->save_buffer_ptr, save_size); +- +- png_ptr->skip_length -= save_size; +- png_ptr->buffer_size -= save_size; +- png_ptr->save_buffer_size -= save_size; +- png_ptr->save_buffer_ptr += save_size; +- } +- if (png_ptr->skip_length && png_ptr->current_buffer_size) +- { +- png_size_t save_size; +- +- if (png_ptr->skip_length < (png_uint_32)png_ptr->current_buffer_size) +- save_size = (png_size_t)png_ptr->skip_length; +- else +- save_size = png_ptr->current_buffer_size; +- +- png_calculate_crc(png_ptr, png_ptr->current_buffer_ptr, save_size); +- +- png_ptr->skip_length -= save_size; +- png_ptr->buffer_size -= save_size; +- png_ptr->current_buffer_size -= save_size; +- png_ptr->current_buffer_ptr += save_size; +- } +- if (!png_ptr->skip_length) +- { +- if (png_ptr->buffer_size < 4) +- { +- png_push_save_buffer(png_ptr); +- return; +- } +- +- png_crc_finish(png_ptr, 0); +- png_ptr->process_mode = PNG_READ_CHUNK_MODE; +- } +-} +- +-void PNGAPI +-png_push_fill_buffer(png_structp png_ptr, png_bytep buffer, png_size_t length) ++void PNGCBAPI ++png_push_fill_buffer(png_structp png_ptr, png_bytep buffer, size_t length) + { + png_bytep ptr; + +@@ -636,25 +426,26 @@ png_push_fill_buffer(png_structp png_ptr, png_bytep buffer, png_size_t length) + return; + + ptr = buffer; +- if (png_ptr->save_buffer_size) ++ if (png_ptr->save_buffer_size != 0) + { +- png_size_t save_size; ++ size_t save_size; + + if (length < png_ptr->save_buffer_size) + save_size = length; ++ + else + save_size = png_ptr->save_buffer_size; + +- png_memcpy(ptr, png_ptr->save_buffer_ptr, save_size); ++ 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; ++ size_t save_size; + + if (length < png_ptr->current_buffer_size) + save_size = length; +@@ -662,7 +453,7 @@ png_push_fill_buffer(png_structp png_ptr, png_bytep buffer, png_size_t length) + 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; +@@ -670,52 +461,57 @@ png_push_fill_buffer(png_structp png_ptr, png_bytep buffer, png_size_t length) + } + + 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) + { +- png_size_t i, istop; ++ size_t i, istop; + png_bytep sp; + png_bytep dp; + + istop = png_ptr->save_buffer_size; + for (i = 0, sp = png_ptr->save_buffer_ptr, dp = png_ptr->save_buffer; +- i < istop; i++, sp++, dp++) ++ i < istop; i++, sp++, dp++) + { + *dp = *sp; + } + } + } + if (png_ptr->save_buffer_size + png_ptr->current_buffer_size > +- png_ptr->save_buffer_max) ++ png_ptr->save_buffer_max) + { +- png_size_t new_max; ++ size_t new_max; + png_bytep old_buffer; + + if (png_ptr->save_buffer_size > PNG_SIZE_MAX - +- (png_ptr->current_buffer_size + 256)) ++ (png_ptr->current_buffer_size + 256)) + { +- png_error(png_ptr, "Potential overflow of save_buffer"); ++ png_error(png_ptr, "Potential overflow of save_buffer"); + } + + new_max = png_ptr->save_buffer_size + png_ptr->current_buffer_size + 256; + old_buffer = png_ptr->save_buffer; + png_ptr->save_buffer = (png_bytep)png_malloc_warn(png_ptr, +- (png_uint_32)new_max); ++ (size_t)new_max); ++ + if (png_ptr->save_buffer == NULL) + { +- png_free(png_ptr, old_buffer); +- png_error(png_ptr, "Insufficient memory for save_buffer"); ++ png_free(png_ptr, old_buffer); ++ png_error(png_ptr, "Insufficient memory for save_buffer"); + } +- png_memcpy(png_ptr->save_buffer, old_buffer, png_ptr->save_buffer_size); ++ ++ if (old_buffer) ++ memcpy(png_ptr->save_buffer, old_buffer, png_ptr->save_buffer_size); ++ else if (png_ptr->save_buffer_size) ++ png_error(png_ptr, "save_buffer error"); + png_free(png_ptr, old_buffer); + png_ptr->save_buffer_max = new_max; + } + if (png_ptr->current_buffer_size) + { +- png_memcpy(png_ptr->save_buffer + png_ptr->save_buffer_size, ++ 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; +@@ -725,8 +521,8 @@ png_push_save_buffer(png_structp png_ptr) + } + + void /* PRIVATE */ +-png_push_restore_buffer(png_structp png_ptr, png_bytep buffer, +- png_size_t buffer_length) ++png_push_restore_buffer(png_structrp png_ptr, png_bytep buffer, ++ size_t buffer_length) + { + png_ptr->current_buffer = buffer; + png_ptr->current_buffer_size = buffer_length; +@@ -735,102 +531,101 @@ png_push_restore_buffer(png_structp png_ptr, png_bytep buffer, + } + + void /* PRIVATE */ +-png_push_read_IDAT(png_structp png_ptr) ++png_push_read_IDAT(png_structrp png_ptr) + { +-#ifdef PNG_USE_LOCAL_ARRAYS +- PNG_CONST PNG_IDAT; +-#endif +- 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; + } + + png_ptr->idat_size = png_ptr->push_length; + } +- if (png_ptr->idat_size && png_ptr->save_buffer_size) +- { +- png_size_t save_size; + +- if (png_ptr->idat_size < (png_uint_32)png_ptr->save_buffer_size) +- { +- save_size = (png_size_t)png_ptr->idat_size; ++ if (png_ptr->idat_size != 0 && png_ptr->save_buffer_size != 0) ++ { ++ size_t save_size = png_ptr->save_buffer_size; ++ png_uint_32 idat_size = png_ptr->idat_size; ++ ++ /* We want the smaller of 'idat_size' and 'current_buffer_size', but they ++ * are of different types and we don't know which variable has the fewest ++ * bits. Carefully select the smaller and cast it to the type of the ++ * larger - this cannot overflow. Do not cast in the following test - it ++ * will break on either 16-bit or 64-bit platforms. ++ */ ++ if (idat_size < save_size) ++ save_size = (size_t)idat_size; + +- /* Check for overflow */ +- if ((png_uint_32)save_size != png_ptr->idat_size) +- png_error(png_ptr, "save_size overflowed in pngpread"); +- } + else +- save_size = png_ptr->save_buffer_size; ++ idat_size = (png_uint_32)save_size; + + png_calculate_crc(png_ptr, png_ptr->save_buffer_ptr, save_size); + + png_process_IDAT_data(png_ptr, png_ptr->save_buffer_ptr, save_size); + +- png_ptr->idat_size -= save_size; ++ png_ptr->idat_size -= idat_size; + png_ptr->buffer_size -= save_size; + png_ptr->save_buffer_size -= save_size; + png_ptr->save_buffer_ptr += save_size; + } +- if (png_ptr->idat_size && png_ptr->current_buffer_size) ++ ++ if (png_ptr->idat_size != 0 && png_ptr->current_buffer_size != 0) + { +- png_size_t save_size; ++ size_t save_size = png_ptr->current_buffer_size; ++ png_uint_32 idat_size = png_ptr->idat_size; + +- if (png_ptr->idat_size < (png_uint_32)png_ptr->current_buffer_size) +- { +- save_size = (png_size_t)png_ptr->idat_size; ++ /* We want the smaller of 'idat_size' and 'current_buffer_size', but they ++ * are of different types and we don't know which variable has the fewest ++ * bits. Carefully select the smaller and cast it to the type of the ++ * larger - this cannot overflow. ++ */ ++ if (idat_size < save_size) ++ save_size = (size_t)idat_size; + +- /* Check for overflow */ +- if ((png_uint_32)save_size != png_ptr->idat_size) +- png_error(png_ptr, "save_size overflowed in pngpread"); +- } + else +- save_size = png_ptr->current_buffer_size; ++ idat_size = (png_uint_32)save_size; + + png_calculate_crc(png_ptr, png_ptr->current_buffer_ptr, save_size); + + png_process_IDAT_data(png_ptr, png_ptr->current_buffer_ptr, save_size); + +- png_ptr->idat_size -= save_size; ++ png_ptr->idat_size -= idat_size; + png_ptr->buffer_size -= save_size; + png_ptr->current_buffer_size -= save_size; + png_ptr->current_buffer_ptr += save_size; + } +- if (!png_ptr->idat_size) +- { +- if (png_ptr->buffer_size < 4) +- { +- png_push_save_buffer(png_ptr); +- return; +- } + ++ if (png_ptr->idat_size == 0) ++ { ++ 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_size_t buffer_length) ++png_process_IDAT_data(png_structrp png_ptr, png_bytep buffer, ++ size_t buffer_length) + { + /* The caller checks for a non-zero buffer length. */ + if (!(buffer_length > 0) || buffer == NULL) +@@ -841,84 +636,95 @@ png_process_IDAT_data(png_structp png_ptr, png_bytep buffer, + * 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) == 0) + { + int ret; + + /* We have data for zlib, but we must check that zlib +- * has somewhere to put the results. It doesn't matter ++ * has someplace to put the results. It doesn't matter + * if we don't expect any results -- it may be the input + * data is just the LZ end code. + */ + 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; + } + + /* Using Z_SYNC_FLUSH here means that an unterminated +- * LZ stream can still be handled (a stream with a missing +- * end code), otherwise (Z_NO_FLUSH) a future zlib +- * implementation might defer output and, therefore, +- * change the current behavior. (See comments in inflate.c +- * for why this doesn't happen at present with zlib 1.2.5.) ++ * LZ stream (a stream with a missing end code) can still ++ * be handled, otherwise (Z_NO_FLUSH) a future zlib ++ * implementation might defer output and therefore ++ * change the current behavior (see comments in inflate.c ++ * for why this doesn't happen at present with zlib 1.2.5). + */ +- ret = inflate(&png_ptr->zstream, Z_SYNC_FLUSH); ++ ret = PNG_INFLATE(png_ptr, Z_SYNC_FLUSH); + + /* Check for any failure before proceeding. */ + if (ret != Z_OK && ret != Z_STREAM_END) + { +- /* Terminate the decompression. */ +- png_ptr->flags |= PNG_FLAG_ZLIB_FINISHED; ++ /* Terminate the decompression. */ ++ 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. +- */ ++ * damaged end code). Treat that as a warning. ++ */ + if (png_ptr->row_number >= png_ptr->num_rows || +- png_ptr->pass > 6) +- png_warning(png_ptr, "Truncated compressed data in IDAT"); +- else +- png_error(png_ptr, "Decompression error in IDAT"); ++ png_ptr->pass > 6) ++ png_warning(png_ptr, "Truncated compressed data in IDAT"); ++ ++ else ++ { ++ if (ret == Z_DATA_ERROR) ++ png_benign_error(png_ptr, "IDAT: ADLER32 checksum mismatch"); ++ else ++ png_error(png_ptr, "Decompression error in IDAT"); ++ } + +- /* Skip the check on unprocessed input */ ++ /* Skip the check on unprocessed input */ + return; + } + + /* Did inflate output any data? */ + if (png_ptr->zstream.next_out != png_ptr->row_buf) + { +- /* Is this unexpected data after the last row? +- * If it is, artificially terminate the LZ output +- * here. +- */ ++ /* Is this unexpected data after the last row? ++ * If it is, artificially terminate the LZ output ++ * here. ++ */ + if (png_ptr->row_number >= png_ptr->num_rows || +- png_ptr->pass > 6) ++ png_ptr->pass > 6) + { +- /* Extra data. */ +- png_warning(png_ptr, "Extra compressed data in IDAT"); +- png_ptr->flags |= PNG_FLAG_ZLIB_FINISHED; +- /* Do no more processing; skip the unprocessed +- * input check below. +- */ ++ /* Extra data. */ ++ png_warning(png_ptr, "Extra compressed data in IDAT"); ++ png_ptr->flags |= PNG_FLAG_ZSTREAM_ENDED; ++ png_ptr->zowner = 0; ++ ++ /* Do no more processing; skip the unprocessed ++ * input check below. ++ */ + return; +- } ++ } + +- /* Do we have a complete row? */ +- if (png_ptr->zstream.avail_out == 0) +- png_push_process_row(png_ptr); ++ /* Do we have a complete row? */ ++ if (png_ptr->zstream.avail_out == 0) ++ png_push_process_row(png_ptr); + } + + /* 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 +@@ -926,44 +732,66 @@ png_process_IDAT_data(png_structp png_ptr, png_bytep buffer, + * after the zlib end code. + */ + if (png_ptr->zstream.avail_in > 0) +- png_warning(png_ptr, "Extra compression data"); ++ png_warning(png_ptr, "Extra compression data in IDAT"); + } + + 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; ++ ++ 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); ++ ++ 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"); ++ } ++ ++ /* 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); + +- png_ptr->row_info.rowbytes = PNG_ROWBYTES(png_ptr->row_info.pixel_depth, +- png_ptr->row_info.width); ++#ifdef PNG_READ_TRANSFORMS_SUPPORTED ++ if (png_ptr->transformations != 0) ++ png_do_read_transformations(png_ptr, &row_info); ++#endif + +- 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])); ++ /* 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"); ++ } + +- png_memcpy_check(png_ptr, png_ptr->prev_row, png_ptr->row_buf, +- png_ptr->rowbytes + 1); ++ else if (png_ptr->transformed_pixel_depth != row_info.pixel_depth) ++ png_error(png_ptr, "internal progressive row size calculation error"); + +- if (png_ptr->transformations || (png_ptr->flags&PNG_FLAG_STRIP_ALPHA)) +- png_do_read_transformations(png_ptr); + + #ifdef PNG_READ_INTERLACING_SUPPORTED +- /* Blow up interlaced rows to full size */ +- if (png_ptr->interlaced && (png_ptr->transformations & PNG_INTERLACE)) ++ /* 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; +@@ -977,7 +805,7 @@ png_push_process_row(png_structp png_ptr) + { + for (i = 0; i < 4 && png_ptr->pass == 2; i++) + { +- png_push_have_row(png_ptr, png_bytep_NULL); ++ png_push_have_row(png_ptr, NULL); + png_read_push_finish_row(png_ptr); + } + } +@@ -986,14 +814,14 @@ png_push_process_row(png_structp png_ptr) + { + for (i = 0; i < 2 && png_ptr->pass == 4; i++) + { +- png_push_have_row(png_ptr, png_bytep_NULL); ++ png_push_have_row(png_ptr, NULL); + png_read_push_finish_row(png_ptr); + } + } + + if (png_ptr->pass == 6 && png_ptr->height <= 4) + { +- png_push_have_row(png_ptr, png_bytep_NULL); ++ png_push_have_row(png_ptr, NULL); + png_read_push_finish_row(png_ptr); + } + +@@ -1013,7 +841,7 @@ png_push_process_row(png_structp png_ptr) + { + for (i = 0; i < 4 && png_ptr->pass == 2; i++) + { +- png_push_have_row(png_ptr, png_bytep_NULL); ++ png_push_have_row(png_ptr, NULL); + png_read_push_finish_row(png_ptr); + } + } +@@ -1033,7 +861,7 @@ png_push_process_row(png_structp png_ptr) + + for (i = 0; i < 4 && png_ptr->pass == 2; i++) + { +- png_push_have_row(png_ptr, png_bytep_NULL); ++ png_push_have_row(png_ptr, NULL); + png_read_push_finish_row(png_ptr); + } + +@@ -1041,7 +869,7 @@ png_push_process_row(png_structp png_ptr) + { + for (i = 0; i < 2 && png_ptr->pass == 4; i++) + { +- png_push_have_row(png_ptr, png_bytep_NULL); ++ png_push_have_row(png_ptr, NULL); + png_read_push_finish_row(png_ptr); + } + } +@@ -1063,7 +891,7 @@ png_push_process_row(png_structp png_ptr) + { + for (i = 0; i < 2 && png_ptr->pass == 4; i++) + { +- png_push_have_row(png_ptr, png_bytep_NULL); ++ png_push_have_row(png_ptr, NULL); + png_read_push_finish_row(png_ptr); + } + } +@@ -1083,13 +911,13 @@ png_push_process_row(png_structp png_ptr) + + for (i = 0; i < 2 && png_ptr->pass == 4; i++) + { +- png_push_have_row(png_ptr, png_bytep_NULL); ++ png_push_have_row(png_ptr, NULL); + png_read_push_finish_row(png_ptr); + } + + if (png_ptr->pass == 6) /* Pass 5 might be empty */ + { +- png_push_have_row(png_ptr, png_bytep_NULL); ++ png_push_have_row(png_ptr, NULL); + png_read_push_finish_row(png_ptr); + } + +@@ -1108,12 +936,14 @@ png_push_process_row(png_structp png_ptr) + + if (png_ptr->pass == 6) /* Skip top generated row */ + { +- png_push_have_row(png_ptr, png_bytep_NULL); ++ png_push_have_row(png_ptr, NULL); + png_read_push_finish_row(png_ptr); + } + + break; + } ++ ++ default: + case 6: + { + png_push_have_row(png_ptr, png_ptr->row_buf + 1); +@@ -1122,7 +952,7 @@ png_push_process_row(png_structp png_ptr) + if (png_ptr->pass != 6) + break; + +- png_push_have_row(png_ptr, png_bytep_NULL); ++ png_push_have_row(png_ptr, NULL); + png_read_push_finish_row(png_ptr); + } + } +@@ -1136,26 +966,26 @@ png_push_process_row(png_structp png_ptr) + } + + void /* PRIVATE */ +-png_read_push_finish_row(png_structp png_ptr) ++png_read_push_finish_row(png_structrp png_ptr) + { +-#ifdef PNG_USE_LOCAL_ARRAYS ++#ifdef PNG_READ_INTERLACING_SUPPORTED + /* Arrays to facilitate easy interlacing - use pass (0 - 6) as index */ + + /* Start of interlace block */ +- PNG_CONST int FARDATA png_pass_start[] = {0, 4, 0, 2, 0, 1, 0}; ++ static 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 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 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 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 const png_byte png_pass_height[] = {8, 8, 4, 4, 2, 2, 1}; + */ + #endif + +@@ -1164,18 +994,18 @@ png_read_push_finish_row(png_structp png_ptr) + return; + + #ifdef PNG_READ_INTERLACING_SUPPORTED +- if (png_ptr->interlaced) ++ if (png_ptr->interlaced != 0) + { + png_ptr->row_number = 0; +- png_memset_check(png_ptr, png_ptr->prev_row, 0, +- png_ptr->rowbytes + 1); ++ memset(png_ptr->prev_row, 0, png_ptr->rowbytes + 1); ++ + do + { + png_ptr->pass++; + if ((png_ptr->pass == 1 && png_ptr->width < 5) || + (png_ptr->pass == 3 && png_ptr->width < 3) || + (png_ptr->pass == 5 && png_ptr->width < 2)) +- png_ptr->pass++; ++ png_ptr->pass++; + + if (png_ptr->pass > 7) + png_ptr->pass--; +@@ -1184,574 +1014,66 @@ png_read_push_finish_row(png_structp png_ptr) + break; + + png_ptr->iwidth = (png_ptr->width + +- png_pass_inc[png_ptr->pass] - 1 - +- png_pass_start[png_ptr->pass]) / +- png_pass_inc[png_ptr->pass]; ++ png_pass_inc[png_ptr->pass] - 1 - ++ 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 + +- png_pass_yinc[png_ptr->pass] - 1 - +- png_pass_ystart[png_ptr->pass]) / +- png_pass_yinc[png_ptr->pass]; ++ png_pass_yinc[png_ptr->pass] - 1 - ++ png_pass_ystart[png_ptr->pass]) / ++ png_pass_yinc[png_ptr->pass]; + + } while (png_ptr->iwidth == 0 || png_ptr->num_rows == 0); + } +-#endif /* PNG_READ_INTERLACING_SUPPORTED */ +-} +- +-#ifdef PNG_READ_tEXt_SUPPORTED +-void /* PRIVATE */ +-png_push_handle_tEXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 +- length) +-{ +- if (!(png_ptr->mode & PNG_HAVE_IHDR) || (png_ptr->mode & PNG_HAVE_IEND)) +- { +- png_error(png_ptr, "Out of place tEXt"); +- info_ptr = info_ptr; /* To quiet some compiler warnings */ +- } +- +-#ifdef PNG_MAX_MALLOC_64K +- png_ptr->skip_length = 0; /* This may not be necessary */ +- +- if (length > (png_uint_32)65535L) /* Can't hold entire string in memory */ +- { +- png_warning(png_ptr, "tEXt chunk too large to fit in memory"); +- png_ptr->skip_length = length - (png_uint_32)65535L; +- length = (png_uint_32)65535L; +- } +-#endif +- +- png_ptr->current_text = (png_charp)png_malloc(png_ptr, +- (png_uint_32)(length + 1)); +- png_ptr->current_text[length] = '\0'; +- png_ptr->current_text_ptr = png_ptr->current_text; +- png_ptr->current_text_size = (png_size_t)length; +- png_ptr->current_text_left = (png_size_t)length; +- png_ptr->process_mode = PNG_READ_tEXt_MODE; +-} +- +-void /* PRIVATE */ +-png_push_read_tEXt(png_structp png_ptr, png_infop info_ptr) +-{ +- if (png_ptr->buffer_size && png_ptr->current_text_left) +- { +- png_size_t text_size; +- +- if (png_ptr->buffer_size < png_ptr->current_text_left) +- text_size = png_ptr->buffer_size; +- +- else +- text_size = png_ptr->current_text_left; +- +- png_crc_read(png_ptr, (png_bytep)png_ptr->current_text_ptr, text_size); +- png_ptr->current_text_left -= text_size; +- png_ptr->current_text_ptr += text_size; +- } +- if (!(png_ptr->current_text_left)) +- { +- png_textp text_ptr; +- png_charp text; +- png_charp key; +- int ret; +- +- if (png_ptr->buffer_size < 4) +- { +- png_push_save_buffer(png_ptr); +- return; +- } +- +- png_push_crc_finish(png_ptr); +- +-#ifdef PNG_MAX_MALLOC_64K +- if (png_ptr->skip_length) +- return; +-#endif +- +- key = png_ptr->current_text; +- +- for (text = key; *text; text++) +- /* Empty loop */ ; +- +- if (text < key + png_ptr->current_text_size) +- text++; +- +- text_ptr = (png_textp)png_malloc(png_ptr, +- (png_uint_32)png_sizeof(png_text)); +- text_ptr->compression = PNG_TEXT_COMPRESSION_NONE; +- text_ptr->key = key; +-#ifdef PNG_iTXt_SUPPORTED +- text_ptr->lang = NULL; +- text_ptr->lang_key = NULL; +-#endif +- text_ptr->text = text; +- +- ret = png_set_text_2(png_ptr, info_ptr, text_ptr, 1); +- +- png_free(png_ptr, key); +- png_free(png_ptr, text_ptr); +- png_ptr->current_text = NULL; +- +- if (ret) +- png_warning(png_ptr, "Insufficient memory to store text chunk."); +- } +-} +-#endif +- +-#ifdef PNG_READ_zTXt_SUPPORTED +-void /* PRIVATE */ +-png_push_handle_zTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 +- length) +-{ +- if (!(png_ptr->mode & PNG_HAVE_IHDR) || (png_ptr->mode & PNG_HAVE_IEND)) +- { +- png_error(png_ptr, "Out of place zTXt"); +- info_ptr = info_ptr; /* To quiet some compiler warnings */ +- } +- +-#ifdef PNG_MAX_MALLOC_64K +- /* We can't handle zTXt chunks > 64K, since we don't have enough space +- * to be able to store the uncompressed data. Actually, the threshold +- * is probably around 32K, but it isn't as definite as 64K is. +- */ +- if (length > (png_uint_32)65535L) +- { +- png_warning(png_ptr, "zTXt chunk too large to fit in memory"); +- png_push_crc_skip(png_ptr, length); +- return; +- } +-#endif +- +- png_ptr->current_text = (png_charp)png_malloc(png_ptr, +- (png_uint_32)(length + 1)); +- png_ptr->current_text[length] = '\0'; +- png_ptr->current_text_ptr = png_ptr->current_text; +- png_ptr->current_text_size = (png_size_t)length; +- png_ptr->current_text_left = (png_size_t)length; +- png_ptr->process_mode = PNG_READ_zTXt_MODE; +-} +- +-void /* PRIVATE */ +-png_push_read_zTXt(png_structp png_ptr, png_infop info_ptr) +-{ +- if (png_ptr->buffer_size && png_ptr->current_text_left) +- { +- png_size_t text_size; +- +- if (png_ptr->buffer_size < (png_uint_32)png_ptr->current_text_left) +- text_size = png_ptr->buffer_size; +- +- else +- text_size = png_ptr->current_text_left; +- +- png_crc_read(png_ptr, (png_bytep)png_ptr->current_text_ptr, text_size); +- png_ptr->current_text_left -= text_size; +- png_ptr->current_text_ptr += text_size; +- } +- if (!(png_ptr->current_text_left)) +- { +- png_textp text_ptr; +- png_charp text; +- png_charp key; +- int ret; +- png_size_t text_size, key_size; +- +- if (png_ptr->buffer_size < 4) +- { +- png_push_save_buffer(png_ptr); +- return; +- } +- +- png_push_crc_finish(png_ptr); +- +- key = png_ptr->current_text; +- +- for (text = key; *text; text++) +- /* Empty loop */ ; +- +- /* zTXt can't have zero text */ +- if (text >= key + png_ptr->current_text_size) +- { +- png_ptr->current_text = NULL; +- png_free(png_ptr, key); +- return; +- } +- +- text++; +- +- if (*text != PNG_TEXT_COMPRESSION_zTXt) /* Check compression byte */ +- { +- png_ptr->current_text = NULL; +- png_free(png_ptr, key); +- return; +- } +- +- text++; +- +- png_ptr->zstream.next_in = (png_bytep )text; +- png_ptr->zstream.avail_in = (uInt)(png_ptr->current_text_size - +- (text - key)); +- png_ptr->zstream.next_out = png_ptr->zbuf; +- png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size; +- +- key_size = text - key; +- text_size = 0; +- text = NULL; +- ret = Z_STREAM_END; +- +- while (png_ptr->zstream.avail_in) +- { +- ret = inflate(&png_ptr->zstream, Z_PARTIAL_FLUSH); +- if (ret != Z_OK && ret != Z_STREAM_END) +- { +- inflateReset(&png_ptr->zstream); +- png_ptr->zstream.avail_in = 0; +- png_ptr->current_text = NULL; +- png_free(png_ptr, key); +- png_free(png_ptr, text); +- return; +- } +- if (!(png_ptr->zstream.avail_out) || ret == Z_STREAM_END) +- { +- if (text == NULL) +- { +- text = (png_charp)png_malloc(png_ptr, +- (png_uint_32)(png_ptr->zbuf_size +- - png_ptr->zstream.avail_out + key_size + 1)); +- +- png_memcpy(text + key_size, png_ptr->zbuf, +- png_ptr->zbuf_size - png_ptr->zstream.avail_out); +- +- png_memcpy(text, key, key_size); +- +- text_size = key_size + png_ptr->zbuf_size - +- png_ptr->zstream.avail_out; +- +- *(text + text_size) = '\0'; +- } +- else +- { +- png_charp tmp; +- +- tmp = text; +- text = (png_charp)png_malloc(png_ptr, text_size + +- (png_uint_32)(png_ptr->zbuf_size +- - png_ptr->zstream.avail_out + 1)); +- +- png_memcpy(text, tmp, text_size); +- png_free(png_ptr, tmp); +- +- png_memcpy(text + text_size, png_ptr->zbuf, +- png_ptr->zbuf_size - png_ptr->zstream.avail_out); +- +- text_size += png_ptr->zbuf_size - png_ptr->zstream.avail_out; +- *(text + text_size) = '\0'; +- } +- if (ret != Z_STREAM_END) +- { +- png_ptr->zstream.next_out = png_ptr->zbuf; +- png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size; +- } +- } +- else +- { +- break; +- } +- +- if (ret == Z_STREAM_END) +- break; +- } +- +- inflateReset(&png_ptr->zstream); +- png_ptr->zstream.avail_in = 0; +- +- if (ret != Z_STREAM_END) +- { +- png_ptr->current_text = NULL; +- png_free(png_ptr, key); +- png_free(png_ptr, text); +- return; +- } +- +- png_ptr->current_text = NULL; +- png_free(png_ptr, key); +- key = text; +- text += key_size; +- +- text_ptr = (png_textp)png_malloc(png_ptr, +- (png_uint_32)png_sizeof(png_text)); +- text_ptr->compression = PNG_TEXT_COMPRESSION_zTXt; +- text_ptr->key = key; +-#ifdef PNG_iTXt_SUPPORTED +- text_ptr->lang = NULL; +- text_ptr->lang_key = NULL; +-#endif +- text_ptr->text = text; +- +- ret = png_set_text_2(png_ptr, info_ptr, text_ptr, 1); +- +- png_free(png_ptr, key); +- png_free(png_ptr, text_ptr); +- +- if (ret) +- png_warning(png_ptr, "Insufficient memory to store text chunk."); +- } +-} +-#endif +- +-#ifdef PNG_READ_iTXt_SUPPORTED +-void /* PRIVATE */ +-png_push_handle_iTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 +- length) +-{ +- if (!(png_ptr->mode & PNG_HAVE_IHDR) || (png_ptr->mode & PNG_HAVE_IEND)) +- { +- png_error(png_ptr, "Out of place iTXt"); +- info_ptr = info_ptr; /* To quiet some compiler warnings */ +- } +- +-#ifdef PNG_MAX_MALLOC_64K +- png_ptr->skip_length = 0; /* This may not be necessary */ +- +- if (length > (png_uint_32)65535L) /* Can't hold entire string in memory */ +- { +- png_warning(png_ptr, "iTXt chunk too large to fit in memory"); +- png_ptr->skip_length = length - (png_uint_32)65535L; +- length = (png_uint_32)65535L; +- } +-#endif +- +- png_ptr->current_text = (png_charp)png_malloc(png_ptr, +- (png_uint_32)(length + 1)); +- png_ptr->current_text[length] = '\0'; +- png_ptr->current_text_ptr = png_ptr->current_text; +- png_ptr->current_text_size = (png_size_t)length; +- png_ptr->current_text_left = (png_size_t)length; +- png_ptr->process_mode = PNG_READ_iTXt_MODE; +-} +- +-void /* PRIVATE */ +-png_push_read_iTXt(png_structp png_ptr, png_infop info_ptr) +-{ +- +- if (png_ptr->buffer_size && png_ptr->current_text_left) +- { +- png_size_t text_size; +- +- if (png_ptr->buffer_size < png_ptr->current_text_left) +- text_size = png_ptr->buffer_size; +- +- else +- text_size = png_ptr->current_text_left; +- +- png_crc_read(png_ptr, (png_bytep)png_ptr->current_text_ptr, text_size); +- png_ptr->current_text_left -= text_size; +- png_ptr->current_text_ptr += text_size; +- } +- if (!(png_ptr->current_text_left)) +- { +- png_textp text_ptr; +- png_charp key; +- int comp_flag; +- png_charp lang; +- png_charp lang_key; +- png_charp text; +- int ret; +- +- if (png_ptr->buffer_size < 4) +- { +- png_push_save_buffer(png_ptr); +- return; +- } +- +- png_push_crc_finish(png_ptr); +- +-#ifdef PNG_MAX_MALLOC_64K +- if (png_ptr->skip_length) +- return; +-#endif +- +- key = png_ptr->current_text; +- +- for (lang = key; *lang; lang++) +- /* Empty loop */ ; +- +- if (lang < key + png_ptr->current_text_size - 3) +- lang++; +- +- comp_flag = *lang++; +- lang++; /* Skip comp_type, always zero */ +- +- for (lang_key = lang; *lang_key; lang_key++) +- /* Empty loop */ ; +- +- lang_key++; /* Skip NUL separator */ +- +- text=lang_key; +- +- if (lang_key < key + png_ptr->current_text_size - 1) +- { +- for (; *text; text++) +- /* Empty loop */ ; +- } +- +- if (text < key + png_ptr->current_text_size) +- text++; +- +- text_ptr = (png_textp)png_malloc(png_ptr, +- (png_uint_32)png_sizeof(png_text)); +- +- text_ptr->compression = comp_flag + 2; +- text_ptr->key = key; +- text_ptr->lang = lang; +- text_ptr->lang_key = lang_key; +- text_ptr->text = text; +- text_ptr->text_length = 0; +- text_ptr->itxt_length = png_strlen(text); +- +- ret = png_set_text_2(png_ptr, info_ptr, text_ptr, 1); +- +- png_ptr->current_text = NULL; +- +- png_free(png_ptr, text_ptr); +- if (ret) +- png_warning(png_ptr, "Insufficient memory to store iTXt chunk."); +- } +-} +-#endif +- +-/* This function is called when we haven't found a handler for this +- * chunk. If there isn't a problem with the chunk itself (ie a bad chunk +- * name or a critical chunk), the chunk is (currently) silently ignored. +- */ +-void /* PRIVATE */ +-png_push_handle_unknown(png_structp png_ptr, png_infop info_ptr, png_uint_32 +- length) +-{ +- png_uint_32 skip = 0; +- +- if (!(png_ptr->chunk_name[0] & 0x20)) +- { +-#ifdef PNG_READ_UNKNOWN_CHUNKS_SUPPORTED +- if (png_handle_as_unknown(png_ptr, png_ptr->chunk_name) != +- PNG_HANDLE_CHUNK_ALWAYS +-#ifdef PNG_READ_USER_CHUNKS_SUPPORTED +- && png_ptr->read_user_chunk_fn == NULL +-#endif +- ) +-#endif +- png_chunk_error(png_ptr, "unknown critical chunk"); +- +- info_ptr = info_ptr; /* To quiet some compiler warnings */ +- } +- +-#ifdef PNG_READ_UNKNOWN_CHUNKS_SUPPORTED +- if (png_ptr->flags & PNG_FLAG_KEEP_UNKNOWN_CHUNKS) +- { +-#ifdef PNG_MAX_MALLOC_64K +- if (length > (png_uint_32)65535L) +- { +- png_warning(png_ptr, "unknown chunk too large to fit in memory"); +- skip = length - (png_uint_32)65535L; +- length = (png_uint_32)65535L; +- } +-#endif +- png_memcpy((png_charp)png_ptr->unknown_chunk.name, +- (png_charp)png_ptr->chunk_name, +- png_sizeof(png_ptr->unknown_chunk.name)); +- png_ptr->unknown_chunk.name[png_sizeof(png_ptr->unknown_chunk.name) - 1] +- = '\0'; +- +- png_ptr->unknown_chunk.size = (png_size_t)length; +- +- if (length == 0) +- png_ptr->unknown_chunk.data = NULL; +- +- else +- { +- png_ptr->unknown_chunk.data = (png_bytep)png_malloc(png_ptr, +- (png_uint_32)length); +- png_crc_read(png_ptr, (png_bytep)png_ptr->unknown_chunk.data, length); +- } +- +-#ifdef PNG_READ_USER_CHUNKS_SUPPORTED +- if (png_ptr->read_user_chunk_fn != NULL) +- { +- /* Callback to user unknown chunk handler */ +- int ret; +- ret = (*(png_ptr->read_user_chunk_fn)) +- (png_ptr, &png_ptr->unknown_chunk); +- +- if (ret < 0) +- png_chunk_error(png_ptr, "error in user chunk"); +- +- if (ret == 0) +- { +- if (!(png_ptr->chunk_name[0] & 0x20)) +- if (png_handle_as_unknown(png_ptr, png_ptr->chunk_name) != +- PNG_HANDLE_CHUNK_ALWAYS) +- png_chunk_error(png_ptr, "unknown critical chunk"); +- png_set_unknown_chunks(png_ptr, info_ptr, +- &png_ptr->unknown_chunk, 1); +- } +- } +- +- else +-#endif +- png_set_unknown_chunks(png_ptr, info_ptr, &png_ptr->unknown_chunk, 1); +- png_free(png_ptr, png_ptr->unknown_chunk.data); +- png_ptr->unknown_chunk.data = NULL; +- } +- +- else +-#endif +- skip=length; +- png_push_crc_skip(png_ptr, skip); ++#endif /* READ_INTERLACING */ + } + + 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, +- (int)png_ptr->pass); ++ (int)png_ptr->pass); + } + ++#ifdef PNG_READ_INTERLACING_SUPPORTED + void PNGAPI +-png_progressive_combine_row (png_structp png_ptr, +- png_bytep old_row, png_bytep new_row) ++png_progressive_combine_row(png_const_structrp png_ptr, png_bytep old_row, ++ png_const_bytep new_row) + { +-#ifdef PNG_USE_LOCAL_ARRAYS +- PNG_CONST int FARDATA png_pass_dsp_mask[7] = +- {0xff, 0x0f, 0xff, 0x33, 0xff, 0x55, 0xff}; +-#endif +- + if (png_ptr == NULL) + return; + +- if (new_row != NULL) /* new_row must == png_ptr->row_buf here. */ +- png_combine_row(png_ptr, old_row, png_pass_dsp_mask[png_ptr->pass]); ++ /* 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*/); + } ++#endif /* READ_INTERLACING */ + + void PNGAPI +-png_set_progressive_read_fn(png_structp png_ptr, png_voidp progressive_ptr, +- png_progressive_info_ptr info_fn, png_progressive_row_ptr row_fn, +- png_progressive_end_ptr end_fn) ++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) + { + if (png_ptr == NULL) + return; +@@ -1764,11 +1086,11 @@ png_set_progressive_read_fn(png_structp png_ptr, png_voidp progressive_ptr, + } + + png_voidp PNGAPI +-png_get_progressive_ptr(png_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 */ +diff --git a/com32/lib/libpng/pngread.c b/com32/lib/libpng/pngread.c +index 62076248..f8e76219 100644 +--- a/com32/lib/libpng/pngread.c ++++ b/com32/lib/libpng/pngread.c +@@ -1,10 +1,10 @@ + + /* pngread.c - read a PNG file + * +- * Last changed in libpng 1.2.44 [June 26, 2010] +- * Copyright (c) 1998-2010 Glenn Randers-Pehrson +- * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) +- * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) ++ * Copyright (c) 2018 Cosmin Truta ++ * Copyright (c) 1998-2002,2004,2006-2018 Glenn Randers-Pehrson ++ * Copyright (c) 1996-1997 Andreas Dilger ++ * Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc. + * + * This code is released under the libpng license. + * For conditions of distribution and use, see the disclaimer +@@ -14,332 +14,70 @@ + * read a PNG file or stream. + */ + +-#define PNG_INTERNAL +-#define PNG_NO_PEDANTIC_WARNINGS +-#include "png.h" +-#ifdef PNG_READ_SUPPORTED ++#include "pngpriv.h" ++#if defined(PNG_SIMPLIFIED_READ_SUPPORTED) && defined(PNG_STDIO_SUPPORTED) ++# include ++#endif + ++#ifdef PNG_READ_SUPPORTED + + /* Create a PNG structure for reading, and allocate any memory needed. */ +-png_structp PNGAPI +-png_create_read_struct(png_const_charp user_png_ver, png_voidp error_ptr, +- png_error_ptr error_fn, png_error_ptr warn_fn) ++PNG_FUNCTION(png_structp,PNGAPI ++png_create_read_struct,(png_const_charp user_png_ver, png_voidp error_ptr, ++ png_error_ptr error_fn, png_error_ptr warn_fn),PNG_ALLOCATED) + { +- +-#ifdef PNG_USER_MEM_SUPPORTED +- return (png_create_read_struct_2(user_png_ver, error_ptr, error_fn, +- warn_fn, png_voidp_NULL, png_malloc_ptr_NULL, png_free_ptr_NULL)); ++#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 + * needed. + */ +-png_structp PNGAPI +-png_create_read_struct_2(png_const_charp user_png_ver, png_voidp error_ptr, +- png_error_ptr error_fn, png_error_ptr warn_fn, png_voidp mem_ptr, +- png_malloc_ptr malloc_fn, png_free_ptr free_fn) ++PNG_FUNCTION(png_structp,PNGAPI ++png_create_read_struct_2,(png_const_charp user_png_ver, png_voidp error_ptr, ++ png_error_ptr error_fn, png_error_ptr warn_fn, png_voidp mem_ptr, ++ png_malloc_ptr malloc_fn, png_free_ptr free_fn),PNG_ALLOCATED) + { +-#endif /* PNG_USER_MEM_SUPPORTED */ +- +-#ifdef PNG_SETJMP_SUPPORTED +- volatile +-#endif +- png_structp png_ptr; +- +-#ifdef PNG_SETJMP_SUPPORTED +-#ifdef USE_FAR_KEYWORD +- jmp_buf jmpbuf; +-#endif +-#endif +- +- int i; +- +- png_debug(1, "in png_create_read_struct"); ++ 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 */ + +-#ifdef PNG_USER_MEM_SUPPORTED +- png_ptr = (png_structp)png_create_struct_2(PNG_STRUCT_PNG, +- (png_malloc_ptr)malloc_fn, (png_voidp)mem_ptr); +-#else +- png_ptr = (png_structp)png_create_struct(PNG_STRUCT_PNG); +-#endif +- if (png_ptr == NULL) +- return (NULL); +- +- /* Added at libpng-1.2.6 */ +-#ifdef PNG_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 +-#ifdef USE_FAR_KEYWORD +- if (setjmp(jmpbuf)) +-#else +- if (setjmp(png_ptr->jmpbuf)) +-#endif ++ if (png_ptr != NULL) + { +- png_free(png_ptr, png_ptr->zbuf); +- png_ptr->zbuf = NULL; +-#ifdef PNG_USER_MEM_SUPPORTED +- png_destroy_struct_2((png_voidp)png_ptr, +- (png_free_ptr)free_fn, (png_voidp)mem_ptr); +-#else +- png_destroy_struct((png_voidp)png_ptr); +-#endif +- return (NULL); +- } +-#ifdef USE_FAR_KEYWORD +- png_memcpy(png_ptr->jmpbuf, jmpbuf, png_sizeof(jmp_buf)); +-#endif +-#endif /* PNG_SETJMP_SUPPORTED */ ++ png_ptr->mode = PNG_IS_READ_STRUCT; + +-#ifdef PNG_USER_MEM_SUPPORTED +- png_set_mem_fn(png_ptr, mem_ptr, malloc_fn, free_fn); +-#endif ++ /* 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 + +- png_set_error_fn(png_ptr, error_ptr, error_fn, warn_fn); ++# ifdef PNG_BENIGN_READ_ERRORS_SUPPORTED ++ png_ptr->flags |= PNG_FLAG_BENIGN_ERRORS_WARN; + +- if (user_png_ver) +- { +- i = 0; +- do +- { +- if (user_png_ver[i] != png_libpng_ver[i]) +- png_ptr->flags |= PNG_FLAG_LIBRARY_MISMATCH; +- } while (png_libpng_ver[i++]); +- } +- else +- png_ptr->flags |= PNG_FLAG_LIBRARY_MISMATCH; +- +- +- if (png_ptr->flags & PNG_FLAG_LIBRARY_MISMATCH) +- { +- /* Libpng 0.90 and later are binary incompatible with libpng 0.89, so +- * we must recompile any applications that use any older library version. +- * For versions after libpng 1.0, we will be compatible, so we need +- * only check the first digit. ++ /* In stable builds only warn if an application error can be completely ++ * handled. ++ */ ++# if PNG_RELEASE_BUILD ++ 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. + */ +- if (user_png_ver == NULL || user_png_ver[0] != png_libpng_ver[0] || +- (user_png_ver[0] == '1' && user_png_ver[2] != png_libpng_ver[2]) || +- (user_png_ver[0] == '0' && user_png_ver[2] < '9')) +- { +-#if defined(PNG_STDIO_SUPPORTED) && !defined(_WIN32_WCE) +- char msg[80]; +- if (user_png_ver) +- { +- png_snprintf(msg, 80, +- "Application was compiled with png.h from libpng-%.20s", +- user_png_ver); +- png_warning(png_ptr, msg); +- } +- png_snprintf(msg, 80, +- "Application is running with png.c from libpng-%.20s", +- png_libpng_ver); +- png_warning(png_ptr, msg); +-#endif +-#ifdef PNG_ERROR_NUMBERS_SUPPORTED +- png_ptr->flags = 0; +-#endif +- png_error(png_ptr, +- "Incompatible libpng version in application and library"); +- } ++ png_set_read_fn(png_ptr, NULL, NULL); + } + +- /* Initialize zbuf - compression buffer */ +- png_ptr->zbuf_size = PNG_ZBUF_SIZE; +- png_ptr->zbuf = (png_bytep)png_malloc(png_ptr, +- (png_uint_32)png_ptr->zbuf_size); +- png_ptr->zstream.zalloc = png_zalloc; +- png_ptr->zstream.zfree = png_zfree; +- png_ptr->zstream.opaque = (voidpf)png_ptr; +- +- switch (inflateInit(&png_ptr->zstream)) +- { +- case Z_OK: /* Do nothing */ break; +- case Z_MEM_ERROR: +- case Z_STREAM_ERROR: png_error(png_ptr, "zlib memory error"); +- break; +- case Z_VERSION_ERROR: png_error(png_ptr, "zlib version error"); +- break; +- default: png_error(png_ptr, "Unknown zlib error"); +- } +- +- +- png_ptr->zstream.next_out = png_ptr->zbuf; +- png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size; +- +- png_set_read_fn(png_ptr, png_voidp_NULL, png_rw_ptr_NULL); +- +-#ifdef PNG_SETJMP_SUPPORTED +-/* Applications that neglect to set up their own setjmp() and then +- encounter a png_error() will longjmp here. Since the jmpbuf is +- then meaningless we abort instead of returning. */ +-#ifdef USE_FAR_KEYWORD +- if (setjmp(jmpbuf)) +- PNG_ABORT(); +- png_memcpy(png_ptr->jmpbuf, jmpbuf, png_sizeof(jmp_buf)); +-#else +- if (setjmp(png_ptr->jmpbuf)) +- PNG_ABORT(); +-#endif +-#endif /* PNG_SETJMP_SUPPORTED */ +- +- return (png_ptr); +-} +- +-#if defined(PNG_1_0_X) || defined(PNG_1_2_X) +-/* Initialize PNG structure for reading, and allocate any memory needed. +- * This interface is deprecated in favour of the png_create_read_struct(), +- * and it will disappear as of libpng-1.3.0. +- */ +-#undef png_read_init +-void PNGAPI +-png_read_init(png_structp png_ptr) +-{ +- /* We only come here via pre-1.0.7-compiled applications */ +- png_read_init_2(png_ptr, "1.0.6 or earlier", 0, 0); +-} +- +-void PNGAPI +-png_read_init_2(png_structp png_ptr, png_const_charp user_png_ver, +- png_size_t png_struct_size, png_size_t png_info_size) +-{ +- /* We only come here via pre-1.0.12-compiled applications */ +- if (png_ptr == NULL) +- return; +-#if defined(PNG_STDIO_SUPPORTED) && !defined(_WIN32_WCE) +- if (png_sizeof(png_struct) > png_struct_size || +- png_sizeof(png_info) > png_info_size) +- { +- char msg[80]; +- png_ptr->warning_fn = NULL; +- if (user_png_ver) +- { +- png_snprintf(msg, 80, +- "Application was compiled with png.h from libpng-%.20s", +- user_png_ver); +- png_warning(png_ptr, msg); +- } +- png_snprintf(msg, 80, +- "Application is running with png.c from libpng-%.20s", +- png_libpng_ver); +- png_warning(png_ptr, msg); +- } +-#endif +- if (png_sizeof(png_struct) > png_struct_size) +- { +- png_ptr->error_fn = NULL; +-#ifdef PNG_ERROR_NUMBERS_SUPPORTED +- png_ptr->flags = 0; +-#endif +- png_error(png_ptr, +- "The png struct allocated by the application for reading is" +- " too small."); +- } +- if (png_sizeof(png_info) > png_info_size) +- { +- png_ptr->error_fn = NULL; +-#ifdef PNG_ERROR_NUMBERS_SUPPORTED +- png_ptr->flags = 0; +-#endif +- png_error(png_ptr, +- "The info struct allocated by application for reading is" +- " too small."); +- } +- png_read_init_3(&png_ptr, user_png_ver, png_struct_size); ++ return png_ptr; + } +-#endif /* PNG_1_0_X || PNG_1_2_X */ +- +-void PNGAPI +-png_read_init_3(png_structpp ptr_ptr, png_const_charp user_png_ver, +- png_size_t png_struct_size) +-{ +-#ifdef PNG_SETJMP_SUPPORTED +- jmp_buf tmp_jmp; /* to save current jump buffer */ +-#endif +- +- int i = 0; +- +- png_structp png_ptr=*ptr_ptr; +- +- if (png_ptr == NULL) +- return; +- +- do +- { +- if (user_png_ver[i] != png_libpng_ver[i]) +- { +-#ifdef PNG_LEGACY_SUPPORTED +- png_ptr->flags |= PNG_FLAG_LIBRARY_MISMATCH; +-#else +- png_ptr->warning_fn = NULL; +- png_warning(png_ptr, +- "Application uses deprecated png_read_init() and should be" +- " recompiled."); +- break; +-#endif +- } +- } while (png_libpng_ver[i++]); +- +- png_debug(1, "in png_read_init_3"); +- +-#ifdef PNG_SETJMP_SUPPORTED +- /* Save jump buffer and error functions */ +- png_memcpy(tmp_jmp, png_ptr->jmpbuf, png_sizeof(jmp_buf)); +-#endif +- +- if (png_sizeof(png_struct) > png_struct_size) +- { +- png_destroy_struct(png_ptr); +- *ptr_ptr = (png_structp)png_create_struct(PNG_STRUCT_PNG); +- png_ptr = *ptr_ptr; +- } +- +- /* Reset all variables to 0 */ +- png_memset(png_ptr, 0, png_sizeof(png_struct)); +- +-#ifdef PNG_SETJMP_SUPPORTED +- /* Restore jump buffer */ +- png_memcpy(png_ptr->jmpbuf, tmp_jmp, png_sizeof(jmp_buf)); +-#endif +- +- /* Added at libpng-1.2.6 */ +-#ifdef PNG_SET_USER_LIMITS_SUPPORTED +- png_ptr->user_width_max = PNG_USER_WIDTH_MAX; +- png_ptr->user_height_max = PNG_USER_HEIGHT_MAX; +-#endif +- +- /* Initialize zbuf - compression buffer */ +- png_ptr->zbuf_size = PNG_ZBUF_SIZE; +- png_ptr->zstream.zalloc = png_zalloc; +- png_ptr->zbuf = (png_bytep)png_malloc(png_ptr, +- (png_uint_32)png_ptr->zbuf_size); +- png_ptr->zstream.zalloc = png_zalloc; +- png_ptr->zstream.zfree = png_zfree; +- png_ptr->zstream.opaque = (voidpf)png_ptr; +- +- switch (inflateInit(&png_ptr->zstream)) +- { +- case Z_OK: /* Do nothing */ break; +- case Z_STREAM_ERROR: png_error(png_ptr, "zlib memory error"); break; +- case Z_VERSION_ERROR: png_error(png_ptr, "zlib version error"); +- break; +- default: png_error(png_ptr, "Unknown zlib error"); +- } +- +- png_ptr->zstream.next_out = png_ptr->zbuf; +- png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size; + +- png_set_read_fn(png_ptr, png_voidp_NULL, png_rw_ptr_NULL); +-} + + #ifdef PNG_SEQUENTIAL_READ_SUPPORTED + /* Read the information before the actual image data. This has been +@@ -351,229 +89,203 @@ png_read_init_3(png_structpp ptr_ptr, png_const_charp user_png_ver, + * 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) + return; +- +- /* If we haven't checked all of the PNG signature bytes, do so now. */ +- if (png_ptr->sig_bytes < 8) +- { +- png_size_t num_checked = png_ptr->sig_bytes, +- num_to_check = 8 - num_checked; + +- png_read_data(png_ptr, &(info_ptr->signature[num_checked]), num_to_check); +- png_ptr->sig_bytes = 8; +- +- if (png_sig_cmp(info_ptr->signature, num_checked, num_to_check)) +- { +- if (num_checked < 4 && +- png_sig_cmp(info_ptr->signature, num_checked, num_to_check - 4)) +- png_error(png_ptr, "Not a PNG file"); +- else +- png_error(png_ptr, "PNG file corrupted by ASCII conversion"); +- } +- if (num_checked < 3) +- png_ptr->mode |= PNG_HAVE_PNG_SIGNATURE; +- } ++ /* Read and check the PNG file signature. */ ++ png_read_sig(png_ptr, info_ptr); + + for (;;) + { +-#ifdef PNG_USE_LOCAL_ARRAYS +- PNG_CONST PNG_IHDR; +- PNG_CONST PNG_IDAT; +- PNG_CONST PNG_IEND; +- PNG_CONST PNG_PLTE; +-#ifdef PNG_READ_bKGD_SUPPORTED +- PNG_CONST PNG_bKGD; +-#endif +-#ifdef PNG_READ_cHRM_SUPPORTED +- PNG_CONST PNG_cHRM; +-#endif +-#ifdef PNG_READ_gAMA_SUPPORTED +- PNG_CONST PNG_gAMA; +-#endif +-#ifdef PNG_READ_hIST_SUPPORTED +- PNG_CONST PNG_hIST; +-#endif +-#ifdef PNG_READ_iCCP_SUPPORTED +- PNG_CONST PNG_iCCP; +-#endif +-#ifdef PNG_READ_iTXt_SUPPORTED +- PNG_CONST PNG_iTXt; +-#endif +-#ifdef PNG_READ_oFFs_SUPPORTED +- PNG_CONST PNG_oFFs; +-#endif +-#ifdef PNG_READ_pCAL_SUPPORTED +- PNG_CONST PNG_pCAL; +-#endif +-#ifdef PNG_READ_pHYs_SUPPORTED +- PNG_CONST PNG_pHYs; +-#endif +-#ifdef PNG_READ_sBIT_SUPPORTED +- PNG_CONST PNG_sBIT; +-#endif +-#ifdef PNG_READ_sCAL_SUPPORTED +- PNG_CONST PNG_sCAL; +-#endif +-#ifdef PNG_READ_sPLT_SUPPORTED +- PNG_CONST PNG_sPLT; +-#endif +-#ifdef PNG_READ_sRGB_SUPPORTED +- PNG_CONST PNG_sRGB; +-#endif +-#ifdef PNG_READ_tEXt_SUPPORTED +- PNG_CONST PNG_tEXt; +-#endif +-#ifdef PNG_READ_tIME_SUPPORTED +- PNG_CONST PNG_tIME; +-#endif +-#ifdef PNG_READ_tRNS_SUPPORTED +- PNG_CONST PNG_tRNS; +-#endif +-#ifdef PNG_READ_zTXt_SUPPORTED +- PNG_CONST PNG_zTXt; +-#endif +-#endif /* PNG_USE_LOCAL_ARRAYS */ + png_uint_32 length = png_read_chunk_header(png_ptr); +- PNG_CONST png_bytep chunk_name = png_ptr->chunk_name; ++ 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_HAVE_CHUNK_AFTER_IDAT; ++ 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)) +- { +- 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"); + ++ else if (chunk_name == png_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_eXIf_SUPPORTED ++ else if (chunk_name == png_eXIf) ++ png_handle_eXIf(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"); + +- png_read_transform_info(png_ptr, info_ptr); ++ 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 +@@ -583,72 +295,166 @@ png_read_update_info(png_structp png_ptr, png_infop info_ptr) + * 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) +- return; +- if (!(png_ptr->flags & PNG_FLAG_ROW_INIT)) +- png_read_start_row(png_ptr); ++ ++ 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 /* PNG_SEQUENTIAL_READ_SUPPORTED */ ++#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 = (png_uint_32)(*(rp ) << 8) | *(rp + 1); ++ png_uint_32 s1 = (png_uint_32)(*(rp + 2) << 8) | *(rp + 3); ++ png_uint_32 s2 = (png_uint_32)(*(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_structp png_ptr, png_bytep row, png_bytep dsp_row) ++png_read_row(png_structrp png_ptr, png_bytep row, png_bytep dsp_row) + { +- PNG_CONST PNG_IDAT; +- PNG_CONST int png_pass_dsp_mask[7] = {0xff, 0x0f, 0xff, 0x33, 0xff, 0x55, +- 0xff}; +- PNG_CONST int png_pass_mask[7] = {0x80, 0x08, 0x88, 0x22, 0xaa, 0x55, 0xff}; +- int ret; +- ++ png_row_info row_info; ++ + if (png_ptr == NULL) + return; +- ++ + png_debug2(1, "in png_read_row (row %lu, pass %d)", +- png_ptr->row_number, png_ptr->pass); ++ (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) +- png_warning(png_ptr, "PNG_READ_INVERT_SUPPORTED is not defined."); ++ 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) +- png_warning(png_ptr, "PNG_READ_FILLER_SUPPORTED is not defined."); ++ 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) +- png_warning(png_ptr, "PNG_READ_PACKSWAP_SUPPORTED is not defined."); ++ 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) +- png_warning(png_ptr, "PNG_READ_PACK_SUPPORTED is not defined."); ++ 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) +- png_warning(png_ptr, "PNG_READ_SHIFT_SUPPORTED is not defined."); ++ 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) +- png_warning(png_ptr, "PNG_READ_BGR_SUPPORTED is not defined."); ++ 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) +- png_warning(png_ptr, "PNG_READ_SWAP_SUPPORTED is not defined."); ++ 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) + { +@@ -656,64 +462,70 @@ png_read_row(png_structp png_ptr, png_bytep row, png_bytep dsp_row) + 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; + } + break; ++ + case 1: + if ((png_ptr->row_number & 0x07) || png_ptr->width < 5) + { + if (dsp_row != NULL) +- png_combine_row(png_ptr, dsp_row, +- png_pass_dsp_mask[png_ptr->pass]); ++ png_combine_row(png_ptr, dsp_row, 1/*display*/); ++ + png_read_finish_row(png_ptr); + return; + } + break; ++ + case 2: + if ((png_ptr->row_number & 0x07) != 4) + { + if (dsp_row != NULL && (png_ptr->row_number & 4)) +- png_combine_row(png_ptr, dsp_row, +- png_pass_dsp_mask[png_ptr->pass]); ++ png_combine_row(png_ptr, dsp_row, 1/*display*/); ++ + png_read_finish_row(png_ptr); + return; + } + break; ++ + case 3: + if ((png_ptr->row_number & 3) || png_ptr->width < 3) + { + if (dsp_row != NULL) +- png_combine_row(png_ptr, dsp_row, +- png_pass_dsp_mask[png_ptr->pass]); ++ png_combine_row(png_ptr, dsp_row, 1/*display*/); ++ + png_read_finish_row(png_ptr); + return; + } + break; ++ + case 4: + if ((png_ptr->row_number & 3) != 2) + { + if (dsp_row != NULL && (png_ptr->row_number & 2)) +- png_combine_row(png_ptr, dsp_row, +- png_pass_dsp_mask[png_ptr->pass]); ++ png_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; + } + break; ++ ++ default: + case 6: +- if (!(png_ptr->row_number & 1)) ++ if ((png_ptr->row_number & 1) == 0) + { + png_read_finish_row(png_ptr); + return; +@@ -723,111 +535,86 @@ png_read_row(png_structp png_ptr, png_bytep row, png_bytep dsp_row) + } + #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 +- { +- if (!(png_ptr->zstream.avail_in)) +- { +- while (!png_ptr->idat_size) +- { +- png_crc_finish(png_ptr, 0); +- +- png_ptr->idat_size = png_read_chunk_header(png_ptr); +- if (png_memcmp(png_ptr->chunk_name, png_IDAT, 4)) +- png_error(png_ptr, "Not enough image data"); +- } +- png_ptr->zstream.avail_in = (uInt)png_ptr->zbuf_size; +- png_ptr->zstream.next_in = png_ptr->zbuf; +- if (png_ptr->zbuf_size > png_ptr->idat_size) +- png_ptr->zstream.avail_in = (uInt)png_ptr->idat_size; +- png_crc_read(png_ptr, png_ptr->zbuf, +- (png_size_t)png_ptr->zstream.avail_in); +- png_ptr->idat_size -= png_ptr->zstream.avail_in; +- } +- ret = inflate(&png_ptr->zstream, Z_PARTIAL_FLUSH); +- if (ret == Z_STREAM_END) +- { +- if (png_ptr->zstream.avail_out || png_ptr->zstream.avail_in || +- png_ptr->idat_size) +- png_error(png_ptr, "Extra compressed data"); +- png_ptr->mode |= PNG_AFTER_IDAT; +- png_ptr->flags |= PNG_FLAG_ZLIB_FINISHED; +- break; +- } +- if (ret != Z_OK) +- png_error(png_ptr, png_ptr->zstream.msg ? png_ptr->zstream.msg : +- "Decompression error"); +- +- } while (png_ptr->zstream.avail_out); ++ /* Fill the row with IDAT data: */ ++ png_ptr->row_buf[0]=255; /* to force error if no data was found */ ++ png_read_IDAT_data(png_ptr, png_ptr->row_buf, row_info.rowbytes + 1); + +- 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])); ++ 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_check(png_ptr, 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 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) && +- (png_ptr->filter_type == PNG_INTRAPIXEL_DIFFERENCING)) ++ 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, &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"); ++ } + +- if (png_ptr->transformations || (png_ptr->flags&PNG_FLAG_STRIP_ALPHA)) +- png_do_read_transformations(png_ptr); ++ 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, +@@ -855,17 +642,18 @@ png_read_row(png_structp png_ptr, png_bytep row, png_bytep dsp_row) + */ + + void PNGAPI +-png_read_rows(png_structp png_ptr, png_bytepp row, +- png_bytepp display_row, png_uint_32 num_rows) ++png_read_rows(png_structrp png_ptr, png_bytepp row, ++ png_bytepp display_row, png_uint_32 num_rows) + { + png_uint_32 i; + png_bytepp rp; + png_bytepp dp; + + png_debug(1, "in png_read_rows"); +- ++ + if (png_ptr == NULL) + return; ++ + rp = row; + dp = display_row; + if (rp != NULL && dp != NULL) +@@ -876,22 +664,24 @@ png_read_rows(png_structp png_ptr, png_bytepp row, + + png_read_row(png_ptr, rptr, dptr); + } ++ + else if (rp != NULL) + for (i = 0; i < num_rows; i++) + { + png_bytep rptr = *rp; +- png_read_row(png_ptr, rptr, png_bytep_NULL); ++ png_read_row(png_ptr, rptr, NULL); + rp++; + } ++ + else if (dp != NULL) + for (i = 0; i < num_rows; i++) + { + png_bytep dptr = *dp; +- png_read_row(png_ptr, png_bytep_NULL, dptr); ++ png_read_row(png_ptr, NULL, dptr); + 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 +@@ -907,41 +697,65 @@ png_read_rows(png_structp png_ptr, png_bytepp row, + * [*] 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; + png_bytepp rp; + + png_debug(1, "in png_read_image"); +- ++ + if (png_ptr == NULL) + return; + + #ifdef PNG_READ_INTERLACING_SUPPORTED +- pass = png_set_interlace_handling(png_ptr); ++ if ((png_ptr->flags & PNG_FLAG_ROW_INIT) == 0) ++ { ++ pass = png_set_interlace_handling(png_ptr); ++ /* And make sure transforms are initialized. */ ++ png_start_read_image(png_ptr); ++ } ++ else ++ { ++ 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, ++ * but the caller should do it! ++ */ ++ png_warning(png_ptr, "Interlace handling should be turned on when " ++ "using png_read_image"); ++ /* Make sure this is set correctly */ ++ png_ptr->num_rows = png_ptr->height; ++ } ++ ++ /* Obtain the pass number, which also turns on the PNG_INTERLACE flag in ++ * the above error case. ++ */ ++ pass = png_set_interlace_handling(png_ptr); ++ } + #else + if (png_ptr->interlaced) + png_error(png_ptr, +- "Cannot read interlaced image -- interlace handler disabled."); ++ "Cannot read interlaced image -- interlace handler disabled"); ++ + pass = 1; + #endif + +- + image_height=png_ptr->height; +- png_ptr->num_rows = image_height; /* Make sure this is set correctly */ + + for (j = 0; j < pass; j++) + { + rp = image; + for (i = 0; i < image_height; i++) + { +- png_read_row(png_ptr, *rp, png_bytep_NULL); ++ png_read_row(png_ptr, *rp, NULL); + rp++; + } + } + } +-#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 +@@ -949,404 +763,276 @@ png_read_image(png_structp png_ptr, png_bytepp image) + * 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 */ + +- do +- { +-#ifdef PNG_USE_LOCAL_ARRAYS +- PNG_CONST PNG_IHDR; +- PNG_CONST PNG_IDAT; +- PNG_CONST PNG_IEND; +- PNG_CONST PNG_PLTE; +-#ifdef PNG_READ_bKGD_SUPPORTED +- PNG_CONST PNG_bKGD; +-#endif +-#ifdef PNG_READ_cHRM_SUPPORTED +- PNG_CONST PNG_cHRM; +-#endif +-#ifdef PNG_READ_gAMA_SUPPORTED +- PNG_CONST PNG_gAMA; +-#endif +-#ifdef PNG_READ_hIST_SUPPORTED +- PNG_CONST PNG_hIST; +-#endif +-#ifdef PNG_READ_iCCP_SUPPORTED +- PNG_CONST PNG_iCCP; +-#endif +-#ifdef PNG_READ_iTXt_SUPPORTED +- PNG_CONST PNG_iTXt; +-#endif +-#ifdef PNG_READ_oFFs_SUPPORTED +- PNG_CONST PNG_oFFs; +-#endif +-#ifdef PNG_READ_pCAL_SUPPORTED +- PNG_CONST PNG_pCAL; +-#endif +-#ifdef PNG_READ_pHYs_SUPPORTED +- PNG_CONST PNG_pHYs; +-#endif +-#ifdef PNG_READ_sBIT_SUPPORTED +- PNG_CONST PNG_sBIT; +-#endif +-#ifdef PNG_READ_sCAL_SUPPORTED +- PNG_CONST PNG_sCAL; +-#endif +-#ifdef PNG_READ_sPLT_SUPPORTED +- PNG_CONST PNG_sPLT; +-#endif +-#ifdef PNG_READ_sRGB_SUPPORTED +- PNG_CONST PNG_sRGB; +-#endif +-#ifdef PNG_READ_tEXt_SUPPORTED +- PNG_CONST PNG_tEXt; +-#endif +-#ifdef PNG_READ_tIME_SUPPORTED +- PNG_CONST PNG_tIME; +-#endif +-#ifdef PNG_READ_tRNS_SUPPORTED +- PNG_CONST PNG_tRNS; ++ /* 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 +-#ifdef PNG_READ_zTXt_SUPPORTED +- PNG_CONST PNG_zTXt; ++ 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 +-#endif /* PNG_USE_LOCAL_ARRAYS */ ++ ++ do ++ { + 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; + +- if (!png_memcmp(chunk_name, png_IHDR, 4)) +- png_handle_IHDR(png_ptr, info_ptr, length); +- else if (!png_memcmp(chunk_name, png_IEND, 4)) ++ if (chunk_name != png_IDAT) ++ png_ptr->mode |= PNG_HAVE_CHUNK_AFTER_IDAT; ++ ++ 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 (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)) +- png_error(png_ptr, "Too many IDAT's found"); ++ if ((length > 0 && !(png_ptr->flags & PNG_FLAG_ZSTREAM_ENDED)) ++ || (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. ++ * read, but not after other chunks have been read. 1.6 does not ++ * always read all the deflate data; specifically it cannot be relied ++ * upon to read the Adler32 at the end. If it doesn't ignore IDAT ++ * chunks which are longer than zero as well: + */ +- if ((length > 0) || (png_ptr->mode & PNG_HAVE_CHUNK_AFTER_IDAT)) +- png_error(png_ptr, "Too many IDAT's found"); ++ if ((length > 0 && !(png_ptr->flags & PNG_FLAG_ZSTREAM_ENDED)) ++ || (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_eXIf_SUPPORTED ++ else if (chunk_name == png_eXIf) ++ png_handle_eXIf(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 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) ++/* Free all memory used in the read struct */ ++static void ++png_read_destroy(png_structrp png_ptr) + { +- png_structp png_ptr = NULL; +- png_infop info_ptr = NULL, end_info_ptr = NULL; +-#ifdef PNG_USER_MEM_SUPPORTED +- png_free_ptr free_fn = NULL; +- png_voidp mem_ptr = NULL; +-#endif +- +- png_debug(1, "in png_destroy_read_struct"); +- +- if (png_ptr_ptr != NULL) +- png_ptr = *png_ptr_ptr; +- if (png_ptr == NULL) +- return; +- +-#ifdef PNG_USER_MEM_SUPPORTED +- free_fn = png_ptr->free_fn; +- mem_ptr = png_ptr->mem_ptr; +-#endif +- +- if (info_ptr_ptr != NULL) +- info_ptr = *info_ptr_ptr; +- +- if (end_info_ptr_ptr != NULL) +- end_info_ptr = *end_info_ptr_ptr; +- +- png_read_destroy(png_ptr, info_ptr, end_info_ptr); ++ png_debug(1, "in png_read_destroy"); + +- if (info_ptr != NULL) +- { +-#ifdef PNG_TEXT_SUPPORTED +- png_free_data(png_ptr, info_ptr, PNG_FREE_TEXT, -1); ++#ifdef PNG_READ_GAMMA_SUPPORTED ++ png_destroy_gamma_table(png_ptr); + #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; +- } ++ 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; + +- 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); ++#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 +- *end_info_ptr_ptr = NULL; +- } + +- if (png_ptr != NULL) ++ if ((png_ptr->free_me & PNG_FREE_PLTE) != 0) + { +-#ifdef PNG_USER_MEM_SUPPORTED +- png_destroy_struct_2((png_voidp)png_ptr, (png_free_ptr)free_fn, +- (png_voidp)mem_ptr); +-#else +- png_destroy_struct((png_voidp)png_ptr); +-#endif +- *png_ptr_ptr = NULL; +- } +-} +- +-/* Free all memory used by the read (old method) */ +-void /* PRIVATE */ +-png_read_destroy(png_structp png_ptr, png_infop info_ptr, +- png_infop end_info_ptr) +-{ +-#ifdef PNG_SETJMP_SUPPORTED +- jmp_buf tmp_jmp; +-#endif +- png_error_ptr error_fn; +- png_error_ptr warning_fn; +- png_voidp error_ptr; +-#ifdef PNG_USER_MEM_SUPPORTED +- png_free_ptr free_fn; +-#endif +- +- png_debug(1, "in png_read_destroy"); +- +- if (info_ptr != NULL) +- png_info_destroy(png_ptr, info_ptr); +- +- if (end_info_ptr != NULL) +- png_info_destroy(png_ptr, end_info_ptr); +- +- png_free(png_ptr, png_ptr->zbuf); +- png_free(png_ptr, png_ptr->big_row_buf); +- png_free(png_ptr, png_ptr->prev_row); +- png_free(png_ptr, png_ptr->chunkdata); +-#ifdef PNG_READ_DITHER_SUPPORTED +- png_free(png_ptr, png_ptr->palette_lookup); +- png_free(png_ptr, png_ptr->dither_index); +-#endif +-#ifdef PNG_READ_GAMMA_SUPPORTED +- png_free(png_ptr, png_ptr->gamma_table); +-#endif +-#ifdef PNG_READ_BACKGROUND_SUPPORTED +- png_free(png_ptr, png_ptr->gamma_from_1); +- png_free(png_ptr, png_ptr->gamma_to_1); +-#endif +-#ifdef PNG_FREE_ME_SUPPORTED +- if (png_ptr->free_me & PNG_FREE_PLTE) + png_zfree(png_ptr, png_ptr->palette); ++ png_ptr->palette = NULL; ++ } + png_ptr->free_me &= ~PNG_FREE_PLTE; +-#else +- if (png_ptr->flags & PNG_FLAG_FREE_PLTE) +- png_zfree(png_ptr, png_ptr->palette); +- png_ptr->flags &= ~PNG_FLAG_FREE_PLTE; +-#endif ++ + #if defined(PNG_tRNS_SUPPORTED) || \ + defined(PNG_READ_EXPAND_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) +-#ifdef PNG_FREE_ME_SUPPORTED +- if (png_ptr->free_me & PNG_FREE_TRNS) +- png_free(png_ptr, png_ptr->trans); +- png_ptr->free_me &= ~PNG_FREE_TRNS; +-#else +- if (png_ptr->flags & PNG_FLAG_FREE_TRNS) +- png_free(png_ptr, png_ptr->trans); +- png_ptr->flags &= ~PNG_FLAG_FREE_TRNS; +-#endif +-#endif +-#ifdef PNG_READ_hIST_SUPPORTED +-#ifdef PNG_FREE_ME_SUPPORTED +- if (png_ptr->free_me & PNG_FREE_HIST) +- png_free(png_ptr, png_ptr->hist); +- png_ptr->free_me &= ~PNG_FREE_HIST; +-#else +- if (png_ptr->flags & PNG_FLAG_FREE_HIST) +- png_free(png_ptr, png_ptr->hist); +- png_ptr->flags &= ~PNG_FLAG_FREE_HIST; +-#endif +-#endif +-#ifdef PNG_READ_GAMMA_SUPPORTED +- if (png_ptr->gamma_16_table != NULL) +- { +- int i; +- int istop = (1 << (8 - png_ptr->gamma_shift)); +- for (i = 0; i < istop; i++) +- { +- png_free(png_ptr, png_ptr->gamma_16_table[i]); +- } +- png_free(png_ptr, png_ptr->gamma_16_table); +- } +-#ifdef PNG_READ_BACKGROUND_SUPPORTED +- if (png_ptr->gamma_16_from_1 != NULL) ++ if ((png_ptr->free_me & PNG_FREE_TRNS) != 0) + { +- 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); ++ png_free(png_ptr, png_ptr->trans_alpha); ++ png_ptr->trans_alpha = NULL; + } +-#endif +-#endif +-#ifdef PNG_TIME_RFC1123_SUPPORTED +- png_free(png_ptr, png_ptr->time_buffer); ++ 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 + +-#ifdef PNG_PROGRESSIVE_READ_SUPPORTED +-#ifdef PNG_TEXT_SUPPORTED +- png_free(png_ptr, png_ptr->current_text); +-#endif /* PNG_TEXT_SUPPORTED */ +-#endif /* PNG_PROGRESSIVE_READ_SUPPORTED */ +- +- /* Save the important info out of the png_struct, in case it is +- * being used again. +- */ +-#ifdef PNG_SETJMP_SUPPORTED +- png_memcpy(tmp_jmp, png_ptr->jmpbuf, png_sizeof(jmp_buf)); ++#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 + +- error_fn = png_ptr->error_fn; +- warning_fn = png_ptr->warning_fn; +- error_ptr = png_ptr->error_ptr; +-#ifdef PNG_USER_MEM_SUPPORTED +- free_fn = png_ptr->free_fn; ++#ifdef PNG_SET_UNKNOWN_CHUNKS_SUPPORTED ++ png_free(png_ptr, png_ptr->chunk_list); ++ png_ptr->chunk_list = NULL; + #endif + +- png_memset(png_ptr, 0, png_sizeof(png_struct)); ++ /* 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. ++ */ ++} + +- png_ptr->error_fn = error_fn; +- png_ptr->warning_fn = warning_fn; +- png_ptr->error_ptr = error_ptr; +-#ifdef PNG_USER_MEM_SUPPORTED +- png_ptr->free_fn = free_fn; +-#endif ++/* 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_structrp png_ptr = NULL; + +-#ifdef PNG_SETJMP_SUPPORTED +- png_memcpy(png_ptr->jmpbuf, tmp_jmp, png_sizeof(jmp_buf)); +-#endif ++ png_debug(1, "in png_destroy_read_struct"); ++ ++ if (png_ptr_ptr != NULL) ++ png_ptr = *png_ptr_ptr; ++ ++ if (png_ptr == NULL) ++ return; + ++ /* 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); + } + + 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; ++ + png_ptr->read_row_fn = read_row_fn; + } + +@@ -1354,138 +1040,172 @@ png_set_read_status_fn(png_structp png_ptr, png_read_status_ptr read_row_fn) + #ifdef PNG_SEQUENTIAL_READ_SUPPORTED + #ifdef PNG_INFO_IMAGE_SUPPORTED + void PNGAPI +-png_read_png(png_structp png_ptr, png_infop info_ptr, +- int transforms, +- voidp params) ++png_read_png(png_structrp png_ptr, png_inforp info_ptr, ++ int transforms, voidp params) + { +- int row; +- +- if (png_ptr == NULL) ++ if (png_ptr == NULL || info_ptr == NULL) + return; +-#ifdef PNG_READ_INVERT_ALPHA_SUPPORTED +- /* Invert the alpha channel from opacity to transparency +- */ +- if (transforms & PNG_TRANSFORM_INVERT_ALPHA) +- png_set_invert_alpha(png_ptr); +-#endif + + /* png_read_info() gives us all of the information from the + * PNG file before the first IDAT (image data chunk). + */ + png_read_info(png_ptr, info_ptr); +- if (info_ptr->height > PNG_UINT_32_MAX/png_sizeof(png_bytep)) ++ 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 ------------------- */ ++ /* 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) != 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_16_TO_8_SUPPORTED +- /* Tell libpng to strip 16 bit/color files down to 8 bits per color. ++ /* 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 dithering. ++ /* 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); ++ 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); ++ 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); ++ 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 ++ 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 */ + ++ /* We use png_read_image and rely on that for interlace handling, but we also ++ * call png_read_update_info therefore must turn on interlace handling now: ++ */ ++ (void)png_set_interlace_handling(png_ptr); ++ + /* Optional call to gamma correct and add the background to the palette + * and update info structure. REQUIRED if you are expecting libpng to + * update the palette for you (i.e., you selected such a transform above). +@@ -1494,23 +1214,22 @@ png_read_png(png_structp png_ptr, png_infop info_ptr, + + /* -------------- image transformations end here ------------------- */ + +-#ifdef PNG_FREE_ME_SUPPORTED + png_free_data(png_ptr, info_ptr, PNG_FREE_ROWS, 0); +-#endif + if (info_ptr->row_pointers == NULL) + { +- info_ptr->row_pointers = (png_bytepp)png_malloc(png_ptr, +- info_ptr->height * png_sizeof(png_bytep)); +- png_memset(info_ptr->row_pointers, 0, info_ptr->height +- * png_sizeof(png_bytep)); ++ png_uint_32 iptr; ++ ++ info_ptr->row_pointers = png_voidcast(png_bytepp, png_malloc(png_ptr, ++ info_ptr->height * (sizeof (png_bytep)))); ++ ++ for (iptr=0; iptrheight; iptr++) ++ info_ptr->row_pointers[iptr] = NULL; + +-#ifdef PNG_FREE_ME_SUPPORTED + info_ptr->free_me |= PNG_FREE_ROWS; +-#endif + +- for (row = 0; row < (int)info_ptr->height; row++) +- info_ptr->row_pointers[row] = (png_bytep)png_malloc(png_ptr, +- png_get_rowbytes(png_ptr, info_ptr)); ++ 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); +@@ -1519,10 +1238,2982 @@ png_read_png(png_structp png_ptr, png_infop info_ptr, + /* Read rest of file, and get additional chunks in info_ptr - REQUIRED */ + png_read_end(png_ptr, info_ptr); + +- transforms = transforms; /* Quiet compiler warnings */ +- params = params; ++ PNG_UNUSED(params) ++} ++#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; ++ ++#ifdef PNG_BENIGN_ERRORS_SUPPORTED ++ png_set_benign_errors(png_ptr, 1/*warn*/); ++#endif ++ 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_uint_32)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, 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; ++ 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, 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 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; ++ ++#ifdef __GNUC__ ++ default: ++ png_error(display->image->opaque->png_ptr, ++ "unexpected encoding (internal error)"); ++#endif ++ } ++ ++ 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; + } +-#endif /* PNG_INFO_IMAGE_SUPPORTED */ +-#endif /* PNG_SEQUENTIAL_READ_SUPPORTED */ +-#endif /* PNG_READ_SUPPORTED */ ++ ++/* 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; ++ int output_encoding = (image->format & PNG_FORMAT_FLAG_LINEAR) != 0 ? ++ P_LINEAR : P_sRGB; ++ 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); ++ alpha = PNG_DIV257(alpha); ++ 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 ++ 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 ++ 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; ++ /* FALLTHROUGH */ ++ ++ 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; ++ /* FALLTHROUGH */ ++ ++ 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; ++ /* FALLTHROUGH */ ++ 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; ++ /* FALLTHROUGH */ ++ 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 (int)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 (int)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 (int)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 (int)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); ++ png_imagep image = display->image; ++ ++ png_structrp png_ptr = image->opaque->png_ptr; ++ png_uint_32 output_format = image->format; ++ 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, ++ "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; ibit_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 = (unsigned int)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; ++ } ++#ifdef __COVERITY__ ++ /* Coverity claims that output_encoding cannot be 2 (P_LINEAR) ++ * here. ++ */ ++ back_alpha = 255; ++#else ++ back_alpha = output_encoding == P_LINEAR ? 65535 : 255; ++#endif ++ } ++ ++ /* 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 = (unsigned int)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 = (unsigned int)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, ++#ifdef __COVERITY__ ++ /* Coverity claims that output_encoding ++ * cannot be 2 (P_LINEAR) here. ++ */ 255U, ++#else ++ output_encoding == P_LINEAR ? 65535U : 255U, ++#endif ++ 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 = (unsigned int)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 = (unsigned int)make_gray_file_colormap(display); ++ data_encoding = P_FILE; ++ } ++ ++ else ++ cmap_entries = (unsigned int)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 = (unsigned int)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 = (unsigned int)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 = (unsigned int)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; ++ 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 = (unsigned int)png_ptr->num_palette; ++ if (cmap_entries > 256) ++ cmap_entries = 256; ++ ++ if (cmap_entries > (unsigned int)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*/ ++ } ++ ++ /* 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) ++ { ++ case P_sRGB: ++ /* Change to 8-bit sRGB */ ++ png_set_alpha_mode_fixed(png_ptr, PNG_ALPHA_PNG, PNG_GAMMA_sRGB); ++ /* FALLTHROUGH */ ++ ++ case P_FILE: ++ if (png_ptr->bit_depth > 8) ++ png_set_scale_16(png_ptr); ++ break; ++ ++#ifdef __GNUC__ ++ default: ++ png_error(png_ptr, "bad data option (internal error)"); ++#endif ++ } ++ ++ 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 = (int)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 (; ylocal_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; ++ ++ 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 = (png_alloc_size_t)display->row_bytes; ++ ++ while (--passes >= 0) ++ { ++ png_uint_32 y = image->height; ++ png_bytep row = png_voidcast(png_bytep, display->first_row); ++ ++ for (; y > 0; --y) ++ { ++ 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 (; ylocal_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; cimage; ++ 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) ++ { ++ 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 (; ylocal_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 (; ylocal_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; ++ unsigned int preserve_alpha = (image->format & ++ PNG_FORMAT_FLAG_ALPHA) != 0; ++ unsigned int outchannels = 1U+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 (; ylocal_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; ++ ++#ifdef __GNUC__ ++ default: ++ png_error(png_ptr, "unexpected bit depth"); ++#endif ++ } ++ ++ 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 ((change & PNG_FORMAT_FLAG_ASSOCIATED_ALPHA) != 0) ++ { ++ mode = PNG_ALPHA_OPTIMIZED; ++ change &= ~PNG_FORMAT_FLAG_ASSOCIATED_ALPHA; ++ } ++ ++ /* 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(>est, 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_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 ((format & PNG_FORMAT_FLAG_ASSOCIATED_ALPHA) != 0) { ++ info_format |= PNG_FORMAT_FLAG_ASSOCIATED_ALPHA; ++ } ++ ++ 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 = (png_alloc_size_t)display->row_bytes; ++ ++ while (--passes >= 0) ++ { ++ png_uint_32 y = image->height; ++ png_bytep row = png_voidcast(png_bytep, display->first_row); ++ ++ for (; y > 0; --y) ++ { ++ 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) ++ { ++ /* Check for row_stride overflow. This check is not performed on the ++ * original PNG format because it may not occur in the output PNG format ++ * and libpng deals with the issues of reading the original. ++ */ ++ unsigned int channels = PNG_IMAGE_PIXEL_CHANNELS(image->format); ++ ++ /* The following checks just the 'row_stride' calculation to ensure it ++ * fits in a signed 32-bit value. Because channels/components can be ++ * either 1 or 2 bytes in size the length of a row can still overflow 32 ++ * bits; this is just to verify that the 'row_stride' argument can be ++ * represented. ++ */ ++ if (image->width <= 0x7fffffffU/channels) /* no overflow */ ++ { ++ png_uint_32 check; ++ png_uint_32 png_row_stride = image->width * channels; ++ ++ if (row_stride == 0) ++ row_stride = (png_int_32)/*SAFE*/png_row_stride; ++ ++ if (row_stride < 0) ++ check = (png_uint_32)(-row_stride); ++ ++ else ++ check = (png_uint_32)row_stride; ++ ++ /* This verifies 'check', the absolute value of the actual stride ++ * passed in and detects overflow in the application calculation (i.e. ++ * if the app did actually pass in a non-zero 'row_stride'. ++ */ ++ if (image->opaque != NULL && buffer != NULL && check >= png_row_stride) ++ { ++ /* Now check for overflow of the image buffer calculation; this ++ * limits the whole image size to 32 bits for API compatibility with ++ * the current, 32-bit, PNG_IMAGE_BUFFER_SIZE macro. ++ * ++ * The PNG_IMAGE_BUFFER_SIZE macro is: ++ * ++ * (PNG_IMAGE_PIXEL_COMPONENT_SIZE(fmt)*height*(row_stride)) ++ * ++ * And the component size is always 1 or 2, so make sure that the ++ * number of *bytes* that the application is saying are available ++ * does actually fit into a 32-bit number. ++ * ++ * NOTE: this will be changed in 1.7 because PNG_IMAGE_BUFFER_SIZE ++ * will be changed to use png_alloc_size_t; bigger images can be ++ * accommodated on 64-bit systems. ++ */ ++ if (image->height <= ++ 0xffffffffU/PNG_IMAGE_PIXEL_COMPONENT_SIZE(image->format)/check) ++ { ++ 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: image too large"); ++ } ++ ++ else ++ return png_image_error(image, ++ "png_image_finish_read: invalid argument"); ++ } ++ ++ else ++ return png_image_error(image, ++ "png_image_finish_read: row_stride too large"); ++ } ++ ++ else if (image != NULL) ++ return png_image_error(image, ++ "png_image_finish_read: damaged PNG_IMAGE_VERSION"); ++ ++ return 0; ++} ++ ++#endif /* SIMPLIFIED_READ */ ++#endif /* READ */ +diff --git a/com32/lib/libpng/pngrio.c b/com32/lib/libpng/pngrio.c +index 6978682c..79463581 100644 +--- a/com32/lib/libpng/pngrio.c ++++ b/com32/lib/libpng/pngrio.c +@@ -1,10 +1,10 @@ + + /* pngrio.c - functions for data input + * +- * Last changed in libpng 1.2.43 [February 25, 2010] +- * Copyright (c) 1998-2010 Glenn Randers-Pehrson +- * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) +- * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) ++ * Copyright (c) 2018 Cosmin Truta ++ * Copyright (c) 1998-2002,2004,2006-2016,2018 Glenn Randers-Pehrson ++ * Copyright (c) 1996-1997 Andreas Dilger ++ * Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc. + * + * This code is released under the libpng license. + * For conditions of distribution and use, see the disclaimer +@@ -18,24 +18,24 @@ + * libpng use it at run time with png_set_read_fn(...). + */ + +-#define PNG_INTERNAL +-#define PNG_NO_PEDANTIC_WARNINGS +-#include "png.h" ++#include "pngpriv.h" ++ + #ifdef PNG_READ_SUPPORTED + + /* Read the data from whatever input you are using. The default routine + * reads from a file pointer. Note that this routine sometimes gets called + * with very small lengths, so you should implement some kind of simple + * buffering if you are using unbuffered reads. This should never be asked +- * to read more then 64K on a 16 bit machine. ++ * to read more than 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, size_t length) + { + png_debug1(4, "reading %d bytes", (int)length); +- ++ + if (png_ptr->read_data_fn != NULL) + (*(png_ptr->read_data_fn))(png_ptr, data, length); ++ + else + png_error(png_ptr, "Call to NULL read function"); + } +@@ -46,97 +46,34 @@ png_read_data(png_structp png_ptr, png_bytep data, png_size_t length) + * read_data function and use it at run time with png_set_read_fn(), rather + * than changing the library. + */ +-#ifndef USE_FAR_KEYWORD +-void PNGAPI +-png_default_read_data(png_structp png_ptr, png_bytep data, png_size_t length) ++void PNGCBAPI ++png_default_read_data(png_structp png_ptr, png_bytep data, size_t length) + { +- png_size_t check; ++ size_t check; + + if (png_ptr == NULL) + return; +- /* fread() returns 0 on error, so it is OK to store this in a png_size_t ++ ++ /* fread() returns 0 on error, so it is OK to store this in a size_t + * instead of an int, which is what fread() actually returns. + */ +-#ifdef _WIN32_WCE +- if ( !ReadFile((HANDLE)(png_ptr->io_ptr), data, length, &check, NULL) ) +- check = 0; +-#else +- check = (png_size_t)fread(data, (png_size_t)1, length, +- (png_FILE_p)png_ptr->io_ptr); +-#endif ++ 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 PNGAPI +-png_default_read_data(png_structp png_ptr, png_bytep data, png_size_t length) +-{ +- int check; +- png_byte *n_data; +- png_FILE_p io_ptr; +- +- if (png_ptr == NULL) +- return; +- /* Check if data really is near. If so, use usual code. */ +- n_data = (png_byte *)CVT_PTR_NOCHECK(data); +- io_ptr = (png_FILE_p)CVT_PTR(png_ptr->io_ptr); +- if ((png_bytep)n_data == data) +- { +-#ifdef _WIN32_WCE +- if ( !ReadFile((HANDLE)(png_ptr->io_ptr), data, length, &check, +- NULL) ) +- check = 0; +-#else +- check = fread(n_data, 1, length, io_ptr); +-#endif +- } +- else +- { +- png_byte buf[NEAR_BUF_SIZE]; +- png_size_t read, remaining, err; +- check = 0; +- remaining = length; +- do +- { +- read = MIN(NEAR_BUF_SIZE, remaining); +-#ifdef _WIN32_WCE +- if ( !ReadFile((HANDLE)(io_ptr), buf, read, &err, NULL) ) +- err = 0; +-#else +- err = fread(buf, (png_size_t)1, read, io_ptr); +-#endif +- png_memcpy(data, buf, read); /* copy far buffer to near buffer */ +- if (err != read) +- break; +- else +- check += err; +- data += read; +- remaining -= read; +- } +- while (remaining != 0); +- } +- if ((png_uint_32)check != (png_uint_32)length) +- png_error(png_ptr, "read Error"); +-} +-#endif + #endif + + /* This function allows the application to supply a new input function + * for libpng if standard C streams aren't being used. + * + * This function takes as its arguments: ++ * + * png_ptr - pointer to a png input data structure ++ * + * io_ptr - pointer to user supplied structure containing info about + * the input functions. May be NULL. ++ * + * read_data_fn - pointer to a new input function that takes as its + * arguments a pointer to a png_struct, a pointer to + * a location where input data can be stored, and a 32-bit +@@ -147,34 +84,37 @@ png_default_read_data(png_structp png_ptr, png_bytep data, png_size_t length) + * be used. + */ + void PNGAPI +-png_set_read_fn(png_structp png_ptr, png_voidp io_ptr, +- png_rw_ptr read_data_fn) ++png_set_read_fn(png_structrp png_ptr, png_voidp io_ptr, ++ png_rw_ptr read_data_fn) + { + if (png_ptr == NULL) + return; ++ + png_ptr->io_ptr = io_ptr; + + #ifdef PNG_STDIO_SUPPORTED + if (read_data_fn != NULL) + png_ptr->read_data_fn = read_data_fn; ++ + else + png_ptr->read_data_fn = png_default_read_data; + #else + png_ptr->read_data_fn = read_data_fn; + #endif + ++#ifdef PNG_WRITE_SUPPORTED + /* It is an error to write to a read device */ + if (png_ptr->write_data_fn != NULL) + { + png_ptr->write_data_fn = NULL; + png_warning(png_ptr, +- "It's an error to set both read_data_fn and write_data_fn in the "); +- png_warning(png_ptr, +- "same structure. Resetting write_data_fn to NULL."); ++ "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 */ +diff --git a/com32/lib/libpng/pngrtran.c b/com32/lib/libpng/pngrtran.c +index af1aa8e4..ccc58ce6 100644 +--- a/com32/lib/libpng/pngrtran.c ++++ b/com32/lib/libpng/pngrtran.c +@@ -1,10 +1,10 @@ + + /* pngrtran.c - transforms the data in a row for PNG readers + * +- * Last changed in libpng 1.2.43 [February 25, 2010] +- * Copyright (c) 1998-2010 Glenn Randers-Pehrson +- * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) +- * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) ++ * Copyright (c) 2018 Cosmin Truta ++ * Copyright (c) 1998-2002,2004,2006-2018 Glenn Randers-Pehrson ++ * Copyright (c) 1996-1997 Andreas Dilger ++ * Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc. + * + * This code is released under the libpng license. + * For conditions of distribution and use, see the disclaimer +@@ -16,17 +16,27 @@ + * in pngtrans.c. + */ + +-#define PNG_INTERNAL +-#define PNG_NO_PEDANTIC_WARNINGS +-#include "png.h" ++#include "pngpriv.h" ++ ++#ifdef PNG_ARM_NEON_IMPLEMENTATION ++# if PNG_ARM_NEON_IMPLEMENTATION == 1 ++# define PNG_ARM_NEON_INTRINSICS_AVAILABLE ++# if defined(_MSC_VER) && defined(_M_ARM64) ++# include ++# else ++# include ++# endif ++# endif ++#endif ++ + #ifdef PNG_READ_SUPPORTED + + /* Set the action on getting a CRC error for an ancillary or critical chunk. */ + void PNGAPI +-png_set_crc_action(png_structp png_ptr, int crit_action, int ancil_action) ++png_set_crc_action(png_structrp png_ptr, int crit_action, int ancil_action) + { + png_debug(1, "in png_set_crc_action"); +- ++ + if (png_ptr == NULL) + return; + +@@ -49,7 +59,8 @@ png_set_crc_action(png_structp png_ptr, int crit_action, int ancil_action) + + case PNG_CRC_WARN_DISCARD: /* Not a valid action for critical data */ + png_warning(png_ptr, +- "Can't discard critical data on CRC error."); ++ "Can't discard critical data on CRC error"); ++ /* FALLTHROUGH */ + case PNG_CRC_ERROR_QUIT: /* Error/quit */ + + case PNG_CRC_DEFAULT: +@@ -89,96 +100,350 @@ png_set_crc_action(png_structp png_ptr, int crit_action, int ancil_action) + } + } + +-#if defined(PNG_READ_BACKGROUND_SUPPORTED) && \ +- defined(PNG_FLOATING_POINT_SUPPORTED) ++#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 PNGAPI +-png_set_background(png_structp png_ptr, +- png_color_16p background_color, int background_gamma_code, +- int need_expand, double background_gamma) ++void PNGFAPI ++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"); +- +- if (png_ptr == NULL) ++ png_debug(1, "in png_set_background_fixed"); ++ ++ if (png_rtran_ok(png_ptr, 0) == 0 || background_color == NULL) + return; ++ + if (background_gamma_code == PNG_BACKGROUND_GAMMA_UNKNOWN) + { + png_warning(png_ptr, "Application must supply a known background gamma"); + return; + } + +- png_ptr->transformations |= PNG_BACKGROUND; +- png_memcpy(&(png_ptr->background), background_color, +- png_sizeof(png_color_16)); +- png_ptr->background_gamma = (float)background_gamma; ++ png_ptr->transformations |= PNG_COMPOSE | PNG_STRIP_ALPHA; ++ png_ptr->transformations &= ~PNG_ENCODE_ALPHA; ++ png_ptr->flags &= ~PNG_FLAG_OPTIMIZE_ALPHA; ++ ++ png_ptr->background = *background_color; ++ png_ptr->background_gamma = background_gamma; + png_ptr->background_gamma_type = (png_byte)(background_gamma_code); +- png_ptr->transformations |= (need_expand ? PNG_BACKGROUND_EXPAND : 0); ++ if (need_expand != 0) ++ png_ptr->transformations |= PNG_BACKGROUND_EXPAND; ++ else ++ png_ptr->transformations &= ~PNG_BACKGROUND_EXPAND; ++} ++ ++# ifdef PNG_FLOATING_POINT_SUPPORTED ++void PNGAPI ++png_set_background(png_structrp png_ptr, ++ png_const_color_16p background_color, int background_gamma_code, ++ int need_expand, double background_gamma) ++{ ++ png_set_background_fixed(png_ptr, background_color, background_gamma_code, ++ need_expand, png_fixed(png_ptr, background_gamma, "png_set_background")); ++} ++# endif /* FLOATING_POINT */ ++#endif /* READ_BACKGROUND */ ++ ++/* Scale 16-bit depth files to 8-bit depth. If both of these are set then the ++ * one that pngrtran does first (scale) happens. This is necessary to allow the ++ * TRANSFORM and API behavior to be somewhat consistent, and it's simpler. ++ */ ++#ifdef PNG_READ_SCALE_16_TO_8_SUPPORTED ++void PNGAPI ++png_set_scale_16(png_structrp png_ptr) ++{ ++ png_debug(1, "in png_set_scale_16"); ++ ++ if (png_rtran_ok(png_ptr, 0) == 0) ++ return; ++ ++ png_ptr->transformations |= PNG_SCALE_16_TO_8; + } + #endif + +-#ifdef PNG_READ_16_TO_8_SUPPORTED +-/* Strip 16 bit depth files to 8 bit depth */ ++#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; + } + #endif + + #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; ++} ++#endif ++ ++#if defined(PNG_READ_ALPHA_MODE_SUPPORTED) || defined(PNG_READ_GAMMA_SUPPORTED) ++static png_fixed_point ++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 ++ * flag is that it is pretty near impossible to work out what the correct ++ * value is from Apple documentation - a working Mac system is needed to ++ * discover the value! ++ */ ++ if (output_gamma == PNG_DEFAULT_sRGB || ++ output_gamma == PNG_FP_1 / PNG_DEFAULT_sRGB) ++ { ++ /* If there is no sRGB support this just sets the gamma to the standard ++ * sRGB value. (This is a side effect of using this function!) ++ */ ++# ifdef PNG_READ_sRGB_SUPPORTED ++ png_ptr->flags |= PNG_FLAG_ASSUME_sRGB; ++# else ++ PNG_UNUSED(png_ptr) ++# endif ++ if (is_screen != 0) ++ output_gamma = PNG_GAMMA_sRGB; ++ else ++ output_gamma = PNG_GAMMA_sRGB_INVERSE; ++ } ++ ++ else if (output_gamma == PNG_GAMMA_MAC_18 || ++ output_gamma == PNG_FP_1 / PNG_GAMMA_MAC_18) ++ { ++ if (is_screen != 0) ++ output_gamma = PNG_GAMMA_MAC_OLD; ++ else ++ output_gamma = PNG_GAMMA_MAC_INVERSE; ++ } ++ ++ return output_gamma; ++} ++ ++# ifdef PNG_FLOATING_POINT_SUPPORTED ++static png_fixed_point ++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 ++ * means the fixed point constants work just fine with the floating point ++ * API. The alternative would just lead to undetected errors and spurious ++ * bug reports. Negative values fail inside the _fixed API unless they ++ * correspond to the flag values. ++ */ ++ if (output_gamma > 0 && output_gamma < 128) ++ output_gamma *= PNG_FP_1; ++ ++ /* This preserves -1 and -2 exactly: */ ++ output_gamma = floor(output_gamma + .5); ++ ++ if (output_gamma > PNG_FP_MAX || output_gamma < PNG_FP_MIN) ++ png_fixed_error(png_ptr, "gamma value"); ++ ++ return (png_fixed_point)output_gamma; ++} ++# endif ++#endif /* READ_ALPHA_MODE || READ_GAMMA */ ++ ++#ifdef PNG_READ_ALPHA_MODE_SUPPORTED ++void PNGFAPI ++png_set_alpha_mode_fixed(png_structrp png_ptr, int mode, ++ png_fixed_point output_gamma) ++{ ++ int compose = 0; ++ png_fixed_point file_gamma; ++ ++ png_debug(1, "in png_set_alpha_mode"); ++ ++ if (png_rtran_ok(png_ptr, 0) == 0) + return; +- png_ptr->flags |= PNG_FLAG_STRIP_ALPHA; ++ ++ output_gamma = translate_gamma_flags(png_ptr, output_gamma, 1/*screen*/); ++ ++ /* Validate the value to ensure it is in a reasonable range. The value ++ * is expected to be 1 or greater, but this range test allows for some ++ * viewing correction values. The intent is to weed out users of this API ++ * who use the inverse of the gamma value accidentally! Since some of these ++ * values are reasonable this may have to be changed: ++ * ++ * 1.6.x: changed from 0.07..3 to 0.01..100 (to accommodate the optimal 16-bit ++ * gamma of 36, and its reciprocal.) ++ */ ++ if (output_gamma < 1000 || output_gamma > 10000000) ++ png_error(png_ptr, "output gamma out of expected range"); ++ ++ /* The default file gamma is the inverse of the output gamma; the output ++ * gamma may be changed below so get the file value first: ++ */ ++ file_gamma = png_reciprocal(output_gamma); ++ ++ /* There are really 8 possibilities here, composed of any combination ++ * of: ++ * ++ * premultiply the color channels ++ * do not encode non-opaque pixels ++ * encode the alpha as well as the color channels ++ * ++ * The differences disappear if the input/output ('screen') gamma is 1.0, ++ * because then the encoding is a no-op and there is only the choice of ++ * premultiplying the color channels or not. ++ * ++ * png_set_alpha_mode and png_set_background interact because both use ++ * png_compose to do the work. Calling both is only useful when ++ * png_set_alpha_mode is used to set the default mode - PNG_ALPHA_PNG - along ++ * with a default gamma value. Otherwise PNG_COMPOSE must not be set. ++ */ ++ switch (mode) ++ { ++ case PNG_ALPHA_PNG: /* default: png standard */ ++ /* No compose, but it may be set by png_set_background! */ ++ png_ptr->transformations &= ~PNG_ENCODE_ALPHA; ++ png_ptr->flags &= ~PNG_FLAG_OPTIMIZE_ALPHA; ++ break; ++ ++ case PNG_ALPHA_ASSOCIATED: /* color channels premultiplied */ ++ compose = 1; ++ png_ptr->transformations &= ~PNG_ENCODE_ALPHA; ++ png_ptr->flags &= ~PNG_FLAG_OPTIMIZE_ALPHA; ++ /* The output is linear: */ ++ output_gamma = PNG_FP_1; ++ break; ++ ++ case PNG_ALPHA_OPTIMIZED: /* associated, non-opaque pixels linear */ ++ compose = 1; ++ png_ptr->transformations &= ~PNG_ENCODE_ALPHA; ++ png_ptr->flags |= PNG_FLAG_OPTIMIZE_ALPHA; ++ /* output_gamma records the encoding of opaque pixels! */ ++ break; ++ ++ case PNG_ALPHA_BROKEN: /* associated, non-linear, alpha encoded */ ++ compose = 1; ++ png_ptr->transformations |= PNG_ENCODE_ALPHA; ++ png_ptr->flags &= ~PNG_FLAG_OPTIMIZE_ALPHA; ++ break; ++ ++ default: ++ png_error(png_ptr, "invalid alpha mode"); ++ } ++ ++ /* Only set the default gamma if the file gamma has not been set (this has ++ * the side effect that the gamma in a second call to png_set_alpha_mode will ++ * be ignored.) ++ */ ++ 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; ++ ++ /* Finally, if pre-multiplying, set the background fields to achieve the ++ * desired result. ++ */ ++ if (compose != 0) ++ { ++ /* And obtain alpha pre-multiplication by composing on black: */ ++ 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) != 0) ++ png_error(png_ptr, ++ "conflicting calls to set alpha mode and background"); ++ ++ png_ptr->transformations |= PNG_COMPOSE; ++ } ++} ++ ++# ifdef PNG_FLOATING_POINT_SUPPORTED ++void PNGAPI ++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)); + } ++# endif + #endif + +-#ifdef PNG_READ_DITHER_SUPPORTED +-/* Dither file to 8 bit. Supply a palette, the current number ++#ifdef PNG_READ_QUANTIZE_SUPPORTED ++/* Dither file to 8-bit. Supply a palette, the current number + * of elements in the palette, the maximum number of elements + * allowed, and a histogram if possible. If the current number +- * of colors is greater then the maximum number, the palette will be +- * modified to fit in the maximum number. "full_dither" indicates +- * whether we need a dithering cube set up for RGB images, or if we ++ * of colors is greater than the maximum number, the palette will be ++ * modified to fit in the maximum number. "full_quantize" indicates ++ * whether we need a quantizing cube set up for RGB images, or if we + * simply are reducing the number of colors in a paletted image. + */ + + typedef struct png_dsort_struct + { +- struct png_dsort_struct FAR * next; ++ 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_dither(png_structp png_ptr, png_colorp palette, +- int num_palette, int maximum_colors, png_uint_16p histogram, +- int full_dither) ++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_dither"); ++ png_debug(1, "in png_set_quantize"); + +- if (png_ptr == NULL) ++ if (png_rtran_ok(png_ptr, 0) == 0) + return; +- png_ptr->transformations |= PNG_DITHER; + +- if (!full_dither) ++ png_ptr->transformations |= PNG_QUANTIZE; ++ ++ if (full_quantize == 0) + { + int i; + +- png_ptr->dither_index = (png_bytep)png_malloc(png_ptr, +- (png_uint_32)(num_palette * png_sizeof(png_byte))); ++ png_ptr->quantize_index = (png_bytep)png_malloc(png_ptr, ++ (png_alloc_size_t)((png_uint_32)num_palette * (sizeof (png_byte)))); + for (i = 0; i < num_palette; i++) +- png_ptr->dither_index[i] = (png_byte)i; ++ png_ptr->quantize_index[i] = (png_byte)i; + } + + if (num_palette > maximum_colors) +@@ -192,12 +457,12 @@ png_set_dither(png_structp png_ptr, png_colorp palette, + int i; + + /* Initialize an array to sort colors */ +- png_ptr->dither_sort = (png_bytep)png_malloc(png_ptr, +- (png_uint_32)(num_palette * png_sizeof(png_byte))); ++ png_ptr->quantize_sort = (png_bytep)png_malloc(png_ptr, ++ (png_alloc_size_t)((png_uint_32)num_palette * (sizeof (png_byte)))); + +- /* Initialize the dither_sort array */ ++ /* Initialize the quantize_sort array */ + for (i = 0; i < num_palette; i++) +- png_ptr->dither_sort[i] = (png_byte)i; ++ png_ptr->quantize_sort[i] = (png_byte)i; + + /* Find the least used palette entries by starting a + * bubble sort, and running it until we have sorted +@@ -214,23 +479,24 @@ png_set_dither(png_structp png_ptr, png_colorp palette, + done = 1; + for (j = 0; j < i; j++) + { +- if (histogram[png_ptr->dither_sort[j]] +- < histogram[png_ptr->dither_sort[j + 1]]) ++ if (histogram[png_ptr->quantize_sort[j]] ++ < histogram[png_ptr->quantize_sort[j + 1]]) + { + png_byte t; + +- t = png_ptr->dither_sort[j]; +- png_ptr->dither_sort[j] = png_ptr->dither_sort[j + 1]; +- png_ptr->dither_sort[j + 1] = t; ++ t = png_ptr->quantize_sort[j]; ++ png_ptr->quantize_sort[j] = png_ptr->quantize_sort[j + 1]; ++ png_ptr->quantize_sort[j + 1] = t; + done = 0; + } + } +- if (done) ++ ++ if (done != 0) + break; + } + + /* Swap the palette around, and set up a table, if necessary */ +- if (full_dither) ++ if (full_quantize != 0) + { + int j = num_palette; + +@@ -239,11 +505,12 @@ png_set_dither(png_structp png_ptr, png_colorp palette, + */ + for (i = 0; i < maximum_colors; i++) + { +- if ((int)png_ptr->dither_sort[i] >= maximum_colors) ++ if ((int)png_ptr->quantize_sort[i] >= maximum_colors) + { + do + j--; +- while ((int)png_ptr->dither_sort[j] >= maximum_colors); ++ while ((int)png_ptr->quantize_sort[j] >= maximum_colors); ++ + palette[i] = palette[j]; + } + } +@@ -258,32 +525,32 @@ png_set_dither(png_structp png_ptr, png_colorp palette, + for (i = 0; i < maximum_colors; i++) + { + /* Only move the colors we need to */ +- if ((int)png_ptr->dither_sort[i] >= maximum_colors) ++ if ((int)png_ptr->quantize_sort[i] >= maximum_colors) + { + png_color tmp_color; + + do + j--; +- while ((int)png_ptr->dither_sort[j] >= maximum_colors); ++ while ((int)png_ptr->quantize_sort[j] >= maximum_colors); + + tmp_color = palette[j]; + palette[j] = palette[i]; + palette[i] = tmp_color; + /* Indicate where the color went */ +- png_ptr->dither_index[j] = (png_byte)i; +- png_ptr->dither_index[i] = (png_byte)j; ++ png_ptr->quantize_index[j] = (png_byte)i; ++ png_ptr->quantize_index[i] = (png_byte)j; + } + } + + /* Find closest color for those colors we are not using */ + for (i = 0; i < num_palette; i++) + { +- if ((int)png_ptr->dither_index[i] >= maximum_colors) ++ if ((int)png_ptr->quantize_index[i] >= maximum_colors) + { + int min_d, k, min_k, d_index; + + /* Find the closest color to one we threw out */ +- d_index = png_ptr->dither_index[i]; ++ d_index = png_ptr->quantize_index[i]; + min_d = PNG_COLOR_DIST(palette[d_index], palette[0]); + for (k = 1, min_k = 0; k < maximum_colors; k++) + { +@@ -298,12 +565,12 @@ png_set_dither(png_structp png_ptr, png_colorp palette, + } + } + /* Point to closest color */ +- png_ptr->dither_index[i] = (png_byte)min_k; ++ png_ptr->quantize_index[i] = (png_byte)min_k; + } + } + } +- png_free(png_ptr, png_ptr->dither_sort); +- png_ptr->dither_sort = NULL; ++ png_free(png_ptr, png_ptr->quantize_sort); ++ png_ptr->quantize_sort = NULL; + } + else + { +@@ -325,9 +592,11 @@ png_set_dither(png_structp png_ptr, png_colorp palette, + + /* 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_alloc_size_t)((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_alloc_size_t)((png_uint_32)num_palette * ++ (sizeof (png_byte)))); + + /* Initialize the sort array */ + for (i = 0; i < num_palette; i++) +@@ -336,8 +605,8 @@ png_set_dither(png_structp png_ptr, png_colorp palette, + png_ptr->palette_to_index[i] = (png_byte)i; + } + +- hash = (png_dsortpp)png_calloc(png_ptr, (png_uint_32)(769 * +- png_sizeof(png_dsortp))); ++ hash = (png_dsortpp)png_calloc(png_ptr, (png_alloc_size_t)(769 * ++ (sizeof (png_dsortp)))); + + num_new_palette = num_palette; + +@@ -367,9 +636,11 @@ png_set_dither(png_structp png_ptr, png_colorp palette, + { + + t = (png_dsortp)png_malloc_warn(png_ptr, +- (png_uint_32)(png_sizeof(png_dsort))); ++ (png_alloc_size_t)(sizeof (png_dsort))); ++ + if (t == NULL) + break; ++ + t->next = hash[d]; + t->left = (png_byte)i; + t->right = (png_byte)j; +@@ -390,9 +661,9 @@ png_set_dither(png_structp png_ptr, png_colorp palette, + for (p = hash[i]; p; p = p->next) + { + if ((int)png_ptr->index_to_palette[p->left] +- < num_new_palette && +- (int)png_ptr->index_to_palette[p->right] +- < num_new_palette) ++ < num_new_palette && ++ (int)png_ptr->index_to_palette[p->right] ++ < num_new_palette) + { + int j, next_j; + +@@ -409,31 +680,34 @@ png_set_dither(png_structp png_ptr, png_colorp palette, + + num_new_palette--; + palette[png_ptr->index_to_palette[j]] +- = palette[num_new_palette]; +- if (!full_dither) ++ = palette[num_new_palette]; ++ if (full_quantize == 0) + { + int k; + + for (k = 0; k < num_palette; k++) + { +- if (png_ptr->dither_index[k] == +- png_ptr->index_to_palette[j]) +- png_ptr->dither_index[k] = +- png_ptr->index_to_palette[next_j]; +- if ((int)png_ptr->dither_index[k] == +- num_new_palette) +- png_ptr->dither_index[k] = +- png_ptr->index_to_palette[j]; ++ if (png_ptr->quantize_index[k] == ++ png_ptr->index_to_palette[j]) ++ png_ptr->quantize_index[k] = ++ png_ptr->index_to_palette[next_j]; ++ ++ if ((int)png_ptr->quantize_index[k] == ++ num_new_palette) ++ png_ptr->quantize_index[k] = ++ png_ptr->index_to_palette[j]; + } + } + + png_ptr->index_to_palette[png_ptr->palette_to_index +- [num_new_palette]] = png_ptr->index_to_palette[j]; ++ [num_new_palette]] = png_ptr->index_to_palette[j]; ++ + png_ptr->palette_to_index[png_ptr->index_to_palette[j]] +- = png_ptr->palette_to_index[num_new_palette]; ++ = png_ptr->palette_to_index[num_new_palette]; + + png_ptr->index_to_palette[j] = + (png_byte)num_new_palette; ++ + png_ptr->palette_to_index[num_new_palette] = + (png_byte)j; + } +@@ -475,37 +749,38 @@ png_set_dither(png_structp png_ptr, png_colorp palette, + } + png_ptr->num_palette = (png_uint_16)num_palette; + +- if (full_dither) ++ if (full_quantize != 0) + { + int i; + png_bytep distance; +- int total_bits = PNG_DITHER_RED_BITS + PNG_DITHER_GREEN_BITS + +- PNG_DITHER_BLUE_BITS; +- int num_red = (1 << PNG_DITHER_RED_BITS); +- int num_green = (1 << PNG_DITHER_GREEN_BITS); +- int num_blue = (1 << PNG_DITHER_BLUE_BITS); +- png_size_t num_entries = ((png_size_t)1 << total_bits); ++ int total_bits = PNG_QUANTIZE_RED_BITS + PNG_QUANTIZE_GREEN_BITS + ++ PNG_QUANTIZE_BLUE_BITS; ++ int num_red = (1 << PNG_QUANTIZE_RED_BITS); ++ int num_green = (1 << PNG_QUANTIZE_GREEN_BITS); ++ int num_blue = (1 << PNG_QUANTIZE_BLUE_BITS); ++ size_t num_entries = ((size_t)1 << total_bits); ++ ++ png_ptr->palette_lookup = (png_bytep)png_calloc(png_ptr, ++ (png_alloc_size_t)(num_entries * (sizeof (png_byte)))); + +- png_ptr->palette_lookup = (png_bytep )png_calloc(png_ptr, +- (png_uint_32)(num_entries * png_sizeof(png_byte))); ++ distance = (png_bytep)png_malloc(png_ptr, (png_alloc_size_t)(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)); ++ memset(distance, 0xff, num_entries * (sizeof (png_byte))); + + for (i = 0; i < num_palette; i++) + { + int ir, ig, ib; +- int r = (palette[i].red >> (8 - PNG_DITHER_RED_BITS)); +- int g = (palette[i].green >> (8 - PNG_DITHER_GREEN_BITS)); +- int b = (palette[i].blue >> (8 - PNG_DITHER_BLUE_BITS)); ++ int r = (palette[i].red >> (8 - PNG_QUANTIZE_RED_BITS)); ++ int g = (palette[i].green >> (8 - PNG_QUANTIZE_GREEN_BITS)); ++ int b = (palette[i].blue >> (8 - PNG_QUANTIZE_BLUE_BITS)); + + for (ir = 0; ir < num_red; ir++) + { + /* int dr = abs(ir - r); */ + int dr = ((ir > r) ? ir - r : r - ir); +- int index_r = (ir << (PNG_DITHER_BLUE_BITS + +- PNG_DITHER_GREEN_BITS)); ++ int index_r = (ir << (PNG_QUANTIZE_BLUE_BITS + ++ PNG_QUANTIZE_GREEN_BITS)); + + for (ig = 0; ig < num_green; ig++) + { +@@ -513,7 +788,7 @@ png_set_dither(png_structp png_ptr, png_colorp palette, + int dg = ((ig > g) ? ig - g : g - ig); + int dt = dr + dg; + int dm = ((dr > dg) ? dr : dg); +- int index_g = index_r | (ig << PNG_DITHER_BLUE_BITS); ++ int index_g = index_r | (ig << PNG_QUANTIZE_BLUE_BITS); + + for (ib = 0; ib < num_blue; ib++) + { +@@ -536,34 +811,57 @@ png_set_dither(png_structp png_ptr, png_colorp palette, + png_free(png_ptr, distance); + } + } +-#endif ++#endif /* READ_QUANTIZE */ + +-#if defined(PNG_READ_GAMMA_SUPPORTED) && defined(PNG_FLOATING_POINT_SUPPORTED) +-/* Transform the image from the file_gamma to the screen_gamma. We +- * only do transformations on images where the file_gamma and screen_gamma +- * are not close reciprocals, otherwise it slows things down slightly, and +- * also needlessly introduces small errors. +- * +- * We will turn off gamma transformation later if no semitransparent entries +- * are present in the tRNS array for palette images. We can't do it here +- * because we don't necessarily have the tRNS chunk yet. +- */ +-void PNGAPI +-png_set_gamma(png_structp png_ptr, double scrn_gamma, double file_gamma) ++#ifdef PNG_READ_GAMMA_SUPPORTED ++void PNGFAPI ++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"); ++ png_debug(1, "in png_set_gamma_fixed"); + +- if (png_ptr == NULL) ++ if (png_rtran_ok(png_ptr, 0) == 0) + return; + +- if ((fabs(scrn_gamma * file_gamma - 1.0) > PNG_GAMMA_THRESHOLD) || +- (png_ptr->color_type & PNG_COLOR_MASK_ALPHA) || +- (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)) +- png_ptr->transformations |= PNG_GAMMA; +- png_ptr->gamma = (float)file_gamma; +- png_ptr->screen_gamma = (float)scrn_gamma; ++ /* 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*/); ++ ++ /* 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 ++ * disabled in background handling. There is no evidence (so far) that this ++ * was being used; however, png_set_background itself accepted and must still ++ * 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) 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"); ++ ++ /* 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->colorspace.gamma = file_gamma; ++ png_ptr->colorspace.flags |= PNG_COLORSPACE_HAVE_GAMMA; ++ png_ptr->screen_gamma = scrn_gamma; + } +-#endif ++ ++# ifdef PNG_FLOATING_POINT_SUPPORTED ++void PNGAPI ++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 */ ++#endif /* READ_GAMMA */ + + #ifdef PNG_READ_EXPAND_SUPPORTED + /* Expand paletted images to RGB, expand grayscale images of +@@ -571,15 +869,14 @@ png_set_gamma(png_structp png_ptr, double scrn_gamma, double file_gamma) + * 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 +@@ -602,333 +899,719 @@ png_set_expand(png_structp png_ptr) + + /* 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; + } + +-#ifndef PNG_1_0_X + /* Expand grayscale images of less than 8-bit depth to 8 bits. */ + void PNGAPI +-png_set_expand_gray_1_2_4_to_8(png_structp png_ptr) ++png_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; + } +-#endif + +-#if defined(PNG_1_0_X) || defined(PNG_1_2_X) +-/* Expand grayscale images of less than 8-bit depth to 8 bits. */ +-/* Deprecated as of libpng-1.2.9 */ ++/* Expand tRNS chunks to alpha channels. */ + void PNGAPI +-png_set_gray_1_2_4_to_8(png_structp png_ptr) ++png_set_tRNS_to_alpha(png_structrp png_ptr) + { +- png_debug(1, "in png_set_gray_1_2_4_to_8"); ++ png_debug(1, "in png_set_tRNS_to_alpha"); + +- if (png_ptr == NULL) ++ if (png_rtran_ok(png_ptr, 0) == 0) + return; + + png_ptr->transformations |= (PNG_EXPAND | PNG_EXPAND_tRNS); + } +-#endif +- ++#endif /* READ_EXPAND */ + +-/* Expand tRNS chunks to alpha channels. */ ++#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_tRNS_to_alpha(png_structp png_ptr) ++png_set_expand_16(png_structrp png_ptr) + { +- png_debug(1, "in png_set_tRNS_to_alpha"); ++ png_debug(1, "in png_set_expand_16"); + +- png_ptr->transformations |= (PNG_EXPAND | PNG_EXPAND_tRNS); +- png_ptr->flags &= ~PNG_FLAG_ROW_INIT; ++ if (png_rtran_ok(png_ptr, 0) == 0) ++ return; ++ ++ png_ptr->transformations |= (PNG_EXPAND_16 | PNG_EXPAND | PNG_EXPAND_tRNS); + } +-#endif /* defined(PNG_READ_EXPAND_SUPPORTED) */ ++#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_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; +- png_ptr->flags &= ~PNG_FLAG_ROW_INIT; + } + #endif + + #ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED +-#ifdef PNG_FLOATING_POINT_SUPPORTED +-/* Convert a RGB image to a grayscale of the same width. This allows us, +- * for example, to convert a 24 bpp RGB image into an 8 bpp grayscale image. +- */ +- +-void PNGAPI +-png_set_rgb_to_gray(png_structp png_ptr, int error_action, double red, +- double green) +-{ +- int red_fixed = (int)((float)red*100000.0 + 0.5); +- int green_fixed = (int)((float)green*100000.0 + 0.5); +- if (png_ptr == NULL) +- return; +- png_set_rgb_to_gray_fixed(png_ptr, error_action, red_fixed, green_fixed); +-} +-#endif +- +-void PNGAPI +-png_set_rgb_to_gray_fixed(png_structp png_ptr, int error_action, +- png_fixed_point red, png_fixed_point green) ++void PNGFAPI ++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: png_ptr->transformations |= PNG_RGB_TO_GRAY; +- break; ++ case PNG_ERROR_ACTION_NONE: ++ png_ptr->transformations |= PNG_RGB_TO_GRAY; ++ break; ++ ++ case PNG_ERROR_ACTION_WARN: ++ png_ptr->transformations |= PNG_RGB_TO_GRAY_WARN; ++ break; + +- case 2: png_ptr->transformations |= PNG_RGB_TO_GRAY_WARN; +- break; ++ case PNG_ERROR_ACTION_ERROR: ++ png_ptr->transformations |= PNG_RGB_TO_GRAY_ERR; ++ break; + +- case 3: png_ptr->transformations |= PNG_RGB_TO_GRAY_ERR; ++ default: ++ png_error(png_ptr, "invalid error action to rgb_to_gray"); + } ++ + if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE) + #ifdef PNG_READ_EXPAND_SUPPORTED + png_ptr->transformations |= PNG_EXPAND; + #else + { +- png_warning(png_ptr, +- "Cannot do RGB_TO_GRAY without EXPAND_SUPPORTED."); +- png_ptr->transformations &= ~PNG_RGB_TO_GRAY; ++ /* 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; */ + } + #endif + { +- png_uint_16 red_int, green_int; +- if (red < 0 || green < 0) +- { +- red_int = 6968; /* .212671 * 32768 + .5 */ +- green_int = 23434; /* .715160 * 32768 + .5 */ +- } +- else if (red + green < 100000L) ++ if (red >= 0 && green >= 0 && red + green <= PNG_FP_1) + { +- red_int = (png_uint_16)(((png_uint_32)red*32768L)/100000L); +- green_int = (png_uint_16)(((png_uint_32)green*32768L)/100000L); ++ png_uint_16 red_int, green_int; ++ ++ /* 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_coefficients_set = 1; + } ++ + else + { +- png_warning(png_ptr, "ignoring out of range rgb_to_gray coefficients"); +- red_int = 6968; +- green_int = 23434; ++ if (red >= 0 && green >= 0) ++ png_app_warning(png_ptr, ++ "ignoring out of range rgb_to_gray coefficients"); ++ ++ /* 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_red_coeff = 6968; ++ png_ptr->rgb_to_gray_green_coeff = 23434; ++ /* png_ptr->rgb_to_gray_blue_coeff = 2366; */ ++ } + } +- png_ptr->rgb_to_gray_red_coeff = red_int; +- png_ptr->rgb_to_gray_green_coeff = green_int; +- png_ptr->rgb_to_gray_blue_coeff = +- (png_uint_16)(32768 - red_int - green_int); + } + } +-#endif ++ ++#ifdef PNG_FLOATING_POINT_SUPPORTED ++/* Convert a RGB image to a grayscale of the same width. This allows us, ++ * for example, to convert a 24 bpp RGB image into an 8 bpp grayscale image. ++ */ ++ ++void PNGAPI ++png_set_rgb_to_gray(png_structrp png_ptr, int error_action, double red, ++ double green) ++{ ++ 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 /* RGB_TO_GRAY */ + + #if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \ +- defined(PNG_LEGACY_SUPPORTED) || \ + defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) + void PNGAPI +-png_set_read_user_transform_fn(png_structp png_ptr, png_user_transform_ptr +- read_user_transform_fn) ++png_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; + #endif +-#ifdef PNG_LEGACY_SUPPORTED +- if (read_user_transform_fn) +- png_warning(png_ptr, +- "This version of libpng does not support user transforms"); +-#endif + } + #endif + +-/* Initialize everything needed for the read. This includes modifying +- * the palette. ++#ifdef PNG_READ_TRANSFORMS_SUPPORTED ++#ifdef PNG_READ_GAMMA_SUPPORTED ++/* In the case of gamma transformations only do transformations on images where ++ * the [file] gamma and screen_gamma are not close reciprocals, otherwise it ++ * slows things down slightly, and also needlessly introduces small errors. + */ +-void /* PRIVATE */ +-png_init_read_transformations(png_structp png_ptr) ++static int /* PRIVATE */ ++png_gamma_threshold(png_fixed_point screen_gamma, png_fixed_point file_gamma) + { +- png_debug(1, "in png_init_read_transformations"); +- +-#ifdef PNG_USELESS_TESTS_SUPPORTED +- if (png_ptr != NULL) +-#endif +- { +-#if defined(PNG_READ_BACKGROUND_SUPPORTED) || \ +- defined(PNG_READ_SHIFT_SUPPORTED) || \ +- defined(PNG_READ_GAMMA_SUPPORTED) +- int color_type = png_ptr->color_type; ++ /* PNG_GAMMA_THRESHOLD is the threshold for performing gamma ++ * correction as a difference of the overall transform from 1.0 ++ * ++ * We want to compare the threshold with s*f - 1, if we get ++ * overflow here it is because of wacky gamma values so we ++ * turn on processing anyway. ++ */ ++ png_fixed_point gtest; ++ return !png_muldiv(>est, screen_gamma, file_gamma, PNG_FP_1) || ++ png_gamma_significant(gtest); ++} + #endif + +-#if defined(PNG_READ_EXPAND_SUPPORTED) && defined(PNG_READ_BACKGROUND_SUPPORTED) ++/* Initialize everything needed for the read. This includes modifying ++ * the palette. ++ */ + +-#ifdef PNG_READ_GRAY_TO_RGB_SUPPORTED +- /* Detect gray background and attempt to enable optimization +- * for gray --> RGB case ++/* 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_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 ++ * take care to only make changes that are invariant with respect to the ++ * palette expansion, or only do them if there is no expansion. + * +- * Note: if PNG_BACKGROUND_EXPAND is set and color_type is either RGB or +- * RGB_ALPHA (in which case need_expand is superfluous anyway), the +- * background color might actually be gray yet not be flagged as such. +- * This is not a problem for the current code, which uses +- * PNG_BACKGROUND_IS_GRAY only to decide when to do the +- * png_do_gray_to_rgb() transformation. ++ * STRIP_ALPHA has already been handled in the caller (by setting num_trans ++ * to 0.) + */ +- if ((png_ptr->transformations & PNG_BACKGROUND_EXPAND) && +- !(color_type & PNG_COLOR_MASK_COLOR)) +- { +- png_ptr->mode |= PNG_BACKGROUND_IS_GRAY; +- } else if ((png_ptr->transformations & PNG_BACKGROUND) && +- !(png_ptr->transformations & PNG_BACKGROUND_EXPAND) && +- (png_ptr->transformations & PNG_GRAY_TO_RGB) && +- png_ptr->background.red == png_ptr->background.green && +- png_ptr->background.red == png_ptr->background.blue) +- { +- png_ptr->mode |= PNG_BACKGROUND_IS_GRAY; +- png_ptr->background.gray = png_ptr->background.red; +- } +-#endif ++ int input_has_alpha = 0; ++ int input_has_transparency = 0; + +- if ((png_ptr->transformations & PNG_BACKGROUND_EXPAND) && +- (png_ptr->transformations & PNG_EXPAND)) ++ if (png_ptr->num_trans > 0) + { +- if (!(color_type & PNG_COLOR_MASK_COLOR)) /* i.e., GRAY or GRAY_ALPHA */ ++ int i; ++ ++ /* Ignore if all the entries are opaque (unlikely!) */ ++ for (i=0; inum_trans; ++i) + { +- /* Expand background and tRNS chunks */ +- switch (png_ptr->bit_depth) ++ if (png_ptr->trans_alpha[i] == 255) ++ continue; ++ else if (png_ptr->trans_alpha[i] == 0) ++ input_has_transparency = 1; ++ else + { +- case 1: +- png_ptr->background.gray *= (png_uint_16)0xff; +- png_ptr->background.red = png_ptr->background.green +- = png_ptr->background.blue = png_ptr->background.gray; +- if (!(png_ptr->transformations & PNG_EXPAND_tRNS)) +- { +- png_ptr->trans_values.gray *= (png_uint_16)0xff; +- png_ptr->trans_values.red = png_ptr->trans_values.green +- = png_ptr->trans_values.blue = png_ptr->trans_values.gray; +- } +- break; ++ input_has_transparency = 1; ++ input_has_alpha = 1; ++ break; ++ } ++ } ++ } + +- case 2: +- png_ptr->background.gray *= (png_uint_16)0x55; +- png_ptr->background.red = png_ptr->background.green +- = png_ptr->background.blue = png_ptr->background.gray; +- if (!(png_ptr->transformations & PNG_EXPAND_tRNS)) +- { +- png_ptr->trans_values.gray *= (png_uint_16)0x55; +- png_ptr->trans_values.red = png_ptr->trans_values.green +- = png_ptr->trans_values.blue = png_ptr->trans_values.gray; +- } +- break; ++ /* If no alpha we can optimize. */ ++ if (input_has_alpha == 0) ++ { ++ /* Any alpha means background and associative alpha processing is ++ * 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; + +- case 4: +- png_ptr->background.gray *= (png_uint_16)0x11; +- png_ptr->background.red = png_ptr->background.green +- = png_ptr->background.blue = png_ptr->background.gray; +- if (!(png_ptr->transformations & PNG_EXPAND_tRNS)) +- { +- png_ptr->trans_values.gray *= (png_uint_16)0x11; +- png_ptr->trans_values.red = png_ptr->trans_values.green +- = png_ptr->trans_values.blue = png_ptr->trans_values.gray; +- } +- break; ++ if (input_has_transparency == 0) ++ png_ptr->transformations &= ~(PNG_COMPOSE | PNG_BACKGROUND_EXPAND); ++ } + +- case 8: ++#if defined(PNG_READ_EXPAND_SUPPORTED) && defined(PNG_READ_BACKGROUND_SUPPORTED) ++ /* png_set_background handling - deals with the complexity of whether the ++ * background color is in the file format or the screen format in the case ++ * where an 'expand' will happen. ++ */ + +- case 16: +- png_ptr->background.red = png_ptr->background.green +- = png_ptr->background.blue = png_ptr->background.gray; +- break; +- } +- } +- else if (color_type == PNG_COLOR_TYPE_PALETTE) ++ /* 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) != 0 && ++ (png_ptr->transformations & PNG_EXPAND) != 0) ++ { + { + png_ptr->background.red = +- png_ptr->palette[png_ptr->background.index].red; ++ png_ptr->palette[png_ptr->background.index].red; + png_ptr->background.green = +- png_ptr->palette[png_ptr->background.index].green; ++ png_ptr->palette[png_ptr->background.index].green; + png_ptr->background.blue = +- png_ptr->palette[png_ptr->background.index].blue; ++ 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) + { +-#ifdef PNG_READ_EXPAND_SUPPORTED +- if (!(png_ptr->transformations & PNG_EXPAND_tRNS)) +-#endif ++ 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 +- */ +- int i, istop; +- istop=(int)png_ptr->num_trans; ++ /* Invert the alpha channel (in tRNS) unless the pixels are ++ * going to be expanded, in which case leave it for later ++ */ ++ int i, istop = png_ptr->num_trans; ++ + for (i=0; itrans[i] = (png_byte)(255 - png_ptr->trans[i]); ++ png_ptr->trans_alpha[i] = (png_byte)(255 - ++ png_ptr->trans_alpha[i]); + } + } +-#endif ++#endif /* READ_INVERT_ALPHA */ ++ } ++ } /* background expand and (therefore) no alpha association. */ ++#endif /* READ_EXPAND && READ_BACKGROUND */ ++} ++ ++static void /* PRIVATE */ ++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 ++ * background and alpha mode stuff if there isn't. ++ */ ++ int input_has_alpha = (png_ptr->color_type & PNG_COLOR_MASK_ALPHA) != 0; ++ int input_has_transparency = png_ptr->num_trans > 0; ++ ++ /* If no alpha we can optimize. */ ++ if (input_has_alpha == 0) ++ { ++ /* Any alpha means background and associative alpha processing is ++ * required, however if the alpha is 0 or 1 throughout OPTIMIZE_ALPHA ++ * and ENCODE_ALPHA are irrelevant. ++ */ ++# ifdef PNG_READ_ALPHA_MODE_SUPPORTED ++ png_ptr->transformations &= ~PNG_ENCODE_ALPHA; ++ png_ptr->flags &= ~PNG_FLAG_OPTIMIZE_ALPHA; ++# endif ++ ++ if (input_has_transparency == 0) ++ png_ptr->transformations &= ~(PNG_COMPOSE | PNG_BACKGROUND_EXPAND); ++ } ++ ++#if defined(PNG_READ_EXPAND_SUPPORTED) && defined(PNG_READ_BACKGROUND_SUPPORTED) ++ /* png_set_background handling - deals with the complexity of whether the ++ * background color is in the file format or the screen format in the case ++ * where an 'expand' will happen. ++ */ ++ ++ /* 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) != 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: ++ gray *= 0xff; ++ trans_gray *= 0xff; ++ break; ++ ++ case 2: ++ gray *= 0x55; ++ trans_gray *= 0x55; ++ break; ++ ++ case 4: ++ gray *= 0x11; ++ trans_gray *= 0x11; ++ break; ++ ++ default: ++ ++ case 8: ++ /* FALLTHROUGH */ /* (Already 8 bits) */ ++ ++ case 16: ++ /* 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 /* READ_EXPAND && READ_BACKGROUND */ ++} ++ ++void /* PRIVATE */ ++png_init_read_transformations(png_structrp png_ptr) ++{ ++ png_debug(1, "in png_init_read_transformations"); ++ ++ /* This internal function is called from png_read_start_row in pngrutil.c ++ * and it is called before the 'rowbytes' calculation is done, so the code ++ * in here can change or update the transformations flags. ++ * ++ * First do updates that do not depend on the details of the PNG image data ++ * being processed. ++ */ ++ ++#ifdef PNG_READ_GAMMA_SUPPORTED ++ /* Prior to 1.5.4 these tests were performed from png_set_gamma, 1.5.4 adds ++ * png_set_alpha_mode and this is another source for a default file gamma so ++ * the test needs to be performed later - here. In addition prior to 1.5.4 ++ * the tests were repeated for the PALETTE color type here - this is no ++ * longer necessary (and doesn't seem to have been necessary before.) ++ */ ++ { ++ /* The following temporary indicates if overall gamma correction is ++ * required. ++ */ ++ int gamma_correction = 0; ++ ++ 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->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->colorspace.gamma); + } ++ ++ else if (png_ptr->screen_gamma != 0) ++ /* The converse - assume the file matches the screen, note that this ++ * perhaps undesirable default can (from 1.5.4) be changed by calling ++ * png_set_alpha_mode (even if the alpha handling mode isn't required ++ * or isn't changed from the default.) ++ */ ++ 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 ++ * are both assumed to be linear and there is no way to introduce a ++ * third gamma value other than png_set_background with 'UNIQUE', and, ++ * prior to 1.5.4 ++ */ ++ 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 ++ * composition may independently cause gamma correction because it needs ++ * linear data (e.g. if the file has a gAMA chunk but the screen gamma ++ * hasn't been specified.) In any case this flag may get turned off in ++ * the code immediately below if the transform can be handled outside the ++ * row loop. ++ */ ++ if (gamma_correction != 0) ++ png_ptr->transformations |= PNG_GAMMA; ++ ++ else ++ png_ptr->transformations &= ~PNG_GAMMA; ++ } ++#endif ++ ++ /* Certain transformations have the effect of preventing other ++ * transformations that happen afterward in png_do_read_transformations; ++ * resolve the interdependencies here. From the code of ++ * png_do_read_transformations the order is: ++ * ++ * 1) PNG_EXPAND (including PNG_EXPAND_tRNS) ++ * 2) PNG_STRIP_ALPHA (if no compose) ++ * 3) PNG_RGB_TO_GRAY ++ * 4) PNG_GRAY_TO_RGB iff !PNG_BACKGROUND_IS_GRAY ++ * 5) PNG_COMPOSE ++ * 6) PNG_GAMMA ++ * 7) PNG_STRIP_ALPHA (if compose) ++ * 8) PNG_ENCODE_ALPHA ++ * 9) PNG_SCALE_16_TO_8 ++ * 10) PNG_16_TO_8 ++ * 11) PNG_QUANTIZE (converts to palette) ++ * 12) PNG_EXPAND_16 ++ * 13) PNG_GRAY_TO_RGB iff PNG_BACKGROUND_IS_GRAY ++ * 14) PNG_INVERT_MONO ++ * 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) != 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 ++ * the alpha handling. It has the side effect negating the effect of ++ * PNG_EXPAND_tRNS too: ++ */ ++ png_ptr->transformations &= ~(PNG_BACKGROUND_EXPAND | PNG_ENCODE_ALPHA | ++ PNG_EXPAND_tRNS); ++ png_ptr->flags &= ~PNG_FLAG_OPTIMIZE_ALPHA; ++ ++ /* Kill the tRNS chunk itself too. Prior to 1.5.4 this did not happen ++ * so transparency information would remain just so long as it wasn't ++ * expanded. This produces unexpected API changes if the set of things ++ * that do PNG_EXPAND_tRNS changes (perfectly possible given the ++ * documentation - which says ask for what you want, accept what you ++ * get.) This makes the behavior consistent from 1.5.4: ++ */ ++ png_ptr->num_trans = 0; ++ } ++#endif /* STRIP_ALPHA supported, no COMPOSE */ ++ ++#ifdef PNG_READ_ALPHA_MODE_SUPPORTED ++ /* 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) == 0) ++ { ++ png_ptr->transformations &= ~PNG_ENCODE_ALPHA; ++ png_ptr->flags &= ~PNG_FLAG_OPTIMIZE_ALPHA; + } + #endif + +-#if defined(PNG_READ_BACKGROUND_SUPPORTED) && defined(PNG_READ_GAMMA_SUPPORTED) +- png_ptr->background_1 = png_ptr->background; ++#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 +-#if defined(PNG_READ_GAMMA_SUPPORTED) && defined(PNG_FLOATING_POINT_SUPPORTED) + +- if ((color_type == PNG_COLOR_TYPE_PALETTE && png_ptr->num_trans != 0) +- && (fabs(png_ptr->screen_gamma * png_ptr->gamma - 1.0) +- < PNG_GAMMA_THRESHOLD)) ++#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. ++ * ++ * Note: if PNG_BACKGROUND_EXPAND is set and color_type is either RGB or ++ * RGB_ALPHA (in which case need_expand is superfluous anyway), the ++ * background color might actually be gray yet not be flagged as such. ++ * This is not a problem for the current code, which uses ++ * PNG_BACKGROUND_IS_GRAY only to decide when to do the ++ * png_do_gray_to_rgb() transformation. ++ * ++ * TODO: this code needs to be revised to avoid the complexity and ++ * interdependencies. The color type of the background should be recorded in ++ * 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) != 0) ++ { ++ /* PNG_BACKGROUND_EXPAND: the background is in the file color space, so if ++ * the file was grayscale the background value is gray. ++ */ ++ if ((png_ptr->color_type & PNG_COLOR_MASK_COLOR) == 0) ++ png_ptr->mode |= PNG_BACKGROUND_IS_GRAY; ++ } ++ ++ 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) != 0) ++ { ++ if (png_ptr->background.red == png_ptr->background.green && ++ png_ptr->background.red == png_ptr->background.blue) ++ { ++ png_ptr->mode |= PNG_BACKGROUND_IS_GRAY; ++ png_ptr->background.gray = png_ptr->background.red; ++ } ++ } ++ } ++#endif /* 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) ++ * can be optimized inside the palette. This is particularly true of the ++ * composite (background and alpha) stuff, which can be pretty much all done ++ * in the palette even if the result is expanded to RGB or gray afterward. ++ * ++ * NOTE: this is Not Yet Implemented, the code behaves as in 1.5.1 and ++ * earlier and the palette stuff is actually handled on the first row. This ++ * leads to the reported bug that the palette returned by png_get_PLTE is not ++ * updated. ++ */ ++ if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE) ++ png_init_palette_transformations(png_ptr); ++ ++ else ++ png_init_rgb_transformations(png_ptr); ++ ++#if defined(PNG_READ_BACKGROUND_SUPPORTED) && \ ++ defined(PNG_READ_EXPAND_16_SUPPORTED) ++ 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 ++ * application will supply a 16-bit value so reduce it here. ++ * ++ * The PNG_BACKGROUND_EXPAND code above does not expand to 16 bits at ++ * present, so that case is ok (until do_expand_16 is moved.) ++ * ++ * 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_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 /* 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) + { +- int i, k; +- k=0; +- for (i=0; inum_trans; i++) +- { +- if (png_ptr->trans[i] != 0 && png_ptr->trans[i] != 0xff) +- k=1; /* Partial transparency is present */ +- } +- if (k == 0) +- png_ptr->transformations &= ~PNG_GAMMA; ++ /* 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 ++ * allows pre-multiplication of the alpha channel to be implemented as ++ * compositing on black. This is probably sub-optimal and has been done in ++ * 1.5.4 betas simply to enable external critique and testing (i.e. to ++ * implement the new API quickly, without lots of internal changes.) ++ */ + +- if ((png_ptr->transformations & (PNG_GAMMA | PNG_RGB_TO_GRAY)) && +- png_ptr->gamma != 0.0) ++#ifdef PNG_READ_GAMMA_SUPPORTED ++# ifdef PNG_READ_BACKGROUND_SUPPORTED ++ /* Includes ALPHA_MODE */ ++ png_ptr->background_1 = png_ptr->background; ++# endif ++ ++ /* This needs to change - in the palette image case a whole set of tables are ++ * built when it would be quicker to just calculate the correct value for ++ * each palette entry directly. Also, the test is too tricky - why check ++ * PNG_RGB_TO_GRAY if PNG_GAMMA is not set? The answer seems to be that ++ * PNG_GAMMA is cancelled even if the gamma is known? The test excludes the ++ * PNG_COMPOSE case, so apparently if there is no *overall* gamma correction ++ * the gamma tables will not be built even if composition is required on a ++ * gamma encoded value. ++ * ++ * In 1.5.4 this is addressed below by an additional check on the individual ++ * file gamma - if it is not 1.0 both RGB_TO_GRAY and COMPOSE need the ++ * tables. ++ */ ++ 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) != 0) ++# endif ++ )) || ((png_ptr->transformations & PNG_ENCODE_ALPHA) != 0 && ++ png_gamma_significant(png_ptr->screen_gamma) != 0)) + { +- png_build_gamma_table(png_ptr); ++ png_build_gamma_table(png_ptr, png_ptr->bit_depth); + + #ifdef PNG_READ_BACKGROUND_SUPPORTED +- if (png_ptr->transformations & PNG_BACKGROUND) ++ if ((png_ptr->transformations & PNG_COMPOSE) != 0) + { +- if (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) + { +- /* Could skip if no transparency */ ++ /* 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. ++ */ + png_color back, back_1; + png_colorp palette = png_ptr->palette; + int num_palette = png_ptr->num_palette; + int i; + if (png_ptr->background_gamma_type == PNG_BACKGROUND_GAMMA_FILE) + { ++ + back.red = png_ptr->gamma_table[png_ptr->background.red]; + back.green = png_ptr->gamma_table[png_ptr->background.green]; + back.blue = png_ptr->gamma_table[png_ptr->background.blue]; +@@ -939,76 +1622,90 @@ png_init_read_transformations(png_structp png_ptr) + } + else + { +- double g, gs; ++ png_fixed_point g, gs; + + switch (png_ptr->background_gamma_type) + { + case PNG_BACKGROUND_GAMMA_SCREEN: + g = (png_ptr->screen_gamma); +- gs = 1.0; ++ gs = PNG_FP_1; + break; + + case PNG_BACKGROUND_GAMMA_FILE: +- g = 1.0 / (png_ptr->gamma); +- gs = 1.0 / (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: +- g = 1.0 / (png_ptr->background_gamma); +- gs = 1.0 / (png_ptr->background_gamma * +- png_ptr->screen_gamma); ++ g = png_reciprocal(png_ptr->background_gamma); ++ gs = png_reciprocal2(png_ptr->background_gamma, ++ png_ptr->screen_gamma); + break; + default: +- g = 1.0; /* back_1 */ +- gs = 1.0; /* back */ ++ g = PNG_FP_1; /* back_1 */ ++ gs = PNG_FP_1; /* back */ ++ break; ++ } ++ ++ if (png_gamma_significant(gs) != 0) ++ { ++ back.red = png_gamma_8bit_correct(png_ptr->background.red, ++ gs); ++ back.green = png_gamma_8bit_correct(png_ptr->background.green, ++ gs); ++ back.blue = png_gamma_8bit_correct(png_ptr->background.blue, ++ gs); + } + +- if ( fabs(gs - 1.0) < PNG_GAMMA_THRESHOLD) ++ else + { + back.red = (png_byte)png_ptr->background.red; + back.green = (png_byte)png_ptr->background.green; + back.blue = (png_byte)png_ptr->background.blue; + } +- else ++ ++ if (png_gamma_significant(g) != 0) + { +- back.red = (png_byte)(pow( +- (double)png_ptr->background.red/255, gs) * 255.0 + .5); +- back.green = (png_byte)(pow( +- (double)png_ptr->background.green/255, gs) * 255.0 +- + .5); +- back.blue = (png_byte)(pow( +- (double)png_ptr->background.blue/255, gs) * 255.0 + .5); ++ back_1.red = png_gamma_8bit_correct(png_ptr->background.red, ++ g); ++ back_1.green = png_gamma_8bit_correct( ++ png_ptr->background.green, g); ++ back_1.blue = png_gamma_8bit_correct(png_ptr->background.blue, ++ g); + } + +- back_1.red = (png_byte)(pow( +- (double)png_ptr->background.red/255, g) * 255.0 + .5); +- back_1.green = (png_byte)(pow( +- (double)png_ptr->background.green/255, g) * 255.0 + .5); +- back_1.blue = (png_byte)(pow( +- (double)png_ptr->background.blue/255, g) * 255.0 + .5); ++ else ++ { ++ back_1.red = (png_byte)png_ptr->background.red; ++ back_1.green = (png_byte)png_ptr->background.green; ++ back_1.blue = (png_byte)png_ptr->background.blue; ++ } + } ++ + for (i = 0; i < num_palette; i++) + { +- if (i < (int)png_ptr->num_trans && png_ptr->trans[i] != 0xff) ++ if (i < (int)png_ptr->num_trans && ++ png_ptr->trans_alpha[i] != 0xff) + { +- if (png_ptr->trans[i] == 0) ++ if (png_ptr->trans_alpha[i] == 0) + { + palette[i] = back; + } +- else /* if (png_ptr->trans[i] != 0xff) */ ++ else /* if (png_ptr->trans_alpha[i] != 0xff) */ + { + png_byte v, w; + + v = png_ptr->gamma_to_1[palette[i].red]; +- png_composite(w, v, png_ptr->trans[i], back_1.red); ++ png_composite(w, v, png_ptr->trans_alpha[i], back_1.red); + palette[i].red = png_ptr->gamma_from_1[w]; + + v = png_ptr->gamma_to_1[palette[i].green]; +- png_composite(w, v, png_ptr->trans[i], back_1.green); ++ png_composite(w, v, png_ptr->trans_alpha[i], back_1.green); + palette[i].green = png_ptr->gamma_from_1[w]; + + v = png_ptr->gamma_to_1[palette[i].blue]; +- png_composite(w, v, png_ptr->trans[i], back_1.blue); ++ png_composite(w, v, png_ptr->trans_alpha[i], back_1.blue); + palette[i].blue = png_ptr->gamma_from_1[w]; + } + } +@@ -1019,84 +1716,120 @@ png_init_read_transformations(png_structp png_ptr) + palette[i].blue = png_ptr->gamma_table[palette[i].blue]; + } + } +- /* Prevent the transformations being done again, and make sure +- * that the now spurious alpha channel is stripped - the code +- * has just reduced background composition and gamma correction +- * to a simple alpha channel strip. ++ ++ /* Prevent the transformations being done again. ++ * ++ * NOTE: this is highly dubious; it removes the transformations in ++ * place. This seems inconsistent with the general treatment of the ++ * transformations elsewhere. + */ +- png_ptr->transformations &= ~PNG_BACKGROUND; +- png_ptr->transformations &= ~PNG_GAMMA; +- png_ptr->transformations |= PNG_STRIP_ALPHA; +- } ++ png_ptr->transformations &= ~(PNG_COMPOSE | PNG_GAMMA); ++ } /* color_type == PNG_COLOR_TYPE_PALETTE */ ++ + /* if (png_ptr->background_gamma_type!=PNG_BACKGROUND_GAMMA_UNKNOWN) */ +- else +- /* color_type != PNG_COLOR_TYPE_PALETTE */ ++ else /* color_type != PNG_COLOR_TYPE_PALETTE */ + { +- double m = (double)(((png_uint_32)1 << png_ptr->bit_depth) - 1); +- double g = 1.0; +- double gs = 1.0; ++ 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) + { + case PNG_BACKGROUND_GAMMA_SCREEN: +- g = (png_ptr->screen_gamma); +- gs = 1.0; ++ g = png_ptr->screen_gamma; ++ /* gs = PNG_FP_1; */ + break; + + case PNG_BACKGROUND_GAMMA_FILE: +- g = 1.0 / (png_ptr->gamma); +- gs = 1.0 / (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: +- g = 1.0 / (png_ptr->background_gamma); +- gs = 1.0 / (png_ptr->background_gamma * +- png_ptr->screen_gamma); ++ g = png_reciprocal(png_ptr->background_gamma); ++ gs = png_reciprocal2(png_ptr->background_gamma, ++ png_ptr->screen_gamma); + break; ++ ++ default: ++ png_error(png_ptr, "invalid background gamma type"); + } + +- png_ptr->background_1.gray = (png_uint_16)(pow( +- (double)png_ptr->background.gray / m, g) * m + .5); +- png_ptr->background.gray = (png_uint_16)(pow( +- (double)png_ptr->background.gray / m, gs) * m + .5); ++ 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_uint_16)(pow( +- (double)png_ptr->background.red / m, g) * m + .5); +- png_ptr->background_1.green = (png_uint_16)(pow( +- (double)png_ptr->background.green / m, g) * m + .5); +- png_ptr->background_1.blue = (png_uint_16)(pow( +- (double)png_ptr->background.blue / m, g) * m + .5); +- png_ptr->background.red = (png_uint_16)(pow( +- (double)png_ptr->background.red / m, gs) * m + .5); +- png_ptr->background.green = (png_uint_16)(pow( +- (double)png_ptr->background.green / m, gs) * m + .5); +- png_ptr->background.blue = (png_uint_16)(pow( +- (double)png_ptr->background.blue / m, gs) * m + .5); ++ 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 + { + /* GRAY, GRAY ALPHA, RGB, or RGBA with gray background */ + png_ptr->background_1.red = png_ptr->background_1.green +- = png_ptr->background_1.blue = png_ptr->background_1.gray; ++ = png_ptr->background_1.blue = png_ptr->background_1.gray; ++ + png_ptr->background.red = png_ptr->background.green +- = png_ptr->background.blue = png_ptr->background.gray; ++ = 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 (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. ++ */ + for (i = 0; i < num_palette; i++) + { + palette[i].red = png_ptr->gamma_table[palette[i].red]; +@@ -1106,16 +1839,17 @@ png_init_read_transformations(png_structp png_ptr) + + /* Done the gamma correction. */ + png_ptr->transformations &= ~PNG_GAMMA; +- } ++ } /* color_type == PALETTE && !PNG_BACKGROUND transformation */ + } + #ifdef PNG_READ_BACKGROUND_SUPPORTED + else + #endif +-#endif /* PNG_READ_GAMMA_SUPPORTED && PNG_FLOATING_POINT_SUPPORTED */ ++#endif /* READ_GAMMA */ ++ + #ifdef PNG_READ_BACKGROUND_SUPPORTED +- /* No GAMMA transformation */ +- if ((png_ptr->transformations & PNG_BACKGROUND) && +- (color_type == PNG_COLOR_TYPE_PALETTE)) ++ /* No GAMMA transformation (see the hanging else 4 lines above) */ ++ if ((png_ptr->transformations & PNG_COMPOSE) != 0 && ++ (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)) + { + int i; + int istop = (int)png_ptr->num_trans; +@@ -1128,58 +1862,74 @@ png_init_read_transformations(png_structp png_ptr) + + for (i = 0; i < istop; i++) + { +- if (png_ptr->trans[i] == 0) ++ if (png_ptr->trans_alpha[i] == 0) + { + palette[i] = back; + } +- else if (png_ptr->trans[i] != 0xff) ++ ++ else if (png_ptr->trans_alpha[i] != 0xff) + { + /* The png_composite() macro is defined in png.h */ + png_composite(palette[i].red, palette[i].red, +- png_ptr->trans[i], back.red); ++ png_ptr->trans_alpha[i], back.red); ++ + png_composite(palette[i].green, palette[i].green, +- png_ptr->trans[i], back.green); ++ png_ptr->trans_alpha[i], back.green); ++ + png_composite(palette[i].blue, palette[i].blue, +- png_ptr->trans[i], back.blue); ++ png_ptr->trans_alpha[i], back.blue); + } + } + +- /* Handled alpha, still need to strip the channel. */ +- png_ptr->transformations &= ~PNG_BACKGROUND; +- png_ptr->transformations |= PNG_STRIP_ALPHA; ++ png_ptr->transformations &= ~PNG_COMPOSE; + } +-#endif /* PNG_READ_BACKGROUND_SUPPORTED */ ++#endif /* READ_BACKGROUND */ + + #ifdef PNG_READ_SHIFT_SUPPORTED +- if ((png_ptr->transformations & PNG_SHIFT) && +- (color_type == PNG_COLOR_TYPE_PALETTE)) ++ 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 meaningful 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; ipalette[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; ipalette[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; ipalette[i].blue; ++ ++ component >>= shift; ++ png_ptr->palette[i].blue = (png_byte)component; ++ } + } +-#endif /* PNG_READ_SHIFT_SUPPORTED */ +- } +-#if !defined(PNG_READ_GAMMA_SUPPORTED) && !defined(PNG_READ_SHIFT_SUPPORTED) \ +- && !defined(PNG_READ_BACKGROUND_SUPPORTED) +- if (png_ptr) +- return; +-#endif ++#endif /* READ_SHIFT */ + } + + /* Modify the info structure to reflect the transformations. The +@@ -1187,407 +1937,223 @@ png_init_read_transformations(png_structp png_ptr) + * 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) + { +- if (png_ptr->num_trans && +- (png_ptr->transformations & PNG_EXPAND_tRNS)) ++ /* This check must match what actually happens in ++ * png_do_expand_palette; if it ever checks the tRNS chunk to see if ++ * it is all opaque we must do the same (at present it does not.) ++ */ ++ if (png_ptr->num_trans > 0) + info_ptr->color_type = PNG_COLOR_TYPE_RGB_ALPHA; ++ + else + info_ptr->color_type = PNG_COLOR_TYPE_RGB; ++ + info_ptr->bit_depth = 8; + info_ptr->num_trans = 0; ++ ++ if (png_ptr->palette == NULL) ++ png_error (png_ptr, "Palette is NULL in indexed image"); + } + else + { +- if (png_ptr->num_trans) ++ if (png_ptr->num_trans != 0) + { +- if (png_ptr->transformations & PNG_EXPAND_tRNS) +- info_ptr->color_type |= PNG_COLOR_MASK_ALPHA; ++ if ((png_ptr->transformations & PNG_EXPAND_tRNS) != 0) ++ info_ptr->color_type |= PNG_COLOR_MASK_ALPHA; + } + if (info_ptr->bit_depth < 8) + info_ptr->bit_depth = 8; ++ + info_ptr->num_trans = 0; + } + } + #endif + +-#ifdef PNG_READ_BACKGROUND_SUPPORTED +- if (png_ptr->transformations & PNG_BACKGROUND) +- { +- info_ptr->color_type &= ~PNG_COLOR_MASK_ALPHA; +- info_ptr->num_trans = 0; ++#if defined(PNG_READ_BACKGROUND_SUPPORTED) ||\ ++ defined(PNG_READ_ALPHA_MODE_SUPPORTED) ++ /* The following is almost certainly wrong unless the background value is in ++ * the screen space! ++ */ ++ if ((png_ptr->transformations & PNG_COMPOSE) != 0) + info_ptr->background = png_ptr->background; +- } + #endif + + #ifdef PNG_READ_GAMMA_SUPPORTED +- if (png_ptr->transformations & PNG_GAMMA) +- { +-#ifdef PNG_FLOATING_POINT_SUPPORTED +- info_ptr->gamma = png_ptr->gamma; +-#endif +-#ifdef PNG_FIXED_POINT_SUPPORTED +- info_ptr->int_gamma = png_ptr->int_gamma; +-#endif +- } ++ /* The following used to be conditional on PNG_GAMMA (prior to 1.5.4), ++ * 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->colorspace.gamma = png_ptr->colorspace.gamma; + #endif + +-#ifdef PNG_READ_16_TO_8_SUPPORTED +- if ((png_ptr->transformations & PNG_16_TO_8) && (info_ptr->bit_depth == 16)) +- info_ptr->bit_depth = 8; +-#endif ++ 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) != 0) ++ info_ptr->bit_depth = 8; ++# endif ++ ++# ifdef PNG_READ_STRIP_16_TO_8_SUPPORTED ++ if ((png_ptr->transformations & PNG_16_TO_8) != 0) ++ info_ptr->bit_depth = 8; ++# endif ++ ++# else ++ /* No 16-bit support: force chopping 16-bit input down to 8, in this case ++ * the app program can chose if both APIs are available by setting the ++ * correct scaling to use. ++ */ ++# ifdef PNG_READ_STRIP_16_TO_8_SUPPORTED ++ /* For compatibility with previous versions use the strip method by ++ * default. This code works because if PNG_SCALE_16_TO_8 is already ++ * set the code below will do that in preference to the chop. ++ */ ++ png_ptr->transformations |= PNG_16_TO_8; ++ info_ptr->bit_depth = 8; ++# else ++ ++# ifdef PNG_READ_SCALE_16_TO_8_SUPPORTED ++ png_ptr->transformations |= PNG_SCALE_16_TO_8; ++ info_ptr->bit_depth = 8; ++# else ++ ++ CONFIGURATION ERROR: you must enable at least one 16 to 8 method ++# endif ++# endif ++#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_DITHER_SUPPORTED +- if (png_ptr->transformations & PNG_DITHER) ++#ifdef PNG_READ_QUANTIZE_SUPPORTED ++ 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; + } + } + #endif + ++#ifdef PNG_READ_EXPAND_16_SUPPORTED ++ 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->flags & PNG_FLAG_STRIP_ALPHA) +- info_ptr->color_type &= ~PNG_COLOR_MASK_ALPHA; ++ if ((png_ptr->transformations & PNG_STRIP_ALPHA) != 0) ++ { ++ 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 */ +-#ifndef PNG_1_0_X +- if (png_ptr->transformations & PNG_ADD_ALPHA) +- info_ptr->color_type |= PNG_COLOR_MASK_ALPHA; +-#endif ++ 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 (info_ptr->bit_depth < png_ptr->user_transform_depth) ++ if ((png_ptr->transformations & PNG_USER_TRANSFORM) != 0) ++ { ++ if (png_ptr->user_transform_depth != 0) + info_ptr->bit_depth = png_ptr->user_transform_depth; +- if (info_ptr->channels < png_ptr->user_transform_channels) ++ ++ if (png_ptr->user_transform_channels != 0) + info_ptr->channels = png_ptr->user_transform_channels; +- } ++ } + #endif + + info_ptr->pixel_depth = (png_byte)(info_ptr->channels * +- info_ptr->bit_depth); ++ info_ptr->bit_depth); + + info_ptr->rowbytes = PNG_ROWBYTES(info_ptr->pixel_depth, info_ptr->width); + ++ /* Adding in 1.5.4: cache the above value in png_struct so that we can later ++ * check in png_rowbytes that the user buffer won't get overwritten. Note ++ * that the field is not always set - if png_read_update_info isn't called ++ * the application has to either not do any transforms or get the calculation ++ * right itself. ++ */ ++ 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. ++#ifdef PNG_READ_PACK_SUPPORTED ++/* Unpack pixels of 1, 2, or 4 bits per pixel into 1 byte per pixel, ++ * without changing the actual values. Thus, if you had a row with ++ * a bit depth of 1, you would end up with bytes that only contained ++ * the numbers 0 or 1. If you would rather they contain 0 and 255, use ++ * png_do_shift() after this. + */ +-void /* PRIVATE */ +-png_do_read_transformations(png_structp png_ptr) +-{ +- png_debug(1, "in png_do_read_transformations"); +- +- if (png_ptr->row_buf == NULL) +- { +-#if defined(PNG_STDIO_SUPPORTED) && !defined(_WIN32_WCE) +- char msg[50]; +- +- png_snprintf2(msg, 50, +- "NULL row buffer for row %ld, pass %d", (long)png_ptr->row_number, +- png_ptr->pass); +- png_error(png_ptr, msg); +-#else +- png_error(png_ptr, "NULL row buffer"); +-#endif +- } +-#ifdef PNG_WARN_UNINITIALIZED_ROW +- if (!(png_ptr->flags & PNG_FLAG_ROW_INIT)) +- /* Application has failed to call either png_read_start_image() +- * or png_read_update_info() after setting transforms that expand +- * pixels. This check added to libpng-1.2.19 +- */ +-#if (PNG_WARN_UNINITIALIZED_ROW==1) +- png_error(png_ptr, "Uninitialized row"); +-#else +- png_warning(png_ptr, "Uninitialized row"); +-#endif +-#endif +- +-#ifdef PNG_READ_EXPAND_SUPPORTED +- if (png_ptr->transformations & PNG_EXPAND) +- { +- if (png_ptr->row_info.color_type == PNG_COLOR_TYPE_PALETTE) +- { +- png_do_expand_palette(&(png_ptr->row_info), png_ptr->row_buf + 1, +- png_ptr->palette, png_ptr->trans, png_ptr->num_trans); +- } +- else +- { +- if (png_ptr->num_trans && +- (png_ptr->transformations & PNG_EXPAND_tRNS)) +- png_do_expand(&(png_ptr->row_info), png_ptr->row_buf + 1, +- &(png_ptr->trans_values)); +- else +- png_do_expand(&(png_ptr->row_info), png_ptr->row_buf + 1, +- NULL); +- } +- } +-#endif +- +-#ifdef PNG_READ_STRIP_ALPHA_SUPPORTED +- if (png_ptr->flags & PNG_FLAG_STRIP_ALPHA) +- png_do_strip_filler(&(png_ptr->row_info), png_ptr->row_buf + 1, +- PNG_FLAG_FILLER_AFTER | (png_ptr->flags & PNG_FLAG_STRIP_ALPHA)); +-#endif +- +-#ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED +- if (png_ptr->transformations & PNG_RGB_TO_GRAY) +- { +- int rgb_error = +- png_do_rgb_to_gray(png_ptr, &(png_ptr->row_info), +- png_ptr->row_buf + 1); +- if (rgb_error) +- { +- png_ptr->rgb_to_gray_status=1; +- if ((png_ptr->transformations & PNG_RGB_TO_GRAY) == +- PNG_RGB_TO_GRAY_WARN) +- png_warning(png_ptr, "png_do_rgb_to_gray found nongray pixel"); +- if ((png_ptr->transformations & PNG_RGB_TO_GRAY) == +- PNG_RGB_TO_GRAY_ERR) +- png_error(png_ptr, "png_do_rgb_to_gray found nongray pixel"); +- } +- } +-#endif +- +-/* From Andreas Dilger e-mail to png-implement, 26 March 1998: +- * +- * In most cases, the "simple transparency" should be done prior to doing +- * gray-to-RGB, or you will have to test 3x as many bytes to check if a +- * pixel is transparent. You would also need to make sure that the +- * transparency information is upgraded to RGB. +- * +- * To summarize, the current flow is: +- * - Gray + simple transparency -> compare 1 or 2 gray bytes and composite +- * with background "in place" if transparent, +- * convert to RGB if necessary +- * - Gray + alpha -> composite with gray background and remove alpha bytes, +- * convert to RGB if necessary +- * +- * To support RGB backgrounds for gray images we need: +- * - Gray + simple transparency -> convert to RGB + simple transparency, +- * compare 3 or 6 bytes and composite with +- * background "in place" if transparent +- * (3x compare/pixel compared to doing +- * composite with gray bkgrnd) +- * - Gray + alpha -> convert to RGB + alpha, composite with background and +- * remove alpha bytes (3x float +- * operations/pixel compared with composite +- * on gray background) +- * +- * Greg's change will do this. The reason it wasn't done before is for +- * performance, as this increases the per-pixel operations. If we would check +- * in advance if the background was gray or RGB, and position the gray-to-RGB +- * transform appropriately, then it would save a lot of work/time. +- */ +- +-#ifdef PNG_READ_GRAY_TO_RGB_SUPPORTED +- /* If gray -> RGB, do so now only if background is non-gray; else do later +- * for performance reasons +- */ +- if ((png_ptr->transformations & PNG_GRAY_TO_RGB) && +- !(png_ptr->mode & PNG_BACKGROUND_IS_GRAY)) +- png_do_gray_to_rgb(&(png_ptr->row_info), png_ptr->row_buf + 1); +-#endif +- +-#ifdef PNG_READ_BACKGROUND_SUPPORTED +- if ((png_ptr->transformations & PNG_BACKGROUND) && +- ((png_ptr->num_trans != 0 ) || +- (png_ptr->color_type & PNG_COLOR_MASK_ALPHA))) +- png_do_background(&(png_ptr->row_info), png_ptr->row_buf + 1, +- &(png_ptr->trans_values), &(png_ptr->background) +-#ifdef PNG_READ_GAMMA_SUPPORTED +- , &(png_ptr->background_1), +- png_ptr->gamma_table, png_ptr->gamma_from_1, +- png_ptr->gamma_to_1, png_ptr->gamma_16_table, +- png_ptr->gamma_16_from_1, png_ptr->gamma_16_to_1, +- png_ptr->gamma_shift +-#endif +-); +-#endif +- +-#ifdef PNG_READ_GAMMA_SUPPORTED +- if ((png_ptr->transformations & PNG_GAMMA) && +-#ifdef PNG_READ_BACKGROUND_SUPPORTED +- !((png_ptr->transformations & PNG_BACKGROUND) && +- ((png_ptr->num_trans != 0) || +- (png_ptr->color_type & PNG_COLOR_MASK_ALPHA))) && +-#endif +- (png_ptr->color_type != PNG_COLOR_TYPE_PALETTE)) +- png_do_gamma(&(png_ptr->row_info), png_ptr->row_buf + 1, +- png_ptr->gamma_table, png_ptr->gamma_16_table, +- png_ptr->gamma_shift); +-#endif +- +-#ifdef PNG_READ_16_TO_8_SUPPORTED +- if (png_ptr->transformations & PNG_16_TO_8) +- png_do_chop(&(png_ptr->row_info), png_ptr->row_buf + 1); +-#endif +- +-#ifdef PNG_READ_DITHER_SUPPORTED +- if (png_ptr->transformations & PNG_DITHER) +- { +- png_do_dither((png_row_infop)&(png_ptr->row_info), png_ptr->row_buf + 1, +- png_ptr->palette_lookup, png_ptr->dither_index); +- if (png_ptr->row_info.rowbytes == (png_uint_32)0) +- png_error(png_ptr, "png_do_dither returned rowbytes=0"); +- } +-#endif +- +-#ifdef PNG_READ_INVERT_SUPPORTED +- if (png_ptr->transformations & PNG_INVERT_MONO) +- png_do_invert(&(png_ptr->row_info), png_ptr->row_buf + 1); +-#endif +- +-#ifdef PNG_READ_SHIFT_SUPPORTED +- if (png_ptr->transformations & PNG_SHIFT) +- png_do_unshift(&(png_ptr->row_info), png_ptr->row_buf + 1, +- &(png_ptr->shift)); +-#endif +- +-#ifdef PNG_READ_PACK_SUPPORTED +- if (png_ptr->transformations & PNG_PACK) +- png_do_unpack(&(png_ptr->row_info), png_ptr->row_buf + 1); +-#endif +- +-#ifdef PNG_READ_BGR_SUPPORTED +- if (png_ptr->transformations & PNG_BGR) +- png_do_bgr(&(png_ptr->row_info), png_ptr->row_buf + 1); +-#endif +- +-#ifdef PNG_READ_PACKSWAP_SUPPORTED +- if (png_ptr->transformations & PNG_PACKSWAP) +- png_do_packswap(&(png_ptr->row_info), png_ptr->row_buf + 1); +-#endif +- +-#ifdef PNG_READ_GRAY_TO_RGB_SUPPORTED +- /* If gray -> RGB, do so now only if we did not do so above */ +- if ((png_ptr->transformations & PNG_GRAY_TO_RGB) && +- (png_ptr->mode & PNG_BACKGROUND_IS_GRAY)) +- png_do_gray_to_rgb(&(png_ptr->row_info), png_ptr->row_buf + 1); +-#endif +- +-#ifdef PNG_READ_FILLER_SUPPORTED +- if (png_ptr->transformations & PNG_FILLER) +- png_do_read_filler(&(png_ptr->row_info), png_ptr->row_buf + 1, +- (png_uint_32)png_ptr->filler, png_ptr->flags); +-#endif +- +-#ifdef PNG_READ_INVERT_ALPHA_SUPPORTED +- if (png_ptr->transformations & PNG_INVERT_ALPHA) +- png_do_read_invert_alpha(&(png_ptr->row_info), png_ptr->row_buf + 1); +-#endif +- +-#ifdef PNG_READ_SWAP_ALPHA_SUPPORTED +- if (png_ptr->transformations & PNG_SWAP_ALPHA) +- png_do_read_swap_alpha(&(png_ptr->row_info), png_ptr->row_buf + 1); +-#endif +- +-#ifdef PNG_READ_SWAP_SUPPORTED +- if (png_ptr->transformations & PNG_SWAP_BYTES) +- png_do_swap(&(png_ptr->row_info), png_ptr->row_buf + 1); +-#endif +- +-#ifdef PNG_READ_USER_TRANSFORM_SUPPORTED +- if (png_ptr->transformations & PNG_USER_TRANSFORM) +- { +- if (png_ptr->read_user_transform_fn != NULL) +- (*(png_ptr->read_user_transform_fn)) /* User read transform function */ +- (png_ptr, /* png_ptr */ +- &(png_ptr->row_info), /* row_info: */ +- /* png_uint_32 width; width of row */ +- /* png_uint_32 rowbytes; number of bytes in row */ +- /* png_byte color_type; color type of pixels */ +- /* png_byte bit_depth; bit depth of samples */ +- /* png_byte channels; number of channels (1-4) */ +- /* png_byte pixel_depth; bits per pixel (depth*channels) */ +- png_ptr->row_buf + 1); /* start of pixel data for row */ +-#ifdef PNG_USER_TRANSFORM_PTR_SUPPORTED +- if (png_ptr->user_transform_depth) +- png_ptr->row_info.bit_depth = png_ptr->user_transform_depth; +- if (png_ptr->user_transform_channels) +- png_ptr->row_info.channels = png_ptr->user_transform_channels; +-#endif +- png_ptr->row_info.pixel_depth = (png_byte)(png_ptr->row_info.bit_depth * +- png_ptr->row_info.channels); +- png_ptr->row_info.rowbytes = PNG_ROWBYTES(png_ptr->row_info.pixel_depth, +- png_ptr->row_info.width); +- } +-#endif +- +-} +- +-#ifdef PNG_READ_PACK_SUPPORTED +-/* Unpack pixels of 1, 2, or 4 bits per pixel into 1 byte per pixel, +- * without changing the actual values. Thus, if you had a row with +- * a bit depth of 1, you would end up with bytes that only contained +- * the numbers 0 or 1. If you would rather they contain 0 and 255, use +- * png_do_shift() after this. +- */ +-void /* PRIVATE */ ++static void + png_do_unpack(png_row_infop row_info, png_bytep row) + { + png_debug(1, "in png_do_unpack"); + +-#ifdef PNG_USELESS_TESTS_SUPPORTED +- if (row != NULL && row_info != NULL && row_info->bit_depth < 8) +-#else + if (row_info->bit_depth < 8) +-#endif + { + png_uint_32 i; + png_uint_32 row_width=row_info->width; +@@ -1596,17 +2162,19 @@ png_do_unpack(png_row_infop row_info, png_bytep row) + { + case 1: + { +- png_bytep sp = row + (png_size_t)((row_width - 1) >> 3); +- png_bytep dp = row + (png_size_t)row_width - 1; +- png_uint_32 shift = 7 - (int)((row_width + 7) & 0x07); ++ png_bytep sp = row + (size_t)((row_width - 1) >> 3); ++ png_bytep dp = row + (size_t)row_width - 1; ++ png_uint_32 shift = 7U - ((row_width + 7U) & 0x07); + for (i = 0; i < row_width; i++) + { + *dp = (png_byte)((*sp >> shift) & 0x01); ++ + if (shift == 7) + { + shift = 0; + sp--; + } ++ + else + shift++; + +@@ -1618,17 +2186,19 @@ png_do_unpack(png_row_infop row_info, png_bytep row) + case 2: + { + +- png_bytep sp = row + (png_size_t)((row_width - 1) >> 2); +- png_bytep dp = row + (png_size_t)row_width - 1; +- png_uint_32 shift = (int)((3 - ((row_width + 3) & 0x03)) << 1); ++ png_bytep sp = row + (size_t)((row_width - 1) >> 2); ++ png_bytep dp = row + (size_t)row_width - 1; ++ png_uint_32 shift = ((3U - ((row_width + 3U) & 0x03)) << 1); + for (i = 0; i < row_width; i++) + { + *dp = (png_byte)((*sp >> shift) & 0x03); ++ + if (shift == 6) + { + shift = 0; + sp--; + } ++ + else + shift += 2; + +@@ -1639,17 +2209,19 @@ png_do_unpack(png_row_infop row_info, png_bytep row) + + case 4: + { +- png_bytep sp = row + (png_size_t)((row_width - 1) >> 1); +- png_bytep dp = row + (png_size_t)row_width - 1; +- png_uint_32 shift = (int)((1 - ((row_width + 1) & 0x01)) << 2); ++ png_bytep sp = row + (size_t)((row_width - 1) >> 1); ++ png_bytep dp = row + (size_t)row_width - 1; ++ png_uint_32 shift = ((1U - ((row_width + 1U) & 0x01)) << 2); + for (i = 0; i < row_width; i++) + { + *dp = (png_byte)((*sp >> shift) & 0x0f); ++ + if (shift == 4) + { + shift = 0; + sp--; + } ++ + else + shift = 4; + +@@ -1657,6 +2229,9 @@ png_do_unpack(png_row_infop row_info, png_bytep row) + } + break; + } ++ ++ default: ++ break; + } + row_info->bit_depth = 8; + row_info->pixel_depth = (png_byte)(8 * row_info->channels); +@@ -1671,166 +2246,223 @@ png_do_unpack(png_row_infop row_info, png_bytep row) + * a row of bit depth 8, but only 5 are significant, this will shift + * the values back to 0 through 31. + */ +-void /* PRIVATE */ +-png_do_unshift(png_row_infop row_info, png_bytep row, png_color_8p sig_bits) ++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 ( +-#ifdef PNG_USELESS_TESTS_SUPPORTED +- row != NULL && row_info != NULL && sig_bits != NULL && +-#endif +- 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; ++ int bit_depth = row_info->bit_depth; + +- if (row_info->color_type & PNG_COLOR_MASK_COLOR) ++ 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; + +- if (!value) +- return; ++ 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; + +- switch (row_info->bit_depth) ++ else ++ have_shift = 1; ++ } ++ ++ if (have_shift == 0) ++ return; ++ } ++ ++ 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_uint_32 i; +- png_uint_32 istop = row_info->rowbytes; ++ png_bytep bp = row; ++ png_bytep bp_end = bp + row_info->rowbytes; + +- for (bp = row, i = 0; i < istop; i++) ++ 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_uint_32 i; +- png_uint_32 istop = row_info->rowbytes; +- png_byte mask = (png_byte)((((int)0xf0 >> shift[0]) & (int)0xf0) | +- (png_byte)((int)0xf >> shift[0])); ++ png_bytep bp_end = bp + row_info->rowbytes; ++ int gray_shift = shift[0]; ++ int mask = 0xf >> gray_shift; ++ ++ mask |= mask << 4; + +- for (i = 0; i < istop; i++) ++ 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; ++ png_bytep bp_end = bp + row_info->rowbytes; ++ int channel = 0; + +- for (i = 0; i < istop; i++) ++ 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; ++ png_bytep bp_end = bp + row_info->rowbytes; ++ int channel = 0; + +- for (i = 0; i < istop; i++) ++ 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); ++ *bp++ = (png_byte)value; + } + break; + } ++#endif + } + } + } + #endif + +-#ifdef PNG_READ_16_TO_8_SUPPORTED +-/* Chop rows of bit depth 16 down to 8 */ +-void /* PRIVATE */ +-png_do_chop(png_row_infop row_info, png_bytep row) ++#ifdef PNG_READ_SCALE_16_TO_8_SUPPORTED ++/* Scale rows of bit depth 16 down to 8 accurately */ ++static void ++png_do_scale_16_to_8(png_row_infop row_info, png_bytep row) + { +- png_debug(1, "in png_do_chop"); ++ png_debug(1, "in png_do_scale_16_to_8"); + +-#ifdef PNG_USELESS_TESTS_SUPPORTED +- if (row != NULL && row_info != NULL && row_info->bit_depth == 16) +-#else + if (row_info->bit_depth == 16) +-#endif + { +- png_bytep sp = row; +- png_bytep dp = row; +- png_uint_32 i; +- png_uint_32 istop = row_info->width * row_info->channels; ++ png_bytep sp = row; /* source */ ++ png_bytep dp = row; /* destination */ ++ png_bytep ep = sp + row_info->rowbytes; /* end+1 */ + +- for (i = 0; i> 8)) >> 8; +- * +- * Approximate calculation with shift/add instead of multiply/divide: +- * *dp = ((((png_uint_32)(*sp) << 8) | +- * (png_uint_32)((int)(*(sp + 1)) - *sp)) + 128) >> 8; +- * +- * What we actually do to avoid extra shifting and conversion: +- */ ++ /* The input is an array of 16-bit components, these must be scaled to ++ * 8 bits each. For a 16-bit value V the required value (from the PNG ++ * specification) is: ++ * ++ * (V * 255) / 65535 ++ * ++ * This reduces to round(V / 257), or floor((V + 128.5)/257) ++ * ++ * Represent V as the two byte value vhi.vlo. Make a guess that the ++ * result is the top byte of V, vhi, then the correction to this value ++ * is: ++ * ++ * error = floor(((V-vhi.vhi) + 128.5) / 257) ++ * = floor(((vlo-vhi) + 128.5) / 257) ++ * ++ * This can be approximated using integer arithmetic (and a signed ++ * shift): ++ * ++ * error = (vlo-vhi+128) >> 8; ++ * ++ * The approximate differs from the exact answer only when (vlo-vhi) is ++ * 128; it then gives a correction of +1 when the exact correction is ++ * 0. This gives 128 errors. The exact answer (correct for all 16-bit ++ * input values) is: ++ * ++ * error = (vlo-vhi+128)*65535 >> 24; ++ * ++ * An alternative arithmetic calculation which also gives no errors is: ++ * ++ * (V * 255 + 32895) >> 16 ++ */ + +- *dp = *sp + ((((int)(*(sp + 1)) - *sp) > 128) ? 1 : 0); +-#else +- /* Simply discard the low order byte */ +- *dp = *sp; ++ png_int_32 tmp = *sp++; /* must be signed! */ ++ tmp += (((int)*sp++ - tmp + 128) * 65535) >> 24; ++ *dp++ = (png_byte)tmp; ++ } ++ ++ row_info->bit_depth = 8; ++ row_info->pixel_depth = (png_byte)(8 * row_info->channels); ++ row_info->rowbytes = row_info->width * row_info->channels; ++ } ++} + #endif ++ ++#ifdef PNG_READ_STRIP_16_TO_8_SUPPORTED ++static void ++/* Simply discard the low byte. This was the default behavior prior ++ * to libpng-1.5.4. ++ */ ++png_do_chop(png_row_infop row_info, png_bytep row) ++{ ++ png_debug(1, "in png_do_chop"); ++ ++ if (row_info->bit_depth == 16) ++ { ++ png_bytep sp = row; /* source */ ++ png_bytep dp = row; /* destination */ ++ png_bytep ep = sp + row_info->rowbytes; /* end+1 */ ++ ++ while (sp < ep) ++ { ++ *dp++ = *sp; ++ sp += 2; /* skip low byte */ + } ++ + row_info->bit_depth = 8; + row_info->pixel_depth = (png_byte)(8 * row_info->channels); + row_info->rowbytes = row_info->width * row_info->channels; +@@ -1839,224 +2471,228 @@ png_do_chop(png_row_infop row_info, png_bytep row) + #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_uint_32 row_width = row_info->width; ++ + png_debug(1, "in png_do_read_swap_alpha"); + +-#ifdef PNG_USELESS_TESTS_SUPPORTED +- if (row != NULL && row_info != NULL) +-#endif ++ if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA) + { +- png_uint_32 row_width = row_info->width; +- if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA) ++ /* This converts from RGBA to ARGB */ ++ if (row_info->bit_depth == 8) + { +- /* This converts from RGBA to ARGB */ +- if (row_info->bit_depth == 8) +- { +- png_bytep sp = row + row_info->rowbytes; +- png_bytep dp = sp; +- png_byte save; +- png_uint_32 i; ++ png_bytep sp = row + row_info->rowbytes; ++ png_bytep dp = sp; ++ png_byte save; ++ png_uint_32 i; + +- for (i = 0; i < row_width; i++) +- { +- save = *(--sp); +- *(--dp) = *(--sp); +- *(--dp) = *(--sp); +- *(--dp) = *(--sp); +- *(--dp) = save; +- } +- } +- /* This converts from RRGGBBAA to AARRGGBB */ +- else ++ for (i = 0; i < row_width; i++) + { +- png_bytep sp = row + row_info->rowbytes; +- png_bytep dp = sp; +- png_byte save[2]; +- png_uint_32 i; ++ save = *(--sp); ++ *(--dp) = *(--sp); ++ *(--dp) = *(--sp); ++ *(--dp) = *(--sp); ++ *(--dp) = save; ++ } ++ } + +- for (i = 0; i < row_width; i++) +- { +- save[0] = *(--sp); +- save[1] = *(--sp); +- *(--dp) = *(--sp); +- *(--dp) = *(--sp); +- *(--dp) = *(--sp); +- *(--dp) = *(--sp); +- *(--dp) = *(--sp); +- *(--dp) = *(--sp); +- *(--dp) = save[0]; +- *(--dp) = save[1]; +- } ++#ifdef PNG_READ_16BIT_SUPPORTED ++ /* This converts from RRGGBBAA to AARRGGBB */ ++ else ++ { ++ png_bytep sp = row + row_info->rowbytes; ++ png_bytep dp = sp; ++ png_byte save[2]; ++ png_uint_32 i; ++ ++ for (i = 0; i < row_width; i++) ++ { ++ save[0] = *(--sp); ++ save[1] = *(--sp); ++ *(--dp) = *(--sp); ++ *(--dp) = *(--sp); ++ *(--dp) = *(--sp); ++ *(--dp) = *(--sp); ++ *(--dp) = *(--sp); ++ *(--dp) = *(--sp); ++ *(--dp) = save[0]; ++ *(--dp) = save[1]; + } + } +- else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA) ++#endif ++ } ++ ++ else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA) ++ { ++ /* This converts from GA to AG */ ++ if (row_info->bit_depth == 8) + { +- /* This converts from GA to AG */ +- if (row_info->bit_depth == 8) +- { +- png_bytep sp = row + row_info->rowbytes; +- png_bytep dp = sp; +- png_byte save; +- png_uint_32 i; ++ png_bytep sp = row + row_info->rowbytes; ++ png_bytep dp = sp; ++ png_byte save; ++ png_uint_32 i; + +- for (i = 0; i < row_width; i++) +- { +- save = *(--sp); +- *(--dp) = *(--sp); +- *(--dp) = save; +- } +- } +- /* This converts from GGAA to AAGG */ +- else ++ for (i = 0; i < row_width; i++) + { +- png_bytep sp = row + row_info->rowbytes; +- png_bytep dp = sp; +- png_byte save[2]; +- png_uint_32 i; ++ save = *(--sp); ++ *(--dp) = *(--sp); ++ *(--dp) = save; ++ } ++ } + +- for (i = 0; i < row_width; i++) +- { +- save[0] = *(--sp); +- save[1] = *(--sp); +- *(--dp) = *(--sp); +- *(--dp) = *(--sp); +- *(--dp) = save[0]; +- *(--dp) = save[1]; +- } ++#ifdef PNG_READ_16BIT_SUPPORTED ++ /* This converts from GGAA to AAGG */ ++ else ++ { ++ png_bytep sp = row + row_info->rowbytes; ++ png_bytep dp = sp; ++ png_byte save[2]; ++ png_uint_32 i; ++ ++ for (i = 0; i < row_width; i++) ++ { ++ save[0] = *(--sp); ++ save[1] = *(--sp); ++ *(--dp) = *(--sp); ++ *(--dp) = *(--sp); ++ *(--dp) = save[0]; ++ *(--dp) = save[1]; + } + } ++#endif + } + } + #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; + png_debug(1, "in png_do_read_invert_alpha"); + +-#ifdef PNG_USELESS_TESTS_SUPPORTED +- if (row != NULL && row_info != NULL) +-#endif ++ row_width = row_info->width; ++ if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA) + { +- png_uint_32 row_width = row_info->width; +- if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA) ++ if (row_info->bit_depth == 8) + { + /* This inverts the alpha channel in RGBA */ +- if (row_info->bit_depth == 8) +- { +- png_bytep sp = row + row_info->rowbytes; +- png_bytep dp = sp; +- png_uint_32 i; ++ png_bytep sp = row + row_info->rowbytes; ++ png_bytep dp = sp; ++ png_uint_32 i; + +- for (i = 0; i < row_width; i++) +- { +- *(--dp) = (png_byte)(255 - *(--sp)); ++ for (i = 0; i < row_width; i++) ++ { ++ *(--dp) = (png_byte)(255 - *(--sp)); + +-/* This does nothing: +- *(--dp) = *(--sp); +- *(--dp) = *(--sp); +- *(--dp) = *(--sp); +- We can replace it with: ++/* This does nothing: ++ *(--dp) = *(--sp); ++ *(--dp) = *(--sp); ++ *(--dp) = *(--sp); ++ We can replace it with: + */ +- sp-=3; +- dp=sp; +- } ++ sp-=3; ++ dp=sp; + } +- /* This inverts the alpha channel in RRGGBBAA */ +- else +- { +- png_bytep sp = row + row_info->rowbytes; +- png_bytep dp = sp; +- png_uint_32 i; ++ } + +- for (i = 0; i < row_width; i++) +- { +- *(--dp) = (png_byte)(255 - *(--sp)); +- *(--dp) = (png_byte)(255 - *(--sp)); ++#ifdef PNG_READ_16BIT_SUPPORTED ++ /* This inverts the alpha channel in RRGGBBAA */ ++ else ++ { ++ png_bytep sp = row + row_info->rowbytes; ++ png_bytep dp = sp; ++ png_uint_32 i; + +-/* This does nothing: +- *(--dp) = *(--sp); +- *(--dp) = *(--sp); +- *(--dp) = *(--sp); +- *(--dp) = *(--sp); +- *(--dp) = *(--sp); +- *(--dp) = *(--sp); +- We can replace it with: ++ for (i = 0; i < row_width; i++) ++ { ++ *(--dp) = (png_byte)(255 - *(--sp)); ++ *(--dp) = (png_byte)(255 - *(--sp)); ++ ++/* This does nothing: ++ *(--dp) = *(--sp); ++ *(--dp) = *(--sp); ++ *(--dp) = *(--sp); ++ *(--dp) = *(--sp); ++ *(--dp) = *(--sp); ++ *(--dp) = *(--sp); ++ We can replace it with: + */ +- sp-=6; +- dp=sp; +- } ++ sp-=6; ++ dp=sp; + } + } +- else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA) ++#endif ++ } ++ else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA) ++ { ++ if (row_info->bit_depth == 8) + { + /* This inverts the alpha channel in GA */ +- if (row_info->bit_depth == 8) +- { +- png_bytep sp = row + row_info->rowbytes; +- png_bytep dp = sp; +- png_uint_32 i; ++ png_bytep sp = row + row_info->rowbytes; ++ png_bytep dp = sp; ++ png_uint_32 i; + +- for (i = 0; i < row_width; i++) +- { +- *(--dp) = (png_byte)(255 - *(--sp)); +- *(--dp) = *(--sp); +- } ++ for (i = 0; i < row_width; i++) ++ { ++ *(--dp) = (png_byte)(255 - *(--sp)); ++ *(--dp) = *(--sp); + } ++ } ++ ++#ifdef PNG_READ_16BIT_SUPPORTED ++ else ++ { + /* This inverts the alpha channel in GGAA */ +- else +- { +- png_bytep sp = row + row_info->rowbytes; +- png_bytep dp = sp; +- png_uint_32 i; ++ png_bytep sp = row + row_info->rowbytes; ++ png_bytep dp = sp; ++ png_uint_32 i; + +- for (i = 0; i < row_width; i++) +- { +- *(--dp) = (png_byte)(255 - *(--sp)); +- *(--dp) = (png_byte)(255 - *(--sp)); ++ for (i = 0; i < row_width; i++) ++ { ++ *(--dp) = (png_byte)(255 - *(--sp)); ++ *(--dp) = (png_byte)(255 - *(--sp)); + /* +- *(--dp) = *(--sp); +- *(--dp) = *(--sp); ++ *(--dp) = *(--sp); ++ *(--dp) = *(--sp); + */ +- sp-=2; +- dp=sp; +- } ++ sp-=2; ++ dp=sp; + } + } ++#endif + } + } + #endif + + #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) ++ png_uint_32 filler, png_uint_32 flags) + { + png_uint_32 i; + png_uint_32 row_width = row_info->width; + +- png_byte hi_filler = (png_byte)((filler>>8) & 0xff); +- png_byte lo_filler = (png_byte)(filler & 0xff); ++#ifdef PNG_READ_16BIT_SUPPORTED ++ png_byte hi_filler = (png_byte)(filler>>8); ++#endif ++ png_byte lo_filler = (png_byte)filler; + + png_debug(1, "in png_do_read_filler"); + + if ( +-#ifdef PNG_USELESS_TESTS_SUPPORTED +- row != NULL && row_info != NULL && +-#endif + row_info->color_type == PNG_COLOR_TYPE_GRAY) + { + if (row_info->bit_depth == 8) + { +- /* This changes the data from G to GX */ +- if (flags & PNG_FLAG_FILLER_AFTER) ++ if ((flags & PNG_FLAG_FILLER_AFTER) != 0) + { +- png_bytep sp = row + (png_size_t)row_width; +- png_bytep dp = sp + (png_size_t)row_width; ++ /* This changes the data from G to GX */ ++ png_bytep sp = row + (size_t)row_width; ++ png_bytep dp = sp + (size_t)row_width; + for (i = 1; i < row_width; i++) + { + *(--dp) = lo_filler; +@@ -2067,11 +2703,12 @@ png_do_read_filler(png_row_infop row_info, png_bytep row, + row_info->pixel_depth = 16; + row_info->rowbytes = row_width * 2; + } +- /* This changes the data from G to XG */ ++ + else + { +- png_bytep sp = row + (png_size_t)row_width; +- png_bytep dp = sp + (png_size_t)row_width; ++ /* This changes the data from G to XG */ ++ png_bytep sp = row + (size_t)row_width; ++ png_bytep dp = sp + (size_t)row_width; + for (i = 0; i < row_width; i++) + { + *(--dp) = *(--sp); +@@ -2082,53 +2719,57 @@ png_do_read_filler(png_row_infop row_info, png_bytep row, + row_info->rowbytes = row_width * 2; + } + } ++ ++#ifdef PNG_READ_16BIT_SUPPORTED + else if (row_info->bit_depth == 16) + { +- /* This changes the data from GG to GGXX */ +- if (flags & PNG_FLAG_FILLER_AFTER) ++ if ((flags & PNG_FLAG_FILLER_AFTER) != 0) + { +- png_bytep sp = row + (png_size_t)row_width * 2; +- png_bytep dp = sp + (png_size_t)row_width * 2; ++ /* This changes the data from GG to GGXX */ ++ png_bytep sp = row + (size_t)row_width * 2; ++ png_bytep dp = sp + (size_t)row_width * 2; + for (i = 1; i < row_width; i++) + { +- *(--dp) = hi_filler; + *(--dp) = lo_filler; ++ *(--dp) = hi_filler; + *(--dp) = *(--sp); + *(--dp) = *(--sp); + } +- *(--dp) = hi_filler; + *(--dp) = lo_filler; ++ *(--dp) = hi_filler; + row_info->channels = 2; + row_info->pixel_depth = 32; + row_info->rowbytes = row_width * 4; + } +- /* This changes the data from GG to XXGG */ ++ + else + { +- png_bytep sp = row + (png_size_t)row_width * 2; +- png_bytep dp = sp + (png_size_t)row_width * 2; ++ /* This changes the data from GG to XXGG */ ++ png_bytep sp = row + (size_t)row_width * 2; ++ png_bytep dp = sp + (size_t)row_width * 2; + for (i = 0; i < row_width; i++) + { + *(--dp) = *(--sp); + *(--dp) = *(--sp); +- *(--dp) = hi_filler; + *(--dp) = lo_filler; ++ *(--dp) = hi_filler; + } + row_info->channels = 2; + row_info->pixel_depth = 32; + row_info->rowbytes = row_width * 4; + } + } ++#endif + } /* COLOR_TYPE == GRAY */ + else if (row_info->color_type == PNG_COLOR_TYPE_RGB) + { + if (row_info->bit_depth == 8) + { +- /* This changes the data from RGB to RGBX */ +- if (flags & PNG_FLAG_FILLER_AFTER) ++ if ((flags & PNG_FLAG_FILLER_AFTER) != 0) + { +- png_bytep sp = row + (png_size_t)row_width * 3; +- png_bytep dp = sp + (png_size_t)row_width; ++ /* This changes the data from RGB to RGBX */ ++ png_bytep sp = row + (size_t)row_width * 3; ++ png_bytep dp = sp + (size_t)row_width; + for (i = 1; i < row_width; i++) + { + *(--dp) = lo_filler; +@@ -2141,11 +2782,12 @@ png_do_read_filler(png_row_infop row_info, png_bytep row, + row_info->pixel_depth = 32; + row_info->rowbytes = row_width * 4; + } +- /* This changes the data from RGB to XRGB */ ++ + else + { +- png_bytep sp = row + (png_size_t)row_width * 3; +- png_bytep dp = sp + (png_size_t)row_width; ++ /* This changes the data from RGB to XRGB */ ++ png_bytep sp = row + (size_t)row_width * 3; ++ png_bytep dp = sp + (size_t)row_width; + for (i = 0; i < row_width; i++) + { + *(--dp) = *(--sp); +@@ -2158,17 +2800,19 @@ png_do_read_filler(png_row_infop row_info, png_bytep row, + row_info->rowbytes = row_width * 4; + } + } ++ ++#ifdef PNG_READ_16BIT_SUPPORTED + else if (row_info->bit_depth == 16) + { +- /* This changes the data from RRGGBB to RRGGBBXX */ +- if (flags & PNG_FLAG_FILLER_AFTER) ++ if ((flags & PNG_FLAG_FILLER_AFTER) != 0) + { +- png_bytep sp = row + (png_size_t)row_width * 6; +- png_bytep dp = sp + (png_size_t)row_width * 2; ++ /* This changes the data from RRGGBB to RRGGBBXX */ ++ png_bytep sp = row + (size_t)row_width * 6; ++ png_bytep dp = sp + (size_t)row_width * 2; + for (i = 1; i < row_width; i++) + { +- *(--dp) = hi_filler; + *(--dp) = lo_filler; ++ *(--dp) = hi_filler; + *(--dp) = *(--sp); + *(--dp) = *(--sp); + *(--dp) = *(--sp); +@@ -2176,17 +2820,18 @@ png_do_read_filler(png_row_infop row_info, png_bytep row, + *(--dp) = *(--sp); + *(--dp) = *(--sp); + } +- *(--dp) = hi_filler; + *(--dp) = lo_filler; ++ *(--dp) = hi_filler; + row_info->channels = 4; + row_info->pixel_depth = 64; + row_info->rowbytes = row_width * 8; + } +- /* This changes the data from RRGGBB to XXRRGGBB */ ++ + else + { +- png_bytep sp = row + (png_size_t)row_width * 6; +- png_bytep dp = sp + (png_size_t)row_width * 2; ++ /* This changes the data from RRGGBB to XXRRGGBB */ ++ png_bytep sp = row + (size_t)row_width * 6; ++ png_bytep dp = sp + (size_t)row_width * 2; + for (i = 0; i < row_width; i++) + { + *(--dp) = *(--sp); +@@ -2195,21 +2840,23 @@ png_do_read_filler(png_row_infop row_info, png_bytep row, + *(--dp) = *(--sp); + *(--dp) = *(--sp); + *(--dp) = *(--sp); +- *(--dp) = hi_filler; + *(--dp) = lo_filler; ++ *(--dp) = hi_filler; + } ++ + row_info->channels = 4; + row_info->pixel_depth = 64; + row_info->rowbytes = row_width * 8; + } + } ++#endif + } /* COLOR_TYPE == RGB */ + } + #endif + + #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; +@@ -2218,17 +2865,15 @@ png_do_gray_to_rgb(png_row_infop row_info, png_bytep row) + png_debug(1, "in png_do_gray_to_rgb"); + + if (row_info->bit_depth >= 8 && +-#ifdef PNG_USELESS_TESTS_SUPPORTED +- row != NULL && row_info != NULL && +-#endif +- !(row_info->color_type & PNG_COLOR_MASK_COLOR)) ++ (row_info->color_type & PNG_COLOR_MASK_COLOR) == 0) + { + if (row_info->color_type == PNG_COLOR_TYPE_GRAY) + { + if (row_info->bit_depth == 8) + { +- png_bytep sp = row + (png_size_t)row_width - 1; +- png_bytep dp = sp + (png_size_t)row_width * 2; ++ /* This changes G to RGB */ ++ png_bytep sp = row + (size_t)row_width - 1; ++ png_bytep dp = sp + (size_t)row_width * 2; + for (i = 0; i < row_width; i++) + { + *(dp--) = *sp; +@@ -2236,10 +2881,12 @@ png_do_gray_to_rgb(png_row_infop row_info, png_bytep row) + *(dp--) = *(sp--); + } + } ++ + else + { +- png_bytep sp = row + (png_size_t)row_width * 2 - 1; +- png_bytep dp = sp + (png_size_t)row_width * 4; ++ /* This changes GG to RRGGBB */ ++ png_bytep sp = row + (size_t)row_width * 2 - 1; ++ png_bytep dp = sp + (size_t)row_width * 4; + for (i = 0; i < row_width; i++) + { + *(dp--) = *sp; +@@ -2251,12 +2898,14 @@ png_do_gray_to_rgb(png_row_infop row_info, png_bytep row) + } + } + } ++ + else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA) + { + if (row_info->bit_depth == 8) + { +- png_bytep sp = row + (png_size_t)row_width * 2 - 1; +- png_bytep dp = sp + (png_size_t)row_width * 2; ++ /* This changes GA to RGBA */ ++ png_bytep sp = row + (size_t)row_width * 2 - 1; ++ png_bytep dp = sp + (size_t)row_width * 2; + for (i = 0; i < row_width; i++) + { + *(dp--) = *(sp--); +@@ -2265,10 +2914,12 @@ png_do_gray_to_rgb(png_row_infop row_info, png_bytep row) + *(dp--) = *(sp--); + } + } ++ + else + { +- png_bytep sp = row + (png_size_t)row_width * 4 - 1; +- png_bytep dp = sp + (png_size_t)row_width * 4; ++ /* This changes GGAA to RRGGBBAA */ ++ png_bytep sp = row + (size_t)row_width * 4 - 1; ++ png_bytep dp = sp + (size_t)row_width * 4; + for (i = 0; i < row_width; i++) + { + *(dp--) = *(sp--); +@@ -2282,10 +2933,10 @@ png_do_gray_to_rgb(png_row_infop row_info, png_bytep row) + } + } + } +- 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); ++ row_info->bit_depth); + row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth, row_width); + } + } +@@ -2293,831 +2944,502 @@ png_do_gray_to_rgb(png_row_infop row_info, png_bytep row) + + #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 +- * (THIS LINK IS DEAD June 2008) +- * New link: +- * ++ * using the equation given in Poynton's ColorFAQ of 1998-01-04 at ++ * (THIS LINK IS DEAD June 2008 but ++ * versions dated 1998 through November 2002 have been archived at ++ * https://web.archive.org/web/20000816232553/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 ++ * which can be expressed with integers as ++ * ++ * Y = (6969 * R + 23434 * G + 2365 * B)/32768 ++ * ++ * Poynton's current link (as of January 2003 through July 2011): ++ * ++ * has changed the numbers slightly: + * +- * Y = 0.21268 * R + 0.7151 * G + 0.07217 * B ++ * Y = 0.2126*R + 0.7152*G + 0.0722*B + * + * which can be expressed with integers as + * +- * Y = (6969 * R + 23434 * G + 2365 * B)/32768 ++ * Y = (6966 * R + 23436 * G + 2366 * B)/32768 + * +- * The calculation is to be done in a linear colorspace. ++ * 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: + * +- * Other integer coefficents can be used via png_set_rgb_to_gray(). ++ * 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 coefficients 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 ( +-#ifdef PNG_USELESS_TESTS_SUPPORTED +- row != NULL && row_info != NULL && +-#endif +- (row_info->color_type & PNG_COLOR_MASK_COLOR)) ++ if ((row_info->color_type & PNG_COLOR_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; ++ png_uint_32 bc = 32768 - rc - gc; ++ png_uint_32 row_width = row_info->width; ++ int have_alpha = (row_info->color_type & PNG_COLOR_MASK_ALPHA) != 0; + +- if (row_info->color_type == PNG_COLOR_TYPE_RGB) ++ 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_bytep sp = row; ++ png_bytep dp = row; ++ png_uint_32 i; + +- for (i = 0; i < row_width; i++) +- { +- png_byte red = png_ptr->gamma_to_1[*(sp++)]; +- png_byte green = png_ptr->gamma_to_1[*(sp++)]; +- png_byte blue = png_ptr->gamma_to_1[*(sp++)]; +- if (red != green || red != blue) +- { +- rgb_error |= 1; +- *(dp++) = png_ptr->gamma_from_1[ +- (rc*red + gc*green + bc*blue)>>15]; +- } +- else +- *(dp++) = *(sp - 1); +- } +- } +- else +-#endif ++ 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) +- { +- rgb_error |= 1; +- *(dp++) = (png_byte)((rc*red + gc*green + bc*blue)>>15); +- } +- else +- *(dp++) = *(sp - 1); +- } +- } +- } ++ png_byte red = *(sp++); ++ png_byte green = *(sp++); ++ png_byte blue = *(sp++); + +- else /* RGB bit_depth == 16 */ +- { +-#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) +- if (png_ptr->gamma_16_to_1 != NULL && +- png_ptr->gamma_16_from_1 != NULL) +- { +- png_bytep sp = row; +- png_bytep dp = row; +- for (i = 0; i < row_width; i++) ++ if (red != green || red != blue) + { +- png_uint_16 red, green, blue, w; ++ red = png_ptr->gamma_to_1[red]; ++ green = png_ptr->gamma_to_1[green]; ++ blue = png_ptr->gamma_to_1[blue]; + +- 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; ++ rgb_error |= 1; ++ *(dp++) = png_ptr->gamma_from_1[ ++ (rc*red + gc*green + bc*blue + 16384)>>15]; ++ } + +- 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; +- } ++ 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++) = (png_byte)((w>>8) & 0xff); +- *(dp++) = (png_byte)(w & 0xff); ++ *(dp++) = red; + } ++ ++ if (have_alpha != 0) ++ *(dp++) = *(sp++); + } +- else ++ } ++ else + #endif ++ { ++ 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_uint_16 red, green, blue, gray16; ++ rgb_error |= 1; ++ /* NOTE: this is the historical approach which simply ++ * truncates the results. ++ */ ++ *(dp++) = (png_byte)((rc*red + gc*green + bc*blue)>>15); ++ } + +- 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; ++ else ++ *(dp++) = red; + +- 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 (have_alpha != 0) ++ *(dp++) = *(sp++); + } + } + } +- if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA) ++ ++ else /* RGB bit_depth == 16 */ + { +- if (row_info->bit_depth == 8) ++#ifdef PNG_READ_GAMMA_SUPPORTED ++ if (png_ptr->gamma_16_to_1 != NULL && png_ptr->gamma_16_from_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_uint_16 red, green, blue, w; ++ png_byte hi,lo; ++ ++ hi=*(sp)++; lo=*(sp)++; red = (png_uint_16)((hi << 8) | (lo)); ++ hi=*(sp)++; lo=*(sp)++; green = (png_uint_16)((hi << 8) | (lo)); ++ hi=*(sp)++; lo=*(sp)++; blue = (png_uint_16)((hi << 8) | (lo)); ++ ++ 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]; +- *(dp++) = *(sp++); /* alpha */ ++ if (png_ptr->gamma_16_table != NULL) ++ w = png_ptr->gamma_16_table[(red & 0xff) ++ >> png_ptr->gamma_shift][red >> 8]; ++ ++ else ++ 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); +- *(dp++) = *(sp++); /* alpha */ ++ 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; + } +- } +- } +- 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++) = (png_byte)((w>>8) & 0xff); +- *(dp++) = (png_byte)(w & 0xff); +- *(dp++) = *(sp++); /* alpha */ ++ if (have_alpha != 0) ++ { ++ *(dp++) = *(sp++); + *(dp++) = *(sp++); + } + } +- else ++ } ++ else + #endif ++ { ++ 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; ++ png_byte hi,lo; ++ ++ hi=*(sp)++; lo=*(sp)++; red = (png_uint_16)((hi << 8) | (lo)); ++ hi=*(sp)++; lo=*(sp)++; green = (png_uint_16)((hi << 8) | (lo)); ++ hi=*(sp)++; lo=*(sp)++; blue = (png_uint_16)((hi << 8) | (lo)); ++ ++ 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, 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++); + *(dp++) = *(sp++); + } + } + } + } +- row_info->channels -= (png_byte)2; +- row_info->color_type &= ~PNG_COLOR_MASK_COLOR; ++ ++ 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 * +- row_info->bit_depth); ++ row_info->bit_depth); + row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth, row_width); + } + return rgb_error; + } + #endif + +-/* Build a grayscale palette. Palette is assumed to be 1 << bit_depth +- * large of png_color. This lets grayscale images be treated as +- * paletted. Most useful for gamma correction and simplification +- * of code. ++#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 PNGAPI +-png_build_grayscale_palette(int bit_depth, png_colorp palette) ++static void ++png_do_compose(png_row_infop row_info, png_bytep row, png_structrp png_ptr) + { +- int num_palette; +- int color_inc; +- int i; +- int v; +- +- png_debug(1, "in png_do_build_grayscale_palette"); +- +- if (palette == NULL) +- return; ++#ifdef PNG_READ_GAMMA_SUPPORTED ++ png_const_bytep gamma_table = png_ptr->gamma_table; ++ png_const_bytep gamma_from_1 = png_ptr->gamma_from_1; ++ png_const_bytep gamma_to_1 = png_ptr->gamma_to_1; ++ png_const_uint_16pp gamma_16 = png_ptr->gamma_16_table; ++ 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 + +- 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; +- } +-} ++ png_bytep sp; ++ png_uint_32 i; ++ png_uint_32 row_width = row_info->width; ++ int shift; + +-/* This function is currently unused. Do we really need it? */ +-#if defined(PNG_READ_DITHER_SUPPORTED) && \ +- defined(PNG_CORRECT_PALETTE_SUPPORTED) +-void /* PRIVATE */ +-png_correct_palette(png_structp png_ptr, png_colorp palette, +- int num_palette) +-{ +- png_debug(1, "in png_correct_palette"); ++ png_debug(1, "in png_do_compose"); + +-#if defined(PNG_READ_BACKGROUND_SUPPORTED) && \ +- defined(PNG_READ_GAMMA_SUPPORTED) && \ +- defined(PNG_FLOATING_POINT_SUPPORTED) +- if (png_ptr->transformations & (PNG_GAMMA | PNG_BACKGROUND)) ++ switch (row_info->color_type) + { +- png_color back, back_1; +- +- if (png_ptr->background_gamma_type == PNG_BACKGROUND_GAMMA_FILE) +- { +- back.red = png_ptr->gamma_table[png_ptr->background.red]; +- back.green = png_ptr->gamma_table[png_ptr->background.green]; +- back.blue = png_ptr->gamma_table[png_ptr->background.blue]; +- +- back_1.red = png_ptr->gamma_to_1[png_ptr->background.red]; +- back_1.green = png_ptr->gamma_to_1[png_ptr->background.green]; +- back_1.blue = png_ptr->gamma_to_1[png_ptr->background.blue]; +- } +- else +- { +- double g; +- +- g = 1.0 / (png_ptr->background_gamma * png_ptr->screen_gamma); +- +- if (png_ptr->background_gamma_type == PNG_BACKGROUND_GAMMA_SCREEN +- || fabs(g - 1.0) < PNG_GAMMA_THRESHOLD) +- { +- back.red = png_ptr->background.red; +- back.green = png_ptr->background.green; +- back.blue = png_ptr->background.blue; +- } +- else +- { +- back.red = +- (png_byte)(pow((double)png_ptr->background.red/255, g) * +- 255.0 + 0.5); +- back.green = +- (png_byte)(pow((double)png_ptr->background.green/255, g) * +- 255.0 + 0.5); +- back.blue = +- (png_byte)(pow((double)png_ptr->background.blue/255, g) * +- 255.0 + 0.5); +- } +- +- g = 1.0 / png_ptr->background_gamma; +- +- back_1.red = +- (png_byte)(pow((double)png_ptr->background.red/255, g) * +- 255.0 + 0.5); +- back_1.green = +- (png_byte)(pow((double)png_ptr->background.green/255, g) * +- 255.0 + 0.5); +- back_1.blue = +- (png_byte)(pow((double)png_ptr->background.blue/255, g) * +- 255.0 + 0.5); +- } +- +- if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE) ++ case PNG_COLOR_TYPE_GRAY: + { +- png_uint_32 i; +- +- for (i = 0; i < (png_uint_32)num_palette; i++) ++ switch (row_info->bit_depth) + { +- if (i < png_ptr->num_trans && png_ptr->trans[i] == 0) +- { +- palette[i] = back; +- } +- else if (i < png_ptr->num_trans && png_ptr->trans[i] != 0xff) ++ case 1: + { +- png_byte v, w; +- +- v = png_ptr->gamma_to_1[png_ptr->palette[i].red]; +- png_composite(w, v, png_ptr->trans[i], back_1.red); +- palette[i].red = png_ptr->gamma_from_1[w]; ++ sp = row; ++ shift = 7; ++ for (i = 0; i < row_width; i++) ++ { ++ if ((png_uint_16)((*sp >> shift) & 0x01) ++ == png_ptr->trans_color.gray) ++ { ++ unsigned int tmp = *sp & (0x7f7f >> (7 - shift)); ++ tmp |= ++ (unsigned int)(png_ptr->background.gray << shift); ++ *sp = (png_byte)(tmp & 0xff); ++ } + +- v = png_ptr->gamma_to_1[png_ptr->palette[i].green]; +- png_composite(w, v, png_ptr->trans[i], back_1.green); +- palette[i].green = png_ptr->gamma_from_1[w]; ++ if (shift == 0) ++ { ++ shift = 7; ++ sp++; ++ } + +- v = png_ptr->gamma_to_1[png_ptr->palette[i].blue]; +- png_composite(w, v, png_ptr->trans[i], back_1.blue); +- palette[i].blue = png_ptr->gamma_from_1[w]; +- } +- else +- { +- palette[i].red = png_ptr->gamma_table[palette[i].red]; +- palette[i].green = png_ptr->gamma_table[palette[i].green]; +- palette[i].blue = png_ptr->gamma_table[palette[i].blue]; ++ else ++ shift--; ++ } ++ break; + } +- } +- } +- else +- { +- int i; + +- for (i = 0; i < num_palette; i++) +- { +- if (palette[i].red == (png_byte)png_ptr->trans_values.gray) +- { +- palette[i] = back; +- } +- else ++ case 2: + { +- palette[i].red = png_ptr->gamma_table[palette[i].red]; +- palette[i].green = png_ptr->gamma_table[palette[i].green]; +- palette[i].blue = png_ptr->gamma_table[palette[i].blue]; +- } +- } +- } +- } +- else +-#endif + #ifdef PNG_READ_GAMMA_SUPPORTED +- if (png_ptr->transformations & PNG_GAMMA) +- { +- int i; +- +- for (i = 0; i < num_palette; i++) +- { +- palette[i].red = png_ptr->gamma_table[palette[i].red]; +- palette[i].green = png_ptr->gamma_table[palette[i].green]; +- palette[i].blue = png_ptr->gamma_table[palette[i].blue]; +- } +- } +-#ifdef PNG_READ_BACKGROUND_SUPPORTED +- else +-#endif +-#endif +-#ifdef PNG_READ_BACKGROUND_SUPPORTED +- if (png_ptr->transformations & PNG_BACKGROUND) +- { +- if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE) +- { +- png_color back; +- +- back.red = (png_byte)png_ptr->background.red; +- back.green = (png_byte)png_ptr->background.green; +- back.blue = (png_byte)png_ptr->background.blue; +- +- for (i = 0; i < (int)png_ptr->num_trans; i++) +- { +- if (png_ptr->trans[i] == 0) +- { +- palette[i].red = back.red; +- palette[i].green = back.green; +- palette[i].blue = back.blue; +- } +- else if (png_ptr->trans[i] != 0xff) +- { +- png_composite(palette[i].red, png_ptr->palette[i].red, +- png_ptr->trans[i], back.red); +- png_composite(palette[i].green, png_ptr->palette[i].green, +- png_ptr->trans[i], back.green); +- png_composite(palette[i].blue, png_ptr->palette[i].blue, +- png_ptr->trans[i], back.blue); +- } +- } +- } +- else /* Assume grayscale palette (what else could it be?) */ +- { +- int i; +- +- for (i = 0; i < num_palette; i++) +- { +- if (i == (png_byte)png_ptr->trans_values.gray) +- { +- palette[i].red = (png_byte)png_ptr->background.red; +- palette[i].green = (png_byte)png_ptr->background.green; +- palette[i].blue = (png_byte)png_ptr->background.blue; +- } +- } +- } +- } +-#endif +-} +-#endif +- +-#ifdef PNG_READ_BACKGROUND_SUPPORTED +-/* Replace any alpha or transparency with the supplied background color. +- * "background" is already in the screen gamma, while "background_1" is +- * at a gamma of 1.0. Paletted files have already been taken care of. +- */ +-void /* PRIVATE */ +-png_do_background(png_row_infop row_info, png_bytep row, +- png_color_16p trans_values, png_color_16p background +-#ifdef PNG_READ_GAMMA_SUPPORTED +- , png_color_16p background_1, +- png_bytep gamma_table, png_bytep gamma_from_1, png_bytep gamma_to_1, +- png_uint_16pp gamma_16, png_uint_16pp gamma_16_from_1, +- png_uint_16pp gamma_16_to_1, int gamma_shift +-#endif +- ) +-{ +- png_bytep sp, dp; +- png_uint_32 i; +- png_uint_32 row_width=row_info->width; +- int shift; +- +- png_debug(1, "in png_do_background"); +- +- if (background != NULL && +-#ifdef PNG_USELESS_TESTS_SUPPORTED +- row != NULL && row_info != NULL && +-#endif +- (!(row_info->color_type & PNG_COLOR_MASK_ALPHA) || +- (row_info->color_type != PNG_COLOR_TYPE_PALETTE && trans_values))) +- { +- switch (row_info->color_type) +- { +- case PNG_COLOR_TYPE_GRAY: +- { +- switch (row_info->bit_depth) +- { +- case 1: ++ if (gamma_table != NULL) + { + sp = row; +- shift = 7; ++ shift = 6; + for (i = 0; i < row_width; i++) + { +- if ((png_uint_16)((*sp >> shift) & 0x01) +- == trans_values->gray) ++ if ((png_uint_16)((*sp >> shift) & 0x03) ++ == png_ptr->trans_color.gray) + { +- *sp &= (png_byte)((0x7f7f >> (7 - shift)) & 0xff); +- *sp |= (png_byte)(background->gray << shift); ++ unsigned int tmp = *sp & (0x3f3f >> (6 - shift)); ++ tmp |= ++ (unsigned int)png_ptr->background.gray << shift; ++ *sp = (png_byte)(tmp & 0xff); + } +- if (!shift) ++ ++ else ++ { ++ 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 |= (unsigned int)(g << shift); ++ *sp = (png_byte)(tmp & 0xff); ++ } ++ ++ if (shift == 0) + { +- shift = 7; ++ shift = 6; + sp++; + } ++ + else +- shift--; ++ shift -= 2; + } +- break; + } + +- case 2: ++ else ++#endif + { +-#ifdef PNG_READ_GAMMA_SUPPORTED +- if (gamma_table != NULL) ++ sp = row; ++ shift = 6; ++ for (i = 0; i < row_width; i++) + { +- sp = row; +- shift = 6; +- for (i = 0; i < row_width; i++) ++ if ((png_uint_16)((*sp >> shift) & 0x03) ++ == png_ptr->trans_color.gray) + { +- if ((png_uint_16)((*sp >> shift) & 0x03) +- == trans_values->gray) +- { +- *sp &= (png_byte)((0x3f3f >> (6 - shift)) & 0xff); +- *sp |= (png_byte)(background->gray << shift); +- } +- else +- { +- png_byte p = (png_byte)((*sp >> shift) & 0x03); +- png_byte g = (png_byte)((gamma_table [p | (p << 2) | +- (p << 4) | (p << 6)] >> 6) & 0x03); +- *sp &= (png_byte)((0x3f3f >> (6 - shift)) & 0xff); +- *sp |= (png_byte)(g << shift); +- } +- if (!shift) +- { +- shift = 6; +- sp++; +- } +- else +- shift -= 2; ++ unsigned int tmp = *sp & (0x3f3f >> (6 - shift)); ++ tmp |= ++ (unsigned int)png_ptr->background.gray << shift; ++ *sp = (png_byte)(tmp & 0xff); + } +- } +- else +-#endif +- { +- sp = row; +- shift = 6; +- for (i = 0; i < row_width; i++) ++ ++ if (shift == 0) + { +- if ((png_uint_16)((*sp >> shift) & 0x03) +- == trans_values->gray) +- { +- *sp &= (png_byte)((0x3f3f >> (6 - shift)) & 0xff); +- *sp |= (png_byte)(background->gray << shift); +- } +- if (!shift) +- { +- shift = 6; +- sp++; +- } +- else +- shift -= 2; ++ shift = 6; ++ sp++; + } ++ ++ else ++ shift -= 2; + } +- break; + } ++ break; ++ } + +- case 4: +- { ++ case 4: ++ { + #ifdef PNG_READ_GAMMA_SUPPORTED +- if (gamma_table != NULL) +- { +- sp = row; +- shift = 4; +- for (i = 0; i < row_width; i++) +- { +- if ((png_uint_16)((*sp >> shift) & 0x0f) +- == trans_values->gray) +- { +- *sp &= (png_byte)((0xf0f >> (4 - shift)) & 0xff); +- *sp |= (png_byte)(background->gray << shift); +- } +- else +- { +- png_byte p = (png_byte)((*sp >> shift) & 0x0f); +- png_byte g = (png_byte)((gamma_table[p | +- (p << 4)] >> 4) & 0x0f); +- *sp &= (png_byte)((0xf0f >> (4 - shift)) & 0xff); +- *sp |= (png_byte)(g << shift); +- } +- if (!shift) +- { +- shift = 4; +- sp++; +- } +- else +- shift -= 4; +- } +- } +- else +-#endif ++ if (gamma_table != NULL) ++ { ++ sp = row; ++ shift = 4; ++ for (i = 0; i < row_width; i++) + { +- sp = row; +- shift = 4; +- for (i = 0; i < row_width; i++) ++ if ((png_uint_16)((*sp >> shift) & 0x0f) ++ == png_ptr->trans_color.gray) + { +- if ((png_uint_16)((*sp >> shift) & 0x0f) +- == trans_values->gray) +- { +- *sp &= (png_byte)((0xf0f >> (4 - shift)) & 0xff); +- *sp |= (png_byte)(background->gray << shift); +- } +- if (!shift) +- { +- shift = 4; +- sp++; +- } +- else +- shift -= 4; ++ unsigned int tmp = *sp & (0x0f0f >> (4 - shift)); ++ tmp |= ++ (unsigned int)(png_ptr->background.gray << shift); ++ *sp = (png_byte)(tmp & 0xff); + } +- } +- break; +- } + +- case 8: +- { +-#ifdef PNG_READ_GAMMA_SUPPORTED +- if (gamma_table != NULL) +- { +- sp = row; +- for (i = 0; i < row_width; i++, sp++) ++ else + { +- if (*sp == trans_values->gray) +- { +- *sp = (png_byte)background->gray; +- } +- else +- { +- *sp = gamma_table[*sp]; +- } ++ unsigned int p = (*sp >> shift) & 0x0f; ++ unsigned int g = (gamma_table[p | (p << 4)] >> 4) & ++ 0x0f; ++ unsigned int tmp = *sp & (0x0f0f >> (4 - shift)); ++ tmp |= (unsigned int)(g << shift); ++ *sp = (png_byte)(tmp & 0xff); + } +- } +- else +-#endif +- { +- sp = row; +- for (i = 0; i < row_width; i++, sp++) ++ ++ if (shift == 0) + { +- if (*sp == trans_values->gray) +- { +- *sp = (png_byte)background->gray; +- } ++ shift = 4; ++ sp++; + } ++ ++ else ++ shift -= 4; + } +- break; + } + +- case 16: ++ else ++#endif + { +-#ifdef PNG_READ_GAMMA_SUPPORTED +- if (gamma_16 != NULL) ++ sp = row; ++ shift = 4; ++ for (i = 0; i < row_width; i++) + { +- sp = row; +- for (i = 0; i < row_width; i++, sp += 2) ++ if ((png_uint_16)((*sp >> shift) & 0x0f) ++ == png_ptr->trans_color.gray) + { +- png_uint_16 v; +- +- v = (png_uint_16)(((*sp) << 8) + *(sp + 1)); +- if (v == trans_values->gray) +- { +- /* Background is already in screen gamma */ +- *sp = (png_byte)((background->gray >> 8) & 0xff); +- *(sp + 1) = (png_byte)(background->gray & 0xff); +- } +- else +- { +- v = gamma_16[*(sp + 1) >> gamma_shift][*sp]; +- *sp = (png_byte)((v >> 8) & 0xff); +- *(sp + 1) = (png_byte)(v & 0xff); +- } ++ unsigned int tmp = *sp & (0x0f0f >> (4 - shift)); ++ tmp |= ++ (unsigned int)(png_ptr->background.gray << shift); ++ *sp = (png_byte)(tmp & 0xff); + } +- } +- else +-#endif +- { +- sp = row; +- for (i = 0; i < row_width; i++, sp += 2) +- { +- png_uint_16 v; + +- v = (png_uint_16)(((*sp) << 8) + *(sp + 1)); +- if (v == trans_values->gray) +- { +- *sp = (png_byte)((background->gray >> 8) & 0xff); +- *(sp + 1) = (png_byte)(background->gray & 0xff); +- } ++ if (shift == 0) ++ { ++ shift = 4; ++ sp++; + } ++ ++ else ++ shift -= 4; + } +- break; + } ++ break; + } +- break; +- } + +- case PNG_COLOR_TYPE_RGB: +- { +- if (row_info->bit_depth == 8) ++ case 8: + { + #ifdef PNG_READ_GAMMA_SUPPORTED + if (gamma_table != NULL) + { + sp = row; +- for (i = 0; i < row_width; i++, sp += 3) ++ for (i = 0; i < row_width; i++, sp++) + { +- if (*sp == trans_values->red && +- *(sp + 1) == trans_values->green && +- *(sp + 2) == trans_values->blue) +- { +- *sp = (png_byte)background->red; +- *(sp + 1) = (png_byte)background->green; +- *(sp + 2) = (png_byte)background->blue; +- } ++ if (*sp == png_ptr->trans_color.gray) ++ *sp = (png_byte)png_ptr->background.gray; ++ + else +- { + *sp = gamma_table[*sp]; +- *(sp + 1) = gamma_table[*(sp + 1)]; +- *(sp + 2) = gamma_table[*(sp + 2)]; +- } + } + } + else + #endif + { + sp = row; +- for (i = 0; i < row_width; i++, sp += 3) ++ for (i = 0; i < row_width; i++, sp++) + { +- if (*sp == trans_values->red && +- *(sp + 1) == trans_values->green && +- *(sp + 2) == trans_values->blue) +- { +- *sp = (png_byte)background->red; +- *(sp + 1) = (png_byte)background->green; +- *(sp + 2) = (png_byte)background->blue; +- } ++ if (*sp == png_ptr->trans_color.gray) ++ *sp = (png_byte)png_ptr->background.gray; + } + } ++ break; + } +- else /* if (row_info->bit_depth == 16) */ ++ ++ case 16: + { + #ifdef PNG_READ_GAMMA_SUPPORTED + if (gamma_16 != NULL) + { + sp = row; +- for (i = 0; i < row_width; i++, sp += 6) ++ for (i = 0; i < row_width; i++, sp += 2) + { +- png_uint_16 r = (png_uint_16)(((*sp) << 8) + *(sp + 1)); +- png_uint_16 g = (png_uint_16)(((*(sp+2)) << 8) + *(sp+3)); +- png_uint_16 b = (png_uint_16)(((*(sp+4)) << 8) + *(sp+5)); +- if (r == trans_values->red && g == trans_values->green && +- b == trans_values->blue) ++ png_uint_16 v; ++ ++ v = (png_uint_16)(((*sp) << 8) + *(sp + 1)); ++ ++ if (v == png_ptr->trans_color.gray) + { + /* Background is already in screen gamma */ +- *sp = (png_byte)((background->red >> 8) & 0xff); +- *(sp + 1) = (png_byte)(background->red & 0xff); +- *(sp + 2) = (png_byte)((background->green >> 8) & 0xff); +- *(sp + 3) = (png_byte)(background->green & 0xff); +- *(sp + 4) = (png_byte)((background->blue >> 8) & 0xff); +- *(sp + 5) = (png_byte)(background->blue & 0xff); ++ *sp = (png_byte)((png_ptr->background.gray >> 8) ++ & 0xff); ++ *(sp + 1) = (png_byte)(png_ptr->background.gray ++ & 0xff); + } ++ + else + { +- png_uint_16 v = gamma_16[*(sp + 1) >> gamma_shift][*sp]; ++ v = gamma_16[*(sp + 1) >> gamma_shift][*sp]; + *sp = (png_byte)((v >> 8) & 0xff); + *(sp + 1) = (png_byte)(v & 0xff); +- v = gamma_16[*(sp + 3) >> gamma_shift][*(sp + 2)]; +- *(sp + 2) = (png_byte)((v >> 8) & 0xff); +- *(sp + 3) = (png_byte)(v & 0xff); +- v = gamma_16[*(sp + 5) >> gamma_shift][*(sp + 4)]; +- *(sp + 4) = (png_byte)((v >> 8) & 0xff); +- *(sp + 5) = (png_byte)(v & 0xff); + } + } + } +@@ -3125,364 +3447,491 @@ png_do_background(png_row_infop row_info, png_bytep row, + #endif + { + sp = row; +- for (i = 0; i < row_width; i++, sp += 6) ++ for (i = 0; i < row_width; i++, sp += 2) + { +- png_uint_16 r = (png_uint_16)(((*sp) << 8) + *(sp+1)); +- png_uint_16 g = (png_uint_16)(((*(sp+2)) << 8) + *(sp+3)); +- png_uint_16 b = (png_uint_16)(((*(sp+4)) << 8) + *(sp+5)); ++ png_uint_16 v; ++ ++ v = (png_uint_16)(((*sp) << 8) + *(sp + 1)); + +- if (r == trans_values->red && g == trans_values->green && +- b == trans_values->blue) ++ if (v == png_ptr->trans_color.gray) + { +- *sp = (png_byte)((background->red >> 8) & 0xff); +- *(sp + 1) = (png_byte)(background->red & 0xff); +- *(sp + 2) = (png_byte)((background->green >> 8) & 0xff); +- *(sp + 3) = (png_byte)(background->green & 0xff); +- *(sp + 4) = (png_byte)((background->blue >> 8) & 0xff); +- *(sp + 5) = (png_byte)(background->blue & 0xff); ++ *sp = (png_byte)((png_ptr->background.gray >> 8) ++ & 0xff); ++ *(sp + 1) = (png_byte)(png_ptr->background.gray ++ & 0xff); + } + } + } ++ break; + } +- break; ++ ++ default: ++ break; + } ++ break; ++ } + +- case PNG_COLOR_TYPE_GRAY_ALPHA: ++ case PNG_COLOR_TYPE_RGB: ++ { ++ if (row_info->bit_depth == 8) + { +- if (row_info->bit_depth == 8) ++#ifdef PNG_READ_GAMMA_SUPPORTED ++ if (gamma_table != NULL) + { ++ sp = row; ++ for (i = 0; i < row_width; i++, sp += 3) ++ { ++ if (*sp == png_ptr->trans_color.red && ++ *(sp + 1) == png_ptr->trans_color.green && ++ *(sp + 2) == png_ptr->trans_color.blue) ++ { ++ *sp = (png_byte)png_ptr->background.red; ++ *(sp + 1) = (png_byte)png_ptr->background.green; ++ *(sp + 2) = (png_byte)png_ptr->background.blue; ++ } ++ ++ else ++ { ++ *sp = gamma_table[*sp]; ++ *(sp + 1) = gamma_table[*(sp + 1)]; ++ *(sp + 2) = gamma_table[*(sp + 2)]; ++ } ++ } ++ } ++ else ++#endif ++ { ++ sp = row; ++ for (i = 0; i < row_width; i++, sp += 3) ++ { ++ if (*sp == png_ptr->trans_color.red && ++ *(sp + 1) == png_ptr->trans_color.green && ++ *(sp + 2) == png_ptr->trans_color.blue) ++ { ++ *sp = (png_byte)png_ptr->background.red; ++ *(sp + 1) = (png_byte)png_ptr->background.green; ++ *(sp + 2) = (png_byte)png_ptr->background.blue; ++ } ++ } ++ } ++ } ++ else /* if (row_info->bit_depth == 16) */ ++ { + #ifdef PNG_READ_GAMMA_SUPPORTED +- if (gamma_to_1 != NULL && gamma_from_1 != NULL && +- gamma_table != NULL) ++ if (gamma_16 != NULL) ++ { ++ sp = row; ++ for (i = 0; i < row_width; i++, sp += 6) + { +- sp = row; +- dp = row; +- for (i = 0; i < row_width; i++, sp += 2, dp++) ++ png_uint_16 r = (png_uint_16)(((*sp) << 8) + *(sp + 1)); ++ ++ png_uint_16 g = (png_uint_16)(((*(sp + 2)) << 8) ++ + *(sp + 3)); ++ ++ png_uint_16 b = (png_uint_16)(((*(sp + 4)) << 8) ++ + *(sp + 5)); ++ ++ if (r == png_ptr->trans_color.red && ++ g == png_ptr->trans_color.green && ++ b == png_ptr->trans_color.blue) + { +- png_uint_16 a = *(sp + 1); ++ /* 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 + 5) = (png_byte)(png_ptr->background.blue & 0xff); ++ } + +- if (a == 0xff) +- { +- *dp = gamma_table[*sp]; +- } +- else if (a == 0) +- { +- /* Background is already in screen gamma */ +- *dp = (png_byte)background->gray; +- } +- else +- { +- png_byte v, w; ++ else ++ { ++ png_uint_16 v = gamma_16[*(sp + 1) >> gamma_shift][*sp]; ++ *sp = (png_byte)((v >> 8) & 0xff); ++ *(sp + 1) = (png_byte)(v & 0xff); + +- v = gamma_to_1[*sp]; +- png_composite(w, v, a, background_1->gray); +- *dp = gamma_from_1[w]; +- } ++ v = gamma_16[*(sp + 3) >> gamma_shift][*(sp + 2)]; ++ *(sp + 2) = (png_byte)((v >> 8) & 0xff); ++ *(sp + 3) = (png_byte)(v & 0xff); ++ ++ v = gamma_16[*(sp + 5) >> gamma_shift][*(sp + 4)]; ++ *(sp + 4) = (png_byte)((v >> 8) & 0xff); ++ *(sp + 5) = (png_byte)(v & 0xff); + } + } +- else ++ } ++ ++ else + #endif ++ { ++ sp = row; ++ for (i = 0; i < row_width; i++, sp += 6) + { +- sp = row; +- dp = row; +- for (i = 0; i < row_width; i++, sp += 2, dp++) ++ png_uint_16 r = (png_uint_16)(((*sp) << 8) + *(sp + 1)); ++ ++ png_uint_16 g = (png_uint_16)(((*(sp + 2)) << 8) ++ + *(sp + 3)); ++ ++ png_uint_16 b = (png_uint_16)(((*(sp + 4)) << 8) ++ + *(sp + 5)); ++ ++ if (r == png_ptr->trans_color.red && ++ g == png_ptr->trans_color.green && ++ b == png_ptr->trans_color.blue) + { +- png_byte a = *(sp + 1); ++ *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 + 5) = (png_byte)(png_ptr->background.blue & 0xff); ++ } ++ } ++ } ++ } ++ break; ++ } + +- if (a == 0xff) +- { +- *dp = *sp; +- } ++ case PNG_COLOR_TYPE_GRAY_ALPHA: ++ { ++ if (row_info->bit_depth == 8) ++ { + #ifdef PNG_READ_GAMMA_SUPPORTED +- else if (a == 0) +- { +- *dp = (png_byte)background->gray; +- } +- else +- { +- png_composite(*dp, *sp, a, background_1->gray); +- } +-#else +- *dp = (png_byte)background->gray; +-#endif ++ if (gamma_to_1 != NULL && gamma_from_1 != NULL && ++ gamma_table != NULL) ++ { ++ sp = row; ++ for (i = 0; i < row_width; i++, sp += 2) ++ { ++ png_uint_16 a = *(sp + 1); ++ ++ if (a == 0xff) ++ *sp = gamma_table[*sp]; ++ ++ else if (a == 0) ++ { ++ /* Background is already in screen gamma */ ++ *sp = (png_byte)png_ptr->background.gray; ++ } ++ ++ else ++ { ++ png_byte v, w; ++ ++ v = gamma_to_1[*sp]; ++ png_composite(w, v, a, png_ptr->background_1.gray); ++ if (optimize == 0) ++ w = gamma_from_1[w]; ++ *sp = w; + } + } + } +- else /* if (png_ptr->bit_depth == 16) */ ++ else ++#endif + { ++ sp = row; ++ for (i = 0; i < row_width; i++, sp += 2) ++ { ++ png_byte a = *(sp + 1); ++ ++ if (a == 0) ++ *sp = (png_byte)png_ptr->background.gray; ++ ++ else if (a < 0xff) ++ png_composite(*sp, *sp, a, png_ptr->background.gray); ++ } ++ } ++ } ++ else /* if (png_ptr->bit_depth == 16) */ ++ { + #ifdef PNG_READ_GAMMA_SUPPORTED +- if (gamma_16 != NULL && gamma_16_from_1 != NULL && +- gamma_16_to_1 != NULL) ++ if (gamma_16 != NULL && gamma_16_from_1 != NULL && ++ gamma_16_to_1 != NULL) ++ { ++ sp = row; ++ for (i = 0; i < row_width; i++, sp += 4) + { +- sp = row; +- dp = row; +- for (i = 0; i < row_width; i++, sp += 4, dp += 2) ++ png_uint_16 a = (png_uint_16)(((*(sp + 2)) << 8) ++ + *(sp + 3)); ++ ++ if (a == (png_uint_16)0xffff) + { +- png_uint_16 a = (png_uint_16)(((*(sp+2)) << 8) + *(sp+3)); ++ png_uint_16 v; + +- if (a == (png_uint_16)0xffff) +- { +- png_uint_16 v; ++ v = gamma_16[*(sp + 1) >> gamma_shift][*sp]; ++ *sp = (png_byte)((v >> 8) & 0xff); ++ *(sp + 1) = (png_byte)(v & 0xff); ++ } + +- v = gamma_16[*(sp + 1) >> gamma_shift][*sp]; +- *dp = (png_byte)((v >> 8) & 0xff); +- *(dp + 1) = (png_byte)(v & 0xff); +- } +-#ifdef PNG_READ_GAMMA_SUPPORTED +- else if (a == 0) +-#else +- else +-#endif +- { +- /* Background is already in screen gamma */ +- *dp = (png_byte)((background->gray >> 8) & 0xff); +- *(dp + 1) = (png_byte)(background->gray & 0xff); +- } +-#ifdef PNG_READ_GAMMA_SUPPORTED +- else +- { +- png_uint_16 g, v, w; ++ else if (a == 0) ++ { ++ /* Background is already in screen gamma */ ++ *sp = (png_byte)((png_ptr->background.gray >> 8) ++ & 0xff); ++ *(sp + 1) = (png_byte)(png_ptr->background.gray & 0xff); ++ } + +- g = gamma_16_to_1[*(sp + 1) >> gamma_shift][*sp]; +- png_composite_16(v, g, a, background_1->gray); +- w = gamma_16_from_1[(v&0xff) >> gamma_shift][v >> 8]; +- *dp = (png_byte)((w >> 8) & 0xff); +- *(dp + 1) = (png_byte)(w & 0xff); +- } +-#endif ++ else ++ { ++ png_uint_16 g, v, w; ++ ++ g = gamma_16_to_1[*(sp + 1) >> gamma_shift][*sp]; ++ png_composite_16(v, g, a, png_ptr->background_1.gray); ++ if (optimize != 0) ++ w = v; ++ else ++ w = gamma_16_from_1[(v & 0xff) >> ++ gamma_shift][v >> 8]; ++ *sp = (png_byte)((w >> 8) & 0xff); ++ *(sp + 1) = (png_byte)(w & 0xff); + } + } +- else ++ } ++ else + #endif ++ { ++ sp = row; ++ for (i = 0; i < row_width; i++, sp += 4) + { +- sp = row; +- dp = row; +- for (i = 0; i < row_width; i++, sp += 4, dp += 2) ++ png_uint_16 a = (png_uint_16)(((*(sp + 2)) << 8) ++ + *(sp + 3)); ++ ++ if (a == 0) + { +- png_uint_16 a = (png_uint_16)(((*(sp+2)) << 8) + *(sp+3)); +- if (a == (png_uint_16)0xffff) +- { +- png_memcpy(dp, sp, 2); +- } +-#ifdef PNG_READ_GAMMA_SUPPORTED +- else if (a == 0) +-#else +- else +-#endif +- { +- *dp = (png_byte)((background->gray >> 8) & 0xff); +- *(dp + 1) = (png_byte)(background->gray & 0xff); +- } +-#ifdef PNG_READ_GAMMA_SUPPORTED +- else +- { +- png_uint_16 g, v; ++ *sp = (png_byte)((png_ptr->background.gray >> 8) ++ & 0xff); ++ *(sp + 1) = (png_byte)(png_ptr->background.gray & 0xff); ++ } + +- g = (png_uint_16)(((*sp) << 8) + *(sp + 1)); +- png_composite_16(v, g, a, background_1->gray); +- *dp = (png_byte)((v >> 8) & 0xff); +- *(dp + 1) = (png_byte)(v & 0xff); +- } +-#endif ++ else if (a < 0xffff) ++ { ++ png_uint_16 g, v; ++ ++ g = (png_uint_16)(((*sp) << 8) + *(sp + 1)); ++ png_composite_16(v, g, a, png_ptr->background.gray); ++ *sp = (png_byte)((v >> 8) & 0xff); ++ *(sp + 1) = (png_byte)(v & 0xff); + } + } + } +- break; + } ++ break; ++ } + +- case PNG_COLOR_TYPE_RGB_ALPHA: ++ case PNG_COLOR_TYPE_RGB_ALPHA: ++ { ++ if (row_info->bit_depth == 8) + { +- if (row_info->bit_depth == 8) +- { + #ifdef PNG_READ_GAMMA_SUPPORTED +- if (gamma_to_1 != NULL && gamma_from_1 != NULL && +- gamma_table != NULL) ++ if (gamma_to_1 != NULL && gamma_from_1 != NULL && ++ gamma_table != NULL) ++ { ++ sp = row; ++ for (i = 0; i < row_width; i++, sp += 4) + { +- sp = row; +- dp = row; +- for (i = 0; i < row_width; i++, sp += 4, dp += 3) ++ png_byte a = *(sp + 3); ++ ++ if (a == 0xff) + { +- png_byte a = *(sp + 3); ++ *sp = gamma_table[*sp]; ++ *(sp + 1) = gamma_table[*(sp + 1)]; ++ *(sp + 2) = gamma_table[*(sp + 2)]; ++ } + +- if (a == 0xff) +- { +- *dp = gamma_table[*sp]; +- *(dp + 1) = gamma_table[*(sp + 1)]; +- *(dp + 2) = gamma_table[*(sp + 2)]; +- } +- else if (a == 0) +- { +- /* Background is already in screen gamma */ +- *dp = (png_byte)background->red; +- *(dp + 1) = (png_byte)background->green; +- *(dp + 2) = (png_byte)background->blue; +- } +- else +- { +- png_byte v, w; +- +- v = gamma_to_1[*sp]; +- png_composite(w, v, a, background_1->red); +- *dp = gamma_from_1[w]; +- v = gamma_to_1[*(sp + 1)]; +- png_composite(w, v, a, background_1->green); +- *(dp + 1) = gamma_from_1[w]; +- v = gamma_to_1[*(sp + 2)]; +- png_composite(w, v, a, background_1->blue); +- *(dp + 2) = gamma_from_1[w]; +- } ++ else if (a == 0) ++ { ++ /* Background is already in screen gamma */ ++ *sp = (png_byte)png_ptr->background.red; ++ *(sp + 1) = (png_byte)png_ptr->background.green; ++ *(sp + 2) = (png_byte)png_ptr->background.blue; ++ } ++ ++ else ++ { ++ png_byte v, w; ++ ++ v = gamma_to_1[*sp]; ++ png_composite(w, v, a, png_ptr->background_1.red); ++ 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 == 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 == 0) w = gamma_from_1[w]; ++ *(sp + 2) = w; + } + } +- else ++ } ++ else + #endif ++ { ++ sp = row; ++ for (i = 0; i < row_width; i++, sp += 4) + { +- sp = row; +- dp = row; +- for (i = 0; i < row_width; i++, sp += 4, dp += 3) ++ png_byte a = *(sp + 3); ++ ++ if (a == 0) + { +- png_byte a = *(sp + 3); ++ *sp = (png_byte)png_ptr->background.red; ++ *(sp + 1) = (png_byte)png_ptr->background.green; ++ *(sp + 2) = (png_byte)png_ptr->background.blue; ++ } + +- if (a == 0xff) +- { +- *dp = *sp; +- *(dp + 1) = *(sp + 1); +- *(dp + 2) = *(sp + 2); +- } +- else if (a == 0) +- { +- *dp = (png_byte)background->red; +- *(dp + 1) = (png_byte)background->green; +- *(dp + 2) = (png_byte)background->blue; +- } +- else +- { +- png_composite(*dp, *sp, a, background->red); +- png_composite(*(dp + 1), *(sp + 1), a, +- background->green); +- png_composite(*(dp + 2), *(sp + 2), a, +- background->blue); +- } ++ else if (a < 0xff) ++ { ++ png_composite(*sp, *sp, a, png_ptr->background.red); ++ ++ png_composite(*(sp + 1), *(sp + 1), a, ++ png_ptr->background.green); ++ ++ png_composite(*(sp + 2), *(sp + 2), a, ++ png_ptr->background.blue); + } + } + } +- else /* if (row_info->bit_depth == 16) */ +- { ++ } ++ else /* if (row_info->bit_depth == 16) */ ++ { + #ifdef PNG_READ_GAMMA_SUPPORTED +- if (gamma_16 != NULL && gamma_16_from_1 != NULL && +- gamma_16_to_1 != NULL) ++ if (gamma_16 != NULL && gamma_16_from_1 != NULL && ++ gamma_16_to_1 != NULL) ++ { ++ sp = row; ++ for (i = 0; i < row_width; i++, sp += 8) + { +- sp = row; +- dp = row; +- for (i = 0; i < row_width; i++, sp += 8, dp += 6) ++ png_uint_16 a = (png_uint_16)(((png_uint_16)(*(sp + 6)) ++ << 8) + (png_uint_16)(*(sp + 7))); ++ ++ if (a == (png_uint_16)0xffff) + { +- png_uint_16 a = (png_uint_16)(((png_uint_16)(*(sp + 6)) +- << 8) + (png_uint_16)(*(sp + 7))); +- if (a == (png_uint_16)0xffff) +- { +- png_uint_16 v; ++ png_uint_16 v; + +- v = gamma_16[*(sp + 1) >> gamma_shift][*sp]; +- *dp = (png_byte)((v >> 8) & 0xff); +- *(dp + 1) = (png_byte)(v & 0xff); +- v = gamma_16[*(sp + 3) >> gamma_shift][*(sp + 2)]; +- *(dp + 2) = (png_byte)((v >> 8) & 0xff); +- *(dp + 3) = (png_byte)(v & 0xff); +- v = gamma_16[*(sp + 5) >> gamma_shift][*(sp + 4)]; +- *(dp + 4) = (png_byte)((v >> 8) & 0xff); +- *(dp + 5) = (png_byte)(v & 0xff); +- } +- else if (a == 0) +- { +- /* Background is already in screen gamma */ +- *dp = (png_byte)((background->red >> 8) & 0xff); +- *(dp + 1) = (png_byte)(background->red & 0xff); +- *(dp + 2) = (png_byte)((background->green >> 8) & 0xff); +- *(dp + 3) = (png_byte)(background->green & 0xff); +- *(dp + 4) = (png_byte)((background->blue >> 8) & 0xff); +- *(dp + 5) = (png_byte)(background->blue & 0xff); +- } +- else +- { +- png_uint_16 v, w, x; +- +- v = gamma_16_to_1[*(sp + 1) >> gamma_shift][*sp]; +- png_composite_16(w, v, a, background_1->red); +- x = gamma_16_from_1[((w&0xff) >> gamma_shift)][w >> 8]; +- *dp = (png_byte)((x >> 8) & 0xff); +- *(dp + 1) = (png_byte)(x & 0xff); +- v = gamma_16_to_1[*(sp + 3) >> gamma_shift][*(sp + 2)]; +- png_composite_16(w, v, a, background_1->green); +- x = gamma_16_from_1[((w&0xff) >> gamma_shift)][w >> 8]; +- *(dp + 2) = (png_byte)((x >> 8) & 0xff); +- *(dp + 3) = (png_byte)(x & 0xff); +- v = gamma_16_to_1[*(sp + 5) >> gamma_shift][*(sp + 4)]; +- png_composite_16(w, v, a, background_1->blue); +- x = gamma_16_from_1[(w & 0xff) >> gamma_shift][w >> 8]; +- *(dp + 4) = (png_byte)((x >> 8) & 0xff); +- *(dp + 5) = (png_byte)(x & 0xff); +- } ++ v = gamma_16[*(sp + 1) >> gamma_shift][*sp]; ++ *sp = (png_byte)((v >> 8) & 0xff); ++ *(sp + 1) = (png_byte)(v & 0xff); ++ ++ v = gamma_16[*(sp + 3) >> gamma_shift][*(sp + 2)]; ++ *(sp + 2) = (png_byte)((v >> 8) & 0xff); ++ *(sp + 3) = (png_byte)(v & 0xff); ++ ++ v = gamma_16[*(sp + 5) >> gamma_shift][*(sp + 4)]; ++ *(sp + 4) = (png_byte)((v >> 8) & 0xff); ++ *(sp + 5) = (png_byte)(v & 0xff); ++ } ++ ++ else if (a == 0) ++ { ++ /* 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 + 5) = (png_byte)(png_ptr->background.blue & 0xff); ++ } ++ ++ else ++ { ++ png_uint_16 v, w; ++ ++ v = gamma_16_to_1[*(sp + 1) >> gamma_shift][*sp]; ++ png_composite_16(w, v, a, png_ptr->background_1.red); ++ 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 == 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 == 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); + } + } +- else ++ } ++ ++ else + #endif ++ { ++ sp = row; ++ for (i = 0; i < row_width; i++, sp += 8) + { +- sp = row; +- dp = row; +- for (i = 0; i < row_width; i++, sp += 8, dp += 6) ++ png_uint_16 a = (png_uint_16)(((png_uint_16)(*(sp + 6)) ++ << 8) + (png_uint_16)(*(sp + 7))); ++ ++ if (a == 0) + { +- png_uint_16 a = (png_uint_16)(((png_uint_16)(*(sp + 6)) +- << 8) + (png_uint_16)(*(sp + 7))); +- if (a == (png_uint_16)0xffff) +- { +- png_memcpy(dp, sp, 6); +- } +- else if (a == 0) +- { +- *dp = (png_byte)((background->red >> 8) & 0xff); +- *(dp + 1) = (png_byte)(background->red & 0xff); +- *(dp + 2) = (png_byte)((background->green >> 8) & 0xff); +- *(dp + 3) = (png_byte)(background->green & 0xff); +- *(dp + 4) = (png_byte)((background->blue >> 8) & 0xff); +- *(dp + 5) = (png_byte)(background->blue & 0xff); +- } +- else +- { +- png_uint_16 v; +- +- png_uint_16 r = (png_uint_16)(((*sp) << 8) + *(sp + 1)); +- png_uint_16 g = (png_uint_16)(((*(sp + 2)) << 8) +- + *(sp + 3)); +- png_uint_16 b = (png_uint_16)(((*(sp + 4)) << 8) +- + *(sp + 5)); +- +- png_composite_16(v, r, a, background->red); +- *dp = (png_byte)((v >> 8) & 0xff); +- *(dp + 1) = (png_byte)(v & 0xff); +- png_composite_16(v, g, a, background->green); +- *(dp + 2) = (png_byte)((v >> 8) & 0xff); +- *(dp + 3) = (png_byte)(v & 0xff); +- png_composite_16(v, b, a, background->blue); +- *(dp + 4) = (png_byte)((v >> 8) & 0xff); +- *(dp + 5) = (png_byte)(v & 0xff); +- } ++ *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 + 5) = (png_byte)(png_ptr->background.blue & 0xff); ++ } ++ ++ else if (a < 0xffff) ++ { ++ png_uint_16 v; ++ ++ png_uint_16 r = (png_uint_16)(((*sp) << 8) + *(sp + 1)); ++ png_uint_16 g = (png_uint_16)(((*(sp + 2)) << 8) ++ + *(sp + 3)); ++ png_uint_16 b = (png_uint_16)(((*(sp + 4)) << 8) ++ + *(sp + 5)); ++ ++ png_composite_16(v, r, a, png_ptr->background.red); ++ *sp = (png_byte)((v >> 8) & 0xff); ++ *(sp + 1) = (png_byte)(v & 0xff); ++ ++ png_composite_16(v, g, a, png_ptr->background.green); ++ *(sp + 2) = (png_byte)((v >> 8) & 0xff); ++ *(sp + 3) = (png_byte)(v & 0xff); ++ ++ png_composite_16(v, b, a, png_ptr->background.blue); ++ *(sp + 4) = (png_byte)((v >> 8) & 0xff); ++ *(sp + 5) = (png_byte)(v & 0xff); + } + } + } +- break; + } ++ break; + } + +- if (row_info->color_type & PNG_COLOR_MASK_ALPHA) +- { +- row_info->color_type &= ~PNG_COLOR_MASK_ALPHA; +- row_info->channels--; +- row_info->pixel_depth = (png_byte)(row_info->channels * +- row_info->bit_depth); +- row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth, row_width); +- } ++ default: ++ break; + } + } +-#endif ++#endif /* READ_BACKGROUND || READ_ALPHA_MODE */ + + #ifdef PNG_READ_GAMMA_SUPPORTED + /* Gamma correct the image, avoiding the alpha channel. Make sure +@@ -3491,23 +3940,21 @@ png_do_background(png_row_infop row_info, png_bytep row, + * is 16, use gamma_16_table and gamma_shift. Build these with + * build_gamma_table(). + */ +-void /* PRIVATE */ +-png_do_gamma(png_row_infop row_info, png_bytep row, +- png_bytep gamma_table, png_uint_16pp gamma_16_table, +- int gamma_shift) ++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; ++ int gamma_shift = png_ptr->gamma_shift; ++ + png_bytep sp; + png_uint_32 i; + png_uint_32 row_width=row_info->width; + + png_debug(1, "in png_do_gamma"); + +- if ( +-#ifdef PNG_USELESS_TESTS_SUPPORTED +- row != NULL && row_info != NULL && +-#endif +- ((row_info->bit_depth <= 8 && gamma_table != NULL) || +- (row_info->bit_depth == 16 && gamma_16_table != NULL))) ++ if (((row_info->bit_depth <= 8 && gamma_table != NULL) || ++ (row_info->bit_depth == 16 && gamma_16_table != NULL))) + { + switch (row_info->color_type) + { +@@ -3526,6 +3973,7 @@ png_do_gamma(png_row_infop row_info, png_bytep row, + sp++; + } + } ++ + else /* if (row_info->bit_depth == 16) */ + { + sp = row; +@@ -3537,10 +3985,12 @@ png_do_gamma(png_row_infop row_info, png_bytep row, + *sp = (png_byte)((v >> 8) & 0xff); + *(sp + 1) = (png_byte)(v & 0xff); + sp += 2; ++ + v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp]; + *sp = (png_byte)((v >> 8) & 0xff); + *(sp + 1) = (png_byte)(v & 0xff); + sp += 2; ++ + v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp]; + *sp = (png_byte)((v >> 8) & 0xff); + *(sp + 1) = (png_byte)(v & 0xff); +@@ -3559,13 +4009,17 @@ png_do_gamma(png_row_infop row_info, png_bytep row, + { + *sp = gamma_table[*sp]; + sp++; ++ + *sp = gamma_table[*sp]; + sp++; ++ + *sp = gamma_table[*sp]; + sp++; ++ + sp++; + } + } ++ + else /* if (row_info->bit_depth == 16) */ + { + sp = row; +@@ -3575,10 +4029,12 @@ png_do_gamma(png_row_infop row_info, png_bytep row, + *sp = (png_byte)((v >> 8) & 0xff); + *(sp + 1) = (png_byte)(v & 0xff); + sp += 2; ++ + v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp]; + *sp = (png_byte)((v >> 8) & 0xff); + *(sp + 1) = (png_byte)(v & 0xff); + sp += 2; ++ + v = gamma_16_table[*(sp + 1) >> gamma_shift][*sp]; + *sp = (png_byte)((v >> 8) & 0xff); + *(sp + 1) = (png_byte)(v & 0xff); +@@ -3599,6 +4055,7 @@ png_do_gamma(png_row_infop row_info, png_bytep row, + sp += 2; + } + } ++ + else /* if (row_info->bit_depth == 16) */ + { + sp = row; +@@ -3671,8 +4128,76 @@ png_do_gamma(png_row_infop row_info, png_bytep row, + } + break; + } ++ ++ default: ++ break; ++ } ++ } ++} ++#endif ++ ++#ifdef PNG_READ_ALPHA_MODE_SUPPORTED ++/* Encode the alpha channel to the output gamma (the input channel is always ++ * linear.) Called only with color types that have an alpha channel. Needs the ++ * from_1 tables. ++ */ ++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) != 0) ++ { ++ if (row_info->bit_depth == 8) ++ { ++ png_bytep table = png_ptr->gamma_from_1; ++ ++ if (table != NULL) ++ { ++ int step = (row_info->color_type & PNG_COLOR_MASK_COLOR) ? 4 : 2; ++ ++ /* The alpha channel is the last component: */ ++ row += step - 1; ++ ++ for (; row_width > 0; --row_width, row += step) ++ *row = table[*row]; ++ ++ return; ++ } ++ } ++ ++ else if (row_info->bit_depth == 16) ++ { ++ png_uint_16pp table = png_ptr->gamma_16_from_1; ++ int gamma_shift = png_ptr->gamma_shift; ++ ++ if (table != NULL) ++ { ++ int step = (row_info->color_type & PNG_COLOR_MASK_COLOR) ? 8 : 4; ++ ++ /* The alpha channel is the last component: */ ++ row += step - 2; ++ ++ for (; row_width > 0; --row_width, row += step) ++ { ++ png_uint_16 v; ++ ++ v = table[*(row + 1) >> gamma_shift][*row]; ++ *row = (png_byte)((v >> 8) & 0xff); ++ *(row + 1) = (png_byte)(v & 0xff); ++ } ++ ++ return; ++ } + } + } ++ ++ /* Only get to here if called with a weird row_info; no harm has been done, ++ * so just issue a warning. ++ */ ++ png_warning(png_ptr, "png_do_encode_alpha: unexpected call"); + } + #endif + +@@ -3680,9 +4205,10 @@ png_do_gamma(png_row_infop row_info, png_bytep row, + /* Expands a palette row to an RGB or RGBA row depending + * upon whether you supply trans and num_trans. + */ +-void /* PRIVATE */ +-png_do_expand_palette(png_row_infop row_info, png_bytep row, +- png_colorp palette, png_bytep trans, int num_trans) ++static void ++png_do_expand_palette(png_structrp png_ptr, png_row_infop row_info, ++ png_bytep row, png_const_colorp palette, png_const_bytep trans_alpha, ++ int num_trans) + { + int shift, value; + png_bytep sp, dp; +@@ -3691,11 +4217,7 @@ png_do_expand_palette(png_row_infop row_info, png_bytep row, + + png_debug(1, "in png_do_expand_palette"); + +- if ( +-#ifdef PNG_USELESS_TESTS_SUPPORTED +- row != NULL && row_info != NULL && +-#endif +- row_info->color_type == PNG_COLOR_TYPE_PALETTE) ++ if (row_info->color_type == PNG_COLOR_TYPE_PALETTE) + { + if (row_info->bit_depth < 8) + { +@@ -3703,20 +4225,23 @@ png_do_expand_palette(png_row_infop row_info, png_bytep row, + { + case 1: + { +- sp = row + (png_size_t)((row_width - 1) >> 3); +- dp = row + (png_size_t)row_width - 1; ++ sp = row + (size_t)((row_width - 1) >> 3); ++ dp = row + (size_t)row_width - 1; + shift = 7 - (int)((row_width + 7) & 0x07); + for (i = 0; i < row_width; i++) + { + if ((*sp >> shift) & 0x01) + *dp = 1; ++ + else + *dp = 0; ++ + if (shift == 7) + { + shift = 0; + sp--; + } ++ + else + shift++; + +@@ -3727,8 +4252,8 @@ png_do_expand_palette(png_row_infop row_info, png_bytep row, + + case 2: + { +- sp = row + (png_size_t)((row_width - 1) >> 2); +- dp = row + (png_size_t)row_width - 1; ++ sp = row + (size_t)((row_width - 1) >> 2); ++ dp = row + (size_t)row_width - 1; + shift = (int)((3 - ((row_width + 3) & 0x03)) << 1); + for (i = 0; i < row_width; i++) + { +@@ -3739,6 +4264,7 @@ png_do_expand_palette(png_row_infop row_info, png_bytep row, + shift = 0; + sp--; + } ++ + else + shift += 2; + +@@ -3749,8 +4275,8 @@ png_do_expand_palette(png_row_infop row_info, png_bytep row, + + case 4: + { +- sp = row + (png_size_t)((row_width - 1) >> 1); +- dp = row + (png_size_t)row_width - 1; ++ sp = row + (size_t)((row_width - 1) >> 1); ++ dp = row + (size_t)row_width - 1; + shift = (int)((row_width & 0x01) << 2); + for (i = 0; i < row_width; i++) + { +@@ -3761,6 +4287,7 @@ png_do_expand_palette(png_row_infop row_info, png_bytep row, + shift = 0; + sp--; + } ++ + else + shift += 4; + +@@ -3768,26 +4295,42 @@ png_do_expand_palette(png_row_infop row_info, png_bytep row, + } + break; + } ++ ++ default: ++ break; + } + row_info->bit_depth = 8; + row_info->pixel_depth = 8; + row_info->rowbytes = row_width; + } +- switch (row_info->bit_depth) ++ ++ if (row_info->bit_depth == 8) + { +- case 8: + { +- if (trans != NULL) ++ if (num_trans > 0) + { +- sp = row + (png_size_t)row_width - 1; +- dp = row + (png_size_t)(row_width << 2) - 1; ++ sp = row + (size_t)row_width - 1; ++ dp = row + ((size_t)row_width << 2) - 1; + +- for (i = 0; i < row_width; i++) ++ i = 0; ++#ifdef PNG_ARM_NEON_INTRINSICS_AVAILABLE ++ if (png_ptr->riffled_palette != NULL) ++ { ++ /* The RGBA optimization works with png_ptr->bit_depth == 8 ++ * but sometimes row_info->bit_depth has been changed to 8. ++ * In these cases, the palette hasn't been riffled. ++ */ ++ i = png_do_expand_palette_neon_rgba(png_ptr, row_info, row, ++ &sp, &dp); ++ } ++#endif ++ ++ for (; i < row_width; i++) + { + if ((int)(*sp) >= num_trans) + *dp-- = 0xff; + else +- *dp-- = trans[*sp]; ++ *dp-- = trans_alpha[*sp]; + *dp-- = palette[*sp].blue; + *dp-- = palette[*sp].green; + *dp-- = palette[*sp].red; +@@ -3799,12 +4342,18 @@ png_do_expand_palette(png_row_infop row_info, png_bytep row, + row_info->color_type = 6; + row_info->channels = 4; + } ++ + else + { +- sp = row + (png_size_t)row_width - 1; +- dp = row + (png_size_t)(row_width * 3) - 1; ++ sp = row + (size_t)row_width - 1; ++ dp = row + (size_t)(row_width * 3) - 1; ++ i = 0; ++#ifdef PNG_ARM_NEON_INTRINSICS_AVAILABLE ++ i = png_do_expand_palette_neon_rgb(png_ptr, row_info, row, ++ &sp, &dp); ++#endif + +- for (i = 0; i < row_width; i++) ++ for (; i < row_width; i++) + { + *dp-- = palette[*sp].blue; + *dp-- = palette[*sp].green; +@@ -3818,7 +4367,6 @@ png_do_expand_palette(png_row_infop row_info, png_bytep row, + row_info->color_type = 2; + row_info->channels = 3; + } +- break; + } + } + } +@@ -3827,9 +4375,9 @@ png_do_expand_palette(png_row_infop row_info, png_bytep row, + /* 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_color_16p trans_value) ++ png_const_color_16p trans_color) + { + int shift, value; + png_bytep sp, dp; +@@ -3838,224 +4386,268 @@ png_do_expand(png_row_infop row_info, png_bytep row, + + png_debug(1, "in png_do_expand"); + +-#ifdef PNG_USELESS_TESTS_SUPPORTED +- if (row != NULL && row_info != NULL) +-#endif ++ if (row_info->color_type == PNG_COLOR_TYPE_GRAY) + { +- if (row_info->color_type == PNG_COLOR_TYPE_GRAY) +- { +- png_uint_16 gray = (png_uint_16)(trans_value ? trans_value->gray : 0); ++ unsigned int gray = trans_color != NULL ? trans_color->gray : 0; + +- if (row_info->bit_depth < 8) ++ if (row_info->bit_depth < 8) ++ { ++ switch (row_info->bit_depth) + { +- switch (row_info->bit_depth) ++ case 1: + { +- case 1: ++ gray = (gray & 0x01) * 0xff; ++ sp = row + (size_t)((row_width - 1) >> 3); ++ dp = row + (size_t)row_width - 1; ++ shift = 7 - (int)((row_width + 7) & 0x07); ++ for (i = 0; i < row_width; i++) + { +- gray = (png_uint_16)((gray&0x01)*0xff); +- sp = row + (png_size_t)((row_width - 1) >> 3); +- dp = row + (png_size_t)row_width - 1; +- shift = 7 - (int)((row_width + 7) & 0x07); +- for (i = 0; i < row_width; i++) +- { +- if ((*sp >> shift) & 0x01) +- *dp = 0xff; +- else +- *dp = 0; +- if (shift == 7) +- { +- shift = 0; +- sp--; +- } +- else +- shift++; ++ if ((*sp >> shift) & 0x01) ++ *dp = 0xff; + +- dp--; +- } +- break; +- } ++ else ++ *dp = 0; + +- case 2: +- { +- gray = (png_uint_16)((gray&0x03)*0x55); +- sp = row + (png_size_t)((row_width - 1) >> 2); +- dp = row + (png_size_t)row_width - 1; +- shift = (int)((3 - ((row_width + 3) & 0x03)) << 1); +- for (i = 0; i < row_width; i++) ++ if (shift == 7) + { +- value = (*sp >> shift) & 0x03; +- *dp = (png_byte)(value | (value << 2) | (value << 4) | +- (value << 6)); +- if (shift == 6) +- { +- shift = 0; +- sp--; +- } +- else +- shift += 2; +- +- dp--; ++ shift = 0; ++ sp--; + } +- break; +- } + +- case 4: +- { +- gray = (png_uint_16)((gray&0x0f)*0x11); +- sp = row + (png_size_t)((row_width - 1) >> 1); +- dp = row + (png_size_t)row_width - 1; +- shift = (int)((1 - ((row_width + 1) & 0x01)) << 2); +- for (i = 0; i < row_width; i++) +- { +- value = (*sp >> shift) & 0x0f; +- *dp = (png_byte)(value | (value << 4)); +- if (shift == 4) +- { +- shift = 0; +- sp--; +- } +- else +- shift = 4; ++ else ++ shift++; + +- dp--; +- } +- break; ++ dp--; + } ++ break; + } + +- row_info->bit_depth = 8; +- row_info->pixel_depth = 8; +- row_info->rowbytes = row_width; +- } +- +- if (trans_value != NULL) +- { +- if (row_info->bit_depth == 8) ++ case 2: + { +- gray = gray & 0xff; +- sp = row + (png_size_t)row_width - 1; +- dp = row + (png_size_t)(row_width << 1) - 1; ++ gray = (gray & 0x03) * 0x55; ++ sp = row + (size_t)((row_width - 1) >> 2); ++ dp = row + (size_t)row_width - 1; ++ shift = (int)((3 - ((row_width + 3) & 0x03)) << 1); + for (i = 0; i < row_width; i++) + { +- if (*sp == gray) +- *dp-- = 0; ++ value = (*sp >> shift) & 0x03; ++ *dp = (png_byte)(value | (value << 2) | (value << 4) | ++ (value << 6)); ++ if (shift == 6) ++ { ++ shift = 0; ++ sp--; ++ } ++ + else +- *dp-- = 0xff; +- *dp-- = *sp--; ++ shift += 2; ++ ++ dp--; + } ++ break; + } + +- else if (row_info->bit_depth == 16) ++ case 4: + { +- png_byte gray_high = (gray >> 8) & 0xff; +- png_byte gray_low = gray & 0xff; +- sp = row + row_info->rowbytes - 1; +- dp = row + (row_info->rowbytes << 1) - 1; ++ gray = (gray & 0x0f) * 0x11; ++ sp = row + (size_t)((row_width - 1) >> 1); ++ dp = row + (size_t)row_width - 1; ++ shift = (int)((1 - ((row_width + 1) & 0x01)) << 2); + for (i = 0; i < row_width; i++) + { +- if (*(sp - 1) == gray_high && *(sp) == gray_low) ++ value = (*sp >> shift) & 0x0f; ++ *dp = (png_byte)(value | (value << 4)); ++ if (shift == 4) + { +- *dp-- = 0; +- *dp-- = 0; ++ shift = 0; ++ sp--; + } ++ + else +- { +- *dp-- = 0xff; +- *dp-- = 0xff; +- } +- *dp-- = *sp--; +- *dp-- = *sp--; ++ shift = 4; ++ ++ dp--; + } ++ break; + } + +- row_info->color_type = PNG_COLOR_TYPE_GRAY_ALPHA; +- row_info->channels = 2; +- row_info->pixel_depth = (png_byte)(row_info->bit_depth << 1); +- row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth, +- row_width); ++ default: ++ break; + } ++ ++ row_info->bit_depth = 8; ++ row_info->pixel_depth = 8; ++ row_info->rowbytes = row_width; + } +- else if (row_info->color_type == PNG_COLOR_TYPE_RGB && trans_value) ++ ++ if (trans_color != NULL) + { + if (row_info->bit_depth == 8) + { +- png_byte red = trans_value->red & 0xff; +- png_byte green = trans_value->green & 0xff; +- png_byte blue = trans_value->blue & 0xff; +- sp = row + (png_size_t)row_info->rowbytes - 1; +- dp = row + (png_size_t)(row_width << 2) - 1; ++ gray = gray & 0xff; ++ sp = row + (size_t)row_width - 1; ++ dp = row + ((size_t)row_width << 1) - 1; ++ + for (i = 0; i < row_width; i++) + { +- if (*(sp - 2) == red && *(sp - 1) == green && *(sp) == blue) ++ if ((*sp & 0xffU) == gray) + *dp-- = 0; ++ + else + *dp-- = 0xff; +- *dp-- = *sp--; +- *dp-- = *sp--; ++ + *dp-- = *sp--; + } + } ++ + else if (row_info->bit_depth == 16) + { +- png_byte red_high = (trans_value->red >> 8) & 0xff; +- png_byte green_high = (trans_value->green >> 8) & 0xff; +- png_byte blue_high = (trans_value->blue >> 8) & 0xff; +- png_byte red_low = trans_value->red & 0xff; +- png_byte green_low = trans_value->green & 0xff; +- png_byte blue_low = trans_value->blue & 0xff; ++ unsigned int gray_high = (gray >> 8) & 0xff; ++ unsigned int gray_low = gray & 0xff; + sp = row + row_info->rowbytes - 1; +- dp = row + (png_size_t)(row_width << 3) - 1; ++ dp = row + (row_info->rowbytes << 1) - 1; + for (i = 0; i < row_width; i++) + { +- if (*(sp - 5) == red_high && +- *(sp - 4) == red_low && +- *(sp - 3) == green_high && +- *(sp - 2) == green_low && +- *(sp - 1) == blue_high && +- *(sp ) == blue_low) ++ if ((*(sp - 1) & 0xffU) == gray_high && ++ (*(sp) & 0xffU) == gray_low) + { + *dp-- = 0; + *dp-- = 0; + } ++ + else + { + *dp-- = 0xff; + *dp-- = 0xff; + } +- *dp-- = *sp--; +- *dp-- = *sp--; +- *dp-- = *sp--; +- *dp-- = *sp--; ++ + *dp-- = *sp--; + *dp-- = *sp--; + } + } +- row_info->color_type = PNG_COLOR_TYPE_RGB_ALPHA; +- row_info->channels = 4; +- row_info->pixel_depth = (png_byte)(row_info->bit_depth << 2); +- row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth, row_width); ++ ++ row_info->color_type = PNG_COLOR_TYPE_GRAY_ALPHA; ++ row_info->channels = 2; ++ row_info->pixel_depth = (png_byte)(row_info->bit_depth << 1); ++ row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth, ++ row_width); ++ } ++ } ++ else if (row_info->color_type == PNG_COLOR_TYPE_RGB && ++ trans_color != NULL) ++ { ++ if (row_info->bit_depth == 8) ++ { ++ png_byte red = (png_byte)(trans_color->red & 0xff); ++ png_byte green = (png_byte)(trans_color->green & 0xff); ++ png_byte blue = (png_byte)(trans_color->blue & 0xff); ++ sp = row + (size_t)row_info->rowbytes - 1; ++ dp = row + ((size_t)row_width << 2) - 1; ++ for (i = 0; i < row_width; i++) ++ { ++ if (*(sp - 2) == red && *(sp - 1) == green && *(sp) == blue) ++ *dp-- = 0; ++ ++ else ++ *dp-- = 0xff; ++ ++ *dp-- = *sp--; ++ *dp-- = *sp--; ++ *dp-- = *sp--; ++ } ++ } ++ else if (row_info->bit_depth == 16) ++ { ++ png_byte red_high = (png_byte)((trans_color->red >> 8) & 0xff); ++ png_byte green_high = (png_byte)((trans_color->green >> 8) & 0xff); ++ png_byte blue_high = (png_byte)((trans_color->blue >> 8) & 0xff); ++ png_byte red_low = (png_byte)(trans_color->red & 0xff); ++ png_byte green_low = (png_byte)(trans_color->green & 0xff); ++ png_byte blue_low = (png_byte)(trans_color->blue & 0xff); ++ sp = row + row_info->rowbytes - 1; ++ dp = row + ((size_t)row_width << 3) - 1; ++ for (i = 0; i < row_width; i++) ++ { ++ if (*(sp - 5) == red_high && ++ *(sp - 4) == red_low && ++ *(sp - 3) == green_high && ++ *(sp - 2) == green_low && ++ *(sp - 1) == blue_high && ++ *(sp ) == blue_low) ++ { ++ *dp-- = 0; ++ *dp-- = 0; ++ } ++ ++ else ++ { ++ *dp-- = 0xff; ++ *dp-- = 0xff; ++ } ++ ++ *dp-- = *sp--; ++ *dp-- = *sp--; ++ *dp-- = *sp--; ++ *dp-- = *sp--; ++ *dp-- = *sp--; ++ *dp-- = *sp--; ++ } + } ++ row_info->color_type = PNG_COLOR_TYPE_RGB_ALPHA; ++ row_info->channels = 4; ++ row_info->pixel_depth = (png_byte)(row_info->bit_depth << 2); ++ row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth, row_width); + } + } + #endif + +-#ifdef PNG_READ_DITHER_SUPPORTED +-void /* PRIVATE */ +-png_do_dither(png_row_infop row_info, png_bytep row, +- png_bytep palette_lookup, png_bytep dither_lookup) ++#ifdef PNG_READ_EXPAND_16_SUPPORTED ++/* 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. ++ */ ++static void ++png_do_expand_16(png_row_infop row_info, png_bytep row) ++{ ++ if (row_info->bit_depth == 8 && ++ row_info->color_type != PNG_COLOR_TYPE_PALETTE) ++ { ++ /* The row have a sequence of bytes containing [0..255] and we need ++ * to turn it into another row containing [0..65535], to do this we ++ * calculate: ++ * ++ * (input / 255) * 65535 ++ * ++ * Which happens to be exactly input * 257 and this can be achieved ++ * simply by byte replication in place (copying backwards). ++ */ ++ png_byte *sp = row + row_info->rowbytes; /* source, last byte + 1 */ ++ png_byte *dp = sp + row_info->rowbytes; /* destination, end + 1 */ ++ while (dp > sp) ++ { ++ dp[-2] = dp[-1] = *--sp; dp -= 2; ++ } ++ ++ row_info->rowbytes *= 2; ++ row_info->bit_depth = 16; ++ row_info->pixel_depth = (png_byte)(row_info->channels * 16); ++ } ++} ++#endif ++ ++#ifdef PNG_READ_QUANTIZE_SUPPORTED ++static void ++png_do_quantize(png_row_infop row_info, png_bytep row, ++ png_const_bytep palette_lookup, png_const_bytep quantize_lookup) + { + png_bytep sp, dp; + png_uint_32 i; + png_uint_32 row_width=row_info->width; + +- png_debug(1, "in png_do_dither"); ++ png_debug(1, "in png_do_quantize"); + +-#ifdef PNG_USELESS_TESTS_SUPPORTED +- if (row != NULL && row_info != NULL) +-#endif ++ if (row_info->bit_depth == 8) + { +- if (row_info->color_type == PNG_COLOR_TYPE_RGB && +- palette_lookup && row_info->bit_depth == 8) ++ if (row_info->color_type == PNG_COLOR_TYPE_RGB && palette_lookup) + { + int r, g, b, p; + sp = row; +@@ -4073,24 +4665,26 @@ png_do_dither(png_row_infop row_info, png_bytep row, + * (((g >> 3) & 0x1f) << 5) | + * ((b >> 3) & 0x1f); + */ +- p = (((r >> (8 - PNG_DITHER_RED_BITS)) & +- ((1 << PNG_DITHER_RED_BITS) - 1)) << +- (PNG_DITHER_GREEN_BITS + PNG_DITHER_BLUE_BITS)) | +- (((g >> (8 - PNG_DITHER_GREEN_BITS)) & +- ((1 << PNG_DITHER_GREEN_BITS) - 1)) << +- (PNG_DITHER_BLUE_BITS)) | +- ((b >> (8 - PNG_DITHER_BLUE_BITS)) & +- ((1 << PNG_DITHER_BLUE_BITS) - 1)); ++ p = (((r >> (8 - PNG_QUANTIZE_RED_BITS)) & ++ ((1 << PNG_QUANTIZE_RED_BITS) - 1)) << ++ (PNG_QUANTIZE_GREEN_BITS + PNG_QUANTIZE_BLUE_BITS)) | ++ (((g >> (8 - PNG_QUANTIZE_GREEN_BITS)) & ++ ((1 << PNG_QUANTIZE_GREEN_BITS) - 1)) << ++ (PNG_QUANTIZE_BLUE_BITS)) | ++ ((b >> (8 - PNG_QUANTIZE_BLUE_BITS)) & ++ ((1 << PNG_QUANTIZE_BLUE_BITS) - 1)); + + *dp++ = palette_lookup[p]; + } ++ + row_info->color_type = PNG_COLOR_TYPE_PALETTE; + row_info->channels = 1; + row_info->pixel_depth = row_info->bit_depth; + row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth, row_width); + } ++ + else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA && +- palette_lookup != NULL && row_info->bit_depth == 8) ++ palette_lookup != NULL) + { + int r, g, b, p; + sp = row; +@@ -4102,356 +4696,347 @@ png_do_dither(png_row_infop row_info, png_bytep row, + b = *sp++; + sp++; + +- p = (((r >> (8 - PNG_DITHER_RED_BITS)) & +- ((1 << PNG_DITHER_RED_BITS) - 1)) << +- (PNG_DITHER_GREEN_BITS + PNG_DITHER_BLUE_BITS)) | +- (((g >> (8 - PNG_DITHER_GREEN_BITS)) & +- ((1 << PNG_DITHER_GREEN_BITS) - 1)) << +- (PNG_DITHER_BLUE_BITS)) | +- ((b >> (8 - PNG_DITHER_BLUE_BITS)) & +- ((1 << PNG_DITHER_BLUE_BITS) - 1)); ++ p = (((r >> (8 - PNG_QUANTIZE_RED_BITS)) & ++ ((1 << PNG_QUANTIZE_RED_BITS) - 1)) << ++ (PNG_QUANTIZE_GREEN_BITS + PNG_QUANTIZE_BLUE_BITS)) | ++ (((g >> (8 - PNG_QUANTIZE_GREEN_BITS)) & ++ ((1 << PNG_QUANTIZE_GREEN_BITS) - 1)) << ++ (PNG_QUANTIZE_BLUE_BITS)) | ++ ((b >> (8 - PNG_QUANTIZE_BLUE_BITS)) & ++ ((1 << PNG_QUANTIZE_BLUE_BITS) - 1)); + + *dp++ = palette_lookup[p]; + } ++ + row_info->color_type = PNG_COLOR_TYPE_PALETTE; + row_info->channels = 1; + row_info->pixel_depth = row_info->bit_depth; + row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth, row_width); + } ++ + else if (row_info->color_type == PNG_COLOR_TYPE_PALETTE && +- dither_lookup && row_info->bit_depth == 8) ++ quantize_lookup) + { + sp = row; ++ + for (i = 0; i < row_width; i++, sp++) + { +- *sp = dither_lookup[*sp]; ++ *sp = quantize_lookup[*sp]; + } + } + } + } +-#endif ++#endif /* READ_QUANTIZE */ + +-#ifdef PNG_FLOATING_POINT_SUPPORTED +-#ifdef PNG_READ_GAMMA_SUPPORTED +-static PNG_CONST int png_gamma_shift[] = +- {0x10, 0x21, 0x42, 0x84, 0x110, 0x248, 0x550, 0xff0, 0x00}; +- +-/* We build the 8- or 16-bit gamma tables here. Note that for 16-bit +- * tables, we don't make a full table if we are reducing to 8-bit in +- * the future. Note also how the gamma_16 tables are segmented so that +- * we don't need to allocate > 64K chunks for a full 16-bit table. +- * +- * See the PNG extensions document for an integer algorithm for creating +- * the gamma tables. Maybe we will implement that here someday. +- * +- * We should only reach this point if +- * +- * the file_gamma is known (i.e., the gAMA or sRGB chunk is present, +- * or the application has provided a file_gamma) +- * +- * AND +- * { +- * the screen_gamma is known +- * OR +- * +- * RGB_to_gray transformation is being performed +- * } +- * +- * AND +- * { +- * the screen_gamma is different from the reciprocal of the +- * file_gamma by more than the specified threshold +- * +- * OR +- * +- * a background color has been specified and the file_gamma +- * and screen_gamma are not 1.0, within the specified threshold. +- * } ++/* 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_build_gamma_table(png_structp png_ptr) ++png_do_read_transformations(png_structrp png_ptr, png_row_infop row_info) + { +- png_debug(1, "in png_build_gamma_table"); +- +- if (png_ptr->bit_depth <= 8) +- { +- int i; +- double g; +- +- if (png_ptr->screen_gamma > .000001) +- g = 1.0 / (png_ptr->gamma * png_ptr->screen_gamma); +- +- else +- g = 1.0; +- +- png_ptr->gamma_table = (png_bytep)png_malloc(png_ptr, +- (png_uint_32)256); +- +- for (i = 0; i < 256; i++) +- { +- png_ptr->gamma_table[i] = (png_byte)(pow((double)i / 255.0, +- g) * 255.0 + .5); +- } +- +-#if defined(PNG_READ_BACKGROUND_SUPPORTED) || \ +- defined(PNG_READ_RGB_TO_GRAY_SUPPORTED) +- if (png_ptr->transformations & ((PNG_BACKGROUND) | PNG_RGB_TO_GRAY)) +- { ++ png_debug(1, "in png_do_read_transformations"); + +- g = 1.0 / (png_ptr->gamma); ++ 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"); ++ } + +- png_ptr->gamma_to_1 = (png_bytep)png_malloc(png_ptr, +- (png_uint_32)256); ++ /* 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"); ++ } + +- for (i = 0; i < 256; i++) +- { +- png_ptr->gamma_to_1[i] = (png_byte)(pow((double)i / 255.0, +- g) * 255.0 + .5); +- } ++#ifdef PNG_READ_EXPAND_SUPPORTED ++ if ((png_ptr->transformations & PNG_EXPAND) != 0) ++ { ++ if (row_info->color_type == PNG_COLOR_TYPE_PALETTE) ++ { ++#ifdef PNG_ARM_NEON_INTRINSICS_AVAILABLE ++ if ((png_ptr->num_trans > 0) && (png_ptr->bit_depth == 8)) ++ { ++ /* Allocate space for the decompressed full palette. */ ++ if (png_ptr->riffled_palette == NULL) ++ { ++ png_ptr->riffled_palette = png_malloc(png_ptr, 256*4); ++ if (png_ptr->riffled_palette == NULL) ++ png_error(png_ptr, "NULL row buffer"); ++ /* Build the RGBA palette. */ ++ png_riffle_palette_rgba(png_ptr, row_info); ++ } ++ } ++#endif ++ 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 != 0 && ++ (png_ptr->transformations & PNG_EXPAND_tRNS) != 0) ++ png_do_expand(row_info, png_ptr->row_buf + 1, ++ &(png_ptr->trans_color)); + +- png_ptr->gamma_from_1 = (png_bytep)png_malloc(png_ptr, +- (png_uint_32)256); ++ else ++ png_do_expand(row_info, png_ptr->row_buf + 1, NULL); ++ } ++ } ++#endif + +- if (png_ptr->screen_gamma > 0.000001) +- g = 1.0 / png_ptr->screen_gamma; ++#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 + +- else +- g = png_ptr->gamma; /* Probably doing rgb_to_gray */ ++#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); + +- for (i = 0; i < 256; i++) +- { +- png_ptr->gamma_from_1[i] = (png_byte)(pow((double)i / 255.0, +- g) * 255.0 + .5); ++ 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"); + +- } +- } +-#endif /* PNG_READ_BACKGROUND_SUPPORTED || PNG_RGB_TO_GRAY_SUPPORTED */ +- } +- else +- { +- double g; +- int i, j, shift, num; +- int sig_bit; +- png_uint_32 ig; +- +- if (png_ptr->color_type & PNG_COLOR_MASK_COLOR) +- { +- sig_bit = (int)png_ptr->sig_bit.red; +- +- if ((int)png_ptr->sig_bit.green > sig_bit) +- sig_bit = png_ptr->sig_bit.green; +- +- if ((int)png_ptr->sig_bit.blue > sig_bit) +- sig_bit = png_ptr->sig_bit.blue; +- } +- else +- { +- sig_bit = (int)png_ptr->sig_bit.gray; +- } +- +- if (sig_bit > 0) +- shift = 16 - sig_bit; +- +- else +- shift = 0; +- +- if (png_ptr->transformations & PNG_16_TO_8) +- { +- if (shift < (16 - PNG_MAX_GAMMA_8)) +- shift = (16 - PNG_MAX_GAMMA_8); +- } +- +- if (shift > 8) +- shift = 8; +- +- if (shift < 0) +- shift = 0; +- +- png_ptr->gamma_shift = (png_byte)shift; +- +- num = (1 << (8 - shift)); +- +- if (png_ptr->screen_gamma > .000001) +- g = 1.0 / (png_ptr->gamma * png_ptr->screen_gamma); +- else +- g = 1.0; +- +- png_ptr->gamma_16_table = (png_uint_16pp)png_calloc(png_ptr, +- (png_uint_32)(num * png_sizeof(png_uint_16p))); +- +- if (png_ptr->transformations & (PNG_16_TO_8 | PNG_BACKGROUND)) +- { +- double fin, fout; +- png_uint_32 last, max; +- +- for (i = 0; i < num; i++) +- { +- png_ptr->gamma_16_table[i] = (png_uint_16p)png_malloc(png_ptr, +- (png_uint_32)(256 * png_sizeof(png_uint_16))); +- } ++ 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 + +- g = 1.0 / g; +- last = 0; +- for (i = 0; i < 256; i++) +- { +- fout = ((double)i + 0.5) / 256.0; +- fin = pow(fout, g); +- max = (png_uint_32)(fin * (double)((png_uint_32)num << 8)); +- while (last <= max) +- { +- png_ptr->gamma_16_table[(int)(last & (0xff >> shift))] +- [(int)(last >> (8 - shift))] = (png_uint_16)( +- (png_uint_16)i | ((png_uint_16)i << 8)); +- last++; +- } +- } +- while (last < ((png_uint_32)num << 8)) +- { +- png_ptr->gamma_16_table[(int)(last & (0xff >> shift))] +- [(int)(last >> (8 - shift))] = (png_uint_16)65535L; +- last++; +- } +- } +- else +- { +- for (i = 0; i < num; i++) +- { +- png_ptr->gamma_16_table[i] = (png_uint_16p)png_malloc(png_ptr, +- (png_uint_32)(256 * png_sizeof(png_uint_16))); ++/* 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. ++ */ + +- ig = (((png_uint_32)i * (png_uint_32)png_gamma_shift[shift]) >> 4); ++#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 + +- for (j = 0; j < 256; j++) +- { +- png_ptr->gamma_16_table[i][j] = +- (png_uint_16)(pow((double)(ig + ((png_uint_32)j << 8)) / +- 65535.0, g) * 65535.0 + .5); +- } +- } +- } ++#if defined(PNG_READ_BACKGROUND_SUPPORTED) ||\ ++ defined(PNG_READ_ALPHA_MODE_SUPPORTED) ++ if ((png_ptr->transformations & PNG_COMPOSE) != 0) ++ png_do_compose(row_info, png_ptr->row_buf + 1, png_ptr); ++#endif + +-#if defined(PNG_READ_BACKGROUND_SUPPORTED) || \ +- defined(PNG_READ_RGB_TO_GRAY_SUPPORTED) +- if (png_ptr->transformations & (PNG_BACKGROUND | PNG_RGB_TO_GRAY)) +- { ++#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) != 0 && ++ ((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 + +- g = 1.0 / (png_ptr->gamma); ++#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 + +- png_ptr->gamma_16_to_1 = (png_uint_16pp)png_calloc(png_ptr, +- (png_uint_32)(num * png_sizeof(png_uint_16p ))); ++#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 + +- for (i = 0; i < num; i++) +- { +- png_ptr->gamma_16_to_1[i] = (png_uint_16p)png_malloc(png_ptr, +- (png_uint_32)(256 * png_sizeof(png_uint_16))); ++#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 + +- ig = (((png_uint_32)i * +- (png_uint_32)png_gamma_shift[shift]) >> 4); +- for (j = 0; j < 256; j++) +- { +- png_ptr->gamma_16_to_1[i][j] = +- (png_uint_16)(pow((double)(ig + ((png_uint_32)j << 8)) / +- 65535.0, g) * 65535.0 + .5); +- } +- } ++#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 + +- if (png_ptr->screen_gamma > 0.000001) +- g = 1.0 / png_ptr->screen_gamma; ++#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); + +- else +- g = png_ptr->gamma; /* Probably doing rgb_to_gray */ ++ if (row_info->rowbytes == 0) ++ png_error(png_ptr, "png_do_quantize returned rowbytes=0"); ++ } ++#endif /* READ_QUANTIZE */ + +- png_ptr->gamma_16_from_1 = (png_uint_16pp)png_calloc(png_ptr, +- (png_uint_32)(num * png_sizeof(png_uint_16p))); ++#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 + +- for (i = 0; i < num; i++) +- { +- png_ptr->gamma_16_from_1[i] = (png_uint_16p)png_malloc(png_ptr, +- (png_uint_32)(256 * png_sizeof(png_uint_16))); ++#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 + +- ig = (((png_uint_32)i * +- (png_uint_32)png_gamma_shift[shift]) >> 4); ++#ifdef PNG_READ_INVERT_SUPPORTED ++ if ((png_ptr->transformations & PNG_INVERT_MONO) != 0) ++ png_do_invert(row_info, png_ptr->row_buf + 1); ++#endif + +- for (j = 0; j < 256; j++) +- { +- png_ptr->gamma_16_from_1[i][j] = +- (png_uint_16)(pow((double)(ig + ((png_uint_32)j << 8)) / +- 65535.0, g) * 65535.0 + .5); +- } +- } +- } +-#endif /* PNG_READ_BACKGROUND_SUPPORTED || PNG_RGB_TO_GRAY_SUPPORTED */ +- } +-} ++#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 +-/* To do: install integer version of png_build_gamma_table here */ ++ ++#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_MNG_FEATURES_SUPPORTED +-/* Undoes intrapixel differencing */ +-void /* PRIVATE */ +-png_do_read_intrapixel(png_row_infop row_info, png_bytep row) +-{ +- png_debug(1, "in png_do_read_intrapixel"); ++#ifdef PNG_READ_PACK_SUPPORTED ++ if ((png_ptr->transformations & PNG_PACK) != 0) ++ png_do_unpack(row_info, png_ptr->row_buf + 1); ++#endif + +- if ( +-#ifdef PNG_USELESS_TESTS_SUPPORTED +- row != NULL && row_info != NULL && ++#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 +- (row_info->color_type & PNG_COLOR_MASK_COLOR)) +- { +- int bytes_per_pixel; +- png_uint_32 row_width = row_info->width; +- if (row_info->bit_depth == 8) +- { +- png_bytep rp; +- png_uint_32 i; + +- if (row_info->color_type == PNG_COLOR_TYPE_RGB) +- bytes_per_pixel = 3; ++#ifdef PNG_READ_BGR_SUPPORTED ++ if ((png_ptr->transformations & PNG_BGR) != 0) ++ png_do_bgr(row_info, png_ptr->row_buf + 1); ++#endif + +- else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA) +- bytes_per_pixel = 4; ++#ifdef PNG_READ_PACKSWAP_SUPPORTED ++ if ((png_ptr->transformations & PNG_PACKSWAP) != 0) ++ png_do_packswap(row_info, png_ptr->row_buf + 1); ++#endif + +- else +- return; ++#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 + +- 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; ++#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 + +- if (row_info->color_type == PNG_COLOR_TYPE_RGB) +- bytes_per_pixel = 6; ++#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 + +- else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA) +- bytes_per_pixel = 8; ++#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 */ ++ /* 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; + +- else +- return; ++ 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); + +- 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); +- } +- } ++ 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 */ +diff --git a/com32/lib/libpng/pngrutil.c b/com32/lib/libpng/pngrutil.c +index 1e2db31b..d5fa08c3 100644 +--- a/com32/lib/libpng/pngrutil.c ++++ b/com32/lib/libpng/pngrutil.c +@@ -1,10 +1,10 @@ + + /* pngrutil.c - utilities to read a PNG file + * +- * Last changed in libpng 1.2.44 [June 26, 2010] +- * Copyright (c) 1998-2010 Glenn Randers-Pehrson +- * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) +- * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) ++ * Copyright (c) 2018 Cosmin Truta ++ * Copyright (c) 1998-2002,2004,2006-2018 Glenn Randers-Pehrson ++ * Copyright (c) 1996-1997 Andreas Dilger ++ * Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc. + * + * This code is released under the libpng license. + * For conditions of distribution and use, see the disclaimer +@@ -14,169 +14,230 @@ + * libpng itself during the course of reading an image. + */ + +-#define PNG_INTERNAL +-#define PNG_NO_PEDANTIC_WARNINGS +-#include "png.h" +-#ifdef PNG_READ_SUPPORTED ++#include "pngpriv.h" + +-#if defined(_WIN32_WCE) && (_WIN32_WCE<0x500) +-# define WIN32_WCE_OLD +-#endif ++#ifdef PNG_READ_SUPPORTED + +-#ifdef PNG_FLOATING_POINT_SUPPORTED +-# ifdef WIN32_WCE_OLD +-/* The strtod() function is not supported on WindowsCE */ +-__inline double png_strtod(png_structp png_ptr, PNG_CONST char *nptr, +- char **endptr) ++png_uint_32 PNGAPI ++png_get_uint_31(png_const_structrp png_ptr, png_const_bytep buf) + { +- double result = 0; +- int len; +- wchar_t *str, *end; ++ png_uint_32 uval = png_get_uint_32(buf); + +- len = MultiByteToWideChar(CP_ACP, 0, nptr, -1, NULL, 0); +- str = (wchar_t *)png_malloc(png_ptr, len * png_sizeof(wchar_t)); +- if ( NULL != str ) +- { +- MultiByteToWideChar(CP_ACP, 0, nptr, -1, str, len); +- result = wcstod(str, &end); +- len = WideCharToMultiByte(CP_ACP, 0, end, -1, NULL, 0, NULL, NULL); +- *endptr = (char *)nptr + (png_strlen(nptr) - len + 1); +- png_free(png_ptr, str); +- } +- return result; ++ if (uval > PNG_UINT_31_MAX) ++ png_error(png_ptr, "PNG unsigned integer out of range"); ++ ++ return (uval); + } +-# else +-# define png_strtod(p,a,b) strtod(a,b) +-# endif +-#endif + +-png_uint_32 PNGAPI +-png_get_uint_31(png_structp png_ptr, png_bytep buf) ++#if defined(PNG_READ_gAMA_SUPPORTED) || defined(PNG_READ_cHRM_SUPPORTED) ++/* The following is a variation on the above for use with the fixed ++ * point values used for gAMA and cHRM. Instead of png_error it ++ * issues a warning and returns (-1) - an invalid value because both ++ * gAMA and cHRM use *unsigned* integers for fixed point values. ++ */ ++#define PNG_FIXED_ERROR (-1) ++ ++static png_fixed_point /* PRIVATE */ ++png_get_fixed_point(png_structrp png_ptr, png_const_bytep buf) + { +-#ifdef PNG_READ_BIG_ENDIAN_SUPPORTED +- png_uint_32 i = png_get_uint_32(buf); +-#else +- /* Avoid an extra function call by inlining the result. */ +- png_uint_32 i = ((png_uint_32)(*buf) << 24) + +- ((png_uint_32)(*(buf + 1)) << 16) + +- ((png_uint_32)(*(buf + 2)) << 8) + +- (png_uint_32)(*(buf + 3)); +-#endif +- if (i > PNG_UINT_31_MAX) +- png_error(png_ptr, "PNG unsigned integer out of range."); +- return (i); ++ png_uint_32 uval = png_get_uint_32(buf); ++ ++ if (uval <= PNG_UINT_31_MAX) ++ return (png_fixed_point)uval; /* known to be in range */ ++ ++ /* The caller can turn off the warning by passing NULL. */ ++ if (png_ptr != NULL) ++ png_warning(png_ptr, "PNG fixed point integer out of range"); ++ ++ return PNG_FIXED_ERROR; + } +-#ifndef PNG_READ_BIG_ENDIAN_SUPPORTED ++#endif ++ ++#ifdef PNG_READ_INT_FUNCTIONS_SUPPORTED ++/* NOTE: the read macros will obscure these definitions, so that if ++ * PNG_USE_READ_MACROS is set the library will not use them internally, ++ * but the APIs will still be available externally. ++ * ++ * The parentheses around "PNGAPI function_name" in the following three ++ * functions are necessary because they allow the macros to co-exist with ++ * these (unused but exported) functions. ++ */ ++ + /* Grab an unsigned 32-bit integer from a buffer in big-endian format. */ +-png_uint_32 PNGAPI +-png_get_uint_32(png_bytep buf) ++png_uint_32 (PNGAPI ++png_get_uint_32)(png_const_bytep buf) + { +- png_uint_32 i = ((png_uint_32)(*buf) << 24) + +- ((png_uint_32)(*(buf + 1)) << 16) + +- ((png_uint_32)(*(buf + 2)) << 8) + +- (png_uint_32)(*(buf + 3)); ++ png_uint_32 uval = ++ ((png_uint_32)(*(buf )) << 24) + ++ ((png_uint_32)(*(buf + 1)) << 16) + ++ ((png_uint_32)(*(buf + 2)) << 8) + ++ ((png_uint_32)(*(buf + 3)) ) ; + +- return (i); ++ return uval; + } + + /* Grab a signed 32-bit integer from a buffer in big-endian format. The +- * data is stored in the PNG file in two's complement format, and it is +- * assumed that the machine format for signed integers is the same. ++ * data is stored in the PNG file in two's complement format and there ++ * is no guarantee that a 'png_int_32' is exactly 32 bits, therefore ++ * the following code does a two's complement to native conversion. + */ +-png_int_32 PNGAPI +-png_get_int_32(png_bytep buf) ++png_int_32 (PNGAPI ++png_get_int_32)(png_const_bytep buf) + { +- png_int_32 i = ((png_int_32)(*buf) << 24) + +- ((png_int_32)(*(buf + 1)) << 16) + +- ((png_int_32)(*(buf + 2)) << 8) + +- (png_int_32)(*(buf + 3)); +- +- return (i); ++ png_uint_32 uval = png_get_uint_32(buf); ++ if ((uval & 0x80000000) == 0) /* non-negative */ ++ return (png_int_32)uval; ++ ++ uval = (uval ^ 0xffffffff) + 1; /* 2's complement: -x = ~x+1 */ ++ if ((uval & 0x80000000) == 0) /* no overflow */ ++ return -(png_int_32)uval; ++ /* The following has to be safe; this function only gets called on PNG data ++ * and if we get here that data is invalid. 0 is the most safe value and ++ * if not then an attacker would surely just generate a PNG with 0 instead. ++ */ ++ return 0; + } + + /* Grab an unsigned 16-bit integer from a buffer in big-endian format. */ +-png_uint_16 PNGAPI +-png_get_uint_16(png_bytep buf) ++png_uint_16 (PNGAPI ++png_get_uint_16)(png_const_bytep buf) ++{ ++ /* ANSI-C requires an int value to accommodate 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.) ++ */ ++ unsigned int val = ++ ((unsigned int)(*buf) << 8) + ++ ((unsigned int)(*(buf + 1))); ++ ++ return (png_uint_16)val; ++} ++ ++#endif /* READ_INT_FUNCTIONS */ ++ ++/* Read and check the PNG file signature */ ++void /* PRIVATE */ ++png_read_sig(png_structrp png_ptr, png_inforp info_ptr) + { +- png_uint_16 i = (png_uint_16)(((png_uint_16)(*buf) << 8) + +- (png_uint_16)(*(buf + 1))); ++ size_t num_checked, num_to_check; ++ ++ /* Exit if the user application does not expect a signature. */ ++ if (png_ptr->sig_bytes >= 8) ++ return; ++ ++ num_checked = png_ptr->sig_bytes; ++ num_to_check = 8 - num_checked; + +- return (i); ++#ifdef PNG_IO_STATE_SUPPORTED ++ png_ptr->io_state = PNG_IO_READING | PNG_IO_SIGNATURE; ++#endif ++ ++ /* The signature must be serialized in a single I/O call. */ ++ 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) != 0) ++ { ++ if (num_checked < 4 && ++ png_sig_cmp(info_ptr->signature, num_checked, num_to_check - 4)) ++ png_error(png_ptr, "Not a PNG file"); ++ else ++ png_error(png_ptr, "PNG file corrupted by ASCII conversion"); ++ } ++ if (num_checked < 3) ++ png_ptr->mode |= PNG_HAVE_PNG_SIGNATURE; + } +-#endif /* PNG_READ_BIG_ENDIAN_SUPPORTED */ + + /* Read the chunk header (length + type name). + * Put the type name into png_ptr->chunk_name, and return the length. + */ + png_uint_32 /* PRIVATE */ +-png_read_chunk_header(png_structp png_ptr) ++png_read_chunk_header(png_structrp png_ptr) + { + png_byte buf[8]; + png_uint_32 length; + +- /* Read the length and the chunk name */ ++#ifdef PNG_IO_STATE_SUPPORTED ++ png_ptr->io_state = PNG_IO_READING | PNG_IO_CHUNK_HDR; ++#endif ++ ++ /* Read the length and the chunk name. ++ * This must be performed in a single I/O call. ++ */ + png_read_data(png_ptr, buf, 8); + length = png_get_uint_31(png_ptr, buf); + +- /* Put the chunk name into png_ptr->chunk_name */ +- png_memcpy(png_ptr->chunk_name, buf + 4, 4); ++ /* Put the chunk name into png_ptr->chunk_name. */ ++ png_ptr->chunk_name = PNG_CHUNK_FROM_STRING(buf+4); + +- png_debug2(0, "Reading %s chunk, length = %lu", +- png_ptr->chunk_name, length); ++ 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 */ ++ /* 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 */ ++ /* Check to see if chunk name is valid. */ + png_check_chunk_name(png_ptr, png_ptr->chunk_name); + ++ /* Check for too-large chunk length */ ++ png_check_chunk_length(png_ptr, length); ++ ++#ifdef PNG_IO_STATE_SUPPORTED ++ png_ptr->io_state = PNG_IO_READING | PNG_IO_CHUNK_DATA; ++#endif ++ + return length; + } + + /* Read data, and (optionally) run it through the CRC. */ + void /* PRIVATE */ +-png_crc_read(png_structp png_ptr, png_bytep buf, png_size_t length) ++png_crc_read(png_structrp png_ptr, png_bytep buf, png_uint_32 length) + { + if (png_ptr == NULL) + return; ++ + png_read_data(png_ptr, buf, length); + png_calculate_crc(png_ptr, buf, length); + } + + /* Optionally skip data and then check the CRC. Depending on whether we +- * are reading a ancillary or critical chunk, and how the program has set ++ * 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) +- { +- png_crc_read(png_ptr, png_ptr->zbuf, png_ptr->zbuf_size); +- } +- if (i) ++ /* 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, i); ++ 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 (png_crc_error(png_ptr)) ++ if (png_crc_error(png_ptr) != 0) + { +- 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_error(png_ptr, "CRC error"); +- } ++ + return (1); + } + +@@ -187,251 +248,595 @@ png_crc_finish(png_structp png_ptr, png_uint_32 skip) + * 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; + } + ++#ifdef PNG_IO_STATE_SUPPORTED ++ png_ptr->io_state = PNG_IO_READING | PNG_IO_CHUNK_CRC; ++#endif ++ ++ /* 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)); + } ++ + else + return (0); + } + +-#if defined(PNG_READ_zTXt_SUPPORTED) || defined(PNG_READ_iTXt_SUPPORTED) || \ +- defined(PNG_READ_iCCP_SUPPORTED) +-static png_size_t +-png_inflate(png_structp png_ptr, const png_byte *data, png_size_t size, +- png_bytep output, png_size_t output_size) ++#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_size_t count = 0; ++ png_bytep buffer = png_ptr->read_buffer; + +- png_ptr->zstream.next_in = (png_bytep)data; /* const_cast: VALID */ +- png_ptr->zstream.avail_in = size; ++ 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) ++ { ++ memset(buffer, 0, new_size); /* just in case */ ++ 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 */ + +- while (1) ++/* 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) + { +- int ret, avail; ++ char msg[64]; + +- /* Reset the output buffer each time round - we empty it +- * after every inflate call. ++ PNG_STRING_FROM_CHUNK(msg, png_ptr->zowner); ++ /* So the message that results is " using zstream"; this is an ++ * internal error, but is very useful for debugging. i18n requirements ++ * are minimal. + */ +- png_ptr->zstream.next_out = png_ptr->zbuf; +- png_ptr->zstream.avail_out = png_ptr->zbuf_size; ++ (void)png_safecat(msg, (sizeof msg), 4, " using zstream"); ++#if PNG_RELEASE_BUILD ++ 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 ZLIB_VERNUM >= 0x1240 ++ int window_bits = 0; ++ ++# if defined(PNG_SET_OPTION_SUPPORTED) && defined(PNG_MAXIMUM_INFLATE_WINDOW) ++ if (((png_ptr->options >> PNG_MAXIMUM_INFLATE_WINDOW) & 3) == ++ PNG_OPTION_ON) ++ { ++ window_bits = 15; ++ png_ptr->zstream_start = 0; /* fixed window size */ ++ } ++ ++ else ++ { ++ png_ptr->zstream_start = 1; ++ } ++# endif + +- ret = inflate(&png_ptr->zstream, Z_NO_FLUSH); +- avail = png_ptr->zbuf_size - png_ptr->zstream.avail_out; ++#endif /* ZLIB_VERNUM >= 0x1240 */ + +- /* First copy/count any new output - but only if we didn't +- * get an error code. ++ /* Set this for safety, just in case the previous owner left pointers to ++ * memory allocations. + */ +- if ((ret == Z_OK || ret == Z_STREAM_END) && avail > 0) ++ 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 (output != 0 && output_size > count) +- { +- int copy = output_size - count; +- if (avail < copy) copy = avail; +- png_memcpy(output + count, png_ptr->zbuf, copy); +- } +- count += avail; ++#if ZLIB_VERNUM >= 0x1240 ++ ret = inflateReset2(&png_ptr->zstream, window_bits); ++#else ++ ret = inflateReset(&png_ptr->zstream); ++#endif ++ } ++ ++ else ++ { ++#if ZLIB_VERNUM >= 0x1240 ++ ret = inflateInit2(&png_ptr->zstream, window_bits); ++#else ++ ret = inflateInit(&png_ptr->zstream); ++#endif ++ ++ if (ret == Z_OK) ++ png_ptr->flags |= PNG_FLAG_ZSTREAM_INITIALIZED; + } + ++#if ZLIB_VERNUM >= 0x1290 && \ ++ defined(PNG_SET_OPTION_SUPPORTED) && defined(PNG_IGNORE_ADLER32) ++ if (((png_ptr->options >> PNG_IGNORE_ADLER32) & 3) == PNG_OPTION_ON) ++ /* Turn off validation of the ADLER32 checksum in IDAT chunks */ ++ ret = inflateValidate(&png_ptr->zstream, 0); ++#endif ++ + if (ret == Z_OK) +- continue; ++ png_ptr->zowner = owner; ++ ++ else ++ png_zstream_error(png_ptr, ret); + +- /* Termination conditions - always reset the zstream, it +- * must be left in inflateInit state. ++ return ret; ++ } ++ ++#ifdef window_bits ++# undef window_bits ++#endif ++} ++ ++#if ZLIB_VERNUM >= 0x1240 ++/* Handle the start of the inflate stream if we called inflateInit2(strm,0); ++ * in this case some zlib versions skip validation of the CINFO field and, in ++ * certain circumstances, libpng may end up displaying an invalid image, in ++ * contrast to implementations that call zlib in the normal way (e.g. libpng ++ * 1.5). ++ */ ++int /* PRIVATE */ ++png_zlib_inflate(png_structrp png_ptr, int flush) ++{ ++ if (png_ptr->zstream_start && png_ptr->zstream.avail_in > 0) ++ { ++ if ((*png_ptr->zstream.next_in >> 4) > 7) ++ { ++ png_ptr->zstream.msg = "invalid window size (libpng)"; ++ return Z_DATA_ERROR; ++ } ++ ++ png_ptr->zstream_start = 0; ++ } ++ ++ return inflate(&png_ptr->zstream, flush); ++} ++#endif /* Zlib >= 1.2.4 */ ++ ++#ifdef PNG_READ_COMPRESSED_TEXT_SUPPORTED ++#if defined(PNG_READ_zTXt_SUPPORTED) || defined (PNG_READ_iTXt_SUPPORTED) ++/* 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) ++{ ++ if (png_ptr->zowner == owner) /* Else not claimed */ ++ { ++ 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. + */ ++ 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; +- inflateReset(&png_ptr->zstream); +- +- if (ret == Z_STREAM_END) +- return count; /* NOTE: may be zero. */ ++ png_ptr->zstream.avail_out = 0; + +- /* Now handle the error codes - the API always returns 0 +- * and the error message is dumped into the uncompressed +- * buffer if available. ++ /* 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 + { +- PNG_CONST char *msg; +- if (png_ptr->zstream.msg != 0) +- msg = png_ptr->zstream.msg; +- else +- { +-#if defined(PNG_STDIO_SUPPORTED) && !defined(_WIN32_WCE) +- char umsg[52]; ++ uInt avail; ++ Byte local_buffer[PNG_INFLATE_BUF_SIZE]; + +- switch (ret) +- { +- case Z_BUF_ERROR: +- msg = "Buffer error in compressed datastream in %s chunk"; +- break; +- case Z_DATA_ERROR: +- msg = "Data error in compressed datastream in %s chunk"; +- break; +- default: +- msg = "Incomplete compressed datastream in %s chunk"; +- break; +- } ++ /* 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 */ + +- png_snprintf(umsg, sizeof umsg, msg, png_ptr->chunk_name); +- msg = umsg; +-#else +- msg = "Damaged compressed datastream in chunk other than IDAT"; +-#endif ++ 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) ++ { ++ /* 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); + } + +- png_warning(png_ptr, msg); +- } ++ if (avail_out < avail) ++ avail = (uInt)avail_out; /* safe: < ZLIB_IO_MAX */ ++ ++ png_ptr->zstream.avail_out = avail; ++ avail_out -= avail; + +- /* 0 means an error - notice that this code simple ignores +- * zero length compressed chunks as a result. ++ /* 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 = PNG_INFLATE(png_ptr, 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. + */ +- return 0; ++ 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! ++ */ ++ 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). + */ +-void /* PRIVATE */ +-png_decompress_chunk(png_structp png_ptr, int comp_type, +- png_size_t chunklength, +- png_size_t prefix_size, png_size_t *newlength) ++static 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*/) + { +- /* 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 */ +- } ++ /* 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_USER_LIMITS_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 + +- else if (comp_type == PNG_COMPRESSION_TYPE_BASE) ++ if (limit >= prefix_size + (terminate != 0)) + { +- png_size_t expanded_size = png_inflate(png_ptr, +- (png_bytep)(png_ptr->chunkdata + prefix_size), +- chunklength - prefix_size, +- 0/*output*/, 0/*output size*/); ++ int ret; + +- /* 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"); ++ limit -= prefix_size + (terminate != 0); + +- /* 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 +-#endif +- if (expanded_size > 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) + { +- /* 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); ++ 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 (text != NULL) ++ if (ret == Z_STREAM_END) + { +- 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) ++ /* 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) + { +- png_free(png_ptr, png_ptr->chunkdata); +- png_ptr->chunkdata = text; +- *newlength = prefix_size + expanded_size; +- return; /* The success return! */ ++ /* 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) ++ { ++ memset(text, 0, buffer_size); ++ ++ 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); ++ ++ /* 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); ++ } + } + +- png_warning(png_ptr, "png_inflate logic error"); +- png_free(png_ptr, text); ++ else ++ { ++ /* inflateReset failed, store the error message */ ++ png_zstream_error(png_ptr, ret); ++ ret = PNG_UNEXPECTED_ZLIB_RETURN; ++ } + } +- else +- png_warning(png_ptr, "Not enough memory to decompress chunk."); ++ ++ else if (ret == Z_OK) ++ ret = PNG_UNEXPECTED_ZLIB_RETURN; ++ ++ /* Release the claimed stream */ ++ png_ptr->zowner = 0; + } +- } + +- else /* if (comp_type != PNG_COMPRESSION_TYPE_BASE) */ +- { +-#if defined(PNG_STDIO_SUPPORTED) && !defined(_WIN32_WCE) +- char umsg[50]; ++ else /* the claim failed */ if (ret == Z_STREAM_END) /* impossible! */ ++ ret = PNG_UNEXPECTED_ZLIB_RETURN; + +- png_snprintf(umsg, sizeof umsg, "Unknown zTXt compression type %d", +- comp_type); +- png_warning(png_ptr, umsg); +-#else +- png_warning(png_ptr, "Unknown zTXt compression type"); +-#endif ++ return ret; ++ } + +- /* The recovery is to simply drop the data. */ ++ else ++ { ++ /* Application/configuration limits exceeded */ ++ png_zstream_error(png_ptr, Z_MEM_ERROR); ++ return Z_MEM_ERROR; + } ++} ++#endif /* READ_zTXt || READ_iTXt */ ++#endif /* READ_COMPRESSED_TEXT */ + +- /* Generic error return - leave the prefix, delete the compressed +- * data, reallocate the chunkdata to remove the potentially large +- * amount of compressed data. +- */ ++#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) + { +- png_charp text = png_malloc_warn(png_ptr, prefix_size + 1); +- if (text != NULL) ++ 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 (prefix_size > 0) +- png_memcpy(text, png_ptr->chunkdata, prefix_size); +- png_free(png_ptr, png_ptr->chunkdata); +- png_ptr->chunkdata = text; ++ 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; ++ } + +- /* This is an extra zero in the 'uncompressed' part. */ +- *(png_ptr->chunkdata + prefix_size) = 0x00; ++ /* 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 = PNG_INFLATE(png_ptr, *chunk_bytes > 0 ? ++ Z_NO_FLUSH : (finish ? Z_FINISH : Z_SYNC_FLUSH)); + } +- /* Ignore a malloc error here - it is safe. */ ++ 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; + } + +- *newlength = prefix_size; ++ else ++ { ++ png_ptr->zstream.msg = PNGZ_MSG_CAST("zstream unclaimed"); ++ return Z_STREAM_ERROR; ++ } + } +-#endif ++#endif /* READ_iCCP */ + + /* 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; +@@ -440,12 +845,12 @@ png_handle_IHDR(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) + + 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; + +@@ -474,6 +879,7 @@ png_handle_IHDR(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) + /* Find number of channels */ + switch (png_ptr->color_type) + { ++ default: /* invalid, png_set_IHDR calls png_error */ + case PNG_COLOR_TYPE_GRAY: + case PNG_COLOR_TYPE_PALETTE: + png_ptr->channels = 1; +@@ -493,50 +899,57 @@ png_handle_IHDR(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) + } + + /* 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); +- png_debug1(3, "rowbytes = %lu", png_ptr->rowbytes); ++ png_debug1(3, "rowbytes = %lu", (unsigned long)png_ptr->rowbytes); + png_set_IHDR(png_ptr, info_ptr, width, height, bit_depth, +- color_type, interlace_type, compression_type, filter_type); ++ color_type, interlace_type, compression_type, filter_type); + } + + /* Read and check the palette */ + void /* PRIVATE */ +-png_handle_PLTE(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) ++png_handle_PLTE(png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length) + { + png_color palette[PNG_MAX_PALETTE_LENGTH]; +- int num, i; ++ int max_palette_length, num, i; + #ifdef PNG_POINTER_INDEXING_SUPPORTED + png_colorp pal_ptr; + #endif + + png_debug(1, "in png_handle_PLTE"); + +- if (!(png_ptr->mode & PNG_HAVE_IHDR)) +- png_error(png_ptr, "Missing IHDR before PLTE"); ++ if ((png_ptr->mode & PNG_HAVE_IHDR) == 0) ++ png_chunk_error(png_ptr, "missing IHDR"); + +- else if (png_ptr->mode & PNG_HAVE_IDAT) ++ /* 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; + } ++ + #ifndef PNG_READ_OPT_PLTE_SUPPORTED + if (png_ptr->color_type != PNG_COLOR_TYPE_PALETTE) + { +@@ -547,21 +960,33 @@ png_handle_PLTE(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) + + 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; + ++ /* If the palette has 256 or fewer entries but is too large for the bit ++ * depth, we don't issue an error, to preserve the behavior of previous ++ * libpng versions. We silently truncate the unused extra palette entries ++ * here. ++ */ ++ if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE) ++ max_palette_length = (1 << png_ptr->bit_depth); ++ else ++ max_palette_length = PNG_MAX_PALETTE_LENGTH; ++ ++ if (num > max_palette_length) ++ num = max_palette_length; ++ + #ifdef PNG_POINTER_INDEXING_SUPPORTED + for (i = 0, pal_ptr = palette; i < num; i++, pal_ptr++) + { +@@ -585,7 +1010,7 @@ png_handle_PLTE(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) + } + #endif + +- /* If we actually NEED the PLTE chunk (ie for a paletted image), we do ++ /* If we actually need the PLTE chunk (ie for a paletted image), we do + * whatever the normal CRC configuration tells us. However, if we + * have an RGB image, the PLTE can be considered ancillary, so + * we will act as though it is. +@@ -594,214 +1019,209 @@ png_handle_PLTE(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) + if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE) + #endif + { +- png_crc_finish(png_ptr, 0); ++ png_crc_finish(png_ptr, (png_uint_32) (length - (unsigned int)num * 3)); + } ++ + #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). */ +- if (!(png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_USE)) ++ * 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) == 0) + { +- if (png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_NOWARN) +- { +- png_chunk_error(png_ptr, "CRC error"); +- } +- else +- { +- png_chunk_warning(png_ptr, "CRC error"); ++ if ((png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_NOWARN) != 0) + return; +- } ++ ++ else ++ 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); + +- if (length != 0) +- { +- png_warning(png_ptr, "Incorrect IEND chunk length"); +- } + png_crc_finish(png_ptr, length); + +- info_ptr = info_ptr; /* Quiet compiler warnings about unused info_ptr */ ++ if (length != 0) ++ 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; +-#ifdef PNG_FLOATING_POINT_SUPPORTED +- float file_gamma; +-#endif + png_byte buf[4]; + + png_debug(1, "in png_handle_gAMA"); + +- if (!(png_ptr->mode & PNG_HAVE_IHDR)) +- png_error(png_ptr, "Missing IHDR before gAMA"); +- else if (png_ptr->mode & PNG_HAVE_IDAT) +- { +- png_warning(png_ptr, "Invalid gAMA after IDAT"); +- png_crc_finish(png_ptr, length); +- return; +- } +- else if (png_ptr->mode & PNG_HAVE_PLTE) +- /* Should be an error, but we can cope with it */ +- png_warning(png_ptr, "Out of place gAMA chunk"); ++ if ((png_ptr->mode & PNG_HAVE_IHDR) == 0) ++ png_chunk_error(png_ptr, "missing IHDR"); + +- if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_gAMA) +-#ifdef PNG_READ_sRGB_SUPPORTED +- && !(info_ptr->valid & PNG_INFO_sRGB) +-#endif +- ) ++ else if ((png_ptr->mode & (PNG_HAVE_IDAT|PNG_HAVE_PLTE)) != 0) + { +- png_warning(png_ptr, "Duplicate gAMA chunk"); + png_crc_finish(png_ptr, length); ++ png_chunk_benign_error(png_ptr, "out of place"); + return; + } + + if (length != 4) + { +- png_warning(png_ptr, "Incorrect gAMA chunk length"); + 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)) +- return; + +- igamma = (png_fixed_point)png_get_uint_32(buf); +- /* Check for zero gamma */ +- if (igamma == 0) +- { +- png_warning(png_ptr, +- "Ignoring gAMA chunk with gamma=0"); +- return; +- } ++ if (png_crc_finish(png_ptr, 0) != 0) ++ return; + +-#ifdef PNG_READ_sRGB_SUPPORTED +- if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_sRGB)) +- if (PNG_OUT_OF_RANGE(igamma, 45500L, 500)) +- { +- png_warning(png_ptr, +- "Ignoring incorrect gAMA value when sRGB is also present"); +-#ifdef PNG_CONSOLE_IO_SUPPORTED +- fprintf(stderr, "gamma = (%d/100000)", (int)igamma); +-#endif +- return; +- } +-#endif /* PNG_READ_sRGB_SUPPORTED */ ++ igamma = png_get_fixed_point(NULL, buf); + +-#ifdef PNG_FLOATING_POINT_SUPPORTED +- file_gamma = (float)igamma / (float)100000.0; +-# ifdef PNG_READ_GAMMA_SUPPORTED +- png_ptr->gamma = file_gamma; +-# endif +- png_set_gAMA(png_ptr, info_ptr, file_gamma); +-#endif +-#ifdef PNG_FIXED_POINT_SUPPORTED +- png_set_gAMA_fixed(png_ptr, info_ptr, igamma); +-#endif ++ 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_structp png_ptr, png_infop info_ptr, png_uint_32 length) ++png_handle_sBIT(png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length) + { +- png_size_t truelen; ++ unsigned int truelen, i; ++ png_byte sample_depth; + 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) == 0) ++ png_chunk_error(png_ptr, "missing IHDR"); + +- if (!(png_ptr->mode & PNG_HAVE_IHDR)) +- png_error(png_ptr, "Missing IHDR before sBIT"); +- else if (png_ptr->mode & PNG_HAVE_IDAT) ++ else if ((png_ptr->mode & (PNG_HAVE_IDAT|PNG_HAVE_PLTE)) != 0) + { +- png_warning(png_ptr, "Invalid sBIT 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) +- { +- /* 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)) ++ ++ if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_sBIT) != 0) + { +- png_warning(png_ptr, "Duplicate sBIT chunk"); + 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_size_t)png_ptr->channels; ++ { ++ truelen = png_ptr->channels; ++ sample_depth = png_ptr->bit_depth; ++ } + + if (length != truelen || length > 4) + { +- png_warning(png_ptr, "Incorrect sBIT chunk length"); ++ png_chunk_benign_error(png_ptr, "invalid"); + png_crc_finish(png_ptr, length); + return; + } + ++ buf[0] = buf[1] = buf[2] = buf[3] = sample_depth; + png_crc_read(png_ptr, buf, truelen); +- if (png_crc_finish(png_ptr, 0)) ++ ++ if (png_crc_finish(png_ptr, 0) != 0) + return; + +- if (png_ptr->color_type & PNG_COLOR_MASK_COLOR) ++ for (i=0; i sample_depth) ++ { ++ png_chunk_benign_error(png_ptr, "invalid"); ++ return; ++ } ++ } ++ ++ if ((png_ptr->color_type & PNG_COLOR_MASK_COLOR) != 0) + { + png_ptr->sig_bit.red = buf[0]; + png_ptr->sig_bit.green = buf[1]; + png_ptr->sig_bit.blue = buf[2]; + png_ptr->sig_bit.alpha = buf[3]; + } ++ + else + { + png_ptr->sig_bit.gray = buf[0]; +@@ -810,372 +1230,428 @@ png_handle_sBIT(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) + png_ptr->sig_bit.blue = buf[0]; + png_ptr->sig_bit.alpha = buf[1]; + } ++ + png_set_sBIT(png_ptr, info_ptr, &(png_ptr->sig_bit)); + } + #endif + + #ifdef PNG_READ_cHRM_SUPPORTED + void /* PRIVATE */ +-png_handle_cHRM(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) ++png_handle_cHRM(png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length) + { + png_byte buf[32]; +-#ifdef PNG_FLOATING_POINT_SUPPORTED +- float white_x, white_y, red_x, red_y, green_x, green_y, blue_x, blue_y; +-#endif +- png_fixed_point int_x_white, int_y_white, int_x_red, int_y_red, int_x_green, +- int_y_green, int_x_blue, int_y_blue; +- +- png_uint_32 uint_x, uint_y; ++ png_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) +- { +- png_warning(png_ptr, "Invalid cHRM after IDAT"); +- png_crc_finish(png_ptr, length); +- return; +- } +- else if (png_ptr->mode & PNG_HAVE_PLTE) +- /* Should be an error, but we can cope with it */ +- png_warning(png_ptr, "Missing PLTE before cHRM"); ++ if ((png_ptr->mode & PNG_HAVE_IHDR) == 0) ++ png_chunk_error(png_ptr, "missing IHDR"); + +- if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_cHRM) +-#ifdef PNG_READ_sRGB_SUPPORTED +- && !(info_ptr->valid & PNG_INFO_sRGB) +-#endif +- ) ++ else if ((png_ptr->mode & (PNG_HAVE_IDAT|PNG_HAVE_PLTE)) != 0) + { +- png_warning(png_ptr, "Duplicate cHRM chunk"); + png_crc_finish(png_ptr, length); ++ png_chunk_benign_error(png_ptr, "out of place"); + return; + } + + if (length != 32) + { +- png_warning(png_ptr, "Incorrect cHRM chunk length"); + 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)) +- return; +- +- uint_x = png_get_uint_32(buf); +- uint_y = png_get_uint_32(buf + 4); +- int_x_white = (png_fixed_point)uint_x; +- int_y_white = (png_fixed_point)uint_y; +- +- uint_x = png_get_uint_32(buf + 8); +- uint_y = png_get_uint_32(buf + 12); +- int_x_red = (png_fixed_point)uint_x; +- int_y_red = (png_fixed_point)uint_y; +- +- uint_x = png_get_uint_32(buf + 16); +- uint_y = png_get_uint_32(buf + 20); +- int_x_green = (png_fixed_point)uint_x; +- int_y_green = (png_fixed_point)uint_y; +- +- uint_x = png_get_uint_32(buf + 24); +- uint_y = png_get_uint_32(buf + 28); +- int_x_blue = (png_fixed_point)uint_x; +- int_y_blue = (png_fixed_point)uint_y; +- +-#ifdef PNG_FLOATING_POINT_SUPPORTED +- white_x = (float)int_x_white / (float)100000.0; +- white_y = (float)int_y_white / (float)100000.0; +- red_x = (float)int_x_red / (float)100000.0; +- red_y = (float)int_y_red / (float)100000.0; +- green_x = (float)int_x_green / (float)100000.0; +- green_y = (float)int_y_green / (float)100000.0; +- blue_x = (float)int_x_blue / (float)100000.0; +- blue_y = (float)int_y_blue / (float)100000.0; +-#endif + +-#ifdef PNG_READ_sRGB_SUPPORTED +- if ((info_ptr != NULL) && (info_ptr->valid & PNG_INFO_sRGB)) +- { +- if (PNG_OUT_OF_RANGE(int_x_white, 31270, 1000) || +- PNG_OUT_OF_RANGE(int_y_white, 32900, 1000) || +- PNG_OUT_OF_RANGE(int_x_red, 64000L, 1000) || +- PNG_OUT_OF_RANGE(int_y_red, 33000, 1000) || +- PNG_OUT_OF_RANGE(int_x_green, 30000, 1000) || +- PNG_OUT_OF_RANGE(int_y_green, 60000L, 1000) || +- PNG_OUT_OF_RANGE(int_x_blue, 15000, 1000) || +- PNG_OUT_OF_RANGE(int_y_blue, 6000, 1000)) +- { +- png_warning(png_ptr, +- "Ignoring incorrect cHRM value when sRGB is also present"); +-#ifdef PNG_CONSOLE_IO_SUPPORTED +-#ifdef PNG_FLOATING_POINT_SUPPORTED +- fprintf(stderr, "wx=%f, wy=%f, rx=%f, ry=%f\n", +- white_x, white_y, red_x, red_y); +- fprintf(stderr, "gx=%f, gy=%f, bx=%f, by=%f\n", +- green_x, green_y, blue_x, blue_y); +-#else +- fprintf(stderr, "wx=%ld, wy=%ld, rx=%ld, ry=%ld\n", +- (long)int_x_white, (long)int_y_white, +- (long)int_x_red, (long)int_y_red); +- fprintf(stderr, "gx=%ld, gy=%ld, bx=%ld, by=%ld\n", +- (long)int_x_green, (long)int_y_green, +- (long)int_x_blue, (long)int_y_blue); +-#endif +-#endif /* PNG_CONSOLE_IO_SUPPORTED */ +- } +- return; +- } +-#endif /* PNG_READ_sRGB_SUPPORTED */ ++ if (png_crc_finish(png_ptr, 0) != 0) ++ return; + +-#ifdef PNG_FLOATING_POINT_SUPPORTED +- png_set_cHRM(png_ptr, info_ptr, +- white_x, white_y, red_x, red_y, green_x, green_y, blue_x, blue_y); +-#endif +-#ifdef PNG_FIXED_POINT_SUPPORTED +- png_set_cHRM_fixed(png_ptr, info_ptr, +- int_x_white, int_y_white, int_x_red, int_y_red, int_x_green, +- int_y_green, int_x_blue, int_y_blue); +-#endif ++ 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_structp png_ptr, png_infop info_ptr, png_uint_32 length) ++png_handle_sRGB(png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length) + { +- int intent; +- png_byte buf[1]; ++ png_byte intent; + + 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 ((png_ptr->mode & PNG_HAVE_IHDR) == 0) ++ png_chunk_error(png_ptr, "missing IHDR"); + +- if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_sRGB)) ++ else if ((png_ptr->mode & (PNG_HAVE_IDAT|PNG_HAVE_PLTE)) != 0) + { +- png_warning(png_ptr, "Duplicate sRGB chunk"); + png_crc_finish(png_ptr, length); ++ png_chunk_benign_error(png_ptr, "out of place"); + return; + } + + if (length != 1) + { +- png_warning(png_ptr, "Incorrect sRGB chunk length"); + png_crc_finish(png_ptr, length); ++ png_chunk_benign_error(png_ptr, "invalid"); + return; + } + +- png_crc_read(png_ptr, buf, 1); +- if (png_crc_finish(png_ptr, 0)) ++ png_crc_read(png_ptr, &intent, 1); ++ ++ if (png_crc_finish(png_ptr, 0) != 0) + return; + +- intent = buf[0]; +- /* Check for bad intent */ +- if (intent >= PNG_sRGB_INTENT_LAST) +- { +- png_warning(png_ptr, "Unknown sRGB intent"); ++ /* If a colorspace error has already been output skip this chunk */ ++ if ((png_ptr->colorspace.flags & PNG_COLORSPACE_INVALID) != 0) + return; +- } + +-#if defined(PNG_READ_gAMA_SUPPORTED) && defined(PNG_READ_GAMMA_SUPPORTED) +- if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_gAMA)) ++ /* 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_fixed_point igamma; +-#ifdef PNG_FIXED_POINT_SUPPORTED +- igamma=info_ptr->int_gamma; +-#else +-# ifdef PNG_FLOATING_POINT_SUPPORTED +- igamma=(png_fixed_point)(info_ptr->gamma * 100000.); +-# endif +-#endif +- if (PNG_OUT_OF_RANGE(igamma, 45500L, 500)) +- { +- png_warning(png_ptr, +- "Ignoring incorrect gAMA value when sRGB is also present"); +-#ifdef PNG_CONSOLE_IO_SUPPORTED +-# ifdef PNG_FIXED_POINT_SUPPORTED +- fprintf(stderr, "incorrect gamma=(%d/100000)\n", +- (int)png_ptr->int_gamma); +-# else +-# ifdef PNG_FLOATING_POINT_SUPPORTED +- fprintf(stderr, "incorrect gamma=%f\n", png_ptr->gamma); +-# endif +-# endif +-#endif +- } ++ png_ptr->colorspace.flags |= PNG_COLORSPACE_INVALID; ++ png_colorspace_sync(png_ptr, info_ptr); ++ png_chunk_benign_error(png_ptr, "too many profiles"); ++ return; + } +-#endif /* PNG_READ_gAMA_SUPPORTED */ +- +-#ifdef PNG_READ_cHRM_SUPPORTED +-#ifdef PNG_FIXED_POINT_SUPPORTED +- if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_cHRM)) +- if (PNG_OUT_OF_RANGE(info_ptr->int_x_white, 31270, 1000) || +- PNG_OUT_OF_RANGE(info_ptr->int_y_white, 32900, 1000) || +- PNG_OUT_OF_RANGE(info_ptr->int_x_red, 64000L, 1000) || +- PNG_OUT_OF_RANGE(info_ptr->int_y_red, 33000, 1000) || +- PNG_OUT_OF_RANGE(info_ptr->int_x_green, 30000, 1000) || +- PNG_OUT_OF_RANGE(info_ptr->int_y_green, 60000L, 1000) || +- PNG_OUT_OF_RANGE(info_ptr->int_x_blue, 15000, 1000) || +- PNG_OUT_OF_RANGE(info_ptr->int_y_blue, 6000, 1000)) +- { +- png_warning(png_ptr, +- "Ignoring incorrect cHRM value when sRGB is also present"); +- } +-#endif /* PNG_FIXED_POINT_SUPPORTED */ +-#endif /* PNG_READ_cHRM_SUPPORTED */ + +- png_set_sRGB_gAMA_and_cHRM(png_ptr, info_ptr, intent); ++ (void)png_colorspace_set_sRGB(png_ptr, &png_ptr->colorspace, intent); ++ png_colorspace_sync(png_ptr, info_ptr); + } +-#endif /* PNG_READ_sRGB_SUPPORTED */ ++#endif /* READ_sRGB */ + + #ifdef PNG_READ_iCCP_SUPPORTED + void /* PRIVATE */ +-png_handle_iCCP(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) +-/* Note: this does not properly handle chunks that are > 64K under DOS */ ++png_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_byte compression_type; +- png_bytep pC; +- png_charp profile; +- png_uint_32 skip = 0; +- png_uint_32 profile_size, profile_length; +- png_size_t slength, prefix_length, data_length; ++ png_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)) +- png_error(png_ptr, "Missing IHDR before iCCP"); +- 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 iCCP 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) +- /* 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)) ++ /* 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 keyword must be at least one character and there is a ++ * terminator (0) byte and the compression method byte, and the ++ * 'zlib' datastream is at least 11 bytes. ++ */ ++ if (length < 14) + { +- png_warning(png_ptr, "Duplicate iCCP chunk"); + png_crc_finish(png_ptr, length); ++ png_chunk_benign_error(png_ptr, "too short"); + return; + } + +-#ifdef PNG_MAX_MALLOC_64K +- if (length > (png_uint_32)65535L) ++ /* If a colorspace error has already been output skip this chunk */ ++ if ((png_ptr->colorspace.flags & PNG_COLORSPACE_INVALID) != 0) + { +- png_warning(png_ptr, "iCCP chunk too large to fit in memory"); +- skip = length - (png_uint_32)65535L; +- length = (png_uint_32)65535L; ++ png_crc_finish(png_ptr, length); ++ return; + } +-#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)) ++ /* 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_free(png_ptr, png_ptr->chunkdata); +- png_ptr->chunkdata = NULL; +- return; +- } ++ uInt read_length, keyword_length; ++ char keyword[81]; + +- png_ptr->chunkdata[slength] = 0x00; ++ /* 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; + +- for (profile = png_ptr->chunkdata; *profile; profile++) +- /* Empty loop to find end of name */ ; ++ png_crc_read(png_ptr, (png_bytep)keyword, read_length); ++ length -= read_length; + +- ++profile; ++ /* The minimum 'zlib' stream is assumed to be just the 2 byte header, ++ * 5 bytes minimum 'deflate' stream, and the 4 byte checksum. ++ */ ++ if (length < 11) ++ { ++ png_crc_finish(png_ptr, length); ++ png_chunk_benign_error(png_ptr, "too short"); ++ return; ++ } + +- /* 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; +- } ++ keyword_length = 0; ++ while (keyword_length < 80 && keyword_length < read_length && ++ keyword[keyword_length] != 0) ++ ++keyword_length; + +- /* 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) */ +- } ++ /* 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; + +- prefix_length = profile - png_ptr->chunkdata; +- png_decompress_chunk(png_ptr, compression_type, +- slength, prefix_length, &data_length); ++ if (png_inflate_claim(png_ptr, png_iCCP) == Z_OK) ++ { ++ Byte profile_header[132]={0}; ++ Byte local_buffer[PNG_INFLATE_BUF_SIZE]; ++ png_alloc_size_t size = (sizeof profile_header); + +- profile_length = data_length - prefix_length; ++ 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 ( 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; +- } ++ if (size == 0) ++ { ++ /* We have the ICC profile header; do the basic header checks. ++ */ ++ png_uint_32 profile_length = png_get_uint_32(profile_header); + +- /* Check the profile_size recorded in the first 32 bits of the ICC profile */ +- pC = (png_bytep)(png_ptr->chunkdata + prefix_length); +- profile_size = ((*(pC ))<<24) | +- ((*(pC + 1))<<16) | +- ((*(pC + 2))<< 8) | +- ((*(pC + 3)) ); ++ if (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 this stuff will overflow. ++ */ ++ 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; ++ ++# if defined(PNG_sRGB_SUPPORTED) && PNG_sRGB_PROFILE_CHECKS >= 0 ++ /* 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; ++ } ++ } ++ if (errmsg == NULL) ++ 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 */ ++ } + +- if (profile_size < profile_length) +- profile_length = profile_size; ++ /* else png_icc_check_length output an error */ ++ } + +- if (profile_size > profile_length) +- { +- png_free(png_ptr, png_ptr->chunkdata); +- png_ptr->chunkdata = NULL; +- png_warning(png_ptr, "Ignoring truncated iCCP profile."); +- return; ++ 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"; + } + +- png_set_iCCP(png_ptr, info_ptr, png_ptr->chunkdata, +- compression_type, png_ptr->chunkdata + prefix_length, profile_length); +- png_free(png_ptr, png_ptr->chunkdata); +- png_ptr->chunkdata = NULL; ++ else ++ errmsg = "too many profiles"; ++ ++ /* Failure: the reason is in 'errmsg' */ ++ if (finished == 0) ++ png_crc_finish(png_ptr, length); ++ ++ 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 /* PNG_READ_iCCP_SUPPORTED */ ++#endif /* READ_iCCP */ + + #ifdef PNG_READ_sPLT_SUPPORTED + void /* PRIVATE */ +-png_handle_sPLT(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_bytep entry_start; ++ png_bytep entry_start, buffer; + png_sPLT_t new_palette; +-#ifdef PNG_POINTER_INDEXING_SUPPORTED + png_sPLT_entryp pp; +-#endif +- int data_length, entry_size, i; ++ png_uint_32 data_length; ++ int entry_size, i; + png_uint_32 skip = 0; +- png_size_t slength; ++ png_uint_32 dl; ++ 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) +@@ -1183,6 +1659,7 @@ png_handle_sPLT(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) + png_crc_finish(png_ptr, length); + return; + } ++ + if (--png_ptr->user_chunk_cache_max == 1) + { + png_warning(png_ptr, "No space in chunk cache for sPLT"); +@@ -1192,78 +1669,89 @@ png_handle_sPLT(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) + } + #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); +- slength = (png_size_t)length; +- png_crc_read(png_ptr, (png_bytep)png_ptr->chunkdata, slength); +- +- if (png_crc_finish(png_ptr, skip)) ++ buffer = png_read_buffer(png_ptr, length+1, 2/*silent*/); ++ if (buffer == NULL) + { +- png_free(png_ptr, png_ptr->chunkdata); +- png_ptr->chunkdata = NULL; ++ png_crc_finish(png_ptr, length); ++ png_chunk_benign_error(png_ptr, "out of memory"); + return; + } + +- png_ptr->chunkdata[slength] = 0x00; + +- for (entry_start = (png_bytep)png_ptr->chunkdata; *entry_start; +- entry_start++) ++ /* 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. ++ */ ++ 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 > (png_bytep)png_ptr->chunkdata + slength - 2) ++ if (length < 2U || entry_start > buffer + (length - 2U)) + { +- png_free(png_ptr, png_ptr->chunkdata); +- png_ptr->chunkdata = NULL; + png_warning(png_ptr, "malformed sPLT chunk"); + return; + } + + new_palette.depth = *entry_start++; + entry_size = (new_palette.depth == 8 ? 6 : 10); +- data_length = (slength - (entry_start - (png_bytep)png_ptr->chunkdata)); ++ /* This must fit in a png_uint_32 because it is derived from the original ++ * chunk data length. ++ */ ++ data_length = length - (png_uint_32)(entry_start - buffer); + + /* Integrity-check the data length */ +- if (data_length % entry_size) ++ if ((data_length % (unsigned int)entry_size) != 0) + { +- png_free(png_ptr, png_ptr->chunkdata); +- png_ptr->chunkdata = NULL; + png_warning(png_ptr, "sPLT chunk has bad length"); + return; + } + +- new_palette.nentries = (png_int_32) ( data_length / entry_size); +- if ((png_uint_32) new_palette.nentries > +- (png_uint_32) (PNG_SIZE_MAX / png_sizeof(png_sPLT_entry))) ++ dl = (png_uint_32)(data_length / (unsigned int)entry_size); ++ max_dl = PNG_SIZE_MAX / (sizeof (png_sPLT_entry)); ++ ++ if (dl > max_dl) + { +- png_warning(png_ptr, "sPLT chunk too long"); +- return; ++ png_warning(png_ptr, "sPLT chunk too long"); ++ return; + } +- new_palette.entries = (png_sPLT_entryp)png_malloc_warn( +- png_ptr, new_palette.nentries * png_sizeof(png_sPLT_entry)); ++ ++ new_palette.nentries = (png_int_32)(data_length / (unsigned int)entry_size); ++ ++ new_palette.entries = (png_sPLT_entryp)png_malloc_warn(png_ptr, ++ (png_alloc_size_t) new_palette.nentries * (sizeof (png_sPLT_entry))); ++ + if (new_palette.entries == NULL) + { +- png_warning(png_ptr, "sPLT chunk requires too much memory"); +- return; ++ png_warning(png_ptr, "sPLT chunk requires too much memory"); ++ return; + } + + #ifdef PNG_POINTER_INDEXING_SUPPORTED +@@ -1273,74 +1761,79 @@ png_handle_sPLT(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) + + if (new_palette.depth == 8) + { +- pp->red = *entry_start++; +- pp->green = *entry_start++; +- pp->blue = *entry_start++; +- pp->alpha = *entry_start++; ++ pp->red = *entry_start++; ++ pp->green = *entry_start++; ++ pp->blue = *entry_start++; ++ pp->alpha = *entry_start++; + } ++ + else + { +- pp->red = png_get_uint_16(entry_start); entry_start += 2; +- pp->green = png_get_uint_16(entry_start); entry_start += 2; +- pp->blue = png_get_uint_16(entry_start); entry_start += 2; +- pp->alpha = png_get_uint_16(entry_start); entry_start += 2; ++ pp->red = png_get_uint_16(entry_start); entry_start += 2; ++ pp->green = png_get_uint_16(entry_start); entry_start += 2; ++ pp->blue = png_get_uint_16(entry_start); entry_start += 2; ++ pp->alpha = png_get_uint_16(entry_start); entry_start += 2; + } ++ + pp->frequency = png_get_uint_16(entry_start); entry_start += 2; + } + #else + pp = new_palette.entries; ++ + for (i = 0; i < new_palette.nentries; i++) + { + + if (new_palette.depth == 8) + { +- pp[i].red = *entry_start++; +- pp[i].green = *entry_start++; +- pp[i].blue = *entry_start++; +- pp[i].alpha = *entry_start++; ++ pp[i].red = *entry_start++; ++ pp[i].green = *entry_start++; ++ pp[i].blue = *entry_start++; ++ pp[i].alpha = *entry_start++; + } ++ + else + { +- pp[i].red = png_get_uint_16(entry_start); entry_start += 2; +- pp[i].green = png_get_uint_16(entry_start); entry_start += 2; +- pp[i].blue = png_get_uint_16(entry_start); entry_start += 2; +- pp[i].alpha = png_get_uint_16(entry_start); entry_start += 2; ++ pp[i].red = png_get_uint_16(entry_start); entry_start += 2; ++ pp[i].green = png_get_uint_16(entry_start); entry_start += 2; ++ pp[i].blue = png_get_uint_16(entry_start); entry_start += 2; ++ pp[i].alpha = png_get_uint_16(entry_start); entry_start += 2; + } +- pp->frequency = png_get_uint_16(entry_start); entry_start += 2; ++ ++ pp[i].frequency = png_get_uint_16(entry_start); entry_start += 2; + } + #endif + + /* Discard all chunk data except the name and stash that */ +- new_palette.name = png_ptr->chunkdata; ++ 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; + } + +@@ -1350,197 +1843,294 @@ png_handle_tRNS(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) + + 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; + } + + png_crc_read(png_ptr, buf, 2); + png_ptr->num_trans = 1; +- png_ptr->trans_values.gray = png_get_uint_16(buf); ++ png_ptr->trans_color.gray = png_get_uint_16(buf); + } ++ + else if (png_ptr->color_type == PNG_COLOR_TYPE_RGB) + { + png_byte buf[6]; + + if (length != 6) + { +- png_warning(png_ptr, "Incorrect tRNS chunk length"); + png_crc_finish(png_ptr, length); ++ 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_values.red = png_get_uint_16(buf); +- png_ptr->trans_values.green = png_get_uint_16(buf + 2); +- png_ptr->trans_values.blue = png_get_uint_16(buf + 4); ++ png_ptr->trans_color.red = png_get_uint_16(buf); ++ png_ptr->trans_color.green = png_get_uint_16(buf + 2); ++ png_ptr->trans_color.blue = png_get_uint_16(buf + 4); + } ++ + else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE) + { +- if (!(png_ptr->mode & PNG_HAVE_PLTE)) +- { +- /* Should be an error, but we can cope with it. */ +- png_warning(png_ptr, "Missing PLTE before tRNS"); +- } +- if (length > (png_uint_32)png_ptr->num_palette || +- length > PNG_MAX_PALETTE_LENGTH) ++ if ((png_ptr->mode & PNG_HAVE_PLTE) == 0) + { +- 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 > (unsigned int) png_ptr->num_palette || ++ length > (unsigned int) 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_values)); ++ &(png_ptr->trans_color)); + } + #endif + + #ifdef PNG_READ_bKGD_SUPPORTED + void /* PRIVATE */ +-png_handle_bKGD(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) ++png_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) +- { +- png_warning(png_ptr, "Invalid bKGD after IDAT"); +- png_crc_finish(png_ptr, length); +- return; +- } +- else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE && +- !(png_ptr->mode & PNG_HAVE_PLTE)) ++ 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, "Missing PLTE before bKGD"); + 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_bKGD)) ++ ++ else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_bKGD) != 0) + { +- png_warning(png_ptr, "Duplicate bKGD chunk"); + png_crc_finish(png_ptr, length); ++ png_chunk_benign_error(png_ptr, "duplicate"); + return; + } + + if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE) + truelen = 1; +- else if (png_ptr->color_type & PNG_COLOR_MASK_COLOR) ++ ++ else if ((png_ptr->color_type & PNG_COLOR_MASK_COLOR) != 0) + truelen = 6; ++ + else + truelen = 2; + + if (length != truelen) + { +- png_warning(png_ptr, "Incorrect bKGD chunk length"); + png_crc_finish(png_ptr, length); ++ png_chunk_benign_error(png_ptr, "invalid"); + 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 + * arbitrary RGB values for background when we have transparency, and + * so it is easy to determine the RGB values of the background color +- * from the info_ptr struct. */ ++ * from the info_ptr struct. ++ */ + if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE) + { +- png_ptr->background.index = buf[0]; +- if (info_ptr && info_ptr->num_palette) +- { +- if (buf[0] >= info_ptr->num_palette) +- { +- png_warning(png_ptr, "Incorrect bKGD chunk index value"); +- return; +- } +- png_ptr->background.red = +- (png_uint_16)png_ptr->palette[buf[0]].red; +- png_ptr->background.green = +- (png_uint_16)png_ptr->palette[buf[0]].green; +- png_ptr->background.blue = +- (png_uint_16)png_ptr->palette[buf[0]].blue; ++ background.index = buf[0]; ++ ++ if (info_ptr != NULL && info_ptr->num_palette != 0) ++ { ++ if (buf[0] >= info_ptr->num_palette) ++ { ++ png_chunk_benign_error(png_ptr, "invalid index"); ++ return; ++ } ++ ++ background.red = (png_uint_16)png_ptr->palette[buf[0]].red; ++ background.green = (png_uint_16)png_ptr->palette[buf[0]].green; ++ background.blue = (png_uint_16)png_ptr->palette[buf[0]].blue; + } ++ ++ else ++ background.red = background.green = background.blue = 0; ++ ++ 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 */ + { +- png_ptr->background.red = +- png_ptr->background.green = +- png_ptr->background.blue = +- png_ptr->background.gray = png_get_uint_16(buf); ++ if (png_ptr->bit_depth <= 8) ++ { ++ if (buf[0] != 0 || buf[1] >= (unsigned int)(1 << png_ptr->bit_depth)) ++ { ++ png_chunk_benign_error(png_ptr, "invalid gray level"); ++ return; ++ } ++ } ++ ++ background.index = 0; ++ background.red = ++ background.green = ++ background.blue = ++ background.gray = png_get_uint_16(buf); + } ++ + else + { +- png_ptr->background.red = png_get_uint_16(buf); +- png_ptr->background.green = png_get_uint_16(buf + 2); +- png_ptr->background.blue = png_get_uint_16(buf + 4); ++ if (png_ptr->bit_depth <= 8) ++ { ++ if (buf[0] != 0 || buf[2] != 0 || buf[4] != 0) ++ { ++ png_chunk_benign_error(png_ptr, "invalid color"); ++ return; ++ } ++ } ++ ++ background.index = 0; ++ background.red = png_get_uint_16(buf); ++ background.green = png_get_uint_16(buf + 2); ++ background.blue = png_get_uint_16(buf + 4); ++ background.gray = 0; + } + +- png_set_bKGD(png_ptr, info_ptr, &(png_ptr->background)); ++ png_set_bKGD(png_ptr, info_ptr, &background); + } + #endif + +-#ifdef PNG_READ_hIST_SUPPORTED ++#ifdef PNG_READ_eXIf_SUPPORTED + void /* PRIVATE */ +-png_handle_hIST(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) ++png_handle_eXIf(png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length) + { +- unsigned int num, i; +- png_uint_16 readbuf[PNG_MAX_PALETTE_LENGTH]; ++ unsigned int i; + +- png_debug(1, "in png_handle_hIST"); ++ png_debug(1, "in png_handle_eXIf"); ++ ++ if ((png_ptr->mode & PNG_HAVE_IHDR) == 0) ++ png_chunk_error(png_ptr, "missing IHDR"); + +- if (!(png_ptr->mode & PNG_HAVE_IHDR)) +- png_error(png_ptr, "Missing IHDR before hIST"); +- else if (png_ptr->mode & PNG_HAVE_IDAT) ++ if (length < 2) + { +- png_warning(png_ptr, "Invalid hIST after IDAT"); + png_crc_finish(png_ptr, length); ++ png_chunk_benign_error(png_ptr, "too short"); + return; + } +- else if (!(png_ptr->mode & PNG_HAVE_PLTE)) ++ ++ else if (info_ptr == NULL || (info_ptr->valid & PNG_INFO_eXIf) != 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)) ++ ++ info_ptr->free_me |= PNG_FREE_EXIF; ++ ++ info_ptr->eXIf_buf = png_voidcast(png_bytep, ++ png_malloc_warn(png_ptr, length)); ++ ++ if (info_ptr->eXIf_buf == NULL) + { +- png_warning(png_ptr, "Duplicate hIST chunk"); + png_crc_finish(png_ptr, length); ++ png_chunk_benign_error(png_ptr, "out of memory"); ++ return; ++ } ++ ++ for (i = 0; i < length; i++) ++ { ++ png_byte buf[1]; ++ png_crc_read(png_ptr, buf, 1); ++ info_ptr->eXIf_buf[i] = buf[0]; ++ if (i == 1 && buf[0] != 'M' && buf[0] != 'I' ++ && info_ptr->eXIf_buf[0] != buf[0]) ++ { ++ png_crc_finish(png_ptr, length); ++ png_chunk_benign_error(png_ptr, "incorrect byte-order specifier"); ++ png_free(png_ptr, info_ptr->eXIf_buf); ++ info_ptr->eXIf_buf = NULL; ++ return; ++ } ++ } ++ ++ if (png_crc_finish(png_ptr, 0) != 0) ++ return; ++ ++ png_set_eXIf_1(png_ptr, info_ptr, length, info_ptr->eXIf_buf); ++ ++ png_free(png_ptr, info_ptr->eXIf_buf); ++ info_ptr->eXIf_buf = NULL; ++} ++#endif ++ ++#ifdef PNG_READ_hIST_SUPPORTED ++void /* PRIVATE */ ++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) == 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_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_hIST) != 0) ++ { ++ png_crc_finish(png_ptr, length); ++ png_chunk_benign_error(png_ptr, "duplicate"); + return; + } + + num = length / 2 ; +- if (num != (unsigned int) png_ptr->num_palette || num > +- (unsigned int) PNG_MAX_PALETTE_LENGTH) ++ ++ 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; + } + +@@ -1552,7 +2142,7 @@ png_handle_hIST(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) + 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); +@@ -1561,7 +2151,7 @@ png_handle_hIST(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) + + #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; +@@ -1569,30 +2159,33 @@ png_handle_pHYs(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) + + 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); +@@ -1604,7 +2197,7 @@ png_handle_pHYs(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) + + #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; +@@ -1612,30 +2205,33 @@ png_handle_oFFs(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) + + 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); +@@ -1648,66 +2244,64 @@ png_handle_oFFs(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) + #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 (%lu bytes)", +- length + 1); +- png_free(png_ptr, png_ptr->chunkdata); +- png_ptr->chunkdata = (png_charp)png_malloc_warn(png_ptr, length + 1); +- if (png_ptr->chunkdata == NULL) +- { +- png_warning(png_ptr, "No memory for pCAL purpose."); +- return; +- } +- slength = (png_size_t)length; +- png_crc_read(png_ptr, (png_bytep)png_ptr->chunkdata, slength); ++ png_debug1(2, "Allocating and reading pCAL chunk data (%u bytes)", ++ length + 1); ++ ++ buffer = png_read_buffer(png_ptr, length+1, 2/*silent*/); + +- if (png_crc_finish(png_ptr, 0)) ++ if (buffer == NULL) + { +- png_free(png_ptr, png_ptr->chunkdata); +- png_ptr->chunkdata = NULL; ++ png_crc_finish(png_ptr, length); ++ png_chunk_benign_error(png_ptr, "out of memory"); + return; + } + +- png_ptr->chunkdata[slength] = 0x00; /* Null terminate the last string */ ++ png_crc_read(png_ptr, buffer, length); ++ ++ if (png_crc_finish(png_ptr, 0) != 0) ++ return; ++ ++ 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) ++ * 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; + } + +@@ -1720,61 +2314,58 @@ png_handle_pCAL(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) + + png_debug(3, "Checking pCAL equation type and number of parameters"); + /* Check that we have the right number of parameters for known +- equation types. */ ++ * equation types. ++ */ + if ((type == PNG_EQUATION_LINEAR && nparams != 2) || + (type == PNG_EQUATION_BASE_E && nparams != 3) || + (type == PNG_EQUATION_ARBITRARY && nparams != 3) || + (type == PNG_EQUATION_HYPERBOLIC && nparams != 4)) + { +- png_warning(png_ptr, "Invalid pCAL parameters for equation type"); +- png_free(png_ptr, png_ptr->chunkdata); +- png_ptr->chunkdata = NULL; ++ 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++) + /* Empty loop to move past the units string. */ ; + + png_debug(3, "Allocating pCAL parameters array"); +- params = (png_charpp)png_malloc_warn(png_ptr, +- (png_uint_32)(nparams * png_sizeof(png_charp))) ; ++ ++ 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."); +- return; +- } ++ { ++ 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_set_pCAL(png_ptr, info_ptr, (png_charp)buffer, X0, X1, type, nparams, ++ (png_charp)units, params); + +- png_free(png_ptr, png_ptr->chunkdata); +- png_ptr->chunkdata = NULL; + png_free(png_ptr, params); + } + #endif +@@ -1782,190 +2373,129 @@ png_handle_pCAL(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) + #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_charp ep; +-#ifdef PNG_FLOATING_POINT_SUPPORTED +- double width, height; +- png_charp vp; +-#else +-#ifdef PNG_FIXED_POINT_SUPPORTED +- png_charp swidth, sheight; +-#endif +-#endif +- png_size_t slength; ++ png_bytep buffer; ++ 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) +- { +- png_warning(png_ptr, "Invalid sCAL after IDAT"); +- png_crc_finish(png_ptr, length); +- return; +- } +- else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_sCAL)) ++ 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, "Duplicate sCAL chunk"); + png_crc_finish(png_ptr, length); ++ png_chunk_benign_error(png_ptr, "out of place"); + return; + } + +- png_debug1(2, "Allocating and reading sCAL chunk data (%lu bytes)", +- length + 1); +- png_ptr->chunkdata = (png_charp)png_malloc_warn(png_ptr, length + 1); +- if (png_ptr->chunkdata == NULL) ++ else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_sCAL) != 0) + { +- png_warning(png_ptr, "Out of memory while processing sCAL chunk"); + png_crc_finish(png_ptr, length); ++ png_chunk_benign_error(png_ptr, "duplicate"); + return; + } +- slength = (png_size_t)length; +- png_crc_read(png_ptr, (png_bytep)png_ptr->chunkdata, slength); + +- if (png_crc_finish(png_ptr, 0)) ++ /* Need unit type, width, \0, height: minimum 4 bytes */ ++ else if (length < 4) + { +- png_free(png_ptr, png_ptr->chunkdata); +- png_ptr->chunkdata = NULL; ++ png_crc_finish(png_ptr, length); ++ png_chunk_benign_error(png_ptr, "invalid"); + return; + } + +- png_ptr->chunkdata[slength] = 0x00; /* Null terminate the last string */ ++ png_debug1(2, "Allocating and reading sCAL chunk data (%u bytes)", ++ length + 1); + +- ep = png_ptr->chunkdata + 1; /* Skip unit byte */ ++ buffer = png_read_buffer(png_ptr, length+1, 2/*silent*/); + +-#ifdef PNG_FLOATING_POINT_SUPPORTED +- width = png_strtod(png_ptr, ep, &vp); +- if (*vp) ++ if (buffer == NULL) + { +- png_warning(png_ptr, "malformed width string in sCAL chunk"); +- png_free(png_ptr, png_ptr->chunkdata); +- png_ptr->chunkdata = NULL; +- return; +- } +-#else +-#ifdef PNG_FIXED_POINT_SUPPORTED +- swidth = (png_charp)png_malloc_warn(png_ptr, png_strlen(ep) + 1); +- if (swidth == NULL) +- { +- png_warning(png_ptr, "Out of memory while processing sCAL chunk width"); +- png_free(png_ptr, png_ptr->chunkdata); +- png_ptr->chunkdata = NULL; ++ png_chunk_benign_error(png_ptr, "out of memory"); ++ png_crc_finish(png_ptr, length); + return; + } +- png_memcpy(swidth, ep, (png_size_t)png_strlen(ep)); +-#endif +-#endif + +- for (ep = png_ptr->chunkdata; *ep; ep++) +- /* Empty loop */ ; +- ep++; ++ png_crc_read(png_ptr, buffer, length); ++ buffer[length] = 0; /* Null terminate the last string */ + +- if (png_ptr->chunkdata + slength < ep) +- { +- png_warning(png_ptr, "Truncated sCAL chunk"); +-#if defined(PNG_FIXED_POINT_SUPPORTED) && !defined(PNG_FLOATING_POINT_SUPPORTED) +- png_free(png_ptr, swidth); +-#endif +- png_free(png_ptr, png_ptr->chunkdata); +- png_ptr->chunkdata = NULL; ++ if (png_crc_finish(png_ptr, 0) != 0) + return; +- } + +-#ifdef PNG_FLOATING_POINT_SUPPORTED +- height = png_strtod(png_ptr, ep, &vp); +- if (*vp) ++ /* Validate the unit. */ ++ if (buffer[0] != 1 && buffer[0] != 2) + { +- png_warning(png_ptr, "malformed height string in sCAL chunk"); +- png_free(png_ptr, png_ptr->chunkdata); +- png_ptr->chunkdata = NULL; +-#if defined(PNG_FIXED_POINT_SUPPORTED) && !defined(PNG_FLOATING_POINT_SUPPORTED) +- png_free(png_ptr, swidth); +-#endif +- return; +- } +-#else +-#ifdef PNG_FIXED_POINT_SUPPORTED +- sheight = (png_charp)png_malloc_warn(png_ptr, png_strlen(ep) + 1); +- if (sheight == NULL) +- { +- png_warning(png_ptr, "Out of memory while processing sCAL chunk height"); +- png_free(png_ptr, png_ptr->chunkdata); +- png_ptr->chunkdata = NULL; +-#if defined(PNG_FIXED_POINT_SUPPORTED) && !defined(PNG_FLOATING_POINT_SUPPORTED) +- png_free(png_ptr, swidth); +-#endif ++ png_chunk_benign_error(png_ptr, "invalid unit"); + return; + } +- png_memcpy(sheight, ep, (png_size_t)png_strlen(ep)); +-#endif +-#endif + +- if (png_ptr->chunkdata + slength < ep +-#ifdef PNG_FLOATING_POINT_SUPPORTED +- || width <= 0. || height <= 0. +-#endif +- ) +- { +- png_warning(png_ptr, "Invalid sCAL data"); +- png_free(png_ptr, png_ptr->chunkdata); +- png_ptr->chunkdata = NULL; +-#if defined(PNG_FIXED_POINT_SUPPORTED) && !defined(PNG_FLOATING_POINT_SUPPORTED) +- png_free(png_ptr, swidth); +- png_free(png_ptr, sheight); +-#endif +- return; +- } ++ /* Validate the ASCII numbers, need two ASCII numbers separated by ++ * a '\0' and they need to fit exactly in the chunk data. ++ */ ++ i = 1; ++ state = 0; + ++ 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"); + +-#ifdef PNG_FLOATING_POINT_SUPPORTED +- png_set_sCAL(png_ptr, info_ptr, png_ptr->chunkdata[0], width, height); +-#else +-#ifdef PNG_FIXED_POINT_SUPPORTED +- png_set_sCAL_s(png_ptr, info_ptr, png_ptr->chunkdata[0], swidth, sheight); +-#endif +-#endif ++ else if (PNG_FP_IS_POSITIVE(state) == 0) ++ png_chunk_benign_error(png_ptr, "non-positive width"); + +- png_free(png_ptr, png_ptr->chunkdata); +- png_ptr->chunkdata = NULL; +-#if defined(PNG_FIXED_POINT_SUPPORTED) && !defined(PNG_FLOATING_POINT_SUPPORTED) +- png_free(png_ptr, swidth); +- png_free(png_ptr, sheight); +-#endif ++ else ++ { ++ size_t heighti = i; ++ ++ state = 0; ++ 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, buffer[0], ++ (png_charp)buffer+1, (png_charp)buffer+heighti); ++ } + } + #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]; +@@ -1982,14 +2512,13 @@ png_handle_tIME(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) + #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"); + +@@ -2001,97 +2530,74 @@ png_handle_tEXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) + png_crc_finish(png_ptr, length); + return; + } ++ + if (--png_ptr->user_chunk_cache_max == 1) + { +- png_warning(png_ptr, "No space in chunk cache for tEXt"); + png_crc_finish(png_ptr, length); ++ 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_IHDR) == 0) ++ png_chunk_error(png_ptr, "missing IHDR"); + +- if (png_ptr->mode & PNG_HAVE_IDAT) ++ 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) +- { +- png_warning(png_ptr, "No memory to process text chunk."); +- return; +- } +- slength = (png_size_t)length; +- png_crc_read(png_ptr, (png_bytep)png_ptr->chunkdata, slength); ++ buffer = png_read_buffer(png_ptr, length+1, 1/*warn*/); + +- if (png_crc_finish(png_ptr, skip)) ++ if (buffer == NULL) + { +- png_free(png_ptr, png_ptr->chunkdata); +- png_ptr->chunkdata = NULL; ++ png_chunk_benign_error(png_ptr, "out of memory"); + return; + } + +- key = png_ptr->chunkdata; ++ png_crc_read(png_ptr, buffer, length); ++ ++ if (png_crc_finish(png_ptr, skip) != 0) ++ return; + +- 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_uint_32)png_sizeof(png_text)); +- if (text_ptr == NULL) +- { +- png_warning(png_ptr, "Not enough memory to process text chunk."); +- png_free(png_ptr, png_ptr->chunkdata); +- png_ptr->chunkdata = NULL; +- return; +- } +- text_ptr->compression = PNG_TEXT_COMPRESSION_NONE; +- text_ptr->key = key; +-#ifdef PNG_iTXt_SUPPORTED +- text_ptr->lang = NULL; +- text_ptr->lang_key = NULL; +- text_ptr->itxt_length = 0; +-#endif +- text_ptr->text = text; +- text_ptr->text_length = png_strlen(text); +- +- ret = png_set_text_2(png_ptr, info_ptr, text_ptr, 1); ++ 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); + +- png_free(png_ptr, png_ptr->chunkdata); +- png_ptr->chunkdata = NULL; +- png_free(png_ptr, text_ptr); +- if (ret) +- png_warning(png_ptr, "Insufficient memory to process text chunk."); ++ if (png_set_text_2(png_ptr, info_ptr, &text_info, 1) != 0) ++ png_warning(png_ptr, "Insufficient memory to process text chunk"); + } + #endif + + #ifdef PNG_READ_zTXt_SUPPORTED + /* Note: this does not correctly handle chunks that are > 64K under DOS */ + void /* PRIVATE */ +-png_handle_zTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) ++png_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"); + +@@ -2103,116 +2609,112 @@ png_handle_zTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) + png_crc_finish(png_ptr, length); + return; + } ++ + if (--png_ptr->user_chunk_cache_max == 1) + { +- png_warning(png_ptr, "No space in chunk cache for zTXt"); + png_crc_finish(png_ptr, length); ++ 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_IHDR) == 0) ++ png_chunk_error(png_ptr, "missing IHDR"); + +- if (png_ptr->mode & PNG_HAVE_IDAT) ++ 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) +- { +- png_warning(png_ptr, "zTXt chunk too large to fit in memory"); +- png_crc_finish(png_ptr, length); +- return; +- } +-#endif ++ /* Note, "length" is sufficient here; we won't be adding ++ * a null terminator later. ++ */ ++ buffer = png_read_buffer(png_ptr, length, 2/*silent*/); + +- png_free(png_ptr, png_ptr->chunkdata); +- png_ptr->chunkdata = (png_charp)png_malloc_warn(png_ptr, length + 1); +- if (png_ptr->chunkdata == NULL) +- { +- png_warning(png_ptr, "Out of memory processing zTXt chunk."); +- return; +- } +- slength = (png_size_t)length; +- png_crc_read(png_ptr, (png_bytep)png_ptr->chunkdata, slength); +- if (png_crc_finish(png_ptr, 0)) ++ if (buffer == NULL) + { +- png_free(png_ptr, png_ptr->chunkdata); +- png_ptr->chunkdata = NULL; ++ png_crc_finish(png_ptr, length); ++ png_chunk_benign_error(png_ptr, "out of memory"); + return; + } + +- png_ptr->chunkdata[slength] = 0x00; ++ png_crc_read(png_ptr, buffer, length); + +- 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; ++ if (png_crc_finish(png_ptr, 0) != 0) + 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 */ +- } +- prefix_len = text - png_ptr->chunkdata; +- +- png_decompress_chunk(png_ptr, comp_type, +- (png_size_t)length, prefix_len, &data_len); +- +- text_ptr = (png_textp)png_malloc_warn(png_ptr, +- (png_uint_32)png_sizeof(png_text)); +- if (text_ptr == NULL) +- { +- png_warning(png_ptr, "Not enough memory to process zTXt chunk."); +- png_free(png_ptr, png_ptr->chunkdata); +- png_ptr->chunkdata = NULL; +- return; +- } +- text_ptr->compression = comp_type; +- text_ptr->key = png_ptr->chunkdata; +-#ifdef PNG_iTXt_SUPPORTED +- text_ptr->lang = NULL; +- text_ptr->lang_key = NULL; +- text_ptr->itxt_length = 0; +-#endif +- text_ptr->text = png_ptr->chunkdata + prefix_len; +- text_ptr->text_length = data_len; ++ 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; ++ ++ if (png_ptr->read_buffer == NULL) ++ errmsg="Read failure in png_handle_zTXt"; ++ else ++ { ++ /* 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"; ++ } ++ } + +- ret = png_set_text_2(png_ptr, info_ptr, text_ptr, 1); ++ else ++ errmsg = png_ptr->zstream.msg; ++ } + +- 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"); + +@@ -2224,493 +2726,967 @@ png_handle_iTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) + png_crc_finish(png_ptr, length); + return; + } ++ + if (--png_ptr->user_chunk_cache_max == 1) + { +- png_warning(png_ptr, "No space in chunk cache for iTXt"); + png_crc_finish(png_ptr, length); ++ 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_IHDR) == 0) ++ png_chunk_error(png_ptr, "missing IHDR"); + +- if (png_ptr->mode & PNG_HAVE_IDAT) ++ 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) +- { +- png_warning(png_ptr, "iTXt chunk too large to fit in memory"); +- png_crc_finish(png_ptr, length); +- return; +- } +-#endif ++ buffer = png_read_buffer(png_ptr, length+1, 1/*warn*/); + +- png_free(png_ptr, png_ptr->chunkdata); +- png_ptr->chunkdata = (png_charp)png_malloc_warn(png_ptr, length + 1); +- if (png_ptr->chunkdata == NULL) ++ if (buffer == NULL) + { +- png_warning(png_ptr, "No memory to process iTXt chunk."); +- return; +- } +- slength = (png_size_t)length; +- png_crc_read(png_ptr, (png_bytep)png_ptr->chunkdata, slength); +- if (png_crc_finish(png_ptr, 0)) +- { +- png_free(png_ptr, png_ptr->chunkdata); +- png_ptr->chunkdata = NULL; ++ png_crc_finish(png_ptr, length); ++ png_chunk_benign_error(png_ptr, "out of memory"); + return; + } + +- png_ptr->chunkdata[slength] = 0x00; ++ png_crc_read(png_ptr, buffer, length); ++ ++ if (png_crc_finish(png_ptr, 0) != 0) ++ return; + +- for (lang = png_ptr->chunkdata; *lang; lang++) ++ /* First the keyword. */ ++ for (prefix_length=0; ++ prefix_length < length && buffer[prefix_length] != 0; ++ ++prefix_length) + /* 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 ++ /* 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"; + +- 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 ++ else if (buffer[prefix_length+1] == 0 || ++ (buffer[prefix_length+1] == 1 && ++ buffer[prefix_length+2] == PNG_COMPRESSION_TYPE_BASE)) + { +- comp_flag = *lang++; +- comp_type = *lang++; +- } +- +- for (lang_key = lang; *lang_key; lang_key++) +- /* Empty loop */ ; +- lang_key++; /* Skip NUL separator */ ++ int compressed = buffer[prefix_length+1] != 0; ++ png_uint_32 language_offset, translated_keyword_offset; ++ png_alloc_size_t uncompressed_length = 0; + +- 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; +- } ++ /* Now the language tag */ ++ prefix_length += 3; ++ language_offset = prefix_length; + +- 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; +- } ++ for (; prefix_length < length && buffer[prefix_length] != 0; ++ ++prefix_length) ++ /* Empty loop */ ; + +- prefix_len = text - png_ptr->chunkdata; ++ /* WARNING: the length may be invalid here, this is checked below. */ ++ translated_keyword_offset = ++prefix_length; + +- key=png_ptr->chunkdata; +- if (comp_flag) +- png_decompress_chunk(png_ptr, comp_type, +- (size_t)length, prefix_len, &data_len); +- else +- data_len = png_strlen(png_ptr->chunkdata + prefix_len); +- text_ptr = (png_textp)png_malloc_warn(png_ptr, +- (png_uint_32)png_sizeof(png_text)); +- if (text_ptr == NULL) +- { +- png_warning(png_ptr, "Not enough memory to process iTXt chunk."); +- png_free(png_ptr, png_ptr->chunkdata); +- png_ptr->chunkdata = NULL; +- return; +- } +- text_ptr->compression = (int)comp_flag + 1; +- text_ptr->lang_key = png_ptr->chunkdata + (lang_key - key); +- text_ptr->lang = png_ptr->chunkdata + (lang - key); +- text_ptr->itxt_length = data_len; +- text_ptr->text_length = 0; +- text_ptr->key = png_ptr->chunkdata; +- text_ptr->text = png_ptr->chunkdata + prefix_len; +- +- ret = png_set_text_2(png_ptr, info_ptr, text_ptr, 1); +- +- png_free(png_ptr, text_ptr); +- png_free(png_ptr, png_ptr->chunkdata); +- png_ptr->chunkdata = NULL; +- if (ret) +- png_error(png_ptr, "Insufficient memory to store iTXt chunk."); +-} +-#endif ++ for (; prefix_length < length && buffer[prefix_length] != 0; ++ ++prefix_length) ++ /* Empty loop */ ; + +-/* This function is called when we haven't found a handler for a +- chunk. If there isn't a problem with the chunk itself (ie bad +- chunk name, CRC, or a critical chunk), the chunk is silently ignored +- -- unless the PNG_FLAG_UNKNOWN_CHUNKS_SUPPORTED flag is on in which +- case it will be saved away to be written out later. */ +-void /* PRIVATE */ +-png_handle_unknown(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) +-{ +- png_uint_32 skip = 0; ++ /* 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; + +- png_debug(1, "in png_handle_unknown"); ++ if (compressed == 0 && prefix_length <= length) ++ uncompressed_length = length - prefix_length; + +-#ifdef PNG_USER_LIMITS_SUPPORTED +- if (png_ptr->user_chunk_cache_max != 0) +- { +- if (png_ptr->user_chunk_cache_max == 1) ++ else if (compressed != 0 && prefix_length < length) + { +- png_crc_finish(png_ptr, length); +- return; ++ 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; + } +- if (--png_ptr->user_chunk_cache_max == 1) ++ ++ else ++ errmsg = "truncated"; ++ ++ if (errmsg == NULL) + { +- png_warning(png_ptr, "No space in chunk cache for unknown chunk"); +- png_crc_finish(png_ptr, length); +- return; ++ 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"; + } + } +-#endif + +- if (png_ptr->mode & PNG_HAVE_IDAT) +- { +-#ifdef PNG_USE_LOCAL_ARRAYS +- PNG_CONST PNG_IDAT; +-#endif +- if (png_memcmp(png_ptr->chunk_name, png_IDAT, 4)) /* Not an IDAT */ +- png_ptr->mode |= PNG_AFTER_IDAT; +- } ++ else ++ errmsg = "bad compression info"; + +- 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 +- ) ++ if (errmsg != NULL) ++ png_chunk_benign_error(png_ptr, errmsg); ++} + #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 +- ) ++/* 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_alloc_size_t limit = PNG_SIZE_MAX; ++ ++ if (png_ptr->unknown_chunk.data != NULL) + { +-#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; ++ png_free(png_ptr, png_ptr->unknown_chunk.data); ++ png_ptr->unknown_chunk.data = NULL; + } +- else +-#endif +- skip = length; + +- png_crc_finish(png_ptr, skip); ++# ifdef PNG_SET_USER_LIMITS_SUPPORTED ++ if (png_ptr->user_chunk_malloc_max > 0 && ++ png_ptr->user_chunk_malloc_max < limit) ++ limit = png_ptr->user_chunk_malloc_max; + +-#ifndef PNG_READ_USER_CHUNKS_SUPPORTED +- info_ptr = info_ptr; /* Quiet compiler warnings about unused info_ptr */ +-#endif +-} ++# elif PNG_USER_CHUNK_MALLOC_MAX > 0 ++ if (PNG_USER_CHUNK_MALLOC_MAX < limit) ++ limit = PNG_USER_CHUNK_MALLOC_MAX; ++# endif + +-/* This function is called to verify that a chunk name is valid. +- This function can't have the "critical chunk check" incorporated +- into it, since in the future we will need to be able to call user +- functions to handle unknown critical chunks after we check that +- the chunk name itself is valid. */ ++ 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 = (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; + +-#define isnonalpha(c) ((c) < 65 || (c) > 122 || ((c) > 90 && (c) < 97)) ++ else ++ { ++ /* Do a 'warn' here - it is handled below. */ ++ png_ptr->unknown_chunk.data = png_voidcast(png_bytep, ++ png_malloc_warn(png_ptr, length)); ++ } ++ } + +-void /* PRIVATE */ +-png_check_chunk_name(png_structp png_ptr, png_bytep chunk_name) +-{ +- png_debug(1, "in png_check_chunk_name"); +- if (isnonalpha(chunk_name[0]) || isnonalpha(chunk_name[1]) || +- isnonalpha(chunk_name[2]) || isnonalpha(chunk_name[3])) ++ if (png_ptr->unknown_chunk.data == NULL && length > 0) + { +- png_chunk_error(png_ptr, "invalid chunk type"); ++ /* 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; + } +-} + +-/* 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. */ ++ else ++ { ++ 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_combine_row(png_structp png_ptr, png_bytep row, int mask) ++png_handle_unknown(png_structrp png_ptr, png_inforp info_ptr, ++ png_uint_32 length, int keep) + { +- png_debug(1, "in png_combine_row"); +- if (mask == 0xff) +- { +- png_memcpy(row, png_ptr->row_buf + 1, +- PNG_ROWBYTES(png_ptr->row_info.pixel_depth, png_ptr->width)); +- } +- else ++ 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) + { +- switch (png_ptr->row_info.pixel_depth) ++ if (png_cache_unknown_chunk(png_ptr, length) != 0) + { +- case 1: ++ /* 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 occurred; 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) + { +- png_bytep sp = png_ptr->row_buf + 1; +- png_bytep dp = row; +- int s_inc, s_start, s_end; +- int m = 0x80; +- int shift; +- png_uint_32 i; +- png_uint_32 row_width = png_ptr->width; +- +-#ifdef PNG_READ_PACKSWAP_SUPPORTED +- if (png_ptr->transformations & PNG_PACKSWAP) +- { +- s_start = 0; +- s_end = 7; +- s_inc = 1; +- } +- else +-#endif ++ /* 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) + { +- s_start = 7; +- s_end = 0; +- s_inc = -1; ++# 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; + } ++ } + +- shift = s_start; ++ else /* chunk was handled */ ++ { ++ handled = 1; ++ /* Critical chunks can be safely discarded at this point. */ ++ keep = PNG_HANDLE_CHUNK_NEVER; ++ } ++ } + +- for (i = 0; i < row_width; i++) +- { +- if (m & mask) +- { +- int value; ++ else ++ keep = PNG_HANDLE_CHUNK_NEVER; /* insufficient memory */ ++ } + +- value = (*sp >> shift) & 0x01; +- *dp &= (png_byte)((0x7f7f >> (7 - shift)) & 0xff); +- *dp |= (png_byte)(value << shift); +- } ++ else ++ /* Use the SAVE_UNKNOWN_CHUNKS code or skip the chunk */ ++# endif /* READ_USER_CHUNKS */ + +- if (shift == s_end) +- { +- shift = s_start; +- sp++; +- dp++; +- } +- else +- shift += s_inc; ++# 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 (m == 1) +- m = 0x80; +- else +- m >>= 1; +- } +- break; +- } ++ 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"); ++ /* FALLTHROUGH */ ++ 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); ++ /* FALLTHROUGH */ ++ 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. ++ * This function can't have the "critical chunk check" incorporated ++ * into it, since in the future we will need to be able to call user ++ * functions to handle unknown critical chunks after we check that ++ * the chunk name itself is valid. ++ */ ++ ++/* 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_const_structrp png_ptr, png_uint_32 chunk_name) ++{ ++ int i; ++ png_uint_32 cn=chunk_name; ++ ++ png_debug(1, "in png_check_chunk_name"); ++ ++ for (i=1; i<=4; ++i) ++ { ++ int c = cn & 0xff; ++ ++ if (c < 65 || c > 122 || (c > 90 && c < 97)) ++ png_chunk_error(png_ptr, "invalid chunk type"); ++ ++ cn >>= 8; ++ } ++} ++ ++void /* PRIVATE */ ++png_check_chunk_length(png_const_structrp png_ptr, png_uint_32 length) ++{ ++ png_alloc_size_t limit = PNG_UINT_31_MAX; ++ ++# ifdef PNG_SET_USER_LIMITS_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 (png_ptr->chunk_name == png_IDAT) ++ { ++ png_alloc_size_t idat_limit = PNG_UINT_31_MAX; ++ size_t row_factor = ++ (size_t)png_ptr->width ++ * (size_t)png_ptr->channels ++ * (png_ptr->bit_depth > 8? 2: 1) ++ + 1 ++ + (png_ptr->interlaced? 6: 0); ++ if (png_ptr->height > PNG_UINT_32_MAX/row_factor) ++ idat_limit = PNG_UINT_31_MAX; ++ else ++ idat_limit = png_ptr->height * row_factor; ++ row_factor = row_factor > 32566? 32566 : row_factor; ++ idat_limit += 6 + 5*(idat_limit/row_factor+1); /* zlib+deflate overhead */ ++ idat_limit=idat_limit < PNG_UINT_31_MAX? idat_limit : PNG_UINT_31_MAX; ++ limit = limit < idat_limit? idat_limit : limit; ++ } ++ ++ if (length > limit) ++ { ++ png_debug2(0," length = %lu, limit = %lu", ++ (unsigned long)length,(unsigned long)limit); ++ png_chunk_error(png_ptr, "chunk data is too large"); ++ } ++} ++ ++/* 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_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.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(pixel_depth, row_width)) ++ png_error(png_ptr, "internal row size calculation error"); ++ ++ /* 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) ++ { ++ /* 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 = (unsigned int)(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 */ ++ } ++ ++ /* 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))) ++ { ++ /* 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) ++ { ++ /* 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 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_start, s_end, s_inc; +- int m = 0x80; +- int shift; +- png_uint_32 i; +- png_uint_32 row_width = png_ptr->width; +- int value; ++ /* 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 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); + +-#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; +- } ++ else ++# endif ++ mask = MASK(pass, pixel_depth, display, 1); + +- shift = s_start; ++ for (;;) ++ { ++ png_uint_32 m; + +- 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); +- } ++ /* 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 (shift == s_end) +- { +- shift = s_start; +- sp++; +- dp++; +- } +- else +- shift += s_inc; +- if (m == 1) +- m = 0x80; ++ if (m != 0) /* something to copy */ ++ { ++ if (m != 0xff) ++ *dp = (png_byte)((*dp & ~m) | (*sp & m)); + else +- m >>= 1; ++ *dp = *sp; + } +- 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; + } +- case 4: ++ } ++ ++ 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. ++ */ + { +- 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; ++ unsigned int offset = PNG_PASS_START_COL(pass) * pixel_depth; + +-#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; ++ row_width -= offset; ++ dp += offset; ++ sp += offset; ++ } + +- for (i = 0; i < row_width; i++) +- { +- if (m & mask) ++ /* 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 (;;) + { +- value = (*sp >> shift) & 0xf; +- *dp &= (png_byte)((0xf0f >> (4 - shift)) & 0xff); +- *dp |= (png_byte)(value << shift); ++ *dp = *sp; ++ ++ if (row_width <= bytes_to_jump) ++ return; ++ ++ dp += bytes_to_jump; ++ sp += bytes_to_jump; ++ row_width -= bytes_to_jump; + } + +- if (shift == s_end) ++ case 2: ++ /* There is a possibility of a partial copy at the end here; this ++ * slows the code down somewhat. ++ */ ++ do + { +- shift = s_start; +- sp++; +- dp++; ++ 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; + } +- 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; ++ while (row_width > 1); + ++ /* And there can only be one byte left at this point: */ ++ *dp = *sp; ++ return; + +- for (i = 0; i < row_width; i++) +- { +- if (m & mask) ++ 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 (;;) + { +- png_memcpy(dp, sp, pixel_bytes); ++ 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; + } + +- sp += pixel_bytes; +- dp += pixel_bytes; ++ 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) && ++ png_isaligned(sp, png_uint_32) && ++ 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; ++ } + +- if (m == 1) +- m = 0x80; +- else +- m >>= 1; +- } +- break; ++ /* 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 +-/* OLD pre-1.0.9 interface: +-void png_do_read_interlace(png_row_infop row_info, png_bytep row, int pass, +- png_uint_32 transformations) +- */ + void /* PRIVATE */ +-png_do_read_interlace(png_structp png_ptr) ++png_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 const unsigned 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) +@@ -2723,29 +3699,31 @@ png_do_read_interlace(png_structp png_ptr) + { + case 1: + { +- png_bytep sp = row + (png_size_t)((row_info->width - 1) >> 3); +- png_bytep dp = row + (png_size_t)((final_width - 1) >> 3); +- int sshift, dshift; +- int s_start, s_end, s_inc; +- int jstop = png_pass_inc[pass]; ++ png_bytep sp = row + (size_t)((row_info->width - 1) >> 3); ++ png_bytep dp = row + (size_t)((final_width - 1) >> 3); ++ unsigned int sshift, dshift; ++ unsigned int s_start, s_end; ++ int s_inc; ++ int jstop = (int)png_pass_inc[pass]; + png_byte v; + png_uint_32 i; + 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); ++ sshift = ((row_info->width + 7) & 0x07); ++ dshift = ((final_width + 7) & 0x07); + s_start = 7; + s_end = 0; + s_inc = -1; + } ++ + else + #endif + { +- sshift = 7 - (int)((row_info->width + 7) & 0x07); +- dshift = 7 - (int)((final_width + 7) & 0x07); ++ sshift = 7 - ((row_info->width + 7) & 0x07); ++ dshift = 7 - ((final_width + 7) & 0x07); + s_start = 0; + s_end = 7; + s_inc = 1; +@@ -2756,49 +3734,57 @@ png_do_read_interlace(png_structp png_ptr) + 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 |= (unsigned int)(v << dshift); ++ *dp = (png_byte)(tmp & 0xff); ++ + if (dshift == s_end) + { + dshift = s_start; + dp--; + } ++ + else +- dshift += s_inc; ++ dshift = (unsigned int)((int)dshift + s_inc); + } ++ + if (sshift == s_end) + { + sshift = s_start; + sp--; + } ++ + else +- sshift += s_inc; ++ sshift = (unsigned int)((int)sshift + s_inc); + } + break; + } ++ + case 2: + { + png_bytep sp = row + (png_uint_32)((row_info->width - 1) >> 2); + png_bytep dp = row + (png_uint_32)((final_width - 1) >> 2); +- int sshift, dshift; +- int s_start, s_end, s_inc; +- int jstop = png_pass_inc[pass]; ++ unsigned int sshift, dshift; ++ unsigned int s_start, s_end; ++ int s_inc; ++ int jstop = (int)png_pass_inc[pass]; + 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); ++ sshift = (((row_info->width + 3) & 0x03) << 1); ++ dshift = (((final_width + 3) & 0x03) << 1); + s_start = 6; + s_end = 0; + s_inc = -2; + } ++ + else + #endif + { +- sshift = (int)((3 - ((row_info->width + 3) & 0x03)) << 1); +- dshift = (int)((3 - ((final_width + 3) & 0x03)) << 1); ++ sshift = ((3 - ((row_info->width + 3) & 0x03)) << 1); ++ dshift = ((3 - ((final_width + 3) & 0x03)) << 1); + s_start = 0; + s_end = 6; + s_inc = 2; +@@ -2812,49 +3798,57 @@ png_do_read_interlace(png_structp png_ptr) + 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 |= (unsigned int)(v << dshift); ++ *dp = (png_byte)(tmp & 0xff); ++ + if (dshift == s_end) + { + dshift = s_start; + dp--; + } ++ + else +- dshift += s_inc; ++ dshift = (unsigned int)((int)dshift + s_inc); + } ++ + if (sshift == s_end) + { + sshift = s_start; + sp--; + } ++ + else +- sshift += s_inc; ++ sshift = (unsigned int)((int)sshift + s_inc); + } + break; + } ++ + case 4: + { +- png_bytep sp = row + (png_size_t)((row_info->width - 1) >> 1); +- png_bytep dp = row + (png_size_t)((final_width - 1) >> 1); +- int sshift, dshift; +- int s_start, s_end, s_inc; ++ png_bytep sp = row + (size_t)((row_info->width - 1) >> 1); ++ png_bytep dp = row + (size_t)((final_width - 1) >> 1); ++ unsigned int sshift, dshift; ++ unsigned int s_start, s_end; ++ int s_inc; + png_uint_32 i; +- int jstop = png_pass_inc[pass]; ++ int jstop = (int)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); ++ sshift = (((row_info->width + 1) & 0x01) << 2); ++ dshift = (((final_width + 1) & 0x01) << 2); + s_start = 4; + s_end = 0; + s_inc = -4; + } ++ + else + #endif + { +- sshift = (int)((1 - ((row_info->width + 1) & 0x01)) << 2); +- dshift = (int)((1 - ((final_width + 1) & 0x01)) << 2); ++ sshift = ((1 - ((row_info->width + 1) & 0x01)) << 2); ++ dshift = ((1 - ((final_width + 1) & 0x01)) << 2); + s_start = 0; + s_end = 4; + s_inc = 4; +@@ -2862,390 +3856,624 @@ png_do_read_interlace(png_structp png_ptr) + + 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 |= (unsigned int)(v << dshift); ++ *dp = (png_byte)(tmp & 0xff); ++ + if (dshift == s_end) + { + dshift = s_start; + dp--; + } ++ + else +- dshift += s_inc; ++ dshift = (unsigned int)((int)dshift + s_inc); + } ++ + if (sshift == s_end) + { + sshift = s_start; + sp--; + } ++ + else +- sshift += s_inc; ++ sshift = (unsigned int)((int)sshift + s_inc); + } + break; + } ++ + default: + { +- png_size_t pixel_bytes = (row_info->pixel_depth >> 3); +- png_bytep sp = row + (png_size_t)(row_info->width - 1) ++ size_t pixel_bytes = (row_info->pixel_depth >> 3); ++ ++ png_bytep sp = row + (size_t)(row_info->width - 1) + * pixel_bytes; +- png_bytep dp = row + (png_size_t)(final_width - 1) * pixel_bytes; + +- int jstop = png_pass_inc[pass]; ++ png_bytep dp = row + (size_t)(final_width - 1) * pixel_bytes; ++ ++ int jstop = (int)png_pass_inc[pass]; + png_uint_32 i; + + 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; + } ++ + sp -= pixel_bytes; + } + break; + } + } ++ + row_info->width = final_width; + row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth, final_width); + } + #ifndef PNG_READ_PACKSWAP_SUPPORTED +- transformations = transformations; /* Silence compiler warning */ ++ PNG_UNUSED(transformations) /* Silence compiler warning */ ++#endif ++} ++#endif /* READ_INTERLACING */ ++ ++static void ++png_read_filter_row_sub(png_row_infop row_info, png_bytep row, ++ png_const_bytep prev_row) ++{ ++ size_t i; ++ 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) ++{ ++ size_t i; ++ 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) ++{ ++ size_t i; ++ png_bytep rp = row; ++ png_const_bytep pp = prev_row; ++ unsigned int bpp = (row_info->pixel_depth + 7) >> 3; ++ 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) ++{ ++ unsigned 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 = 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 + } +-#endif /* PNG_READ_INTERLACING_SUPPORTED */ + + void /* PRIVATE */ +-png_read_filter_row(png_structp png_ptr, png_row_infop row_info, png_bytep row, +- png_bytep prev_row, int filter) ++png_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 = %lu, 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_uint_32 i; +- png_uint_32 istop = row_info->rowbytes; +- png_uint_32 bpp = (row_info->pixel_depth + 7) >> 3; +- png_bytep rp = row + bpp; +- png_bytep lp = row; ++ uInt avail_in; ++ png_bytep buffer; + +- for (i = bpp; i < istop; i++) ++ 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"); + } +- break; ++ ++ 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; + } +- case PNG_FILTER_VALUE_UP: ++ ++ /* And set up the output side. */ ++ if (output != NULL) /* standard read */ + { +- png_uint_32 i; +- png_uint_32 istop = row_info->rowbytes; +- png_bytep rp = row; +- png_bytep pp = prev_row; ++ uInt out = ZLIB_IO_MAX; + +- for (i = 0; i < istop; i++) +- { +- *rp = (png_byte)(((int)(*rp) + (int)(*pp++)) & 0xff); +- rp++; +- } +- break; ++ if (out > avail_out) ++ out = (uInt)avail_out; ++ ++ avail_out -= out; ++ png_ptr->zstream.avail_out = out; + } +- case PNG_FILTER_VALUE_AVG: ++ ++ else /* after last row, checking for end */ + { +- png_uint_32 i; +- png_bytep rp = row; +- png_bytep pp = prev_row; +- png_bytep lp = row; +- png_uint_32 bpp = (row_info->pixel_depth + 7) >> 3; +- png_uint_32 istop = row_info->rowbytes - bpp; ++ png_ptr->zstream.next_out = tmpbuf; ++ png_ptr->zstream.avail_out = (sizeof tmpbuf); ++ } + +- for (i = 0; i < bpp; i++) +- { +- *rp = (png_byte)(((int)(*rp) + +- ((int)(*pp++) / 2 )) & 0xff); +- rp++; +- } ++ /* 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 = PNG_INFLATE(png_ptr, Z_NO_FLUSH); + +- for (i = 0; i < istop; i++) +- { +- *rp = (png_byte)(((int)(*rp) + +- (int)(*pp++ + *lp++) / 2 ) & 0xff); +- rp++; +- } ++ /* 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_PAETH: ++ ++ if (ret != Z_OK) + { +- png_uint_32 i; +- png_bytep rp = row; +- png_bytep pp = prev_row; +- png_bytep lp = row; +- png_bytep cp = prev_row; +- png_uint_32 bpp = (row_info->pixel_depth + 7) >> 3; +- png_uint_32 istop=row_info->rowbytes - bpp; ++ png_zstream_error(png_ptr, ret); + +- for (i = 0; i < bpp; i++) ++ 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; + } ++ } ++ } while (avail_out > 0); + +- for (i = 0; i < istop; i++) /* Use leftover rp,pp */ +- { +- int a, b, c, pa, pb, pc, p; ++ 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"); + +- a = *lp++; +- b = *pp++; +- c = *cp++; ++ else /* the deflate stream contained extra data */ ++ png_chunk_benign_error(png_ptr, "Too much image data"); ++ } ++} + +- p = b - c; +- pc = a - c; ++void /* PRIVATE */ ++png_read_finish_IDAT(png_structrp png_ptr) ++{ ++ /* 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 */ + +-#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 ++ /* 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 (pa <= pb && pa <= pc) +- p = a; +- else if (pb <= pc) +- p = b; +- else +- p = c; +- */ ++ /* 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; + +- p = (pa <= pb && pa <= pc) ? a : (pb <= pc) ? b : c; ++ /* Now we no longer own the zstream. */ ++ png_ptr->zowner = 0; + +- *rp = (png_byte)(((int)(*rp) + p) & 0xff); +- rp++; +- } +- break; +- } +- default: +- png_warning(png_ptr, "Ignoring bad adaptive filter type"); +- *row = 0; +- break; ++ /* 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); + } + } + +-#ifdef PNG_SEQUENTIAL_READ_SUPPORTED + void /* PRIVATE */ +-png_read_finish_row(png_structp png_ptr) ++png_read_finish_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 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 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 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 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_check(png_ptr, 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 + { + png_ptr->pass++; ++ + if (png_ptr->pass >= 7) + break; ++ + png_ptr->iwidth = (png_ptr->width + + png_pass_inc[png_ptr->pass] - 1 - + png_pass_start[png_ptr->pass]) / + png_pass_inc[png_ptr->pass]; + +- 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 - +- png_pass_ystart[png_ptr->pass]) / +- png_pass_yinc[png_ptr->pass]; +- if (!(png_ptr->num_rows)) +- continue; ++ png_pass_yinc[png_ptr->pass] - 1 - ++ png_pass_ystart[png_ptr->pass]) / ++ png_pass_yinc[png_ptr->pass]; + } ++ + else /* if (png_ptr->transformations & PNG_INTERLACE) */ +- break; +- } while (png_ptr->iwidth == 0); ++ break; /* libpng deinterlacing sees every row */ ++ ++ } while (png_ptr->num_rows == 0 || png_ptr->iwidth == 0); + + if (png_ptr->pass < 7) + return; + } +-#endif /* PNG_READ_INTERLACING_SUPPORTED */ +- +- if (!(png_ptr->flags & PNG_FLAG_ZLIB_FINISHED)) +- { +-#ifdef PNG_USE_LOCAL_ARRAYS +- PNG_CONST PNG_IDAT; +-#endif +- char extra; +- int ret; +- +- png_ptr->zstream.next_out = (Byte *)&extra; +- png_ptr->zstream.avail_out = (uInt)1; +- for (;;) +- { +- if (!(png_ptr->zstream.avail_in)) +- { +- while (!png_ptr->idat_size) +- { +- png_byte chunk_length[4]; +- +- png_crc_finish(png_ptr, 0); +- +- png_read_data(png_ptr, chunk_length, 4); +- png_ptr->idat_size = png_get_uint_31(png_ptr, chunk_length); +- png_reset_crc(png_ptr); +- png_crc_read(png_ptr, png_ptr->chunk_name, 4); +- if (png_memcmp(png_ptr->chunk_name, png_IDAT, 4)) +- png_error(png_ptr, "Not enough image data"); +- +- } +- png_ptr->zstream.avail_in = (uInt)png_ptr->zbuf_size; +- png_ptr->zstream.next_in = png_ptr->zbuf; +- if (png_ptr->zbuf_size > png_ptr->idat_size) +- png_ptr->zstream.avail_in = (uInt)png_ptr->idat_size; +- png_crc_read(png_ptr, png_ptr->zbuf, png_ptr->zstream.avail_in); +- png_ptr->idat_size -= png_ptr->zstream.avail_in; +- } +- ret = inflate(&png_ptr->zstream, Z_PARTIAL_FLUSH); +- if (ret == Z_STREAM_END) +- { +- if (!(png_ptr->zstream.avail_out) || png_ptr->zstream.avail_in || +- png_ptr->idat_size) +- png_warning(png_ptr, "Extra compressed data."); +- png_ptr->mode |= PNG_AFTER_IDAT; +- png_ptr->flags |= PNG_FLAG_ZLIB_FINISHED; +- break; +- } +- if (ret != Z_OK) +- png_error(png_ptr, png_ptr->zstream.msg ? png_ptr->zstream.msg : +- "Decompression Error"); +- +- if (!(png_ptr->zstream.avail_out)) +- { +- png_warning(png_ptr, "Extra compressed data."); +- png_ptr->mode |= PNG_AFTER_IDAT; +- png_ptr->flags |= PNG_FLAG_ZLIB_FINISHED; +- break; +- } +- +- } +- png_ptr->zstream.avail_out = 0; +- } +- +- if (png_ptr->idat_size || png_ptr->zstream.avail_in) +- png_warning(png_ptr, "Extra compression data."); + +- inflateReset(&png_ptr->zstream); +- +- png_ptr->mode |= PNG_AFTER_IDAT; ++ /* 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 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 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 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 const png_byte png_pass_yinc[7] = {8, 8, 8, 4, 4, 2, 2}; + +- int max_pixel_depth; +- png_size_t row_bytes; ++ unsigned int max_pixel_depth; ++ 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); +-#ifdef PNG_READ_INTERLACING_SUPPORTED +- if (png_ptr->interlaced) ++#endif ++ 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]; ++ png_pass_ystart[0]) / png_pass_yinc[0]; ++ + else + png_ptr->num_rows = png_ptr->height; + + png_ptr->iwidth = (png_ptr->width + +- png_pass_inc[png_ptr->pass] - 1 - +- png_pass_start[png_ptr->pass]) / +- png_pass_inc[png_ptr->pass]; ++ png_pass_inc[png_ptr->pass] - 1 - ++ png_pass_start[png_ptr->pass]) / ++ png_pass_inc[png_ptr->pass]; + } ++ + else +-#endif /* PNG_READ_INTERLACING_SUPPORTED */ + { + png_ptr->num_rows = png_ptr->height; + png_ptr->iwidth = png_ptr->width; + } +- max_pixel_depth = png_ptr->pixel_depth; + ++ max_pixel_depth = (unsigned int)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 + max_pixel_depth = 24; + } ++ + else if (png_ptr->color_type == PNG_COLOR_TYPE_GRAY) + { + if (max_pixel_depth < 8) + max_pixel_depth = 8; +- if (png_ptr->num_trans) ++ ++ 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; +@@ -3254,22 +4482,42 @@ png_read_start_row(png_structp png_ptr) + } + #endif + ++#ifdef PNG_READ_EXPAND_16_SUPPORTED ++ 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) != 0) ++ { ++ if (png_ptr->bit_depth < 16) ++ max_pixel_depth *= 2; ++ } ++ else ++# endif ++ png_ptr->transformations &= ~PNG_EXPAND_16; ++ } ++#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; ++ + else + 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; ++ + else + max_pixel_depth = 64; + } +@@ -3277,33 +4525,39 @@ png_read_start_row(png_structp png_ptr) + #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) ++ png_ptr->color_type == PNG_COLOR_TYPE_GRAY_ALPHA) + { + if (max_pixel_depth <= 16) + max_pixel_depth = 32; ++ + else + max_pixel_depth = 64; + } ++ + else + { + if (max_pixel_depth <= 8) +- { +- if (png_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA) ++ { ++ if (png_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA) + max_pixel_depth = 32; +- else ++ ++ else + max_pixel_depth = 24; +- } ++ } ++ + else if (png_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA) + max_pixel_depth = 64; ++ + else + max_pixel_depth = 48; + } +@@ -3312,15 +4566,22 @@ png_read_start_row(png_structp png_ptr) + + #if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) && \ + defined(PNG_USER_TRANSFORM_PTR_SUPPORTED) +- if (png_ptr->transformations & PNG_USER_TRANSFORM) +- { +- int user_pixel_depth = png_ptr->user_transform_depth* ++ if ((png_ptr->transformations & PNG_USER_TRANSFORM) != 0) ++ { ++ unsigned 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; +- } ++ ++ if (user_pixel_depth > max_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 + */ +@@ -3329,54 +4590,92 @@ defined(PNG_USER_TRANSFORM_PTR_SUPPORTED) + * for safety's sake + */ + row_bytes = PNG_ROWBYTES(max_pixel_depth, row_bytes) + +- 1 + ((max_pixel_depth + 7) >> 3); ++ 1 + ((max_pixel_depth + 7) >> 3U); ++ + #ifdef PNG_MAX_MALLOC_64K + if (row_bytes > (png_uint_32)65536L) + png_error(png_ptr, "This image requires a row greater than 64KB"); + #endif + +- if (row_bytes + 64 > png_ptr->old_big_row_buf_size) ++ if (row_bytes + 48 > png_ptr->old_big_row_buf_size) + { +- png_free(png_ptr, png_ptr->big_row_buf); +- if (png_ptr->interlaced) +- png_ptr->big_row_buf = (png_bytep)png_calloc(png_ptr, +- row_bytes + 64); +- else +- png_ptr->big_row_buf = (png_bytep)png_malloc(png_ptr, +- row_bytes + 64); +- png_ptr->old_big_row_buf_size = row_bytes + 64; ++ png_free(png_ptr, png_ptr->big_row_buf); ++ 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); + +- /* Use 32 bytes of padding before and after row_buf. */ +- png_ptr->row_buf = png_ptr->big_row_buf + 32; +- png_ptr->old_big_row_buf_size = row_bytes + 64; ++ 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; 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_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 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; + } + + #ifdef PNG_MAX_MALLOC_64K +- if ((png_uint_32)row_bytes + 1 > (png_uint_32)65536L) ++ if (png_ptr->rowbytes > 65535) + png_error(png_ptr, "This image requires a row greater than 64KB"); ++ + #endif +- if ((png_uint_32)row_bytes > (png_uint_32)(PNG_SIZE_MAX - 1)) +- png_error(png_ptr, "Row has too many bytes to allocate in memory."); ++ if (png_ptr->rowbytes > (PNG_SIZE_MAX - 1)) ++ png_error(png_ptr, "Row has too many bytes to allocate in memory"); ++ ++ memset(png_ptr->prev_row, 0, png_ptr->rowbytes + 1); + +- if (row_bytes + 1 > png_ptr->old_prev_row_size) ++ png_debug1(3, "width = %u,", png_ptr->width); ++ png_debug1(3, "height = %u,", png_ptr->height); ++ png_debug1(3, "iwidth = %u,", png_ptr->iwidth); ++ png_debug1(3, "num_rows = %u,", png_ptr->num_rows); ++ png_debug1(3, "rowbytes = %lu,", (unsigned long)png_ptr->rowbytes); ++ 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 != NULL) + { +- png_free(png_ptr, png_ptr->prev_row); +- png_ptr->prev_row = (png_bytep)png_malloc(png_ptr, (png_uint_32)( +- row_bytes + 1)); +- png_memset_check(png_ptr, png_ptr->prev_row, 0, row_bytes + 1); +- png_ptr->old_prev_row_size = row_bytes + 1; +- } ++ png_bytep buffer = png_ptr->read_buffer; + +- png_ptr->rowbytes = row_bytes; ++ png_ptr->read_buffer_size = 0; ++ png_ptr->read_buffer = NULL; ++ png_free(png_ptr, buffer); ++ } + +- png_debug1(3, "width = %lu,", png_ptr->width); +- png_debug1(3, "height = %lu,", png_ptr->height); +- png_debug1(3, "iwidth = %lu,", png_ptr->iwidth); +- png_debug1(3, "num_rows = %lu,", png_ptr->num_rows); +- png_debug1(3, "rowbytes = %lu,", png_ptr->rowbytes); +- png_debug1(3, "irowbytes = %lu", +- PNG_ROWBYTES(png_ptr->pixel_depth, png_ptr->iwidth) + 1); ++ /* 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 */ +diff --git a/com32/lib/libpng/pngset.c b/com32/lib/libpng/pngset.c +index 717757fc..ec75dbe3 100644 +--- a/com32/lib/libpng/pngset.c ++++ b/com32/lib/libpng/pngset.c +@@ -1,10 +1,10 @@ + + /* pngset.c - storage of image information into info struct + * +- * Last changed in libpng 1.2.43 [February 25, 2010] +- * Copyright (c) 1998-2010 Glenn Randers-Pehrson +- * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) +- * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) ++ * Copyright (c) 2018 Cosmin Truta ++ * Copyright (c) 1998-2018 Glenn Randers-Pehrson ++ * Copyright (c) 1996-1997 Andreas Dilger ++ * Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc. + * + * This code is released under the libpng license. + * For conditions of distribution and use, see the disclaimer +@@ -16,170 +16,199 @@ + * info struct and allows us to change the structure in the future. + */ + +-#define PNG_INTERNAL +-#define PNG_NO_PEDANTIC_WARNINGS +-#include "png.h" ++#include "pngpriv.h" ++ + #if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED) + + #ifdef PNG_bKGD_SUPPORTED + void PNGAPI +-png_set_bKGD(png_structp png_ptr, png_infop info_ptr, png_color_16p background) ++png_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 +-#ifdef PNG_FLOATING_POINT_SUPPORTED +-void PNGAPI +-png_set_cHRM(png_structp png_ptr, png_infop info_ptr, +- double white_x, double white_y, double red_x, double red_y, +- double green_x, double green_y, double blue_x, double blue_y) ++void PNGFAPI ++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_debug1(1, "in %s storage function", "cHRM"); ++ png_xy xy; ++ ++ png_debug1(1, "in %s storage function", "cHRM fixed"); + + if (png_ptr == NULL || info_ptr == NULL) + return; + +- info_ptr->x_white = (float)white_x; +- info_ptr->y_white = (float)white_y; +- info_ptr->x_red = (float)red_x; +- info_ptr->y_red = (float)red_y; +- info_ptr->x_green = (float)green_x; +- info_ptr->y_green = (float)green_y; +- info_ptr->x_blue = (float)blue_x; +- info_ptr->y_blue = (float)blue_y; +-#ifdef PNG_FIXED_POINT_SUPPORTED +- info_ptr->int_x_white = (png_fixed_point)(white_x*100000.+0.5); +- info_ptr->int_y_white = (png_fixed_point)(white_y*100000.+0.5); +- info_ptr->int_x_red = (png_fixed_point)( red_x*100000.+0.5); +- info_ptr->int_y_red = (png_fixed_point)( red_y*100000.+0.5); +- info_ptr->int_x_green = (png_fixed_point)(green_x*100000.+0.5); +- info_ptr->int_y_green = (png_fixed_point)(green_y*100000.+0.5); +- info_ptr->int_x_blue = (png_fixed_point)( blue_x*100000.+0.5); +- info_ptr->int_y_blue = (png_fixed_point)( blue_y*100000.+0.5); +-#endif +- info_ptr->valid |= PNG_INFO_cHRM; ++ 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); + } +-#endif /* PNG_FLOATING_POINT_SUPPORTED */ + +-#ifdef PNG_FIXED_POINT_SUPPORTED +-void PNGAPI +-png_set_cHRM_fixed(png_structp png_ptr, png_infop info_ptr, +- png_fixed_point white_x, png_fixed_point white_y, png_fixed_point red_x, +- png_fixed_point red_y, png_fixed_point green_x, png_fixed_point green_y, +- png_fixed_point blue_x, png_fixed_point blue_y) ++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_debug1(1, "in %s storage function", "cHRM fixed"); ++ png_XYZ XYZ; ++ ++ png_debug1(1, "in %s storage function", "cHRM XYZ fixed"); + + if (png_ptr == NULL || info_ptr == NULL) + return; + +-#ifdef PNG_CHECK_cHRM_SUPPORTED +- if (png_check_cHRM_fixed(png_ptr, +- white_x, white_y, red_x, red_y, green_x, green_y, blue_x, blue_y)) +-#endif +- { +- info_ptr->int_x_white = white_x; +- info_ptr->int_y_white = white_y; +- info_ptr->int_x_red = red_x; +- info_ptr->int_y_red = red_y; +- info_ptr->int_x_green = green_x; +- info_ptr->int_y_green = green_y; +- info_ptr->int_x_blue = blue_x; +- info_ptr->int_y_blue = blue_y; +-#ifdef PNG_FLOATING_POINT_SUPPORTED +- info_ptr->x_white = (float)(white_x/100000.); +- info_ptr->y_white = (float)(white_y/100000.); +- info_ptr->x_red = (float)( red_x/100000.); +- info_ptr->y_red = (float)( red_y/100000.); +- info_ptr->x_green = (float)(green_x/100000.); +- info_ptr->y_green = (float)(green_y/100000.); +- info_ptr->x_blue = (float)( blue_x/100000.); +- info_ptr->y_blue = (float)( blue_y/100000.); +-#endif +- info_ptr->valid |= PNG_INFO_cHRM; +- } ++ 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); + } +-#endif /* PNG_FIXED_POINT_SUPPORTED */ +-#endif /* PNG_cHRM_SUPPORTED */ + +-#ifdef PNG_gAMA_SUPPORTED +-#ifdef PNG_FLOATING_POINT_SUPPORTED ++# ifdef PNG_FLOATING_POINT_SUPPORTED + void PNGAPI +-png_set_gAMA(png_structp png_ptr, png_infop info_ptr, double file_gamma) ++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) + { +- double png_gamma; ++ png_set_cHRM_fixed(png_ptr, info_ptr, ++ png_fixed(png_ptr, white_x, "cHRM White X"), ++ png_fixed(png_ptr, white_y, "cHRM White Y"), ++ png_fixed(png_ptr, red_x, "cHRM Red X"), ++ png_fixed(png_ptr, red_y, "cHRM Red Y"), ++ png_fixed(png_ptr, green_x, "cHRM Green X"), ++ png_fixed(png_ptr, green_y, "cHRM Green Y"), ++ png_fixed(png_ptr, blue_x, "cHRM Blue X"), ++ png_fixed(png_ptr, blue_y, "cHRM Blue Y")); ++} + +- png_debug1(1, "in %s storage function", "gAMA"); ++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 Green X"), ++ png_fixed(png_ptr, green_Y, "cHRM Green Y"), ++ png_fixed(png_ptr, green_Z, "cHRM Green Z"), ++ png_fixed(png_ptr, blue_X, "cHRM Blue X"), ++ png_fixed(png_ptr, blue_Y, "cHRM Blue Y"), ++ png_fixed(png_ptr, blue_Z, "cHRM Blue Z")); ++} ++# endif /* FLOATING_POINT */ + +- if (png_ptr == NULL || info_ptr == NULL) +- return; ++#endif /* cHRM */ + +- /* Check for overflow */ +- if (file_gamma > 21474.83) +- { +- png_warning(png_ptr, "Limiting gamma to 21474.83"); +- png_gamma=21474.83; +- } +- else +- png_gamma = file_gamma; +- info_ptr->gamma = (float)png_gamma; +-#ifdef PNG_FIXED_POINT_SUPPORTED +- info_ptr->int_gamma = (int)(png_gamma*100000.+.5); +-#endif +- info_ptr->valid |= PNG_INFO_gAMA; +- if (png_gamma == 0.0) +- png_warning(png_ptr, "Setting gamma=0"); ++#ifdef PNG_eXIf_SUPPORTED ++void PNGAPI ++png_set_eXIf(png_const_structrp png_ptr, png_inforp info_ptr, ++ png_bytep eXIf_buf) ++{ ++ png_warning(png_ptr, "png_set_eXIf does not work; use png_set_eXIf_1"); ++ PNG_UNUSED(info_ptr) ++ PNG_UNUSED(eXIf_buf) + } +-#endif ++ + void PNGAPI +-png_set_gAMA_fixed(png_structp png_ptr, png_infop info_ptr, png_fixed_point +- int_gamma) ++png_set_eXIf_1(png_const_structrp png_ptr, png_inforp info_ptr, ++ png_uint_32 num_exif, png_bytep eXIf_buf) + { +- png_fixed_point png_gamma; ++ int i; + +- png_debug1(1, "in %s storage function", "gAMA"); ++ png_debug1(1, "in %s storage function", "eXIf"); + + if (png_ptr == NULL || info_ptr == NULL) + return; + +- if (int_gamma > (png_fixed_point)PNG_UINT_31_MAX) ++ if (info_ptr->exif) + { +- png_warning(png_ptr, "Limiting gamma to 21474.83"); +- png_gamma=PNG_UINT_31_MAX; ++ png_free(png_ptr, info_ptr->exif); ++ info_ptr->exif = NULL; + } +- else ++ ++ info_ptr->num_exif = num_exif; ++ ++ info_ptr->exif = png_voidcast(png_bytep, png_malloc_warn(png_ptr, ++ info_ptr->num_exif)); ++ ++ if (info_ptr->exif == NULL) + { +- if (int_gamma < 0) +- { +- png_warning(png_ptr, "Setting negative gamma to zero"); +- png_gamma = 0; +- } +- else +- png_gamma = int_gamma; ++ png_warning(png_ptr, "Insufficient memory for eXIf chunk data"); ++ return; + } +-#ifdef PNG_FLOATING_POINT_SUPPORTED +- info_ptr->gamma = (float)(png_gamma/100000.); +-#endif +-#ifdef PNG_FIXED_POINT_SUPPORTED +- info_ptr->int_gamma = png_gamma; +-#endif +- info_ptr->valid |= PNG_INFO_gAMA; +- if (png_gamma == 0) +- png_warning(png_ptr, "Setting gamma=0"); ++ ++ info_ptr->free_me |= PNG_FREE_EXIF; ++ ++ for (i = 0; i < (int) info_ptr->num_exif; i++) ++ info_ptr->exif[i] = eXIf_buf[i]; ++ ++ info_ptr->valid |= PNG_INFO_eXIf; + } ++#endif /* eXIf */ ++ ++#ifdef PNG_gAMA_SUPPORTED ++void PNGFAPI ++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; ++ ++ 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_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")); ++} ++# endif + #endif + + #ifdef PNG_hIST_SUPPORTED + void PNGAPI +-png_set_hIST(png_structp png_ptr, png_infop info_ptr, png_uint_16p hist) ++png_set_hIST(png_const_structrp png_ptr, png_inforp info_ptr, ++ png_const_uint_16p hist) + { + int i; + +@@ -192,42 +221,40 @@ png_set_hIST(png_structp png_ptr, png_infop info_ptr, png_uint_16p hist) + > PNG_MAX_PALETTE_LENGTH) + { + png_warning(png_ptr, +- "Invalid palette size, hIST allocation skipped."); ++ "Invalid palette size, hIST allocation skipped"); ++ + return; + } + +-#ifdef PNG_FREE_ME_SUPPORTED + png_free_data(png_ptr, info_ptr, PNG_FREE_HIST, 0); +-#endif ++ + /* Changed from info->num_palette to PNG_MAX_PALETTE_LENGTH in + * version 1.2.1 + */ +- png_ptr->hist = (png_uint_16p)png_malloc_warn(png_ptr, +- (png_uint_32)(PNG_MAX_PALETTE_LENGTH * png_sizeof(png_uint_16))); +- if (png_ptr->hist == NULL) ++ info_ptr->hist = png_voidcast(png_uint_16p, png_malloc_warn(png_ptr, ++ PNG_MAX_PALETTE_LENGTH * (sizeof (png_uint_16)))); ++ ++ if (info_ptr->hist == NULL) + { +- png_warning(png_ptr, "Insufficient memory for hIST chunk data."); ++ 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 = png_ptr->hist; +- info_ptr->valid |= PNG_INFO_hIST; ++ info_ptr->hist[i] = hist[i]; + +-#ifdef PNG_FREE_ME_SUPPORTED +- info_ptr->free_me |= PNG_FREE_HIST; +-#else +- png_ptr->flags |= PNG_FLAG_FREE_HIST; +-#endif ++ info_ptr->valid |= PNG_INFO_hIST; + } + #endif + + void PNGAPI +-png_set_IHDR(png_structp png_ptr, png_infop info_ptr, +- png_uint_32 width, png_uint_32 height, int bit_depth, +- int color_type, int interlace_type, int compression_type, +- int filter_type) ++png_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) + { + png_debug1(1, "in %s storage function", "IHDR"); + +@@ -248,30 +275,25 @@ png_set_IHDR(png_structp png_ptr, png_infop info_ptr, + + 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 RGBA pixels */ +- - 64 /* bigrowbuf hack */ +- - 1 /* filter byte */ +- - 7*8 /* rounding of width to multiple of 8 pixels */ +- - 8) /* extra max_pixel_depth pad */ +- info_ptr->rowbytes = (png_size_t)0; +- else +- info_ptr->rowbytes = PNG_ROWBYTES(info_ptr->pixel_depth, width); ++ info_ptr->rowbytes = PNG_ROWBYTES(info_ptr->pixel_depth, width); + } + + #ifdef PNG_oFFs_SUPPORTED + void PNGAPI +-png_set_oFFs(png_structp png_ptr, png_infop info_ptr, +- png_int_32 offset_x, png_int_32 offset_y, int unit_type) ++png_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"); + +@@ -287,28 +309,63 @@ png_set_oFFs(png_structp png_ptr, png_infop info_ptr, + + #ifdef PNG_pCAL_SUPPORTED + void PNGAPI +-png_set_pCAL(png_structp png_ptr, png_infop info_ptr, +- png_charp purpose, png_int_32 X0, png_int_32 X1, int type, int nparams, +- png_charp units, png_charpp params) ++png_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) + { +- png_uint_32 length; ++ size_t length; + int i; + + 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); +- info_ptr->pcal_purpose = (png_charp)png_malloc_warn(png_ptr, length); ++ (unsigned long)length); ++ ++ /* TODO: validate format of calibration name and unit name */ ++ ++ /* Check that the type matches the specification. */ ++ if (type < 0 || type > 3) ++ { ++ png_chunk_report(png_ptr, "Invalid pCAL equation type", ++ PNG_CHUNK_WRITE_ERROR); ++ return; ++ } ++ ++ if (nparams < 0 || nparams > 255) ++ { ++ png_chunk_report(png_ptr, "Invalid pCAL parameter count", ++ PNG_CHUNK_WRITE_ERROR); ++ return; ++ } ++ ++ /* Validate params[nparams] */ ++ for (i=0; ipcal_purpose = png_voidcast(png_charp, ++ png_malloc_warn(png_ptr, length)); ++ + if (info_ptr->pcal_purpose == NULL) + { +- png_warning(png_ptr, "Insufficient memory for pCAL purpose."); ++ png_chunk_report(png_ptr, "Insufficient memory for pCAL purpose", ++ PNG_CHUNK_WRITE_ERROR); + return; + } +- png_memcpy(info_ptr->pcal_purpose, purpose, (png_size_t)length); ++ ++ memcpy(info_ptr->pcal_purpose, purpose, length); + + png_debug(3, "storing X0, X1, type, and nparams in info"); + info_ptr->pcal_X0 = X0; +@@ -316,118 +373,188 @@ png_set_pCAL(png_structp png_ptr, png_infop info_ptr, + 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); ++ (unsigned long)length); ++ ++ info_ptr->pcal_units = png_voidcast(png_charp, ++ png_malloc_warn(png_ptr, length)); ++ + if (info_ptr->pcal_units == NULL) + { +- png_warning(png_ptr, "Insufficient memory for pCAL units."); ++ png_warning(png_ptr, "Insufficient memory for pCAL units"); ++ + return; + } +- png_memcpy(info_ptr->pcal_units, units, (png_size_t)length); + +- info_ptr->pcal_params = (png_charpp)png_malloc_warn(png_ptr, +- (png_uint_32)((nparams + 1) * png_sizeof(png_charp))); ++ memcpy(info_ptr->pcal_units, units, length); ++ ++ info_ptr->pcal_params = png_voidcast(png_charpp, png_malloc_warn(png_ptr, ++ (size_t)(((unsigned int)nparams + 1) * (sizeof (png_charp))))); ++ + if (info_ptr->pcal_params == NULL) + { +- png_warning(png_ptr, "Insufficient memory for pCAL params."); ++ png_warning(png_ptr, "Insufficient memory for pCAL params"); ++ + return; + } + +- png_memset(info_ptr->pcal_params, 0, (nparams + 1) * png_sizeof(png_charp)); ++ memset(info_ptr->pcal_params, 0, ((unsigned int)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); ++ (unsigned long)length); ++ + info_ptr->pcal_params[i] = (png_charp)png_malloc_warn(png_ptr, length); ++ + if (info_ptr->pcal_params[i] == NULL) + { +- png_warning(png_ptr, "Insufficient memory for pCAL parameter."); ++ png_warning(png_ptr, "Insufficient memory for pCAL parameter"); ++ + return; + } +- png_memcpy(info_ptr->pcal_params[i], params[i], (png_size_t)length); ++ ++ memcpy(info_ptr->pcal_params[i], params[i], length); + } + + info_ptr->valid |= PNG_INFO_pCAL; +-#ifdef PNG_FREE_ME_SUPPORTED + info_ptr->free_me |= PNG_FREE_PCAL; +-#endif + } + #endif + +-#if defined(PNG_READ_sCAL_SUPPORTED) || defined(PNG_WRITE_sCAL_SUPPORTED) +-#ifdef PNG_FLOATING_POINT_SUPPORTED ++#ifdef PNG_sCAL_SUPPORTED + void PNGAPI +-png_set_sCAL(png_structp png_ptr, png_infop info_ptr, +- int unit, double width, double height) ++png_set_sCAL_s(png_const_structrp png_ptr, png_inforp info_ptr, ++ int unit, png_const_charp swidth, png_const_charp sheight) + { ++ size_t lengthw = 0, lengthh = 0; ++ + png_debug1(1, "in %s storage function", "sCAL"); + + if (png_ptr == NULL || info_ptr == NULL) + return; + +- info_ptr->scal_unit = (png_byte)unit; +- info_ptr->scal_pixel_width = width; +- info_ptr->scal_pixel_height = height; +- +- info_ptr->valid |= PNG_INFO_sCAL; +-} +-#else +-#ifdef PNG_FIXED_POINT_SUPPORTED +-void PNGAPI +-png_set_sCAL_s(png_structp png_ptr, png_infop info_ptr, +- int unit, png_charp swidth, png_charp sheight) +-{ +- png_uint_32 length; ++ /* Double check the unit (should never get here with an invalid ++ * unit unless this is an API call.) ++ */ ++ if (unit != 1 && unit != 2) ++ png_error(png_ptr, "Invalid sCAL unit"); + +- png_debug1(1, "in %s storage function", "sCAL"); ++ if (swidth == NULL || (lengthw = strlen(swidth)) == 0 || ++ swidth[0] == 45 /* '-' */ || !png_check_fp_string(swidth, lengthw)) ++ png_error(png_ptr, "Invalid sCAL width"); + +- if (png_ptr == NULL || info_ptr == NULL) +- return; ++ if (sheight == NULL || (lengthh = strlen(sheight)) == 0 || ++ sheight[0] == 45 /* '-' */ || !png_check_fp_string(sheight, lengthh)) ++ png_error(png_ptr, "Invalid sCAL height"); + + info_ptr->scal_unit = (png_byte)unit; + +- length = png_strlen(swidth) + 1; +- png_debug1(3, "allocating unit for info (%u bytes)", +- (unsigned int)length); +- info_ptr->scal_s_width = (png_charp)png_malloc_warn(png_ptr, length); ++ ++lengthw; ++ ++ png_debug1(3, "allocating unit for info (%u bytes)", (unsigned int)lengthw); ++ ++ info_ptr->scal_s_width = png_voidcast(png_charp, ++ png_malloc_warn(png_ptr, lengthw)); ++ + if (info_ptr->scal_s_width == NULL) + { +- png_warning(png_ptr, +- "Memory allocation failed while processing sCAL."); ++ png_warning(png_ptr, "Memory allocation failed while processing sCAL"); ++ + return; + } +- png_memcpy(info_ptr->scal_s_width, swidth, (png_size_t)length); + +- length = png_strlen(sheight) + 1; +- png_debug1(3, "allocating unit for info (%u bytes)", +- (unsigned int)length); +- info_ptr->scal_s_height = (png_charp)png_malloc_warn(png_ptr, length); ++ 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_voidcast(png_charp, ++ png_malloc_warn(png_ptr, lengthh)); ++ + if (info_ptr->scal_s_height == NULL) + { + png_free (png_ptr, info_ptr->scal_s_width); + info_ptr->scal_s_width = NULL; +- png_warning(png_ptr, +- "Memory allocation failed while processing sCAL."); ++ ++ png_warning(png_ptr, "Memory allocation failed while processing sCAL"); ++ + return; + } +- png_memcpy(info_ptr->scal_s_height, sheight, (png_size_t)length); ++ ++ memcpy(info_ptr->scal_s_height, sheight, lengthh); ++ + info_ptr->valid |= PNG_INFO_sCAL; +-#ifdef PNG_FREE_ME_SUPPORTED + info_ptr->free_me |= PNG_FREE_SCAL; +-#endif + } +-#endif +-#endif ++ ++# ifdef PNG_FLOATING_POINT_SUPPORTED ++void PNGAPI ++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"); ++ ++ /* Check the arguments. */ ++ if (width <= 0) ++ png_warning(png_ptr, "Invalid sCAL width ignored"); ++ ++ else if (height <= 0) ++ png_warning(png_ptr, "Invalid sCAL height ignored"); ++ ++ else ++ { ++ /* Convert 'width' and 'height' to ASCII. */ ++ 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_sCAL_PRECISION); ++ png_ascii_from_fp(png_ptr, sheight, (sizeof sheight), height, ++ PNG_sCAL_PRECISION); ++ ++ png_set_sCAL_s(png_ptr, info_ptr, unit, swidth, sheight); ++ } ++} ++# endif ++ ++# ifdef PNG_FIXED_POINT_SUPPORTED ++void PNGAPI ++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"); ++ ++ /* Check the arguments. */ ++ if (width <= 0) ++ png_warning(png_ptr, "Invalid sCAL width ignored"); ++ ++ else if (height <= 0) ++ png_warning(png_ptr, "Invalid sCAL height ignored"); ++ ++ else ++ { ++ /* Convert 'width' and 'height' to ASCII. */ ++ 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_set_sCAL_s(png_ptr, info_ptr, unit, swidth, sheight); ++ } ++} ++# endif + #endif + + #ifdef PNG_pHYs_SUPPORTED + void PNGAPI +-png_set_pHYs(png_structp png_ptr, png_infop info_ptr, +- png_uint_32 res_x, png_uint_32 res_y, int unit_type) ++png_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"); + +@@ -442,275 +569,286 @@ png_set_pHYs(png_structp png_ptr, png_infop info_ptr, + #endif + + void PNGAPI +-png_set_PLTE(png_structp png_ptr, png_infop info_ptr, +- png_colorp palette, int num_palette) ++png_set_PLTE(png_structrp png_ptr, png_inforp info_ptr, ++ png_const_colorp palette, int num_palette) + { + ++ png_uint_32 max_palette_length; ++ + png_debug1(1, "in %s storage function", "PLTE"); + + if (png_ptr == NULL || info_ptr == NULL) + return; + +- if (num_palette < 0 || num_palette > PNG_MAX_PALETTE_LENGTH) ++ max_palette_length = (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE) ? ++ (1 << info_ptr->bit_depth) : PNG_MAX_PALETTE_LENGTH; ++ ++ if (num_palette < 0 || num_palette > (int) max_palette_length) + { + if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE) + png_error(png_ptr, "Invalid palette length"); ++ + else + { + png_warning(png_ptr, "Invalid palette length"); ++ + return; + } + } + ++ if ((num_palette > 0 && palette == NULL) || ++ (num_palette == 0 ++# ifdef PNG_MNG_FEATURES_SUPPORTED ++ && (png_ptr->mng_features_permitted & PNG_FLAG_MNG_EMPTY_PLTE) == 0 ++# endif ++ )) ++ { ++ png_error(png_ptr, "Invalid palette"); ++ } ++ + /* 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. + */ +-#ifdef PNG_FREE_ME_SUPPORTED + png_free_data(png_ptr, info_ptr, PNG_FREE_PLTE, 0); +-#endif + + /* Changed in libpng-1.2.1 to allocate PNG_MAX_PALETTE_LENGTH instead +- * of num_palette entries, in case of an invalid PNG file that has +- * too-large sample values. ++ * of num_palette entries, in case of an invalid PNG file or incorrect ++ * call to png_set_PLTE() with too-large sample values. + */ +- png_ptr->palette = (png_colorp)png_calloc(png_ptr, +- PNG_MAX_PALETTE_LENGTH * png_sizeof(png_color)); +- png_memcpy(png_ptr->palette, palette, num_palette * png_sizeof(png_color)); ++ png_ptr->palette = png_voidcast(png_colorp, png_calloc(png_ptr, ++ PNG_MAX_PALETTE_LENGTH * (sizeof (png_color)))); ++ ++ if (num_palette > 0) ++ memcpy(png_ptr->palette, palette, (unsigned int)num_palette * ++ (sizeof (png_color))); + info_ptr->palette = png_ptr->palette; + info_ptr->num_palette = png_ptr->num_palette = (png_uint_16)num_palette; + +-#ifdef PNG_FREE_ME_SUPPORTED + info_ptr->free_me |= PNG_FREE_PLTE; +-#else +- png_ptr->flags |= PNG_FLAG_FREE_PLTE; +-#endif + + info_ptr->valid |= PNG_INFO_PLTE; + } + + #ifdef PNG_sBIT_SUPPORTED + void PNGAPI +-png_set_sBIT(png_structp png_ptr, png_infop info_ptr, +- png_color_8p sig_bit) ++png_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 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)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, +- int intent) ++png_set_sRGB_gAMA_and_cHRM(png_const_structrp png_ptr, png_inforp info_ptr, ++ int srgb_intent) + { +-#ifdef PNG_gAMA_SUPPORTED +-#ifdef PNG_FLOATING_POINT_SUPPORTED +- float file_gamma; +-#endif +-#ifdef PNG_FIXED_POINT_SUPPORTED +- png_fixed_point int_file_gamma; +-#endif +-#endif +-#ifdef PNG_cHRM_SUPPORTED +-#ifdef PNG_FLOATING_POINT_SUPPORTED +- float white_x, white_y, red_x, red_y, green_x, green_y, blue_x, blue_y; +-#endif +- png_fixed_point int_white_x, int_white_y, int_red_x, int_red_y, int_green_x, +- int_green_y, int_blue_x, int_blue_y; +-#endif + png_debug1(1, "in %s storage function", "sRGB_gAMA_and_cHRM"); + + if (png_ptr == NULL || info_ptr == NULL) + return; + +- png_set_sRGB(png_ptr, info_ptr, intent); +- +-#ifdef PNG_gAMA_SUPPORTED +-#ifdef PNG_FLOATING_POINT_SUPPORTED +- file_gamma = (float).45455; +- png_set_gAMA(png_ptr, info_ptr, file_gamma); +-#endif +-#ifdef PNG_FIXED_POINT_SUPPORTED +- int_file_gamma = 45455L; +- png_set_gAMA_fixed(png_ptr, info_ptr, int_file_gamma); +-#endif +-#endif +- +-#ifdef PNG_cHRM_SUPPORTED +- int_white_x = 31270L; +- int_white_y = 32900L; +- int_red_x = 64000L; +- int_red_y = 33000L; +- int_green_x = 30000L; +- int_green_y = 60000L; +- int_blue_x = 15000L; +- int_blue_y = 6000L; +- +-#ifdef PNG_FLOATING_POINT_SUPPORTED +- white_x = (float).3127; +- white_y = (float).3290; +- red_x = (float).64; +- red_y = (float).33; +- green_x = (float).30; +- green_y = (float).60; +- blue_x = (float).15; +- blue_y = (float).06; +-#endif ++ 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_FIXED_POINT_SUPPORTED +- png_set_cHRM_fixed(png_ptr, info_ptr, +- int_white_x, int_white_y, int_red_x, int_red_y, int_green_x, +- int_green_y, int_blue_x, int_blue_y); +-#endif +-#ifdef PNG_FLOATING_POINT_SUPPORTED +- png_set_cHRM(png_ptr, info_ptr, +- white_x, white_y, red_x, red_y, green_x, green_y, blue_x, blue_y); +-#endif +-#endif /* cHRM */ ++ 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_charp name, int compression_type, +- png_charp profile, png_uint_32 proflen) ++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_charp new_iccp_profile; +- png_uint_32 length; ++ png_bytep new_iccp_profile; ++ 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_charp)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, +- "Insufficient memory to process iCCP profile."); ++ png_free(png_ptr, new_iccp_name); ++ 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; +-#ifdef PNG_FREE_ME_SUPPORTED + info_ptr->free_me |= PNG_FREE_ICCP; +-#endif + info_ptr->valid |= PNG_INFO_iCCP; + } + #endif + + #ifdef PNG_TEXT_SUPPORTED + void PNGAPI +-png_set_text(png_structp png_ptr, png_infop info_ptr, png_textp text_ptr, +- int num_text) ++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_textp text_ptr, +- int num_text) ++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 ? 0xabadca11U : ++ (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; +- +- old_max = info_ptr->max_text; +- info_ptr->max_text = info_ptr->num_text + num_text + 8; +- old_text = info_ptr->text; +- info_ptr->text = (png_textp)png_malloc_warn(png_ptr, +- (png_uint_32)(info_ptr->max_text * png_sizeof(png_text))); +- if (info_ptr->text == NULL) +- { +- png_free(png_ptr, old_text); +- return(1); +- } +- png_memcpy(info_ptr->text, old_text, (png_size_t)(old_max * +- png_sizeof(png_text))); +- png_free(png_ptr, old_text); ++ max_text += num_text; ++ ++ /* Round up to a multiple of 8 */ ++ if (max_text < INT_MAX-8) ++ max_text = (max_text + 8) & ~0x7; ++ ++ else ++ max_text = INT_MAX; ++ ++ /* 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_uint_32)(info_ptr->max_text * png_sizeof(png_text))); +- if (info_ptr->text == NULL) +- return(1); +-#ifdef PNG_FREE_ME_SUPPORTED +- info_ptr->free_me |= PNG_FREE_TEXT; +-#endif ++ png_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) + continue; + +- key_len = png_strlen(text_ptr[i].key); ++ if (text_ptr[i].compression < PNG_TEXT_COMPRESSION_NONE || ++ text_ptr[i].compression >= PNG_TEXT_COMPRESSION_LAST) ++ { ++ png_chunk_report(png_ptr, "text compression mode is out of range", ++ PNG_CHUNK_WRITE_ERROR); ++ continue; ++ } ++ ++ key_len = strlen(text_ptr[i].key); + + if (text_ptr[i].compression <= 0) + { +@@ -719,403 +857,679 @@ png_set_text_2(png_structp png_ptr, png_infop info_ptr, png_textp text_ptr, + } + + else +-#ifdef PNG_iTXt_SUPPORTED ++# ifdef PNG_iTXt_SUPPORTED + { + /* 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 */ ++# else /* iTXt */ + { +- png_warning(png_ptr, "iTXt chunk not supported."); ++ png_chunk_report(png_ptr, "iTXt chunk not supported", ++ PNG_CHUNK_WRITE_ERROR); + continue; + } +-#endif ++# endif + + if (text_ptr[i].text == NULL || text_ptr[i].text[0] == '\0') + { + text_length = 0; +-#ifdef PNG_iTXt_SUPPORTED ++# ifdef PNG_iTXt_SUPPORTED + if (text_ptr[i].compression > 0) + textp->compression = PNG_ITXT_COMPRESSION_NONE; ++ + else +-#endif ++# endif + textp->compression = PNG_TEXT_COMPRESSION_NONE; + } + + 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_uint_32) +- (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_debug2(2, "Allocated %lu bytes at %x in png_set_text", +- (png_uint_32) +- (key_len + lang_len + lang_key_len + text_length + 4), +- (int)textp->key); ++ { ++ png_chunk_report(png_ptr, "text chunk: out of memory", ++ PNG_CHUNK_WRITE_ERROR); + +- png_memcpy(textp->key, text_ptr[i].key,(png_size_t)(key_len)); ++ return 1; ++ } ++ ++ png_debug2(2, "Allocated %lu bytes at %p in png_set_text", ++ (unsigned long)(png_uint_32) ++ (key_len + lang_len + lang_key_len + text_length + 4), ++ textp->key); ++ ++ memcpy(textp->key, text_ptr[i].key, key_len); + *(textp->key + key_len) = '\0'; +-#ifdef PNG_iTXt_SUPPORTED ++ + if (text_ptr[i].compression > 0) + { + textp->lang = textp->key + key_len + 1; +- png_memcpy(textp->lang, text_ptr[i].lang, lang_len); ++ 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; + } ++ + else +-#endif + { +-#ifdef PNG_iTXt_SUPPORTED + textp->lang=NULL; + textp->lang_key=NULL; +-#endif + textp->text = textp->key + key_len + 1; + } +- if (text_length) +- png_memcpy(textp->text, text_ptr[i].text, +- (png_size_t)(text_length)); ++ ++ if (text_length != 0) ++ memcpy(textp->text, text_ptr[i].text, text_length); ++ + *(textp->text + text_length) = '\0'; + +-#ifdef PNG_iTXt_SUPPORTED ++# ifdef PNG_iTXt_SUPPORTED + if (textp->compression > 0) + { + textp->text_length = 0; + textp->itxt_length = text_length; + } +- else +-#endif + ++ else ++# endif + { + textp->text_length = text_length; +-#ifdef PNG_iTXt_SUPPORTED + textp->itxt_length = 0; +-#endif + } ++ + info_ptr->num_text++; + png_debug1(3, "transferred text chunk %d", info_ptr->num_text); + } ++ + return(0); + } + #endif + + #ifdef PNG_tIME_SUPPORTED + void PNGAPI +-png_set_tIME(png_structp png_ptr, png_infop info_ptr, png_timep mod_time) ++png_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; ++ ++ 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; ++ } + +- png_memcpy(&(info_ptr->mod_time), mod_time, png_sizeof(png_time)); ++ 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_bytep trans, int num_trans, png_color_16p trans_values) ++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"); + + if (png_ptr == NULL || info_ptr == NULL) ++ + return; + +- if (trans != NULL) ++ if (trans_alpha != NULL) + { +- /* It may not actually be necessary to set png_ptr->trans here; ++ /* 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). + */ + +-#ifdef PNG_FREE_ME_SUPPORTED + png_free_data(png_ptr, info_ptr, PNG_FREE_TRNS, 0); +-#endif + +- /* Changed from num_trans to PNG_MAX_PALETTE_LENGTH in version 1.2.1 */ +- png_ptr->trans = info_ptr->trans = (png_bytep)png_malloc(png_ptr, +- (png_uint_32)PNG_MAX_PALETTE_LENGTH); + if (num_trans > 0 && num_trans <= PNG_MAX_PALETTE_LENGTH) +- png_memcpy(info_ptr->trans, trans, (png_size_t)num_trans); ++ { ++ /* Changed from num_trans to PNG_MAX_PALETTE_LENGTH in version 1.2.1 */ ++ info_ptr->trans_alpha = png_voidcast(png_bytep, ++ png_malloc(png_ptr, PNG_MAX_PALETTE_LENGTH)); ++ memcpy(info_ptr->trans_alpha, trans_alpha, (size_t)num_trans); ++ } ++ png_ptr->trans_alpha = info_ptr->trans_alpha; + } + +- if (trans_values != NULL) ++ if (trans_color != NULL) + { +- int sample_max = (1 << info_ptr->bit_depth); +- if ((info_ptr->color_type == PNG_COLOR_TYPE_GRAY && +- (int)trans_values->gray > sample_max) || +- (info_ptr->color_type == PNG_COLOR_TYPE_RGB && +- ((int)trans_values->red > sample_max || +- (int)trans_values->green > sample_max || +- (int)trans_values->blue > sample_max))) +- png_warning(png_ptr, +- "tRNS chunk has out-of-range samples for bit_depth"); +- png_memcpy(&(info_ptr->trans_values), trans_values, +- png_sizeof(png_color_16)); ++#ifdef PNG_WARNINGS_SUPPORTED ++ if (info_ptr->bit_depth < 16) ++ { ++ int sample_max = (1 << info_ptr->bit_depth) - 1; ++ ++ if ((info_ptr->color_type == PNG_COLOR_TYPE_GRAY && ++ trans_color->gray > sample_max) || ++ (info_ptr->color_type == PNG_COLOR_TYPE_RGB && ++ (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"); ++ } ++#endif ++ ++ info_ptr->trans_color = *trans_color; ++ + if (num_trans == 0) + num_trans = 1; + } + + info_ptr->num_trans = (png_uint_16)num_trans; ++ + if (num_trans != 0) + { + info_ptr->valid |= PNG_INFO_tRNS; +-#ifdef PNG_FREE_ME_SUPPORTED + info_ptr->free_me |= PNG_FREE_TRNS; +-#else +- png_ptr->flags |= PNG_FLAG_FREE_TRNS; +-#endif + } + } + #endif + + #ifdef PNG_sPLT_SUPPORTED + void PNGAPI +-png_set_sPLT(png_structp png_ptr, +- png_infop info_ptr, png_sPLT_tp entries, int nentries) ++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 + * in the info structure. ++ * + * nentries - number of palette structures to be + * added. + */ + { + png_sPLT_tp np; +- int i; + +- if (png_ptr == NULL || info_ptr == NULL) ++ 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_uint_32)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=NULL; ++ info_ptr->splt_palettes = np; ++ info_ptr->free_me |= PNG_FREE_SPLT; ++ ++ 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_sPLT_tp from = entries + i; +- png_uint_32 length; ++ size_t length; + +- length = png_strlen(from->name) + 1; +- to->name = (png_charp)png_malloc_warn(png_ptr, 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_uint_32)(from->nentries * png_sizeof(png_sPLT_entry))); +- if (to->entries == NULL) ++ ++ np->depth = entries->depth; ++ ++ /* 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)); +- to->nentries = from->nentries; +- to->depth = from->depth; ++ ++ 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, ++ (unsigned int)entries->nentries * sizeof (png_sPLT_entry)); ++ ++ /* 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; ++ ++entries; + } ++ while (--nentries); + +- info_ptr->splt_palettes = np; +- info_ptr->splt_palettes_num += nentries; +- info_ptr->valid |= PNG_INFO_sPLT; +-#ifdef PNG_FREE_ME_SUPPORTED +- info_ptr->free_me |= PNG_FREE_SPLT; +-#endif ++ 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)); ++ } ++ ++ /* 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_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_uint_32)((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, +- info_ptr->unknown_chunks_num * png_sizeof(png_unknown_chunk)); + png_free(png_ptr, info_ptr->unknown_chunks); +- info_ptr->unknown_chunks = NULL; ++ info_ptr->unknown_chunks = np; /* safe because it is initialized */ ++ info_ptr->free_me |= PNG_FREE_UNKN; + +- for (i = 0; i < num_unknowns; i++) ++ np += info_ptr->unknown_chunks_num; ++ ++ /* 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_unknown_chunkp from = unknowns + i; +- +- png_memcpy((png_charp)to->name, (png_charp)from->name, +- png_sizeof(from->name)); +- to->name[png_sizeof(to->name)-1] = '\0'; +- to->size = from->size; +- /* Note our location in the read or write sequence */ +- to->location = (png_byte)(png_ptr->mode & 0xff); +- +- if (from->size == 0) +- to->data=NULL; ++ memcpy(np->name, unknowns->name, (sizeof np->name)); ++ np->name[(sizeof np->name)-1] = '\0'; ++ np->location = check_location(png_ptr, unknowns->location); ++ ++ if (unknowns->size == 0) ++ { ++ np->data = NULL; ++ np->size = 0; ++ } ++ + else + { +- to->data = (png_bytep)png_malloc_warn(png_ptr, +- (png_uint_32)from->size); +- if (to->data == NULL) ++ np->data = png_voidcast(png_bytep, ++ png_malloc_base(png_ptr, unknowns->size)); ++ ++ 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; + } +- } + +- info_ptr->unknown_chunks = np; +- info_ptr->unknown_chunks_num += num_unknowns; +-#ifdef PNG_FREE_ME_SUPPORTED +- info_ptr->free_me |= PNG_FREE_UNKN; +-#endif +-} +-void PNGAPI +-png_set_unknown_chunk_location(png_structp png_ptr, png_infop info_ptr, +- int chunk, int location) +-{ +- if (png_ptr != NULL && info_ptr != NULL && chunk >= 0 && chunk < +- (int)info_ptr->unknown_chunks_num) +- info_ptr->unknown_chunks[chunk].location = (png_byte)location; ++ /* 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); ++ } + } +-#endif + +-#if defined(PNG_1_0_X) || defined(PNG_1_2_X) +-#if defined(PNG_READ_EMPTY_PLTE_SUPPORTED) || \ +- defined(PNG_WRITE_EMPTY_PLTE_SUPPORTED) + void PNGAPI +-png_permit_empty_plte (png_structp png_ptr, int empty_plte_permitted) ++png_set_unknown_chunk_location(png_const_structrp png_ptr, png_inforp info_ptr, ++ int chunk, int location) + { +- /* This function is deprecated in favor of png_permit_mng_features() +- and will be removed from libpng-1.3.0 */ ++ /* 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 (((unsigned int)location & PNG_HAVE_IDAT) != 0) /* undocumented! */ ++ location = PNG_AFTER_IDAT; + +- png_debug(1, "in png_permit_empty_plte, DEPRECATED."); ++ else ++ location = PNG_HAVE_IHDR; /* also undocumented */ ++ } + +- if (png_ptr == NULL) +- return; +- png_ptr->mng_features_permitted = (png_byte) +- ((png_ptr->mng_features_permitted & (~PNG_FLAG_MNG_EMPTY_PLTE)) | +- ((empty_plte_permitted & PNG_FLAG_MNG_EMPTY_PLTE))); ++ info_ptr->unknown_chunks[chunk].location = ++ check_location(png_ptr, location); ++ } + } +-#endif +-#endif ++#endif /* STORE_UNKNOWN_CHUNKS */ + + #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; +- png_ptr->mng_features_permitted = +- (png_byte)(mng_features & PNG_ALL_MNG_FEATURES); +- return (png_uint_32)png_ptr->mng_features_permitted; ++ return 0; ++ ++ png_ptr->mng_features_permitted = mng_features & PNG_ALL_MNG_FEATURES; ++ ++ 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= 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; ++ png_app_error(png_ptr, "png_set_keep_unknown_chunks: invalid keep"); + +- if (keep == PNG_HANDLE_CHUNK_ALWAYS) +- png_ptr->flags |= PNG_FLAG_KEEP_UNSAFE_CHUNKS; +- else +- png_ptr->flags &= ~PNG_FLAG_KEEP_UNSAFE_CHUNKS; + return; + } +- if (chunk_list == NULL) +- return; ++ ++ 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 const png_byte chunks_to_ignore[] = { ++ 98, 75, 71, 68, '\0', /* bKGD */ ++ 99, 72, 82, 77, '\0', /* cHRM */ ++ 101, 88, 73, 102, '\0', /* eXIf */ ++ 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 = (unsigned int)num_chunks_in; ++ } ++ + old_num_chunks = png_ptr->num_chunk_list; +- new_list=(png_bytep)png_malloc(png_ptr, +- (png_uint_32) +- (5*(num_chunks + old_num_chunks))); +- if (png_ptr->chunk_list != NULL) ++ if (png_ptr->chunk_list == NULL) ++ old_num_chunks = 0; ++ ++ /* Since num_chunks is always restricted to UINT_MAX/5 this can't overflow. ++ */ ++ if (num_chunks + old_num_chunks > UINT_MAX/5) ++ { ++ png_app_error(png_ptr, "png_set_keep_unknown_chunks: too many chunks"); ++ ++ return; ++ } ++ ++ /* 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) + { +- 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; ++ new_list = png_voidcast(png_bytep, png_malloc(png_ptr, ++ 5 * (num_chunks + old_num_chunks))); ++ ++ if (old_num_chunks > 0) ++ memcpy(new_list, png_ptr->chunk_list, 5*old_num_chunks); ++ } ++ ++ 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; ichunk_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; + } +- png_memcpy(new_list + 5*old_num_chunks, chunk_list, +- (png_size_t)(5*num_chunks)); +- for (p = new_list + 5*old_num_chunks + 4, i = 0; inum_chunk_list = old_num_chunks + num_chunks; +- png_ptr->chunk_list = new_list; +-#ifdef PNG_FREE_ME_SUPPORTED +- png_ptr->free_me |= PNG_FREE_LIST; +-#endif + } + #endif + + #ifdef PNG_READ_USER_CHUNKS_SUPPORTED + void PNGAPI +-png_set_read_user_chunk_fn(png_structp png_ptr, png_voidp user_chunk_ptr, +- png_user_chunk_ptr read_user_chunk_fn) ++png_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"); + +@@ -1129,98 +1543,260 @@ png_set_read_user_chunk_fn(png_structp png_ptr, png_voidp user_chunk_ptr, + + #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_uint_32 size) ++png_set_compression_buffer_size(png_structrp png_ptr, size_t size) + { +- if (png_ptr == NULL) +- return; +- png_free(png_ptr, png_ptr->zbuf); +- png_ptr->zbuf_size = (png_size_t)size; +- png_ptr->zbuf = (png_bytep)png_malloc(png_ptr, size); +- png_ptr->zstream.next_out = png_ptr->zbuf; +- png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size; +-} ++ if (png_ptr == NULL) ++ return; + +-void PNGAPI +-png_set_invalid(png_structp png_ptr, png_infop info_ptr, int mask) +-{ +- if (png_ptr && info_ptr) +- info_ptr->valid &= ~mask; +-} ++ if (size == 0 || size > PNG_UINT_31_MAX) ++ png_error(png_ptr, "invalid compression buffer size"); + ++# 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 + +-#ifndef PNG_1_0_X +-#ifdef PNG_ASSEMBLER_CODE_SUPPORTED +-/* Function was added to libpng 1.2.0 and should always exist by default */ +-void PNGAPI +-png_set_asm_flags (png_structp png_ptr, png_uint_32 asm_flags) +-{ +-/* Obsolete as of libpng-1.2.20 and will be removed from libpng-1.4.0 */ +- if (png_ptr != NULL) +- png_ptr->asm_flags = 0; +- asm_flags = asm_flags; /* Quiet the compiler */ ++# 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; ++ } ++ ++#ifndef __COVERITY__ ++ /* Some compilers complain that this is always false. However, it ++ * can be true when integer overflow happens. ++ */ ++ if (size > ZLIB_IO_MAX) ++ { ++ png_warning(png_ptr, ++ "Compression buffer size limited to system maximum"); ++ size = ZLIB_IO_MAX; /* must fit */ ++ } ++#endif ++ ++ 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 + } + +-/* This function was added to libpng 1.2.0 */ + void PNGAPI +-png_set_mmx_thresholds (png_structp png_ptr, +- png_byte mmx_bitdepth_threshold, +- png_uint_32 mmx_rowbytes_threshold) ++png_set_invalid(png_const_structrp png_ptr, png_inforp info_ptr, int mask) + { +-/* Obsolete as of libpng-1.2.20 and will be removed from libpng-1.4.0 */ +- if (png_ptr == NULL) +- return; +- /* Quiet the compiler */ +- mmx_bitdepth_threshold = mmx_bitdepth_threshold; +- mmx_rowbytes_threshold = mmx_rowbytes_threshold; ++ if (png_ptr != NULL && info_ptr != NULL) ++ info_ptr->valid &= (unsigned int)(~mask); + } +-#endif /* ?PNG_ASSEMBLER_CODE_SUPPORTED */ ++ + + #ifdef PNG_SET_USER_LIMITS_SUPPORTED + /* This function was added to libpng 1.2.6 */ + void PNGAPI +-png_set_user_limits (png_structp png_ptr, png_uint_32 user_width_max, ++png_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 + * rejected by png_set_IHDR(). To accept any PNG datastream +- * regardless of dimensions, set both limits to 0x7ffffffL. ++ * regardless of dimensions, set both limits to 0x7fffffff. + */ + if (png_ptr == NULL) + return; ++ + png_ptr->user_width_max = user_width_max; + png_ptr->user_height_max = user_height_max; + } +-#endif /* ?PNG_SET_USER_LIMITS_SUPPORTED */ ++ ++/* This function was added to libpng 1.4.0 */ ++void PNGAPI ++png_set_chunk_cache_max (png_structrp png_ptr, png_uint_32 user_chunk_cache_max) ++{ ++ 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_structrp png_ptr, ++ png_alloc_size_t user_chunk_malloc_max) ++{ ++ if (png_ptr != NULL) ++ png_ptr->user_chunk_malloc_max = user_chunk_malloc_max; ++} ++#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_FLAG_APP_WARNINGS_WARN | PNG_FLAG_APP_ERRORS_WARN); ++} ++#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->flags &= ~PNG_FLAG_BENIGN_ERRORS_WARN; ++ png_ptr->num_palette_max = -1; ++} ++#endif ++ ++#if defined(PNG_TEXT_SUPPORTED) || defined(PNG_pCAL_SUPPORTED) || \ ++ defined(PNG_iCCP_SUPPORTED) || defined(PNG_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. ++ */ ++png_uint_32 /* PRIVATE */ ++png_check_keyword(png_structrp png_ptr, png_const_charp key, png_bytep new_key) ++{ ++#ifdef PNG_WARNINGS_SUPPORTED ++ png_const_charp orig_key = key; ++#endif ++ 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)*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(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'"); ++ } ++#else /* !WARNINGS */ ++ PNG_UNUSED(png_ptr) ++#endif /* !WARNINGS */ ++ ++ return key_len; + } +-#endif /* PNG_BENIGN_ERRORS_SUPPORTED */ +-#endif /* ?PNG_1_0_X */ +-#endif /* PNG_READ_SUPPORTED || PNG_WRITE_SUPPORTED */ ++#endif /* TEXT || pCAL || iCCP || sPLT */ ++#endif /* READ || WRITE */ +diff --git a/com32/lib/libpng/pngtest.c b/com32/lib/libpng/pngtest.c +index fd0e432c..f27e91eb 100644 +--- a/com32/lib/libpng/pngtest.c ++++ b/com32/lib/libpng/pngtest.c +@@ -1,10 +1,10 @@ + + /* pngtest.c - a simple test program to test libpng + * +- * Last changed in libpng 1.2.43 [February 25, 2010] +- * Copyright (c) 1998-2010 Glenn Randers-Pehrson +- * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) +- * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) ++ * Copyright (c) 2018 Cosmin Truta ++ * Copyright (c) 1998-2002,2004,2006-2018 Glenn Randers-Pehrson ++ * Copyright (c) 1996-1997 Andreas Dilger ++ * Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc. + * + * This code is released under the libpng license. + * For conditions of distribution and use, see the disclaimer +@@ -31,47 +31,81 @@ + * of files at once by typing "pngtest -m file1.png file2.png ..." + */ + +-#define PNG_PEDANTIC_WARNINGS ++#define _POSIX_SOURCE 1 ++ ++#include ++#include ++#include ++ ++/* Defined so I can write to a file on gui/windowing platforms */ ++/* #define STDERR stderr */ ++#define STDERR stdout /* For DOS */ ++ + #include "png.h" + +-#ifdef _WIN32_WCE +-# if _WIN32_WCE < 211 +- __error__ (f|w)printf functions are not supported on old WindowsCE.; +-# endif +-# include +-# include +-# define READFILE(file, data, length, check) \ +- if (ReadFile(file, data, length, &check, NULL)) check = 0 +-# define WRITEFILE(file, data, length, check)) \ +- if (WriteFile(file, data, length, &check, NULL)) check = 0 +-# define FCLOSE(file) CloseHandle(file) ++/* 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_sPLT_SUPPORTED &&\ ++ defined PNG_READ_tEXt_SUPPORTED &&\ ++ defined PNG_READ_tIME_SUPPORTED &&\ ++ defined PNG_READ_zTXt_SUPPORTED &&\ ++ (defined PNG_WRITE_INTERLACING_SUPPORTED || PNG_LIBPNG_VER >= 10700) ++ ++#ifdef PNG_ZLIB_HEADER ++# include PNG_ZLIB_HEADER /* defined by pnglibconf.h from 1.7 */ + #else +-# include +-# include +-# define READFILE(file, data, length, check) \ +- check=(png_size_t)fread(data, (png_size_t)1, length, file) +-# define WRITEFILE(file, data, length, check) \ +- check=(png_size_t)fwrite(data, (png_size_t)1, length, file) +-# define FCLOSE(file) fclose(file) ++# 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 ++#define FCLOSE(file) fclose(file) ++ + #ifndef PNG_STDIO_SUPPORTED +-# ifdef _WIN32_WCE +- typedef HANDLE png_FILE_p; +-# else +- typedef FILE * png_FILE_p; +-# endif ++typedef FILE * png_FILE_p; + #endif + +-/* Makes pngtest verbose so we can find problems (needs to be before png.h) */ ++/* Makes pngtest verbose so we can find problems. */ + #ifndef PNG_DEBUG + # define PNG_DEBUG 0 + #endif + ++#if PNG_DEBUG > 1 ++# define pngtest_debug(m) ((void)fprintf(stderr, m "\n")) ++# define pngtest_debug1(m,p1) ((void)fprintf(stderr, m "\n", p1)) ++# define pngtest_debug2(m,p1,p2) ((void)fprintf(stderr, m "\n", p1, p2)) ++#else ++# define pngtest_debug(m) ((void)0) ++# define pngtest_debug1(m,p1) ((void)0) ++# define pngtest_debug2(m,p1,p2) ((void)0) ++#endif ++ + #if !PNG_DEBUG + # define SINGLE_ROWBUF_ALLOC /* Makes buffer overruns easier to nail */ + #endif + ++#ifndef PNG_UNUSED ++# define PNG_UNUSED(param) (void)param; ++#endif ++ + /* Turn on CPU timing + #define PNGTEST_TIMING + */ +@@ -89,99 +123,98 @@ static float t_start, t_stop, t_decode, t_encode, t_misc; + #define PNG_tIME_STRING_LENGTH 29 + static int tIME_chunk_present = 0; + static char tIME_string[PNG_tIME_STRING_LENGTH] = "tIME chunk is not present"; +-#endif +- +-static int verbose = 0; + +-int test_one_file PNGARG((PNG_CONST char *inname, PNG_CONST char *outname)); ++#if PNG_LIBPNG_VER < 10619 ++#define png_convert_to_rfc1123_buffer(ts, t) tIME_to_str(read_ptr, ts, t) + +-#ifdef __TURBOC__ +-#include +-#endif ++static int ++tIME_to_str(png_structp png_ptr, png_charp ts, png_const_timep t) ++{ ++ png_const_charp str = png_convert_to_rfc1123(png_ptr, t); + +-/* Defined so I can write to a file on gui/windowing platforms */ +-/* #define STDERR stderr */ +-#define STDERR stdout /* For DOS */ ++ if (str == NULL) ++ return 0; + +-/* In case a system header (e.g., on AIX) defined jmpbuf */ +-#ifdef jmpbuf +-# undef jmpbuf ++ strcpy(ts, str); ++ return 1; ++} ++#endif /* older libpng */ + #endif + ++static int verbose = 0; ++static int strict = 0; ++static int relaxed = 0; ++static int xfail = 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 +-#ifdef PNG_1_0_X +-PNGAPI +-#endif +-read_row_callback(png_structp png_ptr, png_uint_32 row_number, int pass); +-void +-#ifdef PNG_1_0_X +-PNGAPI +-#endif ++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) + return; ++ + if (status_pass != pass) + { + fprintf(stdout, "\n Pass %d: ", pass); + status_pass = pass; + status_dots = 31; + } ++ + status_dots--; ++ + if (status_dots == 0) + { + fprintf(stdout, "\n "); + status_dots=30; + } ++ + fprintf(stdout, "r"); + } + +-void +-#ifdef PNG_1_0_X +-PNGAPI +-#endif +-write_row_callback(png_structp png_ptr, png_uint_32 row_number, int pass); +-void +-#ifdef PNG_1_0_X +-PNGAPI +-#endif ++#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) + return; ++ + fprintf(stdout, "w"); + } ++#endif + + + #ifdef PNG_READ_USER_TRANSFORM_SUPPORTED +-/* Example of using user transform callback (we don't transform anything, +- * but merely examine the row filters. We set this to 256 rather than +- * 5 in case illegal filter values are present.) ++/* Example of using a user transform callback (doesn't do anything at present). + */ +-static png_uint_32 filters_used[256]; +-void +-#ifdef PNG_1_0_X +-PNGAPI +-#endif +-count_filters(png_structp png_ptr, png_row_infop row_info, png_bytep data); +-void +-#ifdef PNG_1_0_X +-PNGAPI +-#endif +-count_filters(png_structp png_ptr, png_row_infop row_info, png_bytep data) ++static void PNGCBAPI ++read_user_callback(png_structp png_ptr, png_row_infop row_info, png_bytep data) + { +- if (png_ptr != NULL && row_info != NULL) +- ++filters_used[*(data - 1)]; ++ PNG_UNUSED(png_ptr) ++ PNG_UNUSED(row_info) ++ PNG_UNUSED(data) + } + #endif + +@@ -192,19 +225,12 @@ count_filters(png_structp png_ptr, png_row_infop row_info, png_bytep data) + + static png_uint_32 zero_samples; + +-void +-#ifdef PNG_1_0_X +-PNGAPI +-#endif +-count_zero_samples(png_structp png_ptr, png_row_infop row_info, png_bytep data); +-void +-#ifdef PNG_1_0_X +-PNGAPI +-#endif ++static void PNGCBAPI + count_zero_samples(png_structp png_ptr, png_row_infop row_info, png_bytep data) + { + png_bytep dp = data; +- if (png_ptr == NULL)return; ++ if (png_ptr == NULL) ++ return; + + /* Contents of row_info: + * png_uint_32 width width of row +@@ -215,88 +241,97 @@ count_zero_samples(png_structp png_ptr, png_row_infop row_info, png_bytep data) + * png_byte pixel_depth bits per pixel (depth*channels) + */ + +- /* Counts the number of zero samples (or zero pixels if color_type is 3 */ ++ /* Counts the number of zero samples (or zero pixels if color_type is 3 */ + +- if (row_info->color_type == 0 || row_info->color_type == 3) +- { +- int pos = 0; +- png_uint_32 n, nstop; +- for (n = 0, nstop=row_info->width; nbit_depth == 1) +- { +- if (((*dp << pos++ ) & 0x80) == 0) +- zero_samples++; +- if (pos == 8) +- { +- pos = 0; +- dp++; +- } +- } +- if (row_info->bit_depth == 2) +- { +- if (((*dp << (pos+=2)) & 0xc0) == 0) +- zero_samples++; +- if (pos == 8) +- { +- pos = 0; +- dp++; +- } +- } +- if (row_info->bit_depth == 4) +- { +- if (((*dp << (pos+=4)) & 0xf0) == 0) +- zero_samples++; +- if (pos == 8) +- { +- pos = 0; +- dp++; +- } +- } +- if (row_info->bit_depth == 8) +- if (*dp++ == 0) +- zero_samples++; +- if (row_info->bit_depth == 16) +- { +- if ((*dp | *(dp+1)) == 0) +- zero_samples++; +- dp+=2; +- } +- } +- } +- else /* Other color types */ +- { +- png_uint_32 n, nstop; +- int channel; +- int color_channels = row_info->channels; +- if (row_info->color_type > 3)color_channels--; +- +- for (n = 0, nstop=row_info->width; nbit_depth == 8) +- if (*dp++ == 0) +- zero_samples++; +- if (row_info->bit_depth == 16) +- { +- if ((*dp | *(dp+1)) == 0) +- zero_samples++; +- dp+=2; +- } +- } +- if (row_info->color_type > 3) +- { +- dp++; +- if (row_info->bit_depth == 16) +- dp++; +- } +- } +- } +-} +-#endif /* PNG_WRITE_USER_TRANSFORM_SUPPORTED */ ++ if (row_info->color_type == 0 || row_info->color_type == 3) ++ { ++ int pos = 0; ++ png_uint_32 n, nstop; + +-static int wrote_question = 0; ++ for (n = 0, nstop=row_info->width; nbit_depth == 1) ++ { ++ if (((*dp << pos++ ) & 0x80) == 0) ++ zero_samples++; ++ ++ if (pos == 8) ++ { ++ pos = 0; ++ dp++; ++ } ++ } ++ ++ if (row_info->bit_depth == 2) ++ { ++ if (((*dp << (pos+=2)) & 0xc0) == 0) ++ zero_samples++; ++ ++ if (pos == 8) ++ { ++ pos = 0; ++ dp++; ++ } ++ } ++ ++ if (row_info->bit_depth == 4) ++ { ++ if (((*dp << (pos+=4)) & 0xf0) == 0) ++ zero_samples++; ++ ++ if (pos == 8) ++ { ++ pos = 0; ++ dp++; ++ } ++ } ++ ++ if (row_info->bit_depth == 8) ++ if (*dp++ == 0) ++ zero_samples++; ++ ++ if (row_info->bit_depth == 16) ++ { ++ if ((*dp | *(dp+1)) == 0) ++ zero_samples++; ++ dp+=2; ++ } ++ } ++ } ++ else /* Other color types */ ++ { ++ png_uint_32 n, nstop; ++ int channel; ++ int color_channels = row_info->channels; ++ if (row_info->color_type > 3) ++ color_channels--; ++ ++ for (n = 0, nstop=row_info->width; nbit_depth == 8) ++ if (*dp++ == 0) ++ zero_samples++; ++ ++ if (row_info->bit_depth == 16) ++ { ++ if ((*dp | *(dp+1)) == 0) ++ zero_samples++; ++ ++ dp+=2; ++ } ++ } ++ if (row_info->color_type > 3) ++ { ++ dp++; ++ if (row_info->bit_depth == 16) ++ dp++; ++ } ++ } ++ } ++} ++#endif /* WRITE_USER_TRANSFORM */ + + #ifndef PNG_STDIO_SUPPORTED + /* START of code to validate stdio-free compilation */ +@@ -308,81 +343,79 @@ static int wrote_question = 0; + * than changing the library. + */ + +-#ifndef USE_FAR_KEYWORD +-static void +-pngtest_read_data(png_structp png_ptr, png_bytep data, png_size_t length) ++#ifdef PNG_IO_STATE_SUPPORTED ++void ++pngtest_check_io_state(png_structp png_ptr, size_t data_length, ++ png_uint_32 io_op); ++void ++pngtest_check_io_state(png_structp png_ptr, size_t data_length, ++ png_uint_32 io_op) ++{ ++ png_uint_32 io_state = png_get_io_state(png_ptr); ++ int err = 0; ++ ++ /* Check if the current operation (reading / writing) is as expected. */ ++ if ((io_state & PNG_IO_MASK_OP) != io_op) ++ png_error(png_ptr, "Incorrect operation in I/O state"); ++ ++ /* Check if the buffer size specific to the current location ++ * (file signature / header / data / crc) is as expected. ++ */ ++ switch (io_state & PNG_IO_MASK_LOC) ++ { ++ case PNG_IO_SIGNATURE: ++ if (data_length > 8) ++ err = 1; ++ break; ++ case PNG_IO_CHUNK_HDR: ++ if (data_length != 8) ++ err = 1; ++ break; ++ case PNG_IO_CHUNK_DATA: ++ break; /* no restrictions here */ ++ case PNG_IO_CHUNK_CRC: ++ if (data_length != 4) ++ err = 1; ++ break; ++ default: ++ err = 1; /* uninitialized */ ++ } ++ if (err != 0) ++ png_error(png_ptr, "Bad I/O state or buffer size"); ++} ++#endif ++ ++static void PNGCBAPI ++pngtest_read_data(png_structp png_ptr, png_bytep data, size_t length) + { +- png_size_t check = 0; ++ size_t check = 0; + png_voidp io_ptr; + +- /* fread() returns 0 on error, so it is OK to store this in a png_size_t ++ /* fread() returns 0 on error, so it is OK to store this in a size_t + * instead of an int, which is what fread() actually returns. + */ + io_ptr = png_get_io_ptr(png_ptr); + if (io_ptr != NULL) + { +- READFILE((png_FILE_p)io_ptr, data, length, check); ++ check = fread(data, 1, length, (png_FILE_p)io_ptr); + } + + if (check != length) + { +- png_error(png_ptr, "Read Error!"); ++ png_error(png_ptr, "Read Error"); + } +-} +-#else +-/* This is the model-independent version. Since the standard I/O library +- can't handle far buffers in the medium and small models, we have to copy +- the data. +-*/ + +-#define NEAR_BUF_SIZE 1024 +-#define MIN(a,b) (a <= b ? a : b) +- +-static void +-pngtest_read_data(png_structp png_ptr, png_bytep data, png_size_t length) +-{ +- int check; +- png_byte *n_data; +- png_FILE_p io_ptr; +- +- /* Check if data really is near. If so, use usual code. */ +- n_data = (png_byte *)CVT_PTR_NOCHECK(data); +- io_ptr = (png_FILE_p)CVT_PTR(png_ptr->io_ptr); +- if ((png_bytep)n_data == data) +- { +- READFILE(io_ptr, n_data, length, check); +- } +- else +- { +- png_byte buf[NEAR_BUF_SIZE]; +- png_size_t read, remaining, err; +- check = 0; +- remaining = length; +- do +- { +- read = MIN(NEAR_BUF_SIZE, remaining); +- READFILE(io_ptr, buf, 1, err); +- png_memcpy(data, buf, read); /* Copy far buffer to near buffer */ +- if (err != read) +- break; +- else +- check += err; +- data += read; +- remaining -= read; +- } +- while (remaining != 0); +- } +- if (check != length) +- png_error(png_ptr, "read Error"); ++#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 ++static void PNGCBAPI + pngtest_flush(png_structp png_ptr) + { + /* Do nothing; fflush() is said to be just a waste of energy. */ +- png_ptr = png_ptr; /* Stifle compiler warning */ ++ PNG_UNUSED(png_ptr) /* Stifle compiler warning */ + } + #endif + +@@ -391,83 +424,47 @@ pngtest_flush(png_structp png_ptr) + * write_data function and use it at run time with png_set_write_fn(), rather + * than changing the library. + */ +-#ifndef USE_FAR_KEYWORD +-static void +-pngtest_write_data(png_structp png_ptr, png_bytep data, png_size_t length) ++static void PNGCBAPI ++pngtest_write_data(png_structp png_ptr, png_bytep data, size_t length) + { +- png_uint_32 check; ++ size_t check; + +- WRITEFILE((png_FILE_p)png_ptr->io_ptr, data, length, check); +- if (check != length) +- { +- png_error(png_ptr, "Write Error"); +- } +-} +-#else +-/* This is the model-independent version. Since the standard I/O library +- can't handle far buffers in the medium and small models, we have to copy +- the data. +-*/ ++ check = fwrite(data, 1, length, (png_FILE_p)png_get_io_ptr(png_ptr)); + +-#define NEAR_BUF_SIZE 1024 +-#define MIN(a,b) (a <= b ? a : b) +- +-static void +-pngtest_write_data(png_structp png_ptr, png_bytep data, png_size_t length) +-{ +- png_uint_32 check; +- png_byte *near_data; /* Needs to be "png_byte *" instead of "png_bytep" */ +- png_FILE_p io_ptr; +- +- /* Check if data really is near. If so, use usual code. */ +- near_data = (png_byte *)CVT_PTR_NOCHECK(data); +- io_ptr = (png_FILE_p)CVT_PTR(png_ptr->io_ptr); +- if ((png_bytep)near_data == data) +- { +- WRITEFILE(io_ptr, near_data, length, check); +- } +- else +- { +- png_byte buf[NEAR_BUF_SIZE]; +- png_size_t written, remaining, err; +- check = 0; +- remaining = length; +- do +- { +- written = MIN(NEAR_BUF_SIZE, remaining); +- png_memcpy(buf, data, written); /* Copy far buffer to near buffer */ +- WRITEFILE(io_ptr, buf, written, err); +- if (err != written) +- break; +- else +- check += err; +- data += written; +- remaining -= written; +- } +- while (remaining != 0); +- } + if (check != length) + { + png_error(png_ptr, "Write Error"); + } ++ ++#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. + */ +-static void ++typedef struct ++{ ++ 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); +- if (test == NULL) +- fprintf(STDERR, "%s: libpng warning: %s\n", name, message); +- else +- fprintf(STDERR, "%s: libpng warning: %s\n", test, message); ++ const char *name = "UNKNOWN (ERROR!)"; ++ pngtest_error_parameters *test = ++ (pngtest_error_parameters*)png_get_error_ptr(png_ptr); ++ ++ ++warning_count; ++ ++ if (test != NULL && test->file_name != NULL) ++ name = test->file_name; ++ ++ fprintf(STDERR, "\n%s: libpng warning: %s\n", name, message); + } + + /* This is the default error handling function. Note that replacements for +@@ -475,22 +472,24 @@ pngtest_warning(png_structp png_ptr, png_const_charp message) + * function is used by default, or if the program supplies NULL for the + * error function pointer in png_set_error_fn(). + */ +-static void ++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 */ + #if defined(PNG_USER_MEM_SUPPORTED) && PNG_DEBUG + + /* Allocate memory. For reasonable files, size should never exceed +- * 64K. However, zlib may allocate more then 64K if you don't tell ++ * 64K. However, zlib may allocate more than 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. +@@ -500,11 +499,11 @@ pngtest_error(png_structp png_ptr, png_const_charp message) + */ + typedef struct memory_information + { +- png_uint_32 size; ++ 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; +@@ -512,11 +511,12 @@ static int maximum_allocation = 0; + static int total_allocation = 0; + static int num_allocations = 0; + +-png_voidp png_debug_malloc PNGARG((png_structp png_ptr, png_uint_32 size)); +-void png_debug_free PNGARG((png_structp png_ptr, png_voidp ptr)); ++png_voidp PNGCBAPI png_debug_malloc PNGARG((png_structp png_ptr, ++ png_alloc_size_t size)); ++void PNGCBAPI png_debug_free PNGARG((png_structp png_ptr, png_voidp ptr)); + + png_voidp +-png_debug_malloc(png_structp png_ptr, png_uint_32 size) ++PNGCBAPI png_debug_malloc(png_structp png_ptr, png_alloc_size_t size) + { + + /* png_malloc has already tested for NULL; png_create_struct calls +@@ -533,42 +533,49 @@ png_debug_malloc(png_structp png_ptr, png_uint_32 size) + memory_infop pinfo; + png_set_mem_fn(png_ptr, NULL, NULL, NULL); + pinfo = (memory_infop)png_malloc(png_ptr, +- (png_uint_32)png_sizeof(*pinfo)); ++ (sizeof *pinfo)); + pinfo->size = size; + current_allocation += size; + total_allocation += size; + num_allocations ++; ++ + if (current_allocation > maximum_allocation) + maximum_allocation = current_allocation; +- pinfo->pointer = (png_voidp)png_malloc(png_ptr, size); ++ ++ pinfo->pointer = png_malloc(png_ptr, size); + /* Restore malloc_fn and free_fn */ ++ + png_set_mem_fn(png_ptr, +- png_voidp_NULL, (png_malloc_ptr)png_debug_malloc, +- (png_free_ptr)png_debug_free); ++ NULL, png_debug_malloc, png_debug_free); ++ + if (size != 0 && pinfo->pointer == NULL) + { + current_allocation -= size; + total_allocation -= size; + png_error(png_ptr, +- "out of memory in pngtest->png_debug_malloc."); ++ "out of memory in pngtest->png_debug_malloc"); + } ++ + pinfo->next = pinformation; + pinformation = pinfo; + /* Make sure the caller isn't assuming zeroed memory. */ +- png_memset(pinfo->pointer, 0xdd, pinfo->size); +- if (verbose) +- printf("png_malloc %lu bytes at %x\n", (unsigned long)size, +- pinfo->pointer); ++ memset(pinfo->pointer, 0xdd, pinfo->size); ++ ++ if (verbose != 0) ++ printf("png_malloc %lu bytes at %p\n", (unsigned long)size, ++ pinfo->pointer); ++ + return (png_voidp)(pinfo->pointer); + } + } + + /* Free a pointer. It is removed from the list at the same time. */ +-void ++void PNGCBAPI + png_debug_free(png_structp png_ptr, png_voidp ptr) + { + if (png_ptr == NULL) + fprintf(STDERR, "NULL pointer to png_debug_free.\n"); ++ + if (ptr == 0) + { + #if 0 /* This happens all the time. */ +@@ -578,11 +585,14 @@ png_debug_free(png_structp png_ptr, png_voidp ptr) + } + + /* Unlink the element from the list. */ ++ if (pinformation != NULL) + { +- memory_infop FAR *ppinfo = &pinformation; ++ memory_infop *ppinfo = &pinformation; ++ + for (;;) + { + memory_infop pinfo = *ppinfo; ++ + if (pinfo->pointer == ptr) + { + *ppinfo = pinfo->next; +@@ -591,49 +601,101 @@ png_debug_free(png_structp png_ptr, png_voidp ptr) + 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); ++ 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; + } ++ + ppinfo = &pinfo->next; + } + } + + /* Finally free the data. */ +- if (verbose) +- printf("Freeing %x\n", ptr); +- png_free_default(png_ptr, ptr); ++ if (verbose != 0) ++ printf("Freeing %p\n", 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; ++ ++/* 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 void ++init_callback_info(png_const_infop info_ptr) ++{ ++ 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; + +- /* 0: sTER mode + 1 +- * 1: vpAg width +- * 2: vpAg height +- * 3: vpAg units +- */ ++ if ((data->location[0] & what) != 0 || (data->location[1] & what) != 0) ++ return 0; /* already have one of these */ + +-static int read_user_chunk_callback(png_struct *png_ptr, +- png_unknown_chunkp chunk) ++ /* 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) + { +- png_uint_32 +- *my_user_chunk_data; ++ 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 +@@ -643,7 +705,7 @@ static int read_user_chunk_callback(png_struct *png_ptr, + * The unknown chunk structure contains the chunk data: + * png_byte name[5]; + * png_byte *data; +- * png_size_t size; ++ * size_t size; + * + * Note that libpng has already taken care of the CRC handling. + */ +@@ -654,11 +716,18 @@ static int read_user_chunk_callback(png_struct *png_ptr, + /* Found sTER chunk */ + if (chunk->size != 1) + return (-1); /* Error return */ ++ + if (chunk->data[0] != 0 && chunk->data[0] != 1) + return (-1); /* Invalid mode */ +- my_user_chunk_data=(png_uint_32 *) png_get_user_chunk_ptr(png_ptr); +- my_user_chunk_data[0]=chunk->data[0]+1; +- return (1); ++ ++ if (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 */ +@@ -670,120 +739,184 @@ static int read_user_chunk_callback(png_struct *png_ptr, + 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_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; ++ /* In libpng 1.7 this now does an app-error, so stop it: */ ++ text_ptr[num_text].compression = PNG_TEXT_COMPRESSION_NONE; ++# endif ++ break; ++ ++ case PNG_ITXT_COMPRESSION_NONE: ++ case PNG_ITXT_COMPRESSION_zTXt: ++# ifndef PNG_WRITE_iTXt_SUPPORTED ++ ++unsupported_chunks; ++ text_ptr[num_text].compression = PNG_TEXT_COMPRESSION_NONE; ++# 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 +-test_one_file(PNG_CONST char *inname, PNG_CONST char *outname) ++static int ++test_one_file(const char *inname, 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; +-#else ++#ifdef PNG_WRITE_FILTER_SUPPORTED ++ int interlace_preserved = 1; ++#endif /* WRITE_FILTER */ ++#else /* !WRITE */ + png_structp write_ptr = NULL; + png_infop write_info_ptr = NULL; + png_infop write_end_info_ptr = NULL; +-#endif ++#endif /* !WRITE */ + png_bytep row_buf; + png_uint_32 y; + png_uint_32 width, height; +- int num_pass, pass; ++ volatile int num_passes; ++ int pass; + int bit_depth, color_type; +-#ifdef PNG_SETJMP_SUPPORTED +-#ifdef USE_FAR_KEYWORD +- jmp_buf jmpbuf; +-#endif +-#endif +- +-#ifdef _WIN32_WCE +- TCHAR path[MAX_PATH]; +-#endif +- char inbuf[256], outbuf[256]; + + row_buf = NULL; ++ error_parameters.file_name = inname; + +-#ifdef _WIN32_WCE +- MultiByteToWideChar(CP_ACP, 0, inname, -1, path, MAX_PATH); +- if ((fpin = CreateFile(path, GENERIC_READ, 0, NULL, OPEN_EXISTING, 0, +- NULL)) == INVALID_HANDLE_VALUE) +-#else + if ((fpin = fopen(inname, "rb")) == NULL) +-#endif + { + fprintf(STDERR, "Could not find input file %s\n", inname); + return (1); + } + +-#ifdef _WIN32_WCE +- MultiByteToWideChar(CP_ACP, 0, outname, -1, path, MAX_PATH); +- if ((fpout = CreateFile(path, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, +- 0, NULL)) == INVALID_HANDLE_VALUE) +-#else + if ((fpout = fopen(outname, "wb")) == NULL) +-#endif + { + fprintf(STDERR, "Could not open output file %s\n", outname); + FCLOSE(fpin); + return (1); + } + +- png_debug(0, "Allocating read and write structures"); ++ pngtest_debug("Allocating read and write structures"); + #if defined(PNG_USER_MEM_SUPPORTED) && PNG_DEBUG + read_ptr = +- png_create_read_struct_2(PNG_LIBPNG_VER_STRING, png_voidp_NULL, +- png_error_ptr_NULL, png_error_ptr_NULL, png_voidp_NULL, +- (png_malloc_ptr)png_debug_malloc, (png_free_ptr)png_debug_free); ++ png_create_read_struct_2(PNG_LIBPNG_VER_STRING, NULL, ++ NULL, NULL, NULL, png_debug_malloc, png_debug_free); + #else + read_ptr = +- png_create_read_struct(PNG_LIBPNG_VER_STRING, png_voidp_NULL, +- png_error_ptr_NULL, png_error_ptr_NULL); ++ 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, ++ png_set_error_fn(read_ptr, &error_parameters, pngtest_error, + pngtest_warning); +-#endif + +-#ifdef PNG_UNKNOWN_CHUNKS_SUPPORTED +- user_chunk_data[0] = 0; +- user_chunk_data[1] = 0; +- user_chunk_data[2] = 0; +- user_chunk_data[3] = 0; +- png_set_read_user_chunk_fn(read_ptr, user_chunk_data, +- read_user_chunk_callback); +- +-#endif + #ifdef PNG_WRITE_SUPPORTED + #if defined(PNG_USER_MEM_SUPPORTED) && PNG_DEBUG + write_ptr = +- png_create_write_struct_2(PNG_LIBPNG_VER_STRING, png_voidp_NULL, +- png_error_ptr_NULL, png_error_ptr_NULL, png_voidp_NULL, +- (png_malloc_ptr)png_debug_malloc, (png_free_ptr)png_debug_free); ++ png_create_write_struct_2(PNG_LIBPNG_VER_STRING, NULL, ++ NULL, NULL, NULL, png_debug_malloc, png_debug_free); + #else + write_ptr = +- png_create_write_struct(PNG_LIBPNG_VER_STRING, png_voidp_NULL, +- png_error_ptr_NULL, png_error_ptr_NULL); ++ 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, ++ png_set_error_fn(write_ptr, &error_parameters, pngtest_error, + pngtest_warning); + #endif +-#endif +- png_debug(0, "Allocating read_info, write_info and end_info structures"); ++ pngtest_debug("Allocating read_info, write_info and end_info structures"); + read_info_ptr = png_create_info_struct(read_ptr); + end_info_ptr = png_create_info_struct(read_ptr); + #ifdef PNG_WRITE_SUPPORTED +@@ -791,19 +924,25 @@ test_one_file(PNG_CONST char *inname, PNG_CONST char *outname) + 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 +- png_debug(0, "Setting jmpbuf for read struct"); +-#ifdef USE_FAR_KEYWORD +- if (setjmp(jmpbuf)) +-#else ++ pngtest_debug("Setting jmpbuf for read struct"); + if (setjmp(png_jmpbuf(read_ptr))) +-#endif + { + fprintf(STDERR, "%s -> %s: libpng read error\n", inname, outname); + png_free(read_ptr, row_buf); + row_buf = NULL; ++ if (verbose != 0) ++ fprintf(STDERR, " destroy read structs\n"); + png_destroy_read_struct(&read_ptr, &read_info_ptr, &end_info_ptr); + #ifdef PNG_WRITE_SUPPORTED ++ if (verbose != 0) ++ fprintf(STDERR, " destroy write structs\n"); + png_destroy_info_struct(write_ptr, &write_end_info_ptr); + png_destroy_write_struct(&write_ptr, &write_info_ptr); + #endif +@@ -811,35 +950,65 @@ test_one_file(PNG_CONST char *inname, PNG_CONST char *outname) + FCLOSE(fpout); + return (1); + } +-#ifdef USE_FAR_KEYWORD +- png_memcpy(png_jmpbuf(read_ptr), jmpbuf, png_sizeof(jmp_buf)); +-#endif + + #ifdef PNG_WRITE_SUPPORTED +- png_debug(0, "Setting jmpbuf for write struct"); +-#ifdef USE_FAR_KEYWORD +- if (setjmp(jmpbuf)) +-#else ++ pngtest_debug("Setting jmpbuf for write struct"); ++ + if (setjmp(png_jmpbuf(write_ptr))) +-#endif + { + fprintf(STDERR, "%s -> %s: libpng write error\n", inname, outname); ++ if (verbose != 0) ++ fprintf(STDERR, " destroying read structs\n"); + png_destroy_read_struct(&read_ptr, &read_info_ptr, &end_info_ptr); ++ if (verbose != 0) ++ fprintf(STDERR, " destroying write structs\n"); + png_destroy_info_struct(write_ptr, &write_end_info_ptr); +-#ifdef PNG_WRITE_SUPPORTED + png_destroy_write_struct(&write_ptr, &write_info_ptr); +-#endif + FCLOSE(fpin); + FCLOSE(fpout); + return (1); + } +-#ifdef USE_FAR_KEYWORD +- png_memcpy(png_jmpbuf(write_ptr), jmpbuf, png_sizeof(jmp_buf)); + #endif + #endif ++ ++#ifdef PNG_BENIGN_ERRORS_SUPPORTED ++ 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); ++ ++ /* Turn off CRC checking while reading */ ++ png_set_crc_action(read_ptr, PNG_CRC_QUIET_USE, PNG_CRC_QUIET_USE); ++ ++#ifdef PNG_IGNORE_ADLER32 ++ /* Turn off ADLER32 checking while reading */ ++ png_set_option(read_ptr, PNG_IGNORE_ADLER32, PNG_OPTION_ON); + #endif + +- png_debug(0, "Initializing input and output streams"); ++# ifdef PNG_WRITE_SUPPORTED ++ png_set_benign_errors(write_ptr, 1); ++# endif ++ ++ } ++#endif /* BENIGN_ERRORS */ ++ ++ pngtest_debug("Initializing input and output streams"); + #ifdef PNG_STDIO_SUPPORTED + png_init_io(read_ptr, fpin); + # ifdef PNG_WRITE_SUPPORTED +@@ -850,12 +1019,13 @@ test_one_file(PNG_CONST char *inname, PNG_CONST char *outname) + # ifdef PNG_WRITE_SUPPORTED + png_set_write_fn(write_ptr, (png_voidp)fpout, pngtest_write_data, + # ifdef PNG_WRITE_FLUSH_SUPPORTED +- pngtest_flush); ++ pngtest_flush); + # else +- NULL); ++ NULL); + # endif + # endif + #endif ++ + if (status_dots_requested == 1) + { + #ifdef PNG_WRITE_SUPPORTED +@@ -863,70 +1033,96 @@ test_one_file(PNG_CONST char *inname, PNG_CONST char *outname) + #endif + png_set_read_status_fn(read_ptr, read_row_callback); + } ++ + else + { + #ifdef PNG_WRITE_SUPPORTED +- png_set_write_status_fn(write_ptr, png_write_status_ptr_NULL); ++ png_set_write_status_fn(write_ptr, NULL); + #endif +- png_set_read_status_fn(read_ptr, png_read_status_ptr_NULL); ++ png_set_read_status_fn(read_ptr, NULL); + } + + #ifdef PNG_READ_USER_TRANSFORM_SUPPORTED +- { +- int i; +- for (i = 0; i<256; i++) +- filters_used[i] = 0; +- png_set_read_user_transform_fn(read_ptr, count_filters); +- } ++ png_set_read_user_transform_fn(read_ptr, read_user_callback); + #endif + #ifdef PNG_WRITE_USER_TRANSFORM_SUPPORTED + zero_samples = 0; + png_set_write_user_transform_fn(write_ptr, count_zero_samples); + #endif + +-#ifdef PNG_READ_UNKNOWN_CHUNKS_SUPPORTED +-# ifndef PNG_HANDLE_CHUNK_ALWAYS +-# define PNG_HANDLE_CHUNK_ALWAYS 3 +-# endif ++#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, +- png_bytep_NULL, 0); ++ NULL, 0); + #endif + #ifdef PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED +-# ifndef PNG_HANDLE_CHUNK_IF_SAFE +-# define PNG_HANDLE_CHUNK_IF_SAFE 2 +-# endif +- png_set_keep_unknown_chunks(write_ptr, PNG_HANDLE_CHUNK_IF_SAFE, +- png_bytep_NULL, 0); ++ png_set_keep_unknown_chunks(write_ptr, PNG_HANDLE_CHUNK_ALWAYS, ++ NULL, 0); ++#endif + #endif + +- png_debug(0, "Reading info struct"); ++ pngtest_debug("Reading info struct"); + png_read_info(read_ptr, read_info_ptr); + +- png_debug(0, "Transferring info struct"); ++#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); +-#endif ++ color_type, interlace_type, compression_type, filter_type); ++ /* num_passes may not be available below if interlace support is not ++ * provided by libpng for both read and write. ++ */ ++ switch (interlace_type) ++ { ++ case PNG_INTERLACE_NONE: ++ num_passes = 1; ++ break; ++ ++ case PNG_INTERLACE_ADAM7: ++ num_passes = 7; ++ break; ++ ++ default: ++ png_error(read_ptr, "invalid interlace type"); ++ /*NOT REACHED*/ ++ } + } ++ ++ else ++ png_error(read_ptr, "png_get_IHDR failed"); + } + #ifdef PNG_FIXED_POINT_SUPPORTED + #ifdef PNG_cHRM_SUPPORTED + { + png_fixed_point white_x, white_y, red_x, red_y, green_x, green_y, blue_x, +- blue_y; ++ 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); ++ red_y, green_x, green_y, blue_x, blue_y); + } + } + #endif +@@ -934,7 +1130,7 @@ test_one_file(PNG_CONST char *inname, PNG_CONST char *outname) + { + 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 +@@ -943,12 +1139,13 @@ test_one_file(PNG_CONST char *inname, PNG_CONST char *outname) + #ifdef PNG_cHRM_SUPPORTED + { + double white_x, white_y, red_x, red_y, green_x, green_y, blue_x, +- blue_y; ++ 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); ++ red_y, green_x, green_y, blue_x, blue_y); + } + } + #endif +@@ -956,7 +1153,7 @@ test_one_file(PNG_CONST char *inname, PNG_CONST char *outname) + { + 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 +@@ -965,15 +1162,15 @@ test_one_file(PNG_CONST char *inname, PNG_CONST char *outname) + #ifdef PNG_iCCP_SUPPORTED + { + png_charp name; +- png_charp profile; ++ png_bytep profile; + png_uint_32 proflen; + 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); ++ profile, proflen); + } + } + #endif +@@ -981,7 +1178,7 @@ test_one_file(PNG_CONST char *inname, PNG_CONST char *outname) + { + 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 +@@ -989,24 +1186,40 @@ test_one_file(PNG_CONST char *inname, PNG_CONST char *outname) + 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); + } + } + #endif ++#ifdef PNG_READ_eXIf_SUPPORTED ++ { ++ png_bytep exif=NULL; ++ png_uint_32 exif_length; ++ ++ if (png_get_eXIf_1(read_ptr, read_info_ptr, &exif_length, &exif) != 0) ++ { ++ if (exif_length > 1) ++ fprintf(STDERR," eXIf type %c%c, %lu bytes\n",exif[0],exif[1], ++ (unsigned long)exif_length); ++# ifdef PNG_WRITE_eXIf_SUPPORTED ++ png_set_eXIf_1(write_ptr, write_info_ptr, exif_length, exif); ++# endif ++ } ++ } ++#endif + #ifdef PNG_hIST_SUPPORTED + { + 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 +@@ -1016,7 +1229,7 @@ test_one_file(PNG_CONST char *inname, PNG_CONST char *outname) + 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); + } +@@ -1030,10 +1243,10 @@ test_one_file(PNG_CONST char *inname, PNG_CONST char *outname) + int type, nparams; + + if (png_get_pCAL(read_ptr, read_info_ptr, &purpose, &X0, &X1, &type, +- &nparams, &units, ¶ms)) ++ &nparams, &units, ¶ms) != 0) + { + png_set_pCAL(write_ptr, write_info_ptr, purpose, X0, X1, type, +- nparams, units, params); ++ nparams, units, params); + } + } + #endif +@@ -1042,7 +1255,8 @@ test_one_file(PNG_CONST char *inname, PNG_CONST char *outname) + 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 +@@ -1050,18 +1264,19 @@ test_one_file(PNG_CONST char *inname, PNG_CONST char *outname) + { + 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); + } +@@ -1073,7 +1288,7 @@ test_one_file(PNG_CONST char *inname, PNG_CONST char *outname) + 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); +@@ -1082,6 +1297,19 @@ test_one_file(PNG_CONST char *inname, PNG_CONST char *outname) + #endif + #endif + #endif ++ ++#ifdef PNG_sPLT_SUPPORTED ++ { ++ png_sPLT_tp entries; ++ ++ int num_entries = (int) png_get_sPLT(read_ptr, read_info_ptr, &entries); ++ if (num_entries) ++ { ++ png_set_sPLT(write_ptr, write_info_ptr, entries, num_entries); ++ } ++ } ++#endif ++ + #ifdef PNG_TEXT_SUPPORTED + { + png_textp text_ptr; +@@ -1089,7 +1317,22 @@ test_one_file(PNG_CONST char *inname, PNG_CONST char *outname) + + if (png_get_text(read_ptr, read_info_ptr, &text_ptr, &num_text) > 0) + { +- png_debug1(0, "Handling %d iTXt/tEXt/zTXt chunks", num_text); ++ 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; ++ ++ fprintf(STDERR,"\n"); ++ for (i=0; igray > sample_max) || ++ (int)trans_color->gray > sample_max) || + (color_type == PNG_COLOR_TYPE_RGB && +- ((int)trans_values->red > sample_max || +- (int)trans_values->green > sample_max || +- (int)trans_values->blue > sample_max)))) +- png_set_tRNS(write_ptr, write_info_ptr, trans, num_trans, +- trans_values); ++ ((int)trans_color->red > sample_max || ++ (int)trans_color->green > sample_max || ++ (int)trans_color->blue > sample_max)))) ++ png_set_tRNS(write_ptr, write_info_ptr, trans_alpha, num_trans, ++ trans_color); + } + } + #endif + #ifdef PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED + { + png_unknown_chunkp unknowns; +- int num_unknowns = (int)png_get_unknown_chunks(read_ptr, read_info_ptr, +- &unknowns); +- if (num_unknowns) ++ int num_unknowns = png_get_unknown_chunks(read_ptr, read_info_ptr, ++ &unknowns); ++ ++ if (num_unknowns != 0) + { +- png_size_t i; + png_set_unknown_chunks(write_ptr, write_info_ptr, unknowns, +- num_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 < (png_size_t)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 + + #ifdef PNG_WRITE_SUPPORTED +- png_debug(0, "Writing info struct"); ++ pngtest_debug("Writing info struct"); ++ ++ /* 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 */ + +-/* If we wanted, we could write info in two steps: +- * png_write_info_before_PLTE(write_ptr, write_info_ptr); +- */ + png_write_info(write_ptr, write_info_ptr); + +-#ifdef PNG_UNKNOWN_CHUNKS_SUPPORTED +- if (user_chunk_data[0] != 0) +- { +- png_byte png_sTER[5] = {115, 84, 69, 82, '\0'}; ++ write_chunks(write_ptr, before_IDAT); /* after PLTE */ + +- unsigned char +- ster_chunk_data[1]; ++ png_write_info(write_ptr, write_end_info_ptr); + +- 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); +- } ++ write_chunks(write_ptr, after_IDAT); /* after IDAT */ + ++#ifdef PNG_COMPRESSION_COMPAT ++ /* Test the 'compatibility' setting here, if it is available. */ ++ png_set_compression(write_ptr, PNG_COMPRESSION_COMPAT); + #endif + #endif + + #ifdef SINGLE_ROWBUF_ALLOC +- png_debug(0, "Allocating row buffer..."); ++ pngtest_debug("Allocating row buffer..."); + row_buf = (png_bytep)png_malloc(read_ptr, +- png_get_rowbytes(read_ptr, read_info_ptr)); +- png_debug1(0, "0x%08lx", (unsigned long)row_buf); ++ png_get_rowbytes(read_ptr, read_info_ptr)); ++ ++ pngtest_debug1("\t0x%08lx", (unsigned long)row_buf); + #endif /* SINGLE_ROWBUF_ALLOC */ +- png_debug(0, "Writing row data"); ++ pngtest_debug("Writing row data"); + +-#if defined(PNG_READ_INTERLACING_SUPPORTED) || \ +- defined(PNG_WRITE_INTERLACING_SUPPORTED) +- num_pass = png_set_interlace_handling(read_ptr); +-# ifdef PNG_WRITE_SUPPORTED +- png_set_interlace_handling(write_ptr); +-# endif +-#else +- num_pass = 1; +-#endif ++#if defined(PNG_READ_INTERLACING_SUPPORTED) &&\ ++ defined(PNG_WRITE_INTERLACING_SUPPORTED) ++ /* Both must be defined for libpng to be able to handle the interlace, ++ * otherwise it gets handled below by simply reading and writing the passes ++ * directly. ++ */ ++ if (png_set_interlace_handling(read_ptr) != num_passes) ++ png_error(write_ptr, ++ "png_set_interlace_handling(read): wrong pass count "); ++ if (png_set_interlace_handling(write_ptr) != num_passes) ++ png_error(write_ptr, ++ "png_set_interlace_handling(write): wrong pass count "); ++#else /* png_set_interlace_handling not called on either read or write */ ++# define calc_pass_height ++#endif /* not using libpng interlace handling */ + + #ifdef PNGTEST_TIMING + t_stop = (float)clock(); + t_misc += (t_stop - t_start); + t_start = t_stop; + #endif +- for (pass = 0; pass < num_pass; pass++) ++ for (pass = 0; pass < num_passes; pass++) + { +- png_debug1(0, "Writing row data for pass %d", pass); +- for (y = 0; y < height; y++) ++# ifdef calc_pass_height ++ png_uint_32 pass_height; ++ ++ if (num_passes == 7) /* interlaced */ ++ { ++ if (PNG_PASS_COLS(width, pass) > 0) ++ pass_height = PNG_PASS_ROWS(height, pass); ++ ++ else ++ pass_height = 0; ++ } ++ ++ else /* not interlaced */ ++ pass_height = height; ++# else ++# define pass_height height ++# endif ++ ++ pngtest_debug1("Writing row data for pass %d", pass); ++ for (y = 0; y < pass_height; y++) + { + #ifndef SINGLE_ROWBUF_ALLOC +- png_debug2(0, "Allocating row buffer (pass %d, y = %ld)...", pass, y); ++ 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)); +- png_debug2(0, "0x%08lx (%ld bytes)", (unsigned long)row_buf, +- png_get_rowbytes(read_ptr, read_info_ptr)); ++ 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, png_bytepp_NULL, 1); ++ png_read_rows(read_ptr, (png_bytepp)&row_buf, NULL, 1); + + #ifdef PNG_WRITE_SUPPORTED + #ifdef PNGTEST_TIMING +@@ -1250,24 +1508,26 @@ test_one_file(PNG_CONST char *inname, PNG_CONST char *outname) + t_encode += (t_stop - t_start); + t_start = t_stop; + #endif +-#endif /* PNG_WRITE_SUPPORTED */ ++#endif /* WRITE */ + + #ifndef SINGLE_ROWBUF_ALLOC +- png_debug2(0, "Freeing row buffer (pass %d, y = %ld)", pass, y); ++ pngtest_debug2("Freeing row buffer (pass %d, y = %u)", pass, y); + png_free(read_ptr, row_buf); + row_buf = NULL; + #endif /* !SINGLE_ROWBUF_ALLOC */ + } + } + +-#ifdef PNG_READ_UNKNOWN_CHUNKS_SUPPORTED +- png_free_data(read_ptr, read_info_ptr, PNG_FREE_UNKN, -1); +-#endif +-#ifdef PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED +- png_free_data(write_ptr, write_info_ptr, PNG_FREE_UNKN, -1); ++#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 + +- png_debug(0, "Reading and writing end_info data"); ++ pngtest_debug("Reading and writing end_info data"); + + png_read_end(read_ptr, end_info_ptr); + #ifdef PNG_TEXT_SUPPORTED +@@ -1277,163 +1537,269 @@ test_one_file(PNG_CONST char *inname, PNG_CONST char *outname) + + if (png_get_text(read_ptr, end_info_ptr, &text_ptr, &num_text) > 0) + { +- png_debug1(0, "Handling %d iTXt/tEXt/zTXt chunks", num_text); ++ 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; ++ ++ fprintf(STDERR,"\n"); ++ for (i=0; i 1) ++ fprintf(STDERR," eXIf type %c%c, %lu bytes\n",exif[0],exif[1], ++ (unsigned long)exif_length); ++# ifdef PNG_WRITE_eXIf_SUPPORTED ++ png_set_eXIf_1(write_ptr, write_end_info_ptr, exif_length, exif); ++# endif ++ } ++ } ++#endif + #ifdef PNG_tIME_SUPPORTED + { + 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)); +- tIME_string[png_sizeof(tIME_string) - 1] = '\0'; ++ if (png_convert_to_rfc1123_buffer(tIME_string, mod_time) != 0) ++ tIME_string[(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 + #ifdef PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED + { + png_unknown_chunkp unknowns; +- int num_unknowns; +- num_unknowns = (int)png_get_unknown_chunks(read_ptr, end_info_ptr, +- &unknowns); +- if (num_unknowns) ++ int num_unknowns = png_get_unknown_chunks(read_ptr, end_info_ptr, ++ &unknowns); ++ ++ if (num_unknowns != 0) + { +- png_size_t i; + png_set_unknown_chunks(write_ptr, write_end_info_ptr, unknowns, +- num_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 < (png_size_t)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); + iheight = png_get_image_height(write_ptr, write_info_ptr); + fprintf(STDERR, "\n Image width = %lu, height = %lu\n", +- (unsigned long)iwidth, (unsigned long)iheight); ++ (unsigned long)iwidth, (unsigned long)iheight); + } + #endif + +- png_debug(0, "Destroying data structs"); ++ pngtest_debug("Destroying data structs"); + #ifdef SINGLE_ROWBUF_ALLOC +- png_debug(1, "destroying row_buf for read_ptr"); ++ pngtest_debug("destroying row_buf for read_ptr"); + png_free(read_ptr, row_buf); + row_buf = NULL; + #endif /* SINGLE_ROWBUF_ALLOC */ +- png_debug(1, "destroying read_ptr, read_info_ptr, end_info_ptr"); ++ pngtest_debug("destroying read_ptr, read_info_ptr, end_info_ptr"); + png_destroy_read_struct(&read_ptr, &read_info_ptr, &end_info_ptr); + #ifdef PNG_WRITE_SUPPORTED +- png_debug(1, "destroying write_end_info_ptr"); ++ pngtest_debug("destroying write_end_info_ptr"); + png_destroy_info_struct(write_ptr, &write_end_info_ptr); +- png_debug(1, "destroying write_ptr, write_info_ptr"); ++ pngtest_debug("destroying write_ptr, write_info_ptr"); + png_destroy_write_struct(&write_ptr, &write_info_ptr); + #endif +- png_debug(0, "Destruction complete."); ++ pngtest_debug("Destruction complete."); + + FCLOSE(fpin); + FCLOSE(fpout); + +- png_debug(0, "Opening files for comparison"); +-#ifdef _WIN32_WCE +- MultiByteToWideChar(CP_ACP, 0, inname, -1, path, MAX_PATH); +- if ((fpin = CreateFile(path, GENERIC_READ, 0, NULL, OPEN_EXISTING, +- 0, NULL)) == INVALID_HANDLE_VALUE) +-#else ++ /* 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 is 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) +-#endif + { + fprintf(STDERR, "Could not find file %s\n", inname); + return (1); + } + +-#ifdef _WIN32_WCE +- MultiByteToWideChar(CP_ACP, 0, outname, -1, path, MAX_PATH); +- if ((fpout = CreateFile(path, GENERIC_READ, 0, NULL, OPEN_EXISTING, +- 0, NULL)) == INVALID_HANDLE_VALUE) +-#else + if ((fpout = fopen(outname, "rb")) == NULL) +-#endif + { + fprintf(STDERR, "Could not find file %s\n", outname); + FCLOSE(fpin); + return (1); + } + +- for (;;) ++#if defined (PNG_WRITE_SUPPORTED) /* else nothing was written */ &&\ ++ defined (PNG_WRITE_FILTER_SUPPORTED) ++ if (interlace_preserved != 0) /* else the files will be changed */ + { +- png_size_t num_in, num_out; ++ for (;;) ++ { ++ static int wrote_question = 0; ++ size_t num_in, num_out; ++ char inbuf[256], outbuf[256]; + +- READFILE(fpin, inbuf, 1, num_in); +- READFILE(fpout, outbuf, 1, num_out); ++ 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 (wrote_question == 0) ++ if (num_in != num_out) + { +- 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; ++ fprintf(STDERR, "\nFiles %s and %s are of a different size\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; ++ } ++ ++ FCLOSE(fpin); ++ FCLOSE(fpout); ++ ++ if (strict != 0 && unsupported_chunks == 0) ++ return (1); ++ ++ else ++ return (0); + } +- FCLOSE(fpin); +- FCLOSE(fpout); +- return (0); +- } + +- if (!num_in) +- break; ++ if (num_in == 0) ++ break; + +- if (png_memcmp(inbuf, outbuf, num_in)) +- { +- fprintf(STDERR, "\nFiles %s and %s are different\n", inname, outname); +- if (wrote_question == 0) ++ if (memcmp(inbuf, outbuf, num_in)) + { +- 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; ++ 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; ++ } ++ ++ 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 && WRITE_FILTER */ + + FCLOSE(fpin); + FCLOSE(fpout); +@@ -1443,11 +1809,11 @@ test_one_file(PNG_CONST char *inname, PNG_CONST char *outname) + + /* Input and output filenames */ + #ifdef RISCOS +-static PNG_CONST char *inname = "pngtest/png"; +-static PNG_CONST char *outname = "pngout/png"; ++static const char *inname = "pngtest/png"; ++static const char *outname = "pngout/png"; + #else +-static PNG_CONST char *inname = "pngtest.png"; +-static PNG_CONST char *outname = "pngout.png"; ++static const char *inname = "pngtest.png"; ++static const char *outname = "pngout.png"; + #endif + + int +@@ -1456,18 +1822,19 @@ main(int argc, char *argv[]) + int multiple = 0; + int ierror = 0; + ++ png_structp dummy_ptr; ++ + fprintf(STDERR, "\n Testing libpng version %s\n", PNG_LIBPNG_VER_STRING); + fprintf(STDERR, " with zlib version %s\n", ZLIB_VERSION); + fprintf(STDERR, "%s", png_get_copyright(NULL)); + /* Show the version of libpng used in building the library */ + fprintf(STDERR, " library (%lu):%s", +- (unsigned long)png_access_version_number(), +- png_get_header_version(NULL)); ++ (unsigned long)png_access_version_number(), ++ png_get_header_version(NULL)); ++ + /* Show the version of libpng used in building the application */ + fprintf(STDERR, " pngtest (%lu):%s", (unsigned long)PNG_LIBPNG_VER, +- PNG_HEADER_VERSION_STRING); +- fprintf(STDERR, " sizeof(png_struct)=%ld, sizeof(png_info)=%ld\n", +- (long)png_sizeof(png_struct), (long)png_sizeof(png_info)); ++ PNG_HEADER_VERSION_STRING); + + /* Do some consistency checking on the memory allocation settings, I'm + * not sure this matters, but it is nice to know, the first of these +@@ -1485,7 +1852,7 @@ main(int argc, char *argv[]) + if (strcmp(png_libpng_ver, PNG_LIBPNG_VER_STRING)) + { + fprintf(STDERR, +- "Warning: versions are different between png.h and png.c\n"); ++ "Warning: versions are different between png.h and png.c\n"); + fprintf(STDERR, " png.h version: %s\n", PNG_LIBPNG_VER_STRING); + fprintf(STDERR, " png.c version: %s\n\n", png_libpng_ver); + ++ierror; +@@ -1498,6 +1865,7 @@ main(int argc, char *argv[]) + multiple = 1; + status_dots_requested = 0; + } ++ + else if (strcmp(argv[1], "-mv") == 0 || + strcmp(argv[1], "-vm") == 0 ) + { +@@ -1505,12 +1873,44 @@ main(int argc, char *argv[]) + verbose = 1; + status_dots_requested = 1; + } ++ + else if (strcmp(argv[1], "-v") == 0) + { + verbose = 1; + status_dots_requested = 1; + inname = argv[2]; + } ++ ++ else if (strcmp(argv[1], "--strict") == 0) ++ { ++ status_dots_requested = 0; ++ verbose = 1; ++ inname = argv[2]; ++ strict++; ++ relaxed = 0; ++ multiple=1; ++ } ++ ++ else if (strcmp(argv[1], "--relaxed") == 0) ++ { ++ status_dots_requested = 0; ++ verbose = 1; ++ inname = argv[2]; ++ strict = 0; ++ relaxed++; ++ multiple=1; ++ } ++ else if (strcmp(argv[1], "--xfail") == 0) ++ { ++ status_dots_requested = 0; ++ verbose = 1; ++ inname = argv[2]; ++ strict = 0; ++ xfail++; ++ relaxed++; ++ multiple=1; ++ } ++ + else + { + inname = argv[1]; +@@ -1518,22 +1918,23 @@ main(int argc, char *argv[]) + } + } + +- if (!multiple && argc == 3 + verbose) +- outname = argv[2 + 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", +- argv[0], argv[0]); +- fprintf(STDERR, +- " reads/writes one PNG file (without -m) or multiple files (-m)\n"); +- fprintf(STDERR, +- " with -m %s is used as a temporary file\n", outname); +- exit(1); ++ fprintf(STDERR, ++ "usage: %s [infile.png] [outfile.png]\n\t%s -m {infile.png}\n", ++ argv[0], argv[0]); ++ fprintf(STDERR, ++ " reads/writes one PNG file (without -m) or multiple files (-m)\n"); ++ fprintf(STDERR, ++ " with -m %s is used as a temporary file\n", outname); ++ exit(1); + } + +- if (multiple) ++ if (multiple != 0) + { + int i; + #if defined(PNG_USER_MEM_SUPPORTED) && PNG_DEBUG +@@ -1543,50 +1944,53 @@ main(int argc, char *argv[]) + { + 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) + { +-#ifdef PNG_READ_USER_TRANSFORM_SUPPORTED +- int k; +-#endif + #ifdef PNG_WRITE_USER_TRANSFORM_SUPPORTED + fprintf(STDERR, "\n PASS (%lu zero samples)\n", +- (unsigned long)zero_samples); ++ (unsigned long)zero_samples); + #else + fprintf(STDERR, " PASS\n"); + #endif +-#ifdef PNG_READ_USER_TRANSFORM_SUPPORTED +- for (k = 0; k<256; k++) +- if (filters_used[k]) +- fprintf(STDERR, " Filter %d was used %lu times\n", +- k, (unsigned long)filters_used[k]); +-#endif + #ifdef PNG_TIME_RFC1123_SUPPORTED +- if (tIME_chunk_present != 0) +- fprintf(STDERR, " tIME = %s\n", tIME_string); +- tIME_chunk_present = 0; +-#endif /* PNG_TIME_RFC1123_SUPPORTED */ ++ if (tIME_chunk_present != 0) ++ fprintf(STDERR, " tIME = %s\n", tIME_string); ++ ++ tIME_chunk_present = 0; ++#endif /* TIME_RFC1123 */ + } ++ + else + { +- fprintf(STDERR, " FAIL\n"); +- ierror += kerror; ++ if (xfail) ++ fprintf(STDERR, " XFAIL\n"); ++ else ++ { ++ fprintf(STDERR, " FAIL\n"); ++ ierror += kerror; ++ } + } + #if defined(PNG_USER_MEM_SUPPORTED) && PNG_DEBUG + if (allocation_now != current_allocation) + fprintf(STDERR, "MEMORY ERROR: %d bytes lost\n", +- current_allocation - allocation_now); ++ current_allocation - allocation_now); ++ + if (current_allocation != 0) + { + memory_infop pinfo = pinformation; + + fprintf(STDERR, "MEMORY ERROR: %d bytes still allocated\n", +- current_allocation); ++ current_allocation); ++ + 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; + } + } +@@ -1594,15 +1998,16 @@ main(int argc, char *argv[]) + } + #if defined(PNG_USER_MEM_SUPPORTED) && PNG_DEBUG + fprintf(STDERR, " Current memory allocation: %10d bytes\n", +- current_allocation); ++ current_allocation); + fprintf(STDERR, " Maximum memory allocation: %10d bytes\n", +- maximum_allocation); ++ maximum_allocation); + fprintf(STDERR, " Total memory allocation: %10d bytes\n", +- total_allocation); ++ total_allocation); + fprintf(STDERR, " Number of allocations: %10d\n", +- num_allocations); ++ num_allocations); + #endif + } ++ + else + { + int i; +@@ -1612,57 +2017,73 @@ main(int argc, char *argv[]) + #if defined(PNG_USER_MEM_SUPPORTED) && PNG_DEBUG + int allocation_now = current_allocation; + #endif +- if (i == 1) status_dots_requested = 1; +- else if (verbose == 0)status_dots_requested = 0; ++ if (i == 1) ++ status_dots_requested = 1; ++ ++ else if (verbose == 0) ++ status_dots_requested = 0; ++ + if (i == 0 || verbose == 1 || ierror != 0) ++ { + fprintf(STDERR, "\n Testing %s:", inname); ++#if PNG_DEBUG > 0 ++ fprintf(STDERR, "\n"); ++#endif ++ } ++ + kerror = test_one_file(inname, outname); ++ + if (kerror == 0) + { + if (verbose == 1 || i == 2) + { +-#ifdef PNG_READ_USER_TRANSFORM_SUPPORTED +- int k; +-#endif + #ifdef PNG_WRITE_USER_TRANSFORM_SUPPORTED + fprintf(STDERR, "\n PASS (%lu zero samples)\n", +- (unsigned long)zero_samples); ++ (unsigned long)zero_samples); + #else + fprintf(STDERR, " PASS\n"); + #endif +-#ifdef PNG_READ_USER_TRANSFORM_SUPPORTED +- for (k = 0; k<256; k++) +- if (filters_used[k]) +- fprintf(STDERR, " Filter %d was used %lu times\n", +- k, (unsigned long)filters_used[k]); +-#endif + #ifdef PNG_TIME_RFC1123_SUPPORTED + if (tIME_chunk_present != 0) + fprintf(STDERR, " tIME = %s\n", tIME_string); +-#endif /* PNG_TIME_RFC1123_SUPPORTED */ ++#endif /* TIME_RFC1123 */ + } + } ++ + else + { + if (verbose == 0 && i != 2) ++ { + fprintf(STDERR, "\n Testing %s:", inname); +- fprintf(STDERR, " FAIL\n"); +- ierror += kerror; ++#if PNG_DEBUG > 0 ++ fprintf(STDERR, "\n"); ++#endif ++ } ++ ++ if (xfail) ++ fprintf(STDERR, " XFAIL\n"); ++ else ++ { ++ fprintf(STDERR, " FAIL\n"); ++ ierror += kerror; ++ } + } + #if defined(PNG_USER_MEM_SUPPORTED) && PNG_DEBUG + if (allocation_now != current_allocation) + fprintf(STDERR, "MEMORY ERROR: %d bytes lost\n", +- current_allocation - allocation_now); ++ current_allocation - allocation_now); ++ + if (current_allocation != 0) + { + memory_infop pinfo = pinformation; + + fprintf(STDERR, "MEMORY ERROR: %d bytes still allocated\n", +- current_allocation); ++ current_allocation); ++ + 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; + } + } +@@ -1670,13 +2091,13 @@ main(int argc, char *argv[]) + } + #if defined(PNG_USER_MEM_SUPPORTED) && PNG_DEBUG + fprintf(STDERR, " Current memory allocation: %10d bytes\n", +- current_allocation); ++ current_allocation); + fprintf(STDERR, " Maximum memory allocation: %10d bytes\n", +- maximum_allocation); ++ maximum_allocation); + fprintf(STDERR, " Total memory allocation: %10d bytes\n", +- total_allocation); ++ total_allocation); + fprintf(STDERR, " Number of allocations: %10d\n", +- num_allocations); ++ num_allocations); + #endif + } + +@@ -1685,21 +2106,51 @@ main(int argc, char *argv[]) + t_misc += (t_stop - t_start); + t_start = t_stop; + fprintf(STDERR, " CPU time used = %.3f seconds", +- (t_misc+t_decode+t_encode)/(float)CLOCKS_PER_SEC); ++ (t_misc+t_decode+t_encode)/(float)CLOCKS_PER_SEC); + fprintf(STDERR, " (decoding %.3f,\n", +- t_decode/(float)CLOCKS_PER_SEC); ++ t_decode/(float)CLOCKS_PER_SEC); + fprintf(STDERR, " encoding %.3f ,", +- t_encode/(float)CLOCKS_PER_SEC); ++ t_encode/(float)CLOCKS_PER_SEC); + fprintf(STDERR, " other %.3f seconds)\n\n", +- t_misc/(float)CLOCKS_PER_SEC); ++ t_misc/(float)CLOCKS_PER_SEC); + #endif + + if (ierror == 0) + fprintf(STDERR, " libpng passes test\n"); ++ + else + fprintf(STDERR, " libpng FAILS test\n"); ++ ++ dummy_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL); ++ fprintf(STDERR, " Default limits:\n"); ++ fprintf(STDERR, " width_max = %lu\n", ++ (unsigned long) png_get_user_width_max(dummy_ptr)); ++ fprintf(STDERR, " height_max = %lu\n", ++ (unsigned long) png_get_user_height_max(dummy_ptr)); ++ if (png_get_chunk_cache_max(dummy_ptr) == 0) ++ fprintf(STDERR, " cache_max = unlimited\n"); ++ else ++ fprintf(STDERR, " cache_max = %lu\n", ++ (unsigned long) png_get_chunk_cache_max(dummy_ptr)); ++ if (png_get_chunk_malloc_max(dummy_ptr) == 0) ++ fprintf(STDERR, " malloc_max = unlimited\n"); ++ else ++ fprintf(STDERR, " malloc_max = %lu\n", ++ (unsigned long) png_get_chunk_malloc_max(dummy_ptr)); ++ png_destroy_read_struct(&dummy_ptr, NULL, NULL); ++ + 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 version_1_2_44 your_png_h_is_not_version_1_2_44; ++typedef png_libpng_version_1_6_36 Your_png_h_is_not_version_1_6_36; +diff --git a/com32/lib/libpng/pngtrans.c b/com32/lib/libpng/pngtrans.c +index 6ad9dcf6..1100f46e 100644 +--- a/com32/lib/libpng/pngtrans.c ++++ b/com32/lib/libpng/pngtrans.c +@@ -1,43 +1,44 @@ + + /* pngtrans.c - transforms the data in a row (used by both readers and writers) + * +- * Last changed in libpng 1.2.41 [December 3, 2009] +- * Copyright (c) 1998-2009 Glenn Randers-Pehrson +- * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) +- * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) ++ * Copyright (c) 2018 Cosmin Truta ++ * Copyright (c) 1998-2002,2004,2006-2018 Glenn Randers-Pehrson ++ * Copyright (c) 1996-1997 Andreas Dilger ++ * Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc. + * + * This code is released under the libpng license. + * For conditions of distribution and use, see the disclaimer + * and license in png.h + */ + +-#define PNG_INTERNAL +-#define PNG_NO_PEDANTIC_WARNINGS +-#include "png.h" ++#include "pngpriv.h" ++ + #if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED) + + #if defined(PNG_READ_BGR_SUPPORTED) || defined(PNG_WRITE_BGR_SUPPORTED) + /* Turn on BGR-to-RGB mapping */ + void PNGAPI +-png_set_bgr(png_structp png_ptr) ++png_set_bgr(png_structrp png_ptr) + { + png_debug(1, "in png_set_bgr"); + + if (png_ptr == NULL) + return; ++ + png_ptr->transformations |= PNG_BGR; + } + #endif + + #if defined(PNG_READ_SWAP_SUPPORTED) || defined(PNG_WRITE_SWAP_SUPPORTED) +-/* Turn on 16 bit byte swapping */ ++/* 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"); + + if (png_ptr == NULL) + return; ++ + if (png_ptr->bit_depth == 16) + png_ptr->transformations |= PNG_SWAP_BYTES; + } +@@ -46,16 +47,19 @@ png_set_swap(png_structp png_ptr) + #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"); + + if (png_ptr == NULL) + return; ++ + 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 +@@ -63,12 +67,13 @@ png_set_packing(png_structp png_ptr) + #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"); + + if (png_ptr == NULL) + return; ++ + if (png_ptr->bit_depth < 8) + png_ptr->transformations |= PNG_PACKSWAP; + } +@@ -76,12 +81,13 @@ png_set_packswap(png_structp png_ptr) + + #if defined(PNG_READ_SHIFT_SUPPORTED) || defined(PNG_WRITE_SHIFT_SUPPORTED) + void PNGAPI +-png_set_shift(png_structp png_ptr, png_color_8p true_bits) ++png_set_shift(png_structrp png_ptr, png_const_color_8p true_bits) + { + png_debug(1, "in png_set_shift"); + + if (png_ptr == NULL) + return; ++ + png_ptr->transformations |= PNG_SHIFT; + png_ptr->shift = *true_bits; + } +@@ -90,11 +96,11 @@ png_set_shift(png_structp png_ptr, png_color_8p true_bits) + #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); +@@ -111,67 +117,116 @@ png_set_interlace_handling(png_structp png_ptr) + * 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; +- png_ptr->transformations |= PNG_FILLER; +-#ifdef PNG_LEGACY_SUPPORTED +- png_ptr->filler = (png_byte)filler; +-#else +- png_ptr->filler = (png_uint_16)filler; +-#endif +- if (filler_loc == PNG_FILLER_AFTER) +- png_ptr->flags |= PNG_FLAG_FILLER_AFTER; +- else +- png_ptr->flags &= ~PNG_FLAG_FILLER_AFTER; + +- /* This should probably go in the "do_read_filler" routine. +- * I attempted to do that in libpng-1.0.1a but that caused problems +- * so I restored it in libpng-1.0.2a +- */ +- +- if (png_ptr->color_type == PNG_COLOR_TYPE_RGB) ++ /* 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) + { +- png_ptr->usr_channels = 4; ++# 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 + } + +- /* 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) ++ else /* write */ + { +- png_ptr->usr_channels = 2; ++# 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; ++ ++ if (filler_loc == PNG_FILLER_AFTER) ++ png_ptr->flags |= PNG_FLAG_FILLER_AFTER; ++ ++ else ++ png_ptr->flags &= ~PNG_FLAG_FILLER_AFTER; + } + +-#ifndef PNG_1_0_X + /* Added to libpng-1.2.7 */ + void PNGAPI +-png_set_add_alpha(png_structp png_ptr, png_uint_32 filler, int filler_loc) ++png_set_add_alpha(png_structrp png_ptr, png_uint_32 filler, int filler_loc) + { + png_debug(1, "in png_set_add_alpha"); + + if (png_ptr == NULL) + return; ++ + png_set_filler(png_ptr, filler, filler_loc); +- png_ptr->transformations |= PNG_ADD_ALPHA; ++ /* The above may fail to do anything. */ ++ if ((png_ptr->transformations & PNG_FILLER) != 0) ++ png_ptr->transformations |= PNG_ADD_ALPHA; + } +-#endif + + #endif + + #if defined(PNG_READ_SWAP_ALPHA_SUPPORTED) || \ + defined(PNG_WRITE_SWAP_ALPHA_SUPPORTED) + void PNGAPI +-png_set_swap_alpha(png_structp png_ptr) ++png_set_swap_alpha(png_structrp png_ptr) + { + png_debug(1, "in png_set_swap_alpha"); + + if (png_ptr == NULL) + return; ++ + png_ptr->transformations |= PNG_SWAP_ALPHA; + } + #endif +@@ -179,24 +234,26 @@ png_set_swap_alpha(png_structp png_ptr) + #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"); + + if (png_ptr == NULL) + return; ++ + png_ptr->transformations |= PNG_INVERT_ALPHA; + } + #endif + + #if defined(PNG_READ_INVERT_SUPPORTED) || defined(PNG_WRITE_INVERT_SUPPORTED) + void PNGAPI +-png_set_invert_mono(png_structp png_ptr) ++png_set_invert_mono(png_structrp png_ptr) + { + png_debug(1, "in png_set_invert_mono"); + + if (png_ptr == NULL) + return; ++ + png_ptr->transformations |= PNG_INVERT_MONO; + } + +@@ -209,15 +266,11 @@ png_do_invert(png_row_infop row_info, png_bytep row) + /* This test removed from libpng version 1.0.13 and 1.2.0: + * if (row_info->bit_depth == 1 && + */ +-#ifdef PNG_USELESS_TESTS_SUPPORTED +- if (row == NULL || row_info == NULL) +- return; +-#endif + if (row_info->color_type == PNG_COLOR_TYPE_GRAY) + { + png_bytep rp = row; +- png_uint_32 i; +- png_uint_32 istop = row_info->rowbytes; ++ size_t i; ++ size_t istop = row_info->rowbytes; + + for (i = 0; i < istop; i++) + { +@@ -225,48 +278,49 @@ png_do_invert(png_row_infop row_info, png_bytep row) + rp++; + } + } ++ + else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA && + row_info->bit_depth == 8) + { + png_bytep rp = row; +- png_uint_32 i; +- png_uint_32 istop = row_info->rowbytes; ++ size_t i; ++ size_t istop = row_info->rowbytes; + +- for (i = 0; i < istop; i+=2) ++ for (i = 0; i < istop; i += 2) + { + *rp = (png_byte)(~(*rp)); +- rp+=2; ++ rp += 2; + } + } ++ ++#ifdef PNG_16BIT_SUPPORTED + else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA && + row_info->bit_depth == 16) + { + png_bytep rp = row; +- png_uint_32 i; +- png_uint_32 istop = row_info->rowbytes; ++ size_t i; ++ size_t istop = row_info->rowbytes; + +- for (i = 0; i < istop; i+=4) ++ for (i = 0; i < istop; i += 4) + { + *rp = (png_byte)(~(*rp)); +- *(rp+1) = (png_byte)(~(*(rp+1))); +- rp+=4; ++ *(rp + 1) = (png_byte)(~(*(rp + 1))); ++ rp += 4; + } + } ++#endif + } + #endif + ++#ifdef PNG_16BIT_SUPPORTED + #if defined(PNG_READ_SWAP_SUPPORTED) || defined(PNG_WRITE_SWAP_SUPPORTED) +-/* Swaps byte order on 16 bit depth images */ ++/* Swaps byte order on 16-bit depth images */ + void /* PRIVATE */ + png_do_swap(png_row_infop row_info, png_bytep row) + { + png_debug(1, "in png_do_swap"); + +- if ( +-#ifdef PNG_USELESS_TESTS_SUPPORTED +- row != NULL && row_info != NULL && +-#endif +- row_info->bit_depth == 16) ++ if (row_info->bit_depth == 16) + { + png_bytep rp = row; + png_uint_32 i; +@@ -274,16 +328,24 @@ png_do_swap(png_row_infop row_info, png_bytep row) + + 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 + } + } + } + #endif ++#endif + + #if defined(PNG_READ_PACKSWAP_SUPPORTED)||defined(PNG_WRITE_PACKSWAP_SUPPORTED) +-static PNG_CONST png_byte onebppswaptable[256] = { ++static const png_byte onebppswaptable[256] = { + 0x00, 0x80, 0x40, 0xC0, 0x20, 0xA0, 0x60, 0xE0, + 0x10, 0x90, 0x50, 0xD0, 0x30, 0xB0, 0x70, 0xF0, + 0x08, 0x88, 0x48, 0xC8, 0x28, 0xA8, 0x68, 0xE8, +@@ -318,7 +380,7 @@ static PNG_CONST png_byte onebppswaptable[256] = { + 0x1F, 0x9F, 0x5F, 0xDF, 0x3F, 0xBF, 0x7F, 0xFF + }; + +-static PNG_CONST png_byte twobppswaptable[256] = { ++static const png_byte twobppswaptable[256] = { + 0x00, 0x40, 0x80, 0xC0, 0x10, 0x50, 0x90, 0xD0, + 0x20, 0x60, 0xA0, 0xE0, 0x30, 0x70, 0xB0, 0xF0, + 0x04, 0x44, 0x84, 0xC4, 0x14, 0x54, 0x94, 0xD4, +@@ -353,7 +415,7 @@ static PNG_CONST png_byte twobppswaptable[256] = { + 0x2F, 0x6F, 0xAF, 0xEF, 0x3F, 0x7F, 0xBF, 0xFF + }; + +-static PNG_CONST png_byte fourbppswaptable[256] = { ++static const png_byte fourbppswaptable[256] = { + 0x00, 0x10, 0x20, 0x30, 0x40, 0x50, 0x60, 0x70, + 0x80, 0x90, 0xA0, 0xB0, 0xC0, 0xD0, 0xE0, 0xF0, + 0x01, 0x11, 0x21, 0x31, 0x41, 0x51, 0x61, 0x71, +@@ -394,22 +456,22 @@ png_do_packswap(png_row_infop row_info, png_bytep row) + { + png_debug(1, "in png_do_packswap"); + +- if ( +-#ifdef PNG_USELESS_TESTS_SUPPORTED +- row != NULL && row_info != NULL && +-#endif +- row_info->bit_depth < 8) ++ if (row_info->bit_depth < 8) + { +- png_bytep rp, end, table; ++ png_bytep rp; ++ png_const_bytep end, table; + + end = row + row_info->rowbytes; + + if (row_info->bit_depth == 1) +- table = (png_bytep)onebppswaptable; ++ table = onebppswaptable; ++ + else if (row_info->bit_depth == 2) +- table = (png_bytep)twobppswaptable; ++ table = twobppswaptable; ++ + else if (row_info->bit_depth == 4) +- table = (png_bytep)fourbppswaptable; ++ table = fourbppswaptable; ++ + else + return; + +@@ -417,165 +479,137 @@ png_do_packswap(png_row_infop row_info, png_bytep row) + *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) +-/* Remove filler or alpha byte(s) */ ++/* Remove a channel - this used to be 'png_do_strip_filler' but it used a ++ * somewhat weird combination of flags to determine what to do. All the calls ++ * to png_do_strip_filler are changed in 1.5.2 to call this instead with the ++ * correct arguments. ++ * ++ * The routine isn't general - the channel must be the channel at the start or ++ * end (not in the middle) of each pixel. ++ */ + void /* PRIVATE */ +-png_do_strip_filler(png_row_infop row_info, png_bytep row, png_uint_32 flags) ++png_do_strip_channel(png_row_infop row_info, png_bytep row, int at_start) + { +- png_debug(1, "in png_do_strip_filler"); +- +-#ifdef PNG_USELESS_TESTS_SUPPORTED +- if (row != NULL && row_info != NULL) +-#endif ++ png_bytep sp = row; /* source pointer */ ++ png_bytep dp = row; /* destination pointer */ ++ png_bytep ep = row + row_info->rowbytes; /* One beyond end of row */ ++ ++ /* At the start sp will point to the first byte to copy and dp to where ++ * it is copied to. ep always points just beyond the end of the row, so ++ * the loop simply copies (channels-1) channels until sp reaches ep. ++ * ++ * at_start: 0 -- convert AG, XG, ARGB, XRGB, AAGG, XXGG, etc. ++ * nonzero -- convert GA, GX, RGBA, RGBX, GGAA, RRGGBBXX, etc. ++ */ ++ ++ /* GA, GX, XG cases */ ++ if (row_info->channels == 2) + { +- png_bytep sp=row; +- png_bytep dp=row; +- png_uint_32 row_width=row_info->width; +- png_uint_32 i; ++ if (row_info->bit_depth == 8) ++ { ++ if (at_start != 0) /* Skip initial filler */ ++ ++sp; ++ else /* Skip initial channel and, for sp, the filler */ ++ { ++ sp += 2; ++dp; ++ } + +- if ((row_info->color_type == PNG_COLOR_TYPE_RGB || +- (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA && +- (flags & PNG_FLAG_STRIP_ALPHA))) && +- row_info->channels == 4) ++ /* For a 1 pixel wide image there is nothing to do */ ++ while (sp < ep) ++ { ++ *dp++ = *sp; sp += 2; ++ } ++ ++ row_info->pixel_depth = 8; ++ } ++ ++ else if (row_info->bit_depth == 16) + { +- if (row_info->bit_depth == 8) ++ if (at_start != 0) /* Skip initial filler */ ++ sp += 2; ++ else /* Skip initial channel and, for sp, the filler */ + { +- /* This converts from RGBX or RGBA to RGB */ +- if (flags & PNG_FLAG_FILLER_AFTER) +- { +- dp+=3; sp+=4; +- for (i = 1; i < row_width; i++) +- { +- *dp++ = *sp++; +- *dp++ = *sp++; +- *dp++ = *sp++; +- sp++; +- } +- } +- /* This converts from XRGB or ARGB to RGB */ +- else +- { +- for (i = 0; i < row_width; i++) +- { +- sp++; +- *dp++ = *sp++; +- *dp++ = *sp++; +- *dp++ = *sp++; +- } +- } +- row_info->pixel_depth = 24; +- row_info->rowbytes = row_width * 3; ++ sp += 4; dp += 2; + } +- else /* if (row_info->bit_depth == 16) */ ++ ++ while (sp < ep) + { +- if (flags & PNG_FLAG_FILLER_AFTER) +- { +- /* This converts from RRGGBBXX or RRGGBBAA to RRGGBB */ +- sp += 8; dp += 6; +- for (i = 1; i < row_width; i++) +- { +- /* This could be (although png_memcpy is probably slower): +- png_memcpy(dp, sp, 6); +- sp += 8; +- dp += 6; +- */ +- +- *dp++ = *sp++; +- *dp++ = *sp++; +- *dp++ = *sp++; +- *dp++ = *sp++; +- *dp++ = *sp++; +- *dp++ = *sp++; +- sp += 2; +- } +- } +- else +- { +- /* This converts from XXRRGGBB or AARRGGBB to RRGGBB */ +- for (i = 0; i < row_width; i++) +- { +- /* This could be (although png_memcpy is probably slower): +- png_memcpy(dp, sp, 6); +- sp += 8; +- dp += 6; +- */ +- +- sp+=2; +- *dp++ = *sp++; +- *dp++ = *sp++; +- *dp++ = *sp++; +- *dp++ = *sp++; +- *dp++ = *sp++; +- *dp++ = *sp++; +- } +- } +- row_info->pixel_depth = 48; +- row_info->rowbytes = row_width * 6; ++ *dp++ = *sp++; *dp++ = *sp; sp += 3; + } +- row_info->channels = 3; ++ ++ row_info->pixel_depth = 16; + } +- else if ((row_info->color_type == PNG_COLOR_TYPE_GRAY || +- (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA && +- (flags & PNG_FLAG_STRIP_ALPHA))) && +- row_info->channels == 2) ++ ++ else ++ return; /* bad bit depth */ ++ ++ row_info->channels = 1; ++ ++ /* Finally fix the color type if it records an alpha channel */ ++ if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA) ++ row_info->color_type = PNG_COLOR_TYPE_GRAY; ++ } ++ ++ /* RGBA, RGBX, XRGB cases */ ++ else if (row_info->channels == 4) ++ { ++ if (row_info->bit_depth == 8) + { +- if (row_info->bit_depth == 8) ++ if (at_start != 0) /* Skip initial filler */ ++ ++sp; ++ else /* Skip initial channels and, for sp, the filler */ + { +- /* This converts from GX or GA to G */ +- if (flags & PNG_FLAG_FILLER_AFTER) +- { +- for (i = 0; i < row_width; i++) +- { +- *dp++ = *sp++; +- sp++; +- } +- } +- /* This converts from XG or AG to G */ +- else +- { +- for (i = 0; i < row_width; i++) +- { +- sp++; +- *dp++ = *sp++; +- } +- } +- row_info->pixel_depth = 8; +- row_info->rowbytes = row_width; ++ sp += 4; dp += 3; + } +- else /* if (row_info->bit_depth == 16) */ ++ ++ /* Note that the loop adds 3 to dp and 4 to sp each time. */ ++ while (sp < ep) + { +- if (flags & PNG_FLAG_FILLER_AFTER) +- { +- /* This converts from GGXX or GGAA to GG */ +- sp += 4; dp += 2; +- for (i = 1; i < row_width; i++) +- { +- *dp++ = *sp++; +- *dp++ = *sp++; +- sp += 2; +- } +- } +- else +- { +- /* This converts from XXGG or AAGG to GG */ +- for (i = 0; i < row_width; i++) +- { +- sp += 2; +- *dp++ = *sp++; +- *dp++ = *sp++; +- } +- } +- row_info->pixel_depth = 16; +- row_info->rowbytes = row_width * 2; ++ *dp++ = *sp++; *dp++ = *sp++; *dp++ = *sp; sp += 2; + } +- row_info->channels = 1; ++ ++ row_info->pixel_depth = 24; + } +- if (flags & PNG_FLAG_STRIP_ALPHA) +- row_info->color_type &= ~PNG_COLOR_MASK_ALPHA; ++ ++ else if (row_info->bit_depth == 16) ++ { ++ if (at_start != 0) /* Skip initial filler */ ++ sp += 2; ++ else /* Skip initial channels and, for sp, the filler */ ++ { ++ sp += 8; dp += 6; ++ } ++ ++ while (sp < ep) ++ { ++ /* Copy 6 bytes, skip 2 */ ++ *dp++ = *sp++; *dp++ = *sp++; ++ *dp++ = *sp++; *dp++ = *sp++; ++ *dp++ = *sp++; *dp++ = *sp; sp += 3; ++ } ++ ++ row_info->pixel_depth = 48; ++ } ++ ++ else ++ return; /* bad bit depth */ ++ ++ row_info->channels = 3; ++ ++ /* Finally fix the color type if it records an alpha channel */ ++ if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA) ++ row_info->color_type = PNG_COLOR_TYPE_RGB; + } ++ ++ else ++ return; /* The filler channel has gone already */ ++ ++ /* Fix the rowbytes value. */ ++ row_info->rowbytes = (size_t)(dp-row); + } + #endif + +@@ -586,11 +620,7 @@ png_do_bgr(png_row_infop row_info, png_bytep row) + { + png_debug(1, "in png_do_bgr"); + +- if ( +-#ifdef PNG_USELESS_TESTS_SUPPORTED +- row != NULL && row_info != NULL && +-#endif +- (row_info->color_type & PNG_COLOR_MASK_COLOR)) ++ if ((row_info->color_type & PNG_COLOR_MASK_COLOR) != 0) + { + png_uint_32 row_width = row_info->width; + if (row_info->bit_depth == 8) +@@ -607,6 +637,7 @@ png_do_bgr(png_row_infop row_info, png_bytep row) + *(rp + 2) = save; + } + } ++ + else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA) + { + png_bytep rp; +@@ -620,6 +651,8 @@ png_do_bgr(png_row_infop row_info, png_bytep row) + } + } + } ++ ++#ifdef PNG_16BIT_SUPPORTED + else if (row_info->bit_depth == 16) + { + if (row_info->color_type == PNG_COLOR_TYPE_RGB) +@@ -637,6 +670,7 @@ png_do_bgr(png_row_infop row_info, png_bytep row) + *(rp + 5) = save; + } + } ++ + else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA) + { + png_bytep rp; +@@ -653,30 +687,139 @@ png_do_bgr(png_row_infop row_info, png_bytep row) + } + } + } ++#endif ++ } ++} ++#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 = PNG_PADBITS(row_info->pixel_depth, row_info->width); ++ png_bytep rp = png_ptr->row_buf + row_info->rowbytes - 1; ++ ++ 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 /* PNG_READ_BGR_SUPPORTED or PNG_WRITE_BGR_SUPPORTED */ ++#endif /* CHECK_FOR_INVALID_INDEX */ + + #if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \ +- defined(PNG_LEGACY_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_USER_TRANSFORM_PTR_SUPPORTED ++ ++#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; +-#else +- if (user_transform_ptr || user_transform_depth || user_transform_channels) +- png_warning(png_ptr, +- "This version of libpng does not support user transform info"); +-#endif + } + #endif + +@@ -685,15 +828,37 @@ png_set_user_transform_info(png_structp png_ptr, png_voidp + * associated with this pointer before png_write_destroy and png_read_destroy + * are called. + */ ++#ifdef PNG_USER_TRANSFORM_PTR_SUPPORTED + png_voidp PNGAPI +-png_get_user_transform_ptr(png_structp png_ptr) ++png_get_user_transform_ptr(png_const_structrp png_ptr) + { + if (png_ptr == NULL) + return (NULL); +-#ifdef PNG_USER_TRANSFORM_PTR_SUPPORTED +- return ((png_voidp)png_ptr->user_transform_ptr); +-#else +- return (NULL); ++ ++ return png_ptr->user_transform_ptr; ++} + #endif ++ ++#ifdef PNG_USER_TRANSFORM_INFO_SUPPORTED ++png_uint_32 PNGAPI ++png_get_current_row_number(png_const_structrp png_ptr) ++{ ++ /* See the comments in png.h - this is the sub-image row when reading an ++ * interlaced image. ++ */ ++ if (png_ptr != NULL) ++ return png_ptr->row_number; ++ ++ return PNG_UINT_32_MAX; /* help the app not to fail silently */ ++} ++ ++png_byte PNGAPI ++png_get_current_pass_number(png_const_structrp png_ptr) ++{ ++ if (png_ptr != NULL) ++ return png_ptr->pass; ++ return 8; /* invalid */ + } +-#endif /* PNG_READ_SUPPORTED || PNG_WRITE_SUPPORTED */ ++#endif /* USER_TRANSFORM_INFO */ ++#endif /* READ_USER_TRANSFORM || WRITE_USER_TRANSFORM */ ++#endif /* READ || WRITE */ +diff --git a/com32/lib/libpng/pngwio.c b/com32/lib/libpng/pngwio.c +index 44e5ea91..10e919dd 100644 +--- a/com32/lib/libpng/pngwio.c ++++ b/com32/lib/libpng/pngwio.c +@@ -1,10 +1,10 @@ + + /* pngwio.c - functions for data output + * +- * Last changed in libpng 1.2.41 [December 3, 2009] +- * Copyright (c) 1998-2009 Glenn Randers-Pehrson +- * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) +- * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) ++ * Copyright (c) 2018 Cosmin Truta ++ * Copyright (c) 1998-2002,2004,2006-2014,2016,2018 Glenn Randers-Pehrson ++ * Copyright (c) 1996-1997 Andreas Dilger ++ * Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc. + * + * This code is released under the libpng license. + * For conditions of distribution and use, see the disclaimer +@@ -18,23 +18,25 @@ + * them at run time with png_set_write_fn(...). + */ + +-#define PNG_INTERNAL +-#define PNG_NO_PEDANTIC_WARNINGS +-#include "png.h" ++#include "pngpriv.h" ++ + #ifdef PNG_WRITE_SUPPORTED + + /* Write the data to whatever output you are using. The default routine + * writes to a file pointer. Note that this routine sometimes gets called + * with very small lengths, so you should implement some kind of simple + * buffering if you are using unbuffered writes. This should never be asked +- * to write more than 64K on a 16 bit machine. ++ * to write more than 64K on a 16-bit machine. + */ + + void /* PRIVATE */ +-png_write_data(png_structp png_ptr, png_bytep data, png_size_t length) ++png_write_data(png_structrp png_ptr, png_const_bytep data, 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, 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"); + } +@@ -45,85 +47,19 @@ png_write_data(png_structp png_ptr, png_bytep data, png_size_t length) + * write_data function and use it at run time with png_set_write_fn(), rather + * than changing the library. + */ +-#ifndef USE_FAR_KEYWORD +-void PNGAPI +-png_default_write_data(png_structp png_ptr, png_bytep data, png_size_t length) ++void PNGCBAPI ++png_default_write_data(png_structp png_ptr, png_bytep data, size_t length) + { +- png_uint_32 check; ++ size_t check; + + if (png_ptr == NULL) + return; +-#ifdef _WIN32_WCE +- if ( !WriteFile((HANDLE)(png_ptr->io_ptr), data, length, &check, NULL) ) +- check = 0; +-#else +- check = fwrite(data, 1, length, (png_FILE_p)(png_ptr->io_ptr)); +-#endif +- if (check != length) +- png_error(png_ptr, "Write Error"); +-} +-#else +-/* This is the model-independent version. Since the standard I/O library +- * can't handle far buffers in the medium and small models, we have to copy +- * the data. +- */ +- +-#define NEAR_BUF_SIZE 1024 +-#define MIN(a,b) (a <= b ? a : b) + +-void PNGAPI +-png_default_write_data(png_structp png_ptr, png_bytep data, png_size_t length) +-{ +- png_uint_32 check; +- png_byte *near_data; /* Needs to be "png_byte *" instead of "png_bytep" */ +- png_FILE_p io_ptr; +- +- if (png_ptr == NULL) +- return; +- /* Check if data really is near. If so, use usual code. */ +- near_data = (png_byte *)CVT_PTR_NOCHECK(data); +- io_ptr = (png_FILE_p)CVT_PTR(png_ptr->io_ptr); +- if ((png_bytep)near_data == data) +- { +-#ifdef _WIN32_WCE +- if ( !WriteFile(io_ptr, near_data, length, &check, NULL) ) +- check = 0; +-#else +- check = fwrite(near_data, 1, length, io_ptr); +-#endif +- } +- else +- { +- png_byte buf[NEAR_BUF_SIZE]; +- png_size_t written, remaining, err; +- check = 0; +- remaining = length; +- do +- { +- written = MIN(NEAR_BUF_SIZE, remaining); +- png_memcpy(buf, data, written); /* Copy far buffer to near buffer */ +-#ifdef _WIN32_WCE +- if ( !WriteFile(io_ptr, buf, written, &err, NULL) ) +- err = 0; +-#else +- err = fwrite(buf, 1, written, io_ptr); +-#endif +- if (err != written) +- break; +- +- else +- check += err; ++ check = fwrite(data, 1, length, (png_FILE_p)(png_ptr->io_ptr)); + +- 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 +@@ -132,27 +68,25 @@ png_default_write_data(png_structp png_ptr, png_bytep data, png_size_t length) + */ + #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); + } + +-#ifdef PNG_STDIO_SUPPORTED +-void PNGAPI ++# ifdef PNG_STDIO_SUPPORTED ++void PNGCBAPI + png_default_flush(png_structp png_ptr) + { +-#ifndef _WIN32_WCE + png_FILE_p io_ptr; +-#endif ++ + if (png_ptr == NULL) + return; +-#ifndef _WIN32_WCE +- io_ptr = (png_FILE_p)CVT_PTR((png_ptr->io_ptr)); ++ ++ io_ptr = png_voidcast(png_FILE_p, (png_ptr->io_ptr)); + fflush(io_ptr); +-#endif + } +-#endif ++# endif + #endif + + /* This function allows the application to supply new output functions for +@@ -185,8 +119,8 @@ png_default_flush(png_structp png_ptr) + * *FILE structure. + */ + void PNGAPI +-png_set_write_fn(png_structp png_ptr, png_voidp io_ptr, +- png_rw_ptr write_data_fn, png_flush_ptr output_flush_fn) ++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) + return; +@@ -204,57 +138,31 @@ png_set_write_fn(png_structp png_ptr, png_voidp io_ptr, + #endif + + #ifdef PNG_WRITE_FLUSH_SUPPORTED +-#ifdef PNG_STDIO_SUPPORTED ++# ifdef PNG_STDIO_SUPPORTED ++ + if (output_flush_fn != NULL) + png_ptr->output_flush_fn = output_flush_fn; + + else + png_ptr->output_flush_fn = png_default_flush; +-#else ++ ++# else + png_ptr->output_flush_fn = output_flush_fn; +-#endif +-#endif /* PNG_WRITE_FLUSH_SUPPORTED */ ++# endif ++#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) + { + png_ptr->read_data_fn = NULL; ++ + png_warning(png_ptr, +- "Attempted to set both read_data_fn and write_data_fn in"); +- png_warning(png_ptr, +- "the same structure. Resetting read_data_fn to NULL."); ++ "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 */ +diff --git a/com32/lib/libpng/pngwrite.c b/com32/lib/libpng/pngwrite.c +index e411e816..160c877d 100644 +--- a/com32/lib/libpng/pngwrite.c ++++ b/com32/lib/libpng/pngwrite.c +@@ -1,22 +1,76 @@ + + /* pngwrite.c - general routines to write a PNG file + * +- * Last changed in libpng 1.2.42 [January 3, 2010] +- * Copyright (c) 1998-2010 Glenn Randers-Pehrson +- * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) +- * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) ++ * Copyright (c) 2018 Cosmin Truta ++ * Copyright (c) 1998-2002,2004,2006-2018 Glenn Randers-Pehrson ++ * Copyright (c) 1996-1997 Andreas Dilger ++ * Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc. + * + * This code is released under the libpng license. + * For conditions of distribution and use, see the disclaimer + * and license in png.h + */ + +-/* Get internal access to png.h */ +-#define PNG_INTERNAL +-#define PNG_NO_PEDANTIC_WARNINGS +-#include "png.h" ++#include "pngpriv.h" ++#ifdef PNG_SIMPLIFIED_WRITE_STDIO_SUPPORTED ++# include ++#endif /* SIMPLIFIED_WRITE_STDIO */ ++ + #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 +@@ -27,112 +81,115 @@ + * 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); ++ /* Write PNG signature */ ++ png_write_sig(png_ptr); ++ + #ifdef PNG_MNG_FEATURES_SUPPORTED +- if ((png_ptr->mode&PNG_HAVE_PNG_SIGNATURE) && \ +- (png_ptr->mng_features_permitted)) +- { +- png_warning(png_ptr, "MNG features are not allowed in a PNG datastream"); +- png_ptr->mng_features_permitted = 0; +- } ++ 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; ++ } + #endif +- /* Write IHDR information. */ +- png_write_IHDR(png_ptr, info_ptr->width, info_ptr->height, +- info_ptr->bit_depth, info_ptr->color_type, info_ptr->compression_type, +- info_ptr->filter_type, ++ ++ /* Write IHDR information. */ ++ png_write_IHDR(png_ptr, info_ptr->width, info_ptr->height, ++ info_ptr->bit_depth, info_ptr->color_type, info_ptr->compression_type, ++ info_ptr->filter_type, + #ifdef PNG_WRITE_INTERLACING_SUPPORTED +- info_ptr->interlace_type); ++ info_ptr->interlace_type + #else +- 0); +-#endif +- /* The rest of these check to see if the valid field has the appropriate +- * flag set, and if it does, writes the chunk. +- */ +-#ifdef PNG_WRITE_gAMA_SUPPORTED +- if (info_ptr->valid & PNG_INFO_gAMA) +- { +-# ifdef PNG_FLOATING_POINT_SUPPORTED +- png_write_gAMA(png_ptr, info_ptr->gamma); +-#else +-#ifdef PNG_FIXED_POINT_SUPPORTED +- png_write_gAMA_fixed(png_ptr, info_ptr->int_gamma); ++ 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 ++ * an 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_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 +- } +-#endif +-#ifdef PNG_WRITE_sRGB_SUPPORTED +- if (info_ptr->valid & PNG_INFO_sRGB) +- png_write_sRGB(png_ptr, (int)info_ptr->srgb_intent); +-#endif +-#ifdef PNG_WRITE_iCCP_SUPPORTED +- if (info_ptr->valid & PNG_INFO_iCCP) +- png_write_iCCP(png_ptr, info_ptr->iccp_name, PNG_COMPRESSION_TYPE_BASE, +- info_ptr->iccp_profile, (int)info_ptr->iccp_proflen); +-#endif ++ ++#ifdef PNG_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) +- png_write_sBIT(png_ptr, &(info_ptr->sig_bit), info_ptr->color_type); ++ 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) +- { +-#ifdef PNG_FLOATING_POINT_SUPPORTED +- png_write_cHRM(png_ptr, +- info_ptr->x_white, info_ptr->y_white, +- info_ptr->x_red, info_ptr->y_red, +- info_ptr->x_green, info_ptr->y_green, +- info_ptr->x_blue, info_ptr->y_blue); +-#else +-# ifdef PNG_FIXED_POINT_SUPPORTED +- png_write_cHRM_fixed(png_ptr, +- info_ptr->int_x_white, info_ptr->int_y_white, +- info_ptr->int_x_red, info_ptr->int_y_red, +- info_ptr->int_x_green, info_ptr->int_y_green, +- info_ptr->int_x_blue, info_ptr->int_y_blue); ++ ++#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 +- } +-#endif +-#ifdef PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED +- if (info_ptr->unknown_chunks_num) +- { +- png_unknown_chunk *up; +- +- png_debug(5, "writing extra chunks"); + +- for (up = info_ptr->unknown_chunks; +- up < info_ptr->unknown_chunks + info_ptr->unknown_chunks_num; +- up++) +- { +- int keep = png_handle_as_unknown(png_ptr, up->name); +- if (keep != PNG_HANDLE_CHUNK_NEVER && +- up->location && !(up->location & PNG_HAVE_PLTE) && +- !(up->location & PNG_HAVE_IDAT) && +- ((up->name[3] & 0x20) || keep == PNG_HANDLE_CHUNK_ALWAYS || +- (png_ptr->flags & PNG_FLAG_KEEP_UNSAFE_CHUNKS))) +- { +- if (up->size == 0) +- png_warning(png_ptr, "Writing zero-length unknown chunk"); +- png_write_chunk(png_ptr, up->name, up->data, up->size); +- } +- } +- } ++#ifdef PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED ++ write_unknown_chunks(png_ptr, info_ptr, PNG_HAVE_IHDR); + #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; +@@ -145,75 +202,78 @@ png_write_info(png_structp png_ptr, png_infop info_ptr) + + 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); ++ (png_uint_32)info_ptr->num_palette); ++ + else if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE) + png_error(png_ptr, "Valid palette required for paletted images"); + + #ifdef PNG_WRITE_tRNS_SUPPORTED +- if (info_ptr->valid & PNG_INFO_tRNS) ++ 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) && +- info_ptr->color_type == PNG_COLOR_TYPE_PALETTE) ++ if ((png_ptr->transformations & PNG_INVERT_ALPHA) != 0 && ++ info_ptr->color_type == PNG_COLOR_TYPE_PALETTE) + { +- int j; +- for (j = 0; j<(int)info_ptr->num_trans; j++) +- info_ptr->trans[j] = (png_byte)(255 - info_ptr->trans[j]); ++ int j, jend; ++ ++ jend = info_ptr->num_trans; ++ if (jend > PNG_MAX_PALETTE_LENGTH) ++ jend = PNG_MAX_PALETTE_LENGTH; ++ ++ for (j = 0; jtrans_alpha[j] = ++ (png_byte)(255 - info_ptr->trans_alpha[j]); + } + #endif +- png_write_tRNS(png_ptr, info_ptr->trans, &(info_ptr->trans_values), +- info_ptr->num_trans, info_ptr->color_type); ++ png_write_tRNS(png_ptr, info_ptr->trans_alpha, &(info_ptr->trans_color), ++ info_ptr->num_trans, info_ptr->color_type); + } + #endif + #ifdef PNG_WRITE_bKGD_SUPPORTED +- if (info_ptr->valid & PNG_INFO_bKGD) ++ if ((info_ptr->valid & PNG_INFO_bKGD) != 0) + png_write_bKGD(png_ptr, &(info_ptr->background), info_ptr->color_type); + #endif ++ ++#ifdef PNG_WRITE_eXIf_SUPPORTED ++ if ((info_ptr->valid & PNG_INFO_eXIf) != 0) ++ png_write_eXIf(png_ptr, info_ptr->exif, info_ptr->num_exif); ++#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); ++ 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); ++ info_ptr->pcal_X1, info_ptr->pcal_type, info_ptr->pcal_nparams, ++ info_ptr->pcal_units, info_ptr->pcal_params); + #endif + +-#ifdef PNG_sCAL_SUPPORTED +- if (info_ptr->valid & PNG_INFO_sCAL) + #ifdef PNG_WRITE_sCAL_SUPPORTED +-#if defined(PNG_FLOATING_POINT_SUPPORTED) && defined(PNG_STDIO_SUPPORTED) +- png_write_sCAL(png_ptr, (int)info_ptr->scal_unit, +- info_ptr->scal_pixel_width, info_ptr->scal_pixel_height); +-#else /* !FLOATING_POINT */ +-#ifdef PNG_FIXED_POINT_SUPPORTED ++ 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 /* FIXED_POINT */ +-#endif /* FLOATING_POINT */ +-#else /* !WRITE_sCAL */ +- png_warning(png_ptr, +- "png_write_sCAL not supported; sCAL chunk not written."); +-#endif /* WRITE_sCAL */ + #endif /* sCAL */ + + #ifdef PNG_WRITE_pHYs_SUPPORTED +- if (info_ptr->valid & PNG_INFO_pHYs) ++ 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); ++ 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; +@@ -221,9 +281,9 @@ png_write_info(png_structp png_ptr, png_infop info_ptr) + #endif /* tIME */ + + #ifdef PNG_WRITE_sPLT_SUPPORTED +- if (info_ptr->valid & PNG_INFO_sPLT) +- for (i = 0; i < (int)info_ptr->splt_palettes_num; i++) +- png_write_sPLT(png_ptr, info_ptr->splt_palettes + i); ++ 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 */ + + #ifdef PNG_WRITE_TEXT_SUPPORTED +@@ -231,45 +291,49 @@ png_write_info(png_structp png_ptr, png_infop info_ptr) + for (i = 0; i < info_ptr->num_text; i++) + { + png_debug2(2, "Writing header text chunk %d, type %d", i, +- info_ptr->text[i].compression); ++ info_ptr->text[i].compression); + /* An internationalized chunk? */ + if (info_ptr->text[i].compression > 0) + { + #ifdef PNG_WRITE_iTXt_SUPPORTED +- /* Write international chunk */ +- png_write_iTXt(png_ptr, +- info_ptr->text[i].compression, +- info_ptr->text[i].key, +- info_ptr->text[i].lang, +- info_ptr->text[i].lang_key, +- info_ptr->text[i].text); ++ /* Write international chunk */ ++ png_write_iTXt(png_ptr, ++ info_ptr->text[i].compression, ++ info_ptr->text[i].key, ++ info_ptr->text[i].lang, ++ info_ptr->text[i].lang_key, ++ info_ptr->text[i].text); ++ /* 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 */ + else if (info_ptr->text[i].compression == PNG_TEXT_COMPRESSION_zTXt) + { + #ifdef PNG_WRITE_zTXt_SUPPORTED + /* Write compressed chunk */ + png_write_zTXt(png_ptr, info_ptr->text[i].key, +- info_ptr->text[i].text, 0, +- info_ptr->text[i].compression); ++ 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) + { + #ifdef PNG_WRITE_tEXt_SUPPORTED + /* Write uncompressed chunk */ + png_write_tEXt(png_ptr, info_ptr->text[i].key, +- info_ptr->text[i].text, +- 0); ++ info_ptr->text[i].text, ++ 0); + /* Mark this chunk as written */ + info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_NONE_WR; + #else +@@ -281,27 +345,7 @@ png_write_info(png_structp png_ptr, png_infop info_ptr) + #endif /* tEXt */ + + #ifdef PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED +- if (info_ptr->unknown_chunks_num) +- { +- png_unknown_chunk *up; +- +- png_debug(5, "writing extra chunks"); +- +- for (up = info_ptr->unknown_chunks; +- up < info_ptr->unknown_chunks + info_ptr->unknown_chunks_num; +- up++) +- { +- int keep = png_handle_as_unknown(png_ptr, up->name); +- if (keep != PNG_HANDLE_CHUNK_NEVER && +- up->location && (up->location & PNG_HAVE_PLTE) && +- !(up->location & PNG_HAVE_IDAT) && +- ((up->name[3] & 0x20) || keep == PNG_HANDLE_CHUNK_ALWAYS || +- (png_ptr->flags & PNG_FLAG_KEEP_UNSAFE_CHUNKS))) +- { +- png_write_chunk(png_ptr, up->name, up->data, up->size); +- } +- } +- } ++ write_unknown_chunks(png_ptr, info_ptr, PNG_HAVE_PLTE); + #endif + } + +@@ -311,15 +355,21 @@ png_write_info(png_structp png_ptr, png_infop info_ptr) + * 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) + { +@@ -328,82 +378,73 @@ png_write_end(png_structp png_ptr, png_infop info_ptr) + #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 + #ifdef PNG_WRITE_TEXT_SUPPORTED + /* Loop through comment chunks */ + for (i = 0; i < info_ptr->num_text; i++) + { + png_debug2(2, "Writing trailer text chunk %d, type %d", i, +- info_ptr->text[i].compression); ++ info_ptr->text[i].compression); + /* An internationalized chunk? */ + if (info_ptr->text[i].compression > 0) + { + #ifdef PNG_WRITE_iTXt_SUPPORTED + /* Write international chunk */ + png_write_iTXt(png_ptr, +- info_ptr->text[i].compression, +- info_ptr->text[i].key, +- info_ptr->text[i].lang, +- info_ptr->text[i].lang_key, +- info_ptr->text[i].text); ++ info_ptr->text[i].compression, ++ info_ptr->text[i].key, ++ info_ptr->text[i].lang, ++ info_ptr->text[i].lang_key, ++ info_ptr->text[i].text); ++ /* 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) + { + #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) + { + #ifdef PNG_WRITE_tEXt_SUPPORTED + /* Write uncompressed chunk */ + png_write_tEXt(png_ptr, info_ptr->text[i].key, +- info_ptr->text[i].text, 0); ++ 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"); ++#ifdef PNG_WRITE_eXIf_SUPPORTED ++ if ((info_ptr->valid & PNG_INFO_eXIf) != 0) ++ png_write_eXIf(png_ptr, info_ptr->exif, info_ptr->num_exif); ++#endif + +- 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); +- } +- } +- } ++#ifdef PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED ++ write_unknown_chunks(png_ptr, info_ptr, PNG_AFTER_IDAT); + #endif + } + +@@ -411,6 +452,7 @@ png_write_end(png_structp png_ptr, png_infop info_ptr) + + /* 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 +@@ -426,9 +468,8 @@ png_write_end(png_structp png_ptr, png_infop info_ptr) + } + + #ifdef PNG_CONVERT_tIME_SUPPORTED +-/* "tm" structure is not supported on WindowsCE */ + void PNGAPI +-png_convert_from_struct_tm(png_timep ptime, struct tm FAR * ttime) ++png_convert_from_struct_tm(png_timep ptime, const struct tm * ttime) + { + png_debug(1, "in png_convert_from_struct_tm"); + +@@ -453,288 +494,90 @@ png_convert_from_time_t(png_timep ptime, time_t ttime) + #endif + + /* Initialize png_ptr structure, and allocate any memory needed */ +-png_structp PNGAPI +-png_create_write_struct(png_const_charp user_png_ver, png_voidp error_ptr, +- png_error_ptr error_fn, png_error_ptr warn_fn) ++PNG_FUNCTION(png_structp,PNGAPI ++png_create_write_struct,(png_const_charp user_png_ver, png_voidp error_ptr, ++ png_error_ptr error_fn, png_error_ptr warn_fn),PNG_ALLOCATED) + { +-#ifdef PNG_USER_MEM_SUPPORTED +- return (png_create_write_struct_2(user_png_ver, error_ptr, error_fn, +- warn_fn, png_voidp_NULL, png_malloc_ptr_NULL, png_free_ptr_NULL)); +-} +- +-/* Alternate initialize png_ptr structure, and allocate any memory needed */ +-png_structp PNGAPI +-png_create_write_struct_2(png_const_charp user_png_ver, png_voidp error_ptr, +- png_error_ptr error_fn, png_error_ptr warn_fn, png_voidp mem_ptr, +- png_malloc_ptr malloc_fn, png_free_ptr free_fn) +-{ +-#endif /* PNG_USER_MEM_SUPPORTED */ +-#ifdef PNG_SETJMP_SUPPORTED +- volatile +-#endif +- png_structp png_ptr; +-#ifdef PNG_SETJMP_SUPPORTED +-#ifdef USE_FAR_KEYWORD +- jmp_buf jmpbuf; +-#endif +-#endif +- int i; +- +- png_debug(1, "in png_create_write_struct"); +- +-#ifdef PNG_USER_MEM_SUPPORTED +- png_ptr = (png_structp)png_create_struct_2(PNG_STRUCT_PNG, +- (png_malloc_ptr)malloc_fn, (png_voidp)mem_ptr); +-#else +- png_ptr = (png_structp)png_create_struct(PNG_STRUCT_PNG); +-#endif /* PNG_USER_MEM_SUPPORTED */ +- if (png_ptr == NULL) +- return (NULL); +- +- /* Added at libpng-1.2.6 */ +-#ifdef PNG_SET_USER_LIMITS_SUPPORTED +- png_ptr->user_width_max = PNG_USER_WIDTH_MAX; +- png_ptr->user_height_max = PNG_USER_HEIGHT_MAX; +-#endif +- +-#ifdef PNG_SETJMP_SUPPORTED +-#ifdef USE_FAR_KEYWORD +- if (setjmp(jmpbuf)) +-#else +- if (setjmp(png_ptr->jmpbuf)) +-#endif +- { +- png_free(png_ptr, png_ptr->zbuf); +- png_ptr->zbuf = NULL; +-#ifdef PNG_USER_MEM_SUPPORTED +- png_destroy_struct_2((png_voidp)png_ptr, +- (png_free_ptr)free_fn, (png_voidp)mem_ptr); +-#else +- png_destroy_struct((png_voidp)png_ptr); +-#endif +- return (NULL); +- } +-#ifdef USE_FAR_KEYWORD +- png_memcpy(png_ptr->jmpbuf, jmpbuf, png_sizeof(jmp_buf)); +-#endif +-#endif +- +-#ifdef PNG_USER_MEM_SUPPORTED +- png_set_mem_fn(png_ptr, mem_ptr, malloc_fn, free_fn); +-#endif /* PNG_USER_MEM_SUPPORTED */ +- png_set_error_fn(png_ptr, error_ptr, error_fn, warn_fn); +- +- if (user_png_ver) +- { +- i = 0; +- do +- { +- if (user_png_ver[i] != png_libpng_ver[i]) +- png_ptr->flags |= PNG_FLAG_LIBRARY_MISMATCH; +- } while (png_libpng_ver[i++]); +- } +- +- if (png_ptr->flags & PNG_FLAG_LIBRARY_MISMATCH) +- { +- /* Libpng 0.90 and later are binary incompatible with libpng 0.89, so +- * we must recompile any applications that use any older library version. +- * For versions after libpng 1.0, we will be compatible, so we need +- * only check the first digit. +- */ +- if (user_png_ver == NULL || user_png_ver[0] != png_libpng_ver[0] || +- (user_png_ver[0] == '1' && user_png_ver[2] != png_libpng_ver[2]) || +- (user_png_ver[0] == '0' && user_png_ver[2] < '9')) +- { +-#if defined(PNG_STDIO_SUPPORTED) && !defined(_WIN32_WCE) +- char msg[80]; +- if (user_png_ver) +- { +- png_snprintf(msg, 80, +- "Application was compiled with png.h from libpng-%.20s", +- user_png_ver); +- png_warning(png_ptr, msg); +- } +- png_snprintf(msg, 80, +- "Application is running with png.c from libpng-%.20s", +- png_libpng_ver); +- png_warning(png_ptr, msg); +-#endif +-#ifdef PNG_ERROR_NUMBERS_SUPPORTED +- png_ptr->flags = 0; +-#endif +- png_error(png_ptr, +- "Incompatible libpng version in application and library"); +- } +- } +- +- /* Initialize zbuf - compression buffer */ +- png_ptr->zbuf_size = PNG_ZBUF_SIZE; +- png_ptr->zbuf = (png_bytep)png_malloc(png_ptr, +- (png_uint_32)png_ptr->zbuf_size); +- +- png_set_write_fn(png_ptr, png_voidp_NULL, png_rw_ptr_NULL, +- png_flush_ptr_NULL); +- +-#ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED +- png_set_filter_heuristics(png_ptr, PNG_FILTER_HEURISTIC_DEFAULT, +- 1, png_doublep_NULL, png_doublep_NULL); +-#endif +- +-#ifdef PNG_SETJMP_SUPPORTED +- /* Applications that neglect to set up their own setjmp() and then +- * encounter a png_error() will longjmp here. Since the jmpbuf is +- * then meaningless we abort instead of returning. +- */ +-#ifdef USE_FAR_KEYWORD +- if (setjmp(jmpbuf)) +- PNG_ABORT(); +- png_memcpy(png_ptr->jmpbuf, jmpbuf, png_sizeof(jmp_buf)); ++#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 +- if (setjmp(png_ptr->jmpbuf)) +- PNG_ABORT(); +-#endif +-#endif +- return (png_ptr); +-} +- +-/* Initialize png_ptr structure, and allocate any memory needed */ +-#if defined(PNG_1_0_X) || defined(PNG_1_2_X) +-/* Deprecated. */ +-#undef png_write_init +-void PNGAPI +-png_write_init(png_structp png_ptr) +-{ +- /* We only come here via pre-1.0.7-compiled applications */ +- png_write_init_2(png_ptr, "1.0.6 or earlier", 0, 0); ++ return png_create_write_struct_2(user_png_ver, error_ptr, error_fn, ++ warn_fn, NULL, NULL, NULL); + } + +-void PNGAPI +-png_write_init_2(png_structp png_ptr, png_const_charp user_png_ver, +- png_size_t png_struct_size, png_size_t png_info_size) ++/* Alternate initialize png_ptr structure, and allocate any memory needed */ ++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) + { +- /* We only come here via pre-1.0.12-compiled applications */ +- if (png_ptr == NULL) return; +-#if defined(PNG_STDIO_SUPPORTED) && !defined(_WIN32_WCE) +- if (png_sizeof(png_struct) > png_struct_size || +- png_sizeof(png_info) > png_info_size) +- { +- char msg[80]; +- png_ptr->warning_fn = NULL; +- if (user_png_ver) +- { +- png_snprintf(msg, 80, +- "Application was compiled with png.h from libpng-%.20s", +- user_png_ver); +- png_warning(png_ptr, msg); +- } +- png_snprintf(msg, 80, +- "Application is running with png.c from libpng-%.20s", +- png_libpng_ver); +- png_warning(png_ptr, msg); +- } +-#endif +- if (png_sizeof(png_struct) > png_struct_size) +- { +- png_ptr->error_fn = NULL; +-#ifdef PNG_ERROR_NUMBERS_SUPPORTED +- png_ptr->flags = 0; +-#endif +- png_error(png_ptr, +- "The png struct allocated by the application for writing is" +- " too small."); +- } +- if (png_sizeof(png_info) > png_info_size) ++ png_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) + { +- png_ptr->error_fn = NULL; +-#ifdef PNG_ERROR_NUMBERS_SUPPORTED +- png_ptr->flags = 0; +-#endif +- png_error(png_ptr, +- "The info struct allocated by the application for writing is" +- " too small."); +- } +- png_write_init_3(&png_ptr, user_png_ver, png_struct_size); +-} +-#endif /* PNG_1_0_X || PNG_1_2_X */ +- +- +-void PNGAPI +-png_write_init_3(png_structpp ptr_ptr, png_const_charp user_png_ver, +- png_size_t png_struct_size) +-{ +- png_structp png_ptr = *ptr_ptr; +-#ifdef PNG_SETJMP_SUPPORTED +- jmp_buf tmp_jmp; /* to save current jump buffer */ +-#endif +- +- int i = 0; +- +- if (png_ptr == NULL) +- return; ++ /* 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; + +- do +- { +- if (user_png_ver[i] != png_libpng_ver[i]) +- { +-#ifdef PNG_LEGACY_SUPPORTED +- png_ptr->flags |= PNG_FLAG_LIBRARY_MISMATCH; +-#else +- png_ptr->warning_fn = NULL; +- png_warning(png_ptr, +- "Application uses deprecated png_write_init() and should be recompiled."); ++ /* 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 +- } +- } while (png_libpng_ver[i++]); + +- png_debug(1, "in png_write_init_3"); +- +-#ifdef PNG_SETJMP_SUPPORTED +- /* Save jump buffer and error functions */ +- png_memcpy(tmp_jmp, png_ptr->jmpbuf, png_sizeof(jmp_buf)); ++ /* App warnings are warnings in release (or release candidate) builds but ++ * are errors during development. ++ */ ++#if PNG_RELEASE_BUILD ++ png_ptr->flags |= PNG_FLAG_APP_WARNINGS_WARN; + #endif + +- if (png_sizeof(png_struct) > png_struct_size) +- { +- png_destroy_struct(png_ptr); +- png_ptr = (png_structp)png_create_struct(PNG_STRUCT_PNG); +- *ptr_ptr = png_ptr; ++ /* 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); + } + +- /* Reset all variables to 0 */ +- png_memset(png_ptr, 0, png_sizeof(png_struct)); +- +- /* Added at libpng-1.2.6 */ +-#ifdef PNG_SET_USER_LIMITS_SUPPORTED +- png_ptr->user_width_max = PNG_USER_WIDTH_MAX; +- png_ptr->user_height_max = PNG_USER_HEIGHT_MAX; +-#endif +- +-#ifdef PNG_SETJMP_SUPPORTED +- /* Restore jump buffer */ +- png_memcpy(png_ptr->jmpbuf, tmp_jmp, png_sizeof(jmp_buf)); +-#endif +- +- png_set_write_fn(png_ptr, png_voidp_NULL, png_rw_ptr_NULL, +- png_flush_ptr_NULL); +- +- /* Initialize zbuf - compression buffer */ +- png_ptr->zbuf_size = PNG_ZBUF_SIZE; +- png_ptr->zbuf = (png_bytep)png_malloc(png_ptr, +- (png_uint_32)png_ptr->zbuf_size); +-#ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED +- png_set_filter_heuristics(png_ptr, PNG_FILTER_HEURISTIC_DEFAULT, +- 1, png_doublep_NULL, png_doublep_NULL); +-#endif ++ return png_ptr; + } + ++ + /* Write a few rows of image data. If the image is interlaced, + * either you will have to write the 7 sub images, or, if you + * have called png_set_interlace_handling(), you will have to + * "write" the image seven times. + */ + void PNGAPI +-png_write_rows(png_structp png_ptr, png_bytepp row, +- png_uint_32 num_rows) ++png_write_rows(png_structrp png_ptr, png_bytepp row, ++ png_uint_32 num_rows) + { + png_uint_32 i; /* row counter */ + png_bytepp rp; /* row pointer */ +@@ -755,7 +598,7 @@ png_write_rows(png_structp png_ptr, png_bytepp row, + * 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 */ +@@ -785,56 +628,127 @@ png_write_image(png_structp png_ptr, png_bytepp image) + } + } + +-/* Called by user to write a row of image data */ +-void PNGAPI +-png_write_row(png_structp png_ptr, png_bytep row) ++#ifdef PNG_MNG_FEATURES_SUPPORTED ++/* Performs intrapixel differencing */ ++static void ++png_do_write_intrapixel(png_row_infop row_info, png_bytep row) + { +- if (png_ptr == NULL) +- return; +- +- png_debug2(1, "in png_write_row (row %ld, pass %d)", +- png_ptr->row_number, png_ptr->pass); ++ png_debug(1, "in png_do_write_intrapixel"); + +- /* Initialize transformations and other stuff if first time */ +- if (png_ptr->row_number == 0 && png_ptr->pass == 0) ++ if ((row_info->color_type & PNG_COLOR_MASK_COLOR) != 0) + { +- /* Make sure we wrote the header info */ +- if (!(png_ptr->mode & PNG_WROTE_INFO_BEFORE_PLTE)) +- png_error(png_ptr, +- "png_write_info was never called before png_write_row."); ++ 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)); ++ *(rp + 2) = (png_byte)(*(rp + 2) - *(rp + 1)); ++ } ++ } ++ ++#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 = (png_uint_32)(*(rp ) << 8) | *(rp + 1); ++ png_uint_32 s1 = (png_uint_32)(*(rp + 2) << 8) | *(rp + 3); ++ png_uint_32 s2 = (png_uint_32)(*(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); ++ *(rp + 1) = (png_byte)red; ++ *(rp + 4) = (png_byte)(blue >> 8); ++ *(rp + 5) = (png_byte)blue; ++ } ++ } ++#endif /* WRITE_16BIT */ ++ } ++} ++#endif /* MNG_FEATURES */ ++ ++/* Called by user to write a row of image data */ ++void PNGAPI ++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; ++ ++ png_debug2(1, "in png_write_row (row %u, pass %d)", ++ png_ptr->row_number, png_ptr->pass); ++ ++ /* Initialize transformations and other stuff if first time */ ++ if (png_ptr->row_number == 0 && png_ptr->pass == 0) ++ { ++ /* Make sure we wrote the header info */ ++ if ((png_ptr->mode & PNG_WROTE_INFO_BEFORE_PLTE) == 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) != 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) != 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) != 0) ++ png_warning(png_ptr, ++ "PNG_WRITE_PACKSWAP_SUPPORTED is not defined"); ++#endif + +- /* Check for transforms that have been set but were defined out */ +-#if !defined(PNG_WRITE_INVERT_SUPPORTED) && defined(PNG_READ_INVERT_SUPPORTED) +- if (png_ptr->transformations & PNG_INVERT_MONO) +- png_warning(png_ptr, +- "PNG_WRITE_INVERT_SUPPORTED is not defined."); +-#endif +-#if !defined(PNG_WRITE_FILLER_SUPPORTED) && defined(PNG_READ_FILLER_SUPPORTED) +- if (png_ptr->transformations & PNG_FILLER) +- png_warning(png_ptr, +- "PNG_WRITE_FILLER_SUPPORTED is not defined."); +-#endif +-#if !defined(PNG_WRITE_PACKSWAP_SUPPORTED) && \ +- defined(PNG_READ_PACKSWAP_SUPPORTED) +- if (png_ptr->transformations & PNG_PACKSWAP) +- png_warning(png_ptr, +- "PNG_WRITE_PACKSWAP_SUPPORTED is not defined."); +-#endif + #if !defined(PNG_WRITE_PACK_SUPPORTED) && defined(PNG_READ_PACK_SUPPORTED) +- if (png_ptr->transformations & PNG_PACK) +- png_warning(png_ptr, "PNG_WRITE_PACK_SUPPORTED is not defined."); ++ 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) +- png_warning(png_ptr, "PNG_WRITE_SHIFT_SUPPORTED is not defined."); ++ 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) +- png_warning(png_ptr, "PNG_WRITE_BGR_SUPPORTED is not defined."); ++ 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) +- png_warning(png_ptr, "PNG_WRITE_SWAP_SUPPORTED is not defined."); ++ if ((png_ptr->transformations & PNG_SWAP_BYTES) != 0) ++ png_warning(png_ptr, "PNG_WRITE_SWAP_SUPPORTED is not defined"); + #endif + + png_write_start_row(png_ptr); +@@ -842,24 +756,27 @@ png_write_row(png_structp png_ptr, png_bytep row) + + #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; + } + 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; + } + break; ++ + case 2: + if ((png_ptr->row_number & 0x07) != 4) + { +@@ -867,13 +784,15 @@ png_write_row(png_structp png_ptr, png_bytep row) + return; + } + 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; + } + break; ++ + case 4: + if ((png_ptr->row_number & 0x03) != 2) + { +@@ -881,55 +800,55 @@ png_write_row(png_structp png_ptr, png_bytep row) + return; + } + 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; + } + break; ++ + case 6: +- if (!(png_ptr->row_number & 0x01)) ++ if ((png_ptr->row_number & 0x01) == 0) + { + png_write_finish_row(png_ptr); + return; + } + break; ++ ++ default: /* error: ignore it */ ++ break; + } + } + #endif + + /* Set up row info for transformations */ +- png_ptr->row_info.color_type = png_ptr->color_type; +- png_ptr->row_info.width = png_ptr->usr_width; +- png_ptr->row_info.channels = png_ptr->usr_channels; +- png_ptr->row_info.bit_depth = png_ptr->usr_bit_depth; +- png_ptr->row_info.pixel_depth = (png_byte)(png_ptr->row_info.bit_depth * +- png_ptr->row_info.channels); +- +- png_ptr->row_info.rowbytes = PNG_ROWBYTES(png_ptr->row_info.pixel_depth, +- png_ptr->row_info.width); +- +- png_debug1(3, "row_info->color_type = %d", png_ptr->row_info.color_type); +- png_debug1(3, "row_info->width = %lu", png_ptr->row_info.width); +- png_debug1(3, "row_info->channels = %d", png_ptr->row_info.channels); +- png_debug1(3, "row_info->bit_depth = %d", png_ptr->row_info.bit_depth); +- png_debug1(3, "row_info->pixel_depth = %d", png_ptr->row_info.pixel_depth); +- png_debug1(3, "row_info->rowbytes = %lu", png_ptr->row_info.rowbytes); ++ 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_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_check(png_ptr, 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; +@@ -937,9 +856,18 @@ png_write_row(png_structp png_ptr, png_bytep row) + } + #endif + ++#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 +@@ -951,16 +879,24 @@ png_write_row(png_structp png_ptr, png_bytep row) + * 4. The filter_method is 64 and + * 5. The color_type is RGB or RGBA + */ +- if ((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) && +- (png_ptr->filter_type == PNG_INTRAPIXEL_DIFFERENCING)) ++ 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); +@@ -969,223 +905,114 @@ png_write_row(png_structp png_ptr, png_bytep row) + #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"); + + if (png_ptr == NULL) + return; +- png_ptr->flush_dist = (nrows < 0 ? 0 : nrows); ++ ++ png_ptr->flush_dist = (nrows < 0 ? 0 : (png_uint_32)nrows); + } + + /* 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) + return; ++ + /* We have already written out all of the data */ + if (png_ptr->row_number >= png_ptr->num_rows) + return; + +- do +- { +- int ret; +- +- /* Compress the data */ +- ret = deflate(&png_ptr->zstream, Z_SYNC_FLUSH); +- wrote_IDAT = 0; +- +- /* Check for compression errors */ +- if (ret != Z_OK) +- { +- if (png_ptr->zstream.msg != NULL) +- png_error(png_ptr, png_ptr->zstream.msg); +- else +- png_error(png_ptr, "zlib error"); +- } +- +- if (!(png_ptr->zstream.avail_out)) +- { +- /* Write the IDAT and reset the zlib output buffer */ +- png_write_IDAT(png_ptr, png_ptr->zbuf, +- png_ptr->zbuf_size); +- png_ptr->zstream.next_out = png_ptr->zbuf; +- png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size; +- wrote_IDAT = 1; +- } +- } while(wrote_IDAT == 1); +- +- /* If there is any data left to be output, write it into a new IDAT */ +- if (png_ptr->zbuf_size != png_ptr->zstream.avail_out) +- { +- /* Write the IDAT and reset the zlib output buffer */ +- png_write_IDAT(png_ptr, png_ptr->zbuf, +- png_ptr->zbuf_size - png_ptr->zstream.avail_out); +- png_ptr->zstream.next_out = png_ptr->zbuf; +- png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size; +- } ++ png_compress_IDAT(png_ptr, NULL, 0, Z_SYNC_FLUSH); + png_ptr->flush_rows = 0; + png_flush(png_ptr); + } +-#endif /* PNG_WRITE_FLUSH_SUPPORTED */ +- +-/* Free all memory used by the write */ +-void PNGAPI +-png_destroy_write_struct(png_structpp png_ptr_ptr, png_infopp info_ptr_ptr) +-{ +- png_structp png_ptr = NULL; +- png_infop info_ptr = NULL; +-#ifdef PNG_USER_MEM_SUPPORTED +- png_free_ptr free_fn = NULL; +- png_voidp mem_ptr = NULL; +-#endif +- +- png_debug(1, "in png_destroy_write_struct"); +- +- if (png_ptr_ptr != NULL) +- { +- png_ptr = *png_ptr_ptr; +-#ifdef PNG_USER_MEM_SUPPORTED +- free_fn = png_ptr->free_fn; +- mem_ptr = png_ptr->mem_ptr; +-#endif +- } +- +-#ifdef PNG_USER_MEM_SUPPORTED +- if (png_ptr != NULL) +- { +- free_fn = png_ptr->free_fn; +- mem_ptr = png_ptr->mem_ptr; +- } +-#endif +- +- if (info_ptr_ptr != NULL) +- info_ptr = *info_ptr_ptr; +- +- if (info_ptr != NULL) +- { +- if (png_ptr != NULL) +- { +- png_free_data(png_ptr, info_ptr, PNG_FREE_ALL, -1); +- +-#ifdef PNG_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 +- } +- +-#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; +- } +-} +- ++#endif /* WRITE_FLUSH */ + +-/* 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; +- png_error_ptr warning_fn; +- png_voidp error_ptr; +-#ifdef PNG_USER_MEM_SUPPORTED +- png_free_ptr free_fn; +-#endif +- + png_debug(1, "in png_write_destroy"); + + /* Free any memory zlib uses */ +- deflateEnd(&png_ptr->zstream); ++ 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_READ_EXPANDED_SUPPORTED ++ png_free(png_ptr, png_ptr->riffled_palette); ++ png_ptr->riffled_palette = NULL; ++#endif + #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_free(png_ptr, png_ptr->try_row); ++ png_free(png_ptr, png_ptr->tst_row); ++ png_ptr->prev_row = NULL; ++ png_ptr->try_row = NULL; ++ png_ptr->tst_row = NULL; + #endif + +-#ifdef PNG_TIME_RFC1123_SUPPORTED +- png_free(png_ptr, png_ptr->time_buffer); ++#ifdef PNG_SET_UNKNOWN_CHUNKS_SUPPORTED ++ png_free(png_ptr, png_ptr->chunk_list); ++ png_ptr->chunk_list = NULL; + #endif + +-#ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED +- png_free(png_ptr, png_ptr->prev_filters); +- png_free(png_ptr, png_ptr->filter_weights); +- png_free(png_ptr, png_ptr->inv_filter_weights); +- png_free(png_ptr, png_ptr->filter_costs); +- png_free(png_ptr, png_ptr->inv_filter_costs); +-#endif +- +-#ifdef PNG_SETJMP_SUPPORTED +- /* Reset structure */ +- png_memcpy(tmp_jmp, png_ptr->jmpbuf, png_sizeof(jmp_buf)); +-#endif ++ /* 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. ++ */ ++} + +- error_fn = png_ptr->error_fn; +- warning_fn = png_ptr->warning_fn; +- error_ptr = png_ptr->error_ptr; +-#ifdef PNG_USER_MEM_SUPPORTED +- free_fn = png_ptr->free_fn; +-#endif ++/* 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_memset(png_ptr, 0, png_sizeof(png_struct)); ++ if (png_ptr_ptr != NULL) ++ { ++ png_structrp png_ptr = *png_ptr_ptr; + +- png_ptr->error_fn = error_fn; +- png_ptr->warning_fn = warning_fn; +- png_ptr->error_ptr = error_ptr; +-#ifdef PNG_USER_MEM_SUPPORTED +- png_ptr->free_fn = free_fn; +-#endif ++ if (png_ptr != NULL) /* added in libpng 1.6.0 */ ++ { ++ png_destroy_info_struct(png_ptr, info_ptr_ptr); + +-#ifdef PNG_SETJMP_SUPPORTED +- png_memcpy(png_ptr->jmpbuf, tmp_jmp, png_sizeof(jmp_buf)); +-#endif ++ *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"); + + if (png_ptr == NULL) + return; ++ + #ifdef PNG_MNG_FEATURES_SUPPORTED +- if ((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) && +- (method == PNG_INTRAPIXEL_DIFFERENCING)) +- method = PNG_FILTER_TYPE_BASE; ++ if ((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) != 0 && ++ (method == PNG_INTRAPIXEL_DIFFERENCING)) ++ method = PNG_FILTER_TYPE_BASE; ++ + #endif + if (method == PNG_FILTER_TYPE_BASE) + { +@@ -1194,399 +1021,1379 @@ png_set_filter(png_structp png_ptr, int method, int filters) + #ifdef PNG_WRITE_FILTER_SUPPORTED + case 5: + case 6: +- case 7: png_warning(png_ptr, "Unknown row filter for method 0"); +-#endif /* PNG_WRITE_FILTER_SUPPORTED */ ++ case 7: png_app_error(png_ptr, "Unknown row filter for method 0"); ++#endif /* WRITE_FILTER */ ++ /* FALLTHROUGH */ + case PNG_FILTER_VALUE_NONE: +- png_ptr->do_filter = PNG_FILTER_NONE; break; ++ png_ptr->do_filter = PNG_FILTER_NONE; break; ++ + #ifdef PNG_WRITE_FILTER_SUPPORTED + case PNG_FILTER_VALUE_SUB: +- png_ptr->do_filter = PNG_FILTER_SUB; break; ++ png_ptr->do_filter = PNG_FILTER_SUB; break; ++ + case PNG_FILTER_VALUE_UP: +- png_ptr->do_filter = PNG_FILTER_UP; break; ++ png_ptr->do_filter = PNG_FILTER_UP; break; ++ + case PNG_FILTER_VALUE_AVG: +- png_ptr->do_filter = PNG_FILTER_AVG; break; ++ png_ptr->do_filter = PNG_FILTER_AVG; break; ++ + case PNG_FILTER_VALUE_PAETH: +- png_ptr->do_filter = PNG_FILTER_PAETH; break; +- default: png_ptr->do_filter = (png_byte)filters; break; ++ png_ptr->do_filter = PNG_FILTER_PAETH; break; ++ ++ default: ++ png_ptr->do_filter = (png_byte)filters; break; + #else +- default: png_warning(png_ptr, "Unknown row filter for method 0"); +-#endif /* PNG_WRITE_FILTER_SUPPORTED */ ++ default: ++ png_app_error(png_ptr, "Unknown row filter for method 0"); ++#endif /* WRITE_FILTER */ + } + ++#ifdef PNG_WRITE_FILTER_SUPPORTED + /* If we have allocated the row_buf, this means we have already started + * with the image and we should have allocated all of the filter buffers + * that have been selected. If prev_row isn't already allocated, then + * it is too late to start using the filters that need it, since we + * will be missing the data in the previous row. If an application + * wants to start and stop using particular filters during compression, +- * it should start out with all of the filters, and then add and +- * remove them after the start of compression. ++ * it should start out with all of the filters, and then remove them ++ * or add them back after the start of compression. ++ * ++ * NOTE: this is a nasty constraint on the code, because it means that the ++ * prev_row buffer must be maintained even if there are currently no ++ * 'prev_row' requiring filters active. + */ + if (png_ptr->row_buf != NULL) + { +-#ifdef PNG_WRITE_FILTER_SUPPORTED +- if ((png_ptr->do_filter & PNG_FILTER_SUB) && png_ptr->sub_row == NULL) +- { +- png_ptr->sub_row = (png_bytep)png_malloc(png_ptr, +- (png_ptr->rowbytes + 1)); +- png_ptr->sub_row[0] = PNG_FILTER_VALUE_SUB; +- } ++ int num_filters; ++ png_alloc_size_t buf_size; + +- if ((png_ptr->do_filter & PNG_FILTER_UP) && png_ptr->up_row == NULL) +- { +- if (png_ptr->prev_row == NULL) +- { +- png_warning(png_ptr, "Can't add Up filter after starting"); +- png_ptr->do_filter &= ~PNG_FILTER_UP; +- } +- else +- { +- png_ptr->up_row = (png_bytep)png_malloc(png_ptr, +- (png_ptr->rowbytes + 1)); +- png_ptr->up_row[0] = PNG_FILTER_VALUE_UP; +- } +- } ++ /* Repeat the checks in png_write_start_row; 1 pixel high or wide ++ * images cannot benefit from certain filters. If this isn't done here ++ * the check below will fire on 1 pixel high images. ++ */ ++ if (png_ptr->height == 1) ++ filters &= ~(PNG_FILTER_UP|PNG_FILTER_AVG|PNG_FILTER_PAETH); + +- if ((png_ptr->do_filter & PNG_FILTER_AVG) && png_ptr->avg_row == NULL) +- { +- if (png_ptr->prev_row == NULL) +- { +- png_warning(png_ptr, "Can't add Average filter after starting"); +- png_ptr->do_filter &= ~PNG_FILTER_AVG; +- } +- else +- { +- png_ptr->avg_row = (png_bytep)png_malloc(png_ptr, +- (png_ptr->rowbytes + 1)); +- png_ptr->avg_row[0] = PNG_FILTER_VALUE_AVG; +- } +- } ++ if (png_ptr->width == 1) ++ filters &= ~(PNG_FILTER_SUB|PNG_FILTER_AVG|PNG_FILTER_PAETH); + +- if ((png_ptr->do_filter & PNG_FILTER_PAETH) && +- png_ptr->paeth_row == NULL) ++ if ((filters & (PNG_FILTER_UP|PNG_FILTER_AVG|PNG_FILTER_PAETH)) != 0 ++ && png_ptr->prev_row == NULL) + { +- if (png_ptr->prev_row == NULL) +- { +- png_warning(png_ptr, "Can't add Paeth filter after starting"); +- png_ptr->do_filter &= (png_byte)(~PNG_FILTER_PAETH); +- } +- else +- { +- png_ptr->paeth_row = (png_bytep)png_malloc(png_ptr, +- (png_ptr->rowbytes + 1)); +- png_ptr->paeth_row[0] = PNG_FILTER_VALUE_PAETH; +- } ++ /* This is the error case, however it is benign - the previous row ++ * is not available so the filter can't be used. Just warn here. ++ */ ++ png_app_warning(png_ptr, ++ "png_set_filter: UP/AVG/PAETH cannot be added after start"); ++ filters &= ~(PNG_FILTER_UP|PNG_FILTER_AVG|PNG_FILTER_PAETH); + } + +- if (png_ptr->do_filter == PNG_NO_FILTERS) +-#endif /* PNG_WRITE_FILTER_SUPPORTED */ +- png_ptr->do_filter = PNG_FILTER_NONE; +- } +- } +- else +- png_error(png_ptr, "Unknown custom filter method"); +-} +- +-/* This allows us to influence the way in which libpng chooses the "best" +- * filter for the current scanline. While the "minimum-sum-of-absolute- +- * differences metric is relatively fast and effective, there is some +- * question as to whether it can be improved upon by trying to keep the +- * filtered data going to zlib more consistent, hopefully resulting in +- * better compression. +- */ +-#ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED /* GRR 970116 */ +-void PNGAPI +-png_set_filter_heuristics(png_structp png_ptr, int heuristic_method, +- int num_weights, png_doublep filter_weights, +- png_doublep filter_costs) +-{ +- int i; +- +- png_debug(1, "in png_set_filter_heuristics"); +- +- if (png_ptr == NULL) +- return; +- if (heuristic_method >= PNG_FILTER_HEURISTIC_LAST) +- { +- png_warning(png_ptr, "Unknown filter heuristic method"); +- return; +- } +- +- if (heuristic_method == PNG_FILTER_HEURISTIC_DEFAULT) +- { +- heuristic_method = PNG_FILTER_HEURISTIC_UNWEIGHTED; +- } ++ num_filters = 0; + +- if (num_weights < 0 || filter_weights == NULL || +- heuristic_method == PNG_FILTER_HEURISTIC_UNWEIGHTED) +- { +- num_weights = 0; +- } ++ if (filters & PNG_FILTER_SUB) ++ num_filters++; + +- png_ptr->num_prev_filters = (png_byte)num_weights; +- png_ptr->heuristic_method = (png_byte)heuristic_method; ++ if (filters & PNG_FILTER_UP) ++ num_filters++; + +- if (num_weights > 0) +- { +- if (png_ptr->prev_filters == NULL) +- { +- png_ptr->prev_filters = (png_bytep)png_malloc(png_ptr, +- (png_uint_32)(png_sizeof(png_byte) * num_weights)); ++ if (filters & PNG_FILTER_AVG) ++ num_filters++; + +- /* To make sure that the weighting starts out fairly */ +- for (i = 0; i < num_weights; i++) +- { +- png_ptr->prev_filters[i] = 255; +- } +- } ++ if (filters & PNG_FILTER_PAETH) ++ num_filters++; + +- if (png_ptr->filter_weights == NULL) +- { +- png_ptr->filter_weights = (png_uint_16p)png_malloc(png_ptr, +- (png_uint_32)(png_sizeof(png_uint_16) * num_weights)); ++ /* Allocate needed row buffers if they have not already been ++ * allocated. ++ */ ++ buf_size = PNG_ROWBYTES(png_ptr->usr_channels * png_ptr->usr_bit_depth, ++ png_ptr->width) + 1; + +- png_ptr->inv_filter_weights = (png_uint_16p)png_malloc(png_ptr, +- (png_uint_32)(png_sizeof(png_uint_16) * num_weights)); +- for (i = 0; i < num_weights; i++) +- { +- png_ptr->inv_filter_weights[i] = +- png_ptr->filter_weights[i] = PNG_WEIGHT_FACTOR; +- } +- } ++ if (png_ptr->try_row == NULL) ++ png_ptr->try_row = png_voidcast(png_bytep, ++ png_malloc(png_ptr, buf_size)); + +- for (i = 0; i < num_weights; i++) +- { +- if (filter_weights[i] < 0.0) ++ if (num_filters > 1) + { +- png_ptr->inv_filter_weights[i] = +- png_ptr->filter_weights[i] = PNG_WEIGHT_FACTOR; +- } +- else +- { +- png_ptr->inv_filter_weights[i] = +- (png_uint_16)((double)PNG_WEIGHT_FACTOR*filter_weights[i]+0.5); +- png_ptr->filter_weights[i] = +- (png_uint_16)((double)PNG_WEIGHT_FACTOR/filter_weights[i]+0.5); ++ if (png_ptr->tst_row == NULL) ++ png_ptr->tst_row = png_voidcast(png_bytep, ++ png_malloc(png_ptr, buf_size)); + } + } ++ png_ptr->do_filter = (png_byte)filters; ++#endif + } ++ else ++ png_error(png_ptr, "Unknown custom filter method"); ++} + +- /* If, in the future, there are other filter methods, this would +- * need to be based on png_ptr->filter. +- */ +- if (png_ptr->filter_costs == NULL) +- { +- png_ptr->filter_costs = (png_uint_16p)png_malloc(png_ptr, +- (png_uint_32)(png_sizeof(png_uint_16) * PNG_FILTER_VALUE_LAST)); +- +- png_ptr->inv_filter_costs = (png_uint_16p)png_malloc(png_ptr, +- (png_uint_32)(png_sizeof(png_uint_16) * PNG_FILTER_VALUE_LAST)); +- +- for (i = 0; i < PNG_FILTER_VALUE_LAST; i++) +- { +- png_ptr->inv_filter_costs[i] = +- png_ptr->filter_costs[i] = PNG_COST_FACTOR; +- } +- } ++#ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED /* DEPRECATED */ ++/* Provide floating and fixed point APIs */ ++#ifdef PNG_FLOATING_POINT_SUPPORTED ++void PNGAPI ++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_UNUSED(png_ptr) ++ PNG_UNUSED(heuristic_method) ++ PNG_UNUSED(num_weights) ++ PNG_UNUSED(filter_weights) ++ PNG_UNUSED(filter_costs) ++} ++#endif /* FLOATING_POINT */ + +- /* Here is where we set the relative costs of the different filters. We +- * should take the desired compression level into account when setting +- * the costs, so that Paeth, for instance, has a high relative cost at low +- * compression levels, while it has a lower relative cost at higher +- * compression settings. The filter types are in order of increasing +- * relative cost, so it would be possible to do this with an algorithm. +- */ +- for (i = 0; i < PNG_FILTER_VALUE_LAST; i++) +- { +- if (filter_costs == NULL || filter_costs[i] < 0.0) +- { +- png_ptr->inv_filter_costs[i] = +- png_ptr->filter_costs[i] = PNG_COST_FACTOR; +- } +- else if (filter_costs[i] >= 1.0) +- { +- png_ptr->inv_filter_costs[i] = +- (png_uint_16)((double)PNG_COST_FACTOR / filter_costs[i] + 0.5); +- png_ptr->filter_costs[i] = +- (png_uint_16)((double)PNG_COST_FACTOR * filter_costs[i] + 0.5); +- } +- } ++#ifdef PNG_FIXED_POINT_SUPPORTED ++void PNGAPI ++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) ++{ ++ PNG_UNUSED(png_ptr) ++ PNG_UNUSED(heuristic_method) ++ PNG_UNUSED(num_weights) ++ PNG_UNUSED(filter_weights) ++ PNG_UNUSED(filter_costs) + } +-#endif /* PNG_WRITE_WEIGHTED_FILTER_SUPPORTED */ ++#endif /* FIXED_POINT */ ++#endif /* WRITE_WEIGHTED_FILTER */ + ++#ifdef PNG_WRITE_CUSTOMIZE_COMPRESSION_SUPPORTED + 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; + } + ++/* If PNG_WRITE_OPTIMIZE_CMF_SUPPORTED is defined, libpng will use a ++ * 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 that 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"); +-#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; ++ window_bits = 8; ++ } ++ + 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; + } ++#endif /* WRITE_CUSTOMIZE_COMPRESSION */ + ++/* The following were added to libpng-1.5.4 */ ++#ifdef PNG_WRITE_CUSTOMIZE_ZTXT_COMPRESSION_SUPPORTED + void PNGAPI +-png_set_write_status_fn(png_structp png_ptr, png_write_status_ptr write_row_fn) ++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->write_row_fn = write_row_fn; ++ ++ png_ptr->zlib_text_level = level; + } + +-#ifdef PNG_WRITE_USER_TRANSFORM_SUPPORTED + void PNGAPI +-png_set_write_user_transform_fn(png_structp png_ptr, png_user_transform_ptr +- write_user_transform_fn) ++png_set_text_compression_mem_level(png_structrp png_ptr, int mem_level) + { +- png_debug(1, "in png_set_write_user_transform_fn"); ++ png_debug(1, "in png_set_text_compression_mem_level"); + + if (png_ptr == NULL) + return; +- png_ptr->transformations |= PNG_USER_TRANSFORM; +- png_ptr->write_user_transform_fn = write_user_transform_fn; +-} +-#endif + ++ png_ptr->zlib_text_mem_level = mem_level; ++} + +-#ifdef PNG_INFO_IMAGE_SUPPORTED + void PNGAPI +-png_write_png(png_structp png_ptr, png_infop info_ptr, +- int transforms, voidp params) ++png_set_text_compression_strategy(png_structrp png_ptr, int strategy) + { +- if (png_ptr == NULL || info_ptr == NULL) +- return; ++ png_debug(1, "in png_set_text_compression_strategy"); ++ ++ if (png_ptr == NULL) ++ return; ++ ++ png_ptr->zlib_text_strategy = strategy; ++} ++ ++/* If PNG_WRITE_OPTIMIZE_CMF_SUPPORTED is defined, libpng will use a ++ * smaller value of window_bits if it can do so safely. ++ */ ++void PNGAPI ++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; ++ } ++ ++ png_ptr->zlib_text_window_bits = window_bits; ++} ++ ++void PNGAPI ++png_set_text_compression_method(png_structrp png_ptr, int method) ++{ ++ png_debug(1, "in png_set_text_compression_method"); ++ ++ if (png_ptr == NULL) ++ return; ++ ++ if (method != 8) ++ png_warning(png_ptr, "Only compression method 8 is supported by PNG"); ++ ++ png_ptr->zlib_text_method = method; ++} ++#endif /* WRITE_CUSTOMIZE_ZTXT_COMPRESSION */ ++/* end of API added to libpng-1.5.4 */ ++ ++void PNGAPI ++png_set_write_status_fn(png_structrp png_ptr, png_write_status_ptr write_row_fn) ++{ ++ if (png_ptr == NULL) ++ return; ++ ++ png_ptr->write_row_fn = write_row_fn; ++} ++ ++#ifdef PNG_WRITE_USER_TRANSFORM_SUPPORTED ++void PNGAPI ++png_set_write_user_transform_fn(png_structrp png_ptr, png_user_transform_ptr ++ write_user_transform_fn) ++{ ++ png_debug(1, "in png_set_write_user_transform_fn"); ++ ++ if (png_ptr == NULL) ++ return; ++ ++ png_ptr->transformations |= PNG_USER_TRANSFORM; ++ png_ptr->write_user_transform_fn = write_user_transform_fn; ++} ++#endif ++ ++ ++#ifdef PNG_INFO_IMAGE_SUPPORTED ++void PNGAPI ++png_write_png(png_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 ------- */ + +-#ifdef PNG_WRITE_INVERT_SUPPORTED + /* Invert monochrome pixels */ +- if (transforms & PNG_TRANSFORM_INVERT_MONO) ++ if ((transforms & PNG_TRANSFORM_INVERT_MONO) != 0) ++#ifdef PNG_WRITE_INVERT_SUPPORTED + 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 + +-#ifdef PNG_WRITE_PACK_SUPPORTED + /* Pack pixels into bytes */ +- if (transforms & PNG_TRANSFORM_PACKING) +- png_set_packing(png_ptr); ++ if ((transforms & PNG_TRANSFORM_PACKING) != 0) ++#ifdef PNG_WRITE_PACK_SUPPORTED ++ png_set_packing(png_ptr); ++#else ++ png_app_error(png_ptr, "PNG_TRANSFORM_PACKING not supported"); + #endif + +-#ifdef PNG_WRITE_SWAP_ALPHA_SUPPORTED + /* Swap location of alpha bytes from ARGB to RGBA */ +- if (transforms & PNG_TRANSFORM_SWAP_ALPHA) ++ if ((transforms & PNG_TRANSFORM_SWAP_ALPHA) != 0) ++#ifdef PNG_WRITE_SWAP_ALPHA_SUPPORTED + 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); +- else if (transforms & PNG_TRANSFORM_STRIP_FILLER_BEFORE) +- png_set_filler(png_ptr, 0, PNG_FILLER_BEFORE); ++ 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"); ++ ++ /* 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 ++ } + +-#ifdef PNG_WRITE_BGR_SUPPORTED + /* Flip BGR pixels to RGB */ +- if (transforms & PNG_TRANSFORM_BGR) ++ 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_SWAP_SUPPORTED + /* Swap bytes of 16-bit files to most significant byte first */ +- if (transforms & PNG_TRANSFORM_SWAP_ENDIAN) ++ 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 + ++ /* Swap bits of 1-bit, 2-bit, 4-bit packed pixel formats */ ++ if ((transforms & PNG_TRANSFORM_PACKSWAP) != 0) + #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); ++#else ++ png_app_error(png_ptr, "PNG_TRANSFORM_PACKSWAP not supported"); + #endif + +-#ifdef PNG_WRITE_INVERT_ALPHA_SUPPORTED + /* Invert the alpha channel from opacity to transparency */ +- if (transforms & PNG_TRANSFORM_INVERT_ALPHA) ++ if ((transforms & PNG_TRANSFORM_INVERT_ALPHA) != 0) ++#ifdef PNG_WRITE_INVERT_ALPHA_SUPPORTED + 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); + +- transforms = transforms; /* Quiet compiler warnings */ +- params = params; ++ PNG_UNUSED(params) + } + #endif +-#endif /* PNG_WRITE_SUPPORTED */ ++ ++ ++#ifdef PNG_SIMPLIFIED_WRITE_SUPPORTED ++/* 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; ++ /* Byte count for memory writing */ ++ png_bytep memory; ++ png_alloc_size_t memory_bytes; /* not used for STDIO */ ++ png_alloc_size_t output_bytes; /* running total */ ++} 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; ++ unsigned 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 ++ aindex = (int)channels; ++# else ++ aindex = (int)channels; ++# endif ++ } ++ ++ 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); ++ ++ for (; y > 0; --y) ++ { ++ png_const_uint_16p in_ptr = input_row; ++ png_uint_16p out_ptr = output_row; ++ ++ while (out_ptr < row_end) ++ { ++ 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 = (int)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 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 += (png_uint_16)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 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; ++ unsigned 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 = (int)channels; ++ ++ /* Use row_end in place of a loop counter: */ ++ row_end = output_row + image->width * (channels+1); ++ ++ for (; y > 0; --y) ++ { ++ 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 = (int)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 += (png_uint_16)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; ++ ++ for (; y > 0; --y) ++ { ++ 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 += (png_uint_16)display->row_bytes/(sizeof (png_uint_16)); ++ } ++ } ++ ++ return 1; ++} ++ ++static void ++png_image_set_PLTE(png_image_write_control *display) ++{ ++ png_imagep image = display->image; ++ const void *cmap = display->colormap; ++ int entries = image->colormap_entries > 256 ? 256 : ++ (int)image->colormap_entries; ++ ++ /* NOTE: the caller must check for cmap != NULL and entries != 0 */ ++ png_uint_32 format = image->format; ++ unsigned int channels = PNG_IMAGE_SAMPLE_CHANNELS(format); ++ ++# if defined(PNG_FORMAT_BGR_SUPPORTED) &&\ ++ defined(PNG_SIMPLIFIED_WRITE_AFIRST_SUPPORTED) ++ int afirst = (format & PNG_FORMAT_FLAG_AFIRST) != 0 && ++ (format & PNG_FORMAT_FLAG_ALPHA) != 0; ++# else ++# define afirst 0 ++# endif ++ ++# ifdef PNG_FORMAT_BGR_SUPPORTED ++ 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= 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 += (unsigned int)i * channels; ++ ++ switch (channels) ++ { ++ case 4: ++ tRNS[i] = entry[afirst ? 0 : 3]; ++ if (tRNS[i] < 255) ++ num_trans = i+1; ++ /* FALLTHROUGH */ ++ 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; ++ /* FALLTHROUGH */ ++ 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 = (png_uint_32)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 && (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, also check the row stride ++ * and total image size to ensure that they are within the system limits. ++ */ ++ { ++ unsigned int channels = PNG_IMAGE_PIXEL_CHANNELS(image->format); ++ ++ if (image->width <= 0x7fffffffU/channels) /* no overflow */ ++ { ++ png_uint_32 check; ++ png_uint_32 png_row_stride = image->width * channels; ++ ++ if (display->row_stride == 0) ++ display->row_stride = (png_int_32)/*SAFE*/png_row_stride; ++ ++ if (display->row_stride < 0) ++ check = (png_uint_32)(-display->row_stride); ++ ++ else ++ check = (png_uint_32)display->row_stride; ++ ++ if (check >= png_row_stride) ++ { ++ /* Now check for overflow of the image buffer calculation; this ++ * limits the whole image size to 32 bits for API compatibility with ++ * the current, 32-bit, PNG_IMAGE_BUFFER_SIZE macro. ++ */ ++ if (image->height > 0xffffffffU/png_row_stride) ++ png_error(image->opaque->png_ptr, "memory image too large"); ++ } ++ ++ else ++ png_error(image->opaque->png_ptr, "supplied row stride too small"); ++ } ++ ++ else ++ png_error(image->opaque->png_ptr, "image row stride too large"); ++ } ++ ++ /* 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_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. ++ */ ++# ifdef PNG_WRITE_CUSTOMIZE_COMPRESSION_SUPPORTED ++ png_set_compression_level(png_ptr, 3); ++# endif ++ } ++ ++ /* 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; ++ ++ for (; y > 0; --y) ++ { ++ png_write_row(png_ptr, row); ++ row += row_bytes; ++ } ++ } ++ ++ png_write_end(png_ptr, info_ptr); ++ return 1; ++} ++ ++ ++static void (PNGCBAPI ++image_memory_write)(png_structp png_ptr, png_bytep/*const*/ data, size_t size) ++{ ++ png_image_write_control *display = png_voidcast(png_image_write_control*, ++ png_ptr->io_ptr/*backdoor: png_get_io_ptr(png_ptr)*/); ++ png_alloc_size_t ob = display->output_bytes; ++ ++ /* Check for overflow; this should never happen: */ ++ if (size <= ((png_alloc_size_t)-1) - ob) ++ { ++ /* I don't think libpng ever does this, but just in case: */ ++ if (size > 0) ++ { ++ if (display->memory_bytes >= ob+size) /* writing */ ++ memcpy(display->memory+ob, data, size); ++ ++ /* Always update the size: */ ++ display->output_bytes = ob+size; ++ } ++ } ++ ++ else ++ png_error(png_ptr, "png_image_write_to_memory: PNG too big"); ++} ++ ++static void (PNGCBAPI ++image_memory_flush)(png_structp png_ptr) ++{ ++ PNG_UNUSED(png_ptr) ++} ++ ++static int ++png_image_write_memory(png_voidp argument) ++{ ++ png_image_write_control *display = png_voidcast(png_image_write_control*, ++ argument); ++ ++ /* The rest of the memory-specific init and write_main in an error protected ++ * environment. This case needs to use callbacks for the write operations ++ * since libpng has no built in support for writing to memory. ++ */ ++ png_set_write_fn(display->image->opaque->png_ptr, display/*io_ptr*/, ++ image_memory_write, image_memory_flush); ++ ++ return png_image_write_main(display); ++} ++ ++int PNGAPI ++png_image_write_to_memory(png_imagep image, void *memory, ++ png_alloc_size_t * PNG_RESTRICT memory_bytes, int convert_to_8bit, ++ const void *buffer, png_int_32 row_stride, const void *colormap) ++{ ++ /* Write the image to the given buffer, or count the bytes if it is NULL */ ++ if (image != NULL && image->version == PNG_IMAGE_VERSION) ++ { ++ if (memory_bytes != NULL && buffer != NULL) ++ { ++ /* This is to give the caller an easier error detection in the NULL ++ * case and guard against uninitialized variable problems: ++ */ ++ if (memory == NULL) ++ *memory_bytes = 0; ++ ++ if (png_image_write_init(image) != 0) ++ { ++ png_image_write_control display; ++ int result; ++ ++ 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; ++ display.memory = png_voidcast(png_bytep, memory); ++ display.memory_bytes = *memory_bytes; ++ display.output_bytes = 0; ++ ++ result = png_safe_execute(image, png_image_write_memory, &display); ++ png_image_free(image); ++ ++ /* write_memory returns true even if we ran out of buffer. */ ++ if (result) ++ { ++ /* On out-of-buffer this function returns '0' but still updates ++ * memory_bytes: ++ */ ++ if (memory != NULL && display.output_bytes > *memory_bytes) ++ result = 0; ++ ++ *memory_bytes = display.output_bytes; ++ } ++ ++ return result; ++ } ++ ++ else ++ return 0; ++ } ++ ++ else ++ return png_image_error(image, ++ "png_image_write_to_memory: invalid argument"); ++ } ++ ++ else if (image != NULL) ++ return png_image_error(image, ++ "png_image_write_to_memory: incorrect PNG_IMAGE_VERSION"); ++ ++ else ++ return 0; ++} ++ ++#ifdef PNG_SIMPLIFIED_WRITE_STDIO_SUPPORTED ++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 && buffer != 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 && buffer != 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 /* SIMPLIFIED_WRITE_STDIO */ ++#endif /* SIMPLIFIED_WRITE */ ++#endif /* WRITE */ +diff --git a/com32/lib/libpng/pngwtran.c b/com32/lib/libpng/pngwtran.c +index 0ce9b9b5..49a13c1e 100644 +--- a/com32/lib/libpng/pngwtran.c ++++ b/com32/lib/libpng/pngwtran.c +@@ -1,102 +1,32 @@ + + /* pngwtran.c - transforms the data in a row for PNG writers + * +- * Last changed in libpng 1.2.43 [February 25, 2010] +- * Copyright (c) 1998-2010 Glenn Randers-Pehrson +- * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) +- * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) ++ * Copyright (c) 2018 Cosmin Truta ++ * Copyright (c) 1998-2002,2004,2006-2016,2018 Glenn Randers-Pehrson ++ * Copyright (c) 1996-1997 Andreas Dilger ++ * Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc. + * + * This code is released under the libpng license. + * For conditions of distribution and use, see the disclaimer + * and license in png.h + */ + +-#define PNG_INTERNAL +-#define PNG_NO_PEDANTIC_WARNINGS +-#include "png.h" +-#ifdef PNG_WRITE_SUPPORTED +- +-/* Transform the data according to the user's wishes. The order of +- * transformations is significant. +- */ +-void /* PRIVATE */ +-png_do_write_transformations(png_structp png_ptr) +-{ +- png_debug(1, "in png_do_write_transformations"); +- +- if (png_ptr == NULL) +- return; ++#include "pngpriv.h" + +-#ifdef PNG_WRITE_USER_TRANSFORM_SUPPORTED +- if (png_ptr->transformations & PNG_USER_TRANSFORM) +- if (png_ptr->write_user_transform_fn != NULL) +- (*(png_ptr->write_user_transform_fn)) /* User write transform +- function */ +- (png_ptr, /* png_ptr */ +- &(png_ptr->row_info), /* row_info: */ +- /* png_uint_32 width; width of row */ +- /* png_uint_32 rowbytes; number of bytes in row */ +- /* png_byte color_type; color type of pixels */ +- /* png_byte bit_depth; bit depth of samples */ +- /* png_byte channels; number of channels (1-4) */ +- /* png_byte pixel_depth; bits per pixel (depth*channels) */ +- png_ptr->row_buf + 1); /* start of pixel data for row */ +-#endif +-#ifdef PNG_WRITE_FILLER_SUPPORTED +- if (png_ptr->transformations & PNG_FILLER) +- png_do_strip_filler(&(png_ptr->row_info), png_ptr->row_buf + 1, +- png_ptr->flags); +-#endif +-#ifdef PNG_WRITE_PACKSWAP_SUPPORTED +- if (png_ptr->transformations & PNG_PACKSWAP) +- png_do_packswap(&(png_ptr->row_info), png_ptr->row_buf + 1); +-#endif +-#ifdef PNG_WRITE_PACK_SUPPORTED +- if (png_ptr->transformations & PNG_PACK) +- png_do_pack(&(png_ptr->row_info), png_ptr->row_buf + 1, +- (png_uint_32)png_ptr->bit_depth); +-#endif +-#ifdef PNG_WRITE_SWAP_SUPPORTED +- if (png_ptr->transformations & PNG_SWAP_BYTES) +- png_do_swap(&(png_ptr->row_info), png_ptr->row_buf + 1); +-#endif +-#ifdef PNG_WRITE_SHIFT_SUPPORTED +- if (png_ptr->transformations & PNG_SHIFT) +- png_do_shift(&(png_ptr->row_info), png_ptr->row_buf + 1, +- &(png_ptr->shift)); +-#endif +-#ifdef PNG_WRITE_SWAP_ALPHA_SUPPORTED +- if (png_ptr->transformations & PNG_SWAP_ALPHA) +- png_do_write_swap_alpha(&(png_ptr->row_info), png_ptr->row_buf + 1); +-#endif +-#ifdef PNG_WRITE_INVERT_ALPHA_SUPPORTED +- if (png_ptr->transformations & PNG_INVERT_ALPHA) +- png_do_write_invert_alpha(&(png_ptr->row_info), png_ptr->row_buf + 1); +-#endif +-#ifdef PNG_WRITE_BGR_SUPPORTED +- if (png_ptr->transformations & PNG_BGR) +- png_do_bgr(&(png_ptr->row_info), png_ptr->row_buf + 1); +-#endif +-#ifdef PNG_WRITE_INVERT_SUPPORTED +- if (png_ptr->transformations & PNG_INVERT_MONO) +- png_do_invert(&(png_ptr->row_info), png_ptr->row_buf + 1); +-#endif +-} ++#ifdef PNG_WRITE_SUPPORTED ++#ifdef PNG_WRITE_TRANSFORMS_SUPPORTED + + #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"); + + if (row_info->bit_depth == 8 && +-#ifdef PNG_USELESS_TESTS_SUPPORTED +- row != NULL && row_info != NULL && +-#endif + row_info->channels == 1) + { + switch ((int)bit_depth) +@@ -117,9 +47,12 @@ png_do_pack(png_row_infop row_info, png_bytep row, png_uint_32 bit_depth) + { + if (*sp != 0) + v |= mask; ++ + sp++; ++ + if (mask > 1) + mask >>= 1; ++ + else + { + mask = 0x80; +@@ -128,14 +61,18 @@ png_do_pack(png_row_infop row_info, png_bytep row, png_uint_32 bit_depth) + v = 0; + } + } ++ + if (mask != 0x80) + *dp = (png_byte)v; ++ + break; + } ++ + case 2: + { + png_bytep sp, dp; +- int shift, v; ++ unsigned int shift; ++ int v; + png_uint_32 i; + png_uint_32 row_width = row_info->width; + +@@ -143,12 +80,14 @@ png_do_pack(png_row_infop row_info, png_bytep row, png_uint_32 bit_depth) + dp = row; + shift = 6; + v = 0; ++ + for (i = 0; i < row_width; i++) + { + png_byte value; + + value = (png_byte)(*sp & 0x03); + v |= (value << shift); ++ + if (shift == 0) + { + shift = 6; +@@ -156,18 +95,24 @@ png_do_pack(png_row_infop row_info, png_bytep row, png_uint_32 bit_depth) + dp++; + v = 0; + } ++ + else + shift -= 2; ++ + sp++; + } ++ + if (shift != 6) + *dp = (png_byte)v; ++ + break; + } ++ + case 4: + { + png_bytep sp, dp; +- int shift, v; ++ unsigned int shift; ++ int v; + png_uint_32 i; + png_uint_32 row_width = row_info->width; + +@@ -175,6 +120,7 @@ png_do_pack(png_row_infop row_info, png_bytep row, png_uint_32 bit_depth) + dp = row; + shift = 4; + v = 0; ++ + for (i = 0; i < row_width; i++) + { + png_byte value; +@@ -189,20 +135,27 @@ png_do_pack(png_row_infop row_info, png_bytep row, png_uint_32 bit_depth) + dp++; + v = 0; + } ++ + else + shift -= 4; + + sp++; + } ++ + if (shift != 4) + *dp = (png_byte)v; ++ + break; + } ++ ++ default: ++ break; + } ++ + row_info->bit_depth = (png_byte)bit_depth; + row_info->pixel_depth = (png_byte)(bit_depth * row_info->channels); + row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth, +- row_info->width); ++ row_info->width); + } + } + #endif +@@ -215,40 +168,40 @@ png_do_pack(png_row_infop row_info, png_bytep row, png_uint_32 bit_depth) + * would pass 3 as bit_depth, and this routine would translate the + * data to 0 to 15. + */ +-void /* PRIVATE */ +-png_do_shift(png_row_infop row_info, png_bytep row, png_color_8p bit_depth) ++static void ++png_do_shift(png_row_infop row_info, png_bytep row, ++ png_const_color_8p bit_depth) + { + png_debug(1, "in png_do_shift"); + +-#ifdef PNG_USELESS_TESTS_SUPPORTED +- if (row != NULL && row_info != NULL && +-#else +- if ( +-#endif +- row_info->color_type != PNG_COLOR_TYPE_PALETTE) ++ if (row_info->color_type != PNG_COLOR_TYPE_PALETTE) + { + int shift_start[4], shift_dec[4]; +- int channels = 0; ++ unsigned 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; + channels++; ++ + shift_start[channels] = row_info->bit_depth - bit_depth->green; + shift_dec[channels] = bit_depth->green; + channels++; ++ + shift_start[channels] = row_info->bit_depth - bit_depth->blue; + shift_dec[channels] = bit_depth->blue; + channels++; + } ++ + else + { + shift_start[channels] = row_info->bit_depth - bit_depth->gray; + shift_dec[channels] = bit_depth->gray; + channels++; + } +- if (row_info->color_type & PNG_COLOR_MASK_ALPHA) ++ ++ 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; +@@ -259,33 +212,40 @@ png_do_shift(png_row_infop row_info, png_bytep row, png_color_8p bit_depth) + if (row_info->bit_depth < 8) + { + png_bytep bp = row; +- png_uint_32 i; +- png_byte mask; +- png_uint_32 row_bytes = row_info->rowbytes; ++ size_t i; ++ unsigned int mask; ++ size_t row_bytes = row_info->rowbytes; + + if (bit_depth->gray == 1 && row_info->bit_depth == 2) + mask = 0x55; ++ + else if (row_info->bit_depth == 4 && bit_depth->gray == 3) + mask = 0x11; ++ + else + mask = 0xff; + + for (i = 0; i < row_bytes; i++, bp++) + { +- png_uint_16 v; + int j; ++ 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); + } + } ++ + else if (row_info->bit_depth == 8) + { + png_bytep bp = row; +@@ -294,22 +254,26 @@ png_do_shift(png_row_infop row_info, png_bytep row, png_color_8p bit_depth) + + for (i = 0; i < istop; i++, bp++) + { +- +- png_uint_16 v; ++ 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); + } + } ++ + else + { + png_bytep bp; +@@ -318,20 +282,22 @@ png_do_shift(png_row_infop row_info, png_bytep row, png_color_8p bit_depth) + + for (bp = row, i = 0; i < istop; i++) + { +- int c = (int)(i%channels); +- png_uint_16 value, v; ++ 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); + } + } +@@ -340,23 +306,21 @@ png_do_shift(png_row_infop row_info, png_bytep row, png_color_8p bit_depth) + #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"); + +-#ifdef PNG_USELESS_TESTS_SUPPORTED +- if (row != NULL && row_info != NULL) +-#endif + { + if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA) + { +- /* This converts from ARGB to RGBA */ + if (row_info->bit_depth == 8) + { ++ /* This converts from ARGB to RGBA */ + png_bytep sp, dp; + png_uint_32 i; + png_uint_32 row_width = row_info->width; ++ + for (i = 0, sp = dp = row; i < row_width; i++) + { + png_byte save = *(sp++); +@@ -366,9 +330,11 @@ png_do_write_swap_alpha(png_row_infop row_info, png_bytep row) + *(dp++) = save; + } + } +- /* This converts from AARRGGBB to RRGGBBAA */ ++ ++#ifdef PNG_WRITE_16BIT_SUPPORTED + else + { ++ /* This converts from AARRGGBB to RRGGBBAA */ + png_bytep sp, dp; + png_uint_32 i; + png_uint_32 row_width = row_info->width; +@@ -388,12 +354,14 @@ png_do_write_swap_alpha(png_row_infop row_info, png_bytep row) + *(dp++) = save[1]; + } + } ++#endif /* WRITE_16BIT */ + } ++ + else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA) + { +- /* This converts from AG to GA */ + if (row_info->bit_depth == 8) + { ++ /* This converts from AG to GA */ + png_bytep sp, dp; + png_uint_32 i; + png_uint_32 row_width = row_info->width; +@@ -405,9 +373,11 @@ png_do_write_swap_alpha(png_row_infop row_info, png_bytep row) + *(dp++) = save; + } + } +- /* This converts from AAGG to GGAA */ ++ ++#ifdef PNG_WRITE_16BIT_SUPPORTED + else + { ++ /* This converts from AAGG to GGAA */ + png_bytep sp, dp; + png_uint_32 i; + png_uint_32 row_width = row_info->width; +@@ -423,29 +393,28 @@ png_do_write_swap_alpha(png_row_infop row_info, png_bytep row) + *(dp++) = save[1]; + } + } ++#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"); + +-#ifdef PNG_USELESS_TESTS_SUPPORTED +- if (row != NULL && row_info != NULL) +-#endif + { + if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA) + { +- /* This inverts the alpha channel in RGBA */ + if (row_info->bit_depth == 8) + { ++ /* This inverts the alpha channel in RGBA */ + png_bytep sp, dp; + png_uint_32 i; + png_uint_32 row_width = row_info->width; ++ + for (i = 0, sp = dp = row; i < row_width; i++) + { + /* Does nothing +@@ -454,12 +423,14 @@ png_do_write_invert_alpha(png_row_infop row_info, png_bytep row) + *(dp++) = *(sp++); + */ + sp+=3; dp = sp; +- *(dp++) = (png_byte)(255 - *(sp++)); ++ *dp = (png_byte)(255 - *(sp++)); + } + } +- /* This inverts the alpha channel in RRGGBBAA */ ++ ++#ifdef PNG_WRITE_16BIT_SUPPORTED + else + { ++ /* This inverts the alpha channel in RRGGBBAA */ + png_bytep sp, dp; + png_uint_32 i; + png_uint_32 row_width = row_info->width; +@@ -476,15 +447,17 @@ png_do_write_invert_alpha(png_row_infop row_info, png_bytep row) + */ + sp+=6; dp = sp; + *(dp++) = (png_byte)(255 - *(sp++)); +- *(dp++) = (png_byte)(255 - *(sp++)); ++ *dp = (png_byte)(255 - *(sp++)); + } + } ++#endif /* WRITE_16BIT */ + } ++ + else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA) + { +- /* This inverts the alpha channel in GA */ + if (row_info->bit_depth == 8) + { ++ /* This inverts the alpha channel in GA */ + png_bytep sp, dp; + png_uint_32 i; + png_uint_32 row_width = row_info->width; +@@ -495,9 +468,11 @@ png_do_write_invert_alpha(png_row_infop row_info, png_bytep row) + *(dp++) = (png_byte)(255 - *(sp++)); + } + } +- /* This inverts the alpha channel in GGAA */ ++ ++#ifdef PNG_WRITE_16BIT_SUPPORTED + else + { ++ /* This inverts the alpha channel in GGAA */ + png_bytep sp, dp; + png_uint_32 i; + png_uint_32 row_width = row_info->width; +@@ -510,73 +485,91 @@ png_do_write_invert_alpha(png_row_infop row_info, png_bytep row) + */ + sp+=2; dp = sp; + *(dp++) = (png_byte)(255 - *(sp++)); +- *(dp++) = (png_byte)(255 - *(sp++)); ++ *dp = (png_byte)(255 - *(sp++)); + } + } ++#endif /* WRITE_16BIT */ + } + } + } + #endif + +-#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 ( +-#ifdef PNG_USELESS_TESTS_SUPPORTED +- row != NULL && row_info != NULL && ++ if (png_ptr == NULL) ++ return; ++ ++#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 */ ++ /* 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 +- (row_info->color_type & PNG_COLOR_MASK_COLOR)) +- { +- int bytes_per_pixel; +- png_uint_32 row_width = row_info->width; +- if (row_info->bit_depth == 8) +- { +- png_bytep rp; +- png_uint_32 i; + +- if (row_info->color_type == PNG_COLOR_TYPE_RGB) +- bytes_per_pixel = 3; +- else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA) +- bytes_per_pixel = 4; +- else +- return; ++#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 + +- for (i = 0, rp = row; i < row_width; i++, rp += bytes_per_pixel) +- { +- *(rp) = (png_byte)((*rp - *(rp+1))&0xff); +- *(rp+2) = (png_byte)((*(rp+2) - *(rp+1))&0xff); +- } +- } +- else if (row_info->bit_depth == 16) +- { +- png_bytep rp; +- png_uint_32 i; ++#ifdef PNG_WRITE_PACKSWAP_SUPPORTED ++ if ((png_ptr->transformations & PNG_PACKSWAP) != 0) ++ png_do_packswap(row_info, png_ptr->row_buf + 1); ++#endif + +- 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; ++#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 + +- 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); +- } +- } +- } ++#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 ++ ++#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 ++ ++#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 ++ ++#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 ++ ++#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 */ +diff --git a/com32/lib/libpng/pngwutil.c b/com32/lib/libpng/pngwutil.c +index c75f53eb..16345e4c 100644 +--- a/com32/lib/libpng/pngwutil.c ++++ b/com32/lib/libpng/pngwutil.c +@@ -1,21 +1,21 @@ + + /* pngwutil.c - utilities to write a PNG file + * +- * Last changed in libpng 1.2.43 [February 25, 2010] +- * Copyright (c) 1998-2010 Glenn Randers-Pehrson +- * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) +- * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) ++ * Copyright (c) 2018 Cosmin Truta ++ * Copyright (c) 1998-2002,2004,2006-2018 Glenn Randers-Pehrson ++ * Copyright (c) 1996-1997 Andreas Dilger ++ * Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc. + * + * This code is released under the libpng license. + * For conditions of distribution and use, see the disclaimer + * and license in png.h + */ + +-#define PNG_INTERNAL +-#define PNG_NO_PEDANTIC_WARNINGS +-#include "png.h" ++#include "pngpriv.h" ++ + #ifdef PNG_WRITE_SUPPORTED + ++#ifdef PNG_WRITE_INT_FUNCTIONS_SUPPORTED + /* Place a 32-bit number into a buffer in PNG byte order. We work + * with unsigned numbers for convenience, although one supported + * ancillary chunk uses signed (two's complement) numbers. +@@ -23,23 +23,10 @@ + void PNGAPI + png_save_uint_32(png_bytep buf, png_uint_32 i) + { +- buf[0] = (png_byte)((i >> 24) & 0xff); +- buf[1] = (png_byte)((i >> 16) & 0xff); +- buf[2] = (png_byte)((i >> 8) & 0xff); +- buf[3] = (png_byte)(i & 0xff); +-} +- +-/* The png_save_int_32 function assumes integers are stored in two's +- * complement format. If this isn't the case, then this routine needs to +- * be modified to write data in two's complement format. +- */ +-void PNGAPI +-png_save_int_32(png_bytep buf, png_int_32 i) +-{ +- buf[0] = (png_byte)((i >> 24) & 0xff); +- buf[1] = (png_byte)((i >> 16) & 0xff); +- buf[2] = (png_byte)((i >> 8) & 0xff); +- buf[3] = (png_byte)(i & 0xff); ++ buf[0] = (png_byte)((i >> 24) & 0xffU); ++ buf[1] = (png_byte)((i >> 16) & 0xffU); ++ buf[2] = (png_byte)((i >> 8) & 0xffU); ++ buf[3] = (png_byte)( i & 0xffU); + } + + /* Place a 16-bit number into a buffer in PNG byte order. +@@ -49,9 +36,10 @@ png_save_int_32(png_bytep buf, png_int_32 i) + void PNGAPI + png_save_uint_16(png_bytep buf, unsigned int i) + { +- buf[0] = (png_byte)((i >> 8) & 0xff); +- buf[1] = (png_byte)(i & 0xff); ++ buf[0] = (png_byte)((i >> 8) & 0xffU); ++ buf[1] = (png_byte)( i & 0xffU); + } ++#endif + + /* Simple function to write the signature. If we have already written + * the magic bytes of the signature, or more likely, the PNG stream is +@@ -59,346 +47,634 @@ png_save_uint_16(png_bytep buf, unsigned int i) + * we should call png_set_sig_bytes() to tell libpng how many of the + * bytes have already been written. + */ +-void /* PRIVATE */ +-png_write_sig(png_structp png_ptr) ++void PNGAPI ++png_write_sig(png_structrp png_ptr) + { + png_byte png_signature[8] = {137, 80, 78, 71, 13, 10, 26, 10}; + ++#ifdef PNG_IO_STATE_SUPPORTED ++ /* Inform the I/O callback that the signature is being written */ ++ png_ptr->io_state = PNG_IO_WRITING | PNG_IO_SIGNATURE; ++#endif ++ + /* Write the rest of the 8 byte signature */ + png_write_data(png_ptr, &png_signature[png_ptr->sig_bytes], +- (png_size_t)(8 - png_ptr->sig_bytes)); ++ (size_t)(8 - png_ptr->sig_bytes)); ++ + if (png_ptr->sig_bytes < 3) + png_ptr->mode |= PNG_HAVE_PNG_SIGNATURE; + } + +-/* Write a PNG chunk all at once. The type is an array of ASCII characters +- * representing the chunk name. The array must be at least 4 bytes in +- * length, and does not need to be null terminated. To be safe, pass the +- * pre-defined chunk names here, and if you need a new one, define it +- * where the others are defined. The length is the length of the data. +- * All the data must be present. If that is not possible, use the +- * png_write_chunk_start(), png_write_chunk_data(), and png_write_chunk_end() +- * functions instead. +- */ +-void PNGAPI +-png_write_chunk(png_structp png_ptr, png_bytep chunk_name, +- png_bytep data, png_size_t length) +-{ +- if (png_ptr == NULL) +- return; +- png_write_chunk_start(png_ptr, chunk_name, (png_uint_32)length); +- png_write_chunk_data(png_ptr, data, (png_size_t)length); +- png_write_chunk_end(png_ptr); +-} +- + /* Write the start of a PNG chunk. The type is the chunk type. + * The total_length is the sum of the lengths of all the data you will be + * passing in png_write_chunk_data(). + */ +-void PNGAPI +-png_write_chunk_start(png_structp png_ptr, png_bytep chunk_name, +- png_uint_32 length) ++static void ++png_write_chunk_header(png_structrp png_ptr, png_uint_32 chunk_name, ++ png_uint_32 length) + { + png_byte buf[8]; + +- png_debug2(0, "Writing %s chunk, length = %lu", chunk_name, +- (unsigned long)length); ++#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_memcpy(buf + 4, chunk_name, 4); +- png_write_data(png_ptr, buf, (png_size_t)8); ++ 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_memcpy(png_ptr->chunk_name, chunk_name, 4); ++ 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, chunk_name, (png_size_t)4); ++ ++ 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_start(). ++/* 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_start(). ++ * given to png_write_chunk_header(). + */ + void PNGAPI +-png_write_chunk_data(png_structp png_ptr, png_bytep data, png_size_t length) ++png_write_chunk_data(png_structrp png_ptr, png_const_bytep data, size_t length) + { + /* Write the data, and run the CRC over it */ + if (png_ptr == NULL) + return; ++ + if (data != NULL && length > 0) + { + png_write_data(png_ptr, data, length); ++ + /* Update the CRC after writing the data, +- * in case that the user I/O routine alters it. ++ * in case the user I/O routine alters it. + */ + png_calculate_crc(png_ptr, data, length); + } + } + +-/* Finish a chunk started with png_write_chunk_start(). */ ++/* Finish a chunk started with png_write_chunk_header(). */ + void PNGAPI +-png_write_chunk_end(png_structp png_ptr) ++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); ++ png_write_data(png_ptr, buf, 4); + } + +-#if defined(PNG_WRITE_TEXT_SUPPORTED) || defined(PNG_WRITE_iCCP_SUPPORTED) +-/* This pair of functions encapsulates the operation of (a) compressing a +- * text string, and (b) issuing it later as a series of chunk data writes. +- * The compression_state structure is shared context for these functions +- * set up by the caller in order to make the whole mess thread-safe. ++/* Write a PNG chunk all at once. The type is an array of ASCII characters ++ * representing the chunk name. The array must be at least 4 bytes in ++ * length, and does not need to be null terminated. To be safe, pass the ++ * pre-defined chunk names here, and if you need a new one, define it ++ * where the others are defined. The length is the length of the data. ++ * All the data must be present. If that is not possible, use the ++ * png_write_chunk_start(), png_write_chunk_data(), and png_write_chunk_end() ++ * functions instead. + */ +- +-typedef struct ++static void ++png_write_complete_chunk(png_structrp png_ptr, png_uint_32 chunk_name, ++ png_const_bytep data, size_t length) + { +- char *input; /* The uncompressed input data */ +- int input_len; /* Its length */ +- int num_output_ptr; /* Number of output pointers used */ +- int max_output_ptr; /* Size of output_ptr */ +- png_charpp output_ptr; /* Array of pointers to output */ +-} compression_state; ++ if (png_ptr == NULL) ++ return; ++ ++ /* 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"); + +-/* Compress given text into storage in the png_ptr structure */ +-static int /* PRIVATE */ +-png_text_compress(png_structp png_ptr, +- png_charp text, png_size_t text_len, int compression, +- compression_state *comp) ++ 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); ++} ++ ++/* 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, size_t length) + { +- int ret; ++ png_write_complete_chunk(png_ptr, PNG_CHUNK_FROM_STRING(chunk_string), data, ++ length); ++} + +- comp->num_output_ptr = 0; +- comp->max_output_ptr = 0; +- comp->output_ptr = NULL; +- comp->input = NULL; +- comp->input_len = 0; ++/* 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.) ++ */ ++static png_alloc_size_t ++png_image_size(png_structrp png_ptr) ++{ ++ /* 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_uint_32 h = png_ptr->height; + +- /* We may just want to pass the text right through */ +- if (compression == PNG_TEXT_COMPRESSION_NONE) ++ if (png_ptr->rowbytes < 32768 && h < 32768) + { +- comp->input = text; +- comp->input_len = text_len; +- return((int)text_len); ++ 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; + } + +- if (compression >= PNG_TEXT_COMPRESSION_LAST) ++ 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.) ++ */ ++static void ++optimize_cmf(png_bytep data, png_alloc_size_t data_size) ++{ ++ /* 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 */ + { +-#if defined(PNG_STDIO_SUPPORTED) && !defined(_WIN32_WCE) +- char msg[50]; +- png_snprintf(msg, 50, "Unknown compression type %d", compression); +- png_warning(png_ptr, msg); +-#else +- png_warning(png_ptr, "Unknown compression type"); +-#endif ++ 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; ++ } ++ } + } ++} ++#endif /* WRITE_OPTIMIZE_CMF */ + +- /* 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). +- */ ++/* 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) ++{ ++ 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 " 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 ++#if PNG_RELEASE_BUILD ++ 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; ++ } + +- /* Set up the compression buffers */ +- png_ptr->zstream.avail_in = (uInt)text_len; +- png_ptr->zstream.next_in = (Bytef *)text; +- png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size; +- png_ptr->zstream.next_out = (Bytef *)png_ptr->zbuf; ++ png_ptr->zowner = 0; ++#else ++ png_error(png_ptr, msg); ++#endif ++ } + +- /* 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) ++ 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) + { +- /* Error */ +- if (png_ptr->zstream.msg != NULL) +- png_error(png_ptr, png_ptr->zstream.msg); ++ 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 +- png_error(png_ptr, "zlib error"); ++ strategy = PNG_Z_DEFAULT_NOFILTER_STRATEGY; + } +- /* Check to see if we need more room */ +- if (!(png_ptr->zstream.avail_out)) ++ ++ else + { +- /* Make sure the output array has room */ +- if (comp->num_output_ptr >= comp->max_output_ptr) +- { +- int old_max; ++#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 ++ } + +- old_max = comp->max_output_ptr; +- comp->max_output_ptr = comp->num_output_ptr + 4; +- if (comp->output_ptr != NULL) +- { +- png_charpp old_ptr; +- +- old_ptr = comp->output_ptr; +- comp->output_ptr = (png_charpp)png_malloc(png_ptr, +- (png_uint_32) +- (comp->max_output_ptr * png_sizeof(png_charpp))); +- png_memcpy(comp->output_ptr, old_ptr, old_max +- * png_sizeof(png_charp)); +- png_free(png_ptr, old_ptr); +- } +- else +- comp->output_ptr = (png_charpp)png_malloc(png_ptr, +- (png_uint_32) +- (comp->max_output_ptr * png_sizeof(png_charp))); ++ /* 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) ++ { ++ half_window_size >>= 1; ++ --windowBits; + } ++ } ++ ++ /* 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)"); + +- /* Save the data */ +- comp->output_ptr[comp->num_output_ptr] = +- (png_charp)png_malloc(png_ptr, +- (png_uint_32)png_ptr->zbuf_size); +- png_memcpy(comp->output_ptr[comp->num_output_ptr], png_ptr->zbuf, +- png_ptr->zbuf_size); +- comp->num_output_ptr++; +- +- /* and reset the buffer */ +- png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size; +- png_ptr->zstream.next_out = png_ptr->zbuf; ++ png_ptr->flags &= ~PNG_FLAG_ZSTREAM_INITIALIZED; + } +- /* 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); ++ /* 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 ++ * do 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; ++ } ++} ++ ++/* Clean up (or trim) a linked list of compression buffers. */ ++void /* PRIVATE */ ++png_free_buffer_list(png_structrp png_ptr, png_compression_bufferp *listp) ++{ ++ png_compression_bufferp list = *listp; ++ ++ if (list != NULL) ++ { ++ *listp = NULL; ++ ++ do ++ { ++ png_compression_bufferp next = list->next; ++ ++ png_free(png_ptr, list); ++ list = next; ++ } ++ while (list != NULL); ++ } ++} ++ ++#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 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_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; ++ ++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; ++ ++ /* 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. ++ */ ++ { ++ 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 + { +- /* Check to see if we need more room */ +- if (!(png_ptr->zstream.avail_out)) ++ 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) + { +- /* Check to make sure our output array has room */ +- if (comp->num_output_ptr >= comp->max_output_ptr) ++ 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) + { +- int old_max; ++ next = png_voidcast(png_compression_bufferp, png_malloc_base ++ (png_ptr, PNG_COMPRESSION_BUFFER_SIZE(png_ptr))); + +- old_max = comp->max_output_ptr; +- comp->max_output_ptr = comp->num_output_ptr + 4; +- if (comp->output_ptr != NULL) ++ if (next == NULL) + { +- png_charpp old_ptr; +- +- old_ptr = comp->output_ptr; +- /* This could be optimized to realloc() */ +- comp->output_ptr = (png_charpp)png_malloc(png_ptr, +- (png_uint_32)(comp->max_output_ptr * +- png_sizeof(png_charp))); +- png_memcpy(comp->output_ptr, old_ptr, +- old_max * png_sizeof(png_charp)); +- png_free(png_ptr, old_ptr); ++ ret = Z_MEM_ERROR; ++ break; + } +- else +- comp->output_ptr = (png_charpp)png_malloc(png_ptr, +- (png_uint_32)(comp->max_output_ptr * +- png_sizeof(png_charp))); ++ ++ /* Link in this buffer (so that it will be freed later) */ ++ next->next = NULL; ++ *end = next; + } + +- /* Save the data */ +- comp->output_ptr[comp->num_output_ptr] = +- (png_charp)png_malloc(png_ptr, +- (png_uint_32)png_ptr->zbuf_size); +- png_memcpy(comp->output_ptr[comp->num_output_ptr], png_ptr->zbuf, +- png_ptr->zbuf_size); +- comp->num_output_ptr++; +- +- /* and reset the buffer pointers */ +- png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size; +- png_ptr->zstream.next_out = png_ptr->zbuf; ++ 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 */ + } +- else if (ret != Z_STREAM_END) ++ 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) + { +- /* 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"); ++ png_ptr->zstream.msg = PNGZ_MSG_CAST("compressed data too long"); ++ ret = Z_MEM_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; ++ 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; ++ } + +- return((int)text_len); ++ else ++ return ret; ++ } + } + + /* Ship the compressed text out via chunk writes */ +-static void /* PRIVATE */ +-png_write_compressed_data_out(png_structp png_ptr, compression_state *comp) ++static void ++png_write_compressed_data_out(png_structrp png_ptr, compression_state *comp) + { +- int i; ++ 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; + +- /* Handle the no-compression case */ +- if (comp->input) ++ for (;;) + { +- png_write_chunk_data(png_ptr, (png_bytep)comp->input, +- (png_size_t)comp->input_len); +- return; +- } ++ if (avail > output_len) ++ avail = output_len; + +- /* Write saved output buffers, if any */ +- for (i = 0; i < comp->num_output_ptr; i++) +- { +- png_write_chunk_data(png_ptr, (png_bytep)comp->output_ptr[i], +- (png_size_t)png_ptr->zbuf_size); +- png_free(png_ptr, comp->output_ptr[i]); +- comp->output_ptr[i]=NULL; ++ 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; + } +- if (comp->max_output_ptr != 0) +- png_free(png_ptr, comp->output_ptr); +- comp->output_ptr=NULL; +- /* Write anything left in zbuf */ +- if (png_ptr->zstream.avail_out < (png_uint_32)png_ptr->zbuf_size) +- png_write_chunk_data(png_ptr, png_ptr->zbuf, +- (png_size_t)(png_ptr->zbuf_size - png_ptr->zstream.avail_out)); + +- /* Reset zlib for another zTXt/iTXt or image data */ +- deflateReset(&png_ptr->zstream); +- png_ptr->zstream.data_type = Z_BINARY; ++ /* 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 ++#endif /* WRITE_COMPRESSED_TEXT */ + + /* Write the IHDR chunk, and update the png_struct with the necessary + * information. Note that the rest of this code depends upon this + * information being correct. + */ + void /* PRIVATE */ +-png_write_IHDR(png_structp png_ptr, png_uint_32 width, png_uint_32 height, +- int bit_depth, int color_type, int compression_type, int filter_type, +- int interlace_type) ++png_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) + { +-#ifdef PNG_USE_LOCAL_ARRAYS +- PNG_IHDR; +-#endif +- int ret; +- + png_byte buf[13]; /* Buffer to store the IHDR info */ ++ int is_invalid_depth; + + png_debug(1, "in png_write_IHDR"); + +@@ -412,36 +688,65 @@ png_write_IHDR(png_structp png_ptr, png_uint_32 width, png_uint_32 height, + case 2: + case 4: + case 8: +- case 16: png_ptr->channels = 1; break; +- default: png_error(png_ptr, +- "Invalid bit depth for grayscale image"); ++#ifdef PNG_WRITE_16BIT_SUPPORTED ++ case 16: ++#endif ++ png_ptr->channels = 1; break; ++ ++ default: ++ png_error(png_ptr, ++ "Invalid bit depth for grayscale image"); + } + break; ++ + case PNG_COLOR_TYPE_RGB: +- if (bit_depth != 8 && bit_depth != 16) ++ is_invalid_depth = (bit_depth != 8); ++#ifdef PNG_WRITE_16BIT_SUPPORTED ++ is_invalid_depth = (is_invalid_depth && bit_depth != 16); ++#endif ++ if (is_invalid_depth) + png_error(png_ptr, "Invalid bit depth for RGB image"); ++ + png_ptr->channels = 3; + break; ++ + case PNG_COLOR_TYPE_PALETTE: + switch (bit_depth) + { + case 1: + case 2: + case 4: +- case 8: png_ptr->channels = 1; break; +- default: png_error(png_ptr, "Invalid bit depth for paletted image"); ++ case 8: ++ png_ptr->channels = 1; ++ break; ++ ++ default: ++ png_error(png_ptr, "Invalid bit depth for paletted image"); + } + break; ++ + case PNG_COLOR_TYPE_GRAY_ALPHA: +- if (bit_depth != 8 && bit_depth != 16) ++ is_invalid_depth = (bit_depth != 8); ++#ifdef PNG_WRITE_16BIT_SUPPORTED ++ is_invalid_depth = (is_invalid_depth && bit_depth != 16); ++#endif ++ if (is_invalid_depth) + png_error(png_ptr, "Invalid bit depth for grayscale+alpha image"); ++ + png_ptr->channels = 2; + break; ++ + case PNG_COLOR_TYPE_RGB_ALPHA: +- if (bit_depth != 8 && bit_depth != 16) ++ is_invalid_depth = (bit_depth != 8); ++#ifdef PNG_WRITE_16BIT_SUPPORTED ++ is_invalid_depth = (is_invalid_depth && bit_depth != 16); ++#endif ++ if (is_invalid_depth) + png_error(png_ptr, "Invalid bit depth for RGBA image"); ++ + png_ptr->channels = 4; + break; ++ + default: + png_error(png_ptr, "Invalid image color type specified"); + } +@@ -463,13 +768,13 @@ png_write_IHDR(png_structp png_ptr, png_uint_32 width, png_uint_32 height, + */ + if ( + #ifdef PNG_MNG_FEATURES_SUPPORTED +- !((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) && +- ((png_ptr->mode&PNG_HAVE_PNG_SIGNATURE) == 0) && +- (color_type == PNG_COLOR_TYPE_RGB || +- color_type == PNG_COLOR_TYPE_RGB_ALPHA) && +- (filter_type == PNG_INTRAPIXEL_DIFFERENCING)) && ++ !((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)) && + #endif +- filter_type != PNG_FILTER_TYPE_BASE) ++ filter_type != PNG_FILTER_TYPE_BASE) + { + png_warning(png_ptr, "Invalid filter type specified"); + filter_type = PNG_FILTER_TYPE_BASE; +@@ -477,7 +782,7 @@ png_write_IHDR(png_structp png_ptr, png_uint_32 width, png_uint_32 height, + + #ifdef PNG_WRITE_INTERLACING_SUPPORTED + if (interlace_type != PNG_INTERLACE_NONE && +- interlace_type != PNG_INTERLACE_ADAM7) ++ interlace_type != PNG_INTERLACE_ADAM7) + { + png_warning(png_ptr, "Invalid interlace type specified"); + interlace_type = PNG_INTERLACE_ADAM7; +@@ -486,7 +791,7 @@ png_write_IHDR(png_structp png_ptr, png_uint_32 width, png_uint_32 height, + interlace_type=PNG_INTERLACE_NONE; + #endif + +- /* Save the relevent information */ ++ /* Save the relevant information */ + png_ptr->bit_depth = (png_byte)bit_depth; + png_ptr->color_type = (png_byte)color_type; + png_ptr->interlaced = (png_byte)interlace_type; +@@ -514,55 +819,19 @@ png_write_IHDR(png_structp png_ptr, png_uint_32 width, png_uint_32 height, + buf[12] = (png_byte)interlace_type; + + /* Write the chunk */ +- png_write_chunk(png_ptr, (png_bytep)png_IHDR, buf, (png_size_t)13); ++ png_write_complete_chunk(png_ptr, png_IHDR, buf, 13); + +- /* Initialize zlib with PNG info */ +- png_ptr->zstream.zalloc = png_zalloc; +- png_ptr->zstream.zfree = png_zfree; +- png_ptr->zstream.opaque = (voidpf)png_ptr; +- if (!(png_ptr->do_filter)) ++ if ((png_ptr->do_filter) == PNG_NO_FILTERS) + { + if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE || +- png_ptr->bit_depth < 8) ++ png_ptr->bit_depth < 8) + png_ptr->do_filter = PNG_FILTER_NONE; ++ + else + png_ptr->do_filter = PNG_ALL_FILTERS; + } +- if (!(png_ptr->flags & PNG_FLAG_ZLIB_CUSTOM_STRATEGY)) +- { +- if (png_ptr->do_filter != PNG_FILTER_NONE) +- png_ptr->zlib_strategy = Z_FILTERED; +- else +- png_ptr->zlib_strategy = Z_DEFAULT_STRATEGY; +- } +- if (!(png_ptr->flags & PNG_FLAG_ZLIB_CUSTOM_LEVEL)) +- png_ptr->zlib_level = Z_DEFAULT_COMPRESSION; +- if (!(png_ptr->flags & PNG_FLAG_ZLIB_CUSTOM_MEM_LEVEL)) +- png_ptr->zlib_mem_level = 8; +- if (!(png_ptr->flags & PNG_FLAG_ZLIB_CUSTOM_WINDOW_BITS)) +- png_ptr->zlib_window_bits = 15; +- if (!(png_ptr->flags & PNG_FLAG_ZLIB_CUSTOM_METHOD)) +- png_ptr->zlib_method = 8; +- ret = deflateInit2(&png_ptr->zstream, png_ptr->zlib_level, +- png_ptr->zlib_method, png_ptr->zlib_window_bits, +- png_ptr->zlib_mem_level, png_ptr->zlib_strategy); +- if (ret != Z_OK) +- { +- if (ret == Z_VERSION_ERROR) png_error(png_ptr, +- "zlib failed to initialize compressor -- version error"); +- if (ret == Z_STREAM_ERROR) png_error(png_ptr, +- "zlib failed to initialize compressor -- stream error"); +- if (ret == Z_MEM_ERROR) png_error(png_ptr, +- "zlib failed to initialize compressor -- mem error"); +- png_error(png_ptr, "zlib failed to initialize compressor"); +- } +- png_ptr->zstream.next_out = png_ptr->zbuf; +- png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size; +- /* libpng is not interested in zstream.data_type */ +- /* Set it to a predefined value, to avoid its evaluation inside zlib */ +- png_ptr->zstream.data_type = Z_BINARY; +- +- png_ptr->mode = PNG_HAVE_IHDR; ++ ++ png_ptr->mode = PNG_HAVE_IHDR; /* not READY_FOR_ZTXT */ + } + + /* Write the palette. We are careful not to trust png_color to be in the +@@ -570,293 +839,350 @@ png_write_IHDR(png_structp png_ptr, png_uint_32 width, png_uint_32 height, + * structure. + */ + void /* PRIVATE */ +-png_write_PLTE(png_structp png_ptr, png_colorp palette, png_uint_32 num_pal) ++png_write_PLTE(png_structrp png_ptr, png_const_colorp palette, ++ png_uint_32 num_pal) + { +-#ifdef PNG_USE_LOCAL_ARRAYS +- PNG_PLTE; +-#endif +- png_uint_32 i; +- png_colorp pal_ptr; ++ png_uint_32 max_palette_length, i; ++ png_const_colorp pal_ptr; + png_byte buf[3]; + + png_debug(1, "in png_write_PLTE"); + ++ max_palette_length = (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE) ? ++ (1 << png_ptr->bit_depth) : PNG_MAX_PALETTE_LENGTH; ++ + 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) ++ num_pal == 0) || num_pal > max_palette_length) + { +- if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE) +- { +- png_error(png_ptr, "Invalid number of colors in palette"); +- } +- else +- { +- png_warning(png_ptr, "Invalid number of colors in palette"); +- return; +- } ++ if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE) ++ { ++ png_error(png_ptr, "Invalid number of colors in palette"); ++ } ++ ++ else ++ { ++ png_warning(png_ptr, "Invalid number of colors in palette"); ++ return; ++ } + } + +- if (!(png_ptr->color_type&PNG_COLOR_MASK_COLOR)) ++ if ((png_ptr->color_type & PNG_COLOR_MASK_COLOR) == 0) + { + png_warning(png_ptr, +- "Ignoring request to write a PLTE chunk in grayscale PNG"); ++ "Ignoring request to write a PLTE chunk in grayscale PNG"); ++ + return; + } + + png_ptr->num_palette = (png_uint_16)num_pal; + png_debug1(3, "num_palette = %d", png_ptr->num_palette); + +- png_write_chunk_start(png_ptr, (png_bytep)png_PLTE, +- (png_uint_32)(num_pal * 3)); ++ 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++) + { + buf[0] = pal_ptr->red; + buf[1] = pal_ptr->green; + buf[2] = pal_ptr->blue; +- png_write_chunk_data(png_ptr, buf, (png_size_t)3); ++ png_write_chunk_data(png_ptr, buf, 3); + } ++ + #else + /* This is a little slower but some buggy compilers need to do this + * instead + */ + pal_ptr=palette; ++ + for (i = 0; i < num_pal; i++) + { + buf[0] = pal_ptr[i].red; + buf[1] = pal_ptr[i].green; + buf[2] = pal_ptr[i].blue; +- png_write_chunk_data(png_ptr, buf, (png_size_t)3); ++ png_write_chunk_data(png_ptr, buf, 3); + } ++ + #endif + png_write_chunk_end(png_ptr); + 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) + { +-#ifdef PNG_USE_LOCAL_ARRAYS +- PNG_IDAT; +-#endif ++ 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; ++ } + +- png_debug(1, "in png_write_IDAT"); ++ 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; ++ } + +- /* Optimize the CMF field in the zlib stream. */ +- /* This hack of the zlib stream is compliant to the stream specification. */ +- if (!(png_ptr->mode & PNG_HAVE_IDAT) && +- png_ptr->compression_type == PNG_COMPRESSION_TYPE_BASE) ++ /* 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 (;;) + { +- unsigned int z_cmf = data[0]; /* zlib compression method and flags */ +- if ((z_cmf & 0x0f) == 8 && (z_cmf & 0xf0) <= 0x70) ++ 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) == 0 && ++ png_ptr->compression_type == PNG_COMPRESSION_TYPE_BASE) ++ optimize_cmf(data, png_image_size(png_ptr)); ++#endif ++ ++ if (size > 0) ++ 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. ++ */ ++ 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) + { +- png_uint_32 uncompressed_idat_size = png_ptr->height * +- ((png_ptr->width * +- png_ptr->channels * png_ptr->bit_depth + 15) >> 3); +- unsigned int z_cinfo = z_cmf >> 4; +- unsigned int half_z_window_size = 1 << (z_cinfo + 7); +- while (uncompressed_idat_size <= half_z_window_size && +- half_z_window_size >= 256) +- { +- z_cinfo--; +- half_z_window_size >>= 1; +- } +- z_cmf = (z_cmf & 0x0f) | (z_cinfo << 4); +- if (data[0] != (png_byte)z_cmf) +- { +- data[0] = (png_byte)z_cmf; +- data[1] &= 0xe0; +- data[1] += (png_byte)(0x1f - ((z_cmf << 8) + data[1]) % 0x1f); +- } ++ 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 ++ ++ if (size > 0) ++ 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); ++ } + } +- +- png_write_chunk(png_ptr, (png_bytep)png_IDAT, data, length); +- png_ptr->mode |= PNG_HAVE_IDAT; + } + + /* Write an IEND chunk */ + void /* PRIVATE */ +-png_write_IEND(png_structp png_ptr) ++png_write_IEND(png_structrp png_ptr) + { +-#ifdef PNG_USE_LOCAL_ARRAYS +- PNG_IEND; +-#endif +- + png_debug(1, "in png_write_IEND"); + +- png_write_chunk(png_ptr, (png_bytep)png_IEND, png_bytep_NULL, +- (png_size_t)0); ++ png_write_complete_chunk(png_ptr, png_IEND, NULL, 0); + png_ptr->mode |= PNG_HAVE_IEND; + } + + #ifdef PNG_WRITE_gAMA_SUPPORTED + /* Write a gAMA chunk */ +-#ifdef PNG_FLOATING_POINT_SUPPORTED +-void /* PRIVATE */ +-png_write_gAMA(png_structp png_ptr, double file_gamma) +-{ +-#ifdef PNG_USE_LOCAL_ARRAYS +- PNG_gAMA; +-#endif +- png_uint_32 igamma; +- png_byte buf[4]; +- +- png_debug(1, "in png_write_gAMA"); +- +- /* file_gamma is saved in 1/100,000ths */ +- igamma = (png_uint_32)(file_gamma * 100000.0 + 0.5); +- png_save_uint_32(buf, igamma); +- png_write_chunk(png_ptr, (png_bytep)png_gAMA, buf, (png_size_t)4); +-} +-#endif +-#ifdef PNG_FIXED_POINT_SUPPORTED + void /* PRIVATE */ +-png_write_gAMA_fixed(png_structp png_ptr, png_fixed_point file_gamma) ++png_write_gAMA_fixed(png_structrp png_ptr, png_fixed_point file_gamma) + { +-#ifdef PNG_USE_LOCAL_ARRAYS +- PNG_gAMA; +-#endif + png_byte buf[4]; + + png_debug(1, "in png_write_gAMA"); + + /* file_gamma is saved in 1/100,000ths */ + png_save_uint_32(buf, (png_uint_32)file_gamma); +- png_write_chunk(png_ptr, (png_bytep)png_gAMA, buf, (png_size_t)4); ++ png_write_complete_chunk(png_ptr, png_gAMA, buf, 4); + } + #endif +-#endif + + #ifdef PNG_WRITE_sRGB_SUPPORTED + /* Write a sRGB chunk */ + void /* PRIVATE */ +-png_write_sRGB(png_structp png_ptr, int srgb_intent) ++png_write_sRGB(png_structrp png_ptr, int srgb_intent) + { +-#ifdef PNG_USE_LOCAL_ARRAYS +- PNG_sRGB; +-#endif + png_byte buf[1]; + + png_debug(1, "in png_write_sRGB"); + + if (srgb_intent >= PNG_sRGB_INTENT_LAST) +- png_warning(png_ptr, +- "Invalid sRGB rendering intent specified"); ++ png_warning(png_ptr, ++ "Invalid sRGB rendering intent specified"); ++ + buf[0]=(png_byte)srgb_intent; +- png_write_chunk(png_ptr, (png_bytep)png_sRGB, buf, (png_size_t)1); ++ png_write_complete_chunk(png_ptr, png_sRGB, buf, 1); + } + #endif + + #ifdef PNG_WRITE_iCCP_SUPPORTED + /* Write an iCCP chunk */ + void /* PRIVATE */ +-png_write_iCCP(png_structp png_ptr, png_charp name, int compression_type, +- png_charp profile, int profile_len) ++png_write_iCCP(png_structrp png_ptr, png_const_charp name, ++ png_const_bytep profile) + { +-#ifdef PNG_USE_LOCAL_ARRAYS +- PNG_iCCP; +-#endif +- 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; ++ /* These are all internal problems: the profile should have been checked ++ * before when it was stored. ++ */ ++ if (profile == NULL) ++ png_error(png_ptr, "No profile for iCCP chunk"); /* internal error */ + +- if (compression_type != PNG_COMPRESSION_TYPE_BASE) +- png_warning(png_ptr, "Unknown compression type in iCCP chunk"); ++ profile_len = png_get_uint_32(profile); + +- if (profile == NULL) +- profile_len = 0; ++ if (profile_len < 132) ++ png_error(png_ptr, "ICC profile too short"); + +- if (profile_len > 3) +- embedded_profile_len = +- ((*( (png_bytep)profile ))<<24) | +- ((*( (png_bytep)profile + 1))<<16) | +- ((*( (png_bytep)profile + 2))<< 8) | +- ((*( (png_bytep)profile + 3)) ); ++ 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)"); + +- if (embedded_profile_len < 0) + { +- 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_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_error(png_ptr, "Profile length does not match profile"); + } + +- if (profile_len > embedded_profile_len) +- { +- png_warning(png_ptr, +- "Truncating profile to actual length in iCCP chunk"); +- profile_len = embedded_profile_len; +- } ++ name_len = png_check_keyword(png_ptr, name, new_name); + +- if (profile_len) +- profile_len = png_text_compress(png_ptr, profile, +- (png_size_t)profile_len, PNG_COMPRESSION_TYPE_BASE, &comp); ++ 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_bytep)png_iCCP, +- (png_uint_32)(name_len + profile_len + 2)); +- new_name[name_len + 1] = 0x00; +- png_write_chunk_data(png_ptr, (png_bytep)new_name, +- (png_size_t)(name_len + 2)); ++ ++name_len; + +- if (profile_len) +- png_write_compressed_data_out(png_ptr, &comp); ++ 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_sPLT_tp spalette) ++png_write_sPLT(png_structrp png_ptr, png_const_sPLT_tp spalette) + { +-#ifdef PNG_USE_LOCAL_ARRAYS +- PNG_sPLT; +-#endif +- png_size_t name_len; +- png_charp new_name; ++ png_uint_32 name_len; ++ png_byte new_name[80]; + png_byte entrybuf[10]; +- int entry_size = (spalette->depth == 8 ? 6 : 10); +- int palette_size = entry_size * spalette->nentries; ++ size_t entry_size = (spalette->depth == 8 ? 6 : 10); ++ size_t palette_size = entry_size * (size_t)spalette->nentries; + png_sPLT_entryp ep; + #ifndef PNG_POINTER_INDEXING_SUPPORTED + int i; +@@ -864,15 +1190,18 @@ png_write_sPLT(png_structp png_ptr, png_sPLT_tp spalette) + + 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_bytep)png_sPLT, +- (png_uint_32)(name_len + 2 + palette_size)); +- png_write_chunk_data(png_ptr, (png_bytep)new_name, +- (png_size_t)(name_len + 1)); +- png_write_chunk_data(png_ptr, (png_bytep)&spalette->depth, (png_size_t)1); ++ 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, (size_t)(name_len + 1)); ++ ++ png_write_chunk_data(png_ptr, &spalette->depth, 1); + + /* Loop through each palette entry, writing appropriately */ + #ifdef PNG_POINTER_INDEXING_SUPPORTED +@@ -880,71 +1209,72 @@ png_write_sPLT(png_structp png_ptr, png_sPLT_tp spalette) + { + if (spalette->depth == 8) + { +- entrybuf[0] = (png_byte)ep->red; +- entrybuf[1] = (png_byte)ep->green; +- entrybuf[2] = (png_byte)ep->blue; +- entrybuf[3] = (png_byte)ep->alpha; +- png_save_uint_16(entrybuf + 4, ep->frequency); ++ entrybuf[0] = (png_byte)ep->red; ++ entrybuf[1] = (png_byte)ep->green; ++ entrybuf[2] = (png_byte)ep->blue; ++ entrybuf[3] = (png_byte)ep->alpha; ++ png_save_uint_16(entrybuf + 4, ep->frequency); + } ++ + else + { +- png_save_uint_16(entrybuf + 0, ep->red); +- png_save_uint_16(entrybuf + 2, ep->green); +- png_save_uint_16(entrybuf + 4, ep->blue); +- png_save_uint_16(entrybuf + 6, ep->alpha); +- png_save_uint_16(entrybuf + 8, ep->frequency); ++ png_save_uint_16(entrybuf + 0, ep->red); ++ png_save_uint_16(entrybuf + 2, ep->green); ++ png_save_uint_16(entrybuf + 4, ep->blue); ++ png_save_uint_16(entrybuf + 6, ep->alpha); ++ png_save_uint_16(entrybuf + 8, ep->frequency); + } +- png_write_chunk_data(png_ptr, entrybuf, (png_size_t)entry_size); ++ ++ png_write_chunk_data(png_ptr, entrybuf, entry_size); + } + #else + ep=spalette->entries; +- for (i=0; i>spalette->nentries; i++) ++ for (i = 0; i>spalette->nentries; i++) + { + if (spalette->depth == 8) + { +- entrybuf[0] = (png_byte)ep[i].red; +- entrybuf[1] = (png_byte)ep[i].green; +- entrybuf[2] = (png_byte)ep[i].blue; +- entrybuf[3] = (png_byte)ep[i].alpha; +- png_save_uint_16(entrybuf + 4, ep[i].frequency); ++ entrybuf[0] = (png_byte)ep[i].red; ++ entrybuf[1] = (png_byte)ep[i].green; ++ entrybuf[2] = (png_byte)ep[i].blue; ++ entrybuf[3] = (png_byte)ep[i].alpha; ++ png_save_uint_16(entrybuf + 4, ep[i].frequency); + } ++ + else + { +- png_save_uint_16(entrybuf + 0, ep[i].red); +- png_save_uint_16(entrybuf + 2, ep[i].green); +- png_save_uint_16(entrybuf + 4, ep[i].blue); +- png_save_uint_16(entrybuf + 6, ep[i].alpha); +- png_save_uint_16(entrybuf + 8, ep[i].frequency); ++ png_save_uint_16(entrybuf + 0, ep[i].red); ++ png_save_uint_16(entrybuf + 2, ep[i].green); ++ png_save_uint_16(entrybuf + 4, ep[i].blue); ++ png_save_uint_16(entrybuf + 6, ep[i].alpha); ++ png_save_uint_16(entrybuf + 8, ep[i].frequency); + } +- png_write_chunk_data(png_ptr, entrybuf, (png_size_t)entry_size); ++ ++ 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_color_8p sbit, int color_type) ++png_write_sBIT(png_structrp png_ptr, png_const_color_8p sbit, int color_type) + { +-#ifdef PNG_USE_LOCAL_ARRAYS +- PNG_sBIT; +-#endif + png_byte buf[4]; +- png_size_t size; ++ 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; + + maxbits = (png_byte)(color_type==PNG_COLOR_TYPE_PALETTE ? 8 : +- png_ptr->usr_bit_depth); ++ png_ptr->usr_bit_depth); ++ + if (sbit->red == 0 || sbit->red > maxbits || + sbit->green == 0 || sbit->green > maxbits || + sbit->blue == 0 || sbit->blue > maxbits) +@@ -952,11 +1282,13 @@ png_write_sBIT(png_structp png_ptr, png_color_8p sbit, int color_type) + png_warning(png_ptr, "Invalid sBIT depth specified"); + return; + } ++ + buf[0] = sbit->red; + buf[1] = sbit->green; + buf[2] = sbit->blue; + size = 3; + } ++ + else + { + if (sbit->gray == 0 || sbit->gray > png_ptr->usr_bit_depth) +@@ -964,121 +1296,58 @@ png_write_sBIT(png_structp png_ptr, png_color_8p sbit, int color_type) + png_warning(png_ptr, "Invalid sBIT depth specified"); + return; + } ++ + buf[0] = sbit->gray; + 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) + { + png_warning(png_ptr, "Invalid sBIT depth specified"); + return; + } ++ + buf[size++] = sbit->alpha; + } + +- png_write_chunk(png_ptr, (png_bytep)png_sBIT, buf, size); ++ png_write_complete_chunk(png_ptr, png_sBIT, buf, size); + } + #endif + + #ifdef PNG_WRITE_cHRM_SUPPORTED + /* Write the cHRM chunk */ +-#ifdef PNG_FLOATING_POINT_SUPPORTED +-void /* PRIVATE */ +-png_write_cHRM(png_structp png_ptr, double white_x, double white_y, +- double red_x, double red_y, double green_x, double green_y, +- double blue_x, double blue_y) +-{ +-#ifdef PNG_USE_LOCAL_ARRAYS +- PNG_cHRM; +-#endif +- png_byte buf[32]; +- +- png_fixed_point int_white_x, int_white_y, int_red_x, int_red_y, +- int_green_x, int_green_y, int_blue_x, int_blue_y; +- +- png_debug(1, "in png_write_cHRM"); +- +- int_white_x = (png_uint_32)(white_x * 100000.0 + 0.5); +- int_white_y = (png_uint_32)(white_y * 100000.0 + 0.5); +- int_red_x = (png_uint_32)(red_x * 100000.0 + 0.5); +- int_red_y = (png_uint_32)(red_y * 100000.0 + 0.5); +- int_green_x = (png_uint_32)(green_x * 100000.0 + 0.5); +- int_green_y = (png_uint_32)(green_y * 100000.0 + 0.5); +- int_blue_x = (png_uint_32)(blue_x * 100000.0 + 0.5); +- int_blue_y = (png_uint_32)(blue_y * 100000.0 + 0.5); +- +-#ifdef PNG_CHECK_cHRM_SUPPORTED +- if (png_check_cHRM_fixed(png_ptr, int_white_x, int_white_y, +- int_red_x, int_red_y, int_green_x, int_green_y, int_blue_x, int_blue_y)) +-#endif +- { +- /* Each value is saved in 1/100,000ths */ +- +- png_save_uint_32(buf, int_white_x); +- png_save_uint_32(buf + 4, int_white_y); +- +- png_save_uint_32(buf + 8, int_red_x); +- png_save_uint_32(buf + 12, int_red_y); +- +- png_save_uint_32(buf + 16, int_green_x); +- png_save_uint_32(buf + 20, int_green_y); +- +- png_save_uint_32(buf + 24, int_blue_x); +- png_save_uint_32(buf + 28, int_blue_y); +- +- png_write_chunk(png_ptr, (png_bytep)png_cHRM, buf, (png_size_t)32); +- } +-} +-#endif +-#ifdef PNG_FIXED_POINT_SUPPORTED + void /* PRIVATE */ +-png_write_cHRM_fixed(png_structp png_ptr, png_fixed_point white_x, +- png_fixed_point white_y, png_fixed_point red_x, png_fixed_point red_y, +- png_fixed_point green_x, png_fixed_point green_y, png_fixed_point blue_x, +- png_fixed_point blue_y) ++png_write_cHRM_fixed(png_structrp png_ptr, const png_xy *xy) + { +-#ifdef PNG_USE_LOCAL_ARRAYS +- PNG_cHRM; +-#endif + png_byte buf[32]; + + png_debug(1, "in png_write_cHRM"); + + /* Each value is saved in 1/100,000ths */ +-#ifdef PNG_CHECK_cHRM_SUPPORTED +- if (png_check_cHRM_fixed(png_ptr, white_x, white_y, red_x, red_y, +- green_x, green_y, blue_x, blue_y)) +-#endif +- { +- png_save_uint_32(buf, (png_uint_32)white_x); +- png_save_uint_32(buf + 4, (png_uint_32)white_y); ++ png_save_int_32(buf, xy->whitex); ++ png_save_int_32(buf + 4, xy->whitey); + +- png_save_uint_32(buf + 8, (png_uint_32)red_x); +- png_save_uint_32(buf + 12, (png_uint_32)red_y); ++ png_save_int_32(buf + 8, xy->redx); ++ png_save_int_32(buf + 12, xy->redy); + +- png_save_uint_32(buf + 16, (png_uint_32)green_x); +- png_save_uint_32(buf + 20, (png_uint_32)green_y); ++ png_save_int_32(buf + 16, xy->greenx); ++ png_save_int_32(buf + 20, xy->greeny); + +- png_save_uint_32(buf + 24, (png_uint_32)blue_x); +- png_save_uint_32(buf + 28, (png_uint_32)blue_y); ++ png_save_int_32(buf + 24, xy->bluex); ++ png_save_int_32(buf + 28, xy->bluey); + +- png_write_chunk(png_ptr, (png_bytep)png_cHRM, buf, (png_size_t)32); +- } ++ png_write_complete_chunk(png_ptr, png_cHRM, buf, 32); + } + #endif +-#endif + + #ifdef PNG_WRITE_tRNS_SUPPORTED + /* Write the tRNS chunk */ + void /* PRIVATE */ +-png_write_tRNS(png_structp png_ptr, png_bytep trans, png_color_16p tran, +- int num_trans, int color_type) ++png_write_tRNS(png_structrp png_ptr, png_const_bytep trans_alpha, ++ png_const_color_16p tran, int num_trans, int color_type) + { +-#ifdef PNG_USE_LOCAL_ARRAYS +- PNG_tRNS; +-#endif + png_byte buf[6]; + + png_debug(1, "in png_write_tRNS"); +@@ -1087,42 +1356,54 @@ png_write_tRNS(png_structp png_ptr, png_bytep trans, png_color_16p tran, + { + 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_bytep)png_tRNS, trans, +- (png_size_t)num_trans); ++ png_write_complete_chunk(png_ptr, png_tRNS, trans_alpha, ++ (size_t)num_trans); + } ++ + else if (color_type == PNG_COLOR_TYPE_GRAY) + { +- /* One 16 bit value */ ++ /* One 16-bit value */ + if (tran->gray >= (1 << png_ptr->bit_depth)) + { +- png_warning(png_ptr, +- "Ignoring attempt to write tRNS chunk out-of-range for bit_depth"); ++ 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_bytep)png_tRNS, buf, (png_size_t)2); ++ png_write_complete_chunk(png_ptr, png_tRNS, buf, 2); + } ++ + else if (color_type == PNG_COLOR_TYPE_RGB) + { +- /* Three 16 bit values */ ++ /* Three 16-bit values */ + png_save_uint_16(buf, tran->red); + png_save_uint_16(buf + 2, tran->green); + png_save_uint_16(buf + 4, tran->blue); +- if (png_ptr->bit_depth == 8 && (buf[0] | buf[2] | buf[4])) ++#ifdef PNG_WRITE_16BIT_SUPPORTED ++ if (png_ptr->bit_depth == 8 && (buf[0] | buf[2] | buf[4]) != 0) ++#else ++ if ((buf[0] | buf[2] | buf[4]) != 0) ++#endif + { +- png_warning(png_ptr, +- "Ignoring attempt to write 16-bit tRNS chunk when bit_depth is 8"); ++ 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_bytep)png_tRNS, buf, (png_size_t)6); ++ ++ png_write_complete_chunk(png_ptr, png_tRNS, buf, 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 +@@ -1130,11 +1411,8 @@ png_write_tRNS(png_structp png_ptr, png_bytep trans, png_color_16p tran, + #ifdef PNG_WRITE_bKGD_SUPPORTED + /* Write the background chunk */ + void /* PRIVATE */ +-png_write_bKGD(png_structp png_ptr, png_color_16p back, int color_type) ++png_write_bKGD(png_structrp png_ptr, png_const_color_16p back, int color_type) + { +-#ifdef PNG_USE_LOCAL_ARRAYS +- PNG_bKGD; +-#endif + png_byte buf[6]; + + png_debug(1, "in png_write_bKGD"); +@@ -1143,301 +1421,195 @@ png_write_bKGD(png_structp png_ptr, png_color_16p back, int color_type) + { + 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) + { + png_warning(png_ptr, "Invalid background palette index"); + return; + } ++ + buf[0] = back->index; +- png_write_chunk(png_ptr, (png_bytep)png_bKGD, buf, (png_size_t)1); ++ png_write_complete_chunk(png_ptr, png_bKGD, buf, 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); +- if (png_ptr->bit_depth == 8 && (buf[0] | buf[2] | buf[4])) ++#ifdef PNG_WRITE_16BIT_SUPPORTED ++ if (png_ptr->bit_depth == 8 && (buf[0] | buf[2] | buf[4]) != 0) ++#else ++ if ((buf[0] | buf[2] | buf[4]) != 0) ++#endif + { + png_warning(png_ptr, +- "Ignoring attempt to write 16-bit bKGD chunk when bit_depth is 8"); ++ "Ignoring attempt to write 16-bit bKGD chunk " ++ "when bit_depth is 8"); ++ + return; + } +- png_write_chunk(png_ptr, (png_bytep)png_bKGD, buf, (png_size_t)6); ++ ++ png_write_complete_chunk(png_ptr, png_bKGD, buf, 6); + } ++ + else + { + if (back->gray >= (1 << png_ptr->bit_depth)) + { + png_warning(png_ptr, +- "Ignoring attempt to write bKGD chunk out-of-range for bit_depth"); ++ "Ignoring attempt to write bKGD chunk out-of-range for bit_depth"); ++ + return; + } ++ + png_save_uint_16(buf, back->gray); +- png_write_chunk(png_ptr, (png_bytep)png_bKGD, buf, (png_size_t)2); ++ png_write_complete_chunk(png_ptr, png_bKGD, buf, 2); + } + } + #endif + +-#ifdef PNG_WRITE_hIST_SUPPORTED +-/* Write the histogram */ ++#ifdef PNG_WRITE_eXIf_SUPPORTED ++/* Write the Exif data */ + void /* PRIVATE */ +-png_write_hIST(png_structp png_ptr, png_uint_16p hist, int num_hist) ++png_write_eXIf(png_structrp png_ptr, png_bytep exif, int num_exif) + { +-#ifdef PNG_USE_LOCAL_ARRAYS +- PNG_hIST; +-#endif + int i; +- png_byte buf[3]; ++ png_byte buf[1]; + +- png_debug(1, "in png_write_hIST"); ++ png_debug(1, "in png_write_eXIf"); + +- if (num_hist > (int)png_ptr->num_palette) +- { +- png_debug2(3, "num_hist = %d, num_palette = %d", num_hist, +- png_ptr->num_palette); +- png_warning(png_ptr, "Invalid number of histogram entries specified"); +- return; +- } ++ png_write_chunk_header(png_ptr, png_eXIf, (png_uint_32)(num_exif)); + +- png_write_chunk_start(png_ptr, (png_bytep)png_hIST, +- (png_uint_32)(num_hist * 2)); +- for (i = 0; i < num_hist; i++) ++ for (i = 0; i < num_exif; i++) + { +- png_save_uint_16(buf, hist[i]); +- png_write_chunk_data(png_ptr, buf, (png_size_t)2); ++ buf[0] = exif[i]; ++ png_write_chunk_data(png_ptr, buf, 1); + } ++ + png_write_chunk_end(png_ptr); + } + #endif + +-#if defined(PNG_WRITE_TEXT_SUPPORTED) || defined(PNG_WRITE_pCAL_SUPPORTED) || \ +- defined(PNG_WRITE_iCCP_SUPPORTED) || defined(PNG_WRITE_sPLT_SUPPORTED) +-/* Check that the tEXt or zTXt keyword is valid per PNG 1.0 specification, +- * and if invalid, correct the keyword rather than discarding the entire +- * chunk. The PNG 1.0 specification requires keywords 1-79 characters in +- * length, forbids leading or trailing whitespace, multiple internal spaces, +- * and the non-break space (0x80) from ISO 8859-1. Returns keyword length. +- * +- * The new_key is allocated to hold the corrected keyword and must be freed +- * by the calling routine. This avoids problems with trying to write to +- * static keywords without having to have duplicate copies of the strings. +- */ +-png_size_t /* PRIVATE */ +-png_check_keyword(png_structp png_ptr, png_charp key, png_charpp new_key) ++#ifdef PNG_WRITE_hIST_SUPPORTED ++/* Write the histogram */ ++void /* PRIVATE */ ++png_write_hIST(png_structrp png_ptr, png_const_uint_16p hist, int num_hist) + { +- png_size_t key_len; +- png_charp kp, dp; +- int kflag; +- int kwarn=0; +- +- png_debug(1, "in png_check_keyword"); +- +- *new_key = NULL; +- +- if (key == NULL || (key_len = png_strlen(key)) == 0) +- { +- png_warning(png_ptr, "zero length keyword"); +- return ((png_size_t)0); +- } +- +- png_debug1(2, "Keyword to be checked is '%s'", key); +- +- *new_key = (png_charp)png_malloc_warn(png_ptr, (png_uint_32)(key_len + 2)); +- if (*new_key == NULL) +- { +- png_warning(png_ptr, "Out of memory while procesing keyword"); +- return ((png_size_t)0); +- } +- +- /* Replace non-printing characters with a blank and print a warning */ +- for (kp = key, dp = *new_key; *kp != '\0'; kp++, dp++) +- { +- if ((png_byte)*kp < 0x20 || +- ((png_byte)*kp > 0x7E && (png_byte)*kp < 0xA1)) +- { +-#if defined(PNG_STDIO_SUPPORTED) && !defined(_WIN32_WCE) +- char msg[40]; +- +- png_snprintf(msg, 40, +- "invalid keyword character 0x%02X", (png_byte)*kp); +- png_warning(png_ptr, msg); +-#else +- png_warning(png_ptr, "invalid character in keyword"); +-#endif +- *dp = ' '; +- } +- else +- { +- *dp = *kp; +- } +- } +- *dp = '\0'; +- +- /* Remove any trailing white space. */ +- kp = *new_key + key_len - 1; +- if (*kp == ' ') +- { +- png_warning(png_ptr, "trailing spaces removed from keyword"); ++ int i; ++ png_byte buf[3]; + +- while (*kp == ' ') +- { +- *(kp--) = '\0'; +- key_len--; +- } +- } ++ png_debug(1, "in png_write_hIST"); + +- /* Remove any leading white space. */ +- kp = *new_key; +- if (*kp == ' ') ++ if (num_hist > (int)png_ptr->num_palette) + { +- 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); ++ png_debug2(3, "num_hist = %d, num_palette = %d", num_hist, ++ png_ptr->num_palette); + +- /* 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; +- } ++ png_warning(png_ptr, "Invalid number of histogram entries specified"); ++ return; + } +- *dp = '\0'; +- if (kwarn) +- png_warning(png_ptr, "extra interior spaces removed from keyword"); + +- if (key_len == 0) +- { +- png_free(png_ptr, *new_key); +- *new_key=NULL; +- png_warning(png_ptr, "Zero length keyword"); +- } ++ png_write_chunk_header(png_ptr, png_hIST, (png_uint_32)(num_hist * 2)); + +- if (key_len > 79) ++ for (i = 0; i < num_hist; i++) + { +- png_warning(png_ptr, "keyword length must be 1 - 79 characters"); +- (*new_key)[79] = '\0'; +- key_len = 79; ++ png_save_uint_16(buf, hist[i]); ++ png_write_chunk_data(png_ptr, buf, 2); + } + +- return (key_len); ++ png_write_chunk_end(png_ptr); + } + #endif + + #ifdef PNG_WRITE_tEXt_SUPPORTED + /* Write a tEXt chunk */ + void /* PRIVATE */ +-png_write_tEXt(png_structp png_ptr, png_charp key, png_charp text, +- png_size_t text_len) ++png_write_tEXt(png_structrp png_ptr, png_const_charp key, png_const_charp text, ++ size_t text_len) + { +-#ifdef PNG_USE_LOCAL_ARRAYS +- PNG_tEXt; +-#endif +- 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_bytep)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_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_charp key, png_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) + { +-#ifdef PNG_USE_LOCAL_ARRAYS +- PNG_zTXt; +-#endif +- png_size_t key_len; +- char buf[1]; +- 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; +- } ++ if (compression != PNG_TEXT_COMPRESSION_zTXt) ++ png_error(png_ptr, "zTXt: invalid compression type"); + +- text_len = png_strlen(text); ++ 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_bytep)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); ++ png_write_chunk_data(png_ptr, new_key, key_len); + +- buf[0] = (png_byte)compression; +- /* Write compression */ +- png_write_chunk_data(png_ptr, (png_bytep)buf, (png_size_t)1); + /* Write the compressed data */ + png_write_compressed_data_out(png_ptr, &comp); + +@@ -1449,101 +1621,109 @@ png_write_zTXt(png_structp png_ptr, png_charp key, png_charp text, + #ifdef PNG_WRITE_iTXt_SUPPORTED + /* Write an iTXt chunk */ + void /* PRIVATE */ +-png_write_iTXt(png_structp png_ptr, int compression, png_charp key, +- png_charp lang, png_charp lang_key, png_charp text) ++png_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) + { +-#ifdef PNG_USE_LOCAL_ARRAYS +- PNG_iTXt; +-#endif +- png_size_t lang_len, key_len, lang_key_len, text_len; +- png_charp new_lang; +- png_charp new_key = NULL; +- png_byte cbuf[2]; ++ png_uint_32 key_len, prefix_len; ++ 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; ++ key_len = png_check_keyword(png_ptr, key, new_key); + +- if ((key_len = png_check_keyword(png_ptr, key, &new_key))==0) +- return; ++ if (key_len == 0) ++ png_error(png_ptr, "iTXt: invalid keyword"); + +- if ((lang_len = png_check_keyword(png_ptr, lang, &new_lang))==0) ++ /* 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; ++ 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, 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.) ++ */ ++ 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 +- lang_key_len = png_strlen(lang_key); ++ prefix_len = (png_uint_32)(prefix_len + lang_len); + +- if (text == NULL) +- text_len = 0; ++ if (lang_key_len > PNG_UINT_31_MAX-prefix_len) ++ prefix_len = PNG_UINT_31_MAX; + else +- text_len = png_strlen(text); ++ prefix_len = (png_uint_32)(prefix_len + lang_key_len); + +- /* Compute the compressed data; do it now for the length */ +- text_len = png_text_compress(png_ptr, text, text_len, compression-2, +- &comp); ++ 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); ++ } + +- /* Make sure we include the compression flag, the compression byte, +- * and the NULs after the key, lang, and lang_key parts */ ++ else ++ { ++ if (comp.input_len > PNG_UINT_31_MAX-prefix_len) ++ png_error(png_ptr, "iTXt: uncompressed text too long"); + +- png_write_chunk_start(png_ptr, (png_bytep)png_iTXt, +- (png_uint_32)( +- 5 /* comp byte, comp flag, terminators for key, lang and lang_key */ +- + key_len +- + lang_len +- + lang_key_len +- + text_len)); ++ /* So the string will fit in a chunk: */ ++ comp.output_len = (png_uint_32)/*SAFE*/comp.input_len; ++ } + +- /* We leave it to the application to meet PNG-1.0 requirements on the +- * contents of the text. PNG-1.0 through PNG-1.2 discourage the use of +- * any non-Latin-1 characters except for NEWLINE. ISO PNG will forbid them. +- * The NUL character is forbidden by PNG-1.0 through PNG-1.2 and ISO PNG. +- */ +- png_write_chunk_data(png_ptr, (png_bytep)new_key, +- (png_size_t)(key_len + 1)); ++ png_write_chunk_header(png_ptr, png_iTXt, comp.output_len + prefix_len); + +- /* Set the compression flag */ +- if (compression == PNG_ITXT_COMPRESSION_NONE || \ +- compression == PNG_TEXT_COMPRESSION_NONE) +- cbuf[0] = 0; +- else /* compression == PNG_ITXT_COMPRESSION_zTXt */ +- cbuf[0] = 1; +- /* Set the compression method */ +- cbuf[1] = 0; +- png_write_chunk_data(png_ptr, cbuf, (png_size_t)2); +- +- cbuf[0] = 0; +- png_write_chunk_data(png_ptr, (new_lang ? (png_bytep)new_lang : cbuf), +- (png_size_t)(lang_len + 1)); +- png_write_chunk_data(png_ptr, (lang_key ? (png_bytep)lang_key : cbuf), +- (png_size_t)(lang_key_len + 1)); +- png_write_compressed_data_out(png_ptr, &comp); ++ png_write_chunk_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.output_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, +- int unit_type) ++png_write_oFFs(png_structrp png_ptr, png_int_32 x_offset, png_int_32 y_offset, ++ int unit_type) + { +-#ifdef PNG_USE_LOCAL_ARRAYS +- PNG_oFFs; +-#endif + png_byte buf[9]; + + png_debug(1, "in png_write_oFFs"); +@@ -1555,65 +1735,67 @@ png_write_oFFs(png_structp png_ptr, png_int_32 x_offset, png_int_32 y_offset, + png_save_int_32(buf + 4, y_offset); + buf[8] = (png_byte)unit_type; + +- png_write_chunk(png_ptr, (png_bytep)png_oFFs, buf, (png_size_t)9); ++ png_write_complete_chunk(png_ptr, png_oFFs, buf, 9); + } + #endif + #ifdef PNG_WRITE_pCAL_SUPPORTED + /* Write the pCAL chunk (described in the PNG extensions document) */ + void /* PRIVATE */ +-png_write_pCAL(png_structp png_ptr, png_charp purpose, png_int_32 X0, +- png_int_32 X1, int type, int nparams, png_charp units, png_charpp params) ++png_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) + { +-#ifdef PNG_USE_LOCAL_ARRAYS +- PNG_pCAL; +-#endif +- png_size_t purpose_len, units_len, total_len; +- png_uint_32p params_len; ++ png_uint_32 purpose_len; ++ 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"); ++ 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 */ + +- purpose_len = png_check_keyword(png_ptr, purpose, &new_purpose) + 1; + png_debug1(3, "pCAL purpose length = %d", (int)purpose_len); +- units_len = png_strlen(units) + (nparams == 0 ? 0 : 1); ++ 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_uint_32)(nparams * png_sizeof(png_uint_32))); ++ params_len = (png_size_tp)png_malloc(png_ptr, ++ (png_alloc_size_t)((png_alloc_size_t)nparams * (sizeof (size_t)))); + + /* Find the length of each parameter, making sure we don't count the +- null terminator for the last parameter. */ ++ * 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]; ++ (unsigned long)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_bytep)png_pCAL, (png_uint_32)total_len); +- png_write_chunk_data(png_ptr, (png_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; + buf[9] = (png_byte)nparams; +- png_write_chunk_data(png_ptr, buf, (png_size_t)10); +- png_write_chunk_data(png_ptr, (png_bytep)units, (png_size_t)units_len); +- +- png_free(png_ptr, new_purpose); ++ png_write_chunk_data(png_ptr, buf, 10); ++ png_write_chunk_data(png_ptr, (png_const_bytep)units, (size_t)units_len); + + for (i = 0; i < nparams; i++) + { +- png_write_chunk_data(png_ptr, (png_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); +@@ -1623,62 +1805,19 @@ png_write_pCAL(png_structp png_ptr, png_charp purpose, png_int_32 X0, + + #ifdef PNG_WRITE_sCAL_SUPPORTED + /* Write the sCAL chunk */ +-#if defined(PNG_FLOATING_POINT_SUPPORTED) && defined(PNG_STDIO_SUPPORTED) +-void /* PRIVATE */ +-png_write_sCAL(png_structp png_ptr, int unit, double width, double height) +-{ +-#ifdef PNG_USE_LOCAL_ARRAYS +- PNG_sCAL; +-#endif +- char buf[64]; +- png_size_t total_len; +- +- png_debug(1, "in png_write_sCAL"); +- +- buf[0] = (char)unit; +-#ifdef _WIN32_WCE +-/* sprintf() function is not supported on WindowsCE */ +- { +- wchar_t wc_buf[32]; +- size_t wc_len; +- swprintf(wc_buf, TEXT("%12.12e"), width); +- wc_len = wcslen(wc_buf); +- WideCharToMultiByte(CP_ACP, 0, wc_buf, -1, buf + 1, wc_len, NULL, +- NULL); +- total_len = wc_len + 2; +- swprintf(wc_buf, TEXT("%12.12e"), height); +- wc_len = wcslen(wc_buf); +- WideCharToMultiByte(CP_ACP, 0, wc_buf, -1, buf + total_len, wc_len, +- NULL, NULL); +- total_len += wc_len; +- } +-#else +- png_snprintf(buf + 1, 63, "%12.12e", width); +- total_len = 1 + png_strlen(buf + 1) + 1; +- png_snprintf(buf + total_len, 64-total_len, "%12.12e", height); +- total_len += png_strlen(buf + total_len); +-#endif +- +- png_debug1(3, "sCAL total length = %u", (unsigned int)total_len); +- png_write_chunk(png_ptr, (png_bytep)png_sCAL, (png_bytep)buf, total_len); +-} +-#else +-#ifdef PNG_FIXED_POINT_SUPPORTED + void /* PRIVATE */ +-png_write_sCAL_s(png_structp png_ptr, int unit, png_charp width, +- png_charp height) ++png_write_sCAL_s(png_structrp png_ptr, int unit, png_const_charp width, ++ png_const_charp height) + { +-#ifdef PNG_USE_LOCAL_ARRAYS +- PNG_sCAL; +-#endif + png_byte buf[64]; +- png_size_t wlen, hlen, total_len; ++ 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) + { + png_warning(png_ptr, "Can't write sCAL (buffer too small)"); +@@ -1686,26 +1825,21 @@ png_write_sCAL_s(png_structp png_ptr, int unit, png_charp width, + } + + 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_bytep)png_sCAL, buf, total_len); ++ png_write_complete_chunk(png_ptr, png_sCAL, buf, total_len); + } + #endif +-#endif +-#endif + + #ifdef PNG_WRITE_pHYs_SUPPORTED + /* Write the pHYs chunk */ + void /* PRIVATE */ +-png_write_pHYs(png_structp png_ptr, png_uint_32 x_pixels_per_unit, +- png_uint_32 y_pixels_per_unit, +- int unit_type) ++png_write_pHYs(png_structrp png_ptr, png_uint_32 x_pixels_per_unit, ++ png_uint_32 y_pixels_per_unit, ++ int unit_type) + { +-#ifdef PNG_USE_LOCAL_ARRAYS +- PNG_pHYs; +-#endif + png_byte buf[9]; + + png_debug(1, "in png_write_pHYs"); +@@ -1717,7 +1851,7 @@ png_write_pHYs(png_structp png_ptr, png_uint_32 x_pixels_per_unit, + png_save_uint_32(buf + 4, y_pixels_per_unit); + buf[8] = (png_byte)unit_type; + +- png_write_chunk(png_ptr, (png_bytep)png_pHYs, buf, (png_size_t)9); ++ png_write_complete_chunk(png_ptr, png_pHYs, buf, 9); + } + #endif + +@@ -1726,11 +1860,8 @@ png_write_pHYs(png_structp png_ptr, png_uint_32 x_pixels_per_unit, + * or png_convert_from_time_t(), or fill in the structure yourself. + */ + void /* PRIVATE */ +-png_write_tIME(png_structp png_ptr, png_timep mod_time) ++png_write_tIME(png_structrp png_ptr, png_const_timep mod_time) + { +-#ifdef PNG_USE_LOCAL_ARRAYS +- PNG_tIME; +-#endif + png_byte buf[7]; + + png_debug(1, "in png_write_tIME"); +@@ -1750,130 +1881,145 @@ png_write_tIME(png_structp png_ptr, png_timep mod_time) + buf[5] = mod_time->minute; + buf[6] = mod_time->second; + +- png_write_chunk(png_ptr, (png_bytep)png_tIME, buf, (png_size_t)7); ++ png_write_complete_chunk(png_ptr, png_tIME, buf, 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 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 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 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 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; ++ ++#ifdef PNG_WRITE_FILTER_SUPPORTED ++ png_byte filters; ++#endif + + 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_uint_32)buf_size); ++ png_ptr->row_buf = png_voidcast(png_bytep, png_malloc(png_ptr, buf_size)); ++ + png_ptr->row_buf[0] = PNG_FILTER_VALUE_NONE; + + #ifdef PNG_WRITE_FILTER_SUPPORTED +- /* Set up filtering buffer, if using this filter */ +- if (png_ptr->do_filter & PNG_FILTER_SUB) +- { +- png_ptr->sub_row = (png_bytep)png_malloc(png_ptr, +- (png_uint_32)(png_ptr->rowbytes + 1)); +- png_ptr->sub_row[0] = PNG_FILTER_VALUE_SUB; +- } ++ filters = png_ptr->do_filter; ++ ++ if (png_ptr->height == 1) ++ filters &= 0xff & ~(PNG_FILTER_UP|PNG_FILTER_AVG|PNG_FILTER_PAETH); ++ ++ if (png_ptr->width == 1) ++ filters &= 0xff & ~(PNG_FILTER_SUB|PNG_FILTER_AVG|PNG_FILTER_PAETH); ++ ++ if (filters == 0) ++ filters = PNG_FILTER_NONE; + +- /* 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)) ++ png_ptr->do_filter = filters; ++ ++ if (((filters & (PNG_FILTER_SUB | PNG_FILTER_UP | PNG_FILTER_AVG | ++ PNG_FILTER_PAETH)) != 0) && png_ptr->try_row == NULL) + { +- /* Set up previous row buffer */ +- png_ptr->prev_row = (png_bytep)png_calloc(png_ptr, +- (png_uint_32)buf_size); ++ int num_filters = 0; + +- if (png_ptr->do_filter & PNG_FILTER_UP) +- { +- png_ptr->up_row = (png_bytep)png_malloc(png_ptr, +- (png_uint_32)(png_ptr->rowbytes + 1)); +- png_ptr->up_row[0] = PNG_FILTER_VALUE_UP; +- } ++ png_ptr->try_row = png_voidcast(png_bytep, png_malloc(png_ptr, buf_size)); + +- if (png_ptr->do_filter & PNG_FILTER_AVG) +- { +- png_ptr->avg_row = (png_bytep)png_malloc(png_ptr, +- (png_uint_32)(png_ptr->rowbytes + 1)); +- png_ptr->avg_row[0] = PNG_FILTER_VALUE_AVG; +- } ++ if (filters & PNG_FILTER_SUB) ++ num_filters++; + +- if (png_ptr->do_filter & PNG_FILTER_PAETH) +- { +- png_ptr->paeth_row = (png_bytep)png_malloc(png_ptr, +- (png_uint_32)(png_ptr->rowbytes + 1)); +- png_ptr->paeth_row[0] = PNG_FILTER_VALUE_PAETH; +- } ++ if (filters & PNG_FILTER_UP) ++ num_filters++; ++ ++ if (filters & PNG_FILTER_AVG) ++ num_filters++; ++ ++ if (filters & PNG_FILTER_PAETH) ++ num_filters++; ++ ++ if (num_filters > 1) ++ png_ptr->tst_row = png_voidcast(png_bytep, png_malloc(png_ptr, ++ buf_size)); + } +-#endif /* PNG_WRITE_FILTER_SUPPORTED */ ++ ++ /* We only need to keep the previous row if we are using one of the following ++ * filters. ++ */ ++ if ((filters & (PNG_FILTER_AVG | PNG_FILTER_UP | PNG_FILTER_PAETH)) != 0) ++ png_ptr->prev_row = png_voidcast(png_bytep, ++ png_calloc(png_ptr, buf_size)); ++#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]; ++ png_pass_ystart[0]) / png_pass_yinc[0]; ++ + png_ptr->usr_width = (png_ptr->width + png_pass_inc[0] - 1 - +- png_pass_start[0]) / png_pass_inc[0]; ++ png_pass_start[0]) / png_pass_inc[0]; + } ++ + else + { + png_ptr->num_rows = png_ptr->height; + png_ptr->usr_width = png_ptr->width; + } + } ++ + else + #endif + { + png_ptr->num_rows = png_ptr->height; + png_ptr->usr_width = png_ptr->width; + } +- png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size; +- png_ptr->zstream.next_out = png_ptr->zbuf; + } + + /* Internal use only. Called when finished processing a row of data. */ + void /* PRIVATE */ +-png_write_finish_row(png_structp png_ptr) ++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 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 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 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 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 */ +@@ -1885,31 +2031,37 @@ png_write_finish_row(png_structp png_ptr) + + #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++; + } ++ + else + { + /* Loop until we find a non-zero width or height pass */ + do + { + png_ptr->pass++; ++ + if (png_ptr->pass >= 7) + break; ++ + png_ptr->usr_width = (png_ptr->width + +- png_pass_inc[png_ptr->pass] - 1 - +- png_pass_start[png_ptr->pass]) / +- png_pass_inc[png_ptr->pass]; ++ png_pass_inc[png_ptr->pass] - 1 - ++ png_pass_start[png_ptr->pass]) / ++ png_pass_inc[png_ptr->pass]; ++ + png_ptr->num_rows = (png_ptr->height + +- png_pass_yinc[png_ptr->pass] - 1 - +- png_pass_ystart[png_ptr->pass]) / +- png_pass_yinc[png_ptr->pass]; +- if (png_ptr->transformations & PNG_INTERLACE) ++ png_pass_yinc[png_ptr->pass] - 1 - ++ png_pass_ystart[png_ptr->pass]) / ++ png_pass_yinc[png_ptr->pass]; ++ ++ if ((png_ptr->transformations & PNG_INTERLACE) != 0) + break; ++ + } while (png_ptr->usr_width == 0 || png_ptr->num_rows == 0); + + } +@@ -1918,9 +2070,10 @@ png_write_finish_row(png_structp png_ptr) + if (png_ptr->pass < 7) + { + if (png_ptr->prev_row != NULL) +- png_memset(png_ptr->prev_row, 0, +- (png_size_t)(PNG_ROWBYTES(png_ptr->usr_channels* +- png_ptr->usr_bit_depth, png_ptr->width)) + 1); ++ memset(png_ptr->prev_row, 0, ++ PNG_ROWBYTES(png_ptr->usr_channels * ++ png_ptr->usr_bit_depth, png_ptr->width) + 1); ++ + return; + } + } +@@ -1928,39 +2081,7 @@ png_write_finish_row(png_structp png_ptr) + + /* If we get here, we've just written the last row, so we need + to flush the compressor */ +- do +- { +- /* Tell the compressor we are done */ +- ret = deflate(&png_ptr->zstream, Z_FINISH); +- /* Check for an error */ +- if (ret == Z_OK) +- { +- /* Check to see if we need more room */ +- if (!(png_ptr->zstream.avail_out)) +- { +- png_write_IDAT(png_ptr, png_ptr->zbuf, png_ptr->zbuf_size); +- png_ptr->zstream.next_out = png_ptr->zbuf; +- png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size; +- } +- } +- else if (ret != Z_STREAM_END) +- { +- if (png_ptr->zstream.msg != NULL) +- png_error(png_ptr, png_ptr->zstream.msg); +- else +- png_error(png_ptr, "zlib error"); +- } +- } while (ret != Z_STREAM_END); +- +- /* Write any extra space */ +- if (png_ptr->zstream.avail_out < png_ptr->zbuf_size) +- { +- png_write_IDAT(png_ptr, png_ptr->zbuf, png_ptr->zbuf_size - +- png_ptr->zstream.avail_out); +- } +- +- deflateReset(&png_ptr->zstream); +- png_ptr->zstream.data_type = Z_BINARY; ++ png_compress_IDAT(png_ptr, NULL, 0, Z_FINISH); + } + + #ifdef PNG_WRITE_INTERLACING_SUPPORTED +@@ -1977,19 +2098,15 @@ png_do_write_interlace(png_row_infop row_info, png_bytep row, int pass) + /* Arrays to facilitate easy interlacing - use pass (0 - 6) as index */ + + /* Start of interlace block */ +- int png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0}; ++ static 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 const png_byte png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1}; + + png_debug(1, "in png_do_write_interlace"); + + /* We don't have to do anything on the last pass (6) */ +-#ifdef PNG_USELESS_TESTS_SUPPORTED +- if (row != NULL && row_info != NULL && pass < 6) +-#else + if (pass < 6) +-#endif + { + /* Each pixel depth is handled separately */ + switch (row_info->pixel_depth) +@@ -1998,7 +2115,7 @@ png_do_write_interlace(png_row_infop row_info, png_bytep row, int pass) + { + png_bytep sp; + png_bytep dp; +- int shift; ++ unsigned int shift; + int d; + int value; + png_uint_32 i; +@@ -2007,10 +2124,11 @@ png_do_write_interlace(png_row_infop row_info, png_bytep row, int pass) + dp = row; + d = 0; + shift = 7; ++ + for (i = png_pass_start[pass]; i < row_width; + i += png_pass_inc[pass]) + { +- sp = row + (png_size_t)(i >> 3); ++ sp = row + (size_t)(i >> 3); + value = (int)(*sp >> (7 - (int)(i & 0x07))) & 0x01; + d |= (value << shift); + +@@ -2020,19 +2138,22 @@ png_do_write_interlace(png_row_infop row_info, png_bytep row, int pass) + *dp++ = (png_byte)d; + d = 0; + } ++ + else + shift--; + + } + if (shift != 7) + *dp = (png_byte)d; ++ + break; + } ++ + case 2: + { + png_bytep sp; + png_bytep dp; +- int shift; ++ unsigned int shift; + int d; + int value; + png_uint_32 i; +@@ -2041,10 +2162,11 @@ png_do_write_interlace(png_row_infop row_info, png_bytep row, int pass) + dp = row; + shift = 6; + d = 0; ++ + for (i = png_pass_start[pass]; i < row_width; + i += png_pass_inc[pass]) + { +- sp = row + (png_size_t)(i >> 2); ++ sp = row + (size_t)(i >> 2); + value = (*sp >> ((3 - (int)(i & 0x03)) << 1)) & 0x03; + d |= (value << shift); + +@@ -2054,18 +2176,21 @@ png_do_write_interlace(png_row_infop row_info, png_bytep row, int pass) + *dp++ = (png_byte)d; + d = 0; + } ++ + else + shift -= 2; + } + if (shift != 6) +- *dp = (png_byte)d; ++ *dp = (png_byte)d; ++ + break; + } ++ + case 4: + { + png_bytep sp; + png_bytep dp; +- int shift; ++ unsigned int shift; + int d; + int value; + png_uint_32 i; +@@ -2075,9 +2200,9 @@ png_do_write_interlace(png_row_infop row_info, png_bytep row, int pass) + shift = 4; + d = 0; + for (i = png_pass_start[pass]; i < row_width; +- i += png_pass_inc[pass]) ++ i += png_pass_inc[pass]) + { +- sp = row + (png_size_t)(i >> 1); ++ sp = row + (size_t)(i >> 1); + value = (*sp >> ((1 - (int)(i & 0x01)) << 2)) & 0x0f; + d |= (value << shift); + +@@ -2087,35 +2212,41 @@ png_do_write_interlace(png_row_infop row_info, png_bytep row, int pass) + *dp++ = (png_byte)d; + d = 0; + } ++ + else + shift -= 4; + } + if (shift != 4) + *dp = (png_byte)d; ++ + break; + } ++ + default: + { + png_bytep sp; + png_bytep dp; + png_uint_32 i; + png_uint_32 row_width = row_info->width; +- png_size_t pixel_bytes; ++ size_t pixel_bytes; + + /* Start at the beginning */ + dp = row; ++ + /* Find out how many bytes each pixel takes up */ + pixel_bytes = (row_info->pixel_depth >> 3); +- /* Loop through the row, only looking at the pixels that +- matter */ ++ ++ /* Loop through the row, only looking at the pixels that matter */ + for (i = png_pass_start[pass]; i < row_width; + i += png_pass_inc[pass]) + { + /* Find out where the original pixel is */ +- sp = row + (png_size_t)i * pixel_bytes; ++ sp = row + (size_t)i * pixel_bytes; ++ + /* Move the pixel */ + if (dp != sp) +- png_memcpy(dp, sp, pixel_bytes); ++ memcpy(dp, sp, pixel_bytes); ++ + /* Next pixel */ + dp += pixel_bytes; + } +@@ -2124,688 +2255,505 @@ png_do_write_interlace(png_row_infop row_info, png_bytep row, int pass) + } + /* Set new row width */ + row_info->width = (row_info->width + +- png_pass_inc[pass] - 1 - +- png_pass_start[pass]) / +- png_pass_inc[pass]; +- row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth, +- row_info->width); ++ png_pass_inc[pass] - 1 - ++ png_pass_start[pass]) / ++ png_pass_inc[pass]; ++ ++ row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth, ++ row_info->width); + } + } + #endif + ++ + /* This filters the row, chooses which filter to use, if it has not already + * been specified by the application, and then writes the row out with the + * chosen filter. + */ +-#define PNG_MAXSUM (((png_uint_32)(-1)) >> 1) +-#define PNG_HISHIFT 10 +-#define PNG_LOMASK ((png_uint_32)0xffffL) +-#define PNG_HIMASK ((png_uint_32)(~PNG_LOMASK >> PNG_HISHIFT)) +-void /* PRIVATE */ +-png_write_find_filter(png_structp png_ptr, png_row_infop row_info) +-{ +- png_bytep best_row; +-#ifdef PNG_WRITE_FILTER_SUPPORTED +- png_bytep prev_row, row_buf; +- png_uint_32 mins, bpp; +- png_byte filter_to_do = png_ptr->do_filter; +- png_uint_32 row_bytes = row_info->rowbytes; +-#ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED +- int num_p_filters = (int)png_ptr->num_prev_filters; +-#endif +- +- png_debug(1, "in png_write_find_filter"); +- +-#ifndef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED +- if (png_ptr->row_number == 0 && filter_to_do == PNG_ALL_FILTERS) +- { +- /* These will never be selected so we need not test them. */ +- filter_to_do &= ~(PNG_FILTER_UP | PNG_FILTER_PAETH); +- } +-#endif +- +- /* Find out how many bytes offset each pixel is */ +- bpp = (row_info->pixel_depth + 7) >> 3; ++static void /* PRIVATE */ ++png_write_filtered_row(png_structrp png_ptr, png_bytep filtered_row, ++ size_t row_bytes); + +- prev_row = png_ptr->prev_row; +-#endif +- best_row = png_ptr->row_buf; + #ifdef PNG_WRITE_FILTER_SUPPORTED +- row_buf = best_row; +- mins = PNG_MAXSUM; +- +- /* The prediction method we use is to find which method provides the +- * smallest value when summing the absolute values of the distances +- * from zero, using anything >= 128 as negative numbers. This is known +- * as the "minimum sum of absolute differences" heuristic. Other +- * heuristics are the "weighted minimum sum of absolute differences" +- * (experimental and can in theory improve compression), and the "zlib +- * predictive" method (not implemented yet), which does test compressions +- * of lines using different filter methods, and then chooses the +- * (series of) filter(s) that give minimum compressed data size (VERY +- * computationally expensive). +- * +- * GRR 980525: consider also +- * (1) minimum sum of absolute differences from running average (i.e., +- * keep running sum of non-absolute differences & count of bytes) +- * [track dispersion, too? restart average if dispersion too large?] +- * (1b) minimum sum of absolute differences from sliding average, probably +- * with window size <= deflate window (usually 32K) +- * (2) minimum sum of squared differences from zero or running average +- * (i.e., ~ root-mean-square approach) +- */ ++static size_t /* PRIVATE */ ++png_setup_sub_row(png_structrp png_ptr, png_uint_32 bpp, ++ size_t row_bytes, size_t lmins) ++{ ++ png_bytep rp, dp, lp; ++ size_t i; ++ size_t sum = 0; ++ unsigned int v; + ++ png_ptr->try_row[0] = PNG_FILTER_VALUE_SUB; + +- /* 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) ++ for (i = 0, rp = png_ptr->row_buf + 1, dp = png_ptr->try_row + 1; i < bpp; ++ i++, rp++, dp++) + { +- png_bytep rp; +- png_uint_32 sum = 0; +- png_uint_32 i; +- int v; ++ v = *dp = *rp; ++#ifdef PNG_USE_ABS ++ sum += 128 - abs((int)v - 128); ++#else ++ sum += (v < 128) ? v : 256 - v; ++#endif ++ } + +- for (i = 0, rp = row_buf + 1; i < row_bytes; i++, rp++) +- { +- v = *rp; +- sum += (v < 128) ? v : 256 - v; +- } ++ for (lp = png_ptr->row_buf + 1; i < row_bytes; ++ i++, rp++, lp++, dp++) ++ { ++ v = *dp = (png_byte)(((int)*rp - (int)*lp) & 0xff); ++#ifdef PNG_USE_ABS ++ sum += 128 - abs((int)v - 128); ++#else ++ sum += (v < 128) ? v : 256 - v; ++#endif + +-#ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED +- if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED) +- { +- png_uint_32 sumhi, sumlo; +- int j; +- sumlo = sum & PNG_LOMASK; +- sumhi = (sum >> PNG_HISHIFT) & PNG_HIMASK; /* Gives us some footroom */ ++ if (sum > lmins) /* We are already worse, don't continue. */ ++ break; ++ } + +- /* Reduce the sum if we match any of the previous rows */ +- for (j = 0; j < num_p_filters; j++) +- { +- if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_NONE) +- { +- sumlo = (sumlo * png_ptr->filter_weights[j]) >> +- PNG_WEIGHT_SHIFT; +- sumhi = (sumhi * png_ptr->filter_weights[j]) >> +- PNG_WEIGHT_SHIFT; +- } +- } ++ return (sum); ++} + +- /* Factor in the cost of this filter (this is here for completeness, +- * but it makes no sense to have a "cost" for the NONE filter, as +- * it has the minimum possible computational cost - none). +- */ +- sumlo = (sumlo * png_ptr->filter_costs[PNG_FILTER_VALUE_NONE]) >> +- PNG_COST_SHIFT; +- sumhi = (sumhi * png_ptr->filter_costs[PNG_FILTER_VALUE_NONE]) >> +- PNG_COST_SHIFT; ++static void /* PRIVATE */ ++png_setup_sub_row_only(png_structrp png_ptr, png_uint_32 bpp, ++ size_t row_bytes) ++{ ++ png_bytep rp, dp, lp; ++ size_t i; + +- if (sumhi > PNG_HIMASK) +- sum = PNG_MAXSUM; +- else +- sum = (sumhi << PNG_HISHIFT) + sumlo; +- } +-#endif +- mins = sum; +- } ++ png_ptr->try_row[0] = PNG_FILTER_VALUE_SUB; + +- /* Sub filter */ +- if (filter_to_do == PNG_FILTER_SUB) +- /* It's the only filter so no testing is needed */ ++ for (i = 0, rp = png_ptr->row_buf + 1, dp = png_ptr->try_row + 1; i < bpp; ++ i++, rp++, dp++) + { +- png_bytep rp, lp, dp; +- png_uint_32 i; +- for (i = 0, rp = row_buf + 1, dp = png_ptr->sub_row + 1; i < bpp; +- i++, rp++, dp++) +- { +- *dp = *rp; +- } +- for (lp = row_buf + 1; i < row_bytes; +- i++, rp++, lp++, dp++) +- { +- *dp = (png_byte)(((int)*rp - (int)*lp) & 0xff); +- } +- best_row = png_ptr->sub_row; ++ *dp = *rp; + } + +- else if (filter_to_do & PNG_FILTER_SUB) ++ for (lp = png_ptr->row_buf + 1; i < row_bytes; ++ i++, rp++, lp++, dp++) + { +- png_bytep rp, dp, lp; +- png_uint_32 sum = 0, lmins = mins; +- png_uint_32 i; +- int v; +- +-#ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED +- /* We temporarily increase the "minimum sum" by the factor we +- * would reduce the sum of this filter, so that we can do the +- * early exit comparison without scaling the sum each time. +- */ +- if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED) +- { +- int j; +- png_uint_32 lmhi, lmlo; +- lmlo = lmins & PNG_LOMASK; +- lmhi = (lmins >> PNG_HISHIFT) & PNG_HIMASK; ++ *dp = (png_byte)(((int)*rp - (int)*lp) & 0xff); ++ } ++} + +- for (j = 0; j < num_p_filters; j++) +- { +- if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_SUB) +- { +- lmlo = (lmlo * png_ptr->inv_filter_weights[j]) >> +- PNG_WEIGHT_SHIFT; +- lmhi = (lmhi * png_ptr->inv_filter_weights[j]) >> +- PNG_WEIGHT_SHIFT; +- } +- } ++static size_t /* PRIVATE */ ++png_setup_up_row(png_structrp png_ptr, size_t row_bytes, size_t lmins) ++{ ++ png_bytep rp, dp, pp; ++ size_t i; ++ size_t sum = 0; ++ unsigned int v; + +- lmlo = (lmlo * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_SUB]) >> +- PNG_COST_SHIFT; +- lmhi = (lmhi * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_SUB]) >> +- PNG_COST_SHIFT; ++ png_ptr->try_row[0] = PNG_FILTER_VALUE_UP; + +- if (lmhi > PNG_HIMASK) +- lmins = PNG_MAXSUM; +- else +- lmins = (lmhi << PNG_HISHIFT) + lmlo; +- } ++ for (i = 0, rp = png_ptr->row_buf + 1, dp = png_ptr->try_row + 1, ++ pp = png_ptr->prev_row + 1; i < row_bytes; ++ i++, rp++, pp++, dp++) ++ { ++ v = *dp = (png_byte)(((int)*rp - (int)*pp) & 0xff); ++#ifdef PNG_USE_ABS ++ sum += 128 - abs((int)v - 128); ++#else ++ sum += (v < 128) ? v : 256 - v; + #endif + +- for (i = 0, rp = row_buf + 1, dp = png_ptr->sub_row + 1; i < bpp; +- i++, rp++, dp++) +- { +- v = *dp = *rp; ++ if (sum > lmins) /* We are already worse, don't continue. */ ++ break; ++ } + +- sum += (v < 128) ? v : 256 - v; +- } +- for (lp = row_buf + 1; i < row_bytes; +- i++, rp++, lp++, dp++) +- { +- v = *dp = (png_byte)(((int)*rp - (int)*lp) & 0xff); ++ return (sum); ++} ++static void /* PRIVATE */ ++png_setup_up_row_only(png_structrp png_ptr, size_t row_bytes) ++{ ++ png_bytep rp, dp, pp; ++ size_t i; + +- sum += (v < 128) ? v : 256 - v; ++ png_ptr->try_row[0] = PNG_FILTER_VALUE_UP; + +- if (sum > lmins) /* We are already worse, don't continue. */ +- break; +- } ++ for (i = 0, rp = png_ptr->row_buf + 1, dp = png_ptr->try_row + 1, ++ pp = png_ptr->prev_row + 1; i < row_bytes; ++ i++, rp++, pp++, dp++) ++ { ++ *dp = (png_byte)(((int)*rp - (int)*pp) & 0xff); ++ } ++} + +-#ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED +- if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED) +- { +- int j; +- png_uint_32 sumhi, sumlo; +- sumlo = sum & PNG_LOMASK; +- sumhi = (sum >> PNG_HISHIFT) & PNG_HIMASK; ++static size_t /* PRIVATE */ ++png_setup_avg_row(png_structrp png_ptr, png_uint_32 bpp, ++ size_t row_bytes, size_t lmins) ++{ ++ png_bytep rp, dp, pp, lp; ++ png_uint_32 i; ++ size_t sum = 0; ++ unsigned int v; + +- for (j = 0; j < num_p_filters; j++) +- { +- if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_SUB) +- { +- sumlo = (sumlo * png_ptr->inv_filter_weights[j]) >> +- PNG_WEIGHT_SHIFT; +- sumhi = (sumhi * png_ptr->inv_filter_weights[j]) >> +- PNG_WEIGHT_SHIFT; +- } +- } ++ png_ptr->try_row[0] = PNG_FILTER_VALUE_AVG; + +- sumlo = (sumlo * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_SUB]) >> +- PNG_COST_SHIFT; +- sumhi = (sumhi * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_SUB]) >> +- PNG_COST_SHIFT; ++ for (i = 0, rp = png_ptr->row_buf + 1, dp = png_ptr->try_row + 1, ++ pp = png_ptr->prev_row + 1; i < bpp; i++) ++ { ++ v = *dp++ = (png_byte)(((int)*rp++ - ((int)*pp++ / 2)) & 0xff); + +- if (sumhi > PNG_HIMASK) +- sum = PNG_MAXSUM; +- else +- sum = (sumhi << PNG_HISHIFT) + sumlo; +- } ++#ifdef PNG_USE_ABS ++ sum += 128 - abs((int)v - 128); ++#else ++ sum += (v < 128) ? v : 256 - v; + #endif +- +- if (sum < mins) +- { +- mins = sum; +- best_row = png_ptr->sub_row; +- } + } + +- /* Up filter */ +- if (filter_to_do == PNG_FILTER_UP) ++ for (lp = png_ptr->row_buf + 1; i < row_bytes; i++) + { +- png_bytep rp, dp, pp; +- png_uint_32 i; ++ v = *dp++ = (png_byte)(((int)*rp++ - (((int)*pp++ + (int)*lp++) / 2)) ++ & 0xff); + +- for (i = 0, rp = row_buf + 1, dp = png_ptr->up_row + 1, +- pp = prev_row + 1; i < row_bytes; +- i++, rp++, pp++, dp++) +- { +- *dp = (png_byte)(((int)*rp - (int)*pp) & 0xff); +- } +- best_row = png_ptr->up_row; ++#ifdef PNG_USE_ABS ++ sum += 128 - abs((int)v - 128); ++#else ++ sum += (v < 128) ? v : 256 - v; ++#endif ++ ++ if (sum > lmins) /* We are already worse, don't continue. */ ++ break; + } + +- else if (filter_to_do & PNG_FILTER_UP) ++ return (sum); ++} ++static void /* PRIVATE */ ++png_setup_avg_row_only(png_structrp png_ptr, png_uint_32 bpp, ++ size_t row_bytes) ++{ ++ png_bytep rp, dp, pp, lp; ++ png_uint_32 i; ++ ++ png_ptr->try_row[0] = PNG_FILTER_VALUE_AVG; ++ ++ for (i = 0, rp = png_ptr->row_buf + 1, dp = png_ptr->try_row + 1, ++ pp = png_ptr->prev_row + 1; i < bpp; i++) + { +- png_bytep rp, dp, pp; +- png_uint_32 sum = 0, lmins = mins; +- png_uint_32 i; +- int v; ++ *dp++ = (png_byte)(((int)*rp++ - ((int)*pp++ / 2)) & 0xff); ++ } + ++ for (lp = png_ptr->row_buf + 1; i < row_bytes; i++) ++ { ++ *dp++ = (png_byte)(((int)*rp++ - (((int)*pp++ + (int)*lp++) / 2)) ++ & 0xff); ++ } ++} + +-#ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED +- if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED) +- { +- int j; +- png_uint_32 lmhi, lmlo; +- lmlo = lmins & PNG_LOMASK; +- lmhi = (lmins >> PNG_HISHIFT) & PNG_HIMASK; ++static size_t /* PRIVATE */ ++png_setup_paeth_row(png_structrp png_ptr, png_uint_32 bpp, ++ size_t row_bytes, size_t lmins) ++{ ++ png_bytep rp, dp, pp, cp, lp; ++ size_t i; ++ size_t sum = 0; ++ unsigned int v; + +- for (j = 0; j < num_p_filters; j++) +- { +- if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_UP) +- { +- lmlo = (lmlo * png_ptr->inv_filter_weights[j]) >> +- PNG_WEIGHT_SHIFT; +- lmhi = (lmhi * png_ptr->inv_filter_weights[j]) >> +- PNG_WEIGHT_SHIFT; +- } +- } ++ png_ptr->try_row[0] = PNG_FILTER_VALUE_PAETH; + +- lmlo = (lmlo * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_UP]) >> +- PNG_COST_SHIFT; +- lmhi = (lmhi * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_UP]) >> +- PNG_COST_SHIFT; ++ for (i = 0, rp = png_ptr->row_buf + 1, dp = png_ptr->try_row + 1, ++ pp = png_ptr->prev_row + 1; i < bpp; i++) ++ { ++ v = *dp++ = (png_byte)(((int)*rp++ - (int)*pp++) & 0xff); + +- if (lmhi > PNG_HIMASK) +- lmins = PNG_MAXSUM; +- else +- lmins = (lmhi << PNG_HISHIFT) + lmlo; +- } ++#ifdef PNG_USE_ABS ++ sum += 128 - abs((int)v - 128); ++#else ++ sum += (v < 128) ? v : 256 - v; + #endif ++ } + +- for (i = 0, rp = row_buf + 1, dp = png_ptr->up_row + 1, +- pp = prev_row + 1; i < row_bytes; i++) +- { +- v = *dp++ = (png_byte)(((int)*rp++ - (int)*pp++) & 0xff); ++ for (lp = png_ptr->row_buf + 1, cp = png_ptr->prev_row + 1; i < row_bytes; ++ i++) ++ { ++ int a, b, c, pa, pb, pc, p; + +- sum += (v < 128) ? v : 256 - v; ++ b = *pp++; ++ c = *cp++; ++ a = *lp++; + +- if (sum > lmins) /* We are already worse, don't continue. */ +- break; +- } ++ p = b - c; ++ pc = a - c; + +-#ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED +- if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED) +- { +- int j; +- png_uint_32 sumhi, sumlo; +- sumlo = sum & PNG_LOMASK; +- sumhi = (sum >> PNG_HISHIFT) & PNG_HIMASK; ++#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 + +- for (j = 0; j < num_p_filters; j++) +- { +- if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_UP) +- { +- sumlo = (sumlo * png_ptr->filter_weights[j]) >> +- PNG_WEIGHT_SHIFT; +- sumhi = (sumhi * png_ptr->filter_weights[j]) >> +- PNG_WEIGHT_SHIFT; +- } +- } ++ p = (pa <= pb && pa <=pc) ? a : (pb <= pc) ? b : c; + +- sumlo = (sumlo * png_ptr->filter_costs[PNG_FILTER_VALUE_UP]) >> +- PNG_COST_SHIFT; +- sumhi = (sumhi * png_ptr->filter_costs[PNG_FILTER_VALUE_UP]) >> +- PNG_COST_SHIFT; ++ v = *dp++ = (png_byte)(((int)*rp++ - p) & 0xff); + +- if (sumhi > PNG_HIMASK) +- sum = PNG_MAXSUM; +- else +- sum = (sumhi << PNG_HISHIFT) + sumlo; +- } ++#ifdef PNG_USE_ABS ++ sum += 128 - abs((int)v - 128); ++#else ++ sum += (v < 128) ? v : 256 - v; + #endif + +- if (sum < mins) +- { +- mins = sum; +- best_row = png_ptr->up_row; +- } ++ if (sum > lmins) /* We are already worse, don't continue. */ ++ break; + } + +- /* Avg filter */ +- if (filter_to_do == PNG_FILTER_AVG) ++ return (sum); ++} ++static void /* PRIVATE */ ++png_setup_paeth_row_only(png_structrp png_ptr, png_uint_32 bpp, ++ size_t row_bytes) ++{ ++ png_bytep rp, dp, pp, cp, lp; ++ size_t i; ++ ++ png_ptr->try_row[0] = PNG_FILTER_VALUE_PAETH; ++ ++ for (i = 0, rp = png_ptr->row_buf + 1, dp = png_ptr->try_row + 1, ++ pp = png_ptr->prev_row + 1; i < bpp; i++) + { +- png_bytep rp, dp, pp, lp; +- png_uint_32 i; +- for (i = 0, rp = row_buf + 1, dp = png_ptr->avg_row + 1, +- pp = prev_row + 1; i < bpp; i++) +- { +- *dp++ = (png_byte)(((int)*rp++ - ((int)*pp++ / 2)) & 0xff); +- } +- for (lp = row_buf + 1; i < row_bytes; i++) +- { +- *dp++ = (png_byte)(((int)*rp++ - (((int)*pp++ + (int)*lp++) / 2)) +- & 0xff); +- } +- best_row = png_ptr->avg_row; ++ *dp++ = (png_byte)(((int)*rp++ - (int)*pp++) & 0xff); + } + +- else if (filter_to_do & PNG_FILTER_AVG) ++ for (lp = png_ptr->row_buf + 1, cp = png_ptr->prev_row + 1; i < row_bytes; ++ i++) + { +- png_bytep rp, dp, pp, lp; +- png_uint_32 sum = 0, lmins = mins; +- png_uint_32 i; +- int v; ++ int a, b, c, pa, pb, pc, p; + +-#ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED +- if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED) +- { +- int j; +- png_uint_32 lmhi, lmlo; +- lmlo = lmins & PNG_LOMASK; +- lmhi = (lmins >> PNG_HISHIFT) & PNG_HIMASK; ++ b = *pp++; ++ c = *cp++; ++ a = *lp++; + +- for (j = 0; j < num_p_filters; j++) +- { +- if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_AVG) +- { +- lmlo = (lmlo * png_ptr->inv_filter_weights[j]) >> +- PNG_WEIGHT_SHIFT; +- lmhi = (lmhi * png_ptr->inv_filter_weights[j]) >> +- PNG_WEIGHT_SHIFT; +- } +- } ++ p = b - c; ++ pc = a - c; + +- lmlo = (lmlo * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_AVG]) >> +- PNG_COST_SHIFT; +- lmhi = (lmhi * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_AVG]) >> +- PNG_COST_SHIFT; +- +- if (lmhi > PNG_HIMASK) +- lmins = PNG_MAXSUM; +- else +- lmins = (lmhi << PNG_HISHIFT) + lmlo; +- } ++#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 + +- for (i = 0, rp = row_buf + 1, dp = png_ptr->avg_row + 1, +- pp = prev_row + 1; i < bpp; i++) +- { +- v = *dp++ = (png_byte)(((int)*rp++ - ((int)*pp++ / 2)) & 0xff); ++ p = (pa <= pb && pa <=pc) ? a : (pb <= pc) ? b : c; + +- sum += (v < 128) ? v : 256 - v; +- } +- for (lp = row_buf + 1; i < row_bytes; i++) +- { +- v = *dp++ = +- (png_byte)(((int)*rp++ - (((int)*pp++ + (int)*lp++) / 2)) & 0xff); ++ *dp++ = (png_byte)(((int)*rp++ - p) & 0xff); ++ } ++} ++#endif /* WRITE_FILTER */ + +- sum += (v < 128) ? v : 256 - v; ++void /* PRIVATE */ ++png_write_find_filter(png_structrp png_ptr, png_row_infop row_info) ++{ ++#ifndef PNG_WRITE_FILTER_SUPPORTED ++ png_write_filtered_row(png_ptr, png_ptr->row_buf, row_info->rowbytes+1); ++#else ++ unsigned int filter_to_do = png_ptr->do_filter; ++ png_bytep row_buf; ++ png_bytep best_row; ++ png_uint_32 bpp; ++ size_t mins; ++ size_t row_bytes = row_info->rowbytes; + +- if (sum > lmins) /* We are already worse, don't continue. */ +- break; +- } ++ png_debug(1, "in png_write_find_filter"); + +-#ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED +- if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED) +- { +- int j; +- png_uint_32 sumhi, sumlo; +- sumlo = sum & PNG_LOMASK; +- sumhi = (sum >> PNG_HISHIFT) & PNG_HIMASK; ++ /* Find out how many bytes offset each pixel is */ ++ bpp = (row_info->pixel_depth + 7) >> 3; + +- for (j = 0; j < num_p_filters; j++) +- { +- if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_NONE) +- { +- sumlo = (sumlo * png_ptr->filter_weights[j]) >> +- PNG_WEIGHT_SHIFT; +- sumhi = (sumhi * png_ptr->filter_weights[j]) >> +- PNG_WEIGHT_SHIFT; +- } +- } ++ row_buf = png_ptr->row_buf; ++ mins = PNG_SIZE_MAX - 256/* so we can detect potential overflow of the ++ running sum */; ++ ++ /* The prediction method we use is to find which method provides the ++ * smallest value when summing the absolute values of the distances ++ * from zero, using anything >= 128 as negative numbers. This is known ++ * as the "minimum sum of absolute differences" heuristic. Other ++ * heuristics are the "weighted minimum sum of absolute differences" ++ * (experimental and can in theory improve compression), and the "zlib ++ * predictive" method (not implemented yet), which does test compressions ++ * of lines using different filter methods, and then chooses the ++ * (series of) filter(s) that give minimum compressed data size (VERY ++ * computationally expensive). ++ * ++ * GRR 980525: consider also ++ * ++ * (1) minimum sum of absolute differences from running average (i.e., ++ * keep running sum of non-absolute differences & count of bytes) ++ * [track dispersion, too? restart average if dispersion too large?] ++ * ++ * (1b) minimum sum of absolute differences from sliding average, probably ++ * with window size <= deflate window (usually 32K) ++ * ++ * (2) minimum sum of squared differences from zero or running average ++ * (i.e., ~ root-mean-square approach) ++ */ + +- sumlo = (sumlo * png_ptr->filter_costs[PNG_FILTER_VALUE_AVG]) >> +- PNG_COST_SHIFT; +- sumhi = (sumhi * png_ptr->filter_costs[PNG_FILTER_VALUE_AVG]) >> +- PNG_COST_SHIFT; + +- if (sumhi > PNG_HIMASK) +- sum = PNG_MAXSUM; +- else +- sum = (sumhi << PNG_HISHIFT) + sumlo; +- } +-#endif ++ /* 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. ++ */ ++ best_row = png_ptr->row_buf; + +- if (sum < mins) +- { +- mins = sum; +- best_row = png_ptr->avg_row; +- } ++ if (PNG_SIZE_MAX/128 <= row_bytes) ++ { ++ /* Overflow can occur in the calculation, just select the lowest set ++ * filter. ++ */ ++ filter_to_do &= 0U-filter_to_do; + } +- +- /* Paeth filter */ +- if (filter_to_do == PNG_FILTER_PAETH) ++ else if ((filter_to_do & PNG_FILTER_NONE) != 0 && ++ filter_to_do != PNG_FILTER_NONE) + { +- png_bytep rp, dp, pp, cp, lp; +- png_uint_32 i; +- for (i = 0, rp = row_buf + 1, dp = png_ptr->paeth_row + 1, +- pp = prev_row + 1; i < bpp; i++) +- { +- *dp++ = (png_byte)(((int)*rp++ - (int)*pp++) & 0xff); +- } ++ /* Overflow not possible and multiple filters in the list, including the ++ * 'none' filter. ++ */ ++ png_bytep rp; ++ size_t sum = 0; ++ size_t i; ++ unsigned int v; + +- for (lp = row_buf + 1, cp = prev_row + 1; i < row_bytes; i++) + { +- int a, b, c, pa, pb, pc, p; +- +- b = *pp++; +- c = *cp++; +- a = *lp++; +- +- p = b - c; +- pc = a - c; +- ++ for (i = 0, rp = row_buf + 1; i < row_bytes; i++, rp++) ++ { ++ v = *rp; + #ifdef PNG_USE_ABS +- pa = abs(p); +- pb = abs(pc); +- pc = abs(p + pc); ++ sum += 128 - abs((int)v - 128); + #else +- pa = p < 0 ? -p : p; +- pb = pc < 0 ? -pc : pc; +- pc = (p + pc) < 0 ? -(p + pc) : p + pc; ++ sum += (v < 128) ? v : 256 - v; + #endif ++ } ++ } + +- p = (pa <= pb && pa <=pc) ? a : (pb <= pc) ? b : c; ++ mins = sum; ++ } + +- *dp++ = (png_byte)(((int)*rp++ - p) & 0xff); +- } +- best_row = png_ptr->paeth_row; ++ /* Sub filter */ ++ if (filter_to_do == PNG_FILTER_SUB) ++ /* It's the only filter so no testing is needed */ ++ { ++ png_setup_sub_row_only(png_ptr, bpp, row_bytes); ++ best_row = png_ptr->try_row; + } + +- else if (filter_to_do & PNG_FILTER_PAETH) ++ else if ((filter_to_do & PNG_FILTER_SUB) != 0) + { +- png_bytep rp, dp, pp, cp, lp; +- png_uint_32 sum = 0, lmins = mins; +- png_uint_32 i; +- int v; ++ size_t sum; ++ size_t lmins = mins; + +-#ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED +- if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED) +- { +- int j; +- png_uint_32 lmhi, lmlo; +- lmlo = lmins & PNG_LOMASK; +- lmhi = (lmins >> PNG_HISHIFT) & PNG_HIMASK; ++ sum = png_setup_sub_row(png_ptr, bpp, row_bytes, lmins); + +- for (j = 0; j < num_p_filters; j++) ++ if (sum < mins) ++ { ++ mins = sum; ++ best_row = png_ptr->try_row; ++ if (png_ptr->tst_row != NULL) + { +- if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_PAETH) +- { +- lmlo = (lmlo * png_ptr->inv_filter_weights[j]) >> +- PNG_WEIGHT_SHIFT; +- lmhi = (lmhi * png_ptr->inv_filter_weights[j]) >> +- PNG_WEIGHT_SHIFT; +- } ++ png_ptr->try_row = png_ptr->tst_row; ++ png_ptr->tst_row = best_row; + } +- +- lmlo = (lmlo * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_PAETH]) >> +- PNG_COST_SHIFT; +- lmhi = (lmhi * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_PAETH]) >> +- PNG_COST_SHIFT; +- +- if (lmhi > PNG_HIMASK) +- lmins = PNG_MAXSUM; +- else +- lmins = (lmhi << PNG_HISHIFT) + lmlo; +- } +-#endif +- +- for (i = 0, rp = row_buf + 1, dp = png_ptr->paeth_row + 1, +- pp = prev_row + 1; i < bpp; i++) +- { +- v = *dp++ = (png_byte)(((int)*rp++ - (int)*pp++) & 0xff); +- +- sum += (v < 128) ? v : 256 - v; + } ++ } + +- for (lp = row_buf + 1, cp = prev_row + 1; i < row_bytes; i++) +- { +- int a, b, c, pa, pb, pc, p; +- +- b = *pp++; +- c = *cp++; +- a = *lp++; +- +-#ifndef PNG_SLOW_PAETH +- p = b - c; +- pc = a - c; +-#ifdef PNG_USE_ABS +- pa = abs(p); +- pb = abs(pc); +- pc = abs(p + pc); +-#else +- pa = p < 0 ? -p : p; +- pb = pc < 0 ? -pc : pc; +- pc = (p + pc) < 0 ? -(p + pc) : p + pc; +-#endif +- p = (pa <= pb && pa <=pc) ? a : (pb <= pc) ? b : c; +-#else /* PNG_SLOW_PAETH */ +- p = a + b - c; +- pa = abs(p - a); +- pb = abs(p - b); +- pc = abs(p - c); +- if (pa <= pb && pa <= pc) +- p = a; +- else if (pb <= pc) +- p = b; +- else +- p = c; +-#endif /* PNG_SLOW_PAETH */ +- +- v = *dp++ = (png_byte)(((int)*rp++ - p) & 0xff); ++ /* Up filter */ ++ if (filter_to_do == PNG_FILTER_UP) ++ { ++ png_setup_up_row_only(png_ptr, row_bytes); ++ best_row = png_ptr->try_row; ++ } + +- sum += (v < 128) ? v : 256 - v; ++ else if ((filter_to_do & PNG_FILTER_UP) != 0) ++ { ++ size_t sum; ++ size_t lmins = mins; + +- if (sum > lmins) /* We are already worse, don't continue. */ +- break; +- } ++ sum = png_setup_up_row(png_ptr, row_bytes, lmins); + +-#ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED +- if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED) ++ if (sum < mins) + { +- int j; +- png_uint_32 sumhi, sumlo; +- sumlo = sum & PNG_LOMASK; +- sumhi = (sum >> PNG_HISHIFT) & PNG_HIMASK; +- +- for (j = 0; j < num_p_filters; j++) ++ mins = sum; ++ best_row = png_ptr->try_row; ++ if (png_ptr->tst_row != NULL) + { +- if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_PAETH) +- { +- sumlo = (sumlo * png_ptr->filter_weights[j]) >> +- PNG_WEIGHT_SHIFT; +- sumhi = (sumhi * png_ptr->filter_weights[j]) >> +- PNG_WEIGHT_SHIFT; +- } ++ png_ptr->try_row = png_ptr->tst_row; ++ png_ptr->tst_row = best_row; + } ++ } ++ } ++ ++ /* Avg filter */ ++ if (filter_to_do == PNG_FILTER_AVG) ++ { ++ png_setup_avg_row_only(png_ptr, bpp, row_bytes); ++ best_row = png_ptr->try_row; ++ } + +- sumlo = (sumlo * png_ptr->filter_costs[PNG_FILTER_VALUE_PAETH]) >> +- PNG_COST_SHIFT; +- sumhi = (sumhi * png_ptr->filter_costs[PNG_FILTER_VALUE_PAETH]) >> +- PNG_COST_SHIFT; ++ else if ((filter_to_do & PNG_FILTER_AVG) != 0) ++ { ++ size_t sum; ++ size_t lmins = mins; + +- if (sumhi > PNG_HIMASK) +- sum = PNG_MAXSUM; +- else +- sum = (sumhi << PNG_HISHIFT) + sumlo; +- } +-#endif ++ sum= png_setup_avg_row(png_ptr, bpp, row_bytes, lmins); + + if (sum < mins) + { +- best_row = png_ptr->paeth_row; ++ mins = sum; ++ best_row = png_ptr->try_row; ++ if (png_ptr->tst_row != NULL) ++ { ++ png_ptr->try_row = png_ptr->tst_row; ++ png_ptr->tst_row = best_row; ++ } + } + } +-#endif /* PNG_WRITE_FILTER_SUPPORTED */ +- /* Do the actual writing of the filtered row data from the chosen filter. */ + +- png_write_filtered_row(png_ptr, best_row); ++ /* Paeth filter */ ++ if (filter_to_do == PNG_FILTER_PAETH) ++ { ++ png_setup_paeth_row_only(png_ptr, bpp, row_bytes); ++ best_row = png_ptr->try_row; ++ } + +-#ifdef PNG_WRITE_FILTER_SUPPORTED +-#ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED +- /* Save the type of filter we picked this time for future calculations */ +- if (png_ptr->num_prev_filters > 0) ++ else if ((filter_to_do & PNG_FILTER_PAETH) != 0) + { +- int j; +- for (j = 1; j < num_p_filters; j++) ++ size_t sum; ++ size_t lmins = mins; ++ ++ sum = png_setup_paeth_row(png_ptr, bpp, row_bytes, lmins); ++ ++ if (sum < mins) + { +- png_ptr->prev_filters[j] = png_ptr->prev_filters[j - 1]; ++ best_row = png_ptr->try_row; ++ if (png_ptr->tst_row != NULL) ++ { ++ png_ptr->try_row = png_ptr->tst_row; ++ png_ptr->tst_row = best_row; ++ } + } +- png_ptr->prev_filters[j] = best_row[0]; + } +-#endif +-#endif /* PNG_WRITE_FILTER_SUPPORTED */ ++ ++ /* Do the actual writing of the filtered row data from the chosen filter. */ ++ png_write_filtered_row(png_ptr, best_row, row_info->rowbytes+1); ++ ++#endif /* WRITE_FILTER */ + } + + + /* Do the actual writing of a previously filtered row. */ +-void /* PRIVATE */ +-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, ++ size_t full_row_length/*includes filter byte*/) + { + png_debug(1, "in png_write_filtered_row"); + + png_debug1(2, "filter = %d", filtered_row[0]); +- /* Set up the zlib input buffer */ +- +- png_ptr->zstream.next_in = filtered_row; +- png_ptr->zstream.avail_in = (uInt)png_ptr->row_info.rowbytes + 1; +- /* Repeat until we have compressed all the data */ +- do +- { +- int ret; /* Return of zlib */ +- +- /* Compress the data */ +- ret = deflate(&png_ptr->zstream, Z_NO_FLUSH); +- /* Check for compression errors */ +- if (ret != Z_OK) +- { +- if (png_ptr->zstream.msg != NULL) +- png_error(png_ptr, png_ptr->zstream.msg); +- else +- png_error(png_ptr, "zlib error"); +- } + +- /* See if it is time to write another IDAT */ +- if (!(png_ptr->zstream.avail_out)) +- { +- /* Write the IDAT and reset the zlib output buffer */ +- png_write_IDAT(png_ptr, png_ptr->zbuf, png_ptr->zbuf_size); +- png_ptr->zstream.next_out = png_ptr->zbuf; +- png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size; +- } +- /* Repeat until all data has been compressed */ +- } while (png_ptr->zstream.avail_in); ++ png_compress_IDAT(png_ptr, filtered_row, full_row_length, Z_NO_FLUSH); + ++#ifdef PNG_WRITE_FILTER_SUPPORTED + /* Swap the current and previous rows */ + if (png_ptr->prev_row != NULL) + { +@@ -2815,6 +2763,7 @@ png_write_filtered_row(png_structp png_ptr, png_bytep filtered_row) + png_ptr->prev_row = png_ptr->row_buf; + png_ptr->row_buf = tptr; + } ++#endif /* WRITE_FILTER */ + + /* Finish row - updates counters and flushes zlib if last row */ + png_write_finish_row(png_ptr); +@@ -2827,6 +2776,6 @@ png_write_filtered_row(png_structp png_ptr, png_bytep filtered_row) + { + png_write_flush(png_ptr); + } +-#endif ++#endif /* WRITE_FLUSH */ + } +-#endif /* PNG_WRITE_SUPPORTED */ ++#endif /* WRITE */ +diff --git a/com32/lib/sys/vesa/background.c b/com32/lib/sys/vesa/background.c +index 15e90895..0e957da8 100644 +--- a/com32/lib/sys/vesa/background.c ++++ b/com32/lib/sys/vesa/background.c +@@ -36,6 +36,7 @@ + #include + #include + #include ++#include + #include "vesa.h" + #include "video.h" + +@@ -112,6 +113,8 @@ static int read_png_file(FILE * fp) + { + png_structp png_ptr = NULL; + png_infop info_ptr = NULL; ++ int color_type, bit_depth; ++ png_uint_32 height, width; + #if 0 + png_color_16p image_background; + static const png_color_16 my_background = { 0, 0, 0, 0, 0 }; +@@ -136,14 +139,17 @@ static int read_png_file(FILE * fp) + /* Set the appropriate set of transformations. We need to end up + with 32-bit BGRA format, no more, no less. */ + ++ png_get_IHDR(png_ptr, info_ptr, &width, &height, &bit_depth, &color_type, ++ NULL, NULL, NULL); ++ + /* Expand to RGB first... */ +- if (info_ptr->color_type & PNG_COLOR_MASK_PALETTE) ++ if (color_type & PNG_COLOR_MASK_PALETTE) + png_set_palette_to_rgb(png_ptr); +- else if (!(info_ptr->color_type & PNG_COLOR_MASK_COLOR)) ++ else if (!(color_type & PNG_COLOR_MASK_COLOR)) + png_set_gray_to_rgb(png_ptr); + + /* Add alpha channel, if need be */ +- if (!(png_ptr->color_type & PNG_COLOR_MASK_ALPHA)) { ++ if (!(color_type & PNG_COLOR_MASK_ALPHA)) { + if (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS)) + png_set_tRNS_to_alpha(png_ptr); + else +@@ -154,9 +160,10 @@ static int read_png_file(FILE * fp) + png_set_bgr(png_ptr); + + /* Make sure we end up with 8-bit data */ +- if (info_ptr->bit_depth == 16) ++ bit_depth = png_get_bit_depth(png_ptr, info_ptr); ++ if (bit_depth == 16) + png_set_strip_16(png_ptr); +- else if (info_ptr->bit_depth < 8) ++ else if (bit_depth < 8) + png_set_packing(png_ptr); + + #if 0 +@@ -170,14 +177,14 @@ static int read_png_file(FILE * fp) + + /* Whew! Now we should get the stuff we want... */ + rp = (png_bytep)__vesacon_background; +- for (i = 0; i < (int)info_ptr->height; i++) { ++ for (i = 0; i < (int)height; i++) { + row_pointers[i] = rp; + rp += __vesa_info.mi.h_res << 2; + } + + png_read_image(png_ptr, row_pointers); + +- tile_image(info_ptr->width, info_ptr->height); ++ tile_image(width, height); + + rv = 0; + +diff --git a/mk/lib.mk b/mk/lib.mk +index 977c2716..f3fb07c7 100644 +--- a/mk/lib.mk ++++ b/mk/lib.mk +@@ -32,11 +32,8 @@ GCCOPT += $(call gcc_ok,-falign-loops=0,-malign-loops=0) + INCLUDE = -I$(SRC) + STRIP = strip --strip-all -R .comment -R .note + +-# zlib and libpng configuration flags +-LIBFLAGS = -DDYNAMIC_CRC_TABLE -DPNG_NO_CONSOLE_IO \ +- -DPNG_NO_WRITE_SUPPORTED \ +- -DPNG_NO_MNG_FEATURES \ +- -DPNG_NO_READ_tIME -DPNG_NO_WRITE_tIME ++# zlib configuration flags ++LIBFLAGS = -DDYNAMIC_CRC_TABLE + + # We need some features in libpng which apparently aren't available in the + # fixed-point versions. It's OK, because we have to have a non-graphical +-- +2.33.0 + diff --git a/syslinux.spec b/syslinux.spec index 1dd9bb1..cc7b940 100644 --- a/syslinux.spec +++ b/syslinux.spec @@ -2,7 +2,7 @@ Name: syslinux Version: 6.04 -Release: 15 +Release: 16 License: GPLv2+ Summary: The Syslinux boot loader collection URL: http://syslinux.zytor.com/wiki/index.php/The_Syslinux_Project @@ -27,6 +27,7 @@ Patch0004: backport-replace-builtin-strlen-that-appears-to-get-optimized.pa Patch0005: backport-add-RPMOPTFLAGS-to-CFLAGS-for-some-stuff.patch Patch0006: backport-tweak-for-gcc-10.patch Patch0007: backport-zlib-update.patch +Patch0008: backport-libpng-update-to-1.6.36.patch %description The Syslinux Project covers lightweight bootloaders for MS-DOS FAT filesystems (SYSLINUX), @@ -162,6 +163,11 @@ fi %{_datadir}/syslinux/efi64 %changelog +* Thu Aug 29 2024 lingsheng - 6.04-16 +- update libpng 1.6.36 to fix CVE-2011-2501 CVE-2011-2690 CVE-2011-2691 +- CVE-2011-2692 CVE-2011-3045 CVE-2011-3048 CVE-2012-3425 CVE-2015-7981 +- CVE-2015-8126 CVE-2015-8472 CVE-2015-8540 CVE-2016-10087 CVE-2017-12652 + * Thu Aug 01 2024 lingsheng - 6.04-15 - Clean changelog format, fix yaml -- Gitee