[libpng16] Imported from libpng-1.6.16rc01.tar

that don't do alignment correctly.

CMakeLists.txt

@@ -1,6 +1,6 @@
 # CMakeLists.txt
 
-# Copyright (C) 2007-2015 Glenn Randers-Pehrson
+# Copyright (C) 2007-2014 Glenn Randers-Pehrson
 
 # This code is released under the libpng license.
 # For conditions of distribution and use, see the disclaimer
@@ -15,8 +15,8 @@ project(libpng C)
 enable_testing()
 
 set(PNGLIB_MAJOR 1)
-set(PNGLIB_MINOR 7)
-set(PNGLIB_RELEASE 0)
+set(PNGLIB_MINOR 6)
+set(PNGLIB_RELEASE 16)
 set(PNGLIB_NAME libpng${PNGLIB_MAJOR}${PNGLIB_MINOR})
 set(PNGLIB_VERSION ${PNGLIB_MAJOR}.${PNGLIB_MINOR}.${PNGLIB_RELEASE})
 
@@ -30,7 +30,8 @@ if(NOT WIN32)
     PATHS /usr/lib /usr/local/lib
   )
   if(NOT M_LIBRARY)
-    message(STATUS "math lib 'libm' not found; floating point support disabled")
+    message(STATUS
+      "math library 'libm' not found - floating point support disabled")
   endif()
 else()
   # not needed on windows
@@ -38,14 +39,22 @@ else()
 endif()
 
 # COMMAND LINE OPTIONS
-option(PNG_SHARED "Build shared lib" ON)
-option(PNG_STATIC "Build static lib" ON)
-option(PNG_TESTS  "Build libpng tests" ON)
+if(DEFINED PNG_SHARED)
+  option(PNG_SHARED "Build shared lib" ${PNG_SHARED})
+else()
+  option(PNG_SHARED "Build shared lib" ON)
+endif()
+if(DEFINED PNG_STATIC)
+  option(PNG_STATIC "Build static lib" ${PNG_STATIC})
+else()
+  option(PNG_STATIC "Build static lib" ON)
+endif()
+
+option(PNG_TESTS  "Build libpng tests" YES)
 
 # Many more configuration options could be added here
-option(PNG_FRAMEWORK "Build OS X framework" OFF)
-option(PNG_DEBUG     "Build with debug output" OFF)
-option(PNGARG        "Disable ANSI-C prototypes" OFF)
+option(PNG_DEBUG         "Build with debug output" NO)
+option(PNGARG            "Disable ANSI-C prototypes" NO)
 
 # SET LIBNAME
 set(PNG_LIB_NAME png${PNGLIB_MAJOR}${PNGLIB_MINOR})
@@ -125,7 +134,7 @@ if(PNG_SHARED)
 endif()
 
 if(PNG_STATIC)
-  # does not work without changing name
+# does not work without changing name
   set(PNG_LIB_NAME_STATIC ${PNG_LIB_NAME}_static)
   add_library(${PNG_LIB_NAME_STATIC} STATIC ${libpng_sources})
   list(APPEND PNG_LIB_TARGETS ${PNG_LIB_NAME_STATIC})
@@ -136,27 +145,10 @@ if(PNG_STATIC)
   target_link_libraries(${PNG_LIB_NAME_STATIC} ${ZLIB_LIBRARY} ${M_LIBRARY})
 endif()
 
-if(PNG_FRAMEWORK)
-  set(PNG_LIB_NAME_FRAMEWORK ${PNG_LIB_NAME}_framework)
-  add_library(${PNG_LIB_NAME_FRAMEWORK} SHARED ${libpng_sources})
-  list(APPEND PNG_LIB_TARGETS ${PNG_LIB_NAME_FRAMEWORK})
-  set_target_properties(${PNG_LIB_NAME_FRAMEWORK} PROPERTIES
-    FRAMEWORK TRUE
-    FRAMEWORK_VERSION ${PNGLIB_VERSION}
-    MACOSX_FRAMEWORK_SHORT_VERSION_STRING ${PNGLIB_MAJOR}.${PNGLIB_MINOR}
-    MACOSX_FRAMEWORK_BUNDLE_VERSION ${PNGLIB_VERSION}
-    MACOSX_FRAMEWORK_IDENTIFIER org.libpng.libpng
-    XCODE_ATTRIBUTE_INSTALL_PATH "@rpath"
-    PUBLIC_HEADER "${libpng_public_hdrs}"
-    OUTPUT_NAME png)
-  target_link_libraries(${PNG_LIB_NAME_FRAMEWORK} ${ZLIB_LIBRARY} ${M_LIBRARY})
-endif()
-
 if(NOT PNG_LIB_TARGETS)
   message(SEND_ERROR
     "No library variant selected to build. "
-    "Please enable at least one of the following options: "
-    " PNG_STATIC, PNG_SHARED, PNG_FRAMEWORK")
+    "Please enable at least one of the following options: PNG_STATIC, PNG_SHARED")
 endif()
 
 if(PNG_SHARED AND WIN32)
@@ -261,9 +253,9 @@ endif(NOT WIN32 OR CYGWIN OR MINGW)
 # SET UP LINKS
 if(PNG_SHARED)
   set_target_properties(${PNG_LIB_NAME} PROPERTIES
-#   VERSION 17.${PNGLIB_RELEASE}.1.7.0beta73
-    VERSION 17.${PNGLIB_RELEASE}.0
-    SOVERSION 17
+#   VERSION 16.${PNGLIB_RELEASE}.1.6.16rc01
+    VERSION 16.${PNGLIB_RELEASE}.0
+    SOVERSION 16
     CLEAN_DIRECT_OUTPUT 1)
 endif()
 if(PNG_STATIC)
@@ -292,11 +284,10 @@ if(NOT SKIP_INSTALL_LIBRARIES AND NOT SKIP_INSTALL_ALL )
       ${PNG_EXPORT_RULE}
       RUNTIME DESTINATION bin
       LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
-      ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
-      FRAMEWORK DESTINATION ${CMAKE_INSTALL_LIBDIR})
+      ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR})
 
   if(PNG_SHARED)
-    # Create a symlink for libpng.dll.a => libpng17.dll.a on Cygwin
+    # Create a symlink for libpng.dll.a => libpng16.dll.a on Cygwin
     if(CYGWIN OR MINGW)
        get_target_property(BUILD_TARGET_LOCATION ${PNG_LIB_NAME} LOCATION_${CMAKE_BUILD_TYPE})
        CREATE_SYMLINK(${BUILD_TARGET_LOCATION} libpng${CMAKE_IMPORT_LIBRARY_SUFFIX})

INSTALL

@@ -17,7 +17,7 @@ VIII. Configuring libpng for 16-bit platforms
  XII. Configuring for compiler xxx:
 XIII. Removing unwanted object code
  XIV. Changes to the build and configuration of libpng in libpng-1.5.x
-  XV. Setjmp/longjmp issues
+  XV. Configuring libpng for multiprocessing
  XVI. Other sources of information about libpng
 
 I. Simple installation
@@ -189,7 +189,7 @@ run "make install".
 VIII. Configuring libpng for 16-bit platforms
 
 You will want to look into zconf.h to tell zlib (and thus libpng) that
-it cannot allocate more than 64K at a time.  Even if you can, the memory
+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.
 
 IX. Configuring for DOS
@@ -362,7 +362,7 @@ $PREFIX/include directory).  Do not edit pnglibconf.h after you have built
 libpng, because than the settings would not accurately reflect the settings
 that were used to build libpng.
 
-XV. Setjmp/longjmp issues
+XV. Configuring libpng for multiprocessing
 
 Libpng uses setjmp()/longjmp() for error handling.  Unfortunately setjmp()
 is known to be not thread-safe on some platforms and we don't know of
@@ -375,11 +375,6 @@ configure libpng with PNG_NO_SETJMP in your pngusr.dfa file, with
 
 in your pnglibconf.h or pngusr.h.
 
-Starting with libpng-1.6.0, the library included a "simplified API".
-This requires setjmp/longjmp, so you must either build the library
-with PNG_SETJMP_SUPPORTED defined, or with PNG_SIMPLIFIED_READ_SUPPORTED
-and PNG_SIMPLIFIED_WRITE_SUPPORTED undefined.
-
 XVI. Other sources of information about libpng:
 
 Further information can be found in the README and libpng-manual.txt
@@ -399,7 +394,7 @@ CFLAGS="-Wall -O -funroll-loops \
 --with-pkgconfigdir=/usr/lib/pkgconfig --includedir=/usr/include
 
 You can alternatively specify --includedir=/usr/include, /usr/local/include,
-/usr/include/libpng17, or whatever.
+/usr/include/libpng16, or whatever.
 
 If you find that the configure script is out-of-date or is not supporting
 your platform properly, try running autogen.sh to regenerate "configure",

LICENSE

@@ -10,18 +10,21 @@ this sentence.
 
 This code is released under the libpng license.
 
-libpng versions 1.0.7, July 1, 2000, through 1.7.0beta73, December 11, 2015, are
-Copyright (c) 2000-2002, 2004, 2006-2015 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:
+libpng versions 1.2.6, August 15, 2004, through 1.6.16rc01, December 21, 2014, are
+Copyright (c) 2004, 2006-2014 Glenn Randers-Pehrson, and are
+distributed according to the same disclaimer and license as libpng-1.2.5
+with the following individual added to the list of Contributing Authors
+
+   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
-   Mans Rullgard
-   Cosmin Truta
    Gilles Vollant
-   James Yu
 
 and with the following additions to the disclaimer:
 
@@ -33,20 +36,18 @@ and with the following additions to the disclaimer:
    the user.
 
 libpng versions 0.97, January 1998, through 1.0.6, March 20, 2000, are
-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:
+Copyright (c) 1998, 1999 Glenn Randers-Pehrson, and are
+distributed according to the same disclaimer and license as libpng-0.96,
+with the following individuals added to the list of Contributing Authors:
 
    Tom Lane
    Glenn Randers-Pehrson
    Willem van Schaik
 
 libpng versions 0.89, June 1996, through 0.96, May 1997, are
-Copyright (c) 1996-1997 Andreas Dilger, 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:
+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
@@ -56,7 +57,7 @@ Contributing Authors:
    Tom Tanner
 
 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:
@@ -79,13 +80,13 @@ 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.
+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.
+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.
+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
@@ -93,20 +94,18 @@ 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.
 
-END OF COPYRIGHT NOTICE, DISCLAIMER, and LICENSE.
 
 A "png_get_copyright" function is available, for convenient use in "about"
 boxes and the like:
 
-   printf("%s", png_get_copyright(NULL));
+   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. OSI has not addressed
-the additional disclaimers inserted at version 1.0.7.
+Libpng is OSI Certified Open Source Software.  OSI Certified Open Source is a
+certification mark of the Open Source Initiative.
 
 Glenn Randers-Pehrson
 glennrp at users.sourceforge.net
-December 11, 2015
+December 21, 2014

Makefile.am

@@ -51,17 +51,23 @@ TESTS =\
    tests/pngvalid-gamma-expand16-background\
    tests/pngvalid-gamma-expand16-transform tests/pngvalid-gamma-sbit\
    tests/pngvalid-gamma-threshold tests/pngvalid-gamma-transform\
-   tests/pngvalid-progressive-size tests/pngvalid-size\
+   tests/pngvalid-progressive-interlace-size\
    tests/pngvalid-progressive-interlace-standard\
-   tests/pngvalid-transform tests/pngvalid-interlace-transform\
+   tests/pngvalid-progressive-interlace-transform\
    tests/pngvalid-progressive-standard tests/pngvalid-standard\
-   tests/pngstest-1.8 tests/pngstest-1.8-alpha tests/pngstest-linear\
-   tests/pngstest-linear-alpha tests/pngstest-none tests/pngstest-none-alpha\
-   tests/pngstest-sRGB tests/pngstest-sRGB-alpha tests/pngunknown-IDAT\
+   tests/pngstest-0g01 tests/pngstest-0g02 tests/pngstest-0g04\
+   tests/pngstest-0g08 tests/pngstest-0g16 tests/pngstest-2c08\
+   tests/pngstest-2c16 tests/pngstest-3p01 tests/pngstest-3p02\
+   tests/pngstest-3p04 tests/pngstest-3p08 tests/pngstest-4a08\
+   tests/pngstest-4a16 tests/pngstest-6a08 tests/pngstest-6a16\
+   tests/pngstest-error tests/pngunknown-IDAT\
    tests/pngunknown-discard tests/pngunknown-if-safe tests/pngunknown-sAPI\
    tests/pngunknown-sTER tests/pngunknown-save tests/pngunknown-vpAg\
    tests/pngimage-quick tests/pngimage-full
 
+# These tests are expected, and required, to fail:
+XFAIL_TESTS = tests/pngstest-error
+
 # man pages
 dist_man_MANS= libpng.3 libpngpf.3 png.5
 
@@ -76,15 +82,11 @@ lib_LTLIBRARIES=libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@.la
 libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@_la_SOURCES = png.c pngerror.c\
 	pngget.c pngmem.c pngpread.c pngread.c pngrio.c pngrtran.c pngrutil.c\
 	pngset.c pngtrans.c pngwio.c pngwrite.c pngwtran.c pngwutil.c\
-	png.h pngconf.h pngdebug.h pnginfo.h pngpriv.h pngstruct.h pngchunk.h \
-	pngusr.dfa
+	png.h pngconf.h pngdebug.h pnginfo.h pngpriv.h pngstruct.h pngusr.dfa
 
-# Include libpng extensions, if appropriate.  This uses a Makefile.am fragment,
-# pre-set things that might be changed by addition:
-AM_CPPFLAGS =
-DFA_EXTENSION = 
-if LIBPNG_EXTENSIONS
-include $(top_srcdir)/contrib/extensions.am
+if PNG_ARM_NEON
+libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@_la_SOURCES += arm/arm_init.c\
+	arm/filter_neon.S arm/filter_neon_intrinsics.c
 endif
 
 nodist_libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@_la_SOURCES = pnglibconf.h
@@ -131,8 +133,7 @@ SCRIPT_CLEANFILES=scripts/*.out scripts/*.chk scripts/pnglibconf.c
 
 CLEANFILES= *.tf? pngout.png libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@.pc \
 	libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@-config libpng.vers libpng.sym \
-	check.new pnglibconf.h pngprefix.h symbols.new pngtest-log.txt \
-	pnglibconf.out pnglibconf.c pnglibconf.dfn pnglibconf.pre \
+	check.new pnglibconf.* pngprefix.h symbols.new pngtest-log.txt \
 	$(SCRIPT_CLEANFILES)
 
 MAINTAINERCLEANFILES = Makefile.in aclocal.m4 config.guess config.h.in \
@@ -144,8 +145,8 @@ config.sub configure depcomp install-sh ltmain.sh missing
 PNG_COPTS = @PNG_COPTS@
 AM_CFLAGS = ${PNG_COPTS}
 
-# DFNCPP is normally just "CPP -E" - the C preprocessor - but on Solaris and
-# maybe other operating systems (NeXT?) the C preprocessor selected by configure
+# DFNCPP is normally just CPP - the C preprocessor - but on Solaris and maybe
+# other operating systems (NeXT?) the C preprocessor selected by configure
 # checks input tokens for validity - effectively it performs part of the ANSI-C
 # parsing - and therefore fails with the .df files.  configure.ac has special
 # checks for this and sets DFNCPP appropriately.
@@ -164,8 +165,6 @@ scripts/prefix.out: png.h pngconf.h pnglibconf.out
 scripts/symbols.out: png.h pngconf.h $(srcdir)/scripts/pnglibconf.h.prebuilt
 scripts/intprefix.out: pnglibconf.h
 
-pnglibconf.out: config.h
-
 libpng.sym: scripts/sym.out
 	rm -f $@
 	cp $? $@
@@ -177,7 +176,7 @@ if DO_PNG_PREFIX
 # Rename functions in scripts/prefix.out with a PNG_PREFIX prefix.
 # Rename macros in scripts/macro.lst from PNG_PREFIXpng_ to PNG_ (the actual
 # implementation of the macro).
-pnglibconf.h: pnglibconf.out scripts/prefix.out scripts/macro.lst config.h
+pnglibconf.h: pnglibconf.out scripts/prefix.out scripts/macro.lst
 	rm -f $@
 	$(AWK) 's==0 && NR>1{print prev}\
 	   s==0{prev=$$0}\
@@ -242,17 +241,17 @@ endif
 	rm -f $@ $*.tf[12]
 	test -d scripts || mkdir scripts || test -d scripts
 	$(DFNCPP) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES)\
-	    $(AM_CPPFLAGS) $(CPPFLAGS) $(SYMBOL_CFLAGS) $< > $*.tf1
+	    $(CPPFLAGS) $(SYMBOL_CFLAGS) $< > $*.tf1
 	$(AWK) -f "${srcdir}/scripts/dfn.awk" out="$*.tf2" $*.tf1 1>&2
 	rm -f $*.tf1
 	mv $*.tf2 $@
 
 # The .c file for pnglibconf.h is machine generated
-pnglibconf.c: scripts/pnglibconf.dfa scripts/options.awk pngconf.h pngusr.dfa $(DFA_EXTENSION) $(DFA_XTRA)
+pnglibconf.c: scripts/pnglibconf.dfa scripts/options.awk pngconf.h pngusr.dfa $(DFA_XTRA)
 	rm -f $@ $*.tf[45]
 	$(AWK) -f ${srcdir}/scripts/options.awk out=$*.tf4 version=search\
 	    ${srcdir}/pngconf.h ${srcdir}/scripts/pnglibconf.dfa\
-	    $(DFA_EXTENSION) ${srcdir}/pngusr.dfa $(DFA_XTRA) 1>&2
+	    ${srcdir}/pngusr.dfa $(DFA_XTRA) 1>&2
 	$(AWK) -f ${srcdir}/scripts/options.awk out=$*.tf5 $*.tf4 1>&2
 	rm $*.tf4
 	mv $*.tf5 $@
@@ -270,8 +269,8 @@ scripts/symbols.chk: scripts/checksym.awk scripts/symbols.def scripts/symbols.ou
 # be empty - no non-standard defines
 scripts/pnglibconf.c: scripts/pnglibconf.dfa scripts/options.awk pngconf.h
 	rm -f $@ pnglibconf.tf[67]
-	test -z "$(CPPFLAGS)" -a -z "$(AM_CPPFLAGS)"
-	echo "com libpng @PNGLIB_VERSION@ STANDARD API DEFINITION" |\
+	test -z "$(CPPFLAGS)"
+	echo "com @PNGLIB_VERSION@ STANDARD API DEFINITION" |\
 	$(AWK) -f ${srcdir}/scripts/options.awk out=pnglibconf.tf6\
 	    logunsupported=1 version=search ${srcdir}/pngconf.h -\
 	    ${srcdir}/scripts/pnglibconf.dfa 1>&2
@@ -280,7 +279,7 @@ scripts/pnglibconf.c: scripts/pnglibconf.dfa scripts/options.awk pngconf.h
 	rm pnglibconf.tf6
 	mv pnglibconf.tf7 $@
 
-$(libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@_la_OBJECTS): png.h pngconf.h pngchunk.h \
+$(libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@_la_OBJECTS): png.h pngconf.h \
 	pnglibconf.h pngpriv.h pngdebug.h pnginfo.h pngstruct.h pngprefix.h
 
 test: check-am

README

@@ -1,4 +1,4 @@
-README for libpng version 1.7.0beta73 - December 11, 2015 (shared library 17.0)
+README for libpng version 1.6.16rc01 - December 21, 2014 (shared library 16.0)
 See the note about version numbers near the top of png.h
 
 See INSTALL for instructions on how to install libpng.
@@ -134,7 +134,7 @@ 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 twenty years now, and it is official and
+been discussing PNG for nineteen years now, and it is official and
 finished.  If you have suggestions for libpng, however, I'll
 gladly listen.  Even if your suggestion is not used immediately,
 it may be used later.

TODO

@@ -25,6 +25,5 @@ Investigate pre-incremented loop counters and other loop constructions.
 Add interpolated method of handling interlacing.
 Switch to the simpler zlib (zlib/libpng) license if legally possible.
 Extend pngvalid.c to validate more of the libpng transformations.
-Refactor preprocessor conditionals to compile entire statements
 
 */

arm/arm_init.c

@@ -3,7 +3,7 @@
  *
  * Copyright (c) 2014 Glenn Randers-Pehrson
  * Written by Mans Rullgard, 2011.
- * Last changed in libpng 1.6.16 [December 22, 2014]
+ * Last changed in libpng 1.6.16 [(PENDING RELEASE)]
  *
  * This code is released under the libpng license.
  * For conditions of distribution and use, see the disclaimer
@@ -14,8 +14,7 @@
  */
 #define _POSIX_SOURCE 1
 
-#include "../../pngpriv.h"
-#define PNG_SRC_FILE PNG_SRC_FILE_arm_arm_init
+#include "../pngpriv.h"
 
 #ifdef PNG_READ_SUPPORTED
 

arm/filter_neon.S

@@ -14,7 +14,7 @@
  * definitions (or not) of PNG_ARM_NEON_OPT and PNG_ARM_NEON_IMPLEMENTATION.
  */
 #define PNG_VERSION_INFO_ONLY
-#include "../../pngpriv.h"
+#include "../pngpriv.h"
 
 #if defined(__linux__) && defined(__ELF__)
 .section .note.GNU-stack,"",%progbits /* mark stack as non-executable */

arm/filter_neon_intrinsics.c

@@ -5,15 +5,14 @@
  * Written by James Yu <james.yu at linaro.org>, October 2013.
  * Based on filter_neon.S, written by Mans Rullgard, 2011.
  *
- * Last changed in libpng 1.6.16 [December 22, 2014]
+ * Last changed in libpng 1.6.16 [(PENDING RELEASE)]
  *
  * This code is released under the libpng license.
  * For conditions of distribution and use, see the disclaimer
  * and license in png.h
  */
 
-#include "../../pngpriv.h"
-#define PNG_SRC_FILE PNG_SRC_FILE_arm_filter_neon_intrinsics
+#include "../pngpriv.h"
 
 #ifdef PNG_READ_SUPPORTED
 
@@ -41,11 +40,11 @@
 #if PNG_ARM_NEON_OPT > 0
 
 void
