Subversion Repositories Kolibri OS

 *

 * libpng version 1.0.12 - June 8, 2001

 * Copyright (c) 1998-2001 Glenn Randers-Pehrson

 * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)

 * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)

 *

 * Authors and maintainers:

 *  libpng versions 0.71, May 1995, through 0.88, January 1996: Guy Schalnat

 *  libpng versions 0.89c, June 1996, through 0.96, May 1997: Andreas Dilger

 *  libpng versions 0.97, January 1998, through 1.0.12 - June 8, 2001: Glenn

 *  See also "Contributing Authors", below.

 *

 * Note about libpng version numbers:

 *

 *    Due to various miscommunications, unforeseen code incompatibilities

 *    and occasional factors outside the authors' control, version numbering

 *    on the library has not always been consistent and straightforward.

 *    The following table summarizes matters since version 0.89c, which was

 *    the first widely used release:

 *

 *    source                 png.h  png.h  shared-lib

 *    version                string   int  version

 *    -------                ------ -----  ----------

 *    0.89c "1.0 beta 3"     0.89      89  1.0.89

 *    0.90  "1.0 beta 4"     0.90      90  0.90  [should have been 2.0.90]

 *    0.95  "1.0 beta 5"     0.95      95  0.95  [should have been 2.0.95]

 *    0.96  "1.0 beta 6"     0.96      96  0.96  [should have been 2.0.96]

 *    0.97b "1.00.97 beta 7" 1.00.97   97  1.0.1 [should have been 2.0.97]

 *    0.97c                  0.97      97  2.0.97

 *    0.98                   0.98      98  2.0.98

 *    0.99                   0.99      98  2.0.99

 *    0.99a-m                0.99      99  2.0.99

 *    1.00                   1.00     100  2.1.0 [100 should be 10000]

 *    1.0.0      (from here on, the   100  2.1.0 [100 should be 10000]

 *    1.0.1       png.h string is   10001  2.1.0

 *    1.0.1a-e    identical to the  10002  from here on, the shared library

 *    1.0.2       source version)   10002  is 2.V where V is the source code

 *    1.0.2a-b                      10003  version, except as noted.

 *    1.0.3                         10003

 *    1.0.3a-d                      10004

 *    1.0.4                         10004

 *    1.0.4a-f                      10005

 *    1.0.5 (+ 2 patches)           10005

 *    1.0.5a-d                      10006

 *    1.0.5e-r                      10100 (not source compatible)

 *    1.0.5s-v                      10006 (not binary compatible)

 *    1.0.6 (+ 3 patches)           10006 (still binary incompatible)

 *    1.0.6d-f                      10007 (still binary incompatible)

 *    1.0.6g                        10007

 *    1.0.6h                        10007  10.6h (testing xy.z so-numbering)

 *    1.0.6i                        10007  10.6i

 *    1.0.6j                        10007  2.1.0.6j (incompatible with 1.0.0)

 *    1.0.7beta11-14        DLLNUM  10007  2.1.0.7beta11-14 (binary compatible)

 *    1.0.7beta15-18           1    10007  2.1.0.7beta15-18 (binary compatible)

 *    1.0.7rc1-2               1    10007  2.1.0.7rc1-2 (binary compatible)

 *    1.0.7                    1    10007  (still compatible)

 *    1.0.8beta1-4             1    10008  2.1.0.8beta1-4

 *    1.0.8rc1                 1    10008  2.1.0.8rc1

 *    1.0.8                    1    10008  2.1.0.8

 *    1.0.9beta1-6             1    10009  2.1.0.9beta1-6

 *    1.0.9rc1                 1    10009  2.1.0.9rc1

 *    1.0.9beta7-10            1    10009  2.1.0.9beta7-10

 *    1.0.9rc2                 1    10009  2.1.0.9rc2

 *    1.0.9                    1    10009  2.1.0.9

 *    1.0.10beta1              1    10010  2.1.0.10beta1

 *    1.0.10rc1                1    10010  2.1.0.10rc1

 *    1.0.10                   1    10010  2.1.0.10

 *    1.0.11beta1-3            1    10011  2.1.0.11beta1-3

 *    1.0.11rc1                1    10011  2.1.0.11rc1

 *    1.0.11                   1    10011  2.1.0.11

 *    1.0.12beta1-2            2    10012  2.1.0.11beta1-2

 *

 *    Henceforth the source version will match the shared-library major

 *    and minor numbers; the shared-library major version number will be

 *    used for changes in backward compatibility, as it is intended.  The

 *    PNG_LIBPNG_VER macro, which is not used within libpng but is available

 *    for applications, is an unsigned integer of the form xyyzz corresponding

 *    to the source version x.y.z (leading zeros in y and z).  Beta versions

 *    were given the previous public release number plus a letter, until

 *    version 1.0.6j; from then on they were given the upcoming public

 *    release number plus "betaNN" or "rcN".

 *

 *    Binary incompatibility exists only when applications make direct access

 *    to the info_ptr or png_ptr members through png.h, and the compiled

 *    application is loaded with a different version of the library.

 *

 *    DLLNUM will change each time there are forward or backward changes

 *    in binary compatibility (e.g., when a new feature is added).

 *

 * See libpng.txt or libpng.3 for more information.  The PNG specification

 * is available as RFC 2083 

 * and as a W3C Recommendation 

 */

 * COPYRIGHT NOTICE, DISCLAIMER, and LICENSE:

 *

 * If you modify libpng you may insert additional notices immediately following

 * this sentence.

 *

 * libpng versions 1.0.7, July 1, 2000, through  1.0.12, June 8, 2001, are

 * Copyright (c) 2000, 2001 Glenn Randers-Pehrson, and are

 * distributed according to the same disclaimer and license as libpng-1.0.6

 * with the following individuals added to the list of Contributing Authors

 *

 *    Simon-Pierre Cadieux

 *    Eric S. Raymond

 *    Gilles Vollant

 *

 * and with the following additions to the disclaimer:

 *

 *    There is no warranty against interference with your enjoyment of the

 *    library or against infringement.  There is no warranty that our

 *    efforts or the library will fulfill any of your particular purposes

 *    or needs.  This library is provided with all faults, and the entire

 *    risk of satisfactory quality, performance, accuracy, and effort is with

 *    the user.

 *

 * libpng versions 0.97, January 1998, through 1.0.6, March 20, 2000, are

 * Copyright (c) 1998, 1999, 2000 Glenn Randers-Pehrson

 * Distributed according to the same disclaimer and license as libpng-0.96,

 * with the following individuals added to the list of Contributing Authors:

 *

 *    Tom Lane

 *    Glenn Randers-Pehrson

 *    Willem van Schaik

 *

 * libpng versions 0.89, June 1996, through 0.96, May 1997, are

 * Copyright (c) 1996, 1997 Andreas Dilger

 * Distributed according to the same disclaimer and license as libpng-0.88,

 * with the following individuals added to the list of Contributing Authors:

 *

 *    John Bowler

 *    Kevin Bracey

 *    Sam Bushell

 *    Magnus Holmgren

 *    Greg Roelofs

 *    Tom Tanner

 *

 * libpng versions 0.5, May 1995, through 0.88, January 1996, are

 * Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.

 *

 * For the purposes of this copyright and license, "Contributing Authors"

 * is defined as the following set of individuals:

 *

 *    Andreas Dilger

 *    Dave Martindale

 *    Guy Eric Schalnat

 *    Paul Schmidt

 *    Tim Wegner

 *

 * The PNG Reference Library is supplied "AS IS".  The Contributing Authors

 * and Group 42, Inc. disclaim all warranties, expressed or implied,

 * including, without limitation, the warranties of merchantability and of

 * fitness for any purpose.  The Contributing Authors and Group 42, Inc.

 * assume no liability for direct, indirect, incidental, special, exemplary,

 * or consequential damages, which may result from the use of the PNG

 * Reference Library, even if advised of the possibility of such damage.

 *

 * Permission is hereby granted to use, copy, modify, and distribute this

 * source code, or portions hereof, for any purpose, without fee, subject

 * to the following restrictions:

 *

 * 1. The origin of this source code must not be misrepresented.

 *

 * 2. Altered versions must be plainly marked as such and

 * must not be misrepresented as being the original source.

 *

 * 3. This Copyright notice may not be removed or altered from

 *    any source or altered source distribution.

 *

 * The Contributing Authors and Group 42, Inc. specifically permit, without

 * fee, and encourage the use of this source code as a component to

 * supporting the PNG file format in commercial products.  If you use this

 * source code in a product, acknowledgment is not required but would be

 * appreciated.

 */

 * A "png_get_copyright" function is available, for convenient use in "about"

 * boxes and the like:

 *

 * printf("%s",png_get_copyright(NULL));

 *

 * Also, the PNG logo (in PNG format, of course) is supplied in the

 * files "pngbar.png" and "pngbar.jpg (88x31) and "pngnow.png" (98x31).

 */

 * Libpng is OSI Certified Open Source Software.  OSI Certified is a

 * certification mark of the Open Source Initiative.

 */

 * The contributing authors would like to thank all those who helped

 * with testing, bug fixes, and patience.  This wouldn't have been

 * possible without all of you.

 *

 * Thanks to Frank J. T. Wojcik for helping with the documentation.

 */

 * Y2K compliance in libpng:

 * =========================

 *

 *    June 8, 2001

 *

 *    Since the PNG Development group is an ad-hoc body, we can't make

 *    an official declaration.

 *

 *    This is your unofficial assurance that libpng from version 0.71 and

 *    upward through 1.0.12 are Y2K compliant.  It is my belief that earlier

 *    versions were also Y2K compliant.

 *

 *    Libpng only has three year fields.  One is a 2-byte unsigned integer

 *    that will hold years up to 65535.  The other two hold the date in text

 *    format, and will hold years up to 9999.

 *

 *    The integer is

 *        "png_uint_16 year" in png_time_struct.

 *

 *    The strings are

 *        "png_charp time_buffer" in png_struct and

 *        "near_time_buffer", which is a local character string in png.c.

 *

 *    There are seven time-related functions:

 *        png.c: png_convert_to_rfc_1123() in png.c

 *          (formerly png_convert_to_rfc_1152() in error)

 *        png_convert_from_struct_tm() in pngwrite.c, called in pngwrite.c

 *        png_convert_from_time_t() in pngwrite.c

 *        png_get_tIME() in pngget.c

 *        png_handle_tIME() in pngrutil.c, called in pngread.c

 *        png_set_tIME() in pngset.c

 *        png_write_tIME() in pngwutil.c, called in pngwrite.c

 *

 *    All handle dates properly in a Y2K environment.  The

 *    png_convert_from_time_t() function calls gmtime() to convert from system

 *    clock time, which returns (year - 1900), which we properly convert to

 *    the full 4-digit year.  There is a possibility that applications using

 *    libpng are not passing 4-digit years into the png_convert_to_rfc_1123()

 *    function, or that they are incorrectly passing only a 2-digit year

 *    instead of "year - 1900" into the png_convert_from_struct_tm() function,

 *    but this is not under our control.  The libpng documentation has always

 *    stated that it works with 4-digit years, and the APIs have been

 *    documented as such.

 *

 *    The tIME chunk itself is also Y2K compliant.  It uses a 2-byte unsigned

 *    integer to hold the year, and can hold years as large as 65535.

 *

 *    zlib, upon which libpng depends, is also Y2K compliant.  It contains

 *    no date-related code.

 *

 *       Glenn Randers-Pehrson

 *       libpng maintainer

 *       PNG Development Group

 */

