[libpng17] Imported from libpng-1.7.0beta25.tar

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().

ANNOUNCE

@@ -1,57 +1,477 @@
 
-Libpng 1.0.4 - September 18, 1999
+Libpng 1.7.0beta25 - December 26, 2013
 
-This is a public release of libpng, intended for use in production codes.
+This is not intended to be a public release.  It will be replaced
+within a few weeks by a public version or by another test version.
 
-Changes since the last public release (1.0.3):
+Files available for download:
 
-  Added check for PNG_READ_INTERLACE_SUPPORTED in pngread.c; issue a warning
-     if an attempt is made to read an interlaced image when it's not supported.
-  Added check if png_ptr->trans is defined before free'ing it in pngread.c
-  Modified the Y2K statement to include versions back to version 0.71
-  Fixed a bug in the check for valid IHDR bit_depth/color_types in pngrutil.c
-  Modified makefile.wat (added -zp8 flag, ".symbolic", changed some comments)
-  Replaced leading blanks with tab characters in makefile.hux
-  Changed "dworkin.wustl.edu" to "ccrc.wustl.edu" in various documents.
-  Changed (float)red and (float)green to (double)red, (double)green
-     in png_set_rgb_to_gray() to avoid "promotion" problems in AIX.
-  Fixed a bug in pngconf.h that omitted <stdio.h> when PNG_DEBUG==0 (K Bracey).
-  Reformatted libpng.3 and libpngpf.3 with proper fonts (script by J. vanZandt).
-  Updated documentation to refer to the PNG-1.2 specification.
-  Removed ansi2knr.c and left pointers to the latest source for ansi2knr.c
-    in makefile.knr, INSTALL, and README (L. Peter Deutsch)
-  Fixed bugs in calculation of the length of rowbytes when adding alpha
-    channels to 16-bit images, in pngrtran.c (Chris Nokleberg)
-  Added function png_set_user_transform_info() to store user_transform_ptr,
-    user_depth, and user_channels into the png_struct, and a function
-    png_get_user_transform_ptr() to retrieve the pointer (Chris Nokleberg)
-  Added function png_set_empty_plte_permitted() to make libpng useable
-    in MNG applications.
-  Corrected the typedef for png_free_ptr in png.h (Jesse Jones).
-  Correct gamma with srgb is 45455 instead of 45000 in pngrutil.c, to be
-    consistent with PNG-1.2, and allow variance of 500 before complaining.
-  Added assembler code contributed by Intel in file pngvcrd.c and modified
-    makefile.w32 to use it (Nirav Chhatrapati, INTEL Corporation, Gilles Vollant)
-  Define PNG_USE_PNGVCRD in makefile.w32, to get MMX assembler code.
-  Changed "ln -s -f" to "ln -f -s" in the makefiles to make Solaris happy.
-  Added makefile.beo for BEOS on X86, contributed by Sander Stok.
-  Replaced 2147483647L several places with PNG_MAX_UINT macro, defined in png.h
-  Changed leading blanks to tabs in all makefiles.
-  Made alternate versions of  png_set_expand() in pngrtran.c, namely
-    png_set_gray_1_2_4_to_8, png_set_palette_to_rgb, and png_set_tRNS_to_alpha
-    (Greg Roelofs, in "PNG: The Definitive Guide").
-  Relocated start of 'extern "C"' block in png.h so it doesn't include pngconf.h
-  Revised calculation of num_blocks in pngmem.c to avoid a potentially
-    negative shift distance, whose results are undefined in the C language.
-  Added a check in pngset.c to prevent writing multiple tIME chunks.
-  Added a check in pngwrite.c to detect invalid small window_bits sizes.
-  Added a demo read_user_transform_fn that examines the row filters in pngtest.c
-  Define PNG_ALWAYS_EXTERN in pngconf.h if __STDC__ is defined
-  Made several minor corrections to pngtest.c
-  Changed "hptr += 16L" to "hptr = hptr + 16L" in pngmem.c for Turbo 3.0
-  Renamed the makefiles with longer but more user friendly extensions
+Source files with LF line endings (for Unix/Linux) and with a
+"configure" script
 