-png_read_filter_row_up_neon(png_alloc_size_t rowbytes, unsigned int bpp,
-   png_bytep row, png_const_bytep prev_row)
+png_read_filter_row_up_neon(png_row_infop row_info, png_bytep row,
+   png_const_bytep prev_row)
 {
    png_bytep rp = row;
-   png_bytep rp_stop = row + rowbytes;
+   png_bytep rp_stop = row + row_info->rowbytes;
    png_const_bytep pp = prev_row;
 
    for (; rp < rp_stop; rp += 16, pp += 16)
@@ -57,15 +56,14 @@ png_read_filter_row_up_neon(png_alloc_size_t rowbytes, unsigned int bpp,
       qrp = vaddq_u8(qrp, qpp);
       vst1q_u8(rp, qrp);
    }
-
-   PNG_UNUSED(bpp)
 }
 
 void
-png_read_filter_row_sub3_neon(png_alloc_size_t rowbytes, unsigned int bpp, png_bytep row, png_const_bytep prev_row)
+png_read_filter_row_sub3_neon(png_row_infop row_info, png_bytep row,
+   png_const_bytep prev_row)
 {
    png_bytep rp = row;
-   png_bytep rp_stop = row + rowbytes;
+   png_bytep rp_stop = row + row_info->rowbytes;
 
    uint8x16_t vtmp = vld1q_u8(rp);
    uint8x8x2_t *vrpt = png_ptr(uint8x8x2_t, &vtmp);
@@ -102,16 +100,15 @@ png_read_filter_row_sub3_neon(png_alloc_size_t rowbytes, unsigned int bpp, png_b
       rp += 3;
    }
 
-   PNG_UNUSED(bpp)
    PNG_UNUSED(prev_row)
 }
 
 void
-png_read_filter_row_sub4_neon(png_alloc_size_t rowbytes, unsigned int bpp,
-   png_bytep row, png_const_bytep prev_row)
+png_read_filter_row_sub4_neon(png_row_infop row_info, png_bytep row,
+   png_const_bytep prev_row)
 {
    png_bytep rp = row;
-   png_bytep rp_stop = row + rowbytes;
+   png_bytep rp_stop = row + row_info->rowbytes;
 
    uint8x8x4_t vdest;
    vdest.val[3] = vdup_n_u8(0);
@@ -130,17 +127,16 @@ png_read_filter_row_sub4_neon(png_alloc_size_t rowbytes, unsigned int bpp,
       vst4_lane_u32(png_ptr(uint32_t,rp), png_ldr(uint32x2x4_t,&vdest), 0);
    }
 
-   PNG_UNUSED(bpp)
    PNG_UNUSED(prev_row)
 }
 
 void
-png_read_filter_row_avg3_neon(png_alloc_size_t rowbytes, unsigned int bpp,
-   png_bytep row, png_const_bytep prev_row)
+png_read_filter_row_avg3_neon(png_row_infop row_info, png_bytep row,
+   png_const_bytep prev_row)
 {
    png_bytep rp = row;
    png_const_bytep pp = prev_row;
-   png_bytep rp_stop = row + rowbytes;
+   png_bytep rp_stop = row + row_info->rowbytes;
 
    uint8x16_t vtmp;
    uint8x8x2_t *vrpt;
@@ -198,16 +194,14 @@ png_read_filter_row_avg3_neon(png_alloc_size_t rowbytes, unsigned int bpp,
       vst1_lane_u32(png_ptr(uint32_t,rp), png_ldr(uint32x2_t,&vdest.val[3]), 0);
       rp += 3;
    }
-
-   PNG_UNUSED(bpp)
 }
 
 void
-png_read_filter_row_avg4_neon(png_alloc_size_t rowbytes, unsigned int bpp,
-   png_bytep row, png_const_bytep prev_row)
+png_read_filter_row_avg4_neon(png_row_infop row_info, png_bytep row,
+   png_const_bytep prev_row)
 {
    png_bytep rp = row;
-   png_bytep rp_stop = row + rowbytes;
+   png_bytep rp_stop = row + row_info->rowbytes;
    png_const_bytep pp = prev_row;
 
    uint8x8x4_t vdest;
@@ -238,8 +232,6 @@ png_read_filter_row_avg4_neon(png_alloc_size_t rowbytes, unsigned int bpp,
 
       vst4_lane_u32(png_ptr(uint32_t,rp), png_ldr(uint32x2x4_t,&vdest), 0);
    }
-
-   PNG_UNUSED(bpp)
 }
 
 static uint8x8_t
@@ -270,12 +262,12 @@ paeth(uint8x8_t a, uint8x8_t b, uint8x8_t c)
 }
 
 void
-png_read_filter_row_paeth3_neon(png_alloc_size_t rowbytes, unsigned int bpp,
-   png_bytep row, png_const_bytep prev_row)
+png_read_filter_row_paeth3_neon(png_row_infop row_info, png_bytep row,
+   png_const_bytep prev_row)
 {
    png_bytep rp = row;
    png_const_bytep pp = prev_row;
-   png_bytep rp_stop = row + rowbytes;
+   png_bytep rp_stop = row + row_info->rowbytes;
 
    uint8x16_t vtmp;
    uint8x8x2_t *vrpt;
@@ -333,16 +325,14 @@ png_read_filter_row_paeth3_neon(png_alloc_size_t rowbytes, unsigned int bpp,
       vst1_lane_u32(png_ptr(uint32_t,rp), png_ldr(uint32x2_t,&vdest.val[3]), 0);
       rp += 3;
    }
-
-   PNG_UNUSED(bpp)
 }
 
 void
-png_read_filter_row_paeth4_neon(png_alloc_size_t rowbytes, unsigned int bpp,
-   png_bytep row, png_const_bytep prev_row)
+png_read_filter_row_paeth4_neon(png_row_infop row_info, png_bytep row,
+   png_const_bytep prev_row)
 {
    png_bytep rp = row;
-   png_bytep rp_stop = row + rowbytes;
+   png_bytep rp_stop = row + row_info->rowbytes;
    png_const_bytep pp = prev_row;
 
    uint8x8_t vlast = vdup_n_u8(0);
@@ -376,9 +366,8 @@ png_read_filter_row_paeth4_neon(png_alloc_size_t rowbytes, unsigned int bpp,
 
       vst4_lane_u32(png_ptr(uint32_t,rp), png_ldr(uint32x2x4_t,&vdest), 0);
    }
-
-   PNG_UNUSED(bpp)
 }
+
 #endif /* PNG_ARM_NEON_OPT > 0 */
 #endif /* PNG_ARM_NEON_IMPLEMENTATION == 1 (intrinsics) */
 #endif /* READ */

autogen.sh

@@ -73,13 +73,12 @@ done
 # present bad things are happening.
 #
 # The autotools generated files:
-libpng_autotools_files="Makefile.in aclocal.m4 config.guess config.h.in
-   config.sub configure depcomp install-sh ltmain.sh missing\
-   test-driver"
+libpng_autotools_files="Makefile.in aclocal.m4 config.guess config.h.in\
+   config.sub configure depcomp install-sh ltmain.sh missing test-driver"
 #
 # Files generated by versions of configue >2.68 or automake >1.13 (i.e. later
 # versions than those required by configure.ac):
-libpng_autotools_extra="compile config.h.in~"
+libpng_autotools_extra="compile"
 #
 # These are separate because 'maintainer-clean' does not remove them.
 libpng_libtool_files="scripts/libtool.m4 scripts/ltoptions.m4\

configure.ac

@@ -18,7 +18,7 @@ AC_PREREQ([2.68])
 
 dnl Version number stuff here:
 
-AC_INIT([libpng],[1.7.0beta73],[png-mng-implement@lists.sourceforge.net])
+AC_INIT([libpng],[1.6.16rc01],[png-mng-implement@lists.sourceforge.net])
 AC_CONFIG_MACRO_DIR([scripts])
 
 # libpng does not follow GNU file name conventions (hence 'foreign')
@@ -27,8 +27,7 @@ AC_CONFIG_MACRO_DIR([scripts])
 # dist-xz requires automake 1.11 or later
 # 1.12.2 fixes a security issue in 1.11.2 and 1.12.1
 # 1.13 is required for parallel tests
-# 1.14.1 is required for %reldir% support
-AM_INIT_AUTOMAKE([1.15 foreign dist-xz color-tests silent-rules subdir-objects])
+AM_INIT_AUTOMAKE([1.13 foreign dist-xz color-tests silent-rules subdir-objects])
 # The following line causes --disable-maintainer-mode to be the default to
 # configure, this is necessary because libpng distributions cannot rely on the
 # time stamps of the autotools generated files being correct
@@ -40,10 +39,10 @@ dnl automake, so the following is not necessary (and is not defined anyway):
 dnl AM_PREREQ([1.11.2])
 dnl stop configure from automagically running automake
 
-PNGLIB_VERSION=1.7.0beta73
+PNGLIB_VERSION=1.6.16rc01
 PNGLIB_MAJOR=1
-PNGLIB_MINOR=7
-PNGLIB_RELEASE=0
+PNGLIB_MINOR=6
+PNGLIB_RELEASE=16
 
 dnl End of version number stuff
 
@@ -61,10 +60,10 @@ AC_PROG_INSTALL
 AC_PROG_LN_S
 AC_PROG_MAKE_SET
 
-dnl libtool/libtoolize; version 2.4.4 is the tested version, this or any
+dnl libtool/libtoolize; version 2.4.2 is the tested version, this or any
 dnl compatible later version may be used
 LT_INIT([win32-dll])
-LT_PREREQ([2.4.4])
+LT_PREREQ([2.4.2])
 
 # Some awks crash when confronted with pnglibconf.dfa, do a test run now
 # to make sure this doesn't happen
@@ -80,7 +79,7 @@ fi
 
 # This is a remnant of the old cc -E validation, where it may have been
 # necessary to use a different preprocessor for .dfn files
-DFNCPP="$CPP -E"
+DFNCPP="$CPP"
 AC_SUBST(DFNCPP)
 
 # -Werror cannot be passed to GCC in CFLAGS because configure will fail (it
@@ -110,146 +109,30 @@ AC_ARG_ENABLE(werror,
 
 # Checks for header files.
 AC_HEADER_STDC
-# Headers used in pngpriv.h:
-AC_CHECK_HEADERS([assert.h stdlib.h string.h float.h fp.h math.h m68881.h])
-# Additional headers used in pngconf.h:
-AC_CHECK_HEADERS([limits.h stddef.h stdio.h setjmp.h time.h])
-# Used by pngread.c (for the simplified API):
-AC_CHECK_HEADERS([errno.h])
-# The following are not required for the standard 'make' build of libpng:
-# Additional requirements of contrib/libtests/makepng.c:
-AC_CHECK_HEADERS([ctype.h])
-# Additional requirements of contrib/libtests/pngvalid.c:
-AC_CHECK_HEADERS([fenv.h])
 
 # Checks for typedefs, structures, and compiler characteristics.
-# Most of these have been removed from 1.7.0 because they checked for non-ANSI-C
-# behaviors and the result were, anyway, not used by earlier versions of libpng.
+AC_C_CONST
+AC_TYPE_SIZE_T
+AC_STRUCT_TM
 AC_C_RESTRICT
 
-# Checks for library functions; these need to be in order, least demanding to
-# most because the -l directives are added to the head of the list at each
-# check.
-# ANSI-C functions: all are required but they don't have to be implemented in
-# libc, it is perfectly ok to configure with an extra, wrapper, library preset
-# in LIBS.  NOTE: this list may not be complete
-AC_CHECK_FUNCS([memset memcpy strncpy],,
-               AC_MSG_FAILURE([missing ANSI-C functions]))
-
-# floor and ceil are required for FLOATING_POINT, but they can be turned off on
-# the configure command line (and they are independent.)  Default is to 'on'
-AC_ARG_ENABLE([floating-point],
-   AS_HELP_STRING([[[--enabled-floating-point]]],
-      [Enable floating point APIs (default: yes)]),,
-   [enable_floating_point=yes])
-
-AC_ARG_ENABLE([fixed-point],
-   AS_HELP_STRING([[[--enable-fixed-point]]],
-      [Enable fixed point APIs (default: yes)]),,
-   [enable_fixed_point=yes])
-
-AC_ARG_ENABLE([floating-arithmetic],
-   AS_HELP_STRING([[[--enable-floating-arithmetic]]],
-      [Use floating point arithmetic internally (default: yes)]),,
-   [enable_floating_arithmetic=yes])
-
-# Check for a requirement for math library support
-if test "$enable_floating_arithmetic" = yes
-then
-   AC_SEARCH_LIBS([floor],[m],,
-                  [AC_MSG_WARN([not found])
-                   enable_floating_arithmetic=no])
-   AC_SEARCH_LIBS([frexp],[m],,
-                  [AC_MSG_WARN([not found])
-                   enable_floating_arithmetic=no])
-   AC_SEARCH_LIBS([modf],[m],,
-                  [AC_MSG_WARN([not found])
-                   enable_floating_arithmetic=no])
-   AC_SEARCH_LIBS([atof],[m],,
-                  [AC_MSG_WARN([not found])
-                   enable_floating_arithmetic=no])
-   AC_SEARCH_LIBS([pow],[m],,
-                  [AC_MSG_WARN([not found])
-                   enable_floating_arithmetic=no])
-fi
-
-# Set the relevant defines if required (only if required), this will override
-# anything on the command line.
-if test "$enable_floating_point" != yes
-then
-   AC_MSG_NOTICE([Floating point APIs disabled])
-   AC_DEFINE([PNG_NO_FLOATING_POINT],[1],
-             [No support for floating point APIs])
-fi
-if test "$enable_fixed_point" != yes
-then
-   AC_MSG_NOTICE([Fixed point APIs disabled])
-   AC_DEFINE([PNG_NO_FIXED_POINT],[1],
-             [No support for fixed point APIs])
-fi
-if test "$enable_floating_arithmetic" != yes
-then
-   AC_MSG_NOTICE([Fixed point arithmetic will be used])
-   AC_DEFINE([PNG_NO_FLOATING_ARITHMETIC],[1],
-             [No support for floating point arithmetic])
-fi
+# Checks for library functions.
+AC_FUNC_STRTOD
+AC_CHECK_FUNCS([memset], , AC_MSG_ERROR(memset not found in libc))
+AC_CHECK_FUNCS([pow], , AC_CHECK_LIB(m, pow, , AC_MSG_ERROR(cannot find pow)) )
+AC_ARG_WITH(zlib-prefix,
+   AS_HELP_STRING([[[--with-zlib-prefix]]],
+      [prefix that may have been used in installed zlib]),
+      [ZPREFIX=${withval}],
+      [ZPREFIX='z_'])
+AC_CHECK_LIB(z, zlibVersion, ,
+    AC_CHECK_LIB(z, ${ZPREFIX}zlibVersion, , AC_MSG_ERROR(zlib not installed)))
 
 # The following is for pngvalid, to ensure it catches FP errors even on
 # platforms that don't enable FP exceptions, the function appears in the math
 # library (typically), it's not an error if it is not found.
-AC_SEARCH_LIBS([feenableexcept],[m],AC_DEFINE([HAVE_FEENABLEEXCEPT],[1],
-      [Define to 1 if the feenableexcept function is available]))
-# Required by pngvalid:
-AC_SEARCH_LIBS([ceil],[m])
-
-# zlib checks and arguments;
-#  package zlib: argument is the name of the library
-#  zlib-header: the name of the header file
-#  zlib-prefix: the prefix for library functions, if any
-AC_ARG_WITH([zlib],
-   AS_HELP_STRING([[[--with-zlib=<name>]]],
-                  [base name of the zlib implementation (e.g. 'z')]),,
-   [with_zlib='z'])
-
-z_prefix=
-AC_ARG_WITH([zlib-prefix],
-   AS_HELP_STRING([[[--with-zlib-prefix=<prefix>]]],
-                  [prefix for zlib API functions]),
-   [if test "$withval" = "" -o "$withval" = yes; then
-      with_zlib_prefix='z_'
-      AC_DEFINE([PNG_ZLIB_PREFIX],[z_],[Standard zlib prefix])
-   elif test "${withval}" != "no"; then
-      AC_DEFINE_UNQUOTED([PNG_ZLIB_PREFIX],[${withval}],
-         [User defined zlib prefix])
-   else
-      with_zlib_prefix=
-   fi
-   if test "$with_zlib_prefix" != ""; then
-      AC_DEFINE([Z_PREFIX],[1],[Tell zlib.h to prefix function names])
-      z_prefix="#define Z_PREFIX 1"
-   fi])
-
-AC_ARG_WITH([zlib-header],
-   AS_HELP_STRING([[[--with-zlib-header='<file>' or '"file"']]],
-      [C include argument to locate zlib header file, e.g. <zlib.h>, take
-       care to put single quotes round this on the command line]),
-   [AC_DEFINE_UNQUOTED([PNG_ZLIB_HEADER],[${withval}],[Zlib header file])],
-   with_zlib_header='<zlib.h>')
-
-# AC_CHECK_LIB isn't quite enough for this because we need the special header
-# file too.
-LIBS="-l${with_zlib} $LIBS"
-AC_MSG_CHECKING(
-   [[Library '${with_zlib}' and #include ${with_zlib_header} for symbol '${with_zlib_prefix}zlibVersion']])
-AC_LINK_IFELSE(
-   [AC_LANG_PROGRAM(
-      [[
-${z_prefix}
-#include ${with_zlib_header}
-      ]],
-      [[(void)${with_zlib_prefix}zlibVersion();]])],
-   AC_MSG_RESULT([ok]),
-   AC_MSG_FAILURE([not found]))
+AC_CHECK_LIB([m], [feenableexcept])
+AC_CHECK_FUNCS([feenableexcept])
 
 AC_MSG_CHECKING([if using Solaris linker])
 SLD=`$LD --version 2>&1 | grep Solaris`
@@ -295,7 +178,7 @@ AM_CONDITIONAL(HAVE_LD_VERSION_SCRIPT, test "$have_ld_version_script" = "yes")
 if test "$have_ld_version_script" = "yes"; then
     AC_MSG_CHECKING([for symbol prefix])
     SYMBOL_PREFIX=`echo "PREFIX=__USER_LABEL_PREFIX__" \
-                  | ${DFNCPP-${CC-gcc -E}} - 2>&1 \
+                  | ${CPP-${CC-gcc} -E} - 2>&1 \
                   | ${EGREP-grep} "^PREFIX=" \
                   | ${SED-sed} -e "s:^PREFIX=::" -e "s:__USER_LABEL_PREFIX__::"`
     AC_SUBST(SYMBOL_PREFIX)
@@ -382,16 +265,60 @@ AC_ARG_ENABLE([unversioned-libpng-config],
 AM_CONDITIONAL([DO_INSTALL_LIBPNG_CONFIG],
    [test "$enable_unversioned_libpng_config" != "no"])
 
-# EXTENSIONS
-# Configure (and all other) support for extensions is included when autoconf is
-# run by virtue of the existence (or not) of the following file:
-sinclude([contrib/extensions.ac])
-AM_CONDITIONAL([LIBPNG_EXTENSIONS],[test -n "$libpng_automake_extensions"])
+# HOST SPECIFIC OPTIONS
+# =====================
+#
+# ARM
+# ===
+#
+# ARM NEON (SIMD) support.
+
+AC_ARG_ENABLE([arm-neon],
+   AS_HELP_STRING([[[--enable-arm-neon]]],
+      [Enable ARM NEON optimizations: =no/off, check, api, yes/on:]
+      [no/off: disable the optimizations; check: use internal checking code]
+      [(deprecated and poorly supported); api: disable by default, enable by]
+      [a call to png_set_option; yes/on: turn on unconditionally.]
+      [If not specified: determined by the compiler.]),
+   [case "$enableval" in
+      no|off)
+         # disable the default enabling on __ARM_NEON__ systems:
+         AC_DEFINE([PNG_ARM_NEON_OPT], [0],
+                   [Disable ARM Neon optimizations])
+         # Prevent inclusion of the assembler files below:
+         enable_arm_neon=no;;
+      check)
+         AC_DEFINE([PNG_ARM_NEON_CHECK_SUPPORTED], [],
+                   [Check for ARM Neon support at run-time]);;
+      api)
+         AC_DEFINE([PNG_ARM_NEON_API_SUPPORTED], [],
+                   [Turn on ARM Neon optimizations at run-time]);;
+      yes|on)
+         AC_DEFINE([PNG_ARM_NEON_OPT], [2],
+                   [Enable ARM Neon optimizations])
+         AC_MSG_WARN([--enable-arm-neon: please specify 'check' or 'api', if]
+            [you want the optimizations unconditionally pass -mfpu=neon]
+            [to the compiler.]);;
+      *)
+         AC_MSG_ERROR([--enable-arm-neon=${enable_arm_neon}: invalid value])
+   esac])
+
+# Add ARM specific files to all builds where the host_cpu is arm ('arm*') or
+# where ARM optimizations were explicitly requested (this allows a fallback if a
+# future host CPU does not match 'arm*')
+
+AM_CONDITIONAL([PNG_ARM_NEON],
+   [test "$enable_arm_neon" != 'no' &&
+    case "$host_cpu" in
+      arm*|aarch64*) :;;
+      *)    test "$enable_arm_neon" != '';;
+    esac])
 
 AC_MSG_NOTICE([[Extra options for compiler: $PNG_COPTS]])
 
 # Config files, substituting as above
-AC_CONFIG_FILES([Makefile libpng.pc])
-AC_CONFIG_FILES([libpng-config], [chmod +x libpng-config])
+AC_CONFIG_FILES([Makefile libpng.pc:libpng.pc.in])
+AC_CONFIG_FILES([libpng-config:libpng-config.in],
+   [chmod +x libpng-config])
 
 AC_OUTPUT

contrib/README.txt

@@ -1,5 +1,4 @@
 
 This "contrib" directory contains contributions which are not necessarily under
 the libpng license, although all are open source.  They are not part of
-libpng proper and are not used for building the library, although some are used
-for testing the library via "make check".
+libpng proper and are not used for building the library.

contrib/arm-neon/README

@@ -1,7 +1,7 @@
 OPERATING SYSTEM SPECIFIC ARM NEON DETECTION
 --------------------------------------------
 
-Detection of the ability to execute ARM NEON on an ARM processor requires
+Detection of the ability to exexcute ARM NEON on an ARM processor requires
 operating system support.  (The information is not available in user mode.)
 
 HOW TO USE THIS

contrib/arm-neon/linux-auxv.c

@@ -7,7 +7,7 @@
  * This code is released under the libpng license.
  * For conditions of distribution and use, see the disclaimer
  * and license in png.h
- *
+ * 
  * SEE contrib/arm-neon/README before reporting bugs
  *
  * STATUS: COMPILED, TESTED

