[master] Imported from libpng-1.2.41beta19.tar

These functions won't be exported until libpng-1.4.0

ANNOUNCE

@@ -1,49 +1,167 @@
 
-Libpng 1.6.2 - April 25, 2013
+Libpng 1.2.41beta19 - November 12, 2009
 
-This is a public release of libpng, intended for use in production codes.
+This is not intended to be a public release.  It will be replaced
+within a few weeks by a public version or by another test version.
 
 Files available for download:
 
 Source files with LF line endings (for Unix/Linux) and with a
 "configure" script
 
-   libpng-1.6.2.tar.xz (LZMA-compressed, recommended)
-   libpng-1.6.2.tar.gz
+   libpng-1.2.41beta19.tar.xz (LZMA-compressed, recommended)
+   libpng-1.2.41beta19.tar.gz
+   libpng-1.2.41beta19.tar.bz2
+
+Source files with LF line endings (for Unix/Linux) without the
+"configure" script
+
+   libpng-1.2.41beta19-no-config.tar.xz (LZMA-compressed, recommended)
+   libpng-1.2.41beta19-no-config.tar.gz
+   libpng-1.2.41beta19-no-config.tar.bz2
 
 Source files with CRLF line endings (for Windows), without the
 "configure" script
 
-   lpng162.7z  (LZMA-compressed, recommended)
-   lpng162.zip
+   lp1241b19.zip
+   lp1241b19.7z
+   lp1241b19.tar.bz2
+
+Project files
+
+   libpng-1.2.41beta19-project-netware.zip
+   libpng-1.2.41beta19-project-wince.zip
 
 Other information:
 
-   libpng-1.6.2-README.txt
-   libpng-1.6.2-LICENSE.txt
+   libpng-1.2.41beta19-README.txt
+   libpng-1.2.41beta19-KNOWNBUGS.txt
+   libpng-1.2.41beta19-LICENSE.txt
+   libpng-1.2.41beta19-Y2K-compliance.txt
+   libpng-1.2.41beta19-[previous version]-diff.txt
 
-Changes since the last public release (1.6.1):
+Changes since the last public release (1.2.40):
 
-  Updated documentation of 1.5.x to 1.6.x changes in iCCP chunk handling.
-  Fixed incorrect warning of excess deflate data. End condition - the
-    warning would be produced if the end of the deflate stream wasn't read
-    in the last row.  The warning is harmless.
-  Corrected the test on user transform changes on read. It was in the
-    png_set of the transform function, but that doesn't matter unless the
-    transform function changes the rowbuf size, and that is only valid if
-    transform_info is called.
-  Corrected a misplaced closing bracket in contrib/libtests/pngvalid.c
-    (Flavio Medeiros).
-  Corrected length written to uncompressed iTXt chunks (Samuli Suominen).
-  Added contrib/tools/fixitxt.c, to repair the erroneous iTXt chunk length
-    written by libpng-1.6.0 and 1.6.1.
-  Disallow storing sRGB information when the sRGB is not supported.
-  Merge pngtest.c with libpng-1.7.0
+version 1.2.41beta01 [September 25, 2009]
+  Moved redundant IHDR checking into new png_check_IHDR() in png.c
+    and report all errors found in the IHDR data.
+  Eliminated useless call to png_check_cHRM() from pngset.c
+  Expanded TAB characters in pngrtran.c
+
+version 1.2.41beta02 [September 30, 2009]
+  Revised png_check_IHDR().
+
+version 1.2.41beta03 [October 1, 2009]
+  Revised png_check_IHDR() again, to check info_ptr members instead of
+    the contents of the returned parameters.
+
+version 1.2.41beta04 [October 7, 2009]
+  Added "xcode" project similar one already in libpng-1.4.0beta (Alam Arias).
+  Ported some cosmetic changes from libpng-1.4.0beta86.
+  Eliminated a shadowed declaration of "pp" in png_handle_sPLT().
+
+version 1.2.41beta05 [October 17, 2009]
+  Revised pngconf.h to make it easier to enable iTXt support.  From libpng
+    version 1.2.9 through 1.2.40, defining PNG_iTXt_SUPPORTED did not work
+    as expected.
+  Ported some cosmetic changes from libpng-1.4.0beta87, changing
+    many "#if defined(x)" to "#ifdef x".
+
+version 1.2.41beta06 [October 18, 2009]
+  Restored PNG_USE_LOCAL_ARRAYS code in pngread.c that was inadvertently
+    deleted in libpng-1.2.41beta05.
+  Converted all PNG_NO_* tests to PNG_*_SUPPORTED everywhere except pngconf.h
+    as in libpng-1.4.0beta78 and later.
+
+version 1.2.41beta07 [October 21, 2009]
+  Ported some cosmetic changes from libpng-1.4.0rc01, changing
+    many "#if defined(x)" to "#ifdef x" in png.h and pngconf.h.
+
+version 1.2.41beta08 [October 30, 2009]
+  Ported from libpng-1.4.0rc01: png_calloc(), png_get_io_chunk_name(),
+    png_get_io_state(), png_set_user_cache_max(), png_get_user_cache_max(),
+    png_set_premultiply_alpha, and png_do_read_premultiply_alpha().
+  Relocated png_do_chop() ahead of building gamma tables in pngrtran.c
+    This avoids building 16-bit gamma tables unnecessarily.
+
+version 1.2.41beta09 [November 1, 2009]
+  Removed a harmless extra png_set_invert_alpha() from pngwrite.c
+  More bugfixes and improvements to CMakeLists.txt (Philip Lowman)
+  Moved CMakeLists.txt from scripts into the main libpng directory.
+  Apply png_user_chunk_cache_max within png_decompress_chunk().
+  Merged libpng-1.2.41.txt with libpng-1.4.0.txt where appropriate.
+
+version 1.2.41beta10 [November 1, 2009]
+  Enabled iTXt support by default. To ensure binary compatibility with
+    previous versions, the "lang" and "lang_key" members will be assumed
+    to be omitted from previous versions unless the current libpng
+    version was built with PNG_iTXt_SUPPORTED (which is otherwise no
+    longer necessary to gain iTXt support), as a signal that the user has
+    been building previous versions with PNG_iTXt_SUPPORTED as well.
+
+version 1.2.41beta11 [November 2, 2009]
+  Store user's user_png_ver in new png_ptr->user_png_ver element.
+  Revised iTXt support. To ensure binary compatibility with
+    previous versions, the "lang" and "lang_key" members will be assumed
+    to be omitted from versions prior to 1.2.41beta11 whenever there is a
+    library mismatch.
+
+version 1.2.41beta12 [November 2, 2009]
+  Free png_ptr->user_png_ver when destroying png_ptr.
+
+version 1.2.41beta13 [November 3, 2009]
+  Updated scripts/pngw32.def and projects/wince/png32ce.def
+  Copied projects/wince/png32ce.def to the scripts directory.
+  Added scripts/makefile.wce
+  Patched ltmain.sh for wince support.
+  Added PNG_CONVERT_tIME_SUPPORTED macro.
+
+version 1.2.41beta14 [November 8, 2009]
+  versions 1.2.41beta05 through 1.2.41beta13 were abandoned.
+  Make inclusion of time.h in pngconf.h depend on PNG_CONVERT_tIME_SUPPORTED
+  Make #define PNG_CONVERT_tIME_SUPPORTED depend on PNG_WRITE_tIME_SUPPORTED
+  Reverted iTXt compatibility stuff from 1.2.41beta05, 1.2.41beta11, and
+    1.2.41beta12.
+  Reverted IOSTATE feature, user_cache_max, and premultiply_alpha features
+    from 1.2.41beta08.
+  Retained png_calloc() from 1.2.41beta08 but as a non-exported function,
+    and removed reference to png_calloc from scripts/*.def
+
+version 1.2.41beta15 [November 8, 2009]
+  Added PNG_DEPSTRUCT, PNG_DEPRECATED, PNG_USE_RESULT, PNG_NORETURN, and
+    PNG_ALLOCATED macros to detect deprecated direct access to the
+    png_struct or info_struct members and other deprecated usage in
+    applications (John Bowler).
+  Updated scripts/makefile* to add "-DPNG_CONFIGURE_LIBPNG" to CFLAGS,
+    to prevent warnings about direct access to png structs by libpng
+    functions while building libpng.  They need to be tested, especially
+    those using compilers other than gcc.
+  Updated projects/visualc6 and visualc71 with "/d PNG_CONFIGURE_LIBPNG".
+
+version 1.2.41beta16 [November 9, 2009]
+  Removed three direct references to read_info_ptr members in pngtest.c
+    that were detected by the new PNG_DEPSTRUCT macro.
+  Only #define PNG_DEPSTRUCT, etc. in pngconf.h if not already defined.
+
+version 1.2.41beta17 [November 10, 2009]
+  Updated CMakeLists.txt to add "-DPNG_CONFIGURE_LIBPNG" to the definitions.
+  Marked deprecated function prototypes with PNG_DEPRECATED.
+  Marked memory allocation function prototypes with PNG_ALLOCATED.
+  Changed png_check_sig() to !png_sig_cmp() in contrib programs.
+  Corrected the png_get_IHDR() call in contrib/gregbook/readpng2.c
+  Added "-DPNG_CONFIGURE_LIBPNG" to the contrib/pngminum makefiles.
+
+version 1.2.41beta18 [November 11, 2009]
+  Renamed scripts/makefile.wce to scripts/makefile.cegcc
+  Marked nonexported functions with PNG_PRIVATE macro.
+
+version 1.2.41beta19 [November 12, 2009]
+  Revised scripts/*.def to reflect functions actually exported by libpng.
 
 Send comments/corrections/commendations to png-mng-implement at lists.sf.net
+
 (subscription required; visit
 https://lists.sourceforge.net/lists/listinfo/png-mng-implement
-to subscribe)
-or to glennrp at users.sourceforge.net
+to subscribe) or to glennrp at users.sourceforge.net
 
 Glenn R-P

CMakeLists.txt

@@ -1,60 +1,43 @@
-# CMakeLists.txt
+cmake_minimum_required(VERSION 2.4.3)
+if(UNIX AND NOT DEFINED CMAKE_BUILD_TYPE)
+   set(CMAKE_BUILD_TYPE "RelWithDebInfo" CACHE STRING "Choose the type of
+   build, options are: None(CMAKE_CXX_FLAGS or CMAKE_C_FLAGS used) Debug
+   Release RelWithDebInfo MinSizeRel.")
+endif()
 
-# Copyright (C) 2007-2011 Glenn Randers-Pehrson
+project(PNG C)
+enable_testing()
+
+# Copyright (C) 2007 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.4.4)
-set(CMAKE_ALLOW_LOOSE_LOOP_CONSTRUCTS true)
-
-if(UNIX AND NOT DEFINED CMAKE_BUILD_TYPE)
-  if(CMAKE_MAJOR_VERSION EQUAL 2 AND CMAKE_MINOR_VERSION EQUAL 4)
-    # workaround CMake 2.4.x bug
-    set(CMAKE_BUILD_TYPE "RelWithDebInfo" CACHE STRING
-        "Choose the type of build, options are:
-           None(CMAKE_CXX_FLAGS or CMAKE_C_FLAGS used)
-           Debug
-           Release
-           RelWithDebInfo
-           MinSizeRel.")
-  else()
-    set(CMAKE_BUILD_TYPE "RelWithDebInfo" CACHE STRING
-        "Choose the type of build, options are:
-           None(CMAKE_CXX_FLAGS or CMAKE_C_FLAGS used)
-           Debug
-           Release
-           RelWithDebInfo
-           MinSizeRel.")
-  endif()
-endif()
-
-project(libpng C)
-enable_testing()
-
 set(PNGLIB_MAJOR 1)
-set(PNGLIB_MINOR 6)
-set(PNGLIB_RELEASE 2)
+set(PNGLIB_MINOR 2)
+set(PNGLIB_RELEASE 41)
 set(PNGLIB_NAME libpng${PNGLIB_MAJOR}${PNGLIB_MINOR})
 set(PNGLIB_VERSION ${PNGLIB_MAJOR}.${PNGLIB_MINOR}.${PNGLIB_RELEASE})
 
+set(CMAKE_ALLOW_LOOSE_LOOP_CONSTRUCTS true)
+
 # needed packages
 find_package(ZLIB REQUIRED)
 include_directories(${ZLIB_INCLUDE_DIR})
 
 if(NOT WIN32)
-  find_library(M_LIBRARY
-    NAMES m
-    PATHS /usr/lib /usr/local/lib
-  )
-  if(NOT M_LIBRARY)
-    message(STATUS
-      "math library 'libm' not found - floating point support disabled")
-  endif()
+ find_library(M_LIBRARY
+     NAMES m
+     PATHS /usr/lib /usr/local/lib
+ )
+ if(NOT M_LIBRARY)
+   message(STATUS
+     "math library 'libm' not found - floating point support disabled")
+ endif()
 else()
-  # not needed on windows
-  set(M_LIBRARY "")
+ # not needed on windows
+ set(M_LIBRARY "")
 endif()
 
 # COMMAND LINE OPTIONS
@@ -69,11 +52,38 @@ else()
   option(PNG_STATIC "Build static lib" ON)
 endif()
 
-option(PNG_TESTS  "Build libpng tests" YES)
+if(MINGW)
+  option(PNG_TESTS  "Build pngtest" NO)
+else(MINGW)
+  option(PNG_TESTS  "Build pngtest" YES)
+endif(MINGW)
 
-# Many more configuration options could be added here
+option(PNG_NO_CONSOLE_IO "FIXME" YES)
+option(PNG_NO_STDIO      "FIXME" YES)
 option(PNG_DEBUG         "Build with debug output" NO)
-option(PNGARG            "Disable ANSI-C prototypes" NO)
+option(PNGARG            "FIXME" YES)
+#TODO:
+# PNG_CONSOLE_IO_SUPPORTED
+
+# maybe needs improving, but currently I don't know when we can enable what :)
+set(png_asm_tmp "OFF")
+if(NOT WIN32)
+ find_program(uname_executable NAMES uname PATHS /bin /usr/bin /usr/local/bin)
+ if(uname_executable)
+   EXEC_PROGRAM(${uname_executable} ARGS --machine OUTPUT_VARIABLE uname_output)
+   if("uname_output" MATCHES "^.*i[1-9]86.*$")
+      set(png_asm_tmp "ON")
+   else("uname_output" MATCHES "^.*i[1-9]86.*$")
+      set(png_asm_tmp "OFF")
+   endif("uname_output" MATCHES "^.*i[1-9]86.*$")
+ endif(uname_executable)
+else()
+ # this env var is normally only set on win64
+ SET(TEXT "ProgramFiles(x86)")
+ if("$ENV{${TEXT}}" STREQUAL "")
+  set(png_asm_tmp "ON")
+ endif("$ENV{${TEXT}}" STREQUAL "")
+endif()
 
 # SET LIBNAME
 set(PNG_LIB_NAME png${PNGLIB_MAJOR}${PNGLIB_MINOR})
@@ -81,299 +91,173 @@ set(PNG_LIB_NAME png${PNGLIB_MAJOR}${PNGLIB_MINOR})
 # to distinguish between debug and release lib
 set(CMAKE_DEBUG_POSTFIX "d")
 
-# 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})
 
 # OUR SOURCES
-set(libpng_public_hdrs
-  png.h
-  pngconf.h
-  ${CMAKE_CURRENT_BINARY_DIR}/pnglibconf.h
-)
 set(libpng_sources
-  ${libpng_public_hdrs}
-  pngdebug.h
-  pnginfo.h
-  pngpriv.h
-  pngstruct.h
-  png.c
-  pngerror.c
-  pngget.c
-  pngmem.c
-  pngpread.c
-  pngread.c
-  pngrio.c
-  pngrtran.c
-  pngrutil.c
-  pngset.c
-  pngtrans.c
-  pngwio.c
-  pngwrite.c
-  pngwtran.c
-  pngwutil.c
+ png.h
+ pngconf.h
+ png.c
+ pngerror.c
+ pngget.c
+ pngmem.c
+ pngpread.c
+ pngread.c
+ pngrio.c
+ pngrtran.c
+ pngrutil.c
+ pngset.c
+ pngtrans.c
+ pngwio.c
+ pngwrite.c
+ pngwtran.c
+ pngwutil.c
 )
 set(pngtest_sources
-  pngtest.c
-)
-set(pngvalid_sources
-  contrib/libtests/pngvalid.c
-)
-set(pngstest_sources
-  contrib/libtests/pngstest.c
+       pngtest.c
 )
 # SOME NEEDED DEFINITIONS
 
+add_definitions(-DPNG_CONFIGURE_LIBPNG)
+
 if(MSVC)
-  add_definitions(-D_CRT_SECURE_NO_DEPRECATE)
+  add_definitions(-DPNG_NO_MODULEDEF -D_CRT_SECURE_NO_DEPRECATE)
 endif(MSVC)
 
+if(PNG_SHARED OR  NOT MSVC)
+	#if building msvc static this has NOT to be defined
+	add_definitions(-DZLIB_DLL)
+endif()
+
+add_definitions(-DLIBPNG_NO_MMX)
+add_definitions(-DPNG_NO_MMX_CODE)
+
+if(PNG_CONSOLE_IO_SUPPORTED)
+ add_definitions(-DPNG_CONSOLE_IO_SUPPORTED)
+endif()
+
+if(PNG_NO_CONSOLE_IO)
+ add_definitions(-DPNG_NO_CONSOLE_IO)
+endif()
+
+if(PNG_NO_STDIO)
+ add_definitions(-DPNG_NO_STDIO)
+endif()
+
 if(PNG_DEBUG)
-  add_definitions(-DPNG_DEBUG)
+ add_definitions(-DPNG_DEBUG)
+endif()
+
+if(NOT M_LIBRARY AND NOT WIN32)
+ add_definitions(-DPNG_NO_FLOATING_POINT_SUPPORTED)
 endif()
 
 # NOW BUILD OUR TARGET
-include_directories(${CMAKE_CURRENT_SOURCE_DIR} ${ZLIB_INCLUDE_DIR})
-
-unset(PNG_LIB_TARGETS)
+include_directories(${PNG_SOURCE_DIR} ${ZLIB_INCLUDE_DIR})
 
 if(PNG_SHARED)
-  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_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})
+ add_library(${PNG_LIB_NAME} SHARED ${libpng_sources})
+ if(MSVC)
+   # msvc does not append 'lib' - do it here to have consistent name
+   set_target_properties(${PNG_LIB_NAME} PROPERTIES 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_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_LIB_NAME_STATIC} PROPERTIES PREFIX "lib")
-  endif()
-  target_link_libraries(${PNG_LIB_NAME_STATIC} ${ZLIB_LIBRARY} ${M_LIBRARY})
+ set(PNG_LIB_NAME_STATIC ${PNG_LIB_NAME}_static)
+ add_library(${PNG_LIB_NAME_STATIC} STATIC ${libpng_sources})
+ if(MSVC)
+   # msvc does not append 'lib' - do it here to have consistent name
+   set_target_properties(${PNG_LIB_NAME_STATIC} PROPERTIES PREFIX "lib")
+ endif()
 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")
-endif()
 
 if(PNG_SHARED AND WIN32)
-  set_target_properties(${PNG_LIB_NAME} PROPERTIES DEFINE_SYMBOL PNG_BUILD_DLL)
+ set_target_properties(${PNG_LIB_NAME} PROPERTIES DEFINE_SYMBOL PNG_BUILD_DLL)
 endif()
 
 if(PNG_TESTS AND PNG_SHARED)
-  # does not work with msvc due to png_lib_ver issue
-  add_executable(pngtest ${pngtest_sources})
-  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_LIB_NAME})
-  add_test(pngvalid ./pngvalid)
-  add_executable(pngstest ${pngstest_sources})
-  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
-  )
+# does not work with msvc due to png_lib_ver issue
+ add_executable(pngtest ${pngtest_sources})
+ target_link_libraries(pngtest ${PNG_LIB_NAME})
+ add_test(pngtest pngtest ${PNG_SOURCE_DIR}/pngtest.png)
 endif()
 
-# Ensure the CMAKE_LIBRARY_OUTPUT_DIRECTORY is set
-IF(NOT CMAKE_LIBRARY_OUTPUT_DIRECTORY)
-  SET(CMAKE_LIBRARY_OUTPUT_DIRECTORY "lib")
-ENDIF(NOT CMAKE_LIBRARY_OUTPUT_DIRECTORY)
-
-# Set a variable with CMake code which:
-# Creates a symlink from src to dest (if possible) or alternatively
-# copies if different.
-macro(CREATE_SYMLINK SRC_FILE DEST_FILE)
-  FILE(REMOVE ${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/${DEST_FILE})
-  if(WIN32 AND NOT CYGWIN AND NOT MSYS)
-    ADD_CUSTOM_COMMAND(
-        OUTPUT ${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/${DEST_FILE}   ${CMAKE_CURRENT_BINARY_DIR}/${DEST_FILE}
-        COMMAND ${CMAKE_COMMAND} -E copy_if_different  "${SRC_FILE}" ${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/${DEST_FILE}
-        COMMAND ${CMAKE_COMMAND} -E copy_if_different  "${SRC_FILE}" ${CMAKE_CURRENT_BINARY_DIR}/${DEST_FILE}
-        DEPENDS ${PNG_LIB_TARGETS}
-        )
-    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 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()
-
-# libpng is a library so default to 'lib'
-if(NOT DEFINED CMAKE_INSTALL_LIBDIR)
-  set(CMAKE_INSTALL_LIBDIR lib)
-endif(NOT DEFINED CMAKE_INSTALL_LIBDIR)
 
 # CREATE PKGCONFIG FILES
 # we use the same files like ./configure, so we have to set its vars
-# Only do this on Windows for Cygwin - the files don't make much sense outside
-# a UNIX look alike
-if(NOT WIN32 OR CYGWIN OR MINGW)
-  set(prefix      ${CMAKE_INSTALL_PREFIX})
-  set(exec_prefix ${CMAKE_INSTALL_PREFIX})
-  set(libdir      ${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_LIBDIR})
-  set(includedir  ${CMAKE_INSTALL_PREFIX}/include)
-  set(LIBS        "-lz -lm")
-  configure_file(${CMAKE_CURRENT_SOURCE_DIR}/libpng.pc.in
-    ${CMAKE_CURRENT_BINARY_DIR}/${PNGLIB_NAME}.pc @ONLY)
-  CREATE_SYMLINK(${PNGLIB_NAME}.pc libpng.pc)
+set(prefix      ${CMAKE_INSTALL_PREFIX})
+set(exec_prefix ${CMAKE_INSTALL_PREFIX})
+set(libdir      ${CMAKE_INSTALL_PREFIX}/lib)
+set(includedir  ${CMAKE_INSTALL_PREFIX}/include)
 
-  configure_file(${CMAKE_CURRENT_SOURCE_DIR}/libpng-config.in
-    ${CMAKE_CURRENT_BINARY_DIR}/${PNGLIB_NAME}-config @ONLY)
-  CREATE_SYMLINK(${PNGLIB_NAME}-config libpng-config)
-endif(NOT WIN32 OR CYGWIN OR MINGW)
+configure_file(${PNG_SOURCE_DIR}/scripts/libpng.pc.in
+  ${PNG_BINARY_DIR}/libpng.pc)
+configure_file(${PNG_SOURCE_DIR}/scripts/libpng-config.in
+  ${PNG_BINARY_DIR}/libpng-config)
+configure_file(${PNG_SOURCE_DIR}/scripts/libpng.pc.in
+  ${PNG_BINARY_DIR}/${PNGLIB_NAME}.pc)
+configure_file(${PNG_SOURCE_DIR}/scripts/libpng-config.in
+  ${PNG_BINARY_DIR}/${PNGLIB_NAME}-config)
 
 # SET UP LINKS
 if(PNG_SHARED)
   set_target_properties(${PNG_LIB_NAME} PROPERTIES
-#   VERSION 16.${PNGLIB_RELEASE}.1.6.2
-    VERSION 16.${PNGLIB_RELEASE}.0
-    SOVERSION 16
-    CLEAN_DIRECT_OUTPUT 1)
+#    VERSION 0.${PNGLIB_RELEASE}.1.2.41beta19
+     VERSION 0.${PNGLIB_RELEASE}.0
+     SOVERSION 0
+     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)
+  if(NOT WIN32)
+    # that's uncool on win32 - it overwrites our static import lib...
     set_target_properties(${PNG_LIB_NAME_STATIC} PROPERTIES
-      OUTPUT_NAME ${PNG_LIB_NAME}
-      CLEAN_DIRECT_OUTPUT 1)
+       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.
-# TODO: Use VERSION_GREATER after our cmake_minimum_required >= 2.6.2
-if(CMAKE_MAJOR_VERSION GREATER 1 AND CMAKE_MINOR_VERSION GREATER 4)
-  set(PNG_EXPORT_RULE EXPORT libpng)
-elseif(CMAKE_MAJOR_VERSION GREATER 2) # future proof
-  set(PNG_EXPORT_RULE EXPORT libpng)
-endif()
-
 # INSTALL
 if(NOT SKIP_INSTALL_LIBRARIES AND NOT SKIP_INSTALL_ALL )
-  install(TARGETS ${PNG_LIB_TARGETS}
-      ${PNG_EXPORT_RULE}
-      RUNTIME DESTINATION bin
-      LIBRARY 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_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_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})
-    endif(NOT WIN32)
-  endif(PNG_SHARED)
-
-  if(PNG_STATIC)
-    if(NOT WIN32 OR CYGWIN OR MINGW)
-      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})
-    endif(NOT WIN32 OR CYGWIN OR MINGW)
- endif()
+    if(PNG_SHARED)
+        install(TARGETS ${PNG_LIB_NAME}
+            RUNTIME DESTINATION bin
+            LIBRARY DESTINATION lib
+            ARCHIVE DESTINATION lib)
+    endif()
+    if(PNG_STATIC)
+        install(TARGETS ${PNG_LIB_NAME_STATIC}
+            LIBRARY DESTINATION lib
+            ARCHIVE DESTINATION lib)
+    endif()
 endif()
 
 if(NOT SKIP_INSTALL_HEADERS AND NOT SKIP_INSTALL_ALL )
-  install(FILES ${libpng_public_hdrs}   DESTINATION include)
-  install(FILES ${libpng_public_hdrs}   DESTINATION include/${PNGLIB_NAME})
+    install(FILES png.h pngconf.h         DESTINATION include)
+    install(FILES png.h pngconf.h         DESTINATION include/${PNGLIB_NAME})
 endif()
 if(NOT SKIP_INSTALL_EXECUTABLES AND NOT SKIP_INSTALL_ALL )
-  if(NOT WIN32 OR CYGWIN OR MINGW)
-    install(PROGRAMS ${CMAKE_CURRENT_BINARY_DIR}/libpng-config DESTINATION bin)
-    install(PROGRAMS ${CMAKE_CURRENT_BINARY_DIR}/${PNGLIB_NAME}-config
-            DESTINATION bin)
-  endif(NOT WIN32 OR CYGWIN OR MINGW)
+    install(PROGRAMS ${PNG_BINARY_DIR}/libpng-config      DESTINATION bin)
+    install(PROGRAMS ${PNG_BINARY_DIR}/${PNGLIB_NAME}-config DESTINATION bin)
 endif()
-
 if(NOT SKIP_INSTALL_FILES AND NOT SKIP_INSTALL_ALL )
-  # Install man pages
-  if(NOT PNG_MAN_DIR)
-    set(PNG_MAN_DIR "share/man")
-  endif()
-  install(FILES libpng.3 libpngpf.3      DESTINATION ${PNG_MAN_DIR}/man3)
-  install(FILES png.5                    DESTINATION ${PNG_MAN_DIR}/man5)
-  # Install pkg-config files
-  if(NOT WIN32 OR CYGWIN OR MINGW)
-    install(FILES ${CMAKE_CURRENT_BINARY_DIR}/libpng.pc
-            DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig)
-    install(PROGRAMS ${CMAKE_CURRENT_BINARY_DIR}/libpng-config
-            DESTINATION bin)
-    install(FILES ${CMAKE_CURRENT_BINARY_DIR}/${PNGLIB_NAME}.pc
-            DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig)
-    install(PROGRAMS ${CMAKE_CURRENT_BINARY_DIR}/${PNGLIB_NAME}-config
-            DESTINATION bin)
-  endif(NOT WIN32 OR CYGWIN OR MINGW)
+    install(FILES libpng.3 libpngpf.3             DESTINATION man/man3)
+    install(FILES png.5                           DESTINATION man/man5)
+    install(FILES ${PNG_BINARY_DIR}/libpng.pc     DESTINATION lib/pkgconfig)
+    install(FILES ${PNG_BINARY_DIR}/libpng-config      DESTINATION bin)
+    install(FILES ${PNG_BINARY_DIR}/${PNGLIB_NAME}.pc  DESTINATION lib/pkgconfig)
+    install(FILES ${PNG_BINARY_DIR}/${PNGLIB_NAME}-config DESTINATION bin)
 endif()
 
-# On versions of CMake that support it, create an export file CMake
-# users can include() to import our targets
-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.txt and all the extra files?
 
-# what's with libpng-$VER%.txt and all the extra files?
 
 # UNINSTALL
 # do we need this?
 
+
 # DIST
 # do we need this?
 

INSTALL

@@ -1,5 +1,5 @@
 
-Installing libpng
+Installing libpng version 1.2.41beta19 - November 12, 2009
 
 On Unix/Linux and similar systems, you can simply type
 
@@ -9,20 +9,14 @@ On Unix/Linux and similar systems, you can simply type
 
 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, you can do this:
-
-    ./configure --enable-maintainer-mode
-    make maintainer-clean
-    ./autogen.sh --maintainer --clean
-    ./autogen.sh --maintainer
-    ./configure [--prefix=/path] [other options]
-    make
-    make install
-    make check
+If configure does not work on your system and you have a reasonably
+up-to-date set of tools, running ./autogen.sh before running ./configure
+may fix the problem.  You can also run the individual commands in
+autogen.sh with the --force option, if supported by your version of
+the tools.  If you run 'libtoolize --force', though, this will replace
+the distributed, patched, version of ltmain.sh with an unpatched version
+and your shared library builds may fail to produce libraries with the
+correct version numbers.
 
 Instead, you can use one of the custom-built makefiles in the
 "scripts" directory
@@ -31,11 +25,15 @@ Instead, you can use one of the custom-built makefiles in the
     make test
     make install
 
-The files that are presently available in the scripts directory
-are listed and described in scripts/README.txt.
-
 Or you can use one of the "projects" in the "projects" directory.
 
+If you want to use "cmake" (see www.cmake.org), copy CMakeLists.txt
+from the "scripts" directory to this directory and type
+
+   cmake . [-DPNG_MMX=YES] -DCMAKE_INSTALL_PREFIX=/path
+   make
+   make install
+
 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.  zlib can be placed in another directory,
@@ -45,29 +43,9 @@ 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
 correspond to the version of zlib that's installed.
 
-If you wish to test with a particular zlib that is not first in the
-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
-
-If you are using one of the makefile scripts, put ZLIBLIB and ZLIBINC
-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
-
 You can rename the directories that you downloaded (they
-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".
+might be called "libpng-1.2.41beta19" or "lpng109" and "zlib-1.2.1"
+or "zlib121") so that you have directories called "zlib" and "libpng".
 
 Your directory structure should look like this:
 
@@ -77,26 +55,19 @@ Your directory structure should look like this:
           README
           *.h
           *.c
-          CMakeLists.txt    =>  "cmake" script
-          configuration files:
-             configure.ac, configure, Makefile.am, Makefile.in,
-             autogen.sh, config.guess, ltmain.sh, missing, libpng.pc.in,
-             libpng-config.in, aclocal.m4, config.h.in, config.sub,
-             depcomp, install-sh, mkinstalldirs, test-pngtest.sh
           contrib
              gregbook
-             libtests
-             pngminim
              pngminus
              pngsuite
              visupng
           projects
-             visualc71
-             vstudio
+             beos
+             c5builder (Borland)
+             visualc6 (msvc)
+             netware.txt
+             wince.txt
           scripts
              makefile.*
-             *.def (module definition files)
-             etc.
           pngtest.png
           etc.
       zlib
@@ -111,13 +82,81 @@ distribution of libpng.  It is available in both tar.gz (UNIX style line
 endings) and zip (DOS style line endings) formats.
 
 If you are building libpng with MSVC, you can enter the
-libpng projects\visualc6 or visualc71 directory and follow the instructions
-in README.txt.
+libpng projects\visualc6 directory and follow the instructions in
+projects\visualc6\README.txt.
 
-Otherwise enter the zlib directory and follow the instructions in zlib/README,
+You can build libpng for WindowsCE by downloading and installing
+the projects\wince directory as instructed in the projects\wince.txt file, and
+then following the instructions in the README* files.  Similarly, you can
+build libpng for Netware or Beos as instructed in projects\netware.txt
+or projects\beos.
+
+Else 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.
 
+The files that are presently available in the scripts directory
+include
+
+ CMakeLists.txt    =>  "cmake" script
+ makefile.std      =>  Generic UNIX makefile (cc, creates static libpng.a)
+ makefile.elf      =>  Linux/ELF makefile symbol versioning,
+                       gcc, creates libpng12.so.0.1.2.41beta19)
+ makefile.linux    =>  Linux/ELF makefile
+                       (gcc, creates libpng12.so.0.1.2.41beta19)
+ makefile.gcc      =>  Generic makefile (gcc, creates static libpng.a)
+ makefile.knr      =>  Archaic UNIX Makefile that converts files with
+                       ansi2knr (Requires ansi2knr.c from
+                       ftp://ftp.cs.wisc.edu/ghost)
+ makefile.aix      =>  AIX/gcc makefile
+ makefile.cegcc    =>  minge32ce for Windows CE makefile
+ makefile.cygwin   =>  Cygwin/gcc makefile
+ makefile.darwin   =>  Darwin makefile, can use on MacosX
+ makefile.dec      =>  DEC Alpha UNIX makefile
+ makefile.freebsd  =>  FreeBSD makefile
+ makefile.hpgcc    =>  HPUX makefile using gcc
+ makefile.hpux     =>  HPUX (10.20 and 11.00) makefile
+ makefile.hp64     =>  HPUX (10.20 and 11.00) makefile, 64-bit
+ makefile.ibmc     =>  IBM C/C++ version 3.x for Win32 and OS/2 (static)
+ makefile.intel    =>  Intel C/C++ version 4.0 and later
+ libpng.icc        =>  Project file for IBM VisualAge/C++ version 4.0 or later
+ makefile.netbsd   =>  NetBSD/cc makefile, uses PNGGCCRD, makes libpng.so.
+ makefile.ne12bsd  =>  NetBSD/cc makefile, uses PNGGCCRD,
+                       makes libpng12.so
+ makefile.openbsd  =>  OpenBSD makefile
+ makefile.sgi      =>  Silicon Graphics IRIX makefile (cc, creates static lib)
+ makefile.sggcc    =>  Silicon Graphics (gcc,
+                       creates libpng12.so.0.1.2.41beta19)
+ makefile.sunos    =>  Sun makefile
+ makefile.solaris  =>  Solaris 2.X makefile (gcc,
+                       creates libpng12.so.0.1.2.41beta19)
+ makefile.solaris-x86 =>  Solaris/intelMMX 2.X makefile (gcc,
+                       creates libpng12.so.0.1.2.41beta19)
+ makefile.so9      =>  Solaris 9 makefile (gcc,
+                       creates libpng12.so.0.1.2.41beta19)
+ makefile.32sunu   =>  Sun Ultra 32-bit makefile
+ makefile.64sunu   =>  Sun Ultra 64-bit makefile
+ makefile.sco      =>  For SCO OSr5  ELF and Unixware 7 with Native cc
+ makefile.mips     =>  MIPS makefile
+ makefile.acorn    =>  Acorn makefile
+ makefile.amiga    =>  Amiga makefile
+ smakefile.ppc     =>  AMIGA smakefile for SAS C V6.58/7.00 PPC compiler
+                       (Requires SCOPTIONS, copied from scripts/SCOPTIONS.ppc)
+ makefile.atari    =>  Atari makefile
+ makefile.beos     =>  BEOS makefile for X86
+ makefile.bor      =>  Borland makefile (uses bcc)
+ makefile.bc32     =>  32-bit Borland C++ (all modules compiled in C mode)
+ makefile.tc3      =>  Turbo C 3.0 makefile
+ makefile.dj2      =>  DJGPP 2 makefile
+ makefile.msc      =>  Microsoft C makefile
+ makefile.vcwin32  =>  makefile for Microsoft Visual C++ 4.0 and later
+ makefile.os2      =>  OS/2 Makefile (gcc and emx, requires pngos2.def)
+ pngos2.def        =>  OS/2 module definition file used by makefile.os2
+ makefile.watcom   =>  Watcom 10a+ Makefile, 32-bit flat memory model
+ makevms.com       =>  VMS build script
+ descrip.mms       =>  VMS makefile for MMS or MMK
+ SCOPTIONS.ppc     =>  Used with smakefile.ppc
+
 Copy the file (or files) that you need from the
 scripts directory into this directory, for example
 
@@ -127,7 +166,7 @@ scripts directory into this directory, for example
 Read the makefile to see if you need to change any source or
 target directories to match your preferences.
 
-Then read pnglibconf.dfa to see if you want to make any configuration
+Then read pngconf.h to see if you want to make any configuration
 changes.
 
 Then just run "make" which will create the libpng library in
@@ -145,26 +184,37 @@ 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".
 
-Further information can be found in the README and libpng-manual.txt
+If you encounter a compiler error message complaining about the
+lines
+      __png.h__ already includes setjmp.h;
+      __dont__ include it again.;
+This means you have compiled another module that includes setjmp.h,
+which is hazardous because the two modules might not include exactly
+the same setjmp.h.  If you are sure that you know what you are doing
+and that they are exactly the same, then you can comment out or
+delete the two lines.  Better yet, use the cexcept interface
+instead, as demonstrated in contrib/visupng of the libpng distribution.
+
+Further information can be found in the README and libpng.txt
 files, in the individual makefiles, in png.h, and the manual pages
 libpng.3 and png.5.
 
+
 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
+did, however there are some options you 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.
+/usr/include/png12, 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.
 

KNOWNBUG

@@ -0,0 +1,22 @@
+
+Known bugs in libpng version 1.2.41beta19
+
+1. February 23, 2006: The custom makefiles don't build libpng with -lz.
+
+   STATUS: This is a subject of debate. The change will probably be made
+   as a part of a major overhaul of the makefiles in libpng version 1.4.0.
+
+2. February 24, 2006: The Makefile generated by the "configure" script
+   fails to install symbolic links
+   libpng12.so => libpng12.so.0.1.2.9betaN
+   that are generated by the custom makefiles.
+
+3. September 4, 2007:  There is a report that pngtest crashes on MacOS 10.
+
+   STATUS: workarounds are
+      1) Compile without optimization (crashes are observed with
+         -arch i386 and -O2 or -O3, using gcc-4.0.1).
+      2) Compile pngtest.c with PNG_DEBUG defined (the bug goes away if
+         you try to look at it).
+      3) Ignore the crash.  The library itself seems to be OK.
+

LICENSE

@@ -10,8 +10,8 @@ this sentence.
 
 This code is released under the libpng license.
 
-libpng versions 1.2.6, August 15, 2004, through 1.6.2, April 25, 2013, are
-Copyright (c) 2004, 2006-2012 Glenn Randers-Pehrson, and are
+libpng versions 1.2.6, August 15, 2004, through 1.2.41beta19, November 12, 2009, are
+Copyright (c) 2004, 2006-2009 Glenn Randers-Pehrson, and are
 distributed according to the same disclaimer and license as libpng-1.2.5
 with the following individual added to the list of Contributing Authors
 
@@ -108,4 +108,4 @@ certification mark of the Open Source Initiative.
 
 Glenn Randers-Pehrson
 glennrp at users.sourceforge.net
-April 25, 2013
+November 12, 2009

Makefile.am

@@ -1,281 +1,138 @@
 # Makefile.am:
 #   Source file for Makefile.in (and hence Makefile)
 #
+# Makefile.am need only be changed on a major version number
+# change (e.g. libpng12 --> libpng14).  In that case seach
+# this file for every instance of the old base name (libpng12)
+# and change to the new one (libpng14), then change the
+# -version-number settings below so that the new values have
+# the correct major part (first field).
 
 PNGLIB_BASENAME= libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@
 
-ACLOCAL_AMFLAGS = -I scripts
+# libpng does not follow GNU file name conventions
+AUTOMAKE_OPTIONS = foreign
 
 # test programs - run on make check, make distcheck
-check_PROGRAMS= pngtest pngunknown pngstest pngvalid
-
+check_PROGRAMS= pngtest
 pngtest_SOURCES = pngtest.c
-pngtest_LDADD = libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@.la
-
-pngvalid_SOURCES = contrib/libtests/pngvalid.c
-pngvalid_LDADD = libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@.la
-
-pngstest_SOURCES = contrib/libtests/pngstest.c
-pngstest_LDADD = libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@.la
-
-pngunknown_SOURCES = contrib/libtests/pngunknown.c
-pngunknown_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 =\
-   tests/pngtest\
-   tests/pngvalid-gamma-16-to-8 tests/pngvalid-gamma-alpha-mode\
-   tests/pngvalid-gamma-background tests/pngvalid-gamma-expand16-alpha-mode\
-   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-interlace-size\
-   tests/pngvalid-progressive-interlace-standard\
-   tests/pngvalid-progressive-interlace-transform\
-   tests/pngvalid-progressive-standard tests/pngvalid-standard\
-   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
-
-# These tests are expected, and required, to fail:
-XFAIL_TESTS = tests/pngstest-error
+pngtest_LDADD = libpng12.la
+TESTS = test-pngtest.sh
+TESTS_ENVIRONMENT= srcdir=$(srcdir) 
 
 # man pages
 dist_man_MANS= libpng.3 libpngpf.3 png.5
 
 # generate the -config scripts if required
-binconfigs= libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@-config
-EXTRA_SCRIPTS= libpng-config libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@-config
+binconfigs= libpng12-config 
+EXTRA_SCRIPTS= libpng-config libpng12-config
 bin_SCRIPTS= @binconfigs@
 
 # rules to build libpng, only build the old library on request
-lib_LTLIBRARIES=libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@.la
-# EXTRA_LTLIBRARIES= libpng.la
-libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@_la_SOURCES = png.c pngerror.c\
-	pngget.c pngmem.c pngpread.c pngread.c pngrio.c pngrtran.c pngrutil.c\
-	pngset.c pngtrans.c pngwio.c pngwrite.c pngwtran.c pngwutil.c\
-	png.h pngconf.h pngdebug.h pnginfo.h pngpriv.h pngstruct.h pngusr.dfa
+lib_LTLIBRARIES=libpng12.la @compatlib@
+EXTRA_LTLIBRARIES= libpng.la
+libpng12_la_SOURCES = png.c pngset.c pngget.c pngrutil.c pngtrans.c pngwutil.c \
+	pngread.c pngrio.c pngwio.c pngwrite.c pngrtran.c \
+	pngwtran.c pngmem.c pngerror.c pngpread.c \
+	png.h pngconf.h
+libpng_la_SOURCES = $(libpng12_la_SOURCES)
 
-if PNG_ARM_NEON
-libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@_la_SOURCES += arm/arm_init.c\
-	arm/filter_neon.S
-endif
+libpng_la_CPPFLAGS = @LIBPNG_DEFINES@
+libpng12_la_CPPFLAGS = @LIBPNG_DEFINES@
 
-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
+# MAJOR UPGRADE: the version-number settings below must be changed.
+libpng12_la_LDFLAGS = -no-undefined -export-dynamic \
+	-version-number 0:@PNGLIB_RELEASE@:0
+# -rpath is needed as automake doesn't know the directory
+libpng_la_LDFLAGS = -rpath '$(libdir)' -no-undefined -export-dynamic \
+	-version-number 3:@PNGLIB_RELEASE@:0
 
 if HAVE_LD_VERSION_SCRIPT
-#   Versioned symbols and restricted exports
-if HAVE_SOLARIS_LD
-  libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@_la_LDFLAGS += -Wl,-M -Wl,libpng.vers
+  # Versioned symbols and restricted exports
+  libpng12_la_LDFLAGS += -Wl,--version-script=libpng.vers
+  libpng12_la_DEPENDENCIES = libpng.vers
 else
-  libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@_la_LDFLAGS += -Wl,--version-script=libpng.vers
+  # Only restricted exports when possible
+  libpng12_la_LDFLAGS += -export-symbols libpng.sym
+  libpng12_la_DEPENDENCIES = libpng.sym
 endif
+libpng_la_DEPENDENCIES = $(libpng12_la_DEPENDENCIES)
 
-  libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@_la_DEPENDENCIES = libpng.vers
-else
-#   Only restricted exports when possible
-  libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@_la_LDFLAGS += -export-symbols libpng.sym
-  libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@_la_DEPENDENCIES = libpng.sym
-endif
+# Avoid depending upon Character Ranges.
+AN = '_abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'
 
 #distribute headers in /usr/include/libpng/*
 pkgincludedir= $(includedir)/$(PNGLIB_BASENAME)
 pkginclude_HEADERS= png.h pngconf.h
-nodist_pkginclude_HEADERS= pnglibconf.h
 
 # pkg-config stuff, note that libpng.pc is always required in order
 # to get the correct library
 pkgconfigdir = @pkgconfigdir@
-pkgconfig_DATA = libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@.pc
+pkgconfig_DATA = libpng12.pc
 
-# Extra source distribution files, '${srcdir}' is used below to stop build files
-# from those directories being included.  This only works if the configure is
-# not done in the source directory!
+#extra source distribution files.
 EXTRA_DIST= \
-	ANNOUNCE CHANGES INSTALL LICENSE README TODO \
+	ANNOUNCE CHANGES INSTALL KNOWNBUG LICENSE README TODO Y2KINFO \
 	pngtest.png pngbar.png pngnow.png pngbar.jpg autogen.sh \
-	${srcdir}/contrib ${srcdir}/projects ${srcdir}/scripts \
-	$(TESTS) $(XFAIL_TESTS) tests/pngstest \
-	CMakeLists.txt example.c libpng-manual.txt
+	${srcdir}/projects/cbuilder5/* \
+	${srcdir}/projects/beos/* \
+	${srcdir}/projects/visualc6/* \
+	${srcdir}/projects/visualc71/* \
+	${srcdir}/projects/wince.txt \
+	${srcdir}/projects/netware.txt \
+	${srcdir}/scripts/* \
+	${srcdir}/contrib/gregbook/* \
+	${srcdir}/contrib/pngminus/* \
+	${srcdir}/contrib/pngsuite/* \
+	${srcdir}/contrib/visupng/* \
+	$(TESTS) \
+	example.c libpng-1.2.41beta19.txt pngvcrd.c 
 
-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.* pngprefix.h symbols.new pngtest-log.txt \
-	$(SCRIPT_CLEANFILES)
+CLEANFILES= pngout.png libpng12.pc libpng12-config libpng.vers \
+libpng.sym
 
 MAINTAINERCLEANFILES = Makefile.in aclocal.m4 config.guess config.h.in \
 config.sub configure depcomp install-sh ltmain.sh missing
 
-# PNG_COPTS give extra options for the C compiler to be used on all compilation
-# steps (unless targe_CFLAGS is specified; that will take precedence over
-# AM_CFLAGS)
-PNG_COPTS = @PNG_COPTS@
-AM_CFLAGS = ${PNG_COPTS}
-
-# DFNCPP is normally just CPP - the C preprocessor - but on Solaris and maybe
-# other operating systems (NeXT?) the C preprocessor selected by configure
-# checks input tokens for validity - effectively it performs part of the ANSI-C
-# parsing - and therefore fails with the .df files.  configure.ac has special
-# checks for this and sets DFNCPP appropriately.
-DFNCPP = @DFNCPP@
-
-SUFFIXES = .chk .dfn .out
-
 $(PNGLIB_BASENAME).pc: libpng.pc
 	cp libpng.pc $@
 
 $(PNGLIB_BASENAME)-config: libpng-config
 	cp libpng-config $@
 
-scripts/sym.out scripts/vers.out: png.h pngconf.h pnglibconf.h
-scripts/prefix.out: png.h pngconf.h pnglibconf.out
-scripts/symbols.out: png.h pngconf.h $(srcdir)/scripts/pnglibconf.h.prebuilt
-scripts/intprefix.out: pnglibconf.h
+libpng.sym: png.h pngconf.h
+	rm -f $@ $@.new
+	$(CPP) @LIBPNG_DEFINES@ $(CPPFLAGS) -DPNG_BUILDSYMS $(srcdir)/png.h | \
+		$(SED) -n -e \
+		's|^.*PNG_FUNCTION_EXPORT[ 	]*\([$(AN)]*\).*$$|$(SYMBOL_PREFIX)\1|p' \
+		-e 's|^.*PNG_DATA_EXPORT[ 	]*\([$(AN)]*\).*$$|$(SYMBOL_PREFIX)\1|p' \
+			>$@.new
+	mv $@.new $@
 
-libpng.sym: scripts/sym.out
-	rm -f $@
-	cp $? $@
-libpng.vers: scripts/vers.out
-	rm -f $@
-	cp $? $@
+libpng.vers: libpng.sym
+	rm -f $@ $@.new
+	echo PNG@PNGLIB_MAJOR@@PNGLIB_MINOR@_0 '{global:' > $@.new
+	$(SED) s/$$/\;/ libpng.sym >> $@.new
+	echo 'local: *; };' >> $@.new
+	mv $@.new $@
 
-if DO_PNG_PREFIX
-# Rename functions in scripts/prefix.out with a PNG_PREFIX prefix.
-# Rename macros in scripts/macro.lst from PNG_PREFIXpng_ to PNG_ (the actual
-# implementation of the macro).
-pnglibconf.h: pnglibconf.out scripts/prefix.out scripts/macro.lst
-	rm -f $@
-	$(AWK) 's==0 && NR>1{print prev}\
-	   s==0{prev=$$0}\
-	   s==1{print "#define", $$1, "@PNG_PREFIX@" $$1}\
-	   s==2{print "#define @PNG_PREFIX@png_" $$1, "PNG_" $$1}\
-	   END{print prev}' s=0 pnglibconf.out s=1 scripts/prefix.out\
-	   s=2 ${srcdir}/scripts/macro.lst >pnglibconf.tf8
-	mv pnglibconf.tf8 $@
-
-pngprefix.h: scripts/intprefix.out
-	rm -f pngprefix.tf1
-	$(AWK) '{print "#define", $$1, "@PNG_PREFIX@" $$1}' $? >pngprefix.tf1
-	mv pngprefix.tf1 $@
-else
-pnglibconf.h: pnglibconf.out
-	rm -f $@
-	cp $? $@
-
-pngprefix.h: # is empty
-	:>$@
-endif
-
-$(srcdir)/scripts/pnglibconf.h.prebuilt:
-	@echo "Attempting to build $@" >&2
-	@echo "This is a machine generated file, but if you want to make" >&2
-	@echo "a new one simply make 'scripts/pnglibconf.out' and copy that" >&2
-	@exit 1
-
-# 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.)
-contrib/libtests/pngstest.o contrib/libtests/pngvalid.o pngtest.o: pnglibconf.h
-contrib/libtests/pngunknown.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
-# interfering with the symbol file format.
-SYMBOL_CFLAGS = -DPNGLIB_LIBNAME='PNG@PNGLIB_MAJOR@@PNGLIB_MINOR@_0'\
-		-DPNGLIB_VERSION='@PNGLIB_VERSION@'\
-		-DSYMBOL_PREFIX='$(SYMBOL_PREFIX)'\
-		-DPNG_NO_USE_READ_MACROS -DPNG_BUILDING_SYMBOL_TABLE
-
-if DO_PNG_PREFIX
-SYMBOL_CFLAGS += -DPNG_PREFIX='@PNG_PREFIX@'
-endif
-
-.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) $*.c > $*.tf1
-	$(AWK) -f "${srcdir}/scripts/dfn.awk" out="$*.tf2" $*.tf1 1>&2
-	rm -f $*.c $*.tf1
-	mv $*.tf2 $@
-
-# 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\
-	    ${srcdir}/pngusr.dfa $(DFA_XTRA) 1>&2
-	$(AWK) -f ${srcdir}/scripts/options.awk out=$*.tf5 $*.tf4 1>&2
-	rm $*.tf4
-	mv $*.tf5 $@
-
-# Symbol checks (.def and .out files should match)
-scripts/symbols.chk: scripts/checksym.awk scripts/symbols.def scripts/symbols.out
-
-.out.chk:
-	rm -f $@ $*.new
-	$(AWK) -f ${srcdir}/scripts/checksym.awk ${srcdir}/scripts/${*F}.def\
-	    of="$*.new" $< >&2
-	mv $*.new $@
-
-# used on demand to regenerate the standard header, CPPFLAGS should
-# be empty - no non-standard defines
-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" |\
-	$(AWK) -f ${srcdir}/scripts/options.awk out=pnglibconf.tf6\
-	    logunsupported=1 version=search ${srcdir}/pngconf.h -\
-	    ${srcdir}/scripts/pnglibconf.dfa 1>&2
-	$(AWK) -f ${srcdir}/scripts/options.awk out=pnglibconf.tf7\
-	    pnglibconf.tf6 1>&2
-	rm pnglibconf.tf6
-	mv pnglibconf.tf7 $@
-
-$(libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@_la_OBJECTS): png.h pngconf.h \
-	pnglibconf.h pngpriv.h pngdebug.h pnginfo.h pngstruct.h pngprefix.h
-
-test: check-am
-
-# Extra checks
-check: scripts/symbols.chk
-
-# Don't distribute the generated script files
-dist-hook:
-	cd '$(top_distdir)'; rm -f $(SCRIPT_CLEANFILES)
+test: check
 
 # 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
+	cd $(DESTDIR)$(includedir); rm -f png.h pngconf.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)$(pkgconfigdir); rm -f libpng.pc
+	cd $(DESTDIR)$(pkgconfigdir); $(LN_S) $(PNGLIB_BASENAME).pc libpng.pc
 
-# do evil things to libpng to cause libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@ to be used
+# do evil things to libpng to cause libpng12 to be used
 install-exec-hook:
-	cd '$(DESTDIR)$(bindir)'; rm -f libpng-config
-	cd '$(DESTDIR)$(bindir)';\
-	   $(LN_S) $(PNGLIB_BASENAME)-config libpng-config
+	cd $(DESTDIR)$(bindir); rm -f libpng-config
+	cd $(DESTDIR)$(bindir); $(LN_S) $(PNGLIB_BASENAME)-config libpng-config
 	@set -x;\
-	cd '$(DESTDIR)$(libdir)';\
-	for ext in a la so so.@PNGLIB_MAJOR@@PNGLIB_MINOR@.@PNGLIB_RELEASE@\
-	   sl dylib dll.a; do\
+	cd $(DESTDIR)$(libdir);\
+	for ext in a la so sl dylib; do\
 		rm -f libpng.$$ext;\
                 if test -f $(PNGLIB_BASENAME).$$ext; then\
                        $(LN_S) $(PNGLIB_BASENAME).$$ext libpng.$$ext;\
@@ -283,13 +140,13 @@ install-exec-hook:
 	done
 
 uninstall-hook:
-	cd '$(DESTDIR)$(includedir)'; rm -f png.h pngconf.h pnglibconf.h
-	rm -f '$(DESTDIR)$(pkgconfigdir)/libpng.pc'
-	rm -f '$(DESTDIR)$(bindir)/libpng-config'
-	rm -f '$(DESTDIR)$(libdir)/libpng.a'
-	rm -f '$(DESTDIR)$(libdir)/libpng.la'
-	rm -f '$(DESTDIR)$(libdir)/libpng.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'
+	cd $(DESTDIR)$(includedir); rm -f png.h pngconf.h
+	rm -f $(DESTDIR)$(pkgconfigdir)/libpng.pc
+	rm -f $(DESTDIR)$(bindir)/libpng-config
+	@if test -n "@compatlib@"; then\
+		set -x;\
+		cd $(DESTDIR)$(libdir);\
+		for ext in a la so sl dylib; do\
+			rm -f libpng.$$ext;\
+		done;\
+	fi

README

@@ -1,11 +1,15 @@
-README for libpng version 1.6.2 - April 25, 2013 (shared library 16.0)
+README for libpng version 1.2.41beta19 - November 12, 2009 (shared library 12.0)
 See the note about version numbers near the top of png.h
 
 See INSTALL for instructions on how to install libpng.
 
 Libpng comes in several distribution formats.  Get libpng-*.tar.gz,
-libpng-*.tar.xz or libpng-*.tar.bz2 if you want UNIX-style line endings
-in the text files, or lpng*.zip if you want DOS-style line endings.
+libpng-*.tar.lzma, or libpng-*.tar.bz2 if you want UNIX-style line
+endings in the text files, or lpng*.7z or lpng*.zip if you want DOS-style
+line endings.  You can get UNIX-style line endings from the *.zip file
+by using "unzip -a" but there seems to be no simple way to recover
+UNIX-style line endings from the *.7z file.  The *.tar.lzma file is
+recommended for *NIX users instead.
 
 Version 0.89 was the first official release of libpng.  Don't let the
 fact that it's the first release fool you.  The libpng library has been in
@@ -54,11 +58,11 @@ to set different actions based on whether the CRC error occurred in a
 critical or an ancillary chunk.
 
 The changes made to the library, and bugs fixed are based on discussions
-on the PNG-implement mailing list and not on material submitted
-privately to Guy, Andreas, or Glenn.  They will forward any good
-suggestions to the list.
+on the png-mng-implement mailing list
+and not on material submitted privately to Guy, Andreas, or Glenn.  They will
+forward any good suggestions to the list.
 
-For a detailed description on using libpng, read libpng-manual.txt.  For
+For a detailed description on using libpng, read libpng.txt.  For
 examples of libpng in a program, see example.c and pngtest.c.  For usage
 information and restrictions (what little they are) on libpng, see
 png.h.  For a description on using zlib (the compression library used by
@@ -77,12 +81,12 @@ compression library that is useful for more things than just PNG files.
 You can use zlib as a drop-in replacement for fread() and fwrite() if
 you are so inclined.
 
-zlib should be available at the same place that libpng is, or at.
-ftp://ftp.info-zip.org/pub/infozip/zlib
+zlib should be available at the same place that libpng is, or at
+ftp://ftp.simplesystems.org/pub/png/src/
 
 You may also want a copy of the PNG specification.  It is available
 as an RFC, a W3C Recommendation, and an ISO/IEC Standard.  You can find
-these at http://www.libpng.org/pub/png/documents/
+these at http://www.libpng.org/pub/png/pngdocs.html
 
 This code is currently being archived at libpng.sf.net in the
 [DOWNLOAD] area, and on CompuServe, Lib 20 (PNG SUPPORT)
@@ -101,29 +105,31 @@ Finally, if you get any warning messages when compiling libpng
 fix.  Please mention "libpng" somewhere in the subject line.  Thanks.
 
 This release was created and will be supported by myself (of course
-based in a large way on Guy's and Andreas' earlier work), and the PNG
-development group.
+based in a large way on Guy's and Andreas' earlier work), and the PNG group.
 
-Send comments/corrections/commendations to png-mng-implement at
-lists.sourceforge.net (subscription required; visit
+Send comments/corrections/commendations to png-mng-implement at lists.sf.net
+(subscription required; visit 
 https://lists.sourceforge.net/lists/listinfo/png-mng-implement
 to subscribe) or to glennrp at users.sourceforge.net
 
 You can't reach Guy, the original libpng author, at the addresses
-given in previous versions of this document.  He and Andreas will
-read mail addressed to the png-implement list, however.
+given in previous versions of this document.  He and Andreas will read mail
+addressed to the png-mng-implement list, however.
 
 Please do not send general questions about PNG.  Send them to
-png-mng-misc at lists.sf.net (subscription required; visit
-https://lists.sourceforge.net/lists/listinfo/png-mng-misc to
-subscribe).  If you have a question about something
+the (png-mng-misc at lists.sourceforge.net, subscription required, visit
+https://lists.sourceforge.net/lists/listinfo/png-mng-implement to subscribe)
+On the other hand,
+please do not send libpng questions to that address, send them to me
+or to the png-mng-implement list.  I'll
+get them in the end anyway.  If you have a question about something
 in the PNG specification that is related to using libpng, send it
 to me.  Send me any questions that start with "I was using libpng,
 and ...".  If in doubt, send questions to me.  I'll bounce them
 to others, if necessary.
 
 Please do not send suggestions on how to change PNG.  We have
-been discussing PNG for sixteen years now, and it is official and
+been discussing PNG for twelve years now, and it is official and
 finished.  If you have suggestions for libpng, however, I'll
 gladly listen.  Even if your suggestion is not used immediately,
 it may be used later.
@@ -138,17 +144,14 @@ Files in this distribution:
       TODO          =>  Things not implemented in the current library
       Y2KINFO       =>  Statement of Y2K compliance
       example.c     =>  Example code for using libpng functions
-      libpng.3      =>  manual page for libpng (includes libpng-manual.txt)
-      libpng-manual.txt  =>  Description of libpng and its functions
+      libpng-*-*-diff.txt => Diff from previous release
+      libpng.3      =>  manual page for libpng (includes libpng.txt)
+      libpng.txt    =>  Description of libpng and its functions
       libpngpf.3    =>  manual page for libpng's private functions
       png.5         =>  manual page for the PNG format
       png.c         =>  Basic interface functions common to library
-      png.h         =>  Library function and interface declarations (public)
-      pngpriv.h     =>  Library function and interface declarations (private)
-      pngconf.h     =>  System specific library configuration (public)
-      pngstruct.h   =>  png_struct declaration (private)
-      pnginfo.h     =>  png_info struct declaration (private)
-      pngdebug.h    =>  debugging macros (private)
+      png.h         =>  Library function and interface declarations
+      pngconf.h     =>  System specific library configuration
       pngerror.c    =>  Error/warning message I/O functions
       pngget.c      =>  Functions for retrieving info from struct
       pngmem.c      =>  Memory handling functions
@@ -175,27 +178,89 @@ Files in this distribution:
        pngminus     =>  Simple pnm2png and png2pnm programs
        pngsuite     =>  Test images
        visupng      =>  Contains a MSVC workspace for VisualPng
-      projects      =>  Contains project files and workspaces for
-                        building a DLL
-       cbuilder5        =>  Contains a Borland workspace for building
-                            libpng and zlib
-       visualc6         =>  Contains a Microsoft Visual C++ (MSVC)
-                            workspace for building libpng and zlib
-       visualc71        =>  Contains a Microsoft Visual C++ (MSVC)
-                            workspace for building libpng and zlib
-       xcode            =>  Contains an Apple xcode
-                            workspace for building libpng and zlib
+      projects      =>  Contains project files and workspaces for building DLL
+       beos             =>  Contains a Beos workspace for building libpng
+       c5builder        =>  Contains a Borland workspace for building libpng
+                            and zlib
+       visualc6         =>  Contains a Microsoft Visual C++ (MSVC) workspace
+                            for building libpng and zlib
+       netware.txt      =>  Contains instructions for downloading a set of
+                            project files for building libpng and zlib on
+                            Netware.
+       wince.txt        =>  Contains instructions for downloading a Microsoft
+                            Visual C++ (Windows CD Toolkit) workspace for
+                            building libpng and zlib on WindowsCE
       scripts       =>  Directory containing scripts for building libpng:
-                            (see scripts/README.txt for the list of scripts)
+       descrip.mms      =>  VMS makefile for MMS or MMK
+       makefile.std     =>  Generic UNIX makefile (cc, creates static libpng.a)
+       makefile.elf     =>  Linux/ELF makefile symbol versioning,
+                            gcc, creates libpng12.so.0.1.2.41beta19)
+       makefile.linux   =>  Linux/ELF makefile
+                            (gcc, creates libpng12.so.0.1.2.41beta19)
+       makefile.gcmmx   =>  Linux/ELF makefile
+                            (gcc, creates libpng12.so.0.1.2.41beta19,
+                            uses assembler code tuned for Intel MMX platform)
+       makefile.gcc     =>  Generic makefile (gcc, creates static libpng.a)
+       makefile.knr     =>  Archaic UNIX Makefile that converts files with
+                            ansi2knr (Requires ansi2knr.c from
+                            ftp://ftp.cs.wisc.edu/ghost)
+       makefile.aix     =>  AIX makefile
+       makefile.cygwin  =>  Cygwin/gcc makefile
+       makefile.darwin  =>  Darwin makefile
+       makefile.dec     =>  DEC Alpha UNIX makefile
+       makefile.freebsd =>  FreeBSD makefile
+       makefile.hpgcc   =>  HPUX makefile using gcc
+       makefile.hpux    =>  HPUX (10.20 and 11.00) makefile
+       makefile.hp64    =>  HPUX (10.20 and 11.00) makefile, 64 bit
+       makefile.ibmc    =>  IBM C/C++ version 3.x for Win32 and OS/2 (static)
+       makefile.intel   =>  Intel C/C++ version 4.0 and later
+       libpng.icc       =>  Project file, IBM VisualAge/C++ 4.0 or later
+       makefile.netbsd  =>  NetBSD/cc makefile, PNGGCCRD, makes libpng.so.
+       makefile.ne12bsd  =>  NetBSD/cc makefile, PNGGCCRD, makes libpng12.so
+       makefile.openbsd =>  OpenBSD makefile
+       makefile.sgi     =>  Silicon Graphics IRIX (cc, creates static lib)
+       makefile.sggcc   =>  Silicon Graphics
+                            (gcc, creates libpng12.so.0.1.2.41beta19)
+       makefile.sunos   =>  Sun makefile
+       makefile.solaris =>  Solaris 2.X makefile
+                            (gcc, creates libpng12.so.0.1.2.41beta19)
+       makefile.so9     =>  Solaris 9 makefile
+                            (gcc, creates libpng12.so.0.1.2.41beta19)
+       makefile.32sunu  =>  Sun Ultra 32-bit makefile
+       makefile.64sunu  =>  Sun Ultra 64-bit makefile
+       makefile.sco     =>  For SCO OSr5  ELF and Unixware 7 with Native cc
+       makefile.mips    =>  MIPS makefile
+       makefile.acorn   =>  Acorn makefile
+       makefile.amiga   =>  Amiga makefile
+       smakefile.ppc    =>  AMIGA smakefile for SAS C V6.58/7.00 PPC
+                            compiler (Requires SCOPTIONS, copied from
+                            scripts/SCOPTIONS.ppc)
+       makefile.atari   =>  Atari makefile
+       makefile.beos    =>  BEOS makefile for X86
+       makefile.bor     =>  Borland makefile (uses bcc)
+       makefile.bc32    =>  32-bit Borland C++ (all modules compiled in C mode)
+       makefile.tc3     =>  Turbo C 3.0 makefile
+       makefile.dj2     =>  DJGPP 2 makefile
+       makefile.msc     =>  Microsoft C makefile
+       makefile.vcawin32=>  makefile for Microsoft Visual C++ 5.0 and
+                            later (uses assembler code tuned for Intel MMX
+                            platform)
+       makefile.vcwin32 =>  makefile for Microsoft Visual C++ 4.0 and
+                            later (does not use assembler code)
+       makefile.os2     =>  OS/2 Makefile (gcc and emx, requires pngos2.def)
+       pngos2.def       =>  OS/2 module definition file used by makefile.os2
+       makefile.watcom  =>  Watcom 10a+ Makefile, 32-bit flat memory model
+       makevms.com      =>  VMS build script
+       SCOPTIONS.ppc    =>  Used with smakefile.ppc
 
 Good luck, and happy coding.
 
--Glenn Randers-Pehrson (current maintainer, since 1998)
+-Glenn Randers-Pehrson (current maintainer)
  Internet: glennrp at users.sourceforge.net
 
 -Andreas Eric Dilger (former maintainer, 1996-1997)
  Internet: adilger at enel.ucalgary.ca
- Web: http://www-mddsp.enel.ucalgary.ca/People/adilger/
+ Web: http://members.shaw.ca/adilger/
 
 -Guy Eric Schalnat (original author and former maintainer, 1995-1996)
  (formerly of Group 42, Inc)

TODO

@@ -1,11 +1,12 @@
-/*
 TODO - list of things to do for libpng:
 
 Final bug fixes.
+Improve API by hiding the png_struct and png_info structs.
+Finish work on the no-floating-point version (including gamma compensation)
 Better C++ wrapper/full C++ implementation?
 Fix problem with C++ and EXTERN "C".
 cHRM transformation.
-Remove setjmp/longjmp usage in favor of returning error codes.
+Improve setjmp/longjmp usage or remove it in favor of returning error codes.
 Add "grayscale->palette" transformation and "palette->grayscale" detection.
 Improved dithering.
 Multi-lingual error and warning message support.
@@ -16,12 +17,9 @@ Better filter selection
    (counting huffman bits/precompression?  filter inertia?  filter costs?).
 Histogram creation.
 Text conversion between different code pages (Latin-1 -> Mac and DOS).
-Avoid building gamma tables whenever possible.
+Should we always malloc 2^bit_depth PLTE/tRNS/hIST entries for safety?
+Build gamma tables using fixed point (and do away with floating point entirely).
 Use greater precision when changing to linear gamma for compositing against
   background and doing rgb-to-gray transformation.
 Investigate pre-incremented loop counters and other loop constructions.
 Add interpolated method of handling interlacing.
-Switch to the simpler zlib (zlib/libpng) license if legally possible.
-Extend pngvalid.c to validate more of the libpng transformations.
-
-*/

Y2KINFO

@@ -0,0 +1,55 @@
+   Y2K compliance in libpng:
+   =========================
+
+      November 12, 2009
+
+      Since the PNG Development group is an ad-hoc body, we can't make
+      an official declaration.
+
+      This is your unofficial assurance that libpng from version 0.71 and
+      upward through 1.2.41beta19 are Y2K compliant.  It is my belief that earlier
+      versions were also Y2K compliant.
+
+      Libpng only has three year fields.  One is a 2-byte unsigned integer
+      that will hold years up to 65535.  The other two hold the date in text
+      format, and will hold years up to 9999.
+
+      The integer is
+          "png_uint_16 year" in png_time_struct.
+
+      The strings are
+          "png_charp time_buffer" in png_struct and
+          "near_time_buffer", which is a local character string in png.c.
+
+      There are seven time-related functions:
+
+          png_convert_to_rfc_1123() in png.c
+            (formerly png_convert_to_rfc_1152() in error)
+          png_convert_from_struct_tm() in pngwrite.c, called in pngwrite.c
+          png_convert_from_time_t() in pngwrite.c
+          png_get_tIME() in pngget.c
+          png_handle_tIME() in pngrutil.c, called in pngread.c
+          png_set_tIME() in pngset.c
+          png_write_tIME() in pngwutil.c, called in pngwrite.c
+
+      All appear to handle dates properly in a Y2K environment.  The
+      png_convert_from_time_t() function calls gmtime() to convert from system
+      clock time, which returns (year - 1900), which we properly convert to
+      the full 4-digit year.  There is a possibility that applications using
+      libpng are not passing 4-digit years into the png_convert_to_rfc_1123()
+      function, or that they are incorrectly passing only a 2-digit year
+      instead of "year - 1900" into the png_convert_from_struct_tm() function,
+      but this is not under our control.  The libpng documentation has always
+      stated that it works with 4-digit years, and the APIs have been
+      documented as such.
+
+      The tIME chunk itself is also Y2K compliant.  It uses a 2-byte unsigned
+      integer to hold the year, and can hold years as large as 65535.
+
+      zlib, upon which libpng depends, is also Y2K compliant.  It contains
+      no date-related code.
+
+
+         Glenn Randers-Pehrson
+         libpng maintainer
+         PNG Development Group

arm/arm_init.c

@@ -1,219 +0,0 @@
-
-/* arm_init.c - NEON optimised filter functions
- *
- * Copyright (c) 2013 Glenn Randers-Pehrson
- * Written by Mans Rullgard, 2011.
- * Last changed in libpng 1.5.15 [March 28, 2013]
- *
- * This code is released under the libpng license.
- * For conditions of distribution and use, see the disclaimer
- * and license in png.h
- */
-/* Below, after checking __linux__, various non-C90 POSIX 1003.1 functions are
- * called.
- */
-#define _POSIX_SOURCE 1
-
-#include "../pngpriv.h"
-
-#ifdef PNG_ARM_NEON_SUPPORTED
-#ifdef PNG_ARM_NEON_CHECK_SUPPORTED /* Do run-time checks */
-#include <signal.h> /* for sig_atomic_t */
-
-#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
-#  error "ALIGNED_MEMORY is required; set: -DPNG_ALIGNED_MEMORY_SUPPORTED"
-#endif
-
-void
-png_init_filter_functions_neon(png_structp pp, unsigned int bpp)
-{
-#ifdef PNG_ARM_NEON_API_SUPPORTED
-   switch ((pp->options >> PNG_ARM_NEON) & 3)
-   {
-      case PNG_OPTION_UNSET:
-         /* Allow the run-time check to execute if it has been enabled -
-          * thus both API and CHECK can be turned on.  If it isn't supported
-          * this case will fall through to the 'default' below, which just
-          * returns.
-          */
-#endif /* PNG_ARM_NEON_API_SUPPORTED */
-#ifdef PNG_ARM_NEON_CHECK_SUPPORTED
-         {
-            static volatile sig_atomic_t no_neon = -1; /* not checked */
-
-            if (no_neon < 0)
-               no_neon = !png_have_neon(pp);
-
-            if (no_neon)
-               return;
-         }
-#ifdef PNG_ARM_NEON_API_SUPPORTED
-         break;
-#endif
-#endif /* PNG_ARM_NEON_CHECK_SUPPORTED */
-#ifdef PNG_ARM_NEON_API_SUPPORTED
-      case PNG_OPTION_ON:
-         /* Option turned on */
-         break;
-
-      default: /* OFF or INVALID */
-         return;
-   }
-#endif
-
-   /* IMPORTANT: any new external functions used here must be declared using
-    * PNG_INTERNAL_FUNCTION in ../pngpriv.h.  This is required so that the
-    * 'prefix' option to configure works:
-    *
-    *    ./configure --with-libpng-prefix=foobar_
-    *
-    * Verify you have got this right by running the above command, doing a build
-    * and examining pngprefix.h; it must contain a #define for every external
-    * function you add.  (Notice that this happens automatically for the
-    * initialization function.)
-    */
-   pp->read_filter[PNG_FILTER_VALUE_UP-1] = png_read_filter_row_up_neon;
-
-   if (bpp == 3)
-   {
-      pp->read_filter[PNG_FILTER_VALUE_SUB-1] = png_read_filter_row_sub3_neon;
-      pp->read_filter[PNG_FILTER_VALUE_AVG-1] = png_read_filter_row_avg3_neon;
-      pp->read_filter[PNG_FILTER_VALUE_PAETH-1] =
-         png_read_filter_row_paeth3_neon;
-   }
-
-   else if (bpp == 4)
-   {
-      pp->read_filter[PNG_FILTER_VALUE_SUB-1] = png_read_filter_row_sub4_neon;
-      pp->read_filter[PNG_FILTER_VALUE_AVG-1] = png_read_filter_row_avg4_neon;
-      pp->read_filter[PNG_FILTER_VALUE_PAETH-1] =
-          png_read_filter_row_paeth4_neon;
-   }
-}
-#endif /* FILTER_OPTIMIZATIONS && __arm__ && __ARM_NEON__ */

arm/filter_neon.S

@@ -1,235 +0,0 @@
-
-/* filter_neon.S - NEON optimised filter functions
- *
- * Copyright (c) 2011 Glenn Randers-Pehrson
- * Written by Mans Rullgard, 2011.
- * Last changed in libpng 1.5.7 [December 15, 2011]
- *
- * This code is released under the libpng license.
- * For conditions of distribution and use, see the disclaimer
- * and license in png.h
- */
-
-/* This is required to get the symbol renames, which are #defines, and also
- * includes the value of PNG_FILTER_OPTIMIZATIONS.
- */
-#define PNG_VERSION_INFO_ONLY
-#include "../pngpriv.h"
-
-#if defined(PNG_FILTER_OPTIMIZATIONS) && defined(__arm__) && \
-   defined(__ARM_NEON__)
-#if defined(__linux__) && defined(__ELF__)
-.section .note.GNU-stack,"",%progbits /* mark stack as non-executable */
-#endif
-
-#ifdef __ELF__
-#   define ELF
-#else
-#   define ELF @
-#endif
-
-        .arch armv7-a
-        .fpu  neon
-
-.macro  func    name, export=0
-    .macro endfunc
-ELF     .size   \name, . - \name
-        .endfunc
-        .purgem endfunc
-    .endm
-        .text
-    .if \export
-        .global \name
-    .endif
-ELF     .type   \name, STT_FUNC
-        .func   \name
-\name:
-.endm
-
-func    png_read_filter_row_sub4_neon, export=1
-        ldr             r3,  [r0, #4]           @ rowbytes
-        vmov.i8         d3,  #0
-1:
-        vld4.32         {d4[],d5[],d6[],d7[]},    [r1,:128]
-        vadd.u8         d0,  d3,  d4
-        vadd.u8         d1,  d0,  d5
-        vadd.u8         d2,  d1,  d6
-        vadd.u8         d3,  d2,  d7
-        vst4.32         {d0[0],d1[0],d2[0],d3[0]},[r1,:128]!
-        subs            r3,  r3,  #16
-        bgt             1b
-
-        bx              lr
-endfunc
-
-func    png_read_filter_row_sub3_neon, export=1
-        ldr             r3,  [r0, #4]           @ rowbytes
-        vmov.i8         d3,  #0
-        mov             r0,  r1
-        mov             r2,  #3
-        mov             r12, #12
-        vld1.8          {q11},    [r0], r12
-1:
-        vext.8          d5,  d22, d23, #3
-        vadd.u8         d0,  d3,  d22
-        vext.8          d6,  d22, d23, #6
-        vadd.u8         d1,  d0,  d5
-        vext.8          d7,  d23, d23, #1
-        vld1.8          {q11},    [r0], r12
-        vst1.32         {d0[0]},  [r1,:32], r2
-        vadd.u8         d2,  d1,  d6
-        vst1.32         {d1[0]},  [r1], r2
-        vadd.u8         d3,  d2,  d7
-        vst1.32         {d2[0]},  [r1], r2
-        vst1.32         {d3[0]},  [r1], r2
-        subs            r3,  r3,  #12
-        bgt             1b
-
-        bx              lr
-endfunc
-
-func    png_read_filter_row_up_neon, export=1
-        ldr             r3,  [r0, #4]           @ rowbytes
-1:
-        vld1.8          {q0}, [r1,:128]
-        vld1.8          {q1}, [r2,:128]!
-        vadd.u8         q0,  q0,  q1
-        vst1.8          {q0}, [r1,:128]!
-        subs            r3,  r3,  #16
-        bgt             1b
-
-        bx              lr
-endfunc
-
-func    png_read_filter_row_avg4_neon, export=1
-        ldr             r12, [r0, #4]           @ rowbytes
-        vmov.i8         d3,  #0
-1:
-        vld4.32         {d4[],d5[],d6[],d7[]},    [r1,:128]
-        vld4.32         {d16[],d17[],d18[],d19[]},[r2,:128]!
-        vhadd.u8        d0,  d3,  d16
-        vadd.u8         d0,  d0,  d4
-        vhadd.u8        d1,  d0,  d17
-        vadd.u8         d1,  d1,  d5
-        vhadd.u8        d2,  d1,  d18
-        vadd.u8         d2,  d2,  d6
-        vhadd.u8        d3,  d2,  d19
-        vadd.u8         d3,  d3,  d7
-        vst4.32         {d0[0],d1[0],d2[0],d3[0]},[r1,:128]!
-        subs            r12, r12, #16
-        bgt             1b
-
-        bx              lr
-endfunc
-
-func    png_read_filter_row_avg3_neon, export=1
-        push            {r4,lr}
-        ldr             r12, [r0, #4]           @ rowbytes
-        vmov.i8         d3,  #0
-        mov             r0,  r1
-        mov             r4,  #3
-        mov             lr,  #12
-        vld1.8          {q11},    [r0], lr
-1:
-        vld1.8          {q10},    [r2], lr
-        vext.8          d5,  d22, d23, #3
-        vhadd.u8        d0,  d3,  d20
-        vext.8          d17, d20, d21, #3
-        vadd.u8         d0,  d0,  d22
-        vext.8          d6,  d22, d23, #6
-        vhadd.u8        d1,  d0,  d17
-        vext.8          d18, d20, d21, #6
-        vadd.u8         d1,  d1,  d5
-        vext.8          d7,  d23, d23, #1
-        vld1.8          {q11},    [r0], lr
-        vst1.32         {d0[0]},  [r1,:32], r4
-        vhadd.u8        d2,  d1,  d18
-        vst1.32         {d1[0]},  [r1], r4
-        vext.8          d19, d21, d21, #1
-        vadd.u8         d2,  d2,  d6
-        vhadd.u8        d3,  d2,  d19
-        vst1.32         {d2[0]},  [r1], r4
-        vadd.u8         d3,  d3,  d7
-        vst1.32         {d3[0]},  [r1], r4
-        subs            r12, r12, #12
-        bgt             1b
-
-        pop             {r4,pc}
-endfunc
-
-.macro  paeth           rx,  ra,  rb,  rc
-        vaddl.u8        q12, \ra, \rb           @ a + b
-        vaddl.u8        q15, \rc, \rc           @ 2*c
-        vabdl.u8        q13, \rb, \rc           @ pa
-        vabdl.u8        q14, \ra, \rc           @ pb
-        vabd.u16        q15, q12, q15           @ pc
-        vcle.u16        q12, q13, q14           @ pa <= pb
-        vcle.u16        q13, q13, q15           @ pa <= pc
-        vcle.u16        q14, q14, q15           @ pb <= pc
-        vand            q12, q12, q13           @ pa <= pb && pa <= pc
-        vmovn.u16       d28, q14
-        vmovn.u16       \rx, q12
-        vbsl            d28, \rb, \rc
-        vbsl            \rx, \ra, d28
-.endm
-
-func    png_read_filter_row_paeth4_neon, export=1
-        ldr             r12, [r0, #4]           @ rowbytes
-        vmov.i8         d3,  #0
-        vmov.i8         d20, #0
-1:
-        vld4.32         {d4[],d5[],d6[],d7[]},    [r1,:128]
-        vld4.32         {d16[],d17[],d18[],d19[]},[r2,:128]!
-        paeth           d0,  d3,  d16, d20
-        vadd.u8         d0,  d0,  d4
-        paeth           d1,  d0,  d17, d16
-        vadd.u8         d1,  d1,  d5
-        paeth           d2,  d1,  d18, d17
-        vadd.u8         d2,  d2,  d6
-        paeth           d3,  d2,  d19, d18
-        vmov            d20, d19
-        vadd.u8         d3,  d3,  d7
-        vst4.32         {d0[0],d1[0],d2[0],d3[0]},[r1,:128]!
-        subs            r12, r12, #16
-        bgt             1b
-
-        bx              lr
-endfunc
-
-func    png_read_filter_row_paeth3_neon, export=1
-        push            {r4,lr}
-        ldr             r12, [r0, #4]           @ rowbytes
-        vmov.i8         d3,  #0
-        vmov.i8         d4,  #0
-        mov             r0,  r1
-        mov             r4,  #3
-        mov             lr,  #12
-        vld1.8          {q11},    [r0], lr
-1:
-        vld1.8          {q10},    [r2], lr
-        paeth           d0,  d3,  d20, d4
-        vext.8          d5,  d22, d23, #3
-        vadd.u8         d0,  d0,  d22
-        vext.8          d17, d20, d21, #3
-        paeth           d1,  d0,  d17, d20
-        vst1.32         {d0[0]},  [r1,:32], r4
-        vext.8          d6,  d22, d23, #6
-        vadd.u8         d1,  d1,  d5
-        vext.8          d18, d20, d21, #6
-        paeth           d2,  d1,  d18, d17
-        vext.8          d7,  d23, d23, #1
-        vld1.8          {q11},    [r0], lr
-        vst1.32         {d1[0]},  [r1], r4
-        vadd.u8         d2,  d2,  d6
-        vext.8          d19, d21, d21, #1
-        paeth           d3,  d2,  d19, d18
-        vst1.32         {d2[0]},  [r1], r4
-        vmov            d4,  d19
-        vadd.u8         d3,  d3,  d7
-        vst1.32         {d3[0]},  [r1], r4
-        subs            r12, r12, #12
-        bgt             1b
-
-        pop             {r4,pc}
-endfunc
-#endif /* FILTER_OPTIMIZATIONS && __arm__ && __ARM_NEON__ */

autogen.sh

@@ -1,219 +1,25 @@
 #! /bin/sh
+# a quick hack script to generate necessary files from 
+# auto* tools.
 #
-# Run 'autoreconf' to build 'configure', 'Makefile.in' and other configure
-# control files.
-#
-# The first time this is run on a GIT checkout the only files that exist are
-# configure.ac and Makefile.am; all of the autotools support scripts are
-# missing.  They are instantiated with autoreconf --force --install.
-#
-# 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 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 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.
-#
-clean=
-maintainer=
-while test $# -gt 0
-do
-   case "$1" in
-      --maintainer)
-         maintainer=1;;
-
-      --clean)
-         clean=1;;
-
-      *)
-         exec >&2
-         echo "$0: usage: ./autogen.sh"
-         if test -d .git
-         then
-            echo "  ./autogen.sh generates the configure script and"
-            echo "  Makefile.in, or refreshes them after changes to Makefile.am"
-            echo "  or configure.ac.  You may prefer to just run autoreconf."
-         elif test -z "$maintainer"
-         then
-            echo "  DO NOT RUN THIS SCRIPT."
-            echo "  If you need to change Makefile.am or configure.ac then you"
-            echo "  also need to run ./configure --enable-maintainer-mode and"
-            echo "  use the appropriate autotools, *NOT* this script, to update"
-            echo "  everything, please check the documentation of autoreconf."
-            echo "  WARNING: libpng is intentionally generated with a known,"
-            echo "  fixed, set of autotools.  It is known *NOT* to work with"
-            echo "  the collection of autotools distributed on highly reputable"
-            echo "  operating systems."
-            echo "  Remember: autotools is GNU software, you are expected to"
-            echo "  pay for support."
-         else
-            echo "  You have run autogen.sh with --maintainer enabled and you"
-            echo "  are not using a GIT distribution, then you have given an"
-            echo "  unrecognized argument.  This is not good. --maintainer"
-            echo "  switches off any assumptions that you might not know what"
-            echo "  you are doing."
-         fi
-         exit 1;;
-   esac
-
-   shift
-done
-#
-# First check for a set of the autotools files; if absent then this is assumed
-# to be a GIT version and the local autotools must be used.  If present this
-# is a tarball distribution and the script should not be used.  If partially
-# 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"
-#
-# These are separate because 'maintainer-clean' does not remove them.
-libpng_libtool_files="scripts/libtool.m4 scripts/ltoptions.m4\
-   scripts/ltsugar.m4 scripts/ltversion.m4 scripts/lt~obsolete.m4"
-
-libpng_autotools_dirs="autom4te.cache" # not required
-#
-# The configure generated files:
-libpng_configure_files="Makefile config.h config.log config.status\
-   libpng-config libpng.pc libtool stamp-h1"
-
-libpng_configure_dirs=".deps"
-#
-# We must remove the configure generated files as well as the autotools
-# generated files if autotools are regenerated because otherwise if configure
-# has been run without "--enable-maintainer-mode" make can do a partial update
-# of Makefile.  These functions do the two bits of cleaning.
-clean_autotools(){
-   rm -rf $libpng_autotools_files $libpng_libtool_files $libpng_autotools_dirs
-}
-
-clean_configure(){
-   rm -rf $libpng_configure_files $libpng_configure_dirs
-}
-#
-# Clean: remove everything (this is to help with testing)
-if test -n "$clean"
-then
-   clean_configure
-   if test -n "$maintainer"
-   then
-      clean_autotools
-   fi
-
-   exit 0
-fi
-#
-# Validate the distribution.
-libpng_autotools_file_found=
-libpng_autotools_file_missing=
-for file in $libpng_autotools_files
-do
-   if test -f  "$file"
-   then
-      libpng_autotools_file_found=1
-   else
-      libpng_autotools_file_missing=1
-   fi
-done
-#
-# Presence of one of these does not *invalidate* missing, but absence
-# invalidates found.
-for file in $libpng_libtool_files
-do
-   if test ! -f "$file"
-   then
-      libpng_autotools_file_missing=1
-   fi
-done
-#
-# The cache directory doesn't matter - it will be regenerated and does not exist
-# anyway in a tarball.
-#
-# Either everything is missing or everything is there, the --maintainer option
-# just changes this so that the mode is set to generate all the files.
-mode=
-if test -z "$libpng_autotools_file_found" -o -n "$maintainer"
-then
-   mode="autoreconf"
-else
-   if test -n "$libpng_autotools_file_missing"
-   then
-      mode="broken"
-   else
-      mode="configure"
-   fi
-fi
-#
-# So:
-case "$mode" in
-   autoreconf)
-      # Clean in case configure files exist
-      clean_configure
-      clean_autotools
-      # Everything must be initialized, so use --force
-      if autoreconf --warnings=all --force --install
-      then
-         missing=
-         for file in $libpng_autotools_files
-         do
-            test -f "$file" || missing=1
-         done
-         # ignore the cache directory
-         test -z "$missing" || {
-            exec >&2
-            echo "autoreconf was run, but did not produce all the expected"
-            echo "files.  It is likely that your autotools installation is"
-            echo "not compatible with that expected by libpng."
-            exit 1
-         }
-      else
-         exec >&2
-         echo "autoreconf failed: your version of autotools is incompatible"
-         echo "with this libpng version.  Please use a distributed archive"
-         echo "(which includes the autotools generated files) and run configure"
-         echo "instead."
-         exit 1
-      fi;;
-
-   configure)
-      if test -d .git
-      then
-         exec >&2
-         echo "ERROR: running autoreconf on an initialized sytem"
-         echo "  This is not necessary; it is only necessary to remake the"
-         echo "  autotools generated files if Makefile.am or configure.ac"
-         echo "  change and make does the right thing with:"
-         echo
-         echo "     ./configure --enable-maintainer-mode."
-         echo
-         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 "  compatiblity with prior releases."
-         exit 1
-      else
-         exec >&2
-         echo "autogen.sh is intended only to generate 'configure' on systems"
-         echo "that do not have it.  You have a complete 'configure', if you"
-         echo "need to change Makefile.am or configure.ac you also need to"
-         echo "run configure with the --enable-maintainer-mode option."
-         exit 1
-      fi;;
-
-   broken)
-      exec >&2
-      echo "Your system has a partial set of autotools generated files."
-      echo "autogen.sh is unable to proceed.  The full set of files is"
-      echo "contained in the libpng 'tar' distribution archive and you do"
-      echo "not need to run autogen.sh if you use it."
-      exit 1;;
-esac
+# WARNING: if you run this you will change the versions
+# of the tools which are used and, maybe, required!
+        touch Makefile.am configure.ac
+{
+	echo "running libtoolize" >&2
+	libtoolize --force --copy --automake
+} && {
+	echo "running aclocal" >&2
+	aclocal
+} && {
+	echo "running autoheader [ignore the warnings]" >&2
+	autoheader
+} && {
+	echo "running automake" >&2
+	automake --force-missing --foreign -a -c
+} && {
+	echo "running autoconf" >&2
+	autoconf
+} &&
+	echo "autogen complete" >&2 ||
+	echo "ERROR: autogen.sh failed, autogen is incomplete" >&2

config.h.in

@@ -0,0 +1,86 @@
+/* config.h.in.  Generated from configure.ac by autoheader.  */
+
+/* Define to 1 if you have the <dlfcn.h> header file. */
+#undef HAVE_DLFCN_H
+
+/* Define to 1 if you have the <inttypes.h> header file. */
+#undef HAVE_INTTYPES_H
+
+/* Define to 1 if you have the `m' library (-lm). */
+#undef HAVE_LIBM
+
+/* Define to 1 if you have the `z' library (-lz). */
+#undef HAVE_LIBZ
+
+/* Define to 1 if you have the <malloc.h> header file. */
+#undef HAVE_MALLOC_H
+
+/* Define to 1 if you have the <memory.h> header file. */
+#undef HAVE_MEMORY_H
+
+/* Define to 1 if you have the `memset' function. */
+#undef HAVE_MEMSET
+
+/* Define to 1 if you have the `pow' function. */
+#undef HAVE_POW
+
+/* Define to 1 if you have the <stdint.h> header file. */
+#undef HAVE_STDINT_H
+
+/* Define to 1 if you have the <stdlib.h> header file. */
+#undef HAVE_STDLIB_H
+
+/* Define to 1 if you have the <strings.h> header file. */
+#undef HAVE_STRINGS_H
+
+/* Define to 1 if you have the <string.h> header file. */
+#undef HAVE_STRING_H
+
+/* Define to 1 if you have the <sys/stat.h> header file. */
+#undef HAVE_SYS_STAT_H
+
+/* Define to 1 if you have the <sys/types.h> header file. */
+#undef HAVE_SYS_TYPES_H
+
+/* Define to 1 if you have the <unistd.h> header file. */
+#undef HAVE_UNISTD_H
+
+/* Define to the sub-directory in which libtool stores uninstalled libraries.
+   */
+#undef LT_OBJDIR
+
+/* Name of package */
+#undef PACKAGE
+
+/* Define to the address where bug reports for this package should be sent. */
+#undef PACKAGE_BUGREPORT
+
+/* Define to the full name of this package. */
+#undef PACKAGE_NAME
+
+/* Define to the full name and version of this package. */
+#undef PACKAGE_STRING
+
+/* Define to the one symbol short name of this package. */
+#undef PACKAGE_TARNAME
+
+/* Define to the home page for this package. */
+#undef PACKAGE_URL
+
+/* Define to the version of this package. */
+#undef PACKAGE_VERSION
+
+/* Define to 1 if you have the ANSI C header files. */
+#undef STDC_HEADERS
+
+/* Define to 1 if your <sys/time.h> declares `struct tm'. */
+#undef TM_IN_SYS_TIME
+
+/* Version number of package */
+#undef VERSION
+
+/* Define to empty if `const' does not conform to ANSI C. */
+#undef const
+
+/* Define to `unsigned int' if <sys/types.h> does not define. */
+#undef size_t

configure.ac

@@ -14,154 +14,67 @@ dnl Makefile.am to upgrade the package name.
 dnl This is here to prevent earlier autoconf from being used, it
 dnl should not be necessary to regenerate configure if the time
 dnl stamps are correct
-AC_PREREQ([2.68])
+AC_PREREQ(2.59)
 
 dnl Version number stuff here:
 
-AC_INIT([libpng],[1.6.2],[png-mng-implement@lists.sourceforge.net])
-AC_CONFIG_MACRO_DIR([scripts])
-
-# libpng does not follow GNU file name conventions (hence 'foreign')
-# color-tests requires automake 1.11 or later
-# silent-rules requires automake 1.11 or later
-# dist-xz requires automake 1.11 or later
-# 1.12.2 fixes a security issue in 1.11.2 and 1.12.1
-# 1.13 is required for parallel tests
-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
-# time stamps of the autotools generated files being correct
+AC_INIT([libpng], [1.2.41beta19], [png-mng-implement@lists.sourceforge.net])
+AM_INIT_AUTOMAKE
+dnl stop configure from automagically running automake
 AM_MAINTAINER_MODE
 
-dnl configure.ac and Makefile.am expect automake 1.11.2 or a compatible later
-dnl version; aclocal.m4 will generate a failure if you use a prior version of
-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.2
+PNGLIB_VERSION=1.2.41beta19
 PNGLIB_MAJOR=1
-PNGLIB_MINOR=6
-PNGLIB_RELEASE=2
+PNGLIB_MINOR=2
+PNGLIB_RELEASE=41
 
 dnl End of version number stuff
 
 AC_CONFIG_SRCDIR([pngget.c])
-AC_CONFIG_HEADERS([config.h])
+AM_CONFIG_HEADER(config.h)
 
 # Checks for programs.
-AC_LANG([C])
 AC_PROG_CC
-AM_PROG_AS
-LT_PATH_LD
+AC_PROG_LD
 AC_PROG_CPP
-AC_PROG_AWK
+AC_CHECK_TOOL(SED, sed, :)
+AC_LIBTOOL_WIN32_DLL
 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 compatible later version may be used
-LT_INIT([win32-dll])
-LT_PREREQ([2.4.2])
-
-# Some awks crash when confronted with pnglibconf.dfa, do a test run now
-# to make sure this doesn't happen
-AC_MSG_CHECKING([that AWK works])
-if ${AWK} -f ${srcdir}/scripts/options.awk out="/dev/null" version=search\
-   ${srcdir}/pngconf.h ${srcdir}/scripts/pnglibconf.dfa\
-   ${srcdir}/pngusr.dfa 1>&2
-then
-   AC_MSG_RESULT([ok])
-else
-   AC_MSG_FAILURE([failed], 1)
-fi
-
-# This is a remnant of the old cc -E validation, where it may have been
-# necessary to use a different preprocessor for .dfn files
-DFNCPP="$CPP"
-AC_SUBST(DFNCPP)
-
-# -Werror cannot be passed to GCC in CFLAGS because configure will fail (it
-# checks the compiler with a program that generates a warning), add the
-# following option to deal with this
-AC_ARG_VAR(PNG_COPTS,
-   [additional flags for the C compiler, use this for options that would]
-   [cause configure itself to fail])
-AC_ARG_ENABLE(werror,
-   AS_HELP_STRING([[[--enable-werror[=OPT]]]],
-      [Pass -Werror or the given argument to the compiler if it is supported]),
-   [test "$enable_werror" = "yes" && enable_werror="-Werror"
-    if test "$enable_werror" != "no"; then
-      sav_CFLAGS="$CFLAGS"
-      CFLAGS="$enable_werror $CFLAGS"
-      AC_MSG_CHECKING([if the compiler allows $enable_werror])
-      AC_COMPILE_IFELSE(
-         [AC_LANG_SOURCE([
-            [int main(int argc, char **argv){]
-            [return argv[argc-1][0];]
-            [}]])],
-         AC_MSG_RESULT(yes)
-         PNG_COPTS="$PNG_COPTS $enable_werror",
-         AC_MSG_RESULT(no))
-      CFLAGS="$sav_CFLAGS"
-    fi],)
+AC_PROG_LIBTOOL
 
 # Checks for header files.
 AC_HEADER_STDC
+AC_CHECK_HEADERS([malloc.h stdlib.h string.h strings.h])
 
 # Checks for typedefs, structures, and compiler characteristics.
 AC_C_CONST
 AC_TYPE_SIZE_T
 AC_STRUCT_TM
-AC_C_RESTRICT
 
 # Checks for library functions.
 AC_FUNC_STRTOD
-AC_CHECK_FUNCS([memset], , AC_MSG_ERROR(memset not found in libc))
-AC_CHECK_FUNCS([pow], , AC_CHECK_LIB(m, pow, , AC_MSG_ERROR(cannot find pow)) )
-AC_ARG_WITH(zlib-prefix,
-   AS_HELP_STRING([[[--with-zlib-prefix]]],
-      [prefix that may have been used in installed zlib]),
-      [ZPREFIX=${withval}],
-      [ZPREFIX='z_'])
-AC_CHECK_LIB(z, zlibVersion, ,
-    AC_CHECK_LIB(z, ${ZPREFIX}zlibVersion, , AC_MSG_ERROR(zlib not installed)))
+AC_CHECK_FUNCS([memset], , AC_ERROR([memset not found in libc]))
+AC_CHECK_FUNCS([pow], , AC_CHECK_LIB(m, pow, , AC_ERROR([cannot find pow])) )
+AC_CHECK_LIB(z, zlibVersion, , AC_ERROR([zlib not installed]))
 
-# The following is for pngvalid, to ensure it catches FP errors even on
-# platforms that don't enable FP exceptions, the function appears in the math
-# library (typically), it's not an error if it is not found.
-AC_CHECK_LIB([m], [feenableexcept])
-AC_CHECK_FUNCS([feenableexcept])
-
-AC_MSG_CHECKING([if using Solaris linker])
-SLD=`$LD --version 2>&1 | grep Solaris`
-if test "$SLD"; then
-    have_solaris_ld=yes
-    AC_MSG_RESULT(yes)
-else
-    have_solaris_ld=no
-    AC_MSG_RESULT(no)
-fi
-AM_CONDITIONAL(HAVE_SOLARIS_LD, test "$have_solaris_ld" = "yes")
+LIBPNG_DEFINES=-DPNG_CONFIGURE_LIBPNG
+AC_MSG_CHECKING(
+  [if assembler code in pnggccrd.c can be compiled without PNG_NO_MMX_CODE])
+AC_TRY_COMPILE(
+  [#include "$srcdir/pnggccrd.c"],
+  [return 0;],
+  AC_MSG_RESULT(yes)
+  LIBPNG_NO_MMX="",
+  AC_MSG_RESULT(no)
+  LIBPNG_NO_MMX=-DPNG_NO_MMX_CODE)
+LIBPNG_DEFINES=$LIBPNG_DEFINES\ $LIBPNG_NO_MMX
+AC_SUBST(LIBPNG_DEFINES)
+AC_SUBST(LIBPNG_NO_MMX)
 
 AC_MSG_CHECKING([if libraries can be versioned])
-# Special case for PE/COFF platforms: ld reports
-# support for version-script, but doesn't actually
-# DO anything with it.
-case $host in
-*cygwin* | *mingw32* | *interix* )
-    have_ld_version_script=no
-    AC_MSG_RESULT(no)
-;;
-* )
-
-if test "$have_solaris_ld" = "yes"; then
-    GLD=`$LD --help < /dev/null 2>&1 | grep 'M mapfile'`
-else
-    GLD=`$LD --help < /dev/null 2>/dev/null | grep version-script`
-fi
-
+GLD=`$LD --help < /dev/null 2>/dev/null | grep version-script`
 if test "$GLD"; then
     have_ld_version_script=yes
     AC_MSG_RESULT(yes)
@@ -170,17 +83,14 @@ else
     AC_MSG_RESULT(no)
     AC_MSG_WARN(*** You have not enabled versioned symbols.)
 fi
-;;
-esac
-
 AM_CONDITIONAL(HAVE_LD_VERSION_SCRIPT, test "$have_ld_version_script" = "yes")
 
 if test "$have_ld_version_script" = "yes"; then
     AC_MSG_CHECKING([for symbol prefix])
     SYMBOL_PREFIX=`echo "PREFIX=__USER_LABEL_PREFIX__" \
-                  | ${CPP-${CC-gcc} -E} - 2>&1 \
-                  | ${EGREP-grep} "^PREFIX=" \
-                  | ${SED-sed} -e "s:^PREFIX=::" -e "s:__USER_LABEL_PREFIX__::"`
+                   | ${CPP-${CC-gcc} -E} - 2>&1 \
+                   | ${EGREP-grep} "^PREFIX=" \
+                   | ${SED-sed} "s:^PREFIX=::"`
     AC_SUBST(SYMBOL_PREFIX)
     AC_MSG_RESULT($SYMBOL_PREFIX)
 fi
@@ -194,73 +104,45 @@ AC_SUBST(PNGLIB_RELEASE)
 # Additional arguments (and substitutions)
 # Allow the pkg-config directory to be set
 AC_ARG_WITH(pkgconfigdir,
-   AS_HELP_STRING([[[--with-pkgconfigdir]]],
-      [Use the specified pkgconfig dir (default is libdir/pkgconfig)]),
-   [pkgconfigdir=${withval}],
-   [pkgconfigdir='${libdir}/pkgconfig'])
+	AC_HELP_STRING([--with-pkgconfigdir],
+	[Use the specified pkgconfig dir (default is libdir/pkgconfig)]),
+	[pkgconfigdir=${withval}],
+	[pkgconfigdir='${libdir}/pkgconfig'])
 
 AC_SUBST([pkgconfigdir])
-AC_MSG_NOTICE([[pkgconfig directory is ${pkgconfigdir}]])
+AC_MSG_NOTICE([pkgconfig directory is ${pkgconfigdir}])
 
 # Make the *-config binary config scripts optional
 AC_ARG_WITH(binconfigs,
-   AS_HELP_STRING([[[--with-binconfigs]]],
-      [Generate shell libpng-config scripts as well as pkg-config data]
-      [@<:@default=yes@:>@]),
-   [if test "${withval}" = no; then
-      binconfigs=
-      AC_MSG_NOTICE([[libpng-config scripts will not be built]])
-    else
-      binconfigs='${binconfigs}'
-    fi],
-   [binconfigs='${binconfigs}'])
+	AC_HELP_STRING([--with-binconfigs],
+		[Generate shell libpng-config scripts as well as pkg-config data]
+		[@<:@default=yes@:>@]),
+	[if test "${withval}" = no; then
+		binconfigs=
+		AC_MSG_NOTICE([libpng-config scripts will not be built])
+	else
+		binconfigs='${binconfigs}'
+	fi],
+	[binconfigs='${binconfigs}'])
 AC_SUBST([binconfigs])
 
-# Support for prefixes to the API function names; this will generate defines
-# at the start of the build to rename exported library functions
-AC_ARG_WITH(libpng-prefix,
-   AS_HELP_STRING([[[--with-libpng-prefix]]],
-      [prefix libpng exported function (API) names with the given value]),
-   [if test "${withval:-no}" != "no"; then
-      AC_SUBST([PNG_PREFIX], [${withval}])
-    fi])
-AM_CONDITIONAL([DO_PNG_PREFIX], [test "${with_libpng_prefix:-no}" != "no"])
-
-# Because GCC by default assembles code with an executable stack, even though it
-# compiles C code with a non-executable stack, it is necessary to do a fixup
-# here (this may by GCC specific)
-# AC_SUBST([AM_CCASFLAGS], [-Wa,--noexecstack])
-
-AC_ARG_ENABLE([arm-neon],
-   AS_HELP_STRING([[[--enable-arm-neon]]],
-      [Enable ARM NEON optimizations: =off, check, api, on:]
-      [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; on: turn on unconditionally.  The]
-      [default is 'on' if __ARM_NEON__ is defined, otherwise 'off'.]),
-   [case "$enableval" in
-      off)
-         AC_DEFINE([PNG_NO_ARM_NEON], [],
-                   [Disable ARM Neon optimizations]);;
-      check)
-         AC_DEFINE([PNG_ARM_NEON_CHECK_SUPPORTED], [],
-                   [Check for ARM Neon support at run-time]);;
-      api)
-         AC_DEFINE([PNG_ARM_NEON_API_SUPPORTED], [],
-                   [Turn on ARM Neon optimizations at run-time]);;
-      on)
-         AC_DEFINE([PNG_ARM_NEON_SUPPORTED], [],
-                   [Enable ARM Neon optimizations]);;
-      *)
-         AC_MSG_ERROR([arm-neon: option value required (off/check/api/on)]);;
-   esac])
-AM_CONDITIONAL([PNG_ARM_NEON], [test "${enable_arm_neon:-no}" != "no"])
-
-AC_MSG_NOTICE([[Extra options for compiler: $PNG_COPTS]])
+# Allow the old version number library, libpng.so, to be removed from
+# the build
+AC_ARG_WITH(libpng-compat,
+	AC_HELP_STRING([--with-libpng-compat],
+		[Generate the obsolete libpng.so library @<:@default=yes@:>@]),
+	[if test "${withval}" = no; then
+		compatlib=
+		AC_MSG_NOTICE([libpng.so will not be built])
+	else
+		compatlib=libpng.la
+	fi],
+	[compatlib=libpng.la])
+AC_SUBST([compatlib])
 
 # 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_CONFIG_FILES([Makefile libpng.pc:scripts/libpng.pc-configure.in])
+AC_CONFIG_FILES([libpng-config:scripts/libpng-config.in],
+		[chmod +x libpng-config])
 
 AC_OUTPUT

contrib/README.txt

@@ -1,4 +0,0 @@
-
-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.

contrib/examples/README.txt

@@ -1,24 +0,0 @@
-
-This directory (contrib/examples) contains examples of libpng usage.
-
-NO COPYRIGHT RIGHTS ARE CLAIMED TO ANY OF THE FILES IN THIS DIRECTORY.
-
-To the extent possible under law, the authors have waived all copyright and
-related or neighboring rights to this work.  This work is published from:
-United States.
-
-The files may be used freely in any way.  The intention is that appropriate
-parts of the files be used in other libpng-using programs without any need for
-the authors of the using code to seek copyright or license from the original
-authors.
-
-The source code and comments in this directory are the original work of the
-people named below.  No other person or organization has made contributions to
-the work in this directory.
-
-ORIGINAL AUTHORS
-    The following people have contributed to the code in this directory.  None
-    of the people below claim any rights with regard to the contents of this
-    directory.
-
-    John Bowler <jbowler@acm.org>

contrib/examples/iccfrompng.c

@@ -1,180 +0,0 @@
-/*- iccfrompng
- *
- * COPYRIGHT: Written by John Cunningham Bowler, 2011.
- * 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.
- *
- * Extract any icc profiles found in the given PNG files.  This is a simple
- * 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
- * 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.
- *
- * Compile and link against libpng and zlib, plus anything else required on the
- * system you use.
- *
- * To use supply a list of PNG files containing iCCP chunks, the chunks will be
- * extracted to a similarly named file with the extension replaced by 'icc',
- * which will be overwritten without warning.
- */
-#include <stdlib.h>
-#include <setjmp.h>
-#include <string.h>
-#include <stdio.h>
-
-#include <png.h>
-
-static int verbose = 1;
-static png_byte no_profile[] = "no profile";
-
-static png_bytep
-extract(FILE *fp, png_uint_32 *proflen)
-{
-   png_structp png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING,0,0,0);
-   png_infop info_ptr = NULL;
-   png_bytep result = NULL;
-
-   /* Initialize for error or no profile: */
-   *proflen = 0;
-
-   if (png_ptr == NULL)
-   {
-      fprintf(stderr, "iccfrompng: version library mismatch?\n");
-      return 0;
-   }
-
-   if (setjmp(png_jmpbuf(png_ptr)))
-   {
-      png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
-      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_charp name;
-      int compression_type;
-      png_bytep profile;
-
-      if (png_get_iCCP(png_ptr, info_ptr, &name, &compression_type, &profile,
-         proflen) & PNG_INFO_iCCP)
-      {
-         result = malloc(*proflen);
-         if (result != NULL)
-            memcpy(result, profile, *proflen);
-
-         else
-            png_error(png_ptr, "OOM allocating profile buffer");
-      }
-
-      else
-	result = no_profile;
-   }
-
-   png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
-   return result;
-}
-
-static int
-extract_one_file(const char *filename)
-{
-   int result = 0;
-   FILE *fp = fopen(filename, "rb");
-
-   if (fp != NULL)
-   {
-      png_uint_32 proflen = 0;
-      png_bytep profile = extract(fp, &proflen);
-
-      if (profile != NULL && profile != no_profile)
-      {
-         size_t len;
-         char *output;
-
-         {
-            const char *ep = strrchr(filename, '.');
-
-            if (ep != NULL)
-               len = ep-filename;
-
-            else
-               len = strlen(filename);
-         }
-
-         output = malloc(len + 5);
-         if (output != NULL)
-         {
-            FILE *of;
-
-            memcpy(output, filename, len);
-            strcpy(output+len, ".icc");
-
-            of = fopen(output, "wb");
-            if (of != NULL)
-            {
-               if (fwrite(profile, proflen, 1, of) == 1 &&
-                  fflush(of) == 0 &&
-                  fclose(of) == 0)
-               {
-                  if (verbose)
-                     printf("%s -> %s\n", filename, output);
-                  /* Success return */
-                  result = 1;
-               }
-
-               else
-               {
-                  fprintf(stderr, "%s: error writing profile\n", output);
-                  if (remove(output))
-                     fprintf(stderr, "%s: could not remove file\n", output);
-               }
-            }
-
-            else
-               fprintf(stderr, "%s: failed to open output file\n", output);
-
-            free(output);
-         }
-
-         else
-            fprintf(stderr, "%s: OOM allocating string!\n", filename);
-
-         free(profile);
-      }
-
-      else if (verbose && profile == no_profile)
-	printf("%s has no profile\n", filename);
-   }
-
-   else
-      fprintf(stderr, "%s: could not open file\n", filename);
-
-   return result;
-}
-
-int
-main(int argc, char **argv)
-{
-   int i;
-   int extracted = 0;
-
-   for (i=1; i<argc; ++i)
-   {
-      if (strcmp(argv[i], "-q") == 0)
-         verbose = 0;
-
-      else if (extract_one_file(argv[i]))
-         extracted = 1;
-   }
-
-   /* Exit code is true if any extract succeeds */
-   return extracted == 0;
-}

contrib/examples/pngpixel.c

@@ -1,368 +0,0 @@
-/*- pngpixel
- *
- * COPYRIGHT: Written by John Cunningham Bowler, 2011.
- * 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 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
- * then printed on stdout.
- *
- * The code illustrates how to do this on interlaced as well as non-interlaced
- * images.  Normally you would call png_set_interlace_handling() to have libpng
- * deal with the interlace for you, but that obliges you to buffer half of the
- * image to assemble the interlaced rows.  In this code
- * png_set_interlace_handling() is not called and, instead, the code handles the
- * interlace passes directly looking for the required pixel.
- */
-#include <stdlib.h>
-#include <stdio.h>
-#include <setjmp.h> /* required for error handling */
-
-/* Normally use <png.h> here to get the installed libpng, but this is done to
- * ensure the code picks up the local libpng implementation:
- */
-#include "../../png.h"
-
-/* 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,
-   unsigned int bit_depth, unsigned int channels)
-{
-   /* PNG images can be up to 2^31 pixels wide, but this means they can be up to
-    * 2^37 bits wide (for a 64-bit pixel - the largest possible) and hence 2^34
-    * bytes wide.  Since the row fitted into memory, however, the following must
-    * work:
-    */
-   png_uint_32 bit_offset_hi = bit_depth * ((x >> 6) * channels);
-   png_uint_32 bit_offset_lo = bit_depth * ((x & 0x3f) * channels + c);
-
-   row = (png_const_bytep)(((PNG_CONST png_byte (*)[8])row) + bit_offset_hi);
-   row += bit_offset_lo >> 3;
-   bit_offset_lo &= 0x07;
-
-   /* PNG pixels are packed into bytes to put the first pixel in the highest
-    * bits of the byte and into two bytes for 16-bit values with the high 8 bits
-    * first, so:
-    */
-   switch (bit_depth)
-   {
-      case 1: return (row[0] >> (7-bit_offset_lo)) & 0x01;
-      case 2: return (row[0] >> (6-bit_offset_lo)) & 0x03;
-      case 4: return (row[0] >> (4-bit_offset_lo)) & 0x0f;
-      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
-          * libpng itself:
-          */
-         fprintf(stderr, "pngpixel: invalid bit depth %u\n", bit_depth);
-         exit(1);
-   }
-}
-
-/* Print a pixel from a row returned by libpng; determine the row format, find
- * the pixel, and print the relevant information to stdout.
- */
-static void
-print_pixel(png_structp png_ptr, png_infop info_ptr, png_const_bytep row,
-   png_uint_32 x)
-{
-   PNG_CONST unsigned int bit_depth = png_get_bit_depth(png_ptr, info_ptr);
-
-   switch (png_get_color_type(png_ptr, info_ptr))
-   {
-      case PNG_COLOR_TYPE_GRAY:
-         printf("GRAY %u\n", component(row, x, 0, bit_depth, 1));
-         return;
-
-      /* The palette case is slightly more difficult - the palette and, if
-       * present, the tRNS ('transparency', though the values are really
-       * opacity) data must be read to give the full picture:
-       */
-      case PNG_COLOR_TYPE_PALETTE:
-         {
-            PNG_CONST unsigned int index = component(row, x, 0, bit_depth, 1);
-            png_colorp palette = NULL;
-            int num_palette = 0;
-
-            if ((png_get_PLTE(png_ptr, info_ptr, &palette, &num_palette) &
-               PNG_INFO_PLTE) && num_palette > 0 && palette != NULL)
-            {
-               png_bytep trans_alpha = NULL;
-               int num_trans = 0;
-               if ((png_get_tRNS(png_ptr, info_ptr, &trans_alpha, &num_trans,
-                  NULL) & PNG_INFO_tRNS) && num_trans > 0 &&
-                  trans_alpha != NULL)
-                  printf("INDEXED %u = %d %d %d %d\n", index,
-                     palette[index].red, palette[index].green,
-                     palette[index].blue,
-                     index < num_trans ? trans_alpha[index] : 255);
-
-               else /* no transparency */
-                  printf("INDEXED %u = %d %d %d\n", index,
-                     palette[index].red, palette[index].green,
-                     palette[index].blue);
-            }
-
-            else
-               printf("INDEXED %u = invalid index\n", index);
-         }
-         return;
-
-      case PNG_COLOR_TYPE_RGB:
-         printf("RGB %u %u %u\n", component(row, x, 0, bit_depth, 3),
-            component(row, x, 1, bit_depth, 3),
-            component(row, x, 2, bit_depth, 3));
-         return;
-
-      case PNG_COLOR_TYPE_GRAY_ALPHA:
-         printf("GRAY+ALPHA %u %u\n", component(row, x, 0, bit_depth, 2),
-            component(row, x, 1, bit_depth, 2));
-         return;
-
-      case PNG_COLOR_TYPE_RGB_ALPHA:
-         printf("RGBA %u %u %u %u\n", component(row, x, 0, bit_depth, 4),
-            component(row, x, 1, bit_depth, 4),
-            component(row, x, 2, bit_depth, 4),
-            component(row, x, 3, bit_depth, 4));
-         return;
-
-      default:
-         png_error(png_ptr, "invalid color type");
-   }
-}
-
-int main(int argc, const char **argv)
-{
-   /* This program uses the default, <setjmp.h> based, libpng error handling
-    * mechanism, therefore any local variable that exists before the call to
-    * setjmp and is changed after the call to setjmp returns successfully must
-    * be declared with 'volatile' to ensure that their values don't get
-    * destroyed by longjmp:
-    */
-   volatile int result = 1/*fail*/;
-
-   if (argc == 4)
-   {
-      long x = atol(argv[1]);
-      long y = atol(argv[2]);
-      FILE *f = fopen(argv[3], "rb");
-      volatile png_bytep row = NULL;
-
-      if (f != NULL)
-      {
-         /* libpng requires a callback function for handling errors; this
-          * callback must not return.  The default callback function uses a
-          * stored <setjmp.h> style jmp_buf which is held in a png_struct and
-          * writes error messages to stderr.  Creating the png_struct is a
-          * little tricky; just copy the following code.
-          */
-         png_structp png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING,
-            NULL, NULL, NULL);
-
-         if (png_ptr != NULL)
-         {
-            png_infop info_ptr = png_create_info_struct(png_ptr);
-
-            if (info_ptr != NULL)
-            {
-               /* Declare stack variables to hold pointers to locally allocated
-                * data.
-                */
-
-               /* Initialize the error control buffer: */
-               if (setjmp(png_jmpbuf(png_ptr)) == 0)
-               {
-                  png_uint_32 width, height;
-                  int bit_depth, color_type, interlace_method,
-                     compression_method, filter_method;
-                  png_bytep row_tmp;
-
-                  /* Now associate the recently opened (FILE*) with the default
-                   * libpng initialization functions.  Sometimes libpng is
-                   * compiled without stdio support (it can be difficult to do
-                   * in some environments); in that case you will have to write
-                   * your own read callback to read data from the (FILE*).
-                   */
-                  png_init_io(png_ptr, f);
-
-                  /* And read the first part of the PNG file - the header and
-                   * all the information up to the first pixel.
-                   */
-                  png_read_info(png_ptr, info_ptr);
-
-                  /* This fills in enough information to tell us the width of
-                   * each row in bytes, allocate the appropriate amount of
-                   * space.  In this case png_malloc is used - it will not
-                   * return if memory isn't available.
-                   */
-                  row = png_malloc(png_ptr, png_get_rowbytes(png_ptr,
-                     info_ptr));
-
-                  /* To avoid the overhead of using a volatile auto copy row_tmp
-                   * to a local here - just use row for the png_free below.
-                   */
-                  row_tmp = row;
-
-                  /* All the information we need is in the header is returned by
-                   * png_get_IHDR, if this fails we can now use 'png_error' to
-                   * signal the error and return control to the setjmp above.
-                   */
-                  if (png_get_IHDR(png_ptr, info_ptr, &width, &height,
-                     &bit_depth, &color_type, &interlace_method,
-                     &compression_method, &filter_method))
-                  {
-                     int passes, pass;
-
-                     /* png_set_interlace_handling returns the number of
-                      * passes required as well as turning on libpng's
-                      * handling, but since we do it ourselves this is
-                      * necessary:
-                      */
-                     switch (interlace_method)
-                     {
-                        case PNG_INTERLACE_NONE:
-                           passes = 1;
-                           break;
-
-                        case PNG_INTERLACE_ADAM7:
-                           passes = PNG_INTERLACE_ADAM7_PASSES;
-                           break;
-
-                        default:
-                           png_error(png_ptr, "pngpixel: unknown interlace");
-                     }
-
-                     /* Now read the pixels, pass-by-pass, row-by-row: */
-                     png_start_read_image(png_ptr);
-
-                     for (pass=0; pass<passes; ++pass)
-                     {
-                        png_uint_32 ystart, xstart, ystep, xstep;
-                        png_uint_32 py;
-
-                        if (interlace_method == PNG_INTERLACE_ADAM7)
-                        {
-                           /* Sometimes the whole pass is empty because the
-                            * image is too narrow or too short.  libpng
-                            * expects to be called for each row that is
-                            * present in the pass, so it may be necessary to
-                            * skip the loop below (over py) if the image is
-                            * too narrow.
-                            */
-                           if (PNG_PASS_COLS(width, pass) == 0)
-                              continue;
-
-                           /* We need the starting pixel and the offset
-                            * between each pixel in this pass; use the macros
-                            * in png.h:
-                            */
-                           xstart = PNG_PASS_START_COL(pass);
-                           ystart = PNG_PASS_START_ROW(pass);
-                           xstep = PNG_PASS_COL_OFFSET(pass);
-                           ystep = PNG_PASS_ROW_OFFSET(pass);
-                        }
-
-                        else
-                        {
-                           ystart = xstart = 0;
-                           ystep = xstep = 1;
-                        }
-
-                        /* To find the pixel, loop over 'py' for each pass
-                         * reading a row and then checking to see if it
-                         * contains the pixel.
-                         */
-                        for (py = ystart; py < height; py += ystep)
-                        {
-                           png_uint_32 px, ppx;
-
-                           /* png_read_row takes two pointers.  When libpng
-                            * handles the interlace the first is filled in
-                            * pixel-by-pixel, and the second receives the same
-                            * pixels but they are replicated across the
-                            * unwritten pixels so far for each pass.  When we
-                            * do the interlace, however, they just contain
-                            * the pixels from the interlace pass - giving
-                            * both is wasteful and pointless, so we pass a
-                            * NULL pointer.
-                            */
-                           png_read_row(png_ptr, row_tmp, NULL);
-
-                           /* Now find the pixel if it is in this row; there
-                            * are, of course, much better ways of doing this
-                            * than using a for loop:
-                            */
-                           if (y == py) for (px = xstart, ppx = 0;
-                              px < width; px += xstep, ++ppx) if (x == px)
-                           {
-                              /* 'ppx' is the index of the pixel in the row
-                               * buffer.
-                               */
-                              print_pixel(png_ptr, info_ptr, row_tmp, ppx);
-
-                              /* Now terminate the loops early - we have
-                               * found and handled the required data.
-                               */
-                              goto pass_loop_end;
-                           } /* x loop */
-                        } /* y loop */
-                     } /* pass loop */
-
-                     /* Finally free the temporary buffer: */
-                  pass_loop_end:
-                     row = NULL;
-                     png_free(png_ptr, row_tmp);
-                  }
-
-                  else
-                     png_error(png_ptr, "pngpixel: png_get_IHDR failed");
-
-               }
-
-               else
-               {
-                  /* Else libpng has raised an error.  An error message has
-                   * already been output, so it is only necessary to clean up
-                   * locally allocated data:
-                   */
-                  if (row != NULL)
-                  {
-                     /* The default implementation of png_free never errors out
-                      * (it just crashes if something goes wrong), but the safe
-                      * way of using it is still to clear 'row' before calling
-                      * png_free:
-                      */
-                     png_bytep row_tmp = row;
-                     row = NULL;
-                     png_free(png_ptr, row_tmp);
-                  }
-               }
-
-               png_destroy_info_struct(png_ptr, &info_ptr);
-            }
-
-            else
-               fprintf(stderr, "pngpixel: out of memory allocating png_info\n");
-
-            png_destroy_read_struct(&png_ptr, NULL, NULL);
-         }
-
-         else
-            fprintf(stderr, "pngpixel: out of memory allocating png_struct\n");
-      }
-
-      else
-         fprintf(stderr, "pngpixel: %s: could not open file\n", argv[3]);
-   }
-
-   else
-      /* Wrong number of arguments */
-      fprintf(stderr, "pngpixel: usage: pngpixel x y png-file\n");
-
-   return result;
-}

contrib/examples/pngtopng.c

@@ -1,92 +0,0 @@
-/*- pngtopng
- *
- * COPYRIGHT: Written by John Cunningham Bowler, 2011.
- * 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 a PNG and write it out in a fixed format, using the 'simplified API'
- * that was introduced in libpng-1.6.0.
- *
- * This sample code is just the code from the top of 'example.c' with some error
- * handling added.  See example.c for more comments.
- */
-#include <stddef.h>
-#include <stdlib.h>
-#include <string.h>
-#include <stdio.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:
- */
-#include "../../png.h"
-
-int main(int argc, const char **argv)
-{
-   int result = 1;
-
-   if (argc == 3)
-   {
-      png_image image;
-
-      /* Only the image structure version number needs to be set. */
-      memset(&image, 0, sizeof image);
-      image.version = PNG_IMAGE_VERSION;
-
-      if (png_image_begin_read_from_file(&image, argv[1]))
-      {
-         png_bytep buffer;
-
-         /* Change this to try different formats!  If you set a colormap format
-          * then you must also supply a colormap below.
-          */
-         image.format = PNG_FORMAT_RGBA;
-
-         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 */))
-            {
-               if (png_image_write_to_file(&image, argv[2],
-                  0/*convert_to_8bit*/, buffer, 0/*row_stride*/,
-                  NULL/*colormap*/))
-                  result = 0;
-
-               else
-                  fprintf(stderr, "pngtopng: write %s: %s\n", argv[2],
-                      image.message);
-
-               free(buffer);
-            }
-
-            else
-            {
-               fprintf(stderr, "pngtopng: read %s: %s\n", argv[1],
-                   image.message);
-
-               /* 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
-            fprintf(stderr, "pngtopng: out of memory: %lu bytes\n",
-               (unsigned long)PNG_IMAGE_SIZE(image));
-      }
-
-      else
-         /* Failed to read the first argument: */
-         fprintf(stderr, "pngtopng: %s: %s\n", argv[1], image.message);
-   }
-
-   else
-      /* Wrong number of arguments */
-      fprintf(stderr, "pngtopng: usage: pngtopng input-file output-file\n");
-
-   return result;
-}

contrib/gregbook/COPYING

@@ -1,12 +1,12 @@
-                    GNU GENERAL PUBLIC LICENSE
-                       Version 2, June 1991
+		    GNU GENERAL PUBLIC LICENSE
+		       Version 2, June 1991
 
  Copyright (C) 1989, 1991 Free Software Foundation, Inc.
      59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  Everyone is permitted to copy and distribute verbatim copies
  of this license document, but changing it is not allowed.
 
-                            Preamble
+			    Preamble
 
   The licenses for most software are designed to take away your
 freedom to share and change it.  By contrast, the GNU General Public
@@ -56,7 +56,7 @@ patent must be licensed for everyone's free use or not licensed at all.
   The precise terms and conditions for copying, distribution and
 modification follow.
 
-                    GNU GENERAL PUBLIC LICENSE
+		    GNU GENERAL PUBLIC LICENSE
    TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
 
   0. This License applies to any program or other work which contains
@@ -255,7 +255,7 @@ make exceptions for this.  Our decision will be guided by the two goals
 of preserving the free status of all derivatives of our free software and
 of promoting the sharing and reuse of software generally.
 
-                            NO WARRANTY
+			    NO WARRANTY
 
   11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
 FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
@@ -277,9 +277,9 @@ YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
 PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
 POSSIBILITY OF SUCH DAMAGES.
 
-                     END OF TERMS AND CONDITIONS
+		     END OF TERMS AND CONDITIONS
 
-            How to Apply These Terms to Your New Programs
+	    How to Apply These Terms to Your New Programs
 
   If you develop a new program, and you want it to be of the greatest
 possible use to the public, the best way to achieve this is to make it

contrib/gregbook/Makefile.sgi

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

contrib/gregbook/Makefile.unx

@@ -26,14 +26,14 @@
 # macros --------------------------------------------------------------------
 
 #PNGDIR = /usr/local/lib
-#PNGINC = -I/usr/local/include/libpng16
-#PNGLIBd = -L$(PNGDIR) -lpng16 # dynamically linked, installed libpng
-#PNGLIBs = $(PNGDIR)/libpng16.a # statically linked, installed libpng
+#PNGINC = -I/usr/local/include/libpng12
+#PNGLIBd = -L$(PNGDIR) -lpng12 # dynamically linked, installed libpng
+#PNGLIBs = $(PNGDIR)/libpng12.a # statically linked, installed libpng
 # or:
 PNGDIR = ../..#	this one is for libpng-x.y.z/contrib/gregbook builds
 #PNGDIR = ../libpng
 PNGINC = -I$(PNGDIR)
-PNGLIBd = -Wl,-rpath,$(PNGDIR) -L$(PNGDIR) -lpng16	# dynamically linked
+PNGLIBd = -Wl,-rpath,$(PNGDIR) -L$(PNGDIR) -lpng12	# dynamically linked
 PNGLIBs = $(PNGDIR)/libpng.a		# statically linked, local libpng
 
 ZDIR = /usr/local/lib

contrib/gregbook/Makefile.w32

@@ -18,7 +18,7 @@
 # "c:\windows\command.com /e:4096" as the program command line and set the
 # working directory to this directory.  Then double-click to open the new
 # DOS-prompt window with a bigger environment and retry the commands above.
-#
+# 
 # This makefile assumes libpng and zlib have already been built or downloaded
 # and are in subdirectories at the same level as the current subdirectory
 # (as indicated by the PNGPATH and ZPATH macros below).  Edit as appropriate.

contrib/gregbook/README

@@ -63,9 +63,9 @@ BUILD INSTRUCTIONS
 
  - Prerequisites (in order of compilation):
 
-      - zlib            http://zlib.net/
-      - libpng          http://www.libpng.org/pub/png/libpng.html
-      - pngbook         http://www.libpng.org/pub/png/book/sources.html
+      - zlib		http://zlib.net/
+      - libpng		http://www.libpng.org/pub/png/libpng.html
+      - pngbook		http://www.libpng.org/pub/png/book/sources.html
 
      The pngbook demo programs are explicitly designed to demonstrate proper
      coding techniques for using the libpng reference library.  As a result,
@@ -104,7 +104,7 @@ BUILD INSTRUCTIONS
      unpacked the source code.
 
      For MSVC, set up the necessary environment variables by invoking
-
+ 
         %devstudio%\vc\bin\vcvars32.bat
 
      where where %devstudio% is the installation directory for MSVC /
@@ -165,19 +165,19 @@ RUNNING THE PROGRAMS:  (VERY) BRIEF INTRO
      rpng is a simple PNG viewer that can display transparent PNGs with a
      specified background color; for example,
 
-        rpng -bgcolor \#ff0000 toucan.png
+	rpng -bgcolor #ff0000 toucan.png
 
      would display the image with a red background.  rpng2 is a progressive
      viewer that simulates a web browser in some respects; it can display
      images against either a background color or a dynamically generated
      background image.  For example:
 
-        rpng2 -bgpat 16 toucan.png
+	rpng2 -bgpat 16 toucan.png
 
      wpng is a purely command-line image converter from binary PBMPLUS/NetPBM
      format (.pgm or .ppm) to PNG; for example,
 
-        wpng -time < toucan-notrans.ppm > toucan-notrans.png
+	wpng -time < toucan-notrans.ppm > toucan-notrans.png
 
      would convert the specified PPM file (using redirection) to PNG, auto-
      matically setting the PNG modification-time chunk.

contrib/gregbook/makevms.com

@@ -20,13 +20,13 @@ $ if zpath .eqs. ""
 $ then
 $   write sys$output "zlib include not found. Exiting..."
 $   exit 2
-$ endif
+$ endif 
 $!
 $ if pngpath .eqs. ""
 $ then
 $   write sys$output "libpng include not found. Exiting..."
 $   exit 2
-$ endif
+$ endif 
 $!
 $!    Look for the compiler used.
 $!

contrib/gregbook/readpng.c

@@ -55,9 +55,8 @@
 
 #include <stdio.h>
 #include <stdlib.h>
-#include <zlib.h>
 
-#include "png.h"        /* libpng header */
+#include "png.h"        /* libpng header; includes zlib.h */
 #include "readpng.h"    /* typedefs, common macros, public prototypes */
 
 /* future versions of libpng will provide this macro: */
@@ -215,10 +214,6 @@ uch *readpng_get_image(double display_exponent, int *pChannels, ulg *pRowbytes)
      * libpng function */
 
     if (setjmp(png_jmpbuf(png_ptr))) {
-        free(image_data);
-        image_data = NULL;
-        free(row_pointers);
-        row_pointers = NULL;
         png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
         return NULL;
     }
@@ -234,14 +229,8 @@ uch *readpng_get_image(double display_exponent, int *pChannels, ulg *pRowbytes)
         png_set_expand(png_ptr);
     if (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS))
         png_set_expand(png_ptr);
-#ifdef PNG_READ_16_TO_8_SUPPORTED
     if (bit_depth == 16)
-#  ifdef PNG_READ_SCALE_16_TO_8_SUPPORTED
-        png_set_scale_16(png_ptr);
-#  else
         png_set_strip_16(png_ptr);
-#  endif
-#endif
     if (color_type == PNG_COLOR_TYPE_GRAY ||
         color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
         png_set_gray_to_rgb(png_ptr);
@@ -274,8 +263,7 @@ uch *readpng_get_image(double display_exponent, int *pChannels, ulg *pRowbytes)
         return NULL;
     }
 
-    Trace((stderr, "readpng_get_image:  channels = %d, rowbytes = %ld, height = %ld\n",
-        *pChannels, rowbytes, height));
+    Trace((stderr, "readpng_get_image:  channels = %d, rowbytes = %ld, height = %ld\n", *pChannels, rowbytes, height));
 
 
     /* set the individual row_pointers to point at the correct offsets */

contrib/gregbook/readpng2.c

@@ -55,10 +55,8 @@
 
 
 #include <stdlib.h>     /* for exit() prototype */
-#include <setjmp.h>
 
-#include <zlib.h>
-#include "png.h"        /* libpng header from the local directory */
+#include "png.h"        /* libpng header; includes zlib.h and setjmp.h */
 #include "readpng2.h"   /* typedefs, common macros, public prototypes */
 
 
@@ -75,10 +73,84 @@ static void readpng2_error_handler(png_structp png_ptr, png_const_charp msg);
 
 void readpng2_version_info(void)
 {
-    fprintf(stderr, "   Compiled with libpng %s; using libpng %s\n",
-      PNG_LIBPNG_VER_STRING, png_libpng_ver);
+#if defined(PNG_ASSEMBLER_CODE_SUPPORTED) && \
+    (defined(__i386__) || defined(_M_IX86) || defined(__x86_64__)) && \
+    defined(PNG_LIBPNG_VER) && (PNG_LIBPNG_VER >= 10200)
+    /*
+     * WARNING:  This preprocessor approach means that the following code
+     *           cannot be used with a libpng DLL older than 1.2.0--the
+     *           compiled-in symbols for the new functions will not exist.
+     *           (Could use dlopen() and dlsym() on Unix and corresponding
+     *           calls for Windows, but not portable...)
+     */
+    {
+        int mmxsupport = png_mmx_support();
+        if (mmxsupport < 0)
+            fprintf(stderr, "   Compiled with libpng %s; using libpng %s "
+              "without MMX support.\n", PNG_LIBPNG_VER_STRING, png_libpng_ver);
+        else {
+            int compilerID;
+            png_uint_32 mmx_mask = png_get_mmx_flagmask(
+              PNG_SELECT_READ | PNG_SELECT_WRITE, &compilerID);
 
-    fprintf(stderr, "   and with zlib %s; using zlib %s.\n",
+            fprintf(stderr, "   Compiled with libpng %s; using libpng %s "
+              "with MMX support\n   (%s version).", PNG_LIBPNG_VER_STRING,
+              png_libpng_ver, compilerID == 1? "MSVC++" :
+              (compilerID == 2? "GNU C" : "unknown"));
+            fprintf(stderr, "  Processor (x86%s) %s MMX instructions.\n",
+#if defined(__x86_64__)
+              "_64",
+#else
+              "",
+#endif
+              mmxsupport? "supports" : "does not support");
+            if (mmxsupport > 0) {
+                int num_optims = 0;
+
+                fprintf(stderr,
+                  "      Potential MMX optimizations supported by libpng:\n");
+                if (mmx_mask & PNG_ASM_FLAG_MMX_READ_FILTER_SUB)
+                    ++num_optims;
+                if (mmx_mask & PNG_ASM_FLAG_MMX_READ_FILTER_UP)
+                    ++num_optims;
+                if (mmx_mask & PNG_ASM_FLAG_MMX_READ_FILTER_AVG)
+                    ++num_optims;
+                if (mmx_mask & PNG_ASM_FLAG_MMX_READ_FILTER_PAETH)
+                    ++num_optims;
+                if (num_optims)
+                    fprintf(stderr,
+                      "         decoding %s row filters (reading)\n",
+                      (num_optims == 4)? "all non-trivial" : "some");
+                if (mmx_mask & PNG_ASM_FLAG_MMX_READ_COMBINE_ROW) {
+                    fprintf(stderr, "         combining rows (reading)\n");
+                    ++num_optims;
+                }
+                if (mmx_mask & PNG_ASM_FLAG_MMX_READ_INTERLACE) {
+                    fprintf(stderr,
+                      "         expanding interlacing (reading)\n");
+                    ++num_optims;
+                }
+                mmx_mask &= ~( PNG_ASM_FLAG_MMX_READ_COMBINE_ROW  \
+                             | PNG_ASM_FLAG_MMX_READ_INTERLACE    \
+                             | PNG_ASM_FLAG_MMX_READ_FILTER_SUB   \
+                             | PNG_ASM_FLAG_MMX_READ_FILTER_UP    \
+                             | PNG_ASM_FLAG_MMX_READ_FILTER_AVG   \
+                             | PNG_ASM_FLAG_MMX_READ_FILTER_PAETH );
+                if (mmx_mask) {
+                    fprintf(stderr, "         other (unknown)\n");
+                    ++num_optims;
+                }
+                if (num_optims == 0)
+                    fprintf(stderr, "         (none)\n");
+            }
+        }
+    }
+#else
+    fprintf(stderr, "   Compiled with libpng %s; using libpng %s "
+      "without MMX support.\n", PNG_LIBPNG_VER_STRING, png_libpng_ver);
+#endif
+
+    fprintf(stderr, "   Compiled with zlib %s; using zlib %s.\n",
       ZLIB_VERSION, zlib_version);
 }
 
@@ -131,30 +203,36 @@ int readpng2_init(mainprog_info *mainprog_ptr)
     }
 
 
-#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED
+#ifdef PNG_UNKNOWN_CHUNKS_SUPPORTED
     /* prepare the reader to ignore all recognized chunks whose data won't be
      * used, i.e., all chunks recognized by libpng except for IHDR, PLTE, IDAT,
      * IEND, tRNS, bKGD, gAMA, and sRGB (small performance improvement) */
     {
-        /* These byte strings were copied from png.h.  If a future version
-         * of readpng2.c recognizes more chunks, add them to this list.
-         */
-        static PNG_CONST png_byte chunks_to_process[] = {
-            98,  75,  71,  68, '\0',  /* bKGD */
-           103,  65,  77,  65, '\0',  /* gAMA */
-           115,  82,  71,  66, '\0',  /* sRGB */
-           };
+        /* These byte strings were copied from png.h.  If a future libpng
+         * version recognizes more chunks, add them to this list.  If a
+         * future version of readpng2.c recognizes more chunks, delete them
+         * from this list. */
+        static const png_byte chunks_to_ignore[] = {
+             99,  72,  82,  77, '\0',  /* cHRM */
+            104,  73,  83,  84, '\0',  /* hIST */
+            105,  67,  67,  80, '\0',  /* iCCP */
+            105,  84,  88, 116, '\0',  /* iTXt */
+            111,  70,  70, 115, '\0',  /* oFFs */
+            112,  67,  65,  76, '\0',  /* pCAL */
+            112,  72,  89, 115, '\0',  /* pHYs */
+            115,  66,  73,  84, '\0',  /* sBIT */
+            115,  67,  65,  76, '\0',  /* sCAL */
+            115,  80,  76,  84, '\0',  /* sPLT */
+            115,  84,  69,  82, '\0',  /* sTER */
+            116,  69,  88, 116, '\0',  /* tEXt */
+            116,  73,  77,  69, '\0',  /* tIME */
+            122,  84,  88, 116, '\0'   /* zTXt */
+        };
 
-       /* Ignore all chunks except for IHDR, PLTE, tRNS, IDAT, and IEND */
-       png_set_keep_unknown_chunks(png_ptr, -1 /* PNG_HANDLE_CHUNK_NEVER */,
-          NULL, -1);
-
-       /* But do not ignore chunks in the "chunks_to_process" list */
-       png_set_keep_unknown_chunks(png_ptr,
-          0 /* PNG_HANDLE_CHUNK_AS_DEFAULT */, chunks_to_process,
-          sizeof(chunks_to_process)/5);
+        png_set_keep_unknown_chunks(png_ptr, 1 /* PNG_HANDLE_CHUNK_NEVER */,
+          chunks_to_ignore, sizeof(chunks_to_ignore)/5);
     }
-#endif /* PNG_HANDLE_AS_UNKNOWN_SUPPORTED */
+#endif /* PNG_UNKNOWN_CHUNKS_SUPPORTED */
 
 
     /* instead of doing png_init_io() here, now we set up our callback
@@ -164,6 +242,96 @@ int readpng2_init(mainprog_info *mainprog_ptr)
       readpng2_info_callback, readpng2_row_callback, readpng2_end_callback);
 
 
+    /*
+     * may as well enable or disable MMX routines here, if supported;
+     *
+     * to enable all:  mask = png_get_mmx_flagmask (
+     *                   PNG_SELECT_READ | PNG_SELECT_WRITE, &compilerID);
+     *                 flags = png_get_asm_flags (png_ptr);
+     *                 flags |= mask;
+     *                 png_set_asm_flags (png_ptr, flags);
+     *
+     * to disable all:  mask = png_get_mmx_flagmask (
+     *                   PNG_SELECT_READ | PNG_SELECT_WRITE, &compilerID);
+     *                  flags = png_get_asm_flags (png_ptr);
+     *                  flags &= ~mask;
+     *                  png_set_asm_flags (png_ptr, flags);
+     */
+
+#if (defined(__i386__) || defined(_M_IX86) || defined(__x86_64__)) && \
+    defined(PNG_LIBPNG_VER) && (PNG_LIBPNG_VER >= 10200)
+    /*
+     * WARNING:  This preprocessor approach means that the following code
+     *           cannot be used with a libpng DLL older than 1.2.0--the
+     *           compiled-in symbols for the new functions will not exist.
+     *           (Could use dlopen() and dlsym() on Unix and corresponding
+     *           calls for Windows, but not portable...)
+     */
+    {
+#ifdef PNG_ASSEMBLER_CODE_SUPPORTED
+        png_uint_32 mmx_disable_mask = 0;
+        png_uint_32 asm_flags, mmx_mask;
+        int compilerID;
+
+        if (mainprog_ptr->nommxfilters)
+            mmx_disable_mask |= ( PNG_ASM_FLAG_MMX_READ_FILTER_SUB   \
+                                | PNG_ASM_FLAG_MMX_READ_FILTER_UP    \
+                                | PNG_ASM_FLAG_MMX_READ_FILTER_AVG   \
+                                | PNG_ASM_FLAG_MMX_READ_FILTER_PAETH );
+        if (mainprog_ptr->nommxcombine)
+            mmx_disable_mask |= PNG_ASM_FLAG_MMX_READ_COMBINE_ROW;
+        if (mainprog_ptr->nommxinterlace)
+            mmx_disable_mask |= PNG_ASM_FLAG_MMX_READ_INTERLACE;
+        asm_flags = png_get_asm_flags(png_ptr);
+        png_set_asm_flags(png_ptr, asm_flags & ~mmx_disable_mask);
+
+
+        /* Now query libpng's asm settings, just for yuks.  Note that this
+         * differs from the querying of its *potential* MMX capabilities
+         * in readpng2_version_info(); this is true runtime verification. */
+
+        asm_flags = png_get_asm_flags(png_ptr);
+        mmx_mask = png_get_mmx_flagmask(PNG_SELECT_READ | PNG_SELECT_WRITE,
+          &compilerID);
+        if (asm_flags & PNG_ASM_FLAG_MMX_SUPPORT_COMPILED)
+            fprintf(stderr,
+              "  MMX support (%s version) is compiled into libpng\n",
+              compilerID == 1? "MSVC++" :
+              (compilerID == 2? "GNU C" : "unknown"));
+        else
+            fprintf(stderr, "  MMX support is not compiled into libpng\n");
+        fprintf(stderr, "  MMX instructions are %ssupported by CPU\n",
+          (asm_flags & PNG_ASM_FLAG_MMX_SUPPORT_IN_CPU)? "" : "not ");
+        fprintf(stderr, "  MMX read support for combining rows is %sabled\n",
+          (asm_flags & PNG_ASM_FLAG_MMX_READ_COMBINE_ROW)? "en" : "dis");
+        fprintf(stderr,
+          "  MMX read support for expanding interlacing is %sabled\n",
+          (asm_flags & PNG_ASM_FLAG_MMX_READ_INTERLACE)? "en" : "dis");
+        fprintf(stderr, "  MMX read support for \"sub\" filter is %sabled\n",
+          (asm_flags & PNG_ASM_FLAG_MMX_READ_FILTER_SUB)? "en" : "dis");
+        fprintf(stderr, "  MMX read support for \"up\" filter is %sabled\n",
+          (asm_flags & PNG_ASM_FLAG_MMX_READ_FILTER_UP)? "en" : "dis");
+        fprintf(stderr, "  MMX read support for \"avg\" filter is %sabled\n",
+          (asm_flags & PNG_ASM_FLAG_MMX_READ_FILTER_AVG)? "en" : "dis");
+        fprintf(stderr, "  MMX read support for \"Paeth\" filter is %sabled\n",
+          (asm_flags & PNG_ASM_FLAG_MMX_READ_FILTER_PAETH)? "en" : "dis");
+        asm_flags &= (mmx_mask & ~( PNG_ASM_FLAG_MMX_READ_COMBINE_ROW  \
+                                  | PNG_ASM_FLAG_MMX_READ_INTERLACE    \
+                                  | PNG_ASM_FLAG_MMX_READ_FILTER_SUB   \
+                                  | PNG_ASM_FLAG_MMX_READ_FILTER_UP    \
+                                  | PNG_ASM_FLAG_MMX_READ_FILTER_AVG   \
+                                  | PNG_ASM_FLAG_MMX_READ_FILTER_PAETH ));
+        if (asm_flags)
+            fprintf(stderr,
+              "  additional MMX support is also enabled (0x%02lx)\n",
+              asm_flags);
+#else  /* !PNG_ASSEMBLER_CODE_SUPPORTED */
+        fprintf(stderr, "  MMX querying is disabled in libpng.\n");
+#endif /* ?PNG_ASSEMBLER_CODE_SUPPORTED */
+    }
+#endif
+
+
     /* make sure we save our pointers for use in readpng2_decode_data() */
 
     mainprog_ptr->png_ptr = png_ptr;
@@ -212,11 +380,7 @@ static void readpng2_info_callback(png_structp png_ptr, png_infop info_ptr)
     mainprog_info  *mainprog_ptr;
     int  color_type, bit_depth;
     png_uint_32 width, height;
-#ifdef PNG_FLOATING_POINT_SUPPORTED
     double  gamma;
-#else
-    png_fixed_point gamma;
-#endif
 
 
     /* setjmp() doesn't make sense here, because we'd either have to exit(),
@@ -305,14 +469,8 @@ static void readpng2_info_callback(png_structp png_ptr, png_infop info_ptr)
         png_set_expand(png_ptr);
     if (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS))
         png_set_expand(png_ptr);
-#ifdef PNG_READ_16_TO_8_SUPPORTED
     if (bit_depth == 16)
-#  ifdef PNG_READ_SCALE_16_TO_8_SUPPORTED
-        png_set_scale_16(png_ptr);
-#  else
         png_set_strip_16(png_ptr);
-#  endif
-#endif
     if (color_type == PNG_COLOR_TYPE_GRAY ||
         color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
         png_set_gray_to_rgb(png_ptr);
@@ -333,19 +491,11 @@ static void readpng2_info_callback(png_structp png_ptr, png_infop info_ptr)
      * "gamma" value for the entire display system, i.e., the product of
      * LUT_exponent and CRT_exponent. */
 
-#ifdef PNG_FLOATING_POINT_SUPPORTED
     if (png_get_gAMA(png_ptr, info_ptr, &gamma))
         png_set_gamma(png_ptr, mainprog_ptr->display_exponent, gamma);
     else
         png_set_gamma(png_ptr, mainprog_ptr->display_exponent, 0.45455);
-#else
-    if (png_get_gAMA_fixed(png_ptr, info_ptr, &gamma))
-        png_set_gamma_fixed(png_ptr,
-            (png_fixed_point)(100000*mainprog_ptr->display_exponent+.5), gamma);
-    else
-        png_set_gamma_fixed(png_ptr,
-            (png_fixed_point)(100000*mainprog_ptr->display_exponent+.5), 45455);
-#endif
+
 
     /* we'll let libpng expand interlaced images, too */
 
@@ -494,12 +644,5 @@ static void readpng2_error_handler(png_structp png_ptr, png_const_charp msg)
         exit(99);
     }
 
-    /* Now we have our data structure we can use the information in it
-     * to return control to our own higher level code (all the points
-     * where 'setjmp' is called in this file.)  This will work with other
-     * error handling mechanisms as well - libpng always calls png_error
-     * when it can proceed no further, thus, so long as the error handler
-     * is intercepted, application code can do its own error recovery.
-     */
     longjmp(mainprog_ptr->jmpbuf, 1);
 }

contrib/gregbook/readpng2.h

@@ -96,6 +96,11 @@ typedef struct _mainprog_info {
     int rowbytes;
     int channels;
     int need_bgcolor;
+#if (defined(__i386__) || defined(_M_IX86) || defined(__x86_64__))
+    int nommxfilters;
+    int nommxcombine;
+    int nommxinterlace;
+#endif
     int state;
     uch bg_red;
     uch bg_green;

contrib/gregbook/rpng-win.c

@@ -85,33 +85,7 @@
 #include <string.h>
 #include <time.h>
 #include <windows.h>
-#ifdef __CYGWIN__
-/* getch replacement. Turns out, we don't really need this,
- * but leave it here if we ever enable any of the uses of
- * _getch in the main code
- */
-#include <unistd.h>
-#include <termio.h>
-#include <sys/ioctl.h>
-int repl_getch( void )
-{
-  char ch;
-  int fd = fileno(stdin);
-  struct termio old_tty, new_tty;
-
-  ioctl(fd, TCGETA, &old_tty);
-  new_tty = old_tty;
-  new_tty.c_lflag &= ~(ICANON | ECHO | ISIG);
-  ioctl(fd, TCSETA, &new_tty);
-  fread(&ch, 1, sizeof(ch), stdin);
-  ioctl(fd, TCSETA, &old_tty);
-
-  return ch;
-}
-#define _getch repl_getch
-#else
 #include <conio.h>      /* only for _getch() */
-#endif
 
 /* #define DEBUG  :  this enables the Trace() macros */
 
@@ -179,7 +153,7 @@ int WINAPI WinMain(HINSTANCE hInst, HINSTANCE hPrevInst, PSTR cmd, int showmode)
 
     filename = (char *)NULL;
 
-#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@realviz.com for supplying the magical
@@ -188,7 +162,6 @@ int WINAPI WinMain(HINSTANCE hInst, HINSTANCE hPrevInst, PSTR cmd, int showmode)
     AllocConsole();
     freopen("CONOUT$", "a", stderr);
     freopen("CONOUT$", "a", stdout);
-#endif
 
 
     /* Next set the default value for our display-system exponent, i.e.,
@@ -306,9 +279,7 @@ int WINAPI WinMain(HINSTANCE hInst, HINSTANCE hPrevInst, PSTR cmd, int showmode)
     /* print usage screen if any errors up to this point */
 
     if (error) {
-#ifndef __CYGWIN__
         int ch;
-#endif
 
         fprintf(stderr, "\n%s %s:  %s\n\n", PROGNAME, VERSION, appname);
         readpng_version_info();
@@ -322,15 +293,11 @@ int WINAPI WinMain(HINSTANCE hInst, HINSTANCE hPrevInst, PSTR cmd, int showmode)
           "\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 after image is displayed to quit.\n"
-#ifndef __CYGWIN__
           "Press Q or Esc to quit this usage screen.\n"
-#endif
           "\n", PROGNAME, default_display_exponent);
-#ifndef __CYGWIN__
         do
             ch = _getch();
         while (ch != 'q' && ch != 'Q' && ch != 0x1B);
-#endif
         exit(1);
     }
 
@@ -366,24 +333,18 @@ int WINAPI WinMain(HINSTANCE hInst, HINSTANCE hPrevInst, PSTR cmd, int showmode)
 
 
     if (error) {
-#ifndef __CYGWIN__
         int ch;
-#endif
 
         fprintf(stderr, PROGNAME ":  aborting.\n");
-#ifndef __CYGWIN__
         do
             ch = _getch();
         while (ch != 'q' && ch != 'Q' && ch != 0x1B);
-#endif
         exit(2);
     } else {
         fprintf(stderr, "\n%s %s:  %s\n", PROGNAME, VERSION, appname);
-#ifndef __CYGWIN__
         fprintf(stderr,
           "\n   [console window:  closing this window will terminate %s]\n\n",
           PROGNAME);
-#endif
     }
 
 
@@ -456,12 +417,7 @@ int WINAPI WinMain(HINSTANCE hInst, HINSTANCE hPrevInst, PSTR cmd, int showmode)
     /* wait for the user to tell us when to quit */
 
     printf(
-#ifndef __CYGWIN__
-      "Done.  Press Q, Esc or mouse button 1 (within image window) to quit.\n"
-#else
-      "Done.  Press mouse button 1 (within image window) to quit.\n"
-#endif
-    );
+      "Done.  Press Q, Esc or mouse button 1 (within image window) to quit.\n");
     fflush(stdout);
 
     while (GetMessage(&msg, NULL, 0, 0)) {

contrib/gregbook/rpng-x.c

@@ -81,8 +81,8 @@
 #define PROGNAME  "rpng-x"
 #define LONGNAME  "Simple PNG Viewer for X"
 #define VERSION   "2.01 of 16 March 2008"
-#define RESNAME   "rpng"        /* our X resource application name */
-#define RESCLASS  "Rpng"        /* our X resource class name */
+#define RESNAME   "rpng"	/* our X resource application name */
+#define RESCLASS  "Rpng"	/* our X resource class name */
 
 #include <stdio.h>
 #include <stdlib.h>
@@ -252,8 +252,8 @@ int main(int argc, char **argv)
             else {
                 bgstr = *argv;
                 if (strlen(bgstr) != 7 || bgstr[0] != '#')
-                    ++error;
-                else
+                    ++error; 
+                else 
                     have_bg = TRUE;
             }
         } else {

contrib/gregbook/rpng2-win.c

@@ -32,7 +32,6 @@
     - 2.01:  fixed 64-bit typo in readpng2.c
     - 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
 
   ---------------------------------------------------------------------------
 
@@ -96,33 +95,7 @@
 #include <time.h>
 #include <math.h>      /* only for PvdM background code */
 #include <windows.h>
-#ifdef __CYGWIN__
-/* getch replacement. Turns out, we don't really need this,
- * but leave it here if we ever enable any of the uses of
- * _getch in the main code
- */
-#include <unistd.h>
-#include <termio.h>
-#include <sys/ioctl.h>
-int repl_getch( void )
-{
-  char ch;
-  int fd = fileno(stdin);
-  struct termio old_tty, new_tty;
-
-  ioctl(fd, TCGETA, &old_tty);
-  new_tty = old_tty;
-  new_tty.c_lflag &= ~(ICANON | ECHO | ISIG);
-  ioctl(fd, TCSETA, &new_tty);
-  fread(&ch, 1, sizeof(ch), stdin);
-  ioctl(fd, TCSETA, &old_tty);
-
-  return ch;
-}
-#define _getch repl_getch
-#else
 #include <conio.h>     /* only for _getch() */
-#endif
 
 /* all for PvdM background code: */
 #ifndef PI
@@ -296,7 +269,7 @@ int WINAPI WinMain(HINSTANCE hInst, HINSTANCE hPrevInst, PSTR cmd, int showmode)
     filename = (char *)NULL;
     memset(&rpng2_info, 0, sizeof(mainprog_info));
 
-#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@realviz.com for supplying the magical
@@ -305,7 +278,7 @@ int WINAPI WinMain(HINSTANCE hInst, HINSTANCE hPrevInst, PSTR cmd, int showmode)
     AllocConsole();
     freopen("CONOUT$", "a", stderr);
     freopen("CONOUT$", "a", stdout);
-#endif
+
 
     /* Set the default value for our display-system exponent, i.e., the
      * product of the CRT exponent and the exponent corresponding to
@@ -422,6 +395,18 @@ int WINAPI WinMain(HINSTANCE hInst, HINSTANCE hPrevInst, PSTR cmd, int showmode)
             }
         } else if (!strncmp(*argv, "-timing", 2)) {
             timing = TRUE;
+#if (defined(__i386__) || defined(_M_IX86) || defined(__x86_64__))
+        } else if (!strncmp(*argv, "-nommxfilters", 7)) {
+            rpng2_info.nommxfilters = TRUE;
+        } else if (!strncmp(*argv, "-nommxcombine", 7)) {
+            rpng2_info.nommxcombine = TRUE;
+        } else if (!strncmp(*argv, "-nommxinterlace", 7)) {
+            rpng2_info.nommxinterlace = TRUE;
+        } else if (!strcmp(*argv, "-nommx")) {
+            rpng2_info.nommxfilters = TRUE;
+            rpng2_info.nommxcombine = TRUE;
+            rpng2_info.nommxinterlace = TRUE;
+#endif
         } else {
             if (**argv != '-') {
                 filename = *argv;
@@ -439,14 +424,15 @@ int WINAPI WinMain(HINSTANCE hInst, HINSTANCE hPrevInst, PSTR cmd, int showmode)
     /* print usage screen if any errors up to this point */
 
     if (error) {
-#ifndef __CYGWIN__
         int ch;
-#endif
 
         fprintf(stderr, "\n%s %s:  %s\n\n", PROGNAME, VERSION, appname);
         readpng2_version_info();
         fprintf(stderr, "\n"
           "Usage:  %s [-gamma exp] [-bgcolor bg | -bgpat pat] [-timing]\n"
+#if (defined(__i386__) || defined(_M_IX86) || defined(__x86_64__))
+          "        %*s [[-nommxfilters] [-nommxcombine] [-nommxinterlace] | -nommx]\n"
+#endif
           "        %*s file.png\n\n"
           "    exp \ttransfer-function exponent (``gamma'') of the display\n"
           "\t\t  system in floating-point format (e.g., ``%.1f''); equal\n"
@@ -459,24 +445,21 @@ int WINAPI WinMain(HINSTANCE hInst, HINSTANCE hPrevInst, PSTR cmd, int showmode)
           "\t\t  transparent images; overrides -bgcolor option\n"
           "    -timing\tenables delay for every block read, to simulate modem\n"
           "\t\t  download of image (~36 Kbps)\n"
-          "\nPress Q, Esc or mouse button 1 after image is displayed to quit.\n"
-#ifndef __CYGWIN__
-          "Press Q or Esc to quit this usage screen. ",
-#else
-          ,
+#if (defined(__i386__) || defined(_M_IX86) || defined(__x86_64__))
+          "    -nommx*\tdisable optimized MMX routines for decoding row filters,\n"
+          "\t\t  combining rows, and expanding interlacing, respectively\n"
 #endif
+          "\nPress Q, Esc or mouse button 1 after image is displayed to quit.\n"
+          "Press Q or Esc to quit this usage screen. ",
           PROGNAME,
-#if (defined(__i386__) || defined(_M_IX86) || defined(__x86_64__)) && \
-    !(defined(__CYGWIN__) || defined(__MINGW32__))
+#if (defined(__i386__) || defined(_M_IX86) || defined(__x86_64__))
           (int)strlen(PROGNAME), " ",
 #endif
           (int)strlen(PROGNAME), " ", default_display_exponent, num_bgpat);
         fflush(stderr);
-#ifndef __CYGWIN__
         do
             ch = _getch();
         while (ch != 'q' && ch != 'Q' && ch != 0x1B);
-#endif
         exit(1);
     }
 
@@ -513,24 +496,18 @@ int WINAPI WinMain(HINSTANCE hInst, HINSTANCE hPrevInst, PSTR cmd, int showmode)
 
 
     if (error) {
-#ifndef __CYGWIN__
         int ch;
-#endif
 
         fprintf(stderr, PROGNAME ":  aborting.\n");
-#ifndef __CYGWIN__
         do
             ch = _getch();
         while (ch != 'q' && ch != 'Q' && ch != 0x1B);
-#endif
         exit(2);
     } else {
         fprintf(stderr, "\n%s %s:  %s\n", PROGNAME, VERSION, appname);
-#ifndef __CYGWIN__
         fprintf(stderr,
           "\n   [console window:  closing this window will terminate %s]\n\n",
           PROGNAME);
-#endif
         fflush(stderr);
     }
 
@@ -590,7 +567,7 @@ int WINAPI WinMain(HINSTANCE hInst, HINSTANCE hPrevInst, PSTR cmd, int showmode)
                   "(unexpectedly) while reading PNG image file\n");
                 exit(3);
             } else /* if (error) */ {
-                /* will print error message below */
+                // will print error message below
             }
             break;
         }
@@ -1173,12 +1150,7 @@ static void rpng2_win_finish_display()
 
     rpng2_info.state = kDone;
     printf(
-#ifndef __CYGWIN__
-      "Done.  Press Q, Esc or mouse button 1 (within image window) to quit.\n"
-#else
-      "Done.  Press mouse button 1 (within image window) to quit.\n"
-#endif
-    );
+      "Done.  Press Q, Esc or mouse button 1 (within image window) to quit.\n");
     fflush(stdout);
 }
 

contrib/gregbook/rpng2-x.c

@@ -40,7 +40,6 @@
     - 2.02:  fixed improper display of usage screen on PNG error(s); fixed
               unexpected-EOF and file-read-error cases; fixed Trace() cut-and-
               paste bugs
-    - 2.03:  deleted runtime MMX-enabling/disabling and obsolete -mmx* options
 
   ---------------------------------------------------------------------------
 
@@ -95,9 +94,9 @@
 
 #define PROGNAME  "rpng2-x"
 #define LONGNAME  "Progressive PNG Viewer for X"
-#define VERSION   "2.03 of 25 February 2010"
-#define RESNAME   "rpng2"       /* our X resource application name */
-#define RESCLASS  "Rpng"       /* our X resource class name */
+#define VERSION   "2.02 of 16 March 2008"
+#define RESNAME   "rpng2"	/* our X resource application name */
+#define RESCLASS  "Rpng"	/* our X resource class name */
 
 #include <stdio.h>
 #include <stdlib.h>
@@ -132,7 +131,7 @@
                   (e.type == KeyPress &&   /*  v--- or 1 for shifted keys */  \
                   ((k = XLookupKeysym(&e.xkey, 0)) == XK_q || k == XK_Escape)))
 
-#define NO_24BIT_MASKS /* undef case not fully written--only for redisplay() */
+#define NO_24BIT_MASKS	/* undef case not fully written--only for redisplay() */
 
 #define rgb1_max   bg_freq
 #define rgb1_min   bg_gray
@@ -302,7 +301,7 @@ int main(int argc, char **argv)
     int have_bg = FALSE;
 #ifdef FEATURE_LOOP
     int loop = FALSE;
-    long loop_interval = -1;            /* seconds (100,000 max) */
+    long loop_interval = -1;		/* seconds (100,000 max) */
 #endif
     double LUT_exponent;                /* just the lookup table */
     double CRT_exponent = 2.2;          /* just the monitor */
@@ -435,6 +434,18 @@ int main(int argc, char **argv)
                 else if (loop_interval > 100000)   /* bit more than one day */
                     loop_interval = 100000;
             }
+#endif
+#if (defined(__i386__) || defined(_M_IX86) || defined(__x86_64__))
+        } else if (!strncmp(*argv, "-nommxfilters", 7)) {
+            rpng2_info.nommxfilters = TRUE;
+        } else if (!strncmp(*argv, "-nommxcombine", 7)) {
+            rpng2_info.nommxcombine = TRUE;
+        } else if (!strncmp(*argv, "-nommxinterlace", 7)) {
+            rpng2_info.nommxinterlace = TRUE;
+        } else if (!strcmp(*argv, "-nommx")) {
+            rpng2_info.nommxfilters = TRUE;
+            rpng2_info.nommxcombine = TRUE;
+            rpng2_info.nommxinterlace = TRUE;
 #endif
         } else {
             if (**argv != '-') {
@@ -457,6 +468,9 @@ int main(int argc, char **argv)
         readpng2_version_info();
         fprintf(stderr, "\n"
           "Usage:  %s [-display xdpy] [-gamma exp] [-bgcolor bg | -bgpat pat]\n"
+#if (defined(__i386__) || defined(_M_IX86) || defined(__x86_64__))
+          "        %*s [[-nommxfilters] [-nommxcombine] [-nommxinterlace] | -nommx]\n"
+#endif
 #ifdef FEATURE_LOOP
           "        %*s [-usleep dur | -timing] [-pause] [-loop [sec]] file.png\n\n"
 #else
@@ -476,6 +490,10 @@ int main(int argc, char **argv)
           "    -loop\tloops through background images after initial display\n"
           "\t\t  is complete (depends on -bgpat)\n"
           "    sec \tseconds to display each background image (default = 2)\n"
+#endif
+#if (defined(__i386__) || defined(_M_IX86) || defined(__x86_64__))
+          "    -nommx*\tdisable optimized MMX routines for decoding row filters,\n"
+          "\t\t  combining rows, and expanding interlacing, respectively\n"
 #endif
           "    dur \tduration in microseconds to wait after displaying each\n"
           "\t\t  row (for demo purposes)\n"
@@ -485,6 +503,9 @@ int main(int argc, char **argv)
           "\nPress Q, Esc or mouse button 1 (within image window, after image\n"
           "is displayed) to quit.\n"
           "\n", PROGNAME,
+#if (defined(__i386__) || defined(_M_IX86) || defined(__x86_64__))
+          (int)strlen(PROGNAME), " ",
+#endif
           (int)strlen(PROGNAME), " ", default_display_exponent, num_bgpat-1);
         exit(1);
     }
@@ -591,7 +612,7 @@ int main(int argc, char **argv)
                   "(unexpectedly) while reading PNG image file\n");
                 exit(3);
             } else /* if (error) */ {
-                /* will print error message below */
+                // will print error message below
             }
             break;
         }
@@ -781,9 +802,8 @@ static void rpng2_x_init(void)
     if (rpng2_x_create_window()) {
 
         /* GRR TEMPORARY HACK:  this is fundamentally no different from cases
-         * above; libpng should call our error handler to longjmp() back to us
-         * when png_ptr goes away.  If we/it segfault instead, seems like a
-         * libpng bug... */
+         * above; libpng should longjmp() back to us when png_ptr goes away.
+         * If we/it segfault instead, seems like a libpng bug... */
 
         /* we're here via libpng callback, so if window fails, clean and bail */
         readpng2_cleanup(&rpng2_info);
@@ -1277,7 +1297,7 @@ static int rpng2_x_load_bg_image(void)
         for (row = 0;  row < rpng2_info.height;  ++row) {
             src = bg_data + row*bg_rowbytes;
             dest = ximage->data + row*ximage_rowbytes;
-            if (bpp == 32) {    /* slightly optimized version */
+            if (bpp == 32) {	/* slightly optimized version */
                 for (i = rpng2_info.width;  i > 0;  --i) {
                     red   = *src++;
                     green = *src++;

contrib/gregbook/writepng.c

@@ -55,9 +55,8 @@
 
 
 #include <stdlib.h>     /* for exit() prototype */
-#include <zlib.h>
 
-#include "png.h"        /* libpng header, includes setjmp.h */
+#include "png.h"        /* libpng header; includes zlib.h and setjmp.h */
 #include "writepng.h"   /* typedefs, common macros, public prototypes */
 
 
@@ -105,8 +104,7 @@ int writepng_init(mainprog_info *mainprog_ptr)
     /* setjmp() must be called in every function that calls a PNG-writing
      * libpng function, unless an alternate error handler was installed--
      * but compatible error handlers must either use longjmp() themselves
-     * (as in this program) or some other method to return control to
-     * application code, so here we go: */
+     * (as in this program) or exit immediately, so here we go: */
 
     if (setjmp(mainprog_ptr->jmpbuf)) {
         png_destroy_write_struct(&png_ptr, &info_ptr);
@@ -390,12 +388,5 @@ static void writepng_error_handler(png_structp png_ptr, png_const_charp msg)
         exit(99);
     }
 
-    /* Now we have our data structure we can use the information in it
-     * to return control to our own higher level code (all the points
-     * where 'setjmp' is called in this file.)  This will work with other
-     * error handling mechanisms as well - libpng always calls png_error
-     * when it can proceed no further, thus, so long as the error handler
-     * is intercepted, application code can do its own error recovery.
-     */
     longjmp(mainprog_ptr->jmpbuf, 1);
 }

contrib/libtests/fakepng.c

@@ -1,57 +0,0 @@
-/* Fake a PNG - just write it out directly. */
-#include <stdio.h>
-#include <zlib.h> /* for crc32 */
-
-void
-put_uLong(uLong val)
-{
-   putchar(val >> 24);
-   putchar(val >> 16);
-   putchar(val >>  8);
-   putchar(val >>  0);
-}
-
-void
-put_chunk(const unsigned char *chunk, uInt length)
-{
-   uLong crc;
-
-   put_uLong(length-4); /* Exclude the tag */
-
-   fwrite(chunk, length, 1, stdout);
-
-   crc = crc32(0, Z_NULL, 0);
-   put_uLong(crc32(crc, chunk, length));
-}
-
-const unsigned char signature[] =
-{
-   137, 80, 78, 71, 13, 10, 26, 10
-};
-
-const unsigned char IHDR[] =
-{
-   73, 72, 68, 82, /* IHDR */
-   0, 0, 0, 1, /* width */
-   0, 0, 0, 1, /* height */
-   1, /* bit depth */
-   0, /* color type: greyscale */
-   0, /* compression method */
-   0, /* filter method */
-   0  /* interlace method: none */
-};
-
-const unsigned char unknown[] =
-{
-   'u', 'n', 'K', 'n' /* "unKn" - private safe to copy */
-};
-
-int
-main(void)
-{
-   fwrite(signature, sizeof signature, 1, stdout);
-   put_chunk(IHDR, sizeof IHDR);
-
-   for(;;)
-      put_chunk(unknown, sizeof unknown);
-}

contrib/libtests/gentests.sh

@@ -1,102 +0,0 @@
-#!/bin/sh
-#
-# Copyright (c) 2013 John Cunningham Bowler
-#
-# Last changed in libpng 1.6.0 [February 14, 2013]
-#
-# This code is released under the libpng license.
-# For conditions of distribution and use, see the disclaimer
-# and license in png.h
-#
-# Generate a set of PNG test images.  The images are generated in a
-# sub-directory called 'tests' by default, however a command line argument will
-# change that name.  The generation requires a built version of makepng in the
-# current directory.
-#
-usage(){
-   exec >&2
-   echo "$0 [<directory>]"
-   echo '  Generate a set of PNG test files in "directory" ("tests" by default)'
-   exit 1
-}
-
-mp="$PWD/makepng"
-test -x "$mp" || {
-   exec >&2
-   echo "$0: the 'makepng' program must exist"
-   echo "  in the directory within which this program:"
-   echo "    $mp"
-   echo "  is executed"
-   usage
-}
-
-# Just one argument: the directory
-testdir="tests"
-test $# -gt 1 && {
-   testdir="$1"
-   shift
-}
-test $# -eq 0 || usage
-
-# Take care not to clobber something
-if test -e "$testdir"
-then
-   test -d "$testdir" || usage
-else
-   # mkdir -p isn't portable, so do the following
-   mkdir "$testdir" 2>/dev/null || mkdir -p "$testdir" || usage
-fi
-
-# This fails in a very satisfactory way if it's not accessible
-cd "$testdir"
-:>"test$$.png" || {
-   exec >&2
-   echo "$testdir: directory not writable"
-   usage
-}
-rm "test$$.png" || {
-   exec >&2
-   echo "$testdir: you have create but not write privileges here."
-   echo "  This is unexpected.  You have a spurion; "'"'"test$$.png"'"'"."
-   echo "  You need to remove this yourself.  Try a different directory."
-   exit 1
-}
-
-# Now call makepng ($mp) to create every file we can think of with a
-# reasonable name
-doit(){
-   for gamma in "" --sRGB --linear --1.8
-   do
-      case "$gamma" in
-         "")
-            gname=;;
-         --sRGB)
-            gname="-srgb";;
-         --linear)
-            gname="-lin";;
-         --1.8)
-            gname="-18";;
-         *)
-            gname="-$gamma";;
-      esac
-      "$mp" $gamma "$1" "$2" "test-$1-$2$gname.png"
-   done
-}
-#
-for ct in gray palette
-do
-   for bd in 1 2 4 8
-   do
-      doit "$ct" "$bd"
-   done
-done
-#
-doit "gray" "16"
-#
-for ct in gray-alpha rgb rgb-alpha
-do
-   for bd in 8 16
-   do
-      doit "$ct" "$bd"
-   done
-done

contrib/libtests/readpng.c

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

contrib/libtests/tarith.c

@@ -1,999 +0,0 @@
-
-/* tarith.c
- *
- * Copyright (c) 2011-2013 John Cunningham Bowler
- *
- * Last changed in libpng 1.6.0 [February 14, 2013]
- *
- * This code is released under the libpng license.
- * For conditions of distribution and use, see the disclaimer
- * and license in png.h
- *
- * Test internal arithmetic functions of libpng.
- *
- * This code must be linked against a math library (-lm), but does not require
- * libpng or zlib to work.  Because it includes the complete source of 'png.c'
- * it tests the code with whatever compiler options are used to build it.
- * Changing these options can substantially change the errors in the
- * calculations that the compiler chooses!
- */
-#define _POSIX_SOURCE 1
-#define _ISOC99_SOURCE 1
-
-/* Obtain a copy of the code to be tested (plus other things), disabling
- * stuff that is not required.
- */
-#include <math.h>
-#include <stdlib.h>
-#include <ctype.h>
-#include <string.h>
-#include <assert.h>
-
-#include "../../pngpriv.h"
-
-#define png_error png_warning
-
-void png_warning(png_const_structrp png_ptr, png_const_charp msg)
-{
-   fprintf(stderr, "validation: %s\n", msg);
-}
-
-#define png_fixed_error png_fixed_warning
-
-void png_fixed_warning(png_const_structrp png_ptr, png_const_charp msg)
-{
-   fprintf(stderr, "overflow in: %s\n", msg);
-}
-
-#define png_set_error_fn(pp, ep, efp, wfp) ((void)0)
-#define png_malloc(pp, s) malloc(s)
-#define png_malloc_warn(pp, s) malloc(s)
-#define png_malloc_base(pp, s) malloc(s)
-#define png_calloc(pp, s) calloc(1, (s))
-#define png_free(pp, s) free(s)
-
-#define png_safecat(b, sb, pos, str) (pos)
-#define png_format_number(start, end, format, number) (start)
-
-#define crc32(crc, pp, s) (crc)
-#define inflateReset(zs) Z_OK
-
-#define png_create_struct(type) (0)
-#define png_destroy_struct(pp) ((void)0)
-#define png_create_struct_2(type, m, mm) (0)
-#define png_destroy_struct_2(pp, f, mm) ((void)0)
-
-#undef PNG_SIMPLIFIED_READ_SUPPORTED
-#undef PNG_SIMPLIFIED_WRITE_SUPPORTED
-#undef PNG_USER_MEM_SUPPORTED
-
-#include "../../png.c"
-
-/* Validate ASCII to fp routines. */
-static int verbose = 0;
-
-int validation_ascii_to_fp(int count, int argc, char **argv)
-{
-   int    showall = 0;
-   double max_error=2;      /* As a percentage error-in-last-digit/.5 */
-   double max_error_abs=17; /* Used when precision is DBL_DIG */
-   double max = 0;
-   double max_abs = 0;
-   double test = 0; /* Important to test this. */
-   int    precision = 5;
-   int    nonfinite = 0;
-   int    finite = 0;
-   int    ok = 0;
-   int    failcount = 0;
-   int    minorarith = 0;
-
-   while (--argc > 0)
-      if (strcmp(*++argv, "-a") == 0)
-         showall = 1;
-      else if (strcmp(*argv, "-e") == 0 && argc > 0)
-      {
-         --argc;
-         max_error = atof(*++argv);
-      }
-      else if (strcmp(*argv, "-E") == 0 && argc > 0)
-      {
-         --argc;
-         max_error_abs = atof(*++argv);
-      }
-      else
-      {
-         fprintf(stderr, "unknown argument %s\n", *argv);
-         return 1;
-      }
-
-   do
-   {
-      png_size_t index;
-      int state, failed = 0;
-      char buffer[64];
-
-      if (isfinite(test))
-         ++finite;
-      else
-         ++nonfinite;
-
-      if (verbose)
-         fprintf(stderr, "%.*g %d\n", DBL_DIG, test, precision);
-
-      /* Check for overflow in the buffer by setting a marker. */
-      memset(buffer, 71, sizeof buffer);
-
-      png_ascii_from_fp(0, buffer, precision+10, test, precision);
-
-      /* Allow for a three digit exponent, this stuff will fail if
-       * the exponent is bigger than this!
-       */
-      if (buffer[precision+7] != 71)
-      {
-         fprintf(stderr, "%g[%d] -> '%s'[%lu] buffer overflow\n", test,
-            precision, buffer, (unsigned long)strlen(buffer));
-         failed = 1;
-      }
-
-      /* Following are used for the number parser below and must be
-       * initialized to zero.
-       */
-      state = 0;
-      index = 0;
-      if (!isfinite(test))
-      {
-         /* Expect 'inf' */
-         if (test >= 0 && strcmp(buffer, "inf") ||
-             test <  0 && strcmp(buffer, "-inf"))
-         {
-            fprintf(stderr, "%g[%d] -> '%s' but expected 'inf'\n", test,
-               precision, buffer);
-            failed = 1;
-         }
-      }
-      else if (!png_check_fp_number(buffer, precision+10, &state, &index) ||
-          buffer[index] != 0)
-      {
-         fprintf(stderr, "%g[%d] -> '%s' but has bad format ('%c')\n", test,
-         precision, buffer, buffer[index]);
-         failed = 1;
-      }
-      else if (PNG_FP_IS_NEGATIVE(state) && !(test < 0))
-      {
-         fprintf(stderr, "%g[%d] -> '%s' but negative value not so reported\n",
-            test, precision, buffer);
-         failed = 1;
-         assert(!PNG_FP_IS_ZERO(state));
-         assert(!PNG_FP_IS_POSITIVE(state));
-      }
-      else if (PNG_FP_IS_ZERO(state) && !(test == 0))
-      {
-         fprintf(stderr, "%g[%d] -> '%s' but zero value not so reported\n",
-            test, precision, buffer);
-         failed = 1;
-         assert(!PNG_FP_IS_NEGATIVE(state));
-         assert(!PNG_FP_IS_POSITIVE(state));
-      }
-      else if (PNG_FP_IS_POSITIVE(state) && !(test > 0))
-      {
-         fprintf(stderr, "%g[%d] -> '%s' but postive value not so reported\n",
-            test, precision, buffer);
-         failed = 1;
-         assert(!PNG_FP_IS_NEGATIVE(state));
-         assert(!PNG_FP_IS_ZERO(state));
-      }
-      else
-      {
-         /* Check the result against the original. */
-         double out = atof(buffer);
-         double change = fabs((out - test)/test);
-         double allow = .5/pow(10,
-            (precision >= DBL_DIG) ? DBL_DIG-1 : precision-1);
-
-         /* NOTE: if you hit this error case are you compiling with gcc
-          * and -O0?  Try -O2 - the errors can accumulate if the FP
-          * code above is not optimized and may drift outside the .5 in
-          * DBL_DIG allowed.  In any case a small number of errors may
-          * occur (very small ones - 1 or 2%) because of rounding in the
-          * calculations, either in the conversion API or in atof.
-          */
-         if (change >= allow && (isfinite(out) ||
-             fabs(test/DBL_MAX) <= 1-allow))
-         {
-            double percent = (precision >= DBL_DIG) ? max_error_abs : max_error;
-            double allowp = (change-allow)*100/allow;
-
-            if (precision >= DBL_DIG)
-            {
-               if (max_abs < allowp) max_abs = allowp;
-            }
-
-            else
-            {
-               if (max < allowp) max = allowp;
-            }
-
-            if (showall || allowp >= percent)
-            {
-               fprintf(stderr,
-                  "%.*g[%d] -> '%s' -> %.*g number changed (%g > %g (%d%%))\n",
-                  DBL_DIG, test, precision, buffer, DBL_DIG, out, change, allow,
-                  (int)round(allowp));
-               failed = 1;
-            }
-            else
-               ++minorarith;
-         }
-      }
-
-      if (failed)
-         ++failcount;
-      else
-         ++ok;
-
-skip:
-      /* Generate a new number and precision. */
-      precision = rand();
-      if (precision & 1) test = -test;
-      precision >>= 1;
-
-      /* Generate random numbers. */
-      if (test == 0 || !isfinite(test))
-         test = precision+1;
-      else
-      {
-         /* Derive the exponent from the previous rand() value. */
-         int exponent = precision % (DBL_MAX_EXP - DBL_MIN_EXP) + DBL_MIN_EXP;
-         int tmp;
-         test = frexp(test * rand(), &tmp);
-         test = ldexp(test, exponent);
-         precision >>= 8; /* arbitrary */
-      }
-
-      /* This limits the precision to 32 digits, enough for standard
-       * IEEE implementations which have at most 15 digits.
-       */
-      precision = (precision & 0x1f) + 1;
-   }
-   while (--count);
-
-   printf("Tested %d finite values, %d non-finite, %d OK (%d failed) %d minor "
-      "arithmetic errors\n", finite, nonfinite, ok, failcount, minorarith);
-   printf(" Error with >=%d digit precision %.2f%%\n", DBL_DIG, max_abs);
-   printf(" Error with < %d digit precision %.2f%%\n", DBL_DIG, max);
-
-   return 0;
-}
-
-/* Observe that valid FP numbers have the forms listed in the PNG extensions
- * specification:
- *
- * [+,-]{integer,integer.fraction,.fraction}[{e,E}[+,-]integer]
- *
- * Test each of these in turn, including invalid cases.
- */
-typedef enum checkfp_state
-{
-   start, fraction, exponent, states
-} checkfp_state;
-
-/* The characters (other than digits) that characterize the states: */
-static const char none[] = "";
-static const char hexdigits[16] = "0123456789ABCDEF";
-
-static const struct
-{
-   const char *start; /* Characters valid at the start */
-   const char *end;   /* Valid characters that end the state */
-   const char *tests; /* Characters to test after 2 digits seen */
-}
-state_characters[states] =
-{
-   /* start:    */ { "+-.", ".eE", "+-.e*0369" },
-   /* fraction: */ { none, "eE",  "+-.E#0147" },
-   /* exponent: */ { "+-", none,  "+-.eE^0258" }
-};
-
-typedef struct
-{
-   char number[1024];  /* Buffer for number being tested */
-   int  limit;         /* Command line limit */
-   int  verbose;       /* Shadows global variable */
-   int  ctimes;        /* Number of numbers tested */
-   int  cmillions;     /* Count of millions of numbers */
-   int  cinvalid;      /* Invalid strings checked */
-   int  cnoaccept;     /* Characters not accepted */
-}
-checkfp_command;
-
-typedef struct
-{
-   int           cnumber;          /* Index into number string */
-   checkfp_state check_state;      /* Current number state */
-   int           at_start;         /* At start (first character) of state */
-   int           cdigits_in_state; /* Digits seen in that state */
-   int           limit;            /* Limit on same for checking all chars */
-   int           state;            /* Current parser state */
-   int           is_negative;      /* Number is negative */
-   int           is_zero;          /* Number is (still) zero */
-   int           number_was_valid; /* Previous character validity */
-}
-checkfp_control;
-
-static int check_all_characters(checkfp_command *co, checkfp_control c);
-
-static int check_some_characters(checkfp_command *co, checkfp_control c,
-   const char *tests);
-
-static int check_one_character(checkfp_command *co, checkfp_control c, int ch)
-{
-   /* Test this character (ch) to ensure the parser does the correct thing.
-    */
-   png_size_t index = 0;
-   const char test = (char)ch;
-   const int number_is_valid = png_check_fp_number(&test, 1, &c.state, &index);
-   const int character_accepted = (index == 1);
-
-   if (c.check_state != exponent && isdigit(ch) && ch != '0')
-      c.is_zero = 0;
-
-   if (c.check_state == start && c.at_start && ch == '-')
-      c.is_negative = 1;
-
-   if (isprint(ch))
-      co->number[c.cnumber++] = (char)ch;
-   else
-   {
-      co->number[c.cnumber++] = '<';
-      co->number[c.cnumber++] = hexdigits[(ch >> 4) & 0xf];
-      co->number[c.cnumber++] = hexdigits[ch & 0xf];
-      co->number[c.cnumber++] = '>';
-   }
-   co->number[c.cnumber] = 0;
-
-   if (co->verbose > 1)
-      fprintf(stderr, "%s\n", co->number);
-
-   if (++(co->ctimes) == 1000000)
-   {
-      if (co->verbose == 1)
-         fputc('.', stderr);
-      co->ctimes = 0;
-      ++(co->cmillions);
-   }
-
-   if (!number_is_valid)
-      ++(co->cinvalid);
-
-   if (!character_accepted)
-      ++(co->cnoaccept);
-
-   /* This should never fail (it's a serious bug if it does): */
-   if (index != 0 && index != 1)
-   {
-      fprintf(stderr, "%s: read beyond end of string (%lu)\n", co->number,
-         (unsigned long)index);
-      return 0;
-   }
-
-   /* Validate the new state, note that the PNG_FP_IS_ macros all return
-    * false unless the number is valid.
-    */
-   if (PNG_FP_IS_NEGATIVE(c.state) !=
-      (number_is_valid && !c.is_zero && c.is_negative))
-   {
-      fprintf(stderr, "%s: negative when it is not\n", co->number);
-      return 0;
-   }
-
-   if (PNG_FP_IS_ZERO(c.state) != (number_is_valid && c.is_zero))
-   {
-      fprintf(stderr, "%s: zero when it is not\n", co->number);
-      return 0;
-   }
-
-   if (PNG_FP_IS_POSITIVE(c.state) !=
-      (number_is_valid && !c.is_zero && !c.is_negative))
-   {
-      fprintf(stderr, "%s: positive when it is not\n", co->number);
-      return 0;
-   }
-
-   /* Testing a digit */
-   if (isdigit(ch))
-   {
-      if (!character_accepted)
-      {
-         fprintf(stderr, "%s: digit '%c' not accepted\n", co->number, ch);
-         return 0;
-      }
-
-      if (!number_is_valid)
-      {
-         fprintf(stderr, "%s: saw a digit (%c) but number not valid\n",
-            co->number, ch);
-         return 0;
-      }
-
-      ++c.cdigits_in_state;
-      c.at_start = 0;
-      c.number_was_valid = 1;
-
-      /* Continue testing characters in this state.  Either test all of
-       * them or, if we have already seen one digit in this state, just test a
-       * limited set.
-       */
-      if (c.cdigits_in_state < 1)
-         return check_all_characters(co, c);
-
-      else
-         return check_some_characters(co, c,
-            state_characters[c.check_state].tests);
-   }
-
-   /* A non-digit; is it allowed here? */
-   else if (((ch == '+' || ch == '-') && c.check_state != fraction &&
-               c.at_start) ||
-            (ch == '.' && c.check_state == start) ||
-            ((ch == 'e' || ch == 'E') && c.number_was_valid &&
-               c.check_state != exponent))
-   {
-      if (!character_accepted)
-      {
-         fprintf(stderr, "%s: character '%c' not accepted\n", co->number, ch);
-         return 0;
-      }
-
-      /* The number remains valid after start of fraction but nowhere else. */
-      if (number_is_valid && (c.check_state != start || ch != '.'))
-      {
-         fprintf(stderr, "%s: saw a non-digit (%c) but number valid\n",
-            co->number, ch);
-         return 0;
-      }
-
-      c.number_was_valid = number_is_valid;
-
-      /* Check for a state change.  When changing to 'fraction' if the number
-       * is valid at this point set the at_start to false to allow an exponent
-       * 'e' to come next.
-       */
-      if (c.check_state == start && ch == '.')
-      {
-         c.check_state = fraction;
-         c.at_start = !number_is_valid;
-         c.cdigits_in_state = 0;
-         c.limit = co->limit;
-         return check_all_characters(co, c);
-      }
-
-      else if (c.check_state < exponent && (ch == 'e' || ch == 'E'))
-      {
-         c.check_state = exponent;
-         c.at_start = 1;
-         c.cdigits_in_state = 0;
-         c.limit = co->limit;
-         return check_all_characters(co, c);
-      }
-
-      /* Else it was a sign, and the state doesn't change. */
-      else
-      {
-         if (ch != '-' && ch != '+')
-         {
-            fprintf(stderr, "checkfp: internal error (1)\n");
-            return 0;
-         }
-
-         c.at_start = 0;
-         return check_all_characters(co, c);
-      }
-   }
-
-   /* Testing an invalid character */
-   else
-   {
-      if (character_accepted)
-      {
-         fprintf(stderr, "%s: character '%c' [0x%.2x] accepted\n", co->number,
-            ch, ch);
-         return 0;
-      }
-
-      if (number_is_valid != c.number_was_valid)
-      {
-         fprintf(stderr,
-            "%s: character '%c' [0x%.2x] changed number validity\n", co->number,
-            ch, ch);
-         return 0;
-      }
-
-      /* Do nothing - the parser has stuck; return success and keep going with
-       * the next character.
-       */
-   }
-
-   /* Successful return (the caller will try the next character.) */
-   return 1;
-}
-
-static int check_all_characters(checkfp_command *co, checkfp_control c)
-{
-   int ch;
-
-   if (c.cnumber+4 < sizeof co->number) for (ch=0; ch<256; ++ch)
-   {
-      if (!check_one_character(co, c, ch))
-         return 0;
-   }
-
-   return 1;
-}
-
-static int check_some_characters(checkfp_command *co, checkfp_control c,
-   const char *tests)
-{
-   int i;
-
-   --(c.limit);
-
-   if (c.cnumber+4 < sizeof co->number && c.limit >= 0)
-   {
-      if (c.limit > 0) for (i=0; tests[i]; ++i)
-      {
-         if (!check_one_character(co, c, tests[i]))
-               return 0;
-      }
-
-      /* At the end check all the characters. */
-      else
-         return check_all_characters(co, c);
-   }
-
-   return 1;
-}
-
-int validation_checkfp(int count, int argc, char **argv)
-{
-   int result;
-   checkfp_command command;
-   checkfp_control control;
-
-   command.number[0] = 0;
-   command.limit = 3;
-   command.verbose = verbose;
-   command.ctimes = 0;
-   command.cmillions = 0;
-   command.cinvalid = 0;
-   command.cnoaccept = 0;
-
-   while (--argc > 0)
-   {
-      ++argv;
-      if (argc > 1 && strcmp(*argv, "-l") == 0)
-      {
-         --argc;
-         command.limit = atoi(*++argv);
-      }
-
-      else
-      {
-         fprintf(stderr, "unknown argument %s\n", *argv);
-         return 1;
-      }
-   }
-
-   control.cnumber = 0;
-   control.check_state = start;
-   control.at_start = 1;
-   control.cdigits_in_state = 0;
-   control.limit = command.limit;
-   control.state = 0;
-   control.is_negative = 0;
-   control.is_zero = 1;
-   control.number_was_valid = 0;
-
-   result = check_all_characters(&command, control);
-
-   printf("checkfp: %s: checked %d,%.3d,%.3d,%.3d strings (%d invalid)\n",
-      result ? "pass" : "FAIL", command.cmillions / 1000,
-      command.cmillions % 1000, command.ctimes / 1000, command.ctimes % 1000,
-      command.cinvalid);
-
-   return result;
-}
-
-int validation_muldiv(int count, int argc, char **argv)
-{
-   int tested = 0;
-   int overflow = 0;
-   int error = 0;
-   int error64 = 0;
-   int passed = 0;
-   int randbits = 0;
-   png_uint_32 randbuffer;
-   png_fixed_point a;
-   png_int_32 times, div;
-
-   while (--argc > 0)
-      {
-         fprintf(stderr, "unknown argument %s\n", *++argv);
-         return 1;
-      }
-
-   /* Find out about the random number generator. */
-   randbuffer = RAND_MAX;
-   while (randbuffer != 0) ++randbits, randbuffer >>= 1;
-   printf("Using random number generator that makes %d bits\n", randbits);
-   for (div=0; div<32; div += randbits)
-      randbuffer = (randbuffer << randbits) ^ rand();
-
-   a = 0;
-   times = div = 0;
-   do
-   {
-      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
-       * better mantissa is required.
-       */
-      long long int fp, fpround;
-      unsigned long hi, lo;
-      int ok;
-
-      /* Check the values, png_64bit_product can only handle positive
-       * numbers, so correct for that here.
-       */
-      {
-         long u1, u2;
-         int n = 0;
-         if (a < 0) u1 = -a, n = 1; else u1 = a;
-         if (times < 0) u2 = -times, n = !n; else u2 = times;
-         png_64bit_product(u1, u2, &hi, &lo);
-         if (n)
-         {
-            /* -x = ~x+1 */
-            lo = ((~lo) + 1) & 0xffffffff;
-            hi = ~hi;
-            if (lo == 0) ++hi;
-         }
-      }
-
-      fp = a;
-      fp *= times;
-      if ((fp & 0xffffffff) != lo || ((fp >> 32) & 0xffffffff) != hi)
-      {
-         fprintf(stderr, "png_64bit_product %d * %d -> %lx|%.8lx not %llx\n",
-            a, times, hi, lo, fp);
-         ++error64;
-      }
-
-      if (div != 0)
-      {
-         /* Round - this is C round to zero. */
-         if ((fp < 0) != (div < 0))
-           fp -= div/2;
-         else
-           fp += div/2;
-
-         fp /= div;
-         fpround = fp;
-         /* Assume 2's complement here: */
-         ok = fpround <= PNG_UINT_31_MAX &&
-              fpround >= -1-(long long int)PNG_UINT_31_MAX;
-         if (!ok) ++overflow;
-      }
-      else
-        ok = 0, ++overflow, fpround = fp/*misleading*/;
-
-      if (verbose)
-         fprintf(stderr, "TEST %d * %d / %d -> %lld (%s)\n", a, times, div,
-            fp, ok ? "ok" : "overflow");
-
-      ++tested;
-      if (png_muldiv(&result, a, times, div) != ok)
-      {
-         ++error;
-         if (ok)
-             fprintf(stderr, "%d * %d / %d -> overflow (expected %lld)\n", a,
-                times, div, fp);
-         else
-             fprintf(stderr, "%d * %d / %d -> %d (expected overflow %lld)\n", a,
-                times, div, result, fp);
-      }
-      else if (ok && result != fpround)
-      {
-         ++error;
-         fprintf(stderr, "%d * %d / %d -> %d not %lld\n", a, times, div, result,
-            fp);
-      }
-      else
-         ++passed;
-
-      /* Generate three new values, this uses rand() and rand() only returns
-       * up to RAND_MAX.
-       */
-      /* CRUDE */
-      a += times;
-      times += div;
-      div = randbuffer;
-      randbuffer = (randbuffer << randbits) ^ rand();
-   }
-   while (--count > 0);
-
-   printf("%d tests including %d overflows, %d passed, %d failed (%d 64 bit "
-      "errors)\n", tested, overflow, passed, error, error64);
-   return 0;
-}
-
-/* When FP is on this just becomes a speed test - compile without FP to get real
- * validation.
- */
-#ifdef PNG_FLOATING_ARITHMETIC_SUPPORTED
-#define LN2 .000010576586617430806112933839 /* log(2)/65536 */
-#define L2INV 94548.46219969910586572651    /* 65536/log(2) */
-
-/* For speed testing, need the internal functions too: */
-static png_uint_32 png_log8bit(unsigned x)
-{
-   if (x > 0)
-      return (png_uint_32)floor(.5-log(x/255.)*L2INV);
-
-   return 0xffffffff;
-}
-
-static png_uint_32 png_log16bit(png_uint_32 x)
-{
-   if (x > 0)
-      return (png_uint_32)floor(.5-log(x/65535.)*L2INV);
-
-   return 0xffffffff;
-}
-
-static png_uint_32 png_exp(png_uint_32 x)
-{
-   return (png_uint_32)floor(.5 + exp(x * -LN2) * 0xffffffffU);
-}
-
-static png_byte png_exp8bit(png_uint_32 log)
-{
-   return (png_byte)floor(.5 + exp(log * -LN2) * 255);
-}
-
-static png_uint_16 png_exp16bit(png_uint_32 log)
-{
-   return (png_uint_16)floor(.5 + exp(log * -LN2) * 65535);
-}
-#endif /* FLOATING_ARITHMETIC */
-
-int validation_gamma(int argc, char **argv)
-{
-   double gamma[9] = { 2.2, 1.8, 1.52, 1.45, 1., 1/1.45, 1/1.52, 1/1.8, 1/2.2 };
-   double maxerr;
-   int i, silent=0, onlygamma=0;
-
-   /* Silence the output with -s, just test the gamma functions with -g: */
-   while (--argc > 0)
-      if (strcmp(*++argv, "-s") == 0)
-         silent = 1;
-      else if (strcmp(*argv, "-g") == 0)
-         onlygamma = 1;
-      else
-      {
-         fprintf(stderr, "unknown argument %s\n", *argv);
-         return 1;
-      }
-
-   if (!onlygamma)
-   {
-      /* First validate the log functions: */
-      maxerr = 0;
-      for (i=0; i<256; ++i)
-      {
-         double correct = -log(i/255.)/log(2.)*65536;
-         double error = png_log8bit(i) - correct;
-
-         if (i != 0 && fabs(error) > maxerr)
-            maxerr = fabs(error);
-
-         if (i == 0 && png_log8bit(i) != 0xffffffff ||
-             i != 0 && png_log8bit(i) != floor(correct+.5))
-         {
-            fprintf(stderr, "8 bit log error: %d: got %u, expected %f\n",
-               i, png_log8bit(i), correct);
-         }
-      }
-
-      if (!silent)
-         printf("maximum 8 bit log error = %f\n", maxerr);
-
-      maxerr = 0;
-      for (i=0; i<65536; ++i)
-      {
-         double correct = -log(i/65535.)/log(2.)*65536;
-         double error = png_log16bit(i) - correct;
-
-         if (i != 0 && fabs(error) > maxerr)
-            maxerr = fabs(error);
-
-         if (i == 0 && png_log16bit(i) != 0xffffffff ||
-             i != 0 && png_log16bit(i) != floor(correct+.5))
-         {
-            if (error > .68) /* By experiment error is less than .68 */
-            {
-               fprintf(stderr, "16 bit log error: %d: got %u, expected %f"
-                  " error: %f\n", i, png_log16bit(i), correct, error);
-            }
-         }
-      }
-
-      if (!silent)
-         printf("maximum 16 bit log error = %f\n", maxerr);
-
-      /* Now exponentiations. */
-      maxerr = 0;
-      for (i=0; i<=0xfffff; ++i)
-      {
-         double correct = exp(-i/65536. * log(2.)) * (65536. * 65536);
-         double error = png_exp(i) - correct;
-
-         if (fabs(error) > maxerr)
-            maxerr = fabs(error);
-         if (fabs(error) > 1883) /* By experiment. */
-         {
-            fprintf(stderr, "32 bit exp error: %d: got %u, expected %f"
-                  " error: %f\n", i, png_exp(i), correct, error);
-         }
-      }
-
-      if (!silent)
-         printf("maximum 32 bit exp error = %f\n", maxerr);
-
-      maxerr = 0;
-      for (i=0; i<=0xfffff; ++i)
-      {
-         double correct = exp(-i/65536. * log(2.)) * 255;
-         double error = png_exp8bit(i) - correct;
-
-         if (fabs(error) > maxerr)
-            maxerr = fabs(error);
-         if (fabs(error) > .50002) /* By experiment */
-         {
-            fprintf(stderr, "8 bit exp error: %d: got %u, expected %f"
-                  " error: %f\n", i, png_exp8bit(i), correct, error);
-         }
-      }
-
-      if (!silent)
-         printf("maximum 8 bit exp error = %f\n", maxerr);
-
-      maxerr = 0;
-      for (i=0; i<=0xfffff; ++i)
-      {
-         double correct = exp(-i/65536. * log(2.)) * 65535;
-         double error = png_exp16bit(i) - correct;
-
-         if (fabs(error) > maxerr)
-            maxerr = fabs(error);
-         if (fabs(error) > .524) /* By experiment */
-         {
-            fprintf(stderr, "16 bit exp error: %d: got %u, expected %f"
-                  " error: %f\n", i, png_exp16bit(i), correct, error);
-         }
-      }
-
-      if (!silent)
-         printf("maximum 16 bit exp error = %f\n", maxerr);
-   } /* !onlygamma */
-
-   /* Test the overall gamma correction. */
-   for (i=0; i<9; ++i)
-   {
-      unsigned j;
-      double g = gamma[i];
-      png_fixed_point gfp = floor(g * PNG_FP_1 + .5);
-
-      if (!silent)
-         printf("Test gamma %f\n", g);
-
-      maxerr = 0;
-      for (j=0; j<256; ++j)
-      {
-         double correct = pow(j/255., g) * 255;
-         png_byte out = png_gamma_8bit_correct(j, gfp);
-         double error = out - correct;
-
-         if (fabs(error) > maxerr)
-            maxerr = fabs(error);
-         if (out != floor(correct+.5))
-         {
-            fprintf(stderr, "8bit %d ^ %f: got %d expected %f error %f\n",
-               j, g, out, correct, error);
-         }
-      }
-
-      if (!silent)
-         printf("gamma %f: maximum 8 bit error %f\n", g, maxerr);
-
-      maxerr = 0;
-      for (j=0; j<65536; ++j)
-      {
-         double correct = pow(j/65535., g) * 65535;
-         png_uint_16 out = png_gamma_16bit_correct(j, gfp);
-         double error = out - correct;
-
-         if (fabs(error) > maxerr)
-            maxerr = fabs(error);
-         if (fabs(error) > 1.62)
-         {
-            fprintf(stderr, "16bit %d ^ %f: got %d expected %f error %f\n",
-               j, g, out, correct, error);
-         }
-      }
-
-      if (!silent)
-         printf("gamma %f: maximum 16 bit error %f\n", g, maxerr);
-   }
-
-   return 0;
-}
-
-/**************************** VALIDATION TESTS ********************************/
-/* Various validation routines are included herein, they require some
- * definition for png_warning and png_error, seetings of VALIDATION:
- *
- * 1: validates the ASCII to floating point conversions
- * 2: validates png_muldiv
- * 3: accuracy test of fixed point gamma tables
- */
-
-/* The following COUNT (10^8) takes about 1 hour on a 1GHz Pentium IV
- * processor.
- */
-#define COUNT 1000000000
-
-int main(int argc, char **argv)
-{
-   int count = COUNT;
-
-   while (argc > 1)
-   {
-      if (argc > 2 && strcmp(argv[1], "-c") == 0)
-      {
-         count = atoi(argv[2]);
-         argc -= 2;
-         argv += 2;
-      }
-
-      else if (strcmp(argv[1], "-v") == 0)
-      {
-         ++verbose;
-         --argc;
-         ++argv;
-      }
-
-      else
-         break;
-   }
-
-   if (count > 0 && argc > 1)
-   {
-      if (strcmp(argv[1], "ascii") == 0)
-         return validation_ascii_to_fp(count, argc-1, argv+1);
-      else if (strcmp(argv[1], "checkfp") == 0)
-         return validation_checkfp(count, argc-1, argv+1);
-      else if (strcmp(argv[1], "muldiv") == 0)
-         return validation_muldiv(count, argc-1, argv+1);
-      else if (strcmp(argv[1], "gamma") == 0)
-         return validation_gamma(argc-1, argv+1);
-   }
-
-   /* Bad argument: */
-   fprintf(stderr,
-      "usage: tarith [-v] [-c count] {ascii,muldiv,gamma} [args]\n");
-   fprintf(stderr, " arguments: ascii [-a (all results)] [-e error%%]\n");
-   fprintf(stderr, "            checkfp [-l max-number-chars]\n");
-   fprintf(stderr, "            muldiv\n");
-   fprintf(stderr, "            gamma -s (silent) -g (only gamma; no log)\n");
-   return 1;
-}

contrib/libtests/timepng.c

@@ -1,303 +0,0 @@
-/* timepng.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
- * and license in png.h
- *
- * Load an arbitrary number of PNG files (from the command line, or, if there
- * are no arguments on the command line, from stdin) then run a time test by
- * reading each file by row.  The test does nothing with the read result and
- * does no transforms.  The only output is a time as a floating point number of
- * seconds with 9 decimal digits.
- */
-#define _POSIX_C_SOURCE 199309L /* for clock_gettime */
-
-#include <stdlib.h>
-#include <stdio.h>
-#include <string.h>
-
-#include <time.h>
-
-#if defined(HAVE_CONFIG_H) && !defined(PNG_NO_CONFIG_H)
-#  include <config.h>
-#endif
-
-/* Define the following to use this test against your installed libpng, rather
- * than the one being built here:
- */
-#ifdef PNG_FREESTANDING_TESTS
-#  include <png.h>
-#else
-#  include "../../png.h"
-#endif
-
-static int read_png(FILE *fp)
-{
-   png_structp png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING,0,0,0);
-   png_infop info_ptr = NULL;
-   png_bytep row = NULL, display = NULL;
-
-   if (png_ptr == NULL)
-      return 0;
-
-   if (setjmp(png_jmpbuf(png_ptr)))
-   {
-      png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
-      if (row != NULL) free(row);
-      if (display != NULL) free(display);
-      return 0;
-   }
-
-   png_init_io(png_ptr, fp);
-
-   info_ptr = png_create_info_struct(png_ptr);
-   if (info_ptr == NULL)
-      png_error(png_ptr, "OOM allocating info structure");
-
-   png_read_info(png_ptr, info_ptr);
-
-   {
-      png_size_t rowbytes = png_get_rowbytes(png_ptr, info_ptr);
-
-      row = malloc(rowbytes);
-      display = malloc(rowbytes);
-
-      if (row == NULL || display == NULL)
-         png_error(png_ptr, "OOM allocating row buffers");
-
-      {
-         png_uint_32 height = png_get_image_height(png_ptr, info_ptr);
-         int passes = png_set_interlace_handling(png_ptr);
-         int pass;
-
-         png_start_read_image(png_ptr);
-
-         for (pass = 0; pass < passes; ++pass)
-         {
-            png_uint_32 y = height;
-
-            /* NOTE: this trashes the row each time; interlace handling won't
-             * work, but this avoids memory thrashing for speed testing.
-             */
-            while (y-- > 0)
-               png_read_row(png_ptr, row, display);
-         }
-      }
-   }
-
-   /* Make sure to read to the end of the file: */
-   png_read_end(png_ptr, info_ptr);
-   png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
-   free(row);
-   free(display);
-   return 1;
-}
-
-static int mytime(struct timespec *t)
-{
-   /* Do the timing using clock_gettime and the per-process timer. */
-   if (!clock_gettime(CLOCK_PROCESS_CPUTIME_ID, t))
-      return 1;
-
-   perror("CLOCK_PROCESS_CPUTIME_ID");
-   fprintf(stderr, "timepng: could not get the time\n");
-   return 0;
-}
-
-static int perform_one_test(FILE *fp, int nfiles)
-{
-   int i;
-   struct timespec before, after;
-
-   /* Clear out all errors: */
-   rewind(fp);
-
-   if (mytime(&before))
-   {
-      for (i=0; i<nfiles; ++i)
-      {
-         if (read_png(fp))
-         {
-            if (ferror(fp))
-            {
-               perror("temporary file");
-               fprintf(stderr, "file %d: error reading PNG data\n", i);
-               return 0;
-            }
-         }
-
-         else
-         {
-            perror("temporary file");
-            fprintf(stderr, "file %d: error from libpng\n", i);
-            return 0;
-         }
-      }
-   }
-
-   else
-      return 0;
-
-   if (mytime(&after))
-   {
-      /* Work out the time difference and print it - this is the only output,
-       * so flush it immediately.
-       */
-      unsigned long s = after.tv_sec - before.tv_sec;
-      long ns = after.tv_nsec - before.tv_nsec;
-
-      if (ns < 0)
-      {
-         --s;
-         ns += 1000000000;
-
-         if (ns < 0)
-         {
-            fprintf(stderr, "timepng: bad clock from kernel\n");
-            return 0;
-         }
-      }
-
-      printf("%lu.%.9ld\n", s, ns);
-      fflush(stdout);
-      if (ferror(stdout))
-      {
-         fprintf(stderr, "timepng: error writing output\n");
-         return 0;
-      }
-
-      /* Successful return */
-      return 1;
-   }
-
-   else
-      return 0;
-}
-
-static int add_one_file(FILE *fp, char *name)
-{
-   FILE *ip = fopen(name, "rb");
-
-   if (ip != NULL)
-   {
-      int ch;
-      for (;;)
-      {
-         ch = getc(ip);
-         if (ch == EOF) break;
-         putc(ch, fp);
-      }
-
-      if (ferror(ip))
-      {
-         perror(name);
-         fprintf(stderr, "%s: read error\n", name);
-         return 0;
-      }
-
-      (void)fclose(ip);
-
-      if (ferror(fp))
-      {
-         perror("temporary file");
-         fprintf(stderr, "temporary file write error\n");
-         return 0;
-      }
-   }
-
-   else
-   {
-      perror(name);
-      fprintf(stderr, "%s: open failed\n", name);
-      return 0;
-   }
-
-   return 1;
-}
-
-int main(int argc, char **argv)
-{
-   int ok = 0;
-   FILE *fp = tmpfile();
-
-   if (fp != NULL)
-   {
-      int err = 0;
-      int nfiles = 0;
-
-      if (argc > 1)
-      {
-         int i;
-
-         for (i=1; i<argc; ++i)
-         {
-            if (add_one_file(fp, argv[i]))
-               ++nfiles;
-
-            else
-            {
-               err = 1;
-               break;
-            }
-         }
-      }
-
-      else
-      {
-         char filename[FILENAME_MAX+1];
-
-         while (fgets(filename, FILENAME_MAX+1, stdin))
-         {
-            int len = strlen(filename);
-
-            if (filename[len-1] == '\n')
-            {
-               filename[len-1] = 0;
-               if (add_one_file(fp, filename))
-                  ++nfiles;
-
-               else
-               {
-                  err = 1;
-                  break;
-               }
-            }
-
-            else
-            {
-               fprintf(stderr, "timepng: truncated file name ...%s\n",
-                  filename+len-32);
-               err = 1;
-               break;
-            }
-         }
-
-         if (ferror(stdin))
-         {
-            fprintf(stderr, "timepng: stdin: read error\n");
-            err = 1;
-         }
-      }
-
-      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
-      fprintf(stderr, "timepng: could not open temporary file\n");
-
-   /* Exit code 0 on success. */
-   return ok == 0;
-}

contrib/pngminim/README

@@ -1,5 +0,0 @@
-
-This demonstrates the use of PNG_USER_CONFIG, pngusr.h and pngusr.dfa
-to build minimal decoder, encoder, and progressive reader applications.
-
-See the individual README and pngusr.dfa files for more explanation.

contrib/pngminim/decoder/README

@@ -1,10 +1,9 @@
-This demonstrates the use of PNG_USER_CONFIG, pngusr.h and pngusr.dfa
+This demonstrates the use of PNG_USER_CONFIG and pngusr.h
 
-The makefile builds a minimal read-only decoder with embedded libpng
-and zlib.
+To build a minimal read-only decoder with embedded libpng and zlib, run
 
-Specify the location of the zlib source (1.2.1 or later) as ZLIBSRC
-on the make command line.
+    gather.sh  # to collect needed files from pngminus, libpng, and zlib
+    make
 
 If you prefer to use the shared libraries, go to contrib/pngminus
-and build the png2pnm application there.
+and build the png2pnm application there. 

contrib/pngminim/decoder/gather.sh

@@ -0,0 +1,9 @@
+cp ../../pngminus/png2pnm.c pngm2pnm.c
+cp ../../../*.h .
+cp ../../../*.c .
+rm pnggccrd.c pngvcrd.c
+rm example.c pngtest.c pngpread.c pngw*.c
+# change the following 2 lines if zlib is somewhere else
+cp ../../../../zlib/*.h .
+cp ../../../../zlib/*.c .
+rm minigzip.c example.c compress.c deflate.c 

contrib/pngminim/decoder/makefile

@@ -5,82 +5,27 @@
 CC=gcc
 LD=$(CC)
 
-# If awk fails try
-# make AWK=nawk
-
-# If cpp fails try
-# make CPP=/lib/cpp
-
 RM=rm -f
-COPY=cp
 
-CFLAGS=-DPNG_USER_CONFIG -DNO_GZCOMPRESS -DZ_SOLO -DNO_GZIP -I. -O1
+CFLAGS=-DPNG_CONFIGURE_LIBPNG -DPNG_USER_CONFIG -DNO_GZCOMPRESS -DNO_GZIP \
+       -DdeflateParams\(a,b,c\)=Z_OK -I. -O1
 
 C=.c
 O=.o
 L=.a
 E=
 
-# Where to find the source code:
-PNGSRC =../../..
-ZLIBSRC=$(PNGSRC)/../zlib
-PROGSRC=$(PNGSRC)/contrib/pngminus
+ZOBJS  = adler32$(O) crc32$(O) gzio$(O) \
+	 infback$(O) inffast$(O) inflate$(O) inftrees$(O) \
+	 trees$(O) uncompr$(O) zutil$(O)
 
-# Zlib (minimal inflate requirements - crc32 is used by libpng)
-# zutil can be eliminated if you provide your own zcalloc and zcfree
-ZSRCS  = adler32$(C) crc32$(C) \
-	 inffast$(C) inflate$(C) inftrees$(C) \
-	 zutil$(C)
-
-# Standard headers
-ZH     = zlib.h crc32.h inffast.h inffixed.h \
-	 inflate.h inftrees.h zutil.h
-
-# Machine generated headers
-ZCONF  = zconf.h
-
-# Headers callers use
-ZINC   = zlib.h $(ZCONF)
-
-# Headers the Zlib source uses
-ZHDRS  = $(ZH) $(ZCONF)
-
-ZOBJS  = adler32$(O) crc32$(O) \
-	 inffast$(O) inflate$(O) inftrees$(O) \
-	 zutil$(O)
-
-# libpng
-PNGSRCS=png$(C) pngerror$(C) pngget$(C) pngmem$(C) \
-	pngread$(C) pngrio$(C) pngrtran$(C) pngrutil$(C) \
-	pngset$(C) pngtrans$(C)
-	
-# Standard headers
-PNGH   =png.h pngconf.h pngdebug.h pnginfo.h pngpriv.h pngstruct.h
-
-# Machine generated headers
-PNGCONF=pnglibconf.h
-
-# Headers callers use
-PNGINC= png.h pngconf.h pngusr.h $(PNGCONF)
-
-# Headers the PNG library uses
-PNGHDRS=$(PNGH) $(PNGCONF) pngusr.h
-
-PNGOBJS=png$(O) pngerror$(O) pngget$(O) pngmem$(O) \
+OBJS  = pngm2pnm$(O) png$(O) pngerror$(O) pngget$(O) pngmem$(O) \
 	pngread$(O) pngrio$(O) pngrtran$(O) pngrutil$(O) \
-	pngset$(O) pngtrans$(O)
-
-PROGSRCS= pngm2pnm$(C)
-PROGHDRS=
-PROGDOCS=
-PROGOBJS= pngm2pnm$(O)
-
-OBJS    = $(PROGOBJS) $(PNGOBJS) $(ZOBJS)
+	pngset$(O) pngtrans$(O)  $(ZOBJS)
 
 # implicit make rules -------------------------------------------------------
 
-# note: dependencies do not work on implicit rule lines
-.c$(O):
+.c$(O): png.h pngconf.h pngusr.h zlib.h
 	$(CC) -c $(CFLAGS) $<
 
 # dependencies
@@ -89,62 +34,11 @@ all: pngm2pnm$(E)
 
 pngm2pnm$(E): $(OBJS)
 	$(LD) -o pngm2pnm$(E) $(OBJS)
-
-# The DFA_XTRA setting turns all libpng options off then
-# turns on those required for this minimal build.
-# The CPP_FLAGS setting causes pngusr.h to be included in
-# both the build of pnglibconf.h and, subsequently, when
-# building libpng itself.
-$(PNGCONF): $(PNGSRC)/scripts/pnglibconf.mak\
-	$(PNGSRC)/scripts/pnglibconf.dfa \
-	$(PNGSRC)/scripts/options.awk pngusr.h pngusr.dfa
-	$(RM) pnglibconf.h pnglibconf.dfn
-	$(MAKE) $(MAKEFLAGS) -f $(PNGSRC)/scripts/pnglibconf.mak\
-	    srcdir=$(PNGSRC) CPPFLAGS="-DPNG_USER_CONFIG"\
-	    DFA_XTRA="pngusr.dfa" $@
+	strip pngm2pnm$(E)
 
 clean:
-	$(MAKE) $(MAKEFLAGS) -f $(PNGSRC)/scripts/pnglibconf.mak\
-	    srcdir=$(PNGSRC) clean
 	$(RM) pngm2pnm$(O)
 	$(RM) pngm2pnm$(E)
 	$(RM) $(OBJS)
 
-# distclean also removes the copied source and headers
-distclean: clean
-	$(RM) -r scripts # historical reasons
-	$(RM) $(PNGSRCS) $(PNGH)
-	$(RM) $(ZSRCS) $(ZH) $(ZCONF)
-	$(RM) $(PROGSRCS) $(PROGHDRS) $(PROGDOCS)
-
-# Header file dependencies:
-$(PROGOBJS): $(PROGHDRS) $(PNGINC) $(ZINC)
-$(PNGOBJS): $(PNGHDRS) $(ZINC)
-$(ZOBJS): $(ZHDRS)
-
-# Gather the source code from the respective directories
-$(PNGSRCS) $(PNGH): $(PNGSRC)/$@
-	$(RM) $@
-	$(COPY) $(PNGSRC)/$@ $@
-
-# No dependency on the ZLIBSRC target so that it only needs
-# to be specified once.
-$(ZSRCS) $(ZH):
-	$(RM) $@
-	$(COPY) $(ZLIBSRC)/$@ $@
-
-# The unconfigured zconf.h varies in name according to the
-# zlib release
-$(ZCONF):
-	$(RM) $@
-	@for f in zconf.h.in zconf.in.h zconf.h; do\
-	    test -r $(ZLIBSRC)/$$f &&\
-	    echo $(COPY) $(ZLIBSRC)/$$f $@ &&\
-	    $(COPY) $(ZLIBSRC)/$$f $@ && exit 0;\
-	done; echo copy: $(ZLIBSRC)/zconf.h not found; exit 1
-
-pngm2pnm.c: $(PROGSRC)/png2pnm.c
-	$(RM) $@
-	$(COPY) $(PROGSRC)/png2pnm.c $@
-
 # End of makefile for pngm2pnm

contrib/pngminim/decoder/pngusr.dfa

@@ -1,40 +0,0 @@
-# pngminim/decoder/pngusr.dfa
-#
-# Copyright (c) 2010-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
-
-# First all the build options off:
-
-everything = off
-
-# All that is required is some read code. This example switches
-# on the sequential read code (see ../preader for a progressive
-# read example).
-
-option SEQUENTIAL_READ on
-
-# You must choose fixed or floating point arithmetic:
-# option FLOATING_POINT on
-
-option FIXED_POINT on
-
-# You must chose the internal fixed point implementation or to
-# use the system floating point.  The latter is considerably
-# smaller (by about 1kbyte on an x86 system):
-# option FLOATING_ARITHMETIC on
-
-option FLOATING_ARITHMETIC off
-
-# Your program will probably need other options.  The example
-# program here, pngm2pnm, requires the following.  Take a look
-# at pnglibconf.h to find out the full set of what has to be
-# enabled to make the following work.
-
-option SETJMP on
-option STDIO on
-option READ_EXPAND on
-option READ_STRIP_16_TO_8 on
-option USER_LIMITS on

contrib/pngminim/decoder/pngusr.h

@@ -1,6 +1,6 @@
 /* minrdpngconf.h: headers to make a minimal png-read-only library
  *
- * Copyright (c) 2007, 2010-2013 Glenn Randers-Pehrson
+ * Copyright (c) 2007, 2009 Glenn Randers-Pehrson
  *
  * This code is released under the libpng license.
  * For conditions of distribution and use, see the disclaimer
@@ -12,13 +12,67 @@
 #ifndef MINRDPNGCONF_H
 #define MINRDPNGCONF_H
 
-/* To include pngusr.h set -DPNG_USER_CONFIG in CPPFLAGS */
+#ifdef NJET
+  /* No 16-bit support beyond reading with strip_16 */
+#endif
 
-/* List options to turn off features of the build that do not
- * affect the API (so are not recorded in pnglibconf.h)
- */
+#define PNG_NO_GLOBAL_ARRAYS
 
 #define PNG_NO_WARNINGS
-#define PNG_ALIGN_TYPE PNG_ALIGN_NONE
+#define png_warning(s1,s2) ""
+#define png_chunk_warning(s1,s2) ""
+#define PNG_NO_ERROR_TEXT
+#define png_error(s1,s2) png_err(s1)
+#define png_chunk_error(s1,s2) png_err(s1)
+
+#define PNG_NO_ASSEMBLER_CODE
+#define PNG_NO_OPTIMIZED_CODE
+#define PNG_NO_READ_GAMMA
+#define PNG_NO_READ_BACKGROUND
+#define PNG_NO_READ_DITHER
+#define PNG_NO_READ_INVERT
+#define PNG_NO_READ_SHIFT
+#define PNG_NO_READ_PACK
+#define PNG_NO_READ_PACKSWAP
+#define PNG_NO_READ_FILLER
+#define PNG_NO_READ_SWAP
+#define PNG_NO_READ_SWAP_ALPHA
+#define PNG_NO_READ_INVERT_ALPHA
+#define PNG_NO_READ_RGB_TO_GRAY
+#define PNG_NO_READ_USER_TRANSFORM
+#define PNG_NO_READ_bKGD
+#define PNG_NO_READ_cHRM
+#define PNG_NO_READ_gAMA
+#define PNG_NO_READ_hIST
+#define PNG_NO_READ_iCCP
+#define PNG_NO_READ_pCAL
+#define PNG_NO_READ_pHYs
+#define PNG_NO_READ_sBIT
+#define PNG_NO_READ_sCAL
+#define PNG_NO_READ_sPLT
+#define PNG_NO_READ_sRGB
+#define PNG_NO_READ_TEXT
+#define PNG_NO_READ_tIME
+#define PNG_NO_READ_UNKNOWN_CHUNKS
+#define PNG_NO_READ_USER_CHUNKS
+#define PNG_NO_READ_EMPTY_PLTE
+#define PNG_NO_READ_OPT_PLTE
+#define PNG_NO_READ_STRIP_ALPHA
+#define PNG_NO_READ_oFFs
+#define PNG_NO_WARN_UNINITIALIZED_ROW
+
+#define PNG_NO_WRITE_SUPPORTED
+
+#define PNG_NO_INFO_IMAGE
+#define PNG_NO_USER_MEM
+#define PNG_NO_FIXED_POINT_SUPPORTED
+#define PNG_NO_MNG_FEATURES
+#define PNG_NO_USER_TRANSFORM_PTR
+#define PNG_NO_HANDLE_AS_UNKNOWN
+#define PNG_NO_CONSOLE_IO
+#define PNG_NO_ZALLOC_ZERO
+#define PNG_NO_ERROR_NUMBERS
+#define PNG_NO_EASY_ACCESS
+#define PNG_NO_PROGRESSIVE_READ
 
 #endif /* MINRDPNGCONF_H */

contrib/pngminim/encoder/README

@@ -1,10 +1,9 @@
 This demonstrates the use of PNG_USER_CONFIG and pngusr.h
 
-The makefile builds a minimal write-only encoder with embedded libpng
-and zlib.
-
-Specify the location of the zlib source (1.2.1 or later) as ZLIBSRC
-on the make command line.
+To build a minimal write-only decoder with embedded libpng and zlib, run
 
+    gather.sh  # to collect needed files from pngminus, libpng, and zlib
+    make
+ 
 If you prefer to use the shared libraries, go to contrib/pngminus
-and build the pnm2png application there.
+and build the pnm2png application there. 

contrib/pngminim/encoder/dummy_inflate.c

@@ -0,0 +1,27 @@
+#include "zlib.h"
+
+int ZEXPORT inflate(strm, flush)
+z_streamp strm;
+int flush;
+{ return Z_OK ; }
+
+int ZEXPORT inflateReset(strm)
+z_streamp strm;
+{ return Z_OK ; }
+
+int ZEXPORT inflateEnd(strm)
+z_streamp strm;
+{ return Z_STREAM_ERROR ; }
+
+int ZEXPORT inflateInit_(strm, version, stream_size)
+z_streamp strm;
+const char *version;
+int stream_size;
+{ return Z_OK ; }
+
+int ZEXPORT inflateInit2_(strm, windowBits, version, stream_size)
+z_streamp strm;
+int windowBits;
+const char *version;
+int stream_size;
+{ return Z_STREAM_ERROR ; }

contrib/pngminim/encoder/gather.sh

@@ -0,0 +1,10 @@
+cp ../../pngminus/pnm2png.c pnm2pngm.c
+cp ../../../*.h .
+cp ../../../*.c .
+rm pnggccrd.c pngvcrd.c
+rm example.c pngtest.c pngr*.c pngpread.c
+# Change the next 2 lines if zlib is somewhere else.
+cp ../../../../zlib/*.h .
+cp ../../../../zlib/*.c .
+rm inf*.[ch]
+rm minigzip.c example.c

contrib/pngminim/encoder/makefile

@@ -5,81 +5,26 @@
 CC=gcc
 LD=$(CC)
 
-# If awk fails try
-# make AWK=nawk
-
-# If cpp fails try
-# make CPP=/lib/cpp
-
 RM=rm -f
-COPY=cp
 
-CFLAGS=-DPNG_USER_CONFIG -DZ_SOLO -DNO_GZIP -I. -O1
+CFLAGS=-DPNG_CONFIGURE_LIBPNG -DPNG_USER_CONFIG -DNO_GZIP -I. -O1
 
 C=.c
 O=.o
 L=.a
 E=
 
-# Where to find the source code:
-PNGSRC =../../..
-ZLIBSRC=$(PNGSRC)/../zlib
-PROGSRC=$(PNGSRC)/contrib/pngminus
+ZOBJS  = adler32$(O) compress$(O) crc32$(O) deflate$(O) gzio$(O) \
+	 dummy_inflate$(O) \
+	 trees$(O) uncompr$(O) zutil$(O)
 
-# Zlib
-ZSRCS  = adler32$(C) compress$(C) crc32$(C) deflate$(C) \
-	 trees$(C) zutil$(C)
-
-# Standard headers
-#ZH     = zlib.h crc32.h deflate.h trees.h zutil.h
-ZH     = zlib.h crc32.h deflate.h trees.h zutil.h
-
-# Machine generated headers
-ZCONF  = zconf.h
-
-# Headers callers use
-ZINC   = zlib.h $(ZCONF)
-
-# Headers the Zlib source uses
-ZHDRS  = $(ZH) $(ZCONF)
-
-# compress is not required; it is needed to link the zlib
-# code because deflate defines an unused API function deflateBound
-# which itself calls compressBound from compress.
-ZOBJS  = adler32$(O) compress$(O) crc32$(O) deflate$(O) \
-	 trees$(O) zutil$(O)
-
-# libpng
-PNGSRCS=png$(C) pngerror$(C) pngget$(C) pngmem$(C) \
-	pngset$(C) pngtrans$(C) pngwio$(C) pngwrite$(C) \
-	pngwtran$(C) pngwutil$(C)
-
-# Standard headers
-PNGH   =png.h pngconf.h pngdebug.h pnginfo.h pngpriv.h pngstruct.h
-
-# Machine generated headers
-PNGCONF=pnglibconf.h
-
-# Headers callers use
-PNGINC= png.h pngconf.h pngusr.h $(PNGCONF)
-
-# Headers the PNG library uses
-PNGHDRS=$(PNGH) $(PNGCONF) pngusr.h
-
-PNGOBJS=png$(O) pngerror$(O) pngget$(O) pngmem$(O) \
+OBJS  = pnm2pngm$(O) png$(O) pngerror$(O) pngget$(O) pngmem$(O) \
 	pngset$(O) pngtrans$(O) pngwio$(O) pngwrite$(O) \
-	pngwtran$(O) pngwutil$(O)
-
-PROGSRCS= pnm2pngm$(C)
-PROGHDRS=
-PROGDOCS=
-PROGOBJS= pnm2pngm$(O)
-
-OBJS    = $(PROGOBJS) $(PNGOBJS) $(ZOBJS)
+	pngwtran$(O) pngwutil$(O) $(ZOBJS)
 
 # implicit make rules -------------------------------------------------------
 
-.c$(O):
+.c$(O): png.h pngconf.h pngusr.h zlib.h
 	$(CC) -c $(CFLAGS) $<
 
 # dependencies
@@ -88,62 +33,11 @@ all: pnm2pngm$(E)
 
 pnm2pngm$(E): $(OBJS)
 	$(LD) -o pnm2pngm$(E) $(OBJS)
-
-# The DFA_XTRA setting turns all libpng options off then
-# turns on those required for this minimal build.
-# The CPP_FLAGS setting causes pngusr.h to be included in
-# both the build of pnglibconf.h and, subsequently, when
-# building libpng itself.
-$(PNGCONF): $(PNGSRC)/scripts/pnglibconf.mak\
-	$(PNGSRC)/scripts/pnglibconf.dfa \
-	$(PNGSRC)/scripts/options.awk pngusr.h pngusr.dfa
-	$(RM) pnglibconf.h pnglibconf.dfn
-	$(MAKE) $(MAKEFLAGS) -f $(PNGSRC)/scripts/pnglibconf.mak\
-	    srcdir=$(PNGSRC) CPPFLAGS="-DPNG_USER_CONFIG"\
-	    DFA_XTRA="pngusr.dfa" $@
+	strip pnm2pngm$(E)
 
 clean:
-	$(MAKE) $(MAKEFLAGS) -f $(PNGSRC)/scripts/pnglibconf.mak\
-	    srcdir=$(PNGSRC) clean
 	$(RM) pnm2pngm$(O)
 	$(RM) pnm2pngm$(E)
 	$(RM) $(OBJS)
 
-# distclean also removes the copied source and headers
-distclean: clean
-	$(RM) -r scripts # historical reasons
-	$(RM) $(PNGSRCS) $(PNGH)
-	$(RM) $(ZSRCS) $(ZH) $(ZCONF)
-	$(RM) $(PROGSRCS) $(PROGHDRS) $(PROGDOCS)
-
-# Header file dependencies:
-$(PROGOBJS): $(PROGHDRS) $(PNGINC) $(ZINC)
-$(PNGOBJS): $(PNGHDRS) $(ZINC)
-$(ZOBJS): $(ZHDRS)
-
-# Gather the source code from the respective directories
-$(PNGSRCS) $(PNGH): $(PNGSRC)/$@
-	$(RM) $@
-	$(COPY) $(PNGSRC)/$@ $@
-
-# No dependency on the ZLIBSRC target so that it only needs
-# to be specified once.
-$(ZSRCS) $(ZH):
-	$(RM) $@
-	$(COPY) $(ZLIBSRC)/$@ $@
-
-# The unconfigured zconf.h varies in name according to the
-# zlib release
-$(ZCONF):
-	$(RM) $@
-	@for f in zconf.h.in zconf.in.h zconf.h; do\
-	    test -r $(ZLIBSRC)/$$f &&\
-	    echo $(COPY) $(ZLIBSRC)/$$f $@ &&\
-	    $(COPY) $(ZLIBSRC)/$$f $@ && exit 0;\
-	done; echo copy: $(ZLIBSRC)/zconf.h not found; exit 1
-
-pnm2pngm.c: $(PROGSRC)/pnm2png.c
-	$(RM) $@
-	$(COPY) $(PROGSRC)/pnm2png.c $@
-
 # End of makefile for pnm2pngm

contrib/pngminim/encoder/pngusr.dfa

@@ -1,35 +0,0 @@
-# pngminim/encoder/pngusr.dfa
-#
-# Copyright (c) 2010-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
-
-# First all the build options off:
-
-everything = off
-
-# Switch on the write code - this makes a minimalist encoder
-
-option WRITE on
-
-# You must choose fixed or floating point arithmetic:
-# option FLOATING_POINT on
-
-option FIXED_POINT on
-
-# You must chose the internal fixed point implementation or to
-# use the system floating point.  The latter is considerably
-# smaller (by about 1kbyte on an x86 system):
-# option FLOATING_ARITHMETIC on
-
-option FLOATING_ARITHMETIC off
-
-# Your program will probably need other options.  The example
-# program here, pnm2pngm, requires the following.  Take a look
-# at pnglibconf.h to find out the full set of what has to be
-# enabled to make the following work.
-
-option SETJMP on
-option STDIO on

contrib/pngminim/encoder/pngusr.h

@@ -1,6 +1,6 @@
 /* minwrpngconf.h: headers to make a minimal png-write-only library
  *
- * Copyright (c) 2007, 2010-2013 Glenn Randers-Pehrson
+ * Copyright (c) 2007, 2009 Glenn Randers-Pehrson
  *
  * This code is released under the libpng license.
  * For conditions of distribution and use, see the disclaimer
@@ -12,13 +12,62 @@
 #ifndef MINWRPNGCONF_H
 #define MINWRPNGCONF_H
 
-/* To include pngusr.h set -DPNG_USER_CONFIG in CPPFLAGS */
+#define PNG_NO_GLOBAL_ARRAYS
 
-/* List options to turn off features of the build that do not
- * affect the API (so are not recorded in pnglibconf.h)
- */
+#define PNG_NO_READ_SUPPORTED
 
 #define PNG_NO_WARNINGS
-#define PNG_ALIGN_TYPE PNG_ALIGN_NONE
+#define png_warning(s1,s2) ""
+#define png_chunk_warning(s1,s2) ""
+#define PNG_NO_ERROR_TEXT
+#define png_error(s1,s2) png_err(s1)
+#define png_chunk_error(s1,s2) png_err(s1)
+
+#define PNG_NO_WRITE_BACKGROUND
+#define PNG_NO_WRITE_GAMMA
+#define PNG_NO_WRITE_DITHER
+#define PNG_NO_WRITE_INVERT
+#define PNG_NO_WRITE_SHIFT
+#define PNG_NO_WRITE_PACK
+#define PNG_NO_WRITE_PACKSWAP
+#define PNG_NO_WRITE_FILLER
+#define PNG_NO_WRITE_SWAP
+#define PNG_NO_WRITE_SWAP_ALPHA
+#define PNG_NO_WRITE_INVERT_ALPHA
+#define PNG_NO_WRITE_RGB_TO_GRAY
+#define PNG_NO_WRITE_USER_TRANSFORM
+#define PNG_NO_WRITE_bKGD
+#define PNG_NO_WRITE_cHRM
+#define PNG_NO_WRITE_gAMA
+#define PNG_NO_WRITE_hIST
+#define PNG_NO_WRITE_iCCP
+#define PNG_NO_WRITE_oFFs
+#define PNG_NO_WRITE_pCAL
+#define PNG_NO_WRITE_pHYs
+#define PNG_NO_WRITE_sBIT
+#define PNG_NO_WRITE_sCAL
+#define PNG_NO_WRITE_sPLT
+#define PNG_NO_WRITE_sRGB
+#define PNG_NO_WRITE_TEXT
+#define PNG_NO_WRITE_tIME
+#define PNG_NO_WRITE_UNKNOWN_CHUNKS
+#define PNG_NO_WRITE_USER_CHUNKS
+#define PNG_NO_WRITE_EMPTY_PLTE
+#define PNG_NO_WRITE_OPT_PLTE
+#define PNG_NO_WRITE_FILTER
+#define PNG_NO_WRITE_WEIGHTED_FILTER
+#define PNG_NO_WRITE_INTERLACING_SUPPORTED
+#define PNG_NO_WRITE_FLUSH
+
+#define PNG_NO_INFO_IMAGE
+#define PNG_NO_USER_MEM
+#define PNG_NO_FIXED_POINT_SUPPORTED
+#define PNG_NO_MNG_FEATURES
+#define PNG_NO_USER_TRANSFORM_PTR
+#define PNG_NO_HANDLE_AS_UNKNOWN
+#define PNG_NO_CONSOLE_IO
+#define PNG_NO_ZALLOC_ZERO
+#define PNG_NO_ERROR_NUMBERS
+#define PNG_NO_EASY_ACCESS
 
 #endif /* MINWRPNGCONF_H */

contrib/pngminim/preader/README

@@ -1,15 +1,14 @@
 This demonstrates the use of PNG_USER_CONFIG and pngusr.h
 
-The makefile builds a minimal read-only progressive decoder with
-embedded libpng, zlib and your system's X library.
+To build a minimal read-only progressive decoder embedded libpng and
+zlib and with your system's X library, run
 
-Specify the location of the zlib source (1.2.1 or later) as ZLIBSRC
-on the make command line.
+    gather.sh # to collect needed files from gregbook, libpng, and zlib
 
 Edit makefile if required, to find your X library and include files,
 then
-
-    make ZLIBSRC=directory
-
+    
+    make
+ 
 If you prefer to use the shared libraries, go to contrib/gregbook
-and build the rpng2-x application there.
+and build the rpng2-x application there. 

contrib/pngminim/preader/gather.sh

@@ -0,0 +1,10 @@
+cp ../../gregbook/rpng2-x.c ../../gregbook/readpng2.[ch] .
+cp ../../gregbook/COPYING ../../gregbook/LICENSE .
+cp ../../../*.h .
+cp ../../../*.c .
+rm pnggccrd.c pngvcrd.c
+rm example.c pngtest.c pngw*.c
+# change the following 2 lines if zlib is somewhere else
+cp ../../../../zlib/*.h .
+cp ../../../../zlib/*.c .
+rm minigzip.c example.c compress.c deflate.c 

contrib/pngminim/preader/makefile

@@ -5,14 +5,7 @@
 CC=gcc
 LD=$(CC)
 
-# If awk fails try
-# make AWK=nawk
-
-# If cpp fails try
-# make CPP=/lib/cpp
-
 RM=rm -f
-COPY=cp
 
 #XINC = -I/usr/include			# old-style, stock X distributions
 #XLIB = -L/usr/lib/X11 -lX11		#  (including SGI IRIX)
@@ -30,136 +23,38 @@ XLIB = -L/usr/X11R6/lib -lX11
 #LIBS = $(XLIB)
 LIBS = $(XLIB) -lm                      #platforms that need libm
 
-CFLAGS=-DPNG_USER_CONFIG -DNO_GZCOMPRESS -DZ_SOLO -DNO_GZIP -I. $(XINC) -O1
+CFLAGS=-DPNG_CONFIGURE_LIBPNG -DPNG_USER_CONFIG -DNO_GZCOMPRESS -DNO_GZIP \
+       -DdeflateParams\(a,b,c\)=Z_OK -I. $(XINC) -O1
 
 C=.c
 O=.o
 L=.a
 E=
 
-# Where to find the source code:
-PNGSRC =../../..
-ZLIBSRC=$(PNGSRC)/../zlib
-PROGSRC=$(PNGSRC)/contrib/gregbook
+ZOBJS  = adler32$(O) crc32$(O) gzio$(O) \
+	 infback$(O) inffast$(O) inflate$(O) inftrees$(O) \
+	 trees$(O) uncompr$(O) zutil$(O)
 
-# Zlib (minimal inflate requirements - crc32 is used by libpng)
-# zutil can be eliminated if you provide your own zcalloc and zcfree
-ZSRCS  = adler32$(C) crc32$(C) \
-	 inffast$(C) inflate$(C) inftrees$(C) \
-	 zutil$(C)
-
-# Standard headers
-ZH     = zlib.h crc32.h inffast.h inffixed.h \
-	 inflate.h inftrees.h zutil.h
-
-# Machine generated headers
-ZCONF  = zconf.h
-
-# Headers callers use
-ZINC   = zlib.h $(ZCONF)
-
-# Headers the Zlib source uses
-ZHDRS  = $(ZH) $(ZCONF)
-
-ZOBJS  = adler32$(O) crc32$(O) \
-	 inffast$(O) inflate$(O) inftrees$(O) \
-	 zutil$(O)
-
-# libpng
-PNGSRCS=png$(C) pngerror$(C) pngget$(C) pngmem$(C) \
-	pngpread$(C) pngread$(C) pngrio$(C) pngrtran$(C) pngrutil$(C) \
-	pngset$(C) pngtrans$(C)
-
-# Standard headers
-PNGH   =png.h pngconf.h pngdebug.h pnginfo.h pngpriv.h pngstruct.h
-
-# Machine generated headers
-PNGCONF=pnglibconf.h
-
-# Headers callers use
-PNGINC= png.h pngconf.h pngusr.h $(PNGCONF)
-
-# Headers the PNG library uses
-PNGHDRS=$(PNGH) $(PNGCONF) pngusr.h
-
-PNGOBJS=png$(O) pngerror$(O) pngget$(O) pngmem$(O) \
+OBJS  = rpng2-x$(O) readpng2$(O) png$(O) pngerror$(O) pngget$(O) pngmem$(O) \
 	pngpread$(O) pngread$(O) pngrio$(O) pngrtran$(O) pngrutil$(O) \
-	pngset$(O) pngtrans$(O)
-
-PROGSRCS= rpng2-x$(C) readpng2$(C)
-PROGHDRS= readpng2.h
-PROGDOCS= COPYING LICENSE
-PROGOBJS= rpng2-x$(O) readpng2$(O)
-
-OBJS    = $(PROGOBJS) $(PNGOBJS) $(ZOBJS)
+	pngset$(O) pngtrans$(O)  $(ZOBJS)
 
 # implicit make rules -------------------------------------------------------
 
-.c$(O):
+.c$(O): png.h pngconf.h readpng2.h pngusr.h zlib.h
 	$(CC) -c $(CFLAGS) $<
 
 # dependencies
 
-all: $(PROGDOCS) rpng2-x$(E)
+all: rpng2-x$(E)
 
 rpng2-x$(E): $(OBJS)
 	$(LD) -o rpng2-x$(E) $(OBJS) $(LIBS)
-
-# The DFA_XTRA setting turns all libpng options off then
-# turns on those required for this minimal build.
-# The CPP_FLAGS setting causes pngusr.h to be included in
-# both the build of pnglibconf.h and, subsequently, when
-# building libpng itself.
-$(PNGCONF): $(PNGSRC)/scripts/pnglibconf.mak\
-	$(PNGSRC)/scripts/pnglibconf.dfa \
-	$(PNGSRC)/scripts/options.awk pngusr.h pngusr.dfa
-	$(RM) pnglibconf.h pnglibconf.dfn
-	$(MAKE) $(MAKEFLAGS) -f $(PNGSRC)/scripts/pnglibconf.mak\
-	    srcdir=$(PNGSRC) CPPFLAGS="-DPNG_USER_CONFIG"\
-	    DFA_XTRA="pngusr.dfa" $@
+	strip rpng2-x$(E)
 
 clean:
-	$(MAKE) $(MAKEFLAGS) -f $(PNGSRC)/scripts/pnglibconf.mak\
-	    srcdir=$(PNGSRC) clean
 	$(RM) rpng2-x$(O)
 	$(RM) rpng2-x$(E)
 	$(RM) $(OBJS)
 
-# distclean also removes the copied source and headers
-distclean: clean
-	$(RM) -r scripts # historical reasons
-	$(RM) $(PNGSRCS) $(PNGH)
-	$(RM) $(ZSRCS) $(ZH) $(ZCONF)
-	$(RM) $(PROGSRCS) $(PROGHDRS) $(PROGDOCS)
-
-# Header file dependencies:
-$(PROGOBJS): $(PROGHDRS) $(PNGINC) $(ZINC)
-$(PNGOBJS): $(PNGHDRS) $(ZINC)
-$(ZOBJS): $(ZHDRS)
-
-# Gather the source code from the respective directories
-$(PNGSRCS) $(PNGH): $(PNGSRC)/$@
-	$(RM) $@
-	$(COPY) $(PNGSRC)/$@ $@
-
-# No dependency on the ZLIBSRC target so that it only needs
-# to be specified once.
-$(ZSRCS) $(ZH):
-	$(RM) $@
-	$(COPY) $(ZLIBSRC)/$@ $@
-
-# The unconfigured zconf.h varies in name according to the
-# zlib release
-$(ZCONF):
-	$(RM) $@
-	@for f in zconf.h.in zconf.in.h zconf.h; do\
-	    test -r $(ZLIBSRC)/$$f &&\
-	    echo $(COPY) $(ZLIBSRC)/$$f $@ &&\
-	    $(COPY) $(ZLIBSRC)/$$f $@ && exit 0;\
-	done; echo copy: $(ZLIBSRC)/zconf.h not found; exit 1
-
-$(PROGSRCS) $(PROGHDRS) $(PROGDOCS): $(PROGSRC)/$@
-	$(RM) $@
-	$(COPY) $(PROGSRC)/$@ $@
-
 # End of makefile for rpng2-x

contrib/pngminim/preader/pngusr.dfa

@@ -1,40 +0,0 @@
-# pngminim/preader/pngusr.dfa
-#
-# Copyright (c) 2010-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
-
-# First all the build options off:
-
-everything = off
-
-# Just switch on the progressive read code
-
-option PROGRESSIVE_READ on
-
-# You may choose fixed or floating point APIs:
-# option FLOATING_POINT on
-
-option FIXED_POINT on
-
-# You must chose the internal fixed point implementation or to
-# use the system floating point.  The latter is considerably
-# smaller (by about 1kbyte on an x86 system):
-
-option FLOATING_ARITHMETIC on
-# option FLOATING_ARITHMETIC off
-
-# Your program will probably need other options.  The example
-# program here, rpng2-x, requires the following.  Take a look
-# at pnglibconf.h to find out the full set of what has to be
-# enabled to make the following work.
-
-option SETJMP on
-option STDIO on
-option READ_bKGD on
-option READ_GAMMA on
-option READ_EXPAND on
-option READ_STRIP_16_TO_8 on
-option READ_GRAY_TO_RGB on

contrib/pngminim/preader/pngusr.h

@@ -1,6 +1,6 @@
 /* minrdpngconf.h: headers to make a minimal png-read-only library
  *
- * Copyright (c) 2009, 2010-2013 Glenn Randers-Pehrson
+ * Copyright (c) 2009 Glenn Randers-Pehrson
  *
  * This code is released under the libpng license.
  * For conditions of distribution and use, see the disclaimer
@@ -12,13 +12,57 @@
 #ifndef MINPRDPNGCONF_H
 #define MINPRDPNGCONF_H
 
-/* To include pngusr.h set -DPNG_USER_CONFIG in CPPFLAGS */
-
-/* List options to turn off features of the build that do not
- * affect the API (so are not recorded in pnglibconf.h)
- */
+#define PNG_NO_GLOBAL_ARRAYS
 
 #define PNG_NO_WARNINGS
-#define PNG_ALIGN_TYPE PNG_ALIGN_NONE
+#define png_warning(s1,s2) ""
+#define png_chunk_warning(s1,s2) ""
+#define PNG_NO_ERROR_TEXT
+#define png_error(s1,s2) png_err(s1)
+#define png_chunk_error(s1,s2) png_err(s1)
+
+#define PNG_NO_ASSEMBLER_CODE
+#define PNG_NO_OPTIMIZED_CODE
+#define PNG_NO_READ_DITHER
+#define PNG_NO_READ_INVERT
+#define PNG_NO_READ_SHIFT
+#define PNG_NO_READ_PACK
+#define PNG_NO_READ_PACKSWAP
+#define PNG_NO_READ_FILLER
+#define PNG_NO_READ_SWAP
+#define PNG_NO_READ_SWAP_ALPHA
+#define PNG_NO_READ_INVERT_ALPHA
+#define PNG_NO_READ_RGB_TO_GRAY
+#define PNG_NO_READ_USER_TRANSFORM
+#define PNG_NO_READ_cHRM
+#define PNG_NO_READ_hIST
+#define PNG_NO_READ_iCCP
+#define PNG_NO_READ_pCAL
+#define PNG_NO_READ_pHYs
+#define PNG_NO_READ_sBIT
+#define PNG_NO_READ_sCAL
+#define PNG_NO_READ_sPLT
+#define PNG_NO_READ_TEXT
+#define PNG_NO_READ_tIME
+#define PNG_NO_READ_UNKNOWN_CHUNKS
+#define PNG_NO_READ_USER_CHUNKS
+#define PNG_NO_READ_EMPTY_PLTE
+#define PNG_NO_READ_OPT_PLTE
+#define PNG_NO_READ_STRIP_ALPHA
+#define PNG_NO_READ_oFFs
+#define PNG_NO_WARN_UNINITIALIZED_ROW
+
+#define PNG_NO_WRITE_SUPPORTED
+
+#define PNG_NO_INFO_IMAGE
+#define PNG_NO_USER_MEM
+#define PNG_NO_FIXED_POINT_SUPPORTED
+#define PNG_NO_MNG_FEATURES
+#define PNG_NO_USER_TRANSFORM_PTR
+#define PNG_NO_HANDLE_AS_UNKNOWN
+#define PNG_NO_CONSOLE_IO
+#define PNG_NO_ZALLOC_ZERO
+#define PNG_NO_ERROR_NUMBERS
+#define PNG_NO_EASY_ACCESS
 
 #endif /* MINPRDPNGCONF_H */

contrib/pngminus/makefile.std

@@ -8,9 +8,9 @@ LD=$(CC)
 RM=rm -f
 
 #PNGPATH = /usr/local
-#PNGINC = -I$(PNGPATH)/include/libpng16
-#PNGLIB = -L$(PNGPATH)/lib -lpng16
-#PNGLIBS = $(PNGPATH)/lib/libpng16.a
+#PNGINC = -I$(PNGPATH)/include/libpng12
+#PNGLIB = -L$(PNGPATH)/lib -lpng12
+#PNGLIBS = $(PNGPATH)/lib/libpng12.a
 PNGINC = -I../..
 PNGLIB = -L../.. -lpng
 PNGLIBS = ../../libpng.a
@@ -23,9 +23,9 @@ ZINC = -I../../../zlib
 ZLIB = -L../../../zlib -lz
 ZLIBS = ../../../zlib/libz.a
 
-CFLAGS=$(PNGINC) $(ZINC)
-LDLIBS=$(PNGLIB) $(ZLIB)
-LDLIBSS=$(PNGLIBS) $(ZLIBS)
+CFLAGS=-O3 $(PNGINC) $(ZINC)
+LDFLAGS=$(PNGLIB) $(ZLIB)
+LDFLAGSS=$(PNGLIBS) $(ZLIBS)
 C=.c
 O=.o
 L=.a
@@ -40,19 +40,19 @@ png2pnm$(O): png2pnm$(C)
 	$(CC) -c $(CFLAGS) png2pnm$(C)
 
 png2pnm$(E): png2pnm$(O)
-	$(LD) $(LDFLAGS) -o png2pnm$(E) png2pnm$(O) $(LDLIBS) -lm
+	$(LD) -o png2pnm$(E) png2pnm$(O) $(LDFLAGS) -lm
 
 png2pnm-static$(E): png2pnm$(O)
-	$(LD) $(LDFLAGS) -o png2pnm-static$(E) png2pnm$(O) $(LDLIBSS) -lm
+	$(LD) -o png2pnm-static$(E) png2pnm$(O) $(LDFLAGSS) -lm
 
 pnm2png$(O): pnm2png$(C)
 	$(CC) -c $(CFLAGS) pnm2png$(C)
 
 pnm2png$(E): pnm2png$(O)
-	$(LD) $(LDFLAGS) -o pnm2png$(E) pnm2png$(O) $(LDLIBS) -lm
+	$(LD) -o pnm2png$(E) pnm2png$(O) $(LDFLAGS) -lm
 
 pnm2png-static$(E): pnm2png$(O)
-	$(LD) $(LDFLAGS) -o pnm2png-static$(E) pnm2png$(O) $(LDLIBSS) -lm
+	$(LD) -o pnm2png-static$(E) pnm2png$(O) $(LDFLAGSS) -lm
 
 clean:
 	$(RM) png2pnm$(O)

contrib/pngminus/png2pnm.c

@@ -18,7 +18,6 @@
 #include <mem.h>
 #include <fcntl.h>
 #endif
-#include <zlib.h>
 
 #ifndef BOOL
 #define BOOL unsigned char
@@ -145,7 +144,7 @@ int main(int argc, char *argv[])
   if (png2pnm (fp_rd, fp_wr, fp_al, raw, alpha) == FALSE)
   {
     fprintf (stderr, "PNG2PNM\n");
-    fprintf (stderr, "Error:  unsuccessful conversion of PNG-image\n");
+    fprintf (stderr, "Error:  unsuccessful convertion of PNG-image\n");
     exit(1);
   }
 
@@ -189,7 +188,7 @@ void usage()
 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;
+  png_info	*info_ptr = NULL;
   png_byte      buf[8];
   png_byte      *png_pixels = NULL;
   png_byte      **row_pointers = NULL;
@@ -212,8 +211,8 @@ BOOL png2pnm (FILE *png_file, FILE *pnm_file, FILE *alpha_file, BOOL raw, BOOL a
   if (ret != 8)
     return FALSE;
 
-  ret = png_sig_cmp (buf, 0, 8);
-  if (ret)
+  ret = !png_sig_cmp (buf, 0, 8);
+  if (!ret)
     return FALSE;
 
   /* create png and info structures */
@@ -382,7 +381,7 @@ BOOL png2pnm (FILE *png_file, FILE *pnm_file, FILE *alpha_file, BOOL raw, BOOL a
           fputc ((int) *pix_ptr++ , pnm_file);
         else
           if (bit_depth == 16){
-            dep_16 = (long) *pix_ptr++;
+	    dep_16 = (long) *pix_ptr++;
             fprintf (pnm_file, "%ld ", (dep_16 << 8) + ((long) *pix_ptr++));
           }
           else
@@ -402,9 +401,9 @@ BOOL png2pnm (FILE *png_file, FILE *pnm_file, FILE *alpha_file, BOOL raw, BOOL a
             fputc ((int) *pix_ptr++ , alpha_file);
           else
             if (bit_depth == 16){
-              dep_16 = (long) *pix_ptr++;
+	      dep_16 = (long) *pix_ptr++;
               fprintf (alpha_file, "%ld ", (dep_16 << 8) + (long) *pix_ptr++);
-            }
+	    }  
             else
               fprintf (alpha_file, "%ld ", (long) *pix_ptr++);
         }

contrib/pngminus/pnm2png.c

@@ -18,7 +18,6 @@
 #include <mem.h>
 #include <fcntl.h>
 #endif
-#include <zlib.h>
 
 #ifndef BOOL
 #define BOOL unsigned char
@@ -198,9 +197,6 @@ BOOL pnm2png (FILE *pnm_file, FILE *png_file, FILE *alpha_file, BOOL interlace,
   char          height_token[16];
   char          maxval_token[16];
   int           color_type;
-  unsigned long   ul_width, ul_alpha_width;
-  unsigned long   ul_height, ul_alpha_height;
-  unsigned long   ul_maxval;
   png_uint_32   width, alpha_width;
   png_uint_32   height, alpha_height;
   png_uint_32   maxval;
@@ -231,15 +227,11 @@ BOOL pnm2png (FILE *pnm_file, FILE *png_file, FILE *alpha_file, BOOL interlace,
     raw = (type_token[1] == '5');
     color_type = PNG_COLOR_TYPE_GRAY;
     get_token(pnm_file, width_token);
-    sscanf (width_token, "%lu", &ul_width);
-    width = (png_uint_32) ul_width;
+    sscanf (width_token, "%lu", &width);
     get_token(pnm_file, height_token);
-    sscanf (height_token, "%lu", &ul_height);
-    height = (png_uint_32) ul_height;
+    sscanf (height_token, "%lu", &height);
     get_token(pnm_file, maxval_token);
-    sscanf (maxval_token, "%lu", &ul_maxval);
-    maxval = (png_uint_32) ul_maxval;
-
+    sscanf (maxval_token, "%lu", &maxval);
     if (maxval <= 1)
       bit_depth = 1;
     else if (maxval <= 3)
@@ -256,14 +248,11 @@ BOOL pnm2png (FILE *pnm_file, FILE *png_file, FILE *alpha_file, BOOL interlace,
     raw = (type_token[1] == '6');
     color_type = PNG_COLOR_TYPE_RGB;
     get_token(pnm_file, width_token);
-    sscanf (width_token, "%lu", &ul_width);
-    width = (png_uint_32) ul_width;
+    sscanf (width_token, "%lu", &width);
     get_token(pnm_file, height_token);
-    sscanf (height_token, "%lu", &ul_height);
-    height = (png_uint_32) ul_height;
+    sscanf (height_token, "%lu", &height);
     get_token(pnm_file, maxval_token);
-    sscanf (maxval_token, "%lu", &ul_maxval);
-    maxval = (png_uint_32) ul_maxval;
+    sscanf (maxval_token, "%lu", &maxval);
     if (maxval <= 1)
       bit_depth = 1;
     else if (maxval <= 3)
@@ -298,18 +287,15 @@ BOOL pnm2png (FILE *pnm_file, FILE *png_file, FILE *alpha_file, BOOL interlace,
     {
       alpha_raw = (type_token[1] == '5');
       get_token(alpha_file, width_token);
-      sscanf (width_token, "%lu", &ul_alpha_width);
-      alpha_width=(png_uint_32) ul_alpha_width;
+      sscanf (width_token, "%lu", &alpha_width);
       if (alpha_width != width)
         return FALSE;
       get_token(alpha_file, height_token);
-      sscanf (height_token, "%lu", &ul_alpha_height);
-      alpha_height = (png_uint_32) ul_alpha_height;
+      sscanf (height_token, "%lu", &alpha_height);
       if (alpha_height != height)
         return FALSE;
       get_token(alpha_file, maxval_token);
-      sscanf (maxval_token, "%lu", &ul_maxval);
-      maxval = (png_uint_32) ul_maxval;
+      sscanf (maxval_token, "%lu", &maxval);
       if (maxval <= 1)
         alpha_depth = 1;
       else if (maxval <= 3)
@@ -524,7 +510,6 @@ png_uint_32 get_value (FILE *pnm_file, int depth)
 {
   static png_uint_32 mask = 0;
   png_byte token[16];
-  unsigned long ul_ret_value;
   png_uint_32 ret_value;
   int i = 0;
 
@@ -533,8 +518,7 @@ png_uint_32 get_value (FILE *pnm_file, int depth)
       mask = (mask << 1) | 0x01;
 
   get_token (pnm_file, (char *) token);
-  sscanf ((const char *) token, "%lu", &ul_ret_value);
-  ret_value = (png_uint_32) ul_ret_value;
+  sscanf ((const char *) token, "%lu", &ret_value);
 
   ret_value &= mask;
 

contrib/pngsuite/README

@@ -1,61 +1,41 @@
 
 pngsuite
 --------
-(c) Willem van Schaik, 1999, 2011, 2012
-Two images are by Glenn Randers-Pehrson, 2012
+(c) Willem van Schaik, 1999
 
-Permission to use, copy, modify, and distribute these images for any
-purpose and without fee is hereby granted.
+Permission to use, copy, and distribute these images for any purpose and
+without fee is hereby granted.
 
-The 15 "bas*.png" images are part of the much larger PngSuite test-set of
-images, available for developers of PNG supporting software. The
-complete set, available at http:/www.schaik.com/pngsuite/, contains
+These 15 images are part of the much larger PngSuite test-set of 
+images, available for developers of PNG supporting software. The 
+complete set, available at http:/www.schaik.com/pngsuite/, contains 
 a variety of images to test interlacing, gamma settings, ancillary
 chunks, etc.
 
-The "ft*.png" images are "free/libre" replacements for the transparent
-corresponding t*.png images in the PngSuite.
-
 The images in this directory represent the basic PNG color-types:
 grayscale (1-16 bit deep), full color (8 or 16 bit), paletted
 (1-8 bit) and grayscale or color images with alpha channel. You
 can use them to test the proper functioning of PNG software.
 
-    filename       depth type
+    filename      depth type
     ------------ ------ --------------
-    basn0g01.png   1-bit grayscale
-    basn0g02.png   2-bit grayscale
-    basn0g04.png   4-bit grayscale
-    basn0g08.png   8-bit grayscale
-    basn0g16.png  16-bit grayscale
-    basn2c08.png   8-bit truecolor
-    basn2c16.png  16-bit truecolor
-    basn3p01.png   1-bit paletted
-    basn3p02.png   2-bit paletted
-    basn3p04.png   4-bit paletted
-    basn3p08.png   8-bit paletted
-    basn4a08.png   8-bit gray with alpha
-    basn4a16.png  16-bit gray with alpha
-    basn6a08.png   8-bit RGBA
-    basn6a16.png  16-bit RGBA
+    basn0g01.png  1-bit grayscale
+    basn0g02.png  2-bit grayscale
+    basn0g04.png  4-bit grayscale
+    basn0g08.png  8-bit grayscale
+    basn0g16.png 16-bit grayscale
+    basn2c08.png  8-bit truecolor
+    basn2c16.png 16-bit truecolor
+    basn3p01.png  1-bit paletted
+    basn3p02.png  2-bit paletted
+    basn3p04.png  4-bit paletted
+    basn3p08.png  8-bit paletted
+    basn4a08.png  8-bit gray with alpha
+    basn4a16.png 16-bit gray with alpha
+    basn6a08.png  8-bit RGBA
+    basn6a16.png 16-bit RGBA
 
-    ftbbn0g01.png  1-bit grayscale, black bKGD
-    ftbbn0g02.png  2-bit grayscale, black bKGD
-    ftbbn0g04.png  4-bit grayscale, black bKGD
-    ftbbn2c16.png 16-bit truecolor, black bKGD
-    ftbbn3p08.png  8-bit paletted, black bKGD
-    ftbgn2c16.png 16-bit truecolor, gray bKGD
-    ftbgn3p08.png  8-bit paletted, gray bKGD
-    ftbrn2c08.png  8-bit truecolor, red bKGD
-    ftbwn0g16.png 16-bit gray, white bKGD
-    ftbwn3p08.png  8-bit paletted, white bKGD
-    ftbyn3p08.png  8-bit paletted, yellow bKGD
-    ftp0n0g08.png  8-bit grayscale, opaque
-    ftp0n2c08.png  8-bit truecolor, opaque
-    ftp0n3p08.png  8-bit paletted, opaque
-    ftp1n3p08.png  8-bit paletted, no bKGD
-
-Here is the correct result of typing "pngtest -m bas*.png" in
+Here is the correct result of typing "pngtest -m *.png" in
 this directory:
 
 Testing basn0g01.png: PASS (524 zero samples)

contrib/tools/README.txt

@@ -1,26 +0,0 @@
-This directory (contrib/tools) contains tools used by the authors of libpng.
-
-Code and data placed in this directory is not required to build libpng,
-however the code in this directory has been used to generate data or code in
-the body of the libpng source.  The source code identifies where this has
-been done.  Code in this directory may not compile on all operating systems
-that libpng supports.
-
-NO COPYRIGHT RIGHTS ARE CLAIMED TO ANY OF THE FILES IN THIS DIRECTORY.
-
-To the extent possible under law, the authors have waived all copyright and
-related or neighboring rights to this work.  This work is published from:
-United States.
-
-The files may be used freely in any way.
-
-The source code and comments in this directory are the original work of the
-people named below.  No other person or organization has made contributions to
-the work in this directory.
-
-ORIGINAL AUTHORS
-    The following people have contributed to the code in this directory.  None
-    of the people below claim any rights with regard to the contents of this
-    directory.
-
-    John Bowler <jbowler@acm.org>

contrib/tools/checksum-icc.c

@@ -1,102 +0,0 @@
-/* checksum-icc.c
- *
- * Copyright (c) 2013 John Cunningham Bowler
- *
- * Last changed in libpng 1.6.0 [February 14, 2013]
- *
- * This code is released under the libpng license.
- * For conditions of distribution and use, see the disclaimer
- * and license in png.h
- *
- * Generate crc32 and adler32 checksums of the given input files, used to
- * generate check-codes for use when matching ICC profiles within libpng.
- */
-#include <stdio.h>
-
-#include <zlib.h>
-
-static int
-read_one_file(FILE *ip, const char *name)
-{
-   uLong length = 0;
-   uLong a32 = adler32(0, NULL, 0);
-   uLong c32 = crc32(0, NULL, 0);
-   Byte header[132];
-
-   for (;;)
-   {
-      int ch = getc(ip);
-      Byte b;
-
-      if (ch == EOF) break;
-
-      b = (Byte)ch;
-
-      if (length < sizeof header)
-         header[length] = b;
-
-      ++length;
-      a32 = adler32(a32, &b, 1);
-      c32 = crc32(c32, &b, 1);
-   }
-
-   if (ferror(ip))
-      return 0;
-
-   /* Success */
-   printf("PNG_ICC_CHECKSUM(0x%8.8lx, 0x%8.8lx,\n   PNG_MD5("
-      "0x%2.2x%2.2x%2.2x%2.2x, 0x%2.2x%2.2x%2.2x%2.2x, 0x%2.2x%2.2x%2.2x%2.2x,"
-      " 0x%2.2x%2.2x%2.2x%2.2x), %d,\n"
-      "   \"%4.4d/%2.2d/%2.2d %2.2d:%2.2d:%2.2d\", %lu, \"%s\")\n",
-      (unsigned long)a32, (unsigned long)c32,
-      header[84], header[85], header[86], header[87],
-      header[88], header[89], header[90], header[91],
-      header[92], header[93], header[94], header[95],
-      header[96], header[97], header[98], header[99],
-#     define u16(x) (header[x] * 256 + header[x+1])
-#     define u32(x) (u16(x) * 65536 + u16(x+2))
-      u32(64), u16(24), u16(26), u16(28), u16(30), u16(32), u16(34),
-      (unsigned long)length, name);
-
-   return 1;
-}
-
-int main(int argc, char **argv)
-{
-   int err = 0;
-
-   printf("/* adler32, crc32, MD5[16], intent, date, length, file-name */\n");
-
-   if (argc > 1)
-   {
-      int i;
-
-      for (i=1; i<argc; ++i)
-      {
-         FILE *ip = fopen(argv[i], "rb");
-
-         if (ip == NULL || !read_one_file(ip, argv[i]))
-         {
-            err = 1;
-            perror(argv[i]);
-            fprintf(stderr, "%s: read error\n", argv[i]);
-            printf("/* ERROR: %s */\n", argv[i]);
-         }
-
-         (void)fclose(ip);
-      }
-   }
-
-   else
-   {
-      if (!read_one_file(stdin, "-"))
-      {
-         err = 1;
-         perror("stdin");
-         fprintf(stderr, "stdin: read error\n");
-         printf("/* ERROR: stdin */\n");
-      }
-   }
-
-   return err;
-}

contrib/tools/chkfmt

@@ -1,137 +0,0 @@
-#!/bin/sh
-#
-# Check the format of the source files in the current directory - checks for a
-# line length of 80 characters max and no tab characters.
-#
-# Optionally arguments are files or directories to check.
-#
-# -v: output the long lines (makes fixing them easier)
-# -e: spawn an editor for each file that needs a change ($EDITOR must be
-#     defined).  When using -e the script MUST be run from an interactive
-#     command line.
-verbose=
-edit=
-vers=
-test "$1" = "-v" && {
-   shift
-   verbose=yes
-}
-test "$1" = "-e" && {
-   shift
-   if test -n "$EDITOR"
-   then
-      edit=yes
-
-      # Copy the standard streams for the editor
-      exec 3>&0 4>&1 5>&2
-   else
-      echo "chkfmt -e: EDITOR must be defined" >&2
-      exit 1
-   fi
-}
-
-# Function to edit a single file - if the file isn't changed ask the user
-# whether or not to continue.  This stuff only works if the script is run from
-# the command line (otherwise, don't specify -e or you will be sorry).
-doed(){
-   cp "$file" "$file".orig
-   "$EDITOR" "$file" 0>&3 1>&4 2>&5 3>&- 4>&- 5>&- || exit 1
-   if cmp -s "$file".orig "$file"
-   then
-      rm "$file".orig
-      echo -n "$file: file not changed, type anything to continue: " >&5
-      read ans 0>&3
-      test -n "$ans" || return 1
-   fi
-   return 0
-}
-
-# In beta versions the version string which appears in files can be a little
-# long and cause spuriously overlong lines.  To avoid this subtitute the version
-# string with a 'standard' version a.b.cc before checking for long lines.
-if test -r png.h
-then
-   vers="`sed -n -e \
-   's/^#define PNG_LIBPNG_VER_STRING .\([0-9]\.[0-9]\.[0-9][0-9a-z]*\).$/\1/p' \
-   png.h`"
-   echo "chkfmt: checking version $vers"
-fi
-if test -z "$vers"
-then
-   echo "chkfmt: png.h not found, ignoring version number" >&2
-fi
-
-test -n "$1" || set -- .
-find "$@" \( -type d \( -name '.git' -o -name '.libs' -o -name 'projects' \) \
-   -prune \) -o \( -type f \
-   ! -name '*.[oa]' ! -name '*.l[oa]' !  -name '*.png' ! -name '*.out' \
-   ! -name '*.jpg' ! -name '*.patch' ! -name '*.obj' ! -name '*.exe' \
-   ! -name '*.com' ! -name '*.tar.*' ! -name '*.zip' ! -name '*.ico' \
-   ! -name '*.res' ! -name '*.rc' ! -name '*.mms' ! -name '*.rej' \
-   ! -name '*.dsp' ! -name '*.orig' ! -name '*.dfn' ! -name '*.swp' \
-   ! -name '~*' ! -name '*.3' \
-   ! -name 'missing' ! -name 'mkinstalldirs' ! -name 'depcomp' \
-   ! -name 'aclocal.m4' ! -name 'install-sh' ! -name 'Makefile.in' \
-   ! -name 'ltmain.sh' ! -name 'config*' -print \) | {
-   st=0
-   while read file
-   do
-      case "$file" in
-      *.mak|*[Mm]akefile.*|*[Mm]akefile)
-         # Makefiles require tabs, dependency lines can be this long.
-         check_tabs=
-         line_length=100;;
-      *.awk)
-         # Includes literal tabs
-         check_tabs=
-         # The following is arbitrary
-         line_length=132;;
-      *contrib/*/*.[ch])
-         check_tabs=yes
-         line_length=96;;
-      *)
-         check_tabs=yes
-         line_length=80;;
-      esac
-
-      # Note that vers can only contain 0-9, . and a-z
-      if test -n "$vers"
-      then
-         sed -e "s/$vers/a.b.cc/g" "$file" >"$file".$$
-      else
-         cp "$file" "$file".$$
-      fi
-      splt="`fold -$line_length "$file".$$ | diff -c "$file".$$ -`"
-      rm "$file".$$
-
-      if test -n "$splt"
-      then
-         echo "$file: lines too long"
-         st=1
-         if test -n "$EDITOR" -a -n "$edit"
-         then
-            doed "$file" || exit 1
-         elif test -n "$verbose"
-         then
-            echo "$splt"
-         fi
-      fi
-      if test -n "$check_tabs"
-      then
-         tab="`tr -c -d '\t' <"$file"`"
-         if test -n "$tab"
-         then
-            echo "$file: file contains tab characters"
-            st=1
-            if test -n "$EDITOR" -a -n "$edit"
-            then
-               doed "$file" || exit 1
-            elif test -n "$verbose"
-            then
-               echo "$splt"
-            fi
-         fi
-      fi
-   done
-   exit $st
-}

contrib/tools/cvtcolor.c

@@ -1,188 +0,0 @@
-/*-
- * convert.c
- *
- * Last changed in libpng 1.6.0 [February 14, 2013]
- *
- * COPYRIGHT: Written by John Cunningham Bowler, 2013.
- * 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.
- *
- * Convert 8-bit sRGB or 16-bit linear values to another format.
- */
-#define _ISOC99_SOURCE 1
-
-#include <stdlib.h>
-#include <string.h>
-#include <math.h>
-#include <stdio.h>
-
-#include <fenv.h>
-
-#include "sRGB.h"
-
-static void
-usage(const char *prog)
-{
-   fprintf(stderr,
-      "%s: usage: %s [-linear|-sRGB] [-gray|-color] component{1,4}\n",
-      prog, prog);
-   exit(1);
-}
-
-unsigned long
-component(const char *prog, const char *arg, int issRGB)
-{
-   char *ep;
-   unsigned long c = strtoul(arg, &ep, 0);
-
-   if (ep <= arg || *ep || c > 65535 || (issRGB && c > 255))
-   {
-      fprintf(stderr, "%s: %s: invalid component value (%lu)\n", prog, arg, c);
-      usage(prog);
-   }
-
-   return c;
-}
-
-int
-main(int argc, const char **argv)
-{
-   const char *prog = *argv++;
-   int to_linear = 0, to_gray = 0, to_color = 0;
-   int channels = 0;
-   double c[4];
-
-   /* FE_TONEAREST is the IEEE754 round to nearest, preferring even, mode; i.e.
-    * everything rounds to the nearest value except that '.5' rounds to the
-    * nearest even value.
-    */
-   fesetround(FE_TONEAREST);
-
-   c[3] = c[2] = c[1] = c[0] = 0;
-
-   while (--argc > 0 && **argv == '-')
-   {
-      const char *arg = 1+*argv++;
-
-      if (strcmp(arg, "sRGB") == 0)
-         to_linear = 0;
-
-      else if (strcmp(arg, "linear") == 0)
-         to_linear = 1;
-
-      else if (strcmp(arg, "gray") == 0)
-         to_gray = 1, to_color = 0;
-
-      else if (strcmp(arg, "color") == 0)
-         to_gray = 0, to_color = 1;
-
-      else
-         usage(prog);
-   }
-
-   switch (argc)
-   {
-      default:
-         usage(prog);
-         break;
-
-      case 4:
-         c[3] = component(prog, argv[3], to_linear);
-         ++channels;
-      case 3:
-         c[2] = component(prog, argv[2], to_linear);
-         ++channels;
-      case 2:
-         c[1] = component(prog, argv[1], to_linear);
-         ++channels;
-      case 1:
-         c[0] = component(prog, argv[0], to_linear);
-         ++channels;
-         break;
-      }
-
-   if (to_linear)
-   {
-      int i;
-      int components = channels;
-
-      if ((components & 1) == 0)
-         --components;
-
-      for (i=0; i<components; ++i) c[i] = linear_from_sRGB(c[i] / 255);
-      if (components < channels)
-         c[components] = c[components] / 255;
-   }
-
-   else
-   {
-      int i;
-      for (i=0; i<4; ++i) c[i] /= 65535;
-
-      if ((channels & 1) == 0)
-      {
-         double alpha = c[channels-1];
-
-         if (alpha > 0)
-            for (i=0; i<channels-1; ++i) c[i] /= alpha;
-         else
-            for (i=0; i<channels-1; ++i) c[i] = 1;
-      }
-   }
-
-   if (to_gray)
-   {
-      if (channels < 3)
-      {
-         fprintf(stderr, "%s: too few channels (%d) for -gray\n",
-            prog, channels);
-         usage(prog);
-      }
-
-      c[0] = YfromRGB(c[0], c[1], c[2]);
-      channels -= 2;
-   }
-
-   if (to_color)
-   {
-      if (channels > 2)
-      {
-         fprintf(stderr, "%s: too many channels (%d) for -color\n",
-            prog, channels);
-         usage(prog);
-      }
-
-      c[3] = c[1]; /* alpha, if present */
-      c[2] = c[1] = c[0];
-   }
-
-   if (to_linear)
-   {
-      int i;
-      if ((channels & 1) == 0)
-      {
-         double alpha = c[channels-1];
-         for (i=0; i<channels-1; ++i) c[i] *= alpha;
-      }
-
-      for (i=0; i<channels; ++i) c[i] = nearbyint(c[i] * 65535);
-   }
-
-   else /* to sRGB */
-   {
-      int i = (channels+1)&~1;
-      while (--i >= 0)
-         c[i] = sRGB_from_linear(c[i]);
-
-      for (i=0; i<channels; ++i) c[i] = nearbyint(c[i] * 255);
-   }
-
-   {
-      int i;
-      for (i=0; i<channels; ++i) printf(" %g", c[i]);
-   }
-   printf("\n");
-
-   return 0;
-}

contrib/tools/fixitxt.c

@@ -1,144 +0,0 @@
-#include <stdio.h>
-
-/* fixitxt version 1.0.0
- *
- * Copyright 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
- *
- * Usage:            
- *
- *     fixitxt.exe < bad.png > good.png
- *
- * Fixes a PNG file written with libpng-1.6.0 or 1.6.1 that has one or more
- * uncompressed iTXt chunks.  Assumes that the actual length is greater
- * than or equal to the value in the length byte, and that the CRC is
- * correct for the actual length.  This program hunts for the CRC and
- * adjusts the length byte accordingly.  It is not an error to process a
- * PNG file that has no iTXt chunks or one that has valid iTXt chunks;
- * such files will simply be copied.
- *
- * Requires zlib (for crc32 and Z_NULL); build with
- *
- *     gcc -O -o fixitxt fixitxt.c -lz
- */
-
-#define MAX_LENGTH 500000
-
-#define GETBREAK c=getchar(); if (c == EOF) break;
-#include <zlib.h>
-
-main()
-{
-   unsigned int i;
-   unsigned char buf[MAX_LENGTH];
-   unsigned long crc;
-   unsigned int c;
-
-/* Skip 8-byte signature */
-   for (i=8; i; i--)
-   {
-      c=GETBREAK;
-      putchar(c);
-   }
-
-if (c != EOF)
-for (;;)
- {
-   /* Read the length */
-   unsigned long length;
-   c=GETBREAK; buf[0] = c;
-   c=GETBREAK; buf[1] = c;
-   c=GETBREAK; buf[2] = c;
-   c=GETBREAK; buf[3] = c;
-
-   length=((((unsigned long) buf[0]<<8 + buf[1]<<16) + buf[2] << 8) + buf[3]);
-   /* Read the chunkname */
-   c=GETBREAK; buf[4] = c;
-   c=GETBREAK; buf[5] = c;
-   c=GETBREAK; buf[6] = c;
-   c=GETBREAK; buf[7] = c;
-
-
-   /* The iTXt chunk type expressed as integers is (105, 84, 88, 116) */
-   if (buf[4] == 105 && buf[5] == 84 && buf[6] == 88 && buf[7] == 116)
-   {
-      if (length >= MAX_LENGTH-12)
-         break;  /* To do: handle this more gracefully */
-
-      /* Initialize the CRC */
-      crc = crc32(0, Z_NULL, 0);
-
-      /* Copy the data bytes */
-      for (i=8; i < length + 12; i++)
-      {
-         c=GETBREAK; buf[i] = c;
-      }
-
-      /* Calculate the CRC */
-      crc = crc32(crc, buf+4, (uInt)length+4);
-
-      for (;;)
-      {
-        /* Check the CRC */
-        if (((crc >> 24) & 0xff) == buf[length+8] &&
-            ((crc >> 16) & 0xff) == buf[length+9] &&
-            ((crc >>  8) & 0xff) == buf[length+10] &&
-            ((crc      ) & 0xff) == buf[length+11])
-           break;
-
-        length++;
-
-        if (length >= MAX_LENGTH-12)
-           break;
-
-        c=GETBREAK;
-        buf[length+11]=c;
-
-        /* Update the CRC */
-        crc = crc32(crc, buf+7+length, 1);
-      }
-
-      /* Update length bytes */
-        buf[0] = (length << 24) & 0xff;
-        buf[1] = (length << 16) & 0xff;
-        buf[2] = (length <<  8) & 0xff;
-        buf[3] = (length      ) & 0xff;
-
-      /* Write the fixed iTXt chunk (length, name, data, crc) */
-      for (i=0; i<length+12; i++)
-         putchar(buf[i]);
-   }
-
-   else
-   {
-      /* Copy bytes that were already read (length and chunk name) */
-      for (i=0; i<8; i++)
-         putchar(buf[i]);
-
-      /* Copy data bytes and CRC */
-      for (i=8; i< length+12; i++)
-      {
-         c=GETBREAK;
-         putchar(c);
-      }
-
-      if (c == EOF)
-      {
-         break;
-      }
-
-   /* The IEND chunk type expressed as integers is (73, 69, 78, 68) */
-      if (buf[4] == 73 && buf[5] == 69 && buf[6] == 78 && buf[7] == 68)
-         break;
-   }
-
-   if (c == EOF)
-      break;
-
-   if (buf[4] == 73 && buf[5] == 69 && buf[6] == 78 && buf[7] == 68)
-     break;
- }
-}

contrib/tools/intgamma.sh

@@ -1,110 +0,0 @@
-#!/bin/sh
-#
-# intgamma.sh
-#
-# Last changed in libpng 1.6.0 [February 14, 2013]
-#
-# COPYRIGHT: Written by John Cunningham Bowler, 2013.
-# 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.
-#
-# Shell script to generate png.c 8-bit and 16-bit log tables (see the code in
-# png.c for details).
-#
-# This script uses the "bc" arbitrary precision calculator to calculate 32-bit
-# fixed point values of logarithms appropriate to finding the log of an 8-bit
-# (0..255) value and a similar table for the exponent calculation.
-#
-# "bc" must be on the path when the script is executed, and the math library
-# (-lm) must be available
-#
-# function to print out a list of numbers as integers; the function truncates
-# the integers which must be one-per-line
-function print(){
-   awk 'BEGIN{
-      str = ""
-   }
-   {
-      sub("\\.[0-9]*$", "")
-      if ($0 == "")
-         $0 = "0"
-
-      if (str == "")
-         t = "   " $0 "U"
-      else
-         t = str ", " $0 "U"
-
-      if (length(t) >= 80) {
-         print str ","
-         str = "   " $0 "U"
-      } else
-         str = t
-   }
-   END{
-      print str
-   }'
-}
-#
-# The logarithm table.
-cat <<END
-/* 8-bit log table: png_8bit_l2[128]
- * This is a table of -log(value/255)/log(2) for 'value' in the range 128 to
- * 255, so it's the base 2 logarithm of a normalized 8-bit floating point
- * mantissa.  The numbers are 32-bit fractions.
- */
-static const png_uint_32
-png_8bit_l2[128] =
-{
-END
-#
-bc -lqws <<END | print
-f=65536*65536/l(2)
-for (i=128;i<256;++i) { .5 - l(i/255)*f; }
-END
-echo '};'
-echo
-#
-# The exponent table.
-cat <<END
-/* The 'exp()' case must invert the above, taking a 20-bit fixed point
- * logarithmic value and returning a 16 or 8-bit number as appropriate.  In
- * each case only the low 16 bits are relevant - the fraction - since the
- * integer bits (the top 4) simply determine a shift.
- *
- * The worst case is the 16-bit distinction between 65535 and 65534; this
- * requires perhaps spurious accuracy in the decoding of the logarithm to
- * distinguish log2(65535/65534.5) - 10^-5 or 17 bits.  There is little chance
- * of getting this accuracy in practice.
- *
- * To deal with this the following exp() function works out the exponent of the
- * frational part of the logarithm by using an accurate 32-bit value from the
- * top four fractional bits then multiplying in the remaining bits.
- */
-static const png_uint_32
-png_32bit_exp[16] =
-{
-END
-#
-bc -lqws <<END | print
-f=l(2)/16
-for (i=0;i<16;++i) {
-   x = .5 + e(-i*f)*2^32;
-   if (x >= 2^32) x = 2^32-1;
-   x;
-}
-END
-echo '};'
-echo
-#
-# And the table of adjustment values.
-cat <<END
-/* Adjustment table; provided to explain the numbers in the code below. */
-#if 0
-END
-bc -lqws <<END | awk '{ printf "%5d %s\n", 12-NR, $0 }'
-for (i=11;i>=0;--i){
-   (1 - e(-(2^i)/65536*l(2))) * 2^(32-i)
-}
-END
-echo '#endif'

contrib/tools/makesRGB.c

@@ -1,430 +0,0 @@
-/* makesRGB.c -- build sRGB-to-linear and linear-to-sRGB conversion tables
- *
- * Last changed in libpng 1.6.0 [February 14, 2013]
- *
- * COPYRIGHT: Written by John Cunningham Bowler, 2013.
- * 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.
- *
- * Make a table to convert 8-bit sRGB encoding values into the closest 16-bit
- * linear value.
- *
- * Make two tables to take a linear value scaled to 255*65535 and return an
- * approximation to the 8-bit sRGB encoded value.  Calculate the error in these
- * tables and display it.
- */
-#define _C99_SOURCE 1
-#include <stdio.h>
-#include <math.h>
-#include <stdlib.h>
-
-/* pngpriv.h includes the definition of 'PNG_sRGB_FROM_LINEAR' which is required
- * to verify the actual code.
- */
-#include "../../pngpriv.h"
-
-#include "sRGB.h"
-
-/* The tables are declared 'const' in pngpriv.h, so this redefines the tables to
- * be used.
- */
-#define png_sRGB_table sRGB_table
-#define png_sRGB_base sRGB_base
-#define png_sRGB_delta sRGB_delta
-
-static png_uint_16 png_sRGB_table[256];
-static png_uint_16 png_sRGB_base[512];
-static png_byte png_sRGB_delta[512];
-
-static const unsigned int max_input = 255*65535;
-
-double
-fsRGB(double l)
-{
-   return sRGB_from_linear(l/max_input);
-}
-
-double
-sRGB(unsigned int i)
-{
-   return fsRGB(i);
-}
-
-double
-finvsRGB(unsigned int i)
-{
-   return 65535 * linear_from_sRGB(i/255.);
-}
-
-png_uint_16
-invsRGB(unsigned int i)
-{
-   unsigned int x = nearbyint(finvsRGB(i));
-
-   if (x > 65535)
-   {
-      fprintf(stderr, "invsRGB(%u) overflows to %u\n", i, x);
-      exit(1);
-   }
-
-   return (png_uint_16)x;
-}
-
-int
-main(int argc, char **argv)
-{
-   unsigned int i, i16, ibase;
-   double min_error = 0;
-   double max_error = 0;
-   double min_error16 = 0;
-   double max_error16 = 0;
-   double adjust;
-   double adjust_lo = 0.4, adjust_hi = 0.6, adjust_mid = 0.5;
-   unsigned int ec_lo = 0, ec_hi = 0, ec_mid = 0;
-   unsigned int error_count = 0;
-   unsigned int error_count16 = 0;
-   int test_only = 0;
-
-   if (argc > 1)
-      test_only = strcmp("--test", argv[1]) == 0;
-
-   /* Initialize the encoding table first. */
-   for (i=0; i<256; ++i)
-   {
-      png_sRGB_table[i] = invsRGB(i);
-   }
-
-   /* Now work out the decoding tables (this is where the error comes in because
-    * there are 512 set points and 512 straight lines between them.)
-    */
-   for (;;)
-   {
-      if (ec_lo == 0)
-         adjust = adjust_lo;
-
-      else if (ec_hi == 0)
-         adjust = adjust_hi;
-
-      else if (ec_mid == 0)
-         adjust = adjust_mid;
-
-      else if (ec_mid < ec_hi)
-         adjust = (adjust_mid + adjust_hi)/2;
-
-      else if (ec_mid < ec_lo)
-         adjust = (adjust_mid + adjust_lo)/2;
-
-      else
-      {
-         fprintf(stderr, "not reached: %u .. %u .. %u\n", ec_lo, ec_mid, ec_hi);
-         exit(1);
-      }
-
-      /* Calculate the table using the current 'adjust' */
-      for (i=0; i<=511; ++i)
-      {
-         double lo = 255 * sRGB(i << 15);
-         double hi = 255 * sRGB((i+1) << 15);
-         unsigned int calc;
-
-         calc = nearbyint((lo+adjust) * 256);
-         if (calc > 65535)
-         {
-            fprintf(stderr, "table[%d][0]: overflow %08x (%d)\n", i, calc,
-               calc);
-            exit(1);
-         }
-         png_sRGB_base[i] = calc;
-
-         calc = nearbyint((hi-lo) * 32);
-         if (calc > 255)
-         {
-            fprintf(stderr, "table[%d][1]: overflow %08x (%d)\n", i, calc,
-               calc);
-            exit(1);
-         }
-         png_sRGB_delta[i] = calc;
-      }
-
-      /* Check the 16-bit linear values alone: */
-      error_count16 = 0;
-      for (i16=0; i16 <= 65535; ++i16)
-      {
-         unsigned int i = 255*i16;
-         unsigned int iexact = nearbyint(255*sRGB(i));
-         unsigned int icalc = PNG_sRGB_FROM_LINEAR(i);
-
-         if (icalc != iexact)
-            ++error_count16;
-      }
-
-      /* Now try changing the adjustment. */
-      if (ec_lo == 0)
-         ec_lo = error_count16;
-
-      else if (ec_hi == 0)
-         ec_hi = error_count16;
-
-      else if (ec_mid == 0)
-      {
-         ec_mid = error_count16;
-         printf("/* initial error counts: %u .. %u .. %u */\n", ec_lo, ec_mid,
-            ec_hi);
-      }
-
-      else if (error_count16 < ec_mid)
-      {
-         printf("/* adjust (mid ): %f: %u -> %u */\n", adjust, ec_mid,
-            error_count16);
-         ec_mid = error_count16;
-         adjust_mid = adjust;
-      }
-
-      else if (adjust < adjust_mid && error_count16 < ec_lo)
-      {
-         printf("/* adjust (low ): %f: %u -> %u */\n", adjust, ec_lo,
-            error_count16);
-         ec_lo = error_count16;
-         adjust_lo = adjust;
-      }
-
-      else if (adjust > adjust_mid && error_count16 < ec_hi)
-      {
-         printf("/* adjust (high): %f: %u -> %u */\n", adjust, ec_hi,
-            error_count16);
-         ec_hi = error_count16;
-         adjust_hi = adjust;
-      }
-
-      else
-      {
-         adjust = adjust_mid;
-         printf("/* adjust: %f: %u */\n", adjust, ec_mid);
-         break;
-      }
-   }
-
-   /* For each entry in the table try to adjust it to minimize the error count
-    * in that entry.  Each entry corresponds to 128 input values.
-    */
-   for (ibase=0; ibase<65536; ibase+=128)
-   {
-      png_uint_16 base = png_sRGB_base[ibase >> 7], trybase = base, ob=base;
-      png_byte delta = png_sRGB_delta[ibase >> 7], trydelta = delta, od=delta;
-      unsigned int ecbase = 0, eco;
-
-      for (;;)
-      {
-         png_sRGB_base[ibase >> 7] = trybase;
-         png_sRGB_delta[ibase >> 7] = trydelta;
-
-         /* Check the 16-bit linear values alone: */
-         error_count16 = 0;
-         for (i16=ibase; i16 < ibase+128; ++i16)
-         {
-            unsigned int i = 255*i16;
-            unsigned int iexact = nearbyint(255*sRGB(i));
-            unsigned int icalc = PNG_sRGB_FROM_LINEAR(i);
-
-            if (icalc != iexact)
-               ++error_count16;
-         }
-
-         if (error_count16 == 0)
-            break;
-
-         if (ecbase == 0)
-         {
-            eco = ecbase = error_count16;
-            ++trybase; /* First test */
-         }
-
-         else if (error_count16 < ecbase)
-         {
-            if (trybase > base)
-            {
-               base = trybase;
-               ++trybase;
-            }
-            else if (trybase < base)
-            {
-               base = trybase;
-               --trybase;
-            }
-            else if (trydelta > delta)
-            {
-               delta = trydelta;
-               ++trydelta;
-            }
-            else if (trydelta < delta)
-            {
-               delta = trydelta;
-               --trydelta;
-            }
-            else
-            {
-               fprintf(stderr, "makesRGB: impossible\n");
-               exit(1);
-            }
-            ecbase = error_count16;
-         }
-
-         else
-         {
-            if (trybase > base)
-               trybase = base-1;
-            else if (trybase < base)
-            {
-               trybase = base;
-               ++trydelta;
-            }
-            else if (trydelta > delta)
-               trydelta = delta-1;
-            else if (trydelta < delta)
-               break; /* end of tests */
-         }
-      }
-
-      png_sRGB_base[ibase >> 7] = base;
-      png_sRGB_delta[ibase >> 7] = delta;
-      if (base != ob || delta != od)
-      {
-         printf("/* table[%u]={%u,%u} -> {%u,%u} %u -> %u errors */\n",
-            ibase>>7, ob, od, base, delta, eco, ecbase);
-      }
-      else if (0)
-         printf("/* table[%u]={%u,%u} %u errors */\n", ibase>>7, ob, od,
-            ecbase);
-   }
-
-   /* Only do the full (slow) test at the end: */
-   min_error = -.4999;
-   max_error = .4999;
-   error_count = 0;
-
-   for (i=0; i <= max_input; ++i)
-   {
-      unsigned int iexact = nearbyint(255*sRGB(i));
-      unsigned int icalc = PNG_sRGB_FROM_LINEAR(i);
-
-      if (icalc != iexact)
-      {
-         double err = 255*sRGB(i) - icalc;
-
-         if (err > (max_error+.001) || err < (min_error-.001))
-         {
-            printf(
-               "/* 0x%08x: exact: %3d, got: %3d [tables: %08x, %08x] (%f) */\n",
-               i, iexact, icalc, png_sRGB_base[i>>15],
-               png_sRGB_delta[i>>15], err);
-         }
-
-         ++error_count;
-         if (err > max_error)
-            max_error = err;
-         else if (err < min_error)
-            min_error = err;
-      }
-   }
-
-   /* Re-check the 16-bit cases too, including the warning if there is an error
-    * bigger than 1.
-    */
-   error_count16 = 0;
-   max_error16 = 0;
-   min_error16 = 0;
-   for (i16=0; i16 <= 65535; ++i16)
-   {
-      unsigned int i = 255*i16;
-      unsigned int iexact = nearbyint(255*sRGB(i));
-      unsigned int icalc = PNG_sRGB_FROM_LINEAR(i);
-
-      if (icalc != iexact)
-      {
-         double err = 255*sRGB(i) - icalc;
-
-         ++error_count16;
-         if (err > max_error16)
-            max_error16 = err;
-         else if (err < min_error16)
-            min_error16 = err;
-
-         if (abs(icalc - iexact) > 1)
-            printf(
-               "/* 0x%04x: exact: %3d, got: %3d [tables: %08x, %08x] (%f) */\n",
-               i16, iexact, icalc, png_sRGB_base[i>>15],
-               png_sRGB_delta[i>>15], err);
-      }
-   }
-
-   /* Check the round trip for each 8-bit sRGB value. */
-   for (i16=0; i16 <= 255; ++i16)
-   {
-      unsigned int i = 255 * png_sRGB_table[i16];
-      unsigned int iexact = nearbyint(255*sRGB(i));
-      unsigned int icalc = PNG_sRGB_FROM_LINEAR(i);
-
-      if (i16 != iexact)
-      {
-         fprintf(stderr, "8-bit rounding error: %d -> %d\n", i16, iexact);
-         exit(1);
-      }
-
-      if (icalc != i16)
-      {
-         double finv = finvsRGB(i16);
-
-         printf("/* 8-bit roundtrip error: %d -> %f -> %d(%f) */\n",
-            i16, finv, icalc, fsRGB(255*finv));
-      }
-   }
-
-
-   printf("/* error: %g - %g, %u (%g%%) of readings inexact */\n",
-      min_error, max_error, error_count, (100.*error_count)/max_input);
-   printf("/* 16-bit error: %g - %g, %u (%g%%) of readings inexact */\n",
-      min_error16, max_error16, error_count16, (100.*error_count16)/65535);
-
-   if (!test_only)
-   {
-      printf("PNG_CONST png_uint_16 png_sRGB_table[256] =\n{\n   ");
-      for (i=0; i<255; )
-      {
-         do
-         {
-            printf("%d,", png_sRGB_table[i++]);
-         }
-         while ((i & 0x7) != 0 && i<255);
-         if (i<255) printf("\n   ");
-      }
-      printf("%d\n};\n\n", png_sRGB_table[i]);
-
-
-      printf("PNG_CONST png_uint_16 png_sRGB_base[512] =\n{\n   ");
-      for (i=0; i<511; )
-      {
-         do
-         {
-            printf("%d,", png_sRGB_base[i++]);
-         }
-         while ((i & 0x7) != 0 && i<511);
-         if (i<511) printf("\n   ");
-      }
-      printf("%d\n};\n\n", png_sRGB_base[i]);
-
-      printf("PNG_CONST png_byte png_sRGB_delta[512] =\n{\n   ");
-      for (i=0; i<511; )
-      {
-         do
-         {
-            printf("%d,", png_sRGB_delta[i++]);
-         }
-         while ((i & 0xf) != 0 && i<511);
-         if (i<511) printf("\n   ");
-      }
-      printf("%d\n};\n\n", png_sRGB_delta[i]);
-   }
-
-   return 0;
-}

contrib/tools/sRGB.h

@@ -1,48 +0,0 @@
-/*-
- * sRGB.h
- *
- * Last changed in libpng 1.6.0 [February 14, 2013]
- *
- * COPYRIGHT: Written by John Cunningham Bowler, 2013.
- * 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.
- *
- * Utility file; not actually a header, this contains definitions of sRGB
- * calculation functions for inclusion in those test programs that need them.
- *
- * All routines take and return a floating point value in the range
- * 0 to 1.0, doing a calculation according to the sRGB specification
- * (in fact the source of the numbers is the wikipedia article at
- * http://en.wikipedia.org/wiki/SRGB).
- */
-static double
-sRGB_from_linear(double l)
-{
-   if (l <= 0.0031308)
-      l *= 12.92;
-
-   else
-      l = 1.055 * pow(l, 1/2.4) - 0.055;
-
-   return l;
-}
-
-static double
-linear_from_sRGB(double s)
-{
-   if (s <= 0.04045)
-      return s / 12.92;
-
-   else
-      return pow((s+0.055)/1.055, 2.4);
-}
-
-static double
-YfromRGB(double r, double g, double b)
-{
-   /* Use the sRGB (rounded) coefficients for Rlinear, Glinear, Blinear to get
-    * the CIE Y value (also linear).
-    */
-   return 0.2126 * r + 0.7152 * g + 0.0722 * b;
-}

contrib/visupng/PngFile.c

@@ -1,19 +1,17 @@
-/*-------------------------------------
- *  PNGFILE.C -- Image File Functions
- *-------------------------------------
- *
- * Copyright 2000, Willem van Schaik.
- *
- * This code is released under the libpng license.
- * For conditions of distribution and use, see the disclaimer
- * and license in png.h
- */
+//-------------------------------------
+//  PNGFILE.C -- Image File Functions
+//-------------------------------------
+
+// Copyright 2000, Willem van Schaik.
+//
+// This code is released under the libpng license.
+// For conditions of distribution and use, see the disclaimer
+// and license in png.h
 
 #include <windows.h>
 #include <commdlg.h>
 #include <stdio.h>
 #include <stdlib.h>
-#include <zlib.h>
 
 #include "png.h"
 #include "pngfile.h"
@@ -30,14 +28,14 @@ static png_structp png_ptr = NULL;
 static png_infop info_ptr = NULL;
 
 
-/* cexcept interface */
+// cexcept interface
 
 static void
 png_cexcept_error(png_structp png_ptr, png_const_charp msg)
 {
    if(png_ptr)
      ;
-#ifdef PNG_CONSOLE_IO_SUPPORTED
+#ifndef PNG_NO_CONSOLE_IO
    fprintf(stderr, "libpng error: %s\n", msg);
 #endif
    {
@@ -45,7 +43,7 @@ png_cexcept_error(png_structp png_ptr, png_const_charp msg)
    }
 }
 
-/* Windows open-file functions */
+// Windows open-file functions
 
 void PngFileInitialize (HWND hwnd)
 {
@@ -59,13 +57,13 @@ void PngFileInitialize (HWND hwnd)
     ofn.lpstrCustomFilter = NULL;
     ofn.nMaxCustFilter    = 0;
     ofn.nFilterIndex      = 0;
-    ofn.lpstrFile         = NULL;          /* Set in Open and Close functions */
+    ofn.lpstrFile         = NULL;          // Set in Open and Close functions
     ofn.nMaxFile          = MAX_PATH;
-    ofn.lpstrFileTitle    = NULL;          /* Set in Open and Close functions */
+    ofn.lpstrFileTitle    = NULL;          // Set in Open and Close functions
     ofn.nMaxFileTitle     = MAX_PATH;
     ofn.lpstrInitialDir   = NULL;
     ofn.lpstrTitle        = NULL;
-    ofn.Flags             = 0;             /* Set in Open and Close functions */
+    ofn.Flags             = 0;             // Set in Open and Close functions
     ofn.nFileOffset       = 0;
     ofn.nFileExtension    = 0;
     ofn.lpstrDefExt       = TEXT ("png");
@@ -94,7 +92,7 @@ BOOL PngFileSaveDlg (HWND hwnd, PTSTR pstrFileName, PTSTR pstrTitleName)
     return GetSaveFileName (&ofn);
 }
 
-/* PNG image handler functions */
+// PNG image handler functions
 
 BOOL PngLoadImage (PTSTR pstrFileName, png_byte **ppbImageData,
                    int *piWidth, int *piHeight, int *piChannels, png_color *pBkgColor)
@@ -111,7 +109,7 @@ BOOL PngLoadImage (PTSTR pstrFileName, png_byte **ppbImageData,
     static png_byte   **ppbRowPointers = NULL;
     int                 i;
 
-    /* open the PNG input file */
+    // open the PNG input file
 
     if (!pstrFileName)
     {
@@ -125,7 +123,7 @@ BOOL PngLoadImage (PTSTR pstrFileName, png_byte **ppbImageData,
         return FALSE;
     }
 
-    /* first check the eight byte PNG signature */
+    // first check the eight byte PNG signature
 
     fread(pbSig, 1, 8, pfFile);
     if (png_sig_cmp(pbSig, 0, 8))
@@ -134,7 +132,7 @@ BOOL PngLoadImage (PTSTR pstrFileName, png_byte **ppbImageData,
         return FALSE;
     }
 
-    /* create the two png(-info) structures */
+    // create the two png(-info) structures
 
     png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL,
       (png_error_ptr)png_cexcept_error, (png_error_ptr)NULL);
@@ -154,37 +152,31 @@ BOOL PngLoadImage (PTSTR pstrFileName, png_byte **ppbImageData,
 
     Try
     {
-
-        /* initialize the png structure */
-
-#ifdef PNG_STDIO_SUPPORTED
+        
+        // initialize the png structure
+        
+#if !defined(PNG_NO_STDIO)
         png_init_io(png_ptr, pfFile);
 #else
         png_set_read_fn(png_ptr, (png_voidp)pfFile, png_read_data);
 #endif
-
+        
         png_set_sig_bytes(png_ptr, 8);
-
-        /* read all PNG info up to image data */
-
+        
+        // read all PNG info up to image data
+        
         png_read_info(png_ptr, info_ptr);
-
-        /* get width, height, bit-depth and color-type */
-
+        
+        // get width, height, bit-depth and color-type
+        
         png_get_IHDR(png_ptr, info_ptr, piWidth, piHeight, &iBitDepth,
             &iColorType, NULL, NULL, NULL);
-
-        /* expand images of all color-type and bit-depth to 3x8-bit RGB */
-        /* let the library process alpha, transparency, background, etc. */
-
-#ifdef PNG_READ_16_TO_8_SUPPORTED
-    if (iBitDepth == 16)
-#  ifdef PNG_READ_SCALE_16_TO_8_SUPPORTED
-        png_set_scale_16(png_ptr);
-#  else
-        png_set_strip_16(png_ptr);
-#  endif
-#endif
+        
+        // expand images of all color-type and bit-depth to 3x8 bit RGB images
+        // let the library process things like alpha, transparency, background
+        
+        if (iBitDepth == 16)
+            png_set_strip_16(png_ptr);
         if (iColorType == PNG_COLOR_TYPE_PALETTE)
             png_set_expand(png_ptr);
         if (iBitDepth < 8)
@@ -194,8 +186,8 @@ BOOL PngLoadImage (PTSTR pstrFileName, png_byte **ppbImageData,
         if (iColorType == PNG_COLOR_TYPE_GRAY ||
             iColorType == PNG_COLOR_TYPE_GRAY_ALPHA)
             png_set_gray_to_rgb(png_ptr);
-
-        /* set the background color to draw transparent and alpha images over */
+        
+        // set the background color to draw transparent and alpha images over.
         if (png_get_bKGD(png_ptr, info_ptr, &pBackground))
         {
             png_set_background(png_ptr, pBackground, PNG_BACKGROUND_GAMMA_FILE, 1, 1.0);
@@ -207,30 +199,30 @@ BOOL PngLoadImage (PTSTR pstrFileName, png_byte **ppbImageData,
         {
             pBkgColor = NULL;
         }
-
-        /* if required set gamma conversion */
+        
+        // if required set gamma conversion
         if (png_get_gAMA(png_ptr, info_ptr, &dGamma))
             png_set_gamma(png_ptr, (double) 2.2, dGamma);
-
-        /* after the transformations are registered, update info_ptr data */
-
+        
+        // after the transformations have been registered update info_ptr data
+        
         png_read_update_info(png_ptr, info_ptr);
-
-        /* get again width, height and the new bit-depth and color-type */
-
+        
+        // get again width, height and the new bit-depth and color-type
+        
         png_get_IHDR(png_ptr, info_ptr, piWidth, piHeight, &iBitDepth,
             &iColorType, NULL, NULL, NULL);
-
-
-        /* row_bytes is the width x number of channels */
-
+        
+        
+        // row_bytes is the width x number of channels
+        
         ulRowBytes = png_get_rowbytes(png_ptr, info_ptr);
         ulChannels = png_get_channels(png_ptr, info_ptr);
-
+        
         *piChannels = ulChannels;
-
-        /* now we can allocate memory to store the image */
-
+        
+        // now we can allocate memory to store the image
+        
         if (pbImageData)
         {
             free (pbImageData);
@@ -242,34 +234,34 @@ BOOL PngLoadImage (PTSTR pstrFileName, png_byte **ppbImageData,
             png_error(png_ptr, "Visual PNG: out of memory");
         }
         *ppbImageData = pbImageData;
-
-        /* and allocate memory for an array of row-pointers */
-
+        
+        // and allocate memory for an array of row-pointers
+        
         if ((ppbRowPointers = (png_bytepp) malloc((*piHeight)
                             * sizeof(png_bytep))) == NULL)
         {
             png_error(png_ptr, "Visual PNG: out of memory");
         }
-
-        /* set the individual row-pointers to point at the correct offsets */
-
+        
+        // set the individual row-pointers to point at the correct offsets
+        
         for (i = 0; i < (*piHeight); i++)
             ppbRowPointers[i] = pbImageData + i * ulRowBytes;
-
-        /* now we can go ahead and just read the whole image */
-
+        
+        // now we can go ahead and just read the whole image
+        
         png_read_image(png_ptr, ppbRowPointers);
-
-        /* read the additional chunks in the PNG file (not really needed) */
-
+        
+        // read the additional chunks in the PNG file (not really needed)
+        
         png_read_end(png_ptr, NULL);
-
-        /* and we're done */
-
+        
+        // and we're done
+        
         free (ppbRowPointers);
         ppbRowPointers = NULL;
-
-        /* yepp, done */
+        
+        // yepp, done
     }
 
     Catch (msg)
@@ -277,7 +269,7 @@ BOOL PngLoadImage (PTSTR pstrFileName, png_byte **ppbImageData,
         png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
 
         *ppbImageData = pbImageData = NULL;
-
+        
         if(ppbRowPointers)
             free (ppbRowPointers);
 
@@ -303,7 +295,7 @@ BOOL PngSaveImage (PTSTR pstrFileName, png_byte *pDiData,
     static png_byte   **ppbRowPointers = NULL;
     int                 i;
 
-    /* open the PNG output file */
+    // open the PNG output file
 
     if (!pstrFileName)
         return FALSE;
@@ -311,7 +303,7 @@ BOOL PngSaveImage (PTSTR pstrFileName, png_byte *pDiData,
     if (!(pfFile = fopen(pstrFileName, "wb")))
         return FALSE;
 
-    /* prepare the standard PNG structures */
+    // prepare the standard PNG structures
 
     png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL,
       (png_error_ptr)png_cexcept_error, (png_error_ptr)NULL);
@@ -330,60 +322,60 @@ BOOL PngSaveImage (PTSTR pstrFileName, png_byte *pDiData,
 
     Try
     {
-        /* initialize the png structure */
-
-#ifdef PNG_STDIO_SUPPORTED
+        // initialize the png structure
+        
+#if !defined(PNG_NO_STDIO)
         png_init_io(png_ptr, pfFile);
 #else
         png_set_write_fn(png_ptr, (png_voidp)pfFile, png_write_data, png_flush);
 #endif
-
-        /* we're going to write a very simple 3x8-bit RGB image */
-
+        
+        // we're going to write a very simple 3x8 bit RGB image
+        
         png_set_IHDR(png_ptr, info_ptr, iWidth, iHeight, ciBitDepth,
             PNG_COLOR_TYPE_RGB, PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_BASE,
             PNG_FILTER_TYPE_BASE);
-
-        /* write the file header information */
-
+        
+        // write the file header information
+        
         png_write_info(png_ptr, info_ptr);
-
-        /* swap the BGR pixels in the DiData structure to RGB */
-
+        
+        // swap the BGR pixels in the DiData structure to RGB
+        
         png_set_bgr(png_ptr);
-
-        /* row_bytes is the width x number of channels */
-
+        
+        // row_bytes is the width x number of channels
+        
         ulRowBytes = iWidth * ciChannels;
-
-        /* we can allocate memory for an array of row-pointers */
-
+        
+        // we can allocate memory for an array of row-pointers
+        
         if ((ppbRowPointers = (png_bytepp) malloc(iHeight * sizeof(png_bytep))) == NULL)
             Throw "Visualpng: Out of memory";
-
-        /* set the individual row-pointers to point at the correct offsets */
-
+        
+        // set the individual row-pointers to point at the correct offsets
+        
         for (i = 0; i < iHeight; i++)
             ppbRowPointers[i] = pDiData + i * (((ulRowBytes + 3) >> 2) << 2);
-
-        /* write out the entire image data in one call */
-
+        
+        // write out the entire image data in one call
+        
         png_write_image (png_ptr, ppbRowPointers);
-
-        /* write the additional chunks to the PNG file (not really needed) */
-
+        
+        // write the additional chunks to the PNG file (not really needed)
+        
         png_write_end(png_ptr, info_ptr);
-
-        /* and we're done */
-
+        
+        // and we're done
+        
         free (ppbRowPointers);
         ppbRowPointers = NULL;
-
-        /* clean up after the write, and free any memory allocated */
-
+        
+        // clean up after the write, and free any memory allocated
+        
         png_destroy_write_struct(&png_ptr, (png_infopp) NULL);
-
-        /* yepp, done */
+        
+        // yepp, done
     }
 
     Catch (msg)
@@ -397,13 +389,13 @@ BOOL PngSaveImage (PTSTR pstrFileName, png_byte *pDiData,
 
         return FALSE;
     }
-
+    
     fclose (pfFile);
-
+    
     return TRUE;
 }
 
-#ifndef PNG_STDIO_SUPPORTED
+#ifdef PNG_NO_STDIO
 
 static void
 png_read_data(png_structp png_ptr, png_bytep data, png_size_t length)
@@ -445,7 +437,6 @@ png_flush(png_structp png_ptr)
 
 #endif
 
-/*-----------------
- *  end of source
- *-----------------
- */
+//-----------------
+//  end of source
+//-----------------

contrib/visupng/PngFile.h

@@ -1,12 +1,12 @@
-/*------------------------------------------*/
-/*  PNGFILE.H -- Header File for pngfile.c*/
-/*------------------------------------------*/
+//------------------------------------------
+//  PNGFILE.H -- Header File for pngfile.c
+//------------------------------------------
 
-/* Copyright 2000, Willem van Schaik.*/
+// Copyright 2000, Willem van Schaik.
 
-/* This code is released under the libpng license.*/
-/* For conditions of distribution and use, see the disclaimer*/
-/* and license in png.h*/
+// This code is released under the libpng license.
+// For conditions of distribution and use, see the disclaimer
+// and license in png.h
 
 #include <stdio.h>
 #include <stdlib.h>
@@ -17,12 +17,12 @@ void PngFileInitialize (HWND hwnd) ;
 BOOL PngFileOpenDlg (HWND hwnd, PTSTR pstrFileName, PTSTR pstrTitleName) ;
 BOOL PngFileSaveDlg (HWND hwnd, PTSTR pstrFileName, PTSTR pstrTitleName) ;
 
-BOOL PngLoadImage (PTSTR pstrFileName, png_byte **ppbImageData,
+BOOL PngLoadImage (PTSTR pstrFileName, png_byte **ppbImageData, 
                    int *piWidth, int *piHeight, int *piChannels, png_color *pBkgColor);
 BOOL PngSaveImage (PTSTR pstrFileName, png_byte *pDiData,
                    int iWidth, int iHeight, png_color BkgColor);
 
-#ifndef PNG_STDIO_SUPPORTED
+#if defined(PNG_NO_STDIO)
 static void png_read_data(png_structp png_ptr, png_bytep data, png_size_t length);
 static void png_write_data(png_structp png_ptr, png_bytep data, png_size_t length);
 static void png_flush(png_structp png_ptr);

contrib/visupng/README.txt

@@ -8,8 +8,8 @@ For conditions of distribution and use, see the disclaimer
 and license in png.h
 
 As a PNG .dll demo VisualPng is finished. More features would only hinder
-the program's objective. However, further extensions (like support for other
-graphics formats) are in development. To get these, or for pre-compiled
+the program's objective. However, further extensions (like support for other 
+graphics formats) are in development. To get these, or for pre-compiled 
 binaries, go to "http://www.schaik.com/png/visualpng.html".
 
 ------------------------------------------------------------------------

contrib/visupng/VisualPng.c

@@ -1,43 +1,41 @@
-/*------------------------------------
- *  VisualPng.C -- Shows a PNG image
- *------------------------------------
- *
- * Copyright 2000, Willem van Schaik.
- *
- * This code is released under the libpng license.
- * For conditions of distribution and use, see the disclaimer
- * and license in png.h
- */
+//------------------------------------
+//  VisualPng.C -- Shows a PNG image
+//------------------------------------
 
-/* switches */
+// Copyright 2000, Willem van Schaik.
 
-/* defines */
+// This code is released under the libpng license.
+// For conditions of distribution and use, see the disclaimer
+// and license in png.h
+
+// switches
+
+// defines
 
 #define PROGNAME  "VisualPng"
 #define LONGNAME  "Win32 Viewer for PNG-files"
 #define VERSION   "1.0 of 2000 June 07"
 
-/* constants */
+// constants
 
 #define MARGIN 8
 
-/* standard includes */
+// standard includes
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <windows.h>
-#include <zlib.h>
 
-/* application includes */
+// application includes
 
 #include "png.h"
 #include "pngfile.h"
 #include "resource.h"
 
-/* macros */
+// macros
 
-/* function prototypes */
+// function prototypes
 
 LRESULT CALLBACK WndProc (HWND, UINT, WPARAM, LPARAM);
 BOOL    CALLBACK AboutDlgProc (HWND, UINT, WPARAM, LPARAM) ;
@@ -67,14 +65,14 @@ BOOL FillBitmap (
         BYTE *pbImage, int cxImgSize, int cyImgSize, int cImgChannels,
         BOOL bStretched);
 
-/* a few global variables */
+// a few global variables
 
 static char *szProgName = PROGNAME;
 static char *szAppName = LONGNAME;
 static char *szIconName = PROGNAME;
 static char szCmdFileName [MAX_PATH];
 
-/* MAIN routine */
+// MAIN routine
 
 int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance,
                     PSTR szCmdLine, int iCmdShow)
@@ -92,7 +90,7 @@ int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance,
     wndclass.hInstance     = hInstance;
     wndclass.hIcon         = LoadIcon (hInstance, szIconName) ;
     wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW);
-    wndclass.hbrBackground = NULL; /* (HBRUSH) GetStockObject (GRAY_BRUSH); */
+    wndclass.hbrBackground = NULL; // (HBRUSH) GetStockObject (GRAY_BRUSH);
     wndclass.lpszMenuName  = szProgName;
     wndclass.lpszClassName = szProgName;
 
@@ -103,7 +101,7 @@ int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance,
         return 0;
     }
 
-    /* if filename given on commandline, store it */
+    // if filename given on commandline, store it
     if ((szCmdLine != NULL) && (*szCmdLine != '\0'))
         if (szCmdLine[0] == '"')
             strncpy (szCmdFileName, szCmdLine + 1, strlen(szCmdLine) - 2);
@@ -112,20 +110,20 @@ int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance,
     else
         strcpy (szCmdFileName, "");
 
-    /* calculate size of window-borders */
+    // calculate size of window-borders
     ixBorders = 2 * (GetSystemMetrics (SM_CXBORDER) +
                      GetSystemMetrics (SM_CXDLGFRAME));
     iyBorders = 2 * (GetSystemMetrics (SM_CYBORDER) +
                      GetSystemMetrics (SM_CYDLGFRAME)) +
                      GetSystemMetrics (SM_CYCAPTION) +
                      GetSystemMetrics (SM_CYMENUSIZE) +
-                     1; /* WvS: don't ask me why?  */
+                     1; /* WvS: don't ask me why? */
 
     hwnd = CreateWindow (szProgName, szAppName,
         WS_OVERLAPPEDWINDOW,
         CW_USEDEFAULT, CW_USEDEFAULT,
         512 + 2 * MARGIN + ixBorders, 384 + 2 * MARGIN + iyBorders,
-/*      CW_USEDEFAULT, CW_USEDEFAULT, */
+//      CW_USEDEFAULT, CW_USEDEFAULT,
         NULL, NULL, hInstance, NULL);
 
     ShowWindow (hwnd, iCmdShow);
@@ -182,29 +180,29 @@ LRESULT CALLBACK WndProc (HWND hwnd, UINT message, WPARAM wParam,
 
         strcpy (szImgPathName, "");
 
-        /* in case we process file given on command-line */
+        // in case we process file given on command-line
 
         if (szCmdFileName[0] != '\0')
         {
             strcpy (szImgPathName, szCmdFileName);
 
-            /* read the other png-files in the directory for later */
-            /* next/previous commands */
+            // read the other png-files in the directory for later
+            // next/previous commands
 
             BuildPngList (szImgPathName, &pPngFileList, &iPngFileCount,
                           &iPngFileIndex);
 
-            /* load the image from file */
+            // load the image from file
 
             if (!LoadImageFile (hwnd, szImgPathName,
                 &pbImage, &cxImgSize, &cyImgSize, &cImgChannels, &bkgColor))
                 return 0;
 
-            /* invalidate the client area for later update */
+            // invalidate the client area for later update
 
             InvalidateRect (hwnd, NULL, TRUE);
 
-            /* display the PNG into the DIBitmap */
+            // display the PNG into the DIBitmap
 
             DisplayImage (hwnd, &pDib, &pDiData, cxWinSize, cyWinSize,
                 pbImage, cxImgSize, cyImgSize, cImgChannels, bStretched);
@@ -216,11 +214,11 @@ LRESULT CALLBACK WndProc (HWND hwnd, UINT message, WPARAM wParam,
         cxWinSize = LOWORD (lParam);
         cyWinSize = HIWORD (lParam);
 
-        /* invalidate the client area for later update */
+        // invalidate the client area for later update
 
         InvalidateRect (hwnd, NULL, TRUE);
 
-        /* display the PNG into the DIBitmap */
+        // display the PNG into the DIBitmap
 
         DisplayImage (hwnd, &pDib, &pDiData, cxWinSize, cyWinSize,
             pbImage, cxImgSize, cyImgSize, cImgChannels, bStretched);
@@ -244,28 +242,28 @@ LRESULT CALLBACK WndProc (HWND hwnd, UINT message, WPARAM wParam,
         {
         case IDM_FILE_OPEN:
 
-            /* show the File Open dialog box */
+            // show the File Open dialog box
 
             if (!PngFileOpenDlg (hwnd, szImgPathName, szTitleName))
                 return 0;
 
-            /* read the other png-files in the directory for later */
-            /* next/previous commands */
+            // read the other png-files in the directory for later
+            // next/previous commands
 
             BuildPngList (szImgPathName, &pPngFileList, &iPngFileCount,
                           &iPngFileIndex);
 
-            /* load the image from file */
+            // load the image from file
 
             if (!LoadImageFile (hwnd, szImgPathName,
                 &pbImage, &cxImgSize, &cyImgSize, &cImgChannels, &bkgColor))
                 return 0;
 
-            /* invalidate the client area for later update */
+            // invalidate the client area for later update
 
             InvalidateRect (hwnd, NULL, TRUE);
 
-            /* display the PNG into the DIBitmap */
+            // display the PNG into the DIBitmap
 
             DisplayImage (hwnd, &pDib, &pDiData, cxWinSize, cyWinSize,
                 pbImage, cxImgSize, cyImgSize, cImgChannels, bStretched);
@@ -274,12 +272,12 @@ LRESULT CALLBACK WndProc (HWND hwnd, UINT message, WPARAM wParam,
 
         case IDM_FILE_SAVE:
 
-            /* show the File Save dialog box */
+            // show the File Save dialog box
 
             if (!PngFileSaveDlg (hwnd, szImgPathName, szTitleName))
                 return 0;
 
-            /* save the PNG to a disk file */
+            // save the PNG to a disk file
 
             SetCursor (LoadCursor (NULL, IDC_WAIT));
             ShowCursor (TRUE);
@@ -297,55 +295,55 @@ LRESULT CALLBACK WndProc (HWND hwnd, UINT message, WPARAM wParam,
 
         case IDM_FILE_NEXT:
 
-            /* read next entry in the directory */
+            // read next entry in the directory
 
             if (SearchPngList (pPngFileList, iPngFileCount, &iPngFileIndex,
                 NULL, szImgPathName))
             {
                 if (strcmp (szImgPathName, "") == 0)
                     return 0;
-
-                /* load the image from file */
-
+                
+                // load the image from file
+                
                 if (!LoadImageFile (hwnd, szImgPathName, &pbImage,
                         &cxImgSize, &cyImgSize, &cImgChannels, &bkgColor))
                     return 0;
-
-                /* invalidate the client area for later update */
-
+                
+                // invalidate the client area for later update
+                
                 InvalidateRect (hwnd, NULL, TRUE);
-
-                /* display the PNG into the DIBitmap */
-
+                
+                // display the PNG into the DIBitmap
+                
                 DisplayImage (hwnd, &pDib, &pDiData, cxWinSize, cyWinSize,
                     pbImage, cxImgSize, cyImgSize, cImgChannels, bStretched);
             }
-
+            
             return 0;
 
         case IDM_FILE_PREVIOUS:
 
-            /* read previous entry in the directory */
+            // read previous entry in the directory
 
             if (SearchPngList (pPngFileList, iPngFileCount, &iPngFileIndex,
                 szImgPathName, NULL))
             {
-
+                
                 if (strcmp (szImgPathName, "") == 0)
                     return 0;
-
-                /* load the image from file */
-
+                
+                // load the image from file
+                
                 if (!LoadImageFile (hwnd, szImgPathName, &pbImage, &cxImgSize,
                     &cyImgSize, &cImgChannels, &bkgColor))
                     return 0;
-
-                /* invalidate the client area for later update */
-
+                
+                // invalidate the client area for later update
+                
                 InvalidateRect (hwnd, NULL, TRUE);
-
-                /* display the PNG into the DIBitmap */
-
+                
+                // display the PNG into the DIBitmap
+                
                 DisplayImage (hwnd, &pDib, &pDiData, cxWinSize, cyWinSize,
                     pbImage, cxImgSize, cyImgSize, cImgChannels, bStretched);
             }
@@ -354,9 +352,9 @@ LRESULT CALLBACK WndProc (HWND hwnd, UINT message, WPARAM wParam,
 
         case IDM_FILE_EXIT:
 
-            /* more cleanup needed... */
+            // more cleanup needed...
 
-            /* free image buffer */
+            // free image buffer
 
             if (pDib != NULL)
             {
@@ -364,7 +362,7 @@ LRESULT CALLBACK WndProc (HWND hwnd, UINT message, WPARAM wParam,
                 pDib = NULL;
             }
 
-            /* free file-list */
+            // free file-list
 
             if (pPngFileList != NULL)
             {
@@ -372,7 +370,7 @@ LRESULT CALLBACK WndProc (HWND hwnd, UINT message, WPARAM wParam,
                 pPngFileList = NULL;
             }
 
-            /* let's go ... */
+            // let's go ...
 
             exit (0);
 
@@ -385,11 +383,11 @@ LRESULT CALLBACK WndProc (HWND hwnd, UINT message, WPARAM wParam,
             else
                 CheckMenuItem (hMenu, IDM_OPTIONS_STRETCH, MF_UNCHECKED);
 
-            /* invalidate the client area for later update */
+            // invalidate the client area for later update
 
             InvalidateRect (hwnd, NULL, TRUE);
 
-            /* display the PNG into the DIBitmap */
+            // display the PNG into the DIBitmap
 
             DisplayImage (hwnd, &pDib, &pDiData, cxWinSize, cyWinSize,
                 pbImage, cxImgSize, cyImgSize, cImgChannels, bStretched);
@@ -400,7 +398,7 @@ LRESULT CALLBACK WndProc (HWND hwnd, UINT message, WPARAM wParam,
             DialogBox (hInstance, TEXT ("AboutBox"), hwnd, AboutDlgProc) ;
             return 0;
 
-        } /* end switch */
+        } // end switch
 
         break;
 
@@ -452,10 +450,10 @@ BOOL CALLBACK AboutDlgProc (HWND hDlg, UINT message,
      return FALSE ;
 }
 
-/*---------------
- *  CenterAbout
- *---------------
- */
+//---------------
+//  CenterAbout
+//---------------
+
 BOOL CenterAbout (HWND hwndChild, HWND hwndParent)
 {
    RECT    rChild, rParent, rWorkArea;
@@ -463,19 +461,19 @@ BOOL CenterAbout (HWND hwndChild, HWND hwndParent)
    int     xNew, yNew;
    BOOL  bResult;
 
-   /* Get the Height and Width of the child window */
+   // Get the Height and Width of the child window
    GetWindowRect (hwndChild, &rChild);
    wChild = rChild.right - rChild.left;
    hChild = rChild.bottom - rChild.top;
 
-   /* Get the Height and Width of the parent window */
+   // Get the Height and Width of the parent window
    GetWindowRect (hwndParent, &rParent);
    wParent = rParent.right - rParent.left;
    hParent = rParent.bottom - rParent.top;
 
-   /* Get the limits of the 'workarea' */
+   // Get the limits of the 'workarea'
    bResult = SystemParametersInfo(
-      SPI_GETWORKAREA,  /* system parameter to query or set */
+      SPI_GETWORKAREA,  // system parameter to query or set
       sizeof(RECT),
       &rWorkArea,
       0);
@@ -485,7 +483,7 @@ BOOL CenterAbout (HWND hwndChild, HWND hwndParent)
       rWorkArea.bottom = GetSystemMetrics(SM_CYSCREEN);
    }
 
-   /* Calculate new X position, then adjust for workarea */
+   // Calculate new X position, then adjust for workarea
    xNew = rParent.left + ((wParent - wChild) /2);
    if (xNew < rWorkArea.left) {
       xNew = rWorkArea.left;
@@ -493,7 +491,7 @@ BOOL CenterAbout (HWND hwndChild, HWND hwndParent)
       xNew = rWorkArea.right - wChild;
    }
 
-   /* Calculate new Y position, then adjust for workarea */
+   // Calculate new Y position, then adjust for workarea
    yNew = rParent.top  + ((hParent - hChild) /2);
    if (yNew < rWorkArea.top) {
       yNew = rWorkArea.top;
@@ -501,15 +499,15 @@ BOOL CenterAbout (HWND hwndChild, HWND hwndParent)
       yNew = rWorkArea.bottom - hChild;
    }
 
-   /* Set it, and return */
+   // Set it, and return
    return SetWindowPos (hwndChild, NULL, xNew, yNew, 0, 0, SWP_NOSIZE |
           SWP_NOZORDER);
 }
 
-/*----------------
- *  BuildPngList
- *----------------
- */
+//----------------
+//  BuildPngList
+//----------------
+
 BOOL BuildPngList (PTSTR pstrPathName, TCHAR **ppFileList, int *pFileCount,
      int *pFileIndex)
 {
@@ -525,7 +523,7 @@ BOOL BuildPngList (PTSTR pstrPathName, TCHAR **ppFileList, int *pFileCount,
     int                       i, ii;
     int                       j, jj;
 
-    /* free previous file-list */
+    // free previous file-list
 
     if (*ppFileList != NULL)
     {
@@ -533,7 +531,7 @@ BOOL BuildPngList (PTSTR pstrPathName, TCHAR **ppFileList, int *pFileCount,
         *ppFileList = NULL;
     }
 
-    /* extract foldername, filename and search-name */
+    // extract foldername, filename and search-name
 
     strcpy (szImgPathName, pstrPathName);
     strcpy (szImgFileName, strrchr (pstrPathName, '\\') + 1);
@@ -542,7 +540,7 @@ BOOL BuildPngList (PTSTR pstrPathName, TCHAR **ppFileList, int *pFileCount,
     *(strrchr (szImgFindName, '\\') + 1) = '\0';
     strcat (szImgFindName, "*.png");
 
-    /* first cycle: count number of files in directory for memory allocation */
+    // first cycle: count number of files in directory for memory allocation
 
     *pFileCount = 0;
 
@@ -556,11 +554,11 @@ BOOL BuildPngList (PTSTR pstrPathName, TCHAR **ppFileList, int *pFileCount,
     }
     FindClose(hFind);
 
-    /* allocation memory for file-list */
+    // allocation memory for file-list
 
     *ppFileList = (TCHAR *) malloc (*pFileCount * MAX_PATH);
 
-    /* second cycle: read directory and store filenames in file-list */
+    // second cycle: read directory and store filenames in file-list
 
     hFind = FindFirstFile(szImgFindName, &finddata);
     bOk = (hFind != (HANDLE) -1);
@@ -582,7 +580,7 @@ BOOL BuildPngList (PTSTR pstrPathName, TCHAR **ppFileList, int *pFileCount,
     }
     FindClose(hFind);
 
-    /* finally we must sort the file-list */
+    // finally we must sort the file-list
 
     for (i = 0; i < *pFileCount - 1; i++)
     {
@@ -596,7 +594,7 @@ BOOL BuildPngList (PTSTR pstrPathName, TCHAR **ppFileList, int *pFileCount,
                 strcpy (*ppFileList + jj, *ppFileList + ii);
                 strcpy (*ppFileList + ii, szTmp);
 
-                /* check if this was the current image that we moved */
+                // check if this was the current image that we moved
 
                 if (*pFileIndex == i)
                     *pFileIndex = j;
@@ -610,10 +608,9 @@ BOOL BuildPngList (PTSTR pstrPathName, TCHAR **ppFileList, int *pFileCount,
     return TRUE;
 }
 
-/*----------------
- *  SearchPngList
- *----------------
- */
+//----------------
+//  SearchPngList
+//----------------
 
 BOOL SearchPngList (
         TCHAR *pFileList, int FileCount, int *pFileIndex,
@@ -621,30 +618,30 @@ BOOL SearchPngList (
 {
     if (FileCount > 0)
     {
-        /* get previous entry */
-
+        // get previous entry
+        
         if (pstrPrevName != NULL)
         {
             if (*pFileIndex > 0)
                 *pFileIndex -= 1;
             else
                 *pFileIndex = FileCount - 1;
-
+            
             strcpy (pstrPrevName, pFileList + (*pFileIndex * MAX_PATH));
         }
-
-        /* get next entry */
-
+        
+        // get next entry
+        
         if (pstrNextName != NULL)
         {
             if (*pFileIndex < FileCount - 1)
                 *pFileIndex += 1;
             else
                 *pFileIndex = 0;
-
+            
             strcpy (pstrNextName, pFileList + (*pFileIndex * MAX_PATH));
         }
-
+        
         return TRUE;
     }
     else
@@ -653,10 +650,9 @@ BOOL SearchPngList (
     }
 }
 
-/*-----------------
- *  LoadImageFile
- *-----------------
- */
+//-----------------
+//  LoadImageFile
+//-----------------
 
 BOOL LoadImageFile (HWND hwnd, PTSTR pstrPathName,
                 png_byte **ppbImage, int *pxImgSize, int *pyImgSize,
@@ -664,7 +660,7 @@ BOOL LoadImageFile (HWND hwnd, PTSTR pstrPathName,
 {
     static TCHAR szTmp [MAX_PATH];
 
-    /* if there's an existing PNG, free the memory */
+    // if there's an existing PNG, free the memory
 
     if (*ppbImage)
     {
@@ -672,7 +668,7 @@ BOOL LoadImageFile (HWND hwnd, PTSTR pstrPathName,
         *ppbImage = NULL;
     }
 
-    /* Load the entire PNG into memory */
+    // Load the entire PNG into memory
 
     SetCursor (LoadCursor (NULL, IDC_WAIT));
     ShowCursor (TRUE);
@@ -698,10 +694,10 @@ BOOL LoadImageFile (HWND hwnd, PTSTR pstrPathName,
     return TRUE;
 }
 
-/*----------------
- *  DisplayImage
- *----------------
- */
+//----------------
+//  DisplayImage
+//----------------
+
 BOOL DisplayImage (HWND hwnd, BYTE **ppDib,
         BYTE **ppDiData, int cxWinSize, int cyWinSize,
         BYTE *pbImage, int cxImgSize, int cyImgSize, int cImgChannels,
@@ -709,14 +705,14 @@ BOOL DisplayImage (HWND hwnd, BYTE **ppDib,
 {
     BYTE                       *pDib = *ppDib;
     BYTE                       *pDiData = *ppDiData;
-    /* BITMAPFILEHEADER        *pbmfh; */
+    // BITMAPFILEHEADER        *pbmfh;
     BITMAPINFOHEADER           *pbmih;
     WORD                        wDIRowBytes;
     png_color                   bkgBlack = {0, 0, 0};
     png_color                   bkgGray  = {127, 127, 127};
     png_color                   bkgWhite = {255, 255, 255};
 
-    /* allocate memory for the Device Independant bitmap */
+    // allocate memory for the Device Independant bitmap
 
     wDIRowBytes = (WORD) ((3 * cxWinSize + 3L) >> 2) << 2;
 
@@ -737,7 +733,7 @@ BOOL DisplayImage (HWND hwnd, BYTE **ppDib,
     *ppDib = pDib;
     memset (pDib, 0, sizeof(BITMAPINFOHEADER));
 
-    /* initialize the dib-structure */
+    // initialize the dib-structure
 
     pbmih = (BITMAPINFOHEADER *) pDib;
     pbmih->biSize = sizeof(BITMAPINFOHEADER);
@@ -749,11 +745,11 @@ BOOL DisplayImage (HWND hwnd, BYTE **ppDib,
     pDiData = pDib + sizeof(BITMAPINFOHEADER);
     *ppDiData = pDiData;
 
-    /* first fill bitmap with gray and image border */
+    // first fill bitmap with gray and image border
 
     InitBitmap (pDiData, cxWinSize, cyWinSize);
 
-    /* then fill bitmap with image */
+    // then fill bitmap with image
 
     if (pbImage)
     {
@@ -766,16 +762,16 @@ BOOL DisplayImage (HWND hwnd, BYTE **ppDib,
     return TRUE;
 }
 
-/*--------------
- *  InitBitmap
- *--------------
- */
+//--------------
+//  InitBitmap
+//--------------
+
 BOOL InitBitmap (BYTE *pDiData, int cxWinSize, int cyWinSize)
 {
     BYTE *dst;
     int x, y, col;
 
-    /* initialize the background with gray */
+    // initialize the background with gray
 
     dst = pDiData;
     for (y = 0; y < cyWinSize; y++)
@@ -783,13 +779,13 @@ BOOL InitBitmap (BYTE *pDiData, int cxWinSize, int cyWinSize)
         col = 0;
         for (x = 0; x < cxWinSize; x++)
         {
-            /* fill with GRAY */
+            // fill with GRAY
             *dst++ = 127;
             *dst++ = 127;
             *dst++ = 127;
             col += 3;
         }
-        /* rows start on 4 byte boundaries */
+        // rows start on 4 byte boundaries
         while ((col % 4) != 0)
         {
             dst++;
@@ -800,10 +796,10 @@ BOOL InitBitmap (BYTE *pDiData, int cxWinSize, int cyWinSize)
     return TRUE;
 }
 
-/*--------------
- *  FillBitmap
- *--------------
- */
+//--------------
+//  FillBitmap
+//--------------
+
 BOOL FillBitmap (
         BYTE *pDiData, int cxWinSize, int cyWinSize,
         BYTE *pbImage, int cxImgSize, int cyImgSize, int cImgChannels,
@@ -828,12 +824,11 @@ BOOL FillBitmap (
         cxNewSize = cxWinSize - 2 * MARGIN;
         cyNewSize = cyWinSize - 2 * MARGIN;
 
-        /* stretch the image to it's window determined size */
+        // stretch the image to it's window determined size
 
-        /* the following two are mathematically the same, but the first
-         * has side-effects because of rounding
-         */
-/*      if ((cyNewSize / cxNewSize) > (cyImgSize / cxImgSize)) */
+        // the following two are the same, but the first has side-effects
+        // because of rounding
+//      if ((cyNewSize / cxNewSize) > (cyImgSize / cxImgSize))
         if ((cyNewSize * cxImgSize) > (cyImgSize * cxNewSize))
         {
             cyNewSize = cxNewSize * cyImgSize / cxImgSize;
@@ -872,12 +867,12 @@ BOOL FillBitmap (
             }
         }
 
-        /* calculate row-bytes */
+        // calculate row-bytes
 
         wImgRowBytes = cImgChannels * cxNewSize;
         wDIRowBytes = (WORD) ((cDIChannels * cxWinSize + 3L) >> 2) << 2;
 
-        /* copy image to screen */
+        // copy image to screen
 
         for (yImg = 0, yWin = cyImgPos; yImg < cyNewSize; yImg++, yWin++)
         {
@@ -893,7 +888,7 @@ BOOL FillBitmap (
                 r = *src++;
                 g = *src++;
                 b = *src++;
-                *dst++ = b; /* note the reverse order  */
+                *dst++ = b; /* note the reverse order */
                 *dst++ = g;
                 *dst++ = r;
                 if (cImgChannels == 4)
@@ -903,7 +898,7 @@ BOOL FillBitmap (
             }
         }
 
-        /* free memory */
+        // free memory
 
         if (pStretchedImage != NULL)
         {
@@ -913,28 +908,28 @@ BOOL FillBitmap (
 
     }
 
-    /* process the image not-stretched */
+    // process the image not-stretched
 
     else
     {
-        /* calculate the central position */
+        // calculate the central position
 
         cxImgPos = (cxWinSize - cxImgSize) / 2;
         cyImgPos = (cyWinSize - cyImgSize) / 2;
 
-        /* check for image larger than window */
+        // check for image larger than window
 
         if (cxImgPos < MARGIN)
             cxImgPos = MARGIN;
         if (cyImgPos < MARGIN)
             cyImgPos = MARGIN;
 
-        /* calculate both row-bytes */
+        // calculate both row-bytes
 
         wImgRowBytes = cImgChannels * cxImgSize;
         wDIRowBytes = (WORD) ((cDIChannels * cxWinSize + 3L) >> 2) << 2;
 
-        /* copy image to screen */
+        // copy image to screen
 
         for (yImg = 0, yWin = cyImgPos; yImg < cyImgSize; yImg++, yWin++)
         {
@@ -950,7 +945,7 @@ BOOL FillBitmap (
                 r = *src++;
                 g = *src++;
                 b = *src++;
-                *dst++ = b; /* note the reverse order  */
+                *dst++ = b; /* note the reverse order */
                 *dst++ = g;
                 *dst++ = r;
                 if (cImgChannels == 4)
@@ -964,7 +959,6 @@ BOOL FillBitmap (
     return TRUE;
 }
 
-/*-----------------
- *  end of source
- *-----------------
- */
+//-----------------
+//  end of source
+//-----------------

contrib/visupng/VisualPng.dsp

@@ -43,9 +43,9 @@ RSC=rc.exe
 # PROP Intermediate_Dir "Release"
 # PROP Ignore_Export_Lib 0
 # PROP Target_Dir ""
-# ADD BASE CPP /nologo /W3 /O2 /I "..\.." /I "..\..\..\zlib" /D "WIN32" /D "NDEBUG" /D "PNG_NO_STDIO" /FD /c
+# ADD BASE CPP /nologo /W3 /O2 /I "..\.." /I "..\..\..\zlib" /D "WIN32" /D "NDEBUG" /D "PNG_NO_STDIO" /D "PNG_NO_GLOBAL_ARRAYS" /FD /c
 # SUBTRACT BASE CPP /YX
-# ADD CPP /nologo /MD /W3 /O2 /I "..\.." /I "..\..\..\zlib" /D "WIN32" /D "NDEBUG" /D "PNG_NO_STDIO" /FD /c
+# ADD CPP /nologo /MD /W3 /O2 /I "..\.." /I "..\..\..\zlib" /D "WIN32" /D "NDEBUG" /D "PNG_NO_STDIO" /D "PNG_NO_GLOBAL_ARRAYS" /FD /c
 # SUBTRACT CPP /YX
 # ADD BASE MTL /nologo /D "NDEBUG" /mktyplib203 /win32
 # ADD MTL /nologo /D "NDEBUG" /mktyplib203 /win32
@@ -77,9 +77,9 @@ PostBuild_Cmds=$(outdir)\VisualPng.exe ..\..\contrib\pngsuite\basn6a16.png
 # PROP Intermediate_Dir "Debug"
 # PROP Ignore_Export_Lib 0
 # PROP Target_Dir ""
-# ADD BASE CPP /nologo /W3 /Gm /ZI /Od /I "..\.." /I "..\..\..\zlib" /D "WIN32" /D "_DEBUG" /D "PNG_NO_STDIO" /FD /GZ /c
+# ADD BASE CPP /nologo /W3 /Gm /ZI /Od /I "..\.." /I "..\..\..\zlib" /D "WIN32" /D "_DEBUG" /D "PNG_NO_STDIO" /D "PNG_NO_GLOBAL_ARRAYS" /FD /GZ /c
 # SUBTRACT BASE CPP /YX
-# ADD CPP /nologo /MDd /W3 /Gm /ZI /Od /I "..\.." /I "..\..\..\zlib" /D "WIN32" /D "_DEBUG" /D "PNG_NO_STDIO" /FD /GZ /c
+# ADD CPP /nologo /MDd /W3 /Gm /ZI /Od /I "..\.." /I "..\..\..\zlib" /D "WIN32" /D "_DEBUG" /D "PNG_NO_STDIO" /D "PNG_NO_GLOBAL_ARRAYS" /FD /GZ /c
 # SUBTRACT CPP /YX
 # ADD BASE MTL /nologo /D "_DEBUG" /mktyplib203 /win32
 # ADD MTL /nologo /D "_DEBUG" /mktyplib203 /win32

contrib/visupng/resource.h

@@ -12,7 +12,7 @@
 #define IDM_HELP_ABOUT                  40008
 
 // Next default values for new objects
-//
+// 
 #ifdef APSTUDIO_INVOKED
 #ifndef APSTUDIO_READONLY_SYMBOLS
 #define _APS_NEXT_RESOURCE_VALUE        113

depcomp

@@ -0,0 +1,630 @@
+#! /bin/sh
+# depcomp - compile a program generating dependencies as side-effects
+
+scriptversion=2009-04-28.21; # UTC
+
+# Copyright (C) 1999, 2000, 2003, 2004, 2005, 2006, 2007, 2009 Free
+# Software Foundation, Inc.
+
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2, or (at your option)
+# any later version.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+# As a special exception to the GNU General Public License, if you
+# distribute this file as part of a program that contains a
+# configuration script generated by Autoconf, you may include it under
+# the same distribution terms that you use for the rest of that program.
+
+# Originally written by Alexandre Oliva <oliva@dcc.unicamp.br>.
+
+case $1 in
+  '')
+     echo "$0: No command.  Try \`$0 --help' for more information." 1>&2
+     exit 1;
+     ;;
+  -h | --h*)
+    cat <<\EOF
+Usage: depcomp [--help] [--version] PROGRAM [ARGS]
+
+Run PROGRAMS ARGS to compile a file, generating dependencies
+as side-effects.
+
+Environment variables:
+  depmode     Dependency tracking mode.
+  source      Source file read by `PROGRAMS ARGS'.
+  object      Object file output by `PROGRAMS ARGS'.
+  DEPDIR      directory where to store dependencies.
+  depfile     Dependency file to output.
+  tmpdepfile  Temporary file to use when outputing dependencies.
+  libtool     Whether libtool is used (yes/no).
+
+Report bugs to <bug-automake@gnu.org>.
+EOF
+    exit $?
+    ;;
+  -v | --v*)
+    echo "depcomp $scriptversion"
+    exit $?
+    ;;
+esac
+
+if test -z "$depmode" || test -z "$source" || test -z "$object"; then
+  echo "depcomp: Variables source, object and depmode must be set" 1>&2
+  exit 1
+fi
+
+# Dependencies for sub/bar.o or sub/bar.obj go into sub/.deps/bar.Po.
+depfile=${depfile-`echo "$object" |
+  sed 's|[^\\/]*$|'${DEPDIR-.deps}'/&|;s|\.\([^.]*\)$|.P\1|;s|Pobj$|Po|'`}
+tmpdepfile=${tmpdepfile-`echo "$depfile" | sed 's/\.\([^.]*\)$/.T\1/'`}
+
+rm -f "$tmpdepfile"
+
+# Some modes work just like other modes, but use different flags.  We
+# parameterize here, but still list the modes in the big case below,
+# to make depend.m4 easier to write.  Note that we *cannot* use a case
+# here, because this file can only contain one case statement.
+if test "$depmode" = hp; then
+  # HP compiler uses -M and no extra arg.
+  gccflag=-M
+  depmode=gcc
+fi
+
+if test "$depmode" = dashXmstdout; then
+   # This is just like dashmstdout with a different argument.
+   dashmflag=-xM
+   depmode=dashmstdout
+fi
+
+cygpath_u="cygpath -u -f -"
+if test "$depmode" = msvcmsys; then
+   # This is just like msvisualcpp but w/o cygpath translation.
+   # Just convert the backslash-escaped backslashes to single forward
+   # slashes to satisfy depend.m4
+   cygpath_u="sed s,\\\\\\\\,/,g"
+   depmode=msvisualcpp
+fi
+
+case "$depmode" in
+gcc3)
+## gcc 3 implements dependency tracking that does exactly what
+## we want.  Yay!  Note: for some reason libtool 1.4 doesn't like
+## it if -MD -MP comes after the -MF stuff.  Hmm.
+## Unfortunately, FreeBSD c89 acceptance of flags depends upon
+## the command line argument order; so add the flags where they
+## appear in depend2.am.  Note that the slowdown incurred here
+## affects only configure: in makefiles, %FASTDEP% shortcuts this.
+  for arg
+  do
+    case $arg in
+    -c) set fnord "$@" -MT "$object" -MD -MP -MF "$tmpdepfile" "$arg" ;;
+    *)  set fnord "$@" "$arg" ;;
+    esac
+    shift # fnord
+    shift # $arg
+  done
+  "$@"
+  stat=$?
+  if test $stat -eq 0; then :
+  else
+    rm -f "$tmpdepfile"
+    exit $stat
+  fi
+  mv "$tmpdepfile" "$depfile"
+  ;;
+
+gcc)
+## There are various ways to get dependency output from gcc.  Here's
+## why we pick this rather obscure method:
+## - Don't want to use -MD because we'd like the dependencies to end
+##   up in a subdir.  Having to rename by hand is ugly.
+##   (We might end up doing this anyway to support other compilers.)
+## - The DEPENDENCIES_OUTPUT environment variable makes gcc act like
+##   -MM, not -M (despite what the docs say).
+## - Using -M directly means running the compiler twice (even worse
+##   than renaming).
+  if test -z "$gccflag"; then
+    gccflag=-MD,
+  fi
+  "$@" -Wp,"$gccflag$tmpdepfile"
+  stat=$?
+  if test $stat -eq 0; then :
+  else
+    rm -f "$tmpdepfile"
+    exit $stat
+  fi
+  rm -f "$depfile"
+  echo "$object : \\" > "$depfile"
+  alpha=ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz
+## The second -e expression handles DOS-style file names with drive letters.
+  sed -e 's/^[^:]*: / /' \
+      -e 's/^['$alpha']:\/[^:]*: / /' < "$tmpdepfile" >> "$depfile"
+## This next piece of magic avoids the `deleted header file' problem.
+## The problem is that when a header file which appears in a .P file
+## is deleted, the dependency causes make to die (because there is
+## typically no way to rebuild the header).  We avoid this by adding
+## dummy dependencies for each header file.  Too bad gcc doesn't do
+## this for us directly.
+  tr ' ' '
+' < "$tmpdepfile" |
+## Some versions of gcc put a space before the `:'.  On the theory
+## that the space means something, we add a space to the output as
+## well.
+## Some versions of the HPUX 10.20 sed can't process this invocation
+## correctly.  Breaking it into two sed invocations is a workaround.
+    sed -e 's/^\\$//' -e '/^$/d' -e '/:$/d' | sed -e 's/$/ :/' >> "$depfile"
+  rm -f "$tmpdepfile"
+  ;;
+
+hp)
+  # This case exists only to let depend.m4 do its work.  It works by
+  # looking at the text of this script.  This case will never be run,
+  # since it is checked for above.
+  exit 1
+  ;;
+
+sgi)
+  if test "$libtool" = yes; then
+    "$@" "-Wp,-MDupdate,$tmpdepfile"
+  else
+    "$@" -MDupdate "$tmpdepfile"
+  fi
+  stat=$?
+  if test $stat -eq 0; then :
+  else
+    rm -f "$tmpdepfile"
+    exit $stat
+  fi
+  rm -f "$depfile"
+
+  if test -f "$tmpdepfile"; then  # yes, the sourcefile depend on other files
+    echo "$object : \\" > "$depfile"
+
+    # Clip off the initial element (the dependent).  Don't try to be
+    # clever and replace this with sed code, as IRIX sed won't handle
+    # lines with more than a fixed number of characters (4096 in
+    # IRIX 6.2 sed, 8192 in IRIX 6.5).  We also remove comment lines;
+    # the IRIX cc adds comments like `#:fec' to the end of the
+    # dependency line.
+    tr ' ' '
+' < "$tmpdepfile" \
+    | sed -e 's/^.*\.o://' -e 's/#.*$//' -e '/^$/ d' | \
+    tr '
+' ' ' >> "$depfile"
+    echo >> "$depfile"
+
+    # The second pass generates a dummy entry for each header file.
+    tr ' ' '
+' < "$tmpdepfile" \
+   | sed -e 's/^.*\.o://' -e 's/#.*$//' -e '/^$/ d' -e 's/$/:/' \
+   >> "$depfile"
+  else
+    # The sourcefile does not contain any dependencies, so just
+    # store a dummy comment line, to avoid errors with the Makefile
+    # "include basename.Plo" scheme.
+    echo "#dummy" > "$depfile"
+  fi
+  rm -f "$tmpdepfile"
+  ;;
+
+aix)
+  # The C for AIX Compiler uses -M and outputs the dependencies
+  # in a .u file.  In older versions, this file always lives in the
+  # current directory.  Also, the AIX compiler puts `$object:' at the
+  # start of each line; $object doesn't have directory information.
+  # Version 6 uses the directory in both cases.
+  dir=`echo "$object" | sed -e 's|/[^/]*$|/|'`
+  test "x$dir" = "x$object" && dir=
+  base=`echo "$object" | sed -e 's|^.*/||' -e 's/\.o$//' -e 's/\.lo$//'`
+  if test "$libtool" = yes; then
+    tmpdepfile1=$dir$base.u
+    tmpdepfile2=$base.u
+    tmpdepfile3=$dir.libs/$base.u
+    "$@" -Wc,-M
+  else
+    tmpdepfile1=$dir$base.u
+    tmpdepfile2=$dir$base.u
+    tmpdepfile3=$dir$base.u
+    "$@" -M
+  fi
+  stat=$?
+
+  if test $stat -eq 0; then :
+  else
+    rm -f "$tmpdepfile1" "$tmpdepfile2" "$tmpdepfile3"
+    exit $stat
+  fi
+
+  for tmpdepfile in "$tmpdepfile1" "$tmpdepfile2" "$tmpdepfile3"
+  do
+    test -f "$tmpdepfile" && break
+  done
+  if test -f "$tmpdepfile"; then
+    # Each line is of the form `foo.o: dependent.h'.
+    # Do two passes, one to just change these to
+    # `$object: dependent.h' and one to simply `dependent.h:'.
+    sed -e "s,^.*\.[a-z]*:,$object:," < "$tmpdepfile" > "$depfile"
+    # That's a tab and a space in the [].
+    sed -e 's,^.*\.[a-z]*:[	 ]*,,' -e 's,$,:,' < "$tmpdepfile" >> "$depfile"
+  else
+    # The sourcefile does not contain any dependencies, so just
+    # store a dummy comment line, to avoid errors with the Makefile
+    # "include basename.Plo" scheme.
+    echo "#dummy" > "$depfile"
+  fi
+  rm -f "$tmpdepfile"
+  ;;
+
+icc)
+  # Intel's C compiler understands `-MD -MF file'.  However on
+  #    icc -MD -MF foo.d -c -o sub/foo.o sub/foo.c
+  # ICC 7.0 will fill foo.d with something like
+  #    foo.o: sub/foo.c
+  #    foo.o: sub/foo.h
+  # which is wrong.  We want:
+  #    sub/foo.o: sub/foo.c
+  #    sub/foo.o: sub/foo.h
+  #    sub/foo.c:
+  #    sub/foo.h:
+  # ICC 7.1 will output
+  #    foo.o: sub/foo.c sub/foo.h
+  # and will wrap long lines using \ :
+  #    foo.o: sub/foo.c ... \
+  #     sub/foo.h ... \
+  #     ...
+
+  "$@" -MD -MF "$tmpdepfile"
+  stat=$?
+  if test $stat -eq 0; then :
+  else
+    rm -f "$tmpdepfile"
+    exit $stat
+  fi
+  rm -f "$depfile"
+  # Each line is of the form `foo.o: dependent.h',
+  # or `foo.o: dep1.h dep2.h \', or ` dep3.h dep4.h \'.
+  # Do two passes, one to just change these to
+  # `$object: dependent.h' and one to simply `dependent.h:'.
+  sed "s,^[^:]*:,$object :," < "$tmpdepfile" > "$depfile"
+  # Some versions of the HPUX 10.20 sed can't process this invocation
+  # correctly.  Breaking it into two sed invocations is a workaround.
+  sed 's,^[^:]*: \(.*\)$,\1,;s/^\\$//;/^$/d;/:$/d' < "$tmpdepfile" |
+    sed -e 's/$/ :/' >> "$depfile"
+  rm -f "$tmpdepfile"
+  ;;
+
+hp2)
+  # The "hp" stanza above does not work with aCC (C++) and HP's ia64
+  # compilers, which have integrated preprocessors.  The correct option
+  # to use with these is +Maked; it writes dependencies to a file named
+  # 'foo.d', which lands next to the object file, wherever that
+  # happens to be.
+  # Much of this is similar to the tru64 case; see comments there.
+  dir=`echo "$object" | sed -e 's|/[^/]*$|/|'`
+  test "x$dir" = "x$object" && dir=
+  base=`echo "$object" | sed -e 's|^.*/||' -e 's/\.o$//' -e 's/\.lo$//'`
+  if test "$libtool" = yes; then
+    tmpdepfile1=$dir$base.d
+    tmpdepfile2=$dir.libs/$base.d
+    "$@" -Wc,+Maked
+  else
+    tmpdepfile1=$dir$base.d
+    tmpdepfile2=$dir$base.d
+    "$@" +Maked
+  fi
+  stat=$?
+  if test $stat -eq 0; then :
+  else
+     rm -f "$tmpdepfile1" "$tmpdepfile2"
+     exit $stat
+  fi
+
+  for tmpdepfile in "$tmpdepfile1" "$tmpdepfile2"
+  do
+    test -f "$tmpdepfile" && break
+  done
+  if test -f "$tmpdepfile"; then
+    sed -e "s,^.*\.[a-z]*:,$object:," "$tmpdepfile" > "$depfile"
+    # Add `dependent.h:' lines.
+    sed -ne '2,${
+	       s/^ *//
+	       s/ \\*$//
+	       s/$/:/
+	       p
+	     }' "$tmpdepfile" >> "$depfile"
+  else
+    echo "#dummy" > "$depfile"
+  fi
+  rm -f "$tmpdepfile" "$tmpdepfile2"
+  ;;
+
+tru64)
+   # The Tru64 compiler uses -MD to generate dependencies as a side
+   # effect.  `cc -MD -o foo.o ...' puts the dependencies into `foo.o.d'.
+   # At least on Alpha/Redhat 6.1, Compaq CCC V6.2-504 seems to put
+   # dependencies in `foo.d' instead, so we check for that too.
+   # Subdirectories are respected.
+   dir=`echo "$object" | sed -e 's|/[^/]*$|/|'`
+   test "x$dir" = "x$object" && dir=
+   base=`echo "$object" | sed -e 's|^.*/||' -e 's/\.o$//' -e 's/\.lo$//'`
+
+   if test "$libtool" = yes; then
+      # With Tru64 cc, shared objects can also be used to make a
+      # static library.  This mechanism is used in libtool 1.4 series to
+      # handle both shared and static libraries in a single compilation.
+      # With libtool 1.4, dependencies were output in $dir.libs/$base.lo.d.
+      #
+      # With libtool 1.5 this exception was removed, and libtool now
+      # generates 2 separate objects for the 2 libraries.  These two
+      # compilations output dependencies in $dir.libs/$base.o.d and
+      # in $dir$base.o.d.  We have to check for both files, because
+      # one of the two compilations can be disabled.  We should prefer
+      # $dir$base.o.d over $dir.libs/$base.o.d because the latter is
+      # automatically cleaned when .libs/ is deleted, while ignoring
+      # the former would cause a distcleancheck panic.
+      tmpdepfile1=$dir.libs/$base.lo.d   # libtool 1.4
+      tmpdepfile2=$dir$base.o.d          # libtool 1.5
+      tmpdepfile3=$dir.libs/$base.o.d    # libtool 1.5
+      tmpdepfile4=$dir.libs/$base.d      # Compaq CCC V6.2-504
+      "$@" -Wc,-MD
+   else
+      tmpdepfile1=$dir$base.o.d
+      tmpdepfile2=$dir$base.d
+      tmpdepfile3=$dir$base.d
+      tmpdepfile4=$dir$base.d
+      "$@" -MD
+   fi
+
+   stat=$?
+   if test $stat -eq 0; then :
+   else
+      rm -f "$tmpdepfile1" "$tmpdepfile2" "$tmpdepfile3" "$tmpdepfile4"
+      exit $stat
+   fi
+
+   for tmpdepfile in "$tmpdepfile1" "$tmpdepfile2" "$tmpdepfile3" "$tmpdepfile4"
+   do
+     test -f "$tmpdepfile" && break
+   done
+   if test -f "$tmpdepfile"; then
+      sed -e "s,^.*\.[a-z]*:,$object:," < "$tmpdepfile" > "$depfile"
+      # That's a tab and a space in the [].
+      sed -e 's,^.*\.[a-z]*:[	 ]*,,' -e 's,$,:,' < "$tmpdepfile" >> "$depfile"
+   else
+      echo "#dummy" > "$depfile"
+   fi
+   rm -f "$tmpdepfile"
+   ;;
+
+#nosideeffect)
+  # This comment above is used by automake to tell side-effect
+  # dependency tracking mechanisms from slower ones.
+
+dashmstdout)
+  # Important note: in order to support this mode, a compiler *must*
+  # always write the preprocessed file to stdout, regardless of -o.
+  "$@" || exit $?
+
+  # Remove the call to Libtool.
+  if test "$libtool" = yes; then
+    while test "X$1" != 'X--mode=compile'; do
+      shift
+    done
+    shift
+  fi
+
+  # Remove `-o $object'.
+  IFS=" "
+  for arg
+  do
+    case $arg in
+    -o)
+      shift
+      ;;
+    $object)
+      shift
+      ;;
+    *)
+      set fnord "$@" "$arg"
+      shift # fnord
+      shift # $arg
+      ;;
+    esac
+  done
+
+  test -z "$dashmflag" && dashmflag=-M
+  # Require at least two characters before searching for `:'
+  # in the target name.  This is to cope with DOS-style filenames:
+  # a dependency such as `c:/foo/bar' could be seen as target `c' otherwise.
+  "$@" $dashmflag |
+    sed 's:^[  ]*[^: ][^:][^:]*\:[    ]*:'"$object"'\: :' > "$tmpdepfile"
+  rm -f "$depfile"
+  cat < "$tmpdepfile" > "$depfile"
+  tr ' ' '
+' < "$tmpdepfile" | \
+## Some versions of the HPUX 10.20 sed can't process this invocation
+## correctly.  Breaking it into two sed invocations is a workaround.
+    sed -e 's/^\\$//' -e '/^$/d' -e '/:$/d' | sed -e 's/$/ :/' >> "$depfile"
+  rm -f "$tmpdepfile"
+  ;;
+
+dashXmstdout)
+  # This case only exists to satisfy depend.m4.  It is never actually
+  # run, as this mode is specially recognized in the preamble.
+  exit 1
+  ;;
+
+makedepend)
+  "$@" || exit $?
+  # Remove any Libtool call
+  if test "$libtool" = yes; then
+    while test "X$1" != 'X--mode=compile'; do
+      shift
+    done
+    shift
+  fi
+  # X makedepend
+  shift
+  cleared=no eat=no
+  for arg
+  do
+    case $cleared in
+    no)
+      set ""; shift
+      cleared=yes ;;
+    esac
+    if test $eat = yes; then
+      eat=no
+      continue
+    fi
+    case "$arg" in
+    -D*|-I*)
+      set fnord "$@" "$arg"; shift ;;
+    # Strip any option that makedepend may not understand.  Remove
+    # the object too, otherwise makedepend will parse it as a source file.
+    -arch)
+      eat=yes ;;
+    -*|$object)
+      ;;
+    *)
+      set fnord "$@" "$arg"; shift ;;
+    esac
+  done
+  obj_suffix=`echo "$object" | sed 's/^.*\././'`
+  touch "$tmpdepfile"
+  ${MAKEDEPEND-makedepend} -o"$obj_suffix" -f"$tmpdepfile" "$@"
+  rm -f "$depfile"
+  cat < "$tmpdepfile" > "$depfile"
+  sed '1,2d' "$tmpdepfile" | tr ' ' '
+' | \
+## Some versions of the HPUX 10.20 sed can't process this invocation
+## correctly.  Breaking it into two sed invocations is a workaround.
+    sed -e 's/^\\$//' -e '/^$/d' -e '/:$/d' | sed -e 's/$/ :/' >> "$depfile"
+  rm -f "$tmpdepfile" "$tmpdepfile".bak
+  ;;
+
+cpp)
+  # Important note: in order to support this mode, a compiler *must*
+  # always write the preprocessed file to stdout.
+  "$@" || exit $?
+
+  # Remove the call to Libtool.
+  if test "$libtool" = yes; then
+    while test "X$1" != 'X--mode=compile'; do
+      shift
+    done
+    shift
+  fi
+
+  # Remove `-o $object'.
+  IFS=" "
+  for arg
+  do
+    case $arg in
+    -o)
+      shift
+      ;;
+    $object)
+      shift
+      ;;
+    *)
+      set fnord "$@" "$arg"
+      shift # fnord
+      shift # $arg
+      ;;
+    esac
+  done
+
+  "$@" -E |
+    sed -n -e '/^# [0-9][0-9]* "\([^"]*\)".*/ s:: \1 \\:p' \
+       -e '/^#line [0-9][0-9]* "\([^"]*\)".*/ s:: \1 \\:p' |
+    sed '$ s: \\$::' > "$tmpdepfile"
+  rm -f "$depfile"
+  echo "$object : \\" > "$depfile"
+  cat < "$tmpdepfile" >> "$depfile"
+  sed < "$tmpdepfile" '/^$/d;s/^ //;s/ \\$//;s/$/ :/' >> "$depfile"
+  rm -f "$tmpdepfile"
+  ;;
+
+msvisualcpp)
+  # Important note: in order to support this mode, a compiler *must*
+  # always write the preprocessed file to stdout.
+  "$@" || exit $?
+
+  # Remove the call to Libtool.
+  if test "$libtool" = yes; then
+    while test "X$1" != 'X--mode=compile'; do
+      shift
+    done
+    shift
+  fi
+
+  IFS=" "
+  for arg
+  do
+    case "$arg" in
+    -o)
+      shift
+      ;;
+    $object)
+      shift
+      ;;
+    "-Gm"|"/Gm"|"-Gi"|"/Gi"|"-ZI"|"/ZI")
+	set fnord "$@"
+	shift
+	shift
+	;;
+    *)
+	set fnord "$@" "$arg"
+	shift
+	shift
+	;;
+    esac
+  done
+  "$@" -E 2>/dev/null |
+  sed -n '/^#line [0-9][0-9]* "\([^"]*\)"/ s::\1:p' | $cygpath_u | sort -u > "$tmpdepfile"
+  rm -f "$depfile"
+  echo "$object : \\" > "$depfile"
+  sed < "$tmpdepfile" -n -e 's% %\\ %g' -e '/^\(.*\)$/ s::	\1 \\:p' >> "$depfile"
+  echo "	" >> "$depfile"
+  sed < "$tmpdepfile" -n -e 's% %\\ %g' -e '/^\(.*\)$/ s::\1\::p' >> "$depfile"
+  rm -f "$tmpdepfile"
+  ;;
+
+msvcmsys)
+  # This case exists only to let depend.m4 do its work.  It works by
+  # looking at the text of this script.  This case will never be run,
+  # since it is checked for above.
+  exit 1
+  ;;
+
+none)
+  exec "$@"
+  ;;
+
+*)
+  echo "Unknown depmode $depmode" 1>&2
+  exit 1
+  ;;
+esac
+
+exit 0
+
+# Local Variables:
+# mode: shell-script
+# sh-indentation: 2
+# eval: (add-hook 'write-file-hooks 'time-stamp)
+# time-stamp-start: "scriptversion="
+# time-stamp-format: "%:y-%02m-%02d.%02H"
+# time-stamp-time-zone: "UTC"
+# time-stamp-end: "; # UTC"
+# End:

example.c

@@ -2,17 +2,15 @@
 #if 0 /* in case someone actually tries to compile this */
 
 /* example.c - an example of using libpng
- * Last changed in libpng 1.6.0 [February 14, 2013]
- * Maintained 1998-2013 Glenn Randers-Pehrson
+ * Last changed in libpng 1.2.37 [June 4, 2009]
+ * This file has been placed in the public domain by the authors.
+ * Maintained 1998-2009 Glenn Randers-Pehrson
  * Maintained 1996, 1997 Andreas Dilger)
  * Written 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
- * To the extent possible under law, the authors have waived
- * all copyright and related or neighboring rights to this file.
- * This work is published from: United States.
  */
 
 /* This is an example of how to use libpng to read and write PNG files.
- * The file libpng-manual.txt is much more verbose then this.  If you have not
+ * The file libpng.txt is much more verbose then this.  If you have not
  * read it, do so first.  This was designed to be a starting point of an
  * implementation.  This is not officially part of libpng, is hereby placed
  * in the public domain, and therefore does not require a copyright notice.
@@ -24,192 +22,7 @@
  * see also the programs in the contrib directory.
  */
 
-/* The simple, but restricted, approach to reading a PNG file or data stream
- * just requires two function calls, as in the following complete program.
- * Writing a file just needs one function call, so long as the data has an
- * appropriate layout.
- *
- * The following code reads PNG image data from a file and writes it, in a
- * potentially new format, to a new file.  While this code will compile there is
- * minimal (insufficient) error checking; for a more realistic version look at
- * contrib/examples/pngtopng.c
- */
-#include <stddef.h>
-#include <stdlib.h>
-#include <string.h>
-#include <stdio.h>
-#include <png.h>
-#include <zlib.h>
-
-int main(int argc, const char **argv)
-{
-   if (argc == 3)
-   {
-      png_image image; /* The control structure used by libpng */
-
-      /* Initialize the 'png_image' structure. */
-      memset(&image, 0, (sizeof image));
-      image.version = PNG_IMAGE_VERSION;
-
-      /* The first argument is the file to read: */
-      if (png_image_begin_read_from_file(&image, argv[1]))
-      {
-         png_bytep buffer;
-
-         /* Set the format in which to read the PNG file; this code chooses a
-          * simple sRGB format with a non-associated alpha channel, adequate to
-          * store most images.
-          */
-         image.format = PNG_FORMAT_RGBA;
-
-         /* Now allocate enough memory to hold the image in this format; the
-          * PNG_IMAGE_SIZE macro uses the information about the image (width,
-          * height and format) stored in 'image'.
-          */
-         buffer = malloc(PNG_IMAGE_SIZE(image));
-
-         /* If enough memory was available read the image in the desired format
-          * then write the result out to the new file.  'background' is not
-          * necessary when reading the image because the alpha channel is
-          * preserved; if it were to be removed, for example if we requested
-          * PNG_FORMAT_RGB, then either a solid background color would have to
-          * be supplied or the output buffer would have to be initialized to the
-          * actual background of the image.
-          *
-          * The fourth argument to png_image_finish_read is the 'row_stride' -
-          * this is the number of components allocated for the image in each
-          * row.  It has to be at least as big as the value returned by
-          * PNG_IMAGE_ROW_STRIDE, but if you just allocate space for the
-          * default, minimum, size using PNG_IMAGE_SIZE as above you can pass
-          * zero.
-          *
-          * The final argument is a pointer to a buffer for the colormap;
-          * colormaps have exactly the same format as a row of image pixels (so
-          * you choose what format to make the colormap by setting
-          * image.format).  A colormap is only returned if
-          * PNG_FORMAT_FLAG_COLORMAP is also set in image.format, so in this
-          * case NULL is passed as the final argument.  If you do want to force
-          * all images into an index/color-mapped format then you can use:
-          *
-          *    PNG_IMAGE_COLORMAP_SIZE(image)
-          *
-          * to find the maximum size of the colormap in bytes.
-          */
-         if (buffer != NULL &&
-            png_image_finish_read(&image, NULL/*background*/, buffer,
-               0/*row_stride*/, NULL/*colormap*/))
-         {
-            /* Now write the image out to the second argument.  In the write
-             * call 'convert_to_8bit' allows 16-bit data to be squashed down to
-             * 8 bits; this isn't necessary here because the original read was
-             * to the 8-bit format.
-             */
-            if (png_image_write_to_file(&image, argv[2], 0/*convert_to_8bit*/,
-               buffer, 0/*row_stride*/, NULL/*colormap*/))
-            {
-               /* The image has been written successfully. */
-               exit(0);
-            }
-         }
-
-         else
-         {
-            /* Calling png_free_image is optional unless the simplified API was
-             * not run to completion.  In this case if there wasn't enough
-             * memory for 'buffer' we didn't complete the read, so we must free
-             * the image:
-             */
-            if (buffer == NULL)
-               png_free_image(&image);
-
-            else
-               free(buffer);
-      }
-
-      /* Something went wrong reading or writing the image.  libpng stores a
-       * textual message in the 'png_image' structure:
-       */
-      fprintf(stderr, "pngtopng: error: %s\n", image.message);
-      exit (1);
-   }
-
-   fprintf(stderr, "pngtopng: usage: pngtopng input-file output-file\n");
-   exit(1);
-}
-
-/* That's it ;-)  Of course you probably want to do more with PNG files than
- * just converting them all to 32-bit RGBA PNG files; you can do that between
- * the call to png_image_finish_read and png_image_write_to_file.  You can also
- * ask for the image data to be presented in a number of different formats.  You
- * do this by simply changing the 'format' parameter set before allocating the
- * buffer.
- *
- * The format parameter consists of five flags that define various aspects of
- * the image, you can simply add these together to get the format or you can use
- * one of the predefined macros from png.h (as above):
- *
- * PNG_FORMAT_FLAG_COLOR: if set the image will have three color components per
- *    pixel (red, green and blue), if not set the image will just have one
- *    luminance (grayscale) component.
- *
- * PNG_FORMAT_FLAG_ALPHA: if set each pixel in the image will have an additional
- *    alpha value; a linear value that describes the degree the image pixel
- *    covers (overwrites) the contents of the existing pixel on the display.
- *
- * PNG_FORMAT_FLAG_LINEAR: if set the components of each pixel will be returned
- *    as a series of 16-bit linear values, if not set the components will be
- *    returned as a series of 8-bit values encoded according to the 'sRGB'
- *    standard.  The 8-bit format is the normal format for images intended for
- *    direct display, because almost all display devices do the inverse of the
- *    sRGB transformation to the data they receive.  The 16-bit format is more
- *    common for scientific data and image data that must be further processed;
- *    because it is linear simple math can be done on the component values.
- *    Regardless of the setting of this flag the alpha channel is always linear,
- *    although it will be 8 bits or 16 bits wide as specified by the flag.
- *
- * PNG_FORMAT_FLAG_BGR: if set the components of a color pixel will be returned
- *    in the order blue, then green, then red.  If not set the pixel components
- *    are in the order red, then green, then blue.
- *
- * PNG_FORMAT_FLAG_AFIRST: if set the alpha channel (if present) precedes the
- *    color or grayscale components.  If not set the alpha channel follows the
- *    components.
- *
- * You do not have to read directly from a file.  You can read from memory or,
- * on systems that support it, from a <stdio.h> FILE*.  This is controlled by
- * the particular png_image_read_from_ function you call at the start.  Likewise
- * on write you can write to a FILE* if your system supports it.  Check the
- * macro PNG_STDIO_SUPPORTED to see if stdio support has been included in your
- * libpng build.
- *
- * If you read 16-bit (PNG_FORMAT_FLAG_LINEAR) data you may need to write it in
- * the 8-bit format for display.  You do this by setting the convert_to_8bit
- * flag to 'true'.
- *
- * Don't repeatedly convert between the 8-bit and 16-bit forms.  There is
- * significant data loss when 16-bit data is converted to the 8-bit encoding and
- * the current libpng implementation of convertion to 16-bit is also
- * significantly lossy.  The latter will be fixed in the future, but the former
- * is unavoidable - the 8-bit format just doesn't have enough resolution.
- */
-
-/* If your program needs more information from the PNG data it reads, or if you
- * need to do more complex transformations, or minimise transformations, on the
- * data you read, then you must use one of the several lower level libpng
- * interfaces.
- *
- * All these interfaces require that you do your own error handling - your
- * program must be able to arrange for control to return to your own code any
- * time libpng encounters a problem.  There are several ways to do this, but the
- * standard way is to use the ANSI-C (C90) <setjmp.h> interface to establish a
- * return point within your own code.  You must do this if you do not use the
- * simplified interface (above).
- *
- * The first step is to include the header files you need, including the libpng
- * header file.  Include any standard headers and feature test macros your
- * program requires before including png.h:
- */
-#include <png.h>
+#include "png.h"
 
  /* The png_jmpbuf() macro, used in error handling, became available in
   * libpng version 1.0.6.  If you want to be able to run your code with older
@@ -218,7 +31,7 @@ int main(int argc, const char **argv)
   */
 
 #ifndef png_jmpbuf
-#  define png_jmpbuf(png_ptr) ((png_ptr)->png_jmpbuf)
+#  define png_jmpbuf(png_ptr) ((png_ptr)->jmpbuf)
 #endif
 
 /* Check to see if a file is a PNG file using png_sig_cmp().  png_sig_cmp()
@@ -308,7 +121,7 @@ void read_png(FILE *fp, unsigned int sig_read)  /* File is already open */
    if (info_ptr == NULL)
    {
       fclose(fp);
-      png_destroy_read_struct(&png_ptr, NULL, NULL);
+      png_destroy_read_struct(&png_ptr, png_infopp_NULL, png_infopp_NULL);
       return (ERROR);
    }
 
@@ -320,7 +133,7 @@ void read_png(FILE *fp, unsigned int sig_read)  /* File is already open */
    if (setjmp(png_jmpbuf(png_ptr)))
    {
       /* Free all of the memory associated with the png_ptr and info_ptr */
-      png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
+      png_destroy_read_struct(&png_ptr, &info_ptr, png_infopp_NULL);
       fclose(fp);
       /* If we get here, we had a problem reading the file */
       return (ERROR);
@@ -347,11 +160,11 @@ void read_png(FILE *fp, unsigned int sig_read)  /* File is already open */
     * If you have enough memory to read in the entire image at once,
     * and you need to specify only transforms that can be controlled
     * with one of the PNG_TRANSFORM_* bits (this presently excludes
-    * quantizing, filling, setting background, and doing gamma
+    * dithering, filling, setting background, and doing gamma
     * adjustment), then you can read the entire image (including
     * pixels) into the info structure with this call:
     */
-   png_read_png(png_ptr, info_ptr, png_transforms, NULL);
+   png_read_png(png_ptr, info_ptr, png_transforms, png_voidp_NULL);
 
 #else
    /* OK, you're doing it the hard way, with the lower-level functions */
@@ -362,7 +175,7 @@ void read_png(FILE *fp, unsigned int sig_read)  /* File is already open */
    png_read_info(png_ptr, info_ptr);
 
    png_get_IHDR(png_ptr, info_ptr, &width, &height, &bit_depth, &color_type,
-       &interlace_type, NULL, NULL);
+       &interlace_type, int_p_NULL, int_p_NULL);
 
    /* Set up the data transformations you want.  Note that these are all
     * optional.  Only call them if you want/need them.  Many of the
@@ -370,15 +183,8 @@ void read_png(FILE *fp, unsigned int sig_read)  /* File is already open */
     * are mutually exclusive.
     */
 
-   /* Tell libpng to strip 16 bit/color files down to 8 bits/color.
-    * Use accurate scaling if it's available, otherwise just chop off the
-    * low byte.
-    */
-#ifdef PNG_READ_SCALE_16_TO_8_SUPPORTED
-    png_set_scale_16(png_ptr);
-#else
+   /* Tell libpng to strip 16 bit/color files down to 8 bits/color */
    png_set_strip_16(png_ptr);
-#endif
 
    /* Strip alpha bytes from the input data without combining with the
     * background (not recommended).
@@ -465,8 +271,7 @@ void read_png(FILE *fp, unsigned int sig_read)  /* File is already open */
          png_set_gamma(png_ptr, screen_gamma, 0.45455);
    }
 
-#ifdef PNG_READ_QUANTIZE_SUPPORTED
-   /* Quantize RGB files down to 8 bit palette or reduce palettes
+   /* Dither RGB files down to 8 bit palette or reduce palettes
     * to the number of colors available on your screen.
     */
    if (color_type & PNG_COLOR_MASK_COLOR)
@@ -477,11 +282,11 @@ void read_png(FILE *fp, unsigned int sig_read)  /* File is already open */
       /* This reduces the image to the application supplied palette */
       if (/* We have our own palette */)
       {
-         /* An array of colors to which the image should be quantized */
+         /* An array of colors to which the image should be dithered */
          png_color std_color_cube[MAX_SCREEN_COLORS];
 
-         png_set_quantize(png_ptr, std_color_cube, MAX_SCREEN_COLORS,
-            MAX_SCREEN_COLORS, NULL, 0);
+         png_set_dither(png_ptr, std_color_cube, MAX_SCREEN_COLORS,
+            MAX_SCREEN_COLORS, png_uint_16p_NULL, 0);
       }
       /* This reduces the image to the palette supplied in the file */
       else if (png_get_PLTE(png_ptr, info_ptr, &palette, &num_palette))
@@ -490,11 +295,10 @@ void read_png(FILE *fp, unsigned int sig_read)  /* File is already open */
 
          png_get_hIST(png_ptr, info_ptr, &histogram);
 
-         png_set_quantize(png_ptr, palette, num_palette,
+         png_set_dither(png_ptr, palette, num_palette,
                         max_screen_colors, histogram, 0);
       }
    }
-#endif /* PNG_READ_QUANTIZE_SUPPORTED */
 
    /* Invert monochrome files to have 0 as white and 1 as black */
    png_set_invert_mono(png_ptr);
@@ -524,16 +328,11 @@ void read_png(FILE *fp, unsigned int sig_read)  /* File is already open */
    /* Add filler (or alpha) byte (before/after each RGB triplet) */
    png_set_filler(png_ptr, 0xff, PNG_FILLER_AFTER);
 
-#ifdef PNG_READ_INTERLACING_SUPPORTED
    /* Turn on interlace handling.  REQUIRED if you are not using
     * png_read_image().  To see how to handle interlacing passes,
     * see the png_read_row() method below:
     */
    number_passes = png_set_interlace_handling(png_ptr);
-#else
-   number_passes = 1;
-#endif /* PNG_READ_INTERLACING_SUPPORTED */
-
 
    /* Optional call to gamma correct and add the background to the palette
     * and update info structure.  REQUIRED if you are expecting libpng to
@@ -566,17 +365,17 @@ void read_png(FILE *fp, unsigned int sig_read)  /* File is already open */
 #ifdef single /* Read the image a single row at a time */
       for (y = 0; y < height; y++)
       {
-         png_read_rows(png_ptr, &row_pointers[y], NULL, 1);
+         png_read_rows(png_ptr, &row_pointers[y], png_bytepp_NULL, 1);
       }
 
 #else no_single /* Read the image several rows at a time */
       for (y = 0; y < height; y += number_of_rows)
       {
 #ifdef sparkle /* Read the image using the "sparkle" effect. */
-         png_read_rows(png_ptr, &row_pointers[y], NULL,
+         png_read_rows(png_ptr, &row_pointers[y], png_bytepp_NULL,
             number_of_rows);
 #else no_sparkle /* Read the image using the "rectangle" effect */
-         png_read_rows(png_ptr, NULL, &row_pointers[y],
+         png_read_rows(png_ptr, png_bytepp_NULL, &row_pointers[y],
             number_of_rows);
 #endif no_sparkle /* Use only one of these two methods */
       }
@@ -593,7 +392,7 @@ void read_png(FILE *fp, unsigned int sig_read)  /* File is already open */
    /* At this point you have read the entire image */
 
    /* Clean up after the read, and free any memory allocated - REQUIRED */
-   png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
+   png_destroy_read_struct(&png_ptr, &info_ptr, png_infopp_NULL);
 
    /* Close the file */
    fclose(fp);
@@ -626,13 +425,13 @@ initialize_png_reader(png_structp *png_ptr, png_infop *info_ptr)
 
    if (*info_ptr == NULL)
    {
-      png_destroy_read_struct(png_ptr, info_ptr, NULL);
+      png_destroy_read_struct(png_ptr, info_ptr, png_infopp_NULL);
       return (ERROR);
    }
 
    if (setjmp(png_jmpbuf((*png_ptr))))
    {
-      png_destroy_read_struct(png_ptr, info_ptr, NULL);
+      png_destroy_read_struct(png_ptr, info_ptr, png_infopp_NULL);
       return (ERROR);
    }
 
@@ -661,7 +460,7 @@ process_data(png_structp *png_ptr, png_infop *info_ptr,
    if (setjmp(png_jmpbuf((*png_ptr))))
    {
       /* Free the png_ptr and info_ptr memory on error */
-      png_destroy_read_struct(png_ptr, info_ptr, NULL);
+      png_destroy_read_struct(png_ptr, info_ptr, png_infopp_NULL);
       return (ERROR);
    }
 
@@ -710,18 +509,20 @@ row_callback(png_structp png_ptr, png_bytep new_row,
     * shown below:
     */
 
-   /* Get pointer to corresponding row in our
-    * PNG read buffer.
-    */
-   png_bytep old_row = ((png_bytep *)our_data)[row_num];
-
-#ifdef PNG_READ_INTERLACING_SUPPORTED
-   /* If both rows are allocated then copy the new row
-    * data to the corresponding row data.
-    */
-   if ((old_row != NULL) && (new_row != NULL))
-   png_progressive_combine_row(png_ptr, old_row, new_row);
+   /* Check if row_num is in bounds. */
+   if ((row_num >= 0) && (row_num < height))
+   {
+     /* Get pointer to corresponding row in our
+      * PNG read buffer.
+      */
+     png_bytep old_row = ((png_bytep *)our_data)[row_num];
 
+     /* If both rows are allocated then copy the new row
+      * data to the corresponding row data.
+      */
+     if ((old_row != NULL) && (new_row != NULL))
+     png_progressive_combine_row(png_ptr, old_row, new_row);
+   }
    /*
     * The rows and passes are called in order, so you don't really
     * need the row_num and pass, but I'm supplying them because it
@@ -731,7 +532,7 @@ row_callback(png_structp png_ptr, png_bytep new_row,
     * png_progressive_combine_row() passing in the new row and the
     * old row, as demonstrated above.  You can call this function for
     * NULL rows (it will just return) and for non-interlaced images
-    * (it just does the memcpy for you) if it will make the code
+    * (it just does the png_memcpy for you) if it will make the code
     * easier.  Thus, you can just do this for all cases:
     */
 
@@ -744,7 +545,6 @@ row_callback(png_structp png_ptr, png_bytep new_row,
     * to pass the current row as new_row, and the function will combine
     * the old row and the new row.
     */
-#endif /* PNG_READ_INTERLACING_SUPPORTED */
 }
 
 end_callback(png_structp png_ptr, png_infop info)
@@ -793,7 +593,7 @@ void write_png(char *file_name /* , ... other image information ... */)
    if (info_ptr == NULL)
    {
       fclose(fp);
-      png_destroy_write_struct(&png_ptr,  NULL);
+      png_destroy_write_struct(&png_ptr,  png_infopp_NULL);
       return (ERROR);
    }
 
@@ -828,7 +628,7 @@ void write_png(char *file_name /* , ... other image information ... */)
     * image info living in the structure.  You could "|" many
     * PNG_TRANSFORM flags into the png_transforms integer here.
     */
-   png_write_png(png_ptr, info_ptr, png_transforms, NULL);
+   png_write_png(png_ptr, info_ptr, png_transforms, png_voidp_NULL);
 
 #else
    /* This is the hard way */
@@ -846,7 +646,7 @@ void write_png(char *file_name /* , ... other image information ... */)
 
    /* Set the palette if there is one.  REQUIRED for indexed-color images */
    palette = (png_colorp)png_malloc(png_ptr, PNG_MAX_PALETTE_LENGTH
-             * (sizeof (png_color)));
+             * png_sizeof(png_color));
    /* ... Set palette colors ... */
    png_set_PLTE(png_ptr, info_ptr, palette, PNG_MAX_PALETTE_LENGTH);
    /* You must not free palette here, because png_set_PLTE only makes a link to
@@ -856,18 +656,14 @@ void write_png(char *file_name /* , ... other image information ... */)
 
    /* Optional significant bit (sBIT) chunk */
    png_color_8 sig_bit;
-
    /* If we are dealing with a grayscale image then */
    sig_bit.gray = true_bit_depth;
-
    /* Otherwise, if we are dealing with a color image then */
    sig_bit.red = true_red_bit_depth;
    sig_bit.green = true_green_bit_depth;
    sig_bit.blue = true_blue_bit_depth;
-
    /* If the image has an alpha channel then */
    sig_bit.alpha = true_alpha_bit_depth;
-
    png_set_sBIT(png_ptr, info_ptr, &sig_bit);
 
 
@@ -877,38 +673,21 @@ void write_png(char *file_name /* , ... other image information ... */)
    png_set_gAMA(png_ptr, info_ptr, gamma);
 
    /* Optionally write comments into the image */
-   {
-      png_text text_ptr[3];
-
-      char key0[]="Title";
-      char text0[]="Mona Lisa";
-      text_ptr[0].key = key0;
-      text_ptr[0].text = text0;
-      text_ptr[0].compression = PNG_TEXT_COMPRESSION_NONE;
-      text_ptr[0].itxt_length = 0;
-      text_ptr[0].lang = NULL;
-      text_ptr[0].lang_key = NULL;
-
-      char key1[]="Author";
-      char text1[]="Leonardo DaVinci";
-      text_ptr[1].key = key1;
-      text_ptr[1].text = text1;
-      text_ptr[1].compression = PNG_TEXT_COMPRESSION_NONE;
-      text_ptr[1].itxt_length = 0;
-      text_ptr[1].lang = NULL;
-      text_ptr[1].lang_key = NULL;
-
-      char key2[]="Description";
-      char text2[]="<long text>";
-      text_ptr[2].key = key2;
-      text_ptr[2].text = text2;
-      text_ptr[2].compression = PNG_TEXT_COMPRESSION_zTXt;
-      text_ptr[2].itxt_length = 0;
-      text_ptr[2].lang = NULL;
-      text_ptr[2].lang_key = NULL;
-
-      png_set_text(write_ptr, write_info_ptr, text_ptr, 3);
-   }
+   text_ptr[0].key = "Title";
+   text_ptr[0].text = "Mona Lisa";
+   text_ptr[0].compression = PNG_TEXT_COMPRESSION_NONE;
+   text_ptr[1].key = "Author";
+   text_ptr[1].text = "Leonardo DaVinci";
+   text_ptr[1].compression = PNG_TEXT_COMPRESSION_NONE;
+   text_ptr[2].key = "Description";
+   text_ptr[2].text = "<long text>";
+   text_ptr[2].compression = PNG_TEXT_COMPRESSION_zTXt;
+#ifdef PNG_iTXt_SUPPORTED
+   text_ptr[0].lang = NULL;
+   text_ptr[1].lang = NULL;
+   text_ptr[2].lang = NULL;
+#endif
+   png_set_text(png_ptr, info_ptr, text_ptr, 3);
 
    /* Other optional chunks like cHRM, bKGD, tRNS, tIME, oFFs, pHYs */
 
@@ -972,7 +751,6 @@ void write_png(char *file_name /* , ... other image information ... */)
    /* Turn on interlace handling if you are not using png_write_image() */
    if (interlacing)
       number_passes = png_set_interlace_handling(png_ptr);
-
    else
       number_passes = 1;
 
@@ -981,16 +759,12 @@ void write_png(char *file_name /* , ... other image information ... */)
     * use the first method if you aren't handling interlacing yourself.
     */
    png_uint_32 k, height, width;
-
-   /* In this example, "image" is a one-dimensional array of bytes */
-   png_byte image[height*width*bytes_per_pixel];
-
+   png_byte image[height][width*bytes_per_pixel];
    png_bytep row_pointers[height];
 
-   if (height > PNG_UINT_32_MAX/(sizeof (png_bytep)))
+   if (height > PNG_UINT_32_MAX/png_sizeof(png_bytep))
      png_error (png_ptr, "Image is too tall to process in memory");
 
-   /* Set up pointers into your "image" byte array */
    for (k = 0; k < height; k++)
      row_pointers[k] = image + k*width*bytes_per_pixel;