[libpng16] Imported from libpng-1.6.3.tar

where warnings may be erroneously issued by code-checking applications.
Revised manual about changes in iTXt chunk handling made in libpng-1.6.0.

ANNOUNCE

@@ -1,4 +1,5 @@
-Libpng 1.6.26 - October 20, 2016
+
+Libpng 1.6.3 - July 18, 2013
 
 This is a public release of libpng, intended for use in production codes.
 
@@ -7,53 +8,106 @@ Files available for download:
 Source files with LF line endings (for Unix/Linux) and with a
 "configure" script
 
-   libpng-1.6.26.tar.xz (LZMA-compressed, recommended)
-   libpng-1.6.26.tar.gz
+   libpng-1.6.3.tar.xz (LZMA-compressed, recommended)
+   libpng-1.6.3.tar.gz
 
 Source files with CRLF line endings (for Windows), without the
 "configure" script
 
-   lpng1626.7z  (LZMA-compressed, recommended)
-   lpng1626.zip
+   lpng163.7z  (LZMA-compressed, recommended)
+   lpng163.zip
 
 Other information:
 
-   libpng-1.6.26-README.txt
-   libpng-1.6.26-LICENSE.txt
-   libpng-1.6.26-*.asc (armored detached GPG signatures)
+   libpng-1.6.3-README.txt
+   libpng-1.6.3-LICENSE.txt
 
-Changes since the last public release (1.6.25):
+Changes since the last public release (1.6.2):
 
-  Fixed handling zero length IDAT in pngfix (bug report by Agostino Sarubbo,
-    bugfix by John Bowler).
-  Do not issue a png_error() on read in png_set_pCAL() because png_handle_pCAL
-    has allocated memory that libpng needs to free.
-  Conditionally compile png_set_benign_errors() in pngread.c and pngtest.c
-  Issue a png_benign_error instead of a png_error on ADLER32 mismatch
-    while decoding compressed data chunks.
-  Changed PNG_ZLIB_VERNUM to ZLIB_VERNUM in pngpriv.h, pngstruct.h, and
-    pngrutil.c.
-  If CRC handling of critical chunks has been set to PNG_CRC_QUIET_USE,
-    ignore the ADLER32 checksum in the IDAT chunk as well as the chunk CRCs.
-  Issue png_benign_error() on ADLER32 checksum mismatch instead of png_error().
-  Add tests/badcrc.png and tests/badadler.png to tests/pngtest.
-  Merged pngtest.c with libpng-1.7.0beta84/pngtest.c
-  Updated the documentation about CRC and ADLER32 handling.
-  Quieted 117 warnings from clang-3.8 in pngtrans.c, pngread.c,
-     pngwrite.c, pngunknown.c, and pngvalid.c.
-  Quieted the 144 remaining -Wconversion compiler warnings by
-    revising the png_isaligned() macro and trivial changes in png.c,
-    pngerror.c, pngget.c, pngmem.c, pngset.c, pngrtran.c, pngrutil.c,
-    pngwtran.c, pngwrite.c, and pngwutil.c.
-  Quieted (bogus?) clang warnings about "absolute value has no effect"
-    when PNG_USE_ABS is defined.
-  Fixed offsets in contrib/intel/intel_sse.patch
-  Changed integer constant 4294967294 to unsigned 4294967294U in pngconf.h
-    to avoid a signed/unsigned compare in the preprocessor.
-  Use zlib-1.2.8.1 inflateValidate() instead of inflateReset2() to
-    optionally avoid ADLER32 evaluation.
-  Cosmetic change, "ptr != 0" to "ptr != NULL" in png.c and pngrutil.c
-  Despammed email addresses (replaced "@" with " at ").
+  Revised stack marking in arm/filter_neon.S and configure.ac.
+  Ensure that NEON filter stuff is completely disabled when switched 'off'.
+    Previously the ARM NEON specific files were still built if the option
+    was switched 'off' as opposed to being explicitly disabled.
+  Test for 'arm*' not just 'arm' in the host_cpu configure variable.
+  Rebuilt the configure scripts.
+  Expanded manual paragraph about writing private chunks, particularly
+    the need to call png_set_keep_unknown_chunks() when writing them.
+  Avoid dereferencing NULL pointer possibly returned from
+     png_create_write_struct() (Andrew Church).
+  Calculate our own zlib windowBits when decoding rather than trusting the
+    CMF bytes in the PNG datastream.
+  Added an option to force maximum window size for inflating, which was
+    the behavior of libpng15 and earlier.
+  Added png-fix-itxt and png-fix-too-far-back to the built programs and
+    removed warnings from the source code and timepng that are revealed as
+    a result.
+  Detect wrong libpng versions linked to png-fix-too-far-back, which currently
+    only works with libpng versions that can be made to reliably fail when
+    the deflate data contains an out-of-window reference.  This means only
+    1.6 and later.
+  Fixed gnu issues: g++ needs a static_cast, gcc 4.4.7 has a broken warning
+    message which it is easier to work round than ignore.
+  Updated contrib/pngminus/pnm2png.c (Paul Stewart):
+    Check for EOF
+    Ignore "#" delimited comments in input file to pnm2png.c.
+    Fixed whitespace handling
+    Added a call to png_set_packing()
+    Initialize dimension values so if sscanf fails at least we have known
+      invalid values.
+  Attempt to detect configuration issues with png-fix-too-far-back, which
+    requires both the correct libpng and the correct zlib to function
+    correctly.
+  Check ZLIB_VERNUM for mismatches, enclose #error in quotes
+  Added information in the documentation about problems with and fixes for
+    the bad CRC and bad iTXt chunk situations.
+  Allow contrib/pngminus/pnm2png.c to compile without WRITE_INVERT and
+    WRITE_PACK supported (writes error message that it can't read P1 or
+  Improved png-fix-too-far-back usage message, added --suffix option.
+  Revised contrib/pngminim/*/makefile to generate pnglibconf.h with the
+    right zlib header files.
+  Separated CPPFLAGS and CFLAGS in contrib/pngminim/*/makefile
+  Removed a redundant test in png_set_IHDR().
+  Added set(CMAKE_CONFIGURATION_TYPES ...) to CMakeLists.txt (Andrew Hundt)
+  Deleted set(CMAKE_BUILD_TYPE) block from CMakeLists.txt
+  Enclose the prototypes for the simplified write API in
+    #ifdef PNG_STDIO_SUPPORTED/#endif
+  Make ARM NEON support work at compile time (not just configure time).
+    This moves the test on __ARM_NEON__ into pngconf.h to avoid issues when
+    using a compiler that compiles for multiple architectures at one time.
+  Removed PNG_FILTER_OPTIMIZATIONS and PNG_ARM_NEON_SUPPORTED from
+    pnglibconf.h, allowing more of the decisions to be made internally
+    (pngpriv.h) during the compile.  Without this, symbol prefixing is broken
+    under certain circumstances on ARM platforms.  Now only the API parts of
+    the optimizations ('check' vs 'api') are exposed in the public header files
+    except that the new setting PNG_ARM_NEON_OPT documents how libpng makes the
+    decision about whether or not to use the optimizations.
+  Protect symbol prefixing against CC/CPPFLAGS/CFLAGS useage.
+    Previous iOS/Xcode fixes for the ARM NEON optimizations moved the test
+    on __ARM_NEON__ from configure time to compile time.  This breaks symbol
+    prefixing because the definition of the special png_init_filter_functions
+    call was hidden at configure time if the relevant compiler arguments are
+    passed in CFLAGS as opposed to CC.  This change attempts to avoid all
+    the confusion that would result by declaring the init function even when
+    it is not used, so that it will always get prefixed.
+  Revised libpng.3 so that "doclifter" can process it.
+  Revised example.c to illustrate use of PNG_DEFAULT_sRGB and PNG_GAMMA_MAC_18
+    as parameters for png_set_gamma().  These have been available since
+    libpng-1.5.4.
+  Renamed contrib/tools/png-fix-too-far-back.c to pngfix.c and revised it
+    to check all compressed chunks known to libpng.
+  Updated documentation to show default behavior of benign errors correctly.
+  Only compile ARM code when PNG_READ_SUPPORTED is defined.
+  Fixed undefined behavior in contrib/tools/pngfix.c and added new strip
+    option. pngfix relied on undefined behavior and even a simple change from
+    gcc to g++ caused it to fail.  The new strip option 'unsafe' has been
+    implemented and is the default if --max is given.  Option names have
+    been clarified, with --strip=transform now stripping the bKGD chunk,
+    which was stripped previously with --strip=unused.
+  Added all documented chunk types to pngpriv.h
+  Unified pngfix.c source with libpng17.
+  Revised manual about changes in iTXt chunk handling made in libpng-1.6.0.
+  Added "/* SAFE */" comments in pngrutil.c and pngrtran.c where warnings
+    may be erroneously issued by code-checking applications.
 
 Send comments/corrections/commendations to png-mng-implement at lists.sf.net
 (subscription required; visit

CMakeLists.txt

@@ -1,32 +1,13 @@
 # CMakeLists.txt
 
-# Copyright (C) 2007,2009-2016 Glenn Randers-Pehrson
-# Written by Christian Ehrlicher, 2007
-# Revised by Roger Lowman, 2009-2010
-# Revised by Clifford Yapp, 2011-2012
-# Revised by Roger Leigh, 2016
+# Copyright (C) 2007-2013 Glenn Randers-Pehrson
 
 # This code is released under the libpng license.
 # For conditions of distribution and use, see the disclaimer
 # and license in png.h
 
-cmake_minimum_required(VERSION 2.8.3)
-cmake_policy(VERSION 2.8.3)
-
-# Set MacOSX @rpath usage globally.
-if (POLICY CMP0020)
-  cmake_policy(SET CMP0020 NEW)
-endif(POLICY CMP0020)
-if (POLICY CMP0042)
-  cmake_policy(SET CMP0042 NEW)
-endif(POLICY CMP0042)
-# Use new variable expansion policy.
-if (POLICY CMP0053)
-  cmake_policy(SET CMP0053 NEW)
-endif(POLICY CMP0053)
-if (POLICY CMP0054)
-  cmake_policy(SET CMP0054 NEW)
-endif(POLICY CMP0054)
+cmake_minimum_required(VERSION 2.4.4)
+set(CMAKE_ALLOW_LOOSE_LOOP_CONSTRUCTS true)
 
 set(CMAKE_CONFIGURATION_TYPES "Release;Debug;MinSizeRel;RelWithDebInfo")
 
@@ -35,7 +16,7 @@ enable_testing()
 
 set(PNGLIB_MAJOR 1)
 set(PNGLIB_MINOR 6)
-set(PNGLIB_RELEASE 26)
+set(PNGLIB_RELEASE 3)
 set(PNGLIB_NAME libpng${PNGLIB_MAJOR}${PNGLIB_MINOR})
 set(PNGLIB_VERSION ${PNGLIB_MAJOR}.${PNGLIB_MINOR}.${PNGLIB_RELEASE})
 
@@ -49,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
@@ -57,17 +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)
-
-set(PNG_PREFIX "" CACHE STRING "Prefix to add to the API function names")
-set(DFA_XTRA "" CACHE FILEPATH "File containing extra configuration settings")
+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})
@@ -75,275 +62,26 @@ set(PNG_LIB_NAME png${PNGLIB_MAJOR}${PNGLIB_MINOR})
 # to distinguish between debug and release lib
 set(CMAKE_DEBUG_POSTFIX "d")
 