contrib/arm-neon/linux.c

@@ -2,7 +2,7 @@
  *
  * Copyright (c) 2014 Glenn Randers-Pehrson
  * Written by John Bowler, 2014.
- * Last changed in libpng 1.6.16 [December 22, 2014]
+ * Last changed in libpng 1.6.16 [(PENDING RELEASE)]
  *
  * This code is released under the libpng license.
  * For conditions of distribution and use, see the disclaimer
@@ -72,7 +72,7 @@ png_have_neon(png_structp png_ptr)
                      state = Colon;
                   break;
                }
-
+               
                /* did not match 'feature' */
                state = SkipLine;
                /* FALL THROUGH */

contrib/examples/iccfrompng.c

@@ -26,10 +26,6 @@
 
 #include <png.h>
 
-#if defined(PNG_READ_SUPPORTED) && defined(PNG_STDIO_SUPPORTED) && \
-    defined (PNG_iCCP_SUPPORTED)
-
-
 static int verbose = 1;
 static png_byte no_profile[] = "no profile";
 
@@ -182,4 +178,3 @@ main(int argc, char **argv)
    /* Exit code is true if any extract succeeds */
    return extracted == 0;
 }
-#endif /* READ && STDIO && iCCP */

contrib/examples/pngpixel.c

@@ -27,8 +27,6 @@
  */
 #include "../../png.h"
 
-#if defined(PNG_READ_SUPPORTED) && defined(PNG_SEQUENTIAL_READ_SUPPORTED)
-
 /* Return component 'c' of pixel 'x' from the given row. */
 static unsigned int
 component(png_const_bytep row, png_uint_32 x, unsigned int c,
@@ -87,7 +85,7 @@ print_pixel(png_structp png_ptr, png_infop info_ptr, png_const_bytep row,
        */
       case PNG_COLOR_TYPE_PALETTE:
          {
-            PNG_CONST int index = component(row, x, 0, bit_depth, 1);
+            PNG_CONST unsigned int index = component(row, x, 0, bit_depth, 1);
             png_colorp palette = NULL;
             int num_palette = 0;
 
@@ -368,4 +366,3 @@ int main(int argc, const char **argv)
 
    return result;
 }
-#endif /* READ && SEQUENTIAL_READ */

contrib/examples/pngtopng.c

@@ -20,8 +20,6 @@
  * ensure the code picks up the local libpng implementation:
  */
 #include "../../png.h"
-#if defined(PNG_SIMPLIFIED_READ_SUPPORTED) && \
-    defined(PNG_SIMPLIFIED_WRITE_SUPPORTED)
 
 int main(int argc, const char **argv)
 {
@@ -92,4 +90,3 @@ int main(int argc, const char **argv)
 
    return result;
 }
-#endif /* READ && WRITE */

contrib/examples/simpleover.c

@@ -1,648 +0,0 @@
-/*- simpleover
- *
- * COPYRIGHT: Written by John Cunningham Bowler, 2015.
- * To the extent possible under law, the author has waived all copyright and
- * related or neighboring rights to this work.  This work is published from:
- * United States.
- *
- * Read several PNG files, which should have an alpha channel or transparency
- * information, and composite them together to produce one or more 16-bit linear
- * RGBA intermediates.  This involves doing the correct 'over' composition to
- * combine the alpha channels and corresponding data.
- *
- * Finally read an output (background) PNG using the 24-bit RGB format (the
- * PNG will be composited on green (#00ff00) by default if it has an alpha
- * channel), and apply the intermediate image generated above to specified
- * locations in the image.
- *
- * The command line has the general format:
- *
- *    simpleover <background.png> [output.png]
- *        {--sprite=width,height,name {[--at=x,y] {sprite.png}}}
- *        {--add=name {x,y}}
- *
- * The --sprite and --add options may occur multiple times. They are executed
- * in order.  --add may refer to any sprite already read.
- *
- * This code is intended to show how to composite multiple images together
- * correctly.  Apart from the libpng Simplified API the only work done in here
- * is to combine multiple input PNG images into a single sprite; this involves
- * a Porter-Duff 'over' operation and the input PNG images may, as a result,
- * be regarded as being layered one on top of the other with the first (leftmost
- * on the command line) being at the bottom and the last on the top.
- */
-#include <stddef.h>
-#include <stdlib.h>
-#include <string.h>
-#include <stdio.h>
-#include <errno.h>
-
-/* Normally use <png.h> here to get the installed libpng, but this is done to
- * ensure the code picks up the local libpng implementation, so long as this
- * file is linked against a sufficiently recent libpng (1.6+) it is ok to
- * change this to <png.h>:
- */
-#include "../../png.h"
-
-#ifdef PNG_SIMPLIFIED_READ_SUPPORTED
-
-#define sprite_name_chars 15
-struct sprite {
-   FILE         *file;
-   png_uint_16p  buffer;
-   unsigned int  width;
-   unsigned int  height;
-   char          name[sprite_name_chars+1];
-};
-
-#if 0 /* div by 65535 test program */
-#include <math.h>
-#include <stdio.h>
-
-int main(void) {
-   double err = 0;
-   unsigned int xerr = 0;
-   unsigned int r = 32769;
-   {
-      unsigned int x = 0;
-
-      do {
-         unsigned int t = x + (x >> 16) /*+ (x >> 31)*/ + r;
-         double v = x, errtest;
-
-         if (t < x) {
-            fprintf(stderr, "overflow: %u+%u -> %u\n", x, r, t);
-            return 1;
-         }
-
-         v /= 65535;
-         errtest = v;
-         t >>= 16;
-         errtest -= t;
-
-         if (errtest > err) {
-            err = errtest;
-            xerr = x;
-
-            if (errtest >= .5) {
-               fprintf(stderr, "error: %u/65535 = %f, not %u, error %f\n",
-                     x, v, t, errtest);
-               return 0;
-            }
-         }
-      } while (++x <= 65535U*65535U);
-   }
-
-   printf("error %f @ %u\n", err, xerr);
-
-   return 0;
-}
-#endif /* div by 65535 test program */
-
-static void
-sprite_op(const struct sprite *sprite, int x_offset, int y_offset,
-   png_imagep image, const png_uint_16 *buffer)
-{
-   /* This is where the Porter-Duff 'Over' operator is evaluated; change this
-    * code to change the operator (this could be parameterized).  Any other
-    * image processing operation could be used here.
-    */
-
-
-   /* Check for an x or y offset that pushes any part of the image beyond the
-    * right or bottom of the sprite:
-    */
-   if ((y_offset < 0 || (unsigned)/*SAFE*/y_offset < sprite->height) &&
-       (x_offset < 0 || (unsigned)/*SAFE*/x_offset < sprite->width))
-   {
-      unsigned int y = 0;
-
-      if (y_offset < 0)
-         y = -y_offset; /* Skip to first visible row */
-
-      do
-      {
-         unsigned int x = 0;
-
-         if (x_offset < 0)
-            x = -x_offset;
-
-         do
-         {
-            /* In and out are RGBA values, so: */
-            const png_uint_16 *in_pixel = buffer + (y * image->width + x)*4;
-            png_uint_32 in_alpha = in_pixel[3];
-
-            /* This is the optimized Porter-Duff 'Over' operation, when the
-             * input alpha is 0 the output is not changed.
-             */
-            if (in_alpha > 0)
-            {
-               png_uint_16 *out_pixel = sprite->buffer +
-                  ((y+y_offset) * sprite->width + (x+x_offset))*4;
-
-               /* This is the weight to apply to the output: */
-               in_alpha = 65535-in_alpha;
-
-               if (in_alpha > 0)
-               {
-                  /* The input must be composed onto the output. This means
-                   * multiplying the current output pixel value by the inverse
-                   * of the input alpha (1-alpha). A division is required but
-                   * it is by the constant 65535.  Approximate this as:
-                   *
-                   *     (x + (x >> 16) + 32769) >> 16;
-                   *
-                   * This is exact (and does not overflow) for all values of
-                   * x in the range 0..65535*65535.  (Note that the calculation
-                   * produces the closest integer; the maximum error is <0.5).
-                   */
-                  png_uint_32 tmp;
-
-#                 define compose(c)\
-                     tmp = out_pixel[c] * in_alpha;\
-                     tmp = (tmp + (tmp >> 16) + 32769) >> 16;\
-                     out_pixel[c] = tmp + in_pixel[c]
-
-                  /* The following is very vectorizable... */
-                  compose(0);
-                  compose(1);
-                  compose(2);
-                  compose(3);
-               }
-
-               else
-                  out_pixel[0] = in_pixel[0],
-                  out_pixel[1] = in_pixel[1],
-                  out_pixel[2] = in_pixel[2],
-                  out_pixel[3] = in_pixel[3];
-            }
-         }
-         while (++x < image->width);
-      }
-      while (++y < image->height);
-   }
-}
-
-static int
-create_sprite(struct sprite *sprite, int *argc, const char ***argv)
-{
-   /* Read the arguments and create this sprite. The sprite buffer has already
-    * been allocated. This reads the input PNGs one by one in linear format,
-    * composes them onto the sprite buffer (the code in the function above)
-    * then saves the result, converting it on the fly to PNG RGBA 8-bit format.
-    */
-   while (*argc > 0)
-   {
-      char tombstone;
-      int x = 0, y = 0;
-
-      if ((*argv)[0][0] == '-' && (*argv)[0][1] == '-')
-      {
-         /* The only supported option is --at. */
-         if (sscanf((*argv)[0], "--at=%d,%d%c", &x, &y, &tombstone) != 2)
-            break; /* success; caller will parse this option */
-
-         ++*argv, --*argc;
-      }
-
-      else
-      {
-         /* The argument has to be a file name */
-         png_image image;
-
-         image.version = PNG_IMAGE_VERSION;
-         image.opaque = NULL;
-
-         if (png_image_begin_read_from_file(&image, (*argv)[0]))
-         {
-            png_uint_16p buffer;
-
-            image.format = PNG_FORMAT_LINEAR_RGB_ALPHA;
-
-            buffer = malloc(PNG_IMAGE_SIZE(image));
-
-            if (buffer != NULL)
-            {
-               if (png_image_finish_read(&image, NULL/*background*/, buffer,
-                  0/*row_stride*/,
-                  NULL/*colormap for PNG_FORMAT_FLAG_COLORMAP*/))
-               {
-                  /* This is the place where the Porter-Duff 'Over' operator
-                   * needs to be done by this code.  In fact, any image
-                   * processing required can be done here; the data is in
-                   * the correct format (linear, 16-bit) and source and
-                   * destination are in memory.
-                   */
-                  sprite_op(sprite, x, y, &image, buffer);
-                  free(buffer);
-                  ++*argv, --*argc;
-                  /* And continue to the next argument */
-                  continue;
-               }
-
-               else
-               {
-                  free(buffer);
-                  fprintf(stderr, "simpleover: read %s: %s\n", (*argv)[0],
-                      image.message);
-               }
-            }
-
-            else
-            {
-               fprintf(stderr, "simpleover: out of memory: %lu bytes\n",
-                  (unsigned long)PNG_IMAGE_SIZE(image));
-
-               /* png_image_free must be called if we abort the Simplified API
-                * read because of a problem detected in this code.  If problems
-                * are detected in the Simplified API it cleans up itself.
-                */
-               png_image_free(&image);
-            }
-         }
-
-         else
-         {
-            /* Failed to read the first argument: */
-            fprintf(stderr, "simpleover: %s: %s\n", (*argv)[0], image.message);
-         }
-
-         return 0; /* failure */
-      }
-   }
-
-   /* All the sprite operations have completed successfully. Save the RGBA
-    * buffer as a PNG using the simplified write API.
-    */
-   sprite->file = tmpfile();
-
-   if (sprite->file != NULL)
-   {
-      png_image save;
-
-      memset(&save, 0, sizeof save);
-      save.version = PNG_IMAGE_VERSION;
-      save.opaque = NULL;
-      save.width = sprite->width;
-      save.height = sprite->height;
-      save.format = PNG_FORMAT_LINEAR_RGB_ALPHA;
-      save.flags = PNG_IMAGE_FLAG_FAST;
-      save.colormap_entries = 0;
-
-      if (png_image_write_to_stdio(&save, sprite->file, 1/*convert_to_8_bit*/,
-          sprite->buffer, 0/*row_stride*/, NULL/*colormap*/))
-      {
-         /* Success; the buffer is no longer needed: */
-         free(sprite->buffer);
-         sprite->buffer = NULL;
-         return 1; /* ok */
-      }
-
-      else
-         fprintf(stderr, "simpleover: write sprite %s: %s\n", sprite->name,
-            save.message);
-   }
-
-   else
-      fprintf(stderr, "simpleover: sprite %s: could not allocate tmpfile: %s\n",
-         sprite->name, strerror(errno));
-
-   return 0; /* fail */
-}
-
-static int
-add_sprite(png_imagep output, png_bytep out_buf, struct sprite *sprite,
-   int *argc, const char ***argv)
-{
-   /* Given a --add argument naming this sprite, perform the operations listed
-    * in the following arguments.  The arguments are expected to have the form
-    * (x,y), which is just an offset at which to add the sprite to the
-    * output.
-    */
-   while (*argc > 0)
-   {
-      char tombstone;
-      int x, y;
-
-      if ((*argv)[0][0] == '-' && (*argv)[0][1] == '-')
-         return 1; /* success */
-
-      if (sscanf((*argv)[0], "%d,%d%c", &x, &y, &tombstone) == 2)
-      {
-         /* Now add the new image into the sprite data, but only if it
-          * will fit.
-          */
-         if (x < 0 || y < 0 ||
-             (unsigned)/*SAFE*/x >= output->width ||
-             (unsigned)/*SAFE*/y >= output->height ||
-             sprite->width > output->width-x ||
-             sprite->height > output->height-y)
-         {
-            fprintf(stderr, "simpleover: sprite %s @ (%d,%d) outside image\n",
-               sprite->name, x, y);
-            /* Could just skip this, but for the moment it is an error */
-            return 0; /* error */
-         }
-
-         else
-         {
-            /* Since we know the sprite fits we can just read it into the
-             * output using the simplified API.
-             */
-            png_image in;
-
-            in.version = PNG_IMAGE_VERSION;
-            rewind(sprite->file);
-
-            if (png_image_begin_read_from_stdio(&in, sprite->file))
-            {
-               in.format = PNG_FORMAT_RGB; /* force compose */
-
-               if (png_image_finish_read(&in, NULL/*background*/,
-                  out_buf + (y*output->width + x)*3/*RGB*/,
-                  output->width*3/*row_stride*/,
-                  NULL/*colormap for PNG_FORMAT_FLAG_COLORMAP*/))
-               {
-                  ++*argv, --*argc;
-                  continue;
-               }
-            }
-
-            /* The read failed: */
-            fprintf(stderr, "simpleover: add sprite %s: %s\n", sprite->name,
-                in.message);
-            return 0; /* error */
-         }
-      }
-
-      else
-      {
-         fprintf(stderr, "simpleover: --add='%s': invalid position %s\n",
-               sprite->name, (*argv)[0]);
-         return 0; /* error */
-      }
-   }
-
-   return 1; /* ok */
-}
-
-static int
-simpleover_process(png_imagep output, png_bytep out_buf, int argc,
-   const char **argv)
-{
-   int result = 1; /* success */
-#  define csprites 10/*limit*/
-#  define str(a) #a
-   int nsprites = 0;
-   struct sprite sprites[csprites];
-
-   while (argc > 0)
-   {
-      result = 0; /* fail */
-
-      if (strncmp(argv[0], "--sprite=", 9) == 0)
-      {
-         char tombstone;
-
-         if (nsprites < csprites)
-         {
-            int n;
-
-            sprites[nsprites].width = sprites[nsprites].height = 0;
-            sprites[nsprites].name[0] = 0;
-
-            n = sscanf(argv[0], "--sprite=%u,%u,%" str(sprite_name_chars) "s%c",
-                &sprites[nsprites].width, &sprites[nsprites].height,
-                sprites[nsprites].name, &tombstone);
-
-            if ((n == 2 || n == 3) &&
-                sprites[nsprites].width > 0 && sprites[nsprites].height > 0)
-            {
-               size_t buf_size, tmp;
-
-               /* Default a name if not given. */
-               if (sprites[nsprites].name[0] == 0)
-                  sprintf(sprites[nsprites].name, "sprite-%d", nsprites+1);
-
-               /* Allocate a buffer for the sprite and calculate the buffer
-                * size:
-                */
-               buf_size = sizeof (png_uint_16 [4]);
-               buf_size *= sprites[nsprites].width;
-               buf_size *= sprites[nsprites].height;
-
-               /* This can overflow a (size_t); check for this: */
-               tmp = buf_size;
-               tmp /= sprites[nsprites].width;
-               tmp /= sprites[nsprites].height;
-
-               if (tmp == sizeof (png_uint_16 [4]))
-               {
-                  sprites[nsprites].buffer = malloc(buf_size);
-                  /* This buffer must be initialized to transparent: */
-                  memset(sprites[nsprites].buffer, 0, buf_size);
-
-                  if (sprites[nsprites].buffer != NULL)
-                  {
-                     sprites[nsprites].file = NULL;
-                     ++argv, --argc;
-
-                     if (create_sprite(sprites+nsprites++, &argc, &argv))
-                     {
-                        result = 1; /* still ok */
-                        continue;
-                     }
-
-                     break; /* error */
-                  }
-               }
-
-               /* Overflow, or OOM */
-               fprintf(stderr, "simpleover: %s: sprite too large\n", argv[0]);
-               break;
-            }
-
-            else
-            {
-               fprintf(stderr, "simpleover: %s: invalid sprite (%u,%u)\n",
-                  argv[0], sprites[nsprites].width, sprites[nsprites].height);
-               break;
-            }
-         }
-
-         else
-         {
-            fprintf(stderr, "simpleover: %s: too many sprites\n", argv[0]);
-            break;
-         }
-      }
-
-      else if (strncmp(argv[0], "--add=", 6) == 0)
-      {
-         const char *name = argv[0]+6;
-         int isprite = nsprites;
-
-         ++argv, --argc;
-
-         while (--isprite >= 0)
-         {
-            if (strcmp(sprites[isprite].name, name) == 0)
-            {
-               if (!add_sprite(output, out_buf, sprites+isprite, &argc, &argv))
-                  goto out; /* error in add_sprite */
-
-               break;
-            }
-         }
-
-         if (isprite < 0) /* sprite not found */
-         {
-            fprintf(stderr, "simpleover: --add='%s': sprite not found\n", name);
-            break;
-         }
-      }
-
-      else
-      {
-         fprintf(stderr, "simpleover: %s: unrecognized operation\n", argv[0]);
-         break;
-      }
-
-      result = 1; /* ok  */
-   }
-
-   /* Clean up the cache of sprites: */
-out:
-   while (--nsprites >= 0)
-   {
-      if (sprites[nsprites].buffer != NULL)
-         free(sprites[nsprites].buffer);
-
-      if (sprites[nsprites].file != NULL)
-         (void)fclose(sprites[nsprites].file);
-   }
-
-   return result;
-}
-
-int main(int argc, const char **argv)
-{
-   int result = 1; /* default to fail */
-
-   if (argc >= 2)
-   {
-      int argi = 2;
-      const char *output = NULL;
-      png_image image;
-
-      if (argc > 2 && argv[2][0] != '-'/*an operation*/)
-      {
-         output = argv[2];
-         argi = 3;
-      }
-
-      image.version = PNG_IMAGE_VERSION;
-      image.opaque = NULL;
-
-      if (png_image_begin_read_from_file(&image, argv[1]))
-      {
-         png_bytep buffer;
-
-         image.format = PNG_FORMAT_RGB; /* 24-bit RGB */
-
-         buffer = malloc(PNG_IMAGE_SIZE(image));
-
-         if (buffer != NULL)
-         {
-            png_color background = {0, 0xff, 0}; /* fully saturated green */
-
-            if (png_image_finish_read(&image, &background, buffer,
-               0/*row_stride*/, NULL/*colormap for PNG_FORMAT_FLAG_COLORMAP */))
-            {
-               /* At this point png_image_finish_read has cleaned up the
-                * allocated data in png_image, and only the buffer needs to be
-                * freed.
-                *
-                * Perform the remaining operations:
-                */
-               if (simpleover_process(&image, buffer, argc-argi, argv+argi))
-               {
-                  /* Write the output: */
-                  if ((output != NULL &&
-                       png_image_write_to_file(&image, output,
-                        0/*convert_to_8bit*/, buffer, 0/*row_stride*/,
-                        NULL/*colormap*/)) ||
-                      (output == NULL &&
-                       png_image_write_to_stdio(&image, stdout,
-                        0/*convert_to_8bit*/, buffer, 0/*row_stride*/,
-                        NULL/*colormap*/)))
-                     result = 0;
-
-                  else
-                     fprintf(stderr, "simpleover: write %s: %s\n",
-                        output == NULL ? "stdout" : output, image.message);
-               }
-
-               /* else simpleover_process writes an error message */
-            }
-
-            else
-               fprintf(stderr, "simpleover: read %s: %s\n", argv[1],
-                   image.message);
-
-            free(buffer);
-         }
-
-         else
-         {
-            fprintf(stderr, "simpleover: out of memory: %lu bytes\n",
-               (unsigned long)PNG_IMAGE_SIZE(image));
-
-            /* This is the only place where a 'free' is required; libpng does
-             * the cleanup on error and success, but in this case we couldn't
-             * complete the read because of running out of memory.
-             */
-            png_image_free(&image);
-         }
-      }
-
-      else
-      {
-         /* Failed to read the first argument: */
-         fprintf(stderr, "simpleover: %s: %s\n", argv[1], image.message);
-      }
-   }
-
-   else
-   {
-      /* Usage message */
-      fprintf(stderr,
-         "simpleover: usage: simpleover background.png [output.png]\n"
-         "  Output 'background.png' as a 24-bit RGB PNG file in 'output.png'\n"
-         "   or, if not given, stdout.  'background.png' will be composited\n"
-         "   on fully saturated green.\n"
-         "\n"
-         "  Optionally, before output, process additional PNG files:\n"
-         "\n"
-         "   --sprite=width,height,name {[--at=x,y] {sprite.png}}\n"
-         "    Produce a transparent sprite of size (width,height) and with\n"
-         "     name 'name'.\n"
-         "    For each sprite.png composite it using a Porter-Duff 'Over'\n"
-         "     operation at offset (x,y) in the sprite (defaulting to (0,0)).\n"
-         "     Input PNGs will be truncated to the area of the sprite.\n"
-         "\n"
-         "   --add='name' {x,y}\n"
-         "    Optionally, before output, composite a sprite, 'name', which\n"
-         "     must have been previously produced using --sprite, at each\n"
-         "     offset (x,y) in the output image.  Each sprite must fit\n"
-         "     completely within the output image.\n"
-         "\n"
-         "  PNG files are processed in the order they occur on the command\n"
-         "  line and thus the first PNG processed appears as the bottommost\n"
-         "  in the output image.\n");
-   }
-
-   return result;
-}
-#endif /* SIMPLIFIED_READ */

contrib/extensions.ac

@@ -1,16 +0,0 @@
-# CONTRIBUTED EXTENSIONS
-#
-# The following extensions are part of a standard libpng distribution.  They are
-# not supported parts of libpng and they are not necessarily released under the
-# same license as libpng.  Please consult the relevant directory for copyright
-# and support information before uncommenting any of the lines below.
-#
-# After you change this file you MUST re-run "autoreconf" to regenerate the
-# configure script, otherwise the change may have no effect.
-#
-# Include the ARM NEON extension:
-#sinclude([contrib/neon/neon.ac])
-#
-# If any of the extensions require automake support (this is likely) automake
-# must include the file contrib/extensions.am
-#libpng_automake_extensions="yes"

contrib/extensions.am

@@ -1,7 +0,0 @@
-# CONTRIBUTED EXTENSIONS
-#
-# Please read the file "contrib/extensions.ac" before making changes to this
-# file.
-#
-# Include the ARM NEON extension:
-#include %reldir%/neon/neon.am

contrib/gregbook/Makefile.sgi

@@ -23,9 +23,9 @@
 
 # macros --------------------------------------------------------------------
 
-PNGINC = -I/usr/local/include/libpng17
-PNGLIB = -L/usr/local/lib -lpng17	  # dynamically linked against libpng
-#PNGLIB = /usr/local/lib/libpng17.a # statically linked against libpng
+PNGINC = -I/usr/local/include/libpng16
+PNGLIB = -L/usr/local/lib -lpng16	  # dynamically linked against libpng
+#PNGLIB = /usr/local/lib/libpng16.a # statically linked against libpng
 # or:
 #PNGINC = -I../..
 #PNGLIB = -L../.. -lpng

contrib/gregbook/Makefile.unx

@@ -26,14 +26,14 @@
 # macros --------------------------------------------------------------------
 
 #PNGDIR = /usr/local/lib
-#PNGINC = -I/usr/local/include/libpng17
-#PNGLIBd = -L$(PNGDIR) -lpng17 # dynamically linked, installed libpng
-#PNGLIBs = $(PNGDIR)/libpng17.a # statically linked, installed libpng
+#PNGINC = -I/usr/local/include/libpng16
+#PNGLIBd = -L$(PNGDIR) -lpng16 # dynamically linked, installed libpng
+#PNGLIBs = $(PNGDIR)/libpng16.a # statically linked, installed libpng
 # or:
 PNGDIR = ../..#	this one is for libpng-x.y.z/contrib/gregbook builds
 #PNGDIR = ../libpng
 PNGINC = -I$(PNGDIR)
-PNGLIBd = -Wl,-rpath,$(PNGDIR) -L$(PNGDIR) -lpng17	# dynamically linked
+PNGLIBd = -Wl,-rpath,$(PNGDIR) -L$(PNGDIR) -lpng16	# dynamically linked
 PNGLIBs = $(PNGDIR)/libpng.a		# statically linked, local libpng
 
 ZDIR = /usr/local/lib
@@ -59,15 +59,16 @@ INCS = $(PNGINC) $(ZINC) $(XINC)
 RLIBSd = $(PNGLIBd) $(ZLIBd) $(XLIB) -lm
 RLIBSs = $(PNGLIBs) $(ZLIBs) $(XLIB) -lm
 WLIBSd = $(PNGLIBd) $(ZLIBd) -lm
-WLIBSs = $(PNGLIBs) $(ZLIBs)
+WLIBSs = $(PNGLIBs) $(ZLIBs) -lm
 
 CC = gcc
 LD = gcc
 RM = rm -f
 CPPFLAGS = $(INCS) -DFEATURE_LOOP
 CFLAGS = -O -Wall
+#CFLAGS = -O -W -Wall -Wextra -pedantic -ansi
 # [note that -Wall is a gcc-specific compilation flag ("most warnings on")]
-# [-ansi, -pedantic and -W can also be used]
+# [-ansi, -pedantic, -Wextra, and -W can also be used]
 LDFLAGS =
 O = .o
 E =

contrib/gregbook/readpng.c

@@ -100,7 +100,8 @@ int readpng_init(FILE *infile, ulg *pWidth, ulg *pHeight)
 
     /* could pass pointers to user-defined error handlers instead of NULLs: */
 
-    png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
+    png_ptr = png_create_read_struct(png_get_libpng_ver(NULL), NULL, NULL,
+        NULL);
     if (!png_ptr)
         return 4;   /* out of memory */
 

contrib/gregbook/readpng2.c

@@ -4,7 +4,7 @@
 
   ---------------------------------------------------------------------------
 
-      Copyright (c) 1998-2015 Greg Roelofs.  All rights reserved.
+      Copyright (c) 1998-2007 Greg Roelofs.  All rights reserved.
 
       This software is provided "as is," without warranty of any kind,
       express or implied.  In no event shall the author or contributors
@@ -51,11 +51,6 @@
       along with this program; if not, write to the Free Software Foundation,
       Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
-  ---------------------------------------------------------------------------
-
-   Changelog:
-     %RDATE% - Check return value of png_get_bKGD() (Glenn R-P)
-
   ---------------------------------------------------------------------------*/
 
 
@@ -266,38 +261,36 @@ static void readpng2_info_callback(png_structp png_ptr, png_infop info_ptr)
     /* since we know we've read all of the PNG file's "header" (i.e., up
      * to IDAT), we can check for a background color here */
 
-    if (mainprog_ptr->need_bgcolor)
+    if (mainprog_ptr->need_bgcolor &&
+        png_get_valid(png_ptr, info_ptr, PNG_INFO_bKGD))
     {
         png_color_16p pBackground;
 
         /* it is not obvious from the libpng documentation, but this function
          * takes a pointer to a pointer, and it always returns valid red,
          * green and blue values, regardless of color_type: */
-        if (png_get_bKGD(png_ptr, info_ptr, &pBackground))
-        {
+        png_get_bKGD(png_ptr, info_ptr, &pBackground);
 
-           /* however, it always returns the raw bKGD data, regardless of any
-            * bit-depth transformations, so check depth and adjust if necessary
-            */
-           if (bit_depth == 16) {
-               mainprog_ptr->bg_red   = pBackground->red   >> 8;
-               mainprog_ptr->bg_green = pBackground->green >> 8;
-               mainprog_ptr->bg_blue  = pBackground->blue  >> 8;
-           } else if (color_type == PNG_COLOR_TYPE_GRAY && bit_depth < 8) {
-               if (bit_depth == 1)
-                   mainprog_ptr->bg_red = mainprog_ptr->bg_green =
-                     mainprog_ptr->bg_blue = pBackground->gray? 255 : 0;
-               else if (bit_depth == 2)
-                   mainprog_ptr->bg_red = mainprog_ptr->bg_green =
-                     mainprog_ptr->bg_blue = (255/3) * pBackground->gray;
-               else /* bit_depth == 4 */
-                   mainprog_ptr->bg_red = mainprog_ptr->bg_green =
-                     mainprog_ptr->bg_blue = (255/15) * pBackground->gray;
-           } else {
-               mainprog_ptr->bg_red   = (uch)pBackground->red;
-               mainprog_ptr->bg_green = (uch)pBackground->green;
-               mainprog_ptr->bg_blue  = (uch)pBackground->blue;
-           }
+        /* however, it always returns the raw bKGD data, regardless of any
+         * bit-depth transformations, so check depth and adjust if necessary */
+        if (bit_depth == 16) {
+            mainprog_ptr->bg_red   = pBackground->red   >> 8;
+            mainprog_ptr->bg_green = pBackground->green >> 8;
+            mainprog_ptr->bg_blue  = pBackground->blue  >> 8;
+        } else if (color_type == PNG_COLOR_TYPE_GRAY && bit_depth < 8) {
+            if (bit_depth == 1)
+                mainprog_ptr->bg_red = mainprog_ptr->bg_green =
+                  mainprog_ptr->bg_blue = pBackground->gray? 255 : 0;
+            else if (bit_depth == 2)
+                mainprog_ptr->bg_red = mainprog_ptr->bg_green =
+                  mainprog_ptr->bg_blue = (255/3) * pBackground->gray;
+            else /* bit_depth == 4 */
+                mainprog_ptr->bg_red = mainprog_ptr->bg_green =
+                  mainprog_ptr->bg_blue = (255/15) * pBackground->gray;
+        } else {
+            mainprog_ptr->bg_red   = (uch)pBackground->red;
+            mainprog_ptr->bg_green = (uch)pBackground->green;
+            mainprog_ptr->bg_blue  = (uch)pBackground->blue;
         }
     }
 

contrib/gregbook/rpng-x.c

@@ -26,6 +26,8 @@
     - 1.14:  added support for X resources (thanks to Gerhard Niklasch)
     - 2.00:  dual-licensed (added GNU GPL)
     - 2.01:  fixed improper display of usage screen on PNG error(s)
+    - 2.02:  Added "void(argc);" statement to quiet pedantic compiler warnings
+             about unused variable (GR-P)
 
   ---------------------------------------------------------------------------
 
@@ -80,7 +82,7 @@
 
 #define PROGNAME  "rpng-x"
 #define LONGNAME  "Simple PNG Viewer for X"
-#define VERSION   "2.01 of 16 March 2008"
+#define VERSION   "2.02 of 15 June 2014"
 #define RESNAME   "rpng"        /* our X resource application name */
 #define RESCLASS  "Rpng"        /* our X resource class name */
 
@@ -279,15 +281,17 @@ int main(int argc, char **argv)
           "Usage:  %s [-display xdpy] [-gamma exp] [-bgcolor bg] file.png\n"
           "    xdpy\tname of the target X display (e.g., ``hostname:0'')\n"
           "    exp \ttransfer-function exponent (``gamma'') of the display\n"
-          "\t\t  system in floating-point format (e.g., ``%.1f''); equal\n"
+          "\t\t  system in floating-point format (e.g., ``%.1f''); equal\n",
+          PROGNAME, default_display_exponent);
+
+        fprintf(stderr, "\n"
           "\t\t  to the product of the lookup-table exponent (varies)\n"
           "\t\t  and the CRT exponent (usually 2.2); must be positive\n"
           "    bg  \tdesired background color in 7-character hex RGB format\n"
           "\t\t  (e.g., ``#ff7700'' for orange:  same as HTML colors);\n"
           "\t\t  used with transparent images\n"
           "\nPress Q, Esc or mouse button 1 (within image window, after image\n"
-          "is displayed) to quit.\n"
-          "\n", PROGNAME, default_display_exponent);
+          "is displayed) to quit.\n");
         exit(1);
     }
 
