/*

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the LICENSE file that accompanied this code.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

/* pngpriv.h - private declarations for use inside libpng

 *

 * This file is available under and governed by the GNU General Public

 * License version 2 only, as published by the Free Software Foundation.

 * However, the following notice accompanied the original version of this

 * file and, per its terms, should not be removed:

 *

 * Last changed in libpng 1.6.26 [October 20, 2016]

 * Copyright (c) 1998-2002,2004,2006-2016 Glenn Randers-Pehrson

 * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)

 * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)

 *

 * This code is released under the libpng license.

 * For conditions of distribution and use, see the disclaimer

 * and license in png.h

 */

/* The symbols declared in this file (including the functions declared

 * as extern) are PRIVATE.  They are not part of the libpng public

 * interface, and are not recommended for use by regular applications.

 * Some of them may become public in the future; others may stay private,

 * change in an incompatible way, or even disappear.

 * Although the libpng users are not forbidden to include this header,

 * they should be well aware of the issues that may arise from doing so.

 */

#ifndef PNGPRIV_H

#define PNGPRIV_H

/* Feature Test Macros.  The following are defined here to ensure that correctly

 * implemented libraries reveal the APIs libpng needs to build and hide those

 * that are not needed and potentially damaging to the compilation.

 *

 * Feature Test Macros must be defined before any system header is included (see

 * POSIX 1003.1 2.8.2 "POSIX Symbols."

 *

 * These macros only have an effect if the operating system supports either

 * POSIX 1003.1 or C99, or both.  On other operating systems (particularly

 * Windows/Visual Studio) there is no effect; the OS specific tests below are

 * still required (as of 2011-05-02.)

 */

#define _POSIX_SOURCE 1 /* Just the POSIX 1003.1 and C89 APIs */

#ifndef PNG_VERSION_INFO_ONLY

/* Standard library headers not required by png.h: */

#  include <stdlib.h>

#  include <string.h>

#endif

#define PNGLIB_BUILD /*libpng is being built, not used*/

/* If HAVE_CONFIG_H is defined during the build then the build system must

 * provide an appropriate "config.h" file on the include path.  The header file

 * must provide definitions as required below (search for "HAVE_CONFIG_H");

 * see configure.ac for more details of the requirements.  The macro

 * "PNG_NO_CONFIG_H" is provided for maintainers to test for dependencies on

 * 'configure'; define this macro to prevent the configure build including the

 * configure generated config.h.  Libpng is expected to compile without *any*

 * special build system support on a reasonably ANSI-C compliant system.

 */

#if defined(HAVE_CONFIG_H) && !defined(PNG_NO_CONFIG_H)

#  include <config.h>

   /* Pick up the definition of 'restrict' from config.h if it was read: */

#  define PNG_RESTRICT restrict

#endif

/* To support symbol prefixing it is necessary to know *before* including png.h

 * whether the fixed point (and maybe other) APIs are exported, because if they

 * are not internal definitions may be required.  This is handled below just

 * before png.h is included, but load the configuration now if it is available.

 */

#ifndef PNGLCONF_H

#  include "pnglibconf.h"

#endif

/* Local renames may change non-exported API functions from png.h */

#if defined(PNG_PREFIX) && !defined(PNGPREFIX_H)

#  include "pngprefix.h"

#endif

#ifdef PNG_USER_CONFIG

#  include "pngusr.h"

   /* These should have been defined in pngusr.h */

#  ifndef PNG_USER_PRIVATEBUILD

#    define PNG_USER_PRIVATEBUILD "Custom libpng build"

#  endif

#  ifndef PNG_USER_DLLFNAME_POSTFIX

#    define PNG_USER_DLLFNAME_POSTFIX "Cb"

#  endif

#endif