#define PNG_H

 * describes how to use libpng, and the file example.c summarizes it

 * with some code on which to build.  This file is useful for looking

 * at the actual function definitions and structure components.

 */

#define PNG_LIBPNG_VER_STRING "1.0.12"

#define PNG_LIBPNG_VER_DLLNUM  %DLLNUM%

#define PNG_LIBPNG_VER_MAJOR   1

#define PNG_LIBPNG_VER_MINOR   0

#define PNG_LIBPNG_VER_RELEASE 12

/* This should match the numeric part of the final component of

 * PNG_LIBPNG_VER_STRING, omitting any leading zero: */

#define PNG_LIBPNG_BUILD_BETA     2

#define PNG_LIBPNG_BUILD_RC       3

#define PNG_LIBPNG_BUILD_STABLE   4

#define PNG_LIBPNG_BUILD_TYPEMASK 7

#define PNG_LIBPNG_BUILD_PATCH    8 /* Can be OR'ed with STABLE only */

#define PNG_LIBPNG_BUILD_TYPE 4

 * We must not include leading zeros.

 * Versions 0.7 through 1.0.0 were in the range 0 to 100 here (only

 * version 1.0.0 was mis-numbered 100 instead of 10000).  From

 * version 1.0.1 it's    xxyyzz, where x=major, y=minor, z=release */

