[libpng15] Imported from libpng-1.5.16beta06.tar

to use unsigned long, not png_uint_32 arguments to sscanf().

ANNOUNCE

@@ -1,5 +1,5 @@
 
-Libpng 1.7.0beta52 - February 21, 2015
+Libpng 1.5.16beta06 - May 12, 2013
 
 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.
@@ -9,279 +9,44 @@ Files available for download:
 Source files with LF line endings (for Unix/Linux) and with a
 "configure" script
 
-   1.7.0beta52.tar.xz (LZMA-compressed, recommended)
-   1.7.0beta52.tar.gz
+   1.5.16beta06.tar.xz (LZMA-compressed, recommended)
+   1.5.16beta06.tar.gz
+   1.5.16beta06.tar.bz2
 
 Source files with CRLF line endings (for Windows), without the
 "configure" script
 
-   lp170b52.7z  (LZMA-compressed, recommended)
-   lp170b52.zip
+   lp1516b06.7z  (LZMA-compressed, recommended)
+   lp1516b06.zip
 
 Other information:
 
-   1.7.0beta52-README.txt
-   1.7.0beta52-LICENSE.txt
-   libpng-1.7.0beta52-*.asc (armored detached GPG signatures)
+   1.5.16beta06-README.txt
+   1.5.16beta06-LICENSE.txt
 
-Changes since the last public release (1.6.0):
+Changes since the last public release (1.5.15):
 
-Version 1.7.0alpha01 [December 15, 2012]
-  Started 1.7.0 branch from libpng-1.6.0beta33.
-  Made 8-bit compose and rgb_to_grayscale accuracy improvements.  These
-    changes cause 16-bit arithmetic to be used for 8-bit data in the gamma
-    corrected compose and grayscale operations.  The arithmetic errors have
-    three sources all of which are fixed in this commit:
-    1) 8-bit linear calculations produce massive errors for lower intensity
-       values.
-    2) The old 16-bit "16 to 8" gamma table code erroneously wrote the lowest
-       output value into a table entry which corresponded to multiple output
-       values (so where the value written should have been the closest to the
-       transformed input value.)
-    3) In a number of cases the code to access the 16-bit table did not round;
-       it did a simple shift, which was wrong and made the side effects of (2)
-       even worse.
-  The new gamma code does not have the 16-to-8 problem at the cost of slightly
-    more calculations and the algorithm used to minimize the number of
-    calculations has been extended to all the 16-bit tables; it has advantages
-    for any significant gamma correction.
-  Rearranged png_struct, remove unused members, change png_set_filter handling
-    png_struct members rearranged - partly to reorder to avoid packing, partly
-    to put frequently accessed members at the start and partly to make
-    the grouping more clear. png_set_filter code has been rewritten and the
-    code shared with png_write_start_row moved to a common function.  Comments
-    in png.h have been made more clear. Minor fixes to
-    contrib/libtests/timepng.c and some of the png_*_tRNS logic, including
-    more error detection in png_set_tRNS.
-  Cleaned up USER_LIMITS feature, removing members from png_struct when not
-    required.
-  Rearranged ARM-NEON optimizations to isolate the machine specific code to
-    the hardware subdirectory, and add comments to pngrutil.c so that
-    implementors of other optimizations will know what to do.
-  Fixed cases of unquoted DESTDIR in Makefile.am.
-  Rebuilt Makefile.in, configure, etc., with autoconf-2.69 and automake-1.12.5.
-
-Version 1.7.0alpha02 [December 17, 2012]
-  Removed functions that were deprecated in libpng-1.6.0:
-    png_reset_zstream(), png_info_init_3(), and png_data_freer() and its
-    associated flags.
-  Removed some duplicated lines from contrib/tools/scale.c and png.c.
-  Changed some instances of png_warning() to png_app_error().
-  Updated some left over "1.6.0beta32" in code sources.
-  Fixed a "png_structp" prototype (should be png_structrp) in arm_init.c
-  Updated the version-number hack in pngvalid.c
-
-Version 1.7.0alpha03 [December 19, 2012]
-  Cleaned up and enhanced the configure option; libpng now correctly
-    links and tests against zlib with a prefix; tests have been clarified; and
-    irrelevant or obsolete things (as defined by the autotools man page) have
-    been removed.
-  Documented new PNG_ABORT behavior in the manual and commentary in pngerror.c
-  Cleaned up whitespace in the synopsis portion of the manpage "libpng.3"
-  Fixed previous support for Z_PREFIX in configure builds, corrected sCAL APIs;
-    some of these use floating point arithmetic so they need to be disabled if
-    floating point arithmetic is switched off.  This is a quiet API change -
-    previously it appeared that the APIs were supported if fixed point
-    arithmetic was used internally, however they required certain APIs (floor,
-    modf, frexp, atof) that are part of C floating point support. Changed
-    png_fixed and the gamma code specific version of the same to avoid floor(),
-    which may be a library function (not an intrinsic). Removed unused #if 0
-    code.
-  Disassembled the version number in scripts/options.awk (necessary for
-    building on SunOs).
-
-Version 1.7.0alpha04 [December 23, 2012]
-  Added scripts/makefile.msys contributed by Christopher M. Wheeler
-  Made default Zlib compression settings be configurable. This adds #defines to
-    pnglibconf.h to control the defaults.
-  Fixed Windows build issues, enabled ARM compilation. Various warnings issued
-    by earlier versions of GCC fixed for Cygwin and Min/GW (which both use old
-    GCCs.) ARM support is enabled by default in zlib.props (unsupported by
-    Microsoft) and ARM compilation is made possible by deleting the check for
-    x86. The test programs cannot be run because they are not signed.
-
-Version 1.7.0alpha05 [December 24, 2012]
-  Discontinued distributing libpng-1.x.x.tar.bz2.
-  Discontinued distributing libpng-1.7.0-1.6.0-diff.txt and similar.
-
-Version 1.7.0alpha06 [January 1, 2013]
-  Fixed 'make distcheck' on SUN OS - libpng.so was not being removed
-
-Version 1.7.0alpha07 [January 10, 2013]
-  Fixed conceivable but difficult to repro overflow. Also added two test
-    programs to generate and test a PNG which should have the problem.
-
-Version 1.7.0alpha08 [January 17, 2013]
-  Corrected previous attempt at overflow detection in png_set_unknown_chunks()
-  (CVE-2013-7353).  Added overflow detection in png_set_sPLT() and
-  png_set_text_2() (CVE-2013-7354).
-
-Version 1.7.0alpha09 [January 21, 2013]
-  Pulled changes to multi-chunk handling from libpng-1.6.0beta40.
-
-Version 1.7.0alpha10 [February 5, 2013]
-  Make symbol prefixing work with the ARM neon optimizations. Also
-    allow pngpriv.h to be included for preprocessor definitions only, so
-    it can be used in non-C/C++ files.
-  Added png_get_palette_max() function.
-  Changed png_size_t to size_t throughout headers, make sRGB check numbers
-    consistent.
-  Fixed ARM support (Mans Rullgard).
-  Removed stray out-of-order #endif and #ifdef (Mans Rullgard).
-  Ported libpng 1.5 options.awk/dfn file handling to 1.7, fixed one bug.
-  Rebuilt Makefile.in, configure, etc., with autoconf-2.69 and automake-1.13.
-  Minor fixes to assembler changes, verified with a dummy .S file
-  Removed cc -E workround, corrected png_get_palette_max API. Tested on
-    SUN OS cc 5.9, which demonstrates the tokenization problem previously
-    avoided by using /lib/cpp.  Since all .dfn output is now protected
-    in double quotes unless it is to be macro substituted the fix should work
-    everywhere.
-
-Version 1.7.0beta01 [February 15, 2013]
-  Enable parallel tests and rearrange TESTS order to take advantage of
-    the massive speed improvements use a make capable of parallel builds
-    on a multi-CPU machine and pass the right arguments to make (-j10000
-    for GNU make) to get the build to run in parallel.
-  Fixed previous support for Z_PREFIX in configure builds, corrected
-    sCAL APIs; some of these use floating point arithmetic so need to be
-    disabled if floating point arithmetic is switched off.  This is a quiet API
-    change - previously it appeared that the APIs were supported if fixed point
-    arithmetic was used internally, however they required certain APIs (floor,
-    modf, frexp, atof) that are part of C floating point support. Changed
-    png_fixed and the gamma code specific version of the same to avoid floor(),
-    which may be a library function (not an intrinsic). Removed unused #if 0
-    code.
-  Fixed make distcheck to skip over the test result files. They were
-    being included because the whole of the 'tests' directory is included,
-    fixed to just include the actual test files and tests/pngstest.  Also
-    reverted the previous erroneous change to remove the ${srcdir} from the
-    front of contrib, scripts, projects and added an explanation of what is
-    going on to Makefile.am
-  Fixed missing dependency in --prefix builds. The intermediate
-    internal 'prefix.h' file can only be generated correctly after pnglibconf.h,
-    however the dependency was not in Makefile.am.  The symptoms are
-    unpredictable depending on the order make chooses to build pngprefix.h and
-    pnglibconf.h, often the error goes unnoticed because there is a system
-    pnglibconf.h to use instead.
-  Accept "," as a separator in pnglibconf.dfa and allow for
-    continuation lines. This adds to the syntax of "option" and "chunk" lines,
-    allowing the elements to be separated by a "," at the end of an element and
-    interpreting a "," at end of line as a continuation - so the following line
-    is read.  The new syntax is optional and solely provided for readability.
-  Enclosed the new png_get_palette_max in #ifdef PNG_GET_PALETTE_MAX_SUPPORTED
-    block, and revised pnglibconf.h and pnglibconf.h.prebuilt accordingly.
-
-Version 1.7.0beta02 [February 18, 2013]
-  Fixed a race condition in the creation of the build 'scripts' directory
-    while building with a parallel make.
-  Use approved/supported Android method to check for NEON, use Linux/POSIX
-    1003.1 API to check /proc/self/auxv avoiding buffer allocation and other
-    library calls (ported from libpng15).
-  Use parentheses more consistently in "#if defined(MACRO)" tests.
-  Folded long lines.
-
-Version 1.7.0beta03 [February 22, 2013]
-  Reenabled code to allow zero length PLTE chunks for MNG.
-  Fixed ALIGNED_MEMORY support.
-  Allow run-time ARM NEON checking to be disabled. A new configure option:
-    --enable-arm-neon=always will stop the run-time checks. New checks
-    within arm/arm_init.c will cause the code not to be compiled unless
-    __ARM_NEON__ is set. This should make it fail safe (if someone asks
-    for it on then the build will fail if it can't be done.)
-  Updated the INSTALL document.
-
-Version 1.7.0beta04 [February 27, 2013]
-  Revised INSTALL to recommend using CPPFLAGS instead of INCLUDES.
-  Revised scripts/makefile.freebsd to respect ZLIBLIB and ZLIBINC.
-  Revised scripts/dfn.awk to work with the buggy MSYS awk that has trouble
-    with CRLF line endings.
-
-Version 1.7.0beta05 [March 5, 2013]
-  Avoid a possible memory leak in contrib/gregbook/readpng.c
-  Changed user chunk callback API to respect global and per chunk defaults.
-    Previously a return of 0 from a user chunk callback would result in the
-    chunk being saved (if this was safe, even if the chunk was unsafe-to-copy);
-    this change respects the defaults set by the application, so unknown chunks
-    can be discarded by default and known-safe ones preserved.
-  Corrected Android builds and corrected libpng.vers with symbol
-    prefixing. This adds an API to set optimization options externally,
-    providing an alternative and general solution for the non-portable
-    run-time tests used by the ARM Neon code.  It also makes those tests
-    compile and link on Android.  The order of settings vs options in
-    pnglibconf.h is reversed to allow settings to depend on options and
-    options can now set (or override) the defaults for settings.
-
-Version 1.7.0beta06 [March 13, 2013]
-  Corrected simplified API default gamma for color-mapped output, added
-    a flag to change default. In 1.6.0 when the simplified API was used
-    to produce color-mapped output from an input image with no gamma
-    information the gamma assumed for the input could be different from
-    that assumed for non-color-mapped output.  In particular 16-bit depth
-    input files were assumed to be sRGB encoded, whereas in the 'direct'
-    case they were assumed to have linear data.  This was an error.  The
-    fix makes the simplified API treat all input files the same way and
-    adds a new flag to the png_image::flags member to allow the
-    application/user to specify that 16-bit files contain sRGB data
-    rather than the default linear.
-  Fixed bugs in the pngpixel and makepng test programs.
-  Fixed CMakelists.txt to allow building a single variant of the library
-    (Claudio Bley):
-  Introduced a PNG_LIB_TARGETS variable that lists all activated library
-    targets.  It is an error if this variable ends up empty, ie. you have
-    to build at least one library variant.
-  Made the *_COPY targets only depend on library targets actually being build.
-  Use PNG_LIB_TARGETS to unify a code path.
-  Changed the CREATE_SYMLINK macro to expect the full path to a file as the
-    first argument. When symlinking the filename component of that path is
-    determined and used as the link target.
-  Use copy_if_different in the CREATE_SYMLINK macro.
-  Eliminated two warnings from the Intel C compiler. The warnings are
-    technically valid, although a reasonable treatment of division would
-    show it to be incorrect.
-
-Version 1.7.0beta07 [April 14, 2013]
-  Updated documentation of 1.5.x to 1.6.x changes in iCCP chunk handling.
-  Fixed incorrect warning of excess deflate data. End condition - the
-    warning would be produced if the end of the deflate stream wasn't read
-    in the last row.  The warning is harmless.
-  Corrected the test on user transform changes on read. It was in the
-    png_set of the transform function, but that doesn't matter unless the
-    transform function changes the rowbuf size, and that is only valid if
-    transform_info is called.
+Version 1.5.16beta01 [April 25, 2013]
   Corrected a misplaced closing bracket in contrib/libtests/pngvalid.c
     (Flavio Medeiros).
-  Corrected length written to uncompressed iTXt chunks (Samuli Suominen).
-
-Version 1.7.0beta08 [April 18, 2013]
-  Added contrib/tools/fixitxt.c, to repair the erroneous iTXt chunk length
-    written by libpng-1.6.0 and 1.6.1.
-  Disallow storing sRGB information when the sRGB is not supported.
-
-Version 1.7.0beta09 [April 24, 2013]
-  Exposed PNG chunk types in png.h
-  Modified png_uint_32 macros/code to make as few assumptions as possible
   Revised stack marking in arm/filter_neon.S and configure.ac
   Ensure that NEON filter stuff is completely disabled when switched 'off'.
     Previously the ARM NEON specific files were still built if the option
     was switched 'off' as opposed to being explicitly disabled.
+  Avoid a compiler warning about unused png_ptr in translate_gamma_flags()
 
-Version 1.7.0beta10 [April 24, 2013]
-  Attempt to fix the PNG_ARM_NEON configuration mess.
+Version 1.5.16beta02 [April 26, 2013]
+  Revise pngtest.c to skip tests of unsupported features.
+  Regenerated configure files.
 
-Version 1.7.0beta11 [April 26, 2013]
-  Test for 'arm*', not just 'arm' in the host_cpu configure variable.
+Version 1.5.16beta03 [April 26, 2013]
+  Test for 'arm*' not just 'arm' in the host_cpu configure variable.
 
-Version 1.7.0beta12 [April 30, 2013]
-  Added png_app_warning for out-of-range unknown chunk index in
-    png_set_unknown_chunk_location().
-  Expanded manual paragraph about writing private chunks.
-  Avoid dereferencing NULL pointer possibly returned from
-     png_create_write_struct() (Andrew Church).
+Version 1.5.16beta04 [May 1, 2013]
+  Expanded manual paragraph about writing private chunks, particularly
+    the need to call png_set_keep_unknown_chunks() when writing them.
 
-Version 1.7.0beta13 [May 12, 2013]
-  Revised contrib/pngminim/*/makefile to generate pnglibconf.h with the
-    right zlib header files.
-  Separated CPPFLAGS and CFLAGS in contrib/pngminim/*/makefile
+Version 1.5.16beta05 [May 9, 2013]
   Updated contrib/pngminus/pnm2png.c (Paul Stewart):
     Check for EOF
     Ignore "#" delimited comments in input file to pnm2png.c.
@@ -289,444 +54,14 @@ Version 1.7.0beta13 [May 12, 2013]
     Added a call to png_set_packing()
     Initialize dimension values so if sscanf fails at least we have known
       invalid values.
-  Calculate our own zlib windowBits when decoding rather than trusting the
-    CMF bytes in the PNG datastream.
-  Added an option to force maximum window size for inflating, which was
-    the behavior of libpng15 and earlier.
-  Added png-fix-itxt and png-fix-too-far-back to the built programs and
-    removed warnings from the source code and timepng that are revealed as
-    a result.
-  Detect wrong libpng versions linked to png-fix-too-far-back, which currently
-    only works with libpng versions that can be made to reliably fail when
-    the deflate data contains an out-of-window reference.  This means only
-    1.6 and later.
-  Attempt to detect configuration issues with png-fix-too-far-back, which
-    requires both the correct libpng and the correct zlib to function
-    correctly.
-  Check ZLIB_VERNUM for mismatches, enclose #error in quotes
-  Added information in the documentation about problems with and fixes for
-    the bad CRC and bad iTXt chunk situations.
 
-Version 1.7.0beta14 [June 8, 2013]
-  Removed a redundant test in png_set_IHDR().
-  Added set(CMAKE_CONFIGURATION_TYPES ...) to CMakeLists.txt (Andrew Hundt)
-  Deleted set(CMAKE_BUILD_TYPE) block from CMakeLists.txt
-  Enclose the prototypes for the simplified write API in #ifdef STDIO/#endif
-  Make ARM NEON support work at compile time (not just configure time).
-    This moves the test on __ARM_NEON__ into pngconf.h to avoid issues when
-    using a compiler that compiles for multiple architectures at one time.
-  Removed PNG_FILTER_OPTIMIZATIONS and PNG_ARM_NEON_SUPPORTED from
-    pnglibconf.h, allowing more of the decisions to be made internally
-    (pngpriv.h) during the compile.  Without this, symbol prefixing is broken
-    under certain circumstances on ARM platforms.  Now only the API parts of
-    the optimizations ('check' vs 'api') are exposed in the public header files
-    except that the new setting PNG_ARM_NEON_OPT documents how libpng makes the
-    decision about whether or not to use the optimizations.
-  Protect symbol prefixing against CC/CPPFLAGS/CFLAGS useage.
-    Previous iOS/Xcode fixes for the ARM NEON optimizations moved the test
-    on __ARM_NEON__ from configure time to compile time.  This breaks symbol
-    prefixing because the definition of the special png_init_filter_functions
-    call was hidden at configure time if the relevant compiler arguments are
-    passed in CFLAGS as opposed to CC.  This change attempts to avoid all
-    the confusion that would result by declaring the init function even when
-    it is not used, so that it will always get prefixed.
-
-Version 1.7.0beta15 [June 18, 2013]
-  Revised libpng.3 so that "doclifter" can process it.
-
-Version 1.7.0beta16 [July 5, 2013]
-  Revised example.c to illustrate use of PNG_DEFAULT_sRGB and PNG_GAMMA_MAC_18
-    as parameters for png_set_gamma().  These have been available since
-    libpng-1.5.4.
-  Renamed contrib/tools/png-fix-too-far-back.c to pngfix.c and revised it
-    to check all compressed chunks known to libpng.
-  Updated documentation to show default behavior of benign errors correctly.
-  Added perfect hash code generation for lists of PNG chunks. This is
-    a work in progress; checked in for use in pngfix.c
-  Ported ARM no-read patch from libpng16.
-  Ported pngfix.c patches from libpng16.
-
-Version 1.7.0beta17 [August 21, 2013]
-  Revised manual about changes in iTXt chunk handling made in libpng-1.6.0.
-  Added "/* SAFE */" comments in pngrutil.c and pngrtran.c where warnings
-    may be erroneously issued by code-checking applications.
-  Added information about png_set_options() to the manual.
-  Delay calling png_init_filter_functions() until a row with nonzero filter
-    is found.
-
-Version 1.7.0beta18 [September 16, 2013]
-  Fixed inconsistent conditional compilation of png_chunk_unknown_handling()
-    prototype, definition, and usage.  Made it depend on
-    PNG_HANDLE_AS_UNKNOWN_SUPPORTED everywhere.
-
-Version 1.7.0beta19 [September 30, 2013]
-  Reverted the change to unknown handling #defines; the change breaks 'NOREAD'
-    builds.
-  Fixed default behavior of ARM_NEON_API. If the ARM NEON API option is
-    compiled without the CHECK option it defaulted to on, not off.
-  Catch up with recent libpng16 changes; unknown handling and spelling
-    corrections
-  Avoid up-cast warnings in pngvalid.c. On ARM the alignment requirements of
-    png_modifier are greater than that of png_store and as a consequence
-    compilation of pngvalid.c results in a warning about increased alignment
-    requirements because of the bare cast to (png_modifier*).  The code is
-    safe, because the pointer is known to point to a stack allocated
-    png_modifier, but this change avoids the warning.
-  Fixed some grammatical changes and updated the png chunks list.
-
-Version 1.7.0beta20 [October 13, 2013]
-  Made changes for compatibility with automake 1.14:
-    1) Added the 'compile' program to the list of programs that must be cleaned
-       in autogen.sh
-    2) Added 'subdir-objects' which causes .c files in sub-directories to be
-       compiled such that the corresponding .o files are also in the
-       sub-directory.  This is because automake 1.14 warns that the
-       current behavior of compiling to the top level directory may be removed
-       in the future.
-    3) Updated dependencies on pnglibconf.h to match the new .o locations and
-       added all the files in contrib/libtests and contrib/tools that depend
-       on pnglibconf.h
-    4) Added 'BUILD_SOURCES = pnglibconf.h'; this is the automake recommended
-       way of handling the dependencies of sources that are machine generated;
-       unfortunately it only works if the user does 'make all' or 'make check',
-       so the dependencies (3) are still required.
-  Cleaned up (char*) casts of zlib messages. The latest version of the Intel C
-    compiler complains about casting a string literal as (char*), so copied the
-    treatment of z_const from the library code into pngfix.c
-  Simplified error message code in pngunknown. The simplification has the
-    useful side effect of avoiding a bogus warning generated by the latest
-    version of the Intel C compiler (it objects to
-    condition ? string-literal : string-literal).
-  Make autogen.sh work with automake 1.13 as well as 1.14. Do this by always
-    removing the 1.14 'compile' script but never checking for it.
-
-Version 1.7.0beta21 [November 2, 2013]
-  Added ARMv8 support (James Yu <james.yu at linaro.org>).  Added file
-    arm/filter_neon_intrinsics.c; enable with -mfpu=neon.
-  Revised pngvalid to generate size images with as many filters as it can
-    manage, limited by the number of rows.
-  Cleaned up ARM NEON compilation handling. The tests are now in pngpriv.h
-    and detect the broken GCC compilers.
-  Allow clang derived from older GCC versions to use ARM intrinsics. This
-    causes all clang builds that use -mfpu=neon to use the intrinsics code,
-    not the assembler code.  This has only been tested on iOS 7. It may be
-    necessary to exclude some earlier clang versions but this seems unlikely.
-  Changed NEON implementation selection mechanism. This allows assembler
-    or intrinsics to be turned on at compile time during the build by defining
-    PNG_ARM_NEON_IMPLEMENTATION to the correct value (2 or 1).  This macro
-    is undefined by default and the build type is selected in pngpriv.h.
-
-Version 1.7.0beta22 [November 7, 2013]
-  Fixed #include in filter_neon_intrinsics.c and ctype macros. The ctype char
-    checking macros take an unsigned char argument, not a signed char.
-
-Version 1.7.0beta23 [November 24, 2013]
-  Changed #ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED in pngpread.c to
-    #ifdef PNG_SET_UNKNOWN_CHUNKS_SUPPORTED to be consistent with
-    what is in pngpriv.h.
-  Moved prototype for png_handle_unknown() in pngpriv.h outside of
-    the #ifdef PNG_SET_UNKNOWN_CHUNKS_SUPPORTED/#endif block.
-  Added "-Wall" to CFLAGS in contrib/pngminim/*/makefile
-  Conditionally compile some unused functions reported by -Wall in
-    pngminim.
-  Fixed 'minimal' builds. Various obviously useful minimal configurations
-    don't build because of missing contrib/libtests test programs and
-    overly complex dependencies in scripts/pnglibconf.dfa. This change
-    adds contrib/conftest/*.dfa files that can be used in automatic build
-    scripts to ensure that these configurations continue to build.
-  Enabled WRITE_INVERT and WRITE_PACK in contrib/pngminim/encoder.
-  Fixed pngvalid 'fail' function declaration on the Intel C Compiler.
-    This reverts to the previous 'static' implementation and works round
-    the 'unused static function' warning by using PNG_UNUSED().
-
-Version 1.7.0beta24 [December 15, 2013]
-  Removed or marked PNG_UNUSED some harmless "dead assignments" reported
-    by clang scan-build.
-  Changed tabs to 3 spaces in png_debug macros and changed '"%s"m'
-    to '"%s" m' to improve portability among compilers.
-  Changed png_free_default() to free() in pngtest.c
-  Tidied up pngfix inits and fixed pngtest no-write builds.
-  Bookkeeping: Moved functions around (no changes). Moved transform
-    function definitions before the place where they are called so that
-    they can be made static. Move the intrapixel functions and the
-    grayscale palette builder out of the png?tran.c files. The latter
-    isn't a transform function and is no longer used internally, and the
-    former MNG specific functions are better placed in pngread/pngwrite.c
-  Made transform implementation functions static. This makes the internal
-    functions called by png_do_{read|write}_transformations static. On an
-    x86-64 DLL build (Gentoo Linux) this reduces the size of the text
-    segment of the DLL by 1208 bytes, about 0.6%. It also simplifies
-    maintenance by removing the declarations from pngpriv.h and allowing
-    easier changes to the internal interfaces.
-  Handle zero-length PLTE chunk or NULL palette with png_error()
-    instead of png_chunk_report(), which by default issues a warning
-    rather than an error, leading to later reading from a NULL pointer
-    (png_ptr->palette) in png_do_expand_palette(). This is CVE-2013-6954
-    and VU#650142.  Libpng-1.6.1 through 1.6.7 and libpng-1.7.0beta03
-    through 1.7.0beta23 are vulnerable.  Libpng-1.6.0 and earlier do not
-    have the bug.
-
-Version 1.7.0beta25 [December 26, 2013]
-  Merged files with version 1.6.8 that have not changed since then.
-  Rebuilt configure scripts with automake-1.14.1 and autoconf-2.69
-
-Version 1.7.0beta26 [January 1, 2014]
-  Added libpng 1.5 checks to pngvalid.c
-  Merged with 1.5 and 1.6 changes to create a single pngvalid.c
-  Added dSIG to chunk list in png.h
-  Removed #error macro from contrib/tools/pngfix.c (Thomas Klausner).
-  Merged pngrio.c, pngtrans.c, and pngwio.c with libpng-1.6.9
-  Fixed test programs for interlace options. Made pngvalid.c and
-    pngtest.c work correctly when READ_INTERLACING and/or WRITE_INTERLACING
-    are switched off.
-  Changed pngvalid.c to support libpng 1.5, which does not support
-    the PNG_MAXIMUM_INFLATE_WINDOW option, so #define it out when
-    appropriate in pngvalid.c
-  Allow unversioned links created on install to be disabled in configure.
-    In configure builds 'make install' changes/adds links like png.h
-    and libpng.a to point to the newly installed, versioned, files (e.g.
-    libpng17/png.h and libpng17.a). Three new configure options and some
-    rearrangement of Makefile.am allow creation of these links to be disabled.
-
-Version 1.7.0beta27 [January 10, 2014]
-  Removed potentially misleading warning from png_check_IHDR().
-
-Version 1.7.0beta28 [January 20, 2014]
-  Updated scripts/makefile.* to use CPPFLAGS (Cosmin).
-  Added clang attribute support (Cosmin).
-
-Version 1.7.0beta29 [January 30, 2014]
-  Quiet an uninitialized memory warning from VS2013 in png_get_png().
-
-Version 1.7.0beta30 [February 2, 2014]
-  Fixed a large number of instances where PNGCBAPI was omitted from
-    function definitions.
-  Added pngimage test program for png_read_png and png_write_png. This
-    is a work-in-progress; no tests are run automatically at present and
-    the program by virtue of exhaustively testing all the transforms is
-    very slow.
-
-Version 1.7.0beta31 [February 6, 2014]
-  Make png_read_png() and png_write_png() prototypes in png.h depend
-    upon PNG_READ_SUPPORTED and PNG_WRITE_SUPPORTED.
-  Removed dependence on !PNG_READ_EXPAND_SUPPORTED for calling
-    png_set_packing() in png_read_png().
-  Completed full working pngimage test program and added two test scripts.
-  Fixed combination of ~alpha with shift. On read invert alpha, processing
-    occurred after shift processing, which causes the final values to be
-    outside the range that should be produced by the shift. Reversing the
-    order on read makes the two transforms work together correctly and mirrors
-    the order used on write.
-  Do not read invalid sBIT chunks. Previously libpng only checked sBIT
-    values on write, so a malicious PNG writer could therefore cause
-    the read code to return an invalid sBIT chunk, which might lead to
-    application errors or crashes.  Such chunks are now skipped (with
-    chunk_benign_error).
-  Restored a line, "c = b;", that was inadvertently deleted from the
-    PAETH filtering code from libpng-1.7.0beta24/pngrutil.c. Deleted
-    the other instance of "c = b;" which is the one that triggered a
-    scan-build warning.
-  Support builds with unsupported PNG_TRANSFORM_* values.  All of the
-    PNG_TRANSFORM_* values are always defined in png.h and, because they
-    are used for both read and write in some cases, it is not reliable
-    to #if out ones that are totally unsupported. This change adds error
-    detection in png_read_image() and png_write_image() to do a
-    png_app_error() if the app requests something that cannot be done
-    and it adds corresponding code to pngimage.c to handle such options
-    by not attempting to test them.
-
-Version 1.7.0beta32 [February 26, 2014]
-  Moved redefines of png_error(), png_warning(), png_chunk_error(),
-    and png_chunk_warning() from pngpriv.h to png.h to make them visible
-    to libpng-calling applications.
-  Moved OS dependent code from arm/arm_init.c, to allow the included
-    implementation of the ARM NEON discovery function to be set at
-    build-time and provide sample implementations from the current code in the
-    contrib/arm-neon subdirectory. The __linux__ code has also been changed to
-    compile and link on Android by using /proc/cpuinfo, and the old linux code
-    is in contrib/arm-neon/linux-auxv.c.  The new code avoids POSIX and Linux
-    dependencies apart from opening /proc/cpuinfo and is C90 compliant.
-  Check for info_ptr == NULL early in png_read_end() so we don't need to
-    run all the png_handle_*() and depend on them to return if info_ptr == NULL.
-    This improves the performance of png_read_end(png_ptr, NULL) and makes
-    it more robust against future programming errors.
-  Check for __has_extension before using it in pngconf.h, to
-    support older Clang versions (Jeremy Sequoia).
-  Use a user warning handler in contrib/gregbook/readpng2.c instead of default,
-    so warnings will be put on stderr even if libpng has CONSOLE_IO disabled.
-  Added png_ptr->process_mode = PNG_READ_IDAT_MODE in png_push_read_chunk
-    after recognizing the IDAT chunk, which avoids an infinite loop while
-    reading a datastream whose first IDAT chunk is of zero-length.
-    This fixes CERT VU#684412 and CVE-2014-0333.
-  Don't recognize known sRGB profiles as sRGB if they have been hacked,
-    but don't reject them and don't issue a copyright violation warning.
-  Minor editing of contrib/arm-neon/README and contrib/examples/*.c
-  Moved some documentation from png.h to libpng.3 and libpng-manual.txt
-
-Version 1.7.0beta33 [February 27, 2014]
-  Fixed typos in the manual and in scripts/pnglibconf.dfa (CFLAGS -> CPPFLAGS
-    and PNG_USR_CONFIG -> PNG_USER_CONFIG).
-
-Version 1.7.0beta34 [March 17, 2014]
-  Treat CRC error handling with png_set_crc_action(), instead of with
-    png_set_benign_errors(), which has been the case since libpng-1.6.0beta18.
-  Use "if (value != 0)" instead of "if (value)" consistently.
-  Changed ZlibSrcDir from 1.2.5 to 1.2.8 in projects/vstudio.
-  Moved configuration information from the manual to the INSTALL file.
-
-Version 1.7.0beta35 [August 6, 2014]
-  Removed #if/#else/#endif from inside two pow() calls in pngvalid.c because
-    they were handled improperly by Portland Group's PGI-14.1 - PGI-14.3
-    when using its "__builtin_pow()" function.
-  Silence 'unused parameter' build warnings (Cosmin).
-  $(CP) is now used alongside $(RM_F).  Also, use 'copy' instead
-    of 'cp' where applicable, and applied other minor makefile changes.
-  Don't warn about invalid dimensions exceeding user limits.
-  Allow an easy replacement of the default pre-built configuration
-    header with a custom header, via the make PNGLIBCONF_H_PREBUILT
-    macro.
-  Fixed a typo in pngrutil.c, introduced in libpng-1.5.6, that interferes
-    with "blocky" expansion of sub-8-bit interlaced PNG files (Eric Huss).
-  Removed scripts/makefile.elf. It has not worked since libpng-1.5.0beta14
-    due to elimination of the PNG_FUNCTION_EXPORT and PNG_DATA_EXPORT
-    definitions from pngconf.h.
-  Ensure that CMakeLists.txt makes the target "lib" directory before making
-    symbolic link into it (SourceForge bug report #226 by Rolf Timmermans).
-  Added opinion that the ECCN (Export Control Classification Number) for
-    libpng is EAR99 to the README file.
-
-Version 1.7.0beta36 [September 27, 2014]
-  Updated scripts/makefiles from libpng-1.6.13beta04.
-  Minor updates to the manual from libpng-1.6.14beta04.
-  Fixed incorrect handling of the iTXt compression flag in pngrutil.c
-    (bug report by Shunsaku Hirata).  Bug was introduced in libpng-1.6.0.
-
-Version 1.7.0beta37 [September 28, 2014]
-  Merged scripts/*, pngvalid.c and pngfix.c with libpng-1.6.14beta04.
-
-Version 1.7.0beta38 [October 17, 2014]
-  Added "option READ_iCCP enables READ_COMPRESSED_TEXT" to pnglibconf.dfa
-  Removed unused "text_len" parameter from private function png_write_zTXt().
-  Conditionally compile some code in png_deflate_claim(), when
-    PNG_WARNINGS_SUPPORTED and PNG_ERROR_TEXT_SUPPORTED are disabled.
-  Replaced repeated code in pngpread.c with PNG_PUSH_SAVE_BUFFER_IF_FULL.
-  Added "chunk iTXt enables TEXT" and "chunk zTXt enables TEXT"
-    to pnglibconf.dfa.
-  Removed "option READ_COMPRESSED_TEXT enables READ_TEXT" from pnglibconf.dfa,
-    to make it possible to configure a libpng that supports iCCP but not TEXT.
-  Removed "option WRITE_COMPRESSED_TEXT enables WRITE_TEXT" from pnglibconf.dfa
-  Only mark text chunks as written after successfully writing them.
-
-Version 1.7.0beta39 [November 1, 2014]
-  Ported cosmetic changes from libpng-1.6.15beta02.
-
-Version 1.7.0beta40 [November 6, 2014]
-  Made a one-line revision to configure.ac to support ARM on aarch64
-    (bug report by Marcin Juszkiewicz, fix by John Bowler).
-  Use png_get_libpng_ver(NULL) instead of PNG_LIBPNG_VER_STRING in
-    example.c, pngtest.c, and applications in the contrib directory.
-  Avoid out-of-bounds memory access in png_user_version_check().
-  Simplified and future-proofed png_user_version_check().
-  Fixed GCC unsigned int->float warnings. Various versions of GCC
-    seem to generate warnings when an unsigned value is implicitly
-    converted to double. This is probably a GCC bug but this change
-    avoids the issue by explicitly converting to (int) where safe.
-  Free all allocated memory in pngimage. The file buffer cache was left
-    allocated at the end of the program, harmless but it causes memory
-    leak reports from clang.
-  Fixed array size calculations to avoid warnings. At various points
-    in the code the number of elements in an array is calculated using
-    sizeof.  This generates a compile time constant of type (size_t) which
-    is then typically assigned to an (unsigned int) or (int). Some versions
-    of GCC on 64-bit systems warn about the apparent narrowing, even though
-    the same compiler does apparently generate the correct, in-range,
-    numeric constant.  This adds appropriate, safe, casts to make the
-    warnings go away.
-
-Version 1.7.0beta41 [November 7, 2014]
-  Added #ifdef PNG_16BIT_SUPPORTED/#endif around png_log16bit() and
-    png_do_swap().
-  Changed all "#endif /* PNG_FEATURE_SUPPORTED */" to "#endif /* FEATURE */"
-
-Version 1.7.0beta42 [November 20, 2014]
-  The macros passed in the command line to Borland make were ignored if
-    similarly-named macros were already defined in makefiles. This behavior
-    is different from POSIX make and other make programs.  Surround the
-    macro definitions with ifndef guards (Cosmin).
-  Added "-D_CRT_SECURE_NO_WARNINGS" to CFLAGS in scripts/makefile.vcwin32.
-  Removed the obsolete $ARCH variable from scripts/makefile.darwin.
-  Merged clang no-warning fix from libpng-1.6.13: png_digit was defined
-    but never used in pngerror.c.
-
-Version 1.7.0beta43 [December 18, 2014]
-  Added ".align 2" to arm/filter_neon.S to support old GAS assemblers that
-    don't do alignment correctly.
-  Revised Makefile.am and scripts/*.dfn to work with MinGW/MSYS;
-    renamed scripts/*.dfn to scripts/*.c (Bob Friesenhahn and John Bowler).
-  Quiet a "comparison always true" warning in pngstest.c (John Bowler).
-
-Version 1.7.0beta44 [December 23, 2014]
-  Restored a test on width that was removed from png.c at libpng-1.6.9
-    (Bug report by Alex Eubanks, CVE-2015-0973).
-  Fixed an overflow in png_combine_row() with very wide interlaced images
-    (Bug report and fix by John Bowler, CVE-2014-9495).
-  Corrected the width limit calculation in png_check_IHDR().
-  Removed extraneous handling of PNG_SAFE_LIMITS_SUPPORTED from pngconf.h
-
-Version 1.7.0beta45 [December 28, 2014]
-  Eliminated the PNG_SAFE_LIMITS macro and restored the 1-million-column
-    and 1-million-row default limits in pnglibconf.dfa, that can be reset
-    by the user at build time or run time.  This provides a more robust
-    defense against DOS and as-yet undiscovered overflows.
-  Removed user limits from pngfix. Also pass NULL pointers to
-    png_read_row to skip the unnecessary row de-interlace stuff.
-  Added testing of png_set_packing() to pngvalid.c
-
-Version 1.7.0beta46 [January 2, 2015]
-  Regenerated configure scripts in the tar distributions with libtool-2.4.4
-  Implement previously untested cases of libpng transforms in pngvalid.c
-  Fixed byte order in 2-byte filler, in png_do_read_filler().
-  Allow user to call png_get_IHDR() with NULL arguments (Reuben Hawkins).
-
-Version 1.7.0beta47 [January 29, 2015]
-  Made the check for out-of-range values in png_set_tRNS() detect
-    values that are exactly 2^bit_depth, and work on 16-bit platforms.
-  Added PNG_SKIP_sRGB_CHECK_PROFILE choice for png_set_option().
-  Report all IHDR errors before exiting png_check_IHDR().
-  Merged some parts of libpng-1.6.17beta01 and libpng-1.7.0beta47.
-  Added #ifndef __COVERITY__ where needed in png.c, pngrutil.c and
-    pngset.c to avoid warnings about dead code.
-
-Version 1.7.0beta48 [February 7, 2015]
-  Work around one more Coverity-scan dead-code warning.
-  Do not build png_product2() when it is unused.
-
-Version 1.7.0beta49 [February 11, 2015]
-  Combined sub_row, up_row, avg_row, and paeth_row buffers into a
-    single try_row buffer.
-  Added PNG_WRITE_CUSTOMIZE_COMPRESSION_SUPPORTED macro, on by default.
-  Consolidated redundant code in pngwutil.c
-  Deal with integer overflow of sum in pngwutil.c
-
-Version 1.7.0beta50 [February 15, 2015]
-  Combined sub_row, up_row, avg_row, and paeth_row buffers into a
-    single try_row buffer and in cases where two or more of those are
-    being tested, a second tst_row buffer.  This improves CPU speed
-    over that achieved by libpng-1.7.0beta49.
-
-Version 1.7.0beta51 [February 17, 2015]
-  Combined similar parts of png_write_find_filter() into a png_increase_lmins()
-    function.
-  Display user limits in the output from pngtest.
-  Replaced test for harmless integer overflow (wraparound) in pngwutil.c
-    with a method that prevents overflow and does not increase cpu usage
-    significantly.
-
-Version 1.7.0beta52 [February 21, 2015]
-  Added information about setjmp/simplified API interaction in the
-    manual page and INSTALL file. Added information about using
-    row_pointers with a single height*width*bpp allocated block
-  Rebuilt configure scripts with automake-1.15 and libtool-2.4.6
+Version 1.5.16beta06 [May 12, 2013]
+  Allow contrib/pnminus/pnm2png.c to compile without WRITE_INVERT and WRITE_PACK
+    supported (writes error message that it can't read P1 or P4 PBM files).
+  Revised contrib/pngminim/*/makefile to separate CPPFLAGS and CPFLAGS, and
+    to generate pnglibconf.h with the right zlib header files.
+  Ported contrib/pngminus/pnm2png.c changes back from libpng-1.6.3beta06,
+    to use unsigned long, not png_uint_32 arguments to sscanf().
 
 Send comments/corrections/commendations to png-mng-implement at lists.sf.net
 (subscription required; visit

CMakeLists.txt

@@ -1,6 +1,6 @@
 # CMakeLists.txt
 
-# Copyright (C) 2007-2014 Glenn Randers-Pehrson
+# Copyright (C) 2007-2011 Glenn Randers-Pehrson
 
 # This code is released under the libpng license.
 # For conditions of distribution and use, see the disclaimer
@@ -9,14 +9,33 @@
 cmake_minimum_required(VERSION 2.4.4)
 set(CMAKE_ALLOW_LOOSE_LOOP_CONSTRUCTS true)
 
-set(CMAKE_CONFIGURATION_TYPES "Release;Debug;MinSizeRel;RelWithDebInfo")
+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 7)
-set(PNGLIB_RELEASE 0)
+set(PNGLIB_MINOR 5)
+set(PNGLIB_RELEASE 16)
 set(PNGLIB_NAME libpng${PNGLIB_MAJOR}${PNGLIB_MINOR})
 set(PNGLIB_VERSION ${PNGLIB_MAJOR}.${PNGLIB_MINOR}.${PNGLIB_RELEASE})
 