-include(CheckCSourceCompiles)
-option(ld-version-script "Enable linker version script" ON)
-if(ld-version-script AND NOT APPLE)
-  # Check if LD supports linker scripts.
-  file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/conftest.map" "VERS_1 {
-        global: sym;
-        local: *;
-};
-
-VERS_2 {
-        global: sym2;
-                main;
-} VERS_1;
-")
-  set(CMAKE_REQUIRED_FLAGS_SAVE ${CMAKE_REQUIRED_FLAGS})
-  set(CMAKE_REQUIRED_FLAGS ${CMAKE_REQUIRED_FLAGS} "-Wl,--version-script='${CMAKE_CURRENT_BINARY_DIR}/conftest.map'")
-  check_c_source_compiles("void sym(void) {}
-void sym2(void) {}
-int main(void) {return 0;}
-" HAVE_LD_VERSION_SCRIPT)
-  if(NOT HAVE_LD_VERSION_SCRIPT)
-    set(CMAKE_REQUIRED_FLAGS ${CMAKE_REQUIRED_FLAGS_SAVE} "-Wl,-M -Wl,${CMAKE_CURRENT_BINARY_DIR}/conftest.map")
-  check_c_source_compiles("void sym(void) {}
-void sym2(void) {}
-int main(void) {return 0;}
-" HAVE_SOLARIS_LD_VERSION_SCRIPT)
-  endif()
-  set(CMAKE_REQUIRED_FLAGS ${CMAKE_REQUIRED_FLAGS_SAVE})
-  file(REMOVE "${CMAKE_CURRENT_BINARY_DIR}/conftest.map")
-endif()
-
-# Find symbol prefix.  Likely obsolete and unnecessary with recent
-# toolchains (it's not done in many other projects).
-function(symbol_prefix)
-  set(SYMBOL_PREFIX)
-
-  execute_process(COMMAND "${CMAKE_C_COMPILER}" "-E" "-"
-                  INPUT_FILE /dev/null
-                  OUTPUT_VARIABLE OUT
-                  RESULT_VARIABLE STATUS)
-
-  if(CPP_FAIL)
-    message(WARNING "Failed to run the C preprocessor")
-  endif()
-
-  string(REPLACE "\n" ";" OUT "${OUT}")
-  foreach(line ${OUT})
-    string(REGEX MATCH "^PREFIX=" found_match "${line}")
-    if(found_match)
-      STRING(REGEX REPLACE "^PREFIX=(.*\)" "\\1" prefix "${line}")
-      string(REGEX MATCH "__USER_LABEL_PREFIX__" found_match "${prefix}")
-      if(found_match)
-        STRING(REGEX REPLACE "(.*)__USER_LABEL_PREFIX__(.*)" "\\1\\2" prefix "${prefix}")
-      endif()
-      set(SYMBOL_PREFIX "${prefix}")
-    endif()
-  endforeach()
-
-    message(STATUS "Symbol prefix: ${SYMBOL_PREFIX}")
-    set(SYMBOL_PREFIX "${SYMBOL_PREFIX}" PARENT_SCOPE)
-endfunction()
-
-if(UNIX)
-  symbol_prefix()
-endif()
-
-find_program(AWK NAMES gawk awk)
-
+# Use the prebuilt pnglibconf.h file from the scripts folder
+# TODO: fix this by building with awk; without this no cmake build can be
+# configured directly (to do so indirectly use your local awk to build a
+# pnglibconf.h in the build directory.)
+configure_file(${CMAKE_CURRENT_SOURCE_DIR}/scripts/pnglibconf.h.prebuilt
+               ${CMAKE_CURRENT_BINARY_DIR}/pnglibconf.h)
 include_directories(${CMAKE_CURRENT_BINARY_DIR})
 
-if(NOT AWK)
-  # No awk available to generate sources; use pre-built pnglibconf.h
-  configure_file(${CMAKE_CURRENT_SOURCE_DIR}/scripts/pnglibconf.h.prebuilt
-                 ${CMAKE_CURRENT_BINARY_DIR}/pnglibconf.h)
-  add_custom_target(genfiles) # Dummy
-else()
-  include(CMakeParseArguments)
-  # Generate .chk from .out with awk
-  # generate_chk(INPUT inputfile OUTPUT outputfile [DEPENDS dep1 [dep2...]])
-  function(generate_chk)
-    set(options)
-    set(oneValueArgs INPUT OUTPUT)
-    set(multiValueArgs DEPENDS)
-    cmake_parse_arguments(_GC "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
-    if (NOT _GC_INPUT)
-      message(FATAL_ERROR "Invalid arguments.  generate_out requires input.")
-    endif()
-    if (NOT _GC_OUTPUT)
-      message(FATAL_ERROR "Invalid arguments.  generate_out requires output.")
-    endif()
-
-    add_custom_command(OUTPUT "${_GC_OUTPUT}"
-                       COMMAND "${CMAKE_COMMAND}"
-                               "-DINPUT=${_GC_INPUT}"
-                               "-DOUTPUT=${_GC_OUTPUT}"
-                               -P "${CMAKE_CURRENT_BINARY_DIR}/scripts/genchk.cmake"
-                       DEPENDS "${_GC_INPUT}" ${_GC_DEPENDS}
-                       WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}")
-  endfunction()
-
-  # Generate .out from .c with awk
-  # generate_out(INPUT inputfile OUTPUT outputfile [DEPENDS dep1 [dep2...]])
-  function(generate_out)
-    set(options)
-    set(oneValueArgs INPUT OUTPUT)
-    set(multiValueArgs DEPENDS)
-    cmake_parse_arguments(_GO "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
-    if (NOT _GO_INPUT)
-      message(FATAL_ERROR "Invalid arguments.  generate_out requires input.")
-    endif()
-    if (NOT _GO_OUTPUT)
-      message(FATAL_ERROR "Invalid arguments.  generate_out requires output.")
-    endif()
-
-    add_custom_command(OUTPUT "${_GO_OUTPUT}"
-                       COMMAND "${CMAKE_COMMAND}"
-                               "-DINPUT=${_GO_INPUT}"
-                               "-DOUTPUT=${_GO_OUTPUT}"
-                               -P "${CMAKE_CURRENT_BINARY_DIR}/scripts/genout.cmake"
-                       DEPENDS "${_GO_INPUT}" ${_GO_DEPENDS}
-                       WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}")
-  endfunction()
-
-  # Generate specific source file with awk
-  # generate_source(OUTPUT outputfile [DEPENDS dep1 [dep2...]])
-  function(generate_source)
-    set(options)
-    set(oneValueArgs OUTPUT)
-    set(multiValueArgs DEPENDS)
-    cmake_parse_arguments(_GSO "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
-    if (NOT _GSO_OUTPUT)
-      message(FATAL_ERROR "Invalid arguments.  generate_source requires output.")
-    endif()
-
-    add_custom_command(OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/${_GSO_OUTPUT}"
-                       COMMAND "${CMAKE_COMMAND}"
-                               "-DOUTPUT=${_GSO_OUTPUT}"
-                               -P "${CMAKE_CURRENT_BINARY_DIR}/scripts/gensrc.cmake"
-                       DEPENDS ${_GSO_DEPENDS}
-                       WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}")
-  endfunction()
-
-  # Copy file
-  function(generate_copy source destination)
-    add_custom_command(OUTPUT "${destination}"
-                       COMMAND "${CMAKE_COMMAND}" -E remove "${destination}"
-                       COMMAND "${CMAKE_COMMAND}" -E copy "${source}"
-                                                          "${destination}"
-                       DEPENDS "${source}")
-  endfunction()
-
-  # Generate scripts/pnglibconf.h
-  generate_source(OUTPUT "scripts/pnglibconf.c"
-                  DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/scripts/pnglibconf.dfa"
-                          "${CMAKE_CURRENT_SOURCE_DIR}/scripts/options.awk"
-                          "${CMAKE_CURRENT_SOURCE_DIR}/pngconf.h")
-
-  # Generate pnglibconf.c
-  generate_source(OUTPUT "pnglibconf.c"
-                  DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/scripts/pnglibconf.dfa"
-                          "${CMAKE_CURRENT_SOURCE_DIR}/scripts/options.awk"
-                          "${CMAKE_CURRENT_SOURCE_DIR}/pngconf.h")
-
-  if(PNG_PREFIX)
-    set(PNGLIBCONF_H_EXTRA_DEPENDS
-        "${CMAKE_CURRENT_BINARY_DIR}/scripts/prefix.out"
-        "${CMAKE_CURRENT_SOURCE_DIR}/scripts/macro.lst")
-    set(PNGPREFIX_H_EXTRA_DEPENDS
-        "${CMAKE_CURRENT_BINARY_DIR}/scripts/intprefix.out")
-  endif()
-
-  generate_out(INPUT "${CMAKE_CURRENT_BINARY_DIR}/pnglibconf.c"
-               OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/pnglibconf.out")
-
-  # Generate pnglibconf.h
-  generate_source(OUTPUT "pnglibconf.h"
-                  DEPENDS "${CMAKE_CURRENT_BINARY_DIR}/pnglibconf.out"
-                          ${PNGLIBCONF_H_EXTRA_DEPENDS})
-
-  generate_out(INPUT "${CMAKE_CURRENT_SOURCE_DIR}/scripts/intprefix.c"
-               OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/scripts/intprefix.out"
-               DEPENDS "${CMAKE_CURRENT_BINARY_DIR}/pnglibconf.h")
-
-  generate_out(INPUT "${CMAKE_CURRENT_SOURCE_DIR}/scripts/prefix.c"
-               OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/scripts/prefix.out"
-               DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/png.h"
-                       "${CMAKE_CURRENT_SOURCE_DIR}/pngconf.h"
-                       "${CMAKE_CURRENT_BINARY_DIR}/pnglibconf.out")
-
-  # Generate pngprefix.h
-  generate_source(OUTPUT "pngprefix.h"
-                  DEPENDS ${PNGPREFIX_H_EXTRA_DEPENDS})
-
-  generate_out(INPUT "${CMAKE_CURRENT_SOURCE_DIR}/scripts/sym.c"
-               OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/scripts/sym.out"
-               DEPENDS "${CMAKE_CURRENT_BINARY_DIR}/pnglibconf.h")
-
-  generate_out(INPUT "${CMAKE_CURRENT_SOURCE_DIR}/scripts/symbols.c"
-               OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/scripts/symbols.out"
-               DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/png.h"
-                       "${CMAKE_CURRENT_SOURCE_DIR}/pngconf.h"
-                       "${CMAKE_CURRENT_SOURCE_DIR}/scripts/pnglibconf.h.prebuilt")
-
-  generate_out(INPUT "${CMAKE_CURRENT_SOURCE_DIR}/scripts/vers.c"
-               OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/scripts/vers.out"
-               DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/png.h"
-                       "${CMAKE_CURRENT_SOURCE_DIR}/pngconf.h"
-                       "${CMAKE_CURRENT_BINARY_DIR}/pnglibconf.h")
-
-  generate_chk(INPUT "${CMAKE_CURRENT_BINARY_DIR}/scripts/symbols.out"
-               OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/scripts/symbols.chk"
-               DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/scripts/checksym.awk"
-                       "${CMAKE_CURRENT_SOURCE_DIR}/scripts/symbols.def")
-
-  add_custom_target(symbol-check DEPENDS
-                    "${CMAKE_CURRENT_BINARY_DIR}/scripts/symbols.chk")
-
-  generate_copy("${CMAKE_CURRENT_BINARY_DIR}/scripts/sym.out"
-                "${CMAKE_CURRENT_BINARY_DIR}/libpng.sym")
-  generate_copy("${CMAKE_CURRENT_BINARY_DIR}/scripts/vers.out"
-                "${CMAKE_CURRENT_BINARY_DIR}/libpng.vers")
-
-  add_custom_target(genvers DEPENDS "${CMAKE_CURRENT_BINARY_DIR}/libpng.vers")
-  add_custom_target(gensym DEPENDS "${CMAKE_CURRENT_BINARY_DIR}/libpng.sym")
-
-  add_custom_target("genprebuilt"
-                    COMMAND "${CMAKE_COMMAND}"
-                            "-DOUTPUT=scripts/pnglibconf.h.prebuilt"
-                            -P "${CMAKE_CURRENT_BINARY_DIR}/scripts/gensrc.cmake"
-                    WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}")
-
-  # A single target handles generation of all generated files.  If
-  # they are dependend upon separately by multiple targets, this
-  # confuses parallel make (it would require a separate top-level
-  # target for each file to track the dependencies properly).
-  add_custom_target(genfiles DEPENDS
-    "${CMAKE_CURRENT_BINARY_DIR}/libpng.sym"
-    "${CMAKE_CURRENT_BINARY_DIR}/libpng.vers"
-    "${CMAKE_CURRENT_BINARY_DIR}/pnglibconf.c"
-    "${CMAKE_CURRENT_BINARY_DIR}/pnglibconf.h"
-    "${CMAKE_CURRENT_BINARY_DIR}/pnglibconf.out"
-    "${CMAKE_CURRENT_BINARY_DIR}/pngprefix.h"
-    "${CMAKE_CURRENT_BINARY_DIR}/scripts/intprefix.out"
-    "${CMAKE_CURRENT_BINARY_DIR}/scripts/pnglibconf.c"
-    "${CMAKE_CURRENT_BINARY_DIR}/scripts/prefix.out"
-    "${CMAKE_CURRENT_BINARY_DIR}/scripts/sym.out"
-    "${CMAKE_CURRENT_BINARY_DIR}/scripts/symbols.chk"
-    "${CMAKE_CURRENT_BINARY_DIR}/scripts/symbols.out"
-    "${CMAKE_CURRENT_BINARY_DIR}/scripts/vers.out")
-endif(NOT AWK)
-
 # OUR SOURCES
 set(libpng_public_hdrs
   png.h
   pngconf.h
-  "${CMAKE_CURRENT_BINARY_DIR}/pnglibconf.h"
+  ${CMAKE_CURRENT_BINARY_DIR}/pnglibconf.h
 )
-set(libpng_private_hdrs
-  pngpriv.h
-  pngdebug.h
-  pnginfo.h
-  pngstruct.h
-)
-if(AWK)
-  list(APPEND libpng_private_hdrs "${CMAKE_CURRENT_BINARY_DIR}/pngprefix.h")
-endif()
 set(libpng_sources
   ${libpng_public_hdrs}
-  ${libpng_private_hdrs}
+  pngdebug.h
+  pnginfo.h
+  pngpriv.h
+  pngstruct.h
   png.c
   pngerror.c
   pngget.c
@@ -369,18 +107,7 @@ set(pngvalid_sources
 set(pngstest_sources
   contrib/libtests/pngstest.c
 )
-set(pngunknown_sources
-  contrib/libtests/pngunknown.c
-)
-set(pngimage_sources
-  contrib/libtests/pngimage.c
-)
-set(pngfix_sources
-  contrib/tools/pngfix.c
-)
-set(png_fix_itxt_sources
-  contrib/tools/png-fix-itxt.c
-)
+# SOME NEEDED DEFINITIONS
 
 if(MSVC)
   add_definitions(-D_CRT_SECURE_NO_DEPRECATE)
@@ -396,242 +123,81 @@ include_directories(${CMAKE_CURRENT_SOURCE_DIR} ${ZLIB_INCLUDE_DIR})
 unset(PNG_LIB_TARGETS)
 
 if(PNG_SHARED)
-  add_library(png SHARED ${libpng_sources})
-  set(PNG_LIB_TARGETS png)
-  set_target_properties(png PROPERTIES OUTPUT_NAME ${PNG_LIB_NAME})
-  add_dependencies(png genfiles)
+  add_library(${PNG_LIB_NAME} SHARED ${libpng_sources})
+  set(PNG_LIB_TARGETS ${PNG_LIB_NAME})
   if(MSVC)
     # msvc does not append 'lib' - do it here to have consistent name
-    set_target_properties(png PROPERTIES PREFIX "lib")
-    set_target_properties(png PROPERTIES IMPORT_PREFIX "lib")
-  endif()
-  target_link_libraries(png ${ZLIB_LIBRARY} ${M_LIBRARY})
-
-  if(UNIX AND AWK)
-    if(HAVE_LD_VERSION_SCRIPT)
-      set_target_properties(png PROPERTIES LINK_FLAGS
-        "-Wl,--version-script='${CMAKE_CURRENT_BINARY_DIR}/libpng.vers'")
-    elseif(HAVE_SOLARIS_LD_VERSION_SCRIPT)
-      set_target_properties(png PROPERTIES LINK_FLAGS
-        "-Wl,-M -Wl,'${CMAKE_CURRENT_BINARY_DIR}/libpng.vers'")
-    endif()
+    set_target_properties(${PNG_LIB_NAME} PROPERTIES PREFIX "lib")
+    set_target_properties(${PNG_LIB_NAME} PROPERTIES IMPORT_PREFIX "lib")
   endif()
+  target_link_libraries(${PNG_LIB_NAME} ${ZLIB_LIBRARY} ${M_LIBRARY})
 endif()
 
 if(PNG_STATIC)
-  # does not work without changing name
-  set(PNG_LIB_NAME_STATIC png_static)
-  add_library(png_static STATIC ${libpng_sources})
-  add_dependencies(png_static genfiles)
-  # MSVC doesn't use a different file extension for shared vs. static
-  # libs.  We are able to change OUTPUT_NAME to remove the _static
-  # for all other platforms.
-  if(NOT MSVC)
-    set_target_properties(png_static PROPERTIES
-      OUTPUT_NAME "${PNG_LIB_NAME}"
-      CLEAN_DIRECT_OUTPUT 1)
-  else()
-    set_target_properties(png_static PROPERTIES
-      OUTPUT_NAME "${PNG_LIB_NAME}_static"
-      CLEAN_DIRECT_OUTPUT 1)
-  endif()
-  list(APPEND PNG_LIB_TARGETS png_static)
+# 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})
   if(MSVC)
     # msvc does not append 'lib' - do it here to have consistent name
-    set_target_properties(png_static PROPERTIES PREFIX "lib")
+    set_target_properties(${PNG_LIB_NAME_STATIC} PROPERTIES PREFIX "lib")
   endif()
-  target_link_libraries(png_static ${ZLIB_LIBRARY} ${M_LIBRARY})
-endif()
-
-if(PNG_FRAMEWORK)
-  set(PNG_LIB_NAME_FRAMEWORK png_framework)
-  add_library(png_framework SHARED ${libpng_sources})
-  add_dependencies(png_framework genfiles)
-  list(APPEND PNG_LIB_TARGETS png_framework)
-  set_target_properties(png_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_framework ${ZLIB_LIBRARY} ${M_LIBRARY})
+  target_link_libraries(${PNG_LIB_NAME_STATIC} ${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)
-  set_target_properties(png PROPERTIES DEFINE_SYMBOL PNG_BUILD_DLL)
+  set_target_properties(${PNG_LIB_NAME} PROPERTIES DEFINE_SYMBOL PNG_BUILD_DLL)
 endif()
 
-function(png_add_test)
-  set(options)
-  set(oneValueArgs NAME COMMAND)
-  set(multiValueArgs OPTIONS FILES)
-  cmake_parse_arguments(_PAT "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
-
-  if (NOT _PAT_NAME)
-    message(FATAL_ERROR "Invalid arguments.  png_add_test requires name.")
-  endif()
-  if (NOT _PAT_COMMAND)
-    message(FATAL_ERROR "Invalid arguments.  png_add_test requires command.")
-  endif()
-
-  set(TEST_OPTIONS "${_PAT_OPTIONS}")
-  set(TEST_FILES "${_PAT_FILES}")
-
-  configure_file("${CMAKE_CURRENT_SOURCE_DIR}/scripts/test.cmake.in"
-                 "${CMAKE_CURRENT_BINARY_DIR}/tests/${_PAT_NAME}.cmake" @ONLY)
-  if(CMAKE_MAJOR_VERSION GREATER 2) # have generator expressions
-    add_test(NAME "${_PAT_NAME}"
-             COMMAND "${CMAKE_COMMAND}"
-             "-DLIBPNG=$<TARGET_FILE:png>"
-             "-DTEST_COMMAND=$<TARGET_FILE:${_PAT_COMMAND}>"
-             -P "${CMAKE_CURRENT_BINARY_DIR}/tests/${_PAT_NAME}.cmake")
-  else() # old 2.x add_test; limited and won't work well on Windows
-    # Note LIBPNG is a dummy value as there are no generator expressions
-    add_test("${_PAT_NAME}" "${CMAKE_COMMAND}"
-             "-DLIBPNG=${CMAKE_CURRENT_BINARY_DIR}/libpng.so"
-             "-DTEST_COMMAND=./${_PAT_COMMAND}"
-             -P "${CMAKE_CURRENT_BINARY_DIR}/tests/${_PAT_NAME}.cmake")
-  endif()
-endfunction()
-
 if(PNG_TESTS AND PNG_SHARED)
-  # Find test PNG files by globbing, but sort lists to ensure
-  # consistency between different filesystems.
-  file(GLOB PNGSUITE_PNGS "${CMAKE_CURRENT_SOURCE_DIR}/contrib/pngsuite/*.png")
-  list(SORT PNGSUITE_PNGS)
-  file(GLOB TEST_PNGS "${CMAKE_CURRENT_SOURCE_DIR}/contrib/testpngs/*.png")
-  list(SORT TEST_PNGS)
-
-  set(PNGTEST_PNG "${CMAKE_CURRENT_SOURCE_DIR}/pngtest.png")
-
+  # does not work with msvc due to png_lib_ver issue
   add_executable(pngtest ${pngtest_sources})
-  target_link_libraries(pngtest png)
-
-  png_add_test(NAME pngtest COMMAND pngtest FILES "${PNGTEST_PNG}")
-
+  target_link_libraries(pngtest ${PNG_LIB_NAME})
+  add_test(pngtest ./pngtest ${CMAKE_CURRENT_SOURCE_DIR}/pngtest.png)
+  #
   add_executable(pngvalid ${pngvalid_sources})
-  target_link_libraries(pngvalid png)
-
-  png_add_test(NAME pngvalid-gamma-16-to-8
-               COMMAND pngvalid OPTIONS --gamma-16-to-8)
-  png_add_test(NAME pngvalid-gamma-alpha-mode
-               COMMAND pngvalid OPTIONS --gamma-alpha-mode)
-  png_add_test(NAME pngvalid-gamma-background
-               COMMAND pngvalid OPTIONS --gamma-background)
-  png_add_test(NAME pngvalid-gamma-expand16-alpha-mode
-               COMMAND pngvalid OPTIONS --gamma-alpha-mode --expand16)
-  png_add_test(NAME pngvalid-gamma-expand16-background
-               COMMAND pngvalid OPTIONS --gamma-background --expand16)
-  png_add_test(NAME pngvalid-gamma-expand16-transform
-               COMMAND pngvalid OPTIONS --gamma-transform --expand16)
-  png_add_test(NAME pngvalid-gamma-sbit
-               COMMAND pngvalid OPTIONS --gamma-sbit)
-  png_add_test(NAME pngvalid-gamma-threshold
-               COMMAND pngvalid OPTIONS --gamma-threshold)
-  png_add_test(NAME pngvalid-gamma-transform
-               COMMAND pngvalid OPTIONS --gamma-transform)
-  png_add_test(NAME pngvalid-progressive-interlace-standard
-               COMMAND pngvalid OPTIONS --standard --progressive-read --interlace)
-  png_add_test(NAME pngvalid-progressive-size
-               COMMAND pngvalid OPTIONS --size --progressive-read)
-  png_add_test(NAME pngvalid-progressive-standard
-               COMMAND pngvalid OPTIONS --standard --progressive-read)
-  png_add_test(NAME pngvalid-standard
-               COMMAND pngvalid OPTIONS --standard)
-  png_add_test(NAME pngvalid-transform
-               COMMAND pngvalid OPTIONS --transform)
-
+  target_link_libraries(pngvalid ${PNG_LIB_NAME})
+  add_test(pngvalid ./pngvalid)
   add_executable(pngstest ${pngstest_sources})
-  target_link_libraries(pngstest png)
-
-  foreach(gamma_type 1.8 linear none sRGB)
-    foreach(alpha_type none alpha)
-      set(PNGSTEST_FILES)
-      foreach(test_png ${TEST_PNGS})
-        string(REGEX MATCH ".*-linear[-.].*" TEST_PNG_LINEAR "${test_png}")
-        string(REGEX MATCH ".*-sRGB[-.].*" TEST_PNG_SRGB "${test_png}")
-        string(REGEX MATCH ".*-1.8[-.].*" TEST_PNG_G18 "${test_png}")
-        string(REGEX MATCH ".*-alpha-.*" TEST_PNG_ALPHA "${test_png}")
-
-        set(TEST_PNG_VALID TRUE)
-
-        if(TEST_PNG_ALPHA)
-          if (NOT "${alpha_type}" STREQUAL "alpha")
-            set(TEST_PNG_VALID FALSE)
-          endif()
-        else()
-          if ("${alpha_type}" STREQUAL "alpha")
-            set(TEST_PNG_VALID FALSE)
-          endif()
-        endif()
-
-        if(TEST_PNG_LINEAR)
-          if(NOT "${gamma_type}" STREQUAL "linear")
-            set(TEST_PNG_VALID FALSE)
-          endif()
-        elseif(TEST_PNG_SRGB)
-          if(NOT "${gamma_type}" STREQUAL "sRGB")
-            set(TEST_PNG_VALID FALSE)
-          endif()
-        elseif(TEST_PNG_G18)
-          if(NOT "${gamma_type}" STREQUAL "1.8")
-            set(TEST_PNG_VALID FALSE)
-          endif()
-        else()
-          if(NOT "${gamma_type}" STREQUAL "none")
-            set(TEST_PNG_VALID FALSE)
-          endif()
-        endif()
-
-        if(TEST_PNG_VALID)
-          list(APPEND PNGSTEST_FILES "${test_png}")
-        endif()
-      endforeach()
-      # Should already be sorted, but sort anyway to be certain.
-      list(SORT PNGSTEST_FILES)
-      png_add_test(NAME pngstest-${gamma_type}-${alpha_type}
-                   COMMAND pngstest
-                   OPTIONS --tmpfile "${gamma_type}-${alpha_type}-" --log
-                   FILES ${PNGSTEST_FILES})
-    endforeach()
-  endforeach()
-
-  add_executable(pngunknown ${pngunknown_sources})
-  target_link_libraries(pngunknown png)
-
-  png_add_test(NAME pngunknown-discard COMMAND pngunknown OPTIONS --strict default=discard FILES "${PNGTEST_PNG}")
-  png_add_test(NAME pngunknown-IDAT COMMAND pngunknown OPTIONS --strict default=discard IDAT=save FILES "${PNGTEST_PNG}")
-  png_add_test(NAME pngunknown-if-safe COMMAND pngunknown OPTIONS --strict default=if-safe FILES "${PNGTEST_PNG}")
-  png_add_test(NAME pngunknown-sAPI COMMAND pngunknown OPTIONS --strict bKGD=save cHRM=save gAMA=save all=discard iCCP=save sBIT=save sRGB=save FILES "${PNGTEST_PNG}")
-  png_add_test(NAME pngunknown-save COMMAND pngunknown OPTIONS --strict default=save FILES "${PNGTEST_PNG}")
-  png_add_test(NAME pngunknown-sTER COMMAND pngunknown OPTIONS --strict sTER=if-safe FILES "${PNGTEST_PNG}")
-  png_add_test(NAME pngunknown-vpAg COMMAND pngunknown OPTIONS --strict vpAg=if-safe FILES "${PNGTEST_PNG}")
-
-  add_executable(pngimage ${pngimage_sources})
-  target_link_libraries(pngimage png)
-
-  png_add_test(NAME pngimage-quick COMMAND pngimage OPTIONS --list-combos --log FILES ${PNGSUITE_PNGS})
-  png_add_test(NAME pngimage-full COMMAND pngimage OPTIONS --exhaustive --list-combos --log FILES ${PNGSUITE_PNGS})
-endif()
-
-if(PNG_SHARED)
-  add_executable(pngfix ${pngfix_sources})
-  target_link_libraries(pngfix png)
-  set(PNG_BIN_TARGETS pngfix)
-
-  add_executable(png-fix-itxt ${png_fix_itxt_sources})
-  target_link_libraries(png-fix-itxt ${ZLIB_LIBRARY} ${M_LIBRARY})
-  list(APPEND PNG_BIN_TARGETS png-fix-itxt)
+  target_link_libraries(pngstest ${PNG_LIB_NAME})
+  add_test(pngstest ./pngstest
+    ${CMAKE_CURRENT_SOURCE_DIR}/contrib/pngsuite/basn0g01.png
+    ${CMAKE_CURRENT_SOURCE_DIR}/contrib/pngsuite/basn0g02.png
+    ${CMAKE_CURRENT_SOURCE_DIR}/contrib/pngsuite/basn0g04.png
+    ${CMAKE_CURRENT_SOURCE_DIR}/contrib/pngsuite/basn0g08.png
+    ${CMAKE_CURRENT_SOURCE_DIR}/contrib/pngsuite/basn0g16.png
+    ${CMAKE_CURRENT_SOURCE_DIR}/contrib/pngsuite/basn2c08.png
+    ${CMAKE_CURRENT_SOURCE_DIR}/contrib/pngsuite/basn2c16.png
+    ${CMAKE_CURRENT_SOURCE_DIR}/contrib/pngsuite/basn3p01.png
+    ${CMAKE_CURRENT_SOURCE_DIR}/contrib/pngsuite/basn3p02.png
+    ${CMAKE_CURRENT_SOURCE_DIR}/contrib/pngsuite/basn3p04.png
+    ${CMAKE_CURRENT_SOURCE_DIR}/contrib/pngsuite/basn3p08.png
+    ${CMAKE_CURRENT_SOURCE_DIR}/contrib/pngsuite/basn4a08.png
+    ${CMAKE_CURRENT_SOURCE_DIR}/contrib/pngsuite/basn4a16.png
+    ${CMAKE_CURRENT_SOURCE_DIR}/contrib/pngsuite/basn6a08.png
+    ${CMAKE_CURRENT_SOURCE_DIR}/contrib/pngsuite/basn6a16.png
+    ${CMAKE_CURRENT_SOURCE_DIR}/contrib/pngsuite/ftbbn0g01.png
+    ${CMAKE_CURRENT_SOURCE_DIR}/contrib/pngsuite/ftbbn0g02.png
+    ${CMAKE_CURRENT_SOURCE_DIR}/contrib/pngsuite/ftbbn0g04.png
+    ${CMAKE_CURRENT_SOURCE_DIR}/contrib/pngsuite/ftbbn2c16.png
+    ${CMAKE_CURRENT_SOURCE_DIR}/contrib/pngsuite/ftbbn3p08.png
+    ${CMAKE_CURRENT_SOURCE_DIR}/contrib/pngsuite/ftbgn2c16.png
+    ${CMAKE_CURRENT_SOURCE_DIR}/contrib/pngsuite/ftbgn3p08.png
+    ${CMAKE_CURRENT_SOURCE_DIR}/contrib/pngsuite/ftbrn2c08.png
+    ${CMAKE_CURRENT_SOURCE_DIR}/contrib/pngsuite/ftbwn0g16.png
+    ${CMAKE_CURRENT_SOURCE_DIR}/contrib/pngsuite/ftbwn3p08.png
+    ${CMAKE_CURRENT_SOURCE_DIR}/contrib/pngsuite/ftbyn3p08.png
+    ${CMAKE_CURRENT_SOURCE_DIR}/contrib/pngsuite/ftp0n0g08.png
+    ${CMAKE_CURRENT_SOURCE_DIR}/contrib/pngsuite/ftp0n2c08.png
+    ${CMAKE_CURRENT_SOURCE_DIR}/contrib/pngsuite/ftp0n3p08.png
+    ${CMAKE_CURRENT_SOURCE_DIR}/contrib/pngsuite/ftp1n3p08.png
+  )
 endif()
 
 # Ensure the CMAKE_LIBRARY_OUTPUT_DIRECTORY is set
@@ -654,21 +220,11 @@ macro(CREATE_SYMLINK SRC_FILE DEST_FILE)
     ADD_CUSTOM_TARGET(${DEST_FILE}_COPY ALL DEPENDS ${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/${DEST_FILE})
   else(WIN32 AND NOT CYGWIN AND NOT MSYS)
     get_filename_component(LINK_TARGET "${SRC_FILE}" NAME)
-    execute_process(COMMAND ${CMAKE_COMMAND} -E make_directory ${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_LIBRARY_OUTPUT_DIRECTORY})
     execute_process(COMMAND ${CMAKE_COMMAND} -E create_symlink "${LINK_TARGET}" ${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/${DEST_FILE} WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
     execute_process(COMMAND ${CMAKE_COMMAND} -E create_symlink "${LINK_TARGET}" ${DEST_FILE} WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
   endif(WIN32 AND NOT CYGWIN AND NOT MSYS)
 endmacro()
 
-# Create source generation scripts.
-configure_file(${CMAKE_CURRENT_SOURCE_DIR}/scripts/genchk.cmake.in
-               ${CMAKE_CURRENT_BINARY_DIR}/scripts/genchk.cmake @ONLY)
-configure_file(${CMAKE_CURRENT_SOURCE_DIR}/scripts/genout.cmake.in
-               ${CMAKE_CURRENT_BINARY_DIR}/scripts/genout.cmake @ONLY)
-configure_file(${CMAKE_CURRENT_SOURCE_DIR}/scripts/gensrc.cmake.in
-               ${CMAKE_CURRENT_BINARY_DIR}/scripts/gensrc.cmake @ONLY)
-
-
 # libpng is a library so default to 'lib'
 if(NOT DEFINED CMAKE_INSTALL_LIBDIR)
   set(CMAKE_INSTALL_LIBDIR lib)
@@ -695,12 +251,22 @@ endif(NOT WIN32 OR CYGWIN OR MINGW)
 
 # SET UP LINKS
 if(PNG_SHARED)
-  set_target_properties(png PROPERTIES
-#   VERSION 16.${PNGLIB_RELEASE}.1.6.26
+  set_target_properties(${PNG_LIB_NAME} PROPERTIES
+#   VERSION 16.${PNGLIB_RELEASE}.1.6.3
     VERSION 16.${PNGLIB_RELEASE}.0
     SOVERSION 16
     CLEAN_DIRECT_OUTPUT 1)
 endif()
+if(PNG_STATIC)
+  # MSVC doesn't use a different file extension for shared vs. static
+  # libs.  We are able to change OUTPUT_NAME to remove the _static
+  # for all other platforms.
+  if(NOT MSVC)
+    set_target_properties(${PNG_LIB_NAME_STATIC} PROPERTIES
+      OUTPUT_NAME ${PNG_LIB_NAME}
+      CLEAN_DIRECT_OUTPUT 1)
+  endif()
+endif()
 
 # If CMake > 2.4.x, we set a variable used below to export
 # targets to an export file.
@@ -717,20 +283,19 @@ 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 => libpng16.dll.a on Cygwin
     if(CYGWIN OR MINGW)
-       get_target_property(BUILD_TARGET_LOCATION png LOCATION_${CMAKE_BUILD_TYPE})
+       get_target_property(BUILD_TARGET_LOCATION ${PNG_LIB_NAME} LOCATION_${CMAKE_BUILD_TYPE})
        CREATE_SYMLINK(${BUILD_TARGET_LOCATION} libpng${CMAKE_IMPORT_LIBRARY_SUFFIX})
        install(FILES ${CMAKE_CURRENT_BINARY_DIR}/libpng${CMAKE_IMPORT_LIBRARY_SUFFIX}
          DESTINATION ${CMAKE_INSTALL_LIBDIR})
     endif(CYGWIN OR MINGW)
 
     if(NOT WIN32)
-      get_target_property(BUILD_TARGET_LOCATION png LOCATION_${CMAKE_BUILD_TYPE})
+      get_target_property(BUILD_TARGET_LOCATION ${PNG_LIB_NAME} LOCATION_${CMAKE_BUILD_TYPE})
       CREATE_SYMLINK(${BUILD_TARGET_LOCATION} libpng${CMAKE_SHARED_LIBRARY_SUFFIX})
       install(FILES ${CMAKE_CURRENT_BINARY_DIR}/libpng${CMAKE_SHARED_LIBRARY_SUFFIX}
          DESTINATION ${CMAKE_INSTALL_LIBDIR})
@@ -739,7 +304,7 @@ if(NOT SKIP_INSTALL_LIBRARIES AND NOT SKIP_INSTALL_ALL )
 
   if(PNG_STATIC)
     if(NOT WIN32 OR CYGWIN OR MINGW)
-      get_target_property(BUILD_TARGET_LOCATION png_static LOCATION_${CMAKE_BUILD_TYPE})
+      get_target_property(BUILD_TARGET_LOCATION ${PNG_LIB_NAME_STATIC} LOCATION_${CMAKE_BUILD_TYPE})
       CREATE_SYMLINK(${BUILD_TARGET_LOCATION} libpng${CMAKE_STATIC_LIBRARY_SUFFIX})
       install(FILES ${CMAKE_CURRENT_BINARY_DIR}/libpng${CMAKE_STATIC_LIBRARY_SUFFIX}
          DESTINATION ${CMAKE_INSTALL_LIBDIR})
@@ -759,11 +324,6 @@ if(NOT SKIP_INSTALL_EXECUTABLES AND NOT SKIP_INSTALL_ALL )
   endif(NOT WIN32 OR CYGWIN OR MINGW)
 endif()
 
-if(NOT SKIP_INSTALL_PROGRAMS AND NOT SKIP_INSTALL_ALL )
-  install(TARGETS ${PNG_BIN_TARGETS}
-      RUNTIME DESTINATION bin)
-endif()
-
 if(NOT SKIP_INSTALL_FILES AND NOT SKIP_INSTALL_ALL )
   # Install man pages
   if(NOT PNG_MAN_DIR)
@@ -790,7 +350,7 @@ if(PNG_EXPORT_RULE AND NOT SKIP_INSTALL_EXPORT AND NOT SKIP_INSTALL_ALL )
   install(EXPORT libpng DESTINATION lib/libpng FILE lib${PNG_LIB_NAME}.cmake)
 endif()
 
-# what's with libpng-manual.txt and all the extra files?
+# what's with libpng-$VER%.txt and all the extra files?
 
 # UNINSTALL
 # do we need this?

INSTALL

@@ -1,27 +1,5 @@
 
-    Installing libpng
-
-Contents
-
-       I. Simple installation
-      II. Rebuilding the configure scripts
-     III. Using scripts/makefile*
-      IV. Using cmake
-       V. Directory structure
-      VI. Building with project files
-     VII. Building with makefiles
-    VIII. Configuring libpng for 16-bit platforms
-      IX. Configuring for DOS
-       X. Configuring for Medium Model
-      XI. Prepending a prefix to exported symbols
-     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
-     XVI. Common linking failures
-    XVII. Other sources of information about libpng
-
-I. Simple installation
+Installing libpng
 
 On Unix/Linux and similar systems, you can simply type
 
@@ -29,28 +7,13 @@ On Unix/Linux and similar systems, you can simply type
     make check
     make install
 
-and ignore the rest of this document.  "/path" is the path to the directory
-where you want to install the libpng "lib", "include", and "bin"
-subdirectories.
-
-If you downloaded a GIT clone, you will need to run ./autogen.sh before
-running ./configure, to create "configure" and "Makefile.in" which are
-not included in the GIT repository.
-
-Note that "configure" is only included in the "*.tar" distributions and not
-in the "*.zip" or "*.7z" distributions. If you downloaded one of those
-distributions, see "Building with project files" or "Building with makefiles",
-below.
-
-II. Rebuilding the configure scripts
+and ignore the rest of this document.
 
 If configure does not work on your system, or if you have a need to
 change configure.ac or Makefile.am, and you have a reasonably
 up-to-date set of tools, running ./autogen.sh in a git clone before
 running ./configure may fix the problem.  To be really sure that you
-aren't using any of the included pre-built scripts, especially if you
-are building from a tar distribution instead of a git distribution,
-do this:
+aren't using any of the included pre-built scripts, you can do this:
 
     ./configure --enable-maintainer-mode
     make maintainer-clean
@@ -61,12 +24,9 @@ do this:
     make install
     make check
 
-III. Using scripts/makefile*
-
 Instead, you can use one of the custom-built makefiles in the
 "scripts" directory
 
-    cp scripts/pnglibconf.h.prebuilt pnglibconf.h
     cp scripts/makefile.system makefile
     make test
     make install
@@ -78,8 +38,8 @@ Or you can use one of the "projects" in the "projects" directory.
 
 Before installing libpng, you must first install zlib, if it
 is not already on your system.  zlib can usually be found
-wherever you got libpng; otherwise go to http://zlib.net.  You can place
-zlib in the same directory as libpng or in another directory.
+wherever you got libpng.  zlib can be placed in another directory,
+at the same level as libpng.
 
 If your system already has a preinstalled zlib you will still need
 to have access to the zlib.h and zconf.h include files that
@@ -90,42 +50,33 @@ standard library search path, put ZLIBLIB, ZLIBINC, CPPFLAGS, LDFLAGS,
 and LD_LIBRARY_PATH in your environment before running "make test"
 or "make distcheck":
 
-    ZLIBLIB=/path/to/lib export ZLIBLIB
-    ZLIBINC=/path/to/include export ZLIBINC
-    CPPFLAGS="-I$ZLIBINC" export CPPFLAGS
-    LDFLAGS="-L$ZLIBLIB" export LDFLAGS
-    LD_LIBRARY_PATH="$ZLIBLIB:$LD_LIBRARY_PATH" export LD_LIBRARY_PATH
+ZLIBLIB=/path/to/lib export ZLIBLIB
+ZLIBINC=/path/to/include export ZLIBINC
+CPPFLAGS="-I$ZLIBINC" export CPPFLAGS
+LDFLAGS="-L$ZLIBLIB" export LDFLAGS
+LD_LIBRARY_PATH="$ZLIBLIB:$LD_LIBRARY_PATH" export LD_LIBRARY_PATH
 
 If you are using one of the makefile scripts, put ZLIBLIB and ZLIBINC
-in your environment and type
-
-    make ZLIBLIB=$ZLIBLIB ZLIBINC=$ZLIBINC test
-
-IV. Using cmake
+in your environment and type "make ZLIBLIB=$ZLIBLIB ZLIBINC=$ZLIBINC test".
 
 If you want to use "cmake" (see www.cmake.org), type
 
-    cmake . -DCMAKE_INSTALL_PREFIX=/path
-    make
-    make install
-
-As when using the simple configure method described above, "/path" points to
-the installation directory where you want to put the libpng "lib", "include",
-and "bin" subdirectories.
-
-V. Directory structure
+   cmake . -DCMAKE_INSTALL_PREFIX=/path
+   make
+   make install
 
 You can rename the directories that you downloaded (they
-might be called "libpng-x.y.z" or "libpngNN" and "zlib-1.2.8"
-or "zlib128") so that you have directories called "zlib" and "libpng".
+might be called "libpng-x.y.z" or "libpngNN" and "zlib-1.2.7"
+or "zlib127") so that you have directories called "zlib" and "libpng".
 
 Your directory structure should look like this:
 
-    .. (the parent directory)
-      libpng (this directory)
+   ..       (the parent directory)
+      libpng  (this directory)
           INSTALL (this file)
           README
-          *.h, *.c  => libpng source files
+          *.h
+          *.c
           CMakeLists.txt    =>  "cmake" script
           configuration files:
              configure.ac, configure, Makefile.am, Makefile.in,
@@ -133,10 +84,15 @@ Your directory structure should look like this:
              libpng-config.in, aclocal.m4, config.h.in, config.sub,
              depcomp, install-sh, mkinstalldirs, test-pngtest.sh
           contrib
-             arm-neon, conftest, examples, gregbook, libtests, pngminim,
-             pngminus, pngsuite, tools, visupng
+             gregbook
+             libtests
+             pngminim
+             pngminus
+             pngsuite
+             visupng
           projects
-             cbuilder5, owatcom, visualc71, vstudio, xcode
+             visualc71
+             vstudio
           scripts
              makefile.*
              *.def (module definition files)
@@ -144,36 +100,29 @@ Your directory structure should look like this:
           pngtest.png
           etc.
       zlib
-          README, *.h, *.c contrib, etc.
+          README
+          *.h
+          *.c
+          contrib
+          etc.
 
 If the line endings in the files look funny, you may wish to get the other
 distribution of libpng.  It is available in both tar.gz (UNIX style line
 endings) and zip (DOS style line endings) formats.
 
-VI. Building with project files
-
 If you are building libpng with MSVC, you can enter the
-libpng projects\visualc71 or vstudio directory and follow the instructions
+libpng projects\visualc6 or visualc71 directory and follow the instructions
 in README.txt.
 
 Otherwise enter the zlib directory and follow the instructions in zlib/README,
 then come back here and run "configure" or choose the appropriate
 makefile.sys in the scripts directory.
 
-VII. Building with makefiles
-
 Copy the file (or files) that you need from the
 scripts directory into this directory, for example
 
-MSDOS example:
-
-    copy scripts\makefile.msc makefile
-    copy scripts\pnglibconf.h.prebuilt pnglibconf.h
-
-UNIX example:
-
-    cp scripts/makefile.std makefile
-    cp scripts/pnglibconf.h.prebuilt pnglibconf.h
+   MSDOS example: copy scripts\makefile.msc makefile
+   UNIX example:    cp scripts/makefile.std makefile
 
 Read the makefile to see if you need to change any source or
 target directories to match your preferences.
@@ -196,219 +145,26 @@ do that, run "make install" in the zlib directory first if necessary).
 Some also allow you to run "make test-installed" after you have
 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
-won't be accessible.  So limit zlib and libpng to 64K by defining MAXSEG_64K.
-
-IX. Configuring for DOS
-
-For DOS users who only have access to the lower 640K, you will
-have to limit zlib's memory usage via a png_set_compression_mem_level()
-call.  See zlib.h or zconf.h in the zlib library for more information.
-
-X. Configuring for Medium Model
-
-Libpng's support for medium model has been tested on most of the popular
-compilers.  Make sure MAXSEG_64K gets defined, USE_FAR_KEYWORD gets
-defined, and FAR gets defined to far in pngconf.h, and you should be
-all set.  Everything in the library (except for zlib's structure) is
-expecting far data.  You must use the typedefs with the p or pp on
-the end for pointers (or at least look at them and be careful).  Make
-note that the rows of data are defined as png_bytepp, which is
-an "unsigned char far * far *".
-
-XI. Prepending a prefix to exported symbols
-
-Starting with libpng-1.6.0, you can configure libpng (when using the
-"configure" script) to prefix all exported symbols by means of the
-configuration option "--with-libpng-prefix=FOO_", where FOO_ can be any
-string beginning with a letter and containing only uppercase
-and lowercase letters, digits, and the underscore (i.e., a C language
-identifier).  This creates a set of macros in pnglibconf.h, so this is
-transparent to applications; their function calls get transformed by
-the macros to use the modified names.
-
-XII. Configuring for compiler xxx:
-
-All includes for libpng are in pngconf.h.  If you need to add, change
-or delete an include, this is the place to do it.
-The includes that are not needed outside libpng are placed in pngpriv.h,
-which is only used by the routines inside libpng itself.
-The files in libpng proper only include pngpriv.h and png.h, which
-in turn includes pngconf.h and, as of libpng-1.5.0, pnglibconf.h.
-As of libpng-1.5.0, pngpriv.h also includes three other private header
-files, pngstruct.h, pnginfo.h, and pngdebug.h, which contain material
-that previously appeared in the public headers.
-
-XIII. Removing unwanted object code
-
-There are a bunch of #define's in pngconf.h that control what parts of
-libpng are compiled.  All the defines end in _SUPPORTED.  If you are
-never going to use a capability, you can change the #define to #undef
-before recompiling libpng and save yourself code and data space, or
-you can turn off individual capabilities with defines that begin with
-"PNG_NO_".
-
-In libpng-1.5.0 and later, the #define's are in pnglibconf.h instead.
-
-You can also turn all of the transforms and ancillary chunk capabilities
-off en masse with compiler directives that define
-PNG_NO_READ[or WRITE]_TRANSFORMS, or PNG_NO_READ[or WRITE]_ANCILLARY_CHUNKS,
-or all four, along with directives to turn on any of the capabilities that
-you do want.  The PNG_NO_READ[or WRITE]_TRANSFORMS directives disable the
-extra transformations but still leave the library fully capable of reading
-and writing PNG files with all known public chunks. Use of the
-PNG_NO_READ[or WRITE]_ANCILLARY_CHUNKS directive produces a library
-that is incapable of reading or writing ancillary chunks.  If you are
-not using the progressive reading capability, you can turn that off
-with PNG_NO_PROGRESSIVE_READ (don't confuse this with the INTERLACING
-capability, which you'll still have).
-
-All the reading and writing specific code are in separate files, so the
-linker should only grab the files it needs.  However, if you want to
-make sure, or if you are building a stand alone library, all the
-reading files start with "pngr" and all the writing files start with "pngw".
-The files that don't match either (like png.c, pngtrans.c, etc.)
-are used for both reading and writing, and always need to be included.
-The progressive reader is in pngpread.c
-
-If you are creating or distributing a dynamically linked library (a .so
-or DLL file), you should not remove or disable any parts of the library,
-as this will cause applications linked with different versions of the
-library to fail if they call functions not available in your library.
-The size of the library itself should not be an issue, because only
-those sections that are actually used will be loaded into memory.
-
-XIV. Changes to the build and configuration of libpng in libpng-1.5.x
-
-Details of internal changes to the library code can be found in the CHANGES
-file and in the GIT repository logs.  These will be of no concern to the vast
-majority of library users or builders; however, the few who configure libpng
-to a non-default feature set may need to change how this is done.
-
-There should be no need for library builders to alter build scripts if
-these use the distributed build support - configure or the makefiles -
-however, users of the makefiles may care to update their build scripts
-to build pnglibconf.h where the corresponding makefile does not do so.
-
-Building libpng with a non-default configuration has changed completely.
-The old method using pngusr.h should still work correctly even though the
-way pngusr.h is used in the build has been changed; however, library
-builders will probably want to examine the changes to take advantage of
-new capabilities and to simplify their build system.
-
-A. Specific changes to library configuration capabilities
-
-The exact mechanism used to control attributes of API functions has
-changed.  A single set of operating system independent macro definitions
-is used and operating system specific directives are defined in
-pnglibconf.h
-
-As part of this the mechanism used to choose procedure call standards on
-those systems that allow a choice has been changed.  At present this only
-affects certain Microsoft (DOS, Windows) and IBM (OS/2) operating systems
-running on Intel processors.  As before, PNGAPI is defined where required
-to control the exported API functions; however, two new macros, PNGCBAPI
-and PNGCAPI, are used instead for callback functions (PNGCBAPI) and
-(PNGCAPI) for functions that must match a C library prototype (currently
-only png_longjmp_ptr, which must match the C longjmp function.)  The new
-approach is documented in pngconf.h
-
-Despite these changes, libpng 1.5.0 only supports the native C function
-calling standard on those platforms tested so far ("__cdecl" on Microsoft
-Windows).  This is because the support requirements for alternative
-calling conventions seem to no longer exist.  Developers who find it
-necessary to set PNG_API_RULE to 1 should advise the mailing list
-(png-mng-implement) of this and library builders who use Openwatcom and
-therefore set PNG_API_RULE to 2 should also contact the mailing list.
-
-B. Changes to the configuration mechanism
-
-Prior to libpng-1.5.0 library builders who needed to configure libpng
-had either to modify the exported pngconf.h header file to add system
-specific configuration or had to write feature selection macros into
-pngusr.h and cause this to be included into pngconf.h by defining
-PNG_USER_CONFIG. The latter mechanism had the disadvantage that an
-application built without PNG_USER_CONFIG defined would see the
-unmodified, default, libpng API and thus would probably fail to link.
-
-These mechanisms still work in the configure build and in any makefile
-build that builds pnglibconf.h, although the feature selection macros
-have changed somewhat as described above.  In 1.5.0, however, pngusr.h is
-processed only once, at the time the exported header file pnglibconf.h is
-built.  pngconf.h no longer includes pngusr.h; therefore, pngusr.h is ignored
-after the build of pnglibconf.h and it is never included in an application
-build.
-
-The formerly used alternative of adding a list of feature macros to the
-CPPFLAGS setting in the build also still works; however, the macros will be
-copied to pnglibconf.h and this may produce macro redefinition warnings
-when the individual C files are compiled.
-
-All configuration now only works if pnglibconf.h is built from
-scripts/pnglibconf.dfa.  This requires the program awk.  Brian Kernighan
-(the original author of awk) maintains C source code of that awk and this
-and all known later implementations (often called by subtly different
-names - nawk and gawk for example) are adequate to build pnglibconf.h.
-The Sun Microsystems (now Oracle) program 'awk' is an earlier version
-and does not work; this may also apply to other systems that have a
-functioning awk called 'nawk'.
-
-Configuration options are now documented in scripts/pnglibconf.dfa.  This
-file also includes dependency information that ensures a configuration is
-consistent; that is, if a feature is switched off, dependent features are
-also switched off.  As a recommended alternative to using feature macros in
-pngusr.h a system builder may also define equivalent options in pngusr.dfa
-(or, indeed, any file) and add that to the configuration by setting
-DFA_XTRA to the file name.  The makefiles in contrib/pngminim illustrate
-how to do this, and also illustrate a case where pngusr.h is still required.
-
-After you have built libpng, the definitions that were recorded in
-pnglibconf.h are available to your application (pnglibconf.h is included
-in png.h and gets installed alongside png.h and pngconf.h in your
-$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
-
-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
-any platform where it is guaranteed to be thread-safe.  Therefore, if
-your application is going to be using multiple threads, you should
-configure libpng with PNG_NO_SETJMP in your pngusr.dfa file, with
--DPNG_NO_SETJMP on your compile line, or with
-
-    #undef PNG_SETJMP_SUPPORTED
-
-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. Common linking failures
-
-If your application fails to find libpng or zlib entries while linking:
-
-  Be sure "-lz" appears after "-lpng" on your linking command.
-
-  Be sure you have built libpng, zlib, and your application for the
-  same platform (e.g., 32-bit or 64-bit).
-
-  If you are using the vstudio project, observe the WARNING in
-  project/vstudio/README.txt.
-
-XVII. Other sources of information about libpng:
-
 Further information can be found in the README and libpng-manual.txt
 files, in the individual makefiles, in png.h, and the manual pages
 libpng.3 and png.5.
 
-Copyright (c) 1998-2002,2006-2016 Glenn Randers-Pehrson
-This document is released under the libpng license.
-For conditions of distribution and use, see the disclaimer
-and license in png.h.
+Using the ./configure script -- 16 December 2002.
+=================================================
+
+The ./configure script should work compatibly with what scripts/makefile.*
+did, however there are some options you might need to add to configure
+explicitly, which previously was done semi-automatically (if you didn't edit
+scripts/makefile.* yourself, that is)
+
+CFLAGS="-Wall -O -funroll-loops \
+-malign-loops=2 -malign-functions=2" ./configure --prefix=/usr/include \
+--with-pkgconfigdir=/usr/lib/pkgconfig --includedir=/usr/include
+
+You can alternatively specify --includedir=/usr/include, /usr/local/include,
+/usr/include/libpng%NN%, 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",
+"Makefile.in", and the other configuration files. Then try configure again.
+

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.6.26, October 20, 2016 are
-Copyright (c) 2000-2002, 2004, 2006-2016 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.3, July 18, 2013, are
+Copyright (c) 2004, 2006-2013 Glenn Randers-Pehrson, and are
+distributed according to the same disclaimer and license as libpng-1.2.5
+with the following individual added to the list of Contributing Authors
+
+   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:
 
@@ -32,25 +35,19 @@ and with the following additions to the disclaimer:
    risk of satisfactory quality, performance, accuracy, and effort is with
    the user.
 
-Some files in the "contrib" directory and some configure-generated
-files that are distributed with libpng have other copyright owners and
-are released under other open source licenses.
-
 libpng versions 0.97, January 1998, through 1.0.6, March 20, 2000, are
-Copyright (c) 1998-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
@@ -59,11 +56,8 @@ Contributing Authors:
    Greg Roelofs
    Tom Tanner
 
-Some files in the "scripts" directory have other copyright owners
-but are released under this license.
-
 libpng versions 0.5, May 1995, through 0.88, January 1996, are
-Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.
+Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
 
 For the purposes of this copyright and license, "Contributing Authors"
 is defined as the following set of individuals:
@@ -86,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
@@ -100,31 +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.
 
-TRADEMARK:
+A "png_get_copyright" function is available, for convenient use in "about"
+boxes and the like:
 
-The name "libpng" has not been registered by the Copyright owner
-as a trademark in any jurisdiction.  However, because libpng has
-been distributed and maintained world-wide, continually since 1995,
-the Copyright owner claims "common-law trademark protection" in any
-jurisdiction where common-law trademark is recognized.
+   printf("%s",png_get_copyright(NULL));
 
-OSI CERTIFICATION:
+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.
-
-EXPORT CONTROL:
-
-The Copyright owner believes that the Export Control Classification
-Number (ECCN) for libpng is EAR99, which means not subject to export
-controls or International Traffic in Arms Regulations (ITAR) because
-it is open source, publicly available software, that does not contain
-any encryption software.  See the EAR, paragraphs 734.3(b)(3) and
-734.7(b).
+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
-October 20, 2016
+July 18, 2013

Makefile.am

@@ -1,35 +1,17 @@
-# Makefile.am, the source file for Makefile.in (and hence Makefile), is
+# Makefile.am:
+#   Source file for Makefile.in (and hence Makefile)
 #
-# Copyright (c) 2004-2016 Glenn Randers-Pehrson
-# Last changed in libpng 1.6.25 [October 20, 2016]
-#
-# This code is released under the libpng license.
-# For conditions of distribution and use, see the disclaimer
-# and license in png.h
 
 PNGLIB_BASENAME= libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@
 
 ACLOCAL_AMFLAGS = -I scripts
 
 # test programs - run on make check, make distcheck
-check_PROGRAMS= pngtest pngunknown pngstest pngvalid pngimage pngcp
-if HAVE_CLOCK_GETTIME
-check_PROGRAMS += timepng
-endif
+check_PROGRAMS= pngtest pngunknown pngstest pngvalid
 
 # Utilities - installed
 bin_PROGRAMS= pngfix png-fix-itxt
 
-# This ensures that pnglibconf.h gets built at the start of 'make all' or
-# 'make check', but it does not add dependencies to the individual programs,
-# this is done below.
-#
-# IMPORTANT: always add the object modules of new programs to the list below
-# because otherwise the sequence 'configure; make new-program' will *sometimes*
-# result in the installed (system) pnglibconf.h being used and the result is
-# always wrong and always very confusing.
-BUILT_SOURCES = pnglibconf.h
-
 pngtest_SOURCES = pngtest.c
 pngtest_LDADD = libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@.la
 
@@ -42,20 +24,11 @@ pngstest_LDADD = libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@.la
 pngunknown_SOURCES = contrib/libtests/pngunknown.c
 pngunknown_LDADD = libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@.la
 
-pngimage_SOURCES = contrib/libtests/pngimage.c
-pngimage_LDADD = libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@.la
-
-timepng_SOURCES = contrib/libtests/timepng.c
-timepng_LDADD = libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@.la
-
 pngfix_SOURCES = contrib/tools/pngfix.c
 pngfix_LDADD = libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@.la
 
 png_fix_itxt_SOURCES = contrib/tools/png-fix-itxt.c
 
-pngcp_SOURCES = contrib/tools/pngcp.c
-pngcp_LDADD = libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@.la
-
 # Generally these are single line shell scripts to run a test with a particular
 # set of parameters:
 TESTS =\
@@ -65,16 +38,21 @@ 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-progressive-interlace-size\
    tests/pngvalid-progressive-interlace-standard\
-   tests/pngvalid-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
+   tests/pngunknown-sTER tests/pngunknown-save tests/pngunknown-vpAg
+
+# These tests are expected, and required, to fail:
+XFAIL_TESTS = tests/pngstest-error
 
 # man pages
 dist_man_MANS= libpng.3 libpngpf.3 png.5
@@ -94,12 +72,7 @@ libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@_la_SOURCES = png.c pngerror.c\
 
 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
-
-if PNG_MIPS_MSA
-libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@_la_SOURCES += mips/mips_init.c\
-	mips/filter_msa_intrinsics.c
+	arm/filter_neon.S
 endif
 
 nodist_libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@_la_SOURCES = pnglibconf.h
@@ -142,12 +115,11 @@ EXTRA_DIST= \
 	$(TESTS) $(XFAIL_TESTS) tests/pngstest \
 	CMakeLists.txt example.c libpng-manual.txt
 
-SCRIPT_CLEANFILES=scripts/*.out scripts/*.chk
+SCRIPT_CLEANFILES=scripts/*.out scripts/*.chk scripts/pnglibconf.dfn
 
 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.pre pnglibconf.dfn \
+	check.new pnglibconf.* pngprefix.h symbols.new pngtest-log.txt \
 	$(SCRIPT_CLEANFILES)
 
 MAINTAINERCLEANFILES = Makefile.in aclocal.m4 config.guess config.h.in \
@@ -166,7 +138,7 @@ AM_CFLAGS = ${PNG_COPTS}
 # checks for this and sets DFNCPP appropriately.
 DFNCPP = @DFNCPP@
 
-SUFFIXES = .chk .out
+SUFFIXES = .chk .dfn .out
 
 $(PNGLIB_BASENAME).pc: libpng.pc
 	cp libpng.pc $@
@@ -222,23 +194,9 @@ $(srcdir)/scripts/pnglibconf.h.prebuilt:
 
 # The following is necessary to ensure that the local pnglibconf.h is used, not
 # an installed one (this can happen immediately after on a clean system if
-# 'make test' is the first thing the user does.)  Only files which include
-# one of the png source files (typically png.h or pngpriv.h) need to be listed
-# here:
-pngtest.o: pnglibconf.h
-
-contrib/libtests/makepng.o: pnglibconf.h
-contrib/libtests/pngstest.o: pnglibconf.h
-contrib/libtests/pngunknown.o: pnglibconf.h
-contrib/libtests/pngimage.o: pnglibconf.h
-contrib/libtests/pngvalid.o: pnglibconf.h
-contrib/libtests/readpng.o: pnglibconf.h
-contrib/libtests/tarith.o: pnglibconf.h
-contrib/libtests/timepng.o: pnglibconf.h
-
-contrib/tools/makesRGB.o: pnglibconf.h
-contrib/tools/pngfix.o: pnglibconf.h
-contrib/tools/pngcp.o: pnglibconf.h
+# 'make test' is the first thing the user does.)
+pngstest.o pngvalid.o pngtest.o pngunknown.o timepng.o: pnglibconf.h
+pngfix.o png-fix-itxt.o: pnglibconf.h
 
 # We must use -DPNG_NO_USE_READ_MACROS here even when the library may actually
 # be built with PNG_USE_READ_MACROS; this prevents the read macros from
@@ -252,17 +210,18 @@ if DO_PNG_PREFIX
 SYMBOL_CFLAGS += -DPNG_PREFIX='@PNG_PREFIX@'
 endif
 
-.c.out:
-	rm -f $@ $*.tf[12]
+.dfn.out:
+	rm -f $@ $*.c $*.tf[12]
 	test -d scripts || mkdir scripts || test -d scripts
+	echo '#include "$<"' >$*.c
 	$(DFNCPP) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES)\
-	    $(CPPFLAGS) $(SYMBOL_CFLAGS) $< > $*.tf1
+	    $(CPPFLAGS) $(SYMBOL_CFLAGS) $*.c > $*.tf1
 	$(AWK) -f "${srcdir}/scripts/dfn.awk" out="$*.tf2" $*.tf1 1>&2
-	rm -f $*.tf1
+	rm -f $*.c $*.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_XTRA)
+# The .dfn file for pnglibconf.h is machine generated
+pnglibconf.dfn: 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\
@@ -282,7 +241,7 @@ scripts/symbols.chk: scripts/checksym.awk scripts/symbols.def scripts/symbols.ou
 
 # used on demand to regenerate the standard header, CPPFLAGS should
 # be empty - no non-standard defines
-scripts/pnglibconf.c: scripts/pnglibconf.dfa scripts/options.awk pngconf.h
+scripts/pnglibconf.dfn: scripts/pnglibconf.dfa scripts/options.awk pngconf.h
 	rm -f $@ pnglibconf.tf[67]
 	test -z "$(CPPFLAGS)"
 	echo "com @PNGLIB_VERSION@ STANDARD API DEFINITION" |\
@@ -306,76 +265,40 @@ check: scripts/symbols.chk
 dist-hook:
 	cd '$(top_distdir)'; rm -f $(SCRIPT_CLEANFILES)
 
-# Make links between installed files with release-specific names and the generic
-# file names.  If this install rule is run the generic names will be deleted and
-# recreated - this has obvious issues for systems with multiple installations.
+# install the .../include headers as links to the new ones
+install-data-hook:
+	cd '$(DESTDIR)$(includedir)'; rm -f png.h pngconf.h pnglibconf.h
+	cd '$(DESTDIR)$(includedir)'; $(LN_S) $(PNGLIB_BASENAME)/png.h png.h
+	cd '$(DESTDIR)$(includedir)'; $(LN_S) $(PNGLIB_BASENAME)/pngconf.h \
+		pngconf.h
+	cd '$(DESTDIR)$(includedir)'; $(LN_S) $(PNGLIB_BASENAME)/pnglibconf.h \
+		pnglibconf.h
+	cd '$(DESTDIR)$(pkgconfigdir)'; rm -f libpng.pc
+	cd '$(DESTDIR)$(pkgconfigdir)'; $(LN_S) $(PNGLIB_BASENAME).pc libpng.pc
 
-install-header-links:
-	@set -ex; cd '$(DESTDIR)$(includedir)'; for f in $(HEADERS); do \
-	   rm -f "$$f"; $(LN_S) "$(PNGLIB_BASENAME)/$$f" "$$f"; done
-
-uninstall-header-links:
-	cd '$(DESTDIR)$(includedir)'; rm -f $(HEADERS)
-
-install-libpng-pc:
-	@set -ex; cd '$(DESTDIR)$(pkgconfigdir)'; rm -f libpng.pc; \
-	   $(LN_S) '$(PNGLIB_BASENAME).pc' libpng.pc
-
-uninstall-libpng-pc:
-	rm -f '$(DESTDIR)$(pkgconfigdir)/libpng.pc'
-
-# EXT_LIST is a list of the possibly library directory extensions, this exists
-# because we can't find a good way of discovering the file extensions that are
-# actually installed on a given system, so instead we check for every extension
-# we have seen.
-
-EXT_LIST = a dll.a so so.@PNGLIB_MAJOR@@PNGLIB_MINOR@.@PNGLIB_RELEASE@ la sl dylib
-
-install-library-links:
-	@set -x; cd '$(DESTDIR)$(libdir)';\
-	for ext in $(EXT_LIST); do\
-	   rm -f "libpng.$$ext";\
-           if test -f "$(PNGLIB_BASENAME).$$ext"; then\
-              $(LN_S) "$(PNGLIB_BASENAME).$$ext" "libpng.$$ext" || exit 1;\
-           fi;\
+# do evil things to libpng to cause libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@ to be used
+install-exec-hook:
+	cd '$(DESTDIR)$(bindir)'; rm -f libpng-config
+	cd '$(DESTDIR)$(bindir)';\
+	   $(LN_S) $(PNGLIB_BASENAME)-config libpng-config
+	@set -x;\
+	cd '$(DESTDIR)$(libdir)';\
+	for ext in a la so so.@PNGLIB_MAJOR@@PNGLIB_MINOR@.@PNGLIB_RELEASE@\
+	   sl dylib dll.a; do\
+		rm -f libpng.$$ext;\
+                if test -f $(PNGLIB_BASENAME).$$ext; then\
+                       $(LN_S) $(PNGLIB_BASENAME).$$ext libpng.$$ext;\
+                fi;\
 	done
 
-uninstall-library-links:
-	@set -x; cd '$(DESTDIR)$(libdir)'; for ext in $(EXT_LIST); do\
-	   rm -f "libpng.$$ext"; done
-
-install-libpng-config:
-	@set -ex; cd '$(DESTDIR)$(bindir)'; rm -f libpng-config; \
-	   $(LN_S) '$(PNGLIB_BASENAME)-config' libpng-config
-
-uninstall-libpng-config:
+uninstall-hook:
+	cd '$(DESTDIR)$(includedir)'; rm -f png.h pngconf.h pnglibconf.h
+	rm -f '$(DESTDIR)$(pkgconfigdir)/libpng.pc'
 	rm -f '$(DESTDIR)$(bindir)/libpng-config'
-
-if DO_INSTALL_LINKS
-# If --enable-unversioned-links is specified the header and lib file links
-# will be automatically made on a 'make install':
-
-install-data-hook: install-header-links
-uninstall-hook: uninstall-header-links
-install-exec-hook: install-library-links
-uninstall-hook: uninstall-library-links
-endif
-
-if DO_INSTALL_LIBPNG_PC
-# Likewise, --install-pc causes libpng.pc to be constructed:
-
-install-data-hook: install-libpng-pc
-uninstall-hook: uninstall-libpng-pc
-endif
-
-if DO_INSTALL_LIBPNG_CONFIG
-# And --install-config:
-
-install-exec-hook: install-libpng-config
-uninstall-hook: uninstall-libpng-config
-endif
-
-# The following addition ensures that 'make all' always builds the test programs
-# too.  It used to, but some change either in libpng or configure stopped this
-# working.
-all-am: $(check_PROGRAMS)
+	rm -f '$(DESTDIR)$(libdir)/libpng.a'
+	rm -f '$(DESTDIR)$(libdir)/libpng.la'
+	rm -f '$(DESTDIR)$(libdir)/libpng.so'
+	rm -f '$(DESTDIR)$(libdir)/libpng.so.@PNGLIB_MAJOR@@PNGLIB_MINOR@.@PNGLIB_RELEASE@'
+	rm -f '$(DESTDIR)$(libdir)/libpng.sl'
+	rm -f '$(DESTDIR)$(libdir)/libpng.dylib'
+	rm -f '$(DESTDIR)$(libdir)/libpng.dll.a'

README

@@ -1,4 +1,4 @@
-README for libpng version 1.6.26 - October 20, 2016 (shared library 16.0)
+README for libpng version 1.6.3 - July 18, 2013 (shared library 16.0)
 See the note about version numbers near the top of png.h
 
 See INSTALL for instructions on how to install libpng.
@@ -23,25 +23,18 @@ earlier versions if you are using a shared library.  The type of the
 png_uint_32, which will affect shared-library applications that use
 this function.
 
-To avoid problems with changes to the internals of png info_struct,
+To avoid problems with changes to the internals of png_info_struct,
 new APIs have been made available in 0.95 to avoid direct application
 access to info_ptr.  These functions are the png_set_<chunk> and
 png_get_<chunk> functions.  These functions should be used when
 accessing/storing the info_struct data, rather than manipulating it
 directly, to avoid such problems in the future.
 
-It is important to note that the APIs did not make current programs
+It is important to note that the APIs do not make current programs
 that access the info struct directly incompatible with the new
-library, through libpng-1.2.x.  In libpng-1.4.x, which was meant to
-be a transitional release, members of the png_struct and the
-info_struct can still be accessed, but the compiler will issue a
-warning about deprecated usage.  Since libpng-1.5.0, direct access
-to these structs is not allowed, and the definitions of the structs
-reside in private pngstruct.h and pnginfo.h header files that are not
-accessible to applications.  It is strongly suggested that new
-programs use the new APIs (as shown in example.c and pngtest.c), and
-older programs be converted to the new format, to facilitate upgrades
-in the future.
+library.  However, it is strongly suggested that new programs use
+the new APIs (as shown in example.c and pngtest.c), and older programs
+be converted to the new format, to facilitate upgrades in the future.
 ****
 
 Additions since 0.90 include the ability to compile libpng as a
@@ -94,12 +87,6 @@ This code is currently being archived at libpng.sf.net in the
 [DOWNLOAD] area, and at ftp://ftp.simplesystems.org.  If you can't find it
 in any of those places, e-mail me, and I'll help you find it.
 
-I am not a lawyer, but I believe that the Export Control Classification
-Number (ECCN) for libpng is EAR99, which means not subject to export
-controls or International Traffic in Arms Regulations (ITAR) because it
-is open source, publicly available software, that does not contain any
-encryption software.  See the EAR, paragraphs 734.3(b)(3) and 734.7(b).
-
 If you have any code changes, requests, problems, etc., please e-mail
 them to me.  Also, I'd appreciate any make files or project files,
 and any modifications you needed to make to get libpng to compile,
@@ -134,7 +121,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 eighteen 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.
@@ -180,20 +167,17 @@ Files in this distribution:
       pngwutil.c    =>  Write utility functions
       arm           =>  Contains optimized code for the ARM platform
       contrib       =>  Contributions
-       arm-neon         =>  Optimized code for ARM-NEON platform
        examples         =>  Example programs
        gregbook         =>  source code for PNG reading and writing, from
                             Greg Roelofs' "PNG: The Definitive Guide",
                             O'Reilly, 1999
-       intel            =>  Optimized code for INTEL-SSE2 platform
        libtests         =>  Test programs
        pngminim         =>  Minimal decoder, encoder, and progressive decoder
                             programs demonstrating use of pngusr.dfa
        pngminus         =>  Simple pnm2png and png2pnm programs
        pngsuite         =>  Test images
-       testpngs
        tools            =>  Various tools
-       visupng          =>  Contains a MSVC workspace for VisualPng
+       visupng      =>  Contains a MSVC workspace for VisualPng
       projects      =>  Contains project files and workspaces for
                         building a DLL
        owatcom          =>  Contains a WATCOM project for building libpng

TODO

@@ -5,10 +5,7 @@ Final bug fixes.
 Better C++ wrapper/full C++ implementation?
 Fix problem with C++ and EXTERN "C".
 cHRM transformation.
-Remove setjmp/longjmp usage in favor of returning error codes. As a start on
-  this, minimize the use of png_error(), replacing them with
-  png_warning(); return(0; or similar.
-Palette creation.
+Remove setjmp/longjmp usage in favor of returning error codes.
 Add "grayscale->palette" transformation and "palette->grayscale" detection.
 Improved dithering.
 Multi-lingual error and warning message support.

arm/arm_init.c

@@ -1,9 +1,9 @@
 
 /* arm_init.c - NEON optimised filter functions
  *
- * Copyright (c) 2014,2016 Glenn Randers-Pehrson
+ * Copyright (c) 2013 Glenn Randers-Pehrson
  * Written by Mans Rullgard, 2011.
- * Last changed in libpng 1.6.22 [May 26, 2016]
+ * Last changed in libpng 1.5.17 [July 18, 2013]
  *
  * This code is released under the libpng license.
  * For conditions of distribution and use, see the disclaimer
@@ -17,36 +17,134 @@
 #include "../pngpriv.h"
 
 #ifdef PNG_READ_SUPPORTED
-
 #if PNG_ARM_NEON_OPT > 0
 #ifdef PNG_ARM_NEON_CHECK_SUPPORTED /* Do run-time checks */
-/* WARNING: it is strongly recommended that you do not build libpng with
- * run-time checks for CPU features if at all possible.  In the case of the ARM
- * NEON instructions there is no processor-specific way of detecting the
- * presence of the required support, therefore run-time detection is extremely
- * OS specific.
- *
- * You may set the macro PNG_ARM_NEON_FILE to the file name of file containing
- * a fragment of C source code which defines the png_have_neon function.  There
- * are a number of implementations in contrib/arm-neon, but the only one that
- * has partial support is contrib/arm-neon/linux.c - a generic Linux
- * implementation which reads /proc/cpufino.
- */
-#ifndef PNG_ARM_NEON_FILE
-#  ifdef __linux__
-#     define PNG_ARM_NEON_FILE "contrib/arm-neon/linux.c"
-#  endif
-#endif
-
-#ifdef PNG_ARM_NEON_FILE
-
 #include <signal.h> /* for sig_atomic_t */
-static int png_have_neon(png_structp png_ptr);
-#include PNG_ARM_NEON_FILE
 
-#else  /* PNG_ARM_NEON_FILE */
-#  error "PNG_ARM_NEON_FILE undefined: no support for run-time ARM NEON checks"
-#endif /* PNG_ARM_NEON_FILE */
+#ifdef __ANDROID__
+/* Linux provides access to information about CPU capabilites via
+ * /proc/self/auxv, however Android blocks this while still claiming to be
+ * Linux.  The Andoid NDK, however, provides appropriate support.
+ *
+ * Documentation: http://www.kandroid.org/ndk/docs/CPU-ARM-NEON.html
+ */
+#include <cpu-features.h>
+
+static int
+png_have_neon(png_structp png_ptr)
+{
+   /* This is a whole lot easier than the mess below, however it is probably
+    * implemented as below, therefore it is better to cache the result (these
+    * function calls may be slow!)
+    */
+   PNG_UNUSED(png_ptr)
+   return android_getCpuFamily() == ANDROID_CPU_FAMILY_ARM &&
+      (android_getCpuFeatures() & ANDROID_CPU_ARM_FEATURE_NEON) != 0;
+}
+#elif defined(__linux__)
+/* The generic __linux__ implementation requires reading /proc/self/auxv and
+ * looking at each element for one that records NEON capabilities.
+ */
+#include <unistd.h> /* for POSIX 1003.1 */
+#include <errno.h>  /* for EINTR */
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <elf.h>
+#include <asm/hwcap.h>
+
+/* A read call may be interrupted, in which case it returns -1 and sets errno to
+ * EINTR if nothing was done, otherwise (if something was done) a partial read
+ * may result.
+ */
+static size_t
+safe_read(png_structp png_ptr, int fd, void *buffer_in, size_t nbytes)
+{
+   size_t ntotal = 0;
+   char *buffer = png_voidcast(char*, buffer_in);
+
+   while (nbytes > 0)
+   {
+      unsigned int nread;
+      int iread;
+
+      /* Passing nread > INT_MAX to read is implementation defined in POSIX
+       * 1003.1, therefore despite the unsigned argument portable code must
+       * limit the value to INT_MAX!
+       */
+      if (nbytes > INT_MAX)
+         nread = INT_MAX;
+
+      else
+         nread = (unsigned int)/*SAFE*/nbytes;
+
+      iread = read(fd, buffer, nread);
+
+      if (iread == -1)
+      {
+         /* This is the devil in the details, a read can terminate early with 0
+          * bytes read because of EINTR, yet it still returns -1 otherwise end
+          * of file cannot be distinguished.
+          */
+         if (errno != EINTR)
+         {
+            png_warning(png_ptr, "/proc read failed");
+            return 0; /* I.e. a permanent failure */
+         }
+      }
+
+      else if (iread < 0)
+      {
+         /* Not a valid 'read' result: */
+         png_warning(png_ptr, "OS /proc read bug");
+         return 0;
+      }
+
+      else if (iread > 0)
+      {
+         /* Continue reading until a permanent failure, or EOF */
+         buffer += iread;
+         nbytes -= (unsigned int)/*SAFE*/iread;
+         ntotal += (unsigned int)/*SAFE*/iread;
+      }
+
+      else
+         return ntotal;
+   }
+
+   return ntotal; /* nbytes == 0 */
+}
+
+static int
+png_have_neon(png_structp png_ptr)
+{
+   int fd = open("/proc/self/auxv", O_RDONLY);
+   Elf32_auxv_t aux;
+
+   /* Failsafe: failure to open means no NEON */
+   if (fd == -1)
+   {
+      png_warning(png_ptr, "/proc/self/auxv open failed");
+      return 0;
+   }
+
+   while (safe_read(png_ptr, fd, &aux, sizeof aux) == sizeof aux)
+   {
+      if (aux.a_type == AT_HWCAP && (aux.a_un.a_val & HWCAP_NEON) != 0)
+      {
+         close(fd);
+         return 1;
+      }
+   }
+
+   close(fd);
+   return 0;
+}
+#else
+   /* We don't know how to do a run-time check on this system */
+#  error "no support for run-time ARM NEON checks"
+#endif /* OS checks */
 #endif /* PNG_ARM_NEON_CHECK_SUPPORTED */
 
 #ifndef PNG_ALIGNED_MEMORY_SUPPORTED
@@ -56,17 +154,6 @@ static int png_have_neon(png_structp png_ptr);
 void
 png_init_filter_functions_neon(png_structp pp, unsigned int bpp)
 {
-   /* The switch statement is compiled in for ARM_NEON_API, the call to
-    * png_have_neon is compiled in for ARM_NEON_CHECK.  If both are defined
-    * the check is only performed if the API has not set the NEON option on
-    * or off explicitly.  In this case the check controls what happens.
-    *
-    * If the CHECK is not compiled in and the option is UNSET the behavior prior
-    * to 1.6.7 was to use the NEON code - this was a bug caused by having the
-    * wrong order of the 'ON' and 'default' cases.  UNSET now defaults to OFF,
-    * as documented in png.h
-    */
-   png_debug(1, "in png_init_filter_functions_neon");
 #ifdef PNG_ARM_NEON_API_SUPPORTED
    switch ((pp->options >> PNG_ARM_NEON) & 3)
    {
@@ -91,14 +178,13 @@ png_init_filter_functions_neon(png_structp pp, unsigned int bpp)
          break;
 #endif
 #endif /* PNG_ARM_NEON_CHECK_SUPPORTED */
-
 #ifdef PNG_ARM_NEON_API_SUPPORTED
-      default: /* OFF or INVALID */
-         return;
-
       case PNG_OPTION_ON:
          /* Option turned on */
          break;
+
+      default: /* OFF or INVALID */
+         return;
    }
 #endif
 
@@ -132,4 +218,4 @@ png_init_filter_functions_neon(png_structp pp, unsigned int bpp)
    }
 }
 #endif /* PNG_ARM_NEON_OPT > 0 */
-#endif /* READ */
+#endif /* PNG_READ_SUPPORTED */

arm/filter_neon.S

@@ -1,17 +1,17 @@
 
 /* filter_neon.S - NEON optimised filter functions
  *
- * Copyright (c) 2014 Glenn Randers-Pehrson
+ * Copyright (c) 2013 Glenn Randers-Pehrson
  * Written by Mans Rullgard, 2011.
- * Last changed in libpng 1.6.16 [December 22, 2014]
+ * Last changed in libpng 1.5.17 [July 18, 2013]
  *
  * This code is released under the libpng license.
  * For conditions of distribution and use, see the disclaimer
  * and license in png.h
  */
 
-/* This is required to get the symbol renames, which are #defines, and the
- * definitions (or not) of PNG_ARM_NEON_OPT and PNG_ARM_NEON_IMPLEMENTATION.
+/* This is required to get the symbol renames, which are #defines, and also
+ * includes the definition (or not) of PNG_ARM_NEON_OPT.
  */
 #define PNG_VERSION_INFO_ONLY
 #include "../pngpriv.h"
@@ -21,14 +21,6 @@
 #endif
 
 #ifdef PNG_READ_SUPPORTED
-
-/* Assembler NEON support - only works for 32-bit ARM (i.e. it does not work for
- * ARM64).  The code in arm/filter_neon_intrinsics.c supports ARM64, however it
- * only works if -mfpu=neon is specified on the GCC command line.  See pngpriv.h
- * for the logic which sets PNG_USE_ARM_NEON_ASM:
- */
-#if PNG_ARM_NEON_IMPLEMENTATION == 2 /* hand-coded assembler */
-
 #if PNG_ARM_NEON_OPT > 0
 
 #ifdef __ELF__
@@ -47,13 +39,6 @@ ELF     .size   \name, . - \name
         .purgem endfunc
     .endm
         .text
-
-        /* Explicitly specifying alignment here because some versions of
-         * GAS don't align code correctly.  This is harmless in correctly
-         * written versions of GAS.
-         */
-        .align 2
-
     .if \export
         .global \name
     .endif
@@ -249,5 +234,4 @@ func    png_read_filter_row_paeth3_neon, export=1
         pop             {r4,pc}
 endfunc
 #endif /* PNG_ARM_NEON_OPT > 0 */
-#endif /* PNG_ARM_NEON_IMPLEMENTATION == 2 (assembler) */
-#endif /* READ */
+#endif /* PNG_READ_SUPPORTED */

arm/filter_neon_intrinsics.c

@@ -1,387 +0,0 @@
-
-/* filter_neon_intrinsics.c - NEON optimised filter functions
- *
- * Copyright (c) 2014,2016 Glenn Randers-Pehrson
- * 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.22 [May 26, 2016]
- *
- * 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"
-
-#ifdef PNG_READ_SUPPORTED
-
-/* This code requires -mfpu=neon on the command line: */
-#if PNG_ARM_NEON_IMPLEMENTATION == 1 /* intrinsics code from pngpriv.h */
-
-#include <arm_neon.h>
-
-/* libpng row pointers are not necessarily aligned to any particular boundary,
- * however this code will only work with appropriate alignment.  arm/arm_init.c
- * checks for this (and will not compile unless it is done). This code uses
- * variants of png_aligncast to avoid compiler warnings.
- */
-#define png_ptr(type,pointer) png_aligncast(type *,pointer)
-#define png_ptrc(type,pointer) png_aligncastconst(const type *,pointer)
-
-/* The following relies on a variable 'temp_pointer' being declared with type
- * 'type'.  This is written this way just to hide the GCC strict aliasing
- * warning; note that the code is safe because there never is an alias between
- * the input and output pointers.
- */
-#define png_ldr(type,pointer)\
-   (temp_pointer = png_ptr(type,pointer), *temp_pointer)
-
-#if PNG_ARM_NEON_OPT > 0
-
-void
-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 + row_info->rowbytes;
-   png_const_bytep pp = prev_row;
-
-   png_debug(1, "in png_read_filter_row_up_neon");
-
-   for (; rp < rp_stop; rp += 16, pp += 16)
-   {
-      uint8x16_t qrp, qpp;
-
-      qrp = vld1q_u8(rp);
-      qpp = vld1q_u8(pp);
-      qrp = vaddq_u8(qrp, qpp);
-      vst1q_u8(rp, qrp);
-   }
-}
-
-void
-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 + row_info->rowbytes;
-
-   uint8x16_t vtmp = vld1q_u8(rp);
-   uint8x8x2_t *vrpt = png_ptr(uint8x8x2_t, &vtmp);
-   uint8x8x2_t vrp = *vrpt;
-
-   uint8x8x4_t vdest;
-   vdest.val[3] = vdup_n_u8(0);
-
-   png_debug(1, "in png_read_filter_row_sub3_neon");
-
-   for (; rp < rp_stop;)
-   {
-      uint8x8_t vtmp1, vtmp2;
-      uint32x2_t *temp_pointer;
-
-      vtmp1 = vext_u8(vrp.val[0], vrp.val[1], 3);
-      vdest.val[0] = vadd_u8(vdest.val[3], vrp.val[0]);
-      vtmp2 = vext_u8(vrp.val[0], vrp.val[1], 6);
-      vdest.val[1] = vadd_u8(vdest.val[0], vtmp1);
-
-      vtmp1 = vext_u8(vrp.val[1], vrp.val[1], 1);
-      vdest.val[2] = vadd_u8(vdest.val[1], vtmp2);
-      vdest.val[3] = vadd_u8(vdest.val[2], vtmp1);
-
-      vtmp = vld1q_u8(rp + 12);
-      vrpt = png_ptr(uint8x8x2_t, &vtmp);
-      vrp = *vrpt;
-
-      vst1_lane_u32(png_ptr(uint32_t,rp), png_ldr(uint32x2_t,&vdest.val[0]), 0);
-      rp += 3;
-      vst1_lane_u32(png_ptr(uint32_t,rp), png_ldr(uint32x2_t,&vdest.val[1]), 0);
-      rp += 3;
-      vst1_lane_u32(png_ptr(uint32_t,rp), png_ldr(uint32x2_t,&vdest.val[2]), 0);
-      rp += 3;
-      vst1_lane_u32(png_ptr(uint32_t,rp), png_ldr(uint32x2_t,&vdest.val[3]), 0);
-      rp += 3;
-   }
-
-   PNG_UNUSED(prev_row)
-}
-
-void
-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 + row_info->rowbytes;
-
-   uint8x8x4_t vdest;
-   vdest.val[3] = vdup_n_u8(0);
-
-   png_debug(1, "in png_read_filter_row_sub4_neon");
-
-   for (; rp < rp_stop; rp += 16)
-   {
-      uint32x2x4_t vtmp = vld4_u32(png_ptr(uint32_t,rp));
-      uint8x8x4_t *vrpt = png_ptr(uint8x8x4_t,&vtmp);
-      uint8x8x4_t vrp = *vrpt;
-      uint32x2x4_t *temp_pointer;
-
-      vdest.val[0] = vadd_u8(vdest.val[3], vrp.val[0]);
-      vdest.val[1] = vadd_u8(vdest.val[0], vrp.val[1]);
-      vdest.val[2] = vadd_u8(vdest.val[1], vrp.val[2]);
-      vdest.val[3] = vadd_u8(vdest.val[2], vrp.val[3]);
-      vst4_lane_u32(png_ptr(uint32_t,rp), png_ldr(uint32x2x4_t,&vdest), 0);
-   }
-
-   PNG_UNUSED(prev_row)
-}
-
-void
-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 + row_info->rowbytes;
-
-   uint8x16_t vtmp;
-   uint8x8x2_t *vrpt;
-   uint8x8x2_t vrp;
-   uint8x8x4_t vdest;
-   vdest.val[3] = vdup_n_u8(0);
-
-   vtmp = vld1q_u8(rp);
-   vrpt = png_ptr(uint8x8x2_t,&vtmp);
-   vrp = *vrpt;
-
-   png_debug(1, "in png_read_filter_row_avg3_neon");
-
-   for (; rp < rp_stop; pp += 12)
-   {
-      uint8x8_t vtmp1, vtmp2, vtmp3;
-
-      uint8x8x2_t *vppt;
-      uint8x8x2_t vpp;
-
-      uint32x2_t *temp_pointer;
-
-      vtmp = vld1q_u8(pp);
-      vppt = png_ptr(uint8x8x2_t,&vtmp);
-      vpp = *vppt;
-
-      vtmp1 = vext_u8(vrp.val[0], vrp.val[1], 3);
-      vdest.val[0] = vhadd_u8(vdest.val[3], vpp.val[0]);
-      vdest.val[0] = vadd_u8(vdest.val[0], vrp.val[0]);
-
-      vtmp2 = vext_u8(vpp.val[0], vpp.val[1], 3);
-      vtmp3 = vext_u8(vrp.val[0], vrp.val[1], 6);
-      vdest.val[1] = vhadd_u8(vdest.val[0], vtmp2);
-      vdest.val[1] = vadd_u8(vdest.val[1], vtmp1);
-
-      vtmp2 = vext_u8(vpp.val[0], vpp.val[1], 6);
-      vtmp1 = vext_u8(vrp.val[1], vrp.val[1], 1);
-
-      vtmp = vld1q_u8(rp + 12);
-      vrpt = png_ptr(uint8x8x2_t,&vtmp);
-      vrp = *vrpt;
-
-      vdest.val[2] = vhadd_u8(vdest.val[1], vtmp2);
-      vdest.val[2] = vadd_u8(vdest.val[2], vtmp3);
-
-      vtmp2 = vext_u8(vpp.val[1], vpp.val[1], 1);
-
-      vdest.val[3] = vhadd_u8(vdest.val[2], vtmp2);
-      vdest.val[3] = vadd_u8(vdest.val[3], vtmp1);
-
-      vst1_lane_u32(png_ptr(uint32_t,rp), png_ldr(uint32x2_t,&vdest.val[0]), 0);
-      rp += 3;
-      vst1_lane_u32(png_ptr(uint32_t,rp), png_ldr(uint32x2_t,&vdest.val[1]), 0);
-      rp += 3;
-      vst1_lane_u32(png_ptr(uint32_t,rp), png_ldr(uint32x2_t,&vdest.val[2]), 0);
-      rp += 3;
-      vst1_lane_u32(png_ptr(uint32_t,rp), png_ldr(uint32x2_t,&vdest.val[3]), 0);
-      rp += 3;
-   }
-}
-
-void
-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 + row_info->rowbytes;
-   png_const_bytep pp = prev_row;
-
-   uint8x8x4_t vdest;
-   vdest.val[3] = vdup_n_u8(0);
-
-   png_debug(1, "in png_read_filter_row_avg4_neon");
-
-   for (; rp < rp_stop; rp += 16, pp += 16)
-   {
-      uint32x2x4_t vtmp;
-      uint8x8x4_t *vrpt, *vppt;
-      uint8x8x4_t vrp, vpp;
-      uint32x2x4_t *temp_pointer;
-
-      vtmp = vld4_u32(png_ptr(uint32_t,rp));
-      vrpt = png_ptr(uint8x8x4_t,&vtmp);
-      vrp = *vrpt;
-      vtmp = vld4_u32(png_ptrc(uint32_t,pp));
-      vppt = png_ptr(uint8x8x4_t,&vtmp);
-      vpp = *vppt;
-
-      vdest.val[0] = vhadd_u8(vdest.val[3], vpp.val[0]);
-      vdest.val[0] = vadd_u8(vdest.val[0], vrp.val[0]);
-      vdest.val[1] = vhadd_u8(vdest.val[0], vpp.val[1]);
-      vdest.val[1] = vadd_u8(vdest.val[1], vrp.val[1]);
-      vdest.val[2] = vhadd_u8(vdest.val[1], vpp.val[2]);
-      vdest.val[2] = vadd_u8(vdest.val[2], vrp.val[2]);
-      vdest.val[3] = vhadd_u8(vdest.val[2], vpp.val[3]);
-      vdest.val[3] = vadd_u8(vdest.val[3], vrp.val[3]);
-
-      vst4_lane_u32(png_ptr(uint32_t,rp), png_ldr(uint32x2x4_t,&vdest), 0);
-   }
-}
-
-static uint8x8_t
-paeth(uint8x8_t a, uint8x8_t b, uint8x8_t c)
-{
-   uint8x8_t d, e;
-   uint16x8_t p1, pa, pb, pc;
-
-   p1 = vaddl_u8(a, b); /* a + b */
-   pc = vaddl_u8(c, c); /* c * 2 */
-   pa = vabdl_u8(b, c); /* pa */
-   pb = vabdl_u8(a, c); /* pb */
-   pc = vabdq_u16(p1, pc); /* pc */
-
-   p1 = vcleq_u16(pa, pb); /* pa <= pb */
-   pa = vcleq_u16(pa, pc); /* pa <= pc */
-   pb = vcleq_u16(pb, pc); /* pb <= pc */
-
-   p1 = vandq_u16(p1, pa); /* pa <= pb && pa <= pc */
-
-   d = vmovn_u16(pb);
-   e = vmovn_u16(p1);
-
-   d = vbsl_u8(d, b, c);
-   e = vbsl_u8(e, a, d);
-
-   return e;
-}
-
-void
-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 + row_info->rowbytes;
-
-   uint8x16_t vtmp;
-   uint8x8x2_t *vrpt;
-   uint8x8x2_t vrp;
-   uint8x8_t vlast = vdup_n_u8(0);
-   uint8x8x4_t vdest;
-   vdest.val[3] = vdup_n_u8(0);
-
-   vtmp = vld1q_u8(rp);
-   vrpt = png_ptr(uint8x8x2_t,&vtmp);
-   vrp = *vrpt;
-
-   png_debug(1, "in png_read_filter_row_paeth3_neon");
-
-   for (; rp < rp_stop; pp += 12)
-   {
-      uint8x8x2_t *vppt;
-      uint8x8x2_t vpp;
-      uint8x8_t vtmp1, vtmp2, vtmp3;
-      uint32x2_t *temp_pointer;
-
-      vtmp = vld1q_u8(pp);
-      vppt = png_ptr(uint8x8x2_t,&vtmp);
-      vpp = *vppt;
-
-      vdest.val[0] = paeth(vdest.val[3], vpp.val[0], vlast);
-      vdest.val[0] = vadd_u8(vdest.val[0], vrp.val[0]);
-
-      vtmp1 = vext_u8(vrp.val[0], vrp.val[1], 3);
-      vtmp2 = vext_u8(vpp.val[0], vpp.val[1], 3);
-      vdest.val[1] = paeth(vdest.val[0], vtmp2, vpp.val[0]);
-      vdest.val[1] = vadd_u8(vdest.val[1], vtmp1);
-
-      vtmp1 = vext_u8(vrp.val[0], vrp.val[1], 6);
-      vtmp3 = vext_u8(vpp.val[0], vpp.val[1], 6);
-      vdest.val[2] = paeth(vdest.val[1], vtmp3, vtmp2);
-      vdest.val[2] = vadd_u8(vdest.val[2], vtmp1);
-
-      vtmp1 = vext_u8(vrp.val[1], vrp.val[1], 1);
-      vtmp2 = vext_u8(vpp.val[1], vpp.val[1], 1);
-
-      vtmp = vld1q_u8(rp + 12);
-      vrpt = png_ptr(uint8x8x2_t,&vtmp);
-      vrp = *vrpt;
-
-      vdest.val[3] = paeth(vdest.val[2], vtmp2, vtmp3);
-      vdest.val[3] = vadd_u8(vdest.val[3], vtmp1);
-
-      vlast = vtmp2;
-
-      vst1_lane_u32(png_ptr(uint32_t,rp), png_ldr(uint32x2_t,&vdest.val[0]), 0);
-      rp += 3;
-      vst1_lane_u32(png_ptr(uint32_t,rp), png_ldr(uint32x2_t,&vdest.val[1]), 0);
-      rp += 3;
-      vst1_lane_u32(png_ptr(uint32_t,rp), png_ldr(uint32x2_t,&vdest.val[2]), 0);
-      rp += 3;
-      vst1_lane_u32(png_ptr(uint32_t,rp), png_ldr(uint32x2_t,&vdest.val[3]), 0);
-      rp += 3;
-   }
-}
-
-void
-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 + row_info->rowbytes;
-   png_const_bytep pp = prev_row;
-
-   uint8x8_t vlast = vdup_n_u8(0);
-   uint8x8x4_t vdest;
-   vdest.val[3] = vdup_n_u8(0);
-
-   png_debug(1, "in png_read_filter_row_paeth4_neon");
-
-   for (; rp < rp_stop; rp += 16, pp += 16)
-   {
-      uint32x2x4_t vtmp;
-      uint8x8x4_t *vrpt, *vppt;
-      uint8x8x4_t vrp, vpp;
-      uint32x2x4_t *temp_pointer;
-
-      vtmp = vld4_u32(png_ptr(uint32_t,rp));
-      vrpt = png_ptr(uint8x8x4_t,&vtmp);
-      vrp = *vrpt;
-      vtmp = vld4_u32(png_ptrc(uint32_t,pp));
-      vppt = png_ptr(uint8x8x4_t,&vtmp);
-      vpp = *vppt;
-
-      vdest.val[0] = paeth(vdest.val[3], vpp.val[0], vlast);
-      vdest.val[0] = vadd_u8(vdest.val[0], vrp.val[0]);
-      vdest.val[1] = paeth(vdest.val[0], vpp.val[1], vpp.val[0]);
-      vdest.val[1] = vadd_u8(vdest.val[1], vrp.val[1]);
-      vdest.val[2] = paeth(vdest.val[1], vpp.val[2], vpp.val[1]);
-      vdest.val[2] = vadd_u8(vdest.val[2], vrp.val[2]);
-      vdest.val[3] = paeth(vdest.val[2], vpp.val[3], vpp.val[2]);
-      vdest.val[3] = vadd_u8(vdest.val[3], vrp.val[3]);
-
-      vlast = vpp.val[3];
-
-      vst4_lane_u32(png_ptr(uint32_t,rp), png_ldr(uint32x2x4_t,&vdest), 0);
-   }
-}
-
-#endif /* PNG_ARM_NEON_OPT > 0 */
-#endif /* PNG_ARM_NEON_IMPLEMENTATION == 1 (intrinsics) */
-#endif /* READ */

autogen.sh

@@ -9,15 +9,15 @@
 #
 # For regular ("tarball") distributions all the files should exist.  We do not
 # want them to be updated *under any circumstances*.  It should never be
-# necessary to run autogen.sh because ./configure --enable-maintainer-mode says
-# what to do if Makefile.am or configure.ac are changed.
+# necessary to rune autogen.sh because ./configure --enable-maintainer-mode says
+# what to do if Makeile.am or configure.ac are changed.
 #
 # It is *probably* OK to update the files on a GIT checkout, because they have
 # come from the local tools, but leave that to the user who is assumed to know
 # whether it is ok or required.
 #
 # This script is intended to work without arguments, there are, however, hidden
-# arguments (a) for use while testing the script and (b) to fix up systems that
+# arguments for (a) use while testing the script and (b) to fix up systems that
 # have been broken.  If (b) is required the script prompts for the correct
 # options.  For this reason the options are *NOT* documented in the help; this
 # is deliberate; UTSL.
@@ -73,13 +73,8 @@ 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"
-#
-# 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_files="Makefile.in aclocal.m4 config.guess config.h.in\
+   config.sub configure depcomp install-sh ltmain.sh missing test-driver"
 #
 # These are separate because 'maintainer-clean' does not remove them.
 libpng_libtool_files="scripts/libtool.m4 scripts/ltoptions.m4\
@@ -99,7 +94,6 @@ libpng_configure_dirs=".deps"
 # of Makefile.  These functions do the two bits of cleaning.
 clean_autotools(){
    rm -rf $libpng_autotools_files $libpng_libtool_files $libpng_autotools_dirs
-   rm -rf $libpng_autotools_extra
 }
 
 clean_configure(){
@@ -204,7 +198,7 @@ case "$mode" in
          echo "  You can run autoreconf yourself if you don't like maintainer"
          echo "  mode and you can also just run autoreconf -f -i to initialize"
          echo "  everything in the first place; this script is only for"
-         echo "  compatibility with prior releases."
+         echo "  compatiblity with prior releases."
          exit 1
       else
          exec >&2

configure.ac

@@ -1,12 +1,5 @@
 # configure.ac
 
-# Copyright (c) 2004-2016 Glenn Randers-Pehrson
-# Last changed in libpng 1.6.25 [October 20, 2016]
-
-# This code is released under the libpng license.
-# For conditions of distribution and use, see the disclaimer
-# and license in png.h
-
 dnl Process this file with autoconf to produce a configure script.
 dnl
 dnl Minor upgrades (compatible ABI): increment the package version
@@ -25,7 +18,7 @@ AC_PREREQ([2.68])
 
 dnl Version number stuff here:
 
-AC_INIT([libpng],[1.6.26],[png-mng-implement@lists.sourceforge.net])
+AC_INIT([libpng],[1.6.3],[png-mng-implement@lists.sourceforge.net])
 AC_CONFIG_MACRO_DIR([scripts])
 
 # libpng does not follow GNU file name conventions (hence 'foreign')
@@ -34,9 +27,9 @@ 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
-AM_INIT_AUTOMAKE([1.13 foreign dist-xz color-tests silent-rules subdir-objects])
+AM_INIT_AUTOMAKE([1.13 foreign dist-xz color-tests silent-rules])
 # The following line causes --disable-maintainer-mode to be the default to
-# configure. This is necessary because libpng distributions cannot rely on the
+# configure, this is necessary because libpng distributions cannot rely on the
 # time stamps of the autotools generated files being correct
 AM_MAINTAINER_MODE
 
@@ -46,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.6.26
+PNGLIB_VERSION=1.6.3
 PNGLIB_MAJOR=1
 PNGLIB_MINOR=6
-PNGLIB_RELEASE=26
+PNGLIB_RELEASE=3
 
 dnl End of version number stuff
 
@@ -67,7 +60,7 @@ AC_PROG_INSTALL
 AC_PROG_LN_S
 AC_PROG_MAKE_SET
 
-dnl libtool/libtoolize; version 2.4.2 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.2])
@@ -114,25 +107,6 @@ AC_ARG_ENABLE(werror,
       CFLAGS="$sav_CFLAGS"
     fi],)
 
-# For GCC 5 the default mode for C is -std=gnu11 instead of -std=gnu89
-# In pngpriv.h we request just the POSIX 1003.1 and C89 APIs by defining _POSIX_SOURCE to 1
-# This is incompatible with the new default mode, so we test for that and force the 
-# "-std=c89" compiler option:
-AC_MSG_CHECKING([if we need to force back C standard to C89])
-AC_COMPILE_IFELSE(
-   [AC_LANG_PROGRAM([
-      [#define _POSIX_SOURCE 1]
-      [#include <stdio.h>]
-   ])],
-   AC_MSG_RESULT(no),[
-      if test "x$GCC" != "xyes"; then
-         AC_MSG_ERROR(
-            [Forcing back to C89 is required but the flags are only known for GCC])
-      fi
-   AC_MSG_RESULT(yes)
-   CFLAGS="$CFLAGS -std=c89"
-])
-
 # Checks for header files.
 AC_HEADER_STDC
 
@@ -146,12 +120,6 @@ AC_C_RESTRICT
 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)) )
-
-# Some later POSIX 1003.1 functions are required for test programs, failure here
-# is soft (the corresponding test program is not built).
-AC_CHECK_FUNC([clock_gettime],,[AC_MSG_WARN([not building timepng])])
-AM_CONDITIONAL([HAVE_CLOCK_GETTIME], [test "$ac_cv_func_clock_gettime" = "yes"])
-
 AC_ARG_WITH(zlib-prefix,
    AS_HELP_STRING([[[--with-zlib-prefix]]],
       [prefix that may have been used in installed zlib]),
@@ -258,45 +226,6 @@ AC_ARG_WITH(libpng-prefix,
     fi])
 AM_CONDITIONAL([DO_PNG_PREFIX], [test "${with_libpng_prefix:-no}" != "no"])
 
-# Control over what links are made for installed files.  Versioned files are
-# always installed, when the following options are turned on corresponding
-# unversioned links are also created (normally as symbolic links):
-AC_ARG_ENABLE([unversioned-links],
-   AS_HELP_STRING([[[--enable-unversioned-links]]],
-      [Installed libpng header files are placed in a versioned subdirectory]
-      [and installed libpng library (including DLL) files are versioned.]
-      [If this option is enabled unversioned links will be created pointing to]
-      [the corresponding installed files.  If you use libpng.pc or]
-      [libpng-config for all builds you do not need these links, but if you]
-      [compile programs directly they will typically #include <png.h> and]
-      [link with -lpng; in that case you need the links.]
-      [The links can be installed manually using 'make install-header-links']
-      [and 'make install-library-links' and can be removed using the]
-      [corresponding uninstall- targets.  If you do enable this option every]
-      [libpng 'make install' will recreate the links to point to the just]
-      [installed version of libpng.  The default is to create the links;]
-      [use --disable-unversioned-links to change this]))
-
-# The AM_CONDITIONAL test is written so that the default is enabled;
-# --disable-unversioned-links must be given to turn the option off.
-AM_CONDITIONAL([DO_INSTALL_LINKS],[test "$enable_unversioned_links" != "no"])
-
-AC_ARG_ENABLE([unversioned-libpng-pc],
-   AS_HELP_STRING([[[--enable-unversioned-libpng-pc]]],
-      [Install the configuration file 'libpng.pc' as a link to the versioned]
-      [version.  This is done by default - use --disable-unversioned-libpng-pc]
-      [to change this.]))
-AM_CONDITIONAL([DO_INSTALL_LIBPNG_PC],
-   [test "$enable_unversioned_libpng_pc" != "no"])
-
-AC_ARG_ENABLE([unversioned-libpng-config],
-   AS_HELP_STRING([[[--enable-unversioned-libpng-config]]],
-      [Install the configuration file 'libpng-config' as a link to the]
-      [versioned version.  This is done by default - use]
-      [--disable-unversioned-libpng-config to change this.]))
-AM_CONDITIONAL([DO_INSTALL_LIBPNG_CONFIG],
-   [test "$enable_unversioned_libpng_config" != "no"])
-
 # HOST SPECIFIC OPTIONS
 # =====================
 #
@@ -342,55 +271,10 @@ AC_ARG_ENABLE([arm-neon],
 AM_CONDITIONAL([PNG_ARM_NEON],
    [test "$enable_arm_neon" != 'no' &&
     case "$host_cpu" in
-      arm*|aarch64*) :;;
+      arm*) :;;
       *)    test "$enable_arm_neon" != '';;
     esac])
 
-# MIPS
-# ===
-#
-# MIPS MSA (SIMD) support.
-
-AC_ARG_ENABLE([mips-msa],
-   AS_HELP_STRING([[[--enable-mips-msa]]],
-      [Enable MIPS MSA 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 __mips_msa systems:
-         AC_DEFINE([PNG_MIPS_MSA_OPT], [0],
-                   [Disable MIPS MSA optimizations])
-         # Prevent inclusion of the assembler files below:
-         enable_mips_msa=no;;
-      check)
-         AC_DEFINE([PNG_MIPS_MSA_CHECK_SUPPORTED], [],
-                   [Check for MIPS MSA support at run-time]);;
-      api)
-         AC_DEFINE([PNG_MIPS_MSA_API_SUPPORTED], [],
-                   [Turn on MIPS MSA optimizations at run-time]);;
-      yes|on)
-         AC_DEFINE([PNG_MIPS_MSA_OPT], [2],
-                   [Enable MIPS MSA optimizations])
-         AC_MSG_WARN([--enable-mips-msa: please specify 'check' or 'api', if]
-            [you want the optimizations unconditionally pass '-mmsa -mfp64']
-            [to the compiler.]);;
-      *)
-         AC_MSG_ERROR([--enable-mips-msa=${enable_mips_msa}: invalid value])
-   esac])
-
-# Add MIPS specific files to all builds where the host_cpu is mips ('mips*') or
-# where MIPS optimizations were explicitly requested (this allows a fallback if a
-# future host CPU does not match 'mips*')
-
-AM_CONDITIONAL([PNG_MIPS_MSA],
-   [test "$enable_mips_msa" != 'no' &&
-    case "$host_cpu" in
-      mipsel*|mips64el*) :;;
-    esac])
-
 AC_MSG_NOTICE([[Extra options for compiler: $PNG_COPTS]])
 
 # Config files, substituting as above

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,83 +0,0 @@
-OPERATING SYSTEM SPECIFIC ARM NEON DETECTION
---------------------------------------------
-
-Detection of the ability to execute ARM NEON on an ARM processor requires
-operating system support.  (The information is not available in user mode.)
-
-HOW TO USE THIS
----------------
-
-This directory contains C code fragments that can be included in arm/arm_init.c
-by setting the macro PNG_ARM_NEON_FILE to the file name in "" or <> at build
-time.  This setting is not recorded in pnglibconf.h and can be changed simply by
-rebuilding arm/arm_init.o with the required macro definition.
-
-For any of this code to be used the ARM NEON code must be enabled and run time
-checks must be supported.  I.e.:
-
-#if PNG_ARM_NEON_OPT > 0
-#ifdef PNG_ARM_NEON_CHECK_SUPPORTED
-
-This is done in a 'configure' build by passing configure the argument:
-
-   --enable-arm-neon=check
-
-Apart from the basic Linux implementation in contrib/arm-neon/linux.c this code
-is unsupported.  That means that it is not even compiled on a regular basis and
-may be broken in any given minor release.
-
-FILE FORMAT
------------
-
-Each file documents its testing status as of the last time it was tested (which
-may have been a long time ago):
-
-STATUS: one of:
-   SUPPORTED: This indicates that the file is included in the regularly
-         performed test builds and bugs are fixed when discovered.
-   COMPILED: This indicates that the code did compile at least once.  See the
-         more detailed description for the extent to which the result was
-         successful.
-   TESTED: This means the code was fully compiled into the libpng test programs
-         and these were run at least once.
-
-BUG REPORTS: an email address to which to send reports of problems
-
-The file is a fragment of C code. It should not define any 'extern' symbols;
-everything should be static.  It must define the function:
-
-static int png_have_neon(png_structp png_ptr);
-
-That function must return 1 if ARM NEON instructions are supported, 0 if not.
-It must not execute png_error unless it detects a bug.  A png_error will prevent
-the reading of the PNG and in the future, writing too.
-
-BUG REPORTS
------------
-
-If you mail a bug report for any file that is not SUPPORTED there may only be
-limited response.  Consider fixing it and sending a patch to fix the problem -
-this is more likely to result in action.
-
-CONTRIBUTIONS
--------------
-
-You may send contributions of new implementations to
-png-mng-implement@sourceforge.net.  Please write code in strict C90 C where
-possible.  Obviously OS dependencies are to be expected.  If you submit code you
-must have the authors permission and it must have a license that is acceptable
-to the current maintainer; in particular that license must permit modification
-and redistribution.
-
-Please try to make the contribution a single file and give the file a clear and
-unambiguous name that identifies the target OS.  If multiple files really are
-required put them all in a sub-directory.
-
-You must also be prepared to handle bug reports from users of the code, either
-by joining the png-mng-implement mailing list or by providing an email for the
-"BUG REPORTS" entry or both.  Please make sure that the header of the file
-contains the STATUS and BUG REPORTS fields as above.
-
-Please list the OS requirements as precisely as possible.  Ideally you should
-also list the environment in which the code has been tested and certainly list
-any environments where you suspect it might not work.