-Send comments/corrections/commendations to
-png-implement@ccrc.wustl.edu or to randeg@alum.rpi.edu
+   1.7.0beta25.tar.xz (LZMA-compressed, recommended)
+   1.7.0beta25.tar.gz
+
+Source files with CRLF line endings (for Windows), without the
+"configure" script
+
+   lp170b25.7z  (LZMA-compressed, recommended)
+   lp170b25.zip
+
+Other information:
+
+   1.7.0beta25-README.txt
+   1.7.0beta25-LICENSE.txt
+   Gnupg/*.asc (PGP armored detached signatures)
+
+Changes since the last public release (1.6.0):
+
+Version 1.7.0alpha01 [December 15, 2012]
+  Started 1.7.0 branch from libpng-1.6.0beta33.
+  Made 8-bit compose and rgb_to_grayscale accuracy improvements.  These
+    changes cause 16-bit arithmetic to be used for 8-bit data in the gamma
+    corrected compose and grayscale operations.  The arithmetic errors have
+    three sources all of which are fixed in this commit:
+    1) 8-bit linear calculations produce massive errors for lower intensity
+       values.
+    2) The old 16-bit "16 to 8" gamma table code erroneously wrote the lowest
+       output value into a table entry which corresponded to multiple output
+       values (so where the value written should have been the closest to the
+       transformed input value.)
+    3) In a number of cases the code to access the 16-bit table did not round;
+       it did a simple shift, which was wrong and made the side effects of (2)
+       even worse.
+  The new gamma code does not have the 16-to-8 problem at the cost of slightly
+    more calculations and the algorithm used to minimize the number of
+    calculations has been extended to all the 16-bit tables; it has advantages
+    for any significant gamma correction.
+  Rearranged png_struct, remove unused members, change png_set_filter handling
+    png_struct members rearranged - partly to reorder to avoid packing, partly
+    to put frequently accessed members at the start and partly to make
+    the grouping more clear. png_set_filter code has been rewritten and the
+    code shared with png_write_start_row moved to a common function.  Comments
+    in png.h have been made more clear. Minor fixes to
+    contrib/libtests/timepng.c and some of the png_*_tRNS logic, including
+    more error detection in png_set_tRNS.
+  Cleaned up USER_LIMITS feature, removing members from png_struct when not
+    required.
+  Rearranged ARM-NEON optimizations to isolate the machine specific code to
+    the hardware subdirectory, and add comments to pngrutil.c so that
+    implementors of other optimizations will know what to do.
+  Fixed cases of unquoted DESTDIR in Makefile.am.
+  Rebuilt Makefile.in, configure, etc., with autoconf-2.69 and automake-1.12.5.
+
+Version 1.7.0alpha02 [December 17, 2012]
+  Removed functions that were deprecated in libpng-1.6.0:
+    png_reset_zstream(), png_info_init_3(), and png_data_freer() and its
+    associated flags.
+  Removed some duplicated lines from contrib/tools/scale.c and png.c.
+  Changed some instances of png_warning() to png_app_error().
+  Updated some left over "1.6.0beta32" in code sources.
+  Fixed a "png_structp" prototype (should be png_structrp) in arm_init.c
+  Updated the version-number hack in pngvalid.c
+
+Version 1.7.0alpha03 [December 19, 2012]
+  Cleaned up and enhanced the configure option; libpng now correctly
+    links and tests against zlib with a prefix; tests have been clarified; and
+    irrelevant or obsolete things (as defined by the autotools man page) have
+    been removed.
+  Documented new PNG_ABORT behavior in the manual and commentary in pngerror.c
+  Cleaned up whitespace in the synopsis portion of the manpage "libpng.3"
+  Fixed previous support for Z_PREFIX in configure builds, corrected sCAL APIs;
+    some of these use floating point arithmetic so they need to be disabled if
+    floating point arithmetic is switched off.  This is a quiet API change -
+    previously it appeared that the APIs were supported if fixed point
+    arithmetic was used internally, however they required certain APIs (floor,
+    modf, frexp, atof) that are part of C floating point support. Changed
+    png_fixed and the gamma code specific version of the same to avoid floor(),
+    which may be a library function (not an intrinsic). Removed unused #if 0
+    code.
+  Disassembled the version number in scripts/options.awk (necessary for
+    building on SunOs).
+
+Version 1.7.0alpha04 [December 23, 2012]
+  Added scripts/makefile.msys contributed by Christopher M. Wheeler
+  Made default Zlib compression settings be configurable. This adds #defines to
+    pnglibconf.h to control the defaults.
+  Fixed Windows build issues, enabled ARM compilation. Various warnings issued
+    by earlier versions of GCC fixed for Cygwin and Min/GW (which both use old
+    GCCs.) ARM support is enabled by default in zlib.props (unsupported by
+    Microsoft) and ARM compilation is made possible by deleting the check for
+    x86. The test programs cannot be run because they are not signed.
+
+Version 1.7.0alpha05 [December 24, 2012]
+  Discontinued distributing libpng-1.x.x.tar.bz2.
+  Discontinued distributing libpng-1.7.0-1.6.0-diff.txt and similar.
+
+Version 1.7.0alpha06 [January 1, 2013]
+  Fixed 'make distcheck' on SUN OS - libpng.so was not being removed
+
+Version 1.7.0alpha07 [January 10, 2013]
+  Fixed conceivable but difficult to repro overflow. Also added two test
+    programs to generate and test a PNG which should have the problem.
+
+Version 1.7.0alpha08 [January 17, 2013]
+  Corrected previous attempt at overflow detection in png_set_unknown_chunks().
+
+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
+
+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
 
 Glenn R-P

CMakeLists.txt

@@ -0,0 +1,364 @@
+# 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,17 +1,73 @@
 
-Installing libpng version 1.0.4 - September 18, 1999
+Installing libpng
 
-Before installing libpng, you must first install zlib.  zlib
-can usually be found wherever you got libpng.  zlib can be
-placed in another directory, at the same level as libpng.
-Note that your system might already have a preinstalled
-zlib, but 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.
+On Unix/Linux and similar systems, you can simply type
+
+    ./configure [--prefix=/path]
+    make check
+    make install
+
+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
+
+Instead, you can use one of the custom-built makefiles in the
+"scripts" directory
+
+    cp scripts/makefile.system makefile
+    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.
+
+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,
+at the same level as libpng.
+
+If your system already has a preinstalled zlib you will still need
+to have access to the zlib.h and zconf.h include files that
+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-1.0.4" or "lpng103" and "zlib-1.1.3"
-or "zlib113") so that you have directories called "zlib" and "libpng".
+might be called "libpng-x.y.z" or "libpngNN" and "zlib-1.2.7"
+or "zlib127") so that you have directories called "zlib" and "libpng".
 
 Your directory structure should look like this:
 
@@ -21,8 +77,26 @@ 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
           scripts
              makefile.*
+             *.def (module definition files)
+             etc.
           pngtest.png
           etc.
       zlib
@@ -32,65 +106,65 @@ Your directory structure should look like this:
           contrib
           etc.
 
-First enter the zlib directory and follow the instructions
-in zlib/README.  Then come back here and choose the
-appropriate makefile.sys in the scripts directory.
-The files that are presently available in the scripts directory
-include
+If the line endings in the files look funny, you may wish to get the other
+distribution of libpng.  It is available in both tar.gz (UNIX style line
+endings) and zip (DOS style line endings) formats.
 
- descrip.mms      =>  VMS makefile for MMS or MMK
- makefile.std     =>  Generic UNIX makefile
- makefile.knr     =>  Archaic UNIX Makefile that converts files with
-                      ansi2knr (Requires ansi2knr.c from
-                      ftp://ftp.cs.wisc.edu/ghost)
- makefile.dec     =>  DEC Alpha UNIX makefile
- makefile.hpux    =>  HPUX (10.20 and 11.00) makefile
- makefile.sgi     =>  Silicon Graphics IRIX makefile
- makefile.sunos   =>  Sun makefile
- makefile.solaris =>  Solaris 2.X makefile (gcc, creates libpng.so.2.1.0.4)
- makefile.linux   =>  Linux/ELF makefile (gcc, creates libpng.so.2.1.0.4)
- 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.borland =>  Borland makefile
- build.bat        =>  MS-DOS batch file for Borland compiler
- makefile.dj2     =>  DJGPP 2 makefile
- makefile.msc     =>  Microsoft C makefile
- makefile.win32vc =>  makefile for Microsoft Visual C++ 4.0 and later
- makefile.turboc3 =>  Turbo C 3.0 makefile
- 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
- pngdll.mak       =>  To make a png32bd.dll with Borland C++ 4.5
- pngdef.pas       =>  Defines for a png32bd.dll with Borland C++ 4.5
- SCOPTIONS.ppc    =>  Used with smakefile.ppc
+If you are building libpng with MSVC, you can enter the
+libpng projects\visualc6 or visualc71 directory and follow the instructions
+in README.txt.
+
+Otherwise enter the zlib directory and follow the instructions in zlib/README,
+then come back here and run "configure" or choose the appropriate
+makefile.sys in the scripts directory.
 
 Copy the file (or files) that you need from the
 scripts directory into this directory, for example
 
-   MSDOS example: copy scripts\makefile.msd makefile
+   MSDOS example: copy scripts\makefile.msc makefile
    UNIX example:    cp scripts/makefile.std makefile
 
 Read the makefile to see if you need to change any source or
 target directories to match your preferences.
 
-Then read pngconf.h to see if you want to make any configuration
+Then read pnglibconf.dfa to see if you want to make any configuration
 changes.
 
-Then just run "make test" which will create the libpng library in
-this directory and run a quick test that reads the "pngtest.png"
-file and writes a "pngout.png" file that should be identical to it.
+Then just run "make" which will create the libpng library in
+this directory and "make test" which will run a quick test that reads
+the "pngtest.png" file and writes a "pngout.png" file that should be
+identical to it.  Look for "9782 zero samples" in the output of the
+test.  For more confidence, you can run another test by typing
+"pngtest pngnow.png" and looking for "289 zero samples" in the output.
+Also, you can run "pngtest -m contrib/pngsuite/*.png" and compare
+your output with the result shown in contrib/pngsuite/README.
 
 Most of the makefiles will allow you to run "make install" to
 put the library in its final resting place (if you want to
 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
+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
+scripts/makefile.* yourself, that is)
+
+CFLAGS="-Wall -O -funroll-loops \
+-malign-loops=2 -malign-functions=2" ./configure --prefix=/usr/include \
+--with-pkgconfigdir=/usr/lib/pkgconfig --includedir=/usr/include
+
+You can alternatively specify --includedir=/usr/include, /usr/local/include,
+/usr/include/libpng%NN%, or whatever.
+
+If you find that the configure script is out-of-date or is not supporting
+your platform properly, try running autogen.sh to regenerate "configure",
+"Makefile.in", and the other configuration files. Then try configure again.
 
-Further information can be found in the README and libpng.txt
-files, in the individual makefiles, and in png.h, and the manual
-pages libpng.3 and png.5.

KNOWNBUG

@@ -1,40 +0,0 @@
-
-Known bugs and suggested enhancements in libpng-1.0.4
-
-
-1. March 15, 1998 -- OPTIMIZATION -- Kevin Bracey
-
-   Loops need to be optimized everywhere
-
-   Make them count down instead of up -- Kevin Bracey
-
-   Optimizing compilers don't need this, and making
-   the change would be error prone -- Tom Lane, Glenn R-P
-
-   Question whether i-- or --i is better.
-
-   STATUS: Under investigation, postponed until after
-   libpng-1.0.4.  About 160 loops will be turned around
-   in libpng-1.0.Nn, for testing.
-
-2. July 4, 1998 -- ENHANCEMENT -- Glenn R-P
-
-   libpng-1.0.4 and earlier transform colors to gamma=1.0 space for
-   merging with background, and then back to the image's gamma.  The
-   bit_depth of the intermediate (gamma=1.0) representation is probably
-   not sufficient.  In the typical gamma=1/2.2 situation, the linear
-   pixels need about 4 more bits than the gamma-encoded ones, to avoid
-   loss of precision.  A similar situation exists with the rgb_to_gray
-   operation.
-
-   STATUS: under development.
-
-3. September 1999 -- ENHANCEMENT --
-
-   It should be possible to use libpng without floating-point aritmetic.
-
-   STATUS: Under investigation, implementation postponed until after
-   libpng-1.0.4.  The application interface will change because replacements
-   for the png_set_gAMA(), png_set_cHRM(), and corresponding png_get_()
-   functions will be needed.
-

LICENSE

@@ -0,0 +1,111 @@
+
+This copy of the libpng notices is provided for your convenience.  In case of
+any discrepancy between this copy and the notices in the file png.h that is
+included in the libpng distribution, the latter shall prevail.
+
+COPYRIGHT NOTICE, DISCLAIMER, and LICENSE:
+
+If you modify libpng you may insert additional notices immediately following
+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
+distributed according to the same disclaimer and license as libpng-1.2.5
+with the following individual added to the list of Contributing Authors
+
+   Cosmin Truta
+
+libpng versions 1.0.7, July 1, 2000, through 1.2.5 - October 3, 2002, are
+Copyright (c) 2000-2002 Glenn Randers-Pehrson, and are
+distributed according to the same disclaimer and license as libpng-1.0.6
+with the following individuals added to the list of Contributing Authors
+
+   Simon-Pierre Cadieux
+   Eric S. Raymond
+   Gilles Vollant
+
+and with the following additions to the disclaimer:
+
+   There is no warranty against interference with your enjoyment of the
+   library or against infringement.  There is no warranty that our
+   efforts or the library will fulfill any of your particular purposes
+   or needs.  This library is provided with all faults, and the entire
+   risk of satisfactory quality, performance, accuracy, and effort is with
+   the user.
+
+libpng versions 0.97, January 1998, through 1.0.6, March 20, 2000, are
+Copyright (c) 1998, 1999 Glenn Randers-Pehrson, and are
+distributed according to the same disclaimer and license as libpng-0.96,
+with the following individuals added to the list of Contributing Authors:
+
+   Tom Lane
+   Glenn Randers-Pehrson
+   Willem van Schaik
+
+libpng versions 0.89, June 1996, through 0.96, May 1997, are
+Copyright (c) 1996, 1997 Andreas Dilger
+Distributed according to the same disclaimer and license as libpng-0.88,
+with the following individuals added to the list of Contributing Authors:
+
+   John Bowler
+   Kevin Bracey
+   Sam Bushell
+   Magnus Holmgren
+   Greg Roelofs
+   Tom Tanner
+
+libpng versions 0.5, May 1995, through 0.88, January 1996, are
+Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.
+
+For the purposes of this copyright and license, "Contributing Authors"
+is defined as the following set of individuals:
+
+   Andreas Dilger
+   Dave Martindale
+   Guy Eric Schalnat
+   Paul Schmidt
+   Tim Wegner
+
+The PNG Reference Library is supplied "AS IS".  The Contributing Authors
+and Group 42, Inc. disclaim all warranties, expressed or implied,
+including, without limitation, the warranties of merchantability and of
+fitness for any purpose.  The Contributing Authors and Group 42, Inc.
+assume no liability for direct, indirect, incidental, special, exemplary,
+or consequential damages, which may result from the use of the PNG
+Reference Library, even if advised of the possibility of such damage.
+
+Permission is hereby granted to use, copy, modify, and distribute this
+source code, or portions hereof, for any purpose, without fee, subject
+to the following restrictions:
+
+1. The origin of this source code must not be misrepresented.
+
+2. Altered versions must be plainly marked as such and must not
+   be misrepresented as being the original source.
+
+3. This Copyright notice may not be removed or altered from any
+   source or altered source distribution.
+
+The Contributing Authors and Group 42, Inc. specifically permit, without
+fee, and encourage the use of this source code as a component to
+supporting the PNG file format in commercial products.  If you use this
+source code in a product, acknowledgment is not required but would be
+appreciated.
+
+
+A "png_get_copyright" function is available, for convenient use in "about"
+boxes and the like:
+
+   printf("%s",png_get_copyright(NULL));
+
+Also, the PNG logo (in PNG format, of course) is supplied in the
+files "pngbar.png" and "pngbar.jpg (88x31) and "pngnow.png" (98x31).
+
+Libpng is OSI Certified Open Source Software.  OSI Certified Open Source is a
+certification mark of the Open Source Initiative.
+
+Glenn Randers-Pehrson
+glennrp at users.sourceforge.net
+December 26, 2013

Makefile.am

@@ -0,0 +1,333 @@
+# Makefile.am:
+#   Source file for Makefile.in (and hence Makefile)
+#
+
+PNGLIB_BASENAME= libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@
+
+ACLOCAL_AMFLAGS = -I scripts
+
+# test programs - run on make check, make distcheck
+check_PROGRAMS= pngtest pngunknown pngstest pngvalid
+
+# Utilities - installed
+bin_PROGRAMS= pngfix png-fix-itxt
+
+# This ensures that pnglibconf.h gets built at the start of 'make all' or
+# 'make check', but it does not add dependencies to the individual programs,
+# this is done below.
+#
+# IMPORTANT: always add the object modules of new programs to the list below
+# because otherwise the sequence 'configure; make new-program' will *sometimes*
+# result in the installed (system) pnglibconf.h being used and the result is
+# always wrong and always very confusing.
+BUILT_SOURCES = pnglibconf.h
+
+pngtest_SOURCES = pngtest.c
+pngtest_LDADD = libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@.la
+
+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
+
+# 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
+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
+
+if PNG_ARM_NEON
+libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@_la_SOURCES += arm/arm_init.c\
+	arm/filter_neon.S arm/filter_neon_intrinsics.c
+endif
+
+nodist_libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@_la_SOURCES = pnglibconf.h
+
+libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@_la_LDFLAGS = -no-undefined -export-dynamic \
+	-version-number @PNGLIB_MAJOR@@PNGLIB_MINOR@:@PNGLIB_RELEASE@:0
+
+if HAVE_LD_VERSION_SCRIPT
+#   Versioned symbols and restricted exports
+if HAVE_SOLARIS_LD
+  libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@_la_LDFLAGS += -Wl,-M -Wl,libpng.vers
+else
+  libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@_la_LDFLAGS += -Wl,--version-script=libpng.vers
+endif
+
+  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
+
+#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
+
+# 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_DIST= \
+	ANNOUNCE CHANGES INSTALL LICENSE README TODO \
+	pngtest.png pngbar.png pngnow.png pngbar.jpg autogen.sh \
+	${srcdir}/contrib ${srcdir}/projects ${srcdir}/scripts \
+	$(TESTS) $(XFAIL_TESTS) tests/pngstest \
+	CMakeLists.txt example.c libpng-manual.txt
+
+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)
+
+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
+
+pnglibconf.out: config.h
+
+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)
+
+# 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
+
+# do evil things to libpng to cause libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@ to be used
+install-exec-hook:
+	cd '$(DESTDIR)$(bindir)'; rm -f libpng-config
+	cd '$(DESTDIR)$(bindir)';\
+	   $(LN_S) $(PNGLIB_BASENAME)-config libpng-config
+	@set -x;\
+	cd '$(DESTDIR)$(libdir)';\
+	for ext in a la so so.@PNGLIB_MAJOR@@PNGLIB_MINOR@.@PNGLIB_RELEASE@\
+	   sl dylib dll.a; do\
+		rm -f libpng.$$ext;\
+                if test -f $(PNGLIB_BASENAME).$$ext; then\
+                       $(LN_S) $(PNGLIB_BASENAME).$$ext libpng.$$ext;\
+                fi;\
+	done
+
+uninstall-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)

README

@@ -1,14 +1,19 @@
-README for libpng 1.0.4 - September 18, 1999 (shared library 2.1)
+README for libpng version 1.7.0beta25 - December 26, 2013 (shared library 17.0)
 See the note about version numbers near the top of png.h
 
 See INSTALL for instructions on how to install libpng.
 
-This is 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
-extensive use and testing for about two and a half years.  However, it's
-finally gotten to the stage where there haven't been significant
+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.
+
+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
+extensive use and testing since mid-1995.  By late 1997 it had
+finally gotten to the stage where there hadn't been significant
 changes to the API in some time, and people have a bad feeling about
-libraries with versions < 1.0.
+libraries with versions < 1.0.  Version 1.0.0 was released in
+March 1998.
 
 ****
 Note that some of the changes to the png_info structure render this
@@ -28,8 +33,8 @@ directly, to avoid such problems in the future.
 It is important to note that the APIs do not make current programs
 that access the info struct directly incompatible with the new
 library.  However, it is strongly suggested that new programs use
-the new APIs (as shown in example.c), and older programs be converted
-to the new format, to facilitate upgrades in the future.
+the new APIs (as shown in example.c and pngtest.c), and older programs
+be converted to the new format, to facilitate upgrades in the future.
 ****
 
 Additions since 0.90 include the ability to compile libpng as a
@@ -49,10 +54,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 implementation mailing list <png-implement@ccrc.wustl.edu>
-and not on material submitted to Guy.
+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.
 
-For a detailed description on using libpng, read libpng.txt.  For
+For a detailed description on using libpng, read libpng-manual.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
@@ -71,18 +77,15 @@ 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.
-If not, it should be at ftp.uu.net in /graphics/png
-Eventually, it will be at ftp.uu.net in /pub/archiving/zip/zlib
+zlib should be available at the same place that libpng is, or at zlib.net.
 
 You may also want a copy of the PNG specification.  It is available
-as an RFC and a W3C Recommendation.  Failing
-these resources you can try ftp.uu.net in the /graphics/png directory.
+as an RFC, a W3C Recommendation, and an ISO/IEC Standard.  You can find
+these at http://www.libpng.org/pub/png/documents/
 
-This code is currently being archived at ftp.uu.net in the
-/graphics/png directory, 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.
+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.
 
 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,
@@ -96,49 +99,59 @@ 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 group.
+based in a large way on Guy's and Andreas' earlier work), and the PNG
+development group.
 
-randeg@alum.rpi.edu
-png-implement@ccrc.wustl.edu
+Send comments/corrections/commendations to png-mng-implement at
+lists.sourceforge.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-implement list, however.
 
 Please do not send general questions about PNG.  Send them to
-the address in the specification (png-group@w3.org).  At the same
-time, please do not send libpng questions to that address, send them to me
-or to png-implement@ccrc.wustl.edu.  I'll
-get them in the end anyway.  If you have a question about something
+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
 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 three years now, and it is official and
+been discussing PNG for eighteen years now, and it is official and
 finished.  If you have suggestions for libpng, however, I'll
-gladly listen.  Even if your suggestion is not used for version
-1.0, it may be used later.
+gladly listen.  Even if your suggestion is not used immediately,
+it may be used later.
 
 Files in this distribution:
 
+      ANNOUNCE      =>  Announcement of this version, with recent changes
       CHANGES       =>  Description of changes between libpng versions
+      KNOWNBUG      =>  List of known bugs and deficiencies
+      LICENSE       =>  License to use and redistribute libpng
       README        =>  This file
       TODO          =>  Things not implemented in the current library
-      build.bat     =>  MS-DOS batch file for Borland compiler
-      descrip.mms   =>  VMS project file
+      Y2KINFO       =>  Statement of Y2K compliance
       example.c     =>  Example code for using libpng functions
-      libpng.3      =>  manual page for libpng
-      libpng.txt    =>  Description of libpng and its functions
+      libpng.3      =>  manual page for libpng (includes libpng-manual.txt)
+      libpng-manual.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
-      pngconf.h     =>  System specific library configuration
+      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)
       pngerror.c    =>  Error/warning message I/O functions
       pngget.c      =>  Functions for retrieving info from struct
       pngmem.c      =>  Memory handling functions
+      pngbar.png    =>  PNG logo, 88x31
+      pngnow.png    =>  PNG logo, 98x31
       pngpread.c    =>  Progressive reading functions
       pngread.c     =>  Read data/helper high-level functions
       pngrio.c      =>  Lowest-level data read I/O functions
@@ -152,53 +165,38 @@ Files in this distribution:
       pngwrite.c    =>  High-level write functions
       pngwtran.c    =>  Write data transformations
       pngwutil.c    =>  Write utility functions
+      arm           =>  Contains optimized code for the ARM platform
+      contrib       =>  Contributions
+       examples         =>  Example programs
+       gregbook         =>  source code for PNG reading and writing, from
+                            Greg Roelofs' "PNG: The Definitive Guide",
+                            O'Reilly, 1999
+       libtests         =>  Test programs
+       pngminim         =>  Minimal decoder, encoder, and progressive decoder
+                            programs demonstrating use of pngusr.dfa
+       pngminus         =>  Simple pnm2png and png2pnm programs
+       pngsuite         =>  Test images
+       tools            =>  Various tools
+       visupng      =>  Contains a MSVC workspace for VisualPng
+      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
       scripts       =>  Directory containing scripts for building libpng:
-       descrip.mms      =>  VMS makefile for MMS or MMK
-       makefile.std     =>  Generic UNIX makefile
-       makefile.knr     =>  Archaic UNIX Makefile that converts files with
-                            ansi2knr (Requires ansi2knr.c from
-                            ftp://ftp.cs.wisc.edu/ghost)
-       makefile.dec     =>  DEC Alpha UNIX makefile
-       makefile.hpux    =>  HPUX (10.20 and 11.00) makefile
-       makefile.sgi     =>  Silicon Graphics IRIX makefile
-       makefile.sunos   =>  Sun makefile
-       makefile.solaris =>  Solaris 2.X makefile
-                            (gcc, creates libpng.so.2.1.0.4)
-       makefile.linux   =>  Linux/ELF makefile
-                            (gcc, creates libpng.so.2.1.0.4)
-       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.borland =>  Borland makefile
-       build.bat        =>  MS-DOS batch file for Borland compiler
-       makefile.dj2     =>  DJGPP 2 makefile
-       makefile.msc     =>  Microsoft C makefile
-       makefile.win32vc =>  makefile for Microsoft Visual C++ 4.0 and later
-       makefile.turboc3 =>  Turbo C 3.0 makefile
-       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
-       pngdll.mak       =>  To make a png32bd.dll with Borland C++ 4.5
-       pngdef.pas       =>  Defines for a png32bd.dll with Borland C++ 4.5
-       SCOPTIONS.ppc    =>  Used with smakefile.ppc
+                            (see scripts/README.txt for the list of scripts)
 
 Good luck, and happy coding.
 
--Glenn Randers-Pehrson
- Internet: randeg@alum.rpi.edu
- Web: http://www.rpi.edu/~randeg/index.html
+-Glenn Randers-Pehrson (current maintainer, since 1998)
+ Internet: glennrp at users.sourceforge.net
 
--Andreas Eric Dilger
- Internet: adilger@enel.ucalgary.ca
+-Andreas Eric Dilger (former maintainer, 1996-1997)
+ Internet: adilger at enel.ucalgary.ca
  Web: http://www-mddsp.enel.ucalgary.ca/People/adilger/
 
--Guy Eric Schalnat
+-Guy Eric Schalnat (original author and former maintainer, 1995-1996)
  (formerly of Group 42, Inc)
- Internet: gschal@infinet.com
+ Internet: gschal at infinet.com

TODO

@@ -1,14 +1,11 @@
+/*
 TODO - list of things to do for libpng:
 
 Final bug fixes.
-Fix problem with C++ and EXTERN "C".
 Better C++ wrapper/full C++ implementation?
-Keep up with public chunks.
-sPLT chunk handling.
+Fix problem with C++ and EXTERN "C".
 cHRM transformation.
-Support for application-defined chunk handlers.
-Improve setjmp/longjmp usage or remove it in favor of returning error codes.
-High-level API for reading images.
+Remove setjmp/longjmp usage in favor of returning error codes.
 Add "grayscale->palette" transformation and "palette->grayscale" detection.
 Improved dithering.
 Multi-lingual error and warning message support.
@@ -17,8 +14,14 @@ Man pages for function calls.
 Better documentation.
 Better filter selection
    (counting huffman bits/precompression?  filter inertia?  filter costs?).
-Optional palette (sPLT) creation.
 Histogram creation.
 Text conversion between different code pages (Latin-1 -> Mac and DOS).
-Improve API by hiding the info_ptr.
-Make a no-floating-point version.
+Avoid building gamma tables whenever possible.
+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

@@ -1,55 +0,0 @@
-   Y2K compliance in libpng:
-   =========================
-      
-      January 13, 1999
-      
-      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.0.4 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

@@ -0,0 +1,232 @@
+
+/* 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

@@ -0,0 +1,246 @@
+
+/* 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

@@ -0,0 +1,372 @@
+
+/* 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

@@ -0,0 +1,224 @@
+#! /bin/sh
+#
+# 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

compile

@@ -0,0 +1,347 @@
+#! /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:

configure.ac

@@ -0,0 +1,392 @@
+# configure.ac
+
+dnl Process this file with autoconf to produce a configure script.
+dnl
+dnl Minor upgrades (compatible ABI): increment the package version
+dnl (third field in two places below) and set the PNGLIB_RELEASE
+dnl variable.
+dnl
+dnl Major upgrades (incompatible ABI): increment the package major
+dnl version (second field, or first if desired), set the minor
+dnl to 0, set PNGLIB_MAJOR below *and* follow the instructions in
+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])
+
+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
+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_MAJOR=1
+PNGLIB_MINOR=7
+PNGLIB_RELEASE=0
+
+dnl End of version number stuff
+
+AC_CONFIG_SRCDIR([pngget.c])
+AC_CONFIG_HEADERS([config.h])
+
+# Checks for programs.
+AC_LANG([C])
+AC_PROG_CC
+AM_PROG_AS
+LT_PATH_LD
+AC_PROG_CPP
+AC_PROG_AWK
+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],)
+
+# Checks for header files.
+AC_HEADER_STDC
+# Headers used in pngpriv.h:
+AC_CHECK_HEADERS([assert.h stdlib.h string.h float.h fp.h math.h m68881.h])
+# Additional headers used in pngconf.h:
+AC_CHECK_HEADERS([limits.h stddef.h stdio.h setjmp.h time.h])
+# Used by pngread.c (for the simplified API):
+AC_CHECK_HEADERS([errno.h])
+# The following are not required for the standard 'make' build of libpng:
+# Additional requirements of contrib/libtests/makepng.c:
+AC_CHECK_HEADERS([ctype.h])
+# Additional requirements of contrib/libtests/pngvalid.c:
+AC_CHECK_HEADERS([fenv.h])
+
+# Checks for typedefs, structures, and compiler characteristics.
+# Most of these have been removed from 1.7.0 because they checked for non-ANSI-C
+# behaviors and the result were, anyway, not used by earlier versions of libpng.
+AC_C_RESTRICT
+
+# Checks for library functions; these need to be in order, least demanding to
+# most because the -l directives are added to the head of the list at each
+# check.
+# ANSI-C functions: all are required but they don't have to be implemented in
+# libc, it is perfectly ok to configure with an extra, wrapper, library preset
+# in LIBS.  NOTE: this list may not be complete
+AC_CHECK_FUNCS([memset memcpy strncpy],,
+               AC_MSG_FAILURE([missing ANSI-C functions]))
+
+# floor and ceil are required for FLOATING_POINT, but they can be turned off on
+# the configure command line (and they are independent.)  Default is to 'on'
+AC_ARG_ENABLE([floating-point],[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"
+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")
+
+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
+
+if test "$GLD"; then
+    have_ld_version_script=yes
+    AC_MSG_RESULT(yes)
+else
+    have_ld_version_script=no
+    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__::"`
+    AC_SUBST(SYMBOL_PREFIX)
+    AC_MSG_RESULT($SYMBOL_PREFIX)
+fi
+
+# Substitutions for .in files
+AC_SUBST(PNGLIB_VERSION)
+AC_SUBST(PNGLIB_MAJOR)
+AC_SUBST(PNGLIB_MINOR)
+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_SUBST([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_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]])
+
+# Config files, substituting as above
+AC_CONFIG_FILES([Makefile libpng.pc])
+AC_CONFIG_FILES([libpng-config], [chmod +x libpng-config])
+
+AC_OUTPUT

contrib/README.txt

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

contrib/conftest/README

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

@@ -0,0 +1,58 @@
+# 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

@@ -0,0 +1,35 @@
+# 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

@@ -0,0 +1,33 @@
+# 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

@@ -0,0 +1,36 @@
+# 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

@@ -0,0 +1,45 @@
+# 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

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

@@ -0,0 +1,180 @@
+/*- 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

@@ -0,0 +1,368 @@
+/*- 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

@@ -0,0 +1,92 @@
+/*- 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

@@ -0,0 +1,340 @@
+                    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
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+License is intended to guarantee your freedom to share and change free
+software--to make sure the software is free for all its users.  This
+General Public License applies to most of the Free Software
+Foundation's software and to any other program whose authors commit to
+using it.  (Some other Free Software Foundation software is covered by
+the GNU Library General Public License instead.)  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+this service if you wish), that you receive source code or can get it
+if you want it, that you can change the software or use pieces of it
+in new free programs; and that you know you can do these things.
+
+  To protect your rights, we need to make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if you
+distribute copies of the software, or if you modify it.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must give the recipients all the rights that
+you have.  You must make sure that they, too, receive or can get the
+source code.  And you must show them these terms so they know their
+rights.
+
+  We protect your rights with two steps: (1) copyright the software, and
+(2) offer you this license which gives you legal permission to copy,
+distribute and/or modify the software.
+
+  Also, for each author's protection and ours, we want to make certain
+that everyone understands that there is no warranty for this free
+software.  If the software is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original, so
+that any problems introduced by others will not reflect on the original
+authors' reputations.
+
+  Finally, any free program is threatened constantly by software
+patents.  We wish to avoid the danger that redistributors of a free
+program will individually obtain patent licenses, in effect making the
+program proprietary.  To prevent this, we have made it clear that any
+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
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License applies to any program or other work which contains
+a notice placed by the copyright holder saying it may be distributed
+under the terms of this General Public License.  The "Program", below,
+refers to any such program or work, and a "work based on the Program"
+means either the Program or any derivative work under copyright law:
+that is to say, a work containing the Program or a portion of it,
+either verbatim or with modifications and/or translated into another
+language.  (Hereinafter, translation is included without limitation in
+the term "modification".)  Each licensee is addressed as "you".
+
+Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running the Program is not restricted, and the output from the Program
+is covered only if its contents constitute a work based on the
+Program (independent of having been made by running the Program).
+Whether that is true depends on what the Program does.
+
+  1. You may copy and distribute verbatim copies of the Program's
+source code as you receive it, in any medium, provided that you
+conspicuously and appropriately publish on each copy an appropriate
+copyright notice and disclaimer of warranty; keep intact all the
+notices that refer to this License and to the absence of any warranty;
+and give any other recipients of the Program a copy of this License
+along with the Program.
+
+You may charge a fee for the physical act of transferring a copy, and
+you may at your option offer warranty protection in exchange for a fee.
+
+  2. You may modify your copy or copies of the Program or any portion
+of it, thus forming a work based on the Program, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) You must cause the modified files to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    b) You must cause any work that you distribute or publish, that in
+    whole or in part contains or is derived from the Program or any
+    part thereof, to be licensed as a whole at no charge to all third
+    parties under the terms of this License.
+
+    c) If the modified program normally reads commands interactively
+    when run, you must cause it, when started running for such
+    interactive use in the most ordinary way, to print or display an
+    announcement including an appropriate copyright notice and a
+    notice that there is no warranty (or else, saying that you provide
+    a warranty) and that users may redistribute the program under
+    these conditions, and telling the user how to view a copy of this
+    License.  (Exception: if the Program itself is interactive but
+    does not normally print such an announcement, your work based on
+    the Program is not required to print an announcement.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Program,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Program, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Program.
+
+In addition, mere aggregation of another work not based on the Program
+with the Program (or with a work based on the Program) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may copy and distribute the Program (or a work based on it,
+under Section 2) in object code or executable form under the terms of
+Sections 1 and 2 above provided that you also do one of the following:
+
+    a) Accompany it with the complete corresponding machine-readable
+    source code, which must be distributed under the terms of Sections
+    1 and 2 above on a medium customarily used for software interchange; or,
+
+    b) Accompany it with a written offer, valid for at least three
+    years, to give any third party, for a charge no more than your
+    cost of physically performing source distribution, a complete
+    machine-readable copy of the corresponding source code, to be
+    distributed under the terms of Sections 1 and 2 above on a medium
+    customarily used for software interchange; or,
+
+    c) Accompany it with the information you received as to the offer
+    to distribute corresponding source code.  (This alternative is
+    allowed only for noncommercial distribution and only if you
+    received the program in object code or executable form with such
+    an offer, in accord with Subsection b above.)
+
+The source code for a work means the preferred form of the work for
+making modifications to it.  For an executable work, complete source
+code means all the source code for all modules it contains, plus any
+associated interface definition files, plus the scripts used to
+control compilation and installation of the executable.  However, as a
+special exception, the source code distributed need not include
+anything that is normally distributed (in either source or binary
+form) with the major components (compiler, kernel, and so on) of the
+operating system on which the executable runs, unless that component
+itself accompanies the executable.
+
+If distribution of executable or object code is made by offering
+access to copy from a designated place, then offering equivalent
+access to copy the source code from the same place counts as
+distribution of the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  4. You may not copy, modify, sublicense, or distribute the Program
+except as expressly provided under this License.  Any attempt
+otherwise to copy, modify, sublicense or distribute the Program is
+void, and will automatically terminate your rights under this License.
+However, parties who have received copies, or rights, from you under
+this License will not have their licenses terminated so long as such
+parties remain in full compliance.
+
+  5. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Program or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Program (or any work based on the
+Program), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Program or works based on it.
+
+  6. Each time you redistribute the Program (or any work based on the
+Program), the recipient automatically receives a license from the
+original licensor to copy, distribute or modify the Program subject to
+these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties to
+this License.
+
+  7. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Program at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Program by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Program.
+
+If any portion of this section is held invalid or unenforceable under
+any particular circumstance, the balance of the section is intended to
+apply and the section as a whole is intended to apply in other
+circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system, which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  8. If the distribution and/or use of the Program is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Program under this License
+may add an explicit geographical distribution limitation excluding
+those countries, so that distribution is permitted only in or among
+countries not thus excluded.  In such case, this License incorporates
+the limitation as if written in the body of this License.
+
+  9. The Free Software Foundation may publish revised and/or new versions
+of the General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Program
+specifies a version number of this License which applies to it and "any
+later version", you have the option of following the terms and conditions
+either of that version or of any later version published by the Free
+Software Foundation.  If the Program does not specify a version number of
+this License, you may choose any version ever published by the Free Software
+Foundation.
+
+  10. If you wish to incorporate parts of the Program into other free
+programs whose distribution conditions are different, write to the author
+to ask for permission.  For software which is copyrighted by the Free
+Software Foundation, write to the Free Software Foundation; we sometimes
+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
+
+  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
+OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
+PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
+OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
+TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
+PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
+REPAIR OR CORRECTION.
+
+  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
+REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
+INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
+OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
+TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
+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
+
+            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
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    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 of the License, 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, write to the Free Software
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+
+Also add information on how to contact you by electronic and paper mail.
+
+If the program is interactive, make it output a short notice like this
+when it starts in an interactive mode:
+
+    Gnomovision version 69, Copyright (C) year  name of author
+    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, the commands you use may
+be called something other than `show w' and `show c'; they could even be
+mouse-clicks or menu items--whatever suits your program.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the program, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
+  `Gnomovision' (which makes passes at compilers) written by James Hacker.
+
+  <signature of Ty Coon>, 1 April 1989
+  Ty Coon, President of Vice
+
+This General Public License does not permit incorporating your program into
+proprietary programs.  If your program is a subroutine library, you may
+consider it more useful to permit linking proprietary applications with the
+library.  If this is what you want to do, use the GNU Library General
+Public License instead of this License.

contrib/gregbook/LICENSE

@@ -0,0 +1,50 @@
+  ---------------------------------------------------------------------------
+
+      Copyright (c) 1998-2008 Greg Roelofs.  All rights reserved.
+
+      This software is provided "as is," without warranty of any kind,
+      express or implied.  In no event shall the author or contributors
+      be held liable for any damages arising in any way from the use of
+      this software.
+
+      The contents of this file are DUAL-LICENSED.  You may modify and/or
+      redistribute this software according to the terms of one of the
+      following two licenses (at your option):
+
+
+      LICENSE 1 ("BSD-like with advertising clause"):
+
+      Permission is granted to anyone to use this software for any purpose,
+      including commercial applications, and to alter it and redistribute
+      it freely, subject to the following restrictions:
+
+      1. Redistributions of source code must retain the above copyright
+         notice, disclaimer, and this list of conditions.
+      2. Redistributions in binary form must reproduce the above copyright
+         notice, disclaimer, and this list of conditions in the documenta-
+         tion and/or other materials provided with the distribution.
+      3. All advertising materials mentioning features or use of this
+         software must display the following acknowledgment:
+
+            This product includes software developed by Greg Roelofs
+            and contributors for the book, "PNG: The Definitive Guide,"
+            published by O'Reilly and Associates.
+
+
+      LICENSE 2 (GNU GPL v2 or later):
+
+      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 of the License, 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, write to the Free Software Foundation,
+      Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+  ---------------------------------------------------------------------------

contrib/gregbook/Makefile.mingw32

@@ -0,0 +1,130 @@
+# Sample makefile for rpng-win / rpng2-win / wpng using mingw32-gcc and make.
+# Greg Roelofs
+# Last modified:  2 June 2007
+#
+#	The programs built by this makefile are described in the book,
+#	"PNG:  The Definitive Guide," by Greg Roelofs (O'Reilly and
+#	Associates, 1999).  Go buy a copy, eh?  Well, OK, it's not
+#	generally for sale anymore, but it's the thought that counts,
+#	right?  (Hint:  http://www.libpng.org/pub/png/book/ )
+#
+# Invoke this makefile from a DOS-prompt window via:
+#
+#	make -f Makefile.mingw32
+#
+# 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 PNGDIR and ZDIR macros below).  It makes no assumptions
+# at all about the mingw32 installation tree (W32DIR).  Edit as appropriate.
+#
+# Note that the names of the dynamic and static libpng and zlib libraries
+# used below may change in later releases of the libraries.  This makefile
+# builds both statically and dynamically linked executables by default.
+# (You need only one set, but for testing it can be handy to have both.)
+
+
+# macros --------------------------------------------------------------------
+
+#PNGDIR = ../..#		for libpng-x.y.z/contrib/gregbook builds
+PNGDIR = ../libpng-win32
+PNGINC = -I$(PNGDIR)
+PNGLIBd = $(PNGDIR)/libpng.dll.a	# dynamically linked
+PNGLIBs = $(PNGDIR)/libpng.a		# statically linked, local libpng
+
+#ZDIR = ../../../zlib-win32#	for libpng-x.y.z/contrib/gregbook builds
+ZDIR = ../zlib-win32
+ZINC = -I$(ZDIR)
+ZLIBd = $(ZDIR)/libzdll.a
+ZLIBs = $(ZDIR)/libz.a
+
+# change this to be the path where mingw32 installs its stuff:
+W32DIR =
+#W32DIR = /usr/local/cross-tools/i386-mingw32msvc
+W32INC = -I$(W32DIR)/include
+W32LIB = $(W32DIR)/lib/libuser32.a $(W32DIR)/lib/libgdi32.a
+
+CC = gcc
+#CC = i386-mingw32msvc-gcc #	e.g., Linux -> Win32 cross-compilation
+LD = $(CC)
+RM = rm -f
+CFLAGS = -O -Wall $(INCS) $(MINGW_CCFLAGS)
+# [note that -Wall is a gcc-specific compilation flag ("most warnings on")]
+# [-ansi, -pedantic and -W can also be used]
+LDFLAGS = $(MINGW_LDFLAGS)
+O = .o
+E = .exe
+
+INCS = $(PNGINC) $(ZINC) $(W32INC)
+RLIBSd = $(PNGLIBd) $(ZLIBd) $(W32LIB) -lm
+RLIBSs = $(PNGLIBs) $(ZLIBs) $(W32LIB) -lm
+WLIBSd = $(PNGLIBd) $(ZLIBd)
+WLIBSs = $(PNGLIBs) $(ZLIBs)
+
+RPNG   = rpng-win
+RPNG2  = rpng2-win
+WPNG   = wpng
+
+ROBJSd  = $(RPNG)$(O) readpng.pic$(O)
+ROBJS2d = $(RPNG2)$(O) readpng2.pic$(O)
+WOBJSd  = $(WPNG)$(O) writepng.pic$(O)
+
+RPNGs  = $(RPNG)-static
+RPNG2s = $(RPNG2)-static
+WPNGs  = $(WPNG)-static
+
+ROBJSs  = $(RPNG)$(O) readpng$(O)
+ROBJS2s = $(RPNG2)$(O) readpng2$(O)
+WOBJSs  = $(WPNG)$(O) writepng$(O)
+
+STATIC_EXES  = $(RPNGs)$(E) $(RPNG2s)$(E) $(WPNGs)$(E)
+DYNAMIC_EXES = $(RPNG)$(E) $(RPNG2)$(E) $(WPNG)$(E)
+
+EXES = $(STATIC_EXES) $(DYNAMIC_EXES)
+
+
+# implicit make rules -------------------------------------------------------
+
+.c$(O):
+	$(CC) -c $(CFLAGS) $<
+
+%.pic$(O): %.c
+	$(CC) -c $(CFLAGS) -DPNG_BUILD_DLL -o $@ $<
+
+
+# dependencies --------------------------------------------------------------
+
+all:  $(EXES)
+
+$(RPNGs)$(E): $(ROBJSs)
+	$(LD) $(LDFLAGS) -o $@ $(ROBJSs) $(RLIBSs)
+
+$(RPNG)$(E): $(ROBJSd)
+	$(LD) $(LDFLAGS) -o $@ $(ROBJSd) $(RLIBSd)
+
+$(RPNG2s)$(E): $(ROBJS2s)
+	$(LD) $(LDFLAGS) -o $@ $(ROBJS2s) $(RLIBSs)
+
+$(RPNG2)$(E): $(ROBJS2d)
+	$(LD) $(LDFLAGS) -o $@ $(ROBJS2d) $(RLIBSd)
+
+$(WPNGs)$(E): $(WOBJSs)
+	$(LD) $(LDFLAGS) -o $@ $(WOBJSs) $(WLIBSs)
+
+$(WPNG)$(E): $(WOBJSd)
+	$(LD) $(LDFLAGS) -o $@ $(WOBJSd) $(WLIBSd)
+
+$(RPNG)$(O):	$(RPNG).c readpng.h
+$(RPNG2)$(O):	$(RPNG2).c readpng2.h
+$(WPNG)$(O):	$(WPNG).c writepng.h
+
+readpng$(O) readpng.pic$(O):	readpng.c readpng.h
+readpng2$(O) readpng2.pic$(O):	readpng2.c readpng2.h
+writepng$(O) writepng.pic$(O):	writepng.c writepng.h
+
+
+# maintenance ---------------------------------------------------------------
+
+clean:
+	$(RM) $(EXES)
+	$(RM) $(ROBJSs) $(ROBJS2s) $(WOBJSs)
+	$(RM) $(ROBJSd) $(ROBJS2d) $(WOBJSd)

contrib/gregbook/Makefile.sgi

@@ -0,0 +1,104 @@
+# Sample makefile for rpng-x / rpng2-x / wpng for SGI using cc and make.
+# Greg Roelofs
+# Last modified:  7 March 2002
+#
+#	The programs built by this makefile are described in the book,
+#	"PNG:  The Definitive Guide," by Greg Roelofs (O'Reilly and
+#	Associates, 1999).  Go buy a copy, eh?  Buy some for friends
+#	and family, too.  (Not that this is a blatant plug or anything.)
+#
+# Invoke this makefile from a shell prompt in the usual way; for example:
+#
+#	make -f Makefile.sgi
+#
+# This makefile assumes libpng and zlib have already been built or downloaded
+# and are both installed in /usr/local/{include,lib} (as indicated by the
+# PNG* and Z* macros below).  Edit as appropriate--choose only ONE each of
+# the PNGINC, PNGLIB, ZINC and ZLIB lines.
+#
+# This makefile builds dynamically linked executables (against libpng and zlib,
+# that is), but that can be changed by uncommenting the appropriate PNGLIB and
+# ZLIB lines.
+
+
+# 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
+# or:
+#PNGINC = -I../..
+#PNGLIB = -L../.. -lpng
+#PNGLIB = ../../libpng.a
+
+ZINC = -I/usr/local/include
+ZLIB = -L/usr/local/lib -lz		# dynamically linked against zlib
+#ZLIB = /usr/local/lib/libz.a		# statically linked against zlib
+#ZINC = -I../zlib
+#ZLIB = -L../zlib -lz
+#ZLIB = ../../../zlib/libz.a
+
+XINC = -I/usr/include/X11		# old-style, stock X distributions
+XLIB = -L/usr/lib/X11 -lX11
+#XINC = -I/usr/openwin/include    	# Sun workstations (OpenWindows)
+#XLIB = -L/usr/openwin/lib -lX11
+#XINC = -I/usr/X11R6/include		# new X distributions (XFree86, etc.)
+#XLIB = -L/usr/X11R6/lib -lX11
+
+INCS = $(PNGINC) $(ZINC) $(XINC)
+RLIBS = $(PNGLIB) $(ZLIB) $(XLIB) -lm
+WLIBS = $(PNGLIB) $(ZLIB)
+
+CC = cc
+LD = cc
+RM = rm -f
+# ABI must be the same as that used to build libpng.
+ABI=
+CFLAGS = $(ABI) -O -fullwarn $(INCS)
+LDFLAGS = $(ABI)
+O = .o
+E =
+
+RPNG  = rpng-x
+RPNG2 = rpng2-x
+WPNG  = wpng
+
+ROBJS  = $(RPNG)$(O) readpng$(O)
+ROBJS2 = $(RPNG2)$(O) readpng2$(O)
+WOBJS  = $(WPNG)$(O) writepng$(O)
+
+EXES = $(RPNG)$(E) $(RPNG2)$(E) $(WPNG)$(E)
+
+
+# implicit make rules -------------------------------------------------------
+
+.c$(O):
+	$(CC) -c $(CFLAGS) $<
+
+
+# dependencies --------------------------------------------------------------
+
+all:  $(EXES)
+
+$(RPNG)$(E): $(ROBJS)
+	$(LD) $(LDFLAGS) -o $@ $(ROBJS) $(RLIBS)
+
+$(RPNG2)$(E): $(ROBJS2)
+	$(LD) $(LDFLAGS) -o $@ $(ROBJS2) $(RLIBS)
+
+$(WPNG)$(E): $(WOBJS)
+	$(LD) $(LDFLAGS) -o $@ $(WOBJS) $(WLIBS)
+
+$(RPNG)$(O):	$(RPNG).c readpng.h
+$(RPNG2)$(O):	$(RPNG2).c readpng2.h
+$(WPNG)$(O):	$(WPNG).c writepng.h
+
+readpng$(O):	readpng.c readpng.h
+readpng2$(O):	readpng2.c readpng2.h
+writepng$(O):	writepng.c writepng.h
+
+
+# maintenance ---------------------------------------------------------------
+
+clean:
+	$(RM) $(EXES) $(ROBJS) $(ROBJS2) $(WOBJS)

contrib/gregbook/Makefile.unx

@@ -0,0 +1,132 @@
+# Sample makefile for rpng-x / rpng2-x / wpng using gcc and make.
+# Greg Roelofs
+# Last modified:  2 June 2007
+#
+#	The programs built by this makefile are described in the book,
+#	"PNG:  The Definitive Guide," by Greg Roelofs (O'Reilly and
+#	Associates, 1999).  Go buy a copy, eh?  Well, OK, it's not
+#	generally for sale anymore, but it's the thought that counts,
+#	right?  (Hint:  http://www.libpng.org/pub/png/book/ )
+#
+# Invoke this makefile from a shell prompt in the usual way; for example:
+#
+#	make -f Makefile.unx
+#
+# This makefile assumes libpng and zlib have already been built or downloaded
+# and are installed in /usr/local/{include,lib} or as otherwise indicated by
+# the PNG* and Z* macros below.  Edit as appropriate--choose only ONE each of
+# the PNGINC, PNGLIBd, PNGLIBs, ZINC, ZLIBd and ZLIBs lines.
+#
+# This makefile builds both dynamically and statically linked executables
+# (against libpng and zlib, that is), but that can be changed by modifying
+# the "EXES =" line.  (You need only one set, but for testing it can be handy
+# to have both.)
+
+
+# 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
+# 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
+PNGLIBs = $(PNGDIR)/libpng.a		# statically linked, local libpng
+
+ZDIR = /usr/local/lib
+#ZDIR = /usr/lib64
+ZINC = -I/usr/local/include
+ZLIBd = -L$(ZDIR) -lz			# dynamically linked against zlib
+ZLIBs = $(ZDIR)/libz.a			# statically linked against zlib
+# or:
+#ZDIR = ../zlib
+#ZINC = -I$(ZDIR)
+#ZLIBd = -Wl,-rpath,$(ZDIR) -L$(ZDIR) -lz  # -rpath allows in-place testing
+#ZLIBs = $(ZDIR)/libz.a
+
+#XINC = -I/usr/include			# old-style, stock X distributions
+#XLIB = -L/usr/lib/X11 -lX11		#  (including SGI IRIX)
+#XINC = -I/usr/openwin/include		# Sun workstations (OpenWindows)
+#XLIB = -L/usr/openwin/lib -lX11
+XINC = -I/usr/X11R6/include		# new X distributions (X.org, etc.)
+XLIB = -L/usr/X11R6/lib -lX11
+#XLIB = -L/usr/X11R6/lib64 -lX11	# e.g., Red Hat on AMD64
+
+INCS = $(PNGINC) $(ZINC) $(XINC)
+RLIBSd = $(PNGLIBd) $(ZLIBd) $(XLIB) -lm
+RLIBSs = $(PNGLIBs) $(ZLIBs) $(XLIB) -lm
+WLIBSd = $(PNGLIBd) $(ZLIBd) -lm
+WLIBSs = $(PNGLIBs) $(ZLIBs)
+
+CC = gcc
+LD = gcc
+RM = rm -f
+CFLAGS = -O -Wall $(INCS) -DFEATURE_LOOP
+# [note that -Wall is a gcc-specific compilation flag ("most warnings on")]
+# [-ansi, -pedantic and -W can also be used]
+LDFLAGS =
+O = .o
+E =
+
+RPNG   = rpng-x
+RPNG2  = rpng2-x
+WPNG   = wpng
+
+RPNGs  = $(RPNG)-static
+RPNG2s = $(RPNG2)-static
+WPNGs  = $(WPNG)-static
+
+ROBJS  = $(RPNG)$(O) readpng$(O)
+ROBJS2 = $(RPNG2)$(O) readpng2$(O)
+WOBJS  = $(WPNG)$(O) writepng$(O)
+
+STATIC_EXES  = $(RPNGs)$(E) $(RPNG2s)$(E) $(WPNGs)$(E)
+DYNAMIC_EXES = $(RPNG)$(E) $(RPNG2)$(E) $(WPNG)$(E)
+
+EXES = $(STATIC_EXES) $(DYNAMIC_EXES)
+
+
+# implicit make rules -------------------------------------------------------
+
+.c$(O):
+	$(CC) -c $(CFLAGS) $<
+
+
+# dependencies --------------------------------------------------------------
+
+all:  $(EXES)
+
+$(RPNGs)$(E): $(ROBJS)
+	$(LD) $(LDFLAGS) -o $@ $(ROBJS) $(RLIBSs)
+
+$(RPNG)$(E): $(ROBJS)
+	$(LD) $(LDFLAGS) -o $@ $(ROBJS) $(RLIBSd)
+
+$(RPNG2s)$(E): $(ROBJS2)
+	$(LD) $(LDFLAGS) -o $@ $(ROBJS2) $(RLIBSs)
+
+$(RPNG2)$(E): $(ROBJS2)
+	$(LD) $(LDFLAGS) -o $@ $(ROBJS2) $(RLIBSd)
+
+$(WPNGs)$(E): $(WOBJS)
+	$(LD) $(LDFLAGS) -o $@ $(WOBJS) $(WLIBSs)
+
+$(WPNG)$(E): $(WOBJS)
+	$(LD) $(LDFLAGS) -o $@ $(WOBJS) $(WLIBSd)
+
+$(RPNG)$(O):	$(RPNG).c readpng.h
+$(RPNG2)$(O):	$(RPNG2).c readpng2.h
+$(WPNG)$(O):	$(WPNG).c writepng.h
+
+readpng$(O):	readpng.c readpng.h
+readpng2$(O):	readpng2.c readpng2.h
+writepng$(O):	writepng.c writepng.h
+
+
+# maintenance ---------------------------------------------------------------
+
+clean:
+	$(RM) $(EXES) $(ROBJS) $(ROBJS2) $(WOBJS)

contrib/gregbook/Makefile.w32

@@ -0,0 +1,113 @@
+# Sample makefile for rpng-win / rpng2-win / wpng using MSVC and NMAKE.
+# Greg Roelofs
+# Last modified:  2 June 2007
+#
+#	The programs built by this makefile are described in the book,
+#	"PNG:  The Definitive Guide," by Greg Roelofs (O'Reilly and
+#	Associates, 1999).  Go buy a copy, eh?  Well, OK, it's not
+#	generally for sale anymore, but it's the thought that counts,
+#	right?  (Hint:  http://www.libpng.org/pub/png/book/ )
+#
+# Invoke this makefile from a DOS prompt window via:
+#
+#	%devstudio%\vc\bin\vcvars32.bat
+#	nmake -nologo -f Makefile.w32
+#
+# where %devstudio% is the installation directory for MSVC / DevStudio.  If
+# you get "environment out of space" errors, create a desktop shortcut with
+# "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.
+#
+# Note that the names of the dynamic and static libpng and zlib libraries
+# used below may change in later releases of the libraries.  This makefile
+# builds statically linked executables, but that can be changed by uncom-
+# menting the appropriate PNGLIB and ZLIB lines.
+
+!include <ntwin32.mak>
+
+
+# macros --------------------------------------------------------------------
+
+PNGPATH = ../libpng
+PNGINC = -I$(PNGPATH)
+#PNGLIB = $(PNGPATH)/pngdll.lib
+PNGLIB = $(PNGPATH)/libpng.lib
+
+ZPATH = ../zlib
+ZINC = -I$(ZPATH)
+#ZLIB = $(ZPATH)/zlibdll.lib
+ZLIB = $(ZPATH)/zlibstat.lib
+
+WINLIBS = -defaultlib:user32.lib gdi32.lib
+# ["real" apps may also need comctl32.lib, comdlg32.lib, winmm.lib, etc.]
+
+INCS = $(PNGINC) $(ZINC)
+RLIBS = $(PNGLIB) $(ZLIB) $(WINLIBS)
+WLIBS = $(PNGLIB) $(ZLIB)
+
+CC = cl
+LD = link
+RM = del
+CFLAGS = -nologo -O -W3 $(INCS) $(cvars)
+# [note that -W3 is an MSVC-specific compilation flag ("all warnings on")]
+# [see %devstudio%\vc\include\win32.mak for cvars macro definition]
+O = .obj
+E = .exe
+
+RLDFLAGS = -nologo -subsystem:windows
+WLDFLAGS = -nologo
+
+RPNG  = rpng-win
+RPNG2 = rpng2-win
+WPNG  = wpng
+
+ROBJS  = $(RPNG)$(O) readpng$(O)
+ROBJS2 = $(RPNG2)$(O) readpng2$(O)
+WOBJS  = $(WPNG)$(O) writepng$(O)
+
+EXES = $(RPNG)$(E) $(RPNG2)$(E) $(WPNG)$(E)
+
+
+# implicit make rules -------------------------------------------------------
+
+.c$(O):
+	$(CC) -c $(CFLAGS) $<
+
+
+# dependencies --------------------------------------------------------------
+
+all:  $(EXES)
+
+$(RPNG)$(E): $(ROBJS)
+	$(LD) $(RLDFLAGS) -out:$@ $(ROBJS) $(RLIBS)
+
+$(RPNG2)$(E): $(ROBJS2)
+	$(LD) $(RLDFLAGS) -out:$@ $(ROBJS2) $(RLIBS)
+
+$(WPNG)$(E): $(WOBJS)
+	$(LD) $(WLDFLAGS) -out:$@ $(WOBJS) $(WLIBS)
+
+$(RPNG)$(O):	$(RPNG).c readpng.h
+$(RPNG2)$(O):	$(RPNG2).c readpng2.h
+$(WPNG)$(O):	$(WPNG).c writepng.h
+
+readpng$(O):	readpng.c readpng.h
+readpng2$(O):	readpng2.c readpng2.h
+writepng$(O):	writepng.c writepng.h
+
+
+# maintenance ---------------------------------------------------------------
+
+clean:
+#	ideally we could just do this:
+#	$(RM) $(EXES) $(ROBJS) $(ROBJS2) $(WOBJS)
+#	...but the Windows "DEL" command is none too bright, so:
+	$(RM) r*$(E)
+	$(RM) w*$(E)
+	$(RM) r*$(O)
+	$(RM) w*$(O)

contrib/gregbook/README

@@ -0,0 +1,186 @@
+                     ===========================
+                      PNG: The Definitive Guide
+                     ===========================
+
+                             Source Code
+
+Chapters 13, 14 and 15 of "PNG: The Definitive Guide" discuss three free,
+cross-platform demo programs that show how to use the libpng reference
+library:  rpng, rpng2 and wpng.  rpng and rpng2 are viewers; the first is
+a very simple example that that shows how a standard file-viewer might use
+libpng, while the second is designed to process streaming data and shows
+how a web browser might be written.  wpng is a simple command-line program
+that reads binary PGM and PPM files (the ``raw'' grayscale and RGB subsets
+of PBMPLUS/NetPBM) and converts them to PNG.
+
+The source code for all three demo programs currently compiles under
+Unix, OpenVMS, and 32-bit Windows.  (Special thanks to Martin Zinser,
+zinser@decus.de, for making the necessary changes for OpenVMS and for
+providing an appropriate build script.)  Build instructions can be found
+below.
+
+Files:
+
+   README             this file
+   LICENSE            terms of distribution and reuse (BSD-like or GNU GPL)
+   COPYING            GNU General Public License (GPL)
+
+   Makefile.unx       Unix makefile
+   Makefile.w32       Windows (MSVC) makefile
+   makevms.com        OpenVMS build script
+
+   rpng-win.c         Windows front end for the basic viewer
+   rpng-x.c           X Window System (Unix, OpenVMS) front end
+   readpng.c          generic back end for the basic viewer
+   readpng.h          header file for the basic viewer
+
+   rpng2-win.c        Windows front end for the progressive viewer
+   rpng2-x.c          X front end for the progressive viewer
+   readpng2.c         generic back end for the progressive viewer
+   readpng2.h         header file for the progressive viewer
+
+   wpng.c             generic (text) front end for the converter
+   writepng.c         generic back end for the converter
+   writepng.h         header file for the converter
+
+   toucan.png         transparent PNG for testing (by Stefan Schneider)
+
+Note that, although the programs are designed to be functional, their
+primary purpose is to illustrate how to use libpng to add PNG support to
+other programs.  As such, their user interfaces are crude and definitely
+are not intended for everyday use.
+
+Please see http://www.libpng.org/pub/png/pngbook.html for further infor-
+mation and links to the latest version of the source code, and Chapters
+13-15 of the book for detailed discussion of the three programs.
+
+Greg Roelofs
+http://pobox.com/~newt/greg_contact.html
+16 March 2008
+
+
+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
+
+     The pngbook demo programs are explicitly designed to demonstrate proper
+     coding techniques for using the libpng reference library.  As a result,
+     you need to download and build both zlib (on which libpng depends) and
+     libpng.  A common build setup is to place the zlib, libpng and pngbook
+     subdirectory trees ("folders") in the same parent directory.  Then the
+     libpng build can refer to files in ../zlib (or ..\zlib or [-.zlib]),
+     and similarly for the pngbook build.
+
+     Note that all three packages are designed to be built from a command
+     line by default; those who wish to use a graphical or other integrated
+     development environments are on their own.
+
+
+ - Unix:
+
+     Unpack the latest pngbook sources (which should correspond to this
+     README file) into a directory and change into that directory.
+
+     Copy Makefile.unx to Makefile and edit the PNG* and Z* variables
+     appropriately (possibly also the X* variables if necessary).
+
+     make
+
+     There is no "install" target, so copy the three executables somewhere
+     in your path or run them from the current directory.  All three will
+     print a basic usage screen when run without any command-line arguments;
+     see the book for more details.
+
+
+ - Windows:
+
+     Unpack the latest pngbook sources (which should correspond to this
+     README file) into a folder, open a "DOS shell" or "command prompt"
+     or equivalent command-line window, and cd into the folder where you
+     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 /
+     DevStudio.  If you get "environment out of space" errors under 95/98,
+     create a desktop shortcut with "c:\windows\command.com /e:4096" as
+     the program command line and set the working directory to the pngbook
+     directory.  Then double-click to open the new DOS-prompt window with
+     a bigger environment and retry the commands above.
+
+     Copy Makefile.w32 to Makefile and edit the PNGPATH and ZPATH variables
+     appropriately (possibly also the "INC" and "LIB" variables if needed).
+     Note that the names of the dynamic and static libpng and zlib libraries
+     used in the makefile may change in later releases of the libraries.
+     Also note that, as of libpng version 1.0.5, MSVC DLL builds do not work.
+     This makefile therefore builds statically linked executables, but if
+     the DLL problems ever get fixed, uncommenting the appropriate PNGLIB
+     and ZLIB lines will build dynamically linked executables instead.
+
+     Do the build by typing
+
+        nmake
+
+     The result should be three executables:  rpng-win.exe, rpng2-win.exe,
+     and wpng.exe.  Copy them somewhere in your PATH or run them from the
+     current folder.  Like the Unix versions, the two windowed programs
+     (rpng and rpng2) now display a usage screen in a console window when
+     invoked without command-line arguments; this is new behavior as of
+     the June 2001 release.  Note that the programs use the Unix-style "-"
+     character to specify options, instead of the more common DOS/Windows
+     "/" character.  (For example:  "rpng2-win -bgpat 4 foo.png", not
+     "rpng2-win /bgpat 4 foo.png")
+
+
+ - OpenVMS:
+
+     Unpack the pngbook sources into a subdirectory and change into that
+     subdirectory.
+
+     Edit makevms.com appropriately, specifically the zpath and pngpath
+     variables.
+
+     @makevms
+
+     To run the programs, they probably first need to be set up as "foreign
+     symbols," with "disk" and "dir" set appropriately:
+
+     $ rpng  == "$disk:[dir]rpng-x.exe"
+     $ rpng2 == "$disk:[dir]rpng2-x.exe"
+     $ wpng  == "$disk:[dir]wpng.exe"
+
+     All three will print a basic usage screen when run without any command-
+     line arguments; see the book for more details.  Note that the options
+     style is Unix-like, i.e., preceded by "-" rather than "/".
+
+
+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
+
+     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
+
+     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
+
+     would convert the specified PPM file (using redirection) to PNG, auto-
+     matically setting the PNG modification-time chunk.
+
+     All options can be abbreviated to the shortest unique value; for example,
+     "-bgc" for -bgcolor (versus "-bgp" for -bgpat), or "-g" for -gamma.

contrib/gregbook/makevms.com

@@ -0,0 +1,132 @@
+$!------------------------------------------------------------------------------
+$! make "PNG: The Definitive Guide" demo programs (for X) under OpenVMS
+$!
+$! Script created by Martin Zinser for libpng; modified by Greg Roelofs
+$! for standalone pngbook source distribution.
+$!
+$!
+$!    Set locations where zlib and libpng sources live.
+$!
+$ zpath   = ""
+$ pngpath = ""
+$!
+$ if f$search("[---.zlib]zlib.h").nes."" then zpath = "[---.zlib]"
+$ if f$search("[--]png.h").nes."" then pngpath = "[--]"
+$!
+$ if f$search("[-.zlib]zlib.h").nes."" then zpath = "[-.zlib]"
+$ if f$search("[-.libpng]png.h").nes."" then pngpath = "[-.libpng]"
+$!
+$ if zpath .eqs. ""
+$ then
+$   write sys$output "zlib include not found. Exiting..."
+$   exit 2
+$ endif
+$!
+$ if pngpath .eqs. ""
+$ then
+$   write sys$output "libpng include not found. Exiting..."
+$   exit 2
+$ endif
+$!
+$!    Look for the compiler used.
+$!
+$ ccopt="/include=(''zpath',''pngpath')"
+$ if f$getsyi("HW_MODEL").ge.1024
+$ then
+$  ccopt = "/prefix=all"+ccopt
+$  comp  = "__decc__=1"
+$  if f$trnlnm("SYS").eqs."" then define sys sys$library:
+$ else
+$  if f$search("SYS$SYSTEM:DECC$COMPILER.EXE").eqs.""
+$   then
+$    if f$trnlnm("SYS").eqs."" then define sys sys$library:
+$    if f$search("SYS$SYSTEM:VAXC.EXE").eqs.""
+$     then
+$      comp  = "__gcc__=1"
+$      CC :== GCC
+$     else
+$      comp = "__vaxc__=1"
+$     endif
+$   else
+$    if f$trnlnm("SYS").eqs."" then define sys decc$library_include:
+$    ccopt = "/decc/prefix=all"+ccopt
+$    comp  = "__decc__=1"
+$  endif
+$ endif
+$ open/write lopt lib.opt
+$ write lopt "''pngpath'libpng.olb/lib"
+$ write lopt "''zpath'libz.olb/lib"
+$ close lopt
+$ open/write xopt x11.opt
+$ write xopt "sys$library:decw$xlibshr.exe/share"
+$ close xopt
+$!
+$!    Build 'em.
+$!
+$ write sys$output "Compiling PNG book programs ..."
+$   CALL MAKE readpng.OBJ "cc ''CCOPT' readpng" -
+	readpng.c readpng.h
+$   CALL MAKE readpng2.OBJ "cc ''CCOPT' readpng2" -
+	readpng2.c readpng2.h
+$   CALL MAKE writepng.OBJ "cc ''CCOPT' writepng" -
+	writepng.c writepng.h
+$   write sys$output "Building rpng-x..."
+$   CALL MAKE rpng-x.OBJ "cc ''CCOPT' rpng-x" -
+	rpng-x.c readpng.h
+$   call make rpng-x.exe -
+	"LINK rpng-x,readpng,lib.opt/opt,x11.opt/opt" -
+	rpng-x.obj readpng.obj
+$   write sys$output "Building rpng2-x..."
+$   CALL MAKE rpng2-x.OBJ "cc ''CCOPT' rpng2-x" -
+	rpng2-x.c readpng2.h
+$   call make rpng2-x.exe -
+	"LINK rpng2-x,readpng2,lib.opt/opt,x11.opt/opt" -
+	rpng2-x.obj readpng2.obj
+$   write sys$output "Building wpng..."
+$   CALL MAKE wpng.OBJ "cc ''CCOPT' wpng" -
+	wpng.c writepng.h
+$   call make wpng.exe -
+	"LINK wpng,writepng,lib.opt/opt" -
+	wpng.obj writepng.obj
+$ exit
+$!
+$!
+$MAKE: SUBROUTINE   !SUBROUTINE TO CHECK DEPENDENCIES
+$ V = 'F$Verify(0)
+$! P1 = What we are trying to make
+$! P2 = Command to make it
+$! P3 - P8  What it depends on
+$
+$ If F$Search(P1) .Eqs. "" Then Goto Makeit
+$ Time = F$CvTime(F$File(P1,"RDT"))
+$arg=3
+$Loop:
+$       Argument = P'arg
+$       If Argument .Eqs. "" Then Goto Exit
+$       El=0
+$Loop2:
+$       File = F$Element(El," ",Argument)
+$       If File .Eqs. " " Then Goto Endl
+$       AFile = ""
+$Loop3:
+$       OFile = AFile
+$       AFile = F$Search(File)
+$       If AFile .Eqs. "" .Or. AFile .Eqs. OFile Then Goto NextEl
+$       If F$CvTime(F$File(AFile,"RDT")) .Ges. Time Then Goto Makeit
+$       Goto Loop3
+$NextEL:
+$       El = El + 1
+$       Goto Loop2
+$EndL:
+$ arg=arg+1
+$ If arg .Le. 8 Then Goto Loop
+$ Goto Exit
+$
+$Makeit:
+$ VV=F$VERIFY(0)
+$ write sys$output P2
+$ 'P2
+$ VV='F$Verify(VV)
+$Exit:
+$ If V Then Set Verify
+$ENDSUBROUTINE

contrib/gregbook/readpng.c

@@ -0,0 +1,316 @@
+/*---------------------------------------------------------------------------
+
+   rpng - simple PNG display program                              readpng.c
+
+  ---------------------------------------------------------------------------
+
+      Copyright (c) 1998-2007 Greg Roelofs.  All rights reserved.
+
+      This software is provided "as is," without warranty of any kind,
+      express or implied.  In no event shall the author or contributors
+      be held liable for any damages arising in any way from the use of
+      this software.
+
+      The contents of this file are DUAL-LICENSED.  You may modify and/or
+      redistribute this software according to the terms of one of the
+      following two licenses (at your option):
+
+
+      LICENSE 1 ("BSD-like with advertising clause"):
+
+      Permission is granted to anyone to use this software for any purpose,
+      including commercial applications, and to alter it and redistribute
+      it freely, subject to the following restrictions:
+
+      1. Redistributions of source code must retain the above copyright
+         notice, disclaimer, and this list of conditions.
+      2. Redistributions in binary form must reproduce the above copyright
+         notice, disclaimer, and this list of conditions in the documenta-
+         tion and/or other materials provided with the distribution.
+      3. All advertising materials mentioning features or use of this
+         software must display the following acknowledgment:
+
+            This product includes software developed by Greg Roelofs
+            and contributors for the book, "PNG: The Definitive Guide,"
+            published by O'Reilly and Associates.
+
+
+      LICENSE 2 (GNU GPL v2 or later):
+
+      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 of the License, 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, write to the Free Software Foundation,
+      Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+  ---------------------------------------------------------------------------*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <zlib.h>
+
+#include "png.h"        /* libpng header */
+#include "readpng.h"    /* typedefs, common macros, public prototypes */
+
+/* future versions of libpng will provide this macro: */
+#ifndef png_jmpbuf
+#  define png_jmpbuf(png_ptr)   ((png_ptr)->jmpbuf)
+#endif
+
+
+static png_structp png_ptr = NULL;
+static png_infop info_ptr = NULL;
+
+png_uint_32  width, height;
+int  bit_depth, color_type;
+uch  *image_data = NULL;
+
+
+void readpng_version_info(void)
+{
+    fprintf(stderr, "   Compiled with libpng %s; using libpng %s.\n",
+      PNG_LIBPNG_VER_STRING, png_libpng_ver);
+    fprintf(stderr, "   Compiled with zlib %s; using zlib %s.\n",
+      ZLIB_VERSION, zlib_version);
+}
+
+
+/* return value = 0 for success, 1 for bad sig, 2 for bad IHDR, 4 for no mem */
+
+int readpng_init(FILE *infile, ulg *pWidth, ulg *pHeight)
+{
+    uch sig[8];
+
+
+    /* first do a quick check that the file really is a PNG image; could
+     * have used slightly more general png_sig_cmp() function instead */
+
+    fread(sig, 1, 8, infile);
+    if (png_sig_cmp(sig, 0, 8))
+        return 1;   /* bad signature */
+
+
+    /* could pass pointers to user-defined error handlers instead of NULLs: */
+
+    png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
+    if (!png_ptr)
+        return 4;   /* out of memory */
+
+    info_ptr = png_create_info_struct(png_ptr);
+    if (!info_ptr) {
+        png_destroy_read_struct(&png_ptr, NULL, NULL);
+        return 4;   /* out of memory */
+    }
+
+
+    /* we could create a second info struct here (end_info), but it's only
+     * useful if we want to keep pre- and post-IDAT chunk info separated
+     * (mainly for PNG-aware image editors and converters) */
+
+
+    /* setjmp() must be called in every function that calls a PNG-reading
+     * libpng function */
+
+    if (setjmp(png_jmpbuf(png_ptr))) {
+        png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
+        return 2;
+    }
+
+
+    png_init_io(png_ptr, infile);
+    png_set_sig_bytes(png_ptr, 8);  /* we already read the 8 signature bytes */
+
+    png_read_info(png_ptr, info_ptr);  /* read all PNG info up to image data */
+
+
+    /* alternatively, could make separate calls to png_get_image_width(),
+     * etc., but want bit_depth and color_type for later [don't care about
+     * compression_type and filter_type => NULLs] */
+
+    png_get_IHDR(png_ptr, info_ptr, &width, &height, &bit_depth, &color_type,
+      NULL, NULL, NULL);
+    *pWidth = width;
+    *pHeight = height;
+
+
+    /* OK, that's all we need for now; return happy */
+
+    return 0;
+}
+
+
+
+
+/* returns 0 if succeeds, 1 if fails due to no bKGD chunk, 2 if libpng error;
+ * scales values to 8-bit if necessary */
+
+int readpng_get_bgcolor(uch *red, uch *green, uch *blue)
+{
+    png_color_16p pBackground;
+
+
+    /* setjmp() must be called in every function that calls a PNG-reading
+     * libpng function */
+
+    if (setjmp(png_jmpbuf(png_ptr))) {
+        png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
+        return 2;
+    }
+
+
+    if (!png_get_valid(png_ptr, info_ptr, PNG_INFO_bKGD))
+        return 1;
+
+    /* it is not obvious from the libpng documentation, but this function
+     * takes a pointer to a pointer, and it always returns valid red, green
+     * and blue values, regardless of color_type: */
+
+    png_get_bKGD(png_ptr, info_ptr, &pBackground);
+
+
+    /* however, it always returns the raw bKGD data, regardless of any
+     * bit-depth transformations, so check depth and adjust if necessary */
+
+    if (bit_depth == 16) {
+        *red   = pBackground->red   >> 8;
+        *green = pBackground->green >> 8;
+        *blue  = pBackground->blue  >> 8;
+    } else if (color_type == PNG_COLOR_TYPE_GRAY && bit_depth < 8) {
+        if (bit_depth == 1)
+            *red = *green = *blue = pBackground->gray? 255 : 0;
+        else if (bit_depth == 2)
+            *red = *green = *blue = (255/3) * pBackground->gray;
+        else /* bit_depth == 4 */
+            *red = *green = *blue = (255/15) * pBackground->gray;
+    } else {
+        *red   = (uch)pBackground->red;
+        *green = (uch)pBackground->green;
+        *blue  = (uch)pBackground->blue;
+    }
+
+    return 0;
+}
+
+
+
+
+/* display_exponent == LUT_exponent * CRT_exponent */
+
+uch *readpng_get_image(double display_exponent, int *pChannels, ulg *pRowbytes)
+{
+    double  gamma;
+    png_uint_32  i, rowbytes;
+    png_bytepp  row_pointers = NULL;
+
+
+    /* setjmp() must be called in every function that calls a PNG-reading
+     * 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;
+    }
+
+
+    /* expand palette images to RGB, low-bit-depth grayscale images to 8 bits,
+     * transparency chunks to full alpha channel; strip 16-bit-per-sample
+     * images to 8 bits per sample; and convert grayscale to RGB[A] */
+
+    if (color_type == PNG_COLOR_TYPE_PALETTE)
+        png_set_expand(png_ptr);
+    if (color_type == PNG_COLOR_TYPE_GRAY && bit_depth < 8)
+        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);
+
+
+    /* unlike the example in the libpng documentation, we have *no* idea where
+     * this file may have come from--so if it doesn't have a file gamma, don't
+     * do any correction ("do no harm") */
+
+    if (png_get_gAMA(png_ptr, info_ptr, &gamma))
+        png_set_gamma(png_ptr, display_exponent, gamma);
+
+
+    /* all transformations have been registered; now update info_ptr data,
+     * get rowbytes and channels, and allocate image memory */
+
+    png_read_update_info(png_ptr, info_ptr);
+
+    *pRowbytes = rowbytes = png_get_rowbytes(png_ptr, info_ptr);
+    *pChannels = (int)png_get_channels(png_ptr, info_ptr);
+
+    if ((image_data = (uch *)malloc(rowbytes*height)) == NULL) {
+        png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
+        return NULL;
+    }
+    if ((row_pointers = (png_bytepp)malloc(height*sizeof(png_bytep))) == NULL) {
+        png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
+        free(image_data);
+        image_data = NULL;
+        return NULL;
+    }
+
+    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 */
+
+    for (i = 0;  i < height;  ++i)
+        row_pointers[i] = image_data + i*rowbytes;
+
+
+    /* now we can go ahead and just read the whole image */
+
+    png_read_image(png_ptr, row_pointers);
+
+
+    /* and we're done!  (png_read_end() can be omitted if no processing of
+     * post-IDAT text/time/etc. is desired) */
+
+    free(row_pointers);
+    row_pointers = NULL;
+
+    png_read_end(png_ptr, NULL);
+
+    return image_data;
+}
+
+
+void readpng_cleanup(int free_image_data)
+{
+    if (free_image_data && image_data) {
+        free(image_data);
+        image_data = NULL;
+    }
+
+    if (png_ptr && info_ptr) {
+        png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
+        png_ptr = NULL;
+        info_ptr = NULL;
+    }
+}