#define PNG_LIBPNG_VER 10012 /* 1.0.12 */

#include "zlib.h"

#include "pngconf.h"

#ifdef __cplusplus

extern "C" {

#endif /* __cplusplus */

 * structure and type definitions.  The second section contains the external

 * library functions, while the third has the internal library functions,

 * which applications aren't expected to use directly.

 */

#if !defined(PNG_NO_EXTERN) || defined(PNG_ALWAYS_EXTERN)

/* Version information for C files, stored in png.c.  This had better match

 * the version above.

 */

#ifdef PNG_USE_GLOBAL_ARRAYS

PNG_EXPORT_VAR (const char) png_libpng_ver[18];

  /* need room for 99.99.99beta99z*/

#else

#define png_libpng_ver png_get_header_ver(NULL)

#endif

/* This was removed in version 1.0.5c */

/* Structures to facilitate easy interlacing.  See png.c for more details */

PNG_EXPORT_VAR (const int FARDATA) png_pass_start[7];

PNG_EXPORT_VAR (const int FARDATA) png_pass_inc[7];

PNG_EXPORT_VAR (const int FARDATA) png_pass_ystart[7];

PNG_EXPORT_VAR (const int FARDATA) png_pass_yinc[7];

PNG_EXPORT_VAR (const int FARDATA) png_pass_mask[7];

PNG_EXPORT_VAR (const int FARDATA) png_pass_dsp_mask[7];

#ifdef PNG_HAVE_ASSEMBLER_COMBINE_ROW

PNG_EXPORT_VAR (const int FARDATA) png_pass_width[7];

#endif

/* This isn't currently used.  If you need it, see png.c for more details.

PNG_EXPORT_VAR (const int FARDATA) png_pass_height[7];

*/

#endif

 * exact size) is not important, although the size of the fields need to

 * be png_byte or png_uint_16 (as defined below).

 */

typedef struct png_color_struct

{

   png_byte red;

   png_byte green;

   png_byte blue;

} png_color;

typedef png_color FAR * png_colorp;

typedef png_color FAR * FAR * png_colorpp;

{

   png_byte index;    /* used for palette files */

   png_uint_16 red;   /* for use in red green blue files */

   png_uint_16 green;

   png_uint_16 blue;

   png_uint_16 gray;  /* for use in grayscale files */

} png_color_16;

typedef png_color_16 FAR * png_color_16p;

typedef png_color_16 FAR * FAR * png_color_16pp;

{

   png_byte red;   /* for use in red green blue files */

   png_byte green;

   png_byte blue;

   png_byte gray;  /* for use in grayscale files */

   png_byte alpha; /* for alpha channel files */

} png_color_8;

typedef png_color_8 FAR * png_color_8p;

typedef png_color_8 FAR * FAR * png_color_8pp;

 * The following two structures are used for the in-core representation

 * of sPLT chunks.

 */

typedef struct png_sPLT_entry_struct

{

   png_uint_16 red;

   png_uint_16 green;

   png_uint_16 blue;

   png_uint_16 alpha;

   png_uint_16 frequency;

} png_sPLT_entry;

typedef png_sPLT_entry FAR * png_sPLT_entryp;

typedef png_sPLT_entry FAR * FAR * png_sPLT_entrypp;

 *  occupy the LSB of their respective members, and the MSB of each member

 *  is zero-filled.  The frequency member always occupies the full 16 bits.

 */

{

   png_charp name;           /* palette name */

   png_byte depth;           /* depth of palette samples */

   png_sPLT_entryp entries;  /* palette entries */

   png_int_32 nentries;      /* number of palette entries */

} png_sPLT_t;

typedef png_sPLT_t FAR * png_sPLT_tp;

typedef png_sPLT_t FAR * FAR * png_sPLT_tpp;

/* png_text holds the contents of a text/ztxt/itxt chunk in a PNG file,

 * and whether that contents is compressed or not.  The "key" field

 * points to a regular zero-terminated C string.  The "text", "lang", and

 * "lang_key" fields can be regular C strings, empty strings, or NULL pointers.

 * However, the * structure returned by png_get_text() will always contain

 * regular zero-terminated C strings (possibly empty), never NULL pointers,

 * so they can be safely used in printf() and other string-handling functions.

 */

typedef struct png_text_struct

{

   int  compression;       /* compression value:

                             -1: tEXt, none

                              0: zTXt, deflate

                              1: iTXt, none

                              2: iTXt, deflate  */

   png_charp key;          /* keyword, 1-79 character description of "text" */

   png_charp text;         /* comment, may be an empty string (ie "")

                              or a NULL pointer */

   png_size_t text_length; /* length of the text string */

#ifdef PNG_iTXt_SUPPORTED

   png_size_t itxt_length; /* length of the itxt string */

   png_charp lang;         /* language code, 0-79 characters

                              or a NULL pointer */

   png_charp lang_key;     /* keyword translated UTF-8 string, 0 or more

                              chars or a NULL pointer */

#endif

} png_text;