/* Compile time options.

 * =====================

 * In a multi-arch build the compiler may compile the code several times for the

 * same object module, producing different binaries for different architectures.

 * When this happens configure-time setting of the target host options cannot be

 * done and this interferes with the handling of the ARM NEON optimizations, and

 * possibly other similar optimizations.  Put additional tests here; in general

 * this is needed when the same option can be changed at both compile time and

 * run time depending on the target OS (i.e. iOS vs Android.)

 *

 * NOTE: symbol prefixing does not pass $(CFLAGS) to the preprocessor, because

 * this is not possible with certain compilers (Oracle SUN OS CC), as a result

 * it is necessary to ensure that all extern functions that *might* be used

 * regardless of $(CFLAGS) get declared in this file.  The test on __ARM_NEON__

 * below is one example of this behavior because it is controlled by the

 * presence or not of -mfpu=neon on the GCC command line, it is possible to do

 * this in $(CC), e.g. "CC=gcc -mfpu=neon", but people who build libpng rarely

 * do this.

 */

#ifndef PNG_ARM_NEON_OPT

   /* ARM NEON optimizations are being controlled by the compiler settings,

    * typically the target FPU.  If the FPU has been set to NEON (-mfpu=neon

    * with GCC) then the compiler will define __ARM_NEON__ and we can rely

    * unconditionally on NEON instructions not crashing, otherwise we must

    * disable use of NEON instructions.

    *

    * NOTE: at present these optimizations depend on 'ALIGNED_MEMORY', so they

    * can only be turned on automatically if that is supported too.  If

    * PNG_ARM_NEON_OPT is set in CPPFLAGS (to >0) then arm/arm_init.c will fail

    * to compile with an appropriate #error if ALIGNED_MEMORY has been turned

    * off.

    *

    * Note that gcc-4.9 defines __ARM_NEON instead of the deprecated

    * __ARM_NEON__, so we check both variants.

    *

    * To disable ARM_NEON optimizations entirely, and skip compiling the

    * associated assembler code, pass --enable-arm-neon=no to configure

    * or put -DPNG_ARM_NEON_OPT=0 in CPPFLAGS.

    */

#  if (defined(__ARM_NEON__) || defined(__ARM_NEON)) && \

   defined(PNG_ALIGNED_MEMORY_SUPPORTED)

#     define PNG_ARM_NEON_OPT 2

#  else

#     define PNG_ARM_NEON_OPT 0

#  endif

#endif

#if PNG_ARM_NEON_OPT > 0

   /* NEON optimizations are to be at least considered by libpng, so enable the

    * callbacks to do this.

    */

#  define PNG_FILTER_OPTIMIZATIONS png_init_filter_functions_neon

   /* By default the 'intrinsics' code in arm/filter_neon_intrinsics.c is used

    * if possible - if __ARM_NEON__ is set and the compiler version is not known

    * to be broken.  This is controlled by PNG_ARM_NEON_IMPLEMENTATION which can

    * be:

    *

    *    1  The intrinsics code (the default with __ARM_NEON__)

    *    2  The hand coded assembler (the default without __ARM_NEON__)

    *

    * It is possible to set PNG_ARM_NEON_IMPLEMENTATION in CPPFLAGS, however

    * this is *NOT* supported and may cease to work even after a minor revision

    * to libpng.  It *is* valid to do this for testing purposes, e.g. speed

    * testing or a new compiler, but the results should be communicated to the

    * libpng implementation list for incorporation in the next minor release.

    */

#  ifndef PNG_ARM_NEON_IMPLEMENTATION

#     if defined(__ARM_NEON__) || defined(__ARM_NEON)

#        if defined(__clang__)

            /* At present it is unknown by the libpng developers which versions

             * of clang support the intrinsics, however some or perhaps all

             * versions do not work with the assembler so this may be

             * irrelevant, so just use the default (do nothing here.)

             */

#        elif defined(__GNUC__)

            /* GCC 4.5.4 NEON support is known to be broken.  4.6.3 is known to

             * work, so if this *is* GCC, or G++, look for a version >4.5

             */

#           if __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 6)

#              define PNG_ARM_NEON_IMPLEMENTATION 2

#           endif /* no GNUC support */

#        endif /* __GNUC__ */

#     else /* !defined __ARM_NEON__ */

         /* The 'intrinsics' code simply won't compile without this -mfpu=neon:

          */

#        define PNG_ARM_NEON_IMPLEMENTATION 2

#     endif /* __ARM_NEON__ */

#  endif /* !PNG_ARM_NEON_IMPLEMENTATION */