@@ -104,11 +123,10 @@ set(pngtest_sources
 set(pngvalid_sources
   contrib/libtests/pngvalid.c
 )
-set(pngstest_sources
-  contrib/libtests/pngstest.c
-)
 # SOME NEEDED DEFINITIONS
 
+add_definitions(-DPNG_CONFIGURE_LIBPNG)
+
 if(MSVC)
   add_definitions(-D_CRT_SECURE_NO_DEPRECATE)
 endif(MSVC)
@@ -164,40 +182,6 @@ if(PNG_TESTS AND PNG_SHARED)
   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
-  )
 endif()
 
 # Ensure the CMAKE_LIBRARY_OUTPUT_DIRECTORY is set
@@ -220,7 +204,6 @@ macro(CREATE_SYMLINK SRC_FILE DEST_FILE)
     ADD_CUSTOM_TARGET(${DEST_FILE}_COPY ALL DEPENDS ${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/${DEST_FILE})
   else(WIN32 AND NOT CYGWIN AND NOT MSYS)
     get_filename_component(LINK_TARGET "${SRC_FILE}" NAME)
-    execute_process(COMMAND ${CMAKE_COMMAND} -E make_directory ${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_LIBRARY_OUTPUT_DIRECTORY})
     execute_process(COMMAND ${CMAKE_COMMAND} -E create_symlink "${LINK_TARGET}" ${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/${DEST_FILE} WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
     execute_process(COMMAND ${CMAKE_COMMAND} -E create_symlink "${LINK_TARGET}" ${DEST_FILE} WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
   endif(WIN32 AND NOT CYGWIN AND NOT MSYS)
@@ -235,7 +218,7 @@ endif(NOT DEFINED CMAKE_INSTALL_LIBDIR)
 # 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)
+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})
@@ -253,9 +236,9 @@ endif(NOT WIN32 OR CYGWIN OR MINGW)
 # SET UP LINKS
 if(PNG_SHARED)
   set_target_properties(${PNG_LIB_NAME} PROPERTIES
-#   VERSION 17.${PNGLIB_RELEASE}.1.7.0beta52
-    VERSION 17.${PNGLIB_RELEASE}.0
-    SOVERSION 17
+#   VERSION 15.${PNGLIB_RELEASE}.1.5.16beta06
+    VERSION 15.${PNGLIB_RELEASE}.0
+    SOVERSION 15
     CLEAN_DIRECT_OUTPUT 1)
 endif()
 if(PNG_STATIC)
@@ -287,7 +270,7 @@ if(NOT SKIP_INSTALL_LIBRARIES AND NOT SKIP_INSTALL_ALL )
       ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR})
 
   if(PNG_SHARED)
-    # Create a symlink for libpng.dll.a => libpng17.dll.a on Cygwin
+    # Create a symlink for libpng.dll.a => libpng15.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})
@@ -351,7 +334,7 @@ if(PNG_EXPORT_RULE AND NOT SKIP_INSTALL_EXPORT AND NOT SKIP_INSTALL_ALL )
   install(EXPORT libpng DESTINATION lib/libpng FILE lib${PNG_LIB_NAME}.cmake)
 endif()
 
-# what's with libpng-manual.txt and all the extra files?
+# what's with libpng-$VER%.txt and all the extra files?
 
 # UNINSTALL
 # do we need this?

INSTALL

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

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.7.0beta52, February 21, 2015, are
-Copyright (c) 2004, 2006-2015 Glenn Randers-Pehrson, and are
+libpng versions 1.2.6, August 15, 2004, through 1.5.16beta06, May 12, 2013, are
+Copyright (c) 2004, 2006-2012 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
-February 21, 2015
+May 12, 2013

Makefile.am

@@ -4,69 +4,25 @@
 
 PNGLIB_BASENAME= libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@
 
-ACLOCAL_AMFLAGS = -I scripts
+# libpng does not follow GNU file name conventions
+
+# "color-tests" requires automake 1.11.1 or later.  Enable it if you like,
+# to get red "FAIL" and green "PASS" notations during tests.
+# AUTOMAKE_OPTIONS = foreign color-tests
+AUTOMAKE_OPTIONS = foreign
 
 # test programs - run on make check, make distcheck
-check_PROGRAMS= pngtest pngunknown pngstest pngvalid pngimage
-
-# Utilities - installed
-bin_PROGRAMS= pngfix png-fix-itxt
-
-# This ensures that pnglibconf.h gets built at the start of 'make all' or
-# 'make check', but it does not add dependencies to the individual programs,
-# this is done below.
-#
-# IMPORTANT: always add the object modules of new programs to the list below
-# because otherwise the sequence 'configure; make new-program' will *sometimes*
-# result in the installed (system) pnglibconf.h being used and the result is
-# always wrong and always very confusing.
-BUILT_SOURCES = pnglibconf.h
-
+TESTS_ENVIRONMENT= srcdir=$(srcdir)
+check_PROGRAMS= pngtest
 pngtest_SOURCES = pngtest.c
 pngtest_LDADD = libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@.la
+TESTS = test-pngtest.sh
 
+# Only do the following if the contrib directory is present.
+check_PROGRAMS+= pngvalid
 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
-
-pngimage_SOURCES = contrib/libtests/pngimage.c
-pngimage_LDADD = libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@.la
-
-pngfix_SOURCES = contrib/tools/pngfix.c
-pngfix_LDADD = libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@.la
-
-png_fix_itxt_SOURCES = contrib/tools/png-fix-itxt.c
-
-# 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\
-   tests/pngimage-quick tests/pngimage-full
-
-# These tests are expected, and required, to fail:
-XFAIL_TESTS = tests/pngstest-error
+TESTS += test-pngvalid-simple.sh test-pngvalid-full.sh
 
 # man pages
 dist_man_MANS= libpng.3 libpngpf.3 png.5
@@ -86,11 +42,13 @@ libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@_la_SOURCES = png.c pngerror.c\
 
 if PNG_ARM_NEON
 libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@_la_SOURCES += arm/arm_init.c\
-	arm/filter_neon.S arm/filter_neon_intrinsics.c
+	arm/filter_neon.S
 endif
 
 nodist_libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@_la_SOURCES = pnglibconf.h
 
+libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@_la_CPPFLAGS = @LIBPNG_DEFINES@
+
 libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@_la_LDFLAGS = -no-undefined -export-dynamic \
 	-version-number @PNGLIB_MAJOR@@PNGLIB_MINOR@:@PNGLIB_RELEASE@:0
 
@@ -119,40 +77,33 @@ nodist_pkginclude_HEADERS= pnglibconf.h
 pkgconfigdir = @pkgconfigdir@
 pkgconfig_DATA = libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@.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 \
 	pngtest.png pngbar.png pngnow.png pngbar.jpg autogen.sh \
 	${srcdir}/contrib ${srcdir}/projects ${srcdir}/scripts \
-	$(TESTS) $(XFAIL_TESTS) tests/pngstest \
+	$(TESTS) \
 	CMakeLists.txt example.c libpng-manual.txt
 
-SCRIPT_CLEANFILES=scripts/*.out scripts/*.chk scripts/pnglibconf.c
+SCRIPT_CLEANFILES=scripts/*.out scripts/*.chk scripts/pnglibconf.dfn
 
-CLEANFILES= *.tf? pngout.png libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@.pc \
+CLEANFILES= dfn.c dfn?.out *.out.? scripts/*.out.? 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 \
+	check.new pnglibconf.* symbols.new pngtest-log.txt \
 	$(SCRIPT_CLEANFILES)
 
 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 -E" - the C preprocessor - but on Solaris and
-# maybe other operating systems (NeXT?) the C preprocessor selected by configure
+# DFNCPP is normally just CPP - the C preprocessor - but on Solaris and maybe
+# other operating systems (NeXT?) the C preprocessor selected by configure
 # checks input tokens for validity - effectively it performs part of the ANSI-C
 # parsing - and therefore fails with the .df files.  configure.ac has special
 # checks for this and sets DFNCPP appropriately.
 DFNCPP = @DFNCPP@
 
-SUFFIXES = .chk .out
+SUFFIXES = .chk .dfn .out
 
 $(PNGLIB_BASENAME).pc: libpng.pc
 	cp libpng.pc $@
@@ -161,11 +112,7 @@ $(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
-
-pnglibconf.out: config.h
 
 libpng.sym: scripts/sym.out
 	rm -f $@
@@ -173,59 +120,19 @@ libpng.sym: scripts/sym.out
 libpng.vers: scripts/vers.out
 	rm -f $@
 	cp $? $@
-
-if DO_PNG_PREFIX
-# Rename functions in scripts/prefix.out with a PNG_PREFIX prefix.
-# Rename macros in scripts/macro.lst from PNG_PREFIXpng_ to PNG_ (the actual
-# implementation of the macro).
-pnglibconf.h: pnglibconf.out scripts/prefix.out scripts/macro.lst config.h
-	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', copy that" >&2
-	@echo "AND set PNG_ZLIB_VERNUM to 0 (you MUST do this)" >&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.)  Only files which include
-# one of the png source files (typically png.h or pngpriv.h) need to be listed
-# here:
-pngtest.o: pnglibconf.h
-
-contrib/libtests/makepng.o: pnglibconf.h
-contrib/libtests/pngstest.o: pnglibconf.h
-contrib/libtests/pngunknown.o: pnglibconf.h
-contrib/libtests/pngimage.o: pnglibconf.h
-contrib/libtests/pngvalid.o: pnglibconf.h
-contrib/libtests/readpng.o: pnglibconf.h
-contrib/libtests/tarith.o: pnglibconf.h
-contrib/libtests/timepng.o: pnglibconf.h
-
-contrib/tools/makesRGB.o: pnglibconf.h
-contrib/tools/pngfix.o: pnglibconf.h
+# 'make test' is the first thing the user does.)
+contrib/libtests/pngvalid.o pngtest.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
@@ -235,54 +142,47 @@ SYMBOL_CFLAGS = -DPNGLIB_LIBNAME='PNG@PNGLIB_MAJOR@@PNGLIB_MINOR@_0'\
 		-DSYMBOL_PREFIX='$(SYMBOL_PREFIX)'\
 		-DPNG_NO_USE_READ_MACROS -DPNG_BUILDING_SYMBOL_TABLE
 
-if DO_PNG_PREFIX
-SYMBOL_CFLAGS += -DPNG_PREFIX='@PNG_PREFIX@'
-endif
-
-.c.out:
-	rm -f $@ $*.tf[12]
+.dfn.out:
+	rm -f $@ $@.c $@.?
 	test -d scripts || mkdir scripts || test -d scripts
-	$(DFNCPP) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES)\
-	    $(CPPFLAGS) $(SYMBOL_CFLAGS) $< > $*.tf1
-	$(AWK) -f "${srcdir}/scripts/dfn.awk" out="$*.tf2" $*.tf1 1>&2
-	rm -f $*.tf1
-	mv $*.tf2 $@
+	echo '#include "$<"' >$@.c
+	$(DFNCPP) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) @LIBPNG_DEFINES@\
+	    $(CPPFLAGS) $(SYMBOL_CFLAGS) $@.c > $@.1
+	$(AWK) -f "${srcdir}/scripts/dfn.awk" out="$@.2" $@.1 1>&2
+	mv $@.2 $@
 
-# The .c file for pnglibconf.h is machine generated
-pnglibconf.c: scripts/pnglibconf.dfa scripts/options.awk pngconf.h pngusr.dfa $(DFA_XTRA)
-	rm -f $@ $*.tf[45]
-	$(AWK) -f ${srcdir}/scripts/options.awk out=$*.tf4 version=search\
-	    ${srcdir}/pngconf.h ${srcdir}/scripts/pnglibconf.dfa\
+# 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 $@ pnglibconf.pre $@.?
+	$(AWK) -f ${srcdir}/scripts/options.awk out="pnglibconf.pre"\
+	    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 $@
+	$(AWK) -f ${srcdir}/scripts/options.awk out="$@.1" pnglibconf.pre 1>&2
+	mv $@.1 $@
 
 # 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
+	rm -f $@ symbols.new
 	$(AWK) -f ${srcdir}/scripts/checksym.awk ${srcdir}/scripts/${*F}.def\
-	    of="$*.new" $< >&2
-	mv $*.new $@
+	    $< >&2
+	mv symbols.new $@
 
 # used on demand to regenerate the standard header, CPPFLAGS should
 # be empty - no non-standard defines
-scripts/pnglibconf.c: scripts/pnglibconf.dfa scripts/options.awk pngconf.h
-	rm -f $@ pnglibconf.tf[67]
+scripts/pnglibconf.dfn: scripts/pnglibconf.dfa scripts/options.awk pngconf.h
+	rm -f $@ dfn?.out
 	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 $@
+	$(AWK) -f ${srcdir}/scripts/options.awk out=dfn1.out logunsupported=1\
+		version=search ${srcdir}/pngconf.h -\
+		${srcdir}/scripts/pnglibconf.dfa 1>&2
+	$(AWK) -f ${srcdir}/scripts/options.awk out=dfn2.out dfn1.out 1>&2
+	rm dfn1.out
+	mv dfn2.out $@
 
 $(libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@_la_OBJECTS): png.h pngconf.h \
-	pnglibconf.h pngpriv.h pngdebug.h pnginfo.h pngstruct.h pngprefix.h
+	pnglibconf.h pngpriv.h pngdebug.h pnginfo.h pngstruct.h
 
 test: check-am
 
@@ -293,76 +193,40 @@ check: scripts/symbols.chk
 dist-hook:
 	cd '$(top_distdir)'; rm -f $(SCRIPT_CLEANFILES)
 
-# Make links between installed files with release-specific names and the generic
-# file names.  If this install rule is run the generic names will be deleted and
-# recreated - this has obvious issues for systems with multiple installations.
+# install the .../include headers as links to the new ones
+install-data-hook:
+	cd '$(DESTDIR)$(includedir)'; rm -f png.h pngconf.h pnglibconf.h
+	cd '$(DESTDIR)$(includedir)'; $(LN_S) $(PNGLIB_BASENAME)/png.h png.h
+	cd '$(DESTDIR)$(includedir)'; $(LN_S) $(PNGLIB_BASENAME)/pngconf.h \
+		pngconf.h
+	cd '$(DESTDIR)$(includedir)'; $(LN_S) $(PNGLIB_BASENAME)/pnglibconf.h \
+		pnglibconf.h
+	cd '$(DESTDIR)$(pkgconfigdir)'; rm -f libpng.pc
+	cd '$(DESTDIR)$(pkgconfigdir)'; $(LN_S) $(PNGLIB_BASENAME).pc libpng.pc
 
-install-header-links:
-	@set -ex; cd '$(DESTDIR)$(includedir)'; for f in $(HEADERS); do \
-	   rm -f "$$f"; $(LN_S) "$(PNGLIB_BASENAME)/$$f" "$$f"; done
-
-uninstall-header-links:
-	cd '$(DESTDIR)$(includedir)'; rm -f $(HEADERS)
-
-install-libpng-pc:
-	@set -ex; cd '$(DESTDIR)$(pkgconfigdir)'; rm -f libpng.pc; \
-	   $(LN_S) '$(PNGLIB_BASENAME).pc' libpng.pc
-
-uninstall-libpng-pc:
-	rm -f '$(DESTDIR)$(pkgconfigdir)/libpng.pc'
-
-# EXT_LIST is a list of the possibly library directory extensions, this exists
-# because we can't find a good way of discovering the file extensions that are
-# actually installed on a given system, so instead we check for every extension
-# we have seen.
-
-EXT_LIST = a dll.a so so.@PNGLIB_MAJOR@@PNGLIB_MINOR@.@PNGLIB_RELEASE@ la sl dylib
-
-install-library-links:
-	@set -x; cd '$(DESTDIR)$(libdir)';\
-	for ext in $(EXT_LIST); do\
-	   rm -f "libpng.$$ext";\
-           if test -f "$(PNGLIB_BASENAME).$$ext"; then\
-              $(LN_S) "$(PNGLIB_BASENAME).$$ext" "libpng.$$ext" || exit 1;\
-           fi;\
+# do evil things to libpng to cause libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@ to be used
+install-exec-hook:
+	cd '$(DESTDIR)$(bindir)'; rm -f libpng-config
+	cd '$(DESTDIR)$(bindir)';\
+	   $(LN_S) $(PNGLIB_BASENAME)-config libpng-config
+	@set -x;\
+	cd '$(DESTDIR)$(libdir)';\
+	for ext in a la so so.@PNGLIB_MAJOR@@PNGLIB_MINOR@.@PNGLIB_RELEASE@\
+	   sl dylib dll.a; do\
+		rm -f libpng.$$ext;\
+                if test -f $(PNGLIB_BASENAME).$$ext; then\
+                       $(LN_S) $(PNGLIB_BASENAME).$$ext libpng.$$ext;\
+                fi;\
 	done
 
-uninstall-library-links:
-	@set -x; cd '$(DESTDIR)$(libdir)'; for ext in $(EXT_LIST); do\
-	   rm -f "libpng.$$ext"; done
-
-install-libpng-config:
-	@set -ex; cd '$(DESTDIR)$(bindir)'; rm -f libpng-config; \
-	   $(LN_S) '$(PNGLIB_BASENAME)-config' libpng-config
-
-uninstall-libpng-config:
+uninstall-hook:
+	cd '$(DESTDIR)$(includedir)'; rm -f png.h pngconf.h pnglibconf.h
+	rm -f '$(DESTDIR)$(pkgconfigdir)/libpng.pc'
 	rm -f '$(DESTDIR)$(bindir)/libpng-config'
-
-if DO_INSTALL_LINKS
-# If --enable-unversioned-links is specified the header and lib file links
-# will be automatically made on a 'make install':
-
-install-data-hook: install-header-links
-uninstall-hook: uninstall-header-links
-install-exec-hook: install-library-links
-uninstall-hook: uninstall-library-links
-endif
-
-if DO_INSTALL_LIBPNG_PC
-# Likewise, --install-pc causes libpng.pc to be constructed:
-
-install-data-hook: install-libpng-pc
-uninstall-hook: uninstall-libpng-pc
-endif
-
-if DO_INSTALL_LIBPNG_CONFIG
-# And --install-config:
-
-install-exec-hook: install-libpng-config
-uninstall-hook: uninstall-libpng-config
-endif
-
-# The following addition ensures that 'make all' always builds the test programs
-# too.  It used to, but some change either in libpng or configure stopped this
-# working.
-all-am: $(check_PROGRAMS)
+	rm -f '$(DESTDIR)$(libdir)/libpng.a'
+	rm -f '$(DESTDIR)$(libdir)/libpng.la'
+	rm -f '$(DESTDIR)$(libdir)/libpng.so'
+	rm -f '$(DESTDIR)$(libdir)/libpng.so.@PNGLIB_MAJOR@@PNGLIB_MINOR@.@PNGLIB_RELEASE@'
+	rm -f '$(DESTDIR)$(libdir)/libpng.sl'
+	rm -f '$(DESTDIR)$(libdir)/libpng.dylib'
+	rm -f '$(DESTDIR)$(libdir)/libpng.dll.a'

README

@@ -1,11 +1,11 @@
-README for libpng version 1.7.0beta52 - February 21, 2015 (shared library 17.0)
+README for libpng version 1.5.16beta06 - May 12, 2013 (shared library 15.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 or
-libpng-*.tar.xz or if you want UNIX-style line endings in the text files,
-or lpng*.7z or lpng*.zip if you want DOS-style line endings.
+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.
 
 Version 0.89 was the first official release of libpng.  Don't let the
 fact that it's the first release fool you.  The libpng library has been in
@@ -23,25 +23,18 @@ earlier versions if you are using a shared library.  The type of the
 png_uint_32, which will affect shared-library applications that use
 this function.
 
-To avoid problems with changes to the internals of png info_struct,
+To avoid problems with changes to the internals of png_info_struct,
 new APIs have been made available in 0.95 to avoid direct application
 access to info_ptr.  These functions are the png_set_<chunk> and
 png_get_<chunk> functions.  These functions should be used when
 accessing/storing the info_struct data, rather than manipulating it
 directly, to avoid such problems in the future.
 
-It is important to note that the APIs did not make current programs
+It is important to note that the APIs do not make current programs
 that access the info struct directly incompatible with the new
-library, through libpng-1.2.x.  In libpng-1.4.x, which was meant to
-be a transitional release, members of the png_struct and the
-info_struct can still be accessed, but the compiler will issue a
-warning about deprecated usage.  Since libpng-1.5.0, direct access
-to these structs is not allowed, and the definitions of the structs
-reside in private pngstruct.h and pnginfo.h header files that are not
-accessible to applications.  It is strongly suggested that new
-programs use the new APIs (as shown in example.c and pngtest.c), and
-older programs be converted to the new format, to facilitate upgrades
-in the future.
+library.  However, it is strongly suggested that new programs use
+the new APIs (as shown in example.c and pngtest.c), and older programs
+be converted to the new format, to facilitate upgrades in the future.
 ****
 
 Additions since 0.90 include the ability to compile libpng as a
@@ -84,21 +77,17 @@ 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 zlib.net.
+zlib should be available at the same place that libpng is, or at.
+ftp://ftp.info-zip.org/pub/infozip/zlib
 
 You may also want a copy of the PNG specification.  It is available
 as an RFC, a W3C Recommendation, and an ISO/IEC Standard.  You can find
 these at http://www.libpng.org/pub/png/documents/
 
 This code is currently being archived at libpng.sf.net in the
-[DOWNLOAD] area, and at ftp://ftp.simplesystems.org.  If you can't find it
-in any of those places, e-mail me, and I'll help you find it.
-
-I am not a lawyer, but I believe that the Export Control Classification
-Number (ECCN) for libpng is EAR99, which means not subject to export
-controls or International Traffic in Arms Regulations (ITAR) because it
-is open source, publicly available software, that does not contain any
-encryption software.  See the EAR, paragraphs 734.3(b)(3) and 734.7(b).
+[DOWNLOAD] area, and on CompuServe, Lib 20 (PNG SUPPORT)
+at GO GRAPHSUP.  If you can't find it in any of those places,
+e-mail me, and I'll help you find it.
 
 If you have any code changes, requests, problems, etc., please e-mail
 them to me.  Also, I'd appreciate any make files or project files,
@@ -116,7 +105,7 @@ based in a large way on Guy's and Andreas' earlier work), and the PNG
 development group.
 
 Send comments/corrections/commendations to png-mng-implement at
-lists.sourceforge.net (subscription required; visit
+lists.sourceforge.net (subscription required; visit 
 https://lists.sourceforge.net/lists/listinfo/png-mng-implement
 to subscribe) or to glennrp at users.sourceforge.net
 
@@ -134,7 +123,7 @@ and ...".  If in doubt, send questions to me.  I'll bounce them
 to others, if necessary.
 
 Please do not send suggestions on how to change PNG.  We have
-been discussing PNG for nineteen years now, and it is official and
+been discussing PNG for sixteen 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.
@@ -178,25 +167,23 @@ Files in this distribution:
       pngwrite.c    =>  High-level write functions
       pngwtran.c    =>  Write data transformations
       pngwutil.c    =>  Write utility functions
-      arm           =>  Contains optimized code for the ARM platform
       contrib       =>  Contributions
-       examples         =>  Example programs
        gregbook         =>  source code for PNG reading and writing, from
                             Greg Roelofs' "PNG: The Definitive Guide",
                             O'Reilly, 1999
-       libtests         =>  Test programs
-       pngminim         =>  Minimal decoder, encoder, and progressive decoder
-                            programs demonstrating use of pngusr.dfa
-       pngminus         =>  Simple pnm2png and png2pnm programs
-       pngsuite         =>  Test images
-       tools            =>  Various tools
-       visupng          =>  Contains a MSVC workspace for VisualPng
+       msvctest     =>  Builds and runs pngtest using a MSVC workspace
+       pngminus     =>  Simple pnm2png and png2pnm programs
+       pngsuite     =>  Test images
+       visupng      =>  Contains a MSVC workspace for VisualPng
       projects      =>  Contains project files and workspaces for
                         building a DLL
-       owatcom          =>  Contains a WATCOM project for building libpng
+       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
-       vstudio          =>  Contains a Microsoft Visual C++ (MSVC)
+       xcode            =>  Contains an Apple xcode
                             workspace for building libpng and zlib
       scripts       =>  Directory containing scripts for building libpng:
                             (see scripts/README.txt for the list of scripts)

TODO

@@ -6,12 +6,10 @@ 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.
-Palette creation.
 Add "grayscale->palette" transformation and "palette->grayscale" detection.
 Improved dithering.
 Multi-lingual error and warning message support.
 Complete sRGB transformation (presently it simply uses gamma=0.45455).
-Make profile checking optional via a png_set_something() call.
 Man pages for function calls.
 Better documentation.
 Better filter selection

arm/arm_init.c

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

arm/filter_neon.S

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

arm/filter_neon_intrinsics.c

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

autogen.sh

@@ -1,224 +1,34 @@
 #! /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 run autogen.sh because ./configure --enable-maintainer-mode says
-# what to do if Makefile.am or configure.ac are changed.
-#
-# It is *probably* OK to update the files on a GIT checkout, because they have
-# come from the local tools, but leave that to the user who is assumed to know
-# whether it is ok or required.
-#
-# This script is intended to work without arguments, there are, however, hidden
-# arguments (a) for use while testing the script and (b) to fix up systems that
-# 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;;
+# WARNING: if you run this you will change the versions
+# of the tools which are used and, maybe, required!
 
-      --clean)
-         clean=1;;
+# You can define your own replacements in your environment.
+# $AUTOCONF,  $AUTOMAKE, $AUTOHEADER, $AUTOPOINT, $ACLOCAL and $LIBTOOLIZE
 
-      *)
-         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"
-#
-# Files generated by versions of configue >2.68 or automake >1.13 (i.e. later
-# versions than those required by configure.ac):
-libpng_autotools_extra="compile"
-#
-# 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
-   rm -rf $libpng_autotools_extra
-}
-
-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 "  compatibility 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
+touch Makefile.am configure.ac
+{
+   LT=${LIBTOOLIZE-libtoolize}
+   echo "running $LT" >&2
+   $LT --force --copy --automake
+} && {
+   AL=${ACLOCAL-aclocal}
+   echo "running $AL" >&2
+   $AL
+} && {
+   AH=${AUTOHEADER-autoheader}
+   echo "running $AH [ignore the warnings]" >&2
+   $AH
+} && {
+   AM=${AUTOMAKE-automake}
+   echo "running $AM" >&2
+   $AM --force-missing --foreign -a -c
+} && {
+   AC=${AUTOCONF-autoconf}
+   echo "running $AC" >&2
+   $AC
+} &&
+   echo "autogen complete" >&2 ||
+   echo "ERROR: autogen.sh failed, autogen is incomplete" >&2

config.h.in

@@ -0,0 +1,115 @@
+/* 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 `feenableexcept' function. */
+#undef HAVE_FEENABLEEXCEPT
+
+/* 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
+
+/* Turn on ARM Neon optimizations at run-time */
+#undef PNG_ARM_NEON_API_SUPPORTED
+
+/* Check for ARM Neon support at run-time */
+#undef PNG_ARM_NEON_CHECK_SUPPORTED
+
+/* Enable ARM Neon optimizations */
+#undef PNG_ARM_NEON_SUPPORTED
+
+/* Disable ARM Neon optimizations */
+#undef PNG_NO_ARM_NEON
+
+/* 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 the equivalent of the C99 'restrict' keyword, or to
+   nothing if this is not supported.  Do not define if restrict is
+   supported directly.  */
+#undef restrict
+/* Work around a bug in Sun C++: it does not support _Restrict or
+   __restrict__, even though the corresponding Sun C compiler ends up with
+   "#define restrict _Restrict" or "#define restrict __restrict__" in the
+   previous line.  Perhaps some future version of Sun C++ will work with
+   restrict; if so, hopefully it defines __RESTRICT like Sun C does.  */
+#if defined __SUNPRO_CC && !defined __RESTRICT
+# define _Restrict
+# define __restrict__
+#endif
+
+/* Define to `unsigned int' if <sys/types.h> does not define. */
+#undef size_t

configure.ac

@@ -14,35 +14,19 @@ 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.7.0beta52],[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 subdir-objects])
-# The following line causes --disable-maintainer-mode to be the default to
-# configure, this is necessary because libpng distributions cannot rely on the
-# time stamps of the autotools generated files being correct
+AC_INIT([libpng], [1.5.16beta06], [png-mng-implement@lists.sourceforge.net])
+AM_INIT_AUTOMAKE([serial-tests])
+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.7.0beta52
+PNGLIB_VERSION=1.5.16beta06
 PNGLIB_MAJOR=1
-PNGLIB_MINOR=7
-PNGLIB_RELEASE=0
+PNGLIB_MINOR=5
+PNGLIB_RELEASE=16
 
 dnl End of version number stuff
 
@@ -53,202 +37,52 @@ AC_CONFIG_HEADERS([config.h])
 AC_LANG([C])
 AC_PROG_CC
 AM_PROG_AS
-LT_PATH_LD
+AC_PROG_LD
 AC_PROG_CPP
+AC_PROG_SED
 AC_PROG_AWK
 AC_PROG_INSTALL
 AC_PROG_LN_S
 AC_PROG_MAKE_SET
-
-dnl libtool/libtoolize; version 2.4.4 is the tested version, this or any
-dnl compatible later version may be used
 LT_INIT([win32-dll])
-LT_PREREQ([2.4.4])
-
-# 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 -E"
-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],)
 
 # Checks for header files.
 AC_HEADER_STDC
-# Headers used in pngpriv.h:
-AC_CHECK_HEADERS([assert.h stdlib.h string.h float.h fp.h math.h m68881.h])
-# Additional headers used in pngconf.h:
-AC_CHECK_HEADERS([limits.h stddef.h stdio.h setjmp.h time.h])
-# Used by pngread.c (for the simplified API):
-AC_CHECK_HEADERS([errno.h])
-# The following are not required for the standard 'make' build of libpng:
-# Additional requirements of contrib/libtests/makepng.c:
-AC_CHECK_HEADERS([ctype.h])
-# Additional requirements of contrib/libtests/pngvalid.c:
-AC_CHECK_HEADERS([fenv.h])
+AC_CHECK_HEADERS([malloc.h stdlib.h string.h strings.h])
 
 # Checks for typedefs, structures, and compiler characteristics.
-# Most of these have been removed from 1.7.0 because they checked for non-ANSI-C
-# behaviors and the result were, anyway, not used by earlier versions of libpng.
+AC_C_CONST
+AC_TYPE_SIZE_T
+AC_STRUCT_TM
 AC_C_RESTRICT
 
-# Checks for library functions; these need to be in order, least demanding to
-# most because the -l directives are added to the head of the list at each
-# check.
-# ANSI-C functions: all are required but they don't have to be implemented in
-# libc, it is perfectly ok to configure with an extra, wrapper, library preset
-# in LIBS.  NOTE: this list may not be complete
-AC_CHECK_FUNCS([memset memcpy strncpy],,
-               AC_MSG_FAILURE([missing ANSI-C functions]))
+# 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)
 
-# floor and ceil are required for FLOATING_POINT, but they can be turned off on
-# the configure command line (and they are independent.)  Default is to 'on'
-AC_ARG_ENABLE([floating-point],
-   AS_HELP_STRING([[[--enabled-floating-point]]],
-      [Enable floating point APIs (default: yes)]),,
-   [enable_floating_point=yes])
-
-AC_ARG_ENABLE([fixed-point],
-   AS_HELP_STRING([[[--enable-fixed-point]]],
-      [Enable fixed point APIs (default: yes)]),,
-   [enable_fixed_point=yes])
-
-AC_ARG_ENABLE([floating-arithmetic],
-   AS_HELP_STRING([[[--enable-floating-arithmetic]]],
-      [Use floating point arithmetic internally (default: yes)]),,
-   [enable_floating_arithmetic=yes])
-
-# Check for a requirement for math library support
-if test "$enable_floating_arithmetic" = yes
-then
-   AC_SEARCH_LIBS([floor],[m],,
-                  [AC_MSG_WARN([not found])
-                   enable_floating_arithmetic=no])
-   AC_SEARCH_LIBS([frexp],[m],,
-                  [AC_MSG_WARN([not found])
-                   enable_floating_arithmetic=no])
-   AC_SEARCH_LIBS([modf],[m],,
-                  [AC_MSG_WARN([not found])
-                   enable_floating_arithmetic=no])
-   AC_SEARCH_LIBS([atof],[m],,
-                  [AC_MSG_WARN([not found])
-                   enable_floating_arithmetic=no])
-   AC_SEARCH_LIBS([pow],[m],,
-                  [AC_MSG_WARN([not found])
-                   enable_floating_arithmetic=no])
-fi
-
-# Set the relevant defines if required (only if required), this will override
-# anything on the command line.
-if test "$enable_floating_point" != yes
-then
-   AC_MSG_NOTICE([Floating point APIs disabled])
-   AC_DEFINE([PNG_NO_FLOATING_POINT],[1],
-             [No support for floating point APIs])
-fi
-if test "$enable_fixed_point" != yes
-then
-   AC_MSG_NOTICE([Fixed point APIs disabled])
-   AC_DEFINE([PNG_NO_FIXED_POINT],[1],
-             [No support for fixed point APIs])
-fi
-if test "$enable_floating_arithmetic" != yes
-then
-   AC_MSG_NOTICE([Fixed point arithmetic will be used])
-   AC_DEFINE([PNG_NO_FLOATING_ARITHMETIC],[1],
-             [No support for floating point arithmetic])
-fi
+# Checks for library functions.
+AC_FUNC_STRTOD
+AC_CHECK_FUNCS([memset], , AC_ERROR([memset not found in libc]))
+AC_CHECK_FUNCS([pow], , AC_CHECK_LIB(m, pow, , AC_ERROR([cannot find pow])) )
+AC_ARG_WITH(zlib-prefix,
+   AC_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_ERROR([zlib not installed])))
 
 # The following is for pngvalid, to ensure it catches FP errors even on
 # platforms that don't enable FP exceptions, the function appears in the math
 # library (typically), it's not an error if it is not found.
-AC_SEARCH_LIBS([feenableexcept],[m],AC_DEFINE([HAVE_FEENABLEEXCEPT],[1],
-      [Define to 1 if the feenableexcept function is available]))
-# Required by pngvalid:
-AC_SEARCH_LIBS([ceil],[m])
+AC_CHECK_LIB([m], [feenableexcept])
+AC_CHECK_FUNCS([feenableexcept])
 
