1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/media/libpng/pngpriv.h Wed Dec 31 06:09:35 2014 +0100
1.3 @@ -0,0 +1,1999 @@
1.4 +
1.5 +/* pngpriv.h - private declarations for use inside libpng
1.6 + *
1.7 + * For conditions of distribution and use, see copyright notice in png.h
1.8 + * Copyright (c) 1998-2014 Glenn Randers-Pehrson
1.9 + * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
1.10 + * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
1.11 + *
1.12 + * Last changed in libpng 1.6.10 [March 6, 2014]
1.13 + *
1.14 + * This code is released under the libpng license.
1.15 + * For conditions of distribution and use, see the disclaimer
1.16 + * and license in png.h
1.17 + */
1.18 +
1.19 +/* The symbols declared in this file (including the functions declared
1.20 + * as extern) are PRIVATE. They are not part of the libpng public
1.21 + * interface, and are not recommended for use by regular applications.
1.22 + * Some of them may become public in the future; others may stay private,
1.23 + * change in an incompatible way, or even disappear.
1.24 + * Although the libpng users are not forbidden to include this header,
1.25 + * they should be well aware of the issues that may arise from doing so.
1.26 + */
1.27 +
1.28 +#ifndef PNGPRIV_H
1.29 +#define PNGPRIV_H
1.30 +
1.31 +/* Feature Test Macros. The following are defined here to ensure that correctly
1.32 + * implemented libraries reveal the APIs libpng needs to build and hide those
1.33 + * that are not needed and potentially damaging to the compilation.
1.34 + *
1.35 + * Feature Test Macros must be defined before any system header is included (see
1.36 + * POSIX 1003.1 2.8.2 "POSIX Symbols."
1.37 + *
1.38 + * These macros only have an effect if the operating system supports either
1.39 + * POSIX 1003.1 or C99, or both. On other operating systems (particularly
1.40 + * Windows/Visual Studio) there is no effect; the OS specific tests below are
1.41 + * still required (as of 2011-05-02.)
1.42 + */
1.43 +#define _POSIX_SOURCE 1 /* Just the POSIX 1003.1 and C89 APIs */
1.44 +
1.45 +#ifndef PNG_VERSION_INFO_ONLY
1.46 +/* Standard library headers not required by png.h: */
1.47 +# include <stdlib.h>
1.48 +# include <string.h>
1.49 +#endif
1.50 +
1.51 +#define PNGLIB_BUILD /*libpng is being built, not used*/
1.52 +
1.53 +/* If HAVE_CONFIG_H is defined during the build then the build system must
1.54 + * provide an appropriate "config.h" file on the include path. The header file
1.55 + * must provide definitions as required below (search for "HAVE_CONFIG_H");
1.56 + * see configure.ac for more details of the requirements. The macro
1.57 + * "PNG_NO_CONFIG_H" is provided for maintainers to test for dependencies on
1.58 + * 'configure'; define this macro to prevent the configure build including the
1.59 + * configure generated config.h. Libpng is expected to compile without *any*
1.60 + * special build system support on a reasonably ANSI-C compliant system.
1.61 + */
1.62 +#if defined(HAVE_CONFIG_H) && !defined(PNG_NO_CONFIG_H)
1.63 +# include <config.h>
1.64 +
1.65 + /* Pick up the definition of 'restrict' from config.h if it was read: */
1.66 +# define PNG_RESTRICT restrict
1.67 +#endif
1.68 +
1.69 +#include "mozpngconf.h"
1.70 +
1.71 +/* To support symbol prefixing it is necessary to know *before* including png.h
1.72 + * whether the fixed point (and maybe other) APIs are exported, because if they
1.73 + * are not internal definitions may be required. This is handled below just
1.74 + * before png.h is included, but load the configuration now if it is available.
1.75 + */
1.76 +#ifndef PNGLCONF_H
1.77 +# include "pnglibconf.h"
1.78 +#endif
1.79 +
1.80 +/* Local renames may change non-exported API functions from png.h */
1.81 +#if defined(PNG_PREFIX) && !defined(PNGPREFIX_H)
1.82 +# include "pngprefix.h"
1.83 +#endif
1.84 +
1.85 +#ifdef PNG_USER_CONFIG
1.86 +# include "pngusr.h"
1.87 + /* These should have been defined in pngusr.h */
1.88 +# ifndef PNG_USER_PRIVATEBUILD
1.89 +# define PNG_USER_PRIVATEBUILD "Custom libpng build"
1.90 +# endif
1.91 +# ifndef PNG_USER_DLLFNAME_POSTFIX
1.92 +# define PNG_USER_DLLFNAME_POSTFIX "Cb"
1.93 +# endif
1.94 +#endif
1.95 +
1.96 +/* Compile time options.
1.97 + * =====================
1.98 + * In a multi-arch build the compiler may compile the code several times for the
1.99 + * same object module, producing different binaries for different architectures.
1.100 + * When this happens configure-time setting of the target host options cannot be
1.101 + * done and this interferes with the handling of the ARM NEON optimizations, and
1.102 + * possibly other similar optimizations. Put additional tests here; in general
1.103 + * this is needed when the same option can be changed at both compile time and
1.104 + * run time depending on the target OS (i.e. iOS vs Android.)
1.105 + *
1.106 + * NOTE: symbol prefixing does not pass $(CFLAGS) to the preprocessor, because
1.107 + * this is not possible with certain compilers (Oracle SUN OS CC), as a result
1.108 + * it is necessary to ensure that all extern functions that *might* be used
1.109 + * regardless of $(CFLAGS) get declared in this file. The test on __ARM_NEON__
1.110 + * below is one example of this behavior because it is controlled by the
1.111 + * presence or not of -mfpu=neon on the GCC command line, it is possible to do
1.112 + * this in $(CC), e.g. "CC=gcc -mfpu=neon", but people who build libpng rarely
1.113 + * do this.
1.114 + */
1.115 +#ifndef PNG_ARM_NEON_OPT
1.116 + /* ARM NEON optimizations are being controlled by the compiler settings,
1.117 + * typically the target FPU. If the FPU has been set to NEON (-mfpu=neon
1.118 + * with GCC) then the compiler will define __ARM_NEON__ and we can rely
1.119 + * unconditionally on NEON instructions not crashing, otherwise we must
1.120 + * disable use of NEON instructions.
1.121 + *
1.122 + * NOTE: at present these optimizations depend on 'ALIGNED_MEMORY', so they
1.123 + * can only be turned on automatically if that is supported too. If
1.124 + * PNG_ARM_NEON_OPT is set in CPPFLAGS (to >0) then arm/arm_init.c will fail
1.125 + * to compile with an appropriate #error if ALIGNED_MEMORY has been turned
1.126 + * off.
1.127 + */
1.128 +# if defined(__ARM_NEON__) && defined(PNG_ALIGNED_MEMORY_SUPPORTED)
1.129 +# define PNG_ARM_NEON_OPT 2
1.130 +# else
1.131 +# define PNG_ARM_NEON_OPT 0
1.132 +# endif
1.133 +#endif
1.134 +
1.135 +#if PNG_ARM_NEON_OPT > 0
1.136 + /* NEON optimizations are to be at least considered by libpng, so enable the
1.137 + * callbacks to do this.
1.138 + */
1.139 +# define PNG_FILTER_OPTIMIZATIONS png_init_filter_functions_neon
1.140 +
1.141 + /* By default the 'intrinsics' code in arm/filter_neon_intrinsics.c is used
1.142 + * if possible - if __ARM_NEON__ is set and the compiler version is not known
1.143 + * to be broken. This is controlled by PNG_ARM_NEON_IMPLEMENTATION which can
1.144 + * be:
1.145 + *
1.146 + * 1 The intrinsics code (the default with __ARM_NEON__)
1.147 + * 2 The hand coded assembler (the default without __ARM_NEON__)
1.148 + *
1.149 + * It is possible to set PNG_ARM_NEON_IMPLEMENTATION in CPPFLAGS, however
1.150 + * this is *NOT* supported and may cease to work even after a minor revision
1.151 + * to libpng. It *is* valid to do this for testing purposes, e.g. speed
1.152 + * testing or a new compiler, but the results should be communicated to the
1.153 + * libpng implementation list for incorporation in the next minor release.
1.154 + */
1.155 +# ifndef PNG_ARM_NEON_IMPLEMENTATION
1.156 +# ifdef __ARM_NEON__
1.157 +# if defined(__clang__)
1.158 + /* At present it is unknown by the libpng developers which versions
1.159 + * of clang support the intrinsics, however some or perhaps all
1.160 + * versions do not work with the assembler so this may be
1.161 + * irrelevant, so just use the default (do nothing here.)
1.162 + */
1.163 +# elif defined(__GNUC__)
1.164 + /* GCC 4.5.4 NEON support is known to be broken. 4.6.3 is known to
1.165 + * work, so if this *is* GCC, or G++, look for a version >4.5
1.166 + */
1.167 +# if __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 6)
1.168 +# define PNG_ARM_NEON_IMPLEMENTATION 2
1.169 +# endif /* no GNUC support */
1.170 +# endif /* __GNUC__ */
1.171 +# else /* !defined __ARM_NEON__ */
1.172 + /* The 'intrinsics' code simply won't compile without this -mfpu=neon:
1.173 + */
1.174 +# define PNG_ARM_NEON_IMPLEMENTATION 2
1.175 +# endif /* __ARM_NEON__ */
1.176 +# endif /* !defined PNG_ARM_NEON_IMPLEMENTATION */
1.177 +
1.178 +# ifndef PNG_ARM_NEON_IMPLEMENTATION
1.179 + /* Use the intrinsics code by default. */
1.180 +# define PNG_ARM_NEON_IMPLEMENTATION 1
1.181 +# endif
1.182 +#endif /* PNG_ARM_NEON_OPT > 0 */
1.183 +
1.184 +/* Is this a build of a DLL where compilation of the object modules requires
1.185 + * different preprocessor settings to those required for a simple library? If
1.186 + * so PNG_BUILD_DLL must be set.
1.187 + *
1.188 + * If libpng is used inside a DLL but that DLL does not export the libpng APIs
1.189 + * PNG_BUILD_DLL must not be set. To avoid the code below kicking in build a
1.190 + * static library of libpng then link the DLL against that.
1.191 + */
1.192 +#ifndef PNG_BUILD_DLL
1.193 +# ifdef DLL_EXPORT
1.194 + /* This is set by libtool when files are compiled for a DLL; libtool
1.195 + * always compiles twice, even on systems where it isn't necessary. Set
1.196 + * PNG_BUILD_DLL in case it is necessary:
1.197 + */
1.198 +# define PNG_BUILD_DLL
1.199 +# else
1.200 +# ifdef _WINDLL
1.201 + /* This is set by the Microsoft Visual Studio IDE in projects that
1.202 + * build a DLL. It can't easily be removed from those projects (it
1.203 + * isn't visible in the Visual Studio UI) so it is a fairly reliable
1.204 + * indication that PNG_IMPEXP needs to be set to the DLL export
1.205 + * attributes.
1.206 + */
1.207 +# define PNG_BUILD_DLL
1.208 +# else
1.209 +# ifdef __DLL__
1.210 + /* This is set by the Borland C system when compiling for a DLL
1.211 + * (as above.)
1.212 + */
1.213 +# define PNG_BUILD_DLL
1.214 +# else
1.215 + /* Add additional compiler cases here. */
1.216 +# endif
1.217 +# endif
1.218 +# endif
1.219 +#endif /* Setting PNG_BUILD_DLL if required */
1.220 +
1.221 +/* See pngconf.h for more details: the builder of the library may set this on
1.222 + * the command line to the right thing for the specific compilation system or it
1.223 + * may be automagically set above (at present we know of no system where it does
1.224 + * need to be set on the command line.)
1.225 + *
1.226 + * PNG_IMPEXP must be set here when building the library to prevent pngconf.h
1.227 + * setting it to the "import" setting for a DLL build.
1.228 + */
1.229 +#ifndef PNG_IMPEXP
1.230 +# ifdef PNG_BUILD_DLL
1.231 +# define PNG_IMPEXP PNG_DLL_EXPORT
1.232 +# else
1.233 + /* Not building a DLL, or the DLL doesn't require specific export
1.234 + * definitions.
1.235 + */
1.236 +# define PNG_IMPEXP
1.237 +# endif
1.238 +#endif
1.239 +
1.240 +/* No warnings for private or deprecated functions in the build: */
1.241 +#ifndef PNG_DEPRECATED
1.242 +# define PNG_DEPRECATED
1.243 +#endif
1.244 +#ifndef PNG_PRIVATE
1.245 +# define PNG_PRIVATE
1.246 +#endif
1.247 +
1.248 +/* Symbol preprocessing support.
1.249 + *
1.250 + * To enable listing global, but internal, symbols the following macros should
1.251 + * always be used to declare an extern data or function object in this file.
1.252 + */
1.253 +#ifndef PNG_INTERNAL_DATA
1.254 +# define PNG_INTERNAL_DATA(type, name, array) extern type name array
1.255 +#endif
1.256 +
1.257 +#ifndef PNG_INTERNAL_FUNCTION
1.258 +# define PNG_INTERNAL_FUNCTION(type, name, args, attributes)\
1.259 + extern PNG_FUNCTION(type, name, args, PNG_EMPTY attributes)
1.260 +#endif
1.261 +
1.262 +#ifndef PNG_INTERNAL_CALLBACK
1.263 +# define PNG_INTERNAL_CALLBACK(type, name, args, attributes)\
1.264 + extern PNG_FUNCTION(type, (PNGCBAPI name), args, PNG_EMPTY attributes)
1.265 +#endif
1.266 +
1.267 +/* If floating or fixed point APIs are disabled they may still be compiled
1.268 + * internally. To handle this make sure they are declared as the appropriate
1.269 + * internal extern function (otherwise the symbol prefixing stuff won't work and
1.270 + * the functions will be used without definitions.)
1.271 + *
1.272 + * NOTE: although all the API functions are declared here they are not all
1.273 + * actually built! Because the declarations are still made it is necessary to
1.274 + * fake out types that they depend on.
1.275 + */
1.276 +#ifndef PNG_FP_EXPORT
1.277 +# ifndef PNG_FLOATING_POINT_SUPPORTED
1.278 +# define PNG_FP_EXPORT(ordinal, type, name, args)\
1.279 + PNG_INTERNAL_FUNCTION(type, name, args, PNG_EMPTY);
1.280 +# ifndef PNG_VERSION_INFO_ONLY
1.281 + typedef struct png_incomplete png_double;
1.282 + typedef png_double* png_doublep;
1.283 + typedef const png_double* png_const_doublep;
1.284 + typedef png_double** png_doublepp;
1.285 +# endif
1.286 +# endif
1.287 +#endif
1.288 +#ifndef PNG_FIXED_EXPORT
1.289 +# ifndef PNG_FIXED_POINT_SUPPORTED
1.290 +# define PNG_FIXED_EXPORT(ordinal, type, name, args)\
1.291 + PNG_INTERNAL_FUNCTION(type, name, args, PNG_EMPTY);
1.292 +# endif
1.293 +#endif
1.294 +
1.295 +#include "png.h"
1.296 +
1.297 +/* pngconf.h does not set PNG_DLL_EXPORT unless it is required, so: */
1.298 +#ifndef PNG_DLL_EXPORT
1.299 +# define PNG_DLL_EXPORT
1.300 +#endif
1.301 +
1.302 +/* SECURITY and SAFETY:
1.303 + *
1.304 + * By default libpng is built without any internal limits on image size,
1.305 + * individual heap (png_malloc) allocations or the total amount of memory used.
1.306 + * If PNG_SAFE_LIMITS_SUPPORTED is defined, however, the limits below are used
1.307 + * (unless individually overridden). These limits are believed to be fairly
1.308 + * safe, but builders of secure systems should verify the values against the
1.309 + * real system capabilities.
1.310 + */
1.311 +#ifdef PNG_SAFE_LIMITS_SUPPORTED
1.312 + /* 'safe' limits */
1.313 +# ifndef PNG_USER_WIDTH_MAX
1.314 +# define PNG_USER_WIDTH_MAX 1000000
1.315 +# endif
1.316 +# ifndef PNG_USER_HEIGHT_MAX
1.317 +# define PNG_USER_HEIGHT_MAX 1000000
1.318 +# endif
1.319 +# ifndef PNG_USER_CHUNK_CACHE_MAX
1.320 +# define PNG_USER_CHUNK_CACHE_MAX 128
1.321 +# endif
1.322 +# ifndef PNG_USER_CHUNK_MALLOC_MAX
1.323 +# define PNG_USER_CHUNK_MALLOC_MAX 8000000
1.324 +# endif
1.325 +#else
1.326 + /* values for no limits */
1.327 +# ifndef PNG_USER_WIDTH_MAX
1.328 +# define PNG_USER_WIDTH_MAX 0x7fffffff
1.329 +# endif
1.330 +# ifndef PNG_USER_HEIGHT_MAX
1.331 +# define PNG_USER_HEIGHT_MAX 0x7fffffff
1.332 +# endif
1.333 +# ifndef PNG_USER_CHUNK_CACHE_MAX
1.334 +# define PNG_USER_CHUNK_CACHE_MAX 0
1.335 +# endif
1.336 +# ifndef PNG_USER_CHUNK_MALLOC_MAX
1.337 +# define PNG_USER_CHUNK_MALLOC_MAX 0
1.338 +# endif
1.339 +#endif
1.340 +
1.341 +/* Moved to pngpriv.h at libpng-1.5.0 */
1.342 +/* NOTE: some of these may have been used in external applications as
1.343 + * these definitions were exposed in pngconf.h prior to 1.5.
1.344 + */
1.345 +
1.346 +/* If you are running on a machine where you cannot allocate more
1.347 + * than 64K of memory at once, uncomment this. While libpng will not
1.348 + * normally need that much memory in a chunk (unless you load up a very
1.349 + * large file), zlib needs to know how big of a chunk it can use, and
1.350 + * libpng thus makes sure to check any memory allocation to verify it
1.351 + * will fit into memory.
1.352 + *
1.353 + * zlib provides 'MAXSEG_64K' which, if defined, indicates the
1.354 + * same limit and pngconf.h (already included) sets the limit
1.355 + * if certain operating systems are detected.
1.356 + */
1.357 +#if defined(MAXSEG_64K) && !defined(PNG_MAX_MALLOC_64K)
1.358 +# define PNG_MAX_MALLOC_64K
1.359 +#endif
1.360 +
1.361 +#ifndef PNG_UNUSED
1.362 +/* Unused formal parameter warnings are silenced using the following macro
1.363 + * which is expected to have no bad effects on performance (optimizing
1.364 + * compilers will probably remove it entirely). Note that if you replace
1.365 + * it with something other than whitespace, you must include the terminating
1.366 + * semicolon.
1.367 + */
1.368 +# define PNG_UNUSED(param) (void)param;
1.369 +#endif
1.370 +
1.371 +/* Just a little check that someone hasn't tried to define something
1.372 + * contradictory.
1.373 + */
1.374 +#if (PNG_ZBUF_SIZE > 65536L) && defined(PNG_MAX_MALLOC_64K)
1.375 +# undef PNG_ZBUF_SIZE
1.376 +# define PNG_ZBUF_SIZE 65536L
1.377 +#endif
1.378 +
1.379 +/* If warnings or errors are turned off the code is disabled or redirected here.
1.380 + * From 1.5.4 functions have been added to allow very limited formatting of
1.381 + * error and warning messages - this code will also be disabled here.
1.382 + */
1.383 +#ifdef PNG_WARNINGS_SUPPORTED
1.384 +# define PNG_WARNING_PARAMETERS(p) png_warning_parameters p;
1.385 +#else
1.386 +# define png_warning_parameter(p,number,string) ((void)0)
1.387 +# define png_warning_parameter_unsigned(p,number,format,value) ((void)0)
1.388 +# define png_warning_parameter_signed(p,number,format,value) ((void)0)
1.389 +# define png_formatted_warning(pp,p,message) ((void)(pp))
1.390 +# define PNG_WARNING_PARAMETERS(p)
1.391 +#endif
1.392 +#ifndef PNG_ERROR_TEXT_SUPPORTED
1.393 +# define png_fixed_error(s1,s2) png_err(s1)
1.394 +#endif
1.395 +
1.396 +/* C allows up-casts from (void*) to any pointer and (const void*) to any
1.397 + * pointer to a const object. C++ regards this as a type error and requires an
1.398 + * explicit, static, cast and provides the static_cast<> rune to ensure that
1.399 + * const is not cast away.
1.400 + */
1.401 +#ifdef __cplusplus
1.402 +# define png_voidcast(type, value) static_cast<type>(value)
1.403 +# define png_constcast(type, value) const_cast<type>(value)
1.404 +# define png_aligncast(type, value) \
1.405 + static_cast<type>(static_cast<void*>(value))
1.406 +# define png_aligncastconst(type, value) \
1.407 + static_cast<type>(static_cast<const void*>(value))
1.408 +#else
1.409 +# define png_voidcast(type, value) (value)
1.410 +# define png_constcast(type, value) ((type)(value))
1.411 +# define png_aligncast(type, value) ((void*)(value))
1.412 +# define png_aligncastconst(type, value) ((const void*)(value))
1.413 +#endif /* __cplusplus */
1.414 +
1.415 +/* Some fixed point APIs are still required even if not exported because
1.416 + * they get used by the corresponding floating point APIs. This magic
1.417 + * deals with this:
1.418 + */
1.419 +#ifdef PNG_FIXED_POINT_SUPPORTED
1.420 +# define PNGFAPI PNGAPI
1.421 +#else
1.422 +# define PNGFAPI /* PRIVATE */
1.423 +#endif
1.424 +
1.425 +#ifndef PNG_VERSION_INFO_ONLY
1.426 +/* Other defines specific to compilers can go here. Try to keep
1.427 + * them inside an appropriate ifdef/endif pair for portability.
1.428 + */
1.429 +#if defined(PNG_FLOATING_POINT_SUPPORTED) ||\
1.430 + defined(PNG_FLOATING_ARITHMETIC_SUPPORTED)
1.431 + /* png.c requires the following ANSI-C constants if the conversion of
1.432 + * floating point to ASCII is implemented therein:
1.433 + *
1.434 + * DBL_DIG Maximum number of decimal digits (can be set to any constant)
1.435 + * DBL_MIN Smallest normalized fp number (can be set to an arbitrary value)
1.436 + * DBL_MAX Maximum floating point number (can be set to an arbitrary value)
1.437 + */
1.438 +# include <float.h>
1.439 +
1.440 +# if (defined(__MWERKS__) && defined(macintosh)) || defined(applec) || \
1.441 + defined(THINK_C) || defined(__SC__) || defined(TARGET_OS_MAC)
1.442 + /* We need to check that <math.h> hasn't already been included earlier
1.443 + * as it seems it doesn't agree with <fp.h>, yet we should really use
1.444 + * <fp.h> if possible.
1.445 + */
1.446 +# if !defined(__MATH_H__) && !defined(__MATH_H) && !defined(__cmath__)
1.447 +# include <fp.h>
1.448 +# endif
1.449 +# else
1.450 +# include <math.h>
1.451 +# endif
1.452 +# if defined(_AMIGA) && defined(__SASC) && defined(_M68881)
1.453 + /* Amiga SAS/C: We must include builtin FPU functions when compiling using
1.454 + * MATH=68881
1.455 + */
1.456 +# include <m68881.h>
1.457 +# endif
1.458 +#endif
1.459 +
1.460 +/* This provides the non-ANSI (far) memory allocation routines. */
1.461 +#if defined(__TURBOC__) && defined(__MSDOS__)
1.462 +# include <mem.h>
1.463 +# include <alloc.h>
1.464 +#endif
1.465 +
1.466 +#if defined(WIN32) || defined(_Windows) || defined(_WINDOWS) || \
1.467 + defined(_WIN32) || defined(__WIN32__)
1.468 +# include <windows.h> /* defines _WINDOWS_ macro */
1.469 +#endif
1.470 +#endif /* PNG_VERSION_INFO_ONLY */
1.471 +
1.472 +/* Moved here around 1.5.0beta36 from pngconf.h */
1.473 +/* Users may want to use these so they are not private. Any library
1.474 + * functions that are passed far data must be model-independent.
1.475 + */
1.476 +
1.477 +/* Memory model/platform independent fns */
1.478 +#ifndef PNG_ABORT
1.479 +# ifdef _WINDOWS_
1.480 +# define PNG_ABORT() ExitProcess(0)
1.481 +# else
1.482 +# define PNG_ABORT() abort()
1.483 +# endif
1.484 +#endif
1.485 +
1.486 +/* These macros may need to be architecture dependent. */
1.487 +#define PNG_ALIGN_NONE 0 /* do not use data alignment */
1.488 +#define PNG_ALIGN_ALWAYS 1 /* assume unaligned accesses are OK */
1.489 +#ifdef offsetof
1.490 +# define PNG_ALIGN_OFFSET 2 /* use offsetof to determine alignment */
1.491 +#else
1.492 +# define PNG_ALIGN_OFFSET -1 /* prevent the use of this */
1.493 +#endif
1.494 +#define PNG_ALIGN_SIZE 3 /* use sizeof to determine alignment */
1.495 +
1.496 +#ifndef PNG_ALIGN_TYPE
1.497 + /* Default to using aligned access optimizations and requiring alignment to a
1.498 + * multiple of the data type size. Override in a compiler specific fashion
1.499 + * if necessary by inserting tests here:
1.500 + */
1.501 +# define PNG_ALIGN_TYPE PNG_ALIGN_SIZE
1.502 +#endif
1.503 +
1.504 +#if PNG_ALIGN_TYPE == PNG_ALIGN_SIZE
1.505 + /* This is used because in some compiler implementations non-aligned
1.506 + * structure members are supported, so the offsetof approach below fails.
1.507 + * Set PNG_ALIGN_SIZE=0 for compiler combinations where unaligned access
1.508 + * is good for performance. Do not do this unless you have tested the result
1.509 + * and understand it.
1.510 + */
1.511 +# define png_alignof(type) (sizeof (type))
1.512 +#else
1.513 +# if PNG_ALIGN_TYPE == PNG_ALIGN_OFFSET
1.514 +# define png_alignof(type) offsetof(struct{char c; type t;}, t)
1.515 +# else
1.516 +# if PNG_ALIGN_TYPE == PNG_ALIGN_ALWAYS
1.517 +# define png_alignof(type) (1)
1.518 +# endif
1.519 + /* Else leave png_alignof undefined to prevent use thereof */
1.520 +# endif
1.521 +#endif
1.522 +
1.523 +/* This implicitly assumes alignment is always to a power of 2. */
1.524 +#ifdef png_alignof
1.525 +# define png_isaligned(ptr, type)\
1.526 + ((((const char*)ptr-(const char*)0) & (png_alignof(type)-1)) == 0)
1.527 +#else
1.528 +# define png_isaligned(ptr, type) 0
1.529 +#endif
1.530 +
1.531 +/* End of memory model/platform independent support */
1.532 +/* End of 1.5.0beta36 move from pngconf.h */
1.533 +
1.534 +/* CONSTANTS and UTILITY MACROS
1.535 + * These are used internally by libpng and not exposed in the API
1.536 + */
1.537 +
1.538 +/* Various modes of operation. Note that after an init, mode is set to
1.539 + * zero automatically when the structure is created. Three of these
1.540 + * are defined in png.h because they need to be visible to applications
1.541 + * that call png_set_unknown_chunk().
1.542 + */
1.543 +/* #define PNG_HAVE_IHDR 0x01 (defined in png.h) */
1.544 +/* #define PNG_HAVE_PLTE 0x02 (defined in png.h) */
1.545 +#define PNG_HAVE_IDAT 0x04
1.546 +/* #define PNG_AFTER_IDAT 0x08 (defined in png.h) */
1.547 +#define PNG_HAVE_IEND 0x10
1.548 + /* 0x20 (unused) */
1.549 + /* 0x40 (unused) */
1.550 + /* 0x80 (unused) */
1.551 +#define PNG_HAVE_CHUNK_HEADER 0x100
1.552 +#define PNG_WROTE_tIME 0x200
1.553 +#define PNG_WROTE_INFO_BEFORE_PLTE 0x400
1.554 +#define PNG_BACKGROUND_IS_GRAY 0x800
1.555 +#define PNG_HAVE_PNG_SIGNATURE 0x1000
1.556 +#define PNG_HAVE_CHUNK_AFTER_IDAT 0x2000 /* Have another chunk after IDAT */
1.557 + /* 0x4000 (unused) */
1.558 +#define PNG_IS_READ_STRUCT 0x8000 /* Else is a write struct */
1.559 +#ifdef PNG_APNG_SUPPORTED
1.560 +#define PNG_HAVE_acTL 0x10000
1.561 +#define PNG_HAVE_fcTL 0x20000
1.562 +#endif
1.563 +
1.564 +/* Flags for the transformations the PNG library does on the image data */
1.565 +#define PNG_BGR 0x0001
1.566 +#define PNG_INTERLACE 0x0002
1.567 +#define PNG_PACK 0x0004
1.568 +#define PNG_SHIFT 0x0008
1.569 +#define PNG_SWAP_BYTES 0x0010
1.570 +#define PNG_INVERT_MONO 0x0020
1.571 +#define PNG_QUANTIZE 0x0040
1.572 +#define PNG_COMPOSE 0x0080 /* Was PNG_BACKGROUND */
1.573 +#define PNG_BACKGROUND_EXPAND 0x0100
1.574 +#define PNG_EXPAND_16 0x0200 /* Added to libpng 1.5.2 */
1.575 +#define PNG_16_TO_8 0x0400 /* Becomes 'chop' in 1.5.4 */
1.576 +#define PNG_RGBA 0x0800
1.577 +#define PNG_EXPAND 0x1000
1.578 +#define PNG_GAMMA 0x2000
1.579 +#define PNG_GRAY_TO_RGB 0x4000
1.580 +#define PNG_FILLER 0x8000
1.581 +#define PNG_PACKSWAP 0x10000
1.582 +#define PNG_SWAP_ALPHA 0x20000
1.583 +#define PNG_STRIP_ALPHA 0x40000
1.584 +#define PNG_INVERT_ALPHA 0x80000
1.585 +#define PNG_USER_TRANSFORM 0x100000
1.586 +#define PNG_RGB_TO_GRAY_ERR 0x200000
1.587 +#define PNG_RGB_TO_GRAY_WARN 0x400000
1.588 +#define PNG_RGB_TO_GRAY 0x600000 /* two bits, RGB_TO_GRAY_ERR|WARN */
1.589 +#define PNG_ENCODE_ALPHA 0x800000 /* Added to libpng-1.5.4 */
1.590 +#define PNG_ADD_ALPHA 0x1000000 /* Added to libpng-1.2.7 */
1.591 +#define PNG_EXPAND_tRNS 0x2000000 /* Added to libpng-1.2.9 */
1.592 +#define PNG_SCALE_16_TO_8 0x4000000 /* Added to libpng-1.5.4 */
1.593 + /* 0x8000000 unused */
1.594 + /* 0x10000000 unused */
1.595 + /* 0x20000000 unused */
1.596 + /* 0x40000000 unused */
1.597 +/* Flags for png_create_struct */
1.598 +#define PNG_STRUCT_PNG 0x0001
1.599 +#define PNG_STRUCT_INFO 0x0002
1.600 +
1.601 +/* Scaling factor for filter heuristic weighting calculations */
1.602 +#define PNG_WEIGHT_FACTOR (1<<(PNG_WEIGHT_SHIFT))
1.603 +#define PNG_COST_FACTOR (1<<(PNG_COST_SHIFT))
1.604 +
1.605 +/* Flags for the png_ptr->flags rather than declaring a byte for each one */
1.606 +#define PNG_FLAG_ZLIB_CUSTOM_STRATEGY 0x0001
1.607 +#define PNG_FLAG_ZSTREAM_INITIALIZED 0x0002 /* Added to libpng-1.6.0 */
1.608 + /* 0x0004 unused */
1.609 +#define PNG_FLAG_ZSTREAM_ENDED 0x0008 /* Added to libpng-1.6.0 */
1.610 + /* 0x0010 unused */
1.611 + /* 0x0020 unused */
1.612 +#define PNG_FLAG_ROW_INIT 0x0040
1.613 +#define PNG_FLAG_FILLER_AFTER 0x0080
1.614 +#define PNG_FLAG_CRC_ANCILLARY_USE 0x0100
1.615 +#define PNG_FLAG_CRC_ANCILLARY_NOWARN 0x0200
1.616 +#define PNG_FLAG_CRC_CRITICAL_USE 0x0400
1.617 +#define PNG_FLAG_CRC_CRITICAL_IGNORE 0x0800
1.618 +#define PNG_FLAG_ASSUME_sRGB 0x1000 /* Added to libpng-1.5.4 */
1.619 +#define PNG_FLAG_OPTIMIZE_ALPHA 0x2000 /* Added to libpng-1.5.4 */
1.620 +#define PNG_FLAG_DETECT_UNINITIALIZED 0x4000 /* Added to libpng-1.5.4 */
1.621 +/* #define PNG_FLAG_KEEP_UNKNOWN_CHUNKS 0x8000 */
1.622 +/* #define PNG_FLAG_KEEP_UNSAFE_CHUNKS 0x10000 */
1.623 +#define PNG_FLAG_LIBRARY_MISMATCH 0x20000
1.624 +#define PNG_FLAG_STRIP_ERROR_NUMBERS 0x40000
1.625 +#define PNG_FLAG_STRIP_ERROR_TEXT 0x80000
1.626 +#define PNG_FLAG_BENIGN_ERRORS_WARN 0x100000 /* Added to libpng-1.4.0 */
1.627 +#define PNG_FLAG_APP_WARNINGS_WARN 0x200000 /* Added to libpng-1.6.0 */
1.628 +#define PNG_FLAG_APP_ERRORS_WARN 0x400000 /* Added to libpng-1.6.0 */
1.629 + /* 0x800000 unused */
1.630 + /* 0x1000000 unused */
1.631 + /* 0x2000000 unused */
1.632 + /* 0x4000000 unused */
1.633 + /* 0x8000000 unused */
1.634 + /* 0x10000000 unused */
1.635 + /* 0x20000000 unused */
1.636 + /* 0x40000000 unused */
1.637 +
1.638 +#define PNG_FLAG_CRC_ANCILLARY_MASK (PNG_FLAG_CRC_ANCILLARY_USE | \
1.639 + PNG_FLAG_CRC_ANCILLARY_NOWARN)
1.640 +
1.641 +#define PNG_FLAG_CRC_CRITICAL_MASK (PNG_FLAG_CRC_CRITICAL_USE | \
1.642 + PNG_FLAG_CRC_CRITICAL_IGNORE)
1.643 +
1.644 +#define PNG_FLAG_CRC_MASK (PNG_FLAG_CRC_ANCILLARY_MASK | \
1.645 + PNG_FLAG_CRC_CRITICAL_MASK)
1.646 +
1.647 +/* Save typing and make code easier to understand */
1.648 +
1.649 +#define PNG_COLOR_DIST(c1, c2) (abs((int)((c1).red) - (int)((c2).red)) + \
1.650 + abs((int)((c1).green) - (int)((c2).green)) + \
1.651 + abs((int)((c1).blue) - (int)((c2).blue)))
1.652 +
1.653 +/* Added to libpng-1.6.0: scale a 16-bit value in the range 0..65535 to 0..255
1.654 + * by dividing by 257 *with rounding*. This macro is exact for the given range.
1.655 + * See the discourse in pngrtran.c png_do_scale_16_to_8. The values in the
1.656 + * macro were established by experiment (modifying the added value). The macro
1.657 + * has a second variant that takes a value already scaled by 255 and divides by
1.658 + * 65535 - this has a maximum error of .502. Over the range 0..65535*65535 it
1.659 + * only gives off-by-one errors and only for 0.5% (1 in 200) of the values.
1.660 + */
1.661 +#define PNG_DIV65535(v24) (((v24) + 32895) >> 16)
1.662 +#define PNG_DIV257(v16) PNG_DIV65535((png_uint_32)(v16) * 255)
1.663 +
1.664 +/* Added to libpng-1.2.6 JB */
1.665 +#define PNG_ROWBYTES(pixel_bits, width) \
1.666 + ((pixel_bits) >= 8 ? \
1.667 + ((png_size_t)(width) * (((png_size_t)(pixel_bits)) >> 3)) : \
1.668 + (( ((png_size_t)(width) * ((png_size_t)(pixel_bits))) + 7) >> 3) )
1.669 +
1.670 +/* PNG_OUT_OF_RANGE returns true if value is outside the range
1.671 + * ideal-delta..ideal+delta. Each argument is evaluated twice.
1.672 + * "ideal" and "delta" should be constants, normally simple
1.673 + * integers, "value" a variable. Added to libpng-1.2.6 JB
1.674 + */
1.675 +#define PNG_OUT_OF_RANGE(value, ideal, delta) \
1.676 + ( (value) < (ideal)-(delta) || (value) > (ideal)+(delta) )
1.677 +
1.678 +/* Conversions between fixed and floating point, only defined if
1.679 + * required (to make sure the code doesn't accidentally use float
1.680 + * when it is supposedly disabled.)
1.681 + */
1.682 +#ifdef PNG_FLOATING_POINT_SUPPORTED
1.683 +/* The floating point conversion can't overflow, though it can and
1.684 + * does lose accuracy relative to the original fixed point value.
1.685 + * In practice this doesn't matter because png_fixed_point only
1.686 + * stores numbers with very low precision. The png_ptr and s
1.687 + * arguments are unused by default but are there in case error
1.688 + * checking becomes a requirement.
1.689 + */
1.690 +#define png_float(png_ptr, fixed, s) (.00001 * (fixed))
1.691 +
1.692 +/* The fixed point conversion performs range checking and evaluates
1.693 + * its argument multiple times, so must be used with care. The
1.694 + * range checking uses the PNG specification values for a signed
1.695 + * 32 bit fixed point value except that the values are deliberately
1.696 + * rounded-to-zero to an integral value - 21474 (21474.83 is roughly
1.697 + * (2^31-1) * 100000). 's' is a string that describes the value being
1.698 + * converted.
1.699 + *
1.700 + * NOTE: this macro will raise a png_error if the range check fails,
1.701 + * therefore it is normally only appropriate to use this on values
1.702 + * that come from API calls or other sources where an out of range
1.703 + * error indicates a programming error, not a data error!
1.704 + *
1.705 + * NOTE: by default this is off - the macro is not used - because the
1.706 + * function call saves a lot of code.
1.707 + */
1.708 +#ifdef PNG_FIXED_POINT_MACRO_SUPPORTED
1.709 +#define png_fixed(png_ptr, fp, s) ((fp) <= 21474 && (fp) >= -21474 ?\
1.710 + ((png_fixed_point)(100000 * (fp))) : (png_fixed_error(png_ptr, s),0))
1.711 +#endif
1.712 +/* else the corresponding function is defined below, inside the scope of the
1.713 + * cplusplus test.
1.714 + */
1.715 +#endif
1.716 +
1.717 +/* Constants for known chunk types. If you need to add a chunk, define the name
1.718 + * here. For historical reasons these constants have the form png_<name>; i.e.
1.719 + * the prefix is lower case. Please use decimal values as the parameters to
1.720 + * match the ISO PNG specification and to avoid relying on the C locale
1.721 + * interpretation of character values.
1.722 + *
1.723 + * Prior to 1.5.6 these constants were strings, as of 1.5.6 png_uint_32 values
1.724 + * are computed and a new macro (PNG_STRING_FROM_CHUNK) added to allow a string
1.725 + * to be generated if required.
1.726 + *
1.727 + * PNG_32b correctly produces a value shifted by up to 24 bits, even on
1.728 + * architectures where (int) is only 16 bits.
1.729 + */
1.730 +#define PNG_32b(b,s) ((png_uint_32)(b) << (s))
1.731 +#define PNG_U32(b1,b2,b3,b4) \
1.732 + (PNG_32b(b1,24) | PNG_32b(b2,16) | PNG_32b(b3,8) | PNG_32b(b4,0))
1.733 +
1.734 +/* Constants for known chunk types.
1.735 + *
1.736 + * MAINTAINERS: If you need to add a chunk, define the name here.
1.737 + * For historical reasons these constants have the form png_<name>; i.e.
1.738 + * the prefix is lower case. Please use decimal values as the parameters to
1.739 + * match the ISO PNG specification and to avoid relying on the C locale
1.740 + * interpretation of character values. Please keep the list sorted.
1.741 + *
1.742 + * Notice that PNG_U32 is used to define a 32-bit value for the 4 byte chunk
1.743 + * type. In fact the specification does not express chunk types this way,
1.744 + * however using a 32-bit value means that the chunk type can be read from the
1.745 + * stream using exactly the same code as used for a 32-bit unsigned value and
1.746 + * can be examined far more efficiently (using one arithmetic compare).
1.747 + *
1.748 + * Prior to 1.5.6 the chunk type constants were expressed as C strings. The
1.749 + * libpng API still uses strings for 'unknown' chunks and a macro,
1.750 + * PNG_STRING_FROM_CHUNK, allows a string to be generated if required. Notice
1.751 + * that for portable code numeric values must still be used; the string "IHDR"
1.752 + * is not portable and neither is PNG_U32('I', 'H', 'D', 'R').
1.753 + *
1.754 + * In 1.7.0 the definitions will be made public in png.h to avoid having to
1.755 + * duplicate the same definitions in application code.
1.756 + */
1.757 +#define png_IDAT PNG_U32( 73, 68, 65, 84)
1.758 +#define png_IEND PNG_U32( 73, 69, 78, 68)
1.759 +#define png_IHDR PNG_U32( 73, 72, 68, 82)
1.760 +#define png_PLTE PNG_U32( 80, 76, 84, 69)
1.761 +#define png_bKGD PNG_U32( 98, 75, 71, 68)
1.762 +#define png_cHRM PNG_U32( 99, 72, 82, 77)
1.763 +#define png_fRAc PNG_U32(102, 82, 65, 99) /* registered, not defined */
1.764 +#define png_gAMA PNG_U32(103, 65, 77, 65)
1.765 +#define png_gIFg PNG_U32(103, 73, 70, 103)
1.766 +#define png_gIFt PNG_U32(103, 73, 70, 116) /* deprecated */
1.767 +#define png_gIFx PNG_U32(103, 73, 70, 120)
1.768 +#define png_hIST PNG_U32(104, 73, 83, 84)
1.769 +#define png_iCCP PNG_U32(105, 67, 67, 80)
1.770 +#define png_iTXt PNG_U32(105, 84, 88, 116)
1.771 +#define png_oFFs PNG_U32(111, 70, 70, 115)
1.772 +#define png_pCAL PNG_U32(112, 67, 65, 76)
1.773 +#define png_pHYs PNG_U32(112, 72, 89, 115)
1.774 +#define png_sBIT PNG_U32(115, 66, 73, 84)
1.775 +#define png_sCAL PNG_U32(115, 67, 65, 76)
1.776 +#define png_sPLT PNG_U32(115, 80, 76, 84)
1.777 +#define png_sRGB PNG_U32(115, 82, 71, 66)
1.778 +#define png_sTER PNG_U32(115, 84, 69, 82)
1.779 +#define png_tEXt PNG_U32(116, 69, 88, 116)
1.780 +#define png_tIME PNG_U32(116, 73, 77, 69)
1.781 +#define png_tRNS PNG_U32(116, 82, 78, 83)
1.782 +#define png_zTXt PNG_U32(122, 84, 88, 116)
1.783 +
1.784 +#ifdef PNG_APNG_SUPPORTED
1.785 +#define png_acTL PNG_U32( 97, 99, 84, 76)
1.786 +#define png_fcTL PNG_U32(102, 99, 84, 76)
1.787 +#define png_fdAT PNG_U32(102, 100, 65, 84)
1.788 +
1.789 +/* For png_struct.apng_flags: */
1.790 +#define PNG_FIRST_FRAME_HIDDEN 0x0001
1.791 +#define PNG_APNG_APP 0x0002
1.792 +#endif
1.793 +
1.794 +/* The following will work on (signed char*) strings, whereas the get_uint_32
1.795 + * macro will fail on top-bit-set values because of the sign extension.
1.796 + */
1.797 +#define PNG_CHUNK_FROM_STRING(s)\
1.798 + PNG_U32(0xff&(s)[0], 0xff&(s)[1], 0xff&(s)[2], 0xff&(s)[3])
1.799 +
1.800 +/* This uses (char), not (png_byte) to avoid warnings on systems where (char) is
1.801 + * signed and the argument is a (char[]) This macro will fail miserably on
1.802 + * systems where (char) is more than 8 bits.
1.803 + */
1.804 +#define PNG_STRING_FROM_CHUNK(s,c)\
1.805 + (void)(((char*)(s))[0]=(char)((c)>>24), ((char*)(s))[1]=(char)((c)>>16),\
1.806 + ((char*)(s))[2]=(char)((c)>>8), ((char*)(s))[3]=(char)((c)))
1.807 +
1.808 +/* Do the same but terminate with a null character. */
1.809 +#define PNG_CSTRING_FROM_CHUNK(s,c)\
1.810 + (void)(PNG_STRING_FROM_CHUNK(s,c), ((char*)(s))[4] = 0)
1.811 +
1.812 +/* Test on flag values as defined in the spec (section 5.4): */
1.813 +#define PNG_CHUNK_ANCILLARY(c) (1 & ((c) >> 29))
1.814 +#define PNG_CHUNK_CRITICAL(c) (!PNG_CHUNK_ANCILLARY(c))
1.815 +#define PNG_CHUNK_PRIVATE(c) (1 & ((c) >> 21))
1.816 +#define PNG_CHUNK_RESERVED(c) (1 & ((c) >> 13))
1.817 +#define PNG_CHUNK_SAFE_TO_COPY(c) (1 & ((c) >> 5))
1.818 +
1.819 +/* Gamma values (new at libpng-1.5.4): */
1.820 +#define PNG_GAMMA_MAC_OLD 151724 /* Assume '1.8' is really 2.2/1.45! */
1.821 +#define PNG_GAMMA_MAC_INVERSE 65909
1.822 +#define PNG_GAMMA_sRGB_INVERSE 45455
1.823 +
1.824 +/* Almost everything below is C specific; the #defines above can be used in
1.825 + * non-C code (so long as it is C-preprocessed) the rest of this stuff cannot.
1.826 + */
1.827 +#ifndef PNG_VERSION_INFO_ONLY
1.828 +
1.829 +#include "pngstruct.h"
1.830 +#include "pnginfo.h"
1.831 +
1.832 +/* Validate the include paths - the include path used to generate pnglibconf.h
1.833 + * must match that used in the build, or we must be using pnglibconf.h.prebuilt:
1.834 + */
1.835 +#if PNG_ZLIB_VERNUM != 0 && PNG_ZLIB_VERNUM != ZLIB_VERNUM
1.836 +# error ZLIB_VERNUM != PNG_ZLIB_VERNUM \
1.837 + "-I (include path) error: see the notes in pngpriv.h"
1.838 + /* This means that when pnglibconf.h was built the copy of zlib.h that it
1.839 + * used is not the same as the one being used here. Because the build of
1.840 + * libpng makes decisions to use inflateInit2 and inflateReset2 based on the
1.841 + * zlib version number and because this affects handling of certain broken
1.842 + * PNG files the -I directives must match.
1.843 + *
1.844 + * The most likely explanation is that you passed a -I in CFLAGS, this will
1.845 + * not work; all the preprocessor directories and in particular all the -I
1.846 + * directives must be in CPPFLAGS.
1.847 + */
1.848 +#endif
1.849 +
1.850 +/* This is used for 16 bit gamma tables -- only the top level pointers are
1.851 + * const; this could be changed:
1.852 + */
1.853 +typedef const png_uint_16p * png_const_uint_16pp;
1.854 +
1.855 +/* Added to libpng-1.5.7: sRGB conversion tables */
1.856 +#if defined(PNG_SIMPLIFIED_READ_SUPPORTED) ||\
1.857 + defined(PNG_SIMPLIFIED_WRITE_SUPPORTED)
1.858 +#ifdef PNG_SIMPLIFIED_READ_SUPPORTED
1.859 +PNG_INTERNAL_DATA(const png_uint_16, png_sRGB_table, [256]);
1.860 + /* Convert from an sRGB encoded value 0..255 to a 16-bit linear value,
1.861 + * 0..65535. This table gives the closest 16-bit answers (no errors).
1.862 + */
1.863 +#endif
1.864 +
1.865 +PNG_INTERNAL_DATA(const png_uint_16, png_sRGB_base, [512]);
1.866 +PNG_INTERNAL_DATA(const png_byte, png_sRGB_delta, [512]);
1.867 +
1.868 +#define PNG_sRGB_FROM_LINEAR(linear) ((png_byte)((png_sRGB_base[(linear)>>15] +\
1.869 + ((((linear)&0x7fff)*png_sRGB_delta[(linear)>>15])>>12)) >> 8))
1.870 + /* Given a value 'linear' in the range 0..255*65535 calculate the 8-bit sRGB
1.871 + * encoded value with maximum error 0.646365. Note that the input is not a
1.872 + * 16-bit value; it has been multiplied by 255! */
1.873 +#endif /* PNG_SIMPLIFIED_READ/WRITE */
1.874 +
1.875 +
1.876 +/* Inhibit C++ name-mangling for libpng functions but not for system calls. */
1.877 +#ifdef __cplusplus
1.878 +extern "C" {
1.879 +#endif /* __cplusplus */
1.880 +
1.881 +/* Internal functions; these are not exported from a DLL however because they
1.882 + * are used within several of the C source files they have to be C extern.
1.883 + *
1.884 + * All of these functions must be declared with PNG_INTERNAL_FUNCTION.
1.885 + */
1.886 +
1.887 +/* Zlib support */
1.888 +#define PNG_UNEXPECTED_ZLIB_RETURN (-7)
1.889 +PNG_INTERNAL_FUNCTION(void, png_zstream_error,(png_structrp png_ptr, int ret),
1.890 + PNG_EMPTY);
1.891 + /* Used by the zlib handling functions to ensure that z_stream::msg is always
1.892 + * set before they return.
1.893 + */
1.894 +
1.895 +#ifdef PNG_WRITE_SUPPORTED
1.896 +PNG_INTERNAL_FUNCTION(void,png_free_buffer_list,(png_structrp png_ptr,
1.897 + png_compression_bufferp *list),PNG_EMPTY);
1.898 + /* Free the buffer list used by the compressed write code. */
1.899 +#endif
1.900 +
1.901 +#if defined(PNG_FLOATING_POINT_SUPPORTED) && \
1.902 + !defined(PNG_FIXED_POINT_MACRO_SUPPORTED) && \
1.903 + (defined(PNG_gAMA_SUPPORTED) || defined(PNG_cHRM_SUPPORTED) || \
1.904 + defined(PNG_sCAL_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) || \
1.905 + defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)) || \
1.906 + (defined(PNG_sCAL_SUPPORTED) && \
1.907 + defined(PNG_FLOATING_ARITHMETIC_SUPPORTED))
1.908 +PNG_INTERNAL_FUNCTION(png_fixed_point,png_fixed,(png_const_structrp png_ptr,
1.909 + double fp, png_const_charp text),PNG_EMPTY);
1.910 +#endif
1.911 +
1.912 +/* Check the user version string for compatibility, returns false if the version
1.913 + * numbers aren't compatible.
1.914 + */
1.915 +PNG_INTERNAL_FUNCTION(int,png_user_version_check,(png_structrp png_ptr,
1.916 + png_const_charp user_png_ver),PNG_EMPTY);
1.917 +
1.918 +/* Internal base allocator - no messages, NULL on failure to allocate. This
1.919 + * does, however, call the application provided allocator and that could call
1.920 + * png_error (although that would be a bug in the application implementation.)
1.921 + */
1.922 +PNG_INTERNAL_FUNCTION(png_voidp,png_malloc_base,(png_const_structrp png_ptr,
1.923 + png_alloc_size_t size),PNG_ALLOCATED);
1.924 +
1.925 +#if defined(PNG_TEXT_SUPPORTED) || defined(PNG_sPLT_SUPPORTED) ||\
1.926 + defined(PNG_STORE_UNKNOWN_CHUNKS_SUPPORTED)
1.927 +/* Internal array allocator, outputs no error or warning messages on failure,
1.928 + * just returns NULL.
1.929 + */
1.930 +PNG_INTERNAL_FUNCTION(png_voidp,png_malloc_array,(png_const_structrp png_ptr,
1.931 + int nelements, size_t element_size),PNG_ALLOCATED);
1.932 +
1.933 +/* The same but an existing array is extended by add_elements. This function
1.934 + * also memsets the new elements to 0 and copies the old elements. The old
1.935 + * array is not freed or altered.
1.936 + */
1.937 +PNG_INTERNAL_FUNCTION(png_voidp,png_realloc_array,(png_const_structrp png_ptr,
1.938 + png_const_voidp array, int old_elements, int add_elements,
1.939 + size_t element_size),PNG_ALLOCATED);
1.940 +#endif /* text, sPLT or unknown chunks */
1.941 +
1.942 +/* Magic to create a struct when there is no struct to call the user supplied
1.943 + * memory allocators. Because error handling has not been set up the memory
1.944 + * handlers can't safely call png_error, but this is an obscure and undocumented
1.945 + * restriction so libpng has to assume that the 'free' handler, at least, might
1.946 + * call png_error.
1.947 + */
1.948 +PNG_INTERNAL_FUNCTION(png_structp,png_create_png_struct,
1.949 + (png_const_charp user_png_ver, png_voidp error_ptr, png_error_ptr error_fn,
1.950 + png_error_ptr warn_fn, png_voidp mem_ptr, png_malloc_ptr malloc_fn,
1.951 + png_free_ptr free_fn),PNG_ALLOCATED);
1.952 +
1.953 +/* Free memory from internal libpng struct */
1.954 +PNG_INTERNAL_FUNCTION(void,png_destroy_png_struct,(png_structrp png_ptr),
1.955 + PNG_EMPTY);
1.956 +
1.957 +/* Free an allocated jmp_buf (always succeeds) */
1.958 +PNG_INTERNAL_FUNCTION(void,png_free_jmpbuf,(png_structrp png_ptr),PNG_EMPTY);
1.959 +
1.960 +/* Function to allocate memory for zlib. PNGAPI is disallowed. */
1.961 +PNG_INTERNAL_FUNCTION(voidpf,png_zalloc,(voidpf png_ptr, uInt items, uInt size),
1.962 + PNG_ALLOCATED);
1.963 +
1.964 +/* Function to free memory for zlib. PNGAPI is disallowed. */
1.965 +PNG_INTERNAL_FUNCTION(void,png_zfree,(voidpf png_ptr, voidpf ptr),PNG_EMPTY);
1.966 +
1.967 +/* Next four functions are used internally as callbacks. PNGCBAPI is required
1.968 + * but not PNG_EXPORT. PNGAPI added at libpng version 1.2.3, changed to
1.969 + * PNGCBAPI at 1.5.0
1.970 + */
1.971 +
1.972 +PNG_INTERNAL_FUNCTION(void PNGCBAPI,png_default_read_data,(png_structp png_ptr,
1.973 + png_bytep data, png_size_t length),PNG_EMPTY);
1.974 +
1.975 +#ifdef PNG_PROGRESSIVE_READ_SUPPORTED
1.976 +PNG_INTERNAL_FUNCTION(void PNGCBAPI,png_push_fill_buffer,(png_structp png_ptr,
1.977 + png_bytep buffer, png_size_t length),PNG_EMPTY);
1.978 +#endif
1.979 +
1.980 +PNG_INTERNAL_FUNCTION(void PNGCBAPI,png_default_write_data,(png_structp png_ptr,
1.981 + png_bytep data, png_size_t length),PNG_EMPTY);
1.982 +
1.983 +#ifdef PNG_WRITE_FLUSH_SUPPORTED
1.984 +# ifdef PNG_STDIO_SUPPORTED
1.985 +PNG_INTERNAL_FUNCTION(void PNGCBAPI,png_default_flush,(png_structp png_ptr),
1.986 + PNG_EMPTY);
1.987 +# endif
1.988 +#endif
1.989 +
1.990 +/* Reset the CRC variable */
1.991 +PNG_INTERNAL_FUNCTION(void,png_reset_crc,(png_structrp png_ptr),PNG_EMPTY);
1.992 +
1.993 +/* Write the "data" buffer to whatever output you are using */
1.994 +PNG_INTERNAL_FUNCTION(void,png_write_data,(png_structrp png_ptr,
1.995 + png_const_bytep data, png_size_t length),PNG_EMPTY);
1.996 +
1.997 +/* Read and check the PNG file signature */
1.998 +PNG_INTERNAL_FUNCTION(void,png_read_sig,(png_structrp png_ptr,
1.999 + png_inforp info_ptr),PNG_EMPTY);
1.1000 +
1.1001 +/* Read the chunk header (length + type name) */
1.1002 +PNG_INTERNAL_FUNCTION(png_uint_32,png_read_chunk_header,(png_structrp png_ptr),
1.1003 + PNG_EMPTY);
1.1004 +
1.1005 +/* Read data from whatever input you are using into the "data" buffer */
1.1006 +PNG_INTERNAL_FUNCTION(void,png_read_data,(png_structrp png_ptr, png_bytep data,
1.1007 + png_size_t length),PNG_EMPTY);
1.1008 +
1.1009 +/* Read bytes into buf, and update png_ptr->crc */
1.1010 +PNG_INTERNAL_FUNCTION(void,png_crc_read,(png_structrp png_ptr, png_bytep buf,
1.1011 + png_uint_32 length),PNG_EMPTY);
1.1012 +
1.1013 +/* Read "skip" bytes, read the file crc, and (optionally) verify png_ptr->crc */
1.1014 +PNG_INTERNAL_FUNCTION(int,png_crc_finish,(png_structrp png_ptr,
1.1015 + png_uint_32 skip),PNG_EMPTY);
1.1016 +
1.1017 +/* Read the CRC from the file and compare it to the libpng calculated CRC */
1.1018 +PNG_INTERNAL_FUNCTION(int,png_crc_error,(png_structrp png_ptr),PNG_EMPTY);
1.1019 +
1.1020 +/* Calculate the CRC over a section of data. Note that we are only
1.1021 + * passing a maximum of 64K on systems that have this as a memory limit,
1.1022 + * since this is the maximum buffer size we can specify.
1.1023 + */
1.1024 +PNG_INTERNAL_FUNCTION(void,png_calculate_crc,(png_structrp png_ptr,
1.1025 + png_const_bytep ptr, png_size_t length),PNG_EMPTY);
1.1026 +
1.1027 +#ifdef PNG_WRITE_FLUSH_SUPPORTED
1.1028 +PNG_INTERNAL_FUNCTION(void,png_flush,(png_structrp png_ptr),PNG_EMPTY);
1.1029 +#endif
1.1030 +
1.1031 +/* Write various chunks */
1.1032 +
1.1033 +/* Write the IHDR chunk, and update the png_struct with the necessary
1.1034 + * information.
1.1035 + */
1.1036 +PNG_INTERNAL_FUNCTION(void,png_write_IHDR,(png_structrp png_ptr,
1.1037 + png_uint_32 width, png_uint_32 height, int bit_depth, int color_type,
1.1038 + int compression_method, int filter_method, int interlace_method),PNG_EMPTY);
1.1039 +
1.1040 +PNG_INTERNAL_FUNCTION(void,png_write_PLTE,(png_structrp png_ptr,
1.1041 + png_const_colorp palette, png_uint_32 num_pal),PNG_EMPTY);
1.1042 +
1.1043 +PNG_INTERNAL_FUNCTION(void,png_compress_IDAT,(png_structrp png_ptr,
1.1044 + png_const_bytep row_data, png_alloc_size_t row_data_length, int flush),
1.1045 + PNG_EMPTY);
1.1046 +
1.1047 +PNG_INTERNAL_FUNCTION(void,png_write_IEND,(png_structrp png_ptr),PNG_EMPTY);
1.1048 +
1.1049 +#ifdef PNG_WRITE_gAMA_SUPPORTED
1.1050 +PNG_INTERNAL_FUNCTION(void,png_write_gAMA_fixed,(png_structrp png_ptr,
1.1051 + png_fixed_point file_gamma),PNG_EMPTY);
1.1052 +#endif
1.1053 +
1.1054 +#ifdef PNG_WRITE_sBIT_SUPPORTED
1.1055 +PNG_INTERNAL_FUNCTION(void,png_write_sBIT,(png_structrp png_ptr,
1.1056 + png_const_color_8p sbit, int color_type),PNG_EMPTY);
1.1057 +#endif
1.1058 +
1.1059 +#ifdef PNG_WRITE_cHRM_SUPPORTED
1.1060 +PNG_INTERNAL_FUNCTION(void,png_write_cHRM_fixed,(png_structrp png_ptr,
1.1061 + const png_xy *xy), PNG_EMPTY);
1.1062 + /* The xy value must have been previously validated */
1.1063 +#endif
1.1064 +
1.1065 +#ifdef PNG_WRITE_sRGB_SUPPORTED
1.1066 +PNG_INTERNAL_FUNCTION(void,png_write_sRGB,(png_structrp png_ptr,
1.1067 + int intent),PNG_EMPTY);
1.1068 +#endif
1.1069 +
1.1070 +#ifdef PNG_WRITE_iCCP_SUPPORTED
1.1071 +PNG_INTERNAL_FUNCTION(void,png_write_iCCP,(png_structrp png_ptr,
1.1072 + png_const_charp name, png_const_bytep profile), PNG_EMPTY);
1.1073 + /* The profile must have been previously validated for correctness, the
1.1074 + * length comes from the first four bytes. Only the base, deflate,
1.1075 + * compression is supported.
1.1076 + */
1.1077 +#endif
1.1078 +
1.1079 +#ifdef PNG_WRITE_sPLT_SUPPORTED
1.1080 +PNG_INTERNAL_FUNCTION(void,png_write_sPLT,(png_structrp png_ptr,
1.1081 + png_const_sPLT_tp palette),PNG_EMPTY);
1.1082 +#endif
1.1083 +
1.1084 +#ifdef PNG_WRITE_tRNS_SUPPORTED
1.1085 +PNG_INTERNAL_FUNCTION(void,png_write_tRNS,(png_structrp png_ptr,
1.1086 + png_const_bytep trans, png_const_color_16p values, int number,
1.1087 + int color_type),PNG_EMPTY);
1.1088 +#endif
1.1089 +
1.1090 +#ifdef PNG_WRITE_bKGD_SUPPORTED
1.1091 +PNG_INTERNAL_FUNCTION(void,png_write_bKGD,(png_structrp png_ptr,
1.1092 + png_const_color_16p values, int color_type),PNG_EMPTY);
1.1093 +#endif
1.1094 +
1.1095 +#ifdef PNG_WRITE_hIST_SUPPORTED
1.1096 +PNG_INTERNAL_FUNCTION(void,png_write_hIST,(png_structrp png_ptr,
1.1097 + png_const_uint_16p hist, int num_hist),PNG_EMPTY);
1.1098 +#endif
1.1099 +
1.1100 +/* Chunks that have keywords */
1.1101 +#ifdef PNG_WRITE_tEXt_SUPPORTED
1.1102 +PNG_INTERNAL_FUNCTION(void,png_write_tEXt,(png_structrp png_ptr,
1.1103 + png_const_charp key, png_const_charp text, png_size_t text_len),PNG_EMPTY);
1.1104 +#endif
1.1105 +
1.1106 +#ifdef PNG_WRITE_zTXt_SUPPORTED
1.1107 +PNG_INTERNAL_FUNCTION(void,png_write_zTXt,(png_structrp png_ptr, png_const_charp
1.1108 + key, png_const_charp text, png_size_t text_len, int compression),PNG_EMPTY);
1.1109 +#endif
1.1110 +
1.1111 +#ifdef PNG_WRITE_iTXt_SUPPORTED
1.1112 +PNG_INTERNAL_FUNCTION(void,png_write_iTXt,(png_structrp png_ptr,
1.1113 + int compression, png_const_charp key, png_const_charp lang,
1.1114 + png_const_charp lang_key, png_const_charp text),PNG_EMPTY);
1.1115 +#endif
1.1116 +
1.1117 +#ifdef PNG_TEXT_SUPPORTED /* Added at version 1.0.14 and 1.2.4 */
1.1118 +PNG_INTERNAL_FUNCTION(int,png_set_text_2,(png_const_structrp png_ptr,
1.1119 + png_inforp info_ptr, png_const_textp text_ptr, int num_text),PNG_EMPTY);
1.1120 +#endif
1.1121 +
1.1122 +#ifdef PNG_WRITE_oFFs_SUPPORTED
1.1123 +PNG_INTERNAL_FUNCTION(void,png_write_oFFs,(png_structrp png_ptr,
1.1124 + png_int_32 x_offset, png_int_32 y_offset, int unit_type),PNG_EMPTY);
1.1125 +#endif
1.1126 +
1.1127 +#ifdef PNG_WRITE_pCAL_SUPPORTED
1.1128 +PNG_INTERNAL_FUNCTION(void,png_write_pCAL,(png_structrp png_ptr,
1.1129 + png_charp purpose, png_int_32 X0, png_int_32 X1, int type, int nparams,
1.1130 + png_const_charp units, png_charpp params),PNG_EMPTY);
1.1131 +#endif
1.1132 +
1.1133 +#ifdef PNG_WRITE_pHYs_SUPPORTED
1.1134 +PNG_INTERNAL_FUNCTION(void,png_write_pHYs,(png_structrp png_ptr,
1.1135 + png_uint_32 x_pixels_per_unit, png_uint_32 y_pixels_per_unit,
1.1136 + int unit_type),PNG_EMPTY);
1.1137 +#endif
1.1138 +
1.1139 +#ifdef PNG_WRITE_tIME_SUPPORTED
1.1140 +PNG_INTERNAL_FUNCTION(void,png_write_tIME,(png_structrp png_ptr,
1.1141 + png_const_timep mod_time),PNG_EMPTY);
1.1142 +#endif
1.1143 +
1.1144 +#ifdef PNG_WRITE_sCAL_SUPPORTED
1.1145 +PNG_INTERNAL_FUNCTION(void,png_write_sCAL_s,(png_structrp png_ptr,
1.1146 + int unit, png_const_charp width, png_const_charp height),PNG_EMPTY);
1.1147 +#endif
1.1148 +
1.1149 +/* Called when finished processing a row of data */
1.1150 +PNG_INTERNAL_FUNCTION(void,png_write_finish_row,(png_structrp png_ptr),
1.1151 + PNG_EMPTY);
1.1152 +
1.1153 +/* Internal use only. Called before first row of data */
1.1154 +PNG_INTERNAL_FUNCTION(void,png_write_start_row,(png_structrp png_ptr),
1.1155 + PNG_EMPTY);
1.1156 +
1.1157 +/* Combine a row of data, dealing with alpha, etc. if requested. 'row' is an
1.1158 + * array of png_ptr->width pixels. If the image is not interlaced or this
1.1159 + * is the final pass this just does a memcpy, otherwise the "display" flag
1.1160 + * is used to determine whether to copy pixels that are not in the current pass.
1.1161 + *
1.1162 + * Because 'png_do_read_interlace' (below) replicates pixels this allows this
1.1163 + * function to achieve the documented 'blocky' appearance during interlaced read
1.1164 + * if display is 1 and the 'sparkle' appearance, where existing pixels in 'row'
1.1165 + * are not changed if they are not in the current pass, when display is 0.
1.1166 + *
1.1167 + * 'display' must be 0 or 1, otherwise the memcpy will be done regardless.
1.1168 + *
1.1169 + * The API always reads from the png_struct row buffer and always assumes that
1.1170 + * it is full width (png_do_read_interlace has already been called.)
1.1171 + *
1.1172 + * This function is only ever used to write to row buffers provided by the
1.1173 + * caller of the relevant libpng API and the row must have already been
1.1174 + * transformed by the read transformations.
1.1175 + *
1.1176 + * The PNG_USE_COMPILE_TIME_MASKS option causes generation of pre-computed
1.1177 + * bitmasks for use within the code, otherwise runtime generated masks are used.
1.1178 + * The default is compile time masks.
1.1179 + */
1.1180 +#ifndef PNG_USE_COMPILE_TIME_MASKS
1.1181 +# define PNG_USE_COMPILE_TIME_MASKS 1
1.1182 +#endif
1.1183 +PNG_INTERNAL_FUNCTION(void,png_combine_row,(png_const_structrp png_ptr,
1.1184 + png_bytep row, int display),PNG_EMPTY);
1.1185 +
1.1186 +#ifdef PNG_READ_INTERLACING_SUPPORTED
1.1187 +/* Expand an interlaced row: the 'row_info' describes the pass data that has
1.1188 + * been read in and must correspond to the pixels in 'row', the pixels are
1.1189 + * expanded (moved apart) in 'row' to match the final layout, when doing this
1.1190 + * the pixels are *replicated* to the intervening space. This is essential for
1.1191 + * the correct operation of png_combine_row, above.
1.1192 + */
1.1193 +PNG_INTERNAL_FUNCTION(void,png_do_read_interlace,(png_row_infop row_info,
1.1194 + png_bytep row, int pass, png_uint_32 transformations),PNG_EMPTY);
1.1195 +#endif
1.1196 +
1.1197 +/* GRR TO DO (2.0 or whenever): simplify other internal calling interfaces */
1.1198 +
1.1199 +#ifdef PNG_WRITE_INTERLACING_SUPPORTED
1.1200 +/* Grab pixels out of a row for an interlaced pass */
1.1201 +PNG_INTERNAL_FUNCTION(void,png_do_write_interlace,(png_row_infop row_info,
1.1202 + png_bytep row, int pass),PNG_EMPTY);
1.1203 +#endif
1.1204 +
1.1205 +/* Unfilter a row: check the filter value before calling this, there is no point
1.1206 + * calling it for PNG_FILTER_VALUE_NONE.
1.1207 + */
1.1208 +PNG_INTERNAL_FUNCTION(void,png_read_filter_row,(png_structrp pp, png_row_infop
1.1209 + row_info, png_bytep row, png_const_bytep prev_row, int filter),PNG_EMPTY);
1.1210 +
1.1211 +PNG_INTERNAL_FUNCTION(void,png_read_filter_row_up_neon,(png_row_infop row_info,
1.1212 + png_bytep row, png_const_bytep prev_row),PNG_EMPTY);
1.1213 +PNG_INTERNAL_FUNCTION(void,png_read_filter_row_sub3_neon,(png_row_infop
1.1214 + row_info, png_bytep row, png_const_bytep prev_row),PNG_EMPTY);
1.1215 +PNG_INTERNAL_FUNCTION(void,png_read_filter_row_sub4_neon,(png_row_infop
1.1216 + row_info, png_bytep row, png_const_bytep prev_row),PNG_EMPTY);
1.1217 +PNG_INTERNAL_FUNCTION(void,png_read_filter_row_avg3_neon,(png_row_infop
1.1218 + row_info, png_bytep row, png_const_bytep prev_row),PNG_EMPTY);
1.1219 +PNG_INTERNAL_FUNCTION(void,png_read_filter_row_avg4_neon,(png_row_infop
1.1220 + row_info, png_bytep row, png_const_bytep prev_row),PNG_EMPTY);
1.1221 +PNG_INTERNAL_FUNCTION(void,png_read_filter_row_paeth3_neon,(png_row_infop
1.1222 + row_info, png_bytep row, png_const_bytep prev_row),PNG_EMPTY);
1.1223 +PNG_INTERNAL_FUNCTION(void,png_read_filter_row_paeth4_neon,(png_row_infop
1.1224 + row_info, png_bytep row, png_const_bytep prev_row),PNG_EMPTY);
1.1225 +
1.1226 +/* Choose the best filter to use and filter the row data */
1.1227 +PNG_INTERNAL_FUNCTION(void,png_write_find_filter,(png_structrp png_ptr,
1.1228 + png_row_infop row_info),PNG_EMPTY);
1.1229 +
1.1230 +#ifdef PNG_SEQUENTIAL_READ_SUPPORTED
1.1231 +PNG_INTERNAL_FUNCTION(void,png_read_IDAT_data,(png_structrp png_ptr,
1.1232 + png_bytep output, png_alloc_size_t avail_out),PNG_EMPTY);
1.1233 + /* Read 'avail_out' bytes of data from the IDAT stream. If the output buffer
1.1234 + * is NULL the function checks, instead, for the end of the stream. In this
1.1235 + * case a benign error will be issued if the stream end is not found or if
1.1236 + * extra data has to be consumed.
1.1237 + */
1.1238 +PNG_INTERNAL_FUNCTION(void,png_read_finish_IDAT,(png_structrp png_ptr),
1.1239 + PNG_EMPTY);
1.1240 + /* This cleans up when the IDAT LZ stream does not end when the last image
1.1241 + * byte is read; there is still some pending input.
1.1242 + */
1.1243 +
1.1244 +PNG_INTERNAL_FUNCTION(void,png_read_finish_row,(png_structrp png_ptr),
1.1245 + PNG_EMPTY);
1.1246 + /* Finish a row while reading, dealing with interlacing passes, etc. */
1.1247 +#endif /* PNG_SEQUENTIAL_READ_SUPPORTED */
1.1248 +
1.1249 +/* Initialize the row buffers, etc. */
1.1250 +PNG_INTERNAL_FUNCTION(void,png_read_start_row,(png_structrp png_ptr),PNG_EMPTY);
1.1251 +
1.1252 +#ifdef PNG_READ_TRANSFORMS_SUPPORTED
1.1253 +/* Optional call to update the users info structure */
1.1254 +PNG_INTERNAL_FUNCTION(void,png_read_transform_info,(png_structrp png_ptr,
1.1255 + png_inforp info_ptr),PNG_EMPTY);
1.1256 +#endif
1.1257 +
1.1258 +/* Shared transform functions, defined in pngtran.c */
1.1259 +#if defined(PNG_WRITE_FILLER_SUPPORTED) || \
1.1260 + defined(PNG_READ_STRIP_ALPHA_SUPPORTED)
1.1261 +PNG_INTERNAL_FUNCTION(void,png_do_strip_channel,(png_row_infop row_info,
1.1262 + png_bytep row, int at_start),PNG_EMPTY);
1.1263 +#endif
1.1264 +
1.1265 +#ifdef PNG_16BIT_SUPPORTED
1.1266 +#if defined(PNG_READ_SWAP_SUPPORTED) || defined(PNG_WRITE_SWAP_SUPPORTED)
1.1267 +PNG_INTERNAL_FUNCTION(void,png_do_swap,(png_row_infop row_info,
1.1268 + png_bytep row),PNG_EMPTY);
1.1269 +#endif
1.1270 +#endif
1.1271 +
1.1272 +#if defined(PNG_READ_PACKSWAP_SUPPORTED) || \
1.1273 + defined(PNG_WRITE_PACKSWAP_SUPPORTED)
1.1274 +PNG_INTERNAL_FUNCTION(void,png_do_packswap,(png_row_infop row_info,
1.1275 + png_bytep row),PNG_EMPTY);
1.1276 +#endif
1.1277 +
1.1278 +#if defined(PNG_READ_INVERT_SUPPORTED) || defined(PNG_WRITE_INVERT_SUPPORTED)
1.1279 +PNG_INTERNAL_FUNCTION(void,png_do_invert,(png_row_infop row_info,
1.1280 + png_bytep row),PNG_EMPTY);
1.1281 +#endif
1.1282 +
1.1283 +#if defined(PNG_READ_BGR_SUPPORTED) || defined(PNG_WRITE_BGR_SUPPORTED)
1.1284 +PNG_INTERNAL_FUNCTION(void,png_do_bgr,(png_row_infop row_info,
1.1285 + png_bytep row),PNG_EMPTY);
1.1286 +#endif
1.1287 +
1.1288 +/* The following decodes the appropriate chunks, and does error correction,
1.1289 + * then calls the appropriate callback for the chunk if it is valid.
1.1290 + */
1.1291 +
1.1292 +/* Decode the IHDR chunk */
1.1293 +PNG_INTERNAL_FUNCTION(void,png_handle_IHDR,(png_structrp png_ptr,
1.1294 + png_inforp info_ptr, png_uint_32 length),PNG_EMPTY);
1.1295 +PNG_INTERNAL_FUNCTION(void,png_handle_PLTE,(png_structrp png_ptr,
1.1296 + png_inforp info_ptr, png_uint_32 length),PNG_EMPTY);
1.1297 +PNG_INTERNAL_FUNCTION(void,png_handle_IEND,(png_structrp png_ptr,
1.1298 + png_inforp info_ptr, png_uint_32 length),PNG_EMPTY);
1.1299 +
1.1300 +#ifdef PNG_READ_bKGD_SUPPORTED
1.1301 +PNG_INTERNAL_FUNCTION(void,png_handle_bKGD,(png_structrp png_ptr,
1.1302 + png_inforp info_ptr, png_uint_32 length),PNG_EMPTY);
1.1303 +#endif
1.1304 +
1.1305 +#ifdef PNG_READ_cHRM_SUPPORTED
1.1306 +PNG_INTERNAL_FUNCTION(void,png_handle_cHRM,(png_structrp png_ptr,
1.1307 + png_inforp info_ptr, png_uint_32 length),PNG_EMPTY);
1.1308 +#endif
1.1309 +
1.1310 +#ifdef PNG_READ_gAMA_SUPPORTED
1.1311 +PNG_INTERNAL_FUNCTION(void,png_handle_gAMA,(png_structrp png_ptr,
1.1312 + png_inforp info_ptr, png_uint_32 length),PNG_EMPTY);
1.1313 +#endif
1.1314 +
1.1315 +#ifdef PNG_READ_hIST_SUPPORTED
1.1316 +PNG_INTERNAL_FUNCTION(void,png_handle_hIST,(png_structrp png_ptr,
1.1317 + png_inforp info_ptr, png_uint_32 length),PNG_EMPTY);
1.1318 +#endif
1.1319 +
1.1320 +#ifdef PNG_READ_iCCP_SUPPORTED
1.1321 +PNG_INTERNAL_FUNCTION(void,png_handle_iCCP,(png_structrp png_ptr,
1.1322 + png_inforp info_ptr, png_uint_32 length),PNG_EMPTY);
1.1323 +#endif /* PNG_READ_iCCP_SUPPORTED */
1.1324 +
1.1325 +#ifdef PNG_READ_iTXt_SUPPORTED
1.1326 +PNG_INTERNAL_FUNCTION(void,png_handle_iTXt,(png_structrp png_ptr,
1.1327 + png_inforp info_ptr, png_uint_32 length),PNG_EMPTY);
1.1328 +#endif
1.1329 +
1.1330 +#ifdef PNG_READ_oFFs_SUPPORTED
1.1331 +PNG_INTERNAL_FUNCTION(void,png_handle_oFFs,(png_structrp png_ptr,
1.1332 + png_inforp info_ptr, png_uint_32 length),PNG_EMPTY);
1.1333 +#endif
1.1334 +
1.1335 +#ifdef PNG_READ_pCAL_SUPPORTED
1.1336 +PNG_INTERNAL_FUNCTION(void,png_handle_pCAL,(png_structrp png_ptr,
1.1337 + png_inforp info_ptr, png_uint_32 length),PNG_EMPTY);
1.1338 +#endif
1.1339 +
1.1340 +#ifdef PNG_READ_pHYs_SUPPORTED
1.1341 +PNG_INTERNAL_FUNCTION(void,png_handle_pHYs,(png_structrp png_ptr,
1.1342 + png_inforp info_ptr, png_uint_32 length),PNG_EMPTY);
1.1343 +#endif
1.1344 +
1.1345 +#ifdef PNG_READ_sBIT_SUPPORTED
1.1346 +PNG_INTERNAL_FUNCTION(void,png_handle_sBIT,(png_structrp png_ptr,
1.1347 + png_inforp info_ptr, png_uint_32 length),PNG_EMPTY);
1.1348 +#endif
1.1349 +
1.1350 +#ifdef PNG_READ_sCAL_SUPPORTED
1.1351 +PNG_INTERNAL_FUNCTION(void,png_handle_sCAL,(png_structrp png_ptr,
1.1352 + png_inforp info_ptr, png_uint_32 length),PNG_EMPTY);
1.1353 +#endif
1.1354 +
1.1355 +#ifdef PNG_READ_sPLT_SUPPORTED
1.1356 +PNG_INTERNAL_FUNCTION(void,png_handle_sPLT,(png_structrp png_ptr,
1.1357 + png_inforp info_ptr, png_uint_32 length),PNG_EMPTY);
1.1358 +#endif /* PNG_READ_sPLT_SUPPORTED */
1.1359 +
1.1360 +#ifdef PNG_READ_sRGB_SUPPORTED
1.1361 +PNG_INTERNAL_FUNCTION(void,png_handle_sRGB,(png_structrp png_ptr,
1.1362 + png_inforp info_ptr, png_uint_32 length),PNG_EMPTY);
1.1363 +#endif
1.1364 +
1.1365 +#ifdef PNG_READ_tEXt_SUPPORTED
1.1366 +PNG_INTERNAL_FUNCTION(void,png_handle_tEXt,(png_structrp png_ptr,
1.1367 + png_inforp info_ptr, png_uint_32 length),PNG_EMPTY);
1.1368 +#endif
1.1369 +
1.1370 +#ifdef PNG_READ_tIME_SUPPORTED
1.1371 +PNG_INTERNAL_FUNCTION(void,png_handle_tIME,(png_structrp png_ptr,
1.1372 + png_inforp info_ptr, png_uint_32 length),PNG_EMPTY);
1.1373 +#endif
1.1374 +
1.1375 +#ifdef PNG_READ_tRNS_SUPPORTED
1.1376 +PNG_INTERNAL_FUNCTION(void,png_handle_tRNS,(png_structrp png_ptr,
1.1377 + png_inforp info_ptr, png_uint_32 length),PNG_EMPTY);
1.1378 +#endif
1.1379 +
1.1380 +#ifdef PNG_READ_zTXt_SUPPORTED
1.1381 +PNG_INTERNAL_FUNCTION(void,png_handle_zTXt,(png_structrp png_ptr,
1.1382 + png_inforp info_ptr, png_uint_32 length),PNG_EMPTY);
1.1383 +#endif
1.1384 +
1.1385 +PNG_INTERNAL_FUNCTION(void,png_check_chunk_name,(png_structrp png_ptr,
1.1386 + png_uint_32 chunk_name),PNG_EMPTY);
1.1387 +
1.1388 +PNG_INTERNAL_FUNCTION(void,png_handle_unknown,(png_structrp png_ptr,
1.1389 + png_inforp info_ptr, png_uint_32 length, int keep),PNG_EMPTY);
1.1390 + /* This is the function that gets called for unknown chunks. The 'keep'
1.1391 + * argument is either non-zero for a known chunk that has been set to be
1.1392 + * handled as unknown or zero for an unknown chunk. By default the function
1.1393 + * just skips the chunk or errors out if it is critical.
1.1394 + */
1.1395 +
1.1396 +#if defined(PNG_READ_UNKNOWN_CHUNKS_SUPPORTED) ||\
1.1397 + defined(PNG_HANDLE_AS_UNKNOWN_SUPPORTED)
1.1398 +PNG_INTERNAL_FUNCTION(int,png_chunk_unknown_handling,
1.1399 + (png_const_structrp png_ptr, png_uint_32 chunk_name),PNG_EMPTY);
1.1400 + /* Exactly as the API png_handle_as_unknown() except that the argument is a
1.1401 + * 32-bit chunk name, not a string.
1.1402 + */
1.1403 +#endif /* READ_UNKNOWN_CHUNKS || HANDLE_AS_UNKNOWN */
1.1404 +
1.1405 +/* Handle the transformations for reading and writing */
1.1406 +#ifdef PNG_READ_TRANSFORMS_SUPPORTED
1.1407 +PNG_INTERNAL_FUNCTION(void,png_do_read_transformations,(png_structrp png_ptr,
1.1408 + png_row_infop row_info),PNG_EMPTY);
1.1409 +#endif
1.1410 +#ifdef PNG_WRITE_TRANSFORMS_SUPPORTED
1.1411 +PNG_INTERNAL_FUNCTION(void,png_do_write_transformations,(png_structrp png_ptr,
1.1412 + png_row_infop row_info),PNG_EMPTY);
1.1413 +#endif
1.1414 +
1.1415 +#ifdef PNG_READ_TRANSFORMS_SUPPORTED
1.1416 +PNG_INTERNAL_FUNCTION(void,png_init_read_transformations,(png_structrp png_ptr),
1.1417 + PNG_EMPTY);
1.1418 +#endif
1.1419 +
1.1420 +#ifdef PNG_PROGRESSIVE_READ_SUPPORTED
1.1421 +PNG_INTERNAL_FUNCTION(void,png_push_read_chunk,(png_structrp png_ptr,
1.1422 + png_inforp info_ptr),PNG_EMPTY);
1.1423 +PNG_INTERNAL_FUNCTION(void,png_push_read_sig,(png_structrp png_ptr,
1.1424 + png_inforp info_ptr),PNG_EMPTY);
1.1425 +PNG_INTERNAL_FUNCTION(void,png_push_check_crc,(png_structrp png_ptr),PNG_EMPTY);
1.1426 +PNG_INTERNAL_FUNCTION(void,png_push_crc_skip,(png_structrp png_ptr,
1.1427 + png_uint_32 length),PNG_EMPTY);
1.1428 +PNG_INTERNAL_FUNCTION(void,png_push_crc_finish,(png_structrp png_ptr),
1.1429 + PNG_EMPTY);
1.1430 +PNG_INTERNAL_FUNCTION(void,png_push_save_buffer,(png_structrp png_ptr),
1.1431 + PNG_EMPTY);
1.1432 +PNG_INTERNAL_FUNCTION(void,png_push_restore_buffer,(png_structrp png_ptr,
1.1433 + png_bytep buffer, png_size_t buffer_length),PNG_EMPTY);
1.1434 +PNG_INTERNAL_FUNCTION(void,png_push_read_IDAT,(png_structrp png_ptr),PNG_EMPTY);
1.1435 +PNG_INTERNAL_FUNCTION(void,png_process_IDAT_data,(png_structrp png_ptr,
1.1436 + png_bytep buffer, png_size_t buffer_length),PNG_EMPTY);
1.1437 +PNG_INTERNAL_FUNCTION(void,png_push_process_row,(png_structrp png_ptr),
1.1438 + PNG_EMPTY);
1.1439 +PNG_INTERNAL_FUNCTION(void,png_push_handle_unknown,(png_structrp png_ptr,
1.1440 + png_inforp info_ptr, png_uint_32 length),PNG_EMPTY);
1.1441 +PNG_INTERNAL_FUNCTION(void,png_push_have_info,(png_structrp png_ptr,
1.1442 + png_inforp info_ptr),PNG_EMPTY);
1.1443 +PNG_INTERNAL_FUNCTION(void,png_push_have_end,(png_structrp png_ptr,
1.1444 + png_inforp info_ptr),PNG_EMPTY);
1.1445 +PNG_INTERNAL_FUNCTION(void,png_push_have_row,(png_structrp png_ptr,
1.1446 + png_bytep row),PNG_EMPTY);
1.1447 +PNG_INTERNAL_FUNCTION(void,png_push_read_end,(png_structrp png_ptr,
1.1448 + png_inforp info_ptr),PNG_EMPTY);
1.1449 +PNG_INTERNAL_FUNCTION(void,png_process_some_data,(png_structrp png_ptr,
1.1450 + png_inforp info_ptr),PNG_EMPTY);
1.1451 +PNG_INTERNAL_FUNCTION(void,png_read_push_finish_row,(png_structrp png_ptr),
1.1452 + PNG_EMPTY);
1.1453 +# ifdef PNG_READ_tEXt_SUPPORTED
1.1454 +PNG_INTERNAL_FUNCTION(void,png_push_handle_tEXt,(png_structrp png_ptr,
1.1455 + png_inforp info_ptr, png_uint_32 length),PNG_EMPTY);
1.1456 +PNG_INTERNAL_FUNCTION(void,png_push_read_tEXt,(png_structrp png_ptr,
1.1457 + png_inforp info_ptr),PNG_EMPTY);
1.1458 +# endif
1.1459 +# ifdef PNG_READ_zTXt_SUPPORTED
1.1460 +PNG_INTERNAL_FUNCTION(void,png_push_handle_zTXt,(png_structrp png_ptr,
1.1461 + png_inforp info_ptr, png_uint_32 length),PNG_EMPTY);
1.1462 +PNG_INTERNAL_FUNCTION(void,png_push_read_zTXt,(png_structrp png_ptr,
1.1463 + png_inforp info_ptr),PNG_EMPTY);
1.1464 +# endif
1.1465 +# ifdef PNG_READ_iTXt_SUPPORTED
1.1466 +PNG_INTERNAL_FUNCTION(void,png_push_handle_iTXt,(png_structrp png_ptr,
1.1467 + png_inforp info_ptr, png_uint_32 length),PNG_EMPTY);
1.1468 +PNG_INTERNAL_FUNCTION(void,png_push_read_iTXt,(png_structrp png_ptr,
1.1469 + png_inforp info_ptr),PNG_EMPTY);
1.1470 +# endif
1.1471 +
1.1472 +#endif /* PNG_PROGRESSIVE_READ_SUPPORTED */
1.1473 +
1.1474 +#ifdef PNG_APNG_SUPPORTED
1.1475 +PNG_INTERNAL_FUNCTION(void,png_ensure_fcTL_is_valid,(png_structp png_ptr,
1.1476 + png_uint_32 width, png_uint_32 height,
1.1477 + png_uint_32 x_offset, png_uint_32 y_offset,
1.1478 + png_uint_16 delay_num, png_uint_16 delay_den,
1.1479 + png_byte dispose_op, png_byte blend_op),PNG_EMPTY);
1.1480 +
1.1481 +#ifdef PNG_READ_APNG_SUPPORTED
1.1482 +PNG_INTERNAL_FUNCTION(void,png_handle_acTL,(png_structp png_ptr,
1.1483 + png_infop info_ptr, png_uint_32 length),PNG_EMPTY);
1.1484 +PNG_INTERNAL_FUNCTION(void,png_handle_fcTL,(png_structp png_ptr,
1.1485 + png_infop info_ptr, png_uint_32 length),PNG_EMPTY);
1.1486 +PNG_INTERNAL_FUNCTION(void,png_handle_fdAT,(png_structp png_ptr,
1.1487 + png_infop info_ptr, png_uint_32 length),PNG_EMPTY);
1.1488 +PNG_INTERNAL_FUNCTION(void,png_have_info,(png_structp png_ptr,
1.1489 + png_infop info_ptr),PNG_EMPTY);
1.1490 +PNG_INTERNAL_FUNCTION(void,png_ensure_sequence_number,(png_structp png_ptr,
1.1491 + png_uint_32 length),PNG_EMPTY);
1.1492 +PNG_INTERNAL_FUNCTION(void,png_read_reset,(png_structp png_ptr),PNG_EMPTY);
1.1493 +PNG_INTERNAL_FUNCTION(void,png_read_reinit,(png_structp png_ptr,
1.1494 + png_infop info_ptr),PNG_EMPTY);
1.1495 +#ifdef PNG_PROGRESSIVE_READ_SUPPORTED
1.1496 +PNG_INTERNAL_FUNCTION(void,png_progressive_read_reset,(png_structp png_ptr),
1.1497 + PNG_EMPTY);
1.1498 +#endif /* PNG_PROGRESSIVE_READ_SUPPORTED */
1.1499 +#endif /* PNG_READ_APNG_SUPPORTED */
1.1500 +
1.1501 +#ifdef PNG_WRITE_APNG_SUPPORTED
1.1502 +PNG_INTERNAL_FUNCTION(void,png_write_acTL,(png_structp png_ptr,
1.1503 + png_uint_32 num_frames, png_uint_32 num_plays),PNG_EMPTY);
1.1504 +PNG_INTERNAL_FUNCTION(void,png_write_fcTL,(png_structp png_ptr,
1.1505 + png_uint_32 width, png_uint_32 height,
1.1506 + png_uint_32 x_offset, png_uint_32 y_offset,
1.1507 + png_uint_16 delay_num, png_uint_16 delay_den,
1.1508 + png_byte dispose_op, png_byte blend_op),PNG_EMPTY);
1.1509 +PNG_INTERNAL_FUNCTION(void,png_write_fdAT,(png_structp png_ptr,
1.1510 + png_const_bytep data, png_size_t length),PNG_EMPTY);
1.1511 +PNG_INTERNAL_FUNCTION(void,png_write_reset,(png_structp png_ptr),PNG_EMPTY);
1.1512 +PNG_INTERNAL_FUNCTION(void,png_write_reinit,(png_structp png_ptr,
1.1513 + png_infop info_ptr, png_uint_32 width, png_uint_32 height),PNG_EMPTY);
1.1514 +#endif /* PNG_WRITE_APNG_SUPPORTED */
1.1515 +#endif /* PNG_APNG_SUPPORTED */
1.1516 +
1.1517 +/* Added at libpng version 1.6.0 */
1.1518 +#ifdef PNG_GAMMA_SUPPORTED
1.1519 +PNG_INTERNAL_FUNCTION(void,png_colorspace_set_gamma,(png_const_structrp png_ptr,
1.1520 + png_colorspacerp colorspace, png_fixed_point gAMA), PNG_EMPTY);
1.1521 + /* Set the colorspace gamma with a value provided by the application or by
1.1522 + * the gAMA chunk on read. The value will override anything set by an ICC
1.1523 + * profile.
1.1524 + */
1.1525 +
1.1526 +PNG_INTERNAL_FUNCTION(void,png_colorspace_sync_info,(png_const_structrp png_ptr,
1.1527 + png_inforp info_ptr), PNG_EMPTY);
1.1528 + /* Synchronize the info 'valid' flags with the colorspace */
1.1529 +
1.1530 +PNG_INTERNAL_FUNCTION(void,png_colorspace_sync,(png_const_structrp png_ptr,
1.1531 + png_inforp info_ptr), PNG_EMPTY);
1.1532 + /* Copy the png_struct colorspace to the info_struct and call the above to
1.1533 + * synchronize the flags. Checks for NULL info_ptr and does nothing.
1.1534 + */
1.1535 +#endif
1.1536 +
1.1537 +/* Added at libpng version 1.4.0 */
1.1538 +#ifdef PNG_COLORSPACE_SUPPORTED
1.1539 +/* These internal functions are for maintaining the colorspace structure within
1.1540 + * a png_info or png_struct (or, indeed, both).
1.1541 + */
1.1542 +PNG_INTERNAL_FUNCTION(int,png_colorspace_set_chromaticities,
1.1543 + (png_const_structrp png_ptr, png_colorspacerp colorspace, const png_xy *xy,
1.1544 + int preferred), PNG_EMPTY);
1.1545 +
1.1546 +PNG_INTERNAL_FUNCTION(int,png_colorspace_set_endpoints,
1.1547 + (png_const_structrp png_ptr, png_colorspacerp colorspace, const png_XYZ *XYZ,
1.1548 + int preferred), PNG_EMPTY);
1.1549 +
1.1550 +#ifdef PNG_sRGB_SUPPORTED
1.1551 +PNG_INTERNAL_FUNCTION(int,png_colorspace_set_sRGB,(png_const_structrp png_ptr,
1.1552 + png_colorspacerp colorspace, int intent), PNG_EMPTY);
1.1553 + /* This does set the colorspace gAMA and cHRM values too, but doesn't set the
1.1554 + * flags to write them, if it returns false there was a problem and an error
1.1555 + * message has already been output (but the colorspace may still need to be
1.1556 + * synced to record the invalid flag).
1.1557 + */
1.1558 +#endif /* sRGB */
1.1559 +
1.1560 +#ifdef PNG_iCCP_SUPPORTED
1.1561 +PNG_INTERNAL_FUNCTION(int,png_colorspace_set_ICC,(png_const_structrp png_ptr,
1.1562 + png_colorspacerp colorspace, png_const_charp name,
1.1563 + png_uint_32 profile_length, png_const_bytep profile, int color_type),
1.1564 + PNG_EMPTY);
1.1565 + /* The 'name' is used for information only */
1.1566 +
1.1567 +/* Routines for checking parts of an ICC profile. */
1.1568 +PNG_INTERNAL_FUNCTION(int,png_icc_check_length,(png_const_structrp png_ptr,
1.1569 + png_colorspacerp colorspace, png_const_charp name,
1.1570 + png_uint_32 profile_length), PNG_EMPTY);
1.1571 +PNG_INTERNAL_FUNCTION(int,png_icc_check_header,(png_const_structrp png_ptr,
1.1572 + png_colorspacerp colorspace, png_const_charp name,
1.1573 + png_uint_32 profile_length,
1.1574 + png_const_bytep profile /* first 132 bytes only */, int color_type),
1.1575 + PNG_EMPTY);
1.1576 +PNG_INTERNAL_FUNCTION(int,png_icc_check_tag_table,(png_const_structrp png_ptr,
1.1577 + png_colorspacerp colorspace, png_const_charp name,
1.1578 + png_uint_32 profile_length,
1.1579 + png_const_bytep profile /* header plus whole tag table */), PNG_EMPTY);
1.1580 +#ifdef PNG_sRGB_SUPPORTED
1.1581 +PNG_INTERNAL_FUNCTION(void,png_icc_set_sRGB,(
1.1582 + png_const_structrp png_ptr, png_colorspacerp colorspace,
1.1583 + png_const_bytep profile, uLong adler), PNG_EMPTY);
1.1584 + /* 'adler' is the Adler32 checksum of the uncompressed profile data. It may
1.1585 + * be zero to indicate that it is not available. It is used, if provided,
1.1586 + * as a fast check on the profile when checking to see if it is sRGB.
1.1587 + */
1.1588 +#endif
1.1589 +#endif /* iCCP */
1.1590 +
1.1591 +#ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED
1.1592 +PNG_INTERNAL_FUNCTION(void,png_colorspace_set_rgb_coefficients,
1.1593 + (png_structrp png_ptr), PNG_EMPTY);
1.1594 + /* Set the rgb_to_gray coefficients from the colorspace Y values */
1.1595 +#endif /* READ_RGB_TO_GRAY */
1.1596 +#endif /* COLORSPACE */
1.1597 +
1.1598 +/* Added at libpng version 1.4.0 */
1.1599 +PNG_INTERNAL_FUNCTION(void,png_check_IHDR,(png_const_structrp png_ptr,
1.1600 + png_uint_32 width, png_uint_32 height, int bit_depth,
1.1601 + int color_type, int interlace_type, int compression_type,
1.1602 + int filter_type),PNG_EMPTY);
1.1603 +
1.1604 +/* Added at libpng version 1.5.10 */
1.1605 +#if defined(PNG_READ_CHECK_FOR_INVALID_INDEX_SUPPORTED) || \
1.1606 + defined(PNG_WRITE_CHECK_FOR_INVALID_INDEX_SUPPORTED)
1.1607 +PNG_INTERNAL_FUNCTION(void,png_do_check_palette_indexes,
1.1608 + (png_structrp png_ptr, png_row_infop row_info),PNG_EMPTY);
1.1609 +#endif
1.1610 +
1.1611 +#if defined(PNG_FLOATING_POINT_SUPPORTED) && defined(PNG_ERROR_TEXT_SUPPORTED)
1.1612 +PNG_INTERNAL_FUNCTION(void,png_fixed_error,(png_const_structrp png_ptr,
1.1613 + png_const_charp name),PNG_NORETURN);
1.1614 +#endif
1.1615 +
1.1616 +/* Puts 'string' into 'buffer' at buffer[pos], taking care never to overwrite
1.1617 + * the end. Always leaves the buffer nul terminated. Never errors out (and
1.1618 + * there is no error code.)
1.1619 + */
1.1620 +PNG_INTERNAL_FUNCTION(size_t,png_safecat,(png_charp buffer, size_t bufsize,
1.1621 + size_t pos, png_const_charp string),PNG_EMPTY);
1.1622 +
1.1623 +/* Various internal functions to handle formatted warning messages, currently
1.1624 + * only implemented for warnings.
1.1625 + */
1.1626 +#if defined(PNG_WARNINGS_SUPPORTED) || defined(PNG_TIME_RFC1123_SUPPORTED)
1.1627 +/* Utility to dump an unsigned value into a buffer, given a start pointer and
1.1628 + * and end pointer (which should point just *beyond* the end of the buffer!)
1.1629 + * Returns the pointer to the start of the formatted string. This utility only
1.1630 + * does unsigned values.
1.1631 + */
1.1632 +PNG_INTERNAL_FUNCTION(png_charp,png_format_number,(png_const_charp start,
1.1633 + png_charp end, int format, png_alloc_size_t number),PNG_EMPTY);
1.1634 +
1.1635 +/* Convenience macro that takes an array: */
1.1636 +#define PNG_FORMAT_NUMBER(buffer,format,number) \
1.1637 + png_format_number(buffer, buffer + (sizeof buffer), format, number)
1.1638 +
1.1639 +/* Suggested size for a number buffer (enough for 64 bits and a sign!) */
1.1640 +#define PNG_NUMBER_BUFFER_SIZE 24
1.1641 +
1.1642 +/* These are the integer formats currently supported, the name is formed from
1.1643 + * the standard printf(3) format string.
1.1644 + */
1.1645 +#define PNG_NUMBER_FORMAT_u 1 /* chose unsigned API! */
1.1646 +#define PNG_NUMBER_FORMAT_02u 2
1.1647 +#define PNG_NUMBER_FORMAT_d 1 /* chose signed API! */
1.1648 +#define PNG_NUMBER_FORMAT_02d 2
1.1649 +#define PNG_NUMBER_FORMAT_x 3
1.1650 +#define PNG_NUMBER_FORMAT_02x 4
1.1651 +#define PNG_NUMBER_FORMAT_fixed 5 /* choose the signed API */
1.1652 +#endif
1.1653 +
1.1654 +#ifdef PNG_WARNINGS_SUPPORTED
1.1655 +/* New defines and members adding in libpng-1.5.4 */
1.1656 +# define PNG_WARNING_PARAMETER_SIZE 32
1.1657 +# define PNG_WARNING_PARAMETER_COUNT 8 /* Maximum 9; see pngerror.c */
1.1658 +
1.1659 +/* An l-value of this type has to be passed to the APIs below to cache the
1.1660 + * values of the parameters to a formatted warning message.
1.1661 + */
1.1662 +typedef char png_warning_parameters[PNG_WARNING_PARAMETER_COUNT][
1.1663 + PNG_WARNING_PARAMETER_SIZE];
1.1664 +
1.1665 +PNG_INTERNAL_FUNCTION(void,png_warning_parameter,(png_warning_parameters p,
1.1666 + int number, png_const_charp string),PNG_EMPTY);
1.1667 + /* Parameters are limited in size to PNG_WARNING_PARAMETER_SIZE characters,
1.1668 + * including the trailing '\0'.
1.1669 + */
1.1670 +PNG_INTERNAL_FUNCTION(void,png_warning_parameter_unsigned,
1.1671 + (png_warning_parameters p, int number, int format, png_alloc_size_t value),
1.1672 + PNG_EMPTY);
1.1673 + /* Use png_alloc_size_t because it is an unsigned type as big as any we
1.1674 + * need to output. Use the following for a signed value.
1.1675 + */
1.1676 +PNG_INTERNAL_FUNCTION(void,png_warning_parameter_signed,
1.1677 + (png_warning_parameters p, int number, int format, png_int_32 value),
1.1678 + PNG_EMPTY);
1.1679 +
1.1680 +PNG_INTERNAL_FUNCTION(void,png_formatted_warning,(png_const_structrp png_ptr,
1.1681 + png_warning_parameters p, png_const_charp message),PNG_EMPTY);
1.1682 + /* 'message' follows the X/Open approach of using @1, @2 to insert
1.1683 + * parameters previously supplied using the above functions. Errors in
1.1684 + * specifying the parameters will simply result in garbage substitutions.
1.1685 + */
1.1686 +#endif
1.1687 +
1.1688 +#ifdef PNG_BENIGN_ERRORS_SUPPORTED
1.1689 +/* Application errors (new in 1.6); use these functions (declared below) for
1.1690 + * errors in the parameters or order of API function calls on read. The
1.1691 + * 'warning' should be used for an error that can be handled completely; the
1.1692 + * 'error' for one which can be handled safely but which may lose application
1.1693 + * information or settings.
1.1694 + *
1.1695 + * By default these both result in a png_error call prior to release, while in a
1.1696 + * released version the 'warning' is just a warning. However if the application
1.1697 + * explicitly disables benign errors (explicitly permitting the code to lose
1.1698 + * information) they both turn into warnings.
1.1699 + *
1.1700 + * If benign errors aren't supported they end up as the corresponding base call
1.1701 + * (png_warning or png_error.)
1.1702 + */
1.1703 +PNG_INTERNAL_FUNCTION(void,png_app_warning,(png_const_structrp png_ptr,
1.1704 + png_const_charp message),PNG_EMPTY);
1.1705 + /* The application provided invalid parameters to an API function or called
1.1706 + * an API function at the wrong time, libpng can completely recover.
1.1707 + */
1.1708 +
1.1709 +PNG_INTERNAL_FUNCTION(void,png_app_error,(png_const_structrp png_ptr,
1.1710 + png_const_charp message),PNG_EMPTY);
1.1711 + /* As above but libpng will ignore the call, or attempt some other partial
1.1712 + * recovery from the error.
1.1713 + */
1.1714 +#else
1.1715 +# define png_app_warning(pp,s) png_warning(pp,s)
1.1716 +# define png_app_error(pp,s) png_error(pp,s)
1.1717 +#endif
1.1718 +
1.1719 +PNG_INTERNAL_FUNCTION(void,png_chunk_report,(png_const_structrp png_ptr,
1.1720 + png_const_charp message, int error),PNG_EMPTY);
1.1721 + /* Report a recoverable issue in chunk data. On read this is used to report
1.1722 + * a problem found while reading a particular chunk and the
1.1723 + * png_chunk_benign_error or png_chunk_warning function is used as
1.1724 + * appropriate. On write this is used to report an error that comes from
1.1725 + * data set via an application call to a png_set_ API and png_app_error or
1.1726 + * png_app_warning is used as appropriate.
1.1727 + *
1.1728 + * The 'error' parameter must have one of the following values:
1.1729 + */
1.1730 +#define PNG_CHUNK_WARNING 0 /* never an error */
1.1731 +#define PNG_CHUNK_WRITE_ERROR 1 /* an error only on write */
1.1732 +#define PNG_CHUNK_ERROR 2 /* always an error */
1.1733 +
1.1734 +/* ASCII to FP interfaces, currently only implemented if sCAL
1.1735 + * support is required.
1.1736 + */
1.1737 +#if defined(PNG_sCAL_SUPPORTED)
1.1738 +/* MAX_DIGITS is actually the maximum number of characters in an sCAL
1.1739 + * width or height, derived from the precision (number of significant
1.1740 + * digits - a build time settable option) and assumptions about the
1.1741 + * maximum ridiculous exponent.
1.1742 + */
1.1743 +#define PNG_sCAL_MAX_DIGITS (PNG_sCAL_PRECISION+1/*.*/+1/*E*/+10/*exponent*/)
1.1744 +
1.1745 +#ifdef PNG_FLOATING_POINT_SUPPORTED
1.1746 +PNG_INTERNAL_FUNCTION(void,png_ascii_from_fp,(png_const_structrp png_ptr,
1.1747 + png_charp ascii, png_size_t size, double fp, unsigned int precision),
1.1748 + PNG_EMPTY);
1.1749 +#endif /* FLOATING_POINT */
1.1750 +
1.1751 +#ifdef PNG_FIXED_POINT_SUPPORTED
1.1752 +PNG_INTERNAL_FUNCTION(void,png_ascii_from_fixed,(png_const_structrp png_ptr,
1.1753 + png_charp ascii, png_size_t size, png_fixed_point fp),PNG_EMPTY);
1.1754 +#endif /* FIXED_POINT */
1.1755 +#endif /* sCAL */
1.1756 +
1.1757 +#if defined(PNG_sCAL_SUPPORTED) || defined(PNG_pCAL_SUPPORTED)
1.1758 +/* An internal API to validate the format of a floating point number.
1.1759 + * The result is the index of the next character. If the number is
1.1760 + * not valid it will be the index of a character in the supposed number.
1.1761 + *
1.1762 + * The format of a number is defined in the PNG extensions specification
1.1763 + * and this API is strictly conformant to that spec, not anyone elses!
1.1764 + *
1.1765 + * The format as a regular expression is:
1.1766 + *
1.1767 + * [+-]?[0-9]+.?([Ee][+-]?[0-9]+)?
1.1768 + *
1.1769 + * or:
1.1770 + *
1.1771 + * [+-]?.[0-9]+(.[0-9]+)?([Ee][+-]?[0-9]+)?
1.1772 + *
1.1773 + * The complexity is that either integer or fraction must be present and the
1.1774 + * fraction is permitted to have no digits only if the integer is present.
1.1775 + *
1.1776 + * NOTE: The dangling E problem.
1.1777 + * There is a PNG valid floating point number in the following:
1.1778 + *
1.1779 + * PNG floating point numbers are not greedy.
1.1780 + *
1.1781 + * Working this out requires *TWO* character lookahead (because of the
1.1782 + * sign), the parser does not do this - it will fail at the 'r' - this
1.1783 + * doesn't matter for PNG sCAL chunk values, but it requires more care
1.1784 + * if the value were ever to be embedded in something more complex. Use
1.1785 + * ANSI-C strtod if you need the lookahead.
1.1786 + */
1.1787 +/* State table for the parser. */
1.1788 +#define PNG_FP_INTEGER 0 /* before or in integer */
1.1789 +#define PNG_FP_FRACTION 1 /* before or in fraction */
1.1790 +#define PNG_FP_EXPONENT 2 /* before or in exponent */
1.1791 +#define PNG_FP_STATE 3 /* mask for the above */
1.1792 +#define PNG_FP_SAW_SIGN 4 /* Saw +/- in current state */
1.1793 +#define PNG_FP_SAW_DIGIT 8 /* Saw a digit in current state */
1.1794 +#define PNG_FP_SAW_DOT 16 /* Saw a dot in current state */
1.1795 +#define PNG_FP_SAW_E 32 /* Saw an E (or e) in current state */
1.1796 +#define PNG_FP_SAW_ANY 60 /* Saw any of the above 4 */
1.1797 +
1.1798 +/* These three values don't affect the parser. They are set but not used.
1.1799 + */
1.1800 +#define PNG_FP_WAS_VALID 64 /* Preceding substring is a valid fp number */
1.1801 +#define PNG_FP_NEGATIVE 128 /* A negative number, including "-0" */
1.1802 +#define PNG_FP_NONZERO 256 /* A non-zero value */
1.1803 +#define PNG_FP_STICKY 448 /* The above three flags */
1.1804 +
1.1805 +/* This is available for the caller to store in 'state' if required. Do not
1.1806 + * call the parser after setting it (the parser sometimes clears it.)
1.1807 + */
1.1808 +#define PNG_FP_INVALID 512 /* Available for callers as a distinct value */
1.1809 +
1.1810 +/* Result codes for the parser (boolean - true meants ok, false means
1.1811 + * not ok yet.)
1.1812 + */
1.1813 +#define PNG_FP_MAYBE 0 /* The number may be valid in the future */
1.1814 +#define PNG_FP_OK 1 /* The number is valid */
1.1815 +
1.1816 +/* Tests on the sticky non-zero and negative flags. To pass these checks
1.1817 + * the state must also indicate that the whole number is valid - this is
1.1818 + * achieved by testing PNG_FP_SAW_DIGIT (see the implementation for why this
1.1819 + * is equivalent to PNG_FP_OK above.)
1.1820 + */
1.1821 +#define PNG_FP_NZ_MASK (PNG_FP_SAW_DIGIT | PNG_FP_NEGATIVE | PNG_FP_NONZERO)
1.1822 + /* NZ_MASK: the string is valid and a non-zero negative value */
1.1823 +#define PNG_FP_Z_MASK (PNG_FP_SAW_DIGIT | PNG_FP_NONZERO)
1.1824 + /* Z MASK: the string is valid and a non-zero value. */
1.1825 + /* PNG_FP_SAW_DIGIT: the string is valid. */
1.1826 +#define PNG_FP_IS_ZERO(state) (((state) & PNG_FP_Z_MASK) == PNG_FP_SAW_DIGIT)
1.1827 +#define PNG_FP_IS_POSITIVE(state) (((state) & PNG_FP_NZ_MASK) == PNG_FP_Z_MASK)
1.1828 +#define PNG_FP_IS_NEGATIVE(state) (((state) & PNG_FP_NZ_MASK) == PNG_FP_NZ_MASK)
1.1829 +
1.1830 +/* The actual parser. This can be called repeatedly. It updates
1.1831 + * the index into the string and the state variable (which must
1.1832 + * be initialized to 0). It returns a result code, as above. There
1.1833 + * is no point calling the parser any more if it fails to advance to
1.1834 + * the end of the string - it is stuck on an invalid character (or
1.1835 + * terminated by '\0').
1.1836 + *
1.1837 + * Note that the pointer will consume an E or even an E+ and then leave
1.1838 + * a 'maybe' state even though a preceding integer.fraction is valid.
1.1839 + * The PNG_FP_WAS_VALID flag indicates that a preceding substring was
1.1840 + * a valid number. It's possible to recover from this by calling
1.1841 + * the parser again (from the start, with state 0) but with a string
1.1842 + * that omits the last character (i.e. set the size to the index of
1.1843 + * the problem character.) This has not been tested within libpng.
1.1844 + */
1.1845 +PNG_INTERNAL_FUNCTION(int,png_check_fp_number,(png_const_charp string,
1.1846 + png_size_t size, int *statep, png_size_tp whereami),PNG_EMPTY);
1.1847 +
1.1848 +/* This is the same but it checks a complete string and returns true
1.1849 + * only if it just contains a floating point number. As of 1.5.4 this
1.1850 + * function also returns the state at the end of parsing the number if
1.1851 + * it was valid (otherwise it returns 0.) This can be used for testing
1.1852 + * for negative or zero values using the sticky flag.
1.1853 + */
1.1854 +PNG_INTERNAL_FUNCTION(int,png_check_fp_string,(png_const_charp string,
1.1855 + png_size_t size),PNG_EMPTY);
1.1856 +#endif /* pCAL || sCAL */
1.1857 +
1.1858 +#if defined(PNG_GAMMA_SUPPORTED) ||\
1.1859 + defined(PNG_INCH_CONVERSIONS_SUPPORTED) || defined(PNG_READ_pHYs_SUPPORTED)
1.1860 +/* Added at libpng version 1.5.0 */
1.1861 +/* This is a utility to provide a*times/div (rounded) and indicate
1.1862 + * if there is an overflow. The result is a boolean - false (0)
1.1863 + * for overflow, true (1) if no overflow, in which case *res
1.1864 + * holds the result.
1.1865 + */
1.1866 +PNG_INTERNAL_FUNCTION(int,png_muldiv,(png_fixed_point_p res, png_fixed_point a,
1.1867 + png_int_32 multiplied_by, png_int_32 divided_by),PNG_EMPTY);
1.1868 +#endif
1.1869 +
1.1870 +#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_INCH_CONVERSIONS_SUPPORTED)
1.1871 +/* Same deal, but issue a warning on overflow and return 0. */
1.1872 +PNG_INTERNAL_FUNCTION(png_fixed_point,png_muldiv_warn,
1.1873 + (png_const_structrp png_ptr, png_fixed_point a, png_int_32 multiplied_by,
1.1874 + png_int_32 divided_by),PNG_EMPTY);
1.1875 +#endif
1.1876 +
1.1877 +#ifdef PNG_GAMMA_SUPPORTED
1.1878 +/* Calculate a reciprocal - used for gamma values. This returns
1.1879 + * 0 if the argument is 0 in order to maintain an undefined value;
1.1880 + * there are no warnings.
1.1881 + */
1.1882 +PNG_INTERNAL_FUNCTION(png_fixed_point,png_reciprocal,(png_fixed_point a),
1.1883 + PNG_EMPTY);
1.1884 +
1.1885 +#ifdef PNG_READ_GAMMA_SUPPORTED
1.1886 +/* The same but gives a reciprocal of the product of two fixed point
1.1887 + * values. Accuracy is suitable for gamma calculations but this is
1.1888 + * not exact - use png_muldiv for that. Only required at present on read.
1.1889 + */
1.1890 +PNG_INTERNAL_FUNCTION(png_fixed_point,png_reciprocal2,(png_fixed_point a,
1.1891 + png_fixed_point b),PNG_EMPTY);
1.1892 +#endif
1.1893 +
1.1894 +/* Return true if the gamma value is significantly different from 1.0 */
1.1895 +PNG_INTERNAL_FUNCTION(int,png_gamma_significant,(png_fixed_point gamma_value),
1.1896 + PNG_EMPTY);
1.1897 +#endif
1.1898 +
1.1899 +#ifdef PNG_READ_GAMMA_SUPPORTED
1.1900 +/* Internal fixed point gamma correction. These APIs are called as
1.1901 + * required to convert single values - they don't need to be fast,
1.1902 + * they are not used when processing image pixel values.
1.1903 + *
1.1904 + * While the input is an 'unsigned' value it must actually be the
1.1905 + * correct bit value - 0..255 or 0..65535 as required.
1.1906 + */
1.1907 +PNG_INTERNAL_FUNCTION(png_uint_16,png_gamma_correct,(png_structrp png_ptr,
1.1908 + unsigned int value, png_fixed_point gamma_value),PNG_EMPTY);
1.1909 +PNG_INTERNAL_FUNCTION(png_uint_16,png_gamma_16bit_correct,(unsigned int value,
1.1910 + png_fixed_point gamma_value),PNG_EMPTY);
1.1911 +PNG_INTERNAL_FUNCTION(png_byte,png_gamma_8bit_correct,(unsigned int value,
1.1912 + png_fixed_point gamma_value),PNG_EMPTY);
1.1913 +PNG_INTERNAL_FUNCTION(void,png_destroy_gamma_table,(png_structrp png_ptr),
1.1914 + PNG_EMPTY);
1.1915 +PNG_INTERNAL_FUNCTION(void,png_build_gamma_table,(png_structrp png_ptr,
1.1916 + int bit_depth),PNG_EMPTY);
1.1917 +#endif
1.1918 +
1.1919 +/* SIMPLIFIED READ/WRITE SUPPORT */
1.1920 +#if defined(PNG_SIMPLIFIED_READ_SUPPORTED) ||\
1.1921 + defined(PNG_SIMPLIFIED_WRITE_SUPPORTED)
1.1922 +/* The internal structure that png_image::opaque points to. */
1.1923 +typedef struct png_control
1.1924 +{
1.1925 + png_structp png_ptr;
1.1926 + png_infop info_ptr;
1.1927 + png_voidp error_buf; /* Always a jmp_buf at present. */
1.1928 +
1.1929 + png_const_bytep memory; /* Memory buffer. */
1.1930 + png_size_t size; /* Size of the memory buffer. */
1.1931 +
1.1932 + unsigned int for_write :1; /* Otherwise it is a read structure */
1.1933 + unsigned int owned_file :1; /* We own the file in io_ptr */
1.1934 +} png_control;
1.1935 +
1.1936 +/* Return the pointer to the jmp_buf from a png_control: necessary because C
1.1937 + * does not reveal the type of the elements of jmp_buf.
1.1938 + */
1.1939 +#ifdef __cplusplus
1.1940 +# define png_control_jmp_buf(pc) (((jmp_buf*)((pc)->error_buf))[0])
1.1941 +#else
1.1942 +# define png_control_jmp_buf(pc) ((pc)->error_buf)
1.1943 +#endif
1.1944 +
1.1945 +/* Utility to safely execute a piece of libpng code catching and logging any
1.1946 + * errors that might occur. Returns true on success, false on failure (either
1.1947 + * of the function or as a result of a png_error.)
1.1948 + */
1.1949 +PNG_INTERNAL_CALLBACK(void,png_safe_error,(png_structp png_ptr,
1.1950 + png_const_charp error_message),PNG_NORETURN);
1.1951 +
1.1952 +#ifdef PNG_WARNINGS_SUPPORTED
1.1953 +PNG_INTERNAL_CALLBACK(void,png_safe_warning,(png_structp png_ptr,
1.1954 + png_const_charp warning_message),PNG_EMPTY);
1.1955 +#else
1.1956 +# define png_safe_warning 0/*dummy argument*/
1.1957 +#endif
1.1958 +
1.1959 +PNG_INTERNAL_FUNCTION(int,png_safe_execute,(png_imagep image,
1.1960 + int (*function)(png_voidp), png_voidp arg),PNG_EMPTY);
1.1961 +
1.1962 +/* Utility to log an error; this also cleans up the png_image; the function
1.1963 + * always returns 0 (false).
1.1964 + */
1.1965 +PNG_INTERNAL_FUNCTION(int,png_image_error,(png_imagep image,
1.1966 + png_const_charp error_message),PNG_EMPTY);
1.1967 +
1.1968 +#ifndef PNG_SIMPLIFIED_READ_SUPPORTED
1.1969 +/* png_image_free is used by the write code but not exported */
1.1970 +PNG_INTERNAL_FUNCTION(void, png_image_free, (png_imagep image), PNG_EMPTY);
1.1971 +#endif /* !SIMPLIFIED_READ */
1.1972 +
1.1973 +#endif /* SIMPLIFIED READ/WRITE */
1.1974 +
1.1975 +/* These are initialization functions for hardware specific PNG filter
1.1976 + * optimizations; list these here then select the appropriate one at compile
1.1977 + * time using the macro PNG_FILTER_OPTIMIZATIONS. If the macro is not defined
1.1978 + * the generic code is used.
1.1979 + */
1.1980 +#ifdef PNG_FILTER_OPTIMIZATIONS
1.1981 +PNG_INTERNAL_FUNCTION(void, PNG_FILTER_OPTIMIZATIONS, (png_structp png_ptr,
1.1982 + unsigned int bpp), PNG_EMPTY);
1.1983 + /* Just declare the optimization that will be used */
1.1984 +#else
1.1985 + /* List *all* the possible optimizations here - this branch is required if
1.1986 + * the builder of libpng passes the definition of PNG_FILTER_OPTIMIZATIONS in
1.1987 + * CFLAGS in place of CPPFLAGS *and* uses symbol prefixing.
1.1988 + */
1.1989 +PNG_INTERNAL_FUNCTION(void, png_init_filter_functions_neon,
1.1990 + (png_structp png_ptr, unsigned int bpp), PNG_EMPTY);
1.1991 +#endif
1.1992 +
1.1993 +/* Maintainer: Put new private prototypes here ^ */
1.1994 +
1.1995 +#include "pngdebug.h"
1.1996 +
1.1997 +#ifdef __cplusplus
1.1998 +}
1.1999 +#endif
1.2000 +
1.2001 +#endif /* PNG_VERSION_INFO_ONLY */
1.2002 +#endif /* PNGPRIV_H */