typedef png_text FAR * png_textp;

typedef png_text FAR * FAR * png_textpp;

#endif

 * The values of the PNG_TEXT_COMPRESSION_ defines should NOT be changed. */

#define PNG_TEXT_COMPRESSION_NONE_WR -3

#define PNG_TEXT_COMPRESSION_zTXt_WR -2

#define PNG_TEXT_COMPRESSION_NONE    -1

#define PNG_TEXT_COMPRESSION_zTXt     0

#define PNG_ITXT_COMPRESSION_NONE     1

#define PNG_ITXT_COMPRESSION_zTXt     2

#define PNG_TEXT_COMPRESSION_LAST     3  /* Not a valid value */

 * Two conversions are provided, both from time_t and struct tm.  There

 * is no portable way to convert to either of these structures, as far

 * as I know.  If you know of a portable way, send it to me.  As a side

 * note - PNG has always been Year 2000 compliant!

 */

typedef struct png_time_struct

{

   png_uint_16 year; /* full year, as in, 1995 */

   png_byte month;   /* month of year, 1 - 12 */

   png_byte day;     /* day of month, 1 - 31 */

   png_byte hour;    /* hour of day, 0 - 23 */

   png_byte minute;  /* minute of hour, 0 - 59 */

   png_byte second;  /* second of minute, 0 - 60 (for leap seconds) */

} png_time;

typedef png_time FAR * png_timep;

typedef png_time FAR * FAR * png_timepp;

/* png_unknown_chunk is a structure to hold queued chunks for which there is

 * no specific support.  The idea is that we can use this to queue

 * up private chunks for output even though the library doesn't actually

 * know about their semantics.

 */

typedef struct png_unknown_chunk_t

{

    png_byte name[5];

    png_byte *data;

    png_size_t size;

    png_byte location; /* mode of operation at read time */

}

png_unknown_chunk;

typedef png_unknown_chunk FAR * png_unknown_chunkp;

typedef png_unknown_chunk FAR * FAR * png_unknown_chunkpp;

#endif

 * that the application can find out the characteristics of the image.

 * If you are reading the file, this structure will tell you what is

 * in the PNG file.  If you are writing the file, fill in the information

 * you want to put into the PNG file, then call png_write_info().

 * The names chosen should be very close to the PNG specification, so

 * consult that document for information about the meaning of each field.

 *

 * With libpng < 0.95, it was only possible to directly set and read the

 * the values in the png_info_struct, which meant that the contents and

 * order of the values had to remain fixed.  With libpng 0.95 and later,

 * however, there are now functions that abstract the contents of

 * png_info_struct from the application, so this makes it easier to use

 * libpng with dynamic libraries, and even makes it possible to use

 * libraries that don't have all of the libpng ancillary chunk-handing

 * functionality.

 *

 * In any case, the order of the parameters in png_info_struct should NOT

 * be changed for as long as possible to keep compatibility with applications

 * that use the old direct-access method with png_info_struct.

 *

 * The following members may have allocated storage attached that should be

 * cleaned up before the structure is discarded: palette, trans, text,

 * pcal_purpose, pcal_units, pcal_params, hist, iccp_name, iccp_profile,

 * splt_palettes, scal_unit, row_pointers, and unknowns.   By default, these

 * are automatically freed when the info structure is deallocated, if they were

 * allocated internally by libpng.  This behavior can be changed by means

 * of the png_data_freer() function.

 *

 * More allocation details: all the chunk-reading functions that

 * change these members go through the corresponding png_set_*

 * functions.  A function to clear these members is available: see

 * png_free_data().  The png_set_* functions do not depend on being

 * able to point info structure members to any of the storage they are

 * passed (they make their own copies), EXCEPT that the png_set_text

 * functions use the same storage passed to them in the text_ptr or

 * itxt_ptr structure argument, and the png_set_rows and png_set_unknowns

 * functions do not make their own copies.

 */

typedef struct png_info_struct