contrib/gregbook/readpng.h

@@ -0,0 +1,88 @@
+/*---------------------------------------------------------------------------
+
+   rpng - simple PNG display program                              readpng.h
+
+  ---------------------------------------------------------------------------
+
+      Copyright (c) 1998-2007 Greg Roelofs.  All rights reserved.
+
+      This software is provided "as is," without warranty of any kind,
+      express or implied.  In no event shall the author or contributors
+      be held liable for any damages arising in any way from the use of
+      this software.
+
+      The contents of this file are DUAL-LICENSED.  You may modify and/or
+      redistribute this software according to the terms of one of the
+      following two licenses (at your option):
+
+
+      LICENSE 1 ("BSD-like with advertising clause"):
+
+      Permission is granted to anyone to use this software for any purpose,
+      including commercial applications, and to alter it and redistribute
+      it freely, subject to the following restrictions:
+
+      1. Redistributions of source code must retain the above copyright
+         notice, disclaimer, and this list of conditions.
+      2. Redistributions in binary form must reproduce the above copyright
+         notice, disclaimer, and this list of conditions in the documenta-
+         tion and/or other materials provided with the distribution.
+      3. All advertising materials mentioning features or use of this
+         software must display the following acknowledgment:
+
+            This product includes software developed by Greg Roelofs
+            and contributors for the book, "PNG: The Definitive Guide,"
+            published by O'Reilly and Associates.
+
+
+      LICENSE 2 (GNU GPL v2 or later):
+
+      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 of the License, 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, write to the Free Software Foundation,
+      Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+  ---------------------------------------------------------------------------*/
+
+#ifndef TRUE
+#  define TRUE 1
+#  define FALSE 0
+#endif
+
+#ifndef MAX
+#  define MAX(a,b)  ((a) > (b)? (a) : (b))
+#  define MIN(a,b)  ((a) < (b)? (a) : (b))
+#endif
+
+#ifdef DEBUG
+#  define Trace(x)  {fprintf x ; fflush(stderr); fflush(stdout);}
+#else
+#  define Trace(x)  ;
+#endif
+
+typedef unsigned char   uch;
+typedef unsigned short  ush;
+typedef unsigned long   ulg;
+
+
+/* prototypes for public functions in readpng.c */
+
+void readpng_version_info(void);
+
+int readpng_init(FILE *infile, ulg *pWidth, ulg *pHeight);
+
+int readpng_get_bgcolor(uch *bg_red, uch *bg_green, uch *bg_blue);
+
+uch *readpng_get_image(double display_exponent, int *pChannels,
+                       ulg *pRowbytes);
+
+void readpng_cleanup(int free_image_data);

contrib/gregbook/readpng2.c

