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