#  ifndef PNG_ARM_NEON_IMPLEMENTATION

      /* Use the intrinsics code by default. */

#     define PNG_ARM_NEON_IMPLEMENTATION 1

#  endif

#endif /* PNG_ARM_NEON_OPT > 0 */

#ifndef PNG_MIPS_MSA_OPT

#  if defined(__mips_msa) && (__mips_isa_rev >= 5) && defined(PNG_ALIGNED_MEMORY_SUPPORTED)

#     define PNG_MIPS_MSA_OPT 2

#  else

#     define PNG_MIPS_MSA_OPT 0

#  endif

#endif

#if PNG_MIPS_MSA_OPT > 0

#  define PNG_FILTER_OPTIMIZATIONS png_init_filter_functions_msa

#  ifndef PNG_MIPS_MSA_IMPLEMENTATION

#     if defined(__mips_msa)

#        if defined(__clang__)

#        elif defined(__GNUC__)

#           if __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 7)

#              define PNG_MIPS_MSA_IMPLEMENTATION 2

#           endif /* no GNUC support */

#        endif /* __GNUC__ */

#     else /* !defined __mips_msa */

#        define PNG_MIPS_MSA_IMPLEMENTATION 2

#     endif /* __mips_msa */

#  endif /* !PNG_MIPS_MSA_IMPLEMENTATION */

#  ifndef PNG_MIPS_MSA_IMPLEMENTATION

#     define PNG_MIPS_MSA_IMPLEMENTATION 1

#  endif

#endif /* PNG_MIPS_MSA_OPT > 0 */

/* Is this a build of a DLL where compilation of the object modules requires

 * different preprocessor settings to those required for a simple library?  If

 * so PNG_BUILD_DLL must be set.

 *

 * If libpng is used inside a DLL but that DLL does not export the libpng APIs

 * PNG_BUILD_DLL must not be set.  To avoid the code below kicking in build a

 * static library of libpng then link the DLL against that.

 */

#ifndef PNG_BUILD_DLL

#  ifdef DLL_EXPORT

      /* This is set by libtool when files are compiled for a DLL; libtool

       * always compiles twice, even on systems where it isn't necessary.  Set

       * PNG_BUILD_DLL in case it is necessary:

       */

#     define PNG_BUILD_DLL

#  else

#     ifdef _WINDLL

         /* This is set by the Microsoft Visual Studio IDE in projects that

          * build a DLL.  It can't easily be removed from those projects (it

          * isn't visible in the Visual Studio UI) so it is a fairly reliable

          * indication that PNG_IMPEXP needs to be set to the DLL export

          * attributes.

          */

#        define PNG_BUILD_DLL

#     else

#        ifdef __DLL__

            /* This is set by the Borland C system when compiling for a DLL

             * (as above.)

             */

#           define PNG_BUILD_DLL

#        else

            /* Add additional compiler cases here. */

#        endif

#     endif

#  endif

#endif /* Setting PNG_BUILD_DLL if required */

/* See pngconf.h for more details: the builder of the library may set this on

 * the command line to the right thing for the specific compilation system or it

 * may be automagically set above (at present we know of no system where it does

 * need to be set on the command line.)

 *

 * PNG_IMPEXP must be set here when building the library to prevent pngconf.h

 * setting it to the "import" setting for a DLL build.

 */

#ifndef PNG_IMPEXP

#  ifdef PNG_BUILD_DLL

#     define PNG_IMPEXP PNG_DLL_EXPORT

#  else

      /* Not building a DLL, or the DLL doesn't require specific export

       * definitions.

       */

#     define PNG_IMPEXP

#  endif

#endif

/* No warnings for private or deprecated functions in the build: */

#ifndef PNG_DEPRECATED

#  define PNG_DEPRECATED

#endif

#ifndef PNG_PRIVATE

#  define PNG_PRIVATE

#endif

/* Symbol preprocessing support.

 *

 * To enable listing global, but internal, symbols the following macros should

 * always be used to declare an extern data or function object in this file.

 */

#ifndef PNG_INTERNAL_DATA

#  define PNG_INTERNAL_DATA(type, name, array) PNG_LINKAGE_DATA type name array

