#include "pnglibconf.h"
#include "pngconf.h"

Include dependency graph for png.h:

This graph shows which files directly or indirectly include this file:

Classes
struct	png_color_struct

struct	png_color_16_struct

struct	png_color_8_struct

struct	png_sPLT_entry_struct

struct	png_sPLT_struct

struct	png_text_struct

struct	png_time_struct

struct	png_unknown_chunk_t

struct	png_row_info_struct

struct	png_image

Macros
#define	PNG_LIBPNG_VER_STRING "1.6.16"

#define	PNG_HEADER_VERSION_STRING " libpng version 1.6.16 - December 22, 2014\n"

#define	PNG_LIBPNG_VER_SONUM 16

#define	PNG_LIBPNG_VER_DLLNUM 16

#define	PNG_LIBPNG_VER_MAJOR 1

#define	PNG_LIBPNG_VER_MINOR 6

#define	PNG_LIBPNG_VER_RELEASE 16

#define	PNG_LIBPNG_VER_BUILD 0

#define	PNG_LIBPNG_BUILD_ALPHA 1

#define	PNG_LIBPNG_BUILD_BETA 2

#define	PNG_LIBPNG_BUILD_RC 3

#define	PNG_LIBPNG_BUILD_STABLE 4

#define	PNG_LIBPNG_BUILD_RELEASE_STATUS_MASK 7

#define	PNG_LIBPNG_BUILD_PATCH

#define	PNG_LIBPNG_BUILD_PRIVATE

#define	PNG_LIBPNG_BUILD_SPECIAL

#define	PNG_LIBPNG_BUILD_BASE_TYPE PNG_LIBPNG_BUILD_STABLE

#define	PNG_LIBPNG_VER 10616 /* 1.6.16 */

#define	PNG_LIBPNG_BUILD_TYPE (PNG_LIBPNG_BUILD_BASE_TYPE)

#define	png_libpng_ver png_get_header_ver(NULL)

#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 */

#define	PNG_HAVE_IHDR 0x01

#define	PNG_HAVE_PLTE 0x02

#define	PNG_AFTER_IDAT 0x08

#define	PNG_UINT_31_MAX ((png_uint_32)0x7fffffffL)

#define	PNG_UINT_32_MAX ((png_uint_32)(-1))

#define	PNG_SIZE_MAX ((png_size_t)(-1))

#define	PNG_FP_1 100000

#define	PNG_FP_HALF 50000

#define	PNG_FP_MAX ((png_fixed_point)0x7fffffffL)

#define	PNG_FP_MIN (-PNG_FP_MAX)

#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)

#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

#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 0x8000 /* ESR, 1.0.6 */

#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_TRANSFORM_STRIP_FILLER_BEFORE PNG_TRANSFORM_STRIP_FILLER

#define	PNG_TRANSFORM_STRIP_FILLER_AFTER 0x1000 /* write only */

#define	PNG_TRANSFORM_GRAY_TO_RGB 0x2000 /* read only */

#define	PNG_TRANSFORM_EXPAND_16 0x4000 /* read only */

#define	PNG_TRANSFORM_SCALE_16 0x8000 /* read only */

#define	PNG_FLAG_MNG_EMPTY_PLTE 0x01

#define	PNG_FLAG_MNG_FILTER_64 0x04

#define	PNG_ALL_MNG_FEATURES 0x05

#define	png_check_sig(sig, n) !png_sig_cmp((sig), 0, (n))

#define	png_jmpbuf(png_ptr) (*png_set_longjmp_fn((png_ptr), longjmp, (sizeof (jmp_buf))))

#define	PNG_ERROR_ACTION_NONE 1

#define	PNG_ERROR_ACTION_WARN 2

#define	PNG_ERROR_ACTION_ERROR 3

#define	PNG_RGB_TO_GRAY_DEFAULT (-1)/for red/green coefficients/

#define	PNG_ALPHA_PNG 0 /* according to the PNG standard */

#define	PNG_ALPHA_STANDARD 1 /* according to Porter/Duff */

#define	PNG_ALPHA_ASSOCIATED 1 /* as above; this is the normal practice */

#define	PNG_ALPHA_PREMULTIPLIED 1 /* as above */

#define	PNG_ALPHA_OPTIMIZED 2 /* 'PNG' for opaque pixels, else 'STANDARD' */

#define	PNG_ALPHA_BROKEN 3 /* the alpha channel is gamma encoded */

#define	PNG_DEFAULT_sRGB -1 /* sRGB gamma and color space */

#define	PNG_GAMMA_MAC_18 -2 /* Old Mac '1.8' gamma and color space */

#define	PNG_GAMMA_sRGB 220000 /* Television standards--matches sRGB gamma */

#define	PNG_GAMMA_LINEAR PNG_FP_1 /* Linear */

#define	PNG_FILLER_BEFORE 0

#define	PNG_FILLER_AFTER 1

#define	PNG_BACKGROUND_GAMMA_UNKNOWN 0

#define	PNG_BACKGROUND_GAMMA_SCREEN 1

#define	PNG_BACKGROUND_GAMMA_FILE 2

#define	PNG_BACKGROUND_GAMMA_UNIQUE 3

#define	PNG_READ_16_TO_8 SUPPORTED /* Name prior to 1.5.4 */

#define	PNG_GAMMA_THRESHOLD (PNG_GAMMA_THRESHOLD_FIXED*.00001)

#define	PNG_CRC_DEFAULT 0 /* error/quit warn/discard data */

#define	PNG_CRC_ERROR_QUIT 1 /* error/quit error/quit */

#define	PNG_CRC_WARN_DISCARD 2 /* (INVALID) warn/discard data */

#define	PNG_CRC_WARN_USE 3 /* warn/use data warn/use data */

#define	PNG_CRC_QUIET_USE 4 /* quiet/use data quiet/use data */

#define	PNG_CRC_NO_CHANGE 5 /* use current value use current value */

#define	PNG_NO_FILTERS 0x00

#define	PNG_FILTER_NONE 0x08

#define	PNG_FILTER_SUB 0x10

#define	PNG_FILTER_UP 0x20

#define	PNG_FILTER_AVG 0x40

#define	PNG_FILTER_PAETH 0x80

#define	PNG_ALL_FILTERS

#define	PNG_FILTER_VALUE_NONE 0

#define	PNG_FILTER_VALUE_SUB 1

#define	PNG_FILTER_VALUE_UP 2

#define	PNG_FILTER_VALUE_AVG 3

#define	PNG_FILTER_VALUE_PAETH 4

#define	PNG_FILTER_VALUE_LAST 5

#define	PNG_FILTER_HEURISTIC_DEFAULT 0 /* Currently "UNWEIGHTED" */

#define	PNG_FILTER_HEURISTIC_UNWEIGHTED 1 /* Used by libpng < 0.95 */

#define	PNG_FILTER_HEURISTIC_WEIGHTED 2 /* Experimental feature */

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

#define	PNG_DESTROY_WILL_FREE_DATA 1

#define	PNG_SET_WILL_FREE_DATA 1

#define	PNG_USER_WILL_FREE_DATA 2

#define	PNG_FREE_HIST 0x0008

#define	PNG_FREE_ICCP 0x0010

#define	PNG_FREE_SPLT 0x0020

#define	PNG_FREE_ROWS 0x0040

#define	PNG_FREE_PCAL 0x0080

#define	PNG_FREE_SCAL 0x0100

#define	PNG_FREE_UNKN 0x0200

#define	PNG_FREE_PLTE 0x1000

#define	PNG_FREE_TRNS 0x2000

#define	PNG_FREE_TEXT 0x4000

#define	PNG_FREE_ALL 0x7fff

#define	PNG_FREE_MUL 0x4220 /* PNG_FREE_SPLT\|PNG_FREE_TEXT\|PNG_FREE_UNKN */

#define	PNG_HANDLE_CHUNK_AS_DEFAULT 0

#define	PNG_HANDLE_CHUNK_NEVER 1

#define	PNG_HANDLE_CHUNK_IF_SAFE 2

#define	PNG_HANDLE_CHUNK_ALWAYS 3

#define	PNG_HANDLE_CHUNK_LAST 4

#define	PNG_IO_NONE 0x0000 /* no I/O at this moment */

#define	PNG_IO_READING 0x0001 /* currently reading */

#define	PNG_IO_WRITING 0x0002 /* currently writing */

#define	PNG_IO_SIGNATURE 0x0010 /* currently at the file signature */

#define	PNG_IO_CHUNK_HDR 0x0020 /* currently at the chunk header */

#define	PNG_IO_CHUNK_DATA 0x0040 /* currently at the chunk data */

#define	PNG_IO_CHUNK_CRC 0x0080 /* currently at the chunk crc */

#define	PNG_IO_MASK_OP 0x000f /* current operation: reading/writing */

#define	PNG_IO_MASK_LOC 0x00f0 /* current location: sig/hdr/data/crc */

#define	PNG_INTERLACE_ADAM7_PASSES 7

#define	PNG_PASS_START_ROW(pass) (((1&~(pass))<<(3-((pass)>>1)))&7)

#define	PNG_PASS_START_COL(pass) (((1& (pass))<<(3-(((pass)+1)>>1)))&7)

#define	PNG_PASS_ROW_OFFSET(pass) ((pass)>2?(8>>(((pass)-1)>>1)):8)

#define	PNG_PASS_COL_OFFSET(pass) (1<<((7-(pass))>>1))

#define	PNG_PASS_ROW_SHIFT(pass) ((pass)>2?(8-(pass))>>1:3)

#define	PNG_PASS_COL_SHIFT(pass) ((pass)>1?(7-(pass))>>1:3)

#define	PNG_PASS_ROWS(height, pass)

#define	PNG_PASS_COLS(width, pass)

#define	PNG_ROW_FROM_PASS_ROW(y_in, pass) (((y_in)<<PNG_PASS_ROW_SHIFT(pass))+PNG_PASS_START_ROW(pass))

#define	PNG_COL_FROM_PASS_COL(x_in, pass) (((x_in)<<PNG_PASS_COL_SHIFT(pass))+PNG_PASS_START_COL(pass))

#define	PNG_PASS_MASK(pass, off)

#define	PNG_ROW_IN_INTERLACE_PASS(y, pass) ((PNG_PASS_MASK(pass,0) >> ((y)&7)) & 1)

#define	PNG_COL_IN_INTERLACE_PASS(x, pass) ((PNG_PASS_MASK(pass,1) >> ((x)&7)) & 1)

#define	png_composite(composite, fg, alpha, bg)

#define	png_composite_16(composite, fg, alpha, bg)

#define	PNG_get_uint_32(buf)

#define	PNG_get_uint_16(buf)

#define	PNG_get_int_32(buf)

#define	png_get_uint_32(buf) PNG_get_uint_32(buf)

#define	png_get_uint_16(buf) PNG_get_uint_16(buf)

#define	png_get_int_32(buf) PNG_get_int_32(buf)

#define	PNG_IMAGE_VERSION 1

#define	PNG_IMAGE_WARNING 1

#define	PNG_IMAGE_ERROR 2

#define	PNG_IMAGE_FAILED(png_cntrl) ((((png_cntrl).warning_or_error)&0x03)>1)

#define	PNG_FORMAT_FLAG_ALPHA 0x01U /* format with an alpha channel */

#define	PNG_FORMAT_FLAG_COLOR 0x02U /* color format: otherwise grayscale */

#define	PNG_FORMAT_FLAG_LINEAR 0x04U /* 2 byte channels else 1 byte */

#define	PNG_FORMAT_FLAG_COLORMAP 0x08U /* image data is color-mapped */

#define	PNG_FORMAT_FLAG_BGR 0x10U /* BGR colors, else order is RGB */

#define	PNG_FORMAT_FLAG_AFIRST 0x20U /* alpha channel comes first */

#define	PNG_FORMAT_GRAY 0

#define	PNG_FORMAT_GA PNG_FORMAT_FLAG_ALPHA

#define	PNG_FORMAT_AG (PNG_FORMAT_GA\|PNG_FORMAT_FLAG_AFIRST)

#define	PNG_FORMAT_RGB PNG_FORMAT_FLAG_COLOR

#define	PNG_FORMAT_BGR (PNG_FORMAT_FLAG_COLOR\|PNG_FORMAT_FLAG_BGR)

#define	PNG_FORMAT_RGBA (PNG_FORMAT_RGB\|PNG_FORMAT_FLAG_ALPHA)

#define	PNG_FORMAT_ARGB (PNG_FORMAT_RGBA\|PNG_FORMAT_FLAG_AFIRST)

#define	PNG_FORMAT_BGRA (PNG_FORMAT_BGR\|PNG_FORMAT_FLAG_ALPHA)

#define	PNG_FORMAT_ABGR (PNG_FORMAT_BGRA\|PNG_FORMAT_FLAG_AFIRST)

#define	PNG_FORMAT_LINEAR_Y PNG_FORMAT_FLAG_LINEAR

#define	PNG_FORMAT_LINEAR_Y_ALPHA (PNG_FORMAT_FLAG_LINEAR\|PNG_FORMAT_FLAG_ALPHA)

#define	PNG_FORMAT_LINEAR_RGB (PNG_FORMAT_FLAG_LINEAR\|PNG_FORMAT_FLAG_COLOR)

#define	PNG_FORMAT_LINEAR_RGB_ALPHA (PNG_FORMAT_FLAG_LINEAR\|PNG_FORMAT_FLAG_COLOR\|PNG_FORMAT_FLAG_ALPHA)

#define	PNG_FORMAT_RGB_COLORMAP (PNG_FORMAT_RGB\|PNG_FORMAT_FLAG_COLORMAP)

#define	PNG_FORMAT_BGR_COLORMAP (PNG_FORMAT_BGR\|PNG_FORMAT_FLAG_COLORMAP)

#define	PNG_FORMAT_RGBA_COLORMAP (PNG_FORMAT_RGBA\|PNG_FORMAT_FLAG_COLORMAP)

#define	PNG_FORMAT_ARGB_COLORMAP (PNG_FORMAT_ARGB\|PNG_FORMAT_FLAG_COLORMAP)

#define	PNG_FORMAT_BGRA_COLORMAP (PNG_FORMAT_BGRA\|PNG_FORMAT_FLAG_COLORMAP)

#define	PNG_FORMAT_ABGR_COLORMAP (PNG_FORMAT_ABGR\|PNG_FORMAT_FLAG_COLORMAP)

#define	PNG_IMAGE_SAMPLE_CHANNELS(fmt) (((fmt)&(PNG_FORMAT_FLAG_COLOR\|PNG_FORMAT_FLAG_ALPHA))+1)

#define	PNG_IMAGE_SAMPLE_COMPONENT_SIZE(fmt) ((((fmt) & PNG_FORMAT_FLAG_LINEAR) >> 2)+1)

#define	PNG_IMAGE_SAMPLE_SIZE(fmt) (PNG_IMAGE_SAMPLE_CHANNELS(fmt) * PNG_IMAGE_SAMPLE_COMPONENT_SIZE(fmt))

#define	PNG_IMAGE_MAXIMUM_COLORMAP_COMPONENTS(fmt) (PNG_IMAGE_SAMPLE_CHANNELS(fmt) * 256)

#define	PNG_IMAGE_PIXEL_(test, fmt) (((fmt)&PNG_FORMAT_FLAG_COLORMAP)?1:test(fmt))

#define	PNG_IMAGE_PIXEL_CHANNELS(fmt) PNG_IMAGE_PIXEL_(PNG_IMAGE_SAMPLE_CHANNELS,fmt)

#define	PNG_IMAGE_PIXEL_COMPONENT_SIZE(fmt) PNG_IMAGE_PIXEL_(PNG_IMAGE_SAMPLE_COMPONENT_SIZE,fmt)

#define	PNG_IMAGE_PIXEL_SIZE(fmt) PNG_IMAGE_PIXEL_(PNG_IMAGE_SAMPLE_SIZE,fmt)

#define	PNG_IMAGE_ROW_STRIDE(image) (PNG_IMAGE_PIXEL_CHANNELS((image).format) * (image).width)

#define	PNG_IMAGE_BUFFER_SIZE(image, row_stride) (PNG_IMAGE_PIXEL_COMPONENT_SIZE((image).format)(image).height(row_stride))

#define	PNG_IMAGE_SIZE(image) PNG_IMAGE_BUFFER_SIZE(image, PNG_IMAGE_ROW_STRIDE(image))

#define	PNG_IMAGE_COLORMAP_SIZE(image) (PNG_IMAGE_SAMPLE_SIZE((image).format) * (image).colormap_entries)

#define	PNG_IMAGE_FLAG_COLORSPACE_NOT_sRGB 0x01

#define	PNG_IMAGE_FLAG_FAST 0x02

#define	PNG_IMAGE_FLAG_16BIT_sRGB 0x04

#define	PNG_MAXIMUM_INFLATE_WINDOW 2 /* SOFTWARE: force maximum window */

#define	PNG_SKIP_sRGB_CHECK_PROFILE 4 /* SOFTWARE: Check ICC profile for sRGB */

#define	PNG_OPTION_NEXT 6 /* Next option - numbers must be even */

#define	PNG_OPTION_UNSET 0 /* Unset - defaults to off */

#define	PNG_OPTION_INVALID 1 /* Option number out of range */

#define	PNG_OPTION_OFF 2

#define	PNG_OPTION_ON 3

Typedefs
typedef char *	png_libpng_version_1_6_16

typedef struct png_struct_def	png_struct

typedef const png_struct *	png_const_structp

typedef png_struct *	png_structp

typedef png_struct **	png_structpp

typedef struct png_info_def	png_info

typedef png_info *	png_infop

typedef const png_info *	png_const_infop

typedef png_info **	png_infopp

typedef png_struct *	png_structrp

typedef const png_struct *	png_const_structrp

typedef png_info *	png_inforp

typedef const png_info *	png_const_inforp

typedef struct png_color_struct	png_color

typedef png_color *	png_colorp

typedef const png_color *	png_const_colorp

typedef png_color **	png_colorpp

typedef struct png_color_16_struct	png_color_16

typedef png_color_16 *	png_color_16p

typedef const png_color_16 *	png_const_color_16p

typedef png_color_16 **	png_color_16pp

typedef struct png_color_8_struct	png_color_8

typedef png_color_8 *	png_color_8p

typedef const png_color_8 *	png_const_color_8p

typedef png_color_8 **	png_color_8pp

typedef struct png_sPLT_entry_struct	png_sPLT_entry

typedef png_sPLT_entry *	png_sPLT_entryp

typedef const png_sPLT_entry *	png_const_sPLT_entryp

typedef png_sPLT_entry **	png_sPLT_entrypp

typedef struct png_sPLT_struct	png_sPLT_t

typedef png_sPLT_t *	png_sPLT_tp

typedef const png_sPLT_t *	png_const_sPLT_tp

typedef png_sPLT_t **	png_sPLT_tpp

typedef struct png_text_struct	png_text

typedef png_text *	png_textp

typedef const png_text *	png_const_textp

typedef png_text **	png_textpp

typedef struct png_time_struct	png_time

typedef png_time *	png_timep

typedef const png_time *	png_const_timep

typedef png_time **	png_timepp

typedef struct png_unknown_chunk_t	png_unknown_chunk

typedef png_unknown_chunk *	png_unknown_chunkp

typedef const png_unknown_chunk *	png_const_unknown_chunkp

typedef png_unknown_chunk **	png_unknown_chunkpp

typedef struct png_row_info_struct	png_row_info

typedef png_row_info *	png_row_infop

typedef png_row_info **	png_row_infopp

typedef void(*	png_error_ptr) (png_structp, png_const_charp)

typedef void(*	png_rw_ptr) (png_structp, png_bytep, png_size_t)

typedef void(*	png_flush_ptr) (png_structp)

typedef void(*	png_read_status_ptr) (png_structp, png_uint_32, int)

typedef void(*	png_write_status_ptr) (png_structp, png_uint_32, int)

typedef void(*	png_progressive_info_ptr) (png_structp, png_infop)

typedef void(*	png_progressive_end_ptr) (png_structp, png_infop)

typedef void(*	png_progressive_row_ptr) (png_structp, png_bytep, png_uint_32, int)

typedef void(*	png_user_transform_ptr) (png_structp, png_row_infop, png_bytep)

typedef int(*	png_user_chunk_ptr) (png_structp, png_unknown_chunkp)

typedef void(*	png_longjmp_ptr) (jmp_buf, int)

typedef png_voidp(*	png_malloc_ptr) (png_structp, png_alloc_size_t)

typedef void(*	png_free_ptr) (png_structp, png_voidp)

typedef struct png_control *	png_controlp

typedef struct png_image *	png_imagep

Functions
PNG_IMPEXP png_uint_32()	png_access_version_number (void)

PNG_IMPEXP void()	png_set_sig_bytes (png_structrp png_ptr, int num_bytes)

PNG_IMPEXP int()	png_sig_cmp (png_const_bytep sig, png_size_t start, png_size_t num_to_check)

PNG_IMPEXP png_structp()	png_create_read_struct (png_const_charp user_png_ver, png_voidp error_ptr, png_error_ptr error_fn, png_error_ptr warn_fn)

PNG_IMPEXP png_structp()	png_create_write_struct (png_const_charp user_png_ver, png_voidp error_ptr, png_error_ptr error_fn, png_error_ptr warn_fn)

PNG_IMPEXP png_size_t()	png_get_compression_buffer_size (png_const_structrp png_ptr)

PNG_IMPEXP void()	png_set_compression_buffer_size (png_structrp png_ptr, png_size_t size)

PNG_IMPEXP jmp_buf *()	png_set_longjmp_fn (png_structrp png_ptr, png_longjmp_ptr longjmp_fn, size_t jmp_buf_size)

PNG_IMPEXP void()	png_longjmp (png_const_structrp png_ptr, int val)

PNG_DEPRECATED PNG_IMPEXP int()	png_reset_zstream (png_structrp png_ptr)

PNG_IMPEXP png_structp()	png_create_read_struct_2 (png_const_charp user_png_ver, png_voidp error_ptr, png_error_ptr error_fn, png_error_ptr warn_fn, png_voidp mem_ptr, png_malloc_ptr malloc_fn, png_free_ptr free_fn)

PNG_IMPEXP png_structp()	png_create_write_struct_2 (png_const_charp user_png_ver, png_voidp error_ptr, png_error_ptr error_fn, png_error_ptr warn_fn, png_voidp mem_ptr, png_malloc_ptr malloc_fn, png_free_ptr free_fn)

PNG_IMPEXP void()	png_write_sig (png_structrp png_ptr)

PNG_IMPEXP void()	png_write_chunk (png_structrp png_ptr, png_const_bytep chunk_name, png_const_bytep data, png_size_t length)

PNG_IMPEXP void()	png_write_chunk_start (png_structrp png_ptr, png_const_bytep chunk_name, png_uint_32 length)

PNG_IMPEXP void()	png_write_chunk_data (png_structrp png_ptr, png_const_bytep data, png_size_t length)

PNG_IMPEXP void()	png_write_chunk_end (png_structrp png_ptr)

PNG_IMPEXP png_infop()	png_create_info_struct (png_const_structrp png_ptr)

PNG_DEPRECATED PNG_IMPEXP void()	png_info_init_3 (png_infopp info_ptr, png_size_t png_info_struct_size)

PNG_IMPEXP void()	png_write_info_before_PLTE (png_structrp png_ptr, png_const_inforp info_ptr)

PNG_IMPEXP void()	png_write_info (png_structrp png_ptr, png_const_inforp info_ptr)

PNG_IMPEXP void()	png_read_info (png_structrp png_ptr, png_inforp info_ptr)

PNG_DEPRECATED PNG_IMPEXP png_const_charp()	png_convert_to_rfc1123 (png_structrp png_ptr, png_const_timep ptime)

PNG_IMPEXP int()	png_convert_to_rfc1123_buffer (char out[29], png_const_timep ptime)

PNG_IMPEXP void()	png_convert_from_struct_tm (png_timep ptime, const struct tm *ttime)

PNG_IMPEXP void()	png_convert_from_time_t (png_timep ptime, time_t ttime)

PNG_IMPEXP void()	png_set_expand (png_structrp png_ptr)

PNG_IMPEXP void()	png_set_expand_gray_1_2_4_to_8 (png_structrp png_ptr)

PNG_IMPEXP void()	png_set_palette_to_rgb (png_structrp png_ptr)

PNG_IMPEXP void()	png_set_tRNS_to_alpha (png_structrp png_ptr)

PNG_IMPEXP void()	png_set_expand_16 (png_structrp png_ptr)

PNG_IMPEXP void()	png_set_bgr (png_structrp png_ptr)

PNG_IMPEXP void()	png_set_gray_to_rgb (png_structrp png_ptr)

PNG_IMPEXP void()	png_set_rgb_to_gray (png_structrp png_ptr, int error_action, double red, double green)

PNG_IMPEXP void()	png_set_rgb_to_gray_fixed (png_structrp png_ptr, int error_action, png_fixed_point red, png_fixed_point green)

PNG_IMPEXP png_byte()	png_get_rgb_to_gray_status (png_const_structrp png_ptr)

PNG_IMPEXP void()	png_build_grayscale_palette (int bit_depth, png_colorp palette)

PNG_IMPEXP void()	png_set_alpha_mode (png_structrp png_ptr, int mode, double output_gamma)

PNG_IMPEXP void()	png_set_alpha_mode_fixed (png_structrp png_ptr, int mode, png_fixed_point output_gamma)

PNG_IMPEXP void()	png_set_strip_alpha (png_structrp png_ptr)

PNG_IMPEXP void()	png_set_swap_alpha (png_structrp png_ptr)

PNG_IMPEXP void()	png_set_invert_alpha (png_structrp png_ptr)

PNG_IMPEXP void()	png_set_filler (png_structrp png_ptr, png_uint_32 filler, int flags)

PNG_IMPEXP void()	png_set_add_alpha (png_structrp png_ptr, png_uint_32 filler, int flags)

PNG_IMPEXP void()	png_set_swap (png_structrp png_ptr)

PNG_IMPEXP void()	png_set_packing (png_structrp png_ptr)

PNG_IMPEXP void()	png_set_packswap (png_structrp png_ptr)

PNG_IMPEXP void()	png_set_shift (png_structrp png_ptr, png_const_color_8p true_bits)

PNG_IMPEXP int()	png_set_interlace_handling (png_structrp png_ptr)

PNG_IMPEXP void()	png_set_invert_mono (png_structrp png_ptr)

PNG_IMPEXP void()	png_set_background (png_structrp png_ptr, png_const_color_16p background_color, int background_gamma_code, int need_expand, double background_gamma)

PNG_IMPEXP void()	png_set_background_fixed (png_structrp png_ptr, png_const_color_16p background_color, int background_gamma_code, int need_expand, png_fixed_point background_gamma)

PNG_IMPEXP void()	png_set_scale_16 (png_structrp png_ptr)

PNG_IMPEXP void()	png_set_strip_16 (png_structrp png_ptr)

PNG_IMPEXP void()	png_set_quantize (png_structrp png_ptr, png_colorp palette, int num_palette, int maximum_colors, png_const_uint_16p histogram, int full_quantize)

PNG_IMPEXP void()	png_set_gamma (png_structrp png_ptr, double screen_gamma, double override_file_gamma)

PNG_IMPEXP void()	png_set_gamma_fixed (png_structrp png_ptr, png_fixed_point screen_gamma, png_fixed_point override_file_gamma)

PNG_IMPEXP void()	png_set_flush (png_structrp png_ptr, int nrows)

PNG_IMPEXP void()	png_write_flush (png_structrp png_ptr)

PNG_IMPEXP void()	png_start_read_image (png_structrp png_ptr)

PNG_IMPEXP void()	png_read_update_info (png_structrp png_ptr, png_inforp info_ptr)

PNG_IMPEXP void()	png_read_rows (png_structrp png_ptr, png_bytepp row, png_bytepp display_row, png_uint_32 num_rows)

PNG_IMPEXP void()	png_read_row (png_structrp png_ptr, png_bytep row, png_bytep display_row)

PNG_IMPEXP void()	png_read_image (png_structrp png_ptr, png_bytepp image)

PNG_IMPEXP void()	png_write_row (png_structrp png_ptr, png_const_bytep row)

PNG_IMPEXP void()	png_write_rows (png_structrp png_ptr, png_bytepp row, png_uint_32 num_rows)

PNG_IMPEXP void()	png_write_image (png_structrp png_ptr, png_bytepp image)

PNG_IMPEXP void()	png_write_end (png_structrp png_ptr, png_inforp info_ptr)

PNG_IMPEXP void()	png_read_end (png_structrp png_ptr, png_inforp info_ptr)

PNG_IMPEXP void()	png_destroy_info_struct (png_const_structrp png_ptr, png_infopp info_ptr_ptr)

PNG_IMPEXP void()	png_destroy_read_struct (png_structpp png_ptr_ptr, png_infopp info_ptr_ptr, png_infopp end_info_ptr_ptr)

PNG_IMPEXP void()	png_destroy_write_struct (png_structpp png_ptr_ptr, png_infopp info_ptr_ptr)

PNG_IMPEXP void()	png_set_crc_action (png_structrp png_ptr, int crit_action, int ancil_action)

PNG_IMPEXP void()	png_set_filter (png_structrp png_ptr, int method, int filters)

PNG_IMPEXP void()	png_set_filter_heuristics (png_structrp png_ptr, int heuristic_method, int num_weights, png_const_doublep filter_weights, png_const_doublep filter_costs)

PNG_IMPEXP void()	png_set_filter_heuristics_fixed (png_structrp png_ptr, int heuristic_method, int num_weights, png_const_fixed_point_p filter_weights, png_const_fixed_point_p filter_costs)

PNG_IMPEXP void()	png_set_compression_level (png_structrp png_ptr, int level)

PNG_IMPEXP void()	png_set_compression_mem_level (png_structrp png_ptr, int mem_level)

PNG_IMPEXP void()	png_set_compression_strategy (png_structrp png_ptr, int strategy)

PNG_IMPEXP void()	png_set_compression_window_bits (png_structrp png_ptr, int window_bits)

PNG_IMPEXP void()	png_set_compression_method (png_structrp png_ptr, int method)

PNG_IMPEXP void()	png_set_text_compression_level (png_structrp png_ptr, int level)

PNG_IMPEXP void()	png_set_text_compression_mem_level (png_structrp png_ptr, int mem_level)

PNG_IMPEXP void()	png_set_text_compression_strategy (png_structrp png_ptr, int strategy)

PNG_IMPEXP void()	png_set_text_compression_window_bits (png_structrp png_ptr, int window_bits)

PNG_IMPEXP void()	png_set_text_compression_method (png_structrp png_ptr, int method)

PNG_IMPEXP void()	png_init_io (png_structrp png_ptr, png_FILE_p fp)

PNG_IMPEXP void()	png_set_error_fn (png_structrp png_ptr, png_voidp error_ptr, png_error_ptr error_fn, png_error_ptr warning_fn)

PNG_IMPEXP png_voidp()	png_get_error_ptr (png_const_structrp png_ptr)

PNG_IMPEXP void()	png_set_write_fn (png_structrp png_ptr, png_voidp io_ptr, png_rw_ptr write_data_fn, png_flush_ptr output_flush_fn)

PNG_IMPEXP void()	png_set_read_fn (png_structrp png_ptr, png_voidp io_ptr, png_rw_ptr read_data_fn)

PNG_IMPEXP png_voidp()	png_get_io_ptr (png_const_structrp png_ptr)

PNG_IMPEXP void()	png_set_read_status_fn (png_structrp png_ptr, png_read_status_ptr read_row_fn)

PNG_IMPEXP void()	png_set_write_status_fn (png_structrp png_ptr, png_write_status_ptr write_row_fn)

PNG_IMPEXP void()	png_set_mem_fn (png_structrp png_ptr, png_voidp mem_ptr, png_malloc_ptr malloc_fn, png_free_ptr free_fn)

PNG_IMPEXP png_voidp()	png_get_mem_ptr (png_const_structrp png_ptr)

PNG_IMPEXP void()	png_set_read_user_transform_fn (png_structrp png_ptr, png_user_transform_ptr read_user_transform_fn)

PNG_IMPEXP void()	png_set_write_user_transform_fn (png_structrp png_ptr, png_user_transform_ptr write_user_transform_fn)

PNG_IMPEXP void()	png_set_user_transform_info (png_structrp png_ptr, png_voidp user_transform_ptr, int user_transform_depth, int user_transform_channels)

PNG_IMPEXP png_voidp()	png_get_user_transform_ptr (png_const_structrp png_ptr)

PNG_IMPEXP png_uint_32()	png_get_current_row_number (png_const_structrp)

PNG_IMPEXP png_byte()	png_get_current_pass_number (png_const_structrp)

PNG_IMPEXP void()	png_set_read_user_chunk_fn (png_structrp png_ptr, png_voidp user_chunk_ptr, png_user_chunk_ptr read_user_chunk_fn)

PNG_IMPEXP png_voidp()	png_get_user_chunk_ptr (png_const_structrp png_ptr)

PNG_IMPEXP void()	png_set_progressive_read_fn (png_structrp png_ptr, png_voidp progressive_ptr, png_progressive_info_ptr info_fn, png_progressive_row_ptr row_fn, png_progressive_end_ptr end_fn)

PNG_IMPEXP png_voidp()	png_get_progressive_ptr (png_const_structrp png_ptr)

PNG_IMPEXP void()	png_process_data (png_structrp png_ptr, png_inforp info_ptr, png_bytep buffer, png_size_t buffer_size)

PNG_IMPEXP png_size_t()	png_process_data_pause (png_structrp, int save)

PNG_IMPEXP png_uint_32()	png_process_data_skip (png_structrp)

PNG_IMPEXP void()	png_progressive_combine_row (png_const_structrp png_ptr, png_bytep old_row, png_const_bytep new_row)

PNG_IMPEXP png_voidp()	png_malloc (png_const_structrp png_ptr, png_alloc_size_t size)

PNG_IMPEXP png_voidp()	png_calloc (png_const_structrp png_ptr, png_alloc_size_t size)

PNG_IMPEXP png_voidp()	png_malloc_warn (png_const_structrp png_ptr, png_alloc_size_t size)

PNG_IMPEXP void()	png_free (png_const_structrp png_ptr, png_voidp ptr)

PNG_IMPEXP void()	png_free_data (png_const_structrp png_ptr, png_inforp info_ptr, png_uint_32 free_me, int num)

PNG_IMPEXP void()	png_data_freer (png_const_structrp png_ptr, png_inforp info_ptr, int freer, png_uint_32 mask)

PNG_DEPRECATED PNG_IMPEXP png_voidp()	png_malloc_default (png_const_structrp png_ptr, png_alloc_size_t size)

PNG_DEPRECATED PNG_IMPEXP void()	png_free_default (png_const_structrp png_ptr, png_voidp ptr)

PNG_IMPEXP void()	png_error (png_const_structrp png_ptr, png_const_charp error_message)

PNG_IMPEXP void()	png_chunk_error (png_const_structrp png_ptr, png_const_charp error_message)

PNG_IMPEXP void()	png_warning (png_const_structrp png_ptr, png_const_charp warning_message)

PNG_IMPEXP void()	png_chunk_warning (png_const_structrp png_ptr, png_const_charp warning_message)

PNG_IMPEXP void()	png_benign_error (png_const_structrp png_ptr, png_const_charp warning_message)

PNG_IMPEXP void()	png_chunk_benign_error (png_const_structrp png_ptr, png_const_charp warning_message)

PNG_IMPEXP void()	png_set_benign_errors (png_structrp png_ptr, int allowed)

PNG_IMPEXP png_uint_32()	png_get_valid (png_const_structrp png_ptr, png_const_inforp info_ptr, png_uint_32 flag)

PNG_IMPEXP png_size_t()	png_get_rowbytes (png_const_structrp png_ptr, png_const_inforp info_ptr)

PNG_IMPEXP png_bytepp()	png_get_rows (png_const_structrp png_ptr, png_const_inforp info_ptr)

PNG_IMPEXP void()	png_set_rows (png_const_structrp png_ptr, png_inforp info_ptr, png_bytepp row_pointers)

PNG_IMPEXP png_byte()	png_get_channels (png_const_structrp png_ptr, png_const_inforp info_ptr)

PNG_IMPEXP png_uint_32()	png_get_image_width (png_const_structrp png_ptr, png_const_inforp info_ptr)

PNG_IMPEXP png_uint_32()	png_get_image_height (png_const_structrp png_ptr, png_const_inforp info_ptr)

PNG_IMPEXP png_byte()	png_get_bit_depth (png_const_structrp png_ptr, png_const_inforp info_ptr)

PNG_IMPEXP png_byte()	png_get_color_type (png_const_structrp png_ptr, png_const_inforp info_ptr)

PNG_IMPEXP png_byte()	png_get_filter_type (png_const_structrp png_ptr, png_const_inforp info_ptr)

PNG_IMPEXP png_byte()	png_get_interlace_type (png_const_structrp png_ptr, png_const_inforp info_ptr)

PNG_IMPEXP png_byte()	png_get_compression_type (png_const_structrp png_ptr, png_const_inforp info_ptr)

PNG_IMPEXP png_uint_32()	png_get_pixels_per_meter (png_const_structrp png_ptr, png_const_inforp info_ptr)

PNG_IMPEXP png_uint_32()	png_get_x_pixels_per_meter (png_const_structrp png_ptr, png_const_inforp info_ptr)

PNG_IMPEXP png_uint_32()	png_get_y_pixels_per_meter (png_const_structrp png_ptr, png_const_inforp info_ptr)

PNG_IMPEXP float()	png_get_pixel_aspect_ratio (png_const_structrp png_ptr, png_const_inforp info_ptr)

PNG_IMPEXP png_fixed_point()	png_get_pixel_aspect_ratio_fixed (png_const_structrp png_ptr, png_const_inforp info_ptr)

PNG_IMPEXP png_int_32()	png_get_x_offset_pixels (png_const_structrp png_ptr, png_const_inforp info_ptr)

PNG_IMPEXP png_int_32()	png_get_y_offset_pixels (png_const_structrp png_ptr, png_const_inforp info_ptr)

PNG_IMPEXP png_int_32()	png_get_x_offset_microns (png_const_structrp png_ptr, png_const_inforp info_ptr)

PNG_IMPEXP png_int_32()	png_get_y_offset_microns (png_const_structrp png_ptr, png_const_inforp info_ptr)

PNG_IMPEXP png_const_bytep()	png_get_signature (png_const_structrp png_ptr, png_const_inforp info_ptr)

PNG_IMPEXP png_uint_32()	png_get_bKGD (png_const_structrp png_ptr, png_inforp info_ptr, png_color_16p *background)

PNG_IMPEXP void()	png_set_bKGD (png_const_structrp png_ptr, png_inforp info_ptr, png_const_color_16p background)

PNG_IMPEXP png_uint_32()	png_get_cHRM (png_const_structrp png_ptr, png_const_inforp info_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)

PNG_IMPEXP png_uint_32()	png_get_cHRM_XYZ (png_const_structrp png_ptr, png_const_inforp info_ptr, double red_X, double red_Y, double red_Z, double green_X, double green_Y, double green_Z, double blue_X, double blue_Y, double *blue_Z)

PNG_IMPEXP png_uint_32()	png_get_cHRM_fixed (png_const_structrp png_ptr, png_const_inforp info_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)

PNG_IMPEXP png_uint_32()	png_get_cHRM_XYZ_fixed (png_const_structrp png_ptr, png_const_inforp info_ptr, png_fixed_point int_red_X, png_fixed_point int_red_Y, png_fixed_point int_red_Z, png_fixed_point int_green_X, png_fixed_point int_green_Y, png_fixed_point int_green_Z, png_fixed_point int_blue_X, png_fixed_point int_blue_Y, png_fixed_point *int_blue_Z)

PNG_IMPEXP void()	png_set_cHRM (png_const_structrp png_ptr, png_inforp info_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)

PNG_IMPEXP void()	png_set_cHRM_XYZ (png_const_structrp png_ptr, png_inforp info_ptr, double red_X, double red_Y, double red_Z, double green_X, double green_Y, double green_Z, double blue_X, double blue_Y, double blue_Z)

PNG_IMPEXP void()	png_set_cHRM_fixed (png_const_structrp png_ptr, png_inforp info_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)

PNG_IMPEXP void()	png_set_cHRM_XYZ_fixed (png_const_structrp png_ptr, png_inforp info_ptr, png_fixed_point int_red_X, png_fixed_point int_red_Y, png_fixed_point int_red_Z, png_fixed_point int_green_X, png_fixed_point int_green_Y, png_fixed_point int_green_Z, png_fixed_point int_blue_X, png_fixed_point int_blue_Y, png_fixed_point int_blue_Z)

PNG_IMPEXP png_uint_32()	png_get_gAMA (png_const_structrp png_ptr, png_const_inforp info_ptr, double *file_gamma)

PNG_IMPEXP png_uint_32()	png_get_gAMA_fixed (png_const_structrp png_ptr, png_const_inforp info_ptr, png_fixed_point *int_file_gamma)

PNG_IMPEXP void()	png_set_gAMA (png_const_structrp png_ptr, png_inforp info_ptr, double file_gamma)

PNG_IMPEXP void()	png_set_gAMA_fixed (png_const_structrp png_ptr, png_inforp info_ptr, png_fixed_point int_file_gamma)

PNG_IMPEXP png_uint_32()	png_get_hIST (png_const_structrp png_ptr, png_inforp info_ptr, png_uint_16p *hist)

PNG_IMPEXP void()	png_set_hIST (png_const_structrp png_ptr, png_inforp info_ptr, png_const_uint_16p hist)

PNG_IMPEXP png_uint_32()	png_get_IHDR (png_const_structrp png_ptr, png_const_inforp info_ptr, png_uint_32 width, png_uint_32 height, int bit_depth, int color_type, int interlace_method, int compression_method, int *filter_method)

PNG_IMPEXP void()	png_set_IHDR (png_const_structrp png_ptr, png_inforp info_ptr, png_uint_32 width, png_uint_32 height, int bit_depth, int color_type, int interlace_method, int compression_method, int filter_method)

PNG_IMPEXP png_uint_32()	png_get_oFFs (png_const_structrp png_ptr, png_const_inforp info_ptr, png_int_32 offset_x, png_int_32 offset_y, int *unit_type)

PNG_IMPEXP void()	png_set_oFFs (png_const_structrp png_ptr, png_inforp info_ptr, png_int_32 offset_x, png_int_32 offset_y, int unit_type)

PNG_IMPEXP png_uint_32()	png_get_pCAL (png_const_structrp png_ptr, png_inforp info_ptr, png_charp purpose, png_int_32 X0, png_int_32 X1, int type, int nparams, png_charp units, png_charpp *params)

PNG_IMPEXP void()	png_set_pCAL (png_const_structrp png_ptr, png_inforp info_ptr, png_const_charp purpose, png_int_32 X0, png_int_32 X1, int type, int nparams, png_const_charp units, png_charpp params)

PNG_IMPEXP png_uint_32()	png_get_pHYs (png_const_structrp png_ptr, png_const_inforp info_ptr, png_uint_32 res_x, png_uint_32 res_y, int *unit_type)

PNG_IMPEXP void()	png_set_pHYs (png_const_structrp png_ptr, png_inforp info_ptr, png_uint_32 res_x, png_uint_32 res_y, int unit_type)

PNG_IMPEXP png_uint_32()	png_get_PLTE (png_const_structrp png_ptr, png_inforp info_ptr, png_colorp palette, int num_palette)

PNG_IMPEXP void()	png_set_PLTE (png_structrp png_ptr, png_inforp info_ptr, png_const_colorp palette, int num_palette)

PNG_IMPEXP png_uint_32()	png_get_sBIT (png_const_structrp png_ptr, png_inforp info_ptr, png_color_8p *sig_bit)

PNG_IMPEXP void()	png_set_sBIT (png_const_structrp png_ptr, png_inforp info_ptr, png_const_color_8p sig_bit)

PNG_IMPEXP png_uint_32()	png_get_sRGB (png_const_structrp png_ptr, png_const_inforp info_ptr, int *file_srgb_intent)

PNG_IMPEXP void()	png_set_sRGB (png_const_structrp png_ptr, png_inforp info_ptr, int srgb_intent)

PNG_IMPEXP void()	png_set_sRGB_gAMA_and_cHRM (png_const_structrp png_ptr, png_inforp info_ptr, int srgb_intent)

PNG_IMPEXP png_uint_32()	png_get_iCCP (png_const_structrp png_ptr, png_inforp info_ptr, png_charpp name, int compression_type, png_bytepp profile, png_uint_32 proflen)

PNG_IMPEXP void()	png_set_iCCP (png_const_structrp png_ptr, png_inforp info_ptr, png_const_charp name, int compression_type, png_const_bytep profile, png_uint_32 proflen)

PNG_IMPEXP int()	png_get_sPLT (png_const_structrp png_ptr, png_inforp info_ptr, png_sPLT_tpp entries)

PNG_IMPEXP void()	png_set_sPLT (png_const_structrp png_ptr, png_inforp info_ptr, png_const_sPLT_tp entries, int nentries)

PNG_IMPEXP int()	png_get_text (png_const_structrp png_ptr, png_inforp info_ptr, png_textp text_ptr, int num_text)

PNG_IMPEXP void()	png_set_text (png_const_structrp png_ptr, png_inforp info_ptr, png_const_textp text_ptr, int num_text)

PNG_IMPEXP png_uint_32()	png_get_tIME (png_const_structrp png_ptr, png_inforp info_ptr, png_timep *mod_time)

PNG_IMPEXP void()	png_set_tIME (png_const_structrp png_ptr, png_inforp info_ptr, png_const_timep mod_time)

PNG_IMPEXP png_uint_32()	png_get_tRNS (png_const_structrp png_ptr, png_inforp info_ptr, png_bytep trans_alpha, int num_trans, png_color_16p *trans_color)

PNG_IMPEXP void()	png_set_tRNS (png_structrp png_ptr, png_inforp info_ptr, png_const_bytep trans_alpha, int num_trans, png_const_color_16p trans_color)

PNG_IMPEXP png_uint_32()	png_get_sCAL (png_const_structrp png_ptr, png_const_inforp info_ptr, int unit, double width, double *height)

PNG_IMPEXP png_uint_32()	png_get_sCAL_fixed (png_const_structrp png_ptr, png_const_inforp info_ptr, int unit, png_fixed_point width, png_fixed_point *height)

PNG_IMPEXP png_uint_32()	png_get_sCAL_s (png_const_structrp png_ptr, png_const_inforp info_ptr, int *unit, png_charpp swidth, png_charpp sheight)

PNG_IMPEXP void()	png_set_sCAL (png_const_structrp png_ptr, png_inforp info_ptr, int unit, double width, double height)

PNG_IMPEXP void()	png_set_sCAL_fixed (png_const_structrp png_ptr, png_inforp info_ptr, int unit, png_fixed_point width, png_fixed_point height)

PNG_IMPEXP void()	png_set_sCAL_s (png_const_structrp png_ptr, png_inforp info_ptr, int unit, png_const_charp swidth, png_const_charp sheight)

PNG_IMPEXP void()	png_set_keep_unknown_chunks (png_structrp png_ptr, int keep, png_const_bytep chunk_list, int num_chunks)

PNG_IMPEXP int()	png_handle_as_unknown (png_const_structrp png_ptr, png_const_bytep chunk_name)

PNG_IMPEXP void()	png_set_unknown_chunks (png_const_structrp png_ptr, png_inforp info_ptr, png_const_unknown_chunkp unknowns, int num_unknowns)

PNG_IMPEXP void()	png_set_unknown_chunk_location (png_const_structrp png_ptr, png_inforp info_ptr, int chunk, int location)

PNG_IMPEXP int()	png_get_unknown_chunks (png_const_structrp png_ptr, png_inforp info_ptr, png_unknown_chunkpp entries)

PNG_IMPEXP void()	png_set_invalid (png_const_structrp png_ptr, png_inforp info_ptr, int mask)

PNG_IMPEXP void()	png_read_png (png_structrp png_ptr, png_inforp info_ptr, int transforms, png_voidp params)

PNG_IMPEXP void()	png_write_png (png_structrp png_ptr, png_inforp info_ptr, int transforms, png_voidp params)

PNG_IMPEXP png_const_charp()	png_get_copyright (png_const_structrp png_ptr)

PNG_IMPEXP png_const_charp()	png_get_header_ver (png_const_structrp png_ptr)

PNG_IMPEXP png_const_charp()	png_get_header_version (png_const_structrp png_ptr)

PNG_IMPEXP png_const_charp()	png_get_libpng_ver (png_const_structrp png_ptr)

PNG_IMPEXP png_uint_32()	png_permit_mng_features (png_structrp png_ptr, png_uint_32 mng_features_permitted)

PNG_IMPEXP void()	png_set_user_limits (png_structrp png_ptr, png_uint_32 user_width_max, png_uint_32 user_height_max)

PNG_IMPEXP png_uint_32()	png_get_user_width_max (png_const_structrp png_ptr)

PNG_IMPEXP png_uint_32()	png_get_user_height_max (png_const_structrp png_ptr)

PNG_IMPEXP void()	png_set_chunk_cache_max (png_structrp png_ptr, png_uint_32 user_chunk_cache_max)

PNG_IMPEXP png_uint_32()	png_get_chunk_cache_max (png_const_structrp png_ptr)

PNG_IMPEXP void()	png_set_chunk_malloc_max (png_structrp png_ptr, png_alloc_size_t user_chunk_cache_max)

PNG_IMPEXP png_alloc_size_t()	png_get_chunk_malloc_max (png_const_structrp png_ptr)

PNG_IMPEXP png_uint_32()	png_get_pixels_per_inch (png_const_structrp png_ptr, png_const_inforp info_ptr)

PNG_IMPEXP png_uint_32()	png_get_x_pixels_per_inch (png_const_structrp png_ptr, png_const_inforp info_ptr)

PNG_IMPEXP png_uint_32()	png_get_y_pixels_per_inch (png_const_structrp png_ptr, png_const_inforp info_ptr)

PNG_IMPEXP float()	png_get_x_offset_inches (png_const_structrp png_ptr, png_const_inforp info_ptr)

PNG_IMPEXP png_fixed_point()	png_get_x_offset_inches_fixed (png_const_structrp png_ptr, png_const_inforp info_ptr)

PNG_IMPEXP float()	png_get_y_offset_inches (png_const_structrp png_ptr, png_const_inforp info_ptr)

PNG_IMPEXP png_fixed_point()	png_get_y_offset_inches_fixed (png_const_structrp png_ptr, png_const_inforp info_ptr)

PNG_IMPEXP png_uint_32()	png_get_pHYs_dpi (png_const_structrp png_ptr, png_const_inforp info_ptr, png_uint_32 res_x, png_uint_32 res_y, int *unit_type)

PNG_IMPEXP png_uint_32()	png_get_io_state (png_const_structrp png_ptr)

PNG_IMPEXP png_uint_32()	png_get_io_chunk_type (png_const_structrp png_ptr)

PNG_IMPEXP png_uint_32()	png_get_uint_32 (png_const_bytep buf)

PNG_IMPEXP png_uint_16()	png_get_uint_16 (png_const_bytep buf)

PNG_IMPEXP png_int_32()	png_get_int_32 (png_const_bytep buf)

PNG_IMPEXP png_uint_32()	png_get_uint_31 (png_const_structrp png_ptr, png_const_bytep buf)

PNG_IMPEXP void()	png_save_uint_32 (png_bytep buf, png_uint_32 i)

PNG_IMPEXP void()	png_save_int_32 (png_bytep buf, png_int_32 i)

PNG_IMPEXP void()	png_save_uint_16 (png_bytep buf, unsigned int i)

PNG_IMPEXP int()	png_image_begin_read_from_file (png_imagep image, const char *file_name)

PNG_IMPEXP int()	png_image_begin_read_from_stdio (png_imagep image, FILE *file)

PNG_IMPEXP int()	png_image_begin_read_from_memory (png_imagep image, png_const_voidp memory, png_size_t size)

PNG_IMPEXP int()	png_image_finish_read (png_imagep image, png_const_colorp background, void buffer, png_int_32 row_stride, void colormap)

PNG_IMPEXP void()	png_image_free (png_imagep image)

PNG_IMPEXP int()	png_image_write_to_file (png_imagep image, const char file, int convert_to_8bit, const void buffer, png_int_32 row_stride, const void *colormap)

PNG_IMPEXP int()	png_image_write_to_stdio (png_imagep image, FILE file, int convert_to_8_bit, const void buffer, png_int_32 row_stride, const void *colormap)

PNG_IMPEXP void()	png_set_check_for_invalid_index (png_structrp png_ptr, int allowed)

PNG_IMPEXP int()	png_get_palette_max (png_const_structp png_ptr, png_const_infop info_ptr)

PNG_IMPEXP int()	png_set_option (png_structrp png_ptr, int option, int onoff)

Macro Definition Documentation

#define PNG_LIBPNG_VER_STRING "1.6.16"

#define PNG_HEADER_VERSION_STRING " libpng version 1.6.16 - December 22, 2014\n"

#define PNG_LIBPNG_VER_SONUM 16

#define PNG_LIBPNG_VER_DLLNUM 16

#define PNG_LIBPNG_VER_MAJOR 1

#define PNG_LIBPNG_VER_MINOR 6

#define PNG_LIBPNG_VER_RELEASE 16

#define PNG_LIBPNG_VER_BUILD 0

#define PNG_LIBPNG_BUILD_ALPHA 1

#define PNG_LIBPNG_BUILD_BETA 2

#define PNG_LIBPNG_BUILD_RC 3

#define PNG_LIBPNG_BUILD_STABLE 4

#define PNG_LIBPNG_BUILD_RELEASE_STATUS_MASK 7

#define PNG_LIBPNG_BUILD_PATCH

Value:

8 /* Can be OR'ed with

PNG_LIBPNG_BUILD_STABLE only */

#define PNG_LIBPNG_BUILD_PRIVATE

Value:

16 /* Cannot be OR'ed with

PNG_LIBPNG_BUILD_SPECIAL */

#define PNG_LIBPNG_BUILD_SPECIAL

Value:

32 /* Cannot be OR'ed with

PNG_LIBPNG_BUILD_PRIVATE */

#define PNG_LIBPNG_BUILD_BASE_TYPE PNG_LIBPNG_BUILD_STABLE

#define PNG_LIBPNG_VER 10616 /* 1.6.16 */

#define PNG_LIBPNG_BUILD_TYPE (PNG_LIBPNG_BUILD_BASE_TYPE)

#define png_libpng_ver png_get_header_ver(NULL)

#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 */

#define PNG_HAVE_IHDR 0x01

#define PNG_HAVE_PLTE 0x02

#define PNG_AFTER_IDAT 0x08

#define PNG_UINT_31_MAX ((png_uint_32)0x7fffffffL)

#define PNG_UINT_32_MAX ((png_uint_32)(-1))

#define PNG_SIZE_MAX ((png_size_t)(-1))

#define PNG_FP_1 100000

#define PNG_FP_HALF 50000

#define PNG_FP_MAX ((png_fixed_point)0x7fffffffL)

#define PNG_FP_MIN (-PNG_FP_MAX)

#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)

#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

#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 0x8000 /* ESR, 1.0.6 */

#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_TRANSFORM_STRIP_FILLER_BEFORE PNG_TRANSFORM_STRIP_FILLER

#define PNG_TRANSFORM_STRIP_FILLER_AFTER 0x1000 /* write only */

#define PNG_TRANSFORM_GRAY_TO_RGB 0x2000 /* read only */

#define PNG_TRANSFORM_EXPAND_16 0x4000 /* read only */

#define PNG_TRANSFORM_SCALE_16 0x8000 /* read only */

#define PNG_FLAG_MNG_EMPTY_PLTE 0x01

#define PNG_FLAG_MNG_FILTER_64 0x04

#define PNG_ALL_MNG_FEATURES 0x05

#define png_check_sig	(	sig,
		n
	)	!png_sig_cmp((sig), 0, (n))

#define png_jmpbuf ( png_ptr ) (*png_set_longjmp_fn((png_ptr), longjmp, (sizeof (jmp_buf))))

#define PNG_ERROR_ACTION_NONE 1

#define PNG_ERROR_ACTION_WARN 2

#define PNG_ERROR_ACTION_ERROR 3

#define PNG_RGB_TO_GRAY_DEFAULT (-1)/*for red/green coefficients*/

#define PNG_ALPHA_PNG 0 /* according to the PNG standard */

#define PNG_ALPHA_STANDARD 1 /* according to Porter/Duff */

#define PNG_ALPHA_ASSOCIATED 1 /* as above; this is the normal practice */

#define PNG_ALPHA_PREMULTIPLIED 1 /* as above */

#define PNG_ALPHA_OPTIMIZED 2 /* 'PNG' for opaque pixels, else 'STANDARD' */

#define PNG_ALPHA_BROKEN 3 /* the alpha channel is gamma encoded */

#define PNG_DEFAULT_sRGB -1 /* sRGB gamma and color space */

#define PNG_GAMMA_MAC_18 -2 /* Old Mac '1.8' gamma and color space */

#define PNG_GAMMA_sRGB 220000 /* Television standards--matches sRGB gamma */

#define PNG_GAMMA_LINEAR PNG_FP_1 /* Linear */

#define PNG_FILLER_BEFORE 0

#define PNG_FILLER_AFTER 1

#define PNG_BACKGROUND_GAMMA_UNKNOWN 0

#define PNG_BACKGROUND_GAMMA_SCREEN 1

#define PNG_BACKGROUND_GAMMA_FILE 2

#define PNG_BACKGROUND_GAMMA_UNIQUE 3

#define PNG_READ_16_TO_8 SUPPORTED /* Name prior to 1.5.4 */

#define PNG_GAMMA_THRESHOLD (PNG_GAMMA_THRESHOLD_FIXED*.00001)

#define PNG_CRC_DEFAULT 0 /* error/quit warn/discard data */

#define PNG_CRC_ERROR_QUIT 1 /* error/quit error/quit */

#define PNG_CRC_WARN_DISCARD 2 /* (INVALID) warn/discard data */

#define PNG_CRC_WARN_USE 3 /* warn/use data warn/use data */

#define PNG_CRC_QUIET_USE 4 /* quiet/use data quiet/use data */

#define PNG_CRC_NO_CHANGE 5 /* use current value use current value */

#define PNG_NO_FILTERS 0x00

#define PNG_FILTER_NONE 0x08

#define PNG_FILTER_SUB 0x10

#define PNG_FILTER_UP 0x20

#define PNG_FILTER_AVG 0x40

#define PNG_FILTER_PAETH 0x80

#define PNG_ALL_FILTERS

Value:

(PNG_FILTER_NONE | PNG_FILTER_SUB | PNG_FILTER_UP | \

PNG_FILTER_AVG | PNG_FILTER_PAETH)

PNG_FILTER_PAETH

#define PNG_FILTER_PAETH

Definition: png.h:1605

PNG_FILTER_SUB

#define PNG_FILTER_SUB

Definition: png.h:1602

PNG_FILTER_UP

#define PNG_FILTER_UP

Definition: png.h:1603

PNG_FILTER_AVG

#define PNG_FILTER_AVG

Definition: png.h:1604

PNG_FILTER_NONE

#define PNG_FILTER_NONE

Definition: png.h:1601

#define PNG_FILTER_VALUE_NONE 0

#define PNG_FILTER_VALUE_SUB 1

#define PNG_FILTER_VALUE_UP 2

#define PNG_FILTER_VALUE_AVG 3

#define PNG_FILTER_VALUE_PAETH 4

#define PNG_FILTER_VALUE_LAST 5

#define PNG_FILTER_HEURISTIC_DEFAULT 0 /* Currently "UNWEIGHTED" */

#define PNG_FILTER_HEURISTIC_UNWEIGHTED 1 /* Used by libpng < 0.95 */

#define PNG_FILTER_HEURISTIC_WEIGHTED 2 /* Experimental feature */

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

#define PNG_DESTROY_WILL_FREE_DATA 1

#define PNG_SET_WILL_FREE_DATA 1

#define PNG_USER_WILL_FREE_DATA 2

#define PNG_FREE_HIST 0x0008

#define PNG_FREE_ICCP 0x0010

#define PNG_FREE_SPLT 0x0020

#define PNG_FREE_ROWS 0x0040

#define PNG_FREE_PCAL 0x0080

#define PNG_FREE_SCAL 0x0100

#define PNG_FREE_UNKN 0x0200

#define PNG_FREE_PLTE 0x1000

#define PNG_FREE_TRNS 0x2000

#define PNG_FREE_TEXT 0x4000

#define PNG_FREE_ALL 0x7fff

#define PNG_FREE_MUL 0x4220 /* PNG_FREE_SPLT|PNG_FREE_TEXT|PNG_FREE_UNKN */

#define PNG_HANDLE_CHUNK_AS_DEFAULT 0

#define PNG_HANDLE_CHUNK_NEVER 1

#define PNG_HANDLE_CHUNK_IF_SAFE 2

#define PNG_HANDLE_CHUNK_ALWAYS 3

#define PNG_HANDLE_CHUNK_LAST 4

#define PNG_IO_NONE 0x0000 /* no I/O at this moment */

#define PNG_IO_READING 0x0001 /* currently reading */

#define PNG_IO_WRITING 0x0002 /* currently writing */

#define PNG_IO_SIGNATURE 0x0010 /* currently at the file signature */

#define PNG_IO_CHUNK_HDR 0x0020 /* currently at the chunk header */

#define PNG_IO_CHUNK_DATA 0x0040 /* currently at the chunk data */

#define PNG_IO_CHUNK_CRC 0x0080 /* currently at the chunk crc */

#define PNG_IO_MASK_OP 0x000f /* current operation: reading/writing */

#define PNG_IO_MASK_LOC 0x00f0 /* current location: sig/hdr/data/crc */

#define PNG_INTERLACE_ADAM7_PASSES 7

#define PNG_PASS_START_ROW ( pass ) (((1&~(pass))<<(3-((pass)>>1)))&7)

#define PNG_PASS_START_COL ( pass ) (((1& (pass))<<(3-(((pass)+1)>>1)))&7)

#define PNG_PASS_ROW_OFFSET ( pass ) ((pass)>2?(8>>(((pass)-1)>>1)):8)

#define PNG_PASS_COL_OFFSET ( pass ) (1<<((7-(pass))>>1))

#define PNG_PASS_ROW_SHIFT ( pass ) ((pass)>2?(8-(pass))>>1:3)

#define PNG_PASS_COL_SHIFT ( pass ) ((pass)>1?(7-(pass))>>1:3)

#define PNG_PASS_ROWS	(	height,
		pass
	)

Value:

(((height)+(((1<<PNG_PASS_ROW_SHIFT(pass))\

-1)-PNG_PASS_START_ROW(pass)))>>PNG_PASS_ROW_SHIFT(pass))

PNG_PASS_START_ROW

#define PNG_PASS_START_ROW(pass)

Definition: png.h:2595

PNG_PASS_ROW_SHIFT

#define PNG_PASS_ROW_SHIFT(pass)

Definition: png.h:2610

#define PNG_PASS_COLS	(	width,
		pass
	)

Value:

(((width)+(((1<<PNG_PASS_COL_SHIFT(pass))\

-1)-PNG_PASS_START_COL(pass)))>>PNG_PASS_COL_SHIFT(pass))

PNG_PASS_START_COL

#define PNG_PASS_START_COL(pass)

Definition: png.h:2596

PNG_PASS_COL_SHIFT

#define PNG_PASS_COL_SHIFT(pass)

Definition: png.h:2611

#define PNG_ROW_FROM_PASS_ROW	(	y_in,
		pass
	)	(((y_in)<<PNG_PASS_ROW_SHIFT(pass))+PNG_PASS_START_ROW(pass))

#define PNG_COL_FROM_PASS_COL	(	x_in,
		pass
	)	(((x_in)<<PNG_PASS_COL_SHIFT(pass))+PNG_PASS_START_COL(pass))

#define PNG_PASS_MASK	(	pass,
		off
	)

Value:

( \
   ((0x110145AF>>(((7-(off))-(pass))<<2)) & 0xF) | \
   ((0x01145AF0>>(((7-(off))-(pass))<<2)) & 0xF0))

#define PNG_ROW_IN_INTERLACE_PASS	(	y,
		pass
	)	((PNG_PASS_MASK(pass,0) >> ((y)&7)) & 1)

#define PNG_COL_IN_INTERLACE_PASS	(	x,
		pass
	)	((PNG_PASS_MASK(pass,1) >> ((x)&7)) & 1)

#define png_composite	(	composite,
		fg,
		alpha,
		bg
	)

Value:

{ png_uint_16 temp = (png_uint_16)((png_uint_16)(fg) \
           * (png_uint_16)(alpha)                         \
           + (png_uint_16)(bg)*(png_uint_16)(255          \
           - (png_uint_16)(alpha)) + 128);                \
       (composite) = (png_byte)((temp + (temp >> 8)) >> 8); }

#define png_composite_16	(	composite,
		fg,
		alpha,
		bg
	)

Value:

{ png_uint_32 temp = (png_uint_32)((png_uint_32)(fg)  \
           * (png_uint_32)(alpha)                          \
           + (png_uint_32)(bg)*(65535                      \
           - (png_uint_32)(alpha)) + 32768);               \
       (composite) = (png_uint_16)((temp + (temp >> 16)) >> 16); }

#define PNG_get_uint_32 ( buf )

Value:

(((png_uint_32)(*(buf)) << 24) + \
      ((png_uint_32)(*((buf) + 1)) << 16) + \
      ((png_uint_32)(*((buf) + 2)) << 8) + \
      ((png_uint_32)(*((buf) + 3))))

#define PNG_get_uint_16 ( buf )

Value:

((png_uint_16) \
      (((unsigned int)(*(buf)) << 8) + \
       ((unsigned int)(*((buf) + 1)))))

#define PNG_get_int_32 ( buf )

Value:

((png_int_32)((*(buf) & 0x80) \
      ? -((png_int_32)((png_get_uint_32(buf) ^ 0xffffffffL) + 1)) \
      : (png_int_32)png_get_uint_32(buf)))

#define png_get_uint_32 ( buf ) PNG_get_uint_32(buf)

#define png_get_uint_16 ( buf ) PNG_get_uint_16(buf)

#define png_get_int_32 ( buf ) PNG_get_int_32(buf)

#define PNG_IMAGE_VERSION 1

#define PNG_IMAGE_WARNING 1

#define PNG_IMAGE_ERROR 2

#define PNG_IMAGE_FAILED ( png_cntrl ) ((((png_cntrl).warning_or_error)&0x03)>1)

#define PNG_FORMAT_FLAG_ALPHA 0x01U /* format with an alpha channel */

#define PNG_FORMAT_FLAG_COLOR 0x02U /* color format: otherwise grayscale */

#define PNG_FORMAT_FLAG_LINEAR 0x04U /* 2 byte channels else 1 byte */

#define PNG_FORMAT_FLAG_COLORMAP 0x08U /* image data is color-mapped */

#define PNG_FORMAT_FLAG_BGR 0x10U /* BGR colors, else order is RGB */

#define PNG_FORMAT_FLAG_AFIRST 0x20U /* alpha channel comes first */

#define PNG_FORMAT_GRAY 0

#define PNG_FORMAT_GA PNG_FORMAT_FLAG_ALPHA

#define PNG_FORMAT_AG (PNG_FORMAT_GA|PNG_FORMAT_FLAG_AFIRST)

#define PNG_FORMAT_RGB PNG_FORMAT_FLAG_COLOR

#define PNG_FORMAT_BGR (PNG_FORMAT_FLAG_COLOR|PNG_FORMAT_FLAG_BGR)

#define PNG_FORMAT_RGBA (PNG_FORMAT_RGB|PNG_FORMAT_FLAG_ALPHA)

#define PNG_FORMAT_ARGB (PNG_FORMAT_RGBA|PNG_FORMAT_FLAG_AFIRST)

#define PNG_FORMAT_BGRA (PNG_FORMAT_BGR|PNG_FORMAT_FLAG_ALPHA)

#define PNG_FORMAT_ABGR (PNG_FORMAT_BGRA|PNG_FORMAT_FLAG_AFIRST)

#define PNG_FORMAT_LINEAR_Y PNG_FORMAT_FLAG_LINEAR

#define PNG_FORMAT_LINEAR_Y_ALPHA (PNG_FORMAT_FLAG_LINEAR|PNG_FORMAT_FLAG_ALPHA)

#define PNG_FORMAT_LINEAR_RGB (PNG_FORMAT_FLAG_LINEAR|PNG_FORMAT_FLAG_COLOR)

#define PNG_FORMAT_LINEAR_RGB_ALPHA (PNG_FORMAT_FLAG_LINEAR|PNG_FORMAT_FLAG_COLOR|PNG_FORMAT_FLAG_ALPHA)

#define PNG_FORMAT_RGB_COLORMAP (PNG_FORMAT_RGB|PNG_FORMAT_FLAG_COLORMAP)

#define PNG_FORMAT_BGR_COLORMAP (PNG_FORMAT_BGR|PNG_FORMAT_FLAG_COLORMAP)

#define PNG_FORMAT_RGBA_COLORMAP (PNG_FORMAT_RGBA|PNG_FORMAT_FLAG_COLORMAP)

#define PNG_FORMAT_ARGB_COLORMAP (PNG_FORMAT_ARGB|PNG_FORMAT_FLAG_COLORMAP)

#define PNG_FORMAT_BGRA_COLORMAP (PNG_FORMAT_BGRA|PNG_FORMAT_FLAG_COLORMAP)

#define PNG_FORMAT_ABGR_COLORMAP (PNG_FORMAT_ABGR|PNG_FORMAT_FLAG_COLORMAP)

#define PNG_IMAGE_SAMPLE_CHANNELS ( fmt ) (((fmt)&(PNG_FORMAT_FLAG_COLOR|PNG_FORMAT_FLAG_ALPHA))+1)

#define PNG_IMAGE_SAMPLE_COMPONENT_SIZE ( fmt ) ((((fmt) & PNG_FORMAT_FLAG_LINEAR) >> 2)+1)

#define PNG_IMAGE_SAMPLE_SIZE ( fmt ) (PNG_IMAGE_SAMPLE_CHANNELS(fmt) * PNG_IMAGE_SAMPLE_COMPONENT_SIZE(fmt))

#define PNG_IMAGE_MAXIMUM_COLORMAP_COMPONENTS ( fmt ) (PNG_IMAGE_SAMPLE_CHANNELS(fmt) * 256)

#define PNG_IMAGE_PIXEL_	(	test,
		fmt
	)	(((fmt)&PNG_FORMAT_FLAG_COLORMAP)?1:test(fmt))

#define PNG_IMAGE_PIXEL_CHANNELS ( fmt ) PNG_IMAGE_PIXEL_(PNG_IMAGE_SAMPLE_CHANNELS,fmt)

#define PNG_IMAGE_PIXEL_COMPONENT_SIZE ( fmt ) PNG_IMAGE_PIXEL_(PNG_IMAGE_SAMPLE_COMPONENT_SIZE,fmt)

#define PNG_IMAGE_PIXEL_SIZE ( fmt ) PNG_IMAGE_PIXEL_(PNG_IMAGE_SAMPLE_SIZE,fmt)

#define PNG_IMAGE_ROW_STRIDE ( image ) (PNG_IMAGE_PIXEL_CHANNELS((image).format) * (image).width)

#define PNG_IMAGE_BUFFER_SIZE	(	image,
		row_stride
	)	(PNG_IMAGE_PIXEL_COMPONENT_SIZE((image).format)(image).height(row_stride))

#define PNG_IMAGE_SIZE ( image ) PNG_IMAGE_BUFFER_SIZE(image, PNG_IMAGE_ROW_STRIDE(image))

#define PNG_IMAGE_COLORMAP_SIZE ( image ) (PNG_IMAGE_SAMPLE_SIZE((image).format) * (image).colormap_entries)

#define PNG_IMAGE_FLAG_COLORSPACE_NOT_sRGB 0x01

#define PNG_IMAGE_FLAG_FAST 0x02

#define PNG_IMAGE_FLAG_16BIT_sRGB 0x04

#define PNG_MAXIMUM_INFLATE_WINDOW 2 /* SOFTWARE: force maximum window */

#define PNG_SKIP_sRGB_CHECK_PROFILE 4 /* SOFTWARE: Check ICC profile for sRGB */

#define PNG_OPTION_NEXT 6 /* Next option - numbers must be even */

#define PNG_OPTION_UNSET 0 /* Unset - defaults to off */

#define PNG_OPTION_INVALID 1 /* Option number out of range */

#define PNG_OPTION_OFF 2

#define PNG_OPTION_ON 3

Typedef Documentation

typedef char* png_libpng_version_1_6_16

typedef struct png_struct_def png_struct

typedef const png_struct* png_const_structp

typedef png_struct* png_structp

typedef png_struct* * png_structpp

typedef struct png_info_def png_info

typedef png_info* png_infop

typedef const png_info* png_const_infop

typedef png_info* * png_infopp

typedef png_struct* png_structrp

typedef const png_struct* png_const_structrp

typedef png_info* png_inforp

typedef const png_info* png_const_inforp

typedef struct png_color_struct png_color

typedef png_color* png_colorp

typedef const png_color* png_const_colorp

typedef png_color* * png_colorpp

typedef struct png_color_16_struct png_color_16

typedef png_color_16* png_color_16p

typedef const png_color_16* png_const_color_16p

typedef png_color_16* * png_color_16pp

typedef struct png_color_8_struct png_color_8

typedef png_color_8* png_color_8p

typedef const png_color_8* png_const_color_8p

typedef png_color_8* * png_color_8pp

typedef struct png_sPLT_entry_struct png_sPLT_entry

typedef png_sPLT_entry* png_sPLT_entryp

typedef const png_sPLT_entry* png_const_sPLT_entryp

typedef png_sPLT_entry* * png_sPLT_entrypp

typedef struct png_sPLT_struct png_sPLT_t

typedef png_sPLT_t* png_sPLT_tp

typedef const png_sPLT_t* png_const_sPLT_tp

typedef png_sPLT_t* * png_sPLT_tpp

typedef struct png_text_struct png_text

typedef png_text* png_textp

typedef const png_text* png_const_textp

typedef png_text* * png_textpp

typedef struct png_time_struct png_time

typedef png_time* png_timep

typedef const png_time* png_const_timep

typedef png_time* * png_timepp

typedef struct png_unknown_chunk_t png_unknown_chunk

typedef png_unknown_chunk* png_unknown_chunkp

typedef const png_unknown_chunk* png_const_unknown_chunkp

typedef png_unknown_chunk* * png_unknown_chunkpp

typedef struct png_row_info_struct png_row_info

typedef png_row_info* png_row_infop

typedef png_row_info* * png_row_infopp

typedef void( * png_error_ptr) (png_structp, png_const_charp)

typedef void( * png_rw_ptr) (png_structp, png_bytep, png_size_t)

typedef void( * png_flush_ptr) (png_structp)

typedef void( * png_read_status_ptr) (png_structp, png_uint_32, int)

typedef void( * png_write_status_ptr) (png_structp, png_uint_32, int)

typedef void( * png_progressive_info_ptr) (png_structp, png_infop)

typedef void( * png_progressive_end_ptr) (png_structp, png_infop)

typedef void( * png_progressive_row_ptr) (png_structp, png_bytep, png_uint_32, int)

typedef void( * png_user_transform_ptr) (png_structp, png_row_infop, png_bytep)

typedef int( * png_user_chunk_ptr) (png_structp, png_unknown_chunkp)

typedef void( * png_longjmp_ptr) (jmp_buf, int)

typedef png_voidp( * png_malloc_ptr) (png_structp, png_alloc_size_t)

typedef void( * png_free_ptr) (png_structp, png_voidp)

typedef struct png_control* png_controlp

typedef struct png_image * png_imagep

Function Documentation

PNG_IMPEXP png_uint_32() png_access_version_number ( void )

 {
    /* Version of *.c files used when building libpng */
    return((png_uint_32)PNG_LIBPNG_VER);
 }

PNG_IMPEXP void() png_set_sig_bytes	(	png_structrp	png_ptr,
		int	num_bytes
	)

 {
    png_debug(1, "in png_set_sig_bytes");
 
    if (png_ptr == NULL)
       return;
 
    if (num_bytes > 8)
       png_error(png_ptr, "Too many bytes for PNG signature");
 
    png_ptr->sig_bytes = (png_byte)(num_bytes < 0 ? 0 : num_bytes);
 }

PNG_IMPEXP int() png_sig_cmp	(	png_const_bytep	sig,
		png_size_t	start,
		png_size_t	num_to_check
	)

 {
    png_byte png_signature[8] = {137, 80, 78, 71, 13, 10, 26, 10};
 
    if (num_to_check > 8)
       num_to_check = 8;
 
    else if (num_to_check < 1)
       return (-1);
 
    if (start > 7)
       return (-1);
 
    if (start + num_to_check > 8)
       num_to_check = 8 - start;
 
    return ((int)(memcmp(&sig[start], &png_signature[start], num_to_check)));
 }

PNG_IMPEXP png_structp() png_create_read_struct	(	png_const_charp	user_png_ver,
		png_voidp	error_ptr,
		png_error_ptr	error_fn,
		png_error_ptr	warn_fn
	)

 {
 #ifndef PNG_USER_MEM_SUPPORTED
    png_structp png_ptr = png_create_png_struct(user_png_ver, error_ptr,
       error_fn, warn_fn, NULL, NULL, NULL);
 #else
    return png_create_read_struct_2(user_png_ver, error_ptr, error_fn,
        warn_fn, NULL, NULL, NULL);
 }

PNG_IMPEXP png_structp() png_create_write_struct	(	png_const_charp	user_png_ver,
		png_voidp	error_ptr,
		png_error_ptr	error_fn,
		png_error_ptr	warn_fn
	)

 {
 #ifndef PNG_USER_MEM_SUPPORTED
    png_structrp png_ptr = png_create_png_struct(user_png_ver, error_ptr,
        error_fn, warn_fn, NULL, NULL, NULL);
 #else
    return png_create_write_struct_2(user_png_ver, error_ptr, error_fn,
        warn_fn, NULL, NULL, NULL);
 }

PNG_IMPEXP png_size_t() png_get_compression_buffer_size ( png_const_structrp png_ptr )

 {
    if (png_ptr == NULL)
       return 0;
 
 #  ifdef PNG_WRITE_SUPPORTED
       if ((png_ptr->mode & PNG_IS_READ_STRUCT) != 0)
 #  endif
    {
 #     ifdef PNG_SEQUENTIAL_READ_SUPPORTED
          return png_ptr->IDAT_read_size;
 #     else
          return PNG_IDAT_READ_SIZE;
 #     endif
    }
 
 #  ifdef PNG_WRITE_SUPPORTED
       else
          return png_ptr->zbuffer_size;
 #  endif
 }

PNG_IMPEXP void() png_set_compression_buffer_size	(	png_structrp	png_ptr,
		png_size_t	size
	)

 {
     if (png_ptr == NULL)
        return;
 
     if (size == 0 || size > PNG_UINT_31_MAX)
        png_error(png_ptr, "invalid compression buffer size");
 
 #  ifdef PNG_SEQUENTIAL_READ_SUPPORTED
       if ((png_ptr->mode & PNG_IS_READ_STRUCT) != 0)
       {
          png_ptr->IDAT_read_size = (png_uint_32)size; /* checked above */
          return;
       }
 #  endif
 
 #  ifdef PNG_WRITE_SUPPORTED
       if ((png_ptr->mode & PNG_IS_READ_STRUCT) == 0)
       {
          if (png_ptr->zowner != 0)
          {
             png_warning(png_ptr,
               "Compression buffer size cannot be changed because it is in use");
             return;
          }
 
          if (size > ZLIB_IO_MAX)
          {
             png_warning(png_ptr,
                "Compression buffer size limited to system maximum");
             size = ZLIB_IO_MAX; /* must fit */
          }
 
          else if (size < 6)
          {
             /* Deflate will potentially go into an infinite loop on a SYNC_FLUSH
              * if this is permitted.
              */
             png_warning(png_ptr,
                "Compression buffer size cannot be reduced below 6");
             return;
          }
 
          if (png_ptr->zbuffer_size != size)
          {
             png_free_buffer_list(png_ptr, &png_ptr->zbuffer_list);
             png_ptr->zbuffer_size = (uInt)size;
          }
       }
 #  endif
 }

PNG_IMPEXP jmp_buf*() png_set_longjmp_fn	(	png_structrp	png_ptr,
		png_longjmp_ptr	longjmp_fn,
		size_t	jmp_buf_size
	)

 {
    /* From libpng 1.6.0 the app gets one chance to set a 'jmpbuf_size' value
     * and it must not change after that.  Libpng doesn't care how big the
     * buffer is, just that it doesn't change.
     *
     * If the buffer size is no *larger* than the size of jmp_buf when libpng is
     * compiled a built in jmp_buf is returned; this preserves the pre-1.6.0
     * semantics that this call will not fail.  If the size is larger, however,
     * the buffer is allocated and this may fail, causing the function to return
     * NULL.
     */
    if (png_ptr == NULL)
       return NULL;
 
    if (png_ptr->jmp_buf_ptr == NULL)
    {
       png_ptr->jmp_buf_size = 0; /* not allocated */
 
       if (jmp_buf_size <= (sizeof png_ptr->jmp_buf_local))
          png_ptr->jmp_buf_ptr = &png_ptr->jmp_buf_local;
 
       else
       {
          png_ptr->jmp_buf_ptr = png_voidcast(jmp_buf *,
             png_malloc_warn(png_ptr, jmp_buf_size));
 
          if (png_ptr->jmp_buf_ptr == NULL)
             return NULL; /* new NULL return on OOM */
 
          png_ptr->jmp_buf_size = jmp_buf_size;
       }
    }
 
    else /* Already allocated: check the size */
    {
       size_t size = png_ptr->jmp_buf_size;
 
       if (size == 0)
       {
          size = (sizeof png_ptr->jmp_buf_local);
          if (png_ptr->jmp_buf_ptr != &png_ptr->jmp_buf_local)
          {
             /* This is an internal error in libpng: somehow we have been left
              * with a stack allocated jmp_buf when the application regained
              * control.  It's always possible to fix this up, but for the moment
              * this is a png_error because that makes it easy to detect.
              */
             png_error(png_ptr, "Libpng jmp_buf still allocated");
             /* png_ptr->jmp_buf_ptr = &png_ptr->jmp_buf_local; */
          }
       }
 
       if (size != jmp_buf_size)
       {
          png_warning(png_ptr, "Application jmp_buf size changed");
          return NULL; /* caller will probably crash: no choice here */
       }
    }
 
    /* Finally fill in the function, now we have a satisfactory buffer. It is
     * valid to change the function on every call.
     */
    png_ptr->longjmp_fn = longjmp_fn;
    return png_ptr->jmp_buf_ptr;
 }

PNG_IMPEXP void() png_longjmp	(	png_const_structrp	png_ptr,
		int	val
	)

 {
 #ifdef PNG_SETJMP_SUPPORTED
    if (png_ptr != NULL && png_ptr->longjmp_fn != NULL &&
        png_ptr->jmp_buf_ptr != NULL)
       png_ptr->longjmp_fn(*png_ptr->jmp_buf_ptr, val);
 #else
    PNG_UNUSED(png_ptr)
    PNG_UNUSED(val)
 #endif
 
    /* If control reaches this point, png_longjmp() must not return. The only
     * choice is to terminate the whole process (or maybe the thread); to do
     * this the ANSI-C abort() function is used unless a different method is 
     * implemented by overriding the default configuration setting for
     * PNG_ABORT().
     */
    PNG_ABORT();
 }

PNG_DEPRECATED PNG_IMPEXP int() png_reset_zstream ( png_structrp png_ptr )

 {
    if (png_ptr == NULL)
       return Z_STREAM_ERROR;
 
    /* WARNING: this resets the window bits to the maximum! */
    return (inflateReset(&png_ptr->zstream));
 }

PNG_IMPEXP png_structp() png_create_read_struct_2	(	png_const_charp	user_png_ver,
		png_voidp	error_ptr,
		png_error_ptr	error_fn,
		png_error_ptr	warn_fn,
		png_voidp	mem_ptr,
		png_malloc_ptr	malloc_fn,
		png_free_ptr	free_fn
	)

 {
    png_structp png_ptr = png_create_png_struct(user_png_ver, error_ptr,
       error_fn, warn_fn, mem_ptr, malloc_fn, free_fn);
 #endif /* USER_MEM */
 
    if (png_ptr != NULL)
    {
       png_ptr->mode = PNG_IS_READ_STRUCT;
 
       /* Added in libpng-1.6.0; this can be used to detect a read structure if
        * required (it will be zero in a write structure.)
        */
 #     ifdef PNG_SEQUENTIAL_READ_SUPPORTED
          png_ptr->IDAT_read_size = PNG_IDAT_READ_SIZE;
 #     endif
 
 #     ifdef PNG_BENIGN_READ_ERRORS_SUPPORTED
          png_ptr->flags |= PNG_FLAG_BENIGN_ERRORS_WARN;
 
          /* In stable builds only warn if an application error can be completely
           * handled.
           */
 #        if PNG_LIBPNG_BUILD_BASE_TYPE >= PNG_LIBPNG_BUILD_RC
             png_ptr->flags |= PNG_FLAG_APP_WARNINGS_WARN;
 #        endif
 #     endif
 
       /* TODO: delay this, it can be done in png_init_io (if the app doesn't
        * do it itself) avoiding setting the default function if it is not
        * required.
        */
       png_set_read_fn(png_ptr, NULL, NULL);
    }
 
    return png_ptr;
 }

PNG_IMPEXP png_structp() png_create_write_struct_2	(	png_const_charp	user_png_ver,
		png_voidp	error_ptr,
		png_error_ptr	error_fn,
		png_error_ptr	warn_fn,
		png_voidp	mem_ptr,
		png_malloc_ptr	malloc_fn,
		png_free_ptr	free_fn
	)

 {
    png_structrp png_ptr = png_create_png_struct(user_png_ver, error_ptr,
        error_fn, warn_fn, mem_ptr, malloc_fn, free_fn);
 #endif /* USER_MEM */
    if (png_ptr != NULL)
    {
       /* Set the zlib control values to defaults; they can be overridden by the
        * application after the struct has been created.
        */
       png_ptr->zbuffer_size = PNG_ZBUF_SIZE;
 
       /* The 'zlib_strategy' setting is irrelevant because png_default_claim in
        * pngwutil.c defaults it according to whether or not filters will be
        * used, and ignores this setting.
        */
       png_ptr->zlib_strategy = PNG_Z_DEFAULT_STRATEGY;
       png_ptr->zlib_level = PNG_Z_DEFAULT_COMPRESSION;
       png_ptr->zlib_mem_level = 8;
       png_ptr->zlib_window_bits = 15;
       png_ptr->zlib_method = 8;
 
 #ifdef PNG_WRITE_COMPRESSED_TEXT_SUPPORTED
       png_ptr->zlib_text_strategy = PNG_TEXT_Z_DEFAULT_STRATEGY;
       png_ptr->zlib_text_level = PNG_TEXT_Z_DEFAULT_COMPRESSION;
       png_ptr->zlib_text_mem_level = 8;
       png_ptr->zlib_text_window_bits = 15;
       png_ptr->zlib_text_method = 8;
 #endif /* WRITE_COMPRESSED_TEXT */
 
       /* This is a highly dubious configuration option; by default it is off,
        * but it may be appropriate for private builds that are testing
        * extensions not conformant to the current specification, or of
        * applications that must not fail to write at all costs!
        */
 #ifdef PNG_BENIGN_WRITE_ERRORS_SUPPORTED
       /* In stable builds only warn if an application error can be completely
        * handled.
        */
       png_ptr->flags |= PNG_FLAG_BENIGN_ERRORS_WARN;
 #endif
 
       /* App warnings are warnings in release (or release candidate) builds but
        * are errors during development.
        */
 #if PNG_LIBPNG_BUILD_BASE_TYPE >= PNG_LIBPNG_BUILD_RC
       png_ptr->flags |= PNG_FLAG_APP_WARNINGS_WARN;
 #endif
 
       /* TODO: delay this, it can be done in png_init_io() (if the app doesn't
        * do it itself) avoiding setting the default function if it is not
        * required.
        */
       png_set_write_fn(png_ptr, NULL, NULL, NULL);
    }
 
    return png_ptr;
 }

PNG_IMPEXP void() png_write_sig ( png_structrp png_ptr )

 {
    png_byte png_signature[8] = {137, 80, 78, 71, 13, 10, 26, 10};
 
 #ifdef PNG_IO_STATE_SUPPORTED
    /* Inform the I/O callback that the signature is being written */
    png_ptr->io_state = PNG_IO_WRITING | PNG_IO_SIGNATURE;
 #endif
 
    /* Write the rest of the 8 byte signature */
    png_write_data(png_ptr, &png_signature[png_ptr->sig_bytes],
       (png_size_t)(8 - png_ptr->sig_bytes));
 
    if (png_ptr->sig_bytes < 3)
       png_ptr->mode |= PNG_HAVE_PNG_SIGNATURE;
 }

PNG_IMPEXP void() png_write_chunk	(	png_structrp	png_ptr,
		png_const_bytep	chunk_name,
		png_const_bytep	data,
		png_size_t	length
	)

 {
    png_write_complete_chunk(png_ptr, PNG_CHUNK_FROM_STRING(chunk_string), data,
       length);
 }

PNG_IMPEXP void() png_write_chunk_start	(	png_structrp	png_ptr,
		png_const_bytep	chunk_name,
		png_uint_32	length
	)

 {
    png_write_chunk_header(png_ptr, PNG_CHUNK_FROM_STRING(chunk_string), length);
 }

PNG_IMPEXP void() png_write_chunk_data	(	png_structrp	png_ptr,
		png_const_bytep	data,
		png_size_t	length
	)

 {
    /* Write the data, and run the CRC over it */
    if (png_ptr == NULL)
       return;
 
    if (data != NULL && length > 0)
    {
       png_write_data(png_ptr, data, length);
 
       /* Update the CRC after writing the data,
        * in case the user I/O routine alters it.
        */
       png_calculate_crc(png_ptr, data, length);
    }
 }

PNG_IMPEXP void() png_write_chunk_end ( png_structrp png_ptr )

 {
    png_byte buf[4];
 
    if (png_ptr == NULL) return;
 
 #ifdef PNG_IO_STATE_SUPPORTED
    /* Inform the I/O callback that the chunk CRC is being written.
     * PNG_IO_CHUNK_CRC requires a single I/O function call.
     */
    png_ptr->io_state = PNG_IO_WRITING | PNG_IO_CHUNK_CRC;
 #endif
 
    /* Write the crc in a single operation */
    png_save_uint_32(buf, png_ptr->crc);
 
    png_write_data(png_ptr, buf, (png_size_t)4);
 }

PNG_IMPEXP png_infop() png_create_info_struct ( png_const_structrp png_ptr )

 {
    png_inforp info_ptr;
 
    png_debug(1, "in png_create_info_struct");
 
    if (png_ptr == NULL)
       return NULL;
 
    /* Use the internal API that does not (or at least should not) error out, so
     * that this call always returns ok.  The application typically sets up the
     * error handling *after* creating the info_struct because this is the way it
     * has always been done in 'example.c'.
     */
    info_ptr = png_voidcast(png_inforp, png_malloc_base(png_ptr,
       (sizeof *info_ptr)));
 
    if (info_ptr != NULL)
       memset(info_ptr, 0, (sizeof *info_ptr));
 
    return info_ptr;
 }

PNG_DEPRECATED PNG_IMPEXP void() png_info_init_3	(	png_infopp	info_ptr,
		png_size_t	png_info_struct_size
	)

 {
    png_inforp info_ptr = *ptr_ptr;
 
    png_debug(1, "in png_info_init_3");
 
    if (info_ptr == NULL)
       return;
 
    if ((sizeof (png_info)) > png_info_struct_size)
    {
       *ptr_ptr = NULL;
       /* The following line is why this API should not be used: */
       free(info_ptr);
       info_ptr = png_voidcast(png_inforp, png_malloc_base(NULL,
          (sizeof *info_ptr)));
       *ptr_ptr = info_ptr;
    }
 
    /* Set everything to 0 */
    memset(info_ptr, 0, (sizeof *info_ptr));
 }

PNG_IMPEXP void() png_write_info_before_PLTE	(	png_structrp	png_ptr,
		png_const_inforp	info_ptr
	)

 {
    png_debug(1, "in png_write_info_before_PLTE");
 
    if (png_ptr == NULL || info_ptr == NULL)
       return;
 
    if ((png_ptr->mode & PNG_WROTE_INFO_BEFORE_PLTE) == 0)
    {
    /* Write PNG signature */
    png_write_sig(png_ptr);
 
 #ifdef PNG_MNG_FEATURES_SUPPORTED
    if ((png_ptr->mode & PNG_HAVE_PNG_SIGNATURE) != 0 && \
        png_ptr->mng_features_permitted != 0)
    {
       png_warning(png_ptr, "MNG features are not allowed in a PNG datastream");
       png_ptr->mng_features_permitted = 0;
    }
 #endif
 
    /* Write IHDR information. */
    png_write_IHDR(png_ptr, info_ptr->width, info_ptr->height,
        info_ptr->bit_depth, info_ptr->color_type, info_ptr->compression_type,
        info_ptr->filter_type,
 #ifdef PNG_WRITE_INTERLACING_SUPPORTED
        info_ptr->interlace_type
 #else
        0
 #endif
       );
 
    /* The rest of these check to see if the valid field has the appropriate
     * flag set, and if it does, writes the chunk.
     *
     * 1.6.0: COLORSPACE support controls the writing of these chunks too, and
     * the chunks will be written if the WRITE routine is there and information
     * is available in the COLORSPACE.  (See png_colorspace_sync_info in png.c
     * for where the valid flags get set.)
     *
     * Under certain circumstances the colorspace can be invalidated without
     * syncing the info_struct 'valid' flags; this happens if libpng detects and
     * error and calls png_error while the color space is being set, yet the
     * application continues writing the PNG.  So check the 'invalid' flag here
     * too.
     */
 #ifdef PNG_GAMMA_SUPPORTED
 #  ifdef PNG_WRITE_gAMA_SUPPORTED
       if ((info_ptr->colorspace.flags & PNG_COLORSPACE_INVALID) == 0 &&
           (info_ptr->colorspace.flags & PNG_COLORSPACE_FROM_gAMA) != 0 &&
           (info_ptr->valid & PNG_INFO_gAMA) != 0)
          png_write_gAMA_fixed(png_ptr, info_ptr->colorspace.gamma);
 #  endif
 #endif
 
 #ifdef PNG_COLORSPACE_SUPPORTED
    /* Write only one of sRGB or an ICC profile.  If a profile was supplied
     * and it matches one of the known sRGB ones issue a warning.
     */
 #  ifdef PNG_WRITE_iCCP_SUPPORTED
       if ((info_ptr->colorspace.flags & PNG_COLORSPACE_INVALID) == 0 &&
           (info_ptr->valid & PNG_INFO_iCCP) != 0)
       {
 #        ifdef PNG_WRITE_sRGB_SUPPORTED
             if ((info_ptr->valid & PNG_INFO_sRGB) != 0)
                png_app_warning(png_ptr,
                   "profile matches sRGB but writing iCCP instead");
 #        endif
 
          png_write_iCCP(png_ptr, info_ptr->iccp_name,
             info_ptr->iccp_profile);
       }
 #     ifdef PNG_WRITE_sRGB_SUPPORTED
          else
 #     endif
 #  endif
 
 #  ifdef PNG_WRITE_sRGB_SUPPORTED
       if ((info_ptr->colorspace.flags & PNG_COLORSPACE_INVALID) == 0 &&
           (info_ptr->valid & PNG_INFO_sRGB) != 0)
          png_write_sRGB(png_ptr, info_ptr->colorspace.rendering_intent);
 #  endif /* WRITE_sRGB */
 #endif /* COLORSPACE */
 
 #ifdef PNG_WRITE_sBIT_SUPPORTED
    if ((info_ptr->valid & PNG_INFO_sBIT) != 0)
       png_write_sBIT(png_ptr, &(info_ptr->sig_bit), info_ptr->color_type);
 #endif
 
 #ifdef PNG_COLORSPACE_SUPPORTED
 #  ifdef PNG_WRITE_cHRM_SUPPORTED
       if ((info_ptr->colorspace.flags & PNG_COLORSPACE_INVALID) == 0 &&
          (info_ptr->colorspace.flags & PNG_COLORSPACE_FROM_cHRM) != 0 &&
          (info_ptr->valid & PNG_INFO_cHRM) != 0)
          png_write_cHRM_fixed(png_ptr, &info_ptr->colorspace.end_points_xy);
 #  endif
 #endif
 
 #ifdef PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED
       write_unknown_chunks(png_ptr, info_ptr, PNG_HAVE_IHDR);
 #endif
 
       png_ptr->mode |= PNG_WROTE_INFO_BEFORE_PLTE;
    }
 }

PNG_IMPEXP void() png_write_info	(	png_structrp	png_ptr,
		png_const_inforp	info_ptr
	)

 {
 #if defined(PNG_WRITE_TEXT_SUPPORTED) || defined(PNG_WRITE_sPLT_SUPPORTED)
    int i;
 #endif
 
    png_debug(1, "in png_write_info");
 
    if (png_ptr == NULL || info_ptr == NULL)
       return;
 
    png_write_info_before_PLTE(png_ptr, info_ptr);
 
    if ((info_ptr->valid & PNG_INFO_PLTE) != 0)
       png_write_PLTE(png_ptr, info_ptr->palette,
           (png_uint_32)info_ptr->num_palette);
 
    else if ((info_ptr->color_type == PNG_COLOR_TYPE_PALETTE) !=0)
       png_error(png_ptr, "Valid palette required for paletted images");
 
 #ifdef PNG_WRITE_tRNS_SUPPORTED
    if ((info_ptr->valid & PNG_INFO_tRNS) !=0)
    {
 #ifdef PNG_WRITE_INVERT_ALPHA_SUPPORTED
       /* Invert the alpha channel (in tRNS) */
       if ((png_ptr->transformations & PNG_INVERT_ALPHA) != 0 &&
           info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
       {
          int j;
          for (j = 0; j<(int)info_ptr->num_trans; j++)
             info_ptr->trans_alpha[j] =
                (png_byte)(255 - info_ptr->trans_alpha[j]);
       }
 #endif
       png_write_tRNS(png_ptr, info_ptr->trans_alpha, &(info_ptr->trans_color),
           info_ptr->num_trans, info_ptr->color_type);
    }
 #endif
 #ifdef PNG_WRITE_bKGD_SUPPORTED
    if ((info_ptr->valid & PNG_INFO_bKGD) != 0)
       png_write_bKGD(png_ptr, &(info_ptr->background), info_ptr->color_type);
 #endif
 
 #ifdef PNG_WRITE_hIST_SUPPORTED
    if ((info_ptr->valid & PNG_INFO_hIST) != 0)
       png_write_hIST(png_ptr, info_ptr->hist, info_ptr->num_palette);
 #endif
 
 #ifdef PNG_WRITE_oFFs_SUPPORTED
    if ((info_ptr->valid & PNG_INFO_oFFs) != 0)
       png_write_oFFs(png_ptr, info_ptr->x_offset, info_ptr->y_offset,
           info_ptr->offset_unit_type);
 #endif
 
 #ifdef PNG_WRITE_pCAL_SUPPORTED
    if ((info_ptr->valid & PNG_INFO_pCAL) != 0)
       png_write_pCAL(png_ptr, info_ptr->pcal_purpose, info_ptr->pcal_X0,
           info_ptr->pcal_X1, info_ptr->pcal_type, info_ptr->pcal_nparams,
           info_ptr->pcal_units, info_ptr->pcal_params);
 #endif
 
 #ifdef PNG_WRITE_sCAL_SUPPORTED
    if ((info_ptr->valid & PNG_INFO_sCAL) != 0)
       png_write_sCAL_s(png_ptr, (int)info_ptr->scal_unit,
           info_ptr->scal_s_width, info_ptr->scal_s_height);
 #endif /* sCAL */
 
 #ifdef PNG_WRITE_pHYs_SUPPORTED
    if ((info_ptr->valid & PNG_INFO_pHYs) != 0)
       png_write_pHYs(png_ptr, info_ptr->x_pixels_per_unit,
           info_ptr->y_pixels_per_unit, info_ptr->phys_unit_type);
 #endif /* pHYs */
 
 #ifdef PNG_WRITE_tIME_SUPPORTED
    if ((info_ptr->valid & PNG_INFO_tIME) != 0)
    {
       png_write_tIME(png_ptr, &(info_ptr->mod_time));
       png_ptr->mode |= PNG_WROTE_tIME;
    }
 #endif /* tIME */
 
 #ifdef PNG_WRITE_sPLT_SUPPORTED
    if ((info_ptr->valid & PNG_INFO_sPLT) != 0)
       for (i = 0; i < (int)info_ptr->splt_palettes_num; i++)
          png_write_sPLT(png_ptr, info_ptr->splt_palettes + i);
 #endif /* sPLT */
 
 #ifdef PNG_WRITE_TEXT_SUPPORTED
    /* Check to see if we need to write text chunks */
    for (i = 0; i < info_ptr->num_text; i++)
    {
       png_debug2(2, "Writing header text chunk %d, type %d", i,
           info_ptr->text[i].compression);
       /* An internationalized chunk? */
       if (info_ptr->text[i].compression > 0)
       {
 #ifdef PNG_WRITE_iTXt_SUPPORTED
          /* Write international chunk */
          png_write_iTXt(png_ptr,
              info_ptr->text[i].compression,
              info_ptr->text[i].key,
              info_ptr->text[i].lang,
              info_ptr->text[i].lang_key,
              info_ptr->text[i].text);
          /* Mark this chunk as written */
          if (info_ptr->text[i].compression == PNG_TEXT_COMPRESSION_NONE)
             info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_NONE_WR;
          else
             info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_zTXt_WR;
 #else
          png_warning(png_ptr, "Unable to write international text");
 #endif
       }
 
       /* If we want a compressed text chunk */
       else if (info_ptr->text[i].compression == PNG_TEXT_COMPRESSION_zTXt)
       {
 #ifdef PNG_WRITE_zTXt_SUPPORTED
          /* Write compressed chunk */
          png_write_zTXt(png_ptr, info_ptr->text[i].key,
              info_ptr->text[i].text, info_ptr->text[i].compression);
          /* Mark this chunk as written */
          info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_zTXt_WR;
 #else
          png_warning(png_ptr, "Unable to write compressed text");
 #endif
       }
 
       else if (info_ptr->text[i].compression == PNG_TEXT_COMPRESSION_NONE)
       {
 #ifdef PNG_WRITE_tEXt_SUPPORTED
          /* Write uncompressed chunk */
          png_write_tEXt(png_ptr, info_ptr->text[i].key,
              info_ptr->text[i].text,
              0);
          /* Mark this chunk as written */
          info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_NONE_WR;
 #else
          /* Can't get here */
          png_warning(png_ptr, "Unable to write uncompressed text");
 #endif
       }
    }
 #endif /* tEXt */
 
 #ifdef PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED
    write_unknown_chunks(png_ptr, info_ptr, PNG_HAVE_PLTE);
 #endif
 }

PNG_IMPEXP void() png_read_info	(	png_structrp	png_ptr,
		png_inforp	info_ptr
	)

 {
 #ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED
    int keep;
 #endif
 
    png_debug(1, "in png_read_info");
 
    if (png_ptr == NULL || info_ptr == NULL)
       return;
 
    /* Read and check the PNG file signature. */
    png_read_sig(png_ptr, info_ptr);
 
    for (;;)
    {
       png_uint_32 length = png_read_chunk_header(png_ptr);
       png_uint_32 chunk_name = png_ptr->chunk_name;
 
       /* IDAT logic needs to happen here to simplify getting the two flags
        * right.
        */
       if (chunk_name == png_IDAT)
       {
          if ((png_ptr->mode & PNG_HAVE_IHDR) == 0)
             png_chunk_error(png_ptr, "Missing IHDR before IDAT");
 
          else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE &&
              (png_ptr->mode & PNG_HAVE_PLTE) == 0)
             png_chunk_error(png_ptr, "Missing PLTE before IDAT");
 
          else if ((png_ptr->mode & PNG_AFTER_IDAT) != 0)
             png_chunk_benign_error(png_ptr, "Too many IDATs found");
 
          png_ptr->mode |= PNG_HAVE_IDAT;
       }
 
       else if ((png_ptr->mode & PNG_HAVE_IDAT) != 0)
          png_ptr->mode |= PNG_AFTER_IDAT;
 
       /* This should be a binary subdivision search or a hash for
        * matching the chunk name rather than a linear search.
        */
       if (chunk_name == png_IHDR)
          png_handle_IHDR(png_ptr, info_ptr, length);
 
       else if (chunk_name == png_IEND)
          png_handle_IEND(png_ptr, info_ptr, length);
 
 #ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED
       else if ((keep = png_chunk_unknown_handling(png_ptr, chunk_name)) != 0)
       {
          png_handle_unknown(png_ptr, info_ptr, length, keep);
 
          if (chunk_name == png_PLTE)
             png_ptr->mode |= PNG_HAVE_PLTE;
 
          else if (chunk_name == png_IDAT)
          {
             png_ptr->idat_size = 0; /* It has been consumed */
             break;
          }
       }
 #endif
       else if (chunk_name == png_PLTE)
          png_handle_PLTE(png_ptr, info_ptr, length);
 
       else if (chunk_name == png_IDAT)
       {
          png_ptr->idat_size = length;
          break;
       }
 
 #ifdef PNG_READ_bKGD_SUPPORTED
       else if (chunk_name == png_bKGD)
          png_handle_bKGD(png_ptr, info_ptr, length);
 #endif
 
 #ifdef PNG_READ_cHRM_SUPPORTED
       else if (chunk_name == png_cHRM)
          png_handle_cHRM(png_ptr, info_ptr, length);
 #endif
 
 #ifdef PNG_READ_gAMA_SUPPORTED
       else if (chunk_name == png_gAMA)
          png_handle_gAMA(png_ptr, info_ptr, length);
 #endif
 
 #ifdef PNG_READ_hIST_SUPPORTED
       else if (chunk_name == png_hIST)
          png_handle_hIST(png_ptr, info_ptr, length);
 #endif
 
 #ifdef PNG_READ_oFFs_SUPPORTED
       else if (chunk_name == png_oFFs)
          png_handle_oFFs(png_ptr, info_ptr, length);
 #endif
 
 #ifdef PNG_READ_pCAL_SUPPORTED
       else if (chunk_name == png_pCAL)
          png_handle_pCAL(png_ptr, info_ptr, length);
 #endif
 
 #ifdef PNG_READ_sCAL_SUPPORTED
       else if (chunk_name == png_sCAL)
          png_handle_sCAL(png_ptr, info_ptr, length);
 #endif
 
 #ifdef PNG_READ_pHYs_SUPPORTED
       else if (chunk_name == png_pHYs)
          png_handle_pHYs(png_ptr, info_ptr, length);
 #endif
 
 #ifdef PNG_READ_sBIT_SUPPORTED
       else if (chunk_name == png_sBIT)
          png_handle_sBIT(png_ptr, info_ptr, length);
 #endif
 
 #ifdef PNG_READ_sRGB_SUPPORTED
       else if (chunk_name == png_sRGB)
          png_handle_sRGB(png_ptr, info_ptr, length);
 #endif
 
 #ifdef PNG_READ_iCCP_SUPPORTED
       else if (chunk_name == png_iCCP)
          png_handle_iCCP(png_ptr, info_ptr, length);
 #endif
 
 #ifdef PNG_READ_sPLT_SUPPORTED
       else if (chunk_name == png_sPLT)
          png_handle_sPLT(png_ptr, info_ptr, length);
 #endif
 
 #ifdef PNG_READ_tEXt_SUPPORTED
       else if (chunk_name == png_tEXt)
          png_handle_tEXt(png_ptr, info_ptr, length);
 #endif
 
 #ifdef PNG_READ_tIME_SUPPORTED
       else if (chunk_name == png_tIME)
          png_handle_tIME(png_ptr, info_ptr, length);
 #endif
 
 #ifdef PNG_READ_tRNS_SUPPORTED
       else if (chunk_name == png_tRNS)
          png_handle_tRNS(png_ptr, info_ptr, length);
 #endif
 
 #ifdef PNG_READ_zTXt_SUPPORTED
       else if (chunk_name == png_zTXt)
          png_handle_zTXt(png_ptr, info_ptr, length);
 #endif
 
 #ifdef PNG_READ_iTXt_SUPPORTED
       else if (chunk_name == png_iTXt)
          png_handle_iTXt(png_ptr, info_ptr, length);
 #endif
 
       else
          png_handle_unknown(png_ptr, info_ptr, length,
             PNG_HANDLE_CHUNK_AS_DEFAULT);
    }
 }

PNG_DEPRECATED PNG_IMPEXP png_const_charp() png_convert_to_rfc1123	(	png_structrp	png_ptr,
		png_const_timep	ptime
	)

 {
    if (png_ptr != NULL)
    {
       /* The only failure above if png_ptr != NULL is from an invalid ptime */
       if (png_convert_to_rfc1123_buffer(png_ptr->time_buffer, ptime) == 0)
          png_warning(png_ptr, "Ignoring invalid time value");
 
       else
          return png_ptr->time_buffer;
    }
 
    return NULL;
 }

PNG_IMPEXP int() png_convert_to_rfc1123_buffer	(	char	out[29],
		png_const_timep	ptime
	)

 {
    static PNG_CONST char short_months[12][4] =
         {"Jan", "Feb", "Mar", "Apr", "May", "Jun",
          "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
 
    if (out == NULL)
       return 0;
 
    if (ptime->year > 9999 /* RFC1123 limitation */ ||
        ptime->month == 0    ||  ptime->month > 12  ||
        ptime->day   == 0    ||  ptime->day   > 31  ||
        ptime->hour  > 23    ||  ptime->minute > 59 ||
        ptime->second > 60)
       return 0;
 
    {
       size_t pos = 0;
       char number_buf[5]; /* enough for a four-digit year */
 
 #     define APPEND_STRING(string) pos = png_safecat(out, 29, pos, (string))
 #     define APPEND_NUMBER(format, value)\
          APPEND_STRING(PNG_FORMAT_NUMBER(number_buf, format, (value)))
 #     define APPEND(ch) if (pos < 28) out[pos++] = (ch)
 
       APPEND_NUMBER(PNG_NUMBER_FORMAT_u, (unsigned)ptime->day);
       APPEND(' ');
       APPEND_STRING(short_months[(ptime->month - 1)]);
       APPEND(' ');
       APPEND_NUMBER(PNG_NUMBER_FORMAT_u, ptime->year);
       APPEND(' ');
       APPEND_NUMBER(PNG_NUMBER_FORMAT_02u, (unsigned)ptime->hour);
       APPEND(':');
       APPEND_NUMBER(PNG_NUMBER_FORMAT_02u, (unsigned)ptime->minute);
       APPEND(':');
       APPEND_NUMBER(PNG_NUMBER_FORMAT_02u, (unsigned)ptime->second);
       APPEND_STRING(" +0000"); /* This reliably terminates the buffer */
 
 #     undef APPEND
 #     undef APPEND_NUMBER
 #     undef APPEND_STRING
    }
 
    return 1;
 }

PNG_IMPEXP void() png_convert_from_struct_tm	(	png_timep	ptime,
		const struct tm *	ttime
	)

 {
    png_debug(1, "in png_convert_from_struct_tm");
 
    ptime->year = (png_uint_16)(1900 + ttime->tm_year);
    ptime->month = (png_byte)(ttime->tm_mon + 1);
    ptime->day = (png_byte)ttime->tm_mday;
    ptime->hour = (png_byte)ttime->tm_hour;
    ptime->minute = (png_byte)ttime->tm_min;
    ptime->second = (png_byte)ttime->tm_sec;
 }

PNG_IMPEXP void() png_convert_from_time_t	(	png_timep	ptime,
		time_t	ttime
	)

 {
    struct tm *tbuf;
 
    png_debug(1, "in png_convert_from_time_t");
 
    tbuf = gmtime(&ttime);
    png_convert_from_struct_tm(ptime, tbuf);
 }

PNG_IMPEXP void() png_set_expand ( png_structrp png_ptr )

 {
    png_debug(1, "in png_set_expand");
 
    if (png_rtran_ok(png_ptr, 0) == 0)
       return;
 
    png_ptr->transformations |= (PNG_EXPAND | PNG_EXPAND_tRNS);
 }

PNG_IMPEXP void() png_set_expand_gray_1_2_4_to_8 ( png_structrp png_ptr )

 {
    png_debug(1, "in png_set_expand_gray_1_2_4_to_8");
 
    if (png_rtran_ok(png_ptr, 0) == 0)
       return;
 
    png_ptr->transformations |= PNG_EXPAND;
 }

PNG_IMPEXP void() png_set_palette_to_rgb ( png_structrp png_ptr )

 {
    png_debug(1, "in png_set_palette_to_rgb");
 
    if (png_rtran_ok(png_ptr, 0) == 0)
       return;
 
    png_ptr->transformations |= (PNG_EXPAND | PNG_EXPAND_tRNS);
 }

PNG_IMPEXP void() png_set_tRNS_to_alpha ( png_structrp png_ptr )

 {
    png_debug(1, "in png_set_tRNS_to_alpha");
 
    if (png_rtran_ok(png_ptr, 0) == 0)
       return;
 
    png_ptr->transformations |= (PNG_EXPAND | PNG_EXPAND_tRNS);
 }

PNG_IMPEXP void() png_set_expand_16 ( png_structrp png_ptr )

 {
    png_debug(1, "in png_set_expand_16");
 
    if (png_rtran_ok(png_ptr, 0) == 0)
       return;
 
    png_ptr->transformations |= (PNG_EXPAND_16 | PNG_EXPAND | PNG_EXPAND_tRNS);
 }

PNG_IMPEXP void() png_set_bgr ( png_structrp png_ptr )

 {
    png_debug(1, "in png_set_bgr");
 
    if (png_ptr == NULL)
       return;
 
    png_ptr->transformations |= PNG_BGR;
 }

PNG_IMPEXP void() png_set_gray_to_rgb ( png_structrp png_ptr )

 {
    png_debug(1, "in png_set_gray_to_rgb");
 
    if (png_rtran_ok(png_ptr, 0) == 0)
       return;
 
    /* Because rgb must be 8 bits or more: */
    png_set_expand_gray_1_2_4_to_8(png_ptr);
    png_ptr->transformations |= PNG_GRAY_TO_RGB;
 }

PNG_IMPEXP void() png_set_rgb_to_gray	(	png_structrp	png_ptr,
		int	error_action,
		double	red,
		double	green
	)

 {
    png_set_rgb_to_gray_fixed(png_ptr, error_action,
       png_fixed(png_ptr, red, "rgb to gray red coefficient"),
       png_fixed(png_ptr, green, "rgb to gray green coefficient"));
 }

PNG_IMPEXP void() png_set_rgb_to_gray_fixed	(	png_structrp	png_ptr,
		int	error_action,
		png_fixed_point	red,
		png_fixed_point	green
	)

 {
    png_debug(1, "in png_set_rgb_to_gray");
 
    /* Need the IHDR here because of the check on color_type below. */
    /* TODO: fix this */
    if (png_rtran_ok(png_ptr, 1) == 0)
       return;
 
    switch (error_action)
    {
       case PNG_ERROR_ACTION_NONE:
          png_ptr->transformations |= PNG_RGB_TO_GRAY;
          break;
 
       case PNG_ERROR_ACTION_WARN:
          png_ptr->transformations |= PNG_RGB_TO_GRAY_WARN;
          break;
 
       case PNG_ERROR_ACTION_ERROR:
          png_ptr->transformations |= PNG_RGB_TO_GRAY_ERR;
          break;
 
       default:
          png_error(png_ptr, "invalid error action to rgb_to_gray");
          break;
    }
 
    if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
 #ifdef PNG_READ_EXPAND_SUPPORTED
       png_ptr->transformations |= PNG_EXPAND;
 #else
    {
       /* Make this an error in 1.6 because otherwise the application may assume
        * that it just worked and get a memory overwrite.
        */
       png_error(png_ptr,
         "Cannot do RGB_TO_GRAY without EXPAND_SUPPORTED");
 
       /* png_ptr->transformations &= ~PNG_RGB_TO_GRAY; */
    }
 #endif
    {
       if (red >= 0 && green >= 0 && red + green <= PNG_FP_1)
       {
          png_uint_16 red_int, green_int;
 
          /* NOTE: this calculation does not round, but this behavior is retained
           * for consistency; the inaccuracy is very small.  The code here always
           * overwrites the coefficients, regardless of whether they have been
           * defaulted or set already.
           */
          red_int = (png_uint_16)(((png_uint_32)red*32768)/100000);
          green_int = (png_uint_16)(((png_uint_32)green*32768)/100000);
 
          png_ptr->rgb_to_gray_red_coeff   = red_int;
          png_ptr->rgb_to_gray_green_coeff = green_int;
          png_ptr->rgb_to_gray_coefficients_set = 1;
       }
 
       else
       {
          if (red >= 0 && green >= 0)
             png_app_warning(png_ptr,
                "ignoring out of range rgb_to_gray coefficients");
 
          /* Use the defaults, from the cHRM chunk if set, else the historical
           * values which are close to the sRGB/HDTV/ITU-Rec 709 values.  See
           * png_do_rgb_to_gray for more discussion of the values.  In this case
           * the coefficients are not marked as 'set' and are not overwritten if
           * something has already provided a default.
           */
          if (png_ptr->rgb_to_gray_red_coeff == 0 &&
             png_ptr->rgb_to_gray_green_coeff == 0)
          {
             png_ptr->rgb_to_gray_red_coeff   = 6968;
             png_ptr->rgb_to_gray_green_coeff = 23434;
             /* png_ptr->rgb_to_gray_blue_coeff  = 2366; */
          }
       }
    }
 }

PNG_IMPEXP png_byte() png_get_rgb_to_gray_status ( png_const_structrp png_ptr )

 {
    return (png_byte)(png_ptr ? png_ptr->rgb_to_gray_status : 0);
 }

PNG_IMPEXP void() png_build_grayscale_palette	(	int	bit_depth,
		png_colorp	palette
	)

 {
    int num_palette;
    int color_inc;
    int i;
    int v;
 
    png_debug(1, "in png_do_build_grayscale_palette");
 
    if (palette == NULL)
       return;
 
    switch (bit_depth)
    {
       case 1:
          num_palette = 2;
          color_inc = 0xff;
          break;
 
       case 2:
          num_palette = 4;
          color_inc = 0x55;
          break;
 
       case 4:
          num_palette = 16;
          color_inc = 0x11;
          break;
 
       case 8:
          num_palette = 256;
          color_inc = 1;
          break;
 
       default:
          num_palette = 0;
          color_inc = 0;
          break;
    }
 
    for (i = 0, v = 0; i < num_palette; i++, v += color_inc)
    {
       palette[i].red = (png_byte)v;
       palette[i].green = (png_byte)v;
       palette[i].blue = (png_byte)v;
    }
 }

PNG_IMPEXP void() png_set_alpha_mode	(	png_structrp	png_ptr,
		int	mode,
		double	output_gamma
	)

 {
    png_set_alpha_mode_fixed(png_ptr, mode, convert_gamma_value(png_ptr,
       output_gamma));
 }

PNG_IMPEXP void() png_set_alpha_mode_fixed	(	png_structrp	png_ptr,
		int	mode,
		png_fixed_point	output_gamma
	)

 {
    int compose = 0;
    png_fixed_point file_gamma;
 
    png_debug(1, "in png_set_alpha_mode");
 
    if (png_rtran_ok(png_ptr, 0) == 0)
       return;
 
    output_gamma = translate_gamma_flags(png_ptr, output_gamma, 1/*screen*/);
 
    /* Validate the value to ensure it is in a reasonable range. The value
     * is expected to be 1 or greater, but this range test allows for some
     * viewing correction values.  The intent is to weed out users of this API
     * who use the inverse of the gamma value accidentally!  Since some of these
     * values are reasonable this may have to be changed.
     */
    if (output_gamma < 70000 || output_gamma > 300000)
       png_error(png_ptr, "output gamma out of expected range");
 
    /* The default file gamma is the inverse of the output gamma; the output
     * gamma may be changed below so get the file value first:
     */
    file_gamma = png_reciprocal(output_gamma);
 
    /* There are really 8 possibilities here, composed of any combination
     * of:
     *
     *    premultiply the color channels
     *    do not encode non-opaque pixels
     *    encode the alpha as well as the color channels
     *
     * The differences disappear if the input/output ('screen') gamma is 1.0,
     * because then the encoding is a no-op and there is only the choice of
     * premultiplying the color channels or not.
     *
     * png_set_alpha_mode and png_set_background interact because both use
     * png_compose to do the work.  Calling both is only useful when
     * png_set_alpha_mode is used to set the default mode - PNG_ALPHA_PNG - along
     * with a default gamma value.  Otherwise PNG_COMPOSE must not be set.
     */
    switch (mode)
    {
       case PNG_ALPHA_PNG:        /* default: png standard */
          /* No compose, but it may be set by png_set_background! */
          png_ptr->transformations &= ~PNG_ENCODE_ALPHA;
          png_ptr->flags &= ~PNG_FLAG_OPTIMIZE_ALPHA;
          break;
 
       case PNG_ALPHA_ASSOCIATED: /* color channels premultiplied */
          compose = 1;
          png_ptr->transformations &= ~PNG_ENCODE_ALPHA;
          png_ptr->flags &= ~PNG_FLAG_OPTIMIZE_ALPHA;
          /* The output is linear: */
          output_gamma = PNG_FP_1;
          break;
 
       case PNG_ALPHA_OPTIMIZED:  /* associated, non-opaque pixels linear */
          compose = 1;
          png_ptr->transformations &= ~PNG_ENCODE_ALPHA;
          png_ptr->flags |= PNG_FLAG_OPTIMIZE_ALPHA;
          /* output_gamma records the encoding of opaque pixels! */
          break;
 
       case PNG_ALPHA_BROKEN:     /* associated, non-linear, alpha encoded */
          compose = 1;
          png_ptr->transformations |= PNG_ENCODE_ALPHA;
          png_ptr->flags &= ~PNG_FLAG_OPTIMIZE_ALPHA;
          break;
 
       default:
          png_error(png_ptr, "invalid alpha mode");
    }
 
    /* Only set the default gamma if the file gamma has not been set (this has
     * the side effect that the gamma in a second call to png_set_alpha_mode will
     * be ignored.)
     */
    if (png_ptr->colorspace.gamma == 0)
    {
       png_ptr->colorspace.gamma = file_gamma;
       png_ptr->colorspace.flags |= PNG_COLORSPACE_HAVE_GAMMA;
    }
 
    /* But always set the output gamma: */
    png_ptr->screen_gamma = output_gamma;
 
    /* Finally, if pre-multiplying, set the background fields to achieve the
     * desired result.
     */
    if (compose != 0)
    {
       /* And obtain alpha pre-multiplication by composing on black: */
       memset(&png_ptr->background, 0, (sizeof png_ptr->background));
       png_ptr->background_gamma = png_ptr->colorspace.gamma; /* just in case */
       png_ptr->background_gamma_type = PNG_BACKGROUND_GAMMA_FILE;
       png_ptr->transformations &= ~PNG_BACKGROUND_EXPAND;
 
       if ((png_ptr->transformations & PNG_COMPOSE) != 0)
          png_error(png_ptr,
             "conflicting calls to set alpha mode and background");
 
       png_ptr->transformations |= PNG_COMPOSE;
    }
 }

PNG_IMPEXP void() png_set_strip_alpha ( png_structrp png_ptr )

 {
    png_debug(1, "in png_set_strip_alpha");
 
    if (png_rtran_ok(png_ptr, 0) == 0)
       return;
 
    png_ptr->transformations |= PNG_STRIP_ALPHA;
 }

PNG_IMPEXP void() png_set_swap_alpha ( png_structrp png_ptr )

 {
    png_debug(1, "in png_set_swap_alpha");
 
    if (png_ptr == NULL)
       return;
 
    png_ptr->transformations |= PNG_SWAP_ALPHA;
 }

PNG_IMPEXP void() png_set_invert_alpha ( png_structrp png_ptr )

 {
    png_debug(1, "in png_set_invert_alpha");
 
    if (png_ptr == NULL)
       return;
 
    png_ptr->transformations |= PNG_INVERT_ALPHA;
 }

PNG_IMPEXP void() png_set_filler	(	png_structrp	png_ptr,
		png_uint_32	filler,
		int	flags
	)

 {
    png_debug(1, "in png_set_filler");
 
    if (png_ptr == NULL)
       return;
 
    /* In libpng 1.6 it is possible to determine whether this is a read or write
     * operation and therefore to do more checking here for a valid call.
     */
    if ((png_ptr->mode & PNG_IS_READ_STRUCT) != 0)
    {
 #     ifdef PNG_READ_FILLER_SUPPORTED
          /* On read png_set_filler is always valid, regardless of the base PNG
           * format, because other transformations can give a format where the
           * filler code can execute (basically an 8 or 16-bit component RGB or G
           * format.)
           *
           * NOTE: usr_channels is not used by the read code!  (This has led to
           * confusion in the past.)  The filler is only used in the read code.
           */
          png_ptr->filler = (png_uint_16)filler;
 #     else
          png_app_error(png_ptr, "png_set_filler not supported on read");
          PNG_UNUSED(filler) /* not used in the write case */
          return;
 #     endif
    }
 
    else /* write */
    {
 #     ifdef PNG_WRITE_FILLER_SUPPORTED
          /* On write the usr_channels parameter must be set correctly at the
           * start to record the number of channels in the app-supplied data.
           */
          switch (png_ptr->color_type)
          {
             case PNG_COLOR_TYPE_RGB:
                png_ptr->usr_channels = 4;
                break;
 
             case PNG_COLOR_TYPE_GRAY:
                if (png_ptr->bit_depth >= 8)
                {
                   png_ptr->usr_channels = 2;
                   break;
                }
 
                else
                {
                   /* There simply isn't any code in libpng to strip out bits
                    * from bytes when the components are less than a byte in
                    * size!
                    */
                   png_app_error(png_ptr,
                      "png_set_filler is invalid for low bit depth gray output");
                   return;
                }
 
             default:
                png_app_error(png_ptr,
                   "png_set_filler: inappropriate color type");
                return;
          }
 #     else
          png_app_error(png_ptr, "png_set_filler not supported on write");
          return;
 #     endif
    }
 
    /* Here on success - libpng supports the operation, set the transformation
     * and the flag to say where the filler channel is.
     */
    png_ptr->transformations |= PNG_FILLER;
 
    if (filler_loc == PNG_FILLER_AFTER)
       png_ptr->flags |= PNG_FLAG_FILLER_AFTER;
 
    else
       png_ptr->flags &= ~PNG_FLAG_FILLER_AFTER;
 }

PNG_IMPEXP void() png_set_add_alpha	(	png_structrp	png_ptr,
		png_uint_32	filler,
		int	flags
	)

 {
    png_debug(1, "in png_set_add_alpha");
 
    if (png_ptr == NULL)
       return;
 
    png_set_filler(png_ptr, filler, filler_loc);
    /* The above may fail to do anything. */
    if ((png_ptr->transformations & PNG_FILLER) != 0)
       png_ptr->transformations |= PNG_ADD_ALPHA;
 }

PNG_IMPEXP void() png_set_swap ( png_structrp png_ptr )

 {
    png_debug(1, "in png_set_swap");
 
    if (png_ptr == NULL)
       return;
 
    if (png_ptr->bit_depth == 16)
       png_ptr->transformations |= PNG_SWAP_BYTES;
 }

PNG_IMPEXP void() png_set_packing ( png_structrp png_ptr )

 {
    png_debug(1, "in png_set_packing");
 
    if (png_ptr == NULL)
       return;
 
    if (png_ptr->bit_depth < 8)
    {
       png_ptr->transformations |= PNG_PACK;
 #     ifdef PNG_WRITE_SUPPORTED
          png_ptr->usr_bit_depth = 8;
 #     endif
    }
 }

PNG_IMPEXP void() png_set_packswap ( png_structrp png_ptr )

 {
    png_debug(1, "in png_set_packswap");
 
    if (png_ptr == NULL)
       return;
 
    if (png_ptr->bit_depth < 8)
       png_ptr->transformations |= PNG_PACKSWAP;
 }

PNG_IMPEXP void() png_set_shift	(	png_structrp	png_ptr,
		png_const_color_8p	true_bits
	)

 {
    png_debug(1, "in png_set_shift");
 
    if (png_ptr == NULL)
       return;
 
    png_ptr->transformations |= PNG_SHIFT;
    png_ptr->shift = *true_bits;
 }

PNG_IMPEXP int() png_set_interlace_handling ( png_structrp png_ptr )

 {
    png_debug(1, "in png_set_interlace handling");
 
    if (png_ptr != 0 && png_ptr->interlaced != 0)
    {
       png_ptr->transformations |= PNG_INTERLACE;
       return (7);
    }
 
    return (1);
 }

PNG_IMPEXP void() png_set_invert_mono ( png_structrp png_ptr )

 {
    png_debug(1, "in png_set_invert_mono");
 
    if (png_ptr == NULL)
       return;
 
    png_ptr->transformations |= PNG_INVERT_MONO;
 }

PNG_IMPEXP void() png_set_background	(	png_structrp	png_ptr,
		png_const_color_16p	background_color,
		int	background_gamma_code,
		int	need_expand,
		double	background_gamma
	)

 {
    png_set_background_fixed(png_ptr, background_color, background_gamma_code,
       need_expand, png_fixed(png_ptr, background_gamma, "png_set_background"));
 }

PNG_IMPEXP void() png_set_background_fixed	(	png_structrp	png_ptr,
		png_const_color_16p	background_color,
		int	background_gamma_code,
		int	need_expand,
		png_fixed_point	background_gamma
	)

 {
    png_debug(1, "in png_set_background_fixed");
 
    if (png_rtran_ok(png_ptr, 0) == 0 || background_color == NULL)
       return;
 
    if (background_gamma_code == PNG_BACKGROUND_GAMMA_UNKNOWN)
    {
       png_warning(png_ptr, "Application must supply a known background gamma");
       return;
    }
 
    png_ptr->transformations |= PNG_COMPOSE | PNG_STRIP_ALPHA;
    png_ptr->transformations &= ~PNG_ENCODE_ALPHA;
    png_ptr->flags &= ~PNG_FLAG_OPTIMIZE_ALPHA;
 
    png_ptr->background = *background_color;
    png_ptr->background_gamma = background_gamma;
    png_ptr->background_gamma_type = (png_byte)(background_gamma_code);
    if (need_expand != 0)
       png_ptr->transformations |= PNG_BACKGROUND_EXPAND;
    else
       png_ptr->transformations &= ~PNG_BACKGROUND_EXPAND;
 }

PNG_IMPEXP void() png_set_scale_16 ( png_structrp png_ptr )

 {
    png_debug(1, "in png_set_scale_16");
 
    if (png_rtran_ok(png_ptr, 0) == 0)
       return;
 
    png_ptr->transformations |= PNG_SCALE_16_TO_8;
 }

PNG_IMPEXP void() png_set_strip_16 ( png_structrp png_ptr )

 {
    png_debug(1, "in png_set_strip_16");
 
    if (png_rtran_ok(png_ptr, 0) == 0)
       return;
 
    png_ptr->transformations |= PNG_16_TO_8;
 }

PNG_IMPEXP void() png_set_quantize	(	png_structrp	png_ptr,
		png_colorp	palette,
		int	num_palette,
		int	maximum_colors,
		png_const_uint_16p	histogram,
		int	full_quantize
	)

 {
    png_debug(1, "in png_set_quantize");
 
    if (png_rtran_ok(png_ptr, 0) == 0)
       return;
 
    png_ptr->transformations |= PNG_QUANTIZE;
 
    if (full_quantize == 0)
    {
       int i;
 
       png_ptr->quantize_index = (png_bytep)png_malloc(png_ptr,
           (png_uint_32)(num_palette * (sizeof (png_byte))));
       for (i = 0; i < num_palette; i++)
          png_ptr->quantize_index[i] = (png_byte)i;
    }
 
    if (num_palette > maximum_colors)
    {
       if (histogram != NULL)
       {
          /* This is easy enough, just throw out the least used colors.
           * Perhaps not the best solution, but good enough.
           */
 
          int i;
 
          /* Initialize an array to sort colors */
          png_ptr->quantize_sort = (png_bytep)png_malloc(png_ptr,
              (png_uint_32)(num_palette * (sizeof (png_byte))));
 
          /* Initialize the quantize_sort array */
          for (i = 0; i < num_palette; i++)
             png_ptr->quantize_sort[i] = (png_byte)i;
 
          /* Find the least used palette entries by starting a
           * bubble sort, and running it until we have sorted
           * out enough colors.  Note that we don't care about
           * sorting all the colors, just finding which are
           * least used.
           */
 
          for (i = num_palette - 1; i >= maximum_colors; i--)
          {
             int done; /* To stop early if the list is pre-sorted */
             int j;
 
             done = 1;
             for (j = 0; j < i; j++)
             {
                if (histogram[png_ptr->quantize_sort[j]]
                    < histogram[png_ptr->quantize_sort[j + 1]])
                {
                   png_byte t;
 
                   t = png_ptr->quantize_sort[j];
                   png_ptr->quantize_sort[j] = png_ptr->quantize_sort[j + 1];
                   png_ptr->quantize_sort[j + 1] = t;
                   done = 0;
                }
             }
 
             if (done != 0)
                break;
          }
 
          /* Swap the palette around, and set up a table, if necessary */
          if (full_quantize != 0)
          {
             int j = num_palette;
 
             /* Put all the useful colors within the max, but don't
              * move the others.
              */
             for (i = 0; i < maximum_colors; i++)
             {
                if ((int)png_ptr->quantize_sort[i] >= maximum_colors)
                {
                   do
                      j--;
                   while ((int)png_ptr->quantize_sort[j] >= maximum_colors);
 
                   palette[i] = palette[j];
                }
             }
          }
          else
          {
             int j = num_palette;
 
             /* Move all the used colors inside the max limit, and
              * develop a translation table.
              */
             for (i = 0; i < maximum_colors; i++)
             {
                /* Only move the colors we need to */
                if ((int)png_ptr->quantize_sort[i] >= maximum_colors)
                {
                   png_color tmp_color;
 
                   do
                      j--;
                   while ((int)png_ptr->quantize_sort[j] >= maximum_colors);
 
                   tmp_color = palette[j];
                   palette[j] = palette[i];
                   palette[i] = tmp_color;
                   /* Indicate where the color went */
                   png_ptr->quantize_index[j] = (png_byte)i;
                   png_ptr->quantize_index[i] = (png_byte)j;
                }
             }
 
             /* Find closest color for those colors we are not using */
             for (i = 0; i < num_palette; i++)
             {
                if ((int)png_ptr->quantize_index[i] >= maximum_colors)
                {
                   int min_d, k, min_k, d_index;
 
                   /* Find the closest color to one we threw out */
                   d_index = png_ptr->quantize_index[i];
                   min_d = PNG_COLOR_DIST(palette[d_index], palette[0]);
                   for (k = 1, min_k = 0; k < maximum_colors; k++)
                   {
                      int d;
 
                      d = PNG_COLOR_DIST(palette[d_index], palette[k]);
 
                      if (d < min_d)
                      {
                         min_d = d;
                         min_k = k;
                      }
                   }
                   /* Point to closest color */
                   png_ptr->quantize_index[i] = (png_byte)min_k;
                }
             }
          }
          png_free(png_ptr, png_ptr->quantize_sort);
          png_ptr->quantize_sort = NULL;
       }
       else
       {
          /* This is much harder to do simply (and quickly).  Perhaps
           * we need to go through a median cut routine, but those
           * don't always behave themselves with only a few colors
           * as input.  So we will just find the closest two colors,
           * and throw out one of them (chosen somewhat randomly).
           * [We don't understand this at all, so if someone wants to
           *  work on improving it, be our guest - AED, GRP]
           */
          int i;
          int max_d;
          int num_new_palette;
          png_dsortp t;
          png_dsortpp hash;
 
          t = NULL;
 
          /* Initialize palette index arrays */
          png_ptr->index_to_palette = (png_bytep)png_malloc(png_ptr,
              (png_uint_32)(num_palette * (sizeof (png_byte))));
          png_ptr->palette_to_index = (png_bytep)png_malloc(png_ptr,
              (png_uint_32)(num_palette * (sizeof (png_byte))));
 
          /* Initialize the sort array */
          for (i = 0; i < num_palette; i++)
          {
             png_ptr->index_to_palette[i] = (png_byte)i;
             png_ptr->palette_to_index[i] = (png_byte)i;
          }
 
          hash = (png_dsortpp)png_calloc(png_ptr, (png_uint_32)(769 *
              (sizeof (png_dsortp))));
 
          num_new_palette = num_palette;
 
          /* Initial wild guess at how far apart the farthest pixel
           * pair we will be eliminating will be.  Larger
           * numbers mean more areas will be allocated, Smaller
           * numbers run the risk of not saving enough data, and
           * having to do this all over again.
           *
           * I have not done extensive checking on this number.
           */
          max_d = 96;
 
          while (num_new_palette > maximum_colors)
          {
             for (i = 0; i < num_new_palette - 1; i++)
             {
                int j;
 
                for (j = i + 1; j < num_new_palette; j++)
                {
                   int d;
 
                   d = PNG_COLOR_DIST(palette[i], palette[j]);
 
                   if (d <= max_d)
                   {
 
                      t = (png_dsortp)png_malloc_warn(png_ptr,
                          (png_uint_32)(sizeof (png_dsort)));
 
                      if (t == NULL)
                          break;
 
                      t->next = hash[d];
                      t->left = (png_byte)i;
                      t->right = (png_byte)j;
                      hash[d] = t;
                   }
                }
                if (t == NULL)
                   break;
             }
 
             if (t != NULL)
             for (i = 0; i <= max_d; i++)
             {
                if (hash[i] != NULL)
                {
                   png_dsortp p;
 
                   for (p = hash[i]; p; p = p->next)
                   {
                      if ((int)png_ptr->index_to_palette[p->left]
                          < num_new_palette &&
                          (int)png_ptr->index_to_palette[p->right]
                          < num_new_palette)
                      {
                         int j, next_j;
 
                         if (num_new_palette & 0x01)
                         {
                            j = p->left;
                            next_j = p->right;
                         }
                         else
                         {
                            j = p->right;
                            next_j = p->left;
                         }
 
                         num_new_palette--;
                         palette[png_ptr->index_to_palette[j]]
                             = palette[num_new_palette];
                         if (full_quantize == 0)
                         {
                            int k;
 
                            for (k = 0; k < num_palette; k++)
                            {
                               if (png_ptr->quantize_index[k] ==
                                   png_ptr->index_to_palette[j])
                                  png_ptr->quantize_index[k] =
                                      png_ptr->index_to_palette[next_j];
 
                               if ((int)png_ptr->quantize_index[k] ==
                                   num_new_palette)
                                  png_ptr->quantize_index[k] =
                                      png_ptr->index_to_palette[j];
                            }
                         }
 
                         png_ptr->index_to_palette[png_ptr->palette_to_index
                             [num_new_palette]] = png_ptr->index_to_palette[j];
 
                         png_ptr->palette_to_index[png_ptr->index_to_palette[j]]
                             = png_ptr->palette_to_index[num_new_palette];
 
                         png_ptr->index_to_palette[j] =
                             (png_byte)num_new_palette;
 
                         png_ptr->palette_to_index[num_new_palette] =
                             (png_byte)j;
                      }
                      if (num_new_palette <= maximum_colors)
                         break;
                   }
                   if (num_new_palette <= maximum_colors)
                      break;
                }
             }
 
             for (i = 0; i < 769; i++)
             {
                if (hash[i] != NULL)
                {
                   png_dsortp p = hash[i];
                   while (p)
                   {
                      t = p->next;
                      png_free(png_ptr, p);
                      p = t;
                   }
                }
                hash[i] = 0;
             }
             max_d += 96;
          }
          png_free(png_ptr, hash);
          png_free(png_ptr, png_ptr->palette_to_index);
          png_free(png_ptr, png_ptr->index_to_palette);
          png_ptr->palette_to_index = NULL;
          png_ptr->index_to_palette = NULL;
       }
       num_palette = maximum_colors;
    }
    if (png_ptr->palette == NULL)
    {
       png_ptr->palette = palette;
    }
    png_ptr->num_palette = (png_uint_16)num_palette;
 
    if (full_quantize != 0)
    {
       int i;
       png_bytep distance;
       int total_bits = PNG_QUANTIZE_RED_BITS + PNG_QUANTIZE_GREEN_BITS +
           PNG_QUANTIZE_BLUE_BITS;
       int num_red = (1 << PNG_QUANTIZE_RED_BITS);
       int num_green = (1 << PNG_QUANTIZE_GREEN_BITS);
       int num_blue = (1 << PNG_QUANTIZE_BLUE_BITS);
       png_size_t num_entries = ((png_size_t)1 << total_bits);
 
       png_ptr->palette_lookup = (png_bytep)png_calloc(png_ptr,
           (png_uint_32)(num_entries * (sizeof (png_byte))));
 
       distance = (png_bytep)png_malloc(png_ptr, (png_uint_32)(num_entries *
           (sizeof (png_byte))));
 
       memset(distance, 0xff, num_entries * (sizeof (png_byte)));
 
       for (i = 0; i < num_palette; i++)
       {
          int ir, ig, ib;
          int r = (palette[i].red >> (8 - PNG_QUANTIZE_RED_BITS));
          int g = (palette[i].green >> (8 - PNG_QUANTIZE_GREEN_BITS));
          int b = (palette[i].blue >> (8 - PNG_QUANTIZE_BLUE_BITS));
 
          for (ir = 0; ir < num_red; ir++)
          {
             /* int dr = abs(ir - r); */
             int dr = ((ir > r) ? ir - r : r - ir);
             int index_r = (ir << (PNG_QUANTIZE_BLUE_BITS +
                 PNG_QUANTIZE_GREEN_BITS));
 
             for (ig = 0; ig < num_green; ig++)
             {
                /* int dg = abs(ig - g); */
                int dg = ((ig > g) ? ig - g : g - ig);
                int dt = dr + dg;
                int dm = ((dr > dg) ? dr : dg);
                int index_g = index_r | (ig << PNG_QUANTIZE_BLUE_BITS);
 
                for (ib = 0; ib < num_blue; ib++)
                {
                   int d_index = index_g | ib;
                   /* int db = abs(ib - b); */
                   int db = ((ib > b) ? ib - b : b - ib);
                   int dmax = ((dm > db) ? dm : db);
                   int d = dmax + dt + db;
 
                   if (d < (int)distance[d_index])
                   {
                      distance[d_index] = (png_byte)d;
                      png_ptr->palette_lookup[d_index] = (png_byte)i;
                   }
                }
             }
          }
       }
 
       png_free(png_ptr, distance);
    }
 }

PNG_IMPEXP void() png_set_gamma	(	png_structrp	png_ptr,
		double	screen_gamma,
		double	override_file_gamma
	)

 {
    png_set_gamma_fixed(png_ptr, convert_gamma_value(png_ptr, scrn_gamma),
       convert_gamma_value(png_ptr, file_gamma));
 }

PNG_IMPEXP void() png_set_gamma_fixed	(	png_structrp	png_ptr,
		png_fixed_point	screen_gamma,
		png_fixed_point	override_file_gamma
	)

 {
    png_debug(1, "in png_set_gamma_fixed");
 
    if (png_rtran_ok(png_ptr, 0) == 0)
       return;
 
    /* New in libpng-1.5.4 - reserve particular negative values as flags. */
    scrn_gamma = translate_gamma_flags(png_ptr, scrn_gamma, 1/*screen*/);
    file_gamma = translate_gamma_flags(png_ptr, file_gamma, 0/*file*/);
 
    /* Checking the gamma values for being >0 was added in 1.5.4 along with the
     * premultiplied alpha support; this actually hides an undocumented feature
     * of the previous implementation which allowed gamma processing to be
     * disabled in background handling.  There is no evidence (so far) that this
     * was being used; however, png_set_background itself accepted and must still
     * accept '0' for the gamma value it takes, because it isn't always used.
     *
     * Since this is an API change (albeit a very minor one that removes an
     * undocumented API feature) the following checks were only enabled in
     * libpng-1.6.0.
     */
    if (file_gamma <= 0)
       png_error(png_ptr, "invalid file gamma in png_set_gamma");
 
    if (scrn_gamma <= 0)
       png_error(png_ptr, "invalid screen gamma in png_set_gamma");
 
    /* Set the gamma values unconditionally - this overrides the value in the PNG
     * file if a gAMA chunk was present.  png_set_alpha_mode provides a
     * different, easier, way to default the file gamma.
     */
    png_ptr->colorspace.gamma = file_gamma;
    png_ptr->colorspace.flags |= PNG_COLORSPACE_HAVE_GAMMA;
    png_ptr->screen_gamma = scrn_gamma;
 }

PNG_IMPEXP void() png_set_flush	(	png_structrp	png_ptr,
		int	nrows
	)

 {
    png_debug(1, "in png_set_flush");
 
    if (png_ptr == NULL)
       return;
 
    png_ptr->flush_dist = (nrows < 0 ? 0 : nrows);
 }

PNG_IMPEXP void() png_write_flush ( png_structrp png_ptr )

 {
    png_debug(1, "in png_write_flush");
 
    if (png_ptr == NULL)
       return;
 
    /* We have already written out all of the data */
    if (png_ptr->row_number >= png_ptr->num_rows)
       return;
 
    png_compress_IDAT(png_ptr, NULL, 0, Z_SYNC_FLUSH);
    png_ptr->flush_rows = 0;
    png_flush(png_ptr);
 }

PNG_IMPEXP void() png_start_read_image ( png_structrp png_ptr )

 {
    png_debug(1, "in png_start_read_image");
 
    if (png_ptr != NULL)
    {
       if ((png_ptr->flags & PNG_FLAG_ROW_INIT) == 0)
          png_read_start_row(png_ptr);
 
       /* New in 1.6.0 this avoids the bug of doing the initializations twice */
       else
          png_app_error(png_ptr,
             "png_start_read_image/png_read_update_info: duplicate call");
    }
 }

PNG_IMPEXP void() png_read_update_info	(	png_structrp	png_ptr,
		png_inforp	info_ptr
	)

 {
    png_debug(1, "in png_read_update_info");
 
    if (png_ptr != NULL)
    {
       if ((png_ptr->flags & PNG_FLAG_ROW_INIT) == 0)
       {
          png_read_start_row(png_ptr);
 
 #        ifdef PNG_READ_TRANSFORMS_SUPPORTED
             png_read_transform_info(png_ptr, info_ptr);
 #        else
             PNG_UNUSED(info_ptr)
 #        endif
       }
 
       /* New in 1.6.0 this avoids the bug of doing the initializations twice */
       else
          png_app_error(png_ptr,
             "png_read_update_info/png_start_read_image: duplicate call");
    }
 }

PNG_IMPEXP void() png_read_rows	(	png_structrp	png_ptr,
		png_bytepp	row,
		png_bytepp	display_row,
		png_uint_32	num_rows
	)

 {
    png_uint_32 i;
    png_bytepp rp;
    png_bytepp dp;
 
    png_debug(1, "in png_read_rows");
 
    if (png_ptr == NULL)
       return;
 
    rp = row;
    dp = display_row;
    if (rp != NULL && dp != NULL)
       for (i = 0; i < num_rows; i++)
       {
          png_bytep rptr = *rp++;
          png_bytep dptr = *dp++;
 
          png_read_row(png_ptr, rptr, dptr);
       }
 
    else if (rp != NULL)
       for (i = 0; i < num_rows; i++)
       {
          png_bytep rptr = *rp;
          png_read_row(png_ptr, rptr, NULL);
          rp++;
       }
 
    else if (dp != NULL)
       for (i = 0; i < num_rows; i++)
       {
          png_bytep dptr = *dp;
          png_read_row(png_ptr, NULL, dptr);
          dp++;
       }
 }

PNG_IMPEXP void() png_read_row	(	png_structrp	png_ptr,
		png_bytep	row,
		png_bytep	display_row
	)

 {
    png_row_info row_info;
 
    if (png_ptr == NULL)
       return;
 
    png_debug2(1, "in png_read_row (row %lu, pass %d)",
        (unsigned long)png_ptr->row_number, png_ptr->pass);
 
    /* png_read_start_row sets the information (in particular iwidth) for this
     * interlace pass.
     */
    if ((png_ptr->flags & PNG_FLAG_ROW_INIT) == 0)
       png_read_start_row(png_ptr);
 
    /* 1.5.6: row_info moved out of png_struct to a local here. */
    row_info.width = png_ptr->iwidth; /* NOTE: width of current interlaced row */
    row_info.color_type = png_ptr->color_type;
    row_info.bit_depth = png_ptr->bit_depth;
    row_info.channels = png_ptr->channels;
    row_info.pixel_depth = png_ptr->pixel_depth;
    row_info.rowbytes = PNG_ROWBYTES(row_info.pixel_depth, row_info.width);
 
 #ifdef PNG_WARNINGS_SUPPORTED
    if (png_ptr->row_number == 0 && png_ptr->pass == 0)
    {
    /* Check for transforms that have been set but were defined out */
 #if defined(PNG_WRITE_INVERT_SUPPORTED) && !defined(PNG_READ_INVERT_SUPPORTED)
    if ((png_ptr->transformations & PNG_INVERT_MONO) != 0)
       png_warning(png_ptr, "PNG_READ_INVERT_SUPPORTED is not defined");
 #endif
 
 #if defined(PNG_WRITE_FILLER_SUPPORTED) && !defined(PNG_READ_FILLER_SUPPORTED)
    if ((png_ptr->transformations & PNG_FILLER) != 0)
       png_warning(png_ptr, "PNG_READ_FILLER_SUPPORTED is not defined");
 #endif
 
 #if defined(PNG_WRITE_PACKSWAP_SUPPORTED) && \
     !defined(PNG_READ_PACKSWAP_SUPPORTED)
    if ((png_ptr->transformations & PNG_PACKSWAP) != 0)
       png_warning(png_ptr, "PNG_READ_PACKSWAP_SUPPORTED is not defined");
 #endif
 
 #if defined(PNG_WRITE_PACK_SUPPORTED) && !defined(PNG_READ_PACK_SUPPORTED)
    if ((png_ptr->transformations & PNG_PACK) != 0)
       png_warning(png_ptr, "PNG_READ_PACK_SUPPORTED is not defined");
 #endif
 
 #if defined(PNG_WRITE_SHIFT_SUPPORTED) && !defined(PNG_READ_SHIFT_SUPPORTED)
    if ((png_ptr->transformations & PNG_SHIFT) != 0)
       png_warning(png_ptr, "PNG_READ_SHIFT_SUPPORTED is not defined");
 #endif
 
 #if defined(PNG_WRITE_BGR_SUPPORTED) && !defined(PNG_READ_BGR_SUPPORTED)
    if ((png_ptr->transformations & PNG_BGR) != 0)
       png_warning(png_ptr, "PNG_READ_BGR_SUPPORTED is not defined");
 #endif
 
 #if defined(PNG_WRITE_SWAP_SUPPORTED) && !defined(PNG_READ_SWAP_SUPPORTED)
    if ((png_ptr->transformations & PNG_SWAP_BYTES) != 0)
       png_warning(png_ptr, "PNG_READ_SWAP_SUPPORTED is not defined");
 #endif
    }
 #endif /* WARNINGS */
 
 #ifdef PNG_READ_INTERLACING_SUPPORTED
    /* If interlaced and we do not need a new row, combine row and return.
     * Notice that the pixels we have from previous rows have been transformed
     * already; we can only combine like with like (transformed or
     * untransformed) and, because of the libpng API for interlaced images, this
     * means we must transform before de-interlacing.
     */
    if (png_ptr->interlaced != 0 &&
        (png_ptr->transformations & PNG_INTERLACE) != 0)
    {
       switch (png_ptr->pass)
       {
          case 0:
             if (png_ptr->row_number & 0x07)
             {
                if (dsp_row != NULL)
                   png_combine_row(png_ptr, dsp_row, 1/*display*/);
                png_read_finish_row(png_ptr);
                return;
             }
             break;
 
          case 1:
             if ((png_ptr->row_number & 0x07) || png_ptr->width < 5)
             {
                if (dsp_row != NULL)
                   png_combine_row(png_ptr, dsp_row, 1/*display*/);
 
                png_read_finish_row(png_ptr);
                return;
             }
             break;
 
          case 2:
             if ((png_ptr->row_number & 0x07) != 4)
             {
                if (dsp_row != NULL && (png_ptr->row_number & 4))
                   png_combine_row(png_ptr, dsp_row, 1/*display*/);
 
                png_read_finish_row(png_ptr);
                return;
             }
             break;
 
          case 3:
             if ((png_ptr->row_number & 3) || png_ptr->width < 3)
             {
                if (dsp_row != NULL)
                   png_combine_row(png_ptr, dsp_row, 1/*display*/);
 
                png_read_finish_row(png_ptr);
                return;
             }
             break;
 
          case 4:
             if ((png_ptr->row_number & 3) != 2)
             {
                if (dsp_row != NULL && (png_ptr->row_number & 2))
                   png_combine_row(png_ptr, dsp_row, 1/*display*/);
 
                png_read_finish_row(png_ptr);
                return;
             }
             break;
 
          case 5:
             if ((png_ptr->row_number & 1) || png_ptr->width < 2)
             {
                if (dsp_row != NULL)
                   png_combine_row(png_ptr, dsp_row, 1/*display*/);
 
                png_read_finish_row(png_ptr);
                return;
             }
             break;
 
          default:
          case 6:
             if ((png_ptr->row_number & 1) == 0)
             {
                png_read_finish_row(png_ptr);
                return;
             }
             break;
       }
    }
 #endif
 
    if ((png_ptr->mode & PNG_HAVE_IDAT) == 0)
       png_error(png_ptr, "Invalid attempt to read row data");
 
    /* Fill the row with IDAT data: */
    png_read_IDAT_data(png_ptr, png_ptr->row_buf, row_info.rowbytes + 1);
 
    if (png_ptr->row_buf[0] > PNG_FILTER_VALUE_NONE)
    {
       if (png_ptr->row_buf[0] < PNG_FILTER_VALUE_LAST)
          png_read_filter_row(png_ptr, &row_info, png_ptr->row_buf + 1,
             png_ptr->prev_row + 1, png_ptr->row_buf[0]);
       else
          png_error(png_ptr, "bad adaptive filter value");
    }
 
    /* libpng 1.5.6: the following line was copying png_ptr->rowbytes before
     * 1.5.6, while the buffer really is this big in current versions of libpng
     * it may not be in the future, so this was changed just to copy the
     * interlaced count:
     */
    memcpy(png_ptr->prev_row, png_ptr->row_buf, row_info.rowbytes + 1);
 
 #ifdef PNG_MNG_FEATURES_SUPPORTED
    if ((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) != 0 &&
        (png_ptr->filter_type == PNG_INTRAPIXEL_DIFFERENCING))
    {
       /* Intrapixel differencing */
       png_do_read_intrapixel(&row_info, png_ptr->row_buf + 1);
    }
 #endif
 
 #ifdef PNG_READ_TRANSFORMS_SUPPORTED
    if (png_ptr->transformations)
       png_do_read_transformations(png_ptr, &row_info);
 #endif
 
    /* The transformed pixel depth should match the depth now in row_info. */
    if (png_ptr->transformed_pixel_depth == 0)
    {
       png_ptr->transformed_pixel_depth = row_info.pixel_depth;
       if (row_info.pixel_depth > png_ptr->maximum_pixel_depth)
          png_error(png_ptr, "sequential row overflow");
    }
 
    else if (png_ptr->transformed_pixel_depth != row_info.pixel_depth)
       png_error(png_ptr, "internal sequential row size calculation error");
 
 #ifdef PNG_READ_INTERLACING_SUPPORTED
    /* Expand interlaced rows to full size */
    if (png_ptr->interlaced != 0 &&
       (png_ptr->transformations & PNG_INTERLACE) != 0)
    {
       if (png_ptr->pass < 6)
          png_do_read_interlace(&row_info, png_ptr->row_buf + 1, png_ptr->pass,
             png_ptr->transformations);
 
       if (dsp_row != NULL)
          png_combine_row(png_ptr, dsp_row, 1/*display*/);
 
       if (row != NULL)
          png_combine_row(png_ptr, row, 0/*row*/);
    }
 
    else
 #endif
    {
       if (row != NULL)
          png_combine_row(png_ptr, row, -1/*ignored*/);
 
       if (dsp_row != NULL)
          png_combine_row(png_ptr, dsp_row, -1/*ignored*/);
    }
    png_read_finish_row(png_ptr);
 
    if (png_ptr->read_row_fn != NULL)
       (*(png_ptr->read_row_fn))(png_ptr, png_ptr->row_number, png_ptr->pass);
 
 }

PNG_IMPEXP void() png_read_image	(	png_structrp	png_ptr,
		png_bytepp	image
	)

 {
    png_uint_32 i, image_height;
    int pass, j;
    png_bytepp rp;
 
    png_debug(1, "in png_read_image");
 
    if (png_ptr == NULL)
       return;
 
 #ifdef PNG_READ_INTERLACING_SUPPORTED
    if ((png_ptr->flags & PNG_FLAG_ROW_INIT) == 0)
    {
       pass = png_set_interlace_handling(png_ptr);
       /* And make sure transforms are initialized. */
       png_start_read_image(png_ptr);
    }
    else
    {
       if (png_ptr->interlaced != 0 &&
           (png_ptr->transformations & PNG_INTERLACE) == 0)
       {
          /* Caller called png_start_read_image or png_read_update_info without
           * first turning on the PNG_INTERLACE transform.  We can fix this here,
           * but the caller should do it!
           */
          png_warning(png_ptr, "Interlace handling should be turned on when "
             "using png_read_image");
          /* Make sure this is set correctly */
          png_ptr->num_rows = png_ptr->height;
       }
 
       /* Obtain the pass number, which also turns on the PNG_INTERLACE flag in
        * the above error case.
        */
       pass = png_set_interlace_handling(png_ptr);
    }
 #else
    if (png_ptr->interlaced)
       png_error(png_ptr,
           "Cannot read interlaced image -- interlace handler disabled");
 
    pass = 1;
 #endif
 
    image_height=png_ptr->height;
 
    for (j = 0; j < pass; j++)
    {
       rp = image;
       for (i = 0; i < image_height; i++)
       {
          png_read_row(png_ptr, *rp, NULL);
          rp++;
       }
    }
 }

PNG_IMPEXP void() png_write_row	(	png_structrp	png_ptr,
		png_const_bytep	row
	)

 {
    /* 1.5.6: moved from png_struct to be a local structure: */
    png_row_info row_info;
 
    if (png_ptr == NULL)
       return;
 
    png_debug2(1, "in png_write_row (row %u, pass %d)",
       png_ptr->row_number, png_ptr->pass);
 
    /* Initialize transformations and other stuff if first time */
    if (png_ptr->row_number == 0 && png_ptr->pass == 0)
    {
       /* Make sure we wrote the header info */
       if ((png_ptr->mode & PNG_WROTE_INFO_BEFORE_PLTE) == 0)
          png_error(png_ptr,
              "png_write_info was never called before png_write_row");
 
       /* Check for transforms that have been set but were defined out */
 #if !defined(PNG_WRITE_INVERT_SUPPORTED) && defined(PNG_READ_INVERT_SUPPORTED)
       if ((png_ptr->transformations & PNG_INVERT_MONO) != 0)
          png_warning(png_ptr, "PNG_WRITE_INVERT_SUPPORTED is not defined");
 #endif
 
 #if !defined(PNG_WRITE_FILLER_SUPPORTED) && defined(PNG_READ_FILLER_SUPPORTED)
       if ((png_ptr->transformations & PNG_FILLER) != 0)
          png_warning(png_ptr, "PNG_WRITE_FILLER_SUPPORTED is not defined");
 #endif
 #if !defined(PNG_WRITE_PACKSWAP_SUPPORTED) && \
     defined(PNG_READ_PACKSWAP_SUPPORTED)
       if ((png_ptr->transformations & PNG_PACKSWAP) != 0)
          png_warning(png_ptr,
              "PNG_WRITE_PACKSWAP_SUPPORTED is not defined");
 #endif
 
 #if !defined(PNG_WRITE_PACK_SUPPORTED) && defined(PNG_READ_PACK_SUPPORTED)
       if ((png_ptr->transformations & PNG_PACK) != 0)
          png_warning(png_ptr, "PNG_WRITE_PACK_SUPPORTED is not defined");
 #endif
 
 #if !defined(PNG_WRITE_SHIFT_SUPPORTED) && defined(PNG_READ_SHIFT_SUPPORTED)
       if ((png_ptr->transformations & PNG_SHIFT) != 0)
          png_warning(png_ptr, "PNG_WRITE_SHIFT_SUPPORTED is not defined");
 #endif
 
 #if !defined(PNG_WRITE_BGR_SUPPORTED) && defined(PNG_READ_BGR_SUPPORTED)
       if ((png_ptr->transformations & PNG_BGR) != 0)
          png_warning(png_ptr, "PNG_WRITE_BGR_SUPPORTED is not defined");
 #endif
 
 #if !defined(PNG_WRITE_SWAP_SUPPORTED) && defined(PNG_READ_SWAP_SUPPORTED)
       if ((png_ptr->transformations & PNG_SWAP_BYTES) != 0)
          png_warning(png_ptr, "PNG_WRITE_SWAP_SUPPORTED is not defined");
 #endif
 
       png_write_start_row(png_ptr);
    }
 
 #ifdef PNG_WRITE_INTERLACING_SUPPORTED
    /* If interlaced and not interested in row, return */
    if (png_ptr->interlaced != 0 &&
        (png_ptr->transformations & PNG_INTERLACE) != 0)
    {
       switch (png_ptr->pass)
       {
          case 0:
             if ((png_ptr->row_number & 0x07) != 0)
             {
                png_write_finish_row(png_ptr);
                return;
             }
             break;
 
          case 1:
             if ((png_ptr->row_number & 0x07) != 0 || png_ptr->width < 5)
             {
                png_write_finish_row(png_ptr);
                return;
             }
             break;
 
          case 2:
             if ((png_ptr->row_number & 0x07) != 4)
             {
                png_write_finish_row(png_ptr);
                return;
             }
             break;
 
          case 3:
             if ((png_ptr->row_number & 0x03) != 0 || png_ptr->width < 3)
             {
                png_write_finish_row(png_ptr);
                return;
             }
             break;
 
          case 4:
             if ((png_ptr->row_number & 0x03) != 2)
             {
                png_write_finish_row(png_ptr);
                return;
             }
             break;
 
          case 5:
             if ((png_ptr->row_number & 0x01) != 0 || png_ptr->width < 2)
             {
                png_write_finish_row(png_ptr);
                return;
             }
             break;
 
          case 6:
             if ((png_ptr->row_number & 0x01) == 0)
             {
                png_write_finish_row(png_ptr);
                return;
             }
             break;
 
          default: /* error: ignore it */
             break;
       }
    }
 #endif
 
    /* Set up row info for transformations */
    row_info.color_type = png_ptr->color_type;
    row_info.width = png_ptr->usr_width;
    row_info.channels = png_ptr->usr_channels;
    row_info.bit_depth = png_ptr->usr_bit_depth;
    row_info.pixel_depth = (png_byte)(row_info.bit_depth * row_info.channels);
    row_info.rowbytes = PNG_ROWBYTES(row_info.pixel_depth, row_info.width);
 
    png_debug1(3, "row_info->color_type = %d", row_info.color_type);
    png_debug1(3, "row_info->width = %u", row_info.width);
    png_debug1(3, "row_info->channels = %d", row_info.channels);
    png_debug1(3, "row_info->bit_depth = %d", row_info.bit_depth);
    png_debug1(3, "row_info->pixel_depth = %d", row_info.pixel_depth);
    png_debug1(3, "row_info->rowbytes = %lu", (unsigned long)row_info.rowbytes);
 
    /* Copy user's row into buffer, leaving room for filter byte. */
    memcpy(png_ptr->row_buf + 1, row, row_info.rowbytes);
 
 #ifdef PNG_WRITE_INTERLACING_SUPPORTED
    /* Handle interlacing */
    if (png_ptr->interlaced && png_ptr->pass < 6 &&
        (png_ptr->transformations & PNG_INTERLACE) != 0)
    {
       png_do_write_interlace(&row_info, png_ptr->row_buf + 1, png_ptr->pass);
       /* This should always get caught above, but still ... */
       if (row_info.width == 0)
       {
          png_write_finish_row(png_ptr);
          return;
       }
    }
 #endif
 
 #ifdef PNG_WRITE_TRANSFORMS_SUPPORTED
    /* Handle other transformations */
    if (png_ptr->transformations != 0)
       png_do_write_transformations(png_ptr, &row_info);
 #endif
 
    /* At this point the row_info pixel depth must match the 'transformed' depth,
     * which is also the output depth.
     */
    if (row_info.pixel_depth != png_ptr->pixel_depth ||
       row_info.pixel_depth != png_ptr->transformed_pixel_depth)
       png_error(png_ptr, "internal write transform logic error");
 
 #ifdef PNG_MNG_FEATURES_SUPPORTED
    /* Write filter_method 64 (intrapixel differencing) only if
     * 1. Libpng was compiled with PNG_MNG_FEATURES_SUPPORTED and
     * 2. Libpng did not write a PNG signature (this filter_method is only
     *    used in PNG datastreams that are embedded in MNG datastreams) and
     * 3. The application called png_permit_mng_features with a mask that
     *    included PNG_FLAG_MNG_FILTER_64 and
     * 4. The filter_method is 64 and
     * 5. The color_type is RGB or RGBA
     */
    if ((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) != 0 &&
        (png_ptr->filter_type == PNG_INTRAPIXEL_DIFFERENCING))
    {
       /* Intrapixel differencing */
       png_do_write_intrapixel(&row_info, png_ptr->row_buf + 1);
    }
 #endif
 
 /* Added at libpng-1.5.10 */
 #ifdef PNG_WRITE_CHECK_FOR_INVALID_INDEX_SUPPORTED
    /* Check for out-of-range palette index */
    if (row_info.color_type == PNG_COLOR_TYPE_PALETTE &&
        png_ptr->num_palette_max >= 0)
       png_do_check_palette_indexes(png_ptr, &row_info);
 #endif
 
    /* Find a filter if necessary, filter the row and write it out. */
    png_write_find_filter(png_ptr, &row_info);
 
    if (png_ptr->write_row_fn != NULL)
       (*(png_ptr->write_row_fn))(png_ptr, png_ptr->row_number, png_ptr->pass);
 }

PNG_IMPEXP void() png_write_rows	(	png_structrp	png_ptr,
		png_bytepp	row,
		png_uint_32	num_rows
	)

 {
    png_uint_32 i; /* row counter */
    png_bytepp rp; /* row pointer */
 
    png_debug(1, "in png_write_rows");
 
    if (png_ptr == NULL)
       return;
 
    /* Loop through the rows */
    for (i = 0, rp = row; i < num_rows; i++, rp++)
    {
       png_write_row(png_ptr, *rp);
    }
 }

PNG_IMPEXP void() png_write_image	(	png_structrp	png_ptr,
		png_bytepp	image
	)

 {
    png_uint_32 i; /* row index */
    int pass, num_pass; /* pass variables */
    png_bytepp rp; /* points to current row */
 
    if (png_ptr == NULL)
       return;
 
    png_debug(1, "in png_write_image");
 
 #ifdef PNG_WRITE_INTERLACING_SUPPORTED
    /* Initialize interlace handling.  If image is not interlaced,
     * this will set pass to 1
     */
    num_pass = png_set_interlace_handling(png_ptr);
 #else
    num_pass = 1;
 #endif
    /* Loop through passes */
    for (pass = 0; pass < num_pass; pass++)
    {
       /* Loop through image */
       for (i = 0, rp = image; i < png_ptr->height; i++, rp++)
       {
          png_write_row(png_ptr, *rp);
       }
    }
 }

PNG_IMPEXP void() png_write_end	(	png_structrp	png_ptr,
		png_inforp	info_ptr
	)

 {
    png_debug(1, "in png_write_end");
 
    if (png_ptr == NULL)
       return;
 
    if ((png_ptr->mode & PNG_HAVE_IDAT) == 0)
       png_error(png_ptr, "No IDATs written into file");
 
 #ifdef PNG_WRITE_CHECK_FOR_INVALID_INDEX_SUPPORTED
    if (png_ptr->num_palette_max > png_ptr->num_palette)
       png_benign_error(png_ptr, "Wrote palette index exceeding num_palette");
 #endif
 
    /* See if user wants us to write information chunks */
    if (info_ptr != NULL)
    {
 #ifdef PNG_WRITE_TEXT_SUPPORTED
       int i; /* local index variable */
 #endif
 #ifdef PNG_WRITE_tIME_SUPPORTED
       /* Check to see if user has supplied a time chunk */
       if ((info_ptr->valid & PNG_INFO_tIME) != 0 &&
           (png_ptr->mode & PNG_WROTE_tIME) == 0)
          png_write_tIME(png_ptr, &(info_ptr->mod_time));
 
 #endif
 #ifdef PNG_WRITE_TEXT_SUPPORTED
       /* Loop through comment chunks */
       for (i = 0; i < info_ptr->num_text; i++)
       {
          png_debug2(2, "Writing trailer text chunk %d, type %d", i,
             info_ptr->text[i].compression);
          /* An internationalized chunk? */
          if (info_ptr->text[i].compression > 0)
          {
 #ifdef PNG_WRITE_iTXt_SUPPORTED
             /* Write international chunk */
             png_write_iTXt(png_ptr,
                 info_ptr->text[i].compression,
                 info_ptr->text[i].key,
                 info_ptr->text[i].lang,
                 info_ptr->text[i].lang_key,
                 info_ptr->text[i].text);
             /* Mark this chunk as written */
             if (info_ptr->text[i].compression == PNG_TEXT_COMPRESSION_NONE)
                info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_NONE_WR;
             else
                info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_zTXt_WR;
 #else
             png_warning(png_ptr, "Unable to write international text");
 #endif
          }
 
          else if (info_ptr->text[i].compression >= PNG_TEXT_COMPRESSION_zTXt)
          {
 #ifdef PNG_WRITE_zTXt_SUPPORTED
             /* Write compressed chunk */
             png_write_zTXt(png_ptr, info_ptr->text[i].key,
                 info_ptr->text[i].text, info_ptr->text[i].compression);
             /* Mark this chunk as written */
             info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_zTXt_WR;
 #else
             png_warning(png_ptr, "Unable to write compressed text");
 #endif
          }
 
          else if (info_ptr->text[i].compression == PNG_TEXT_COMPRESSION_NONE)
          {
 #ifdef PNG_WRITE_tEXt_SUPPORTED
             /* Write uncompressed chunk */
             png_write_tEXt(png_ptr, info_ptr->text[i].key,
                 info_ptr->text[i].text, 0);
             /* Mark this chunk as written */
             info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_NONE_WR;
 #else
             png_warning(png_ptr, "Unable to write uncompressed text");
 #endif
          }
       }
 #endif
 #ifdef PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED
       write_unknown_chunks(png_ptr, info_ptr, PNG_AFTER_IDAT);
 #endif
    }
 
    png_ptr->mode |= PNG_AFTER_IDAT;
 
    /* Write end of PNG file */
    png_write_IEND(png_ptr);
 
    /* This flush, added in libpng-1.0.8, removed from libpng-1.0.9beta03,
     * and restored again in libpng-1.2.30, may cause some applications that
     * do not set png_ptr->output_flush_fn to crash.  If your application
     * experiences a problem, please try building libpng with
     * PNG_WRITE_FLUSH_AFTER_IEND_SUPPORTED defined, and report the event to
     * png-mng-implement at lists.sf.net .
     */
 #ifdef PNG_WRITE_FLUSH_SUPPORTED
 #  ifdef PNG_WRITE_FLUSH_AFTER_IEND_SUPPORTED
    png_flush(png_ptr);
 #  endif
 #endif
 }

PNG_IMPEXP void() png_read_end	(	png_structrp	png_ptr,
		png_inforp	info_ptr
	)

 {
 #ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED
    int keep;
 #endif
 
    png_debug(1, "in png_read_end");
 
    if (png_ptr == NULL)
       return;
 
    /* If png_read_end is called in the middle of reading the rows there may
     * still be pending IDAT data and an owned zstream.  Deal with this here.
     */
 #ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED
    if (png_chunk_unknown_handling(png_ptr, png_IDAT) == 0)
 #endif
       png_read_finish_IDAT(png_ptr);
 
 #ifdef PNG_READ_CHECK_FOR_INVALID_INDEX_SUPPORTED
    /* Report invalid palette index; added at libng-1.5.10 */
    if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE &&
       png_ptr->num_palette_max > png_ptr->num_palette)
      png_benign_error(png_ptr, "Read palette index exceeding num_palette");
 #endif
 
    do
    {
       png_uint_32 length = png_read_chunk_header(png_ptr);
       png_uint_32 chunk_name = png_ptr->chunk_name;
 
       if (chunk_name == png_IEND)
          png_handle_IEND(png_ptr, info_ptr, length);
 
       else if (chunk_name == png_IHDR)
          png_handle_IHDR(png_ptr, info_ptr, length);
 
       else if (info_ptr == NULL)
          png_crc_finish(png_ptr, length);
 
 #ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED
       else if ((keep = png_chunk_unknown_handling(png_ptr, chunk_name)) != 0)
       {
          if (chunk_name == png_IDAT)
          {
             if ((length > 0) ||
                 (png_ptr->mode & PNG_HAVE_CHUNK_AFTER_IDAT) != 0)
                png_benign_error(png_ptr, "Too many IDATs found");
          }
          png_handle_unknown(png_ptr, info_ptr, length, keep);
          if (chunk_name == png_PLTE)
             png_ptr->mode |= PNG_HAVE_PLTE;
       }
 #endif
 
       else if (chunk_name == png_IDAT)
       {
          /* Zero length IDATs are legal after the last IDAT has been
           * read, but not after other chunks have been read.
           */
          if ((length > 0) ||
              (png_ptr->mode & PNG_HAVE_CHUNK_AFTER_IDAT) != 0)
             png_benign_error(png_ptr, "Too many IDATs found");
 
          png_crc_finish(png_ptr, length);
       }
       else if (chunk_name == png_PLTE)
          png_handle_PLTE(png_ptr, info_ptr, length);
 
 #ifdef PNG_READ_bKGD_SUPPORTED
       else if (chunk_name == png_bKGD)
          png_handle_bKGD(png_ptr, info_ptr, length);
 #endif
 
 #ifdef PNG_READ_cHRM_SUPPORTED
       else if (chunk_name == png_cHRM)
          png_handle_cHRM(png_ptr, info_ptr, length);
 #endif
 
 #ifdef PNG_READ_gAMA_SUPPORTED
       else if (chunk_name == png_gAMA)
          png_handle_gAMA(png_ptr, info_ptr, length);
 #endif
 
 #ifdef PNG_READ_hIST_SUPPORTED
       else if (chunk_name == png_hIST)
          png_handle_hIST(png_ptr, info_ptr, length);
 #endif
 
 #ifdef PNG_READ_oFFs_SUPPORTED
       else if (chunk_name == png_oFFs)
          png_handle_oFFs(png_ptr, info_ptr, length);
 #endif
 
 #ifdef PNG_READ_pCAL_SUPPORTED
       else if (chunk_name == png_pCAL)
          png_handle_pCAL(png_ptr, info_ptr, length);
 #endif
 
 #ifdef PNG_READ_sCAL_SUPPORTED
       else if (chunk_name == png_sCAL)
          png_handle_sCAL(png_ptr, info_ptr, length);
 #endif
 
 #ifdef PNG_READ_pHYs_SUPPORTED
       else if (chunk_name == png_pHYs)
          png_handle_pHYs(png_ptr, info_ptr, length);
 #endif
 
 #ifdef PNG_READ_sBIT_SUPPORTED
       else if (chunk_name == png_sBIT)
          png_handle_sBIT(png_ptr, info_ptr, length);
 #endif
 
 #ifdef PNG_READ_sRGB_SUPPORTED
       else if (chunk_name == png_sRGB)
          png_handle_sRGB(png_ptr, info_ptr, length);
 #endif
 
 #ifdef PNG_READ_iCCP_SUPPORTED
       else if (chunk_name == png_iCCP)
          png_handle_iCCP(png_ptr, info_ptr, length);
 #endif
 
 #ifdef PNG_READ_sPLT_SUPPORTED
       else if (chunk_name == png_sPLT)
          png_handle_sPLT(png_ptr, info_ptr, length);
 #endif
 
 #ifdef PNG_READ_tEXt_SUPPORTED
       else if (chunk_name == png_tEXt)
          png_handle_tEXt(png_ptr, info_ptr, length);
 #endif
 
 #ifdef PNG_READ_tIME_SUPPORTED
       else if (chunk_name == png_tIME)
          png_handle_tIME(png_ptr, info_ptr, length);
 #endif
 
 #ifdef PNG_READ_tRNS_SUPPORTED
       else if (chunk_name == png_tRNS)
          png_handle_tRNS(png_ptr, info_ptr, length);
 #endif
 
 #ifdef PNG_READ_zTXt_SUPPORTED
       else if (chunk_name == png_zTXt)
          png_handle_zTXt(png_ptr, info_ptr, length);
 #endif
 
 #ifdef PNG_READ_iTXt_SUPPORTED
       else if (chunk_name == png_iTXt)
          png_handle_iTXt(png_ptr, info_ptr, length);
 #endif
 
       else
          png_handle_unknown(png_ptr, info_ptr, length,
             PNG_HANDLE_CHUNK_AS_DEFAULT);
    } while ((png_ptr->mode & PNG_HAVE_IEND) == 0);
 }

PNG_IMPEXP void() png_destroy_info_struct	(	png_const_structrp	png_ptr,
		png_infopp	info_ptr_ptr
	)

 {
    png_inforp info_ptr = NULL;
 
    png_debug(1, "in png_destroy_info_struct");
 
    if (png_ptr == NULL)
       return;
 
    if (info_ptr_ptr != NULL)
       info_ptr = *info_ptr_ptr;
 
    if (info_ptr != NULL)
    {
       /* Do this first in case of an error below; if the app implements its own
        * memory management this can lead to png_free calling png_error, which
        * will abort this routine and return control to the app error handler.
        * An infinite loop may result if it then tries to free the same info
        * ptr.
        */
       *info_ptr_ptr = NULL;
 
       png_free_data(png_ptr, info_ptr, PNG_FREE_ALL, -1);
       memset(info_ptr, 0, (sizeof *info_ptr));
       png_free(png_ptr, info_ptr);
    }
 }

PNG_IMPEXP void() png_destroy_read_struct	(	png_structpp	png_ptr_ptr,
		png_infopp	info_ptr_ptr,
		png_infopp	end_info_ptr_ptr
	)

 {
    png_structrp png_ptr = NULL;
 
    png_debug(1, "in png_destroy_read_struct");
 
    if (png_ptr_ptr != NULL)
       png_ptr = *png_ptr_ptr;
 
    if (png_ptr == NULL)
       return;
 
    /* libpng 1.6.0: use the API to destroy info structs to ensure consistent
     * behavior.  Prior to 1.6.0 libpng did extra 'info' destruction in this API.
     * The extra was, apparently, unnecessary yet this hides memory leak bugs.
     */
    png_destroy_info_struct(png_ptr, end_info_ptr_ptr);
    png_destroy_info_struct(png_ptr, info_ptr_ptr);
 
    *png_ptr_ptr = NULL;
    png_read_destroy(png_ptr);
    png_destroy_png_struct(png_ptr);
 }

PNG_IMPEXP void() png_destroy_write_struct	(	png_structpp	png_ptr_ptr,
		png_infopp	info_ptr_ptr
	)

 {
    png_debug(1, "in png_destroy_write_struct");
 
    if (png_ptr_ptr != NULL)
    {
       png_structrp png_ptr = *png_ptr_ptr;
 
       if (png_ptr != NULL) /* added in libpng 1.6.0 */
       {
          png_destroy_info_struct(png_ptr, info_ptr_ptr);
 
          *png_ptr_ptr = NULL;
          png_write_destroy(png_ptr);
          png_destroy_png_struct(png_ptr);
       }
    }
 }

PNG_IMPEXP void() png_set_crc_action	(	png_structrp	png_ptr,
		int	crit_action,
		int	ancil_action
	)

 {
    png_debug(1, "in png_set_crc_action");
 
    if (png_ptr == NULL)
       return;
 
    /* Tell libpng how we react to CRC errors in critical chunks */
    switch (crit_action)
    {
       case PNG_CRC_NO_CHANGE:                        /* Leave setting as is */
          break;
 
       case PNG_CRC_WARN_USE:                               /* Warn/use data */
          png_ptr->flags &= ~PNG_FLAG_CRC_CRITICAL_MASK;
          png_ptr->flags |= PNG_FLAG_CRC_CRITICAL_USE;
          break;
 
       case PNG_CRC_QUIET_USE:                             /* Quiet/use data */
          png_ptr->flags &= ~PNG_FLAG_CRC_CRITICAL_MASK;
          png_ptr->flags |= PNG_FLAG_CRC_CRITICAL_USE |
                            PNG_FLAG_CRC_CRITICAL_IGNORE;
          break;
 
       case PNG_CRC_WARN_DISCARD:    /* Not a valid action for critical data */
          png_warning(png_ptr,
             "Can't discard critical data on CRC error");
       case PNG_CRC_ERROR_QUIT:                                /* Error/quit */
 
       case PNG_CRC_DEFAULT:
       default:
          png_ptr->flags &= ~PNG_FLAG_CRC_CRITICAL_MASK;
          break;
    }
 
    /* Tell libpng how we react to CRC errors in ancillary chunks */
    switch (ancil_action)
    {
       case PNG_CRC_NO_CHANGE:                       /* Leave setting as is */
          break;
 
       case PNG_CRC_WARN_USE:                              /* Warn/use data */
          png_ptr->flags &= ~PNG_FLAG_CRC_ANCILLARY_MASK;
          png_ptr->flags |= PNG_FLAG_CRC_ANCILLARY_USE;
          break;
 
       case PNG_CRC_QUIET_USE:                            /* Quiet/use data */
          png_ptr->flags &= ~PNG_FLAG_CRC_ANCILLARY_MASK;
          png_ptr->flags |= PNG_FLAG_CRC_ANCILLARY_USE |
                            PNG_FLAG_CRC_ANCILLARY_NOWARN;
          break;
 
       case PNG_CRC_ERROR_QUIT:                               /* Error/quit */
          png_ptr->flags &= ~PNG_FLAG_CRC_ANCILLARY_MASK;
          png_ptr->flags |= PNG_FLAG_CRC_ANCILLARY_NOWARN;
          break;
 
       case PNG_CRC_WARN_DISCARD:                      /* Warn/discard data */
 
       case PNG_CRC_DEFAULT:
       default:
          png_ptr->flags &= ~PNG_FLAG_CRC_ANCILLARY_MASK;
          break;
    }
 }

PNG_IMPEXP void() png_set_filter	(	png_structrp	png_ptr,
		int	method,
		int	filters
	)

 {
    png_debug(1, "in png_set_filter");
 
    if (png_ptr == NULL)
       return;
 
 #ifdef PNG_MNG_FEATURES_SUPPORTED
    if ((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) != 0 &&
        (method == PNG_INTRAPIXEL_DIFFERENCING))
       method = PNG_FILTER_TYPE_BASE;
 
 #endif
    if (method == PNG_FILTER_TYPE_BASE)
    {
       switch (filters & (PNG_ALL_FILTERS | 0x07))
       {
 #ifdef PNG_WRITE_FILTER_SUPPORTED
          case 5:
          case 6:
          case 7: png_app_error(png_ptr, "Unknown row filter for method 0");
             /* FALL THROUGH */
 #endif /* WRITE_FILTER */
          case PNG_FILTER_VALUE_NONE:
             png_ptr->do_filter = PNG_FILTER_NONE; break;
 
 #ifdef PNG_WRITE_FILTER_SUPPORTED
          case PNG_FILTER_VALUE_SUB:
             png_ptr->do_filter = PNG_FILTER_SUB; break;
 
          case PNG_FILTER_VALUE_UP:
             png_ptr->do_filter = PNG_FILTER_UP; break;
 
          case PNG_FILTER_VALUE_AVG:
             png_ptr->do_filter = PNG_FILTER_AVG; break;
 
          case PNG_FILTER_VALUE_PAETH:
             png_ptr->do_filter = PNG_FILTER_PAETH; break;
 
          default:
             png_ptr->do_filter = (png_byte)filters; break;
 #else
          default:
             png_app_error(png_ptr, "Unknown row filter for method 0");
 #endif /* WRITE_FILTER */
       }
 
       /* If we have allocated the row_buf, this means we have already started
        * with the image and we should have allocated all of the filter buffers
        * that have been selected.  If prev_row isn't already allocated, then
        * it is too late to start using the filters that need it, since we
        * will be missing the data in the previous row.  If an application
        * wants to start and stop using particular filters during compression,
        * it should start out with all of the filters, and then add and
        * remove them after the start of compression.
        */
       if (png_ptr->row_buf != NULL)
       {
 #ifdef PNG_WRITE_FILTER_SUPPORTED
          if ((png_ptr->do_filter & PNG_FILTER_SUB) != 0 &&
              png_ptr->sub_row == NULL)
          {
             png_ptr->sub_row = (png_bytep)png_malloc(png_ptr,
                 (png_ptr->rowbytes + 1));
             png_ptr->sub_row[0] = PNG_FILTER_VALUE_SUB;
          }
 
          if ((png_ptr->do_filter & PNG_FILTER_UP) != 0 &&
               png_ptr->up_row == NULL)
          {
             if (png_ptr->prev_row == NULL)
             {
                png_warning(png_ptr, "Can't add Up filter after starting");
                png_ptr->do_filter = (png_byte)(png_ptr->do_filter &
                    ~PNG_FILTER_UP);
             }
 
             else
             {
                png_ptr->up_row = (png_bytep)png_malloc(png_ptr,
                    (png_ptr->rowbytes + 1));
                png_ptr->up_row[0] = PNG_FILTER_VALUE_UP;
             }
          }
 
          if ((png_ptr->do_filter & PNG_FILTER_AVG) != 0 &&
               png_ptr->avg_row == NULL)
          {
             if (png_ptr->prev_row == NULL)
             {
                png_warning(png_ptr, "Can't add Average filter after starting");
                png_ptr->do_filter = (png_byte)(png_ptr->do_filter &
                    ~PNG_FILTER_AVG);
             }
 
             else
             {
                png_ptr->avg_row = (png_bytep)png_malloc(png_ptr,
                    (png_ptr->rowbytes + 1));
                png_ptr->avg_row[0] = PNG_FILTER_VALUE_AVG;
             }
          }
 
          if ((png_ptr->do_filter & PNG_FILTER_PAETH) != 0 &&
              png_ptr->paeth_row == NULL)
          {
             if (png_ptr->prev_row == NULL)
             {
                png_warning(png_ptr, "Can't add Paeth filter after starting");
                png_ptr->do_filter &= (png_byte)(~PNG_FILTER_PAETH);
             }
 
             else
             {
                png_ptr->paeth_row = (png_bytep)png_malloc(png_ptr,
                    (png_ptr->rowbytes + 1));
                png_ptr->paeth_row[0] = PNG_FILTER_VALUE_PAETH;
             }
          }
 
          if (png_ptr->do_filter == PNG_NO_FILTERS)
 #endif /* WRITE_FILTER */
             png_ptr->do_filter = PNG_FILTER_NONE;
       }
    }
    else
       png_error(png_ptr, "Unknown custom filter method");
 }

PNG_IMPEXP void() png_set_filter_heuristics	(	png_structrp	png_ptr,
		int	heuristic_method,
		int	num_weights,
		png_const_doublep	filter_weights,
		png_const_doublep	filter_costs
	)

 {
    png_debug(1, "in png_set_filter_heuristics");
 
    /* The internal API allocates all the arrays and ensures that the elements of
     * those arrays are set to the default value.
     */
    if (png_init_filter_heuristics(png_ptr, heuristic_method, num_weights) == 0)
       return;
 
    /* If using the weighted method copy in the weights. */
    if (heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED)
    {
       int i;
       for (i = 0; i < num_weights; i++)
       {
          if (filter_weights[i] <= 0.0)
          {
             png_ptr->inv_filter_weights[i] =
             png_ptr->filter_weights[i] = PNG_WEIGHT_FACTOR;
          }
 
          else
          {
             png_ptr->inv_filter_weights[i] =
                 (png_uint_16)(PNG_WEIGHT_FACTOR*filter_weights[i]+.5);
 
             png_ptr->filter_weights[i] =
                 (png_uint_16)(PNG_WEIGHT_FACTOR/filter_weights[i]+.5);
          }
       }
 
       /* Here is where we set the relative costs of the different filters.  We
        * should take the desired compression level into account when setting
        * the costs, so that Paeth, for instance, has a high relative cost at low
        * compression levels, while it has a lower relative cost at higher
        * compression settings.  The filter types are in order of increasing
        * relative cost, so it would be possible to do this with an algorithm.
        */
       for (i = 0; i < PNG_FILTER_VALUE_LAST; i++) if (filter_costs[i] >= 1.0)
       {
          png_ptr->inv_filter_costs[i] =
              (png_uint_16)(PNG_COST_FACTOR / filter_costs[i] + .5);
 
          png_ptr->filter_costs[i] =
              (png_uint_16)(PNG_COST_FACTOR * filter_costs[i] + .5);
       }
    }
 }

PNG_IMPEXP void() png_set_filter_heuristics_fixed	(	png_structrp	png_ptr,
		int	heuristic_method,
		int	num_weights,
		png_const_fixed_point_p	filter_weights,
		png_const_fixed_point_p	filter_costs
	)

 {
    png_debug(1, "in png_set_filter_heuristics_fixed");
 
    /* The internal API allocates all the arrays and ensures that the elements of
     * those arrays are set to the default value.
     */
    if (png_init_filter_heuristics(png_ptr, heuristic_method, num_weights) == 0)
       return;
 
    /* If using the weighted method copy in the weights. */
    if (heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED)
    {
       int i;
       for (i = 0; i < num_weights; i++)
       {
          if (filter_weights[i] <= 0)
          {
             png_ptr->inv_filter_weights[i] =
             png_ptr->filter_weights[i] = PNG_WEIGHT_FACTOR;
          }
 
          else
          {
             png_ptr->inv_filter_weights[i] = (png_uint_16)
                ((PNG_WEIGHT_FACTOR*filter_weights[i]+PNG_FP_HALF)/PNG_FP_1);
 
             png_ptr->filter_weights[i] = (png_uint_16)((PNG_WEIGHT_FACTOR*
                PNG_FP_1+(filter_weights[i]/2))/filter_weights[i]);
          }
       }
 
       /* Here is where we set the relative costs of the different filters.  We
        * should take the desired compression level into account when setting
        * the costs, so that Paeth, for instance, has a high relative cost at low
        * compression levels, while it has a lower relative cost at higher
        * compression settings.  The filter types are in order of increasing
        * relative cost, so it would be possible to do this with an algorithm.
        */
       for (i = 0; i < PNG_FILTER_VALUE_LAST; i++)
          if (filter_costs[i] >= PNG_FP_1)
       {
          png_uint_32 tmp;
 
          /* Use a 32 bit unsigned temporary here because otherwise the
           * intermediate value will be a 32 bit *signed* integer (ANSI rules)
           * and this will get the wrong answer on division.
           */
          tmp = PNG_COST_FACTOR*PNG_FP_1 + (filter_costs[i]/2);
          tmp /= filter_costs[i];
 
          png_ptr->inv_filter_costs[i] = (png_uint_16)tmp;
 
          tmp = PNG_COST_FACTOR * filter_costs[i] + PNG_FP_HALF;
          tmp /= PNG_FP_1;
 
          png_ptr->filter_costs[i] = (png_uint_16)tmp;
       }
    }
 }

PNG_IMPEXP void() png_set_compression_level	(	png_structrp	png_ptr,
		int	level
	)

 {
    png_debug(1, "in png_set_compression_level");
 
    if (png_ptr == NULL)
       return;
 
    png_ptr->zlib_level = level;
 }

PNG_IMPEXP void() png_set_compression_mem_level	(	png_structrp	png_ptr,
		int	mem_level
	)

 {
    png_debug(1, "in png_set_compression_mem_level");
 
    if (png_ptr == NULL)
       return;
 
    png_ptr->zlib_mem_level = mem_level;
 }

PNG_IMPEXP void() png_set_compression_strategy	(	png_structrp	png_ptr,
		int	strategy
	)

 {
    png_debug(1, "in png_set_compression_strategy");
 
    if (png_ptr == NULL)
       return;
 
    /* The flag setting here prevents the libpng dynamic selection of strategy.
     */
    png_ptr->flags |= PNG_FLAG_ZLIB_CUSTOM_STRATEGY;
    png_ptr->zlib_strategy = strategy;
 }

PNG_IMPEXP void() png_set_compression_window_bits	(	png_structrp	png_ptr,
		int	window_bits
	)

 {
    if (png_ptr == NULL)
       return;
 
    /* Prior to 1.6.0 this would warn but then set the window_bits value, this
     * meant that negative window bits values could be selected which would cause
     * libpng to write a non-standard PNG file with raw deflate or gzip
     * compressed IDAT or ancillary chunks.  Such files can be read and there is
     * no warning on read, so this seems like a very bad idea.
     */
    if (window_bits > 15)
    {
       png_warning(png_ptr, "Only compression windows <= 32k supported by PNG");
       window_bits = 15;
    }
 
    else if (window_bits < 8)
    {
       png_warning(png_ptr, "Only compression windows >= 256 supported by PNG");
       window_bits = 8;
    }
 
    png_ptr->zlib_window_bits = window_bits;
 }

PNG_IMPEXP void() png_set_compression_method	(	png_structrp	png_ptr,
		int	method
	)

 {
    png_debug(1, "in png_set_compression_method");
 
    if (png_ptr == NULL)
       return;
 
    /* This would produce an invalid PNG file if it worked, but it doesn't and
     * deflate will fault it, so it is harmless to just warn here.
     */
    if (method != 8)
       png_warning(png_ptr, "Only compression method 8 is supported by PNG");
 
    png_ptr->zlib_method = method;
 }

PNG_IMPEXP void() png_set_text_compression_level	(	png_structrp	png_ptr,
		int	level
	)

 {
    png_debug(1, "in png_set_text_compression_level");
 
    if (png_ptr == NULL)
       return;
 
    png_ptr->zlib_text_level = level;
 }

PNG_IMPEXP void() png_set_text_compression_mem_level	(	png_structrp	png_ptr,
		int	mem_level
	)

 {
    png_debug(1, "in png_set_text_compression_mem_level");
 
    if (png_ptr == NULL)
       return;
 
    png_ptr->zlib_text_mem_level = mem_level;
 }

PNG_IMPEXP void() png_set_text_compression_strategy	(	png_structrp	png_ptr,
		int	strategy
	)

 {
    png_debug(1, "in png_set_text_compression_strategy");
 
    if (png_ptr == NULL)
       return;
 
    png_ptr->zlib_text_strategy = strategy;
 }

PNG_IMPEXP void() png_set_text_compression_window_bits	(	png_structrp	png_ptr,
		int	window_bits
	)

 {
    if (png_ptr == NULL)
       return;
 
    if (window_bits > 15)
    {
       png_warning(png_ptr, "Only compression windows <= 32k supported by PNG");
       window_bits = 15;
    }
 
    else if (window_bits < 8)
    {
       png_warning(png_ptr, "Only compression windows >= 256 supported by PNG");
       window_bits = 8;
    }
 
    png_ptr->zlib_text_window_bits = window_bits;
 }

PNG_IMPEXP void() png_set_text_compression_method	(	png_structrp	png_ptr,
		int	method
	)

 {
    png_debug(1, "in png_set_text_compression_method");
 
    if (png_ptr == NULL)
       return;
 
    if (method != 8)
       png_warning(png_ptr, "Only compression method 8 is supported by PNG");
 
    png_ptr->zlib_text_method = method;
 }

PNG_IMPEXP void() png_init_io	(	png_structrp	png_ptr,
		png_FILE_p	fp
	)

 {
    png_debug(1, "in png_init_io");
 
    if (png_ptr == NULL)
       return;
 
    png_ptr->io_ptr = (png_voidp)fp;
 }

PNG_IMPEXP void() png_set_error_fn	(	png_structrp	png_ptr,
		png_voidp	error_ptr,
		png_error_ptr	error_fn,
		png_error_ptr	warning_fn
	)

 {
    if (png_ptr == NULL)
       return;
 
    png_ptr->error_ptr = error_ptr;
    png_ptr->error_fn = error_fn;
 #ifdef PNG_WARNINGS_SUPPORTED
    png_ptr->warning_fn = warning_fn;
 #else
    PNG_UNUSED(warning_fn)
 #endif
 }

PNG_IMPEXP png_voidp() png_get_error_ptr ( png_const_structrp png_ptr )

 {
    if (png_ptr == NULL)
       return NULL;
 
    return ((png_voidp)png_ptr->error_ptr);
 }

PNG_IMPEXP void() png_set_write_fn	(	png_structrp	png_ptr,
		png_voidp	io_ptr,
		png_rw_ptr	write_data_fn,
		png_flush_ptr	output_flush_fn
	)

 {
    if (png_ptr == NULL)
       return;
 
    png_ptr->io_ptr = io_ptr;
 
 #ifdef PNG_STDIO_SUPPORTED
    if (write_data_fn != NULL)
       png_ptr->write_data_fn = write_data_fn;
 
    else
       png_ptr->write_data_fn = png_default_write_data;
 #else
    png_ptr->write_data_fn = write_data_fn;
 #endif
 
 #ifdef PNG_WRITE_FLUSH_SUPPORTED
 #  ifdef PNG_STDIO_SUPPORTED
 
    if (output_flush_fn != NULL)
       png_ptr->output_flush_fn = output_flush_fn;
 
    else
       png_ptr->output_flush_fn = png_default_flush;
 
 #  else
    png_ptr->output_flush_fn = output_flush_fn;
 #  endif
 #else
    PNG_UNUSED(output_flush_fn)
 #endif /* WRITE_FLUSH */
 
 #ifdef PNG_READ_SUPPORTED
    /* It is an error to read while writing a png file */
    if (png_ptr->read_data_fn != NULL)
    {
       png_ptr->read_data_fn = NULL;
 
       png_warning(png_ptr,
           "Can't set both read_data_fn and write_data_fn in the"
           " same structure");
    }
 #endif
 }

PNG_IMPEXP void() png_set_read_fn	(	png_structrp	png_ptr,
		png_voidp	io_ptr,
		png_rw_ptr	read_data_fn
	)

 {
    if (png_ptr == NULL)
       return;
 
    png_ptr->io_ptr = io_ptr;
 
 #ifdef PNG_STDIO_SUPPORTED
    if (read_data_fn != NULL)
       png_ptr->read_data_fn = read_data_fn;
 
    else
       png_ptr->read_data_fn = png_default_read_data;
 #else
    png_ptr->read_data_fn = read_data_fn;
 #endif
 
 #ifdef PNG_WRITE_SUPPORTED
    /* It is an error to write to a read device */
    if (png_ptr->write_data_fn != NULL)
    {
       png_ptr->write_data_fn = NULL;
       png_warning(png_ptr,
           "Can't set both read_data_fn and write_data_fn in the"
           " same structure");
    }
 #endif
 
 #ifdef PNG_WRITE_FLUSH_SUPPORTED
    png_ptr->output_flush_fn = NULL;
 #endif
 }

PNG_IMPEXP png_voidp() png_get_io_ptr ( png_const_structrp png_ptr )

 {
    if (png_ptr == NULL)
       return (NULL);
 
    return (png_ptr->io_ptr);
 }

PNG_IMPEXP void() png_set_read_status_fn	(	png_structrp	png_ptr,
		png_read_status_ptr	read_row_fn
	)

 {
    if (png_ptr == NULL)
       return;
 
    png_ptr->read_row_fn = read_row_fn;
 }

PNG_IMPEXP void() png_set_write_status_fn	(	png_structrp	png_ptr,
		png_write_status_ptr	write_row_fn
	)

 {
    if (png_ptr == NULL)
       return;
 
    png_ptr->write_row_fn = write_row_fn;
 }

PNG_IMPEXP void() png_set_mem_fn	(	png_structrp	png_ptr,
		png_voidp	mem_ptr,
		png_malloc_ptr	malloc_fn,
		png_free_ptr	free_fn
	)

 {
    if (png_ptr != NULL)
    {
       png_ptr->mem_ptr = mem_ptr;
       png_ptr->malloc_fn = malloc_fn;
       png_ptr->free_fn = free_fn;
    }
 }

PNG_IMPEXP png_voidp() png_get_mem_ptr ( png_const_structrp png_ptr )

 {
    if (png_ptr == NULL)
       return NULL;
 
    return png_ptr->mem_ptr;
 }

PNG_IMPEXP void() png_set_read_user_transform_fn	(	png_structrp	png_ptr,
		png_user_transform_ptr	read_user_transform_fn
	)

 {
    png_debug(1, "in png_set_read_user_transform_fn");
 
 #ifdef PNG_READ_USER_TRANSFORM_SUPPORTED
    png_ptr->transformations |= PNG_USER_TRANSFORM;
    png_ptr->read_user_transform_fn = read_user_transform_fn;
 #endif
 }

PNG_IMPEXP void() png_set_write_user_transform_fn	(	png_structrp	png_ptr,
		png_user_transform_ptr	write_user_transform_fn
	)

 {
    png_debug(1, "in png_set_write_user_transform_fn");
 
    if (png_ptr == NULL)
       return;
 
    png_ptr->transformations |= PNG_USER_TRANSFORM;
    png_ptr->write_user_transform_fn = write_user_transform_fn;
 }

PNG_IMPEXP void() png_set_user_transform_info	(	png_structrp	png_ptr,
		png_voidp	user_transform_ptr,
		int	user_transform_depth,
		int	user_transform_channels
	)

 {
    png_debug(1, "in png_set_user_transform_info");
 
    if (png_ptr == NULL)
       return;
 
 #ifdef PNG_READ_USER_TRANSFORM_SUPPORTED
    if ((png_ptr->mode & PNG_IS_READ_STRUCT) != 0 &&
       (png_ptr->flags & PNG_FLAG_ROW_INIT) != 0)
    {
       png_app_error(png_ptr,
             "info change after png_start_read_image or png_read_update_info");
       return;
    }
 #endif
 
    png_ptr->user_transform_ptr = user_transform_ptr;
    png_ptr->user_transform_depth = (png_byte)user_transform_depth;
    png_ptr->user_transform_channels = (png_byte)user_transform_channels;
 }

PNG_IMPEXP png_voidp() png_get_user_transform_ptr ( png_const_structrp png_ptr )

 {
    if (png_ptr == NULL)
       return (NULL);
 
    return png_ptr->user_transform_ptr;
 }

PNG_IMPEXP png_uint_32() png_get_current_row_number ( png_const_structrp )

 {
    /* See the comments in png.h - this is the sub-image row when reading an
     * interlaced image.
     */
    if (png_ptr != NULL)
       return png_ptr->row_number;
 
    return PNG_UINT_32_MAX; /* help the app not to fail silently */
 }

PNG_IMPEXP png_byte() png_get_current_pass_number ( png_const_structrp )

 {
    if (png_ptr != NULL)
       return png_ptr->pass;
    return 8; /* invalid */
 }

PNG_IMPEXP void() png_set_read_user_chunk_fn	(	png_structrp	png_ptr,
		png_voidp	user_chunk_ptr,
		png_user_chunk_ptr	read_user_chunk_fn
	)

 {
    png_debug(1, "in png_set_read_user_chunk_fn");
 
    if (png_ptr == NULL)
       return;
 
    png_ptr->read_user_chunk_fn = read_user_chunk_fn;
    png_ptr->user_chunk_ptr = user_chunk_ptr;
 }

PNG_IMPEXP png_voidp() png_get_user_chunk_ptr ( png_const_structrp png_ptr )

 {
    return (png_ptr ? png_ptr->user_chunk_ptr : NULL);
 }

PNG_IMPEXP void() png_set_progressive_read_fn	(	png_structrp	png_ptr,
		png_voidp	progressive_ptr,
		png_progressive_info_ptr	info_fn,
		png_progressive_row_ptr	row_fn,
		png_progressive_end_ptr	end_fn
	)

 {
    if (png_ptr == NULL)
       return;
 
    png_ptr->info_fn = info_fn;
    png_ptr->row_fn = row_fn;
    png_ptr->end_fn = end_fn;
 
    png_set_read_fn(png_ptr, progressive_ptr, png_push_fill_buffer);
 }

PNG_IMPEXP png_voidp() png_get_progressive_ptr ( png_const_structrp png_ptr )

 {
    if (png_ptr == NULL)
       return (NULL);
 
    return png_ptr->io_ptr;
 }

PNG_IMPEXP void() png_process_data	(	png_structrp	png_ptr,
		png_inforp	info_ptr,
		png_bytep	buffer,
		png_size_t	buffer_size
	)

 {
    if (png_ptr == NULL || info_ptr == NULL)
       return;
 
    png_push_restore_buffer(png_ptr, buffer, buffer_size);
 
    while (png_ptr->buffer_size)
    {
       png_process_some_data(png_ptr, info_ptr);
    }
 }

PNG_IMPEXP png_size_t() png_process_data_pause	(	png_structrp	,
		int	save
	)

 {
    if (png_ptr != NULL)
    {
       /* It's easiest for the caller if we do the save; then the caller doesn't
        * have to supply the same data again:
        */
       if (save != 0)
          png_push_save_buffer(png_ptr);
       else
       {
          /* This includes any pending saved bytes: */
          png_size_t remaining = png_ptr->buffer_size;
          png_ptr->buffer_size = 0;
 
          /* So subtract the saved buffer size, unless all the data
           * is actually 'saved', in which case we just return 0
           */
          if (png_ptr->save_buffer_size < remaining)
             return remaining - png_ptr->save_buffer_size;
       }
    }
 
    return 0;
 }

PNG_IMPEXP png_uint_32() png_process_data_skip ( png_structrp )

 {
    png_uint_32 remaining = 0;
 
    if (png_ptr != NULL && png_ptr->process_mode == PNG_SKIP_MODE &&
       png_ptr->skip_length > 0)
    {
       /* At the end of png_process_data the buffer size must be 0 (see the loop
        * above) so we can detect a broken call here:
        */
       if (png_ptr->buffer_size != 0)
          png_error(png_ptr,
             "png_process_data_skip called inside png_process_data");
 
       /* If is impossible for there to be a saved buffer at this point -
        * otherwise we could not be in SKIP mode.  This will also happen if
        * png_process_skip is called inside png_process_data (but only very
        * rarely.)
        */
       if (png_ptr->save_buffer_size != 0)
          png_error(png_ptr, "png_process_data_skip called with saved data");
 
       remaining = png_ptr->skip_length;
       png_ptr->skip_length = 0;
       png_ptr->process_mode = PNG_READ_CHUNK_MODE;
    }
 
    return remaining;
 }

PNG_IMPEXP void() png_progressive_combine_row	(	png_const_structrp	png_ptr,
		png_bytep	old_row,
		png_const_bytep	new_row
	)

 {
    if (png_ptr == NULL)
       return;
 
    /* new_row is a flag here - if it is NULL then the app callback was called
     * from an empty row (see the calls to png_struct::row_fn below), otherwise
     * it must be png_ptr->row_buf+1
     */
    if (new_row != NULL)
       png_combine_row(png_ptr, old_row, 1/*blocky display*/);
 }

PNG_IMPEXP png_voidp() png_malloc	(	png_const_structrp	png_ptr,
		png_alloc_size_t	size
	)

 {
    png_voidp ret;
 
    if (png_ptr == NULL)
       return NULL;
 
    ret = png_malloc_base(png_ptr, size);
 
    if (ret == NULL)
        png_error(png_ptr, "Out of memory"); /* 'm' means png_malloc */
 
    return ret;
 }

PNG_IMPEXP png_voidp() png_calloc	(	png_const_structrp	png_ptr,
		png_alloc_size_t	size
	)

 {
    png_voidp ret;
 
    ret = png_malloc(png_ptr, size);
 
    if (ret != NULL)
       memset(ret, 0, size);
 
    return ret;
 }

PNG_IMPEXP png_voidp() png_malloc_warn	(	png_const_structrp	png_ptr,
		png_alloc_size_t	size
	)

 {
    if (png_ptr != NULL)
    {
       png_voidp ret = png_malloc_base(png_ptr, size);
 
       if (ret != NULL)
          return ret;
 
       png_warning(png_ptr, "Out of memory");
    }
 
    return NULL;
 }

PNG_IMPEXP void() png_free	(	png_const_structrp	png_ptr,
		png_voidp	ptr
	)

 {
    if (png_ptr == NULL || ptr == NULL)
       return;
 
 #ifdef PNG_USER_MEM_SUPPORTED
    if (png_ptr->free_fn != NULL)
       png_ptr->free_fn(png_constcast(png_structrp,png_ptr), ptr);
 
    else
       png_free_default(png_ptr, ptr);
 }

PNG_IMPEXP void() png_free_data	(	png_const_structrp	png_ptr,
		png_inforp	info_ptr,
		png_uint_32	free_me,
		int	num
	)

 {
    png_debug(1, "in png_free_data");
 
    if (png_ptr == NULL || info_ptr == NULL)
       return;
 
 #ifdef PNG_TEXT_SUPPORTED
    /* Free text item num or (if num == -1) all text items */
    if (info_ptr->text != 0 &&
        ((mask & PNG_FREE_TEXT) & info_ptr->free_me) != 0)
    {
       if (num != -1)
       {
          png_free(png_ptr, info_ptr->text[num].key);
          info_ptr->text[num].key = NULL;
       }
 
       else
       {
          int i;
 
          for (i = 0; i < info_ptr->num_text; i++)
             png_free(png_ptr, info_ptr->text[i].key);
 
          png_free(png_ptr, info_ptr->text);
          info_ptr->text = NULL;
          info_ptr->num_text = 0;
       }
    }
 #endif
 
 #ifdef PNG_tRNS_SUPPORTED
    /* Free any tRNS entry */
    if (((mask & PNG_FREE_TRNS) & info_ptr->free_me) != 0)
    {
       png_free(png_ptr, info_ptr->trans_alpha);
       info_ptr->trans_alpha = NULL;
       info_ptr->valid &= ~PNG_INFO_tRNS;
    }
 #endif
 
 #ifdef PNG_sCAL_SUPPORTED
    /* Free any sCAL entry */
    if (((mask & PNG_FREE_SCAL) & info_ptr->free_me) != 0)
    {
       png_free(png_ptr, info_ptr->scal_s_width);
       png_free(png_ptr, info_ptr->scal_s_height);
       info_ptr->scal_s_width = NULL;
       info_ptr->scal_s_height = NULL;
       info_ptr->valid &= ~PNG_INFO_sCAL;
    }
 #endif
 
 #ifdef PNG_pCAL_SUPPORTED
    /* Free any pCAL entry */
    if (((mask & PNG_FREE_PCAL) & info_ptr->free_me) != 0)
    {
       png_free(png_ptr, info_ptr->pcal_purpose);
       png_free(png_ptr, info_ptr->pcal_units);
       info_ptr->pcal_purpose = NULL;
       info_ptr->pcal_units = NULL;
 
       if (info_ptr->pcal_params != NULL)
          {
             int i;
 
             for (i = 0; i < info_ptr->pcal_nparams; i++)
                png_free(png_ptr, info_ptr->pcal_params[i]);
 
             png_free(png_ptr, info_ptr->pcal_params);
             info_ptr->pcal_params = NULL;
          }
       info_ptr->valid &= ~PNG_INFO_pCAL;
    }
 #endif
 
 #ifdef PNG_iCCP_SUPPORTED
    /* Free any profile entry */
    if (((mask & PNG_FREE_ICCP) & info_ptr->free_me) != 0)
    {
       png_free(png_ptr, info_ptr->iccp_name);
       png_free(png_ptr, info_ptr->iccp_profile);
       info_ptr->iccp_name = NULL;
       info_ptr->iccp_profile = NULL;
       info_ptr->valid &= ~PNG_INFO_iCCP;
    }
 #endif
 
 #ifdef PNG_sPLT_SUPPORTED
    /* Free a given sPLT entry, or (if num == -1) all sPLT entries */
    if (info_ptr->splt_palettes != 0 &&
        ((mask & PNG_FREE_SPLT) & info_ptr->free_me) != 0)
    {
       if (num != -1)
       {
          png_free(png_ptr, info_ptr->splt_palettes[num].name);
          png_free(png_ptr, info_ptr->splt_palettes[num].entries);
          info_ptr->splt_palettes[num].name = NULL;
          info_ptr->splt_palettes[num].entries = NULL;
       }
 
       else
       {
          if (info_ptr->splt_palettes_num != 0)
          {
             int i;
 
             for (i = 0; i < info_ptr->splt_palettes_num; i++)
             {
                png_free(png_ptr, info_ptr->splt_palettes[i].name);
                png_free(png_ptr, info_ptr->splt_palettes[i].entries);
             }
 
             png_free(png_ptr, info_ptr->splt_palettes);
             info_ptr->splt_palettes = NULL;
             info_ptr->splt_palettes_num = 0;
          }
          info_ptr->valid &= ~PNG_INFO_sPLT;
       }
    }
 #endif
 
 #ifdef PNG_STORE_UNKNOWN_CHUNKS_SUPPORTED
    if (info_ptr->unknown_chunks != 0 &&
        ((mask & PNG_FREE_UNKN) & info_ptr->free_me) != 0)
    {
       if (num != -1)
       {
           png_free(png_ptr, info_ptr->unknown_chunks[num].data);
           info_ptr->unknown_chunks[num].data = NULL;
       }
 
       else
       {
          int i;
 
          if (info_ptr->unknown_chunks_num != 0)
          {
             for (i = 0; i < info_ptr->unknown_chunks_num; i++)
                png_free(png_ptr, info_ptr->unknown_chunks[i].data);
 
             png_free(png_ptr, info_ptr->unknown_chunks);
             info_ptr->unknown_chunks = NULL;
             info_ptr->unknown_chunks_num = 0;
          }
       }
    }
 #endif
 
 #ifdef PNG_hIST_SUPPORTED
    /* Free any hIST entry */
    if (((mask & PNG_FREE_HIST) & info_ptr->free_me) != 0)
    {
       png_free(png_ptr, info_ptr->hist);
       info_ptr->hist = NULL;
       info_ptr->valid &= ~PNG_INFO_hIST;
    }
 #endif
 
    /* Free any PLTE entry that was internally allocated */
    if (((mask & PNG_FREE_PLTE) & info_ptr->free_me) != 0)
    {
       png_free(png_ptr, info_ptr->palette);
       info_ptr->palette = NULL;
       info_ptr->valid &= ~PNG_INFO_PLTE;
       info_ptr->num_palette = 0;
    }
 
 #ifdef PNG_INFO_IMAGE_SUPPORTED
    /* Free any image bits attached to the info structure */
    if (((mask & PNG_FREE_ROWS) & info_ptr->free_me) != 0)
    {
       if (info_ptr->row_pointers != 0)
       {
          png_uint_32 row;
          for (row = 0; row < info_ptr->height; row++)
             png_free(png_ptr, info_ptr->row_pointers[row]);
 
          png_free(png_ptr, info_ptr->row_pointers);
          info_ptr->row_pointers = NULL;
       }
       info_ptr->valid &= ~PNG_INFO_IDAT;
    }
 #endif
 
    if (num != -1)
       mask &= ~PNG_FREE_MUL;
 
    info_ptr->free_me &= ~mask;
 }

PNG_IMPEXP void() png_data_freer	(	png_const_structrp	png_ptr,
		png_inforp	info_ptr,
		int	freer,
		png_uint_32	mask
	)

 {
    png_debug(1, "in png_data_freer");
 
    if (png_ptr == NULL || info_ptr == NULL)
       return;
 
    if (freer == PNG_DESTROY_WILL_FREE_DATA)
       info_ptr->free_me |= mask;
 
    else if (freer == PNG_USER_WILL_FREE_DATA)
       info_ptr->free_me &= ~mask;
 
    else
       png_error(png_ptr, "Unknown freer parameter in png_data_freer");
 }

PNG_DEPRECATED PNG_IMPEXP png_voidp() png_malloc_default	(	png_const_structrp	png_ptr,
		png_alloc_size_t	size
	)

 {
    png_voidp ret;
 
    if (png_ptr == NULL)
       return NULL;
 
    /* Passing 'NULL' here bypasses the application provided memory handler. */
    ret = png_malloc_base(NULL/*use malloc*/, size);
 
    if (ret == NULL)
       png_error(png_ptr, "Out of Memory"); /* 'M' means png_malloc_default */
 
    return ret;
 }

PNG_DEPRECATED PNG_IMPEXP void() png_free_default	(	png_const_structrp	png_ptr,
		png_voidp	ptr
	)

 {
    if (png_ptr == NULL || ptr == NULL)
       return;
 #endif /* USER_MEM */
 
    free(ptr);
 }

PNG_IMPEXP void() png_error	(	png_const_structrp	png_ptr,
		png_const_charp	error_message
	)

 {
 #ifdef PNG_ERROR_NUMBERS_SUPPORTED
    char msg[16];
    if (png_ptr != NULL)
    {
       if ((png_ptr->flags &
          (PNG_FLAG_STRIP_ERROR_NUMBERS|PNG_FLAG_STRIP_ERROR_TEXT)) != 0
       {
          if (*error_message == PNG_LITERAL_SHARP)
          {
             /* Strip "#nnnn " from beginning of error message. */
             int offset;
             for (offset = 1; offset<15; offset++)
                if (error_message[offset] == ' ')
                   break;
 
             if ((png_ptr->flags & PNG_FLAG_STRIP_ERROR_TEXT) != 0)
             {
                int i;
                for (i = 0; i < offset - 1; i++)
                   msg[i] = error_message[i + 1];
                msg[i - 1] = '\0';
                error_message = msg;
             }
 
             else
                error_message += offset;
       }
 
       else
       {
          if ((png_ptr->flags & PNG_FLAG_STRIP_ERROR_TEXT) != 0)
          {
             msg[0] = '0';
             msg[1] = '\0';
             error_message = msg;
          }
        }
      }
    }
 #endif
    if (png_ptr != NULL && png_ptr->error_fn != NULL)
       (*(png_ptr->error_fn))(png_constcast(png_structrp,png_ptr),
           error_message);
 
    /* If the custom handler doesn't exist, or if it returns,
       use the default handler, which will not return. */
    png_default_error(png_ptr, error_message);
 }

PNG_IMPEXP void() png_chunk_error	(	png_const_structrp	png_ptr,
		png_const_charp	error_message
	)

 {
    char msg[18+PNG_MAX_ERROR_TEXT];
    if (png_ptr == NULL)
       png_error(png_ptr, error_message);
 
    else
    {
       png_format_buffer(png_ptr, msg, error_message);
       png_error(png_ptr, msg);
    }
 }

PNG_IMPEXP void() png_warning	(	png_const_structrp	png_ptr,
		png_const_charp	warning_message
	)

 {
    int offset = 0;
    if (png_ptr != NULL)
    {
 #ifdef PNG_ERROR_NUMBERS_SUPPORTED
    if ((png_ptr->flags &
        (PNG_FLAG_STRIP_ERROR_NUMBERS|PNG_FLAG_STRIP_ERROR_TEXT)) != 0)
 #endif
       {
          if (*warning_message == PNG_LITERAL_SHARP)
          {
             for (offset = 1; offset < 15; offset++)
                if (warning_message[offset] == ' ')
                   break;
          }
       }
    }
    if (png_ptr != NULL && png_ptr->warning_fn != NULL)
       (*(png_ptr->warning_fn))(png_constcast(png_structrp,png_ptr),
          warning_message + offset);
    else
       png_default_warning(png_ptr, warning_message + offset);
 }

PNG_IMPEXP void() png_chunk_warning	(	png_const_structrp	png_ptr,
		png_const_charp	warning_message
	)

 {
    char msg[18+PNG_MAX_ERROR_TEXT];
    if (png_ptr == NULL)
       png_warning(png_ptr, warning_message);
 
    else
    {
       png_format_buffer(png_ptr, msg, warning_message);
       png_warning(png_ptr, msg);
    }
 }

PNG_IMPEXP void() png_benign_error	(	png_const_structrp	png_ptr,
		png_const_charp	warning_message
	)

 {
    if ((png_ptr->flags & PNG_FLAG_BENIGN_ERRORS_WARN) != 0)
    {
 #     ifdef PNG_READ_SUPPORTED
          if ((png_ptr->mode & PNG_IS_READ_STRUCT) != 0 &&
             png_ptr->chunk_name != 0)
             png_chunk_warning(png_ptr, error_message);
          else
 #     endif
       png_warning(png_ptr, error_message);
    }
 
    else
    {
 #     ifdef PNG_READ_SUPPORTED
          if ((png_ptr->mode & PNG_IS_READ_STRUCT) != 0 &&
             png_ptr->chunk_name != 0)
             png_chunk_error(png_ptr, error_message);
          else
 #     endif
       png_error(png_ptr, error_message);
    }
 
 #  ifndef PNG_ERROR_TEXT_SUPPORTED
       PNG_UNUSED(error_message)
 #  endif
 }

PNG_IMPEXP void() png_chunk_benign_error	(	png_const_structrp	png_ptr,
		png_const_charp	warning_message
	)

 {
    if ((png_ptr->flags & PNG_FLAG_BENIGN_ERRORS_WARN) != 0)
       png_chunk_warning(png_ptr, error_message);
 
    else
       png_chunk_error(png_ptr, error_message);
 
 #  ifndef PNG_ERROR_TEXT_SUPPORTED
       PNG_UNUSED(error_message)
 #  endif
 }

PNG_IMPEXP void() png_set_benign_errors	(	png_structrp	png_ptr,
		int	allowed
	)

 {
    png_debug(1, "in png_set_benign_errors");
 
    /* If allowed is 1, png_benign_error() is treated as a warning.
     *
     * If allowed is 0, png_benign_error() is treated as an error (which
     * is the default behavior if png_set_benign_errors() is not called).
     */
 
    if (allowed != 0)
       png_ptr->flags |= PNG_FLAG_BENIGN_ERRORS_WARN |
          PNG_FLAG_APP_WARNINGS_WARN | PNG_FLAG_APP_ERRORS_WARN;
 
    else
       png_ptr->flags &= ~(PNG_FLAG_BENIGN_ERRORS_WARN |
          PNG_FLAG_APP_WARNINGS_WARN | PNG_FLAG_APP_ERRORS_WARN);
 }

PNG_IMPEXP png_uint_32() png_get_valid	(	png_const_structrp	png_ptr,
		png_const_inforp	info_ptr,
		png_uint_32	flag
	)

 {
    if (png_ptr != NULL && info_ptr != NULL)
       return(info_ptr->valid & flag);
 
    return(0);
 }

PNG_IMPEXP png_size_t() png_get_rowbytes	(	png_const_structrp	png_ptr,
		png_const_inforp	info_ptr
	)

 {
    if (png_ptr != NULL && info_ptr != NULL)
       return(info_ptr->rowbytes);
 
    return(0);
 }

PNG_IMPEXP png_bytepp() png_get_rows	(	png_const_structrp	png_ptr,
		png_const_inforp	info_ptr
	)

 {
    if (png_ptr != NULL && info_ptr != NULL)
       return(info_ptr->row_pointers);
 
    return(0);
 }

PNG_IMPEXP void() png_set_rows	(	png_const_structrp	png_ptr,
		png_inforp	info_ptr,
		png_bytepp	row_pointers
	)

 {
    png_debug1(1, "in %s storage function", "rows");
 
    if (png_ptr == NULL || info_ptr == NULL)
       return;
 
    if (info_ptr->row_pointers != NULL &&
        (info_ptr->row_pointers != row_pointers))
       png_free_data(png_ptr, info_ptr, PNG_FREE_ROWS, 0);
 
    info_ptr->row_pointers = row_pointers;
 
    if (row_pointers != NULL)
       info_ptr->valid |= PNG_INFO_IDAT;
 }

PNG_IMPEXP png_byte() png_get_channels	(	png_const_structrp	png_ptr,
		png_const_inforp	info_ptr
	)

 {
    if (png_ptr != NULL && info_ptr != NULL)
       return(info_ptr->channels);
 
    return (0);
 }

PNG_IMPEXP png_uint_32() png_get_image_width	(	png_const_structrp	png_ptr,
		png_const_inforp	info_ptr
	)

 {
    if (png_ptr != NULL && info_ptr != NULL)
       return info_ptr->width;
 
    return (0);
 }

PNG_IMPEXP png_uint_32() png_get_image_height	(	png_const_structrp	png_ptr,
		png_const_inforp	info_ptr
	)

 {
    if (png_ptr != NULL && info_ptr != NULL)
       return info_ptr->height;
 
    return (0);
 }

PNG_IMPEXP png_byte() png_get_bit_depth	(	png_const_structrp	png_ptr,
		png_const_inforp	info_ptr
	)

 {
    if (png_ptr != NULL && info_ptr != NULL)
       return info_ptr->bit_depth;
 
    return (0);
 }

PNG_IMPEXP png_byte() png_get_color_type	(	png_const_structrp	png_ptr,
		png_const_inforp	info_ptr
	)

 {
    if (png_ptr != NULL && info_ptr != NULL)
       return info_ptr->color_type;
 
    return (0);
 }

PNG_IMPEXP png_byte() png_get_filter_type	(	png_const_structrp	png_ptr,
		png_const_inforp	info_ptr
	)

 {
    if (png_ptr != NULL && info_ptr != NULL)
       return info_ptr->filter_type;
 
    return (0);
 }

PNG_IMPEXP png_byte() png_get_interlace_type	(	png_const_structrp	png_ptr,
		png_const_inforp	info_ptr
	)

 {
    if (png_ptr != NULL && info_ptr != NULL)
       return info_ptr->interlace_type;
 
    return (0);
 }

PNG_IMPEXP png_byte() png_get_compression_type	(	png_const_structrp	png_ptr,
		png_const_inforp	info_ptr
	)

 {
    if (png_ptr != NULL && info_ptr != NULL)
       return info_ptr->compression_type;
 
    return (0);
 }

PNG_IMPEXP png_uint_32() png_get_pixels_per_meter	(	png_const_structrp	png_ptr,
		png_const_inforp	info_ptr
	)

 {
 #ifdef PNG_pHYs_SUPPORTED
    if (png_ptr != NULL && info_ptr != NULL &&
        (info_ptr->valid & PNG_INFO_pHYs) != 0)
    {
       png_debug1(1, "in %s retrieval function", "png_get_pixels_per_meter");
 
       if (info_ptr->phys_unit_type == PNG_RESOLUTION_METER &&
           info_ptr->x_pixels_per_unit == info_ptr->y_pixels_per_unit)
          return (info_ptr->x_pixels_per_unit);
    }
 #else
    PNG_UNUSED(png_ptr)
    PNG_UNUSED(info_ptr)
 #endif
 
    return (0);
 }

PNG_IMPEXP png_uint_32() png_get_x_pixels_per_meter	(	png_const_structrp	png_ptr,
		png_const_inforp	info_ptr
	)

 {
 #ifdef PNG_pHYs_SUPPORTED
    if (png_ptr != NULL && info_ptr != NULL &&
        (info_ptr->valid & PNG_INFO_pHYs) != 0)
       {
          png_debug1(1, "in %s retrieval function",
              "png_get_x_pixels_per_meter");
 
          if (info_ptr->phys_unit_type == PNG_RESOLUTION_METER)
             return (info_ptr->x_pixels_per_unit);
       }
 #else
    PNG_UNUSED(png_ptr)
    PNG_UNUSED(info_ptr)
 #endif
 
    return (0);
 }

PNG_IMPEXP png_uint_32() png_get_y_pixels_per_meter	(	png_const_structrp	png_ptr,
		png_const_inforp	info_ptr
	)

 {
 #ifdef PNG_pHYs_SUPPORTED
    if (png_ptr != NULL && info_ptr != NULL &&
        (info_ptr->valid & PNG_INFO_pHYs) != 0)
    {
       png_debug1(1, "in %s retrieval function",
           "png_get_y_pixels_per_meter");
 
       if (info_ptr->phys_unit_type == PNG_RESOLUTION_METER)
          return (info_ptr->y_pixels_per_unit);
    }
 #else
    PNG_UNUSED(png_ptr)
    PNG_UNUSED(info_ptr)
 #endif
 
    return (0);
 }

PNG_IMPEXP float() png_get_pixel_aspect_ratio	(	png_const_structrp	png_ptr,
		png_const_inforp	info_ptr
	)

 {
 #ifdef PNG_READ_pHYs_SUPPORTED
    if (png_ptr != NULL && info_ptr != NULL &&
        (info_ptr->valid & PNG_INFO_pHYs) != 0)
    {
       png_debug1(1, "in %s retrieval function", "png_get_aspect_ratio");
 
       if (info_ptr->x_pixels_per_unit != 0)
          return ((float)((float)info_ptr->y_pixels_per_unit
              /(float)info_ptr->x_pixels_per_unit));
    }
 #else
    PNG_UNUSED(png_ptr)
    PNG_UNUSED(info_ptr)
 #endif
 
    return ((float)0.0);
 }

PNG_IMPEXP png_fixed_point() png_get_pixel_aspect_ratio_fixed	(	png_const_structrp	png_ptr,
		png_const_inforp	info_ptr
	)

 {
 #ifdef PNG_READ_pHYs_SUPPORTED
    if (png_ptr != NULL && info_ptr != NULL &&
        (info_ptr->valid & PNG_INFO_pHYs) != 0 &&
        info_ptr->x_pixels_per_unit > 0 && info_ptr->y_pixels_per_unit > 0 &&
        info_ptr->x_pixels_per_unit <= PNG_UINT_31_MAX &&
        info_ptr->y_pixels_per_unit <= PNG_UINT_31_MAX)
    {
       png_fixed_point res;
 
       png_debug1(1, "in %s retrieval function", "png_get_aspect_ratio_fixed");
 
       /* The following casts work because a PNG 4 byte integer only has a valid
        * range of 0..2^31-1; otherwise the cast might overflow.
        */
       if (png_muldiv(&res, (png_int_32)info_ptr->y_pixels_per_unit, PNG_FP_1,
           (png_int_32)info_ptr->x_pixels_per_unit) != 0)
          return res;
    }
 #else
    PNG_UNUSED(png_ptr)
    PNG_UNUSED(info_ptr)
 #endif
 
    return 0;
 }

PNG_IMPEXP png_int_32() png_get_x_offset_pixels	(	png_const_structrp	png_ptr,
		png_const_inforp	info_ptr
	)

 {
 #ifdef PNG_oFFs_SUPPORTED
    if (png_ptr != NULL && info_ptr != NULL &&
        (info_ptr->valid & PNG_INFO_oFFs) != 0)
    {
       png_debug1(1, "in %s retrieval function", "png_get_x_offset_pixels");
 
       if (info_ptr->offset_unit_type == PNG_OFFSET_PIXEL)
          return (info_ptr->x_offset);
    }
 #else
    PNG_UNUSED(png_ptr)
    PNG_UNUSED(info_ptr)
 #endif
 
    return (0);
 }

PNG_IMPEXP png_int_32() png_get_y_offset_pixels	(	png_const_structrp	png_ptr,
		png_const_inforp	info_ptr
	)

 {
 #ifdef PNG_oFFs_SUPPORTED
    if (png_ptr != NULL && info_ptr != NULL &&
        (info_ptr->valid & PNG_INFO_oFFs) != 0)
    {
       png_debug1(1, "in %s retrieval function", "png_get_y_offset_pixels");
 
       if (info_ptr->offset_unit_type == PNG_OFFSET_PIXEL)
          return (info_ptr->y_offset);
    }
 #else
    PNG_UNUSED(png_ptr)
    PNG_UNUSED(info_ptr)
 #endif
 
    return (0);
 }

PNG_IMPEXP png_int_32() png_get_x_offset_microns	(	png_const_structrp	png_ptr,
		png_const_inforp	info_ptr
	)

 {
 #ifdef PNG_oFFs_SUPPORTED
    if (png_ptr != NULL && info_ptr != NULL &&
        (info_ptr->valid & PNG_INFO_oFFs) != 0)
    {
       png_debug1(1, "in %s retrieval function", "png_get_x_offset_microns");
 
       if (info_ptr->offset_unit_type == PNG_OFFSET_MICROMETER)
          return (info_ptr->x_offset);
    }
 #else
    PNG_UNUSED(png_ptr)
    PNG_UNUSED(info_ptr)
 #endif
 
    return (0);
 }

PNG_IMPEXP png_int_32() png_get_y_offset_microns	(	png_const_structrp	png_ptr,
		png_const_inforp	info_ptr
	)

 {
 #ifdef PNG_oFFs_SUPPORTED
    if (png_ptr != NULL && info_ptr != NULL &&
        (info_ptr->valid & PNG_INFO_oFFs) != 0)
    {
       png_debug1(1, "in %s retrieval function", "png_get_y_offset_microns");
 
       if (info_ptr->offset_unit_type == PNG_OFFSET_MICROMETER)
          return (info_ptr->y_offset);
    }
 #else
    PNG_UNUSED(png_ptr)
    PNG_UNUSED(info_ptr)
 #endif
 
    return (0);
 }

PNG_IMPEXP png_const_bytep() png_get_signature	(	png_const_structrp	png_ptr,
		png_const_inforp	info_ptr
	)

 {
    if (png_ptr != NULL && info_ptr != NULL)
       return(info_ptr->signature);
 
    return (NULL);
 }

PNG_IMPEXP png_uint_32() png_get_bKGD	(	png_const_structrp	png_ptr,
		png_inforp	info_ptr,
		png_color_16p *	background
	)

 {
    if (png_ptr != NULL && info_ptr != NULL &&
        (info_ptr->valid & PNG_INFO_bKGD) != 0 &&
        background != NULL)
    {
       png_debug1(1, "in %s retrieval function", "bKGD");
 
       *background = &(info_ptr->background);
       return (PNG_INFO_bKGD);
    }
 
    return (0);
 }

PNG_IMPEXP void() png_set_bKGD	(	png_const_structrp	png_ptr,
		png_inforp	info_ptr,
		png_const_color_16p	background
	)

 {
    png_debug1(1, "in %s storage function", "bKGD");
 
    if (png_ptr == NULL || info_ptr == NULL || background == NULL)
       return;
 
    info_ptr->background = *background;
    info_ptr->valid |= PNG_INFO_bKGD;
 }

PNG_IMPEXP png_uint_32() png_get_cHRM	(	png_const_structrp	png_ptr,
		png_const_inforp	info_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
	)

 {
    /* Quiet API change: this code used to only return the end points if a cHRM
     * chunk was present, but the end points can also come from iCCP or sRGB
     * chunks, so in 1.6.0 the png_get_ APIs return the end points regardless and
     * the png_set_ APIs merely check that set end points are mutually
     * consistent.
     */
    if (png_ptr != NULL && info_ptr != NULL &&
       (info_ptr->colorspace.flags & PNG_COLORSPACE_HAVE_ENDPOINTS) != 0)
    {
       png_debug1(1, "in %s retrieval function", "cHRM");
 
       if (white_x != NULL)
          *white_x = png_float(png_ptr,
             info_ptr->colorspace.end_points_xy.whitex, "cHRM white X");
       if (white_y != NULL)
          *white_y = png_float(png_ptr,
             info_ptr->colorspace.end_points_xy.whitey, "cHRM white Y");
       if (red_x != NULL)
          *red_x = png_float(png_ptr, info_ptr->colorspace.end_points_xy.redx,
             "cHRM red X");
       if (red_y != NULL)
          *red_y = png_float(png_ptr, info_ptr->colorspace.end_points_xy.redy,
             "cHRM red Y");
       if (green_x != NULL)
          *green_x = png_float(png_ptr,
             info_ptr->colorspace.end_points_xy.greenx, "cHRM green X");
       if (green_y != NULL)
          *green_y = png_float(png_ptr,
             info_ptr->colorspace.end_points_xy.greeny, "cHRM green Y");
       if (blue_x != NULL)
          *blue_x = png_float(png_ptr, info_ptr->colorspace.end_points_xy.bluex,
             "cHRM blue X");
       if (blue_y != NULL)
          *blue_y = png_float(png_ptr, info_ptr->colorspace.end_points_xy.bluey,
             "cHRM blue Y");
       return (PNG_INFO_cHRM);
    }
 
    return (0);
 }

PNG_IMPEXP png_uint_32() png_get_cHRM_XYZ	(	png_const_structrp	png_ptr,
		png_const_inforp	info_ptr,
		double *	red_X,
		double *	red_Y,
		double *	red_Z,
		double *	green_X,
		double *	green_Y,
		double *	green_Z,
		double *	blue_X,
		double *	blue_Y,
		double *	blue_Z
	)

 {
    if (png_ptr != NULL && info_ptr != NULL &&
       (info_ptr->colorspace.flags & PNG_COLORSPACE_HAVE_ENDPOINTS) != 0)
    {
       png_debug1(1, "in %s retrieval function", "cHRM_XYZ(float)");
 
       if (red_X != NULL)
          *red_X = png_float(png_ptr, info_ptr->colorspace.end_points_XYZ.red_X,
             "cHRM red X");
       if (red_Y != NULL)
          *red_Y = png_float(png_ptr, info_ptr->colorspace.end_points_XYZ.red_Y,
             "cHRM red Y");
       if (red_Z != NULL)
          *red_Z = png_float(png_ptr, info_ptr->colorspace.end_points_XYZ.red_Z,
             "cHRM red Z");
       if (green_X != NULL)
          *green_X = png_float(png_ptr,
             info_ptr->colorspace.end_points_XYZ.green_X, "cHRM green X");
       if (green_Y != NULL)
          *green_Y = png_float(png_ptr,
             info_ptr->colorspace.end_points_XYZ.green_Y, "cHRM green Y");
       if (green_Z != NULL)
          *green_Z = png_float(png_ptr,
             info_ptr->colorspace.end_points_XYZ.green_Z, "cHRM green Z");
       if (blue_X != NULL)
          *blue_X = png_float(png_ptr,
             info_ptr->colorspace.end_points_XYZ.blue_X, "cHRM blue X");
       if (blue_Y != NULL)
          *blue_Y = png_float(png_ptr,
             info_ptr->colorspace.end_points_XYZ.blue_Y, "cHRM blue Y");
       if (blue_Z != NULL)
          *blue_Z = png_float(png_ptr,
             info_ptr->colorspace.end_points_XYZ.blue_Z, "cHRM blue Z");
       return (PNG_INFO_cHRM);
    }
 
    return (0);
 }

PNG_IMPEXP png_uint_32() png_get_cHRM_fixed	(	png_const_structrp	png_ptr,
		png_const_inforp	info_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
	)

 {
    png_debug1(1, "in %s retrieval function", "cHRM");
 
    if (png_ptr != NULL && info_ptr != NULL &&
       (info_ptr->colorspace.flags & PNG_COLORSPACE_HAVE_ENDPOINTS) != 0)
    {
       if (white_x != NULL)
          *white_x = info_ptr->colorspace.end_points_xy.whitex;
       if (white_y != NULL)
          *white_y = info_ptr->colorspace.end_points_xy.whitey;
       if (red_x != NULL)
          *red_x = info_ptr->colorspace.end_points_xy.redx;
       if (red_y != NULL)
          *red_y = info_ptr->colorspace.end_points_xy.redy;
       if (green_x != NULL)
          *green_x = info_ptr->colorspace.end_points_xy.greenx;
       if (green_y != NULL)
          *green_y = info_ptr->colorspace.end_points_xy.greeny;
       if (blue_x != NULL)
          *blue_x = info_ptr->colorspace.end_points_xy.bluex;
       if (blue_y != NULL)
          *blue_y = info_ptr->colorspace.end_points_xy.bluey;
       return (PNG_INFO_cHRM);
    }
 
    return (0);
 }

PNG_IMPEXP png_uint_32() png_get_cHRM_XYZ_fixed	(	png_const_structrp	png_ptr,
		png_const_inforp	info_ptr,
		png_fixed_point *	int_red_X,
		png_fixed_point *	int_red_Y,
		png_fixed_point *	int_red_Z,
		png_fixed_point *	int_green_X,
		png_fixed_point *	int_green_Y,
		png_fixed_point *	int_green_Z,
		png_fixed_point *	int_blue_X,
		png_fixed_point *	int_blue_Y,
		png_fixed_point *	int_blue_Z
	)

 {
    if (png_ptr != NULL && info_ptr != NULL &&
       (info_ptr->colorspace.flags & PNG_COLORSPACE_HAVE_ENDPOINTS) != 0)
    {
       png_debug1(1, "in %s retrieval function", "cHRM_XYZ");
 
       if (int_red_X != NULL)
          *int_red_X = info_ptr->colorspace.end_points_XYZ.red_X;
       if (int_red_Y != NULL)
          *int_red_Y = info_ptr->colorspace.end_points_XYZ.red_Y;
       if (int_red_Z != NULL)
          *int_red_Z = info_ptr->colorspace.end_points_XYZ.red_Z;
       if (int_green_X != NULL)
          *int_green_X = info_ptr->colorspace.end_points_XYZ.green_X;
       if (int_green_Y != NULL)
          *int_green_Y = info_ptr->colorspace.end_points_XYZ.green_Y;
       if (int_green_Z != NULL)
          *int_green_Z = info_ptr->colorspace.end_points_XYZ.green_Z;
       if (int_blue_X != NULL)
          *int_blue_X = info_ptr->colorspace.end_points_XYZ.blue_X;
       if (int_blue_Y != NULL)
          *int_blue_Y = info_ptr->colorspace.end_points_XYZ.blue_Y;
       if (int_blue_Z != NULL)
          *int_blue_Z = info_ptr->colorspace.end_points_XYZ.blue_Z;
       return (PNG_INFO_cHRM);
    }
 
    return (0);
 }

PNG_IMPEXP void() png_set_cHRM	(	png_const_structrp	png_ptr,
		png_inforp	info_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
	)

 {
    png_set_cHRM_fixed(png_ptr, info_ptr,
       png_fixed(png_ptr, white_x, "cHRM White X"),
       png_fixed(png_ptr, white_y, "cHRM White Y"),
       png_fixed(png_ptr, red_x, "cHRM Red X"),
       png_fixed(png_ptr, red_y, "cHRM Red Y"),
       png_fixed(png_ptr, green_x, "cHRM Green X"),
       png_fixed(png_ptr, green_y, "cHRM Green Y"),
       png_fixed(png_ptr, blue_x, "cHRM Blue X"),
       png_fixed(png_ptr, blue_y, "cHRM Blue Y"));
 }

PNG_IMPEXP void() png_set_cHRM_XYZ	(	png_const_structrp	png_ptr,
		png_inforp	info_ptr,
		double	red_X,
		double	red_Y,
		double	red_Z,
		double	green_X,
		double	green_Y,
		double	green_Z,
		double	blue_X,
		double	blue_Y,
		double	blue_Z
	)

 {
    png_set_cHRM_XYZ_fixed(png_ptr, info_ptr,
       png_fixed(png_ptr, red_X, "cHRM Red X"),
       png_fixed(png_ptr, red_Y, "cHRM Red Y"),
       png_fixed(png_ptr, red_Z, "cHRM Red Z"),
       png_fixed(png_ptr, green_X, "cHRM Red X"),
       png_fixed(png_ptr, green_Y, "cHRM Red Y"),
       png_fixed(png_ptr, green_Z, "cHRM Red Z"),
       png_fixed(png_ptr, blue_X, "cHRM Red X"),
       png_fixed(png_ptr, blue_Y, "cHRM Red Y"),
       png_fixed(png_ptr, blue_Z, "cHRM Red Z"));
 }

PNG_IMPEXP void() png_set_cHRM_fixed	(	png_const_structrp	png_ptr,
		png_inforp	info_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
	)

 {
    png_xy xy;
 
    png_debug1(1, "in %s storage function", "cHRM fixed");
 
    if (png_ptr == NULL || info_ptr == NULL)
       return;
 
    xy.redx = red_x;
    xy.redy = red_y;
    xy.greenx = green_x;
    xy.greeny = green_y;
    xy.bluex = blue_x;
    xy.bluey = blue_y;
    xy.whitex = white_x;
    xy.whitey = white_y;
 
    if (png_colorspace_set_chromaticities(png_ptr, &info_ptr->colorspace, &xy,
        2/* override with app values*/) != 0)
       info_ptr->colorspace.flags |= PNG_COLORSPACE_FROM_cHRM;
 
    png_colorspace_sync_info(png_ptr, info_ptr);
 }

PNG_IMPEXP void() png_set_cHRM_XYZ_fixed	(	png_const_structrp	png_ptr,
		png_inforp	info_ptr,
		png_fixed_point	int_red_X,
		png_fixed_point	int_red_Y,
		png_fixed_point	int_red_Z,
		png_fixed_point	int_green_X,
		png_fixed_point	int_green_Y,
		png_fixed_point	int_green_Z,
		png_fixed_point	int_blue_X,
		png_fixed_point	int_blue_Y,
		png_fixed_point	int_blue_Z
	)

 {
    png_XYZ XYZ;
 
    png_debug1(1, "in %s storage function", "cHRM XYZ fixed");
 
    if (png_ptr == NULL || info_ptr == NULL)
       return;
 
    XYZ.red_X = int_red_X;
    XYZ.red_Y = int_red_Y;
    XYZ.red_Z = int_red_Z;
    XYZ.green_X = int_green_X;
    XYZ.green_Y = int_green_Y;
    XYZ.green_Z = int_green_Z;
    XYZ.blue_X = int_blue_X;
    XYZ.blue_Y = int_blue_Y;
    XYZ.blue_Z = int_blue_Z;
 
    if (png_colorspace_set_endpoints(png_ptr, &info_ptr->colorspace,
        &XYZ, 2) != 0)
       info_ptr->colorspace.flags |= PNG_COLORSPACE_FROM_cHRM;
 
    png_colorspace_sync_info(png_ptr, info_ptr);
 }

PNG_IMPEXP png_uint_32() png_get_gAMA	(	png_const_structrp	png_ptr,
		png_const_inforp	info_ptr,
		double *	file_gamma
	)

 {
    png_debug1(1, "in %s retrieval function", "gAMA(float)");
 
    if (png_ptr != NULL && info_ptr != NULL &&
       (info_ptr->colorspace.flags & PNG_COLORSPACE_HAVE_GAMMA) != 0 &&
       file_gamma != NULL)
    {
       *file_gamma = png_float(png_ptr, info_ptr->colorspace.gamma,
          "png_get_gAMA");
       return (PNG_INFO_gAMA);
    }
 
    return (0);
 }

PNG_IMPEXP png_uint_32() png_get_gAMA_fixed	(	png_const_structrp	png_ptr,
		png_const_inforp	info_ptr,
		png_fixed_point *	int_file_gamma
	)

 {
    png_debug1(1, "in %s retrieval function", "gAMA");
 
    if (png_ptr != NULL && info_ptr != NULL &&
       (info_ptr->colorspace.flags & PNG_COLORSPACE_HAVE_GAMMA) != 0 &&
       file_gamma != NULL)
    {
       *file_gamma = info_ptr->colorspace.gamma;
       return (PNG_INFO_gAMA);
    }
 
    return (0);
 }

PNG_IMPEXP void() png_set_gAMA	(	png_const_structrp	png_ptr,
		png_inforp	info_ptr,
		double	file_gamma
	)

 {
    png_set_gAMA_fixed(png_ptr, info_ptr, png_fixed(png_ptr, file_gamma,
        "png_set_gAMA"));
 }

PNG_IMPEXP void() png_set_gAMA_fixed	(	png_const_structrp	png_ptr,
		png_inforp	info_ptr,
		png_fixed_point	int_file_gamma
	)

 {
    png_debug1(1, "in %s storage function", "gAMA");
 
    if (png_ptr == NULL || info_ptr == NULL)
       return;
 
    png_colorspace_set_gamma(png_ptr, &info_ptr->colorspace, file_gamma);
    png_colorspace_sync_info(png_ptr, info_ptr);
 }

PNG_IMPEXP png_uint_32() png_get_hIST	(	png_const_structrp	png_ptr,
		png_inforp	info_ptr,
		png_uint_16p *	hist
	)

 {
    png_debug1(1, "in %s retrieval function", "hIST");
 
    if (png_ptr != NULL && info_ptr != NULL &&
        (info_ptr->valid & PNG_INFO_hIST) != 0 && hist != NULL)
    {
       *hist = info_ptr->hist;
       return (PNG_INFO_hIST);
    }
 
    return (0);
 }

PNG_IMPEXP void() png_set_hIST	(	png_const_structrp	png_ptr,
		png_inforp	info_ptr,
		png_const_uint_16p	hist
	)

 {
    int i;
 
    png_debug1(1, "in %s storage function", "hIST");
 
    if (png_ptr == NULL || info_ptr == NULL)
       return;
 
    if (info_ptr->num_palette == 0 || info_ptr->num_palette
        > PNG_MAX_PALETTE_LENGTH)
    {
       png_warning(png_ptr,
           "Invalid palette size, hIST allocation skipped");
 
       return;
    }
 
    png_free_data(png_ptr, info_ptr, PNG_FREE_HIST, 0);
 
    /* Changed from info->num_palette to PNG_MAX_PALETTE_LENGTH in
     * version 1.2.1
     */
    info_ptr->hist = png_voidcast(png_uint_16p, png_malloc_warn(png_ptr,
        PNG_MAX_PALETTE_LENGTH * (sizeof (png_uint_16))));
 
    if (info_ptr->hist == NULL)
    {
       png_warning(png_ptr, "Insufficient memory for hIST chunk data");
       return;
    }
 
    info_ptr->free_me |= PNG_FREE_HIST;
 
    for (i = 0; i < info_ptr->num_palette; i++)
       info_ptr->hist[i] = hist[i];
 
    info_ptr->valid |= PNG_INFO_hIST;
 }

PNG_IMPEXP png_uint_32() png_get_IHDR	(	png_const_structrp	png_ptr,
		png_const_inforp	info_ptr,
		png_uint_32 *	width,
		png_uint_32 *	height,
		int *	bit_depth,
		int *	color_type,
		int *	interlace_method,
		int *	compression_method,
		int *	filter_method
	)

 {
    png_debug1(1, "in %s retrieval function", "IHDR");
 
    if (png_ptr == NULL || info_ptr == NULL || width == NULL ||
        height == NULL || bit_depth == NULL || color_type == NULL)
       return (0);
 
    *width = info_ptr->width;
    *height = info_ptr->height;
    *bit_depth = info_ptr->bit_depth;
    *color_type = info_ptr->color_type;
 
    if (compression_type != NULL)
       *compression_type = info_ptr->compression_type;
 
    if (filter_type != NULL)
       *filter_type = info_ptr->filter_type;
 
    if (interlace_type != NULL)
       *interlace_type = info_ptr->interlace_type;
 
    /* This is redundant if we can be sure that the info_ptr values were all
     * assigned in png_set_IHDR().  We do the check anyhow in case an
     * application has ignored our advice not to mess with the members
     * of info_ptr directly.
     */
    png_check_IHDR(png_ptr, info_ptr->width, info_ptr->height,
        info_ptr->bit_depth, info_ptr->color_type, info_ptr->interlace_type,
        info_ptr->compression_type, info_ptr->filter_type);
 
    return (1);
 }

PNG_IMPEXP void() png_set_IHDR	(	png_const_structrp	png_ptr,
		png_inforp	info_ptr,
		png_uint_32	width,
		png_uint_32	height,
		int	bit_depth,
		int	color_type,
		int	interlace_method,
		int	compression_method,
		int	filter_method
	)

 {
    png_debug1(1, "in %s storage function", "IHDR");
 
    if (png_ptr == NULL || info_ptr == NULL)
       return;
 
    info_ptr->width = width;
    info_ptr->height = height;
    info_ptr->bit_depth = (png_byte)bit_depth;
    info_ptr->color_type = (png_byte)color_type;
    info_ptr->compression_type = (png_byte)compression_type;
    info_ptr->filter_type = (png_byte)filter_type;
    info_ptr->interlace_type = (png_byte)interlace_type;
 
    png_check_IHDR (png_ptr, info_ptr->width, info_ptr->height,
        info_ptr->bit_depth, info_ptr->color_type, info_ptr->interlace_type,
        info_ptr->compression_type, info_ptr->filter_type);
 
    if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
       info_ptr->channels = 1;
 
    else if ((info_ptr->color_type & PNG_COLOR_MASK_COLOR) != 0)
       info_ptr->channels = 3;
 
    else
       info_ptr->channels = 1;
 
    if ((info_ptr->color_type & PNG_COLOR_MASK_ALPHA) != 0)
       info_ptr->channels++;
 
    info_ptr->pixel_depth = (png_byte)(info_ptr->channels * info_ptr->bit_depth);
 
    info_ptr->rowbytes = PNG_ROWBYTES(info_ptr->pixel_depth, width);
 }

PNG_IMPEXP png_uint_32() png_get_oFFs	(	png_const_structrp	png_ptr,
		png_const_inforp	info_ptr,
		png_int_32 *	offset_x,
		png_int_32 *	offset_y,
		int *	unit_type
	)

 {
    png_debug1(1, "in %s retrieval function", "oFFs");
 
    if (png_ptr != NULL && info_ptr != NULL &&
        (info_ptr->valid & PNG_INFO_oFFs) != 0 &&
        offset_x != NULL && offset_y != NULL && unit_type != NULL)
    {
       *offset_x = info_ptr->x_offset;
       *offset_y = info_ptr->y_offset;
       *unit_type = (int)info_ptr->offset_unit_type;
       return (PNG_INFO_oFFs);
    }
 
    return (0);
 }

PNG_IMPEXP void() png_set_oFFs	(	png_const_structrp	png_ptr,
		png_inforp	info_ptr,
		png_int_32	offset_x,
		png_int_32	offset_y,
		int	unit_type
	)

 {
    png_debug1(1, "in %s storage function", "oFFs");
 
    if (png_ptr == NULL || info_ptr == NULL)
       return;
 
    info_ptr->x_offset = offset_x;
    info_ptr->y_offset = offset_y;
    info_ptr->offset_unit_type = (png_byte)unit_type;
    info_ptr->valid |= PNG_INFO_oFFs;
 }

PNG_IMPEXP png_uint_32() png_get_pCAL	(	png_const_structrp	png_ptr,
		png_inforp	info_ptr,
		png_charp *	purpose,
		png_int_32 *	X0,
		png_int_32 *	X1,
		int *	type,
		int *	nparams,
		png_charp *	units,
		png_charpp *	params
	)

 {
    png_debug1(1, "in %s retrieval function", "pCAL");
 
    if (png_ptr != NULL && info_ptr != NULL &&
        (info_ptr->valid & PNG_INFO_pCAL) != 0 &&
        purpose != NULL && X0 != NULL && X1 != NULL && type != NULL &&
        nparams != NULL && units != NULL && params != NULL)
    {
       *purpose = info_ptr->pcal_purpose;
       *X0 = info_ptr->pcal_X0;
       *X1 = info_ptr->pcal_X1;
       *type = (int)info_ptr->pcal_type;
       *nparams = (int)info_ptr->pcal_nparams;
       *units = info_ptr->pcal_units;
       *params = info_ptr->pcal_params;
       return (PNG_INFO_pCAL);
    }
 
    return (0);
 }

PNG_IMPEXP void() png_set_pCAL	(	png_const_structrp	png_ptr,
		png_inforp	info_ptr,
		png_const_charp	purpose,
		png_int_32	X0,
		png_int_32	X1,
		int	type,
		int	nparams,
		png_const_charp	units,
		png_charpp	params
	)

 {
    png_size_t length;
    int i;
 
    png_debug1(1, "in %s storage function", "pCAL");
 
    if (png_ptr == NULL || info_ptr == NULL || purpose == NULL || units == NULL
       || (nparams > 0 && params == NULL))
       return;
 
    length = strlen(purpose) + 1;
    png_debug1(3, "allocating purpose for info (%lu bytes)",
        (unsigned long)length);
 
    /* TODO: validate format of calibration name and unit name */
 
    /* Check that the type matches the specification. */
    if (type < 0 || type > 3)
       png_error(png_ptr, "Invalid pCAL equation type");
 
    if (nparams < 0 || nparams > 255)
       png_error(png_ptr, "Invalid pCAL parameter count");
 
    /* Validate params[nparams] */
    for (i=0; i<nparams; ++i)
    {
       if (params[i] == NULL ||
           !png_check_fp_string(params[i], strlen(params[i])))
          png_error(png_ptr, "Invalid format for pCAL parameter");
    }
 
    info_ptr->pcal_purpose = png_voidcast(png_charp,
        png_malloc_warn(png_ptr, length));
 
    if (info_ptr->pcal_purpose == NULL)
    {
       png_warning(png_ptr, "Insufficient memory for pCAL purpose");
       return;
    }
 
    memcpy(info_ptr->pcal_purpose, purpose, length);
 
    png_debug(3, "storing X0, X1, type, and nparams in info");
    info_ptr->pcal_X0 = X0;
    info_ptr->pcal_X1 = X1;
    info_ptr->pcal_type = (png_byte)type;
    info_ptr->pcal_nparams = (png_byte)nparams;
 
    length = strlen(units) + 1;
    png_debug1(3, "allocating units for info (%lu bytes)",
      (unsigned long)length);
 
    info_ptr->pcal_units = png_voidcast(png_charp,
       png_malloc_warn(png_ptr, length));
 
    if (info_ptr->pcal_units == NULL)
    {
       png_warning(png_ptr, "Insufficient memory for pCAL units");
       return;
    }
 
    memcpy(info_ptr->pcal_units, units, length);
 
    info_ptr->pcal_params = png_voidcast(png_charpp, png_malloc_warn(png_ptr,
        (png_size_t)((nparams + 1) * (sizeof (png_charp)))));
 
    if (info_ptr->pcal_params == NULL)
    {
       png_warning(png_ptr, "Insufficient memory for pCAL params");
       return;
    }
 
    memset(info_ptr->pcal_params, 0, (nparams + 1) * (sizeof (png_charp)));
 
    for (i = 0; i < nparams; i++)
    {
       length = strlen(params[i]) + 1;
       png_debug2(3, "allocating parameter %d for info (%lu bytes)", i,
           (unsigned long)length);
 
       info_ptr->pcal_params[i] = (png_charp)png_malloc_warn(png_ptr, length);
 
       if (info_ptr->pcal_params[i] == NULL)
       {
          png_warning(png_ptr, "Insufficient memory for pCAL parameter");
          return;
       }
 
       memcpy(info_ptr->pcal_params[i], params[i], length);
    }
 
    info_ptr->valid |= PNG_INFO_pCAL;
    info_ptr->free_me |= PNG_FREE_PCAL;
 }

PNG_IMPEXP png_uint_32() png_get_pHYs	(	png_const_structrp	png_ptr,
		png_const_inforp	info_ptr,
		png_uint_32 *	res_x,
		png_uint_32 *	res_y,
		int *	unit_type
	)

 {
    png_uint_32 retval = 0;
 
    png_debug1(1, "in %s retrieval function", "pHYs");
 
    if (png_ptr != NULL && info_ptr != NULL &&
        (info_ptr->valid & PNG_INFO_pHYs) != 0)
    {
       if (res_x != NULL)
       {
          *res_x = info_ptr->x_pixels_per_unit;
          retval |= PNG_INFO_pHYs;
       }
 
       if (res_y != NULL)
       {
          *res_y = info_ptr->y_pixels_per_unit;
          retval |= PNG_INFO_pHYs;
       }
 
       if (unit_type != NULL)
       {
          *unit_type = (int)info_ptr->phys_unit_type;
          retval |= PNG_INFO_pHYs;
       }
    }
 
    return (retval);
 }

PNG_IMPEXP void() png_set_pHYs	(	png_const_structrp	png_ptr,
		png_inforp	info_ptr,
		png_uint_32	res_x,
		png_uint_32	res_y,
		int	unit_type
	)

 {
    png_debug1(1, "in %s storage function", "pHYs");
 
    if (png_ptr == NULL || info_ptr == NULL)
       return;
 
    info_ptr->x_pixels_per_unit = res_x;
    info_ptr->y_pixels_per_unit = res_y;
    info_ptr->phys_unit_type = (png_byte)unit_type;
    info_ptr->valid |= PNG_INFO_pHYs;
 }

PNG_IMPEXP png_uint_32() png_get_PLTE	(	png_const_structrp	png_ptr,
		png_inforp	info_ptr,
		png_colorp *	palette,
		int *	num_palette
	)

 {
    png_debug1(1, "in %s retrieval function", "PLTE");
 
    if (png_ptr != NULL && info_ptr != NULL &&
        (info_ptr->valid & PNG_INFO_PLTE) != 0 && palette != NULL)
    {
       *palette = info_ptr->palette;
       *num_palette = info_ptr->num_palette;
       png_debug1(3, "num_palette = %d", *num_palette);
       return (PNG_INFO_PLTE);
    }
 
    return (0);
 }

PNG_IMPEXP void() png_set_PLTE	(	png_structrp	png_ptr,
		png_inforp	info_ptr,
		png_const_colorp	palette,
		int	num_palette
	)

 {
 
    png_debug1(1, "in %s storage function", "PLTE");
 
    if (png_ptr == NULL || info_ptr == NULL)
       return;
 
    if (num_palette < 0 || num_palette > PNG_MAX_PALETTE_LENGTH)
    {
       if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
          png_error(png_ptr, "Invalid palette length");
 
       else
       {
          png_warning(png_ptr, "Invalid palette length");
          return;
       }
    }
 
    if ((num_palette > 0 && palette == NULL) ||
       (num_palette == 0
 #        ifdef PNG_MNG_FEATURES_SUPPORTED
             && (png_ptr->mng_features_permitted & PNG_FLAG_MNG_EMPTY_PLTE) == 0
 #        endif
       ))
    {
       png_error(png_ptr, "Invalid palette");
       return;
    }
 
    /* It may not actually be necessary to set png_ptr->palette here;
     * we do it for backward compatibility with the way the png_handle_tRNS
     * function used to do the allocation.
     *
     * 1.6.0: the above statement appears to be incorrect; something has to set
     * the palette inside png_struct on read.
     */
    png_free_data(png_ptr, info_ptr, PNG_FREE_PLTE, 0);
 
    /* Changed in libpng-1.2.1 to allocate PNG_MAX_PALETTE_LENGTH instead
     * of num_palette entries, in case of an invalid PNG file that has
     * too-large sample values.
     */
    png_ptr->palette = png_voidcast(png_colorp, png_calloc(png_ptr,
        PNG_MAX_PALETTE_LENGTH * (sizeof (png_color))));
 
    if (num_palette > 0)
       memcpy(png_ptr->palette, palette, num_palette * (sizeof (png_color)));
    info_ptr->palette = png_ptr->palette;
    info_ptr->num_palette = png_ptr->num_palette = (png_uint_16)num_palette;
 
    info_ptr->free_me |= PNG_FREE_PLTE;
 
    info_ptr->valid |= PNG_INFO_PLTE;
 }

PNG_IMPEXP png_uint_32() png_get_sBIT	(	png_const_structrp	png_ptr,
		png_inforp	info_ptr,
		png_color_8p *	sig_bit
	)

 {
    png_debug1(1, "in %s retrieval function", "sBIT");
 
    if (png_ptr != NULL && info_ptr != NULL &&
        (info_ptr->valid & PNG_INFO_sBIT) != 0 && sig_bit != NULL)
    {
       *sig_bit = &(info_ptr->sig_bit);
       return (PNG_INFO_sBIT);
    }
 
    return (0);
 }

PNG_IMPEXP void() png_set_sBIT	(	png_const_structrp	png_ptr,
		png_inforp	info_ptr,
		png_const_color_8p	sig_bit
	)

 {
    png_debug1(1, "in %s storage function", "sBIT");
 
    if (png_ptr == NULL || info_ptr == NULL || sig_bit == NULL)
       return;
 
    info_ptr->sig_bit = *sig_bit;
    info_ptr->valid |= PNG_INFO_sBIT;
 }

PNG_IMPEXP png_uint_32() png_get_sRGB	(	png_const_structrp	png_ptr,
		png_const_inforp	info_ptr,
		int *	file_srgb_intent
	)

 {
    png_debug1(1, "in %s retrieval function", "sRGB");
 
    if (png_ptr != NULL && info_ptr != NULL &&
       (info_ptr->valid & PNG_INFO_sRGB) != 0 && file_srgb_intent != NULL)
    {
       *file_srgb_intent = info_ptr->colorspace.rendering_intent;
       return (PNG_INFO_sRGB);
    }
 
    return (0);
 }

PNG_IMPEXP void() png_set_sRGB	(	png_const_structrp	png_ptr,
		png_inforp	info_ptr,
		int	srgb_intent
	)

 {
    png_debug1(1, "in %s storage function", "sRGB");
 
    if (png_ptr == NULL || info_ptr == NULL)
       return;
 
    (void)png_colorspace_set_sRGB(png_ptr, &info_ptr->colorspace, srgb_intent);
    png_colorspace_sync_info(png_ptr, info_ptr);
 }

PNG_IMPEXP void() png_set_sRGB_gAMA_and_cHRM	(	png_const_structrp	png_ptr,
		png_inforp	info_ptr,
		int	srgb_intent
	)

 {
    png_debug1(1, "in %s storage function", "sRGB_gAMA_and_cHRM");
 
    if (png_ptr == NULL || info_ptr == NULL)
       return;
 
    if (png_colorspace_set_sRGB(png_ptr, &info_ptr->colorspace,
        srgb_intent) != 0)
    {
       /* This causes the gAMA and cHRM to be written too */
       info_ptr->colorspace.flags |=
          PNG_COLORSPACE_FROM_gAMA|PNG_COLORSPACE_FROM_cHRM;
    }
 
    png_colorspace_sync_info(png_ptr, info_ptr);
 }

PNG_IMPEXP png_uint_32() png_get_iCCP	(	png_const_structrp	png_ptr,
		png_inforp	info_ptr,
		png_charpp	name,
		int *	compression_type,
		png_bytepp	profile,
		png_uint_32 *	proflen
	)

 {
    png_debug1(1, "in %s retrieval function", "iCCP");
 
    if (png_ptr != NULL && info_ptr != NULL &&
        (info_ptr->valid & PNG_INFO_iCCP) != 0 &&
        name != NULL && compression_type != NULL && profile != NULL &&
            proflen != NULL)
    {
       *name = info_ptr->iccp_name;
       *profile = info_ptr->iccp_profile;
       *proflen = png_get_uint_32(info_ptr->iccp_profile);
       /* This is somewhat irrelevant since the profile data returned has
        * actually been uncompressed.
        */
       *compression_type = PNG_COMPRESSION_TYPE_BASE;
       return (PNG_INFO_iCCP);
    }
 
    return (0);
 }

PNG_IMPEXP void() png_set_iCCP	(	png_const_structrp	png_ptr,
		png_inforp	info_ptr,
		png_const_charp	name,
		int	compression_type,
		png_const_bytep	profile,
		png_uint_32	proflen
	)

 {
    png_charp new_iccp_name;
    png_bytep new_iccp_profile;
    png_size_t length;
 
    png_debug1(1, "in %s storage function", "iCCP");
 
    if (png_ptr == NULL || info_ptr == NULL || name == NULL || profile == NULL)
       return;
 
    if (compression_type != PNG_COMPRESSION_TYPE_BASE)
       png_app_error(png_ptr, "Invalid iCCP compression method");
 
    /* Set the colorspace first because this validates the profile; do not
     * override previously set app cHRM or gAMA here (because likely as not the
     * application knows better than libpng what the correct values are.)  Pass
     * the info_ptr color_type field to png_colorspace_set_ICC because in the
     * write case it has not yet been stored in png_ptr.
     */
    {
       int result = png_colorspace_set_ICC(png_ptr, &info_ptr->colorspace, name,
          proflen, profile, info_ptr->color_type);
 
       png_colorspace_sync_info(png_ptr, info_ptr);
 
       /* Don't do any of the copying if the profile was bad, or inconsistent. */
       if (result == 0)
          return;
 
       /* But do write the gAMA and cHRM chunks from the profile. */
       info_ptr->colorspace.flags |=
          PNG_COLORSPACE_FROM_gAMA|PNG_COLORSPACE_FROM_cHRM;
    }
 
    length = strlen(name)+1;
    new_iccp_name = png_voidcast(png_charp, png_malloc_warn(png_ptr, length));
 
    if (new_iccp_name == NULL)
    {
       png_benign_error(png_ptr, "Insufficient memory to process iCCP chunk");
       return;
    }
 
    memcpy(new_iccp_name, name, length);
    new_iccp_profile = png_voidcast(png_bytep,
       png_malloc_warn(png_ptr, proflen));
 
    if (new_iccp_profile == NULL)
    {
       png_free(png_ptr, new_iccp_name);
       new_iccp_name = NULL;
       png_benign_error(png_ptr,
           "Insufficient memory to process iCCP profile");
       return;
    }
 
    memcpy(new_iccp_profile, profile, proflen);
 
    png_free_data(png_ptr, info_ptr, PNG_FREE_ICCP, 0);
 
    info_ptr->iccp_proflen = proflen;
    info_ptr->iccp_name = new_iccp_name;
    info_ptr->iccp_profile = new_iccp_profile;
    info_ptr->free_me |= PNG_FREE_ICCP;
    info_ptr->valid |= PNG_INFO_iCCP;
 }

PNG_IMPEXP int() png_get_sPLT	(	png_const_structrp	png_ptr,
		png_inforp	info_ptr,
		png_sPLT_tpp	entries
	)

 {
    if (png_ptr != NULL && info_ptr != NULL && spalettes != NULL)
    {
       *spalettes = info_ptr->splt_palettes;
       return info_ptr->splt_palettes_num;
    }
 
    return (0);
 }

PNG_IMPEXP void() png_set_sPLT	(	png_const_structrp	png_ptr,
		png_inforp	info_ptr,
		png_const_sPLT_tp	entries,
		int	nentries
	)

 {
    png_sPLT_tp np;
 
    if (png_ptr == NULL || info_ptr == NULL || nentries <= 0 || entries == NULL)
       return;
 
    /* Use the internal realloc function, which checks for all the possible
     * overflows.  Notice that the parameters are (int) and (size_t)
     */
    np = png_voidcast(png_sPLT_tp,png_realloc_array(png_ptr,
       info_ptr->splt_palettes, info_ptr->splt_palettes_num, nentries,
       sizeof *np));
 
    if (np == NULL)
    {
       /* Out of memory or too many chunks */
       png_chunk_report(png_ptr, "too many sPLT chunks", PNG_CHUNK_WRITE_ERROR);
       return;
    }
 
    png_free(png_ptr, info_ptr->splt_palettes);
    info_ptr->splt_palettes = np;
    info_ptr->free_me |= PNG_FREE_SPLT;
 
    np += info_ptr->splt_palettes_num;
 
    do
    {
       png_size_t length;
 
       /* Skip invalid input entries */
       if (entries->name == NULL || entries->entries == NULL)
       {
          /* png_handle_sPLT doesn't do this, so this is an app error */
          png_app_error(png_ptr, "png_set_sPLT: invalid sPLT");
          /* Just skip the invalid entry */
          continue;
       }
 
       np->depth = entries->depth;
 
       /* In the event of out-of-memory just return - there's no point keeping
        * on trying to add sPLT chunks.
        */
       length = strlen(entries->name) + 1;
       np->name = png_voidcast(png_charp, png_malloc_base(png_ptr, length));
 
       if (np->name == NULL)
          break;
 
       memcpy(np->name, entries->name, length);
 
       /* IMPORTANT: we have memory now that won't get freed if something else
        * goes wrong; this code must free it.  png_malloc_array produces no
        * warnings; use a png_chunk_report (below) if there is an error.
        */
       np->entries = png_voidcast(png_sPLT_entryp, png_malloc_array(png_ptr,
           entries->nentries, sizeof (png_sPLT_entry)));
 
       if (np->entries == NULL)
       {
          png_free(png_ptr, np->name);
          np->name = NULL;
          break;
       }
 
       np->nentries = entries->nentries;
       /* This multiply can't overflow because png_malloc_array has already
        * checked it when doing the allocation.
        */
       memcpy(np->entries, entries->entries,
          entries->nentries * sizeof (png_sPLT_entry));
 
       /* Note that 'continue' skips the advance of the out pointer and out
        * count, so an invalid entry is not added.
        */
       info_ptr->valid |= PNG_INFO_sPLT;
       ++(info_ptr->splt_palettes_num);
       ++np;
    }
    while (++entries, --nentries);
 
    if (nentries > 0)
       png_chunk_report(png_ptr, "sPLT out of memory", PNG_CHUNK_WRITE_ERROR);
 }

PNG_IMPEXP int() png_get_text	(	png_const_structrp	png_ptr,
		png_inforp	info_ptr,
		png_textp *	text_ptr,
		int *	num_text
	)

 {
    if (png_ptr != NULL && info_ptr != NULL && info_ptr->num_text > 0)
    {
       png_debug1(1, "in 0x%lx retrieval function",
          (unsigned long)png_ptr->chunk_name);
 
       if (text_ptr != NULL)
          *text_ptr = info_ptr->text;
 
       if (num_text != NULL)
          *num_text = info_ptr->num_text;
 
       return info_ptr->num_text;
    }
 
    if (num_text != NULL)
       *num_text = 0;
 
    return(0);
 }

PNG_IMPEXP void() png_set_text	(	png_const_structrp	png_ptr,
		png_inforp	info_ptr,
		png_const_textp	text_ptr,
		int	num_text
	)

 {
    int ret;
    ret = png_set_text_2(png_ptr, info_ptr, text_ptr, num_text);
 
    if (ret != 0)
       png_error(png_ptr, "Insufficient memory to store text");
 }

PNG_IMPEXP png_uint_32() png_get_tIME	(	png_const_structrp	png_ptr,
		png_inforp	info_ptr,
		png_timep *	mod_time
	)

 {
    png_debug1(1, "in %s retrieval function", "tIME");
 
    if (png_ptr != NULL && info_ptr != NULL &&
        (info_ptr->valid & PNG_INFO_tIME) != 0 && mod_time != NULL)
    {
       *mod_time = &(info_ptr->mod_time);
       return (PNG_INFO_tIME);
    }
 
    return (0);
 }

PNG_IMPEXP void() png_set_tIME	(	png_const_structrp	png_ptr,
		png_inforp	info_ptr,
		png_const_timep	mod_time
	)

 {
    png_debug1(1, "in %s storage function", "tIME");
 
    if (png_ptr == NULL || info_ptr == NULL || mod_time == NULL ||
        (png_ptr->mode & PNG_WROTE_tIME) != 0)
       return;
 
    if (mod_time->month == 0   || mod_time->month > 12  ||
        mod_time->day   == 0   || mod_time->day   > 31  ||
        mod_time->hour  > 23   || mod_time->minute > 59 ||
        mod_time->second > 60)
    {
       png_warning(png_ptr, "Ignoring invalid time value");
       return;
    }
 
    info_ptr->mod_time = *mod_time;
    info_ptr->valid |= PNG_INFO_tIME;
 }

PNG_IMPEXP png_uint_32() png_get_tRNS	(	png_const_structrp	png_ptr,
		png_inforp	info_ptr,
		png_bytep *	trans_alpha,
		int *	num_trans,
		png_color_16p *	trans_color
	)

 {
    png_uint_32 retval = 0;
    if (png_ptr != NULL && info_ptr != NULL &&
        (info_ptr->valid & PNG_INFO_tRNS) != 0)
    {
       png_debug1(1, "in %s retrieval function", "tRNS");
 
       if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
       {
          if (trans_alpha != NULL)
          {
             *trans_alpha = info_ptr->trans_alpha;
             retval |= PNG_INFO_tRNS;
          }
 
          if (trans_color != NULL)
             *trans_color = &(info_ptr->trans_color);
       }
 
       else /* if (info_ptr->color_type != PNG_COLOR_TYPE_PALETTE) */
       {
          if (trans_color != NULL)
          {
             *trans_color = &(info_ptr->trans_color);
             retval |= PNG_INFO_tRNS;
          }
 
          if (trans_alpha != NULL)
             *trans_alpha = NULL;
       }
 
       if (num_trans != NULL)
       {
          *num_trans = info_ptr->num_trans;
          retval |= PNG_INFO_tRNS;
       }
    }
 
    return (retval);
 }

PNG_IMPEXP void() png_set_tRNS	(	png_structrp	png_ptr,
		png_inforp	info_ptr,
		png_const_bytep	trans_alpha,
		int	num_trans,
		png_const_color_16p	trans_color
	)

 {
    png_debug1(1, "in %s storage function", "tRNS");
 
    if (png_ptr == NULL || info_ptr == NULL)
       return;
 
    if (trans_alpha != NULL)
    {
        /* It may not actually be necessary to set png_ptr->trans_alpha here;
         * we do it for backward compatibility with the way the png_handle_tRNS
         * function used to do the allocation.
         *
         * 1.6.0: The above statement is incorrect; png_handle_tRNS effectively
         * relies on png_set_tRNS storing the information in png_struct
         * (otherwise it won't be there for the code in pngrtran.c).
         */
 
        png_free_data(png_ptr, info_ptr, PNG_FREE_TRNS, 0);
 
        /* Changed from num_trans to PNG_MAX_PALETTE_LENGTH in version 1.2.1 */
        png_ptr->trans_alpha = info_ptr->trans_alpha = png_voidcast(png_bytep,
          png_malloc(png_ptr, PNG_MAX_PALETTE_LENGTH));
 
        if (num_trans > 0 && num_trans <= PNG_MAX_PALETTE_LENGTH)
           memcpy(info_ptr->trans_alpha, trans_alpha, (png_size_t)num_trans);
    }
 
    if (trans_color != NULL)
    {
       int sample_max = (1 << info_ptr->bit_depth);
 
       if ((info_ptr->color_type == PNG_COLOR_TYPE_GRAY &&
           trans_color->gray > sample_max) ||
           (info_ptr->color_type == PNG_COLOR_TYPE_RGB &&
           (trans_color->red > sample_max ||
           trans_color->green > sample_max ||
           trans_color->blue > sample_max)))
          png_warning(png_ptr,
             "tRNS chunk has out-of-range samples for bit_depth");
 
       info_ptr->trans_color = *trans_color;
 
       if (num_trans == 0)
          num_trans = 1;
    }
 
    info_ptr->num_trans = (png_uint_16)num_trans;
 
    if (num_trans != 0)
    {
       info_ptr->valid |= PNG_INFO_tRNS;
       info_ptr->free_me |= PNG_FREE_TRNS;
    }
 }

PNG_IMPEXP png_uint_32() png_get_sCAL	(	png_const_structrp	png_ptr,
		png_const_inforp	info_ptr,
		int *	unit,
		double *	width,
		double *	height
	)

 {
    if (png_ptr != NULL && info_ptr != NULL &&
        (info_ptr->valid & PNG_INFO_sCAL) != 0)
    {
       *unit = info_ptr->scal_unit;
       *width = atof(info_ptr->scal_s_width);
       *height = atof(info_ptr->scal_s_height);
       return (PNG_INFO_sCAL);
    }
 
    return(0);
 }

PNG_IMPEXP png_uint_32() png_get_sCAL_fixed	(	png_const_structrp	png_ptr,
		png_const_inforp	info_ptr,
		int *	unit,
		png_fixed_point *	width,
		png_fixed_point *	height
	)

 {
    if (png_ptr != NULL && info_ptr != NULL &&
        (info_ptr->valid & PNG_INFO_sCAL) != 0)
    {
       *unit = info_ptr->scal_unit;
       /*TODO: make this work without FP support; the API is currently eliminated
        * if neither floating point APIs nor internal floating point arithmetic
        * are enabled.
        */
       *width = png_fixed(png_ptr, atof(info_ptr->scal_s_width), "sCAL width");
       *height = png_fixed(png_ptr, atof(info_ptr->scal_s_height),
          "sCAL height");
       return (PNG_INFO_sCAL);
    }
 
    return(0);
 }

PNG_IMPEXP png_uint_32() png_get_sCAL_s	(	png_const_structrp	png_ptr,
		png_const_inforp	info_ptr,
		int *	unit,
		png_charpp	swidth,
		png_charpp	sheight
	)

 {
    if (png_ptr != NULL && info_ptr != NULL &&
        (info_ptr->valid & PNG_INFO_sCAL) != 0)
    {
       *unit = info_ptr->scal_unit;
       *width = info_ptr->scal_s_width;
       *height = info_ptr->scal_s_height;
       return (PNG_INFO_sCAL);
    }
 
    return(0);
 }

PNG_IMPEXP void() png_set_sCAL	(	png_const_structrp	png_ptr,
		png_inforp	info_ptr,
		int	unit,
		double	width,
		double	height
	)

 {
    png_debug1(1, "in %s storage function", "sCAL");
 
    /* Check the arguments. */
    if (width <= 0)
       png_warning(png_ptr, "Invalid sCAL width ignored");
 
    else if (height <= 0)
       png_warning(png_ptr, "Invalid sCAL height ignored");
 
    else
    {
       /* Convert 'width' and 'height' to ASCII. */
       char swidth[PNG_sCAL_MAX_DIGITS+1];
       char sheight[PNG_sCAL_MAX_DIGITS+1];
 
       png_ascii_from_fp(png_ptr, swidth, (sizeof swidth), width,
          PNG_sCAL_PRECISION);
       png_ascii_from_fp(png_ptr, sheight, (sizeof sheight), height,
          PNG_sCAL_PRECISION);
 
       png_set_sCAL_s(png_ptr, info_ptr, unit, swidth, sheight);
    }
 }

PNG_IMPEXP void() png_set_sCAL_fixed	(	png_const_structrp	png_ptr,
		png_inforp	info_ptr,
		int	unit,
		png_fixed_point	width,
		png_fixed_point	height
	)

 {
    png_debug1(1, "in %s storage function", "sCAL");
 
    /* Check the arguments. */
    if (width <= 0)
       png_warning(png_ptr, "Invalid sCAL width ignored");
 
    else if (height <= 0)
       png_warning(png_ptr, "Invalid sCAL height ignored");
 
    else
    {
       /* Convert 'width' and 'height' to ASCII. */
       char swidth[PNG_sCAL_MAX_DIGITS+1];
       char sheight[PNG_sCAL_MAX_DIGITS+1];
 
       png_ascii_from_fixed(png_ptr, swidth, (sizeof swidth), width);
       png_ascii_from_fixed(png_ptr, sheight, (sizeof sheight), height);
 
       png_set_sCAL_s(png_ptr, info_ptr, unit, swidth, sheight);
    }
 }

PNG_IMPEXP void() png_set_sCAL_s	(	png_const_structrp	png_ptr,
		png_inforp	info_ptr,
		int	unit,
		png_const_charp	swidth,
		png_const_charp	sheight
	)

 {
    png_size_t lengthw = 0, lengthh = 0;
 
    png_debug1(1, "in %s storage function", "sCAL");
 
    if (png_ptr == NULL || info_ptr == NULL)
       return;
 
    /* Double check the unit (should never get here with an invalid
     * unit unless this is an API call.)
     */
    if (unit != 1 && unit != 2)
       png_error(png_ptr, "Invalid sCAL unit");
 
    if (swidth == NULL || (lengthw = strlen(swidth)) == 0 ||
        swidth[0] == 45 /* '-' */ || !png_check_fp_string(swidth, lengthw))
       png_error(png_ptr, "Invalid sCAL width");
 
    if (sheight == NULL || (lengthh = strlen(sheight)) == 0 ||
        sheight[0] == 45 /* '-' */ || !png_check_fp_string(sheight, lengthh))
       png_error(png_ptr, "Invalid sCAL height");
 
    info_ptr->scal_unit = (png_byte)unit;
 
    ++lengthw;
 
    png_debug1(3, "allocating unit for info (%u bytes)", (unsigned int)lengthw);
 
    info_ptr->scal_s_width = png_voidcast(png_charp,
       png_malloc_warn(png_ptr, lengthw));
 
    if (info_ptr->scal_s_width == NULL)
    {
       png_warning(png_ptr, "Memory allocation failed while processing sCAL");
       return;
    }
 
    memcpy(info_ptr->scal_s_width, swidth, lengthw);
 
    ++lengthh;
 
    png_debug1(3, "allocating unit for info (%u bytes)", (unsigned int)lengthh);
 
    info_ptr->scal_s_height = png_voidcast(png_charp,
       png_malloc_warn(png_ptr, lengthh));
 
    if (info_ptr->scal_s_height == NULL)
    {
       png_free (png_ptr, info_ptr->scal_s_width);
       info_ptr->scal_s_width = NULL;
 
       png_warning(png_ptr, "Memory allocation failed while processing sCAL");
       return;
    }
 
    memcpy(info_ptr->scal_s_height, sheight, lengthh);
 
    info_ptr->valid |= PNG_INFO_sCAL;
    info_ptr->free_me |= PNG_FREE_SCAL;
 }

PNG_IMPEXP void() png_set_keep_unknown_chunks	(	png_structrp	png_ptr,
		int	keep,
		png_const_bytep	chunk_list,
		int	num_chunks
	)

 {
    png_bytep new_list;
    unsigned int num_chunks, old_num_chunks;
 
    if (png_ptr == NULL)
       return;
 
    if (keep < 0 || keep >= PNG_HANDLE_CHUNK_LAST)
    {
       png_app_error(png_ptr, "png_set_keep_unknown_chunks: invalid keep");
       return;
    }
 
    if (num_chunks_in <= 0)
    {
       png_ptr->unknown_default = keep;
 
       /* '0' means just set the flags, so stop here */
       if (num_chunks_in == 0)
         return;
    }
 
    if (num_chunks_in < 0)
    {
       /* Ignore all unknown chunks and all chunks recognized by
        * libpng except for IHDR, PLTE, tRNS, IDAT, and IEND
        */
       static PNG_CONST png_byte chunks_to_ignore[] = {
          98,  75,  71,  68, '\0',  /* bKGD */
          99,  72,  82,  77, '\0',  /* cHRM */
         103,  65,  77,  65, '\0',  /* gAMA */
         104,  73,  83,  84, '\0',  /* hIST */
         105,  67,  67,  80, '\0',  /* iCCP */
         105,  84,  88, 116, '\0',  /* iTXt */
         111,  70,  70, 115, '\0',  /* oFFs */
         112,  67,  65,  76, '\0',  /* pCAL */
         112,  72,  89, 115, '\0',  /* pHYs */
         115,  66,  73,  84, '\0',  /* sBIT */
         115,  67,  65,  76, '\0',  /* sCAL */
         115,  80,  76,  84, '\0',  /* sPLT */
         115,  84,  69,  82, '\0',  /* sTER */
         115,  82,  71,  66, '\0',  /* sRGB */
         116,  69,  88, 116, '\0',  /* tEXt */
         116,  73,  77,  69, '\0',  /* tIME */
         122,  84,  88, 116, '\0'   /* zTXt */
       };
 
       chunk_list = chunks_to_ignore;
       num_chunks = (unsigned int)/*SAFE*/(sizeof chunks_to_ignore)/5U;
    }
 
    else /* num_chunks_in > 0 */
    {
       if (chunk_list == NULL)
       {
          /* Prior to 1.6.0 this was silently ignored, now it is an app_error
           * which can be switched off.
           */
          png_app_error(png_ptr, "png_set_keep_unknown_chunks: no chunk list");
          return;
       }
 
       num_chunks = num_chunks_in;
    }
 
    old_num_chunks = png_ptr->num_chunk_list;
    if (png_ptr->chunk_list == NULL)
       old_num_chunks = 0;
 
    /* Since num_chunks is always restricted to UINT_MAX/5 this can't overflow.
     */
    if (num_chunks + old_num_chunks > UINT_MAX/5)
    {
       png_app_error(png_ptr, "png_set_keep_unknown_chunks: too many chunks");
       return;
    }
 
    /* If these chunks are being reset to the default then no more memory is
     * required because add_one_chunk above doesn't extend the list if the 'keep'
     * parameter is the default.
     */
    if (keep != 0)
    {
       new_list = png_voidcast(png_bytep, png_malloc(png_ptr,
           5 * (num_chunks + old_num_chunks)));
 
       if (old_num_chunks > 0)
          memcpy(new_list, png_ptr->chunk_list, 5*old_num_chunks);
    }
 
    else if (old_num_chunks > 0)
       new_list = png_ptr->chunk_list;
 
    else
       new_list = NULL;
 
    /* Add the new chunks together with each one's handling code.  If the chunk
     * already exists the code is updated, otherwise the chunk is added to the
     * end.  (In libpng 1.6.0 order no longer matters because this code enforces
     * the earlier convention that the last setting is the one that is used.)
     */
    if (new_list != NULL)
    {
       png_const_bytep inlist;
       png_bytep outlist;
       unsigned int i;
 
       for (i=0; i<num_chunks; ++i)
       {
          old_num_chunks = add_one_chunk(new_list, old_num_chunks,
             chunk_list+5*i, keep);
       }
 
       /* Now remove any spurious 'default' entries. */
       num_chunks = 0;
       for (i=0, inlist=outlist=new_list; i<old_num_chunks; ++i, inlist += 5)
       {
          if (inlist[4])
          {
             if (outlist != inlist)
                memcpy(outlist, inlist, 5);
             outlist += 5;
             ++num_chunks;
          }
       }
 
       /* This means the application has removed all the specialized handling. */
       if (num_chunks == 0)
       {
          if (png_ptr->chunk_list != new_list)
             png_free(png_ptr, new_list);
 
          new_list = NULL;
       }
    }
 
    else
       num_chunks = 0;
 
    png_ptr->num_chunk_list = num_chunks;
 
    if (png_ptr->chunk_list != new_list)
    {
       if (png_ptr->chunk_list != NULL)
          png_free(png_ptr, png_ptr->chunk_list);
 
       png_ptr->chunk_list = new_list;
    }
 }

PNG_IMPEXP int() png_handle_as_unknown	(	png_const_structrp	png_ptr,
		png_const_bytep	chunk_name
	)

 {
    /* Check chunk_name and return "keep" value if it's on the list, else 0 */
    png_const_bytep p, p_end;
 
    if (png_ptr == NULL || chunk_name == NULL || png_ptr->num_chunk_list == 0)
       return PNG_HANDLE_CHUNK_AS_DEFAULT;
 
    p_end = png_ptr->chunk_list;
    p = p_end + png_ptr->num_chunk_list*5; /* beyond end */
 
    /* The code is the fifth byte after each four byte string.  Historically this
     * code was always searched from the end of the list, this is no longer
     * necessary because the 'set' routine handles duplicate entries correcty.
     */
    do /* num_chunk_list > 0, so at least one */
    {
       p -= 5;
 
       if (memcmp(chunk_name, p, 4) == 0)
          return p[4];
    }
    while (p > p_end);
 
    /* This means that known chunks should be processed and unknown chunks should
     * be handled according to the value of png_ptr->unknown_default; this can be
     * confusing because, as a result, there are two levels of defaulting for
     * unknown chunks.
     */
    return PNG_HANDLE_CHUNK_AS_DEFAULT;
 }

PNG_IMPEXP void() png_set_unknown_chunks	(	png_const_structrp	png_ptr,
		png_inforp	info_ptr,
		png_const_unknown_chunkp	unknowns,
		int	num_unknowns
	)

 {
    png_unknown_chunkp np;
 
    if (png_ptr == NULL || info_ptr == NULL || num_unknowns <= 0 ||
       unknowns == NULL)
       return;
 
    /* Check for the failure cases where support has been disabled at compile
     * time.  This code is hardly ever compiled - it's here because
     * STORE_UNKNOWN_CHUNKS is set by both read and write code (compiling in this
     * code) but may be meaningless if the read or write handling of unknown
     * chunks is not compiled in.
     */
 #  if !defined(PNG_READ_UNKNOWN_CHUNKS_SUPPORTED) && \
       defined(PNG_READ_SUPPORTED)
       if ((png_ptr->mode & PNG_IS_READ_STRUCT) != 0)
       {
          png_app_error(png_ptr, "no unknown chunk support on read");
          return;
       }
 #  endif
 #  if !defined(PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED) && \
       defined(PNG_WRITE_SUPPORTED)
       if ((png_ptr->mode & PNG_IS_READ_STRUCT) == 0)
       {
          png_app_error(png_ptr, "no unknown chunk support on write");
          return;
       }
 #  endif
 
    /* Prior to 1.6.0 this code used png_malloc_warn; however, this meant that
     * unknown critical chunks could be lost with just a warning resulting in
     * undefined behavior.  Now png_chunk_report is used to provide behavior
     * appropriate to read or write.
     */
    np = png_voidcast(png_unknown_chunkp, png_realloc_array(png_ptr,
          info_ptr->unknown_chunks, info_ptr->unknown_chunks_num, num_unknowns,
          sizeof *np));
 
    if (np == NULL)
    {
       png_chunk_report(png_ptr, "too many unknown chunks",
          PNG_CHUNK_WRITE_ERROR);
       return;
    }
 
    png_free(png_ptr, info_ptr->unknown_chunks);
    info_ptr->unknown_chunks = np; /* safe because it is initialized */
    info_ptr->free_me |= PNG_FREE_UNKN;
 
    np += info_ptr->unknown_chunks_num;
 
    /* Increment unknown_chunks_num each time round the loop to protect the
     * just-allocated chunk data.
     */
    for (; num_unknowns > 0; --num_unknowns, ++unknowns)
    {
       memcpy(np->name, unknowns->name, (sizeof np->name));
       np->name[(sizeof np->name)-1] = '\0';
       np->location = check_location(png_ptr, unknowns->location);
 
       if (unknowns->size == 0)
       {
          np->data = NULL;
          np->size = 0;
       }
 
       else
       {
          np->data = png_voidcast(png_bytep,
             png_malloc_base(png_ptr, unknowns->size));
 
          if (np->data == NULL)
          {
             png_chunk_report(png_ptr, "unknown chunk: out of memory",
                PNG_CHUNK_WRITE_ERROR);
             /* But just skip storing the unknown chunk */
             continue;
          }
 
          memcpy(np->data, unknowns->data, unknowns->size);
          np->size = unknowns->size;
       }
 
       /* These increments are skipped on out-of-memory for the data - the
        * unknown chunk entry gets overwritten if the png_chunk_report returns.
        * This is correct in the read case (the chunk is just dropped.)
        */
       ++np;
       ++(info_ptr->unknown_chunks_num);
    }
 }

PNG_IMPEXP void() png_set_unknown_chunk_location	(	png_const_structrp	png_ptr,
		png_inforp	info_ptr,
		int	chunk,
		int	location
	)

 {
    /* This API is pretty pointless in 1.6.0 because the location can be set
     * before the call to png_set_unknown_chunks.
     *
     * TODO: add a png_app_warning in 1.7
     */
    if (png_ptr != NULL && info_ptr != NULL && chunk >= 0 &&
       chunk < info_ptr->unknown_chunks_num)
    {
       if ((location & (PNG_HAVE_IHDR|PNG_HAVE_PLTE|PNG_AFTER_IDAT)) == 0)
       {
          png_app_error(png_ptr, "invalid unknown chunk location");
          /* Fake out the pre 1.6.0 behavior: */
          if ((location & PNG_HAVE_IDAT) != 0) /* undocumented! */
             location = PNG_AFTER_IDAT;
 
          else
             location = PNG_HAVE_IHDR; /* also undocumented */
       }
 
       info_ptr->unknown_chunks[chunk].location =
          check_location(png_ptr, location);
    }
 }

PNG_IMPEXP int() png_get_unknown_chunks	(	png_const_structrp	png_ptr,
		png_inforp	info_ptr,
		png_unknown_chunkpp	entries
	)

 {
    if (png_ptr != NULL && info_ptr != NULL && unknowns != NULL)
    {
       *unknowns = info_ptr->unknown_chunks;
       return info_ptr->unknown_chunks_num;
    }
 
    return (0);
 }

PNG_IMPEXP void() png_set_invalid	(	png_const_structrp	png_ptr,
		png_inforp	info_ptr,
		int	mask
	)

 {
    if (png_ptr != NULL && info_ptr != NULL)
       info_ptr->valid &= ~mask;
 }

PNG_IMPEXP void() png_read_png	(	png_structrp	png_ptr,
		png_inforp	info_ptr,
		int	transforms,
		png_voidp	params
	)

PNG_IMPEXP void() png_write_png	(	png_structrp	png_ptr,
		png_inforp	info_ptr,
		int	transforms,
		png_voidp	params
	)

PNG_IMPEXP png_const_charp() png_get_copyright ( png_const_structrp png_ptr )

 {
    PNG_UNUSED(png_ptr)  /* Silence compiler warning about unused png_ptr */
 #ifdef PNG_STRING_COPYRIGHT
    return PNG_STRING_COPYRIGHT
 #else
 #  ifdef __STDC__
    return PNG_STRING_NEWLINE \
      "libpng version 1.6.16 - December 22, 2014" PNG_STRING_NEWLINE \
      "Copyright (c) 1998-2014 Glenn Randers-Pehrson" PNG_STRING_NEWLINE \
      "Copyright (c) 1996-1997 Andreas Dilger" PNG_STRING_NEWLINE \
      "Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc." \
      PNG_STRING_NEWLINE;
 #  else
       return "libpng version 1.6.16 - December 22, 2014\
       Copyright (c) 1998-2014 Glenn Randers-Pehrson\
       Copyright (c) 1996-1997 Andreas Dilger\
       Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.";
 #  endif
 #endif
 }

PNG_IMPEXP png_const_charp() png_get_header_ver ( png_const_structrp png_ptr )

 {
    /* Version of *.h files used when building libpng */
    PNG_UNUSED(png_ptr)  /* Silence compiler warning about unused png_ptr */
    return PNG_LIBPNG_VER_STRING;
 }

PNG_IMPEXP png_const_charp() png_get_header_version ( png_const_structrp png_ptr )

 {
    /* Returns longer string containing both version and date */
    PNG_UNUSED(png_ptr)  /* Silence compiler warning about unused png_ptr */
 #ifdef __STDC__
    return PNG_HEADER_VERSION_STRING
 #  ifndef PNG_READ_SUPPORTED
    "     (NO READ SUPPORT)"
 #  endif
    PNG_STRING_NEWLINE;
 #else
    return PNG_HEADER_VERSION_STRING;
 #endif
 }

PNG_IMPEXP png_const_charp() png_get_libpng_ver ( png_const_structrp png_ptr )

 {
    /* Version of *.c files used when building libpng */
    return png_get_header_ver(png_ptr);
 }

PNG_IMPEXP png_uint_32() png_permit_mng_features	(	png_structrp	png_ptr,
		png_uint_32	mng_features_permitted
	)

 {
    png_debug(1, "in png_permit_mng_features");
 
    if (png_ptr == NULL)
       return 0;
 
    png_ptr->mng_features_permitted = mng_features & PNG_ALL_MNG_FEATURES;
 
    return png_ptr->mng_features_permitted;
 }

PNG_IMPEXP void() png_set_user_limits	(	png_structrp	png_ptr,
		png_uint_32	user_width_max,
		png_uint_32	user_height_max
	)

 {
    /* Images with dimensions larger than these limits will be
     * rejected by png_set_IHDR().  To accept any PNG datastream
     * regardless of dimensions, set both limits to 0x7ffffffL.
     */
    if (png_ptr == NULL)
       return;
 
    png_ptr->user_width_max = user_width_max;
    png_ptr->user_height_max = user_height_max;
 }

PNG_IMPEXP png_uint_32() png_get_user_width_max ( png_const_structrp png_ptr )

 {
    return (png_ptr ? png_ptr->user_width_max : 0);
 }

PNG_IMPEXP png_uint_32() png_get_user_height_max ( png_const_structrp png_ptr )

 {
    return (png_ptr ? png_ptr->user_height_max : 0);
 }

PNG_IMPEXP void() png_set_chunk_cache_max	(	png_structrp	png_ptr,
		png_uint_32	user_chunk_cache_max
	)

 {
     if (png_ptr != NULL)
        png_ptr->user_chunk_cache_max = user_chunk_cache_max;
 }

PNG_IMPEXP png_uint_32() png_get_chunk_cache_max ( png_const_structrp png_ptr )

 {
    return (png_ptr ? png_ptr->user_chunk_cache_max : 0);
 }

PNG_IMPEXP void() png_set_chunk_malloc_max	(	png_structrp	png_ptr,
		png_alloc_size_t	user_chunk_cache_max
	)

 {
    if (png_ptr != NULL)
       png_ptr->user_chunk_malloc_max = user_chunk_malloc_max;
 }

PNG_IMPEXP png_alloc_size_t() png_get_chunk_malloc_max ( png_const_structrp png_ptr )

 {
    return (png_ptr ? png_ptr->user_chunk_malloc_max : 0);
 }

PNG_IMPEXP png_uint_32() png_get_pixels_per_inch	(	png_const_structrp	png_ptr,
		png_const_inforp	info_ptr
	)

 {
    return ppi_from_ppm(png_get_pixels_per_meter(png_ptr, info_ptr));
 }

PNG_IMPEXP png_uint_32() png_get_x_pixels_per_inch	(	png_const_structrp	png_ptr,
		png_const_inforp	info_ptr
	)

 {
    return ppi_from_ppm(png_get_x_pixels_per_meter(png_ptr, info_ptr));
 }

PNG_IMPEXP png_uint_32() png_get_y_pixels_per_inch	(	png_const_structrp	png_ptr,
		png_const_inforp	info_ptr
	)

 {
    return ppi_from_ppm(png_get_y_pixels_per_meter(png_ptr, info_ptr));
 }

PNG_IMPEXP float() png_get_x_offset_inches	(	png_const_structrp	png_ptr,
		png_const_inforp	info_ptr
	)

 {
    /* To avoid the overflow do the conversion directly in floating
     * point.
     */
    return (float)(png_get_x_offset_microns(png_ptr, info_ptr) * .00003937);
 }

PNG_IMPEXP png_fixed_point() png_get_x_offset_inches_fixed	(	png_const_structrp	png_ptr,
		png_const_inforp	info_ptr
	)

 {
    return png_fixed_inches_from_microns(png_ptr,
        png_get_x_offset_microns(png_ptr, info_ptr));
 }

PNG_IMPEXP float() png_get_y_offset_inches	(	png_const_structrp	png_ptr,
		png_const_inforp	info_ptr
	)

 {
    /* To avoid the overflow do the conversion directly in floating
     * point.
     */
    return (float)(png_get_y_offset_microns(png_ptr, info_ptr) * .00003937);
 }

PNG_IMPEXP png_fixed_point() png_get_y_offset_inches_fixed	(	png_const_structrp	png_ptr,
		png_const_inforp	info_ptr
	)

 {
    return png_fixed_inches_from_microns(png_ptr,
        png_get_y_offset_microns(png_ptr, info_ptr));
 }

PNG_IMPEXP png_uint_32() png_get_pHYs_dpi	(	png_const_structrp	png_ptr,
		png_const_inforp	info_ptr,
		png_uint_32 *	res_x,
		png_uint_32 *	res_y,
		int *	unit_type
	)

 {
    png_uint_32 retval = 0;
 
    if (png_ptr != NULL && info_ptr != NULL &&
        (info_ptr->valid & PNG_INFO_pHYs) != 0)
    {
       png_debug1(1, "in %s retrieval function", "pHYs");
 
       if (res_x != NULL)
       {
          *res_x = info_ptr->x_pixels_per_unit;
          retval |= PNG_INFO_pHYs;
       }
 
       if (res_y != NULL)
       {
          *res_y = info_ptr->y_pixels_per_unit;
          retval |= PNG_INFO_pHYs;
       }
 
       if (unit_type != NULL)
       {
          *unit_type = (int)info_ptr->phys_unit_type;
          retval |= PNG_INFO_pHYs;
 
          if (*unit_type == 1)
          {
             if (res_x != NULL) *res_x = (png_uint_32)(*res_x * .0254 + .50);
             if (res_y != NULL) *res_y = (png_uint_32)(*res_y * .0254 + .50);
          }
       }
    }
 
    return (retval);
 }

PNG_IMPEXP png_uint_32() png_get_io_state ( png_const_structrp png_ptr )

 {
    return png_ptr->io_state;
 }

PNG_IMPEXP png_uint_32() png_get_io_chunk_type ( png_const_structrp png_ptr )

 {
    return png_ptr->chunk_name;
 }

PNG_IMPEXP png_uint_32() png_get_uint_32 ( png_const_bytep buf )

 {
    png_uint_32 uval =
        ((png_uint_32)(*(buf    )) << 24) +
        ((png_uint_32)(*(buf + 1)) << 16) +
        ((png_uint_32)(*(buf + 2)) <<  8) +
        ((png_uint_32)(*(buf + 3))      ) ;
 
    return uval;
 }

PNG_IMPEXP png_uint_16() png_get_uint_16 ( png_const_bytep buf )

 {
    /* ANSI-C requires an int value to accomodate at least 16 bits so this
     * works and allows the compiler not to worry about possible narrowing
     * on 32 bit systems.  (Pre-ANSI systems did not make integers smaller
     * than 16 bits either.)
     */
    unsigned int val =
        ((unsigned int)(*buf) << 8) +
        ((unsigned int)(*(buf + 1)));
 
    return (png_uint_16)val;
 }

PNG_IMPEXP png_int_32() png_get_int_32 ( png_const_bytep buf )

 {
    png_uint_32 uval = png_get_uint_32(buf);
    if ((uval & 0x80000000) == 0) /* non-negative */
       return uval;
 
    uval = (uval ^ 0xffffffff) + 1;  /* 2's complement: -x = ~x+1 */
    return -(png_int_32)uval;
 }

PNG_IMPEXP png_uint_32() png_get_uint_31	(	png_const_structrp	png_ptr,
		png_const_bytep	buf
	)

 {
    png_uint_32 uval = png_get_uint_32(buf);
 
    if (uval > PNG_UINT_31_MAX)
       png_error(png_ptr, "PNG unsigned integer out of range");
 
    return (uval);
 }

PNG_IMPEXP void() png_save_uint_32	(	png_bytep	buf,
		png_uint_32	i
	)

 {
    buf[0] = (png_byte)((i >> 24) & 0xff);
    buf[1] = (png_byte)((i >> 16) & 0xff);
    buf[2] = (png_byte)((i >> 8) & 0xff);
    buf[3] = (png_byte)(i & 0xff);
 }

PNG_IMPEXP void() png_save_int_32	(	png_bytep	buf,
		png_int_32	i
	)

 {
    buf[0] = (png_byte)((i >> 24) & 0xff);
    buf[1] = (png_byte)((i >> 16) & 0xff);
    buf[2] = (png_byte)((i >> 8) & 0xff);
    buf[3] = (png_byte)(i & 0xff);
 }

PNG_IMPEXP void() png_save_uint_16	(	png_bytep	buf,
		unsigned int	i
	)

 {
    buf[0] = (png_byte)((i >> 8) & 0xff);
    buf[1] = (png_byte)(i & 0xff);
 }

PNG_IMPEXP int() png_image_begin_read_from_file	(	png_imagep	image,
		const char *	file_name
	)

 {
    if (image != NULL && image->version == PNG_IMAGE_VERSION)
    {
       if (file_name != NULL)
       {
          FILE *fp = fopen(file_name, "rb");
 
          if (fp != NULL)
          {
             if (png_image_read_init(image) != 0)
             {
                image->opaque->png_ptr->io_ptr = fp;
                image->opaque->owned_file = 1;
                return png_safe_execute(image, png_image_read_header, image);
             }
 
             /* Clean up: just the opened file. */
             (void)fclose(fp);
          }
 
          else
             return png_image_error(image, strerror(errno));
       }
 
       else
          return png_image_error(image,
             "png_image_begin_read_from_file: invalid argument");
    }
 
    else if (image != NULL)
       return png_image_error(image,
          "png_image_begin_read_from_file: incorrect PNG_IMAGE_VERSION");
 
    return 0;
 }

PNG_IMPEXP int() png_image_begin_read_from_stdio	(	png_imagep	image,
		FILE *	file
	)

 {
    if (image != NULL && image->version == PNG_IMAGE_VERSION)
    {
       if (file != NULL)
       {
          if (png_image_read_init(image) != 0)
          {
             /* This is slightly evil, but png_init_io doesn't do anything other
              * than this and we haven't changed the standard IO functions so
              * this saves a 'safe' function.
              */
             image->opaque->png_ptr->io_ptr = file;
             return png_safe_execute(image, png_image_read_header, image);
          }
       }
 
       else
          return png_image_error(image,
             "png_image_begin_read_from_stdio: invalid argument");
    }
 
    else if (image != NULL)
       return png_image_error(image,
          "png_image_begin_read_from_stdio: incorrect PNG_IMAGE_VERSION");
 
    return 0;
 }

PNG_IMPEXP int() png_image_begin_read_from_memory	(	png_imagep	image,
		png_const_voidp	memory,
		png_size_t	size
	)

 {
    if (image != NULL && image->version == PNG_IMAGE_VERSION)
    {
       if (memory != NULL && size > 0)
       {
          if (png_image_read_init(image) != 0)
          {
             /* Now set the IO functions to read from the memory buffer and
              * store it into io_ptr.  Again do this in-place to avoid calling a
              * libpng function that requires error handling.
              */
             image->opaque->memory = png_voidcast(png_const_bytep, memory);
             image->opaque->size = size;
             image->opaque->png_ptr->io_ptr = image;
             image->opaque->png_ptr->read_data_fn = png_image_memory_read;
 
             return png_safe_execute(image, png_image_read_header, image);
          }
       }
 
       else
          return png_image_error(image,
             "png_image_begin_read_from_memory: invalid argument");
    }
 
    else if (image != NULL)
       return png_image_error(image,
          "png_image_begin_read_from_memory: incorrect PNG_IMAGE_VERSION");
 
    return 0;
 }

PNG_IMPEXP int() png_image_finish_read	(	png_imagep	image,
		png_const_colorp	background,
		void *	buffer,
		png_int_32	row_stride,
		void *	colormap
	)

 {
    if (image != NULL && image->version == PNG_IMAGE_VERSION)
    {
       png_uint_32 check;
 
       if (row_stride == 0)
          row_stride = PNG_IMAGE_ROW_STRIDE(*image);
 
       if (row_stride < 0)
          check = -row_stride;
 
       else
          check = row_stride;
 
       if (image->opaque != NULL && buffer != NULL &&
          check >= PNG_IMAGE_ROW_STRIDE(*image))
       {
          if ((image->format & PNG_FORMAT_FLAG_COLORMAP) == 0 ||
             (image->colormap_entries > 0 && colormap != NULL))
          {
             int result;
             png_image_read_control display;
 
             memset(&display, 0, (sizeof display));
             display.image = image;
             display.buffer = buffer;
             display.row_stride = row_stride;
             display.colormap = colormap;
             display.background = background;
             display.local_row = NULL;
 
             /* Choose the correct 'end' routine; for the color-map case all the
              * setup has already been done.
              */
             if ((image->format & PNG_FORMAT_FLAG_COLORMAP) != 0)
                result =
                   png_safe_execute(image, png_image_read_colormap, &display) &&
                   png_safe_execute(image, png_image_read_colormapped, &display);
 
             else
                result =
                   png_safe_execute(image, png_image_read_direct, &display);
 
             png_image_free(image);
             return result;
          }
 
          else
             return png_image_error(image,
                "png_image_finish_read[color-map]: no color-map");
       }
 
       else
          return png_image_error(image,
             "png_image_finish_read: invalid argument");
    }
 
    else if (image != NULL)
       return png_image_error(image,
          "png_image_finish_read: damaged PNG_IMAGE_VERSION");
 
    return 0;
 }

PNG_IMPEXP void() png_image_free ( png_imagep image )

 {
    /* Safely call the real function, but only if doing so is safe at this point
     * (if not inside an error handling context).  Otherwise assume
     * png_safe_execute will call this API after the return.
     */
    if (image != NULL && image->opaque != NULL &&
       image->opaque->error_buf == NULL)
    {
       /* Ignore errors here: */
       (void)png_safe_execute(image, png_image_free_function, image);
       image->opaque = NULL;
    }
 }

PNG_IMPEXP int() png_image_write_to_file	(	png_imagep	image,
		const char *	file,
		int	convert_to_8bit,
		const void *	buffer,
		png_int_32	row_stride,
		const void *	colormap
	)

 {
    /* Write the image to the named file. */
    if (image != NULL && image->version == PNG_IMAGE_VERSION)
    {
       if (file_name != NULL)
       {
          FILE *fp = fopen(file_name, "wb");
 
          if (fp != NULL)
          {
             if (png_image_write_to_stdio(image, fp, convert_to_8bit, buffer,
                row_stride, colormap) != 0)
             {
                int error; /* from fflush/fclose */
 
                /* Make sure the file is flushed correctly. */
                if (fflush(fp) == 0 && ferror(fp) == 0)
                {
                   if (fclose(fp) == 0)
                      return 1;
 
                   error = errno; /* from fclose */
                }
 
                else
                {
                   error = errno; /* from fflush or ferror */
                   (void)fclose(fp);
                }
 
                (void)remove(file_name);
                /* The image has already been cleaned up; this is just used to
                 * set the error (because the original write succeeded).
                 */
                return png_image_error(image, strerror(error));
             }
 
             else
             {
                /* Clean up: just the opened file. */
                (void)fclose(fp);
                (void)remove(file_name);
                return 0;
             }
          }
 
          else
             return png_image_error(image, strerror(errno));
       }
 
       else
          return png_image_error(image,
             "png_image_write_to_file: invalid argument");
    }
 
    else if (image != NULL)
       return png_image_error(image,
          "png_image_write_to_file: incorrect PNG_IMAGE_VERSION");
 
    else
       return 0;
 }

PNG_IMPEXP int() png_image_write_to_stdio	(	png_imagep	image,
		FILE *	file,
		int	convert_to_8_bit,
		const void *	buffer,
		png_int_32	row_stride,
		const void *	colormap
	)

 {
    /* Write the image to the given (FILE*). */
    if (image != NULL && image->version == PNG_IMAGE_VERSION)
    {
       if (file != NULL)
       {
          if (png_image_write_init(image) != 0)
          {
             png_image_write_control display;
             int result;
 
             /* This is slightly evil, but png_init_io doesn't do anything other
              * than this and we haven't changed the standard IO functions so
              * this saves a 'safe' function.
              */
             image->opaque->png_ptr->io_ptr = file;
 
             memset(&display, 0, (sizeof display));
             display.image = image;
             display.buffer = buffer;
             display.row_stride = row_stride;
             display.colormap = colormap;
             display.convert_to_8bit = convert_to_8bit;
 
             result = png_safe_execute(image, png_image_write_main, &display);
             png_image_free(image);
             return result;
          }
 
          else
             return 0;
       }
 
       else
          return png_image_error(image,
             "png_image_write_to_stdio: invalid argument");
    }
 
    else if (image != NULL)
       return png_image_error(image,
          "png_image_write_to_stdio: incorrect PNG_IMAGE_VERSION");
 
    else
       return 0;
 }

PNG_IMPEXP void() png_set_check_for_invalid_index	(	png_structrp	png_ptr,
		int	allowed
	)

 {
    png_debug(1, "in png_set_check_for_invalid_index");
 
    if (allowed > 0)
       png_ptr->num_palette_max = 0;
 
    else
       png_ptr->num_palette_max = -1;
 }

PNG_IMPEXP int() png_get_palette_max	(	png_const_structp	png_ptr,
		png_const_infop	info_ptr
	)

 {
    if (png_ptr != NULL && info_ptr != NULL)
       return png_ptr->num_palette_max;
 
    return (-1);
 }

PNG_IMPEXP int() png_set_option	(	png_structrp	png_ptr,
		int	option,
		int	onoff
	)

 {
    if (png_ptr != NULL && option >= 0 && option < PNG_OPTION_NEXT &&
       (option & 1) == 0)
    {
       int mask = 3 << option;
       int setting = (2 + (onoff != 0)) << option;
       int current = png_ptr->options;
 
       png_ptr->options = (png_byte)((current & ~mask) | setting);
 
       return (current & mask) >> option;
    }
 
    return PNG_OPTION_INVALID;
 }

Classes

Macros

Typedefs

Functions

Macro Definition Documentation

Typedef Documentation

Function Documentation