-# zlib checks and arguments;
-#  package zlib: argument is the name of the library
-#  zlib-header: the name of the header file
-#  zlib-prefix: the prefix for library functions, if any
-AC_ARG_WITH([zlib],
-   AS_HELP_STRING([[[--with-zlib=<name>]]],
-                  [base name of the zlib implementation (e.g. 'z')]),,
-   [with_zlib='z'])
-
-z_prefix=
-AC_ARG_WITH([zlib-prefix],
-   AS_HELP_STRING([[[--with-zlib-prefix=<prefix>]]],
-                  [prefix for zlib API functions]),
-   [if test "$withval" = "" -o "$withval" = yes; then
-      with_zlib_prefix='z_'
-      AC_DEFINE([PNG_ZLIB_PREFIX],[z_],[Standard zlib prefix])
-   elif test "${withval}" != "no"; then
-      AC_DEFINE_UNQUOTED([PNG_ZLIB_PREFIX],[${withval}],
-         [User defined zlib prefix])
-   else
-      with_zlib_prefix=
-   fi
-   if test "$with_zlib_prefix" != ""; then
-      AC_DEFINE([Z_PREFIX],[1],[Tell zlib.h to prefix function names])
-      z_prefix="#define Z_PREFIX 1"
-   fi])
-
-AC_ARG_WITH([zlib-header],
-   AS_HELP_STRING([[[--with-zlib-header='<file>' or '"file"']]],
-      [C include argument to locate zlib header file, e.g. <zlib.h>, take
-       care to put single quotes round this on the command line]),
-   [AC_DEFINE_UNQUOTED([PNG_ZLIB_HEADER],[${withval}],[Zlib header file])],
-   with_zlib_header='<zlib.h>')
-
-# AC_CHECK_LIB isn't quite enough for this because we need the special header
-# file too.
-LIBS="-l${with_zlib} $LIBS"
-AC_MSG_CHECKING(
-   [[Library '${with_zlib}' and #include ${with_zlib_header} for symbol '${with_zlib_prefix}zlibVersion']])
-AC_LINK_IFELSE(
-   [AC_LANG_PROGRAM(
-      [[
-${z_prefix}
-#include ${with_zlib_header}
-      ]],
-      [[(void)${with_zlib_prefix}zlibVersion();]])],
-   AC_MSG_RESULT([ok]),
-   AC_MSG_FAILURE([not found]))
+LIBPNG_DEFINES=-DPNG_CONFIGURE_LIBPNG
+LIBPNG_DEFINES=$LIBPNG_DEFINES
+AC_SUBST(LIBPNG_DEFINES)
 
 AC_MSG_CHECKING([if using Solaris linker])
 SLD=`$LD --version 2>&1 | grep Solaris`
@@ -294,7 +128,7 @@ AM_CONDITIONAL(HAVE_LD_VERSION_SCRIPT, test "$have_ld_version_script" = "yes")
 if test "$have_ld_version_script" = "yes"; then
     AC_MSG_CHECKING([for symbol prefix])
     SYMBOL_PREFIX=`echo "PREFIX=__USER_LABEL_PREFIX__" \
-                  | ${DFNCPP-${CC-gcc -E}} - 2>&1 \
+                  | ${CPP-${CC-gcc} -E} - 2>&1 \
                   | ${EGREP-grep} "^PREFIX=" \
                   | ${SED-sed} -e "s:^PREFIX=::" -e "s:__USER_LABEL_PREFIX__::"`
     AC_SUBST(SYMBOL_PREFIX)
@@ -310,77 +144,28 @@ 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"])
-
-# Control over what links are made for installed files.  Versioned files are
-# always installed, when the following options are turned on corresponding
-# unversioned links are also created (normally as symbolic links):
-AC_ARG_ENABLE([unversioned-links],
-   AS_HELP_STRING([[[--enable-unversioned-links]]],
-      [Installed libpng header files are placed in a versioned subdirectory]
-      [and installed libpng library (including DLL) files are versioned.]
-      [If this option is enabled unversioned links will be created pointing to]
-      [the corresponding installed files.  If you use libpng.pc or]
-      [libpng-config for all builds you do not need these links, but if you]
-      [compile programs directly they will typically #include <png.h> and]
-      [link with -lpng; in that case you need the links.]
-      [The links can be installed manually using 'make install-header-links']
-      [and 'make install-library-links' and can be removed using the]
-      [corresponding uninstall- targets.  If you do enable this option every]
-      [libpng 'make install' will recreate the links to point to the just]
-      [installed version of libpng.  The default is to create the links;]
-      [use --disable-unversioned-links to change this]))
-
-# The AM_CONDITIONAL test is written so that the default is enabled;
-# --disable-unversioned-links must be given to turn the option off.
-AM_CONDITIONAL([DO_INSTALL_LINKS],[test "$enable_unversioned_links" != "no"])
-
-AC_ARG_ENABLE([unversioned-libpng-pc],
-   AS_HELP_STRING([[[--enable-unversioned-libpng-pc]]],
-      [Install the configuration file 'libpng.pc' as a link to the versioned]
-      [version.  This is done by default - use --disable-unversioned-libpng-pc]
-      [to change this.]))
-AM_CONDITIONAL([DO_INSTALL_LIBPNG_PC],
-   [test "$enable_unversioned_libpng_pc" != "no"])
-
-AC_ARG_ENABLE([unversioned-libpng-config],
-   AS_HELP_STRING([[[--enable-unversioned-libpng-config]]],
-      [Install the configuration file 'libpng-config' as a link to the]
-      [versioned version.  This is done by default - use]
-      [--disable-unversioned-libpng-config to change this.]))
-AM_CONDITIONAL([DO_INSTALL_LIBPNG_CONFIG],
-   [test "$enable_unversioned_libpng_config" != "no"])
-
 # HOST SPECIFIC OPTIONS
 # =====================
 #
@@ -394,12 +179,11 @@ AC_ARG_ENABLE([arm-neon],
       [Enable ARM NEON optimizations: =no/off, check, api, yes/on:]
       [no/off: disable the optimizations; check: use internal checking code]
       [(deprecated and poorly supported); api: disable by default, enable by]
-      [a call to png_set_option; yes/on: turn on unconditionally.]
-      [If not specified: determined by the compiler.]),
+      [a call to png_set_option; yes/on: turn on unconditionally.]),
    [case "$enableval" in
       no|off)
          # disable the default enabling on __ARM_NEON__ systems:
-         AC_DEFINE([PNG_ARM_NEON_OPT], [0],
+         AC_DEFINE([PNG_NO_ARM_NEON], [],
                    [Disable ARM Neon optimizations])
          # Prevent inclusion of the assembler files below:
          enable_arm_neon=no;;
@@ -410,11 +194,8 @@ AC_ARG_ENABLE([arm-neon],
          AC_DEFINE([PNG_ARM_NEON_API_SUPPORTED], [],
                    [Turn on ARM Neon optimizations at run-time]);;
       yes|on)
-         AC_DEFINE([PNG_ARM_NEON_OPT], [2],
-                   [Enable ARM Neon optimizations])
-         AC_MSG_WARN([--enable-arm-neon: please specify 'check' or 'api', if]
-            [you want the optimizations unconditionally pass -mfpu=neon]
-            [to the compiler.]);;
+         AC_DEFINE([PNG_ARM_NEON_SUPPORTED], [],
+                   [Enable ARM Neon optimizations]);;
       *)
          AC_MSG_ERROR([--enable-arm-neon=${enable_arm_neon}: invalid value])
    esac])
@@ -426,14 +207,15 @@ AC_ARG_ENABLE([arm-neon],
 AM_CONDITIONAL([PNG_ARM_NEON],
    [test "$enable_arm_neon" != 'no' &&
     case "$host_cpu" in
-      arm*|aarch64*) :;;
+      arm*) :;;
       *)    test "$enable_arm_neon" != '';;
     esac])
-
+ 
 AC_MSG_NOTICE([[Extra options for compiler: $PNG_COPTS]])
 
 # Config files, substituting as above
-AC_CONFIG_FILES([Makefile libpng.pc])
-AC_CONFIG_FILES([libpng-config], [chmod +x libpng-config])
+AC_CONFIG_FILES([Makefile libpng.pc:libpng.pc.in])
+AC_CONFIG_FILES([libpng-config:libpng-config.in],
+		[chmod +x libpng-config])
 
 AC_OUTPUT

contrib/arm-neon/README

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

contrib/arm-neon/android-ndk.c

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

contrib/arm-neon/linux-auxv.c

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

contrib/arm-neon/linux.c

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

contrib/conftest/README

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

contrib/conftest/read.dfa

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

contrib/conftest/s_read.dfa

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

contrib/conftest/s_write.dfa

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

contrib/conftest/simple.dfa

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

contrib/conftest/write.dfa

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

contrib/examples/README.txt

@@ -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 that 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, "pngpixel: 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/Makefile.mingw32

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

contrib/gregbook/Makefile.sgi

@@ -23,9 +23,9 @@
 
 # macros --------------------------------------------------------------------
 
-PNGINC = -I/usr/local/include/libpng17
-PNGLIB = -L/usr/local/lib -lpng17	  # dynamically linked against libpng
-#PNGLIB = /usr/local/lib/libpng17.a # statically linked against libpng
+PNGINC = -I/usr/local/include/libpng15
+PNGLIB = -L/usr/local/lib -lpng15	  # dynamically linked against libpng
+#PNGLIB = /usr/local/lib/libpng15.a # statically linked against libpng
 # or:
 #PNGINC = -I../..
 #PNGLIB = -L../.. -lpng
@@ -53,8 +53,7 @@ CC = cc
 LD = cc
 RM = rm -f
 # ABI must be the same as that used to build libpng.
-ABI =
-CPPFLAGS =
+ABI=
 CFLAGS = $(ABI) -O -fullwarn $(INCS)
 LDFLAGS = $(ABI)
 O = .o
@@ -74,7 +73,7 @@ EXES = $(RPNG)$(E) $(RPNG2)$(E) $(WPNG)$(E)
 # implicit make rules -------------------------------------------------------
 
 .c$(O):
-	$(CC) -c $(CPPFLAGS) $(CFLAGS) $<
+	$(CC) -c $(CFLAGS) $<
 
 
 # dependencies --------------------------------------------------------------

contrib/gregbook/Makefile.unx

@@ -26,14 +26,14 @@
 # macros --------------------------------------------------------------------
 
 #PNGDIR = /usr/local/lib
-#PNGINC = -I/usr/local/include/libpng17
-#PNGLIBd = -L$(PNGDIR) -lpng17 # dynamically linked, installed libpng
-#PNGLIBs = $(PNGDIR)/libpng17.a # statically linked, installed libpng
+#PNGINC = -I/usr/local/include/libpng15
+#PNGLIBd = -L$(PNGDIR) -lpng15 # dynamically linked, installed libpng
+#PNGLIBs = $(PNGDIR)/libpng15.a # statically linked, installed libpng
 # or:
 PNGDIR = ../..#	this one is for libpng-x.y.z/contrib/gregbook builds
 #PNGDIR = ../libpng
 PNGINC = -I$(PNGDIR)
-PNGLIBd = -Wl,-rpath,$(PNGDIR) -L$(PNGDIR) -lpng17	# dynamically linked
+PNGLIBd = -Wl,-rpath,$(PNGDIR) -L$(PNGDIR) -lpng15	# dynamically linked
 PNGLIBs = $(PNGDIR)/libpng.a		# statically linked, local libpng
 
 ZDIR = /usr/local/lib
@@ -64,8 +64,7 @@ WLIBSs = $(PNGLIBs) $(ZLIBs)
 CC = gcc
 LD = gcc
 RM = rm -f
-CPPFLAGS = $(INCS) -DFEATURE_LOOP
-CFLAGS = -O -Wall
+CFLAGS = -O -Wall $(INCS) -DFEATURE_LOOP
 # [note that -Wall is a gcc-specific compilation flag ("most warnings on")]
 # [-ansi, -pedantic and -W can also be used]
 LDFLAGS =
@@ -93,7 +92,7 @@ EXES = $(STATIC_EXES) $(DYNAMIC_EXES)
 # implicit make rules -------------------------------------------------------
 
 .c$(O):
-	$(CC) -c $(CPPFLAGS) $(CFLAGS) $<
+	$(CC) -c $(CFLAGS) $<
 
 
 # dependencies --------------------------------------------------------------

contrib/gregbook/Makefile.w32

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

contrib/gregbook/readpng2.c

@@ -69,7 +69,6 @@ static void readpng2_row_callback(png_structp png_ptr, png_bytep new_row,
                                  png_uint_32 row_num, int pass);
 static void readpng2_end_callback(png_structp png_ptr, png_infop info_ptr);
 static void readpng2_error_handler(png_structp png_ptr, png_const_charp msg);
-static void readpng2_warning_handler(png_structp png_ptr, png_const_charp msg);
 
 
 
@@ -105,7 +104,7 @@ int readpng2_init(mainprog_info *mainprog_ptr)
     /* could also replace libpng warning-handler (final NULL), but no need: */
 
     png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, mainprog_ptr,
-      readpng2_error_handler, readpng2_warning_handler);
+      readpng2_error_handler, NULL);
     if (!png_ptr)
         return 4;   /* out of memory */
 
@@ -137,23 +136,29 @@ int readpng2_init(mainprog_info *mainprog_ptr)
      * 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 */
 
@@ -448,8 +453,6 @@ static void readpng2_end_callback(png_structp png_ptr, png_infop info_ptr)
 
     /* all done */
 
-    (void)info_ptr; /* Unused */
-
     return;
 }
 
@@ -470,12 +473,7 @@ void readpng2_cleanup(mainprog_info *mainprog_ptr)
 }
 
 
-static void readpng2_warning_handler(png_structp png_ptr, png_const_charp msg)
-{
-    fprintf(stderr, "readpng2 libpng warning: %s\n", msg);
-    fflush(stderr);
-    (void)png_ptr; /* Unused */
-}
+
 
 
 static void readpng2_error_handler(png_structp png_ptr, png_const_charp msg)

contrib/gregbook/readppm.c

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

contrib/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))
-         {
-            size_t 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,4 +1,3 @@
-
 This demonstrates the use of PNG_USER_CONFIG, pngusr.h and pngusr.dfa
 to build minimal decoder, encoder, and progressive reader applications.
 

contrib/pngminim/decoder/makefile

@@ -15,7 +15,7 @@ RM=rm -f
 COPY=cp
 
 CPPFLAGS=-I. -DPNG_USER_CONFIG -DNO_GZCOMPRESS -DZ_SOLO -DNO_GZIP
-CFLAGS=-O1 -Wall
+CFLAGS=-O1
 
 C=.c
 O=.o
@@ -100,12 +100,12 @@ $(PNGCONF): $(PNGSRC)/scripts/pnglibconf.mak $(ZH)\
 	$(PNGSRC)/scripts/pnglibconf.dfa \
 	$(PNGSRC)/scripts/options.awk pngusr.h pngusr.dfa
 	$(RM) pnglibconf.h pnglibconf.dfn
-	$(MAKE) -f $(PNGSRC)/scripts/pnglibconf.mak $(MAKEFLAGS)\
+	$(MAKE) $(MAKEFLAGS) -f $(PNGSRC)/scripts/pnglibconf.mak\
 	    srcdir=$(PNGSRC) CPPFLAGS="-DPNG_USER_CONFIG -I."\
 	    DFA_XTRA="pngusr.dfa" $@
 
 clean:
-	$(MAKE) -f $(PNGSRC)/scripts/pnglibconf.mak $(MAKEFLAGS)\
+	$(MAKE) $(MAKEFLAGS) -f $(PNGSRC)/scripts/pnglibconf.mak\
 	    srcdir=$(PNGSRC) clean
 	$(RM) pngm2pnm$(O)
 	$(RM) pngm2pnm$(E)

contrib/pngminim/decoder/pngusr.dfa

@@ -1,6 +1,6 @@
 # pngminim/decoder/pngusr.dfa
 #
-# Copyright (c) 2010-2013 Glenn Randers-Pehrson
+# Copyright (c) 2010-2011 Glenn Randers-Pehrson
 #
 # This code is released under the libpng license.
 # For conditions of distribution and use, see the disclaimer
@@ -37,4 +37,3 @@ 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, 2010-2011 Glenn Randers-Pehrson
  *
  * This code is released under the libpng license.
  * For conditions of distribution and use, see the disclaimer
@@ -18,6 +18,7 @@
  * affect the API (so are not recorded in pnglibconf.h)
  */
 
+#define PNG_NO_WARNINGS
 #define PNG_ALIGN_TYPE PNG_ALIGN_NONE
 
 #endif /* MINRDPNGCONF_H */

contrib/pngminim/encoder/makefile

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

contrib/pngminim/encoder/pngusr.dfa

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

contrib/pngminim/encoder/pngusr.h

@@ -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, 2010-2011 Glenn Randers-Pehrson
  *
  * This code is released under the libpng license.
  * For conditions of distribution and use, see the disclaimer
@@ -18,6 +18,7 @@
  * affect the API (so are not recorded in pnglibconf.h)
  */
 
+#define PNG_NO_WARNINGS
 #define PNG_ALIGN_TYPE PNG_ALIGN_NONE
 
 #endif /* MINWRPNGCONF_H */

contrib/pngminim/preader/makefile

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

contrib/pngminim/preader/pngusr.dfa

@@ -1,6 +1,6 @@
 # pngminim/preader/pngusr.dfa
 #
-# Copyright (c) 2010-2013 Glenn Randers-Pehrson
+# Copyright (c) 2010-2011 Glenn Randers-Pehrson
 #
 # This code is released under the libpng license.
 # For conditions of distribution and use, see the disclaimer

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, 2010-2011 Glenn Randers-Pehrson
  *
  * This code is released under the libpng license.
  * For conditions of distribution and use, see the disclaimer
@@ -18,6 +18,7 @@
  * affect the API (so are not recorded in pnglibconf.h)
  */
 
+#define PNG_NO_WARNINGS
 #define PNG_ALIGN_TYPE PNG_ALIGN_NONE
 
 #endif /* MINPRDPNGCONF_H */

contrib/pngminus/makefile.std

@@ -8,9 +8,9 @@ LD=$(CC)
 RM=rm -f
 
 #PNGPATH = /usr/local
-#PNGINC = -I$(PNGPATH)/include/libpng17
-#PNGLIB = -L$(PNGPATH)/lib -lpng17
-#PNGLIBS = $(PNGPATH)/lib/libpng17.a
+#PNGINC = -I$(PNGPATH)/include/libpng15
+#PNGLIB = -L$(PNGPATH)/lib -lpng15
+#PNGLIBS = $(PNGPATH)/lib/libpng15.a
 PNGINC = -I../..
 PNGLIB = -L../.. -lpng
 PNGLIBS = ../../libpng.a

contrib/pngminus/png2pnm.c

@@ -18,7 +18,6 @@
 #include <mem.h>
 #include <fcntl.h>
 #endif
-#include <zlib.h>
 
 #ifndef BOOL
 #define BOOL unsigned char

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/chunkhash.c

@@ -1,437 +0,0 @@
-/* chunkhash.c -- build a perfect hash code for the chunk names on stdin.
- *
- * Last changed in libpng 1.7.0 [(PENDING RELEASE)]
- *
- * COPYRIGHT: Written by John Cunningham Bowler, 2014.
- * To the extent possible under law, the author has waived all copyright and
- * related or neighboring rights to this work.  This work is published from:
- * United States.
- *
- * Feed this program all the known chunks that libpng must recognize.  It will
- * generate an appropriate hash key for the macro in pngpriv.h  To generate the
- * list of chunks currently defined in png.h do this:
- *
- *    sed -n -e 's/^#define png_\(....\) PNG_U32.*$/\1/p' png.h
- *
- * An alternative to using this program is to pipe the output of the above
- * through gperf, however the code generated by perf is somewhat more verbose
- * and it doesn't generate as good a result (however it's a heck of a lot faster
- * than this program!)
- */
-#include <stdio.h>
-#include <string.h>
-#include <stdlib.h>
-#include <png.h> /* for the libpng types for this platform */
-
-/* The machine generated file is checked in, so this works and it obtains the
- * definition of the PNG_CHUNK_HASH macro.  To change this definition only ever
- * alter the strings below!
- */
-#include "chunkhash.h"
-
-/* The best_ variables are local variables defined in the functions below.  When
- * used in libpng code, however, they are just constants.
- */
-#define PNG_CHUNK_HASH_MASK best_mask
-#define PNG_CHUNK_HASH_C0 best_c[0]
-#define PNG_CHUNK_HASH_C1 best_c[1]
-#define PNG_CHUNK_HASH_C2 best_c[2]
-#define PNG_CHUNK_HASH_C3 best_c[3]
-
-/* These strings contain the C text to copy into the new version of
- * contrib/tools/chunkhash.c
- */
-static const char *strings[] = {
-"/* chunkhash.h -- a perfect hash code for the chunk names in png.h",
-" *",
-" * Last changed in libpng 1.7.0 [(PENDING RELEASE)]",
-" *",
-" * THIS IS A MACHINE GENERATED FILE.  See contrib/tools/chunkhash.c for",
-" * copyright and other information.",
-" *",
-" * USAGE:  To include the PNG_CHUNK_HASH macro and associated definitions:",
-" *",
-" * #define PNG_CHUNKHASH_DEFS",
-" * #include \"contrib/tools/chunkhash.h\"",
-" *",
-" * To define the png_chunk_hash array used by the macro:",
-" *",
-" * #define PNG_CHUNKHASH_CODE",
-" * #include \"contrib/tools/chunkhash.h\"",
-" *",
-" * One or both of the defines must be given except when building chunkhash",
-" * itself.",
-" */",
-"#ifdef PNG_CHUNKHASH_DEFS",
-"#ifndef PNG_CHUNKHASH_H",
-"#define PNG_CHUNKHASH_H",
-"/* A perfect hash code - returns a value 0..(PNG_KNOWN_CHUNK_COUNT-1) and is",
-" * generated by the ridiculously simple program in contrib/tools/chunkhash.c",
-" *",
-" * The hash code used here multiplies each byte by a different constant to",
-" * return a single number:",
-" *",
-" *    b0 * c[0] + b1 * [c1] + b2 * c[2] + b3 * c[3]",
-" *",
-" * The values of the constants are found by search using the a table of",
-" * primes, including 0, and may be (in fact are at present) 0 for some of the",
-" * bytes, the compiler is expected to optimize multiply by zero, or one!",
-" *",
-" * The lookup table reduces the sparse result of the hash calculation to the",
-" * correct index values.  The chunks are indexed in the string order of the",
-" * png_uint_32 chunk names.",
-" */",
-0, /* HEADER definitions go here */
-"",
-"extern const png_byte png_chunk_hash[PNG_CHUNK_HASH_MASK+1];",
-"#endif /* !PNG_CHUNKHASH_H */",
-"#endif /* PNG_CHUNKHASH_DEFS */",
-"",
-"#ifndef PNG_CHUNK_HASH",
-"#define PNG_CHUNK_HASH(chunk) (png_chunk_hash[PNG_CHUNK_HASH_MASK & (\\",
-"      ((chunk) >> 24) * PNG_CHUNK_HASH_C0 +\\",
-"      ((chunk) >> 16) * PNG_CHUNK_HASH_C1 +\\",
-"      ((chunk) >>  8) * PNG_CHUNK_HASH_C2 +\\",
-"      ((chunk)      ) * PNG_CHUNK_HASH_C3)])",
-"#endif",
-"",
-"#ifdef PNG_CHUNKHASH_CODE",
-"#ifndef PNG_CHUNKHASH_C",
-"#define PNG_CHUNKHASH_C",
-"const png_byte png_chunk_hash[PNG_CHUNK_HASH_MASK+1] = {",
-0, /* png.c definitions go here */
-"};",
-"#endif /* !PNG_CHUNKHASH_C */",
-"#endif /* PNG_CHUNKHASH_CODE */",
-0 /* end of file */
-};
-
-#define CHUNK_COUNT_MAX 32
-   /* If necessary this is easy to increase; just don't use a png_uint_32
-    * bitmask below, however it doesn't seem likely that the limit will be hit
-    * any time soon.
-    */
-
-static const png_byte
-chunk_hash[256] =
-{
-   0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
-   22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
-   41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59,
-   60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78,
-   79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97,
-   98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113,
-   114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128,
-   129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143,
-   144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158,
-   159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173,
-   174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188,
-   189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203,
-   204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218,
-   219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233,
-   234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248,
-   249, 250, 251, 252, 253, 254, 255
-};
-
-static void
-error(const char *string)
-{
-   fprintf(stderr, "chunkhash: %s\n", string);
-   exit(1);
-}
-
-/* Return a hash code for the given chunk; this is the same as the pngpriv.h
- * macro, but parameterized.  The names of the parameters have to be chosen to
- * match the above #defines.
- */
-static png_uint_32
-test_hash(png_uint_32 chunk, const unsigned int *best_c, png_uint_32 best_mask)
-{
-#  define png_chunk_hash chunk_hash /* prevents lookup */
-      return PNG_CHUNK_HASH(chunk);
-#  undef png_chunk_hash
-}
-
-static void
-print_chunks(const png_uint_32 *chunks, unsigned int nchunks, png_uint_32 first,
-   png_uint_32 last, const unsigned int *best_c, png_uint_32 best_mask,
-   const png_byte *lut)
-{
-   /* 'last' is the last code to print plus 1, this is used to detect duplicates
-    * (which should not happen - if there are any it's an internal error!)
-    */
-   if (nchunks > 0)
-   {
-      /* Recursive algorithm; find the hash code of the next chunk, then print
-       * all remaining chunks with codes in the range first..code (including
-       * duplicates) and after print all remaining chunks with codes in the
-       * range (code+1)..last
-       */
-      const png_uint_32 chunk = *chunks++;
-#     define png_chunk_hash lut
-         const png_uint_32 code = PNG_CHUNK_HASH(chunk);
-#     undef png_chunk_hash
-
-      --nchunks;
-
-      /* The code might be out of the print range */
-      if (code >= first && code <= last)
-      {
-         if (code >= first) /* not time yet */
-            print_chunks(chunks, nchunks, first, code, best_c, best_mask, lut);
-
-         printf("#define PNG_CHUNK_%c%c%c%c_TAG %lu%s\n", (char)(chunk>>24),
-            (char)(chunk>>16), (char)(chunk>>8), (char)chunk,
-            (unsigned long)code, code == last ? " /* DUPLICATE */" : "");
-
-         if (code < last) /* still some to go */
-            print_chunks(chunks, nchunks, code+1, last, best_c, best_mask, lut);
-      }
-
-      else
-         print_chunks(chunks, nchunks, first, last, best_c, best_mask, lut);
-   }
-}
-
-static unsigned int primes[] =
-{
-   0, 1, 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67,
-   71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149,
-   151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229,
-   233, 239, 241, 251
-};
-
-#define NPRIMES ((sizeof primes)/(sizeof primes[0]))
-
-int
-main(void)
-{
-   /* Stdin should just contain chunk names, one per line */
-   png_uint_32 best_mask;
-   unsigned int best_c[4];
-   png_uint_32 chunks[CHUNK_COUNT_MAX];
-   png_byte known_chunk_count;
-
-   /* Not required; stop GCC whining: */
-   memset(best_c, 0xab, sizeof best_c);
-   best_mask = 0x12345678;
-
-   {
-      png_uint_32 this_chunk = 0;
-      png_byte n_chunks = 0;
-
-      for (;;)
-      {
-         int ch = getchar();
-
-         if ((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z'))
-         {
-            if (this_chunk > 0xffffffU)
-               error("chunk name too long");
-
-            this_chunk = (this_chunk << 8) + (unsigned)ch;
-         }
-
-         else
-         {
-            if (this_chunk > 0)
-            {
-               if (this_chunk <= 0xffffffU)
-                  error("chunk name too short");
-
-               if (n_chunks >= CHUNK_COUNT_MAX)
-                  error("too many chunks (check CHUNK_COUNT_MAX)");
-
-               chunks[n_chunks++] = this_chunk;
-               this_chunk = 0;
-            }
-         }
-
-         if (ch < 0)
-            break;
-      }
-
-      /* 22 is the number of chunks currently defined (excluding fRAc), at any
-       * time it should also be in PNG_KNOWN_CHUNK_COUNT, but this run of
-       * chunkhash may be trying to add a chunk so allow bigger numbers.
-       */
-#     ifdef PNG_KNOWN_CHUNK_COUNT
-#        define CHUNK_COUNT_MIN PNG_KNOWN_CHUNK_COUNT
-#     else
-#        define CHUNK_COUNT_MIN 26
-#     endif
-      if (n_chunks < CHUNK_COUNT_MIN)
-         error("too few chunks (expecting at least 26)");
-
-      known_chunk_count = n_chunks;
-   }
-
-   /* Exhaustive search of the hash parameters - in fact this isn't very slow at
-    * all.
-    */
-   {
-      unsigned int i1, c_zero = 0, c_one = 0;
-
-      for (i1=0; i1<NPRIMES; ++i1)
-      {
-         unsigned int i2;
-         unsigned int c[4];
-
-         fprintf(stderr, "TEST: %u\n", primes[i1]);
-         c[0] = primes[i1];
-
-         for (i2=0; i2<NPRIMES; ++i2)
-         {
-            unsigned int i3;
-
-            c[1] = primes[i2];
-
-            for (i3=0; i3<NPRIMES; ++i3)
-            {
-               unsigned int i4;
-
-               c[2] = primes[i3];
-
-               for (i4=0; i4<NPRIMES; ++i4)
-               {
-                  unsigned int i;
-                  png_uint_32 hash_mask = 0xffU;
-                  png_uint_32 hashes[CHUNK_COUNT_MAX];
-
-                  c[3] = primes[i4];
-
-                  while (hash_mask > 0xfU)
-                  {
-                     for (i=0; i<known_chunk_count; ++i)
-                     {
-                        unsigned int j;
-                        png_uint_32 hash = test_hash(chunks[i], c, hash_mask);
-
-                        for (j=0; j<i; ++j) if (hashes[j] == hash) goto next_i4;
-
-                        hashes[i] = hash;
-                     }
-
-                     hash_mask >>= 1;
-                  }
-
-               next_i4:
-                  if (hash_mask < 0xffU)
-                  {
-                     /* This worked */
-                     unsigned int best, c0 = 0, c1 = 0;
-
-                     hash_mask <<= 1;
-                     hash_mask += 1;
-
-                     for (i=0; i<4; ++i)
-                     {
-                        if (c[i] == 0)
-                           ++c0;
-
-                        else if (c[i] == 1)
-                           ++c1;
-                     }
-
-                     if (hash_mask == best_mask)
-                        best = (c0 > c_zero) || (c0 == c_zero && c1 > c_one);
-
-                     else
-                        best = (hash_mask < best_mask);
-
-                     if (best)
-                     {
-                        fprintf(stderr, "{%u,%u,%u,%u} & 0x%lx\n",
-                           c[0], c[1], c[2], c[3],
-                           (unsigned long)hash_mask);
-
-                        c_zero = c0;
-                        c_one = c1;
-                        best_mask = hash_mask;
-                        memcpy(best_c, c, sizeof best_c);
-                     }
-                  }
-               } /* i4 */
-            } /* i3 */
-         } /* i2 */
-      } /* i1 */
-   }
-
-   /* Calculate the LUT (png_chunk_hash) */
-   {
-      png_byte b;
-      png_byte lut[256];
-
-      /* A failure returns PNG_KNOWN_CHUNK_COUNT: */
-      memset(lut, known_chunk_count, sizeof lut);
-
-      for (b=0; b<known_chunk_count; ++b)
-         lut[test_hash(chunks[b], best_c, best_mask)] = b;
-
-      /* Validate the pngpriv.h hash function. */
-#     define png_chunk_hash lut
-         {
-            unsigned int i;
-
-            for (i=0; i<known_chunk_count; ++i)
-            {
-               png_uint_32 chunk = chunks[i];
-
-               if (PNG_CHUNK_HASH(chunk) != i)
-                  error("internal error: hash didn't work!");
-            }
-         }
-#     undef lut
-
-      /* Print all the results, first the stuff for pngpriv.h */
-      {
-         unsigned int i = 0;
-
-         while (strings[i] != 0)
-            puts(strings[i++]);
-
-         printf("#define PNG_CHUNK_HASH_MASK 0x%lxU\n",
-            (unsigned long)best_mask);
-         printf("#define PNG_CHUNK_HASH_C0 %u\n", best_c[0]);
-         printf("#define PNG_CHUNK_HASH_C1 %u\n", best_c[1]);
-         printf("#define PNG_CHUNK_HASH_C2 %u\n", best_c[2]);
-         printf("#define PNG_CHUNK_HASH_C3 %u\n", best_c[3]);
-
-         /* Print the hash codes of all the chunks */
-         putchar('\n');
-         print_chunks(chunks, known_chunk_count, 0, 0xffffffff, best_c,
-            best_mask, lut);
-         putchar('\n');
-         printf("#define PNG_KNOWN_CHUNK_COUNT %u\n", known_chunk_count);
-
-         while (strings[++i] != 0)
-            puts(strings[i]);
-
-         /* Now print the LUT */
-         fputs("   ", stdout);
-         {
-            unsigned int j;
-
-            for (j=0; j<=best_mask; ++j)
-            {
-               printf("%d", lut[j]);
-
-               if ((j % 16) == 15 && j < best_mask)
-                  printf(",\n   ");
-
-               else if (j < best_mask)
-                  printf(", ");
-
-               else
-                  printf("\n");
-            }
-         }
-
-         /* And the trailing text */
-         while (strings[++i] != 0)
-            puts(strings[i]);
-      }
-   }
-
-   exit(0);
-}

contrib/tools/chunkhash.h

@@ -1,97 +0,0 @@
-/* chunkhash.h -- a perfect hash code for the chunk names in png.h
- *
- * Last changed in libpng 1.7.0 [(PENDING RELEASE)]
- *
- * THIS IS A MACHINE GENERATED FILE.  See contrib/tools/chunkhash.c for
- * copyright and other information.
- *
- * USAGE:  To include the PNG_CHUNK_HASH macro and associated definitions:
- *
- * #define PNG_CHUNKHASH_DEFS
- * #include "contrib/tools/chunkhash.h"
- *
- * To define the png_chunk_hash array used by the macro:
- *
- * #define PNG_CHUNKHASH_CODE
- * #include "contrib/tools/chunkhash.h"
- *
- * One or both of the defines must be given except when building chunkhash
- * itself.
- */
-#ifdef PNG_CHUNKHASH_DEFS
-#ifndef PNG_CHUNKHASH_H
-#define PNG_CHUNKHASH_H
-/* A perfect hash code - returns a value 0..(PNG_KNOWN_CHUNK_COUNT-1) and is
- * generated by the ridiculously simple program in contrib/tools/chunkhash.c
- *
- * The hash code used here multiplies each byte by a different constant to
- * return a single number:
- *
- *    b0 * c[0] + b1 * [c1] + b2 * c[2] + b3 * c[3]
- *
- * The values of the constants are found by search using the a table of
- * primes, including 0, and may be (in fact are at present) 0 for some of the
- * bytes, the compiler is expected to optimize multiply by zero, or one!
- *
- * The lookup table reduces the sparse result of the hash calculation to the
- * correct index values.  The chunks are indexed in the string order of the
- * png_uint_32 chunk names.
- */
-#define PNG_CHUNK_HASH_MASK 0x3fU
-#define PNG_CHUNK_HASH_C0 103
-#define PNG_CHUNK_HASH_C1 1
-#define PNG_CHUNK_HASH_C2 0
-#define PNG_CHUNK_HASH_C3 1
-
-#define PNG_CHUNK_IDAT_TAG 0
-#define PNG_CHUNK_IEND_TAG 1
-#define PNG_CHUNK_IHDR_TAG 2
-#define PNG_CHUNK_PLTE_TAG 3
-#define PNG_CHUNK_bKGD_TAG 4
-#define PNG_CHUNK_cHRM_TAG 5
-#define PNG_CHUNK_fRAc_TAG 6
-#define PNG_CHUNK_gAMA_TAG 7
-#define PNG_CHUNK_gIFg_TAG 8
-#define PNG_CHUNK_gIFt_TAG 9
-#define PNG_CHUNK_gIFx_TAG 10
-#define PNG_CHUNK_hIST_TAG 11
-#define PNG_CHUNK_iCCP_TAG 12
-#define PNG_CHUNK_iTXt_TAG 13
-#define PNG_CHUNK_oFFs_TAG 14
-#define PNG_CHUNK_pCAL_TAG 15
-#define PNG_CHUNK_pHYs_TAG 16
-#define PNG_CHUNK_sBIT_TAG 17
-#define PNG_CHUNK_sCAL_TAG 18
-#define PNG_CHUNK_sPLT_TAG 19
-#define PNG_CHUNK_sRGB_TAG 20
-#define PNG_CHUNK_sTER_TAG 21
-#define PNG_CHUNK_tEXt_TAG 22
-#define PNG_CHUNK_tIME_TAG 23
-#define PNG_CHUNK_tRNS_TAG 24
-#define PNG_CHUNK_zTXt_TAG 25
-
-#define PNG_KNOWN_CHUNK_COUNT 26
-
-extern const png_byte png_chunk_hash[PNG_CHUNK_HASH_MASK+1];
-#endif /* !PNG_CHUNKHASH_H */
-#endif /* PNG_CHUNKHASH_DEFS */
-
-#ifndef PNG_CHUNK_HASH
-#define PNG_CHUNK_HASH(chunk) (png_chunk_hash[PNG_CHUNK_HASH_MASK & (\
-      ((chunk) >> 24) * PNG_CHUNK_HASH_C0 +\
-      ((chunk) >> 16) * PNG_CHUNK_HASH_C1 +\
-      ((chunk) >>  8) * PNG_CHUNK_HASH_C2 +\
-      ((chunk)      ) * PNG_CHUNK_HASH_C3)])
-#endif
-
-#ifdef PNG_CHUNKHASH_CODE
-#ifndef PNG_CHUNKHASH_C
-#define PNG_CHUNKHASH_C
-const png_byte png_chunk_hash[PNG_CHUNK_HASH_MASK+1] = {
-   26, 3, 26, 26, 26, 26, 26, 13, 26, 26, 26, 16, 26, 26, 26, 26,
-   26, 24, 12, 26, 18, 26, 26, 26, 26, 20, 26, 17, 26, 26, 25, 15,
-   26, 8, 14, 26, 26, 22, 26, 26, 1, 19, 5, 21, 26, 26, 9, 26,
-   26, 26, 10, 7, 26, 11, 26, 0, 26, 2, 23, 26, 26, 4, 26, 6
-};
-#endif /* !PNG_CHUNKHASH_C */
-#endif /* PNG_CHUNKHASH_CODE */

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/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/png-fix-itxt.c

