[master] Imported from libpng-1.2.41beta06.tar

everywhere except pngconf.h as in libpng-1.4.0beta78 and later.

ANNOUNCE

@@ -1,5 +1,5 @@
 
-Libpng 1.7.0beta25 - December 26, 2013
+Libpng 1.2.41beta06 - October 18, 2009
 
 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,469 +9,74 @@ Files available for download:
 Source files with LF line endings (for Unix/Linux) and with a
 "configure" script
 
-   1.7.0beta25.tar.xz (LZMA-compressed, recommended)
-   1.7.0beta25.tar.gz
+   libpng-1.2.41beta06.tar.xz (LZMA-compressed, recommended)
+   libpng-1.2.41beta06.tar.gz
+   libpng-1.2.41beta06.tar.bz2
+
+Source files with LF line endings (for Unix/Linux) without the
+"configure" script
+
+   libpng-1.2.41beta06-no-config.tar.xz (LZMA-compressed, recommended)
+   libpng-1.2.41beta06-no-config.tar.gz
+   libpng-1.2.41beta06-no-config.tar.bz2
 
 Source files with CRLF line endings (for Windows), without the
 "configure" script
 
-   lp170b25.7z  (LZMA-compressed, recommended)
-   lp170b25.zip
+   lp1241b06.zip
+   lp1241b06.7z
+   lp1241b06.tar.bz2
+
+Project files
+
+   libpng-1.2.41beta06-project-netware.zip
+   libpng-1.2.41beta06-project-wince.zip
 
 Other information:
 