@@ -419,6 +423,8 @@ int main(int argc, char **argv)
 
     rpng_x_cleanup();
 
+    (void)argc; /* Unused */
+
     return 0;
 }
 

contrib/gregbook/rpng2-win.c

@@ -33,6 +33,8 @@
     - 2.02:  fixed improper display of usage screen on PNG error(s); fixed
               unexpected-EOF and file-read-error cases
     - 2.03:  removed runtime MMX-enabling/disabling and obsolete -mmx* options
+    - 2.04:  
+             (GR-P)
 
   ---------------------------------------------------------------------------
 

contrib/gregbook/rpng2-x.c

@@ -43,10 +43,12 @@
     - 2.03:  deleted runtime MMX-enabling/disabling and obsolete -mmx* options
     - 2.04:  Added "void(foo);" statements to quiet pedantic compiler warnings
              about unused variables (GR-P)
-    - 2.05:  Use nanosleep() instead of usleep(), which is deprecated (GR-P).
+
+  TO DO:
+             use nanosleep() instead of usleep(), which is obsolete/deprecated.
   ---------------------------------------------------------------------------
 
-      Copyright (c) 1998-2010, 2014-2015 Greg Roelofs.  All rights reserved.
+      Copyright (c) 1998-2008 Greg Roelofs.  All rights reserved.
 
       This software is provided "as is," without warranty of any kind,
       express or implied.  In no event shall the author or contributors
@@ -117,7 +119,6 @@
 # undef usleep
 # define usleep(usec) {        \
    struct timespec ts;         \
-   ts.tv_sec = 0;              \
    ts.tv_nsec = (usec) * 1000; \
    nanosleep(&ts, NULL); }
 #  endif
@@ -496,12 +497,12 @@ int main(int argc, char **argv)
           "\t\t  transparent images; overrides -bgcolor\n",
           num_bgpat-1);
 #ifdef FEATURE_LOOP