@@ -1,153 +0,0 @@
-
-/* png-fix-itxt version 1.0.0
- *
- * Copyright 2013 Glenn Randers-Pehrson
- * Last changed in libpng 1.6.3 [July 18, 2013]
- *
- * This code is released under the libpng license.
- * For conditions of distribution and use, see the disclaimer
- * and license in png.h
- *
- * Usage:            
- *
- *     png-fix-itxt.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 png-fix-itxt png-fix-itxt.c -lz
- *
- * If you need to handle iTXt chunks larger than 500000 kbytes you must
- * rebuild png-fix-itxt with a larger values of MAX_LENGTH (or a smaller value
- * if you know you will never encounter such huge iTXt chunks).
- */
-
-#include <stdio.h>
-#include <zlib.h>
-
-#define MAX_LENGTH 500000
-
-#define GETBREAK ((unsigned char)(inchar=getchar())); if (inchar == EOF) break
-
-int
-main(void)
-{
-   unsigned int i;
-   unsigned char buf[MAX_LENGTH];
-   unsigned long crc;
-   unsigned char c;
-   int inchar;
-
-/* Skip 8-byte signature */
-   for (i=8; i; i--)
-   {
-      c=GETBREAK;
-      putchar(c);
-   }
-
-if (inchar != EOF)
-for (;;)
- {
-   /* Read the length */
-   unsigned long length; /* must be 32 bits! */
-   c=GETBREAK; buf[0] = c; length  = c; length <<= 8;
-   c=GETBREAK; buf[1] = c; length += c; length <<= 8;
-   c=GETBREAK; buf[2] = c; length += c; length <<= 8;
-   c=GETBREAK; buf[3] = c; length += c;
-
-   /* 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] = (unsigned char)((length << 24) & 0xff);
-      buf[1] = (unsigned char)((length << 16) & 0xff);
-      buf[2] = (unsigned char)((length <<  8) & 0xff);
-      buf[3] = (unsigned char)((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 (inchar == 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 (inchar == EOF)
-      break;
-
-   if (buf[4] == 73 && buf[5] == 69 && buf[6] == 78 && buf[7] == 68)
-     break;
- }
-
- 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/tools/scale.c

@@ -1,238 +0,0 @@
-/* Given a target range and a source range work out an expression to scale from
- * the source to the target of the form:
- *
- *    (number * mult + add)>>16
- *
- * The command arguments are:
- *
- *    scale target source
- *
- * and the program works out a pair of numbers, mult and add, that evaluate:
- *
- *          number * target
- *   round( --------------- )
- *              source
- *
- * exactly for number in the range 0..source
- */
-#define _ISOC99_SOURCE 1
-
-#include <stdlib.h>
-#include <string.h>
-#include <stdio.h>
-#include <math.h>
-
-static double minerr;
-static unsigned long minmult, minadd, minshift;
-static long mindelta;
-
-static int
-test(unsigned long target, unsigned long source, unsigned long mult,
-   long add, unsigned long shift, long delta)
-{
-   unsigned long i;
-   double maxerr = 0;
-   double rs = (double)target/source;
-
-   for (i=0; i<=source; ++i)
-   {
-      unsigned long t = i*mult+add;
-      double err = fabs((t >> shift) - i*rs);
-
-      if (err > minerr)
-         return 0;
-
-      if (err > maxerr)
-         maxerr = err;
-   }
-
-   if (maxerr < minerr)
-   {
-      minerr = maxerr;
-      minmult = mult;
-      minadd = add;
-      minshift = shift;
-      mindelta = delta;
-   }
-
-   return maxerr < .5;
-}
-
-static int
-dotest(unsigned long target, unsigned long source, unsigned long mult,
-   long add, unsigned long shift, long delta, int print)
-{
-   if (test(target, source, mult, add, shift, delta))
-   {
-      if (print & 4)
-         printf("      {%11lu,%6ld /* >>%lu */ }, /* %lu/%lu */\n",
-            mult, add, shift, target, source);
-
-      else if (print & 2)
-         printf("      {%11lu,%6ld,%3lu }, /* %lu/%lu */\n",
-            mult, add, shift, target, source);
-
-      else if (print)
-         printf("number * %lu/%lu = (number * %lu + %ld) >> %lu [delta %ld]\n",
-            target, source, mult, add, shift, delta);
-
-      return 1;
-   }
-
-   return 0;
-}
-
-static int
-find(unsigned long target, unsigned long source, int print, int fixshift)
-{
-   unsigned long shift = 0;
-   unsigned long shiftlim = 0;
-
-   /* In the final math the sum is at most (source*mult+add) >> shift, so:
-    *
-    *    source*mult+add < 1<<32
-    *    mult < (1<<32)/source
-    *
-    * but:
-    *
-    *    mult = (target<<shift)/source
-    *
-    * so:
-    *
-    *    (target<<shift) < (1<<32)
-    */
-   if (fixshift < 0)
-      while ((target<<shiftlim) < 0x80000000U) ++shiftlim;
-
-   else
-      shift = shiftlim = (unsigned long)fixshift;
-
-   minerr = 1E8;
-
-   for (; shift<=shiftlim; ++shift)
-   {
-      unsigned long mult = ((target<<shift) + (source>>1)) / source;
-      long delta;
-      long limit = 1; /* seems to be sufficient */
-      long add, start, end;
-
-      end = 1<<shift;
-      start = -end;
-
-      for (add=start; add<=end; ++add)
-         if (dotest(target,source,mult,add,shift,0,print))
-            return 1;
-
-      for (delta=1; delta<=limit; ++delta)
-      {
-#        if 0
-            fprintf(stderr, "%lu/%lu: shift %lu, delta %lu\n", target, source,
-               shift, delta);
-#        endif
-
-         for (add=start; add<=end; ++add)
-         {
-            if (dotest(target, source, mult-delta, add, shift, -delta, print))
-               return 1;
-
-            if (dotest(target, source, mult+delta, add, shift, delta, print))
-               return 1;
-         }
-      }
-   }
-
-   if (print & 4)
-      printf("      {%11lu,%6ld /* >>%lu */ }, /* %lu/%lu ERROR: .5+%g*/\n",
-         minmult, minadd, minshift, target, source, minerr-.5);
-
-   else if (print & 2)
-      printf("      {%11lu,%6ld,%3lu }, /* %lu/%lu ERROR: .5+%g*/\n",
-         minmult, minadd, minshift, target, source, minerr-.5);
-
-   else if (print)
-      printf(
-         "number * %lu/%lu ~= (number * %lu + %ld) >> %lu +/-.5+%g [delta %ld]\n",
-         target, source, minmult, minadd, minshift, minerr-.5, mindelta);
-
-   return 0;
-}
-
-static void
-usage(const char *prog)
-{
-   fprintf(stderr,
-      "usage: %s {--denominator|--maxshift|--code} target {source}\n"
-      " For each 'source' prints 'mult' and 'add' such that:\n\n"
-      "   (number * mult + add) >> 16 = round(number*target/source)\n\n"
-      " for all integer values of number in the range 0..source.\n\n"
-      " --denominator: swap target and source (specify a single source first\n"
-      "                and follow with multiple targets.)\n"
-      "    --maxshift: find the lowest shift value that works for all the\n"
-      "                repeated 'source' values\n"
-      "        --code: output C code for array/structure initialization\n",
-      prog);
-   exit(1);
-}
-
-int
-main(int argc, const char **argv)
-{
-   int i, err = 0, maxshift = 0, firstsrc = 1, code = 0, denominator = 0;
-   unsigned long target, shift = 0;
-
-   while (argc > 1)
-   {
-      if (strcmp(argv[firstsrc], "--maxshift") == 0)
-      {
-         maxshift = 1;
-         ++firstsrc;
-      }
-
-      else if (strcmp(argv[firstsrc], "--code") == 0)
-      {
-         code = 1;
-         ++firstsrc;
-      }
-
-      else if (strcmp(argv[firstsrc], "--denominator") == 0)
-      {
-         denominator = 1;
-         ++firstsrc;
-      }
-
-      else
-         break;
-   }
-
-
-   if (argc < 2+firstsrc)
-      usage(argv[0]);
-
-   target = strtoul(argv[firstsrc++], 0, 0);
-   if (target == 0) usage(argv[0]);
-
-   for (i=firstsrc; i<argc; ++i)
-   {
-      unsigned long source = strtoul(argv[i], 0, 0);
-
-      if (source == 0) usage(argv[0]);
-
-      if (!find(denominator ? source : target, denominator ? target : source,
-         maxshift ? 0 : 1+code, -1))
-         err = 1;
-
-      if (minshift > shift) shift = minshift;
-   }
-
-   if (maxshift) for (i=firstsrc; i<argc; ++i)
-   {
-      unsigned long source = strtoul(argv[i], 0, 0);
-
-      if (!find(denominator ? source : target, denominator ? target : source,
-         code ? 4 : 1, shift))
-         err = 1;
-   }
-
-   /* Just an exit code - the printout above lists the problem */
-   return err;
-}

depcomp

@@ -0,0 +1,790 @@
+#! /bin/sh
+# depcomp - compile a program generating dependencies as side-effects
+
+scriptversion=2012-10-18.11; # UTC
+
+# Copyright (C) 1999-2012 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 outputting dependencies.
+  libtool     Whether libtool is used (yes/no).
+
+Report bugs to <bug-automake@gnu.org>.
+EOF
+    exit $?
+    ;;
+  -v | --v*)
+    echo "depcomp $scriptversion"
+    exit $?
+    ;;
+esac
+
+# Get the directory component of the given path, and save it in the
+# global variables '$dir'.  Note that this directory component will
+# be either empty or ending with a '/' character.  This is deliberate.
+set_dir_from ()
+{
+  case $1 in
+    */*) dir=`echo "$1" | sed -e 's|/[^/]*$|/|'`;;
+      *) dir=;;
+  esac
+}
+
+# Get the suffix-stripped basename of the given path, and save it the
+# global variable '$base'.
+set_base_from ()
+{
+  base=`echo "$1" | sed -e 's|^.*/||' -e 's/\.[^.]*$//'`
+}
+
+# If no dependency file was actually created by the compiler invocation,
+# we still have to create a dummy depfile, to avoid errors with the
+# Makefile "include basename.Plo" scheme.
+make_dummy_depfile ()
+{
+  echo "#dummy" > "$depfile"
+}
+
+# Factor out some common post-processing of the generated depfile.
+# Requires the auxiliary global variable '$tmpdepfile' to be set.
+aix_post_process_depfile ()
+{
+  # If the compiler actually managed to produce a dependency file,
+  # post-process it.
+  if test -f "$tmpdepfile"; then
+    # Each line is of the form 'foo.o: dependency.h'.
+    # Do two passes, one to just change these to
+    #   $object: dependency.h
+    # and one to simply output
+    #   dependency.h:
+    # which is needed to avoid the deleted-header problem.
+    { sed -e "s,^.*\.[$lower]*:,$object:," < "$tmpdepfile"
+      sed -e "s,^.*\.[$lower]*:[$tab ]*,," -e 's,$,:,' < "$tmpdepfile"
+    } > "$depfile"
+    rm -f "$tmpdepfile"
+  else
+    make_dummy_depfile
+  fi
+}
+
+# A tabulation character.
+tab='	'
+# A newline character.
+nl='
+'
+# Character ranges might be problematic outside the C locale.
+# These definitions help.
+upper=ABCDEFGHIJKLMNOPQRSTUVWXYZ
+lower=abcdefghijklmnopqrstuvwxyz
+digits=0123456789
+alpha=${upper}${lower}
+
+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"
+
+# Avoid interferences from the environment.
+gccflag= dashmflag=
+
+# 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
+
+if test "$depmode" = msvc7msys; then
+  # This is just like msvc7 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=msvc7
+fi
+
+if test "$depmode" = xlc; then
+  # IBM C/C++ Compilers xlc/xlC can output gcc-like dependency information.
+  gccflag=-qmakedep=gcc,-MF
+  depmode=gcc
+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 -ne 0; then
+    rm -f "$tmpdepfile"
+    exit $stat
+  fi
+  mv "$tmpdepfile" "$depfile"
+  ;;
+
+gcc)
+## Note that this doesn't just cater to obsosete pre-3.x GCC compilers.
+## but also to in-use compilers like IMB xlc/xlC and the HP C compiler.
+## (see the conditional assignment to $gccflag above).
+## 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).  Also, it might not be
+##   supported by the other compilers which use the 'gcc' depmode.
+## - 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 -ne 0; then
+    rm -f "$tmpdepfile"
+    exit $stat
+  fi
+  rm -f "$depfile"
+  echo "$object : \\" > "$depfile"
+  # 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.
+## 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.  hp depmode also adds that space, but also prefixes the VPATH
+## to the object.  Take care to not repeat it in the output.
+## Some versions of the HPUX 10.20 sed can't process this invocation
+## correctly.  Breaking it into two sed invocations is a workaround.
+  tr ' ' "$nl" < "$tmpdepfile" \
+    | sed -e 's/^\\$//' -e '/^$/d' -e "s|.*$object$||" -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 -ne 0; then
+    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 ' ' "$nl" < "$tmpdepfile" \
+      | sed -e 's/^.*\.o://' -e 's/#.*$//' -e '/^$/ d' \
+      | tr "$nl" ' ' >> "$depfile"
+    echo >> "$depfile"
+    # The second pass generates a dummy entry for each header file.
+    tr ' ' "$nl" < "$tmpdepfile" \
+      | sed -e 's/^.*\.o://' -e 's/#.*$//' -e '/^$/ d' -e 's/$/:/' \
+      >> "$depfile"
+  else
+    make_dummy_depfile
+  fi
+  rm -f "$tmpdepfile"
+  ;;
+
+xlc)
+  # 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
+  ;;
+
+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.
+  set_dir_from "$object"
+  set_base_from "$object"
+  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 -ne 0; then
+    rm -f "$tmpdepfile1" "$tmpdepfile2" "$tmpdepfile3"
+    exit $stat
+  fi
+
+  for tmpdepfile in "$tmpdepfile1" "$tmpdepfile2" "$tmpdepfile3"
+  do
+    test -f "$tmpdepfile" && break
+  done
+  aix_post_process_depfile
+  ;;
+
+tcc)
+  # tcc (Tiny C Compiler) understand '-MD -MF file' since version 0.9.26
+  # FIXME: That version still under development at the moment of writing.
+  #        Make that this statement remains true also for stable, released
+  #        versions.
+  # It will wrap lines (doesn't matter whether long or short) with a
+  # trailing '\', as in:
+  #
+  #   foo.o : \
+  #    foo.c \
+  #    foo.h \
+  #
+  # It will put a trailing '\' even on the last line, and will use leading
+  # spaces rather than leading tabs (at least since its commit 0394caf7
+  # "Emit spaces for -MD").
+  "$@" -MD -MF "$tmpdepfile"
+  stat=$?
+  if test $stat -ne 0; then
+    rm -f "$tmpdepfile"
+    exit $stat
+  fi
+  rm -f "$depfile"
+  # Each non-empty line is of the form 'foo.o : \' or ' dep.h \'.
+  # We have to change lines of the first kind to '$object: \'.
+  sed -e "s|.*:|$object :|" < "$tmpdepfile" > "$depfile"
+  # And for each line of the second kind, we have to emit a 'dep.h:'
+  # dummy dependency, to avoid the deleted-header problem.
+  sed -n -e 's|^  *\(.*\) *\\$|\1:|p' < "$tmpdepfile" >> "$depfile"
+  rm -f "$tmpdepfile"
+  ;;
+
+## The order of this option in the case statement is important, since the
+## shell code in configure will try each of these formats in the order
+## listed in this file.  A plain '-MD' option would be understood by many
+## compilers, so we must ensure this comes after the gcc and icc options.
+pgcc)
+  # Portland's C compiler understands '-MD'.
+  # Will always output deps to 'file.d' where file is the root name of the
+  # source file under compilation, even if file resides in a subdirectory.
+  # The object file name does not affect the name of the '.d' file.
+  # pgcc 10.2 will output
+  #    foo.o: sub/foo.c sub/foo.h
+  # and will wrap long lines using '\' :
+  #    foo.o: sub/foo.c ... \
+  #     sub/foo.h ... \
+  #     ...
+  set_dir_from "$object"
+  # Use the source, not the object, to determine the base name, since
+  # that's sadly what pgcc will do too.
+  set_base_from "$source"
+  tmpdepfile=$base.d
+
+  # For projects that build the same source file twice into different object
+  # files, the pgcc approach of using the *source* file root name can cause
+  # problems in parallel builds.  Use a locking strategy to avoid stomping on
+  # the same $tmpdepfile.
+  lockdir=$base.d-lock
+  trap "
+    echo '$0: caught signal, cleaning up...' >&2
+    rmdir '$lockdir'
+    exit 1
+  " 1 2 13 15
+  numtries=100
+  i=$numtries
+  while test $i -gt 0; do
+    # mkdir is a portable test-and-set.
+    if mkdir "$lockdir" 2>/dev/null; then
+      # This process acquired the lock.
+      "$@" -MD
+      stat=$?
+      # Release the lock.
+      rmdir "$lockdir"
+      break
+    else
+      # If the lock is being held by a different process, wait
+      # until the winning process is done or we timeout.
+      while test -d "$lockdir" && test $i -gt 0; do
+        sleep 1
+        i=`expr $i - 1`
+      done
+    fi
+    i=`expr $i - 1`
+  done
+  trap - 1 2 13 15
+  if test $i -le 0; then
+    echo "$0: failed to acquire lock after $numtries attempts" >&2
+    echo "$0: check lockdir '$lockdir'" >&2
+    exit 1
+  fi
+
+  if test $stat -ne 0; then
+    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.
+  set_dir_from  "$object"
+  set_base_from "$object"
+  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 -ne 0; then
+     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,^.*\.[$lower]*:,$object:," "$tmpdepfile" > "$depfile"
+    # Add 'dependent.h:' lines.
+    sed -ne '2,${
+               s/^ *//
+               s/ \\*$//
+               s/$/:/
+               p
+             }' "$tmpdepfile" >> "$depfile"
+  else
+    make_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.
+  set_dir_from  "$object"
+  set_base_from "$object"
+
+  if test "$libtool" = yes; then
+    # Libtool 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$base.o.d          # libtool 1.5
+    tmpdepfile2=$dir.libs/$base.o.d    # Likewise.
+    tmpdepfile3=$dir.libs/$base.d      # Compaq CCC V6.2-504
+    "$@" -Wc,-MD
+  else
+    tmpdepfile1=$dir$base.d
+    tmpdepfile2=$dir$base.d
+    tmpdepfile3=$dir$base.d
+    "$@" -MD
+  fi
+
+  stat=$?
+  if test $stat -ne 0; then
+    rm -f "$tmpdepfile1" "$tmpdepfile2" "$tmpdepfile3"
+    exit $stat
+  fi
+
+  for tmpdepfile in "$tmpdepfile1" "$tmpdepfile2" "$tmpdepfile3"
+  do
+    test -f "$tmpdepfile" && break
+  done
+  # Same post-processing that is required for AIX mode.
+  aix_post_process_depfile
+  ;;
+
+msvc7)
+  if test "$libtool" = yes; then
+    showIncludes=-Wc,-showIncludes
+  else
+    showIncludes=-showIncludes
+  fi
+  "$@" $showIncludes > "$tmpdepfile"
+  stat=$?
+  grep -v '^Note: including file: ' "$tmpdepfile"
+  if test $stat -ne 0; then
+    rm -f "$tmpdepfile"
+    exit $stat
+  fi
+  rm -f "$depfile"
+  echo "$object : \\" > "$depfile"
+  # The first sed program below extracts the file names and escapes
+  # backslashes for cygpath.  The second sed program outputs the file
+  # name when reading, but also accumulates all include files in the
+  # hold buffer in order to output them again at the end.  This only
+  # works with sed implementations that can handle large buffers.
+  sed < "$tmpdepfile" -n '
+/^Note: including file:  *\(.*\)/ {
+  s//\1/
+  s/\\/\\\\/g
+  p
+}' | $cygpath_u | sort -u | sed -n '
+s/ /\\ /g
+s/\(.*\)/'"$tab"'\1 \\/p
+s/.\(.*\) \\/\1:/
+H
+$ {
+  s/.*/'"$tab"'/
+  G
+  p
+}' >> "$depfile"
+  rm -f "$tmpdepfile"
+  ;;
+
+msvc7msys)
+  # 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
+  ;;
+
+#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|^[$tab ]*[^:$tab ][^:][^:]*:[$tab ]*|$object: |" > "$tmpdepfile"
+  rm -f "$depfile"
+  cat < "$tmpdepfile" > "$depfile"
+  # Some versions of the HPUX 10.20 sed can't process this sed invocation
+  # correctly.  Breaking it into two sed invocations is a workaround.
+  tr ' ' "$nl" < "$tmpdepfile" \
+    | 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"
+  # makedepend may prepend the VPATH from the source file name to the object.
+  # No need to regex-escape $object, excess matching of '.' is harmless.
+  sed "s|^.*\($object *:\)|\1|" "$tmpdepfile" > "$depfile"
+  # Some versions of the HPUX 10.20 sed can't process the last invocation
+  # correctly.  Breaking it into two sed invocations is a workaround.
+  sed '1,2d' "$tmpdepfile" \
+    | tr ' ' "$nl" \
+    | 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::'"$tab"'\1 \\:p' >> "$depfile"
+  echo "$tab" >> "$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,13 +2,10 @@
 #if 0 /* in case someone actually tries to compile this */
 
 /* example.c - an example of using libpng
- * Last changed in libpng 1.7.0 [(PENDING RELEASE)]
- * Maintained 1998-2015 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.
+ * Last changed in libpng 1.5.10 [March 8, 2012]
+ * Maintained 1998-2012 Glenn Randers-Pehrson
+ * Maintained 1996, 1997 Andreas Dilger
+ * Written 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
  */
 
 /* This is an example of how to use libpng to read and write PNG files.
@@ -16,6 +13,8 @@
  * 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.
+ * To the extent possible under law, the authors have waived all copyright and
+ * related or neighboring rights to this file.
  *
  * This file does not currently compile, because it is missing certain
  * parts, like allocating memory to hold an image.  You will have to
@@ -24,192 +23,11 @@
  * 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 PNG_ZLIB_HEADER /* this is the header libpng was built with */
+#define _POSIX_SOURCE 1  /* libpng and zlib are POSIX-compliant.  You may
+                          * change this if your application uses non-POSIX
+                          * extensions. */
 
-int main(int argc, const char **argv)
-{
-   if (argc == 3)
-   {
-      png_image image; /* The control structure used by libpng */
-
-      /* Initialize the 'png_image' structure. */
-      memset(&image, 0, (sizeof image));
-      image.version = PNG_IMAGE_VERSION;
-
-      /* The first argument is the file to read: */
-      if (png_image_begin_read_from_file(&image, argv[1]) != 0)
-      {
-         png_bytep buffer;
-
-         /* Set the format in which to read the PNG file; this code chooses a
-          * simple sRGB format with a non-associated alpha channel, adequate to
-          * store most images.
-          */
-         image.format = PNG_FORMAT_RGBA;
-
-         /* Now allocate enough memory to hold the image in this format; the
-          * PNG_IMAGE_SIZE macro uses the information about the image (width,
-          * height and format) stored in 'image'.
-          */
-         buffer = malloc(PNG_IMAGE_SIZE(image));
-
-         /* If enough memory was available read the image in the desired format
-          * then write the result out to the new file.  'background' is not
-          * necessary when reading the image because the alpha channel is
-          * preserved; if it were to be removed, for example if we requested
-          * PNG_FORMAT_RGB, then either a solid background color would have to
-          * be supplied or the output buffer would have to be initialized to the
-          * actual background of the image.
-          *
-          * The fourth argument to png_image_finish_read is the 'row_stride' -
-          * this is the number of components allocated for the image in each
-          * row.  It has to be at least as big as the value returned by
-          * PNG_IMAGE_ROW_STRIDE, but if you just allocate space for the
-          * default, minimum, size using PNG_IMAGE_SIZE as above you can pass
-          * zero.
-          *
-          * The final argument is a pointer to a buffer for the colormap;
-          * colormaps have exactly the same format as a row of image pixels (so
-          * you choose what format to make the colormap by setting
-          * image.format).  A colormap is only returned if
-          * PNG_FORMAT_FLAG_COLORMAP is also set in image.format, so in this
-          * case NULL is passed as the final argument.  If you do want to force
-          * all images into an index/color-mapped format then you can use:
-          *
-          *    PNG_IMAGE_COLORMAP_SIZE(image)
-          *
-          * to find the maximum size of the colormap in bytes.
-          */
-         if (buffer != NULL &&
-            png_image_finish_read(&image, NULL/*background*/, buffer,
-               0/*row_stride*/, NULL/*colormap*/) != 0)
-         {
-            /* Now write the image out to the second argument.  In the write
-             * call 'convert_to_8bit' allows 16-bit data to be squashed down to
-             * 8 bits; this isn't necessary here because the original read was
-             * to the 8-bit format.
-             */
-            if (png_image_write_to_file(&image, argv[2], 0/*convert_to_8bit*/,
-               buffer, 0/*row_stride*/, NULL/*colormap*/) != 0)
-            {
-               /* The image has been written successfully. */
-               exit(0);
-            }
-         }
-
-         else
-         {
-            /* Calling png_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 conversion to 16-bit is also
- * significantly lossy.  The latter will be fixed in the future, but the former
- * is unavoidable - the 8-bit format just doesn't have enough resolution.
- */
-
-/* If your program needs more information from the PNG data it reads, or if you
- * need to do more complex transformations, or minimize transformations, on the
- * data you read, then you must use one of the several lower level libpng
- * interfaces.
- *
- * All these interfaces require that you do your own error handling - your
- * program must be able to arrange for control to return to your own code any
- * time libpng encounters a problem.  There are several ways to do this, but the
- * standard way is to use the 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
@@ -405,7 +223,7 @@ void read_png(FILE *fp, unsigned int sig_read)  /* File is already open */
    /* Expand paletted or RGB images with transparency to full alpha channels
     * so the data will be available as RGBA quartets.
     */
-   if (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS) != 0)
+   if (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS))
       png_set_tRNS_to_alpha(png_ptr);
 
    /* Set the background color to draw transparent and alpha images over.
@@ -417,7 +235,7 @@ void read_png(FILE *fp, unsigned int sig_read)  /* File is already open */
 
    png_color_16 my_background, *image_background;
 
-   if (png_get_bKGD(png_ptr, info_ptr, &image_background) != 0)
+   if (png_get_bKGD(png_ptr, info_ptr, &image_background))
       png_set_background(png_ptr, image_background,
                          PNG_BACKGROUND_GAMMA_FILE, 1, 1.0);
    else
@@ -441,9 +259,9 @@ void read_png(FILE *fp, unsigned int sig_read)  /* File is already open */
    /* If we don't have another value */
    else
    {
-      screen_gamma = PNG_DEFAULT_sRGB;  /* A good guess for a PC monitor
-                                           in a dimly lit room */
-      screen_gamma = PNG_GAMMA_MAC_18 or 1.0; /* Good guesses for Mac systems */
+      screen_gamma = 2.2;  /* A good guess for a PC monitor in a dimly
+                              lit room */
+      screen_gamma = 1.7 or 1.0;  /* A good guess for Mac systems */
    }
 
    /* Tell libpng to handle the gamma conversion for you.  The final call
@@ -454,12 +272,12 @@ void read_png(FILE *fp, unsigned int sig_read)  /* File is already open */
 
    int intent;
 
-   if (png_get_sRGB(png_ptr, info_ptr, &intent) != 0)
-      png_set_gamma(png_ptr, screen_gamma, PNG_DEFAULT_sRGB);
+   if (png_get_sRGB(png_ptr, info_ptr, &intent))
+      png_set_gamma(png_ptr, screen_gamma, 0.45455);
    else
    {
       double image_gamma;
-      if (png_get_gAMA(png_ptr, info_ptr, &image_gamma) != 0)
+      if (png_get_gAMA(png_ptr, info_ptr, &image_gamma))
          png_set_gamma(png_ptr, screen_gamma, image_gamma);
       else
          png_set_gamma(png_ptr, screen_gamma, 0.45455);
@@ -469,7 +287,7 @@ void read_png(FILE *fp, unsigned int sig_read)  /* File is already open */
    /* Quantize RGB files down to 8 bit palette or reduce palettes
     * to the number of colors available on your screen.
     */
-   if ((color_type & PNG_COLOR_MASK_COLOR) != 0)
+   if (color_type & PNG_COLOR_MASK_COLOR)
    {
       int num_palette;
       png_colorp palette;
@@ -484,7 +302,7 @@ void read_png(FILE *fp, unsigned int sig_read)  /* File is already open */
             MAX_SCREEN_COLORS, NULL, 0);
       }
       /* This reduces the image to the palette supplied in the file */
-      else if (png_get_PLTE(png_ptr, info_ptr, &palette, &num_palette) != 0)
+      else if (png_get_PLTE(png_ptr, info_ptr, &palette, &num_palette))
       {
          png_uint_16p histogram = NULL;
 
@@ -494,7 +312,7 @@ void read_png(FILE *fp, unsigned int sig_read)  /* File is already open */
                         max_screen_colors, histogram, 0);
       }
    }
-#endif /* READ_QUANTIZE */
+#endif /* PNG_READ_QUANTIZE_SUPPORTED */
 
    /* Invert monochrome files to have 0 as white and 1 as black */
    png_set_invert_mono(png_ptr);
@@ -503,7 +321,7 @@ void read_png(FILE *fp, unsigned int sig_read)  /* File is already open */
     * [0,65535] to the original [0,7] or [0,31], or whatever range the
     * colors were originally in:
     */
-   if (png_get_valid(png_ptr, info_ptr, PNG_INFO_sBIT) != 0)
+   if (png_get_valid(png_ptr, info_ptr, PNG_INFO_sBIT))
    {
       png_color_8p sig_bit_p;
 
@@ -512,7 +330,7 @@ void read_png(FILE *fp, unsigned int sig_read)  /* File is already open */
    }
 
    /* Flip the RGB pixels to BGR (or RGBA to BGRA) */
-   if ((color_type & PNG_COLOR_MASK_COLOR) != 0)
+   if (color_type & PNG_COLOR_MASK_COLOR)
       png_set_bgr(png_ptr);
 
    /* Swap the RGBA or GA data to ARGB or AG (or BGRA to ABGR) */
@@ -532,7 +350,7 @@ void read_png(FILE *fp, unsigned int sig_read)  /* File is already open */
    number_passes = png_set_interlace_handling(png_ptr);
 #else
    number_passes = 1;
-#endif /* READ_INTERLACING */
+#endif /* PNG_READ_INTERLACING_SUPPORTED */
 
 
    /* Optional call to gamma correct and add the background to the palette
@@ -731,7 +549,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 +562,7 @@ row_callback(png_structp png_ptr, png_bytep new_row,
     * to pass the current row as new_row, and the function will combine
     * the old row and the new row.
     */
-#endif /* READ_INTERLACING */
+#endif /* PNG_READ_INTERLACING_SUPPORTED */
 }
 
 end_callback(png_structp png_ptr, png_infop info)
@@ -846,7 +664,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
@@ -932,7 +750,7 @@ void write_png(char *file_name /* , ... other image information ... */)
     */
 
    /* Once we write out the header, the compression type on the text
-    * chunk gets changed to PNG_TEXT_COMPRESSION_NONE_WR or
+    * chunks gets changed to PNG_TEXT_COMPRESSION_NONE_WR or
     * PNG_TEXT_COMPRESSION_zTXt_WR, so it doesn't get written out again
     * at the end.
     */
@@ -970,7 +788,7 @@ void write_png(char *file_name /* , ... other image information ... */)
    png_set_packswap(png_ptr);
 
    /* Turn on interlace handling if you are not using png_write_image() */
-   if (interlacing != 0)
+   if (interlacing)
       number_passes = png_set_interlace_handling(png_ptr);
 
    else
@@ -987,7 +805,7 @@ void write_png(char *file_name /* , ... other image information ... */)
 
    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 */

install-sh