-   1.7.0beta25-README.txt
-   1.7.0beta25-LICENSE.txt
-   Gnupg/*.asc (PGP armored detached signatures)
+   libpng-1.2.41beta06-README.txt
+   libpng-1.2.41beta06-KNOWNBUGS.txt
+   libpng-1.2.41beta06-LICENSE.txt
+   libpng-1.2.41beta06-Y2K-compliance.txt
+   libpng-1.2.41beta06-[previous version]-diff.txt
 
-Changes since the last public release (1.6.0):
+Changes since the last public release (1.2.40):
 
-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.2.41beta01 [September 25, 2009]
+  Moved redundant IHDR checking into new png_check_IHDR() in png.c
+    and report all errors found in the IHDR data.
+  Eliminated useless call to png_check_cHRM() from pngset.c
+  Expanded TAB characters in pngrtran.c
 
-Version 1.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.2.41beta02 [September 30, 2009]
+  Revised png_check_IHDR().
 
-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.2.41beta03 [October 1, 2009]
+  Revised png_check_IHDR() again, to check info_ptr members instead of
+    the contents of the returned parameters.
 
-Version 1.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.2.41beta04 [October 7, 2009]
+  Added "xcode" project similar one already in libpng-1.4.0beta (Alam Arias).
+  Ported some cosmetic changes from libpng-1.4.0beta86.
+  Eliminated a shadowed declaration of "pp" in png_handle_sPLT().
 
-Version 1.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.2.41beta05 [October 17, 2009]
+  Revised pngconf.h to make it easier to enable iTXt support.  From libpng
+    version 1.2.9 through 1.2.40, defining PNG_iTXt_SUPPORTED did not work
+    as expected.
+  Ported some cosmetic changes from libpng-1.4.0beta87, changing
+    many "#if defined(x)" to "#ifdef x".
 
-Version 1.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().
-
-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.
-  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.
-
-Version 1.7.0beta10 [April 24, 2013]
-  Attempt to fix the PNG_ARM_NEON configuration mess.
-
-Version 1.7.0beta11 [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.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
-  Updated contrib/pngminus/pnm2png.c (Paul Stewart):
-    Check for EOF
-    Ignore "#" delimited comments in input file to pnm2png.c.
-    Fixed whitespace handling
-    Added a call to png_set_packing()
-    Initialize dimension values so if sscanf fails at least we have known
-      invalid values.
-  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 masde 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.2.41beta06 [October 18, 2009]
+  Restored PNG_USE_LOCAL_ARRAYS code in pngread.c that was inadvertently
+    deleted in libpng-1.2.41beta05.
+  Converted all PNG_NO_* tests to PNG_*_SUPPORTED everywhere except pngconf.h
+    as in libpng-1.4.0beta78 and later.
 
 Send comments/corrections/commendations to png-mng-implement at lists.sf.net
+
 (subscription required; visit
 https://lists.sourceforge.net/lists/listinfo/png-mng-implement
-to subscribe)
-or to glennrp at users.sourceforge.net
+to subscribe) or to glennrp at users.sourceforge.net
 
 Glenn R-P

CMakeLists.txt

@@ -1,364 +0,0 @@
-# CMakeLists.txt
-
-# Copyright (C) 2007-2013 Glenn Randers-Pehrson
-
-# This code is released under the libpng license.
-# For conditions of distribution and use, see the disclaimer
-# and license in png.h
-
-cmake_minimum_required(VERSION 2.4.4)
-set(CMAKE_ALLOW_LOOSE_LOOP_CONSTRUCTS true)
-
-set(CMAKE_CONFIGURATION_TYPES "Release;Debug;MinSizeRel;RelWithDebInfo")
-
-project(libpng C)
-enable_testing()
-
-set(PNGLIB_MAJOR 1)
-set(PNGLIB_MINOR 7)
-set(PNGLIB_RELEASE 0)
-set(PNGLIB_NAME libpng${PNGLIB_MAJOR}${PNGLIB_MINOR})
-set(PNGLIB_VERSION ${PNGLIB_MAJOR}.${PNGLIB_MINOR}.${PNGLIB_RELEASE})
-
-# needed packages
-find_package(ZLIB REQUIRED)
-include_directories(${ZLIB_INCLUDE_DIR})
-
-if(NOT WIN32)
-  find_library(M_LIBRARY
-    NAMES m
-    PATHS /usr/lib /usr/local/lib
-  )
-  if(NOT M_LIBRARY)
-    message(STATUS
-      "math library 'libm' not found - floating point support disabled")
-  endif()
-else()
-  # not needed on windows
-  set(M_LIBRARY "")
-endif()
-
-# COMMAND LINE OPTIONS
-if(DEFINED PNG_SHARED)
-  option(PNG_SHARED "Build shared lib" ${PNG_SHARED})
-else()
-  option(PNG_SHARED "Build shared lib" ON)
-endif()
-if(DEFINED PNG_STATIC)
-  option(PNG_STATIC "Build static lib" ${PNG_STATIC})
-else()
-  option(PNG_STATIC "Build static lib" ON)
-endif()
-
-option(PNG_TESTS  "Build libpng tests" YES)
-
-# Many more configuration options could be added here
-option(PNG_DEBUG         "Build with debug output" NO)
-option(PNGARG            "Disable ANSI-C prototypes" NO)
-
-# SET LIBNAME
-set(PNG_LIB_NAME png${PNGLIB_MAJOR}${PNGLIB_MINOR})
-
-# to distinguish between debug and release lib
-set(CMAKE_DEBUG_POSTFIX "d")
-
-# Use the prebuilt pnglibconf.h file from the scripts folder
-# TODO: fix this by building with awk; without this no cmake build can be
-# configured directly (to do so indirectly use your local awk to build a
-# pnglibconf.h in the build directory.)
-configure_file(${CMAKE_CURRENT_SOURCE_DIR}/scripts/pnglibconf.h.prebuilt
-               ${CMAKE_CURRENT_BINARY_DIR}/pnglibconf.h)
-include_directories(${CMAKE_CURRENT_BINARY_DIR})
-
-# OUR SOURCES
-set(libpng_public_hdrs
-  png.h
-  pngconf.h
-  ${CMAKE_CURRENT_BINARY_DIR}/pnglibconf.h
-)
-set(libpng_sources
-  ${libpng_public_hdrs}
-  pngdebug.h
-  pnginfo.h
-  pngpriv.h
-  pngstruct.h
-  png.c
-  pngerror.c
-  pngget.c
-  pngmem.c
-  pngpread.c
-  pngread.c
-  pngrio.c
-  pngrtran.c
-  pngrutil.c
-  pngset.c
-  pngtrans.c
-  pngwio.c
-  pngwrite.c
-  pngwtran.c
-  pngwutil.c
-)
-set(pngtest_sources
-  pngtest.c
-)
-set(pngvalid_sources
-  contrib/libtests/pngvalid.c
-)
-set(pngstest_sources
-  contrib/libtests/pngstest.c
-)
-# SOME NEEDED DEFINITIONS
-
-if(MSVC)
-  add_definitions(-D_CRT_SECURE_NO_DEPRECATE)
-endif(MSVC)
-
-if(PNG_DEBUG)
-  add_definitions(-DPNG_DEBUG)
-endif()
-
-# NOW BUILD OUR TARGET
-include_directories(${CMAKE_CURRENT_SOURCE_DIR} ${ZLIB_INCLUDE_DIR})
-
-unset(PNG_LIB_TARGETS)
-
-if(PNG_SHARED)
-  add_library(${PNG_LIB_NAME} SHARED ${libpng_sources})
-  set(PNG_LIB_TARGETS ${PNG_LIB_NAME})
-  if(MSVC)
-    # msvc does not append 'lib' - do it here to have consistent name
-    set_target_properties(${PNG_LIB_NAME} PROPERTIES PREFIX "lib")
-    set_target_properties(${PNG_LIB_NAME} PROPERTIES IMPORT_PREFIX "lib")
-  endif()
-  target_link_libraries(${PNG_LIB_NAME} ${ZLIB_LIBRARY} ${M_LIBRARY})
-endif()
-
-if(PNG_STATIC)
-# does not work without changing name
-  set(PNG_LIB_NAME_STATIC ${PNG_LIB_NAME}_static)
-  add_library(${PNG_LIB_NAME_STATIC} STATIC ${libpng_sources})
-  list(APPEND PNG_LIB_TARGETS ${PNG_LIB_NAME_STATIC})
-  if(MSVC)
-    # msvc does not append 'lib' - do it here to have consistent name
-    set_target_properties(${PNG_LIB_NAME_STATIC} PROPERTIES PREFIX "lib")
-  endif()
-  target_link_libraries(${PNG_LIB_NAME_STATIC} ${ZLIB_LIBRARY} ${M_LIBRARY})
-endif()
-
-if(NOT PNG_LIB_TARGETS)
-  message(SEND_ERROR
-    "No library variant selected to build. "
-    "Please enable at least one of the following options: PNG_STATIC, PNG_SHARED")
-endif()
-
-if(PNG_SHARED AND WIN32)
-  set_target_properties(${PNG_LIB_NAME} PROPERTIES DEFINE_SYMBOL PNG_BUILD_DLL)
-endif()
-
-if(PNG_TESTS AND PNG_SHARED)
-  # does not work with msvc due to png_lib_ver issue
-  add_executable(pngtest ${pngtest_sources})
-  target_link_libraries(pngtest ${PNG_LIB_NAME})
-  add_test(pngtest ./pngtest ${CMAKE_CURRENT_SOURCE_DIR}/pngtest.png)
-  #
-  add_executable(pngvalid ${pngvalid_sources})
-  target_link_libraries(pngvalid ${PNG_LIB_NAME})
-  add_test(pngvalid ./pngvalid)
-  add_executable(pngstest ${pngstest_sources})
-  target_link_libraries(pngstest ${PNG_LIB_NAME})
-  add_test(pngstest ./pngstest
-    ${CMAKE_CURRENT_SOURCE_DIR}/contrib/pngsuite/basn0g01.png
-    ${CMAKE_CURRENT_SOURCE_DIR}/contrib/pngsuite/basn0g02.png
-    ${CMAKE_CURRENT_SOURCE_DIR}/contrib/pngsuite/basn0g04.png
-    ${CMAKE_CURRENT_SOURCE_DIR}/contrib/pngsuite/basn0g08.png
-    ${CMAKE_CURRENT_SOURCE_DIR}/contrib/pngsuite/basn0g16.png
-    ${CMAKE_CURRENT_SOURCE_DIR}/contrib/pngsuite/basn2c08.png
-    ${CMAKE_CURRENT_SOURCE_DIR}/contrib/pngsuite/basn2c16.png
-    ${CMAKE_CURRENT_SOURCE_DIR}/contrib/pngsuite/basn3p01.png
-    ${CMAKE_CURRENT_SOURCE_DIR}/contrib/pngsuite/basn3p02.png
-    ${CMAKE_CURRENT_SOURCE_DIR}/contrib/pngsuite/basn3p04.png
-    ${CMAKE_CURRENT_SOURCE_DIR}/contrib/pngsuite/basn3p08.png
-    ${CMAKE_CURRENT_SOURCE_DIR}/contrib/pngsuite/basn4a08.png
-    ${CMAKE_CURRENT_SOURCE_DIR}/contrib/pngsuite/basn4a16.png
-    ${CMAKE_CURRENT_SOURCE_DIR}/contrib/pngsuite/basn6a08.png
-    ${CMAKE_CURRENT_SOURCE_DIR}/contrib/pngsuite/basn6a16.png
-    ${CMAKE_CURRENT_SOURCE_DIR}/contrib/pngsuite/ftbbn0g01.png
-    ${CMAKE_CURRENT_SOURCE_DIR}/contrib/pngsuite/ftbbn0g02.png
-    ${CMAKE_CURRENT_SOURCE_DIR}/contrib/pngsuite/ftbbn0g04.png
-    ${CMAKE_CURRENT_SOURCE_DIR}/contrib/pngsuite/ftbbn2c16.png
-    ${CMAKE_CURRENT_SOURCE_DIR}/contrib/pngsuite/ftbbn3p08.png
-    ${CMAKE_CURRENT_SOURCE_DIR}/contrib/pngsuite/ftbgn2c16.png
-    ${CMAKE_CURRENT_SOURCE_DIR}/contrib/pngsuite/ftbgn3p08.png
-    ${CMAKE_CURRENT_SOURCE_DIR}/contrib/pngsuite/ftbrn2c08.png
-    ${CMAKE_CURRENT_SOURCE_DIR}/contrib/pngsuite/ftbwn0g16.png
-    ${CMAKE_CURRENT_SOURCE_DIR}/contrib/pngsuite/ftbwn3p08.png
-    ${CMAKE_CURRENT_SOURCE_DIR}/contrib/pngsuite/ftbyn3p08.png
-    ${CMAKE_CURRENT_SOURCE_DIR}/contrib/pngsuite/ftp0n0g08.png
-    ${CMAKE_CURRENT_SOURCE_DIR}/contrib/pngsuite/ftp0n2c08.png
-    ${CMAKE_CURRENT_SOURCE_DIR}/contrib/pngsuite/ftp0n3p08.png
-    ${CMAKE_CURRENT_SOURCE_DIR}/contrib/pngsuite/ftp1n3p08.png
-  )
-endif()
-
-# Ensure the CMAKE_LIBRARY_OUTPUT_DIRECTORY is set
-IF(NOT CMAKE_LIBRARY_OUTPUT_DIRECTORY)
-  SET(CMAKE_LIBRARY_OUTPUT_DIRECTORY "lib")
-ENDIF(NOT CMAKE_LIBRARY_OUTPUT_DIRECTORY)
-
-# Set a variable with CMake code which:
-# Creates a symlink from src to dest (if possible) or alternatively
-# copies if different.
-macro(CREATE_SYMLINK SRC_FILE DEST_FILE)
-  FILE(REMOVE ${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/${DEST_FILE})
-  if(WIN32 AND NOT CYGWIN AND NOT MSYS)
-    ADD_CUSTOM_COMMAND(
-        OUTPUT ${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/${DEST_FILE}   ${CMAKE_CURRENT_BINARY_DIR}/${DEST_FILE}
-        COMMAND ${CMAKE_COMMAND} -E copy_if_different  "${SRC_FILE}" ${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/${DEST_FILE}
-        COMMAND ${CMAKE_COMMAND} -E copy_if_different  "${SRC_FILE}" ${CMAKE_CURRENT_BINARY_DIR}/${DEST_FILE}
-        DEPENDS ${PNG_LIB_TARGETS}
-        )
-    ADD_CUSTOM_TARGET(${DEST_FILE}_COPY ALL DEPENDS ${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/${DEST_FILE})
-  else(WIN32 AND NOT CYGWIN AND NOT MSYS)
-    get_filename_component(LINK_TARGET "${SRC_FILE}" NAME)
-    execute_process(COMMAND ${CMAKE_COMMAND} -E create_symlink "${LINK_TARGET}" ${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/${DEST_FILE} WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
-    execute_process(COMMAND ${CMAKE_COMMAND} -E create_symlink "${LINK_TARGET}" ${DEST_FILE} WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
-  endif(WIN32 AND NOT CYGWIN AND NOT MSYS)
-endmacro()
-
-# libpng is a library so default to 'lib'
-if(NOT DEFINED CMAKE_INSTALL_LIBDIR)
-  set(CMAKE_INSTALL_LIBDIR lib)
-endif(NOT DEFINED CMAKE_INSTALL_LIBDIR)
-
-# CREATE PKGCONFIG FILES
-# we use the same files like ./configure, so we have to set its vars
-# Only do this on Windows for Cygwin - the files don't make much sense outside
-# a UNIX look alike
-if(NOT WIN32 OR CYGWIN OR MINGW)
-  set(prefix      ${CMAKE_INSTALL_PREFIX})
-  set(exec_prefix ${CMAKE_INSTALL_PREFIX})
-  set(libdir      ${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_LIBDIR})
-  set(includedir  ${CMAKE_INSTALL_PREFIX}/include)
-  set(LIBS        "-lz -lm")
-  configure_file(${CMAKE_CURRENT_SOURCE_DIR}/libpng.pc.in
-    ${CMAKE_CURRENT_BINARY_DIR}/${PNGLIB_NAME}.pc @ONLY)
-  CREATE_SYMLINK(${PNGLIB_NAME}.pc libpng.pc)
-
-  configure_file(${CMAKE_CURRENT_SOURCE_DIR}/libpng-config.in
-    ${CMAKE_CURRENT_BINARY_DIR}/${PNGLIB_NAME}-config @ONLY)
-  CREATE_SYMLINK(${PNGLIB_NAME}-config libpng-config)
-endif(NOT WIN32 OR CYGWIN OR MINGW)
-
-# SET UP LINKS
-if(PNG_SHARED)
-  set_target_properties(${PNG_LIB_NAME} PROPERTIES
-#   VERSION 17.${PNGLIB_RELEASE}.1.7.0beta25
-    VERSION 17.${PNGLIB_RELEASE}.0
-    SOVERSION 17
-    CLEAN_DIRECT_OUTPUT 1)
-endif()
-if(PNG_STATIC)
-  # MSVC doesn't use a different file extension for shared vs. static
-  # libs.  We are able to change OUTPUT_NAME to remove the _static
-  # for all other platforms.
-  if(NOT MSVC)
-    set_target_properties(${PNG_LIB_NAME_STATIC} PROPERTIES
-      OUTPUT_NAME ${PNG_LIB_NAME}
-      CLEAN_DIRECT_OUTPUT 1)
-  endif()
-endif()
-
-# If CMake > 2.4.x, we set a variable used below to export
-# targets to an export file.
-# TODO: Use VERSION_GREATER after our cmake_minimum_required >= 2.6.2
-if(CMAKE_MAJOR_VERSION GREATER 1 AND CMAKE_MINOR_VERSION GREATER 4)
-  set(PNG_EXPORT_RULE EXPORT libpng)
-elseif(CMAKE_MAJOR_VERSION GREATER 2) # future proof
-  set(PNG_EXPORT_RULE EXPORT libpng)
-endif()
-
-# INSTALL
-if(NOT SKIP_INSTALL_LIBRARIES AND NOT SKIP_INSTALL_ALL )
-  install(TARGETS ${PNG_LIB_TARGETS}
-      ${PNG_EXPORT_RULE}
-      RUNTIME DESTINATION bin
-      LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
-      ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR})
-
-  if(PNG_SHARED)
-    # Create a symlink for libpng.dll.a => libpng17.dll.a on Cygwin
-    if(CYGWIN OR MINGW)
-       get_target_property(BUILD_TARGET_LOCATION ${PNG_LIB_NAME} LOCATION_${CMAKE_BUILD_TYPE})
-       CREATE_SYMLINK(${BUILD_TARGET_LOCATION} libpng${CMAKE_IMPORT_LIBRARY_SUFFIX})
-       install(FILES ${CMAKE_CURRENT_BINARY_DIR}/libpng${CMAKE_IMPORT_LIBRARY_SUFFIX}
-         DESTINATION ${CMAKE_INSTALL_LIBDIR})
-    endif(CYGWIN OR MINGW)
-
-    if(NOT WIN32)
-      get_target_property(BUILD_TARGET_LOCATION ${PNG_LIB_NAME} LOCATION_${CMAKE_BUILD_TYPE})
-      CREATE_SYMLINK(${BUILD_TARGET_LOCATION} libpng${CMAKE_SHARED_LIBRARY_SUFFIX})
-      install(FILES ${CMAKE_CURRENT_BINARY_DIR}/libpng${CMAKE_SHARED_LIBRARY_SUFFIX}
-         DESTINATION ${CMAKE_INSTALL_LIBDIR})
-    endif(NOT WIN32)
-  endif(PNG_SHARED)
-
-  if(PNG_STATIC)
-    if(NOT WIN32 OR CYGWIN OR MINGW)
-      get_target_property(BUILD_TARGET_LOCATION ${PNG_LIB_NAME_STATIC} LOCATION_${CMAKE_BUILD_TYPE})
-      CREATE_SYMLINK(${BUILD_TARGET_LOCATION} libpng${CMAKE_STATIC_LIBRARY_SUFFIX})
-      install(FILES ${CMAKE_CURRENT_BINARY_DIR}/libpng${CMAKE_STATIC_LIBRARY_SUFFIX}
-         DESTINATION ${CMAKE_INSTALL_LIBDIR})
-    endif(NOT WIN32 OR CYGWIN OR MINGW)
- endif()
-endif()
-
-if(NOT SKIP_INSTALL_HEADERS AND NOT SKIP_INSTALL_ALL )
-  install(FILES ${libpng_public_hdrs}   DESTINATION include)
-  install(FILES ${libpng_public_hdrs}   DESTINATION include/${PNGLIB_NAME})
-endif()
-if(NOT SKIP_INSTALL_EXECUTABLES AND NOT SKIP_INSTALL_ALL )
-  if(NOT WIN32 OR CYGWIN OR MINGW)
-    install(PROGRAMS ${CMAKE_CURRENT_BINARY_DIR}/libpng-config DESTINATION bin)
-    install(PROGRAMS ${CMAKE_CURRENT_BINARY_DIR}/${PNGLIB_NAME}-config
-            DESTINATION bin)
-  endif(NOT WIN32 OR CYGWIN OR MINGW)
-endif()
-
-if(NOT SKIP_INSTALL_FILES AND NOT SKIP_INSTALL_ALL )
-  # Install man pages
-  if(NOT PNG_MAN_DIR)
-    set(PNG_MAN_DIR "share/man")
-  endif()
-  install(FILES libpng.3 libpngpf.3      DESTINATION ${PNG_MAN_DIR}/man3)
-  install(FILES png.5                    DESTINATION ${PNG_MAN_DIR}/man5)
-  # Install pkg-config files
-  if(NOT WIN32 OR CYGWIN OR MINGW)
-    install(FILES ${CMAKE_CURRENT_BINARY_DIR}/libpng.pc
-            DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig)
-    install(PROGRAMS ${CMAKE_CURRENT_BINARY_DIR}/libpng-config
-            DESTINATION bin)
-    install(FILES ${CMAKE_CURRENT_BINARY_DIR}/${PNGLIB_NAME}.pc
-            DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig)
-    install(PROGRAMS ${CMAKE_CURRENT_BINARY_DIR}/${PNGLIB_NAME}-config
-            DESTINATION bin)
-  endif(NOT WIN32 OR CYGWIN OR MINGW)
-endif()
-
-# On versions of CMake that support it, create an export file CMake
-# users can include() to import our targets
-if(PNG_EXPORT_RULE AND NOT SKIP_INSTALL_EXPORT AND NOT SKIP_INSTALL_ALL )
-  install(EXPORT libpng DESTINATION lib/libpng FILE lib${PNG_LIB_NAME}.cmake)
-endif()
-
-# what's with libpng-$VER%.txt and all the extra files?
-
-# UNINSTALL
-# do we need this?
-
-# DIST
-# do we need this?
-
-# to create msvc import lib for mingw compiled shared lib
-# pexports libpng.dll > libpng.def
-# lib /def:libpng.def /machine:x86
-

INSTALL

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

KNOWNBUG

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

LICENSE

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

Makefile.am

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

README

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

TODO

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

Y2KINFO

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

arm/arm_init.c

@@ -1,232 +0,0 @@
-
-/* arm_init.c - NEON optimised filter functions
- *
- * Copyright (c) 2013 Glenn Randers-Pehrson
- * Written by Mans Rullgard, 2011.
- * Last changed in libpng 1.6.6 [September 16, 2013]
- *
- * This code is released under the libpng license.
- * For conditions of distribution and use, see the disclaimer
- * and license in png.h
- */
-/* Below, after checking __linux__, various non-C90 POSIX 1003.1 functions are
- * called.
- */
-#define _POSIX_SOURCE 1
-
-#include "../pngpriv.h"
-
-#ifdef PNG_READ_SUPPORTED
-#if PNG_ARM_NEON_OPT > 0
-#ifdef PNG_ARM_NEON_CHECK_SUPPORTED /* Do run-time checks */
-#include <signal.h> /* for sig_atomic_t */
-
-#ifdef __ANDROID__
-/* Linux provides access to information about CPU capabilites via
- * /proc/self/auxv, however Android blocks this while still claiming to be
- * Linux.  The Andoid NDK, however, provides appropriate support.
- *
- * Documentation: http://www.kandroid.org/ndk/docs/CPU-ARM-NEON.html
- */
-#include <cpu-features.h>
-
-static int
-png_have_neon(png_structp png_ptr)
-{
-   /* This is a whole lot easier than the mess below, however it is probably
-    * implemented as below, therefore it is better to cache the result (these
-    * function calls may be slow!)
-    */
-   PNG_UNUSED(png_ptr)
-   return android_getCpuFamily() == ANDROID_CPU_FAMILY_ARM &&
-      (android_getCpuFeatures() & ANDROID_CPU_ARM_FEATURE_NEON) != 0;
-}
-#elif defined(__linux__)
-/* The generic __linux__ implementation requires reading /proc/self/auxv and
- * looking at each element for one that records NEON capabilities.
- */
-#include <unistd.h> /* for POSIX 1003.1 */
-#include <errno.h>  /* for EINTR */
-
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <fcntl.h>
-#include <elf.h>
-#include <asm/hwcap.h>
-
-/* A read call may be interrupted, in which case it returns -1 and sets errno to
- * EINTR if nothing was done, otherwise (if something was done) a partial read
- * may result.
- */
-static size_t
-safe_read(png_structp png_ptr, int fd, void *buffer_in, size_t nbytes)
-{
-   size_t ntotal = 0;
-   char *buffer = png_voidcast(char*, buffer_in);
-
-   while (nbytes > 0)
-   {
-      unsigned int nread;
-      int iread;
-
-      /* Passing nread > INT_MAX to read is implementation defined in POSIX
-       * 1003.1, therefore despite the unsigned argument portable code must
-       * limit the value to INT_MAX!
-       */
-      if (nbytes > INT_MAX)
-         nread = INT_MAX;
-
-      else
-         nread = (unsigned int)/*SAFE*/nbytes;
-
-      iread = read(fd, buffer, nread);
-
-      if (iread == -1)
-      {
-         /* This is the devil in the details, a read can terminate early with 0
-          * bytes read because of EINTR, yet it still returns -1 otherwise end
-          * of file cannot be distinguished.
-          */
-         if (errno != EINTR)
-         {
-            png_warning(png_ptr, "/proc read failed");
-            return 0; /* I.e., a permanent failure */
-         }
-      }
-
-      else if (iread < 0)
-      {
-         /* Not a valid 'read' result: */
-         png_warning(png_ptr, "OS /proc read bug");
-         return 0;
-      }
-
-      else if (iread > 0)
-      {
-         /* Continue reading until a permanent failure, or EOF */
-         buffer += iread;
-         nbytes -= (unsigned int)/*SAFE*/iread;
-         ntotal += (unsigned int)/*SAFE*/iread;
-      }
-
-      else
-         return ntotal;
-   }
-
-   return ntotal; /* nbytes == 0 */
-}
-
-static int
-png_have_neon(png_structp png_ptr)
-{
-   int fd = open("/proc/self/auxv", O_RDONLY);
-   Elf32_auxv_t aux;
-
-   /* Failsafe: failure to open means no NEON */
-   if (fd == -1)
-   {
-      png_warning(png_ptr, "/proc/self/auxv open failed");
-      return 0;
-   }
-
-   while (safe_read(png_ptr, fd, &aux, sizeof aux) == sizeof aux)
-   {
-      if (aux.a_type == AT_HWCAP && (aux.a_un.a_val & HWCAP_NEON) != 0)
-      {
-         close(fd);
-         return 1;
-      }
-   }
-
-   close(fd);
-   return 0;
-}
-#else
-   /* We don't know how to do a run-time check on this system */
-#  error "no support for run-time ARM NEON checks"
-#endif /* OS checks */
-#endif /* PNG_ARM_NEON_CHECK_SUPPORTED */
-
-#ifndef PNG_ALIGNED_MEMORY_SUPPORTED
-#  error "ALIGNED_MEMORY is required; set: -DPNG_ALIGNED_MEMORY_SUPPORTED"
-#endif
-
-void
-png_init_filter_functions_neon(png_structp pp, unsigned int bpp)
-{
-   /* 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)
-   {
-      case PNG_OPTION_UNSET:
-         /* Allow the run-time check to execute if it has been enabled -
-          * thus both API and CHECK can be turned on.  If it isn't supported
-          * this case will fall through to the 'default' below, which just
-          * returns.
-          */
-#endif /* PNG_ARM_NEON_API_SUPPORTED */
-#ifdef PNG_ARM_NEON_CHECK_SUPPORTED
-         {
-            static volatile sig_atomic_t no_neon = -1; /* not checked */
-
-            if (no_neon < 0)
-               no_neon = !png_have_neon(pp);
-
-            if (no_neon)
-               return;
-         }
-#ifdef PNG_ARM_NEON_API_SUPPORTED
-         break;
-#endif
-#endif /* PNG_ARM_NEON_CHECK_SUPPORTED */
-
-#ifdef PNG_ARM_NEON_API_SUPPORTED
-      default: /* OFF or INVALID */
-         return;
-
-      case PNG_OPTION_ON:
-         /* Option turned on */
-         break;
-   }
-#endif
-
-   /* IMPORTANT: any new external functions used here must be declared using
-    * PNG_INTERNAL_FUNCTION in ../pngpriv.h.  This is required so that the
-    * 'prefix' option to configure works:
-    *
-    *    ./configure --with-libpng-prefix=foobar_
-    *
-    * Verify you have got this right by running the above command, doing a build
-    * and examining pngprefix.h; it must contain a #define for every external
-    * function you add.  (Notice that this happens automatically for the
-    * initialization function.)
-    */
-   pp->read_filter[PNG_FILTER_VALUE_UP-1] = png_read_filter_row_up_neon;
-
-   if (bpp == 3)
-   {
-      pp->read_filter[PNG_FILTER_VALUE_SUB-1] = png_read_filter_row_sub3_neon;
-      pp->read_filter[PNG_FILTER_VALUE_AVG-1] = png_read_filter_row_avg3_neon;
-      pp->read_filter[PNG_FILTER_VALUE_PAETH-1] =
-         png_read_filter_row_paeth3_neon;
-   }
-
-   else if (bpp == 4)
-   {
-      pp->read_filter[PNG_FILTER_VALUE_SUB-1] = png_read_filter_row_sub4_neon;
-      pp->read_filter[PNG_FILTER_VALUE_AVG-1] = png_read_filter_row_avg4_neon;
-      pp->read_filter[PNG_FILTER_VALUE_PAETH-1] =
-          png_read_filter_row_paeth4_neon;
-   }
-}
-#endif /* PNG_ARM_NEON_OPT > 0 */
-#endif /* PNG_READ_SUPPORTED */