#endif

#ifndef PNG_INTERNAL_FUNCTION

#  define PNG_INTERNAL_FUNCTION(type, name, args, attributes)\

      PNG_LINKAGE_FUNCTION PNG_FUNCTION(type, name, args, PNG_EMPTY attributes)

#endif

#ifndef PNG_INTERNAL_CALLBACK

#  define PNG_INTERNAL_CALLBACK(type, name, args, attributes)\

      PNG_LINKAGE_CALLBACK PNG_FUNCTION(type, (PNGCBAPI name), args,\

         PNG_EMPTY attributes)

#endif

/* If floating or fixed point APIs are disabled they may still be compiled

 * internally.  To handle this make sure they are declared as the appropriate

 * internal extern function (otherwise the symbol prefixing stuff won't work and

 * the functions will be used without definitions.)

 *

 * NOTE: although all the API functions are declared here they are not all

 * actually built!  Because the declarations are still made it is necessary to

 * fake out types that they depend on.

 */

#ifndef PNG_FP_EXPORT

#  ifndef PNG_FLOATING_POINT_SUPPORTED

#     define PNG_FP_EXPORT(ordinal, type, name, args)\

         PNG_INTERNAL_FUNCTION(type, name, args, PNG_EMPTY);

#     ifndef PNG_VERSION_INFO_ONLY

         typedef struct png_incomplete png_double;

         typedef png_double*           png_doublep;

         typedef const png_double*     png_const_doublep;

         typedef png_double**          png_doublepp;

#     endif

#  endif

#endif

#ifndef PNG_FIXED_EXPORT

#  ifndef PNG_FIXED_POINT_SUPPORTED

#     define PNG_FIXED_EXPORT(ordinal, type, name, args)\

         PNG_INTERNAL_FUNCTION(type, name, args, PNG_EMPTY);

#  endif

#endif

#include "png.h"

/* pngconf.h does not set PNG_DLL_EXPORT unless it is required, so: */

#ifndef PNG_DLL_EXPORT

#  define PNG_DLL_EXPORT

#endif

/* This is a global switch to set the compilation for an installed system

 * (a release build).  It can be set for testing debug builds to ensure that

 * they will compile when the build type is switched to RC or STABLE, the

 * default is just to use PNG_LIBPNG_BUILD_BASE_TYPE.  Set this in CPPFLAGS

 * with either:

 *

 *   -DPNG_RELEASE_BUILD Turns on the release compile path

 *   -DPNG_RELEASE_BUILD=0 Turns it off

 * or in your pngusr.h with

 *   #define PNG_RELEASE_BUILD=1 Turns on the release compile path

 *   #define PNG_RELEASE_BUILD=0 Turns it off

 */

#ifndef PNG_RELEASE_BUILD

#  define PNG_RELEASE_BUILD (PNG_LIBPNG_BUILD_BASE_TYPE >= PNG_LIBPNG_BUILD_RC)

#endif

/* SECURITY and SAFETY:

 *

 * libpng is built with support for internal limits on image dimensions and

 * memory usage.  These are documented in scripts/pnglibconf.dfa of the

 * source and recorded in the machine generated header file pnglibconf.h.

 */

/* If you are running on a machine where you cannot allocate more

 * than 64K of memory at once, uncomment this.  While libpng will not

 * normally need that much memory in a chunk (unless you load up a very

 * large file), zlib needs to know how big of a chunk it can use, and

 * libpng thus makes sure to check any memory allocation to verify it

 * will fit into memory.

 *

 * zlib provides 'MAXSEG_64K' which, if defined, indicates the

 * same limit and pngconf.h (already included) sets the limit

 * if certain operating systems are detected.

 */

#if defined(MAXSEG_64K) && !defined(PNG_MAX_MALLOC_64K)

#  define PNG_MAX_MALLOC_64K

#endif

#ifndef PNG_UNUSED

/* Unused formal parameter warnings are silenced using the following macro

 * which is expected to have no bad effects on performance (optimizing

 * compilers will probably remove it entirely).  Note that if you replace

 * it with something other than whitespace, you must include the terminating

 * semicolon.

 */