@@ -0,0 +1,527 @@
+#!/bin/sh
+# install - install a program, script, or datafile
+
+scriptversion=2011-11-20.07; # UTC
+
+# This originates from X11R5 (mit/util/scripts/install.sh), which was
+# later released in X11R6 (xc/config/util/install.sh) with the
+# following copyright and license.
+#
+# Copyright (C) 1994 X Consortium
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to
+# deal in the Software without restriction, including without limitation the
+# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+# sell copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+# X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+# AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNEC-
+# TION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#
+# Except as contained in this notice, the name of the X Consortium shall not
+# be used in advertising or otherwise to promote the sale, use or other deal-
+# ings in this Software without prior written authorization from the X Consor-
+# tium.
+#
+#
+# FSF changes to this file are in the public domain.
+#
+# Calling this script install-sh is preferred over install.sh, to prevent
+# 'make' implicit rules from creating a file called install from it
+# when there is no Makefile.
+#
+# This script is compatible with the BSD install script, but was written
+# from scratch.
+
+nl='
+'
+IFS=" ""	$nl"
+
+# set DOITPROG to echo to test this script
+
+# Don't use :- since 4.3BSD and earlier shells don't like it.
+doit=${DOITPROG-}
+if test -z "$doit"; then
+  doit_exec=exec
+else
+  doit_exec=$doit
+fi
+
+# Put in absolute file names if you don't have them in your path;
+# or use environment vars.
+
+chgrpprog=${CHGRPPROG-chgrp}
+chmodprog=${CHMODPROG-chmod}
+chownprog=${CHOWNPROG-chown}
+cmpprog=${CMPPROG-cmp}
+cpprog=${CPPROG-cp}
+mkdirprog=${MKDIRPROG-mkdir}
+mvprog=${MVPROG-mv}
+rmprog=${RMPROG-rm}
+stripprog=${STRIPPROG-strip}
+
+posix_glob='?'
+initialize_posix_glob='
+  test "$posix_glob" != "?" || {
+    if (set -f) 2>/dev/null; then
+      posix_glob=
+    else
+      posix_glob=:
+    fi
+  }
+'
+
+posix_mkdir=
+
+# Desired mode of installed file.
+mode=0755
+
+chgrpcmd=
+chmodcmd=$chmodprog
+chowncmd=
+mvcmd=$mvprog
+rmcmd="$rmprog -f"
+stripcmd=
+
+src=
+dst=
+dir_arg=
+dst_arg=
+
+copy_on_change=false
+no_target_directory=
+
+usage="\
+Usage: $0 [OPTION]... [-T] SRCFILE DSTFILE
+   or: $0 [OPTION]... SRCFILES... DIRECTORY
+   or: $0 [OPTION]... -t DIRECTORY SRCFILES...
+   or: $0 [OPTION]... -d DIRECTORIES...
+
+In the 1st form, copy SRCFILE to DSTFILE.
+In the 2nd and 3rd, copy all SRCFILES to DIRECTORY.
+In the 4th, create DIRECTORIES.
+
+Options:
+     --help     display this help and exit.
+     --version  display version info and exit.
+
+  -c            (ignored)
+  -C            install only if different (preserve the last data modification time)
+  -d            create directories instead of installing files.
+  -g GROUP      $chgrpprog installed files to GROUP.
+  -m MODE       $chmodprog installed files to MODE.
+  -o USER       $chownprog installed files to USER.
+  -s            $stripprog installed files.
+  -t DIRECTORY  install into DIRECTORY.
+  -T            report an error if DSTFILE is a directory.
+
+Environment variables override the default commands:
+  CHGRPPROG CHMODPROG CHOWNPROG CMPPROG CPPROG MKDIRPROG MVPROG
+  RMPROG STRIPPROG
+"
+
+while test $# -ne 0; do
+  case $1 in
+    -c) ;;
+
+    -C) copy_on_change=true;;
+
+    -d) dir_arg=true;;
+
+    -g) chgrpcmd="$chgrpprog $2"
+	shift;;
+
+    --help) echo "$usage"; exit $?;;
+
+    -m) mode=$2
+	case $mode in
+	  *' '* | *'	'* | *'
+'*	  | *'*'* | *'?'* | *'['*)
+	    echo "$0: invalid mode: $mode" >&2
+	    exit 1;;
+	esac
+	shift;;
+
+    -o) chowncmd="$chownprog $2"
+	shift;;
+
+    -s) stripcmd=$stripprog;;
+
+    -t) dst_arg=$2
+	# Protect names problematic for 'test' and other utilities.
+	case $dst_arg in
+	  -* | [=\(\)!]) dst_arg=./$dst_arg;;
+	esac
+	shift;;
+
+    -T) no_target_directory=true;;
+
+    --version) echo "$0 $scriptversion"; exit $?;;
+
+    --)	shift
+	break;;
+
+    -*)	echo "$0: invalid option: $1" >&2
+	exit 1;;
+
+    *)  break;;
+  esac
+  shift
+done
+
+if test $# -ne 0 && test -z "$dir_arg$dst_arg"; then
+  # When -d is used, all remaining arguments are directories to create.
+  # When -t is used, the destination is already specified.
+  # Otherwise, the last argument is the destination.  Remove it from $@.
+  for arg
+  do
+    if test -n "$dst_arg"; then
+      # $@ is not empty: it contains at least $arg.
+      set fnord "$@" "$dst_arg"
+      shift # fnord
+    fi
+    shift # arg
+    dst_arg=$arg
+    # Protect names problematic for 'test' and other utilities.
+    case $dst_arg in
+      -* | [=\(\)!]) dst_arg=./$dst_arg;;
+    esac
+  done
+fi
+
+if test $# -eq 0; then
+  if test -z "$dir_arg"; then
+    echo "$0: no input file specified." >&2
+    exit 1
+  fi
+  # It's OK to call 'install-sh -d' without argument.
+  # This can happen when creating conditional directories.
+  exit 0
+fi
+
+if test -z "$dir_arg"; then
+  do_exit='(exit $ret); exit $ret'
+  trap "ret=129; $do_exit" 1
+  trap "ret=130; $do_exit" 2
+  trap "ret=141; $do_exit" 13
+  trap "ret=143; $do_exit" 15
+
+  # Set umask so as not to create temps with too-generous modes.
+  # However, 'strip' requires both read and write access to temps.
+  case $mode in
+    # Optimize common cases.
+    *644) cp_umask=133;;
+    *755) cp_umask=22;;
+
+    *[0-7])
+      if test -z "$stripcmd"; then
+	u_plus_rw=
+      else
+	u_plus_rw='% 200'
+      fi
+      cp_umask=`expr '(' 777 - $mode % 1000 ')' $u_plus_rw`;;
+    *)
+      if test -z "$stripcmd"; then
+	u_plus_rw=
+      else
+	u_plus_rw=,u+rw
+      fi
+      cp_umask=$mode$u_plus_rw;;
+  esac
+fi
+
+for src
+do
+  # Protect names problematic for 'test' and other utilities.
+  case $src in
+    -* | [=\(\)!]) src=./$src;;
+  esac
+
+  if test -n "$dir_arg"; then
+    dst=$src
+    dstdir=$dst
+    test -d "$dstdir"
+    dstdir_status=$?
+  else
+
+    # Waiting for this to be detected by the "$cpprog $src $dsttmp" command
+    # might cause directories to be created, which would be especially bad
+    # if $src (and thus $dsttmp) contains '*'.
+    if test ! -f "$src" && test ! -d "$src"; then
+      echo "$0: $src does not exist." >&2
+      exit 1
+    fi
+
+    if test -z "$dst_arg"; then
+      echo "$0: no destination specified." >&2
+      exit 1
+    fi
+    dst=$dst_arg
+
+    # If destination is a directory, append the input filename; won't work
+    # if double slashes aren't ignored.
+    if test -d "$dst"; then
+      if test -n "$no_target_directory"; then
+	echo "$0: $dst_arg: Is a directory" >&2
+	exit 1
+      fi
+      dstdir=$dst
+      dst=$dstdir/`basename "$src"`
+      dstdir_status=0
+    else
+      # Prefer dirname, but fall back on a substitute if dirname fails.
+      dstdir=`
+	(dirname "$dst") 2>/dev/null ||
+	expr X"$dst" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+	     X"$dst" : 'X\(//\)[^/]' \| \
+	     X"$dst" : 'X\(//\)$' \| \
+	     X"$dst" : 'X\(/\)' \| . 2>/dev/null ||
+	echo X"$dst" |
+	    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
+		   s//\1/
+		   q
+		 }
+		 /^X\(\/\/\)[^/].*/{
+		   s//\1/
+		   q
+		 }
+		 /^X\(\/\/\)$/{
+		   s//\1/
+		   q
+		 }
+		 /^X\(\/\).*/{
+		   s//\1/
+		   q
+		 }
+		 s/.*/./; q'
+      `
+
+      test -d "$dstdir"
+      dstdir_status=$?
+    fi
+  fi
+
+  obsolete_mkdir_used=false
+
+  if test $dstdir_status != 0; then
+    case $posix_mkdir in
+      '')
+	# Create intermediate dirs using mode 755 as modified by the umask.
+	# This is like FreeBSD 'install' as of 1997-10-28.
+	umask=`umask`
+	case $stripcmd.$umask in
+	  # Optimize common cases.
+	  *[2367][2367]) mkdir_umask=$umask;;
+	  .*0[02][02] | .[02][02] | .[02]) mkdir_umask=22;;
+
+	  *[0-7])
+	    mkdir_umask=`expr $umask + 22 \
+	      - $umask % 100 % 40 + $umask % 20 \
+	      - $umask % 10 % 4 + $umask % 2
+	    `;;
+	  *) mkdir_umask=$umask,go-w;;
+	esac
+
+	# With -d, create the new directory with the user-specified mode.
+	# Otherwise, rely on $mkdir_umask.
+	if test -n "$dir_arg"; then
+	  mkdir_mode=-m$mode
+	else
+	  mkdir_mode=
+	fi
+
+	posix_mkdir=false
+	case $umask in
+	  *[123567][0-7][0-7])
+	    # POSIX mkdir -p sets u+wx bits regardless of umask, which
+	    # is incompatible with FreeBSD 'install' when (umask & 300) != 0.
+	    ;;
+	  *)
+	    tmpdir=${TMPDIR-/tmp}/ins$RANDOM-$$
+	    trap 'ret=$?; rmdir "$tmpdir/d" "$tmpdir" 2>/dev/null; exit $ret' 0
+
+	    if (umask $mkdir_umask &&
+		exec $mkdirprog $mkdir_mode -p -- "$tmpdir/d") >/dev/null 2>&1
+	    then
+	      if test -z "$dir_arg" || {
+		   # Check for POSIX incompatibilities with -m.
+		   # HP-UX 11.23 and IRIX 6.5 mkdir -m -p sets group- or
+		   # other-writable bit of parent directory when it shouldn't.
+		   # FreeBSD 6.1 mkdir -m -p sets mode of existing directory.
+		   ls_ld_tmpdir=`ls -ld "$tmpdir"`
+		   case $ls_ld_tmpdir in
+		     d????-?r-*) different_mode=700;;
+		     d????-?--*) different_mode=755;;
+		     *) false;;
+		   esac &&
+		   $mkdirprog -m$different_mode -p -- "$tmpdir" && {
+		     ls_ld_tmpdir_1=`ls -ld "$tmpdir"`
+		     test "$ls_ld_tmpdir" = "$ls_ld_tmpdir_1"
+		   }
+		 }
+	      then posix_mkdir=:
+	      fi
+	      rmdir "$tmpdir/d" "$tmpdir"
+	    else
+	      # Remove any dirs left behind by ancient mkdir implementations.
+	      rmdir ./$mkdir_mode ./-p ./-- 2>/dev/null
+	    fi
+	    trap '' 0;;
+	esac;;
+    esac
+
+    if
+      $posix_mkdir && (
+	umask $mkdir_umask &&
+	$doit_exec $mkdirprog $mkdir_mode -p -- "$dstdir"
+      )
+    then :
+    else
+
+      # The umask is ridiculous, or mkdir does not conform to POSIX,
+      # or it failed possibly due to a race condition.  Create the
+      # directory the slow way, step by step, checking for races as we go.
+
+      case $dstdir in
+	/*) prefix='/';;
+	[-=\(\)!]*) prefix='./';;
+	*)  prefix='';;
+      esac
+
+      eval "$initialize_posix_glob"
+
+      oIFS=$IFS
+      IFS=/
+      $posix_glob set -f
+      set fnord $dstdir
+      shift
+      $posix_glob set +f
+      IFS=$oIFS
+
+      prefixes=
+
+      for d
+      do
+	test X"$d" = X && continue
+
+	prefix=$prefix$d
+	if test -d "$prefix"; then
+	  prefixes=
+	else
+	  if $posix_mkdir; then
+	    (umask=$mkdir_umask &&
+	     $doit_exec $mkdirprog $mkdir_mode -p -- "$dstdir") && break
+	    # Don't fail if two instances are running concurrently.
+	    test -d "$prefix" || exit 1
+	  else
+	    case $prefix in
+	      *\'*) qprefix=`echo "$prefix" | sed "s/'/'\\\\\\\\''/g"`;;
+	      *) qprefix=$prefix;;
+	    esac
+	    prefixes="$prefixes '$qprefix'"
+	  fi
+	fi
+	prefix=$prefix/
+      done
+
+      if test -n "$prefixes"; then
+	# Don't fail if two instances are running concurrently.
+	(umask $mkdir_umask &&
+	 eval "\$doit_exec \$mkdirprog $prefixes") ||
+	  test -d "$dstdir" || exit 1
+	obsolete_mkdir_used=true
+      fi
+    fi
+  fi
+
+  if test -n "$dir_arg"; then
+    { test -z "$chowncmd" || $doit $chowncmd "$dst"; } &&
+    { test -z "$chgrpcmd" || $doit $chgrpcmd "$dst"; } &&
+    { test "$obsolete_mkdir_used$chowncmd$chgrpcmd" = false ||
+      test -z "$chmodcmd" || $doit $chmodcmd $mode "$dst"; } || exit 1
+  else
+
+    # Make a couple of temp file names in the proper directory.
+    dsttmp=$dstdir/_inst.$$_
+    rmtmp=$dstdir/_rm.$$_
+
+    # Trap to clean up those temp files at exit.
+    trap 'ret=$?; rm -f "$dsttmp" "$rmtmp" && exit $ret' 0
+
+    # Copy the file name to the temp name.
+    (umask $cp_umask && $doit_exec $cpprog "$src" "$dsttmp") &&
+
+    # and set any options; do chmod last to preserve setuid bits.
+    #
+    # If any of these fail, we abort the whole thing.  If we want to
+    # ignore errors from any of these, just make sure not to ignore
+    # errors from the above "$doit $cpprog $src $dsttmp" command.
+    #
+    { test -z "$chowncmd" || $doit $chowncmd "$dsttmp"; } &&
+    { test -z "$chgrpcmd" || $doit $chgrpcmd "$dsttmp"; } &&
+    { test -z "$stripcmd" || $doit $stripcmd "$dsttmp"; } &&
+    { test -z "$chmodcmd" || $doit $chmodcmd $mode "$dsttmp"; } &&
+
+    # If -C, don't bother to copy if it wouldn't change the file.
+    if $copy_on_change &&
+       old=`LC_ALL=C ls -dlL "$dst"	2>/dev/null` &&
+       new=`LC_ALL=C ls -dlL "$dsttmp"	2>/dev/null` &&
+
+       eval "$initialize_posix_glob" &&
+       $posix_glob set -f &&
+       set X $old && old=:$2:$4:$5:$6 &&
+       set X $new && new=:$2:$4:$5:$6 &&
+       $posix_glob set +f &&
+
+       test "$old" = "$new" &&
+       $cmpprog "$dst" "$dsttmp" >/dev/null 2>&1
+    then
+      rm -f "$dsttmp"
+    else
+      # Rename the file to the real destination.
+      $doit $mvcmd -f "$dsttmp" "$dst" 2>/dev/null ||
+
+      # The rename failed, perhaps because mv can't rename something else
+      # to itself, or perhaps because mv is so ancient that it does not
+      # support -f.
+      {
+	# Now remove or move aside any old file at destination location.
+	# We try this two ways since rm can't unlink itself on some
+	# systems and the destination file might be busy for other
+	# reasons.  In this case, the final cleanup might fail but the new
+	# file should still install successfully.
+	{
+	  test ! -f "$dst" ||
+	  $doit $rmcmd -f "$dst" 2>/dev/null ||
+	  { $doit $mvcmd -f "$dst" "$rmtmp" 2>/dev/null &&
+	    { $doit $rmcmd -f "$rmtmp" 2>/dev/null; :; }
+	  } ||
+	  { echo "$0: cannot unlink or rename $dst" >&2
+	    (exit 1); exit 1
+	  }
+	} &&
+
+	# Now rename the file to the real destination.
+	$doit $mvcmd "$dsttmp" "$dst"
+      }
+    fi || exit 1
+
+    trap '' 0
+  fi
+done
+
+# Local variables:
+# 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:

libpngpf.3

@@ -1,6 +1,6 @@
-.TH LIBPNGPF 3 "February 21, 2015"
+.TH LIBPNGPF 3 "May 12, 2013"
 .SH NAME
-libpng \- Portable Network Graphics (PNG) Reference Library 1.7.0beta52
+libpng \- Portable Network Graphics (PNG) Reference Library 1.5.16beta06
 (private functions)
 .SH SYNOPSIS
 \fB#include \fI"pngpriv.h"
@@ -8,9 +8,9 @@ libpng \- Portable Network Graphics (PNG) Reference Library 1.7.0beta52
 \fBAs of libpng version \fP\fI1.5.1\fP\fB, this section is no longer \fP\fImaintained\fP\fB, now that the private function prototypes are hidden in pngpriv.h and not accessible to applications. Look in pngpriv.h for the prototypes and a short description of each \fIfunction.
 
 .SH DESCRIPTION
-The functions previously listed here are used privately by libpng and are not
-available for use by applications.  They are not "exported" to applications
-using shared libraries.
+The functions previously listed here are used privately by libpng
+and are not recommended for use by applications.  They are
+not "exported" to applications using shared libraries.
 
 .SH SEE ALSO
 .BR "png"(5), " libpng"(3), " zlib"(3), " deflate"(5), " " and " zlib"(5)

missing

@@ -0,0 +1,215 @@
+#! /bin/sh
+# Common wrapper for a few potentially missing GNU programs.
+
+scriptversion=2012-06-26.16; # UTC
+
+# Copyright (C) 1996-2012 Free Software Foundation, Inc.
+# Originally written by Fran,cois Pinard <pinard@iro.umontreal.ca>, 1996.
+
+# 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.
+
+if test $# -eq 0; then
+  echo 1>&2 "Try '$0 --help' for more information"
+  exit 1
+fi
+
+case $1 in
+
+  --is-lightweight)
+    # Used by our autoconf macros to check whether the available missing
+    # script is modern enough.
+    exit 0
+    ;;
+
+  --run)
+    # Back-compat with the calling convention used by older automake.
+    shift
+    ;;
+
+  -h|--h|--he|--hel|--help)
+    echo "\
+$0 [OPTION]... PROGRAM [ARGUMENT]...
+
+Run 'PROGRAM [ARGUMENT]...', returning a proper advice when this fails due
+to PROGRAM being missing or too old.
+
+Options:
+  -h, --help      display this help and exit
+  -v, --version   output version information and exit
+
+Supported PROGRAM values:
+  aclocal   autoconf  autoheader   autom4te  automake  makeinfo
+  bison     yacc      flex         lex       help2man
+
+Version suffixes to PROGRAM as well as the prefixes 'gnu-', 'gnu', and
+'g' are ignored when checking the name.
+
+Send bug reports to <bug-automake@gnu.org>."
+    exit $?
+    ;;
+
+  -v|--v|--ve|--ver|--vers|--versi|--versio|--version)
+    echo "missing $scriptversion (GNU Automake)"
+    exit $?
+    ;;
+
+  -*)
+    echo 1>&2 "$0: unknown '$1' option"
+    echo 1>&2 "Try '$0 --help' for more information"
+    exit 1
+    ;;
+
+esac
+
+# Run the given program, remember its exit status.
+"$@"; st=$?
+
+# If it succeeded, we are done.
+test $st -eq 0 && exit 0
+
+# Also exit now if we it failed (or wasn't found), and '--version' was
+# passed; such an option is passed most likely to detect whether the
+# program is present and works.
+case $2 in --version|--help) exit $st;; esac
+
+# Exit code 63 means version mismatch.  This often happens when the user
+# tries to use an ancient version of a tool on a file that requires a
+# minimum version.
+if test $st -eq 63; then
+  msg="probably too old"
+elif test $st -eq 127; then
+  # Program was missing.
+  msg="missing on your system"
+else
+  # Program was found and executed, but failed.  Give up.
+  exit $st
+fi
+
+perl_URL=http://www.perl.org/
+flex_URL=http://flex.sourceforge.net/
+gnu_software_URL=http://www.gnu.org/software
+
+program_details ()
+{
+  case $1 in
+    aclocal|automake)
+      echo "The '$1' program is part of the GNU Automake package:"
+      echo "<$gnu_software_URL/automake>"
+      echo "It also requires GNU Autoconf, GNU m4 and Perl in order to run:"
+      echo "<$gnu_software_URL/autoconf>"
+      echo "<$gnu_software_URL/m4/>"
+      echo "<$perl_URL>"
+      ;;
+    autoconf|autom4te|autoheader)
+      echo "The '$1' program is part of the GNU Autoconf package:"
+      echo "<$gnu_software_URL/autoconf/>"
+      echo "It also requires GNU m4 and Perl in order to run:"
+      echo "<$gnu_software_URL/m4/>"
+      echo "<$perl_URL>"
+      ;;
+  esac
+}
+
+give_advice ()
+{
+  # Normalize program name to check for.
+  normalized_program=`echo "$1" | sed '
+    s/^gnu-//; t
+    s/^gnu//; t
+    s/^g//; t'`
+
+  printf '%s\n' "'$1' is $msg."
+
+  configure_deps="'configure.ac' or m4 files included by 'configure.ac'"
+  case $normalized_program in
+    autoconf*)
+      echo "You should only need it if you modified 'configure.ac',"
+      echo "or m4 files included by it."
+      program_details 'autoconf'
+      ;;
+    autoheader*)
+      echo "You should only need it if you modified 'acconfig.h' or"
+      echo "$configure_deps."
+      program_details 'autoheader'
+      ;;
+    automake*)
+      echo "You should only need it if you modified 'Makefile.am' or"
+      echo "$configure_deps."
+      program_details 'automake'
+      ;;
+    aclocal*)
+      echo "You should only need it if you modified 'acinclude.m4' or"
+      echo "$configure_deps."
+      program_details 'aclocal'
+      ;;
+   autom4te*)
+      echo "You might have modified some maintainer files that require"
+      echo "the 'automa4te' program to be rebuilt."
+      program_details 'autom4te'
+      ;;
+    bison*|yacc*)
+      echo "You should only need it if you modified a '.y' file."
+      echo "You may want to install the GNU Bison package:"
+      echo "<$gnu_software_URL/bison/>"
+      ;;
+    lex*|flex*)
+      echo "You should only need it if you modified a '.l' file."
+      echo "You may want to install the Fast Lexical Analyzer package:"
+      echo "<$flex_URL>"
+      ;;
+    help2man*)
+      echo "You should only need it if you modified a dependency" \
+           "of a man page."
+      echo "You may want to install the GNU Help2man package:"
+      echo "<$gnu_software_URL/help2man/>"
+    ;;
+    makeinfo*)
+      echo "You should only need it if you modified a '.texi' file, or"
+      echo "any other file indirectly affecting the aspect of the manual."
+      echo "You might want to install the Texinfo package:"
+      echo "<$gnu_software_URL/texinfo/>"
+      echo "The spurious makeinfo call might also be the consequence of"
+      echo "using a buggy 'make' (AIX, DU, IRIX), in which case you might"
+      echo "want to install GNU make:"
+      echo "<$gnu_software_URL/make/>"
+      ;;
+    *)
+      echo "You might have modified some files without having the proper"
+      echo "tools for further handling them.  Check the 'README' file, it"
+      echo "often tells you about the needed prerequisites for installing"
+      echo "this package.  You may also peek at any GNU archive site, in"
+      echo "case some other package contains this missing '$1' program."
+      ;;
+  esac
+}
+
+give_advice "$1" | sed -e '1s/^/WARNING: /' \
+                       -e '2,$s/^/         /' >&2
+
+# Propagate the correct exit status (expected to be 127 for a program
+# not found, 63 for a program that failed due to version mismatch).
+exit $st
+
+# Local variables:
+# 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:

png.5

@@ -1,4 +1,4 @@
-.TH PNG 5 "February 21, 2015"
+.TH PNG 5 "May 12, 2013"
 .SH NAME
 png \- Portable Network Graphics (PNG) format
 .SH DESCRIPTION
@@ -24,7 +24,6 @@ PNG specification (second edition), November 2003:
 .IP
 .br
   <http://www.w3.org/TR/2003/REC-PNG-20031110/
-.LP
 PNG 1.2 specification, July 1999:
 .IP
 .br
@@ -59,7 +58,7 @@ Thomas Boutell and others (png-list).
 
 .SH COPYRIGHT NOTICE
 .LP
-This man page is Copyright (c) 1998-2012 Glenn Randers-Pehrson.  See png.h
+This man page is Copyright (c) 1998-2006 Glenn Randers-Pehrson.  See png.h
 for conditions of use and distribution.
 .LP
 The PNG Specification (Second Edition) is

pngconf.h

@@ -1,9 +1,9 @@
 
 /* pngconf.h - machine configurable file for libpng
  *
- * libpng version 1.7.0beta52 - February 21, 2015
+ * libpng version 1.5.16beta06 - May 12, 2013
  *
- * Copyright (c) 1998-2015 Glenn Randers-Pehrson
+ * Copyright (c) 1998-2013 Glenn Randers-Pehrson
  * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
  * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
  *
@@ -22,48 +22,32 @@
 #ifndef PNGCONF_H
 #define PNGCONF_H
 
-#ifndef PNG_BUILDING_SYMBOL_TABLE /* else includes may cause problems */
-
-/* From libpng 1.6.0 libpng requires an ANSI X3.159-1989 ("ISOC90") compliant C
- * compiler for correct compilation.  The following header files are required by
- * the standard.  If your compiler doesn't provide these header files, or they
- * do not match the standard, you will need to provide/improve them.
+#ifndef PNG_BUILDING_SYMBOL_TABLE
+/* PNG_NO_LIMITS_H may be used to turn off the use of the standard C
+ * definition file for  machine specific limits, this may impact the
+ * correctness of the definitions below (see uses of INT_MAX).
  */
-#include <limits.h>
-#include <stddef.h>
+#  ifndef PNG_NO_LIMITS_H
+#    include <limits.h>
+#  endif
 
-/* Library header files.  These header files are all defined by ISOC90; libpng
- * expects conformant implementations, however, an ISOC90 conformant system need
- * not provide these header files if the functionality cannot be implemented.
- * In this case it will be necessary to disable the relevant parts of libpng in
- * the build of pnglibconf.h.
- *
- * Prior to 1.6.0 string.h was included here; the API changes in 1.6.0 to not
- * include this unnecessary header file.
+/* For the memory copy APIs (i.e. the standard definitions of these),
+ * because this file defines png_memcpy and so on the base APIs must
+ * be defined here.
  */
+#  ifdef BSD
+#    include <strings.h>
+#  else
+#    include <string.h>
+#  endif
 
-#ifdef PNG_STDIO_SUPPORTED
-   /* Required for the definition of FILE: */
-#  include <stdio.h>
-#endif
-
-#ifdef PNG_SETJMP_SUPPORTED
-   /* Required for the definition of jmp_buf and the declaration of longjmp: */
-#  include <setjmp.h>
-#endif
-
-#ifdef PNG_CONVERT_tIME_SUPPORTED
-   /* Required for struct tm: */
-#  include <time.h>
-#endif
-
-#endif /* PNG_BUILDING_SYMBOL_TABLE */
-
-/* Prior to 1.6.0 it was possible to turn off 'const' in declarations using
- * PNG_NO_CONST; this is no longer supported except for data declarations which
- * apparently still cause problems in 2011 on some compilers.
+/* For png_FILE_p - this provides the standard definition of a
+ * FILE
  */
-#define PNG_CONST const /* backward compatibility only */
+#  ifdef PNG_STDIO_SUPPORTED
+#    include <stdio.h>
+#  endif
+#endif
 
 /* This controls optimization of the reading of 16 and 32 bit values
  * from PNG files.  It can be set on a per-app-file basis - it
@@ -88,13 +72,28 @@
  * may be changed on a per-file basis when compiling against libpng.
  */
 
-/* The PNGARG macro was used in versions of libpng prior to 1.6.0 to protect
- * against legacy (pre ISOC90) compilers that did not understand function
- * prototypes.  It is not required for modern C compilers.
+/* The PNGARG macro protects us against machines that don't have function
+ * prototypes (ie K&R style headers).  If your compiler does not handle
+ * function prototypes, define this macro and use the included ansi2knr.
+ * I've always been able to use _NO_PROTO as the indicator, but you may
+ * need to drag the empty declaration out in front of here, or change the
+ * ifdef to suit your own needs.
  */
 #ifndef PNGARG
-#  define PNGARG(arglist) arglist
-#endif
+
+#  ifdef OF /* zlib prototype munger */
+#    define PNGARG(arglist) OF(arglist)
+#  else
+
+#    ifdef _NO_PROTO
+#      define PNGARG(arglist) ()
+#    else
+#      define PNGARG(arglist) arglist
+#    endif /* _NO_PROTO */
+
+#  endif /* OF */
+
+#endif /* PNGARG */
 
 /* Function calling conventions.
  * =============================
@@ -221,7 +220,7 @@
   /* NOTE: PNGCBAPI always defaults to PNGCAPI. */
 
 #  if defined(PNGAPI) && !defined(PNG_USER_PRIVATEBUILD)
-#     error "PNG_USER_PRIVATEBUILD must be defined if PNGAPI is changed"
+   ERROR: PNG_USER_PRIVATEBUILD must be defined if PNGAPI is changed
 #  endif
 
 #  if (defined(_MSC_VER) && _MSC_VER < 800) ||\
@@ -335,37 +334,11 @@
 
 #ifdef PNG_PEDANTIC_WARNINGS_SUPPORTED
   /* Support for compiler specific function attributes.  These are used
-   * so that where compiler support is available, incorrect use of API
+   * so that where compiler support is available incorrect use of API
    * functions in png.h will generate compiler warnings.  Added at libpng
-   * version 1.2.41.  Disabling these removes the warnings but may also produce
-   * less efficient code.
+   * version 1.2.41.
    */
-#  if defined(__clang__) && defined(__has_attribute)
-     /* Clang defines both __clang__ and __GNUC__. Check __clang__ first. */
-#    if !defined(PNG_USE_RESULT) && __has_attribute(__warn_unused_result__)
-#      define PNG_USE_RESULT __attribute__((__warn_unused_result__))
-#    endif
-#    if !defined(PNG_NORETURN) && __has_attribute(__noreturn__)
-#      define PNG_NORETURN __attribute__((__noreturn__))
-#    endif
-#    if !defined(PNG_ALLOCATED) && __has_attribute(__malloc__)
-#      define PNG_ALLOCATED __attribute__((__malloc__))
-#    endif
-#    if !defined(PNG_DEPRECATED) && __has_attribute(__deprecated__)
-#      define PNG_DEPRECATED __attribute__((__deprecated__))
-#    endif
-#    if !defined(PNG_PRIVATE)
-#      ifdef __has_extension
-#        if __has_extension(attribute_unavailable_with_message)
-#          define PNG_PRIVATE __attribute__((__unavailable__(\
-             "This function is not exported by libpng.")))
-#        endif
-#      endif
-#    endif
-#    ifndef PNG_RESTRICT
-#      define PNG_RESTRICT __restrict
-#    endif
-#  elif defined(__GNUC__)
+#  if defined(__GNUC__)
 #    ifndef PNG_USE_RESULT
 #      define PNG_USE_RESULT __attribute__((__warn_unused_result__))
 #    endif
@@ -388,19 +361,15 @@
             __attribute__((__deprecated__))
 #        endif
 #      endif
-#      if ((__GNUC__ > 3) || !defined(__GNUC_MINOR__) || (__GNUC_MINOR__ >= 1))
-#        ifndef PNG_RESTRICT
-#          define PNG_RESTRICT __restrict
-#        endif
-#      endif /* __GNUC__.__GNUC_MINOR__ > 3.0 */
-#    endif /* __GNUC__ >= 3 */
+#    endif /*  __GNUC__ >= 3 */
+#  endif /* __GNUC__ */
 
-#  elif defined(_MSC_VER)  && (_MSC_VER >= 1300)
+#  if defined(_MSC_VER)  && (_MSC_VER >= 1300)
 #    ifndef PNG_USE_RESULT
 #      define PNG_USE_RESULT /* not supported */
 #    endif
 #    ifndef PNG_NORETURN
-#      define PNG_NORETURN   __declspec(noreturn)
+#      define PNG_NORETURN __declspec(noreturn)
 #    endif
 #    ifndef PNG_ALLOCATED
 #      if (_MSC_VER >= 1400)
@@ -413,17 +382,7 @@
 #    ifndef PNG_PRIVATE
 #      define PNG_PRIVATE __declspec(deprecated)
 #    endif
-#    ifndef PNG_RESTRICT
-#      if (_MSC_VER >= 1400)
-#        define PNG_RESTRICT __restrict
-#      endif
-#    endif
-
-#  elif defined(__WATCOMC__)
-#    ifndef PNG_RESTRICT
-#      define PNG_RESTRICT __restrict
-#    endif
-#  endif
+#  endif /* _MSC_VER */
 #endif /* PNG_PEDANTIC_WARNINGS */
 
 #ifndef PNG_DEPRECATED
@@ -441,18 +400,6 @@
 #ifndef PNG_PRIVATE
 #  define PNG_PRIVATE     /* This is a private libpng function */
 #endif
-#ifndef PNG_RESTRICT
-#  define PNG_RESTRICT    /* The C99 "restrict" feature */
-#endif
-
-#ifndef PNG_FP_EXPORT     /* A floating point API. */
-#  ifdef PNG_FLOATING_POINT_SUPPORTED
-#     define PNG_FP_EXPORT(ordinal, type, name, args)\
-         PNG_EXPORT(ordinal, type, name, args);
-#  else                   /* No floating point APIs */
-#     define PNG_FP_EXPORT(ordinal, type, name, args)
-#  endif
-#endif
 #ifndef PNG_FP_EXPORT     /* A floating point API. */
 #  ifdef PNG_FLOATING_POINT_SUPPORTED
 #     define PNG_FP_EXPORT(ordinal, type, name, args)\
@@ -470,163 +417,183 @@
 #  endif
 #endif
 
-#ifndef PNG_BUILDING_SYMBOL_TABLE
-/* Some typedefs to get us started.  These should be safe on most of the common
- * platforms.
+/* The following uses const char * instead of char * for error
+ * and warning message functions, so some compilers won't complain.
+ * If you do not want to use const, define PNG_NO_CONST here.
  *
- * png_uint_32 and png_int_32 may, currently, be larger than required to hold a
- * 32-bit value however this is not normally advisable.
- *
- * png_uint_16 and png_int_16 should always be two bytes in size - this is
- * verified at library build time.
- *
- * png_byte must always be one byte in size.
- *
- * The checks below use constants from limits.h, as defined by the ISOC90
- * standard.
+ * This should not change how the APIs are called, so it can be done
+ * on a per-file basis in the application.
  */
-#if CHAR_BIT == 8 && UCHAR_MAX == 255
-   typedef unsigned char png_byte;
-#else
-#  error "libpng requires 8 bit bytes"
-#endif
-
-#if INT_MIN == -32768 && INT_MAX == 32767
-   typedef int png_int_16;
-#elif SHRT_MIN == -32768 && SHRT_MAX == 32767
-   typedef short png_int_16;
-#else
-#  error "libpng requires a signed 16 bit type"
-#endif
-
-#if UINT_MAX == 65535
-   typedef unsigned int png_uint_16;
-#elif USHRT_MAX == 65535
-   typedef unsigned short png_uint_16;
-#else
-#  error "libpng requires an unsigned 16 bit type"
-#endif
-
-#if INT_MIN < -2147483646 && INT_MAX > 2147483646
-   typedef int png_int_32;
-#elif LONG_MIN < -2147483646 && LONG_MAX > 2147483646
-   typedef long int png_int_32;
-#else
-#  error "libpng requires a signed 32 bit (or more) type"
-#endif
-
-#if UINT_MAX > 4294967294
-   typedef unsigned int png_uint_32;
-#elif ULONG_MAX > 4294967294
-   typedef unsigned long int png_uint_32;
-#else
-#  error "libpng requires an unsigned 32 bit (or more) type"
-#endif
-
-/* Prior to 1.6.0 it was possible to disable the use of size_t, 1.6.0, however,
- * requires an ISOC90 compiler and relies on consistent behavior of sizeof.
- *
- * DEPRECATED: don't use these types, instead use size_t and ptrdiff_t.
- */
-typedef size_t png_size_t;
-typedef ptrdiff_t png_ptrdiff_t;
-
-/* libpng needs to know the maximum value of 'size_t' and this controls the
- * definition of png_alloc_size_t, below.  This maximum value of size_t limits
- * but does not control the maximum allocations the library makes - there is
- * direct application control of this through png_set_user_limits().
- */
-#ifndef PNG_SMALL_SIZE_T
-   /* Compiler specific tests for systems where size_t is known to be less than
-    * 32 bits (some of these systems may no longer work because of the lack of
-    * 'far' support; see above.)
-    */
-#  if (defined(__TURBOC__) && !defined(__FLAT__)) ||\
-   (defined(_MSC_VER) && defined(MAXSEG_64K))
-#     define PNG_SMALL_SIZE_T
+#ifndef PNG_CONST
+#  ifndef PNG_NO_CONST
+#    define PNG_CONST const
+#  else
+#    define PNG_CONST
 #  endif
 #endif
 
-/* png_alloc_size_t is guaranteed to be no smaller than size_t, and no
- * smaller than png_uint_32.  Casts from size_t or png_uint_32 to
- * png_alloc_size_t are not necessary; in fact, it is recommended not to use
- * them at all so that the compiler can complain when something turns out to be
- * problematic.
- *
- * Casts in the other direction (from png_alloc_size_t to size_t or
- * png_uint_32) should be explicitly applied; however, we do not expect to
- * encounter practical situations that require such conversions.
- *
- * PNG_SMALL_SIZE_T must be defined if the maximum value of size_t is less than
- * 4294967295 - i.e. less than the maximum value of png_uint_32.
+/* Some typedefs to get us started.  These should be safe on most of the
+ * common platforms.  The typedefs should be at least as large as the
+ * numbers suggest (a png_uint_32 must be at least 32 bits long), but they
+ * don't have to be exactly that size.  Some compilers dislike passing
+ * unsigned shorts as function parameters, so you may be better off using
+ * unsigned int for png_uint_16.
  */
-#ifdef PNG_SMALL_SIZE_T
-   typedef png_uint_32 png_alloc_size_t;
+
+#if defined(INT_MAX) && (INT_MAX > 0x7ffffffeL)
+typedef unsigned int png_uint_32;
+typedef int png_int_32;
 #else
-   typedef size_t png_alloc_size_t;
+typedef unsigned long png_uint_32;
+typedef long png_int_32;
+#endif
+typedef unsigned short png_uint_16;
+typedef short png_int_16;
+typedef unsigned char png_byte;
+
+#ifdef PNG_NO_SIZE_T
+typedef unsigned int png_size_t;
+#else
+typedef size_t png_size_t;
+#endif
+#define png_sizeof(x) (sizeof (x))
+
+/* The following is needed for medium model support.  It cannot be in the
+ * pngpriv.h header.  Needs modification for other compilers besides
+ * MSC.  Model independent support declares all arrays and pointers to be
+ * large using the far keyword.  The zlib version used must also support
+ * model independent data.  As of version zlib 1.0.4, the necessary changes
+ * have been made in zlib.  The USE_FAR_KEYWORD define triggers other
+ * changes that are needed. (Tim Wegner)
+ */
+
+/* Separate compiler dependencies (problem here is that zlib.h always
+ * defines FAR. (SJT)
+ */
+#ifdef __BORLANDC__
+#  if defined(__LARGE__) || defined(__HUGE__) || defined(__COMPACT__)
+#    define LDATA 1
+#  else
+#    define LDATA 0
+#  endif
+  /* GRR:  why is Cygwin in here?  Cygwin is not Borland C... */
+#  if !defined(__WIN32__) && !defined(__FLAT__) && !defined(__CYGWIN__)
+#    define PNG_MAX_MALLOC_64K /* only used in build */
+#    if (LDATA != 1)
+#      ifndef FAR
+#        define FAR __far
+#      endif
+#      define USE_FAR_KEYWORD
+#    endif   /* LDATA != 1 */
+         /* Possibly useful for moving data out of default segment.
+          * Uncomment it if you want. Could also define FARDATA as
+          * const if your compiler supports it. (SJT)
+#        define FARDATA FAR
+          */
+#  endif  /* __WIN32__, __FLAT__, __CYGWIN__ */
+#endif   /* __BORLANDC__ */
+
+
+/* Suggest testing for specific compiler first before testing for
+ * FAR.  The Watcom compiler defines both __MEDIUM__ and M_I86MM,
+ * making reliance oncertain keywords suspect. (SJT)
+ */
+
+/* MSC Medium model */
+#ifdef FAR
+#  ifdef M_I86MM
+#    define USE_FAR_KEYWORD
+#    define FARDATA FAR
+#    include <dos.h>
+#  endif
 #endif
 
-/* Prior to 1.6.0 libpng offered limited support for Microsoft C compiler
- * implementations of Intel CPU specific support of user-mode segmented address
- * spaces, where 16-bit pointers address more than 65536 bytes of memory using
- * separate 'segment' registers.  The implementation requires two different
- * types of pointer (only one of which includes the segment value.)
- *
- * If required this support is available in version 1.2 of libpng and may be
- * available in versions through 1.5, although the correctness of the code has
- * not been verified recently.
- */
+/* SJT: default case */
+#ifndef FAR
+#  define FAR
+#endif
 
-/* Typedef for floating-point numbers that are converted to fixed-point with a
- * multiple of 100,000, e.g., gamma
+/* At this point FAR is always defined */
+#ifndef FARDATA
+#  define FARDATA
+#endif
+
+/* Typedef for floating-point numbers that are converted
+ * to fixed-point with a multiple of 100,000, e.g., gamma
  */
 typedef png_int_32 png_fixed_point;
 
 /* Add typedefs for pointers */
-typedef void                  * png_voidp;
-typedef const void            * png_const_voidp;
-typedef png_byte              * png_bytep;
-typedef const png_byte        * png_const_bytep;
-typedef png_uint_32           * png_uint_32p;
-typedef const png_uint_32     * png_const_uint_32p;
-typedef png_int_32            * png_int_32p;
-typedef const png_int_32      * png_const_int_32p;
-typedef png_uint_16           * png_uint_16p;
-typedef const png_uint_16     * png_const_uint_16p;
-typedef png_int_16            * png_int_16p;
-typedef const png_int_16      * png_const_int_16p;
-typedef char                  * png_charp;
-typedef const char            * png_const_charp;
-typedef png_fixed_point       * png_fixed_point_p;
-typedef const png_fixed_point * png_const_fixed_point_p;
-typedef size_t                * png_size_tp;
-typedef const size_t          * png_const_size_tp;
+typedef void                      FAR * png_voidp;
+typedef PNG_CONST void            FAR * png_const_voidp;
+typedef png_byte                  FAR * png_bytep;
+typedef PNG_CONST png_byte        FAR * png_const_bytep;
+typedef png_uint_32               FAR * png_uint_32p;
+typedef PNG_CONST png_uint_32     FAR * png_const_uint_32p;
+typedef png_int_32                FAR * png_int_32p;
+typedef PNG_CONST png_int_32      FAR * png_const_int_32p;
+typedef png_uint_16               FAR * png_uint_16p;
+typedef PNG_CONST png_uint_16     FAR * png_const_uint_16p;
+typedef png_int_16                FAR * png_int_16p;
+typedef PNG_CONST png_int_16      FAR * png_const_int_16p;
+typedef char                      FAR * png_charp;
+typedef PNG_CONST char            FAR * png_const_charp;
+typedef png_fixed_point           FAR * png_fixed_point_p;
+typedef PNG_CONST png_fixed_point FAR * png_const_fixed_point_p;
+typedef png_size_t                FAR * png_size_tp;
+typedef PNG_CONST png_size_t      FAR * png_const_size_tp;
 
 #ifdef PNG_STDIO_SUPPORTED
 typedef FILE            * png_FILE_p;
 #endif
 
 #ifdef PNG_FLOATING_POINT_SUPPORTED