arm/filter_neon.S

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

arm/filter_neon_intrinsics.c

@@ -1,372 +0,0 @@
-
-/* filter_neon_intrinsics.c - NEON optimised filter functions
- *
- * Copyright (c) 2013 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.8 [December 19, 2013]
- *
- * 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"
-
-/* 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)
-
-#ifdef PNG_READ_SUPPORTED
-#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_READ_SUPPORTED */
-#endif /* PNG_ARM_NEON_IMPLEMENTATION == 1 (intrinsics) */

autogen.sh

@@ -1,224 +1,25 @@
 #! /bin/sh
+# a quick hack script to generate necessary files from 
+# auto* tools.
 #
-# Run 'autoreconf' to build 'configure', 'Makefile.in' and other configure
-# control files.
-#
-# The first time this is run on a GIT checkout the only files that exist are
-# configure.ac and Makefile.am; all of the autotools support scripts are
-# missing.  They are instantiated with autoreconf --force --install.
-#
-# For regular ("tarball") distributions all the files should exist.  We do not
-# want them to be updated *under any circumstances*.  It should never be
-# necessary to 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;;
-
-      --clean)
-         clean=1;;
-
-      *)
-         exec >&2
-         echo "$0: usage: ./autogen.sh"
-         if test -d .git
-         then
-            echo "  ./autogen.sh generates the configure script and"
-            echo "  Makefile.in, or refreshes them after changes to Makefile.am"
-            echo "  or configure.ac.  You may prefer to just run autoreconf."
-         elif test -z "$maintainer"
-         then
-            echo "  DO NOT RUN THIS SCRIPT."
-            echo "  If you need to change Makefile.am or configure.ac then you"
-            echo "  also need to run ./configure --enable-maintainer-mode and"
-            echo "  use the appropriate autotools, *NOT* this script, to update"
-            echo "  everything, please check the documentation of autoreconf."
-            echo "  WARNING: libpng is intentionally generated with a known,"
-            echo "  fixed, set of autotools.  It is known *NOT* to work with"
-            echo "  the collection of autotools distributed on highly reputable"
-            echo "  operating systems."
-            echo "  Remember: autotools is GNU software, you are expected to"
-            echo "  pay for support."
-         else
-            echo "  You have run autogen.sh with --maintainer enabled and you"
-            echo "  are not using a GIT distribution, then you have given an"
-            echo "  unrecognized argument.  This is not good. --maintainer"
-            echo "  switches off any assumptions that you might not know what"
-            echo "  you are doing."
-         fi
-         exit 1;;
-   esac
-
-   shift
-done
-#
-# First check for a set of the autotools files; if absent then this is assumed
-# to be a GIT version and the local autotools must be used.  If present this
-# is a tarball distribution and the script should not be used.  If partially
-# present bad things are happening.
-#
-# The autotools generated files:
-libpng_autotools_files="Makefile.in aclocal.m4 config.guess config.h.in\
-   config.sub configure depcomp install-sh ltmain.sh missing test-driver"
-#
-# 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
+# WARNING: if you run this you will change the versions
+# of the tools which are used and, maybe, required!
+        touch Makefile.am configure.ac
+{
+	echo "running libtoolize" >&2
+	libtoolize --force --copy --automake
+} && {
+	echo "running aclocal" >&2
+	aclocal
+} && {
+	echo "running autoheader [ignore the warnings]" >&2
+	autoheader
+} && {
+	echo "running automake" >&2
+	automake --force-missing --foreign -a -c
+} && {
+	echo "running autoconf" >&2
+	autoconf
+} &&
+	echo "autogen complete" >&2 ||
+	echo "ERROR: autogen.sh failed, autogen is incomplete" >&2

