Subversion Repositories Kolibri OS

 *

 * For conditions of distribution and use, see copyright notice in png.h

 * Copyright (c) 1998-2011 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.)

 *

 * Last changed in libpng 1.5.0 [January 6, 2011]

 *

 * This code is released under the libpng license.

 * For conditions of distribution and use, see the disclaimer

 * and license in png.h

 */

 * as PNG_EXTERN) are PRIVATE.  They are not part of the libpng public

 * interface, and are not recommended for use by regular applications.

 * Some of them may become public in the future; others may stay private,

 * change in an incompatible way, or even disappear.

 * Although the libpng users are not forbidden to include this header,

 * they should be well aware of the issues that may arise from doing so.

 */

#define PNGPRIV_H

 * error handler when all else fails.

 */

#include 

#ifdef PNG_USER_CONFIG

#  include "pngusr.h"

   /* These should have been defined in pngusr.h */

#  ifndef PNG_USER_PRIVATEBUILD

#    define PNG_USER_PRIVATEBUILD "Custom libpng build"

#  endif

#  ifndef PNG_USER_DLLFNAME_POSTFIX

#    define PNG_USER_DLLFNAME_POSTFIX "Cb"

#  endif

#endif

#include "png.h"

#include "pnginfo.h"

#include "pngstruct.h"

 * this could be changed:

 */

typedef PNG_CONST png_uint_16p FAR * png_const_uint_16pp;

/* Moved to pngpriv.h at libpng-1.5.0 */

 * script.  We may need it here to get the correct configuration on things

 * like limits.

 */

#ifdef PNG_CONFIGURE_LIBPNG

#  ifdef HAVE_CONFIG_H

#    include "config.h"

#  endif

#endif

/* NOTE: some of these may have been used in external applications as

 * these definitions were exposed in pngconf.h prior to 1.5.

 */

 * than 64K of memory at once, uncomment this.  While libpng will not

 * normally need that much memory in a chunk (unless you load up a very

 * large file), zlib needs to know how big of a chunk it can use, and

 * libpng thus makes sure to check any memory allocation to verify it

 * will fit into memory.

 *

 * zlib provides 'MAXSEG_64K' which, if defined, indicates the

 * same limit and pngconf.h (already included) sets the limit

 * if certain operating systems are detected.

 */

#if defined(MAXSEG_64K) && !defined(PNG_MAX_MALLOC_64K)

#  define PNG_MAX_MALLOC_64K

#endif

 * which is expected to have no bad effects on performance (optimizing

 * compilers will probably remove it entirely).  Note that if you replace

 * it with something other than whitespace, you must include the terminating

 * semicolon.

 */

#define PNG_UNUSED(param) (void)param;

 * contradictory.

 */

#if (PNG_ZBUF_SIZE > 65536L) && defined(PNG_MAX_MALLOC_64K)

#  undef PNG_ZBUF_SIZE

#  define PNG_ZBUF_SIZE 65536L

#endif

 * or redirected here.

 */

#ifndef PNG_WARNINGS_SUPPORTED

#  define png_warning(s1,s2) ((void)0)

#  define png_chunk_warning(s1,s2) ((void)0)

#endif

#ifndef PNG_ERROR_TEXT_SUPPORTED

#  define png_error(s1,s2) png_err(s1)

#  define png_chunk_error(s1,s2) png_err(s1)

#  define png_fixed_error(s1,s2) png_err(s1)

#endif

/* The functions exported by PNG_EXTERN are internal functions, which

 * aren't usually used outside the library (as far as I know), so it is

 * debatable if they should be exported at all.  In the future, when it

 * is possible to have run-time registry of chunk-handling functions,

 * some of these might be made available again.

#  define PNG_EXTERN extern

 */

#  define PNG_EXTERN

#endif

 * they get used by the corresponding floating point APIs.  This magic

 * deals with this:

 */

#ifdef PNG_FIXED_POINT_SUPPORTED

#  define PNGFAPI PNGAPI

#else

#  define PNGFAPI /* PRIVATE */

#endif

 * them inside an appropriate ifdef/endif pair for portability.

 */

#if defined(PNG_FLOATING_POINT_SUPPORTED) ||\

    defined(PNG_FLOATING_ARITHMETIC_SUPPORTED)

   /* png.c requires the following ANSI-C constants if the conversion of

    * floating point to ASCII is implemented therein:

    *

    *  DBL_DIG  Maximum number of decimal digits (can be set to any constant)

    *  DBL_MIN  Smallest normalized fp number (can be set to an arbitrary value)

    *  DBL_MAX  Maximum floating point number (can be set to an arbitrary value)

    */

#  include 

    defined(THINK_C) || defined(__SC__) || defined(TARGET_OS_MAC)

     /* We need to check that  hasn't already been included earlier

      * as it seems it doesn't agree with , yet we should really use

      *  if possible.

      */

#    if !defined(__MATH_H__) && !defined(__MATH_H) && !defined(__cmath__)

#      include 

#    endif

#  else

#    include 

#  endif

#  if defined(_AMIGA) && defined(__SASC) && defined(_M68881)

     /* Amiga SAS/C: We must include builtin FPU functions when compiling using

      * MATH=68881

      */

#    include 

#  endif

#endif

#if defined(__TURBOC__) && defined(__MSDOS__)

#  include 

#  include 

#endif

/* Users may want to use these so they are not private.  Any library

 * functions that are passed far data must be model-independent.

 */

#ifndef PNG_ABORT