@@ -0,0 +1,505 @@
+/*---------------------------------------------------------------------------
+
+   rpng2 - progressive-model PNG display program                 readpng2.c
+
+  ---------------------------------------------------------------------------
+
+      Copyright (c) 1998-2007 Greg Roelofs.  All rights reserved.
+
+      This software is provided "as is," without warranty of any kind,
+      express or implied.  In no event shall the author or contributors
+      be held liable for any damages arising in any way from the use of
+      this software.
+
+      The contents of this file are DUAL-LICENSED.  You may modify and/or
+      redistribute this software according to the terms of one of the
+      following two licenses (at your option):
+
+
+      LICENSE 1 ("BSD-like with advertising clause"):
+
+      Permission is granted to anyone to use this software for any purpose,
+      including commercial applications, and to alter it and redistribute
+      it freely, subject to the following restrictions:
+
+      1. Redistributions of source code must retain the above copyright
+         notice, disclaimer, and this list of conditions.
+      2. Redistributions in binary form must reproduce the above copyright
+         notice, disclaimer, and this list of conditions in the documenta-
+         tion and/or other materials provided with the distribution.
+      3. All advertising materials mentioning features or use of this
+         software must display the following acknowledgment:
+
+            This product includes software developed by Greg Roelofs
+            and contributors for the book, "PNG: The Definitive Guide,"
+            published by O'Reilly and Associates.
+
+
+      LICENSE 2 (GNU GPL v2 or later):
+
+      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 of the License, 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, write to the Free Software Foundation,
+      Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+  ---------------------------------------------------------------------------*/
+
+
+#include <stdlib.h>     /* for exit() prototype */
+#include <setjmp.h>
+
+#include <zlib.h>
+#include "png.h"        /* libpng header from the local directory */
+#include "readpng2.h"   /* typedefs, common macros, public prototypes */
+
+
+/* local prototypes */
+
+static void readpng2_info_callback(png_structp png_ptr, png_infop info_ptr);
+static void readpng2_row_callback(png_structp png_ptr, png_bytep new_row,
+                                 png_uint_32 row_num, int pass);
+static void readpng2_end_callback(png_structp png_ptr, png_infop info_ptr);
+static void readpng2_error_handler(png_structp png_ptr, png_const_charp msg);
+
+
+
+
+void readpng2_version_info(void)
+{
+    fprintf(stderr, "   Compiled with libpng %s; using libpng %s\n",
+      PNG_LIBPNG_VER_STRING, png_libpng_ver);
+
+    fprintf(stderr, "   and with zlib %s; using zlib %s.\n",
+      ZLIB_VERSION, zlib_version);
+}
+
+
+
+
+int readpng2_check_sig(uch *sig, int num)
+{
+    return !png_sig_cmp(sig, 0, num);
+}
+
+
+
+
+/* returns 0 for success, 2 for libpng problem, 4 for out of memory */
+
+int readpng2_init(mainprog_info *mainprog_ptr)
+{
+    png_structp  png_ptr;       /* note:  temporary variables! */
+    png_infop  info_ptr;
+
+
+    /* could also replace libpng warning-handler (final NULL), but no need: */
+
+    png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, mainprog_ptr,
+      readpng2_error_handler, NULL);
+    if (!png_ptr)
+        return 4;   /* out of memory */
+
+    info_ptr = png_create_info_struct(png_ptr);
+    if (!info_ptr) {
+        png_destroy_read_struct(&png_ptr, NULL, NULL);
+        return 4;   /* out of memory */
+    }
+
+
+    /* we could create a second info struct here (end_info), but it's only
+     * useful if we want to keep pre- and post-IDAT chunk info separated
+     * (mainly for PNG-aware image editors and converters) */
+
+
+    /* setjmp() must be called in every function that calls a PNG-reading
+     * libpng function, unless an alternate error handler was installed--
+     * but compatible error handlers must either use longjmp() themselves
+     * (as in this program) or exit immediately, so here we are: */
+
+    if (setjmp(mainprog_ptr->jmpbuf)) {
+        png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
+        return 2;
+    }
+
+
+#ifdef PNG_HANDLE_AS_UNKNOWN_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 */
+           };
+
+       /* 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);
+    }
+#endif /* PNG_HANDLE_AS_UNKNOWN_SUPPORTED */
+
+
+    /* instead of doing png_init_io() here, now we set up our callback
+     * functions for progressive decoding */
+
+    png_set_progressive_read_fn(png_ptr, mainprog_ptr,
+      readpng2_info_callback, readpng2_row_callback, readpng2_end_callback);
+
+
+    /* make sure we save our pointers for use in readpng2_decode_data() */
+
+    mainprog_ptr->png_ptr = png_ptr;
+    mainprog_ptr->info_ptr = info_ptr;
+
+
+    /* and that's all there is to initialization */
+
+    return 0;
+}
+
+
+
+
+/* returns 0 for success, 2 for libpng (longjmp) problem */
+
+int readpng2_decode_data(mainprog_info *mainprog_ptr, uch *rawbuf, ulg length)
+{
+    png_structp png_ptr = (png_structp)mainprog_ptr->png_ptr;
+    png_infop info_ptr = (png_infop)mainprog_ptr->info_ptr;
+
+
+    /* setjmp() must be called in every function that calls a PNG-reading
+     * libpng function */
+
+    if (setjmp(mainprog_ptr->jmpbuf)) {
+        png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
+        mainprog_ptr->png_ptr = NULL;
+        mainprog_ptr->info_ptr = NULL;
+        return 2;
+    }
+
+
+    /* hand off the next chunk of input data to libpng for decoding */
+
+    png_process_data(png_ptr, info_ptr, rawbuf, length);
+
+    return 0;
+}
+
+
+
+
+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(),
+     * longjmp() ourselves, or return control to libpng, which doesn't want
+     * to see us again.  By not doing anything here, libpng will instead jump
+     * to readpng2_decode_data(), which can return an error value to the main
+     * program. */
+
+
+    /* retrieve the pointer to our special-purpose struct, using the png_ptr
+     * that libpng passed back to us (i.e., not a global this time--there's
+     * no real difference for a single image, but for a multithreaded browser
+     * decoding several PNG images at the same time, one needs to avoid mixing
+     * up different images' structs) */
+
+    mainprog_ptr = png_get_progressive_ptr(png_ptr);
+
+    if (mainprog_ptr == NULL) {         /* we be hosed */
+        fprintf(stderr,
+          "readpng2 error:  main struct not recoverable in info_callback.\n");
+        fflush(stderr);
+        return;
+        /*
+         * Alternatively, we could call our error-handler just like libpng
+         * does, which would effectively terminate the program.  Since this
+         * can only happen if png_ptr gets redirected somewhere odd or the
+         * main PNG struct gets wiped, we're probably toast anyway.  (If
+         * png_ptr itself is NULL, we would not have been called.)
+         */
+    }
+
+
+    /* 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;
+
+
+    /* since we know we've read all of the PNG file's "header" (i.e., up
+     * to IDAT), we can check for a background color here */
+
+    if (mainprog_ptr->need_bgcolor &&
+        png_get_valid(png_ptr, info_ptr, PNG_INFO_bKGD))
+    {
+        png_color_16p pBackground;
+
+        /* it is not obvious from the libpng documentation, but this function
+         * takes a pointer to a pointer, and it always returns valid red,
+         * green and blue values, regardless of color_type: */
+        png_get_bKGD(png_ptr, info_ptr, &pBackground);
+
+        /* however, it always returns the raw bKGD data, regardless of any
+         * bit-depth transformations, so check depth and adjust if necessary */
+        if (bit_depth == 16) {
+            mainprog_ptr->bg_red   = pBackground->red   >> 8;
+            mainprog_ptr->bg_green = pBackground->green >> 8;
+            mainprog_ptr->bg_blue  = pBackground->blue  >> 8;
+        } else if (color_type == PNG_COLOR_TYPE_GRAY && bit_depth < 8) {
+            if (bit_depth == 1)
+                mainprog_ptr->bg_red = mainprog_ptr->bg_green =
+                  mainprog_ptr->bg_blue = pBackground->gray? 255 : 0;
+            else if (bit_depth == 2)
+                mainprog_ptr->bg_red = mainprog_ptr->bg_green =
+                  mainprog_ptr->bg_blue = (255/3) * pBackground->gray;
+            else /* bit_depth == 4 */
+                mainprog_ptr->bg_red = mainprog_ptr->bg_green =
+                  mainprog_ptr->bg_blue = (255/15) * pBackground->gray;
+        } else {
+            mainprog_ptr->bg_red   = (uch)pBackground->red;
+            mainprog_ptr->bg_green = (uch)pBackground->green;
+            mainprog_ptr->bg_blue  = (uch)pBackground->blue;
+        }
+    }
+
+
+    /* as before, let libpng expand palette images to RGB, low-bit-depth
+     * grayscale images to 8 bits, transparency chunks to full alpha channel;
+     * strip 16-bit-per-sample images to 8 bits per sample; and convert
+     * grayscale to RGB[A] */
+
+    if (color_type == PNG_COLOR_TYPE_PALETTE)
+        png_set_expand(png_ptr);
+    if (color_type == PNG_COLOR_TYPE_GRAY && bit_depth < 8)
+        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);
+
+
+    /* Unlike the basic viewer, which was designed to operate on local files,
+     * this program is intended to simulate a web browser--even though we
+     * actually read from a local file, too.  But because we are pretending
+     * that most of the images originate on the Internet, we follow the recom-
+     * mendation of the sRGB proposal and treat unlabelled images (no gAMA
+     * chunk) as existing in the sRGB color space.  That is, we assume that
+     * such images have a file gamma of 0.45455, which corresponds to a PC-like
+     * display system.  This change in assumptions will have no effect on a
+     * PC-like system, but on a Mac, SGI, NeXT or other system with a non-
+     * identity lookup table, it will darken unlabelled images, which effec-
+     * tively favors images from PC-like systems over those originating on
+     * the local platform.  Note that mainprog_ptr->display_exponent is the
+     * "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 */
+
+    mainprog_ptr->passes = png_set_interlace_handling(png_ptr);
+
+
+    /* all transformations have been registered; now update info_ptr data and
+     * then get rowbytes and channels */
+
+    png_read_update_info(png_ptr, info_ptr);
+
+    mainprog_ptr->rowbytes = (int)png_get_rowbytes(png_ptr, info_ptr);
+    mainprog_ptr->channels = png_get_channels(png_ptr, info_ptr);
+
+
+    /* Call the main program to allocate memory for the image buffer and
+     * initialize windows and whatnot.  (The old-style function-pointer
+     * invocation is used for compatibility with a few supposedly ANSI
+     * compilers that nevertheless barf on "fn_ptr()"-style syntax.) */
+
+    (*mainprog_ptr->mainprog_init)();
+
+
+    /* and that takes care of initialization */
+
+    return;
+}
+
+
+
+
+
+static void readpng2_row_callback(png_structp png_ptr, png_bytep new_row,
+                                  png_uint_32 row_num, int pass)
+{
+    mainprog_info  *mainprog_ptr;
+
+
+    /* first check whether the row differs from the previous pass; if not,
+     * nothing to combine or display */
+
+    if (!new_row)
+        return;
+
+
+    /* retrieve the pointer to our special-purpose struct so we can access
+     * the old rows and image-display callback function */
+
+    mainprog_ptr = png_get_progressive_ptr(png_ptr);
+
+
+    /* save the pass number for optional use by the front end */
+
+    mainprog_ptr->pass = pass;
+
+
+    /* have libpng either combine the new row data with the existing row data
+     * from previous passes (if interlaced) or else just copy the new row
+     * into the main program's image buffer */
+
+    png_progressive_combine_row(png_ptr, mainprog_ptr->row_pointers[row_num],
+      new_row);
+
+
+    /* finally, call the display routine in the main program with the number
+     * of the row we just updated */
+
+    (*mainprog_ptr->mainprog_display_row)(row_num);
+
+
+    /* and we're ready for more */
+
+    return;
+}
+
+
+
+
+
+static void readpng2_end_callback(png_structp png_ptr, png_infop info_ptr)
+{
+    mainprog_info  *mainprog_ptr;
+
+
+    /* retrieve the pointer to our special-purpose struct */
+
+    mainprog_ptr = png_get_progressive_ptr(png_ptr);
+
+
+    /* let the main program know that it should flush any buffered image
+     * data to the display now and set a "done" flag or whatever, but note
+     * that it SHOULD NOT DESTROY THE PNG STRUCTS YET--in other words, do
+     * NOT call readpng2_cleanup() either here or in the finish_display()
+     * routine; wait until control returns to the main program via
+     * readpng2_decode_data() */
+
+    (*mainprog_ptr->mainprog_finish_display)();
+
+
+    /* all done */
+
+    return;
+}
+
+
+
+
+
+void readpng2_cleanup(mainprog_info *mainprog_ptr)
+{
+    png_structp png_ptr = (png_structp)mainprog_ptr->png_ptr;
+    png_infop info_ptr = (png_infop)mainprog_ptr->info_ptr;
+
+    if (png_ptr && info_ptr)
+        png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
+
+    mainprog_ptr->png_ptr = NULL;
+    mainprog_ptr->info_ptr = NULL;
+}
+
+
+
+
+
+static void readpng2_error_handler(png_structp png_ptr, png_const_charp msg)
+{
+    mainprog_info  *mainprog_ptr;
+
+    /* This function, aside from the extra step of retrieving the "error
+     * pointer" (below) and the fact that it exists within the application
+     * rather than within libpng, is essentially identical to libpng's
+     * default error handler.  The second point is critical:  since both
+     * setjmp() and longjmp() are called from the same code, they are
+     * guaranteed to have compatible notions of how big a jmp_buf is,
+     * regardless of whether _BSD_SOURCE or anything else has (or has not)
+     * been defined. */
+
+    fprintf(stderr, "readpng2 libpng error: %s\n", msg);
+    fflush(stderr);
+
+    mainprog_ptr = png_get_error_ptr(png_ptr);
+    if (mainprog_ptr == NULL) {         /* we are completely hosed now */
+        fprintf(stderr,
+          "readpng2 severe error:  jmpbuf not recoverable; terminating.\n");
+        fflush(stderr);
+        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

@@ -0,0 +1,116 @@
+/*---------------------------------------------------------------------------
+
+   rpng2 - progressive-model PNG display program                 readpng2.h
+
+  ---------------------------------------------------------------------------
+
+      Copyright (c) 1998-2008 Greg Roelofs.  All rights reserved.
+
+      This software is provided "as is," without warranty of any kind,
+      express or implied.  In no event shall the author or contributors
+      be held liable for any damages arising in any way from the use of
+      this software.
+
+      The contents of this file are DUAL-LICENSED.  You may modify and/or
+      redistribute this software according to the terms of one of the
+      following two licenses (at your option):
+
+
+      LICENSE 1 ("BSD-like with advertising clause"):
+
+      Permission is granted to anyone to use this software for any purpose,
+      including commercial applications, and to alter it and redistribute
+      it freely, subject to the following restrictions:
+
+      1. Redistributions of source code must retain the above copyright
+         notice, disclaimer, and this list of conditions.
+      2. Redistributions in binary form must reproduce the above copyright
+         notice, disclaimer, and this list of conditions in the documenta-
+         tion and/or other materials provided with the distribution.
+      3. All advertising materials mentioning features or use of this
+         software must display the following acknowledgment:
+
+            This product includes software developed by Greg Roelofs
+            and contributors for the book, "PNG: The Definitive Guide,"
+            published by O'Reilly and Associates.
+
+
+      LICENSE 2 (GNU GPL v2 or later):
+
+      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 of the License, 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, write to the Free Software Foundation,
+      Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+  ---------------------------------------------------------------------------*/
+
+#ifndef TRUE
+#  define TRUE 1
+#  define FALSE 0
+#endif
+
+#ifndef MAX
+#  define MAX(a,b)  ((a) > (b)? (a) : (b))
+#  define MIN(a,b)  ((a) < (b)? (a) : (b))
+#endif
+
+#ifdef DEBUG
+#  define Trace(x)  {fprintf x ; fflush(stderr); fflush(stdout);}
+#else
+#  define Trace(x)  ;
+#endif
+
+enum rpng2_states {
+    kPreInit = 0,
+    kWindowInit,
+    kDone
+};
+
+typedef unsigned char   uch;
+typedef unsigned short  ush;
+typedef unsigned long   ulg;
+
+typedef struct _mainprog_info {
+    double display_exponent;
+    ulg width;
+    ulg height;
+    void *png_ptr;
+    void *info_ptr;
+    void (*mainprog_init)(void);
+    void (*mainprog_display_row)(ulg row_num);
+    void (*mainprog_finish_display)(void);
+    uch *image_data;
+    uch **row_pointers;
+    jmp_buf jmpbuf;
+    int passes;              /* not used */
+    int pass;
+    int rowbytes;
+    int channels;
+    int need_bgcolor;
+    int state;
+    uch bg_red;
+    uch bg_green;
+    uch bg_blue;
+} mainprog_info;
+
+
+/* prototypes for public functions in readpng2.c */
+
+void readpng2_version_info(void);
+
+int readpng2_check_sig(uch *sig, int num);
+
+int readpng2_init(mainprog_info *mainprog_ptr);
+
+int readpng2_decode_data(mainprog_info *mainprog_ptr, uch *rawbuf, ulg length);
+
+void readpng2_cleanup(mainprog_info *mainprog_ptr);

contrib/gregbook/readppm.c

@@ -0,0 +1,179 @@
+/*---------------------------------------------------------------------------
+
+   rpng - simple PNG display program                              readppm.c
+
+  ---------------------------------------------------------------------------
+
+   This is a special-purpose replacement for readpng.c that allows binary
+   PPM files to be used in place of PNG images.
+
+  ---------------------------------------------------------------------------
+
+      Copyright (c) 1998-2007 Greg Roelofs.  All rights reserved.
+
+      This software is provided "as is," without warranty of any kind,
+      express or implied.  In no event shall the author or contributors
+      be held liable for any damages arising in any way from the use of
+      this software.
+
+      The contents of this file are DUAL-LICENSED.  You may modify and/or
+      redistribute this software according to the terms of one of the
+      following two licenses (at your option):
+
+
+      LICENSE 1 ("BSD-like with advertising clause"):
+
+      Permission is granted to anyone to use this software for any purpose,
+      including commercial applications, and to alter it and redistribute
+      it freely, subject to the following restrictions:
+
+      1. Redistributions of source code must retain the above copyright
+         notice, disclaimer, and this list of conditions.
+      2. Redistributions in binary form must reproduce the above copyright
+         notice, disclaimer, and this list of conditions in the documenta-
+         tion and/or other materials provided with the distribution.
+      3. All advertising materials mentioning features or use of this
+         software must display the following acknowledgment:
+
+            This product includes software developed by Greg Roelofs
+            and contributors for the book, "PNG: The Definitive Guide,"
+            published by O'Reilly and Associates.
+
+
+      LICENSE 2 (GNU GPL v2 or later):
+
+      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 of the License, 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, write to the Free Software Foundation,
+      Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+  ---------------------------------------------------------------------------*/
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "readpng.h"    /* typedefs, common macros, public prototypes */
+
+
+ulg  width, height;
+int  bit_depth, color_type, channels;
+uch  *image_data = NULL;
+FILE *saved_infile;
+
+
+void readpng_version_info()
+{
+    fprintf(stderr, "   Compiled without libpng, zlib or PBMPLUS/NetPBM.\n");
+}
+
+
+/* return value = 0 for success, 1 for bad sig, 2 for bad IHDR, 4 for no mem */
+
+int readpng_init(FILE *infile, ulg *pWidth, ulg *pHeight)
+{
+    static uch ppmline[256];
+    int maxval;
+
+
+    saved_infile = infile;
+
+    fgets(ppmline, 256, infile);
+    if (ppmline[0] != 'P' || ppmline[1] != '6') {
+        fprintf(stderr, "ERROR:  not a PPM file\n");
+        return 1;
+    }
+    /* possible color types:  P5 = grayscale (0), P6 = RGB (2), P8 = RGBA (6) */
+    if (ppmline[1] == '6') {
+        color_type = 2;
+        channels = 3;
+    } else if (ppmline[1] == '8') {
+        color_type = 6;
+        channels = 4;
+    } else /* if (ppmline[1] == '5') */ {
+        color_type = 0;
+        channels = 1;
+    }
+
+    do {
+        fgets(ppmline, 256, infile);
+    } while (ppmline[0] == '#');
+    sscanf(ppmline, "%lu %lu", &width, &height);
+
+    do {
+        fgets(ppmline, 256, infile);
+    } while (ppmline[0] == '#');
+    sscanf(ppmline, "%d", &maxval);
+    if (maxval != 255) {
+        fprintf(stderr, "ERROR:  maxval = %d\n", maxval);
+        return 2;
+    }
+    bit_depth = 8;
+
+    *pWidth = width;
+    *pHeight = height;
+
+    return 0;
+}
+
+
+
+
+/* returns 0 if succeeds, 1 if fails due to no bKGD chunk, 2 if libpng error;
+ * scales values to 8-bit if necessary */
+
+int readpng_get_bgcolor(uch *red, uch *green, uch *blue)
+{
+    return 1;
+}
+
+
+
+
+/* display_exponent == LUT_exponent * CRT_exponent */
+
+uch *readpng_get_image(double display_exponent, int *pChannels, ulg *pRowbytes)
+{
+    ulg  rowbytes;
+
+
+    /* expand palette images to RGB, low-bit-depth grayscale images to 8 bits,
+     * transparency chunks to full alpha channel; strip 16-bit-per-sample
+     * images to 8 bits per sample; and convert grayscale to RGB[A] */
+
+    /* GRR WARNING:  grayscale needs to be expanded and channels reset! */
+
+    *pRowbytes = rowbytes = channels*width;
+    *pChannels = channels;
+
+    if ((image_data = (uch *)malloc(rowbytes*height)) == NULL) {
+        return NULL;
+    }
+
+    Trace((stderr, "readpng_get_image:  rowbytes = %ld, height = %ld\n", rowbytes, height));
+
+
+    /* now we can go ahead and just read the whole image */
+
+    fread(image_data, 1L, rowbytes*height, saved_infile);
+
+
+    return image_data;
+}
+
+
+void readpng_cleanup(int free_image_data)
+{
+    if (free_image_data && image_data) {
+        free(image_data);
+        image_data = NULL;
+    }
+}

contrib/gregbook/rpng-win.c

@@ -0,0 +1,728 @@
+/*---------------------------------------------------------------------------
+
+   rpng - simple PNG display program                             rpng-win.c
+
+   This program decodes and displays PNG images, with gamma correction and
+   optionally with a user-specified background color (in case the image has
+   transparency).  It is very nearly the most basic PNG viewer possible.
+   This version is for 32-bit Windows; it may compile under 16-bit Windows
+   with a little tweaking (or maybe not).
+
+   to do:
+    - handle quoted command-line args (especially filenames with spaces)
+    - have minimum window width:  oh well
+    - use %.1023s to simplify truncation of title-bar string?
+
+  ---------------------------------------------------------------------------
+
+   Changelog:
+    - 1.00:  initial public release
+    - 1.01:  modified to allow abbreviated options; fixed long/ulong mis-
+              match; switched to png_jmpbuf() macro
+    - 1.02:  added extra set of parentheses to png_jmpbuf() macro; fixed
+              command-line parsing bug
+    - 1.10:  enabled "message window"/console (thanks to David Geldreich)
+    - 2.00:  dual-licensed (added GNU GPL)
+    - 2.01:  fixed improper display of usage screen on PNG error(s)
+
+  ---------------------------------------------------------------------------
+
+      Copyright (c) 1998-2008 Greg Roelofs.  All rights reserved.
+
+      This software is provided "as is," without warranty of any kind,
+      express or implied.  In no event shall the author or contributors
+      be held liable for any damages arising in any way from the use of
+      this software.
+
+      The contents of this file are DUAL-LICENSED.  You may modify and/or
+      redistribute this software according to the terms of one of the
+      following two licenses (at your option):
+
+
+      LICENSE 1 ("BSD-like with advertising clause"):
+
+      Permission is granted to anyone to use this software for any purpose,
+      including commercial applications, and to alter it and redistribute
+      it freely, subject to the following restrictions:
+
+      1. Redistributions of source code must retain the above copyright
+         notice, disclaimer, and this list of conditions.
+      2. Redistributions in binary form must reproduce the above copyright
+         notice, disclaimer, and this list of conditions in the documenta-
+         tion and/or other materials provided with the distribution.
+      3. All advertising materials mentioning features or use of this
+         software must display the following acknowledgment:
+
+            This product includes software developed by Greg Roelofs
+            and contributors for the book, "PNG: The Definitive Guide,"
+            published by O'Reilly and Associates.
+
+
+      LICENSE 2 (GNU GPL v2 or later):
+
+      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 of the License, 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, write to the Free Software Foundation,
+      Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+  ---------------------------------------------------------------------------*/
+
+#define PROGNAME  "rpng-win"
+#define LONGNAME  "Simple PNG Viewer for Windows"
+#define VERSION   "2.01 of 16 March 2008"
+
+#include <stdio.h>
+#include <stdlib.h>
+#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 */
+
+#include "readpng.h"    /* typedefs, common macros, readpng prototypes */
+
+
+/* could just include png.h, but this macro is the only thing we need
+ * (name and typedefs changed to local versions); note that side effects
+ * only happen with alpha (which could easily be avoided with
+ * "ush acopy = (alpha);") */
+
+#define alpha_composite(composite, fg, alpha, bg) {               \
+    ush temp = ((ush)(fg)*(ush)(alpha) +                          \
+                (ush)(bg)*(ush)(255 - (ush)(alpha)) + (ush)128);  \
+    (composite) = (uch)((temp + (temp >> 8)) >> 8);               \
+}
+
+
+/* local prototypes */
+static int        rpng_win_create_window(HINSTANCE hInst, int showmode);
+static int        rpng_win_display_image(void);
+static void       rpng_win_cleanup(void);
+LRESULT CALLBACK  rpng_win_wndproc(HWND, UINT, WPARAM, LPARAM);
+
+
+static char titlebar[1024];
+static char *progname = PROGNAME;
+static char *appname = LONGNAME;
+static char *filename;
+static FILE *infile;
+
+static char *bgstr;
+static uch bg_red=0, bg_green=0, bg_blue=0;
+
+static double display_exponent;
+
+static ulg image_width, image_height, image_rowbytes;
+static int image_channels;
+static uch *image_data;
+
+/* Windows-specific variables */
+static ulg wimage_rowbytes;
+static uch *dib;
+static uch *wimage_data;
+static BITMAPINFOHEADER *bmih;
+
+static HWND global_hwnd;
+
+
+
+
+int WINAPI WinMain(HINSTANCE hInst, HINSTANCE hPrevInst, PSTR cmd, int showmode)
+{
+    char *args[1024];                 /* arbitrary limit, but should suffice */
+    char *p, *q, **argv = args;
+    int argc = 0;
+    int rc, alen, flen;
+    int error = 0;
+    int have_bg = FALSE;
+    double LUT_exponent;              /* just the lookup table */
+    double CRT_exponent = 2.2;        /* just the monitor */
+    double default_display_exponent;  /* whole display system */
+    MSG msg;
+
+
+    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
+     * incantation. */
+
+    AllocConsole();
+    freopen("CONOUT$", "a", stderr);
+    freopen("CONOUT$", "a", stdout);
+#endif
+
+
+    /* Next set the default value for our display-system exponent, i.e.,
+     * the product of the CRT exponent and the exponent corresponding to
+     * the frame-buffer's lookup table (LUT), if any.  This is not an
+     * exhaustive list of LUT values (e.g., OpenStep has a lot of weird
+     * ones), but it should cover 99% of the current possibilities.  And
+     * yes, these ifdefs are completely wasted in a Windows program... */
+
+#if defined(NeXT)
+    LUT_exponent = 1.0 / 2.2;
+    /*
+    if (some_next_function_that_returns_gamma(&next_gamma))
+        LUT_exponent = 1.0 / next_gamma;
+     */
+#elif defined(sgi)
+    LUT_exponent = 1.0 / 1.7;
+    /* there doesn't seem to be any documented function to get the
+     * "gamma" value, so we do it the hard way */
+    infile = fopen("/etc/config/system.glGammaVal", "r");
+    if (infile) {
+        double sgi_gamma;
+
+        fgets(tmpline, 80, infile);
+        fclose(infile);
+        sgi_gamma = atof(tmpline);
+        if (sgi_gamma > 0.0)
+            LUT_exponent = 1.0 / sgi_gamma;
+    }
+#elif defined(Macintosh)
+    LUT_exponent = 1.8 / 2.61;
+    /*
+    if (some_mac_function_that_returns_gamma(&mac_gamma))
+        LUT_exponent = mac_gamma / 2.61;
+     */
+#else
+    LUT_exponent = 1.0;   /* assume no LUT:  most PCs */
+#endif
+
+    /* the defaults above give 1.0, 1.3, 1.5 and 2.2, respectively: */
+    default_display_exponent = LUT_exponent * CRT_exponent;
+
+
+    /* If the user has set the SCREEN_GAMMA environment variable as suggested
+     * (somewhat imprecisely) in the libpng documentation, use that; otherwise
+     * use the default value we just calculated.  Either way, the user may
+     * override this via a command-line option. */
+
+    if ((p = getenv("SCREEN_GAMMA")) != NULL)
+        display_exponent = atof(p);
+    else
+        display_exponent = default_display_exponent;
+
+
+    /* Windows really hates command lines, so we have to set up our own argv.
+     * Note that we do NOT bother with quoted arguments here, so don't use
+     * filenames with spaces in 'em! */
+
+    argv[argc++] = PROGNAME;
+    p = cmd;
+    for (;;) {
+        if (*p == ' ')
+            while (*++p == ' ')
+                ;
+        /* now p points at the first non-space after some spaces */
+        if (*p == '\0')
+            break;    /* nothing after the spaces:  done */
+        argv[argc++] = q = p;
+        while (*q && *q != ' ')
+            ++q;
+        /* now q points at a space or the end of the string */
+        if (*q == '\0')
+            break;    /* last argv already terminated; quit */
+        *q = '\0';    /* change space to terminator */
+        p = q + 1;
+    }
+    argv[argc] = NULL;   /* terminate the argv array itself */
+
+
+    /* Now parse the command line for options and the PNG filename. */
+
+    while (*++argv && !error) {
+        if (!strncmp(*argv, "-gamma", 2)) {
+            if (!*++argv)
+                ++error;
+            else {
+                display_exponent = atof(*argv);
+                if (display_exponent <= 0.0)
+                    ++error;
+            }
+        } else if (!strncmp(*argv, "-bgcolor", 2)) {
+            if (!*++argv)
+                ++error;
+            else {
+                bgstr = *argv;
+                if (strlen(bgstr) != 7 || bgstr[0] != '#')
+                    ++error;
+                else
+                    have_bg = TRUE;
+            }
+        } else {
+            if (**argv != '-') {
+                filename = *argv;
+                if (argv[1])   /* shouldn't be any more args after filename */
+                    ++error;
+            } else
+                ++error;   /* not expecting any other options */
+        }
+    }
+
+    if (!filename)
+        ++error;
+
+
+    /* 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();
+        fprintf(stderr, "\n"
+          "Usage:  %s [-gamma exp] [-bgcolor bg] file.png\n"
+          "    exp \ttransfer-function exponent (``gamma'') of the display\n"
+          "\t\t  system in floating-point format (e.g., ``%.1f''); equal\n"
+          "\t\t  to the product of the lookup-table exponent (varies)\n"
+          "\t\t  and the CRT exponent (usually 2.2); must be positive\n"
+          "    bg  \tdesired background color in 7-character hex RGB format\n"
+          "\t\t  (e.g., ``#ff7700'' for orange:  same as HTML colors);\n"
+          "\t\t  used with transparent images\n"
+          "\nPress Q, Esc or mouse button 1 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);
+    }
+
+
+    if (!(infile = fopen(filename, "rb"))) {
+        fprintf(stderr, PROGNAME ":  can't open PNG file [%s]\n", filename);
+        ++error;
+    } else {
+        if ((rc = readpng_init(infile, &image_width, &image_height)) != 0) {
+            switch (rc) {
+                case 1:
+                    fprintf(stderr, PROGNAME
+                      ":  [%s] is not a PNG file: incorrect signature\n",
+                      filename);
+                    break;
+                case 2:
+                    fprintf(stderr, PROGNAME
+                      ":  [%s] has bad IHDR (libpng longjmp)\n", filename);
+                    break;
+                case 4:
+                    fprintf(stderr, PROGNAME ":  insufficient memory\n");
+                    break;
+                default:
+                    fprintf(stderr, PROGNAME
+                      ":  unknown readpng_init() error\n");
+                    break;
+            }
+            ++error;
+        }
+        if (error)
+            fclose(infile);
+    }
+
+
+    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
+    }
+
+
+    /* set the title-bar string, but make sure buffer doesn't overflow */
+
+    alen = strlen(appname);
+    flen = strlen(filename);
+    if (alen + flen + 3 > 1023)
+        sprintf(titlebar, "%s:  ...%s", appname, filename+(alen+flen+6-1023));
+    else
+        sprintf(titlebar, "%s:  %s", appname, filename);
+
+
+    /* if the user didn't specify a background color on the command line,
+     * check for one in the PNG file--if not, the initialized values of 0
+     * (black) will be used */
+
+    if (have_bg) {
+        unsigned r, g, b;   /* this approach quiets compiler warnings */
+
+        sscanf(bgstr+1, "%2x%2x%2x", &r, &g, &b);
+        bg_red   = (uch)r;
+        bg_green = (uch)g;
+        bg_blue  = (uch)b;
+    } else if (readpng_get_bgcolor(&bg_red, &bg_green, &bg_blue) > 1) {
+        readpng_cleanup(TRUE);
+        fprintf(stderr, PROGNAME
+          ":  libpng error while checking for background color\n");
+        exit(2);
+    }
+
+
+    /* do the basic Windows initialization stuff, make the window and fill it
+     * with the background color */
+
+    if (rpng_win_create_window(hInst, showmode))
+        exit(2);
+
+
+    /* decode the image, all at once */
+
+    Trace((stderr, "calling readpng_get_image()\n"))
+    image_data = readpng_get_image(display_exponent, &image_channels,
+      &image_rowbytes);
+    Trace((stderr, "done with readpng_get_image()\n"))
+
+
+    /* done with PNG file, so clean up to minimize memory usage (but do NOT
+     * nuke image_data!) */
+
+    readpng_cleanup(FALSE);
+    fclose(infile);
+
+    if (!image_data) {
+        fprintf(stderr, PROGNAME ":  unable to decode PNG image\n");
+        exit(3);
+    }
+
+
+    /* display image (composite with background if requested) */
+
+    Trace((stderr, "calling rpng_win_display_image()\n"))
+    if (rpng_win_display_image()) {
+        free(image_data);
+        exit(4);
+    }
+    Trace((stderr, "done with rpng_win_display_image()\n"))
+
+
+    /* 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
+    );
+    fflush(stdout);
+
+    while (GetMessage(&msg, NULL, 0, 0)) {
+        TranslateMessage(&msg);
+        DispatchMessage(&msg);
+    }
+
+
+    /* OK, we're done:  clean up all image and Windows resources and go away */
+
+    rpng_win_cleanup();
+
+    return msg.wParam;
+}
+
+
+
+
+
+static int rpng_win_create_window(HINSTANCE hInst, int showmode)
+{
+    uch *dest;
+    int extra_width, extra_height;
+    ulg i, j;
+    WNDCLASSEX wndclass;
+
+
+/*---------------------------------------------------------------------------
+    Allocate memory for the display-specific version of the image (round up
+    to multiple of 4 for Windows DIB).
+  ---------------------------------------------------------------------------*/
+
+    wimage_rowbytes = ((3*image_width + 3L) >> 2) << 2;
+
+    if (!(dib = (uch *)malloc(sizeof(BITMAPINFOHEADER) +
+                              wimage_rowbytes*image_height)))
+    {
+        return 4;   /* fail */
+    }
+
+/*---------------------------------------------------------------------------
+    Initialize the DIB.  Negative height means to use top-down BMP ordering
+    (must be uncompressed, but that's what we want).  Bit count of 1, 4 or 8
+    implies a colormap of RGBX quads, but 24-bit BMPs just use B,G,R values
+    directly => wimage_data begins immediately after BMP header.
+  ---------------------------------------------------------------------------*/
+
+    memset(dib, 0, sizeof(BITMAPINFOHEADER));
+    bmih = (BITMAPINFOHEADER *)dib;
+    bmih->biSize = sizeof(BITMAPINFOHEADER);
+    bmih->biWidth = image_width;
+    bmih->biHeight = -((long)image_height);
+    bmih->biPlanes = 1;
+    bmih->biBitCount = 24;
+    bmih->biCompression = 0;
+    wimage_data = dib + sizeof(BITMAPINFOHEADER);
+
+/*---------------------------------------------------------------------------
+    Fill in background color (black by default); data are in BGR order.
+  ---------------------------------------------------------------------------*/
+
+    for (j = 0;  j < image_height;  ++j) {
+        dest = wimage_data + j*wimage_rowbytes;
+        for (i = image_width;  i > 0;  --i) {
+            *dest++ = bg_blue;
+            *dest++ = bg_green;
+            *dest++ = bg_red;
+        }
+    }
+
+/*---------------------------------------------------------------------------
+    Set the window parameters.
+  ---------------------------------------------------------------------------*/
+
+    memset(&wndclass, 0, sizeof(wndclass));
+
+    wndclass.cbSize = sizeof(wndclass);
+    wndclass.style = CS_HREDRAW | CS_VREDRAW;
+    wndclass.lpfnWndProc = rpng_win_wndproc;
+    wndclass.hInstance = hInst;
+    wndclass.hIcon = LoadIcon(NULL, IDI_APPLICATION);
+    wndclass.hCursor = LoadCursor(NULL, IDC_ARROW);
+    wndclass.hbrBackground = (HBRUSH)GetStockObject(DKGRAY_BRUSH);
+    wndclass.lpszMenuName = NULL;
+    wndclass.lpszClassName = progname;
+    wndclass.hIconSm = LoadIcon(NULL, IDI_APPLICATION);
+
+    RegisterClassEx(&wndclass);
+
+/*---------------------------------------------------------------------------
+    Finally, create the window.
+  ---------------------------------------------------------------------------*/
+
+    extra_width  = 2*(GetSystemMetrics(SM_CXBORDER) +
+                      GetSystemMetrics(SM_CXDLGFRAME));
+    extra_height = 2*(GetSystemMetrics(SM_CYBORDER) +
+                      GetSystemMetrics(SM_CYDLGFRAME)) +
+                      GetSystemMetrics(SM_CYCAPTION);
+
+    global_hwnd = CreateWindow(progname, titlebar, WS_OVERLAPPEDWINDOW,
+      CW_USEDEFAULT, CW_USEDEFAULT, image_width+extra_width,
+      image_height+extra_height, NULL, NULL, hInst, NULL);
+
+    ShowWindow(global_hwnd, showmode);
+    UpdateWindow(global_hwnd);
+
+    return 0;
+
+} /* end function rpng_win_create_window() */
+
+
+
+
+
+static int rpng_win_display_image()
+{
+    uch *src, *dest;
+    uch r, g, b, a;
+    ulg i, row, lastrow;
+    RECT rect;
+
+
+    Trace((stderr, "beginning display loop (image_channels == %d)\n",
+      image_channels))
+    Trace((stderr, "(width = %ld, rowbytes = %ld, wimage_rowbytes = %d)\n",
+      image_width, image_rowbytes, wimage_rowbytes))
+
+
+/*---------------------------------------------------------------------------
+    Blast image data to buffer.  This whole routine takes place before the
+    message loop begins, so there's no real point in any pseudo-progressive
+    display...
+  ---------------------------------------------------------------------------*/
+
+    for (lastrow = row = 0;  row < image_height;  ++row) {
+        src = image_data + row*image_rowbytes;
+        dest = wimage_data + row*wimage_rowbytes;
+        if (image_channels == 3) {
+            for (i = image_width;  i > 0;  --i) {
+                r = *src++;
+                g = *src++;
+                b = *src++;
+                *dest++ = b;
+                *dest++ = g;   /* note reverse order */
+                *dest++ = r;
+            }
+        } else /* if (image_channels == 4) */ {
+            for (i = image_width;  i > 0;  --i) {
+                r = *src++;
+                g = *src++;
+                b = *src++;
+                a = *src++;
+                if (a == 255) {
+                    *dest++ = b;
+                    *dest++ = g;
+                    *dest++ = r;
+                } else if (a == 0) {
+                    *dest++ = bg_blue;
+                    *dest++ = bg_green;
+                    *dest++ = bg_red;
+                } else {
+                    /* this macro (copied from png.h) composites the
+                     * foreground and background values and puts the
+                     * result into the first argument; there are no
+                     * side effects with the first argument */
+                    alpha_composite(*dest++, b, a, bg_blue);
+                    alpha_composite(*dest++, g, a, bg_green);
+                    alpha_composite(*dest++, r, a, bg_red);
+                }
+            }
+        }
+        /* display after every 16 lines */
+        if (((row+1) & 0xf) == 0) {
+            rect.left = 0L;
+            rect.top = (LONG)lastrow;
+            rect.right = (LONG)image_width;      /* possibly off by one? */
+            rect.bottom = (LONG)lastrow + 16L;   /* possibly off by one? */
+            InvalidateRect(global_hwnd, &rect, FALSE);
+            UpdateWindow(global_hwnd);     /* similar to XFlush() */
+            lastrow = row + 1;
+        }
+    }
+
+    Trace((stderr, "calling final image-flush routine\n"))
+    if (lastrow < image_height) {
+        rect.left = 0L;
+        rect.top = (LONG)lastrow;
+        rect.right = (LONG)image_width;      /* possibly off by one? */
+        rect.bottom = (LONG)image_height;    /* possibly off by one? */
+        InvalidateRect(global_hwnd, &rect, FALSE);
+        UpdateWindow(global_hwnd);     /* similar to XFlush() */
+    }
+
+/*
+    last param determines whether or not background is wiped before paint
+    InvalidateRect(global_hwnd, NULL, TRUE);
+    UpdateWindow(global_hwnd);
+ */
+
+    return 0;
+}
+
+
+
+
+
+static void rpng_win_cleanup()
+{
+    if (image_data) {
+        free(image_data);
+        image_data = NULL;
+    }
+
+    if (dib) {
+        free(dib);
+        dib = NULL;
+    }
+}
+
+
+
+
+
+LRESULT CALLBACK rpng_win_wndproc(HWND hwnd, UINT iMsg, WPARAM wP, LPARAM lP)
+{
+    HDC         hdc;
+    PAINTSTRUCT ps;
+    int rc;
+
+    switch (iMsg) {
+        case WM_CREATE:
+            /* one-time processing here, if any */
+            return 0;
+
+        case WM_PAINT:
+            hdc = BeginPaint(hwnd, &ps);
+                    /*                    dest                          */
+            rc = StretchDIBits(hdc, 0, 0, image_width, image_height,
+                    /*                    source                        */
+                                    0, 0, image_width, image_height,
+                                    wimage_data, (BITMAPINFO *)bmih,
+                    /*              iUsage: no clue                     */
+                                    0, SRCCOPY);
+            EndPaint(hwnd, &ps);
+            return 0;
+
+        /* wait for the user to tell us when to quit */
+        case WM_CHAR:
+            switch (wP) {      /* only need one, so ignore repeat count */
+                case 'q':
+                case 'Q':
+                case 0x1B:     /* Esc key */
+                    PostQuitMessage(0);
+            }
+            return 0;
+
+        case WM_LBUTTONDOWN:   /* another way of quitting */
+        case WM_DESTROY:
+            PostQuitMessage(0);
+            return 0;
+    }
+
+    return DefWindowProc(hwnd, iMsg, wP, lP);
+}

contrib/gregbook/rpng-x.c

@@ -0,0 +1,904 @@
+/*---------------------------------------------------------------------------
+
+   rpng - simple PNG display program                               rpng-x.c
+
+   This program decodes and displays PNG images, with gamma correction and
+   optionally with a user-specified background color (in case the image has
+   transparency).  It is very nearly the most basic PNG viewer possible.
+   This version is for the X Window System (tested by author under Unix and
+   by Martin Zinser under OpenVMS; may work under OS/2 with some tweaking).
+
+   to do:
+    - 8-bit (colormapped) X support
+    - use %.1023s to simplify truncation of title-bar string?
+
+  ---------------------------------------------------------------------------
+
+   Changelog:
+    - 1.01:  initial public release
+    - 1.02:  modified to allow abbreviated options; fixed long/ulong mis-
+              match; switched to png_jmpbuf() macro
+    - 1.10:  added support for non-default visuals; fixed X pixel-conversion
+    - 1.11:  added extra set of parentheses to png_jmpbuf() macro; fixed
+              command-line parsing bug
+    - 1.12:  fixed some small X memory leaks (thanks to Fran<61>ois Petitjean)
+    - 1.13:  fixed XFreeGC() crash bug (thanks to Patrick Welche)
+    - 1.14:  added support for X resources (thanks to Gerhard Niklasch)
+    - 2.00:  dual-licensed (added GNU GPL)
+    - 2.01:  fixed improper display of usage screen on PNG error(s)
+
+  ---------------------------------------------------------------------------
+
+      Copyright (c) 1998-2008 Greg Roelofs.  All rights reserved.
+
+      This software is provided "as is," without warranty of any kind,
+      express or implied.  In no event shall the author or contributors
+      be held liable for any damages arising in any way from the use of
+      this software.
+
+      The contents of this file are DUAL-LICENSED.  You may modify and/or
+      redistribute this software according to the terms of one of the
+      following two licenses (at your option):
+
+
+      LICENSE 1 ("BSD-like with advertising clause"):
+
+      Permission is granted to anyone to use this software for any purpose,
+      including commercial applications, and to alter it and redistribute
+      it freely, subject to the following restrictions:
+
+      1. Redistributions of source code must retain the above copyright
+         notice, disclaimer, and this list of conditions.
+      2. Redistributions in binary form must reproduce the above copyright
+         notice, disclaimer, and this list of conditions in the documenta-
+         tion and/or other materials provided with the distribution.
+      3. All advertising materials mentioning features or use of this
+         software must display the following acknowledgment:
+
+            This product includes software developed by Greg Roelofs
+            and contributors for the book, "PNG: The Definitive Guide,"
+            published by O'Reilly and Associates.
+
+
+      LICENSE 2 (GNU GPL v2 or later):
+
+      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 of the License, 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, write to the Free Software Foundation,
+      Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+  ---------------------------------------------------------------------------*/
+
+#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 */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+#include <X11/Xos.h>
+#include <X11/keysym.h>
+
+/* #define DEBUG  :  this enables the Trace() macros */
+
+#include "readpng.h"   /* typedefs, common macros, readpng prototypes */
+
+
+/* could just include png.h, but this macro is the only thing we need
+ * (name and typedefs changed to local versions); note that side effects
+ * only happen with alpha (which could easily be avoided with
+ * "ush acopy = (alpha);") */
+
+#define alpha_composite(composite, fg, alpha, bg) {               \
+    ush temp = ((ush)(fg)*(ush)(alpha) +                          \
+                (ush)(bg)*(ush)(255 - (ush)(alpha)) + (ush)128);  \
+    (composite) = (uch)((temp + (temp >> 8)) >> 8);               \
+}
+
+
+/* local prototypes */
+static int  rpng_x_create_window(void);
+static int  rpng_x_display_image(void);
+static void rpng_x_cleanup(void);
+static int  rpng_x_msb(ulg u32val);
+
+
+static char titlebar[1024], *window_name = titlebar;
+static char *appname = LONGNAME;
+static char *icon_name = PROGNAME;
+static char *res_name = RESNAME;
+static char *res_class = RESCLASS;
+static char *filename;
+static FILE *infile;
+
+static char *bgstr;
+static uch bg_red=0, bg_green=0, bg_blue=0;
+
+static double display_exponent;
+
+static ulg image_width, image_height, image_rowbytes;
+static int image_channels;
+static uch *image_data;
+
+/* X-specific variables */
+static char *displayname;
+static XImage *ximage;
+static Display *display;
+static int depth;
+static Visual *visual;
+static XVisualInfo *visual_list;
+static int RShift, GShift, BShift;
+static ulg RMask, GMask, BMask;
+static Window window;
+static GC gc;
+static Colormap colormap;
+
+static int have_nondefault_visual = FALSE;
+static int have_colormap = FALSE;
+static int have_window = FALSE;
+static int have_gc = FALSE;
+/*
+ulg numcolors=0, pixels[256];
+ush reds[256], greens[256], blues[256];
+ */
+
+
+
+
+int main(int argc, char **argv)
+{
+#ifdef sgi
+    char tmpline[80];
+#endif
+    char *p;
+    int rc, alen, flen;
+    int error = 0;
+    int have_bg = FALSE;
+    double LUT_exponent;               /* just the lookup table */
+    double CRT_exponent = 2.2;         /* just the monitor */
+    double default_display_exponent;   /* whole display system */
+    XEvent e;
+    KeySym k;
+
+
+    displayname = (char *)NULL;
+    filename = (char *)NULL;
+
+
+    /* First set the default value for our display-system exponent, i.e.,
+     * the product of the CRT exponent and the exponent corresponding to
+     * the frame-buffer's lookup table (LUT), if any.  This is not an
+     * exhaustive list of LUT values (e.g., OpenStep has a lot of weird
+     * ones), but it should cover 99% of the current possibilities. */
+
+#if defined(NeXT)
+    LUT_exponent = 1.0 / 2.2;
+    /*
+    if (some_next_function_that_returns_gamma(&next_gamma))
+        LUT_exponent = 1.0 / next_gamma;
+     */
+#elif defined(sgi)
+    LUT_exponent = 1.0 / 1.7;
+    /* there doesn't seem to be any documented function to get the
+     * "gamma" value, so we do it the hard way */
+    infile = fopen("/etc/config/system.glGammaVal", "r");
+    if (infile) {
+        double sgi_gamma;
+
+        fgets(tmpline, 80, infile);
+        fclose(infile);
+        sgi_gamma = atof(tmpline);
+        if (sgi_gamma > 0.0)
+            LUT_exponent = 1.0 / sgi_gamma;
+    }
+#elif defined(Macintosh)
+    LUT_exponent = 1.8 / 2.61;
+    /*
+    if (some_mac_function_that_returns_gamma(&mac_gamma))
+        LUT_exponent = mac_gamma / 2.61;
+     */
+#else
+    LUT_exponent = 1.0;   /* assume no LUT:  most PCs */
+#endif
+
+    /* the defaults above give 1.0, 1.3, 1.5 and 2.2, respectively: */
+    default_display_exponent = LUT_exponent * CRT_exponent;
+
+
+    /* If the user has set the SCREEN_GAMMA environment variable as suggested
+     * (somewhat imprecisely) in the libpng documentation, use that; otherwise
+     * use the default value we just calculated.  Either way, the user may
+     * override this via a command-line option. */
+
+    if ((p = getenv("SCREEN_GAMMA")) != NULL)
+        display_exponent = atof(p);
+    else
+        display_exponent = default_display_exponent;
+
+
+    /* Now parse the command line for options and the PNG filename. */
+
+    while (*++argv && !error) {
+        if (!strncmp(*argv, "-display", 2)) {
+            if (!*++argv)
+                ++error;
+            else
+                displayname = *argv;
+        } else if (!strncmp(*argv, "-gamma", 2)) {
+            if (!*++argv)
+                ++error;
+            else {
+                display_exponent = atof(*argv);
+                if (display_exponent <= 0.0)
+                    ++error;
+            }
+        } else if (!strncmp(*argv, "-bgcolor", 2)) {
+            if (!*++argv)
+                ++error;
+            else {
+                bgstr = *argv;
+                if (strlen(bgstr) != 7 || bgstr[0] != '#')
+                    ++error;
+                else
+                    have_bg = TRUE;
+            }
+        } else {
+            if (**argv != '-') {
+                filename = *argv;
+                if (argv[1])   /* shouldn't be any more args after filename */
+                    ++error;
+            } else
+                ++error;   /* not expecting any other options */
+        }
+    }
+
+    if (!filename)
+        ++error;
+
+
+    /* print usage screen if any errors up to this point */
+
+    if (error) {
+        fprintf(stderr, "\n%s %s:  %s\n", PROGNAME, VERSION, appname);
+        readpng_version_info();
+        fprintf(stderr, "\n"
+          "Usage:  %s [-display xdpy] [-gamma exp] [-bgcolor bg] file.png\n"
+          "    xdpy\tname of the target X display (e.g., ``hostname:0'')\n"
+          "    exp \ttransfer-function exponent (``gamma'') of the display\n"
+          "\t\t  system in floating-point format (e.g., ``%.1f''); equal\n"
+          "\t\t  to the product of the lookup-table exponent (varies)\n"
+          "\t\t  and the CRT exponent (usually 2.2); must be positive\n"
+          "    bg  \tdesired background color in 7-character hex RGB format\n"
+          "\t\t  (e.g., ``#ff7700'' for orange:  same as HTML colors);\n"
+          "\t\t  used with transparent images\n"
+          "\nPress Q, Esc or mouse button 1 (within image window, after image\n"
+          "is displayed) to quit.\n"
+          "\n", PROGNAME, default_display_exponent);
+        exit(1);
+    }
+
+
+    if (!(infile = fopen(filename, "rb"))) {
+        fprintf(stderr, PROGNAME ":  can't open PNG file [%s]\n", filename);
+        ++error;
+    } else {
+        if ((rc = readpng_init(infile, &image_width, &image_height)) != 0) {
+            switch (rc) {
+                case 1:
+                    fprintf(stderr, PROGNAME
+                      ":  [%s] is not a PNG file: incorrect signature\n",
+                      filename);
+                    break;
+                case 2:
+                    fprintf(stderr, PROGNAME
+                      ":  [%s] has bad IHDR (libpng longjmp)\n", filename);
+                    break;
+                case 4:
+                    fprintf(stderr, PROGNAME ":  insufficient memory\n");
+                    break;
+                default:
+                    fprintf(stderr, PROGNAME
+                      ":  unknown readpng_init() error\n");
+                    break;
+            }
+            ++error;
+        } else {
+            display = XOpenDisplay(displayname);
+            if (!display) {
+                readpng_cleanup(TRUE);
+                fprintf(stderr, PROGNAME ":  can't open X display [%s]\n",
+                  displayname? displayname : "default");
+                ++error;
+            }
+        }
+        if (error)
+            fclose(infile);
+    }
+
+
+    if (error) {
+        fprintf(stderr, PROGNAME ":  aborting.\n");
+        exit(2);
+    }
+
+
+    /* set the title-bar string, but make sure buffer doesn't overflow */
+
+    alen = strlen(appname);
+    flen = strlen(filename);
+    if (alen + flen + 3 > 1023)
+        sprintf(titlebar, "%s:  ...%s", appname, filename+(alen+flen+6-1023));
+    else
+        sprintf(titlebar, "%s:  %s", appname, filename);
+
+
+    /* if the user didn't specify a background color on the command line,
+     * check for one in the PNG file--if not, the initialized values of 0
+     * (black) will be used */
+
+    if (have_bg) {
+        unsigned r, g, b;   /* this approach quiets compiler warnings */
+
+        sscanf(bgstr+1, "%2x%2x%2x", &r, &g, &b);
+        bg_red   = (uch)r;
+        bg_green = (uch)g;
+        bg_blue  = (uch)b;
+    } else if (readpng_get_bgcolor(&bg_red, &bg_green, &bg_blue) > 1) {
+        readpng_cleanup(TRUE);
+        fprintf(stderr, PROGNAME
+          ":  libpng error while checking for background color\n");
+        exit(2);
+    }
+
+
+    /* do the basic X initialization stuff, make the window and fill it
+     * with the background color */
+
+    if (rpng_x_create_window())
+        exit(2);
+
+
+    /* decode the image, all at once */
+
+    Trace((stderr, "calling readpng_get_image()\n"))
+    image_data = readpng_get_image(display_exponent, &image_channels,
+      &image_rowbytes);
+    Trace((stderr, "done with readpng_get_image()\n"))
+
+
+    /* done with PNG file, so clean up to minimize memory usage (but do NOT
+     * nuke image_data!) */
+
+    readpng_cleanup(FALSE);
+    fclose(infile);
+
+    if (!image_data) {
+        fprintf(stderr, PROGNAME ":  unable to decode PNG image\n");
+        exit(3);
+    }
+
+
+    /* display image (composite with background if requested) */
+
+    Trace((stderr, "calling rpng_x_display_image()\n"))
+    if (rpng_x_display_image()) {
+        free(image_data);
+        exit(4);
+    }
+    Trace((stderr, "done with rpng_x_display_image()\n"))
+
+
+    /* wait for the user to tell us when to quit */
+
+    printf(
+      "Done.  Press Q, Esc or mouse button 1 (within image window) to quit.\n");
+    fflush(stdout);
+
+    do
+        XNextEvent(display, &e);
+    while (!(e.type == ButtonPress && e.xbutton.button == Button1) &&
+           !(e.type == KeyPress &&    /*  v--- or 1 for shifted keys */
+             ((k = XLookupKeysym(&e.xkey, 0)) == XK_q || k == XK_Escape) ));
+
+
+    /* OK, we're done:  clean up all image and X resources and go away */
+
+    rpng_x_cleanup();
+
+    return 0;
+}
+
+
+
+
+
+static int rpng_x_create_window(void)
+{
+    uch *xdata;
+    int need_colormap = FALSE;
+    int screen, pad;
+    ulg bg_pixel = 0L;
+    ulg attrmask;
+    Window root;
+    XEvent e;
+    XGCValues gcvalues;
+    XSetWindowAttributes attr;
+    XTextProperty windowName, *pWindowName = &windowName;
+    XTextProperty iconName, *pIconName = &iconName;
+    XVisualInfo visual_info;
+    XSizeHints *size_hints;
+    XWMHints *wm_hints;
+    XClassHint *class_hints;
+
+
+    screen = DefaultScreen(display);
+    depth = DisplayPlanes(display, screen);
+    root = RootWindow(display, screen);
+
+#ifdef DEBUG
+    XSynchronize(display, True);
+#endif
+
+#if 0
+/* GRR:  add 8-bit support */
+    if (/* depth != 8 && */ depth != 16 && depth != 24 && depth != 32) {
+        fprintf(stderr,
+          "screen depth %d not supported (only 16-, 24- or 32-bit TrueColor)\n",
+          depth);
+        return 2;
+    }
+
+    XMatchVisualInfo(display, screen, depth,
+      (depth == 8)? PseudoColor : TrueColor, &visual_info);
+    visual = visual_info.visual;
+#else
+    if (depth != 16 && depth != 24 && depth != 32) {
+        int visuals_matched = 0;
+
+        Trace((stderr, "default depth is %d:  checking other visuals\n",
+          depth))
+
+        /* 24-bit first */
+        visual_info.screen = screen;
+        visual_info.depth = 24;
+        visual_list = XGetVisualInfo(display,
+          VisualScreenMask | VisualDepthMask, &visual_info, &visuals_matched);
+        if (visuals_matched == 0) {
+/* GRR:  add 15-, 16- and 32-bit TrueColor visuals (also DirectColor?) */
+            fprintf(stderr, "default screen depth %d not supported, and no"
+              " 24-bit visuals found\n", depth);
+            return 2;
+        }
+        Trace((stderr, "XGetVisualInfo() returned %d 24-bit visuals\n",
+          visuals_matched))
+        visual = visual_list[0].visual;
+        depth = visual_list[0].depth;
+/*
+        colormap_size = visual_list[0].colormap_size;
+        visual_class = visual->class;
+        visualID = XVisualIDFromVisual(visual);
+ */
+        have_nondefault_visual = TRUE;
+        need_colormap = TRUE;
+    } else {
+        XMatchVisualInfo(display, screen, depth, TrueColor, &visual_info);
+        visual = visual_info.visual;
+    }
+#endif
+
+    RMask = visual->red_mask;
+    GMask = visual->green_mask;
+    BMask = visual->blue_mask;
+
+/* GRR:  add/check 8-bit support */
+    if (depth == 8 || need_colormap) {
+        colormap = XCreateColormap(display, root, visual, AllocNone);
+        if (!colormap) {
+            fprintf(stderr, "XCreateColormap() failed\n");
+            return 2;
+        }
+        have_colormap = TRUE;
+    }
+    if (depth == 15 || depth == 16) {
+        RShift = 15 - rpng_x_msb(RMask);    /* these are right-shifts */
+        GShift = 15 - rpng_x_msb(GMask);
+        BShift = 15 - rpng_x_msb(BMask);
+    } else if (depth > 16) {
+#define NO_24BIT_MASKS
+#ifdef NO_24BIT_MASKS
+        RShift = rpng_x_msb(RMask) - 7;     /* these are left-shifts */
+        GShift = rpng_x_msb(GMask) - 7;
+        BShift = rpng_x_msb(BMask) - 7;
+#else
+        RShift = 7 - rpng_x_msb(RMask);     /* these are right-shifts, too */
+        GShift = 7 - rpng_x_msb(GMask);
+        BShift = 7 - rpng_x_msb(BMask);
+#endif
+    }
+    if (depth >= 15 && (RShift < 0 || GShift < 0 || BShift < 0)) {
+        fprintf(stderr, "rpng internal logic error:  negative X shift(s)!\n");
+        return 2;
+    }
+
+/*---------------------------------------------------------------------------
+    Finally, create the window.
+  ---------------------------------------------------------------------------*/
+
+    attr.backing_store = Always;
+    attr.event_mask = ExposureMask | KeyPressMask | ButtonPressMask;
+    attrmask = CWBackingStore | CWEventMask;
+    if (have_nondefault_visual) {
+        attr.colormap = colormap;
+        attr.background_pixel = 0;
+        attr.border_pixel = 1;
+        attrmask |= CWColormap | CWBackPixel | CWBorderPixel;
+    }
+
+    window = XCreateWindow(display, root, 0, 0, image_width, image_height, 0,
+      depth, InputOutput, visual, attrmask, &attr);
+
+    if (window == None) {
+        fprintf(stderr, "XCreateWindow() failed\n");
+        return 2;
+    } else
+        have_window = TRUE;
+
+    if (depth == 8)
+        XSetWindowColormap(display, window, colormap);
+
+    if (!XStringListToTextProperty(&window_name, 1, pWindowName))
+        pWindowName = NULL;
+    if (!XStringListToTextProperty(&icon_name, 1, pIconName))
+        pIconName = NULL;
+
+    /* OK if any hints allocation fails; XSetWMProperties() allows NULLs */
+
+    if ((size_hints = XAllocSizeHints()) != NULL) {
+        /* window will not be resizable */
+        size_hints->flags = PMinSize | PMaxSize;
+        size_hints->min_width = size_hints->max_width = (int)image_width;
+        size_hints->min_height = size_hints->max_height = (int)image_height;
+    }
+
+    if ((wm_hints = XAllocWMHints()) != NULL) {
+        wm_hints->initial_state = NormalState;
+        wm_hints->input = True;
+     /* wm_hints->icon_pixmap = icon_pixmap; */
+        wm_hints->flags = StateHint | InputHint  /* | IconPixmapHint */ ;
+    }
+
+    if ((class_hints = XAllocClassHint()) != NULL) {
+        class_hints->res_name = res_name;
+        class_hints->res_class = res_class;
+    }
+
+    XSetWMProperties(display, window, pWindowName, pIconName, NULL, 0,
+      size_hints, wm_hints, class_hints);
+
+    /* various properties and hints no longer needed; free memory */
+    if (pWindowName)
+       XFree(pWindowName->value);
+    if (pIconName)
+       XFree(pIconName->value);
+    if (size_hints)
+        XFree(size_hints);
+    if (wm_hints)
+       XFree(wm_hints);
+    if (class_hints)
+       XFree(class_hints);
+
+    XMapWindow(display, window);
+
+    gc = XCreateGC(display, window, 0, &gcvalues);
+    have_gc = TRUE;
+
+/*---------------------------------------------------------------------------
+    Fill window with the specified background color.
+  ---------------------------------------------------------------------------*/
+
+    if (depth == 24 || depth == 32) {
+        bg_pixel = ((ulg)bg_red   << RShift) |
+                   ((ulg)bg_green << GShift) |
+                   ((ulg)bg_blue  << BShift);
+    } else if (depth == 16) {
+        bg_pixel = ((((ulg)bg_red   << 8) >> RShift) & RMask) |
+                   ((((ulg)bg_green << 8) >> GShift) & GMask) |
+                   ((((ulg)bg_blue  << 8) >> BShift) & BMask);
+    } else /* depth == 8 */ {
+
+        /* GRR:  add 8-bit support */
+
+    }
+
+    XSetForeground(display, gc, bg_pixel);
+    XFillRectangle(display, window, gc, 0, 0, image_width, image_height);
+
+/*---------------------------------------------------------------------------
+    Wait for first Expose event to do any drawing, then flush.
+  ---------------------------------------------------------------------------*/
+
+    do
+        XNextEvent(display, &e);
+    while (e.type != Expose || e.xexpose.count);
+
+    XFlush(display);
+
+/*---------------------------------------------------------------------------
+    Allocate memory for the X- and display-specific version of the image.
+  ---------------------------------------------------------------------------*/
+
+    if (depth == 24 || depth == 32) {
+        xdata = (uch *)malloc(4*image_width*image_height);
+        pad = 32;
+    } else if (depth == 16) {
+        xdata = (uch *)malloc(2*image_width*image_height);
+        pad = 16;
+    } else /* depth == 8 */ {
+        xdata = (uch *)malloc(image_width*image_height);
+        pad = 8;
+    }
+
+    if (!xdata) {
+        fprintf(stderr, PROGNAME ":  unable to allocate image memory\n");
+        return 4;
+    }
+
+    ximage = XCreateImage(display, visual, depth, ZPixmap, 0,
+      (char *)xdata, image_width, image_height, pad, 0);
+
+    if (!ximage) {
+        fprintf(stderr, PROGNAME ":  XCreateImage() failed\n");
+        free(xdata);
+        return 3;
+    }
+
+    /* to avoid testing the byte order every pixel (or doubling the size of
+     * the drawing routine with a giant if-test), we arbitrarily set the byte
+     * order to MSBFirst and let Xlib worry about inverting things on little-
+     * endian machines (like Linux/x86, old VAXen, etc.)--this is not the most
+     * efficient approach (the giant if-test would be better), but in the
+     * interest of clarity, we take the easy way out... */
+
+    ximage->byte_order = MSBFirst;
+
+    return 0;
+
+} /* end function rpng_x_create_window() */
+
+
+
+
+
+static int rpng_x_display_image(void)
+{
+    uch *src;
+    char *dest;
+    uch r, g, b, a;
+    ulg i, row, lastrow = 0;
+    ulg pixel;
+    int ximage_rowbytes = ximage->bytes_per_line;
+/*  int bpp = ximage->bits_per_pixel;  */
+
+
+    Trace((stderr, "beginning display loop (image_channels == %d)\n",
+      image_channels))
+    Trace((stderr, "   (width = %ld, rowbytes = %ld, ximage_rowbytes = %d)\n",
+      image_width, image_rowbytes, ximage_rowbytes))
+    Trace((stderr, "   (bpp = %d)\n", ximage->bits_per_pixel))
+    Trace((stderr, "   (byte_order = %s)\n", ximage->byte_order == MSBFirst?
+      "MSBFirst" : (ximage->byte_order == LSBFirst? "LSBFirst" : "unknown")))
+
+    if (depth == 24 || depth == 32) {
+        ulg red, green, blue;
+
+        for (lastrow = row = 0;  row < image_height;  ++row) {
+            src = image_data + row*image_rowbytes;
+            dest = ximage->data + row*ximage_rowbytes;
+            if (image_channels == 3) {
+                for (i = image_width;  i > 0;  --i) {
+                    red   = *src++;
+                    green = *src++;
+                    blue  = *src++;
+#ifdef NO_24BIT_MASKS
+                    pixel = (red   << RShift) |
+                            (green << GShift) |
+                            (blue  << BShift);
+                    /* recall that we set ximage->byte_order = MSBFirst above */
+                    /* GRR BUG:  this assumes bpp == 32, but may be 24: */
+                    *dest++ = (char)((pixel >> 24) & 0xff);
+                    *dest++ = (char)((pixel >> 16) & 0xff);
+                    *dest++ = (char)((pixel >>  8) & 0xff);
+                    *dest++ = (char)( pixel        & 0xff);
+#else
+                    red   = (RShift < 0)? red   << (-RShift) : red   >> RShift;
+                    green = (GShift < 0)? green << (-GShift) : green >> GShift;
+                    blue  = (BShift < 0)? blue  << (-BShift) : blue  >> BShift;
+                    pixel = (red & RMask) | (green & GMask) | (blue & BMask);
+                    /* recall that we set ximage->byte_order = MSBFirst above */
+                    *dest++ = (char)((pixel >> 24) & 0xff);
+                    *dest++ = (char)((pixel >> 16) & 0xff);
+                    *dest++ = (char)((pixel >>  8) & 0xff);
+                    *dest++ = (char)( pixel        & 0xff);
+#endif
+                }
+            } else /* if (image_channels == 4) */ {
+                for (i = image_width;  i > 0;  --i) {
+                    r = *src++;
+                    g = *src++;
+                    b = *src++;
+                    a = *src++;
+                    if (a == 255) {
+                        red   = r;
+                        green = g;
+                        blue  = b;
+                    } else if (a == 0) {
+                        red   = bg_red;
+                        green = bg_green;
+                        blue  = bg_blue;
+                    } else {
+                        /* this macro (from png.h) composites the foreground
+                         * and background values and puts the result into the
+                         * first argument */
+                        alpha_composite(red,   r, a, bg_red);
+                        alpha_composite(green, g, a, bg_green);
+                        alpha_composite(blue,  b, a, bg_blue);
+                    }
+                    pixel = (red   << RShift) |
+                            (green << GShift) |
+                            (blue  << BShift);
+                    /* recall that we set ximage->byte_order = MSBFirst above */
+                    *dest++ = (char)((pixel >> 24) & 0xff);
+                    *dest++ = (char)((pixel >> 16) & 0xff);
+                    *dest++ = (char)((pixel >>  8) & 0xff);
+                    *dest++ = (char)( pixel        & 0xff);
+                }
+            }
+            /* display after every 16 lines */
+            if (((row+1) & 0xf) == 0) {
+                XPutImage(display, window, gc, ximage, 0, (int)lastrow, 0,
+                  (int)lastrow, image_width, 16);
+                XFlush(display);
+                lastrow = row + 1;
+            }
+        }
+
+    } else if (depth == 16) {
+        ush red, green, blue;
+
+        for (lastrow = row = 0;  row < image_height;  ++row) {
+            src = image_data + row*image_rowbytes;
+            dest = ximage->data + row*ximage_rowbytes;
+            if (image_channels == 3) {
+                for (i = image_width;  i > 0;  --i) {
+                    red   = ((ush)(*src) << 8);
+                    ++src;
+                    green = ((ush)(*src) << 8);
+                    ++src;
+                    blue  = ((ush)(*src) << 8);
+                    ++src;
+                    pixel = ((red   >> RShift) & RMask) |
+                            ((green >> GShift) & GMask) |
+                            ((blue  >> BShift) & BMask);
+                    /* recall that we set ximage->byte_order = MSBFirst above */
+                    *dest++ = (char)((pixel >>  8) & 0xff);
+                    *dest++ = (char)( pixel        & 0xff);
+                }
+            } else /* if (image_channels == 4) */ {
+                for (i = image_width;  i > 0;  --i) {
+                    r = *src++;
+                    g = *src++;
+                    b = *src++;
+                    a = *src++;
+                    if (a == 255) {
+                        red   = ((ush)r << 8);
+                        green = ((ush)g << 8);
+                        blue  = ((ush)b << 8);
+                    } else if (a == 0) {
+                        red   = ((ush)bg_red   << 8);
+                        green = ((ush)bg_green << 8);
+                        blue  = ((ush)bg_blue  << 8);
+                    } else {
+                        /* this macro (from png.h) composites the foreground
+                         * and background values and puts the result back into
+                         * the first argument (== fg byte here:  safe) */
+                        alpha_composite(r, r, a, bg_red);
+                        alpha_composite(g, g, a, bg_green);
+                        alpha_composite(b, b, a, bg_blue);
+                        red   = ((ush)r << 8);
+                        green = ((ush)g << 8);
+                        blue  = ((ush)b << 8);
+                    }
+                    pixel = ((red   >> RShift) & RMask) |
+                            ((green >> GShift) & GMask) |
+                            ((blue  >> BShift) & BMask);
+                    /* recall that we set ximage->byte_order = MSBFirst above */
+                    *dest++ = (char)((pixel >>  8) & 0xff);
+                    *dest++ = (char)( pixel        & 0xff);
+                }
+            }
+            /* display after every 16 lines */
+            if (((row+1) & 0xf) == 0) {
+                XPutImage(display, window, gc, ximage, 0, (int)lastrow, 0,
+                  (int)lastrow, image_width, 16);
+                XFlush(display);
+                lastrow = row + 1;
+            }
+        }
+
+    } else /* depth == 8 */ {
+
+        /* GRR:  add 8-bit support */
+
+    }
+
+    Trace((stderr, "calling final XPutImage()\n"))
+    if (lastrow < image_height) {
+        XPutImage(display, window, gc, ximage, 0, (int)lastrow, 0,
+          (int)lastrow, image_width, image_height-lastrow);
+        XFlush(display);
+    }
+
+    return 0;
+}
+
+
+
+
+static void rpng_x_cleanup(void)
+{
+    if (image_data) {
+        free(image_data);
+        image_data = NULL;
+    }
+
+    if (ximage) {
+        if (ximage->data) {
+            free(ximage->data);           /* we allocated it, so we free it */
+            ximage->data = (char *)NULL;  /*  instead of XDestroyImage() */
+        }
+        XDestroyImage(ximage);
+        ximage = NULL;
+    }
+
+    if (have_gc)
+        XFreeGC(display, gc);
+
+    if (have_window)
+        XDestroyWindow(display, window);
+
+    if (have_colormap)
+        XFreeColormap(display, colormap);
+
+    if (have_nondefault_visual)
+        XFree(visual_list);
+}
+
+
+
+
+
+static int rpng_x_msb(ulg u32val)
+{
+    int i;
+
+    for (i = 31;  i >= 0;  --i) {
+        if (u32val & 0x80000000L)
+            break;
+        u32val <<= 1;
+    }
+    return i;
+}