compile

@@ -1,347 +0,0 @@
-#! /bin/sh
-# Wrapper for compilers which do not understand '-c -o'.
-
-scriptversion=2012-10-14.11; # UTC
-
-# Copyright (C) 1999-2013 Free Software Foundation, Inc.
-# Written by Tom Tromey <tromey@cygnus.com>.
-#
-# 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.
-
-# This file is maintained in Automake, please report
-# bugs to <bug-automake@gnu.org> or send patches to
-# <automake-patches@gnu.org>.
-
-nl='
-'
-
-# We need space, tab and new line, in precisely that order.  Quoting is
-# there to prevent tools from complaining about whitespace usage.
-IFS=" ""	$nl"
-
-file_conv=
-
-# func_file_conv build_file lazy
-# Convert a $build file to $host form and store it in $file
-# Currently only supports Windows hosts. If the determined conversion
-# type is listed in (the comma separated) LAZY, no conversion will
-# take place.
-func_file_conv ()
-{
-  file=$1
-  case $file in
-    / | /[!/]*) # absolute file, and not a UNC file
-      if test -z "$file_conv"; then
-	# lazily determine how to convert abs files
-	case `uname -s` in
-	  MINGW*)
-	    file_conv=mingw
-	    ;;
-	  CYGWIN*)
-	    file_conv=cygwin
-	    ;;
-	  *)
-	    file_conv=wine
-	    ;;
-	esac
-      fi
-      case $file_conv/,$2, in
-	*,$file_conv,*)
-	  ;;
-	mingw/*)
-	  file=`cmd //C echo "$file " | sed -e 's/"\(.*\) " *$/\1/'`
-	  ;;
-	cygwin/*)
-	  file=`cygpath -m "$file" || echo "$file"`
-	  ;;
-	wine/*)
-	  file=`winepath -w "$file" || echo "$file"`
-	  ;;
-      esac
-      ;;
-  esac
-}
-
-# func_cl_dashL linkdir
-# Make cl look for libraries in LINKDIR
-func_cl_dashL ()
-{
-  func_file_conv "$1"
-  if test -z "$lib_path"; then
-    lib_path=$file
-  else
-    lib_path="$lib_path;$file"
-  fi
-  linker_opts="$linker_opts -LIBPATH:$file"
-}
-
-# func_cl_dashl library
-# Do a library search-path lookup for cl
-func_cl_dashl ()
-{
-  lib=$1
-  found=no
-  save_IFS=$IFS
-  IFS=';'
-  for dir in $lib_path $LIB
-  do
-    IFS=$save_IFS
-    if $shared && test -f "$dir/$lib.dll.lib"; then
-      found=yes
-      lib=$dir/$lib.dll.lib
-      break
-    fi
-    if test -f "$dir/$lib.lib"; then
-      found=yes
-      lib=$dir/$lib.lib
-      break
-    fi
-    if test -f "$dir/lib$lib.a"; then
-      found=yes
-      lib=$dir/lib$lib.a
-      break
-    fi
-  done
-  IFS=$save_IFS
-
-  if test "$found" != yes; then
-    lib=$lib.lib
-  fi
-}
-
-# func_cl_wrapper cl arg...
-# Adjust compile command to suit cl
-func_cl_wrapper ()
-{
-  # Assume a capable shell
-  lib_path=
-  shared=:
-  linker_opts=
-  for arg
-  do
-    if test -n "$eat"; then
-      eat=
-    else
-      case $1 in
-	-o)
-	  # configure might choose to run compile as 'compile cc -o foo foo.c'.
-	  eat=1
-	  case $2 in
-	    *.o | *.[oO][bB][jJ])
-	      func_file_conv "$2"
-	      set x "$@" -Fo"$file"
-	      shift
-	      ;;
-	    *)
-	      func_file_conv "$2"
-	      set x "$@" -Fe"$file"
-	      shift
-	      ;;
-	  esac
-	  ;;
-	-I)
-	  eat=1
-	  func_file_conv "$2" mingw
-	  set x "$@" -I"$file"
-	  shift
-	  ;;
-	-I*)
-	  func_file_conv "${1#-I}" mingw
-	  set x "$@" -I"$file"
-	  shift
-	  ;;
-	-l)
-	  eat=1
-	  func_cl_dashl "$2"
-	  set x "$@" "$lib"
-	  shift
-	  ;;
-	-l*)
-	  func_cl_dashl "${1#-l}"
-	  set x "$@" "$lib"
-	  shift
-	  ;;
-	-L)
-	  eat=1
-	  func_cl_dashL "$2"
-	  ;;
-	-L*)
-	  func_cl_dashL "${1#-L}"
-	  ;;
-	-static)
-	  shared=false
-	  ;;
-	-Wl,*)
-	  arg=${1#-Wl,}
-	  save_ifs="$IFS"; IFS=','
-	  for flag in $arg; do
-	    IFS="$save_ifs"
-	    linker_opts="$linker_opts $flag"
-	  done
-	  IFS="$save_ifs"
-	  ;;
-	-Xlinker)
-	  eat=1
-	  linker_opts="$linker_opts $2"
-	  ;;
-	-*)
-	  set x "$@" "$1"
-	  shift
-	  ;;
-	*.cc | *.CC | *.cxx | *.CXX | *.[cC]++)
-	  func_file_conv "$1"
-	  set x "$@" -Tp"$file"
-	  shift
-	  ;;
-	*.c | *.cpp | *.CPP | *.lib | *.LIB | *.Lib | *.OBJ | *.obj | *.[oO])
-	  func_file_conv "$1" mingw
-	  set x "$@" "$file"
-	  shift
-	  ;;
-	*)
-	  set x "$@" "$1"
-	  shift
-	  ;;
-      esac
-    fi
-    shift
-  done
-  if test -n "$linker_opts"; then
-    linker_opts="-link$linker_opts"
-  fi
-  exec "$@" $linker_opts
-  exit 1
-}
-
-eat=
-
-case $1 in
-  '')
-     echo "$0: No command.  Try '$0 --help' for more information." 1>&2
-     exit 1;
-     ;;
-  -h | --h*)
-    cat <<\EOF
-Usage: compile [--help] [--version] PROGRAM [ARGS]
-
-Wrapper for compilers which do not understand '-c -o'.
-Remove '-o dest.o' from ARGS, run PROGRAM with the remaining
-arguments, and rename the output as expected.
-
-If you are trying to build a whole package this is not the
-right script to run: please start by reading the file 'INSTALL'.
-
-Report bugs to <bug-automake@gnu.org>.
-EOF
-    exit $?
-    ;;
-  -v | --v*)
-    echo "compile $scriptversion"
-    exit $?
-    ;;
-  cl | *[/\\]cl | cl.exe | *[/\\]cl.exe )
-    func_cl_wrapper "$@"      # Doesn't return...
-    ;;
-esac
-
-ofile=
-cfile=
-
-for arg
-do
-  if test -n "$eat"; then
-    eat=
-  else
-    case $1 in
-      -o)
-	# configure might choose to run compile as 'compile cc -o foo foo.c'.
-	# So we strip '-o arg' only if arg is an object.
-	eat=1
-	case $2 in
-	  *.o | *.obj)
-	    ofile=$2
-	    ;;
-	  *)
-	    set x "$@" -o "$2"
-	    shift
-	    ;;
-	esac
-	;;
-      *.c)
-	cfile=$1
-	set x "$@" "$1"
-	shift
-	;;
-      *)
-	set x "$@" "$1"
-	shift
-	;;
-    esac
-  fi
-  shift
-done
-
-if test -z "$ofile" || test -z "$cfile"; then
-  # If no '-o' option was seen then we might have been invoked from a
-  # pattern rule where we don't need one.  That is ok -- this is a
-  # normal compilation that the losing compiler can handle.  If no
-  # '.c' file was seen then we are probably linking.  That is also
-  # ok.
-  exec "$@"
-fi
-
-# Name of file we expect compiler to create.
-cofile=`echo "$cfile" | sed 's|^.*[\\/]||; s|^[a-zA-Z]:||; s/\.c$/.o/'`
-
-# Create the lock directory.
-# Note: use '[/\\:.-]' here to ensure that we don't use the same name
-# that we are using for the .o file.  Also, base the name on the expected
-# object file name, since that is what matters with a parallel build.
-lockdir=`echo "$cofile" | sed -e 's|[/\\:.-]|_|g'`.d
-while true; do
-  if mkdir "$lockdir" >/dev/null 2>&1; then
-    break
-  fi
-  sleep 1
-done
-# FIXME: race condition here if user kills between mkdir and trap.
-trap "rmdir '$lockdir'; exit 1" 1 2 15
-
-# Run the compile.
-"$@"
-ret=$?
-
-if test -f "$cofile"; then
-  test "$cofile" = "$ofile" || mv "$cofile" "$ofile"
-elif test -f "${cofile}bj"; then
-  test "${cofile}bj" = "$ofile" || mv "${cofile}bj" "$ofile"
-fi
-
-rmdir "$lockdir"
-exit $ret
-
-# 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:

config.h.in

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

configure.ac

@@ -14,262 +14,67 @@ dnl Makefile.am to upgrade the package name.
 dnl This is here to prevent earlier autoconf from being used, it
 dnl should not be necessary to regenerate configure if the time
 dnl stamps are correct
-AC_PREREQ([2.68])
+AC_PREREQ(2.59)
 
 dnl Version number stuff here:
 
-AC_INIT([libpng],[1.7.0beta25],[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.2.41beta06], [png-mng-implement@lists.sourceforge.net])
+AM_INIT_AUTOMAKE
+dnl stop configure from automagically running automake
 AM_MAINTAINER_MODE
 
-dnl configure.ac and Makefile.am expect automake 1.11.2 or a compatible later
-dnl version; aclocal.m4 will generate a failure if you use a prior version of
-dnl automake, so the following is not necessary (and is not defined anyway):
-dnl AM_PREREQ([1.11.2])
-dnl stop configure from automagically running automake
-
-PNGLIB_VERSION=1.7.0beta25
+PNGLIB_VERSION=1.2.41beta06
 PNGLIB_MAJOR=1
-PNGLIB_MINOR=7
-PNGLIB_RELEASE=0
+PNGLIB_MINOR=2
+PNGLIB_RELEASE=41
 
 dnl End of version number stuff
 
 AC_CONFIG_SRCDIR([pngget.c])
-AC_CONFIG_HEADERS([config.h])
+AM_CONFIG_HEADER(config.h)
 
 # Checks for programs.
-AC_LANG([C])
 AC_PROG_CC
-AM_PROG_AS
-LT_PATH_LD
+AC_PROG_LD
 AC_PROG_CPP
-AC_PROG_AWK
+AC_CHECK_TOOL(SED, sed, :)
+AC_LIBTOOL_WIN32_DLL
 AC_PROG_INSTALL
 AC_PROG_LN_S
 AC_PROG_MAKE_SET
-
-dnl libtool/libtoolize; version 2.4.2 is the tested version, this or any
-dnl compatible later version may be used
-LT_INIT([win32-dll])
-LT_PREREQ([2.4.2])
-
-# Some awks crash when confronted with pnglibconf.dfa, do a test run now
-# to make sure this doesn't happen
-AC_MSG_CHECKING([that AWK works])
-if ${AWK} -f ${srcdir}/scripts/options.awk out="/dev/null" version=search\
-   ${srcdir}/pngconf.h ${srcdir}/scripts/pnglibconf.dfa\
-   ${srcdir}/pngusr.dfa 1>&2
-then
-   AC_MSG_RESULT([ok])
-else
-   AC_MSG_FAILURE([failed], 1)
-fi
-
-# This is a remnant of the old cc -E validation, where it may have been
-# necessary to use a different preprocessor for .dfn files
-DFNCPP="$CPP"
-AC_SUBST(DFNCPP)
-
-# -Werror cannot be passed to GCC in CFLAGS because configure will fail (it
-# checks the compiler with a program that generates a warning), add the
-# following option to deal with this
-AC_ARG_VAR(PNG_COPTS,
-   [additional flags for the C compiler, use this for options that would]
-   [cause configure itself to fail])
-AC_ARG_ENABLE(werror,
-   AS_HELP_STRING([[[--enable-werror[=OPT]]]],
-      [Pass -Werror or the given argument to the compiler if it is supported]),
-   [test "$enable_werror" = "yes" && enable_werror="-Werror"
-    if test "$enable_werror" != "no"; then
-      sav_CFLAGS="$CFLAGS"
-      CFLAGS="$enable_werror $CFLAGS"
-      AC_MSG_CHECKING([if the compiler allows $enable_werror])
-      AC_COMPILE_IFELSE(
-         [AC_LANG_SOURCE([
-            [int main(int argc, char **argv){]
-            [return argv[argc-1][0];]
-            [}]])],
-         AC_MSG_RESULT(yes)
-         PNG_COPTS="$PNG_COPTS $enable_werror",
-         AC_MSG_RESULT(no))
-      CFLAGS="$sav_CFLAGS"
-    fi],)
+AC_PROG_LIBTOOL
 
 # Checks for header files.
 AC_HEADER_STDC
-# 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_RESTRICT
+AC_C_CONST
+AC_TYPE_SIZE_T
+AC_STRUCT_TM
 
-# 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]))
+# 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_CHECK_LIB(z, zlibVersion, , AC_ERROR([zlib not installed]))
 
-# 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],[Enable floating point APIs],,
-              [enable_floating_point=yes])
-AC_ARG_ENABLE([fixed-point],[Enable fixed point APIs],,
-              [enable_fixed_point=yes])
-AC_ARG_ENABLE([floating-arithmetic],[Use floating point arithmetic internally],,
-              [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
-
-# The following is for pngvalid, to ensure it catches FP errors even on
-# platforms that don't enable FP exceptions, the function appears in the math
-# library (typically), it's not an error if it is not found.
-AC_SEARCH_LIBS([feenableexcept],[m],AC_DEFINE([HAVE_FEENABLEEXCEPT],[1],
-      [Define to 1 if the feenableexcept function is available]))
-# Required by pngvalid:
-AC_SEARCH_LIBS([ceil],[m])
-
-# zlib checks and arguments;
-#  package zlib: argument is the name of the library
-#  zlib-header: the name of the header file
-#  zlib-prefix: the prefix for library functions, if any
-AC_ARG_WITH([zlib],
-   AS_HELP_STRING([[[--with-zlib=<name>]]],
-                  [base name of the zlib implementation (e.g. 'z')]),,
-   [with_zlib='z'])
-
-z_prefix=
-AC_ARG_WITH([zlib-prefix],
-   AS_HELP_STRING([[[--with-zlib-prefix=<prefix>]]],
-                  [prefix for zlib API functions]),
-   [if test "$withval" = "" -o "$withval" = yes; then
-      with_zlib_prefix='z_'
-      AC_DEFINE([PNG_ZLIB_PREFIX],[z_],[Standard zlib prefix])
-   elif test "${withval}" != "no"; then
-      AC_DEFINE_UNQUOTED([PNG_ZLIB_PREFIX],[${withval}],
-         [User defined zlib prefix])
-   else
-      with_zlib_prefix=
-   fi
-   if test "$with_zlib_prefix" != ""; then
-      AC_DEFINE([Z_PREFIX],[1],[Tell zlib.h to prefix function names])
-      z_prefix="#define Z_PREFIX 1"
-   fi])
-
-AC_ARG_WITH([zlib-header],
-   AS_HELP_STRING([[[--with-zlib-header='<file>' or '"file"']]],
-      [C include argument to locate zlib header file, e.g. <zlib.h>, take
-       care to put single quotes round this on the command line]),
-   [AC_DEFINE_UNQUOTED([PNG_ZLIB_HEADER],[${withval}],[Zlib header file])],
-   with_zlib_header='<zlib.h>')
-
-# AC_CHECK_LIB isn't quite enough for this because we need the special header
-# file too.
-LIBS="-l${with_zlib} $LIBS"
+LIBPNG_DEFINES=-DPNG_CONFIGURE_LIBPNG
 AC_MSG_CHECKING(
-   [[Library '${with_zlib}' and #include ${with_zlib_header} for symbol '${with_zlib_prefix}zlibVersion']])
-AC_LINK_IFELSE(
-   [AC_LANG_PROGRAM(
-      [[
-${z_prefix}
-#include ${with_zlib_header}
-      ]],
-      [[(void)${with_zlib_prefix}zlibVersion();]])],
-   AC_MSG_RESULT([ok]),
-   AC_MSG_FAILURE([not found]))
-
-AC_MSG_CHECKING([if using Solaris linker])
-SLD=`$LD --version 2>&1 | grep Solaris`
-if test "$SLD"; then
-    have_solaris_ld=yes
-    AC_MSG_RESULT(yes)
-else
-    have_solaris_ld=no
-    AC_MSG_RESULT(no)
-fi
-AM_CONDITIONAL(HAVE_SOLARIS_LD, test "$have_solaris_ld" = "yes")
+  [if assembler code in pnggccrd.c can be compiled without PNG_NO_MMX_CODE])
+AC_TRY_COMPILE(
+  [#include "$srcdir/pnggccrd.c"],
+  [return 0;],
+  AC_MSG_RESULT(yes)
+  LIBPNG_NO_MMX="",
+  AC_MSG_RESULT(no)
+  LIBPNG_NO_MMX=-DPNG_NO_MMX_CODE)
+LIBPNG_DEFINES=$LIBPNG_DEFINES\ $LIBPNG_NO_MMX
+AC_SUBST(LIBPNG_DEFINES)
+AC_SUBST(LIBPNG_NO_MMX)
 
 AC_MSG_CHECKING([if libraries can be versioned])
-# Special case for PE/COFF platforms: ld reports
-# support for version-script, but doesn't actually
-# DO anything with it.
-case $host in
-*cygwin* | *mingw32* | *interix* )
-    have_ld_version_script=no
-    AC_MSG_RESULT(no)
-;;
-* )
-
-if test "$have_solaris_ld" = "yes"; then
-    GLD=`$LD --help < /dev/null 2>&1 | grep 'M mapfile'`
-else
-    GLD=`$LD --help < /dev/null 2>/dev/null | grep version-script`
-fi
-
+GLD=`$LD --help < /dev/null 2>/dev/null | grep version-script`
 if test "$GLD"; then
     have_ld_version_script=yes
     AC_MSG_RESULT(yes)
@@ -278,17 +83,14 @@ else
     AC_MSG_RESULT(no)
     AC_MSG_WARN(*** You have not enabled versioned symbols.)
 fi
-;;
-esac
-
 AM_CONDITIONAL(HAVE_LD_VERSION_SCRIPT, test "$have_ld_version_script" = "yes")
 
 if test "$have_ld_version_script" = "yes"; then
     AC_MSG_CHECKING([for symbol prefix])
     SYMBOL_PREFIX=`echo "PREFIX=__USER_LABEL_PREFIX__" \
-                  | ${CPP-${CC-gcc} -E} - 2>&1 \
-                  | ${EGREP-grep} "^PREFIX=" \
-                  | ${SED-sed} -e "s:^PREFIX=::" -e "s:__USER_LABEL_PREFIX__::"`
+                   | ${CPP-${CC-gcc} -E} - 2>&1 \
+                   | ${EGREP-grep} "^PREFIX=" \
+                   | ${SED-sed} "s:^PREFIX=::"`
     AC_SUBST(SYMBOL_PREFIX)
     AC_MSG_RESULT($SYMBOL_PREFIX)
 fi
@@ -302,91 +104,45 @@ AC_SUBST(PNGLIB_RELEASE)
 # Additional arguments (and substitutions)
 # Allow the pkg-config directory to be set
 AC_ARG_WITH(pkgconfigdir,
-   AS_HELP_STRING([[[--with-pkgconfigdir]]],
-      [Use the specified pkgconfig dir (default is libdir/pkgconfig)]),
-   [pkgconfigdir=${withval}],
-   [pkgconfigdir='${libdir}/pkgconfig'])
+	AC_HELP_STRING([--with-pkgconfigdir],
+	[Use the specified pkgconfig dir (default is libdir/pkgconfig)]),
+	[pkgconfigdir=${withval}],
+	[pkgconfigdir='${libdir}/pkgconfig'])
 
 AC_SUBST([pkgconfigdir])
-AC_MSG_NOTICE([[pkgconfig directory is ${pkgconfigdir}]])
+AC_MSG_NOTICE([pkgconfig directory is ${pkgconfigdir}])
 
 # Make the *-config binary config scripts optional
 AC_ARG_WITH(binconfigs,
-   AS_HELP_STRING([[[--with-binconfigs]]],
-      [Generate shell libpng-config scripts as well as pkg-config data]
-      [@<:@default=yes@:>@]),
-   [if test "${withval}" = no; then
-      binconfigs=
-      AC_MSG_NOTICE([[libpng-config scripts will not be built]])
-    else
-      binconfigs='${binconfigs}'
-    fi],
-   [binconfigs='${binconfigs}'])
+	AC_HELP_STRING([--with-binconfigs],
+		[Generate shell libpng-config scripts as well as pkg-config data]
+		[@<:@default=yes@:>@]),
+	[if test "${withval}" = no; then
+		binconfigs=
+		AC_MSG_NOTICE([libpng-config scripts will not be built])
+	else
+		binconfigs='${binconfigs}'
+	fi],
+	[binconfigs='${binconfigs}'])
 AC_SUBST([binconfigs])
 
-# Support for prefixes to the API function names; this will generate defines
-# at the start of the build to rename exported library functions
-AC_ARG_WITH(libpng-prefix,
-   AS_HELP_STRING([[[--with-libpng-prefix]]],
-      [prefix libpng exported function (API) names with the given value]),
-   [if test "${withval:-no}" != "no"; then
-      AC_SUBST([PNG_PREFIX], [${withval}])
-    fi])
-AM_CONDITIONAL([DO_PNG_PREFIX], [test "${with_libpng_prefix:-no}" != "no"])
-
-# HOST SPECIFIC OPTIONS
-# =====================
-#
-# ARM
-# ===
-#
-# ARM NEON (SIMD) support.
-
-AC_ARG_ENABLE([arm-neon],
-   AS_HELP_STRING([[[--enable-arm-neon]]],
-      [Enable ARM NEON optimizations: =no/off, check, api, yes/on:]
-      [no/off: disable the optimizations; check: use internal checking code]
-      [(deprecated and poorly supported); api: disable by default, enable by]
-      [a call to png_set_option; yes/on: turn on unconditionally.]
-      [If not specified: determined by the compiler.]),
-   [case "$enableval" in
-      no|off)
-         # disable the default enabling on __ARM_NEON__ systems:
-         AC_DEFINE([PNG_ARM_NEON_OPT], [0],
-                   [Disable ARM Neon optimizations])
-         # Prevent inclusion of the assembler files below:
-         enable_arm_neon=no;;
-      check)
-         AC_DEFINE([PNG_ARM_NEON_CHECK_SUPPORTED], [],
-                   [Check for ARM Neon support at run-time]);;
-      api)
-         AC_DEFINE([PNG_ARM_NEON_API_SUPPORTED], [],
-                   [Turn on ARM Neon optimizations at run-time]);;
-      yes|on)
-         AC_DEFINE([PNG_ARM_NEON_OPT], [2],
-                   [Enable ARM Neon optimizations])
-         AC_MSG_WARN([--enable-arm-neon: please specify 'check' or 'api', if]
-            [you want the optimizations unconditionally pass -mfpu=neon]
-            [to the compiler.]);;
-      *)
-         AC_MSG_ERROR([--enable-arm-neon=${enable_arm_neon}: invalid value])
-   esac])
-
-# Add ARM specific files to all builds where the host_cpu is arm ('arm*') or
-# where ARM optimizations were explicitly requested (this allows a fallback if a
-# future host CPU does not match 'arm*')
-
-AM_CONDITIONAL([PNG_ARM_NEON],
-   [test "$enable_arm_neon" != 'no' &&
-    case "$host_cpu" in
-      arm*) :;;
-      *)    test "$enable_arm_neon" != '';;
-    esac])
-
-AC_MSG_NOTICE([[Extra options for compiler: $PNG_COPTS]])
+# Allow the old version number library, libpng.so, to be removed from
+# the build
+AC_ARG_WITH(libpng-compat,
+	AC_HELP_STRING([--with-libpng-compat],
+		[Generate the obsolete libpng.so library @<:@default=yes@:>@]),
+	[if test "${withval}" = no; then
+		compatlib=
+		AC_MSG_NOTICE([libpng.so will not be built])
+	else
+		compatlib=libpng.la
+	fi],
+	[compatlib=libpng.la])
+AC_SUBST([compatlib])
 
 # Config files, substituting as above
-AC_CONFIG_FILES([Makefile libpng.pc])
-AC_CONFIG_FILES([libpng-config], [chmod +x libpng-config])
+AC_CONFIG_FILES([Makefile libpng.pc:scripts/libpng.pc-configure.in])
+AC_CONFIG_FILES([libpng-config:scripts/libpng-config.in],
+		[chmod +x libpng-config])
 
 AC_OUTPUT

contrib/README.txt

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

contrib/conftest/README

@@ -1,46 +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.
-
-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 which extracts information from the header of a PNG file
- * without processing the image.  Notice that some header information may occur
- * after the image data, textual data and comments are an example; the approach
- * in this file won't work reliably for such data because it only looks for the
- * information in the section of the file that preceeds the image data.
- *
- * Compile and link against libpng and zlib, plus anything else required on the
- * system you use.
- *
- * To use supply a list of PNG files containing iCCP chunks, the chunks will be
- * extracted to a similarly named file with the extension replaced by 'icc',
- * which will be overwritten without warning.
- */
-#include <stdlib.h>
-#include <setjmp.h>
-#include <string.h>
-#include <stdio.h>
-
-#include <png.h>
-
-static int verbose = 1;
-static png_byte no_profile[] = "no profile";
-
-static png_bytep
-extract(FILE *fp, png_uint_32 *proflen)
-{
-   png_structp png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING,0,0,0);
-   png_infop info_ptr = NULL;
-   png_bytep result = NULL;
-
-   /* Initialize for error or no profile: */
-   *proflen = 0;
-
-   if (png_ptr == NULL)
-   {
-      fprintf(stderr, "iccfrompng: version library mismatch?\n");
-      return 0;
-   }
-
-   if (setjmp(png_jmpbuf(png_ptr)))
-   {
-      png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
-      return 0;
-   }
-
-   png_init_io(png_ptr, fp);
-
-   info_ptr = png_create_info_struct(png_ptr);
-   if (info_ptr == NULL)
-      png_error(png_ptr, "OOM allocating info structure");
-
-   png_read_info(png_ptr, info_ptr);
-
-   {
-      png_charp name;
-      int compression_type;
-      png_bytep profile;
-
-      if (png_get_iCCP(png_ptr, info_ptr, &name, &compression_type, &profile,
-         proflen) & PNG_INFO_iCCP)
-      {
-         result = malloc(*proflen);
-         if (result != NULL)
-            memcpy(result, profile, *proflen);
-
-         else
-            png_error(png_ptr, "OOM allocating profile buffer");
-      }
-
-      else
-	result = no_profile;
-   }
-
-   png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
-   return result;
-}
-
-static int
-extract_one_file(const char *filename)
-{
-   int result = 0;
-   FILE *fp = fopen(filename, "rb");
-
-   if (fp != NULL)
-   {
-      png_uint_32 proflen = 0;
-      png_bytep profile = extract(fp, &proflen);
-
-      if (profile != NULL && profile != no_profile)
-      {
-         size_t len;
-         char *output;
-
-         {
-            const char *ep = strrchr(filename, '.');
-
-            if (ep != NULL)
-               len = ep-filename;
-
-            else
-               len = strlen(filename);
-         }
-
-         output = malloc(len + 5);
-         if (output != NULL)
-         {
-            FILE *of;
-
-            memcpy(output, filename, len);
-            strcpy(output+len, ".icc");
-
-            of = fopen(output, "wb");
-            if (of != NULL)
-            {
-               if (fwrite(profile, proflen, 1, of) == 1 &&
-                  fflush(of) == 0 &&
-                  fclose(of) == 0)
-               {
-                  if (verbose)
-                     printf("%s -> %s\n", filename, output);
-                  /* Success return */
-                  result = 1;
-               }
-
-               else
-               {
-                  fprintf(stderr, "%s: error writing profile\n", output);
-                  if (remove(output))
-                     fprintf(stderr, "%s: could not remove file\n", output);
-               }
-            }
-
-            else
-               fprintf(stderr, "%s: failed to open output file\n", output);
-
-            free(output);
-         }
-
-         else
-            fprintf(stderr, "%s: OOM allocating string!\n", filename);
-
-         free(profile);
-      }
-
-      else if (verbose && profile == no_profile)
-	printf("%s has no profile\n", filename);
-   }
-
-   else
-      fprintf(stderr, "%s: could not open file\n", filename);
-
-   return result;
-}
-
-int
-main(int argc, char **argv)
-{
-   int i;
-   int extracted = 0;
-
-   for (i=1; i<argc; ++i)
-   {
-      if (strcmp(argv[i], "-q") == 0)
-         verbose = 0;
-
-      else if (extract_one_file(argv[i]))
-         extracted = 1;
-   }
-
-   /* Exit code is true if any extract succeeds */
-   return extracted == 0;
-}