#  ifdef _WINDOWS_

#    define PNG_ABORT() ExitProcess(0)

#  else

#    define PNG_ABORT() abort()

#  endif

#endif

/* Use this to make far-to-near assignments */

#  define CHECK   1

#  define NOCHECK 0

#  define CVT_PTR(ptr) (png_far_to_near(png_ptr,ptr,CHECK))

#  define CVT_PTR_NOCHECK(ptr) (png_far_to_near(png_ptr,ptr,NOCHECK))

#  define png_strcpy  _fstrcpy

#  define png_strncpy _fstrncpy   /* Added to v 1.2.6 */

#  define png_strlen  _fstrlen

#  define png_memcmp  _fmemcmp    /* SJT: added */

#  define png_memcpy  _fmemcpy

#  define png_memset  _fmemset

#  define png_sprintf sprintf

#else

#  ifdef _WINDOWS_  /* Favor Windows over C runtime fns */

#    define CVT_PTR(ptr)         (ptr)

#    define CVT_PTR_NOCHECK(ptr) (ptr)

#    define png_strcpy  lstrcpyA

#    define png_strncpy lstrcpynA

#    define png_strlen  lstrlenA

#    define png_memcmp  memcmp

#    define png_memcpy  CopyMemory

#    define png_memset  memset

#    define png_sprintf wsprintfA

#  else

#    define CVT_PTR(ptr)         (ptr)

#    define CVT_PTR_NOCHECK(ptr) (ptr)

#    define png_strcpy  strcpy

#    define png_strncpy strncpy     /* Added to v 1.2.6 */

#    define png_strlen  strlen

#    define png_memcmp  memcmp      /* SJT: added */

#    define png_memcpy  memcpy

#    define png_memset  memset

#    define png_sprintf sprintf

#  endif

#endif

/* End of memory model/platform independent support */

#  ifdef _MSC_VER

#    define png_snprintf _snprintf   /* Added to v 1.2.19 */

#    define png_snprintf2 _snprintf

#    define png_snprintf6 _snprintf

#  else

#    define png_snprintf snprintf   /* Added to v 1.2.19 */

#    define png_snprintf2 snprintf

#    define png_snprintf6 snprintf

#  endif

#else

  /* You don't have or don't want to use snprintf().  Caution: Using

   * sprintf instead of snprintf exposes your application to accidental

   * or malevolent buffer overflows.  If you don't have snprintf()

   * as a general rule you should provide one (you can get one from

   * Portable OpenSSH).

   */

#  define png_snprintf(s1,n,fmt,x1) png_sprintf(s1,fmt,x1)

#  define png_snprintf2(s1,n,fmt,x1,x2) png_sprintf(s1,fmt,x1,x2)

#  define png_snprintf6(s1,n,fmt,x1,x2,x3,x4,x5,x6) \

      png_sprintf(s1,fmt,x1,x2,x3,x4,x5,x6)

#endif

/* End of 1.5.0beta36 move from pngconf.h */

 * These are used internally by libpng and not exposed in the API

 */

 * zero automatically when the structure is created.

 */

#define PNG_HAVE_IHDR               0x01

#define PNG_HAVE_PLTE               0x02

#define PNG_HAVE_IDAT               0x04

#define PNG_AFTER_IDAT              0x08 /* Have complete zlib datastream */

#define PNG_HAVE_IEND               0x10

#define PNG_HAVE_gAMA               0x20

#define PNG_HAVE_cHRM               0x40

#define PNG_HAVE_sRGB               0x80

#define PNG_HAVE_CHUNK_HEADER      0x100

#define PNG_WROTE_tIME             0x200

#define PNG_WROTE_INFO_BEFORE_PLTE 0x400

#define PNG_BACKGROUND_IS_GRAY     0x800

#define PNG_HAVE_PNG_SIGNATURE    0x1000

#define PNG_HAVE_CHUNK_AFTER_IDAT 0x2000 /* Have another chunk after IDAT */

#define PNG_BGR                 0x0001

#define PNG_INTERLACE           0x0002

#define PNG_PACK                0x0004

#define PNG_SHIFT               0x0008

#define PNG_SWAP_BYTES          0x0010

#define PNG_INVERT_MONO         0x0020

#define PNG_QUANTIZE            0x0040

#define PNG_BACKGROUND          0x0080

#define PNG_BACKGROUND_EXPAND   0x0100

                          /*    0x0200 unused */

#define PNG_16_TO_8             0x0400

#define PNG_RGBA                0x0800

#define PNG_EXPAND              0x1000

#define PNG_GAMMA               0x2000

#define PNG_GRAY_TO_RGB         0x4000

#define PNG_FILLER              0x8000L

#define PNG_PACKSWAP           0x10000L

#define PNG_SWAP_ALPHA         0x20000L

#define PNG_STRIP_ALPHA        0x40000L

#define PNG_INVERT_ALPHA       0x80000L

#define PNG_USER_TRANSFORM    0x100000L

#define PNG_RGB_TO_GRAY_ERR   0x200000L

#define PNG_RGB_TO_GRAY_WARN  0x400000L

#define PNG_RGB_TO_GRAY       0x600000L  /* two bits, RGB_TO_GRAY_ERR|WARN */

                       /*     0x800000L     Unused */

#define PNG_ADD_ALPHA         0x1000000L  /* Added to libpng-1.2.7 */