{

   /* the following are necessary for every PNG file */

   png_uint_32 width;       /* width of image in pixels (from IHDR) */

   png_uint_32 height;      /* height of image in pixels (from IHDR) */

   png_uint_32 valid;       /* valid chunk data (see PNG_INFO_ below) */

   png_uint_32 rowbytes;    /* bytes needed to hold an untransformed row */

   png_colorp palette;      /* array of color values (valid & PNG_INFO_PLTE) */

   png_uint_16 num_palette; /* number of color entries in "palette" (PLTE) */

   png_uint_16 num_trans;   /* number of transparent palette color (tRNS) */

   png_byte bit_depth;      /* 1, 2, 4, 8, or 16 bits/channel (from IHDR) */

   png_byte color_type;     /* see PNG_COLOR_TYPE_ below (from IHDR) */

   /* The following three should have been named *_method not *_type */

   png_byte compression_type; /* must be PNG_COMPRESSION_TYPE_BASE (IHDR) */

   png_byte filter_type;    /* must be PNG_FILTER_TYPE_BASE (from IHDR) */

   png_byte interlace_type; /* One of PNG_INTERLACE_NONE, PNG_INTERLACE_ADAM7 */

   png_byte channels;       /* number of data channels per pixel (1, 2, 3, 4)*/

   png_byte pixel_depth;    /* number of bits per pixel */

   png_byte spare_byte;     /* to align the data, and for future use */

   png_byte signature[8];   /* magic bytes read by libpng from start of file */

    * valid field to see if the information in these are valid.  If you

    * are writing, set the valid field to those chunks you want written,

    * and initialize the appropriate fields below.

    */

   /* The gAMA chunk describes the gamma characteristics of the system

    * on which the image was created, normally in the range [1.0, 2.5].

    * Data is valid if (valid & PNG_INFO_gAMA) is non-zero.

    */

   float gamma; /* gamma value of image, if (valid & PNG_INFO_gAMA) */

#endif

    /* GR-P, 0.96a */

    /* Data valid if (valid & PNG_INFO_sRGB) non-zero. */

   png_byte srgb_intent; /* sRGB rendering intent [0, 1, 2, or 3] */

#endif

   /* The tEXt, and zTXt chunks contain human-readable textual data in

    * uncompressed, compressed, and optionally compressed forms, respectively.

    * The data in "text" is an array of pointers to uncompressed,

    * null-terminated C strings. Each chunk has a keyword that describes the

    * textual data contained in that chunk.  Keywords are not required to be

    * unique, and the text string may be empty.  Any number of text chunks may

    * be in an image.

    */

   int num_text; /* number of comments read/to write */

   int max_text; /* current size of text array */

   png_textp text; /* array of comments read/to write */

#endif /* PNG_TEXT_SUPPORTED */

   /* The tIME chunk holds the last time the displayed image data was

    * modified.  See the png_time struct for the contents of this struct.

    */

   png_time mod_time;

#endif

   /* The sBIT chunk specifies the number of significant high-order bits

    * in the pixel data.  Values are in the range [1, bit_depth], and are

    * only specified for the channels in the pixel data.  The contents of

    * the low-order bits is not specified.  Data is valid if

    * (valid & PNG_INFO_sBIT) is non-zero.

    */

   png_color_8 sig_bit; /* significant bits in color channels */

#endif

defined(PNG_READ_BACKGROUND_SUPPORTED)

   /* The tRNS chunk supplies transparency data for paletted images and

    * other image types that don't need a full alpha channel.  There are

    * "num_trans" transparency values for a paletted image, stored in the

    * same order as the palette colors, starting from index 0.  Values

    * for the data are in the range [0, 255], ranging from fully transparent

    * to fully opaque, respectively.  For non-paletted images, there is a

    * single color specified that should be treated as fully transparent.

    * Data is valid if (valid & PNG_INFO_tRNS) is non-zero.

    */

   png_bytep trans; /* transparent values for paletted image */

   png_color_16 trans_values; /* transparent color for non-palette image */

#endif

   /* The bKGD chunk gives the suggested image background color if the

    * display program does not have its own background color and the image

    * is needs to composited onto a background before display.  The colors

    * in "background" are normally in the same color space/depth as the

    * pixel data.  Data is valid if (valid & PNG_INFO_bKGD) is non-zero.

    */

   png_color_16 background;

#endif

   /* The oFFs chunk gives the offset in "offset_unit_type" units rightwards

    * and downwards from the top-left corner of the display, page, or other

    * application-specific co-ordinate space.  See the PNG_OFFSET_ defines

    * below for the unit types.  Valid if (valid & PNG_INFO_oFFs) non-zero.

    */

   png_int_32 x_offset; /* x offset on page */

   png_int_32 y_offset; /* y offset on page */

   png_byte offset_unit_type; /* offset units type */

#endif

   /* The pHYs chunk gives the physical pixel density of the image for

    * display or printing in "phys_unit_type" units (see PNG_RESOLUTION_

    * defines below).  Data is valid if (valid & PNG_INFO_pHYs) is non-zero.

    */

   png_uint_32 x_pixels_per_unit; /* horizontal pixel density */

   png_uint_32 y_pixels_per_unit; /* vertical pixel density */

   png_byte phys_unit_type; /* resolution type (see PNG_RESOLUTION_ below) */

#endif

   /* The hIST chunk contains the relative frequency or importance of the

    * various palette entries, so that a viewer can intelligently select a

    * reduced-color palette, if required.  Data is an array of "num_palette"

    * values in the range [0,65535]. Data valid if (valid & PNG_INFO_hIST)

    * is non-zero.

    */

   png_uint_16p hist;

#endif

   /* The cHRM chunk describes the CIE color characteristics of the monitor

    * on which the PNG was created.  This data allows the viewer to do gamut

    * mapping of the input image to ensure that the viewer sees the same

    * colors in the image as the creator.  Values are in the range

    * [0.0, 0.8].  Data valid if (valid & PNG_INFO_cHRM) non-zero.

    */

#ifdef PNG_FLOATING_POINT_SUPPORTED

   float x_white;

   float y_white;

   float x_red;

   float y_red;

   float x_green;

   float y_green;

   float x_blue;

   float y_blue;

#endif

#endif

   /* The pCAL chunk describes a transformation between the stored pixel

    * values and original physical data values used to create the image.

    * The integer range [0, 2^bit_depth - 1] maps to the floating-point

    * range given by [pcal_X0, pcal_X1], and are further transformed by a

    * (possibly non-linear) transformation function given by "pcal_type"

    * and "pcal_params" into "pcal_units".  Please see the PNG_EQUATION_

    * defines below, and the PNG-Group's PNG extensions document for a

    * complete description of the transformations and how they should be

    * implemented, and for a description of the ASCII parameter strings.

    * Data values are valid if (valid & PNG_INFO_pCAL) non-zero.

    */

   png_charp pcal_purpose;  /* pCAL chunk description string */

   png_int_32 pcal_X0;      /* minimum value */

   png_int_32 pcal_X1;      /* maximum value */

   png_charp pcal_units;    /* Latin-1 string giving physical units */

   png_charpp pcal_params;  /* ASCII strings containing parameter values */

   png_byte pcal_type;      /* equation type (see PNG_EQUATION_ below) */

   png_byte pcal_nparams;   /* number of parameters given in pcal_params */

#endif

#ifdef PNG_FREE_ME_SUPPORTED

   png_uint_32 free_me;     /* flags items libpng is responsible for freeing */

#endif

   /* storage for unknown chunks that the library doesn't recognize. */

   png_unknown_chunkp unknown_chunks;

   png_size_t unknown_chunks_num;

#endif

   /* iCCP chunk data. */

   png_charp iccp_name;     /* profile name */

   png_charp iccp_profile;  /* International Color Consortium profile data */

                            /* Note to maintainer: should be png_bytep */

   png_uint_32 iccp_proflen;  /* ICC profile data length */

   png_byte iccp_compression; /* Always zero */

#endif

   /* data on sPLT chunks (there may be more than one). */

   png_sPLT_tp splt_palettes;

   png_uint_32 splt_palettes_num;

#endif

   /* The sCAL chunk describes the actual physical dimensions of the

    * subject matter of the graphic.  The chunk contains a unit specification

    * a byte value, and two ASCII strings representing floating-point

    * values.  The values are width and height corresponsing to one pixel

    * in the image.  This external representation is converted to double

    * here.  Data values are valid if (valid & PNG_INFO_sCAL) is non-zero.

    */

   png_byte scal_unit;         /* unit of physical scale */

#ifdef PNG_FLOATING_POINT_SUPPORTED

   double scal_pixel_width;    /* width of one pixel */

   double scal_pixel_height;   /* height of one pixel */

#endif

#ifdef PNG_FIXED_POINT_SUPPORTED

   png_charp scal_s_width;     /* string containing height */

   png_charp scal_s_height;    /* string containing width */

#endif

#endif

   /* Memory has been allocated if (valid & PNG_ALLOCATED_INFO_ROWS) non-zero */

   /* Data valid if (valid & PNG_INFO_IDAT) non-zero */

   png_bytepp row_pointers;        /* the image bits */

#endif

   png_fixed_point int_gamma; /* gamma of image, if (valid & PNG_INFO_gAMA) */

#endif

   png_fixed_point int_x_white;

   png_fixed_point int_y_white;

   png_fixed_point int_x_red;

   png_fixed_point int_y_red;

   png_fixed_point int_x_green;

   png_fixed_point int_y_green;

   png_fixed_point int_x_blue;

   png_fixed_point int_y_blue;

#endif

typedef png_info FAR * FAR * png_infopp;

#define PNG_MAX_UINT ((png_uint_32)0x7fffffffL)

/* color type masks */

#define PNG_COLOR_MASK_PALETTE    1

#define PNG_COLOR_MASK_COLOR      2

#define PNG_COLOR_MASK_ALPHA      4

#define PNG_COLOR_TYPE_GRAY 0

#define PNG_COLOR_TYPE_PALETTE  (PNG_COLOR_MASK_COLOR | PNG_COLOR_MASK_PALETTE)

#define PNG_COLOR_TYPE_RGB        (PNG_COLOR_MASK_COLOR)

#define PNG_COLOR_TYPE_RGB_ALPHA  (PNG_COLOR_MASK_COLOR | PNG_COLOR_MASK_ALPHA)

#define PNG_COLOR_TYPE_GRAY_ALPHA (PNG_COLOR_MASK_ALPHA)

/* aliases */

#define PNG_COLOR_TYPE_RGBA  PNG_COLOR_TYPE_RGB_ALPHA

#define PNG_COLOR_TYPE_GA  PNG_COLOR_TYPE_GRAY_ALPHA

#define PNG_COMPRESSION_TYPE_BASE 0 /* Deflate method 8, 32K window */

#define PNG_COMPRESSION_TYPE_DEFAULT PNG_COMPRESSION_TYPE_BASE

#define PNG_FILTER_TYPE_BASE      0 /* Single row per-byte filtering */

#define PNG_INTRAPIXEL_DIFFERENCING 64 /* Used only in MNG datastreams */

#define PNG_FILTER_TYPE_DEFAULT   PNG_FILTER_TYPE_BASE

#define PNG_INTERLACE_NONE        0 /* Non-interlaced image */

#define PNG_INTERLACE_ADAM7       1 /* Adam7 interlacing */

#define PNG_INTERLACE_LAST        2 /* Not a valid value */

#define PNG_OFFSET_PIXEL          0 /* Offset in pixels */

#define PNG_OFFSET_MICROMETER     1 /* Offset in micrometers (1/10^6 meter) */

#define PNG_OFFSET_LAST           2 /* Not a valid value */

#define PNG_EQUATION_LINEAR       0 /* Linear transformation */

#define PNG_EQUATION_BASE_E       1 /* Exponential base e transform */

#define PNG_EQUATION_ARBITRARY    2 /* Arbitrary base exponential transform */

#define PNG_EQUATION_HYPERBOLIC   3 /* Hyperbolic sine transformation */

#define PNG_EQUATION_LAST         4 /* Not a valid value */

#define PNG_SCALE_UNKNOWN         0 /* unknown unit (image scale) */

#define PNG_SCALE_METER           1 /* meters per pixel */

#define PNG_SCALE_RADIAN          2 /* radians per pixel */

#define PNG_SCALE_LAST            3 /* Not a valid value */

#define PNG_RESOLUTION_UNKNOWN    0 /* pixels/unknown unit (aspect ratio) */

#define PNG_RESOLUTION_METER      1 /* pixels/meter */

#define PNG_RESOLUTION_LAST       2 /* Not a valid value */

#define PNG_sRGB_INTENT_PERCEPTUAL 0

#define PNG_sRGB_INTENT_RELATIVE   1

#define PNG_sRGB_INTENT_SATURATION 2

#define PNG_sRGB_INTENT_ABSOLUTE   3

#define PNG_sRGB_INTENT_LAST       4 /* Not a valid value */

#define PNG_KEYWORD_MAX_LENGTH     79

#define PNG_MAX_PALETTE_LENGTH	   256

 * from the PNG header, or if the application has filled in the corresponding

 * data in the info_struct to be written into the output file.  The values

 * of the PNG_INFO_ defines should NOT be changed.

 */

#define PNG_INFO_gAMA 0x0001

#define PNG_INFO_sBIT 0x0002

#define PNG_INFO_cHRM 0x0004

#define PNG_INFO_PLTE 0x0008

#define PNG_INFO_tRNS 0x0010

#define PNG_INFO_bKGD 0x0020

#define PNG_INFO_hIST 0x0040

#define PNG_INFO_pHYs 0x0080

#define PNG_INFO_oFFs 0x0100

#define PNG_INFO_tIME 0x0200

#define PNG_INFO_pCAL 0x0400

#define PNG_INFO_sRGB 0x0800   /* GR-P, 0.96a */

#define PNG_INFO_iCCP 0x1000   /* ESR, 1.0.6 */

#define PNG_INFO_sPLT 0x2000   /* ESR, 1.0.6 */

#define PNG_INFO_sCAL 0x4000   /* ESR, 1.0.6 */

#define PNG_INFO_IDAT 0x8000L  /* ESR, 1.0.6 */

 * change these values for the row.  It also should enable using

 * the routines for other purposes.

 */

typedef struct png_row_info_struct

{

   png_uint_32 width; /* width of row */

   png_uint_32 rowbytes; /* number of bytes in row */

   png_byte color_type; /* color type of row */

   png_byte bit_depth; /* bit depth of row */

   png_byte channels; /* number of channels (1, 2, 3, or 4) */

   png_byte pixel_depth; /* bits per pixel (depth * channels) */

} png_row_info;

typedef png_row_info FAR * FAR * png_row_infopp;

 * that allow the user to override the default I/O functions with his or her

 * own.  The png_error_ptr type should match that of user-supplied warning

 * and error functions, while the png_rw_ptr type should match that of the

 * user read/write data functions.

 */

typedef struct png_struct_def png_struct;

typedef png_struct FAR * png_structp;

typedef void (PNGAPI *png_rw_ptr) PNGARG((png_structp, png_bytep, png_size_t));

typedef void (PNGAPI *png_flush_ptr) PNGARG((png_structp));

typedef void (PNGAPI *png_read_status_ptr) PNGARG((png_structp, png_uint_32,

   int));

typedef void (PNGAPI *png_write_status_ptr) PNGARG((png_structp, png_uint_32,

   int));

typedef void (PNGAPI *png_progressive_info_ptr) PNGARG((png_structp, png_infop));

typedef void (PNGAPI *png_progressive_end_ptr) PNGARG((png_structp, png_infop));

typedef void (PNGAPI *png_progressive_row_ptr) PNGARG((png_structp, png_bytep,

   png_uint_32, int));

#endif

    defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) || \

    defined(PNG_LEGACY_SUPPORTED)