contrib/examples/pngpixel.c

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

contrib/examples/pngtopng.c

@@ -1,92 +0,0 @@
-/*- pngtopng
- *
- * COPYRIGHT: Written by John Cunningham Bowler, 2011.
- * To the extent possible under law, the author has waived all copyright and
- * related or neighboring rights to this work.  This work is published from:
- * United States.
- *
- * Read a PNG and write it out in a fixed format, using the 'simplified API'
- * that was introduced in libpng-1.6.0.
- *
- * This sample code is just the code from the top of 'example.c' with some error
- * handling added.  See example.c for more comments.
- */
-#include <stddef.h>
-#include <stdlib.h>
-#include <string.h>
-#include <stdio.h>
-
-/* Normally use <png.h> here to get the installed libpng, but this is done to
- * ensure the code picks up the local libpng implementation:
- */
-#include "../../png.h"
-
-int main(int argc, const char **argv)
-{
-   int result = 1;
-
-   if (argc == 3)
-   {
-      png_image image;
-
-      /* Only the image structure version number needs to be set. */
-      memset(&image, 0, sizeof image);
-      image.version = PNG_IMAGE_VERSION;
-
-      if (png_image_begin_read_from_file(&image, argv[1]))
-      {
-         png_bytep buffer;
-
-         /* Change this to try different formats!  If you set a colormap format
-          * then you must also supply a colormap below.
-          */
-         image.format = PNG_FORMAT_RGBA;
-
-         buffer = malloc(PNG_IMAGE_SIZE(image));
-
-         if (buffer != NULL)
-         {
-            if (png_image_finish_read(&image, NULL/*background*/, buffer,
-               0/*row_stride*/, NULL/*colormap for PNG_FORMAT_FLAG_COLORMAP */))
-            {
-               if (png_image_write_to_file(&image, argv[2],
-                  0/*convert_to_8bit*/, buffer, 0/*row_stride*/,
-                  NULL/*colormap*/))
-                  result = 0;
-
-               else
-                  fprintf(stderr, "pngtopng: write %s: %s\n", argv[2],
-                      image.message);
-
-               free(buffer);
-            }
-
-            else
-            {
-               fprintf(stderr, "pngtopng: read %s: %s\n", argv[1],
-                   image.message);
-
-               /* This is the only place where a 'free' is required; libpng does
-                * the cleanup on error and success, but in this case we couldn't
-                * complete the read because of running out of memory.
-                */
-               png_image_free(&image);
-            }
-         }
-
-         else
-            fprintf(stderr, "pngtopng: out of memory: %lu bytes\n",
-               (unsigned long)PNG_IMAGE_SIZE(image));
-      }
-
-      else
-         /* Failed to read the first argument: */
-         fprintf(stderr, "pngtopng: %s: %s\n", argv[1], image.message);
-   }
-
-   else
-      /* Wrong number of arguments */
-      fprintf(stderr, "pngtopng: usage: pngtopng input-file output-file\n");
-
-   return result;
-}