#define PNG_EXPAND_tRNS       0x2000000L  /* Added to libpng-1.2.9 */

                       /*   0x4000000L  unused */

                       /*   0x8000000L  unused */

                       /*  0x10000000L  unused */

                       /*  0x20000000L  unused */

                       /*  0x40000000L  unused */

#define PNG_STRUCT_PNG   0x0001

#define PNG_STRUCT_INFO  0x0002

#define PNG_WEIGHT_FACTOR (1<<(PNG_WEIGHT_SHIFT))

#define PNG_COST_FACTOR (1<<(PNG_COST_SHIFT))

#define PNG_FLAG_ZLIB_CUSTOM_STRATEGY     0x0001

#define PNG_FLAG_ZLIB_CUSTOM_LEVEL        0x0002

#define PNG_FLAG_ZLIB_CUSTOM_MEM_LEVEL    0x0004

#define PNG_FLAG_ZLIB_CUSTOM_WINDOW_BITS  0x0008

#define PNG_FLAG_ZLIB_CUSTOM_METHOD       0x0010

#define PNG_FLAG_ZLIB_FINISHED            0x0020

#define PNG_FLAG_ROW_INIT                 0x0040

#define PNG_FLAG_FILLER_AFTER             0x0080

#define PNG_FLAG_CRC_ANCILLARY_USE        0x0100

#define PNG_FLAG_CRC_ANCILLARY_NOWARN     0x0200

#define PNG_FLAG_CRC_CRITICAL_USE         0x0400

#define PNG_FLAG_CRC_CRITICAL_IGNORE      0x0800

                                /*        0x1000  unused */

                                /*        0x2000  unused */

                                /*        0x4000  unused */

#define PNG_FLAG_KEEP_UNKNOWN_CHUNKS      0x8000L

#define PNG_FLAG_KEEP_UNSAFE_CHUNKS       0x10000L

#define PNG_FLAG_LIBRARY_MISMATCH         0x20000L

#define PNG_FLAG_STRIP_ERROR_NUMBERS      0x40000L

#define PNG_FLAG_STRIP_ERROR_TEXT         0x80000L

#define PNG_FLAG_MALLOC_NULL_MEM_OK       0x100000L

#define PNG_FLAG_ADD_ALPHA                0x200000L  /* Added to libpng-1.2.8 */

#define PNG_FLAG_STRIP_ALPHA              0x400000L  /* Added to libpng-1.2.8 */

#define PNG_FLAG_BENIGN_ERRORS_WARN       0x800000L  /* Added to libpng-1.4.0 */

                                  /*     0x1000000L  unused */

                                  /*     0x2000000L  unused */

                                  /*     0x4000000L  unused */

                                  /*     0x8000000L  unused */

                                  /*    0x10000000L  unused */

                                  /*    0x20000000L  unused */

                                  /*    0x40000000L  unused */

                                     PNG_FLAG_CRC_ANCILLARY_NOWARN)

                                     PNG_FLAG_CRC_CRITICAL_IGNORE)

                                     PNG_FLAG_CRC_CRITICAL_MASK)

 * can handle at once.  This type need be no larger than 16 bits (so maximum of

 * 65535), this define allows us to discover how big it is, but limited by the

 * maximuum for png_size_t.  The value can be overriden in a library build

 * (pngusr.h, or set it in CPPFLAGS) and it works to set it to a considerably

 * lower value (e.g. 255 works).  A lower value may help memory usage (slightly)

 * and may even improve performance on some systems (and degrade it on others.)

 */

#ifndef ZLIB_IO_MAX

#  define ZLIB_IO_MAX ((uInt)-1)

#endif

   abs((int)((c1).green) - (int)((c2).green)) + \

   abs((int)((c1).blue) - (int)((c2).blue)))

#define PNG_ROWBYTES(pixel_bits, width) \

    ((pixel_bits) >= 8 ? \

    ((png_size_t)(width) * (((png_size_t)(pixel_bits)) >> 3)) : \

    (( ((png_size_t)(width) * ((png_size_t)(pixel_bits))) + 7) >> 3) )

 * ideal-delta..ideal+delta.  Each argument is evaluated twice.

 * "ideal" and "delta" should be constants, normally simple

 * integers, "value" a variable. Added to libpng-1.2.6 JB

 */

#define PNG_OUT_OF_RANGE(value, ideal, delta) \

   ( (value) < (ideal)-(delta) || (value) > (ideal)+(delta) )

 * required (to make sure the code doesn't accidentally use float

 * when it is supposedly disabled.)

 */

#ifdef PNG_FLOATING_POINT_SUPPORTED

/* The floating point conversion can't overflow, though it can and

 * does lose accuracy relative to the original fixed point value.

 * In practice this doesn't matter because png_fixed_point only

 * stores numbers with very low precision.  The png_ptr and s

 * arguments are unused by default but are there in case error

 * checking becomes a requirement.

 */

#define png_float(png_ptr, fixed, s) (.00001 * (fixed))

 * its argument multiple times, so must be used with care.  The

 * range checking uses the PNG specification values for a signed

 * 32 bit fixed point value except that the values are deliberately

 * rounded-to-zero to an integral value - 21474 (21474.83 is roughly

 * (2^31-1) * 100000). 's' is a string that describes the value being

 * converted.

 *

 * NOTE: this macro will raise a png_error if the range check fails,

 * therefore it is normally only appropriate to use this on values

 * that come from API calls or other sources where an out of range

 * error indicates a programming error, not a data error!

 *

 * NOTE: by default this is off - the macro is not used - because the

 * function call saves a lot of code.

 */