contrib/gregbook/wpng.c

@@ -0,0 +1,853 @@
+/*---------------------------------------------------------------------------
+
+   wpng - simple PNG-writing program                                 wpng.c
+
+   This program converts certain NetPBM binary files (grayscale and RGB,
+   maxval = 255) to PNG.  Non-interlaced PNGs are written progressively;
+   interlaced PNGs are read and written in one memory-intensive blast.
+
+   Thanks to Jean-loup Gailly for providing the necessary trick to read
+   interactive text from the keyboard while stdin is redirected.  Thanks
+   to Cosmin Truta for Cygwin fixes.
+
+   NOTE:  includes provisional support for PNM type "8" (portable alphamap)
+          images, presumed to be a 32-bit interleaved RGBA format; no pro-
+          vision for possible interleaved grayscale+alpha (16-bit) format.
+          THIS IS UNLIKELY TO BECOME AN OFFICIAL NETPBM ALPHA FORMAT!
+
+   to do:
+    - delete output file if quit before calling any writepng routines
+    - process backspace with -text option under DOS/Win? (currently get ^H)
+
+  ---------------------------------------------------------------------------
+
+   Changelog:
+    - 1.01:  initial public release
+    - 1.02:  modified to allow abbreviated options
+    - 1.03:  removed extraneous character from usage screen; fixed bug in
+              command-line parsing
+    - 1.04:  fixed DOS/OS2/Win32 detection, including partial Cygwin fix
+              (see http://home.att.net/~perlspinr/diffs/GregBook_cygwin.diff)
+    - 2.00:  dual-licensed (added GNU GPL)
+
+        [REPORTED BUG (win32 only):  "contrib/gregbook/wpng.c - cmd line
+         dose not work!  In order to do something useful I needed to redirect
+         both input and output, with cygwin and with bcc32 as well.  Under
+         Linux, the same wpng appears to work fine.  I don't know what is
+         the problem."]
+
+  ---------------------------------------------------------------------------
+
+      Copyright (c) 1998-2007 Greg Roelofs.  All rights reserved.
+
+      This software is provided "as is," without warranty of any kind,
+      express or implied.  In no event shall the author or contributors
+      be held liable for any damages arising in any way from the use of
+      this software.
+
+      The contents of this file are DUAL-LICENSED.  You may modify and/or
+      redistribute this software according to the terms of one of the
+      following two licenses (at your option):
+
+
+      LICENSE 1 ("BSD-like with advertising clause"):
+
+      Permission is granted to anyone to use this software for any purpose,
+      including commercial applications, and to alter it and redistribute
+      it freely, subject to the following restrictions:
+
+      1. Redistributions of source code must retain the above copyright
+         notice, disclaimer, and this list of conditions.
+      2. Redistributions in binary form must reproduce the above copyright
+         notice, disclaimer, and this list of conditions in the documenta-
+         tion and/or other materials provided with the distribution.
+      3. All advertising materials mentioning features or use of this
+         software must display the following acknowledgment:
+
+            This product includes software developed by Greg Roelofs
+            and contributors for the book, "PNG: The Definitive Guide,"
+            published by O'Reilly and Associates.
+
+
+      LICENSE 2 (GNU GPL v2 or later):
+
+      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 of the License, 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, write to the Free Software Foundation,
+      Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+  ---------------------------------------------------------------------------*/
+
+#define PROGNAME  "wpng"
+#define VERSION   "2.00 of 2 June 2007"
+#define APPNAME   "Simple PGM/PPM/PAM to PNG Converter"
+
+#if defined(__MSDOS__) || defined(__OS2__)
+#  define DOS_OS2_W32
+#elif defined(WIN32) || defined(_WIN32) || defined(__WIN32__)
+#  ifndef __GNUC__   /* treat Win32 native ports of gcc as Unix environments */
+#    define DOS_OS2_W32
+#  endif
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <setjmp.h>     /* for jmpbuf declaration in writepng.h */
+#include <time.h>
+
+#ifdef DOS_OS2_W32
+#  include <io.h>       /* for isatty(), setmode() prototypes */
+#  include <fcntl.h>    /* O_BINARY for fdopen() without text translation */
+#  ifdef __EMX__
+#    ifndef getch
+#      define getch() _read_kbd(0, 1, 0)    /* need getche() */
+#    endif
+#  else /* !__EMX__ */
+#    ifdef __GO32__
+#      include <pc.h>
+#      define getch() getkey()  /* GRR:  need getche() */
+#    else
+#      include <conio.h>        /* for getche() console input */
+#    endif
+#  endif /* ?__EMX__ */
+#  define FGETS(buf,len,stream)  dos_kbd_gets(buf,len)
+#else
+#  include <unistd.h>           /* for isatty() prototype */
+#  define FGETS fgets
+#endif
+
+/* #define DEBUG  :  this enables the Trace() macros */
+
+/* #define FORBID_LATIN1_CTRL  :  this requires the user to re-enter any
+   text that includes control characters discouraged by the PNG spec; text
+   that includes an escape character (27) must be re-entered regardless */
+
+#include "writepng.h"   /* typedefs, common macros, writepng prototypes */
+
+
+
+/* local prototypes */
+
+static int  wpng_isvalid_latin1(uch *p, int len);
+static void wpng_cleanup(void);
+
+#ifdef DOS_OS2_W32
+   static char *dos_kbd_gets(char *buf, int len);
+#endif
+
+
+
+static mainprog_info wpng_info;   /* lone global */
+
+
+
+int main(int argc, char **argv)
+{
+#ifndef DOS_OS2_W32
+    FILE *keybd;
+#endif
+#ifdef sgi
+    FILE *tmpfile;      /* or we could just use keybd, since no overlap */
+    char tmpline[80];
+#endif
+    char *inname = NULL, outname[256];
+    char *p, pnmchar, pnmline[256];
+    char *bgstr, *textbuf = NULL;
+    ulg rowbytes;
+    int rc, len = 0;
+    int error = 0;
+    int text = FALSE;
+    int maxval;
+    double LUT_exponent;                /* just the lookup table */
+    double CRT_exponent = 2.2;          /* just the monitor */
+    double default_display_exponent;    /* whole display system */
+    double default_gamma = 0.0;
+
+
+    wpng_info.infile = NULL;
+    wpng_info.outfile = NULL;
+    wpng_info.image_data = NULL;
+    wpng_info.row_pointers = NULL;
+    wpng_info.filter = FALSE;
+    wpng_info.interlaced = FALSE;
+    wpng_info.have_bg = FALSE;
+    wpng_info.have_time = FALSE;
+    wpng_info.have_text = 0;
+    wpng_info.gamma = 0.0;
+
+
+    /* First get the default value for our display-system exponent, i.e.,
+     * the product of the CRT exponent and the exponent corresponding to
+     * the frame-buffer's lookup table (LUT), if any.  If the PNM image
+     * looks correct on the user's display system, its file gamma is the
+     * inverse of this value.  (Note that this is not an exhaustive list
+     * of LUT values--e.g., OpenStep has a lot of weird ones--but it should
+     * cover 99% of the current possibilities.  This section must ensure
+     * that default_display_exponent is positive.) */
+
+#if defined(NeXT)
+    /* third-party utilities can modify the default LUT exponent */
+    LUT_exponent = 1.0 / 2.2;
+    /*
+    if (some_next_function_that_returns_gamma(&next_gamma))
+        LUT_exponent = 1.0 / next_gamma;
+     */
+#elif defined(sgi)
+    LUT_exponent = 1.0 / 1.7;
+    /* there doesn't seem to be any documented function to
+     * get the "gamma" value, so we do it the hard way */
+    tmpfile = fopen("/etc/config/system.glGammaVal", "r");
+    if (tmpfile) {
+        double sgi_gamma;
+
+        fgets(tmpline, 80, tmpfile);
+        fclose(tmpfile);
+        sgi_gamma = atof(tmpline);
+        if (sgi_gamma > 0.0)
+            LUT_exponent = 1.0 / sgi_gamma;
+    }
+#elif defined(Macintosh)
+    LUT_exponent = 1.8 / 2.61;
+    /*
+    if (some_mac_function_that_returns_gamma(&mac_gamma))
+        LUT_exponent = mac_gamma / 2.61;
+     */
+#else
+    LUT_exponent = 1.0;   /* assume no LUT:  most PCs */
+#endif
+
+    /* the defaults above give 1.0, 1.3, 1.5 and 2.2, respectively: */
+    default_display_exponent = LUT_exponent * CRT_exponent;
+
+
+    /* If the user has set the SCREEN_GAMMA environment variable as suggested
+     * (somewhat imprecisely) in the libpng documentation, use that; otherwise
+     * use the default value we just calculated.  Either way, the user may
+     * override this via a command-line option. */
+
+    if ((p = getenv("SCREEN_GAMMA")) != NULL) {
+        double exponent = atof(p);
+
+        if (exponent > 0.0)
+            default_gamma = 1.0 / exponent;
+    }
+
+    if (default_gamma == 0.0)
+        default_gamma = 1.0 / default_display_exponent;
+
+
+    /* Now parse the command line for options and the PNM filename. */
+
+    while (*++argv && !error) {
+        if (!strncmp(*argv, "-i", 2)) {
+            wpng_info.interlaced = TRUE;
+        } else if (!strncmp(*argv, "-time", 3)) {
+            wpng_info.modtime = time(NULL);
+            wpng_info.have_time = TRUE;
+        } else if (!strncmp(*argv, "-text", 3)) {
+            text = TRUE;
+        } else if (!strncmp(*argv, "-gamma", 2)) {
+            if (!*++argv)
+                ++error;
+            else {
+                wpng_info.gamma = atof(*argv);
+                if (wpng_info.gamma <= 0.0)
+                    ++error;
+                else if (wpng_info.gamma > 1.01)
+                    fprintf(stderr, PROGNAME
+                      " warning:  file gammas are usually less than 1.0\n");
+            }
+        } else if (!strncmp(*argv, "-bgcolor", 4)) {
+            if (!*++argv)
+                ++error;
+            else {
+                bgstr = *argv;
+                if (strlen(bgstr) != 7 || bgstr[0] != '#')
+                    ++error;
+                else {
+                    unsigned r, g, b;  /* this way quiets compiler warnings */
+
+                    sscanf(bgstr+1, "%2x%2x%2x", &r, &g, &b);
+                    wpng_info.bg_red   = (uch)r;
+                    wpng_info.bg_green = (uch)g;
+                    wpng_info.bg_blue  = (uch)b;
+                    wpng_info.have_bg = TRUE;
+                }
+            }
+        } else {
+            if (**argv != '-') {
+                inname = *argv;
+                if (argv[1])   /* shouldn't be any more args after filename */
+                    ++error;
+            } else
+                ++error;   /* not expecting any other options */
+        }
+    }
+
+
+    /* open the input and output files, or register an error and abort */
+
+    if (!inname) {
+        if (isatty(0)) {
+            fprintf(stderr, PROGNAME
+              ":  must give input filename or provide image data via stdin\n");
+            ++error;
+        } else {
+#ifdef DOS_OS2_W32
+            /* some buggy C libraries require BOTH setmode() and fdopen(bin) */
+            setmode(fileno(stdin), O_BINARY);
+            setmode(fileno(stdout), O_BINARY);
+#endif
+            if ((wpng_info.infile = fdopen(fileno(stdin), "rb")) == NULL) {
+                fprintf(stderr, PROGNAME
+                  ":  unable to reopen stdin in binary mode\n");
+                ++error;
+            } else
+            if ((wpng_info.outfile = fdopen(fileno(stdout), "wb")) == NULL) {
+                fprintf(stderr, PROGNAME
+                  ":  unable to reopen stdout in binary mode\n");
+                fclose(wpng_info.infile);
+                ++error;
+            } else
+                wpng_info.filter = TRUE;
+        }
+    } else if ((len = strlen(inname)) > 250) {
+        fprintf(stderr, PROGNAME ":  input filename is too long [%d chars]\n",
+          len);
+        ++error;
+    } else if (!(wpng_info.infile = fopen(inname, "rb"))) {
+        fprintf(stderr, PROGNAME ":  can't open input file [%s]\n", inname);
+        ++error;
+    }
+
+    if (!error) {
+        fgets(pnmline, 256, wpng_info.infile);
+        if (pnmline[0] != 'P' || ((pnmchar = pnmline[1]) != '5' &&
+            pnmchar != '6' && pnmchar != '8'))
+        {
+            fprintf(stderr, PROGNAME
+              ":  input file [%s] is not a binary PGM, PPM or PAM file\n",
+              inname);
+            ++error;
+        } else {
+            wpng_info.pnmtype = (int)(pnmchar - '0');
+            if (wpng_info.pnmtype != 8)
+                wpng_info.have_bg = FALSE;  /* no need for bg if opaque */
+            do {
+                fgets(pnmline, 256, wpng_info.infile);  /* lose any comments */
+            } while (pnmline[0] == '#');
+            sscanf(pnmline, "%ld %ld", &wpng_info.width, &wpng_info.height);
+            do {
+                fgets(pnmline, 256, wpng_info.infile);  /* more comment lines */
+            } while (pnmline[0] == '#');
+            sscanf(pnmline, "%d", &maxval);
+            if (wpng_info.width <= 0L || wpng_info.height <= 0L ||
+                maxval != 255)
+            {
+                fprintf(stderr, PROGNAME
+                  ":  only positive width/height, maxval == 255 allowed \n");
+                ++error;
+            }
+            wpng_info.sample_depth = 8;  /* <==> maxval 255 */
+
+            if (!wpng_info.filter) {
+                /* make outname from inname */
+                if ((p = strrchr(inname, '.')) == NULL ||
+                    (p - inname) != (len - 4))
+                {
+                    strcpy(outname, inname);
+                    strcpy(outname+len, ".png");
+                } else {
+                    len -= 4;
+                    strncpy(outname, inname, len);
+                    strcpy(outname+len, ".png");
+                }
+                /* check if outname already exists; if not, open */
+                if ((wpng_info.outfile = fopen(outname, "rb")) != NULL) {
+                    fprintf(stderr, PROGNAME ":  output file exists [%s]\n",
+                      outname);
+                    fclose(wpng_info.outfile);
+                    ++error;
+                } else if (!(wpng_info.outfile = fopen(outname, "wb"))) {
+                    fprintf(stderr, PROGNAME ":  can't open output file [%s]\n",
+                      outname);
+                    ++error;
+                }
+            }
+        }
+        if (error) {
+            fclose(wpng_info.infile);
+            wpng_info.infile = NULL;
+            if (wpng_info.filter) {
+                fclose(wpng_info.outfile);
+                wpng_info.outfile = NULL;
+            }
+        }
+    }
+
+
+    /* if we had any errors, print usage and die horrible death...arrr! */
+
+    if (error) {
+        fprintf(stderr, "\n%s %s:  %s\n", PROGNAME, VERSION, APPNAME);
+        writepng_version_info();
+        fprintf(stderr, "\n"
+"Usage:  %s [-gamma exp] [-bgcolor bg] [-text] [-time] [-interlace] pnmfile\n"
+"or: ... | %s [-gamma exp] [-bgcolor bg] [-text] [-time] [-interlace] | ...\n"
+         "    exp \ttransfer-function exponent (``gamma'') of the image in\n"
+         "\t\t  floating-point format (e.g., ``%.5f''); if image looks\n"
+         "\t\t  correct on given display system, image gamma is equal to\n"
+         "\t\t  inverse of display-system exponent, i.e., 1 / (LUT * CRT)\n"
+         "\t\t  (where LUT = lookup-table exponent and CRT = CRT exponent;\n"
+         "\t\t  first varies, second is usually 2.2, all are positive)\n"
+         "    bg  \tdesired background color for alpha-channel images, in\n"
+         "\t\t  7-character hex RGB format (e.g., ``#ff7700'' for orange:\n"
+         "\t\t  same as HTML colors)\n"
+         "    -text\tprompt interactively for text info (tEXt chunks)\n"
+         "    -time\tinclude a tIME chunk (last modification time)\n"
+         "    -interlace\twrite interlaced PNG image\n"
+         "\n"
+"pnmfile or stdin must be a binary PGM (`P5'), PPM (`P6') or (extremely\n"
+"unofficial and unsupported!) PAM (`P8') file.  Currently it is required\n"
+"to have maxval == 255 (i.e., no scaling).  If pnmfile is specified, it\n"
+"is converted to the corresponding PNG file with the same base name but a\n"
+"``.png'' extension; files read from stdin are converted and sent to stdout.\n"
+"The conversion is progressive (low memory usage) unless interlacing is\n"
+"requested; in that case the whole image will be buffered in memory and\n"
+"written in one call.\n"
+         "\n", PROGNAME, PROGNAME, default_gamma);
+        exit(1);
+    }
+
+
+    /* prepare the text buffers for libpng's use; note that even though
+     * PNG's png_text struct includes a length field, we don't have to fill
+     * it out */
+
+    if (text &&
+#ifndef DOS_OS2_W32
+        (keybd = fdopen(fileno(stderr), "r")) != NULL &&
+#endif
+        (textbuf = (char *)malloc((5 + 9)*75)) != NULL)
+    {
+        int i, valid, result;
+
+        fprintf(stderr,
+          "Enter text info (no more than 72 characters per line);\n");
+        fprintf(stderr, "to skip a field, hit the <Enter> key.\n");
+        /* note:  just <Enter> leaves len == 1 */
+
+        do {
+            valid = TRUE;
+            p = textbuf + TEXT_TITLE_OFFSET;
+            fprintf(stderr, "  Title: ");
+            fflush(stderr);
+            if (FGETS(p, 74, keybd) && (len = strlen(p)) > 1) {
+                if (p[len-1] == '\n')
+                    p[--len] = '\0';
+                wpng_info.title = p;
+                wpng_info.have_text |= TEXT_TITLE;
+                if ((result = wpng_isvalid_latin1((uch *)p, len)) >= 0) {
+                    fprintf(stderr, "    " PROGNAME " warning:  character code"
+                      " %u is %sdiscouraged by the PNG\n    specification "
+                      "[first occurrence was at character position #%d]\n",
+                      (unsigned)p[result], (p[result] == 27)? "strongly " : "",
+                      result+1);
+                    fflush(stderr);
+#ifdef FORBID_LATIN1_CTRL
+                    wpng_info.have_text &= ~TEXT_TITLE;
+                    valid = FALSE;
+#else
+                    if (p[result] == 27) {    /* escape character */
+                        wpng_info.have_text &= ~TEXT_TITLE;
+                        valid = FALSE;
+                    }
+#endif
+                }
+            }
+        } while (!valid);
+
+        do {
+            valid = TRUE;
+            p = textbuf + TEXT_AUTHOR_OFFSET;
+            fprintf(stderr, "  Author: ");
+            fflush(stderr);
+            if (FGETS(p, 74, keybd) && (len = strlen(p)) > 1) {
+                if (p[len-1] == '\n')
+                    p[--len] = '\0';
+                wpng_info.author = p;
+                wpng_info.have_text |= TEXT_AUTHOR;
+                if ((result = wpng_isvalid_latin1((uch *)p, len)) >= 0) {
+                    fprintf(stderr, "    " PROGNAME " warning:  character code"
+                      " %u is %sdiscouraged by the PNG\n    specification "
+                      "[first occurrence was at character position #%d]\n",
+                      (unsigned)p[result], (p[result] == 27)? "strongly " : "",
+                      result+1);
+                    fflush(stderr);
+#ifdef FORBID_LATIN1_CTRL
+                    wpng_info.have_text &= ~TEXT_AUTHOR;
+                    valid = FALSE;
+#else
+                    if (p[result] == 27) {    /* escape character */
+                        wpng_info.have_text &= ~TEXT_AUTHOR;
+                        valid = FALSE;
+                    }
+#endif
+                }
+            }
+        } while (!valid);
+
+        do {
+            valid = TRUE;
+            p = textbuf + TEXT_DESC_OFFSET;
+            fprintf(stderr, "  Description (up to 9 lines):\n");
+            for (i = 1;  i < 10;  ++i) {
+                fprintf(stderr, "    [%d] ", i);
+                fflush(stderr);
+                if (FGETS(p, 74, keybd) && (len = strlen(p)) > 1)
+                    p += len;   /* now points at NULL; char before is newline */
+                else
+                    break;
+            }
+            if ((len = p - (textbuf + TEXT_DESC_OFFSET)) > 1) {
+                if (p[-1] == '\n') {
+                    p[-1] = '\0';
+                    --len;
+                }
+                wpng_info.desc = textbuf + TEXT_DESC_OFFSET;
+                wpng_info.have_text |= TEXT_DESC;
+                p = textbuf + TEXT_DESC_OFFSET;
+                if ((result = wpng_isvalid_latin1((uch *)p, len)) >= 0) {
+                    fprintf(stderr, "    " PROGNAME " warning:  character code"
+                      " %u is %sdiscouraged by the PNG\n    specification "
+                      "[first occurrence was at character position #%d]\n",
+                      (unsigned)p[result], (p[result] == 27)? "strongly " : "",
+                      result+1);
+                    fflush(stderr);
+#ifdef FORBID_LATIN1_CTRL
+                    wpng_info.have_text &= ~TEXT_DESC;
+                    valid = FALSE;
+#else
+                    if (p[result] == 27) {    /* escape character */
+                        wpng_info.have_text &= ~TEXT_DESC;
+                        valid = FALSE;
+                    }
+#endif
+                }
+            }
+        } while (!valid);
+
+        do {
+            valid = TRUE;
+            p = textbuf + TEXT_COPY_OFFSET;
+            fprintf(stderr, "  Copyright: ");
+            fflush(stderr);
+            if (FGETS(p, 74, keybd) && (len = strlen(p)) > 1) {
+                if (p[len-1] == '\n')
+                    p[--len] = '\0';
+                wpng_info.copyright = p;
+                wpng_info.have_text |= TEXT_COPY;
+                if ((result = wpng_isvalid_latin1((uch *)p, len)) >= 0) {
+                    fprintf(stderr, "    " PROGNAME " warning:  character code"
+                      " %u is %sdiscouraged by the PNG\n    specification "
+                      "[first occurrence was at character position #%d]\n",
+                      (unsigned)p[result], (p[result] == 27)? "strongly " : "",
+                      result+1);
+                    fflush(stderr);
+#ifdef FORBID_LATIN1_CTRL
+                    wpng_info.have_text &= ~TEXT_COPY;
+                    valid = FALSE;
+#else
+                    if (p[result] == 27) {    /* escape character */
+                        wpng_info.have_text &= ~TEXT_COPY;
+                        valid = FALSE;
+                    }
+#endif
+                }
+            }
+        } while (!valid);
+
+        do {
+            valid = TRUE;
+            p = textbuf + TEXT_EMAIL_OFFSET;
+            fprintf(stderr, "  E-mail: ");
+            fflush(stderr);
+            if (FGETS(p, 74, keybd) && (len = strlen(p)) > 1) {
+                if (p[len-1] == '\n')
+                    p[--len] = '\0';
+                wpng_info.email = p;
+                wpng_info.have_text |= TEXT_EMAIL;
+                if ((result = wpng_isvalid_latin1((uch *)p, len)) >= 0) {
+                    fprintf(stderr, "    " PROGNAME " warning:  character code"
+                      " %u is %sdiscouraged by the PNG\n    specification "
+                      "[first occurrence was at character position #%d]\n",
+                      (unsigned)p[result], (p[result] == 27)? "strongly " : "",
+                      result+1);
+                    fflush(stderr);
+#ifdef FORBID_LATIN1_CTRL
+                    wpng_info.have_text &= ~TEXT_EMAIL;
+                    valid = FALSE;
+#else
+                    if (p[result] == 27) {    /* escape character */
+                        wpng_info.have_text &= ~TEXT_EMAIL;
+                        valid = FALSE;
+                    }
+#endif
+                }
+            }
+        } while (!valid);
+
+        do {
+            valid = TRUE;
+            p = textbuf + TEXT_URL_OFFSET;
+            fprintf(stderr, "  URL: ");
+            fflush(stderr);
+            if (FGETS(p, 74, keybd) && (len = strlen(p)) > 1) {
+                if (p[len-1] == '\n')
+                    p[--len] = '\0';
+                wpng_info.url = p;
+                wpng_info.have_text |= TEXT_URL;
+                if ((result = wpng_isvalid_latin1((uch *)p, len)) >= 0) {
+                    fprintf(stderr, "    " PROGNAME " warning:  character code"
+                      " %u is %sdiscouraged by the PNG\n    specification "
+                      "[first occurrence was at character position #%d]\n",
+                      (unsigned)p[result], (p[result] == 27)? "strongly " : "",
+                      result+1);
+                    fflush(stderr);
+#ifdef FORBID_LATIN1_CTRL
+                    wpng_info.have_text &= ~TEXT_URL;
+                    valid = FALSE;
+#else
+                    if (p[result] == 27) {    /* escape character */
+                        wpng_info.have_text &= ~TEXT_URL;
+                        valid = FALSE;
+                    }
+#endif
+                }
+            }
+        } while (!valid);
+
+#ifndef DOS_OS2_W32
+        fclose(keybd);
+#endif
+
+    } else if (text) {
+        fprintf(stderr, PROGNAME ":  unable to allocate memory for text\n");
+        text = FALSE;
+        wpng_info.have_text = 0;
+    }
+
+
+    /* allocate libpng stuff, initialize transformations, write pre-IDAT data */
+
+    if ((rc = writepng_init(&wpng_info)) != 0) {
+        switch (rc) {
+            case 2:
+                fprintf(stderr, PROGNAME
+                  ":  libpng initialization problem (longjmp)\n");
+                break;
+            case 4:
+                fprintf(stderr, PROGNAME ":  insufficient memory\n");
+                break;
+            case 11:
+                fprintf(stderr, PROGNAME
+                  ":  internal logic error (unexpected PNM type)\n");
+                break;
+            default:
+                fprintf(stderr, PROGNAME
+                  ":  unknown writepng_init() error\n");
+                break;
+        }
+        exit(rc);
+    }
+
+
+    /* free textbuf, since it's a completely local variable and all text info
+     * has just been written to the PNG file */
+
+    if (text && textbuf) {
+        free(textbuf);
+        textbuf = NULL;
+    }
+
+
+    /* calculate rowbytes on basis of image type; note that this becomes much
+     * more complicated if we choose to support PBM type, ASCII PNM types, or
+     * 16-bit-per-sample binary data [currently not an official NetPBM type] */
+
+    if (wpng_info.pnmtype == 5)
+        rowbytes = wpng_info.width;
+    else if (wpng_info.pnmtype == 6)
+        rowbytes = wpng_info.width * 3;
+    else /* if (wpng_info.pnmtype == 8) */
+        rowbytes = wpng_info.width * 4;
+
+
+    /* read and write the image, either in its entirety (if writing interlaced
+     * PNG) or row by row (if non-interlaced) */
+
+    fprintf(stderr, "Encoding image data...\n");
+    fflush(stderr);
+
+    if (wpng_info.interlaced) {
+        long i;
+        ulg bytes;
+        ulg image_bytes = rowbytes * wpng_info.height;   /* overflow? */
+
+        wpng_info.image_data = (uch *)malloc(image_bytes);
+        wpng_info.row_pointers = (uch **)malloc(wpng_info.height*sizeof(uch *));
+        if (wpng_info.image_data == NULL || wpng_info.row_pointers == NULL) {
+            fprintf(stderr, PROGNAME ":  insufficient memory for image data\n");
+            writepng_cleanup(&wpng_info);
+            wpng_cleanup();
+            exit(5);
+        }
+        for (i = 0;  i < wpng_info.height;  ++i)
+            wpng_info.row_pointers[i] = wpng_info.image_data + i*rowbytes;
+        bytes = fread(wpng_info.image_data, 1, image_bytes, wpng_info.infile);
+        if (bytes != image_bytes) {
+            fprintf(stderr, PROGNAME ":  expected %lu bytes, got %lu bytes\n",
+              image_bytes, bytes);
+            fprintf(stderr, "  (continuing anyway)\n");
+        }
+        if (writepng_encode_image(&wpng_info) != 0) {
+            fprintf(stderr, PROGNAME
+              ":  libpng problem (longjmp) while writing image data\n");
+            writepng_cleanup(&wpng_info);
+            wpng_cleanup();
+            exit(2);
+        }
+
+    } else /* not interlaced:  write progressively (row by row) */ {
+        long j;
+        ulg bytes;
+
+        wpng_info.image_data = (uch *)malloc(rowbytes);
+        if (wpng_info.image_data == NULL) {
+            fprintf(stderr, PROGNAME ":  insufficient memory for row data\n");
+            writepng_cleanup(&wpng_info);
+            wpng_cleanup();
+            exit(5);
+        }
+        error = 0;
+        for (j = wpng_info.height;  j > 0L;  --j) {
+            bytes = fread(wpng_info.image_data, 1, rowbytes, wpng_info.infile);
+            if (bytes != rowbytes) {
+                fprintf(stderr, PROGNAME
+                  ":  expected %lu bytes, got %lu bytes (row %ld)\n", rowbytes,
+                  bytes, wpng_info.height-j);
+                ++error;
+                break;
+            }
+            if (writepng_encode_row(&wpng_info) != 0) {
+                fprintf(stderr, PROGNAME
+                  ":  libpng problem (longjmp) while writing row %ld\n",
+                  wpng_info.height-j);
+                ++error;
+                break;
+            }
+        }
+        if (error) {
+            writepng_cleanup(&wpng_info);
+            wpng_cleanup();
+            exit(2);
+        }
+        if (writepng_encode_finish(&wpng_info) != 0) {
+            fprintf(stderr, PROGNAME ":  error on final libpng call\n");
+            writepng_cleanup(&wpng_info);
+            wpng_cleanup();
+            exit(2);
+        }
+    }
+
+
+    /* OK, we're done (successfully):  clean up all resources and quit */
+
+    fprintf(stderr, "Done.\n");
+    fflush(stderr);
+
+    writepng_cleanup(&wpng_info);
+    wpng_cleanup();
+
+    return 0;
+}
+
+
+
+
+
+static int wpng_isvalid_latin1(uch *p, int len)
+{
+    int i, result = -1;
+
+    for (i = 0;  i < len;  ++i) {
+        if (p[i] == 10 || (p[i] > 31 && p[i] < 127) || p[i] > 160)
+            continue;           /* character is completely OK */
+        if (result < 0 || (p[result] != 27 && p[i] == 27))
+            result = i;         /* mark location of first questionable one */
+    }                           /*  or of first escape character (bad) */
+
+    return result;
+}
+
+
+
+
+
+static void wpng_cleanup(void)
+{
+    if (wpng_info.outfile) {
+        fclose(wpng_info.outfile);
+        wpng_info.outfile = NULL;
+    }
+
+    if (wpng_info.infile) {
+        fclose(wpng_info.infile);
+        wpng_info.infile = NULL;
+    }
+
+    if (wpng_info.image_data) {
+        free(wpng_info.image_data);
+        wpng_info.image_data = NULL;
+    }
+
+    if (wpng_info.row_pointers) {
+        free(wpng_info.row_pointers);
+        wpng_info.row_pointers = NULL;
+    }
+}
+
+
+
+
+#ifdef DOS_OS2_W32
+
+static char *dos_kbd_gets(char *buf, int len)
+{
+    int ch, count=0;
+
+    do {
+        buf[count++] = ch = getche();
+    } while (ch != '\r' && count < len-1);
+
+    buf[count--] = '\0';        /* terminate string */
+    if (buf[count] == '\r')     /* Enter key makes CR, so change to newline */
+        buf[count] = '\n';
+
+    fprintf(stderr, "\n");      /* Enter key does *not* cause a newline */
+    fflush(stderr);
+
+    return buf;
+}
+
+#endif /* DOS_OS2_W32 */