contrib/gregbook/COPYING

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

contrib/gregbook/Makefile.sgi

@@ -23,9 +23,9 @@
 
 # macros --------------------------------------------------------------------
 
-PNGINC = -I/usr/local/include/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/libpng12
+PNGLIB = -L/usr/local/lib -lpng12	  # dynamically linked against libpng
+#PNGLIB = /usr/local/lib/libpng12.a # statically linked against libpng
 # or:
 #PNGINC = -I../..
 #PNGLIB = -L../.. -lpng

contrib/gregbook/Makefile.unx

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

contrib/gregbook/Makefile.w32

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

contrib/gregbook/README

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

contrib/gregbook/makevms.com

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

contrib/gregbook/readpng.c

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

contrib/gregbook/readpng2.c

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

contrib/gregbook/readpng2.h

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

contrib/gregbook/rpng-win.c

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

contrib/gregbook/rpng-x.c

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

contrib/gregbook/rpng2-win.c

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

contrib/gregbook/rpng2-x.c

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

contrib/gregbook/writepng.c

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

contrib/libtests/fakepng.c

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

contrib/libtests/gentests.sh

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

contrib/libtests/readpng.c

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

contrib/libtests/tarith.c

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

contrib/libtests/timepng.c

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

contrib/pngminim/decoder/README

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