#ifdef PNG_FIXED_POINT_MACRO_SUPPORTED

#define png_fixed(png_ptr, fp, s) ((fp) <= 21474 && (fp) >= -21474 ?\

    ((png_fixed_point)(100000 * (fp))) : (png_fixed_error(png_ptr, s),0))

#else

PNG_EXTERN png_fixed_point png_fixed PNGARG((png_structp png_ptr, double fp,

   png_const_charp text));

#endif

#endif

 * define the name here, and add an invocation of the macro wherever it's

 * needed.

 */

#define PNG_IHDR PNG_CONST png_byte png_IHDR[5] = { 73,  72,  68,  82, '\0'}

#define PNG_IDAT PNG_CONST png_byte png_IDAT[5] = { 73,  68,  65,  84, '\0'}

#define PNG_IEND PNG_CONST png_byte png_IEND[5] = { 73,  69,  78,  68, '\0'}

#define PNG_PLTE PNG_CONST png_byte png_PLTE[5] = { 80,  76,  84,  69, '\0'}

#define PNG_bKGD PNG_CONST png_byte png_bKGD[5] = { 98,  75,  71,  68, '\0'}

#define PNG_cHRM PNG_CONST png_byte png_cHRM[5] = { 99,  72,  82,  77, '\0'}

#define PNG_gAMA PNG_CONST png_byte png_gAMA[5] = {103,  65,  77,  65, '\0'}

#define PNG_hIST PNG_CONST png_byte png_hIST[5] = {104,  73,  83,  84, '\0'}

#define PNG_iCCP PNG_CONST png_byte png_iCCP[5] = {105,  67,  67,  80, '\0'}

#define PNG_iTXt PNG_CONST png_byte png_iTXt[5] = {105,  84,  88, 116, '\0'}

#define PNG_oFFs PNG_CONST png_byte png_oFFs[5] = {111,  70,  70, 115, '\0'}

#define PNG_pCAL PNG_CONST png_byte png_pCAL[5] = {112,  67,  65,  76, '\0'}

#define PNG_sCAL PNG_CONST png_byte png_sCAL[5] = {115,  67,  65,  76, '\0'}

#define PNG_pHYs PNG_CONST png_byte png_pHYs[5] = {112,  72,  89, 115, '\0'}

#define PNG_sBIT PNG_CONST png_byte png_sBIT[5] = {115,  66,  73,  84, '\0'}

#define PNG_sPLT PNG_CONST png_byte png_sPLT[5] = {115,  80,  76,  84, '\0'}

#define PNG_sRGB PNG_CONST png_byte png_sRGB[5] = {115,  82,  71,  66, '\0'}

#define PNG_sTER PNG_CONST png_byte png_sTER[5] = {115,  84,  69,  82, '\0'}

#define PNG_tEXt PNG_CONST png_byte png_tEXt[5] = {116,  69,  88, 116, '\0'}

#define PNG_tIME PNG_CONST png_byte png_tIME[5] = {116,  73,  77,  69, '\0'}

#define PNG_tRNS PNG_CONST png_byte png_tRNS[5] = {116,  82,  78,  83, '\0'}

#define PNG_zTXt PNG_CONST png_byte png_zTXt[5] = {122,  84,  88, 116, '\0'}

#ifdef __cplusplus

extern "C" {

#endif /* __cplusplus */

 * shouldn't be used unless you are writing code to add or replace some

 * functionality in libpng.  More information about most functions can

 * be found in the files where the functions are located.

 */

PNG_EXTERN PNG_FUNCTION(png_voidp,png_create_struct,PNGARG((int type)),

   PNG_ALLOCATED);

PNG_EXTERN void png_destroy_struct PNGARG((png_voidp struct_ptr));

   PNGARG((int type, png_malloc_ptr malloc_fn, png_voidp mem_ptr)),

   PNG_ALLOCATED);

PNG_EXTERN void png_destroy_struct_2 PNGARG((png_voidp struct_ptr,

    png_free_ptr free_fn, png_voidp mem_ptr));

PNG_EXTERN void png_info_destroy PNGARG((png_structp png_ptr,

    png_infop info_ptr));

PNG_EXTERN PNG_FUNCTION(voidpf,png_zalloc,PNGARG((voidpf png_ptr, uInt items,

   uInt size)),PNG_ALLOCATED);

PNG_EXTERN void png_zfree PNGARG((voidpf png_ptr, voidpf ptr));

 * but not PNG_EXPORT.  PNGAPI added at libpng version 1.2.3, changed to

 * PNGCBAPI at 1.5.0

 */

    png_bytep data, png_size_t length));

PNG_EXTERN void PNGCBAPI png_push_fill_buffer PNGARG((png_structp png_ptr,

    png_bytep buffer, png_size_t length));

#endif

    png_bytep data, png_size_t length));

#  ifdef PNG_STDIO_SUPPORTED

PNG_EXTERN void PNGCBAPI png_default_flush PNGARG((png_structp png_ptr));

#  endif

#endif

PNG_EXTERN void png_reset_crc PNGARG((png_structp png_ptr));

PNG_EXTERN void png_write_data PNGARG((png_structp png_ptr,

    png_const_bytep data, png_size_t length));

PNG_EXTERN void png_read_sig PNGARG((png_structp png_ptr, png_infop info_ptr));

PNG_EXTERN png_uint_32 png_read_chunk_header PNGARG((png_structp png_ptr));