contrib/arm-neon/android-ndk.c

@@ -1,39 +0,0 @@
-/* contrib/arm-neon/android-ndk.c
- *
- * Copyright (c) 2014 Glenn Randers-Pehrson
- * Written by John Bowler, 2014.
- * 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
- * and license in png.h
- *
- * SEE contrib/arm-neon/README before reporting bugs
- *
- * STATUS: COMPILED, UNTESTED
- * BUG REPORTS: png-mng-implement@sourceforge.net
- *
- * png_have_neon implemented for the Android NDK, see:
- *
- * Documentation:
- *    http://www.kandroid.org/ndk/docs/CPU-ARM-NEON.html
- *    http://code.google.com/p/android/issues/detail?id=49065
- *
- * NOTE: this requires that libpng is built against the Android NDK and linked
- * with an implementation of the Android ARM 'cpu-features' library.  The code
- * has been compiled only, not linked: no version of the library has been found,
- * only the header files exist in the NDK.
- */
-#include <cpu-features.h>
-
-static int
-png_have_neon(png_structp png_ptr)
-{
-   /* This is a whole lot easier than the linux code, however it is probably
-    * implemented as below, therefore it is better to cache the result (these
-    * function calls may be slow!)
-    */
-   PNG_UNUSED(png_ptr)
-   return android_getCpuFamily() == ANDROID_CPU_FAMILY_ARM &&
-      (android_getCpuFeatures() & ANDROID_CPU_ARM_FEATURE_NEON) != 0;
-}