contrib/pngminim/decoder/gather.sh

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

contrib/pngminim/decoder/makefile

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

contrib/pngminim/decoder/pngusr.dfa

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

contrib/pngminim/decoder/pngusr.h

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

contrib/pngminim/encoder/README

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

contrib/pngminim/encoder/dummy_inflate.c

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

contrib/pngminim/encoder/gather.sh

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

contrib/pngminim/encoder/makefile

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

contrib/pngminim/encoder/pngusr.dfa

@@ -1,39 +0,0 @@
-# pngminim/encoder/pngusr.dfa
-#
-# Copyright (c) 2010-2013 Glenn Randers-Pehrson
-#
-# This code is released under the libpng license.
-# For conditions of distribution and use, see the disclaimer
-# and license in png.h
-
-# First all the build options off:
-
-everything = off
-
-# Switch on the write code - this makes a minimalist encoder
-
-option WRITE on
-
-# These 2 options are required if you need to read PBM (P1 or P4) files.
-option WRITE_INVERT on
-option WRITE_PACK on
-
-# You must choose fixed or floating point arithmetic:
-# option FLOATING_POINT on
-
-option FIXED_POINT on
-
-# You must chose the internal fixed point implementation or to
-# use the system floating point.  The latter is considerably
-# smaller (by about 1kbyte on an x86 system):
-# option FLOATING_ARITHMETIC on
-
-option FLOATING_ARITHMETIC off
-
-# Your program will probably need other options.  The example
-# program here, pnm2pngm, requires the following.  Take a look
-# at pnglibconf.h to find out the full set of what has to be
-# enabled to make the following work.
-
-option SETJMP on
-option STDIO on

contrib/pngminim/encoder/pngusr.h

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

contrib/pngminim/preader/README

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

contrib/pngminim/preader/gather.sh

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

contrib/pngminim/preader/makefile

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

contrib/pngminim/preader/pngusr.dfa

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

contrib/pngminim/preader/pngusr.h

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

contrib/pngminus/makefile.std

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

contrib/pngminus/png2pnm.c

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

contrib/pngminus/pnm2png.c

@@ -18,7 +18,6 @@
 #include <mem.h>
 #include <fcntl.h>
 #endif
-#include <zlib.h>
 
 #ifndef BOOL
 #define BOOL unsigned char
