"Fossies" - the Fresh Open Source Software Archive

Member "pngcrush-1.8.13/png.h" (29 Aug 2017, 144052 Bytes) of package /linux/privat/pngcrush-1.8.13.tar.gz:


As a special service "Fossies" has tried to format the requested source page into HTML format using (guessed) C and C++ source code syntax highlighting (style: standard) with prefixed line numbers and code folding option. Alternatively you can here view or download the uninterpreted source code file. For more information about "png.h" see the Fossies "Dox" file reference documentation and the latest Fossies "Diffs" side-by-side code changes report: 1.8.12_vs_1.8.13.

    1 
    2 /* png.h - header file for PNG reference library
    3  *
    4  * libpng version 1.6.32, August 24, 2017
    5  *
    6  * Copyright (c) 1998-2002,2004,2006-2017 Glenn Randers-Pehrson
    7  * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
    8  * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
    9  *
   10  * This code is released under the libpng license (See LICENSE, below)
   11  *
   12  * Authors and maintainers:
   13  *   libpng versions 0.71, May 1995, through 0.88, January 1996: Guy Schalnat
   14  *   libpng versions 0.89, June 1996, through 0.96, May 1997: Andreas Dilger
   15  *   libpng versions 0.97, January 1998, through 1.6.32, August 24, 2017:
   16  *     Glenn Randers-Pehrson.
   17  *   See also "Contributing Authors", below.
   18  */
   19 
   20 /*
   21  * COPYRIGHT NOTICE, DISCLAIMER, and LICENSE:
   22  *
   23  * If you modify libpng you may insert additional notices immediately following
   24  * this sentence.
   25  *
   26  * This code is released under the libpng license.
   27  *
   28  * libpng versions 1.0.7, July 1, 2000 through 1.6.32, August 24, 2017 are
   29  * Copyright (c) 2000-2002, 2004, 2006-2017 Glenn Randers-Pehrson, are
   30  * derived from libpng-1.0.6, and are distributed according to the same
   31  * disclaimer and license as libpng-1.0.6 with the following individuals
   32  * added to the list of Contributing Authors:
   33  *
   34  *    Simon-Pierre Cadieux
   35  *    Eric S. Raymond
   36  *    Mans Rullgard
   37  *    Cosmin Truta
   38  *    Gilles Vollant
   39  *    James Yu
   40  *    Mandar Sahastrabuddhe
   41  *    Google Inc.
   42  *    Vadim Barkov
   43  *
   44  * and with the following additions to the disclaimer:
   45  *
   46  *    There is no warranty against interference with your enjoyment of the
   47  *    library or against infringement.  There is no warranty that our
   48  *    efforts or the library will fulfill any of your particular purposes
   49  *    or needs.  This library is provided with all faults, and the entire
   50  *    risk of satisfactory quality, performance, accuracy, and effort is with
   51  *    the user.
   52  *
   53  * Some files in the "contrib" directory and some configure-generated
   54  * files that are distributed with libpng have other copyright owners and
   55  * are released under other open source licenses.
   56  *
   57  * libpng versions 0.97, January 1998, through 1.0.6, March 20, 2000, are
   58  * Copyright (c) 1998-2000 Glenn Randers-Pehrson, are derived from
   59  * libpng-0.96, and are distributed according to the same disclaimer and
   60  * license as libpng-0.96, with the following individuals added to the list
   61  * of Contributing Authors:
   62  *
   63  *    Tom Lane
   64  *    Glenn Randers-Pehrson
   65  *    Willem van Schaik
   66  *
   67  * libpng versions 0.89, June 1996, through 0.96, May 1997, are
   68  * Copyright (c) 1996-1997 Andreas Dilger, are derived from libpng-0.88,
   69  * and are distributed according to the same disclaimer and license as
   70  * libpng-0.88, with the following individuals added to the list of
   71  * Contributing Authors:
   72  *
   73  *    John Bowler
   74  *    Kevin Bracey
   75  *    Sam Bushell
   76  *    Magnus Holmgren
   77  *    Greg Roelofs
   78  *    Tom Tanner
   79  *
   80  * Some files in the "scripts" directory have other copyright owners
   81  * but are released under this license.
   82  *
   83  * libpng versions 0.5, May 1995, through 0.88, January 1996, are
   84  * Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.
   85  *
   86  * For the purposes of this copyright and license, "Contributing Authors"
   87  * is defined as the following set of individuals:
   88  *
   89  *    Andreas Dilger
   90  *    Dave Martindale
   91  *    Guy Eric Schalnat
   92  *    Paul Schmidt
   93  *    Tim Wegner
   94  *
   95  * The PNG Reference Library is supplied "AS IS".  The Contributing Authors
   96  * and Group 42, Inc. disclaim all warranties, expressed or implied,
   97  * including, without limitation, the warranties of merchantability and of
   98  * fitness for any purpose.  The Contributing Authors and Group 42, Inc.
   99  * assume no liability for direct, indirect, incidental, special, exemplary,
  100  * or consequential damages, which may result from the use of the PNG
  101  * Reference Library, even if advised of the possibility of such damage.
  102  *
  103  * Permission is hereby granted to use, copy, modify, and distribute this
  104  * source code, or portions hereof, for any purpose, without fee, subject
  105  * to the following restrictions:
  106  *
  107  *   1. The origin of this source code must not be misrepresented.
  108  *
  109  *   2. Altered versions must be plainly marked as such and must not
  110  *      be misrepresented as being the original source.
  111  *
  112  *   3. This Copyright notice may not be removed or altered from any
  113  *      source or altered source distribution.
  114  *
  115  * The Contributing Authors and Group 42, Inc. specifically permit, without
  116  * fee, and encourage the use of this source code as a component to
  117  * supporting the PNG file format in commercial products.  If you use this
  118  * source code in a product, acknowledgment is not required but would be
  119  * appreciated.
  120  *
  121  * END OF COPYRIGHT NOTICE, DISCLAIMER, and LICENSE.
  122  *
  123  * TRADEMARK:
  124  *
  125  * The name "libpng" has not been registered by the Copyright owner
  126  * as a trademark in any jurisdiction.  However, because libpng has
  127  * been distributed and maintained world-wide, continually since 1995,
  128  * the Copyright owner claims "common-law trademark protection" in any
  129  * jurisdiction where common-law trademark is recognized.
  130  *
  131  * OSI CERTIFICATION:
  132  *
  133  * Libpng is OSI Certified Open Source Software.  OSI Certified Open Source is
  134  * a certification mark of the Open Source Initiative. OSI has not addressed
  135  * the additional disclaimers inserted at version 1.0.7.
  136  *
  137  * EXPORT CONTROL:
  138  *
  139  * The Copyright owner believes that the Export Control Classification
  140  * Number (ECCN) for libpng is EAR99, which means not subject to export
  141  * controls or International Traffic in Arms Regulations (ITAR) because
  142  * it is open source, publicly available software, that does not contain
  143  * any encryption software.  See the EAR, paragraphs 734.3(b)(3) and
  144  * 734.7(b).
  145  */
  146 
  147 /*
  148  * A "png_get_copyright" function is available, for convenient use in "about"
  149  * boxes and the like:
  150  *
  151  *    printf("%s", png_get_copyright(NULL));
  152  *
  153  * Also, the PNG logo (in PNG format, of course) is supplied in the
  154  * files "pngbar.png" and "pngbar.jpg (88x31) and "pngnow.png" (98x31).
  155  */
  156 
  157 /*
  158  * The contributing authors would like to thank all those who helped
  159  * with testing, bug fixes, and patience.  This wouldn't have been
  160  * possible without all of you.
  161  *
  162  * Thanks to Frank J. T. Wojcik for helping with the documentation.
  163  */
  164 
  165 /* Note about libpng version numbers:
  166  *
  167  *    Due to various miscommunications, unforeseen code incompatibilities
  168  *    and occasional factors outside the authors' control, version numbering
  169  *    on the library has not always been consistent and straightforward.
  170  *    The following table summarizes matters since version 0.89c, which was
  171  *    the first widely used release:
  172  *
  173  *    source                 png.h  png.h  shared-lib
  174  *    version                string   int  version
  175  *    -------                ------ -----  ----------
  176  *    0.89c "1.0 beta 3"     0.89      89  1.0.89
  177  *    0.90  "1.0 beta 4"     0.90      90  0.90  [should have been 2.0.90]
  178  *    0.95  "1.0 beta 5"     0.95      95  0.95  [should have been 2.0.95]
  179  *    0.96  "1.0 beta 6"     0.96      96  0.96  [should have been 2.0.96]
  180  *    0.97b "1.00.97 beta 7" 1.00.97   97  1.0.1 [should have been 2.0.97]
  181  *    0.97c                  0.97      97  2.0.97
  182  *    0.98                   0.98      98  2.0.98
  183  *    0.99                   0.99      98  2.0.99
  184  *    0.99a-m                0.99      99  2.0.99
  185  *    1.00                   1.00     100  2.1.0 [100 should be 10000]
  186  *    1.0.0      (from here on, the   100  2.1.0 [100 should be 10000]
  187  *    1.0.1       png.h string is   10001  2.1.0
  188  *    1.0.1a-e    identical to the  10002  from here on, the shared library
  189  *    1.0.2       source version)   10002  is 2.V where V is the source code
  190  *    1.0.2a-b                      10003  version, except as noted.
  191  *    1.0.3                         10003
  192  *    1.0.3a-d                      10004
  193  *    1.0.4                         10004
  194  *    1.0.4a-f                      10005
  195  *    1.0.5 (+ 2 patches)           10005
  196  *    1.0.5a-d                      10006
  197  *    1.0.5e-r                      10100 (not source compatible)
  198  *    1.0.5s-v                      10006 (not binary compatible)
  199  *    1.0.6 (+ 3 patches)           10006 (still binary incompatible)
  200  *    1.0.6d-f                      10007 (still binary incompatible)
  201  *    1.0.6g                        10007
  202  *    1.0.6h                        10007  10.6h (testing xy.z so-numbering)
  203  *    1.0.6i                        10007  10.6i
  204  *    1.0.6j                        10007  2.1.0.6j (incompatible with 1.0.0)
  205  *    1.0.7beta11-14        DLLNUM  10007  2.1.0.7beta11-14 (binary compatible)
  206  *    1.0.7beta15-18           1    10007  2.1.0.7beta15-18 (binary compatible)
  207  *    1.0.7rc1-2               1    10007  2.1.0.7rc1-2 (binary compatible)
  208  *    1.0.7                    1    10007  (still compatible)
  209  *    ...
  210  *    1.0.19                  10    10019  10.so.0.19[.0]
  211  *    ...
  212  *    1.2.57                  13    10257  12.so.0.57[.0]
  213  *    ...
  214  *    1.5.28                  15    10527  15.so.15.28[.0]
  215  *    ...
  216  *    1.6.32                  16    10632  16.so.16.32[.0]
  217  *
  218  *    Henceforth the source version will match the shared-library major
  219  *    and minor numbers; the shared-library major version number will be
  220  *    used for changes in backward compatibility, as it is intended.  The
  221  *    PNG_LIBPNG_VER macro, which is not used within libpng but is available
  222  *    for applications, is an unsigned integer of the form xyyzz corresponding
  223  *    to the source version x.y.z (leading zeros in y and z).  Beta versions
  224  *    were given the previous public release number plus a letter, until
  225  *    version 1.0.6j; from then on they were given the upcoming public
  226  *    release number plus "betaNN" or "rcNN".
  227  *
  228  *    Binary incompatibility exists only when applications make direct access
  229  *    to the info_ptr or png_ptr members through png.h, and the compiled
  230  *    application is loaded with a different version of the library.
  231  *
  232  *    DLLNUM will change each time there are forward or backward changes
  233  *    in binary compatibility (e.g., when a new feature is added).
  234  *
  235  * See libpng.txt or libpng.3 for more information.  The PNG specification
  236  * is available as a W3C Recommendation and as an ISO Specification,
  237  * <https://www.w3.org/TR/2003/REC-PNG-20031110/
  238  */
  239 
  240 /*
  241  * Y2K compliance in libpng:
  242  * =========================
  243  *
  244  *    August 24, 2017
  245  *
  246  *    Since the PNG Development group is an ad-hoc body, we can't make
  247  *    an official declaration.
  248  *
  249  *    This is your unofficial assurance that libpng from version 0.71 and
  250  *    upward through 1.6.32 are Y2K compliant.  It is my belief that
  251  *    earlier versions were also Y2K compliant.
  252  *
  253  *    Libpng only has two year fields.  One is a 2-byte unsigned integer
  254  *    that will hold years up to 65535.  The other, which is deprecated,
  255  *    holds the date in text format, and will hold years up to 9999.
  256  *
  257  *    The integer is
  258  *        "png_uint_16 year" in png_time_struct.
  259  *
  260  *    The string is
  261  *        "char time_buffer[29]" in png_struct.  This is no longer used
  262  *    in libpng-1.6.x and will be removed from libpng-1.7.0.
  263  *
  264  *    There are seven time-related functions:
  265  *        png.c: png_convert_to_rfc_1123_buffer() in png.c
  266  *          (formerly png_convert_to_rfc_1123() prior to libpng-1.5.x and
  267  *          png_convert_to_rfc_1152() in error prior to libpng-0.98)
  268  *        png_convert_from_struct_tm() in pngwrite.c, called in pngwrite.c
  269  *        png_convert_from_time_t() in pngwrite.c
  270  *        png_get_tIME() in pngget.c
  271  *        png_handle_tIME() in pngrutil.c, called in pngread.c
  272  *        png_set_tIME() in pngset.c
  273  *        png_write_tIME() in pngwutil.c, called in pngwrite.c
  274  *
  275  *    All handle dates properly in a Y2K environment.  The
  276  *    png_convert_from_time_t() function calls gmtime() to convert from system
  277  *    clock time, which returns (year - 1900), which we properly convert to
  278  *    the full 4-digit year.  There is a possibility that libpng applications
  279  *    are not passing 4-digit years into the png_convert_to_rfc_1123_buffer()
  280  *    function, or that they are incorrectly passing only a 2-digit year
  281  *    instead of "year - 1900" into the png_convert_from_struct_tm() function,
  282  *    but this is not under our control.  The libpng documentation has always
  283  *    stated that it works with 4-digit years, and the APIs have been
  284  *    documented as such.
  285  *
  286  *    The tIME chunk itself is also Y2K compliant.  It uses a 2-byte unsigned
  287  *    integer to hold the year, and can hold years as large as 65535.
  288  *
  289  *    zlib, upon which libpng depends, is also Y2K compliant.  It contains
  290  *    no date-related code.
  291  *
  292  *       Glenn Randers-Pehrson
  293  *       libpng maintainer
  294  *       PNG Development Group
  295  */
  296 
  297 #ifndef PNG_H
  298 #define PNG_H
  299 
  300 /* This is not the place to learn how to use libpng. The file libpng-manual.txt
  301  * describes how to use libpng, and the file example.c summarizes it
  302  * with some code on which to build.  This file is useful for looking
  303  * at the actual function definitions and structure components.  If that
  304  * file has been stripped from your copy of libpng, you can find it at
  305  * <http://www.libpng.org/pub/png/libpng-manual.txt>
  306  *
  307  * If you just need to read a PNG file and don't want to read the documentation
  308  * skip to the end of this file and read the section entitled 'simplified API'.
  309  */
  310 
  311 /* Version information for png.h - this should match the version in png.c */
  312 #define PNG_LIBPNG_VER_STRING "1.6.32"
  313 #define PNG_HEADER_VERSION_STRING " libpng version 1.6.32 - August 24, 2017\n"
  314 
  315 #define PNG_LIBPNG_VER_SONUM   16
  316 #define PNG_LIBPNG_VER_DLLNUM  16
  317 
  318 /* These should match the first 3 components of PNG_LIBPNG_VER_STRING: */
  319 #define PNG_LIBPNG_VER_MAJOR   1
  320 #define PNG_LIBPNG_VER_MINOR   6
  321 #define PNG_LIBPNG_VER_RELEASE 32
  322 
  323 /* This should match the numeric part of the final component of
  324  * PNG_LIBPNG_VER_STRING, omitting any leading zero:
  325  */
  326 
  327 #define PNG_LIBPNG_VER_BUILD  0
  328 
  329 /* Release Status */
  330 #define PNG_LIBPNG_BUILD_ALPHA    1
  331 #define PNG_LIBPNG_BUILD_BETA     2
  332 #define PNG_LIBPNG_BUILD_RC       3
  333 #define PNG_LIBPNG_BUILD_STABLE   4
  334 #define PNG_LIBPNG_BUILD_RELEASE_STATUS_MASK 7
  335 
  336 /* Release-Specific Flags */
  337 #define PNG_LIBPNG_BUILD_PATCH    8 /* Can be OR'ed with
  338                                        PNG_LIBPNG_BUILD_STABLE only */
  339 #define PNG_LIBPNG_BUILD_PRIVATE 16 /* Cannot be OR'ed with
  340                                        PNG_LIBPNG_BUILD_SPECIAL */
  341 #define PNG_LIBPNG_BUILD_SPECIAL 32 /* Cannot be OR'ed with
  342                                        PNG_LIBPNG_BUILD_PRIVATE */
  343 
  344 #define PNG_LIBPNG_BUILD_BASE_TYPE PNG_LIBPNG_BUILD_STABLE
  345 
  346 /* Careful here.  At one time, Guy wanted to use 082, but that would be octal.
  347  * We must not include leading zeros.
  348  * Versions 0.7 through 1.0.0 were in the range 0 to 100 here (only
  349  * version 1.0.0 was mis-numbered 100 instead of 10000).  From
  350  * version 1.0.1 it's    xxyyzz, where x=major, y=minor, z=release
  351  */
  352 #define PNG_LIBPNG_VER 10632 /* 1.6.32 */
  353 
  354 /* Library configuration: these options cannot be changed after
  355  * the library has been built.
  356  */
  357 #ifndef PNGLCONF_H
  358 /* If pnglibconf.h is missing, you can
  359  * copy scripts/pnglibconf.h.prebuilt to pnglibconf.h
  360  */
  361 #   include "pnglibconf.h"
  362 #endif
  363 
  364 #ifndef PNG_VERSION_INFO_ONLY
  365 /* Machine specific configuration. */
  366 #  include "pngconf.h"
  367 #endif
  368 
  369 /*
  370  * Added at libpng-1.2.8
  371  *
  372  * Ref MSDN: Private as priority over Special
  373  * VS_FF_PRIVATEBUILD File *was not* built using standard release
  374  * procedures. If this value is given, the StringFileInfo block must
  375  * contain a PrivateBuild string.
  376  *
  377  * VS_FF_SPECIALBUILD File *was* built by the original company using
  378  * standard release procedures but is a variation of the standard
  379  * file of the same version number. If this value is given, the
  380  * StringFileInfo block must contain a SpecialBuild string.
  381  */
  382 
  383 #ifdef PNG_USER_PRIVATEBUILD /* From pnglibconf.h */
  384 #  define PNG_LIBPNG_BUILD_TYPE \
  385        (PNG_LIBPNG_BUILD_BASE_TYPE | PNG_LIBPNG_BUILD_PRIVATE)
  386 #else
  387 #  ifdef PNG_LIBPNG_SPECIALBUILD
  388 #    define PNG_LIBPNG_BUILD_TYPE \
  389          (PNG_LIBPNG_BUILD_BASE_TYPE | PNG_LIBPNG_BUILD_SPECIAL)
  390 #  else
  391 #    define PNG_LIBPNG_BUILD_TYPE (PNG_LIBPNG_BUILD_BASE_TYPE)
  392 #  endif
  393 #endif
  394 
  395 #ifndef PNG_VERSION_INFO_ONLY
  396 
  397 /* Inhibit C++ name-mangling for libpng functions but not for system calls. */
  398 #ifdef __cplusplus
  399 extern "C" {
  400 #endif /* __cplusplus */
  401 
  402 /* Version information for C files, stored in png.c.  This had better match
  403  * the version above.
  404  */
  405 #define png_libpng_ver png_get_header_ver(NULL)
  406 
  407 /* This file is arranged in several sections:
  408  *
  409  * 1. [omitted]
  410  * 2. Any configuration options that can be specified by for the application
  411  *    code when it is built.  (Build time configuration is in pnglibconf.h)
  412  * 3. Type definitions (base types are defined in pngconf.h), structure
  413  *    definitions.
  414  * 4. Exported library functions.
  415  * 5. Simplified API.
  416  * 6. Implementation options.
  417  *
  418  * The library source code has additional files (principally pngpriv.h) that
  419  * allow configuration of the library.
  420  */
  421 
  422 /* Section 1: [omitted] */
  423 
  424 /* Section 2: run time configuration
  425  * See pnglibconf.h for build time configuration
  426  *
  427  * Run time configuration allows the application to choose between
  428  * implementations of certain arithmetic APIs.  The default is set
  429  * at build time and recorded in pnglibconf.h, but it is safe to
  430  * override these (and only these) settings.  Note that this won't
  431  * change what the library does, only application code, and the
  432  * settings can (and probably should) be made on a per-file basis
  433  * by setting the #defines before including png.h
  434  *
  435  * Use macros to read integers from PNG data or use the exported
  436  * functions?
  437  *   PNG_USE_READ_MACROS: use the macros (see below)  Note that
  438  *     the macros evaluate their argument multiple times.
  439  *   PNG_NO_USE_READ_MACROS: call the relevant library function.
  440  *
  441  * Use the alternative algorithm for compositing alpha samples that
  442  * does not use division?
  443  *   PNG_READ_COMPOSITE_NODIV_SUPPORTED: use the 'no division'
  444  *      algorithm.
  445  *   PNG_NO_READ_COMPOSITE_NODIV: use the 'division' algorithm.
  446  *
  447  * How to handle benign errors if PNG_ALLOW_BENIGN_ERRORS is
  448  * false?
  449  *   PNG_ALLOW_BENIGN_ERRORS: map calls to the benign error
  450  *      APIs to png_warning.
  451  * Otherwise the calls are mapped to png_error.
  452  */
  453 
  454 /* Section 3: type definitions, including structures and compile time
  455  * constants.
  456  * See pngconf.h for base types that vary by machine/system
  457  */
  458 
  459 /* This triggers a compiler error in png.c, if png.c and png.h
  460  * do not agree upon the version number.
  461  */
  462 typedef char* png_libpng_version_1_6_32;
  463 
  464 /* Basic control structions.  Read libpng-manual.txt or libpng.3 for more info.
  465  *
  466  * png_struct is the cache of information used while reading or writing a single
  467  * PNG file.  One of these is always required, although the simplified API
  468  * (below) hides the creation and destruction of it.
  469  */
  470 typedef struct png_struct_def png_struct;
  471 typedef const png_struct * png_const_structp;
  472 typedef png_struct * png_structp;
  473 typedef png_struct * * png_structpp;
  474 
  475 /* png_info contains information read from or to be written to a PNG file.  One
  476  * or more of these must exist while reading or creating a PNG file.  The
  477  * information is not used by libpng during read but is used to control what
  478  * gets written when a PNG file is created.  "png_get_" function calls read
  479  * information during read and "png_set_" functions calls write information
  480  * when creating a PNG.
  481  * been moved into a separate header file that is not accessible to
  482  * applications.  Read libpng-manual.txt or libpng.3 for more info.
  483  */
  484 typedef struct png_info_def png_info;
  485 typedef png_info * png_infop;
  486 typedef const png_info * png_const_infop;
  487 typedef png_info * * png_infopp;
  488 
  489 /* Types with names ending 'p' are pointer types.  The corresponding types with
  490  * names ending 'rp' are identical pointer types except that the pointer is
  491  * marked 'restrict', which means that it is the only pointer to the object
  492  * passed to the function.  Applications should not use the 'restrict' types;
  493  * it is always valid to pass 'p' to a pointer with a function argument of the
  494  * corresponding 'rp' type.  Different compilers have different rules with
  495  * regard to type matching in the presence of 'restrict'.  For backward
  496  * compatibility libpng callbacks never have 'restrict' in their parameters and,
  497  * consequentially, writing portable application code is extremely difficult if
  498  * an attempt is made to use 'restrict'.
  499  */
  500 typedef png_struct * PNG_RESTRICT png_structrp;
  501 typedef const png_struct * PNG_RESTRICT png_const_structrp;
  502 typedef png_info * PNG_RESTRICT png_inforp;
  503 typedef const png_info * PNG_RESTRICT png_const_inforp;
  504 
  505 /* Three color definitions.  The order of the red, green, and blue, (and the
  506  * exact size) is not important, although the size of the fields need to
  507  * be png_byte or png_uint_16 (as defined below).
  508  */
  509 typedef struct png_color_struct
  510 {
  511    png_byte red;
  512    png_byte green;
  513    png_byte blue;
  514 } png_color;
  515 typedef png_color * png_colorp;
  516 typedef const png_color * png_const_colorp;
  517 typedef png_color * * png_colorpp;
  518 
  519 typedef struct png_color_16_struct
  520 {
  521    png_byte index;    /* used for palette files */
  522    png_uint_16 red;   /* for use in red green blue files */
  523    png_uint_16 green;
  524    png_uint_16 blue;
  525    png_uint_16 gray;  /* for use in grayscale files */
  526 } png_color_16;
  527 typedef png_color_16 * png_color_16p;
  528 typedef const png_color_16 * png_const_color_16p;
  529 typedef png_color_16 * * png_color_16pp;
  530 
  531 typedef struct png_color_8_struct
  532 {
  533    png_byte red;   /* for use in red green blue files */
  534    png_byte green;
  535    png_byte blue;
  536    png_byte gray;  /* for use in grayscale files */
  537    png_byte alpha; /* for alpha channel files */
  538 } png_color_8;
  539 typedef png_color_8 * png_color_8p;
  540 typedef const png_color_8 * png_const_color_8p;
  541 typedef png_color_8 * * png_color_8pp;
  542 
  543 /*
  544  * The following two structures are used for the in-core representation
  545  * of sPLT chunks.
  546  */
  547 typedef struct png_sPLT_entry_struct
  548 {
  549    png_uint_16 red;
  550    png_uint_16 green;
  551    png_uint_16 blue;
  552    png_uint_16 alpha;
  553    png_uint_16 frequency;
  554 } png_sPLT_entry;
  555 typedef png_sPLT_entry * png_sPLT_entryp;
  556 typedef const png_sPLT_entry * png_const_sPLT_entryp;
  557 typedef png_sPLT_entry * * png_sPLT_entrypp;
  558 
  559 /*  When the depth of the sPLT palette is 8 bits, the color and alpha samples
  560  *  occupy the LSB of their respective members, and the MSB of each member
  561  *  is zero-filled.  The frequency member always occupies the full 16 bits.
  562  */
  563 
  564 typedef struct png_sPLT_struct
  565 {
  566    png_charp name;           /* palette name */
  567    png_byte depth;           /* depth of palette samples */
  568    png_sPLT_entryp entries;  /* palette entries */
  569    png_int_32 nentries;      /* number of palette entries */
  570 } png_sPLT_t;
  571 typedef png_sPLT_t * png_sPLT_tp;
  572 typedef const png_sPLT_t * png_const_sPLT_tp;
  573 typedef png_sPLT_t * * png_sPLT_tpp;
  574 
  575 #ifdef PNG_TEXT_SUPPORTED
  576 /* png_text holds the contents of a text/ztxt/itxt chunk in a PNG file,
  577  * and whether that contents is compressed or not.  The "key" field
  578  * points to a regular zero-terminated C string.  The "text" fields can be a
  579  * regular C string, an empty string, or a NULL pointer.
  580  * However, the structure returned by png_get_text() will always contain
  581  * the "text" field as a regular zero-terminated C string (possibly
  582  * empty), never a NULL pointer, so it can be safely used in printf() and
  583  * other string-handling functions.  Note that the "itxt_length", "lang", and
  584  * "lang_key" members of the structure only exist when the library is built
  585  * with iTXt chunk support.  Prior to libpng-1.4.0 the library was built by
  586  * default without iTXt support. Also note that when iTXt *is* supported,
  587  * the "lang" and "lang_key" fields contain NULL pointers when the
  588  * "compression" field contains * PNG_TEXT_COMPRESSION_NONE or
  589  * PNG_TEXT_COMPRESSION_zTXt. Note that the "compression value" is not the
  590  * same as what appears in the PNG tEXt/zTXt/iTXt chunk's "compression flag"
  591  * which is always 0 or 1, or its "compression method" which is always 0.
  592  */
  593 typedef struct png_text_struct
  594 {
  595    int  compression;       /* compression value:
  596                              -1: tEXt, none
  597                               0: zTXt, deflate
  598                               1: iTXt, none
  599                               2: iTXt, deflate  */
  600    png_charp key;          /* keyword, 1-79 character description of "text" */
  601    png_charp text;         /* comment, may be an empty string (ie "")
  602                               or a NULL pointer */
  603    png_size_t text_length; /* length of the text string */
  604    png_size_t itxt_length; /* length of the itxt string */
  605    png_charp lang;         /* language code, 0-79 characters
  606                               or a NULL pointer */
  607    png_charp lang_key;     /* keyword translated UTF-8 string, 0 or more
  608                               chars or a NULL pointer */
  609 } png_text;
  610 typedef png_text * png_textp;
  611 typedef const png_text * png_const_textp;
  612 typedef png_text * * png_textpp;
  613 #endif
  614 
  615 /* Supported compression types for text in PNG files (tEXt, and zTXt).
  616  * The values of the PNG_TEXT_COMPRESSION_ defines should NOT be changed. */
  617 #define PNG_TEXT_COMPRESSION_NONE_WR -3
  618 #define PNG_TEXT_COMPRESSION_zTXt_WR -2
  619 #define PNG_TEXT_COMPRESSION_NONE    -1
  620 #define PNG_TEXT_COMPRESSION_zTXt     0
  621 #define PNG_ITXT_COMPRESSION_NONE     1
  622 #define PNG_ITXT_COMPRESSION_zTXt     2
  623 #define PNG_TEXT_COMPRESSION_LAST     3  /* Not a valid value */
  624 
  625 /* png_time is a way to hold the time in an machine independent way.
  626  * Two conversions are provided, both from time_t and struct tm.  There
  627  * is no portable way to convert to either of these structures, as far
  628  * as I know.  If you know of a portable way, send it to me.  As a side
  629  * note - PNG has always been Year 2000 compliant!
  630  */
  631 typedef struct png_time_struct
  632 {
  633    png_uint_16 year; /* full year, as in, 1995 */
  634    png_byte month;   /* month of year, 1 - 12 */
  635    png_byte day;     /* day of month, 1 - 31 */
  636    png_byte hour;    /* hour of day, 0 - 23 */
  637    png_byte minute;  /* minute of hour, 0 - 59 */
  638    png_byte second;  /* second of minute, 0 - 60 (for leap seconds) */
  639 } png_time;
  640 typedef png_time * png_timep;
  641 typedef const png_time * png_const_timep;
  642 typedef png_time * * png_timepp;
  643 
  644 #if defined(PNG_STORE_UNKNOWN_CHUNKS_SUPPORTED) ||\
  645    defined(PNG_USER_CHUNKS_SUPPORTED)
  646 /* png_unknown_chunk is a structure to hold queued chunks for which there is
  647  * no specific support.  The idea is that we can use this to queue
  648  * up private chunks for output even though the library doesn't actually
  649  * know about their semantics.
  650  *
  651  * The data in the structure is set by libpng on read and used on write.
  652  */
  653 typedef struct png_unknown_chunk_t
  654 {
  655    png_byte name[5]; /* Textual chunk name with '\0' terminator */
  656    png_byte *data;   /* Data, should not be modified on read! */
  657    png_size_t size;
  658 
  659    /* On write 'location' must be set using the flag values listed below.
  660     * Notice that on read it is set by libpng however the values stored have
  661     * more bits set than are listed below.  Always treat the value as a
  662     * bitmask.  On write set only one bit - setting multiple bits may cause the
  663     * chunk to be written in multiple places.
  664     */
  665    png_byte location; /* mode of operation at read time */
  666 }
  667 png_unknown_chunk;
  668 
  669 typedef png_unknown_chunk * png_unknown_chunkp;
  670 typedef const png_unknown_chunk * png_const_unknown_chunkp;
  671 typedef png_unknown_chunk * * png_unknown_chunkpp;
  672 #endif
  673 
  674 /* Flag values for the unknown chunk location byte. */
  675 #define PNG_HAVE_IHDR  0x01
  676 #define PNG_HAVE_PLTE  0x02
  677 #define PNG_AFTER_IDAT 0x08
  678 
  679 /* Maximum positive integer used in PNG is (2^31)-1 */
  680 #define PNG_UINT_31_MAX ((png_uint_32)0x7fffffffL)
  681 #define PNG_UINT_32_MAX ((png_uint_32)(-1))
  682 #define PNG_SIZE_MAX ((png_size_t)(-1))
  683 
  684 /* These are constants for fixed point values encoded in the
  685  * PNG specification manner (x100000)
  686  */
  687 #define PNG_FP_1    100000
  688 #define PNG_FP_HALF  50000
  689 #define PNG_FP_MAX  ((png_fixed_point)0x7fffffffL)
  690 #define PNG_FP_MIN  (-PNG_FP_MAX)
  691 
  692 /* These describe the color_type field in png_info. */
  693 /* color type masks */
  694 #define PNG_COLOR_MASK_PALETTE    1
  695 #define PNG_COLOR_MASK_COLOR      2
  696 #define PNG_COLOR_MASK_ALPHA      4
  697 
  698 /* color types.  Note that not all combinations are legal */
  699 #define PNG_COLOR_TYPE_GRAY 0
  700 #define PNG_COLOR_TYPE_PALETTE  (PNG_COLOR_MASK_COLOR | PNG_COLOR_MASK_PALETTE)
  701 #define PNG_COLOR_TYPE_RGB        (PNG_COLOR_MASK_COLOR)
  702 #define PNG_COLOR_TYPE_RGB_ALPHA  (PNG_COLOR_MASK_COLOR | PNG_COLOR_MASK_ALPHA)
  703 #define PNG_COLOR_TYPE_GRAY_ALPHA (PNG_COLOR_MASK_ALPHA)
  704 /* aliases */
  705 #define PNG_COLOR_TYPE_RGBA  PNG_COLOR_TYPE_RGB_ALPHA
  706 #define PNG_COLOR_TYPE_GA  PNG_COLOR_TYPE_GRAY_ALPHA
  707 
  708 /* This is for compression type. PNG 1.0-1.2 only define the single type. */
  709 #define PNG_COMPRESSION_TYPE_BASE 0 /* Deflate method 8, 32K window */
  710 #define PNG_COMPRESSION_TYPE_DEFAULT PNG_COMPRESSION_TYPE_BASE
  711 
  712 /* This is for filter type. PNG 1.0-1.2 only define the single type. */
  713 #define PNG_FILTER_TYPE_BASE      0 /* Single row per-byte filtering */
  714 #define PNG_INTRAPIXEL_DIFFERENCING 64 /* Used only in MNG datastreams */
  715 #define PNG_FILTER_TYPE_DEFAULT   PNG_FILTER_TYPE_BASE
  716 
  717 /* These are for the interlacing type.  These values should NOT be changed. */
  718 #define PNG_INTERLACE_NONE        0 /* Non-interlaced image */
  719 #define PNG_INTERLACE_ADAM7       1 /* Adam7 interlacing */
  720 #define PNG_INTERLACE_LAST        2 /* Not a valid value */
  721 
  722 /* These are for the oFFs chunk.  These values should NOT be changed. */
  723 #define PNG_OFFSET_PIXEL          0 /* Offset in pixels */
  724 #define PNG_OFFSET_MICROMETER     1 /* Offset in micrometers (1/10^6 meter) */
  725 #define PNG_OFFSET_LAST           2 /* Not a valid value */
  726 
  727 /* These are for the pCAL chunk.  These values should NOT be changed. */
  728 #define PNG_EQUATION_LINEAR       0 /* Linear transformation */
  729 #define PNG_EQUATION_BASE_E       1 /* Exponential base e transform */
  730 #define PNG_EQUATION_ARBITRARY    2 /* Arbitrary base exponential transform */
  731 #define PNG_EQUATION_HYPERBOLIC   3 /* Hyperbolic sine transformation */
  732 #define PNG_EQUATION_LAST         4 /* Not a valid value */
  733 
  734 /* These are for the sCAL chunk.  These values should NOT be changed. */
  735 #define PNG_SCALE_UNKNOWN         0 /* unknown unit (image scale) */
  736 #define PNG_SCALE_METER           1 /* meters per pixel */
  737 #define PNG_SCALE_RADIAN          2 /* radians per pixel */
  738 #define PNG_SCALE_LAST            3 /* Not a valid value */
  739 
  740 /* These are for the pHYs chunk.  These values should NOT be changed. */
  741 #define PNG_RESOLUTION_UNKNOWN    0 /* pixels/unknown unit (aspect ratio) */
  742 #define PNG_RESOLUTION_METER      1 /* pixels/meter */
  743 #define PNG_RESOLUTION_LAST       2 /* Not a valid value */
  744 
  745 /* These are for the sRGB chunk.  These values should NOT be changed. */
  746 #define PNG_sRGB_INTENT_PERCEPTUAL 0
  747 #define PNG_sRGB_INTENT_RELATIVE   1
  748 #define PNG_sRGB_INTENT_SATURATION 2
  749 #define PNG_sRGB_INTENT_ABSOLUTE   3
  750 #define PNG_sRGB_INTENT_LAST       4 /* Not a valid value */
  751 
  752 /* This is for text chunks */
  753 #define PNG_KEYWORD_MAX_LENGTH     79
  754 
  755 /* Maximum number of entries in PLTE/sPLT/tRNS arrays */
  756 #define PNG_MAX_PALETTE_LENGTH    256
  757 
  758 /* These determine if an ancillary chunk's data has been successfully read
  759  * from the PNG header, or if the application has filled in the corresponding
  760  * data in the info_struct to be written into the output file.  The values
  761  * of the PNG_INFO_<chunk> defines should NOT be changed.
  762  */
  763 #define PNG_INFO_gAMA 0x0001U
  764 #define PNG_INFO_sBIT 0x0002U
  765 #define PNG_INFO_cHRM 0x0004U
  766 #define PNG_INFO_PLTE 0x0008U
  767 #define PNG_INFO_tRNS 0x0010U
  768 #define PNG_INFO_bKGD 0x0020U
  769 #define PNG_INFO_hIST 0x0040U
  770 #define PNG_INFO_pHYs 0x0080U
  771 #define PNG_INFO_oFFs 0x0100U
  772 #define PNG_INFO_tIME 0x0200U
  773 #define PNG_INFO_pCAL 0x0400U
  774 #define PNG_INFO_sRGB 0x0800U  /* GR-P, 0.96a */
  775 #define PNG_INFO_iCCP 0x1000U  /* ESR, 1.0.6 */
  776 #define PNG_INFO_sPLT 0x2000U  /* ESR, 1.0.6 */
  777 #define PNG_INFO_sCAL 0x4000U  /* ESR, 1.0.6 */
  778 #define PNG_INFO_IDAT 0x8000U  /* ESR, 1.0.6 */
  779 #define PNG_INFO_eXIf 0x10000U /* GR-P, 1.6.31 */
  780 
  781 /* This is used for the transformation routines, as some of them
  782  * change these values for the row.  It also should enable using
  783  * the routines for other purposes.
  784  */
  785 typedef struct png_row_info_struct
  786 {
  787    png_uint_32 width;    /* width of row */
  788    png_size_t rowbytes;  /* number of bytes in row */
  789    png_byte color_type;  /* color type of row */
  790    png_byte bit_depth;   /* bit depth of row */
  791    png_byte channels;    /* number of channels (1, 2, 3, or 4) */
  792    png_byte pixel_depth; /* bits per pixel (depth * channels) */
  793 } png_row_info;
  794 
  795 typedef png_row_info * png_row_infop;
  796 typedef png_row_info * * png_row_infopp;
  797 
  798 /* These are the function types for the I/O functions and for the functions
  799  * that allow the user to override the default I/O functions with his or her
  800  * own.  The png_error_ptr type should match that of user-supplied warning
  801  * and error functions, while the png_rw_ptr type should match that of the
  802  * user read/write data functions.  Note that the 'write' function must not
  803  * modify the buffer it is passed. The 'read' function, on the other hand, is
  804  * expected to return the read data in the buffer.
  805  */
  806 typedef PNG_CALLBACK(void, *png_error_ptr, (png_structp, png_const_charp));
  807 typedef PNG_CALLBACK(void, *png_rw_ptr, (png_structp, png_bytep, png_size_t));
  808 typedef PNG_CALLBACK(void, *png_flush_ptr, (png_structp));
  809 typedef PNG_CALLBACK(void, *png_read_status_ptr, (png_structp, png_uint_32,
  810     int));
  811 typedef PNG_CALLBACK(void, *png_write_status_ptr, (png_structp, png_uint_32,
  812     int));
  813 
  814 #ifdef PNG_PROGRESSIVE_READ_SUPPORTED
  815 typedef PNG_CALLBACK(void, *png_progressive_info_ptr, (png_structp, png_infop));
  816 typedef PNG_CALLBACK(void, *png_progressive_end_ptr, (png_structp, png_infop));
  817 
  818 /* The following callback receives png_uint_32 row_number, int pass for the
  819  * png_bytep data of the row.  When transforming an interlaced image the
  820  * row number is the row number within the sub-image of the interlace pass, so
  821  * the value will increase to the height of the sub-image (not the full image)
  822  * then reset to 0 for the next pass.
  823  *
  824  * Use PNG_ROW_FROM_PASS_ROW(row, pass) and PNG_COL_FROM_PASS_COL(col, pass) to
  825  * find the output pixel (x,y) given an interlaced sub-image pixel
  826  * (row,col,pass).  (See below for these macros.)
  827  */
  828 typedef PNG_CALLBACK(void, *png_progressive_row_ptr, (png_structp, png_bytep,
  829     png_uint_32, int));
  830 #endif
  831 
  832 #if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \
  833     defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED)
  834 typedef PNG_CALLBACK(void, *png_user_transform_ptr, (png_structp, png_row_infop,
  835     png_bytep));
  836 #endif
  837 
  838 #ifdef PNG_USER_CHUNKS_SUPPORTED
  839 typedef PNG_CALLBACK(int, *png_user_chunk_ptr, (png_structp,
  840     png_unknown_chunkp));
  841 #endif
  842 #ifdef PNG_UNKNOWN_CHUNKS_SUPPORTED
  843 /* not used anywhere */
  844 /* typedef PNG_CALLBACK(void, *png_unknown_chunk_ptr, (png_structp)); */
  845 #endif
  846 
  847 #ifdef PNG_SETJMP_SUPPORTED
  848 /* This must match the function definition in <setjmp.h>, and the application
  849  * must include this before png.h to obtain the definition of jmp_buf.  The
  850  * function is required to be PNG_NORETURN, but this is not checked.  If the
  851  * function does return the application will crash via an abort() or similar
  852  * system level call.
  853  *
  854  * If you get a warning here while building the library you may need to make
  855  * changes to ensure that pnglibconf.h records the calling convention used by
  856  * your compiler.  This may be very difficult - try using a different compiler
  857  * to build the library!
  858  */
  859 PNG_FUNCTION(void, (PNGCAPI *png_longjmp_ptr), PNGARG((jmp_buf, int)), typedef);
  860 #endif
  861 
  862 /* Transform masks for the high-level interface */
  863 #define PNG_TRANSFORM_IDENTITY       0x0000    /* read and write */
  864 #define PNG_TRANSFORM_STRIP_16       0x0001    /* read only */
  865 #define PNG_TRANSFORM_STRIP_ALPHA    0x0002    /* read only */
  866 #define PNG_TRANSFORM_PACKING        0x0004    /* read and write */
  867 #define PNG_TRANSFORM_PACKSWAP       0x0008    /* read and write */
  868 #define PNG_TRANSFORM_EXPAND         0x0010    /* read only */
  869 #define PNG_TRANSFORM_INVERT_MONO    0x0020    /* read and write */
  870 #define PNG_TRANSFORM_SHIFT          0x0040    /* read and write */
  871 #define PNG_TRANSFORM_BGR            0x0080    /* read and write */
  872 #define PNG_TRANSFORM_SWAP_ALPHA     0x0100    /* read and write */
  873 #define PNG_TRANSFORM_SWAP_ENDIAN    0x0200    /* read and write */
  874 #define PNG_TRANSFORM_INVERT_ALPHA   0x0400    /* read and write */
  875 #define PNG_TRANSFORM_STRIP_FILLER   0x0800    /* write only */
  876 /* Added to libpng-1.2.34 */
  877 #define PNG_TRANSFORM_STRIP_FILLER_BEFORE PNG_TRANSFORM_STRIP_FILLER
  878 #define PNG_TRANSFORM_STRIP_FILLER_AFTER 0x1000 /* write only */
  879 /* Added to libpng-1.4.0 */
  880 #define PNG_TRANSFORM_GRAY_TO_RGB   0x2000      /* read only */
  881 /* Added to libpng-1.5.4 */
  882 #define PNG_TRANSFORM_EXPAND_16     0x4000      /* read only */
  883 #if INT_MAX >= 0x8000 /* else this might break */
  884 #define PNG_TRANSFORM_SCALE_16      0x8000      /* read only */
  885 #endif
  886 
  887 /* Flags for MNG supported features */
  888 #define PNG_FLAG_MNG_EMPTY_PLTE     0x01
  889 #define PNG_FLAG_MNG_FILTER_64      0x04
  890 #define PNG_ALL_MNG_FEATURES        0x05
  891 
  892 /* NOTE: prior to 1.5 these functions had no 'API' style declaration,
  893  * this allowed the zlib default functions to be used on Windows
  894  * platforms.  In 1.5 the zlib default malloc (which just calls malloc and
  895  * ignores the first argument) should be completely compatible with the
  896  * following.
  897  */
  898 typedef PNG_CALLBACK(png_voidp, *png_malloc_ptr, (png_structp,
  899     png_alloc_size_t));
  900 typedef PNG_CALLBACK(void, *png_free_ptr, (png_structp, png_voidp));
  901 
  902 /* Section 4: exported functions
  903  * Here are the function definitions most commonly used.  This is not
  904  * the place to find out how to use libpng.  See libpng-manual.txt for the
  905  * full explanation, see example.c for the summary.  This just provides
  906  * a simple one line description of the use of each function.
  907  *
  908  * The PNG_EXPORT() and PNG_EXPORTA() macros used below are defined in
  909  * pngconf.h and in the *.dfn files in the scripts directory.
  910  *
  911  *   PNG_EXPORT(ordinal, type, name, (args));
  912  *
  913  *       ordinal:    ordinal that is used while building
  914  *                   *.def files. The ordinal value is only
  915  *                   relevant when preprocessing png.h with
  916  *                   the *.dfn files for building symbol table
  917  *                   entries, and are removed by pngconf.h.
  918  *       type:       return type of the function
  919  *       name:       function name
  920  *       args:       function arguments, with types
  921  *
  922  * When we wish to append attributes to a function prototype we use
  923  * the PNG_EXPORTA() macro instead.
  924  *
  925  *   PNG_EXPORTA(ordinal, type, name, (args), attributes);
  926  *
  927  *       ordinal, type, name, and args: same as in PNG_EXPORT().
  928  *       attributes: function attributes
  929  */
  930 
  931 /* Returns the version number of the library */
  932 PNG_EXPORT(1, png_uint_32, png_access_version_number, (void));
  933 
  934 /* Tell lib we have already handled the first <num_bytes> magic bytes.
  935  * Handling more than 8 bytes from the beginning of the file is an error.
  936  */
  937 PNG_EXPORT(2, void, png_set_sig_bytes, (png_structrp png_ptr, int num_bytes));
  938 
  939 /* Check sig[start] through sig[start + num_to_check - 1] to see if it's a
  940  * PNG file.  Returns zero if the supplied bytes match the 8-byte PNG
  941  * signature, and non-zero otherwise.  Having num_to_check == 0 or
  942  * start > 7 will always fail (ie return non-zero).
  943  */
  944 PNG_EXPORT(3, int, png_sig_cmp, (png_const_bytep sig, png_size_t start,
  945     png_size_t num_to_check));
  946 
  947 /* Simple signature checking function.  This is the same as calling
  948  * png_check_sig(sig, n) := !png_sig_cmp(sig, 0, n).
  949  */
  950 #define png_check_sig(sig, n) !png_sig_cmp((sig), 0, (n))
  951 
  952 /* Allocate and initialize png_ptr struct for reading, and any other memory. */
  953 PNG_EXPORTA(4, png_structp, png_create_read_struct,
  954     (png_const_charp user_png_ver, png_voidp error_ptr,
  955     png_error_ptr error_fn, png_error_ptr warn_fn),
  956     PNG_ALLOCATED);
  957 
  958 /* Allocate and initialize png_ptr struct for writing, and any other memory */
  959 PNG_EXPORTA(5, png_structp, png_create_write_struct,
  960     (png_const_charp user_png_ver, png_voidp error_ptr, png_error_ptr error_fn,
  961     png_error_ptr warn_fn),
  962     PNG_ALLOCATED);
  963 
  964 PNG_EXPORT(6, png_size_t, png_get_compression_buffer_size,
  965     (png_const_structrp png_ptr));
  966 
  967 PNG_EXPORT(7, void, png_set_compression_buffer_size, (png_structrp png_ptr,
  968     png_size_t size));
  969 
  970 /* Moved from pngconf.h in 1.4.0 and modified to ensure setjmp/longjmp
  971  * match up.
  972  */
  973 #ifdef PNG_SETJMP_SUPPORTED
  974 /* This function returns the jmp_buf built in to *png_ptr.  It must be
  975  * supplied with an appropriate 'longjmp' function to use on that jmp_buf
  976  * unless the default error function is overridden in which case NULL is
  977  * acceptable.  The size of the jmp_buf is checked against the actual size
  978  * allocated by the library - the call will return NULL on a mismatch
  979  * indicating an ABI mismatch.
  980  */
  981 PNG_EXPORT(8, jmp_buf*, png_set_longjmp_fn, (png_structrp png_ptr,
  982     png_longjmp_ptr longjmp_fn, size_t jmp_buf_size));
  983 #  define png_jmpbuf(png_ptr) \
  984       (*png_set_longjmp_fn((png_ptr), longjmp, (sizeof (jmp_buf))))
  985 #else
  986 #  define png_jmpbuf(png_ptr) \
  987       (LIBPNG_WAS_COMPILED_WITH__PNG_NO_SETJMP)
  988 #endif
  989 /* This function should be used by libpng applications in place of
  990  * longjmp(png_ptr->jmpbuf, val).  If longjmp_fn() has been set, it
  991  * will use it; otherwise it will call PNG_ABORT().  This function was
  992  * added in libpng-1.5.0.
  993  */
  994 PNG_EXPORTA(9, void, png_longjmp, (png_const_structrp png_ptr, int val),
  995     PNG_NORETURN);
  996 
  997 #ifdef PNG_READ_SUPPORTED
  998 /* Reset the compression stream */
  999 PNG_EXPORTA(10, int, png_reset_zstream, (png_structrp png_ptr), PNG_DEPRECATED);
 1000 #endif
 1001 
 1002 /* New functions added in libpng-1.0.2 (not enabled by default until 1.2.0) */
 1003 #ifdef PNG_USER_MEM_SUPPORTED
 1004 PNG_EXPORTA(11, png_structp, png_create_read_struct_2,
 1005     (png_const_charp user_png_ver, png_voidp error_ptr, png_error_ptr error_fn,
 1006     png_error_ptr warn_fn,
 1007     png_voidp mem_ptr, png_malloc_ptr malloc_fn, png_free_ptr free_fn),
 1008     PNG_ALLOCATED);
 1009 PNG_EXPORTA(12, png_structp, png_create_write_struct_2,
 1010     (png_const_charp user_png_ver, png_voidp error_ptr, png_error_ptr error_fn,
 1011     png_error_ptr warn_fn,
 1012     png_voidp mem_ptr, png_malloc_ptr malloc_fn, png_free_ptr free_fn),
 1013     PNG_ALLOCATED);
 1014 #endif
 1015 
 1016 /* Write the PNG file signature. */
 1017 PNG_EXPORT(13, void, png_write_sig, (png_structrp png_ptr));
 1018 
 1019 /* Write a PNG chunk - size, type, (optional) data, CRC. */
 1020 PNG_EXPORT(14, void, png_write_chunk, (png_structrp png_ptr, png_const_bytep
 1021     chunk_name, png_const_bytep data, png_size_t length));
 1022 
 1023 /* Write the start of a PNG chunk - length and chunk name. */
 1024 PNG_EXPORT(15, void, png_write_chunk_start, (png_structrp png_ptr,
 1025     png_const_bytep chunk_name, png_uint_32 length));
 1026 
 1027 /* Write the data of a PNG chunk started with png_write_chunk_start(). */
 1028 PNG_EXPORT(16, void, png_write_chunk_data, (png_structrp png_ptr,
 1029     png_const_bytep data, png_size_t length));
 1030 
 1031 /* Finish a chunk started with png_write_chunk_start() (includes CRC). */
 1032 PNG_EXPORT(17, void, png_write_chunk_end, (png_structrp png_ptr));
 1033 
 1034 /* Allocate and initialize the info structure */
 1035 PNG_EXPORTA(18, png_infop, png_create_info_struct, (png_const_structrp png_ptr),
 1036     PNG_ALLOCATED);
 1037 
 1038 /* DEPRECATED: this function allowed init structures to be created using the
 1039  * default allocation method (typically malloc).  Use is deprecated in 1.6.0 and
 1040  * the API will be removed in the future.
 1041  */
 1042 PNG_EXPORTA(19, void, png_info_init_3, (png_infopp info_ptr,
 1043     png_size_t png_info_struct_size), PNG_DEPRECATED);
 1044 
 1045 /* Writes all the PNG information before the image. */
 1046 PNG_EXPORT(20, void, png_write_info_before_PLTE,
 1047     (png_structrp png_ptr, png_const_inforp info_ptr));
 1048 PNG_EXPORT(21, void, png_write_info,
 1049     (png_structrp png_ptr, png_const_inforp info_ptr));
 1050 
 1051 #ifdef PNG_SEQUENTIAL_READ_SUPPORTED
 1052 /* Read the information before the actual image data. */
 1053 PNG_EXPORT(22, void, png_read_info,
 1054     (png_structrp png_ptr, png_inforp info_ptr));
 1055 #endif
 1056 
 1057 #ifdef PNG_TIME_RFC1123_SUPPORTED
 1058    /* Convert to a US string format: there is no localization support in this
 1059     * routine.  The original implementation used a 29 character buffer in
 1060     * png_struct, this will be removed in future versions.
 1061     */
 1062 #if PNG_LIBPNG_VER < 10700
 1063 /* To do: remove this from libpng17 (and from libpng17/png.c and pngstruct.h) */
 1064 PNG_EXPORTA(23, png_const_charp, png_convert_to_rfc1123, (png_structrp png_ptr,
 1065     png_const_timep ptime),PNG_DEPRECATED);
 1066 #endif
 1067 PNG_EXPORT(241, int, png_convert_to_rfc1123_buffer, (char out[29],
 1068     png_const_timep ptime));
 1069 #endif
 1070 
 1071 #ifdef PNG_CONVERT_tIME_SUPPORTED
 1072 /* Convert from a struct tm to png_time */
 1073 PNG_EXPORT(24, void, png_convert_from_struct_tm, (png_timep ptime,
 1074     const struct tm * ttime));
 1075 
 1076 /* Convert from time_t to png_time.  Uses gmtime() */
 1077 PNG_EXPORT(25, void, png_convert_from_time_t, (png_timep ptime, time_t ttime));
 1078 #endif /* CONVERT_tIME */
 1079 
 1080 #ifdef PNG_READ_EXPAND_SUPPORTED
 1081 /* Expand data to 24-bit RGB, or 8-bit grayscale, with alpha if available. */
 1082 PNG_EXPORT(26, void, png_set_expand, (png_structrp png_ptr));
 1083 PNG_EXPORT(27, void, png_set_expand_gray_1_2_4_to_8, (png_structrp png_ptr));
 1084 PNG_EXPORT(28, void, png_set_palette_to_rgb, (png_structrp png_ptr));
 1085 PNG_EXPORT(29, void, png_set_tRNS_to_alpha, (png_structrp png_ptr));
 1086 #endif
 1087 
 1088 #ifdef PNG_READ_EXPAND_16_SUPPORTED
 1089 /* Expand to 16-bit channels, forces conversion of palette to RGB and expansion
 1090  * of a tRNS chunk if present.
 1091  */
 1092 PNG_EXPORT(221, void, png_set_expand_16, (png_structrp png_ptr));
 1093 #endif
 1094 
 1095 #if defined(PNG_READ_BGR_SUPPORTED) || defined(PNG_WRITE_BGR_SUPPORTED)
 1096 /* Use blue, green, red order for pixels. */
 1097 PNG_EXPORT(30, void, png_set_bgr, (png_structrp png_ptr));
 1098 #endif
 1099 
 1100 #ifdef PNG_READ_GRAY_TO_RGB_SUPPORTED
 1101 /* Expand the grayscale to 24-bit RGB if necessary. */
 1102 PNG_EXPORT(31, void, png_set_gray_to_rgb, (png_structrp png_ptr));
 1103 #endif
 1104 
 1105 #ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED
 1106 /* Reduce RGB to grayscale. */
 1107 #define PNG_ERROR_ACTION_NONE  1
 1108 #define PNG_ERROR_ACTION_WARN  2
 1109 #define PNG_ERROR_ACTION_ERROR 3
 1110 #define PNG_RGB_TO_GRAY_DEFAULT (-1)/*for red/green coefficients*/
 1111 
 1112 PNG_FP_EXPORT(32, void, png_set_rgb_to_gray, (png_structrp png_ptr,
 1113     int error_action, double red, double green))
 1114 PNG_FIXED_EXPORT(33, void, png_set_rgb_to_gray_fixed, (png_structrp png_ptr,
 1115     int error_action, png_fixed_point red, png_fixed_point green))
 1116 
 1117 PNG_EXPORT(34, png_byte, png_get_rgb_to_gray_status, (png_const_structrp
 1118     png_ptr));
 1119 #endif
 1120 
 1121 #ifdef PNG_BUILD_GRAYSCALE_PALETTE_SUPPORTED
 1122 PNG_EXPORT(35, void, png_build_grayscale_palette, (int bit_depth,
 1123     png_colorp palette));
 1124 #endif
 1125 
 1126 #ifdef PNG_READ_ALPHA_MODE_SUPPORTED
 1127 /* How the alpha channel is interpreted - this affects how the color channels
 1128  * of a PNG file are returned to the calling application when an alpha channel,
 1129  * or a tRNS chunk in a palette file, is present.
 1130  *
 1131  * This has no effect on the way pixels are written into a PNG output
 1132  * datastream. The color samples in a PNG datastream are never premultiplied
 1133  * with the alpha samples.
 1134  *
 1135  * The default is to return data according to the PNG specification: the alpha
 1136  * channel is a linear measure of the contribution of the pixel to the
 1137  * corresponding composited pixel, and the color channels are unassociated
 1138  * (not premultiplied).  The gamma encoded color channels must be scaled
 1139  * according to the contribution and to do this it is necessary to undo
 1140  * the encoding, scale the color values, perform the composition and reencode
 1141  * the values.  This is the 'PNG' mode.
 1142  *
 1143  * The alternative is to 'associate' the alpha with the color information by
 1144  * storing color channel values that have been scaled by the alpha.
 1145  * image.  These are the 'STANDARD', 'ASSOCIATED' or 'PREMULTIPLIED' modes
 1146  * (the latter being the two common names for associated alpha color channels).
 1147  *
 1148  * For the 'OPTIMIZED' mode, a pixel is treated as opaque only if the alpha
 1149  * value is equal to the maximum value.
 1150  *
 1151  * The final choice is to gamma encode the alpha channel as well.  This is
 1152  * broken because, in practice, no implementation that uses this choice
 1153  * correctly undoes the encoding before handling alpha composition.  Use this
 1154  * choice only if other serious errors in the software or hardware you use
 1155  * mandate it; the typical serious error is for dark halos to appear around
 1156  * opaque areas of the composited PNG image because of arithmetic overflow.
 1157  *
 1158  * The API function png_set_alpha_mode specifies which of these choices to use
 1159  * with an enumerated 'mode' value and the gamma of the required output:
 1160  */
 1161 #define PNG_ALPHA_PNG           0 /* according to the PNG standard */
 1162 #define PNG_ALPHA_STANDARD      1 /* according to Porter/Duff */
 1163 #define PNG_ALPHA_ASSOCIATED    1 /* as above; this is the normal practice */
 1164 #define PNG_ALPHA_PREMULTIPLIED 1 /* as above */
 1165 #define PNG_ALPHA_OPTIMIZED     2 /* 'PNG' for opaque pixels, else 'STANDARD' */
 1166 #define PNG_ALPHA_BROKEN        3 /* the alpha channel is gamma encoded */
 1167 
 1168 PNG_FP_EXPORT(227, void, png_set_alpha_mode, (png_structrp png_ptr, int mode,
 1169     double output_gamma))
 1170 PNG_FIXED_EXPORT(228, void, png_set_alpha_mode_fixed, (png_structrp png_ptr,
 1171     int mode, png_fixed_point output_gamma))
 1172 #endif
 1173 
 1174 #if defined(PNG_GAMMA_SUPPORTED) || defined(PNG_READ_ALPHA_MODE_SUPPORTED)
 1175 /* The output_gamma value is a screen gamma in libpng terminology: it expresses
 1176  * how to decode the output values, not how they are encoded.
 1177  */
 1178 #define PNG_DEFAULT_sRGB -1       /* sRGB gamma and color space */
 1179 #define PNG_GAMMA_MAC_18 -2       /* Old Mac '1.8' gamma and color space */
 1180 #define PNG_GAMMA_sRGB   220000   /* Television standards--matches sRGB gamma */
 1181 #define PNG_GAMMA_LINEAR PNG_FP_1 /* Linear */
 1182 #endif
 1183 
 1184 /* The following are examples of calls to png_set_alpha_mode to achieve the
 1185  * required overall gamma correction and, where necessary, alpha
 1186  * premultiplication.
 1187  *
 1188  * png_set_alpha_mode(pp, PNG_ALPHA_PNG, PNG_DEFAULT_sRGB);
 1189  *    This is the default libpng handling of the alpha channel - it is not
 1190  *    pre-multiplied into the color components.  In addition the call states
 1191  *    that the output is for a sRGB system and causes all PNG files without gAMA
 1192  *    chunks to be assumed to be encoded using sRGB.
 1193  *
 1194  * png_set_alpha_mode(pp, PNG_ALPHA_PNG, PNG_GAMMA_MAC);
 1195  *    In this case the output is assumed to be something like an sRGB conformant
 1196  *    display preceeded by a power-law lookup table of power 1.45.  This is how
 1197  *    early Mac systems behaved.
 1198  *
 1199  * png_set_alpha_mode(pp, PNG_ALPHA_STANDARD, PNG_GAMMA_LINEAR);
 1200  *    This is the classic Jim Blinn approach and will work in academic
 1201  *    environments where everything is done by the book.  It has the shortcoming
 1202  *    of assuming that input PNG data with no gamma information is linear - this
 1203  *    is unlikely to be correct unless the PNG files where generated locally.
 1204  *    Most of the time the output precision will be so low as to show
 1205  *    significant banding in dark areas of the image.
 1206  *
 1207  * png_set_expand_16(pp);
 1208  * png_set_alpha_mode(pp, PNG_ALPHA_STANDARD, PNG_DEFAULT_sRGB);
 1209  *    This is a somewhat more realistic Jim Blinn inspired approach.  PNG files
 1210  *    are assumed to have the sRGB encoding if not marked with a gamma value and
 1211  *    the output is always 16 bits per component.  This permits accurate scaling
 1212  *    and processing of the data.  If you know that your input PNG files were
 1213  *    generated locally you might need to replace PNG_DEFAULT_sRGB with the
 1214  *    correct value for your system.
 1215  *
 1216  * png_set_alpha_mode(pp, PNG_ALPHA_OPTIMIZED, PNG_DEFAULT_sRGB);
 1217  *    If you just need to composite the PNG image onto an existing background
 1218  *    and if you control the code that does this you can use the optimization
 1219  *    setting.  In this case you just copy completely opaque pixels to the
 1220  *    output.  For pixels that are not completely transparent (you just skip
 1221  *    those) you do the composition math using png_composite or png_composite_16
 1222  *    below then encode the resultant 8-bit or 16-bit values to match the output
 1223  *    encoding.
 1224  *
 1225  * Other cases
 1226  *    If neither the PNG nor the standard linear encoding work for you because
 1227  *    of the software or hardware you use then you have a big problem.  The PNG
 1228  *    case will probably result in halos around the image.  The linear encoding
 1229  *    will probably result in a washed out, too bright, image (it's actually too
 1230  *    contrasty.)  Try the ALPHA_OPTIMIZED mode above - this will probably
 1231  *    substantially reduce the halos.  Alternatively try:
 1232  *
 1233  * png_set_alpha_mode(pp, PNG_ALPHA_BROKEN, PNG_DEFAULT_sRGB);
 1234  *    This option will also reduce the halos, but there will be slight dark
 1235  *    halos round the opaque parts of the image where the background is light.
 1236  *    In the OPTIMIZED mode the halos will be light halos where the background
 1237  *    is dark.  Take your pick - the halos are unavoidable unless you can get
 1238  *    your hardware/software fixed!  (The OPTIMIZED approach is slightly
 1239  *    faster.)
 1240  *
 1241  * When the default gamma of PNG files doesn't match the output gamma.
 1242  *    If you have PNG files with no gamma information png_set_alpha_mode allows
 1243  *    you to provide a default gamma, but it also sets the ouput gamma to the
 1244  *    matching value.  If you know your PNG files have a gamma that doesn't
 1245  *    match the output you can take advantage of the fact that
 1246  *    png_set_alpha_mode always sets the output gamma but only sets the PNG
 1247  *    default if it is not already set:
 1248  *
 1249  * png_set_alpha_mode(pp, PNG_ALPHA_PNG, PNG_DEFAULT_sRGB);
 1250  * png_set_alpha_mode(pp, PNG_ALPHA_PNG, PNG_GAMMA_MAC);
 1251  *    The first call sets both the default and the output gamma values, the
 1252  *    second call overrides the output gamma without changing the default.  This
 1253  *    is easier than achieving the same effect with png_set_gamma.  You must use
 1254  *    PNG_ALPHA_PNG for the first call - internal checking in png_set_alpha will
 1255  *    fire if more than one call to png_set_alpha_mode and png_set_background is
 1256  *    made in the same read operation, however multiple calls with PNG_ALPHA_PNG
 1257  *    are ignored.
 1258  */
 1259 
 1260 #ifdef PNG_READ_STRIP_ALPHA_SUPPORTED
 1261 PNG_EXPORT(36, void, png_set_strip_alpha, (png_structrp png_ptr));
 1262 #endif
 1263 
 1264 #if defined(PNG_READ_SWAP_ALPHA_SUPPORTED) || \
 1265     defined(PNG_WRITE_SWAP_ALPHA_SUPPORTED)
 1266 PNG_EXPORT(37, void, png_set_swap_alpha, (png_structrp png_ptr));
 1267 #endif
 1268 
 1269 #if defined(PNG_READ_INVERT_ALPHA_SUPPORTED) || \
 1270     defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED)
 1271 PNG_EXPORT(38, void, png_set_invert_alpha, (png_structrp png_ptr));
 1272 #endif
 1273 
 1274 #if defined(PNG_READ_FILLER_SUPPORTED) || defined(PNG_WRITE_FILLER_SUPPORTED)
 1275 /* Add a filler byte to 8-bit or 16-bit Gray or 24-bit or 48-bit RGB images. */
 1276 PNG_EXPORT(39, void, png_set_filler, (png_structrp png_ptr, png_uint_32 filler,
 1277     int flags));
 1278 /* The values of the PNG_FILLER_ defines should NOT be changed */
 1279 #  define PNG_FILLER_BEFORE 0
 1280 #  define PNG_FILLER_AFTER 1
 1281 /* Add an alpha byte to 8-bit or 16-bit Gray or 24-bit or 48-bit RGB images. */
 1282 PNG_EXPORT(40, void, png_set_add_alpha, (png_structrp png_ptr,
 1283     png_uint_32 filler, int flags));
 1284 #endif /* READ_FILLER || WRITE_FILLER */
 1285 
 1286 #if defined(PNG_READ_SWAP_SUPPORTED) || defined(PNG_WRITE_SWAP_SUPPORTED)
 1287 /* Swap bytes in 16-bit depth files. */
 1288 PNG_EXPORT(41, void, png_set_swap, (png_structrp png_ptr));
 1289 #endif
 1290 
 1291 #if defined(PNG_READ_PACK_SUPPORTED) || defined(PNG_WRITE_PACK_SUPPORTED)
 1292 /* Use 1 byte per pixel in 1, 2, or 4-bit depth files. */
 1293 PNG_EXPORT(42, void, png_set_packing, (png_structrp png_ptr));
 1294 #endif
 1295 
 1296 #if defined(PNG_READ_PACKSWAP_SUPPORTED) || \
 1297     defined(PNG_WRITE_PACKSWAP_SUPPORTED)
 1298 /* Swap packing order of pixels in bytes. */
 1299 PNG_EXPORT(43, void, png_set_packswap, (png_structrp png_ptr));
 1300 #endif
 1301 
 1302 #if defined(PNG_READ_SHIFT_SUPPORTED) || defined(PNG_WRITE_SHIFT_SUPPORTED)
 1303 /* Converts files to legal bit depths. */
 1304 PNG_EXPORT(44, void, png_set_shift, (png_structrp png_ptr, png_const_color_8p
 1305     true_bits));
 1306 #endif
 1307 
 1308 #if defined(PNG_READ_INTERLACING_SUPPORTED) || \
 1309     defined(PNG_WRITE_INTERLACING_SUPPORTED)
 1310 /* Have the code handle the interlacing.  Returns the number of passes.
 1311  * MUST be called before png_read_update_info or png_start_read_image,
 1312  * otherwise it will not have the desired effect.  Note that it is still
 1313  * necessary to call png_read_row or png_read_rows png_get_image_height
 1314  * times for each pass.
 1315 */
 1316 PNG_EXPORT(45, int, png_set_interlace_handling, (png_structrp png_ptr));
 1317 #endif
 1318 
 1319 #if defined(PNG_READ_INVERT_SUPPORTED) || defined(PNG_WRITE_INVERT_SUPPORTED)
 1320 /* Invert monochrome files */
 1321 PNG_EXPORT(46, void, png_set_invert_mono, (png_structrp png_ptr));
 1322 #endif
 1323 
 1324 #ifdef PNG_READ_BACKGROUND_SUPPORTED
 1325 /* Handle alpha and tRNS by replacing with a background color.  Prior to
 1326  * libpng-1.5.4 this API must not be called before the PNG file header has been
 1327  * read.  Doing so will result in unexpected behavior and possible warnings or
 1328  * errors if the PNG file contains a bKGD chunk.
 1329  */
 1330 PNG_FP_EXPORT(47, void, png_set_background, (png_structrp png_ptr,
 1331     png_const_color_16p background_color, int background_gamma_code,
 1332     int need_expand, double background_gamma))
 1333 PNG_FIXED_EXPORT(215, void, png_set_background_fixed, (png_structrp png_ptr,
 1334     png_const_color_16p background_color, int background_gamma_code,
 1335     int need_expand, png_fixed_point background_gamma))
 1336 #endif
 1337 #ifdef PNG_READ_BACKGROUND_SUPPORTED
 1338 #  define PNG_BACKGROUND_GAMMA_UNKNOWN 0
 1339 #  define PNG_BACKGROUND_GAMMA_SCREEN  1
 1340 #  define PNG_BACKGROUND_GAMMA_FILE    2
 1341 #  define PNG_BACKGROUND_GAMMA_UNIQUE  3
 1342 #endif
 1343 
 1344 #ifdef PNG_READ_SCALE_16_TO_8_SUPPORTED
 1345 /* Scale a 16-bit depth file down to 8-bit, accurately. */
 1346 PNG_EXPORT(229, void, png_set_scale_16, (png_structrp png_ptr));
 1347 #endif
 1348 
 1349 #ifdef PNG_READ_STRIP_16_TO_8_SUPPORTED
 1350 #define PNG_READ_16_TO_8_SUPPORTED /* Name prior to 1.5.4 */
 1351 /* Strip the second byte of information from a 16-bit depth file. */
 1352 PNG_EXPORT(48, void, png_set_strip_16, (png_structrp png_ptr));
 1353 #endif
 1354 
 1355 #ifdef PNG_READ_QUANTIZE_SUPPORTED
 1356 /* Turn on quantizing, and reduce the palette to the number of colors
 1357  * available.
 1358  */
 1359 PNG_EXPORT(49, void, png_set_quantize, (png_structrp png_ptr,
 1360     png_colorp palette, int num_palette, int maximum_colors,
 1361     png_const_uint_16p histogram, int full_quantize));
 1362 #endif
 1363 
 1364 #ifdef PNG_READ_GAMMA_SUPPORTED
 1365 /* The threshold on gamma processing is configurable but hard-wired into the
 1366  * library.  The following is the floating point variant.
 1367  */
 1368 #define PNG_GAMMA_THRESHOLD (PNG_GAMMA_THRESHOLD_FIXED*.00001)
 1369 
 1370 /* Handle gamma correction. Screen_gamma=(display_exponent).
 1371  * NOTE: this API simply sets the screen and file gamma values. It will
 1372  * therefore override the value for gamma in a PNG file if it is called after
 1373  * the file header has been read - use with care  - call before reading the PNG
 1374  * file for best results!
 1375  *
 1376  * These routines accept the same gamma values as png_set_alpha_mode (described
 1377  * above).  The PNG_GAMMA_ defines and PNG_DEFAULT_sRGB can be passed to either
 1378  * API (floating point or fixed.)  Notice, however, that the 'file_gamma' value
 1379  * is the inverse of a 'screen gamma' value.
 1380  */
 1381 PNG_FP_EXPORT(50, void, png_set_gamma, (png_structrp png_ptr,
 1382     double screen_gamma, double override_file_gamma))
 1383 PNG_FIXED_EXPORT(208, void, png_set_gamma_fixed, (png_structrp png_ptr,
 1384     png_fixed_point screen_gamma, png_fixed_point override_file_gamma))
 1385 #endif
 1386 
 1387 #ifdef PNG_WRITE_FLUSH_SUPPORTED
 1388 /* Set how many lines between output flushes - 0 for no flushing */
 1389 PNG_EXPORT(51, void, png_set_flush, (png_structrp png_ptr, int nrows));
 1390 /* Flush the current PNG output buffer */
 1391 PNG_EXPORT(52, void, png_write_flush, (png_structrp png_ptr));
 1392 #endif
 1393 
 1394 /* Optional update palette with requested transformations */
 1395 PNG_EXPORT(53, void, png_start_read_image, (png_structrp png_ptr));
 1396 
 1397 /* Optional call to update the users info structure */
 1398 PNG_EXPORT(54, void, png_read_update_info, (png_structrp png_ptr,
 1399     png_inforp info_ptr));
 1400 
 1401 #ifdef PNG_SEQUENTIAL_READ_SUPPORTED
 1402 /* Read one or more rows of image data. */
 1403 PNG_EXPORT(55, void, png_read_rows, (png_structrp png_ptr, png_bytepp row,
 1404     png_bytepp display_row, png_uint_32 num_rows));
 1405 #endif
 1406 
 1407 #ifdef PNG_SEQUENTIAL_READ_SUPPORTED
 1408 /* Read a row of data. */
 1409 PNG_EXPORT(56, void, png_read_row, (png_structrp png_ptr, png_bytep row,
 1410     png_bytep display_row));
 1411 #endif
 1412 
 1413 #ifdef PNG_SEQUENTIAL_READ_SUPPORTED
 1414 /* Read the whole image into memory at once. */
 1415 PNG_EXPORT(57, void, png_read_image, (png_structrp png_ptr, png_bytepp image));
 1416 #endif
 1417 
 1418 /* Write a row of image data */
 1419 PNG_EXPORT(58, void, png_write_row, (png_structrp png_ptr,
 1420     png_const_bytep row));
 1421 
 1422 /* Write a few rows of image data: (*row) is not written; however, the type
 1423  * is declared as writeable to maintain compatibility with previous versions
 1424  * of libpng and to allow the 'display_row' array from read_rows to be passed
 1425  * unchanged to write_rows.
 1426  */
 1427 PNG_EXPORT(59, void, png_write_rows, (png_structrp png_ptr, png_bytepp row,
 1428     png_uint_32 num_rows));
 1429 
 1430 /* Write the image data */
 1431 PNG_EXPORT(60, void, png_write_image, (png_structrp png_ptr, png_bytepp image));
 1432 
 1433 /* Write the end of the PNG file. */
 1434 PNG_EXPORT(61, void, png_write_end, (png_structrp png_ptr,
 1435     png_inforp info_ptr));
 1436 
 1437 #ifdef PNG_SEQUENTIAL_READ_SUPPORTED
 1438 /* Read the end of the PNG file. */
 1439 PNG_EXPORT(62, void, png_read_end, (png_structrp png_ptr, png_inforp info_ptr));
 1440 #endif
 1441 
 1442 /* Free any memory associated with the png_info_struct */
 1443 PNG_EXPORT(63, void, png_destroy_info_struct, (png_const_structrp png_ptr,
 1444     png_infopp info_ptr_ptr));
 1445 
 1446 /* Free any memory associated with the png_struct and the png_info_structs */
 1447 PNG_EXPORT(64, void, png_destroy_read_struct, (png_structpp png_ptr_ptr,
 1448     png_infopp info_ptr_ptr, png_infopp end_info_ptr_ptr));
 1449 
 1450 /* Free any memory associated with the png_struct and the png_info_structs */
 1451 PNG_EXPORT(65, void, png_destroy_write_struct, (png_structpp png_ptr_ptr,
 1452     png_infopp info_ptr_ptr));
 1453 
 1454 /* Set the libpng method of handling chunk CRC errors */
 1455 PNG_EXPORT(66, void, png_set_crc_action, (png_structrp png_ptr, int crit_action,
 1456     int ancil_action));
 1457 
 1458 /* Values for png_set_crc_action() say how to handle CRC errors in
 1459  * ancillary and critical chunks, and whether to use the data contained
 1460  * therein.  Note that it is impossible to "discard" data in a critical
 1461  * chunk.  For versions prior to 0.90, the action was always error/quit,
 1462  * whereas in version 0.90 and later, the action for CRC errors in ancillary
 1463  * chunks is warn/discard.  These values should NOT be changed.
 1464  *
 1465  *      value                       action:critical     action:ancillary
 1466  */
 1467 #define PNG_CRC_DEFAULT       0  /* error/quit          warn/discard data */
 1468 #define PNG_CRC_ERROR_QUIT    1  /* error/quit          error/quit        */
 1469 #define PNG_CRC_WARN_DISCARD  2  /* (INVALID)           warn/discard data */
 1470 #define PNG_CRC_WARN_USE      3  /* warn/use data       warn/use data     */
 1471 #define PNG_CRC_QUIET_USE     4  /* quiet/use data      quiet/use data    */
 1472 #define PNG_CRC_NO_CHANGE     5  /* use current value   use current value */
 1473 
 1474 #ifdef PNG_WRITE_SUPPORTED
 1475 /* These functions give the user control over the scan-line filtering in
 1476  * libpng and the compression methods used by zlib.  These functions are
 1477  * mainly useful for testing, as the defaults should work with most users.
 1478  * Those users who are tight on memory or want faster performance at the
 1479  * expense of compression can modify them.  See the compression library
 1480  * header file (zlib.h) for an explination of the compression functions.
 1481  */
 1482 
 1483 /* Set the filtering method(s) used by libpng.  Currently, the only valid
 1484  * value for "method" is 0.
 1485  */
 1486 PNG_EXPORT(67, void, png_set_filter, (png_structrp png_ptr, int method,
 1487     int filters));
 1488 #endif /* WRITE */
 1489 
 1490 /* Flags for png_set_filter() to say which filters to use.  The flags
 1491  * are chosen so that they don't conflict with real filter types
 1492  * below, in case they are supplied instead of the #defined constants.
 1493  * These values should NOT be changed.
 1494  */
 1495 #define PNG_NO_FILTERS     0x00
 1496 #define PNG_FILTER_NONE    0x08
 1497 #define PNG_FILTER_SUB     0x10
 1498 #define PNG_FILTER_UP      0x20
 1499 #define PNG_FILTER_AVG     0x40
 1500 #define PNG_FILTER_PAETH   0x80
 1501 #define PNG_FAST_FILTERS (PNG_FILTER_NONE | PNG_FILTER_SUB | PNG_FILTER_UP)
 1502 #define PNG_ALL_FILTERS (PNG_FAST_FILTERS | PNG_FILTER_AVG | PNG_FILTER_PAETH)
 1503 
 1504 /* Filter values (not flags) - used in pngwrite.c, pngwutil.c for now.
 1505  * These defines should NOT be changed.
 1506  */
 1507 #define PNG_FILTER_VALUE_NONE  0
 1508 #define PNG_FILTER_VALUE_SUB   1
 1509 #define PNG_FILTER_VALUE_UP    2
 1510 #define PNG_FILTER_VALUE_AVG   3
 1511 #define PNG_FILTER_VALUE_PAETH 4
 1512 #define PNG_FILTER_VALUE_LAST  5
 1513 
 1514 #ifdef PNG_WRITE_SUPPORTED
 1515 #ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED /* DEPRECATED */
 1516 PNG_FP_EXPORT(68, void, png_set_filter_heuristics, (png_structrp png_ptr,
 1517     int heuristic_method, int num_weights, png_const_doublep filter_weights,
 1518     png_const_doublep filter_costs))
 1519 PNG_FIXED_EXPORT(209, void, png_set_filter_heuristics_fixed,
 1520     (png_structrp png_ptr, int heuristic_method, int num_weights,
 1521     png_const_fixed_point_p filter_weights,
 1522     png_const_fixed_point_p filter_costs))
 1523 #endif /* WRITE_WEIGHTED_FILTER */
 1524 
 1525 /* The following are no longer used and will be removed from libpng-1.7: */
 1526 #define PNG_FILTER_HEURISTIC_DEFAULT    0  /* Currently "UNWEIGHTED" */
 1527 #define PNG_FILTER_HEURISTIC_UNWEIGHTED 1  /* Used by libpng < 0.95 */
 1528 #define PNG_FILTER_HEURISTIC_WEIGHTED   2  /* Experimental feature */
 1529 #define PNG_FILTER_HEURISTIC_LAST       3  /* Not a valid value */
 1530 
 1531 /* Set the library compression level.  Currently, valid values range from
 1532  * 0 - 9, corresponding directly to the zlib compression levels 0 - 9
 1533  * (0 - no compression, 9 - "maximal" compression).  Note that tests have
 1534  * shown that zlib compression levels 3-6 usually perform as well as level 9
 1535  * for PNG images, and do considerably fewer caclulations.  In the future,
 1536  * these values may not correspond directly to the zlib compression levels.
 1537  */
 1538 #ifdef PNG_WRITE_CUSTOMIZE_COMPRESSION_SUPPORTED
 1539 PNG_EXPORT(69, void, png_set_compression_level, (png_structrp png_ptr,
 1540     int level));
 1541 
 1542 PNG_EXPORT(70, void, png_set_compression_mem_level, (png_structrp png_ptr,
 1543     int mem_level));
 1544 
 1545 PNG_EXPORT(71, void, png_set_compression_strategy, (png_structrp png_ptr,
 1546     int strategy));
 1547 
 1548 /* If PNG_WRITE_OPTIMIZE_CMF_SUPPORTED is defined, libpng will use a
 1549  * smaller value of window_bits if it can do so safely.
 1550  */
 1551 PNG_EXPORT(72, void, png_set_compression_window_bits, (png_structrp png_ptr,
 1552     int window_bits));
 1553 
 1554 PNG_EXPORT(73, void, png_set_compression_method, (png_structrp png_ptr,
 1555     int method));
 1556 #endif /* WRITE_CUSTOMIZE_COMPRESSION */
 1557 
 1558 #ifdef PNG_WRITE_CUSTOMIZE_ZTXT_COMPRESSION_SUPPORTED
 1559 /* Also set zlib parameters for compressing non-IDAT chunks */
 1560 PNG_EXPORT(222, void, png_set_text_compression_level, (png_structrp png_ptr,
 1561     int level));
 1562 
 1563 PNG_EXPORT(223, void, png_set_text_compression_mem_level, (png_structrp png_ptr,
 1564     int mem_level));
 1565 
 1566 PNG_EXPORT(224, void, png_set_text_compression_strategy, (png_structrp png_ptr,
 1567     int strategy));
 1568 
 1569 /* If PNG_WRITE_OPTIMIZE_CMF_SUPPORTED is defined, libpng will use a
 1570  * smaller value of window_bits if it can do so safely.
 1571  */
 1572 PNG_EXPORT(225, void, png_set_text_compression_window_bits,
 1573     (png_structrp png_ptr, int window_bits));
 1574 
 1575 PNG_EXPORT(226, void, png_set_text_compression_method, (png_structrp png_ptr,
 1576     int method));
 1577 #endif /* WRITE_CUSTOMIZE_ZTXT_COMPRESSION */
 1578 #endif /* WRITE */
 1579 
 1580 /* These next functions are called for input/output, memory, and error
 1581  * handling.  They are in the file pngrio.c, pngwio.c, and pngerror.c,
 1582  * and call standard C I/O routines such as fread(), fwrite(), and
 1583  * fprintf().  These functions can be made to use other I/O routines
 1584  * at run time for those applications that need to handle I/O in a
 1585  * different manner by calling png_set_???_fn().  See libpng-manual.txt for
 1586  * more information.
 1587  */
 1588 
 1589 #ifdef PNG_STDIO_SUPPORTED
 1590 /* Initialize the input/output for the PNG file to the default functions. */
 1591 PNG_EXPORT(74, void, png_init_io, (png_structrp png_ptr, png_FILE_p fp));
 1592 #endif
 1593 
 1594 /* Replace the (error and abort), and warning functions with user
 1595  * supplied functions.  If no messages are to be printed you must still
 1596  * write and use replacement functions. The replacement error_fn should
 1597  * still do a longjmp to the last setjmp location if you are using this
 1598  * method of error handling.  If error_fn or warning_fn is NULL, the
 1599  * default function will be used.
 1600  */
 1601 
 1602 PNG_EXPORT(75, void, png_set_error_fn, (png_structrp png_ptr,
 1603     png_voidp error_ptr, png_error_ptr error_fn, png_error_ptr warning_fn));
 1604 
 1605 /* Return the user pointer associated with the error functions */
 1606 PNG_EXPORT(76, png_voidp, png_get_error_ptr, (png_const_structrp png_ptr));
 1607 
 1608 /* Replace the default data output functions with a user supplied one(s).
 1609  * If buffered output is not used, then output_flush_fn can be set to NULL.
 1610  * If PNG_WRITE_FLUSH_SUPPORTED is not defined at libpng compile time
 1611  * output_flush_fn will be ignored (and thus can be NULL).
 1612  * It is probably a mistake to use NULL for output_flush_fn if
 1613  * write_data_fn is not also NULL unless you have built libpng with
 1614  * PNG_WRITE_FLUSH_SUPPORTED undefined, because in this case libpng's
 1615  * default flush function, which uses the standard *FILE structure, will
 1616  * be used.
 1617  */
 1618 PNG_EXPORT(77, void, png_set_write_fn, (png_structrp png_ptr, png_voidp io_ptr,
 1619     png_rw_ptr write_data_fn, png_flush_ptr output_flush_fn));
 1620 
 1621 /* Replace the default data input function with a user supplied one. */
 1622 PNG_EXPORT(78, void, png_set_read_fn, (png_structrp png_ptr, png_voidp io_ptr,
 1623     png_rw_ptr read_data_fn));
 1624 
 1625 /* Return the user pointer associated with the I/O functions */
 1626 PNG_EXPORT(79, png_voidp, png_get_io_ptr, (png_const_structrp png_ptr));
 1627 
 1628 PNG_EXPORT(80, void, png_set_read_status_fn, (png_structrp png_ptr,
 1629     png_read_status_ptr read_row_fn));
 1630 
 1631 PNG_EXPORT(81, void, png_set_write_status_fn, (png_structrp png_ptr,
 1632     png_write_status_ptr write_row_fn));
 1633 
 1634 #ifdef PNG_USER_MEM_SUPPORTED
 1635 /* Replace the default memory allocation functions with user supplied one(s). */
 1636 PNG_EXPORT(82, void, png_set_mem_fn, (png_structrp png_ptr, png_voidp mem_ptr,
 1637     png_malloc_ptr malloc_fn, png_free_ptr free_fn));
 1638 /* Return the user pointer associated with the memory functions */
 1639 PNG_EXPORT(83, png_voidp, png_get_mem_ptr, (png_const_structrp png_ptr));
 1640 #endif
 1641 
 1642 #ifdef PNG_READ_USER_TRANSFORM_SUPPORTED
 1643 PNG_EXPORT(84, void, png_set_read_user_transform_fn, (png_structrp png_ptr,
 1644     png_user_transform_ptr read_user_transform_fn));
 1645 #endif
 1646 
 1647 #ifdef PNG_WRITE_USER_TRANSFORM_SUPPORTED
 1648 PNG_EXPORT(85, void, png_set_write_user_transform_fn, (png_structrp png_ptr,
 1649     png_user_transform_ptr write_user_transform_fn));
 1650 #endif
 1651 
 1652 #ifdef PNG_USER_TRANSFORM_PTR_SUPPORTED
 1653 PNG_EXPORT(86, void, png_set_user_transform_info, (png_structrp png_ptr,
 1654     png_voidp user_transform_ptr, int user_transform_depth,
 1655     int user_transform_channels));
 1656 /* Return the user pointer associated with the user transform functions */
 1657 PNG_EXPORT(87, png_voidp, png_get_user_transform_ptr,
 1658     (png_const_structrp png_ptr));
 1659 #endif
 1660 
 1661 #ifdef PNG_USER_TRANSFORM_INFO_SUPPORTED
 1662 /* Return information about the row currently being processed.  Note that these
 1663  * APIs do not fail but will return unexpected results if called outside a user
 1664  * transform callback.  Also note that when transforming an interlaced image the
 1665  * row number is the row number within the sub-image of the interlace pass, so
 1666  * the value will increase to the height of the sub-image (not the full image)
 1667  * then reset to 0 for the next pass.
 1668  *
 1669  * Use PNG_ROW_FROM_PASS_ROW(row, pass) and PNG_COL_FROM_PASS_COL(col, pass) to
 1670  * find the output pixel (x,y) given an interlaced sub-image pixel
 1671  * (row,col,pass).  (See below for these macros.)
 1672  */
 1673 PNG_EXPORT(217, png_uint_32, png_get_current_row_number, (png_const_structrp));
 1674 PNG_EXPORT(218, png_byte, png_get_current_pass_number, (png_const_structrp));
 1675 #endif
 1676 
 1677 #ifdef PNG_READ_USER_CHUNKS_SUPPORTED
 1678 /* This callback is called only for *unknown* chunks.  If
 1679  * PNG_HANDLE_AS_UNKNOWN_SUPPORTED is set then it is possible to set known
 1680  * chunks to be treated as unknown, however in this case the callback must do
 1681  * any processing required by the chunk (e.g. by calling the appropriate
 1682  * png_set_ APIs.)
 1683  *
 1684  * There is no write support - on write, by default, all the chunks in the
 1685  * 'unknown' list are written in the specified position.
 1686  *
 1687  * The integer return from the callback function is interpreted thus:
 1688  *
 1689  * negative: An error occurred; png_chunk_error will be called.
 1690  *     zero: The chunk was not handled, the chunk will be saved. A critical
 1691  *           chunk will cause an error at this point unless it is to be saved.
 1692  * positive: The chunk was handled, libpng will ignore/discard it.
 1693  *
 1694  * See "INTERACTION WTIH USER CHUNK CALLBACKS" below for important notes about
 1695  * how this behavior will change in libpng 1.7
 1696  */
 1697 PNG_EXPORT(88, void, png_set_read_user_chunk_fn, (png_structrp png_ptr,
 1698     png_voidp user_chunk_ptr, png_user_chunk_ptr read_user_chunk_fn));
 1699 #endif
 1700 
 1701 #ifdef PNG_USER_CHUNKS_SUPPORTED
 1702 PNG_EXPORT(89, png_voidp, png_get_user_chunk_ptr, (png_const_structrp png_ptr));
 1703 #endif
 1704 
 1705 #ifdef PNG_PROGRESSIVE_READ_SUPPORTED
 1706 /* Sets the function callbacks for the push reader, and a pointer to a
 1707  * user-defined structure available to the callback functions.
 1708  */
 1709 PNG_EXPORT(90, void, png_set_progressive_read_fn, (png_structrp png_ptr,
 1710     png_voidp progressive_ptr, png_progressive_info_ptr info_fn,
 1711     png_progressive_row_ptr row_fn, png_progressive_end_ptr end_fn));
 1712 
 1713 /* Returns the user pointer associated with the push read functions */
 1714 PNG_EXPORT(91, png_voidp, png_get_progressive_ptr,
 1715     (png_const_structrp png_ptr));
 1716 
 1717 /* Function to be called when data becomes available */
 1718 PNG_EXPORT(92, void, png_process_data, (png_structrp png_ptr,
 1719     png_inforp info_ptr, png_bytep buffer, png_size_t buffer_size));
 1720 
 1721 /* A function which may be called *only* within png_process_data to stop the
 1722  * processing of any more data.  The function returns the number of bytes
 1723  * remaining, excluding any that libpng has cached internally.  A subsequent
 1724  * call to png_process_data must supply these bytes again.  If the argument
 1725  * 'save' is set to true the routine will first save all the pending data and
 1726  * will always return 0.
 1727  */
 1728 PNG_EXPORT(219, png_size_t, png_process_data_pause, (png_structrp, int save));
 1729 
 1730 /* A function which may be called *only* outside (after) a call to
 1731  * png_process_data.  It returns the number of bytes of data to skip in the
 1732  * input.  Normally it will return 0, but if it returns a non-zero value the
 1733  * application must skip than number of bytes of input data and pass the
 1734  * following data to the next call to png_process_data.
 1735  */
 1736 PNG_EXPORT(220, png_uint_32, png_process_data_skip, (png_structrp));
 1737 
 1738 /* Function that combines rows.  'new_row' is a flag that should come from
 1739  * the callback and be non-NULL if anything needs to be done; the library
 1740  * stores its own version of the new data internally and ignores the passed
 1741  * in value.
 1742  */
 1743 PNG_EXPORT(93, void, png_progressive_combine_row, (png_const_structrp png_ptr,
 1744     png_bytep old_row, png_const_bytep new_row));
 1745 #endif /* PROGRESSIVE_READ */
 1746 
 1747 PNG_EXPORTA(94, png_voidp, png_malloc, (png_const_structrp png_ptr,
 1748     png_alloc_size_t size), PNG_ALLOCATED);
 1749 /* Added at libpng version 1.4.0 */
 1750 PNG_EXPORTA(95, png_voidp, png_calloc, (png_const_structrp png_ptr,
 1751     png_alloc_size_t size), PNG_ALLOCATED);
 1752 
 1753 /* Added at libpng version 1.2.4 */
 1754 PNG_EXPORTA(96, png_voidp, png_malloc_warn, (png_const_structrp png_ptr,
 1755     png_alloc_size_t size), PNG_ALLOCATED);
 1756 
 1757 /* Frees a pointer allocated by png_malloc() */
 1758 PNG_EXPORT(97, void, png_free, (png_const_structrp png_ptr, png_voidp ptr));
 1759 
 1760 /* Free data that was allocated internally */
 1761 PNG_EXPORT(98, void, png_free_data, (png_const_structrp png_ptr,
 1762     png_inforp info_ptr, png_uint_32 free_me, int num));
 1763 
 1764 /* Reassign responsibility for freeing existing data, whether allocated
 1765  * by libpng or by the application; this works on the png_info structure passed
 1766  * in, it does not change the state for other png_info structures.
 1767  *
 1768  * It is unlikely that this function works correctly as of 1.6.0 and using it
 1769  * may result either in memory leaks or double free of allocated data.
 1770  */
 1771 PNG_EXPORT(99, void, png_data_freer, (png_const_structrp png_ptr,
 1772     png_inforp info_ptr, int freer, png_uint_32 mask));
 1773 
 1774 /* Assignments for png_data_freer */
 1775 #define PNG_DESTROY_WILL_FREE_DATA 1
 1776 #define PNG_SET_WILL_FREE_DATA 1
 1777 #define PNG_USER_WILL_FREE_DATA 2
 1778 /* Flags for png_ptr->free_me and info_ptr->free_me */
 1779 #define PNG_FREE_HIST 0x0008U
 1780 #define PNG_FREE_ICCP 0x0010U
 1781 #define PNG_FREE_SPLT 0x0020U
 1782 #define PNG_FREE_ROWS 0x0040U
 1783 #define PNG_FREE_PCAL 0x0080U
 1784 #define PNG_FREE_SCAL 0x0100U
 1785 #ifdef PNG_STORE_UNKNOWN_CHUNKS_SUPPORTED
 1786 #  define PNG_FREE_UNKN 0x0200U
 1787 #endif
 1788 /*      PNG_FREE_LIST 0x0400U   removed in 1.6.0 because it is ignored */
 1789 #define PNG_FREE_PLTE 0x1000U
 1790 #define PNG_FREE_TRNS 0x2000U
 1791 #define PNG_FREE_TEXT 0x4000U
 1792 #define PNG_FREE_EXIF 0x8000U /* Added at libpng-1.6.31 */
 1793 #define PNG_FREE_ALL  0xffffU
 1794 #define PNG_FREE_MUL  0x4220U /* PNG_FREE_SPLT|PNG_FREE_TEXT|PNG_FREE_UNKN */
 1795 
 1796 #ifdef PNG_USER_MEM_SUPPORTED
 1797 PNG_EXPORTA(100, png_voidp, png_malloc_default, (png_const_structrp png_ptr,
 1798     png_alloc_size_t size), PNG_ALLOCATED PNG_DEPRECATED);
 1799 PNG_EXPORTA(101, void, png_free_default, (png_const_structrp png_ptr,
 1800     png_voidp ptr), PNG_DEPRECATED);
 1801 #endif
 1802 
 1803 #ifdef PNG_ERROR_TEXT_SUPPORTED
 1804 /* Fatal error in PNG image of libpng - can't continue */
 1805 PNG_EXPORTA(102, void, png_error, (png_const_structrp png_ptr,
 1806     png_const_charp error_message), PNG_NORETURN);
 1807 
 1808 /* The same, but the chunk name is prepended to the error string. */
 1809 PNG_EXPORTA(103, void, png_chunk_error, (png_const_structrp png_ptr,
 1810     png_const_charp error_message), PNG_NORETURN);
 1811 
 1812 #else
 1813 /* Fatal error in PNG image of libpng - can't continue */
 1814 PNG_EXPORTA(104, void, png_err, (png_const_structrp png_ptr), PNG_NORETURN);
 1815 #  define png_error(s1,s2) png_err(s1)
 1816 #  define png_chunk_error(s1,s2) png_err(s1)
 1817 #endif
 1818 
 1819 #ifdef PNG_WARNINGS_SUPPORTED
 1820 /* Non-fatal error in libpng.  Can continue, but may have a problem. */
 1821 PNG_EXPORT(105, void, png_warning, (png_const_structrp png_ptr,
 1822     png_const_charp warning_message));
 1823 
 1824 /* Non-fatal error in libpng, chunk name is prepended to message. */
 1825 PNG_EXPORT(106, void, png_chunk_warning, (png_const_structrp png_ptr,
 1826     png_const_charp warning_message));
 1827 #else
 1828 #  define png_warning(s1,s2) ((void)(s1))
 1829 #  define png_chunk_warning(s1,s2) ((void)(s1))
 1830 #endif
 1831 
 1832 #ifdef PNG_BENIGN_ERRORS_SUPPORTED
 1833 /* Benign error in libpng.  Can continue, but may have a problem.
 1834  * User can choose whether to handle as a fatal error or as a warning. */
 1835 PNG_EXPORT(107, void, png_benign_error, (png_const_structrp png_ptr,
 1836     png_const_charp warning_message));
 1837 
 1838 #ifdef PNG_READ_SUPPORTED
 1839 /* Same, chunk name is prepended to message (only during read) */
 1840 PNG_EXPORT(108, void, png_chunk_benign_error, (png_const_structrp png_ptr,
 1841     png_const_charp warning_message));
 1842 #endif
 1843 
 1844 PNG_EXPORT(109, void, png_set_benign_errors,
 1845     (png_structrp png_ptr, int allowed));
 1846 #else
 1847 #  ifdef PNG_ALLOW_BENIGN_ERRORS
 1848 #    define png_benign_error png_warning
 1849 #    define png_chunk_benign_error png_chunk_warning
 1850 #  else
 1851 #    define png_benign_error png_error
 1852 #    define png_chunk_benign_error png_chunk_error
 1853 #  endif
 1854 #endif
 1855 
 1856 /* The png_set_<chunk> functions are for storing values in the png_info_struct.
 1857  * Similarly, the png_get_<chunk> calls are used to read values from the
 1858  * png_info_struct, either storing the parameters in the passed variables, or
 1859  * setting pointers into the png_info_struct where the data is stored.  The
 1860  * png_get_<chunk> functions return a non-zero value if the data was available
 1861  * in info_ptr, or return zero and do not change any of the parameters if the
 1862  * data was not available.
 1863  *
 1864  * These functions should be used instead of directly accessing png_info
 1865  * to avoid problems with future changes in the size and internal layout of
 1866  * png_info_struct.
 1867  */
 1868 /* Returns "flag" if chunk data is valid in info_ptr. */
 1869 PNG_EXPORT(110, png_uint_32, png_get_valid, (png_const_structrp png_ptr,
 1870     png_const_inforp info_ptr, png_uint_32 flag));
 1871 
 1872 /* Returns number of bytes needed to hold a transformed row. */
 1873 PNG_EXPORT(111, png_size_t, png_get_rowbytes, (png_const_structrp png_ptr,
 1874     png_const_inforp info_ptr));
 1875 
 1876 #ifdef PNG_INFO_IMAGE_SUPPORTED
 1877 /* Returns row_pointers, which is an array of pointers to scanlines that was
 1878  * returned from png_read_png().
 1879  */
 1880 PNG_EXPORT(112, png_bytepp, png_get_rows, (png_const_structrp png_ptr,
 1881     png_const_inforp info_ptr));
 1882 
 1883 /* Set row_pointers, which is an array of pointers to scanlines for use
 1884  * by png_write_png().
 1885  */
 1886 PNG_EXPORT(113, void, png_set_rows, (png_const_structrp png_ptr,
 1887     png_inforp info_ptr, png_bytepp row_pointers));
 1888 #endif
 1889 
 1890 /* Returns number of color channels in image. */
 1891 PNG_EXPORT(114, png_byte, png_get_channels, (png_const_structrp png_ptr,
 1892     png_const_inforp info_ptr));
 1893 
 1894 #ifdef PNG_EASY_ACCESS_SUPPORTED
 1895 /* Returns image width in pixels. */
 1896 PNG_EXPORT(115, png_uint_32, png_get_image_width, (png_const_structrp png_ptr,
 1897     png_const_inforp info_ptr));
 1898 
 1899 /* Returns image height in pixels. */
 1900 PNG_EXPORT(116, png_uint_32, png_get_image_height, (png_const_structrp png_ptr,
 1901     png_const_inforp info_ptr));
 1902 
 1903 /* Returns image bit_depth. */
 1904 PNG_EXPORT(117, png_byte, png_get_bit_depth, (png_const_structrp png_ptr,
 1905     png_const_inforp info_ptr));
 1906 
 1907 /* Returns image color_type. */
 1908 PNG_EXPORT(118, png_byte, png_get_color_type, (png_const_structrp png_ptr,
 1909     png_const_inforp info_ptr));
 1910 
 1911 /* Returns image filter_type. */
 1912 PNG_EXPORT(119, png_byte, png_get_filter_type, (png_const_structrp png_ptr,
 1913     png_const_inforp info_ptr));
 1914 
 1915 /* Returns image interlace_type. */
 1916 PNG_EXPORT(120, png_byte, png_get_interlace_type, (png_const_structrp png_ptr,
 1917     png_const_inforp info_ptr));
 1918 
 1919 /* Returns image compression_type. */
 1920 PNG_EXPORT(121, png_byte, png_get_compression_type, (png_const_structrp png_ptr,
 1921     png_const_inforp info_ptr));
 1922 
 1923 /* Returns image resolution in pixels per meter, from pHYs chunk data. */
 1924 PNG_EXPORT(122, png_uint_32, png_get_pixels_per_meter,
 1925     (png_const_structrp png_ptr, png_const_inforp info_ptr));
 1926 PNG_EXPORT(123, png_uint_32, png_get_x_pixels_per_meter,
 1927     (png_const_structrp png_ptr, png_const_inforp info_ptr));
 1928 PNG_EXPORT(124, png_uint_32, png_get_y_pixels_per_meter,
 1929     (png_const_structrp png_ptr, png_const_inforp info_ptr));
 1930 
 1931 /* Returns pixel aspect ratio, computed from pHYs chunk data.  */
 1932 PNG_FP_EXPORT(125, float, png_get_pixel_aspect_ratio,
 1933     (png_const_structrp png_ptr, png_const_inforp info_ptr))
 1934 PNG_FIXED_EXPORT(210, png_fixed_point, png_get_pixel_aspect_ratio_fixed,
 1935     (png_const_structrp png_ptr, png_const_inforp info_ptr))
 1936 
 1937 /* Returns image x, y offset in pixels or microns, from oFFs chunk data. */
 1938 PNG_EXPORT(126, png_int_32, png_get_x_offset_pixels,
 1939     (png_const_structrp png_ptr, png_const_inforp info_ptr));
 1940 PNG_EXPORT(127, png_int_32, png_get_y_offset_pixels,
 1941     (png_const_structrp png_ptr, png_const_inforp info_ptr));
 1942 PNG_EXPORT(128, png_int_32, png_get_x_offset_microns,
 1943     (png_const_structrp png_ptr, png_const_inforp info_ptr));
 1944 PNG_EXPORT(129, png_int_32, png_get_y_offset_microns,
 1945     (png_const_structrp png_ptr, png_const_inforp info_ptr));
 1946 
 1947 #endif /* EASY_ACCESS */
 1948 
 1949 #ifdef PNG_READ_SUPPORTED
 1950 /* Returns pointer to signature string read from PNG header */
 1951 PNG_EXPORT(130, png_const_bytep, png_get_signature, (png_const_structrp png_ptr,
 1952     png_const_inforp info_ptr));
 1953 #endif
 1954 
 1955 #ifdef PNG_bKGD_SUPPORTED
 1956 PNG_EXPORT(131, png_uint_32, png_get_bKGD, (png_const_structrp png_ptr,
 1957     png_inforp info_ptr, png_color_16p *background));
 1958 #endif
 1959 
 1960 #ifdef PNG_bKGD_SUPPORTED
 1961 PNG_EXPORT(132, void, png_set_bKGD, (png_const_structrp png_ptr,
 1962     png_inforp info_ptr, png_const_color_16p background));
 1963 #endif
 1964 
 1965 #ifdef PNG_cHRM_SUPPORTED
 1966 PNG_FP_EXPORT(133, png_uint_32, png_get_cHRM, (png_const_structrp png_ptr,
 1967     png_const_inforp info_ptr, double *white_x, double *white_y, double *red_x,
 1968     double *red_y, double *green_x, double *green_y, double *blue_x,
 1969     double *blue_y))
 1970 PNG_FP_EXPORT(230, png_uint_32, png_get_cHRM_XYZ, (png_const_structrp png_ptr,
 1971     png_const_inforp info_ptr, double *red_X, double *red_Y, double *red_Z,
 1972     double *green_X, double *green_Y, double *green_Z, double *blue_X,
 1973     double *blue_Y, double *blue_Z))
 1974 PNG_FIXED_EXPORT(134, png_uint_32, png_get_cHRM_fixed,
 1975     (png_const_structrp png_ptr, png_const_inforp info_ptr,
 1976     png_fixed_point *int_white_x, png_fixed_point *int_white_y,
 1977     png_fixed_point *int_red_x, png_fixed_point *int_red_y,
 1978     png_fixed_point *int_green_x, png_fixed_point *int_green_y,
 1979     png_fixed_point *int_blue_x, png_fixed_point *int_blue_y))
 1980 PNG_FIXED_EXPORT(231, png_uint_32, png_get_cHRM_XYZ_fixed,
 1981     (png_const_structrp png_ptr, png_const_inforp info_ptr,
 1982     png_fixed_point *int_red_X, png_fixed_point *int_red_Y,
 1983     png_fixed_point *int_red_Z, png_fixed_point *int_green_X,
 1984     png_fixed_point *int_green_Y, png_fixed_point *int_green_Z,
 1985     png_fixed_point *int_blue_X, png_fixed_point *int_blue_Y,
 1986     png_fixed_point *int_blue_Z))
 1987 #endif
 1988 
 1989 #ifdef PNG_cHRM_SUPPORTED
 1990 PNG_FP_EXPORT(135, void, png_set_cHRM, (png_const_structrp png_ptr,
 1991     png_inforp info_ptr,
 1992     double white_x, double white_y, double red_x, double red_y, double green_x,
 1993     double green_y, double blue_x, double blue_y))
 1994 PNG_FP_EXPORT(232, void, png_set_cHRM_XYZ, (png_const_structrp png_ptr,
 1995     png_inforp info_ptr, double red_X, double red_Y, double red_Z,
 1996     double green_X, double green_Y, double green_Z, double blue_X,
 1997     double blue_Y, double blue_Z))
 1998 PNG_FIXED_EXPORT(136, void, png_set_cHRM_fixed, (png_const_structrp png_ptr,
 1999     png_inforp info_ptr, png_fixed_point int_white_x,
 2000     png_fixed_point int_white_y, png_fixed_point int_red_x,
 2001     png_fixed_point int_red_y, png_fixed_point int_green_x,
 2002     png_fixed_point int_green_y, png_fixed_point int_blue_x,
 2003     png_fixed_point int_blue_y))
 2004 PNG_FIXED_EXPORT(233, void, png_set_cHRM_XYZ_fixed, (png_const_structrp png_ptr,
 2005     png_inforp info_ptr, png_fixed_point int_red_X, png_fixed_point int_red_Y,
 2006     png_fixed_point int_red_Z, png_fixed_point int_green_X,
 2007     png_fixed_point int_green_Y, png_fixed_point int_green_Z,
 2008     png_fixed_point int_blue_X, png_fixed_point int_blue_Y,
 2009     png_fixed_point int_blue_Z))
 2010 #endif
 2011 
 2012 #ifdef PNG_eXIf_SUPPORTED
 2013 PNG_EXPORT(246, png_uint_32, png_get_eXIf, (png_const_structrp png_ptr,
 2014     png_inforp info_ptr, png_bytep *exif));
 2015 PNG_EXPORT(247, void, png_set_eXIf, (png_const_structrp png_ptr,
 2016     png_inforp info_ptr, const png_bytep exif));
 2017 
 2018 PNG_EXPORT(248, png_uint_32, png_get_eXIf_1, (png_const_structrp png_ptr,
 2019     png_const_inforp info_ptr, png_uint_32 *num_exif, png_bytep *exif));
 2020 PNG_EXPORT(249, void, png_set_eXIf_1, (png_const_structrp png_ptr,
 2021     png_inforp info_ptr, const png_uint_32 num_exif, const png_bytep exif));
 2022 #endif
 2023 
 2024 #ifdef PNG_gAMA_SUPPORTED
 2025 PNG_FP_EXPORT(137, png_uint_32, png_get_gAMA, (png_const_structrp png_ptr,
 2026     png_const_inforp info_ptr, double *file_gamma))
 2027 PNG_FIXED_EXPORT(138, png_uint_32, png_get_gAMA_fixed,
 2028     (png_const_structrp png_ptr, png_const_inforp info_ptr,
 2029     png_fixed_point *int_file_gamma))
 2030 #endif
 2031 
 2032 #ifdef PNG_gAMA_SUPPORTED
 2033 PNG_FP_EXPORT(139, void, png_set_gAMA, (png_const_structrp png_ptr,
 2034     png_inforp info_ptr, double file_gamma))
 2035 PNG_FIXED_EXPORT(140, void, png_set_gAMA_fixed, (png_const_structrp png_ptr,
 2036     png_inforp info_ptr, png_fixed_point int_file_gamma))
 2037 #endif
 2038 
 2039 #ifdef PNG_hIST_SUPPORTED
 2040 PNG_EXPORT(141, png_uint_32, png_get_hIST, (png_const_structrp png_ptr,
 2041     png_inforp info_ptr, png_uint_16p *hist));
 2042 PNG_EXPORT(142, void, png_set_hIST, (png_const_structrp png_ptr,
 2043     png_inforp info_ptr, png_const_uint_16p hist));
 2044 #endif
 2045 
 2046 PNG_EXPORT(143, png_uint_32, png_get_IHDR, (png_const_structrp png_ptr,
 2047     png_const_inforp info_ptr, png_uint_32 *width, png_uint_32 *height,
 2048     int *bit_depth, int *color_type, int *interlace_method,
 2049     int *compression_method, int *filter_method));
 2050 
 2051 PNG_EXPORT(144, void, png_set_IHDR, (png_const_structrp png_ptr,
 2052     png_inforp info_ptr, png_uint_32 width, png_uint_32 height, int bit_depth,
 2053     int color_type, int interlace_method, int compression_method,
 2054     int filter_method));
 2055 
 2056 #ifdef PNG_oFFs_SUPPORTED
 2057 PNG_EXPORT(145, png_uint_32, png_get_oFFs, (png_const_structrp png_ptr,
 2058    png_const_inforp info_ptr, png_int_32 *offset_x, png_int_32 *offset_y,
 2059    int *unit_type));
 2060 #endif
 2061 
 2062 #ifdef PNG_oFFs_SUPPORTED
 2063 PNG_EXPORT(146, void, png_set_oFFs, (png_const_structrp png_ptr,
 2064     png_inforp info_ptr, png_int_32 offset_x, png_int_32 offset_y,
 2065     int unit_type));
 2066 #endif
 2067 
 2068 #ifdef PNG_pCAL_SUPPORTED
 2069 PNG_EXPORT(147, png_uint_32, png_get_pCAL, (png_const_structrp png_ptr,
 2070     png_inforp info_ptr, png_charp *purpose, png_int_32 *X0,
 2071     png_int_32 *X1, int *type, int *nparams, png_charp *units,
 2072     png_charpp *params));
 2073 #endif
 2074 
 2075 #ifdef PNG_pCAL_SUPPORTED
 2076 PNG_EXPORT(148, void, png_set_pCAL, (png_const_structrp png_ptr,
 2077     png_inforp info_ptr, png_const_charp purpose, png_int_32 X0, png_int_32 X1,
 2078     int type, int nparams, png_const_charp units, png_charpp params));
 2079 #endif
 2080 
 2081 #ifdef PNG_pHYs_SUPPORTED
 2082 PNG_EXPORT(149, png_uint_32, png_get_pHYs, (png_const_structrp png_ptr,
 2083     png_const_inforp info_ptr, png_uint_32 *res_x, png_uint_32 *res_y,
 2084     int *unit_type));
 2085 #endif
 2086 
 2087 #ifdef PNG_pHYs_SUPPORTED
 2088 PNG_EXPORT(150, void, png_set_pHYs, (png_const_structrp png_ptr,
 2089     png_inforp info_ptr, png_uint_32 res_x, png_uint_32 res_y, int unit_type));
 2090 #endif
 2091 
 2092 PNG_EXPORT(151, png_uint_32, png_get_PLTE, (png_const_structrp png_ptr,
 2093    png_inforp info_ptr, png_colorp *palette, int *num_palette));
 2094 
 2095 PNG_EXPORT(152, void, png_set_PLTE, (png_structrp png_ptr,
 2096     png_inforp info_ptr, png_const_colorp palette, int num_palette));
 2097 
 2098 #ifdef PNG_sBIT_SUPPORTED
 2099 PNG_EXPORT(153, png_uint_32, png_get_sBIT, (png_const_structrp png_ptr,
 2100     png_inforp info_ptr, png_color_8p *sig_bit));
 2101 #endif
 2102 
 2103 #ifdef PNG_sBIT_SUPPORTED
 2104 PNG_EXPORT(154, void, png_set_sBIT, (png_const_structrp png_ptr,
 2105     png_inforp info_ptr, png_const_color_8p sig_bit));
 2106 #endif
 2107 
 2108 #ifdef PNG_sRGB_SUPPORTED
 2109 PNG_EXPORT(155, png_uint_32, png_get_sRGB, (png_const_structrp png_ptr,
 2110     png_const_inforp info_ptr, int *file_srgb_intent));
 2111 #endif
 2112 
 2113 #ifdef PNG_sRGB_SUPPORTED
 2114 PNG_EXPORT(156, void, png_set_sRGB, (png_const_structrp png_ptr,
 2115     png_inforp info_ptr, int srgb_intent));
 2116 PNG_EXPORT(157, void, png_set_sRGB_gAMA_and_cHRM, (png_const_structrp png_ptr,
 2117     png_inforp info_ptr, int srgb_intent));
 2118 #endif
 2119 
 2120 #ifdef PNG_iCCP_SUPPORTED
 2121 PNG_EXPORT(158, png_uint_32, png_get_iCCP, (png_const_structrp png_ptr,
 2122     png_inforp info_ptr, png_charpp name, int *compression_type,
 2123     png_bytepp profile, png_uint_32 *proflen));
 2124 #endif
 2125 
 2126 #ifdef PNG_iCCP_SUPPORTED
 2127 PNG_EXPORT(159, void, png_set_iCCP, (png_const_structrp png_ptr,
 2128     png_inforp info_ptr, png_const_charp name, int compression_type,
 2129     png_const_bytep profile, png_uint_32 proflen));
 2130 #endif
 2131 
 2132 #ifdef PNG_sPLT_SUPPORTED
 2133 PNG_EXPORT(160, int, png_get_sPLT, (png_const_structrp png_ptr,
 2134     png_inforp info_ptr, png_sPLT_tpp entries));
 2135 #endif
 2136 
 2137 #ifdef PNG_sPLT_SUPPORTED
 2138 PNG_EXPORT(161, void, png_set_sPLT, (png_const_structrp png_ptr,
 2139     png_inforp info_ptr, png_const_sPLT_tp entries, int nentries));
 2140 #endif
 2141 
 2142 #ifdef PNG_TEXT_SUPPORTED
 2143 /* png_get_text also returns the number of text chunks in *num_text */
 2144 PNG_EXPORT(162, int, png_get_text, (png_const_structrp png_ptr,
 2145     png_inforp info_ptr, png_textp *text_ptr, int *num_text));
 2146 #endif
 2147 
 2148 /* Note while png_set_text() will accept a structure whose text,
 2149  * language, and  translated keywords are NULL pointers, the structure
 2150  * returned by png_get_text will always contain regular
 2151  * zero-terminated C strings.  They might be empty strings but
 2152  * they will never be NULL pointers.
 2153  */
 2154 
 2155 #ifdef PNG_TEXT_SUPPORTED
 2156 PNG_EXPORT(163, void, png_set_text, (png_const_structrp png_ptr,
 2157     png_inforp info_ptr, png_const_textp text_ptr, int num_text));
 2158 #endif
 2159 
 2160 #ifdef PNG_tIME_SUPPORTED
 2161 PNG_EXPORT(164, png_uint_32, png_get_tIME, (png_const_structrp png_ptr,
 2162     png_inforp info_ptr, png_timep *mod_time));
 2163 #endif
 2164 
 2165 #ifdef PNG_tIME_SUPPORTED
 2166 PNG_EXPORT(165, void, png_set_tIME, (png_const_structrp png_ptr,
 2167     png_inforp info_ptr, png_const_timep mod_time));
 2168 #endif
 2169 
 2170 #ifdef PNG_tRNS_SUPPORTED
 2171 PNG_EXPORT(166, png_uint_32, png_get_tRNS, (png_const_structrp png_ptr,
 2172     png_inforp info_ptr, png_bytep *trans_alpha, int *num_trans,
 2173     png_color_16p *trans_color));
 2174 #endif
 2175 
 2176 #ifdef PNG_tRNS_SUPPORTED
 2177 PNG_EXPORT(167, void, png_set_tRNS, (png_structrp png_ptr,
 2178     png_inforp info_ptr, png_const_bytep trans_alpha, int num_trans,
 2179     png_const_color_16p trans_color));
 2180 #endif
 2181 
 2182 #ifdef PNG_sCAL_SUPPORTED
 2183 PNG_FP_EXPORT(168, png_uint_32, png_get_sCAL, (png_const_structrp png_ptr,
 2184     png_const_inforp info_ptr, int *unit, double *width, double *height))
 2185 #if defined(PNG_FLOATING_ARITHMETIC_SUPPORTED) || \
 2186    defined(PNG_FLOATING_POINT_SUPPORTED)
 2187 /* NOTE: this API is currently implemented using floating point arithmetic,
 2188  * consequently it can only be used on systems with floating point support.
 2189  * In any case the range of values supported by png_fixed_point is small and it
 2190  * is highly recommended that png_get_sCAL_s be used instead.
 2191  */
 2192 PNG_FIXED_EXPORT(214, png_uint_32, png_get_sCAL_fixed,
 2193     (png_const_structrp png_ptr, png_const_inforp info_ptr, int *unit,
 2194     png_fixed_point *width, png_fixed_point *height))
 2195 #endif
 2196 PNG_EXPORT(169, png_uint_32, png_get_sCAL_s,
 2197     (png_const_structrp png_ptr, png_const_inforp info_ptr, int *unit,
 2198     png_charpp swidth, png_charpp sheight));
 2199 
 2200 PNG_FP_EXPORT(170, void, png_set_sCAL, (png_const_structrp png_ptr,
 2201     png_inforp info_ptr, int unit, double width, double height))
 2202 PNG_FIXED_EXPORT(213, void, png_set_sCAL_fixed, (png_const_structrp png_ptr,
 2203    png_inforp info_ptr, int unit, png_fixed_point width,
 2204    png_fixed_point height))
 2205 PNG_EXPORT(171, void, png_set_sCAL_s, (png_const_structrp png_ptr,
 2206     png_inforp info_ptr, int unit,
 2207     png_const_charp swidth, png_const_charp sheight));
 2208 #endif /* sCAL */
 2209 
 2210 #ifdef PNG_SET_UNKNOWN_CHUNKS_SUPPORTED
 2211 /* Provide the default handling for all unknown chunks or, optionally, for
 2212  * specific unknown chunks.
 2213  *
 2214  * NOTE: prior to 1.6.0 the handling specified for particular chunks on read was
 2215  * ignored and the default was used, the per-chunk setting only had an effect on
 2216  * write.  If you wish to have chunk-specific handling on read in code that must
 2217  * work on earlier versions you must use a user chunk callback to specify the
 2218  * desired handling (keep or discard.)
 2219  *
 2220  * The 'keep' parameter is a PNG_HANDLE_CHUNK_ value as listed below.  The
 2221  * parameter is interpreted as follows:
 2222  *
 2223  * READ:
 2224  *    PNG_HANDLE_CHUNK_AS_DEFAULT:
 2225  *       Known chunks: do normal libpng processing, do not keep the chunk (but
 2226  *          see the comments below about PNG_HANDLE_AS_UNKNOWN_SUPPORTED)
 2227  *       Unknown chunks: for a specific chunk use the global default, when used
 2228  *          as the default discard the chunk data.
 2229  *    PNG_HANDLE_CHUNK_NEVER:
 2230  *       Discard the chunk data.
 2231  *    PNG_HANDLE_CHUNK_IF_SAFE:
 2232  *       Keep the chunk data if the chunk is not critical else raise a chunk
 2233  *       error.
 2234  *    PNG_HANDLE_CHUNK_ALWAYS:
 2235  *       Keep the chunk data.
 2236  *
 2237  * If the chunk data is saved it can be retrieved using png_get_unknown_chunks,
 2238  * below.  Notice that specifying "AS_DEFAULT" as a global default is equivalent
 2239  * to specifying "NEVER", however when "AS_DEFAULT" is used for specific chunks
 2240  * it simply resets the behavior to the libpng default.
 2241  *
 2242  * INTERACTION WTIH USER CHUNK CALLBACKS:
 2243  * The per-chunk handling is always used when there is a png_user_chunk_ptr
 2244  * callback and the callback returns 0; the chunk is then always stored *unless*
 2245  * it is critical and the per-chunk setting is other than ALWAYS.  Notice that
 2246  * the global default is *not* used in this case.  (In effect the per-chunk
 2247  * value is incremented to at least IF_SAFE.)
 2248  *
 2249  * IMPORTANT NOTE: this behavior will change in libpng 1.7 - the global and
 2250  * per-chunk defaults will be honored.  If you want to preserve the current
 2251  * behavior when your callback returns 0 you must set PNG_HANDLE_CHUNK_IF_SAFE
 2252  * as the default - if you don't do this libpng 1.6 will issue a warning.
 2253  *
 2254  * If you want unhandled unknown chunks to be discarded in libpng 1.6 and
 2255  * earlier simply return '1' (handled).
 2256  *
 2257  * PNG_HANDLE_AS_UNKNOWN_SUPPORTED:
 2258  *    If this is *not* set known chunks will always be handled by libpng and
 2259  *    will never be stored in the unknown chunk list.  Known chunks listed to
 2260  *    png_set_keep_unknown_chunks will have no effect.  If it is set then known
 2261  *    chunks listed with a keep other than AS_DEFAULT will *never* be processed
 2262  *    by libpng, in addition critical chunks must either be processed by the
 2263  *    callback or saved.
 2264  *
 2265  *    The IHDR and IEND chunks must not be listed.  Because this turns off the
 2266  *    default handling for chunks that would otherwise be recognized the
 2267  *    behavior of libpng transformations may well become incorrect!
 2268  *
 2269  * WRITE:
 2270  *    When writing chunks the options only apply to the chunks specified by
 2271  *    png_set_unknown_chunks (below), libpng will *always* write known chunks
 2272  *    required by png_set_ calls and will always write the core critical chunks
 2273  *    (as required for PLTE).
 2274  *
 2275  *    Each chunk in the png_set_unknown_chunks list is looked up in the
 2276  *    png_set_keep_unknown_chunks list to find the keep setting, this is then
 2277  *    interpreted as follows:
 2278  *
 2279  *    PNG_HANDLE_CHUNK_AS_DEFAULT:
 2280  *       Write safe-to-copy chunks and write other chunks if the global
 2281  *       default is set to _ALWAYS, otherwise don't write this chunk.
 2282  *    PNG_HANDLE_CHUNK_NEVER:
 2283  *       Do not write the chunk.
 2284  *    PNG_HANDLE_CHUNK_IF_SAFE:
 2285  *       Write the chunk if it is safe-to-copy, otherwise do not write it.
 2286  *    PNG_HANDLE_CHUNK_ALWAYS:
 2287  *       Write the chunk.
 2288  *
 2289  * Note that the default behavior is effectively the opposite of the read case -
 2290  * in read unknown chunks are not stored by default, in write they are written
 2291  * by default.  Also the behavior of PNG_HANDLE_CHUNK_IF_SAFE is very different
 2292  * - on write the safe-to-copy bit is checked, on read the critical bit is
 2293  * checked and on read if the chunk is critical an error will be raised.
 2294  *
 2295  * num_chunks:
 2296  * ===========
 2297  *    If num_chunks is positive, then the "keep" parameter specifies the manner
 2298  *    for handling only those chunks appearing in the chunk_list array,
 2299  *    otherwise the chunk list array is ignored.
 2300  *
 2301  *    If num_chunks is 0 the "keep" parameter specifies the default behavior for
 2302  *    unknown chunks, as described above.
 2303  *
 2304  *    If num_chunks is negative, then the "keep" parameter specifies the manner
 2305  *    for handling all unknown chunks plus all chunks recognized by libpng
 2306  *    except for the IHDR, PLTE, tRNS, IDAT, and IEND chunks (which continue to
 2307  *    be processed by libpng.
 2308  */
 2309 #ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED
 2310 PNG_EXPORT(172, void, png_set_keep_unknown_chunks, (png_structrp png_ptr,
 2311     int keep, png_const_bytep chunk_list, int num_chunks));
 2312 #endif /* HANDLE_AS_UNKNOWN */
 2313 
 2314 /* The "keep" PNG_HANDLE_CHUNK_ parameter for the specified chunk is returned;
 2315  * the result is therefore true (non-zero) if special handling is required,
 2316  * false for the default handling.
 2317  */
 2318 PNG_EXPORT(173, int, png_handle_as_unknown, (png_const_structrp png_ptr,
 2319     png_const_bytep chunk_name));
 2320 #endif /* SET_UNKNOWN_CHUNKS */
 2321 
 2322 #ifdef PNG_STORE_UNKNOWN_CHUNKS_SUPPORTED
 2323 PNG_EXPORT(174, void, png_set_unknown_chunks, (png_const_structrp png_ptr,
 2324     png_inforp info_ptr, png_const_unknown_chunkp unknowns,
 2325     int num_unknowns));
 2326    /* NOTE: prior to 1.6.0 this routine set the 'location' field of the added
 2327     * unknowns to the location currently stored in the png_struct.  This is
 2328     * invariably the wrong value on write.  To fix this call the following API
 2329     * for each chunk in the list with the correct location.  If you know your
 2330     * code won't be compiled on earlier versions you can rely on
 2331     * png_set_unknown_chunks(write-ptr, png_get_unknown_chunks(read-ptr)) doing
 2332     * the correct thing.
 2333     */
 2334 
 2335 PNG_EXPORT(175, void, png_set_unknown_chunk_location,
 2336     (png_const_structrp png_ptr, png_inforp info_ptr, int chunk, int location));
 2337 
 2338 PNG_EXPORT(176, int, png_get_unknown_chunks, (png_const_structrp png_ptr,
 2339     png_inforp info_ptr, png_unknown_chunkpp entries));
 2340 #endif
 2341 
 2342 /* Png_free_data() will turn off the "valid" flag for anything it frees.
 2343  * If you need to turn it off for a chunk that your application has freed,
 2344  * you can use png_set_invalid(png_ptr, info_ptr, PNG_INFO_CHNK);
 2345  */
 2346 PNG_EXPORT(177, void, png_set_invalid, (png_const_structrp png_ptr,
 2347     png_inforp info_ptr, int mask));
 2348 
 2349 #ifdef PNG_INFO_IMAGE_SUPPORTED
 2350 /* The "params" pointer is currently not used and is for future expansion. */
 2351 #ifdef PNG_SEQUENTIAL_READ_SUPPORTED
 2352 PNG_EXPORT(178, void, png_read_png, (png_structrp png_ptr, png_inforp info_ptr,
 2353     int transforms, png_voidp params));
 2354 #endif
 2355 #ifdef PNG_WRITE_SUPPORTED
 2356 PNG_EXPORT(179, void, png_write_png, (png_structrp png_ptr, png_inforp info_ptr,
 2357     int transforms, png_voidp params));
 2358 #endif
 2359 #endif
 2360 
 2361 PNG_EXPORT(180, png_const_charp, png_get_copyright,
 2362     (png_const_structrp png_ptr));
 2363 PNG_EXPORT(181, png_const_charp, png_get_header_ver,
 2364     (png_const_structrp png_ptr));
 2365 PNG_EXPORT(182, png_const_charp, png_get_header_version,
 2366     (png_const_structrp png_ptr));
 2367 PNG_EXPORT(183, png_const_charp, png_get_libpng_ver,
 2368     (png_const_structrp png_ptr));
 2369 
 2370 #ifdef PNG_MNG_FEATURES_SUPPORTED
 2371 PNG_EXPORT(184, png_uint_32, png_permit_mng_features, (png_structrp png_ptr,
 2372     png_uint_32 mng_features_permitted));
 2373 #endif
 2374 
 2375 /* For use in png_set_keep_unknown, added to version 1.2.6 */
 2376 #define PNG_HANDLE_CHUNK_AS_DEFAULT   0
 2377 #define PNG_HANDLE_CHUNK_NEVER        1
 2378 #define PNG_HANDLE_CHUNK_IF_SAFE      2
 2379 #define PNG_HANDLE_CHUNK_ALWAYS       3
 2380 #define PNG_HANDLE_CHUNK_LAST         4
 2381 
 2382 /* Strip the prepended error numbers ("#nnn ") from error and warning
 2383  * messages before passing them to the error or warning handler.
 2384  */
 2385 #ifdef PNG_ERROR_NUMBERS_SUPPORTED
 2386 PNG_EXPORT(185, void, png_set_strip_error_numbers, (png_structrp png_ptr,
 2387     png_uint_32 strip_mode));
 2388 #endif
 2389 
 2390 /* Added in libpng-1.2.6 */
 2391 #ifdef PNG_SET_USER_LIMITS_SUPPORTED
 2392 PNG_EXPORT(186, void, png_set_user_limits, (png_structrp png_ptr,
 2393     png_uint_32 user_width_max, png_uint_32 user_height_max));
 2394 PNG_EXPORT(187, png_uint_32, png_get_user_width_max,
 2395     (png_const_structrp png_ptr));
 2396 PNG_EXPORT(188, png_uint_32, png_get_user_height_max,
 2397     (png_const_structrp png_ptr));
 2398 /* Added in libpng-1.4.0 */
 2399 PNG_EXPORT(189, void, png_set_chunk_cache_max, (png_structrp png_ptr,
 2400     png_uint_32 user_chunk_cache_max));
 2401 PNG_EXPORT(190, png_uint_32, png_get_chunk_cache_max,
 2402     (png_const_structrp png_ptr));
 2403 /* Added in libpng-1.4.1 */
 2404 PNG_EXPORT(191, void, png_set_chunk_malloc_max, (png_structrp png_ptr,
 2405     png_alloc_size_t user_chunk_cache_max));
 2406 PNG_EXPORT(192, png_alloc_size_t, png_get_chunk_malloc_max,
 2407     (png_const_structrp png_ptr));
 2408 #endif
 2409 
 2410 #if defined(PNG_INCH_CONVERSIONS_SUPPORTED)
 2411 PNG_EXPORT(193, png_uint_32, png_get_pixels_per_inch,
 2412     (png_const_structrp png_ptr, png_const_inforp info_ptr));
 2413 
 2414 PNG_EXPORT(194, png_uint_32, png_get_x_pixels_per_inch,
 2415     (png_const_structrp png_ptr, png_const_inforp info_ptr));
 2416 
 2417 PNG_EXPORT(195, png_uint_32, png_get_y_pixels_per_inch,
 2418     (png_const_structrp png_ptr, png_const_inforp info_ptr));
 2419 
 2420 PNG_FP_EXPORT(196, float, png_get_x_offset_inches,
 2421     (png_const_structrp png_ptr, png_const_inforp info_ptr))
 2422 #ifdef PNG_FIXED_POINT_SUPPORTED /* otherwise not implemented. */
 2423 PNG_FIXED_EXPORT(211, png_fixed_point, png_get_x_offset_inches_fixed,
 2424     (png_const_structrp png_ptr, png_const_inforp info_ptr))
 2425 #endif
 2426 
 2427 PNG_FP_EXPORT(197, float, png_get_y_offset_inches, (png_const_structrp png_ptr,
 2428     png_const_inforp info_ptr))
 2429 #ifdef PNG_FIXED_POINT_SUPPORTED /* otherwise not implemented. */
 2430 PNG_FIXED_EXPORT(212, png_fixed_point, png_get_y_offset_inches_fixed,
 2431     (png_const_structrp png_ptr, png_const_inforp info_ptr))
 2432 #endif
 2433 
 2434 #  ifdef PNG_pHYs_SUPPORTED
 2435 PNG_EXPORT(198, png_uint_32, png_get_pHYs_dpi, (png_const_structrp png_ptr,
 2436     png_const_inforp info_ptr, png_uint_32 *res_x, png_uint_32 *res_y,
 2437     int *unit_type));
 2438 #  endif /* pHYs */
 2439 #endif  /* INCH_CONVERSIONS */
 2440 
 2441 /* Added in libpng-1.4.0 */
 2442 #ifdef PNG_IO_STATE_SUPPORTED
 2443 PNG_EXPORT(199, png_uint_32, png_get_io_state, (png_const_structrp png_ptr));
 2444 
 2445 /* Removed from libpng 1.6; use png_get_io_chunk_type. */
 2446 PNG_REMOVED(200, png_const_bytep, png_get_io_chunk_name, (png_structrp png_ptr),
 2447     PNG_DEPRECATED)
 2448 
 2449 PNG_EXPORT(216, png_uint_32, png_get_io_chunk_type,
 2450     (png_const_structrp png_ptr));
 2451 
 2452 /* The flags returned by png_get_io_state() are the following: */
 2453 #  define PNG_IO_NONE        0x0000   /* no I/O at this moment */
 2454 #  define PNG_IO_READING     0x0001   /* currently reading */
 2455 #  define PNG_IO_WRITING     0x0002   /* currently writing */
 2456 #  define PNG_IO_SIGNATURE   0x0010   /* currently at the file signature */
 2457 #  define PNG_IO_CHUNK_HDR   0x0020   /* currently at the chunk header */
 2458 #  define PNG_IO_CHUNK_DATA  0x0040   /* currently at the chunk data */
 2459 #  define PNG_IO_CHUNK_CRC   0x0080   /* currently at the chunk crc */
 2460 #  define PNG_IO_MASK_OP     0x000f   /* current operation: reading/writing */
 2461 #  define PNG_IO_MASK_LOC    0x00f0   /* current location: sig/hdr/data/crc */
 2462 #endif /* IO_STATE */
 2463 
 2464 /* Interlace support.  The following macros are always defined so that if
 2465  * libpng interlace handling is turned off the macros may be used to handle
 2466  * interlaced images within the application.
 2467  */
 2468 #define PNG_INTERLACE_ADAM7_PASSES 7
 2469 
 2470 /* Two macros to return the first row and first column of the original,
 2471  * full, image which appears in a given pass.  'pass' is in the range 0
 2472  * to 6 and the result is in the range 0 to 7.
 2473  */
 2474 #define PNG_PASS_START_ROW(pass) (((1&~(pass))<<(3-((pass)>>1)))&7)
 2475 #define PNG_PASS_START_COL(pass) (((1& (pass))<<(3-(((pass)+1)>>1)))&7)
 2476 
 2477 /* A macro to return the offset between pixels in the output row for a pair of
 2478  * pixels in the input - effectively the inverse of the 'COL_SHIFT' macro that
 2479  * follows.  Note that ROW_OFFSET is the offset from one row to the next whereas
 2480  * COL_OFFSET is from one column to the next, within a row.
 2481  */
 2482 #define PNG_PASS_ROW_OFFSET(pass) ((pass)>2?(8>>(((pass)-1)>>1)):8)
 2483 #define PNG_PASS_COL_OFFSET(pass) (1<<((7-(pass))>>1))
 2484 
 2485 /* Two macros to help evaluate the number of rows or columns in each
 2486  * pass.  This is expressed as a shift - effectively log2 of the number or
 2487  * rows or columns in each 8x8 tile of the original image.
 2488  */
 2489 #define PNG_PASS_ROW_SHIFT(pass) ((pass)>2?(8-(pass))>>1:3)
 2490 #define PNG_PASS_COL_SHIFT(pass) ((pass)>1?(7-(pass))>>1:3)
 2491 
 2492 /* Hence two macros to determine the number of rows or columns in a given
 2493  * pass of an image given its height or width.  In fact these macros may
 2494  * return non-zero even though the sub-image is empty, because the other
 2495  * dimension may be empty for a small image.
 2496  */
 2497 #define PNG_PASS_ROWS(height, pass) (((height)+(((1<<PNG_PASS_ROW_SHIFT(pass))\
 2498    -1)-PNG_PASS_START_ROW(pass)))>>PNG_PASS_ROW_SHIFT(pass))
 2499 #define PNG_PASS_COLS(width, pass) (((width)+(((1<<PNG_PASS_COL_SHIFT(pass))\
 2500    -1)-PNG_PASS_START_COL(pass)))>>PNG_PASS_COL_SHIFT(pass))
 2501 
 2502 /* For the reader row callbacks (both progressive and sequential) it is
 2503  * necessary to find the row in the output image given a row in an interlaced
 2504  * image, so two more macros:
 2505  */
 2506 #define PNG_ROW_FROM_PASS_ROW(y_in, pass) \
 2507    (((y_in)<<PNG_PASS_ROW_SHIFT(pass))+PNG_PASS_START_ROW(pass))
 2508 #define PNG_COL_FROM_PASS_COL(x_in, pass) \
 2509    (((x_in)<<PNG_PASS_COL_SHIFT(pass))+PNG_PASS_START_COL(pass))
 2510 
 2511 /* Two macros which return a boolean (0 or 1) saying whether the given row
 2512  * or column is in a particular pass.  These use a common utility macro that
 2513  * returns a mask for a given pass - the offset 'off' selects the row or
 2514  * column version.  The mask has the appropriate bit set for each column in
 2515  * the tile.
 2516  */
 2517 #define PNG_PASS_MASK(pass,off) ( \
 2518    ((0x110145AF>>(((7-(off))-(pass))<<2)) & 0xF) | \
 2519    ((0x01145AF0>>(((7-(off))-(pass))<<2)) & 0xF0))
 2520 
 2521 #define PNG_ROW_IN_INTERLACE_PASS(y, pass) \
 2522    ((PNG_PASS_MASK(pass,0) >> ((y)&7)) & 1)
 2523 #define PNG_COL_IN_INTERLACE_PASS(x, pass) \
 2524    ((PNG_PASS_MASK(pass,1) >> ((x)&7)) & 1)
 2525 
 2526 #ifdef PNG_READ_COMPOSITE_NODIV_SUPPORTED
 2527 /* With these routines we avoid an integer divide, which will be slower on
 2528  * most machines.  However, it does take more operations than the corresponding
 2529  * divide method, so it may be slower on a few RISC systems.  There are two
 2530  * shifts (by 8 or 16 bits) and an addition, versus a single integer divide.
 2531  *
 2532  * Note that the rounding factors are NOT supposed to be the same!  128 and
 2533  * 32768 are correct for the NODIV code; 127 and 32767 are correct for the
 2534  * standard method.
 2535  *
 2536  * [Optimized code by Greg Roelofs and Mark Adler...blame us for bugs. :-) ]
 2537  */
 2538 
 2539  /* fg and bg should be in `gamma 1.0' space; alpha is the opacity */
 2540 
 2541 #  define png_composite(composite, fg, alpha, bg)        \
 2542    {                                                     \
 2543       png_uint_16 temp = (png_uint_16)((png_uint_16)(fg) \
 2544           * (png_uint_16)(alpha)                         \
 2545           + (png_uint_16)(bg)*(png_uint_16)(255          \
 2546           - (png_uint_16)(alpha)) + 128);                \
 2547       (composite) = (png_byte)(((temp + (temp >> 8)) >> 8) & 0xff); \
 2548    }
 2549 
 2550 #  define png_composite_16(composite, fg, alpha, bg)     \
 2551    {                                                     \
 2552       png_uint_32 temp = (png_uint_32)((png_uint_32)(fg) \
 2553           * (png_uint_32)(alpha)                         \
 2554           + (png_uint_32)(bg)*(65535                     \
 2555           - (png_uint_32)(alpha)) + 32768);              \
 2556       (composite) = (png_uint_16)(0xffff & ((temp + (temp >> 16)) >> 16)); \
 2557    }
 2558 
 2559 #else  /* Standard method using integer division */
 2560 
 2561 #  define png_composite(composite, fg, alpha, bg)                      \
 2562    (composite) =                                                       \
 2563        (png_byte)(0xff & (((png_uint_16)(fg) * (png_uint_16)(alpha) +  \
 2564        (png_uint_16)(bg) * (png_uint_16)(255 - (png_uint_16)(alpha)) + \
 2565        127) / 255))
 2566 
 2567 #  define png_composite_16(composite, fg, alpha, bg)                       \
 2568    (composite) =                                                           \
 2569        (png_uint_16)(0xffff & (((png_uint_32)(fg) * (png_uint_32)(alpha) + \
 2570        (png_uint_32)(bg)*(png_uint_32)(65535 - (png_uint_32)(alpha)) +     \
 2571        32767) / 65535))
 2572 #endif /* READ_COMPOSITE_NODIV */
 2573 
 2574 #ifdef PNG_READ_INT_FUNCTIONS_SUPPORTED
 2575 PNG_EXPORT(201, png_uint_32, png_get_uint_32, (png_const_bytep buf));
 2576 PNG_EXPORT(202, png_uint_16, png_get_uint_16, (png_const_bytep buf));
 2577 PNG_EXPORT(203, png_int_32, png_get_int_32, (png_const_bytep buf));
 2578 #endif
 2579 
 2580 PNG_EXPORT(204, png_uint_32, png_get_uint_31, (png_const_structrp png_ptr,
 2581     png_const_bytep buf));
 2582 /* No png_get_int_16 -- may be added if there's a real need for it. */
 2583 
 2584 /* Place a 32-bit number into a buffer in PNG byte order (big-endian). */
 2585 #ifdef PNG_WRITE_INT_FUNCTIONS_SUPPORTED
 2586 PNG_EXPORT(205, void, png_save_uint_32, (png_bytep buf, png_uint_32 i));
 2587 #endif
 2588 #ifdef PNG_SAVE_INT_32_SUPPORTED
 2589 PNG_EXPORT(206, void, png_save_int_32, (png_bytep buf, png_int_32 i));
 2590 #endif
 2591 
 2592 /* Place a 16-bit number into a buffer in PNG byte order.
 2593  * The parameter is declared unsigned int, not png_uint_16,
 2594  * just to avoid potential problems on pre-ANSI C compilers.
 2595  */
 2596 #ifdef PNG_WRITE_INT_FUNCTIONS_SUPPORTED
 2597 PNG_EXPORT(207, void, png_save_uint_16, (png_bytep buf, unsigned int i));
 2598 /* No png_save_int_16 -- may be added if there's a real need for it. */
 2599 #endif
 2600 
 2601 #ifdef PNG_USE_READ_MACROS
 2602 /* Inline macros to do direct reads of bytes from the input buffer.
 2603  * The png_get_int_32() routine assumes we are using two's complement
 2604  * format for negative values, which is almost certainly true.
 2605  */
 2606 #  define PNG_get_uint_32(buf) \
 2607    (((png_uint_32)(*(buf)) << 24) + \
 2608     ((png_uint_32)(*((buf) + 1)) << 16) + \
 2609     ((png_uint_32)(*((buf) + 2)) << 8) + \
 2610     ((png_uint_32)(*((buf) + 3))))
 2611 
 2612    /* From libpng-1.4.0 until 1.4.4, the png_get_uint_16 macro (but not the
 2613     * function) incorrectly returned a value of type png_uint_32.
 2614     */
 2615 #  define PNG_get_uint_16(buf) \
 2616    ((png_uint_16) \
 2617     (((unsigned int)(*(buf)) << 8) + \
 2618     ((unsigned int)(*((buf) + 1)))))
 2619 
 2620 #  define PNG_get_int_32(buf) \
 2621    ((png_int_32)((*(buf) & 0x80) \
 2622     ? -((png_int_32)(((png_get_uint_32(buf)^0xffffffffU)+1U)&0x7fffffffU)) \
 2623     : (png_int_32)png_get_uint_32(buf)))
 2624 
 2625 /* If PNG_PREFIX is defined the same thing as below happens in pnglibconf.h,
 2626  * but defining a macro name prefixed with PNG_PREFIX.
 2627  */
 2628 #  ifndef PNG_PREFIX
 2629 #    define png_get_uint_32(buf) PNG_get_uint_32(buf)
 2630 #    define png_get_uint_16(buf) PNG_get_uint_16(buf)
 2631 #    define png_get_int_32(buf)  PNG_get_int_32(buf)
 2632 #  endif
 2633 #else
 2634 #  ifdef PNG_PREFIX
 2635    /* No macros; revert to the (redefined) function */
 2636 #    define PNG_get_uint_32 (png_get_uint_32)
 2637 #    define PNG_get_uint_16 (png_get_uint_16)
 2638 #    define PNG_get_int_32  (png_get_int_32)
 2639 #  endif
 2640 #endif
 2641 
 2642 #ifdef PNG_CHECK_FOR_INVALID_INDEX_SUPPORTED
 2643 PNG_EXPORT(242, void, png_set_check_for_invalid_index,
 2644     (png_structrp png_ptr, int allowed));
 2645 #  ifdef PNG_GET_PALETTE_MAX_SUPPORTED
 2646 PNG_EXPORT(243, int, png_get_palette_max, (png_const_structp png_ptr,
 2647     png_const_infop info_ptr));
 2648 #  endif
 2649 #endif /* CHECK_FOR_INVALID_INDEX */
 2650 
 2651 /*******************************************************************************
 2652  * Section 5: SIMPLIFIED API
 2653  *******************************************************************************
 2654  *
 2655  * Please read the documentation in libpng-manual.txt (TODO: write said
 2656  * documentation) if you don't understand what follows.
 2657  *
 2658  * The simplified API hides the details of both libpng and the PNG file format
 2659  * itself.  It allows PNG files to be read into a very limited number of
 2660  * in-memory bitmap formats or to be written from the same formats.  If these
 2661  * formats do not accomodate your needs then you can, and should, use the more
 2662  * sophisticated APIs above - these support a wide variety of in-memory formats
 2663  * and a wide variety of sophisticated transformations to those formats as well
 2664  * as a wide variety of APIs to manipulate ancillary information.
 2665  *
 2666  * To read a PNG file using the simplified API:
 2667  *
 2668  * 1) Declare a 'png_image' structure (see below) on the stack, set the
 2669  *    version field to PNG_IMAGE_VERSION and the 'opaque' pointer to NULL
 2670  *    (this is REQUIRED, your program may crash if you don't do it.)
 2671  * 2) Call the appropriate png_image_begin_read... function.
 2672  * 3) Set the png_image 'format' member to the required sample format.
 2673  * 4) Allocate a buffer for the image and, if required, the color-map.
 2674  * 5) Call png_image_finish_read to read the image and, if required, the
 2675  *    color-map into your buffers.
 2676  *
 2677  * There are no restrictions on the format of the PNG input itself; all valid
 2678  * color types, bit depths, and interlace methods are acceptable, and the
 2679  * input image is transformed as necessary to the requested in-memory format
 2680  * during the png_image_finish_read() step.  The only caveat is that if you
 2681  * request a color-mapped image from a PNG that is full-color or makes
 2682  * complex use of an alpha channel the transformation is extremely lossy and the
 2683  * result may look terrible.
 2684  *
 2685  * To write a PNG file using the simplified API:
 2686  *
 2687  * 1) Declare a 'png_image' structure on the stack and memset() it to all zero.
 2688  * 2) Initialize the members of the structure that describe the image, setting
 2689  *    the 'format' member to the format of the image samples.
 2690  * 3) Call the appropriate png_image_write... function with a pointer to the
 2691  *    image and, if necessary, the color-map to write the PNG data.
 2692  *
 2693  * png_image is a structure that describes the in-memory format of an image
 2694  * when it is being read or defines the in-memory format of an image that you
 2695  * need to write:
 2696  */
 2697 #if defined(PNG_SIMPLIFIED_READ_SUPPORTED) || \
 2698     defined(PNG_SIMPLIFIED_WRITE_SUPPORTED)
 2699 
 2700 #define PNG_IMAGE_VERSION 1
 2701 
 2702 typedef struct png_control *png_controlp;
 2703 typedef struct
 2704 {
 2705    png_controlp opaque;    /* Initialize to NULL, free with png_image_free */
 2706    png_uint_32  version;   /* Set to PNG_IMAGE_VERSION */
 2707    png_uint_32  width;     /* Image width in pixels (columns) */
 2708    png_uint_32  height;    /* Image height in pixels (rows) */
 2709    png_uint_32  format;    /* Image format as defined below */
 2710    png_uint_32  flags;     /* A bit mask containing informational flags */
 2711    png_uint_32  colormap_entries;
 2712                            /* Number of entries in the color-map */
 2713 
 2714    /* In the event of an error or warning the following field will be set to a
 2715     * non-zero value and the 'message' field will contain a '\0' terminated
 2716     * string with the libpng error or warning message.  If both warnings and
 2717     * an error were encountered, only the error is recorded.  If there
 2718     * are multiple warnings, only the first one is recorded.
 2719     *
 2720     * The upper 30 bits of this value are reserved, the low two bits contain
 2721     * a value as follows:
 2722     */
 2723 #  define PNG_IMAGE_WARNING 1
 2724 #  define PNG_IMAGE_ERROR 2
 2725    /*
 2726     * The result is a two-bit code such that a value more than 1 indicates
 2727     * a failure in the API just called:
 2728     *
 2729     *    0 - no warning or error
 2730     *    1 - warning
 2731     *    2 - error
 2732     *    3 - error preceded by warning
 2733     */
 2734 #  define PNG_IMAGE_FAILED(png_cntrl) ((((png_cntrl).warning_or_error)&0x03)>1)
 2735 
 2736    png_uint_32  warning_or_error;
 2737 
 2738    char         message[64];
 2739 } png_image, *png_imagep;
 2740 
 2741 /* The samples of the image have one to four channels whose components have
 2742  * original values in the range 0 to 1.0:
 2743  *
 2744  * 1: A single gray or luminance channel (G).
 2745  * 2: A gray/luminance channel and an alpha channel (GA).
 2746  * 3: Three red, green, blue color channels (RGB).
 2747  * 4: Three color channels and an alpha channel (RGBA).
 2748  *
 2749  * The components are encoded in one of two ways:
 2750  *
 2751  * a) As a small integer, value 0..255, contained in a single byte.  For the
 2752  * alpha channel the original value is simply value/255.  For the color or
 2753  * luminance channels the value is encoded according to the sRGB specification
 2754  * and matches the 8-bit format expected by typical display devices.
 2755  *
 2756  * The color/gray channels are not scaled (pre-multiplied) by the alpha
 2757  * channel and are suitable for passing to color management software.
 2758  *
 2759  * b) As a value in the range 0..65535, contained in a 2-byte integer.  All
 2760  * channels can be converted to the original value by dividing by 65535; all
 2761  * channels are linear.  Color channels use the RGB encoding (RGB end-points) of
 2762  * the sRGB specification.  This encoding is identified by the
 2763  * PNG_FORMAT_FLAG_LINEAR flag below.
 2764  *
 2765  * When the simplified API needs to convert between sRGB and linear colorspaces,
 2766  * the actual sRGB transfer curve defined in the sRGB specification (see the
 2767  * article at https://en.wikipedia.org/wiki/SRGB) is used, not the gamma=1/2.2
 2768  * approximation used elsewhere in libpng.
 2769  *
 2770  * When an alpha channel is present it is expected to denote pixel coverage
 2771  * of the color or luminance channels and is returned as an associated alpha
 2772  * channel: the color/gray channels are scaled (pre-multiplied) by the alpha
 2773  * value.
 2774  *
 2775  * The samples are either contained directly in the image data, between 1 and 8
 2776  * bytes per pixel according to the encoding, or are held in a color-map indexed
 2777  * by bytes in the image data.  In the case of a color-map the color-map entries
 2778  * are individual samples, encoded as above, and the image data has one byte per
 2779  * pixel to select the relevant sample from the color-map.
 2780  */
 2781 
 2782 /* PNG_FORMAT_*
 2783  *
 2784  * #defines to be used in png_image::format.  Each #define identifies a
 2785  * particular layout of sample data and, if present, alpha values.  There are
 2786  * separate defines for each of the two component encodings.
 2787  *
 2788  * A format is built up using single bit flag values.  All combinations are
 2789  * valid.  Formats can be built up from the flag values or you can use one of
 2790  * the predefined values below.  When testing formats always use the FORMAT_FLAG
 2791  * macros to test for individual features - future versions of the library may
 2792  * add new flags.
 2793  *
 2794  * When reading or writing color-mapped images the format should be set to the
 2795  * format of the entries in the color-map then png_image_{read,write}_colormap
 2796  * called to read or write the color-map and set the format correctly for the
 2797  * image data.  Do not set the PNG_FORMAT_FLAG_COLORMAP bit directly!
 2798  *
 2799  * NOTE: libpng can be built with particular features disabled. If you see
 2800  * compiler errors because the definition of one of the following flags has been
 2801  * compiled out it is because libpng does not have the required support.  It is
 2802  * possible, however, for the libpng configuration to enable the format on just
 2803  * read or just write; in that case you may see an error at run time.  You can
 2804  * guard against this by checking for the definition of the appropriate
 2805  * "_SUPPORTED" macro, one of:
 2806  *
 2807  *    PNG_SIMPLIFIED_{READ,WRITE}_{BGR,AFIRST}_SUPPORTED
 2808  */
 2809 #define PNG_FORMAT_FLAG_ALPHA    0x01U /* format with an alpha channel */
 2810 #define PNG_FORMAT_FLAG_COLOR    0x02U /* color format: otherwise grayscale */
 2811 #define PNG_FORMAT_FLAG_LINEAR   0x04U /* 2-byte channels else 1-byte */
 2812 #define PNG_FORMAT_FLAG_COLORMAP 0x08U /* image data is color-mapped */
 2813 
 2814 #ifdef PNG_FORMAT_BGR_SUPPORTED
 2815 #  define PNG_FORMAT_FLAG_BGR    0x10U /* BGR colors, else order is RGB */
 2816 #endif
 2817 
 2818 #ifdef PNG_FORMAT_AFIRST_SUPPORTED
 2819 #  define PNG_FORMAT_FLAG_AFIRST 0x20U /* alpha channel comes first */
 2820 #endif
 2821 
 2822 /* Commonly used formats have predefined macros.
 2823  *
 2824  * First the single byte (sRGB) formats:
 2825  */
 2826 #define PNG_FORMAT_GRAY 0
 2827 #define PNG_FORMAT_GA   PNG_FORMAT_FLAG_ALPHA
 2828 #define PNG_FORMAT_AG   (PNG_FORMAT_GA|PNG_FORMAT_FLAG_AFIRST)
 2829 #define PNG_FORMAT_RGB  PNG_FORMAT_FLAG_COLOR
 2830 #define PNG_FORMAT_BGR  (PNG_FORMAT_FLAG_COLOR|PNG_FORMAT_FLAG_BGR)
 2831 #define PNG_FORMAT_RGBA (PNG_FORMAT_RGB|PNG_FORMAT_FLAG_ALPHA)
 2832 #define PNG_FORMAT_ARGB (PNG_FORMAT_RGBA|PNG_FORMAT_FLAG_AFIRST)
 2833 #define PNG_FORMAT_BGRA (PNG_FORMAT_BGR|PNG_FORMAT_FLAG_ALPHA)
 2834 #define PNG_FORMAT_ABGR (PNG_FORMAT_BGRA|PNG_FORMAT_FLAG_AFIRST)
 2835 
 2836 /* Then the linear 2-byte formats.  When naming these "Y" is used to
 2837  * indicate a luminance (gray) channel.
 2838  */
 2839 #define PNG_FORMAT_LINEAR_Y PNG_FORMAT_FLAG_LINEAR
 2840 #define PNG_FORMAT_LINEAR_Y_ALPHA (PNG_FORMAT_FLAG_LINEAR|PNG_FORMAT_FLAG_ALPHA)
 2841 #define PNG_FORMAT_LINEAR_RGB (PNG_FORMAT_FLAG_LINEAR|PNG_FORMAT_FLAG_COLOR)
 2842 #define PNG_FORMAT_LINEAR_RGB_ALPHA \
 2843    (PNG_FORMAT_FLAG_LINEAR|PNG_FORMAT_FLAG_COLOR|PNG_FORMAT_FLAG_ALPHA)
 2844 
 2845 /* With color-mapped formats the image data is one byte for each pixel, the byte
 2846  * is an index into the color-map which is formatted as above.  To obtain a
 2847  * color-mapped format it is sufficient just to add the PNG_FOMAT_FLAG_COLORMAP
 2848  * to one of the above definitions, or you can use one of the definitions below.
 2849  */
 2850 #define PNG_FORMAT_RGB_COLORMAP  (PNG_FORMAT_RGB|PNG_FORMAT_FLAG_COLORMAP)
 2851 #define PNG_FORMAT_BGR_COLORMAP  (PNG_FORMAT_BGR|PNG_FORMAT_FLAG_COLORMAP)
 2852 #define PNG_FORMAT_RGBA_COLORMAP (PNG_FORMAT_RGBA|PNG_FORMAT_FLAG_COLORMAP)
 2853 #define PNG_FORMAT_ARGB_COLORMAP (PNG_FORMAT_ARGB|PNG_FORMAT_FLAG_COLORMAP)
 2854 #define PNG_FORMAT_BGRA_COLORMAP (PNG_FORMAT_BGRA|PNG_FORMAT_FLAG_COLORMAP)
 2855 #define PNG_FORMAT_ABGR_COLORMAP (PNG_FORMAT_ABGR|PNG_FORMAT_FLAG_COLORMAP)
 2856 
 2857 /* PNG_IMAGE macros
 2858  *
 2859  * These are convenience macros to derive information from a png_image
 2860  * structure.  The PNG_IMAGE_SAMPLE_ macros return values appropriate to the
 2861  * actual image sample values - either the entries in the color-map or the
 2862  * pixels in the image.  The PNG_IMAGE_PIXEL_ macros return corresponding values
 2863  * for the pixels and will always return 1 for color-mapped formats.  The
 2864  * remaining macros return information about the rows in the image and the
 2865  * complete image.
 2866  *
 2867  * NOTE: All the macros that take a png_image::format parameter are compile time
 2868  * constants if the format parameter is, itself, a constant.  Therefore these
 2869  * macros can be used in array declarations and case labels where required.
 2870  * Similarly the macros are also pre-processor constants (sizeof is not used) so
 2871  * they can be used in #if tests.
 2872  *
 2873  * First the information about the samples.
 2874  */
 2875 #define PNG_IMAGE_SAMPLE_CHANNELS(fmt)\
 2876    (((fmt)&(PNG_FORMAT_FLAG_COLOR|PNG_FORMAT_FLAG_ALPHA))+1)
 2877    /* Return the total number of channels in a given format: 1..4 */
 2878 
 2879 #define PNG_IMAGE_SAMPLE_COMPONENT_SIZE(fmt)\
 2880    ((((fmt) & PNG_FORMAT_FLAG_LINEAR) >> 2)+1)
 2881    /* Return the size in bytes of a single component of a pixel or color-map
 2882     * entry (as appropriate) in the image: 1 or 2.
 2883     */
 2884 
 2885 #define PNG_IMAGE_SAMPLE_SIZE(fmt)\
 2886    (PNG_IMAGE_SAMPLE_CHANNELS(fmt) * PNG_IMAGE_SAMPLE_COMPONENT_SIZE(fmt))
 2887    /* This is the size of the sample data for one sample.  If the image is
 2888     * color-mapped it is the size of one color-map entry (and image pixels are
 2889     * one byte in size), otherwise it is the size of one image pixel.
 2890     */
 2891 
 2892 #define PNG_IMAGE_MAXIMUM_COLORMAP_COMPONENTS(fmt)\
 2893    (PNG_IMAGE_SAMPLE_CHANNELS(fmt) * 256)
 2894    /* The maximum size of the color-map required by the format expressed in a
 2895     * count of components.  This can be used to compile-time allocate a
 2896     * color-map:
 2897     *
 2898     * png_uint_16 colormap[PNG_IMAGE_MAXIMUM_COLORMAP_COMPONENTS(linear_fmt)];
 2899     *
 2900     * png_byte colormap[PNG_IMAGE_MAXIMUM_COLORMAP_COMPONENTS(sRGB_fmt)];
 2901     *
 2902     * Alternatively use the PNG_IMAGE_COLORMAP_SIZE macro below to use the
 2903     * information from one of the png_image_begin_read_ APIs and dynamically
 2904     * allocate the required memory.
 2905     */
 2906 
 2907 /* Corresponding information about the pixels */
 2908 #define PNG_IMAGE_PIXEL_(test,fmt)\
 2909    (((fmt)&PNG_FORMAT_FLAG_COLORMAP)?1:test(fmt))
 2910 
 2911 #define PNG_IMAGE_PIXEL_CHANNELS(fmt)\
 2912    PNG_IMAGE_PIXEL_(PNG_IMAGE_SAMPLE_CHANNELS,fmt)
 2913    /* The number of separate channels (components) in a pixel; 1 for a
 2914     * color-mapped image.
 2915     */
 2916 
 2917 #define PNG_IMAGE_PIXEL_COMPONENT_SIZE(fmt)\
 2918    PNG_IMAGE_PIXEL_(PNG_IMAGE_SAMPLE_COMPONENT_SIZE,fmt)
 2919    /* The size, in bytes, of each component in a pixel; 1 for a color-mapped
 2920     * image.
 2921     */
 2922 
 2923 #define PNG_IMAGE_PIXEL_SIZE(fmt) PNG_IMAGE_PIXEL_(PNG_IMAGE_SAMPLE_SIZE,fmt)
 2924    /* The size, in bytes, of a complete pixel; 1 for a color-mapped image. */
 2925 
 2926 /* Information about the whole row, or whole image */
 2927 #define PNG_IMAGE_ROW_STRIDE(image)\
 2928    (PNG_IMAGE_PIXEL_CHANNELS((image).format) * (image).width)
 2929    /* Return the total number of components in a single row of the image; this
 2930     * is the minimum 'row stride', the minimum count of components between each
 2931     * row.  For a color-mapped image this is the minimum number of bytes in a
 2932     * row.
 2933     *
 2934     * WARNING: this macro overflows for some images with more than one component
 2935     * and very large image widths.  libpng will refuse to process an image where
 2936     * this macro would overflow.
 2937     */
 2938 
 2939 #define PNG_IMAGE_BUFFER_SIZE(image, row_stride)\
 2940    (PNG_IMAGE_PIXEL_COMPONENT_SIZE((image).format)*(image).height*(row_stride))
 2941    /* Return the size, in bytes, of an image buffer given a png_image and a row
 2942     * stride - the number of components to leave space for in each row.
 2943     *
 2944     * WARNING: this macro overflows a 32-bit integer for some large PNG images,
 2945     * libpng will refuse to process an image where such an overflow would occur.
 2946     */
 2947 
 2948 #define PNG_IMAGE_SIZE(image)\
 2949    PNG_IMAGE_BUFFER_SIZE(image, PNG_IMAGE_ROW_STRIDE(image))
 2950    /* Return the size, in bytes, of the image in memory given just a png_image;
 2951     * the row stride is the minimum stride required for the image.
 2952     */
 2953 
 2954 #define PNG_IMAGE_COLORMAP_SIZE(image)\
 2955    (PNG_IMAGE_SAMPLE_SIZE((image).format) * (image).colormap_entries)
 2956    /* Return the size, in bytes, of the color-map of this image.  If the image
 2957     * format is not a color-map format this will return a size sufficient for
 2958     * 256 entries in the given format; check PNG_FORMAT_FLAG_COLORMAP if
 2959     * you don't want to allocate a color-map in this case.
 2960     */
 2961 
 2962 /* PNG_IMAGE_FLAG_*
 2963  *
 2964  * Flags containing additional information about the image are held in the
 2965  * 'flags' field of png_image.
 2966  */
 2967 #define PNG_IMAGE_FLAG_COLORSPACE_NOT_sRGB 0x01
 2968    /* This indicates the the RGB values of the in-memory bitmap do not
 2969     * correspond to the red, green and blue end-points defined by sRGB.
 2970     */
 2971 
 2972 #define PNG_IMAGE_FLAG_FAST 0x02
 2973    /* On write emphasise speed over compression; the resultant PNG file will be
 2974     * larger but will be produced significantly faster, particular for large
 2975     * images.  Do not use this option for images which will be distributed, only
 2976     * used it when producing intermediate files that will be read back in
 2977     * repeatedly.  For a typical 24-bit image the option will double the read
 2978     * speed at the cost of increasing the image size by 25%, however for many
 2979     * more compressible images the PNG file can be 10 times larger with only a
 2980     * slight speed gain.
 2981     */
 2982 
 2983 #define PNG_IMAGE_FLAG_16BIT_sRGB 0x04
 2984    /* On read if the image is a 16-bit per component image and there is no gAMA
 2985     * or sRGB chunk assume that the components are sRGB encoded.  Notice that
 2986     * images output by the simplified API always have gamma information; setting
 2987     * this flag only affects the interpretation of 16-bit images from an
 2988     * external source.  It is recommended that the application expose this flag
 2989     * to the user; the user can normally easily recognize the difference between
 2990     * linear and sRGB encoding.  This flag has no effect on write - the data
 2991     * passed to the write APIs must have the correct encoding (as defined
 2992     * above.)
 2993     *
 2994     * If the flag is not set (the default) input 16-bit per component data is
 2995     * assumed to be linear.
 2996     *
 2997     * NOTE: the flag can only be set after the png_image_begin_read_ call,
 2998     * because that call initializes the 'flags' field.
 2999     */
 3000 
 3001 #ifdef PNG_SIMPLIFIED_READ_SUPPORTED
 3002 /* READ APIs
 3003  * ---------
 3004  *
 3005  * The png_image passed to the read APIs must have been initialized by setting
 3006  * the png_controlp field 'opaque' to NULL (or, safer, memset the whole thing.)
 3007  */
 3008 #ifdef PNG_STDIO_SUPPORTED
 3009 PNG_EXPORT(234, int, png_image_begin_read_from_file, (png_imagep image,
 3010    const char *file_name));
 3011    /* The named file is opened for read and the image header is filled in
 3012     * from the PNG header in the file.
 3013     */
 3014 
 3015 PNG_EXPORT(235, int, png_image_begin_read_from_stdio, (png_imagep image,
 3016    FILE* file));
 3017    /* The PNG header is read from the stdio FILE object. */
 3018 #endif /* STDIO */
 3019 
 3020 PNG_EXPORT(236, int, png_image_begin_read_from_memory, (png_imagep image,
 3021    png_const_voidp memory, png_size_t size));
 3022    /* The PNG header is read from the given memory buffer. */
 3023 
 3024 PNG_EXPORT(237, int, png_image_finish_read, (png_imagep image,
 3025    png_const_colorp background, void *buffer, png_int_32 row_stride,
 3026    void *colormap));
 3027    /* Finish reading the image into the supplied buffer and clean up the
 3028     * png_image structure.
 3029     *
 3030     * row_stride is the step, in byte or 2-byte units as appropriate,
 3031     * between adjacent rows.  A positive stride indicates that the top-most row
 3032     * is first in the buffer - the normal top-down arrangement.  A negative
 3033     * stride indicates that the bottom-most row is first in the buffer.
 3034     *
 3035     * background need only be supplied if an alpha channel must be removed from
 3036     * a png_byte format and the removal is to be done by compositing on a solid
 3037     * color; otherwise it may be NULL and any composition will be done directly
 3038     * onto the buffer.  The value is an sRGB color to use for the background,
 3039     * for grayscale output the green channel is used.
 3040     *
 3041     * background must be supplied when an alpha channel must be removed from a
 3042     * single byte color-mapped output format, in other words if:
 3043     *
 3044     * 1) The original format from png_image_begin_read_from_* had
 3045     *    PNG_FORMAT_FLAG_ALPHA set.
 3046     * 2) The format set by the application does not.
 3047     * 3) The format set by the application has PNG_FORMAT_FLAG_COLORMAP set and
 3048     *    PNG_FORMAT_FLAG_LINEAR *not* set.
 3049     *
 3050     * For linear output removing the alpha channel is always done by compositing
 3051     * on black and background is ignored.
 3052     *
 3053     * colormap must be supplied when PNG_FORMAT_FLAG_COLORMAP is set.  It must
 3054     * be at least the size (in bytes) returned by PNG_IMAGE_COLORMAP_SIZE.
 3055     * image->colormap_entries will be updated to the actual number of entries
 3056     * written to the colormap; this may be less than the original value.
 3057     */
 3058 
 3059 PNG_EXPORT(238, void, png_image_free, (png_imagep image));
 3060    /* Free any data allocated by libpng in image->opaque, setting the pointer to
 3061     * NULL.  May be called at any time after the structure is initialized.
 3062     */
 3063 #endif /* SIMPLIFIED_READ */
 3064 
 3065 #ifdef PNG_SIMPLIFIED_WRITE_SUPPORTED
 3066 /* WRITE APIS
 3067  * ----------
 3068  * For write you must initialize a png_image structure to describe the image to
 3069  * be written.  To do this use memset to set the whole structure to 0 then
 3070  * initialize fields describing your image.
 3071  *
 3072  * version: must be set to PNG_IMAGE_VERSION
 3073  * opaque: must be initialized to NULL
 3074  * width: image width in pixels
 3075  * height: image height in rows
 3076  * format: the format of the data (image and color-map) you wish to write
 3077  * flags: set to 0 unless one of the defined flags applies; set
 3078  *    PNG_IMAGE_FLAG_COLORSPACE_NOT_sRGB for color format images where the RGB
 3079  *    values do not correspond to the colors in sRGB.
 3080  * colormap_entries: set to the number of entries in the color-map (0 to 256)
 3081  */
 3082 #ifdef PNG_SIMPLIFIED_WRITE_STDIO_SUPPORTED
 3083 PNG_EXPORT(239, int, png_image_write_to_file, (png_imagep image,
 3084    const char *file, int convert_to_8bit, const void *buffer,
 3085    png_int_32 row_stride, const void *colormap));
 3086    /* Write the image to the named file. */
 3087 
 3088 PNG_EXPORT(240, int, png_image_write_to_stdio, (png_imagep image, FILE *file,
 3089    int convert_to_8_bit, const void *buffer, png_int_32 row_stride,
 3090    const void *colormap));
 3091    /* Write the image to the given (FILE*). */
 3092 #endif /* SIMPLIFIED_WRITE_STDIO */
 3093 
 3094 /* With all write APIs if image is in one of the linear formats with 16-bit
 3095  * data then setting convert_to_8_bit will cause the output to be an 8-bit PNG
 3096  * gamma encoded according to the sRGB specification, otherwise a 16-bit linear
 3097  * encoded PNG file is written.
 3098  *
 3099  * With color-mapped data formats the colormap parameter point to a color-map
 3100  * with at least image->colormap_entries encoded in the specified format.  If
 3101  * the format is linear the written PNG color-map will be converted to sRGB
 3102  * regardless of the convert_to_8_bit flag.
 3103  *
 3104  * With all APIs row_stride is handled as in the read APIs - it is the spacing
 3105  * from one row to the next in component sized units (1 or 2 bytes) and if
 3106  * negative indicates a bottom-up row layout in the buffer.  If row_stride is
 3107  * zero, libpng will calculate it for you from the image width and number of
 3108  * channels.
 3109  *
 3110  * Note that the write API does not support interlacing, sub-8-bit pixels or
 3111  * most ancillary chunks.  If you need to write text chunks (e.g. for copyright
 3112  * notices) you need to use one of the other APIs.
 3113  */
 3114 
 3115 PNG_EXPORT(245, int, png_image_write_to_memory, (png_imagep image, void *memory,
 3116    png_alloc_size_t * PNG_RESTRICT memory_bytes, int convert_to_8_bit,
 3117    const void *buffer, png_int_32 row_stride, const void *colormap));
 3118    /* Write the image to the given memory buffer.  The function both writes the
 3119     * whole PNG data stream to *memory and updates *memory_bytes with the count
 3120     * of bytes written.
 3121     *
 3122     * 'memory' may be NULL.  In this case *memory_bytes is not read however on
 3123     * success the number of bytes which would have been written will still be
 3124     * stored in *memory_bytes.  On failure *memory_bytes will contain 0.
 3125     *
 3126     * If 'memory' is not NULL it must point to memory[*memory_bytes] of
 3127     * writeable memory.
 3128     *
 3129     * If the function returns success memory[*memory_bytes] (if 'memory' is not
 3130     * NULL) contains the written PNG data.  *memory_bytes will always be less
 3131     * than or equal to the original value.
 3132     *
 3133     * If the function returns false and *memory_bytes was not changed an error
 3134     * occured during write.  If *memory_bytes was changed, or is not 0 if
 3135     * 'memory' was NULL, the write would have succeeded but for the memory
 3136     * buffer being too small.  *memory_bytes contains the required number of
 3137     * bytes and will be bigger that the original value.
 3138     */
 3139 
 3140 #define png_image_write_get_memory_size(image, size, convert_to_8_bit, buffer,\
 3141    row_stride, colormap)\
 3142    png_image_write_to_memory(&(image), 0, &(size), convert_to_8_bit, buffer,\
 3143          row_stride, colormap)
 3144    /* Return the amount of memory in 'size' required to compress this image.
 3145     * The png_image structure 'image' must be filled in as in the above
 3146     * function and must not be changed before the actual write call, the buffer
 3147     * and all other parameters must also be identical to that in the final
 3148     * write call.  The 'size' variable need not be initialized.
 3149     *
 3150     * NOTE: the macro returns true/false, if false is returned 'size' will be
 3151     * set to zero and the write failed and probably will fail if tried again.
 3152     */
 3153 
 3154 /* You can pre-allocate the buffer by making sure it is of sufficient size
 3155  * regardless of the amount of compression achieved.  The buffer size will
 3156  * always be bigger than the original image and it will never be filled.  The
 3157  * following macros are provided to assist in allocating the buffer.
 3158  */
 3159 #define PNG_IMAGE_DATA_SIZE(image) (PNG_IMAGE_SIZE(image)+(image).height)
 3160    /* The number of uncompressed bytes in the PNG byte encoding of the image;
 3161     * uncompressing the PNG IDAT data will give this number of bytes.
 3162     *
 3163     * NOTE: while PNG_IMAGE_SIZE cannot overflow for an image in memory this
 3164     * macro can because of the extra bytes used in the PNG byte encoding.  You
 3165     * need to avoid this macro if your image size approaches 2^30 in width or
 3166     * height.  The same goes for the remainder of these macros; they all produce
 3167     * bigger numbers than the actual in-memory image size.
 3168     */
 3169 #ifndef PNG_ZLIB_MAX_SIZE
 3170 #  define PNG_ZLIB_MAX_SIZE(b) ((b)+(((b)+7U)>>3)+(((b)+63U)>>6)+11U)
 3171    /* An upper bound on the number of compressed bytes given 'b' uncompressed
 3172     * bytes.  This is based on deflateBounds() in zlib; different
 3173     * implementations of zlib compression may conceivably produce more data so
 3174     * if your zlib implementation is not zlib itself redefine this macro
 3175     * appropriately.
 3176     */
 3177 #endif
 3178 
 3179 #define PNG_IMAGE_COMPRESSED_SIZE_MAX(image)\
 3180    PNG_ZLIB_MAX_SIZE((png_alloc_size_t)PNG_IMAGE_DATA_SIZE(image))
 3181    /* An upper bound on the size of the data in the PNG IDAT chunks. */
 3182 
 3183 #define PNG_IMAGE_PNG_SIZE_MAX_(image, image_size)\
 3184    ((8U/*sig*/+25U/*IHDR*/+16U/*gAMA*/+44U/*cHRM*/+12U/*IEND*/+\
 3185     (((image).format&PNG_FORMAT_FLAG_COLORMAP)?/*colormap: PLTE, tRNS*/\
 3186     12U+3U*(image).colormap_entries/*PLTE data*/+\
 3187     (((image).format&PNG_FORMAT_FLAG_ALPHA)?\
 3188     12U/*tRNS*/+(image).colormap_entries:0U):0U)+\
 3189     12U)+(12U*((image_size)/PNG_ZBUF_SIZE))/*IDAT*/+(image_size))
 3190    /* A helper for the following macro; if your compiler cannot handle the
 3191     * following macro use this one with the result of
 3192     * PNG_IMAGE_COMPRESSED_SIZE_MAX(image) as the second argument (most
 3193     * compilers should handle this just fine.)
 3194     */
 3195 
 3196 #define PNG_IMAGE_PNG_SIZE_MAX(image)\
 3197    PNG_IMAGE_PNG_SIZE_MAX_(image, PNG_IMAGE_COMPRESSED_SIZE_MAX(image))
 3198    /* An upper bound on the total length of the PNG data stream for 'image'.
 3199     * The result is of type png_alloc_size_t, on 32-bit systems this may
 3200     * overflow even though PNG_IMAGE_DATA_SIZE does not overflow; the write will
 3201     * run out of buffer space but return a corrected size which should work.
 3202     */
 3203 #endif /* SIMPLIFIED_WRITE */
 3204 /*******************************************************************************
 3205  *  END OF SIMPLIFIED API
 3206  ******************************************************************************/
 3207 #endif /* SIMPLIFIED_{READ|WRITE} */
 3208 
 3209 /*******************************************************************************
 3210  * Section 6: IMPLEMENTATION OPTIONS
 3211  *******************************************************************************
 3212  *
 3213  * Support for arbitrary implementation-specific optimizations.  The API allows
 3214  * particular options to be turned on or off.  'Option' is the number of the
 3215  * option and 'onoff' is 0 (off) or non-0 (on).  The value returned is given
 3216  * by the PNG_OPTION_ defines below.
 3217  *
 3218  * HARDWARE: normally hardware capabilites, such as the Intel SSE instructions,
 3219  *           are detected at run time, however sometimes it may be impossible
 3220  *           to do this in user mode, in which case it is necessary to discover
 3221  *           the capabilities in an OS specific way.  Such capabilities are
 3222  *           listed here when libpng has support for them and must be turned
 3223  *           ON by the application if present.
 3224  *
 3225  * SOFTWARE: sometimes software optimizations actually result in performance
 3226  *           decrease on some architectures or systems, or with some sets of
 3227  *           PNG images.  'Software' options allow such optimizations to be
 3228  *           selected at run time.
 3229  */
 3230 #ifdef PNG_SET_OPTION_SUPPORTED
 3231 #ifdef PNG_ARM_NEON_API_SUPPORTED
 3232 #  define PNG_ARM_NEON   0 /* HARDWARE: ARM Neon SIMD instructions supported */
 3233 #endif
 3234 #define PNG_MAXIMUM_INFLATE_WINDOW 2 /* SOFTWARE: force maximum window */
 3235 #define PNG_SKIP_sRGB_CHECK_PROFILE 4 /* SOFTWARE: Check ICC profile for sRGB */
 3236 #ifdef PNG_MIPS_MSA_API_SUPPORTED
 3237 #  define PNG_MIPS_MSA   6 /* HARDWARE: MIPS Msa SIMD instructions supported */
 3238 #endif
 3239 #define PNG_IGNORE_ADLER32 8
 3240 #ifdef PNG_POWERPC_VSX_API_SUPPORTED
 3241 #  define PNG_POWERPC_VSX   10 /* HARDWARE: PowerPC VSX SIMD instructions supported */
 3242 #endif
 3243 #define PNG_OPTION_NEXT  12 /* Next option - numbers must be even */
 3244 
 3245 /* Return values: NOTE: there are four values and 'off' is *not* zero */
 3246 #define PNG_OPTION_UNSET   0 /* Unset - defaults to off */
 3247 #define PNG_OPTION_INVALID 1 /* Option number out of range */
 3248 #define PNG_OPTION_OFF     2
 3249 #define PNG_OPTION_ON      3
 3250 
 3251 PNG_EXPORT(244, int, png_set_option, (png_structrp png_ptr, int option,
 3252    int onoff));
 3253 #endif /* SET_OPTION */
 3254 
 3255 /*******************************************************************************
 3256  *  END OF HARDWARE AND SOFTWARE OPTIONS
 3257  ******************************************************************************/
 3258 
 3259 /* Maintainer: Put new public prototypes here ^, in libpng.3, in project
 3260  * defs, and in scripts/symbols.def.
 3261  */
 3262 
 3263 /* The last ordinal number (this is the *last* one already used; the next
 3264  * one to use is one more than this.)
 3265  */
 3266 #ifdef PNG_EXPORT_LAST_ORDINAL
 3267   PNG_EXPORT_LAST_ORDINAL(249);
 3268 #endif
 3269 
 3270 #ifdef __cplusplus
 3271 }
 3272 #endif
 3273 
 3274 #endif /* PNG_VERSION_INFO_ONLY */
 3275 /* Do not put anything past this line */
 3276 #endif /* PNG_H */