contrib/arm-neon/linux-auxv.c

@@ -1,120 +0,0 @@
-/* contrib/arm-neon/linux-auxv.c
- *
- * Copyright (c) 2014 Glenn Randers-Pehrson
- * Written by Mans Rullgard, 2011.
- * 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
- * and license in png.h
- *
- * SEE contrib/arm-neon/README before reporting bugs
- *
- * STATUS: COMPILED, TESTED
- * BUG REPORTS: png-mng-implement@sourceforge.net
- *
- * png_have_neon implemented for Linux versions which allow access to
- * /proc/self/auxv.  This is probably faster, cleaner and safer than the code to
- * read /proc/cpuinfo in contrib/arm-neon/linux, however it is yet another piece
- * of potentially untested code and has more complex dependencies than the code
- * to read cpuinfo.
- *
- * This generic __linux__ implementation requires reading /proc/self/auxv and
- * looking at each element for one that records NEON capabilities.
- */
-#include <unistd.h> /* for POSIX 1003.1 */
-#include <errno.h>  /* for EINTR */
-
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <fcntl.h>
-#include <elf.h>
-#include <asm/hwcap.h>
-
-/* A read call may be interrupted, in which case it returns -1 and sets errno to
- * EINTR if nothing was done, otherwise (if something was done) a partial read
- * may result.
- */
-static size_t
-safe_read(png_structp png_ptr, int fd, void *buffer_in, size_t nbytes)
-{
-   size_t ntotal = 0;
-   char *buffer = png_voidcast(char*, buffer_in);
-
-   while (nbytes > 0)
-   {
-      unsigned int nread;
-      int iread;
-
-      /* Passing nread > INT_MAX to read is implementation defined in POSIX
-       * 1003.1, therefore despite the unsigned argument portable code must
-       * limit the value to INT_MAX!
-       */
-      if (nbytes > INT_MAX)
-         nread = INT_MAX;
-
-      else
-         nread = (unsigned int)/*SAFE*/nbytes;
-
-      iread = read(fd, buffer, nread);
-
-      if (iread == -1)
-      {
-         /* This is the devil in the details, a read can terminate early with 0
-          * bytes read because of EINTR, yet it still returns -1 otherwise end
-          * of file cannot be distinguished.
-          */
-         if (errno != EINTR)
-         {
-            png_warning(png_ptr, "/proc read failed");
-            return 0; /* I.e., a permanent failure */
-         }
-      }
-
-      else if (iread < 0)
-      {
-         /* Not a valid 'read' result: */
-         png_warning(png_ptr, "OS /proc read bug");
-         return 0;
-      }
-
-      else if (iread > 0)
-      {
-         /* Continue reading until a permanent failure, or EOF */
-         buffer += iread;
-         nbytes -= (unsigned int)/*SAFE*/iread;
-         ntotal += (unsigned int)/*SAFE*/iread;
-      }
-
-      else
-         return ntotal;
-   }
-
-   return ntotal; /* nbytes == 0 */
-}
-
-static int
-png_have_neon(png_structp png_ptr)
-{
-   int fd = open("/proc/self/auxv", O_RDONLY);
-   Elf32_auxv_t aux;
-
-   /* Failsafe: failure to open means no NEON */
-   if (fd == -1)
-   {
-      png_warning(png_ptr, "/proc/self/auxv open failed");
-      return 0;
-   }
-
-   while (safe_read(png_ptr, fd, &aux, sizeof aux) == sizeof aux)
-   {
-      if (aux.a_type == AT_HWCAP && (aux.a_un.a_val & HWCAP_NEON) != 0)
-      {
-         close(fd);
-         return 1;
-      }
-   }
-
-   close(fd);
-   return 0;
-}

contrib/arm-neon/linux.c

@@ -1,161 +0,0 @@
-/* contrib/arm-neon/linux.c
- *
- * Copyright (c) 2014 Glenn Randers-Pehrson
- * Written by John Bowler, 2014.
- * Last changed in libpng 1.6.16 [December 22, 2014]
- *
- * 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: SUPPORTED
- * BUG REPORTS: png-mng-implement@sourceforge.net
- *
- * png_have_neon implemented for Linux by reading the widely available
- * pseudo-file /proc/cpuinfo.
- *
- * This code is strict ANSI-C and is probably moderately portable; it does
- * however use <stdio.h> and it assumes that /proc/cpuinfo is never localized.
- */
-#include <stdio.h>
-
-static int
-png_have_neon(png_structp png_ptr)
-{
-   FILE *f = fopen("/proc/cpuinfo", "rb");
-
-   if (f != NULL)
-   {
-      /* This is a simple state machine which reads the input byte-by-byte until
-       * it gets a match on the 'neon' feature or reaches the end of the stream.
-       */
-      static const char ch_feature[] = { 70, 69, 65, 84, 85, 82, 69, 83 };
-      static const char ch_neon[] = { 78, 69, 79, 78 };
-
-      enum
-      {
-         StartLine, Feature, Colon, StartTag, Neon, HaveNeon, SkipTag, SkipLine
-      }  state;
-      int counter;
-
-      for (state=StartLine, counter=0;;)
-      {
-         int ch = fgetc(f);
-
-         if (ch == EOF)
-         {
-            /* EOF means error or end-of-file, return false; neon at EOF is
-             * assumed to be a mistake.
-             */
-            fclose(f);
-            return 0;
-         }
-
-         switch (state)
-         {
-            case StartLine:
-               /* Match spaces at the start of line */
-               if (ch <= 32) /* skip control characters and space */
-                  break;
-
-               counter=0;
-               state = Feature;
-               /* FALL THROUGH */
-
-            case Feature:
-               /* Match 'FEATURE', ASCII case insensitive. */
-               if ((ch & ~0x20) == ch_feature[counter])
-               {
-                  if (++counter == (sizeof ch_feature))
-                     state = Colon;
-                  break;
-               }
-
-               /* did not match 'feature' */
-               state = SkipLine;
-               /* FALL THROUGH */
-
-            case SkipLine:
-            skipLine:
-               /* Skip everything until we see linefeed or carriage return */
-               if (ch != 10 && ch != 13)
-                  break;
-
-               state = StartLine;
-               break;
-
-            case Colon:
-               /* Match any number of space or tab followed by ':' */
-               if (ch == 32 || ch == 9)
-                  break;
-
-               if (ch == 58) /* i.e. ':' */
-               {
-                  state = StartTag;
-                  break;
-               }
-
-               /* Either a bad line format or a 'feature' prefix followed by
-                * other characters.
-                */
-               state = SkipLine;
-               goto skipLine;
-
-            case StartTag:
-               /* Skip space characters before a tag */
-               if (ch == 32 || ch == 9)
-                  break;
-
-               state = Neon;
-               counter = 0;
-               /* FALL THROUGH */
-
-            case Neon:
-               /* Look for 'neon' tag */
-               if ((ch & ~0x20) == ch_neon[counter])
-               {
-                  if (++counter == (sizeof ch_neon))
-                     state = HaveNeon;
-                  break;
-               }
-
-               state = SkipTag;
-               /* FALL THROUGH */
-
-            case SkipTag:
-               /* Skip non-space characters */
-               if (ch == 10 || ch == 13)
-                  state = StartLine;
-
-               else if (ch == 32 || ch == 9)
-                  state = StartTag;
-               break;
-
-            case HaveNeon:
-               /* Have seen a 'neon' prefix, but there must be a space or new
-                * line character to terminate it.
-                */
-               if (ch == 10 || ch == 13 || ch == 32 || ch == 9)
-               {
-                  fclose(f);
-                  return 1;
-               }
-
-               state = SkipTag;
-               break;
-
-            default:
-               png_error(png_ptr, "png_have_neon: internal error (bug)");
-         }
-      }
-   }
-
-#ifdef PNG_WARNINGS_SUPPORTED
-   else
-      png_warning(png_ptr, "/proc/cpuinfo open failed");
-#endif
-
-   return 0;
-}

contrib/conftest/README

@@ -1,49 +0,0 @@
-This directory contains test configuration files, currently always '.dfa' files
-intended to be used in the build by setting the make macro DFA_XTRA to the name
-of the file.
-
-These files are used in release validation of the 'configure' builds of libpng
-by building 'make check', or 'make all-am' for cross-builds, with each .dfa
-file.
-
-The files in this directory may change between minor releases, however
-contributions describing specific builds of libpng are welcomed.  There is no
-guarantee that libpng will continue to build with such configurations; support
-for given configurations can be, and has been, dropped between successive minor
-releases.  However if a .dfa file describing a configuration is not in this
-directory it is very unlikely that it will be tested before a minor release!
-
-You can use these .dfa files as the basis of new configurations.  Files in this
-directory should not have any use restrictions or restrictive licenses.
-
-This directory is not included in the .zip and .7z distributions, which do
-not contain 'configure' scripts.
-
-DOCUMENTATION
-=============
-
-Examples:
-   ${srcdir}/pngusr.dfa
-   ${srcdir}/contrib/pngminim/*/pngusr.dfa
-
-Documentation of the options:
-   ${srcdir}/scripts/pnglibconf.dfa
-
-Documentation of the file format:
-   ${srcdir}/scripts/options.awk
-
-FILE NAMING
-===========
-
-File names in this directory may NOT contain any of the five characters:
-
-   - , + * ?
-
-Neither may they contain any space character.
-
-While other characters may be used it is strongly suggested that file names be
-limited to lower case Latiin alphabetic characters (a-z), digits (0-9) and, if
-necessary the underscore (_) character.  File names should be about 8 characters
-long (excluding the .dfa extension).  Submitted .dfa files should have names
-between 7 and 16 characters long, shorter names (6 characters or less) are
-reserved for standard tests.

contrib/conftest/pngcp.dfa

@@ -1,57 +0,0 @@
-# pngcp.dfa
-#  Build time configuration of libpng
-#
-# Author: John Bowler
-# Copyright: (c) John Bowler, 2016
-# Usage rights:
-#  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.
-#
-# Build libpng with support for pngcp.  This means just png_read_png,
-# png_write_png and small number of configuration settings.
-#
-everything = off
-
-# This option is specific to this configuration; it adds a #define to the
-# generated pnglibconf.h which turns on the (not portable) timing option for
-# pngcp.  Note that any option is automatically preceded by PNG_; there is no
-# way round this and this is deliberate.
-option PNGCP_TIMING
-
-# Because of the everything off above the option must also be turned on.  This
-# may not be done in one step because it is safer and avoids mis-spelled options
-# in user .dfa files to error out if an unrecognized option is turned on.
-option PNGCP_TIMING on
-
-# Options to turn on png_read_png and png_write_png:
-option INFO_IMAGE on
-option SEQUENTIAL_READ on
-option EASY_ACCESS on
-option WRITE on
-option WRITE_16BIT on
-option WRITE_FILTER on
-
-# pngcp needs this to preserve unknown chunks, switching all these on means that
-# pngcp can work without explicit known chunk reading suppport
-option UNKNOWN_CHUNKS on
-option SET_UNKNOWN_CHUNKS on
-option HANDLE_AS_UNKNOWN on
-option SAVE_UNKNOWN_CHUNKS on
-option WRITE_UNKNOWN_CHUNKS on
-
-# pngcp needs this to handle palette files with invalid indices:
-option CHECK_FOR_INVALID_INDEX on
-option GET_PALETTE_MAX on
-
-# Pre-libpng 1.7 pngcp has to stash text chunks manually, post 1.7 without this
-# text chunks should be handled as unknown ok.
-option TEXT on
-
-# this is used to turn off limits:
-option USER_LIMITS on
-option SET_USER_LIMITS on
-
-# these are are just required for specific customizations
-option WRITE_CUSTOMIZE_ZTXT_COMPRESSION on
-option WRITE_CUSTOMIZE_COMPRESSION on

contrib/conftest/read.dfa

@@ -1,58 +0,0 @@
-# read.dfa
-#  Build time configuration of libpng
-#
-# Author: John Bowler
-# Copyright: (c) John Bowler, 2013
-# Usage rights:
-#  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.
-#
-# Build libpng with basic read support.  This enables the lowest level libpng
-# read API - the one where the calling code has to use a loop to read each row.
-# At present this is the API used by most programs.
-#
-# Support is enabled only for those chunks and transformations that are
-# typically required - others can be added easily.
-#
-
-everything = off
-
-# The sequential read code is enabled here; the progressive code can be used
-# instead but there is no point enabling both.
-
-option SEQUENTIAL_READ on
-
-# Likewise it is pointless enabling both fixed and floating point APIs.  Choose
-# one or the other for both the API and the internal math.
-
-#Fixed point:
-#option FIXED_POINT on
-#option FLOATING_ARITHMETIC off
-
-#Floating point:
-option FLOATING_POINT on
-option FLOATING_ARITHMETIC on
-
-# Basic error handling, IO and user memory support.  The latter allows the
-# application program to provide its own implementations of 'malloc' and 'free'.
-option SETJMP on
-option STDIO on
-option USER_MEM on
-
-# To read the full set of PNG images correctly interlace, transparency and
-# 16-bit support is required.  The application can implement interlace itself,
-# but very few do and it's no longer possible to disable it when READ is
-# enabled.
-option READ_tRNS on
-option READ_16BIT on
-
-# Everything else is application dependent.  This file assumes the app handles
-# all the native PNG bit layouts, so it doesn't need any of layout change
-# transforms, but needs libpng to perform gamma correction.  It doesn't do any
-# colorspace stuff and ignores the 'significant bit' information.
-#
-# If your app always expands the image to a limited set of bit layouts you
-# probably want to consider using the simplified API instead of the low level
-# one - see png.h and s_read.dfa.
-option READ_GAMMA on

contrib/conftest/s_read.dfa

@@ -1,35 +0,0 @@
-# s_read.dfa
-#  Build time configuration of libpng
-#
-# Author: John Bowler
-# Copyright: (c) John Bowler, 2013
-# Usage rights:
-#  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.
-#
-# Build libpng with simplified read support (only).  This builds a minimal
-# libpng able to read all PNG formats and convert them into a small number of
-# well understood memory formats.
-#
-
-everything = off
-
-option SIMPLIFIED_READ on
-
-# It isn't necessary to chose fixed or floating point for the APIs because the
-# simplified API doesn't need fixed or floating point numbers.  It is necessary
-# to chose an internal math implementation.  The default (because of 'everything
-# = off') is fixed point - turn the floating point implementation on if you have
-# hardware floating point or prefer your software floating point implementation.
-option FLOATING_ARITHMETIC on
-
-# This is not strictly necessary, but without it the message strings in the API
-# will not be filled in
-option ERROR_TEXT on
-
-# Switching these options on enables the 'AFIRST' and 'BGR' formats - you don't
-# need this if you don't use them, they just allow the in-memory layout to be
-# changed to match common hardware formats.
-option SIMPLIFIED_READ_AFIRST on
-option SIMPLIFIED_READ_BGR on

contrib/conftest/s_write.dfa

@@ -1,33 +0,0 @@
-# s_write.dfa
-#  Build time configuration of libpng
-#
-# Author: John Bowler
-# Copyright: (c) John Bowler, 2013
-# Usage rights:
-#  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.
-#
-# Build libpng with (just) simplified write support
-#
-
-everything = off
-
-option SIMPLIFIED_WRITE on
-
-# It isn't necessary to chose fixed or floating point for the APIs because the
-# simplified API doesn't need fixed or floating point numbers.  It is necessary
-# to chose an internal math implementation.  The default (because of 'everything
-# = off') is fixed point - turn the floating point implementation on if you have
-# hardware floating point or prefer your software floating point implementation.
-option FLOATING_ARITHMETIC on
-
-# This is not strictly necessary, but without it the message strings in the API
-# will not be filled in
-option ERROR_TEXT on
-
-# Switching these options on enables the 'AFIRST' and 'BGR' formats - you don't
-# need this if you don't use them, they just allow the in-memory layout to be
-# changed to match common hardware formats.
-option SIMPLIFIED_WRITE_AFIRST on
-option SIMPLIFIED_WRITE_BGR on

contrib/conftest/simple.dfa

@@ -1,36 +0,0 @@
-# simple.dfa
-#  Build time configuration of libpng
-#
-# Author: John Bowler
-# Copyright: (c) John Bowler, 2013
-# Usage rights:
-#  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.
-#
-# Build libpng with just the simplified APIs (read and write).
-#
-
-everything = off
-
-option SIMPLIFIED_WRITE on
-option SIMPLIFIED_READ on
-
-# It isn't necessary to chose fixed or floating point for the APIs because the
-# simplified API doesn't need fixed or floating point numbers.  It is necessary
-# to chose an internal math implementation.  The default (because of 'everything
-# = off') is fixed point - turn the floating point implementation on if you have
-# hardware floating point or prefer your software floating point implementation.
-option FLOATING_ARITHMETIC on
-
-# This is not strictly necessary, but without it the message strings in the API
-# will not be filled in
-option ERROR_TEXT on
-
-# Switching these options on enables the 'AFIRST' and 'BGR' formats - you don't
-# need this if you don't use them, they just allow the in-memory layout to be
-# changed to match common hardware formats.
-option SIMPLIFIED_READ_AFIRST on
-option SIMPLIFIED_READ_BGR on
-option SIMPLIFIED_WRITE_AFIRST on
-option SIMPLIFIED_WRITE_BGR on

contrib/conftest/write.dfa

@@ -1,45 +0,0 @@
-# write.dfa
-#  Build time configuration of libpng
-#
-# Author: John Bowler
-# Copyright: (c) John Bowler, 2013
-# Usage rights:
-#  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.
-#
-# Build libpng with no read support and minimal write support.
-#
-
-everything = off
-
-# Switch on the write code - this makes a minimalist encoder
-
-option WRITE on
-
-# Choose fixed or floating point APIs and arithmetic.  The choices are
-# independent but normally they will match.  It is typically better to use the
-# floating point if you have floating point hardware.  If you don't know, or
-# (perhaps) to make libpng smaller used fixed point throughout.
-
-#Fixed point:
-#option FIXED_POINT on
-#option FLOATING_ARITHMETIC off
-
-#Floating point:
-option FLOATING_POINT on
-option FLOATING_ARITHMETIC on
-
-# Basic error handling, IO and user memory support.  The latter allows the
-# application program to provide its own implementations of 'malloc' and 'free'.
-option SETJMP on
-option STDIO on
-option USER_MEM on
-
-# Everything else is optional.  Unlike the read code in libpng the write code
-# does not need to deal with arbitrary formats, so only add support for things
-# you really do write!  For example you might only write sRGB images, sometimes
-# with transparency and never write 16 bit images, so:
-option WRITE_sRGB on
-option WRITE_tRNS on
-#option WRITE_16BIT off (this is the default with 'everything = off')

contrib/examples/README.txt

@@ -21,4 +21,4 @@ ORIGINAL AUTHORS
     of the people below claim any rights with regard to the contents of this
     directory.
 
-    John Bowler <jbowler at acm.org>
+    John Bowler <jbowler@acm.org>

contrib/examples/iccfrompng.c

@@ -6,9 +6,9 @@
  * United States.
  *
  * Extract any icc profiles found in the given PNG files.  This is a simple
- * example of a program that extracts information from the header of a PNG file
+ * example of a program which extracts information from the header of a PNG file
  * without processing the image.  Notice that some header information may occur
- * after the image data. Textual data and comments are an example; the approach
+ * after the image data, textual data and comments are an example; the approach
  * in this file won't work reliably for such data because it only looks for the
  * information in the section of the file that preceeds the image data.
  *
@@ -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

@@ -8,7 +8,7 @@
  * Read a single pixel value from a PNG file.
  *
  * This code illustrates basic 'by-row' reading of a PNG file using libpng.
- * Rows are read until a particular pixel is found; the value of this pixel is
+ * Rows are read until a particular pixel is found, the value of this pixel is
  * then printed on stdout.
  *
  * The code illustrates how to do this on interlaced as well as non-interlaced
@@ -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,
@@ -58,7 +56,7 @@ component(png_const_bytep row, png_uint_32 x, unsigned int c,
       case 8: return row[0];
       case 16: return (row[0] << 8) + row[1];
       default:
-         /* This should never happen; it indicates a bug in this program or in
+         /* This should never happen, it indicates a bug in this program or in
           * libpng itself:
           */
          fprintf(stderr, "pngpixel: invalid bit depth %u\n", bit_depth);