-        fprintf(stderr,
+        fprintf(stderr, 
           "    -loop\tloops through background images after initial display\n"
           "\t\t  is complete (depends on -bgpat)\n"
           "    sec \tseconds to display each background image (default = 2)\n");
 #endif
-        fprintf(stderr,
+        fprintf(stderr, 
           "    dur \tduration in microseconds to wait after displaying each\n"
           "\t\t  row (for demo purposes)\n"
           "    -timing\tenables delay for every block read, to simulate modem\n"

contrib/gregbook/writepng.c

@@ -90,7 +90,7 @@ int writepng_init(mainprog_info *mainprog_ptr)
 
     /* could also replace libpng warning-handler (final NULL), but no need: */
 
-    png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, mainprog_ptr,
+    png_ptr = png_create_write_struct(png_get_libpng_ver(NULL), mainprog_ptr,
       writepng_error_handler, NULL);
     if (!png_ptr)
         return 4;   /* out of memory */

contrib/libtests/fakepng.c

@@ -1,12 +1,4 @@
-/* Fake a PNG - just write it out directly.
- *
- * COPYRIGHT: Written by John Cunningham Bowler, 2014.
- * To the extent possible under law, the author has waived all copyright and
- * related or neighboring rights to this work.  This work is published from:
- * United States.
- *
- */
-
+/* Fake a PNG - just write it out directly. */
 #include <stdio.h>
 #include <zlib.h> /* for crc32 */
 

contrib/libtests/makepng.c

@@ -1,9 +1,8 @@
-/* makepng.c */
-#define _ISOC99_SOURCE
-/* Copyright: */
-#define COPYRIGHT "\251 2013,2015 John Cunningham Bowler"
-/*
- * Last changed in libpng 1.7.0 [(PENDING RELEASE)]
+/* makepng.c
+ *
+ * Copyright (c) 2013 John Cunningham Bowler
+ *
+ * Last changed in libpng 1.6.1 [March 28, 2013]
  *
  * This code is released under the libpng license.
  * For conditions of distribution and use, see the disclaimer
@@ -11,8 +10,8 @@
  *
  * Make a test PNG image.  The arguments are as follows:
  *
- *    makepng [--sRGB|--linear|--1.8] [--tRNS] [--nofilters] \
- *       color-type bit-depth [file-name]
+ *  makepng [--sRGB|--linear|--1.8] [--color=<color>] color-type bit-depth \
+ *      [file-name]
  *
  * The color-type may be numeric (and must match the numbers used by the PNG
  * specification) or one of the format names listed below.  The bit-depth is the
@@ -40,8 +39,8 @@
  * 4 channels: linear combinations of, from the top-left corner clockwise,
  *    transparent, red, green, blue.
  *
- * For color-mapped images a four channel color-map is used and if --tRNS is
- * given the PNG file has a tRNS chunk, as follows:
+ * For color-mapped images a four channel color-map is used and the PNG file has
+ * a tRNS chunk, as follows:
  *
  * 1-bit: entry 0 is transparent-red, entry 1 is opaque-white
  * 2-bit: entry 0: transparent-green
@@ -54,9 +53,6 @@
  * The palette always has 2^bit-depth entries and the tRNS chunk one fewer.  The
  * image is the 1-channel diamond, but using palette index, not luminosity.
  *
- * For formats other than color-mapped ones if --tRNS is specified a tRNS chunk
- * is generated with all channels equal to the low bits of 0x0101.
- *
  * Image size is determined by the final pixel depth in bits, i.e. channels x
  * bit-depth, as follows:
  *
@@ -64,64 +60,20 @@
  * 16 bits:           256x256
  * More than 16 bits: 1024x1024
  *
- * Row filtering is the libpng default but may be turned off (the 'none' filter
- * is used on every row) with the --nofilters option.
- *
- * The images are not interlaced.
- *
- * If file-name is given then the PNG is written to that file, else it is
- * written to stdout.  Notice that stdout is not supported on systems where, by
- * default, it assumes text output; this program makes no attempt to change the
- * text mode of stdout!
- *
- *    makepng --color=<color> ...
+ * Row filtering is turned off (the 'none' filter is used on every row) and the
+ * images are not interlaced.
  *
  * If --color is given then the whole image has that color, color-mapped images
  * will have exactly one palette entry and all image files with be 16x16 in
  * size.  The color value is 1 to 4 decimal numbers as appropriate for the color
  * type.
  *
- *    makepng --small ...
- *
- * If --small is given the images are no larger than required to include every
- * possible pixel value for the format.
- *
- * For formats with pixels 8 bits or fewer in size the images consist of a
- * single row with 2^pixel-depth pixels, one of every possible value.
- *
- * For formats with 16-bit pixels a 256x256 image is generated containing every
- * possible pixel value.
- *
- * For larger pixel sizes a 256x256 image is generated where the first row
- * consists of each pixel that has identical byte values throughout the pixel
- * followed by rows where the byte values differ within the pixel.
- *
- * In all cases the pixel values are arranged in such a way that the SUB and UP
- * filters give byte sequences for maximal zlib compression.  By default (if
- * --nofilters is not given) the SUB filter is used on the first row and the UP
- * filter on all following rows.
- *
- * The --small option is meant to provide good test-case coverage, however the
- * images are not easy to examine visually.  Without the --small option the
- * images contain identical color values; the pixel values are adjusted
- * according to the gamma encoding with no gamma encoding being interpreted as
- * sRGB.
- *
- * LICENSING
- * =========
- *
- * This code is copyright of the authors, see the COPYRIGHT define above.  The
- * code is licensed as above, using the libpng license.  The code generates
- * images which are solely the product of the code; the options choose which of
- * the many possibilities to generate.  The images that result (but not the code
- * which generates them) are licensed as defined here:
- *
- * IMPORTANT: the COPYRIGHT #define must contain ISO-Latin-1 characters, the
- * IMAGE_LICENSING #define must contain UTF-8 characters.  The 'copyright'
- * symbol 0xA9U (\251) in ISO-Latin-1 encoding and 0xC20xA9 (\302\251) in UTF-8.
+ * If file-name is given then the PNG is written to that file, else it is
+ * written to stdout.  Notice that stdout is not supported on systems where, by
+ * default, it assumes text output; this program makes no attempt to change the
+ * text mode of stdout!
  */
-#define IMAGE_LICENSING "Dedicated to the public domain per Creative Commons "\
-    "license \"CC0 1.0\"; https://creativecommons.org/publicdomain/zero/1.0/"
+#define _ISOC99_SOURCE /* for strtoull */
 
 #include <stddef.h> /* for offsetof */
 #include <stdlib.h>
@@ -130,8 +82,6 @@
 #include <ctype.h>
 #include <math.h>
 #include <errno.h>
-#include <assert.h>
-#include <stdint.h>
 
 #if defined(HAVE_CONFIG_H) && !defined(PNG_NO_CONFIG_H)
 #  include <config.h>
@@ -146,25 +96,6 @@
 #  include "../../png.h"
 #endif
 
-#include <zlib.h>
-
-/* Work round for GCC complaints about casting a (double) function result to
- * an unsigned:
- */
-static unsigned int
-flooru(double d)
-{
-   d = floor(d);
-   return (unsigned int)d;
-}
-
-static png_byte
-floorb(double d)
-{
-   d = floor(d);
-   return (png_byte)d;
-}
-
 /* This structure is used for inserting extra chunks (the --insert argument, not
  * documented above.)
  */
@@ -176,7 +107,7 @@ typedef struct chunk_insert
    png_charp            parameters[1];
 } chunk_insert;
 
-static unsigned int
+static int
 channels_of_type(int color_type)
 {
    if (color_type & PNG_COLOR_MASK_PALETTE)
@@ -197,15 +128,14 @@ channels_of_type(int color_type)
    }
 }
 
-static unsigned int
+static int
 pixel_depth_of_type(int color_type, int bit_depth)
 {
    return channels_of_type(color_type) * bit_depth;
 }
 
 static unsigned int
-image_size_of_type(int color_type, int bit_depth, unsigned int *colors,
-   int small)
+image_size_of_type(int color_type, int bit_depth, unsigned int *colors)
 {
    if (*colors)
       return 16;
@@ -214,16 +144,7 @@ image_size_of_type(int color_type, int bit_depth, unsigned int *colors,
    {
       int pixel_depth = pixel_depth_of_type(color_type, bit_depth);
 
-      if (small)
-      {
-         if (pixel_depth <= 8) /* there will be one row */
-            return 1 << pixel_depth;
-
-         else
-            return 256;
-      }
-
-      else if (pixel_depth < 8)
+      if (pixel_depth < 8)
          return 64;
 
       else if (pixel_depth > 16)
@@ -296,8 +217,7 @@ generate_palette(png_colorp palette, png_bytep trans, int bit_depth,
          else
          {
             unsigned int size = 1U << (bit_depth/2); /* 2, 4 or 16 */
-            unsigned int x, y;
-            volatile unsigned int ip = 0;
+            unsigned int x, y, ip;
 
             for (x=0; x<size; ++x) for (y=0; y<size; ++y)
             {
@@ -361,7 +281,7 @@ set_value(png_bytep row, size_t rowbytes, png_uint_32 x, unsigned int bit_depth,
                exit(1);
 
             case 16:
-               value = flooru(65535*pow(value/65535.,conv)+.5);
+               value = (unsigned int)floor(65535*pow(value/65535.,conv)+.5);
                *row++ = (png_byte)(value >> 8);
                *row = (png_byte)value;
                return;
@@ -386,148 +306,15 @@ set_value(png_bytep row, size_t rowbytes, png_uint_32 x, unsigned int bit_depth,
    }
 }
 
-static int /* filter mask for row */
+static void
 generate_row(png_bytep row, size_t rowbytes, unsigned int y, int color_type,
    int bit_depth, png_const_bytep gamma_table, double conv,
-   unsigned int *colors, int small)
+   unsigned int *colors)
 {
-   int filters = 0; /* file *MASK*, 0 means the default, not NONE */
-   png_uint_32 size_max =
-      image_size_of_type(color_type, bit_depth, colors, small)-1;
+   png_uint_32 size_max = image_size_of_type(color_type, bit_depth, colors)-1;
    png_uint_32 depth_max = (1U << bit_depth)-1; /* up to 65536 */
 
-   if (colors[0] == 0) if (small)
-   {
-      unsigned int pixel_depth = pixel_depth_of_type(color_type, bit_depth);
-
-      /* For pixel depths less than 16 generate a single row containing all the
-       * possible pixel values.  For 16 generate all 65536 byte pair
-       * combinations in a 256x256 pixel array.
-       */
-      switch (pixel_depth)
-      {
-         case 1:
-            assert(y == 0 && rowbytes == 1 && size_max == 1);
-            row[0] = 0x6CU; /* binary: 01101100, only top 2 bits used */
-            filters = PNG_FILTER_NONE;
-            break;
-
-         case 2:
-            assert(y == 0 && rowbytes == 1 && size_max == 3);
-            row[0] = 0x1BU; /* binary 00011011, all bits used */
-            filters = PNG_FILTER_NONE;
-            break;
-
-         case 4:
-            assert(y == 0 && rowbytes == 8 && size_max == 15);
-            row[0] = 0x01U;
-            row[1] = 0x23U; /* SUB gives 0x22U for all following bytes */
-            row[2] = 0x45U;
-            row[3] = 0x67U;
-            row[4] = 0x89U;
-            row[5] = 0xABU;
-            row[6] = 0xCDU;
-            row[7] = 0xEFU;
-            filters = PNG_FILTER_SUB;
-            break;
-
-         case 8:
-            /* The row will have all the pixel values in order starting with
-             * '1', the SUB filter will change every byte into '1' (including
-             * the last, which generates pixel value '0').  Since the SUB filter
-             * has value 1 this should result in maximum compression.
-             */
-            assert(y == 0 && rowbytes == 256 && size_max == 255);
-            for (;;)
-            {
-               row[size_max] = 0xFFU & (size_max+1);
-               if (size_max == 0)
-                  break;
-               --size_max;
-            }
-            filters = PNG_FILTER_SUB;
-            break;
-
-         case 16:
-            /* Rows are generated such that each row has a constant difference
-             * between the first and second byte of each pixel and so that the
-             * difference increases by 1 at each row.  The rows start with the
-             * first byte value of 0 and the value increases to 255 across the
-             * row.
-             *
-             * The difference starts at 1, so the first row is:
-             *
-             *     0 1 1 2 2 3 3 4 ... 254 255 255 0
-             *
-             * This means that running the SUB filter on the first row produces:
-             *
-             *   [SUB==1] 0 1 0 1 0 1...
-             *
-             * Then the difference is 2 on the next row, giving:
-             *
-             *    0 2 1 3 2 4 3 5 ... 254 0 255 1
-             *
-             * When the UP filter is run on this libpng produces:
-             *
-             *   [UP ==2] 0 1 0 1 0 1...
-             *
-             * And so on for all the remain rows to the final two * rows:
-             *
-             *    row 254: 0 255 1 0 2 1 3 2 4 3 ... 254 253 255 254
-             *    row 255: 0   0 1 1 2 2 3 3 4 4 ... 254 254 255 255
-             */
-            assert(rowbytes == 512 && size_max == 255);
-            for (;;)
-            {
-               row[2*size_max  ] = 0xFFU & size_max;
-               row[2*size_max+1] = 0xFFU & (size_max+y+1);
-               if (size_max == 0)
-                  break;
-               --size_max;
-            }
-            /* The first row must include PNG_FILTER_UP so that libpng knows we
-             * need to keep it for the following row:
-             */
-            filters = (y == 0 ? PNG_FILTER_SUB+PNG_FILTER_UP : PNG_FILTER_UP);
-            break;
-
-         case 24:
-         case 32:
-         case 48:
-         case 64:
-            /* The rows are filled by an alogorithm similar to the above, in the
-             * first row pixel bytes are all equal, increasing from 0 by 1 for
-             * each pixel.  In the second row the bytes within a pixel are
-             * incremented 1,3,5,7,... from the previous row byte.  Using an odd
-             * number ensures all the possible byte values are used.
-             */
-            assert(size_max == 255 && rowbytes == 256*(pixel_depth>>3));
-            pixel_depth >>= 3; /* now in bytes */
-            while (rowbytes > 0)
-            {
-               const size_t pixel_index = --rowbytes/pixel_depth;
-
-               if (y == 0)
-                  row[rowbytes] = 0xFFU & pixel_index;
-
-               else
-               {
-                  const size_t byte_offset =
-                     rowbytes - pixel_index * pixel_depth;
-
-                  row[rowbytes] =
-                     0xFFU & (pixel_index + (byte_offset * 2*y) + 1);
-               }
-            }
-            filters = (y == 0 ? PNG_FILTER_SUB+PNG_FILTER_UP : PNG_FILTER_UP);
-            break;
-
-         default:
-            assert(0/*NOT REACHED*/);
-      }
-   }
-
-   else switch (channels_of_type(color_type))
+   if (colors[0] == 0) switch (channels_of_type(color_type))
    {
    /* 1 channel: a square image with a diamond, the least luminous colors are on
     *    the edge of the image, the most luminous in the center.
@@ -739,8 +526,6 @@ generate_row(png_bytep row, size_t rowbytes, unsigned int y, int color_type,
          colors[0], channels_of_type(color_type));
       exit(1);
    }
-
-   return filters;
 }
 
 
@@ -769,7 +554,7 @@ makepng_error(png_structp png_ptr, png_const_charp message)
 static int /* 0 on success, else an error code */
 write_png(const char **name, FILE *fp, int color_type, int bit_depth,
    volatile png_fixed_point gamma, chunk_insert * volatile insert,
-   unsigned int filters, unsigned int *colors, int small, int tRNS)
+   unsigned int filters, unsigned int *colors)
 {
    png_structp png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING,
       name, makepng_error, makepng_warning);
@@ -796,15 +581,6 @@ write_png(const char **name, FILE *fp, int color_type, int bit_depth,
 
    /* Allow benign errors so that we can write PNGs with errors */
    png_set_benign_errors(png_ptr, 1/*allowed*/);
-
-   /* Max out the text compression level in an attempt to make the license
-    * small.   If --small then do the same for the IDAT.
-    */
-   if (small)
-      png_set_compression_level(png_ptr, Z_BEST_COMPRESSION);
-
-   png_set_text_compression_level(png_ptr, Z_BEST_COMPRESSION);
-
    png_init_io(png_ptr, fp);
 
    info_ptr = png_create_info_struct(png_ptr);
@@ -812,37 +588,11 @@ write_png(const char **name, FILE *fp, int color_type, int bit_depth,
       png_error(png_ptr, "OOM allocating info structure");
 
    {
-      const unsigned int size =
-         image_size_of_type(color_type, bit_depth, colors, small);
-      unsigned int ysize;
+      unsigned int size = image_size_of_type(color_type, bit_depth, colors);
       png_fixed_point real_gamma = 45455; /* For sRGB */
       png_byte gamma_table[256];
       double conv;
 
-      /* Normally images are square, but with 'small' we want to simply generate
-       * all the pixel values, or all that we reasonably can:
-       */
-      if (small)
-      {
-         const unsigned int pixel_depth =
-            pixel_depth_of_type(color_type, bit_depth);
-
-         if (pixel_depth <= 8U)
-         {
-            assert(size == (1U<<pixel_depth));
-            ysize = 1U;
-         }
-
-         else
-         {
-            assert(size == 256U);
-            ysize = 256U;
-         }
-      }
-
-      else
-         ysize = size;
-
       /* This function uses the libpng values used on read to carry extra
        * information about the gamma:
        */
@@ -875,13 +625,13 @@ write_png(const char **name, FILE *fp, int color_type, int bit_depth,
             gamma_table[0] = 0;
 
             for (i=1; i<255; ++i)
-               gamma_table[i] = floorb(pow(i/255.,conv) * 255 + .5);
+               gamma_table[i] = (png_byte)floor(pow(i/255.,conv) * 255 + .5);
 
             gamma_table[255] = 255;
          }
       }
 
-      png_set_IHDR(png_ptr, info_ptr, size, ysize, bit_depth, color_type,
+      png_set_IHDR(png_ptr, info_ptr, size, size, bit_depth, color_type,
          PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE);
 
       if (color_type & PNG_COLOR_MASK_PALETTE)
@@ -893,26 +643,14 @@ write_png(const char **name, FILE *fp, int color_type, int bit_depth,
          npalette = generate_palette(palette, trans, bit_depth, gamma_table,
             colors);
          png_set_PLTE(png_ptr, info_ptr, palette, npalette);
-
-         if (tRNS)
-            png_set_tRNS(png_ptr, info_ptr, trans, npalette-1,
-               NULL/*transparent color*/);
+         png_set_tRNS(png_ptr, info_ptr, trans, npalette-1,
+            NULL/*transparent color*/);
 
          /* Reset gamma_table to prevent the image rows being changed */
          for (npalette=0; npalette<256; ++npalette)
             gamma_table[npalette] = (png_byte)npalette;
       }
 
-      else if (tRNS)
-      {
-         png_color_16 col;
-
-         col.red = col.green = col.blue = col.gray =
-            0x0101U & ((1U<<bit_depth)-1U);
-         col.index = 0U;
-         png_set_tRNS(png_ptr, info_ptr, NULL/*trans*/, 1U, &col);
-      }
-
       if (gamma == PNG_DEFAULT_sRGB)
          png_set_sRGB(png_ptr, info_ptr, PNG_sRGB_INTENT_ABSOLUTE);
 
@@ -944,11 +682,7 @@ write_png(const char **name, FILE *fp, int color_type, int bit_depth,
       png_set_filter(png_ptr, PNG_FILTER_TYPE_BASE, filters);
 
       {
-#        ifdef PNG_WRITE_INTERLACING_SUPPORTED
-            int passes = png_set_interlace_handling(png_ptr);
-#        else /* !WRITE_INTERLACING */
-            int passes = 1;
-#        endif /* !WRITE_INTERLACING */
+         int passes = png_set_interlace_handling(png_ptr);
          int pass;
          png_size_t rowbytes = png_get_rowbytes(png_ptr, info_ptr);
 
@@ -961,15 +695,10 @@ write_png(const char **name, FILE *fp, int color_type, int bit_depth,
          {
             unsigned int y;
 
-            for (y=0; y<ysize; ++y)
+            for (y=0; y<size; ++y)
             {
-               unsigned int row_filters =
-                  generate_row(row, rowbytes, y, color_type, bit_depth,
-                        gamma_table, conv, colors, small);
-
-               if (row_filters != 0 && filters == PNG_ALL_FILTERS)
-                  png_set_filter(png_ptr, PNG_FILTER_TYPE_BASE, row_filters);
-
+               generate_row(row, rowbytes, y, color_type, bit_depth,
+                  gamma_table, conv, colors);
                png_write_row(png_ptr, row);
             }
          }
@@ -1098,7 +827,7 @@ static png_size_t
 load_fake(png_charp param, png_bytepp profile)
 {
    char *endptr = NULL;
-   uint64_t size = strtoull(param, &endptr, 0/*base*/);
+   unsigned long long int size = strtoull(param, &endptr, 0/*base*/);
 
    /* The 'fake' format is <number>*[string] */
    if (endptr != NULL && *endptr == '*')
@@ -1333,8 +1062,7 @@ insert_iTXt(png_structp png_ptr, png_infop info_ptr, int nparams,
 }
 
 static void
-insert_hIST(png_structp png_ptr, png_infop info_ptr, int nparams,
-      png_charpp params)
+insert_hIST(png_structp png_ptr, png_infop info_ptr, int nparams, png_charpp params)
 {
    int i;
    png_uint_16 freq[256];
@@ -1361,56 +1089,6 @@ insert_hIST(png_structp png_ptr, png_infop info_ptr, int nparams,
    png_set_hIST(png_ptr, info_ptr, freq);
 }
 
-static png_byte
-bval(png_const_structrp png_ptr, png_charp param, unsigned int maxval)
-{
-   char *endptr = NULL;
-   unsigned long int l = strtoul(param, &endptr, 0/*base*/);
-
-   if (param[0] && *endptr == 0 && l <= maxval)
-      return (png_byte)l;
-
-   else
-      png_error(png_ptr, "sBIT: invalid sBIT value");
-}
-
-static void
-insert_sBIT(png_structp png_ptr, png_infop info_ptr, int nparams,
-      png_charpp params)
-{
-   const int ct = png_get_color_type(png_ptr, info_ptr);
-   const int c = (ct & PNG_COLOR_MASK_COLOR ? 3 : 1) +
-      (ct & PNG_COLOR_MASK_ALPHA ? 1 : 0);
-   const unsigned int maxval =
-      ct & PNG_COLOR_MASK_PALETTE ? 8U : png_get_bit_depth(png_ptr, info_ptr);
-   png_color_8 sBIT;
-
-   if (nparams != c)
-      png_error(png_ptr, "sBIT: incorrect parameter count");
-
-   if (ct & PNG_COLOR_MASK_COLOR)
-   {
-      sBIT.red = bval(png_ptr, params[0], maxval);
-      sBIT.green = bval(png_ptr, params[1], maxval);
-      sBIT.blue = bval(png_ptr, params[2], maxval);
-      sBIT.gray = 42;
-   }
-
-   else
-   {
-      sBIT.red = sBIT.green = sBIT.blue = 42;
-      sBIT.gray = bval(png_ptr, params[0], maxval);
-   }
-
-   if (ct & PNG_COLOR_MASK_ALPHA)
-      sBIT.alpha = bval(png_ptr, params[nparams-1], maxval);
-
-   else
-      sBIT.alpha = 42;
-
-   png_set_sBIT(png_ptr, info_ptr, &sBIT);
-}
-
 #if 0
 static void
 insert_sPLT(png_structp png_ptr, png_infop info_ptr, int nparams, png_charpp params)
@@ -1538,11 +1216,6 @@ find_insert(png_const_charp what, png_charp param)
             return make_insert(what, insert_hIST, nparams, parameter_list);
          break;
 
-      case CHUNK(115,66,73,84): /* sBIT */
-         if (nparams <= 4)
-            return make_insert(what, insert_sBIT, nparams, parameter_list);
-         break;
-
 #if 0
       case CHUNK(115,80,76,84):  /* sPLT */
          return make_insert(what, insert_sPLT, nparams, parameter_list);
@@ -1558,80 +1231,6 @@ find_insert(png_const_charp what, png_charp param)
    return NULL;
 }
 
-/* This is necessary because libpng expects writeable strings for things like
- * text chunks (maybe this should be fixed...)
- */
-static png_charp
-strstash(png_const_charp foo)
-{
-   /* The program indicates a memory allocation error by crashing, this is by
-    * design.
-    */
-   if (foo != NULL)
-   {
-      png_charp bar = malloc(strlen(foo)+1);
-      return strcpy(bar, foo);
-   }
-
-   return NULL;
-}
-
-static png_charp
-strstash_list(const png_const_charp *text)
-{
-   size_t foo = 0;
-   png_charp result, bar;
-   const png_const_charp *line = text;
-
-   while (*line != NULL)
-      foo += strlen(*line++);
-
-   result = bar = malloc(foo+1);
-
-   line = text;
-   while (*line != NULL)
-   {
-      foo = strlen(*line);
-      memcpy(bar, *line++, foo);
-      bar += foo;
-   }
-
-   *bar = 0;
-   return result;
-}
-
-/* These are used to insert Copyright and Licence fields, they allow the text to
- * have \n unlike the --insert option.
- */
-static chunk_insert *
-add_tEXt(const char *key, const png_const_charp *text)
-{
-   static char what[5] = { 116, 69, 88, 116, 0 };
-   png_charp parameter_list[3];
-
-   parameter_list[0] = strstash(key);
-   parameter_list[1] = strstash_list(text);
-   parameter_list[2] = NULL;
-
-   return make_insert(what, insert_tEXt, 2, parameter_list);
-}
-
-static chunk_insert *
-add_iTXt(const char *key, const char *language, const char *language_key,
-      const png_const_charp *text)
-{
-   static char what[5] = { 105, 84, 88, 116, 0 };
-   png_charp parameter_list[5];
-
-   parameter_list[0] = strstash(key);
-   parameter_list[1] = strstash(language);
-   parameter_list[2] = strstash(language_key);
-   parameter_list[3] = strstash_list(text);
-   parameter_list[4] = NULL;
-
-   return make_insert(what, insert_iTXt, 4, parameter_list);
-}
-
 /* This is a not-very-good parser for a sequence of numbers (including 0).  It
  * doesn't accept some apparently valid things, but it accepts all the sensible
  * combinations.
@@ -1681,8 +1280,6 @@ main(int argc, char **argv)
    const char *file_name = NULL;
    int color_type = 8; /* invalid */
    int bit_depth = 32; /* invalid */
-   int small = 0; /* make full size images */
-   int tRNS = 0; /* don't output a tRNS chunk */
    unsigned int colors[5];
    unsigned int filters = PNG_ALL_FILTERS;
    png_fixed_point gamma = 0; /* not set */
@@ -1695,18 +1292,6 @@ main(int argc, char **argv)
    {
       char *arg = *++argv;
 
-      if (strcmp(arg, "--small") == 0)
-      {
-         small = 1;
-         continue;
-      }
-
-      if (strcmp(arg, "--tRNS") == 0)
-      {
-         tRNS = 1;
-         continue;
-      }
-
       if (strcmp(arg, "--sRGB") == 0)
       {
          gamma = PNG_DEFAULT_sRGB;
@@ -1847,10 +1432,9 @@ main(int argc, char **argv)
 
    if (color_type == 8 || bit_depth == 32)
    {
-      fprintf(stderr, "usage: makepng [--small] [--sRGB|--linear|--1.8] "
+      fprintf(stderr, "usage: makepng [--sRGB|--linear|--1.8] "
          "[--color=...] color-type bit-depth [file-name]\n"
-         "  Make a test PNG file, by default writes to stdout.\n"
-         "  Other options are available, UTSL.\n");
+         "  Make a test PNG file, by default writes to stdout.\n");
       exit(1);
    }
 
@@ -1869,19 +1453,10 @@ main(int argc, char **argv)
          }
    }
 
-   /* small and colors are incomparible (will probably crash if both are used at
-    * the same time!)
-    */
-   if (small && colors[0] != 0)
-   {
-      fprintf(stderr, "makepng: --color --small: only one at a time!\n");
-      exit(1);
-   }
-
    /* Restrict the filters for more speed to those we know are used for the
     * generated images.
     */
-   if (filters == PNG_ALL_FILTERS && !small/*small provides defaults*/)
+   if (filters == PNG_ALL_FILTERS)
    {
       if ((color_type & PNG_COLOR_MASK_PALETTE) != 0 || bit_depth < 8)
          filters = PNG_FILTER_NONE;
@@ -1899,39 +1474,9 @@ main(int argc, char **argv)
          filters &= ~PNG_FILTER_NONE;
    }
 
-   /* Insert standard copyright and licence text. */
-   {
-      static png_const_charp copyright[] =
-      {
-         COPYRIGHT, /* ISO-Latin-1 */
-         NULL
-      };
-      static png_const_charp licensing[] =
-      {
-         IMAGE_LICENSING, /* UTF-8 */
-         NULL
-      };
-
-      chunk_insert *new_insert;
-
-      new_insert = add_tEXt("Copyright", copyright);
-      if (new_insert != NULL)
-      {
-         *insert_ptr = new_insert;
-         insert_ptr = &new_insert->next;
-      }
-
-      new_insert = add_iTXt("Licensing", "en", NULL, licensing);
-      if (new_insert != NULL)
-      {
-         *insert_ptr = new_insert;
-         insert_ptr = &new_insert->next;
-      }
-   }
-
    {
       int ret = write_png(&file_name, fp, color_type, bit_depth, gamma,
-         head_insert, filters, colors, small, tRNS);
+         head_insert, filters, colors);
 
       if (ret != 0 && file_name != NULL)
          remove(file_name);

contrib/libtests/pngimage.c

@@ -1,8 +1,8 @@
 /* pngimage.c
  *
- * Copyright (c) 2015 John Cunningham Bowler
+ * Copyright (c) 2014 John Cunningham Bowler
  *
- * Last changed in libpng 1.6.18 [(PENDING RELEASE)]
+ * Last changed in libpng 1.6.10 [March 6, 2014]
  *
  * This code is released under the libpng license.
  * For conditions of distribution and use, see the disclaimer
@@ -36,8 +36,7 @@
 #  include <setjmp.h> /* because png.h did *not* include this */
 #endif
 
-#if defined(PNG_INFO_IMAGE_SUPPORTED) && defined(PNG_SEQUENTIAL_READ_SUPPORTED)\
-    && (defined(PNG_READ_PNG_SUPPORTED) || PNG_LIBPNG_VER < 10700)
+#if defined(PNG_INFO_IMAGE_SUPPORTED) && defined(PNG_SEQUENTIAL_READ_SUPPORTED)
 /* If a transform is valid on both read and write this implies that if the
  * transform is applied to read it must also be applied on write to produce
  * meaningful data.  This is because these transforms when performed on read
@@ -237,12 +236,10 @@ static struct transform_info
        */
 #endif
 #ifdef PNG_READ_SCALE_16_TO_8_SUPPORTED
-   T(SCALE_16,            NONE, X,   X,   16,  R),
+   T(SCALE_16,            NONE, X,   X,   16,  R)
       /* scales 16-bit components to 8-bits. */
 #endif
 
-   { NULL /*name*/, 0, 0, 0, 0, 0, 0, 0/*!tested*/ }
-
 #undef T
 };
 
@@ -297,7 +294,7 @@ transform_name(int t)
 
    t &= -t; /* first set bit */
 
-   for (i=0; i<TTABLE_SIZE; ++i) if (transform_info[i].name != NULL)
+   for (i=0; i<TTABLE_SIZE; ++i)
    {
       if ((transform_info[i].transform & t) != 0)
          return transform_info[i].name;
@@ -318,7 +315,7 @@ validate_T(void)
 {
    unsigned int i;
 
-   for (i=0; i<TTABLE_SIZE; ++i) if (transform_info[i].name != NULL)
+   for (i=0; i<TTABLE_SIZE; ++i)
    {
       if (transform_info[i].when & TRANSFORM_R)
          read_transforms |= transform_info[i].transform;
@@ -508,7 +505,6 @@ typedef enum
 #define SKIP_BUGS       0x100 /* Skip over known bugs */
 #define LOG_SKIPPED     0x200 /* Log skipped bugs */
 #define FIND_BAD_COMBOS 0x400 /* Attempt to deduce bad combos */
-#define LIST_COMBOS     0x800 /* List combos by name */
 
 /* Result masks apply to the result bits in the 'results' field below; these
  * bits are simple 1U<<error_level.  A pass requires either nothing worse than
@@ -694,35 +690,7 @@ display_log(struct display *dp, error_level level, const char *fmt, ...)
          int tr = dp->transforms;
 
          if (is_combo(tr))
-         {
-            if (dp->options & LIST_COMBOS)
-            {
-               int trx = tr;
-
-               fprintf(stderr, "(");
-               if (trx)
-               {
-                  int start = 0;
-
-                  while (trx)
-                  {
-                     int trz = trx & -trx;
-
-                     if (start) fprintf(stderr, "+");
-                     fprintf(stderr, "%s", transform_name(trz));
-                     start = 1;
-                     trx &= ~trz;
-                  }
-               }
-
-               else
-                  fprintf(stderr, "-");
-               fprintf(stderr, ")");
-            }
-
-            else
-               fprintf(stderr, "(0x%x)", tr);
-         }
+            fprintf(stderr, "(0x%x)", tr);
 
          else
             fprintf(stderr, "(%s)", transform_name(tr));
@@ -942,13 +910,13 @@ update_display(struct display *dp)
       int bd = dp->bit_depth;
       unsigned int i;
 
-      for (i=0; i<TTABLE_SIZE; ++i) if (transform_info[i].name != NULL)
+      for (i=0; i<TTABLE_SIZE; ++i)
       {
          int transform = transform_info[i].transform;
 
          if ((transform_info[i].valid_chunks == 0 ||
                (transform_info[i].valid_chunks & chunks) != 0) &&
-            (transform_info[i].color_mask_required & ct) ==
+            (transform_info[i].color_mask_required & ct) == 
                transform_info[i].color_mask_required &&
             (transform_info[i].color_mask_absent & ct) == 0 &&
             (transform_info[i].bit_depths & bd) != 0 &&
@@ -967,6 +935,9 @@ update_display(struct display *dp)
 
       dp->active_transforms = active;
       dp->ignored_transforms = inactive; /* excluding write-only transforms */
+
+      if (active == 0)
+         display_log(dp, INTERNAL_ERROR, "bad transform table");
    }
 }
 
@@ -1006,7 +977,7 @@ compare_read(struct display *dp, int applied_transforms)
    {
       unsigned long chunks =
          png_get_valid(dp->read_pp, dp->read_ip, 0xffffffff);
-
+      
       if (chunks != dp->chunks)
          display_log(dp, APP_FAIL, "PNG chunks changed from 0x%lx to 0x%lx",
             (unsigned long)dp->chunks, chunks);
@@ -1149,8 +1120,8 @@ compare_read(struct display *dp, int applied_transforms)
          {
             int b;
 
-            case 16: /* Two bytes per component, big-endian */
-               for (b = (bpp >> 4); b > 0; --b)
+            case 16: /* Two bytes per component, bit-endian */
+               for (b = (bpp >> 4); b > 0; )
                {
                   unsigned int sig = (unsigned int)(0xffff0000 >> sig_bits[b]);
 
@@ -1617,12 +1588,6 @@ main(const int argc, const char * const * const argv)
       else if (strcmp(name, "--nofind-bad-combos") == 0)
          d.options &= ~FIND_BAD_COMBOS;
 
-      else if (strcmp(name, "--list-combos") == 0)
-         d.options |= LIST_COMBOS;
-
-      else if (strcmp(name, "--nolist-combos") == 0)
-         d.options &= ~LIST_COMBOS;
-
       else if (name[0] == '-' && name[1] == '-')
       {
          fprintf(stderr, "pngimage: %s: unknown option\n", name);
@@ -1677,7 +1642,7 @@ main(const int argc, const char * const * const argv)
       return errors != 0;
    }
 }
-#else /* !INFO_IMAGE || !SEQUENTIAL_READ || !READ_PNG*/
+#else /* !PNG_INFO_IMAGE_SUPPORTED || !PNG_READ_SUPPORTED */
 int
 main(void)
 {

contrib/libtests/pngstest-errors.h

@@ -1,165 +0,0 @@
-/* contrib/libtests/pngstest-errors.h
- *
- * BUILT USING: libpng version 1.7.0beta66 - September 18, 2015
- *
- * This code is released under the libpng license.
- * For conditions of distribution and use, see the disclaimer
- * and license in png.h
- *
- * THIS IS A MACHINE GENERATED FILE: do not edit it directly!
- * Instead run:
- *
- *    pngstest --accumulate
- *
- * on as many PNG files as possible; at least PNGSuite and
- * contrib/libtests/testpngs.
- */
-static png_uint_16 gpc_error[16/*in*/][16/*out*/][4/*a*/] =
-{
- { /* input: sRGB-gray */
-  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
-  { 0, 0, 372, 0 }, { 0, 0, 372, 0 }, { 0, 0, 372, 0 }, { 0, 0, 372, 0 },
-  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
-  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }
- }, { /* input: sRGB-gray+alpha */
-  { 0, 19, 1, 0 }, { 0, 0, 0, 0 }, { 0, 20, 1, 0 }, { 0, 0, 0, 0 },
-  { 0, 897, 788, 0 }, { 0, 897, 788, 0 }, { 0, 897, 788, 0 }, { 0, 897, 788, 0 },
-  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
-  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }
- }, { /* input: sRGB-rgb */
-  { 0, 0, 19, 0 }, { 0, 0, 19, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
-  { 0, 0, 893, 0 }, { 0, 0, 893, 0 }, { 0, 0, 811, 0 }, { 0, 0, 811, 0 },
-  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
-  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }
- }, { /* input: sRGB-rgb+alpha */
-  { 0, 14, 13, 0 }, { 0, 15, 13, 0 }, { 0, 19, 1, 0 }, { 0, 0, 0, 0 },
-  { 0, 832, 764, 0 }, { 0, 832, 764, 0 }, { 0, 897, 788, 0 }, { 0, 897, 788, 0 },
-  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
-  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }
- }, { /* input: linear-gray */
-  { 0, 0, 9, 0 }, { 0, 0, 9, 0 }, { 0, 0, 9, 0 }, { 0, 0, 9, 0 },
-  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
-  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
-  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }
- }, { /* input: linear-gray+alpha */
-  { 0, 74, 9, 0 }, { 0, 20, 9, 0 }, { 0, 74, 9, 0 }, { 0, 20, 9, 0 },
-  { 0, 0, 0, 0 }, { 0, 1, 0, 0 }, { 0, 0, 0, 0 }, { 0, 1, 0, 0 },
-  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
-  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }
- }, { /* input: linear-rgb */
-  { 0, 0, 9, 0 }, { 0, 0, 9, 0 }, { 0, 0, 9, 0 }, { 0, 0, 9, 0 },
-  { 0, 0, 4, 0 }, { 0, 0, 4, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
-  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
-  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }
- }, { /* input: linear-rgb+alpha */
-  { 0, 126, 143, 0 }, { 0, 11, 7, 0 }, { 0, 74, 9, 0 }, { 0, 17, 9, 0 },
-  { 0, 4, 4, 0 }, { 0, 5, 4, 0 }, { 0, 0, 0, 0 }, { 0, 1, 0, 0 },
-  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
-  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }
- }, { /* input: color-mapped-sRGB-gray */
-  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
-  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
-  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
-  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }
- }, { /* input: color-mapped-sRGB-gray+alpha */
-  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
-  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
-  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
-  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }
- }, { /* input: color-mapped-sRGB-rgb */
-  { 0, 0, 13, 0 }, { 0, 0, 13, 0 }, { 0, 0, 8, 0 }, { 0, 0, 8, 0 },
-  { 0, 0, 673, 0 }, { 0, 0, 673, 0 }, { 0, 0, 674, 0 }, { 0, 0, 674, 0 },
-  { 0, 0, 1, 0 }, { 0, 0, 1, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
-  { 0, 0, 460, 0 }, { 0, 0, 460, 0 }, { 0, 0, 263, 0 }, { 0, 0, 263, 0 }
- }, { /* input: color-mapped-sRGB-rgb+alpha */
-  { 0, 6, 8, 0 }, { 0, 7, 8, 0 }, { 0, 75, 8, 0 }, { 0, 9, 8, 0 },
-  { 0, 585, 427, 0 }, { 0, 585, 427, 0 }, { 0, 717, 584, 0 }, { 0, 717, 584, 0 },
-  { 0, 1, 1, 0 }, { 0, 1, 1, 0 }, { 0, 1, 0, 0 }, { 0, 0, 0, 0 },
-  { 0, 13323, 460, 0 }, { 0, 427, 460, 0 }, { 0, 16480, 263, 0 }, { 0, 243, 263, 0 }
- }, { /* input: color-mapped-linear-gray */
-  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
-  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
-  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
-  { 0, 0, 282, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }
- }, { /* input: color-mapped-linear-gray+alpha */
-  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
-  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
-  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
-  { 0, 0, 0, 0 }, { 0, 253, 282, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }
- }, { /* input: color-mapped-linear-rgb */
-  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
-  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
-  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
-  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 265, 0 }, { 0, 0, 0, 0 }
- }, { /* input: color-mapped-linear-rgb+alpha */
-  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
-  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
-  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
-  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 243, 265, 0 }
- }
-};
-static png_uint_16 gpc_error_via_linear[16][4/*out*/][4] =
-{
- { /* input: sRGB-gray */
-  { 0, 0, 7, 0 }, { 0, 0, 7, 0 }, { 0, 0, 7, 0 }, { 0, 0, 7, 0 }
- }, { /* input: sRGB-gray+alpha */
-  { 0, 15, 15, 0 }, { 0, 186, 15, 0 }, { 0, 15, 15, 0 }, { 0, 186, 15, 0 }
- }, { /* input: sRGB-rgb */
-  { 0, 0, 20, 0 }, { 0, 0, 20, 0 }, { 0, 0, 15, 0 }, { 0, 0, 15, 0 }
- }, { /* input: sRGB-rgb+alpha */
-  { 0, 12, 14, 0 }, { 0, 180, 14, 0 }, { 0, 15, 15, 0 }, { 0, 186, 15, 0 }
- }, { /* input: linear-gray */
-  { 0, 0, 1, 0 }, { 0, 0, 1, 0 }, { 0, 0, 1, 0 }, { 0, 0, 1, 0 }
- }, { /* input: linear-gray+alpha */
-  { 0, 1, 1, 0 }, { 0, 1, 1, 0 }, { 0, 1, 1, 0 }, { 0, 1, 1, 0 }
- }, { /* input: linear-rgb */
-  { 0, 0, 1, 0 }, { 0, 0, 1, 0 }, { 0, 0, 1, 0 }, { 0, 0, 1, 0 }
- }, { /* input: linear-rgb+alpha */
-  { 0, 1, 1, 0 }, { 0, 9, 1, 0 }, { 0, 1, 1, 0 }, { 0, 1, 1, 0 }
- }, { /* input: color-mapped-sRGB-gray */
-  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }
- }, { /* input: color-mapped-sRGB-gray+alpha */
-  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }
- }, { /* input: color-mapped-sRGB-rgb */
-  { 0, 0, 13, 0 }, { 0, 0, 13, 0 }, { 0, 0, 14, 0 }, { 0, 0, 14, 0 }
- }, { /* input: color-mapped-sRGB-rgb+alpha */
-  { 0, 4, 8, 0 }, { 0, 9, 8, 0 }, { 0, 9, 9, 0 }, { 0, 32, 9, 0 }
- }, { /* input: color-mapped-linear-gray */
-  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }
- }, { /* input: color-mapped-linear-gray+alpha */
-  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }
- }, { /* input: color-mapped-linear-rgb */
-  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }
- }, { /* input: color-mapped-linear-rgb+alpha */
-  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }
- }
-};
-static png_uint_16 gpc_error_to_colormap[8/*i*/][8/*o*/][4] =
-{
- { /* input: sRGB-gray */
-  { 0, 0, 9, 0 }, { 0, 0, 9, 0 }, { 0, 0, 9, 0 }, { 0, 0, 9, 0 },
-  { 0, 0, 742, 0 }, { 0, 0, 742, 0 }, { 0, 0, 742, 0 }, { 0, 0, 742, 0 }
- }, { /* input: sRGB-gray+alpha */
-  { 0, 19, 6, 0 }, { 0, 255, 6, 25 }, { 0, 88, 6, 0 }, { 0, 255, 6, 25 },
-  { 0, 1012, 911, 0 }, { 0, 16026, 911, 6425 }, { 0, 1012, 911, 0 }, { 0, 16026, 911, 6425 }
- }, { /* input: sRGB-rgb */
-  { 0, 0, 19, 0 }, { 0, 0, 19, 0 }, { 0, 0, 25, 0 }, { 0, 0, 25, 0 },
-  { 0, 0, 962, 0 }, { 0, 0, 962, 0 }, { 0, 0, 13677, 0 }, { 0, 0, 13677, 0 }
- }, { /* input: sRGB-rgb+alpha */
-  { 0, 63, 77, 0 }, { 0, 255, 19, 25 }, { 0, 225, 25, 0 }, { 0, 255, 25, 67 },
-  { 0, 17534, 18491, 0 }, { 0, 15998, 2824, 6425 }, { 0, 14103, 13677, 0 }, { 0, 50115, 13677, 17219 }
- }, { /* input: linear-gray */
-  { 0, 0, 73, 0 }, { 0, 0, 73, 0 }, { 0, 0, 73, 0 }, { 0, 0, 73, 0 },
-  { 0, 0, 18817, 0 }, { 0, 0, 18817, 0 }, { 0, 0, 18817, 0 }, { 0, 0, 18817, 0 }
- }, { /* input: linear-gray+alpha */
-  { 0, 74, 74, 0 }, { 0, 255, 74, 25 }, { 0, 100, 74, 0 }, { 0, 255, 74, 25 },
-  { 0, 18919, 18907, 0 }, { 0, 24549, 18907, 6553 }, { 0, 18919, 18907, 0 }, { 0, 24549, 18907, 6553 }
- }, { /* input: linear-rgb */
-  { 0, 0, 73, 0 }, { 0, 0, 73, 0 }, { 0, 0, 98, 0 }, { 0, 0, 98, 0 },
-  { 0, 0, 18664, 0 }, { 0, 0, 18664, 0 }, { 0, 0, 24998, 0 }, { 0, 0, 24998, 0 }
- }, { /* input: linear-rgb+alpha */
-  { 0, 181, 196, 0 }, { 0, 255, 61, 25 }, { 206, 192, 98, 0 }, { 0, 255, 98, 67 },
-  { 0, 18141, 18137, 0 }, { 0, 17494, 17504, 6553 }, { 0, 24979, 24992, 0 }, { 0, 49172, 24992, 17347 }
- }
-};
-/* END MACHINE GENERATED */

contrib/libtests/pngstest.c

@@ -1,9 +1,9 @@
 /*-
  * pngstest.c
  *
- * Copyright (c) 2013-2015 John Cunningham Bowler
+ * Copyright (c) 2013-2014 John Cunningham Bowler
  *
- * Last changed in libpng 1.6.19 [(PENDING RELEASE)]
+ * Last changed in libpng 1.6.16 [(PENDING RELEASE)]
  *
  * This code is released under the libpng license.
  * For conditions of distribution and use, see the disclaimer
@@ -615,7 +615,7 @@ freeimage(Image *image)
 
    if (image->tmpfile_name[0] != 0 && (image->opts & KEEP_TMPFILES) == 0)
    {
-      (void)remove(image->tmpfile_name);
+      remove(image->tmpfile_name);
       image->tmpfile_name[0] = 0;
    }
 }
@@ -1984,7 +1984,156 @@ static void (* const gpc_fn_colormapped[8/*in*/][8/*out*/])
  * gpc_error_to_colormap.
  */
 #if PNG_FORMAT_FLAG_COLORMAP == 8 /* extra check also required */