@@ -198,9 +197,6 @@ BOOL pnm2png (FILE *pnm_file, FILE *png_file, FILE *alpha_file, BOOL interlace,
   char          height_token[16];
   char          maxval_token[16];
   int           color_type;
-  unsigned long   ul_width=0, ul_alpha_width=0;
-  unsigned long   ul_height=0, ul_alpha_height=0;
-  unsigned long   ul_maxval=0;
   png_uint_32   width, alpha_width;
   png_uint_32   height, alpha_height;
   png_uint_32   maxval;
@@ -210,9 +206,6 @@ BOOL pnm2png (FILE *pnm_file, FILE *png_file, FILE *alpha_file, BOOL interlace,
   int           alpha_present;
   int           row, col;
   BOOL          raw, alpha_raw = FALSE;
-#if defined(PNG_WRITE_INVERT_SUPPORTED) || defined(PNG_WRITE_PACK_SUPPORTED)
-  BOOL          packed_bitmap = FALSE;
-#endif
   png_uint_32   tmp16;
   int           i;
 
@@ -225,36 +218,20 @@ BOOL pnm2png (FILE *pnm_file, FILE *png_file, FILE *alpha_file, BOOL interlace,
   }
   else if ((type_token[1] == '1') || (type_token[1] == '4'))
   {
-#if defined(PNG_WRITE_INVERT_SUPPORTED) || defined(PNG_WRITE_PACK_SUPPORTED)
     raw = (type_token[1] == '4');
     color_type = PNG_COLOR_TYPE_GRAY;
-    get_token(pnm_file, width_token);
-    sscanf (width_token, "%lu", &ul_width);
-    width = (png_uint_32) ul_width;
-    get_token(pnm_file, height_token);
-    sscanf (height_token, "%lu", &ul_height);
-    height = (png_uint_32) ul_height;
     bit_depth = 1;
-    packed_bitmap = TRUE;
-#else
-    fprintf (stderr, "PNM2PNG built without PNG_WRITE_INVERT_SUPPORTED and \n");
-    fprintf (stderr, "PNG_WRITE_PACK_SUPPORTED can't read PBM (P1,P4) files\n");
-#endif
   }
   else if ((type_token[1] == '2') || (type_token[1] == '5'))
   {
     raw = (type_token[1] == '5');
     color_type = PNG_COLOR_TYPE_GRAY;
     get_token(pnm_file, width_token);
-    sscanf (width_token, "%lu", &ul_width);
-    width = (png_uint_32) ul_width;
+    sscanf (width_token, "%lu", &width);
     get_token(pnm_file, height_token);
-    sscanf (height_token, "%lu", &ul_height);
-    height = (png_uint_32) ul_height;
+    sscanf (height_token, "%lu", &height);
     get_token(pnm_file, maxval_token);
-    sscanf (maxval_token, "%lu", &ul_maxval);
-    maxval = (png_uint_32) ul_maxval;
-
+    sscanf (maxval_token, "%lu", &maxval);
     if (maxval <= 1)
       bit_depth = 1;
     else if (maxval <= 3)
@@ -271,14 +248,11 @@ BOOL pnm2png (FILE *pnm_file, FILE *png_file, FILE *alpha_file, BOOL interlace,
     raw = (type_token[1] == '6');
     color_type = PNG_COLOR_TYPE_RGB;
     get_token(pnm_file, width_token);
-    sscanf (width_token, "%lu", &ul_width);
-    width = (png_uint_32) ul_width;
+    sscanf (width_token, "%lu", &width);
     get_token(pnm_file, height_token);
-    sscanf (height_token, "%lu", &ul_height);
-    height = (png_uint_32) ul_height;
+    sscanf (height_token, "%lu", &height);
     get_token(pnm_file, maxval_token);
-    sscanf (maxval_token, "%lu", &ul_maxval);
-    maxval = (png_uint_32) ul_maxval;
+    sscanf (maxval_token, "%lu", &maxval);
     if (maxval <= 1)
       bit_depth = 1;
     else if (maxval <= 3)
@@ -313,18 +287,15 @@ BOOL pnm2png (FILE *pnm_file, FILE *png_file, FILE *alpha_file, BOOL interlace,
     {
       alpha_raw = (type_token[1] == '5');
       get_token(alpha_file, width_token);
-      sscanf (width_token, "%lu", &ul_alpha_width);
-      alpha_width=(png_uint_32) ul_alpha_width;
+      sscanf (width_token, "%lu", &alpha_width);
       if (alpha_width != width)
         return FALSE;
       get_token(alpha_file, height_token);
-      sscanf (height_token, "%lu", &ul_alpha_height);
-      alpha_height = (png_uint_32) ul_alpha_height;
+      sscanf (height_token, "%lu", &alpha_height);
       if (alpha_height != height)
         return FALSE;
       get_token(alpha_file, maxval_token);
-      sscanf (maxval_token, "%lu", &ul_maxval);
-      maxval = (png_uint_32) ul_maxval;
+      sscanf (maxval_token, "%lu", &maxval);
       if (maxval <= 1)
         alpha_depth = 1;
       else if (maxval <= 3)
@@ -358,14 +329,8 @@ BOOL pnm2png (FILE *pnm_file, FILE *png_file, FILE *alpha_file, BOOL interlace,
 
   alpha_present = (channels - 1) % 2;
 
-#if defined(PNG_WRITE_INVERT_SUPPORTED) || defined(PNG_WRITE_PACK_SUPPORTED)
-  if (packed_bitmap)
-    /* row data is as many bytes as can fit width x channels x bit_depth */
-    row_bytes = (width * channels * bit_depth + 7) / 8;
-  else
-#endif
-    /* row_bytes is the width x number of channels x (bit-depth / 8) */
-    row_bytes = width * channels * ((bit_depth <= 8) ? 1 : 2);
+  /* row_bytes is the width x number of channels x (bit-depth / 8) */
+  row_bytes = width * channels * ((bit_depth <= 8) ? 1 : 2);
 
   if ((png_pixels = (png_byte *) malloc (row_bytes * height * sizeof (png_byte))) == NULL)
     return FALSE;
@@ -375,48 +340,40 @@ BOOL pnm2png (FILE *pnm_file, FILE *png_file, FILE *alpha_file, BOOL interlace,
 
   for (row = 0; row < height; row++)
   {
-#if defined(PNG_WRITE_INVERT_SUPPORTED) || defined(PNG_WRITE_PACK_SUPPORTED)
-    if (packed_bitmap) {
-      for (i = 0; i < row_bytes; i++)
-        /* png supports this format natively so no conversion is needed */
-        *pix_ptr++ = get_data (pnm_file, 8);
-    } else
-#endif
+    for (col = 0; col < width; col++)
     {
-      for (col = 0; col < width; col++)
+      for (i = 0; i < (channels - alpha_present); i++)
       {
-        for (i = 0; i < (channels - alpha_present); i++)
-        {
-          if (raw)
-            *pix_ptr++ = get_data (pnm_file, bit_depth);
+        if (raw)
+          *pix_ptr++ = get_data (pnm_file, bit_depth);
+        else
+          if (bit_depth <= 8)
+            *pix_ptr++ = get_value (pnm_file, bit_depth);
           else
-            if (bit_depth <= 8)
-              *pix_ptr++ = get_value (pnm_file, bit_depth);
-            else
-            {
-              tmp16 = get_value (pnm_file, bit_depth);
-              *pix_ptr = (png_byte) ((tmp16 >> 8) & 0xFF);
-              pix_ptr++;
-              *pix_ptr = (png_byte) (tmp16 & 0xFF);
-              pix_ptr++;
-            }
-        }
+          {
+            tmp16 = get_value (pnm_file, bit_depth);
+            *pix_ptr = (png_byte) ((tmp16 >> 8) & 0xFF);
+            pix_ptr++;
+            *pix_ptr = (png_byte) (tmp16 & 0xFF);
+            pix_ptr++;
+          }
+      }
 
-        if (alpha) /* read alpha-channel from pgm file */
-        {
-          if (alpha_raw)
-            *pix_ptr++ = get_data (alpha_file, alpha_depth);
+      if (alpha) /* read alpha-channel from pgm file */
+      {
+        if (alpha_raw)
+          *pix_ptr++ = get_data (alpha_file, alpha_depth);
+        else
+          if (alpha_depth <= 8)
+            *pix_ptr++ = get_value (alpha_file, bit_depth);
           else
-            if (alpha_depth <= 8)
-              *pix_ptr++ = get_value (alpha_file, bit_depth);
-            else
-            {
-              tmp16 = get_value (alpha_file, bit_depth);
-              *pix_ptr++ = (png_byte) ((tmp16 >> 8) & 0xFF);
-              *pix_ptr++ = (png_byte) (tmp16 & 0xFF);
-            }
-        } /* if alpha */
-      } /* if packed_bitmap */
+          {
+            tmp16 = get_value (alpha_file, bit_depth);
+            *pix_ptr++ = (png_byte) ((tmp16 >> 8) & 0xFF);
+            *pix_ptr++ = (png_byte) (tmp16 & 0xFF);
+          }
+      } /* if alpha */
+
     } /* end for col */
   } /* end for row */
 
@@ -433,14 +390,6 @@ BOOL pnm2png (FILE *pnm_file, FILE *png_file, FILE *alpha_file, BOOL interlace,
     return FALSE;
   }
 
-#if defined(PNG_WRITE_INVERT_SUPPORTED) || defined(PNG_WRITE_PACK_SUPPORTED)
-  if (packed_bitmap == TRUE)
-  {
-    png_set_packing (png_ptr);
-    png_set_invert_mono (png_ptr);
-  }
-#endif
-
   /* setjmp() must be called in every function that calls a PNG-reading libpng function */
   if (setjmp (png_jmpbuf(png_ptr)))
   {
@@ -497,32 +446,19 @@ BOOL pnm2png (FILE *pnm_file, FILE *png_file, FILE *alpha_file, BOOL interlace,
 void get_token(FILE *pnm_file, char *token)
 {
   int i = 0;
-  int ret;
 
-  /* remove white-space and comment lines */
+  /* remove white-space */
   do
   {
-    ret = fgetc(pnm_file);
-    if (ret == '#') {
-      /* the rest of this line is a comment */
-      do
-      {
-        ret = fgetc(pnm_file);
-      }
-      while ((ret != '\n') && (ret != '\r') && (ret != EOF));
-    }
-    if (ret == EOF) break;
-    token[i] = (unsigned char) ret;
+    token[i] = (unsigned char) fgetc (pnm_file);
   }
   while ((token[i] == '\n') || (token[i] == '\r') || (token[i] == ' '));
 
   /* read string */
   do
   {
-    ret = fgetc(pnm_file);
-    if (ret == EOF) break;
     i++;
-    token[i] = (unsigned char) ret;
+    token[i] = (unsigned char) fgetc (pnm_file);
   }
   while ((token[i] != '\n') && (token[i] != '\r') && (token[i] != ' '));
 
@@ -574,7 +510,6 @@ png_uint_32 get_value (FILE *pnm_file, int depth)
 {
   static png_uint_32 mask = 0;
   png_byte token[16];
-  unsigned long ul_ret_value;
   png_uint_32 ret_value;
   int i = 0;
 
@@ -583,8 +518,7 @@ png_uint_32 get_value (FILE *pnm_file, int depth)
       mask = (mask << 1) | 0x01;
 
   get_token (pnm_file, (char *) token);
-  sscanf ((const char *) token, "%lu", &ul_ret_value);
-  ret_value = (png_uint_32) ul_ret_value;
+  sscanf ((const char *) token, "%lu", &ret_value);
 
   ret_value &= mask;
 

contrib/pngsuite/README

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

contrib/tools/README.txt

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

contrib/tools/checksum-icc.c

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

contrib/tools/chkfmt

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

contrib/tools/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, 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.
- *
- * 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;
-}