typedef void (PNGAPI *png_user_transform_ptr) PNGARG((png_structp,

    png_row_infop, png_bytep));

#endif

typedef int (PNGAPI *png_user_chunk_ptr) PNGARG((png_structp, png_unknown_chunkp));

#endif

#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED)

typedef void (PNGAPI *png_unknown_chunk_ptr) PNGARG((png_structp));

#endif

#define PNG_TRANSFORM_IDENTITY       0x0000    /* read and write */

#define PNG_TRANSFORM_STRIP_16       0x0001    /* read only */

#define PNG_TRANSFORM_STRIP_ALPHA    0x0002    /* read only */

#define PNG_TRANSFORM_PACKING        0x0004    /* read and write */

#define PNG_TRANSFORM_PACKSWAP       0x0008    /* read and write */

#define PNG_TRANSFORM_EXPAND         0x0010    /* read only */

#define PNG_TRANSFORM_INVERT_MONO    0x0020    /* read and write */

#define PNG_TRANSFORM_SHIFT          0x0040    /* read and write */

#define PNG_TRANSFORM_BGR            0x0080    /* read and write */

#define PNG_TRANSFORM_SWAP_ALPHA     0x0100    /* read and write */

#define PNG_TRANSFORM_SWAP_ENDIAN    0x0200    /* read and write */