-#  include "pngstest-errors.h" /* machine generated */
+/* START MACHINE GENERATED */
+static png_uint_16 gpc_error[16/*in*/][16/*out*/][4/*a*/] =
+{
+ { /* input: sRGB-gray */
+  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
+  { 0, 0, 372, 0 }, { 0, 0, 372, 0 }, { 0, 0, 372, 0 }, { 0, 0, 372, 0 },
+  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
+  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }
+ }, { /* input: sRGB-gray+alpha */
+  { 0, 18, 0, 0 }, { 0, 0, 0, 0 }, { 0, 20, 0, 0 }, { 0, 0, 0, 0 },
+  { 0, 897, 788, 0 }, { 0, 897, 788, 0 }, { 0, 897, 788, 0 }, { 0, 897, 788, 0 },
+  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
+  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }
+ }, { /* input: sRGB-rgb */
+  { 0, 0, 19, 0 }, { 0, 0, 19, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
+  { 0, 0, 893, 0 }, { 0, 0, 893, 0 }, { 0, 0, 811, 0 }, { 0, 0, 811, 0 },
+  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
+  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }
+ }, { /* input: sRGB-rgb+alpha */
+  { 0, 4, 13, 0 }, { 0, 14, 13, 0 }, { 0, 19, 0, 0 }, { 0, 0, 0, 0 },
+  { 0, 832, 764, 0 }, { 0, 832, 764, 0 }, { 0, 897, 788, 0 }, { 0, 897, 788, 0 },
+  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
+  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }
+ }, { /* input: linear-gray */
+  { 0, 0, 9, 0 }, { 0, 0, 9, 0 }, { 0, 0, 9, 0 }, { 0, 0, 9, 0 },
+  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
+  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
+  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }
+ }, { /* input: linear-gray+alpha */
+  { 0, 74, 9, 0 }, { 0, 20, 9, 0 }, { 0, 74, 9, 0 }, { 0, 20, 9, 0 },
+  { 0, 0, 0, 0 }, { 0, 1, 0, 0 }, { 0, 0, 0, 0 }, { 0, 1, 0, 0 },
+  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
+  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }
+ }, { /* input: linear-rgb */
+  { 0, 0, 9, 0 }, { 0, 0, 9, 0 }, { 0, 0, 9, 0 }, { 0, 0, 9, 0 },
+  { 0, 0, 4, 0 }, { 0, 0, 4, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
+  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
+  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }
+ }, { /* input: linear-rgb+alpha */
+  { 0, 126, 143, 0 }, { 0, 9, 7, 0 }, { 0, 74, 9, 0 }, { 0, 16, 9, 0 },
+  { 0, 4, 4, 0 }, { 0, 5, 4, 0 }, { 0, 0, 0, 0 }, { 0, 1, 0, 0 },
+  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
+  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }
+ }, { /* input: color-mapped-sRGB-gray */
+  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
+  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
+  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
+  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }
+ }, { /* input: color-mapped-sRGB-gray+alpha */
+  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
+  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
+  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
+  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }
+ }, { /* input: color-mapped-sRGB-rgb */
+  { 0, 0, 13, 0 }, { 0, 0, 13, 0 }, { 0, 0, 8, 0 }, { 0, 0, 8, 0 },
+  { 0, 0, 673, 0 }, { 0, 0, 673, 0 }, { 0, 0, 674, 0 }, { 0, 0, 674, 0 },
+  { 0, 0, 1, 0 }, { 0, 0, 1, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
+  { 0, 0, 460, 0 }, { 0, 0, 460, 0 }, { 0, 0, 263, 0 }, { 0, 0, 263, 0 }
+ }, { /* input: color-mapped-sRGB-rgb+alpha */
+  { 0, 6, 8, 0 }, { 0, 7, 8, 0 }, { 0, 75, 8, 0 }, { 0, 9, 8, 0 },
+  { 0, 585, 427, 0 }, { 0, 585, 427, 0 }, { 0, 717, 409, 0 }, { 0, 717, 409, 0 },
+  { 0, 1, 1, 0 }, { 0, 1, 1, 0 }, { 0, 1, 0, 0 }, { 0, 0, 0, 0 },
+  { 0, 13323, 460, 0 }, { 0, 334, 460, 0 }, { 0, 16480, 263, 0 }, { 0, 243, 263, 0 }
+ }, { /* input: color-mapped-linear-gray */
+  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
+  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
+  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
+  { 0, 0, 282, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }
+ }, { /* input: color-mapped-linear-gray+alpha */
+  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
+  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
+  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
+  { 0, 0, 0, 0 }, { 0, 253, 282, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }
+ }, { /* input: color-mapped-linear-rgb */
+  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
+  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
+  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
+  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 265, 0 }, { 0, 0, 0, 0 }
+ }, { /* input: color-mapped-linear-rgb+alpha */
+  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
+  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
+  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 },
+  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 243, 265, 0 }
+ }
+};
+static png_uint_16 gpc_error_via_linear[16][4/*out*/][4] =
+{
+ { /* input: sRGB-gray */
+  { 0, 0, 7, 0 }, { 0, 0, 7, 0 }, { 0, 0, 7, 0 }, { 0, 0, 7, 0 }
+ }, { /* input: sRGB-gray+alpha */
+  { 0, 15, 15, 0 }, { 0, 186, 15, 0 }, { 0, 15, 15, 0 }, { 0, 186, 15, 0 }
+ }, { /* input: sRGB-rgb */
+  { 0, 0, 19, 0 }, { 0, 0, 19, 0 }, { 0, 0, 15, 0 }, { 0, 0, 15, 0 }
+ }, { /* input: sRGB-rgb+alpha */
+  { 0, 12, 14, 0 }, { 0, 180, 14, 0 }, { 0, 14, 15, 0 }, { 0, 186, 15, 0 }
+ }, { /* input: linear-gray */
+  { 0, 0, 1, 0 }, { 0, 0, 1, 0 }, { 0, 0, 1, 0 }, { 0, 0, 1, 0 }
+ }, { /* input: linear-gray+alpha */
+  { 0, 1, 1, 0 }, { 0, 1, 1, 0 }, { 0, 1, 1, 0 }, { 0, 1, 1, 0 }
+ }, { /* input: linear-rgb */
+  { 0, 0, 1, 0 }, { 0, 0, 1, 0 }, { 0, 0, 1, 0 }, { 0, 0, 1, 0 }
+ }, { /* input: linear-rgb+alpha */
+  { 0, 1, 1, 0 }, { 0, 8, 1, 0 }, { 0, 1, 1, 0 }, { 0, 1, 1, 0 }
+ }, { /* input: color-mapped-sRGB-gray */
+  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }
+ }, { /* input: color-mapped-sRGB-gray+alpha */
+  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }
+ }, { /* input: color-mapped-sRGB-rgb */
+  { 0, 0, 13, 0 }, { 0, 0, 13, 0 }, { 0, 0, 14, 0 }, { 0, 0, 14, 0 }
+ }, { /* input: color-mapped-sRGB-rgb+alpha */
+  { 0, 4, 8, 0 }, { 0, 9, 8, 0 }, { 0, 8, 3, 0 }, { 0, 32, 3, 0 }
+ }, { /* input: color-mapped-linear-gray */
+  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }
+ }, { /* input: color-mapped-linear-gray+alpha */
+  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }
+ }, { /* input: color-mapped-linear-rgb */
+  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }
+ }, { /* input: color-mapped-linear-rgb+alpha */
+  { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }
+ }
+};
+static png_uint_16 gpc_error_to_colormap[8/*i*/][8/*o*/][4] =
+{
+ { /* input: sRGB-gray */
+  { 0, 0, 9, 0 }, { 0, 0, 9, 0 }, { 0, 0, 9, 0 }, { 0, 0, 9, 0 },
+  { 0, 0, 560, 0 }, { 0, 0, 560, 0 }, { 0, 0, 560, 0 }, { 0, 0, 560, 0 }
+ }, { /* input: sRGB-gray+alpha */
+  { 0, 19, 2, 0 }, { 0, 255, 2, 25 }, { 0, 88, 2, 0 }, { 0, 255, 2, 25 },
+  { 0, 1012, 745, 0 }, { 0, 16026, 745, 6425 }, { 0, 1012, 745, 0 }, { 0, 16026, 745, 6425 }
+ }, { /* input: sRGB-rgb */
+  { 0, 0, 19, 0 }, { 0, 0, 19, 0 }, { 0, 0, 25, 0 }, { 0, 0, 25, 0 },
+  { 0, 0, 937, 0 }, { 0, 0, 937, 0 }, { 0, 0, 13677, 0 }, { 0, 0, 13677, 0 }
+ }, { /* input: sRGB-rgb+alpha */
+  { 0, 63, 77, 0 }, { 0, 255, 19, 25 }, { 0, 220, 25, 0 }, { 0, 255, 25, 67 },
+  { 0, 17534, 18491, 0 }, { 0, 15614, 2824, 6425 }, { 0, 14019, 13677, 0 }, { 0, 48573, 13677, 17219 }
+ }, { /* input: linear-gray */
+  { 0, 0, 73, 0 }, { 0, 0, 73, 0 }, { 0, 0, 73, 0 }, { 0, 0, 73, 0 },
+  { 0, 0, 18817, 0 }, { 0, 0, 18817, 0 }, { 0, 0, 18817, 0 }, { 0, 0, 18817, 0 }
+ }, { /* input: linear-gray+alpha */
+  { 0, 74, 74, 0 }, { 0, 255, 74, 25 }, { 0, 97, 74, 0 }, { 0, 255, 74, 25 },
+  { 0, 18919, 18907, 0 }, { 0, 24549, 18907, 6552 }, { 0, 18919, 18907, 0 }, { 0, 24549, 18907, 6552 }
+ }, { /* input: linear-rgb */
+  { 0, 0, 73, 0 }, { 0, 0, 73, 0 }, { 0, 0, 98, 0 }, { 0, 0, 98, 0 },
+  { 0, 0, 18664, 0 }, { 0, 0, 18664, 0 }, { 0, 0, 24998, 0 }, { 0, 0, 24998, 0 }
+ }, { /* input: linear-rgb+alpha */
+  { 0, 181, 196, 0 }, { 0, 255, 61, 25 }, { 206, 187, 98, 0 }, { 0, 255, 98, 67 },
+  { 0, 18141, 18137, 0 }, { 0, 17494, 17504, 6553 }, { 0, 24979, 24992, 0 }, { 0, 46509, 24992, 17347 }
+ }
+};
+/* END MACHINE GENERATED */
 #endif /* COLORMAP flag check */
 #endif /* flag checks */
 