contrib/gregbook/writepng.c

@@ -0,0 +1,401 @@
+/*---------------------------------------------------------------------------
+
+   wpng - simple PNG-writing program                             writepng.c
+
+  ---------------------------------------------------------------------------
+
+      Copyright (c) 1998-2007 Greg Roelofs.  All rights reserved.
+
+      This software is provided "as is," without warranty of any kind,
+      express or implied.  In no event shall the author or contributors
+      be held liable for any damages arising in any way from the use of
+      this software.
+
+      The contents of this file are DUAL-LICENSED.  You may modify and/or
+      redistribute this software according to the terms of one of the
+      following two licenses (at your option):
+
+
+      LICENSE 1 ("BSD-like with advertising clause"):
+
+      Permission is granted to anyone to use this software for any purpose,
+      including commercial applications, and to alter it and redistribute
+      it freely, subject to the following restrictions:
+
+      1. Redistributions of source code must retain the above copyright
+         notice, disclaimer, and this list of conditions.
+      2. Redistributions in binary form must reproduce the above copyright
+         notice, disclaimer, and this list of conditions in the documenta-
+         tion and/or other materials provided with the distribution.
+      3. All advertising materials mentioning features or use of this
+         software must display the following acknowledgment:
+
+            This product includes software developed by Greg Roelofs
+            and contributors for the book, "PNG: The Definitive Guide,"
+            published by O'Reilly and Associates.
+
+
+      LICENSE 2 (GNU GPL v2 or later):
+
+      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 of the License, 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, write to the Free Software Foundation,
+      Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+  ---------------------------------------------------------------------------*/
+
+
+#include <stdlib.h>     /* for exit() prototype */
+#include <zlib.h>
+
+#include "png.h"        /* libpng header, includes setjmp.h */
+#include "writepng.h"   /* typedefs, common macros, public prototypes */
+
+
+/* local prototype */
+
+static void writepng_error_handler(png_structp png_ptr, png_const_charp msg);
+
+
+
+void writepng_version_info(void)
+{
+  fprintf(stderr, "   Compiled with libpng %s; using libpng %s.\n",
+    PNG_LIBPNG_VER_STRING, png_libpng_ver);
+  fprintf(stderr, "   Compiled with zlib %s; using zlib %s.\n",
+    ZLIB_VERSION, zlib_version);
+}
+
+
+
+
+/* returns 0 for success, 2 for libpng problem, 4 for out of memory, 11 for
+ *  unexpected pnmtype; note that outfile might be stdout */
+
+int writepng_init(mainprog_info *mainprog_ptr)
+{
+    png_structp  png_ptr;       /* note:  temporary variables! */
+    png_infop  info_ptr;
+    int color_type, interlace_type;
+
+
+    /* could also replace libpng warning-handler (final NULL), but no need: */
+
+    png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, mainprog_ptr,
+      writepng_error_handler, NULL);
+    if (!png_ptr)
+        return 4;   /* out of memory */
+
+    info_ptr = png_create_info_struct(png_ptr);
+    if (!info_ptr) {
+        png_destroy_write_struct(&png_ptr, NULL);
+        return 4;   /* out of memory */
+    }
+
+
+    /* 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: */
+
+    if (setjmp(mainprog_ptr->jmpbuf)) {
+        png_destroy_write_struct(&png_ptr, &info_ptr);
+        return 2;
+    }
+
+
+    /* make sure outfile is (re)opened in BINARY mode */
+
+    png_init_io(png_ptr, mainprog_ptr->outfile);
+
+
+    /* set the compression levels--in general, always want to leave filtering
+     * turned on (except for palette images) and allow all of the filters,
+     * which is the default; want 32K zlib window, unless entire image buffer
+     * is 16K or smaller (unknown here)--also the default; usually want max
+     * compression (NOT the default); and remaining compression flags should
+     * be left alone */
+
+    png_set_compression_level(png_ptr, Z_BEST_COMPRESSION);
+/*
+    >> this is default for no filtering; Z_FILTERED is default otherwise:
+    png_set_compression_strategy(png_ptr, Z_DEFAULT_STRATEGY);
+    >> these are all defaults:
+    png_set_compression_mem_level(png_ptr, 8);
+    png_set_compression_window_bits(png_ptr, 15);
+    png_set_compression_method(png_ptr, 8);
+ */
+
+
+    /* set the image parameters appropriately */
+
+    if (mainprog_ptr->pnmtype == 5)
+        color_type = PNG_COLOR_TYPE_GRAY;
+    else if (mainprog_ptr->pnmtype == 6)
+        color_type = PNG_COLOR_TYPE_RGB;
+    else if (mainprog_ptr->pnmtype == 8)
+        color_type = PNG_COLOR_TYPE_RGB_ALPHA;
+    else {
+        png_destroy_write_struct(&png_ptr, &info_ptr);
+        return 11;
+    }
+
+    interlace_type = mainprog_ptr->interlaced? PNG_INTERLACE_ADAM7 :
+                                               PNG_INTERLACE_NONE;
+
+    png_set_IHDR(png_ptr, info_ptr, mainprog_ptr->width, mainprog_ptr->height,
+      mainprog_ptr->sample_depth, color_type, interlace_type,
+      PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
+
+    if (mainprog_ptr->gamma > 0.0)
+        png_set_gAMA(png_ptr, info_ptr, mainprog_ptr->gamma);
+
+    if (mainprog_ptr->have_bg) {   /* we know it's RGBA, not gray+alpha */
+        png_color_16  background;
+
+        background.red = mainprog_ptr->bg_red;
+        background.green = mainprog_ptr->bg_green;
+        background.blue = mainprog_ptr->bg_blue;
+        png_set_bKGD(png_ptr, info_ptr, &background);
+    }
+
+    if (mainprog_ptr->have_time) {
+        png_time  modtime;
+
+        png_convert_from_time_t(&modtime, mainprog_ptr->modtime);
+        png_set_tIME(png_ptr, info_ptr, &modtime);
+    }
+
+    if (mainprog_ptr->have_text) {
+        png_text  text[6];
+        int  num_text = 0;
+
+        if (mainprog_ptr->have_text & TEXT_TITLE) {
+            text[num_text].compression = PNG_TEXT_COMPRESSION_NONE;
+            text[num_text].key = "Title";
+            text[num_text].text = mainprog_ptr->title;
+            ++num_text;
+        }
+        if (mainprog_ptr->have_text & TEXT_AUTHOR) {
+            text[num_text].compression = PNG_TEXT_COMPRESSION_NONE;
+            text[num_text].key = "Author";
+            text[num_text].text = mainprog_ptr->author;
+            ++num_text;
+        }
+        if (mainprog_ptr->have_text & TEXT_DESC) {
+            text[num_text].compression = PNG_TEXT_COMPRESSION_NONE;
+            text[num_text].key = "Description";
+            text[num_text].text = mainprog_ptr->desc;
+            ++num_text;
+        }
+        if (mainprog_ptr->have_text & TEXT_COPY) {
+            text[num_text].compression = PNG_TEXT_COMPRESSION_NONE;
+            text[num_text].key = "Copyright";
+            text[num_text].text = mainprog_ptr->copyright;
+            ++num_text;
+        }
+        if (mainprog_ptr->have_text & TEXT_EMAIL) {
+            text[num_text].compression = PNG_TEXT_COMPRESSION_NONE;
+            text[num_text].key = "E-mail";
+            text[num_text].text = mainprog_ptr->email;
+            ++num_text;
+        }
+        if (mainprog_ptr->have_text & TEXT_URL) {
+            text[num_text].compression = PNG_TEXT_COMPRESSION_NONE;
+            text[num_text].key = "URL";
+            text[num_text].text = mainprog_ptr->url;
+            ++num_text;
+        }
+        png_set_text(png_ptr, info_ptr, text, num_text);
+    }
+
+
+    /* write all chunks up to (but not including) first IDAT */
+
+    png_write_info(png_ptr, info_ptr);
+
+
+    /* if we wanted to write any more text info *after* the image data, we
+     * would set up text struct(s) here and call png_set_text() again, with
+     * just the new data; png_set_tIME() could also go here, but it would
+     * have no effect since we already called it above (only one tIME chunk
+     * allowed) */
+
+
+    /* set up the transformations:  for now, just pack low-bit-depth pixels
+     * into bytes (one, two or four pixels per byte) */
+
+    png_set_packing(png_ptr);
+/*  png_set_shift(png_ptr, &sig_bit);  to scale low-bit-depth values */
+
+
+    /* make sure we save our pointers for use in writepng_encode_image() */
+
+    mainprog_ptr->png_ptr = png_ptr;
+    mainprog_ptr->info_ptr = info_ptr;
+
+
+    /* OK, that's all we need to do for now; return happy */
+
+    return 0;
+}
+
+
+
+
+
+/* returns 0 for success, 2 for libpng (longjmp) problem */
+
+int writepng_encode_image(mainprog_info *mainprog_ptr)
+{
+    png_structp png_ptr = (png_structp)mainprog_ptr->png_ptr;
+    png_infop info_ptr = (png_infop)mainprog_ptr->info_ptr;
+
+
+    /* as always, setjmp() must be called in every function that calls a
+     * PNG-writing libpng function */
+
+    if (setjmp(mainprog_ptr->jmpbuf)) {
+        png_destroy_write_struct(&png_ptr, &info_ptr);
+        mainprog_ptr->png_ptr = NULL;
+        mainprog_ptr->info_ptr = NULL;
+        return 2;
+    }
+
+
+    /* and now we just write the whole image; libpng takes care of interlacing
+     * for us */
+
+    png_write_image(png_ptr, mainprog_ptr->row_pointers);
+
+
+    /* since that's it, we also close out the end of the PNG file now--if we
+     * had any text or time info to write after the IDATs, second argument
+     * would be info_ptr, but we optimize slightly by sending NULL pointer: */
+
+    png_write_end(png_ptr, NULL);
+
+    return 0;
+}
+
+
+
+
+
+/* returns 0 if succeeds, 2 if libpng problem */
+
+int writepng_encode_row(mainprog_info *mainprog_ptr)  /* NON-interlaced only! */
+{
+    png_structp png_ptr = (png_structp)mainprog_ptr->png_ptr;
+    png_infop info_ptr = (png_infop)mainprog_ptr->info_ptr;
+
+
+    /* as always, setjmp() must be called in every function that calls a
+     * PNG-writing libpng function */
+
+    if (setjmp(mainprog_ptr->jmpbuf)) {
+        png_destroy_write_struct(&png_ptr, &info_ptr);
+        mainprog_ptr->png_ptr = NULL;
+        mainprog_ptr->info_ptr = NULL;
+        return 2;
+    }
+
+
+    /* image_data points at our one row of image data */
+
+    png_write_row(png_ptr, mainprog_ptr->image_data);
+
+    return 0;
+}
+
+
+
+
+
+/* returns 0 if succeeds, 2 if libpng problem */
+
+int writepng_encode_finish(mainprog_info *mainprog_ptr)   /* NON-interlaced! */
+{
+    png_structp png_ptr = (png_structp)mainprog_ptr->png_ptr;
+    png_infop info_ptr = (png_infop)mainprog_ptr->info_ptr;
+
+
+    /* as always, setjmp() must be called in every function that calls a
+     * PNG-writing libpng function */
+
+    if (setjmp(mainprog_ptr->jmpbuf)) {
+        png_destroy_write_struct(&png_ptr, &info_ptr);
+        mainprog_ptr->png_ptr = NULL;
+        mainprog_ptr->info_ptr = NULL;
+        return 2;
+    }
+
+
+    /* close out PNG file; if we had any text or time info to write after
+     * the IDATs, second argument would be info_ptr: */
+
+    png_write_end(png_ptr, NULL);
+
+    return 0;
+}
+
+
+
+
+
+void writepng_cleanup(mainprog_info *mainprog_ptr)
+{
+    png_structp png_ptr = (png_structp)mainprog_ptr->png_ptr;
+    png_infop info_ptr = (png_infop)mainprog_ptr->info_ptr;
+
+    if (png_ptr && info_ptr)
+        png_destroy_write_struct(&png_ptr, &info_ptr);
+}
+
+
+
+
+
+static void writepng_error_handler(png_structp png_ptr, png_const_charp msg)
+{
+    mainprog_info  *mainprog_ptr;
+
+    /* This function, aside from the extra step of retrieving the "error
+     * pointer" (below) and the fact that it exists within the application
+     * rather than within libpng, is essentially identical to libpng's
+     * default error handler.  The second point is critical:  since both
+     * setjmp() and longjmp() are called from the same code, they are
+     * guaranteed to have compatible notions of how big a jmp_buf is,
+     * regardless of whether _BSD_SOURCE or anything else has (or has not)
+     * been defined. */
+
+    fprintf(stderr, "writepng libpng error: %s\n", msg);
+    fflush(stderr);
+
+    mainprog_ptr = png_get_error_ptr(png_ptr);
+    if (mainprog_ptr == NULL) {         /* we are completely hosed now */
+        fprintf(stderr,
+          "writepng severe error:  jmpbuf not recoverable; terminating.\n");
+        fflush(stderr);
+        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/writepng.h

@@ -0,0 +1,133 @@
+/*---------------------------------------------------------------------------
+
+   wpng - simple PNG-writing program                             writepng.h
+
+  ---------------------------------------------------------------------------
+
+      Copyright (c) 1998-2007 Greg Roelofs.  All rights reserved.
+
+      This software is provided "as is," without warranty of any kind,
+      express or implied.  In no event shall the author or contributors
+      be held liable for any damages arising in any way from the use of
+      this software.
+
+      The contents of this file are DUAL-LICENSED.  You may modify and/or
+      redistribute this software according to the terms of one of the
+      following two licenses (at your option):
+
+
+      LICENSE 1 ("BSD-like with advertising clause"):
+
+      Permission is granted to anyone to use this software for any purpose,
+      including commercial applications, and to alter it and redistribute
+      it freely, subject to the following restrictions:
+
+      1. Redistributions of source code must retain the above copyright
+         notice, disclaimer, and this list of conditions.
+      2. Redistributions in binary form must reproduce the above copyright
+         notice, disclaimer, and this list of conditions in the documenta-
+         tion and/or other materials provided with the distribution.
+      3. All advertising materials mentioning features or use of this
+         software must display the following acknowledgment:
+
+            This product includes software developed by Greg Roelofs
+            and contributors for the book, "PNG: The Definitive Guide,"
+            published by O'Reilly and Associates.
+
+
+      LICENSE 2 (GNU GPL v2 or later):
+
+      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 of the License, 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, write to the Free Software Foundation,
+      Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+  ---------------------------------------------------------------------------*/
+
+#ifndef TRUE
+#  define TRUE 1
+#  define FALSE 0
+#endif
+
+#ifndef MAX
+#  define MAX(a,b)  ((a) > (b)? (a) : (b))
+#  define MIN(a,b)  ((a) < (b)? (a) : (b))
+#endif
+
+#ifdef DEBUG
+#  define Trace(x)  {fprintf x ; fflush(stderr); fflush(stdout);}
+#else
+#  define Trace(x)  ;
+#endif
+
+#define TEXT_TITLE    0x01
+#define TEXT_AUTHOR   0x02
+#define TEXT_DESC     0x04
+#define TEXT_COPY     0x08
+#define TEXT_EMAIL    0x10
+#define TEXT_URL      0x20
+
+#define TEXT_TITLE_OFFSET        0
+#define TEXT_AUTHOR_OFFSET      72
+#define TEXT_COPY_OFFSET     (2*72)
+#define TEXT_EMAIL_OFFSET    (3*72)
+#define TEXT_URL_OFFSET      (4*72)
+#define TEXT_DESC_OFFSET     (5*72)
+
+typedef unsigned char   uch;
+typedef unsigned short  ush;
+typedef unsigned long   ulg;
+
+typedef struct _mainprog_info {
+    double gamma;
+    long width;
+    long height;
+    time_t modtime;
+    FILE *infile;
+    FILE *outfile;
+    void *png_ptr;
+    void *info_ptr;
+    uch *image_data;
+    uch **row_pointers;
+    char *title;
+    char *author;
+    char *desc;
+    char *copyright;
+    char *email;
+    char *url;
+    int filter;    /* command-line-filter flag, not PNG row filter! */
+    int pnmtype;
+    int sample_depth;
+    int interlaced;
+    int have_bg;
+    int have_time;
+    int have_text;
+    jmp_buf jmpbuf;
+    uch bg_red;
+    uch bg_green;
+    uch bg_blue;
+} mainprog_info;
+
+
+/* prototypes for public functions in writepng.c */
+
+void writepng_version_info(void);
+
+int writepng_init(mainprog_info *mainprog_ptr);
+
+int writepng_encode_image(mainprog_info *mainprog_ptr);
+
+int writepng_encode_row(mainprog_info *mainprog_ptr);
+
+int writepng_encode_finish(mainprog_info *mainprog_ptr);
+
+void writepng_cleanup(mainprog_info *mainprog_ptr);

contrib/libtests/fakepng.c

@@ -0,0 +1,57 @@
+/* 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

@@ -0,0 +1,102 @@
+#!/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

@@ -0,0 +1,104 @@
+/* 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

@@ -0,0 +1,999 @@
+
+/* 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

@@ -0,0 +1,303 @@
+/* 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

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

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

contrib/pngminim/decoder/makefile

@@ -0,0 +1,151 @@
+# Makefile for PngMinus (pngm2pnm)
+# Linux / Unix
+
+#CC=cc
+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
+
+C=.c
+O=.o
+L=.a
+E=
+
+# Where to find the source code:
+PNGSRC =../../..
+ZLIBSRC=$(PNGSRC)/../zlib
+PROGSRC=$(PNGSRC)/contrib/pngminus
+
+# 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) \
+	pngread$(O) pngrio$(O) pngrtran$(O) pngrutil$(O) \
+	pngset$(O) pngtrans$(O)
+
+PROGSRCS= pngm2pnm$(C)
+PROGHDRS=
+PROGDOCS=
+PROGOBJS= pngm2pnm$(O)
+
+OBJS    = $(PROGOBJS) $(PNGOBJS) $(ZOBJS)
+
+# implicit make rules -------------------------------------------------------
+
+# note: dependencies do not work on implicit rule lines
+.c$(O):
+	$(CC) $(CPPFLAGS) -c $(CFLAGS) $<
+
+# dependencies
+
+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" $@
+
+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

@@ -0,0 +1,40 @@
+# 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

@@ -0,0 +1,24 @@
+/* minrdpngconf.h: headers to make a minimal png-read-only library
+ *
+ * Copyright (c) 2007, 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
+ *
+ * Derived from pngcrush.h, Copyright 1998-2007, Glenn Randers-Pehrson
+ */
+
+#ifndef MINRDPNGCONF_H
+#define MINRDPNGCONF_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_WARNINGS
+#define PNG_ALIGN_TYPE PNG_ALIGN_NONE
+
+#endif /* MINRDPNGCONF_H */

contrib/pngminim/encoder/README

@@ -0,0 +1,10 @@
+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.
+
+If you prefer to use the shared libraries, go to contrib/pngminus
+and build the pnm2png application there.

contrib/pngminim/encoder/makefile

@@ -0,0 +1,150 @@
+# Makefile for PngMinus (pnm2pngm)
+# Linux / Unix
+
+#CC=cc
+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
+
+C=.c
+O=.o
+L=.a
+E=
+
+# Where to find the source code:
+PNGSRC =../../..
+ZLIBSRC=$(PNGSRC)/../zlib
+PROGSRC=$(PNGSRC)/contrib/pngminus
+
+# 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) \
+	pngset$(O) pngtrans$(O) pngwio$(O) pngwrite$(O) \
+	pngwtran$(O) pngwutil$(O)
+
+PROGSRCS= pnm2pngm$(C)
+PROGHDRS=
+PROGDOCS=
+PROGOBJS= pnm2pngm$(O)
+
+OBJS    = $(PROGOBJS) $(PNGOBJS) $(ZOBJS)
+
+# implicit make rules -------------------------------------------------------
+
+.c$(O):
+	$(CC) $(CPPFLAGS) -c $(CFLAGS) $<
+
+# dependencies
+
+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" $@
+
+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

@@ -0,0 +1,39 @@
+# 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

@@ -0,0 +1,24 @@
+/* minwrpngconf.h: headers to make a minimal png-write-only library
+ *
+ * Copyright (c) 2007, 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
+ *
+ * Derived from pngcrush.h, Copyright 1998-2007, Glenn Randers-Pehrson
+ */
+
+#ifndef MINWRPNGCONF_H
+#define MINWRPNGCONF_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_WARNINGS
+#define PNG_ALIGN_TYPE PNG_ALIGN_NONE
+
+#endif /* MINWRPNGCONF_H */

contrib/pngminim/preader/README

@@ -0,0 +1,15 @@
+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.
+
+Specify the location of the zlib source (1.2.1 or later) as ZLIBSRC
+on the make command line.
+
+Edit makefile if required, to find your X library and include files,
+then
+
+    make ZLIBSRC=directory
+
+If you prefer to use the shared libraries, go to contrib/gregbook
+and build the rpng2-x application there.

contrib/pngminim/preader/makefile

@@ -0,0 +1,166 @@
+# Makefile for PngMinus (rpng2)
+# Linux / Unix
+
+#CC=cc
+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)
+
+#XINC = -I/usr/openwin/include		# Sun workstations (OpenWindows)
+#XLIB = -L/usr/openwin/lib -lX11
+
+XINC = -I/usr/X11R6/include		# new X distributions (X.org, etc.)
+XLIB = -L/usr/X11R6/lib -lX11
+#XLIB = -L/usr/X11R6/lib64 -lX11	# e.g., Red Hat on AMD64
+
+#XINC = -I/usr/local/include   		# FreeBSD
+#XLIB = -L/usr/local/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
+
+C=.c
+O=.o
+L=.a
+E=
+
+# Where to find the source code:
+PNGSRC =../../..
+ZLIBSRC=$(PNGSRC)/../zlib
+PROGSRC=$(PNGSRC)/contrib/gregbook
+
+# 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) \
+	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)
+
+# implicit make rules -------------------------------------------------------
+
+.c$(O):
+	$(CC) $(CPPFLAGS) -c $(CFLAGS) $<
+
+# dependencies
+
+all: $(PROGDOCS) 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" $@
+
+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