PNG_EXTERN void png_read_data PNGARG((png_structp png_ptr, png_bytep data,

    png_size_t length));

PNG_EXTERN void png_crc_read PNGARG((png_structp png_ptr, png_bytep buf,

    png_size_t length));

#if defined(PNG_zTXt_SUPPORTED) || defined(PNG_iTXt_SUPPORTED) || \

    defined(PNG_iCCP_SUPPORTED) || defined(PNG_sPLT_SUPPORTED)

PNG_EXTERN void png_decompress_chunk PNGARG((png_structp png_ptr,

    int comp_type, png_size_t chunklength, png_size_t prefix_length,

    png_size_t *data_length));

#endif

PNG_EXTERN int png_crc_finish PNGARG((png_structp png_ptr, png_uint_32 skip));

PNG_EXTERN int png_crc_error PNGARG((png_structp png_ptr));

 * passing a maximum of 64K on systems that have this as a memory limit,

 * since this is the maximum buffer size we can specify.

 */

PNG_EXTERN void png_calculate_crc PNGARG((png_structp png_ptr,

    png_const_bytep ptr, png_size_t length));

PNG_EXTERN void png_flush PNGARG((png_structp png_ptr));

#endif

 * information.

 */

PNG_EXTERN void png_write_IHDR PNGARG((png_structp png_ptr, png_uint_32 width,

    png_uint_32 height,

    int bit_depth, int color_type, int compression_method, int filter_method,

    int interlace_method));

    png_const_colorp palette, png_uint_32 num_pal));

    png_size_t length));

#  ifdef PNG_FLOATING_POINT_SUPPORTED

PNG_EXTERN void png_write_gAMA PNGARG((png_structp png_ptr, double file_gamma));

#  endif

#  ifdef PNG_FIXED_POINT_SUPPORTED

PNG_EXTERN void png_write_gAMA_fixed PNGARG((png_structp png_ptr,

    png_fixed_point file_gamma));

#  endif

#endif

PNG_EXTERN void png_write_sBIT PNGARG((png_structp png_ptr,

    png_const_color_8p sbit, int color_type));

#endif

#  ifdef PNG_FLOATING_POINT_SUPPORTED

PNG_EXTERN void png_write_cHRM PNGARG((png_structp png_ptr,

    double white_x, double white_y,

    double red_x, double red_y, double green_x, double green_y,

    double blue_x, double blue_y));

#  endif

PNG_EXTERN void png_write_cHRM_fixed PNGARG((png_structp png_ptr,

    png_fixed_point int_white_x, png_fixed_point int_white_y,

    png_fixed_point int_red_x, png_fixed_point int_red_y, png_fixed_point

    int_green_x, png_fixed_point int_green_y, png_fixed_point int_blue_x,

    png_fixed_point int_blue_y));

#endif

PNG_EXTERN void png_write_sRGB PNGARG((png_structp png_ptr,

    int intent));

#endif

PNG_EXTERN void png_write_iCCP PNGARG((png_structp png_ptr,

    png_const_charp name, int compression_type,

    png_const_charp profile, int proflen));

   /* Note to maintainer: profile should be png_bytep */

#endif

PNG_EXTERN void png_write_sPLT PNGARG((png_structp png_ptr,

    png_const_sPLT_tp palette));

#endif

PNG_EXTERN void png_write_tRNS PNGARG((png_structp png_ptr,

    png_const_bytep trans, png_const_color_16p values, int number,

    int color_type));

#endif

PNG_EXTERN void png_write_bKGD PNGARG((png_structp png_ptr,

    png_const_color_16p values, int color_type));

#endif

PNG_EXTERN void png_write_hIST PNGARG((png_structp png_ptr,

    png_const_uint_16p hist, int num_hist));

#endif

    defined(PNG_WRITE_iCCP_SUPPORTED) || defined(PNG_WRITE_sPLT_SUPPORTED)

PNG_EXTERN png_size_t png_check_keyword PNGARG((png_structp png_ptr,

    png_const_charp key, png_charpp new_key));

#endif

PNG_EXTERN void png_write_tEXt PNGARG((png_structp png_ptr, png_const_charp key,

    png_const_charp text, png_size_t text_len));

#endif

PNG_EXTERN void png_write_zTXt PNGARG((png_structp png_ptr, png_const_charp key,

    png_const_charp text, png_size_t text_len, int compression));

#endif

PNG_EXTERN void png_write_iTXt PNGARG((png_structp png_ptr,

    int compression, png_const_charp key, png_const_charp lang,

    png_const_charp lang_key, png_const_charp text));

#endif

PNG_EXTERN int png_set_text_2 PNGARG((png_structp png_ptr,

    png_infop info_ptr, png_const_textp text_ptr, int num_text));

#endif

PNG_EXTERN void png_write_oFFs PNGARG((png_structp png_ptr,

    png_int_32 x_offset, png_int_32 y_offset, int unit_type));

#endif

PNG_EXTERN void png_write_pCAL PNGARG((png_structp png_ptr, png_charp purpose,

    png_int_32 X0, png_int_32 X1, int type, int nparams,

    png_const_charp units, png_charpp params));

#endif

PNG_EXTERN void png_write_pHYs PNGARG((png_structp png_ptr,

    png_uint_32 x_pixels_per_unit, png_uint_32 y_pixels_per_unit,

    int unit_type));

#endif

PNG_EXTERN void png_write_tIME PNGARG((png_structp png_ptr,

    png_const_timep mod_time));

