[libpng17] Imported from libpng-1.7.0beta64.tar

Contributing Authors.

ANNOUNCE

@@ -1,4 +1,5 @@
-Libpng 1.6.18rc02 - July 12, 2015
+
+Libpng 1.7.0beta64 - July 26, 2015
 
 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.
@@ -8,108 +9,849 @@ Files available for download:
 Source files with LF line endings (for Unix/Linux) and with a
 "configure" script
 
-   1.6.18rc02.tar.xz (LZMA-compressed, recommended)
-   1.6.18rc02.tar.gz
+   1.7.0beta64.tar.xz (LZMA-compressed, recommended)
+   1.7.0beta64.tar.gz
 
 Source files with CRLF line endings (for Windows), without the
 "configure" script
 
-   lp1618r02.7z  (LZMA-compressed, recommended)
-   lp1618r02.zip
+   lp170b64.7z  (LZMA-compressed, recommended)
+   lp170b64.zip
 
 Other information:
 
-   1.6.18rc02-README.txt
-   1.6.18rc02-LICENSE.txt
-   libpng-1.6.18rc02-*.asc (armored detached GPG signatures)
+   1.7.0beta64-README.txt
+   1.7.0beta64-LICENSE.txt
+   libpng-1.7.0beta64-*.asc (armored detached GPG signatures)
 
-Changes since the last public release (1.6.17):
+Changes since the last public release (1.6.0):
 
-Version 1.6.18beta01 [April 1, 2015]
-  Removed PNG_SET_CHUNK_[CACHE|MALLOC]_LIMIT_SUPPORTED macros.  They
-    have been combined with PNG_SET_USER_LIMITS_SUPPORTED (resolves
-    bug report by Andrew Church).
-  Fixed rgb_to_gray checks and added tRNS checks to pngvalid.c.  This
-    fixes some arithmetic errors that caused some tests to fail on
-    some 32-bit platforms (Bug reports by Peter Breitenlohner [i686]
+Version 1.7.0alpha01 [December 15, 2012]
+  Started 1.7.0 branch from libpng-1.6.0beta33.
+  Made 8-bit compose and rgb_to_grayscale accuracy improvements.  These
+    changes cause 16-bit arithmetic to be used for 8-bit data in the gamma
+    corrected compose and grayscale operations.  The arithmetic errors have
+    three sources all of which are fixed in this commit:
+    1) 8-bit linear calculations produce massive errors for lower intensity
+       values.
+    2) The old 16-bit "16 to 8" gamma table code erroneously wrote the lowest
+       output value into a table entry which corresponded to multiple output
+       values (so where the value written should have been the closest to the
+       transformed input value.)
+    3) In a number of cases the code to access the 16-bit table did not round;
+       it did a simple shift, which was wrong and made the side effects of (2)
+       even worse.
+  The new gamma code does not have the 16-to-8 problem at the cost of slightly
+    more calculations and the algorithm used to minimize the number of
+    calculations has been extended to all the 16-bit tables; it has advantages
+    for any significant gamma correction.
+  Rearranged png_struct, remove unused members, change png_set_filter handling
+    png_struct members rearranged - partly to reorder to avoid packing, partly
+    to put frequently accessed members at the start and partly to make
+    the grouping more clear. png_set_filter code has been rewritten and the
+    code shared with png_write_start_row moved to a common function.  Comments
+    in png.h have been made more clear. Minor fixes to
+    contrib/libtests/timepng.c and some of the png_*_tRNS logic, including
+    more error detection in png_set_tRNS.
+  Cleaned up USER_LIMITS feature, removing members from png_struct when not
+    required.
+  Rearranged ARM-NEON optimizations to isolate the machine specific code to
+    the hardware subdirectory, and add comments to pngrutil.c so that
+    implementors of other optimizations will know what to do.
+  Fixed cases of unquoted DESTDIR in Makefile.am.
+  Rebuilt Makefile.in, configure, etc., with autoconf-2.69 and automake-1.12.5.
+
+Version 1.7.0alpha02 [December 17, 2012]
+  Removed functions that were deprecated in libpng-1.6.0:
+    png_reset_zstream(), png_info_init_3(), and png_data_freer() and its
+    associated flags.
+  Removed some duplicated lines from contrib/tools/scale.c and png.c.
+  Changed some instances of png_warning() to png_app_error().
+  Updated some left over "1.6.0beta32" in code sources.
+  Fixed a "png_structp" prototype (should be png_structrp) in arm_init.c
+  Updated the version-number hack in pngvalid.c
+
+Version 1.7.0alpha03 [December 19, 2012]
+  Cleaned up and enhanced the configure option; libpng now correctly
+    links and tests against zlib with a prefix; tests have been clarified; and
+    irrelevant or obsolete things (as defined by the autotools man page) have
+    been removed.
+  Documented new PNG_ABORT behavior in the manual and commentary in pngerror.c
+  Cleaned up whitespace in the synopsis portion of the manpage "libpng.3"
+  Fixed previous support for Z_PREFIX in configure builds, corrected sCAL APIs;
+    some of these use floating point arithmetic so they need to be disabled if
+    floating point arithmetic is switched off.  This is a quiet API change -
+    previously it appeared that the APIs were supported if fixed point
+    arithmetic was used internally, however they required certain APIs (floor,
+    modf, frexp, atof) that are part of C floating point support. Changed
+    png_fixed and the gamma code specific version of the same to avoid floor(),
+    which may be a library function (not an intrinsic). Removed unused #if 0
+    code.
+  Disassembled the version number in scripts/options.awk (necessary for
+    building on SunOs).
+
+Version 1.7.0alpha04 [December 23, 2012]
+  Added scripts/makefile.msys contributed by Christopher M. Wheeler
+  Made default Zlib compression settings be configurable. This adds #defines to
+    pnglibconf.h to control the defaults.
+  Fixed Windows build issues, enabled ARM compilation. Various warnings issued
+    by earlier versions of GCC fixed for Cygwin and Min/GW (which both use old
+    GCCs.) ARM support is enabled by default in zlib.props (unsupported by
+    Microsoft) and ARM compilation is made possible by deleting the check for
+    x86. The test programs cannot be run because they are not signed.
+
+Version 1.7.0alpha05 [December 24, 2012]
+  Discontinued distributing libpng-1.x.x.tar.bz2.
+  Discontinued distributing libpng-1.7.0-1.6.0-diff.txt and similar.
+
+Version 1.7.0alpha06 [January 1, 2013]
+  Fixed 'make distcheck' on SUN OS - libpng.so was not being removed
+
+Version 1.7.0alpha07 [January 10, 2013]
+  Fixed conceivable but difficult to repro overflow. Also added two test
+    programs to generate and test a PNG which should have the problem.
+
+Version 1.7.0alpha08 [January 17, 2013]
+  Corrected previous attempt at overflow detection in png_set_unknown_chunks()
+  (CVE-2013-7353).  Added overflow detection in png_set_sPLT() and
+  png_set_text_2() (CVE-2013-7354).
+
+Version 1.7.0alpha09 [January 21, 2013]
+  Pulled changes to multi-chunk handling from libpng-1.6.0beta40.
+
+Version 1.7.0alpha10 [February 5, 2013]
+  Make symbol prefixing work with the ARM neon optimizations. Also
+    allow pngpriv.h to be included for preprocessor definitions only, so
+    it can be used in non-C/C++ files.
+  Added png_get_palette_max() function.
+  Changed png_size_t to size_t throughout headers, make sRGB check numbers
+    consistent.
+  Fixed ARM support (Mans Rullgard).
+  Removed stray out-of-order #endif and #ifdef (Mans Rullgard).
+  Ported libpng 1.5 options.awk/dfn file handling to 1.7, fixed one bug.
+  Rebuilt Makefile.in, configure, etc., with autoconf-2.69 and automake-1.13.
+  Minor fixes to assembler changes, verified with a dummy .S file
+  Removed cc -E workround, corrected png_get_palette_max API. Tested on
+    SUN OS cc 5.9, which demonstrates the tokenization problem previously
+    avoided by using /lib/cpp.  Since all .dfn output is now protected
+    in double quotes unless it is to be macro substituted the fix should work
+    everywhere.
+
+Version 1.7.0beta01 [February 15, 2013]
+  Enable parallel tests and rearrange TESTS order to take advantage of
+    the massive speed improvements use a make capable of parallel builds
+    on a multi-CPU machine and pass the right arguments to make (-j10000
+    for GNU make) to get the build to run in parallel.
+  Fixed previous support for Z_PREFIX in configure builds, corrected
+    sCAL APIs; some of these use floating point arithmetic so need to be
+    disabled if floating point arithmetic is switched off.  This is a quiet API
+    change - previously it appeared that the APIs were supported if fixed point
+    arithmetic was used internally, however they required certain APIs (floor,
+    modf, frexp, atof) that are part of C floating point support. Changed
+    png_fixed and the gamma code specific version of the same to avoid floor(),
+    which may be a library function (not an intrinsic). Removed unused #if 0
+    code.
+  Fixed make distcheck to skip over the test result files. They were
+    being included because the whole of the 'tests' directory is included,
+    fixed to just include the actual test files and tests/pngstest.  Also
+    reverted the previous erroneous change to remove the ${srcdir} from the
+    front of contrib, scripts, projects and added an explanation of what is
+    going on to Makefile.am
+  Fixed missing dependency in --prefix builds. The intermediate
+    internal 'prefix.h' file can only be generated correctly after pnglibconf.h,
+    however the dependency was not in Makefile.am.  The symptoms are
+    unpredictable depending on the order make chooses to build pngprefix.h and
+    pnglibconf.h, often the error goes unnoticed because there is a system
+    pnglibconf.h to use instead.
+  Accept "," as a separator in pnglibconf.dfa and allow for
+    continuation lines. This adds to the syntax of "option" and "chunk" lines,
+    allowing the elements to be separated by a "," at the end of an element and
+    interpreting a "," at end of line as a continuation - so the following line
+    is read.  The new syntax is optional and solely provided for readability.
+  Enclosed the new png_get_palette_max in #ifdef PNG_GET_PALETTE_MAX_SUPPORTED
+    block, and revised pnglibconf.h and pnglibconf.h.prebuilt accordingly.
+
+Version 1.7.0beta02 [February 18, 2013]
+  Fixed a race condition in the creation of the build 'scripts' directory
+    while building with a parallel make.
+  Use approved/supported Android method to check for NEON, use Linux/POSIX
+    1003.1 API to check /proc/self/auxv avoiding buffer allocation and other
+    library calls (ported from libpng15).
+  Use parentheses more consistently in "#if defined(MACRO)" tests.
+  Folded long lines.
+
+Version 1.7.0beta03 [February 22, 2013]
+  Reenabled code to allow zero length PLTE chunks for MNG.
+  Fixed ALIGNED_MEMORY support.
+  Allow run-time ARM NEON checking to be disabled. A new configure option:
+    --enable-arm-neon=always will stop the run-time checks. New checks
+    within arm/arm_init.c will cause the code not to be compiled unless
+    __ARM_NEON__ is set. This should make it fail safe (if someone asks
+    for it on then the build will fail if it can't be done.)
+  Updated the INSTALL document.
+
+Version 1.7.0beta04 [February 27, 2013]
+  Revised INSTALL to recommend using CPPFLAGS instead of INCLUDES.
+  Revised scripts/makefile.freebsd to respect ZLIBLIB and ZLIBINC.
+  Revised scripts/dfn.awk to work with the buggy MSYS awk that has trouble
+    with CRLF line endings.
+
+Version 1.7.0beta05 [March 5, 2013]
+  Avoid a possible memory leak in contrib/gregbook/readpng.c
+  Changed user chunk callback API to respect global and per chunk defaults.
+    Previously a return of 0 from a user chunk callback would result in the
+    chunk being saved (if this was safe, even if the chunk was unsafe-to-copy);
+    this change respects the defaults set by the application, so unknown chunks
+    can be discarded by default and known-safe ones preserved.
+  Corrected Android builds and corrected libpng.vers with symbol
+    prefixing. This adds an API to set optimization options externally,
+    providing an alternative and general solution for the non-portable
+    run-time tests used by the ARM Neon code.  It also makes those tests
+    compile and link on Android.  The order of settings vs options in
+    pnglibconf.h is reversed to allow settings to depend on options and
+    options can now set (or override) the defaults for settings.
+
+Version 1.7.0beta06 [March 13, 2013]
+  Corrected simplified API default gamma for color-mapped output, added
+    a flag to change default. In 1.6.0 when the simplified API was used
+    to produce color-mapped output from an input image with no gamma
+    information the gamma assumed for the input could be different from
+    that assumed for non-color-mapped output.  In particular 16-bit depth
+    input files were assumed to be sRGB encoded, whereas in the 'direct'
+    case they were assumed to have linear data.  This was an error.  The
+    fix makes the simplified API treat all input files the same way and
+    adds a new flag to the png_image::flags member to allow the
+    application/user to specify that 16-bit files contain sRGB data
+    rather than the default linear.
+  Fixed bugs in the pngpixel and makepng test programs.
+  Fixed CMakelists.txt to allow building a single variant of the library
+    (Claudio Bley):
+  Introduced a PNG_LIB_TARGETS variable that lists all activated library
+    targets.  It is an error if this variable ends up empty, ie. you have
+    to build at least one library variant.
+  Made the *_COPY targets only depend on library targets actually being build.
+  Use PNG_LIB_TARGETS to unify a code path.
+  Changed the CREATE_SYMLINK macro to expect the full path to a file as the
+    first argument. When symlinking the filename component of that path is
+    determined and used as the link target.
+  Use copy_if_different in the CREATE_SYMLINK macro.
+  Eliminated two warnings from the Intel C compiler. The warnings are
+    technically valid, although a reasonable treatment of division would
+    show it to be incorrect.
+
+Version 1.7.0beta07 [April 14, 2013]
+  Updated documentation of 1.5.x to 1.6.x changes in iCCP chunk handling.
+  Fixed incorrect warning of excess deflate data. End condition - the
+    warning would be produced if the end of the deflate stream wasn't read
+    in the last row.  The warning is harmless.
+  Corrected the test on user transform changes on read. It was in the
+    png_set of the transform function, but that doesn't matter unless the
+    transform function changes the rowbuf size, and that is only valid if
+    transform_info is called.
+  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 made static. Move the intrapixel functions and the
+    grayscale palette builder out of the png?tran.c files. The latter
+    isn't a transform function and is no longer used internally, and the
+    former MNG specific functions are better placed in pngread/pngwrite.c
+  Made transform implementation functions static. This makes the internal
+    functions called by png_do_{read|write}_transformations static. On an
+    x86-64 DLL build (Gentoo Linux) this reduces the size of the text
+    segment of the DLL by 1208 bytes, about 0.6%. It also simplifies
+    maintenance by removing the declarations from pngpriv.h and allowing
+    easier changes to the internal interfaces.
+  Handle zero-length PLTE chunk or NULL palette with png_error()
+    instead of png_chunk_report(), which by default issues a warning
+    rather than an error, leading to later reading from a NULL pointer
+    (png_ptr->palette) in png_do_expand_palette(). This is CVE-2013-6954
+    and VU#650142.  Libpng-1.6.1 through 1.6.7 and libpng-1.7.0beta03
+    through 1.7.0beta23 are vulnerable.  Libpng-1.6.0 and earlier do not
+    have the bug.
+
+Version 1.7.0beta25 [December 26, 2013]
+  Merged files with version 1.6.8 that have not changed since then.
+  Rebuilt configure scripts with automake-1.14.1 and autoconf-2.69
+
+Version 1.7.0beta26 [January 1, 2014]
+  Added libpng 1.5 checks to pngvalid.c
+  Merged with 1.5 and 1.6 changes to create a single pngvalid.c
+  Added dSIG to chunk list in png.h
+  Removed #error macro from contrib/tools/pngfix.c (Thomas Klausner).
+  Merged pngrio.c, pngtrans.c, and pngwio.c with libpng-1.6.9
+  Fixed test programs for interlace options. Made pngvalid.c and
+    pngtest.c work correctly when READ_INTERLACING and/or WRITE_INTERLACING
+    are switched off.
+  Changed pngvalid.c to support libpng 1.5, which does not support
+    the PNG_MAXIMUM_INFLATE_WINDOW option, so #define it out when
+    appropriate in pngvalid.c
+  Allow unversioned links created on install to be disabled in configure.
+    In configure builds 'make install' changes/adds links like png.h
+    and libpng.a to point to the newly installed, versioned, files (e.g.
+    libpng17/png.h and libpng17.a). Three new configure options and some
+    rearrangement of Makefile.am allow creation of these links to be disabled.
+
+Version 1.7.0beta27 [January 10, 2014]
+  Removed potentially misleading warning from png_check_IHDR().
+
+Version 1.7.0beta28 [January 20, 2014]
+  Updated scripts/makefile.* to use CPPFLAGS (Cosmin).
+  Added clang attribute support (Cosmin).
+
+Version 1.7.0beta29 [January 30, 2014]
+  Quiet an uninitialized memory warning from VS2013 in png_get_png().
+
+Version 1.7.0beta30 [February 2, 2014]
+  Fixed a large number of instances where PNGCBAPI was omitted from
+    function definitions.
+  Added pngimage test program for png_read_png and png_write_png. This
+    is a work-in-progress; no tests are run automatically at present and
+    the program by virtue of exhaustively testing all the transforms is
+    very slow.
+
+Version 1.7.0beta31 [February 6, 2014]
+  Make png_read_png() and png_write_png() prototypes in png.h depend
+    upon PNG_READ_SUPPORTED and PNG_WRITE_SUPPORTED.
+  Removed dependence on !PNG_READ_EXPAND_SUPPORTED for calling
+    png_set_packing() in png_read_png().
+  Completed full working pngimage test program and added two test scripts.
+  Fixed combination of ~alpha with shift. On read invert alpha, processing
+    occurred after shift processing, which causes the final values to be
+    outside the range that should be produced by the shift. Reversing the
+    order on read makes the two transforms work together correctly and mirrors
+    the order used on write.
+  Do not read invalid sBIT chunks. Previously libpng only checked sBIT
+    values on write, so a malicious PNG writer could therefore cause
+    the read code to return an invalid sBIT chunk, which might lead to
+    application errors or crashes.  Such chunks are now skipped (with
+    chunk_benign_error).
+  Restored a line, "c = b;", that was inadvertently deleted from the
+    PAETH filtering code from libpng-1.7.0beta24/pngrutil.c. Deleted
+    the other instance of "c = b;" which is the one that triggered a
+    scan-build warning.
+  Support builds with unsupported PNG_TRANSFORM_* values.  All of the
+    PNG_TRANSFORM_* values are always defined in png.h and, because they
+    are used for both read and write in some cases, it is not reliable
+    to #if out ones that are totally unsupported. This change adds error
+    detection in png_read_image() and png_write_image() to do a
+    png_app_error() if the app requests something that cannot be done
+    and it adds corresponding code to pngimage.c to handle such options
+    by not attempting to test them.
+
+Version 1.7.0beta32 [February 26, 2014]
+  Moved redefines of png_error(), png_warning(), png_chunk_error(),
+    and png_chunk_warning() from pngpriv.h to png.h to make them visible
+    to libpng-calling applications.
+  Moved OS dependent code from arm/arm_init.c, to allow the included
+    implementation of the ARM NEON discovery function to be set at
+    build-time and provide sample implementations from the current code in the
+    contrib/arm-neon subdirectory. The __linux__ code has also been changed to
+    compile and link on Android by using /proc/cpuinfo, and the old linux code
+    is in contrib/arm-neon/linux-auxv.c.  The new code avoids POSIX and Linux
+    dependencies apart from opening /proc/cpuinfo and is C90 compliant.
+  Check for info_ptr == NULL early in png_read_end() so we don't need to
+    run all the png_handle_*() and depend on them to return if info_ptr == NULL.
+    This improves the performance of png_read_end(png_ptr, NULL) and makes
+    it more robust against future programming errors.
+  Check for __has_extension before using it in pngconf.h, to
+    support older Clang versions (Jeremy Sequoia).
+  Use a user warning handler in contrib/gregbook/readpng2.c instead of default,
+    so warnings will be put on stderr even if libpng has CONSOLE_IO disabled.
+  Added png_ptr->process_mode = PNG_READ_IDAT_MODE in png_push_read_chunk
+    after recognizing the IDAT chunk, which avoids an infinite loop while
+    reading a datastream whose first IDAT chunk is of zero-length.
+    This fixes CERT VU#684412 and CVE-2014-0333.
+  Don't recognize known sRGB profiles as sRGB if they have been hacked,
+    but don't reject them and don't issue a copyright violation warning.
+  Minor editing of contrib/arm-neon/README and contrib/examples/*.c
+  Moved some documentation from png.h to libpng.3 and libpng-manual.txt
+
+Version 1.7.0beta33 [February 27, 2014]
+  Fixed typos in the manual and in scripts/pnglibconf.dfa (CFLAGS -> CPPFLAGS
+    and PNG_USR_CONFIG -> PNG_USER_CONFIG).
+
+Version 1.7.0beta34 [March 17, 2014]
+  Treat CRC error handling with png_set_crc_action(), instead of with
+    png_set_benign_errors(), which has been the case since libpng-1.6.0beta18.
+  Use "if (value != 0)" instead of "if (value)" consistently.
+  Changed ZlibSrcDir from 1.2.5 to 1.2.8 in projects/vstudio.
+  Moved configuration information from the manual to the INSTALL file.
+
+Version 1.7.0beta35 [August 6, 2014]
+  Removed #if/#else/#endif from inside two pow() calls in pngvalid.c because
+    they were handled improperly by Portland Group's PGI-14.1 - PGI-14.3
+    when using its "__builtin_pow()" function.
+  Silence 'unused parameter' build warnings (Cosmin).
+  $(CP) is now used alongside $(RM_F).  Also, use 'copy' instead
+    of 'cp' where applicable, and applied other minor makefile changes.
+  Don't warn about invalid dimensions exceeding user limits.
+  Allow an easy replacement of the default pre-built configuration
+    header with a custom header, via the make PNGLIBCONF_H_PREBUILT
+    macro.
+  Fixed a typo in pngrutil.c, introduced in libpng-1.5.6, that interferes
+    with "blocky" expansion of sub-8-bit interlaced PNG files (Eric Huss).
+  Removed scripts/makefile.elf. It has not worked since libpng-1.5.0beta14
+    due to elimination of the PNG_FUNCTION_EXPORT and PNG_DATA_EXPORT
+    definitions from pngconf.h.
+  Ensure that CMakeLists.txt makes the target "lib" directory before making
+    symbolic link into it (SourceForge bug report #226 by Rolf Timmermans).
+  Added opinion that the ECCN (Export Control Classification Number) for
+    libpng is EAR99 to the README file.
+
+Version 1.7.0beta36 [September 27, 2014]
+  Updated scripts/makefiles from libpng-1.6.13beta04.
+  Minor updates to the manual from libpng-1.6.14beta04.
+  Fixed incorrect handling of the iTXt compression flag in pngrutil.c
+    (bug report by Shunsaku Hirata).  Bug was introduced in libpng-1.6.0.
+
+Version 1.7.0beta37 [September 28, 2014]
+  Merged scripts/*, pngvalid.c and pngfix.c with libpng-1.6.14beta04.
+
+Version 1.7.0beta38 [October 17, 2014]
+  Added "option READ_iCCP enables READ_COMPRESSED_TEXT" to pnglibconf.dfa
+  Removed unused "text_len" parameter from private function png_write_zTXt().
+  Conditionally compile some code in png_deflate_claim(), when
+    PNG_WARNINGS_SUPPORTED and PNG_ERROR_TEXT_SUPPORTED are disabled.
+  Replaced repeated code in pngpread.c with PNG_PUSH_SAVE_BUFFER_IF_FULL.
+  Added "chunk iTXt enables TEXT" and "chunk zTXt enables TEXT"
+    to pnglibconf.dfa.
+  Removed "option READ_COMPRESSED_TEXT enables READ_TEXT" from pnglibconf.dfa,
+    to make it possible to configure a libpng that supports iCCP but not TEXT.
+  Removed "option WRITE_COMPRESSED_TEXT enables WRITE_TEXT" from pnglibconf.dfa
+  Only mark text chunks as written after successfully writing them.
+
+Version 1.7.0beta39 [November 1, 2014]
+  Ported cosmetic changes from libpng-1.6.15beta02.
+
+Version 1.7.0beta40 [November 6, 2014]
+  Made a one-line revision to configure.ac to support ARM on aarch64
+    (bug report by Marcin Juszkiewicz, fix by John Bowler).
+  Use png_get_libpng_ver(NULL) instead of PNG_LIBPNG_VER_STRING in
+    example.c, pngtest.c, and applications in the contrib directory.
+  Avoid out-of-bounds memory access in png_user_version_check().
+  Simplified and future-proofed png_user_version_check().
+  Fixed GCC unsigned int->float warnings. Various versions of GCC
+    seem to generate warnings when an unsigned value is implicitly
+    converted to double. This is probably a GCC bug but this change
+    avoids the issue by explicitly converting to (int) where safe.
+  Free all allocated memory in pngimage. The file buffer cache was left
+    allocated at the end of the program, harmless but it causes memory
+    leak reports from clang.
+  Fixed array size calculations to avoid warnings. At various points
+    in the code the number of elements in an array is calculated using
+    sizeof.  This generates a compile time constant of type (size_t) which
+    is then typically assigned to an (unsigned int) or (int). Some versions
+    of GCC on 64-bit systems warn about the apparent narrowing, even though
+    the same compiler does apparently generate the correct, in-range,
+    numeric constant.  This adds appropriate, safe, casts to make the
+    warnings go away.
+
+Version 1.7.0beta41 [November 7, 2014]
+  Added #ifdef PNG_16BIT_SUPPORTED/#endif around png_log16bit() and
+    png_do_swap().
+  Changed all "#endif /* PNG_FEATURE_SUPPORTED */" to "#endif /* FEATURE */"
+
+Version 1.7.0beta42 [November 20, 2014]
+  The macros passed in the command line to Borland make were ignored if
+    similarly-named macros were already defined in makefiles. This behavior
+    is different from POSIX make and other make programs.  Surround the
+    macro definitions with ifndef guards (Cosmin).
+  Added "-D_CRT_SECURE_NO_WARNINGS" to CFLAGS in scripts/makefile.vcwin32.
+  Removed the obsolete $ARCH variable from scripts/makefile.darwin.
+  Merged clang no-warning fix from libpng-1.6.13: png_digit was defined
+    but never used in pngerror.c.
+
+Version 1.7.0beta43 [December 18, 2014]
+  Added ".align 2" to arm/filter_neon.S to support old GAS assemblers that
+    don't do alignment correctly.
+  Revised Makefile.am and scripts/*.dfn to work with MinGW/MSYS;
+    renamed scripts/*.dfn to scripts/*.c (Bob Friesenhahn and John Bowler).
+  Quiet a "comparison always true" warning in pngstest.c (John Bowler).
+
+Version 1.7.0beta44 [December 23, 2014]
+  Restored a test on width that was removed from png.c at libpng-1.6.9
+    (Bug report by Alex Eubanks, CVE-2015-0973).
+  Fixed an overflow in png_combine_row() with very wide interlaced images
+    (Bug report and fix by John Bowler, CVE-2014-9495).
+  Corrected the width limit calculation in png_check_IHDR().
+  Removed extraneous handling of PNG_SAFE_LIMITS_SUPPORTED from pngconf.h
+
+Version 1.7.0beta45 [December 28, 2014]
+  Eliminated the PNG_SAFE_LIMITS macro and restored the 1-million-column
+    and 1-million-row default limits in pnglibconf.dfa, that can be reset
+    by the user at build time or run time.  This provides a more robust
+    defense against DOS and as-yet undiscovered overflows.
+  Removed user limits from pngfix. Also pass NULL pointers to
+    png_read_row to skip the unnecessary row de-interlace stuff.
+  Added testing of png_set_packing() to pngvalid.c
+
+Version 1.7.0beta46 [January 2, 2015]
+  Regenerated configure scripts in the tar distributions with libtool-2.4.4
+  Implement previously untested cases of libpng transforms in pngvalid.c
+  Fixed byte order in 2-byte filler, in png_do_read_filler().
+  Allow user to call png_get_IHDR() with NULL arguments (Reuben Hawkins).
+
+Version 1.7.0beta47 [January 29, 2015]
+  Made the check for out-of-range values in png_set_tRNS() detect
+    values that are exactly 2^bit_depth, and work on 16-bit platforms.
+  Added PNG_SKIP_sRGB_CHECK_PROFILE choice for png_set_option().
+  Report all IHDR errors before exiting png_check_IHDR().
+  Merged some parts of libpng-1.6.17beta01 and libpng-1.7.0beta47.
+  Added #ifndef __COVERITY__ where needed in png.c, pngrutil.c and
+    pngset.c to avoid warnings about dead code.
+
+Version 1.7.0beta48 [February 7, 2015]
+  Work around one more Coverity-scan dead-code warning.
+  Do not build png_product2() when it is unused.
+
+Version 1.7.0beta49 [February 11, 2015]
+  Combined sub_row, up_row, avg_row, and paeth_row buffers into a
+    single try_row buffer.
+  Added PNG_WRITE_CUSTOMIZE_COMPRESSION_SUPPORTED macro, on by default.
+  Consolidated redundant code in pngwutil.c
+  Deal with integer overflow of sum in pngwutil.c
+
+Version 1.7.0beta50 [February 15, 2015]
+  Combined sub_row, up_row, avg_row, and paeth_row buffers into a
+    single try_row buffer and in cases where two or more of those are
+    being tested, a second tst_row buffer.  This improves CPU speed
+    over that achieved by libpng-1.7.0beta49.
+
+Version 1.7.0beta51 [February 17, 2015]
+  Combined similar parts of png_write_find_filter() into a png_increase_lmins()
+    function.
+  Display user limits in the output from pngtest.
+  Replaced test for harmless integer overflow (wraparound) in pngwutil.c
+    with a method that prevents overflow and does not increase cpu usage
+    significantly.
+
+Version 1.7.0beta52 [February 21, 2015]
+  Added information about setjmp/simplified API interaction in the
+    manual page and INSTALL file. Added information about using
+    row_pointers with a single height*width*bpp allocated block
+  Rebuilt configure scripts with automake-1.15 and libtool-2.4.6
+
+Version 1.7.0beta53 [February 23, 2015]
+  Restored compiling of png_reciprocal2 with PNG_NO_16BIT.
+
+Version 1.7.0beta54 [March 4, 2015]
+  Moved png_set_filter() prototype into a PNG_WRITE_SUPPORTED block
+    of png.h.
+  Conditionally compile a small amount of code in pngwutil.c
+  Avoid runtime checks when converting integer to png_byte with
+    Visual Studio (Sergey Kosarevsky)
+  Merged pngwrite.c with libpng-1.6.17beta06/pngwrite.c
+
+Version 1.7.0beta55 [March 9, 2015]
+  Removed some comments that the configure script did not handle
+    properly from scripts/pnglibconf.dfa and pnglibconf.h.prebuilt.
+  Spelling fixes ("then", "occured") reported by Lauri Nurmi.
+  Added more error reporting in png_default_read_data().
+  Merged png_free_data() with libpng-1.6.17rc02.
+
+Version 1.7.0beta56 [March 11, 2015]
+  Updated CMakeLists.txt to add OSX framework, change YES/NO to ON/OFF
+    for consistency, and remove some useless tests (Alexey Petruchik).
+
+Version 1.7.0beta57 [March 16, 2015]
+  Remove pnglibconf.h, pnglibconf.c, and pnglibconf.out instead of
+    pnglibconf.* in "make clean" (Cosmin).
+  Fix bug in calculation of maxbits, in png_write_sBIT, introduced
+    in libpng-1.6.17beta01 (John Bowler).
+  Revert change to png_default_read_data() made in libpng-1.7.0beta55.
+
+Version 1.7.0beta58 [March 25, 2015]
+  Implemented affirm() support and usage.
+  Remove pnglibconf.dfn and pnglibconf.pre with "make clean".
+  Added byte, short and other overflow checking
+  Added 'affirm' based overflow checking for debug builds for char
+    and short assignments. Simply ignore the error in release builds
+    (a truncated value will be used without warning). Controlled by
+    PNG_RANGE_CHECK_SUPPORTED.
+  Improved some overflow handling. PNG_RELEASE_BUILD replaces tests
+    where the code depended on the build base type and can be defined on
+    the command line, allowing testing in beta builds.  Overflows previously
+    handled by png_warning in png.c have been changed to use new
+    macros/affirm functions so that beta builds will abort on overflow and
+    release builds will quietly ignore it.  This avoids release builds
+    producing warnings that are of no use to end users.
+  Check (png_uint_16) casts for overflow. Also removed png_muldiv_warn,
+    added RELEASE/!RELEASE convenience macros. png_muldiv_warn was used in
+    only one place, and the overflow condition is a genuine warning not
+    an internal error.  Four macros allow code or function parameters to be
+    condition on RELEASE (or not) builds and tidy up the #ifdef handling of
+    functions.
+
+Version 1.7.0beta59 [April 19, 2015]
+  Transformed rewrite: changed row_info, added checks. This introduces an
+    internal struct (png_transform_control) to replace row_info and uses
+    that to implement affirms correctly.  The change also adds checks on
+    the rowbytes calculation and additional checks on most transform
+    implementations.
+  Added png_uint_16 range checking, pngvalid tRNS, fixed png_uint_16:
+    review of previous checks, removal of some where SAFE. pngvalid: add
+    testing of tRNS for better code coverage pngvalid: correct rgb-to-gray
+    error calculations. Code coverage is still incomplete: see /*UNTESTED*/
+    in pngrtran.c. This fixes some arithmetic errors that caused some tests
+    to fail on some 32-bit platforms (Bug reports by Peter Breitenlohner [i686]
     and Petr Gajdos [i586]).
-
-Version 1.6.18beta02 [April 26, 2015]
   Suppressed some warnings from the Borland C++ 5.5.1/5.82 compiler
     (Bug report by Viktor Szaka'ts).
 
-Version 1.6.18beta03 [May 6, 2015]
+Version 1.7.0beta60 [May 6, 2015]
   Replaced "unexpected" with an integer (0xabadca11) in pngset.c
     where a long was expected, to avoid a compiler warning when PNG_DEBUG > 1.
-  Added contrib/examples/simpleover.c, to demonstrate how to handle
-    alpha compositing of multiple images, using the "simplified API"
-    and an example PNG generation tool, contrib/examples/genpng.c
-    (John Bowler).
 
-Version 1.6.18beta04 [May 20, 2015]
-  PNG_RELEASE_BUILD replaces tests where the code depended on the build base
-    type and can be defined on the command line, allowing testing in beta
-    builds (John Bowler).
+Version 1.7.0beta61 [May 31, 2015]
   Avoid Coverity issue 80858 (REVERSE NULL) in pngtest.c
   Avoid a harmless potential integer overflow in png_XYZ_from_xy() (Bug
     report from Christopher Ferris).
-
-Version 1.6.18beta05 [May 31, 2015]
-  Backport filter selection code from libpng-1.7.0beta51, to combine
-    sub_row, up_row, avg_row, and paeth_row into try_row and tst_row.
   Changed png_voidcast(), etc., to voidcast(), etc., in contrib/tools/pngfix.c
     to avoid confusion with the libpng private macros.
   Fixed old cut&paste bug in the weighted filter selection code in
     pngwutil.c, introduced in libpng-0.95, March 1997.
 
-Version 1.6.18beta06 [June 1, 2015]
-  Removed WRITE_WEIGHTED_FILTERED code, to save a few kbytes of the
-    compiled library size. It never worked properly and as far as we can
-    tell, no one uses it. The png_set_filter_heuristics() and
-    png_set_filter_heuristics_fixed() APIs are retained but deprecated
-    and do nothing.
+Version 1.7.0beta62 [June 1, 2015]
+  Removed the experimental WRITE_WEIGHTED_FILTERED code, to save a few
+    kbytes of the compiled library size. It never worked properly and as
+    far as we can tell, no one uses it. The png_set_filter_heuristics() and
+    png_set_filter_heuristics_fixed() APIs are retained but deprecated.
 
-Version 1.6.18beta07 [June 6, 2015]
+Version 1.7.0beta63 [June 6, 2015]
+  Quieted some Coverity issues in pngfix.c, png-fix-itxt.c, pngvalid.c,
+    pngstest.c, and pngimage.c. Most seem harmless, but png-fix-itxt
+    would only work with iTXt chunks with length 255 or less.
+  Fixed cexcept.h in which GCC 5 reported that one of the auto
+    variables in the Try macro needs to be volatile to prevent value
+    being lost over the setjmp, and fixed g++ build breaks (John Bowler).
+  Moved READ_GAMMA to pngrtran.c. This makes everything in pngrtrans.c
+    depend on READ_TRANSFORMS and moves all the transform gamma (READ_GAMMA)
+    code from elsewhere to png_tran.c.  There are no code changes. 
+    There is one remaining use of the gamma (16-bit) code in the simplified
+    API in pngread.c but that is because of a long-standing libpng bug,
+    namely that the gamma corrected palette is no produced by
+    png_read_update_info (John Bowler).
+  Completed AArch64 support. The previous change to recognize __ARM_NEON
+    didn't touch all the required preprocessor lines. This change removes
+    support for __ARM_NEON__ completely and makes this consistent.
+  Added #ifdef's to contrib/examples programs so people don't try
+    to compile them without the minimum required support enabled
+    (suggested by Flavio Medeiros).
+
+Version 1.7.0beta64 [July 26, 2015]
   Removed non-working progressive reader 'skip' function. This
     function has apparently never been used. It was implemented
     to support back-door modification of png_struct in libpng-1.4.x
     but (because it does nothing and cannot do anything) was apparently
     never tested (John Bowler).
-  Fixed cexcept.h in which GCC 5 now reports that one of the auto
-    variables in the Try macro needs to be volatile to prevent value
-    being lost over the setjmp (John Bowler).
-  Fixed NO_WRITE_FILTER and -Wconversion build breaks (John Bowler).
-  Fix g++ build breaks (John Bowler).
-  Quieted some Coverity issues in pngfix.c, png-fix-itxt.c, pngvalid.c,
-    pngstest.c, and pngimage.c. Most seem harmless, but png-fix-itxt
-    would only work with iTXt chunks with length 255 or less.
-  Added #ifdef's to contrib/examples programs so people don't try
-    to compile them without the minimum required support enabled
-    (suggested by Flavio Medeiros).
-
-Version 1.6.18beta08 [June 30, 2015]
   Eliminated the final two Coverity defects (insecure temporary file
     handling in contrib/libtests/pngstest.c; possible overflow of
     unsigned char in contrib/tools/png-fix-itxt.c). To use the "secure"
     file handling, define PNG_USE_MKSTEMP, otherwise "tmpfile()" will
     be used.
   Removed some unused WEIGHTED_FILTER macros from png.h and pngstruct.h
-
-Version 1.6.18beta09 [July 5, 2015]
-  Removed some useless typecasts from contrib/tools/png-fix-itxt.c
-  Fixed a new signed-unsigned comparison in pngrtran.c (Max Stepin).
-  Replaced arbitrary use of 'extern' with #define PNG_LINKAGE_*.  To
-    preserve API compatibility, the new defines all default to "extern"
-    (requested by Jan Nijtmans).
-
-Version 1.6.18rc01 [July 9, 2015]
+  Rearranged png.h to put the major sections in the same order as
+    in libpng16.
   Belatedly added Mans Rullgard and James Yu to the list of Contributing
     Authors.
 
-Version 1.6.18rc02 [July 12, 2015]
-  Restored unused WEIGHTED_FILTER macros removed at libpng-1.6.18beta08
-    to png.h to avoid compatibility warnings.
-
 Send comments/corrections/commendations to png-mng-implement at lists.sf.net
 (subscription required; visit
 https://lists.sourceforge.net/lists/listinfo/png-mng-implement

CMakeLists.txt

@@ -15,8 +15,8 @@ project(libpng C)
 enable_testing()
 
 set(PNGLIB_MAJOR 1)
-set(PNGLIB_MINOR 6)
-set(PNGLIB_RELEASE 18)
+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})
 
@@ -261,9 +261,9 @@ endif(NOT WIN32 OR CYGWIN OR MINGW)
 # SET UP LINKS
 if(PNG_SHARED)
   set_target_properties(${PNG_LIB_NAME} PROPERTIES
-#   VERSION 16.${PNGLIB_RELEASE}.1.6.18rc02
-    VERSION 16.${PNGLIB_RELEASE}.0
-    SOVERSION 16
+#   VERSION 17.${PNGLIB_RELEASE}.1.7.0beta64
+    VERSION 17.${PNGLIB_RELEASE}.0
+    SOVERSION 17
     CLEAN_DIRECT_OUTPUT 1)
 endif()
 if(PNG_STATIC)
@@ -296,7 +296,7 @@ if(NOT SKIP_INSTALL_LIBRARIES AND NOT SKIP_INSTALL_ALL )
       FRAMEWORK DESTINATION ${CMAKE_INSTALL_LIBDIR})
 
   if(PNG_SHARED)
-    # Create a symlink for libpng.dll.a => libpng16.dll.a on Cygwin
+    # 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

@@ -399,7 +399,7 @@ CFLAGS="-Wall -O -funroll-loops \
 --with-pkgconfigdir=/usr/lib/pkgconfig --includedir=/usr/include
 
 You can alternatively specify --includedir=/usr/include, /usr/local/include,
-/usr/include/libpng16, or whatever.
+/usr/include/libpng17, or whatever.
 
 If you find that the configure script is out-of-date or is not supporting
 your platform properly, try running autogen.sh to regenerate "configure",

LICENSE

@@ -10,7 +10,7 @@ this sentence.
 
 This code is released under the libpng license.
 
-libpng versions 1.0.7, July 1, 2000, through 1.6.18rc02, July 12, 2015, are
+libpng versions 1.0.7, July 1, 2000, through 1.7.0beta64, July 26, 2015, are
 Copyright (c) 2000-2002, 2004, 2006-2015 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:
@@ -104,4 +104,4 @@ the additional disclaimers inserted at version 1.0.7.
 
 Glenn Randers-Pehrson
 glennrp at users.sourceforge.net
-July 12, 2015
+July 26, 2015

Makefile.am

@@ -129,12 +129,12 @@ EXTRA_DIST= \
 	$(TESTS) $(XFAIL_TESTS) tests/pngstest \
 	CMakeLists.txt example.c libpng-manual.txt
 
-SCRIPT_CLEANFILES=scripts/*.out scripts/*.chk
+SCRIPT_CLEANFILES=scripts/*.out scripts/*.chk scripts/pnglibconf.c
 
 CLEANFILES= *.tf? pngout.png libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@.pc \
 	libpng@PNGLIB_MAJOR@@PNGLIB_MINOR@-config libpng.vers libpng.sym \
 	check.new pnglibconf.h pngprefix.h symbols.new pngtest-log.txt \
-	pnglibconf.out pnglibconf.c pnglibconf.pre pnglibconf.dfn \
+	pnglibconf.out pnglibconf.c pnglibconf.dfn pnglibconf.pre \
 	$(SCRIPT_CLEANFILES)
 
 MAINTAINERCLEANFILES = Makefile.in aclocal.m4 config.guess config.h.in \
@@ -146,8 +146,8 @@ config.sub configure depcomp install-sh ltmain.sh missing
 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
+# DFNCPP is normally just "CPP -E" - 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.
@@ -166,6 +166,8 @@ 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 $? $@
@@ -177,7 +179,7 @@ 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
+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}\

README

@@ -1,4 +1,4 @@
-README for libpng version 1.6.18rc02 - July 12, 2015 (shared library 16.0)
+README for libpng version 1.7.0beta64 - July 26, 2015 (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.

arm/arm_init.c

@@ -15,6 +15,7 @@
 #define _POSIX_SOURCE 1
 
 #include "../pngpriv.h"
+#define PNG_SRC_FILE PNG_SRC_FILE_arm_arm_init
 
 #ifdef PNG_READ_SUPPORTED
 

arm/filter_neon.S

@@ -3,7 +3,7 @@
  *
  * Copyright (c) 2014 Glenn Randers-Pehrson
  * Written by Mans Rullgard, 2011.
- * Last changed in libpng 1.6.16 [December 22, 2014]
+ * Last changed in libpng 1.6.16 [(PENDING RELEASE)]
  *
  * This code is released under the libpng license.
  * For conditions of distribution and use, see the disclaimer

arm/filter_neon_intrinsics.c

@@ -13,6 +13,7 @@
  */
 
 #include "../pngpriv.h"
+#define PNG_SRC_FILE PNG_SRC_FILE_arm_filter_neon_intrinsics
 
 #ifdef PNG_READ_SUPPORTED
 

configure.ac

@@ -18,7 +18,7 @@ AC_PREREQ([2.68])
 
 dnl Version number stuff here:
 
-AC_INIT([libpng],[1.6.18rc02],[png-mng-implement@lists.sourceforge.net])
+AC_INIT([libpng],[1.7.0beta64],[png-mng-implement@lists.sourceforge.net])
 AC_CONFIG_MACRO_DIR([scripts])
 
 # libpng does not follow GNU file name conventions (hence 'foreign')
@@ -39,10 +39,10 @@ dnl automake, so the following is not necessary (and is not defined anyway):
 dnl AM_PREREQ([1.11.2])
 dnl stop configure from automagically running automake
 
-PNGLIB_VERSION=1.6.18rc02
+PNGLIB_VERSION=1.7.0beta64
 PNGLIB_MAJOR=1
-PNGLIB_MINOR=6
-PNGLIB_RELEASE=18
+PNGLIB_MINOR=7
+PNGLIB_RELEASE=0
 
 dnl End of version number stuff
 
@@ -60,10 +60,10 @@ AC_PROG_INSTALL
 AC_PROG_LN_S
 AC_PROG_MAKE_SET
 
-dnl libtool/libtoolize; version 2.4.2 is the tested version, this or any
+dnl libtool/libtoolize; version 2.4.4 is the tested version, this or any
 dnl compatible later version may be used
 LT_INIT([win32-dll])
-LT_PREREQ([2.4.2])
+LT_PREREQ([2.4.4])
 
 # Some awks crash when confronted with pnglibconf.dfa, do a test run now
 # to make sure this doesn't happen
@@ -79,7 +79,7 @@ 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"
+DFNCPP="$CPP -E"
 AC_SUBST(DFNCPP)
 
 # -Werror cannot be passed to GCC in CFLAGS because configure will fail (it
@@ -109,30 +109,146 @@ AC_ARG_ENABLE(werror,
 
 # 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.
-AC_C_CONST
-AC_TYPE_SIZE_T
-AC_STRUCT_TM
+# 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.
-AC_FUNC_STRTOD
-AC_CHECK_FUNCS([memset], , AC_MSG_ERROR(memset not found in libc))
-AC_CHECK_FUNCS([pow], , AC_CHECK_LIB(m, pow, , AC_MSG_ERROR(cannot find pow)) )
-AC_ARG_WITH(zlib-prefix,
-   AS_HELP_STRING([[[--with-zlib-prefix]]],
-      [prefix that may have been used in installed zlib]),
-      [ZPREFIX=${withval}],
-      [ZPREFIX='z_'])
-AC_CHECK_LIB(z, zlibVersion, ,
-    AC_CHECK_LIB(z, ${ZPREFIX}zlibVersion, , AC_MSG_ERROR(zlib not installed)))
+# 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],
+   AS_HELP_STRING([[[--enabled-floating-point]]],
+      [Enable floating point APIs (default: yes)]),,
+   [enable_floating_point=yes])
+
+AC_ARG_ENABLE([fixed-point],
+   AS_HELP_STRING([[[--enable-fixed-point]]],
+      [Enable fixed point APIs (default: yes)]),,
+   [enable_fixed_point=yes])
+
+AC_ARG_ENABLE([floating-arithmetic],
+   AS_HELP_STRING([[[--enable-floating-arithmetic]]],
+      [Use floating point arithmetic internally (default: yes)]),,
+   [enable_floating_arithmetic=yes])
+
+# Check for a requirement for math library support
+if test "$enable_floating_arithmetic" = yes
+then
+   AC_SEARCH_LIBS([floor],[m],,
+                  [AC_MSG_WARN([not found])
+                   enable_floating_arithmetic=no])
+   AC_SEARCH_LIBS([frexp],[m],,
+                  [AC_MSG_WARN([not found])
+                   enable_floating_arithmetic=no])
+   AC_SEARCH_LIBS([modf],[m],,
+                  [AC_MSG_WARN([not found])
+                   enable_floating_arithmetic=no])
+   AC_SEARCH_LIBS([atof],[m],,
+                  [AC_MSG_WARN([not found])
+                   enable_floating_arithmetic=no])
+   AC_SEARCH_LIBS([pow],[m],,
+                  [AC_MSG_WARN([not found])
+                   enable_floating_arithmetic=no])
+fi
+
+# Set the relevant defines if required (only if required), this will override
+# anything on the command line.
+if test "$enable_floating_point" != yes
+then
+   AC_MSG_NOTICE([Floating point APIs disabled])
+   AC_DEFINE([PNG_NO_FLOATING_POINT],[1],
+             [No support for floating point APIs])
+fi
+if test "$enable_fixed_point" != yes
+then
+   AC_MSG_NOTICE([Fixed point APIs disabled])
+   AC_DEFINE([PNG_NO_FIXED_POINT],[1],
+             [No support for fixed point APIs])
+fi
+if test "$enable_floating_arithmetic" != yes
+then
+   AC_MSG_NOTICE([Fixed point arithmetic will be used])
+   AC_DEFINE([PNG_NO_FLOATING_ARITHMETIC],[1],
+             [No support for floating point arithmetic])
+fi
 
 # The following is for pngvalid, to ensure it catches FP errors even on
 # platforms that don't enable FP exceptions, the function appears in the math
 # library (typically), it's not an error if it is not found.
-AC_CHECK_LIB([m], [feenableexcept])
-AC_CHECK_FUNCS([feenableexcept])
+AC_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`
@@ -178,7 +294,7 @@ AM_CONDITIONAL(HAVE_LD_VERSION_SCRIPT, test "$have_ld_version_script" = "yes")
 if test "$have_ld_version_script" = "yes"; then
     AC_MSG_CHECKING([for symbol prefix])
     SYMBOL_PREFIX=`echo "PREFIX=__USER_LABEL_PREFIX__" \
-                  | ${CPP-${CC-gcc} -E} - 2>&1 \
+                  | ${DFNCPP-${CC-gcc -E}} - 2>&1 \
                   | ${EGREP-grep} "^PREFIX=" \
                   | ${SED-sed} -e "s:^PREFIX=::" -e "s:__USER_LABEL_PREFIX__::"`
     AC_SUBST(SYMBOL_PREFIX)
@@ -317,8 +433,7 @@ AM_CONDITIONAL([PNG_ARM_NEON],
 AC_MSG_NOTICE([[Extra options for compiler: $PNG_COPTS]])
 
 # Config files, substituting as above
-AC_CONFIG_FILES([Makefile libpng.pc:libpng.pc.in])
-AC_CONFIG_FILES([libpng-config:libpng-config.in],
-   [chmod +x libpng-config])
+AC_CONFIG_FILES([Makefile libpng.pc])
+AC_CONFIG_FILES([libpng-config], [chmod +x libpng-config])
 
 AC_OUTPUT

contrib/gregbook/Makefile.sgi

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

contrib/gregbook/Makefile.unx

@@ -26,14 +26,14 @@
 # macros --------------------------------------------------------------------
 
 #PNGDIR = /usr/local/lib
-#PNGINC = -I/usr/local/include/libpng16
-#PNGLIBd = -L$(PNGDIR) -lpng16 # dynamically linked, installed libpng
-#PNGLIBs = $(PNGDIR)/libpng16.a # statically linked, installed libpng
+#PNGINC = -I/usr/local/include/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) -lpng16	# dynamically linked
+PNGLIBd = -Wl,-rpath,$(PNGDIR) -L$(PNGDIR) -lpng17	# dynamically linked
 PNGLIBs = $(PNGDIR)/libpng.a		# statically linked, local libpng
 
 ZDIR = /usr/local/lib
@@ -59,16 +59,15 @@ INCS = $(PNGINC) $(ZINC) $(XINC)
 RLIBSd = $(PNGLIBd) $(ZLIBd) $(XLIB) -lm
 RLIBSs = $(PNGLIBs) $(ZLIBs) $(XLIB) -lm
 WLIBSd = $(PNGLIBd) $(ZLIBd) -lm
-WLIBSs = $(PNGLIBs) $(ZLIBs) -lm
+WLIBSs = $(PNGLIBs) $(ZLIBs)
 
 CC = gcc
 LD = gcc
 RM = rm -f
 CPPFLAGS = $(INCS) -DFEATURE_LOOP
 CFLAGS = -O -Wall
-#CFLAGS = -O -W -Wall -Wextra -pedantic -ansi
 # [note that -Wall is a gcc-specific compilation flag ("most warnings on")]
-# [-ansi, -pedantic, -Wextra, and -W can also be used]
+# [-ansi, -pedantic and -W can also be used]
 LDFLAGS =
 O = .o
 E =

contrib/gregbook/readpng.c

@@ -100,8 +100,7 @@ int readpng_init(FILE *infile, ulg *pWidth, ulg *pHeight)
 
     /* could pass pointers to user-defined error handlers instead of NULLs: */
 
-    png_ptr = png_create_read_struct(png_get_libpng_ver(NULL), NULL, NULL,
-        NULL);
+    png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
     if (!png_ptr)
         return 4;   /* out of memory */
 

contrib/gregbook/readpng2.c

@@ -104,7 +104,7 @@ int readpng2_init(mainprog_info *mainprog_ptr)
 
     /* could also replace libpng warning-handler (final NULL), but no need: */
 
-    png_ptr = png_create_read_struct(png_get_libpng_ver(NULL), mainprog_ptr,
+    png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, mainprog_ptr,
       readpng2_error_handler, readpng2_warning_handler);
     if (!png_ptr)
         return 4;   /* out of memory */

contrib/gregbook/rpng-x.c

@@ -26,8 +26,6 @@
     - 1.14:  added support for X resources (thanks to Gerhard Niklasch)
     - 2.00:  dual-licensed (added GNU GPL)
     - 2.01:  fixed improper display of usage screen on PNG error(s)
-    - 2.02:  Added "void(argc);" statement to quiet pedantic compiler warnings
-             about unused variable (GR-P)
 
   ---------------------------------------------------------------------------
 
@@ -82,7 +80,7 @@
 
 #define PROGNAME  "rpng-x"
 #define LONGNAME  "Simple PNG Viewer for X"
-#define VERSION   "2.02 of 15 June 2014"
+#define VERSION   "2.01 of 16 March 2008"
 #define RESNAME   "rpng"        /* our X resource application name */
 #define RESCLASS  "Rpng"        /* our X resource class name */
 
@@ -281,17 +279,15 @@ int main(int argc, char **argv)
           "Usage:  %s [-display xdpy] [-gamma exp] [-bgcolor bg] file.png\n"
           "    xdpy\tname of the target X display (e.g., ``hostname:0'')\n"
           "    exp \ttransfer-function exponent (``gamma'') of the display\n"
-          "\t\t  system in floating-point format (e.g., ``%.1f''); equal\n",
-          PROGNAME, default_display_exponent);
-
-        fprintf(stderr, "\n"
+          "\t\t  system in floating-point format (e.g., ``%.1f''); equal\n"
           "\t\t  to the product of the lookup-table exponent (varies)\n"
           "\t\t  and the CRT exponent (usually 2.2); must be positive\n"
           "    bg  \tdesired background color in 7-character hex RGB format\n"
           "\t\t  (e.g., ``#ff7700'' for orange:  same as HTML colors);\n"
           "\t\t  used with transparent images\n"
           "\nPress Q, Esc or mouse button 1 (within image window, after image\n"
-          "is displayed) to quit.\n");
+          "is displayed) to quit.\n"
+          "\n", PROGNAME, default_display_exponent);
         exit(1);
     }
 
@@ -423,8 +419,6 @@ int main(int argc, char **argv)
 
     rpng_x_cleanup();
 
-    (void)argc; /* Unused */
-
     return 0;
 }
 

contrib/gregbook/rpng2-win.c

@@ -33,8 +33,6 @@
     - 2.02:  fixed improper display of usage screen on PNG error(s); fixed
               unexpected-EOF and file-read-error cases
     - 2.03:  removed runtime MMX-enabling/disabling and obsolete -mmx* options
-    - 2.04:  
-             (GR-P)
 
   ---------------------------------------------------------------------------
 

contrib/gregbook/rpng2-x.c

@@ -41,11 +41,7 @@
               unexpected-EOF and file-read-error cases; fixed Trace() cut-and-
               paste bugs
     - 2.03:  deleted runtime MMX-enabling/disabling and obsolete -mmx* options
-    - 2.04:  Added "void(foo);" statements to quiet pedantic compiler warnings
-             about unused variables (GR-P)
 
-  TO DO:
-             use nanosleep() instead of usleep(), which is obsolete/deprecated.
   ---------------------------------------------------------------------------
 
       Copyright (c) 1998-2008 Greg Roelofs.  All rights reserved.
@@ -99,7 +95,7 @@
 
 #define PROGNAME  "rpng2-x"
 #define LONGNAME  "Progressive PNG Viewer for X"
-#define VERSION   "2.04 of 15 June 2014"
+#define VERSION   "2.03 of 25 February 2010"
 #define RESNAME   "rpng2"       /* our X resource application name */
 #define RESCLASS  "Rpng"       /* our X resource class name */
 
@@ -115,18 +111,6 @@
 #include <X11/Xos.h>
 #include <X11/keysym.h>   /* defines XK_* macros */
 
-#if _POSIX_C_SOURCE >= 199309L /* have nanosleep() */
-# undef usleep
-# define usleep(usec) {        \
-   struct timespec ts;         \
-   ts.tv_nsec = (usec) * 1000; \
-   nanosleep(&ts, NULL); }
-#  endif
-
-#ifndef usleep /* have neither nanosleep() nor usleep() */
-#  define usleep(x) sleep(((x)+499999)/1000000)
-#endif
-
 #ifdef VMS
 #  include <unistd.h>
 #endif
@@ -472,47 +456,40 @@ int main(int argc, char **argv)
         fprintf(stderr, "\n%s %s:  %s\n\n", PROGNAME, VERSION, appname);
         readpng2_version_info();
         fprintf(stderr, "\n"
-          "Usage:   ");
-        fprintf(stderr,
-          "%s [-display xdpy] [-gamma exp] [-bgcolor bg | -bgpat pat]\n"
-          "        %*s [-usleep dur | -timing] [-pause]\n",
-          PROGNAME, (int)strlen(PROGNAME), " ");
-        fprintf(stderr,
+          "Usage:  %s [-display xdpy] [-gamma exp] [-bgcolor bg | -bgpat pat]\n"
 #ifdef FEATURE_LOOP
-          "        [-loop [sec]]"
+          "        %*s [-usleep dur | -timing] [-pause] [-loop [sec]] file.png\n\n"
+#else
+          "        %*s [-usleep dur | -timing] [-pause] file.png\n\n"
 #endif
-          " file.png\n\n");
-        fprintf(stderr,
           "    xdpy\tname of the target X display (e.g., ``hostname:0'')\n"
           "    exp \ttransfer-function exponent (``gamma'') of the display\n"
           "\t\t  system in floating-point format (e.g., ``%.1f''); equal\n"
-          "\t\t  to the product of the lookup-table exponent (varies)\n",
-          default_display_exponent);
-        fprintf(stderr,
+          "\t\t  to the product of the lookup-table exponent (varies)\n"
           "\t\t  and the CRT exponent (usually 2.2); must be positive\n"
           "    bg  \tdesired background color in 7-character hex RGB format\n"
           "\t\t  (e.g., ``#ff7700'' for orange:  same as HTML colors);\n"
           "\t\t  used with transparent images; overrides -bgpat\n"
           "    pat \tdesired background pattern number (0-%d); used with\n"
-          "\t\t  transparent images; overrides -bgcolor\n",
-          num_bgpat-1);
+          "\t\t  transparent images; overrides -bgcolor\n"
 #ifdef FEATURE_LOOP
-        fprintf(stderr, 
           "    -loop\tloops through background images after initial display\n"
           "\t\t  is complete (depends on -bgpat)\n"
-          "    sec \tseconds to display each background image (default = 2)\n");
+          "    sec \tseconds to display each background image (default = 2)\n"
 #endif
-        fprintf(stderr, 
           "    dur \tduration in microseconds to wait after displaying each\n"
           "\t\t  row (for demo purposes)\n"
           "    -timing\tenables delay for every block read, to simulate modem\n"
           "\t\t  download of image (~36 Kbps)\n"
           "    -pause\tpauses after displaying each pass until mouse clicked\n"
           "\nPress Q, Esc or mouse button 1 (within image window, after image\n"
-          "is displayed) to quit.\n");
+          "is displayed) to quit.\n"
+          "\n", PROGNAME,
+          (int)strlen(PROGNAME), " ", default_display_exponent, num_bgpat-1);
         exit(1);
     }
 
+
     if (!(infile = fopen(filename, "rb"))) {
         fprintf(stderr, PROGNAME ":  can't open PNG file [%s]\n", filename);
         ++error;
@@ -758,8 +735,6 @@ int main(int argc, char **argv)
     Trace((stderr, "about to call rpng2_x_cleanup()\n"))
     rpng2_x_cleanup();
 
-    (void)argc; /* Unused */
-
     return 0;
 }
 
@@ -1851,9 +1826,6 @@ static void rpng2_x_redisplay_image(ulg startcol, ulg startrow,
         XFlush(display);
     }
 
-    (void)startcol;
-    (void)width;
-
 } /* end function rpng2_x_redisplay_image() */
 
 

contrib/gregbook/writepng.c

@@ -90,7 +90,7 @@ int writepng_init(mainprog_info *mainprog_ptr)
 
     /* could also replace libpng warning-handler (final NULL), but no need: */
 
-    png_ptr = png_create_write_struct(png_get_libpng_ver(NULL), mainprog_ptr,
+    png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, mainprog_ptr,
       writepng_error_handler, NULL);
     if (!png_ptr)
         return 4;   /* out of memory */

contrib/libtests/fakepng.c

@@ -52,6 +52,6 @@ main(void)
    fwrite(signature, sizeof signature, 1, stdout);
    put_chunk(IHDR, sizeof IHDR);
 
-   for (;;)
+   for(;;)
       put_chunk(unknown, sizeof unknown);
 }

contrib/libtests/pngunknown.c

@@ -1242,4 +1242,4 @@ main(void)
    /* So the test is skipped: */
    return 77;
 }
-#endif /* SET_UNKNOWN_CHUNKS && READ */
+#endif /* SET_UNKNOWN_CHUNKS && READ*/

contrib/pngminim/decoder/pngusr.h

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

contrib/pngminim/encoder/pngusr.h

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

contrib/pngminim/preader/pngusr.h

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

contrib/pngminus/makefile.std

@@ -8,9 +8,9 @@ LD=$(CC)
 RM=rm -f
 
 #PNGPATH = /usr/local
-#PNGINC = -I$(PNGPATH)/include/libpng16
-#PNGLIB = -L$(PNGPATH)/lib -lpng16
-#PNGLIBS = $(PNGPATH)/lib/libpng16.a
+#PNGINC = -I$(PNGPATH)/include/libpng17
+#PNGLIB = -L$(PNGPATH)/lib -lpng17
+#PNGLIBS = $(PNGPATH)/lib/libpng17.a
 PNGINC = -I../..
 PNGLIB = -L../.. -lpng
 PNGLIBS = ../../libpng.a
@@ -23,8 +23,7 @@ ZINC = -I../../../zlib
 ZLIB = -L../../../zlib -lz
 ZLIBS = ../../../zlib/libz.a
 
-CPPFLAGS=$(PNGINC) $(ZINC)
-CFLAGS=
+CFLAGS=$(PNGINC) $(ZINC)
 LDLIBS=$(PNGLIB) $(ZLIB)
 LDLIBSS=$(PNGLIBS) $(ZLIBS)
 C=.c
@@ -38,7 +37,7 @@ E=
 all: png2pnm$(E) pnm2png$(E) png2pnm-static$(E) pnm2png-static$(E)
 
 png2pnm$(O): png2pnm$(C)
-	$(CC) -c $(CPPFLAGS) $(CFLAGS) png2pnm$(C)
+	$(CC) -c $(CFLAGS) png2pnm$(C)
 
 png2pnm$(E): png2pnm$(O)
 	$(LD) $(LDFLAGS) -o png2pnm$(E) png2pnm$(O) $(LDLIBS) -lm
@@ -47,7 +46,7 @@ png2pnm-static$(E): png2pnm$(O)
 	$(LD) $(LDFLAGS) -o png2pnm-static$(E) png2pnm$(O) $(LDLIBSS) -lm
 
 pnm2png$(O): pnm2png$(C)
-	$(CC) -c $(CPPFLAGS) $(CFLAGS) pnm2png$(C)
+	$(CC) -c $(CFLAGS) pnm2png$(C)
 
 pnm2png$(E): pnm2png$(O)
 	$(LD) $(LDFLAGS) -o pnm2png$(E) pnm2png$(O) $(LDLIBS) -lm

contrib/pngminus/makefile.tc3

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

contrib/pngminus/png2pnm.c

@@ -52,8 +52,7 @@
 
 int  main (int argc, char *argv[]);
 void usage ();
-BOOL png2pnm (FILE *png_file, FILE *pnm_file, FILE *alpha_file, BOOL raw,
-   BOOL alpha);
+BOOL png2pnm (FILE *png_file, FILE *pnm_file, FILE *alpha_file, BOOL raw, BOOL alpha);
 
 /*
  *  main
@@ -86,8 +85,7 @@ int main(int argc, char *argv[])
           if ((fp_al = fopen (argv[argi], "wb")) == NULL)
           {
             fprintf (stderr, "PNM2PNG\n");
-            fprintf (stderr, "Error:  can not create alpha-channel file %s\n",
-               argv[argi]);
+            fprintf (stderr, "Error:  can not create alpha-channel file %s\n", argv[argi]);
             exit (1);
           }
           break;
@@ -178,11 +176,9 @@ void usage()
   fprintf (stderr, "Usage:  png2pnm [options] <file>.png [<file>.pnm]\n");
   fprintf (stderr, "   or:  ... | png2pnm [options]\n");
   fprintf (stderr, "Options:\n");
-  fprintf (stderr,
-     "   -r[aw]   write pnm-file in binary format (P4/P5/P6) (default)\n");
+  fprintf (stderr, "   -r[aw]   write pnm-file in binary format (P4/P5/P6) (default)\n");
   fprintf (stderr, "   -n[oraw] write pnm-file in ascii format (P1/P2/P3)\n");
-  fprintf (stderr,
-     "   -a[lpha] <file>.pgm write PNG alpha channel as pgm-file\n");
+  fprintf (stderr, "   -a[lpha] <file>.pgm write PNG alpha channel as pgm-file\n");
   fprintf (stderr, "   -h | -?  print this help-information\n");
 }
 
@@ -190,8 +186,7 @@ void usage()
  *  png2pnm
  */
 
-BOOL png2pnm (FILE *png_file, FILE *pnm_file, FILE *alpha_file,
-    volatile BOOL raw, BOOL alpha)
+BOOL png2pnm (FILE *png_file, FILE *pnm_file, FILE *alpha_file, BOOL raw, BOOL alpha)
 {
   png_struct    *png_ptr = NULL;
   png_info        *info_ptr = NULL;
@@ -223,7 +218,7 @@ BOOL png2pnm (FILE *png_file, FILE *pnm_file, FILE *alpha_file,
 
   /* create png and info structures */
 
-  png_ptr = png_create_read_struct (png_get_libpng_ver(NULL),
+  png_ptr = png_create_read_struct (PNG_LIBPNG_VER_STRING,
     NULL, NULL, NULL);
   if (!png_ptr)
     return FALSE;   /* out of memory */
@@ -320,14 +315,12 @@ BOOL png2pnm (FILE *png_file, FILE *pnm_file, FILE *alpha_file,
   /* row_bytes is the width x number of channels x (bit-depth / 8) */
   row_bytes = png_get_rowbytes (png_ptr, info_ptr);
 
-  if ((png_pixels = (png_byte *)
-     malloc (row_bytes * height * sizeof (png_byte))) == NULL) {
+  if ((png_pixels = (png_byte *) malloc (row_bytes * height * sizeof (png_byte))) == NULL) {
     png_destroy_read_struct (&png_ptr, &info_ptr, NULL);
     return FALSE;
   }
 
-  if ((row_pointers = (png_byte **)
-     malloc (height * sizeof (png_bytep))) == NULL)
+  if ((row_pointers = (png_byte **) malloc (height * sizeof (png_bytep))) == NULL)
   {
     png_destroy_read_struct (&png_ptr, &info_ptr, NULL);
     free (png_pixels);
@@ -336,7 +329,7 @@ BOOL png2pnm (FILE *png_file, FILE *pnm_file, FILE *alpha_file,
   }
 
   /* set the individual row_pointers to point at the correct offsets */
-  for (i = 0; i < ((int) height); i++)
+  for (i = 0; i < (height); i++)
     row_pointers[i] = png_pixels + i * row_bytes;
 
   /* now we can go ahead and just read the whole image */
@@ -379,9 +372,9 @@ BOOL png2pnm (FILE *png_file, FILE *pnm_file, FILE *alpha_file,
   /* write data to PNM file */
   pix_ptr = png_pixels;
 
-  for (row = 0; row < (int) height; row++)
+  for (row = 0; row < height; row++)
   {
-    for (col = 0; col < (int) width; col++)
+    for (col = 0; col < width; col++)
     {
       for (i = 0; i < (channels - alpha_present); i++)
       {

contrib/pngminus/pnm2png.c

@@ -50,8 +50,7 @@
 
 int  main (int argc, char *argv[]);
 void usage ();
-BOOL pnm2png (FILE *pnm_file, FILE *png_file, FILE *alpha_file, BOOL interlace,
-    BOOL alpha);
+BOOL pnm2png (FILE *pnm_file, FILE *png_file, FILE *alpha_file, BOOL interlace, BOOL alpha);
 void get_token(FILE *pnm_file, char *token);
 png_uint_32 get_data (FILE *pnm_file, int depth);
 png_uint_32 get_value (FILE *pnm_file, int depth);
@@ -177,8 +176,7 @@ void usage()
   fprintf (stderr, "   or:  ... | pnm2png [options]\n");
   fprintf (stderr, "Options:\n");
   fprintf (stderr, "   -i[nterlace]   write png-file with interlacing on\n");
-  fprintf (stderr,
-      "   -a[lpha] <file>.pgm read PNG alpha channel as pgm-file\n");
+  fprintf (stderr, "   -a[lpha] <file>.pgm read PNG alpha channel as pgm-file\n");
   fprintf (stderr, "   -h | -?  print this help-information\n");
 }
 
@@ -186,28 +184,27 @@ void usage()
  *  pnm2png
  */
 
-BOOL pnm2png (FILE *pnm_file, FILE *png_file, FILE *alpha_file, BOOL interlace,
-     BOOL alpha)
+BOOL pnm2png (FILE *pnm_file, FILE *png_file, FILE *alpha_file, BOOL interlace, BOOL alpha)
 {
   png_struct    *png_ptr = NULL;
   png_info      *info_ptr = NULL;
   png_byte      *png_pixels = NULL;
   png_byte      **row_pointers = NULL;
   png_byte      *pix_ptr = NULL;
-  volatile png_uint_32   row_bytes;
+  png_uint_32   row_bytes;
 
   char          type_token[16];
   char          width_token[16];
   char          height_token[16];
   char          maxval_token[16];
-  volatile int           color_type;
+  int           color_type;
   unsigned long   ul_width=0, ul_alpha_width=0;
   unsigned long   ul_height=0, ul_alpha_height=0;
   unsigned long   ul_maxval=0;
-  volatile png_uint_32   width, height;
-  volatile png_uint_32   alpha_width, alpha_height;
+  png_uint_32   width, alpha_width;
+  png_uint_32   height, alpha_height;
   png_uint_32   maxval;
-  volatile int           bit_depth = 0;
+  int           bit_depth = 0;
   int           channels;
   int           alpha_depth = 0;
   int           alpha_present;
@@ -370,24 +367,23 @@ BOOL pnm2png (FILE *pnm_file, FILE *png_file, FILE *alpha_file, BOOL interlace,
     /* row_bytes is the width x number of channels x (bit-depth / 8) */
     row_bytes = width * channels * ((bit_depth <= 8) ? 1 : 2);
 
-  if ((png_pixels = (png_byte *)
-     malloc (row_bytes * height * sizeof (png_byte))) == NULL)
+  if ((png_pixels = (png_byte *) malloc (row_bytes * height * sizeof (png_byte))) == NULL)
     return FALSE;
 
   /* read data from PNM file */
   pix_ptr = png_pixels;
 
-  for (row = 0; row < (int) height; row++)
+  for (row = 0; row < height; row++)
   {
 #if defined(PNG_WRITE_INVERT_SUPPORTED) || defined(PNG_WRITE_PACK_SUPPORTED)
     if (packed_bitmap) {
-      for (i = 0; i < (int) row_bytes; i++)
+      for (i = 0; i < row_bytes; i++)
         /* png supports this format natively so no conversion is needed */
         *pix_ptr++ = get_data (pnm_file, 8);
     } else
 #endif
     {
-      for (col = 0; col < (int) width; col++)
+      for (col = 0; col < width; col++)
       {
         for (i = 0; i < (channels - alpha_present); i++)
         {
@@ -425,8 +421,7 @@ BOOL pnm2png (FILE *pnm_file, FILE *png_file, FILE *alpha_file, BOOL interlace,
   } /* end for row */
 
   /* prepare the standard PNG structures */
-  png_ptr = png_create_write_struct (png_get_libpng_ver(NULL), NULL, NULL,
-      NULL);
+  png_ptr = png_create_write_struct (PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
   if (!png_ptr)
   {
     return FALSE;
@@ -467,8 +462,7 @@ BOOL pnm2png (FILE *pnm_file, FILE *png_file, FILE *alpha_file, BOOL interlace,
   /* if needed we will allocate memory for an new array of row-pointers */
   if (row_pointers == (unsigned char**) NULL)
   {
-    if ((row_pointers = (png_byte **)
-        malloc (height * sizeof (png_bytep))) == NULL)
+    if ((row_pointers = (png_byte **) malloc (height * sizeof (png_bytep))) == NULL)
     {
       png_destroy_write_struct (&png_ptr, (png_infopp) NULL);
       return FALSE;
@@ -476,13 +470,13 @@ BOOL pnm2png (FILE *pnm_file, FILE *png_file, FILE *alpha_file, BOOL interlace,
   }
 
   /* set the individual row_pointers to point at the correct offsets */
-  for (i = 0; i < (int) height; i++)
+  for (i = 0; i < (height); i++)
     row_pointers[i] = png_pixels + i * row_bytes;
 
   /* write out the entire image data in one call */
   png_write_image (png_ptr, row_pointers);
 
-  /* write the additional chunks to the PNG file (not really needed) */
+  /* write the additional chuncks to the PNG file (not really needed) */
   png_write_end (png_ptr, info_ptr);
 
   /* clean up after the write, and free any memory allocated */

contrib/tools/chunkhash.c

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

contrib/tools/chunkhash.h

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

contrib/tools/png-fix-itxt.c

@@ -37,7 +37,7 @@
 /* Read one character (inchar), also return octet (c), break if EOF */
 #define GETBREAK inchar=getchar(); \
                  c=(inchar & 0xffU);\
-                 if (inchar != c) break
+                 if (inchar != (int) c) break
 int
 main(void)
 {
@@ -54,7 +54,7 @@ main(void)
       putchar(c);
    }
 
-if (inchar == c) /* !EOF */
+if (inchar == (int) c) /* !EOF */
 for (;;)
  {
    /* Read the length */
@@ -86,7 +86,7 @@ for (;;)
          GETBREAK; buf[i] = c;
       }
 
-      if (inchar != c) /* EOF */
+      if (inchar != (int) c) /* EOF */
          break;
 
       /* Calculate the CRC */
@@ -113,7 +113,7 @@ for (;;)
         crc = crc32(crc, buf+7+length, 1);
       }
 
-      if (inchar != c) /* EOF */
+      if (inchar != (int) c) /* EOF */
          break;
 
       /* Update length bytes */
@@ -129,7 +129,7 @@ for (;;)
 
    else
    {
-      if (inchar != c) /* EOF */
+      if (inchar != (int) c) /* EOF */
          break;
 
       /* Copy bytes that were already read (length and chunk name) */
@@ -143,7 +143,7 @@ for (;;)
          putchar(c);
       }
 
-      if (inchar != c) /* EOF */
+      if (inchar != (int) c) /* EOF */
       {
          break;
       }
@@ -153,7 +153,7 @@ for (;;)
          break;
    }
 
-   if (inchar != c) /* EOF */
+   if (inchar != (int) c) /* EOF */
       break;
 
    if (buf[4] == 73 && buf[5] == 69 && buf[6] == 78 && buf[7] == 68)

contrib/tools/scale.c

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

contrib/visupng/PngFile.c

@@ -136,7 +136,7 @@ BOOL PngLoadImage (PTSTR pstrFileName, png_byte **ppbImageData,
 
     /* create the two png(-info) structures */
 
-    png_ptr = png_create_read_struct(png_get_libpng_ver(NULL), NULL,
+    png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL,
       (png_error_ptr)png_cexcept_error, (png_error_ptr)NULL);
     if (!png_ptr)
     {
@@ -313,7 +313,7 @@ BOOL PngSaveImage (PTSTR pstrFileName, png_byte *pDiData,
 
     /* prepare the standard PNG structures */
 
-    png_ptr = png_create_write_struct(png_get_libpng_ver(NULL), NULL,
+    png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL,
       (png_error_ptr)png_cexcept_error, (png_error_ptr)NULL);
     if (!png_ptr)
     {

example.c

@@ -2,8 +2,8 @@
 #if 0 /* in case someone actually tries to compile this */
 
 /* example.c - an example of using libpng
- * Last changed in libpng 1.6.15 [November 20, 2014]
- * Maintained 1998-2014 Glenn Randers-Pehrson
+ * Last changed in libpng 1.7.0 [(PENDING RELEASE)]
+ * Maintained 1998-2015 Glenn Randers-Pehrson
  * Maintained 1996, 1997 Andreas Dilger)
  * Written 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
  * To the extent possible under law, the authors have waived
@@ -39,7 +39,7 @@
 #include <string.h>
 #include <stdio.h>
 #include <png.h>
-#include <zlib.h>
+#include PNG_ZLIB_HEADER /* this is the header libpng was built with */
 
 int main(int argc, const char **argv)
 {

libpng-manual.txt

@@ -1,6 +1,6 @@
 libpng-manual.txt - A description on how to use and modify libpng
 
- libpng version 1.6.18rc02 - July 12, 2015
+ libpng version 1.7.0beta64 - July 26, 2015
  Updated and distributed by Glenn Randers-Pehrson
  <glennrp at users.sourceforge.net>
  Copyright (c) 1998-2015 Glenn Randers-Pehrson
@@ -11,15 +11,15 @@ libpng-manual.txt - A description on how to use and modify libpng
 
  Based on:
 
- libpng versions 0.97, January 1998, through 1.6.18rc02 - July 12, 2015
+ libpng versions 0.97, January 1998, through 1.7.0beta64 - July 26, 2015
  Updated and distributed by Glenn Randers-Pehrson
  Copyright (c) 1998-2015 Glenn Randers-Pehrson
 
- libpng 1.0 beta 6 - version 0.96 - May 28, 1997
+ libpng 1.0 beta 6  version 0.96 May 28, 1997
  Updated and distributed by Andreas Dilger
  Copyright (c) 1996, 1997 Andreas Dilger
 
- libpng 1.0 beta 2 - version 0.88 - January 26, 1996
+ libpng 1.0 beta 2 - version 0.88  January 26, 1996
  For conditions of distribution and use, see copyright
  notice in png.h. Copyright (c) 1995, 1996 Guy Eric
  Schalnat, Group 42, Inc.
@@ -42,10 +42,11 @@ libpng-manual.txt - A description on how to use and modify libpng
     X. Changes to Libpng from version 1.0.x/1.2.x to 1.4.x
    XI. Changes to Libpng from version 1.4.x to 1.5.x
   XII. Changes to Libpng from version 1.5.x to 1.6.x
- XIII. Detecting libpng
-  XIV. Source code repository
-   XV. Coding style
-  XVI. Y2K Compliance in libpng
+ XIII. Changes to Libpng from version 1.6.x to 1.7.x
+  XIV. Detecting libpng
+   XV. Source code repository
+  XVI. Coding style
+ XVII. Y2K Compliance in libpng
 
 I. Introduction
 
@@ -344,23 +345,22 @@ then only check the bytes (if any) that your program didn't read.
 to replace them with custom functions.  See the discussion under
 Customizing libpng.
 
+
     FILE *fp = fopen(file_name, "rb");
     if (!fp)
     {
        return (ERROR);
     }
 
-    if (fread(header, 1, number, fp) != number)
-    {
-       return (ERROR);
-    }
-
+    fread(header, 1, number, fp);
     is_png = !png_sig_cmp(header, 0, number);
+
     if (!is_png)
     {
        return (NOT_PNG);
     }
 
+
 Next, png_struct and png_info need to be allocated and initialized.  In
 order to ensure that the size of these structures is correct even with a
 dynamically linked libpng, there are functions to initialize and
@@ -428,12 +428,16 @@ an end_info structure.
 
 If you would rather avoid the complexity of setjmp/longjmp issues,
 you can compile libpng with PNG_NO_SETJMP, in which case
-errors will result in a call to PNG_ABORT() which defaults to abort().
+errors will result in a call to PNG_ABORT which defaults to abort().
 
-You can #define PNG_ABORT() to a function that does something
+You can #define PNG_ABORT to a function or other C code that does something
 more useful than abort(), as long as your function does not
 return.
 
+If you do this, you cannot #define PNG_SIMPLIFIED_READ_SUPPORTED or
+PNG_SIMPLIFIED_WRITE_SUPPORTED, because the simplified API requires
+setjmp() support.
+
 Now you need to set up the input code.  The default for libpng is to
 use the C function fread().  If you use this, you will need to pass a
 valid FILE * in the function png_init_io().  Be sure that the file is
@@ -525,15 +529,15 @@ you can retrieve with
 
     png_get_user_chunk_ptr(png_ptr);
 
-If you call the png_set_read_user_chunk_fn() function, then all unknown
-chunks which the callback does not handle will be saved when read.  You can
-cause them to be discarded by returning '1' ("handled") instead of '0'.  This
-behavior will change in libpng 1.7 and the default handling set by the
-png_set_keep_unknown_chunks() function, described below, will be used when the
-callback returns 0.  If you want the existing behavior you should set the global
-default to PNG_HANDLE_CHUNK_IF_SAFE now; this is compatible with all current
-versions of libpng and with 1.7.  Libpng 1.6 issues a warning if you keep the
-default, or PNG_HANDLE_CHUNK_NEVER, and the callback returns 0.
+If you call the png_set_read_user_chunk_fn() function, then all unknown chunks
+will be passed to your callback when read.  You can cause known chunks to be
+passed in as well by using png_set_keep_unknown_chunks (see below) - this will
+prevent the normal libpng handling of those known chunks.
+
+If your callback returns 0 the default unknown handling will be used (see
+below).  This is new behavior in libpng 1.7, prior to 1.7 it was not possible to
+discard a chunk; PNG_HANDLE_CHUNK_IF_SAFE was forced.  Libpng 1.6.0 issues a
+warning when this was done.
 
 At this point, you can set up a callback function that will be
 called after each row has been read, which you can use to control
@@ -632,10 +636,8 @@ callback function:
     ...
 
     #if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED)
-      /* ignore all unknown chunks
-       * (use global setting "2" for libpng16 and earlier):
-       */
-      png_set_keep_unknown_chunks(read_ptr, 2, NULL, 0);
+      /* ignore all unknown chunks: */
+      png_set_keep_unknown_chunks(read_ptr, 1, NULL, 0);
 
       /* except for vpAg: */
       png_set_keep_unknown_chunks(read_ptr, 2, vpAg, 1);
@@ -649,12 +651,15 @@ User limits
 
 The PNG specification allows the width and height of an image to be as
 large as 2^31-1 (0x7fffffff), or about 2.147 billion rows and columns.
+Since very few applications really need to process such large images,
+we have imposed an arbitrary 1,000,000 limit on rows and columns.
 Larger images will be rejected immediately with a png_error() call. If
-you wish to change these limits, you can use
+you wish to change this limit, you can use
 
    png_set_user_limits(png_ptr, width_max, height_max);
 
-to set your own limits (libpng may reject some very wide images
+to set your own limits, or use width_max = height_max = 0x7fffffffL
+to allow all valid dimensions (libpng may reject some very large images
 anyway because of potential buffer overflow conditions).
 
 You should put this statement after you create the PNG structure and
@@ -1180,7 +1185,10 @@ row_pointers prior to calling png_read_png() with
    png_set_rows(png_ptr, info_ptr, &row_pointers);
 
 Alternatively you could allocate your image in one big block and define
-row_pointers[i] to point into the proper places in your block.
+row_pointers[i] to point into the proper places in your block.  If
+you do this, be sure to call png_read_update_info() described below,
+to update the "rowbytes" value to account for any transformations that
+change the number of bytes per row before you use it to allocate your block.
 
 If you use png_set_rows(), the application is responsible for freeing
 row_pointers (and row_pointers[i], if they were separately allocated).
@@ -1269,12 +1277,13 @@ in until png_read_end() has read the chunk data following the image.
     interlace_type, compression_type, or filter_method can
     be NULL if you are not interested in their values.
 
-    Note that png_get_IHDR() returns 32-bit data into
+    Note that png_get_IHDR() returns png_uint_32 data into
     the application's width and height variables.
     This is an unsafe situation if these are not png_uint_32
-    variables.  In such situations, the
-    png_get_image_width() and png_get_image_height()
-    functions described below are safer.
+    variables, or if they are 32-bit variables on a 64-bit
+    platform.  In such situations, the png_get_image_width()
+    and png_get_image_height() functions described below are
+    safer.
 
     width            = png_get_image_width(png_ptr,
                          info_ptr);
@@ -2737,11 +2746,10 @@ section below for more information on the libpng error handling.
 
 If you would rather avoid the complexity of setjmp/longjmp issues,
 you can compile libpng with PNG_NO_SETJMP, in which case
-errors will result in a call to PNG_ABORT() which defaults to abort().
+errors will result in a call to PNG_ABORT which defaults to abort().
 
-You can #define PNG_ABORT() to a function that does something
-more useful than abort(), as long as your function does not
-return.
+You can #define PNG_ABORT to a function or other C code that does something
+more useful than abort(), as long as your function does not return.
 
 Checking for invalid palette index on write was added at libpng
 1.5.10.  If a pixel contains an invalid (out-of-range) index libpng issues
@@ -3259,7 +3267,7 @@ tEXt chunk use RFC 1123 format dates (e.g. "22 May 1997 18:07:10 GMT"),
 although this isn't a requirement.  Unlike the tIME chunk, the
 "Creation Time" tEXt chunk is not expected to be automatically changed
 by the software.  To facilitate the use of RFC 1123 dates, a function
-png_convert_to_rfc1123_buffer(buffer, png_timep) is provided to
+png_convert_to_rfc1123_buffer(png_ptr, buffer, png_timep) is provided to
 convert from PNG time to an RFC 1123 format string.  The caller must provide
 a writeable buffer of at least 29 bytes.
 
@@ -3748,12 +3756,12 @@ png_image is a structure that describes the in-memory format of an image
 when it is being read or define the in-memory format of an image that you
 need to write.  The "png_image" structure contains the following members:
 
+   png_controlp opaque  Initialize to NULL, free with png_image_free
    png_uint_32  version Set to PNG_IMAGE_VERSION
    png_uint_32  width   Image width in pixels (columns)
    png_uint_32  height  Image height in pixels (rows)
    png_uint_32  format  Image format as defined below
    png_uint_32  flags   A bit mask containing informational flags
-   png_controlp opaque  Initialize to NULL, free with png_image_free
    png_uint_32  colormap_entries; Number of entries in the color-map
    png_uint_32  warning_or_error;
    char         message[64];
@@ -4065,11 +4073,10 @@ a 16-bit linear encoded PNG file is written.
 
 With all APIs row_stride is handled as in the read APIs - it is the spacing
 from one row to the next in component sized units (float) and if negative
-indicates a bottom-up row layout in the buffer.  If you pass zero, libpng will
-calculate the row_stride for you from the width and number of channels.
+indicates a bottom-up row layout in the buffer.
 
 Note that the write API does not support interlacing, sub-8-bit pixels,
-indexed (paletted) images, or most ancillary chunks.
+and indexed (paletted) images.
 
 VI. Modifying/Customizing libpng
 
@@ -4160,7 +4167,7 @@ Error handling in libpng is done through png_error() and png_warning().
 Errors handled through png_error() are fatal, meaning that png_error()
 should never return to its caller.  Currently, this is handled via
 setjmp() and longjmp() (unless you have compiled libpng with
-PNG_NO_SETJMP, in which case it is handled via PNG_ABORT()),
+PNG_NO_SETJMP, in which case it is handled via PNG_ABORT),
 but you could change this to do things like exit() if you should wish,
 as long as your function does not return.
 
@@ -4357,41 +4364,6 @@ is called for the first time.)
               same as the value of filter_method used
               in png_set_IHDR().
 
-It is also possible to influence how libpng chooses from among the
-available filters.  This is done in one or both of two ways - by
-telling it how important it is to keep the same filter for successive
-rows, and by telling it the relative computational costs of the filters.
-
-    double weights[3] = {1.5, 1.3, 1.1},
-       costs[PNG_FILTER_VALUE_LAST] =
-       {1.0, 1.3, 1.3, 1.5, 1.7};
-
-    png_set_filter_heuristics(png_ptr,
-       PNG_FILTER_HEURISTIC_WEIGHTED, 3,
-       weights, costs);
-
-The weights are multiplying factors that indicate to libpng that the
-row filter should be the same for successive rows unless another row filter
-is that many times better than the previous filter.  In the above example,
-if the previous 3 filters were SUB, SUB, NONE, the SUB filter could have a
-"sum of absolute differences" 1.5 x 1.3 times higher than other filters
-and still be chosen, while the NONE filter could have a sum 1.1 times
-higher than other filters and still be chosen.  Unspecified weights are
-taken to be 1.0, and the specified weights should probably be declining
-like those above in order to emphasize recent filters over older filters.
-
-The filter costs specify for each filter type a relative decoding cost
-to be considered when selecting row filters.  This means that filters
-with higher costs are less likely to be chosen over filters with lower
-costs, unless their "sum of absolute differences" is that much smaller.
-The costs do not necessarily reflect the exact computational speeds of
-the various filters, since this would unduly influence the final image
-size.
-
-Note that the numbers above were invented purely for this example and
-are given only to help explain the function usage.  Little testing has
-been done to find optimum values for either the costs or the weights.
-
 Requesting debug printout
 
 The macro definition PNG_DEBUG can be used to request debugging
@@ -5127,7 +5099,54 @@ It can be set for testing debug or beta builds to ensure that they will compile
 when the build type is switched to RC or STABLE. In essence this overrides the
 PNG_LIBPNG_BUILD_BASE_TYPE definition which is not directly user controllable.
 
-XIII.  Detecting libpng
+XIII.  Changes to Libpng from version 1.6.x to 1.7.x
+
+Some functions that were deprecated in libpng-1.6.0 were removed:
+    png_reset_zstream(),
+    png_info_init_3(),
+    png_data_freer() and its associated flags,
+    png_malloc_default(),
+    and png_free_default().
+
+These apparently unused experimental functions have been deprecated
+and the code within them, except for the APIs, has been removed.
+    png_set_filter_heuristics()
+    and png_set_filter_heuristics_fixed()
+
+The PNG_ABORT() macro was changed to PNG_ABORT, and the default is now
+"abort()" for all platforms (previously it was "ExitProcess(0)" on
+Windows platforms).  Starting with libpng-1.7.0 you have to define
+PNG_ABORT instead of PNG_ABORT(), and you must include a terminating
+semicolon in your definition, e.g.,
+
+    #if PNGCRUSH_LIBPNG_VER >= 10700
+    #  ifdef _WINDOWS_
+    #    define PNG_ABORT ExitProcess(0);
+    #  else
+    #    define PNG_ABORT abort();
+    #  endif
+    #else
+    #  ifdef _WINDOWS_
+    #    define PNG_ABORT() ExitProcess(0)
+    #  else
+    #    define PNG_ABORT() abort()
+    #  endif
+    #endif
+
+The png_get_IHDR() function now allows users to supply NULL for any
+argument in which they aren't interested.  Previously, the width, height,
+bit_depth, and color_type arguments were not allowed to be NULL.
+
+The 8-bit compose and rgb_to_grayscale operations were made more accurate.
+While these did not introduce API incompatibility, there may be differences
+in unit test results.
+
+Internal "affirm()" and "impossible()" macros were added, along with
+some internal supporting macros and functions. These are similar to the
+ANSI-C "assert()" macro but they are not affected by NDEBUG, and they are
+private (not visible to nor usable by libpng applications).
+
+XIV.  Detecting libpng
 
 The png_get_io_ptr() function has been present since libpng-0.88, has never
 changed, and is unaffected by conditional compilation macros.  It is the
@@ -5160,7 +5179,7 @@ simple verbal discriptions of bug fixes, reported either to the
 SourceForge bug tracker, to the png-mng-implement at lists.sf.net
 mailing list, or directly to glennrp.
 
-XV. Coding style
+XVI. Coding style
 
 Our coding style is similar to the "Allman" style
 (See http://en.wikipedia.org/wiki/Indent_style#Allman_style), with curly
@@ -5295,15 +5314,15 @@ Lines do not exceed 80 characters.
 
 Other rules can be inferred by inspecting the libpng source.
 
-XVI. Y2K Compliance in libpng
+XVII. Y2K Compliance in libpng
 
-July 12, 2015
+July 26, 2015
 
 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.6.18rc02 are Y2K compliant.  It is my belief that earlier
+upward through 1.7.0beta64 are Y2K compliant.  It is my belief that earlier
 versions were also Y2K compliant.
 
 Libpng only has two year fields.  One is a 2-byte unsigned integer
@@ -5319,9 +5338,8 @@ in libpng-1.6.x and will be removed from libpng-1.7.0.
 
 There are seven time-related functions:
 
-    png_convert_to_rfc_1123_buffer() in png.c
-      (formerly png_convert_to_rfc_1152() in error, and
-      also formerly png_convert_to_rfc_1123())
+    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

libpng.3

@@ -1,6 +1,6 @@
-.TH LIBPNG 3 "July 12, 2015"
+.TH LIBPNG 3 "July 26, 2015"
 .SH NAME
-libpng \- Portable Network Graphics (PNG) Reference Library 1.6.18rc02
+libpng \- Portable Network Graphics (PNG) Reference Library 1.7.0beta64
 .SH SYNOPSIS
 \fB
 #include <png.h>\fP
@@ -23,7 +23,7 @@ libpng \- Portable Network Graphics (PNG) Reference Library 1.6.18rc02
 
 \fBvoid png_convert_from_time_t (png_timep \fP\fIptime\fP\fB, time_t \fIttime\fP\fB);\fP
 
-\fBpng_charp png_convert_to_rfc1123 (png_structp \fP\fIpng_ptr\fP\fB, png_timep \fIptime\fP\fB);\fP
+\fBpng_charp png_convert_to_rfc1123_buffer (png_structp \fP\fIpng_ptr\fP\fB, char \fP\fIout[29]\fP\fB, png_timep \fIptime\fP\fB);\fP
 
 \fBpng_infop png_create_info_struct (png_structp \fIpng_ptr\fP\fB);\fP
 
@@ -35,8 +35,6 @@ libpng \- Portable Network Graphics (PNG) Reference Library 1.6.18rc02
 
 \fBpng_structp png_create_write_struct_2 (png_const_charp \fP\fIuser_png_ver\fP\fB, png_voidp \fP\fIerror_ptr\fP\fB, png_error_ptr \fP\fIerror_fn\fP\fB, png_error_ptr \fP\fIwarn_fn\fP\fB, png_voidp \fP\fImem_ptr\fP\fB, png_malloc_ptr \fP\fImalloc_fn\fP\fB, png_free_ptr \fIfree_fn\fP\fB);\fP
 
-\fBvoid png_data_freer (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, int \fP\fIfreer\fP\fB, png_uint_32 \fImask)\fP\fB);\fP
-
 \fBvoid png_destroy_info_struct (png_structp \fP\fIpng_ptr\fP\fB, png_infopp \fIinfo_ptr_ptr\fP\fB);\fP
 
 \fBvoid png_destroy_read_struct (png_structpp \fP\fIpng_ptr_ptr\fP\fB, png_infopp \fP\fIinfo_ptr_ptr\fP\fB, png_infopp \fIend_info_ptr_ptr\fP\fB);\fP
@@ -51,8 +49,6 @@ libpng \- Portable Network Graphics (PNG) Reference Library 1.6.18rc02
 
 \fBvoid png_free_chunk_list (png_structp \fIpng_ptr\fP\fB);\fP
 
-\fBvoid png_free_default (png_structp \fP\fIpng_ptr\fP\fB, png_voidp \fIptr\fP\fB);\fP
-
 \fBvoid png_free_data (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, int \fInum\fP\fB);\fP
 
 \fBpng_byte png_get_bit_depth (png_const_structp \fP\fIpng_ptr\fP\fB, png_const_infop \fIinfo_ptr\fP\fB);\fP
@@ -119,6 +115,8 @@ libpng \- Portable Network Graphics (PNG) Reference Library 1.6.18rc02
 
 \fBpng_byte png_get_libpng_ver (png_const_structp \fIpng_ptr\fP\fB);\fP
 
+\fBint png_get_palette_max(png_const_structp \fP\fIpng_ptr\fP\fB, png_const_infop \fIinfo_ptr\fP\fB);\fP
+
 \fBpng_voidp png_get_mem_ptr (png_const_structp \fIpng_ptr\fP\fB);\fP
 
 \fBpng_uint_32 png_get_oFFs (png_const_structp \fP\fIpng_ptr\fP\fB, png_const_infop \fP\fIinfo_ptr\fP\fB, png_uint_32 \fP\fI*offset_x\fP\fB, png_uint_32 \fP\fI*offset_y\fP\fB, int \fI*unit_type\fP\fB);\fP
@@ -229,16 +227,12 @@ libpng \- Portable Network Graphics (PNG) Reference Library 1.6.18rc02
 
 \fBint png_image_write_to_stdio (png_imagep \fP\fIimage\fP\fB, FILE \fP\fI*file\fP\fB, int \fP\fIconvert_to_8_bit\fP\fB, const void \fP\fI*buffer\fP\fB, png_int_32 \fP\fIrow_stride\fP\fB, void \fI*colormap)\fP\fB);\fP
 
-\fBvoid png_info_init_3 (png_infopp \fP\fIinfo_ptr\fP\fB, png_size_t \fIpng_info_struct_size\fP\fB);\fP
-
 \fBvoid png_init_io (png_structp \fP\fIpng_ptr\fP\fB, FILE \fI*fp\fP\fB);\fP
 
 \fBvoid png_longjmp (png_structp \fP\fIpng_ptr\fP\fB, int \fIval\fP\fB);\fP
 
 \fBpng_voidp png_malloc (png_structp \fP\fIpng_ptr\fP\fB, png_alloc_size_t \fIsize\fP\fB);\fP
 
-\fBpng_voidp png_malloc_default (png_structp \fP\fIpng_ptr\fP\fB, png_alloc_size_t \fIsize\fP\fB);\fP
-
 \fBpng_voidp png_malloc_warn (png_structp \fP\fIpng_ptr\fP\fB, png_alloc_size_t \fIsize\fP\fB);\fP
 
 \fBpng_uint_32 png_permit_mng_features (png_structp \fP\fIpng_ptr\fP\fB, png_uint_32 \fImng_features_permitted\fP\fB);\fP
@@ -265,8 +259,6 @@ libpng \- Portable Network Graphics (PNG) Reference Library 1.6.18rc02
 
 \fBvoid png_read_update_info (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fIinfo_ptr\fP\fB);\fP
 
-\fBint png_reset_zstream (png_structp \fIpng_ptr\fP\fB);\fP
-
 \fBvoid png_save_int_32 (png_bytep \fP\fIbuf\fP\fB, png_int_32 \fIi\fP\fB);\fP
 
 \fBvoid png_save_uint_16 (png_bytep \fP\fIbuf\fP\fB, unsigned int \fIi\fP\fB);\fP
@@ -369,6 +361,8 @@ libpng \- Portable Network Graphics (PNG) Reference Library 1.6.18rc02
 
 \fBvoid png_set_oFFs (png_structp \fP\fIpng_ptr\fP\fB, png_infop \fP\fIinfo_ptr\fP\fB, png_uint_32 \fP\fIoffset_x\fP\fB, png_uint_32 \fP\fIoffset_y\fP\fB, int \fIunit_type\fP\fB);\fP
 
+\fBint png_set_option(png_structrp \fP\fIpng_ptr\fP\fB, int \fP\fIoption\fP\fB, int \fIonoff\fP\fB);\fP
+
 \fBvoid png_set_packing (png_structp \fIpng_ptr\fP\fB);\fP
 
 \fBvoid png_set_packswap (png_structp \fIpng_ptr\fP\fB);\fP
@@ -504,7 +498,7 @@ Following is a copy of the libpng-manual.txt file that accompanies libpng.
 .SH LIBPNG.TXT
 libpng-manual.txt - A description on how to use and modify libpng
 
- libpng version 1.6.18rc02 - July 12, 2015
+ libpng version 1.7.0beta64 - July 26, 2015
  Updated and distributed by Glenn Randers-Pehrson
  <glennrp at users.sourceforge.net>
  Copyright (c) 1998-2015 Glenn Randers-Pehrson
@@ -515,15 +509,15 @@ libpng-manual.txt - A description on how to use and modify libpng
 
  Based on:
 
- libpng versions 0.97, January 1998, through 1.6.18rc02 - July 12, 2015
+ libpng versions 0.97, January 1998, through 1.7.0beta64 - July 26, 2015
  Updated and distributed by Glenn Randers-Pehrson
  Copyright (c) 1998-2015 Glenn Randers-Pehrson
 
- libpng 1.0 beta 6 - version 0.96 - May 28, 1997
+ libpng 1.0 beta 6  version 0.96 May 28, 1997
  Updated and distributed by Andreas Dilger
  Copyright (c) 1996, 1997 Andreas Dilger
 
- libpng 1.0 beta 2 - version 0.88 - January 26, 1996
+ libpng 1.0 beta 2 - version 0.88  January 26, 1996
  For conditions of distribution and use, see copyright
  notice in png.h. Copyright (c) 1995, 1996 Guy Eric
  Schalnat, Group 42, Inc.
@@ -546,10 +540,11 @@ libpng-manual.txt - A description on how to use and modify libpng
     X. Changes to Libpng from version 1.0.x/1.2.x to 1.4.x
    XI. Changes to Libpng from version 1.4.x to 1.5.x
   XII. Changes to Libpng from version 1.5.x to 1.6.x
- XIII. Detecting libpng
-  XIV. Source code repository
-   XV. Coding style
-  XVI. Y2K Compliance in libpng
+ XIII. Changes to Libpng from version 1.6.x to 1.7.x
+  XIV. Detecting libpng
+   XV. Source code repository
+  XVI. Coding style
+ XVII. Y2K Compliance in libpng
 
 .SH I. Introduction
 
@@ -848,23 +843,22 @@ then only check the bytes (if any) that your program didn't read.
 to replace them with custom functions.  See the discussion under
 Customizing libpng.
 
+
     FILE *fp = fopen(file_name, "rb");
     if (!fp)
     {
        return (ERROR);
     }
 
-    if (fread(header, 1, number, fp) != number)
-    {
-       return (ERROR);
-    }
-
+    fread(header, 1, number, fp);
     is_png = !png_sig_cmp(header, 0, number);
+
     if (!is_png)
     {
        return (NOT_PNG);
     }
 
+
 Next, png_struct and png_info need to be allocated and initialized.  In
 order to ensure that the size of these structures is correct even with a
 dynamically linked libpng, there are functions to initialize and
@@ -932,12 +926,16 @@ an end_info structure.
 
 If you would rather avoid the complexity of setjmp/longjmp issues,
 you can compile libpng with PNG_NO_SETJMP, in which case
-errors will result in a call to PNG_ABORT() which defaults to abort().
+errors will result in a call to PNG_ABORT which defaults to abort().
 
-You can #define PNG_ABORT() to a function that does something
+You can #define PNG_ABORT to a function or other C code that does something
 more useful than abort(), as long as your function does not
 return.
 
+If you do this, you cannot #define PNG_SIMPLIFIED_READ_SUPPORTED or
+PNG_SIMPLIFIED_WRITE_SUPPORTED, because the simplified API requires
+setjmp() support.
+
 Now you need to set up the input code.  The default for libpng is to
 use the C function fread().  If you use this, you will need to pass a
 valid FILE * in the function png_init_io().  Be sure that the file is
@@ -1029,15 +1027,15 @@ you can retrieve with
 
     png_get_user_chunk_ptr(png_ptr);
 
-If you call the png_set_read_user_chunk_fn() function, then all unknown
-chunks which the callback does not handle will be saved when read.  You can
-cause them to be discarded by returning '1' ("handled") instead of '0'.  This
-behavior will change in libpng 1.7 and the default handling set by the
-png_set_keep_unknown_chunks() function, described below, will be used when the
-callback returns 0.  If you want the existing behavior you should set the global
-default to PNG_HANDLE_CHUNK_IF_SAFE now; this is compatible with all current
-versions of libpng and with 1.7.  Libpng 1.6 issues a warning if you keep the
-default, or PNG_HANDLE_CHUNK_NEVER, and the callback returns 0.
+If you call the png_set_read_user_chunk_fn() function, then all unknown chunks
+will be passed to your callback when read.  You can cause known chunks to be
+passed in as well by using png_set_keep_unknown_chunks (see below) - this will
+prevent the normal libpng handling of those known chunks.
+
+If your callback returns 0 the default unknown handling will be used (see
+below).  This is new behavior in libpng 1.7, prior to 1.7 it was not possible to
+discard a chunk; PNG_HANDLE_CHUNK_IF_SAFE was forced.  Libpng 1.6.0 issues a
+warning when this was done.
 
 At this point, you can set up a callback function that will be
 called after each row has been read, which you can use to control
@@ -1136,10 +1134,8 @@ callback function:
     ...
 
     #if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED)
-      /* ignore all unknown chunks
-       * (use global setting "2" for libpng16 and earlier):
-       */
-      png_set_keep_unknown_chunks(read_ptr, 2, NULL, 0);
+      /* ignore all unknown chunks: */
+      png_set_keep_unknown_chunks(read_ptr, 1, NULL, 0);
 
       /* except for vpAg: */
       png_set_keep_unknown_chunks(read_ptr, 2, vpAg, 1);
@@ -1153,12 +1149,15 @@ callback function:
 
 The PNG specification allows the width and height of an image to be as
 large as 2^(31\-1 (0x7fffffff), or about 2.147 billion rows and columns.
+Since very few applications really need to process such large images,
+we have imposed an arbitrary 1,000,000 limit on rows and columns.
 Larger images will be rejected immediately with a png_error() call. If
-you wish to change these limits, you can use
+you wish to change this limit, you can use
 
    png_set_user_limits(png_ptr, width_max, height_max);
 
-to set your own limits (libpng may reject some very wide images
+to set your own limits, or use width_max = height_max = 0x7fffffffL
+to allow all valid dimensions (libpng may reject some very large images
 anyway because of potential buffer overflow conditions).
 
 You should put this statement after you create the PNG structure and
@@ -1684,7 +1683,10 @@ row_pointers prior to calling png_read_png() with
    png_set_rows(png_ptr, info_ptr, &row_pointers);
 
 Alternatively you could allocate your image in one big block and define
-row_pointers[i] to point into the proper places in your block.
+row_pointers[i] to point into the proper places in your block.  If
+you do this, be sure to call png_read_update_info() described below,
+to update the "rowbytes" value to account for any transformations that
+change the number of bytes per row before you use it to allocate your block.
 
 If you use png_set_rows(), the application is responsible for freeing
 row_pointers (and row_pointers[i], if they were separately allocated).
@@ -1773,12 +1775,13 @@ in until png_read_end() has read the chunk data following the image.
     interlace_type, compression_type, or filter_method can
     be NULL if you are not interested in their values.
 
-    Note that png_get_IHDR() returns 32-bit data into
+    Note that png_get_IHDR() returns png_uint_32 data into
     the application's width and height variables.
     This is an unsafe situation if these are not png_uint_32
-    variables.  In such situations, the
-    png_get_image_width() and png_get_image_height()
-    functions described below are safer.
+    variables, or if they are 32-bit variables on a 64-bit
+    platform.  In such situations, the png_get_image_width()
+    and png_get_image_height() functions described below are
+    safer.
 
     width            = png_get_image_width(png_ptr,
                          info_ptr);
@@ -3241,11 +3244,10 @@ section below for more information on the libpng error handling.
 
 If you would rather avoid the complexity of setjmp/longjmp issues,
 you can compile libpng with PNG_NO_SETJMP, in which case
-errors will result in a call to PNG_ABORT() which defaults to abort().
+errors will result in a call to PNG_ABORT which defaults to abort().
 
-You can #define PNG_ABORT() to a function that does something
-more useful than abort(), as long as your function does not
-return.
+You can #define PNG_ABORT to a function or other C code that does something
+more useful than abort(), as long as your function does not return.
 
 Checking for invalid palette index on write was added at libpng
 1.5.10.  If a pixel contains an invalid (out-of-range) index libpng issues
@@ -3763,7 +3765,7 @@ tEXt chunk use RFC 1123 format dates (e.g. "22 May 1997 18:07:10 GMT"),
 although this isn't a requirement.  Unlike the tIME chunk, the
 "Creation Time" tEXt chunk is not expected to be automatically changed
 by the software.  To facilitate the use of RFC 1123 dates, a function
-png_convert_to_rfc1123_buffer(buffer, png_timep) is provided to
+png_convert_to_rfc1123_buffer(png_ptr, buffer, png_timep) is provided to
 convert from PNG time to an RFC 1123 format string.  The caller must provide
 a writeable buffer of at least 29 bytes.
 
@@ -4252,12 +4254,12 @@ png_image is a structure that describes the in-memory format of an image
 when it is being read or define the in-memory format of an image that you
 need to write.  The "png_image" structure contains the following members:
 
+   png_controlp opaque  Initialize to NULL, free with png_image_free
    png_uint_32  version Set to PNG_IMAGE_VERSION
    png_uint_32  width   Image width in pixels (columns)
    png_uint_32  height  Image height in pixels (rows)
    png_uint_32  format  Image format as defined below
    png_uint_32  flags   A bit mask containing informational flags
-   png_controlp opaque  Initialize to NULL, free with png_image_free
    png_uint_32  colormap_entries; Number of entries in the color-map
    png_uint_32  warning_or_error;
    char         message[64];
@@ -4569,11 +4571,10 @@ a 16-bit linear encoded PNG file is written.
 
 With all APIs row_stride is handled as in the read APIs - it is the spacing
 from one row to the next in component sized units (float) and if negative
-indicates a bottom-up row layout in the buffer.  If you pass zero, libpng will
-calculate the row_stride for you from the width and number of channels.
+indicates a bottom-up row layout in the buffer.
 
 Note that the write API does not support interlacing, sub-8-bit pixels,
-indexed (paletted) images, or most ancillary chunks.
+and indexed (paletted) images.
 
 .SH VI. Modifying/Customizing libpng
 
@@ -4664,7 +4665,7 @@ Error handling in libpng is done through png_error() and png_warning().
 Errors handled through png_error() are fatal, meaning that png_error()
 should never return to its caller.  Currently, this is handled via
 setjmp() and longjmp() (unless you have compiled libpng with
-PNG_NO_SETJMP, in which case it is handled via PNG_ABORT()),
+PNG_NO_SETJMP, in which case it is handled via PNG_ABORT),
 but you could change this to do things like exit() if you should wish,
 as long as your function does not return.
 
@@ -4861,41 +4862,6 @@ is called for the first time.)
               same as the value of filter_method used
               in png_set_IHDR().
 
-It is also possible to influence how libpng chooses from among the
-available filters.  This is done in one or both of two ways - by
-telling it how important it is to keep the same filter for successive
-rows, and by telling it the relative computational costs of the filters.
-
-    double weights[3] = {1.5, 1.3, 1.1},
-       costs[PNG_FILTER_VALUE_LAST] =
-       {1.0, 1.3, 1.3, 1.5, 1.7};
-
-    png_set_filter_heuristics(png_ptr,
-       PNG_FILTER_HEURISTIC_WEIGHTED, 3,
-       weights, costs);
-
-The weights are multiplying factors that indicate to libpng that the
-row filter should be the same for successive rows unless another row filter
-is that many times better than the previous filter.  In the above example,
-if the previous 3 filters were SUB, SUB, NONE, the SUB filter could have a
-"sum of absolute differences" 1.5 x 1.3 times higher than other filters
-and still be chosen, while the NONE filter could have a sum 1.1 times
-higher than other filters and still be chosen.  Unspecified weights are
-taken to be 1.0, and the specified weights should probably be declining
-like those above in order to emphasize recent filters over older filters.
-
-The filter costs specify for each filter type a relative decoding cost
-to be considered when selecting row filters.  This means that filters
-with higher costs are less likely to be chosen over filters with lower
-costs, unless their "sum of absolute differences" is that much smaller.
-The costs do not necessarily reflect the exact computational speeds of
-the various filters, since this would unduly influence the final image
-size.
-
-Note that the numbers above were invented purely for this example and
-are given only to help explain the function usage.  Little testing has
-been done to find optimum values for either the costs or the weights.
-
 .SS Requesting debug printout
 
 The macro definition PNG_DEBUG can be used to request debugging
@@ -5631,7 +5597,54 @@ It can be set for testing debug or beta builds to ensure that they will compile
 when the build type is switched to RC or STABLE. In essence this overrides the
 PNG_LIBPNG_BUILD_BASE_TYPE definition which is not directly user controllable.
 
-.SH XIII.  Detecting libpng
+.SH XIII.  Changes to Libpng from version 1.6.x to 1.7.x
+
+Some functions that were deprecated in libpng-1.6.0 were removed:
+    png_reset_zstream(),
+    png_info_init_3(),
+    png_data_freer() and its associated flags,
+    png_malloc_default(),
+    and png_free_default().
+
+These apparently unused experimental functions have been deprecated
+and the code within them, except for the APIs, has been removed.
+    png_set_filter_heuristics()
+    and png_set_filter_heuristics_fixed()
+
+The PNG_ABORT() macro was changed to PNG_ABORT, and the default is now
+"abort()" for all platforms (previously it was "ExitProcess(0)" on
+Windows platforms).  Starting with libpng-1.7.0 you have to define
+PNG_ABORT instead of PNG_ABORT(), and you must include a terminating
+semicolon in your definition, e.g.,
+
+    #if PNGCRUSH_LIBPNG_VER >= 10700
+    #  ifdef _WINDOWS_
+    #    define PNG_ABORT ExitProcess(0);
+    #  else
+    #    define PNG_ABORT abort();
+    #  endif
+    #else
+    #  ifdef _WINDOWS_
+    #    define PNG_ABORT() ExitProcess(0)
+    #  else
+    #    define PNG_ABORT() abort()
+    #  endif
+    #endif
+
+The png_get_IHDR() function now allows users to supply NULL for any
+argument in which they aren't interested.  Previously, the width, height,
+bit_depth, and color_type arguments were not allowed to be NULL.
+
+The 8-bit compose and rgb_to_grayscale operations were made more accurate.
+While these did not introduce API incompatibility, there may be differences
+in unit test results.
+
+Internal "affirm()" and "impossible()" macros were added, along with
+some internal supporting macros and functions. These are similar to the
+ANSI-C "assert()" macro but they are not affected by NDEBUG, and they are
+private (not visible to nor usable by libpng applications).
+
+.SH XIV.  Detecting libpng
 
 The png_get_io_ptr() function has been present since libpng-0.88, has never
 changed, and is unaffected by conditional compilation macros.  It is the
@@ -5664,7 +5677,7 @@ simple verbal discriptions of bug fixes, reported either to the
 SourceForge bug tracker, to the png-mng-implement at lists.sf.net
 mailing list, or directly to glennrp.
 
-.SH XV. Coding style
+.SH XVI. Coding style
 
 Our coding style is similar to the "Allman" style
 (See http://en.wikipedia.org/wiki/Indent_style#Allman_style), with curly
@@ -5799,15 +5812,15 @@ Lines do not exceed 80 characters.
 
 Other rules can be inferred by inspecting the libpng source.
 
-.SH XVI. Y2K Compliance in libpng
+.SH XVII. Y2K Compliance in libpng
 
-July 12, 2015
+July 26, 2015
 
 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.6.18rc02 are Y2K compliant.  It is my belief that earlier
+upward through 1.7.0beta64 are Y2K compliant.  It is my belief that earlier
 versions were also Y2K compliant.
 
 Libpng only has two year fields.  One is a 2-byte unsigned integer
@@ -5823,9 +5836,8 @@ in libpng-1.6.x and will be removed from libpng-1.7.0.
 
 There are seven time-related functions:
 
-    png_convert_to_rfc_1123_buffer() in png.c
-      (formerly png_convert_to_rfc_1152() in error, and
-      also formerly png_convert_to_rfc_1123())
+    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
@@ -6031,7 +6043,7 @@ the first widely used release:
  1.6.5               16    10605  16.so.16.5[.0]
  1.6.6               16    10606  16.so.16.6[.0]
  1.6.7beta01-04      16    10607  16.so.16.7[.0]
- 1.6.7rc01-02        16    10607  16.so.16.7[.0]
+ 1.6.7rc01-03        16    10607  16.so.16.7[.0]
  1.6.7               16    10607  16.so.16.7[.0]
  1.6.8beta01-02      16    10608  16.so.16.8[.0]
  1.6.8rc01-02        16    10608  16.so.16.8[.0]
@@ -6045,7 +6057,7 @@ the first widely used release:
  1.6.11beta01-06     16    10611  16.so.16.11[.0]
  1.6.11rc01-02       16    10611  16.so.16.11[.0]
  1.6.11              16    10611  16.so.16.11[.0]
- 1.6.12rc01          16    10612  16.so.16.12[.0]
+ 1.6.12rc01-03       16    10612  16.so.16.12[.0]
  1.6.12              16    10612  16.so.16.12[.0]
  1.6.13beta01-04     16    10613  16.so.16.13[.0]
  1.6.13rc01-02       16    10613  16.so.16.13[.0]
@@ -6060,10 +6072,14 @@ the first widely used release:
  1.6.16rc01-02       16    10616  16.so.16.16[.0]
  1.6.16              16    10616  16.so.16.16[.0]
  1.6.17beta01-06     16    10617  16.so.16.17[.0]
- 1.6.17rc01-06       16    10617  16.so.16.17[.0]
+ 1.6.17rc01          16    10617  16.so.16.17[.0]
  1.6.17              16    10617  16.so.16.17[.0]
  1.6.18beta01-09     16    10618  16.so.16.18[.0]
- 1.6.18rc01-02       16    10618  16.so.16.18[.0]
+ 1.6.18rc01-03       16    10618  16.so.16.18[.0]
+ 1.6.18              16    10618  16.so.16.18[.0]
+ 1.6.19beta01        16    10619  16.so.16.19[.0]
+ 1.7.0alpha01-10     17    10700  17.so.17.0[.0]
+ 1.7.0beta01-64      17    10700  17.so.17.0[.0]
 
 Henceforth the source version will match the shared-library minor
 and patch numbers; the shared-library major version number will be
@@ -6120,7 +6136,7 @@ possible without all of you.
 
 Thanks to Frank J. T. Wojcik for helping with the documentation.
 
-Libpng version 1.6.18rc02 - July 12, 2015:
+Libpng version 1.7.0beta64 - July 26, 2015:
 Initially created in 1995 by Guy Eric Schalnat, then of Group 42, Inc.
 Currently maintained by Glenn Randers-Pehrson (glennrp at users.sourceforge.net).
 
@@ -6143,7 +6159,7 @@ this sentence.
 
 This code is released under the libpng license.
 
-libpng versions 1.0.7, July 1, 2000, through 1.6.18rc02, July 12, 2015, are
+libpng versions 1.0.7, July 1, 2000, through 1.7.0beta64, July 26, 2015, are
 Copyright (c) 2000-2002, 2004, 2006-2015 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:
@@ -6237,7 +6253,7 @@ the additional disclaimers inserted at version 1.0.7.
 
 Glenn Randers-Pehrson
 glennrp at users.sourceforge.net
-July 12, 2015
+July 26, 2015
 
 .\" end of man page
 

libpngpf.3

@@ -1,6 +1,6 @@
-.TH LIBPNGPF 3 "July 12, 2015"
+.TH LIBPNGPF 3 "July 26, 2015"
 .SH NAME
-libpng \- Portable Network Graphics (PNG) Reference Library 1.6.18rc02
+libpng \- Portable Network Graphics (PNG) Reference Library 1.7.0beta64
 (private functions)
 .SH SYNOPSIS
 \fB#include \fI"pngpriv.h"

png.5

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

png.h

@@ -1,7 +1,7 @@
 
 /* png.h - header file for PNG reference library
  *
- * libpng version 1.6.18rc02, July 12, 2015
+ * libpng version 1.7.0beta64, July 26, 2015
  *
  * Copyright (c) 1998-2015 Glenn Randers-Pehrson
  * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
@@ -12,7 +12,7 @@
  * Authors and maintainers:
  *   libpng versions 0.71, May 1995, through 0.88, January 1996: Guy Schalnat
  *   libpng versions 0.89, June 1996, through 0.96, May 1997: Andreas Dilger
- *   libpng versions 0.97, January 1998, through 1.6.18rc02, July 12, 2015: Glenn
+ *   libpng versions 0.97, January 1998, through 1.7.0beta64, July 26, 2015: Glenn
  *   See also "Contributing Authors", below.
  *
  * Note about libpng version numbers:
@@ -217,7 +217,10 @@
  *    1.6.17rc01-06           16    10617  16.so.16.17[.0]
  *    1.6.17                  16    10617  16.so.16.17[.0]
  *    1.6.18beta01-09         16    10618  16.so.16.18[.0]
- *    1.6.18rc01-02           16    10618  16.so.16.18[.0]
+ *    1.6.18rc01-03           16    10618  16.so.16.18[.0]
+ *    1.6.18                  16    10618  16.so.16.18[.0]
+ *    1.7.0alpha01-10         17    10700  17.so.17.0[.0]
+ *    1.7.0beta01-64          17    10700  17.so.17.0[.0]
  *
  *   Henceforth the source version will match the shared-library major
  *   and minor numbers; the shared-library major version number will be
@@ -249,13 +252,12 @@
  *
  * This code is released under the libpng license.
  *
- * libpng versions 1.0.7, July 1, 2000, through 1.6.18rc02, July 12, 2015, are
+ * libpng versions 1.0.7, July 1, 2000, through 1.7.0beta64, July 26, 2015, are
  * Copyright (c) 2000-2002, 2004, 2006-2015 Glenn Randers-Pehrson, and are
  * distributed according to the same disclaimer and license as libpng-1.0.6
  * with the following individuals added to the list of Contributing Authors:
  *
  *    Simon-Pierre Cadieux
- *    Eric S. Raymond
  *    Mans Rullgard
  *    Cosmin Truta
  *    Gilles Vollant
@@ -277,6 +279,7 @@
  *
  *    Tom Lane
  *    Glenn Randers-Pehrson
+ *    Eric S. Raymond
  *    Willem van Schaik
  *
  * libpng versions 0.89, June 1996, through 0.96, May 1997, are
@@ -358,13 +361,13 @@
  * Y2K compliance in libpng:
  * =========================
  *
- *    July 12, 2015
+ *    July 26, 2015
  *
  *    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.6.18rc02 are Y2K compliant.  It is my belief that
+ *    upward through 1.7.0beta64 are Y2K compliant.  It is my belief that
  *    earlier versions were also Y2K compliant.
  *
  *    Libpng only has two year fields.  One is a 2-byte unsigned integer
@@ -426,23 +429,23 @@
  */
 
 /* Version information for png.h - this should match the version in png.c */
-#define PNG_LIBPNG_VER_STRING "1.6.18rc02"
+#define PNG_LIBPNG_VER_STRING "1.7.0beta64"
 #define PNG_HEADER_VERSION_STRING \
-     " libpng version 1.6.18rc02 - July 12, 2015\n"
+     " libpng version 1.7.0beta64 - July 26, 2015\n"
 
-#define PNG_LIBPNG_VER_SONUM   16
-#define PNG_LIBPNG_VER_DLLNUM  16
+#define PNG_LIBPNG_VER_SONUM   17
+#define PNG_LIBPNG_VER_DLLNUM  17
 
 /* These should match the first 3 components of PNG_LIBPNG_VER_STRING: */
 #define PNG_LIBPNG_VER_MAJOR   1
-#define PNG_LIBPNG_VER_MINOR   6
-#define PNG_LIBPNG_VER_RELEASE 18
+#define PNG_LIBPNG_VER_MINOR   7
+#define PNG_LIBPNG_VER_RELEASE 0
 
 /* This should match the numeric part of the final component of
  * PNG_LIBPNG_VER_STRING, omitting any leading zero:
  */
 
-#define PNG_LIBPNG_VER_BUILD  02
+#define PNG_LIBPNG_VER_BUILD  64
 
 /* Release Status */
 #define PNG_LIBPNG_BUILD_ALPHA    1
@@ -459,7 +462,7 @@
 #define PNG_LIBPNG_BUILD_SPECIAL 32 /* Cannot be OR'ed with
                                        PNG_LIBPNG_BUILD_PRIVATE */
 
-#define PNG_LIBPNG_BUILD_BASE_TYPE PNG_LIBPNG_BUILD_RC
+#define PNG_LIBPNG_BUILD_BASE_TYPE PNG_LIBPNG_BUILD_BETA
 
 /* Careful here.  At one time, Guy wanted to use 082, but that would be octal.
  * We must not include leading zeros.
@@ -467,7 +470,7 @@
  * version 1.0.0 was mis-numbered 100 instead of 10000).  From
  * version 1.0.1 it's    xxyyzz, where x=major, y=minor, z=release
  */
-#define PNG_LIBPNG_VER 10618 /* 1.6.18 */
+#define PNG_LIBPNG_VER 10700 /* 1.7.0 */
 
 /* Library configuration: these options cannot be changed after
  * the library has been built.
@@ -512,11 +515,6 @@
 
 #ifndef PNG_VERSION_INFO_ONLY
 
-/* Inhibit C++ name-mangling for libpng functions but not for system calls. */
-#ifdef __cplusplus
-extern "C" {
-#endif /* __cplusplus */
-
 /* Version information for C files, stored in png.c.  This had better match
  * the version above.
  */
@@ -524,17 +522,141 @@ extern "C" {
 
 /* This file is arranged in several sections:
  *
- * 1. Any configuration options that can be specified by for the application
+ * 1. ISO-PNG constants and definitions; values defined by PNG and not specific
+ *    to the libpng API.
+ * 2. Any configuration options that can be specified by for the application
  *    code when it is built.  (Build time configuration is in pnglibconf.h)
- * 2. Type definitions (base types are defined in pngconf.h), structure
+ * 3. Type definitions (base types are defined in pngconf.h), structure
  *    definitions.
- * 3. Exported library functions.
- * 4. Simplified API.
+ * 4. Exported library functions.
+ * 5. Simplified API.
+ * 6. Implementation options
  *
  * The library source code has additional files (principally pngpriv.h) that
  * allow configuration of the library.
  */
-/* Section 1: run time configuration
+
+/* Section 1: ISO PNG constants and macros. */
+
+/* ISO-PNG defines byte encodings for 16 and 32-bit unsigned values and 32-bit
+ * signed values.  The macros PNG_U16, PNG_U32 and PNG_S32 return values of type
+ * (png_uint_16), (png_uint_32) and (png_int_32) which are target machine
+ * specific representations of these values, using the types defined in
+ * pngconf.h.  The macros take two or four byte values in the order in which
+ * they would occur in a PNG stream.
+ *
+ * These macros must return compile time constants if passed constant values -
+ * machine specific implementations are not permitted.  These macros are used by
+ * default in the API functions/macros png_get_uint_16, png_get_uint_32,
+ * png_get_uint_31 and png_get_int_32 declared below: these functions or macros
+ * are the correct places for machine specific implementations (such as hardware
+ * specific instructions.)
+ *
+ * The macros defined here are generic and intended to give maximum flexibility
+ * in implementation to the compiler; only PNG_S32 contains a sequence point,
+ * there are no side effects and the expressions used permit the maximum
+ * parallelization (relevant because the four bytes may be loaded in parallel.)
+ */
+#define PNG_u2(b1, b2) (((unsigned int)(b1) << 8) + (b2))
+
+#define PNG_U16(b1, b2) ((png_uint_16)/*SAFE*/PNG_u2(b1, b2))
+#define PNG_U32(b1, b2, b3, b4)\
+   (((png_uint_32)/*SAFE*/PNG_u2(b1, b2) << 16) + PNG_u2(b3, b4))
+
+/* ISO-PNG states that signed 32-bit values are stored in two's complement
+ * format.  There is no guarantee that (png_int_32) is exactly 32 bits, so the
+ * following macro tests for a negative number and generates the machine format
+ * directly by portable arithmetic operations.  The cost is that the argument
+ * 'b1' is evaluated twice.
+ */
+#define PNG_S32(b1, b2, b3, b4) ((b1) & 0x80\
+      ? -(png_int_32)((PNG_U32(b1, b2, b3, b4) ^ 0xffffffff) + 1)\
+      : (png_int_32)PNG_U32(b1, b2, b3, b4))
+
+/* Constants for known chunk types.
+ *
+ * MAINTAINERS: If you need to add a chunk, define the name here.
+ * For historical reasons these constants have the form png_<name>; i.e.
+ * the prefix is lower case.  Please use decimal values as the parameters to
+ * match the ISO PNG specification and to avoid relying on the C locale
+ * interpretation of character values.  Please keep the list sorted.
+ *
+ * Notice that PNG_U32 is used to define a 32-bit value for the 4 byte chunk
+ * type.  In fact the specification does not express chunk types this way,
+ * however using a 32-bit value means that the chunk type can be read from the
+ * stream using exactly the same code as used for a 32-bit unsigned value and
+ * can be examined far more efficiently (using one arithmetic compare).
+ *
+ * Prior to 1.5.6 the chunk type constants were expressed as C strings.  The
+ * libpng API still uses strings for 'unknown' chunks and a macro,
+ * PNG_STRING_FROM_CHUNK, allows a string to be generated if required.  Notice
+ * that for portable code numeric values must still be used; the string "IHDR"
+ * is not portable and neither is PNG_U32('I', 'H', 'D', 'R').
+ *
+ * In 1.7.0 the definitions were made public in png.h to avoid having to
+ * duplicate the same definitions in application code.
+ *
+ * SOURCE: http://www.libpng.org/pub/png/spec/register/
+ *    "Register of PNG Public Chunks and Keywords, version 1.4.6"
+ *    "Extensions to the PNG Specification, version 1.4.0"
+ */
+#define png_IDAT PNG_U32( 73,  68,  65,  84)
+#define png_IEND PNG_U32( 73,  69,  78,  68)
+#define png_IHDR PNG_U32( 73,  72,  68,  82)
+#define png_PLTE PNG_U32( 80,  76,  84,  69)
+#define png_bKGD PNG_U32( 98,  75,  71,  68)
+#define png_cHRM PNG_U32( 99,  72,  82,  77)
+#define png_dSIG PNG_U32(100,  83,  73,  71) /* separate spec */
+#define png_fRAc PNG_U32(102,  82,  65,  99) /* registered, not defined */
+#define png_gAMA PNG_U32(103,  65,  77,  65)
+#define png_gIFg PNG_U32(103,  73,  70, 103)
+#define png_gIFt PNG_U32(103,  73,  70, 116) /* deprecated */
+#define png_gIFx PNG_U32(103,  73,  70, 120)
+#define png_hIST PNG_U32(104,  73,  83,  84)
+#define png_iCCP PNG_U32(105,  67,  67,  80)
+#define png_iTXt PNG_U32(105,  84,  88, 116)
+#define png_oFFs PNG_U32(111,  70,  70, 115)
+#define png_pCAL PNG_U32(112,  67,  65,  76)
+#define png_pHYs PNG_U32(112,  72,  89, 115)
+#define png_sBIT PNG_U32(115,  66,  73,  84)
+#define png_sCAL PNG_U32(115,  67,  65,  76)
+#define png_sPLT PNG_U32(115,  80,  76,  84)
+#define png_sRGB PNG_U32(115,  82,  71,  66)
+#define png_sTER PNG_U32(115,  84,  69,  82)
+#define png_tEXt PNG_U32(116,  69,  88, 116)
+#define png_tIME PNG_U32(116,  73,  77,  69)
+#define png_tRNS PNG_U32(116,  82,  78,  83)
+#define png_zTXt PNG_U32(122,  84,  88, 116)
+
+/* The following will work on (signed char*) strings, whereas the PNG_U32 macro
+ * used directory would fail on top-bit-set values because of the sign
+ * extension.
+ */
+#define PNG_CHUNK_FROM_STRING(s)\
+   PNG_U32(0xff&(s)[0], 0xff&(s)[1], 0xff&(s)[2], 0xff&(s)[3])
+
+/* This uses (char), not (png_byte) to avoid warnings on systems where (char) is
+ * signed and the argument is a (char[])  This macro will fail miserably on
+ * systems where (char) is more than 8 bits.
+ */
+#define PNG_STRING_FROM_CHUNK(s,c)\
+   (void)(((char*)(s))[0]=(char)(((c)>>24) & 0xff), \
+   ((char*)(s))[1]=(char)(((c)>>16) & 0xff),\
+   ((char*)(s))[2]=(char)(((c)>>8) & 0xff), \
+   ((char*)(s))[3]=(char)((c & 0xff)))
+
+/* Do the same but terminate with a null character. */
+#define PNG_CSTRING_FROM_CHUNK(s,c)\
+   (void)(PNG_STRING_FROM_CHUNK(s,c), ((char*)(s))[4] = 0)
+
+/* Test on flag values as defined in the spec (section 5.4): */
+#define PNG_CHUNK_ANCILLARY(c)    (1 & ((c) >> 29))
+#define PNG_CHUNK_CRITICAL(c)     (!PNG_CHUNK_ANCILLARY(c))
+#define PNG_CHUNK_PRIVATE(c)      (1 & ((c) >> 21))
+#define PNG_CHUNK_RESERVED(c)     (1 & ((c) >> 13))
+#define PNG_CHUNK_SAFE_TO_COPY(c) (1 & ((c) >>  5))
+
+/* Section 2: run time configuration
  * See pnglibconf.h for build time configuration
  *
  * Run time configuration allows the application to choose between
@@ -564,7 +686,12 @@ extern "C" {
  * Otherwise the calls are mapped to png_error.
  */
 
-/* Section 2: type definitions, including structures and compile time
+/* Inhibit C++ name-mangling for libpng functions but not for system calls. */
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+/* Section 3: type definitions, including structures and compile time
  * constants.
  * See pngconf.h for base types that vary by machine/system
  */
@@ -572,7 +699,7 @@ extern "C" {
 /* This triggers a compiler error in png.c, if png.c and png.h
  * do not agree upon the version number.
  */
-typedef char* png_libpng_version_1_6_18rc02;
+typedef char* png_libpng_version_1_7_0beta64;
 
 /* Basic control structions.  Read libpng-manual.txt or libpng.3 for more info.
  *
@@ -713,8 +840,8 @@ typedef struct png_text_struct
    png_charp key;          /* keyword, 1-79 character description of "text" */
    png_charp text;         /* comment, may be an empty string (ie "")
                               or a NULL pointer */
-   png_size_t text_length; /* length of the text string */
-   png_size_t itxt_length; /* length of the itxt string */
+   size_t text_length; /* length of the text string */
+   size_t itxt_length; /* length of the itxt string */
    png_charp lang;         /* language code, 0-79 characters
                               or a NULL pointer */
    png_charp lang_key;     /* keyword translated UTF-8 string, 0 or more
@@ -767,7 +894,7 @@ typedef struct png_unknown_chunk_t
 {
     png_byte name[5]; /* Textual chunk name with '\0' terminator */
     png_byte *data;   /* Data, should not be modified on read! */
-    png_size_t size;
+    size_t size;
 
     /* On write 'location' must be set using the flag values listed below.
      * Notice that on read it is set by libpng however the values stored have
@@ -792,7 +919,7 @@ typedef png_unknown_chunk * * png_unknown_chunkpp;
 /* Maximum positive integer used in PNG is (2^31)-1 */
 #define PNG_UINT_31_MAX ((png_uint_32)0x7fffffffL)
 #define PNG_UINT_32_MAX ((png_uint_32)(-1))
-#define PNG_SIZE_MAX ((png_size_t)(-1))
+#define PNG_SIZE_MAX ((size_t)(-1))
 
 /* These are constants for fixed point values encoded in the
  * PNG specification manner (x100000)
@@ -897,7 +1024,7 @@ typedef png_unknown_chunk * * png_unknown_chunkpp;
 typedef struct png_row_info_struct
 {
    png_uint_32 width;    /* width of row */
-   png_size_t rowbytes;  /* number of bytes in row */
+   size_t rowbytes;  /* number of bytes in row */
    png_byte color_type;  /* color type of row */
    png_byte bit_depth;   /* bit depth of row */
    png_byte channels;    /* number of channels (1, 2, 3, or 4) */
@@ -916,7 +1043,7 @@ typedef png_row_info * * png_row_infopp;
  * expected to return the read data in the buffer.
  */
 typedef PNG_CALLBACK(void, *png_error_ptr, (png_structp, png_const_charp));
-typedef PNG_CALLBACK(void, *png_rw_ptr, (png_structp, png_bytep, png_size_t));
+typedef PNG_CALLBACK(void, *png_rw_ptr, (png_structp, png_bytep, size_t));
 typedef PNG_CALLBACK(void, *png_flush_ptr, (png_structp));
 typedef PNG_CALLBACK(void, *png_read_status_ptr, (png_structp, png_uint_32,
     int));
@@ -1009,7 +1136,7 @@ typedef PNG_CALLBACK(png_voidp, *png_malloc_ptr, (png_structp,
     png_alloc_size_t));
 typedef PNG_CALLBACK(void, *png_free_ptr, (png_structp, png_voidp));
 
-/* Section 3: exported functions
+/* Section 4: exported functions
  * Here are the function definitions most commonly used.  This is not
  * the place to find out how to use libpng.  See libpng-manual.txt for the
  * full explanation, see example.c for the summary.  This just provides
@@ -1051,8 +1178,8 @@ PNG_EXPORT(2, void, png_set_sig_bytes, (png_structrp png_ptr, int num_bytes));
  * signature, and non-zero otherwise.  Having num_to_check == 0 or
  * start > 7 will always fail (ie return non-zero).
  */
-PNG_EXPORT(3, int, png_sig_cmp, (png_const_bytep sig, png_size_t start,
-    png_size_t num_to_check));
+PNG_EXPORT(3, int, png_sig_cmp, (png_const_bytep sig, size_t start,
+    size_t num_to_check));
 
 /* Simple signature checking function.  This is the same as calling
  * png_check_sig(sig, n) := !png_sig_cmp(sig, 0, n).
@@ -1071,11 +1198,11 @@ PNG_EXPORTA(5, png_structp, png_create_write_struct,
     png_error_ptr warn_fn),
     PNG_ALLOCATED);
 
-PNG_EXPORT(6, png_size_t, png_get_compression_buffer_size,
+PNG_EXPORT(6, size_t, png_get_compression_buffer_size,
     (png_const_structrp png_ptr));
 
 PNG_EXPORT(7, void, png_set_compression_buffer_size, (png_structrp png_ptr,
-    png_size_t size));
+    size_t size));
 
 /* Moved from pngconf.h in 1.4.0 and modified to ensure setjmp/longjmp
  * match up.
@@ -1105,8 +1232,8 @@ PNG_EXPORTA(9, void, png_longjmp, (png_const_structrp png_ptr, int val),
     PNG_NORETURN);
 
 #ifdef PNG_READ_SUPPORTED
-/* Reset the compression stream */
-PNG_EXPORTA(10, int, png_reset_zstream, (png_structrp png_ptr), PNG_DEPRECATED);
+/* Reset the compression stream -- Removed from libpng-1.7.0 */
+PNG_REMOVED(10, int, png_reset_zstream, (png_structrp png_ptr), PNG_DEPRECATED)
 #endif
 
 /* New functions added in libpng-1.0.2 (not enabled by default until 1.2.0) */
@@ -1128,7 +1255,7 @@ PNG_EXPORT(13, void, png_write_sig, (png_structrp png_ptr));
 
 /* Write a PNG chunk - size, type, (optional) data, CRC. */
 PNG_EXPORT(14, void, png_write_chunk, (png_structrp png_ptr, png_const_bytep
-    chunk_name, png_const_bytep data, png_size_t length));
+    chunk_name, png_const_bytep data, size_t length));
 
 /* Write the start of a PNG chunk - length and chunk name. */
 PNG_EXPORT(15, void, png_write_chunk_start, (png_structrp png_ptr,
@@ -1136,7 +1263,7 @@ PNG_EXPORT(15, void, png_write_chunk_start, (png_structrp png_ptr,
 
 /* Write the data of a PNG chunk started with png_write_chunk_start(). */
 PNG_EXPORT(16, void, png_write_chunk_data, (png_structrp png_ptr,
-    png_const_bytep data, png_size_t length));
+    png_const_bytep data, size_t length));
 
 /* Finish a chunk started with png_write_chunk_start() (includes CRC). */
 PNG_EXPORT(17, void, png_write_chunk_end, (png_structrp png_ptr));
@@ -1145,12 +1272,9 @@ PNG_EXPORT(17, void, png_write_chunk_end, (png_structrp png_ptr));
 PNG_EXPORTA(18, png_infop, png_create_info_struct, (png_const_structrp png_ptr),
     PNG_ALLOCATED);
 
-/* DEPRECATED: this function allowed init structures to be created using the
- * default allocation method (typically malloc).  Use is deprecated in 1.6.0 and
- * the API will be removed in the future.
- */
-PNG_EXPORTA(19, void, png_info_init_3, (png_infopp info_ptr,
-    png_size_t png_info_struct_size), PNG_DEPRECATED);
+/* Removed from libpng-1.7.0 */
+PNG_REMOVED(19, void, png_info_init_3, (png_infopp info_ptr,
+    size_t png_info_struct_size), PNG_DEPRECATED)
 
 /* Writes all the PNG information before the image. */
 PNG_EXPORT(20, void, png_write_info_before_PLTE,
@@ -1167,13 +1291,10 @@ PNG_EXPORT(22, void, png_read_info,
 #ifdef PNG_TIME_RFC1123_SUPPORTED
    /* Convert to a US string format: there is no localization support in this
     * routine.  The original implementation used a 29 character buffer in
-    * png_struct, this will be removed in future versions.
+    * png_struct, this has been removed (in libpng 1.7.0).
     */
-#if PNG_LIBPNG_VER < 10700
-/* To do: remove this from libpng17 (and from libpng17/png.c and pngstruct.h) */
-PNG_EXPORTA(23, png_const_charp, png_convert_to_rfc1123, (png_structrp png_ptr,
-    png_const_timep ptime),PNG_DEPRECATED);
-#endif
+PNG_REMOVED(23, png_const_charp, png_convert_to_rfc1123, (png_structrp png_ptr,
+    png_const_timep ptime),PNG_DEPRECATED)
 PNG_EXPORT(241, int, png_convert_to_rfc1123_buffer, (char out[29],
     png_const_timep ptime));
 #endif
@@ -1581,7 +1702,6 @@ PNG_EXPORT(66, void, png_set_crc_action, (png_structrp png_ptr, int crit_action,
 #define PNG_CRC_QUIET_USE     4  /* quiet/use data      quiet/use data    */
 #define PNG_CRC_NO_CHANGE     5  /* use current value   use current value */
 
-#ifdef PNG_WRITE_SUPPORTED
 /* These functions give the user control over the scan-line filtering in
  * libpng and the compression methods used by zlib.  These functions are
  * mainly useful for testing, as the defaults should work with most users.
@@ -1590,6 +1710,7 @@ PNG_EXPORT(66, void, png_set_crc_action, (png_structrp png_ptr, int crit_action,
  * header file (zlib.h) for an explination of the compression functions.
  */
 
+#ifdef PNG_WRITE_SUPPORTED
 /* Set the filtering method(s) used by libpng.  Currently, the only valid
  * value for "method" is 0.
  */
@@ -1597,22 +1718,8 @@ PNG_EXPORT(67, void, png_set_filter, (png_structrp png_ptr, int method,
     int filters));
 #endif /* WRITE */
 
-/* Flags for png_set_filter() to say which filters to use.  The flags
- * are chosen so that they don't conflict with real filter types
- * below, in case they are supplied instead of the #defined constants.
- * These values should NOT be changed.
- */
-#define PNG_NO_FILTERS     0x00
-#define PNG_FILTER_NONE    0x08
-#define PNG_FILTER_SUB     0x10
-#define PNG_FILTER_UP      0x20
-#define PNG_FILTER_AVG     0x40
-#define PNG_FILTER_PAETH   0x80
-#define PNG_ALL_FILTERS (PNG_FILTER_NONE | PNG_FILTER_SUB | PNG_FILTER_UP | \
-                         PNG_FILTER_AVG | PNG_FILTER_PAETH)
-
 /* Filter values (not flags) - used in pngwrite.c, pngwutil.c for now.
- * These defines should NOT be changed.
+ * These defines match the values in the PNG specification.
  */
 #define PNG_FILTER_VALUE_NONE  0
 #define PNG_FILTER_VALUE_SUB   1
@@ -1621,22 +1728,36 @@ PNG_EXPORT(67, void, png_set_filter, (png_structrp png_ptr, int method,
 #define PNG_FILTER_VALUE_PAETH 4
 #define PNG_FILTER_VALUE_LAST  5
 
+/* The above values are valid arguments to png_set_filter() if only a single
+ * filter is to be used.  If multiple filters are to be allowed (the default is
+ * to allow any of them) then a combination of the following masks must be used
+ * and the low three bits of the argument to png_set_filter must be 0.
+ *
+ * The resultant argument fits in a single byte.
+ */
+#define PNG_FILTER_NONE    (0x08 << PNG_FILTER_VALUE_NONE)
+#define PNG_FILTER_SUB     (0x08 << PNG_FILTER_VALUE_SUB)
+#define PNG_FILTER_UP      (0x08 << PNG_FILTER_VALUE_UP)
+#define PNG_FILTER_AVG     (0x08 << PNG_FILTER_VALUE_AVG)
+#define PNG_FILTER_PAETH   (0x08 << PNG_FILTER_VALUE_PAETH)
+
+/* Then two convenience values.  PNG_NO_FILTERS is the same as
+ * PNG_FILTER_VALUE_NONE, but this is harmless because they mean the same thing.
+ */
+#define PNG_NO_FILTERS     0x00
+#define PNG_ALL_FILTERS    (PNG_FILTER_NONE | PNG_FILTER_SUB | PNG_FILTER_UP | \
+   PNG_FILTER_AVG | PNG_FILTER_PAETH)
+
 #ifdef PNG_WRITE_SUPPORTED
 #ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED /* DEPRECATED */
 PNG_FP_EXPORT(68, void, png_set_filter_heuristics, (png_structrp png_ptr,
     int heuristic_method, int num_weights, png_const_doublep filter_weights,
-    png_const_doublep filter_costs))
+    png_const_doublep filter_costs) PNG_DEPRECATED)
 PNG_FIXED_EXPORT(209, void, png_set_filter_heuristics_fixed,
     (png_structrp png_ptr, int heuristic_method, int num_weights,
     png_const_fixed_point_p filter_weights,
-    png_const_fixed_point_p filter_costs))
-#endif /* WRITE_WEIGHTED_FILTER */
-
-/* The following are no longer used and will be removed from libpng-1.7: */
-#define PNG_FILTER_HEURISTIC_DEFAULT    0  /* Currently "UNWEIGHTED" */
-#define PNG_FILTER_HEURISTIC_UNWEIGHTED 1  /* Used by libpng < 0.95 */
-#define PNG_FILTER_HEURISTIC_WEIGHTED   2  /* Experimental feature */
-#define PNG_FILTER_HEURISTIC_LAST       3  /* Not a valid value */
+    png_const_fixed_point_p filter_costs) PNG_DEPRECATED)
+#endif /*  WRITE_WEIGHTED_FILTER */
 
 /* Set the library compression level.  Currently, valid values range from
  * 0 - 9, corresponding directly to the zlib compression levels 0 - 9
@@ -1797,12 +1918,14 @@ PNG_EXPORT(218, png_byte, png_get_current_pass_number, (png_const_structrp));
  * The integer return from the callback function is interpreted thus:
  *
  * negative: An error occurred; png_chunk_error will be called.
- *     zero: The chunk was not handled, the chunk will be saved. A critical
- *           chunk will cause an error at this point unless it is to be saved.
+ *     zero: The chunk was not handled, the default unknown handling is used
+ *           (even if this was a chunk that would otherwise be known.)
+ *           NOTE: prior to libpng 1.7 handling values of
+ *           PNG_HANDLE_CHUNK_AS_DEFAULT and PNG_HANDLE_CHUNK_NEVER were
+ *           converted to PNG_HANDLE_CHUNK_IF_SAFE (libpng 1.6.0 warns if this
+ *           happens) so it was not possible to discard unknown chunk data if a
+ *           user callback was installed.
  * positive: The chunk was handled, libpng will ignore/discard it.
- *
- * See "INTERACTION WTIH USER CHUNK CALLBACKS" below for important notes about
- * how this behavior will change in libpng 1.7
  */
 PNG_EXPORT(88, void, png_set_read_user_chunk_fn, (png_structrp png_ptr,
     png_voidp user_chunk_ptr, png_user_chunk_ptr read_user_chunk_fn));
@@ -1826,7 +1949,7 @@ PNG_EXPORT(91, png_voidp, png_get_progressive_ptr,
 
 /* Function to be called when data becomes available */
 PNG_EXPORT(92, void, png_process_data, (png_structrp png_ptr,
-    png_inforp info_ptr, png_bytep buffer, png_size_t buffer_size));
+    png_inforp info_ptr, png_bytep buffer, size_t buffer_size));
 
 /* A function which may be called *only* within png_process_data to stop the
  * processing of any more data.  The function returns the number of bytes
@@ -1835,7 +1958,7 @@ PNG_EXPORT(92, void, png_process_data, (png_structrp png_ptr,
  * 'save' is set to true the routine will first save all the pending data and
  * will always return 0.
  */
-PNG_EXPORT(219, png_size_t, png_process_data_pause, (png_structrp, int save));
+PNG_EXPORT(219, size_t, png_process_data_pause, (png_structrp, int save));
 
 /* A function which may be called *only* outside (after) a call to
  * png_process_data.  It returns the number of bytes of data to skip in the
@@ -1845,6 +1968,7 @@ PNG_EXPORT(219, png_size_t, png_process_data_pause, (png_structrp, int save));
  */
 PNG_EXPORT(220, png_uint_32, png_process_data_skip, (png_structrp));
 
+#ifdef PNG_READ_INTERLACING_SUPPORTED
 /* Function that combines rows.  'new_row' is a flag that should come from
  * the callback and be non-NULL if anything needs to be done; the library
  * stores its own version of the new data internally and ignores the passed
@@ -1852,6 +1976,7 @@ PNG_EXPORT(220, png_uint_32, png_process_data_skip, (png_structrp));
  */
 PNG_EXPORT(93, void, png_progressive_combine_row, (png_const_structrp png_ptr,
     png_bytep old_row, png_const_bytep new_row));
+#endif /* READ_INTERLACING */
 #endif /* PROGRESSIVE_READ */
 
 PNG_EXPORTA(94, png_voidp, png_malloc, (png_const_structrp png_ptr,
@@ -1876,16 +2001,13 @@ PNG_EXPORT(98, void, png_free_data, (png_const_structrp png_ptr,
  * in, it does not change the state for other png_info structures.
  *
  * It is unlikely that this function works correctly as of 1.6.0 and using it
- * may result either in memory leaks or double free of allocated data.
+ * may result either in memory leaks or double free of allocated data. It was
+ * removed in libpng 1.7.0.
  */
-PNG_EXPORT(99, void, png_data_freer, (png_const_structrp png_ptr,
-    png_inforp info_ptr, int freer, png_uint_32 mask));
+PNG_REMOVED(99, void, png_data_freer, (png_const_structrp png_ptr,
+    png_inforp info_ptr, int freer, png_uint_32 mask), PNG_DEPRECATED)
 
-/* Assignments for png_data_freer */
-#define PNG_DESTROY_WILL_FREE_DATA 1
-#define PNG_SET_WILL_FREE_DATA 1
-#define PNG_USER_WILL_FREE_DATA 2
-/* Flags for png_ptr->free_me and info_ptr->free_me */
+/* Flags for png_free_data */
 #define PNG_FREE_HIST 0x0008
 #define PNG_FREE_ICCP 0x0010
 #define PNG_FREE_SPLT 0x0020
@@ -1903,10 +2025,14 @@ PNG_EXPORT(99, void, png_data_freer, (png_const_structrp png_ptr,
 #define PNG_FREE_MUL  0x4220 /* PNG_FREE_SPLT|PNG_FREE_TEXT|PNG_FREE_UNKN */
 
 #ifdef PNG_USER_MEM_SUPPORTED
-PNG_EXPORTA(100, png_voidp, png_malloc_default, (png_const_structrp png_ptr,
-    png_alloc_size_t size), PNG_ALLOCATED PNG_DEPRECATED);
-PNG_EXPORTA(101, void, png_free_default, (png_const_structrp png_ptr,
-    png_voidp ptr), PNG_DEPRECATED);
+   /* These were deprecated in libpng 1.6.0 and have been removed from libpng
+    * 1.7.0; the functionality should be accessed by calling malloc or free
+    * directly or, if png_error handling is required, calling png_malloc.
+    */
+PNG_REMOVED(100, png_voidp, png_malloc_default, (png_const_structrp png_ptr,
+    png_alloc_size_t size), PNG_ALLOCATED PNG_DEPRECATED)
+PNG_REMOVED(101, void, png_free_default, (png_const_structrp png_ptr,
+    png_voidp ptr), PNG_DEPRECATED)
 #endif
 
 #ifdef PNG_ERROR_TEXT_SUPPORTED
@@ -1979,7 +2105,7 @@ PNG_EXPORT(110, png_uint_32, png_get_valid, (png_const_structrp png_ptr,
     png_const_inforp info_ptr, png_uint_32 flag));
 
 /* Returns number of bytes needed to hold a transformed row. */
-PNG_EXPORT(111, png_size_t, png_get_rowbytes, (png_const_structrp png_ptr,
+PNG_EXPORT(111, size_t, png_get_rowbytes, (png_const_structrp png_ptr,
     png_const_inforp info_ptr));
 
 #ifdef PNG_INFO_IMAGE_SUPPORTED
@@ -2235,7 +2361,7 @@ PNG_EXPORT(160, int, png_get_sPLT, (png_const_structrp png_ptr,
 #endif
 
 #ifdef PNG_sPLT_SUPPORTED
-PNG_EXPORT(161, void, png_set_sPLT, (png_const_structrp png_ptr,
+PNG_EXPORT(161, void, png_set_sPLT, (png_structrp png_ptr,
     png_inforp info_ptr, png_const_sPLT_tp entries, int nentries));
 #endif
 
@@ -2253,7 +2379,7 @@ PNG_EXPORT(162, int, png_get_text, (png_const_structrp png_ptr,
  */
 
 #ifdef PNG_TEXT_SUPPORTED
-PNG_EXPORT(163, void, png_set_text, (png_const_structrp png_ptr,
+PNG_EXPORT(163, void, png_set_text, (png_structrp png_ptr,
     png_inforp info_ptr, png_const_textp text_ptr, int num_text));
 #endif
 
@@ -2280,15 +2406,14 @@ PNG_EXPORT(167, void, png_set_tRNS, (png_structrp png_ptr,
 #endif
 
 #ifdef PNG_sCAL_SUPPORTED
-PNG_FP_EXPORT(168, png_uint_32, png_get_sCAL, (png_const_structrp png_ptr,
-    png_const_inforp info_ptr, int *unit, double *width, double *height))
-#if defined(PNG_FLOATING_ARITHMETIC_SUPPORTED) || \
-   defined(PNG_FLOATING_POINT_SUPPORTED)
-/* NOTE: this API is currently implemented using floating point arithmetic,
- * consequently it can only be used on systems with floating point support.
+#ifdef PNG_FLOATING_ARITHMETIC_SUPPORTED
+/* NOTE: these API are currently implemented using floating point arithmetic,
+ * consequently they can only be used on systems with floating point support.
  * In any case the range of values supported by png_fixed_point is small and it
  * is highly recommended that png_get_sCAL_s be used instead.
  */
+PNG_FP_EXPORT(168, png_uint_32, png_get_sCAL, (png_const_structrp png_ptr,
+    png_const_inforp info_ptr, int *unit, double *width, double *height))
 PNG_FIXED_EXPORT(214, png_uint_32, png_get_sCAL_fixed,
     (png_const_structrp png_ptr, png_const_inforp info_ptr, int *unit,
     png_fixed_point *width, png_fixed_point *height))
@@ -2297,8 +2422,13 @@ PNG_EXPORT(169, png_uint_32, png_get_sCAL_s,
     (png_const_structrp png_ptr, png_const_inforp info_ptr, int *unit,
     png_charpp swidth, png_charpp sheight));
 
+#ifdef PNG_FLOATING_ARITHMETIC_SUPPORTED
+/* This also requires internal floating point arithmetic support - i.e. it
+ * requires a full math library, not just floating point handling.
+ */
 PNG_FP_EXPORT(170, void, png_set_sCAL, (png_const_structrp png_ptr,
     png_inforp info_ptr, int unit, double width, double height))
+#endif
 PNG_FIXED_EXPORT(213, void, png_set_sCAL_fixed, (png_const_structrp png_ptr,
    png_inforp info_ptr, int unit, png_fixed_point width,
    png_fixed_point height))
@@ -2314,9 +2444,14 @@ PNG_EXPORT(171, void, png_set_sCAL_s, (png_const_structrp png_ptr,
  * NOTE: prior to 1.6.0 the handling specified for particular chunks on read was
  * ignored and the default was used, the per-chunk setting only had an effect on
  * write.  If you wish to have chunk-specific handling on read in code that must
- * work on earlier versions you must use a user chunk callback to specify the
+ * work on earlier versions you must use a user chunk callback to implement the
  * desired handling (keep or discard.)
  *
+ * NOTE: prior to 1.7.0 when a user callback returned '0', indicating that the
+ * chunk had not been handled, libpng would preserve it regardless of the
+ * default or per-chunk settings.  For compatibility with earlier versions
+ * simply return '1' (handled) from the callback to discard the chunk.
+ *
  * The 'keep' parameter is a PNG_HANDLE_CHUNK_ value as listed below.  The
  * parameter is interpreted as follows:
  *
@@ -2339,21 +2474,12 @@ PNG_EXPORT(171, void, png_set_sCAL_s, (png_const_structrp png_ptr,
  * to specifying "NEVER", however when "AS_DEFAULT" is used for specific chunks
  * it simply resets the behavior to the libpng default.
  *
- * INTERACTION WTIH USER CHUNK CALLBACKS:
  * The per-chunk handling is always used when there is a png_user_chunk_ptr
  * callback and the callback returns 0; the chunk is then always stored *unless*
  * it is critical and the per-chunk setting is other than ALWAYS.  Notice that
  * the global default is *not* used in this case.  (In effect the per-chunk
  * value is incremented to at least IF_SAFE.)
  *
- * IMPORTANT NOTE: this behavior will change in libpng 1.7 - the global and
- * per-chunk defaults will be honored.  If you want to preserve the current
- * behavior when your callback returns 0 you must set PNG_HANDLE_CHUNK_IF_SAFE
- * as the default - if you don't do this libpng 1.6 will issue a warning.
- *
- * If you want unhandled unknown chunks to be discarded in libpng 1.6 and
- * earlier simply return '1' (handled).
- *
  * PNG_HANDLE_AS_UNKNOWN_SUPPORTED:
  *    If this is *not* set known chunks will always be handled by libpng and
  *    will never be stored in the unknown chunk list.  Known chunks listed to
@@ -2418,7 +2544,7 @@ PNG_EXPORT(173, int, png_handle_as_unknown, (png_const_structrp png_ptr,
 #endif
 
 #ifdef PNG_STORE_UNKNOWN_CHUNKS_SUPPORTED
-PNG_EXPORT(174, void, png_set_unknown_chunks, (png_const_structrp png_ptr,
+PNG_EXPORT(174, void, png_set_unknown_chunks, (png_structrp png_ptr,
     png_inforp info_ptr, png_const_unknown_chunkp unknowns,
     int num_unknowns));
    /* NOTE: prior to 1.6.0 this routine set the 'location' field of the added
@@ -2641,28 +2767,26 @@ PNG_EXPORT(216, png_uint_32, png_get_io_chunk_type,
            * (png_uint_16)(alpha)                         \
            + (png_uint_16)(bg)*(png_uint_16)(255          \
            - (png_uint_16)(alpha)) + 128);                \
-       (composite) = (png_byte)(((temp + (temp >> 8)) >> 8) & 0xff); }
+       (composite) = (png_byte)((temp + (temp >> 8)) >> 8); }
 
 #  define png_composite_16(composite, fg, alpha, bg)       \
      { png_uint_32 temp = (png_uint_32)((png_uint_32)(fg)  \
            * (png_uint_32)(alpha)                          \
            + (png_uint_32)(bg)*(65535                      \
            - (png_uint_32)(alpha)) + 32768);               \
-       (composite) = (png_uint_16)(0xffff & ((temp + (temp >> 16)) >> 16)); }
+       (composite) = (png_uint_16)((temp + (temp >> 16)) >> 16); }
 
 #else  /* Standard method using integer division */
 
-#  define png_composite(composite, fg, alpha, bg)                        \
-     (composite) =                                                       \
-         (png_byte)(0xff & (((png_uint_16)(fg) * (png_uint_16)(alpha) +  \
-         (png_uint_16)(bg) * (png_uint_16)(255 - (png_uint_16)(alpha)) + \
-         127) / 255))
+#  define png_composite(composite, fg, alpha, bg)                          \
+     (composite) = (png_byte)(((png_uint_16)(fg) * (png_uint_16)(alpha) +  \
+     (png_uint_16)(bg) * (png_uint_16)(255 - (png_uint_16)(alpha)) +       \
+     127) / 255)
 
 #  define png_composite_16(composite, fg, alpha, bg)                         \
-     (composite) =                                                           \
-         (png_uint_16)(0xffff & (((png_uint_32)(fg) * (png_uint_32)(alpha) + \
-         (png_uint_32)(bg)*(png_uint_32)(65535 - (png_uint_32)(alpha)) +     \
-         32767) / 65535))
+     (composite) = (png_uint_16)(((png_uint_32)(fg) * (png_uint_32)(alpha) + \
+     (png_uint_32)(bg)*(png_uint_32)(65535 - (png_uint_32)(alpha)) +         \
+     32767) / 65535)
 #endif /* READ_COMPOSITE_NODIV */
 
 #ifdef PNG_READ_INT_FUNCTIONS_SUPPORTED
@@ -2694,27 +2818,18 @@ PNG_EXPORT(207, void, png_save_uint_16, (png_bytep buf, unsigned int i));
 
 #ifdef PNG_USE_READ_MACROS
 /* Inline macros to do direct reads of bytes from the input buffer.
- * The png_get_int_32() routine assumes we are using two's complement
- * format for negative values, which is almost certainly true.
  */
+#  define PNG_B(ptr, offset) (((png_const_bytep)(ptr))[offset])
 #  define PNG_get_uint_32(buf) \
-     (((png_uint_32)(*(buf)) << 24) + \
-      ((png_uint_32)(*((buf) + 1)) << 16) + \
-      ((png_uint_32)(*((buf) + 2)) << 8) + \
-      ((png_uint_32)(*((buf) + 3))))
+      PNG_U32(PNG_B(buf,0), PNG_B(buf,1), PNG_B(buf,2), PNG_B(buf,3))
 
    /* From libpng-1.4.0 until 1.4.4, the png_get_uint_16 macro (but not the
     * function) incorrectly returned a value of type png_uint_32.
     */
-#  define PNG_get_uint_16(buf) \
-     ((png_uint_16) \
-      (((unsigned int)(*(buf)) << 8) + \
-       ((unsigned int)(*((buf) + 1)))))
+#  define PNG_get_uint_16(buf) PNG_U16(PNG_B(buf,0), PNG_B(buf,1))
 
 #  define PNG_get_int_32(buf) \
-     ((png_int_32)((*(buf) & 0x80) \
-      ? -((png_int_32)((png_get_uint_32(buf) ^ 0xffffffffL) + 1)) \
-      : (png_int_32)png_get_uint_32(buf)))
+      PNG_S32(PNG_B(buf,0), PNG_B(buf,1), PNG_B(buf,2), PNG_B(buf,3))
 
    /* If PNG_PREFIX is defined the same thing as below happens in pnglibconf.h,
     * but defining a macro name prefixed with PNG_PREFIX.
@@ -2733,10 +2848,17 @@ PNG_EXPORT(207, void, png_save_uint_16, (png_bytep buf, unsigned int i));
 #  endif
 #endif
 
-#if defined(PNG_SIMPLIFIED_READ_SUPPORTED) || \
-    defined(PNG_SIMPLIFIED_WRITE_SUPPORTED)
+#ifdef PNG_CHECK_FOR_INVALID_INDEX_SUPPORTED
+PNG_EXPORT(242, void, png_set_check_for_invalid_index,
+    (png_structrp png_ptr, int allowed));
+#  ifdef PNG_GET_PALETTE_MAX_SUPPORTED
+PNG_EXPORT(243, int, png_get_palette_max, (png_const_structrp png_ptr,
+    png_const_inforp info_ptr));
+#  endif
+#endif /* CHECK_FOR_INVALID_INDEX */
+
 /*******************************************************************************
- *  SIMPLIFIED API
+ *  Section 5: SIMPLIFIED API
  *******************************************************************************
  *
  * Please read the documentation in libpng-manual.txt (TODO: write said
@@ -2752,9 +2874,8 @@ PNG_EXPORT(207, void, png_save_uint_16, (png_bytep buf, unsigned int i));
  *
  * To read a PNG file using the simplified API:
  *
- * 1) Declare a 'png_image' structure (see below) on the stack, set the
- *    version field to PNG_IMAGE_VERSION and the 'opaque' pointer to NULL
- *    (this is REQUIRED, your program may crash if you don't do it.)
+ * 1) Declare a 'png_image' structure (see below) on the stack and set the
+ *    version field to PNG_IMAGE_VERSION.
  * 2) Call the appropriate png_image_begin_read... function.
  * 3) Set the png_image 'format' member to the required sample format.
  * 4) Allocate a buffer for the image and, if required, the color-map.
@@ -3095,7 +3216,7 @@ PNG_EXPORT(235, int, png_image_begin_read_from_stdio, (png_imagep image,
 #endif /* STDIO */
 
 PNG_EXPORT(236, int, png_image_begin_read_from_memory, (png_imagep image,
-   png_const_voidp memory, png_size_t size));
+   png_const_voidp memory, size_t size));
    /* The PNG header is read from the given memory buffer. */
 
 PNG_EXPORT(237, int, png_image_finish_read, (png_imagep image,
@@ -3179,30 +3300,18 @@ PNG_EXPORT(240, int, png_image_write_to_stdio, (png_imagep image, FILE *file,
  *
  * With all APIs row_stride is handled as in the read APIs - it is the spacing
  * from one row to the next in component sized units (1 or 2 bytes) and if
- * negative indicates a bottom-up row layout in the buffer.  If row_stride is zero,
- * libpng will calculate it for you from the image width and number of channels.
+ * negative indicates a bottom-up row layout in the buffer.
  *
- * Note that the write API does not support interlacing, sub-8-bit pixels, indexed
- * PNG (color_type 3) or most ancillary chunks.
+ * Note that the write API does not support interlacing or sub-8-bit pixels.
  */
 #endif /* STDIO */
 #endif /* SIMPLIFIED_WRITE */
 /*******************************************************************************
  *  END OF SIMPLIFIED API
  ******************************************************************************/
-#endif /* SIMPLIFIED_{READ|WRITE} */
-
-#ifdef PNG_CHECK_FOR_INVALID_INDEX_SUPPORTED
-PNG_EXPORT(242, void, png_set_check_for_invalid_index,
-    (png_structrp png_ptr, int allowed));
-#  ifdef PNG_GET_PALETTE_MAX_SUPPORTED
-PNG_EXPORT(243, int, png_get_palette_max, (png_const_structp png_ptr,
-    png_const_infop info_ptr));
-#  endif
-#endif /* CHECK_FOR_INVALID_INDEX */
 
 /*******************************************************************************
- *  IMPLEMENTATION OPTIONS
+ * Section 6: IMPLEMENTATION OPTIONS
  *******************************************************************************
  *
  * Support for arbitrary implementation-specific optimizations.  The API allows
@@ -3238,18 +3347,20 @@ PNG_EXPORT(243, int, png_get_palette_max, (png_const_structp png_ptr,
 
 PNG_EXPORT(244, int, png_set_option, (png_structrp png_ptr, int option,
    int onoff));
-#endif /* SET_OPTION */
+#endif
 
 /*******************************************************************************
- *  END OF HARDWARE AND SOFTWARE OPTIONS
+ *  END OF HARDWARE OPTIONS
  ******************************************************************************/
 
-/* Maintainer: Put new public prototypes here ^, in libpng.3, in project
- * defs, and in scripts/symbols.def.
+/* Maintainer: Put new public prototypes here ^, in libpng.3, and project
+ * defs
  */
 
+
 /* The last ordinal number (this is the *last* one already used; the next
- * one to use is one more than this.)
+ * one to use is one more than this.)  Maintainer, remember to add an entry to
+ * scripts/symbols.def as well.
  */
 #ifdef PNG_EXPORT_LAST_ORDINAL
   PNG_EXPORT_LAST_ORDINAL(244);

pngconf.h

@@ -1,7 +1,7 @@
 
 /* pngconf.h - machine configurable file for libpng
  *
- * libpng version 1.6.18rc02, (PENDING RELEASE)
+ * libpng version 1.7.0beta64, July 26, 2015
  *
  * Copyright (c) 1998-2015 Glenn Randers-Pehrson
  * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
@@ -295,11 +295,11 @@
     * table entries, so we discard it here.  See the .dfn files in the
     * scripts directory.
     */
-
 #ifndef PNG_EXPORTA
-#  define PNG_EXPORTA(ordinal, type, name, args, attributes) \
-      PNG_FUNCTION(PNG_EXPORT_TYPE(type), (PNGAPI name), PNGARG(args), \
-      PNG_LINKAGE_API attributes)
+
+#  define PNG_EXPORTA(ordinal, type, name, args, attributes)\
+      PNG_FUNCTION(PNG_EXPORT_TYPE(type),(PNGAPI name),PNGARG(args), \
+        extern attributes)
 #endif
 
 /* ANSI-C (C90) does not permit a macro to be invoked with an empty argument,
@@ -307,7 +307,7 @@
  */
 #define PNG_EMPTY /*empty list*/
 
-#define PNG_EXPORT(ordinal, type, name, args) \
+#define PNG_EXPORT(ordinal, type, name, args)\
    PNG_EXPORTA(ordinal, type, name, args, PNG_EMPTY)
 
 /* Use PNG_REMOVED to comment out a removed interface. */
@@ -445,6 +445,14 @@
 #  define PNG_RESTRICT    /* The C99 "restrict" feature */
 #endif
 
+#ifndef PNG_FP_EXPORT     /* A floating point API. */
+#  ifdef PNG_FLOATING_POINT_SUPPORTED
+#     define PNG_FP_EXPORT(ordinal, type, name, args)\
+         PNG_EXPORT(ordinal, type, name, args);
+#  else                   /* No floating point APIs */
+#     define PNG_FP_EXPORT(ordinal, type, name, args)
+#  endif
+#endif
 #ifndef PNG_FP_EXPORT     /* A floating point API. */
 #  ifdef PNG_FLOATING_POINT_SUPPORTED
 #     define PNG_FP_EXPORT(ordinal, type, name, args)\
@@ -517,6 +525,8 @@
 
 /* Prior to 1.6.0 it was possible to disable the use of size_t, 1.6.0, however,
  * requires an ISOC90 compiler and relies on consistent behavior of sizeof.
+ *
+ * DEPRECATED: don't use these types, instead use size_t and ptrdiff_t.
  */
 typedef size_t png_size_t;
 typedef ptrdiff_t png_ptrdiff_t;
@@ -537,13 +547,13 @@ typedef ptrdiff_t png_ptrdiff_t;
 #  endif
 #endif
 
-/* png_alloc_size_t is guaranteed to be no smaller than png_size_t, and no
- * smaller than png_uint_32.  Casts from png_size_t or png_uint_32 to
+/* png_alloc_size_t is guaranteed to be no smaller than size_t, and no
+ * smaller than png_uint_32.  Casts from size_t or png_uint_32 to
  * png_alloc_size_t are not necessary; in fact, it is recommended not to use
  * them at all so that the compiler can complain when something turns out to be
  * problematic.
  *
- * Casts in the other direction (from png_alloc_size_t to png_size_t or
+ * Casts in the other direction (from png_alloc_size_t to size_t or
  * png_uint_32) should be explicitly applied; however, we do not expect to
  * encounter practical situations that require such conversions.
  *
@@ -553,7 +563,7 @@ typedef ptrdiff_t png_ptrdiff_t;
 #ifdef PNG_SMALL_SIZE_T
    typedef png_uint_32 png_alloc_size_t;
 #else
-   typedef png_size_t png_alloc_size_t;
+   typedef size_t png_alloc_size_t;
 #endif
 
 /* Prior to 1.6.0 libpng offered limited support for Microsoft C compiler
@@ -589,8 +599,8 @@ typedef char                  * png_charp;
 typedef const char            * png_const_charp;
 typedef png_fixed_point       * png_fixed_point_p;
 typedef const png_fixed_point * png_const_fixed_point_p;
-typedef png_size_t            * png_size_tp;
-typedef const png_size_t      * png_const_size_tp;
+typedef size_t                * png_size_tp;
+typedef const size_t          * png_const_size_tp;
 
 #ifdef PNG_STDIO_SUPPORTED
 typedef FILE            * png_FILE_p;

pngerror.c

@@ -1,8 +1,8 @@
 
 /* pngerror.c - stub functions for i/o and memory allocation
  *
- * Last changed in libpng 1.6.15 [November 20, 2014]
- * Copyright (c) 1998-2014 Glenn Randers-Pehrson
+ * Last changed in libpng 1.7.0 [(PENDING RELEASE)]
+ * Copyright (c) 1998-2015 Glenn Randers-Pehrson
  * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
  * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
  *
@@ -17,6 +17,7 @@
  */
 
 #include "pngpriv.h"
+#define PNG_SRC_FILE PNG_SRC_FILE_pngerror
 
 #if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)
 
@@ -44,7 +45,7 @@ png_error,(png_const_structrp png_ptr, png_const_charp error_message),
    if (png_ptr != NULL)
    {
       if ((png_ptr->flags &
-         (PNG_FLAG_STRIP_ERROR_NUMBERS|PNG_FLAG_STRIP_ERROR_TEXT)) != 0
+         (PNG_FLAG_STRIP_ERROR_NUMBERS|PNG_FLAG_STRIP_ERROR_TEXT)) != 0)
       {
          if (*error_message == PNG_LITERAL_SHARP)
          {
@@ -129,6 +130,7 @@ png_safecat(png_charp buffer, size_t bufsize, size_t pos,
  * and end pointer (which should point just *beyond* the end of the buffer!)
  * Returns the pointer to the start of the formatted string.
  */
+#define PNG_HAVE_FORMAT_NUMBER /* for the code below */
 png_charp
 png_format_number(png_const_charp start, png_charp end, int format,
    png_alloc_size_t number)
@@ -452,7 +454,7 @@ png_format_buffer(png_const_structrp png_ptr, png_charp buffer, png_const_charp
 
       else
       {
-         buffer[iout++] = (char)c;
+         buffer[iout++] = png_check_char(png_ptr, c);
       }
    }
 
@@ -567,7 +569,13 @@ png_chunk_report(png_const_structrp png_ptr, png_const_charp message, int error)
 }
 
 #ifdef PNG_ERROR_TEXT_SUPPORTED
-#ifdef PNG_FLOATING_POINT_SUPPORTED
+
+#if defined(PNG_FLOATING_POINT_SUPPORTED) && \
+   (defined(PNG_gAMA_SUPPORTED) || defined(PNG_cHRM_SUPPORTED) || \
+   defined(PNG_sCAL_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) || \
+   defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)) || \
+   (defined(PNG_FLOATING_ARITHMETIC_SUPPORTED) &&\
+   defined(PNG_sCAL_SUPPORTED))
 PNG_FUNCTION(void,
 png_fixed_error,(png_const_structrp png_ptr, png_const_charp name),PNG_NORETURN)
 {
@@ -641,9 +649,9 @@ png_set_longjmp_fn(png_structrp png_ptr, png_longjmp_ptr longjmp_fn,
             /* This is an internal error in libpng: somehow we have been left
              * with a stack allocated jmp_buf when the application regained
              * control.  It's always possible to fix this up, but for the moment
-             * this is a png_error because that makes it easy to detect.
+             * this is an affirm because that makes it easy to detect.
              */
-            png_error(png_ptr, "Libpng jmp_buf still allocated");
+            impossible("Libpng jmp_buf still allocated");
             /* png_ptr->jmp_buf_ptr = &png_ptr->jmp_buf_local; */
          }
       }
@@ -770,9 +778,13 @@ png_longjmp,(png_const_structrp png_ptr, int val),PNG_NORETURN)
     * choice is to terminate the whole process (or maybe the thread); to do
     * this the ANSI-C abort() function is used unless a different method is 
     * implemented by overriding the default configuration setting for
-    * PNG_ABORT().
+    * PNG_ABORT (see scripts/pnglibconf.dfa).
+    *
+    * API change: prior to 1.7.0 PNG_ABORT was invoked as a function type macro
+    * with no arguments 'PNG_ABORT();', in 1.7.0 this is changed to a simple
+    * macro that is defined in the configuration.
     */
-   PNG_ABORT();
+   PNG_ABORT
 }
 
 #ifdef PNG_WARNINGS_SUPPORTED
@@ -960,4 +972,246 @@ png_safe_execute(png_imagep image_in, int (*function)(png_voidp), png_voidp arg)
    return result;
 }
 #endif /* SIMPLIFIED READ || SIMPLIFIED_WRITE */
+
+/* Asserts: minimal code in 'STABLE' builds to return control to the
+ * application, more verbose code followed by abort for all other builds to
+ * ensure that internal errors are detected.
+ *
+ * The code always produces a message if it is possible, regardless of the
+ * setting of PNG_ERROR_TEXT_SUPPORTED, except that in stable builds
+ * PNG_ERROR_TEXT_SUPPORTED is honoured.  See pngpriv.h for the calculation of
+ * the two control macros PNG_RELEASE_BUILD (don't abort; stable build or rc)
+ * and PNG_AFFIRM_TEXT (output text.)
+ */
+#if PNG_AFFIRM_TEXT
+#  ifdef PNG_HAVE_FORMAT_NUMBER
+static size_t
+png_affirm_number(png_charp buffer, size_t bufsize, size_t pos,
+   unsigned int number, int format)
+{
+   char numbuf[PNG_NUMBER_BUFFER_SIZE];
+   return png_safecat(buffer, bufsize, pos,
+      png_format_number(numbuf, numbuf + sizeof numbuf, format, number));
+}
+#  define affirm_number(a,b,c,d,e) png_affirm_number(a,b,c,d,e)
+#  else /* !HAVE_FORMAT_NUMBER */
+static size_t
+png_affirm_number(png_charp buffer, size_t bufsize, size_t pos,
+   unsigned int number)
+{
+   /* binhex it; highly non-portable, assumes the ASCII character set, but
+    * if warnings are turned off then it is unlikely the text will get read
+    * anyway.  This binhex variant is (48+val), where 'val' is the next 6
+    * bits of the number, so it starts as '0' (for 0) and ends at 'I' for
+    * 63.  The number is wrapped in {}, so 0 comes out as '{}' and 9 comes
+    * out as '{9}' and so on.
+    */
+   char numbuf[32];
+   int i = sizeof numbuf;
+
+   numbuf[--i] = 0;
+   numbuf[--i] = '}';
+
+   do
+   {
+      if (number > 0)
+         numbuf[--i] = (char)/*SAFE*/((number & 63) + 48), number >>= 6;
+      else
+      {
+         numbuf[--i] = '{';
+         break;
+      }
+   }
+   while (i > 0);
+
+   return png_safecat(buffer, bufsize, pos, numbuf+i);
+}
+#  define affirm_number(a,b,c,d,e) png_affirm_number(a,b,c,d)
+#endif /* !HAVE_FORMAT_NUMBER */
+
+static void
+affirm_text(png_charp buffer, size_t bufsize,
+   param_deb(png_const_charp condition) unsigned int position)
+{
+  /* Format the 'position' number and output:
+   *
+   *  "<file> <line>: affirm 'condition' failed\n"
+   *  " libpng version <version> - <date>\n"
+   *  " translated __DATE__ __TIME__"
+   *
+   * In the STABLE versions the output is the same for the last two lines
+   * but the first line becomes:
+   *
+   *  "<position>: affirm failed"
+   *
+   * If there is no number formatting the numbers just get replaced by
+   * some binhex (see the utility above).
+   */
+  size_t pos = 0;
+
+# if PNG_RELEASE_BUILD /* no 'condition' parameter: minimal text */
+     pos = affirm_number(buffer, bufsize, pos, position, PNG_NUMBER_FORMAT_x);
+     pos = png_safecat(buffer, bufsize, pos, ": affirm failed");
+# else /* !STABLE */
+     /* Break down 'position' into a file name and a line number: */
+     {
+#        define PNG_apply(f) { #f "\0", PNG_SRC_FILE_ ## f },
+#        define PNG_end      { "", PNG_SRC_FILE_LAST }
+         static struct {
+             char         filename[28]; /* GCC checks this size */
+             unsigned int base;
+         } fileinfo[] = { PNG_FILES };
+#        undef PNG_apply
+#        undef PNG_end
+
+         unsigned int i;
+         png_const_charp filename;
+
+         /* Do 'nfiles' this way to avoid problems with g++ where it whines
+          * about (size_t) being larger than (int), even though this is a
+          * compile time constant:
+          */
+#        define nfiles ((sizeof fileinfo)/(sizeof (fileinfo[0])))
+         for (i=0; i < nfiles && position > fileinfo[i].base; ++i) {}
+
+         if (i == 0 || i > nfiles)
+             filename = "UNKNOWN";
+         else
+         {
+             filename = fileinfo[i-1].filename;
+             position -= fileinfo[i-1].base;
+         }
+#        undef nfiles
+
+         pos = png_safecat(buffer, bufsize, pos, filename);
+         pos = png_safecat(buffer, bufsize, pos, ".c ");
+         pos = affirm_number(buffer, bufsize, pos, position,
+            PNG_NUMBER_FORMAT_u);
+     }
+
+     pos = png_safecat(buffer, bufsize, pos, ": affirm '");
+     pos = png_safecat(buffer, bufsize, pos, condition);
+     pos = png_safecat(buffer, bufsize, pos, "' failed\n");
+# endif /* !STABLE */
+
+  pos = png_safecat(buffer, bufsize, pos, PNG_HEADER_VERSION_STRING);
+  pos = png_safecat(buffer, bufsize, pos,
+     " translated " __DATE__ " " __TIME__);
+}
+
+#define affirm_text(b, c, p)\
+   do {\
+      (affirm_text)(b, sizeof b, param_deb(c) (p));\
+   } while (0)
+
+#endif /* AFFIRM_TEXT */
+
+PNG_FUNCTION(void, png_affirm,(png_const_structrp png_ptr,
+   param_deb(png_const_charp condition) unsigned int position), PNG_NORETURN)
+{
+#  if PNG_AFFIRM_TEXT
+      char   buffer[512];
+
+      affirm_text(buffer, condition, position);
+#  else /* !AFFIRM_TEXT */
+      PNG_UNUSED(position)
+#     if !PNG_RELEASE_BUILD
+         PNG_UNUSED(condition)
+#     endif
+#  endif /* AFFIRM_TEXT */
+
+   /* Now in STABLE do a png_error, but in other builds output the message
+    * (if possible) then abort (PNG_ABORT).
+    */
+#  if PNG_RELEASE_BUILD
+      png_error(png_ptr, buffer/*macro parameter used only if ERROR_TEXT*/);
+#  else /* !AFFIRM_ERROR */
+      /* Use console IO if possible; this is because there is no guarantee that
+       * the app 'warning' will output anything.  For certain the simplified
+       * API implementation just copies the message (truncated) to the image
+       * message buffer, which makes debugging much more difficult.
+       *
+       * Note that it is possible that neither WARNINGS nor CONSOLE_IO are
+       * supported; in that case no text will be output (and PNG_AFFIRM_TEXT
+       * will be false.)
+       */
+#     ifdef PNG_CONSOLE_IO_SUPPORTED
+         fprintf(stderr, "%s\n", buffer);
+         PNG_UNUSED(png_ptr)
+#     elif defined PNG_WARNINGS_SUPPORTED
+         if (png_ptr != NULL && png_ptr->warning_fn != NULL)
+            png_ptr->warning_fn(png_constcast(png_structrp, png_ptr), buffer);
+         /* else no way to output the text */
+#     else
+         PNG_UNUSED(png_ptr)
+#     endif
+
+      PNG_ABORT
+#  endif /* AFFIRM_ERROR */
+}
+
+#ifdef PNG_RANGE_CHECK_SUPPORTED
+/* The character/byte checking APIs. These do their own calls to png_affirm
+ * because the caller provides the position.
+ */
+char /* PRIVATE */
+png_char_affirm(png_const_structrp png_ptr, unsigned int position, int c)
+{
+   if (c >= CHAR_MIN && c <= CHAR_MAX)
+       return (char)/*SAFE*/c;
+
+   png_affirm(png_ptr, param_deb("(char) range") position);
+}
+
+png_byte /* PRIVATE */
+png_byte_affirm(png_const_structrp png_ptr, unsigned int position, int b)
+{
+   /* For the type png_byte the limits.h values are ignored and we check
+    * against the values PNG expects to store in a byte:
+    */
+   if (b >= 0 && b <= 255)
+       return (png_byte)/*SAFE*/b;
+
+   png_affirm(png_ptr, param_deb("PNG byte range") position);
+}
+
+#if INT_MAX >= 65535
+png_uint_16 /* PRIVATE */
+png_u16_affirm(png_const_structrp png_ptr, unsigned int position, int b)
+{
+   /* Check against the PNG 16-bit limit, as with png_byte. */
+   if (b >= 0 && b <= 65535)
+       return (png_uint_16)/*SAFE*/b;
+
+   png_affirm(png_ptr, param_deb("PNG 16-bit range") position);
+}
+#endif /* INT_MAX >= 65535 */
+
+void /* PRIVATE */
+png_handled_affirm(png_const_structrp png_ptr, png_const_charp message,
+   unsigned int position)
+{
+#  if PNG_RELEASE_BUILD
+      /* testing in RC: we want to return control to the caller, so do not
+       * use png_affirm.
+       */
+      char   buffer[512];
+
+      affirm_text(buffer, message, position);
+
+#     ifdef PNG_CONSOLE_IO_SUPPORTED
+         fprintf(stderr, "%s\n", buffer);
+#     elif defined PNG_WARNINGS_SUPPORTED
+         if (png_ptr != NULL && png_ptr->warning_fn != NULL)
+            png_ptr->warning_fn(png_constcast(png_structrp, png_ptr), buffer);
+         /* else no way to output the text */
+#     else
+         PNG_UNUSED(png_ptr)
+#     endif
+#  else
+      png_affirm(png_ptr, message, position);
+#  endif
+}
+
+#endif /* RANGE_CHECK */
 #endif /* READ || WRITE */

pngget.c

@@ -1,7 +1,7 @@
 
 /* pngget.c - retrieval of values from info struct
  *
- * Last changed in libpng 1.6.17 [March 26, 2015]
+ * Last changed in libpng 1.7.0 [(PENDING RELEASE)]
  * Copyright (c) 1998-2015 Glenn Randers-Pehrson
  * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
  * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
@@ -13,6 +13,7 @@
  */
 
 #include "pngpriv.h"
+#define PNG_SRC_FILE PNG_SRC_FILE_pngget
 
 #if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)
 
@@ -365,14 +366,25 @@ png_get_y_pixels_per_inch(png_const_structrp png_ptr, png_const_inforp info_ptr)
 
 #ifdef PNG_FIXED_POINT_SUPPORTED
 static png_fixed_point
-png_fixed_inches_from_microns(png_const_structrp png_ptr, png_int_32 microns)
+png_fixed_inches_from_microns(png_const_structrp png_ptr,
+   png_int_32 microns)
 {
    /* Convert from metres * 1,000,000 to inches * 100,000, meters to
     * inches is simply *(100/2.54), so we want *(10/2.54) == 500/127.
     * Notice that this can overflow - a warning is output and 0 is
     * returned.
     */
-   return png_muldiv_warn(png_ptr, microns, 500, 127);
+   png_fixed_point result;
+
+   if (png_muldiv(&result, microns, 500, 127) != 0)
+      return result;
+
+   /* TODO: review this, png_error might be better. */
+   png_warning(png_ptr, "inch to microns overflow");
+   return 0;
+#  ifndef PNG_WARNINGS_SUPPORTED
+      PNG_UNUSED(png_ptr)
+#  endif
 }
 
 png_fixed_point PNGAPI
@@ -382,9 +394,7 @@ png_get_x_offset_inches_fixed(png_const_structrp png_ptr,
    return png_fixed_inches_from_microns(png_ptr,
        png_get_x_offset_microns(png_ptr, info_ptr));
 }
-#endif
 
-#ifdef PNG_FIXED_POINT_SUPPORTED
 png_fixed_point PNGAPI
 png_get_y_offset_inches_fixed(png_const_structrp png_ptr,
     png_const_inforp info_ptr)
@@ -392,7 +402,7 @@ png_get_y_offset_inches_fixed(png_const_structrp png_ptr,
    return png_fixed_inches_from_microns(png_ptr,
        png_get_y_offset_microns(png_ptr, info_ptr));
 }
-#endif
+#endif /* FIXED_POINT */
 
 #ifdef PNG_FLOATING_POINT_SUPPORTED
 float PNGAPI
@@ -884,9 +894,8 @@ png_get_pCAL(png_const_structrp png_ptr, png_inforp info_ptr,
 #endif
 
 #ifdef PNG_sCAL_SUPPORTED
-#  ifdef PNG_FIXED_POINT_SUPPORTED
-#    if defined(PNG_FLOATING_ARITHMETIC_SUPPORTED) || \
-         defined(PNG_FLOATING_POINT_SUPPORTED)
+#  ifdef PNG_FLOATING_ARITHMETIC_SUPPORTED
+#     ifdef PNG_FIXED_POINT_SUPPORTED
 png_uint_32 PNGAPI
 png_get_sCAL_fixed(png_const_structrp png_ptr, png_const_inforp info_ptr,
     int *unit, png_fixed_point *width, png_fixed_point *height)
@@ -907,9 +916,9 @@ png_get_sCAL_fixed(png_const_structrp png_ptr, png_const_inforp info_ptr,
 
    return(0);
 }
-#    endif /* FLOATING_ARITHMETIC */
-#  endif /* FIXED_POINT */
-#  ifdef PNG_FLOATING_POINT_SUPPORTED
+#     endif /* FIXED_POINT */
+
+#     ifdef PNG_FLOATING_POINT_SUPPORTED
 png_uint_32 PNGAPI
 png_get_sCAL(png_const_structrp png_ptr, png_const_inforp info_ptr,
     int *unit, double *width, double *height)
@@ -925,7 +934,9 @@ png_get_sCAL(png_const_structrp png_ptr, png_const_inforp info_ptr,
 
    return(0);
 }
-#  endif /* FLOATING POINT */
+#     endif /* FLOATING POINT */
+#  endif /* FLOATING_ARITHMETIC */
+
 png_uint_32 PNGAPI
 png_get_sCAL_s(png_const_structrp png_ptr, png_const_inforp info_ptr,
     int *unit, png_charpp width, png_charpp height)
@@ -1115,7 +1126,7 @@ png_get_unknown_chunks(png_const_structrp png_ptr, png_inforp info_ptr,
       return info_ptr->unknown_chunks_num;
    }
 
-   return (0);
+   return 0;
 }
 #endif
 
@@ -1123,7 +1134,9 @@ png_get_unknown_chunks(png_const_structrp png_ptr, png_inforp info_ptr,
 png_byte PNGAPI
 png_get_rgb_to_gray_status (png_const_structrp png_ptr)
 {
-   return (png_byte)(png_ptr ? png_ptr->rgb_to_gray_status : 0);
+   if (png_ptr)
+      return png_ptr->rgb_to_gray_status;
+   return 0;
 }
 #endif
 
@@ -1131,7 +1144,9 @@ png_get_rgb_to_gray_status (png_const_structrp png_ptr)
 png_voidp PNGAPI
 png_get_user_chunk_ptr(png_const_structrp png_ptr)
 {
-   return (png_ptr ? png_ptr->user_chunk_ptr : NULL);
+   if (png_ptr)
+      return png_ptr->user_chunk_ptr;
+   return NULL;
 }
 #endif
 
@@ -1206,7 +1221,7 @@ png_get_io_chunk_type (png_const_structrp png_ptr)
 #ifdef PNG_CHECK_FOR_INVALID_INDEX_SUPPORTED
 #  ifdef PNG_GET_PALETTE_MAX_SUPPORTED
 int PNGAPI
-png_get_palette_max(png_const_structp png_ptr, png_const_infop info_ptr)
+png_get_palette_max(png_const_structrp png_ptr, png_const_inforp info_ptr)
 {
    if (png_ptr != NULL && info_ptr != NULL)
       return png_ptr->num_palette_max;

pngmem.c

@@ -1,8 +1,8 @@
 
 /* pngmem.c - stub functions for memory allocation
  *
- * Last changed in libpng 1.6.15 [November 20, 2014]
- * Copyright (c) 1998-2014 Glenn Randers-Pehrson
+ * Last changed in libpng 1.7.0 [(PENDING RELEASE)]
+ * Copyright (c) 1998-2015 Glenn Randers-Pehrson
  * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
  * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
  *
@@ -18,6 +18,7 @@
  */
 
 #include "pngpriv.h"
+#define PNG_SRC_FILE PNG_SRC_FILE_pngmem
 
 #if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)
 /* Free a png_struct */
@@ -122,20 +123,17 @@ PNG_FUNCTION(png_voidp /* PRIVATE */,
 png_malloc_array,(png_const_structrp png_ptr, int nelements,
    size_t element_size),PNG_ALLOCATED)
 {
-   if (nelements <= 0 || element_size == 0)
-      png_error(png_ptr, "internal error: array alloc");
-
+   affirm(nelements > 0 && element_size > 0);
    return png_malloc_array_checked(png_ptr, nelements, element_size);
 }
 
 PNG_FUNCTION(png_voidp /* PRIVATE */,
-png_realloc_array,(png_const_structrp png_ptr, png_const_voidp old_array,
+png_realloc_array,(png_structrp png_ptr, png_const_voidp old_array,
    int old_elements, int add_elements, size_t element_size),PNG_ALLOCATED)
 {
    /* These are internal errors: */
-   if (add_elements <= 0 || element_size == 0 || old_elements < 0 ||
-      (old_array == NULL && old_elements > 0))
-      png_error(png_ptr, "internal error: array realloc");
+   affirm(add_elements > 0 && element_size > 0 && old_elements >= 0 &&
+      (old_array != NULL || old_elements == 0));
 
    /* Check for overflow on the elements count (so the caller does not have to
     * check.)
@@ -160,6 +158,15 @@ png_realloc_array,(png_const_structrp png_ptr, png_const_voidp old_array,
       }
    }
 
+#ifdef PNG_READ_SUPPORTED
+# ifdef PNG_USER_LIMITS_SUPPORTED
+   /* The potential overflow case.  Set the cache counter so libpng will
+    * not make any more attempts
+    */
+   png_ptr->user_chunk_cache_max = 2;
+# endif
+#endif
+
    return NULL; /* error */
 }
 #endif /* TEXT || sPLT || STORE_UNKNOWN_CHUNKS */
@@ -179,31 +186,11 @@ png_malloc,(png_const_structrp png_ptr, png_alloc_size_t size),PNG_ALLOCATED)
    ret = png_malloc_base(png_ptr, size);
 
    if (ret == NULL)
-       png_error(png_ptr, "Out of memory"); /* 'm' means png_malloc */
+       png_error(png_ptr, "Out of memory");
 
    return ret;
 }
 
-#ifdef PNG_USER_MEM_SUPPORTED
-PNG_FUNCTION(png_voidp,PNGAPI
-png_malloc_default,(png_const_structrp png_ptr, png_alloc_size_t size),
-   PNG_ALLOCATED PNG_DEPRECATED)
-{
-   png_voidp ret;
-
-   if (png_ptr == NULL)
-      return NULL;
-
-   /* Passing 'NULL' here bypasses the application provided memory handler. */
-   ret = png_malloc_base(NULL/*use malloc*/, size);
-
-   if (ret == NULL)
-      png_error(png_ptr, "Out of Memory"); /* 'M' means png_malloc_default */
-
-   return ret;
-}
-#endif /* USER_MEM */
-
 /* This function was added at libpng version 1.2.3.  The png_malloc_warn()
  * function will issue a png_warning and return NULL instead of issuing a
  * png_error, if it fails to allocate the requested memory.
@@ -239,17 +226,8 @@ png_free(png_const_structrp png_ptr, png_voidp ptr)
       png_ptr->free_fn(png_constcast(png_structrp,png_ptr), ptr);
 
    else
-      png_free_default(png_ptr, ptr);
-}
-
-PNG_FUNCTION(void,PNGAPI
-png_free_default,(png_const_structrp png_ptr, png_voidp ptr),PNG_DEPRECATED)
-{
-   if (png_ptr == NULL || ptr == NULL)
-      return;
 #endif /* USER_MEM */
-
-   free(ptr);
+      free(ptr);
 }
 
 #ifdef PNG_USER_MEM_SUPPORTED

pngpread.c

@@ -1,7 +1,7 @@
 
 /* pngpread.c - read a png file in push mode
  *
- * Last changed in libpng 1.6.18 [(PENDING RELEASE)]
+ * Last changed in libpng 1.7.0 [(PENDING RELEASE)]
  * Copyright (c) 1998-2015 Glenn Randers-Pehrson
  * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
  * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
@@ -12,6 +12,7 @@
  */
 
 #include "pngpriv.h"
+#define PNG_SRC_FILE PNG_SRC_FILE_pngpread
 
 #ifdef PNG_PROGRESSIVE_READ_SUPPORTED
 
@@ -77,11 +78,11 @@ png_process_data_pause(png_structrp png_ptr, int save)
 png_uint_32 PNGAPI
 png_process_data_skip(png_structrp png_ptr)
 {
-  /* TODO: Deprecate and remove this API.
-   * Somewhere the implementation of this seems to have been lost,
-   * or abandoned.  It was only to support some internal back-door access
-   * to png_struct) in libpng-1.4.x.
-   */
+    /* TODO: Deprecate and remove this API.
+     * Somewhere the implementation of this seems to have been lost,
+     * or abandoned.  It was only to support some internal back-door access
+     * to png_struct) in libpng-1.4.x.
+     */
    png_app_warning(png_ptr,
 "png_process_data_skip is not implemented in any current version of libpng");
    return 0;
@@ -133,17 +134,16 @@ png_process_some_data(png_structrp png_ptr, png_inforp info_ptr)
 void /* PRIVATE */
 png_push_read_sig(png_structrp png_ptr, png_inforp info_ptr)
 {
-   png_size_t num_checked = png_ptr->sig_bytes, /* SAFE, does not exceed 8 */ 
-       num_to_check = 8 - num_checked;
+   unsigned int num_checked = png_ptr->sig_bytes;
+   unsigned int num_to_check = 8 - num_checked;
 
    if (png_ptr->buffer_size < num_to_check)
-   {
-      num_to_check = png_ptr->buffer_size;
-   }
+      num_to_check = (int)/*SAFE*/png_ptr->buffer_size;
 
    png_push_fill_buffer(png_ptr, &(info_ptr->signature[num_checked]),
        num_to_check);
-   png_ptr->sig_bytes = (png_byte)(png_ptr->sig_bytes + num_to_check);
+   png_ptr->sig_bytes = png_check_byte(png_ptr,
+       png_ptr->sig_bytes + num_to_check);
 
    if (png_sig_cmp(info_ptr->signature, num_checked, num_to_check))
    {
@@ -167,7 +167,7 @@ void /* PRIVATE */
 png_push_read_chunk(png_structrp png_ptr, png_inforp info_ptr)
 {
    png_uint_32 chunk_name;
-#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED
+#ifdef PNG_SET_UNKNOWN_CHUNKS_SUPPORTED
    int keep; /* unknown handling method */
 #endif
 
@@ -218,7 +218,7 @@ png_push_read_chunk(png_structrp png_ptr, png_inforp info_ptr)
             return;
 
       if ((png_ptr->mode & PNG_AFTER_IDAT) != 0)
-         png_benign_error(png_ptr, "Too many IDATs found");
+         png_benign_error(png_ptr, "Too many IDATs found[p]");
    }
 
    if (chunk_name == png_IHDR)
@@ -239,7 +239,7 @@ png_push_read_chunk(png_structrp png_ptr, png_inforp info_ptr)
       png_push_have_end(png_ptr, info_ptr);
    }
 
-#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED
+#ifdef PNG_SET_UNKNOWN_CHUNKS_SUPPORTED
    else if ((keep = png_chunk_unknown_handling(png_ptr, chunk_name)) != 0)
    {
       PNG_PUSH_SAVE_BUFFER_IF_FULL
@@ -606,7 +606,6 @@ png_push_read_IDAT(png_structrp png_ptr)
       png_ptr->current_buffer_size -= save_size;
       png_ptr->current_buffer_ptr += save_size;
    }
-
    if (png_ptr->idat_size == 0)
    {
       PNG_PUSH_SAVE_BUFFER_IF_LT(4)
@@ -622,8 +621,7 @@ png_process_IDAT_data(png_structrp png_ptr, png_bytep buffer,
    png_size_t buffer_length)
 {
    /* The caller checks for a non-zero buffer length. */
-   if (!(buffer_length > 0) || buffer == NULL)
-      png_error(png_ptr, "No IDAT data (internal error)");
+   affirm(buffer_length > 0 && buffer != NULL);
 
    /* This routine must process all the data it has been given
     * before returning, calling the row callback as required to

pngpriv.h

@@ -1,7 +1,7 @@
 
 /* pngpriv.h - private declarations for use inside libpng
  *
- * Last changed in libpng 1.6.18 [(PENDING RELEASE)]
+ * Last changed in libpng 1.7.0 [(PENDING RELEASE)]
  * Copyright (c) 1998-2015 Glenn Randers-Pehrson
  * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
  * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
@@ -38,10 +38,17 @@
 #define _POSIX_SOURCE 1 /* Just the POSIX 1003.1 and C89 APIs */
 
 #ifndef PNG_VERSION_INFO_ONLY
+/* Keep standard libraries at the top of this file */
+
 /* Standard library headers not required by png.h: */
 #  include <stdlib.h>
 #  include <string.h>
-#endif
+
+/* For headers only required with some build configurations see the lines after
+ * pnglibconf.h is included!
+ */
+
+#endif /* VERSION_INFO_ONLY */
 
 #define PNGLIB_BUILD /*libpng is being built, not used*/
 
@@ -86,6 +93,36 @@
 #  endif
 #endif
 
+#ifndef PNG_VERSION_INFO_ONLY
+/* Additional standard libaries required in certain cases, put only standard
+ * ANSI-C89 headers here.  If not available, or non-functional, the problem
+ * should be fixed by writing a wrapper for the header and the file on your
+ * include path.
+ */
+#if defined(PNG_sCAL_SUPPORTED) && defined(PNG_FLOATING_POINT_SUPPORTED)
+   /* png.c requires the following ANSI-C constants if the conversion of
+    * floating point to ASCII is implemented therein:
+    *
+    *  DBL_MIN_10_EXP Minimum negative integer such that 10^integer is a
+    *                 normalized (double) value.
+    *  DBL_DIG  Maximum number of decimal digits (can be set to any constant)
+    *  DBL_MIN  Smallest normalized fp number (can be set to an arbitrary value)
+    *  DBL_MAX  Maximum floating point number (can be set to an arbitrary value)
+    */
+#  include <float.h>
+#endif /* sCAL && FLOATING_POINT */
+
+#if defined(PNG_FLOATING_ARITHMETIC_SUPPORTED) ||\
+   defined(PNG_FLOATING_POINT_SUPPORTED)
+   /* ANSI-C90 math functions are required.  Full compliance with the standard
+    * is probably not a requirement, but the functions must exist and be
+    * declared in <math.h>
+    */
+#  include <math.h>
+#endif /* FLOATING_ARITHMETIC || FLOATING_POINT */
+
+#endif /* VERSION_INFO_ONLY */
+
 /* Compile time options.
  * =====================
  * In a multi-arch build the compiler may compile the code several times for the
@@ -99,7 +136,7 @@
  * NOTE: symbol prefixing does not pass $(CFLAGS) to the preprocessor, because
  * this is not possible with certain compilers (Oracle SUN OS CC), as a result
  * it is necessary to ensure that all extern functions that *might* be used
- * regardless of $(CFLAGS) get declared in this file.  The test on __ARM_NEON__
+ * regardless of $(CFLAGS) get declared in this file.  The test on __ARM_NEON
  * below is one example of this behavior because it is controlled by the
  * presence or not of -mfpu=neon on the GCC command line, it is possible to do
  * this in $(CC), e.g. "CC=gcc -mfpu=neon", but people who build libpng rarely
@@ -107,10 +144,10 @@
  */
 #ifndef PNG_ARM_NEON_OPT
    /* ARM NEON optimizations are being controlled by the compiler settings,
-    * typically the target FPU.  If the FPU has been set to NEON (-mfpu=neon
-    * with GCC) then the compiler will define __ARM_NEON__ and we can rely
-    * unconditionally on NEON instructions not crashing, otherwise we must
-    * disable use of NEON instructions.
+    * typically the target FPU.  If the FPU supports NEON instructions then the
+    * compiler will define __ARM_NEON and we can rely unconditionally on NEON
+    * instructions not crashing, otherwise we must disable use of NEON
+    * instructions.
     *
     * NOTE: at present these optimizations depend on 'ALIGNED_MEMORY', so they
     * can only be turned on automatically if that is supported too.  If
@@ -118,15 +155,16 @@
     * to compile with an appropriate #error if ALIGNED_MEMORY has been turned
     * off.
     *
-    * Note that gcc-4.9 defines __ARM_NEON instead of the deprecated
-    * __ARM_NEON__, so we check both variants.
+    * Note that older versions of GCC defined __ARM_NEON__; this is no longer
+    * supported.  Also 32-bit ARM versions of GCC required the NEON FPU mode to
+    * be turned on explicitly on the command line.  If this is not done (on
+    * 32-bit ARM) NEON code will not be included.
     *
     * To disable ARM_NEON optimizations entirely, and skip compiling the
     * associated assembler code, pass --enable-arm-neon=no to configure
     * or put -DPNG_ARM_NEON_OPT=0 in CPPFLAGS.
     */
-#  if (defined(__ARM_NEON__) || defined(__ARM_NEON)) && \
-   defined(PNG_ALIGNED_MEMORY_SUPPORTED)
+#  if defined(__ARM_NEON) && defined(PNG_ALIGNED_MEMORY_SUPPORTED)
 #     define PNG_ARM_NEON_OPT 2
 #  else
 #     define PNG_ARM_NEON_OPT 0
@@ -140,12 +178,12 @@
 #  define PNG_FILTER_OPTIMIZATIONS png_init_filter_functions_neon
 
    /* By default the 'intrinsics' code in arm/filter_neon_intrinsics.c is used
-    * if possible - if __ARM_NEON__ is set and the compiler version is not known
+    * if possible - if __ARM_NEON is set and the compiler version is not known
     * to be broken.  This is controlled by PNG_ARM_NEON_IMPLEMENTATION which can
     * be:
     *
-    *    1  The intrinsics code (the default with __ARM_NEON__)
-    *    2  The hand coded assembler (the default without __ARM_NEON__)
+    *    1  The intrinsics code (the default with __ARM_NEON)
+    *    2  The hand coded assembler (the default without __ARM_NEON)
     *
     * It is possible to set PNG_ARM_NEON_IMPLEMENTATION in CPPFLAGS, however
     * this is *NOT* supported and may cease to work even after a minor revision
@@ -154,7 +192,7 @@
     * libpng implementation list for incorporation in the next minor release.
     */
 #  ifndef PNG_ARM_NEON_IMPLEMENTATION
-#     if defined(__ARM_NEON__) || defined(__ARM_NEON)
+#     ifdef __ARM_NEON
 #        if defined(__clang__)
             /* At present it is unknown by the libpng developers which versions
              * of clang support the intrinsics, however some or perhaps all
@@ -170,11 +208,12 @@
 #           endif /* no GNUC support */
 #        endif /* __GNUC__ */
 #     else /* !defined __ARM_NEON__ */
-         /* The 'intrinsics' code simply won't compile without this -mfpu=neon:
+         /* The 'intrinsics' code simply won't compile without compiler support
+          * and that support switches on __ARM_NEON, so use the assembler:
           */
 #        define PNG_ARM_NEON_IMPLEMENTATION 2
 #     endif /* __ARM_NEON__ */
-#  endif /* !PNG_ARM_NEON_IMPLEMENTATION */
+#  endif /* !defined PNG_ARM_NEON_IMPLEMENTATION */
 
 #  ifndef PNG_ARM_NEON_IMPLEMENTATION
       /* Use the intrinsics code by default. */
@@ -252,18 +291,17 @@
  * always be used to declare an extern data or function object in this file.
  */
 #ifndef PNG_INTERNAL_DATA
-#  define PNG_INTERNAL_DATA(type, name, array) PNG_LINKAGE_DATA type name array
+#  define PNG_INTERNAL_DATA(type, name, array) extern type name array
 #endif
 
 #ifndef PNG_INTERNAL_FUNCTION
 #  define PNG_INTERNAL_FUNCTION(type, name, args, attributes)\
-      PNG_LINKAGE_FUNCTION PNG_FUNCTION(type, name, args, PNG_EMPTY attributes)
+      extern PNG_FUNCTION(type, name, args, PNG_EMPTY attributes)
 #endif
 
 #ifndef PNG_INTERNAL_CALLBACK
 #  define PNG_INTERNAL_CALLBACK(type, name, args, attributes)\
-      PNG_LINKAGE_CALLBACK PNG_FUNCTION(type, (PNGCBAPI name), args,\
-         PNG_EMPTY attributes)
+      extern PNG_FUNCTION(type, (PNGCBAPI name), args, PNG_EMPTY attributes)
 #endif
 
 /* If floating or fixed point APIs are disabled they may still be compiled
@@ -294,6 +332,9 @@
 #  endif
 #endif
 
+/* Include png.h here to get the version info and other macros, pngstruct.h and
+ * pnginfo.h are included later under the protection of !PNG_VERSION_INFO_ONLY
+ */
 #include "png.h"
 
 /* pngconf.h does not set PNG_DLL_EXPORT unless it is required, so: */
@@ -317,6 +358,198 @@
 #  define PNG_RELEASE_BUILD (PNG_LIBPNG_BUILD_BASE_TYPE >= PNG_LIBPNG_BUILD_RC)
 #endif
 
+/* General purpose macros avoid the need to put #if PNG_RELEASE_BUILD
+ * macro blocks around function declarations and definitions when the
+ * parameter number varies.  Using these results in slightly cleaner code.
+ */
+#if PNG_RELEASE_BUILD
+#  define only_rel(text) text
+#  define only_deb(text)
+#  define param_rel(param) param,
+#  define param_deb(param)
+#else
+#  define only_rel(text)
+#  define only_deb(text) text
+#  define param_rel(param)
+#  define param_deb(param) param,
+#endif
+
+/* The affirm mechanism results in a minimal png_error in released versions
+ * ('STABLE' versions) and a more descriptive abort in all other cases.
+ *
+ * The PNG_RELEASE_BUILD macro, defined above, controls the behavior of
+ * 'affirm': if set to 1 affirm will call png_error (or png_err) rather than
+ * abort.  The png_error text is the minimal (file location) text in this case,
+ * if it is produced. This flag indicates a STABLE (or RC) build.
+ *
+ * The macros rely on the naming convention throughout this code - png_ptr
+ * exists and is of type png_const_structrp or a compatible type - and the
+ * presence in each file of a uniquely defined macro PNG_SRC_FILE; a number
+ * indicating which file this is (this is to save space in released versions).
+ *
+ * 'affirm' is intended to look like the ANSI-C <assert.h> macro; note that
+ * this macro can coexist with the assert macro if <assert.h> is
+ * included.
+ *
+ * PNG_SRC_LINE is the position of the affirm macro.  There are currently 15
+ * main source files (4 bits) and the biggest (pngrtran.c) has more than 4095
+ * lines (12 bits).  However, to ensure the number will fit into 16-bits in the
+ * future and to allow hardware files to use affirm, the encoding is a bit-wise
+ * encoding based on the current number of lines.
+ *
+ * 'debug' is a version of 'affirm' that is completely removed from RELEASE
+ * builds.  This is used when either an unexpected condition is completely
+ * handled or when it can't be handled even by png_error, for example after a
+ * memory overwrite.
+ *
+ * UNTESTED is used to mark code that has not been tested; it causes an assert
+ * if the code is executed and (therefore) tested.  UNTESTED should not remain
+ * in release candidate code.
+ *
+ * PNG_AFFIRM_TEXT is set to 1 if affirm text should be produced, either
+ * the minimal text or, if PNG_RELEASE_BUILD is 0, the more verbose text
+ * including the 'condition' string.  This value depends on whether the
+ * build supports an appropriate way of outputting the message.
+ *
+ * Note that PNG_AFFIRM_TEXT is not configurable but is worked out here: this
+ * is just the affirm code; * there's no reason to allow configuration of this
+ * option.
+ */
+#define PNG_AFFIRM_TEXT (PNG_RELEASE_BUILD ?\
+         (defined PNG_ERROR_TEXT_SUPPORTED) :\
+         (defined PNG_WARNINGS_SUPPORTED) || (defined PNG_CONSOLE_IO_SUPPORTED))
+
+#define PNG_SRC_LINE (PNG_SRC_FILE + __LINE__)
+
+/* png_affirmpp and png_impossiblepp are macros to make the correct call to the
+ * png_affirm function; these macros do not assume that the png_structp is
+ * called png_ptr.
+ */
+#if PNG_RELEASE_BUILD
+#  define png_affirmpp(pp, cond)\
+      do\
+         if (!(cond)) png_affirm(pp, PNG_SRC_LINE);\
+      while (0)
+#  define png_impossiblepp(pp, reason) png_affirm(pp, PNG_SRC_LINE)
+
+#  define debug(cond) do {} while (0)
+#  if PNG_LIBPNG_BUILD_BASE_TYPE >= PNG_LIBPNG_BUILD_RC
+     /* Make sure there are no 'UNTESTED' macros in released code: */
+#    define UNTESTED libpng untested code
+#  endif
+#else
+#  define png_affirmpp(pp, cond)\
+      do\
+         if (!(cond)) png_affirm(pp, #cond, PNG_SRC_LINE);\
+      while (0)
+#  define png_impossiblepp(pp, reason) png_affirm(pp, reason, PNG_SRC_LINE)
+
+#  define debug(cond) png_affirmpp(png_ptr, cond)
+#  define UNTESTED png_affirm(png_ptr, "untested code", PNG_SRC_LINE);
+#endif
+
+#define affirm(cond) png_affirmpp(png_ptr, cond)
+#define impossible(cond) png_impossiblepp(png_ptr, cond)
+
+/* The defines for PNG_SRC_FILE: */
+#define PNG_SRC_FILE_(f,lines) PNG_SRC_FILE_ ## f + lines
+
+#define PNG_SRC_FILE_png      0
+#define PNG_SRC_FILE_pngerror (PNG_SRC_FILE_png      +8192)
+#define PNG_SRC_FILE_pngget   (PNG_SRC_FILE_pngerror +2048)
+#define PNG_SRC_FILE_pngmem   (PNG_SRC_FILE_pngget   +2048)
+#define PNG_SRC_FILE_pngpread (PNG_SRC_FILE_pngmem   +1024)
+#define PNG_SRC_FILE_pngread  (PNG_SRC_FILE_pngpread +2048)
+#define PNG_SRC_FILE_pngrio   (PNG_SRC_FILE_pngread  +8192)
+#define PNG_SRC_FILE_pngrtran (PNG_SRC_FILE_pngrio   +1024)
+#define PNG_SRC_FILE_pngrutil (PNG_SRC_FILE_pngrtran +8192)
+#define PNG_SRC_FILE_pngset   (PNG_SRC_FILE_pngrutil +8192)
+#define PNG_SRC_FILE_pngtrans (PNG_SRC_FILE_pngset   +2048)
+#define PNG_SRC_FILE_pngwio   (PNG_SRC_FILE_pngtrans +2048)
+#define PNG_SRC_FILE_pngwrite (PNG_SRC_FILE_pngwio   +1024)
+#define PNG_SRC_FILE_pngwtran (PNG_SRC_FILE_pngwrite +4096)
+#define PNG_SRC_FILE_pngwutil (PNG_SRC_FILE_pngwtran +1024)
+
+#define PNG_SRC_FILE_arm_arm_init (PNG_SRC_FILE_pngwutil +4096)
+#define PNG_SRC_FILE_arm_filter_neon_intrinsics\
+             (PNG_SRC_FILE_arm_arm_init +1024)
+
+/* Add new files by changing the following line: */
+#define PNG_SRC_FILE_LAST (PNG_SRC_FILE_arm_filter_neon_intrinsics +1024)
+
+/* The following #define must list the files in exactly the same order as
+ * the above.
+ */
+#define PNG_FILES\
+   PNG_apply(png)\
+   PNG_apply(pngerror)\
+   PNG_apply(pngget)\
+   PNG_apply(pngmem)\
+   PNG_apply(pngpread)\
+   PNG_apply(pngread)\
+   PNG_apply(pngrio)\
+   PNG_apply(pngrtran)\
+   PNG_apply(pngrutil)\
+   PNG_apply(pngset)\
+   PNG_apply(pngtrans)\
+   PNG_apply(pngwio)\
+   PNG_apply(pngwrite)\
+   PNG_apply(pngwtran)\
+   PNG_apply(pngwutil)\
+   PNG_apply(arm_arm_init)\
+   PNG_apply(arm_filter_neon_intrinsics)\
+   PNG_end
+
+/* GCC complains about assignments of an (int) expression to a (char) even when
+ * it can readily determine that the value is in range.  This makes arithmetic
+ * on (char) or (png_byte) values tedious.  The warning is not issued by
+ * default, but libpng coding rules require no warnings leading to excessive,
+ * ridiculous and dangerous expressions of the form:
+ *
+ *     <char> = (char)(expression & 0xff)
+ *
+ * They are dangerous because they hide the warning, which might actually be
+ * valid, and therefore merely enable introduction of undetected overflows when
+ * code is modified.
+ *
+ * The following macros exist to reliably detect any overflow in non-release
+ * builds.  The theory here is that we really want to know about overflows, not
+ * merely hide a basically flawed compiler warning by throwing unnecessary casts
+ * into the code.  The warnings disappear in RC builds so that the released
+ * (STABLE) version just assigns the value (with, possibly, a warning if someone
+ * turns on the -Wconversion GCC warning.)
+ *
+ * Doing it this way ensures that the code meets two very important aims:
+ *
+ * 1) Overflows are detected in pre-release tests; previously versions of libpng
+ *    have been released that really did have overflows in the RGB calculations.
+ * 2) In release builds GCC specific operations, which may reduce the ability
+ *    of other compilers and even GCC to optimize the code, are avoided.
+ *
+ * There is one important extra consequence for pre-release code; it is
+ * performing a lot of checks in pixel arithmetic that the release code won't
+ * perform.  As a consequence a build time option, RANGE_CHECK, is provided
+ * to allow the checks to be turned off in pre-release when building for
+ * performance testing.  This is a standard "_SUPPORTED" option except that it
+ * cannot be set in the system configuration (pnglibconf.h, pnglibconf.dfa).
+ *
+ * A separate macro PNG_BYTE() is provided to safely convert an unsigned value
+ * to the PNG byte range 0..255.  This handles the fact that, technically,
+ * an ANSI-C (unsigned char), hence a (png_byte), may be able to store values
+ * outside this range.  Note that if you are building on a system where this is
+ * true libpng is almost certainly going to produce errors; it has never been
+ * tested on such a system.  For the moment pngconf.h ensures that this will
+ * not happen.
+ *
+ * PNG_UINT_16 does the same thing for a 16-bit value passed in an (int) or
+ * (png_uint_32) (where checking is not expected.)
+ */
+#if !PNG_RELEASE_BUILD
+#  ifndef PNG_NO_RANGE_CHECK /* Turn off even in pre-release */
+#     define PNG_RANGE_CHECK_SUPPORTED
+#  endif
+#endif
+
 /* SECURITY and SAFETY:
  *
  * libpng is built with support for internal limits on image dimensions and
@@ -349,6 +582,11 @@
 #  define PNG_UNUSED(param) (void)param;
 #endif
 
+/* This is a convenience for parameters which are not used in release
+ * builds.
+ */
+#define PNG_UNUSEDRC(param) only_rel(PNG_UNUSED(param))
+
 /* Just a little check that someone hasn't tried to define something
  * contradictory.
  */
@@ -381,6 +619,7 @@
  */
 #ifdef __cplusplus
 #  define png_voidcast(type, value) static_cast<type>(value)
+#  define png_upcast(type, value) static_cast<type>(value)
 #  define png_constcast(type, value) const_cast<type>(value)
 #  define png_aligncast(type, value) \
    static_cast<type>(static_cast<void*>(value))
@@ -388,6 +627,7 @@
    static_cast<type>(static_cast<const void*>(value))
 #else
 #  define png_voidcast(type, value) (value)
+#  define png_upcast(type, value) ((type)(value))
 #  define png_constcast(type, value) ((type)(value))
 #  define png_aligncast(type, value) ((void*)(value))
 #  define png_aligncastconst(type, value) ((const void*)(value))
@@ -403,67 +643,6 @@
 #  define PNGFAPI /* PRIVATE */
 #endif
 
-#ifndef PNG_VERSION_INFO_ONLY
-/* Other defines specific to compilers can go here.  Try to keep
- * them inside an appropriate ifdef/endif pair for portability.
- */
-#if defined(PNG_FLOATING_POINT_SUPPORTED) ||\
-    defined(PNG_FLOATING_ARITHMETIC_SUPPORTED)
-   /* png.c requires the following ANSI-C constants if the conversion of
-    * floating point to ASCII is implemented therein:
-    *
-    *  DBL_DIG  Maximum number of decimal digits (can be set to any constant)
-    *  DBL_MIN  Smallest normalized fp number (can be set to an arbitrary value)
-    *  DBL_MAX  Maximum floating point number (can be set to an arbitrary value)
-    */
-#  include <float.h>
-
-#  if (defined(__MWERKS__) && defined(macintosh)) || defined(applec) || \
-    defined(THINK_C) || defined(__SC__) || defined(TARGET_OS_MAC)
-     /* We need to check that <math.h> hasn't already been included earlier
-      * as it seems it doesn't agree with <fp.h>, yet we should really use
-      * <fp.h> if possible.
-      */
-#    if !defined(__MATH_H__) && !defined(__MATH_H) && !defined(__cmath__)
-#      include <fp.h>
-#    endif
-#  else
-#    include <math.h>
-#  endif
-#  if defined(_AMIGA) && defined(__SASC) && defined(_M68881)
-     /* Amiga SAS/C: We must include builtin FPU functions when compiling using
-      * MATH=68881
-      */
-#    include <m68881.h>
-#  endif
-#endif
-
-/* This provides the non-ANSI (far) memory allocation routines. */
-#if defined(__TURBOC__) && defined(__MSDOS__)
-#  include <mem.h>
-#  include <alloc.h>
-#endif
-
-#if defined(WIN32) || defined(_Windows) || defined(_WINDOWS) || \
-    defined(_WIN32) || defined(__WIN32__)
-#  include <windows.h>  /* defines _WINDOWS_ macro */
-#endif
-#endif /* PNG_VERSION_INFO_ONLY */
-
-/* Moved here around 1.5.0beta36 from pngconf.h */
-/* Users may want to use these so they are not private.  Any library
- * functions that are passed far data must be model-independent.
- */
-
-/* Memory model/platform independent fns */
-#ifndef PNG_ABORT
-#  ifdef _WINDOWS_
-#    define PNG_ABORT() ExitProcess(0)
-#  else
-#    define PNG_ABORT() abort()
-#  endif
-#endif
-
 /* These macros may need to be architecture dependent. */
 #define PNG_ALIGN_NONE   0 /* do not use data alignment */
 #define PNG_ALIGN_ALWAYS 1 /* assume unaligned accesses are OK */
@@ -532,7 +711,7 @@
 #define PNG_HAVE_CHUNK_HEADER      0x100
 #define PNG_WROTE_tIME             0x200
 #define PNG_WROTE_INFO_BEFORE_PLTE 0x400
-#define PNG_BACKGROUND_IS_GRAY     0x800
+                   /*              0x800 (unused) */
 #define PNG_HAVE_PNG_SIGNATURE    0x1000
 #define PNG_HAVE_CHUNK_AFTER_IDAT 0x2000 /* Have another chunk after IDAT */
                    /*             0x4000 (unused) */
@@ -546,10 +725,10 @@
 #define PNG_SWAP_BYTES          0x0010
 #define PNG_INVERT_MONO         0x0020
 #define PNG_QUANTIZE            0x0040
-#define PNG_COMPOSE             0x0080     /* Was PNG_BACKGROUND */
-#define PNG_BACKGROUND_EXPAND   0x0100
-#define PNG_EXPAND_16           0x0200     /* Added to libpng 1.5.2 */
-#define PNG_16_TO_8             0x0400     /* Becomes 'chop' in 1.5.4 */
+#define PNG_COMPOSE             0x0080 /* Was PNG_BACKGROUND */
+                       /*       0x0100 unused */
+#define PNG_EXPAND_16           0x0200 /* Added to libpng 1.5.2 */
+#define PNG_16_TO_8             0x0400 /* Becomes 'chop' in 1.5.4 */
 #define PNG_RGBA                0x0800
 #define PNG_EXPAND              0x1000
 #define PNG_GAMMA               0x2000
@@ -603,8 +782,8 @@
 #define PNG_FLAG_BENIGN_ERRORS_WARN     0x100000 /* Added to libpng-1.4.0 */
 #define PNG_FLAG_APP_WARNINGS_WARN      0x200000 /* Added to libpng-1.6.0 */
 #define PNG_FLAG_APP_ERRORS_WARN        0x400000 /* Added to libpng-1.6.0 */
-                                  /*    0x800000    unused */
-                                  /*   0x1000000    unused */
+#define PNG_FLAG_BACKGROUND_IS_GRAY     0x800000
+#define PNG_FLAG_BACKGROUND_EXPAND     0x1000000
                                   /*   0x2000000    unused */
                                   /*   0x4000000    unused */
                                   /*   0x8000000    unused */
@@ -627,6 +806,17 @@
    abs((int)((c1).green) - (int)((c2).green)) + \
    abs((int)((c1).blue) - (int)((c2).blue)))
 
+#if defined(PNG_SIMPLIFIED_READ_SUPPORTED) ||\
+   defined(PNG_SIMPLIFIED_WRITE_SUPPORTED)
+/* See below for the definitions of the tables used in these macros */
+#define PNG_sRGB_FROM_LINEAR(pp, linear) png_check_byte(pp,\
+   (png_sRGB_base[(linear)>>15] +\
+    ((((linear)&0x7fff)*png_sRGB_delta[(linear)>>15])>>12)) >> 8)
+   /* Given a value 'linear' in the range 0..255*65535 calculate the 8-bit sRGB
+    * encoded value with maximum error 0.646365.  Note that the input is not a
+    * 16-bit value; it has been multiplied by 255! */
+#endif /* PNG_SIMPLIFIED_READ/WRITE */
+
 /* Added to libpng-1.6.0: scale a 16-bit value in the range 0..65535 to 0..255
  * by dividing by 257 *with rounding*.  This macro is exact for the given range.
  * See the discourse in pngrtran.c png_do_scale_16_to_8.  The values in the
@@ -691,100 +881,6 @@
  */
 #endif
 
-/* Constants for known chunk types.  If you need to add a chunk, define the name
- * here.  For historical reasons these constants have the form png_<name>; i.e.
- * the prefix is lower case.  Please use decimal values as the parameters to
- * match the ISO PNG specification and to avoid relying on the C locale
- * interpretation of character values.
- *
- * Prior to 1.5.6 these constants were strings, as of 1.5.6 png_uint_32 values
- * are computed and a new macro (PNG_STRING_FROM_CHUNK) added to allow a string
- * to be generated if required.
- *
- * PNG_32b correctly produces a value shifted by up to 24 bits, even on
- * architectures where (int) is only 16 bits.
- */
-#define PNG_32b(b,s) ((png_uint_32)(b) << (s))
-#define PNG_U32(b1,b2,b3,b4) \
-   (PNG_32b(b1,24) | PNG_32b(b2,16) | PNG_32b(b3,8) | PNG_32b(b4,0))
-
-/* Constants for known chunk types.
- *
- * MAINTAINERS: If you need to add a chunk, define the name here.
- * For historical reasons these constants have the form png_<name>; i.e.
- * the prefix is lower case.  Please use decimal values as the parameters to
- * match the ISO PNG specification and to avoid relying on the C locale
- * interpretation of character values.  Please keep the list sorted.
- *
- * Notice that PNG_U32 is used to define a 32-bit value for the 4 byte chunk
- * type.  In fact the specification does not express chunk types this way,
- * however using a 32-bit value means that the chunk type can be read from the
- * stream using exactly the same code as used for a 32-bit unsigned value and
- * can be examined far more efficiently (using one arithmetic compare).
- *
- * Prior to 1.5.6 the chunk type constants were expressed as C strings.  The
- * libpng API still uses strings for 'unknown' chunks and a macro,
- * PNG_STRING_FROM_CHUNK, allows a string to be generated if required.  Notice
- * that for portable code numeric values must still be used; the string "IHDR"
- * is not portable and neither is PNG_U32('I', 'H', 'D', 'R').
- *
- * In 1.7.0 the definitions will be made public in png.h to avoid having to
- * duplicate the same definitions in application code.
- */
-#define png_IDAT PNG_U32( 73,  68,  65,  84)
-#define png_IEND PNG_U32( 73,  69,  78,  68)
-#define png_IHDR PNG_U32( 73,  72,  68,  82)
-#define png_PLTE PNG_U32( 80,  76,  84,  69)
-#define png_bKGD PNG_U32( 98,  75,  71,  68)
-#define png_cHRM PNG_U32( 99,  72,  82,  77)
-#define png_fRAc PNG_U32(102,  82,  65,  99) /* registered, not defined */
-#define png_gAMA PNG_U32(103,  65,  77,  65)
-#define png_gIFg PNG_U32(103,  73,  70, 103)
-#define png_gIFt PNG_U32(103,  73,  70, 116) /* deprecated */
-#define png_gIFx PNG_U32(103,  73,  70, 120)
-#define png_hIST PNG_U32(104,  73,  83,  84)
-#define png_iCCP PNG_U32(105,  67,  67,  80)
-#define png_iTXt PNG_U32(105,  84,  88, 116)
-#define png_oFFs PNG_U32(111,  70,  70, 115)
-#define png_pCAL PNG_U32(112,  67,  65,  76)
-#define png_pHYs PNG_U32(112,  72,  89, 115)
-#define png_sBIT PNG_U32(115,  66,  73,  84)
-#define png_sCAL PNG_U32(115,  67,  65,  76)
-#define png_sPLT PNG_U32(115,  80,  76,  84)
-#define png_sRGB PNG_U32(115,  82,  71,  66)
-#define png_sTER PNG_U32(115,  84,  69,  82)
-#define png_tEXt PNG_U32(116,  69,  88, 116)
-#define png_tIME PNG_U32(116,  73,  77,  69)
-#define png_tRNS PNG_U32(116,  82,  78,  83)
-#define png_zTXt PNG_U32(122,  84,  88, 116)
-
-/* The following will work on (signed char*) strings, whereas the get_uint_32
- * macro will fail on top-bit-set values because of the sign extension.
- */
-#define PNG_CHUNK_FROM_STRING(s)\
-   PNG_U32(0xff & (s)[0], 0xff & (s)[1], 0xff & (s)[2], 0xff & (s)[3])
-
-/* This uses (char), not (png_byte) to avoid warnings on systems where (char) is
- * signed and the argument is a (char[])  This macro will fail miserably on
- * systems where (char) is more than 8 bits.
- */
-#define PNG_STRING_FROM_CHUNK(s,c)\
-   (void)(((char*)(s))[0]=(char)(((c)>>24) & 0xff), \
-   ((char*)(s))[1]=(char)(((c)>>16) & 0xff),\
-   ((char*)(s))[2]=(char)(((c)>>8) & 0xff), \
-   ((char*)(s))[3]=(char)((c & 0xff)))
-
-/* Do the same but terminate with a null character. */
-#define PNG_CSTRING_FROM_CHUNK(s,c)\
-   (void)(PNG_STRING_FROM_CHUNK(s,c), ((char*)(s))[4] = 0)
-
-/* Test on flag values as defined in the spec (section 5.4): */
-#define PNG_CHUNK_ANCILLARY(c)   (1 & ((c) >> 29))
-#define PNG_CHUNK_CRITICAL(c)     (!PNG_CHUNK_ANCILLARY(c))
-#define PNG_CHUNK_PRIVATE(c)      (1 & ((c) >> 21))
-#define PNG_CHUNK_RESERVED(c)     (1 & ((c) >> 13))
-#define PNG_CHUNK_SAFE_TO_COPY(c) (1 & ((c) >>  5))
-
 /* Gamma values (new at libpng-1.5.4): */
 #define PNG_GAMMA_MAC_OLD 151724  /* Assume '1.8' is really 2.2/1.45! */
 #define PNG_GAMMA_MAC_INVERSE 65909
@@ -833,14 +929,7 @@ PNG_INTERNAL_DATA(const png_uint_16, png_sRGB_table, [256]);
 
 PNG_INTERNAL_DATA(const png_uint_16, png_sRGB_base, [512]);
 PNG_INTERNAL_DATA(const png_byte, png_sRGB_delta, [512]);
-
-#define PNG_sRGB_FROM_LINEAR(linear) \
-  ((png_byte)(0xff & ((png_sRGB_base[(linear)>>15] \
-   + ((((linear) & 0x7fff)*png_sRGB_delta[(linear)>>15])>>12)) >> 8)))
-   /* Given a value 'linear' in the range 0..255*65535 calculate the 8-bit sRGB
-    * encoded value with maximum error 0.646365.  Note that the input is not a
-    * 16-bit value; it has been multiplied by 255! */
-#endif /* SIMPLIFIED_READ/WRITE */
+#endif /* PNG_SIMPLIFIED_READ/WRITE */
 
 
 /* Inhibit C++ name-mangling for libpng functions but not for system calls. */
@@ -853,6 +942,71 @@ extern "C" {
  *
  * All of these functions must be declared with PNG_INTERNAL_FUNCTION.
  */
+/* Affirm handling */
+PNG_INTERNAL_FUNCTION(void, png_affirm,(png_const_structrp png_ptr,
+    param_deb(png_const_charp condition) unsigned int position), PNG_NORETURN);
+
+/* Character/byte range checking. */
+#ifdef PNG_RANGE_CHECK_SUPPORTED
+PNG_INTERNAL_FUNCTION(char, png_char_affirm,(png_const_structrp png_ptr,
+      unsigned int position, int c), PNG_EMPTY);
+
+PNG_INTERNAL_FUNCTION(png_byte, png_byte_affirm,(png_const_structrp png_ptr,
+      unsigned int position, int b), PNG_EMPTY);
+
+PNG_INTERNAL_FUNCTION(void, png_handled_affirm,(png_const_structrp png_ptr,
+      png_const_charp message, unsigned int position), PNG_EMPTY);
+   /* This is not marked PNG_NORETURN because in PNG_RELEASE_BUILD it will
+    * disappear and control will pass through it.
+    */
+
+#if INT_MAX >= 65535
+PNG_INTERNAL_FUNCTION(png_uint_16, png_u16_affirm,(png_const_structrp png_ptr,
+      unsigned int position, int u), PNG_EMPTY);
+#  define png_check_u16(pp, u) (png_u16_affirm((pp), PNG_SRC_LINE, (u)))
+#else
+   /* (int) cannot hold a (png_uint_16) so the above function just won't
+    * compile correctly, for the moment just do this:
+    */
+#  define png_check_u16(pp, u) (u)
+#endif
+
+#  define png_check_char(pp, c) (png_char_affirm((pp), PNG_SRC_LINE, (c)))
+#  define png_check_byte(pp, b) (png_byte_affirm((pp), PNG_SRC_LINE, (b)))
+#  define PNG_BYTE(b)           ((png_byte)((b) & 0xff))
+#  define PNG_UINT_16(u)        ((png_uint_16)((u) & 0xffff))
+#  define png_handled(pp, m)    (png_handled_affirm((pp), (m), PNG_SRC_LINE))
+#elif !(defined PNG_REMOVE_CASTS)
+#  define png_check_char(pp, c) ((char)(c))
+#  define png_check_byte(pp, b) ((png_byte)(b))
+#  define png_check_u16(pp, u)  ((png_uint_16)(u))
+#  define png_handled(pp, m)    ((void)0)
+#  define PNG_BYTE(b)           ((png_byte)((b) & 0xff))
+#  define PNG_UINT_16(u)        ((png_uint_16)((u) & 0xffff))
+#else
+   /* This is somewhat trust-me-it-works: if PNG_REMOVE_CASTS is defined then
+    * the casts, which might otherwise change the values, are completely
+    * removed.  Use this to test your compiler to see if it makes *any*
+    * difference (code size or speed.)  Currently NOT SUPPORTED.
+    *
+    * It also makes the PNG_BYTE and PNG_UINT_16 macros do nothing either
+    * NOTE: this seems safe at present but might lead to unexpected results
+    * if someone writes code to depend on the truncation.
+    */
+#  define png_check_char(pp, c) (c)
+#  define png_check_byte(pp, b) (b)
+#  define png_check_u16(pp, u)  (u)
+#  define png_handled(pp, m)    ((void)0)
+#  define PNG_BYTE(b)           (b)
+#  define PNG_UINT_16(b)        (u)
+#endif /* RANGE_CHECK */
+
+/* Utility macro to mark a handled error condition ; when control reaches this
+ * there has been an arithmetic overflow but it is being handled.  Use the
+ * png_check_ macros above where control should leave the code for
+ * safety/security reasons.
+ */
+#define handled(m) png_handled(png_ptr, (m))
 
 /* Zlib support */
 #define PNG_UNEXPECTED_ZLIB_RETURN (-7)
@@ -868,6 +1022,16 @@ PNG_INTERNAL_FUNCTION(void,png_free_buffer_list,(png_structrp png_ptr,
    /* Free the buffer list used by the compressed write code. */
 #endif
 
+#ifdef PNG_WRITE_FILTER_SUPPORTED
+PNG_INTERNAL_FUNCTION(void,png_write_alloc_filter_row_buffers,
+   (png_structrp png_ptr, int filters),PNG_EMPTY);
+   /* Allocate pixel row buffers to cache filtered rows while testing candidate
+    * filters.
+    * TODO: avoid this, only one spare row buffer (at most) is required, this
+    * wastes a lot of memory for large images.
+    */
+#endif
+
 #if defined(PNG_FLOATING_POINT_SUPPORTED) && \
    !defined(PNG_FIXED_POINT_MACRO_SUPPORTED) && \
    (defined(PNG_gAMA_SUPPORTED) || defined(PNG_cHRM_SUPPORTED) || \
@@ -904,7 +1068,7 @@ PNG_INTERNAL_FUNCTION(png_voidp,png_malloc_array,(png_const_structrp png_ptr,
  * also memsets the new elements to 0 and copies the old elements.  The old
  * array is not freed or altered.
  */
-PNG_INTERNAL_FUNCTION(png_voidp,png_realloc_array,(png_const_structrp png_ptr,
+PNG_INTERNAL_FUNCTION(png_voidp,png_realloc_array,(png_structrp png_ptr,
    png_const_voidp array, int old_elements, int add_elements,
    size_t element_size),PNG_ALLOCATED);
 #endif /* text, sPLT or unknown chunks */
@@ -1085,7 +1249,7 @@ PNG_INTERNAL_FUNCTION(void,png_write_iTXt,(png_structrp png_ptr,
 #endif
 
 #ifdef PNG_TEXT_SUPPORTED  /* Added at version 1.0.14 and 1.2.4 */
-PNG_INTERNAL_FUNCTION(int,png_set_text_2,(png_const_structrp png_ptr,
+PNG_INTERNAL_FUNCTION(int,png_set_text_2,(png_structrp png_ptr,
     png_inforp info_ptr, png_const_textp text_ptr, int num_text),PNG_EMPTY);
 #endif
 
@@ -1225,35 +1389,94 @@ PNG_INTERNAL_FUNCTION(void,png_read_transform_info,(png_structrp png_ptr,
     png_inforp info_ptr),PNG_EMPTY);
 #endif
 
+#if defined(PNG_READ_TRANSFORMS_SUPPORTED) ||\
+    defined(PNG_WRITE_TRANSFORMS_SUPPORTED)
+/***************************** READ and WRITE TRANSFORMS ***********************
+ * These structures are used in pngrtran.c, pngwtran.c and pngtrans.c to hold
+ * information about transforms in progress.  This mechanism was introduced in
+ * libpng 1.7.0 to ensure reliable transform code and to fix multiple bugs in
+ * the pre-1.7 transform handling.
+ *
+ * Prior to 1.7.0 the internal transform routines took a png_row_infop, like the
+ * user transform function, but without the png_ptr because it was never used.
+ * In 1.7.0 a separate internal structure is used in place of this to allow both
+ * future development to change the structure.
+ *
+ * The values in this structure will normally be changed by transformation
+ * implementations.
+ ***************************** READ and WRITE TRANSFORMS **********************/
+typedef struct
+{
+   png_const_structrp png_ptr;   /* png_struct for error handling and some
+                                  * transform parameters.
+                                  */
+   png_uint_32        width;     /* width of row */
+   unsigned int       channels;  /* number of channels (1, 2, 3, or 4) */
+   unsigned int       bit_depth; /* bit depth of row */
+   unsigned int       priority;  /* priority of the previous transform (see the
+                                  * explanation below for png_transform). */
+#  ifdef PNG_READ_GAMMA_SUPPORTED
+      png_fixed_point gamma;     /* Actual gamma of the row data */
+      png_fixed_point gamma_out; /* Expected final gamma after gamma encoding */
+#  endif
+   unsigned int       flags;     /* As below */
+#  define PNG_INDEXED          1 /* Indexed/palette PNG */
+#  define PNG_RGB_SWAPPED      2 /* as in the PNG_BGR transformation */
+#  define PNG_FILLER_IN_ALPHA  4 /* 'alpha' channel is really just a filler */
+#  define PNG_ALPHA_SWAPPED    8 /* Alpha is in the first channel */
+#  define PNG_ALPHA_INVERTED  16 /* Alpha values inverted */
+#  define PNG_INVERTED        32 /* grayscale channel inverted */
+#  define PNG_BITS_SHIFTED    64 /* Channels not in range 1..(bit_depth-1) */
+#  define PNG_BYTE_SWAPPED   128 /* 'swab', i.e. pairs of bytes swapped */
+#  define PNG_PIXEL_SWAPPED  256 /* pixels swapped within bytes */
+#  define PNG_BAD_INDEX      512 /* Bad palette image index */
+} png_transform_control, *png_transform_controlp;
+
+/* Validation: channels and bit_depth can be set to anything required by
+ * the transform, but the result may not be encodable in PNG.  PNG_USURPED
+ * must be set in this case.  This macro detects the detectably unrepresentable
+ * case channels case.
+ *
+ * Channels: must be 1 when PNG_INDEXED is set, must be 1-4 otherwise, so:
+ *
+ *    (channels-1) <= (((flags & PNG_INDEXED)-1) & 3)
+ */
+#define PNG_VALID_CHANNELS(ri)\
+   (((ri)->channels-1) <= ((((ri)->flags & PNG_INDEXED)-1) & 3))
+
+typedef const png_transform_control *png_const_transform_controlp;
+typedef const png_row_info *png_const_row_infop;
+
 /* Shared transform functions, defined in pngtran.c */
 #if defined(PNG_WRITE_FILLER_SUPPORTED) || \
     defined(PNG_READ_STRIP_ALPHA_SUPPORTED)
-PNG_INTERNAL_FUNCTION(void,png_do_strip_channel,(png_row_infop row_info,
-    png_bytep row, int at_start),PNG_EMPTY);
+PNG_INTERNAL_FUNCTION(void,png_do_strip_channel,(
+    png_transform_controlp row_info, png_bytep row, int at_start),PNG_EMPTY);
 #endif
 
 #ifdef PNG_16BIT_SUPPORTED
 #if defined(PNG_READ_SWAP_SUPPORTED) || defined(PNG_WRITE_SWAP_SUPPORTED)
-PNG_INTERNAL_FUNCTION(void,png_do_swap,(png_row_infop row_info,
+PNG_INTERNAL_FUNCTION(void,png_do_swap,(png_transform_controlp row_info,
     png_bytep row),PNG_EMPTY);
 #endif
 #endif
 
 #if defined(PNG_READ_PACKSWAP_SUPPORTED) || \
     defined(PNG_WRITE_PACKSWAP_SUPPORTED)
-PNG_INTERNAL_FUNCTION(void,png_do_packswap,(png_row_infop row_info,
+PNG_INTERNAL_FUNCTION(void,png_do_packswap,(png_transform_controlp row_info,
     png_bytep row),PNG_EMPTY);
 #endif
 
 #if defined(PNG_READ_INVERT_SUPPORTED) || defined(PNG_WRITE_INVERT_SUPPORTED)
-PNG_INTERNAL_FUNCTION(void,png_do_invert,(png_row_infop row_info,
+PNG_INTERNAL_FUNCTION(void,png_do_invert,(png_transform_controlp row_info,
     png_bytep row),PNG_EMPTY);
 #endif
 
 #if defined(PNG_READ_BGR_SUPPORTED) || defined(PNG_WRITE_BGR_SUPPORTED)
-PNG_INTERNAL_FUNCTION(void,png_do_bgr,(png_row_infop row_info,
+PNG_INTERNAL_FUNCTION(void,png_do_bgr,(png_transform_controlp row_info,
     png_bytep row),PNG_EMPTY);
 #endif
+#endif /* READ_TRANSFORMS || WRITE_TRANSFORMS */
 
 /* The following decodes the appropriate chunks, and does error correction,
  * then calls the appropriate callback for the chunk if it is valid.
@@ -1373,6 +1596,24 @@ PNG_INTERNAL_FUNCTION(int,png_chunk_unknown_handling,
 #endif /* READ_UNKNOWN_CHUNKS || HANDLE_AS_UNKNOWN */
 
 /* Handle the transformations for reading and writing */
+#if defined(PNG_READ_TRANSFORMS_SUPPORTED) ||\
+    defined(PNG_WRITE_TRANSFORMS_SUPPORTED)
+/* Utility functions: */
+PNG_INTERNAL_FUNCTION(void,png_init_transform_control,(
+   png_const_structrp png_ptr, png_transform_controlp out,
+   png_const_row_infop in),
+   PNG_EMPTY);
+
+/* This function exists to ensure that overflow cannot happen even if there
+ * are bugs in the transforms or calculation of maximum_pixel_depth.
+ */
+PNG_INTERNAL_FUNCTION(size_t,png_transform_rowbytes,(
+   png_const_transform_controlp row_info),PNG_EMPTY);
+
+PNG_INTERNAL_FUNCTION(void,png_end_transform_control,(png_row_infop out,
+   png_const_transform_controlp in), PNG_EMPTY);
+#endif /* TRANSFORMS */
+
 #ifdef PNG_READ_TRANSFORMS_SUPPORTED
 PNG_INTERNAL_FUNCTION(void,png_do_read_transformations,(png_structrp png_ptr,
    png_row_infop row_info),PNG_EMPTY);
@@ -1528,7 +1769,7 @@ PNG_INTERNAL_FUNCTION(void,png_check_IHDR,(png_const_structrp png_ptr,
 #if defined(PNG_READ_CHECK_FOR_INVALID_INDEX_SUPPORTED) || \
     defined(PNG_WRITE_CHECK_FOR_INVALID_INDEX_SUPPORTED)
 PNG_INTERNAL_FUNCTION(void,png_do_check_palette_indexes,
-   (png_structrp png_ptr, png_row_infop row_info),PNG_EMPTY);
+   (png_structrp png_ptr, png_transform_controlp row_info),PNG_EMPTY);
 #endif
 
 #if defined(PNG_FLOATING_POINT_SUPPORTED) && defined(PNG_ERROR_TEXT_SUPPORTED)
@@ -1790,13 +2031,6 @@ PNG_INTERNAL_FUNCTION(int,png_muldiv,(png_fixed_point_p res, png_fixed_point a,
    png_int_32 multiplied_by, png_int_32 divided_by),PNG_EMPTY);
 #endif
 
-#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_INCH_CONVERSIONS_SUPPORTED)
-/* Same deal, but issue a warning on overflow and return 0. */
-PNG_INTERNAL_FUNCTION(png_fixed_point,png_muldiv_warn,
-   (png_const_structrp png_ptr, png_fixed_point a, png_int_32 multiplied_by,
-   png_int_32 divided_by),PNG_EMPTY);
-#endif
-
 #ifdef PNG_GAMMA_SUPPORTED
 /* Calculate a reciprocal - used for gamma values.  This returns
  * 0 if the argument is 0 in order to maintain an undefined value;
@@ -1805,15 +2039,6 @@ PNG_INTERNAL_FUNCTION(png_fixed_point,png_muldiv_warn,
 PNG_INTERNAL_FUNCTION(png_fixed_point,png_reciprocal,(png_fixed_point a),
    PNG_EMPTY);
 
-#ifdef PNG_READ_GAMMA_SUPPORTED
-/* The same but gives a reciprocal of the product of two fixed point
- * values.  Accuracy is suitable for gamma calculations but this is
- * not exact - use png_muldiv for that.  Only required at present on read.
- */
-PNG_INTERNAL_FUNCTION(png_fixed_point,png_reciprocal2,(png_fixed_point a,
-   png_fixed_point b),PNG_EMPTY);
-#endif
-
 /* Return true if the gamma value is significantly different from 1.0 */
 PNG_INTERNAL_FUNCTION(int,png_gamma_significant,(png_fixed_point gamma_value),
    PNG_EMPTY);
@@ -1827,16 +2052,11 @@ PNG_INTERNAL_FUNCTION(int,png_gamma_significant,(png_fixed_point gamma_value),
  * While the input is an 'unsigned' value it must actually be the
  * correct bit value - 0..255 or 0..65535 as required.
  */
-PNG_INTERNAL_FUNCTION(png_uint_16,png_gamma_correct,(png_structrp png_ptr,
-   unsigned int value, png_fixed_point gamma_value),PNG_EMPTY);
-PNG_INTERNAL_FUNCTION(png_uint_16,png_gamma_16bit_correct,(unsigned int value,
-   png_fixed_point gamma_value),PNG_EMPTY);
-PNG_INTERNAL_FUNCTION(png_byte,png_gamma_8bit_correct,(unsigned int value,
-   png_fixed_point gamma_value),PNG_EMPTY);
+PNG_INTERNAL_FUNCTION(png_uint_16,png_gamma_16bit_correct,(
+   png_const_structrp png_ptr, png_uint_32 value, png_fixed_point gamma_value),
+   PNG_EMPTY);
 PNG_INTERNAL_FUNCTION(void,png_destroy_gamma_table,(png_structrp png_ptr),
    PNG_EMPTY);
-PNG_INTERNAL_FUNCTION(void,png_build_gamma_table,(png_structrp png_ptr,
-   int bit_depth),PNG_EMPTY);
 #endif
 
 /* SIMPLIFIED READ/WRITE SUPPORT */
@@ -1901,7 +2121,7 @@ PNG_INTERNAL_FUNCTION(void, png_image_free, (png_imagep image), PNG_EMPTY);
  * the generic code is used.
  */
 #ifdef PNG_FILTER_OPTIMIZATIONS
-PNG_INTERNAL_FUNCTION(void, PNG_FILTER_OPTIMIZATIONS, (png_structp png_ptr,
+PNG_INTERNAL_FUNCTION(void, PNG_FILTER_OPTIMIZATIONS, (png_structrp png_ptr,
    unsigned int bpp), PNG_EMPTY);
    /* Just declare the optimization that will be used */
 #else

pngread.c

@@ -1,7 +1,7 @@
 
 /* pngread.c - read a PNG file
  *
- * Last changed in libpng 1.6.17 [March 26, 2015]
+ * Last changed in libpng 1.7.0 [(PENDING RELEASE)]
  * Copyright (c) 1998-2015 Glenn Randers-Pehrson
  * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
  * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
@@ -18,9 +18,78 @@
 #if defined(PNG_SIMPLIFIED_READ_SUPPORTED) && defined(PNG_STDIO_SUPPORTED)
 #  include <errno.h>
 #endif
+#define PNG_SRC_FILE PNG_SRC_FILE_pngread
 
 #ifdef PNG_READ_SUPPORTED
 
+/* Set the action on getting a CRC error for an ancillary or critical chunk. */
+void PNGAPI
+png_set_crc_action(png_structrp png_ptr, int crit_action, int ancil_action)
+{
+   png_debug(1, "in png_set_crc_action");
+
+   if (png_ptr == NULL)
+      return;
+
+   /* Tell libpng how we react to CRC errors in critical chunks */
+   switch (crit_action)
+   {
+      case PNG_CRC_NO_CHANGE:                        /* Leave setting as is */
+         break;
+
+      case PNG_CRC_WARN_USE:                               /* Warn/use data */
+         png_ptr->flags &= ~PNG_FLAG_CRC_CRITICAL_MASK;
+         png_ptr->flags |= PNG_FLAG_CRC_CRITICAL_USE;
+         break;
+
+      case PNG_CRC_QUIET_USE:                             /* Quiet/use data */
+         png_ptr->flags &= ~PNG_FLAG_CRC_CRITICAL_MASK;
+         png_ptr->flags |= PNG_FLAG_CRC_CRITICAL_USE |
+                           PNG_FLAG_CRC_CRITICAL_IGNORE;
+         break;
+
+      case PNG_CRC_WARN_DISCARD:    /* Not a valid action for critical data */
+         png_warning(png_ptr,
+            "Can't discard critical data on CRC error");
+      case PNG_CRC_ERROR_QUIT:                                /* Error/quit */
+
+      case PNG_CRC_DEFAULT:
+      default:
+         png_ptr->flags &= ~PNG_FLAG_CRC_CRITICAL_MASK;
+         break;
+   }
+
+   /* Tell libpng how we react to CRC errors in ancillary chunks */
+   switch (ancil_action)
+   {
+      case PNG_CRC_NO_CHANGE:                       /* Leave setting as is */
+         break;
+
+      case PNG_CRC_WARN_USE:                              /* Warn/use data */
+         png_ptr->flags &= ~PNG_FLAG_CRC_ANCILLARY_MASK;
+         png_ptr->flags |= PNG_FLAG_CRC_ANCILLARY_USE;
+         break;
+
+      case PNG_CRC_QUIET_USE:                            /* Quiet/use data */
+         png_ptr->flags &= ~PNG_FLAG_CRC_ANCILLARY_MASK;
+         png_ptr->flags |= PNG_FLAG_CRC_ANCILLARY_USE |
+                           PNG_FLAG_CRC_ANCILLARY_NOWARN;
+         break;
+
+      case PNG_CRC_ERROR_QUIT:                               /* Error/quit */
+         png_ptr->flags &= ~PNG_FLAG_CRC_ANCILLARY_MASK;
+         png_ptr->flags |= PNG_FLAG_CRC_ANCILLARY_NOWARN;
+         break;
+
+      case PNG_CRC_WARN_DISCARD:                      /* Warn/discard data */
+
+      case PNG_CRC_DEFAULT:
+      default:
+         png_ptr->flags &= ~PNG_FLAG_CRC_ANCILLARY_MASK;
+         break;
+   }
+}
+
 /* Create a PNG structure for reading, and allocate any memory needed. */
 PNG_FUNCTION(png_structp,PNGAPI
 png_create_read_struct,(png_const_charp user_png_ver, png_voidp error_ptr,
@@ -121,7 +190,7 @@ png_read_info(png_structrp png_ptr, png_inforp info_ptr)
             png_chunk_error(png_ptr, "Missing PLTE before IDAT");
 
          else if ((png_ptr->mode & PNG_AFTER_IDAT) != 0)
-            png_chunk_benign_error(png_ptr, "Too many IDATs found");
+            png_chunk_benign_error(png_ptr, "Too many IDATs found[s]");
 
          png_ptr->mode |= PNG_HAVE_IDAT;
       }
@@ -336,6 +405,7 @@ png_do_read_intrapixel(png_row_infop row_info, png_bytep row)
 
          for (i = 0, rp = row; i < row_width; i++, rp += bytes_per_pixel)
          {
+            /* TODO: explain the +256 */
             *(rp) = (png_byte)((256 + *rp + *(rp + 1)) & 0xff);
             *(rp+2) = (png_byte)((256 + *(rp + 2) + *(rp + 1)) & 0xff);
          }
@@ -359,6 +429,7 @@ png_do_read_intrapixel(png_row_infop row_info, png_bytep row)
             png_uint_32 s0   = (*(rp    ) << 8) | *(rp + 1);
             png_uint_32 s1   = (*(rp + 2) << 8) | *(rp + 3);
             png_uint_32 s2   = (*(rp + 4) << 8) | *(rp + 5);
+            /* TODO: explain the +65536 */
             png_uint_32 red  = (s0 + s1 + 65536) & 0xffff;
             png_uint_32 blue = (s2 + s1 + 65536) & 0xffff;
             *(rp    ) = (png_byte)((red >> 8) & 0xff);
@@ -801,7 +872,7 @@ png_read_end(png_structrp png_ptr, png_inforp info_ptr)
          {
             if ((length > 0) ||
                 (png_ptr->mode & PNG_HAVE_CHUNK_AFTER_IDAT) != 0)
-               png_benign_error(png_ptr, "Too many IDATs found");
+               png_benign_error(png_ptr, "Too many IDATs found(a1)");
          }
          png_handle_unknown(png_ptr, info_ptr, length, keep);
          if (chunk_name == png_PLTE)
@@ -815,7 +886,7 @@ png_read_end(png_structrp png_ptr, png_inforp info_ptr)
           * read, but not after other chunks have been read.
           */
          if ((length > 0) || (png_ptr->mode & PNG_HAVE_CHUNK_AFTER_IDAT) != 0)
-            png_benign_error(png_ptr, "Too many IDATs found");
+            png_benign_error(png_ptr, "Too many IDATs found(a2)");
 
          png_crc_finish(png_ptr, length);
       }
@@ -945,15 +1016,12 @@ png_read_destroy(png_structrp png_ptr)
    }
    png_ptr->free_me &= ~PNG_FREE_PLTE;
 
-#if defined(PNG_tRNS_SUPPORTED) || \
-    defined(PNG_READ_EXPAND_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED)
    if ((png_ptr->free_me & PNG_FREE_TRNS) != 0)
    {
       png_free(png_ptr, png_ptr->trans_alpha);
       png_ptr->trans_alpha = NULL;
    }
    png_ptr->free_me &= ~PNG_FREE_TRNS;
-#endif
 
    inflateEnd(&png_ptr->zstream);
 
@@ -1043,9 +1111,9 @@ png_read_png(png_structrp png_ptr, png_inforp info_ptr,
    /* Tell libpng to strip 16-bit/color files down to 8 bits per color.
     */
    if ((transforms & PNG_TRANSFORM_SCALE_16) != 0)
-      /* Added at libpng-1.5.4. "strip_16" produces the same result that it
-       * did in earlier versions, while "scale_16" is now more accurate.
-       */
+     /* Added at libpng-1.5.4. "strip_16" produces the same result that it
+      * did in earlier versions, while "scale_16" is now more accurate.
+      */
 #ifdef PNG_READ_SCALE_16_TO_8_SUPPORTED
       png_set_scale_16(png_ptr);
 #else
@@ -1209,7 +1277,7 @@ png_read_png(png_structrp png_ptr, png_inforp info_ptr,
 
       for (iptr = 0; iptr < info_ptr->height; iptr++)
          info_ptr->row_pointers[iptr] = png_voidcast(png_bytep,
-             png_malloc(png_ptr, info_ptr->rowbytes));
+            png_malloc(png_ptr, info_ptr->rowbytes));
    }
 
    png_read_image(png_ptr, info_ptr->row_pointers);
@@ -1669,7 +1737,8 @@ decode_gamma(png_image_read_control *display, png_uint_32 value, int encoding)
    switch (encoding)
    {
       case P_FILE:
-         value = png_gamma_16bit_correct(value*257, display->gamma_to_linear);
+         value = png_gamma_16bit_correct(display->image->opaque->png_ptr,
+            value*257, display->gamma_to_linear);
          break;
 
       case P_sRGB:
@@ -1684,8 +1753,8 @@ decode_gamma(png_image_read_control *display, png_uint_32 value, int encoding)
          break;
 
       default:
-         png_error(display->image->opaque->png_ptr,
-            "unexpected encoding (internal error)");
+         png_impossiblepp(display->image->opaque->png_ptr,
+            "unexpected encoding");
          break;
    }
 
@@ -1721,7 +1790,7 @@ png_colormap_compose(png_image_read_control *display,
    }
 
    else /* P_sRGB */
-      f = PNG_sRGB_FROM_LINEAR(f);
+      f = PNG_sRGB_FROM_LINEAR(display->image->opaque->png_ptr, f);
 
    return f;
 }
@@ -1735,13 +1804,14 @@ png_create_colormap_entry(png_image_read_control *display,
    png_uint_32 alpha, int encoding)
 {
    png_imagep image = display->image;
+#  define png_ptr image->opaque->png_ptr /* for error messages */
    const int output_encoding = (image->format & PNG_FORMAT_FLAG_LINEAR) != 0 ?
       P_LINEAR : P_sRGB;
    const int convert_to_Y = (image->format & PNG_FORMAT_FLAG_COLOR) == 0 &&
       (red != green || green != blue);
 
    if (ip > 255)
-      png_error(image->opaque->png_ptr, "color-map index out of range");
+      png_error(png_ptr, "color-map index out of range");
 
    /* Update the cache with whether the file gamma is significantly different
     * from sRGB.
@@ -1761,9 +1831,9 @@ png_create_colormap_entry(png_image_read_control *display,
    {
       png_fixed_point g = display->gamma_to_linear;
 
-      red = png_gamma_16bit_correct(red*257, g);
-      green = png_gamma_16bit_correct(green*257, g);
-      blue = png_gamma_16bit_correct(blue*257, g);
+      red = png_gamma_16bit_correct(png_ptr, red*257, g);
+      green = png_gamma_16bit_correct(png_ptr, green*257, g);
+      blue = png_gamma_16bit_correct(png_ptr, blue*257, g);
 
       if (convert_to_Y != 0 || output_encoding == P_LINEAR)
       {
@@ -1773,9 +1843,9 @@ png_create_colormap_entry(png_image_read_control *display,
 
       else
       {
-         red = PNG_sRGB_FROM_LINEAR(red * 255);
-         green = PNG_sRGB_FROM_LINEAR(green * 255);
-         blue = PNG_sRGB_FROM_LINEAR(blue * 255);
+         red = PNG_sRGB_FROM_LINEAR(png_ptr, red * 255);
+         green = PNG_sRGB_FROM_LINEAR(png_ptr, green * 255);
+         blue = PNG_sRGB_FROM_LINEAR(png_ptr, blue * 255);
          encoding = P_sRGB;
       }
    }
@@ -1793,7 +1863,7 @@ png_create_colormap_entry(png_image_read_control *display,
    }
 
    else if (encoding == P_sRGB &&
-       (convert_to_Y  != 0 || output_encoding == P_LINEAR))
+       (convert_to_Y != 0 || output_encoding == P_LINEAR))
    {
       /* The values are 8-bit sRGB values, but must be converted to 16-bit
        * linear.
@@ -1811,8 +1881,7 @@ png_create_colormap_entry(png_image_read_control *display,
       if (convert_to_Y != 0)
       {
          /* NOTE: these values are copied from png_do_rgb_to_gray */
-         png_uint_32 y = (png_uint_32)6968 * red  + (png_uint_32)23434 * green +
-            (png_uint_32)2366 * blue;
+         png_uint_32 y = 6968 * red  + 23434 * green + 2366 * blue;
 
          if (output_encoding == P_LINEAR)
             y = (y + 16384) >> 15;
@@ -1822,7 +1891,7 @@ png_create_colormap_entry(png_image_read_control *display,
             /* y is scaled by 32768, we need it scaled by 255: */
             y = (y + 128) >> 8;
             y *= 255;
-            y = PNG_sRGB_FROM_LINEAR((y + 64) >> 7);
+            y = PNG_sRGB_FROM_LINEAR(png_ptr, (y + 64) >> 7);
             alpha = PNG_DIV257(alpha);
             encoding = P_sRGB;
          }
@@ -1832,16 +1901,16 @@ png_create_colormap_entry(png_image_read_control *display,
 
       else if (output_encoding == P_sRGB)
       {
-         red = PNG_sRGB_FROM_LINEAR(red * 255);
-         green = PNG_sRGB_FROM_LINEAR(green * 255);
-         blue = PNG_sRGB_FROM_LINEAR(blue * 255);
+         red = PNG_sRGB_FROM_LINEAR(png_ptr, red * 255);
+         green = PNG_sRGB_FROM_LINEAR(png_ptr, green * 255);
+         blue = PNG_sRGB_FROM_LINEAR(png_ptr, blue * 255);
          alpha = PNG_DIV257(alpha);
          encoding = P_sRGB;
       }
    }
 
    if (encoding != output_encoding)
-      png_error(image->opaque->png_ptr, "bad encoding (internal error)");
+      png_impossiblepp(png_ptr, "bad encoding");
 
    /* Store the value. */
    {
@@ -1870,7 +1939,7 @@ png_create_colormap_entry(png_image_read_control *display,
          switch (PNG_IMAGE_SAMPLE_CHANNELS(image->format))
          {
             case 4:
-               entry[afirst ? 0 : 3] = (png_uint_16)alpha;
+               entry[afirst ? 0 : 3] = png_check_u16(png_ptr, alpha);
                /* FALL THROUGH */
 
             case 3:
@@ -1886,13 +1955,13 @@ png_create_colormap_entry(png_image_read_control *display,
                   else
                      red = green = blue = 0;
                }
-               entry[afirst + (2 ^ bgr)] = (png_uint_16)blue;
-               entry[afirst + 1] = (png_uint_16)green;
-               entry[afirst + bgr] = (png_uint_16)red;
+               entry[afirst + (2 ^ bgr)] = png_check_u16(png_ptr, blue);
+               entry[afirst + 1] = png_check_u16(png_ptr, green);
+               entry[afirst + bgr] = png_check_u16(png_ptr, red);
                break;
 
             case 2:
-               entry[1 ^ afirst] = (png_uint_16)alpha;
+               entry[1 ^ afirst] = png_check_u16(png_ptr, alpha);
                /* FALL THROUGH */
 
             case 1:
@@ -1904,7 +1973,7 @@ png_create_colormap_entry(png_image_read_control *display,
                   else
                      green = 0;
                }
-               entry[afirst] = (png_uint_16)green;
+               entry[afirst] = png_check_u16(png_ptr, green);
                break;
 
             default:
@@ -1918,20 +1987,24 @@ png_create_colormap_entry(png_image_read_control *display,
 
          entry += ip * PNG_IMAGE_SAMPLE_CHANNELS(image->format);
 
+         png_affirmpp(png_ptr, output_encoding == P_sRGB);
+
          switch (PNG_IMAGE_SAMPLE_CHANNELS(image->format))
          {
             case 4:
-               entry[afirst ? 0 : 3] = (png_byte)alpha;
+               entry[afirst ? 0 : 3] = png_check_byte(png_ptr, alpha);
+
             case 3:
-               entry[afirst + (2 ^ bgr)] = (png_byte)blue;
-               entry[afirst + 1] = (png_byte)green;
-               entry[afirst + bgr] = (png_byte)red;
+               entry[afirst + (2 ^ bgr)] = png_check_byte(png_ptr, blue);
+               entry[afirst + 1] = png_check_byte(png_ptr, green);
+               entry[afirst + bgr] = png_check_byte(png_ptr, red);
                break;
 
             case 2:
-               entry[1 ^ afirst] = (png_byte)alpha;
+               entry[1 ^ afirst] = png_check_byte(png_ptr, alpha);
+
             case 1:
-               entry[afirst] = (png_byte)green;
+               entry[afirst] = png_check_byte(png_ptr, green);
                break;
 
             default:
@@ -1946,6 +2019,8 @@ png_create_colormap_entry(png_image_read_control *display,
 #        undef bgr
 #     endif
    }
+
+#  undef png_ptr
 }
 
 static int
@@ -2053,7 +2128,8 @@ make_rgb_colormap(png_image_read_control *display)
 
 /* Return a palette index to the above palette given three 8-bit sRGB values. */
 #define PNG_RGB_INDEX(r,g,b) \
-   ((png_byte)(6 * (6 * PNG_DIV51(r) + PNG_DIV51(g)) + PNG_DIV51(b)))
+   (png_check_byte(image->opaque->png_ptr,\
+                   6 * (6 * PNG_DIV51(r) + PNG_DIV51(g)) + PNG_DIV51(b)))
 
 static int
 png_image_read_colormap(png_voidp argument)
@@ -2260,7 +2336,7 @@ png_image_read_colormap(png_voidp argument)
 
                      if (output_encoding == P_LINEAR)
                      {
-                        gray = PNG_sRGB_FROM_LINEAR(gray * 255);
+                        gray = PNG_sRGB_FROM_LINEAR(png_ptr, gray * 255);
 
                         /* And make sure the corresponding palette entry
                          * matches.
@@ -2273,7 +2349,8 @@ png_image_read_colormap(png_voidp argument)
                       * sRGB value.
                       */
                      c.index = 0; /*unused*/
-                     c.gray = c.red = c.green = c.blue = (png_uint_16)gray;
+                     c.gray = c.red = c.green = c.blue =
+                        png_check_u16(png_ptr, gray);
 
                      /* NOTE: does this work without expanding tRNS to alpha?
                       * It should be the color->gray case below apparently
@@ -2375,7 +2452,7 @@ png_image_read_colormap(png_voidp argument)
 
                if (output_encoding == P_LINEAR)
                {
-                  gray = PNG_sRGB_FROM_LINEAR(gray * 255);
+                  gray = PNG_sRGB_FROM_LINEAR(png_ptr, gray * 255);
 
                   /* And make sure the corresponding palette entry matches. */
                   png_create_colormap_entry(display, gray, back_g, back_g,
@@ -2386,7 +2463,7 @@ png_image_read_colormap(png_voidp argument)
                 * value.
                 */
                c.index = 0; /*unused*/
-               c.gray = c.red = c.green = c.blue = (png_uint_16)gray;
+               c.gray = c.red = c.green = c.blue = png_check_u16(png_ptr, gray);
 
                png_set_background_fixed(png_ptr, &c,
                   PNG_BACKGROUND_GAMMA_SCREEN, 0/*need_expand*/,
@@ -2463,9 +2540,10 @@ png_image_read_colormap(png_voidp argument)
                      png_uint_32 gray = png_sRGB_table[g*51] * alpha;
 
                      png_create_colormap_entry(display, i++,
-                        PNG_sRGB_FROM_LINEAR(gray + back_rx),
-                        PNG_sRGB_FROM_LINEAR(gray + back_gx),
-                        PNG_sRGB_FROM_LINEAR(gray + back_bx), 255, P_sRGB);
+                        PNG_sRGB_FROM_LINEAR(png_ptr, gray + back_rx),
+                        PNG_sRGB_FROM_LINEAR(png_ptr, gray + back_gx),
+                        PNG_sRGB_FROM_LINEAR(png_ptr, gray + back_bx),
+                        255, P_sRGB);
                   }
                }
 
@@ -2566,7 +2644,7 @@ png_image_read_colormap(png_voidp argument)
                      if (output_encoding == P_sRGB)
                         gray = png_sRGB_table[gray]; /* now P_LINEAR */
 
-                     gray = PNG_DIV257(png_gamma_16bit_correct(gray,
+                     gray = PNG_DIV257(png_gamma_16bit_correct(png_ptr, gray,
                         png_ptr->colorspace.gamma)); /* now P_FILE */
 
                      /* And make sure the corresponding palette entry contains
@@ -2578,7 +2656,7 @@ png_image_read_colormap(png_voidp argument)
 
                   else if (output_encoding == P_LINEAR)
                   {
-                     gray = PNG_sRGB_FROM_LINEAR(gray * 255);
+                     gray = PNG_sRGB_FROM_LINEAR(png_ptr, gray * 255);
 
                      /* And make sure the corresponding palette entry matches.
                       */
@@ -2590,7 +2668,8 @@ png_image_read_colormap(png_voidp argument)
                    * output (normally sRGB) value.
                    */
                   c.index = 0; /*unused*/
-                  c.gray = c.red = c.green = c.blue = (png_uint_16)gray;
+                  c.gray = c.red = c.green = c.blue =
+                     png_check_u16(png_ptr, gray);
 
                   /* NOTE: the following is apparently a bug in libpng. Without
                    * it the transparent color recognition in
@@ -2685,9 +2764,9 @@ png_image_read_colormap(png_voidp argument)
 
                   if (output_encoding == P_LINEAR)
                   {
-                     r = PNG_sRGB_FROM_LINEAR(back_r * 255);
-                     g = PNG_sRGB_FROM_LINEAR(back_g * 255);
-                     b = PNG_sRGB_FROM_LINEAR(back_b * 255);
+                     r = PNG_sRGB_FROM_LINEAR(png_ptr, back_r * 255);
+                     g = PNG_sRGB_FROM_LINEAR(png_ptr, back_g * 255);
+                     b = PNG_sRGB_FROM_LINEAR(png_ptr, back_b * 255);
                   }
 
                   else
@@ -2742,9 +2821,9 @@ png_image_read_colormap(png_voidp argument)
                      png_color_16 c;
 
                      c.index = 0; /*unused*/
-                     c.red = (png_uint_16)back_r;
-                     c.gray = c.green = (png_uint_16)back_g;
-                     c.blue = (png_uint_16)back_b;
+                     c.red = png_check_u16(png_ptr, back_r);
+                     c.gray = c.green = png_check_u16(png_ptr, back_g);
+                     c.blue = png_check_u16(png_ptr, back_b);
 
                      png_set_background_fixed(png_ptr, &c,
                         PNG_BACKGROUND_GAMMA_SCREEN, 0/*need_expand*/,
@@ -2848,7 +2927,7 @@ png_image_read_colormap(png_voidp argument)
    switch (data_encoding)
    {
       default:
-         png_error(png_ptr, "bad data option (internal error)");
+         impossible("bad data option");
          break;
 
       case P_sRGB:
@@ -2862,8 +2941,7 @@ png_image_read_colormap(png_voidp argument)
          break;
    }
 
-   if (cmap_entries > 256 || cmap_entries > image->colormap_entries)
-      png_error(png_ptr, "color map overflow (BAD internal error)");
+   affirm(cmap_entries <= 256 && cmap_entries <= image->colormap_entries);
 
    image->colormap_entries = cmap_entries;
 
@@ -2897,10 +2975,10 @@ png_image_read_colormap(png_voidp argument)
          break;
 
       default:
-         png_error(png_ptr, "bad processing option (internal error)");
+         impossible("bad processing option");
 
       bad_background:
-         png_error(png_ptr, "bad background index (internal error)");
+         impossible("bad background index");
    }
 
    display->colormap_processing = output_processing;
@@ -3009,7 +3087,7 @@ png_image_read_and_map(png_voidp argument)
                         entry = 226 + 6 * PNG_DIV51(alpha) + PNG_DIV51(gray);
                      }
 
-                     *outrow = (png_byte)entry;
+                     *outrow = png_check_byte(png_ptr, entry);
                   }
                   break;
 
@@ -3026,7 +3104,7 @@ png_image_read_and_map(png_voidp argument)
                         *outrow = gray;
 
                      else
-                        *outrow = (png_byte)(PNG_CMAP_TRANS_BACKGROUND+1);
+                        *outrow = PNG_CMAP_TRANS_BACKGROUND+1;
                   }
                   break;
 
@@ -3081,7 +3159,7 @@ png_image_read_and_map(png_voidp argument)
                         if (inrow[0] & 0x80) back_i += 1; /* blue */
                         if (inrow[0] & 0x40) back_i += 1;
 
-                        *outrow = (png_byte)back_i;
+                        *outrow = png_check_byte(png_ptr, back_i);
                      }
 
                      inrow += 4;
@@ -3172,7 +3250,7 @@ png_image_read_colormapped(png_voidp argument)
 
       default:
       bad_output:
-         png_error(png_ptr, "bad color-map processing (internal error)");
+         impossible("bad color-map processing");
    }
 
    /* Now read the rows.  Do this here if it is possible to read directly into
@@ -3329,10 +3407,11 @@ png_image_read_composite(png_voidp argument)
                          * therefore appropriate for the sRGB to linear
                          * conversion table.
                          */
-                        component = PNG_sRGB_FROM_LINEAR(component);
+                        component =
+                           PNG_sRGB_FROM_LINEAR(png_ptr, component);
                      }
 
-                     outrow[c] = (png_byte)component;
+                     outrow[c] = png_check_byte(png_ptr, component);
                   }
                }
 
@@ -3481,10 +3560,11 @@ png_image_read_background(png_voidp argument)
                               component = png_sRGB_table[component] * alpha;
                               component += png_sRGB_table[outrow[0]] *
                                  (255-alpha);
-                              component = PNG_sRGB_FROM_LINEAR(component);
+                              component =
+                                 PNG_sRGB_FROM_LINEAR(png_ptr, component);
                            }
 
-                           outrow[0] = (png_byte)component;
+                           outrow[0] = png_check_byte(png_ptr, component);
                         }
 
                         inrow += 2; /* gray and alpha channel */
@@ -3521,10 +3601,11 @@ png_image_read_background(png_voidp argument)
                            {
                               component = png_sRGB_table[component] * alpha;
                               component += background * (255-alpha);
-                              component = PNG_sRGB_FROM_LINEAR(component);
+                              component =
+                                 PNG_sRGB_FROM_LINEAR(png_ptr, component);
                            }
 
-                           outrow[0] = (png_byte)component;
+                           outrow[0] = png_check_byte(png_ptr, component);
                         }
 
                         else
@@ -3621,7 +3702,8 @@ png_image_read_background(png_voidp argument)
                      else
                         component = 0;
 
-                     outrow[swap_alpha] = (png_uint_16)component;
+                     outrow[swap_alpha] =
+                        png_check_u16(png_ptr, component);
                      if (preserve_alpha != 0)
                         outrow[1 ^ swap_alpha] = alpha;
 
@@ -3957,8 +4039,8 @@ png_image_read_direct(png_voidp argument)
          }
       }
 
-      else if (do_local_compose != 0) /* internal error */
-         png_error(png_ptr, "png_image_read: alpha channel lost");
+      else
+         affirm(do_local_compose == 0 /* else alpha channel lost */);
 
       if (info_ptr->bit_depth == 16)
          info_format |= PNG_FORMAT_FLAG_LINEAR;
@@ -3987,8 +4069,7 @@ png_image_read_direct(png_voidp argument)
 #     endif
 
       /* This is actually an internal error. */
-      if (info_format != format)
-         png_error(png_ptr, "png_read_image: invalid transformations");
+      affirm(info_format == format /* else unimplemented transformations */);
    }
 
    /* Now read the rows.  If do_local_compose is set then it is necessary to use

pngrio.c

@@ -1,7 +1,7 @@
 
 /* pngrio.c - functions for data input
  *
- * Last changed in libpng 1.6.17 [March 26, 2015]
+ * Last changed in libpng 1.7.0 [(PENDING RELEASE)]
  * Copyright (c) 1998-2015 Glenn Randers-Pehrson
  * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
  * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
@@ -19,6 +19,7 @@
  */
 
 #include "pngpriv.h"
+#define PNG_SRC_FILE PNG_SRC_FILE_rio
 
 #ifdef PNG_READ_SUPPORTED
 

pngset.c

@@ -1,7 +1,7 @@
 
 /* pngset.c - storage of image information into info struct
  *
- * Last changed in libpng 1.6.18 [(PENDING RELEASE)]
+ * Last changed in libpng 1.7.0 [(PENDING RELEASE)]
  * Copyright (c) 1998-2015 Glenn Randers-Pehrson
  * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
  * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
@@ -17,6 +17,7 @@
  */
 
 #include "pngpriv.h"
+#define PNG_SRC_FILE PNG_SRC_FILE_pngset
 
 #if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)
 
@@ -216,11 +217,11 @@ png_set_IHDR(png_const_structrp png_ptr, png_inforp info_ptr,
 
    info_ptr->width = width;
    info_ptr->height = height;
-   info_ptr->bit_depth = (png_byte)bit_depth;
-   info_ptr->color_type = (png_byte)color_type;
-   info_ptr->compression_type = (png_byte)compression_type;
-   info_ptr->filter_type = (png_byte)filter_type;
-   info_ptr->interlace_type = (png_byte)interlace_type;
+   info_ptr->bit_depth = png_check_byte(png_ptr, bit_depth);
+   info_ptr->color_type = png_check_byte(png_ptr, color_type);
+   info_ptr->compression_type = png_check_byte(png_ptr, compression_type);
+   info_ptr->filter_type = png_check_byte(png_ptr, filter_type);
+   info_ptr->interlace_type = png_check_byte(png_ptr, interlace_type);
 
    png_check_IHDR (png_ptr, info_ptr->width, info_ptr->height,
        info_ptr->bit_depth, info_ptr->color_type, info_ptr->interlace_type,
@@ -238,7 +239,8 @@ png_set_IHDR(png_const_structrp png_ptr, png_inforp info_ptr,
    if ((info_ptr->color_type & PNG_COLOR_MASK_ALPHA) != 0)
       info_ptr->channels++;
 
-   info_ptr->pixel_depth = (png_byte)(info_ptr->channels * info_ptr->bit_depth);
+   info_ptr->pixel_depth = png_check_byte(png_ptr, info_ptr->channels *
+           info_ptr->bit_depth);
 
    info_ptr->rowbytes = PNG_ROWBYTES(info_ptr->pixel_depth, width);
 }
@@ -255,7 +257,7 @@ png_set_oFFs(png_const_structrp png_ptr, png_inforp info_ptr,
 
    info_ptr->x_offset = offset_x;
    info_ptr->y_offset = offset_y;
-   info_ptr->offset_unit_type = (png_byte)unit_type;
+   info_ptr->offset_unit_type = png_check_byte(png_ptr, unit_type);
    info_ptr->valid |= PNG_INFO_oFFs;
 }
 #endif
@@ -311,8 +313,8 @@ png_set_pCAL(png_const_structrp png_ptr, png_inforp info_ptr,
    png_debug(3, "storing X0, X1, type, and nparams in info");
    info_ptr->pcal_X0 = X0;
    info_ptr->pcal_X1 = X1;
-   info_ptr->pcal_type = (png_byte)type;
-   info_ptr->pcal_nparams = (png_byte)nparams;
+   info_ptr->pcal_type = png_check_byte(png_ptr, type);
+   info_ptr->pcal_nparams = png_check_byte(png_ptr, nparams);
 
    length = strlen(units) + 1;
    png_debug1(3, "allocating units for info (%lu bytes)",
@@ -391,7 +393,7 @@ png_set_sCAL_s(png_const_structrp png_ptr, png_inforp info_ptr,
        sheight[0] == 45 /* '-' */ || !png_check_fp_string(sheight, lengthh))
       png_error(png_ptr, "Invalid sCAL height");
 
-   info_ptr->scal_unit = (png_byte)unit;
+   info_ptr->scal_unit = png_check_byte(png_ptr, unit);
 
    ++lengthw;
 
@@ -432,7 +434,8 @@ png_set_sCAL_s(png_const_structrp png_ptr, png_inforp info_ptr,
    info_ptr->free_me |= PNG_FREE_SCAL;
 }
 
-#  ifdef PNG_FLOATING_POINT_SUPPORTED
+#  if defined(PNG_FLOATING_POINT_SUPPORTED) &&\
+      defined(PNG_FLOATING_ARITHMETIC_SUPPORTED)
 void PNGAPI
 png_set_sCAL(png_const_structrp png_ptr, png_inforp info_ptr, int unit,
     double width, double height)
@@ -503,7 +506,7 @@ png_set_pHYs(png_const_structrp png_ptr, png_inforp info_ptr,
 
    info_ptr->x_pixels_per_unit = res_x;
    info_ptr->y_pixels_per_unit = res_y;
-   info_ptr->phys_unit_type = (png_byte)unit_type;
+   info_ptr->phys_unit_type = png_check_byte(png_ptr, unit_type);
    info_ptr->valid |= PNG_INFO_pHYs;
 }
 #endif
@@ -560,7 +563,8 @@ png_set_PLTE(png_structrp png_ptr, png_inforp info_ptr,
    if (num_palette > 0)
       memcpy(png_ptr->palette, palette, num_palette * (sizeof (png_color)));
    info_ptr->palette = png_ptr->palette;
-   info_ptr->num_palette = png_ptr->num_palette = (png_uint_16)num_palette;
+   info_ptr->num_palette = png_ptr->num_palette =
+      png_check_u16(png_ptr, num_palette);
 
    info_ptr->free_me |= PNG_FREE_PLTE;
 
@@ -693,7 +697,7 @@ png_set_iCCP(png_const_structrp png_ptr, png_inforp info_ptr,
 
 #ifdef PNG_TEXT_SUPPORTED
 void PNGAPI
-png_set_text(png_const_structrp png_ptr, png_inforp info_ptr,
+png_set_text(png_structrp png_ptr, png_inforp info_ptr,
     png_const_textp text_ptr, int num_text)
 {
    int ret;
@@ -704,7 +708,7 @@ png_set_text(png_const_structrp png_ptr, png_inforp info_ptr,
 }
 
 int /* PRIVATE */
-png_set_text_2(png_const_structrp png_ptr, png_inforp info_ptr,
+png_set_text_2(png_structrp png_ptr, png_inforp info_ptr,
     png_const_textp text_ptr, int num_text)
 {
    int i;
@@ -931,67 +935,99 @@ png_set_tRNS(png_structrp png_ptr, png_inforp info_ptr,
    png_debug1(1, "in %s storage function", "tRNS");
 
    if (png_ptr == NULL || info_ptr == NULL)
-
       return;
 
-   if (trans_alpha != NULL)
+   if (info_ptr->color_type & PNG_COLOR_MASK_ALPHA)
+      png_chunk_report(png_ptr,
+         "png_set_tRNS: invalid on PNG with alpha channel", PNG_CHUNK_ERROR);
+
+   else if (info_ptr->color_type & PNG_COLOR_MASK_PALETTE)
    {
-       /* It may not actually be necessary to set png_ptr->trans_alpha here;
-        * we do it for backward compatibility with the way the png_handle_tRNS
-        * function used to do the allocation.
-        *
-        * 1.6.0: The above statement is incorrect; png_handle_tRNS effectively
-        * relies on png_set_tRNS storing the information in png_struct
-        * (otherwise it won't be there for the code in pngrtran.c).
-        */
+      int max_num;
 
-       png_free_data(png_ptr, info_ptr, PNG_FREE_TRNS, 0);
+      /* Free the old data; num_trans 0 can be used to kill the tRNS */
+      png_free_data(png_ptr, info_ptr, PNG_FREE_TRNS, 0);
 
-       /* Changed from num_trans to PNG_MAX_PALETTE_LENGTH in version 1.2.1 */
-       png_ptr->trans_alpha = info_ptr->trans_alpha = png_voidcast(png_bytep,
-         png_malloc(png_ptr, PNG_MAX_PALETTE_LENGTH));
+      /* Do this just in case the old data was not owned by libpng: */
+      info_ptr->valid &= ~PNG_INFO_tRNS;
+      info_ptr->trans_alpha = NULL;
+      info_ptr->num_trans = 0;
 
-       if (num_trans > 0 && num_trans <= PNG_MAX_PALETTE_LENGTH)
-          memcpy(info_ptr->trans_alpha, trans_alpha, (png_size_t)num_trans);
+      /* Expect png_set_PLTE to happen before png_set_tRNS, so num_palette will
+       * be set, but this is not a requirement of the API.
+       */
+      if (png_ptr->num_palette)
+         max_num = png_ptr->num_palette;
+
+      else
+         max_num = 1 << png_ptr->bit_depth;
+
+      if (num_trans > max_num)
+      {
+         png_chunk_report(png_ptr, "png_set_tRNS: num_trans too large",
+            PNG_CHUNK_ERROR);
+         /* If control returns simply limit it; the behavior prior to 1.7 was to
+          * issue a warning and skip the palette in png_write_tRNS.
+          */
+         num_trans = max_num;
+      }
+
+      /* But only attempt a malloc if there is something to do; so the app can
+       * set a tRNS array then later delete it.
+       */
+      if (num_trans > 0 && trans_alpha != NULL)
+      {
+         /* Changed from num_trans to PNG_MAX_PALETTE_LENGTH in version 1.2.1,
+          * this avoids issues where a palette image contains out of range
+          * indices.
+          */
+         info_ptr->trans_alpha = png_voidcast(png_bytep, png_malloc(png_ptr,
+            PNG_MAX_PALETTE_LENGTH));
+         info_ptr->free_me |= PNG_FREE_TRNS;
+
+         memcpy(info_ptr->trans_alpha, trans_alpha,
+            (unsigned)/*SAFE*/num_trans);
+         info_ptr->valid |= PNG_INFO_tRNS;
+         info_ptr->num_trans = png_check_u16(png_ptr, num_trans);
+      }
    }
 
-   if (trans_color != NULL)
+   else /* not a PALETTE image */
    {
-#ifdef PNG_WARNINGS_SUPPORTED
-      if (info_ptr->bit_depth < 16)
+      /* Invalidate any prior transparent color and set num_trans. It is not
+       * used internally in this case but png_get_tRNS still returns it.
+       */
+      info_ptr->valid &= ~PNG_INFO_tRNS;
+      info_ptr->num_trans = 0; /* for png_get_tRNS */
+
+      if (trans_color != NULL && info_ptr->bit_depth < 16)
       {
-         int sample_max = (1 << info_ptr->bit_depth) - 1;
+         unsigned int sample_max = (1U << info_ptr->bit_depth) - 1U;
 
          if ((info_ptr->color_type == PNG_COLOR_TYPE_GRAY &&
-             trans_color->gray > sample_max) ||
+             trans_color->gray <= sample_max) ||
              (info_ptr->color_type == PNG_COLOR_TYPE_RGB &&
-             (trans_color->red > sample_max ||
-             trans_color->green > sample_max ||
-             trans_color->blue > sample_max)))
-            png_warning(png_ptr,
-               "tRNS chunk has out-of-range samples for bit_depth");
+             trans_color->red <= sample_max &&
+             trans_color->green <= sample_max &&
+             trans_color->blue <= sample_max))
+         {
+            info_ptr->trans_color = *trans_color;
+            info_ptr->valid |= PNG_INFO_tRNS;
+            info_ptr->num_trans = 1; /* for png_get_tRNS */
+         }
+
+         else
+            png_chunk_report(png_ptr,
+               "tRNS chunk has out-of-range samples for bit_depth",
+               PNG_CHUNK_ERROR);
       }
-#endif
-
-      info_ptr->trans_color = *trans_color;
-
-      if (num_trans == 0)
-         num_trans = 1;
-   }
-
-   info_ptr->num_trans = (png_uint_16)num_trans;
-
-   if (num_trans != 0)
-   {
-      info_ptr->valid |= PNG_INFO_tRNS;
-      info_ptr->free_me |= PNG_FREE_TRNS;
    }
 }
 #endif
 
 #ifdef PNG_sPLT_SUPPORTED
 void PNGAPI
-png_set_sPLT(png_const_structrp png_ptr,
+png_set_sPLT(png_structrp png_ptr,
     png_inforp info_ptr, png_const_sPLT_tp entries, int nentries)
 /*
  *  entries        - array of png_sPLT_t structures
@@ -1105,7 +1141,7 @@ check_location(png_const_structrp png_ptr, int location)
       png_app_warning(png_ptr,
          "png_set_unknown_chunks now expects a valid location");
       /* Use the old behavior */
-      location = (png_byte)(png_ptr->mode &
+      location = png_check_byte(png_ptr, png_ptr->mode &
          (PNG_HAVE_IHDR|PNG_HAVE_PLTE|PNG_AFTER_IDAT));
    }
 
@@ -1124,11 +1160,11 @@ check_location(png_const_structrp png_ptr, int location)
    /* The cast is safe because 'location' is a bit mask and only the low four
     * bits are significant.
     */
-   return (png_byte)location;
+   return png_check_byte(png_ptr, location);
 }
 
 void PNGAPI
-png_set_unknown_chunks(png_const_structrp png_ptr,
+png_set_unknown_chunks(png_structrp png_ptr,
    png_inforp info_ptr, png_const_unknown_chunkp unknowns, int num_unknowns)
 {
    png_unknown_chunkp np;
@@ -1232,8 +1268,6 @@ png_set_unknown_chunk_location(png_const_structrp png_ptr, png_inforp info_ptr,
 {
    /* This API is pretty pointless in 1.6.0 because the location can be set
     * before the call to png_set_unknown_chunks.
-    *
-    * TODO: add a png_app_warning in 1.7
     */
    if (png_ptr != NULL && info_ptr != NULL && chunk >= 0 &&
       chunk < info_ptr->unknown_chunks_num)
@@ -1252,6 +1286,10 @@ png_set_unknown_chunk_location(png_const_structrp png_ptr, png_inforp info_ptr,
       info_ptr->unknown_chunks[chunk].location =
          check_location(png_ptr, location);
    }
+
+   /* TODO: make this an error in 1.8 (or maybe it will become one in 1.7!) */
+   else if (png_ptr != NULL)
+      png_app_warning(png_ptr, "unknown chunk index out of range");
 }
 #endif /* STORE_UNKNOWN_CHUNKS */
 
@@ -1272,7 +1310,8 @@ png_permit_mng_features (png_structrp png_ptr, png_uint_32 mng_features)
 
 #ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED
 static unsigned int
-add_one_chunk(png_bytep list, unsigned int count, png_const_bytep add, int keep)
+add_one_chunk(png_const_structrp png_ptr, png_bytep list, unsigned int count,
+   png_const_bytep add, int keep)
 {
    unsigned int i;
 
@@ -1283,7 +1322,7 @@ add_one_chunk(png_bytep list, unsigned int count, png_const_bytep add, int keep)
    {
       if (memcmp(list, add, 4) == 0)
       {
-         list[4] = (png_byte)keep;
+         list[4] = png_check_byte(png_ptr, keep);
 
          return count;
       }
@@ -1293,10 +1332,11 @@ add_one_chunk(png_bytep list, unsigned int count, png_const_bytep add, int keep)
    {
       ++count;
       memcpy(list, add, 4);
-      list[4] = (png_byte)keep;
+      list[4] = png_check_byte(png_ptr, keep);
    }
 
    return count;
+   PNG_UNUSEDRC(png_ptr)
 }
 
 void PNGAPI
@@ -1414,7 +1454,7 @@ png_set_keep_unknown_chunks(png_structrp png_ptr, int keep,
 
       for (i=0; i<num_chunks; ++i)
       {
-         old_num_chunks = add_one_chunk(new_list, old_num_chunks,
+         old_num_chunks = add_one_chunk(png_ptr, new_list, old_num_chunks,
             chunk_list+5*i, keep);
       }
 

pngstruct.h

@@ -1,7 +1,7 @@
 
 /* pngstruct.h - header file for PNG reference library
  *
- * Last changed in libpng 1.6.18 [(PENDING RELEASE)]
+ * Last changed in libpng 1.7.0 [(PENDING RELEASE)]
  * Copyright (c) 1998-2015 Glenn Randers-Pehrson
  * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
  * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
@@ -27,7 +27,9 @@
    /* We must ensure that zlib uses 'const' in declarations. */
 #  define ZLIB_CONST
 #endif
-#include "zlib.h"
+
+#include PNG_ZLIB_HEADER
+
 #ifdef const
    /* zlib.h sometimes #defines const to nothing, undo this. */
 #  undef const
@@ -47,10 +49,10 @@
 /* zlib.h declares a magic type 'uInt' that limits the amount of data that zlib
  * can handle at once.  This type need be no larger than 16 bits (so maximum of
  * 65535), this define allows us to discover how big it is, but limited by the
- * maximuum for png_size_t.  The value can be overriden in a library build
- * (pngusr.h, or set it in CPPFLAGS) and it works to set it to a considerably
- * lower value (e.g. 255 works).  A lower value may help memory usage (slightly)
- * and may even improve performance on some systems (and degrade it on others.)
+ * maximum for size_t. The value can be overridden in a library build (pngusr.h,
+ * or set it in CPPFLAGS) and it works to set it to a considerably lower value
+ * (e.g. 255 works).  A lower value may help memory usage (slightly) and may
+ * even improve performance on some systems (and degrade it on others.)
  */
 #ifndef ZLIB_IO_MAX
 #  define ZLIB_IO_MAX ((uInt)-1)
@@ -136,310 +138,234 @@ typedef const png_colorspace * PNG_RESTRICT png_const_colorspacerp;
 #define PNG_COLORSPACE_FROM_sRGB            0x0020
 #define PNG_COLORSPACE_ENDPOINTS_MATCH_sRGB 0x0040
 #define PNG_COLORSPACE_MATCHES_sRGB         0x0080 /* exact match on profile */
+#define PNG_COLORSPACE_RGB_TO_GRAY_SET      0x0100 /* user specified coeffs */
 #define PNG_COLORSPACE_INVALID              0x8000
 #define PNG_COLORSPACE_CANCEL(flags)        (0xffff ^ (flags))
 #endif /* COLORSPACE || GAMMA */
 
 struct png_struct_def
 {
+   /* Rearranged in libpng 1.7 to attempt to lessen padding; in general
+    * (char), (short), (int) and pointer types are kept separate; however
+    * associated members under the control of the same #define are still
+    * together.
+    */
 #ifdef PNG_SETJMP_SUPPORTED
-   jmp_buf jmp_buf_local;     /* New name in 1.6.0 for jmp_buf in png_struct */
-   png_longjmp_ptr longjmp_fn;/* setjmp non-local goto function. */
-   jmp_buf *jmp_buf_ptr;      /* passed to longjmp_fn */
-   size_t jmp_buf_size;       /* size of the above, if allocated */
-#endif
-   png_error_ptr error_fn;    /* function for printing errors and aborting */
-#ifdef PNG_WARNINGS_SUPPORTED
-   png_error_ptr warning_fn;  /* function for printing warnings */
-#endif
-   png_voidp error_ptr;       /* user supplied struct for error functions */
-   png_rw_ptr write_data_fn;  /* function for writing output data */
-   png_rw_ptr read_data_fn;   /* function for reading input data */
-   png_voidp io_ptr;          /* ptr to application struct for I/O functions */
-
-#ifdef PNG_READ_USER_TRANSFORM_SUPPORTED
-   png_user_transform_ptr read_user_transform_fn; /* user read transform */
+   /* jmp_buf can have very high alignment requirements on some systems, so put
+    * it first (the other setjmp members are later as they are infrequently
+    * accessed.)
+    */
+   jmp_buf jmp_buf_local;
 #endif
 
-#ifdef PNG_WRITE_USER_TRANSFORM_SUPPORTED
-   png_user_transform_ptr write_user_transform_fn; /* user write transform */
-#endif
+   /* Next the frequently accessed fields.  Many processors perform arithmetic
+    * in the address pipeline, but frequently the amount of addition or
+    * subtraction is limited.  By putting these fields at the head of png_struct
+    * the hope is that such processors will generate code that is both smaller
+    * and faster.
+    */
+   png_colorp  palette;        /* palette from the input file */
+   png_bytep   trans_alpha;    /* alpha values for paletted files */
 
-/* These were added in libpng-1.0.2 */
-#ifdef PNG_USER_TRANSFORM_PTR_SUPPORTED
-#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \
-    defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED)
-   png_voidp user_transform_ptr; /* user supplied struct for user transform */
-   png_byte user_transform_depth;    /* bit depth of user transformed pixels */
-   png_byte user_transform_channels; /* channels in user transformed pixels */
-#endif
-#endif
+   size_t      rowbytes;       /* size of row in bytes */
+   size_t      info_rowbytes;  /* cache of updated row bytes */
+   png_uint_32 width;          /* width of image in pixels */
+   png_uint_32 height;         /* height of image in pixels */
+   png_uint_32 num_rows;       /* number of rows in current pass */
+   /* TODO: usr_width is used in write, iwidth is used in read, the two fields
+    * could be made one.
+    */
+   png_uint_32 usr_width;      /* width of row at start of write */
+   png_uint_32 iwidth;         /* width of current interlaced row in pixels */
+   png_uint_32 row_number;     /* current row in interlace pass */
+   png_uint_32 chunk_name;     /* PNG_CHUNK() id of current chunk */
+   png_uint_32 crc;            /* current chunk CRC value */
+   png_uint_32 mode;           /* tells us where we are in the PNG file */
+   png_uint_32 flags;          /* flags indicating various things to libpng */
+   png_uint_32 transformations;/* which transformations to perform */
+   png_uint_32 zowner;         /* ID (chunk type) of zstream owner, 0 if none */
+   png_uint_32 free_me;        /* items libpng is responsible for freeing */
 
-   png_uint_32 mode;          /* tells us where we are in the PNG file */
-   png_uint_32 flags;         /* flags indicating various things to libpng */
-   png_uint_32 transformations; /* which transformations to perform */
-
-   png_uint_32 zowner;        /* ID (chunk type) of zstream owner, 0 if none */
-   z_stream    zstream;       /* decompression structure */
-
-#ifdef PNG_WRITE_SUPPORTED
-   png_compression_bufferp zbuffer_list; /* Created on demand during write */
-   uInt                    zbuffer_size; /* size of the actual buffer */
-
-   int zlib_level;            /* holds zlib compression level */
-   int zlib_method;           /* holds zlib compression method */
-   int zlib_window_bits;      /* holds zlib compression window bits */
-   int zlib_mem_level;        /* holds zlib compression memory level */
-   int zlib_strategy;         /* holds zlib compression strategy */
-#endif
-/* Added at libpng 1.5.4 */
-#ifdef PNG_WRITE_CUSTOMIZE_ZTXT_COMPRESSION_SUPPORTED
-   int zlib_text_level;            /* holds zlib compression level */
-   int zlib_text_method;           /* holds zlib compression method */
-   int zlib_text_window_bits;      /* holds zlib compression window bits */
-   int zlib_text_mem_level;        /* holds zlib compression memory level */
-   int zlib_text_strategy;         /* holds zlib compression strategy */
-#endif
-/* End of material added at libpng 1.5.4 */
-/* Added at libpng 1.6.0 */
-#ifdef PNG_WRITE_SUPPORTED
-   int zlib_set_level;        /* Actual values set into the zstream on write */
-   int zlib_set_method;
-   int zlib_set_window_bits;
-   int zlib_set_mem_level;
-   int zlib_set_strategy;
-#endif
-
-   png_uint_32 width;         /* width of image in pixels */
-   png_uint_32 height;        /* height of image in pixels */
-   png_uint_32 num_rows;      /* number of rows in current pass */
-   png_uint_32 usr_width;     /* width of row at start of write */
-   png_size_t rowbytes;       /* size of row in bytes */
-   png_uint_32 iwidth;        /* width of current interlaced row in pixels */
-   png_uint_32 row_number;    /* current row in interlace pass */
-   png_uint_32 chunk_name;    /* PNG_CHUNK() id of current chunk */
-   png_bytep prev_row;        /* buffer to save previous (unfiltered) row.
-                               * While reading this is a pointer into
-                               * big_prev_row; while writing it is separately
-                               * allocated if needed.
-                               */
-   png_bytep row_buf;         /* buffer to save current (unfiltered) row.
-                               * While reading, this is a pointer into
-                               * big_row_buf; while writing it is separately
-                               * allocated.
-                               */
-#ifdef PNG_WRITE_FILTER_SUPPORTED
-   png_bytep try_row;    /* buffer to save trial row when filtering */
-   png_bytep tst_row;    /* buffer to save best trial row when filtering */
-#endif
-   png_size_t info_rowbytes;  /* Added in 1.5.4: cache of updated row bytes */
-
-   png_uint_32 idat_size;     /* current IDAT size for read */
-   png_uint_32 crc;           /* current chunk CRC value */
-   png_colorp palette;        /* palette from the input file */
-   png_uint_16 num_palette;   /* number of color entries in palette */
-
-/* Added at libpng-1.5.10 */
+   unsigned int maximum_pixel_depth; /* pixel depth used for the row buffers */
 #ifdef PNG_CHECK_FOR_INVALID_INDEX_SUPPORTED
-   int num_palette_max;       /* maximum palette index found in IDAT */
+   int         num_palette_max;     /* maximum palette index found in IDAT */
 #endif
 
+   png_uint_16 num_palette;   /* number of color entries in palette */
    png_uint_16 num_trans;     /* number of transparency values */
-   png_byte compression;      /* file compression type (always 0) */
+
+   /* Single byte values, typically used either to save space or to hold 1-byte
+    * values from the PNG chunk specifications.
+    */
+   png_byte compression_type; /* file compression type (always 0) */
    png_byte filter;           /* file filter type (always 0) */
    png_byte interlaced;       /* PNG_INTERLACE_NONE, PNG_INTERLACE_ADAM7 */
    png_byte pass;             /* current interlace pass (0 - 6) */
    png_byte do_filter;        /* row filter flags (see PNG_FILTER_ below ) */
    png_byte color_type;       /* color type of file */
    png_byte bit_depth;        /* bit depth of file */
-   png_byte usr_bit_depth;    /* bit depth of users row: write only */
    png_byte pixel_depth;      /* number of bits per pixel */
    png_byte channels;         /* number of channels in file */
-#ifdef PNG_WRITE_SUPPORTED
-   png_byte usr_channels;     /* channels at start of write: write only */
-#endif
    png_byte sig_bytes;        /* magic bytes read/written from start of file */
-   png_byte maximum_pixel_depth;
-                              /* pixel depth used for the row buffers */
    png_byte transformed_pixel_depth;
                               /* pixel depth after read/write transforms */
-#if defined(PNG_READ_FILLER_SUPPORTED) || defined(PNG_WRITE_FILLER_SUPPORTED)
-   png_uint_16 filler;           /* filler bytes for pixel expansion */
+
+   /* ERROR HANDLING */
+#ifdef PNG_SETJMP_SUPPORTED
+   jmp_buf        *jmp_buf_ptr;   /* passed to longjmp_fn */
+   png_longjmp_ptr longjmp_fn;    /* setjmp non-local goto function. */
+   size_t          jmp_buf_size;  /* size of *jmp_buf_ptr, if allocated */
 #endif
 
-#if defined(PNG_bKGD_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) ||\
-   defined(PNG_READ_ALPHA_MODE_SUPPORTED)
-   png_byte background_gamma_type;
-   png_fixed_point background_gamma;
-   png_color_16 background;   /* background color in screen gamma space */
-#ifdef PNG_READ_GAMMA_SUPPORTED
-   png_color_16 background_1; /* background normalized to gamma 1.0 */
+   /* Error/warning callbacks */
+   png_error_ptr error_fn;        /* print an error message and abort */
+#ifdef PNG_WARNINGS_SUPPORTED
+   png_error_ptr warning_fn;      /* print a warning and continue */
 #endif
-#endif /* bKGD */
+   png_voidp     error_ptr;       /* user supplied data for the above */
 
-#ifdef PNG_WRITE_FLUSH_SUPPORTED
-   png_flush_ptr output_flush_fn; /* Function for flushing output */
-   png_uint_32 flush_dist;    /* how many rows apart to flush, 0 - no flush */
-   png_uint_32 flush_rows;    /* number of rows written since last flush */
-#endif
-
-#ifdef PNG_READ_GAMMA_SUPPORTED
-   int gamma_shift;      /* number of "insignificant" bits in 16-bit gamma */
-   png_fixed_point screen_gamma; /* screen gamma value (display_exponent) */
-
-   png_bytep gamma_table;     /* gamma table for 8-bit depth files */
-   png_uint_16pp gamma_16_table; /* gamma table for 16-bit depth files */
-#if defined(PNG_READ_BACKGROUND_SUPPORTED) || \
-   defined(PNG_READ_ALPHA_MODE_SUPPORTED) || \
-   defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)
-   png_bytep gamma_from_1;    /* converts from 1.0 to screen */
-   png_bytep gamma_to_1;      /* converts from file to 1.0 */
-   png_uint_16pp gamma_16_from_1; /* converts from 1.0 to screen */
-   png_uint_16pp gamma_16_to_1; /* converts from file to 1.0 */
-#endif /* READ_BACKGROUND || READ_ALPHA_MODE || RGB_TO_GRAY */
-#endif
-
-#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_sBIT_SUPPORTED)
-   png_color_8 sig_bit;       /* significant bits in each available channel */
-#endif
-
-#if defined(PNG_READ_SHIFT_SUPPORTED) || defined(PNG_WRITE_SHIFT_SUPPORTED)
-   png_color_8 shift;         /* shift for significant bit tranformation */
-#endif
-
-#if defined(PNG_tRNS_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) \
- || defined(PNG_READ_EXPAND_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED)
-   png_bytep trans_alpha;           /* alpha values for paletted files */
-   png_color_16 trans_color;  /* transparent color for non-paletted files */
-#endif
-
-   png_read_status_ptr read_row_fn;   /* called after each row is decoded */
-   png_write_status_ptr write_row_fn; /* called after each row is encoded */
-#ifdef PNG_PROGRESSIVE_READ_SUPPORTED
-   png_progressive_info_ptr info_fn; /* called after header data fully read */
-   png_progressive_row_ptr row_fn;   /* called after a prog. row is decoded */
-   png_progressive_end_ptr end_fn;   /* called after image is complete */
-   png_bytep save_buffer_ptr;        /* current location in save_buffer */
-   png_bytep save_buffer;            /* buffer for previously read data */
-   png_bytep current_buffer_ptr;     /* current location in current_buffer */
-   png_bytep current_buffer;         /* buffer for recently used data */
-   png_uint_32 push_length;          /* size of current input chunk */
-   png_uint_32 skip_length;          /* bytes to skip in input data */
-   png_size_t save_buffer_size;      /* amount of data now in save_buffer */
-   png_size_t save_buffer_max;       /* total size of save_buffer */
-   png_size_t buffer_size;           /* total amount of available input data */
-   png_size_t current_buffer_size;   /* amount of data now in current_buffer */
-   int process_mode;                 /* what push library is currently doing */
-   int cur_palette;                  /* current push library palette index */
-
-#endif /* PROGRESSIVE_READ */
-
-#if defined(__TURBOC__) && !defined(_Windows) && !defined(__FLAT__)
-/* For the Borland special 64K segment handler */
-   png_bytepp offset_table_ptr;
-   png_bytep offset_table;
-   png_uint_16 offset_table_number;
-   png_uint_16 offset_table_count;
-   png_uint_16 offset_table_count_free;
-#endif
-
-#ifdef PNG_READ_QUANTIZE_SUPPORTED
-   png_bytep palette_lookup; /* lookup table for quantizing */
-   png_bytep quantize_index; /* index translation for palette files */
-#endif
-
-/* Options */
-#ifdef PNG_SET_OPTION_SUPPORTED
-   png_byte options;           /* On/off state (up to 4 options) */
-#endif
-
-#if PNG_LIBPNG_VER < 10700
-/* To do: remove this from libpng-1.7 */
-#ifdef PNG_TIME_RFC1123_SUPPORTED
-   char time_buffer[29]; /* String to hold RFC 1123 time text */
-#endif
-#endif
-
-/* New members added in libpng-1.0.6 */
-
-   png_uint_32 free_me;    /* flags items libpng is responsible for freeing */
-
-#ifdef PNG_USER_CHUNKS_SUPPORTED
-   png_voidp user_chunk_ptr;
-#ifdef PNG_READ_USER_CHUNKS_SUPPORTED
-   png_user_chunk_ptr read_user_chunk_fn; /* user read chunk handler */
-#endif
-#endif
-
-#ifdef PNG_SET_UNKNOWN_CHUNKS_SUPPORTED
-   int          unknown_default; /* As PNG_HANDLE_* */
-   unsigned int num_chunk_list;  /* Number of entries in the list */
-   png_bytep    chunk_list;      /* List of png_byte[5]; the textual chunk name
-                                  * followed by a PNG_HANDLE_* byte */
-#endif
-
-/* New members added in libpng-1.0.3 */
-#ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED
-   png_byte rgb_to_gray_status;
-   /* Added in libpng 1.5.5 to record setting of coefficients: */
-   png_byte rgb_to_gray_coefficients_set;
-   /* These were changed from png_byte in libpng-1.0.6 */
-   png_uint_16 rgb_to_gray_red_coeff;
-   png_uint_16 rgb_to_gray_green_coeff;
-   /* deleted in 1.5.5: rgb_to_gray_blue_coeff; */
-#endif
-
-/* New member added in libpng-1.0.4 (renamed in 1.0.9) */
-#if defined(PNG_MNG_FEATURES_SUPPORTED)
-/* Changed from png_byte to png_uint_32 at version 1.2.0 */
-   png_uint_32 mng_features_permitted;
-#endif
-
-/* New member added in libpng-1.0.9, ifdef'ed out in 1.0.12, enabled in 1.2.0 */
-#ifdef PNG_MNG_FEATURES_SUPPORTED
-   png_byte filter_type;
-#endif
-
-/* New members added in libpng-1.2.0 */
-
-/* New members added in libpng-1.0.2 but first enabled by default in 1.2.0 */
+   /* MEMORY ALLOCATION */
 #ifdef PNG_USER_MEM_SUPPORTED
-   png_voidp mem_ptr;             /* user supplied struct for mem functions */
-   png_malloc_ptr malloc_fn;      /* function for allocating memory */
-   png_free_ptr free_fn;          /* function for freeing memory */
+   png_malloc_ptr malloc_fn; /* allocate memory */
+   png_free_ptr   free_fn;   /* free memory */
+   png_voidp      mem_ptr;   /* user supplied data for the above */
 #endif
 
-/* New member added in libpng-1.0.13 and 1.2.0 */
-   png_bytep big_row_buf;         /* buffer to save current (unfiltered) row */
+   /* IO and BASIC READ/WRITE SUPPORT */
+   png_voidp            io_ptr;       /* user supplied data for IO callbacks */
 
-#ifdef PNG_READ_QUANTIZE_SUPPORTED
-/* The following three members were added at version 1.0.14 and 1.2.4 */
-   png_bytep quantize_sort;          /* working sort array */
-   png_bytep index_to_palette;       /* where the original index currently is
-                                        in the palette */
-   png_bytep palette_to_index;       /* which original index points to this
-                                         palette color */
-#endif
+#ifdef PNG_READ_SUPPORTED
+   png_rw_ptr          read_data_fn;  /* read some bytes (must succeed) */
+   png_read_status_ptr read_row_fn;   /* called after each row is decoded */
+   png_bytep           read_buffer;   /* buffer for reading chunk data */
 
-/* New members added in libpng-1.0.16 and 1.2.6 */
-   png_byte compression_type;
-
-#ifdef PNG_USER_LIMITS_SUPPORTED
-   png_uint_32 user_width_max;
-   png_uint_32 user_height_max;
-
-   /* Added in libpng-1.4.0: Total number of sPLT, text, and unknown
-    * chunks that can be stored (0 means unlimited).
+   /* During read the following array is set up to point to the appropriate
+    * un-filter function, this allows per-image and per-processor optimization.
     */
-   png_uint_32 user_chunk_cache_max;
+   void (*read_filter[PNG_FILTER_VALUE_LAST-1])(png_row_infop row_info,
+      png_bytep row, png_const_bytep prev_row);
 
-   /* Total memory that a zTXt, sPLT, iTXt, iCCP, or unknown chunk
-    * can occupy when decompressed.  0 means unlimited.
+#if defined(PNG_COLORSPACE_SUPPORTED) || defined(PNG_GAMMA_SUPPORTED)
+   /* The png_struct colorspace structure is only required on read - on write it
+    * is in (just) the info_struct.
+    */
+   png_colorspace   colorspace;
+#endif
+#endif /* READ */
+
+#ifdef PNG_SET_USER_LIMITS_SUPPORTED
+   png_uint_32 user_width_max;        /* Maximum width on read */
+   png_uint_32 user_height_max;       /* Maximum height on read */
+   /* Total memory that a single zTXt, sPLT, iTXt, iCCP, or unknown chunk
+    * can occupy when decompressed.  0 means unlimited.  This field is a counter
+    * - it is decremented as memory is allocated.
     */
    png_alloc_size_t user_chunk_malloc_max;
 #endif
+#ifdef PNG_USER_LIMITS_SUPPORTED
+   /* limit on total *number* of sPLT, text and unknown chunks that can be
+    * stored.  0 means unlimited.  This field is a counter - it is decremented
+    * as chunks are encountered.
+    */
+   png_uint_32 user_chunk_cache_max;
+#endif
 
-/* New member added in libpng-1.0.25 and 1.2.17 */
+   /* The progressive reader gets passed data and calls application handling
+    * functions when appropriate.
+    */
+#ifdef PNG_PROGRESSIVE_READ_SUPPORTED
+   png_progressive_info_ptr info_fn; /* called after header data fully read */
+   png_progressive_row_ptr  row_fn;  /* called after a row is decoded */
+   png_progressive_end_ptr  end_fn;  /* called after image is complete */
+
+   /* Progressive read control data */
+   png_bytep   save_buffer_ptr;      /* current location in save_buffer */
+   png_bytep   save_buffer;          /* buffer for previously read data */
+   png_bytep   current_buffer_ptr;   /* current location in current_buffer */
+   png_bytep   current_buffer;       /* buffer for recently used data */
+
+   size_t      save_buffer_size;     /* amount of data now in save_buffer */
+   size_t      save_buffer_max;      /* total size of save_buffer */
+   size_t      buffer_size;          /* total amount of available input data */
+   size_t      current_buffer_size;  /* amount of data now in current_buffer */
+
+   png_uint_32 push_length;          /* size of current input chunk */
+   png_uint_32 skip_length;          /* bytes to skip in input data */
+
+   int         process_mode;         /* what push library is currently doing */
+   int         cur_palette;          /* current push library palette index */
+#endif
+
+#ifdef PNG_WRITE_SUPPORTED
+   png_rw_ptr              write_data_fn;/* write some bytes (must succeed) */
+   png_write_status_ptr    write_row_fn; /* called after each row is encoded */
+#endif
+
+#ifdef PNG_WRITE_FLUSH_SUPPORTED
+   png_flush_ptr output_flush_fn; /* Function for flushing output */
+   png_uint_32   flush_dist; /* how many rows apart to flush, 0 - no flush */
+   png_uint_32   flush_rows; /* number of rows written since last flush */
+#endif
+
+#ifdef PNG_WRITE_SUPPORTED
+   png_byte     usr_bit_depth;       /* bit depth of users row */
+   png_byte     usr_channels;        /* channels at start of write */
+#endif
+
+#ifdef PNG_IO_STATE_SUPPORTED
+   png_uint_32          io_state;     /* tells the app read/write progress */
+#endif
+
+   /* ROW BUFFERS
+    *
+    * Members that hold pointers to the decompressed image rows.
+    */
+   png_bytep row_buf;         /* buffer to save current (unfiltered) row.
+                               * While reading, this is a pointer into
+                               * big_row_buf; while writing it is separately
+                               * allocated.
+                               */
+#if defined(PNG_WRITE_FILTER_SUPPORTED) || defined(PNG_READ_SUPPORTED)
+   png_bytep prev_row;        /* buffer to save previous (unfiltered) row.
+                               * While reading this is a pointer into
+                               * big_prev_row; while writing it is separately
+                               * allocated if needed.
+                               */
+#endif
+
+#ifdef PNG_READ_SUPPORTED
+   /* The row_buf and prev_row pointers are misaligned so that the start of the
+    * row - after the filter byte - is aligned, the 'big_' pointers record the
+    * original allocated pointer.  These are only used while reading.
+    */
+   png_bytep big_row_buf;
+   png_bytep big_prev_row;
+   size_t    big_row_buf_size; /* Actual size of both */
+#endif
+
+#ifdef PNG_WRITE_FILTER_SUPPORTED
+   png_bytep try_row;    /* buffer to save trial row when filtering */
+   png_bytep tst_row;    /* buffer to save best trial row when filtering */
+#endif
+
+   /* UNKNOWN CHUNK HANDLING */
+   /* TODO: this is excessively complicated, there are multiple ways of doing
+    * the same thing.  It should be cleaned up, possibly by finding out which
+    * APIs applications really use.
+    */
+#ifdef PNG_USER_CHUNKS_SUPPORTED
+   /* General purpose pointer for all user/unknown chunk handling; points to
+    * application supplied data for use in the read_user_chunk_fn callback
+    * (currently there is no write side support - the write side must use the
+    * set_unknown_chunks interface.)
+    */
+   png_voidp user_chunk_ptr;
+#endif
+
+#ifdef PNG_READ_USER_CHUNKS_SUPPORTED
+   /* This is called back from the unknown chunk handling */
+   png_user_chunk_ptr     read_user_chunk_fn; /* user read chunk handler */
+#endif
 #ifdef PNG_READ_UNKNOWN_CHUNKS_SUPPORTED
    /* Temporary storage for unknown chunk that the library doesn't recognize,
     * used while reading the chunk.
@@ -447,34 +373,176 @@ struct png_struct_def
    png_unknown_chunk unknown_chunk;
 #endif
 
-/* New member added in libpng-1.2.26 */
-  png_size_t old_big_row_buf_size;
+#ifdef PNG_SET_UNKNOWN_CHUNKS_SUPPORTED
+   png_bytep    chunk_list;      /* List of png_byte[5]; the textual chunk name
+                                  * followed by a PNG_HANDLE_* byte */
+   int          unknown_default; /* As PNG_HANDLE_* */
+   unsigned int num_chunk_list;  /* Number of entries in the list */
+#endif
+
+   /* USER TRANSFORM SUPPORT */
+#ifdef PNG_READ_USER_TRANSFORM_SUPPORTED
+   png_user_transform_ptr read_user_transform_fn; /* user read transform */
+#endif
+#ifdef PNG_WRITE_USER_TRANSFORM_SUPPORTED
+   png_user_transform_ptr write_user_transform_fn; /* user write transform */
+#endif
+#ifdef PNG_USER_TRANSFORM_PTR_SUPPORTED
+   png_voidp user_transform_ptr;      /* user supplied data for the above */
+   png_byte  user_transform_depth;    /* bit depth of user transformed pixels */
+   png_byte  user_transform_channels; /* channels in user transformed pixels */
+#endif
+
+   /* READ TRANSFORM SUPPORT
+    *
+    * Quite a lot of things can be done to the original image data on read, and
+    * most of these are configurable.  The data required by the configurable
+    * read transforms should be stored here.  The png_color_16 and png_color_8
+    * structures have low alignment requirements and odd sizes, so may cause
+    * misalignment when present.  Member alignment is as follows:
+    *
+    *    png_color_16   png_uint_16
+    *    png_color_8    png_byte
+    */
+   /* GAMMA/BACKGROUND/ALPHA-MODE/RGB-TO-GRAY/tRNS/sBIT
+    *
+    * These things are all interrelated because they need some or all of the
+    * gamma tables.  Some attempt has been made below to order these members by
+    * size, so that as little padding as possible is required.
+    */
+#ifdef PNG_READ_GAMMA_SUPPORTED
+   png_bytep gamma_table;        /* gamma table for 8-bit depth files */
+   png_uint_16p gamma_16_table;  /* gamma table for 16-bit depth files */
+
+#if defined(PNG_READ_BACKGROUND_SUPPORTED) ||\
+   defined(PNG_READ_ALPHA_MODE_SUPPORTED) ||\
+   defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)
+   png_bytep gamma_from_1;       /* converts from 1.0 to screen */
+   png_uint_16p gamma_to_1;      /* converts from file to 1.0 */
+   png_uint_16p gamma_16_from_1; /* converts from 1.0 to screen */
+   png_uint_16p gamma_16_to_1;   /* converts from file to 1.0 */
+#endif /* READ_BACKGROUND || READ_ALPHA_MODE || RGB_TO_GRAY */
+#endif /* READ_GAMMA */
+
+   /* Integer values */
+#if defined(PNG_READ_BACKGROUND_SUPPORTED) ||\
+   defined(PNG_READ_ALPHA_MODE_SUPPORTED)
+   png_fixed_point background_gamma;
+#endif
+#ifdef PNG_READ_GAMMA_SUPPORTED
+   png_fixed_point screen_gamma; /* screen gamma value (display_exponent) */
+   int gamma_shift; /* number of "insignificant" bits in 16-bit gamma */
+#endif
+
+   /* png_color_16 */
+#if defined(PNG_READ_BACKGROUND_SUPPORTED) ||\
+   defined(PNG_READ_ALPHA_MODE_SUPPORTED)
+   png_color_16 background;   /* background color in screen gamma space */
+   png_color_16 background_1; /* background normalized to gamma 1.0 */
+#endif
+#if defined(PNG_READ_tRNS_SUPPORTED) || \
+   defined(PNG_READ_BACKGROUND_SUPPORTED) || \
+   defined(PNG_READ_EXPAND_SUPPORTED)
+   png_color_16 trans_color;  /* transparent color for non-paletted files */
+#endif
+
+   /* png_uint_16 */
+#ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED
+   png_uint_16 rgb_to_gray_red_coeff;
+   png_uint_16 rgb_to_gray_green_coeff;
+   /* The blue coefficient is calculated from the above */
+#endif
+
+   /* png_color_8 */
+#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_sBIT_SUPPORTED)
+   png_color_8 sig_bit;       /* significant bits in each available channel */
+#endif
+
+   /* png_byte */
+#if defined(PNG_READ_BACKGROUND_SUPPORTED) ||\
+   defined(PNG_READ_ALPHA_MODE_SUPPORTED)
+   png_byte background_gamma_type;
+#endif
+#ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED
+   png_byte rgb_to_gray_status;
+#endif
+
+   /* SHIFT - both READ_SHIFT and WRITE_SHIFT */
+#if defined(PNG_READ_SHIFT_SUPPORTED) || defined(PNG_WRITE_SHIFT_SUPPORTED)
+   png_color_8 shift;         /* shift for significant bit tranformation */
+#endif
+
+   /* FILLER SUPPORT (pixel expansion or read, contraction on write) */
+#if defined(PNG_READ_FILLER_SUPPORTED) || defined(PNG_WRITE_FILLER_SUPPORTED)
+   png_uint_16 filler;              /* filler bytes for pixel expansion */
+#endif
+
+   /* QUANTIZE (convert to color-mapped) */
+#ifdef PNG_READ_QUANTIZE_SUPPORTED
+   png_bytep palette_lookup;   /* lookup table for quantizing */
+   png_bytep quantize_index;   /* index translation for palette files */
+   png_bytep quantize_sort;    /* working sort array */
+   png_bytep index_to_palette; /* where the original index currently is in the
+                                * palette
+                                */
+   png_bytep palette_to_index; /* which original index points to this palette
+                                * color
+                                */
+#endif
+
+   /* MNG SUPPORT */
+#ifdef PNG_MNG_FEATURES_SUPPORTED
+   png_uint_32 mng_features_permitted;
+   png_byte filter_type;
+#endif
+
+   /* Options */
+#ifdef PNG_SET_OPTION_SUPPORTED
+   png_byte options;           /* On/off state (up to 4 options) */
+#endif
+
+   /* COMPRESSION AND DECOMPRESSION SUPPORT.
+    *
+    * zlib expects a 'zstream' as the fundamental control structure, it allows
+    * all the parameters to be passed as one pointer.
+    */
+   z_stream    zstream;       /* decompression structure */
 
 #ifdef PNG_READ_SUPPORTED
-/* New member added in libpng-1.2.30 */
-  png_bytep        read_buffer;      /* buffer for reading chunk data */
-  png_alloc_size_t read_buffer_size; /* current size of the buffer */
+   /* These, and IDAT_read_size below, control how much input and output (at
+    * most) is available to zlib.
+    */
+   png_uint_32      idat_size;        /* current IDAT size for read */
+   png_alloc_size_t read_buffer_size; /* current size of the buffer */
 #endif
+
+#ifdef PNG_WRITE_CUSTOMIZE_ZTXT_COMPRESSION_SUPPORTED
+   int zlib_text_level;       /* holds zlib compression level */
+   int zlib_text_method;      /* holds zlib compression method */
+   int zlib_text_window_bits; /* holds zlib compression window bits */
+   int zlib_text_mem_level;   /* holds zlib compression memory level */
+   int zlib_text_strategy;    /* holds zlib compression strategy */
+#endif
+
+#ifdef PNG_WRITE_SUPPORTED
+   int zlib_level;            /* holds zlib compression level */
+   int zlib_method;           /* holds zlib compression method */
+   int zlib_window_bits;      /* holds zlib compression window bits */
+   int zlib_mem_level;        /* holds zlib compression memory level */
+   int zlib_strategy;         /* holds zlib compression strategy */
+
+   int zlib_set_level;        /* Actual values set into the zstream on write */
+   int zlib_set_method;
+   int zlib_set_window_bits;
+   int zlib_set_mem_level;
+   int zlib_set_strategy;
+
+   png_compression_bufferp zbuffer_list; /* Created on demand during write */
+   uInt                    zbuffer_size; /* size of the actual zlib buffer */
+#endif
+
 #ifdef PNG_SEQUENTIAL_READ_SUPPORTED
-  uInt             IDAT_read_size;   /* limit on read buffer size for IDAT */
-#endif
-
-#ifdef PNG_IO_STATE_SUPPORTED
-/* New member added in libpng-1.4.0 */
-   png_uint_32 io_state;
-#endif
-
-/* New member added in libpng-1.5.6 */
-   png_bytep big_prev_row;
-
-/* New member added in libpng-1.5.7 */
-   void (*read_filter[PNG_FILTER_VALUE_LAST-1])(png_row_infop row_info,
-      png_bytep row, png_const_bytep prev_row);
-
-#ifdef PNG_READ_SUPPORTED
-#if defined(PNG_COLORSPACE_SUPPORTED) || defined(PNG_GAMMA_SUPPORTED)
-   png_colorspace   colorspace;
-#endif
+   uInt IDAT_read_size;       /* limit on read buffer size for IDAT */
 #endif
 };
 #endif /* PNGSTRUCT_H */

pngtest.c

@@ -2028,4 +2028,4 @@ main(void)
 #endif
 
 /* Generate a compiler error if there is an old png.h in the search path. */
-typedef png_libpng_version_1_6_18rc02 Your_png_h_is_not_version_1_6_18rc02;
+typedef png_libpng_version_1_7_0beta64 Your_png_h_is_not_version_1_7_0beta64;

pngtrans.c

@@ -1,7 +1,7 @@
 
 /* pngtrans.c - transforms the data in a row (used by both readers and writers)
  *
- * Last changed in libpng 1.6.18 [(PENDING RELEASE)]
+ * Last changed in libpng 1.6.17 [(PENDING RELEASE)]
  * Copyright (c) 1998-2015 Glenn Randers-Pehrson
  * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
  * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
@@ -12,6 +12,7 @@
  */
 
 #include "pngpriv.h"
+#define PNG_SRC_FILE PNG_SRC_FILE_pngtrans
 
 #if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)
 
@@ -138,7 +139,7 @@ png_set_filler(png_structrp png_ptr, png_uint_32 filler, int filler_loc)
           * NOTE: usr_channels is not used by the read code!  (This has led to
           * confusion in the past.)  The filler is only used in the read code.
           */
-         png_ptr->filler = (png_uint_16)filler;
+         png_ptr->filler = PNG_UINT_16(filler); /* Max bit depth is 16 */
 #     else
          png_app_error(png_ptr, "png_set_filler not supported on read");
          PNG_UNUSED(filler) /* not used in the write case */
@@ -258,90 +259,89 @@ png_set_invert_mono(png_structrp png_ptr)
 
 /* Invert monochrome grayscale data */
 void /* PRIVATE */
-png_do_invert(png_row_infop row_info, png_bytep row)
+png_do_invert(png_transform_controlp row_info, png_bytep row)
 {
    png_debug(1, "in png_do_invert");
 
+#  define png_ptr row_info->png_ptr
+
   /* This test removed from libpng version 1.0.13 and 1.2.0:
    *   if (row_info->bit_depth == 1 &&
    */
-   if (row_info->color_type == PNG_COLOR_TYPE_GRAY)
+   if (row_info->channels == 1)
    {
-      png_bytep rp = row;
-      png_size_t i;
-      png_size_t istop = row_info->rowbytes;
-
-      for (i = 0; i < istop; i++)
+      if (!(row_info->flags & PNG_INDEXED)) /* GRAY */
       {
-         *rp = (png_byte)(~(*rp));
-         rp++;
+         png_bytep rp = row + png_transform_rowbytes(row_info);
+
+         /* Don't care about the bit depth: */
+         while (rp > row)
+            *--rp ^= 0xff;
+
+         row_info->flags |= PNG_INVERTED;
       }
    }
 
-   else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA &&
-      row_info->bit_depth == 8)
+   else if (row_info->channels == 2) /* GRAY ALPHA */
    {
-      png_bytep rp = row;
-      png_size_t i;
-      png_size_t istop = row_info->rowbytes;
-
-      for (i = 0; i < istop; i += 2)
+      if (row_info->bit_depth == 8)
       {
-         *rp = (png_byte)(~(*rp));
-         rp += 2;
+         png_bytep rp;
+
+         row_info->flags |= PNG_INVERTED;
+         rp = row + png_transform_rowbytes(row_info);
+
+         /* Go backwards, so rp[-1] is alpha and rp[-2] is gray: */
+         while (rp >= row+2)
+            rp -= 2, *rp ^= 0xff;
       }
-   }
 
-#ifdef PNG_16BIT_SUPPORTED
-   else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA &&
-      row_info->bit_depth == 16)
-   {
-      png_bytep rp = row;
-      png_size_t i;
-      png_size_t istop = row_info->rowbytes;
-
-      for (i = 0; i < istop; i += 4)
+#  ifdef PNG_16BIT_SUPPORTED
+      else if (row_info->bit_depth == 16)
       {
-         *rp = (png_byte)(~(*rp));
-         *(rp + 1) = (png_byte)(~(*(rp + 1)));
-         rp += 4;
+         png_bytep rp;
+
+         row_info->flags |= PNG_INVERTED;
+         rp = row + png_transform_rowbytes(row_info);
+
+         /* The same, but now we have GGAA: */
+         while (rp >= row+4)
+            rp -= 3, *rp ^= 0xff, *--rp ^= 0xff;
       }
+#  endif
    }
-#endif
+#  undef png_ptr
 }
-#endif
+#endif /* READ_INVERT || WRITE_INVERT */
 
 #ifdef PNG_16BIT_SUPPORTED
 #if defined(PNG_READ_SWAP_SUPPORTED) || defined(PNG_WRITE_SWAP_SUPPORTED)
 /* Swaps byte order on 16 bit depth images */
 void /* PRIVATE */
-png_do_swap(png_row_infop row_info, png_bytep row)
+png_do_swap(png_transform_controlp row_info, png_bytep row)
 {
    png_debug(1, "in png_do_swap");
 
+#  define png_ptr row_info->png_ptr
+
    if (row_info->bit_depth == 16)
    {
-      png_bytep rp = row;
-      png_uint_32 i;
-      png_uint_32 istop= row_info->width * row_info->channels;
+      png_bytep rp;
 
-      for (i = 0; i < istop; i++, rp += 2)
+      row_info->flags |= PNG_BYTE_SWAPPED;
+      rp = row + png_transform_rowbytes(row_info);
+
+      while (rp >= row+2)
       {
-#ifdef PNG_BUILTIN_BSWAP16_SUPPORTED
-         /* Feature added to libpng-1.6.11 for testing purposes, not
-          * enabled by default.
-          */
-         *(png_uint_16*)rp = __builtin_bswap16(*(png_uint_16*)rp);
-#else
-         png_byte t = *rp;
-         *rp = *(rp + 1);
-         *(rp + 1) = t;
-#endif
+         png_byte save = *--rp;
+         *rp = rp[-1], --rp;
+         *rp = save;
       }
    }
+#  undef png_ptr
 }
-#endif
-#endif
+#endif /* READ_SWAP || WRITE_SWAP */
+#endif /* 16_BIT */
 
 #if defined(PNG_READ_PACKSWAP_SUPPORTED)||defined(PNG_WRITE_PACKSWAP_SUPPORTED)
 static PNG_CONST png_byte onebppswaptable[256] = {
@@ -451,16 +451,16 @@ static PNG_CONST png_byte fourbppswaptable[256] = {
 
 /* Swaps pixel packing order within bytes */
 void /* PRIVATE */
-png_do_packswap(png_row_infop row_info, png_bytep row)
+png_do_packswap(png_transform_controlp row_info, png_bytep row)
 {
    png_debug(1, "in png_do_packswap");
 
+#  define png_ptr row_info->png_ptr
+
    if (row_info->bit_depth < 8)
    {
-      png_bytep rp;
-      png_const_bytep end, table;
-
-      end = row + row_info->rowbytes;
+      png_bytep ep;
+      png_const_bytep table;
 
       if (row_info->bit_depth == 1)
          table = onebppswaptable;
@@ -474,11 +474,15 @@ png_do_packswap(png_row_infop row_info, png_bytep row)
       else
          return;
 
-      for (rp = row; rp < end; rp++)
-         *rp = table[*rp];
+      row_info->flags |= PNG_PIXEL_SWAPPED;
+      ep = row + png_transform_rowbytes(row_info);
+
+      while (row < ep)
+         *row = table[*row], ++row;
    }
+#  undef png_ptr
 }
-#endif /* PACKSWAP || WRITE_PACKSWAP */
+#endif /* READ_PACKSWAP || WRITE_PACKSWAP */
 
 #if defined(PNG_WRITE_FILLER_SUPPORTED) || \
     defined(PNG_READ_STRIP_ALPHA_SUPPORTED)
@@ -491,11 +495,14 @@ png_do_packswap(png_row_infop row_info, png_bytep row)
  * end (not in the middle) of each pixel.
  */
 void /* PRIVATE */
-png_do_strip_channel(png_row_infop row_info, png_bytep row, int at_start)
+png_do_strip_channel(png_transform_controlp row_info, png_bytep row,
+   int at_start)
 {
-   png_bytep sp = row; /* source pointer */
-   png_bytep dp = row; /* destination pointer */
-   png_bytep ep = row + row_info->rowbytes; /* One beyond end of row */
+   png_const_bytep sp = row; /* source pointer */
+   png_bytep       dp = row; /* destination pointer */
+   png_const_bytep ep = row + png_transform_rowbytes(row_info); /* beyond end */
+
+#  define png_ptr row_info->png_ptr
 
    /* At the start sp will point to the first byte to copy and dp to where
     * it is copied to.  ep always points just beyond the end of the row, so
@@ -518,8 +525,6 @@ png_do_strip_channel(png_row_infop row_info, png_bytep row, int at_start)
          /* For a 1 pixel wide image there is nothing to do */
          while (sp < ep)
             *dp++ = *sp, sp += 2;
-
-         row_info->pixel_depth = 8;
       }
 
       else if (row_info->bit_depth == 16)
@@ -531,18 +536,13 @@ png_do_strip_channel(png_row_infop row_info, png_bytep row, int at_start)
 
          while (sp < ep)
             *dp++ = *sp++, *dp++ = *sp, sp += 3;
-
-         row_info->pixel_depth = 16;
       }
 
       else
          return; /* bad bit depth */
 
       row_info->channels = 1;
-
-      /* Finally fix the color type if it records an alpha channel */
-      if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
-         row_info->color_type = PNG_COLOR_TYPE_GRAY;
+      debug(dp == row + png_transform_rowbytes(row_info));
    }
 
    /* RGBA, RGBX, XRGB cases */
@@ -558,8 +558,6 @@ png_do_strip_channel(png_row_infop row_info, png_bytep row, int at_start)
          /* Note that the loop adds 3 to dp and 4 to sp each time. */
          while (sp < ep)
             *dp++ = *sp++, *dp++ = *sp++, *dp++ = *sp, sp += 2;
-
-         row_info->pixel_depth = 24;
       }
 
       else if (row_info->bit_depth == 16)
@@ -576,104 +574,80 @@ png_do_strip_channel(png_row_infop row_info, png_bytep row, int at_start)
             *dp++ = *sp++, *dp++ = *sp++;
             *dp++ = *sp++, *dp++ = *sp, sp += 3;
          }
-
-         row_info->pixel_depth = 48;
       }
 
       else
          return; /* bad bit depth */
 
       row_info->channels = 3;
-
-      /* Finally fix the color type if it records an alpha channel */
-      if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
-         row_info->color_type = PNG_COLOR_TYPE_RGB;
+      debug(dp == row + png_transform_rowbytes(row_info));
    }
 
    else
       return; /* The filler channel has gone already */
-
-   /* Fix the rowbytes value. */
-   row_info->rowbytes = dp-row;
+#  undef png_ptr
 }
-#endif
+#endif /* WRITE_FILLER || READ_STRIP_ALPHA */
 
 #if defined(PNG_READ_BGR_SUPPORTED) || defined(PNG_WRITE_BGR_SUPPORTED)
 /* Swaps red and blue bytes within a pixel */
 void /* PRIVATE */
-png_do_bgr(png_row_infop row_info, png_bytep row)
+png_do_bgr(png_transform_controlp row_info, png_bytep row)
 {
+   unsigned int channels;
+
    png_debug(1, "in png_do_bgr");
 
-   if ((row_info->color_type & PNG_COLOR_MASK_COLOR) != 0)
+#  define png_ptr row_info->png_ptr
+
+   channels = row_info->channels;
+
+   if (channels == 3 || channels == 4)
    {
-      png_uint_32 row_width = row_info->width;
+      png_const_bytep ep = row + png_transform_rowbytes(row_info);
+
       if (row_info->bit_depth == 8)
       {
-         if (row_info->color_type == PNG_COLOR_TYPE_RGB)
-         {
-            png_bytep rp;
-            png_uint_32 i;
+         ep -= channels; /* Last pixel */
+         row_info->flags ^= PNG_RGB_SWAPPED;
 
-            for (i = 0, rp = row; i < row_width; i++, rp += 3)
-            {
-               png_byte save = *rp;
-               *rp = *(rp + 2);
-               *(rp + 2) = save;
-            }
+         while (row <= ep)
+         {
+            png_byte save = row[0];
+            row[0] = row[2];
+            row[2] = save;
+            row += channels;
          }
 
-         else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
-         {
-            png_bytep rp;
-            png_uint_32 i;
-
-            for (i = 0, rp = row; i < row_width; i++, rp += 4)
-            {
-               png_byte save = *rp;
-               *rp = *(rp + 2);
-               *(rp + 2) = save;
-            }
-         }
+         debug(row == ep+channels);
       }
 
-#ifdef PNG_16BIT_SUPPORTED
-      else if (row_info->bit_depth == 16)
-      {
-         if (row_info->color_type == PNG_COLOR_TYPE_RGB)
+#     ifdef PNG_16BIT_SUPPORTED
+         else if (row_info->bit_depth == 16)
          {
-            png_bytep rp;
-            png_uint_32 i;
+            channels *= 2; /* now in bytes */
 
-            for (i = 0, rp = row; i < row_width; i++, rp += 6)
+            ep -= channels; /* Last pixel */
+            row_info->flags |= PNG_RGB_SWAPPED;
+
+            while (row <= ep)
             {
-               png_byte save = *rp;
-               *rp = *(rp + 4);
-               *(rp + 4) = save;
-               save = *(rp + 1);
-               *(rp + 1) = *(rp + 5);
-               *(rp + 5) = save;
-            }
-         }
+               png_byte save = row[0];
+               row[0] = row[4];
+               row[4] = save;
 
-         else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
-         {
-            png_bytep rp;
-            png_uint_32 i;
+               save = row[1];
+               row[1] = row[5];
+               row[5] = save;
 
-            for (i = 0, rp = row; i < row_width; i++, rp += 8)
-            {
-               png_byte save = *rp;
-               *rp = *(rp + 4);
-               *(rp + 4) = save;
-               save = *(rp + 1);
-               *(rp + 1) = *(rp + 5);
-               *(rp + 5) = save;
+               row += channels;
             }
+
+            debug(row == ep+channels);
          }
-      }
-#endif
+#     endif
    }
+#  undef png_ptr
 }
 #endif /* READ_BGR || WRITE_BGR */
 
@@ -681,19 +655,24 @@ png_do_bgr(png_row_infop row_info, png_bytep row)
     defined(PNG_WRITE_CHECK_FOR_INVALID_INDEX_SUPPORTED)
 /* Added at libpng-1.5.10 */
 void /* PRIVATE */
-png_do_check_palette_indexes(png_structrp png_ptr, png_row_infop row_info)
+png_do_check_palette_indexes(png_structrp png_ptr,
+   png_transform_controlp row_info)
 {
    if (png_ptr->num_palette < (1 << row_info->bit_depth) &&
       png_ptr->num_palette > 0) /* num_palette can be 0 in MNG files */
    {
-      /* Calculations moved outside switch in an attempt to stop different
-       * compiler warnings.  'padding' is in *bits* within the last byte, it is
-       * an 'int' because pixel_depth becomes an 'int' in the expression below,
-       * and this calculation is used because it avoids warnings that other
-       * forms produced on either GCC or MSVC.
+      /* Padding is the unused bits in the last byte: 8 - bits-in-last-byte,
+       * which reduces to 7 & (-total_bits), so we don't care about overflow
+       * in the unsigned calculation here:
+       */
+      unsigned int padding =
+         7 & -(row_info->bit_depth * row_info->channels * row_info->width);
+      png_bytep rp = png_ptr->row_buf + png_transform_rowbytes(row_info);
+
+      /* Note that png_ptr->row_buf starts with a filter byte, so rp is
+       * currently pointing to the last byte in the row, not just after
+       * it.
        */
-      int padding = (-row_info->pixel_depth * row_info->width) & 7;
-      png_bytep rp = png_ptr->row_buf + row_info->rowbytes;
 
       switch (row_info->bit_depth)
       {
@@ -780,6 +759,136 @@ png_do_check_palette_indexes(png_structrp png_ptr, png_row_infop row_info)
 }
 #endif /* CHECK_FOR_INVALID_INDEX */
 
+#if defined(PNG_READ_TRANSFORMS_SUPPORTED) ||\
+    defined(PNG_WRITE_TRANSFORMS_SUPPORTED)
+/* Utility functions: */
+void
+png_init_transform_control(png_const_structrp png_ptr,
+   png_transform_controlp out, png_const_row_infop row_info)
+{
+   out->png_ptr = png_ptr;
+
+   /* At the start expect row_info to be consistent with png_ptr: */
+   if (png_ptr->mode & PNG_IS_READ_STRUCT)
+   {
+      debug(png_ptr->iwidth == row_info->width);
+      debug(png_ptr->color_type == row_info->color_type);
+      debug(png_ptr->bit_depth == row_info->bit_depth);
+   }
+
+   out->width = row_info->width;
+   out->flags = 0;
+   out->bit_depth = row_info->bit_depth;
+
+   switch (row_info->color_type)
+   {
+      case PNG_COLOR_TYPE_GRAY:
+         out->channels = 1;
+         break;
+
+      case PNG_COLOR_TYPE_GRAY_ALPHA:
+         out->channels = 2;
+         break;
+
+      case PNG_COLOR_TYPE_PALETTE:
+         affirm(!(png_ptr->mode & PNG_IS_READ_STRUCT) ||
+            png_ptr->palette != NULL);
+         out->flags |= PNG_INDEXED;
+         out->channels = 1;
+         break;
+
+      case PNG_COLOR_TYPE_RGB:
+         out->channels = 3;
+         break;
+
+      case PNG_COLOR_TYPE_RGB_ALPHA:
+         out->channels = 4;
+         break;
+
+      default:
+         impossible("invalid PNG color type");
+   } 
+}
+
+size_t
+png_transform_rowbytes(png_const_transform_controlp row_info)
+{
+#  define png_ptr row_info->png_ptr
+   /* For this not to overflow the pixel depth calculation must not overflow
+    * and the pixel depth must be less than maximum_pixel_depth.
+    */
+   /* The release code uses PNG_ROWBYTES, so make sure that it will not
+    * overflow.  To test this it is necessary to generate some very wide
+    * images and ensure that the code errors out before getting here.
+    */
+   unsigned int channels = row_info->channels;
+   unsigned int bit_depth = row_info->bit_depth;
+   unsigned int pixel_bits = channels * bit_depth;
+   size_t width = row_info->width;
+
+   affirm(bit_depth < 256 && channels < 256 &&
+      pixel_bits <= png_ptr->maximum_pixel_depth);
+
+   return PNG_ROWBYTES(pixel_bits, width);
+#  undef png_ptr
+}
+
+static unsigned int
+transform_color_type(png_const_transform_controlp row_info)
+{
+   const unsigned int ch = row_info->channels - 1;
+   const unsigned int indexed = row_info->flags & PNG_INDEXED;
+
+   /* That is 0, 1, 2, 3 for G/PALETTE, GA, RGB, RGBA.  Check the
+    * numbers:
+    */
+#  if PNG_INDEXED != PNG_COLOR_MASK_PALETTE ||\
+      PNG_FILLER_IN_ALPHA != PNG_COLOR_MASK_ALPHA ||\
+      PNG_COLOR_MASK_PALETTE != 1 ||\
+      PNG_COLOR_MASK_COLOR != 2 ||\
+      PNG_COLOR_MASK_ALPHA != 4
+#     error Unexpected PNG color type defines
+#  endif
+
+   /* The following preserves all the bits in row_info->channels except the
+    * top bit and generates a correct PNG color type for the defined values
+    * and an incorrect one for all undefined cases.
+    *
+    * Note that when PNG_FILLER_IN_ALPHA is set in the flags
+    */
+   return indexed /*PALETTE*/ |
+          ((ch & 2) ^ (indexed << 1) /*COLOR*/) |
+          (((ch & 1) << 2/*ALPHA*/) & ~row_info->flags) |
+          ((ch & ~3) << 1 /*INVALID*/);
+}
+
+void
+png_end_transform_control(png_row_infop out, png_const_transform_controlp in)
+{
+#  define png_ptr in->png_ptr /* for affirm/impossible */
+   out->width = in->width;
+   out->rowbytes = png_transform_rowbytes(in);
+
+   out->color_type = png_check_byte(png_ptr, transform_color_type(in));
+   out->bit_depth = png_check_byte(png_ptr, in->bit_depth);
+   out->channels = png_check_byte(png_ptr, in->channels);
+   out->pixel_depth = png_check_byte(png_ptr, in->channels * in->bit_depth);
+
+#  ifdef PNG_WARNINGS_SUPPORTED
+      if ((in->flags & PNG_BAD_INDEX) != 0)
+         png_warning(png_ptr, "palette image had bad index");
+#  endif
+
+   /* At the end expect row_info to be consistent with png_ptr: */
+   if (!(png_ptr->mode & PNG_IS_READ_STRUCT))
+   {
+      debug(png_ptr->color_type == out->color_type);
+      debug(png_ptr->bit_depth == out->bit_depth);
+   }
+#  undef png_ptr
+}
+#endif /* READ_TRANSFORMS | WRITE_TRANSFORMS */
+
 #if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \
     defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED)
 #ifdef PNG_USER_TRANSFORM_PTR_SUPPORTED
@@ -803,8 +912,10 @@ png_set_user_transform_info(png_structrp png_ptr, png_voidp
 #endif
 
    png_ptr->user_transform_ptr = user_transform_ptr;
-   png_ptr->user_transform_depth = (png_byte)user_transform_depth;
-   png_ptr->user_transform_channels = (png_byte)user_transform_channels;
+   png_ptr->user_transform_depth = png_check_byte(png_ptr,
+      user_transform_depth);
+   png_ptr->user_transform_channels = png_check_byte(png_ptr,
+      user_transform_channels);
 }
 #endif
 

pngusr.dfa

@@ -4,9 +4,10 @@
 #
 # Enter build configuration options in this file
 #
-# Security settings: by default these limits are unset, you can change them
-# here by entering the appropriate values as #defines preceded by '@' (to cause,
-# them to be passed through to the build of pnglibconf.h), for example:
+# Security settings: these limits have default values that are set in
+# scripts/pnglibconf.dfa; you can change them here by entering the
+# appropriate values as #defines preceded by '@' (to cause them
+# to be passed through to the build of pnglibconf.h), for example:
 #
 # @# define PNG_USER_WIDTH_MAX 65535
 # @# define PNG_USER_HEIGHT_MAX 65535

pngwio.c

@@ -1,8 +1,8 @@
 
 /* pngwio.c - functions for data output
  *
- * Last changed in libpng 1.6.15 [November 20, 2014]
- * Copyright (c) 1998-2014 Glenn Randers-Pehrson
+ * Last changed in libpng 1.7.0 [(PENDING RELEASE)]
+ * Copyright (c) 1998-2015 Glenn Randers-Pehrson
  * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
  * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
  *
@@ -19,6 +19,7 @@
  */
 
 #include "pngpriv.h"
+#define PNG_SRC_FILE PNG_SRC_FILE_pngwio
 
 #ifdef PNG_WRITE_SUPPORTED
 

pngwrite.c

@@ -1,7 +1,7 @@
 
 /* pngwrite.c - general routines to write a PNG file
  *
- * Last changed in libpng 1.6.18 [(PENDING RELEASE)]
+ * Last changed in libpng 1.7.0 [(PENDING RELEASE)]
  * Copyright (c) 1998-2015 Glenn Randers-Pehrson
  * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
  * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
@@ -15,6 +15,7 @@
 #if defined(PNG_SIMPLIFIED_WRITE_SUPPORTED) && defined(PNG_STDIO_SUPPORTED)
 #  include <errno.h>
 #endif
+#define PNG_SRC_FILE PNG_SRC_FILE_pngwrite
 
 #ifdef PNG_WRITE_SUPPORTED
 
@@ -90,44 +91,43 @@ png_write_info_before_PLTE(png_structrp png_ptr, png_const_inforp info_ptr)
 
    if ((png_ptr->mode & PNG_WROTE_INFO_BEFORE_PLTE) == 0)
    {
-      /* Write PNG signature */
-      png_write_sig(png_ptr);
+   /* Write PNG signature */
+   png_write_sig(png_ptr);
 
 #ifdef PNG_MNG_FEATURES_SUPPORTED
-      if ((png_ptr->mode & PNG_HAVE_PNG_SIGNATURE) != 0 && \
-          png_ptr->mng_features_permitted != 0)
-      {
-         png_warning(png_ptr,
-             "MNG features are not allowed in a PNG datastream");
-         png_ptr->mng_features_permitted = 0;
-      }
+   if ((png_ptr->mode & PNG_HAVE_PNG_SIGNATURE) != 0 && \
+       png_ptr->mng_features_permitted != 0)
+   {
+      png_warning(png_ptr, "MNG features are not allowed in a PNG datastream");
+      png_ptr->mng_features_permitted = 0;
+   }
 #endif
 
-      /* Write IHDR information. */
-      png_write_IHDR(png_ptr, info_ptr->width, info_ptr->height,
-          info_ptr->bit_depth, info_ptr->color_type, info_ptr->compression_type,
-          info_ptr->filter_type,
+   /* Write IHDR information. */
+   png_write_IHDR(png_ptr, info_ptr->width, info_ptr->height,
+       info_ptr->bit_depth, info_ptr->color_type, info_ptr->compression_type,
+       info_ptr->filter_type,
 #ifdef PNG_WRITE_INTERLACING_SUPPORTED
-          info_ptr->interlace_type
+       info_ptr->interlace_type
 #else
-          0
+       0
 #endif
-         );
+      );
 
-      /* The rest of these check to see if the valid field has the appropriate
-       * flag set, and if it does, writes the chunk.
-       *
-       * 1.6.0: COLORSPACE support controls the writing of these chunks too, and
-       * the chunks will be written if the WRITE routine is there and
-       * information * is available in the COLORSPACE. (See
-       * png_colorspace_sync_info in png.c for where the valid flags get set.)
-       *
-       * Under certain circumstances the colorspace can be invalidated without
-       * syncing the info_struct 'valid' flags; this happens if libpng detects
-       * an error and calls png_error while the color space is being set, yet
-       * the * application continues writing the PNG.  So check the 'invalid'
-       * flag here too.
-       */
+   /* The rest of these check to see if the valid field has the appropriate
+    * flag set, and if it does, writes the chunk.
+    *
+    * 1.6.0: COLORSPACE support controls the writing of these chunks too, and
+    * the chunks will be written if the WRITE routine is there and information
+    * is available in the COLORSPACE.  (See png_colorspace_sync_info in png.c
+    * for where the valid flags get set.)
+    *
+    * Under certain circumstances the colorspace can be invalidated without
+    * syncing the info_struct 'valid' flags; this happens if libpng detects and
+    * error and calls png_error while the color space is being set, yet the
+    * application continues writing the PNG.  So check the 'invalid' flag here
+    * too.
+    */
 #ifdef PNG_GAMMA_SUPPORTED
 #  ifdef PNG_WRITE_gAMA_SUPPORTED
       if ((info_ptr->colorspace.flags & PNG_COLORSPACE_INVALID) == 0 &&
@@ -138,50 +138,50 @@ png_write_info_before_PLTE(png_structrp png_ptr, png_const_inforp info_ptr)
 #endif
 
 #ifdef PNG_COLORSPACE_SUPPORTED
-      /* Write only one of sRGB or an ICC profile.  If a profile was supplied
-       * and it matches one of the known sRGB ones issue a warning.
-       */
+   /* Write only one of sRGB or an ICC profile.  If a profile was supplied
+    * and it matches one of the known sRGB ones issue a warning.
+    */
 #  ifdef PNG_WRITE_iCCP_SUPPORTED
-         if ((info_ptr->colorspace.flags & PNG_COLORSPACE_INVALID) == 0 &&
-             (info_ptr->valid & PNG_INFO_iCCP) != 0)
-         {
-#    ifdef PNG_WRITE_sRGB_SUPPORTED
-               if ((info_ptr->valid & PNG_INFO_sRGB) != 0)
-                  png_app_warning(png_ptr,
-                     "profile matches sRGB but writing iCCP instead");
-#     endif
+      if ((info_ptr->colorspace.flags & PNG_COLORSPACE_INVALID) == 0 &&
+          (info_ptr->valid & PNG_INFO_iCCP) != 0)
+      {
+#        ifdef PNG_WRITE_sRGB_SUPPORTED
+            if ((info_ptr->valid & PNG_INFO_sRGB) != 0)
+               png_app_warning(png_ptr,
+                  "profile matches sRGB but writing iCCP instead");
+#        endif
 
-            png_write_iCCP(png_ptr, info_ptr->iccp_name,
-               info_ptr->iccp_profile);
-         }
+         png_write_iCCP(png_ptr, info_ptr->iccp_name,
+            info_ptr->iccp_profile);
+      }
 #     ifdef PNG_WRITE_sRGB_SUPPORTED
          else
 #     endif
 #  endif
 
 #  ifdef PNG_WRITE_sRGB_SUPPORTED
-         if ((info_ptr->colorspace.flags & PNG_COLORSPACE_INVALID) == 0 &&
-             (info_ptr->valid & PNG_INFO_sRGB) != 0)
-            png_write_sRGB(png_ptr, info_ptr->colorspace.rendering_intent);
+      if ((info_ptr->colorspace.flags & PNG_COLORSPACE_INVALID) == 0 &&
+          (info_ptr->valid & PNG_INFO_sRGB) != 0)
+         png_write_sRGB(png_ptr, info_ptr->colorspace.rendering_intent);
 #  endif /* WRITE_sRGB */
 #endif /* COLORSPACE */
 
 #ifdef PNG_WRITE_sBIT_SUPPORTED
-         if ((info_ptr->valid & PNG_INFO_sBIT) != 0)
-            png_write_sBIT(png_ptr, &(info_ptr->sig_bit), info_ptr->color_type);
+   if ((info_ptr->valid & PNG_INFO_sBIT) != 0)
+      png_write_sBIT(png_ptr, &(info_ptr->sig_bit), info_ptr->color_type);
 #endif
 
 #ifdef PNG_COLORSPACE_SUPPORTED
 #  ifdef PNG_WRITE_cHRM_SUPPORTED
-         if ((info_ptr->colorspace.flags & PNG_COLORSPACE_INVALID) == 0 &&
-             (info_ptr->colorspace.flags & PNG_COLORSPACE_FROM_cHRM) != 0 &&
-             (info_ptr->valid & PNG_INFO_cHRM) != 0)
-            png_write_cHRM_fixed(png_ptr, &info_ptr->colorspace.end_points_xy);
+      if ((info_ptr->colorspace.flags & PNG_COLORSPACE_INVALID) == 0 &&
+         (info_ptr->colorspace.flags & PNG_COLORSPACE_FROM_cHRM) != 0 &&
+         (info_ptr->valid & PNG_INFO_cHRM) != 0)
+         png_write_cHRM_fixed(png_ptr, &info_ptr->colorspace.end_points_xy);
 #  endif
 #endif
 
 #ifdef PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED
-         write_unknown_chunks(png_ptr, info_ptr, PNG_HAVE_IHDR);
+      write_unknown_chunks(png_ptr, info_ptr, PNG_HAVE_IHDR);
 #endif
 
       png_ptr->mode |= PNG_WROTE_INFO_BEFORE_PLTE;
@@ -225,7 +225,7 @@ png_write_info(png_structrp png_ptr, png_const_inforp info_ptr)
 
          for (j = 0; j<jend; ++j)
             info_ptr->trans_alpha[j] =
-               (png_byte)(255 - info_ptr->trans_alpha[j]);
+               png_check_byte(png_ptr, 255 - info_ptr->trans_alpha[j]);
       }
 #endif
       png_write_tRNS(png_ptr, info_ptr->trans_alpha, &(info_ptr->trans_color),
@@ -441,7 +441,6 @@ png_write_end(png_structrp png_ptr, png_inforp info_ptr)
 
    /* Write end of PNG file */
    png_write_IEND(png_ptr);
-
    /* This flush, added in libpng-1.0.8, removed from libpng-1.0.9beta03,
     * and restored again in libpng-1.2.30, may cause some applications that
     * do not set png_ptr->output_flush_fn to crash.  If your application
@@ -462,12 +461,12 @@ png_convert_from_struct_tm(png_timep ptime, PNG_CONST struct tm * ttime)
 {
    png_debug(1, "in png_convert_from_struct_tm");
 
-   ptime->year = (png_uint_16)(1900 + ttime->tm_year);
-   ptime->month = (png_byte)(ttime->tm_mon + 1);
-   ptime->day = (png_byte)ttime->tm_mday;
-   ptime->hour = (png_byte)ttime->tm_hour;
-   ptime->minute = (png_byte)ttime->tm_min;
-   ptime->second = (png_byte)ttime->tm_sec;
+   ptime->year = png_check_u16(0/*TODO: fixme*/, 1900 + ttime->tm_year);
+   ptime->month = png_check_byte(0/*TODO: fixme*/, ttime->tm_mon + 1);
+   ptime->day = png_check_byte(0/*TODO: fixme*/, ttime->tm_mday);
+   ptime->hour = png_check_byte(0/*TODO: fixme*/, ttime->tm_hour);
+   ptime->minute = png_check_byte(0/*TODO: fixme*/, ttime->tm_min);
+   ptime->second = png_check_byte(0/*TODO: fixme*/, ttime->tm_sec);
 }
 
 void PNGAPI
@@ -504,6 +503,7 @@ png_create_write_struct_2,(png_const_charp user_png_ver, png_voidp error_ptr,
    png_structrp png_ptr = png_create_png_struct(user_png_ver, error_ptr,
        error_fn, warn_fn, mem_ptr, malloc_fn, free_fn);
 #endif /* USER_MEM */
+
    if (png_ptr != NULL)
    {
       /* Set the zlib control values to defaults; they can be overridden by the
@@ -644,8 +644,8 @@ png_do_write_intrapixel(png_row_infop row_info, png_bytep row)
 
          for (i = 0, rp = row; i < row_width; i++, rp += bytes_per_pixel)
          {
-            *(rp)     = (png_byte)(*rp       - *(rp + 1));
-            *(rp + 2) = (png_byte)(*(rp + 2) - *(rp + 1));
+            *(rp)     = (png_byte)((*rp       - *(rp + 1)) & 0xff);
+            *(rp + 2) = (png_byte)((*(rp + 2) - *(rp + 1)) & 0xff);
          }
       }
 
@@ -669,12 +669,12 @@ png_do_write_intrapixel(png_row_infop row_info, png_bytep row)
             png_uint_32 s0   = (*(rp    ) << 8) | *(rp + 1);
             png_uint_32 s1   = (*(rp + 2) << 8) | *(rp + 3);
             png_uint_32 s2   = (*(rp + 4) << 8) | *(rp + 5);
-            png_uint_32 red  = (png_uint_32)((s0 - s1) & 0xffffL);
-            png_uint_32 blue = (png_uint_32)((s2 - s1) & 0xffffL);
-            *(rp    ) = (png_byte)(red >> 8);
-            *(rp + 1) = (png_byte)red;
-            *(rp + 4) = (png_byte)(blue >> 8);
-            *(rp + 5) = (png_byte)blue;
+            png_uint_32 red  = (s0 - s1) & 0xffff;
+            png_uint_32 blue = (s2 - s1) & 0xffff;
+            *(rp    ) = png_check_byte(0/*TODO: fixme*/, red >> 8);
+            *(rp + 1) = PNG_BYTE(red);
+            *(rp + 4) = png_check_byte(0/*TODO: fixme*/, blue >> 8);
+            *(rp + 5) = PNG_BYTE(blue);
          }
       }
 #endif /* WRITE_16BIT */
@@ -817,7 +817,8 @@ png_write_row(png_structrp png_ptr, png_const_bytep row)
    row_info.width = png_ptr->usr_width;
    row_info.channels = png_ptr->usr_channels;
    row_info.bit_depth = png_ptr->usr_bit_depth;
-   row_info.pixel_depth = (png_byte)(row_info.bit_depth * row_info.channels);
+   row_info.pixel_depth =
+       png_check_byte(png_ptr, row_info.bit_depth * row_info.channels);
    row_info.rowbytes = PNG_ROWBYTES(row_info.pixel_depth, row_info.width);
 
    png_debug1(3, "row_info->color_type = %d", row_info.color_type);
@@ -855,7 +856,7 @@ png_write_row(png_structrp png_ptr, png_const_bytep row)
     * which is also the output depth.
     */
    if (row_info.pixel_depth != png_ptr->pixel_depth ||
-       row_info.pixel_depth != png_ptr->transformed_pixel_depth)
+      row_info.pixel_depth != png_ptr->transformed_pixel_depth)
       png_error(png_ptr, "internal write transform logic error");
 
 #ifdef PNG_MNG_FEATURES_SUPPORTED
@@ -881,7 +882,12 @@ png_write_row(png_structrp png_ptr, png_const_bytep row)
    /* Check for out-of-range palette index */
    if (row_info.color_type == PNG_COLOR_TYPE_PALETTE &&
        png_ptr->num_palette_max >= 0)
-      png_do_check_palette_indexes(png_ptr, &row_info);
+   {
+      png_transform_control display;
+
+      png_init_transform_control(png_ptr, &display, &row_info);
+      png_do_check_palette_indexes(png_ptr, &display);
+   }
 #endif
 
    /* Find a filter if necessary, filter the row and write it out. */
@@ -997,43 +1003,52 @@ png_set_filter(png_structrp png_ptr, int method, int filters)
    if ((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) != 0 &&
        (method == PNG_INTRAPIXEL_DIFFERENCING))
       method = PNG_FILTER_TYPE_BASE;
-
 #endif
-   if (method == PNG_FILTER_TYPE_BASE)
-   {
-      switch (filters & (PNG_ALL_FILTERS | 0x07))
+
+   /* The only supported method, except for the check above, is
+    * PNG_FILTER_TYPE_BASE.  The code below does not use 'method' other than
+    * for the check, so just keep going if png_app_error returns.
+    */
+   if (method != PNG_FILTER_TYPE_BASE)
+      png_app_error(png_ptr, "Unknown custom filter method");
+
+   /* If filter writing is not supported the 'filters' value must be zero,
+    * otherwise the value must be a single, valid, filter value or a set of the
+    * mask values.  The defines in png.h are such that the filter masks used in
+    * this API and internally are 1<<(3+value), value is in the range 0..4, so
+    * this fits in a byte.
+    */
+#  ifdef PNG_WRITE_FILTER_SUPPORTED
+      /* Notice that PNG_NO_FILTERS is 0 and passes this test; this is OK
+       * because filters then gets set to PNG_FILTER_NONE, as is required.
+       */
+      if (filters < PNG_FILTER_VALUE_LAST)
+         filters = 0x08 << filters;
+
+      else if ((filters & ~PNG_ALL_FILTERS) != 0)
       {
-#ifdef PNG_WRITE_FILTER_SUPPORTED
-         case 5:
-         case 6:
-         case 7: png_app_error(png_ptr, "Unknown row filter for method 0");
-            /* FALL THROUGH */
-#endif /* WRITE_FILTER */
-         case PNG_FILTER_VALUE_NONE:
-            png_ptr->do_filter = PNG_FILTER_NONE; break;
+         png_app_error(png_ptr, "png_set_filter: invalid filters mask/value");
 
-#ifdef PNG_WRITE_FILTER_SUPPORTED
-         case PNG_FILTER_VALUE_SUB:
-            png_ptr->do_filter = PNG_FILTER_SUB; break;
+         /* For compatibility with the previous behavior assume a mask value was
+          * passed and ignore the non-mask bits.
+          */
+         filters &= PNG_ALL_FILTERS;
 
-         case PNG_FILTER_VALUE_UP:
-            png_ptr->do_filter = PNG_FILTER_UP; break;
-
-         case PNG_FILTER_VALUE_AVG:
-            png_ptr->do_filter = PNG_FILTER_AVG; break;
-
-         case PNG_FILTER_VALUE_PAETH:
-            png_ptr->do_filter = PNG_FILTER_PAETH; break;
-
-         default:
-            png_ptr->do_filter = (png_byte)filters; break;
-#else
-         default:
-            png_app_error(png_ptr, "Unknown row filter for method 0");
-#endif /* WRITE_FILTER */
+         /* For a possibly foolish consistency (it shouldn't matter) set
+          * PNG_FILTER_NONE rather than 0.
+          */
+         if (filters == 0)
+            filters = PNG_FILTER_NONE;
       }
+#  else
+      /* PNG_FILTER_VALUE_NONE and PNG_NO_FILTERS are both 0. */
+      if (filters != 0 && filters != PNG_FILTER_NONE)
+         png_app_error(png_ptr, "png_set_filter: no filters supported");
 
-#ifdef PNG_WRITE_FILTER_SUPPORTED
+      filters = PNG_FILTER_NONE;
+#  endif
+
+#  ifdef PNG_WRITE_FILTER_SUPPORTED
       /* If we have allocated the row_buf, this means we have already started
        * with the image and we should have allocated all of the filter buffers
        * that have been selected.  If prev_row isn't already allocated, then
@@ -1049,9 +1064,6 @@ png_set_filter(png_structrp png_ptr, int method, int filters)
        */
       if (png_ptr->row_buf != NULL)
       {
-         int num_filters;
-         png_alloc_size_t buf_size;
-
          /* Repeat the checks in png_write_start_row; 1 pixel high or wide
           * images cannot benefit from certain filters.  If this isn't done here
           * the check below will fire on 1 pixel high images.
@@ -1073,51 +1085,32 @@ png_set_filter(png_structrp png_ptr, int method, int filters)
             filters &= ~(PNG_FILTER_UP|PNG_FILTER_AVG|PNG_FILTER_PAETH);
          }
 
-         num_filters = 0;
-
-         if (filters & PNG_FILTER_SUB)
-            num_filters++;
-
-         if (filters & PNG_FILTER_UP)
-            num_filters++;
-
-         if (filters & PNG_FILTER_AVG)
-            num_filters++;
-
-         if (filters & PNG_FILTER_PAETH)
-            num_filters++;
-
-         /* Allocate needed row buffers if they have not already been
-          * allocated.
+         /* Allocate any required buffers that have not already been allocated.
           */
-         buf_size = PNG_ROWBYTES(png_ptr->usr_channels * png_ptr->usr_bit_depth,
-             png_ptr->width) + 1;
-
-         if (png_ptr->try_row == NULL)
-            png_ptr->try_row = png_voidcast(png_bytep,
-               png_malloc(png_ptr, buf_size));
-
-         if (num_filters > 1)
-         {
-            if (png_ptr->tst_row == NULL)
-               png_ptr->tst_row = png_voidcast(png_bytep,
-                  png_malloc(png_ptr, buf_size));
-         }
+         png_write_alloc_filter_row_buffers(png_ptr, filters);
       }
-      png_ptr->do_filter = (png_byte)filters;
-#endif
-   }
-   else
-      png_error(png_ptr, "Unknown custom filter method");
+#  endif /* WRITE_FILTER */
+
+   /* Finally store the value.
+    * TODO: this field could probably be removed if neither READ nor
+    * WRITE_FILTER are supported.
+    */
+   png_ptr->do_filter = png_check_byte(png_ptr, filters);
 }
 
-#ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED /* DEPRECATED */
-/* Provide floating and fixed point APIs */
+/* This allows us to influence the way in which libpng chooses the "best"
+ * filter for the current scanline.  While the "minimum-sum-of-absolute-
+ * differences metric is relatively fast and effective, there is some
+ * question as to whether it can be improved upon by trying to keep the
+ * filtered data going to zlib more consistent, hopefully resulting in
+ * better compression.
+ */
+#ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED      /* GRR 970116 */
 #ifdef PNG_FLOATING_POINT_SUPPORTED
-void PNGAPI
-png_set_filter_heuristics(png_structrp png_ptr, int heuristic_method,
+PNG_FUNCTION(void,PNGAPI
+png_set_filter_heuristics,(png_structrp png_ptr, int heuristic_method,
     int num_weights, png_const_doublep filter_weights,
-    png_const_doublep filter_costs)
+    png_const_doublep filter_costs),PNG_DEPRECATED)
 {
    PNG_UNUSED(png_ptr)
    PNG_UNUSED(heuristic_method)
@@ -1128,10 +1121,10 @@ png_set_filter_heuristics(png_structrp png_ptr, int heuristic_method,
 #endif /* FLOATING_POINT */
 
 #ifdef PNG_FIXED_POINT_SUPPORTED
-void PNGAPI
-png_set_filter_heuristics_fixed(png_structrp png_ptr, int heuristic_method,
+PNG_FUNCTION(void,PNGAPI
+png_set_filter_heuristics_fixed,(png_structrp png_ptr, int heuristic_method,
     int num_weights, png_const_fixed_point_p filter_weights,
-    png_const_fixed_point_p filter_costs)
+    png_const_fixed_point_p filter_costs),PNG_DEPRECATED)
 {
    PNG_UNUSED(png_ptr)
    PNG_UNUSED(heuristic_method)
@@ -1386,14 +1379,14 @@ png_write_png(png_structrp png_ptr, png_inforp info_ptr,
     * alpha channel.
     */
    if ((transforms & (PNG_TRANSFORM_STRIP_FILLER_AFTER|
-       PNG_TRANSFORM_STRIP_FILLER_BEFORE)) != 0)
+      PNG_TRANSFORM_STRIP_FILLER_BEFORE)) != 0)
    {
 #ifdef PNG_WRITE_FILLER_SUPPORTED
       if ((transforms & PNG_TRANSFORM_STRIP_FILLER_AFTER) != 0)
       {
          if ((transforms & PNG_TRANSFORM_STRIP_FILLER_BEFORE) != 0)
             png_app_error(png_ptr,
-                "PNG_TRANSFORM_STRIP_FILLER: BEFORE+AFTER not supported");
+               "PNG_TRANSFORM_STRIP_FILLER: BEFORE+AFTER not supported");
 
          /* Continue if ignored - this is the pre-1.6.10 behavior */
          png_set_filler(png_ptr, 0, PNG_FILLER_AFTER);
@@ -1452,13 +1445,13 @@ png_write_png(png_structrp png_ptr, png_inforp info_ptr,
 
 
 #ifdef PNG_SIMPLIFIED_WRITE_SUPPORTED
-# ifdef PNG_STDIO_SUPPORTED /* currently required for png_image_write_* */
+#ifdef PNG_STDIO_SUPPORTED /* currently required for png_image_write_* */
 /* Initialize the write structure - general purpose utility. */
 static int
 png_image_write_init(png_imagep image)
 {
    png_structp png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, image,
-       png_safe_error, png_safe_warning);
+          png_safe_error, png_safe_warning);
 
    if (png_ptr != NULL)
    {
@@ -1467,7 +1460,7 @@ png_image_write_init(png_imagep image)
       if (info_ptr != NULL)
       {
          png_controlp control = png_voidcast(png_controlp,
-             png_malloc_warn(png_ptr, (sizeof *control)));
+            png_malloc_warn(png_ptr, (sizeof *control)));
 
          if (control != NULL)
          {
@@ -1514,12 +1507,12 @@ static int
 png_write_image_16bit(png_voidp argument)
 {
    png_image_write_control *display = png_voidcast(png_image_write_control*,
-       argument);
+      argument);
    png_imagep image = display->image;
    png_structrp png_ptr = image->opaque->png_ptr;
 
    png_const_uint_16p input_row = png_voidcast(png_const_uint_16p,
-       display->first_row);
+      display->first_row);
    png_uint_16p output_row = png_voidcast(png_uint_16p, display->local_row);
    png_uint_16p row_end;
    const int channels = (image->format & PNG_FORMAT_FLAG_COLOR) != 0 ? 3 : 1;
@@ -1528,18 +1521,17 @@ png_write_image_16bit(png_voidp argument)
 
    if ((image->format & PNG_FORMAT_FLAG_ALPHA) != 0)
    {
-#   ifdef PNG_SIMPLIFIED_WRITE_AFIRST_SUPPORTED
-      if ((image->format & PNG_FORMAT_FLAG_AFIRST) != 0)
-      {
-         aindex = -1;
-         ++input_row; /* To point to the first component */
-         ++output_row;
-      }
+#     ifdef PNG_SIMPLIFIED_WRITE_AFIRST_SUPPORTED
+         if ((image->format & PNG_FORMAT_FLAG_AFIRST) != 0)
+         {
+            aindex = -1;
+            ++input_row; /* To point to the first component */
+            ++output_row;
+         }
+
          else
-            aindex = channels;
-#     else
-         aindex = channels;
 #     endif
+         aindex = channels;
    }
 
    else
@@ -1594,7 +1586,7 @@ png_write_image_16bit(png_voidp argument)
             {
                png_uint_32 calc = component * reciprocal;
                calc += 16384; /* round to nearest */
-               component = (png_uint_16)(calc >> 15);
+               component = png_check_u16(png_ptr, calc >> 15);
             }
 
             *out_ptr++ = component;
@@ -1621,11 +1613,11 @@ png_write_image_16bit(png_voidp argument)
  * calculation can be done to 15 bits of accuracy; however, the output needs to
  * be scaled in the range 0..255*65535, so include that scaling here.
  */
-#   define UNP_RECIPROCAL(alpha) ((((0xffff*0xff)<<7)+(alpha>>1))/alpha)
+#define UNP_RECIPROCAL(alpha) ((((0xffff*0xff)<<7)+(alpha>>1))/alpha)
 
 static png_byte
-png_unpremultiply(png_uint_32 component, png_uint_32 alpha,
-   png_uint_32 reciprocal/*from the above macro*/)
+png_unpremultiply(png_const_structrp png_ptr, png_uint_32 component,
+   png_uint_32 alpha, png_uint_32 reciprocal/*from the above macro*/)
 {
    /* The following gives 1.0 for an alpha of 0, which is fine, otherwise if 0/0
     * is represented as some other value there is more likely to be a
@@ -1661,23 +1653,25 @@ png_unpremultiply(png_uint_32 component, png_uint_32 alpha,
          component *= 255;
 
       /* Convert the component to sRGB. */
-      return (png_byte)PNG_sRGB_FROM_LINEAR(component);
+      return PNG_sRGB_FROM_LINEAR(png_ptr, component);
    }
 
    else
       return 0;
+
+   PNG_UNUSEDRC(png_ptr)
 }
 
 static int
 png_write_image_8bit(png_voidp argument)
 {
    png_image_write_control *display = png_voidcast(png_image_write_control*,
-       argument);
+      argument);
    png_imagep image = display->image;
    png_structrp png_ptr = image->opaque->png_ptr;
 
    png_const_uint_16p input_row = png_voidcast(png_const_uint_16p,
-       display->first_row);
+      display->first_row);
    png_bytep output_row = png_voidcast(png_bytep, display->local_row);
    png_uint_32 y = image->height;
    const int channels = (image->format & PNG_FORMAT_FLAG_COLOR) != 0 ? 3 : 1;
@@ -1687,17 +1681,17 @@ png_write_image_8bit(png_voidp argument)
       png_bytep row_end;
       int aindex;
 
-#   ifdef PNG_SIMPLIFIED_WRITE_AFIRST_SUPPORTED
-      if ((image->format & PNG_FORMAT_FLAG_AFIRST) != 0)
-      {
-         aindex = -1;
-         ++input_row; /* To point to the first component */
-         ++output_row;
-      }
+#     ifdef PNG_SIMPLIFIED_WRITE_AFIRST_SUPPORTED
+         if ((image->format & PNG_FORMAT_FLAG_AFIRST) != 0)
+         {
+            aindex = -1;
+            ++input_row; /* To point to the first component */
+            ++output_row;
+         }
 
-      else
-#   endif
-      aindex = channels;
+         else
+#     endif
+         aindex = channels;
 
       /* Use row_end in place of a loop counter: */
       row_end = output_row + image->width * (channels+1);
@@ -1710,7 +1704,7 @@ png_write_image_8bit(png_voidp argument)
          while (out_ptr < row_end)
          {
             png_uint_16 alpha = in_ptr[aindex];
-            png_byte alphabyte = (png_byte)PNG_DIV257(alpha);
+            png_byte alphabyte = png_check_byte(png_ptr, PNG_DIV257(alpha));
             png_uint_32 reciprocal = 0;
             int c;
 
@@ -1722,7 +1716,8 @@ png_write_image_8bit(png_voidp argument)
 
             c = channels;
             do /* always at least one channel */
-               *out_ptr++ = png_unpremultiply(*in_ptr++, alpha, reciprocal);
+               *out_ptr++ = png_unpremultiply(png_ptr, *in_ptr++, alpha,
+                  reciprocal);
             while (--c > 0);
 
             /* Skip to next component (skip the intervening alpha channel) */
@@ -1731,7 +1726,7 @@ png_write_image_8bit(png_voidp argument)
          } /* while out_ptr < row_end */
 
          png_write_row(png_ptr, png_voidcast(png_const_bytep,
-             display->local_row));
+            display->local_row));
          input_row += display->row_bytes/(sizeof (png_uint_16));
       } /* while y */
    }
@@ -1753,7 +1748,7 @@ png_write_image_8bit(png_voidp argument)
             png_uint_32 component = *in_ptr++;
 
             component *= 255;
-            *out_ptr++ = (png_byte)PNG_sRGB_FROM_LINEAR(component);
+            *out_ptr++ = PNG_sRGB_FROM_LINEAR(png_ptr, component);
          }
 
          png_write_row(png_ptr, output_row);
@@ -1770,25 +1765,25 @@ png_image_set_PLTE(png_image_write_control *display)
    const png_imagep image = display->image;
    const void *cmap = display->colormap;
    const int entries = image->colormap_entries > 256 ? 256 :
-       (int)image->colormap_entries;
+      (int)image->colormap_entries;
 
    /* NOTE: the caller must check for cmap != NULL and entries != 0 */
    const png_uint_32 format = image->format;
    const int channels = PNG_IMAGE_SAMPLE_CHANNELS(format);
 
-#   if defined(PNG_FORMAT_BGR_SUPPORTED) &&\
+#  if defined(PNG_FORMAT_BGR_SUPPORTED) &&\
       defined(PNG_SIMPLIFIED_WRITE_AFIRST_SUPPORTED)
       const int afirst = (format & PNG_FORMAT_FLAG_AFIRST) != 0 &&
-          (format & PNG_FORMAT_FLAG_ALPHA) != 0;
-#   else
+         (format & PNG_FORMAT_FLAG_ALPHA) != 0;
+#  else
 #     define afirst 0
-#   endif
+#  endif
 
-#   ifdef PNG_FORMAT_BGR_SUPPORTED
+#  ifdef PNG_FORMAT_BGR_SUPPORTED
       const int bgr = (format & PNG_FORMAT_FLAG_BGR) != 0 ? 2 : 0;
-#   else
+#  else
 #     define bgr 0
-#   endif
+#  endif
 
    int i, num_trans;
    png_color palette[256];
@@ -1812,23 +1807,25 @@ png_image_set_PLTE(png_image_write_control *display)
          {
             if (channels >= 3) /* RGB */
             {
-               palette[i].blue = (png_byte)PNG_sRGB_FROM_LINEAR(255 *
-                   entry[(2 ^ bgr)]);
-               palette[i].green = (png_byte)PNG_sRGB_FROM_LINEAR(255 *
-                   entry[1]);
-               palette[i].red = (png_byte)PNG_sRGB_FROM_LINEAR(255 *
-                   entry[bgr]);
+               palette[i].blue = PNG_sRGB_FROM_LINEAR(
+                  display->image->opaque->png_ptr, 255 * entry[(2 ^ bgr)]);
+               palette[i].green = PNG_sRGB_FROM_LINEAR(
+                  display->image->opaque->png_ptr, 255 * entry[1]);
+               palette[i].red = PNG_sRGB_FROM_LINEAR(
+                  display->image->opaque->png_ptr, 255 * entry[bgr]);
             }
 
             else /* Gray */
                palette[i].blue = palette[i].red = palette[i].green =
-                  (png_byte)PNG_sRGB_FROM_LINEAR(255 * *entry);
+                  PNG_sRGB_FROM_LINEAR(display->image->opaque->png_ptr,
+                     255 * *entry);
          }
 
          else /* alpha */
          {
             png_uint_16 alpha = entry[afirst ? 0 : channels-1];
-            png_byte alphabyte = (png_byte)PNG_DIV257(alpha);
+            png_byte alphabyte = png_check_byte(
+               display->image->opaque->png_ptr, PNG_DIV257(alpha));
             png_uint_32 reciprocal = 0;
 
             /* Calculate a reciprocal, as in the png_write_image_8bit code above
@@ -1844,17 +1841,21 @@ png_image_set_PLTE(png_image_write_control *display)
 
             if (channels >= 3) /* RGB */
             {
-               palette[i].blue = png_unpremultiply(entry[afirst + (2 ^ bgr)],
+               palette[i].blue = png_unpremultiply(
+                  display->image->opaque->png_ptr, entry[afirst + (2 ^ bgr)],
                   alpha, reciprocal);
-               palette[i].green = png_unpremultiply(entry[afirst + 1], alpha,
+               palette[i].green = png_unpremultiply(
+                  display->image->opaque->png_ptr, entry[afirst + 1], alpha,
                   reciprocal);
-               palette[i].red = png_unpremultiply(entry[afirst + bgr], alpha,
+               palette[i].red = png_unpremultiply(
+                  display->image->opaque->png_ptr, entry[afirst + bgr], alpha,
                   reciprocal);
             }
 
             else /* gray */
                palette[i].blue = palette[i].red = palette[i].green =
-                  png_unpremultiply(entry[afirst], alpha, reciprocal);
+                  png_unpremultiply(display->image->opaque->png_ptr,
+                     entry[afirst], alpha, reciprocal);
          }
       }
 
@@ -1893,12 +1894,12 @@ png_image_set_PLTE(png_image_write_control *display)
       }
    }
 
-#   ifdef afirst
+#  ifdef afirst
 #     undef afirst
-#   endif
-#   ifdef bgr
+#  endif
+#  ifdef bgr
 #     undef bgr
-#   endif
+#  endif
 
    png_set_PLTE(image->opaque->png_ptr, image->opaque->info_ptr, palette,
       entries);
@@ -1926,10 +1927,10 @@ png_image_write_main(png_voidp argument)
    int alpha = !colormap && (format & PNG_FORMAT_FLAG_ALPHA);
    int write_16bit = linear && !colormap && (display->convert_to_8bit == 0);
 
-#   ifdef PNG_BENIGN_ERRORS_SUPPORTED
+#  ifdef PNG_BENIGN_ERRORS_SUPPORTED
       /* Make sure we error out on any bad situation */
       png_set_benign_errors(png_ptr, 0/*error*/);
-#   endif
+#  endif
 
    /* Default the 'row_stride' parameter if required. */
    if (display->row_stride == 0)
@@ -2008,23 +2009,23 @@ png_image_write_main(png_voidp argument)
          png_set_swap(png_ptr);
    }
 
-#   ifdef PNG_SIMPLIFIED_WRITE_BGR_SUPPORTED
+#  ifdef PNG_SIMPLIFIED_WRITE_BGR_SUPPORTED
       if ((format & PNG_FORMAT_FLAG_BGR) != 0)
       {
          if (colormap == 0 && (format & PNG_FORMAT_FLAG_COLOR) != 0)
             png_set_bgr(png_ptr);
          format &= ~PNG_FORMAT_FLAG_BGR;
       }
-#   endif
+#  endif
 
-#   ifdef PNG_SIMPLIFIED_WRITE_AFIRST_SUPPORTED
+#  ifdef PNG_SIMPLIFIED_WRITE_AFIRST_SUPPORTED
       if ((format & PNG_FORMAT_FLAG_AFIRST) != 0)
       {
          if (colormap == 0 && (format & PNG_FORMAT_FLAG_ALPHA) != 0)
             png_set_swap_alpha(png_ptr);
          format &= ~PNG_FORMAT_FLAG_AFIRST;
       }
-#   endif
+#  endif
 
    /* If there are 16 or fewer color-map entries we wrote a lower bit depth
     * above, but the application data is still byte packed.
@@ -2060,9 +2061,9 @@ png_image_write_main(png_voidp argument)
        * it about 50 times.  The speed-up in pngstest was about 10-20% of the
        * total (user) time on a heavily loaded system.
        */
-#   ifdef PNG_WRITE_CUSTOMIZE_COMPRESSION_SUPPORTED
+#ifdef PNG_WRITE_CUSTOMIZE_COMPRESSION_SUPPORTED
       png_set_compression_level(png_ptr, 3);
-#   endif
+#endif
    }
 
    /* Check for the cases that currently require a pre-transform on the row
@@ -2225,6 +2226,6 @@ png_image_write_to_file(png_imagep image, const char *file_name,
    else
       return 0;
 }
-# endif /* STDIO */
+#endif /* STDIO */
 #endif /* SIMPLIFIED_WRITE */
 #endif /* WRITE */

pngwtran.c

@@ -1,7 +1,7 @@
 
 /* pngwtran.c - transforms the data in a row for PNG writers
  *
- * Last changed in libpng 1.6.18 [(PENDING RELEASE)]
+ * Last changed in libpng 1.6.17 [(PENDING RELEASE)]
  * Copyright (c) 1998-2015 Glenn Randers-Pehrson
  * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
  * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
@@ -12,151 +12,116 @@
  */
 
 #include "pngpriv.h"
+#define PNG_SRC_FILE PNG_SRC_FILE_pngwtran
 
 #ifdef PNG_WRITE_SUPPORTED
 #ifdef PNG_WRITE_TRANSFORMS_SUPPORTED
 
 #ifdef PNG_WRITE_PACK_SUPPORTED
-/* Pack pixels into bytes.  Pass the true bit depth in bit_depth.  The
+/* Pack pixels into bytes.  Get the true bit depth from png_ptr.  The
  * row_info bit depth should be 8 (one pixel per byte).  The channels
  * should be 1 (this only happens on grayscale and paletted images).
  */
 static void
-png_do_pack(png_row_infop row_info, png_bytep row, png_uint_32 bit_depth)
+png_do_pack(png_transform_controlp row_info, png_bytep row)
 {
    png_debug(1, "in png_do_pack");
 
-   if (row_info->bit_depth == 8 &&
-      row_info->channels == 1)
+#  define png_ptr row_info->png_ptr
+
+   /* The comment suggests the following must be true.
+    * TODO: test this.
+    */
+   affirm(row_info->bit_depth == 8 && row_info->channels == 1);
+
    {
-      switch ((int)bit_depth)
+      switch (png_ptr->bit_depth)
       {
          case 1:
          {
-            png_bytep sp, dp;
-            int mask, v;
-            png_uint_32 i;
-            png_uint_32 row_width = row_info->width;
+            png_const_bytep ep = row + png_transform_rowbytes(row_info);
+            png_bytep dp = row;
+            unsigned int mask = 0x80, v = 0;
 
-            sp = row;
-            dp = row;
-            mask = 0x80;
-            v = 0;
-
-            for (i = 0; i < row_width; i++)
+            while (row < ep)
             {
-               if (*sp != 0)
+               if (*row++ != 0)
                   v |= mask;
 
-               sp++;
+               mask >>= 1;
 
-               if (mask > 1)
-                  mask >>= 1;
-
-               else
+               if (mask == 0)
                {
                   mask = 0x80;
-                  *dp = (png_byte)v;
-                  dp++;
+                  *dp++ = (png_byte)/*SAFE*/v;
                   v = 0;
                }
             }
 
             if (mask != 0x80)
-               *dp = (png_byte)v;
+               *dp++ = (png_byte)/*SAFE*/v;
 
+            row_info->bit_depth = 1;
             break;
          }
 
          case 2:
          {
-            png_bytep sp, dp;
-            unsigned int shift;
-            int v;
-            png_uint_32 i;
-            png_uint_32 row_width = row_info->width;
+            png_const_bytep ep = row + png_transform_rowbytes(row_info);
+            png_bytep dp = row;
+            unsigned int shift = 8, v = 0;
 
-            sp = row;
-            dp = row;
-            shift = 6;
-            v = 0;
-
-            for (i = 0; i < row_width; i++)
+            while (row < ep)
             {
-               png_byte value;
-
-               value = (png_byte)(*sp & 0x03);
-               v |= (value << shift);
+               shift -= 2;
+               v |= (*row++ & 0x3) << shift;
 
                if (shift == 0)
                {
-                  shift = 6;
-                  *dp = (png_byte)v;
-                  dp++;
+                  shift = 8;
+                  *dp++ = png_check_byte(png_ptr, v);
                   v = 0;
                }
-
-               else
-                  shift -= 2;
-
-               sp++;
             }
 
-            if (shift != 6)
-               *dp = (png_byte)v;
+            if (shift != 8)
+               *dp++ = png_check_byte(png_ptr, v);
 
+            row_info->bit_depth = 2;
             break;
          }
 
          case 4:
          {
-            png_bytep sp, dp;
-            unsigned int shift;
-            int v;
-            png_uint_32 i;
-            png_uint_32 row_width = row_info->width;
+            png_const_bytep ep = row + png_transform_rowbytes(row_info);
+            png_bytep dp = row;
+            unsigned int shift = 8, v = 0;
 
-            sp = row;
-            dp = row;
-            shift = 4;
-            v = 0;
-
-            for (i = 0; i < row_width; i++)
+            while (row < ep)
             {
-               png_byte value;
-
-               value = (png_byte)(*sp & 0x0f);
-               v |= (value << shift);
+               shift -= 4;
+               v |= ((*row++ & 0xf) << shift);
 
                if (shift == 0)
                {
-                  shift = 4;
-                  *dp = (png_byte)v;
-                  dp++;
+                  shift = 8;
+                  *dp++ = png_check_byte(png_ptr, v);
                   v = 0;
                }
-
-               else
-                  shift -= 4;
-
-               sp++;
             }
 
-            if (shift != 4)
-               *dp = (png_byte)v;
+            if (shift != 8)
+               *dp++ = png_check_byte(png_ptr, v);
 
+            row_info->bit_depth = 4;
             break;
          }
 
          default:
             break;
       }
-
-      row_info->bit_depth = (png_byte)bit_depth;
-      row_info->pixel_depth = (png_byte)(bit_depth * row_info->channels);
-      row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth,
-          row_info->width);
    }
+#  undef png_ptr
 }
 #endif
 
@@ -167,19 +132,26 @@ png_do_pack(png_row_infop row_info, png_bytep row, png_uint_32 bit_depth)
  * bit depth 4, but the pixels only had values from 0 to 7, you
  * would pass 3 as bit_depth, and this routine would translate the
  * data to 0 to 15.
+ *
+ * NOTE: this is horrible complexity for no value.  Once people suggested they
+ * were selling 16-bit displays with 5:6:5 bits spread R:G:B but so far as I
+ * could determine these displays produced intermediate grey (uncolored) colors,
+ * which is impossible with a true 5:6:5, so most likely 5:6:5 was marketing.
  */
 static void
-png_do_shift(png_row_infop row_info, png_bytep row,
-    png_const_color_8p bit_depth)
+png_do_shift(png_transform_controlp row_info, png_bytep row)
 {
    png_debug(1, "in png_do_shift");
 
-   if (row_info->color_type != PNG_COLOR_TYPE_PALETTE)
+#  define png_ptr row_info->png_ptr
+
+   if (!(row_info->flags & PNG_INDEXED) && (row_info->channels-1) <= 3)
    {
+      png_const_color_8p bit_depth = &png_ptr->shift;
       int shift_start[4], shift_dec[4];
       int channels = 0;
 
-      if ((row_info->color_type & PNG_COLOR_MASK_COLOR) != 0)
+      if (row_info->channels == 3 || row_info->channels == 4)
       {
          shift_start[channels] = row_info->bit_depth - bit_depth->red;
          shift_dec[channels] = bit_depth->red;
@@ -194,27 +166,29 @@ png_do_shift(png_row_infop row_info, png_bytep row,
          channels++;
       }
 
-      else
+      else /* 1 or 2 channels */
       {
          shift_start[channels] = row_info->bit_depth - bit_depth->gray;
          shift_dec[channels] = bit_depth->gray;
          channels++;
       }
 
-      if ((row_info->color_type & PNG_COLOR_MASK_ALPHA) != 0)
+      if (row_info->channels == 2 || row_info->channels == 4)
       {
          shift_start[channels] = row_info->bit_depth - bit_depth->alpha;
          shift_dec[channels] = bit_depth->alpha;
          channels++;
       }
 
-      /* With low row depths, could only be grayscale, so one channel */
+      /* With low res depths, could only be grayscale, so one channel */
       if (row_info->bit_depth < 8)
       {
          png_bytep bp = row;
          png_size_t i;
          unsigned int mask;
-         png_size_t row_bytes = row_info->rowbytes;
+         size_t row_bytes = png_transform_rowbytes(row_info);
+
+         affirm(row_info->channels == 1);
 
          if (bit_depth->gray == 1 && row_info->bit_depth == 2)
             mask = 0x55;
@@ -242,7 +216,7 @@ png_do_shift(png_row_infop row_info, png_bytep row,
                   out |= (v >> (-j)) & mask;
             }
 
-            *bp = (png_byte)(out & 0xff);
+            *bp = png_check_byte(png_ptr, out);
          }
       }
 
@@ -271,7 +245,7 @@ png_do_shift(png_row_infop row_info, png_bytep row,
                   out |= v >> (-j);
             }
 
-            *bp = (png_byte)(out & 0xff);
+            *bp = png_check_byte(png_ptr, out);
          }
       }
 
@@ -298,200 +272,174 @@ png_do_shift(png_row_infop row_info, png_bytep row,
                else
                   value |= v >> (-j);
             }
-            *bp++ = (png_byte)((value >> 8) & 0xff);
-            *bp++ = (png_byte)(value & 0xff);
+            *bp++ = png_check_byte(png_ptr, value >> 8);
+            *bp++ = PNG_BYTE(value);
          }
       }
    }
+
+#  undef png_ptr
 }
 #endif
 
 #ifdef PNG_WRITE_SWAP_ALPHA_SUPPORTED
 static void
-png_do_write_swap_alpha(png_row_infop row_info, png_bytep row)
+png_do_write_swap_alpha(png_transform_controlp row_info, png_bytep row)
 {
    png_debug(1, "in png_do_write_swap_alpha");
 
+#  define png_ptr row_info->png_ptr
    {
-      if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
+      if (row_info->channels == 4)
       {
          if (row_info->bit_depth == 8)
          {
-            /* This converts from ARGB to RGBA */
-            png_bytep sp, dp;
-            png_uint_32 i;
-            png_uint_32 row_width = row_info->width;
+            png_const_bytep ep = row + png_transform_rowbytes(row_info) - 4;
 
-            for (i = 0, sp = dp = row; i < row_width; i++)
+            /* This converts from ARGB to RGBA */
+            while (row <= ep)
             {
-               png_byte save = *(sp++);
-               *(dp++) = *(sp++);
-               *(dp++) = *(sp++);
-               *(dp++) = *(sp++);
-               *(dp++) = save;
+               png_byte save = row[0];
+               row[0] = row[1];
+               row[1] = row[2];
+               row[2] = row[3];
+               row[3] = save;
+               row += 4;
             }
+
+            debug(row == ep+4);
          }
 
 #ifdef PNG_WRITE_16BIT_SUPPORTED
-         else
+         else if (row_info->bit_depth == 16)
          {
             /* This converts from AARRGGBB to RRGGBBAA */
-            png_bytep sp, dp;
-            png_uint_32 i;
-            png_uint_32 row_width = row_info->width;
+            png_const_bytep ep = row + png_transform_rowbytes(row_info) - 8;
 
-            for (i = 0, sp = dp = row; i < row_width; i++)
+            while (row <= ep)
             {
-               png_byte save[2];
-               save[0] = *(sp++);
-               save[1] = *(sp++);
-               *(dp++) = *(sp++);
-               *(dp++) = *(sp++);
-               *(dp++) = *(sp++);
-               *(dp++) = *(sp++);
-               *(dp++) = *(sp++);
-               *(dp++) = *(sp++);
-               *(dp++) = save[0];
-               *(dp++) = save[1];
+               png_byte s0 = row[0];
+               png_byte s1 = row[1];
+               memmove(row, row+2, 6);
+               row[6] = s0;
+               row[7] = s1;
+               row += 8;
             }
+
+            debug(row == ep+8);
          }
 #endif /* WRITE_16BIT */
       }
 
-      else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
+      else if (row_info->channels == 2)
       {
          if (row_info->bit_depth == 8)
          {
             /* This converts from AG to GA */
-            png_bytep sp, dp;
-            png_uint_32 i;
-            png_uint_32 row_width = row_info->width;
+            png_const_bytep ep = row + png_transform_rowbytes(row_info) - 2;
 
-            for (i = 0, sp = dp = row; i < row_width; i++)
+            /* This converts from ARGB to RGBA */
+            while (row <= ep)
             {
-               png_byte save = *(sp++);
-               *(dp++) = *(sp++);
-               *(dp++) = save;
+               png_byte save = *row;
+               *row = row[1], ++row;
+               *row++ = save;
             }
+
+            debug(row == ep+2);
          }
 
 #ifdef PNG_WRITE_16BIT_SUPPORTED
          else
          {
             /* This converts from AAGG to GGAA */
-            png_bytep sp, dp;
-            png_uint_32 i;
-            png_uint_32 row_width = row_info->width;
+            png_const_bytep ep = row + png_transform_rowbytes(row_info) - 4;
 
-            for (i = 0, sp = dp = row; i < row_width; i++)
+            while (row <= ep)
             {
-               png_byte save[2];
-               save[0] = *(sp++);
-               save[1] = *(sp++);
-               *(dp++) = *(sp++);
-               *(dp++) = *(sp++);
-               *(dp++) = save[0];
-               *(dp++) = save[1];
+               png_byte save = row[0];
+               row[0] = row[2];
+               row[2] = save;
+
+               save = row[1];
+               row[1] = row[3];
+               row[3] = save;
+
+               row += 4;
             }
+
+            debug(row == ep+4);
          }
 #endif /* WRITE_16BIT */
       }
    }
+
+#  undef png_ptr
 }
 #endif
 
 #ifdef PNG_WRITE_INVERT_ALPHA_SUPPORTED
 static void
-png_do_write_invert_alpha(png_row_infop row_info, png_bytep row)
+png_do_write_invert_alpha(png_transform_controlp row_info, png_bytep row)
 {
    png_debug(1, "in png_do_write_invert_alpha");
 
+#  define png_ptr row_info->png_ptr
    {
-      if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
+      if (row_info->channels == 4)
       {
          if (row_info->bit_depth == 8)
          {
             /* This inverts the alpha channel in RGBA */
-            png_bytep sp, dp;
-            png_uint_32 i;
-            png_uint_32 row_width = row_info->width;
+            png_const_bytep ep = row + png_transform_rowbytes(row_info) - 1;
 
-            for (i = 0, sp = dp = row; i < row_width; i++)
-            {
-               /* Does nothing
-               *(dp++) = *(sp++);
-               *(dp++) = *(sp++);
-               *(dp++) = *(sp++);
-               */
-               sp+=3; dp = sp;
-               *dp = (png_byte)(255 - *(sp++));
-            }
+            row += 3; /* alpha channel */
+            while (row <= ep)
+               *row ^= 0xff, row += 4;
          }
 
 #ifdef PNG_WRITE_16BIT_SUPPORTED
-         else
+         else if (row_info->bit_depth == 16)
          {
             /* This inverts the alpha channel in RRGGBBAA */
-            png_bytep sp, dp;
-            png_uint_32 i;
-            png_uint_32 row_width = row_info->width;
+            png_const_bytep ep = row + png_transform_rowbytes(row_info) - 2;
 
-            for (i = 0, sp = dp = row; i < row_width; i++)
-            {
-               /* Does nothing
-               *(dp++) = *(sp++);
-               *(dp++) = *(sp++);
-               *(dp++) = *(sp++);
-               *(dp++) = *(sp++);
-               *(dp++) = *(sp++);
-               *(dp++) = *(sp++);
-               */
-               sp+=6; dp = sp;
-               *(dp++) = (png_byte)(255 - *(sp++));
-               *dp     = (png_byte)(255 - *(sp++));
-            }
+            row += 6;
+
+            while (row <= ep)
+               row[0] ^= 0xff, row[1] ^= 0xff, row += 8;
          }
 #endif /* WRITE_16BIT */
       }
 
-      else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
+      else if (row_info->channels == 2)
       {
          if (row_info->bit_depth == 8)
          {
             /* This inverts the alpha channel in GA */
-            png_bytep sp, dp;
-            png_uint_32 i;
-            png_uint_32 row_width = row_info->width;
+            png_const_bytep ep = row + png_transform_rowbytes(row_info) - 1;
 
-            for (i = 0, sp = dp = row; i < row_width; i++)
-            {
-               *(dp++) = *(sp++);
-               *(dp++) = (png_byte)(255 - *(sp++));
-            }
+            ++row;
+
+            while (row <= ep)
+               *row ^= 0xff, row += 2;
          }
 
 #ifdef PNG_WRITE_16BIT_SUPPORTED
          else
          {
             /* This inverts the alpha channel in GGAA */
-            png_bytep sp, dp;
-            png_uint_32 i;
-            png_uint_32 row_width = row_info->width;
+            png_const_bytep ep = row + png_transform_rowbytes(row_info) - 2;
 
-            for (i = 0, sp = dp = row; i < row_width; i++)
-            {
-               /* Does nothing
-               *(dp++) = *(sp++);
-               *(dp++) = *(sp++);
-               */
-               sp+=2; dp = sp;
-               *(dp++) = (png_byte)(255 - *(sp++));
-               *dp     = (png_byte)(255 - *(sp++));
-            }
+            row += 2;
+
+            while (row <= ep)
+               row[0] ^= 0xff, row[1] ^= 0xff, row += 4;
          }
 #endif /* WRITE_16BIT */
       }
    }
+#  undef png_ptr
 }
 #endif
 
@@ -499,8 +447,10 @@ png_do_write_invert_alpha(png_row_infop row_info, png_bytep row)
  * transformations is significant.
  */
 void /* PRIVATE */
-png_do_write_transformations(png_structrp png_ptr, png_row_infop row_info)
+png_do_write_transformations(png_structrp png_ptr, png_row_infop row_info_in)
 {
+   png_transform_control display;
+
    png_debug(1, "in png_do_write_transformations");
 
    if (png_ptr == NULL)
@@ -512,7 +462,7 @@ png_do_write_transformations(png_structrp png_ptr, png_row_infop row_info)
          (*(png_ptr->write_user_transform_fn)) /* User write transform
                                                  function */
              (png_ptr,  /* png_ptr */
-             row_info,  /* row_info: */
+              row_info_in,  /* row_info: */
                 /*  png_uint_32 width;       width of row */
                 /*  png_size_t rowbytes;     number of bytes in row */
                 /*  png_byte color_type;     color type of pixels */
@@ -522,55 +472,65 @@ png_do_write_transformations(png_structrp png_ptr, png_row_infop row_info)
              png_ptr->row_buf + 1);      /* start of pixel data for row */
 #endif
 
+   png_init_transform_control(png_ptr, &display, row_info_in);
+
 #ifdef PNG_WRITE_FILLER_SUPPORTED
    if ((png_ptr->transformations & PNG_FILLER) != 0)
-      png_do_strip_channel(row_info, png_ptr->row_buf + 1,
+      png_do_strip_channel(&display, png_ptr->row_buf + 1,
          !(png_ptr->flags & PNG_FLAG_FILLER_AFTER));
 #endif
 
 #ifdef PNG_WRITE_PACKSWAP_SUPPORTED
    if ((png_ptr->transformations & PNG_PACKSWAP) != 0)
-      png_do_packswap(row_info, png_ptr->row_buf + 1);
+      png_do_packswap(&display, png_ptr->row_buf + 1);
 #endif
 
 #ifdef PNG_WRITE_PACK_SUPPORTED
    if ((png_ptr->transformations & PNG_PACK) != 0)
-      png_do_pack(row_info, png_ptr->row_buf + 1,
-          (png_uint_32)png_ptr->bit_depth);
+      png_do_pack(&display, png_ptr->row_buf + 1);
 #endif
 
 #ifdef PNG_WRITE_SWAP_SUPPORTED
 #  ifdef PNG_16BIT_SUPPORTED
    if ((png_ptr->transformations & PNG_SWAP_BYTES) != 0)
-      png_do_swap(row_info, png_ptr->row_buf + 1);
+      png_do_swap(&display, png_ptr->row_buf + 1);
 #  endif
 #endif
 
 #ifdef PNG_WRITE_SHIFT_SUPPORTED
    if ((png_ptr->transformations & PNG_SHIFT) != 0)
-      png_do_shift(row_info, png_ptr->row_buf + 1,
-          &(png_ptr->shift));
+      png_do_shift(&display, png_ptr->row_buf + 1);
 #endif
 
 #ifdef PNG_WRITE_SWAP_ALPHA_SUPPORTED
    if ((png_ptr->transformations & PNG_SWAP_ALPHA) != 0)
-      png_do_write_swap_alpha(row_info, png_ptr->row_buf + 1);
+      png_do_write_swap_alpha(&display, png_ptr->row_buf + 1);
 #endif
 
 #ifdef PNG_WRITE_INVERT_ALPHA_SUPPORTED
    if ((png_ptr->transformations & PNG_INVERT_ALPHA) != 0)
-      png_do_write_invert_alpha(row_info, png_ptr->row_buf + 1);
+      png_do_write_invert_alpha(&display, png_ptr->row_buf + 1);
 #endif
 
 #ifdef PNG_WRITE_BGR_SUPPORTED
    if ((png_ptr->transformations & PNG_BGR) != 0)
-      png_do_bgr(row_info, png_ptr->row_buf + 1);
+      png_do_bgr(&display, png_ptr->row_buf + 1);
 #endif
 
 #ifdef PNG_WRITE_INVERT_SUPPORTED
    if ((png_ptr->transformations & PNG_INVERT_MONO) != 0)
-      png_do_invert(row_info, png_ptr->row_buf + 1);
+      png_do_invert(&display, png_ptr->row_buf + 1);
 #endif
+
+   /* Clear the flags; they are irrelevant because the write code is
+    * reversing transformations to get PNG data but the shared transformation
+    * code assumes input PNG data.  Only PNG_INDEXED is required.
+    */
+   if ((display.flags & PNG_BAD_INDEX) != 0)
+      png_error(png_ptr, "palette data has out of range index");
+
+   display.flags &= PNG_INDEXED;
+   png_end_transform_control(row_info_in, &display);
 }
 #endif /* WRITE_TRANSFORMS */
 #endif /* WRITE */

pngwutil.c

@@ -1,7 +1,7 @@
 
 /* pngwutil.c - utilities to write a PNG file
  *
- * Last changed in libpng 1.6.18 [(PENDING RELEASE)]
+ * Last changed in libpng 1.7.0 [(PENDING RELEASE)]
  * Copyright (c) 1998-2015 Glenn Randers-Pehrson
  * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
  * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
@@ -12,6 +12,7 @@
  */
 
 #include "pngpriv.h"
+#define PNG_SRC_FILE PNG_SRC_FILE_pngwutil
 
 #ifdef PNG_WRITE_SUPPORTED
 
@@ -23,10 +24,10 @@
 void PNGAPI
 png_save_uint_32(png_bytep buf, png_uint_32 i)
 {
-   buf[0] = (png_byte)(i >> 24);
-   buf[1] = (png_byte)(i >> 16);
-   buf[2] = (png_byte)(i >> 8);
-   buf[3] = (png_byte)(i     );
+   buf[0] = PNG_BYTE(i >> 24);
+   buf[1] = PNG_BYTE(i >> 16);
+   buf[2] = PNG_BYTE(i >> 8);
+   buf[3] = PNG_BYTE(i);
 }
 
 /* Place a 16-bit number into a buffer in PNG byte order.
@@ -36,8 +37,8 @@ png_save_uint_32(png_bytep buf, png_uint_32 i)
 void PNGAPI
 png_save_uint_16(png_bytep buf, unsigned int i)
 {
-   buf[0] = (png_byte)(i >> 8);
-   buf[1] = (png_byte)(i     );
+   buf[0] = PNG_BYTE(i >> 8);
+   buf[1] = PNG_BYTE(i);
 }
 #endif
 
@@ -278,10 +279,10 @@ optimize_cmf(png_bytep data, png_alloc_size_t data_size)
 
             z_cmf = (z_cmf & 0x0f) | (z_cinfo << 4);
 
-            data[0] = (png_byte)z_cmf;
+            data[0] = png_check_byte(0/*TODO: fixme*/, z_cmf);
             tmp = data[1] & 0xe0;
             tmp += 0x1f - ((z_cmf << 8) + tmp) % 0x1f;
-            data[1] = (png_byte)tmp;
+            data[1] = png_check_byte(0/*TODO: fixme*/, tmp);
          }
       }
    }
@@ -334,6 +335,7 @@ png_deflate_claim(png_structrp png_ptr, png_uint_32 owner,
 
       if (owner == png_IDAT)
       {
+#ifdef PNG_WRITE_CUSTOMIZE_COMPRESSION_SUPPORTED
          if ((png_ptr->flags & PNG_FLAG_ZLIB_CUSTOM_STRATEGY) != 0)
             strategy = png_ptr->zlib_strategy;
 
@@ -341,6 +343,7 @@ png_deflate_claim(png_structrp png_ptr, png_uint_32 owner,
             strategy = PNG_Z_DEFAULT_STRATEGY;
 
          else
+#endif
             strategy = PNG_Z_DEFAULT_NOFILTER_STRATEGY;
       }
 
@@ -660,8 +663,7 @@ png_write_compressed_data_out(png_structrp png_ptr, compression_state *comp)
    }
 
    /* This is an internal error; 'next' must have been NULL! */
-   if (output_len > 0)
-      png_error(png_ptr, "error writing ancillary chunked compressed data");
+   affirm(output_len == 0);
 }
 #endif /* WRITE_COMPRESSED_TEXT */
 
@@ -695,7 +697,7 @@ png_check_keyword(png_structrp png_ptr, png_const_charp key, png_bytep new_key)
 
    while (*key && key_len < 79)
    {
-      png_byte ch = (png_byte)*key++;
+      png_byte ch = (png_byte)(0xff & *key++);
 
       if ((ch > 32 && ch <= 126) || (ch >= 161 /*&& ch <= 255*/))
          *new_key++ = ch, ++key_len, space = 0;
@@ -872,17 +874,18 @@ png_write_IHDR(png_structrp png_ptr, png_uint_32 width, png_uint_32 height,
 #endif
 
    /* Save the relevant information */
-   png_ptr->bit_depth = (png_byte)bit_depth;
-   png_ptr->color_type = (png_byte)color_type;
-   png_ptr->interlaced = (png_byte)interlace_type;
+   png_ptr->bit_depth = png_check_byte(png_ptr, bit_depth);
+   png_ptr->color_type = png_check_byte(png_ptr, color_type);
+   png_ptr->interlaced = png_check_byte(png_ptr, interlace_type);
 #ifdef PNG_MNG_FEATURES_SUPPORTED
-   png_ptr->filter_type = (png_byte)filter_type;
+   png_ptr->filter_type = png_check_byte(png_ptr, filter_type);
 #endif
-   png_ptr->compression_type = (png_byte)compression_type;
+   png_ptr->compression_type = png_check_byte(png_ptr, compression_type);
    png_ptr->width = width;
    png_ptr->height = height;
 
-   png_ptr->pixel_depth = (png_byte)(bit_depth * png_ptr->channels);
+   png_ptr->pixel_depth = png_check_byte(png_ptr,
+      bit_depth * png_ptr->channels);
    png_ptr->rowbytes = PNG_ROWBYTES(png_ptr->pixel_depth, width);
    /* Set the usr info, so any transformations can modify it */
    png_ptr->usr_width = png_ptr->width;
@@ -892,11 +895,11 @@ png_write_IHDR(png_structrp png_ptr, png_uint_32 width, png_uint_32 height,
    /* Pack the header information into the buffer */
    png_save_uint_32(buf, width);
    png_save_uint_32(buf + 4, height);
-   buf[8] = (png_byte)bit_depth;
-   buf[9] = (png_byte)color_type;
-   buf[10] = (png_byte)compression_type;
-   buf[11] = (png_byte)filter_type;
-   buf[12] = (png_byte)interlace_type;
+   buf[8] = png_check_byte(png_ptr, bit_depth);
+   buf[9] = png_check_byte(png_ptr, color_type);
+   buf[10] = png_check_byte(png_ptr, compression_type);
+   buf[11] = png_check_byte(png_ptr, filter_type);
+   buf[12] = png_check_byte(png_ptr, interlace_type);
 
    /* Write the chunk */
    png_write_complete_chunk(png_ptr, png_IHDR, buf, (png_size_t)13);
@@ -954,7 +957,7 @@ png_write_PLTE(png_structrp png_ptr, png_const_colorp palette,
       return;
    }
 
-   png_ptr->num_palette = (png_uint_16)num_pal;
+   png_ptr->num_palette = png_check_u16(png_ptr, num_pal);
    png_debug1(3, "num_palette = %d", png_ptr->num_palette);
 
    png_write_chunk_header(png_ptr, png_PLTE, (png_uint_32)(num_pal * 3));
@@ -1181,7 +1184,7 @@ png_write_sRGB(png_structrp png_ptr, int srgb_intent)
       png_warning(png_ptr,
           "Invalid sRGB rendering intent specified");
 
-   buf[0]=(png_byte)srgb_intent;
+   buf[0] = png_check_byte(png_ptr, srgb_intent);
    png_write_complete_chunk(png_ptr, png_sRGB, buf, (png_size_t)1);
 }
 #endif
@@ -1196,23 +1199,20 @@ png_write_iCCP(png_structrp png_ptr, png_const_charp name,
    png_uint_32 profile_len;
    png_byte new_name[81]; /* 1 byte for the compression byte */
    compression_state comp;
-   png_uint_32 temp;
 
    png_debug(1, "in png_write_iCCP");
 
    /* These are all internal problems: the profile should have been checked
     * before when it was stored.
     */
-   if (profile == NULL)
-      png_error(png_ptr, "No profile for iCCP chunk"); /* internal error */
+   affirm(profile != NULL);
 
    profile_len = png_get_uint_32(profile);
 
    if (profile_len < 132)
       png_error(png_ptr, "ICC profile too short");
 
-   temp = (png_uint_32) (*(profile+8));
-   if (temp > 3 && (profile_len & 0x03))
+   if (profile_len & 0x03)
       png_error(png_ptr, "ICC profile length invalid (not a multiple of 4)");
 
    {
@@ -1274,10 +1274,9 @@ png_write_sPLT(png_structrp png_ptr, png_const_sPLT_tp spalette)
    png_write_chunk_header(png_ptr, png_sPLT,
        (png_uint_32)(name_len + 2 + palette_size));
 
-   png_write_chunk_data(png_ptr, (png_bytep)new_name,
-       (png_size_t)(name_len + 1));
+   png_write_chunk_data(png_ptr, new_name, name_len + 1);
 
-   png_write_chunk_data(png_ptr, &spalette->depth, (png_size_t)1);
+   png_write_chunk_data(png_ptr, &spalette->depth, 1);
 
    /* Loop through each palette entry, writing appropriately */
 #ifdef PNG_POINTER_INDEXING_SUPPORTED
@@ -1285,10 +1284,10 @@ png_write_sPLT(png_structrp png_ptr, png_const_sPLT_tp spalette)
    {
       if (spalette->depth == 8)
       {
-         entrybuf[0] = (png_byte)ep->red;
-         entrybuf[1] = (png_byte)ep->green;
-         entrybuf[2] = (png_byte)ep->blue;
-         entrybuf[3] = (png_byte)ep->alpha;
+         entrybuf[0] = png_check_byte(png_ptr, ep->red);
+         entrybuf[1] = png_check_byte(png_ptr, ep->green);
+         entrybuf[2] = png_check_byte(png_ptr, ep->blue);
+         entrybuf[3] = png_check_byte(png_ptr, ep->alpha);
          png_save_uint_16(entrybuf + 4, ep->frequency);
       }
 
@@ -1309,10 +1308,10 @@ png_write_sPLT(png_structrp png_ptr, png_const_sPLT_tp spalette)
    {
       if (spalette->depth == 8)
       {
-         entrybuf[0] = (png_byte)ep[i].red;
-         entrybuf[1] = (png_byte)ep[i].green;
-         entrybuf[2] = (png_byte)ep[i].blue;
-         entrybuf[3] = (png_byte)ep[i].alpha;
+         entrybuf[0] = png_check_byte(png_ptr, ep[i].red);
+         entrybuf[1] = png_check_byte(png_ptr, ep[i].green);
+         entrybuf[2] = png_check_byte(png_ptr, ep[i].blue);
+         entrybuf[3] = png_check_byte(png_ptr, ep[i].alpha);
          png_save_uint_16(entrybuf + 4, ep[i].frequency);
       }
 
@@ -1348,7 +1347,7 @@ png_write_sBIT(png_structrp png_ptr, png_const_color_8p sbit, int color_type)
    {
       png_byte maxbits;
 
-      maxbits = (png_byte)(color_type==PNG_COLOR_TYPE_PALETTE ? 8 :
+      maxbits = png_check_byte(png_ptr, color_type==PNG_COLOR_TYPE_PALETTE ? 8 :
           png_ptr->usr_bit_depth);
 
       if (sbit->red == 0 || sbit->red > maxbits ||
@@ -1430,9 +1429,10 @@ png_write_tRNS(png_structrp png_ptr, png_const_bytep trans_alpha,
 
    if (color_type == PNG_COLOR_TYPE_PALETTE)
    {
-      if (num_trans <= 0 || num_trans > (int)png_ptr->num_palette)
+      if (num_trans <= 0 || num_trans > png_ptr->num_palette)
       {
-         png_app_warning(png_ptr,
+         /* This is an error which can only be reliably detected late. */
+         png_app_error(png_ptr,
              "Invalid number of transparent colors specified");
          return;
       }
@@ -1447,7 +1447,8 @@ png_write_tRNS(png_structrp png_ptr, png_const_bytep trans_alpha,
       /* One 16 bit value */
       if (tran->gray >= (1 << png_ptr->bit_depth))
       {
-         png_app_warning(png_ptr,
+         /* This can no longer happen because it is checked in png_set_tRNS */
+         png_app_error(png_ptr,
              "Ignoring attempt to write tRNS chunk out-of-range for bit_depth");
 
          return;
@@ -1469,7 +1470,8 @@ png_write_tRNS(png_structrp png_ptr, png_const_bytep trans_alpha,
       if ((buf[0] | buf[2] | buf[4]) != 0)
 #endif
       {
-         png_app_warning(png_ptr,
+         /* Also checked in png_set_tRNS */
+         png_app_error(png_ptr,
            "Ignoring attempt to write 16-bit tRNS chunk when bit_depth is 8");
          return;
       }
@@ -1479,7 +1481,8 @@ png_write_tRNS(png_structrp png_ptr, png_const_bytep trans_alpha,
 
    else
    {
-      png_app_warning(png_ptr, "Can't write tRNS with an alpha channel");
+      /* Checked in png_set_tRNS */
+      png_app_error(png_ptr, "Can't write tRNS with an alpha channel");
    }
 }
 #endif
@@ -1786,7 +1789,7 @@ png_write_oFFs(png_structrp png_ptr, png_int_32 x_offset, png_int_32 y_offset,
 
    png_save_int_32(buf, x_offset);
    png_save_int_32(buf + 4, y_offset);
-   buf[8] = (png_byte)unit_type;
+   buf[8] = png_check_byte(png_ptr, unit_type);
 
    png_write_complete_chunk(png_ptr, png_oFFs, buf, (png_size_t)9);
 }
@@ -1841,8 +1844,8 @@ png_write_pCAL(png_structrp png_ptr, png_charp purpose, png_int_32 X0,
    png_write_chunk_data(png_ptr, new_purpose, purpose_len);
    png_save_int_32(buf, X0);
    png_save_int_32(buf + 4, X1);
-   buf[8] = (png_byte)type;
-   buf[9] = (png_byte)nparams;
+   buf[8] = png_check_byte(png_ptr, type);
+   buf[9] = png_check_byte(png_ptr, nparams);
    png_write_chunk_data(png_ptr, buf, (png_size_t)10);
    png_write_chunk_data(png_ptr, (png_const_bytep)units, (png_size_t)units_len);
 
@@ -1877,7 +1880,7 @@ png_write_sCAL_s(png_structrp png_ptr, int unit, png_const_charp width,
       return;
    }
 
-   buf[0] = (png_byte)unit;
+   buf[0] = png_check_byte(png_ptr, unit);
    memcpy(buf + 1, width, wlen + 1);      /* Append the '\0' here */
    memcpy(buf + wlen + 2, height, hlen);  /* Do NOT append the '\0' here */
 
@@ -1902,7 +1905,7 @@ png_write_pHYs(png_structrp png_ptr, png_uint_32 x_pixels_per_unit,
 
    png_save_uint_32(buf, x_pixels_per_unit);
    png_save_uint_32(buf + 4, y_pixels_per_unit);
-   buf[8] = (png_byte)unit_type;
+   buf[8] = png_check_byte(png_ptr, unit_type);
 
    png_write_complete_chunk(png_ptr, png_pHYs, buf, (png_size_t)9);
 }
@@ -1938,60 +1941,19 @@ png_write_tIME(png_structrp png_ptr, png_const_timep mod_time)
 }
 #endif
 
-/* Initializes the row writing capability of libpng */
+#ifdef PNG_WRITE_FILTER_SUPPORTED
 void /* PRIVATE */
-png_write_start_row(png_structrp png_ptr)
+png_write_alloc_filter_row_buffers(png_structrp png_ptr, int filters)
+   /* Allocate row buffers for any filters that need them. This is also called
+    * from png_set_filter if the filters are changed during write to ensure that
+    * the required buffers exist.  png_set_filter ensures that up/avg/paeth are
+    * only set if png_ptr->prev_row is allocated.
+    */
 {
-#ifdef PNG_WRITE_INTERLACING_SUPPORTED
-   /* Arrays to facilitate easy interlacing - use pass (0 - 6) as index */
-
-   /* Start of interlace block */
-   static PNG_CONST png_byte png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0};
-
-   /* Offset to next interlace block */
-   static PNG_CONST png_byte png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1};
-
-   /* Start of interlace block in the y direction */
-   static PNG_CONST png_byte png_pass_ystart[7] = {0, 0, 4, 0, 2, 0, 1};
-
-   /* Offset to next interlace block in the y direction */
-   static PNG_CONST png_byte png_pass_yinc[7] = {8, 8, 8, 4, 4, 2, 2};
-#endif
-
-   png_alloc_size_t buf_size;
-   int usr_pixel_depth;
-
-#ifdef PNG_WRITE_FILTER_SUPPORTED
-   png_byte filters;
-#endif
-
-   png_debug(1, "in png_write_start_row");
-
-   usr_pixel_depth = png_ptr->usr_channels * png_ptr->usr_bit_depth;
-   buf_size = PNG_ROWBYTES(usr_pixel_depth, png_ptr->width) + 1;
-
-   /* 1.5.6: added to allow checking in the row write code. */
-   png_ptr->transformed_pixel_depth = png_ptr->pixel_depth;
-   png_ptr->maximum_pixel_depth = (png_byte)usr_pixel_depth;
-
-   /* Set up row buffer */
-   png_ptr->row_buf = png_voidcast(png_bytep, png_malloc(png_ptr, buf_size));
-
-   png_ptr->row_buf[0] = PNG_FILTER_VALUE_NONE;
-
-#ifdef PNG_WRITE_FILTER_SUPPORTED
-   filters = png_ptr->do_filter;
-
-   if (png_ptr->height == 1)
-      filters &= 0xff & ~(PNG_FILTER_UP|PNG_FILTER_AVG|PNG_FILTER_PAETH);
-
-   if (png_ptr->width == 1)
-      filters &= 0xff & ~(PNG_FILTER_SUB|PNG_FILTER_AVG|PNG_FILTER_PAETH);
-
-   if (filters == 0)
-      filters = PNG_FILTER_NONE;
-
-   png_ptr->do_filter = filters;
+   /* The buffer size is determined just by the output row size, not any
+    * processing requirements.
+    */
+   png_alloc_size_t buf_size = png_ptr->rowbytes + 1;
 
    if (((filters & (PNG_FILTER_SUB | PNG_FILTER_UP | PNG_FILTER_AVG |
        PNG_FILTER_PAETH)) != 0) && png_ptr->try_row == NULL)
@@ -2013,16 +1975,81 @@ png_write_start_row(png_structrp png_ptr)
          num_filters++;
 
       if (num_filters > 1)
-         png_ptr->tst_row = png_voidcast(png_bytep, png_malloc(png_ptr,
-             buf_size));
+         png_ptr->tst_row = png_voidcast(png_bytep,
+             png_malloc(png_ptr, buf_size));
    }
+}
+#endif /* WRITE_FILTER */
+
+/* Initializes the row writing capability of libpng */
+void /* PRIVATE */
+png_write_start_row(png_structrp png_ptr)
+{
+#ifdef PNG_WRITE_INTERLACING_SUPPORTED
+   /* Arrays to facilitate easy interlacing - use pass (0 - 6) as index */
+
+   /* Start of interlace block */
+   static PNG_CONST png_byte png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0};
+
+   /* Offset to next interlace block */
+   static PNG_CONST png_byte png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1};
+
+   /* Start of interlace block in the y direction */
+   static PNG_CONST png_byte png_pass_ystart[7] = {0, 0, 4, 0, 2, 0, 1};
+
+   /* Offset to next interlace block in the y direction */
+   static PNG_CONST png_byte png_pass_yinc[7] = {8, 8, 8, 4, 4, 2, 2};
+#endif
+
+#ifdef PNG_WRITE_FILTER_SUPPORTED
+   int filters;
+#endif
+
+   png_alloc_size_t buf_size;
+   unsigned int usr_pixel_depth;
+
+   png_debug(1, "in png_write_start_row");
+
+   if (png_ptr == NULL)
+      return;
+
+   usr_pixel_depth = png_ptr->usr_channels * png_ptr->usr_bit_depth;
+   buf_size = PNG_ROWBYTES(usr_pixel_depth, png_ptr->width) + 1;
+
+   /* 1.5.6: added to allow checking in the row write code. */
+   png_ptr->transformed_pixel_depth = png_ptr->pixel_depth;
+   png_ptr->maximum_pixel_depth = usr_pixel_depth;
+
+   /* Set up row buffer */
+   png_ptr->row_buf = png_voidcast(png_bytep, png_malloc(png_ptr, buf_size));
+
+   png_ptr->row_buf[0] = PNG_FILTER_VALUE_NONE;
+
+#ifdef PNG_WRITE_FILTER_SUPPORTED
+   filters = png_ptr->do_filter;
+
+   if (png_ptr->height == 1)
+      filters &= ~(PNG_FILTER_UP|PNG_FILTER_AVG|PNG_FILTER_PAETH);
+
+   if (png_ptr->width == 1)
+      filters &= ~(PNG_FILTER_SUB|PNG_FILTER_AVG|PNG_FILTER_PAETH);
+
+   if (filters == 0)
+      filters = PNG_FILTER_NONE;
 
    /* We only need to keep the previous row if we are using one of the following
     * filters.
     */
    if ((filters & (PNG_FILTER_AVG | PNG_FILTER_UP | PNG_FILTER_PAETH)) != 0)
-      png_ptr->prev_row = png_voidcast(png_bytep,
-         png_calloc(png_ptr, buf_size));
+      png_ptr->prev_row = png_voidcast(png_bytep, png_calloc(png_ptr,
+         buf_size));
+
+   png_write_alloc_filter_row_buffers(png_ptr, filters);
+
+   /* in case it was changed above */
+   png_ptr->do_filter = png_check_byte(png_ptr, filters);
+#else
+   png_ptr->do_filter = PNG_FILTER_NONE;
 #endif /* WRITE_FILTER */
 
 #ifdef PNG_WRITE_INTERLACING_SUPPORTED
@@ -2188,7 +2215,7 @@ png_do_write_interlace(png_row_infop row_info, png_bytep row, int pass)
                if (shift == 0)
                {
                   shift = 7;
-                  *dp++ = (png_byte)d;
+                  *dp++ = png_check_byte(0/*TODO: fixme*/, d);
                   d = 0;
                }
 
@@ -2197,7 +2224,7 @@ png_do_write_interlace(png_row_infop row_info, png_bytep row, int pass)
 
             }
             if (shift != 7)
-               *dp = (png_byte)d;
+               *dp = png_check_byte(0/*TODO: fixme*/, d);
 
             break;
          }
@@ -2226,7 +2253,7 @@ png_do_write_interlace(png_row_infop row_info, png_bytep row, int pass)
                if (shift == 0)
                {
                   shift = 6;
-                  *dp++ = (png_byte)d;
+                  *dp++ = png_check_byte(0/*TODO: fixme*/, d);
                   d = 0;
                }
 
@@ -2234,7 +2261,7 @@ png_do_write_interlace(png_row_infop row_info, png_bytep row, int pass)
                   shift -= 2;
             }
             if (shift != 6)
-               *dp = (png_byte)d;
+               *dp = png_check_byte(0/*TODO: fixme*/, d);
 
             break;
          }
@@ -2262,7 +2289,7 @@ png_do_write_interlace(png_row_infop row_info, png_bytep row, int pass)
                if (shift == 0)
                {
                   shift = 4;
-                  *dp++ = (png_byte)d;
+                  *dp++ = png_check_byte(0/*TODO: fixme*/, d);
                   d = 0;
                }
 
@@ -2270,7 +2297,7 @@ png_do_write_interlace(png_row_infop row_info, png_bytep row, int pass)
                   shift -= 4;
             }
             if (shift != 4)
-               *dp = (png_byte)d;
+               *dp = png_check_byte(0/*TODO: fixme*/, d);
 
             break;
          }
@@ -2318,7 +2345,6 @@ png_do_write_interlace(png_row_infop row_info, png_bytep row, int pass)
 }
 #endif
 
-
 /* This filters the row, chooses which filter to use, if it has not already
  * been specified by the application, and then writes the row out with the
  * chosen filter.
@@ -2470,6 +2496,7 @@ png_setup_paeth_row(png_structrp png_ptr, const png_uint_32 bpp,
 
    return (sum);
 }
+
 #endif /* WRITE_FILTER */
 
 void /* PRIVATE */
@@ -2568,7 +2595,6 @@ png_write_find_filter(png_structrp png_ptr, png_row_infop row_info)
    {
       png_size_t sum;
       png_size_t lmins = mins;
-
       sum = png_setup_sub_row(png_ptr, bpp, row_bytes, lmins); 
 
       if (sum < mins)
@@ -2594,7 +2620,6 @@ png_write_find_filter(png_structrp png_ptr, png_row_infop row_info)
    {
       png_size_t sum;
       png_size_t lmins = mins;
-
       sum = png_setup_up_row(png_ptr, row_bytes, lmins); 
 
       if (sum < mins)
@@ -2663,7 +2688,6 @@ png_write_find_filter(png_structrp png_ptr, png_row_infop row_info)
 
    /* Do the actual writing of the filtered row data from the chosen filter. */
    png_write_filtered_row(png_ptr, best_row, row_info->rowbytes+1);
-
 #endif /* WRITE_FILTER */
 }
 

projects/visualc71/libpng.vcproj

@@ -30,7 +30,7 @@
 				Name="VCCustomBuildTool"/>
 			<Tool
 				Name="VCLinkerTool"
-				OutputFile="$(OutDir)/libpng16.dll"
+				OutputFile="$(OutDir)/libpng17.dll"
 				LinkIncremental="1"/>
 			<Tool
 				Name="VCMIDLTool"/>
@@ -78,7 +78,7 @@
 				Name="VCCustomBuildTool"/>
 			<Tool
 				Name="VCLinkerTool"
-				OutputFile="$(OutDir)/libpng16d.dll"
+				OutputFile="$(OutDir)/libpng17d.dll"
 				GenerateDebugInformation="TRUE"/>
 			<Tool
 				Name="VCMIDLTool"/>
@@ -126,7 +126,7 @@
 				Name="VCCustomBuildTool"/>
 			<Tool
 				Name="VCLinkerTool"
-				OutputFile="$(OutDir)/libpng16vb.dll"
+				OutputFile="$(OutDir)/libpng17vb.dll"
 				LinkIncremental="1"/>
 			<Tool
 				Name="VCMIDLTool"/>

projects/visualc71/pngtest.vcproj

@@ -130,7 +130,7 @@ $(TargetPath) ..\..\pngtest.png $(IntDir)\pngout.png"
 				Name="VCLinkerTool"
 				OutputFile="$(OutDir)/pngtest.exe"
 				LinkIncremental="1"
-				IgnoreDefaultLibraryNames="$(IntDir)\libpng16b.lib"
+				IgnoreDefaultLibraryNames="$(IntDir)\libpng17b.lib"
 				SubSystem="1"
 				TargetMachine="1"/>
 			<Tool

projects/vstudio/libpng/libpng.vcxproj

@@ -63,23 +63,23 @@
     <LinkIncremental>false</LinkIncremental>
     <CustomBuildBeforeTargets>
     </CustomBuildBeforeTargets>
-    <TargetName>$(ProjectName)16</TargetName>
+    <TargetName>$(ProjectName)17</TargetName>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug Library|Win32'">
     <LinkIncremental>false</LinkIncremental>
     <CustomBuildBeforeTargets />
-    <TargetName>$(ProjectName)16</TargetName>
+    <TargetName>$(ProjectName)17</TargetName>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
     <LinkIncremental>false</LinkIncremental>
     <CustomBuildBeforeTargets>
     </CustomBuildBeforeTargets>
-    <TargetName>$(ProjectName)16</TargetName>
+    <TargetName>$(ProjectName)17</TargetName>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release Library|Win32'">
     <LinkIncremental>false</LinkIncremental>
     <CustomBuildBeforeTargets />
-    <TargetName>$(ProjectName)16</TargetName>
+    <TargetName>$(ProjectName)17</TargetName>
   </PropertyGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
     <ClCompile>
@@ -107,7 +107,7 @@
       <SubSystem>Windows</SubSystem>
       <GenerateDebugInformation>true</GenerateDebugInformation>
       <AdditionalDependencies>zlib.lib</AdditionalDependencies>
-      <Version>16</Version>
+      <Version>17</Version>
       <AdditionalLibraryDirectories>$(OutDir)</AdditionalLibraryDirectories>
     </Link>
   </ItemDefinitionGroup>
@@ -164,7 +164,7 @@
       <EnableCOMDATFolding>true</EnableCOMDATFolding>
       <OptimizeReferences>true</OptimizeReferences>
       <AdditionalDependencies>zlib.lib</AdditionalDependencies>
-      <Version>16</Version>
+      <Version>17</Version>
       <AdditionalLibraryDirectories>$(OutDir)</AdditionalLibraryDirectories>
     </Link>
   </ItemDefinitionGroup>

projects/vstudio/pngstest/pngstest.vcxproj

@@ -96,7 +96,7 @@
     <Link>
       <SubSystem>Console</SubSystem>
       <GenerateDebugInformation>true</GenerateDebugInformation>
-      <AdditionalDependencies>libpng16.lib</AdditionalDependencies>
+      <AdditionalDependencies>libpng17.lib</AdditionalDependencies>
       <AdditionalLibraryDirectories>$(OutDir)</AdditionalLibraryDirectories>
     </Link>
     <CustomBuildStep>
@@ -129,7 +129,7 @@
     <Link>
       <SubSystem>Console</SubSystem>
       <GenerateDebugInformation>true</GenerateDebugInformation>
-      <AdditionalDependencies>libpng16.lib;zlib.lib</AdditionalDependencies>
+      <AdditionalDependencies>libpng17.lib;zlib.lib</AdditionalDependencies>
       <AdditionalLibraryDirectories>$(OutDir)</AdditionalLibraryDirectories>
     </Link>
     <CustomBuildStep>
@@ -163,7 +163,7 @@
       <GenerateDebugInformation>true</GenerateDebugInformation>
       <EnableCOMDATFolding>true</EnableCOMDATFolding>
       <OptimizeReferences>true</OptimizeReferences>
-      <AdditionalDependencies>libpng16.lib</AdditionalDependencies>
+      <AdditionalDependencies>libpng17.lib</AdditionalDependencies>
       <AdditionalLibraryDirectories>$(OutDir)</AdditionalLibraryDirectories>
       <LinkTimeCodeGeneration>UseLinkTimeCodeGeneration</LinkTimeCodeGeneration>
     </Link>
@@ -199,7 +199,7 @@
       <GenerateDebugInformation>true</GenerateDebugInformation>
       <EnableCOMDATFolding>true</EnableCOMDATFolding>
       <OptimizeReferences>true</OptimizeReferences>
-      <AdditionalDependencies>libpng16.lib;zlib.lib</AdditionalDependencies>
+      <AdditionalDependencies>libpng17.lib;zlib.lib</AdditionalDependencies>
       <AdditionalLibraryDirectories>$(OutDir)</AdditionalLibraryDirectories>
       <LinkTimeCodeGeneration>UseLinkTimeCodeGeneration</LinkTimeCodeGeneration>
     </Link>

projects/vstudio/pngtest/pngtest.vcxproj

@@ -96,7 +96,7 @@
     <Link>
       <SubSystem>Console</SubSystem>
       <GenerateDebugInformation>true</GenerateDebugInformation>
-      <AdditionalDependencies>libpng16.lib</AdditionalDependencies>
+      <AdditionalDependencies>libpng17.lib</AdditionalDependencies>
       <AdditionalLibraryDirectories>$(OutDir)</AdditionalLibraryDirectories>
     </Link>
     <CustomBuildStep>
@@ -129,7 +129,7 @@
     <Link>
       <SubSystem>Console</SubSystem>
       <GenerateDebugInformation>true</GenerateDebugInformation>
-      <AdditionalDependencies>libpng16.lib;zlib.lib</AdditionalDependencies>
+      <AdditionalDependencies>libpng17.lib;zlib.lib</AdditionalDependencies>
       <AdditionalLibraryDirectories>$(OutDir)</AdditionalLibraryDirectories>
     </Link>
     <CustomBuildStep>
@@ -164,7 +164,7 @@
       <EnableCOMDATFolding>true</EnableCOMDATFolding>
       <OptimizeReferences>true</OptimizeReferences>
       <LinkTimeCodeGeneration>UseLinkTimeCodeGeneration</LinkTimeCodeGeneration>
-      <AdditionalDependencies>libpng16.lib</AdditionalDependencies>
+      <AdditionalDependencies>libpng17.lib</AdditionalDependencies>
       <AdditionalLibraryDirectories>$(OutDir)</AdditionalLibraryDirectories>
     </Link>
     <CustomBuildStep>
@@ -199,7 +199,7 @@
       <GenerateDebugInformation>true</GenerateDebugInformation>
       <EnableCOMDATFolding>true</EnableCOMDATFolding>
       <OptimizeReferences>true</OptimizeReferences>
-      <AdditionalDependencies>libpng16.lib;zlib.lib</AdditionalDependencies>
+      <AdditionalDependencies>libpng17.lib;zlib.lib</AdditionalDependencies>
       <LinkTimeCodeGeneration>UseLinkTimeCodeGeneration</LinkTimeCodeGeneration>
       <AdditionalLibraryDirectories>$(OutDir)</AdditionalLibraryDirectories>
     </Link>

projects/vstudio/pngunknown/pngunknown.vcxproj

@@ -96,7 +96,7 @@
     <Link>
       <SubSystem>Console</SubSystem>
       <GenerateDebugInformation>true</GenerateDebugInformation>
-      <AdditionalDependencies>libpng16.lib</AdditionalDependencies>
+      <AdditionalDependencies>libpng17.lib</AdditionalDependencies>
       <AdditionalLibraryDirectories>$(OutDir)</AdditionalLibraryDirectories>
     </Link>
     <CustomBuildStep>
@@ -129,7 +129,7 @@
     <Link>
       <SubSystem>Console</SubSystem>
       <GenerateDebugInformation>true</GenerateDebugInformation>
-      <AdditionalDependencies>libpng16.lib;zlib.lib</AdditionalDependencies>
+      <AdditionalDependencies>libpng17.lib;zlib.lib</AdditionalDependencies>
       <AdditionalLibraryDirectories>$(OutDir)</AdditionalLibraryDirectories>
     </Link>
     <CustomBuildStep>
@@ -163,7 +163,7 @@
       <GenerateDebugInformation>true</GenerateDebugInformation>
       <EnableCOMDATFolding>true</EnableCOMDATFolding>
       <OptimizeReferences>true</OptimizeReferences>
-      <AdditionalDependencies>libpng16.lib</AdditionalDependencies>
+      <AdditionalDependencies>libpng17.lib</AdditionalDependencies>
       <AdditionalLibraryDirectories>$(OutDir)</AdditionalLibraryDirectories>
       <LinkTimeCodeGeneration>UseLinkTimeCodeGeneration</LinkTimeCodeGeneration>
     </Link>
@@ -199,7 +199,7 @@
       <GenerateDebugInformation>true</GenerateDebugInformation>
       <EnableCOMDATFolding>true</EnableCOMDATFolding>
       <OptimizeReferences>true</OptimizeReferences>
-      <AdditionalDependencies>libpng16.lib;zlib.lib</AdditionalDependencies>
+      <AdditionalDependencies>libpng17.lib;zlib.lib</AdditionalDependencies>
       <AdditionalLibraryDirectories>$(OutDir)</AdditionalLibraryDirectories>
       <LinkTimeCodeGeneration>UseLinkTimeCodeGeneration</LinkTimeCodeGeneration>
     </Link>

projects/vstudio/pngvalid/pngvalid.vcxproj

@@ -96,7 +96,7 @@
     <Link>
       <SubSystem>Console</SubSystem>
       <GenerateDebugInformation>true</GenerateDebugInformation>
-      <AdditionalDependencies>libpng16.lib;zlib.lib</AdditionalDependencies>
+      <AdditionalDependencies>libpng17.lib;zlib.lib</AdditionalDependencies>
       <AdditionalLibraryDirectories>$(OutDir)</AdditionalLibraryDirectories>
     </Link>
     <CustomBuildStep>
@@ -129,7 +129,7 @@
     <Link>
       <SubSystem>Console</SubSystem>
       <GenerateDebugInformation>true</GenerateDebugInformation>
-      <AdditionalDependencies>libpng16.lib;zlib.lib</AdditionalDependencies>
+      <AdditionalDependencies>libpng17.lib;zlib.lib</AdditionalDependencies>
       <AdditionalLibraryDirectories>$(OutDir)</AdditionalLibraryDirectories>
     </Link>
     <CustomBuildStep>
@@ -163,7 +163,7 @@
       <GenerateDebugInformation>true</GenerateDebugInformation>
       <EnableCOMDATFolding>true</EnableCOMDATFolding>
       <OptimizeReferences>true</OptimizeReferences>
-      <AdditionalDependencies>libpng16.lib;zlib.lib</AdditionalDependencies>
+      <AdditionalDependencies>libpng17.lib;zlib.lib</AdditionalDependencies>
       <AdditionalLibraryDirectories>$(OutDir)</AdditionalLibraryDirectories>
       <LinkTimeCodeGeneration>UseLinkTimeCodeGeneration</LinkTimeCodeGeneration>
     </Link>
@@ -199,7 +199,7 @@
       <GenerateDebugInformation>true</GenerateDebugInformation>
       <EnableCOMDATFolding>true</EnableCOMDATFolding>
       <OptimizeReferences>true</OptimizeReferences>
-      <AdditionalDependencies>libpng16.lib;zlib.lib</AdditionalDependencies>
+      <AdditionalDependencies>libpng17.lib;zlib.lib</AdditionalDependencies>
       <AdditionalLibraryDirectories>$(OutDir)</AdditionalLibraryDirectories>
       <LinkTimeCodeGeneration>UseLinkTimeCodeGeneration</LinkTimeCodeGeneration>
     </Link>

projects/vstudio/readme.txt

@@ -1,7 +1,7 @@
 
 VisualStudio instructions
 
-libpng version 1.6.18rc02 - July 12, 2015
+libpng version 1.7.0beta64 - July 26, 2015
 
 Copyright (c) 1998-2010 Glenn Randers-Pehrson
 
@@ -40,7 +40,7 @@ problems.
 
 If you don't use the Visual Studio defaults your application must still be built
 with the default runtime option (/MD).  If, for some reason, it is not then your
-application will crash inside libpng16.dll as soon as libpng tries to read
+application will crash inside libpng17.dll as soon as libpng tries to read
 from a file handle you pass in.
 
 If you do not want to use the DLL, for example for a very small application,

projects/vstudio/zlib.props

@@ -2,7 +2,7 @@
 <!--
  * zlib.props - location of zlib source
  *
- * libpng version 1.6.18rc02 - July 12, 2015
+ * libpng version 1.7.0beta64 - July 26, 2015
  *
  * Copyright (c) 1998-2011 Glenn Randers-Pehrson
  *

scripts/README.txt

@@ -1,9 +1,9 @@
 
-Makefiles for  libpng version 1.6.18rc02 - July 12, 2015
+Makefiles for  libpng version 1.7.0beta64 - July 26, 2015
 
 pnglibconf.h.prebuilt       =>  Stores configuration settings
  makefile.linux    =>  Linux/ELF makefile
-                       (gcc, creates libpng16.so.16.1.6.18rc02)
+                       (gcc, creates libpng17.so.17.1.7.0beta64)
  makefile.gcc      =>  Generic makefile (gcc, creates static libpng.a)
  makefile.knr      =>  Archaic UNIX Makefile that converts files with
                        ansi2knr (Requires ansi2knr.c from
@@ -33,12 +33,12 @@ pnglibconf.h.prebuilt       =>  Stores configuration settings
  makefile.os2      =>  OS/2 Makefile (gcc and emx, requires libpng.def)
  makefile.sco      =>  For SCO OSr5  ELF and Unixware 7 with Native cc
  makefile.sggcc    =>  Silicon Graphics (gcc,
-                       creates libpng16.so.16.1.6.18rc02)
+                       creates libpng17.so.17.1.7.0beta64)
  makefile.sgi      =>  Silicon Graphics IRIX makefile (cc, creates static lib)
  makefile.solaris  =>  Solaris 2.X makefile (gcc,
-                       creates libpng16.so.16.1.6.18rc02)
+                       creates libpng17.so.17.1.7.0beta64)
  makefile.so9      =>  Solaris 9 makefile (gcc,
-                       creates libpng16.so.16.1.6.18rc02)
+                       creates libpng17.so.17.1.7.0beta64)
  makefile.std      =>  Generic UNIX makefile (cc, creates static libpng.a)
  makefile.sunos    =>  Sun makefile
  makefile.32sunu   =>  Sun Ultra 32-bit makefile

scripts/def.c

@@ -1,6 +1,6 @@
 /* def.c - define format of libpng.def
  *
- * Last changed in libpng version 1.6.16 [December 22, 2014]
+ * Last changed in libpng 1.6.16 [December 22, 2014]
  * Copyright (c) 2011-2014 Glenn Randers-Pehrson
  *
  * This code is released under the libpng license.
@@ -21,7 +21,7 @@ PNG_DFN "OS2 DESCRIPTION "PNG image compression library""
 PNG_DFN "OS2 CODE PRELOAD MOVEABLE DISCARDABLE"
 PNG_DFN ""
 PNG_DFN "EXPORTS"
-PNG_DFN ";Version 1.6.18rc02"
+PNG_DFN ";Version 1.7.0beta64"
 
 #define PNG_EXPORTA(ordinal, type, name, args, attributes)\
         PNG_DFN "@" SYMBOL_PREFIX "@@" name "@"

scripts/descrip.mms

@@ -33,20 +33,20 @@ clean :
 
 
 # Other dependencies.
-png.obj : png.h, pngconf.h, pnglibconf.h, pngpriv.h, pngstruct.h,pnginfo.h, pngdebug.h
-pngpread.obj : png.h, pngconf.h, pnglibconf.h, pngpriv.h, pngstruct.h,pnginfo.h, pngdebug.h
-pngset.obj : png.h, pngconf.h, pnglibconf.h, pngpriv.h, pngstruct.h,pnginfo.h, pngdebug.h
-pngget.obj : png.h, pngconf.h, pnglibconf.h, pngpriv.h, pngstruct.h,pnginfo.h, pngdebug.h
-pngread.obj : png.h, pngconf.h, pnglibconf.h, pngpriv.h, pngstruct.h,pnginfo.h, pngdebug.h
-pngrtran.obj : png.h, pngconf.h, pnglibconf.h, pngpriv.h, pngstruct.h,pnginfo.h, pngdebug.h
-pngrutil.obj : png.h, pngconf.h, pnglibconf.h, pngpriv.h, pngstruct.h,pnginfo.h, pngdebug.h
-pngerror.obj : png.h, pngconf.h, pnglibconf.h, pngpriv.h, pngstruct.h,pnginfo.h, pngdebug.h
-pngmem.obj : png.h, pngconf.h, pnglibconf.h, pngpriv.h, pngstruct.h,pnginfo.h, pngdebug.h
-pngrio.obj : png.h, pngconf.h, pnglibconf.h, pngpriv.h, pngstruct.h,pnginfo.h, pngdebug.h
-pngwio.obj : png.h, pngconf.h, pnglibconf.h, pngpriv.h, pngstruct.h,pnginfo.h, pngdebug.h
-pngtrans.obj : png.h, pngconf.h, pnglibconf.h, pngpriv.h, pngstruct.h,pnginfo.h, pngdebug.h
-pngwrite.obj : png.h, pngconf.h, pnglibconf.h, pngpriv.h, pngstruct.h,pnginfo.h, pngdebug.h
-pngwtran.obj : png.h, pngconf.h, pnglibconf.h, pngpriv.h, pngstruct.h,pnginfo.h, pngdebug.h
-pngwutil.obj : png.h, pngconf.h, pnglibconf.h, pngpriv.h, pngstruct.h,pnginfo.h, pngdebug.h
+png.obj : png.h, pngconf.h, pnglibconf.h, pngpriv.h, pngstruct.h, pnginfo.h, pngdebug.h
+pngpread.obj : png.h, pngconf.h, pnglibconf.h, pngpriv.h, pngstruct.h, pnginfo.h, pngdebug.h
+pngset.obj : png.h, pngconf.h, pnglibconf.h, pngpriv.h, pngstruct.h, pnginfo.h, pngdebug.h
+pngget.obj : png.h, pngconf.h, pnglibconf.h, pngpriv.h, pngstruct.h, pnginfo.h, pngdebug.h
+pngread.obj : png.h, pngconf.h, pnglibconf.h, pngpriv.h, pngstruct.h, pnginfo.h, pngdebug.h
+pngrtran.obj : png.h, pngconf.h, pnglibconf.h, pngpriv.h, pngstruct.h, pnginfo.h, pngdebug.h
+pngrutil.obj : png.h, pngconf.h, pnglibconf.h, pngpriv.h, pngstruct.h, pnginfo.h, pngdebug.h
+pngerror.obj : png.h, pngconf.h, pnglibconf.h, pngpriv.h, pngstruct.h, pnginfo.h, pngdebug.h
+pngmem.obj : png.h, pngconf.h, pnglibconf.h, pngpriv.h, pngstruct.h, pnginfo.h, pngdebug.h
+pngrio.obj : png.h, pngconf.h, pnglibconf.h, pngpriv.h, pngstruct.h, pnginfo.h, pngdebug.h
+pngwio.obj : png.h, pngconf.h, pnglibconf.h, pngpriv.h, pngstruct.h, pnginfo.h, pngdebug.h
+pngtrans.obj : png.h, pngconf.h, pnglibconf.h, pngpriv.h, pngstruct.h, pnginfo.h, pngdebug.h
+pngwrite.obj : png.h, pngconf.h, pnglibconf.h, pngpriv.h, pngstruct.h, pnginfo.h, pngdebug.h
+pngwtran.obj : png.h, pngconf.h, pnglibconf.h, pngpriv.h, pngstruct.h, pnginfo.h, pngdebug.h
+pngwutil.obj : png.h, pngconf.h, pnglibconf.h, pngpriv.h, pngstruct.h, pnginfo.h, pngdebug.h
 
 pngtest.obj : png.h, pngconf.h, pnglibconf.h

scripts/intprefix.c

@@ -1,7 +1,7 @@
 
 /* intprefix.c - generate an unprefixed internal symbol list
  *
- * Last changed in libpng version 1.6.16 [December 22, 2014]
+ * Last changed in libpng 1.6.16 [December 22, 2014]
  * Copyright (c) 2013-2014 Glenn Randers-Pehrson
  *
  * This code is released under the libpng license.

scripts/libpng-config-head.in

@@ -11,7 +11,7 @@
 
 # Modeled after libxml-config.
 
-version=1.6.18rc02
+version=1.7.0beta64
 prefix=""
 libdir=""
 libs=""

scripts/libpng.pc.in

@@ -1,10 +1,10 @@
 prefix=@prefix@
 exec_prefix=@exec_prefix@
 libdir=@libdir@
-includedir=@includedir@/libpng16
+includedir=@includedir@/libpng17
 
 Name: libpng
 Description: Loads and saves PNG files
-Version: 1.6.18rc02
-Libs: -L${libdir} -lpng16
+Version: 1.7.0beta64
+Libs: -L${libdir} -lpng17
 Cflags: -I${includedir}

scripts/makefile.32sunu

@@ -9,8 +9,8 @@
 # and license in png.h
 
 # Library name:
-LIBNAME=libpng16
-PNGMAJ = 16
+LIBNAME=libpng17
+PNGMAJ = 17
 
 # Shared library names:
 LIBSO=$(LIBNAME).so
@@ -29,7 +29,7 @@ RM_F=/bin/rm -f
 SUN_CC_FLAGS=-fast -xtarget=ultra
 SUN_LD_FLAGS=-fast -xtarget=ultra
 
-# where make install puts libpng.a, libpng16.so and libpng16/png.h
+# where make install puts libpng.a, libpng17.so and libpng17/png.h
 prefix=/a
 exec_prefix=$(prefix)
 
@@ -98,7 +98,7 @@ libpng.pc:
 	-e s!@exec_prefix@!$(exec_prefix)! \
 	-e s!@libdir@!$(LIBPATH)! \
 	-e s!@includedir@!$(INCPATH)! \
-	-e s!-lpng16!-lpng16\ -lz\ -lm! > libpng.pc
+	-e s!-lpng17!-lpng17\ -lz\ -lm! > libpng.pc
 
 libpng-config:
 	( cat scripts/libpng-config-head.in; \
@@ -109,7 +109,7 @@ libpng-config:
 	echo R_opts=\"-R$(LIBPATH)\"; \
 	echo ccopts=\"-fast -xtarget=ultra\"; \
 	echo ldopts=\"-fast -xtarget=ultra\"; \
-	echo libs=\"-lpng16 -lz -lm\"; \
+	echo libs=\"-lpng17 -lz -lm\"; \
 	cat scripts/libpng-config-body.in ) > libpng-config
 	chmod +x libpng-config
 

scripts/makefile.64sunu

@@ -9,8 +9,8 @@
 # and license in png.h
 
 # Library name:
-LIBNAME=libpng16
-PNGMAJ = 16
+LIBNAME=libpng17
+PNGMAJ = 17
 
 # Shared library names:
 LIBSO=$(LIBNAME).so
@@ -29,7 +29,7 @@ RM_F=/bin/rm -f
 SUN_CC_FLAGS=-fast -xtarget=ultra -xarch=v9
 SUN_LD_FLAGS=-fast -xtarget=ultra -xarch=v9
 
-# where make install puts libpng.a, libpng16.so and libpng16/png.h
+# where make install puts libpng.a, libpng17.so and libpng17/png.h
 prefix=/a
 exec_prefix=$(prefix)
 
@@ -47,7 +47,7 @@ WARNMORE=-Wwrite-strings -Wpointer-arith -Wshadow \
 	-Wstrict-prototypes -Wmissing-prototypes #-Wconversion
 CPPFLAGS=-I$(ZLIBINC) # -DPNG_DEBUG=5
 CFLAGS= $(SUN_CC_FLAGS) # $(WARNMORE) -g
-LDFLAGS=-L. -R. $(SUN_LD_FLAGS) -L$(ZLIBLIB) -R$(ZLIBLIB) -lpng16 -lz -lm
+LDFLAGS=-L. -R. $(SUN_LD_FLAGS) -L$(ZLIBLIB) -R$(ZLIBLIB) -lpng17 -lz -lm
 
 INCPATH=$(prefix)/include
 LIBPATH=$(exec_prefix)/lib
@@ -98,7 +98,7 @@ libpng.pc:
 	-e s!@exec_prefix@!$(exec_prefix)! \
 	-e s!@libdir@!$(LIBPATH)! \
 	-e s!@includedir@!$(INCPATH)! \
-	-e s!-lpng16!-lpng16\ -lz\ -lm! > libpng.pc
+	-e s!-lpng17!-lpng17\ -lz\ -lm! > libpng.pc
 
 libpng-config:
 	( cat scripts/libpng-config-head.in; \
@@ -109,7 +109,7 @@ libpng-config:
 	echo R_opts=\"-R$(LIBPATH)\"; \
 	echo ccopts=\"-fast -xtarget=ultra -xarch=v9\"; \
 	echo ldopts=\"-fast -xtarget=ultra -xarch=v9\"; \
-	echo libs=\"-lpng16 -lz -lm\"; \
+	echo libs=\"-lpng17 -lz -lm\"; \
 	cat scripts/libpng-config-body.in ) > libpng-config
 	chmod +x libpng-config
 

scripts/makefile.aix

@@ -21,8 +21,8 @@ RANLIB = ranlib
 RM_F = rm -f
 LN_SF = ln -f -s
 
-LIBNAME = libpng16
-PNGMAJ = 16
+LIBNAME = libpng17
+PNGMAJ = 17
 
 prefix=/usr/local
 INCPATH=$(prefix)/include
@@ -44,7 +44,7 @@ DL=$(DESTDIR)$(LIBPATH)
 WARNMORE =
 CPPFLAGS = -I$(ZLIBINC) # -DPNG_DEBUG=5
 CFLAGS = -W -Wall -O2 # $(WARNMORE) -g
-LDFLAGS = -L. -L$(ZLIBLIB) -lpng16 -lz -lm
+LDFLAGS = -L. -L$(ZLIBLIB) -lpng17 -lz -lm
 
 # Variables
 OBJS =  png.o pngerror.o pngget.o pngmem.o pngpread.o \

scripts/makefile.beos

@@ -9,8 +9,8 @@
 # and license in png.h
 
 # Library name:
-LIBNAME=libpng16
-PNGMAJ = 16
+LIBNAME=libpng17
+PNGMAJ = 17
 
 # Shared library names:
 LIBSO=$(LIBNAME).so
@@ -46,7 +46,7 @@ CFLAGS=-W -Wall -O1 -funroll-loops $(ALIGN) # $(WARNMORE) -g
 # LDFLAGS=-L. -Wl,-rpath,. -L$(ZLIBLIB) -Wl,-rpath,$(ZLIBLIB) -lpng -lz
 LDFLAGS=-L. -Wl,-soname=$(LIBSOMAJ) -L$(ZLIBLIB) -lz
 
-# where make install puts libpng.a, libpng16.so*, and png.h
+# where make install puts libpng.a, libpng17.so*, and png.h
 prefix=/usr/local
 exec_prefix=$(prefix)
 INCPATH=$(prefix)/include
@@ -98,13 +98,13 @@ libpng.pc:
 	-e s!@exec_prefix@!$(exec_prefix)! \
 	-e s!@libdir@!$(LIBPATH)! \
 	-e s!@includedir@!$(INCPATH)! \
-	-e s!-lpng16!-lpng16\ -lz\ -lm! > libpng.pc
+	-e s!-lpng17!-lpng17\ -lz\ -lm! > libpng.pc
 
 libpng-config:
 	( cat scripts/libpng-config-head.in; \
 	echo prefix=\"$(prefix)\"; \
 	echo I_opts=\"-I$(INCPATH)/$(LIBNAME)\"; \
-	echo libs=\"-lpng16 -lz \"; \
+	echo libs=\"-lpng17 -lz \"; \
 	cat scripts/libpng-config-body.in ) > libpng-config
 	chmod +x libpng-config
 
@@ -117,7 +117,7 @@ $(LIBSOMAJ): $(OBJSDLL)
 	$(LIBSOMAJ) $(OBJSDLL) $(LDFLAGS)
 
 pngtest: pngtest.o $(LIBSO)
-	$(CC) -L$(ZLIBLIB) -L. -lz -lpng16 -o pngtest pngtest.o
+	$(CC) -L$(ZLIBLIB) -L. -lz -lpng17 -o pngtest pngtest.o
 
 test: pngtest
 	./pngtest

scripts/makefile.cegcc

@@ -22,16 +22,16 @@
 # make clean
 
 VERMAJ = 1
-VERMIN = 6
-VERMIC = 18
+VERMIN = 7
+VERMIC = 0
 VER = $(VERMAJ).$(VERMIN).$(VERMIC)
 NAME = libpng
 PACKAGE = $(NAME)-$(VER)
 
-BIN = libpng16-0.dll
-LIB = libpng16.a libpng16.dll.a libpng.a libpng.dll.a
+BIN = libpng17-0.dll
+LIB = libpng17.a libpng17.dll.a libpng.a libpng.dll.a
 INCLUDE = png.h pngconf.h pnglibconf.h pngpriv.h pngstruct.h pnginfo.h pngdebug.h
-PC = libpng16.pc libpng.pc
+PC = libpng17.pc libpng.pc
 
 MANIFESTVERBIN = "Libpng-$(VER): Binary files"
 MANIFESTVERDEV = "Libpng-$(VER): Developer files"

scripts/makefile.darwin

@@ -9,7 +9,7 @@
 # For conditions of distribution and use, see the disclaimer
 # and license in png.h
 
-# where "make install" puts libpng.a, libpng16.dylib, png.h, pngconf.h,
+# where "make install" puts libpng.a, libpng17.dylib, png.h, pngconf.h,
 # and pnglibconf.h
 prefix=/usr/local
 exec_prefix=$(prefix)
@@ -19,8 +19,8 @@ ZLIBLIB=/usr/lib
 ZLIBINC=/usr/include
 
 # Library name:
-LIBNAME = libpng16
-PNGMAJ = 16
+LIBNAME = libpng17
+PNGMAJ = 17
 
 # Shared library names:
 LIBSO=$(LIBNAME).dylib
@@ -40,7 +40,7 @@ RM_F=/bin/rm -f
 CPPFLAGS=-I$(ZLIBINC)
 # CFLAGS=-W -Wall -O3 -funroll-loops
 CFLAGS=-W -Wall -O -funroll-loops
-LDFLAGS=-L. -L$(ZLIBLIB) -lpng16 -lz
+LDFLAGS=-L. -L$(ZLIBLIB) -lpng17 -lz
 
 INCPATH=$(prefix)/include
 LIBPATH=$(exec_prefix)/lib
@@ -94,14 +94,14 @@ libpng.pc:
 	-e s!@exec_prefix@!$(exec_prefix)! \
 	-e s!@libdir@!$(LIBPATH)! \
 	-e s!@includedir@!$(INCPATH)! \
-	-e s!-lpng16!-lpng16\ -lz! > libpng.pc
+	-e s!-lpng17!-lpng17\ -lz! > libpng.pc
 
 libpng-config:
 	( cat scripts/libpng-config-head.in; \
 	echo prefix=\"$(prefix)\"; \
 	echo I_opts=\"-I$(INCPATH)/$(LIBNAME)\"; \
 	echo L_opts=\"-L$(LIBPATH)\"; \
-	echo libs=\"-lpng16 -lz\"; \
+	echo libs=\"-lpng17 -lz\"; \
 	cat scripts/libpng-config-body.in ) > libpng-config
 	chmod +x libpng-config
 
@@ -111,7 +111,7 @@ $(LIBSO): $(LIBSOMAJ)
 $(LIBSOMAJ): $(OBJSDLL)
 	$(CC) -dynamiclib \
 	 -install_name $(LIBPATH)/$(LIBSOMAJ) \
-	 -current_version 16 -compatibility_version 16 \
+	 -current_version 17 -compatibility_version 17 \
 	 -o $(LIBSOMAJ) \
 	 $(OBJSDLL) -L$(ZLIBLIB) -lz
 

scripts/makefile.dec

@@ -7,8 +7,8 @@
 # and license in png.h
 
 # Library name:
-PNGMAJ = 16
-LIBNAME = libpng16
+PNGMAJ = 17
+LIBNAME = libpng17
 
 # Shared library names:
 LIBSO=$(LIBNAME).so
@@ -83,7 +83,7 @@ libpng.pc:
 	-e s!@exec_prefix@!$(exec_prefix)! \
 	-e s!@libdir@!$(LIBPATH)! \
 	-e s!@includedir@!$(INCPATH)! \
-	-e s!-lpng16!-lpng16\ -lz\ -lm! > libpng.pc
+	-e s!-lpng17!-lpng17\ -lz\ -lm! > libpng.pc
 
 libpng-config:
 	( cat scripts/libpng-config-head.in; \
@@ -91,7 +91,7 @@ libpng-config:
 	echo I_opts=\"-I$(INCPATH)/$(LIBNAME)\"; \
 	echo ccopts=\"-std\"; \
 	echo L_opts=\"-L$(LIBPATH)\"; \
-	echo libs=\"-lpng16 -lz -lm\"; \
+	echo libs=\"-lpng17 -lz -lm\"; \
 	cat scripts/libpng-config-body.in ) > libpng-config
 	chmod +x libpng-config
 

scripts/makefile.freebsd

@@ -7,7 +7,7 @@
 # and license in png.h
 
 PREFIX?=        /usr/local
-SHLIB_VER?=     16
+SHLIB_VER?=     17
 
 LIB=		png
 SHLIB_MAJOR=	${SHLIB_VER}

scripts/makefile.hp64

@@ -19,8 +19,8 @@ ZLIBINC=/opt/zlib/include
 #   SHAREDLIB=libz.sl
 
 # Library name:
-LIBNAME = libpng16
-PNGMAJ = 16
+LIBNAME = libpng17
+PNGMAJ = 17
 
 # Shared library names:
 LIBSO=$(LIBNAME).sl
@@ -45,7 +45,7 @@ CCFLAGS=-O -Ae -Wl,+vnocompatwarnings +DD64 +Z
 
 LDFLAGS=-L. -L$(ZLIBLIB) -lpng -lz -lm
 
-# where make install puts libpng.a, libpng16.sl, and png.h
+# where make install puts libpng.a, libpng17.sl, and png.h
 prefix=/opt/libpng
 exec_prefix=$(prefix)
 INCPATH=$(prefix)/include
@@ -100,7 +100,7 @@ libpng.pc:
 	-e s!@exec_prefix@!$(exec_prefix)! \
 	-e s!@libdir@!$(LIBPATH)! \
 	-e s!@includedir@!$(INCPATH)! \
-	-e s!-lpng16!-lpng16\ -lz\ -lm! > libpng.pc
+	-e s!-lpng17!-lpng17\ -lz\ -lm! > libpng.pc
 
 libpng-config:
 	( cat scripts/libpng-config-head.in; \
@@ -108,7 +108,7 @@ libpng-config:
 	echo I_opts=\"-I$(INCPATH)/$(LIBNAME)\"; \
 	echo ccopts=\"-O -Ae -Wl,+vnocompatwarnings +DD64 +Z\"; \
 	echo L_opts=\"-L$(LIBPATH)\"; \
-	echo libs=\"-lpng16 -lz -lm\"; \
+	echo libs=\"-lpng17 -lz -lm\"; \
 	cat scripts/libpng-config-body.in ) > libpng-config
 	chmod +x libpng-config
 

scripts/makefile.hpgcc

@@ -9,8 +9,8 @@
 # and license in png.h
 
 # Library name:
-LIBNAME = libpng16
-PNGMAJ = 16
+LIBNAME = libpng17
+PNGMAJ = 17
 
 # Shared library names:
 LIBSO=$(LIBNAME).sl
@@ -56,8 +56,8 @@ WARNMORE=-Wwrite-strings -Wpointer-arith -Wshadow \
 
 CPPFLAGS=-I$(ZLIBINC) # -DPNG_DEBUG=5
 CFLAGS=-W -Wall -O3 -funroll-loops $(ALIGN) # $(WARNMORE) -g
-#LDFLAGS=-L. -Wl,-rpath,. -L$(ZLIBLIB) -Wl,-rpath,$(ZLIBLIB) -lpng16 -lz -lm
-LDFLAGS=-L. -L$(ZLIBLIB) -lpng16 -lz -lm
+#LDFLAGS=-L. -Wl,-rpath,. -L$(ZLIBLIB) -Wl,-rpath,$(ZLIBLIB) -lpng17 -lz -lm
+LDFLAGS=-L. -L$(ZLIBLIB) -lpng17 -lz -lm
 
 INCPATH=$(prefix)/include
 LIBPATH=$(exec_prefix)/lib
@@ -104,13 +104,13 @@ libpng.pc:
 	-e s!@exec_prefix@!$(exec_prefix)! \
 	-e s!@libdir@!$(LIBPATH)! \
 	-e s!@includedir@!$(INCPATH)! \
-	-e s!-lpng16!-lpng16\ -lz\ -lm! > libpng.pc
+	-e s!-lpng17!-lpng17\ -lz\ -lm! > libpng.pc
 
 libpng-config:
 	( cat scripts/libpng-config-head.in; \
 	echo prefix=\"$(prefix)\"; \
 	echo I_opts=\"-I$(INCPATH)/$(LIBNAME)\"; \
-	echo libs=\"-lpng16 -lz -lm\"; \
+	echo libs=\"-lpng17 -lz -lm\"; \
 	cat scripts/libpng-config-body.in ) > libpng-config
 	chmod +x libpng-config
 

scripts/makefile.hpux

@@ -20,8 +20,8 @@ ZLIBINC=/opt/zlib/include
 #   SHAREDLIB=libz.sl
 
 # Library name:
-LIBNAME = libpng16
-PNGMAJ = 16
+LIBNAME = libpng17
+PNGMAJ = 17
 
 # Shared library names:
 LIBSO=$(LIBNAME).sl
@@ -37,7 +37,7 @@ LN_SF=ln -sf
 RANLIB=ranlib
 RM_F=/bin/rm -f
 
-# where make install puts libpng.a, libpng16.sl, and png.h
+# where make install puts libpng.a, libpng17.sl, and png.h
 prefix=/opt/libpng
 exec_prefix=$(prefix)
 INCPATH=$(prefix)/include
@@ -98,7 +98,7 @@ libpng.pc:
 	-e s!@exec_prefix@!$(exec_prefix)! \
 	-e s!@libdir@!$(LIBPATH)! \
 	-e s!@includedir@!$(INCPATH)! \
-	-e s!-lpng16!-lpng16\ -lz\ -lm! > libpng.pc
+	-e s!-lpng17!-lpng17\ -lz\ -lm! > libpng.pc
 
 libpng-config:
 	( cat scripts/libpng-config-head.in; \
@@ -106,7 +106,7 @@ libpng-config:
 	echo I_opts=\"-I$(INCPATH)/$(LIBNAME)\"; \
 	echo ccopts=\"-O -Ae +DA1.1 +DS2.0\"; \
 	echo L_opts=\"-L$(LIBPATH)\"; \
-	echo libs=\"-lpng16 -lz -lm\"; \
+	echo libs=\"-lpng17 -lz -lm\"; \
 	cat scripts/libpng-config-body.in ) > libpng-config
 	chmod +x libpng-config
 

scripts/makefile.linux

@@ -1,4 +1,4 @@
-# makefile for libpng.a and libpng16.so on Linux ELF with gcc
+# makefile for libpng.a and libpng17.so on Linux ELF with gcc
 # Copyright (C) 1998, 1999, 2002, 2006, 2008, 2010-2014 Greg Roelofs and
 # Glenn Randers-Pehrson
 # Copyright (C) 1996, 1997 Andreas Dilger
@@ -8,9 +8,9 @@
 # and license in png.h
 
 # Library name:
-LIBNAME = libpng16
-PNGMAJ = 16
-RELEASE = 18
+LIBNAME = libpng17
+PNGMAJ = 17
+RELEASE = 0
 
 # Shared library names:
 LIBSO=$(LIBNAME).so
@@ -27,8 +27,8 @@ RANLIB=ranlib
 CP=cp
 RM_F=/bin/rm -f
 
-# where "make install" puts libpng16.a, libpng16.so*,
-# libpng16/png.h, libpng16/pngconf.h, and libpng16/pnglibconf.h
+# where "make install" puts libpng17.a, libpng17.so*,
+# libpng17/png.h, libpng17/pngconf.h, and libpng17/pnglibconf.h
 # Prefix must be a full pathname.
 prefix=/usr/local
 exec_prefix=$(prefix)
@@ -53,7 +53,7 @@ CPPFLAGS=-I$(ZLIBINC) # -DPNG_DEBUG=5
 CFLAGS= -W -Wall -O3 -funroll-loops \
 	$(ALIGN) # $(WARNMORE) -g -DPNG_DEBUG=5
 
-LDFLAGS=-L. -Wl,-rpath,. -L$(ZLIBLIB) -Wl,-rpath,$(ZLIBLIB) -lpng16 -lz -lm
+LDFLAGS=-L. -Wl,-rpath,. -L$(ZLIBLIB) -Wl,-rpath,$(ZLIBLIB) -lpng17 -lz -lm
 LDFLAGS_A=-L$(ZLIBLIB) -Wl,-rpath,$(ZLIBLIB) libpng.a -lz -lm
 
 INCPATH=$(prefix)/include
@@ -108,7 +108,7 @@ libpng.pc:
 	-e s!@exec_prefix@!$(exec_prefix)! \
 	-e s!@libdir@!$(LIBPATH)! \
 	-e s!@includedir@!$(INCPATH)! \
-	-e s!-lpng16!-lpng16\ -lz\ -lm! > libpng.pc
+	-e s!-lpng17!-lpng17\ -lz\ -lm! > libpng.pc
 
 libpng-config:
 	( cat scripts/libpng-config-head.in; \
@@ -116,7 +116,7 @@ libpng-config:
 	echo I_opts=\"-I$(INCPATH)/$(LIBNAME)\"; \
 	echo L_opts=\"-L$(LIBPATH)\"; \
 	echo R_opts=\"-Wl,-rpath,$(LIBPATH)\"; \
-	echo libs=\"-lpng16 -lz -lm\"; \
+	echo libs=\"-lpng17 -lz -lm\"; \
 	cat scripts/libpng-config-body.in ) > libpng-config
 	chmod +x libpng-config
 

scripts/makefile.msys

@@ -16,9 +16,9 @@ prefix=/usr/local
 exec_prefix=$(prefix)
 
 # Library name:
-LIBNAME = libpng16
-PNGMAJ = 16
-RELEASE = 18
+LIBNAME = libpng17
+PNGMAJ = 17
+RELEASE = 0
 
 # Shared library names:
 LIBSO=$(LIBNAME).dll
@@ -126,7 +126,7 @@ libpng.pc:
 	-e s!@exec_prefix@!$(exec_prefix)! \
 	-e s!@libdir@!$(LIBPATH)! \
 	-e s!@includedir@!$(INCPATH)! \
-	-e s!-lpng16!-lpng16\ -lz\ -lm! > libpng.pc
+	-e s!-lpng17!-lpng17\ -lz\ -lm! > libpng.pc
 
 libpng-config:
 	( cat scripts/libpng-config-head.in; \
@@ -134,7 +134,7 @@ libpng-config:
 	echo I_opts=\"-I$(INCPATH)/$(LIBNAME)\"; \
 	echo L_opts=\"-L$(LIBPATH)\"; \
 	echo R_opts=\"-Wl,-rpath,$(LIBPATH)\"; \
-	echo libs=\"-lpng16 -lz -lm\"; \
+	echo libs=\"-lpng17 -lz -lm\"; \
 	cat scripts/libpng-config-body.in ) > libpng-config
 
 install-shared: install-headers $(LIBSOMAJ) libpng.pc

scripts/makefile.ne12bsd

@@ -13,11 +13,11 @@
 LOCALBASE?=/usr/local
 LIBDIR=	${LOCALBASE}/lib
 MANDIR= ${LOCALBASE}/man
-INCSDIR=${LOCALBASE}/include/libpng16
+INCSDIR=${LOCALBASE}/include/libpng17
 
-LIB=	png16
+LIB=	png17
 SHLIB_MAJOR=	0
-SHLIB_MINOR=	1.6.18rc02
+SHLIB_MINOR=	1.7.0beta64
 SRCS=	png.c pngset.c pngget.c pngrutil.c pngtrans.c pngwutil.c \
 	pngread.c pngrio.c pngwio.c pngwrite.c pngrtran.c \
 	pngwtran.c pngmem.c pngerror.c pngpread.c

scripts/makefile.netbsd

@@ -8,7 +8,7 @@
 # For conditions of distribution and use, see the disclaimer
 # and license in png.h
 
-# You should also run makefile.ne16bsd
+# You should also run makefile.ne17bsd
 
 LOCALBASE?=/usr/local
 LIBDIR=	${LOCALBASE}/lib
@@ -16,8 +16,8 @@ MANDIR= ${LOCALBASE}/man
 INCSDIR=${LOCALBASE}/include
 
 LIB=	png
-SHLIB_MAJOR=	16
-SHLIB_MINOR=	1.6.18rc02
+SHLIB_MAJOR=	17
+SHLIB_MINOR=	1.7.0beta64
 SRCS=	png.c pngset.c pngget.c pngrutil.c pngtrans.c pngwutil.c \
 	pngread.c pngrio.c pngwio.c pngwrite.c pngrtran.c \
 	pngwtran.c pngmem.c pngerror.c pngpread.c

scripts/makefile.openbsd

@@ -10,8 +10,8 @@ PREFIX?= /usr/local
 LIBDIR=	${PREFIX}/lib
 MANDIR= ${PREFIX}/man/cat
 
-SHLIB_MAJOR=	16
-SHLIB_MINOR=	1.6.18rc02
+SHLIB_MAJOR=	17
+SHLIB_MINOR=	1.7.0beta64
 
 LIB=	png
 SRCS=	png.c pngerror.c pngget.c pngmem.c pngpread.c \

scripts/makefile.sco

@@ -10,8 +10,8 @@
 # and license in png.h
 
 # Library name:
-LIBNAME = libpng16
-PNGMAJ = 16
+LIBNAME = libpng17
+PNGMAJ = 17
 
 # Shared library names:
 LIBSO=$(LIBNAME).so
@@ -40,7 +40,7 @@ ZLIBINC=../zlib
 
 CPPFLAGS=-I$(ZLIBINC)
 CFLAGS= -dy -belf -O3
-LDFLAGS=-L. -L$(ZLIBLIB) -lpng16 -lz -lm
+LDFLAGS=-L. -L$(ZLIBLIB) -lpng17 -lz -lm
 
 INCPATH=$(prefix)/include
 LIBPATH=$(exec_prefix)/lib
@@ -94,7 +94,7 @@ libpng.pc:
 	-e s!@exec_prefix@!$(exec_prefix)! \
 	-e s!@libdir@!$(LIBPATH)! \
 	-e s!@includedir@!$(INCPATH)! \
-	-e s!-lpng16!-lpng16\ -lz\ -lm! > libpng.pc
+	-e s!-lpng17!-lpng17\ -lz\ -lm! > libpng.pc
 
 libpng-config:
 	( cat scripts/libpng-config-head.in; \
@@ -102,7 +102,7 @@ libpng-config:
 	echo I_opts=\"-I$(INCPATH)/$(LIBNAME)\"; \
 	echo ccopts=\"-belf\"; \
 	echo L_opts=\"-L$(LIBPATH)\"; \
-	echo libs=\"-lpng16 -lz -lm\"; \
+	echo libs=\"-lpng17 -lz -lm\"; \
 	cat scripts/libpng-config-body.in ) > libpng-config
 	chmod +x libpng-config
 

scripts/makefile.sggcc

@@ -1,4 +1,4 @@
-# makefile for libpng.a and libpng16.so, SGI IRIX with 'cc'
+# makefile for libpng.a and libpng17.so, SGI IRIX with 'cc'
 # Copyright (C) 2001-2002, 2006, 2010-2014 Glenn Randers-Pehrson
 # Copyright (C) 1995 Guy Eric Schalnat, Group 42, Inc.
 #
@@ -7,8 +7,8 @@
 # and license in png.h
 
 # Library name:
-LIBNAME=libpng16
-PNGMAJ = 16
+LIBNAME=libpng17
+PNGMAJ = 17
 
 # Shared library names:
 LIBSO=$(LIBNAME).so
@@ -25,7 +25,7 @@ RANLIB=echo
 CP=cp
 RM_F=/bin/rm -f
 
-# Where make install puts libpng.a, libpng16.so, and libpng16/png.h
+# Where make install puts libpng.a, libpng17.so, and libpng17/png.h
 # Prefix must be a full pathname.
 
 prefix=/usr/local
@@ -99,7 +99,7 @@ libpng.pc:
 	-e s!@exec_prefix@!$(exec_prefix)! \
 	-e s!@libdir@!$(LIBPATH)! \
 	-e s!@includedir@!$(INCPATH)! \
-	-e s!-lpng16!-lpng16\ -lz\ -lm! > libpng.pc
+	-e s!-lpng17!-lpng17\ -lz\ -lm! > libpng.pc
 
 libpng-config:
 	( cat scripts/libpng-config-head.in; \
@@ -110,7 +110,7 @@ libpng-config:
 	echo ldopts=\"$(ABI)\"; \
 	echo L_opts=\"-L$(LIBPATH)\"; \
 	echo libdir=\"$(LIBPATH)\"; \
-	echo libs=\"-lpng16 -lz -lm\"; \
+	echo libs=\"-lpng17 -lz -lm\"; \
 	cat scripts/libpng-config-body.in ) > libpng-config
 	chmod +x libpng-config
 

scripts/makefile.sgi

@@ -1,4 +1,4 @@
-# makefile for libpng.a and libpng16.so, SGI IRIX with 'cc'
+# makefile for libpng.a and libpng17.so, SGI IRIX with 'cc'
 # Copyright (C) 2001-2002, 2006, 2007, 2010-2014 Glenn Randers-Pehrson
 # Copyright (C) 1995 Guy Eric Schalnat, Group 42, Inc.
 #
@@ -7,8 +7,8 @@
 # and license in png.h
 
 # Library name:
-LIBNAME=libpng16
-PNGMAJ = 16
+LIBNAME=libpng17
+PNGMAJ = 17
 
 # Shared library names:
 LIBSO=$(LIBNAME).so
@@ -25,7 +25,7 @@ RANLIB=echo
 CP=cp
 RM_F=/bin/rm -f
 
-# Where make install puts libpng.a, libpng16.so, and libpng16/png.h
+# Where make install puts libpng.a, libpng17.so, and libpng17/png.h
 # Prefix must be a full pathname.
 
 prefix=/usr/local
@@ -48,7 +48,7 @@ WARNMORE=-fullwarn
 CPPFLAGS=-I$(ZLIBINC) # -DPNG_DEBUG=5
 #CFLAGS= $(ABI) -O $(WARNMORE) -KPIC # -g
 CFLAGS=$(ABI) -O $(WARNMORE)
-LDFLAGS_A=$(ABI) -L. -L$(ZLIBLIB) -lpng16 -lz -lm
+LDFLAGS_A=$(ABI) -L. -L$(ZLIBLIB) -lpng17 -lz -lm
 LDFLAGS=$(ABI) -L. -L$(ZLIBLIB) -lpng -lz -lm
 LDSHARED=cc $(ABI) -shared -soname $(LIBSOMAJ) \
 	-set_version sgi$(PNGMAJ).0
@@ -100,7 +100,7 @@ libpng.pc:
 	-e s!@exec_prefix@!$(exec_prefix)! \
 	-e s!@libdir@!$(LIBPATH)! \
 	-e s!@includedir@!$(INCPATH)! \
-	-e s!-lpng16!-lpng16\ -lz\ -lm! > libpng.pc
+	-e s!-lpng17!-lpng17\ -lz\ -lm! > libpng.pc
 
 libpng-config:
 	( cat scripts/libpng-config-head.in; \
@@ -110,7 +110,7 @@ libpng-config:
 	echo ldopts=\"$(ABI)\"; \
 	echo L_opts=\"-L$(LIBPATH)\"; \
 	echo libdir=\"$(LIBPATH)\"; \
-	echo libs=\"-lpng16 -lz -lm\"; \
+	echo libs=\"-lpng17 -lz -lm\"; \
 	cat scripts/libpng-config-body.in ) > libpng-config
 	chmod +x libpng-config
 

scripts/makefile.so9

@@ -10,8 +10,8 @@
 # and license in png.h
 
 # Library name:
-PNGMAJ = 16
-LIBNAME = libpng16
+PNGMAJ = 17
+LIBNAME = libpng17
 
 # Shared library names:
 LIBSO=$(LIBNAME).so
@@ -50,7 +50,7 @@ ZLIBINC=/usr/include
 CPPFLAGS=-I$(ZLIBINC) # -DPNG_DEBUG=5
 #CFLAGS=-W -Wall -O3 $(WARNMORE) -g
 CFLAGS=-O3
-LDFLAGS=-L. -R. -L$(ZLIBLIB) -R$(ZLIBLIB) -lpng16 -lz -lm
+LDFLAGS=-L. -R. -L$(ZLIBLIB) -R$(ZLIBLIB) -lpng17 -lz -lm
 
 INCPATH=$(prefix)/include
 LIBPATH=$(exec_prefix)/lib
@@ -104,7 +104,7 @@ libpng.pc:
 	-e s!@exec_prefix@!$(exec_prefix)! \
 	-e s!@libdir@!$(LIBPATH)! \
 	-e s!@includedir@!$(INCPATH)! \
-	-e s!-lpng16!-lpng16\ -lz\ -lm! > libpng.pc
+	-e s!-lpng17!-lpng17\ -lz\ -lm! > libpng.pc
 
 libpng-config:
 	( cat scripts/libpng-config-head.in; \
@@ -112,7 +112,7 @@ libpng-config:
 	echo I_opts=\"-I$(INCPATH)/$(LIBNAME)\"; \
 	echo L_opts=\"-L$(LIBPATH)\"; \
 	echo R_opts=\"-R$(LIBPATH)\"; \
-	echo libs=\"-lpng16 -lz -lm\"; \
+	echo libs=\"-lpng17 -lz -lm\"; \
 	cat scripts/libpng-config-body.in ) > libpng-config
 	chmod +x libpng-config
 

scripts/makefile.solaris

@@ -9,8 +9,8 @@
 # and license in png.h
 
 # Library name:
-LIBNAME = libpng16
-PNGMAJ = 16
+LIBNAME = libpng17
+PNGMAJ = 17
 
 # Shared library names:
 LIBSO=$(LIBNAME).so
@@ -27,7 +27,7 @@ RANLIB=echo
 CP=cp
 RM_F=/bin/rm -f
 
-# Where make install puts libpng.a, libpng16.so*, and png.h
+# Where make install puts libpng.a, libpng17.so*, and png.h
 prefix=/usr/local
 exec_prefix=$(prefix)
 
@@ -46,7 +46,7 @@ WARNMORE=-Wwrite-strings -Wpointer-arith -Wshadow \
 CPPFLAGS=-I$(ZLIBINC) # -DPNG_DEBUG=5
 CFLAGS= -W -Wall -O \
 	# $(WARNMORE) -g -DPNG_DEBUG=5
-LDFLAGS=-L. -R. -L$(ZLIBLIB) -R$(ZLIBLIB) -lpng16 -lz -lm
+LDFLAGS=-L. -R. -L$(ZLIBLIB) -R$(ZLIBLIB) -lpng17 -lz -lm
 
 INCPATH=$(prefix)/include
 LIBPATH=$(exec_prefix)/lib
@@ -100,7 +100,7 @@ libpng.pc:
 	-e s!@exec_prefix@!$(exec_prefix)! \
 	-e s!@libdir@!$(LIBPATH)! \
 	-e s!@includedir@!$(INCPATH)! \
-	-e s!-lpng16!-lpng16\ -lz\ -lm! > libpng.pc
+	-e s!-lpng17!-lpng17\ -lz\ -lm! > libpng.pc
 
 libpng-config:
 	( cat scripts/libpng-config-head.in; \
@@ -109,7 +109,7 @@ libpng-config:
 	echo cppflags=\"\"; \
 	echo L_opts=\"-L$(LIBPATH)\"; \
 	echo R_opts=\"-R$(LIBPATH)\"; \
-	echo libs=\"-lpng16 -lz -lm\"; \
+	echo libs=\"-lpng17 -lz -lm\"; \
 	cat scripts/libpng-config-body.in ) > libpng-config
 	chmod +x libpng-config
 

scripts/makefile.solaris-x86

@@ -9,8 +9,8 @@
 # and license in png.h
 
 # Library name:
-LIBNAME = libpng16
-PNGMAJ = 16
+LIBNAME = libpng17
+PNGMAJ = 17
 
 # Shared library names:
 LIBSO=$(LIBNAME).so
@@ -27,7 +27,7 @@ RANLIB=echo
 CP=cp
 RM_F=/bin/rm -f
 
-# Where make install puts libpng.a, libpng16.so*, and png.h
+# Where make install puts libpng.a, libpng17.so*, and png.h
 prefix=/usr/local
 exec_prefix=$(prefix)
 
@@ -45,7 +45,7 @@ WARNMORE=-Wwrite-strings -Wpointer-arith -Wshadow \
 	-Wstrict-prototypes -Wmissing-prototypes #-Wconversion
 CPPFLAGS=-I$(ZLIBINC) # -DPNG_DEBUG=5
 CFLAGS=-W -Wall -O # $(WARNMORE) -g
-LDFLAGS=-L. -R. -L$(ZLIBLIB) -R$(ZLIBLIB) -lpng16 -lz -lm
+LDFLAGS=-L. -R. -L$(ZLIBLIB) -R$(ZLIBLIB) -lpng17 -lz -lm
 
 INCPATH=$(prefix)/include
 LIBPATH=$(exec_prefix)/lib
@@ -99,7 +99,7 @@ libpng.pc:
 	-e s!@exec_prefix@!$(exec_prefix)! \
 	-e s!@libdir@!$(LIBPATH)! \
 	-e s!@includedir@!$(INCPATH)! \
-	-e s!-lpng16!-lpng16\ -lz\ -lm! > libpng.pc
+	-e s!-lpng17!-lpng17\ -lz\ -lm! > libpng.pc
 
 libpng-config:
 	( cat scripts/libpng-config-head.in; \
@@ -108,7 +108,7 @@ libpng-config:
 	echo cppflags=\""; \
 	echo L_opts=\"-L$(LIBPATH)\"; \
 	echo R_opts=\"-R$(LIBPATH)\"; \
-	echo libs=\"-lpng16 -lz -lm\"; \
+	echo libs=\"-lpng17 -lz -lm\"; \
 	cat scripts/libpng-config-body.in ) > libpng-config
 	chmod +x libpng-config
 

scripts/pnglibconf.dfa

@@ -8,7 +8,7 @@ com pnglibconf.h - library build configuration
 com
 version
 com
-com Copyright (c) 1998-2014 Glenn Randers-Pehrson
+com Copyright (c) 1998-2015 Glenn Randers-Pehrson
 com
 com This code is released under the libpng license.
 com For conditions of distribution and use, see the disclaimer
@@ -196,6 +196,26 @@ setting API_RULE default 0
 
 setting PREFIX
 
+# This says that a prefix has been added to zlib API function names; at present
+# it is informational. The builder of zlib must ensure that zlib.h contains the
+# appropriate renames
+
+setting ZLIB_PREFIX
+
+# This is used to select an alternative zlib header file - it must look pretty
+# much like the standard zlib.h, but this makes it easier to ensure the correct
+# header file is used.  Set it to the "" or <> quoted file name (a full file
+# name is acceptable).  Prior to 1.7.0 this used "zlib.h", so it would use a
+# zlib.h in the same directory as the libpng source, from 1.7.0 it defaults to
+# just searching the -I directories.  Prior to 1.6.0 the #include appeared in
+# the exported header files - so it was quite important to use "zlib.h" to
+# ensure that applications always got the zlib.h from the same directory as
+# png.h.
+setting ZLIB_HEADER default <zlib.h>
+
+# Include the zlib header too, so that the defaults below are known
+@#  include <zlib.h>
+
 # Implementation specific control of the optimizations, enabled by those
 # hardware or software options that need it (typically when run-time choices
 # must be made by the user)
@@ -238,31 +258,25 @@ option ARM_NEON_CHECK disabled requires ALIGNED_MEMORY,
 #
 # The TEXT values are the defaults when writing compressed text (all forms)
 
-# Include the zlib header so that the defaults below are known
-@#  include <zlib.h>
-
 # The '@' here means to substitute the value when pnglibconf.h is built
+setting ZLIB_VERNUM default @ZLIB_VERNUM
 setting Z_DEFAULT_COMPRESSION default @Z_DEFAULT_COMPRESSION
 # TODO: why aren't these Z_RLE; zlib.h says that Z_RLE, specifically, is
 # appropriate for PNG images, maybe it doesn't exist in all versions?
 setting Z_DEFAULT_STRATEGY default @Z_FILTERED
 setting Z_DEFAULT_NOFILTER_STRATEGY default @Z_DEFAULT_STRATEGY
-setting ZLIB_VERNUM default @ZLIB_VERNUM
-
-# Linkage of:
-#
-#  API:      libpng API functions
-#  CALLBACK: internal non-file-local callbacks
-#  FUNCTION: internal non-file-local functions
-#  DATA:     internal non-file-local (const) data
-setting LINKAGE_API default extern
-setting LINKAGE_CALLBACK default extern
-setting LINKAGE_FUNCTION default extern
-setting LINKAGE_DATA default extern
 
 setting TEXT_Z_DEFAULT_COMPRESSION default @Z_DEFAULT_COMPRESSION
 setting TEXT_Z_DEFAULT_STRATEGY default @Z_DEFAULT_STRATEGY
 
+# Define this to something that will stop, at least, the current thread; control
+# cannot proceed beyond the PNG_ABORT operation and compilation of pngerror.c is
+# likely to fail if the operation implemented does not clearly terminate the
+# thread or process.  The default implementation is the ANSI-C abort function,
+# but any manner of C code may be used.
+
+setting ABORT default { (abort()); }
+
 # Default to using the read macros
 
 setting DEFAULT_READ_MACROS default 1
@@ -378,6 +392,7 @@ option USER_LIMITS requires READ
 # USER_CHUNK_CACHE_MAX: maximum number of chunks to be cached
 #
 # Only chunks that are variable in number are counted towards the
+# USER_CHUNK_CACHE_MAX limit
 
 # Use 0x7fffffff for unlimited
 setting USER_WIDTH_MAX default        1000000

scripts/pnglibconf.h.prebuilt

@@ -1,10 +1,10 @@
-/* libpng 1.6.18rc02 STANDARD API DEFINITION */
+/* libpng 1.7.0beta64 STANDARD API DEFINITION */
 
 /* pnglibconf.h - library build configuration */
 
-/* Libpng version 1.6.18rc02 - July 12, 2015 */
+/* Libpng version 1.7.0beta64 - July 26, 2015 */
 
-/* Copyright (c) 1998-2014 Glenn Randers-Pehrson */
+/* Copyright (c) 1998-2015 Glenn Randers-Pehrson */
 
 /* This code is released under the libpng license. */
 /* For conditions of distribution and use, see the disclaimer */
@@ -184,16 +184,13 @@
 #define PNG_zTXt_SUPPORTED
 /* end of options */
 /* settings */
+#define PNG_ABORT { (abort()); }
 #define PNG_API_RULE 0
 #define PNG_COST_SHIFT 3
 #define PNG_DEFAULT_READ_MACROS 1
 #define PNG_GAMMA_THRESHOLD_FIXED 5000
 #define PNG_IDAT_READ_SIZE PNG_ZBUF_SIZE
 #define PNG_INFLATE_BUF_SIZE 1024
-#define PNG_LINKAGE_API extern
-#define PNG_LINKAGE_CALLBACK extern
-#define PNG_LINKAGE_DATA extern
-#define PNG_LINKAGE_FUNCTION extern
 #define PNG_MAX_GAMMA_8 11
 #define PNG_QUANTIZE_BLUE_BITS 5
 #define PNG_QUANTIZE_GREEN_BITS 5
@@ -206,6 +203,7 @@
 #define PNG_USER_WIDTH_MAX 1000000
 #define PNG_WEIGHT_SHIFT 8
 #define PNG_ZBUF_SIZE 8192
+#define PNG_ZLIB_HEADER <zlib.h>
 #define PNG_ZLIB_VERNUM 0 /* unknown */
 #define PNG_Z_DEFAULT_COMPRESSION (-1)
 #define PNG_Z_DEFAULT_NOFILTER_STRATEGY 0