@@ -0,0 +1,40 @@
+# 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

@@ -0,0 +1,24 @@
+/* minrdpngconf.h: headers to make a minimal png-read-only library
+ *
+ * Copyright (c) 2009, 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
+ *
+ * Derived from pngcrush.h, Copyright 1998-2007, Glenn Randers-Pehrson
+ */
+
+#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_WARNINGS
+#define PNG_ALIGN_TYPE PNG_ALIGN_NONE
+
+#endif /* MINPRDPNGCONF_H */

contrib/pngminus/README

@@ -0,0 +1,153 @@
+PngMinus
+--------
+(copyright Willem van Schaik, 1999)
+
+
+License
+-------
+
+Permission to use, copy, modify, and distribute this software and
+its documentation for any purpose and without fee is hereby granted,
+provided that the above copyright notice appear in all copies and
+that both that copyright notice and this permission notice appear in
+supporting documentation. This software is provided "as is" without
+express or implied warranty.
+
+
+Some history
+------------
+Soon after the creation of PNG in 1995, the need was felt for a set of
+pnmtopng / pngtopnm utilities. Independantly Alexander Lehmann and I
+(Willem van Schaik) started such a project. Luckily we discovered this
+and merged the two together into pnmtopng.tar.gz, which is available
+from a/o ftp://ftp.simplesystems.org/pub/libpng/png/.
+
+These two utilities have many, many options and make use of most of the
+features of PNG, like gamma, alpha, sbit, text-chunks, etc. This makes
+the utilities quite complex and by now not anymore very maintainable.
+When we wrote these programs, libpng was still in an early stage.
+Therefore, lots of the functionality that we put in our software can now
+be done using transform-functions in libpng.
+
+Finally, to compile these programs, you need to have installed and
+compiled three libraries: libpng, zlib and netpbm. Especially the latter
+makes the whole setup a bit bulky. But that's unavoidable given the many
+features of pnmtopng.
+
+
+What now
+--------
+At this moment libpng is in a very stable state and can do much of the
+work done in pnmtopng. Also, pnmtopng needs to be upgraded to the new
+interface of libpng. Hence, it is time for a rewrite from the ground up
+of pnmtopng and pngtopnm. This will happen in the near future (stay
+tuned). The new package will get a different name to distinguish it from
+the old one: PngPlus.
+
+To experiment a bit with the new interface of libpng, I started off with
+a small prototype that contains only the basic functionality. It doesn't
+have any of the options to read or write special chunks and it will do
+no gamma correction. But this makes it also a simple program that is
+quite easy to understand and can serve well as a template for other
+software developments. (By now there are of course a couple of programs,
+like Greg Roelofs' rpng/wpng, that can be used just as good.)
+
+
+Can and can not
+---------------
+As this is the small brother of the future PngPlus, I called this fellow
+PngMinus. Because I started this development in good-old Turbo-C, I
+avoided the use the netpbm library, which requires DOS extenders. Again,
+another reason to call it PngMinus (minus netpbm :-). So, part of the
+program are some elementary routines to read / write pgm- and ppm-files.
+It does not read b&w pbm-files.
+
+The downside of this approach is that you can not use them on images
+that require blocks of memory bigger than 64k (the DOS version). For
+larger images you will get an out-of-memory error.
+
+As said before, PngMinus doesn't correct for gamma. When reading
+png-files you can do this just as well by piping the output of png2pnm
+to pnmgamma, one of the standard PbmPlus tools. This same scenario will
+most probably also be followed in the full-blown future PngPlus, with
+the addition of course of the possibility to create gamma-chunks when
+writing png-files.
+
+On the other hand it supports alpha-channels. When reading a png-image
+you can write the alpha-channel into a pgm-file. And when creating an
+RGB+A png-image, you just combine a ppm-file with a corresponding
+pgm-file containing the alpha-channel. When reading, transparency chunks
+are converted into an alpha-channel and from there on treated the same
+way.
+
+Finally you can opt for writing ascii or binary pgm- and ppm-files. When
+the bit-depth is 16, the format will always be ascii.
+
+
+Using it
+--------
+To distinguish them from pnmtopng and PngPlus, the utilities are named
+png2pnm and pnm2png (2 instead of to). The input- and output-files can
+be given as parameters or through redirection. Therefore the programs
+can be part of a pipe.
+
+To list the options type "png2pnm -h" or "pnm2png -h".
+
+
+Just like Scandinavian furniture
+--------------------------------
+You have to put it together yourself. I did test the software under
+MS-DOS with Turbo-C 3.0 and under RedHat Linux 4.2 with gcc. In both
+cases I used libpng-1.0.4 and zlib-1.1.3. Later versions should be OK,
+however some older libpng versions have a bug in pngmem.c when using
+Turbo-C 3.0 (see below).
+
+You can build it using one of the two makefiles (make -f makefile.###)
+or use the batch/script files pngminus.bat / pngminus.sh. This assumes
+that you have built the libraries in ../libpng and ../zlib. Using Linux,
+make sure that you have built libpng with makefile.std and not
+makefile.linux (also called .lnx in earlier versions of libpng). The
+latter creates a .so shared-library, while the PngMinus makefile assumes
+a normal .a static library.
+
+If you create a ../pngsuite directory and then store the basn####.png
+files from PngSuite (http://www.schaik.com/pngsuite/) in there, you can
+test in one go the proper functioning of PngMinus, see png2pnm.bat and
+pnm2png.bat (or the .sh versions).
+
+
+Warranty
+-------
+Please, remember that this was just a small experiment to learn a few
+things. It will have many unforeseen features <vbg>. Who said bugs? Use
+it when you are in need for something simple or when you want to start
+developing your own stuff.
+
+
+The Turbo bug
+-------------
+** pngmem.old
+          hptr = (png_byte huge *)((long)(hptr) & 0xfffffff0L);
+          hptr += 16L;
+** pngmem.c
+          hptr = (png_byte huge *)((long)(hptr) & 0xfffffff0L);
+          hptr = hptr + 16L;
+**
+
+** pngmem.old
+          png_ptr->offset_table_ptr[i] = (png_bytep)hptr;
+          hptr += (png_uint_32)65536L;
+** pngmem.c
+          png_ptr->offset_table_ptr[i] = (png_bytep)hptr;
+          hptr = hptr + 65536L;
+**
+
+
+The end
+-------
+Willem van Schaik
+mailto:willem@schaik.com
+http://www.schaik.com/png/
+-------
+Oct 1999
+

contrib/pngminus/makefile.std

@@ -0,0 +1,65 @@
+# Makefile for PngMinus (png2pnm and pnm2png)
+# Linux / Unix
+
+#CC=cc
+CC=gcc
+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../..
+PNGLIB = -L../.. -lpng
+PNGLIBS = ../../libpng.a
+
+#ZPATH = /usr/local
+#ZINC = -I$(ZPATH)/include
+#ZLIB = -L$(ZPATH)/lib -lz
+#ZLIBS = $(ZPATH)/lib/libz.a
+ZINC = -I../../../zlib
+ZLIB = -L../../../zlib -lz
+ZLIBS = ../../../zlib/libz.a
+
+CFLAGS=$(PNGINC) $(ZINC)
+LDLIBS=$(PNGLIB) $(ZLIB)
+LDLIBSS=$(PNGLIBS) $(ZLIBS)
+C=.c
+O=.o
+L=.a
+E=
+
+# dependencies
+
+#all: png2pnm$(E) pnm2png$(E)
+all: png2pnm$(E) pnm2png$(E) png2pnm-static$(E) pnm2png-static$(E)
+
+png2pnm$(O): png2pnm$(C)
+	$(CC) -c $(CFLAGS) png2pnm$(C)
+
+png2pnm$(E): png2pnm$(O)
+	$(LD) $(LDFLAGS) -o png2pnm$(E) png2pnm$(O) $(LDLIBS) -lm
+
+png2pnm-static$(E): png2pnm$(O)
+	$(LD) $(LDFLAGS) -o png2pnm-static$(E) png2pnm$(O) $(LDLIBSS) -lm
+
+pnm2png$(O): pnm2png$(C)
+	$(CC) -c $(CFLAGS) pnm2png$(C)
+
+pnm2png$(E): pnm2png$(O)
+	$(LD) $(LDFLAGS) -o pnm2png$(E) pnm2png$(O) $(LDLIBS) -lm
+
+pnm2png-static$(E): pnm2png$(O)
+	$(LD) $(LDFLAGS) -o pnm2png-static$(E) pnm2png$(O) $(LDLIBSS) -lm
+
+clean:
+	$(RM) png2pnm$(O)
+	$(RM) pnm2png$(O)
+	$(RM) png2pnm$(E)
+	$(RM) pnm2png$(E)
+	$(RM) png2pnm-static$(E)
+	$(RM) pnm2png-static$(E)
+
+# End of makefile for png2pnm / pnm2png

contrib/pngminus/makefile.tc3

@@ -0,0 +1,38 @@
+# Makefile for PngMinus (png2pnm and pnm2png)
+# TurboC++ 3.0
+
+CC=tcc -Ic:\tc3\inc
+LD=tcc -Lc:\tc3\lib
+LB=tlib
+RM=del
+CP=copy
+MODEL=l
+CCFLAGS=-O -m$(MODEL) -I..\libpng -I..\zlib
+LDFLAGS=-m$(MODEL) -L..\libpng -L..\zlib
+C=.c
+O=.obj
+L=.lib
+E=.exe
+
+# dependencies
+
+all: png2pnm$(E) pnm2png$(E)
+
+png2pnm$(O): png2pnm$(C)
+        $(CC) -c $(CCFLAGS) png2pnm$(C)
+
+png2pnm$(E): png2pnm$(O)
+        $(LD) $(LDFLAGS) png2pnm$(O) libpng$(L) zlib$(L)
+
+pnm2png$(O): pnm2png$(C)
+        $(CC) -c $(CCFLAGS) pnm2png$(C)
+
+pnm2png$(E): pnm2png$(O)
+        $(LD) $(LDFLAGS) pnm2png$(O) libpng$(L) zlib$(L)
+
+clean:
+        $(RM) *$(O)
+        $(RM) *$(E)
+
+# End of makefile for png2pnm / pnm2png
+

contrib/pngminus/makevms.com

@@ -0,0 +1,92 @@
+$!------------------------------------------------------------------------------
+$! make Contrib programs of libpng under OpenVMS
+$!
+$!
+$! Look for the compiler used
+$!
+$ zlibsrc = "[---.zlib]"
+$ ccopt="/include=(''zlibsrc',[--])"
+$ if f$getsyi("HW_MODEL").ge.1024
+$ then
+$  ccopt = "/prefix=all"+ccopt
+$  comp  = "__decc__=1"
+$  if f$trnlnm("SYS").eqs."" then define sys sys$library:
+$ else
+$  if f$search("SYS$SYSTEM:DECC$COMPILER.EXE").eqs.""
+$   then
+$    if f$trnlnm("SYS").eqs."" then define sys sys$library:
+$    if f$search("SYS$SYSTEM:VAXC.EXE").eqs.""
+$     then
+$      comp  = "__gcc__=1"
+$      CC :== GCC
+$     else
+$      comp = "__vaxc__=1"
+$     endif
+$   else
+$    if f$trnlnm("SYS").eqs."" then define sys decc$library_include:
+$    ccopt = "/decc/prefix=all"+ccopt
+$    comp  = "__decc__=1"
+$  endif
+$ endif
+$ open/write lopt lib.opt
+$ write lopt "[--]libpng.olb/lib"
+$ write lopt "''zlibsrc'libz.olb/lib"
+$ close lopt
+$ open/write xopt x11.opt
+$ write xopt "sys$library:decw$xlibshr.exe/share"
+$ close xopt
+$ write sys$output "Compiling PNG contrib programs ..."
+$   write sys$output "Building pnm2png..."
+$   CALL MAKE pnm2png.OBJ "cc ''CCOPT' pnm2png" -
+	pnm2png.c
+$   call make pnm2png.exe -
+	"LINK pnm2png,lib.opt/opt" -
+	pnm2png.obj
+$   write sys$output "Building png2pnm..."
+$   CALL MAKE png2pnm.OBJ "cc ''CCOPT' png2pnm" -
+	png2pnm.c
+$   call make png2pnm.exe -
+	"LINK png2pnm,lib.opt/opt" -
+	png2pnm.obj
+$ exit
+$!
+$!
+$MAKE: SUBROUTINE   !SUBROUTINE TO CHECK DEPENDENCIES
+$ V = 'F$Verify(0)
+$! P1 = What we are trying to make
+$! P2 = Command to make it
+$! P3 - P8  What it depends on
+$
+$ If F$Search(P1) .Eqs. "" Then Goto Makeit
+$ Time = F$CvTime(F$File(P1,"RDT"))
+$arg=3
+$Loop:
+$       Argument = P'arg
+$       If Argument .Eqs. "" Then Goto Exit
+$       El=0
+$Loop2:
+$       File = F$Element(El," ",Argument)
+$       If File .Eqs. " " Then Goto Endl
+$       AFile = ""
+$Loop3:
+$       OFile = AFile
+$       AFile = F$Search(File)
+$       If AFile .Eqs. "" .Or. AFile .Eqs. OFile Then Goto NextEl
+$       If F$CvTime(F$File(AFile,"RDT")) .Ges. Time Then Goto Makeit
+$       Goto Loop3
+$NextEL:
+$       El = El + 1
+$       Goto Loop2
+$EndL:
+$ arg=arg+1
+$ If arg .Le. 8 Then Goto Loop
+$ Goto Exit
+$
+$Makeit:
+$ VV=F$VERIFY(0)
+$ write sys$output P2
+$ 'P2
+$ VV='F$Verify(VV)
+$Exit:
+$ If V Then Set Verify
+$ENDSUBROUTINE

contrib/pngminus/png2pnm.bat

@@ -0,0 +1,41 @@
+REM -- grayscale
+png2pnm.exe -noraw ..\pngsuite\basn0g01.png basn0g01.pgm
+png2pnm.exe -noraw ..\pngsuite\basn0g02.png basn0g02.pgm
+png2pnm.exe -noraw ..\pngsuite\basn0g04.png basn0g04.pgm
+png2pnm.exe -noraw ..\pngsuite\basn0g08.png basn0g08.pgm
+png2pnm.exe -noraw ..\pngsuite\basn0g16.png basn0g16.pgm
+REM -- full-color
+png2pnm.exe -noraw ..\pngsuite\basn2c08.png basn2c08.ppm
+png2pnm.exe -noraw ..\pngsuite\basn2c16.png basn2c16.ppm
+REM -- palletted
+png2pnm.exe -noraw ..\pngsuite\basn3p01.png basn3p01.ppm
+png2pnm.exe -noraw ..\pngsuite\basn3p02.png basn3p02.ppm
+png2pnm.exe -noraw ..\pngsuite\basn3p04.png basn3p04.ppm
+png2pnm.exe -noraw ..\pngsuite\basn3p08.png basn3p08.ppm
+REM -- gray with alpha-channel
+png2pnm.exe -noraw ..\pngsuite\basn4a08.png basn4a08.pgm
+png2pnm.exe -noraw ..\pngsuite\basn4a16.png basn4a16.pgm
+REM -- color with alpha-channel
+png2pnm.exe -noraw -alpha basn6a08.pgm ..\pngsuite\basn6a08.png basn6a08.ppm
+png2pnm.exe -noraw -alpha basn6a16.pgm ..\pngsuite\basn6a16.png basn6a16.ppm
+REM -- grayscale
+png2pnm.exe -raw ..\pngsuite\basn0g01.png rawn0g01.pgm
+png2pnm.exe -raw ..\pngsuite\basn0g02.png rawn0g02.pgm
+png2pnm.exe -raw ..\pngsuite\basn0g04.png rawn0g04.pgm
+png2pnm.exe -raw ..\pngsuite\basn0g08.png rawn0g08.pgm
+png2pnm.exe -raw ..\pngsuite\basn0g16.png rawn0g16.pgm
+REM -- full-color
+png2pnm.exe -raw ..\pngsuite\basn2c08.png rawn2c08.ppm
+png2pnm.exe -raw ..\pngsuite\basn2c16.png rawn2c16.ppm
+REM -- palletted
+png2pnm.exe -raw ..\pngsuite\basn3p01.png rawn3p01.ppm
+png2pnm.exe -raw ..\pngsuite\basn3p02.png rawn3p02.ppm
+png2pnm.exe -raw ..\pngsuite\basn3p04.png rawn3p04.ppm
+png2pnm.exe -raw ..\pngsuite\basn3p08.png rawn3p08.ppm
+REM -- gray with alpha-channel
+png2pnm.exe -raw ..\pngsuite\basn4a08.png rawn4a08.pgm
+png2pnm.exe -raw ..\pngsuite\basn4a16.png rawn4a16.pgm
+REM -- color with alpha-channel
+png2pnm.exe -noraw -alpha rawn6a08.pgm ..\pngsuite\basn6a08.png rawn6a08.ppm
+png2pnm.exe -noraw -alpha rawn6a16.pgm ..\pngsuite\basn6a16.png rawn6a16.ppm
+

contrib/pngminus/png2pnm.c

@@ -0,0 +1,431 @@
+/*
+ *  png2pnm.c --- conversion from PNG-file to PGM/PPM-file
+ *  copyright (C) 1999 by Willem van Schaik <willem@schaik.com>
+ *
+ *  version 1.0 - 1999.10.15 - First version.
+ *
+ *  Permission to use, copy, modify, and distribute this software and
+ *  its documentation for any purpose and without fee is hereby granted,
+ *  provided that the above copyright notice appear in all copies and
+ *  that both that copyright notice and this permission notice appear in
+ *  supporting documentation. This software is provided "as is" without
+ *  express or implied warranty.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#ifdef __TURBOC__
+#include <mem.h>
+#include <fcntl.h>
+#endif
+#include <zlib.h>
+
+#ifndef BOOL
+#define BOOL unsigned char
+#endif
+#ifndef TRUE
+#define TRUE (BOOL) 1
+#endif
+#ifndef FALSE
+#define FALSE (BOOL) 0
+#endif
+
+#ifdef __TURBOC__
+#define STDIN  0
+#define STDOUT 1
+#define STDERR 2
+#endif
+
+/* to make png2pnm verbose so we can find problems (needs to be before png.h) */
+#ifndef PNG_DEBUG
+#define PNG_DEBUG 0
+#endif
+
+#include "png.h"
+
+/* Define png_jmpbuf() in case we are using a pre-1.0.6 version of libpng */
+#ifndef png_jmpbuf
+#  define png_jmpbuf(png_ptr) ((png_ptr)->jmpbuf)
+#endif
+
+/* function prototypes */
+
+int  main (int argc, char *argv[]);
+void usage ();
+BOOL png2pnm (FILE *png_file, FILE *pnm_file, FILE *alpha_file, BOOL raw, BOOL alpha);
+
+/*
+ *  main
+ */
+
+int main(int argc, char *argv[])
+{
+  FILE *fp_rd = stdin;
+  FILE *fp_wr = stdout;
+  FILE *fp_al = NULL;
+  BOOL raw = TRUE;
+  BOOL alpha = FALSE;
+  int argi;
+
+  for (argi = 1; argi < argc; argi++)
+  {
+    if (argv[argi][0] == '-')
+    {
+      switch (argv[argi][1])
+      {
+        case 'n':
+          raw = FALSE;
+          break;
+        case 'r':
+          raw = TRUE;
+          break;
+        case 'a':
+          alpha = TRUE;
+          argi++;
+          if ((fp_al = fopen (argv[argi], "wb")) == NULL)
+          {
+            fprintf (stderr, "PNM2PNG\n");
+            fprintf (stderr, "Error:  can not create alpha-channel file %s\n", argv[argi]);
+            exit (1);
+          }
+          break;
+        case 'h':
+        case '?':
+          usage();
+          exit(0);
+          break;
+        default:
+          fprintf (stderr, "PNG2PNM\n");
+          fprintf (stderr, "Error:  unknown option %s\n", argv[argi]);
+          usage();
+          exit(1);
+          break;
+      } /* end switch */
+    }
+    else if (fp_rd == stdin)
+    {
+      if ((fp_rd = fopen (argv[argi], "rb")) == NULL)
+      {
+             fprintf (stderr, "PNG2PNM\n");
+            fprintf (stderr, "Error:  file %s does not exist\n", argv[argi]);
+            exit (1);
+      }
+    }
+    else if (fp_wr == stdout)
+    {
+      if ((fp_wr = fopen (argv[argi], "wb")) == NULL)
+      {
+        fprintf (stderr, "PNG2PNM\n");
+        fprintf (stderr, "Error:  can not create file %s\n", argv[argi]);
+        exit (1);
+      }
+    }
+    else
+    {
+      fprintf (stderr, "PNG2PNM\n");
+      fprintf (stderr, "Error:  too many parameters\n");
+      usage();
+      exit(1);
+    }
+  } /* end for */
+
+#ifdef __TURBOC__
+  /* set stdin/stdout if required to binary */
+  if (fp_rd == stdin)
+  {
+    setmode (STDIN, O_BINARY);
+  }
+  if ((raw) && (fp_wr == stdout))
+  {
+    setmode (STDOUT, O_BINARY);
+  }
+#endif
+
+  /* call the conversion program itself */
+  if (png2pnm (fp_rd, fp_wr, fp_al, raw, alpha) == FALSE)
+  {
+    fprintf (stderr, "PNG2PNM\n");
+    fprintf (stderr, "Error:  unsuccessful conversion of PNG-image\n");
+    exit(1);
+  }
+
+  /* close input file */
+  fclose (fp_rd);
+  /* close output file */
+  fclose (fp_wr);
+  /* close alpha file */
+  if (alpha)
+    fclose (fp_al);
+
+  return 0;
+}
+
+/*
+ *  usage
+ */
+
+void usage()
+{
+  fprintf (stderr, "PNG2PNM\n");
+  fprintf (stderr, "   by Willem van Schaik, 1999\n");
+#ifdef __TURBOC__
+  fprintf (stderr, "   for Turbo-C and Borland-C compilers\n");
+#else
+  fprintf (stderr, "   for Linux (and Unix) compilers\n");
+#endif
+  fprintf (stderr, "Usage:  png2pnm [options] <file>.png [<file>.pnm]\n");
+  fprintf (stderr, "   or:  ... | png2pnm [options]\n");
+  fprintf (stderr, "Options:\n");
+  fprintf (stderr, "   -r[aw]   write pnm-file in binary format (P4/P5/P6) (default)\n");
+  fprintf (stderr, "   -n[oraw] write pnm-file in ascii format (P1/P2/P3)\n");
+  fprintf (stderr, "   -a[lpha] <file>.pgm write PNG alpha channel as pgm-file\n");
+  fprintf (stderr, "   -h | -?  print this help-information\n");
+}
+
+/*
+ *  png2pnm
+ */
+
+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_byte      buf[8];
+  png_byte      *png_pixels = NULL;
+  png_byte      **row_pointers = NULL;
+  png_byte      *pix_ptr = NULL;
+  png_uint_32   row_bytes;
+
+  png_uint_32   width;
+  png_uint_32   height;
+  int           bit_depth;
+  int           channels;
+  int           color_type;
+  int           alpha_present;
+  int           row, col;
+  int           ret;
+  int           i;
+  long          dep_16;
+
+  /* read and check signature in PNG file */
+  ret = fread (buf, 1, 8, png_file);
+  if (ret != 8)
+    return FALSE;
+
+  ret = png_sig_cmp (buf, 0, 8);
+  if (ret)
+    return FALSE;
+
+  /* create png and info structures */
+
+  png_ptr = png_create_read_struct (PNG_LIBPNG_VER_STRING,
+    NULL, NULL, NULL);
+  if (!png_ptr)
+    return FALSE;   /* out of memory */
+
+  info_ptr = png_create_info_struct (png_ptr);
+  if (!info_ptr)
+  {
+    png_destroy_read_struct (&png_ptr, NULL, NULL);
+    return FALSE;   /* out of memory */
+  }
+
+  if (setjmp (png_jmpbuf(png_ptr)))
+  {
+    png_destroy_read_struct (&png_ptr, &info_ptr, NULL);
+    return FALSE;
+  }
+
+  /* set up the input control for C streams */
+  png_init_io (png_ptr, png_file);
+  png_set_sig_bytes (png_ptr, 8);  /* we already read the 8 signature bytes */
+
+  /* read the file information */
+  png_read_info (png_ptr, info_ptr);
+
+  /* get size and bit-depth of the PNG-image */
+  png_get_IHDR (png_ptr, info_ptr,
+    &width, &height, &bit_depth, &color_type,
+    NULL, NULL, NULL);
+
+  /* set-up the transformations */
+
+  /* transform paletted images into full-color rgb */
+  if (color_type == PNG_COLOR_TYPE_PALETTE)
+    png_set_expand (png_ptr);
+  /* expand images to bit-depth 8 (only applicable for grayscale images) */
+  if (color_type == PNG_COLOR_TYPE_GRAY && bit_depth < 8)
+    png_set_expand (png_ptr);
+  /* transform transparency maps into full alpha-channel */
+  if (png_get_valid (png_ptr, info_ptr, PNG_INFO_tRNS))
+    png_set_expand (png_ptr);
+
+#ifdef NJET
+  /* downgrade 16-bit images to 8 bit */
+  if (bit_depth == 16)
+    png_set_strip_16 (png_ptr);
+  /* transform grayscale images into full-color */
+  if (color_type == PNG_COLOR_TYPE_GRAY ||
+    color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
+    png_set_gray_to_rgb (png_ptr);
+  /* only if file has a file gamma, we do a correction */
+  if (png_get_gAMA (png_ptr, info_ptr, &file_gamma))
+    png_set_gamma (png_ptr, (double) 2.2, file_gamma);
+#endif
+
+  /* all transformations have been registered; now update info_ptr data,
+   * get rowbytes and channels, and allocate image memory */
+
+  png_read_update_info (png_ptr, info_ptr);
+
+  /* get the new color-type and bit-depth (after expansion/stripping) */
+  png_get_IHDR (png_ptr, info_ptr, &width, &height, &bit_depth, &color_type,
+    NULL, NULL, NULL);
+
+  /* check for 16-bit files */
+  if (bit_depth == 16)
+  {
+    raw = FALSE;
+#ifdef __TURBOC__
+    pnm_file->flags &= ~((unsigned) _F_BIN);
+#endif
+  }
+
+  /* calculate new number of channels and store alpha-presence */
+  if (color_type == PNG_COLOR_TYPE_GRAY)
+    channels = 1;
+  else if (color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
+    channels = 2;
+  else if (color_type == PNG_COLOR_TYPE_RGB)
+    channels = 3;
+  else if (color_type == PNG_COLOR_TYPE_RGB_ALPHA)
+    channels = 4;
+  else
+    channels = 0; /* should never happen */
+  alpha_present = (channels - 1) % 2;
+
+  /* check if alpha is expected to be present in file */
+  if (alpha && !alpha_present)
+  {
+    fprintf (stderr, "PNG2PNM\n");
+    fprintf (stderr, "Error:  PNG-file doesn't contain alpha channel\n");
+    exit (1);
+  }
+
+  /* row_bytes is the width x number of channels x (bit-depth / 8) */
+  row_bytes = png_get_rowbytes (png_ptr, info_ptr);
+
+  if ((png_pixels = (png_byte *) malloc (row_bytes * height * sizeof (png_byte))) == NULL) {
+    png_destroy_read_struct (&png_ptr, &info_ptr, NULL);
+    return FALSE;
+  }
+
+  if ((row_pointers = (png_byte **) malloc (height * sizeof (png_bytep))) == NULL)
+  {
+    png_destroy_read_struct (&png_ptr, &info_ptr, NULL);
+    free (png_pixels);
+    png_pixels = NULL;
+    return FALSE;
+  }
+
+  /* set the individual row_pointers to point at the correct offsets */
+  for (i = 0; i < (height); i++)
+    row_pointers[i] = png_pixels + i * row_bytes;
+
+  /* now we can go ahead and just read the whole image */
+  png_read_image (png_ptr, row_pointers);
+
+  /* read rest of file, and get additional chunks in info_ptr - REQUIRED */
+  png_read_end (png_ptr, info_ptr);
+
+  /* clean up after the read, and free any memory allocated - REQUIRED */
+  png_destroy_read_struct (&png_ptr, &info_ptr, (png_infopp) NULL);
+
+  /* write header of PNM file */
+
+  if ((color_type == PNG_COLOR_TYPE_GRAY) ||
+      (color_type == PNG_COLOR_TYPE_GRAY_ALPHA))
+  {
+    fprintf (pnm_file, "%s\n", (raw) ? "P5" : "P2");
+    fprintf (pnm_file, "%d %d\n", (int) width, (int) height);
+    fprintf (pnm_file, "%ld\n", ((1L << (int) bit_depth) - 1L));
+  }
+  else if ((color_type == PNG_COLOR_TYPE_RGB) ||
+           (color_type == PNG_COLOR_TYPE_RGB_ALPHA))
+  {
+    fprintf (pnm_file, "%s\n", (raw) ? "P6" : "P3");
+    fprintf (pnm_file, "%d %d\n", (int) width, (int) height);
+    fprintf (pnm_file, "%ld\n", ((1L << (int) bit_depth) - 1L));
+  }
+
+  /* write header of PGM file with alpha channel */
+
+  if ((alpha) &&
+      ((color_type == PNG_COLOR_TYPE_GRAY_ALPHA) ||
+       (color_type == PNG_COLOR_TYPE_RGB_ALPHA)))
+  {
+    fprintf (alpha_file, "%s\n", (raw) ? "P5" : "P2");
+    fprintf (alpha_file, "%d %d\n", (int) width, (int) height);
+    fprintf (alpha_file, "%ld\n", ((1L << (int) bit_depth) - 1L));
+  }
+
+  /* write data to PNM file */
+  pix_ptr = png_pixels;
+
+  for (row = 0; row < height; row++)
+  {
+    for (col = 0; col < width; col++)
+    {
+      for (i = 0; i < (channels - alpha_present); i++)
+      {
+        if (raw)
+          fputc ((int) *pix_ptr++ , pnm_file);
+        else
+          if (bit_depth == 16){
+            dep_16 = (long) *pix_ptr++;
+            fprintf (pnm_file, "%ld ", (dep_16 << 8) + ((long) *pix_ptr++));
+          }
+          else
+            fprintf (pnm_file, "%ld ", (long) *pix_ptr++);
+      }
+      if (alpha_present)
+      {
+        if (!alpha)
+        {
+          pix_ptr++; /* alpha */
+          if (bit_depth == 16)
+            pix_ptr++;
+        }
+        else /* output alpha-channel as pgm file */
+        {
+          if (raw)
+            fputc ((int) *pix_ptr++ , alpha_file);
+          else
+            if (bit_depth == 16){
+              dep_16 = (long) *pix_ptr++;
+              fprintf (alpha_file, "%ld ", (dep_16 << 8) + (long) *pix_ptr++);
+            }
+            else
+              fprintf (alpha_file, "%ld ", (long) *pix_ptr++);
+        }
+      } /* if alpha_present */
+
+      if (!raw)
+        if (col % 4 == 3)
+          fprintf (pnm_file, "\n");
+    } /* end for col */
+
+    if (!raw)
+      if (col % 4 != 0)
+        fprintf (pnm_file, "\n");
+  } /* end for row */
+
+  if (row_pointers != (unsigned char**) NULL)
+    free (row_pointers);
+  if (png_pixels != (unsigned char*) NULL)
+    free (png_pixels);
+
+  return TRUE;
+
+} /* end of source */
+

contrib/pngminus/png2pnm.sh

@@ -0,0 +1,42 @@
+#!/bin/sh
+# -- grayscale
+./png2pnm -noraw ../pngsuite/basn0g01.png basn0g01.pgm
+./png2pnm -noraw ../pngsuite/basn0g02.png basn0g02.pgm
+./png2pnm -noraw ../pngsuite/basn0g04.png basn0g04.pgm
+./png2pnm -noraw ../pngsuite/basn0g08.png basn0g08.pgm
+./png2pnm -noraw ../pngsuite/basn0g16.png basn0g16.pgm
+# -- full-color
+./png2pnm -noraw ../pngsuite/basn2c08.png basn2c08.ppm
+./png2pnm -noraw ../pngsuite/basn2c16.png basn2c16.ppm
+# -- palletted
+./png2pnm -noraw ../pngsuite/basn3p01.png basn3p01.ppm
+./png2pnm -noraw ../pngsuite/basn3p02.png basn3p02.ppm
+./png2pnm -noraw ../pngsuite/basn3p04.png basn3p04.ppm
+./png2pnm -noraw ../pngsuite/basn3p08.png basn3p08.ppm
+# -- gray with alpha-channel
+./png2pnm -noraw ../pngsuite/basn4a08.png basn4a08.pgm
+./png2pnm -noraw ../pngsuite/basn4a16.png basn4a16.pgm
+# -- color with alpha-channel
+./png2pnm -noraw -alpha basn6a08.pgm ../pngsuite/basn6a08.png basn6a08.ppm
+./png2pnm -noraw -alpha basn6a16.pgm ../pngsuite/basn6a16.png basn6a16.ppm
+# -- grayscale
+./png2pnm -raw ../pngsuite/basn0g01.png rawn0g01.pgm
+./png2pnm -raw ../pngsuite/basn0g02.png rawn0g02.pgm
+./png2pnm -raw ../pngsuite/basn0g04.png rawn0g04.pgm
+./png2pnm -raw ../pngsuite/basn0g08.png rawn0g08.pgm
+./png2pnm -raw ../pngsuite/basn0g16.png rawn0g16.pgm
+# -- full-color
+./png2pnm -raw ../pngsuite/basn2c08.png rawn2c08.ppm
+./png2pnm -raw ../pngsuite/basn2c16.png rawn2c16.ppm
+# -- palletted
+./png2pnm -raw ../pngsuite/basn3p01.png rawn3p01.ppm
+./png2pnm -raw ../pngsuite/basn3p02.png rawn3p02.ppm
+./png2pnm -raw ../pngsuite/basn3p04.png rawn3p04.ppm
+./png2pnm -raw ../pngsuite/basn3p08.png rawn3p08.ppm
+# -- gray with alpha-channel
+./png2pnm -raw ../pngsuite/basn4a08.png rawn4a08.pgm
+./png2pnm -raw ../pngsuite/basn4a16.png rawn4a16.pgm
+# -- color with alpha-channel
+./png2pnm -noraw -alpha rawn6a08.pgm ../pngsuite/basn6a08.png rawn6a08.ppm
+./png2pnm -noraw -alpha rawn6a16.pgm ../pngsuite/basn6a16.png rawn6a16.ppm
+

contrib/pngminus/pngminus.bat

@@ -0,0 +1,4 @@
+make -f makefile.tc3
+call png2pnm.bat
+call pnm2png.bat
+

contrib/pngminus/pngminus.sh

@@ -0,0 +1,5 @@
+#!/bin/sh
+make -f makefile.std
+sh png2pnm.sh
+sh pnm2png.sh
+

contrib/pngminus/pnm2png.bat

@@ -0,0 +1,41 @@
+REM -- grayscale
+pnm2png.exe basn0g01.pgm basn0g01.png
+pnm2png.exe basn0g02.pgm basn0g02.png
+pnm2png.exe basn0g04.pgm basn0g04.png
+pnm2png.exe basn0g08.pgm basn0g08.png
+pnm2png.exe basn0g16.pgm basn0g16.png
+REM -- full-color
+pnm2png.exe basn2c08.ppm basn2c08.png
+pnm2png.exe basn2c16.ppm basn2c16.png
+REM -- palletted
+pnm2png.exe basn3p01.ppm basn3p01.png
+pnm2png.exe basn3p02.ppm basn3p02.png
+pnm2png.exe basn3p04.ppm basn3p04.png
+pnm2png.exe basn3p08.ppm basn3p08.png
+REM -- gray with alpha-channel
+pnm2png.exe -alpha basn6a08.pgm basn4a08.pgm basn4a08.png
+pnm2png.exe -alpha basn6a16.pgm basn4a16.pgm basn4a16.png
+REM -- color with alpha-channel
+pnm2png.exe -alpha basn6a08.pgm basn6a08.ppm basn6a08.png
+pnm2png.exe -alpha basn6a16.pgm basn6a16.ppm basn6a16.png
+REM -- grayscale
+pnm2png.exe rawn0g01.pgm rawn0g01.png
+pnm2png.exe rawn0g02.pgm rawn0g02.png
+pnm2png.exe rawn0g04.pgm rawn0g04.png
+pnm2png.exe rawn0g08.pgm rawn0g08.png
+pnm2png.exe rawn0g16.pgm rawn0g16.png
+REM -- full-color
+pnm2png.exe rawn2c08.ppm rawn2c08.png
+pnm2png.exe rawn2c16.ppm rawn2c16.png
+REM -- palletted
+pnm2png.exe rawn3p01.ppm rawn3p01.png
+pnm2png.exe rawn3p02.ppm rawn3p02.png
+pnm2png.exe rawn3p04.ppm rawn3p04.png
+pnm2png.exe rawn3p08.ppm rawn3p08.png
+REM -- gray with alpha-channel
+pnm2png.exe -alpha rawn6a08.pgm rawn4a08.pgm rawn4a08.png
+pnm2png.exe -alpha rawn6a16.pgm rawn4a16.pgm rawn4a16.png
+REM -- color with alpha-channel
+pnm2png.exe -alpha rawn6a08.pgm rawn6a08.ppm rawn6a08.png
+pnm2png.exe -alpha rawn6a16.pgm rawn6a16.ppm rawn6a16.png
+

contrib/pngminus/pnm2png.c

@@ -0,0 +1,599 @@
+/*
+ *  pnm2png.c --- conversion from PBM/PGM/PPM-file to PNG-file
+ *  copyright (C) 1999 by Willem van Schaik <willem@schaik.com>
+ *
+ *  version 1.0 - 1999.10.15 - First version.
+ *
+ *  Permission to use, copy, modify, and distribute this software and
+ *  its documentation for any purpose and without fee is hereby granted,
+ *  provided that the above copyright notice appear in all copies and
+ *  that both that copyright notice and this permission notice appear in
+ *  supporting documentation. This software is provided "as is" without
+ *  express or implied warranty.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#ifdef __TURBOC__
+#include <mem.h>
+#include <fcntl.h>
+#endif
+#include <zlib.h>
+
+#ifndef BOOL
+#define BOOL unsigned char
+#endif
+#ifndef TRUE
+#define TRUE (BOOL) 1
+#endif
+#ifndef FALSE
+#define FALSE (BOOL) 0
+#endif
+
+#define STDIN  0
+#define STDOUT 1
+#define STDERR 2
+
+/* to make pnm2png verbose so we can find problems (needs to be before png.h) */
+#ifndef PNG_DEBUG
+#define PNG_DEBUG 0
+#endif
+
+#include "png.h"
+
+/* Define png_jmpbuf() in case we are using a pre-1.0.6 version of libpng */
+#ifndef png_jmpbuf
+#  define png_jmpbuf(png_ptr) ((png_ptr)->jmpbuf)
+#endif
+
+/* function prototypes */
+
+int  main (int argc, char *argv[]);
+void usage ();
+BOOL pnm2png (FILE *pnm_file, FILE *png_file, FILE *alpha_file, BOOL interlace, BOOL alpha);
+void get_token(FILE *pnm_file, char *token);
+png_uint_32 get_data (FILE *pnm_file, int depth);
+png_uint_32 get_value (FILE *pnm_file, int depth);
+
+/*
+ *  main
+ */
+
+int main(int argc, char *argv[])
+{
+  FILE *fp_rd = stdin;
+  FILE *fp_al = NULL;
+  FILE *fp_wr = stdout;
+  BOOL interlace = FALSE;
+  BOOL alpha = FALSE;
+  int argi;
+
+  for (argi = 1; argi < argc; argi++)
+  {
+    if (argv[argi][0] == '-')
+    {
+      switch (argv[argi][1])
+      {
+        case 'i':
+          interlace = TRUE;
+          break;
+        case 'a':
+          alpha = TRUE;
+          argi++;
+          if ((fp_al = fopen (argv[argi], "rb")) == NULL)
+          {
+            fprintf (stderr, "PNM2PNG\n");
+            fprintf (stderr, "Error:  alpha-channel file %s does not exist\n",
+               argv[argi]);
+            exit (1);
+          }
+          break;
+        case 'h':
+        case '?':
+          usage();
+          exit(0);
+          break;
+        default:
+          fprintf (stderr, "PNM2PNG\n");
+          fprintf (stderr, "Error:  unknown option %s\n", argv[argi]);
+          usage();
+          exit(1);
+          break;
+      } /* end switch */
+    }
+    else if (fp_rd == stdin)
+    {
+      if ((fp_rd = fopen (argv[argi], "rb")) == NULL)
+      {
+        fprintf (stderr, "PNM2PNG\n");
+        fprintf (stderr, "Error:  file %s does not exist\n", argv[argi]);
+        exit (1);
+      }
+    }
+    else if (fp_wr == stdout)
+    {
+      if ((fp_wr = fopen (argv[argi], "wb")) == NULL)
+      {
+        fprintf (stderr, "PNM2PNG\n");
+        fprintf (stderr, "Error:  can not create PNG-file %s\n", argv[argi]);
+        exit (1);
+      }
+    }
+    else
+    {
+      fprintf (stderr, "PNM2PNG\n");
+      fprintf (stderr, "Error:  too many parameters\n");
+      usage();
+      exit (1);
+    }
+  } /* end for */
+
+#ifdef __TURBOC__
+  /* set stdin/stdout to binary, we're reading the PNM always! in binary format */
+  if (fp_rd == stdin)
+  {
+    setmode (STDIN, O_BINARY);
+  }
+  if (fp_wr == stdout)
+  {
+    setmode (STDOUT, O_BINARY);
+  }
+#endif
+
+  /* call the conversion program itself */
+  if (pnm2png (fp_rd, fp_wr, fp_al, interlace, alpha) == FALSE)
+  {
+    fprintf (stderr, "PNM2PNG\n");
+    fprintf (stderr, "Error:  unsuccessful converting to PNG-image\n");
+    exit (1);
+  }
+
+  /* close input file */
+  fclose (fp_rd);
+  /* close output file */
+  fclose (fp_wr);
+  /* close alpha file */
+  if (alpha)
+    fclose (fp_al);
+
+  return 0;
+}
+
+/*
+ *  usage
+ */
+
+void usage()
+{
+  fprintf (stderr, "PNM2PNG\n");
+  fprintf (stderr, "   by Willem van Schaik, 1999\n");
+#ifdef __TURBOC__
+  fprintf (stderr, "   for Turbo-C and Borland-C compilers\n");
+#else
+  fprintf (stderr, "   for Linux (and Unix) compilers\n");
+#endif
+  fprintf (stderr, "Usage:  pnm2png [options] <file>.<pnm> [<file>.png]\n");
+  fprintf (stderr, "   or:  ... | pnm2png [options]\n");
+  fprintf (stderr, "Options:\n");
+  fprintf (stderr, "   -i[nterlace]   write png-file with interlacing on\n");
+  fprintf (stderr, "   -a[lpha] <file>.pgm read PNG alpha channel as pgm-file\n");
+  fprintf (stderr, "   -h | -?  print this help-information\n");
+}
+
+/*
+ *  pnm2png
+ */
+
+BOOL pnm2png (FILE *pnm_file, FILE *png_file, FILE *alpha_file, BOOL interlace, BOOL alpha)
+{
+  png_struct    *png_ptr = NULL;
+  png_info      *info_ptr = NULL;
+  png_byte      *png_pixels = NULL;
+  png_byte      **row_pointers = NULL;
+  png_byte      *pix_ptr = NULL;
+  png_uint_32   row_bytes;
+
+  char          type_token[16];
+  char          width_token[16];
+  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;
+  int           bit_depth = 0;
+  int           channels;
+  int           alpha_depth = 0;
+  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;
+
+  /* read header of PNM file */
+
+  get_token(pnm_file, type_token);
+  if (type_token[0] != 'P')
+  {
+    return FALSE;
+  }
+  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;
+    get_token(pnm_file, height_token);
+    sscanf (height_token, "%lu", &ul_height);
+    height = (png_uint_32) ul_height;
+    get_token(pnm_file, maxval_token);
+    sscanf (maxval_token, "%lu", &ul_maxval);
+    maxval = (png_uint_32) ul_maxval;
+
+    if (maxval <= 1)
+      bit_depth = 1;
+    else if (maxval <= 3)
+      bit_depth = 2;
+    else if (maxval <= 15)
+      bit_depth = 4;
+    else if (maxval <= 255)
+      bit_depth = 8;
+    else /* if (maxval <= 65535) */
+      bit_depth = 16;
+  }
+  else if ((type_token[1] == '3') || (type_token[1] == '6'))
+  {
+    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;
+    get_token(pnm_file, height_token);
+    sscanf (height_token, "%lu", &ul_height);
+    height = (png_uint_32) ul_height;
+    get_token(pnm_file, maxval_token);
+    sscanf (maxval_token, "%lu", &ul_maxval);
+    maxval = (png_uint_32) ul_maxval;
+    if (maxval <= 1)
+      bit_depth = 1;
+    else if (maxval <= 3)
+      bit_depth = 2;
+    else if (maxval <= 15)
+      bit_depth = 4;
+    else if (maxval <= 255)
+      bit_depth = 8;
+    else /* if (maxval <= 65535) */
+      bit_depth = 16;
+  }
+  else
+  {
+    return FALSE;
+  }
+
+  /* read header of PGM file with alpha channel */
+
+  if (alpha)
+  {
+    if (color_type == PNG_COLOR_TYPE_GRAY)
+      color_type = PNG_COLOR_TYPE_GRAY_ALPHA;
+    if (color_type == PNG_COLOR_TYPE_RGB)
+      color_type = PNG_COLOR_TYPE_RGB_ALPHA;
+
+    get_token(alpha_file, type_token);
+    if (type_token[0] != 'P')
+    {
+      return FALSE;
+    }
+    else if ((type_token[1] == '2') || (type_token[1] == '5'))
+    {
+      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;
+      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;
+      if (alpha_height != height)
+        return FALSE;
+      get_token(alpha_file, maxval_token);
+      sscanf (maxval_token, "%lu", &ul_maxval);
+      maxval = (png_uint_32) ul_maxval;
+      if (maxval <= 1)
+        alpha_depth = 1;
+      else if (maxval <= 3)
+        alpha_depth = 2;
+      else if (maxval <= 15)
+        alpha_depth = 4;
+      else if (maxval <= 255)
+        alpha_depth = 8;
+      else /* if (maxval <= 65535) */
+        alpha_depth = 16;
+      if (alpha_depth != bit_depth)
+        return FALSE;
+    }
+    else
+    {
+      return FALSE;
+    }
+  } /* end if alpha */
+
+  /* calculate the number of channels and store alpha-presence */
+  if (color_type == PNG_COLOR_TYPE_GRAY)
+    channels = 1;
+  else if (color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
+    channels = 2;
+  else if (color_type == PNG_COLOR_TYPE_RGB)
+    channels = 3;
+  else if (color_type == PNG_COLOR_TYPE_RGB_ALPHA)
+    channels = 4;
+  else
+    channels = 0; /* should not happen */
+
+  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);
+
+  if ((png_pixels = (png_byte *) malloc (row_bytes * height * sizeof (png_byte))) == NULL)
+    return FALSE;
+
+  /* read data from PNM file */
+  pix_ptr = png_pixels;
+
+  for (row = 0; row < 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 (i = 0; i < (channels - alpha_present); i++)
+        {
+          if (raw)
+            *pix_ptr++ = get_data (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++;
+            }
+        }
+
+        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
+            {
+              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 */
+    } /* end for col */
+  } /* end for row */
+
+  /* prepare the standard PNG structures */
+  png_ptr = png_create_write_struct (PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
+  if (!png_ptr)
+  {
+    return FALSE;
+  }
+  info_ptr = png_create_info_struct (png_ptr);
+  if (!info_ptr)
+  {
+    png_destroy_write_struct (&png_ptr, (png_infopp) NULL);
+    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)))
+  {
+    png_destroy_write_struct (&png_ptr, (png_infopp) NULL);
+    return FALSE;
+  }
+
+  /* initialize the png structure */
+  png_init_io (png_ptr, png_file);
+
+  /* we're going to write more or less the same PNG as the input file */
+  png_set_IHDR (png_ptr, info_ptr, width, height, bit_depth, color_type,
+    (!interlace) ? PNG_INTERLACE_NONE : PNG_INTERLACE_ADAM7,
+    PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE);
+
+  /* write the file header information */
+  png_write_info (png_ptr, info_ptr);
+
+  /* if needed we will allocate memory for an new array of row-pointers */
+  if (row_pointers == (unsigned char**) NULL)
+  {
+    if ((row_pointers = (png_byte **) malloc (height * sizeof (png_bytep))) == NULL)
+    {
+      png_destroy_write_struct (&png_ptr, (png_infopp) NULL);
+      return FALSE;
+    }
+  }
+
+  /* set the individual row_pointers to point at the correct offsets */
+  for (i = 0; i < (height); i++)
+    row_pointers[i] = png_pixels + i * row_bytes;
+
+  /* write out the entire image data in one call */
+  png_write_image (png_ptr, row_pointers);
+
+  /* write the additional chuncks to the PNG file (not really needed) */
+  png_write_end (png_ptr, info_ptr);
+
+  /* clean up after the write, and free any memory allocated */
+  png_destroy_write_struct (&png_ptr, (png_infopp) NULL);
+
+  if (row_pointers != (unsigned char**) NULL)
+    free (row_pointers);
+  if (png_pixels != (unsigned char*) NULL)
+    free (png_pixels);
+
+  return TRUE;
+} /* end of pnm2png */
+
+/*
+ * get_token() - gets the first string after whitespace
+ */
+
+void get_token(FILE *pnm_file, char *token)
+{
+  int i = 0;
+  int ret;
+
+  /* remove white-space and comment lines */
+  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;
+  }
+  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;
+  }
+  while ((token[i] != '\n') && (token[i] != '\r') && (token[i] != ' '));
+
+  token[i] = '\0';
+
+  return;
+}
+
+/*
+ * get_data() - takes first byte and converts into next pixel value,
+ *        taking as much bits as defined by bit-depth and
+ *        using the bit-depth to fill up a byte (0Ah -> AAh)
+ */
+
+png_uint_32 get_data (FILE *pnm_file, int depth)
+{
+  static int bits_left = 0;
+  static int old_value = 0;
+  static int mask = 0;
+  int i;
+  png_uint_32 ret_value;
+
+  if (mask == 0)
+    for (i = 0; i < depth; i++)
+      mask = (mask >> 1) | 0x80;
+
+  if (bits_left <= 0)
+  {
+    old_value = fgetc (pnm_file);
+    bits_left = 8;
+  }
+
+  ret_value = old_value & mask;
+  for (i = 1; i < (8 / depth); i++)
+    ret_value = ret_value || (ret_value >> depth);
+
+  old_value = (old_value << depth) & 0xFF;
+  bits_left -= depth;
+
+  return ret_value;
+}
+
+/*
+ * get_value() - takes first (numeric) string and converts into number,
+ *         using the bit-depth to fill up a byte (0Ah -> AAh)
+ */
+
+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;
+
+  if (mask == 0)
+    for (i = 0; i < depth; i++)
+      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;
+
+  ret_value &= mask;
+
+  if (depth < 8)
+    for (i = 0; i < (8 / depth); i++)
+      ret_value = (ret_value << depth) || ret_value;
+
+  return ret_value;
+}
+
+/* end of source */
+