#endif

PNG_EXTERN void png_write_sCAL_s PNGARG((png_structp png_ptr,

    int unit, png_const_charp width, png_const_charp height));

#endif

PNG_EXTERN void png_write_finish_row PNGARG((png_structp png_ptr));

PNG_EXTERN void png_write_start_row PNGARG((png_structp png_ptr));

PNG_EXTERN void png_combine_row PNGARG((png_structp png_ptr, png_bytep row,

    int mask));

/* Expand an interlaced row */

/* OLD pre-1.0.9 interface:

PNG_EXTERN void png_do_read_interlace PNGARG((png_row_infop row_info,

    png_bytep row, int pass, png_uint_32 transformations));

 */

PNG_EXTERN void png_do_read_interlace PNGARG((png_structp png_ptr));

#endif

/* Grab pixels out of a row for an interlaced pass */

PNG_EXTERN void png_do_write_interlace PNGARG((png_row_infop row_info,

    png_bytep row, int pass));

#endif

PNG_EXTERN void png_read_filter_row PNGARG((png_structp png_ptr,

    png_row_infop row_info, png_bytep row, png_const_bytep prev_row,

    int filter));

PNG_EXTERN void png_write_find_filter PNGARG((png_structp png_ptr,

    png_row_infop row_info));

PNG_EXTERN void png_write_filtered_row PNGARG((png_structp png_ptr,

    png_bytep filtered_row));

/* Finish a row while reading, dealing with interlacing passes, etc. */

PNG_EXTERN void png_read_finish_row PNGARG((png_structp png_ptr));

PNG_EXTERN void png_read_start_row PNGARG((png_structp png_ptr));

/* Optional call to update the users info structure */

PNG_EXTERN void png_read_transform_info PNGARG((png_structp png_ptr,

    png_infop info_ptr));

#ifdef PNG_READ_FILLER_SUPPORTED

PNG_EXTERN void png_do_read_filler PNGARG((png_row_infop row_info,

    png_bytep row, png_uint_32 filler, png_uint_32 flags));

#endif

PNG_EXTERN void png_do_read_swap_alpha PNGARG((png_row_infop row_info,

    png_bytep row));

#endif

PNG_EXTERN void png_do_write_swap_alpha PNGARG((png_row_infop row_info,

    png_bytep row));

#endif

PNG_EXTERN void png_do_read_invert_alpha PNGARG((png_row_infop row_info,

    png_bytep row));

#endif

PNG_EXTERN void png_do_write_invert_alpha PNGARG((png_row_infop row_info,

    png_bytep row));

#endif

    defined(PNG_READ_STRIP_ALPHA_SUPPORTED)

PNG_EXTERN void png_do_strip_filler PNGARG((png_row_infop row_info,

    png_bytep row, png_uint_32 flags));

#endif

#if defined(PNG_READ_SWAP_SUPPORTED) || defined(PNG_WRITE_SWAP_SUPPORTED)

PNG_EXTERN void png_do_swap PNGARG((png_row_infop row_info,

    png_bytep row));

#endif

#endif

    defined(PNG_WRITE_PACKSWAP_SUPPORTED)

PNG_EXTERN void png_do_packswap PNGARG((png_row_infop row_info,

    png_bytep row));

#endif

PNG_EXTERN int png_do_rgb_to_gray PNGARG((png_structp png_ptr,

    png_row_infop row_info, png_bytep row));

#endif

PNG_EXTERN void png_do_gray_to_rgb PNGARG((png_row_infop row_info,

    png_bytep row));

#endif

PNG_EXTERN void png_do_unpack PNGARG((png_row_infop row_info,

    png_bytep row));

#endif

PNG_EXTERN void png_do_unshift PNGARG((png_row_infop row_info,

    png_bytep row, png_const_color_8p sig_bits));

#endif

PNG_EXTERN void png_do_invert PNGARG((png_row_infop row_info,

    png_bytep row));

#endif

PNG_EXTERN void png_do_chop PNGARG((png_row_infop row_info,

    png_bytep row));

#endif

PNG_EXTERN void png_do_quantize PNGARG((png_row_infop row_info,

    png_bytep row, png_const_bytep palette_lookup,

    png_const_bytep quantize_lookup));

PNG_EXTERN void png_correct_palette PNGARG((png_structp png_ptr,

    png_colorp palette, int num_palette));

#  endif

#endif

PNG_EXTERN void png_do_bgr PNGARG((png_row_infop row_info,

    png_bytep row));

#endif

PNG_EXTERN void png_do_pack PNGARG((png_row_infop row_info,

   png_bytep row, png_uint_32 bit_depth));

#endif

PNG_EXTERN void png_do_shift PNGARG((png_row_infop row_info,

    png_bytep row, png_const_color_8p bit_depth));

#endif

#  ifdef PNG_READ_GAMMA_SUPPORTED

PNG_EXTERN void png_do_background PNGARG((png_row_infop row_info,

    png_bytep row, png_const_color_16p trans_color,

    png_const_color_16p background, png_const_color_16p background_1,

    png_const_bytep gamma_table, png_const_bytep gamma_from_1,

    png_const_bytep gamma_to_1, png_const_uint_16pp gamma_16,

    png_const_uint_16pp gamma_16_from_1, png_const_uint_16pp gamma_16_to_1,

    int gamma_shift));

#  else

PNG_EXTERN void png_do_background PNGARG((png_row_infop row_info,

    png_bytep row, png_const_color_16p trans_color,

    png_const_color_16p background));