-typedef double       * png_doublep;
-typedef const double * png_const_doublep;
+typedef double           FAR * png_doublep;
+typedef PNG_CONST double FAR * png_const_doublep;
 #endif
 
 /* Pointers to pointers; i.e. arrays */
-typedef png_byte        * * png_bytepp;
-typedef png_uint_32     * * png_uint_32pp;
-typedef png_int_32      * * png_int_32pp;
-typedef png_uint_16     * * png_uint_16pp;
-typedef png_int_16      * * png_int_16pp;
-typedef const char      * * png_const_charpp;
-typedef char            * * png_charpp;
-typedef png_fixed_point * * png_fixed_point_pp;
+typedef png_byte        FAR * FAR * png_bytepp;
+typedef png_uint_32     FAR * FAR * png_uint_32pp;
+typedef png_int_32      FAR * FAR * png_int_32pp;
+typedef png_uint_16     FAR * FAR * png_uint_16pp;
+typedef png_int_16      FAR * FAR * png_int_16pp;
+typedef PNG_CONST char  FAR * FAR * png_const_charpp;
+typedef char            FAR * FAR * png_charpp;
+typedef png_fixed_point FAR * FAR * png_fixed_point_pp;
 #ifdef PNG_FLOATING_POINT_SUPPORTED
-typedef double          * * png_doublepp;
+typedef double          FAR * FAR * png_doublepp;
 #endif
 
 /* Pointers to pointers to pointers; i.e., pointer to array */
-typedef char            * * * png_charppp;
+typedef char            FAR * FAR * FAR * png_charppp;
 
-#endif /* PNG_BUILDING_SYMBOL_TABLE */
+/* png_alloc_size_t is guaranteed to be no smaller than png_size_t,
+ * and no smaller than png_uint_32.  Casts from png_size_t or png_uint_32
+ * to png_alloc_size_t are not necessary; in fact, it is recommended
+ * not to use them at all so that the compiler can complain when something
+ * turns out to be problematic.
+ * Casts in the other direction (from png_alloc_size_t to png_size_t or
+ * png_uint_32) should be explicitly applied; however, we do not expect
+ * to encounter practical situations that require such conversions.
+ */
+#if defined(__TURBOC__) && !defined(__FLAT__)
+   typedef unsigned long png_alloc_size_t;
+#else
+#  if defined(_MSC_VER) && defined(MAXSEG_64K)
+     typedef unsigned long    png_alloc_size_t;
+#  else
+     /* This is an attempt to detect an old Windows system where (int) is
+      * actually 16 bits, in that case png_malloc must have an argument with a
+      * bigger size to accomodate the requirements of the library.
+      */
+#    if (defined(_Windows) || defined(_WINDOWS) || defined(_WINDOWS_)) && \
+        (!defined(INT_MAX) || INT_MAX <= 0x7ffffffeL)
+       typedef DWORD         png_alloc_size_t;
+#    else
+       typedef png_size_t    png_alloc_size_t;
+#    endif
+#  endif
+#endif
 
 #endif /* PNGCONF_H */

pngdebug.h

@@ -1,11 +1,12 @@
 
 /* pngdebug.h - Debugging macros for libpng, also used in pngtest.c
  *
- * Last changed in libpng 1.6.8 [December 19, 2013]
- * Copyright (c) 1998-2013 Glenn Randers-Pehrson
+ * Copyright (c) 1998-2011 Glenn Randers-Pehrson
  * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
  * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
  *
+ * Last changed in libpng 1.5.0 [January 6, 2011]
+ *
  * This code is released under the libpng license.
  * For conditions of distribution and use, see the disclaimer
  * and license in png.h
@@ -24,7 +25,7 @@
  *   (actually ((void)0)).
  *
  *   level: level of detail of message, starting at 0.  A level 'n'
- *          message is preceded by 'n' 3-space indentations (not implemented
+ *          message is preceded by 'n' tab characters (not implemented
  *          on Microsoft compilers unless PNG_DEBUG_FILE is also
  *          defined, to allow debug DLL compilation with no standard IO).
  *   message: a printf(3) style text string.  A trailing '\n' is added
@@ -76,29 +77,32 @@
 #      endif /* PNG_DEBUG_FILE */
 
 #      if (PNG_DEBUG > 1)
+/* Note: ["%s"m PNG_STRING_NEWLINE] probably does not work on
+ * non-ISO compilers
+ */
 #        ifdef __STDC__
 #          ifndef png_debug
 #            define png_debug(l,m) \
        do { \
        int num_tabs=l; \
-       fprintf(PNG_DEBUG_FILE,"%s" m PNG_STRING_NEWLINE,(num_tabs==1 ? "   " : \
-         (num_tabs==2 ? "      " : (num_tabs>2 ? "         " : "")))); \
+       fprintf(PNG_DEBUG_FILE,"%s"m PNG_STRING_NEWLINE,(num_tabs==1 ? "\t" : \
+         (num_tabs==2 ? "\t\t":(num_tabs>2 ? "\t\t\t":"")))); \
        } while (0)
 #          endif
 #          ifndef png_debug1
 #            define png_debug1(l,m,p1) \
        do { \
        int num_tabs=l; \
-       fprintf(PNG_DEBUG_FILE,"%s" m PNG_STRING_NEWLINE,(num_tabs==1 ? "   " : \
-         (num_tabs==2 ? "      " : (num_tabs>2 ? "         " : ""))),p1); \
+       fprintf(PNG_DEBUG_FILE,"%s"m PNG_STRING_NEWLINE,(num_tabs==1 ? "\t" : \
+         (num_tabs==2 ? "\t\t":(num_tabs>2 ? "\t\t\t":""))),p1); \
        } while (0)
 #          endif
 #          ifndef png_debug2
 #            define png_debug2(l,m,p1,p2) \
        do { \
        int num_tabs=l; \
-       fprintf(PNG_DEBUG_FILE,"%s" m PNG_STRING_NEWLINE,(num_tabs==1 ? "   " : \
-         (num_tabs==2 ? "      " : (num_tabs>2 ? "         " : ""))),p1,p2);\
+       fprintf(PNG_DEBUG_FILE,"%s"m PNG_STRING_NEWLINE,(num_tabs==1 ? "\t" : \
+         (num_tabs==2 ? "\t\t":(num_tabs>2 ? "\t\t\t":""))),p1,p2); \
        } while (0)
 #          endif
 #        else /* __STDC __ */

pngerror.c

@@ -1,8 +1,8 @@
 
 /* pngerror.c - stub functions for i/o and memory allocation
  *
- * Last changed in libpng 1.7.0 [(PENDING RELEASE)]
- * Copyright (c) 1998-2015 Glenn Randers-Pehrson
+ * Last changed in libpng 1.5.14 [January 24, 2013]
+ * Copyright (c) 1998-2013 Glenn Randers-Pehrson
  * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
  * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
  *
@@ -20,14 +20,14 @@
 
 #if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)
 
-static PNG_FUNCTION(void, png_default_error,PNGARG((png_const_structrp png_ptr,
+static PNG_FUNCTION(void, png_default_error,PNGARG((png_structp png_ptr,
     png_const_charp error_message)),PNG_NORETURN);
 
 #ifdef PNG_WARNINGS_SUPPORTED
 static void /* PRIVATE */