@@ -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;
 
@@ -134,7 +132,7 @@ print_pixel(png_structp png_ptr, png_infop info_ptr, png_const_bytep row,
          return;
 
       default:
-         png_error(png_ptr, "pngpixel: invalid color type");
+         png_error(png_ptr, "invalid color type");
    }
 }
 
@@ -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/gregbook/Makefile.mingw32

@@ -47,8 +47,7 @@ CC = gcc
 #CC = i386-mingw32msvc-gcc #	e.g., Linux -> Win32 cross-compilation
 LD = $(CC)
 RM = rm -f
-CPPFLAGS = $(INCS)
-CFLAGS = -O -Wall $(MINGW_CCFLAGS)
+CFLAGS = -O -Wall $(INCS) $(MINGW_CCFLAGS)
 # [note that -Wall is a gcc-specific compilation flag ("most warnings on")]
 # [-ansi, -pedantic and -W can also be used]
 LDFLAGS = $(MINGW_LDFLAGS)
@@ -86,10 +85,10 @@ EXES = $(STATIC_EXES) $(DYNAMIC_EXES)
 # implicit make rules -------------------------------------------------------
 
 .c$(O):
-	$(CC) -c $(CPPFLAGS) $(CFLAGS) $<
+	$(CC) -c $(CFLAGS) $<
 
 %.pic$(O): %.c
-	$(CC) -c $(CPPFLAGS) $(CFLAGS) -DPNG_BUILD_DLL -o $@ $<
+	$(CC) -c $(CFLAGS) -DPNG_BUILD_DLL -o $@ $<
 
 
 # dependencies --------------------------------------------------------------

contrib/gregbook/Makefile.sgi

@@ -53,8 +53,7 @@ CC = cc
 LD = cc
 RM = rm -f
 # ABI must be the same as that used to build libpng.
-ABI =
-CPPFLAGS =
+ABI=
 CFLAGS = $(ABI) -O -fullwarn $(INCS)
 LDFLAGS = $(ABI)
 O = .o
@@ -74,7 +73,7 @@ EXES = $(RPNG)$(E) $(RPNG2)$(E) $(WPNG)$(E)
 # implicit make rules -------------------------------------------------------
 
 .c$(O):
-	$(CC) -c $(CPPFLAGS) $(CFLAGS) $<
+	$(CC) -c $(CFLAGS) $<
 
 
 # dependencies --------------------------------------------------------------

contrib/gregbook/Makefile.unx

@@ -59,16 +59,14 @@ INCS = $(PNGINC) $(ZINC) $(XINC)
 RLIBSd = $(PNGLIBd) $(ZLIBd) $(XLIB) -lm
 RLIBSs = $(PNGLIBs) $(ZLIBs) $(XLIB) -lm
 WLIBSd = $(PNGLIBd) $(ZLIBd) -lm
-WLIBSs = $(PNGLIBs) $(ZLIBs) -lm
+WLIBSs = $(PNGLIBs) $(ZLIBs)
 
 CC = gcc
 LD = gcc
 RM = rm -f
-CPPFLAGS = $(INCS) -DFEATURE_LOOP
-CFLAGS = -O -Wall
-#CFLAGS = -O -W -Wall -Wextra -pedantic -ansi
+CFLAGS = -O -Wall $(INCS) -DFEATURE_LOOP
 # [note that -Wall is a gcc-specific compilation flag ("most warnings on")]
-# [-ansi, -pedantic, -Wextra, and -W can also be used]
+# [-ansi, -pedantic and -W can also be used]
 LDFLAGS =
 O = .o
 E =
@@ -94,7 +92,7 @@ EXES = $(STATIC_EXES) $(DYNAMIC_EXES)
 # implicit make rules -------------------------------------------------------
 
 .c$(O):
-	$(CC) -c $(CPPFLAGS) $(CFLAGS) $<
+	$(CC) -c $(CFLAGS) $<
 
 
 # dependencies --------------------------------------------------------------

contrib/gregbook/Makefile.w32

@@ -53,8 +53,7 @@ WLIBS = $(PNGLIB) $(ZLIB)
 CC = cl
 LD = link
 RM = del
-CPPFLAGS = $(INCS)
-CFLAGS = -nologo -O -W3 $(cvars)
+CFLAGS = -nologo -O -W3 $(INCS) $(cvars)
 # [note that -W3 is an MSVC-specific compilation flag ("all warnings on")]
 # [see %devstudio%\vc\include\win32.mak for cvars macro definition]
 O = .obj
@@ -77,7 +76,7 @@ EXES = $(RPNG)$(E) $(RPNG2)$(E) $(WPNG)$(E)
 # implicit make rules -------------------------------------------------------
 
 .c$(O):
-	$(CC) -c $(CPPFLAGS) $(CFLAGS) $<
+	$(CC) -c $(CFLAGS) $<
 
 
 # dependencies --------------------------------------------------------------

contrib/gregbook/README

@@ -15,7 +15,7 @@ of PBMPLUS/NetPBM) and converts them to PNG.
 
 The source code for all three demo programs currently compiles under
 Unix, OpenVMS, and 32-bit Windows.  (Special thanks to Martin Zinser,
-zinser at decus.de, for making the necessary changes for OpenVMS and for
+zinser@decus.de, for making the necessary changes for OpenVMS and for
 providing an appropriate build script.)  Build instructions can be found
 below.
 

contrib/gregbook/readpng.c

@@ -100,8 +100,7 @@ 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_get_libpng_ver(NULL), NULL, NULL,
-        NULL);
+    png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, 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:
-     2015-11-12 - Check return value of png_get_bKGD() (Glenn R-P)
-
   ---------------------------------------------------------------------------*/
 
 
@@ -74,7 +69,6 @@ static void readpng2_row_callback(png_structp png_ptr, png_bytep new_row,
                                  png_uint_32 row_num, int pass);
 static void readpng2_end_callback(png_structp png_ptr, png_infop info_ptr);
 static void readpng2_error_handler(png_structp png_ptr, png_const_charp msg);
-static void readpng2_warning_handler(png_structp png_ptr, png_const_charp msg);
 
 
 
@@ -109,8 +103,8 @@ int readpng2_init(mainprog_info *mainprog_ptr)
 
     /* could also replace libpng warning-handler (final NULL), but no need: */
 
-    png_ptr = png_create_read_struct(png_get_libpng_ver(NULL), mainprog_ptr,
-      readpng2_error_handler, readpng2_warning_handler);
+    png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, mainprog_ptr,
+      readpng2_error_handler, NULL);
     if (!png_ptr)
         return 4;   /* out of memory */
 
@@ -266,38 +260,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;
         }
     }
 
@@ -455,8 +447,6 @@ static void readpng2_end_callback(png_structp png_ptr, png_infop info_ptr)
 
     /* all done */
 
-    (void)info_ptr; /* Unused */
-
     return;
 }
 
@@ -477,12 +467,7 @@ void readpng2_cleanup(mainprog_info *mainprog_ptr)
 }
 
 
-static void readpng2_warning_handler(png_structp png_ptr, png_const_charp msg)
-{
-    fprintf(stderr, "readpng2 libpng warning: %s\n", msg);
-    fflush(stderr);
-    (void)png_ptr; /* Unused */
-}
+
 
 
 static void readpng2_error_handler(png_structp png_ptr, png_const_charp msg)

contrib/gregbook/readppm.c

@@ -163,12 +163,8 @@ uch *readpng_get_image(double display_exponent, int *pChannels, ulg *pRowbytes)
 
     /* now we can go ahead and just read the whole image */
 
-    if (fread(image_data, 1L, rowbytes*height, saved_infile) <
-       rowbytes*height) {
-        free (image_data);
-        image_data = NULL;
-        return NULL;
-    }
+    fread(image_data, 1L, rowbytes*height, saved_infile);
+
 
     return image_data;
 }

contrib/gregbook/rpng-win.c

@@ -182,7 +182,7 @@ int WINAPI WinMain(HINSTANCE hInst, HINSTANCE hPrevInst, PSTR cmd, int showmode)
 #ifndef __CYGWIN__
     /* First reenable console output, which normally goes to the bit bucket
      * for windowed apps.  Closing the console window will terminate the
-     * app.  Thanks to David.Geldreich at realviz.com for supplying the magical
+     * app.  Thanks to David.Geldreich@realviz.com for supplying the magical
      * incantation. */
 
     AllocConsole();

contrib/gregbook/rpng-x.c

@@ -26,8 +26,6 @@
     - 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)
 
   ---------------------------------------------------------------------------
 
@@ -82,7 +80,7 @@
 
 #define PROGNAME  "rpng-x"
 #define LONGNAME  "Simple PNG Viewer for X"
-#define VERSION   "2.02 of 15 June 2014"
+#define VERSION   "2.01 of 16 March 2008"
 #define RESNAME   "rpng"        /* our X resource application name */
 #define RESCLASS  "Rpng"        /* our X resource class name */
 
@@ -281,17 +279,15 @@ 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",
-          PROGNAME, default_display_exponent);
-
-        fprintf(stderr, "\n"
+          "\t\t  system in floating-point format (e.g., ``%.1f''); equal\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");
+          "is displayed) to quit.\n"
+          "\n", PROGNAME, default_display_exponent);
         exit(1);
     }
 
@@ -423,8 +419,6 @@ int main(int argc, char **argv)
 
     rpng_x_cleanup();
 
-    (void)argc; /* Unused */
-
     return 0;
 }
 

contrib/gregbook/rpng2-win.c

@@ -33,8 +33,6 @@
     - 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)
 
   ---------------------------------------------------------------------------
 
@@ -301,7 +299,7 @@ int WINAPI WinMain(HINSTANCE hInst, HINSTANCE hPrevInst, PSTR cmd, int showmode)
 #ifndef __CYGWIN__
     /* Next reenable console output, which normally goes to the bit bucket
      * for windowed apps.  Closing the console window will terminate the
-     * app.  Thanks to David.Geldreich at realviz.com for supplying the magical
+     * app.  Thanks to David.Geldreich@realviz.com for supplying the magical
      * incantation. */
 
     AllocConsole();

contrib/gregbook/rpng2-x.c

@@ -41,12 +41,10 @@
               unexpected-EOF and file-read-error cases; fixed Trace() cut-and-
               paste bugs
     - 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).
+
   ---------------------------------------------------------------------------
 
-      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
@@ -97,7 +95,7 @@
 
 #define PROGNAME  "rpng2-x"
 #define LONGNAME  "Progressive PNG Viewer for X"
-#define VERSION   "2.04 of 15 June 2014"
+#define VERSION   "2.03 of 25 February 2010"
 #define RESNAME   "rpng2"       /* our X resource application name */
 #define RESCLASS  "Rpng"       /* our X resource class name */
 
@@ -113,19 +111,6 @@
 #include <X11/Xos.h>
 #include <X11/keysym.h>   /* defines XK_* macros */
 
-#if _POSIX_C_SOURCE >= 199309L /* have nanosleep() */
-# undef usleep
-# define usleep(usec) {        \
-   struct timespec ts;         \
-   ts.tv_sec = 0;              \
-   ts.tv_nsec = (usec) * 1000; \
-   nanosleep(&ts, NULL); }
-#  endif
-
-#ifndef usleep /* have neither nanosleep() nor usleep() */
-#  define usleep(x) sleep(((x)+499999)/1000000)
-#endif
-
 #ifdef VMS
 #  include <unistd.h>
 #endif
@@ -471,47 +456,40 @@ int main(int argc, char **argv)
         fprintf(stderr, "\n%s %s:  %s\n\n", PROGNAME, VERSION, appname);
         readpng2_version_info();
         fprintf(stderr, "\n"
-          "Usage:   ");
-        fprintf(stderr,
-          "%s [-display xdpy] [-gamma exp] [-bgcolor bg | -bgpat pat]\n"
-          "        %*s [-usleep dur | -timing] [-pause]\n",
-          PROGNAME, (int)strlen(PROGNAME), " ");
-        fprintf(stderr,
+          "Usage:  %s [-display xdpy] [-gamma exp] [-bgcolor bg | -bgpat pat]\n"
 #ifdef FEATURE_LOOP
-          "        [-loop [sec]]"
+          "        %*s [-usleep dur | -timing] [-pause] [-loop [sec]] file.png\n\n"
+#else
+          "        %*s [-usleep dur | -timing] [-pause] file.png\n\n"
 #endif
-          " file.png\n\n");
-        fprintf(stderr,
           "    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  to the product of the lookup-table exponent (varies)\n",
-          default_display_exponent);
-        fprintf(stderr,
+          "\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; overrides -bgpat\n"
           "    pat \tdesired background pattern number (0-%d); used with\n"
-          "\t\t  transparent images; overrides -bgcolor\n",
-          num_bgpat-1);
+          "\t\t  transparent images; overrides -bgcolor\n"
 #ifdef FEATURE_LOOP
-        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");
+          "    sec \tseconds to display each background image (default = 2)\n"
 #endif
-        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"
           "\t\t  download of image (~36 Kbps)\n"
           "    -pause\tpauses after displaying each pass until mouse clicked\n"
           "\nPress Q, Esc or mouse button 1 (within image window, after image\n"
-          "is displayed) to quit.\n");
+          "is displayed) to quit.\n"
+          "\n", PROGNAME,
+          (int)strlen(PROGNAME), " ", default_display_exponent, num_bgpat-1);
         exit(1);
     }
 
+
     if (!(infile = fopen(filename, "rb"))) {
         fprintf(stderr, PROGNAME ":  can't open PNG file [%s]\n", filename);
         ++error;
@@ -757,8 +735,6 @@ int main(int argc, char **argv)
     Trace((stderr, "about to call rpng2_x_cleanup()\n"))
     rpng2_x_cleanup();
 
-    (void)argc; /* Unused */
-
     return 0;
 }
 
@@ -1850,9 +1826,6 @@ static void rpng2_x_redisplay_image(ulg startcol, ulg startrow,
         XFlush(display);
     }
 
-    (void)startcol;
-    (void)width;
-
 } /* end function rpng2_x_redisplay_image() */
 
 

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_get_libpng_ver(NULL), mainprog_ptr,
+    png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, mainprog_ptr,
       writepng_error_handler, NULL);
     if (!png_ptr)
         return 4;   /* out of memory */

contrib/intel/INSTALL

@@ -1,158 +0,0 @@
-Enabling SSE support
-
-Copyright (c) 2016 Google, Inc.
-Written by Mike Klein, Matt Sarett
-
-This INSTALL file written by Glenn Randers-Pehrson, 2016.
-
-If you have moved intel_init.c and filter_sse2_intrinsics.c to a different
-directory, be sure to update the '#include "../../pngpriv.h"' line in both
-files if necessary to point to the correct relative location of pngpriv.h
-with respect to the new location of those files.
-
-To enable SSE support in libpng, follow the instructions in I, II, or III,
-below:
-
-I. Using patched "configure" scripts:
-
-First, apply intel_sse.patch in your build directory.
-
-   patch -i contrib/intel/intel_sse.patch -p1
-
-Then, if you are not building in a new GIT clone, e.g., in a tar
-distribution, remove any existing pre-built configure scripts:
-
-   ./configure --enable-maintainer-mode
-   make maintainer-clean
-   ./autogen.sh --maintainer --clean
-
-Finally, configure libpng with -DPNG_INTEL_SSE in CPPFLAGS:
-
-   ./autogen.sh --maintainer
-   CPPFLAGS="-DPNG_INTEL_SSE" ./configure [options]
-   make CPPFLAGS="-DPNG_INTEL_SSE" [options]
-   make
-
-II. Using a custom makefile:
-
-If you are using a custom makefile makefile, you will have to update it
-manually to include contrib/intel/*.o in the dependencies, and to define
-PNG_INTEL_SSE.
-
-III. Using manually updated "configure" scripts:
-
-If you prefer, manually edit pngpriv.h, configure.ac, and Makefile.am,
-following the instructions below, then follow the instructions in
-section II of INSTALL in the main libpng directory, then configure libpng
-with -DPNG_INTEL_SSE in CPPFLAGS.
-
-1. Add the following code to configure.ac under HOST SPECIFIC OPTIONS
-directly beneath the section for ARM:
-
------------------cut----------------
-# INTEL
-# =====
-#
-# INTEL SSE (SIMD) support.
-
-AC_ARG_ENABLE([intel-sse],
-   AS_HELP_STRING([[[--enable-intel-sse]]],
-      [Enable Intel SSE optimizations: =no/off, yes/on:]
-      [no/off: disable the optimizations;]
-      [yes/on: enable the optimizations.]
-      [If not specified: determined by the compiler.]),
-   [case "$enableval" in
-      no|off)
-         # disable the default enabling:
-         AC_DEFINE([PNG_INTEL_SSE_OPT], [0],
-                   [Disable Intel SSE optimizations])
-         # Prevent inclusion of the assembler files below:
-         enable_intel_sse=no;;
-      yes|on)
-         AC_DEFINE([PNG_INTEL_SSE_OPT], [1],
-                   [Enable Intel SSE optimizations]);;
-      *)
-         AC_MSG_ERROR([--enable-intel-sse=${enable_intel_sse}: invalid value])
-   esac])
-
-# Add Intel specific files to all builds where the host_cpu is Intel ('x86*')
-# or where Intel optimizations were explicitly requested (this allows a
-# fallback if a future host CPU does not match 'x86*')
-AM_CONDITIONAL([PNG_INTEL_SSE],
-   [test "$enable_intel_sse" != 'no' &&
-    case "$host_cpu" in
-      i?86|x86_64) :;;
-      *)    test "$enable_intel_sse" != '';;
-    esac])
------------------cut----------------
-
-2. Add the following code to Makefile.am under HOST SPECIFIC OPTIONS
-directly beneath the "if PNG_ARM_NEON ... endif" statement:
-
------------------cut----------------
-if PNG_INTEL_SSE
-libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@_la_SOURCES += contrib/intel/intel_init.c\
-    contrib/intel/filter_sse2_intrinsics.c
-endif
------------------cut----------------
-
-3. Add the following lines to pngpriv.h, following the PNG_ARM_NEON_OPT
-code:
-
------------------cut----------------
-#ifndef PNG_INTEL_SSE_OPT
-#   ifdef PNG_INTEL_SSE
-      /* Only check for SSE if the build configuration has been modified to
-       * enable SSE optimizations.  This means that these optimizations will
-       * be off by default.  See contrib/intel for more details.
-       */
-#     if defined(__SSE4_1__) || defined(__AVX__) || defined(__SSSE3__) || \
-       defined(__SSE2__) || defined(_M_X64) || defined(_M_AMD64) || \
-       (defined(_M_IX86_FP) && _M_IX86_FP >= 2)
-#         define PNG_INTEL_SSE_OPT 1
-#      endif
-#   endif
-#endif
-
-#if PNG_INTEL_SSE_OPT > 0
-#   ifndef PNG_INTEL_SSE_IMPLEMENTATION
-#      if defined(__SSE4_1__) || defined(__AVX__)
-          /* We are not actually using AVX, but checking for AVX is the best
-             way we can detect SSE4.1 and SSSE3 on MSVC.
-          */
-#         define PNG_INTEL_SSE_IMPLEMENTATION 3
-#      elif defined(__SSSE3__)
-#         define PNG_INTEL_SSE_IMPLEMENTATION 2
-#      elif defined(__SSE2__) || defined(_M_X64) || defined(_M_AMD64) || \
-       (defined(_M_IX86_FP) && _M_IX86_FP >= 2)
-#         define PNG_INTEL_SSE_IMPLEMENTATION 1
-#      else
-#         define PNG_INTEL_SSE_IMPLEMENTATION 0
-#      endif
-#   endif
-
-#   if PNG_INTEL_SSE_IMPLEMENTATION > 0
-#      define PNG_FILTER_OPTIMIZATIONS png_init_filter_functions_sse2
-#   endif
-#endif
-
------------------cut----------------
-
-4. Add the following lines to pngpriv.h, following the prototype for
-png_read_filter_row_paeth4_neon:
-
------------------cut----------------
-PNG_INTERNAL_FUNCTION(void,png_read_filter_row_sub3_sse2,(png_row_infop
-    row_info, png_bytep row, png_const_bytep prev_row),PNG_EMPTY);
-PNG_INTERNAL_FUNCTION(void,png_read_filter_row_sub4_sse2,(png_row_infop
-    row_info, png_bytep row, png_const_bytep prev_row),PNG_EMPTY);
-PNG_INTERNAL_FUNCTION(void,png_read_filter_row_avg3_sse2,(png_row_infop
-    row_info, png_bytep row, png_const_bytep prev_row),PNG_EMPTY);
-PNG_INTERNAL_FUNCTION(void,png_read_filter_row_avg4_sse2,(png_row_infop
-    row_info, png_bytep row, png_const_bytep prev_row),PNG_EMPTY);
-PNG_INTERNAL_FUNCTION(void,png_read_filter_row_paeth3_sse2,(png_row_infop
-    row_info, png_bytep row, png_const_bytep prev_row),PNG_EMPTY);
-PNG_INTERNAL_FUNCTION(void,png_read_filter_row_paeth4_sse2,(png_row_infop
-    row_info, png_bytep row, png_const_bytep prev_row),PNG_EMPTY);
-
------------------cut----------------

contrib/intel/filter_sse2_intrinsics.c

@@ -1,379 +0,0 @@
-
-/* filter_sse2_intrinsics.c - SSE2 optimized filter functions
- *
- * Copyright (c) 2016 Google, Inc.
- * Written by Mike Klein and Matt Sarett
- * Derived from arm/filter_neon_intrinsics.c, which was
- * Copyright (c) 2014,2016 Glenn Randers-Pehrson
- *
- * Last changed in libpng 1.6.24 [August 4, 2016]
- *
- * 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"
-
-#ifdef PNG_READ_SUPPORTED
-
-#if PNG_INTEL_SSE_IMPLEMENTATION > 0
-
-#include <immintrin.h>
-
-/* Functions in this file look at most 3 pixels (a,b,c) to predict the 4th (d).
- * They're positioned like this:
- *    prev:  c b
- *    row:   a d
- * The Sub filter predicts d=a, Avg d=(a+b)/2, and Paeth predicts d to be
- * whichever of a, b, or c is closest to p=a+b-c.
- */
-
-static __m128i load4(const void* p) {
-   return _mm_cvtsi32_si128(*(const int*)p);
-}
-
-static void store4(void* p, __m128i v) {
-   *(int*)p = _mm_cvtsi128_si32(v);
-}
-
-static __m128i load3(const void* p) {
-   /* We'll load 2 bytes, then 1 byte,
-    * then mask them together, and finally load into SSE.
-    */
-   const png_uint_16* p01 = p;
-   const png_byte*    p2  = (const png_byte*)(p01+1);
-
-   png_uint_32 v012 = (png_uint_32)(*p01)
-                    | (png_uint_32)(*p2) << 16;
-   return load4(&v012);
-}
-
-static void store3(void* p, __m128i v) {
-   /* We'll pull from SSE as a 32-bit int, then write
-    * its bottom two bytes, then its third byte.
-    */
-   png_uint_32 v012;
-   store4(&v012, v);
-
-   png_uint_16* p01 = p;
-   png_byte*    p2  = (png_byte*)(p01+1);
-   *p01 = v012;
-   *p2  = v012 >> 16;
-}
-
-void png_read_filter_row_sub3_sse2(png_row_infop row_info, png_bytep row,
-   png_const_bytep prev)
-{
-   /* The Sub filter predicts each pixel as the previous pixel, a.
-    * There is no pixel to the left of the first pixel.  It's encoded directly.
-    * That works with our main loop if we just say that left pixel was zero.
-    */
-   png_debug(1, "in png_read_filter_row_sub3_sse2");
-   __m128i a, d = _mm_setzero_si128();
-
-   int rb = row_info->rowbytes;
-   while (rb >= 4) {
-      a = d; d = load4(row);
-      d = _mm_add_epi8(d, a);
-      store3(row, d);
-
-      row += 3;
-      rb  -= 3;
-   }
-   if (rb > 0) {
-      a = d; d = load3(row);
-      d = _mm_add_epi8(d, a);
-      store3(row, d);
-
-      row += 3;
-      rb  -= 3;
-   }
-}
-
-void png_read_filter_row_sub4_sse2(png_row_infop row_info, png_bytep row,
-   png_const_bytep prev)
-{
-   /* The Sub filter predicts each pixel as the previous pixel, a.
-    * There is no pixel to the left of the first pixel.  It's encoded directly.
-    * That works with our main loop if we just say that left pixel was zero.
-    */
-   png_debug(1, "in png_read_filter_row_sub4_sse2");
-   __m128i a, d = _mm_setzero_si128();
-
-   int rb = row_info->rowbytes;
-   while (rb > 0) {
-      a = d; d = load4(row);
-      d = _mm_add_epi8(d, a);
-      store4(row, d);
-
-      row += 4;
-      rb  -= 4;
-   }
-}
-
-void png_read_filter_row_avg3_sse2(png_row_infop row_info, png_bytep row,
-   png_const_bytep prev)
-{
-   /* The Avg filter predicts each pixel as the (truncated) average of a and b.
-    * There's no pixel to the left of the first pixel.  Luckily, it's
-    * predicted to be half of the pixel above it.  So again, this works
-    * perfectly with our loop if we make sure a starts at zero.
-    */
-   png_debug(1, "in png_read_filter_row_avg3_sse2");
-   const __m128i zero = _mm_setzero_si128();
-   __m128i    b;
-   __m128i a, d = zero;
-
-   int rb = row_info->rowbytes;
-   while (rb >= 4) {
-             b = load4(prev);
-      a = d; d = load4(row );
-
-      /* PNG requires a truncating average, so we can't just use _mm_avg_epu8 */
-      __m128i avg = _mm_avg_epu8(a,b);
-      /* ...but we can fix it up by subtracting off 1 if it rounded up. */
-      avg = _mm_sub_epi8(avg, _mm_and_si128(_mm_xor_si128(a,b),
-                                            _mm_set1_epi8(1)));
-      d = _mm_add_epi8(d, avg);
-      store3(row, d);
-
-      prev += 3;
-      row  += 3;
-      rb   -= 3;
-   }
-   if (rb > 0) {
-             b = load3(prev);
-      a = d; d = load3(row );
-
-      /* PNG requires a truncating average, so we can't just use _mm_avg_epu8 */
-      __m128i avg = _mm_avg_epu8(a,b);
-      /* ...but we can fix it up by subtracting off 1 if it rounded up. */
-      avg = _mm_sub_epi8(avg, _mm_and_si128(_mm_xor_si128(a,b),
-                                            _mm_set1_epi8(1)));
-
-      d = _mm_add_epi8(d, avg);
-      store3(row, d);
-
-      prev += 3;
-      row  += 3;
-      rb   -= 3;
-   }
-}
-
-void png_read_filter_row_avg4_sse2(png_row_infop row_info, png_bytep row,
-   png_const_bytep prev)
-{
-   /* The Avg filter predicts each pixel as the (truncated) average of a and b.
-    * There's no pixel to the left of the first pixel.  Luckily, it's
-    * predicted to be half of the pixel above it.  So again, this works
-    * perfectly with our loop if we make sure a starts at zero.
-    */
-   png_debug(1, "in png_read_filter_row_avg4_sse2");
-   const __m128i zero = _mm_setzero_si128();
-   __m128i    b;
-   __m128i a, d = zero;
-
-   int rb = row_info->rowbytes;
-   while (rb > 0) {
-             b = load4(prev);
-      a = d; d = load4(row );
-
-      /* PNG requires a truncating average, so we can't just use _mm_avg_epu8 */
-      __m128i avg = _mm_avg_epu8(a,b);
-      /* ...but we can fix it up by subtracting off 1 if it rounded up. */
-      avg = _mm_sub_epi8(avg, _mm_and_si128(_mm_xor_si128(a,b),
-                                            _mm_set1_epi8(1)));
-
-      d = _mm_add_epi8(d, avg);
-      store4(row, d);
-
-      prev += 4;
-      row  += 4;
-      rb   -= 4;
-   }
-}
-
-/* Returns |x| for 16-bit lanes. */
-static __m128i abs_i16(__m128i x) {
-#if PNG_INTEL_SSE_IMPLEMENTATION >= 2
-   return _mm_abs_epi16(x);
-#else
-   /* Read this all as, return x<0 ? -x : x.
-   * To negate two's complement, you flip all the bits then add 1.
-    */
-   __m128i is_negative = _mm_cmplt_epi16(x, _mm_setzero_si128());
-
-   /* Flip negative lanes. */
-   x = _mm_xor_si128(x, is_negative);
-
-   /* +1 to negative lanes, else +0. */
-   x = _mm_sub_epi16(x, is_negative);
-   return x;
-#endif
-}
-
-/* Bytewise c ? t : e. */
-static __m128i if_then_else(__m128i c, __m128i t, __m128i e) {
-#if PNG_INTEL_SSE_IMPLEMENTATION >= 3
-   return _mm_blendv_epi8(e,t,c);
-#else
-   return _mm_or_si128(_mm_and_si128(c, t), _mm_andnot_si128(c, e));
-#endif
-}
-
-void png_read_filter_row_paeth3_sse2(png_row_infop row_info, png_bytep row,
-   png_const_bytep prev)
-{
-   /* Paeth tries to predict pixel d using the pixel to the left of it, a,
-    * and two pixels from the previous row, b and c:
-    *   prev: c b
-    *   row:  a d
-    * The Paeth function predicts d to be whichever of a, b, or c is nearest to
-    * p=a+b-c.
-    *
-    * The first pixel has no left context, and so uses an Up filter, p = b.
-    * This works naturally with our main loop's p = a+b-c if we force a and c
-    * to zero.
-    * Here we zero b and d, which become c and a respectively at the start of
-    * the loop.
-    */
-   png_debug(1, "in png_read_filter_row_paeth3_sse2");
-   const __m128i zero = _mm_setzero_si128();
-   __m128i c, b = zero,
-           a, d = zero;
-
-   int rb = row_info->rowbytes;
-   while (rb >= 4) {
-      /* It's easiest to do this math (particularly, deal with pc) with 16-bit
-       * intermediates.
-       */
-      c = b; b = _mm_unpacklo_epi8(load4(prev), zero);
-      a = d; d = _mm_unpacklo_epi8(load4(row ), zero);
-
-      /* (p-a) == (a+b-c - a) == (b-c) */
-      __m128i pa = _mm_sub_epi16(b,c);
-
-      /* (p-b) == (a+b-c - b) == (a-c) */
-      __m128i pb = _mm_sub_epi16(a,c);
-
-      /* (p-c) == (a+b-c - c) == (a+b-c-c) == (b-c)+(a-c) */
-      __m128i pc = _mm_add_epi16(pa,pb);
-
-      pa = abs_i16(pa);  /* |p-a| */
-      pb = abs_i16(pb);  /* |p-b| */
-      pc = abs_i16(pc);  /* |p-c| */
-
-      __m128i smallest = _mm_min_epi16(pc, _mm_min_epi16(pa, pb));
-
-      /* Paeth breaks ties favoring a over b over c. */
-      __m128i nearest  = if_then_else(_mm_cmpeq_epi16(smallest, pa), a,
-                         if_then_else(_mm_cmpeq_epi16(smallest, pb), b,
-                                                                     c));
-
-      /* Note `_epi8`: we need addition to wrap modulo 255. */
-      d = _mm_add_epi8(d, nearest);
-      store3(row, _mm_packus_epi16(d,d));
-
-      prev += 3;
-      row  += 3;
-      rb   -= 3;
-   }
-   if (rb > 0) {
-      /* It's easiest to do this math (particularly, deal with pc) with 16-bit
-       * intermediates.
-       */
-      c = b; b = _mm_unpacklo_epi8(load3(prev), zero);
-      a = d; d = _mm_unpacklo_epi8(load3(row ), zero);
-
-      /* (p-a) == (a+b-c - a) == (b-c) */
-      __m128i pa = _mm_sub_epi16(b,c);
-
-      /* (p-b) == (a+b-c - b) == (a-c) */
-      __m128i pb = _mm_sub_epi16(a,c);
-
-      /* (p-c) == (a+b-c - c) == (a+b-c-c) == (b-c)+(a-c) */
-      __m128i pc = _mm_add_epi16(pa,pb);
-
-      pa = abs_i16(pa);  /* |p-a| */
-      pb = abs_i16(pb);  /* |p-b| */
-      pc = abs_i16(pc);  /* |p-c| */
-
-      __m128i smallest = _mm_min_epi16(pc, _mm_min_epi16(pa, pb));
-
-      /* Paeth breaks ties favoring a over b over c. */
-      __m128i nearest  = if_then_else(_mm_cmpeq_epi16(smallest, pa), a,
-                         if_then_else(_mm_cmpeq_epi16(smallest, pb), b,
-                                                                     c));
-
-      /* Note `_epi8`: we need addition to wrap modulo 255. */
-      d = _mm_add_epi8(d, nearest);
-      store3(row, _mm_packus_epi16(d,d));
-
-      prev += 3;
-      row  += 3;
-      rb   -= 3;
-   }
-}
-
-void png_read_filter_row_paeth4_sse2(png_row_infop row_info, png_bytep row,
-   png_const_bytep prev)
-{
-   /* Paeth tries to predict pixel d using the pixel to the left of it, a,
-    * and two pixels from the previous row, b and c:
-    *   prev: c b
-    *   row:  a d
-    * The Paeth function predicts d to be whichever of a, b, or c is nearest to
-    * p=a+b-c.
-    *
-    * The first pixel has no left context, and so uses an Up filter, p = b.
-    * This works naturally with our main loop's p = a+b-c if we force a and c
-    * to zero.
-    * Here we zero b and d, which become c and a respectively at the start of
-    * the loop.
-    */
-   png_debug(1, "in png_read_filter_row_paeth4_sse2");
-   const __m128i zero = _mm_setzero_si128();
-   __m128i c, b = zero,
-           a, d = zero;
-
-   int rb = row_info->rowbytes;
-   while (rb > 0) {
-      /* It's easiest to do this math (particularly, deal with pc) with 16-bit
-       * intermediates.
-       */
-      c = b; b = _mm_unpacklo_epi8(load4(prev), zero);
-      a = d; d = _mm_unpacklo_epi8(load4(row ), zero);
-
-      /* (p-a) == (a+b-c - a) == (b-c) */
-      __m128i pa = _mm_sub_epi16(b,c);
-
-      /* (p-b) == (a+b-c - b) == (a-c) */
-      __m128i pb = _mm_sub_epi16(a,c);
-
-      /* (p-c) == (a+b-c - c) == (a+b-c-c) == (b-c)+(a-c) */
-      __m128i pc = _mm_add_epi16(pa,pb);
-
-      pa = abs_i16(pa);  /* |p-a| */
-      pb = abs_i16(pb);  /* |p-b| */
-      pc = abs_i16(pc);  /* |p-c| */
-
-      __m128i smallest = _mm_min_epi16(pc, _mm_min_epi16(pa, pb));
-
-      /* Paeth breaks ties favoring a over b over c. */
-      __m128i nearest  = if_then_else(_mm_cmpeq_epi16(smallest, pa), a,
-                         if_then_else(_mm_cmpeq_epi16(smallest, pb), b,
-                                                                     c));
-
-      /* Note `_epi8`: we need addition to wrap modulo 255. */
-      d = _mm_add_epi8(d, nearest);
-      store4(row, _mm_packus_epi16(d,d));
-
-      prev += 4;
-      row  += 4;
-      rb   -= 4;
-   }
-}
-
-#endif /* PNG_INTEL_SSE_IMPLEMENTATION > 0 */
-#endif /* READ */

