1 # scripts/pnglibconf.dfa - library build configuration control 2 # 3 @/*- pnglibconf.dfn intermediate file 4 @ * generated from scripts/pnglibconf.dfa 5 @ */ 6 # 7 com pnglibconf.h - library build configuration 8 com 9 version 10 com 11 com Copyright (c) 1998-2016 Glenn Randers-Pehrson 12 com 13 com This code is released under the libpng license. 14 com For conditions of distribution and use, see the disclaimer 15 com and license in png.h 16 com 17 18 file pnglibconf.h scripts/pnglibconf.dfa PNGLCONF_H 19 20 # This file is preprocessed by scripts/options.awk and the 21 # C compiler to generate 'pnglibconf.h' - a list of all the 22 # configuration options. The file lists the various options 23 # that can *only* be specified during the libpng build; 24 # pnglibconf.h freezes the definitions selected for the specific 25 # build. 26 # 27 # The syntax is detailed in scripts/options.awk; this is a summary 28 # only: 29 # 30 # setting <name> [requires ...] [default] 31 # #define PNG_<name> <value> /* value comes from current setting */ 32 # option <name> [requires ...] [if ...] [enables ...] [disabled] 33 # #define PNG_<name>_SUPPORTED if the requirements are met and 34 # enable the other options listed 35 # chunk <name> [requires ...] [enables ...] [disabled] 36 # Enable chunk processing for the given ancillary chunk; any 37 # 'requires something' expands to READ_something for read and 38 # WRITE_something for write, but the enables list members are 39 # used as given (e.g. enables GAMMA just expands to that on the 40 # correspond READ_name and WRITE_name lines.) 41 # 42 # "," may be used to separate options on an 'option' line and is ignored; it 43 # doesn't change the meaning of the line. (NOT setting, where "," becomes 44 # part of the setting!) A comma at the end of an option line causes a 45 # continuation (the next line is included in the option too.) 46 # 47 # Note that the 'on' and 'off' keywords, while valid on both option 48 # and chunk, should not be used in this file because they force the 49 # relevant options on or off. 50 51 #---------------------------------------------------------------------- 52 53 # The following setting, option and chunk values can all be changed 54 # while building libpng: 55 # 56 # setting: change 'setting' lines to fine tune library performance; 57 # changes to the settings don't affect the libpng API functionally 58 # 59 # option: change 'option' lines to remove or add capabilities from 60 # or to the library; options change the library API 61 # 62 # chunk: change 'chunk' lines to remove capabilities to process 63 # optional ('ancillary') chunks. This does not prevent PNG 64 # decoding but does change the libpng API because some chunks 65 # will be ignored. 66 # 67 # There are three ways of disabling features, in no particular order: 68 # 69 # 1) Create 'pngusr.h', enter the required private build information 70 # detailed below and #define PNG_NO_<option> for each option you 71 # don't want in that file in that file. You can also turn on options 72 # using PNG_<option>_SUPPORTED. When you have finished rerun 73 # configure and rebuild pnglibconf.h file with -DPNG_USER_CONFIG: 74 # 75 # make clean 76 # CPPFLAGS='-DPNG_USER_CONFIG' ./configure 77 # make pnglibconf.h 78 # 79 # pngusr.h is only used during the creation of pnglibconf.h, but it 80 # is safer to ensure that -DPNG_USER_CONFIG is specified throughout 81 # the build by changing the CPPFLAGS passed to the initial ./configure 82 # 83 # 2) Add definitions of the settings you want to change to 84 # CPPFLAGS; for example: 85 # 86 # -DPNG_DEFAULT_READ_MACROS=0 87 # 88 # (This would change the default to *not* use read macros.) Be 89 # very careful to change only settings that don't alter the API 90 # because this approach bypasses the private build checking. You 91 # can also change settings from pngpriv.h (read pngpriv.h) safely 92 # without API changes. Do that in the same way. 93 # 94 # 3) Write a new '.dfa' file (say 'pngusr.dfa') and in this file 95 # provide override values for setting entries and turn option or 96 # chunk values explicitly 'on' or 'off': 97 # 98 # setting FOO default VALUE 99 # option BAR [on|off] 100 # 101 # Then add this file to the options.awk command line (the *first* 102 # one) after this file. The make macro DFA_XTRA is provided to make 103 # this easier (set it like CPPFLAGS prior to running ./configure). 104 # Look at the builds below contrib/pngminim for some extreme examples 105 # of how this can be used. 106 # 107 # Don't edit this file unless you are contributing a patch to 108 # libpng and need new or modified options/settings. 109 #---------------------------------------------------------------------- 110 111 # The following causes commented out #undef lines to be written to 112 # pnglibconf.h; this can be stopped by logunsupported=0 in a later 113 # file or on the command line (after pnglibconf.dfa) 114 115 logunsupported = 1 116 117 # The following allows the output from configure to modify the contents of 118 # pnglibconf.h 119 120 @#ifdef HAVE_CONFIG_H 121 @# include "config.h" 122 @#endif 123 124 # PNG_USER_CONFIG has to be defined on the compiler command line 125 # to cause pngusr.h to be read while constructing pnglibconf.h 126 # 127 # If you create a private DLL you need to define the following 128 # macros in the file 'pngusr.h' and set -DPNG_USER_CONFIG for 129 # compilation (i.e. in CPPFLAGS.) 130 # #define PNG_USER_PRIVATEBUILD \ 131 # <Describes by whom and why this version of the DLL was built> 132 # e.g. #define PNG_USER_PRIVATEBUILD "Build by MyCompany for xyz reasons." 133 # #define PNG_USER_DLLFNAME_POSTFIX <two-letter postfix that serve to 134 # distinguish your DLL from those of the official release. These 135 # correspond to the trailing letters that come after the version 136 # number and must match your private DLL name> 137 # e.g. // private DLL "libpng13gx.dll" 138 # #define PNG_USER_DLLFNAME_POSTFIX "gx" 139 # 140 # The following macros are also at your disposal if you want to complete the 141 # DLL VERSIONINFO structure. 142 # - PNG_USER_VERSIONINFO_COMMENTS 143 # - PNG_USER_VERSIONINFO_COMPANYNAME 144 # - PNG_USER_VERSIONINFO_LEGALTRADEMARKS 145 146 # It is necessary to include configures definitions here so that AC_DEFINE 147 # in configure.ac works in a comprehensible way 148 @#if defined(HAVE_CONFIG_H) && !defined(PNG_NO_CONFIG_H) 149 @# include "config.h" 150 @#endif 151 152 @#ifdef PNG_USER_CONFIG 153 @# include "pngusr.h" 154 @#endif 155 156 # This is a special fixup for the Watcom C compiler on Windows, which has 157 # multiple procedure call standards. Unless PNG_API_RULE is set explicitly 158 # (i.e. if it is not defined at this point) it will be forced to '2' here when 159 # using Watcom. This indicates to the other header files that Watcom behaviour 160 # is required where appropriate. 161 162 @#ifdef __WATCOMC__ 163 @# ifndef PNG_API_RULE 164 @# define PNG_API_RULE 2 /* Use Watcom calling conventions */ 165 @# endif 166 @#endif 167 168 # IN DEVELOPMENT 169 # These are currently experimental features; define them if you want (NOTE: 170 # experimental options must be disabled before they are defined in this file!) 171 172 # NONE 173 174 # Note that PNG_USER_CONFIG only has an effect when building 175 # pnglibconf.h 176 177 setting USER_CONFIG 178 setting USER_PRIVATEBUILD 179 setting USER_DLLFNAME_POSTFIX 180 setting USER_VERSIONINFO_COMMENTS 181 setting USER_VERSIONINFO_COMPANYNAME 182 setting USER_VERSIONINFO_LEGALTRADEMARKS 183 184 # Record the 'API rule' used to select calling conventions on 185 # those systems that support such things (see all the comments in 186 # pngconf.h) 187 # Changing this setting has a fundamental affect on the PNG ABI, 188 # do not release shared libraries with this changed. 189 190 setting API_RULE default 0 191 192 # This allows a prefix to be added to the front of every API functon name (and 193 # therefore every symbol) by redefining all the function names with the prefix 194 # at the end of pnglibconf.h. It also turns on similar internal symbol renaming 195 # by causing a similar build-time only file, pngprefix.h, to be generated. 196 197 setting PREFIX 198 199 # Implementation specific control of the optimizations, enabled by those 200 # hardware or software options that need it (typically when run-time choices 201 # must be made by the user) 202 option SET_OPTION disabled 203 204 # These options are specific to the ARM NEON hardware optimizations. At present 205 # these optimizations depend on GCC specific pre-processing of an assembler (.S) 206 # file so they probably won't work with other compilers. 207 # 208 # ARM_NEON_OPT: unset: check at compile time (__ARM_NEON__ must be defined by 209 # the compiler, typically as a result of specifying 210 # CC="gcc -mfpu=neon".) 211 # 0: disable (even if the CPU has a NEON FPU.) 212 # 1: check at run time (via ARM_NEON_{API,CHECK}) 213 # 2: switch on unconditionally (inadvisable - instead pass 214 # -mfpu=neon to GCC in CC) 215 # When building libpng avoid using any setting other than '0'; '1' is 216 # set automatically when either 'API' or 'CHECK' are configured in, 217 # '2' should not be necessary as -mfpu=neon will achieve the same 218 # effect as well as applying NEON optimizations to the rest of the 219 # libpng code. 220 # NOTE: any setting other than '0' requires ALIGNED_MEMORY 221 # ARM_NEON_API: (PNG_ARM_NEON == 1) allow the optimization to be switched on 222 # with png_set_option 223 # ARM_NEON_CHECK: (PNG_ARM_NEON == 1) compile a run-time check to see if Neon 224 # extensions are supported. This is poorly supported and 225 # deprecated - use the png_set_option API. 226 setting ARM_NEON_OPT 227 option ARM_NEON_API disabled requires ALIGNED_MEMORY enables SET_OPTION, 228 sets ARM_NEON_OPT 1 229 option ARM_NEON_CHECK disabled requires ALIGNED_MEMORY, 230 sets ARM_NEON_OPT 1 231 232 # These settings configure the default compression level (0-9) and 'strategy'; 233 # strategy is as defined by the implementors of zlib. It describes the input 234 # data and modifies the zlib parameters in an attempt to optimize the balance 235 # between search and huffman encoding in the zlib algorithms. The defaults are 236 # the zlib.h defaults - the apparently recursive definition does not arise 237 # because the name of the setting is prefixed by PNG_ 238 # 239 # The TEXT values are the defaults when writing compressed text (all forms) 240 241 # Include the zlib header so that the defaults below are known 242 @# include <zlib.h> 243 244 # The '@' here means to substitute the value when pnglibconf.h is built 245 setting Z_DEFAULT_COMPRESSION default @Z_DEFAULT_COMPRESSION 246 # TODO: why aren't these Z_RLE; zlib.h says that Z_RLE, specifically, is 247 # appropriate for PNG images, maybe it doesn't exist in all versions? 248 setting Z_DEFAULT_STRATEGY default @Z_FILTERED 249 setting Z_DEFAULT_NOFILTER_STRATEGY default @Z_DEFAULT_STRATEGY 250 setting ZLIB_VERNUM default @ZLIB_VERNUM 251 252 # Linkage of: 253 # 254 # API: libpng API functions 255 # CALLBACK: internal non-file-local callbacks 256 # FUNCTION: internal non-file-local functions 257 # DATA: internal non-file-local (const) data 258 setting LINKAGE_API default extern 259 setting LINKAGE_CALLBACK default extern 260 setting LINKAGE_FUNCTION default extern 261 setting LINKAGE_DATA default extern 262 263 setting TEXT_Z_DEFAULT_COMPRESSION default @Z_DEFAULT_COMPRESSION 264 setting TEXT_Z_DEFAULT_STRATEGY default @Z_DEFAULT_STRATEGY 265 266 # Default to using the read macros 267 268 setting DEFAULT_READ_MACROS default 1 269 270 # The alternative is to call functions to read PNG values, if 271 # the functions are turned *off* the read macros must always 272 # be enabled, so turning this off will actually force the 273 # USE_READ_MACROS option on (see pngconf.h) 274 275 option READ_INT_FUNCTIONS requires READ 276 277 # The same for write but these can only be switched off if no writing 278 # is required at all - hence the use of a 'disabled', not a 'requires'. 279 # If these are needed, they are enabled in the 'WRITE options' section 280 # below. 281 282 option WRITE_INT_FUNCTIONS disabled 283 284 # Error controls 285 # 286 # WARNINGS: normally on, if off no warnings are generated 287 # ERROR_TEXT: normally on, if off errors happen but there is no message 288 # ERROR_NUMBERS: unimplemented feature, therefore disabled 289 # BENIGN_ERRORS: support for just issuing warnings for recoverable errors 290 # 291 # BENIGN_READ_ERRORS: 292 # By default recoverable errors on read should just generate warnings, 293 # generally safe but PNG files that don't conform to the specification will 294 # be accepted if a meaningful result can be produced. 295 # 296 # BENIGN_WRITE_ERRORS: 297 # By default recoverable errors on write should just generate warnings, 298 # not generally safe because this allows the application to write invalid 299 # PNG files. Applications should enable this themselves; it's useful 300 # because it means that a failure to write an ancilliary chunk can often be 301 # ignored. 302 303 option WARNINGS 304 option ERROR_TEXT 305 option ERROR_NUMBERS disabled 306 307 option BENIGN_ERRORS 308 option BENIGN_WRITE_ERRORS requires BENIGN_ERRORS disabled 309 option BENIGN_READ_ERRORS requires BENIGN_ERRORS 310 311 312 # Generic options - affect both read and write. 313 314 option MNG_FEATURES 315 316 # Arithmetic options, the first is the big switch that chooses between internal 317 # floating and fixed point arithmetic implementations - it does not affect any 318 # APIs. The second two (the _POINT settings) switch off individual APIs. 319 # 320 # Prior to libpng 1.6.8 one of the API (_POINT) variants had to be selected. At 321 # 1.6.8 this restriction has been removed; the simplified API can be used 322 # without enabling any of the low level fixed/floating APIs. 323 324 option FLOATING_ARITHMETIC 325 option FLOATING_POINT 326 option FIXED_POINT 327 328 # This protects us against compilers that run on a windowing system 329 # and thus don't have or would rather us not use the stdio types: 330 # stdin, stdout, and stderr. The only one currently used is stderr 331 # in png_error() and png_warning(). #defining PNG_NO_CONSOLE_IO will 332 # prevent these from being compiled and used. #defining PNG_NO_STDIO 333 # will also prevent these, plus will prevent the entire set of stdio 334 # macros and functions (FILE *, printf, etc.) from being compiled and used, 335 # unless (PNG_DEBUG > 0) has been #defined. 336 337 option STDIO 338 option CONSOLE_IO requires STDIO 339 340 # Note: prior to 1.5.0 this option could not be disabled if STDIO 341 # was enabled. Prior to 1.5.3 this option required STDIO 342 343 option TIME_RFC1123 344 345 # PNG_SETJMP_NOT_SUPPORTED is an old equivalent for NO_SETJMP 346 347 option SETJMP 348 = NO_SETJMP SETJMP_NOT_SUPPORTED 349 350 # If this is disabled it is not possible for apps to get the 351 # values from the 'info' structure, this effectively removes 352 # quite a lot of the READ API. 353 354 option EASY_ACCESS 355 356 # Added at libpng-1.2.0 357 358 option USER_MEM 359 360 # Added at libpng-1.4.0 361 362 option IO_STATE 363 364 # Libpng limits: limit the size of images and data on read. 365 # 366 # If this option is disabled all the limit checking code will be disabled: 367 368 option USER_LIMITS requires READ 369 370 # The default settings given below for the limits mean that libpng will 371 # limit the size of images or the size of data in ancilliary chunks to less 372 # than the specification or implementation limits. Settings have the 373 # following interpretations: 374 # 375 # USER_WIDTH_MAX: maximum width of an image that will be read 376 # USER_HEIGHT_MAX: maximum height 377 # USER_CHUNK_MALLOC_MAX: maximum in-memory (decompressed) size of a single chunk 378 # USER_CHUNK_CACHE_MAX: maximum number of chunks to be cached 379 # 380 # Only chunks that are variable in number are counted towards the 381 382 # Use 0x7fffffff for unlimited 383 setting USER_WIDTH_MAX default 1000000 384 setting USER_HEIGHT_MAX default 1000000 385 386 # Use 0 for unlimited 387 setting USER_CHUNK_CACHE_MAX default 1000 388 setting USER_CHUNK_MALLOC_MAX default 8000000 389 390 # If this option is enabled APIs to set the above limits at run time are added; 391 # without this the hardwired (compile time) limits will be used. 392 option SET_USER_LIMITS requires USER_LIMITS 393 394 # All of the following options relate to code capabilities for 395 # processing image data before creating a PNG or after reading one. 396 # You can remove these capabilities safely and still be PNG 397 # conformant, however the library that results is still non-standard. 398 # See the comments above about how to change options and settings. 399 400 # READ options 401 # 402 # WARNING: in libpng 1.5 maintained configuration compatibility with earlier 403 # versions. In some cases turning off an option turned off other options, in 404 # others it was ineffective unless dependent options were also turned off. 405 # Libpng 1.6 changes this: in general if you turn off an option that affects 406 # APIs it stays off and simply disables APIs that depend on it. 407 # 408 # As a result if you simply port the libpng 1.5 configuration to libpng 1.6 you 409 # will probably see build failures due to missing APIs. Fixing these failures 410 # requires some, perhaps considerable, knowledge of what your libpng using 411 # applications are doing, fortunately there is no great reason for you to move 412 # to libpng 1.6; the new interfaces in 1.6 will take several years to become 413 # popular. 414 415 option READ enables READ_INTERLACING SET_OPTION 416 417 # Disabling READ_16BIT does not disable reading 16-bit PNG files, but it 418 # forces them to be chopped down to 8-bit, and disables any 16-bit 419 # processing after that has happened. You need to be sure to enable 420 # READ_SCALE_16_TO_8 or READ_STRIP_16_TO_8 when you disable READ_16BIT for 421 # this to work properly. You should disable the other option if you need to 422 # ensure a particular conversion (otherwise the app can chose.) 423 424 option READ_16BIT requires READ enables 16BIT 425 426 option READ_QUANTIZE requires READ 427 428 option READ_TRANSFORMS requires READ 429 = NO_READ_TRANSFORMS READ_TRANSFORMS_NOT_SUPPORTED 430 431 # Read gamma handling. Gamma processing is a core part of libpng and many of 432 # the capabilities are dependent on libpng performing gamma correction. 433 # 434 # In libpng 1.6 disabling gamma processing (setting PNG_NO_READ_GAMMA) 435 # consistently disables those parts of the API that depend on it. Prior to 436 # 1.6.0 this was not true; the results were unpredictable and varied between 437 # releases. 438 # 439 # If you disable gamma processing and your program no longer compiles you need 440 # to ask whether you really need the APIs that are missing. If you do then you 441 # almost certainly need the gamma processing. 442 # 443 # If you handle gamma issues outside libpng then you do not need the libpng 444 # gamma processing; and it is an enormous waste of space. You just need to 445 # remove the use of libpng APIs that depend on it. 446 option READ_GAMMA requires READ_TRANSFORMS, READ_gAMA, READ_sRGB 447 448 option READ_ALPHA_MODE requires READ_TRANSFORMS, READ_GAMMA 449 option READ_BACKGROUND requires READ_TRANSFORMS, READ_STRIP_ALPHA, READ_GAMMA 450 option READ_BGR requires READ_TRANSFORMS 451 option READ_EXPAND_16 requires READ_TRANSFORMS, READ_16BIT, READ_EXPAND 452 option READ_EXPAND requires READ_TRANSFORMS 453 option READ_FILLER requires READ_TRANSFORMS 454 option READ_GRAY_TO_RGB requires READ_TRANSFORMS 455 option READ_INVERT_ALPHA requires READ_TRANSFORMS 456 option READ_INVERT requires READ_TRANSFORMS 457 option READ_PACK requires READ_TRANSFORMS 458 option READ_PACKSWAP requires READ_TRANSFORMS 459 option READ_RGB_TO_GRAY requires READ_TRANSFORMS, READ_GAMMA enables COLORSPACE 460 option READ_SCALE_16_TO_8 requires READ_TRANSFORMS 461 option READ_SHIFT requires READ_TRANSFORMS 462 option READ_STRIP_16_TO_8 requires READ_TRANSFORMS 463 option READ_STRIP_ALPHA requires READ_TRANSFORMS 464 option READ_SWAP_ALPHA requires READ_TRANSFORMS 465 option READ_SWAP requires READ_TRANSFORMS, READ_16BIT 466 option READ_USER_TRANSFORM requires READ_TRANSFORMS 467 468 option PROGRESSIVE_READ requires READ 469 option SEQUENTIAL_READ requires READ 470 471 # You can define PNG_NO_PROGRESSIVE_READ if you don't do progressive reading. 472 # This is not talking about interlacing capability! You'll still have 473 # interlacing unless you turn off the following which is required 474 # for PNG-compliant decoders. (In other words, do not do this - in 475 # fact it can't be disabled from the command line!) 476 #option READ_INTERLACING requires READ 477 478 option READ_COMPOSITE_NODIV requires READ 479 = NO_READ_COMPOSITE_NODIV NO_READ_COMPOSITED_NODIV 480 481 # Inch conversions 482 483 option INCH_CONVERSIONS 484 = INCH_CONVERSIONS INCH_CONVERSIONS 485 486 # API to build a grayscale palette 487 # NOTE: this is not used internally by libpng at present. 488 489 option BUILD_GRAYSCALE_PALETTE 490 491 # WRITE options 492 493 option WRITE enables WRITE_INT_FUNCTIONS 494 495 # Disabling WRITE_16BIT prevents 16-bit PNG files from being 496 # generated. 497 option WRITE_16BIT requires WRITE enables 16BIT 498 499 option WRITE_TRANSFORMS requires WRITE 500 = NO_WRITE_TRANSFORMS WRITE_TRANSFORMS_NOT_SUPPORTED 501 502 option WRITE_SHIFT requires WRITE_TRANSFORMS 503 option WRITE_PACK requires WRITE_TRANSFORMS 504 option WRITE_BGR requires WRITE_TRANSFORMS 505 option WRITE_SWAP requires WRITE_TRANSFORMS, WRITE_16BIT 506 option WRITE_PACKSWAP requires WRITE_TRANSFORMS 507 option WRITE_INVERT requires WRITE_TRANSFORMS 508 option WRITE_FILLER requires WRITE_TRANSFORMS 509 option WRITE_SWAP_ALPHA requires WRITE_TRANSFORMS 510 option WRITE_INVERT_ALPHA requires WRITE_TRANSFORMS 511 option WRITE_USER_TRANSFORM requires WRITE_TRANSFORMS 512 513 # This is not required for PNG-compliant encoders, but can cause 514 # trouble if left undefined 515 516 option WRITE_INTERLACING requires WRITE 517 518 # Deprecated, will be removed. 519 option WRITE_WEIGHTED_FILTER requires WRITE 520 521 option WRITE_FLUSH requires WRITE 522 523 # Note: these can be turned off explicitly if not required by the 524 # apps implementing the user transforms 525 option USER_TRANSFORM_PTR if READ_USER_TRANSFORM, WRITE_USER_TRANSFORM 526 option USER_TRANSFORM_INFO if READ_USER_TRANSFORM, WRITE_USER_TRANSFORM 527 528 # This enables API to set compression parameters for compressing 529 # non-IDAT chunks (zTXt, iTXt, iCCP, and unknown chunks). This feature 530 # was added at libpng-1.5.3. 531 option WRITE_CUSTOMIZE_ZTXT_COMPRESSION requires WRITE 532 option WRITE_CUSTOMIZE_COMPRESSION requires WRITE 533 534 # Any chunks you are not interested in, you can undef here. The 535 # ones that allocate memory may be expecially important (hIST, 536 # tEXt, zTXt, tRNS, pCAL). Others will just save time and make png_info 537 # a bit smaller. 538 539 # The size of the png_text structure changed in libpng-1.0.6 when 540 # iTXt support was added. iTXt support was turned off by default through 541 # libpng-1.2.x, to support old apps that malloc the png_text structure 542 # instead of calling png_set_text() and letting libpng malloc it. It 543 # was turned on by default in libpng-1.4.0. 544 545 option READ_ANCILLARY_CHUNKS requires READ 546 # PNG_READ_ANCILLARY_CHUNKS_NOT_SUPPORTED is deprecated. 547 = NO_READ_ANCILLARY_CHUNKS READ_ANCILLARY_CHUNKS_NOT_SUPPORTED 548 549 option WRITE_ANCILLARY_CHUNKS requires WRITE 550 # PNG_WRITE_ANCILLARY_CHUNKS_NOT_SUPPORTED is deprecated. 551 = NO_WRITE_ANCILLARY_CHUNKS WRITE_ANCILLARY_CHUNKS_NOT_SUPPORTED 552 553 # These options disable *all* the text chunks if turned off 554 555 option READ_TEXT requires READ_ANCILLARY_CHUNKS enables TEXT 556 option WRITE_TEXT requires WRITE_ANCILLARY_CHUNKS enables TEXT 557 558 # Moved to pnglibconf.h at libpng-1.5.0 559 # Feature support: in 1.4 this was in pngconf.h, but the following 560 # features have no affect on the libpng API. Add library 561 # only features to the end of this list. Add features that 562 # affect the API above. (Note: the list of chunks follows 563 # the library-only settings.) 564 # 565 # BUILD TIME ONLY OPTIONS 566 # These options do not affect the API but rather alter how the 567 # API is implemented, they get recorded in pnglibconf.h, but 568 # can't be changed by the application. 569 570 # Colorspace support (enabled as required); just the support for colorant 571 # information. Gamma support, likewise, is just support for the gamma 572 # information, READ_GAMMA is required for gamma transformations (so it 573 # is possible to read PNG gamma without enabling all the libpng transform 574 # code - do this for applications that do their own gamma processing) 575 # 576 # As of 1.6.0 COLORSPACE is only useful if the application processes the 577 # information; this is because the library does not do any colorspace 578 # processing, it just validates the data in the PNG file. 579 580 option GAMMA disabled 581 option COLORSPACE enables GAMMA disabled 582 583 # When an ICC profile is read, or png_set, it will be checked for a match 584 # against known sRGB profiles if the sRGB handling is enabled. The 585 # PNG_sRGB_PROFILE_CHECKS setting controls how much work is done during the 586 # check: 587 # 588 # -1: Don't do any sRGB profile checking. 589 # 590 # 0: Just validate the profile MD5 signature if present, otherwise use 591 # the checks in option 1. 592 # 593 # 1: Additionally check the length, intent and adler32 checksum of the 594 # actual data. If enabled this will reject known profiles that have 595 # had the rendering intent in the header changed as well as other edits 596 # done without updating the checksum. See the discussion below. 597 # 598 # 2: Additionally checksum all the data using the ethernet CRC32 algorithm. 599 # This makes it more difficult to fake profiles and makes it less likely 600 # to get a false positive on profiles with no signature, but is probably 601 # just a waste of time since all currently approved ICC sRGB profiles have 602 # a secure MD5 signature. 603 # 604 # The rendering intent. An ICC profile stores an intended rendering intent, 605 # but does not include the value in the signature. The intent is documented 606 # as the intent that should be used when combining two profiles. The sRGB 607 # profile is intended, however, to be used with any of the four defined intents. 608 # For this reason the sRGB chunk includes an 'intent' to be used when displaying 609 # the image (intent is really a property of the image not the profile.) 610 # 611 # Unfortunately the iCCP chunk does not. It may therefore be that some 612 # applications modify the intent in profiles (including sRGB profiles) to work 613 # round this problem. Selecting an option other than option '0' will cause such 614 # modified profiles to be rejected. 615 # 616 # Security. The use of Adler32 and CRC32 checksums does not help significantly 617 # with any security issues. It is relatively easy to produce arbitrary profiles 618 # with the required checksums on current computer systems. Nevertheless 619 # security does not seem to be an issue because the only consequence of a false 620 # positive is a false assertion that the profile is an sRGB profile. This might 621 # be used to hide data from libpng using applications, but it doesn't seem 622 # possible to damage them. 623 624 setting sRGB_PROFILE_CHECKS default 2 625 626 # Artificially align memory - the code typically aligns to 8 byte 627 # boundaries if this is switched on, it's a small waste of space 628 # but can help (in theory) on some architectures. Only affects 629 # internal structures. Added at libpng 1.4.0 630 631 option ALIGNED_MEMORY 632 633 # Buggy compilers (e.g., gcc 2.7.2.2) need PNG_NO_POINTER_INDEXING 634 # See png[wr]util.c, normally this should always be *on* 635 636 option POINTER_INDEXING 637 638 # Other defines for things like memory and the like can go here. 639 640 # BUILD TIME SETTINGS 641 # Like build time options these do not affect the API, but they 642 # may be useful to applications because they record details of 643 # how the API will behave particularly with regard to overall 644 # accuracy. 645 646 # This controls how fine the quantizing gets. As this allocates 647 # a largish chunk of memory (32K), those who are not as concerned 648 # with quantizing quality can decrease some or all of these. 649 650 setting QUANTIZE_RED_BITS default 5 651 setting QUANTIZE_GREEN_BITS default 5 652 setting QUANTIZE_BLUE_BITS default 5 653 654 # This controls how fine the gamma correction becomes when you 655 # are only interested in 8 bits anyway. Increasing this value 656 # results in more memory being used, and more pow() functions 657 # being called to fill in the gamma tables. Don't set this value 658 # less than 8, and even that may not work (I haven't tested it). 659 660 setting MAX_GAMMA_8 default 11 661 662 # This controls how much a difference in gamma we can tolerate before 663 # we actually start doing gamma conversion, it's a fixed point value, 664 # so the default below is 0.05, meaning libpng ignores corrections in 665 # the range 0.95 to 1.05 666 667 setting GAMMA_THRESHOLD_FIXED default 5000 668 669 # Precision to use when converting a floating point value to a PNG 670 # extension format string in an sCAL chunk (only relevant if the 671 # floating point API is enabled) 672 673 setting sCAL_PRECISION default 5 674 675 # This is the size of the compression buffer, and thus the size of 676 # an IDAT chunk. Make this whatever size you feel is best for your 677 # machine. One of these will be allocated per png_struct. When this 678 # is full, it writes the data to the disk, and does some other 679 # calculations. Making this an extremely small size may slow 680 # the library down, but you may want to experiment to determine 681 # where it becomes significant, if you are concerned with memory 682 # usage. Note that zlib allocates at least 32Kb also. For readers, 683 # this describes the size of the buffer available to read the data in. 684 # Unless this gets smaller than the size of a row (compressed), 685 # it should not make much difference how big this is. 686 687 setting ZBUF_SIZE default 8192 688 689 # This is the size of the decompression buffer used when counting or checking 690 # the decompressed size of an LZ stream from a compressed ancilliary chunk; the 691 # decompressed data is never used so a different size may be optimal. This size 692 # was determined using contrib/libtests/timepng.c with compressed zTXt data 693 # around 11MByte in size. Slight speed improvements (up to about 14% in 694 # timepng) can be achieved by very large increases (to 32kbyte) on regular data, 695 # but highly compressible data shows only around 2% improvement. The size is 696 # chosen to minimize the effects of DoS attacks based on using very large 697 # amounts of highly compressible data. 698 699 setting INFLATE_BUF_SIZE default 1024 700 701 # This is the maximum amount of IDAT data that the sequential reader will 702 # process at one time. The setting does not affect the size of IDAT chunks 703 # read, just the amount read at once. Neither does it affect the progressive 704 # reader, which processes just the amount of data the application gives it. 705 # The sequential reader is currently unable to process more than one IDAT at 706 # once - it has to read and process each one in turn. There is no point setting 707 # this to a value larger than the IDAT chunks typically encountered (it would 708 # just waste memory) but there may be some point in reducing it below the value 709 # of ZBUF_SIZE (the size of IDAT chunks written by libpng.) 710 711 setting IDAT_READ_SIZE default PNG_ZBUF_SIZE 712 713 # Ancillary chunks 714 chunk bKGD 715 chunk cHRM enables COLORSPACE 716 chunk gAMA enables GAMMA 717 chunk hIST 718 chunk iCCP enables COLORSPACE, GAMMA 719 chunk iTXt enables TEXT 720 chunk oFFs 721 chunk pCAL 722 chunk pHYs 723 chunk sBIT 724 chunk sCAL 725 chunk sPLT 726 chunk sRGB enables COLORSPACE, GAMMA, SET_OPTION 727 chunk tEXt requires TEXT 728 chunk tIME 729 chunk tRNS 730 chunk zTXt enables TEXT 731 732 # This only affects support of the optional PLTE chunk in RGB and RGBA 733 # images. Notice that READ_ANCILLARY_CHUNKS therefore disables part 734 # of the regular chunk reading too. 735 736 option READ_OPT_PLTE requires READ_ANCILLARY_CHUNKS 737 738 # Unknown chunk handling 739 # 740 # 'UNKNOWN_CHUNKS' is a global option to disable all unknown chunk handling on 741 # read or write; everything else below requires it (directly or indirectly). 742 option UNKNOWN_CHUNKS 743 744 # There are three main options to control the ability to read and write unknown 745 # chunks. If either read option is turned on then unknown chunks will be read, 746 # otherwise they are skipped. If the write option is turned on unknown chunks 747 # set by png_set_unknown_chunks will be written otherwise it is an error to call 748 # that API on a write struct. 749 option WRITE_UNKNOWN_CHUNKS requires WRITE requires UNKNOWN_CHUNKS 750 option WRITE_UNKNOWN_CHUNKS enables STORE_UNKNOWN_CHUNKS 751 752 # The first way to read user chunks is to have libpng save them for a later call 753 # to png_get_unknown_chunks, the application must call 754 # png_set_keep_unknown_chunks to cause this to actually happen (see png.h) 755 option SAVE_UNKNOWN_CHUNKS requires READ requires SET_UNKNOWN_CHUNKS 756 option SAVE_UNKNOWN_CHUNKS enables READ_UNKNOWN_CHUNKS, STORE_UNKNOWN_CHUNKS 757 758 # The second approach is to use an application provided callback to process the 759 # chunks, the callback can either handle the chunk entirely itself or request 760 # that libpng store the chunk for later retrieval via png_get_unknown_chunks. 761 # 762 # NOTE: If STORE_UNKNOWN_CHUNKS is not enabled (which is the default if 763 # both SAVE_UNKNOWN_CHUNKS and WRITE_UNKNOWN_CHUNKS are disabled) then a 764 # 0 result from the callback will be ignored because no support for saving 765 # unknown chunks has been compiled in. The normal symptom is that your app 766 # fails to compile because png_get_unknown_chunks is no longer defined in png.h. 767 # If you encounter this issue simply enable STORE_UNKNOWN_CHUNKS in your build. 768 # 769 # Note that there is no 'WRITE_USER_CHUNKS' so the USER_CHUNKS option is always 770 # the same as READ_USER_CHUNKS at present 771 option READ_USER_CHUNKS requires READ, UNKNOWN_CHUNKS 772 option READ_USER_CHUNKS enables READ_UNKNOWN_CHUNKS, USER_CHUNKS 773 774 # Two further options are provided to allow detailed control of the handling. 775 # The first enables png_set_keep_unknown_chunks; this allows the default to be 776 # changed from discarding unknown chunks and allows per-chunk control. This is 777 # required to use the SAVE_UNKNOWN_CHUNKS option. If enabled this option also 778 # applies to write (see png.h), otherwise the write API simply writes all the 779 # chunks it is given. 780 # 781 # The second option extends the unknown handling to allow known chunks to be 782 # handled as though they were unknown. This option doesn't change any APIs, it 783 # merely turns on the code to check known as well as unknown chunks. 784 # 785 # This option no longer affects the write code. It can be safely disabled and 786 # will prevent applications stopping libpng reading known chunks. 787 option SET_UNKNOWN_CHUNKS requires UNKNOWN_CHUNKS 788 option HANDLE_AS_UNKNOWN requires SET_UNKNOWN_CHUNKS 789 790 # The following options are derived from the above and should not be turned on 791 # explicitly. 792 option READ_UNKNOWN_CHUNKS requires UNKNOWN_CHUNKS disabled 793 option STORE_UNKNOWN_CHUNKS requires UNKNOWN_CHUNKS disabled 794 795 option CONVERT_tIME requires WRITE_ANCILLARY_CHUNKS 796 # The "tm" structure is not supported on WindowsCE 797 798 @#ifdef _WIN32_WCE 799 @# define PNG_NO_CONVERT_tIME 800 @#endif 801 802 option WRITE_FILTER requires WRITE 803 804 option SAVE_INT_32 disabled 805 # png_save_int_32 is required internally for writing the ancillary chunks oFFs 806 # and pCAL and for both reading and writing iCCP (for the generation/checking of 807 # the corresponding cHRM/gAMA chunks) if full ICC is supported. 808 809 # added at libpng-1.5.4 810 811 option WRITE_OPTIMIZE_CMF requires WRITE 812 813 option READ_COMPRESSED_TEXT disabled 814 option READ_iCCP enables READ_COMPRESSED_TEXT 815 option READ_iTXt enables READ_COMPRESSED_TEXT 816 option READ_zTXt enables READ_COMPRESSED_TEXT 817 818 option WRITE_oFFs enables SAVE_INT_32 819 option WRITE_pCAL enables SAVE_INT_32 820 option WRITE_cHRM enables SAVE_INT_32 821 822 option WRITE_COMPRESSED_TEXT disabled 823 option WRITE_iCCP enables WRITE_COMPRESSED_TEXT 824 option WRITE_iTXt enables WRITE_COMPRESSED_TEXT 825 option WRITE_zTXt enables WRITE_COMPRESSED_TEXT 826 827 # Turn this off to disable png_read_png() and png_write_png() and 828 # leave the row_pointers member out of the info structure. 829 830 option INFO_IMAGE 831 832 # added at libpng-1.5.10 833 # Turn this off to disable warning about invalid palette index and 834 # leave the num_palette_max member out of the png structure. 835 836 option CHECK_FOR_INVALID_INDEX enables READ_CHECK_FOR_INVALID_INDEX 837 option CHECK_FOR_INVALID_INDEX enables WRITE_CHECK_FOR_INVALID_INDEX 838 option READ_CHECK_FOR_INVALID_INDEX requires READ, CHECK_FOR_INVALID_INDEX 839 option WRITE_CHECK_FOR_INVALID_INDEX requires WRITE, CHECK_FOR_INVALID_INDEX 840 841 # added at libpng-1.5.15 842 option GET_PALETTE_MAX enables READ_GET_PALETTE_MAX WRITE_GET_PALETTE_MAX 843 option READ_GET_PALETTE_MAX requires READ_CHECK_FOR_INVALID_INDEX disabled 844 option WRITE_GET_PALETTE_MAX requires WRITE_CHECK_FOR_INVALID_INDEX disabled 845 846 # Simplified API options (added at libpng-1.6.0) 847 # In libpng 1.6.8 the handling of these options was changed to used 'requires' 848 # throughout, so that disabling some of the low level support always disables 849 # the base simplified read/write API. This much simplifies the handling and 850 # makes 'everything = off' work in a more intuitive way. It eliminates a 851 # previously reported feature that APIs previously enabled by the simplified 852 # API couldn't be turned off without explicitly turning off the simplified 853 # APIs. 854 # 855 # Read: 856 option SIMPLIFIED_READ, 857 requires SEQUENTIAL_READ, READ_TRANSFORMS, SETJMP, BENIGN_ERRORS, 858 READ_EXPAND, READ_16BIT, READ_EXPAND_16, READ_SCALE_16_TO_8, 859 READ_RGB_TO_GRAY, READ_ALPHA_MODE, READ_BACKGROUND, READ_STRIP_ALPHA, 860 READ_FILLER, READ_SWAP, READ_PACK, READ_GRAY_TO_RGB, READ_GAMMA, 861 READ_tRNS, READ_bKGD, READ_gAMA, READ_cHRM, READ_sRGB, READ_sBIT 862 863 # AFIRST and BGR read options: 864 # Prior to libpng 1.6.8 these were disabled but switched on if the low level 865 # libpng routines that do the swaps were enabled. This worked but was 866 # confusing. In libpng 1.6.8 the options were changed to simple 'requires' 867 # and are enabled by default. This should work the same way in practice. 868 option SIMPLIFIED_READ_AFIRST enables FORMAT_AFIRST, 869 requires SIMPLIFIED_READ READ_SWAP_ALPHA 870 871 option SIMPLIFIED_READ_BGR enables FORMAT_BGR, 872 requires SIMPLIFIED_READ READ_BGR 873 874 # Write: 875 option SIMPLIFIED_WRITE, 876 requires WRITE, SETJMP, WRITE_SWAP, WRITE_PACK, 877 WRITE_tRNS, WRITE_gAMA, WRITE_sRGB, WRITE_cHRM 878 879 # 1.6.22: allow simplified write without stdio support: 880 option SIMPLIFIED_WRITE_STDIO requires SIMPLIFIED_WRITE STDIO 881 882 option SIMPLIFIED_WRITE_AFIRST enables FORMAT_AFIRST, 883 requires SIMPLIFIED_WRITE WRITE_SWAP_ALPHA 884 885 option SIMPLIFIED_WRITE_BGR enables FORMAT_BGR, 886 requires SIMPLIFIED_WRITE WRITE_BGR 887 888 # Formats: 889 option FORMAT_AFIRST disabled 890 option FORMAT_BGR disabled 891