#  define PNG_UNUSED(param) (void)param;

#endif

/* Just a little check that someone hasn't tried to define something

 * contradictory.

 */

#if (PNG_ZBUF_SIZE > 65536L) && defined(PNG_MAX_MALLOC_64K)

#  undef PNG_ZBUF_SIZE

#  define PNG_ZBUF_SIZE 65536L

#endif

/* If warnings or errors are turned off the code is disabled or redirected here.

 * From 1.5.4 functions have been added to allow very limited formatting of

 * error and warning messages - this code will also be disabled here.

 */

#ifdef PNG_WARNINGS_SUPPORTED

#  define PNG_WARNING_PARAMETERS(p) png_warning_parameters p;

#else

#  define png_warning_parameter(p,number,string) ((void)0)

#  define png_warning_parameter_unsigned(p,number,format,value) ((void)0)

#  define png_warning_parameter_signed(p,number,format,value) ((void)0)

#  define png_formatted_warning(pp,p,message) ((void)(pp))

#  define PNG_WARNING_PARAMETERS(p)

#endif

#ifndef PNG_ERROR_TEXT_SUPPORTED

#  define png_fixed_error(s1,s2) png_err(s1)

#endif

/* C allows up-casts from (void*) to any pointer and (const void*) to any

 * pointer to a const object.  C++ regards this as a type error and requires an

 * explicit, static, cast and provides the static_cast<> rune to ensure that

 * const is not cast away.

 */

#ifdef __cplusplus

#  define png_voidcast(type, value) static_cast<type>(value)

#  define png_constcast(type, value) const_cast<type>(value)

#  define png_aligncast(type, value) \

   static_cast<type>(static_cast<void*>(value))

#  define png_aligncastconst(type, value) \

   static_cast<type>(static_cast<const void*>(value))

#else

#  define png_voidcast(type, value) (value)

#  define png_constcast(type, value) ((type)(value))

#  define png_aligncast(type, value) ((void*)(value))

#  define png_aligncastconst(type, value) ((const void*)(value))

#endif /* __cplusplus */

/* Some fixed point APIs are still required even if not exported because

 * they get used by the corresponding floating point APIs.  This magic

 * deals with this:

 */

#ifdef PNG_FIXED_POINT_SUPPORTED

#  define PNGFAPI PNGAPI

#else

#  define PNGFAPI /* PRIVATE */

#endif

#ifndef PNG_VERSION_INFO_ONLY

/* Other defines specific to compilers can go here.  Try to keep

 * them inside an appropriate ifdef/endif pair for portability.

 */

#if defined(PNG_FLOATING_POINT_SUPPORTED) ||\

    defined(PNG_FLOATING_ARITHMETIC_SUPPORTED)

   /* png.c requires the following ANSI-C constants if the conversion of

    * floating point to ASCII is implemented therein:

    *

    *  DBL_DIG  Maximum number of decimal digits (can be set to any constant)

    *  DBL_MIN  Smallest normalized fp number (can be set to an arbitrary value)

    *  DBL_MAX  Maximum floating point number (can be set to an arbitrary value)

    */

#  include <float.h>

#  if (defined(__MWERKS__) && defined(macintosh)) || defined(applec) || \

    defined(THINK_C) || defined(__SC__) || defined(TARGET_OS_MAC)

   /* We need to check that <math.h> hasn't already been included earlier

    * as it seems it doesn't agree with <fp.h>, yet we should really use

    * <fp.h> if possible.

    */

#    if !defined(__MATH_H__) && !defined(__MATH_H) && !defined(__cmath__)

#      include <fp.h>

#    endif

#  else

#    include <math.h>

#  endif

#  if defined(_AMIGA) && defined(__SASC) && defined(_M68881)

   /* Amiga SAS/C: We must include builtin FPU functions when compiling using

    * MATH=68881

    */

#    include <m68881.h>

#  endif

#endif

/* This provides the non-ANSI (far) memory allocation routines. */

#if defined(__TURBOC__) && defined(__MSDOS__)

#  include <mem.h>

#  include <alloc.h>

#endif

#if defined(WIN32) || defined(_Windows) || defined(_WINDOWS) || \