@@ -2005,7 +2154,7 @@ typedef struct
    int          in_opaque;   /* Value of input alpha that is opaque */
    int          is_palette;  /* Sample values come from the palette */
    int          accumulate;  /* Accumlate component errors (don't log) */
-   int          output_8bit; /* Output is 8-bit (else 16-bit) */
+   int          output_8bit; /* Output is 8 bit (else 16 bit) */
 
    void (*in_gp)(Pixel*, png_const_voidp);
    void (*out_gp)(Pixel*, png_const_voidp);
@@ -2679,7 +2828,7 @@ compare_two_images(Image *a, Image *b, int via_linear,
 
             else if (y >= b->image.colormap_entries)
             {
-               if ((b->opts & ACCUMULATE) == 0)
+               if ((a->opts & ACCUMULATE) == 0)
                   {
                   char pindex[9];
                   sprintf(pindex, "%lu[%lu]", (unsigned long)y,
@@ -3026,9 +3175,7 @@ read_one_file(Image *image)
 
                if (cb > 0)
                {
-#ifndef __COVERITY__
                   if ((unsigned long int)cb <= (size_t)~(size_t)0)
-#endif
                   {
                      png_bytep b = voidcast(png_bytep, malloc((size_t)cb));
 
@@ -3096,40 +3243,7 @@ write_one_file(Image *output, Image *image, int convert_to_8bit)
 
    if (image->opts & USE_STDIO)
    {
-#ifndef PNG_USE_MKSTEMP
       FILE *f = tmpfile();
-#else
-      /* Experimental. Coverity says tmpfile() is insecure because it
-       * generates predictable names.
-       *
-       * It is possible to satisfy Coverity by using mkstemp(); however,
-       * any platform supporting mkstemp() undoubtedly has a secure tmpfile()
-       * implementation as well, and doesn't need the fix.  Note that
-       * the fix won't work on platforms that don't support mkstemp().
-       *
-       * https://www.securecoding.cert.org/confluence/display/c/
-       * FIO21-C.+Do+not+create+temporary+files+in+shared+directories
-       * says that most historic implementations of tmpfile() provide
-       * only a limited number of possible temporary file names
-       * (usually 26) before file names are recycled. That article also
-       * provides a secure solution that unfortunately depends upon mkstemp().
-       */
-      char tmpfile[] = "pngstest-XXXXXX";
-      int filedes;
-      FILE *f;
-      umask(0177);
-      filedes = mkstemp(tmpfile);
-      if (filedes < 0)
-        f = NULL;
-      else
-      {
-        f = fdopen(filedes,"w+");
-        /* Hide the filename immediately and ensure that the file does
-         * not exist after the program ends
-         */
-        (void) unlink(tmpfile);
-      }
-#endif
 
       if (f != NULL)
       {
@@ -3474,7 +3588,7 @@ main(int argc, char **argv)
             }
 
             /* Safe: checked above */
-            strncpy(tmpf, argv[c], sizeof (tmpf)-1);
+            strcpy(tmpf, argv[c]);
          }
 
          else
@@ -3573,23 +3687,6 @@ main(int argc, char **argv)
    {
       unsigned int in;
 
-      printf("/* contrib/libtests/pngstest-errors.h\n");
-      printf(" *\n");
-      printf(" * BUILT USING:" PNG_HEADER_VERSION_STRING);
-      printf(" *\n");
-      printf(" * This code is released under the libpng license.\n");
-      printf(" * For conditions of distribution and use, see the disclaimer\n");
-      printf(" * and license in png.h\n");
-      printf(" *\n");
-      printf(" * THIS IS A MACHINE GENERATED FILE: do not edit it directly!\n");
-      printf(" * Instead run:\n");
-      printf(" *\n");
-      printf(" *    pngstest --accumulate\n");
-      printf(" *\n");
-      printf(" * on as many PNG files as possible; at least PNGSuite and\n");
-      printf(" * contrib/libtests/testpngs.\n");
-      printf(" */\n");
-
       printf("static png_uint_16 gpc_error[16/*in*/][16/*out*/][4/*a*/] =\n");
       printf("{\n");
       for (in=0; in<16; ++in)
@@ -3679,7 +3776,6 @@ main(int argc, char **argv)
             putchar('\n');
       }
       printf("};\n");
-      printf("/* END MACHINE GENERATED */\n");
    }
 
    if (retval == 0 && touch != NULL)

contrib/libtests/pngunknown.c

@@ -363,7 +363,7 @@ ancillary(const char *name)
    return PNG_CHUNK_ANCILLARY(PNG_U32(name[0], name[1], name[2], name[3]));
 }
 
-#ifdef PNG_SAVE_UNKNOWN_CHUNKS_SUPPORTED
+#ifdef PNG_STORE_UNKNOWN_CHUNKS_SUPPORTED
 static int
 ancillaryb(const png_byte *name)
 {
@@ -554,7 +554,7 @@ read_callback(png_structp pp, png_unknown_chunkp pc)
    /* However if there is no support to store unknown chunks don't ask libpng to
     * do it; there will be an png_error.
     */
-#  ifdef PNG_SAVE_UNKNOWN_CHUNKS_SUPPORTED
+#  ifdef PNG_STORE_UNKNOWN_CHUNKS_SUPPORTED
       return discard;
 #  else
       return 1; /*handled; discard*/
@@ -562,7 +562,7 @@ read_callback(png_structp pp, png_unknown_chunkp pc)
 }
 #endif /* READ_USER_CHUNKS_SUPPORTED */
 
-#ifdef PNG_SAVE_UNKNOWN_CHUNKS_SUPPORTED
+#ifdef PNG_STORE_UNKNOWN_CHUNKS_SUPPORTED
 static png_uint_32
 get_unknown(display *d, png_infop info_ptr, int after_IDAT)
 {
@@ -722,17 +722,11 @@ check(FILE *fp, int argc, const char **argv, png_uint_32p flags/*out*/,
                    * in this case, so we just check the arguments!  This could
                    * be improved in the future by using the read callback.
                    */
-#                 if PNG_LIBPNG_VER >= 10700 &&\
-                     !defined(PNG_SAVE_UNKNOWN_CHUNKS_SUPPORTED)
-                     if (option < PNG_HANDLE_CHUNK_IF_SAFE)
-#                 endif /* 1.7+ SAVE_UNKNOWN_CHUNKS */
-                  {
-                     png_byte name[5];
+                  png_byte name[5];
 
-                     memcpy(name, chunk_info[chunk].name, 5);
-                     png_set_keep_unknown_chunks(d->png_ptr, option, name, 1);
-                     chunk_info[chunk].keep = option;
-                  }
+                  memcpy(name, chunk_info[chunk].name, 5);
+                  png_set_keep_unknown_chunks(d->png_ptr, option, name, 1);
+                  chunk_info[chunk].keep = option;
                   continue;
                }
 
@@ -741,12 +735,7 @@ check(FILE *fp, int argc, const char **argv, png_uint_32p flags/*out*/,
             case 7: /* default */
                if (memcmp(argv[i], "default", 7) == 0)
                {
-#                 if PNG_LIBPNG_VER >= 10700 &&\
-                     !defined(PNG_SAVE_UNKNOWN_CHUNKS_SUPPORTED)
-                     if (option < PNG_HANDLE_CHUNK_IF_SAFE)
-#                 endif /* 1.7+ SAVE_UNKNOWN_CHUNKS */
-                     png_set_keep_unknown_chunks(d->png_ptr, option, NULL, 0);
-
+                  png_set_keep_unknown_chunks(d->png_ptr, option, NULL, 0);
                   d->keep = option;
                   continue;
                }
@@ -756,12 +745,7 @@ check(FILE *fp, int argc, const char **argv, png_uint_32p flags/*out*/,
             case 3: /* all */
                if (memcmp(argv[i], "all", 3) == 0)
                {
-#                 if PNG_LIBPNG_VER >= 10700 &&\
-                     !defined(PNG_SAVE_UNKNOWN_CHUNKS_SUPPORTED)
-                     if (option < PNG_HANDLE_CHUNK_IF_SAFE)
-#                 endif /* 1.7+ SAVE_UNKNOWN_CHUNKS */
-                     png_set_keep_unknown_chunks(d->png_ptr, option, NULL, -1);
-
+                  png_set_keep_unknown_chunks(d->png_ptr, option, NULL, -1);
                   d->keep = option;
 
                   for (chunk = 0; chunk < NINFO; ++chunk)
@@ -1001,20 +985,6 @@ perform_one_test(FILE *fp, int argc, const char **argv,
 
    def = check(fp, argc, argv, flags[1], d, set_callback);
 
-   /* If IDAT is being handled as unknown the image read is skipped and all the
-    * IDATs after the first end up in the end info struct, so in this case add
-    * IDAT to the list of unknowns.  (Do this after 'check' above sets the
-    * chunk_info 'keep' fields.)
-    *
-    * Note that the flag setting has to be in the 'known' field to avoid
-    * triggeriing the consistency check below and the flag must only be set if
-    * there are multiple IDATs, so if the check above did find an unknown IDAT
-    * after IDAT.
-    */
-   if (chunk_info[0/*IDAT*/].keep != PNG_HANDLE_CHUNK_AS_DEFAULT &&
-       (flags[1][3] & PNG_INFO_IDAT) != 0)
-      flags[0][2] |= PNG_INFO_IDAT;
-
    /* Chunks should either be known or unknown, never both and this should apply
     * whether the chunk is before or after the IDAT (actually, the app can
     * probably change this by swapping the handling after the image, but this

contrib/libtests/readpng.c

@@ -62,7 +62,6 @@ read_png(FILE *fp)
    {
       png_size_t rowbytes = png_get_rowbytes(png_ptr, info_ptr);
 
-      /* Failure to initialize these is harmless */
       row = malloc(rowbytes);
       display = malloc(rowbytes);
 
@@ -71,12 +70,7 @@ read_png(FILE *fp)
 
       {
          png_uint_32 height = png_get_image_height(png_ptr, info_ptr);
-#        ifdef PNG_READ_INTERLACING_SUPPORTED
-            int passes = png_set_interlace_handling(png_ptr);
-#        else /* !READ_INTERLACING */
-            int passes = png_get_interlace_type(png_ptr, info_ptr) ==
-               PNG_INTERLACE_ADAM7 ? PNG_INTERLACE_ADAM7_PASSES : 1;
-#        endif /* !READ_INTERLACING */
+         int passes = png_set_interlace_handling(png_ptr);
          int pass;
 
          png_start_read_image(png_ptr);
@@ -85,11 +79,6 @@ read_png(FILE *fp)
          {
             png_uint_32 y = height;
 
-#           ifndef PNG_READ_INTERLACING_SUPPORTED
-               if (passes == PNG_INTERLACE_ADAM7_PASSES)
-                  y = PNG_PASS_ROWS(y, pass);
-#           endif /* READ_INTERLACING */
-
             /* NOTE: this trashes the row each time; interlace handling won't
              * work, but this avoids memory thrashing for speed testing.
              */

contrib/libtests/tarith.c

@@ -634,7 +634,7 @@ int validation_muldiv(int count, int argc, char **argv)
    {
       png_fixed_point result;
       /* NOTE: your mileage may vary, a type is required below that can
-       * hold 64 bits or more, if floating point is used a 64-bit or
+       * hold 64 bits or more, if floating point is used a 64 bit or
        * better mantissa is required.
        */
       long long int fp, fpround;
@@ -721,7 +721,7 @@ int validation_muldiv(int count, int argc, char **argv)
    }
    while (--count > 0);
 
-   printf("%d tests including %d overflows, %d passed, %d failed (%d 64-bit "
+   printf("%d tests including %d overflows, %d passed, %d failed (%d 64 bit "
       "errors)\n", tested, overflow, passed, error, error64);
    return 0;
 }
@@ -799,13 +799,13 @@ int validation_gamma(int argc, char **argv)
          if (i == 0 && png_log8bit(i) != 0xffffffff ||
              i != 0 && png_log8bit(i) != floor(correct+.5))
          {
-            fprintf(stderr, "8-bit log error: %d: got %u, expected %f\n",
+            fprintf(stderr, "8 bit log error: %d: got %u, expected %f\n",
                i, png_log8bit(i), correct);
          }
       }
 
       if (!silent)
-         printf("maximum 8-bit log error = %f\n", maxerr);
+         printf("maximum 8 bit log error = %f\n", maxerr);
 
       maxerr = 0;
       for (i=0; i<65536; ++i)
@@ -821,14 +821,14 @@ int validation_gamma(int argc, char **argv)
          {
             if (error > .68) /* By experiment error is less than .68 */
             {
-               fprintf(stderr, "16-bit log error: %d: got %u, expected %f"
+               fprintf(stderr, "16 bit log error: %d: got %u, expected %f"
                   " error: %f\n", i, png_log16bit(i), correct, error);
             }
          }
       }
 
       if (!silent)
-         printf("maximum 16-bit log error = %f\n", maxerr);
+         printf("maximum 16 bit log error = %f\n", maxerr);
 
       /* Now exponentiations. */
       maxerr = 0;
@@ -841,13 +841,13 @@ int validation_gamma(int argc, char **argv)
             maxerr = fabs(error);
          if (fabs(error) > 1883) /* By experiment. */
          {
-            fprintf(stderr, "32-bit exp error: %d: got %u, expected %f"
+            fprintf(stderr, "32 bit exp error: %d: got %u, expected %f"
                   " error: %f\n", i, png_exp(i), correct, error);
          }
       }
 
       if (!silent)
-         printf("maximum 32-bit exp error = %f\n", maxerr);
+         printf("maximum 32 bit exp error = %f\n", maxerr);
 
       maxerr = 0;
       for (i=0; i<=0xfffff; ++i)
@@ -859,13 +859,13 @@ int validation_gamma(int argc, char **argv)
             maxerr = fabs(error);
          if (fabs(error) > .50002) /* By experiment */
          {
-            fprintf(stderr, "8-bit exp error: %d: got %u, expected %f"
+            fprintf(stderr, "8 bit exp error: %d: got %u, expected %f"
                   " error: %f\n", i, png_exp8bit(i), correct, error);
          }
       }
 
       if (!silent)
-         printf("maximum 8-bit exp error = %f\n", maxerr);
+         printf("maximum 8 bit exp error = %f\n", maxerr);
 
       maxerr = 0;
       for (i=0; i<=0xfffff; ++i)
@@ -877,13 +877,13 @@ int validation_gamma(int argc, char **argv)
             maxerr = fabs(error);
          if (fabs(error) > .524) /* By experiment */
          {
-            fprintf(stderr, "16-bit exp error: %d: got %u, expected %f"
+            fprintf(stderr, "16 bit exp error: %d: got %u, expected %f"
                   " error: %f\n", i, png_exp16bit(i), correct, error);
          }
       }
 
       if (!silent)
-         printf("maximum 16-bit exp error = %f\n", maxerr);
+         printf("maximum 16 bit exp error = %f\n", maxerr);
    } /* !onlygamma */
 
    /* Test the overall gamma correction. */
@@ -913,7 +913,7 @@ int validation_gamma(int argc, char **argv)
       }
 
       if (!silent)
-         printf("gamma %f: maximum 8-bit error %f\n", g, maxerr);
+         printf("gamma %f: maximum 8 bit error %f\n", g, maxerr);
 
       maxerr = 0;
       for (j=0; j<65536; ++j)
@@ -932,7 +932,7 @@ int validation_gamma(int argc, char **argv)
       }
 
       if (!silent)
-         printf("gamma %f: maximum 16-bit error %f\n", g, maxerr);
+         printf("gamma %f: maximum 16 bit error %f\n", g, maxerr);
    }
 
    return 0;

contrib/neon/extensions.ac

@@ -1,10 +0,0 @@
-# To just this extension either copy the 'sinclude' line and the setting of
-# libpng_automake_extensions into contrib/extensions.am or link/copy the whole
-# file there.  Do the same with the associated file extensions.am
-#
-# Include the ARM NEON extension:
-sinclude([contrib/neon/neon.ac])
-#
-# If any of the extensions require automake support (this is likely) automake
-# must include the file contrib/extensions.am
-libpng_automake_extensions="yes"

contrib/neon/extensions.am

@@ -1,5 +0,0 @@
-# To just this extension either copy the 'include' line into
-# contrib/extensions.am or link/copy the whole file there.  Do the same with the
-# associated file extensions.ac
-# Include the ARM NEON extension:
-include %reldir%/neon/neon.am

contrib/neon/neon.ac

@@ -1,47 +0,0 @@
-# LIBPNG EXTENSION: NEON
-#
-# ARM NEON (SIMD) support.
-#
-# This file contains configure.ac additions to libpng configure to enable
-# building of the ARM NEON filter optimizations.
-#
-AC_ARG_ENABLE([arm-neon],
-   AS_HELP_STRING([[[--enable-arm-neon]]],
-      [Enable ARM NEON optimizations: =no/off, check, api, yes/on:]
-      [no/off: disable the optimizations; check: use internal checking code]
-      [(deprecated and poorly supported); api: disable by default, enable by]
-      [a call to png_set_option; yes/on: turn on unconditionally.]
-      [If not specified: determined by the compiler.]),
-   [case "$enableval" in
-      no|off)
-         # disable the default enabling on __ARM_NEON__ systems:
-         AC_DEFINE([PNG_ARM_NEON_OPT], [0],
-                   [Disable ARM Neon optimizations])
-         # Prevent inclusion of the assembler files below:
-         enable_arm_neon=no;;
-      check)
-         AC_DEFINE([PNG_ARM_NEON_CHECK_SUPPORTED], [],
-                   [Check for ARM Neon support at run-time]);;
-      api)
-         AC_DEFINE([PNG_ARM_NEON_API_SUPPORTED], [],
-                   [Turn on ARM Neon optimizations at run-time]);;
-      yes|on)
-         AC_DEFINE([PNG_ARM_NEON_OPT], [2],
-                   [Enable ARM Neon optimizations])
-         AC_MSG_WARN([--enable-arm-neon: please specify 'check' or 'api', if]
-            [you want the optimizations unconditionally pass -mfpu=neon]
-            [to the compiler.]);;
-      *)
-         AC_MSG_ERROR([--enable-arm-neon=${enable_arm_neon}: invalid value])
-   esac])
-
-# Add ARM specific files to all builds where the host_cpu is arm ('arm*') or
-# where ARM optimizations were explicitly requested (this allows a fallback if a
-# future host CPU does not match 'arm*')
-
-AM_CONDITIONAL([PNG_ARM_NEON],
-   [test "$enable_arm_neon" != 'no' &&
-    case "$host_cpu" in
-      arm*|aarch64*) :;;
-      *)    test "$enable_arm_neon" != '';;
-    esac])