-png_default_warning PNGARG((png_const_structrp png_ptr,
+png_default_warning PNGARG((png_structp png_ptr,
    png_const_charp warning_message));
-#endif /* WARNINGS */
+#endif /* PNG_WARNINGS_SUPPORTED */
 
 /* This function is called whenever there is a fatal error.  This function
  * should not be changed.  If there is a need to handle errors differently,
@@ -36,15 +36,14 @@ png_default_warning PNGARG((png_const_structrp png_ptr,
  */
 #ifdef PNG_ERROR_TEXT_SUPPORTED
 PNG_FUNCTION(void,PNGAPI
-png_error,(png_const_structrp png_ptr, png_const_charp error_message),
-   PNG_NORETURN)
+png_error,(png_structp png_ptr, png_const_charp error_message),PNG_NORETURN)
 {
 #ifdef PNG_ERROR_NUMBERS_SUPPORTED
    char msg[16];
    if (png_ptr != NULL)
    {
-      if ((png_ptr->flags &
-         (PNG_FLAG_STRIP_ERROR_NUMBERS|PNG_FLAG_STRIP_ERROR_TEXT)) != 0
+      if (png_ptr->flags&
+         (PNG_FLAG_STRIP_ERROR_NUMBERS|PNG_FLAG_STRIP_ERROR_TEXT))
       {
          if (*error_message == PNG_LITERAL_SHARP)
          {
@@ -54,7 +53,7 @@ png_error,(png_const_structrp png_ptr, png_const_charp error_message),
                if (error_message[offset] == ' ')
                   break;
 
-            if ((png_ptr->flags & PNG_FLAG_STRIP_ERROR_TEXT) != 0)
+            if (png_ptr->flags&PNG_FLAG_STRIP_ERROR_TEXT)
             {
                int i;
                for (i = 0; i < offset - 1; i++)
@@ -69,7 +68,7 @@ png_error,(png_const_structrp png_ptr, png_const_charp error_message),
 
       else
       {
-         if ((png_ptr->flags & PNG_FLAG_STRIP_ERROR_TEXT) != 0)
+         if (png_ptr->flags&PNG_FLAG_STRIP_ERROR_TEXT)
          {
             msg[0] = '0';
             msg[1] = '\0';
@@ -80,8 +79,7 @@ png_error,(png_const_structrp png_ptr, png_const_charp error_message),
    }
 #endif
    if (png_ptr != NULL && png_ptr->error_fn != NULL)
-      (*(png_ptr->error_fn))(png_constcast(png_structrp,png_ptr),
-          error_message);
+      (*(png_ptr->error_fn))(png_ptr, error_message);
 
    /* If the custom handler doesn't exist, or if it returns,
       use the default handler, which will not return. */
@@ -89,7 +87,7 @@ png_error,(png_const_structrp png_ptr, png_const_charp error_message),
 }
 #else
 PNG_FUNCTION(void,PNGAPI
-png_err,(png_const_structrp png_ptr),PNG_NORETURN)
+png_err,(png_structp png_ptr),PNG_NORETURN)
 {
    /* Prior to 1.5.2 the error_fn received a NULL pointer, expressed
     * erroneously as '\0', instead of the empty string "".  This was
@@ -97,13 +95,13 @@ png_err,(png_const_structrp png_ptr),PNG_NORETURN)
     * will crash in this case.
     */
    if (png_ptr != NULL && png_ptr->error_fn != NULL)
-      (*(png_ptr->error_fn))(png_constcast(png_structrp,png_ptr), "");
+      (*(png_ptr->error_fn))(png_ptr, "");
 
    /* If the custom handler doesn't exist, or if it returns,
       use the default handler, which will not return. */
    png_default_error(png_ptr, "");
 }
-#endif /* ERROR_TEXT */
+#endif /* PNG_ERROR_TEXT_SUPPORTED */
 
 /* Utility to safely appends strings to a buffer.  This never errors out so
  * error checking is not required in the caller.
@@ -152,7 +150,7 @@ png_format_number(png_const_charp start, png_charp end, int format,
          case PNG_NUMBER_FORMAT_fixed:
             /* Needs five digits (the fraction) */
             mincount = 5;
-            if (output != 0 || number % 10 != 0)
+            if (output || number % 10 != 0)
             {
                *--end = digits[number % 10];
                output = 1;
@@ -189,13 +187,13 @@ png_format_number(png_const_charp start, png_charp end, int format,
       ++count;
 
       /* Float a fixed number here: */
-      if ((format == PNG_NUMBER_FORMAT_fixed) && (count == 5) && (end > start))
+      if (format == PNG_NUMBER_FORMAT_fixed) if (count == 5) if (end > start)
       {
          /* End of the fraction, but maybe nothing was output?  In that case
           * drop the decimal point.  If the number is a true zero handle that
           * here.
           */
-         if (output != 0)
+         if (output)
             *--end = '.';
          else if (number == 0) /* and !output */
             *--end = '0';
@@ -213,14 +211,14 @@ png_format_number(png_const_charp start, png_charp end, int format,
  * png_set_error_fn() to replace the warning function at run-time.
  */
 void PNGAPI
-png_warning(png_const_structrp png_ptr, png_const_charp warning_message)
+png_warning(png_structp png_ptr, png_const_charp warning_message)
 {
    int offset = 0;
    if (png_ptr != NULL)
    {
 #ifdef PNG_ERROR_NUMBERS_SUPPORTED
-   if ((png_ptr->flags &
-       (PNG_FLAG_STRIP_ERROR_NUMBERS|PNG_FLAG_STRIP_ERROR_TEXT)) != 0)
+   if (png_ptr->flags&
+       (PNG_FLAG_STRIP_ERROR_NUMBERS|PNG_FLAG_STRIP_ERROR_TEXT))
 #endif
       {
          if (*warning_message == PNG_LITERAL_SHARP)
@@ -232,8 +230,7 @@ png_warning(png_const_structrp png_ptr, png_const_charp warning_message)
       }
    }
    if (png_ptr != NULL && png_ptr->warning_fn != NULL)
-      (*(png_ptr->warning_fn))(png_constcast(png_structrp,png_ptr),
-         warning_message + offset);
+      (*(png_ptr->warning_fn))(png_ptr, warning_message + offset);
    else
       png_default_warning(png_ptr, warning_message + offset);
 }
@@ -281,7 +278,7 @@ png_warning_parameter_signed(png_warning_parameters p, int number, int format,
 }
 
 void
-png_formatted_warning(png_const_structrp png_ptr, png_warning_parameters p,
+png_formatted_warning(png_structp png_ptr, png_warning_parameters p,
    png_const_charp message)
 {
    /* The internal buffer is just 192 bytes - enough for all our messages,
@@ -349,79 +346,29 @@ png_formatted_warning(png_const_structrp png_ptr, png_warning_parameters p,
    /* i is always less than (sizeof msg), so: */
    msg[i] = '\0';
 
-   /* And this is the formatted message. It may be larger than
-    * PNG_MAX_ERROR_TEXT, but that is only used for 'chunk' errors and these
-    * are not (currently) formatted.
+   /* And this is the formatted message, it may be larger than
+    * PNG_MAX_ERROR_TEXT, but that is only used for 'chunk' errors and these are
+    * not (currently) formatted.
     */
    png_warning(png_ptr, msg);
 }
-#endif /* WARNINGS */
+#endif /* PNG_WARNINGS_SUPPORTED */
 
 #ifdef PNG_BENIGN_ERRORS_SUPPORTED
 void PNGAPI
-png_benign_error(png_const_structrp png_ptr, png_const_charp error_message)
+png_benign_error(png_structp png_ptr, png_const_charp error_message)
 {
-   if ((png_ptr->flags & PNG_FLAG_BENIGN_ERRORS_WARN) != 0)
-   {
-#     ifdef PNG_READ_SUPPORTED
-         if ((png_ptr->mode & PNG_IS_READ_STRUCT) != 0 &&
-            png_ptr->chunk_name != 0)
-            png_chunk_warning(png_ptr, error_message);
-         else
-#     endif
-      png_warning(png_ptr, error_message);
-   }
-
-   else
-   {
-#     ifdef PNG_READ_SUPPORTED
-         if ((png_ptr->mode & PNG_IS_READ_STRUCT) != 0 &&
-            png_ptr->chunk_name != 0)
-            png_chunk_error(png_ptr, error_message);
-         else
-#     endif
-      png_error(png_ptr, error_message);
-   }
-
-#  ifndef PNG_ERROR_TEXT_SUPPORTED
-      PNG_UNUSED(error_message)
-#  endif
-}
-
-void /* PRIVATE */
-png_app_warning(png_const_structrp png_ptr, png_const_charp error_message)
-{
-  if ((png_ptr->flags & PNG_FLAG_APP_WARNINGS_WARN) != 0)
+  if (png_ptr->flags & PNG_FLAG_BENIGN_ERRORS_WARN)
      png_warning(png_ptr, error_message);
   else
      png_error(png_ptr, error_message);
-
-#  ifndef PNG_ERROR_TEXT_SUPPORTED
-      PNG_UNUSED(error_message)
-#  endif
 }
+#endif
 
-void /* PRIVATE */
-png_app_error(png_const_structrp png_ptr, png_const_charp error_message)
-{
-  if ((png_ptr->flags & PNG_FLAG_APP_ERRORS_WARN) != 0)
-     png_warning(png_ptr, error_message);
-  else
-     png_error(png_ptr, error_message);
-
-#  ifndef PNG_ERROR_TEXT_SUPPORTED
-      PNG_UNUSED(error_message)
-#  endif
-}
-#endif /* BENIGN_ERRORS */
-
-#define PNG_MAX_ERROR_TEXT 196 /* Currently limited by profile_error in png.c */
-#if defined(PNG_WARNINGS_SUPPORTED) || \
-   (defined(PNG_READ_SUPPORTED) && defined(PNG_ERROR_TEXT_SUPPORTED))
 /* These utilities are used internally to build an error message that relates
  * to the current chunk.  The chunk name comes from png_ptr->chunk_name,
- * which is used to prefix the message.  The message is limited in length
- * to 63 bytes. The name characters are output as hex digits wrapped in []
+ * this is used to prefix the message.  The message is limited in length
+ * to 63 bytes, the name characters are output as hex digits wrapped in []
  * if the character is invalid.
  */
 #define isnonalpha(c) ((c) < 65 || (c) > 122 || ((c) > 90 && (c) < 97))
@@ -430,8 +377,10 @@ static PNG_CONST char png_digit[16] = {
    'A', 'B', 'C', 'D', 'E', 'F'
 };
 
+#define PNG_MAX_ERROR_TEXT 64
+#if defined(PNG_WARNINGS_SUPPORTED) || defined(PNG_ERROR_TEXT_SUPPORTED)
 static void /* PRIVATE */
-png_format_buffer(png_const_structrp png_ptr, png_charp buffer, png_const_charp
+png_format_buffer(png_structp png_ptr, png_charp buffer, png_const_charp
     error_message)
 {
    png_uint_32 chunk_name = png_ptr->chunk_name;
@@ -442,7 +391,7 @@ png_format_buffer(png_const_structrp png_ptr, png_charp buffer, png_const_charp
       int c = (int)(chunk_name >> ishift) & 0xff;
 
       ishift -= 8;
-      if (isnonalpha(c) != 0)
+      if (isnonalpha(c))
       {
          buffer[iout++] = PNG_LITERAL_LEFT_SQUARE_BRACKET;
          buffer[iout++] = png_digit[(c & 0xf0) >> 4];
@@ -473,11 +422,11 @@ png_format_buffer(png_const_structrp png_ptr, png_charp buffer, png_const_charp
       buffer[iout] = '\0';
    }
 }
-#endif /* WARNINGS || ERROR_TEXT */
+#endif /* PNG_WARNINGS_SUPPORTED || PNG_ERROR_TEXT_SUPPORTED */
 
 #if defined(PNG_READ_SUPPORTED) && defined(PNG_ERROR_TEXT_SUPPORTED)
 PNG_FUNCTION(void,PNGAPI
-png_chunk_error,(png_const_structrp png_ptr, png_const_charp error_message),
+png_chunk_error,(png_structp png_ptr, png_const_charp error_message),
    PNG_NORETURN)
 {
    char msg[18+PNG_MAX_ERROR_TEXT];
@@ -490,11 +439,11 @@ png_chunk_error,(png_const_structrp png_ptr, png_const_charp error_message),
       png_error(png_ptr, msg);
    }
 }
-#endif /* READ && ERROR_TEXT */
+#endif /* PNG_READ_SUPPORTED && PNG_ERROR_TEXT_SUPPORTED */
 
 #ifdef PNG_WARNINGS_SUPPORTED
 void PNGAPI
-png_chunk_warning(png_const_structrp png_ptr, png_const_charp warning_message)
+png_chunk_warning(png_structp png_ptr, png_const_charp warning_message)
 {
    char msg[18+PNG_MAX_ERROR_TEXT];
    if (png_ptr == NULL)
@@ -506,89 +455,38 @@ png_chunk_warning(png_const_structrp png_ptr, png_const_charp warning_message)
       png_warning(png_ptr, msg);
    }
 }
-#endif /* WARNINGS */
+#endif /* PNG_WARNINGS_SUPPORTED */
 
 #ifdef PNG_READ_SUPPORTED
 #ifdef PNG_BENIGN_ERRORS_SUPPORTED
 void PNGAPI
-png_chunk_benign_error(png_const_structrp png_ptr, png_const_charp
-    error_message)
+png_chunk_benign_error(png_structp png_ptr, png_const_charp error_message)
 {
-   if ((png_ptr->flags & PNG_FLAG_BENIGN_ERRORS_WARN) != 0)
+   if (png_ptr->flags & PNG_FLAG_BENIGN_ERRORS_WARN)
       png_chunk_warning(png_ptr, error_message);
 
    else
       png_chunk_error(png_ptr, error_message);
-
-#  ifndef PNG_ERROR_TEXT_SUPPORTED
-      PNG_UNUSED(error_message)
-#  endif
 }
 #endif
-#endif /* READ */
-
-void /* PRIVATE */
-png_chunk_report(png_const_structrp png_ptr, png_const_charp message, int error)
-{
-#  ifndef PNG_WARNINGS_SUPPORTED
-      PNG_UNUSED(message)
-#  endif
-
-   /* This is always supported, but for just read or just write it
-    * unconditionally does the right thing.
-    */
-#  if defined(PNG_READ_SUPPORTED) && defined(PNG_WRITE_SUPPORTED)
-      if ((png_ptr->mode & PNG_IS_READ_STRUCT) != 0)
-#  endif
-
-#  ifdef PNG_READ_SUPPORTED
-      {
-         if (error < PNG_CHUNK_ERROR)
-            png_chunk_warning(png_ptr, message);
-
-         else
-            png_chunk_benign_error(png_ptr, message);
-      }
-#  endif
-
-#  if defined(PNG_READ_SUPPORTED) && defined(PNG_WRITE_SUPPORTED)
-      else if ((png_ptr->mode & PNG_IS_READ_STRUCT) == 0)
-#  endif
-
-#  ifdef PNG_WRITE_SUPPORTED
-      {
-         if (error < PNG_CHUNK_WRITE_ERROR)
-            png_app_warning(png_ptr, message);
-
-         else
-            png_app_error(png_ptr, message);
-      }
-#  endif
-}
+#endif /* PNG_READ_SUPPORTED */
 
 #ifdef PNG_ERROR_TEXT_SUPPORTED
-
-#if defined(PNG_FLOATING_POINT_SUPPORTED) && \
-   (defined(PNG_gAMA_SUPPORTED) || defined(PNG_cHRM_SUPPORTED) || \
-   defined(PNG_sCAL_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) || \
-   defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)) || \
-   (defined(PNG_FLOATING_ARITHMETIC_SUPPORTED) &&\
-   defined(PNG_sCAL_SUPPORTED))
+#ifdef PNG_FLOATING_POINT_SUPPORTED
 PNG_FUNCTION(void,
-png_fixed_error,(png_const_structrp png_ptr, png_const_charp name),PNG_NORETURN)
+png_fixed_error,(png_structp png_ptr, png_const_charp name),PNG_NORETURN)
 {
 #  define fixed_message "fixed point overflow in "
 #  define fixed_message_ln ((sizeof fixed_message)-1)
    int  iin;
    char msg[fixed_message_ln+PNG_MAX_ERROR_TEXT];
-   memcpy(msg, fixed_message, fixed_message_ln);
+   png_memcpy(msg, fixed_message, fixed_message_ln);
    iin = 0;
-   if (name != NULL)
-      while (iin < (PNG_MAX_ERROR_TEXT-1) && name[iin] != 0)
-      {
-         msg[fixed_message_ln + iin] = name[iin];
-         ++iin;
-      }
+   if (name != NULL) while (iin < (PNG_MAX_ERROR_TEXT-1) && name[iin] != 0)
+   {
+      msg[fixed_message_ln + iin] = name[iin];
+      ++iin;
+   }
    msg[fixed_message_ln + iin] = 0;
    png_error(png_ptr, msg);
 }
@@ -600,111 +498,14 @@ png_fixed_error,(png_const_structrp png_ptr, png_const_charp name),PNG_NORETURN)
  * otherwise it is necessary for png_default_error to be overridden.
  */
 jmp_buf* PNGAPI
-png_set_longjmp_fn(png_structrp png_ptr, png_longjmp_ptr longjmp_fn,
+png_set_longjmp_fn(png_structp png_ptr, png_longjmp_ptr longjmp_fn,
     size_t jmp_buf_size)
 {
-   /* From libpng 1.6.0 the app gets one chance to set a 'jmpbuf_size' value
-    * and it must not change after that.  Libpng doesn't care how big the
-    * buffer is, just that it doesn't change.
-    *
-    * If the buffer size is no *larger* than the size of jmp_buf when libpng is
-    * compiled a built in jmp_buf is returned; this preserves the pre-1.6.0
-    * semantics that this call will not fail.  If the size is larger, however,
-    * the buffer is allocated and this may fail, causing the function to return
-    * NULL.
-    */
-   if (png_ptr == NULL)
+   if (png_ptr == NULL || jmp_buf_size != png_sizeof(jmp_buf))
       return NULL;
 
-   if (png_ptr->jmp_buf_ptr == NULL)
-   {
-      png_ptr->jmp_buf_size = 0; /* not allocated */
-
-      if (jmp_buf_size <= (sizeof png_ptr->jmp_buf_local))
-         png_ptr->jmp_buf_ptr = &png_ptr->jmp_buf_local;
-
-      else
-      {
-         png_ptr->jmp_buf_ptr = png_voidcast(jmp_buf *,
-            png_malloc_warn(png_ptr, jmp_buf_size));
-
-         if (png_ptr->jmp_buf_ptr == NULL)
-            return NULL; /* new NULL return on OOM */
-
-         png_ptr->jmp_buf_size = jmp_buf_size;
-      }
-   }
-
-   else /* Already allocated: check the size */
-   {
-      size_t size = png_ptr->jmp_buf_size;
-
-      if (size == 0)
-      {
-         size = (sizeof png_ptr->jmp_buf_local);
-         if (png_ptr->jmp_buf_ptr != &png_ptr->jmp_buf_local)
-         {
-            /* This is an internal error in libpng: somehow we have been left
-             * with a stack allocated jmp_buf when the application regained
-             * control.  It's always possible to fix this up, but for the moment
-             * this is a png_error because that makes it easy to detect.
-             */
-            png_error(png_ptr, "Libpng jmp_buf still allocated");
-            /* png_ptr->jmp_buf_ptr = &png_ptr->jmp_buf_local; */
-         }
-      }
-
-      if (size != jmp_buf_size)
-      {
-         png_warning(png_ptr, "Application jmp_buf size changed");
-         return NULL; /* caller will probably crash: no choice here */
-      }
-   }
-
-   /* Finally fill in the function, now we have a satisfactory buffer. It is
-    * valid to change the function on every call.
-    */
    png_ptr->longjmp_fn = longjmp_fn;
-   return png_ptr->jmp_buf_ptr;
-}
-
-void /* PRIVATE */
-png_free_jmpbuf(png_structrp png_ptr)
-{
-   if (png_ptr != NULL)
-   {
-      jmp_buf *jb = png_ptr->jmp_buf_ptr;
-
-      /* A size of 0 is used to indicate a local, stack, allocation of the
-       * pointer; used here and in png.c
-       */
-      if (jb != NULL && png_ptr->jmp_buf_size > 0)
-      {
-
-         /* This stuff is so that a failure to free the error control structure
-          * does not leave libpng in a state with no valid error handling: the
-          * free always succeeds, if there is an error it gets ignored.
-          */
-         if (jb != &png_ptr->jmp_buf_local)
-         {
-            /* Make an internal, libpng, jmp_buf to return here */
-            jmp_buf free_jmp_buf;
-
-            if (!setjmp(free_jmp_buf))
-            {
-               png_ptr->jmp_buf_ptr = &free_jmp_buf; /* come back here */
-               png_ptr->jmp_buf_size = 0; /* stack allocation */
-               png_ptr->longjmp_fn = longjmp;
-               png_free(png_ptr, jb); /* Return to setjmp on error */
-            }
-         }
-      }
-
-      /* *Always* cancel everything out: */
-      png_ptr->jmp_buf_size = 0;
-      png_ptr->jmp_buf_ptr = NULL;
-      png_ptr->longjmp_fn = 0;
-   }
+   return &png_ptr->longjmp_buffer;
 }
 #endif
 
@@ -714,7 +515,7 @@ png_free_jmpbuf(png_structrp png_ptr)
  * error function pointer in png_set_error_fn().
  */
 static PNG_FUNCTION(void /* PRIVATE */,
-png_default_error,(png_const_structrp png_ptr, png_const_charp error_message),
+png_default_error,(png_structp png_ptr, png_const_charp error_message),
    PNG_NORETURN)
 {
 #ifdef PNG_CONSOLE_IO_SUPPORTED
@@ -761,28 +562,25 @@ png_default_error,(png_const_structrp png_ptr, png_const_charp error_message),
 }
 
 PNG_FUNCTION(void,PNGAPI
-png_longjmp,(png_const_structrp png_ptr, int val),PNG_NORETURN)
+png_longjmp,(png_structp png_ptr, int val),PNG_NORETURN)
 {
 #ifdef PNG_SETJMP_SUPPORTED
-   if (png_ptr != NULL && png_ptr->longjmp_fn != NULL &&
-       png_ptr->jmp_buf_ptr != NULL)
-      png_ptr->longjmp_fn(*png_ptr->jmp_buf_ptr, val);
-#else
-   PNG_UNUSED(png_ptr)
-   PNG_UNUSED(val)
-#endif
+   if (png_ptr && png_ptr->longjmp_fn)
+   {
+#  ifdef USE_FAR_KEYWORD
+      {
+         jmp_buf tmp_jmpbuf;
+         png_memcpy(tmp_jmpbuf, png_ptr->longjmp_buffer, png_sizeof(jmp_buf));
+         png_ptr->longjmp_fn(tmp_jmpbuf, val);
+      }
 
-   /* If control reaches this point, png_longjmp() must not return. The only
-    * choice is to terminate the whole process (or maybe the thread); to do
-    * this the ANSI-C abort() function is used unless a different method is 
-    * implemented by overriding the default configuration setting for
-    * PNG_ABORT (see scripts/pnglibconf.dfa).
-    *
-    * API change: prior to 1.7.0 PNG_ABORT was invoked as a function type macro
-    * with no arguments 'PNG_ABORT();', in 1.7.0 this is changed to a simple
-    * macro that is defined in the configuration.
-    */
-   PNG_ABORT
+#  else
+   png_ptr->longjmp_fn(png_ptr->longjmp_buffer, val);
+#  endif
+   }
+#endif
+   /* Here if not setjmp support or if png_ptr is null. */
+   PNG_ABORT();
 }
 
 #ifdef PNG_WARNINGS_SUPPORTED
@@ -792,7 +590,7 @@ png_longjmp,(png_const_structrp png_ptr, int val),PNG_NORETURN)
  * not used, but it is passed in case it may be useful.
  */
 static void /* PRIVATE */
-png_default_warning(png_const_structrp png_ptr, png_const_charp warning_message)
+png_default_warning(png_structp png_ptr, png_const_charp warning_message)
 {
 #ifdef PNG_CONSOLE_IO_SUPPORTED
 #  ifdef PNG_ERROR_NUMBERS_SUPPORTED
@@ -834,15 +632,15 @@ png_default_warning(png_const_structrp png_ptr, png_const_charp warning_message)
 #endif
    PNG_UNUSED(png_ptr) /* Make compiler happy */
 }
-#endif /* WARNINGS */
+#endif /* PNG_WARNINGS_SUPPORTED */
 
 /* This function is called when the application wants to use another method
  * of handling errors and warnings.  Note that the error function MUST NOT
  * return to the calling routine or serious problems will occur.  The return
- * method used in the default routine calls longjmp(png_ptr->jmp_buf_ptr, 1)
+ * method used in the default routine calls longjmp(png_ptr->longjmp_buffer, 1)
  */
 void PNGAPI
-png_set_error_fn(png_structrp png_ptr, png_voidp error_ptr,
+png_set_error_fn(png_structp png_ptr, png_voidp error_ptr,
     png_error_ptr error_fn, png_error_ptr warning_fn)
 {
    if (png_ptr == NULL)
@@ -863,7 +661,7 @@ png_set_error_fn(png_structrp png_ptr, png_voidp error_ptr,
  * pointer before png_write_destroy and png_read_destroy are called.
  */
 png_voidp PNGAPI
-png_get_error_ptr(png_const_structrp png_ptr)
+png_get_error_ptr(png_const_structp png_ptr)
 {
    if (png_ptr == NULL)
       return NULL;
@@ -874,7 +672,7 @@ png_get_error_ptr(png_const_structrp png_ptr)
 
 #ifdef PNG_ERROR_NUMBERS_SUPPORTED
 void PNGAPI
-png_set_strip_error_numbers(png_structrp png_ptr, png_uint_32 strip_mode)
+png_set_strip_error_numbers(png_structp png_ptr, png_uint_32 strip_mode)
 {
    if (png_ptr != NULL)
    {
@@ -884,90 +682,4 @@ png_set_strip_error_numbers(png_structrp png_ptr, png_uint_32 strip_mode)
    }
 }
 #endif
-
-#if defined(PNG_SIMPLIFIED_READ_SUPPORTED) ||\
-   defined(PNG_SIMPLIFIED_WRITE_SUPPORTED)
-   /* Currently the above both depend on SETJMP_SUPPORTED, however it would be
-    * possible to implement without setjmp support just so long as there is some
-    * way to handle the error return here:
-    */
-PNG_FUNCTION(void /* PRIVATE */, (PNGCBAPI
-png_safe_error),(png_structp png_nonconst_ptr, png_const_charp error_message),
-   PNG_NORETURN)
-{
-   const png_const_structrp png_ptr = png_nonconst_ptr;
-   png_imagep image = png_voidcast(png_imagep, png_ptr->error_ptr);
-
-   /* An error is always logged here, overwriting anything (typically a warning)
-    * that is already there:
-    */
-   if (image != NULL)
-   {
-      png_safecat(image->message, (sizeof image->message), 0, error_message);
-      image->warning_or_error |= PNG_IMAGE_ERROR;
-
-      /* Retrieve the jmp_buf from within the png_control, making this work for
-       * C++ compilation too is pretty tricky: C++ wants a pointer to the first
-       * element of a jmp_buf, but C doesn't tell us the type of that.
-       */
-      if (image->opaque != NULL && image->opaque->error_buf != NULL)
-         longjmp(png_control_jmp_buf(image->opaque), 1);
-
-      /* Missing longjmp buffer, the following is to help debugging: */
-      {
-         size_t pos = png_safecat(image->message, (sizeof image->message), 0,
-            "bad longjmp: ");
-         png_safecat(image->message, (sizeof image->message), pos,
-             error_message);
-      }
-   }
-
-   /* Here on an internal programming error. */
-   abort();
-}
-
-#ifdef PNG_WARNINGS_SUPPORTED
-void /* PRIVATE */ PNGCBAPI
-png_safe_warning(png_structp png_nonconst_ptr, png_const_charp warning_message)
-{
-   const png_const_structrp png_ptr = png_nonconst_ptr;
-   png_imagep image = png_voidcast(png_imagep, png_ptr->error_ptr);
-
-   /* A warning is only logged if there is no prior warning or error. */
-   if (image->warning_or_error == 0)
-   {
-      png_safecat(image->message, (sizeof image->message), 0, warning_message);
-      image->warning_or_error |= PNG_IMAGE_WARNING;
-   }
-}
-#endif
-
-int /* PRIVATE */
-png_safe_execute(png_imagep image_in, int (*function)(png_voidp), png_voidp arg)
-{
-   volatile png_imagep image = image_in;
-   volatile int result;
-   volatile png_voidp saved_error_buf;
-   jmp_buf safe_jmpbuf;
-
-   /* Safely execute function(arg) with png_error returning to this function. */
-   saved_error_buf = image->opaque->error_buf;
-   result = setjmp(safe_jmpbuf) == 0;
-
-   if (result != 0)
-   {
-
-      image->opaque->error_buf = safe_jmpbuf;
-      result = function(arg);
-   }
-
-   image->opaque->error_buf = saved_error_buf;
-
-   /* And do the cleanup prior to any failure return. */
-   if (result == 0)
-      png_image_free(image);
-
-   return result;
-}
-#endif /* SIMPLIFIED READ || SIMPLIFIED_WRITE */
-#endif /* READ || WRITE */
+#endif /* PNG_READ_SUPPORTED || PNG_WRITE_SUPPORTED */

pnginfo.h

@@ -1,11 +1,12 @@
 
 /* pnginfo.h - header file for PNG reference library
  *
- * Last changed in libpng 1.6.1 [March 28, 2013]
- * Copyright (c) 1998-2013 Glenn Randers-Pehrson
+ * Copyright (c) 1998-2011 Glenn Randers-Pehrson
  * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
  * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
  *
+ * Last changed in libpng 1.5.0 [January 6, 2011]
+ *
  * This code is released under the libpng license.
  * For conditions of distribution and use, see the disclaimer
  * and license in png.h
@@ -54,7 +55,7 @@
 
 struct png_info_def
 {
-   /* The following are necessary for every PNG file */
+   /* the following are necessary for every PNG file */
    png_uint_32 width;  /* width of image in pixels (from IHDR) */
    png_uint_32 height; /* height of image in pixels (from IHDR) */
    png_uint_32 valid;  /* valid chunk data (see PNG_INFO_ below) */
@@ -69,17 +70,11 @@ struct png_info_def
    png_byte filter_type;    /* must be PNG_FILTER_TYPE_BASE (from IHDR) */
    png_byte interlace_type; /* One of PNG_INTERLACE_NONE, PNG_INTERLACE_ADAM7 */
 
-   /* The following are set by png_set_IHDR, called from the application on
-    * write, but the are never actually used by the write code.
-    */
+   /* The following is informational only on read, and not used on writes. */
    png_byte channels;       /* number of data channels per pixel (1, 2, 3, 4) */
    png_byte pixel_depth;    /* number of bits per pixel */
    png_byte spare_byte;     /* to align the data, and for future use */
-
-#ifdef PNG_READ_SUPPORTED
-   /* This is never set during write */
    png_byte signature[8];   /* magic bytes read by libpng from start of file */
-#endif
 
    /* The rest of the data is optional.  If you are reading, check the
     * valid field to see if the information in these are valid.  If you
@@ -87,25 +82,18 @@ struct png_info_def
     * and initialize the appropriate fields below.
     */
 
-#if defined(PNG_COLORSPACE_SUPPORTED) || defined(PNG_GAMMA_SUPPORTED)
-   /* png_colorspace only contains 'flags' if neither GAMMA or COLORSPACE are
-    * defined.  When COLORSPACE is switched on all the colorspace-defining
-    * chunks should be enabled, when GAMMA is switched on all the gamma-defining
-    * chunks should be enabled.  If this is not done it becomes possible to read
-    * inconsistent PNG files and assign a probably incorrect interpretation to
-    * the information.  (In other words, by carefully choosing which chunks to
-    * recognize the system configuration can select an interpretation for PNG
-    * files containing ambiguous data and this will result in inconsistent
-    * behavior between different libpng builds!)
+#if defined(PNG_gAMA_SUPPORTED)
+   /* The gAMA chunk describes the gamma characteristics of the system
+    * on which the image was created, normally in the range [1.0, 2.5].
+    * Data is valid if (valid & PNG_INFO_gAMA) is non-zero.
     */
-   png_colorspace colorspace;
+   png_fixed_point gamma;
 #endif
 
-#ifdef PNG_iCCP_SUPPORTED
-   /* iCCP chunk data. */
-   png_charp iccp_name;     /* profile name */
-   png_bytep iccp_profile;  /* International Color Consortium profile data */
-   png_uint_32 iccp_proflen;  /* ICC profile data length */
+#ifdef PNG_sRGB_SUPPORTED
+    /* GR-P, 0.96a */
+    /* Data valid if (valid & PNG_INFO_sRGB) non-zero. */
+   png_byte srgb_intent; /* sRGB rendering intent [0, 1, 2, or 3] */
 #endif
 
 #ifdef PNG_TEXT_SUPPORTED
@@ -120,7 +108,7 @@ struct png_info_def
    int num_text; /* number of comments read or comments to write */
    int max_text; /* current size of text array */
    png_textp text; /* array of comments read or comments to write */
-#endif /* TEXT */
+#endif /* PNG_TEXT_SUPPORTED */
 
 #ifdef PNG_tIME_SUPPORTED
    /* The tIME chunk holds the last time the displayed image data was
@@ -195,6 +183,23 @@ defined(PNG_READ_BACKGROUND_SUPPORTED)
    png_uint_16p hist;
 #endif
 
+#ifdef PNG_cHRM_SUPPORTED
+   /* The cHRM chunk describes the CIE color characteristics of the monitor
+    * on which the PNG was created.  This data allows the viewer to do gamut
+    * mapping of the input image to ensure that the viewer sees the same
+    * colors in the image as the creator.  Values are in the range
+    * [0.0, 0.8].  Data valid if (valid & PNG_INFO_cHRM) non-zero.
+    */
+   png_fixed_point x_white;
+   png_fixed_point y_white;
+   png_fixed_point x_red;
+   png_fixed_point y_red;
+   png_fixed_point x_green;
+   png_fixed_point y_green;
+   png_fixed_point x_blue;
+   png_fixed_point y_blue;
+#endif
+
 #ifdef PNG_pCAL_SUPPORTED
    /* The pCAL chunk describes a transformation between the stored pixel
     * values and original physical data values used to create the image.
@@ -219,20 +224,25 @@ defined(PNG_READ_BACKGROUND_SUPPORTED)
 /* New members added in libpng-1.0.6 */
    png_uint_32 free_me;     /* flags items libpng is responsible for freeing */
 
-#ifdef PNG_STORE_UNKNOWN_CHUNKS_SUPPORTED
+#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED) || \
+ defined(PNG_HANDLE_AS_UNKNOWN_SUPPORTED)
    /* Storage for unknown chunks that the library doesn't recognize. */
    png_unknown_chunkp unknown_chunks;
+   int unknown_chunks_num;
+#endif
 
-   /* The type of this field is limited by the type of 
-    * png_struct::user_chunk_cache_max, else overflow can occur.
-    */
-   int                unknown_chunks_num;
+#ifdef PNG_iCCP_SUPPORTED
+   /* iCCP chunk data. */
+   png_charp iccp_name;     /* profile name */
+   png_bytep iccp_profile;  /* International Color Consortium profile data */
+   png_uint_32 iccp_proflen;  /* ICC profile data length */
+   png_byte iccp_compression; /* Always zero */
 #endif
 
 #ifdef PNG_sPLT_SUPPORTED
    /* Data on sPLT chunks (there may be more than one). */
    png_sPLT_tp splt_palettes;
-   int         splt_palettes_num; /* Match type returned by png_get API */
+   int splt_palettes_num;
 #endif
 
 #ifdef PNG_sCAL_SUPPORTED

pngmem.c

@@ -1,8 +1,8 @@
 
 /* pngmem.c - stub functions for memory allocation
  *
- * Last changed in libpng 1.7.0 [(PENDING RELEASE)]
- * Copyright (c) 1998-2015 Glenn Randers-Pehrson
+ * Last changed in libpng 1.5.13 [September 27, 2012]
+ * Copyright (c) 1998-2012 Glenn Randers-Pehrson
  * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
  * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
  *
@@ -20,23 +20,457 @@
 #include "pngpriv.h"
 
 #if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)
-/* Free a png_struct */
-void /* PRIVATE */
-png_destroy_png_struct(png_structrp png_ptr)
-{
-   if (png_ptr != NULL)
-   {
-      /* png_free might call png_error and may certainly call
-       * png_get_mem_ptr, so fake a temporary png_struct to support this.
-       */
-      png_struct dummy_struct = *png_ptr;
-      memset(png_ptr, 0, (sizeof *png_ptr));
-      png_free(&dummy_struct, png_ptr);
 
-#     ifdef PNG_SETJMP_SUPPORTED
-         /* We may have a jmp_buf left to deallocate. */
-         png_free_jmpbuf(&dummy_struct);
-#     endif
+/* Borland DOS special memory handler */
+#if defined(__TURBOC__) && !defined(_Windows) && !defined(__FLAT__)
+/* If you change this, be sure to change the one in png.h also */
+
+/* Allocate memory for a png_struct.  The malloc and memset can be replaced
+   by a single call to calloc() if this is thought to improve performance. */
+PNG_FUNCTION(png_voidp /* PRIVATE */,
+png_create_struct,(int type),PNG_ALLOCATED)
+{
+#  ifdef PNG_USER_MEM_SUPPORTED
+   return (png_create_struct_2(type, NULL, NULL));
+}
+
+/* Alternate version of png_create_struct, for use with user-defined malloc. */
+PNG_FUNCTION(png_voidp /* PRIVATE */,
+png_create_struct_2,(int type, png_malloc_ptr malloc_fn, png_voidp mem_ptr),
+   PNG_ALLOCATED)
+{
+#  endif /* PNG_USER_MEM_SUPPORTED */
+   png_size_t size;
+   png_voidp struct_ptr;
+
+   if (type == PNG_STRUCT_INFO)
+      size = png_sizeof(png_info);
+
+   else if (type == PNG_STRUCT_PNG)
+      size = png_sizeof(png_struct);
+
+   else
+      return (png_get_copyright(NULL));
+
+#  ifdef PNG_USER_MEM_SUPPORTED
+   if (malloc_fn != NULL)
+   {
+      png_struct dummy_struct;
+      png_memset(&dummy_struct, 0, sizeof dummy_struct);
+      dummy_struct.mem_ptr=mem_ptr;
+      struct_ptr = (*(malloc_fn))(&dummy_struct, (png_alloc_size_t)size);
+   }
+
+   else
+#  endif /* PNG_USER_MEM_SUPPORTED */
+   struct_ptr = (png_voidp)farmalloc(size);
+   if (struct_ptr != NULL)
+      png_memset(struct_ptr, 0, size);
+
+   return (struct_ptr);
+}
+
+/* Free memory allocated by a png_create_struct() call */
+void /* PRIVATE */
+png_destroy_struct(png_voidp struct_ptr)
+{
+#  ifdef PNG_USER_MEM_SUPPORTED
+   png_destroy_struct_2(struct_ptr, NULL, NULL);
+}
+
+/* Free memory allocated by a png_create_struct() call */
+void /* PRIVATE */
+png_destroy_struct_2(png_voidp struct_ptr, png_free_ptr free_fn,
+    png_voidp mem_ptr)
+{
+#  endif
+   if (struct_ptr != NULL)
+   {
+#  ifdef PNG_USER_MEM_SUPPORTED
+      if (free_fn != NULL)
+      {
+         png_struct dummy_struct;
+         png_memset(&dummy_struct, 0, sizeof dummy_struct);
+         dummy_struct.mem_ptr=mem_ptr;
+         (*(free_fn))(&dummy_struct, struct_ptr);
+         return;
+      }
+
+#  endif /* PNG_USER_MEM_SUPPORTED */
+      farfree (struct_ptr);
+   }
+}
+
+/* Allocate memory.  For reasonable files, size should never exceed
+ * 64K.  However, zlib may allocate more then 64K if you don't tell
+ * it not to.  See zconf.h and png.h for more information. zlib does
+ * need to allocate exactly 64K, so whatever you call here must
+ * have the ability to do that.
+ *
+ * Borland seems to have a problem in DOS mode for exactly 64K.
+ * It gives you a segment with an offset of 8 (perhaps to store its
+ * memory stuff).  zlib doesn't like this at all, so we have to
+ * detect and deal with it.  This code should not be needed in
+ * Windows or OS/2 modes, and only in 16 bit mode.  This code has
+ * been updated by Alexander Lehmann for version 0.89 to waste less
+ * memory.
+ *
+ * Note that we can't use png_size_t for the "size" declaration,
+ * since on some systems a png_size_t is a 16-bit quantity, and as a
+ * result, we would be truncating potentially larger memory requests
+ * (which should cause a fatal error) and introducing major problems.
+ */
+PNG_FUNCTION(png_voidp,PNGAPI
+png_calloc,(png_structp png_ptr, png_alloc_size_t size),PNG_ALLOCATED)
+{
+   png_voidp ret;
+
+   ret = (png_malloc(png_ptr, size));
+
+   if (ret != NULL)
+      png_memset(ret,0,(png_size_t)size);
+
+   return (ret);
+}
+
+PNG_FUNCTION(png_voidp,PNGAPI
+png_malloc,(png_structp png_ptr, png_alloc_size_t size),PNG_ALLOCATED)
+{
+   png_voidp ret;
+
+   if (png_ptr == NULL || size == 0)
+      return (NULL);
+
+#  ifdef PNG_USER_MEM_SUPPORTED
+   if (png_ptr->malloc_fn != NULL)
+      ret = ((png_voidp)(*(png_ptr->malloc_fn))(png_ptr, size));
+
+   else
+      ret = (png_malloc_default(png_ptr, size));
+
+   if (ret == NULL && (png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)
+       png_error(png_ptr, "Out of memory");
+
+   return (ret);
+}
+
+PNG_FUNCTION(png_voidp,PNGAPI
+png_malloc_default,(png_structp png_ptr, png_alloc_size_t size),PNG_ALLOCATED)
+{
+   png_voidp ret;
+#  endif /* PNG_USER_MEM_SUPPORTED */
+
+   if (png_ptr == NULL || size == 0)
+      return (NULL);
+
+#  ifdef PNG_MAX_MALLOC_64K
+   if (size > (png_uint_32)65536L)
+   {
+      png_warning(png_ptr, "Cannot Allocate > 64K");
+      ret = NULL;
+   }
+
+   else
+#  endif
+
+   if (size != (size_t)size)
+      ret = NULL;
+
+   else if (size == (png_uint_32)65536L)
+   {
+      if (png_ptr->offset_table == NULL)
+      {
+         /* Try to see if we need to do any of this fancy stuff */
+         ret = farmalloc(size);
+         if (ret == NULL || ((png_size_t)ret & 0xffff))
+         {
+            int num_blocks;
+            png_uint_32 total_size;
+            png_bytep table;
+            int i, mem_level, window_bits;
+            png_byte huge * hptr;
+            int window_bits
+
+            if (ret != NULL)
+            {
+               farfree(ret);
+               ret = NULL;
+            }
+
+            window_bits =
+                png_ptr->zlib_window_bits >= png_ptr->zlib_text_window_bits ?
+                png_ptr->zlib_window_bits : png_ptr->zlib_text_window_bits;
+
+            if (window_bits > 14)
+               num_blocks = (int)(1 << (window_bits - 14));
+
+            else
+               num_blocks = 1;
+
+            mem_level =
+                png_ptr->zlib_mem_level >= png_ptr->zlib_text_mem_level ?
+                png_ptr->zlib_mem_level : png_ptr->zlib_text_mem_level;
+
+            if (mem_level >= 7)
+               num_blocks += (int)(1 << (mem_level - 7));
+
+            else
+               num_blocks++;
+
+            total_size = ((png_uint_32)65536L) * (png_uint_32)num_blocks+16;
+
+            table = farmalloc(total_size);
+
+            if (table == NULL)
+            {
+#  ifndef PNG_USER_MEM_SUPPORTED
+               if ((png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)
+                  png_error(png_ptr, "Out Of Memory"); /* Note "O", "M" */
+
+               else
+                  png_warning(png_ptr, "Out Of Memory");
+#  endif
+               return (NULL);
+            }
+
+            if ((png_size_t)table & 0xfff0)
+            {
+#  ifndef PNG_USER_MEM_SUPPORTED
+               if ((png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)
+                  png_error(png_ptr,
+                    "Farmalloc didn't return normalized pointer");
+
+               else
+                  png_warning(png_ptr,
+                    "Farmalloc didn't return normalized pointer");
+#  endif
+               return (NULL);
+            }
+
+            png_ptr->offset_table = table;
+            png_ptr->offset_table_ptr = farmalloc(num_blocks *
+               png_sizeof(png_bytep));
+
+            if (png_ptr->offset_table_ptr == NULL)
+            {
+#  ifndef PNG_USER_MEM_SUPPORTED
+               if ((png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)
+                  png_error(png_ptr, "Out Of memory"); /* Note "O", "m" */
+
+               else
+                  png_warning(png_ptr, "Out Of memory");
+#  endif
+               return (NULL);
+            }
+
+            hptr = (png_byte huge *)table;
+            if ((png_size_t)hptr & 0xf)
+            {
+               hptr = (png_byte huge *)((long)(hptr) & 0xfffffff0L);
+               hptr = hptr + 16L;  /* "hptr += 16L" fails on Turbo C++ 3.0 */
+            }
+
+            for (i = 0; i < num_blocks; i++)
+            {
+               png_ptr->offset_table_ptr[i] = (png_bytep)hptr;
+               hptr = hptr + (png_uint_32)65536L;  /* "+=" fails on TC++3.0 */
+            }
+
+            png_ptr->offset_table_number = num_blocks;
+            png_ptr->offset_table_count = 0;
+            png_ptr->offset_table_count_free = 0;
+         }
+      }
+
+      if (png_ptr->offset_table_count >= png_ptr->offset_table_number)
+      {
+#  ifndef PNG_USER_MEM_SUPPORTED
+         if ((png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)
+            png_error(png_ptr, "Out of Memory"); /* Note "O" and "M" */
+
+         else
+            png_warning(png_ptr, "Out of Memory");
+#  endif
+         return (NULL);
+      }
+
+      ret = png_ptr->offset_table_ptr[png_ptr->offset_table_count++];
+   }
+
+   else
+      ret = farmalloc(size);
+
+#  ifndef PNG_USER_MEM_SUPPORTED
+   if (ret == NULL)
+   {
+      if ((png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)
+         png_error(png_ptr, "Out of memory"); /* Note "o" and "m" */
+
+      else
+         png_warning(png_ptr, "Out of memory"); /* Note "o" and "m" */
+   }
+#  endif
+
+   return (ret);
+}
+
+/* Free a pointer allocated by png_malloc().  In the default
+ * configuration, png_ptr is not used, but is passed in case it
+ * is needed.  If ptr is NULL, return without taking any action.
+ */
+void PNGAPI
+png_free(png_structp png_ptr, png_voidp ptr)
+{
+   if (png_ptr == NULL || ptr == NULL)
+      return;
+
+#  ifdef PNG_USER_MEM_SUPPORTED
+   if (png_ptr->free_fn != NULL)
+   {
+      (*(png_ptr->free_fn))(png_ptr, ptr);
+      return;
+   }
+
+   else
+      png_free_default(png_ptr, ptr);
+}
+
+void PNGAPI
+png_free_default(png_structp png_ptr, png_voidp ptr)
+{
+#  endif /* PNG_USER_MEM_SUPPORTED */
+
+   if (png_ptr == NULL || ptr == NULL)
+      return;
+
+   if (png_ptr->offset_table != NULL)
+   {
+      int i;
+
+      for (i = 0; i < png_ptr->offset_table_count; i++)
+      {
+         if (ptr == png_ptr->offset_table_ptr[i])
+         {
+            ptr = NULL;
+            png_ptr->offset_table_count_free++;
+            break;
+         }
+      }
+      if (png_ptr->offset_table_count_free == png_ptr->offset_table_count)
+      {
+         farfree(png_ptr->offset_table);
+         farfree(png_ptr->offset_table_ptr);
+         png_ptr->offset_table = NULL;
+         png_ptr->offset_table_ptr = NULL;
+      }
+   }
+
+   if (ptr != NULL)
+      farfree(ptr);
+}
+
+#else /* Not the Borland DOS special memory handler */
+
+/* Allocate memory for a png_struct or a png_info.  The malloc and
+   memset can be replaced by a single call to calloc() if this is thought
+   to improve performance noticably. */
+PNG_FUNCTION(png_voidp /* PRIVATE */,
+png_create_struct,(int type),PNG_ALLOCATED)
+{
+#  ifdef PNG_USER_MEM_SUPPORTED
+   return (png_create_struct_2(type, NULL, NULL));
+}
+
+/* Allocate memory for a png_struct or a png_info.  The malloc and
+   memset can be replaced by a single call to calloc() if this is thought
+   to improve performance noticably. */
+PNG_FUNCTION(png_voidp /* PRIVATE */,
+png_create_struct_2,(int type, png_malloc_ptr malloc_fn, png_voidp mem_ptr),
+   PNG_ALLOCATED)
+{
+#  endif /* PNG_USER_MEM_SUPPORTED */
+   png_size_t size;
+   png_voidp struct_ptr;
+
+   if (type == PNG_STRUCT_INFO)
+      size = png_sizeof(png_info);
+
+   else if (type == PNG_STRUCT_PNG)
+      size = png_sizeof(png_struct);
+
+   else
+      return (NULL);
+
+#  ifdef PNG_USER_MEM_SUPPORTED
+   if (malloc_fn != NULL)
+   {
+      png_struct dummy_struct;
+      png_structp png_ptr = &dummy_struct;
+      png_ptr->mem_ptr=mem_ptr;
+      struct_ptr = (*(malloc_fn))(png_ptr, size);
+
+      if (struct_ptr != NULL)
+         png_memset(struct_ptr, 0, size);
+
+      return (struct_ptr);
+   }
+#  endif /* PNG_USER_MEM_SUPPORTED */
+
+#  if defined(__TURBOC__) && !defined(__FLAT__)
+   struct_ptr = (png_voidp)farmalloc(size);
+#  else
+#    if defined(_MSC_VER) && defined(MAXSEG_64K)
+   struct_ptr = (png_voidp)halloc(size, 1);
+#    else
+   struct_ptr = (png_voidp)malloc(size);
+#    endif
+#  endif
+
+   if (struct_ptr != NULL)
+      png_memset(struct_ptr, 0, size);
+
+   return (struct_ptr);
+}
+
+
+/* Free memory allocated by a png_create_struct() call */
+void /* PRIVATE */
+png_destroy_struct(png_voidp struct_ptr)
+{
+#  ifdef PNG_USER_MEM_SUPPORTED
+   png_destroy_struct_2(struct_ptr, NULL, NULL);
+}
+
+/* Free memory allocated by a png_create_struct() call */
+void /* PRIVATE */
+png_destroy_struct_2(png_voidp struct_ptr, png_free_ptr free_fn,
+    png_voidp mem_ptr)
+{
+#  endif /* PNG_USER_MEM_SUPPORTED */
+   if (struct_ptr != NULL)
+   {
+#  ifdef PNG_USER_MEM_SUPPORTED
+      if (free_fn != NULL)
+      {
+         png_struct dummy_struct;
+         png_structp png_ptr = &dummy_struct;
+         png_ptr->mem_ptr=mem_ptr;
+         (*(free_fn))(png_ptr, struct_ptr);
+         return;
+      }
+#  endif /* PNG_USER_MEM_SUPPORTED */
+#  if defined(__TURBOC__) && !defined(__FLAT__)
+      farfree(struct_ptr);
+
+#  else
+#    if defined(_MSC_VER) && defined(MAXSEG_64K)
+      hfree(struct_ptr);
+
+#    else
+      free(struct_ptr);
+
+#    endif
+#  endif
    }
 }
 
@@ -46,195 +480,167 @@ png_destroy_png_struct(png_structrp png_ptr)
  * need to allocate exactly 64K, so whatever you call here must
  * have the ability to do that.
  */
+
 PNG_FUNCTION(png_voidp,PNGAPI
-png_calloc,(png_const_structrp png_ptr, png_alloc_size_t size),PNG_ALLOCATED)
+png_calloc,(png_structp png_ptr, png_alloc_size_t size),PNG_ALLOCATED)
 {
    png_voidp ret;
 
-   ret = png_malloc(png_ptr, size);
+   ret = (png_malloc(png_ptr, size));
 
    if (ret != NULL)
-      memset(ret, 0, size);
+      png_memset(ret,0,(png_size_t)size);
 
-   return ret;
+   return (ret);
 }
 
-/* png_malloc_base, an internal function added at libpng 1.6.0, does the work of
- * allocating memory, taking into account limits and PNG_USER_MEM_SUPPORTED.
- * Checking and error handling must happen outside this routine; it returns NULL
- * if the allocation cannot be done (for any reason.)
- */
-PNG_FUNCTION(png_voidp /* PRIVATE */,
-png_malloc_base,(png_const_structrp png_ptr, png_alloc_size_t size),
-   PNG_ALLOCATED)
-{
-   /* Moved to png_malloc_base from png_malloc_default in 1.6.0; the DOS
-    * allocators have also been removed in 1.6.0, so any 16-bit system now has
-    * to implement a user memory handler.  This checks to be sure it isn't
-    * called with big numbers.
-    */
-#ifndef PNG_USER_MEM_SUPPORTED
-   PNG_UNUSED(png_ptr)
-#endif
-
-   if (size > 0 && size <= PNG_SIZE_MAX
-#     ifdef PNG_MAX_MALLOC_64K
-         && size <= 65536U
-#     endif
-      )
-   {
-#ifdef PNG_USER_MEM_SUPPORTED
-      if (png_ptr != NULL && png_ptr->malloc_fn != NULL)
-         return png_ptr->malloc_fn(png_constcast(png_structrp,png_ptr), size);
-
-      else
-#endif
-         return malloc((size_t)size); /* checked for truncation above */
-   }
-
-   else
-      return NULL;
-}
-
-#if defined(PNG_TEXT_SUPPORTED) || defined(PNG_sPLT_SUPPORTED) ||\
-   defined(PNG_STORE_UNKNOWN_CHUNKS_SUPPORTED)
-/* This is really here only to work round a spurious warning in GCC 4.6 and 4.7
- * that arises because of the checks in png_realloc_array that are repeated in
- * png_malloc_array.
- */
-static png_voidp
-png_malloc_array_checked(png_const_structrp png_ptr, int nelements,
-   size_t element_size)
-{
-   png_alloc_size_t req = nelements; /* known to be > 0 */
-
-   if (req <= PNG_SIZE_MAX/element_size)
-      return png_malloc_base(png_ptr, req * element_size);
-
-   /* The failure case when the request is too large */
-   return NULL;
-}
-
-PNG_FUNCTION(png_voidp /* PRIVATE */,
-png_malloc_array,(png_const_structrp png_ptr, int nelements,
-   size_t element_size),PNG_ALLOCATED)
-{
-   if (nelements <= 0 || element_size == 0)
-      png_error(png_ptr, "internal error: array alloc");
-
-   return png_malloc_array_checked(png_ptr, nelements, element_size);
-}
-
-PNG_FUNCTION(png_voidp /* PRIVATE */,
-png_realloc_array,(png_structrp png_ptr, png_const_voidp old_array,
-   int old_elements, int add_elements, size_t element_size),PNG_ALLOCATED)
-{
-   /* These are internal errors: */
-   if (add_elements <= 0 || element_size == 0 || old_elements < 0 ||
-      (old_array == NULL && old_elements > 0))
-      png_error(png_ptr, "internal error: array realloc");
-
-   /* Check for overflow on the elements count (so the caller does not have to
-    * check.)
-    */
-   if (add_elements <= INT_MAX - old_elements)
-   {
-      png_voidp new_array = png_malloc_array_checked(png_ptr,
-         old_elements+add_elements, element_size);
-
-      if (new_array != NULL)
-      {
-         /* Because png_malloc_array worked the size calculations below cannot
-          * overflow.
-          */
-         if (old_elements > 0)
-            memcpy(new_array, old_array, element_size*(unsigned)old_elements);
-
-         memset((char*)new_array + element_size*(unsigned)old_elements, 0,
-            element_size*(unsigned)add_elements);
-
-         return new_array;
-      }
-   }
-
-#ifdef PNG_READ_SUPPORTED
-# ifdef PNG_USER_LIMITS_SUPPORTED
-   /* The potential overflow case.  Set the cache counter so libpng will
-    * not make any more attempts
-    */
-   png_ptr->user_chunk_cache_max = 2;
-# endif
-#endif
-
-   return NULL; /* error */
-}
-#endif /* TEXT || sPLT || STORE_UNKNOWN_CHUNKS */
-
-/* Various functions that have different error handling are derived from this.
- * png_malloc always exists, but if PNG_USER_MEM_SUPPORTED is defined a separate
- * function png_malloc_default is also provided.
- */
 PNG_FUNCTION(png_voidp,PNGAPI
-png_malloc,(png_const_structrp png_ptr, png_alloc_size_t size),PNG_ALLOCATED)
+png_malloc,(png_structp png_ptr, png_alloc_size_t size),PNG_ALLOCATED)
 {
    png_voidp ret;
 
-   if (png_ptr == NULL)
-      return NULL;
+#  ifdef PNG_USER_MEM_SUPPORTED
+   if (png_ptr == NULL || size == 0)
+      return (NULL);
 
-   ret = png_malloc_base(png_ptr, size);
+   if (png_ptr->malloc_fn != NULL)
+      ret = ((png_voidp)(*(png_ptr->malloc_fn))(png_ptr, (png_size_t)size));
 
-   if (ret == NULL)
-       png_error(png_ptr, "Out of memory");
+   else
+      ret = (png_malloc_default(png_ptr, size));
 
-   return ret;
+   if (ret == NULL && (png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)
+       png_error(png_ptr, "Out of Memory");
+
+   return (ret);
 }
 
-/* This function was added at libpng version 1.2.3.  The png_malloc_warn()
- * function will issue a png_warning and return NULL instead of issuing a
- * png_error, if it fails to allocate the requested memory.
- */
 PNG_FUNCTION(png_voidp,PNGAPI
-png_malloc_warn,(png_const_structrp png_ptr, png_alloc_size_t size),
-   PNG_ALLOCATED)
+png_malloc_default,(png_structp png_ptr, png_alloc_size_t size),PNG_ALLOCATED)
 {
-   if (png_ptr != NULL)
+   png_voidp ret;
+#  endif /* PNG_USER_MEM_SUPPORTED */
+
+   if (png_ptr == NULL || size == 0)
+      return (NULL);
+
+#  ifdef PNG_MAX_MALLOC_64K
+   if (size > (png_uint_32)65536L)
    {
-      png_voidp ret = png_malloc_base(png_ptr, size);
+#    ifndef PNG_USER_MEM_SUPPORTED
+      if ((png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)
+         png_error(png_ptr, "Cannot Allocate > 64K");
 
-      if (ret != NULL)
-         return ret;
-
-      png_warning(png_ptr, "Out of memory");
+      else
+#    endif
+         return NULL;
    }
+#  endif
 
-   return NULL;
+   /* Check for overflow */
+#  if defined(__TURBOC__) && !defined(__FLAT__)
+
+   if (size != (unsigned long)size)
+      ret = NULL;
+
+   else
+      ret = farmalloc(size);
+
+#  else
+#    if defined(_MSC_VER) && defined(MAXSEG_64K)
+   if (size != (unsigned long)size)
+      ret = NULL;
+
+   else
+      ret = halloc(size, 1);
+
+#    else
+   if (size != (size_t)size)
+      ret = NULL;
+
+   else
+      ret = malloc((size_t)size);
+#    endif
+#  endif
+
+#  ifndef PNG_USER_MEM_SUPPORTED
+   if (ret == NULL && (png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)
+      png_error(png_ptr, "Out of Memory");
+#  endif
+
+   return (ret);
 }
 
 /* Free a pointer allocated by png_malloc().  If ptr is NULL, return
  * without taking any action.
  */
 void PNGAPI
-png_free(png_const_structrp png_ptr, png_voidp ptr)
+png_free(png_structp png_ptr, png_voidp ptr)
 {
    if (png_ptr == NULL || ptr == NULL)
       return;
 
-#ifdef PNG_USER_MEM_SUPPORTED
+#  ifdef PNG_USER_MEM_SUPPORTED
    if (png_ptr->free_fn != NULL)
-      png_ptr->free_fn(png_constcast(png_structrp,png_ptr), ptr);
+   {
+      (*(png_ptr->free_fn))(png_ptr, ptr);
+      return;
+   }
 
    else
-#endif /* USER_MEM */
-      free(ptr);
+      png_free_default(png_ptr, ptr);
 }
 
+void PNGAPI
+png_free_default(png_structp png_ptr, png_voidp ptr)
+{
+   if (png_ptr == NULL || ptr == NULL)
+      return;
+
+#  endif /* PNG_USER_MEM_SUPPORTED */
+
+#  if defined(__TURBOC__) && !defined(__FLAT__)
+   farfree(ptr);
+
+#  else
+#    if defined(_MSC_VER) && defined(MAXSEG_64K)
+   hfree(ptr);
+
+#    else
+   free(ptr);
+
+#    endif
+#  endif
+}
+#endif /* Not Borland DOS special memory handler */
+
+/* This function was added at libpng version 1.2.3.  The png_malloc_warn()
+ * function will set up png_malloc() to issue a png_warning and return NULL
+ * instead of issuing a png_error, if it fails to allocate the requested
+ * memory.
+ */
+PNG_FUNCTION(png_voidp,PNGAPI
+png_malloc_warn,(png_structp png_ptr, png_alloc_size_t size),PNG_ALLOCATED)
+{
+   png_voidp ptr;
+   png_uint_32 save_flags;
+   if (png_ptr == NULL)
+      return (NULL);
+
+   save_flags = png_ptr->flags;
+   png_ptr->flags|=PNG_FLAG_MALLOC_NULL_MEM_OK;
+   ptr = (png_voidp)png_malloc((png_structp)png_ptr, size);
+   png_ptr->flags=save_flags;
+   return(ptr);
+}
+
+
 #ifdef PNG_USER_MEM_SUPPORTED
 /* This function is called when the application wants to use another method
  * of allocating and freeing memory.
  */
 void PNGAPI
-png_set_mem_fn(png_structrp png_ptr, png_voidp mem_ptr, png_malloc_ptr
+png_set_mem_fn(png_structp png_ptr, png_voidp mem_ptr, png_malloc_ptr
   malloc_fn, png_free_ptr free_fn)
 {
    if (png_ptr != NULL)
@@ -250,12 +656,12 @@ png_set_mem_fn(png_structrp png_ptr, png_voidp mem_ptr, png_malloc_ptr
  * pointer before png_write_destroy and png_read_destroy are called.
  */
 png_voidp PNGAPI
-png_get_mem_ptr(png_const_structrp png_ptr)
+png_get_mem_ptr(png_const_structp png_ptr)
 {
    if (png_ptr == NULL)
-      return NULL;
+      return (NULL);
 
-   return png_ptr->mem_ptr;
+   return ((png_voidp)png_ptr->mem_ptr);
 }
-#endif /* USER_MEM */
-#endif /* READ || WRITE */
+#endif /* PNG_USER_MEM_SUPPORTED */
+#endif /* PNG_READ_SUPPORTED || PNG_WRITE_SUPPORTED */

pngpread.c

@@ -1,8 +1,8 @@
 
 /* pngpread.c - read a png file in push mode
  *
- * Last changed in libpng 1.7.0 [(PENDING RELEASE)]
- * Copyright (c) 1998-2015 Glenn Randers-Pehrson
+ * Last changed in libpng 1.5.11 [June 14, 2012]
+ * Copyright (c) 1998-2012 Glenn Randers-Pehrson
  * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
  * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
  *
@@ -26,15 +26,8 @@
 #define PNG_READ_iTXt_MODE  7
 #define PNG_ERROR_MODE      8
 
-#define PNG_PUSH_SAVE_BUFFER_IF_FULL \
-if (png_ptr->push_length + 4 > png_ptr->buffer_size) \
-   { png_push_save_buffer(png_ptr); return; }
-#define PNG_PUSH_SAVE_BUFFER_IF_LT(N) \
-if (png_ptr->buffer_size < N) \
-   { png_push_save_buffer(png_ptr); return; }
-
 void PNGAPI
-png_process_data(png_structrp png_ptr, png_inforp info_ptr,
+png_process_data(png_structp png_ptr, png_infop info_ptr,
     png_bytep buffer, png_size_t buffer_size)
 {
    if (png_ptr == NULL || info_ptr == NULL)
@@ -49,14 +42,14 @@ png_process_data(png_structrp png_ptr, png_inforp info_ptr,
 }
 
 png_size_t PNGAPI
-png_process_data_pause(png_structrp png_ptr, int save)
+png_process_data_pause(png_structp png_ptr, int save)
 {
    if (png_ptr != NULL)
    {
-      /* It's easiest for the caller if we do the save; then the caller doesn't
+      /* It's easiest for the caller if we do the save, then the caller doesn't
        * have to supply the same data again:
        */
-      if (save != 0)
+      if (save)
          png_push_save_buffer(png_ptr);
       else
       {
@@ -76,7 +69,7 @@ png_process_data_pause(png_structrp png_ptr, int save)
 }
 
 png_uint_32 PNGAPI
-png_process_data_skip(png_structrp png_ptr)
+png_process_data_skip(png_structp png_ptr)
 {
    png_uint_32 remaining = 0;
 
@@ -110,7 +103,7 @@ png_process_data_skip(png_structrp png_ptr)
  * doing before we ran out of data...
  */
 void /* PRIVATE */
-png_process_some_data(png_structrp png_ptr, png_inforp info_ptr)
+png_process_some_data(png_structp png_ptr, png_infop info_ptr)
 {
    if (png_ptr == NULL)
       return;
@@ -156,10 +149,10 @@ png_process_some_data(png_structrp png_ptr, png_inforp info_ptr)
  * routine.
  */
 void /* PRIVATE */
-png_push_read_sig(png_structrp png_ptr, png_inforp info_ptr)
+png_push_read_sig(png_structp png_ptr, png_infop info_ptr)
 {
-   png_size_t num_checked = png_ptr->sig_bytes, /* SAFE, does not exceed 8 */ 
-             num_to_check = 8 - num_checked;
+   png_size_t num_checked = png_ptr->sig_bytes,
+       num_to_check = 8 - num_checked;
 
    if (png_ptr->buffer_size < num_to_check)
    {
@@ -179,6 +172,7 @@ png_push_read_sig(png_structrp png_ptr, png_inforp info_ptr)
       else
          png_error(png_ptr, "PNG file corrupted by ASCII conversion");
    }
+
    else
    {
       if (png_ptr->sig_bytes >= 8)
@@ -189,25 +183,27 @@ png_push_read_sig(png_structrp png_ptr, png_inforp info_ptr)
 }
 
 void /* PRIVATE */
-png_push_read_chunk(png_structrp png_ptr, png_inforp info_ptr)
+png_push_read_chunk(png_structp png_ptr, png_infop info_ptr)
 {
    png_uint_32 chunk_name;
-#ifdef PNG_SET_UNKNOWN_CHUNKS_SUPPORTED
-   int keep; /* unknown handling method */
-#endif
 
-   /* First we make sure we have enough data for the 4-byte chunk name
-    * and the 4-byte chunk length before proceeding with decoding the
+   /* First we make sure we have enough data for the 4 byte chunk name
+    * and the 4 byte chunk length before proceeding with decoding the
     * chunk data.  To fully decode each of these chunks, we also make
-    * sure we have enough data in the buffer for the 4-byte CRC at the
+    * sure we have enough data in the buffer for the 4 byte CRC at the
     * end of every chunk (except IDAT, which is handled separately).
     */
-   if ((png_ptr->mode & PNG_HAVE_CHUNK_HEADER) == 0)
+   if (!(png_ptr->mode & PNG_HAVE_CHUNK_HEADER))
    {
       png_byte chunk_length[4];
       png_byte chunk_tag[4];
 
-      PNG_PUSH_SAVE_BUFFER_IF_LT(8)
+      if (png_ptr->buffer_size < 8)
+      {
+         png_push_save_buffer(png_ptr);
+         return;
+      }
+
       png_push_fill_buffer(png_ptr, chunk_length, 4);
       png_ptr->push_length = png_get_uint_31(png_ptr, chunk_length);
       png_reset_crc(png_ptr);
@@ -221,29 +217,14 @@ png_push_read_chunk(png_structrp png_ptr, png_inforp info_ptr)
 
    if (chunk_name == png_IDAT)
    {
-      if ((png_ptr->mode & PNG_AFTER_IDAT) != 0)
-         png_ptr->mode |= PNG_HAVE_CHUNK_AFTER_IDAT;
-
-      /* If we reach an IDAT chunk, this means we have read all of the
-       * header chunks, and we can start reading the image (or if this
-       * is called after the image has been read - we have an error).
+      /* This is here above the if/else case statement below because if the
+       * unknown handling marks 'IDAT' as unknown then the IDAT handling case is
+       * completely skipped.
+       *
+       * TODO: there must be a better way of doing this.
        */
-      if ((png_ptr->mode & PNG_HAVE_IHDR) == 0)
-         png_error(png_ptr, "Missing IHDR before IDAT");
-
-      else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE &&
-          (png_ptr->mode & PNG_HAVE_PLTE) == 0)
-         png_error(png_ptr, "Missing PLTE before IDAT");
-
-      png_ptr->mode |= PNG_HAVE_IDAT;
-      png_ptr->process_mode = PNG_READ_IDAT_MODE;
-
-      if ((png_ptr->mode & PNG_HAVE_CHUNK_AFTER_IDAT) == 0)
-         if (png_ptr->push_length == 0)
-            return;
-
-      if ((png_ptr->mode & PNG_AFTER_IDAT) != 0)
-         png_benign_error(png_ptr, "Too many IDATs found[p]");
+      if (png_ptr->mode & PNG_AFTER_IDAT)
+         png_ptr->mode |= PNG_HAVE_CHUNK_AFTER_IDAT;
    }
 
    if (chunk_name == png_IHDR)
@@ -251,39 +232,94 @@ png_push_read_chunk(png_structrp png_ptr, png_inforp info_ptr)
       if (png_ptr->push_length != 13)
          png_error(png_ptr, "Invalid IHDR length");
 
-      PNG_PUSH_SAVE_BUFFER_IF_FULL
+      if (png_ptr->push_length + 4 > png_ptr->buffer_size)
+      {
+         png_push_save_buffer(png_ptr);
+         return;
+      }
+
       png_handle_IHDR(png_ptr, info_ptr, png_ptr->push_length);
    }
 
    else if (chunk_name == png_IEND)
    {
-      PNG_PUSH_SAVE_BUFFER_IF_FULL
+      if (png_ptr->push_length + 4 > png_ptr->buffer_size)
+      {
+         png_push_save_buffer(png_ptr);
+         return;
+      }
+
       png_handle_IEND(png_ptr, info_ptr, png_ptr->push_length);
 
       png_ptr->process_mode = PNG_READ_DONE_MODE;
       png_push_have_end(png_ptr, info_ptr);
    }
 
-#ifdef PNG_SET_UNKNOWN_CHUNKS_SUPPORTED
-   else if ((keep = png_chunk_unknown_handling(png_ptr, chunk_name)) != 0)
+#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED
+   else if (png_chunk_unknown_handling(png_ptr, chunk_name))
    {
-      PNG_PUSH_SAVE_BUFFER_IF_FULL
-      png_handle_unknown(png_ptr, info_ptr, png_ptr->push_length, keep);
+      if (png_ptr->push_length + 4 > png_ptr->buffer_size)
+      {
+         png_push_save_buffer(png_ptr);
+         return;
+      }
+
+      if (chunk_name == png_IDAT)
+         png_ptr->mode |= PNG_HAVE_IDAT;
+
+      png_handle_unknown(png_ptr, info_ptr, png_ptr->push_length);
 
       if (chunk_name == png_PLTE)
          png_ptr->mode |= PNG_HAVE_PLTE;
+
+      else if (chunk_name == png_IDAT)
+      {
+         if (!(png_ptr->mode & PNG_HAVE_IHDR))
+            png_error(png_ptr, "Missing IHDR before IDAT");
+
+         else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE &&
+             !(png_ptr->mode & PNG_HAVE_PLTE))
+            png_error(png_ptr, "Missing PLTE before IDAT");
+      }
    }
 #endif
 
    else if (chunk_name == png_PLTE)
    {
-      PNG_PUSH_SAVE_BUFFER_IF_FULL
+      if (png_ptr->push_length + 4 > png_ptr->buffer_size)
+      {
+         png_push_save_buffer(png_ptr);
+         return;
+      }
       png_handle_PLTE(png_ptr, info_ptr, png_ptr->push_length);
    }
 
    else if (chunk_name == png_IDAT)
    {
+      /* If we reach an IDAT chunk, this means we have read all of the
+       * header chunks, and we can start reading the image (or if this
+       * is called after the image has been read - we have an error).
+       */
+
+      if (!(png_ptr->mode & PNG_HAVE_IHDR))
+         png_error(png_ptr, "Missing IHDR before IDAT");
+
+      else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE &&
+          !(png_ptr->mode & PNG_HAVE_PLTE))
+         png_error(png_ptr, "Missing PLTE before IDAT");
+
+      if (png_ptr->mode & PNG_HAVE_IDAT)
+      {
+         if (!(png_ptr->mode & PNG_HAVE_CHUNK_AFTER_IDAT))
+            if (png_ptr->push_length == 0)
+               return;
+
+         if (png_ptr->mode & PNG_AFTER_IDAT)
+            png_benign_error(png_ptr, "Too many IDATs found");
+      }
+
       png_ptr->idat_size = png_ptr->push_length;
+      png_ptr->mode |= PNG_HAVE_IDAT;
       png_ptr->process_mode = PNG_READ_IDAT_MODE;
       png_push_have_info(png_ptr, info_ptr);
       png_ptr->zstream.avail_out =
@@ -296,7 +332,12 @@ png_push_read_chunk(png_structrp png_ptr, png_inforp info_ptr)
 #ifdef PNG_READ_gAMA_SUPPORTED
    else if (png_ptr->chunk_name == png_gAMA)
    {
-      PNG_PUSH_SAVE_BUFFER_IF_FULL
+      if (png_ptr->push_length + 4 > png_ptr->buffer_size)
+      {
+         png_push_save_buffer(png_ptr);
+         return;
+      }
+
       png_handle_gAMA(png_ptr, info_ptr, png_ptr->push_length);
    }
 
@@ -304,7 +345,12 @@ png_push_read_chunk(png_structrp png_ptr, png_inforp info_ptr)
 #ifdef PNG_READ_sBIT_SUPPORTED
    else if (png_ptr->chunk_name == png_sBIT)
    {
-      PNG_PUSH_SAVE_BUFFER_IF_FULL
+      if (png_ptr->push_length + 4 > png_ptr->buffer_size)
+      {
+         png_push_save_buffer(png_ptr);
+         return;
+      }
+
       png_handle_sBIT(png_ptr, info_ptr, png_ptr->push_length);
    }
 
@@ -312,7 +358,12 @@ png_push_read_chunk(png_structrp png_ptr, png_inforp info_ptr)
 #ifdef PNG_READ_cHRM_SUPPORTED
    else if (png_ptr->chunk_name == png_cHRM)
    {
-      PNG_PUSH_SAVE_BUFFER_IF_FULL
+      if (png_ptr->push_length + 4 > png_ptr->buffer_size)
+      {
+         png_push_save_buffer(png_ptr);
+         return;
+      }
+
       png_handle_cHRM(png_ptr, info_ptr, png_ptr->push_length);
    }
 
@@ -320,7 +371,12 @@ png_push_read_chunk(png_structrp png_ptr, png_inforp info_ptr)
 #ifdef PNG_READ_sRGB_SUPPORTED
    else if (chunk_name == png_sRGB)
    {
-      PNG_PUSH_SAVE_BUFFER_IF_FULL
+      if (png_ptr->push_length + 4 > png_ptr->buffer_size)
+      {
+         png_push_save_buffer(png_ptr);
+         return;
+      }
+
       png_handle_sRGB(png_ptr, info_ptr, png_ptr->push_length);
    }
 
@@ -328,7 +384,12 @@ png_push_read_chunk(png_structrp png_ptr, png_inforp info_ptr)
 #ifdef PNG_READ_iCCP_SUPPORTED
    else if (png_ptr->chunk_name == png_iCCP)
    {
-      PNG_PUSH_SAVE_BUFFER_IF_FULL
+      if (png_ptr->push_length + 4 > png_ptr->buffer_size)
+      {
+         png_push_save_buffer(png_ptr);
+         return;
+      }
+
       png_handle_iCCP(png_ptr, info_ptr, png_ptr->push_length);
    }
 
@@ -336,7 +397,12 @@ png_push_read_chunk(png_structrp png_ptr, png_inforp info_ptr)
 #ifdef PNG_READ_sPLT_SUPPORTED
    else if (chunk_name == png_sPLT)
    {
-      PNG_PUSH_SAVE_BUFFER_IF_FULL
+      if (png_ptr->push_length + 4 > png_ptr->buffer_size)
+      {
+         png_push_save_buffer(png_ptr);
+         return;
+      }
+
       png_handle_sPLT(png_ptr, info_ptr, png_ptr->push_length);
    }
 
@@ -344,7 +410,12 @@ png_push_read_chunk(png_structrp png_ptr, png_inforp info_ptr)
 #ifdef PNG_READ_tRNS_SUPPORTED
    else if (chunk_name == png_tRNS)
    {
-      PNG_PUSH_SAVE_BUFFER_IF_FULL
+      if (png_ptr->push_length + 4 > png_ptr->buffer_size)
+      {
+         png_push_save_buffer(png_ptr);
+         return;
+      }
+
       png_handle_tRNS(png_ptr, info_ptr, png_ptr->push_length);
    }
 
@@ -352,7 +423,12 @@ png_push_read_chunk(png_structrp png_ptr, png_inforp info_ptr)
 #ifdef PNG_READ_bKGD_SUPPORTED
    else if (chunk_name == png_bKGD)
    {
-      PNG_PUSH_SAVE_BUFFER_IF_FULL
+      if (png_ptr->push_length + 4 > png_ptr->buffer_size)
+      {
+         png_push_save_buffer(png_ptr);
+         return;
+      }
+
       png_handle_bKGD(png_ptr, info_ptr, png_ptr->push_length);
    }
 
@@ -360,7 +436,12 @@ png_push_read_chunk(png_structrp png_ptr, png_inforp info_ptr)
 #ifdef PNG_READ_hIST_SUPPORTED
    else if (chunk_name == png_hIST)
    {
-      PNG_PUSH_SAVE_BUFFER_IF_FULL
+      if (png_ptr->push_length + 4 > png_ptr->buffer_size)
+      {
+         png_push_save_buffer(png_ptr);
+         return;
+      }
+
       png_handle_hIST(png_ptr, info_ptr, png_ptr->push_length);
    }
 
@@ -368,7 +449,12 @@ png_push_read_chunk(png_structrp png_ptr, png_inforp info_ptr)
 #ifdef PNG_READ_pHYs_SUPPORTED
    else if (chunk_name == png_pHYs)
    {
-      PNG_PUSH_SAVE_BUFFER_IF_FULL
+      if (png_ptr->push_length + 4 > png_ptr->buffer_size)
+      {
+         png_push_save_buffer(png_ptr);
+         return;
+      }
+
       png_handle_pHYs(png_ptr, info_ptr, png_ptr->push_length);
    }
 
@@ -376,7 +462,12 @@ png_push_read_chunk(png_structrp png_ptr, png_inforp info_ptr)
 #ifdef PNG_READ_oFFs_SUPPORTED
    else if (chunk_name == png_oFFs)
    {
-      PNG_PUSH_SAVE_BUFFER_IF_FULL
+      if (png_ptr->push_length + 4 > png_ptr->buffer_size)
+      {
+         png_push_save_buffer(png_ptr);
+         return;
+      }
+
       png_handle_oFFs(png_ptr, info_ptr, png_ptr->push_length);
    }
 #endif
@@ -384,7 +475,12 @@ png_push_read_chunk(png_structrp png_ptr, png_inforp info_ptr)
 #ifdef PNG_READ_pCAL_SUPPORTED
    else if (chunk_name == png_pCAL)
    {
-      PNG_PUSH_SAVE_BUFFER_IF_FULL
+      if (png_ptr->push_length + 4 > png_ptr->buffer_size)
+      {
+         png_push_save_buffer(png_ptr);
+         return;
+      }
+
       png_handle_pCAL(png_ptr, info_ptr, png_ptr->push_length);
    }
 
@@ -392,7 +488,12 @@ png_push_read_chunk(png_structrp png_ptr, png_inforp info_ptr)
 #ifdef PNG_READ_sCAL_SUPPORTED
    else if (chunk_name == png_sCAL)
    {
-      PNG_PUSH_SAVE_BUFFER_IF_FULL
+      if (png_ptr->push_length + 4 > png_ptr->buffer_size)
+      {
+         png_push_save_buffer(png_ptr);
+         return;
+      }
+
       png_handle_sCAL(png_ptr, info_ptr, png_ptr->push_length);
    }
 
@@ -400,7 +501,12 @@ png_push_read_chunk(png_structrp png_ptr, png_inforp info_ptr)
 #ifdef PNG_READ_tIME_SUPPORTED
    else if (chunk_name == png_tIME)
    {
-      PNG_PUSH_SAVE_BUFFER_IF_FULL
+      if (png_ptr->push_length + 4 > png_ptr->buffer_size)
+      {
+         png_push_save_buffer(png_ptr);
+         return;
+      }
+
       png_handle_tIME(png_ptr, info_ptr, png_ptr->push_length);
    }
 
@@ -408,7 +514,12 @@ png_push_read_chunk(png_structrp png_ptr, png_inforp info_ptr)
 #ifdef PNG_READ_tEXt_SUPPORTED
    else if (chunk_name == png_tEXt)
    {
-      PNG_PUSH_SAVE_BUFFER_IF_FULL
+      if (png_ptr->push_length + 4 > png_ptr->buffer_size)
+      {
+         png_push_save_buffer(png_ptr);
+         return;
+      }
+
       png_handle_tEXt(png_ptr, info_ptr, png_ptr->push_length);
    }
 
@@ -416,7 +527,12 @@ png_push_read_chunk(png_structrp png_ptr, png_inforp info_ptr)
 #ifdef PNG_READ_zTXt_SUPPORTED
    else if (chunk_name == png_zTXt)
    {
-      PNG_PUSH_SAVE_BUFFER_IF_FULL
+      if (png_ptr->push_length + 4 > png_ptr->buffer_size)
+      {
+         png_push_save_buffer(png_ptr);
+         return;
+      }
+
       png_handle_zTXt(png_ptr, info_ptr, png_ptr->push_length);
    }
 
@@ -424,32 +540,41 @@ png_push_read_chunk(png_structrp png_ptr, png_inforp info_ptr)
 #ifdef PNG_READ_iTXt_SUPPORTED
    else if (chunk_name == png_iTXt)
    {
-      PNG_PUSH_SAVE_BUFFER_IF_FULL
+      if (png_ptr->push_length + 4 > png_ptr->buffer_size)
+      {
+         png_push_save_buffer(png_ptr);
+         return;
+      }
+
       png_handle_iTXt(png_ptr, info_ptr, png_ptr->push_length);
    }
+
 #endif
 
    else
    {
-      PNG_PUSH_SAVE_BUFFER_IF_FULL
-      png_handle_unknown(png_ptr, info_ptr, png_ptr->push_length,
-         PNG_HANDLE_CHUNK_AS_DEFAULT);
+      if (png_ptr->push_length + 4 > png_ptr->buffer_size)
+      {
+         png_push_save_buffer(png_ptr);
+         return;
+      }
+      png_handle_unknown(png_ptr, info_ptr, png_ptr->push_length);
    }
 
    png_ptr->mode &= ~PNG_HAVE_CHUNK_HEADER;
 }
 
 void /* PRIVATE */
-png_push_crc_skip(png_structrp png_ptr, png_uint_32 skip)
+png_push_crc_skip(png_structp png_ptr, png_uint_32 skip)
 {
    png_ptr->process_mode = PNG_SKIP_MODE;
    png_ptr->skip_length = skip;
 }
 
 void /* PRIVATE */
-png_push_crc_finish(png_structrp png_ptr)
+png_push_crc_finish(png_structp png_ptr)
 {
-   if (png_ptr->skip_length != 0 && png_ptr->save_buffer_size != 0)
+   if (png_ptr->skip_length && png_ptr->save_buffer_size)
    {
       png_size_t save_size = png_ptr->save_buffer_size;
       png_uint_32 skip_length = png_ptr->skip_length;
@@ -473,7 +598,8 @@ png_push_crc_finish(png_structrp png_ptr)
       png_ptr->save_buffer_size -= save_size;
       png_ptr->save_buffer_ptr += save_size;
    }
-   if (png_ptr->skip_length != 0 && png_ptr->current_buffer_size != 0)
+
+   if (png_ptr->skip_length && png_ptr->current_buffer_size)
    {
       png_size_t save_size = png_ptr->current_buffer_size;
       png_uint_32 skip_length = png_ptr->skip_length;
@@ -494,9 +620,15 @@ png_push_crc_finish(png_structrp png_ptr)
       png_ptr->current_buffer_size -= save_size;
       png_ptr->current_buffer_ptr += save_size;
    }
-   if (png_ptr->skip_length == 0)
+
+   if (!png_ptr->skip_length)
    {
-      PNG_PUSH_SAVE_BUFFER_IF_LT(4)
+      if (png_ptr->buffer_size < 4)
+      {
+         png_push_save_buffer(png_ptr);
+         return;
+      }
+
       png_crc_finish(png_ptr, 0);
       png_ptr->process_mode = PNG_READ_CHUNK_MODE;
    }
@@ -511,7 +643,8 @@ png_push_fill_buffer(png_structp png_ptr, png_bytep buffer, png_size_t length)
       return;
 
    ptr = buffer;
-   if (png_ptr->save_buffer_size != 0)
+
+   if (png_ptr->save_buffer_size)
    {
       png_size_t save_size;
 
@@ -521,14 +654,15 @@ png_push_fill_buffer(png_structp png_ptr, png_bytep buffer, png_size_t length)
       else
          save_size = png_ptr->save_buffer_size;
 
-      memcpy(ptr, png_ptr->save_buffer_ptr, save_size);
+      png_memcpy(ptr, png_ptr->save_buffer_ptr, save_size);
       length -= save_size;
       ptr += save_size;
       png_ptr->buffer_size -= save_size;
       png_ptr->save_buffer_size -= save_size;
       png_ptr->save_buffer_ptr += save_size;
    }
-   if (length != 0 && png_ptr->current_buffer_size != 0)
+
+   if (length && png_ptr->current_buffer_size)
    {
       png_size_t save_size;
 
@@ -538,7 +672,7 @@ png_push_fill_buffer(png_structp png_ptr, png_bytep buffer, png_size_t length)
       else
          save_size = png_ptr->current_buffer_size;
 
-      memcpy(ptr, png_ptr->current_buffer_ptr, save_size);
+      png_memcpy(ptr, png_ptr->current_buffer_ptr, save_size);
       png_ptr->buffer_size -= save_size;
       png_ptr->current_buffer_size -= save_size;
       png_ptr->current_buffer_ptr += save_size;
@@ -546,9 +680,9 @@ png_push_fill_buffer(png_structp png_ptr, png_bytep buffer, png_size_t length)
 }
 
 void /* PRIVATE */
-png_push_save_buffer(png_structrp png_ptr)
+png_push_save_buffer(png_structp png_ptr)
 {
-   if (png_ptr->save_buffer_size != 0)
+   if (png_ptr->save_buffer_size)
    {
       if (png_ptr->save_buffer_ptr != png_ptr->save_buffer)
       {
@@ -557,6 +691,7 @@ png_push_save_buffer(png_structrp png_ptr)
          png_bytep dp;
 
          istop = png_ptr->save_buffer_size;
+
          for (i = 0, sp = png_ptr->save_buffer_ptr, dp = png_ptr->save_buffer;
              i < istop; i++, sp++, dp++)
          {
@@ -564,6 +699,7 @@ png_push_save_buffer(png_structrp png_ptr)
          }
       }
    }
+
    if (png_ptr->save_buffer_size + png_ptr->current_buffer_size >
        png_ptr->save_buffer_max)
    {
@@ -578,34 +714,33 @@ png_push_save_buffer(png_structrp png_ptr)
 
       new_max = png_ptr->save_buffer_size + png_ptr->current_buffer_size + 256;
       old_buffer = png_ptr->save_buffer;
-      png_ptr->save_buffer = (png_bytep)png_malloc_warn(png_ptr,
-          (png_size_t)new_max);
+      png_ptr->save_buffer = (png_bytep)png_malloc_warn(png_ptr, new_max);
 
       if (png_ptr->save_buffer == NULL)
       {
          png_free(png_ptr, old_buffer);
-         old_buffer = NULL;
          png_error(png_ptr, "Insufficient memory for save_buffer");
       }
 
-      memcpy(png_ptr->save_buffer, old_buffer, png_ptr->save_buffer_size);
+      png_memcpy(png_ptr->save_buffer, old_buffer, png_ptr->save_buffer_size);
       png_free(png_ptr, old_buffer);
-      old_buffer = NULL;
       png_ptr->save_buffer_max = new_max;
    }
+
    if (png_ptr->current_buffer_size)
    {
-      memcpy(png_ptr->save_buffer + png_ptr->save_buffer_size,
+      png_memcpy(png_ptr->save_buffer + png_ptr->save_buffer_size,
          png_ptr->current_buffer_ptr, png_ptr->current_buffer_size);
       png_ptr->save_buffer_size += png_ptr->current_buffer_size;
       png_ptr->current_buffer_size = 0;
    }
+
    png_ptr->save_buffer_ptr = png_ptr->save_buffer;
    png_ptr->buffer_size = 0;
 }
 
 void /* PRIVATE */
-png_push_restore_buffer(png_structrp png_ptr, png_bytep buffer,
+png_push_restore_buffer(png_structp png_ptr, png_bytep buffer,
    png_size_t buffer_length)
 {
    png_ptr->current_buffer = buffer;
@@ -615,15 +750,20 @@ png_push_restore_buffer(png_structrp png_ptr, png_bytep buffer,
 }
 
 void /* PRIVATE */
-png_push_read_IDAT(png_structrp png_ptr)
+png_push_read_IDAT(png_structp png_ptr)
 {
-   if ((png_ptr->mode & PNG_HAVE_CHUNK_HEADER) == 0)
+   if (!(png_ptr->mode & PNG_HAVE_CHUNK_HEADER))
    {
       png_byte chunk_length[4];
       png_byte chunk_tag[4];
 
       /* TODO: this code can be commoned up with the same code in push_read */
-      PNG_PUSH_SAVE_BUFFER_IF_LT(8)
+      if (png_ptr->buffer_size < 8)
+      {
+         png_push_save_buffer(png_ptr);
+         return;
+      }
+
       png_push_fill_buffer(png_ptr, chunk_length, 4);
       png_ptr->push_length = png_get_uint_31(png_ptr, chunk_length);
       png_reset_crc(png_ptr);
@@ -635,7 +775,7 @@ png_push_read_IDAT(png_structrp png_ptr)
       {
          png_ptr->process_mode = PNG_READ_CHUNK_MODE;
 
-         if ((png_ptr->flags & PNG_FLAG_ZSTREAM_ENDED) == 0)
+         if (!(png_ptr->flags & PNG_FLAG_ZLIB_FINISHED))
             png_error(png_ptr, "Not enough compressed data");
 
          return;
@@ -644,7 +784,7 @@ png_push_read_IDAT(png_structrp png_ptr)
       png_ptr->idat_size = png_ptr->push_length;
    }
 
-   if (png_ptr->idat_size != 0 && png_ptr->save_buffer_size != 0)
+   if (png_ptr->idat_size && png_ptr->save_buffer_size)
    {
       png_size_t save_size = png_ptr->save_buffer_size;
       png_uint_32 idat_size = png_ptr->idat_size;
@@ -671,7 +811,7 @@ png_push_read_IDAT(png_structrp png_ptr)
       png_ptr->save_buffer_ptr += save_size;
    }
 
-   if (png_ptr->idat_size != 0 && png_ptr->current_buffer_size != 0)
+   if (png_ptr->idat_size && png_ptr->current_buffer_size)
    {
       png_size_t save_size = png_ptr->current_buffer_size;
       png_uint_32 idat_size = png_ptr->idat_size;
@@ -696,18 +836,23 @@ png_push_read_IDAT(png_structrp png_ptr)
       png_ptr->current_buffer_size -= save_size;
       png_ptr->current_buffer_ptr += save_size;
    }
-   if (png_ptr->idat_size == 0)
+
+   if (!png_ptr->idat_size)
    {
-      PNG_PUSH_SAVE_BUFFER_IF_LT(4)
+      if (png_ptr->buffer_size < 4)
+      {
+         png_push_save_buffer(png_ptr);
+         return;
+      }
+
       png_crc_finish(png_ptr, 0);
       png_ptr->mode &= ~PNG_HAVE_CHUNK_HEADER;
       png_ptr->mode |= PNG_AFTER_IDAT;
-      png_ptr->zowner = 0;
    }
 }
 
 void /* PRIVATE */
-png_process_IDAT_data(png_structrp png_ptr, png_bytep buffer,
+png_process_IDAT_data(png_structp png_ptr, png_bytep buffer,
    png_size_t buffer_length)
 {
    /* The caller checks for a non-zero buffer length. */
@@ -719,14 +864,13 @@ png_process_IDAT_data(png_structrp png_ptr, png_bytep buffer,
     * handle the uncompressed results.
     */
    png_ptr->zstream.next_in = buffer;
-   /* TODO: WARNING: TRUNCATION ERROR: DANGER WILL ROBINSON: */
    png_ptr->zstream.avail_in = (uInt)buffer_length;
 
    /* Keep going until the decompressed data is all processed
     * or the stream marked as finished.
     */
    while (png_ptr->zstream.avail_in > 0 &&
-      (png_ptr->flags & PNG_FLAG_ZSTREAM_ENDED) == 0)
+          !(png_ptr->flags & PNG_FLAG_ZLIB_FINISHED))
    {
       int ret;
 
@@ -737,9 +881,9 @@ png_process_IDAT_data(png_structrp png_ptr, png_bytep buffer,
        */
       if (!(png_ptr->zstream.avail_out > 0))
       {
-         /* TODO: WARNING: TRUNCATION ERROR: DANGER WILL ROBINSON: */
-         png_ptr->zstream.avail_out = (uInt)(PNG_ROWBYTES(png_ptr->pixel_depth,
-             png_ptr->iwidth) + 1);
+         png_ptr->zstream.avail_out =
+             (uInt) PNG_ROWBYTES(png_ptr->pixel_depth,
+             png_ptr->iwidth) + 1;
 
          png_ptr->zstream.next_out = png_ptr->row_buf;
       }
@@ -757,8 +901,7 @@ png_process_IDAT_data(png_structrp png_ptr, png_bytep buffer,
       if (ret != Z_OK && ret != Z_STREAM_END)
       {
          /* Terminate the decompression. */
-         png_ptr->flags |= PNG_FLAG_ZSTREAM_ENDED;
-         png_ptr->zowner = 0;
+         png_ptr->flags |= PNG_FLAG_ZLIB_FINISHED;
 
          /* This may be a truncated stream (missing or
           * damaged end code).  Treat that as a warning.
@@ -786,8 +929,7 @@ png_process_IDAT_data(png_structrp png_ptr, png_bytep buffer,
          {
             /* Extra data. */
             png_warning(png_ptr, "Extra compressed data in IDAT");
-            png_ptr->flags |= PNG_FLAG_ZSTREAM_ENDED;
-            png_ptr->zowner = 0;
+            png_ptr->flags |= PNG_FLAG_ZLIB_FINISHED;
 
             /* Do no more processing; skip the unprocessed
              * input check below.
@@ -802,7 +944,7 @@ png_process_IDAT_data(png_structrp png_ptr, png_bytep buffer,
 
       /* And check for the end of the stream. */
       if (ret == Z_STREAM_END)
-         png_ptr->flags |= PNG_FLAG_ZSTREAM_ENDED;
+         png_ptr->flags |= PNG_FLAG_ZLIB_FINISHED;
    }
 
    /* All the data should have been processed, if anything
@@ -814,7 +956,7 @@ png_process_IDAT_data(png_structrp png_ptr, png_bytep buffer,
 }
 
 void /* PRIVATE */
-png_push_process_row(png_structrp png_ptr)
+png_push_process_row(png_structp png_ptr)
 {
    /* 1.5.6: row_info moved out of png_struct to a local here. */
    png_row_info row_info;
@@ -840,10 +982,10 @@ png_push_process_row(png_structrp png_ptr)
     * it may not be in the future, so this was changed just to copy the
     * interlaced row count:
     */
-   memcpy(png_ptr->prev_row, png_ptr->row_buf, row_info.rowbytes + 1);
+   png_memcpy(png_ptr->prev_row, png_ptr->row_buf, row_info.rowbytes + 1);
 
 #ifdef PNG_READ_TRANSFORMS_SUPPORTED
-   if (png_ptr->transformations != 0)
+   if (png_ptr->transformations)
       png_do_read_transformations(png_ptr, &row_info);
 #endif
 
@@ -860,16 +1002,15 @@ png_push_process_row(png_structrp png_ptr)
 
 
 #ifdef PNG_READ_INTERLACING_SUPPORTED
-   /* Expand interlaced rows to full size */
-   if (png_ptr->interlaced != 0 &&
-       (png_ptr->transformations & PNG_INTERLACE) != 0)
+   /* Blow up interlaced rows to full size */
+   if (png_ptr->interlaced && (png_ptr->transformations & PNG_INTERLACE))
    {
       if (png_ptr->pass < 6)
          png_do_read_interlace(&row_info, png_ptr->row_buf + 1, png_ptr->pass,
             png_ptr->transformations);
 
-      switch (png_ptr->pass)
-      {
+    switch (png_ptr->pass)
+    {
          case 0:
          {
             int i;
@@ -1044,26 +1185,26 @@ png_push_process_row(png_structrp png_ptr)
 }
 
 void /* PRIVATE */
-png_read_push_finish_row(png_structrp png_ptr)
+png_read_push_finish_row(png_structp png_ptr)
 {
 #ifdef PNG_READ_INTERLACING_SUPPORTED
    /* Arrays to facilitate easy interlacing - use pass (0 - 6) as index */
 
    /* Start of interlace block */
-   static PNG_CONST png_byte png_pass_start[] = {0, 4, 0, 2, 0, 1, 0};
+   static PNG_CONST png_byte FARDATA png_pass_start[] = {0, 4, 0, 2, 0, 1, 0};
 
    /* Offset to next interlace block */
-   static PNG_CONST png_byte png_pass_inc[] = {8, 8, 4, 4, 2, 2, 1};
+   static PNG_CONST png_byte FARDATA png_pass_inc[] = {8, 8, 4, 4, 2, 2, 1};
 
    /* Start of interlace block in the y direction */
-   static PNG_CONST png_byte png_pass_ystart[] = {0, 0, 4, 0, 2, 0, 1};
+   static PNG_CONST png_byte FARDATA png_pass_ystart[] = {0, 0, 4, 0, 2, 0, 1};
 
    /* Offset to next interlace block in the y direction */
-   static PNG_CONST png_byte png_pass_yinc[] = {8, 8, 8, 4, 4, 2, 2};
+   static PNG_CONST png_byte FARDATA png_pass_yinc[] = {8, 8, 8, 4, 4, 2, 2};
 
    /* Height of interlace block.  This is not currently used - if you need
     * it, uncomment it here and in png.h
-   static PNG_CONST png_byte png_pass_height[] = {8, 8, 4, 4, 2, 2, 1};
+   static PNG_CONST png_byte FARDATA png_pass_height[] = {8, 8, 4, 4, 2, 2, 1};
    */
 #endif
 
@@ -1072,10 +1213,10 @@ png_read_push_finish_row(png_structrp png_ptr)
       return;
 
 #ifdef PNG_READ_INTERLACING_SUPPORTED
-   if (png_ptr->interlaced != 0)
+   if (png_ptr->interlaced)
    {
       png_ptr->row_number = 0;
-      memset(png_ptr->prev_row, 0, png_ptr->rowbytes + 1);
+      png_memset(png_ptr->prev_row, 0, png_ptr->rowbytes + 1);
 
       do
       {
@@ -1096,7 +1237,7 @@ png_read_push_finish_row(png_structrp png_ptr)
              png_pass_start[png_ptr->pass]) /
              png_pass_inc[png_ptr->pass];
 
-         if ((png_ptr->transformations & PNG_INTERLACE) != 0)
+         if (png_ptr->transformations & PNG_INTERLACE)
             break;
 
          png_ptr->num_rows = (png_ptr->height +
@@ -1106,25 +1247,25 @@ png_read_push_finish_row(png_structrp png_ptr)
 
       } while (png_ptr->iwidth == 0 || png_ptr->num_rows == 0);
    }
-#endif /* READ_INTERLACING */
+#endif /* PNG_READ_INTERLACING_SUPPORTED */
 }
 
 void /* PRIVATE */
-png_push_have_info(png_structrp png_ptr, png_inforp info_ptr)
+png_push_have_info(png_structp png_ptr, png_infop info_ptr)
 {
    if (png_ptr->info_fn != NULL)
       (*(png_ptr->info_fn))(png_ptr, info_ptr);
 }
 
 void /* PRIVATE */
-png_push_have_end(png_structrp png_ptr, png_inforp info_ptr)
+png_push_have_end(png_structp png_ptr, png_infop info_ptr)
 {
    if (png_ptr->end_fn != NULL)
       (*(png_ptr->end_fn))(png_ptr, info_ptr);
 }
 
 void /* PRIVATE */
-png_push_have_row(png_structrp png_ptr, png_bytep row)
+png_push_have_row(png_structp png_ptr, png_bytep row)
 {
    if (png_ptr->row_fn != NULL)
       (*(png_ptr->row_fn))(png_ptr, row, png_ptr->row_number,
@@ -1133,7 +1274,7 @@ png_push_have_row(png_structrp png_ptr, png_bytep row)
 
 #ifdef PNG_READ_INTERLACING_SUPPORTED
 void PNGAPI
-png_progressive_combine_row(png_const_structrp png_ptr, png_bytep old_row,
+png_progressive_combine_row (png_structp png_ptr, png_bytep old_row,
     png_const_bytep new_row)
 {
    if (png_ptr == NULL)
@@ -1144,12 +1285,12 @@ png_progressive_combine_row(png_const_structrp png_ptr, png_bytep old_row,
     * it must be png_ptr->row_buf+1
     */
    if (new_row != NULL)
-      png_combine_row(png_ptr, old_row, 1/*blocky display*/);
+      png_combine_row(png_ptr, old_row, 1/*display*/);
 }
-#endif /* READ_INTERLACING */
+#endif /* PNG_READ_INTERLACING_SUPPORTED */
 
 void PNGAPI
-png_set_progressive_read_fn(png_structrp png_ptr, png_voidp progressive_ptr,
+png_set_progressive_read_fn(png_structp png_ptr, png_voidp progressive_ptr,
     png_progressive_info_ptr info_fn, png_progressive_row_ptr row_fn,
     png_progressive_end_ptr end_fn)
 {
@@ -1164,11 +1305,11 @@ png_set_progressive_read_fn(png_structrp png_ptr, png_voidp progressive_ptr,
 }
 
 png_voidp PNGAPI
-png_get_progressive_ptr(png_const_structrp png_ptr)
+png_get_progressive_ptr(png_const_structp png_ptr)
 {
    if (png_ptr == NULL)
       return (NULL);
 
    return png_ptr->io_ptr;
 }
-#endif /* PROGRESSIVE_READ */
+#endif /* PNG_PROGRESSIVE_READ_SUPPORTED */

pngrio.c

@@ -1,8 +1,8 @@
 
 /* pngrio.c - functions for data input
  *
- * Last changed in libpng 1.6.17 [(PENDING RELEASE)]
- * Copyright (c) 1998-2015 Glenn Randers-Pehrson
+ * Last changed in libpng 1.5.0 [January 6, 2011]
+ * Copyright (c) 1998-2011 Glenn Randers-Pehrson
  * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
  * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
  *
@@ -29,7 +29,7 @@
  * to read more then 64K on a 16 bit machine.
  */
 void /* PRIVATE */
-png_read_data(png_structrp png_ptr, png_bytep data, png_size_t length)
+png_read_data(png_structp png_ptr, png_bytep data, png_size_t length)
 {
    png_debug1(4, "reading %d bytes", (int)length);
 
@@ -46,6 +46,7 @@ png_read_data(png_structrp png_ptr, png_bytep data, png_size_t length)
  * read_data function and use it at run time with png_set_read_fn(), rather
  * than changing the library.
  */
+#  ifndef USE_FAR_KEYWORD
 void PNGCBAPI
 png_default_read_data(png_structp png_ptr, png_bytep data, png_size_t length)
 {
@@ -57,11 +58,68 @@ png_default_read_data(png_structp png_ptr, png_bytep data, png_size_t length)
    /* fread() returns 0 on error, so it is OK to store this in a png_size_t
     * instead of an int, which is what fread() actually returns.
     */
-   check = fread(data, 1, length, png_voidcast(png_FILE_p, png_ptr->io_ptr));
+   check = fread(data, 1, length, (png_FILE_p)png_ptr->io_ptr);
 
    if (check != length)
       png_error(png_ptr, "Read Error");
 }
+#  else
+/* This is the model-independent version. Since the standard I/O library
+   can't handle far buffers in the medium and small models, we have to copy
+   the data.
+*/
+
+#define NEAR_BUF_SIZE 1024
+#define MIN(a,b) (a <= b ? a : b)
+
+static void PNGCBAPI
+png_default_read_data(png_structp png_ptr, png_bytep data, png_size_t length)
+{
+   png_size_t check;
+   png_byte *n_data;
+   png_FILE_p io_ptr;
+
+   if (png_ptr == NULL)
+      return;
+
+   /* Check if data really is near. If so, use usual code. */
+   n_data = (png_byte *)CVT_PTR_NOCHECK(data);
+   io_ptr = (png_FILE_p)CVT_PTR(png_ptr->io_ptr);
+
+   if ((png_bytep)n_data == data)
+   {
+      check = fread(n_data, 1, length, io_ptr);
+   }
+
+   else
+   {
+      png_byte buf[NEAR_BUF_SIZE];
+      png_size_t read, remaining, err;
+      check = 0;
+      remaining = length;
+
+      do
+      {
+         read = MIN(NEAR_BUF_SIZE, remaining);
+         err = fread(buf, 1, read, io_ptr);
+         png_memcpy(data, buf, read); /* copy far buffer to near buffer */
+
+         if (err != read)
+            break;
+
+         else
+            check += err;
+
+         data += read;
+         remaining -= read;
+      }
+      while (remaining != 0);
+   }
+
+   if ((png_uint_32)check != (png_uint_32)length)
+      png_error(png_ptr, "read Error");
+}
+#  endif
 #endif
 
 /* This function allows the application to supply a new input function
@@ -84,7 +142,7 @@ png_default_read_data(png_structp png_ptr, png_bytep data, png_size_t length)
  *                be used.
  */
 void PNGAPI
-png_set_read_fn(png_structrp png_ptr, png_voidp io_ptr,
+png_set_read_fn(png_structp png_ptr, png_voidp io_ptr,
    png_rw_ptr read_data_fn)
 {
    if (png_ptr == NULL)
@@ -102,7 +160,6 @@ png_set_read_fn(png_structrp png_ptr, png_voidp io_ptr,
    png_ptr->read_data_fn = read_data_fn;
 #endif
 
-#ifdef PNG_WRITE_SUPPORTED
    /* It is an error to write to a read device */
    if (png_ptr->write_data_fn != NULL)
    {
@@ -111,10 +168,9 @@ png_set_read_fn(png_structrp png_ptr, png_voidp io_ptr,
           "Can't set both read_data_fn and write_data_fn in the"
           " same structure");
    }
-#endif
 
 #ifdef PNG_WRITE_FLUSH_SUPPORTED
    png_ptr->output_flush_fn = NULL;
 #endif
 }
-#endif /* READ */
+#endif /* PNG_READ_SUPPORTED */