"Fossies" - the Fresh Open Source Software Archive

Member "pngcrush-1.8.13/pngpriv.h" (29 Aug 2017, 88792 Bytes) of package /linux/privat/pngcrush-1.8.13.tar.gz:


As a special service "Fossies" has tried to format the requested source page into HTML format using (guessed) C and C++ source code syntax highlighting (style: standard) with prefixed line numbers and code folding option. Alternatively you can here view or download the uninterpreted source code file. For more information about "pngpriv.h" see the Fossies "Dox" file reference documentation and the latest Fossies "Diffs" side-by-side code changes report: 1.8.12_vs_1.8.13.

    1 
    2 /* pngpriv.h - private declarations for use inside libpng
    3  *
    4  * Last changed in libpng 1.6.32 [August 24, 2017]
    5  * Copyright (c) 1998-2002,2004,2006-2017 Glenn Randers-Pehrson
    6  * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
    7  * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
    8  *
    9  * This code is released under the libpng license.
   10  * For conditions of distribution and use, see the disclaimer
   11  * and license in png.h
   12  */
   13 
   14 /* The symbols declared in this file (including the functions declared
   15  * as extern) are PRIVATE.  They are not part of the libpng public
   16  * interface, and are not recommended for use by regular applications.
   17  * Some of them may become public in the future; others may stay private,
   18  * change in an incompatible way, or even disappear.
   19  * Although the libpng users are not forbidden to include this header,
   20  * they should be well aware of the issues that may arise from doing so.
   21  */
   22 
   23 #ifndef PNGPRIV_H
   24 #define PNGPRIV_H
   25 
   26 /* Feature Test Macros.  The following are defined here to ensure that correctly
   27  * implemented libraries reveal the APIs libpng needs to build and hide those
   28  * that are not needed and potentially damaging to the compilation.
   29  *
   30  * Feature Test Macros must be defined before any system header is included (see
   31  * POSIX 1003.1 2.8.2 "POSIX Symbols."
   32  *
   33  * These macros only have an effect if the operating system supports either
   34  * POSIX 1003.1 or C99, or both.  On other operating systems (particularly
   35  * Windows/Visual Studio) there is no effect; the OS specific tests below are
   36  * still required (as of 2011-05-02.)
   37  */
   38 #ifndef _POSIX_SOURCE
   39 # define _POSIX_SOURCE 1 /* Just the POSIX 1003.1 and C89 APIs */
   40 #endif
   41 
   42 #ifndef PNG_VERSION_INFO_ONLY
   43 /* Standard library headers not required by png.h: */
   44 #  include <stdlib.h>
   45 #  include <string.h>
   46 #endif
   47 
   48 #define PNGLIB_BUILD /*libpng is being built, not used*/
   49 
   50 /* If HAVE_CONFIG_H is defined during the build then the build system must
   51  * provide an appropriate "config.h" file on the include path.  The header file
   52  * must provide definitions as required below (search for "HAVE_CONFIG_H");
   53  * see configure.ac for more details of the requirements.  The macro
   54  * "PNG_NO_CONFIG_H" is provided for maintainers to test for dependencies on
   55  * 'configure'; define this macro to prevent the configure build including the
   56  * configure generated config.h.  Libpng is expected to compile without *any*
   57  * special build system support on a reasonably ANSI-C compliant system.
   58  */
   59 #if defined(HAVE_CONFIG_H) && !defined(PNG_NO_CONFIG_H)
   60 #  include <config.h>
   61 
   62    /* Pick up the definition of 'restrict' from config.h if it was read: */
   63 #  define PNG_RESTRICT restrict
   64 #endif
   65 
   66 /* To support symbol prefixing it is necessary to know *before* including png.h
   67  * whether the fixed point (and maybe other) APIs are exported, because if they
   68  * are not internal definitions may be required.  This is handled below just
   69  * before png.h is included, but load the configuration now if it is available.
   70  */
   71 #ifndef PNGLCONF_H
   72 #  include "pnglibconf.h"
   73 #endif
   74 
   75 /* Local renames may change non-exported API functions from png.h */
   76 #if defined(PNG_PREFIX) && !defined(PNGPREFIX_H)
   77 #  include "pngprefix.h"
   78 #endif
   79 
   80 #ifdef PNG_USER_CONFIG
   81 #  include "pngusr.h"
   82    /* These should have been defined in pngusr.h */
   83 #  ifndef PNG_USER_PRIVATEBUILD
   84 #    define PNG_USER_PRIVATEBUILD "Custom libpng build"
   85 #  endif
   86 #  ifndef PNG_USER_DLLFNAME_POSTFIX
   87 #    define PNG_USER_DLLFNAME_POSTFIX "Cb"
   88 #  endif
   89 #endif
   90 
   91 /* Compile time options.
   92  * =====================
   93  * In a multi-arch build the compiler may compile the code several times for the
   94  * same object module, producing different binaries for different architectures.
   95  * When this happens configure-time setting of the target host options cannot be
   96  * done and this interferes with the handling of the ARM NEON optimizations, and
   97  * possibly other similar optimizations.  Put additional tests here; in general
   98  * this is needed when the same option can be changed at both compile time and
   99  * run time depending on the target OS (i.e. iOS vs Android.)
  100  *
  101  * NOTE: symbol prefixing does not pass $(CFLAGS) to the preprocessor, because
  102  * this is not possible with certain compilers (Oracle SUN OS CC), as a result
  103  * it is necessary to ensure that all extern functions that *might* be used
  104  * regardless of $(CFLAGS) get declared in this file.  The test on __ARM_NEON__
  105  * below is one example of this behavior because it is controlled by the
  106  * presence or not of -mfpu=neon on the GCC command line, it is possible to do
  107  * this in $(CC), e.g. "CC=gcc -mfpu=neon", but people who build libpng rarely
  108  * do this.
  109  */
  110 #ifndef PNG_ARM_NEON_OPT
  111    /* ARM NEON optimizations are being controlled by the compiler settings,
  112     * typically the target FPU.  If the FPU has been set to NEON (-mfpu=neon
  113     * with GCC) then the compiler will define __ARM_NEON__ and we can rely
  114     * unconditionally on NEON instructions not crashing, otherwise we must
  115     * disable use of NEON instructions.
  116     *
  117     * NOTE: at present these optimizations depend on 'ALIGNED_MEMORY', so they
  118     * can only be turned on automatically if that is supported too.  If
  119     * PNG_ARM_NEON_OPT is set in CPPFLAGS (to >0) then arm/arm_init.c will fail
  120     * to compile with an appropriate #error if ALIGNED_MEMORY has been turned
  121     * off.
  122     *
  123     * Note that gcc-4.9 defines __ARM_NEON instead of the deprecated
  124     * __ARM_NEON__, so we check both variants.
  125     *
  126     * To disable ARM_NEON optimizations entirely, and skip compiling the
  127     * associated assembler code, pass --enable-arm-neon=no to configure
  128     * or put -DPNG_ARM_NEON_OPT=0 in CPPFLAGS.
  129     */
  130 #  if (defined(__ARM_NEON__) || defined(__ARM_NEON)) && \
  131    defined(PNG_ALIGNED_MEMORY_SUPPORTED)
  132 #     define PNG_ARM_NEON_OPT 2
  133 #  else
  134 #     define PNG_ARM_NEON_OPT 0
  135 #  endif
  136 #endif
  137 
  138 #if PNG_ARM_NEON_OPT > 0
  139    /* NEON optimizations are to be at least considered by libpng, so enable the
  140     * callbacks to do this.
  141     */
  142 #  define PNG_FILTER_OPTIMIZATIONS png_init_filter_functions_neon
  143 
  144    /* By default the 'intrinsics' code in arm/filter_neon_intrinsics.c is used
  145     * if possible - if __ARM_NEON__ is set and the compiler version is not known
  146     * to be broken.  This is controlled by PNG_ARM_NEON_IMPLEMENTATION which can
  147     * be:
  148     *
  149     *    1  The intrinsics code (the default with __ARM_NEON__)
  150     *    2  The hand coded assembler (the default without __ARM_NEON__)
  151     *
  152     * It is possible to set PNG_ARM_NEON_IMPLEMENTATION in CPPFLAGS, however
  153     * this is *NOT* supported and may cease to work even after a minor revision
  154     * to libpng.  It *is* valid to do this for testing purposes, e.g. speed
  155     * testing or a new compiler, but the results should be communicated to the
  156     * libpng implementation list for incorporation in the next minor release.
  157     */
  158 #  ifndef PNG_ARM_NEON_IMPLEMENTATION
  159 #     if defined(__ARM_NEON__) || defined(__ARM_NEON)
  160 #        if defined(__clang__)
  161             /* At present it is unknown by the libpng developers which versions
  162              * of clang support the intrinsics, however some or perhaps all
  163              * versions do not work with the assembler so this may be
  164              * irrelevant, so just use the default (do nothing here.)
  165              */
  166 #        elif defined(__GNUC__)
  167             /* GCC 4.5.4 NEON support is known to be broken.  4.6.3 is known to
  168              * work, so if this *is* GCC, or G++, look for a version >4.5
  169              */
  170 #           if __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 6)
  171 #              define PNG_ARM_NEON_IMPLEMENTATION 2
  172 #           endif /* no GNUC support */
  173 #        endif /* __GNUC__ */
  174 #     else /* !defined __ARM_NEON__ */
  175          /* The 'intrinsics' code simply won't compile without this -mfpu=neon:
  176           */
  177 #        define PNG_ARM_NEON_IMPLEMENTATION 2
  178 #     endif /* __ARM_NEON__ */
  179 #  endif /* !PNG_ARM_NEON_IMPLEMENTATION */
  180 
  181 #  ifndef PNG_ARM_NEON_IMPLEMENTATION
  182       /* Use the intrinsics code by default. */
  183 #     define PNG_ARM_NEON_IMPLEMENTATION 1
  184 #  endif
  185 #endif /* PNG_ARM_NEON_OPT > 0 */
  186 
  187 #ifndef PNG_MIPS_MSA_OPT
  188 #  if defined(__mips_msa) && (__mips_isa_rev >= 5) && defined(PNG_ALIGNED_MEMORY_SUPPORTED)
  189 #     define PNG_MIPS_MSA_OPT 2
  190 #  else
  191 #     define PNG_MIPS_MSA_OPT 0
  192 #  endif
  193 #endif
  194 
  195 #ifndef PNG_POWERPC_VSX_OPT
  196 #  if defined(__PPC64__) && defined(__ALTIVEC__) && defined(__VSX__)
  197 #     define PNG_POWERPC_VSX_OPT 2
  198 #  else
  199 #     define PNG_POWERPC_VSX_OPT 0
  200 #  endif
  201 #endif
  202 
  203 #ifndef PNG_INTEL_SSE_OPT
  204 #   ifdef PNG_INTEL_SSE
  205       /* Only check for SSE if the build configuration has been modified to
  206        * enable SSE optimizations.  This means that these optimizations will
  207        * be off by default.  See contrib/intel for more details.
  208        */
  209 #     if defined(__SSE4_1__) || defined(__AVX__) || defined(__SSSE3__) || \
  210        defined(__SSE2__) || defined(_M_X64) || defined(_M_AMD64) || \
  211        (defined(_M_IX86_FP) && _M_IX86_FP >= 2)
  212 #         define PNG_INTEL_SSE_OPT 1
  213 #      endif
  214 #   endif
  215 #endif
  216 
  217 #if PNG_INTEL_SSE_OPT > 0
  218 #   ifndef PNG_INTEL_SSE_IMPLEMENTATION
  219 #      if defined(__SSE4_1__) || defined(__AVX__)
  220           /* We are not actually using AVX, but checking for AVX is the best
  221              way we can detect SSE4.1 and SSSE3 on MSVC.
  222           */
  223 #         define PNG_INTEL_SSE_IMPLEMENTATION 3
  224 #      elif defined(__SSSE3__)
  225 #         define PNG_INTEL_SSE_IMPLEMENTATION 2
  226 #      elif defined(__SSE2__) || defined(_M_X64) || defined(_M_AMD64) || \
  227        (defined(_M_IX86_FP) && _M_IX86_FP >= 2)
  228 #         define PNG_INTEL_SSE_IMPLEMENTATION 1
  229 #      else
  230 #         define PNG_INTEL_SSE_IMPLEMENTATION 0
  231 #      endif
  232 #   endif
  233 
  234 #   if PNG_INTEL_SSE_IMPLEMENTATION > 0
  235 #      define PNG_FILTER_OPTIMIZATIONS png_init_filter_functions_sse2
  236 #   endif
  237 #endif
  238 
  239 #if PNG_MIPS_MSA_OPT > 0
  240 #  define PNG_FILTER_OPTIMIZATIONS png_init_filter_functions_msa
  241 #  ifndef PNG_MIPS_MSA_IMPLEMENTATION
  242 #     if defined(__mips_msa)
  243 #        if defined(__clang__)
  244 #        elif defined(__GNUC__)
  245 #           if __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 7)
  246 #              define PNG_MIPS_MSA_IMPLEMENTATION 2
  247 #           endif /* no GNUC support */
  248 #        endif /* __GNUC__ */
  249 #     else /* !defined __mips_msa */
  250 #        define PNG_MIPS_MSA_IMPLEMENTATION 2
  251 #     endif /* __mips_msa */
  252 #  endif /* !PNG_MIPS_MSA_IMPLEMENTATION */
  253 
  254 #  ifndef PNG_MIPS_MSA_IMPLEMENTATION
  255 #     define PNG_MIPS_MSA_IMPLEMENTATION 1
  256 #  endif
  257 #endif /* PNG_MIPS_MSA_OPT > 0 */
  258 
  259 #if PNG_POWERPC_VSX_OPT > 0
  260 #  define PNG_FILTER_OPTIMIZATIONS png_init_filter_functions_vsx
  261 #  define PNG_POWERPC_VSX_IMPLEMENTATION 1
  262 #endif
  263 
  264 
  265 /* Is this a build of a DLL where compilation of the object modules requires
  266  * different preprocessor settings to those required for a simple library?  If
  267  * so PNG_BUILD_DLL must be set.
  268  *
  269  * If libpng is used inside a DLL but that DLL does not export the libpng APIs
  270  * PNG_BUILD_DLL must not be set.  To avoid the code below kicking in build a
  271  * static library of libpng then link the DLL against that.
  272  */
  273 #ifndef PNG_BUILD_DLL
  274 #  ifdef DLL_EXPORT
  275       /* This is set by libtool when files are compiled for a DLL; libtool
  276        * always compiles twice, even on systems where it isn't necessary.  Set
  277        * PNG_BUILD_DLL in case it is necessary:
  278        */
  279 #     define PNG_BUILD_DLL
  280 #  else
  281 #     ifdef _WINDLL
  282          /* This is set by the Microsoft Visual Studio IDE in projects that
  283           * build a DLL.  It can't easily be removed from those projects (it
  284           * isn't visible in the Visual Studio UI) so it is a fairly reliable
  285           * indication that PNG_IMPEXP needs to be set to the DLL export
  286           * attributes.
  287           */
  288 #        define PNG_BUILD_DLL
  289 #     else
  290 #        ifdef __DLL__
  291             /* This is set by the Borland C system when compiling for a DLL
  292              * (as above.)
  293              */
  294 #           define PNG_BUILD_DLL
  295 #        else
  296             /* Add additional compiler cases here. */
  297 #        endif
  298 #     endif
  299 #  endif
  300 #endif /* Setting PNG_BUILD_DLL if required */
  301 
  302 /* See pngconf.h for more details: the builder of the library may set this on
  303  * the command line to the right thing for the specific compilation system or it
  304  * may be automagically set above (at present we know of no system where it does
  305  * need to be set on the command line.)
  306  *
  307  * PNG_IMPEXP must be set here when building the library to prevent pngconf.h
  308  * setting it to the "import" setting for a DLL build.
  309  */
  310 #ifndef PNG_IMPEXP
  311 #  ifdef PNG_BUILD_DLL
  312 #     define PNG_IMPEXP PNG_DLL_EXPORT
  313 #  else
  314       /* Not building a DLL, or the DLL doesn't require specific export
  315        * definitions.
  316        */
  317 #     define PNG_IMPEXP
  318 #  endif
  319 #endif
  320 
  321 /* No warnings for private or deprecated functions in the build: */
  322 #ifndef PNG_DEPRECATED
  323 #  define PNG_DEPRECATED
  324 #endif
  325 #ifndef PNG_PRIVATE
  326 #  define PNG_PRIVATE
  327 #endif
  328 
  329 /* Symbol preprocessing support.
  330  *
  331  * To enable listing global, but internal, symbols the following macros should
  332  * always be used to declare an extern data or function object in this file.
  333  */
  334 #ifndef PNG_INTERNAL_DATA
  335 #  define PNG_INTERNAL_DATA(type, name, array) PNG_LINKAGE_DATA type name array
  336 #endif
  337 
  338 #ifndef PNG_INTERNAL_FUNCTION
  339 #  define PNG_INTERNAL_FUNCTION(type, name, args, attributes)\
  340       PNG_LINKAGE_FUNCTION PNG_FUNCTION(type, name, args, PNG_EMPTY attributes)
  341 #endif
  342 
  343 #ifndef PNG_INTERNAL_CALLBACK
  344 #  define PNG_INTERNAL_CALLBACK(type, name, args, attributes)\
  345       PNG_LINKAGE_CALLBACK PNG_FUNCTION(type, (PNGCBAPI name), args,\
  346          PNG_EMPTY attributes)
  347 #endif
  348 
  349 /* If floating or fixed point APIs are disabled they may still be compiled
  350  * internally.  To handle this make sure they are declared as the appropriate
  351  * internal extern function (otherwise the symbol prefixing stuff won't work and
  352  * the functions will be used without definitions.)
  353  *
  354  * NOTE: although all the API functions are declared here they are not all
  355  * actually built!  Because the declarations are still made it is necessary to
  356  * fake out types that they depend on.
  357  */
  358 #ifndef PNG_FP_EXPORT
  359 #  ifndef PNG_FLOATING_POINT_SUPPORTED
  360 #     define PNG_FP_EXPORT(ordinal, type, name, args)\
  361          PNG_INTERNAL_FUNCTION(type, name, args, PNG_EMPTY);
  362 #     ifndef PNG_VERSION_INFO_ONLY
  363          typedef struct png_incomplete png_double;
  364          typedef png_double*           png_doublep;
  365          typedef const png_double*     png_const_doublep;
  366          typedef png_double**          png_doublepp;
  367 #     endif
  368 #  endif
  369 #endif
  370 #ifndef PNG_FIXED_EXPORT
  371 #  ifndef PNG_FIXED_POINT_SUPPORTED
  372 #     define PNG_FIXED_EXPORT(ordinal, type, name, args)\
  373          PNG_INTERNAL_FUNCTION(type, name, args, PNG_EMPTY);
  374 #  endif
  375 #endif
  376 
  377 #include "png.h"
  378 
  379 /* pngconf.h does not set PNG_DLL_EXPORT unless it is required, so: */
  380 #ifndef PNG_DLL_EXPORT
  381 #  define PNG_DLL_EXPORT
  382 #endif
  383 
  384 /* This is a global switch to set the compilation for an installed system
  385  * (a release build).  It can be set for testing debug builds to ensure that
  386  * they will compile when the build type is switched to RC or STABLE, the
  387  * default is just to use PNG_LIBPNG_BUILD_BASE_TYPE.  Set this in CPPFLAGS
  388  * with either:
  389  *
  390  *   -DPNG_RELEASE_BUILD Turns on the release compile path
  391  *   -DPNG_RELEASE_BUILD=0 Turns it off
  392  * or in your pngusr.h with
  393  *   #define PNG_RELEASE_BUILD=1 Turns on the release compile path
  394  *   #define PNG_RELEASE_BUILD=0 Turns it off
  395  */
  396 #ifndef PNG_RELEASE_BUILD
  397 #  define PNG_RELEASE_BUILD (PNG_LIBPNG_BUILD_BASE_TYPE >= PNG_LIBPNG_BUILD_RC)
  398 #endif
  399 
  400 /* SECURITY and SAFETY:
  401  *
  402  * libpng is built with support for internal limits on image dimensions and
  403  * memory usage.  These are documented in scripts/pnglibconf.dfa of the
  404  * source and recorded in the machine generated header file pnglibconf.h.
  405  */
  406 
  407 /* If you are running on a machine where you cannot allocate more
  408  * than 64K of memory at once, uncomment this.  While libpng will not
  409  * normally need that much memory in a chunk (unless you load up a very
  410  * large file), zlib needs to know how big of a chunk it can use, and
  411  * libpng thus makes sure to check any memory allocation to verify it
  412  * will fit into memory.
  413  *
  414  * zlib provides 'MAXSEG_64K' which, if defined, indicates the
  415  * same limit and pngconf.h (already included) sets the limit
  416  * if certain operating systems are detected.
  417  */
  418 #if defined(MAXSEG_64K) && !defined(PNG_MAX_MALLOC_64K)
  419 #  define PNG_MAX_MALLOC_64K
  420 #endif
  421 
  422 #ifndef PNG_UNUSED
  423 /* Unused formal parameter warnings are silenced using the following macro
  424  * which is expected to have no bad effects on performance (optimizing
  425  * compilers will probably remove it entirely).  Note that if you replace
  426  * it with something other than whitespace, you must include the terminating
  427  * semicolon.
  428  */
  429 #  define PNG_UNUSED(param) (void)param;
  430 #endif
  431 
  432 /* Just a little check that someone hasn't tried to define something
  433  * contradictory.
  434  */
  435 #if (PNG_ZBUF_SIZE > 65536L) && defined(PNG_MAX_MALLOC_64K)
  436 #  undef PNG_ZBUF_SIZE
  437 #  define PNG_ZBUF_SIZE 65536L
  438 #endif
  439 
  440 /* If warnings or errors are turned off the code is disabled or redirected here.
  441  * From 1.5.4 functions have been added to allow very limited formatting of
  442  * error and warning messages - this code will also be disabled here.
  443  */
  444 #ifdef PNG_WARNINGS_SUPPORTED
  445 #  define PNG_WARNING_PARAMETERS(p) png_warning_parameters p;
  446 #else
  447 #  define png_warning_parameter(p,number,string) ((void)0)
  448 #  define png_warning_parameter_unsigned(p,number,format,value) ((void)0)
  449 #  define png_warning_parameter_signed(p,number,format,value) ((void)0)
  450 #  define png_formatted_warning(pp,p,message) ((void)(pp))
  451 #  define PNG_WARNING_PARAMETERS(p)
  452 #endif
  453 #ifndef PNG_ERROR_TEXT_SUPPORTED
  454 #  define png_fixed_error(s1,s2) png_err(s1)
  455 #endif
  456 
  457 /* Some fixed point APIs are still required even if not exported because
  458  * they get used by the corresponding floating point APIs.  This magic
  459  * deals with this:
  460  */
  461 #ifdef PNG_FIXED_POINT_SUPPORTED
  462 #  define PNGFAPI PNGAPI
  463 #else
  464 #  define PNGFAPI /* PRIVATE */
  465 #endif
  466 
  467 #ifndef PNG_VERSION_INFO_ONLY
  468 /* Other defines specific to compilers can go here.  Try to keep
  469  * them inside an appropriate ifdef/endif pair for portability.
  470  */
  471 
  472 /* C allows up-casts from (void*) to any pointer and (const void*) to any
  473  * pointer to a const object.  C++ regards this as a type error and requires an
  474  * explicit, static, cast and provides the static_cast<> rune to ensure that
  475  * const is not cast away.
  476  */
  477 #ifdef __cplusplus
  478 #  define png_voidcast(type, value) static_cast<type>(value)
  479 #  define png_constcast(type, value) const_cast<type>(value)
  480 #  define png_aligncast(type, value) \
  481    static_cast<type>(static_cast<void*>(value))
  482 #  define png_aligncastconst(type, value) \
  483    static_cast<type>(static_cast<const void*>(value))
  484 #else
  485 #  define png_voidcast(type, value) (value)
  486 #  ifdef _WIN64
  487 #     ifdef __GNUC__
  488          typedef unsigned long long png_ptruint;
  489 #     else
  490          typedef unsigned __int64 png_ptruint;
  491 #     endif
  492 #  else
  493       typedef unsigned long png_ptruint;
  494 #  endif
  495 #  define png_constcast(type, value) ((type)(png_ptruint)(const void*)(value))
  496 #  define png_aligncast(type, value) ((void*)(value))
  497 #  define png_aligncastconst(type, value) ((const void*)(value))
  498 #endif /* __cplusplus */
  499 
  500 #if defined(PNG_FLOATING_POINT_SUPPORTED) ||\
  501     defined(PNG_FLOATING_ARITHMETIC_SUPPORTED)
  502    /* png.c requires the following ANSI-C constants if the conversion of
  503     * floating point to ASCII is implemented therein:
  504     *
  505     *  DBL_DIG  Maximum number of decimal digits (can be set to any constant)
  506     *  DBL_MIN  Smallest normalized fp number (can be set to an arbitrary value)
  507     *  DBL_MAX  Maximum floating point number (can be set to an arbitrary value)
  508     */
  509 #  include <float.h>
  510 
  511 #  if (defined(__MWERKS__) && defined(macintosh)) || defined(applec) || \
  512     defined(THINK_C) || defined(__SC__) || defined(TARGET_OS_MAC)
  513    /* We need to check that <math.h> hasn't already been included earlier
  514     * as it seems it doesn't agree with <fp.h>, yet we should really use
  515     * <fp.h> if possible.
  516     */
  517 #    if !defined(__MATH_H__) && !defined(__MATH_H) && !defined(__cmath__)
  518 #      include <fp.h>
  519 #    endif
  520 #  else
  521 #    include <math.h>
  522 #  endif
  523 #  if defined(_AMIGA) && defined(__SASC) && defined(_M68881)
  524    /* Amiga SAS/C: We must include builtin FPU functions when compiling using
  525     * MATH=68881
  526     */
  527 #    include <m68881.h>
  528 #  endif
  529 #endif
  530 
  531 /* This provides the non-ANSI (far) memory allocation routines. */
  532 #if defined(__TURBOC__) && defined(__MSDOS__)
  533 #  include <mem.h>
  534 #  include <alloc.h>
  535 #endif
  536 
  537 #if defined(WIN32) || defined(_Windows) || defined(_WINDOWS) || \
  538     defined(_WIN32) || defined(__WIN32__)
  539 #  include <windows.h>  /* defines _WINDOWS_ macro */
  540 #endif
  541 #endif /* PNG_VERSION_INFO_ONLY */
  542 
  543 /* Moved here around 1.5.0beta36 from pngconf.h */
  544 /* Users may want to use these so they are not private.  Any library
  545  * functions that are passed far data must be model-independent.
  546  */
  547 
  548 /* Memory model/platform independent fns */
  549 #ifndef PNG_ABORT
  550 #  ifdef _WINDOWS_
  551 #    define PNG_ABORT() ExitProcess(0)
  552 #  else
  553 #    define PNG_ABORT() abort()
  554 #  endif
  555 #endif
  556 
  557 /* These macros may need to be architecture dependent. */
  558 #define PNG_ALIGN_NONE   0 /* do not use data alignment */
  559 #define PNG_ALIGN_ALWAYS 1 /* assume unaligned accesses are OK */
  560 #ifdef offsetof
  561 #  define PNG_ALIGN_OFFSET 2 /* use offsetof to determine alignment */
  562 #else
  563 #  define PNG_ALIGN_OFFSET -1 /* prevent the use of this */
  564 #endif
  565 #define PNG_ALIGN_SIZE   3 /* use sizeof to determine alignment */
  566 
  567 #ifndef PNG_ALIGN_TYPE
  568    /* Default to using aligned access optimizations and requiring alignment to a
  569     * multiple of the data type size.  Override in a compiler specific fashion
  570     * if necessary by inserting tests here:
  571     */
  572 #  define PNG_ALIGN_TYPE PNG_ALIGN_SIZE
  573 #endif
  574 
  575 #if PNG_ALIGN_TYPE == PNG_ALIGN_SIZE
  576    /* This is used because in some compiler implementations non-aligned
  577     * structure members are supported, so the offsetof approach below fails.
  578     * Set PNG_ALIGN_SIZE=0 for compiler combinations where unaligned access
  579     * is good for performance.  Do not do this unless you have tested the result
  580     * and understand it.
  581     */
  582 #  define png_alignof(type) (sizeof (type))
  583 #else
  584 #  if PNG_ALIGN_TYPE == PNG_ALIGN_OFFSET
  585 #     define png_alignof(type) offsetof(struct{char c; type t;}, t)
  586 #  else
  587 #     if PNG_ALIGN_TYPE == PNG_ALIGN_ALWAYS
  588 #        define png_alignof(type) (1)
  589 #     endif
  590       /* Else leave png_alignof undefined to prevent use thereof */
  591 #  endif
  592 #endif
  593 
  594 /* This implicitly assumes alignment is always to a power of 2. */
  595 #ifdef png_alignof
  596 #  define png_isaligned(ptr, type)\
  597    (((type)((const char*)ptr-(const char*)0) & \
  598    (type)(png_alignof(type)-1)) == 0)
  599 #else
  600 #  define png_isaligned(ptr, type) 0
  601 #endif
  602 
  603 /* End of memory model/platform independent support */
  604 /* End of 1.5.0beta36 move from pngconf.h */
  605 
  606 /* CONSTANTS and UTILITY MACROS
  607  * These are used internally by libpng and not exposed in the API
  608  */
  609 
  610 /* Various modes of operation.  Note that after an init, mode is set to
  611  * zero automatically when the structure is created.  Three of these
  612  * are defined in png.h because they need to be visible to applications
  613  * that call png_set_unknown_chunk().
  614  */
  615 /* #define PNG_HAVE_IHDR            0x01U (defined in png.h) */
  616 /* #define PNG_HAVE_PLTE            0x02U (defined in png.h) */
  617 #define PNG_HAVE_IDAT               0x04U
  618 /* #define PNG_AFTER_IDAT           0x08U (defined in png.h) */
  619 #define PNG_HAVE_IEND               0x10U
  620                    /*               0x20U (unused) */
  621                    /*               0x40U (unused) */
  622                    /*               0x80U (unused) */
  623 #define PNG_HAVE_CHUNK_HEADER      0x100U
  624 #define PNG_WROTE_tIME             0x200U
  625 #define PNG_WROTE_INFO_BEFORE_PLTE 0x400U
  626 #define PNG_BACKGROUND_IS_GRAY     0x800U
  627 #define PNG_HAVE_PNG_SIGNATURE    0x1000U
  628 #define PNG_HAVE_CHUNK_AFTER_IDAT 0x2000U /* Have another chunk after IDAT */
  629                    /*             0x4000U (unused) */
  630 #define PNG_IS_READ_STRUCT        0x8000U /* Else is a write struct */
  631 
  632 /* Flags for the transformations the PNG library does on the image data */
  633 #define PNG_BGR                 0x0001U
  634 #define PNG_INTERLACE           0x0002U
  635 #define PNG_PACK                0x0004U
  636 #define PNG_SHIFT               0x0008U
  637 #define PNG_SWAP_BYTES          0x0010U
  638 #define PNG_INVERT_MONO         0x0020U
  639 #define PNG_QUANTIZE            0x0040U
  640 #define PNG_COMPOSE             0x0080U    /* Was PNG_BACKGROUND */
  641 #define PNG_BACKGROUND_EXPAND   0x0100U
  642 #define PNG_EXPAND_16           0x0200U    /* Added to libpng 1.5.2 */
  643 #define PNG_16_TO_8             0x0400U    /* Becomes 'chop' in 1.5.4 */
  644 #define PNG_RGBA                0x0800U
  645 #define PNG_EXPAND              0x1000U
  646 #define PNG_GAMMA               0x2000U
  647 #define PNG_GRAY_TO_RGB         0x4000U
  648 #define PNG_FILLER              0x8000U
  649 #define PNG_PACKSWAP           0x10000U
  650 #define PNG_SWAP_ALPHA         0x20000U
  651 #define PNG_STRIP_ALPHA        0x40000U
  652 #define PNG_INVERT_ALPHA       0x80000U
  653 #define PNG_USER_TRANSFORM    0x100000U
  654 #define PNG_RGB_TO_GRAY_ERR   0x200000U
  655 #define PNG_RGB_TO_GRAY_WARN  0x400000U
  656 #define PNG_RGB_TO_GRAY       0x600000U /* two bits, RGB_TO_GRAY_ERR|WARN */
  657 #define PNG_ENCODE_ALPHA      0x800000U /* Added to libpng-1.5.4 */
  658 #define PNG_ADD_ALPHA        0x1000000U /* Added to libpng-1.2.7 */
  659 #define PNG_EXPAND_tRNS      0x2000000U /* Added to libpng-1.2.9 */
  660 #define PNG_SCALE_16_TO_8    0x4000000U /* Added to libpng-1.5.4 */
  661                        /*    0x8000000U unused */
  662                        /*   0x10000000U unused */
  663                        /*   0x20000000U unused */
  664                        /*   0x40000000U unused */
  665 /* Flags for png_create_struct */
  666 #define PNG_STRUCT_PNG   0x0001U
  667 #define PNG_STRUCT_INFO  0x0002U
  668 
  669 /* Flags for the png_ptr->flags rather than declaring a byte for each one */
  670 #define PNG_FLAG_ZLIB_CUSTOM_STRATEGY     0x0001U
  671 #define PNG_FLAG_ZSTREAM_INITIALIZED      0x0002U /* Added to libpng-1.6.0 */
  672                                   /*      0x0004U    unused */
  673 #define PNG_FLAG_ZSTREAM_ENDED            0x0008U /* Added to libpng-1.6.0 */
  674                                   /*      0x0010U    unused */
  675                                   /*      0x0020U    unused */
  676 #define PNG_FLAG_ROW_INIT                 0x0040U
  677 #define PNG_FLAG_FILLER_AFTER             0x0080U
  678 #define PNG_FLAG_CRC_ANCILLARY_USE        0x0100U
  679 #define PNG_FLAG_CRC_ANCILLARY_NOWARN     0x0200U
  680 #define PNG_FLAG_CRC_CRITICAL_USE         0x0400U
  681 #define PNG_FLAG_CRC_CRITICAL_IGNORE      0x0800U
  682 #define PNG_FLAG_ASSUME_sRGB              0x1000U /* Added to libpng-1.5.4 */
  683 #define PNG_FLAG_OPTIMIZE_ALPHA           0x2000U /* Added to libpng-1.5.4 */
  684 #define PNG_FLAG_DETECT_UNINITIALIZED     0x4000U /* Added to libpng-1.5.4 */
  685 /* #define PNG_FLAG_KEEP_UNKNOWN_CHUNKS      0x8000U */
  686 /* #define PNG_FLAG_KEEP_UNSAFE_CHUNKS      0x10000U */
  687 #define PNG_FLAG_LIBRARY_MISMATCH        0x20000U
  688 #define PNG_FLAG_STRIP_ERROR_NUMBERS     0x40000U
  689 #define PNG_FLAG_STRIP_ERROR_TEXT        0x80000U
  690 #define PNG_FLAG_BENIGN_ERRORS_WARN     0x100000U /* Added to libpng-1.4.0 */
  691 #define PNG_FLAG_APP_WARNINGS_WARN      0x200000U /* Added to libpng-1.6.0 */
  692 #define PNG_FLAG_APP_ERRORS_WARN        0x400000U /* Added to libpng-1.6.0 */
  693                                   /*    0x800000U    unused */
  694                                   /*   0x1000000U    unused */
  695                                   /*   0x2000000U    unused */
  696                                   /*   0x4000000U    unused */
  697                                   /*   0x8000000U    unused */
  698                                   /*  0x10000000U    unused */
  699                                   /*  0x20000000U    unused */
  700                                   /*  0x40000000U    unused */
  701 
  702 #define PNG_FLAG_CRC_ANCILLARY_MASK (PNG_FLAG_CRC_ANCILLARY_USE | \
  703                                      PNG_FLAG_CRC_ANCILLARY_NOWARN)
  704 
  705 #define PNG_FLAG_CRC_CRITICAL_MASK  (PNG_FLAG_CRC_CRITICAL_USE | \
  706                                      PNG_FLAG_CRC_CRITICAL_IGNORE)
  707 
  708 #define PNG_FLAG_CRC_MASK           (PNG_FLAG_CRC_ANCILLARY_MASK | \
  709                                      PNG_FLAG_CRC_CRITICAL_MASK)
  710 
  711 /* Save typing and make code easier to understand */
  712 
  713 #define PNG_COLOR_DIST(c1, c2) (abs((int)((c1).red) - (int)((c2).red)) + \
  714    abs((int)((c1).green) - (int)((c2).green)) + \
  715    abs((int)((c1).blue) - (int)((c2).blue)))
  716 
  717 /* Added to libpng-1.6.0: scale a 16-bit value in the range 0..65535 to 0..255
  718  * by dividing by 257 *with rounding*.  This macro is exact for the given range.
  719  * See the discourse in pngrtran.c png_do_scale_16_to_8.  The values in the
  720  * macro were established by experiment (modifying the added value).  The macro
  721  * has a second variant that takes a value already scaled by 255 and divides by
  722  * 65535 - this has a maximum error of .502.  Over the range 0..65535*65535 it
  723  * only gives off-by-one errors and only for 0.5% (1 in 200) of the values.
  724  */
  725 #define PNG_DIV65535(v24) (((v24) + 32895) >> 16)
  726 #define PNG_DIV257(v16) PNG_DIV65535((png_uint_32)(v16) * 255)
  727 
  728 /* Added to libpng-1.2.6 JB */
  729 #define PNG_ROWBYTES(pixel_bits, width) \
  730     ((pixel_bits) >= 8 ? \
  731     ((png_size_t)(width) * (((png_size_t)(pixel_bits)) >> 3)) : \
  732     (( ((png_size_t)(width) * ((png_size_t)(pixel_bits))) + 7) >> 3) )
  733 
  734 /* This returns the number of trailing bits in the last byte of a row, 0 if the
  735  * last byte is completely full of pixels.  It is, in principle, (pixel_bits x
  736  * width) % 8, but that would overflow for large 'width'.  The second macro is
  737  * the same except that it returns the number of unused bits in the last byte;
  738  * (8-TRAILBITS), but 0 when TRAILBITS is 0.
  739  *
  740  * NOTE: these macros are intended to be self-evidently correct and never
  741  * overflow on the assumption that pixel_bits is in the range 0..255.  The
  742  * arguments are evaluated only once and they can be signed (e.g. as a result of
  743  * the integral promotions).  The result of the expression always has type
  744  * (png_uint_32), however the compiler always knows it is in the range 0..7.
  745  */
  746 #define PNG_TRAILBITS(pixel_bits, width) \
  747     (((pixel_bits) * ((width) % (png_uint_32)8)) % 8)
  748 
  749 #define PNG_PADBITS(pixel_bits, width) \
  750     ((8 - PNG_TRAILBITS(pixel_bits, width)) % 8)
  751 
  752 /* PNG_OUT_OF_RANGE returns true if value is outside the range
  753  * ideal-delta..ideal+delta.  Each argument is evaluated twice.
  754  * "ideal" and "delta" should be constants, normally simple
  755  * integers, "value" a variable. Added to libpng-1.2.6 JB
  756  */
  757 #define PNG_OUT_OF_RANGE(value, ideal, delta) \
  758    ( (value) < (ideal)-(delta) || (value) > (ideal)+(delta) )
  759 
  760 /* Conversions between fixed and floating point, only defined if
  761  * required (to make sure the code doesn't accidentally use float
  762  * when it is supposedly disabled.)
  763  */
  764 #ifdef PNG_FLOATING_POINT_SUPPORTED
  765 /* The floating point conversion can't overflow, though it can and
  766  * does lose accuracy relative to the original fixed point value.
  767  * In practice this doesn't matter because png_fixed_point only
  768  * stores numbers with very low precision.  The png_ptr and s
  769  * arguments are unused by default but are there in case error
  770  * checking becomes a requirement.
  771  */
  772 #define png_float(png_ptr, fixed, s) (.00001 * (fixed))
  773 
  774 /* The fixed point conversion performs range checking and evaluates
  775  * its argument multiple times, so must be used with care.  The
  776  * range checking uses the PNG specification values for a signed
  777  * 32-bit fixed point value except that the values are deliberately
  778  * rounded-to-zero to an integral value - 21474 (21474.83 is roughly
  779  * (2^31-1) * 100000). 's' is a string that describes the value being
  780  * converted.
  781  *
  782  * NOTE: this macro will raise a png_error if the range check fails,
  783  * therefore it is normally only appropriate to use this on values
  784  * that come from API calls or other sources where an out of range
  785  * error indicates a programming error, not a data error!
  786  *
  787  * NOTE: by default this is off - the macro is not used - because the
  788  * function call saves a lot of code.
  789  */
  790 #ifdef PNG_FIXED_POINT_MACRO_SUPPORTED
  791 #define png_fixed(png_ptr, fp, s) ((fp) <= 21474 && (fp) >= -21474 ?\
  792     ((png_fixed_point)(100000 * (fp))) : (png_fixed_error(png_ptr, s),0))
  793 #endif
  794 /* else the corresponding function is defined below, inside the scope of the
  795  * cplusplus test.
  796  */
  797 #endif
  798 
  799 /* Constants for known chunk types.  If you need to add a chunk, define the name
  800  * here.  For historical reasons these constants have the form png_<name>; i.e.
  801  * the prefix is lower case.  Please use decimal values as the parameters to
  802  * match the ISO PNG specification and to avoid relying on the C locale
  803  * interpretation of character values.
  804  *
  805  * Prior to 1.5.6 these constants were strings, as of 1.5.6 png_uint_32 values
  806  * are computed and a new macro (PNG_STRING_FROM_CHUNK) added to allow a string
  807  * to be generated if required.
  808  *
  809  * PNG_32b correctly produces a value shifted by up to 24 bits, even on
  810  * architectures where (int) is only 16 bits.
  811  */
  812 #define PNG_32b(b,s) ((png_uint_32)(b) << (s))
  813 #define PNG_U32(b1,b2,b3,b4) \
  814    (PNG_32b(b1,24) | PNG_32b(b2,16) | PNG_32b(b3,8) | PNG_32b(b4,0))
  815 
  816 /* Constants for known chunk types.
  817  *
  818  * MAINTAINERS: If you need to add a chunk, define the name here.
  819  * For historical reasons these constants have the form png_<name>; i.e.
  820  * the prefix is lower case.  Please use decimal values as the parameters to
  821  * match the ISO PNG specification and to avoid relying on the C locale
  822  * interpretation of character values.  Please keep the list sorted.
  823  *
  824  * Notice that PNG_U32 is used to define a 32-bit value for the 4 byte chunk
  825  * type.  In fact the specification does not express chunk types this way,
  826  * however using a 32-bit value means that the chunk type can be read from the
  827  * stream using exactly the same code as used for a 32-bit unsigned value and
  828  * can be examined far more efficiently (using one arithmetic compare).
  829  *
  830  * Prior to 1.5.6 the chunk type constants were expressed as C strings.  The
  831  * libpng API still uses strings for 'unknown' chunks and a macro,
  832  * PNG_STRING_FROM_CHUNK, allows a string to be generated if required.  Notice
  833  * that for portable code numeric values must still be used; the string "IHDR"
  834  * is not portable and neither is PNG_U32('I', 'H', 'D', 'R').
  835  *
  836  * In 1.7.0 the definitions will be made public in png.h to avoid having to
  837  * duplicate the same definitions in application code.
  838  */
  839 #define png_IDAT PNG_U32( 73,  68,  65,  84)
  840 #define png_IEND PNG_U32( 73,  69,  78,  68)
  841 #define png_IHDR PNG_U32( 73,  72,  68,  82)
  842 #define png_PLTE PNG_U32( 80,  76,  84,  69)
  843 #define png_bKGD PNG_U32( 98,  75,  71,  68)
  844 #define png_cHRM PNG_U32( 99,  72,  82,  77)
  845 #define png_eXIf PNG_U32(101,  88,  73, 102) /* registered July 2017 */
  846 #define png_fRAc PNG_U32(102,  82,  65,  99) /* registered, not defined */
  847 #define png_gAMA PNG_U32(103,  65,  77,  65)
  848 #define png_gIFg PNG_U32(103,  73,  70, 103)
  849 #define png_gIFt PNG_U32(103,  73,  70, 116) /* deprecated */
  850 #define png_gIFx PNG_U32(103,  73,  70, 120)
  851 #define png_hIST PNG_U32(104,  73,  83,  84)
  852 #define png_iCCP PNG_U32(105,  67,  67,  80)
  853 #define png_iTXt PNG_U32(105,  84,  88, 116)
  854 #define png_oFFs PNG_U32(111,  70,  70, 115)
  855 #define png_pCAL PNG_U32(112,  67,  65,  76)
  856 #define png_pHYs PNG_U32(112,  72,  89, 115)
  857 #define png_sBIT PNG_U32(115,  66,  73,  84)
  858 #define png_sCAL PNG_U32(115,  67,  65,  76)
  859 #define png_sPLT PNG_U32(115,  80,  76,  84)
  860 #define png_sRGB PNG_U32(115,  82,  71,  66)
  861 #define png_sTER PNG_U32(115,  84,  69,  82)
  862 #define png_tEXt PNG_U32(116,  69,  88, 116)
  863 #define png_tIME PNG_U32(116,  73,  77,  69)
  864 #define png_tRNS PNG_U32(116,  82,  78,  83)
  865 #define png_zTXt PNG_U32(122,  84,  88, 116)
  866 
  867 /* The following will work on (signed char*) strings, whereas the get_uint_32
  868  * macro will fail on top-bit-set values because of the sign extension.
  869  */
  870 #define PNG_CHUNK_FROM_STRING(s)\
  871    PNG_U32(0xff & (s)[0], 0xff & (s)[1], 0xff & (s)[2], 0xff & (s)[3])
  872 
  873 /* This uses (char), not (png_byte) to avoid warnings on systems where (char) is
  874  * signed and the argument is a (char[])  This macro will fail miserably on
  875  * systems where (char) is more than 8 bits.
  876  */
  877 #define PNG_STRING_FROM_CHUNK(s,c)\
  878    (void)(((char*)(s))[0]=(char)(((c)>>24) & 0xff), \
  879    ((char*)(s))[1]=(char)(((c)>>16) & 0xff),\
  880    ((char*)(s))[2]=(char)(((c)>>8) & 0xff), \
  881    ((char*)(s))[3]=(char)((c & 0xff)))
  882 
  883 /* Do the same but terminate with a null character. */
  884 #define PNG_CSTRING_FROM_CHUNK(s,c)\
  885    (void)(PNG_STRING_FROM_CHUNK(s,c), ((char*)(s))[4] = 0)
  886 
  887 /* Test on flag values as defined in the spec (section 5.4): */
  888 #define PNG_CHUNK_ANCILLARY(c)   (1 & ((c) >> 29))
  889 #define PNG_CHUNK_CRITICAL(c)     (!PNG_CHUNK_ANCILLARY(c))
  890 #define PNG_CHUNK_PRIVATE(c)      (1 & ((c) >> 21))
  891 #define PNG_CHUNK_RESERVED(c)     (1 & ((c) >> 13))
  892 #define PNG_CHUNK_SAFE_TO_COPY(c) (1 & ((c) >>  5))
  893 
  894 /* Gamma values (new at libpng-1.5.4): */
  895 #define PNG_GAMMA_MAC_OLD 151724  /* Assume '1.8' is really 2.2/1.45! */
  896 #define PNG_GAMMA_MAC_INVERSE 65909
  897 #define PNG_GAMMA_sRGB_INVERSE 45455
  898 
  899 /* Almost everything below is C specific; the #defines above can be used in
  900  * non-C code (so long as it is C-preprocessed) the rest of this stuff cannot.
  901  */
  902 #ifndef PNG_VERSION_INFO_ONLY
  903 
  904 #include "pngstruct.h"
  905 #include "pnginfo.h"
  906 
  907 /* Validate the include paths - the include path used to generate pnglibconf.h
  908  * must match that used in the build, or we must be using pnglibconf.h.prebuilt:
  909  */
  910 #if PNG_ZLIB_VERNUM != 0 && PNG_ZLIB_VERNUM != ZLIB_VERNUM
  911 #  error ZLIB_VERNUM != PNG_ZLIB_VERNUM \
  912       "-I (include path) error: see the notes in pngpriv.h"
  913    /* This means that when pnglibconf.h was built the copy of zlib.h that it
  914     * used is not the same as the one being used here.  Because the build of
  915     * libpng makes decisions to use inflateInit2 and inflateReset2 based on the
  916     * zlib version number and because this affects handling of certain broken
  917     * PNG files the -I directives must match.
  918     *
  919     * The most likely explanation is that you passed a -I in CFLAGS. This will
  920     * not work; all the preprocessor directories and in particular all the -I
  921     * directives must be in CPPFLAGS.
  922     */
  923 #endif
  924 
  925 /* This is used for 16-bit gamma tables -- only the top level pointers are
  926  * const; this could be changed:
  927  */
  928 typedef const png_uint_16p * png_const_uint_16pp;
  929 
  930 /* Added to libpng-1.5.7: sRGB conversion tables */
  931 #if defined(PNG_SIMPLIFIED_READ_SUPPORTED) ||\
  932    defined(PNG_SIMPLIFIED_WRITE_SUPPORTED)
  933 #ifdef PNG_SIMPLIFIED_READ_SUPPORTED
  934 PNG_INTERNAL_DATA(const png_uint_16, png_sRGB_table, [256]);
  935    /* Convert from an sRGB encoded value 0..255 to a 16-bit linear value,
  936     * 0..65535.  This table gives the closest 16-bit answers (no errors).
  937     */
  938 #endif
  939 
  940 PNG_INTERNAL_DATA(const png_uint_16, png_sRGB_base, [512]);
  941 PNG_INTERNAL_DATA(const png_byte, png_sRGB_delta, [512]);
  942 
  943 #define PNG_sRGB_FROM_LINEAR(linear) \
  944   ((png_byte)(0xff & ((png_sRGB_base[(linear)>>15] \
  945    + ((((linear) & 0x7fff)*png_sRGB_delta[(linear)>>15])>>12)) >> 8)))
  946    /* Given a value 'linear' in the range 0..255*65535 calculate the 8-bit sRGB
  947     * encoded value with maximum error 0.646365.  Note that the input is not a
  948     * 16-bit value; it has been multiplied by 255! */
  949 #endif /* SIMPLIFIED_READ/WRITE */
  950 
  951 
  952 /* Inhibit C++ name-mangling for libpng functions but not for system calls. */
  953 #ifdef __cplusplus
  954 extern "C" {
  955 #endif /* __cplusplus */
  956 
  957 /* Internal functions; these are not exported from a DLL however because they
  958  * are used within several of the C source files they have to be C extern.
  959  *
  960  * All of these functions must be declared with PNG_INTERNAL_FUNCTION.
  961  */
  962 
  963 /* Zlib support */
  964 #define PNG_UNEXPECTED_ZLIB_RETURN (-7)
  965 PNG_INTERNAL_FUNCTION(void, png_zstream_error,(png_structrp png_ptr, int ret),
  966    PNG_EMPTY);
  967    /* Used by the zlib handling functions to ensure that z_stream::msg is always
  968     * set before they return.
  969     */
  970 
  971 #ifdef PNG_WRITE_SUPPORTED
  972 PNG_INTERNAL_FUNCTION(void,png_free_buffer_list,(png_structrp png_ptr,
  973    png_compression_bufferp *list),PNG_EMPTY);
  974    /* Free the buffer list used by the compressed write code. */
  975 #endif
  976 
  977 #if defined(PNG_FLOATING_POINT_SUPPORTED) && \
  978    !defined(PNG_FIXED_POINT_MACRO_SUPPORTED) && \
  979    (defined(PNG_gAMA_SUPPORTED) || defined(PNG_cHRM_SUPPORTED) || \
  980    defined(PNG_sCAL_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) || \
  981    defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)) || \
  982    (defined(PNG_sCAL_SUPPORTED) && \
  983    defined(PNG_FLOATING_ARITHMETIC_SUPPORTED))
  984 PNG_INTERNAL_FUNCTION(png_fixed_point,png_fixed,(png_const_structrp png_ptr,
  985    double fp, png_const_charp text),PNG_EMPTY);
  986 #endif
  987 
  988 /* Check the user version string for compatibility, returns false if the version
  989  * numbers aren't compatible.
  990  */
  991 PNG_INTERNAL_FUNCTION(int,png_user_version_check,(png_structrp png_ptr,
  992    png_const_charp user_png_ver),PNG_EMPTY);
  993 
  994 /* Internal base allocator - no messages, NULL on failure to allocate.  This
  995  * does, however, call the application provided allocator and that could call
  996  * png_error (although that would be a bug in the application implementation.)
  997  */
  998 PNG_INTERNAL_FUNCTION(png_voidp,png_malloc_base,(png_const_structrp png_ptr,
  999    png_alloc_size_t size),PNG_ALLOCATED);
 1000 
 1001 #if defined(PNG_TEXT_SUPPORTED) || defined(PNG_sPLT_SUPPORTED) ||\
 1002    defined(PNG_STORE_UNKNOWN_CHUNKS_SUPPORTED)
 1003 /* Internal array allocator, outputs no error or warning messages on failure,
 1004  * just returns NULL.
 1005  */
 1006 PNG_INTERNAL_FUNCTION(png_voidp,png_malloc_array,(png_const_structrp png_ptr,
 1007    int nelements, size_t element_size),PNG_ALLOCATED);
 1008 
 1009 /* The same but an existing array is extended by add_elements.  This function
 1010  * also memsets the new elements to 0 and copies the old elements.  The old
 1011  * array is not freed or altered.
 1012  */
 1013 PNG_INTERNAL_FUNCTION(png_voidp,png_realloc_array,(png_const_structrp png_ptr,
 1014    png_const_voidp array, int old_elements, int add_elements,
 1015    size_t element_size),PNG_ALLOCATED);
 1016 #endif /* text, sPLT or unknown chunks */
 1017 
 1018 /* Magic to create a struct when there is no struct to call the user supplied
 1019  * memory allocators.  Because error handling has not been set up the memory
 1020  * handlers can't safely call png_error, but this is an obscure and undocumented
 1021  * restriction so libpng has to assume that the 'free' handler, at least, might
 1022  * call png_error.
 1023  */
 1024 PNG_INTERNAL_FUNCTION(png_structp,png_create_png_struct,
 1025    (png_const_charp user_png_ver, png_voidp error_ptr, png_error_ptr error_fn,
 1026     png_error_ptr warn_fn, png_voidp mem_ptr, png_malloc_ptr malloc_fn,
 1027     png_free_ptr free_fn),PNG_ALLOCATED);
 1028 
 1029 /* Free memory from internal libpng struct */
 1030 PNG_INTERNAL_FUNCTION(void,png_destroy_png_struct,(png_structrp png_ptr),
 1031    PNG_EMPTY);
 1032 
 1033 /* Free an allocated jmp_buf (always succeeds) */
 1034 PNG_INTERNAL_FUNCTION(void,png_free_jmpbuf,(png_structrp png_ptr),PNG_EMPTY);
 1035 
 1036 /* Function to allocate memory for zlib.  PNGAPI is disallowed. */
 1037 PNG_INTERNAL_FUNCTION(voidpf,png_zalloc,(voidpf png_ptr, uInt items, uInt size),
 1038    PNG_ALLOCATED);
 1039 
 1040 /* Function to free memory for zlib.  PNGAPI is disallowed. */
 1041 PNG_INTERNAL_FUNCTION(void,png_zfree,(voidpf png_ptr, voidpf ptr),PNG_EMPTY);
 1042 
 1043 /* Next four functions are used internally as callbacks.  PNGCBAPI is required
 1044  * but not PNG_EXPORT.  PNGAPI added at libpng version 1.2.3, changed to
 1045  * PNGCBAPI at 1.5.0
 1046  */
 1047 
 1048 PNG_INTERNAL_FUNCTION(void PNGCBAPI,png_default_read_data,(png_structp png_ptr,
 1049     png_bytep data, png_size_t length),PNG_EMPTY);
 1050 
 1051 #ifdef PNG_PROGRESSIVE_READ_SUPPORTED
 1052 PNG_INTERNAL_FUNCTION(void PNGCBAPI,png_push_fill_buffer,(png_structp png_ptr,
 1053     png_bytep buffer, png_size_t length),PNG_EMPTY);
 1054 #endif
 1055 
 1056 PNG_INTERNAL_FUNCTION(void PNGCBAPI,png_default_write_data,(png_structp png_ptr,
 1057     png_bytep data, png_size_t length),PNG_EMPTY);
 1058 
 1059 #ifdef PNG_WRITE_FLUSH_SUPPORTED
 1060 #  ifdef PNG_STDIO_SUPPORTED
 1061 PNG_INTERNAL_FUNCTION(void PNGCBAPI,png_default_flush,(png_structp png_ptr),
 1062    PNG_EMPTY);
 1063 #  endif
 1064 #endif
 1065 
 1066 /* Reset the CRC variable */
 1067 PNG_INTERNAL_FUNCTION(void,png_reset_crc,(png_structrp png_ptr),PNG_EMPTY);
 1068 
 1069 /* Write the "data" buffer to whatever output you are using */
 1070 PNG_INTERNAL_FUNCTION(void,png_write_data,(png_structrp png_ptr,
 1071     png_const_bytep data, png_size_t length),PNG_EMPTY);
 1072 
 1073 /* Read and check the PNG file signature */
 1074 PNG_INTERNAL_FUNCTION(void,png_read_sig,(png_structrp png_ptr,
 1075    png_inforp info_ptr),PNG_EMPTY);
 1076 
 1077 /* Read the chunk header (length + type name) */
 1078 PNG_INTERNAL_FUNCTION(png_uint_32,png_read_chunk_header,(png_structrp png_ptr),
 1079    PNG_EMPTY);
 1080 
 1081 /* Read data from whatever input you are using into the "data" buffer */
 1082 PNG_INTERNAL_FUNCTION(void,png_read_data,(png_structrp png_ptr, png_bytep data,
 1083     png_size_t length),PNG_EMPTY);
 1084 
 1085 /* Read bytes into buf, and update png_ptr->crc */
 1086 PNG_INTERNAL_FUNCTION(void,png_crc_read,(png_structrp png_ptr, png_bytep buf,
 1087     png_uint_32 length),PNG_EMPTY);
 1088 
 1089 /* Read "skip" bytes, read the file crc, and (optionally) verify png_ptr->crc */
 1090 PNG_INTERNAL_FUNCTION(int,png_crc_finish,(png_structrp png_ptr,
 1091    png_uint_32 skip),PNG_EMPTY);
 1092 
 1093 /* Read the CRC from the file and compare it to the libpng calculated CRC */
 1094 PNG_INTERNAL_FUNCTION(int,png_crc_error,(png_structrp png_ptr),PNG_EMPTY);
 1095 
 1096 /* Calculate the CRC over a section of data.  Note that we are only
 1097  * passing a maximum of 64K on systems that have this as a memory limit,
 1098  * since this is the maximum buffer size we can specify.
 1099  */
 1100 PNG_INTERNAL_FUNCTION(void,png_calculate_crc,(png_structrp png_ptr,
 1101    png_const_bytep ptr, png_size_t length),PNG_EMPTY);
 1102 
 1103 #ifdef PNG_WRITE_FLUSH_SUPPORTED
 1104 PNG_INTERNAL_FUNCTION(void,png_flush,(png_structrp png_ptr),PNG_EMPTY);
 1105 #endif
 1106 
 1107 /* Write various chunks */
 1108 
 1109 /* Write the IHDR chunk, and update the png_struct with the necessary
 1110  * information.
 1111  */
 1112 PNG_INTERNAL_FUNCTION(void,png_write_IHDR,(png_structrp png_ptr,
 1113    png_uint_32 width, png_uint_32 height, int bit_depth, int color_type,
 1114    int compression_method, int filter_method, int interlace_method),PNG_EMPTY);
 1115 
 1116 PNG_INTERNAL_FUNCTION(void,png_write_PLTE,(png_structrp png_ptr,
 1117    png_const_colorp palette, png_uint_32 num_pal),PNG_EMPTY);
 1118 
 1119 PNG_INTERNAL_FUNCTION(void,png_compress_IDAT,(png_structrp png_ptr,
 1120    png_const_bytep row_data, png_alloc_size_t row_data_length, int flush),
 1121    PNG_EMPTY);
 1122 
 1123 PNG_INTERNAL_FUNCTION(void,png_write_IEND,(png_structrp png_ptr),PNG_EMPTY);
 1124 
 1125 #ifdef PNG_WRITE_gAMA_SUPPORTED
 1126 PNG_INTERNAL_FUNCTION(void,png_write_gAMA_fixed,(png_structrp png_ptr,
 1127     png_fixed_point file_gamma),PNG_EMPTY);
 1128 #endif
 1129 
 1130 #ifdef PNG_WRITE_sBIT_SUPPORTED
 1131 PNG_INTERNAL_FUNCTION(void,png_write_sBIT,(png_structrp png_ptr,
 1132     png_const_color_8p sbit, int color_type),PNG_EMPTY);
 1133 #endif
 1134 
 1135 #ifdef PNG_WRITE_cHRM_SUPPORTED
 1136 PNG_INTERNAL_FUNCTION(void,png_write_cHRM_fixed,(png_structrp png_ptr,
 1137     const png_xy *xy), PNG_EMPTY);
 1138    /* The xy value must have been previously validated */
 1139 #endif
 1140 
 1141 #ifdef PNG_WRITE_sRGB_SUPPORTED
 1142 PNG_INTERNAL_FUNCTION(void,png_write_sRGB,(png_structrp png_ptr,
 1143     int intent),PNG_EMPTY);
 1144 #endif
 1145 
 1146 #ifdef PNG_WRITE_eXIf_SUPPORTED
 1147 PNG_INTERNAL_FUNCTION(void,png_write_eXIf,(png_structrp png_ptr,
 1148     png_bytep exif, int num_exif),PNG_EMPTY);
 1149 #endif
 1150 
 1151 #ifdef PNG_WRITE_iCCP_SUPPORTED
 1152 PNG_INTERNAL_FUNCTION(void,png_write_iCCP,(png_structrp png_ptr,
 1153    png_const_charp name, png_const_bytep profile), PNG_EMPTY);
 1154    /* The profile must have been previously validated for correctness, the
 1155     * length comes from the first four bytes.  Only the base, deflate,
 1156     * compression is supported.
 1157     */
 1158 #endif
 1159 
 1160 #ifdef PNG_WRITE_sPLT_SUPPORTED
 1161 PNG_INTERNAL_FUNCTION(void,png_write_sPLT,(png_structrp png_ptr,
 1162     png_const_sPLT_tp palette),PNG_EMPTY);
 1163 #endif
 1164 
 1165 #ifdef PNG_WRITE_tRNS_SUPPORTED
 1166 PNG_INTERNAL_FUNCTION(void,png_write_tRNS,(png_structrp png_ptr,
 1167     png_const_bytep trans, png_const_color_16p values, int number,
 1168     int color_type),PNG_EMPTY);
 1169 #endif
 1170 
 1171 #ifdef PNG_WRITE_bKGD_SUPPORTED
 1172 PNG_INTERNAL_FUNCTION(void,png_write_bKGD,(png_structrp png_ptr,
 1173     png_const_color_16p values, int color_type),PNG_EMPTY);
 1174 #endif
 1175 
 1176 #ifdef PNG_WRITE_hIST_SUPPORTED
 1177 PNG_INTERNAL_FUNCTION(void,png_write_hIST,(png_structrp png_ptr,
 1178     png_const_uint_16p hist, int num_hist),PNG_EMPTY);
 1179 #endif
 1180 
 1181 /* Chunks that have keywords */
 1182 #ifdef PNG_WRITE_tEXt_SUPPORTED
 1183 PNG_INTERNAL_FUNCTION(void,png_write_tEXt,(png_structrp png_ptr,
 1184    png_const_charp key, png_const_charp text, png_size_t text_len),PNG_EMPTY);
 1185 #endif
 1186 
 1187 #ifdef PNG_WRITE_zTXt_SUPPORTED
 1188 PNG_INTERNAL_FUNCTION(void,png_write_zTXt,(png_structrp png_ptr, png_const_charp
 1189     key, png_const_charp text, int compression),PNG_EMPTY);
 1190 #endif
 1191 
 1192 #ifdef PNG_WRITE_iTXt_SUPPORTED
 1193 PNG_INTERNAL_FUNCTION(void,png_write_iTXt,(png_structrp png_ptr,
 1194     int compression, png_const_charp key, png_const_charp lang,
 1195     png_const_charp lang_key, png_const_charp text),PNG_EMPTY);
 1196 #endif
 1197 
 1198 #ifdef PNG_TEXT_SUPPORTED  /* Added at version 1.0.14 and 1.2.4 */
 1199 PNG_INTERNAL_FUNCTION(int,png_set_text_2,(png_const_structrp png_ptr,
 1200     png_inforp info_ptr, png_const_textp text_ptr, int num_text),PNG_EMPTY);
 1201 #endif
 1202 
 1203 #ifdef PNG_WRITE_oFFs_SUPPORTED
 1204 PNG_INTERNAL_FUNCTION(void,png_write_oFFs,(png_structrp png_ptr,
 1205     png_int_32 x_offset, png_int_32 y_offset, int unit_type),PNG_EMPTY);
 1206 #endif
 1207 
 1208 #ifdef PNG_WRITE_pCAL_SUPPORTED
 1209 PNG_INTERNAL_FUNCTION(void,png_write_pCAL,(png_structrp png_ptr,
 1210     png_charp purpose, png_int_32 X0, png_int_32 X1, int type, int nparams,
 1211     png_const_charp units, png_charpp params),PNG_EMPTY);
 1212 #endif
 1213 
 1214 #ifdef PNG_WRITE_pHYs_SUPPORTED
 1215 PNG_INTERNAL_FUNCTION(void,png_write_pHYs,(png_structrp png_ptr,
 1216     png_uint_32 x_pixels_per_unit, png_uint_32 y_pixels_per_unit,
 1217     int unit_type),PNG_EMPTY);
 1218 #endif
 1219 
 1220 #ifdef PNG_WRITE_tIME_SUPPORTED
 1221 PNG_INTERNAL_FUNCTION(void,png_write_tIME,(png_structrp png_ptr,
 1222     png_const_timep mod_time),PNG_EMPTY);
 1223 #endif
 1224 
 1225 #ifdef PNG_WRITE_sCAL_SUPPORTED
 1226 PNG_INTERNAL_FUNCTION(void,png_write_sCAL_s,(png_structrp png_ptr,
 1227     int unit, png_const_charp width, png_const_charp height),PNG_EMPTY);
 1228 #endif
 1229 
 1230 /* Called when finished processing a row of data */
 1231 PNG_INTERNAL_FUNCTION(void,png_write_finish_row,(png_structrp png_ptr),
 1232     PNG_EMPTY);
 1233 
 1234 /* Internal use only.   Called before first row of data */
 1235 PNG_INTERNAL_FUNCTION(void,png_write_start_row,(png_structrp png_ptr),
 1236     PNG_EMPTY);
 1237 
 1238 /* Combine a row of data, dealing with alpha, etc. if requested.  'row' is an
 1239  * array of png_ptr->width pixels.  If the image is not interlaced or this
 1240  * is the final pass this just does a memcpy, otherwise the "display" flag
 1241  * is used to determine whether to copy pixels that are not in the current pass.
 1242  *
 1243  * Because 'png_do_read_interlace' (below) replicates pixels this allows this
 1244  * function to achieve the documented 'blocky' appearance during interlaced read
 1245  * if display is 1 and the 'sparkle' appearance, where existing pixels in 'row'
 1246  * are not changed if they are not in the current pass, when display is 0.
 1247  *
 1248  * 'display' must be 0 or 1, otherwise the memcpy will be done regardless.
 1249  *
 1250  * The API always reads from the png_struct row buffer and always assumes that
 1251  * it is full width (png_do_read_interlace has already been called.)
 1252  *
 1253  * This function is only ever used to write to row buffers provided by the
 1254  * caller of the relevant libpng API and the row must have already been
 1255  * transformed by the read transformations.
 1256  *
 1257  * The PNG_USE_COMPILE_TIME_MASKS option causes generation of pre-computed
 1258  * bitmasks for use within the code, otherwise runtime generated masks are used.
 1259  * The default is compile time masks.
 1260  */
 1261 #ifndef PNG_USE_COMPILE_TIME_MASKS
 1262 #  define PNG_USE_COMPILE_TIME_MASKS 1
 1263 #endif
 1264 PNG_INTERNAL_FUNCTION(void,png_combine_row,(png_const_structrp png_ptr,
 1265     png_bytep row, int display),PNG_EMPTY);
 1266 
 1267 #ifdef PNG_READ_INTERLACING_SUPPORTED
 1268 /* Expand an interlaced row: the 'row_info' describes the pass data that has
 1269  * been read in and must correspond to the pixels in 'row', the pixels are
 1270  * expanded (moved apart) in 'row' to match the final layout, when doing this
 1271  * the pixels are *replicated* to the intervening space.  This is essential for
 1272  * the correct operation of png_combine_row, above.
 1273  */
 1274 PNG_INTERNAL_FUNCTION(void,png_do_read_interlace,(png_row_infop row_info,
 1275     png_bytep row, int pass, png_uint_32 transformations),PNG_EMPTY);
 1276 #endif
 1277 
 1278 /* GRR TO DO (2.0 or whenever):  simplify other internal calling interfaces */
 1279 
 1280 #ifdef PNG_WRITE_INTERLACING_SUPPORTED
 1281 /* Grab pixels out of a row for an interlaced pass */
 1282 PNG_INTERNAL_FUNCTION(void,png_do_write_interlace,(png_row_infop row_info,
 1283     png_bytep row, int pass),PNG_EMPTY);
 1284 #endif
 1285 
 1286 /* Unfilter a row: check the filter value before calling this, there is no point
 1287  * calling it for PNG_FILTER_VALUE_NONE.
 1288  */
 1289 PNG_INTERNAL_FUNCTION(void,png_read_filter_row,(png_structrp pp, png_row_infop
 1290     row_info, png_bytep row, png_const_bytep prev_row, int filter),PNG_EMPTY);
 1291 
 1292 #if PNG_ARM_NEON_OPT > 0
 1293 PNG_INTERNAL_FUNCTION(void,png_read_filter_row_up_neon,(png_row_infop row_info,
 1294     png_bytep row, png_const_bytep prev_row),PNG_EMPTY);
 1295 PNG_INTERNAL_FUNCTION(void,png_read_filter_row_sub3_neon,(png_row_infop
 1296     row_info, png_bytep row, png_const_bytep prev_row),PNG_EMPTY);
 1297 PNG_INTERNAL_FUNCTION(void,png_read_filter_row_sub4_neon,(png_row_infop
 1298     row_info, png_bytep row, png_const_bytep prev_row),PNG_EMPTY);
 1299 PNG_INTERNAL_FUNCTION(void,png_read_filter_row_avg3_neon,(png_row_infop
 1300     row_info, png_bytep row, png_const_bytep prev_row),PNG_EMPTY);
 1301 PNG_INTERNAL_FUNCTION(void,png_read_filter_row_avg4_neon,(png_row_infop
 1302     row_info, png_bytep row, png_const_bytep prev_row),PNG_EMPTY);
 1303 PNG_INTERNAL_FUNCTION(void,png_read_filter_row_paeth3_neon,(png_row_infop
 1304     row_info, png_bytep row, png_const_bytep prev_row),PNG_EMPTY);
 1305 PNG_INTERNAL_FUNCTION(void,png_read_filter_row_paeth4_neon,(png_row_infop
 1306     row_info, png_bytep row, png_const_bytep prev_row),PNG_EMPTY);
 1307 #endif
 1308 
 1309 #if PNG_MIPS_MSA_OPT > 0
 1310 PNG_INTERNAL_FUNCTION(void,png_read_filter_row_up_msa,(png_row_infop row_info,
 1311     png_bytep row, png_const_bytep prev_row),PNG_EMPTY);
 1312 PNG_INTERNAL_FUNCTION(void,png_read_filter_row_sub3_msa,(png_row_infop
 1313     row_info, png_bytep row, png_const_bytep prev_row),PNG_EMPTY);
 1314 PNG_INTERNAL_FUNCTION(void,png_read_filter_row_sub4_msa,(png_row_infop
 1315     row_info, png_bytep row, png_const_bytep prev_row),PNG_EMPTY);
 1316 PNG_INTERNAL_FUNCTION(void,png_read_filter_row_avg3_msa,(png_row_infop
 1317     row_info, png_bytep row, png_const_bytep prev_row),PNG_EMPTY);
 1318 PNG_INTERNAL_FUNCTION(void,png_read_filter_row_avg4_msa,(png_row_infop
 1319     row_info, png_bytep row, png_const_bytep prev_row),PNG_EMPTY);
 1320 PNG_INTERNAL_FUNCTION(void,png_read_filter_row_paeth3_msa,(png_row_infop
 1321     row_info, png_bytep row, png_const_bytep prev_row),PNG_EMPTY);
 1322 PNG_INTERNAL_FUNCTION(void,png_read_filter_row_paeth4_msa,(png_row_infop
 1323     row_info, png_bytep row, png_const_bytep prev_row),PNG_EMPTY);
 1324 #endif
 1325 
 1326 #if PNG_POWERPC_VSX_OPT > 0
 1327 PNG_INTERNAL_FUNCTION(void,png_read_filter_row_up_vsx,(png_row_infop row_info,
 1328     png_bytep row, png_const_bytep prev_row),PNG_EMPTY);
 1329 PNG_INTERNAL_FUNCTION(void,png_read_filter_row_sub3_vsx,(png_row_infop
 1330     row_info, png_bytep row, png_const_bytep prev_row),PNG_EMPTY);
 1331 PNG_INTERNAL_FUNCTION(void,png_read_filter_row_sub4_vsx,(png_row_infop
 1332     row_info, png_bytep row, png_const_bytep prev_row),PNG_EMPTY);
 1333 PNG_INTERNAL_FUNCTION(void,png_read_filter_row_avg3_vsx,(png_row_infop
 1334     row_info, png_bytep row, png_const_bytep prev_row),PNG_EMPTY);
 1335 PNG_INTERNAL_FUNCTION(void,png_read_filter_row_avg4_vsx,(png_row_infop
 1336     row_info, png_bytep row, png_const_bytep prev_row),PNG_EMPTY);
 1337 PNG_INTERNAL_FUNCTION(void,png_read_filter_row_paeth3_vsx,(png_row_infop
 1338     row_info, png_bytep row, png_const_bytep prev_row),PNG_EMPTY);
 1339 PNG_INTERNAL_FUNCTION(void,png_read_filter_row_paeth4_vsx,(png_row_infop
 1340     row_info, png_bytep row, png_const_bytep prev_row),PNG_EMPTY);
 1341 #endif
 1342 
 1343 #if PNG_INTEL_SSE_IMPLEMENTATION > 0
 1344 PNG_INTERNAL_FUNCTION(void,png_read_filter_row_sub3_sse2,(png_row_infop
 1345     row_info, png_bytep row, png_const_bytep prev_row),PNG_EMPTY);
 1346 PNG_INTERNAL_FUNCTION(void,png_read_filter_row_sub4_sse2,(png_row_infop
 1347     row_info, png_bytep row, png_const_bytep prev_row),PNG_EMPTY);
 1348 PNG_INTERNAL_FUNCTION(void,png_read_filter_row_avg3_sse2,(png_row_infop
 1349     row_info, png_bytep row, png_const_bytep prev_row),PNG_EMPTY);
 1350 PNG_INTERNAL_FUNCTION(void,png_read_filter_row_avg4_sse2,(png_row_infop
 1351     row_info, png_bytep row, png_const_bytep prev_row),PNG_EMPTY);
 1352 PNG_INTERNAL_FUNCTION(void,png_read_filter_row_paeth3_sse2,(png_row_infop
 1353     row_info, png_bytep row, png_const_bytep prev_row),PNG_EMPTY);
 1354 PNG_INTERNAL_FUNCTION(void,png_read_filter_row_paeth4_sse2,(png_row_infop
 1355     row_info, png_bytep row, png_const_bytep prev_row),PNG_EMPTY);
 1356 #endif
 1357 
 1358 /* Choose the best filter to use and filter the row data */
 1359 PNG_INTERNAL_FUNCTION(void,png_write_find_filter,(png_structrp png_ptr,
 1360     png_row_infop row_info),PNG_EMPTY);
 1361 
 1362 #ifdef PNG_SEQUENTIAL_READ_SUPPORTED
 1363 PNG_INTERNAL_FUNCTION(void,png_read_IDAT_data,(png_structrp png_ptr,
 1364    png_bytep output, png_alloc_size_t avail_out),PNG_EMPTY);
 1365    /* Read 'avail_out' bytes of data from the IDAT stream.  If the output buffer
 1366     * is NULL the function checks, instead, for the end of the stream.  In this
 1367     * case a benign error will be issued if the stream end is not found or if
 1368     * extra data has to be consumed.
 1369     */
 1370 PNG_INTERNAL_FUNCTION(void,png_read_finish_IDAT,(png_structrp png_ptr),
 1371    PNG_EMPTY);
 1372    /* This cleans up when the IDAT LZ stream does not end when the last image
 1373     * byte is read; there is still some pending input.
 1374     */
 1375 
 1376 PNG_INTERNAL_FUNCTION(void,png_read_finish_row,(png_structrp png_ptr),
 1377    PNG_EMPTY);
 1378    /* Finish a row while reading, dealing with interlacing passes, etc. */
 1379 #endif /* SEQUENTIAL_READ */
 1380 
 1381 /* Initialize the row buffers, etc. */
 1382 PNG_INTERNAL_FUNCTION(void,png_read_start_row,(png_structrp png_ptr),PNG_EMPTY);
 1383 
 1384 #if ZLIB_VERNUM >= 0x1240
 1385 PNG_INTERNAL_FUNCTION(int,png_zlib_inflate,(png_structrp png_ptr, int flush),
 1386       PNG_EMPTY);
 1387 #  define PNG_INFLATE(pp, flush) png_zlib_inflate(pp, flush)
 1388 #else /* Zlib < 1.2.4 */
 1389 #  define PNG_INFLATE(pp, flush) inflate(&(pp)->zstream, flush)
 1390 #endif /* Zlib < 1.2.4 */
 1391 
 1392 #ifdef PNG_READ_TRANSFORMS_SUPPORTED
 1393 /* Optional call to update the users info structure */
 1394 PNG_INTERNAL_FUNCTION(void,png_read_transform_info,(png_structrp png_ptr,
 1395     png_inforp info_ptr),PNG_EMPTY);
 1396 #endif
 1397 
 1398 /* Shared transform functions, defined in pngtran.c */
 1399 #if defined(PNG_WRITE_FILLER_SUPPORTED) || \
 1400     defined(PNG_READ_STRIP_ALPHA_SUPPORTED)
 1401 PNG_INTERNAL_FUNCTION(void,png_do_strip_channel,(png_row_infop row_info,
 1402     png_bytep row, int at_start),PNG_EMPTY);
 1403 #endif
 1404 
 1405 #ifdef PNG_16BIT_SUPPORTED
 1406 #if defined(PNG_READ_SWAP_SUPPORTED) || defined(PNG_WRITE_SWAP_SUPPORTED)
 1407 PNG_INTERNAL_FUNCTION(void,png_do_swap,(png_row_infop row_info,
 1408     png_bytep row),PNG_EMPTY);
 1409 #endif
 1410 #endif
 1411 
 1412 #if defined(PNG_READ_PACKSWAP_SUPPORTED) || \
 1413     defined(PNG_WRITE_PACKSWAP_SUPPORTED)
 1414 PNG_INTERNAL_FUNCTION(void,png_do_packswap,(png_row_infop row_info,
 1415     png_bytep row),PNG_EMPTY);
 1416 #endif
 1417 
 1418 #if defined(PNG_READ_INVERT_SUPPORTED) || defined(PNG_WRITE_INVERT_SUPPORTED)
 1419 PNG_INTERNAL_FUNCTION(void,png_do_invert,(png_row_infop row_info,
 1420     png_bytep row),PNG_EMPTY);
 1421 #endif
 1422 
 1423 #if defined(PNG_READ_BGR_SUPPORTED) || defined(PNG_WRITE_BGR_SUPPORTED)
 1424 PNG_INTERNAL_FUNCTION(void,png_do_bgr,(png_row_infop row_info,
 1425     png_bytep row),PNG_EMPTY);
 1426 #endif
 1427 
 1428 /* The following decodes the appropriate chunks, and does error correction,
 1429  * then calls the appropriate callback for the chunk if it is valid.
 1430  */
 1431 
 1432 /* Decode the IHDR chunk */
 1433 PNG_INTERNAL_FUNCTION(void,png_handle_IHDR,(png_structrp png_ptr,
 1434     png_inforp info_ptr, png_uint_32 length),PNG_EMPTY);
 1435 PNG_INTERNAL_FUNCTION(void,png_handle_PLTE,(png_structrp png_ptr,
 1436     png_inforp info_ptr, png_uint_32 length),PNG_EMPTY);
 1437 PNG_INTERNAL_FUNCTION(void,png_handle_IEND,(png_structrp png_ptr,
 1438     png_inforp info_ptr, png_uint_32 length),PNG_EMPTY);
 1439 
 1440 #ifdef PNG_READ_bKGD_SUPPORTED
 1441 PNG_INTERNAL_FUNCTION(void,png_handle_bKGD,(png_structrp png_ptr,
 1442     png_inforp info_ptr, png_uint_32 length),PNG_EMPTY);
 1443 #endif
 1444 
 1445 #ifdef PNG_READ_cHRM_SUPPORTED
 1446 PNG_INTERNAL_FUNCTION(void,png_handle_cHRM,(png_structrp png_ptr,
 1447     png_inforp info_ptr, png_uint_32 length),PNG_EMPTY);
 1448 #endif
 1449 
 1450 #ifdef PNG_READ_eXIf_SUPPORTED
 1451 PNG_INTERNAL_FUNCTION(void,png_handle_eXIf,(png_structrp png_ptr,
 1452     png_inforp info_ptr, png_uint_32 length),PNG_EMPTY);
 1453 #endif
 1454 
 1455 #ifdef PNG_READ_gAMA_SUPPORTED
 1456 PNG_INTERNAL_FUNCTION(void,png_handle_gAMA,(png_structrp png_ptr,
 1457     png_inforp info_ptr, png_uint_32 length),PNG_EMPTY);
 1458 #endif
 1459 
 1460 #ifdef PNG_READ_hIST_SUPPORTED
 1461 PNG_INTERNAL_FUNCTION(void,png_handle_hIST,(png_structrp png_ptr,
 1462     png_inforp info_ptr, png_uint_32 length),PNG_EMPTY);
 1463 #endif
 1464 
 1465 #ifdef PNG_READ_iCCP_SUPPORTED
 1466 PNG_INTERNAL_FUNCTION(void,png_handle_iCCP,(png_structrp png_ptr,
 1467     png_inforp info_ptr, png_uint_32 length),PNG_EMPTY);
 1468 #endif /* READ_iCCP */
 1469 
 1470 #ifdef PNG_READ_iTXt_SUPPORTED
 1471 PNG_INTERNAL_FUNCTION(void,png_handle_iTXt,(png_structrp png_ptr,
 1472     png_inforp info_ptr, png_uint_32 length),PNG_EMPTY);
 1473 #endif
 1474 
 1475 #ifdef PNG_READ_oFFs_SUPPORTED
 1476 PNG_INTERNAL_FUNCTION(void,png_handle_oFFs,(png_structrp png_ptr,
 1477     png_inforp info_ptr, png_uint_32 length),PNG_EMPTY);
 1478 #endif
 1479 
 1480 #ifdef PNG_READ_pCAL_SUPPORTED
 1481 PNG_INTERNAL_FUNCTION(void,png_handle_pCAL,(png_structrp png_ptr,
 1482     png_inforp info_ptr, png_uint_32 length),PNG_EMPTY);
 1483 #endif
 1484 
 1485 #ifdef PNG_READ_pHYs_SUPPORTED
 1486 PNG_INTERNAL_FUNCTION(void,png_handle_pHYs,(png_structrp png_ptr,
 1487     png_inforp info_ptr, png_uint_32 length),PNG_EMPTY);
 1488 #endif
 1489 
 1490 #ifdef PNG_READ_sBIT_SUPPORTED
 1491 PNG_INTERNAL_FUNCTION(void,png_handle_sBIT,(png_structrp png_ptr,
 1492     png_inforp info_ptr, png_uint_32 length),PNG_EMPTY);
 1493 #endif
 1494 
 1495 #ifdef PNG_READ_sCAL_SUPPORTED
 1496 PNG_INTERNAL_FUNCTION(void,png_handle_sCAL,(png_structrp png_ptr,
 1497     png_inforp info_ptr, png_uint_32 length),PNG_EMPTY);
 1498 #endif
 1499 
 1500 #ifdef PNG_READ_sPLT_SUPPORTED
 1501 PNG_INTERNAL_FUNCTION(void,png_handle_sPLT,(png_structrp png_ptr,
 1502     png_inforp info_ptr, png_uint_32 length),PNG_EMPTY);
 1503 #endif /* READ_sPLT */
 1504 
 1505 #ifdef PNG_READ_sRGB_SUPPORTED
 1506 PNG_INTERNAL_FUNCTION(void,png_handle_sRGB,(png_structrp png_ptr,
 1507     png_inforp info_ptr, png_uint_32 length),PNG_EMPTY);
 1508 #endif
 1509 
 1510 #ifdef PNG_READ_tEXt_SUPPORTED
 1511 PNG_INTERNAL_FUNCTION(void,png_handle_tEXt,(png_structrp png_ptr,
 1512     png_inforp info_ptr, png_uint_32 length),PNG_EMPTY);
 1513 #endif
 1514 
 1515 #ifdef PNG_READ_tIME_SUPPORTED
 1516 PNG_INTERNAL_FUNCTION(void,png_handle_tIME,(png_structrp png_ptr,
 1517     png_inforp info_ptr, png_uint_32 length),PNG_EMPTY);
 1518 #endif
 1519 
 1520 #ifdef PNG_READ_tRNS_SUPPORTED
 1521 PNG_INTERNAL_FUNCTION(void,png_handle_tRNS,(png_structrp png_ptr,
 1522     png_inforp info_ptr, png_uint_32 length),PNG_EMPTY);
 1523 #endif
 1524 
 1525 #ifdef PNG_READ_zTXt_SUPPORTED
 1526 PNG_INTERNAL_FUNCTION(void,png_handle_zTXt,(png_structrp png_ptr,
 1527     png_inforp info_ptr, png_uint_32 length),PNG_EMPTY);
 1528 #endif
 1529 
 1530 PNG_INTERNAL_FUNCTION(void,png_check_chunk_name,(png_const_structrp png_ptr,
 1531     const png_uint_32 chunk_name),PNG_EMPTY);
 1532 
 1533 PNG_INTERNAL_FUNCTION(void,png_check_chunk_length,(png_const_structrp png_ptr,
 1534     const png_uint_32 chunk_length),PNG_EMPTY);
 1535 
 1536 PNG_INTERNAL_FUNCTION(void,png_handle_unknown,(png_structrp png_ptr,
 1537     png_inforp info_ptr, png_uint_32 length, int keep),PNG_EMPTY);
 1538    /* This is the function that gets called for unknown chunks.  The 'keep'
 1539     * argument is either non-zero for a known chunk that has been set to be
 1540     * handled as unknown or zero for an unknown chunk.  By default the function
 1541     * just skips the chunk or errors out if it is critical.
 1542     */
 1543 
 1544 #if defined(PNG_READ_UNKNOWN_CHUNKS_SUPPORTED) ||\
 1545     defined(PNG_HANDLE_AS_UNKNOWN_SUPPORTED)
 1546 PNG_INTERNAL_FUNCTION(int,png_chunk_unknown_handling,
 1547     (png_const_structrp png_ptr, png_uint_32 chunk_name),PNG_EMPTY);
 1548    /* Exactly as the API png_handle_as_unknown() except that the argument is a
 1549     * 32-bit chunk name, not a string.
 1550     */
 1551 #endif /* READ_UNKNOWN_CHUNKS || HANDLE_AS_UNKNOWN */
 1552 
 1553 /* Handle the transformations for reading and writing */
 1554 #ifdef PNG_READ_TRANSFORMS_SUPPORTED
 1555 PNG_INTERNAL_FUNCTION(void,png_do_read_transformations,(png_structrp png_ptr,
 1556    png_row_infop row_info),PNG_EMPTY);
 1557 #endif
 1558 #ifdef PNG_WRITE_TRANSFORMS_SUPPORTED
 1559 PNG_INTERNAL_FUNCTION(void,png_do_write_transformations,(png_structrp png_ptr,
 1560    png_row_infop row_info),PNG_EMPTY);
 1561 #endif
 1562 
 1563 #ifdef PNG_READ_TRANSFORMS_SUPPORTED
 1564 PNG_INTERNAL_FUNCTION(void,png_init_read_transformations,(png_structrp png_ptr),
 1565     PNG_EMPTY);
 1566 #endif
 1567 
 1568 #ifdef PNG_PROGRESSIVE_READ_SUPPORTED
 1569 PNG_INTERNAL_FUNCTION(void,png_push_read_chunk,(png_structrp png_ptr,
 1570     png_inforp info_ptr),PNG_EMPTY);
 1571 PNG_INTERNAL_FUNCTION(void,png_push_read_sig,(png_structrp png_ptr,
 1572     png_inforp info_ptr),PNG_EMPTY);
 1573 PNG_INTERNAL_FUNCTION(void,png_push_check_crc,(png_structrp png_ptr),PNG_EMPTY);
 1574 PNG_INTERNAL_FUNCTION(void,png_push_save_buffer,(png_structrp png_ptr),
 1575     PNG_EMPTY);
 1576 PNG_INTERNAL_FUNCTION(void,png_push_restore_buffer,(png_structrp png_ptr,
 1577     png_bytep buffer, png_size_t buffer_length),PNG_EMPTY);
 1578 PNG_INTERNAL_FUNCTION(void,png_push_read_IDAT,(png_structrp png_ptr),PNG_EMPTY);
 1579 PNG_INTERNAL_FUNCTION(void,png_process_IDAT_data,(png_structrp png_ptr,
 1580     png_bytep buffer, png_size_t buffer_length),PNG_EMPTY);
 1581 PNG_INTERNAL_FUNCTION(void,png_push_process_row,(png_structrp png_ptr),
 1582     PNG_EMPTY);
 1583 PNG_INTERNAL_FUNCTION(void,png_push_handle_unknown,(png_structrp png_ptr,
 1584    png_inforp info_ptr, png_uint_32 length),PNG_EMPTY);
 1585 PNG_INTERNAL_FUNCTION(void,png_push_have_info,(png_structrp png_ptr,
 1586    png_inforp info_ptr),PNG_EMPTY);
 1587 PNG_INTERNAL_FUNCTION(void,png_push_have_end,(png_structrp png_ptr,
 1588    png_inforp info_ptr),PNG_EMPTY);
 1589 PNG_INTERNAL_FUNCTION(void,png_push_have_row,(png_structrp png_ptr,
 1590     png_bytep row),PNG_EMPTY);
 1591 PNG_INTERNAL_FUNCTION(void,png_push_read_end,(png_structrp png_ptr,
 1592     png_inforp info_ptr),PNG_EMPTY);
 1593 PNG_INTERNAL_FUNCTION(void,png_process_some_data,(png_structrp png_ptr,
 1594     png_inforp info_ptr),PNG_EMPTY);
 1595 PNG_INTERNAL_FUNCTION(void,png_read_push_finish_row,(png_structrp png_ptr),
 1596     PNG_EMPTY);
 1597 #  ifdef PNG_READ_tEXt_SUPPORTED
 1598 PNG_INTERNAL_FUNCTION(void,png_push_handle_tEXt,(png_structrp png_ptr,
 1599     png_inforp info_ptr, png_uint_32 length),PNG_EMPTY);
 1600 PNG_INTERNAL_FUNCTION(void,png_push_read_tEXt,(png_structrp png_ptr,
 1601     png_inforp info_ptr),PNG_EMPTY);
 1602 #  endif
 1603 #  ifdef PNG_READ_zTXt_SUPPORTED
 1604 PNG_INTERNAL_FUNCTION(void,png_push_handle_zTXt,(png_structrp png_ptr,
 1605     png_inforp info_ptr, png_uint_32 length),PNG_EMPTY);
 1606 PNG_INTERNAL_FUNCTION(void,png_push_read_zTXt,(png_structrp png_ptr,
 1607     png_inforp info_ptr),PNG_EMPTY);
 1608 #  endif
 1609 #  ifdef PNG_READ_iTXt_SUPPORTED
 1610 PNG_INTERNAL_FUNCTION(void,png_push_handle_iTXt,(png_structrp png_ptr,
 1611     png_inforp info_ptr, png_uint_32 length),PNG_EMPTY);
 1612 PNG_INTERNAL_FUNCTION(void,png_push_read_iTXt,(png_structrp png_ptr,
 1613     png_inforp info_ptr),PNG_EMPTY);
 1614 #  endif
 1615 
 1616 #endif /* PROGRESSIVE_READ */
 1617 
 1618 /* Added at libpng version 1.6.0 */
 1619 #ifdef PNG_GAMMA_SUPPORTED
 1620 PNG_INTERNAL_FUNCTION(void,png_colorspace_set_gamma,(png_const_structrp png_ptr,
 1621     png_colorspacerp colorspace, png_fixed_point gAMA), PNG_EMPTY);
 1622    /* Set the colorspace gamma with a value provided by the application or by
 1623     * the gAMA chunk on read.  The value will override anything set by an ICC
 1624     * profile.
 1625     */
 1626 
 1627 PNG_INTERNAL_FUNCTION(void,png_colorspace_sync_info,(png_const_structrp png_ptr,
 1628     png_inforp info_ptr), PNG_EMPTY);
 1629    /* Synchronize the info 'valid' flags with the colorspace */
 1630 
 1631 PNG_INTERNAL_FUNCTION(void,png_colorspace_sync,(png_const_structrp png_ptr,
 1632     png_inforp info_ptr), PNG_EMPTY);
 1633    /* Copy the png_struct colorspace to the info_struct and call the above to
 1634     * synchronize the flags.  Checks for NULL info_ptr and does nothing.
 1635     */
 1636 #endif
 1637 
 1638 /* Added at libpng version 1.4.0 */
 1639 #ifdef PNG_COLORSPACE_SUPPORTED
 1640 /* These internal functions are for maintaining the colorspace structure within
 1641  * a png_info or png_struct (or, indeed, both).
 1642  */
 1643 PNG_INTERNAL_FUNCTION(int,png_colorspace_set_chromaticities,
 1644    (png_const_structrp png_ptr, png_colorspacerp colorspace, const png_xy *xy,
 1645     int preferred), PNG_EMPTY);
 1646 
 1647 PNG_INTERNAL_FUNCTION(int,png_colorspace_set_endpoints,
 1648    (png_const_structrp png_ptr, png_colorspacerp colorspace, const png_XYZ *XYZ,
 1649     int preferred), PNG_EMPTY);
 1650 
 1651 #ifdef PNG_sRGB_SUPPORTED
 1652 PNG_INTERNAL_FUNCTION(int,png_colorspace_set_sRGB,(png_const_structrp png_ptr,
 1653    png_colorspacerp colorspace, int intent), PNG_EMPTY);
 1654    /* This does set the colorspace gAMA and cHRM values too, but doesn't set the
 1655     * flags to write them, if it returns false there was a problem and an error
 1656     * message has already been output (but the colorspace may still need to be
 1657     * synced to record the invalid flag).
 1658     */
 1659 #endif /* sRGB */
 1660 
 1661 #ifdef PNG_iCCP_SUPPORTED
 1662 PNG_INTERNAL_FUNCTION(int,png_colorspace_set_ICC,(png_const_structrp png_ptr,
 1663    png_colorspacerp colorspace, png_const_charp name,
 1664    png_uint_32 profile_length, png_const_bytep profile, int color_type),
 1665    PNG_EMPTY);
 1666    /* The 'name' is used for information only */
 1667 
 1668 /* Routines for checking parts of an ICC profile. */
 1669 #ifdef PNG_READ_iCCP_SUPPORTED
 1670 PNG_INTERNAL_FUNCTION(int,png_icc_check_length,(png_const_structrp png_ptr,
 1671    png_colorspacerp colorspace, png_const_charp name,
 1672    png_uint_32 profile_length), PNG_EMPTY);
 1673 #endif /* READ_iCCP */
 1674 PNG_INTERNAL_FUNCTION(int,png_icc_check_header,(png_const_structrp png_ptr,
 1675    png_colorspacerp colorspace, png_const_charp name,
 1676    png_uint_32 profile_length,
 1677    png_const_bytep profile /* first 132 bytes only */, int color_type),
 1678    PNG_EMPTY);
 1679 PNG_INTERNAL_FUNCTION(int,png_icc_check_tag_table,(png_const_structrp png_ptr,
 1680    png_colorspacerp colorspace, png_const_charp name,
 1681    png_uint_32 profile_length,
 1682    png_const_bytep profile /* header plus whole tag table */), PNG_EMPTY);
 1683 #ifdef PNG_sRGB_SUPPORTED
 1684 PNG_INTERNAL_FUNCTION(void,png_icc_set_sRGB,(
 1685    png_const_structrp png_ptr, png_colorspacerp colorspace,
 1686    png_const_bytep profile, uLong adler), PNG_EMPTY);
 1687    /* 'adler' is the Adler32 checksum of the uncompressed profile data. It may
 1688     * be zero to indicate that it is not available.  It is used, if provided,
 1689     * as a fast check on the profile when checking to see if it is sRGB.
 1690     */
 1691 #endif
 1692 #endif /* iCCP */
 1693 
 1694 #ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED
 1695 PNG_INTERNAL_FUNCTION(void,png_colorspace_set_rgb_coefficients,
 1696    (png_structrp png_ptr), PNG_EMPTY);
 1697    /* Set the rgb_to_gray coefficients from the colorspace Y values */
 1698 #endif /* READ_RGB_TO_GRAY */
 1699 #endif /* COLORSPACE */
 1700 
 1701 /* Added at libpng version 1.4.0 */
 1702 PNG_INTERNAL_FUNCTION(void,png_check_IHDR,(png_const_structrp png_ptr,
 1703     png_uint_32 width, png_uint_32 height, int bit_depth,
 1704     int color_type, int interlace_type, int compression_type,
 1705     int filter_type),PNG_EMPTY);
 1706 
 1707 /* Added at libpng version 1.5.10 */
 1708 #if defined(PNG_READ_CHECK_FOR_INVALID_INDEX_SUPPORTED) || \
 1709     defined(PNG_WRITE_CHECK_FOR_INVALID_INDEX_SUPPORTED)
 1710 PNG_INTERNAL_FUNCTION(void,png_do_check_palette_indexes,
 1711    (png_structrp png_ptr, png_row_infop row_info),PNG_EMPTY);
 1712 #endif
 1713 
 1714 #if defined(PNG_FLOATING_POINT_SUPPORTED) && defined(PNG_ERROR_TEXT_SUPPORTED)
 1715 PNG_INTERNAL_FUNCTION(void,png_fixed_error,(png_const_structrp png_ptr,
 1716    png_const_charp name),PNG_NORETURN);
 1717 #endif
 1718 
 1719 /* Puts 'string' into 'buffer' at buffer[pos], taking care never to overwrite
 1720  * the end.  Always leaves the buffer nul terminated.  Never errors out (and
 1721  * there is no error code.)
 1722  */
 1723 PNG_INTERNAL_FUNCTION(size_t,png_safecat,(png_charp buffer, size_t bufsize,
 1724    size_t pos, png_const_charp string),PNG_EMPTY);
 1725 
 1726 /* Various internal functions to handle formatted warning messages, currently
 1727  * only implemented for warnings.
 1728  */
 1729 #if defined(PNG_WARNINGS_SUPPORTED) || defined(PNG_TIME_RFC1123_SUPPORTED)
 1730 /* Utility to dump an unsigned value into a buffer, given a start pointer and
 1731  * and end pointer (which should point just *beyond* the end of the buffer!)
 1732  * Returns the pointer to the start of the formatted string.  This utility only
 1733  * does unsigned values.
 1734  */
 1735 PNG_INTERNAL_FUNCTION(png_charp,png_format_number,(png_const_charp start,
 1736    png_charp end, int format, png_alloc_size_t number),PNG_EMPTY);
 1737 
 1738 /* Convenience macro that takes an array: */
 1739 #define PNG_FORMAT_NUMBER(buffer,format,number) \
 1740    png_format_number(buffer, buffer + (sizeof buffer), format, number)
 1741 
 1742 /* Suggested size for a number buffer (enough for 64 bits and a sign!) */
 1743 #define PNG_NUMBER_BUFFER_SIZE 24
 1744 
 1745 /* These are the integer formats currently supported, the name is formed from
 1746  * the standard printf(3) format string.
 1747  */
 1748 #define PNG_NUMBER_FORMAT_u     1 /* chose unsigned API! */
 1749 #define PNG_NUMBER_FORMAT_02u   2
 1750 #define PNG_NUMBER_FORMAT_d     1 /* chose signed API! */
 1751 #define PNG_NUMBER_FORMAT_02d   2
 1752 #define PNG_NUMBER_FORMAT_x     3
 1753 #define PNG_NUMBER_FORMAT_02x   4
 1754 #define PNG_NUMBER_FORMAT_fixed 5 /* choose the signed API */
 1755 #endif
 1756 
 1757 #ifdef PNG_WARNINGS_SUPPORTED
 1758 /* New defines and members adding in libpng-1.5.4 */
 1759 #  define PNG_WARNING_PARAMETER_SIZE 32
 1760 #  define PNG_WARNING_PARAMETER_COUNT 8 /* Maximum 9; see pngerror.c */
 1761 
 1762 /* An l-value of this type has to be passed to the APIs below to cache the
 1763  * values of the parameters to a formatted warning message.
 1764  */
 1765 typedef char png_warning_parameters[PNG_WARNING_PARAMETER_COUNT][
 1766    PNG_WARNING_PARAMETER_SIZE];
 1767 
 1768 PNG_INTERNAL_FUNCTION(void,png_warning_parameter,(png_warning_parameters p,
 1769    int number, png_const_charp string),PNG_EMPTY);
 1770    /* Parameters are limited in size to PNG_WARNING_PARAMETER_SIZE characters,
 1771     * including the trailing '\0'.
 1772     */
 1773 PNG_INTERNAL_FUNCTION(void,png_warning_parameter_unsigned,
 1774    (png_warning_parameters p, int number, int format, png_alloc_size_t value),
 1775    PNG_EMPTY);
 1776    /* Use png_alloc_size_t because it is an unsigned type as big as any we
 1777     * need to output.  Use the following for a signed value.
 1778     */
 1779 PNG_INTERNAL_FUNCTION(void,png_warning_parameter_signed,
 1780    (png_warning_parameters p, int number, int format, png_int_32 value),
 1781    PNG_EMPTY);
 1782 
 1783 PNG_INTERNAL_FUNCTION(void,png_formatted_warning,(png_const_structrp png_ptr,
 1784    png_warning_parameters p, png_const_charp message),PNG_EMPTY);
 1785    /* 'message' follows the X/Open approach of using @1, @2 to insert
 1786     * parameters previously supplied using the above functions.  Errors in
 1787     * specifying the parameters will simply result in garbage substitutions.
 1788     */
 1789 #endif
 1790 
 1791 #ifdef PNG_BENIGN_ERRORS_SUPPORTED
 1792 /* Application errors (new in 1.6); use these functions (declared below) for
 1793  * errors in the parameters or order of API function calls on read.  The
 1794  * 'warning' should be used for an error that can be handled completely; the
 1795  * 'error' for one which can be handled safely but which may lose application
 1796  * information or settings.
 1797  *
 1798  * By default these both result in a png_error call prior to release, while in a
 1799  * released version the 'warning' is just a warning.  However if the application
 1800  * explicitly disables benign errors (explicitly permitting the code to lose
 1801  * information) they both turn into warnings.
 1802  *
 1803  * If benign errors aren't supported they end up as the corresponding base call
 1804  * (png_warning or png_error.)
 1805  */
 1806 PNG_INTERNAL_FUNCTION(void,png_app_warning,(png_const_structrp png_ptr,
 1807    png_const_charp message),PNG_EMPTY);
 1808    /* The application provided invalid parameters to an API function or called
 1809     * an API function at the wrong time, libpng can completely recover.
 1810     */
 1811 
 1812 PNG_INTERNAL_FUNCTION(void,png_app_error,(png_const_structrp png_ptr,
 1813    png_const_charp message),PNG_EMPTY);
 1814    /* As above but libpng will ignore the call, or attempt some other partial
 1815     * recovery from the error.
 1816     */
 1817 #else
 1818 #  define png_app_warning(pp,s) png_warning(pp,s)
 1819 #  define png_app_error(pp,s) png_error(pp,s)
 1820 #endif
 1821 
 1822 PNG_INTERNAL_FUNCTION(void,png_chunk_report,(png_const_structrp png_ptr,
 1823    png_const_charp message, int error),PNG_EMPTY);
 1824    /* Report a recoverable issue in chunk data.  On read this is used to report
 1825     * a problem found while reading a particular chunk and the
 1826     * png_chunk_benign_error or png_chunk_warning function is used as
 1827     * appropriate.  On write this is used to report an error that comes from
 1828     * data set via an application call to a png_set_ API and png_app_error or
 1829     * png_app_warning is used as appropriate.
 1830     *
 1831     * The 'error' parameter must have one of the following values:
 1832     */
 1833 #define PNG_CHUNK_WARNING     0 /* never an error */
 1834 #define PNG_CHUNK_WRITE_ERROR 1 /* an error only on write */
 1835 #define PNG_CHUNK_ERROR       2 /* always an error */
 1836 
 1837 /* ASCII to FP interfaces, currently only implemented if sCAL
 1838  * support is required.
 1839  */
 1840 #if defined(PNG_sCAL_SUPPORTED)
 1841 /* MAX_DIGITS is actually the maximum number of characters in an sCAL
 1842  * width or height, derived from the precision (number of significant
 1843  * digits - a build time settable option) and assumptions about the
 1844  * maximum ridiculous exponent.
 1845  */
 1846 #define PNG_sCAL_MAX_DIGITS (PNG_sCAL_PRECISION+1/*.*/+1/*E*/+10/*exponent*/)
 1847 
 1848 #ifdef PNG_FLOATING_POINT_SUPPORTED
 1849 PNG_INTERNAL_FUNCTION(void,png_ascii_from_fp,(png_const_structrp png_ptr,
 1850    png_charp ascii, png_size_t size, double fp, unsigned int precision),
 1851    PNG_EMPTY);
 1852 #endif /* FLOATING_POINT */
 1853 
 1854 #ifdef PNG_FIXED_POINT_SUPPORTED
 1855 PNG_INTERNAL_FUNCTION(void,png_ascii_from_fixed,(png_const_structrp png_ptr,
 1856    png_charp ascii, png_size_t size, png_fixed_point fp),PNG_EMPTY);
 1857 #endif /* FIXED_POINT */
 1858 #endif /* sCAL */
 1859 
 1860 #if defined(PNG_sCAL_SUPPORTED) || defined(PNG_pCAL_SUPPORTED)
 1861 /* An internal API to validate the format of a floating point number.
 1862  * The result is the index of the next character.  If the number is
 1863  * not valid it will be the index of a character in the supposed number.
 1864  *
 1865  * The format of a number is defined in the PNG extensions specification
 1866  * and this API is strictly conformant to that spec, not anyone elses!
 1867  *
 1868  * The format as a regular expression is:
 1869  *
 1870  * [+-]?[0-9]+.?([Ee][+-]?[0-9]+)?
 1871  *
 1872  * or:
 1873  *
 1874  * [+-]?.[0-9]+(.[0-9]+)?([Ee][+-]?[0-9]+)?
 1875  *
 1876  * The complexity is that either integer or fraction must be present and the
 1877  * fraction is permitted to have no digits only if the integer is present.
 1878  *
 1879  * NOTE: The dangling E problem.
 1880  *   There is a PNG valid floating point number in the following:
 1881  *
 1882  *       PNG floating point numbers are not greedy.
 1883  *
 1884  *   Working this out requires *TWO* character lookahead (because of the
 1885  *   sign), the parser does not do this - it will fail at the 'r' - this
 1886  *   doesn't matter for PNG sCAL chunk values, but it requires more care
 1887  *   if the value were ever to be embedded in something more complex.  Use
 1888  *   ANSI-C strtod if you need the lookahead.
 1889  */
 1890 /* State table for the parser. */
 1891 #define PNG_FP_INTEGER    0  /* before or in integer */
 1892 #define PNG_FP_FRACTION   1  /* before or in fraction */
 1893 #define PNG_FP_EXPONENT   2  /* before or in exponent */
 1894 #define PNG_FP_STATE      3  /* mask for the above */
 1895 #define PNG_FP_SAW_SIGN   4  /* Saw +/- in current state */
 1896 #define PNG_FP_SAW_DIGIT  8  /* Saw a digit in current state */
 1897 #define PNG_FP_SAW_DOT   16  /* Saw a dot in current state */
 1898 #define PNG_FP_SAW_E     32  /* Saw an E (or e) in current state */
 1899 #define PNG_FP_SAW_ANY   60  /* Saw any of the above 4 */
 1900 
 1901 /* These three values don't affect the parser.  They are set but not used.
 1902  */
 1903 #define PNG_FP_WAS_VALID 64  /* Preceding substring is a valid fp number */
 1904 #define PNG_FP_NEGATIVE 128  /* A negative number, including "-0" */
 1905 #define PNG_FP_NONZERO  256  /* A non-zero value */
 1906 #define PNG_FP_STICKY   448  /* The above three flags */
 1907 
 1908 /* This is available for the caller to store in 'state' if required.  Do not
 1909  * call the parser after setting it (the parser sometimes clears it.)
 1910  */
 1911 #define PNG_FP_INVALID  512  /* Available for callers as a distinct value */
 1912 
 1913 /* Result codes for the parser (boolean - true meants ok, false means
 1914  * not ok yet.)
 1915  */
 1916 #define PNG_FP_MAYBE      0  /* The number may be valid in the future */
 1917 #define PNG_FP_OK         1  /* The number is valid */
 1918 
 1919 /* Tests on the sticky non-zero and negative flags.  To pass these checks
 1920  * the state must also indicate that the whole number is valid - this is
 1921  * achieved by testing PNG_FP_SAW_DIGIT (see the implementation for why this
 1922  * is equivalent to PNG_FP_OK above.)
 1923  */
 1924 #define PNG_FP_NZ_MASK (PNG_FP_SAW_DIGIT | PNG_FP_NEGATIVE | PNG_FP_NONZERO)
 1925    /* NZ_MASK: the string is valid and a non-zero negative value */
 1926 #define PNG_FP_Z_MASK (PNG_FP_SAW_DIGIT | PNG_FP_NONZERO)
 1927    /* Z MASK: the string is valid and a non-zero value. */
 1928    /* PNG_FP_SAW_DIGIT: the string is valid. */
 1929 #define PNG_FP_IS_ZERO(state) (((state) & PNG_FP_Z_MASK) == PNG_FP_SAW_DIGIT)
 1930 #define PNG_FP_IS_POSITIVE(state) (((state) & PNG_FP_NZ_MASK) == PNG_FP_Z_MASK)
 1931 #define PNG_FP_IS_NEGATIVE(state) (((state) & PNG_FP_NZ_MASK) == PNG_FP_NZ_MASK)
 1932 
 1933 /* The actual parser.  This can be called repeatedly. It updates
 1934  * the index into the string and the state variable (which must
 1935  * be initialized to 0).  It returns a result code, as above.  There
 1936  * is no point calling the parser any more if it fails to advance to
 1937  * the end of the string - it is stuck on an invalid character (or
 1938  * terminated by '\0').
 1939  *
 1940  * Note that the pointer will consume an E or even an E+ and then leave
 1941  * a 'maybe' state even though a preceding integer.fraction is valid.
 1942  * The PNG_FP_WAS_VALID flag indicates that a preceding substring was
 1943  * a valid number.  It's possible to recover from this by calling
 1944  * the parser again (from the start, with state 0) but with a string
 1945  * that omits the last character (i.e. set the size to the index of
 1946  * the problem character.)  This has not been tested within libpng.
 1947  */
 1948 PNG_INTERNAL_FUNCTION(int,png_check_fp_number,(png_const_charp string,
 1949    png_size_t size, int *statep, png_size_tp whereami),PNG_EMPTY);
 1950 
 1951 /* This is the same but it checks a complete string and returns true
 1952  * only if it just contains a floating point number.  As of 1.5.4 this
 1953  * function also returns the state at the end of parsing the number if
 1954  * it was valid (otherwise it returns 0.)  This can be used for testing
 1955  * for negative or zero values using the sticky flag.
 1956  */
 1957 PNG_INTERNAL_FUNCTION(int,png_check_fp_string,(png_const_charp string,
 1958    png_size_t size),PNG_EMPTY);
 1959 #endif /* pCAL || sCAL */
 1960 
 1961 #if defined(PNG_GAMMA_SUPPORTED) ||\
 1962     defined(PNG_INCH_CONVERSIONS_SUPPORTED) || defined(PNG_READ_pHYs_SUPPORTED)
 1963 /* Added at libpng version 1.5.0 */
 1964 /* This is a utility to provide a*times/div (rounded) and indicate
 1965  * if there is an overflow.  The result is a boolean - false (0)
 1966  * for overflow, true (1) if no overflow, in which case *res
 1967  * holds the result.
 1968  */
 1969 PNG_INTERNAL_FUNCTION(int,png_muldiv,(png_fixed_point_p res, png_fixed_point a,
 1970    png_int_32 multiplied_by, png_int_32 divided_by),PNG_EMPTY);
 1971 #endif
 1972 
 1973 #if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_INCH_CONVERSIONS_SUPPORTED)
 1974 /* Same deal, but issue a warning on overflow and return 0. */
 1975 PNG_INTERNAL_FUNCTION(png_fixed_point,png_muldiv_warn,
 1976    (png_const_structrp png_ptr, png_fixed_point a, png_int_32 multiplied_by,
 1977    png_int_32 divided_by),PNG_EMPTY);
 1978 #endif
 1979 
 1980 #ifdef PNG_GAMMA_SUPPORTED
 1981 /* Calculate a reciprocal - used for gamma values.  This returns
 1982  * 0 if the argument is 0 in order to maintain an undefined value;
 1983  * there are no warnings.
 1984  */
 1985 PNG_INTERNAL_FUNCTION(png_fixed_point,png_reciprocal,(png_fixed_point a),
 1986    PNG_EMPTY);
 1987 
 1988 #ifdef PNG_READ_GAMMA_SUPPORTED
 1989 /* The same but gives a reciprocal of the product of two fixed point
 1990  * values.  Accuracy is suitable for gamma calculations but this is
 1991  * not exact - use png_muldiv for that.  Only required at present on read.
 1992  */
 1993 PNG_INTERNAL_FUNCTION(png_fixed_point,png_reciprocal2,(png_fixed_point a,
 1994    png_fixed_point b),PNG_EMPTY);
 1995 #endif
 1996 
 1997 /* Return true if the gamma value is significantly different from 1.0 */
 1998 PNG_INTERNAL_FUNCTION(int,png_gamma_significant,(png_fixed_point gamma_value),
 1999    PNG_EMPTY);
 2000 #endif
 2001 
 2002 #ifdef PNG_READ_GAMMA_SUPPORTED
 2003 /* Internal fixed point gamma correction.  These APIs are called as
 2004  * required to convert single values - they don't need to be fast,
 2005  * they are not used when processing image pixel values.
 2006  *
 2007  * While the input is an 'unsigned' value it must actually be the
 2008  * correct bit value - 0..255 or 0..65535 as required.
 2009  */
 2010 PNG_INTERNAL_FUNCTION(png_uint_16,png_gamma_correct,(png_structrp png_ptr,
 2011    unsigned int value, png_fixed_point gamma_value),PNG_EMPTY);
 2012 PNG_INTERNAL_FUNCTION(png_uint_16,png_gamma_16bit_correct,(unsigned int value,
 2013    png_fixed_point gamma_value),PNG_EMPTY);
 2014 PNG_INTERNAL_FUNCTION(png_byte,png_gamma_8bit_correct,(unsigned int value,
 2015    png_fixed_point gamma_value),PNG_EMPTY);
 2016 PNG_INTERNAL_FUNCTION(void,png_destroy_gamma_table,(png_structrp png_ptr),
 2017    PNG_EMPTY);
 2018 PNG_INTERNAL_FUNCTION(void,png_build_gamma_table,(png_structrp png_ptr,
 2019    int bit_depth),PNG_EMPTY);
 2020 #endif
 2021 
 2022 /* SIMPLIFIED READ/WRITE SUPPORT */
 2023 #if defined(PNG_SIMPLIFIED_READ_SUPPORTED) ||\
 2024    defined(PNG_SIMPLIFIED_WRITE_SUPPORTED)
 2025 /* The internal structure that png_image::opaque points to. */
 2026 typedef struct png_control
 2027 {
 2028    png_structp png_ptr;
 2029    png_infop   info_ptr;
 2030    png_voidp   error_buf;           /* Always a jmp_buf at present. */
 2031 
 2032    png_const_bytep memory;          /* Memory buffer. */
 2033    png_size_t      size;            /* Size of the memory buffer. */
 2034 
 2035    unsigned int for_write       :1; /* Otherwise it is a read structure */
 2036    unsigned int owned_file      :1; /* We own the file in io_ptr */
 2037 } png_control;
 2038 
 2039 /* Return the pointer to the jmp_buf from a png_control: necessary because C
 2040  * does not reveal the type of the elements of jmp_buf.
 2041  */
 2042 #ifdef __cplusplus
 2043 #  define png_control_jmp_buf(pc) (((jmp_buf*)((pc)->error_buf))[0])
 2044 #else
 2045 #  define png_control_jmp_buf(pc) ((pc)->error_buf)
 2046 #endif
 2047 
 2048 /* Utility to safely execute a piece of libpng code catching and logging any
 2049  * errors that might occur.  Returns true on success, false on failure (either
 2050  * of the function or as a result of a png_error.)
 2051  */
 2052 PNG_INTERNAL_CALLBACK(void,png_safe_error,(png_structp png_ptr,
 2053    png_const_charp error_message),PNG_NORETURN);
 2054 
 2055 #ifdef PNG_WARNINGS_SUPPORTED
 2056 PNG_INTERNAL_CALLBACK(void,png_safe_warning,(png_structp png_ptr,
 2057    png_const_charp warning_message),PNG_EMPTY);
 2058 #else
 2059 #  define png_safe_warning 0/*dummy argument*/
 2060 #endif
 2061 
 2062 PNG_INTERNAL_FUNCTION(int,png_safe_execute,(png_imagep image,
 2063    int (*function)(png_voidp), png_voidp arg),PNG_EMPTY);
 2064 
 2065 /* Utility to log an error; this also cleans up the png_image; the function
 2066  * always returns 0 (false).
 2067  */
 2068 PNG_INTERNAL_FUNCTION(int,png_image_error,(png_imagep image,
 2069    png_const_charp error_message),PNG_EMPTY);
 2070 
 2071 #ifndef PNG_SIMPLIFIED_READ_SUPPORTED
 2072 /* png_image_free is used by the write code but not exported */
 2073 PNG_INTERNAL_FUNCTION(void, png_image_free, (png_imagep image), PNG_EMPTY);
 2074 #endif /* !SIMPLIFIED_READ */
 2075 
 2076 #endif /* SIMPLIFIED READ/WRITE */
 2077 
 2078 /* These are initialization functions for hardware specific PNG filter
 2079  * optimizations; list these here then select the appropriate one at compile
 2080  * time using the macro PNG_FILTER_OPTIMIZATIONS.  If the macro is not defined
 2081  * the generic code is used.
 2082  */
 2083 #ifdef PNG_FILTER_OPTIMIZATIONS
 2084 PNG_INTERNAL_FUNCTION(void, PNG_FILTER_OPTIMIZATIONS, (png_structp png_ptr,
 2085    unsigned int bpp), PNG_EMPTY);
 2086    /* Just declare the optimization that will be used */
 2087 #else
 2088    /* List *all* the possible optimizations here - this branch is required if
 2089     * the builder of libpng passes the definition of PNG_FILTER_OPTIMIZATIONS in
 2090     * CFLAGS in place of CPPFLAGS *and* uses symbol prefixing.
 2091     */
 2092 #  if PNG_ARM_NEON_OPT > 0
 2093 PNG_INTERNAL_FUNCTION(void, png_init_filter_functions_neon,
 2094    (png_structp png_ptr, unsigned int bpp), PNG_EMPTY);
 2095 #endif
 2096 
 2097 #if PNG_MIPS_MSA_OPT > 0
 2098 PNG_INTERNAL_FUNCTION(void, png_init_filter_functions_msa,
 2099    (png_structp png_ptr, unsigned int bpp), PNG_EMPTY);
 2100 #endif
 2101 
 2102 #  if PNG_INTEL_SSE_IMPLEMENTATION > 0
 2103 PNG_INTERNAL_FUNCTION(void, png_init_filter_functions_sse2,
 2104    (png_structp png_ptr, unsigned int bpp), PNG_EMPTY);
 2105 #  endif
 2106 #endif
 2107 
 2108 PNG_INTERNAL_FUNCTION(png_uint_32, png_check_keyword, (png_structrp png_ptr,
 2109    png_const_charp key, png_bytep new_key), PNG_EMPTY);
 2110 
 2111 /* Maintainer: Put new private prototypes here ^ */
 2112 
 2113 #include "pngdebug.h"
 2114 
 2115 #ifdef __cplusplus
 2116 }
 2117 #endif
 2118 
 2119 #endif /* PNG_VERSION_INFO_ONLY */
 2120 #endif /* PNGPRIV_H */