contrib/intel/intel_init.c

@@ -1,54 +0,0 @@
-
-/* intel_init.c - SSE2 optimized filter functions
- *
- * Copyright (c) 2016 Google, Inc.
- * Written by Mike Klein and Matt Sarett
- * Derived from arm/arm_init.c, which was
- * Copyright (c) 2014,2016 Glenn Randers-Pehrson
- *
- * Last changed in libpng 1.6.22 [May 26, 2016]
- *
- * 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"
-
-#ifdef PNG_READ_SUPPORTED
-#if PNG_INTEL_SSE_IMPLEMENTATION > 0
-
-void
-png_init_filter_functions_sse2(png_structp pp, unsigned int bpp)
-{
-   /* The techniques used to implement each of these filters in SSE operate on
-    * one pixel at a time.
-    * So they generally speed up 3bpp images about 3x, 4bpp images about 4x.
-    * They can scale up to 6 and 8 bpp images and down to 2 bpp images,
-    * but they'd not likely have any benefit for 1bpp images.
-    * Most of these can be implemented using only MMX and 64-bit registers,
-    * but they end up a bit slower than using the equally-ubiquitous SSE2.
-   */
-   png_debug(1, "in png_init_filter_functions_sse2");
-   if (bpp == 3)
-   {
-      pp->read_filter[PNG_FILTER_VALUE_SUB-1] = png_read_filter_row_sub3_sse2;
-      pp->read_filter[PNG_FILTER_VALUE_AVG-1] = png_read_filter_row_avg3_sse2;
-      pp->read_filter[PNG_FILTER_VALUE_PAETH-1] =
-         png_read_filter_row_paeth3_sse2;
-   }
-   else if (bpp == 4)
-   {
-      pp->read_filter[PNG_FILTER_VALUE_SUB-1] = png_read_filter_row_sub4_sse2;
-      pp->read_filter[PNG_FILTER_VALUE_AVG-1] = png_read_filter_row_avg4_sse2;
-      pp->read_filter[PNG_FILTER_VALUE_PAETH-1] =
-          png_read_filter_row_paeth4_sse2;
-   }
-
-   /* No need optimize PNG_FILTER_VALUE_UP.  The compiler should
-    * autovectorize.
-    */
-}
-
-#endif /* PNG_INTEL_SSE_IMPLEMENTATION > 0 */
-#endif /* PNG_READ_SUPPORTED */

contrib/intel/intel_sse.patch

@@ -1,190 +0,0 @@
-diff --git a/configure.ac b/configure.ac
---- a/configure.ac	2016-08-29 11:46:27.000000000 -0400
-+++ b/configure.ac	2016-08-29 16:57:03.866355018 -0400
-@@ -386,16 +386,51 @@ AC_ARG_ENABLE([mips-msa],
- # future host CPU does not match 'mips*')
- 
- AM_CONDITIONAL([PNG_MIPS_MSA],
-    [test "$enable_mips_msa" != 'no' &&
-     case "$host_cpu" in
-       mipsel*|mips64el*) :;;
-     esac])
- 
-+# INTEL
-+# =====
-+#
-+# INTEL SSE (SIMD) support.
-+
-+AC_ARG_ENABLE([intel-sse],
-+   AS_HELP_STRING([[[--enable-intel-sse]]],
-+      [Enable Intel SSE optimizations: =no/off, yes/on:]
-+      [no/off: disable the optimizations;]
-+      [yes/on: enable the optimizations.]
-+      [If not specified: determined by the compiler.]),
-+   [case "$enableval" in
-+      no|off)
-+         # disable the default enabling:
-+         AC_DEFINE([PNG_INTEL_SSE_OPT], [0],
-+                   [Disable Intel SSE optimizations])
-+         # Prevent inclusion of the assembler files below:
-+         enable_intel_sse=no;;
-+      yes|on)
-+         AC_DEFINE([PNG_INTEL_SSE_OPT], [1],
-+                   [Enable Intel SSE optimizations]);;
-+      *)
-+         AC_MSG_ERROR([--enable-intel-sse=${enable_intel_sse}: invalid value])
-+   esac])
-+
-+# Add Intel specific files to all builds where the host_cpu is Intel ('x86*')
-+# or where Intel optimizations were explicitly requested (this allows a
-+# fallback if a future host CPU does not match 'x86*')
-+AM_CONDITIONAL([PNG_INTEL_SSE],
-+   [test "$enable_intel_sse" != 'no' &&
-+    case "$host_cpu" in
-+      i?86|x86_64) :;;
-+      *)    test "$enable_intel_sse" != '';;
-+    esac])
-+
- AC_MSG_NOTICE([[Extra options for compiler: $PNG_COPTS]])
- 
- # Config files, substituting as above
- AC_CONFIG_FILES([Makefile libpng.pc:libpng.pc.in])
- AC_CONFIG_FILES([libpng-config:libpng-config.in],
-    [chmod +x libpng-config])
- 
- AC_OUTPUT
-diff --git a/Makefile.am b/Makefile.am
---- a/Makefile.am	2016-08-29 11:46:27.000000000 -0400
-+++ b/Makefile.am	2016-08-29 16:57:45.955528215 -0400
-@@ -97,16 +97,21 @@ libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@_la_SO
- 	arm/filter_neon.S arm/filter_neon_intrinsics.c
- endif
- 
- if PNG_MIPS_MSA
- libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@_la_SOURCES += mips/mips_init.c\
- 	mips/filter_msa_intrinsics.c
- endif
- 
-+if PNG_INTEL_SSE
-+libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@_la_SOURCES += contrib/intel/intel_init.c\
-+    contrib/intel/filter_sse2_intrinsics.c
-+endif
-+
- nodist_libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@_la_SOURCES = pnglibconf.h
- 
- libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@_la_LDFLAGS = -no-undefined -export-dynamic \
- 	-version-number @PNGLIB_MAJOR@@PNGLIB_MINOR@:@PNGLIB_RELEASE@:0
- 
- if HAVE_LD_VERSION_SCRIPT
- #   Versioned symbols and restricted exports
- if HAVE_SOLARIS_LD
-diff --git a/pngpriv.h b/pngpriv.h
---- debug16/pngpriv.h	2016-08-30 10:46:36.000000000 -0400
-+++ libpng16/pngpriv.h	2016-08-30 11:57:25.672280202 -0400
-@@ -185,16 +185,52 @@
- #ifndef PNG_MIPS_MSA_OPT
- #  if defined(__mips_msa) && (__mips_isa_rev >= 5) && defined(PNG_ALIGNED_MEMORY_SUPPORTED)
- #     define PNG_MIPS_MSA_OPT 2
- #  else
- #     define PNG_MIPS_MSA_OPT 0
- #  endif
- #endif
- 
-+#ifndef PNG_INTEL_SSE_OPT
-+#   ifdef PNG_INTEL_SSE
-+      /* Only check for SSE if the build configuration has been modified to
-+       * enable SSE optimizations.  This means that these optimizations will
-+       * be off by default.  See contrib/intel for more details.
-+       */
-+#     if defined(__SSE4_1__) || defined(__AVX__) || defined(__SSSE3__) || \
-+       defined(__SSE2__) || defined(_M_X64) || defined(_M_AMD64) || \
-+       (defined(_M_IX86_FP) && _M_IX86_FP >= 2)
-+#         define PNG_INTEL_SSE_OPT 1
-+#      endif
-+#   endif
-+#endif
-+
-+#if PNG_INTEL_SSE_OPT > 0
-+#   ifndef PNG_INTEL_SSE_IMPLEMENTATION
-+#      if defined(__SSE4_1__) || defined(__AVX__)
-+          /* We are not actually using AVX, but checking for AVX is the best
-+             way we can detect SSE4.1 and SSSE3 on MSVC.
-+          */
-+#         define PNG_INTEL_SSE_IMPLEMENTATION 3
-+#      elif defined(__SSSE3__)
-+#         define PNG_INTEL_SSE_IMPLEMENTATION 2
-+#      elif defined(__SSE2__) || defined(_M_X64) || defined(_M_AMD64) || \
-+       (defined(_M_IX86_FP) && _M_IX86_FP >= 2)
-+#         define PNG_INTEL_SSE_IMPLEMENTATION 1
-+#      else
-+#         define PNG_INTEL_SSE_IMPLEMENTATION 0
-+#      endif
-+#   endif
-+
-+#   if PNG_INTEL_SSE_IMPLEMENTATION > 0
-+#      define PNG_FILTER_OPTIMIZATIONS png_init_filter_functions_sse2
-+#   endif
-+#endif
-+
- #if PNG_MIPS_MSA_OPT > 0
- #  define PNG_FILTER_OPTIMIZATIONS png_init_filter_functions_msa
- #  ifndef PNG_MIPS_MSA_IMPLEMENTATION
- #     if defined(__mips_msa)
- #        if defined(__clang__)
- #        elif defined(__GNUC__)
- #           if __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 7)
- #              define PNG_MIPS_MSA_IMPLEMENTATION 2
-@@ -1251,16 +1287,31 @@ PNG_INTERNAL_FUNCTION(void,png_read_filt
- PNG_INTERNAL_FUNCTION(void,png_read_filter_row_avg4_msa,(png_row_infop
-     row_info, png_bytep row, png_const_bytep prev_row),PNG_EMPTY);
- PNG_INTERNAL_FUNCTION(void,png_read_filter_row_paeth3_msa,(png_row_infop
-     row_info, png_bytep row, png_const_bytep prev_row),PNG_EMPTY);
- PNG_INTERNAL_FUNCTION(void,png_read_filter_row_paeth4_msa,(png_row_infop
-     row_info, png_bytep row, png_const_bytep prev_row),PNG_EMPTY);
- #endif
- 
-+#if PNG_INTEL_SSE_IMPLEMENTATION > 0
-+PNG_INTERNAL_FUNCTION(void,png_read_filter_row_sub3_sse2,(png_row_infop
-+    row_info, png_bytep row, png_const_bytep prev_row),PNG_EMPTY);
-+PNG_INTERNAL_FUNCTION(void,png_read_filter_row_sub4_sse2,(png_row_infop
-+    row_info, png_bytep row, png_const_bytep prev_row),PNG_EMPTY);
-+PNG_INTERNAL_FUNCTION(void,png_read_filter_row_avg3_sse2,(png_row_infop
-+    row_info, png_bytep row, png_const_bytep prev_row),PNG_EMPTY);
-+PNG_INTERNAL_FUNCTION(void,png_read_filter_row_avg4_sse2,(png_row_infop
-+    row_info, png_bytep row, png_const_bytep prev_row),PNG_EMPTY);
-+PNG_INTERNAL_FUNCTION(void,png_read_filter_row_paeth3_sse2,(png_row_infop
-+    row_info, png_bytep row, png_const_bytep prev_row),PNG_EMPTY);
-+PNG_INTERNAL_FUNCTION(void,png_read_filter_row_paeth4_sse2,(png_row_infop
-+    row_info, png_bytep row, png_const_bytep prev_row),PNG_EMPTY);
-+#endif
-+
- /* Choose the best filter to use and filter the row data */
- PNG_INTERNAL_FUNCTION(void,png_write_find_filter,(png_structrp png_ptr,
-     png_row_infop row_info),PNG_EMPTY);
- 
- #ifdef PNG_SEQUENTIAL_READ_SUPPORTED
- PNG_INTERNAL_FUNCTION(void,png_read_IDAT_data,(png_structrp png_ptr,
-    png_bytep output, png_alloc_size_t avail_out),PNG_EMPTY);
-    /* Read 'avail_out' bytes of data from the IDAT stream.  If the output buffer
-@@ -1986,16 +2037,21 @@ PNG_INTERNAL_FUNCTION(void, PNG_FILTER_O
- PNG_INTERNAL_FUNCTION(void, png_init_filter_functions_neon,
-    (png_structp png_ptr, unsigned int bpp), PNG_EMPTY);
- #endif
- 
- #if PNG_MIPS_MSA_OPT > 0
- PNG_INTERNAL_FUNCTION(void, png_init_filter_functions_msa,
-    (png_structp png_ptr, unsigned int bpp), PNG_EMPTY);
- #endif
-+
-+#  if PNG_INTEL_SSE_IMPLEMENTATION > 0
-+PNG_INTERNAL_FUNCTION(void, png_init_filter_functions_sse2,
-+   (png_structp png_ptr, unsigned int bpp), PNG_EMPTY);
-+#  endif
- #endif
- 
- PNG_INTERNAL_FUNCTION(png_uint_32, png_check_keyword, (png_structrp png_ptr,
-    png_const_charp key, png_bytep new_key), PNG_EMPTY);
- 
- /* Maintainer: Put new private prototypes here ^ */
- 
- #include "pngdebug.h"

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 */
 
@@ -60,6 +52,6 @@ main(void)
    fwrite(signature, sizeof signature, 1, stdout);
    put_chunk(IHDR, sizeof IHDR);
 
-   for (;;)
+   for(;;)
       put_chunk(unknown, sizeof unknown);
 }

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.6.20 [November 24, 2015]
+/* 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/pngstest-errors.h

@@ -1,165 +0,0 @@
-/* contrib/libtests/pngstest-errors.h
- *
- * BUILT USING: libpng version 1.6.19beta03 - September 25, 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, 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, 16, 17, 0 }, { 0, 17, 17, 0 }, { 0, 19, 0, 0 }, { 0, 0, 0, 0 },
-  { 0, 850, 875, 0 }, { 0, 850, 875, 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, 9, 0 }, { 0, 0, 9, 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, 9, 0 }, { 0, 9, 9, 0 },
-  { 0, 585, 427, 0 }, { 0, 585, 427, 0 }, { 0, 717, 514, 0 }, { 0, 717, 514, 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, 16, 17, 0 }, { 0, 187, 17, 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, 5, 0 }, { 0, 32, 5, 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, 9, 0 }, { 0, 255, 9, 25 }, { 0, 88, 9, 0 }, { 0, 255, 9, 25 },
-  { 0, 1012, 928, 0 }, { 0, 16026, 928, 6425 }, { 0, 1012, 928, 0 }, { 0, 16026, 928, 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, 15736, 2824, 6425 }, { 0, 14019, 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, 99, 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, 187, 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-2016 John Cunningham Bowler
+ * Copyright (c) 2013 John Cunningham Bowler
  *
- * Last changed in libpng 1.6.24 [August 4, 2016]
+ * 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
@@ -35,15 +35,6 @@
 #  include "../../png.h"
 #endif
 
-/* 1.6.1 added support for the configure test harness, which uses 77 to indicate
- * a skipped test, in earlier versions we need to succeed on a skipped test, so:
- */
-#if PNG_LIBPNG_VER >= 10601 && defined(HAVE_CONFIG_H)
-#  define SKIP 77
-#else
-#  define SKIP 0
-#endif
-
 #ifdef PNG_SIMPLIFIED_READ_SUPPORTED /* Else nothing can be done */
 #include "../tools/sRGB.h"
 
@@ -108,18 +99,10 @@ make_random_bytes(png_uint_32* seed, void* pv, size_t size)
    seed[1] = u1;
 }
 
-static png_uint_32 color_seed[2];
-
-static void
-reseed(void)
-{
-   color_seed[0] = 0x12345678U;
-   color_seed[1] = 0x9abcdefU;
-}
-
 static void
 random_color(png_colorp color)
 {
+   static png_uint_32 color_seed[2] = { 0x12345678, 0x9abcdef };
    make_random_bytes(color_seed, color, sizeof *color);
 }
 
@@ -324,7 +307,7 @@ compare_16bit(int v1, int v2, int error_limit, int multiple_algorithms)
 }
 #endif /* unused */
 
-#define USE_FILE 1       /* else memory */
+#define READ_FILE 1      /* else memory */
 #define USE_STDIO 2      /* else use file name */
 #define STRICT 4         /* fail on warnings too */
 #define VERBOSE 8
@@ -333,19 +316,16 @@ compare_16bit(int v1, int v2, int error_limit, int multiple_algorithms)
 #define ACCUMULATE 64
 #define FAST_WRITE 128
 #define sRGB_16BIT 256
-#define NO_RESEED  512   /* do not reseed on each new file */
-#define GBG_ERROR 1024   /* do not ignore the gamma+background_rgb_to_gray
-                          * libpng warning. */
 
 static void
 print_opts(png_uint_32 opts)
 {
-   if (opts & USE_FILE)
+   if (opts & READ_FILE)
       printf(" --file");
    if (opts & USE_STDIO)
       printf(" --stdio");
-   if (!(opts & STRICT))
-      printf(" --nostrict");
+   if (opts & STRICT)
+      printf(" --strict");
    if (opts & VERBOSE)
       printf(" --verbose");
    if (opts & KEEP_TMPFILES)
@@ -358,12 +338,6 @@ print_opts(png_uint_32 opts)
       printf(" --slow");
    if (opts & sRGB_16BIT)
       printf(" --sRGB-16bit");
-   if (opts & NO_RESEED)
-      printf(" --noreseed");
-#if PNG_LIBPNG_VER < 10700 /* else on by default */
-   if (opts & GBG_ERROR)
-      printf(" --fault-gbg-warning");
-#endif
 }
 
 #define FORMAT_NO_CHANGE 0x80000000 /* additional flag */
@@ -543,23 +517,14 @@ static void format_default(format_list *pf, int redundant)
 
       for (f=0; f<FORMAT_COUNT; ++f)
       {
-         /* Eliminate redundant and unsupported settings. */
-#        ifdef PNG_FORMAT_BGR_SUPPORTED
-            /* BGR is meaningless if no color: */
-            if ((f & PNG_FORMAT_FLAG_COLOR) == 0 &&
-               (f & PNG_FORMAT_FLAG_BGR) != 0)
-#        else
-            if ((f & 0x10U/*HACK: fixed value*/) != 0)
-#        endif
+         /* Eliminate redundant settings. */
+         /* BGR is meaningless if no color: */
+         if ((f & PNG_FORMAT_FLAG_COLOR) == 0 && (f & PNG_FORMAT_FLAG_BGR) != 0)
             continue;
 
          /* AFIRST is meaningless if no alpha: */
-#        ifdef PNG_FORMAT_AFIRST_SUPPORTED
-            if ((f & PNG_FORMAT_FLAG_ALPHA) == 0 &&
-               (f & PNG_FORMAT_FLAG_AFIRST) != 0)
-#        else
-            if ((f & 0x20U/*HACK: fixed value*/) != 0)
-#        endif
+         if ((f & PNG_FORMAT_FLAG_ALPHA) == 0 &&
+            (f & PNG_FORMAT_FLAG_AFIRST) != 0)
             continue;
 
          format_set(pf, f);
@@ -641,7 +606,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;
    }
 }
@@ -767,15 +732,8 @@ checkopaque(Image *image)
       return logerror(image, image->file_name, ": opaque not NULL", "");
    }
 
-   /* Separate out the gamma+background_rgb_to_gray warning because it may
-    * produce opaque component errors:
-    */
-   else if (image->image.warning_or_error != 0 &&
-            (strcmp(image->image.message,
-               "libpng does not support gamma+background+rgb_to_gray") == 0 ?
-                  (image->opts & GBG_ERROR) != 0 : (image->opts & STRICT) != 0))
-      return logerror(image, image->file_name, (image->opts & GBG_ERROR) != 0 ?
-                      " --fault-gbg-warning" : " --strict", "");
+   else if (image->image.warning_or_error != 0 && (image->opts & STRICT) != 0)
+      return logerror(image, image->file_name, " --strict", "");
 
    else
       return 1;
@@ -828,7 +786,6 @@ gp_ga8(Pixel *p, png_const_voidp pb)
    p->a = pp[1];
 }
 
-#ifdef PNG_FORMAT_AFIRST_SUPPORTED
 static void
 gp_ag8(Pixel *p, png_const_voidp pb)
 {
@@ -837,7 +794,6 @@ gp_ag8(Pixel *p, png_const_voidp pb)
    p->r = p->g = p->b = pp[1];
    p->a = pp[0];
 }
-#endif
 
 static void
 gp_rgb8(Pixel *p, png_const_voidp pb)
@@ -850,7 +806,6 @@ gp_rgb8(Pixel *p, png_const_voidp pb)
    p->a = 255;
 }
 
-#ifdef PNG_FORMAT_BGR_SUPPORTED
 static void
 gp_bgr8(Pixel *p, png_const_voidp pb)
 {
@@ -861,7 +816,6 @@ gp_bgr8(Pixel *p, png_const_voidp pb)
    p->b = pp[0];
    p->a = 255;
 }
-#endif
 
 static void
 gp_rgba8(Pixel *p, png_const_voidp pb)
@@ -874,7 +828,6 @@ gp_rgba8(Pixel *p, png_const_voidp pb)
    p->a = pp[3];
 }
 
-#ifdef PNG_FORMAT_BGR_SUPPORTED
 static void
 gp_bgra8(Pixel *p, png_const_voidp pb)
 {
@@ -885,9 +838,7 @@ gp_bgra8(Pixel *p, png_const_voidp pb)
    p->b = pp[0];
    p->a = pp[3];
 }
-#endif
 
-#ifdef PNG_FORMAT_AFIRST_SUPPORTED
 static void
 gp_argb8(Pixel *p, png_const_voidp pb)
 {
@@ -898,9 +849,7 @@ gp_argb8(Pixel *p, png_const_voidp pb)
    p->b = pp[3];
    p->a = pp[0];
 }
-#endif
 
-#if defined(PNG_FORMAT_AFIRST_SUPPORTED) && defined(PNG_FORMAT_BGR_SUPPORTED)
 static void
 gp_abgr8(Pixel *p, png_const_voidp pb)
 {
@@ -911,7 +860,6 @@ gp_abgr8(Pixel *p, png_const_voidp pb)
    p->b = pp[1];
    p->a = pp[0];
 }
-#endif
 
 static void
 gp_g16(Pixel *p, png_const_voidp pb)
@@ -931,7 +879,6 @@ gp_ga16(Pixel *p, png_const_voidp pb)
    p->a = pp[1];
 }
 
-#ifdef PNG_FORMAT_AFIRST_SUPPORTED
 static void
 gp_ag16(Pixel *p, png_const_voidp pb)
 {
@@ -940,7 +887,6 @@ gp_ag16(Pixel *p, png_const_voidp pb)
    p->r = p->g = p->b = pp[1];
    p->a = pp[0];
 }
-#endif
 
 static void
 gp_rgb16(Pixel *p, png_const_voidp pb)
@@ -953,7 +899,6 @@ gp_rgb16(Pixel *p, png_const_voidp pb)
    p->a = 65535;
 }
 
-#ifdef PNG_FORMAT_BGR_SUPPORTED
 static void
 gp_bgr16(Pixel *p, png_const_voidp pb)
 {
@@ -964,7 +909,6 @@ gp_bgr16(Pixel *p, png_const_voidp pb)
    p->b = pp[0];
    p->a = 65535;
 }
-#endif
 
 static void
 gp_rgba16(Pixel *p, png_const_voidp pb)
@@ -977,7 +921,6 @@ gp_rgba16(Pixel *p, png_const_voidp pb)
    p->a = pp[3];
 }
 
-#ifdef PNG_FORMAT_BGR_SUPPORTED
 static void
 gp_bgra16(Pixel *p, png_const_voidp pb)
 {
@@ -988,9 +931,7 @@ gp_bgra16(Pixel *p, png_const_voidp pb)
    p->b = pp[0];
    p->a = pp[3];
 }
-#endif
 
-#ifdef PNG_FORMAT_AFIRST_SUPPORTED
 static void
 gp_argb16(Pixel *p, png_const_voidp pb)
 {
@@ -1001,9 +942,7 @@ gp_argb16(Pixel *p, png_const_voidp pb)
    p->b = pp[3];
    p->a = pp[0];
 }
-#endif
 
-#if defined(PNG_FORMAT_AFIRST_SUPPORTED) && defined(PNG_FORMAT_BGR_SUPPORTED)
 static void
 gp_abgr16(Pixel *p, png_const_voidp pb)
 {
@@ -1014,7 +953,6 @@ gp_abgr16(Pixel *p, png_const_voidp pb)
    p->b = pp[1];
    p->a = pp[0];
 }
