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