#  endif

#endif

PNG_EXTERN void png_do_gamma PNGARG((png_row_infop row_info,

    png_bytep row, png_const_bytep gamma_table,

    png_const_uint_16pp gamma_16_table, int gamma_shift));

#endif

PNG_EXTERN void png_do_expand_palette PNGARG((png_row_infop row_info,

    png_bytep row, png_const_colorp palette, png_const_bytep trans,

    int num_trans));

PNG_EXTERN void png_do_expand PNGARG((png_row_infop row_info,

    png_bytep row, png_const_color_16p trans_color));

#endif

 * then calls the appropriate callback for the chunk if it is valid.

 */

PNG_EXTERN void png_handle_IHDR PNGARG((png_structp png_ptr, png_infop info_ptr,

    png_uint_32 length));

PNG_EXTERN void png_handle_PLTE PNGARG((png_structp png_ptr, png_infop info_ptr,

    png_uint_32 length));

PNG_EXTERN void png_handle_IEND PNGARG((png_structp png_ptr, png_infop info_ptr,

    png_uint_32 length));

PNG_EXTERN void png_handle_bKGD PNGARG((png_structp png_ptr, png_infop info_ptr,

    png_uint_32 length));

#endif

PNG_EXTERN void png_handle_cHRM PNGARG((png_structp png_ptr, png_infop info_ptr,

    png_uint_32 length));

#endif

PNG_EXTERN void png_handle_gAMA PNGARG((png_structp png_ptr, png_infop info_ptr,

    png_uint_32 length));

#endif

PNG_EXTERN void png_handle_hIST PNGARG((png_structp png_ptr, png_infop info_ptr,

    png_uint_32 length));

#endif

PNG_EXTERN void png_handle_iCCP PNGARG((png_structp png_ptr, png_infop info_ptr,

    png_uint_32 length));

#endif /* PNG_READ_iCCP_SUPPORTED */

PNG_EXTERN void png_handle_iTXt PNGARG((png_structp png_ptr, png_infop info_ptr,

    png_uint_32 length));

#endif

PNG_EXTERN void png_handle_oFFs PNGARG((png_structp png_ptr, png_infop info_ptr,

    png_uint_32 length));

#endif

PNG_EXTERN void png_handle_pCAL PNGARG((png_structp png_ptr, png_infop info_ptr,

    png_uint_32 length));

#endif

PNG_EXTERN void png_handle_pHYs PNGARG((png_structp png_ptr, png_infop info_ptr,

    png_uint_32 length));

#endif

PNG_EXTERN void png_handle_sBIT PNGARG((png_structp png_ptr, png_infop info_ptr,

    png_uint_32 length));

#endif

PNG_EXTERN void png_handle_sCAL PNGARG((png_structp png_ptr, png_infop info_ptr,

    png_uint_32 length));

#endif

PNG_EXTERN void png_handle_sPLT PNGARG((png_structp png_ptr, png_infop info_ptr,

    png_uint_32 length));

#endif /* PNG_READ_sPLT_SUPPORTED */

PNG_EXTERN void png_handle_sRGB PNGARG((png_structp png_ptr, png_infop info_ptr,

    png_uint_32 length));

#endif

PNG_EXTERN void png_handle_tEXt PNGARG((png_structp png_ptr, png_infop info_ptr,

    png_uint_32 length));

#endif

PNG_EXTERN void png_handle_tIME PNGARG((png_structp png_ptr, png_infop info_ptr,

    png_uint_32 length));

#endif

PNG_EXTERN void png_handle_tRNS PNGARG((png_structp png_ptr, png_infop info_ptr,

    png_uint_32 length));

#endif

PNG_EXTERN void png_handle_zTXt PNGARG((png_structp png_ptr, png_infop info_ptr,

    png_uint_32 length));

#endif

    png_infop info_ptr, png_uint_32 length));

    png_const_bytep chunk_name));

PNG_EXTERN void png_do_read_transformations PNGARG((png_structp png_ptr));

PNG_EXTERN void png_do_write_transformations PNGARG((png_structp png_ptr));

PNG_EXTERN void png_push_read_chunk PNGARG((png_structp png_ptr,

    png_infop info_ptr));

PNG_EXTERN void png_push_read_sig PNGARG((png_structp png_ptr,

    png_infop info_ptr));

PNG_EXTERN void png_push_check_crc PNGARG((png_structp png_ptr));

PNG_EXTERN void png_push_crc_skip PNGARG((png_structp png_ptr,

    png_uint_32 length));

PNG_EXTERN void png_push_crc_finish PNGARG((png_structp png_ptr));

PNG_EXTERN void png_push_save_buffer PNGARG((png_structp png_ptr));

PNG_EXTERN void png_push_restore_buffer PNGARG((png_structp png_ptr,

    png_bytep buffer, png_size_t buffer_length));

PNG_EXTERN void png_push_read_IDAT PNGARG((png_structp png_ptr));

PNG_EXTERN void png_process_IDAT_data PNGARG((png_structp png_ptr,

    png_bytep buffer, png_size_t buffer_length));

PNG_EXTERN void png_push_process_row PNGARG((png_structp png_ptr));

PNG_EXTERN void png_push_handle_unknown PNGARG((png_structp png_ptr,

   png_infop info_ptr, png_uint_32 length));

PNG_EXTERN void png_push_have_info PNGARG((png_structp png_ptr,

   png_infop info_ptr));