-#endif
 
 /* Given a format, return the correct one of the above functions. */
 static void (*
@@ -1028,35 +966,29 @@ get_pixel(png_uint_32 format))(Pixel *p, png_const_voidp pb)
    {
       if (format & PNG_FORMAT_FLAG_COLOR)
       {
-#        ifdef PNG_FORMAT_BGR_SUPPORTED
-            if (format & PNG_FORMAT_FLAG_BGR)
-            {
-               if (format & PNG_FORMAT_FLAG_ALPHA)
-               {
-#                 ifdef PNG_FORMAT_AFIRST_SUPPORTED
-                     if (format & PNG_FORMAT_FLAG_AFIRST)
-                        return gp_abgr16;
-
-                     else
-#                 endif
-                     return gp_bgra16;
-               }
-
-               else
-                  return gp_bgr16;
-            }
-
-            else
-#        endif
+         if (format & PNG_FORMAT_FLAG_BGR)
          {
             if (format & PNG_FORMAT_FLAG_ALPHA)
             {
-#              ifdef PNG_FORMAT_AFIRST_SUPPORTED
-                  if (format & PNG_FORMAT_FLAG_AFIRST)
-                     return gp_argb16;
+               if (format & PNG_FORMAT_FLAG_AFIRST)
+                  return gp_abgr16;
 
-                  else
-#              endif
+               else
+                  return gp_bgra16;
+            }
+
+            else
+               return gp_bgr16;
+         }
+
+         else
+         {
+            if (format & PNG_FORMAT_FLAG_ALPHA)
+            {
+               if (format & PNG_FORMAT_FLAG_AFIRST)
+                  return gp_argb16;
+
+               else
                   return gp_rgba16;
             }
 
@@ -1069,12 +1001,10 @@ get_pixel(png_uint_32 format))(Pixel *p, png_const_voidp pb)
       {
          if (format & PNG_FORMAT_FLAG_ALPHA)
          {
-#           ifdef PNG_FORMAT_AFIRST_SUPPORTED
-               if (format & PNG_FORMAT_FLAG_AFIRST)
-                  return gp_ag16;
+            if (format & PNG_FORMAT_FLAG_AFIRST)
+               return gp_ag16;
 
-               else
-#           endif
+            else
                return gp_ga16;
          }
 
@@ -1087,35 +1017,29 @@ get_pixel(png_uint_32 format))(Pixel *p, png_const_voidp pb)
    {
       if (format & PNG_FORMAT_FLAG_COLOR)
       {
-#        ifdef PNG_FORMAT_BGR_SUPPORTED
-            if (format & PNG_FORMAT_FLAG_BGR)
-            {
-               if (format & PNG_FORMAT_FLAG_ALPHA)
-               {
-#                 ifdef PNG_FORMAT_AFIRST_SUPPORTED
-                     if (format & PNG_FORMAT_FLAG_AFIRST)
-                        return gp_abgr8;
-
-                     else
-#                 endif
-                     return gp_bgra8;
-               }
-
-               else
-                  return gp_bgr8;
-            }
-
-            else
-#        endif
+         if (format & PNG_FORMAT_FLAG_BGR)
          {
             if (format & PNG_FORMAT_FLAG_ALPHA)
             {
-#              ifdef PNG_FORMAT_AFIRST_SUPPORTED
-                  if (format & PNG_FORMAT_FLAG_AFIRST)
-                     return gp_argb8;
+               if (format & PNG_FORMAT_FLAG_AFIRST)
+                  return gp_abgr8;
 
-                  else
-#              endif
+               else
+                  return gp_bgra8;
+            }
+
+            else
+               return gp_bgr8;
+         }
+
+         else
+         {
+            if (format & PNG_FORMAT_FLAG_ALPHA)
+            {
+               if (format & PNG_FORMAT_FLAG_AFIRST)
+                  return gp_argb8;
+
+               else
                   return gp_rgba8;
             }
 
@@ -1128,12 +1052,10 @@ get_pixel(png_uint_32 format))(Pixel *p, png_const_voidp pb)
       {
          if (format & PNG_FORMAT_FLAG_ALPHA)
          {
-#           ifdef PNG_FORMAT_AFIRST_SUPPORTED
-               if (format & PNG_FORMAT_FLAG_AFIRST)
-                  return gp_ag8;
+            if (format & PNG_FORMAT_FLAG_AFIRST)
+               return gp_ag8;
 
-               else
-#           endif
+            else
                return gp_ga8;
          }
 
@@ -2017,7 +1939,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 */
 
@@ -2038,7 +2109,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);
@@ -2547,15 +2618,13 @@ component_loc(png_byte loc[4], png_uint_32 format)
 
       loc[2] = 1;
 
-#     ifdef PNG_FORMAT_BGR_SUPPORTED
-         if (format & PNG_FORMAT_FLAG_BGR)
-         {
-            loc[1] = 2;
-            loc[3] = 0;
-         }
+      if (format & PNG_FORMAT_FLAG_BGR)
+      {
+         loc[1] = 2;
+         loc[3] = 0;
+      }
 
-         else
-#     endif
+      else
       {
          loc[1] = 0;
          loc[3] = 2;
@@ -2570,17 +2639,15 @@ component_loc(png_byte loc[4], png_uint_32 format)
 
    if (format & PNG_FORMAT_FLAG_ALPHA)
    {
-#     ifdef PNG_FORMAT_AFIRST_SUPPORTED
-         if (format & PNG_FORMAT_FLAG_AFIRST)
-         {
-            loc[0] = 0;
-            ++loc[1];
-            ++loc[2];
-            ++loc[3];
-         }
+      if (format & PNG_FORMAT_FLAG_AFIRST)
+      {
+         loc[0] = 0;
+         ++loc[1];
+         ++loc[2];
+         ++loc[3];
+      }
 
-         else
-#     endif
+      else
          loc[0] = channels;
 
       ++channels;
@@ -2712,7 +2779,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,
@@ -2950,25 +3017,17 @@ read_file(Image *image, png_uint_32 format, png_const_colorp background)
          return logerror(image, "memory init: ", image->file_name, "");
    }
 
-#  ifdef PNG_STDIO_SUPPORTED
-      else if (image->input_file != NULL)
-      {
-         if (!png_image_begin_read_from_stdio(&image->image, image->input_file))
-            return logerror(image, "stdio init: ", image->file_name, "");
-      }
+   else if (image->input_file != NULL)
+   {
+      if (!png_image_begin_read_from_stdio(&image->image, image->input_file))
+         return logerror(image, "stdio init: ", image->file_name, "");
+   }
 
-      else
-      {
-         if (!png_image_begin_read_from_file(&image->image, image->file_name))
-            return logerror(image, "file init: ", image->file_name, "");
-      }
-#  else
-      else
-      {
-         return logerror(image, "unsupported file/stdio init: ",
-            image->file_name, "");
-      }
-#  endif
+   else
+   {
+      if (!png_image_begin_read_from_file(&image->image, image->file_name))
+         return logerror(image, "file init: ", image->file_name, "");
+   }
 
    /* This must be set after the begin_read call: */
    if (image->opts & sRGB_16BIT)
@@ -3041,14 +3100,14 @@ read_file(Image *image, png_uint_32 format, png_const_colorp background)
 static int
 read_one_file(Image *image)
 {
-   if (!(image->opts & USE_FILE) || (image->opts & USE_STDIO))
+   if (!(image->opts & READ_FILE) || (image->opts & USE_STDIO))
    {
       /* memory or stdio. */
       FILE *f = fopen(image->file_name, "rb");
 
       if (f != NULL)
       {
-         if (image->opts & USE_FILE)
+         if (image->opts & READ_FILE)
             image->input_file = f;
 
          else /* memory */
@@ -3057,45 +3116,32 @@ read_one_file(Image *image)
             {
                long int cb = ftell(f);
 
-               if (cb > 0)
+               if (cb > 0 && (unsigned long int)cb < (size_t)~(size_t)0)
                {
-#ifndef __COVERITY__
-                  if ((unsigned long int)cb <= (size_t)~(size_t)0)
-#endif
+                  png_bytep b = voidcast(png_bytep, malloc((size_t)cb));
+
+                  if (b != NULL)
                   {
-                     png_bytep b = voidcast(png_bytep, malloc((size_t)cb));
+                     rewind(f);
 
-                     if (b != NULL)
+                     if (fread(b, (size_t)cb, 1, f) == 1)
                      {
-                        rewind(f);
-
-                        if (fread(b, (size_t)cb, 1, f) == 1)
-                        {
-                           fclose(f);
-                           image->input_memory_size = cb;
-                           image->input_memory = b;
-                        }
-
-                        else
-                        {
-                           free(b);
-                           return logclose(image, f, image->file_name,
-                              ": read failed: ");
-                        }
+                        fclose(f);
+                        image->input_memory_size = cb;
+                        image->input_memory = b;
                      }
 
                      else
+                     {
+                        free(b);
                         return logclose(image, f, image->file_name,
-                           ": out of memory: ");
+                           ": read failed: ");
+                     }
                   }
 
                   else
                      return logclose(image, f, image->file_name,
-                        ": file too big for this architecture: ");
-                     /* cb is the length of the file as a (long) and
-                      * this is greater than the maximum amount of
-                      * memory that can be requested from malloc.
-                      */
+                        ": out of memory: ");
                }
 
                else if (cb == 0)
@@ -3129,41 +3175,7 @@ write_one_file(Image *output, Image *image, int convert_to_8bit)
 
    if (image->opts & USE_STDIO)
    {
-#ifdef PNG_SIMPLIFIED_WRITE_STDIO_SUPPORTED
-#ifndef __COVERITY__
       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)
       {
@@ -3192,14 +3204,10 @@ write_one_file(Image *output, Image *image, int convert_to_8bit)
 
       else
          return logerror(image, "tmpfile", ": open: ", strerror(errno));
-#else /* SIMPLIFIED_WRITE_STDIO */
-      return logerror(image, "tmpfile", ": open: unsupported", "");
-#endif /* SIMPLIFIED_WRITE_STDIO */
    }
 
-   else if (image->opts & USE_FILE)
+   else
    {
-#ifdef PNG_SIMPLIFIED_WRITE_STDIO_SUPPORTED
       static int counter = 0;
       char name[32];
 
@@ -3219,51 +3227,6 @@ write_one_file(Image *output, Image *image, int convert_to_8bit)
 
       else
          return logerror(image, name, ": write failed", "");
-#else /* SIMPLIFIED_WRITE_STDIO */
-      return logerror(image, "stdio", ": open: unsupported", "");
-#endif /* SIMPLIFIED_WRITE_STDIO */
-   }
-
-   else /* use memory */
-   {
-      png_alloc_size_t size;
-
-      if (png_image_write_get_memory_size(image->image, size, convert_to_8bit,
-               image->buffer+16, (png_int_32)image->stride, image->colormap))
-      {
-         /* This is non-fatal but ignoring it was causing serious problems in
-          * the macro to be ignored:
-          */
-         if (size > PNG_IMAGE_PNG_SIZE_MAX(image->image))
-            return logerror(image, "memory", ": PNG_IMAGE_SIZE_MAX wrong", "");
-
-         initimage(output, image->opts, "memory", image->stride_extra);
-         output->input_memory = malloc(size);
-
-         if (output->input_memory != NULL)
-         {
-            output->input_memory_size = size;
-
-            if (png_image_write_to_memory(&image->image, output->input_memory,
-                  &output->input_memory_size, convert_to_8bit, image->buffer+16,
-                  (png_int_32)image->stride, image->colormap))
-            {
-               /* This is also non-fatal but it safes safer to error out anyway:
-                */
-               if (size != output->input_memory_size)
-                  return logerror(image, "memory", ": memory size wrong", "");
-            }
-
-            else
-               return logerror(image, "memory", ": write failed", "");
-         }
-
-         else
-            return logerror(image, "memory", ": out of memory", "");
-      }
-
-      else
-         return logerror(image, "memory", ": get size:", "");
    }
 
    /* 'output' has an initialized temporary image, read this back in and compare
@@ -3439,8 +3402,6 @@ test_one_file(const char *file_name, format_list *formats, png_uint_32 opts,
    int result;
    Image image;
 
-   if (!(opts & NO_RESEED))
-      reseed(); /* ensure that the random numbers don't depend on file order */
    newimage(&image);
    initimage(&image, opts, file_name, stride_extra);
    result = read_one_file(&image);
@@ -3478,7 +3439,7 @@ test_one_file(const char *file_name, format_list *formats, png_uint_32 opts,
 int
 main(int argc, char **argv)
 {
-   png_uint_32 opts = FAST_WRITE | STRICT;
+   png_uint_32 opts = FAST_WRITE;
    format_list formats;
    const char *touch = NULL;
    int log_pass = 0;
@@ -3487,17 +3448,11 @@ main(int argc, char **argv)
    int retval = 0;
    int c;
 
-#if PNG_LIBPNG_VER >= 10700
-      /* This error should not exist in 1.7 or later: */
-      opts |= GBG_ERROR;
-#endif
-
    init_sRGB_to_d();
 #if 0
    init_error_via_linear();
 #endif
    format_init(&formats);
-   reseed(); /* initialize random number seeds */
 
    for (c=1; c<argc; ++c)
    {
@@ -3511,19 +3466,11 @@ main(int argc, char **argv)
          memset(gpc_error_via_linear, 0, sizeof gpc_error_via_linear);
       }
       else if (strcmp(arg, "--file") == 0)
-#        ifdef PNG_STDIO_SUPPORTED
-            opts |= USE_FILE;
-#        else
-            return SKIP; /* skipped: no support */
-#        endif
+         opts |= READ_FILE;
       else if (strcmp(arg, "--memory") == 0)
-         opts &= ~USE_FILE;
+         opts &= ~READ_FILE;
       else if (strcmp(arg, "--stdio") == 0)
-#        ifdef PNG_STDIO_SUPPORTED
-            opts |= USE_STDIO;
-#        else
-            return SKIP; /* skipped: no support */
-#        endif
+         opts |= USE_STDIO;
       else if (strcmp(arg, "--name") == 0)
          opts &= ~USE_STDIO;
       else if (strcmp(arg, "--verbose") == 0)
@@ -3548,16 +3495,10 @@ main(int argc, char **argv)
          opts &= ~KEEP_GOING;
       else if (strcmp(arg, "--strict") == 0)
          opts |= STRICT;
-      else if (strcmp(arg, "--nostrict") == 0)
-         opts &= ~STRICT;
       else if (strcmp(arg, "--sRGB-16bit") == 0)
          opts |= sRGB_16BIT;
       else if (strcmp(arg, "--linear-16bit") == 0)
          opts &= ~sRGB_16BIT;
-      else if (strcmp(arg, "--noreseed") == 0)
-         opts |= NO_RESEED;
-      else if (strcmp(arg, "--fault-gbg-warning") == 0)
-         opts |= GBG_ERROR;
       else if (strcmp(arg, "--tmpfile") == 0)
       {
          if (c+1 < argc)
@@ -3571,7 +3512,7 @@ main(int argc, char **argv)
             }
 
             /* Safe: checked above */
-            strncpy(tmpf, argv[c], sizeof (tmpf)-1);
+            strcpy(tmpf, argv[c]);
          }
 
          else
@@ -3670,23 +3611,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)
@@ -3776,7 +3700,6 @@ main(int argc, char **argv)
             putchar('\n');
       }
       printf("};\n");
-      printf("/* END MACHINE GENERATED */\n");
    }
 
    if (retval == 0 && touch != NULL)
@@ -3814,6 +3737,6 @@ int main(void)
 {
    fprintf(stderr, "pngstest: no read support in libpng, test skipped\n");
    /* So the test is skipped: */
-   return SKIP;
+   return 77;
 }
 #endif /* PNG_SIMPLIFIED_READ_SUPPORTED */

contrib/libtests/pngunknown.c

@@ -1,8 +1,8 @@
 
 /* pngunknown.c - test the read side unknown chunk handling
  *
- * Last changed in libpng 1.6.26 [October 20, 2016]
- * Copyright (c) 2015,2016 Glenn Randers-Pehrson
+ * Last changed in libpng 1.6.0 [February 14, 2013]
+ * Copyright (c) 2013 Glenn Randers-Pehrson
  * Written by John Cunningham Bowler
  *
  * This code is released under the libpng license.
@@ -30,30 +30,7 @@
 #  include "../../png.h"
 #endif
 
-/* 1.6.1 added support for the configure test harness, which uses 77 to indicate
- * a skipped test, in earlier versions we need to succeed on a skipped test, so:
- */
-#if PNG_LIBPNG_VER >= 10601 && defined(HAVE_CONFIG_H)
-#  define SKIP 77
-#else
-#  define SKIP 0
-#endif
-
-
-/* Since this program tests the ability to change the unknown chunk handling
- * these must be defined:
- */
-#if defined(PNG_SET_UNKNOWN_CHUNKS_SUPPORTED) &&\
-   defined(PNG_STDIO_SUPPORTED) &&\
-   defined(PNG_READ_SUPPORTED)
-
-/* One of these must be defined to allow us to find out what happened.  It is
- * still useful to set unknown chunk handling without either of these in order
- * to cause *known* chunks to be discarded.  This can be a significant
- * efficiency gain, but it can't really be tested here.
- */
-#if defined(PNG_READ_USER_CHUNKS_SUPPORTED) ||\
-   defined(PNG_SAVE_UNKNOWN_CHUNKS_SUPPORTED)
+#ifdef PNG_READ_SUPPORTED
 
 #if PNG_LIBPNG_VER < 10500
 /* This deliberately lacks the PNG_CONST. */
@@ -98,74 +75,43 @@ typedef png_byte *png_const_bytep;
 #  define png_const_structp png_structp
 #endif
 
-#if PNG_LIBPNG_VER < 10700
-   /* Copied from libpng 1.7.0 png.h */
-#define PNG_u2(b1, b2) (((unsigned int)(b1) << 8) + (b2))
 
-#define PNG_U16(b1, b2) ((png_uint_16)PNG_u2(b1, b2))
-#define PNG_U32(b1, b2, b3, b4)\
-   (((png_uint_32)PNG_u2(b1, b2) << 16) + PNG_u2(b3, b4))
+/* Copied from pngpriv.h */
+#define PNG_32b(b,s) ((png_uint_32)(b) << (s))
+#define PNG_CHUNK(b1,b2,b3,b4) \
+   (PNG_32b(b1,24) | PNG_32b(b2,16) | PNG_32b(b3,8) | PNG_32b(b4,0))
 
-/* Constants for known chunk types.
- */
-#define png_IDAT PNG_U32( 73,  68,  65,  84)
-#define png_IEND PNG_U32( 73,  69,  78,  68)
-#define png_IHDR PNG_U32( 73,  72,  68,  82)
-#define png_PLTE PNG_U32( 80,  76,  84,  69)
-#define png_bKGD PNG_U32( 98,  75,  71,  68)
-#define png_cHRM PNG_U32( 99,  72,  82,  77)
-#define png_fRAc PNG_U32(102,  82,  65,  99) /* registered, not defined */
-#define png_gAMA PNG_U32(103,  65,  77,  65)
-#define png_gIFg PNG_U32(103,  73,  70, 103)
-#define png_gIFt PNG_U32(103,  73,  70, 116) /* deprecated */
-#define png_gIFx PNG_U32(103,  73,  70, 120)
-#define png_hIST PNG_U32(104,  73,  83,  84)
-#define png_iCCP PNG_U32(105,  67,  67,  80)
-#define png_iTXt PNG_U32(105,  84,  88, 116)
-#define png_oFFs PNG_U32(111,  70,  70, 115)
-#define png_pCAL PNG_U32(112,  67,  65,  76)
-#define png_pHYs PNG_U32(112,  72,  89, 115)
-#define png_sBIT PNG_U32(115,  66,  73,  84)
-#define png_sCAL PNG_U32(115,  67,  65,  76)
-#define png_sPLT PNG_U32(115,  80,  76,  84)
-#define png_sRGB PNG_U32(115,  82,  71,  66)
-#define png_sTER PNG_U32(115,  84,  69,  82)
-#define png_tEXt PNG_U32(116,  69,  88, 116)
-#define png_tIME PNG_U32(116,  73,  77,  69)
-#define png_tRNS PNG_U32(116,  82,  78,  83)
-#define png_zTXt PNG_U32(122,  84,  88, 116)
+#define png_IHDR PNG_CHUNK( 73,  72,  68,  82)
+#define png_IDAT PNG_CHUNK( 73,  68,  65,  84)
+#define png_IEND PNG_CHUNK( 73,  69,  78,  68)
+#define png_PLTE PNG_CHUNK( 80,  76,  84,  69)
+#define png_bKGD PNG_CHUNK( 98,  75,  71,  68)
+#define png_cHRM PNG_CHUNK( 99,  72,  82,  77)
+#define png_gAMA PNG_CHUNK(103,  65,  77,  65)
+#define png_hIST PNG_CHUNK(104,  73,  83,  84)
+#define png_iCCP PNG_CHUNK(105,  67,  67,  80)
+#define png_iTXt PNG_CHUNK(105,  84,  88, 116)
+#define png_oFFs PNG_CHUNK(111,  70,  70, 115)
+#define png_pCAL PNG_CHUNK(112,  67,  65,  76)
+#define png_sCAL PNG_CHUNK(115,  67,  65,  76)
+#define png_pHYs PNG_CHUNK(112,  72,  89, 115)
+#define png_sBIT PNG_CHUNK(115,  66,  73,  84)
+#define png_sPLT PNG_CHUNK(115,  80,  76,  84)
+#define png_sRGB PNG_CHUNK(115,  82,  71,  66)
+#define png_sTER PNG_CHUNK(115,  84,  69,  82)
+#define png_tEXt PNG_CHUNK(116,  69,  88, 116)
+#define png_tIME PNG_CHUNK(116,  73,  77,  69)
+#define png_tRNS PNG_CHUNK(116,  82,  78,  83)
+#define png_zTXt PNG_CHUNK(122,  84,  88, 116)
+#define png_vpAg PNG_CHUNK('v', 'p', 'A', 'g')
 
 /* Test on flag values as defined in the spec (section 5.4): */
-#define PNG_CHUNK_ANCILLARY(c)    (1 & ((c) >> 29))
+#define PNG_CHUNK_ANCILLARY(c )   (1 & ((c) >> 29))
 #define PNG_CHUNK_CRITICAL(c)     (!PNG_CHUNK_ANCILLARY(c))
 #define PNG_CHUNK_PRIVATE(c)      (1 & ((c) >> 21))
 #define PNG_CHUNK_RESERVED(c)     (1 & ((c) >> 13))
 #define PNG_CHUNK_SAFE_TO_COPY(c) (1 & ((c) >>  5))
 
-#endif /* PNG_LIBPNG_VER < 10700 */
-
-#ifdef __cplusplus
-#  define this not_the_cpp_this
-#  define new not_the_cpp_new
-#  define voidcast(type, value) static_cast<type>(value)
-#else
-#  define voidcast(type, value) (value)
-#endif /* __cplusplus */
-
-/* Unused formal parameter errors are removed using the following macro which is
- * expected to have no bad effects on performance.
- */
-#ifndef UNUSED
-#  if defined(__GNUC__) || defined(_MSC_VER)
-#     define UNUSED(param) (void)param;
-#  else
-#     define UNUSED(param)
-#  endif
-#endif
-
-/* Types of chunks not known to libpng */
-#define png_vpAg PNG_U32(118, 112, 65, 103)
-
 /* Chunk information */
 #define PNG_INFO_tEXt 0x10000000U
 #define PNG_INFO_iTXt 0x20000000U
@@ -193,8 +139,8 @@ static struct
    { "PLTE", PNG_INFO_PLTE, png_PLTE, 0, 0, ABSENT, 0 },
 
    /* Non-critical chunks that libpng handles */
-   /* This is a mess but it seems to be the only way to do it - there is no way
-    * to check for a definition outside a #if.
+   /* This is a mess but it seems to be the only way to do it - there is no way to
+    * check for definition outside a #if.
     */
    { "bKGD", PNG_INFO_bKGD, png_bKGD,
 #     ifdef PNG_READ_bKGD_SUPPORTED
@@ -371,16 +317,14 @@ find_by_flag(png_uint_32 flag)
 static int
 ancillary(const char *name)
 {
-   return PNG_CHUNK_ANCILLARY(PNG_U32(name[0], name[1], name[2], name[3]));
+   return PNG_CHUNK_ANCILLARY(PNG_CHUNK(name[0], name[1], name[2], name[3]));
 }
 
-#ifdef PNG_SAVE_UNKNOWN_CHUNKS_SUPPORTED
 static int
 ancillaryb(const png_byte *name)
 {
-   return PNG_CHUNK_ANCILLARY(PNG_U32(name[0], name[1], name[2], name[3]));
+   return PNG_CHUNK_ANCILLARY(PNG_CHUNK(name[0], name[1], name[2], name[3]));
 }
-#endif
 
 /* Type of an error_ptr */
 typedef struct
@@ -388,11 +332,8 @@ typedef struct
    jmp_buf     error_return;
    png_structp png_ptr;
    png_infop   info_ptr, end_ptr;
-   png_uint_32 before_IDAT;
-   png_uint_32 after_IDAT;
    int         error_count;
    int         warning_count;
-   int         keep; /* the default value */
    const char *program;
    const char *file;
    const char *test;
@@ -425,6 +366,9 @@ clean_display(display *d)
          d->test);
       exit(1);
    }
+
+   /* Invalidate the test */
+   d->test = init;
 }
 
 PNG_FUNCTION(void, display_exit, (display *d), static PNG_NORETURN)
@@ -450,7 +394,7 @@ display_rc(const display *d, int strict)
 }
 
 /* libpng error and warning callbacks */
-PNG_FUNCTION(void, (PNGCBAPI error), (png_structp png_ptr, const char *message),
+PNG_FUNCTION(void, error, (png_structp png_ptr, const char *message),
    static PNG_NORETURN)
 {
    display *d = (display*)png_get_error_ptr(png_ptr);
@@ -459,7 +403,7 @@ PNG_FUNCTION(void, (PNGCBAPI error), (png_structp png_ptr, const char *message),
    display_exit(d);
 }
 
-static void PNGCBAPI
+static void
 warning(png_structp png_ptr, const char *message)
 {
    display *d = (display*)png_get_error_ptr(png_ptr);
@@ -478,7 +422,7 @@ get_valid(display *d, png_infop info_ptr)
       png_textp text;
       png_uint_32 ntext = png_get_text(d->png_ptr, info_ptr, &text, NULL);
 
-      while (ntext > 0) switch (text[--ntext].compression)
+      while (ntext-- > 0) switch (text[ntext].compression)
       {
          case -1:
             flags |= PNG_INFO_tEXt;
@@ -500,88 +444,11 @@ get_valid(display *d, png_infop info_ptr)
    return flags;
 }
 
-#ifdef PNG_READ_USER_CHUNKS_SUPPORTED
-static int PNGCBAPI
-read_callback(png_structp pp, png_unknown_chunkp pc)
-{
-   /* This function mimics the behavior of png_set_keep_unknown_chunks by
-    * returning '0' to keep the chunk and '1' to discard it.
-    */
-   display *d = voidcast(display*, png_get_user_chunk_ptr(pp));
-   int chunk = findb(pc->name);
-   int keep, discard;
-
-   if (chunk < 0) /* not one in our list, so not a known chunk */
-      keep = d->keep;
-
-   else
-   {
-      keep = chunk_info[chunk].keep;
-      if (keep == PNG_HANDLE_CHUNK_AS_DEFAULT)
-      {
-         /* See the comments in png.h - use the default for unknown chunks,
-          * do not keep known chunks.
-          */
-         if (chunk_info[chunk].unknown)
-            keep = d->keep;
-
-         else
-            keep = PNG_HANDLE_CHUNK_NEVER;
-      }
-   }
-
-   switch (keep)
-   {
-      default:
-         fprintf(stderr, "%s(%s): %d: unrecognized chunk option\n", d->file,
-            d->test, chunk_info[chunk].keep);
-         display_exit(d);
-
-      case PNG_HANDLE_CHUNK_AS_DEFAULT:
-      case PNG_HANDLE_CHUNK_NEVER:
-         discard = 1/*handled; discard*/;
-         break;
-
-      case PNG_HANDLE_CHUNK_IF_SAFE:
-      case PNG_HANDLE_CHUNK_ALWAYS:
-         discard = 0/*not handled; keep*/;
-         break;
-   }
-
-   /* Also store information about this chunk in the display, the relevant flag
-    * is set if the chunk is to be kept ('not handled'.)
-    */
-   if (chunk >= 0) if (!discard) /* stupidity to stop a GCC warning */
-   {
-      png_uint_32 flag = chunk_info[chunk].flag;
-
-      if (pc->location & PNG_AFTER_IDAT)
-         d->after_IDAT |= flag;
-
-      else
-         d->before_IDAT |= flag;
-   }
-
-   /* 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
-      return discard;
-#  else
-      return 1; /*handled; discard*/
-#  endif
-}
-#endif /* READ_USER_CHUNKS_SUPPORTED */
-
-#ifdef PNG_SAVE_UNKNOWN_CHUNKS_SUPPORTED
 static png_uint_32
-get_unknown(display *d, png_infop info_ptr, int after_IDAT)
+get_unknown(display *d, int def, png_infop info_ptr)
 {
    /* Create corresponding 'unknown' flags */
    png_uint_32 flags = 0;
-
-   UNUSED(after_IDAT)
-
    {
       png_unknown_chunkp unknown;
       int num_unknown = png_get_unknown_chunks(d->png_ptr, info_ptr, &unknown);
@@ -591,16 +458,16 @@ get_unknown(display *d, png_infop info_ptr, int after_IDAT)
          int chunk = findb(unknown[num_unknown].name);
 
          /* Chunks not known to pngunknown must be validated here; since they
-          * must also be unknown to libpng the 'display->keep' behavior should
-          * have been used.
+          * must also be unknown to libpng the 'def' behavior should have been
+          * used.
           */
-         if (chunk < 0) switch (d->keep)
+         if (chunk < 0) switch (def)
          {
             default: /* impossible */
             case PNG_HANDLE_CHUNK_AS_DEFAULT:
             case PNG_HANDLE_CHUNK_NEVER:
                fprintf(stderr, "%s(%s): %s: %s: unknown chunk saved\n",
-                  d->file, d->test, d->keep ? "discard" : "default",
+                  d->file, d->test, def ? "discard" : "default",
                   unknown[num_unknown].name);
                ++(d->error_count);
                break;
@@ -626,39 +493,14 @@ get_unknown(display *d, png_infop info_ptr, int after_IDAT)
 
    return flags;
 }
-#else /* SAVE_UNKNOWN_CHUNKS */
-static png_uint_32
-get_unknown(display *d, png_infop info_ptr, int after_IDAT)
-   /* Otherwise this will return the cached values set by any user callback */
-{
-   UNUSED(info_ptr);
-
-   if (after_IDAT)
-      return d->after_IDAT;
-
-   else
-      return d->before_IDAT;
-}
-
-#  ifndef PNG_READ_USER_CHUNKS_SUPPORTED
-      /* The #defines above should mean this is never reached, it's just here as
-       * a check to ensure the logic is correct.
-       */
-#     error No store support and no user chunk support, this will not work
-#  endif /* READ_USER_CHUNKS */
-#endif /* SAVE_UNKNOWN_CHUNKS */
 
 static int
 check(FILE *fp, int argc, const char **argv, png_uint_32p flags/*out*/,
-   display *d, int set_callback)
+   display *d)
 {
-   int i, npasses, ipass;
+   int i, def = PNG_HANDLE_CHUNK_AS_DEFAULT, npasses, ipass;
    png_uint_32 height;
 
-   d->keep = PNG_HANDLE_CHUNK_AS_DEFAULT;
-   d->before_IDAT = 0;
-   d->after_IDAT = 0;
-
    /* Some of these errors are permanently fatal and cause an exit here, others
     * are per-test and cause an error return.
     */
@@ -684,16 +526,6 @@ check(FILE *fp, int argc, const char **argv, png_uint_32p flags/*out*/,
 
    png_init_io(d->png_ptr, fp);
 
-#  ifdef PNG_READ_USER_CHUNKS_SUPPORTED
-      /* This is only done if requested by the caller; it interferes with the
-       * standard store/save mechanism.
-       */
-      if (set_callback)
-         png_set_read_user_chunk_fn(d->png_ptr, d, read_callback);
-#  else
-      UNUSED(set_callback)
-#  endif
-
    /* Handle each argument in turn; multiple settings are possible for the same
     * chunk and multiple calls will occur (the last one should override all
     * preceding ones).
@@ -733,17 +565,13 @@ 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 */
-                  {
+#                 ifdef PNG_SAVE_UNKNOWN_CHUNKS_SUPPORTED
                      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;
-                  }
+#                 endif
                   continue;
                }
 
@@ -752,13 +580,10 @@ 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 */
+#                 ifdef PNG_SAVE_UNKNOWN_CHUNKS_SUPPORTED
                      png_set_keep_unknown_chunks(d->png_ptr, option, NULL, 0);
-
-                  d->keep = option;
+#                 endif
+                  def = option;
                   continue;
                }
 
@@ -767,17 +592,14 @@ 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 */
+#                 ifdef PNG_SAVE_UNKNOWN_CHUNKS_SUPPORTED
                      png_set_keep_unknown_chunks(d->png_ptr, option, NULL, -1);
+                     def = option;
 
-                  d->keep = option;
-
-                  for (chunk = 0; chunk < NINFO; ++chunk)
-                     if (chunk_info[chunk].all)
-                        chunk_info[chunk].keep = option;
+                     for (chunk = 0; chunk < NINFO; ++chunk)
+                        if (chunk_info[chunk].all)
+                           chunk_info[chunk].keep = option;
+#                 endif
                   continue;
                }
 
@@ -851,18 +673,18 @@ check(FILE *fp, int argc, const char **argv, png_uint_32p flags/*out*/,
    png_read_end(d->png_ptr, d->end_ptr);
 
    flags[0] = get_valid(d, d->info_ptr);
-   flags[1] = get_unknown(d, d->info_ptr, 0/*before IDAT*/);
+   flags[1] = get_unknown(d, def, d->info_ptr);
 
    /* Only png_read_png sets PNG_INFO_IDAT! */
    flags[chunk_info[0/*IDAT*/].keep != PNG_HANDLE_CHUNK_AS_DEFAULT] |=
       PNG_INFO_IDAT;
 
    flags[2] = get_valid(d, d->end_ptr);
-   flags[3] = get_unknown(d, d->end_ptr, 1/*after IDAT*/);
+   flags[3] = get_unknown(d, def, d->end_ptr);
 
    clean_display(d);
 
-   return d->keep;
+   return def;
 }
 
 static void
@@ -883,7 +705,7 @@ check_error(display *d, png_uint_32 flags, const char *message)
 
 static void
 check_handling(display *d, int def, png_uint_32 chunks, png_uint_32 known,
-   png_uint_32 unknown, const char *position, int set_callback)
+   png_uint_32 unknown, const char *position)
 {
    while (chunks)
    {
@@ -990,9 +812,8 @@ check_handling(display *d, int def, png_uint_32 chunks, png_uint_32 known,
       if (errorx != NULL)
       {
          ++(d->error_count);
-         fprintf(stderr, "%s(%s%s): %s %s %s: %s\n", d->file, d->test,
-            set_callback ? ",callback" : "",
-            type, chunk_info[i].name, position, errorx);
+         fprintf(stderr, "%s(%s): %s %s %s: %s\n",
+            d->file, d->test, type, chunk_info[i].name, position, errorx);
       }
 
       chunks &= ~flag;
@@ -1001,7 +822,7 @@ check_handling(display *d, int def, png_uint_32 chunks, png_uint_32 known,
 
 static void
 perform_one_test(FILE *fp, int argc, const char **argv,
-   png_uint_32 *default_flags, display *d, int set_callback)
+   png_uint_32 *default_flags, display *d)
 {
    int def;
    png_uint_32 flags[2][4];
@@ -1010,21 +831,7 @@ perform_one_test(FILE *fp, int argc, const char **argv,
    clear_keep();
    memcpy(flags[0], default_flags, sizeof flags[0]);
 
-   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
-    * triggering 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;
+   def = check(fp, argc, argv, flags[1], d);
 
    /* Chunks should either be known or unknown, never both and this should apply
     * whether the chunk is before or after the IDAT (actually, the app can
@@ -1059,9 +866,9 @@ perform_one_test(FILE *fp, int argc, const char **argv,
     * it or not.
     */
    check_handling(d, def, flags[0][0] | flags[0][1], flags[1][0], flags[1][1],
-      "before IDAT", set_callback);
+      "before IDAT");
    check_handling(d, def, flags[0][2] | flags[0][3], flags[1][2], flags[1][3],
-      "after IDAT", set_callback);
+      "after IDAT");
 }
 
 static void
@@ -1071,12 +878,7 @@ perform_one_test_safe(FILE *fp, int argc, const char **argv,
    if (setjmp(d->error_return) == 0)
    {
       d->test = test; /* allow use of d->error_return */
-#     ifdef PNG_SAVE_UNKNOWN_CHUNKS_SUPPORTED
-         perform_one_test(fp, argc, argv, default_flags, d, 0);
-#     endif
-#     ifdef PNG_READ_USER_CHUNKS_SUPPORTED
-         perform_one_test(fp, argc, argv, default_flags, d, 1);
-#     endif
+      perform_one_test(fp, argc, argv, default_flags, d);
       d->test = init; /* prevent use of d->error_return */
    }
 }
@@ -1100,7 +902,7 @@ usage(const char *program, const char *reason)
    fprintf(stderr, "pngunknown: %s: usage:\n %s [--strict] "
       "--default|{(CHNK|default|all)=(default|discard|if-safe|save)} "
       "testfile.png\n", reason, program);
-   exit(99);
+   exit(2);
 }
 
 int
@@ -1148,6 +950,11 @@ main(int argc, const char **argv)
    else if (default_tests) if (argc != 1)
       usage(d.program, "extra arguments");
 
+#  ifndef PNG_SAVE_UNKNOWN_CHUNKS_SUPPORTED
+      fprintf(stderr, "%s: warning: no 'save' support so arguments ignored\n",
+         d.program);
+#  endif
+
    /* The name of the test file is the last argument; remove it. */
    d.file = argv[--argc];
 
@@ -1155,40 +962,24 @@ main(int argc, const char **argv)
    if (fp == NULL)
    {
       perror(d.file);
-      exit(99);
+      exit(2);
    }
 
    /* First find all the chunks, known and unknown, in the test file, a failure
     * here aborts the whole test.
-    *
-    * If 'save' is supported then the normal saving method should happen,
-    * otherwise if 'read' is supported then the read callback will do the
-    * same thing.  If both are supported the 'read' callback won't be
-    * instantiated by default.  If 'save' is *not* supported then a user
-    * callback is required even though we can call png_get_unknown_chunks.
     */
-   if (check(fp, 1, &count_argv, default_flags, &d,
-#     ifdef PNG_SAVE_UNKNOWN_CHUNKS_SUPPORTED
-         0
-#     else
-         1
-#     endif
-      ) != PNG_HANDLE_CHUNK_ALWAYS)
+   if (check(fp, 1, &count_argv, default_flags, &d) !=
+      PNG_HANDLE_CHUNK_ALWAYS)
    {
       fprintf(stderr, "%s: %s: internal error\n", d.program, d.file);
-      exit(99);
+      exit(3);
    }
 
    /* Now find what the various supplied options cause to change: */
    if (!default_tests)
    {
       d.test = cmd; /* acts as a flag to say exit, do not longjmp */
-#     ifdef PNG_SAVE_UNKNOWN_CHUNKS_SUPPORTED
-         perform_one_test(fp, argc, argv, default_flags, &d, 0);
-#     endif
-#     ifdef PNG_READ_USER_CHUNKS_SUPPORTED
-         perform_one_test(fp, argc, argv, default_flags, &d, 1);
-#     endif
+      perform_one_test(fp, argc, argv, default_flags, &d);
       d.test = init;
    }
 
@@ -1246,14 +1037,14 @@ main(int argc, const char **argv)
             if (fclose(fsuccess) || err)
             {
                fprintf(stderr, "%s: write failed\n", touch_file);
-               exit(99);
+               exit(1);
             }
          }
 
          else
          {
             fprintf(stderr, "%s: open failed\n", touch_file);
-            exit(99);
+            exit(1);
          }
       }
 
@@ -1263,24 +1054,13 @@ main(int argc, const char **argv)
    return 1;
 }
 
-#else /* !(READ_USER_CHUNKS || SAVE_UNKNOWN_CHUNKS) */
+#else
 int
 main(void)
 {
    fprintf(stderr,
-      " test ignored: no support to find out about unknown chunks\n");
+   " test ignored because libpng was not built with unknown chunk support\n");
    /* So the test is skipped: */
-   return SKIP;
+   return 77;
 }
-#endif /* READ_USER_CHUNKS || SAVE_UNKNOWN_CHUNKS */
-
-#else /* !(SET_UNKNOWN_CHUNKS && READ) */
-int
-main(void)
-{
-   fprintf(stderr,
-      " test ignored: no support to modify unknown chunk handling\n");
-   /* So the test is skipped: */
-   return SKIP;
-}
-#endif /* SET_UNKNOWN_CHUNKS && READ*/
+#endif

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/libtests/timepng.c

@@ -1,8 +1,8 @@
 /* timepng.c
  *
- * Copyright (c) 2013,2016 John Cunningham Bowler
+ * Copyright (c) 2013 John Cunningham Bowler
  *
- * Last changed in libpng 1.6.22 [May 26, 2016]
+ * 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
@@ -10,17 +10,15 @@
  *
  * Load an arbitrary number of PNG files (from the command line, or, if there
  * are no arguments on the command line, from stdin) then run a time test by
- * reading each file by row or by image (possibly with transforms in the latter
- * case).  The only output is a time as a floating point number of seconds with
- * 9 decimal digits.
+ * reading each file by row.  The test does nothing with the read result and
+ * does no transforms.  The only output is a time as a floating point number of
+ * seconds with 9 decimal digits.
  */
 #define _POSIX_C_SOURCE 199309L /* for clock_gettime */
 
 #include <stdlib.h>
 #include <stdio.h>
 #include <string.h>
-#include <errno.h>
-#include <limits.h>
 
 #include <time.h>
 
@@ -37,73 +35,36 @@
 #  include "../../png.h"
 #endif
 
-/* The following is to support direct compilation of this file as C++ */
-#ifdef __cplusplus
-#  define voidcast(type, value) static_cast<type>(value)
-#else
-#  define voidcast(type, value) (value)
-#endif /* __cplusplus */
-
-/* 'CLOCK_PROCESS_CPUTIME_ID' is one of the clock timers for clock_gettime.  It
- * need not be supported even when clock_gettime is available.  It returns the
- * 'CPU' time the process has consumed.  'CPU' time is assumed to include time
- * when the CPU is actually blocked by a pending cache fill but not time
- * waiting for page faults.  The attempt is to get a measure of the actual time
- * the implementation takes to read a PNG ignoring the potentially very large IO
- * overhead.
- */
-#if defined (CLOCK_PROCESS_CPUTIME_ID) && defined(PNG_STDIO_SUPPORTED) &&\
-    defined(PNG_EASY_ACCESS_SUPPORTED) &&\
-    (PNG_LIBPNG_VER >= 10700 ? defined(PNG_READ_PNG_SUPPORTED) :\
-     defined (PNG_SEQUENTIAL_READ_SUPPORTED) &&\
-     defined(PNG_INFO_IMAGE_SUPPORTED))
-
-typedef struct
+static int read_png(FILE *fp)
 {
-   FILE *input;
-   FILE *output;
-}  io_data;
-
-static PNG_CALLBACK(void, read_and_copy,
-      (png_structp png_ptr, png_bytep buffer, png_size_t cb))
-{
-   io_data *io = (io_data*)png_get_io_ptr(png_ptr);
-
-   if (fread(buffer, cb, 1, io->input) != 1)
-      png_error(png_ptr, strerror(errno));
-
-   if (fwrite(buffer, cb, 1, io->output) != 1)
-   {
-      perror("temporary file");
-      fprintf(stderr, "temporary file PNG write failed\n");
-      exit(1);
-   }
-}
-
-static void read_by_row(png_structp png_ptr, png_infop info_ptr,
-      FILE *write_ptr, FILE *read_ptr)
-{
-   /* These don't get freed on error, this is fine; the program immediately
-    * exits.
-    */
+   png_structp png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING,0,0,0);
+   png_infop info_ptr = NULL;
    png_bytep row = NULL, display = NULL;
-   io_data io_copy;
 
-   if (write_ptr != NULL)
+   if (png_ptr == NULL)
+      return 0;
+
+   if (setjmp(png_jmpbuf(png_ptr)))
    {
-      /* Set up for a copy to the temporary file: */
-      io_copy.input = read_ptr;
-      io_copy.output = write_ptr;
-      png_set_read_fn(png_ptr, &io_copy, read_and_copy);
+      png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
+      if (row != NULL) free(row);
+      if (display != NULL) free(display);
+      return 0;
    }
 
+   png_init_io(png_ptr, fp);
+
+   info_ptr = png_create_info_struct(png_ptr);
+   if (info_ptr == NULL)
+      png_error(png_ptr, "OOM allocating info structure");
+
    png_read_info(png_ptr, info_ptr);
 
    {
       png_size_t rowbytes = png_get_rowbytes(png_ptr, info_ptr);
 
-      row = voidcast(png_bytep,malloc(rowbytes));
-      display = voidcast(png_bytep,malloc(rowbytes));
+      row = malloc(rowbytes);
+      display = malloc(rowbytes);
 
       if (row == NULL || display == NULL)
          png_error(png_ptr, "OOM allocating row buffers");
@@ -120,8 +81,7 @@ static void read_by_row(png_structp png_ptr, png_infop info_ptr,
             png_uint_32 y = height;
 
             /* NOTE: this trashes the row each time; interlace handling won't
-             * work, but this avoids memory thrashing for speed testing and is
-             * somewhat representative of an application that works row-by-row.
+             * work, but this avoids memory thrashing for speed testing.
              */
             while (y-- > 0)
                png_read_row(png_ptr, row, display);
@@ -131,51 +91,9 @@ static void read_by_row(png_structp png_ptr, png_infop info_ptr,
 
    /* Make sure to read to the end of the file: */
    png_read_end(png_ptr, info_ptr);
-
-   /* Free this up: */
+   png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
    free(row);
    free(display);
-}
-
-static PNG_CALLBACK(void, no_warnings, (png_structp png_ptr,
-         png_const_charp warning))
-{
-   (void)png_ptr;
-   (void)warning;
-}
-
-static int read_png(FILE *fp, png_int_32 transforms, FILE *write_file)
-{
-   png_structp png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING,0,0,
-         no_warnings);
-   png_infop info_ptr = NULL;
-
-   if (png_ptr == NULL)
-      return 0;
-
-   if (setjmp(png_jmpbuf(png_ptr)))
-   {
-      png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
-      return 0;
-   }
-
-#  ifdef PNG_BENIGN_ERRORS_SUPPORTED
-      png_set_benign_errors(png_ptr, 1/*allowed*/);
-#  endif
-   png_init_io(png_ptr, fp);
-
-   info_ptr = png_create_info_struct(png_ptr);
-
-   if (info_ptr == NULL)
-      png_error(png_ptr, "OOM allocating info structure");
-
-   if (transforms < 0)
-      read_by_row(png_ptr, info_ptr, write_file, fp);
-
-   else
-      png_read_png(png_ptr, info_ptr, transforms, NULL/*params*/);
-
-   png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
    return 1;
 }
 
@@ -190,7 +108,7 @@ static int mytime(struct timespec *t)
    return 0;
 }
 
-static int perform_one_test(FILE *fp, int nfiles, png_int_32 transforms)
+static int perform_one_test(FILE *fp, int nfiles)
 {
    int i;
    struct timespec before, after;
@@ -202,7 +120,7 @@ static int perform_one_test(FILE *fp, int nfiles, png_int_32 transforms)
    {
       for (i=0; i<nfiles; ++i)
       {
-         if (read_png(fp, transforms, NULL/*write*/))
+         if (read_png(fp))
          {
             if (ferror(fp))
             {
@@ -266,343 +184,120 @@ static int add_one_file(FILE *fp, char *name)
 
    if (ip != NULL)
    {
-      /* Read the file using libpng; this detects errors and also deals with
-       * files which contain data beyond the end of the file.
-       */
-      int ok = 0;
-      fpos_t pos;
-
-      if (fgetpos(fp, &pos))
+      int ch;
+      for (;;)
       {
-         /* Fatal error reading the start: */
-         perror("temporary file");
-         fprintf(stderr, "temporary file fgetpos error\n");
-         exit(1);
+         ch = getc(ip);
+         if (ch == EOF) break;
+         putc(ch, fp);
       }
 
-      if (read_png(ip, -1/*by row*/, fp/*output*/))
+      if (ferror(ip))
       {
-         if (ferror(ip))
-         {
-            perror(name);
-            fprintf(stderr, "%s: read error\n", name);
-         }
-
-         else
-            ok = 1; /* read ok */
+         perror(name);
+         fprintf(stderr, "%s: read error\n", name);
+         return 0;
       }
 
-      else
-         fprintf(stderr, "%s: file not added\n", name);
-
       (void)fclose(ip);
 
-      /* An error in the output is fatal; exit immediately: */
       if (ferror(fp))
       {
          perror("temporary file");
          fprintf(stderr, "temporary file write error\n");
-         exit(1);
-      }
-
-      if (ok)
-         return 1;
-
-      /* Did not read the file successfully, simply rewind the temporary
-       * file.  This must happen after the ferror check above to avoid clearing
-       * the error.
-       */
-      if (fsetpos(fp, &pos))
-      {
-         perror("temporary file");
-         fprintf(stderr, "temporary file fsetpos error\n");
-         exit(1);
+         return 0;
       }
    }
 
    else
    {
-      /* file open error: */
       perror(name);
       fprintf(stderr, "%s: open failed\n", name);
+      return 0;
    }
 
-   return 0; /* file not added */
-}
-
-static void
-usage(FILE *fp)
-{
-   if (fp != NULL) fclose(fp);
-
-   fprintf(stderr,
-"Usage:\n"
-" timepng --assemble <assembly> {files}\n"
-"  Read the files into <assembly>, output the count.  Options are ignored.\n"
-" timepng --dissemble <assembly> <count> [options]\n"
-"  Time <count> files from <assembly>, additional files may not be given.\n"
-" Otherwise:\n"
-"  Read the files into a temporary file and time the decode\n"
-"Transforms:\n"
-"  --by-image: read by image with png_read_png\n"
-"  --<transform>: implies by-image, use PNG_TRANSFORM_<transform>\n"
-"  Otherwise: read by row using png_read_row (to a single row buffer)\n"
-   /* ISO C90 string length max 509 */);fprintf(stderr,
-"{files}:\n"
-"  PNG files to copy into the assembly and time.  Invalid files are skipped\n"
-"  with appropriate error messages.  If no files are given the list of files\n"
-"  is read from stdin with each file name terminated by a newline\n"
-"Output:\n"
-"  For --assemble the output is the name of the assembly file followed by the\n"
-"  count of the files it contains; the arguments for --dissemble.  Otherwise\n"
-"  the output is the total decode time in seconds.\n");
-
-   exit(99);
+   return 1;
 }
 
 int main(int argc, char **argv)
 {
    int ok = 0;
-   int err = 0;
-   int nfiles = 0;
-   int transforms = -1; /* by row */
-   const char *assembly = NULL;
-   FILE *fp;
+   FILE *fp = tmpfile();
 
-   if (argc > 2 && strcmp(argv[1], "--assemble") == 0)
+   if (fp != NULL)
    {
-      /* Just build the test file, argv[2] is the file name. */
-      assembly = argv[2];
-      fp = fopen(assembly, "wb");
-      if (fp == NULL)
+      int err = 0;
+      int nfiles = 0;
+
+      if (argc > 1)
       {
-         perror(assembly);
-         fprintf(stderr, "timepng --assemble %s: could not open for write\n",
-               assembly);
-         usage(NULL);
-      }
+         int i;
 
-      argv += 2;
-      argc -= 2;
-   }
-
-   else if (argc > 3 && strcmp(argv[1], "--dissemble") == 0)
-   {
-      fp = fopen(argv[2], "rb");
-
-      if (fp == NULL)
-      {
-         perror(argv[2]);
-         fprintf(stderr, "timepng --dissemble %s: could not open for read\n",
-               argv[2]);
-         usage(NULL);
-      }
-
-      nfiles = atoi(argv[3]);
-      if (nfiles <= 0)
-      {
-         fprintf(stderr,
-               "timepng --dissemble <file> <count>: %s is not a count\n",
-               argv[3]);
-         exit(99);
-      }
-#ifdef __COVERITY__
-      else
-      {
-         nfiles &= PNG_UINT_31_MAX;
-      }
-#endif
-
-      argv += 3;
-      argc -= 3;
-   }
-
-   else /* Else use a temporary file */
-   {
-#ifndef __COVERITY__
-      fp = 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[] = "timepng-XXXXXX";
-      int filedes;
-      umask(0177);
-      filedes = mkstemp(tmpfile);
-      if (filedes < 0)
-        fp = NULL;
-      else
-      {
-        fp = fdopen(filedes,"w+");
-        /* Hide the filename immediately and ensure that the file does
-         * not exist after the program ends
-         */
-        (void) unlink(tmpfile);
-      }
-#endif
-
-      if (fp == NULL)
-      {
-         perror("tmpfile");
-         fprintf(stderr, "timepng: could not open the temporary file\n");
-         exit(1); /* not a user error */
-      }
-   }
-
-   /* Handle the transforms: */
-   while (argc > 1 && argv[1][0] == '-' && argv[1][1] == '-')
-   {
-      const char *opt = *++argv + 2;
-
-      --argc;
-
-      /* Transforms turn on the by-image processing and maybe set some
-       * transforms:
-       */
-      if (transforms == -1)
-         transforms = PNG_TRANSFORM_IDENTITY;
-
-      if (strcmp(opt, "by-image") == 0)
-      {
-         /* handled above */
-      }
-
-#        define OPT(name) else if (strcmp(opt, #name) == 0)\
-         transforms |= PNG_TRANSFORM_ ## name
-
-      OPT(STRIP_16);
-      OPT(STRIP_ALPHA);
-      OPT(PACKING);
-      OPT(PACKSWAP);
-      OPT(EXPAND);
-      OPT(INVERT_MONO);
-      OPT(SHIFT);
-      OPT(BGR);
-      OPT(SWAP_ALPHA);
-      OPT(SWAP_ENDIAN);
-      OPT(INVERT_ALPHA);
-      OPT(STRIP_FILLER);
-      OPT(STRIP_FILLER_BEFORE);
-      OPT(STRIP_FILLER_AFTER);
-      OPT(GRAY_TO_RGB);
-      OPT(EXPAND_16);
-      OPT(SCALE_16);
-
-      else
-      {
-         fprintf(stderr, "timepng %s: unrecognized transform\n", opt);
-         usage(fp);
-      }
-   }
-
-   /* Handle the files: */
-   if (argc > 1 && nfiles > 0)
-      usage(fp); /* Additional files not valid with --dissemble */
-
-   else if (argc > 1)
-   {
-      int i;
-
-      for (i=1; i<argc; ++i)
-      {
-         if (nfiles == INT_MAX)
+         for (i=1; i<argc; ++i)
          {
-            fprintf(stderr, "%s: skipped, too many files\n", argv[i]);
-            break;
-         }
+            if (add_one_file(fp, argv[i]))
+               ++nfiles;
 
-         else if (add_one_file(fp, argv[i]))
-            ++nfiles;
-      }
-   }
-
-   else if (nfiles == 0) /* Read from stdin withoout --dissemble */
-   {
-      char filename[FILENAME_MAX+1];
-
-      while (fgets(filename, FILENAME_MAX+1, stdin))
-      {
-         size_t len = strlen(filename);
-
-         if (filename[len-1] == '\n')
-         {
-            filename[len-1] = 0;
-            if (nfiles == INT_MAX)
+            else
             {
-               fprintf(stderr, "%s: skipped, too many files\n", filename);
+               err = 1;
                break;
             }
-
-            else if (add_one_file(fp, filename))
-               ++nfiles;
-         }
-
-         else
-         {
-            fprintf(stderr, "timepng: file name too long: ...%s\n",
-               filename+len-32);
-            err = 1;
-            break;
          }
       }
 
-      if (ferror(stdin))
+      else
       {
-         fprintf(stderr, "timepng: stdin: read error\n");
-         err = 1;
-      }
-   }
+         char filename[FILENAME_MAX+1];
 
-   /* Perform the test, or produce the --assemble output: */
-   if (!err)
-   {
-      if (nfiles > 0)
-      {
-         if (assembly != NULL)
+         while (fgets(filename, FILENAME_MAX+1, stdin))
          {
-            if (fflush(fp) && !ferror(fp) && fclose(fp))
+            size_t len = strlen(filename);
+
+            if (filename[len-1] == '\n')
             {
-               perror(assembly);
-               fprintf(stderr, "%s: close failed\n", assembly);
+               filename[len-1] = 0;
+               if (add_one_file(fp, filename))
+                  ++nfiles;
+
+               else
+               {
+                  err = 1;
+                  break;
+               }
             }
 
             else
             {
-               printf("%s %d\n", assembly, nfiles);
-               fflush(stdout);
-               ok = !ferror(stdout);
+               fprintf(stderr, "timepng: truncated file name ...%s\n",
+                  filename+len-32);
+               err = 1;
+               break;
             }
          }
 
-         else
+         if (ferror(stdin))
          {
-            ok = perform_one_test(fp, nfiles, transforms);
-            (void)fclose(fp);
+            fprintf(stderr, "timepng: stdin: read error\n");
+            err = 1;
          }
       }
 
-      else
-         usage(fp);
+      if (!err)
+      {
+         if (nfiles > 0)
+            ok = perform_one_test(fp, nfiles);
+
+         else
+            fprintf(stderr, "usage: timepng {files} or ls files | timepng\n");
+      }
+
+      (void)fclose(fp);
    }
 
    else
-      (void)fclose(fp);
+      fprintf(stderr, "timepng: could not open temporary file\n");
 
    /* Exit code 0 on success. */
    return ok == 0;
 }
-#else /* !sufficient support */
-int main(void) { return 77; }
-#endif /* !sufficient support */

contrib/mips-msa/README

@@ -1,83 +0,0 @@
-OPERATING SYSTEM SPECIFIC MIPS MSA DETECTION
---------------------------------------------
-
-Detection of the ability to execute MIPS MSA on an MIPS processor requires
-operating system support.  (The information is not available in user mode.)
-
-HOW TO USE THIS
----------------
-
-This directory contains C code fragments that can be included in mips/mips_init.c
-by setting the macro PNG_MIPS_MSA_FILE to the file name in "" or <> at build
-time.  This setting is not recorded in pnglibconf.h and can be changed simply by
-rebuilding mips/msa_init.o with the required macro definition.
-
-For any of this code to be used the MIPS MSA code must be enabled and run time
-checks must be supported.  I.e.:
-
-#if PNG_MIPS_MSA_OPT > 0
-#ifdef PNG_MIPS_MSA_CHECK_SUPPORTED
-
-This is done in a 'configure' build by passing configure the argument:
-
-   --enable-mips-msa=check
-
-Apart from the basic Linux implementation in contrib/mips-msa/linux.c this code
-is unsupported.  That means that it is not even compiled on a regular basis and
-may be broken in any given minor release.
-
-FILE FORMAT
------------
-
-Each file documents its testing status as of the last time it was tested (which
-may have been a long time ago):
-
-STATUS: one of:
-   SUPPORTED: This indicates that the file is included in the regularly
-         performed test builds and bugs are fixed when discovered.
-   COMPILED: This indicates that the code did compile at least once.  See the
-         more detailed description for the extent to which the result was
-         successful.
-   TESTED: This means the code was fully compiled into the libpng test programs
-         and these were run at least once.
-
-BUG REPORTS: an email address to which to send reports of problems
-
-The file is a fragment of C code. It should not define any 'extern' symbols;
-everything should be static.  It must define the function:
-
-static int png_have_msa(png_structp png_ptr);
-
-That function must return 1 if MIPS MSA instructions are supported, 0 if not.
-It must not execute png_error unless it detects a bug.  A png_error will prevent
-the reading of the PNG and in the future, writing too.
-
-BUG REPORTS
------------
-
-If you mail a bug report for any file that is not SUPPORTED there may only be
-limited response.  Consider fixing it and sending a patch to fix the problem -
-this is more likely to result in action.
-
-CONTRIBUTIONS
--------------
-
-You may send contributions of new implementations to
-png-mng-implement@sourceforge.net.  Please write code in strict C90 C where
-possible.  Obviously OS dependencies are to be expected.  If you submit code you
-must have the authors permission and it must have a license that is acceptable
-to the current maintainer; in particular that license must permit modification
-and redistribution.
-
-Please try to make the contribution a single file and give the file a clear and
-unambiguous name that identifies the target OS.  If multiple files really are
-required put them all in a sub-directory.
-
-You must also be prepared to handle bug reports from users of the code, either
-by joining the png-mng-implement mailing list or by providing an email for the
-"BUG REPORTS" entry or both.  Please make sure that the header of the file
-contains the STATUS and BUG REPORTS fields as above.
-
-Please list the OS requirements as precisely as possible.  Ideally you should
-also list the environment in which the code has been tested and certainly list
-any environments where you suspect it might not work.

contrib/mips-msa/linux.c

@@ -1,64 +0,0 @@
-/* contrib/mips-msa/linux.c
- *
- * Copyright (c) 2016 Glenn Randers-Pehrson
- * Written by Mandar Sahastrabuddhe, 2016.
- * Last changed in libpng 1.6.25beta03 [August 29, 2016]
- *
- * This code is released under the libpng license.
- * For conditions of distribution and use, see the disclaimer
- * and license in png.h
- *
- * SEE contrib/mips-msa/README before reporting bugs
- *
- * STATUS: SUPPORTED
- * BUG REPORTS: png-mng-implement@sourceforge.net
- *
- * png_have_msa implemented for Linux by reading the widely available
- * pseudo-file /proc/cpuinfo.
- *
- * This code is strict ANSI-C and is probably moderately portable; it does
- * however use <stdio.h> and it assumes that /proc/cpuinfo is never localized.
- */
-
-#include <stdio.h>
-#include <string.h>
-#include <stdlib.h>
-
-static int
-png_have_msa(png_structp png_ptr)
-{
-   FILE *f = fopen("/proc/cpuinfo", "rb");
-
-   char *string = "msa";
-   char word[10];
-
-   if (f != NULL)
-   {
-      while(!feof(f))
-      {
-         int ch = fgetc(f);
-         static int i = 0;
-
-         while(!(ch <= 32))
-         {
-            word[i++] = ch;
-            ch = fgetc(f);
-         }
-
-         int val = strcmp(string, word);
-
-         if (val == 0)
-            return 1;
-
-         i = 0;
-         memset(word, 0, 10);
-      }
-
-      fclose(f);
-   }
-#ifdef PNG_WARNINGS_SUPPORTED
-   else
-      png_warning(png_ptr, "/proc/cpuinfo open failed");
-#endif
-   return 0;
-}

contrib/pngminim/decoder/makefile

@@ -15,7 +15,7 @@ RM=rm -f
 COPY=cp
 
 CPPFLAGS=-I. -DPNG_USER_CONFIG -DNO_GZCOMPRESS -DZ_SOLO -DNO_GZIP
-CFLAGS=-O1 -Wall
+CFLAGS=-O1
 
 C=.c
 O=.o
@@ -82,7 +82,7 @@ OBJS    = $(PROGOBJS) $(PNGOBJS) $(ZOBJS)
 
 # note: dependencies do not work on implicit rule lines
 .c$(O):
-	$(CC) -c $(CPPFLAGS) $(CFLAGS) $<
+	$(CC) $(CPPFLAGS) -c $(CFLAGS) $<
 
 # dependencies
 
@@ -100,12 +100,12 @@ $(PNGCONF): $(PNGSRC)/scripts/pnglibconf.mak $(ZH)\
 	$(PNGSRC)/scripts/pnglibconf.dfa \
 	$(PNGSRC)/scripts/options.awk pngusr.h pngusr.dfa
 	$(RM) pnglibconf.h pnglibconf.dfn
-	$(MAKE) -f $(PNGSRC)/scripts/pnglibconf.mak $(MAKEFLAGS)\
+	$(MAKE) $(MAKEFLAGS) -f $(PNGSRC)/scripts/pnglibconf.mak\
 	    srcdir=$(PNGSRC) CPPFLAGS="-DPNG_USER_CONFIG -I."\
 	    DFA_XTRA="pngusr.dfa" $@
 
 clean:
-	$(MAKE) -f $(PNGSRC)/scripts/pnglibconf.mak $(MAKEFLAGS)\
+	$(MAKE) $(MAKEFLAGS) -f $(PNGSRC)/scripts/pnglibconf.mak\
 	    srcdir=$(PNGSRC) clean
 	$(RM) pngm2pnm$(O)
 	$(RM) pngm2pnm$(E)

contrib/pngminim/decoder/pngusr.h

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

contrib/pngminim/encoder/makefile

@@ -15,7 +15,7 @@ RM=rm -f
 COPY=cp
 
 CPPFLAGS=-I. -DPNG_USER_CONFIG -DNO_GZCOMPRESS -DZ_SOLO -DNO_GZIP
-CFLAGS=-O1 -Wall
+CFLAGS=-O1
 
 C=.c
 O=.o
@@ -81,7 +81,7 @@ OBJS    = $(PROGOBJS) $(PNGOBJS) $(ZOBJS)
 # implicit make rules -------------------------------------------------------
 
 .c$(O):
-	$(CC) -c $(CPPFLAGS) $(CFLAGS) $<
+	$(CC) $(CPPFLAGS) -c $(CFLAGS) $<
 
 # dependencies
 
@@ -99,12 +99,12 @@ $(PNGCONF): $(PNGSRC)/scripts/pnglibconf.mak $(ZH)\
 	$(PNGSRC)/scripts/pnglibconf.dfa \
 	$(PNGSRC)/scripts/options.awk pngusr.h pngusr.dfa
 	$(RM) pnglibconf.h pnglibconf.dfn
-	$(MAKE) -f $(PNGSRC)/scripts/pnglibconf.mak $(MAKEFLAGS)\
+	$(MAKE) $(MAKEFLAGS) -f $(PNGSRC)/scripts/pnglibconf.mak\
 	    srcdir=$(PNGSRC) CPPFLAGS="-DPNG_USER_CONFIG -I."\
 	    DFA_XTRA="pngusr.dfa" $@
 
 clean:
-	$(MAKE) -f $(PNGSRC)/scripts/pnglibconf.mak $(MAKEFLAGS)\
+	$(MAKE) $(MAKEFLAGS) -f $(PNGSRC)/scripts/pnglibconf.mak\
 	    srcdir=$(PNGSRC) clean
 	$(RM) pnm2pngm$(O)
 	$(RM) pnm2pngm$(E)

contrib/pngminim/encoder/pngusr.dfa

@@ -13,10 +13,9 @@ everything = off
 # Switch on the write code - this makes a minimalist encoder
 
 option WRITE on
-
-# These 2 options are required if you need to read PBM (P1 or P4) files.
-option WRITE_INVERT on
-option WRITE_PACK on
+# These 2 options are required if you need to read PGM (P1 or P4) PGM files.
+# option WRITE_INVERT on
+# option WRITE_PACK on
 
 # You must choose fixed or floating point arithmetic:
 # option FLOATING_POINT on

contrib/pngminim/encoder/pngusr.h

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

contrib/pngminim/preader/makefile

@@ -31,7 +31,7 @@ XLIB = -L/usr/X11R6/lib -lX11
 LIBS = $(XLIB) -lm                      #platforms that need libm
 
 CPPFLAGS=-I. $(XINC) -DPNG_USER_CONFIG -DNO_GZCOMPRESS -DZ_SOLO -DNO_GZIP
-CFLAGS=-O1 -Wall
+CFLAGS=-O1
 
 C=.c
 O=.o
@@ -97,7 +97,7 @@ OBJS    = $(PROGOBJS) $(PNGOBJS) $(ZOBJS)
 # implicit make rules -------------------------------------------------------
 
 .c$(O):
-	$(CC) -c $(CPPFLAGS) $(CFLAGS) $<
+	$(CC) $(CPPFLAGS) -c $(CFLAGS) $<
 
 # dependencies
 
@@ -115,12 +115,12 @@ $(PNGCONF): $(PNGSRC)/scripts/pnglibconf.mak $(ZH)\
 	$(PNGSRC)/scripts/pnglibconf.dfa \
 	$(PNGSRC)/scripts/options.awk pngusr.h pngusr.dfa
 	$(RM) pnglibconf.h pnglibconf.dfn
-	$(MAKE) -f $(PNGSRC)/scripts/pnglibconf.mak $(MAKEFLAGS)\
+	$(MAKE) $(MAKEFLAGS) -f $(PNGSRC)/scripts/pnglibconf.mak\
 	    srcdir=$(PNGSRC) CPPFLAGS="-DPNG_USER_CONFIG -I."\
 	    DFA_XTRA="pngusr.dfa" $@
 
 clean:
-	$(MAKE) -f $(PNGSRC)/scripts/pnglibconf.mak $(MAKEFLAGS)\
+	$(MAKE) $(MAKEFLAGS) -f $(PNGSRC)/scripts/pnglibconf.mak\
 	    srcdir=$(PNGSRC) clean
 	$(RM) rpng2-x$(O)
 	$(RM) rpng2-x$(E)

contrib/pngminim/preader/pngusr.h

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

contrib/pngminus/README

@@ -146,7 +146,7 @@ The Turbo bug
 The end
 -------
 Willem van Schaik
-mailto:willem at schaik.com
+mailto:willem@schaik.com
 http://www.schaik.com/png/
 -------
 Oct 1999

contrib/pngminus/makefile.std

@@ -23,8 +23,7 @@ ZINC = -I../../../zlib
 ZLIB = -L../../../zlib -lz
 ZLIBS = ../../../zlib/libz.a
 
-CPPFLAGS=$(PNGINC) $(ZINC)
-CFLAGS=
+CFLAGS=$(PNGINC) $(ZINC)
 LDLIBS=$(PNGLIB) $(ZLIB)
 LDLIBSS=$(PNGLIBS) $(ZLIBS)
 C=.c
@@ -38,7 +37,7 @@ E=
 all: png2pnm$(E) pnm2png$(E) png2pnm-static$(E) pnm2png-static$(E)
 
 png2pnm$(O): png2pnm$(C)
-	$(CC) -c $(CPPFLAGS) $(CFLAGS) png2pnm$(C)
+	$(CC) -c $(CFLAGS) png2pnm$(C)
 
 png2pnm$(E): png2pnm$(O)
 	$(LD) $(LDFLAGS) -o png2pnm$(E) png2pnm$(O) $(LDLIBS) -lm
@@ -47,7 +46,7 @@ png2pnm-static$(E): png2pnm$(O)
 	$(LD) $(LDFLAGS) -o png2pnm-static$(E) png2pnm$(O) $(LDLIBSS) -lm
 
 pnm2png$(O): pnm2png$(C)
-	$(CC) -c $(CPPFLAGS) $(CFLAGS) pnm2png$(C)
+	$(CC) -c $(CFLAGS) pnm2png$(C)
 
 pnm2png$(E): pnm2png$(O)
 	$(LD) $(LDFLAGS) -o pnm2png$(E) pnm2png$(O) $(LDLIBS) -lm

contrib/pngminus/makefile.tc3

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

contrib/pngminus/png2pnm.c

@@ -1,6 +1,6 @@
 /*
  *  png2pnm.c --- conversion from PNG-file to PGM/PPM-file
- *  copyright (C) 1999 by Willem van Schaik <willem at schaik.com>
+ *  copyright (C) 1999 by Willem van Schaik <willem@schaik.com>
  *
  *  version 1.0 - 1999.10.15 - First version.
  *
@@ -52,8 +52,7 @@
 
 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
@@ -86,8 +85,7 @@ 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;
@@ -178,11 +176,9 @@ 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");
 }
 
@@ -190,8 +186,7 @@ void usage()
  *  png2pnm
  */
 
-BOOL png2pnm (FILE *png_file, FILE *pnm_file, FILE *alpha_file,
-    volatile BOOL raw, BOOL alpha)
+BOOL png2pnm (FILE *png_file, FILE *pnm_file, FILE *alpha_file, BOOL raw, BOOL alpha)
 {
   png_struct    *png_ptr = NULL;
   png_info        *info_ptr = NULL;
@@ -223,7 +218,7 @@ BOOL png2pnm (FILE *png_file, FILE *pnm_file, FILE *alpha_file,
 
   /* create png and info structures */
 
-  png_ptr = png_create_read_struct (png_get_libpng_ver(NULL),
+  png_ptr = png_create_read_struct (PNG_LIBPNG_VER_STRING,
     NULL, NULL, NULL);
   if (!png_ptr)
     return FALSE;   /* out of memory */
@@ -266,7 +261,7 @@ BOOL png2pnm (FILE *png_file, FILE *pnm_file, FILE *alpha_file,
     png_set_expand (png_ptr);
 
 #ifdef NJET
-  /* downgrade 16-bit images to 8-bit */
+  /* downgrade 16-bit images to 8 bit */
   if (bit_depth == 16)
     png_set_strip_16 (png_ptr);
   /* transform grayscale images into full-color */
@@ -320,14 +315,12 @@ BOOL png2pnm (FILE *png_file, FILE *pnm_file, FILE *alpha_file,
   /* 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);
@@ -336,7 +329,7 @@ BOOL png2pnm (FILE *png_file, FILE *pnm_file, FILE *alpha_file,
   }
 
   /* set the individual row_pointers to point at the correct offsets */
-  for (i = 0; i < ((int) height); i++)
+  for (i = 0; i < (height); i++)
     row_pointers[i] = png_pixels + i * row_bytes;
 
   /* now we can go ahead and just read the whole image */
@@ -379,9 +372,9 @@ BOOL png2pnm (FILE *png_file, FILE *pnm_file, FILE *alpha_file,
   /* write data to PNM file */
   pix_ptr = png_pixels;
 
-  for (row = 0; row < (int) height; row++)
+  for (row = 0; row < height; row++)
   {
-    for (col = 0; col < (int) width; col++)
+    for (col = 0; col < width; col++)
     {
       for (i = 0; i < (channels - alpha_present); i++)
       {

contrib/pngminus/pnm2png.c

@@ -1,9 +1,8 @@
 /*
  *  pnm2png.c --- conversion from PBM/PGM/PPM-file to PNG-file
- *  copyright (C) 1999 by Willem van Schaik <willem at schaik.com>
+ *  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,
@@ -51,8 +50,7 @@
 
 int  main (int argc, char *argv[]);
 void usage ();
-BOOL pnm2png (FILE *pnm_file, FILE *png_file, FILE *alpha_file, BOOL interlace,
-    BOOL alpha);
+BOOL pnm2png (FILE *pnm_file, FILE *png_file, FILE *alpha_file, BOOL interlace, BOOL alpha);
 void get_token(FILE *pnm_file, char *token);
 png_uint_32 get_data (FILE *pnm_file, int depth);
 png_uint_32 get_value (FILE *pnm_file, int depth);
@@ -178,8 +176,7 @@ void usage()
   fprintf (stderr, "   or:  ... | pnm2png [options]\n");
   fprintf (stderr, "Options:\n");
   fprintf (stderr, "   -i[nterlace]   write png-file with interlacing on\n");
-  fprintf (stderr,
-      "   -a[lpha] <file>.pgm read PNG alpha channel as pgm-file\n");
+  fprintf (stderr, "   -a[lpha] <file>.pgm read PNG alpha channel as pgm-file\n");
   fprintf (stderr, "   -h | -?  print this help-information\n");
 }
 
@@ -187,31 +184,30 @@ void usage()
  *  pnm2png
  */
 
-BOOL pnm2png (FILE *pnm_file, FILE *png_file, FILE *alpha_file, BOOL interlace,
-     BOOL alpha)
+BOOL pnm2png (FILE *pnm_file, FILE *png_file, FILE *alpha_file, BOOL interlace, BOOL alpha)
 {
   png_struct    *png_ptr = NULL;
   png_info      *info_ptr = NULL;
   png_byte      *png_pixels = NULL;
   png_byte      **row_pointers = NULL;
   png_byte      *pix_ptr = NULL;
-  volatile png_uint_32   row_bytes;
+  png_uint_32   row_bytes;
 
   char          type_token[16];
   char          width_token[16];
   char          height_token[16];
   char          maxval_token[16];
-  volatile int    color_type=1;
+  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;
+  png_uint_32   width, alpha_width;
+  png_uint_32   height, alpha_height;
   png_uint_32   maxval;
-  volatile int           bit_depth = 0;
-  int           channels=0;
+  int           bit_depth = 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 +353,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;
 
@@ -373,24 +367,23 @@ BOOL pnm2png (FILE *pnm_file, FILE *png_file, FILE *alpha_file, BOOL interlace,
     /* row_bytes is the width x number of channels x (bit-depth / 8) */
     row_bytes = width * channels * ((bit_depth <= 8) ? 1 : 2);
 
-  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)
     return FALSE;
 
   /* read data from PNM file */
   pix_ptr = png_pixels;
 
-  for (row = 0; row < (int) height; row++)
+  for (row = 0; row < height; row++)
   {
 #if defined(PNG_WRITE_INVERT_SUPPORTED) || defined(PNG_WRITE_PACK_SUPPORTED)
     if (packed_bitmap) {
-      for (i = 0; i < (int) row_bytes; i++)
+      for (i = 0; i < row_bytes; i++)
         /* png supports this format natively so no conversion is needed */
         *pix_ptr++ = get_data (pnm_file, 8);
     } else
 #endif
     {
-      for (col = 0; col < (int) width; col++)
+      for (col = 0; col < width; col++)
       {
         for (i = 0; i < (channels - alpha_present); i++)
         {
@@ -428,20 +421,15 @@ BOOL pnm2png (FILE *pnm_file, FILE *png_file, FILE *alpha_file, BOOL interlace,
   } /* end for row */
 
   /* prepare the standard PNG structures */
-  png_ptr = png_create_write_struct (png_get_libpng_ver(NULL), NULL, NULL,
-      NULL);
+  png_ptr = png_create_write_struct (PNG_LIBPNG_VER_STRING, NULL, NULL, 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 +444,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;
   }
 
@@ -476,28 +462,25 @@ BOOL pnm2png (FILE *pnm_file, FILE *png_file, FILE *alpha_file, BOOL interlace,
   /* if needed we will allocate memory for an new array of row-pointers */
   if (row_pointers == (unsigned char**) NULL)
   {
-    if ((row_pointers = (png_byte **)
-        malloc (height * sizeof (png_bytep))) == NULL)
+    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;
     }
   }
 
   /* set the individual row_pointers to point at the correct offsets */
-  for (i = 0; i < (int) height; i++)
+  for (i = 0; i < (height); i++)
     row_pointers[i] = png_pixels + i * row_bytes;
 
   /* write out the entire image data in one call */
   png_write_image (png_ptr, row_pointers);
 
-  /* write the additional chunks to the PNG file (not really needed) */
+  /* write the additional chuncks to the PNG file (not really needed) */
   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);

contrib/pngsuite/README

@@ -1,8 +1,8 @@
 
 pngsuite
 --------
-Copyright (c) Willem van Schaik, 1999, 2011, 2012
-Two images (ftbbn0g01.png and ftbbn0g02.png) are by Glenn Randers-Pehrson, 2012
+(c) Willem van Schaik, 1999, 2011, 2012
+Two images are by Glenn Randers-Pehrson, 2012
 
 Permission to use, copy, modify, and distribute these images for any
 purpose and without fee is hereby granted.
@@ -101,5 +101,5 @@ Testing basn6a16.png: PASS (1072 zero samples)
 libpng passes test
 
 Willem van Schaik
-<willem at schaik.com>
+<willem@schaik.com>
 October 1999