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