#define PNG_TRANSFORM_INVERT_ALPHA   0x0400    /* read and write */

#define PNG_TRANSFORM_STRIP_FILLER   0x0800    /* WRITE only */

#define PNG_FLAG_MNG_EMPTY_PLTE     0x01

#define PNG_FLAG_MNG_FILTER_64      0x04

#define PNG_ALL_MNG_FEATURES        0x05

typedef void (*png_free_ptr) PNGARG((png_structp, png_voidp));

 * The only people who need to care about what is inside of this are the

 * people who will be modifying the library for their own special needs.

 * It should NOT be accessed directly by an application, except to store

 * the jmp_buf.

 */

{

#ifdef PNG_SETJMP_SUPPORTED

   jmp_buf jmpbuf;            /* used in png_error */

#endif

   png_error_ptr error_fn;    /* function for printing errors and aborting */

   png_error_ptr warning_fn;  /* function for printing warnings */

   png_voidp error_ptr;       /* user supplied struct for error functions */

   png_rw_ptr write_data_fn;  /* function for writing output data */

   png_rw_ptr read_data_fn;   /* function for reading input data */

   png_voidp io_ptr;          /* ptr to application struct for I/O functions*/

   png_user_transform_ptr read_user_transform_fn; /* user read transform */

#endif

   png_user_transform_ptr write_user_transform_fn; /* user write transform */

#endif

#if defined(PNG_USER_TRANSFORM_PTR_SUPPORTED)

#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \

    defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED)

   png_voidp user_transform_ptr; /* user supplied struct for user transform */

   png_byte user_transform_depth;    /* bit depth of user transformed pixels */

   png_byte user_transform_channels; /* channels in user transformed pixels */

#endif