contrib/pngminus/pnm2png.sh

@@ -0,0 +1,42 @@
+#!/bin/sh
+# -- grayscale
+./pnm2png basn0g01.pgm basn0g01.png
+./pnm2png basn0g02.pgm basn0g02.png
+./pnm2png basn0g04.pgm basn0g04.png
+./pnm2png basn0g08.pgm basn0g08.png
+./pnm2png basn0g16.pgm basn0g16.png
+# -- full-color
+./pnm2png basn2c08.ppm basn2c08.png
+./pnm2png basn2c16.ppm basn2c16.png
+# -- palletted
+./pnm2png basn3p01.ppm basn3p01.png
+./pnm2png basn3p02.ppm basn3p02.png
+./pnm2png basn3p04.ppm basn3p04.png
+./pnm2png basn3p08.ppm basn3p08.png
+# -- gray with alpha-channel
+./pnm2png -alpha basn6a08.pgm basn4a08.pgm basn4a08.png
+./pnm2png -alpha basn6a16.pgm basn4a16.pgm basn4a16.png
+# -- color with alpha-channel
+./pnm2png -alpha basn6a08.pgm basn6a08.ppm basn6a08.png
+./pnm2png -alpha basn6a16.pgm basn6a16.ppm basn6a16.png
+# -- grayscale
+./pnm2png rawn0g01.pgm rawn0g01.png
+./pnm2png rawn0g02.pgm rawn0g02.png
+./pnm2png rawn0g04.pgm rawn0g04.png
+./pnm2png rawn0g08.pgm rawn0g08.png
+./pnm2png rawn0g16.pgm rawn0g16.png
+# -- full-color
+./pnm2png rawn2c08.ppm rawn2c08.png
+./pnm2png rawn2c16.ppm rawn2c16.png
+# -- palletted
+./pnm2png rawn3p01.ppm rawn3p01.png
+./pnm2png rawn3p02.ppm rawn3p02.png
+./pnm2png rawn3p04.ppm rawn3p04.png
+./pnm2png rawn3p08.ppm rawn3p08.png
+# -- gray with alpha-channel
+./pnm2png -alpha rawn6a08.pgm rawn4a08.pgm rawn4a08.png
+./pnm2png -alpha rawn6a16.pgm rawn4a16.pgm rawn4a16.png
+# -- color with alpha-channel
+./pnm2png -alpha rawn6a08.pgm rawn6a08.ppm rawn6a08.png
+./pnm2png -alpha rawn6a16.pgm rawn6a16.ppm rawn6a16.png
+

contrib/pngsuite/README

@@ -0,0 +1,105 @@
+
+pngsuite
+--------
+(c) Willem van Schaik, 1999, 2011, 2012
+Two images are by Glenn Randers-Pehrson, 2012
+
+Permission to use, copy, modify, and distribute these images for any
+purpose and without fee is hereby granted.
+
+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
+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
+    ------------ ------ --------------
+    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
+this directory:
+
+Testing basn0g01.png: PASS (524 zero samples)
+ Filter 0 was used 32 times
+Testing basn0g02.png: PASS (448 zero samples)
+ Filter 0 was used 32 times
+Testing basn0g04.png: PASS (520 zero samples)
+ Filter 0 was used 32 times
+Testing basn0g08.png: PASS (3 zero samples)
+ Filter 1 was used 9 times
+ Filter 4 was used 23 times
+Testing basn0g16.png: PASS (1 zero samples)
+ Filter 1 was used 1 times
+ Filter 2 was used 31 times
+Testing basn2c08.png: PASS (6 zero samples)
+ Filter 1 was used 5 times
+ Filter 4 was used 27 times
+Testing basn2c16.png: PASS (592 zero samples)
+ Filter 1 was used 1 times
+ Filter 4 was used 31 times
+Testing basn3p01.png: PASS (512 zero samples)
+ Filter 0 was used 32 times
+Testing basn3p02.png: PASS (448 zero samples)
+ Filter 0 was used 32 times
+Testing basn3p04.png: PASS (544 zero samples)
+ Filter 0 was used 32 times
+Testing basn3p08.png: PASS (4 zero samples)
+ Filter 0 was used 32 times
+Testing basn4a08.png: PASS (32 zero samples)
+ Filter 1 was used 1 times
+ Filter 4 was used 31 times
+Testing basn4a16.png: PASS (64 zero samples)
+ Filter 0 was used 1 times
+ Filter 1 was used 2 times
+ Filter 2 was used 1 times
+ Filter 4 was used 28 times
+Testing basn6a08.png: PASS (160 zero samples)
+ Filter 1 was used 1 times
+ Filter 4 was used 31 times
+Testing basn6a16.png: PASS (1072 zero samples)
+ Filter 1 was used 4 times
+ Filter 4 was used 28 times
+libpng passes test
+
+Willem van Schaik
+<willem@schaik.com>
+October 1999