PNG_EXTERN void png_push_have_end PNGARG((png_structp png_ptr,

   png_infop info_ptr));

PNG_EXTERN void png_push_have_row PNGARG((png_structp png_ptr, png_bytep row));

PNG_EXTERN void png_push_read_end PNGARG((png_structp png_ptr,

    png_infop info_ptr));

PNG_EXTERN void png_process_some_data PNGARG((png_structp png_ptr,

    png_infop info_ptr));

PNG_EXTERN void png_read_push_finish_row PNGARG((png_structp png_ptr));

#  ifdef PNG_READ_tEXt_SUPPORTED

PNG_EXTERN void png_push_handle_tEXt PNGARG((png_structp png_ptr,

    png_infop info_ptr, png_uint_32 length));

PNG_EXTERN void png_push_read_tEXt PNGARG((png_structp png_ptr,

    png_infop info_ptr));

#  endif

#  ifdef PNG_READ_zTXt_SUPPORTED

PNG_EXTERN void png_push_handle_zTXt PNGARG((png_structp png_ptr,

    png_infop info_ptr, png_uint_32 length));

PNG_EXTERN void png_push_read_zTXt PNGARG((png_structp png_ptr,

    png_infop info_ptr));

#  endif

#  ifdef PNG_READ_iTXt_SUPPORTED

PNG_EXTERN void png_push_handle_iTXt PNGARG((png_structp png_ptr,

    png_infop info_ptr, png_uint_32 length));

PNG_EXTERN void png_push_read_iTXt PNGARG((png_structp png_ptr,

    png_infop info_ptr));

#  endif

PNG_EXTERN void png_do_read_intrapixel PNGARG((png_row_infop row_info,

    png_bytep row));

PNG_EXTERN void png_do_write_intrapixel PNGARG((png_row_infop row_info,

    png_bytep row));

#endif

#ifdef PNG_CHECK_cHRM_SUPPORTED

PNG_EXTERN int png_check_cHRM_fixed PNGARG((png_structp png_ptr,

    png_fixed_point int_white_x, png_fixed_point int_white_y,

    png_fixed_point int_red_x, png_fixed_point int_red_y, png_fixed_point

    int_green_x, png_fixed_point int_green_y, png_fixed_point int_blue_x,

    png_fixed_point int_blue_y));

#endif

/* Added at libpng version 1.2.34 and 1.4.0 */

/* Currently only used by png_check_cHRM_fixed */

PNG_EXTERN void png_64bit_product PNGARG((long v1, long v2,

    unsigned long *hi_product, unsigned long *lo_product));

#endif

PNG_EXTERN void png_check_IHDR PNGARG((png_structp png_ptr,

    png_uint_32 width, png_uint_32 height, int bit_depth,

    int color_type, int interlace_type, int compression_type,

    int filter_type));

PNG_EXTERN void png_read_destroy PNGARG((png_structp png_ptr,

    png_infop info_ptr, png_infop end_info_ptr));

PNG_EXTERN void png_write_destroy PNGARG((png_structp png_ptr));

PNG_EXTERN void *png_far_to_near PNGARG((png_structp png_ptr, png_voidp ptr,

    int check));

#endif /* USE_FAR_KEYWORD */

PNG_EXTERN PNG_FUNCTION(void, png_fixed_error, (png_structp png_ptr,

   png_const_charp name),PNG_NORETURN);

#endif

 * support is required.

 */

#if defined(PNG_READ_sCAL_SUPPORTED)

/* MAX_DIGITS is actually the maximum number of characters in an sCAL

 * width or height, derived from the precision (number of significant

 * digits - a build time settable option) and assumpitions about the

 * maximum ridiculous exponent.

 */

#define PNG_sCAL_MAX_DIGITS (PNG_sCAL_PRECISION+1/*.*/+1/*E*/+10/*exponent*/)

PNG_EXTERN void png_ascii_from_fp PNGARG((png_structp png_ptr, png_charp ascii,

    png_size_t size, double fp, unsigned int precision));

#endif /* FLOATING_POINT */

PNG_EXTERN void png_ascii_from_fixed PNGARG((png_structp png_ptr,

    png_charp ascii, png_size_t size, png_fixed_point fp));

#endif /* FIXED_POINT */

#endif /* READ_sCAL */

/* An internal API to validate the format of a floating point number.

 * The result is the index of the next character.  If the number is

 * not valid it will be the index of a character in the supposed number.

 *

 * The format of a number is defined in the PNG extensions specification

 * and this API is strictly conformant to that spec, not anyone elses!

 *

 * The format as a regular expression is:

 *

 * [+-]?[0-9]+.?([Ee][+-]?[0-9]+)?

 *

 * or:

 *

 * [+-]?.[0-9]+(.[0-9]+)?([Ee][+-]?[0-9]+)?

 *

 * The complexity is that either integer or fraction must be present and the

 * fraction is permitted to have no digits only if the integer is present.

 *

 * NOTE: The dangling E problem.

 *   There is a PNG valid floating point number in the following:

 *

 *       PNG floating point numb1.ers are not greedy.

 *

 *   Working this out requires *TWO* character lookahead (because of the

 *   sign), the parser does not do this - it will fail at the 'r' - this

 *   doesn't matter for PNG sCAL chunk values, but it requires more care

 *   if the value were ever to be embedded in something more complex.  Use

 *   ANSI-C strtod if you need the lookahead.

 */

/* State table for the parser. */