#endif

   png_uint_32 flags;         /* flags indicating various things to libpng */

   png_uint_32 transformations; /* which transformations to perform */

   png_bytep zbuf;            /* buffer for zlib */

   png_size_t zbuf_size;      /* size of zbuf */

   int zlib_level;            /* holds zlib compression level */

   int zlib_method;           /* holds zlib compression method */

   int zlib_window_bits;      /* holds zlib compression window bits */

   int zlib_mem_level;        /* holds zlib compression memory level */

   int zlib_strategy;         /* holds zlib compression strategy */

   png_uint_32 height;        /* height of image in pixels */

   png_uint_32 num_rows;      /* number of rows in current pass */

   png_uint_32 usr_width;     /* width of row at start of write */

   png_uint_32 rowbytes;      /* size of row in bytes */

   png_uint_32 irowbytes;     /* size of current interlaced row in bytes */

   png_uint_32 iwidth;        /* width of current interlaced row in pixels */

   png_uint_32 row_number;    /* current row in interlace pass */

   png_bytep prev_row;        /* buffer to save previous (unfiltered) row */

   png_bytep row_buf;         /* buffer to save current (unfiltered) row */

   png_bytep sub_row;         /* buffer to save "sub" row when filtering */

   png_bytep up_row;          /* buffer to save "up" row when filtering */

   png_bytep avg_row;         /* buffer to save "avg" row when filtering */

   png_bytep paeth_row;       /* buffer to save "Paeth" row when filtering */

   png_row_info row_info;     /* used for transformation routines */

   png_uint_32 crc;           /* current chunk CRC value */

   png_colorp palette;        /* palette from the input file */

   png_uint_16 num_palette;   /* number of color entries in palette */

   png_uint_16 num_trans;     /* number of transparency values */

   png_byte chunk_name[5];    /* null-terminated name of current chunk */

   png_byte compression;      /* file compression type (always 0) */

   png_byte filter;           /* file filter type (always 0) */

   png_byte interlaced;       /* PNG_INTERLACE_NONE, PNG_INTERLACE_ADAM7 */

   png_byte pass;             /* current interlace pass (0 - 6) */

   png_byte do_filter;        /* row filter flags (see PNG_FILTER_ below ) */

   png_byte color_type;       /* color type of file */

   png_byte bit_depth;        /* bit depth of file */

   png_byte usr_bit_depth;    /* bit depth of users row */

   png_byte pixel_depth;      /* number of bits per pixel */

   png_byte channels;         /* number of channels in file */

   png_byte usr_channels;     /* channels at start of write */

   png_byte sig_bytes;        /* magic bytes read/written from start of file */

#ifdef PNG_LEGACY_SUPPORTED

   png_byte filler;           /* filler byte for pixel expansion */

#else

   png_uint_16 filler;           /* filler bytes for pixel expansion */

#endif

#endif

   png_byte background_gamma_type;

#  ifdef PNG_FLOATING_POINT_SUPPORTED

   float background_gamma;

#  endif

   png_color_16 background;   /* background color in screen gamma space */

#  if defined(PNG_READ_GAMMA_SUPPORTED)

     png_color_16 background_1; /* background normalized to gamma 1.0 */

#  endif /* PNG_READ_GAMMA && PNG_bKGD_SUPPORTED */

#endif /* PNG_bKGD_SUPPORTED */

   png_flush_ptr output_flush_fn;/* Function for flushing output */

   png_uint_32 flush_dist;    /* how many rows apart to flush, 0 - no flush */

   png_uint_32 flush_rows;    /* number of rows written since last flush */

#endif

   int gamma_shift;      /* number of "insignificant" bits 16-bit gamma */

#ifdef PNG_FLOATING_POINT_SUPPORTED

   float gamma;          /* file gamma value */

   float screen_gamma;   /* screen gamma value (display_exponent) */

#endif

#endif

   png_bytep gamma_table;     /* gamma table for 8-bit depth files */

   png_bytep gamma_from_1;    /* converts from 1.0 to screen */

   png_bytep gamma_to_1;      /* converts from file to 1.0 */

   png_uint_16pp gamma_16_table; /* gamma table for 16-bit depth files */

   png_uint_16pp gamma_16_from_1; /* converts from 1.0 to screen */

   png_uint_16pp gamma_16_to_1; /* converts from file to 1.0 */

#endif

   png_color_8 sig_bit;       /* significant bits in each available channel */

#endif

   png_color_8 shift;         /* shift for significant bit tranformation */

#endif

 || defined(PNG_READ_EXPAND_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED)

   png_bytep trans;           /* transparency values for paletted files */

   png_color_16 trans_values; /* transparency values for non-paletted files */

#endif

   png_write_status_ptr write_row_fn; /* called after each row is encoded */

#ifdef PNG_PROGRESSIVE_READ_SUPPORTED

   png_progressive_info_ptr info_fn; /* called after header data fully read */

   png_progressive_row_ptr row_fn;   /* called after each prog. row is decoded */

   png_progressive_end_ptr end_fn;   /* called after image is complete */

   png_bytep save_buffer_ptr;        /* current location in save_buffer */

   png_bytep save_buffer;            /* buffer for previously read data */

   png_bytep current_buffer_ptr;     /* current location in current_buffer */

   png_bytep current_buffer;         /* buffer for recently used data */

   png_uint_32 push_length;          /* size of current input chunk */

   png_uint_32 skip_length;          /* bytes to skip in input data */

   png_size_t save_buffer_size;      /* amount of data now in save_buffer */

   png_size_t save_buffer_max;       /* total size of save_buffer */

   png_size_t buffer_size;           /* total amount of available input data */

   png_size_t current_buffer_size;   /* amount of data now in current_buffer */

   int process_mode;                 /* what push library is currently doing */

   int cur_palette;                  /* current push library palette index */

     png_size_t current_text_size;   /* current size of text input data */

     png_size_t current_text_left;   /* how much text left to read in input */

     png_charp current_text;         /* current text chunk buffer */

     png_charp current_text_ptr;     /* current location in current_text */

#  endif /* PNG_PROGRESSIVE_READ_SUPPORTED && PNG_TEXT_SUPPORTED */

/* for the Borland special 64K segment handler */

   png_bytepp offset_table_ptr;

   png_bytep offset_table;

   png_uint_16 offset_table_number;

   png_uint_16 offset_table_count;

   png_uint_16 offset_table_count_free;

#endif

   png_bytep palette_lookup;         /* lookup table for dithering */

   png_bytep dither_index;           /* index translation for palette files */

#endif

   png_uint_16p hist;                /* histogram */

#endif