contrib/neon/neon.am

@@ -1,27 +0,0 @@
-# contrib/neon/neon.am
-#
-# This is an automake fragment included by the top-level Makefile.am if
-# contrib/neon/neon.ac is included in configure
-#
-# It builds the source files in this directory into ARM hardware support for
-# libpng.
-#
-if PNG_ARM_NEON
-libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@_la_SOURCES += %D%/arm_init.c\
-	%D%/filter_neon.S %D%/filter_neon_intrinsics.c
-
-DFA_EXTENSION += ${srcdir}/%D%/neon.dfa
-
-# This causes pngpriv.h to include the named header.  It is VERY important to
-# understand that this MUST be defined and the header MUST define internal
-# 'extern' functions with PNG_INTERNAL_FUNCTION.  This allows vendors to use
-# static library builds of libpng without clashing with the installed system
-# libpng; see the libpng-prefix option in configure.ac  The value of this
-# #define is included in pnglibconf.h
-#
-# NOTE: you must include the double quotes in the value and you must therefore
-# support the whole thing with single quotes.  If you need to use <> for a
-# header be aware that if you miss out the single quotes you will create a
-# random file.
-AM_CPPFLAGS += -DPNG_EXTENSION_HEADER='"%D%/neon.h"'
-endif

contrib/neon/neon.dfa

@@ -1,41 +0,0 @@
-# contrib/arm/neon.dfa
-#
-# This is a dfa fragment that is added to DFA_HARDWARE in Makefile.am and
-# consequently is inserted after scripts/pnglibconf.dfa to define extra,
-# hardware, options.
-#
-# The following are required in any fragment to record the copyright holder of
-# the *changes* and the appropriate email for bug reports.  Note that the
-# copyright here is just for the specific configuration; additional files may
-# have additional and/or different copyrights.
-#
-# Later settings (e.g. in user.dfa) will override these settings.
-#
-setting USER_PRIVATEBUILD default "John Bowler"
-setting USER_BUG_REPORTS default "jbowler@acm.org"
-#
-# These options are specific to the ARM NEON hardware optimizations.  At present
-# these optimizations depend on GCC specific pre-processing of an assembler (.S)
-# file so they probably won't work with other compilers.
-#
-# ARM_NEON_OPT: unset: check at compile time (__ARM_NEON__ must be defined by
-#                      the compiler, typically as a result of specifying
-#                      CC="gcc -mfpu=neon".)
-#                   0: disable (even if the CPU has a NEON FPU.)
-#                   1: check at run time (via ARM_NEON_{API,CHECK})
-#                   2: switch on unconditionally (inadvisable - instead pass
-#                      -mfpu=neon to GCC in CC)
-#           When building libpng avoid using any setting other than '0'; '1' is
-#           set automatically when either 'API' or 'CHECK' are configured in,
-#           '2' should not be necessary as -mfpu=neon will achieve the same
-#           effect as well as applying NEON optimizations to the rest of the
-#           libpng code.
-#           NOTE: any setting other than '0' requires ALIGNED_MEMORY
-# ARM_NEON_API:   (PNG_ARM_NEON == 1) allow the optimization to be switched on
-#                 with png_set_option
-# ARM_NEON_CHECK: (PNG_ARM_NEON == 1) compile a run-time check to see if Neon
-#                 extensions are supported. This is poorly supported and
-#                 deprecated - use the png_set_option API.
-setting ARM_NEON_OPT
-option ARM_NEON_API disabled enables SET_OPTION sets ARM_NEON_OPT 1
-option ARM_NEON_CHECK disabled sets ARM_NEON_OPT 1

contrib/neon/neon.h

@@ -1,124 +0,0 @@
-/* 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.  An example is iOS vs Android compilation of ARM NEON support.
- *
- * 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 supports NEON instructions 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 older versions of GCC defined __ARM_NEON__; this is no longer
-    * supported.  Also 32-bit ARM versions of GCC required the NEON FPU mode to
-    * be turned on explicitly on the command line.  If this is not done (on
-    * 32-bit ARM) NEON code will not be included.
-    *
-    * 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(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
-#     ifdef __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 compiler support
-          * and that support switches on __ARM_NEON, so use the assembler:
-          */
-#        define PNG_ARM_NEON_IMPLEMENTATION 2
-#     endif /* __ARM_NEON */
-#  endif /* !defined 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 */
-
-#ifdef PNG_SET_OPTION_SUPPORTED
-#ifdef PNG_ARM_NEON_API_SUPPORTED
-#  define PNG_ARM_NEON   0 /* HARDWARE: ARM Neon SIMD instructions supported */
-#endif
-#endif /* SET_OPTION */
-
-#if PNG_ARM_NEON_OPT > 0
-PNG_INTERNAL_FUNCTION(void,png_read_filter_row_up_neon,
-   (png_alloc_size_t row_bytes, unsigned int bpp, png_bytep row,
-    png_const_bytep prev_row),PNG_EMPTY);
-PNG_INTERNAL_FUNCTION(void,png_read_filter_row_sub3_neon,
-   (png_alloc_size_t row_bytes, unsigned int bpp, png_bytep row,
-    png_const_bytep prev_row),PNG_EMPTY);
-PNG_INTERNAL_FUNCTION(void,png_read_filter_row_sub4_neon,
-   (png_alloc_size_t row_bytes, unsigned int bpp, png_bytep row,
-    png_const_bytep prev_row),PNG_EMPTY);
-PNG_INTERNAL_FUNCTION(void,png_read_filter_row_avg3_neon,
-   (png_alloc_size_t row_bytes, unsigned int bpp, png_bytep row,
-    png_const_bytep prev_row),PNG_EMPTY);
-PNG_INTERNAL_FUNCTION(void,png_read_filter_row_avg4_neon,
-   (png_alloc_size_t row_bytes, unsigned int bpp, png_bytep row,
-    png_const_bytep prev_row),PNG_EMPTY);
-PNG_INTERNAL_FUNCTION(void,png_read_filter_row_paeth3_neon,
-   (png_alloc_size_t row_bytes, unsigned int bpp, png_bytep row,
-    png_const_bytep prev_row),PNG_EMPTY);
-PNG_INTERNAL_FUNCTION(void,png_read_filter_row_paeth4_neon,
-   (png_alloc_size_t row_bytes, unsigned int bpp, png_bytep row,
-    png_const_bytep prev_row),PNG_EMPTY);
-#endif

contrib/pngminim/decoder/makefile

@@ -56,7 +56,7 @@ PNGSRCS=png$(C) pngerror$(C) pngget$(C) pngmem$(C) \
 	pngset$(C) pngtrans$(C)
 	
 # Standard headers
-PNGH   =png.h pngconf.h pngdebug.h pnginfo.h pngpriv.h pngstruct.h pngchunk.h
+PNGH   =png.h pngconf.h pngdebug.h pnginfo.h pngpriv.h pngstruct.h
 
 # Machine generated headers
 PNGCONF=pnglibconf.h

contrib/pngminim/decoder/pngusr.dfa

@@ -36,7 +36,5 @@ option FLOATING_ARITHMETIC off
 option SETJMP on
 option STDIO on
 option READ_EXPAND on
-option READ_IMAGE on
-option READ_INTERLACING on
 option READ_STRIP_16_TO_8 on
 option USER_LIMITS on

contrib/pngminim/decoder/pngusr.h

@@ -18,7 +18,6 @@
  * affect the API (so are not recorded in pnglibconf.h)
  */
 
-#define PNG_RELEASE_BUILD 1
 #define PNG_ALIGN_TYPE PNG_ALIGN_NONE
 
 #endif /* MINRDPNGCONF_H */

contrib/pngminim/encoder/makefile

@@ -56,7 +56,7 @@ PNGSRCS=png$(C) pngerror$(C) pngget$(C) pngmem$(C) \
 	pngwtran$(C) pngwutil$(C)
 
 # Standard headers
-PNGH   =png.h pngconf.h pngdebug.h pnginfo.h pngpriv.h pngstruct.h pngchunk.h
+PNGH   =png.h pngconf.h pngdebug.h pnginfo.h pngpriv.h pngstruct.h
 
 # Machine generated headers
 PNGCONF=pnglibconf.h

contrib/pngminim/encoder/pngusr.h

@@ -18,7 +18,6 @@
  * affect the API (so are not recorded in pnglibconf.h)
  */
 
-#define PNG_RELEASE_BUILD 1
 #define PNG_ALIGN_TYPE PNG_ALIGN_NONE
 
 #endif /* MINWRPNGCONF_H */

contrib/pngminim/preader/makefile

@@ -72,7 +72,7 @@ PNGSRCS=png$(C) pngerror$(C) pngget$(C) pngmem$(C) \
 	pngset$(C) pngtrans$(C)
 
 # Standard headers
-PNGH   =png.h pngconf.h pngdebug.h pnginfo.h pngpriv.h pngstruct.h pngchunk.h
+PNGH   =png.h pngconf.h pngdebug.h pnginfo.h pngpriv.h pngstruct.h
 
 # Machine generated headers
 PNGCONF=pnglibconf.h

contrib/pngminim/preader/pngusr.dfa

@@ -36,6 +36,5 @@ option STDIO on
 option READ_bKGD on
 option READ_GAMMA on
 option READ_EXPAND on
-option READ_INTERLACING on
 option READ_STRIP_16_TO_8 on
 option READ_GRAY_TO_RGB on

contrib/pngminim/preader/pngusr.h

@@ -18,7 +18,6 @@
  * affect the API (so are not recorded in pnglibconf.h)
  */
 
-#define PNG_RELEASE_BUILD 1
 #define PNG_ALIGN_TYPE PNG_ALIGN_NONE
 
 #endif /* MINPRDPNGCONF_H */

contrib/pngminus/makefile.std

@@ -8,9 +8,9 @@ LD=$(CC)
 RM=rm -f
 
 #PNGPATH = /usr/local
-#PNGINC = -I$(PNGPATH)/include/libpng17
-#PNGLIB = -L$(PNGPATH)/lib -lpng17
-#PNGLIBS = $(PNGPATH)/lib/libpng17.a
+#PNGINC = -I$(PNGPATH)/include/libpng16
+#PNGLIB = -L$(PNGPATH)/lib -lpng16
+#PNGLIBS = $(PNGPATH)/lib/libpng16.a
 PNGINC = -I../..
 PNGLIB = -L../.. -lpng
 PNGLIBS = ../../libpng.a
@@ -23,7 +23,8 @@ ZINC = -I../../../zlib
 ZLIB = -L../../../zlib -lz
 ZLIBS = ../../../zlib/libz.a
 
-CFLAGS=$(PNGINC) $(ZINC)
+CPPFLAGS=$(PNGINC) $(ZINC)
+CFLAGS=
 LDLIBS=$(PNGLIB) $(ZLIB)
 LDLIBSS=$(PNGLIBS) $(ZLIBS)
 C=.c
@@ -37,7 +38,7 @@ E=
 all: png2pnm$(E) pnm2png$(E) png2pnm-static$(E) pnm2png-static$(E)
 
 png2pnm$(O): png2pnm$(C)
-	$(CC) -c $(CFLAGS) png2pnm$(C)
+	$(CC) -c $(CPPFLAGS) $(CFLAGS) png2pnm$(C)
 
 png2pnm$(E): png2pnm$(O)
 	$(LD) $(LDFLAGS) -o png2pnm$(E) png2pnm$(O) $(LDLIBS) -lm
@@ -46,7 +47,7 @@ png2pnm-static$(E): png2pnm$(O)
 	$(LD) $(LDFLAGS) -o png2pnm-static$(E) png2pnm$(O) $(LDLIBSS) -lm
 
 pnm2png$(O): pnm2png$(C)
-	$(CC) -c $(CFLAGS) pnm2png$(C)
+	$(CC) -c $(CPPFLAGS) $(CFLAGS) pnm2png$(C)
 
 pnm2png$(E): pnm2png$(O)
 	$(LD) $(LDFLAGS) -o pnm2png$(E) pnm2png$(O) $(LDLIBS) -lm

contrib/pngminus/makefile.tc3

@@ -7,7 +7,8 @@ LB=tlib
 RM=del
 CP=copy
 MODEL=l
-CCFLAGS=-O -m$(MODEL) -I..\libpng -I..\zlib
+CPPFLAGS=-I..\libpng -I..\zlib
+CFLAGS=-O -m$(MODEL)
 LDFLAGS=-m$(MODEL) -L..\libpng -L..\zlib
 C=.c
 O=.obj
@@ -19,13 +20,13 @@ E=.exe
 all: png2pnm$(E) pnm2png$(E)
 
 png2pnm$(O): png2pnm$(C)
-        $(CC) -c $(CCFLAGS) png2pnm$(C)
+        $(CC) -c $(CPPFLAGS) $(CFLAGS) png2pnm$(C)
 
 png2pnm$(E): png2pnm$(O)
         $(LD) $(LDFLAGS) png2pnm$(O) libpng$(L) zlib$(L)
 
 pnm2png$(O): pnm2png$(C)
-        $(CC) -c $(CCFLAGS) pnm2png$(C)
+        $(CC) -c $(CPPFLAGS) $(CFLAGS) pnm2png$(C)
 
 pnm2png$(E): pnm2png$(O)
         $(LD) $(LDFLAGS) pnm2png$(O) libpng$(L) zlib$(L)
@@ -35,4 +36,3 @@ clean:
         $(RM) *$(E)
 
 # End of makefile for png2pnm / pnm2png
-

contrib/pngminus/png2pnm.c

@@ -52,7 +52,8 @@
 
 int  main (int argc, char *argv[]);
 void usage ();
-BOOL png2pnm (FILE *png_file, FILE *pnm_file, FILE *alpha_file, BOOL raw, BOOL alpha);
+BOOL png2pnm (FILE *png_file, FILE *pnm_file, FILE *alpha_file, BOOL raw,
+   BOOL alpha);
 
 /*
  *  main
@@ -85,7 +86,8 @@ int main(int argc, char *argv[])
           if ((fp_al = fopen (argv[argi], "wb")) == NULL)
           {
             fprintf (stderr, "PNM2PNG\n");
-            fprintf (stderr, "Error:  can not create alpha-channel file %s\n", argv[argi]);
+            fprintf (stderr, "Error:  can not create alpha-channel file %s\n",
+               argv[argi]);
             exit (1);
           }
           break;
@@ -176,9 +178,11 @@ void usage()
   fprintf (stderr, "Usage:  png2pnm [options] <file>.png [<file>.pnm]\n");
   fprintf (stderr, "   or:  ... | png2pnm [options]\n");
   fprintf (stderr, "Options:\n");
-  fprintf (stderr, "   -r[aw]   write pnm-file in binary format (P4/P5/P6) (default)\n");
+  fprintf (stderr,
+     "   -r[aw]   write pnm-file in binary format (P4/P5/P6) (default)\n");
   fprintf (stderr, "   -n[oraw] write pnm-file in ascii format (P1/P2/P3)\n");
-  fprintf (stderr, "   -a[lpha] <file>.pgm write PNG alpha channel as pgm-file\n");
+  fprintf (stderr,
+     "   -a[lpha] <file>.pgm write PNG alpha channel as pgm-file\n");
   fprintf (stderr, "   -h | -?  print this help-information\n");
 }
 
@@ -186,7 +190,8 @@ void usage()
  *  png2pnm
  */
 
-BOOL png2pnm (FILE *png_file, FILE *pnm_file, FILE *alpha_file, BOOL raw, BOOL alpha)
+BOOL png2pnm (FILE *png_file, FILE *pnm_file, FILE *alpha_file,
+    volatile BOOL raw, BOOL alpha)
 {
   png_struct    *png_ptr = NULL;
   png_info        *info_ptr = NULL;
@@ -218,7 +223,7 @@ BOOL png2pnm (FILE *png_file, FILE *pnm_file, FILE *alpha_file, BOOL raw, BOOL a
 
   /* create png and info structures */
 
-  png_ptr = png_create_read_struct (PNG_LIBPNG_VER_STRING,
+  png_ptr = png_create_read_struct (png_get_libpng_ver(NULL),
     NULL, NULL, NULL);
   if (!png_ptr)
     return FALSE;   /* out of memory */
@@ -315,12 +320,14 @@ BOOL png2pnm (FILE *png_file, FILE *pnm_file, FILE *alpha_file, BOOL raw, BOOL a
   /* row_bytes is the width x number of channels x (bit-depth / 8) */
   row_bytes = png_get_rowbytes (png_ptr, info_ptr);
 
-  if ((png_pixels = (png_byte *) malloc (row_bytes * height * sizeof (png_byte))) == NULL) {
+  if ((png_pixels = (png_byte *)
+     malloc (row_bytes * height * sizeof (png_byte))) == NULL) {
     png_destroy_read_struct (&png_ptr, &info_ptr, NULL);
     return FALSE;
   }
 
-  if ((row_pointers = (png_byte **) malloc (height * sizeof (png_bytep))) == NULL)
+  if ((row_pointers = (png_byte **)
+     malloc (height * sizeof (png_bytep))) == NULL)
   {
     png_destroy_read_struct (&png_ptr, &info_ptr, NULL);
     free (png_pixels);
@@ -329,7 +336,7 @@ BOOL png2pnm (FILE *png_file, FILE *pnm_file, FILE *alpha_file, BOOL raw, BOOL a
   }
 
   /* set the individual row_pointers to point at the correct offsets */
-  for (i = 0; i < (height); i++)
+  for (i = 0; i < ((int) height); i++)
     row_pointers[i] = png_pixels + i * row_bytes;
 
   /* now we can go ahead and just read the whole image */
@@ -372,9 +379,9 @@ BOOL png2pnm (FILE *png_file, FILE *pnm_file, FILE *alpha_file, BOOL raw, BOOL a
   /* write data to PNM file */
   pix_ptr = png_pixels;
 
-  for (row = 0; row < height; row++)
+  for (row = 0; row < (int) height; row++)
   {
-    for (col = 0; col < width; col++)
+    for (col = 0; col < (int) width; col++)
     {
       for (i = 0; i < (channels - alpha_present); i++)
       {

contrib/pngminus/pnm2png.c

@@ -3,7 +3,6 @@
  *  copyright (C) 1999 by Willem van Schaik <willem@schaik.com>
  *
  *  version 1.0 - 1999.10.15 - First version.
- *  version 1.1 - 2015.07.29 - Fixed leaks (Glenn Randers-Pehrson)
  *
  *  Permission to use, copy, modify, and distribute this software and
  *  its documentation for any purpose and without fee is hereby granted,
@@ -201,17 +200,17 @@ BOOL pnm2png (FILE *pnm_file, FILE *png_file, FILE *alpha_file, BOOL interlace,
   char          width_token[16];
   char          height_token[16];
   char          maxval_token[16];
-  volatile int    color_type=1;
+  volatile int           color_type;
   unsigned long   ul_width=0, ul_alpha_width=0;
   unsigned long   ul_height=0, ul_alpha_height=0;
   unsigned long   ul_maxval=0;
-  volatile png_uint_32   width=0, height=0;
-  volatile png_uint_32   alpha_width=0, alpha_height=0;
+  volatile png_uint_32   width, height;
+  volatile png_uint_32   alpha_width, alpha_height;
   png_uint_32   maxval;
   volatile int           bit_depth = 0;
-  int           channels=0;
+  int           channels;
   int           alpha_depth = 0;
-  int           alpha_present=0;
+  int           alpha_present;
   int           row, col;
   BOOL          raw, alpha_raw = FALSE;
 #if defined(PNG_WRITE_INVERT_SUPPORTED) || defined(PNG_WRITE_PACK_SUPPORTED)
@@ -357,10 +356,8 @@ BOOL pnm2png (FILE *pnm_file, FILE *png_file, FILE *alpha_file, BOOL interlace,
     channels = 3;
   else if (color_type == PNG_COLOR_TYPE_RGB_ALPHA)
     channels = 4;
-#if 0
   else
-    channels = 0; /* cannot happen */
-#endif
+    channels = 0; /* should not happen */
 
   alpha_present = (channels - 1) % 2;
 
@@ -432,16 +429,12 @@ BOOL pnm2png (FILE *pnm_file, FILE *png_file, FILE *alpha_file, BOOL interlace,
       NULL);
   if (!png_ptr)
   {
-    free (png_pixels);
-    png_pixels = NULL;
     return FALSE;
   }
   info_ptr = png_create_info_struct (png_ptr);
   if (!info_ptr)
   {
     png_destroy_write_struct (&png_ptr, (png_infopp) NULL);
-    free (png_pixels);
-    png_pixels = NULL;
     return FALSE;
   }
 
@@ -456,9 +449,7 @@ BOOL pnm2png (FILE *pnm_file, FILE *png_file, FILE *alpha_file, BOOL interlace,
   /* setjmp() must be called in every function that calls a PNG-reading libpng function */
   if (setjmp (png_jmpbuf(png_ptr)))
   {
-    png_destroy_write_struct (&png_ptr, &info_ptr);
-    free (png_pixels);
-    png_pixels = NULL;
+    png_destroy_write_struct (&png_ptr, (png_infopp) NULL);
     return FALSE;
   }
 
@@ -479,9 +470,7 @@ BOOL pnm2png (FILE *pnm_file, FILE *png_file, FILE *alpha_file, BOOL interlace,
     if ((row_pointers = (png_byte **)
         malloc (height * sizeof (png_bytep))) == NULL)
     {
-      png_destroy_write_struct (&png_ptr, &info_ptr);
-      free (png_pixels);
-      png_pixels = NULL;
+      png_destroy_write_struct (&png_ptr, (png_infopp) NULL);
       return FALSE;
     }
   }
@@ -497,7 +486,7 @@ BOOL pnm2png (FILE *pnm_file, FILE *png_file, FILE *alpha_file, BOOL interlace,
   png_write_end (png_ptr, info_ptr);
 
   /* clean up after the write, and free any memory allocated */
-  png_destroy_write_struct (&png_ptr, &info_ptr);
+  png_destroy_write_struct (&png_ptr, (png_infopp) NULL);
 
   if (row_pointers != (unsigned char**) NULL)
     free (row_pointers);