#include <stdlib.h>
#include <string.h>
#include "pnglibconf.h"
#include "png.h"
#include <float.h>
#include <math.h>
#include "pngstruct.h"
#include "pnginfo.h"
#include "pngdebug.h"

Include dependency graph for pngpriv.h:

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

Classes
struct	png_control

Macros
#define	_POSIX_SOURCE 1 /* Just the POSIX 1003.1 and C89 APIs */

#define	PNGLIB_BUILD /libpng is being built, not used/

#define	PNG_ARM_NEON_OPT 0

#define	PNG_IMPEXP

#define	PNG_DEPRECATED

#define	PNG_PRIVATE

#define	PNG_INTERNAL_DATA(type, name, array) extern type name array

#define	PNG_INTERNAL_FUNCTION(type, name, args, attributes) extern PNG_FUNCTION(type, name, args, PNG_EMPTY attributes)

#define	PNG_INTERNAL_CALLBACK(type, name, args, attributes) extern PNG_FUNCTION(type, (PNGCBAPI name), args, PNG_EMPTY attributes)

#define	PNG_DLL_EXPORT

#define	PNG_USER_WIDTH_MAX 0x7fffffff

#define	PNG_USER_HEIGHT_MAX 0x7fffffff

#define	PNG_USER_CHUNK_CACHE_MAX 0

#define	PNG_USER_CHUNK_MALLOC_MAX 0

#define	PNG_UNUSED(param) (void)param;

#define	PNG_WARNING_PARAMETERS(p) png_warning_parameters p;

#define	png_voidcast(type, value) (value)

#define	png_constcast(type, value) ((type)(value))

#define	png_aligncast(type, value) ((void*)(value))

#define	png_aligncastconst(type, value) ((const void*)(value))

#define	PNGFAPI PNGAPI

#define	PNG_ABORT() abort()

#define	PNG_ALIGN_NONE 0 /* do not use data alignment */

#define	PNG_ALIGN_ALWAYS 1 /* assume unaligned accesses are OK */

#define	PNG_ALIGN_OFFSET -1 /* prevent the use of this */

#define	PNG_ALIGN_SIZE 3 /* use sizeof to determine alignment */

#define	PNG_ALIGN_TYPE PNG_ALIGN_SIZE

#define	png_alignof(type) (sizeof (type))

#define	png_isaligned(ptr, type) ((((const char)ptr-(const char)0) & (png_alignof(type)-1)) == 0)

#define	PNG_HAVE_IDAT 0x04

#define	PNG_HAVE_IEND 0x10

#define	PNG_HAVE_CHUNK_HEADER 0x100

#define	PNG_WROTE_tIME 0x200

#define	PNG_WROTE_INFO_BEFORE_PLTE 0x400

#define	PNG_BACKGROUND_IS_GRAY 0x800

#define	PNG_HAVE_PNG_SIGNATURE 0x1000

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

#define	PNG_IS_READ_STRUCT 0x8000 /* Else is a write struct */

#define	PNG_BGR 0x0001

#define	PNG_INTERLACE 0x0002

#define	PNG_PACK 0x0004

#define	PNG_SHIFT 0x0008

#define	PNG_SWAP_BYTES 0x0010

#define	PNG_INVERT_MONO 0x0020

#define	PNG_QUANTIZE 0x0040

#define	PNG_COMPOSE 0x0080 /* Was PNG_BACKGROUND */

#define	PNG_BACKGROUND_EXPAND 0x0100

#define	PNG_EXPAND_16 0x0200 /* Added to libpng 1.5.2 */

#define	PNG_16_TO_8 0x0400 /* Becomes 'chop' in 1.5.4 */

#define	PNG_RGBA 0x0800

#define	PNG_EXPAND 0x1000

#define	PNG_GAMMA 0x2000

#define	PNG_GRAY_TO_RGB 0x4000

#define	PNG_FILLER 0x8000

#define	PNG_PACKSWAP 0x10000

#define	PNG_SWAP_ALPHA 0x20000

#define	PNG_STRIP_ALPHA 0x40000

#define	PNG_INVERT_ALPHA 0x80000

#define	PNG_USER_TRANSFORM 0x100000

#define	PNG_RGB_TO_GRAY_ERR 0x200000

#define	PNG_RGB_TO_GRAY_WARN 0x400000

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

#define	PNG_ENCODE_ALPHA 0x800000 /* Added to libpng-1.5.4 */

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

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

#define	PNG_SCALE_16_TO_8 0x4000000 /* Added to libpng-1.5.4 */

#define	PNG_STRUCT_PNG 0x0001

#define	PNG_STRUCT_INFO 0x0002

#define	PNG_WEIGHT_FACTOR (1<<(PNG_WEIGHT_SHIFT))

#define	PNG_COST_FACTOR (1<<(PNG_COST_SHIFT))

#define	PNG_FLAG_ZLIB_CUSTOM_STRATEGY 0x0001

#define	PNG_FLAG_ZSTREAM_INITIALIZED 0x0002 /* Added to libpng-1.6.0 */

#define	PNG_FLAG_ZSTREAM_ENDED 0x0008 /* Added to libpng-1.6.0 */

#define	PNG_FLAG_ROW_INIT 0x0040

#define	PNG_FLAG_FILLER_AFTER 0x0080

#define	PNG_FLAG_CRC_ANCILLARY_USE 0x0100

#define	PNG_FLAG_CRC_ANCILLARY_NOWARN 0x0200

#define	PNG_FLAG_CRC_CRITICAL_USE 0x0400

#define	PNG_FLAG_CRC_CRITICAL_IGNORE 0x0800

#define	PNG_FLAG_ASSUME_sRGB 0x1000 /* Added to libpng-1.5.4 */

#define	PNG_FLAG_OPTIMIZE_ALPHA 0x2000 /* Added to libpng-1.5.4 */

#define	PNG_FLAG_DETECT_UNINITIALIZED 0x4000 /* Added to libpng-1.5.4 */

#define	PNG_FLAG_LIBRARY_MISMATCH 0x20000

#define	PNG_FLAG_STRIP_ERROR_NUMBERS 0x40000

#define	PNG_FLAG_STRIP_ERROR_TEXT 0x80000

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

#define	PNG_FLAG_APP_WARNINGS_WARN 0x200000 /* Added to libpng-1.6.0 */

#define	PNG_FLAG_APP_ERRORS_WARN 0x400000 /* Added to libpng-1.6.0 */

#define	PNG_FLAG_CRC_ANCILLARY_MASK

#define	PNG_FLAG_CRC_CRITICAL_MASK

#define	PNG_FLAG_CRC_MASK

#define	PNG_COLOR_DIST(c1, c2)

#define	PNG_DIV65535(v24) (((v24) + 32895) >> 16)

#define	PNG_DIV257(v16) PNG_DIV65535((png_uint_32)(v16) * 255)

#define	PNG_ROWBYTES(pixel_bits, width)

#define	PNG_OUT_OF_RANGE(value, ideal, delta) ( (value) < (ideal)-(delta) \|\| (value) > (ideal)+(delta) )

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

#define	PNG_32b(b, s) ((png_uint_32)(b) << (s))

#define	PNG_U32(b1, b2, b3, b4) (PNG_32b(b1,24) \| PNG_32b(b2,16) \| PNG_32b(b3,8) \| PNG_32b(b4,0))

#define	png_IDAT PNG_U32( 73, 68, 65, 84)

#define	png_IEND PNG_U32( 73, 69, 78, 68)

#define	png_IHDR PNG_U32( 73, 72, 68, 82)

#define	png_PLTE PNG_U32( 80, 76, 84, 69)

#define	png_bKGD PNG_U32( 98, 75, 71, 68)

#define	png_cHRM PNG_U32( 99, 72, 82, 77)

#define	png_fRAc PNG_U32(102, 82, 65, 99) /* registered, not defined */

#define	png_gAMA PNG_U32(103, 65, 77, 65)

#define	png_gIFg PNG_U32(103, 73, 70, 103)

#define	png_gIFt PNG_U32(103, 73, 70, 116) /* deprecated */

#define	png_gIFx PNG_U32(103, 73, 70, 120)

#define	png_hIST PNG_U32(104, 73, 83, 84)

#define	png_iCCP PNG_U32(105, 67, 67, 80)

#define	png_iTXt PNG_U32(105, 84, 88, 116)

#define	png_oFFs PNG_U32(111, 70, 70, 115)

#define	png_pCAL PNG_U32(112, 67, 65, 76)

#define	png_pHYs PNG_U32(112, 72, 89, 115)

#define	png_sBIT PNG_U32(115, 66, 73, 84)

#define	png_sCAL PNG_U32(115, 67, 65, 76)

#define	png_sPLT PNG_U32(115, 80, 76, 84)

#define	png_sRGB PNG_U32(115, 82, 71, 66)

#define	png_sTER PNG_U32(115, 84, 69, 82)

#define	png_tEXt PNG_U32(116, 69, 88, 116)

#define	png_tIME PNG_U32(116, 73, 77, 69)

#define	png_tRNS PNG_U32(116, 82, 78, 83)

#define	png_zTXt PNG_U32(122, 84, 88, 116)

#define	PNG_CHUNK_FROM_STRING(s) PNG_U32(0xff&(s)[0], 0xff&(s)[1], 0xff&(s)[2], 0xff&(s)[3])

#define	PNG_STRING_FROM_CHUNK(s, c)

#define	PNG_CSTRING_FROM_CHUNK(s, c) (void)(PNG_STRING_FROM_CHUNK(s,c), ((char*)(s))[4] = 0)

#define	PNG_CHUNK_ANCILLARY(c) (1 & ((c) >> 29))

#define	PNG_CHUNK_CRITICAL(c) (!PNG_CHUNK_ANCILLARY(c))

#define	PNG_CHUNK_PRIVATE(c) (1 & ((c) >> 21))

#define	PNG_CHUNK_RESERVED(c) (1 & ((c) >> 13))

#define	PNG_CHUNK_SAFE_TO_COPY(c) (1 & ((c) >> 5))

#define	PNG_GAMMA_MAC_OLD 151724 /* Assume '1.8' is really 2.2/1.45! */

#define	PNG_GAMMA_MAC_INVERSE 65909

#define	PNG_GAMMA_sRGB_INVERSE 45455

#define	PNG_sRGB_FROM_LINEAR(linear)

#define	PNG_UNEXPECTED_ZLIB_RETURN (-7)

#define	PNG_USE_COMPILE_TIME_MASKS 1

#define	PNG_FORMAT_NUMBER(buffer, format, number) png_format_number(buffer, buffer + (sizeof buffer), format, number)

#define	PNG_NUMBER_BUFFER_SIZE 24

#define	PNG_NUMBER_FORMAT_u 1 /* chose unsigned API! */

#define	PNG_NUMBER_FORMAT_02u 2

#define	PNG_NUMBER_FORMAT_d 1 /* chose signed API! */

#define	PNG_NUMBER_FORMAT_02d 2

#define	PNG_NUMBER_FORMAT_x 3

#define	PNG_NUMBER_FORMAT_02x 4

#define	PNG_NUMBER_FORMAT_fixed 5 /* choose the signed API */

#define	PNG_WARNING_PARAMETER_SIZE 32

#define	PNG_WARNING_PARAMETER_COUNT 8 /* Maximum 9; see pngerror.c */

#define	PNG_CHUNK_WARNING 0 /* never an error */

#define	PNG_CHUNK_WRITE_ERROR 1 /* an error only on write */

#define	PNG_CHUNK_ERROR 2 /* always an error */

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

#define	PNG_FP_INTEGER 0 /* before or in integer */

#define	PNG_FP_FRACTION 1 /* before or in fraction */

#define	PNG_FP_EXPONENT 2 /* before or in exponent */

#define	PNG_FP_STATE 3 /* mask for the above */

#define	PNG_FP_SAW_SIGN 4 /* Saw +/- in current state */

#define	PNG_FP_SAW_DIGIT 8 /* Saw a digit in current state */

#define	PNG_FP_SAW_DOT 16 /* Saw a dot in current state */

#define	PNG_FP_SAW_E 32 /* Saw an E (or e) in current state */

#define	PNG_FP_SAW_ANY 60 /* Saw any of the above 4 */

#define	PNG_FP_WAS_VALID 64 /* Preceding substring is a valid fp number */

#define	PNG_FP_NEGATIVE 128 /* A negative number, including "-0" */

#define	PNG_FP_NONZERO 256 /* A non-zero value */

#define	PNG_FP_STICKY 448 /* The above three flags */

#define	PNG_FP_INVALID 512 /* Available for callers as a distinct value */

#define	PNG_FP_MAYBE 0 /* The number may be valid in the future */

#define	PNG_FP_OK 1 /* The number is valid */

#define	PNG_FP_NZ_MASK (PNG_FP_SAW_DIGIT \| PNG_FP_NEGATIVE \| PNG_FP_NONZERO)

#define	PNG_FP_Z_MASK (PNG_FP_SAW_DIGIT \| PNG_FP_NONZERO)

#define	PNG_FP_IS_ZERO(state) (((state) & PNG_FP_Z_MASK) == PNG_FP_SAW_DIGIT)

#define	PNG_FP_IS_POSITIVE(state) (((state) & PNG_FP_NZ_MASK) == PNG_FP_Z_MASK)

#define	PNG_FP_IS_NEGATIVE(state) (((state) & PNG_FP_NZ_MASK) == PNG_FP_NZ_MASK)

#define	png_control_jmp_buf(pc) ((pc)->error_buf)

Typedefs
typedef const png_uint_16p *	png_const_uint_16pp

typedef char	png_warning_parameters[8][32]

typedef struct png_control	png_control

Functions
void	png_zstream_error (png_structrp png_ptr, int ret)

void	png_free_buffer_list (png_structrp png_ptr, png_compression_bufferp *list)

png_fixed_point	png_fixed (png_const_structrp png_ptr, double fp, png_const_charp text)

int	png_user_version_check (png_structrp png_ptr, png_const_charp user_png_ver)

png_voidp	png_malloc_base (png_const_structrp png_ptr, png_alloc_size_t size)

png_voidp	png_malloc_array (png_const_structrp png_ptr, int nelements, size_t element_size)

png_voidp	png_realloc_array (png_const_structrp png_ptr, png_const_voidp array, int old_elements, int add_elements, size_t element_size)

png_structp	png_create_png_struct (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)

void	png_destroy_png_struct (png_structrp png_ptr)

void	png_free_jmpbuf (png_structrp png_ptr)

voidpf	png_zalloc (voidpf png_ptr, uInt items, uInt size)

void	png_zfree (voidpf png_ptr, voidpf ptr)

void	png_default_read_data (png_structp png_ptr, png_bytep data, png_size_t length)

void	png_push_fill_buffer (png_structp png_ptr, png_bytep buffer, png_size_t length)

void	png_default_write_data (png_structp png_ptr, png_bytep data, png_size_t length)

void	png_default_flush (png_structp png_ptr)

void	png_reset_crc (png_structrp png_ptr)

void	png_write_data (png_structrp png_ptr, png_const_bytep data, png_size_t length)

void	png_read_sig (png_structrp png_ptr, png_inforp info_ptr)

png_uint_32	png_read_chunk_header (png_structrp png_ptr)

void	png_read_data (png_structrp png_ptr, png_bytep data, png_size_t length)

void	png_crc_read (png_structrp png_ptr, png_bytep buf, png_uint_32 length)

int	png_crc_finish (png_structrp png_ptr, png_uint_32 skip)

int	png_crc_error (png_structrp png_ptr)

void	png_calculate_crc (png_structrp png_ptr, png_const_bytep ptr, png_size_t length)

void	png_flush (png_structrp png_ptr)

void	png_write_IHDR (png_structrp png_ptr, png_uint_32 width, png_uint_32 height, int bit_depth, int color_type, int compression_method, int filter_method, int interlace_method)

void	png_write_PLTE (png_structrp png_ptr, png_const_colorp palette, png_uint_32 num_pal)

void	png_compress_IDAT (png_structrp png_ptr, png_const_bytep row_data, png_alloc_size_t row_data_length, int flush)

void	png_write_IEND (png_structrp png_ptr)

void	png_write_gAMA_fixed (png_structrp png_ptr, png_fixed_point file_gamma)

void	png_write_sBIT (png_structrp png_ptr, png_const_color_8p sbit, int color_type)

void	png_write_cHRM_fixed (png_structrp png_ptr, const png_xy *xy)

void	png_write_sRGB (png_structrp png_ptr, int intent)

void	png_write_iCCP (png_structrp png_ptr, png_const_charp name, png_const_bytep profile)

void	png_write_sPLT (png_structrp png_ptr, png_const_sPLT_tp palette)

void	png_write_tRNS (png_structrp png_ptr, png_const_bytep trans, png_const_color_16p values, int number, int color_type)

void	png_write_bKGD (png_structrp png_ptr, png_const_color_16p values, int color_type)

void	png_write_hIST (png_structrp png_ptr, png_const_uint_16p hist, int num_hist)

void	png_write_tEXt (png_structrp png_ptr, png_const_charp key, png_const_charp text, png_size_t text_len)

void	png_write_zTXt (png_structrp png_ptr, png_const_charp key, png_const_charp text, int compression)

void	png_write_iTXt (png_structrp png_ptr, int compression, png_const_charp key, png_const_charp lang, png_const_charp lang_key, png_const_charp text)

int	png_set_text_2 (png_const_structrp png_ptr, png_inforp info_ptr, png_const_textp text_ptr, int num_text)

void	png_write_oFFs (png_structrp png_ptr, png_int_32 x_offset, png_int_32 y_offset, int unit_type)

void	png_write_pCAL (png_structrp png_ptr, png_charp purpose, png_int_32 X0, png_int_32 X1, int type, int nparams, png_const_charp units, png_charpp params)

void	png_write_pHYs (png_structrp png_ptr, png_uint_32 x_pixels_per_unit, png_uint_32 y_pixels_per_unit, int unit_type)

void	png_write_tIME (png_structrp png_ptr, png_const_timep mod_time)

void	png_write_sCAL_s (png_structrp png_ptr, int unit, png_const_charp width, png_const_charp height)

void	png_write_finish_row (png_structrp png_ptr)

void	png_write_start_row (png_structrp png_ptr)

void	png_combine_row (png_const_structrp png_ptr, png_bytep row, int display)

void	png_do_read_interlace (png_row_infop row_info, png_bytep row, int pass, png_uint_32 transformations)

void	png_do_write_interlace (png_row_infop row_info, png_bytep row, int pass)

void	png_read_filter_row (png_structrp pp, png_row_infop row_info, png_bytep row, png_const_bytep prev_row, int filter)

void	png_read_filter_row_up_neon (png_row_infop row_info, png_bytep row, png_const_bytep prev_row)

void	png_read_filter_row_sub3_neon (png_row_infop row_info, png_bytep row, png_const_bytep prev_row)

void	png_read_filter_row_sub4_neon (png_row_infop row_info, png_bytep row, png_const_bytep prev_row)

void	png_read_filter_row_avg3_neon (png_row_infop row_info, png_bytep row, png_const_bytep prev_row)

void	png_read_filter_row_avg4_neon (png_row_infop row_info, png_bytep row, png_const_bytep prev_row)

void	png_read_filter_row_paeth3_neon (png_row_infop row_info, png_bytep row, png_const_bytep prev_row)

void	png_read_filter_row_paeth4_neon (png_row_infop row_info, png_bytep row, png_const_bytep prev_row)

void	png_write_find_filter (png_structrp png_ptr, png_row_infop row_info)

void	png_read_IDAT_data (png_structrp png_ptr, png_bytep output, png_alloc_size_t avail_out)

void	png_read_finish_IDAT (png_structrp png_ptr)

void	png_read_finish_row (png_structrp png_ptr)

void	png_read_start_row (png_structrp png_ptr)

void	png_read_transform_info (png_structrp png_ptr, png_inforp info_ptr)

void	png_do_strip_channel (png_row_infop row_info, png_bytep row, int at_start)

void	png_do_swap (png_row_infop row_info, png_bytep row)

void	png_do_packswap (png_row_infop row_info, png_bytep row)

void	png_do_invert (png_row_infop row_info, png_bytep row)

void	png_do_bgr (png_row_infop row_info, png_bytep row)

void	png_handle_IHDR (png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length)

void	png_handle_PLTE (png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length)

void	png_handle_IEND (png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length)

void	png_handle_bKGD (png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length)

void	png_handle_cHRM (png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length)

void	png_handle_gAMA (png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length)

void	png_handle_hIST (png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length)

void	png_handle_iCCP (png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length)

void	png_handle_iTXt (png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length)

void	png_handle_oFFs (png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length)

void	png_handle_pCAL (png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length)

void	png_handle_pHYs (png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length)

void	png_handle_sBIT (png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length)

void	png_handle_sCAL (png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length)

void	png_handle_sPLT (png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length)

void	png_handle_sRGB (png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length)

void	png_handle_tEXt (png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length)

void	png_handle_tIME (png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length)

void	png_handle_tRNS (png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length)

void	png_handle_zTXt (png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length)

void	png_check_chunk_name (png_structrp png_ptr, png_uint_32 chunk_name)

void	png_handle_unknown (png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length, int keep)

int	png_chunk_unknown_handling (png_const_structrp png_ptr, png_uint_32 chunk_name)

void	png_do_read_transformations (png_structrp png_ptr, png_row_infop row_info)

void	png_do_write_transformations (png_structrp png_ptr, png_row_infop row_info)

void	png_init_read_transformations (png_structrp png_ptr)

void	png_push_read_chunk (png_structrp png_ptr, png_inforp info_ptr)

void	png_push_read_sig (png_structrp png_ptr, png_inforp info_ptr)

void	png_push_check_crc (png_structrp png_ptr)

void	png_push_crc_skip (png_structrp png_ptr, png_uint_32 length)

void	png_push_crc_finish (png_structrp png_ptr)

void	png_push_save_buffer (png_structrp png_ptr)

void	png_push_restore_buffer (png_structrp png_ptr, png_bytep buffer, png_size_t buffer_length)

void	png_push_read_IDAT (png_structrp png_ptr)

void	png_process_IDAT_data (png_structrp png_ptr, png_bytep buffer, png_size_t buffer_length)

void	png_push_process_row (png_structrp png_ptr)

void	png_push_handle_unknown (png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length)

void	png_push_have_info (png_structrp png_ptr, png_inforp info_ptr)

void	png_push_have_end (png_structrp png_ptr, png_inforp info_ptr)

void	png_push_have_row (png_structrp png_ptr, png_bytep row)

void	png_push_read_end (png_structrp png_ptr, png_inforp info_ptr)

void	png_process_some_data (png_structrp png_ptr, png_inforp info_ptr)

void	png_read_push_finish_row (png_structrp png_ptr)

void	png_push_handle_tEXt (png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length)

void	png_push_read_tEXt (png_structrp png_ptr, png_inforp info_ptr)

void	png_push_handle_zTXt (png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length)

void	png_push_read_zTXt (png_structrp png_ptr, png_inforp info_ptr)

void	png_push_handle_iTXt (png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length)

void	png_push_read_iTXt (png_structrp png_ptr, png_inforp info_ptr)

void	png_colorspace_set_gamma (png_const_structrp png_ptr, png_colorspacerp colorspace, png_fixed_point gAMA)

void	png_colorspace_sync_info (png_const_structrp png_ptr, png_inforp info_ptr)

void	png_colorspace_sync (png_const_structrp png_ptr, png_inforp info_ptr)

int	png_colorspace_set_chromaticities (png_const_structrp png_ptr, png_colorspacerp colorspace, const png_xy *xy, int preferred)

int	png_colorspace_set_endpoints (png_const_structrp png_ptr, png_colorspacerp colorspace, const png_XYZ *XYZ, int preferred)

int	png_colorspace_set_sRGB (png_const_structrp png_ptr, png_colorspacerp colorspace, int intent)

int	png_colorspace_set_ICC (png_const_structrp png_ptr, png_colorspacerp colorspace, png_const_charp name, png_uint_32 profile_length, png_const_bytep profile, int color_type)

int	png_icc_check_length (png_const_structrp png_ptr, png_colorspacerp colorspace, png_const_charp name, png_uint_32 profile_length)

int	png_icc_check_header (png_const_structrp png_ptr, png_colorspacerp colorspace, png_const_charp name, png_uint_32 profile_length, png_const_bytep profile, int color_type)

int	png_icc_check_tag_table (png_const_structrp png_ptr, png_colorspacerp colorspace, png_const_charp name, png_uint_32 profile_length, png_const_bytep profile)

void	png_icc_set_sRGB (png_const_structrp png_ptr, png_colorspacerp colorspace, png_const_bytep profile, uLong adler)

void	png_colorspace_set_rgb_coefficients (png_structrp png_ptr)

void	png_check_IHDR (png_const_structrp png_ptr, png_uint_32 width, png_uint_32 height, int bit_depth, int color_type, int interlace_type, int compression_type, int filter_type)

void	png_do_check_palette_indexes (png_structrp png_ptr, png_row_infop row_info)

void	png_fixed_error (png_const_structrp png_ptr, png_const_charp name)

size_t	png_safecat (png_charp buffer, size_t bufsize, size_t pos, png_const_charp string)

png_charp	png_format_number (png_const_charp start, png_charp end, int format, png_alloc_size_t number)

void	png_warning_parameter (png_warning_parameters p, int number, png_const_charp string)

void	png_warning_parameter_unsigned (png_warning_parameters p, int number, int format, png_alloc_size_t value)

void	png_warning_parameter_signed (png_warning_parameters p, int number, int format, png_int_32 value)

void	png_formatted_warning (png_const_structrp png_ptr, png_warning_parameters p, png_const_charp message)

void	png_app_warning (png_const_structrp png_ptr, png_const_charp message)

void	png_app_error (png_const_structrp png_ptr, png_const_charp message)

void	png_chunk_report (png_const_structrp png_ptr, png_const_charp message, int error)

void	png_ascii_from_fp (png_const_structrp png_ptr, png_charp ascii, png_size_t size, double fp, unsigned int precision)

void	png_ascii_from_fixed (png_const_structrp png_ptr, png_charp ascii, png_size_t size, png_fixed_point fp)

int	png_check_fp_number (png_const_charp string, png_size_t size, int *statep, png_size_tp whereami)

int	png_check_fp_string (png_const_charp string, png_size_t size)

int	png_muldiv (png_fixed_point_p res, png_fixed_point a, png_int_32 multiplied_by, png_int_32 divided_by)

png_fixed_point	png_muldiv_warn (png_const_structrp png_ptr, png_fixed_point a, png_int_32 multiplied_by, png_int_32 divided_by)

png_fixed_point	png_reciprocal (png_fixed_point a)

png_fixed_point	png_reciprocal2 (png_fixed_point a, png_fixed_point b)

int	png_gamma_significant (png_fixed_point gamma_value)

png_uint_16	png_gamma_correct (png_structrp png_ptr, unsigned int value, png_fixed_point gamma_value)

png_uint_16	png_gamma_16bit_correct (unsigned int value, png_fixed_point gamma_value)

png_byte	png_gamma_8bit_correct (unsigned int value, png_fixed_point gamma_value)

void	png_destroy_gamma_table (png_structrp png_ptr)

void	png_build_gamma_table (png_structrp png_ptr, int bit_depth)

void()	png_safe_error (png_structp png_ptr, png_const_charp error_message)

void()	png_safe_warning (png_structp png_ptr, png_const_charp warning_message)

int	png_safe_execute (png_imagep image, int(*function)(png_voidp), png_voidp arg)

int	png_image_error (png_imagep image, png_const_charp error_message)

void	png_init_filter_functions_neon (png_structp png_ptr, unsigned int bpp)

Variables
const png_uint_16	png_sRGB_table [256]

const png_uint_16	png_sRGB_base [512]

const png_byte	png_sRGB_delta [512]

Macro Definition Documentation

#define _POSIX_SOURCE 1 /* Just the POSIX 1003.1 and C89 APIs */

#define PNGLIB_BUILD /*libpng is being built, not used*/

#define PNG_ARM_NEON_OPT 0

#define PNG_IMPEXP

#define PNG_DEPRECATED

#define PNG_PRIVATE

#define PNG_INTERNAL_DATA	(	type,
		name,
		array
	)	extern type name array

#define PNG_INTERNAL_FUNCTION	(	type,
		name,
		args,
		attributes
	)	extern PNG_FUNCTION(type, name, args, PNG_EMPTY attributes)

#define PNG_INTERNAL_CALLBACK	(	type,
		name,
		args,
		attributes
	)	extern PNG_FUNCTION(type, (PNGCBAPI name), args, PNG_EMPTY attributes)

#define PNG_DLL_EXPORT

#define PNG_USER_WIDTH_MAX 0x7fffffff

#define PNG_USER_HEIGHT_MAX 0x7fffffff

#define PNG_USER_CHUNK_CACHE_MAX 0

#define PNG_USER_CHUNK_MALLOC_MAX 0

#define PNG_UNUSED ( param ) (void)param;

#define PNG_WARNING_PARAMETERS ( p ) png_warning_parameters p;

#define png_voidcast	(	type,
		value
	)	(value)

#define png_constcast	(	type,
		value
	)	((type)(value))

#define png_aligncast	(	type,
		value
	)	((void*)(value))

#define png_aligncastconst	(	type,
		value
	)	((const void*)(value))

#define PNGFAPI PNGAPI

#define PNG_ABORT ( ) abort()

#define PNG_ALIGN_NONE 0 /* do not use data alignment */

#define PNG_ALIGN_ALWAYS 1 /* assume unaligned accesses are OK */

#define PNG_ALIGN_OFFSET -1 /* prevent the use of this */

#define PNG_ALIGN_SIZE 3 /* use sizeof to determine alignment */

#define PNG_ALIGN_TYPE PNG_ALIGN_SIZE

#define png_alignof ( type ) (sizeof (type))

#define png_isaligned	(	ptr,
		type
	)	((((const char)ptr-(const char)0) & (png_alignof(type)-1)) == 0)

#define PNG_HAVE_IDAT 0x04

#define PNG_HAVE_IEND 0x10

#define PNG_HAVE_CHUNK_HEADER 0x100

#define PNG_WROTE_tIME 0x200

#define PNG_WROTE_INFO_BEFORE_PLTE 0x400

#define PNG_BACKGROUND_IS_GRAY 0x800

#define PNG_HAVE_PNG_SIGNATURE 0x1000

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

#define PNG_IS_READ_STRUCT 0x8000 /* Else is a write struct */

#define PNG_BGR 0x0001

#define PNG_INTERLACE 0x0002

#define PNG_PACK 0x0004

#define PNG_SHIFT 0x0008

#define PNG_SWAP_BYTES 0x0010

#define PNG_INVERT_MONO 0x0020

#define PNG_QUANTIZE 0x0040

#define PNG_COMPOSE 0x0080 /* Was PNG_BACKGROUND */

#define PNG_BACKGROUND_EXPAND 0x0100

#define PNG_EXPAND_16 0x0200 /* Added to libpng 1.5.2 */

#define PNG_16_TO_8 0x0400 /* Becomes 'chop' in 1.5.4 */

#define PNG_RGBA 0x0800

#define PNG_EXPAND 0x1000

#define PNG_GAMMA 0x2000

#define PNG_GRAY_TO_RGB 0x4000

#define PNG_FILLER 0x8000

#define PNG_PACKSWAP 0x10000

#define PNG_SWAP_ALPHA 0x20000

#define PNG_STRIP_ALPHA 0x40000

#define PNG_INVERT_ALPHA 0x80000

#define PNG_USER_TRANSFORM 0x100000

#define PNG_RGB_TO_GRAY_ERR 0x200000

#define PNG_RGB_TO_GRAY_WARN 0x400000

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

#define PNG_ENCODE_ALPHA 0x800000 /* Added to libpng-1.5.4 */

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

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

#define PNG_SCALE_16_TO_8 0x4000000 /* Added to libpng-1.5.4 */

#define PNG_STRUCT_PNG 0x0001

#define PNG_STRUCT_INFO 0x0002

#define PNG_WEIGHT_FACTOR (1<<(PNG_WEIGHT_SHIFT))

#define PNG_COST_FACTOR (1<<(PNG_COST_SHIFT))

#define PNG_FLAG_ZLIB_CUSTOM_STRATEGY 0x0001

#define PNG_FLAG_ZSTREAM_INITIALIZED 0x0002 /* Added to libpng-1.6.0 */

#define PNG_FLAG_ZSTREAM_ENDED 0x0008 /* Added to libpng-1.6.0 */

#define PNG_FLAG_ROW_INIT 0x0040

#define PNG_FLAG_FILLER_AFTER 0x0080

#define PNG_FLAG_CRC_ANCILLARY_USE 0x0100

#define PNG_FLAG_CRC_ANCILLARY_NOWARN 0x0200

#define PNG_FLAG_CRC_CRITICAL_USE 0x0400

#define PNG_FLAG_CRC_CRITICAL_IGNORE 0x0800

#define PNG_FLAG_ASSUME_sRGB 0x1000 /* Added to libpng-1.5.4 */

#define PNG_FLAG_OPTIMIZE_ALPHA 0x2000 /* Added to libpng-1.5.4 */

#define PNG_FLAG_DETECT_UNINITIALIZED 0x4000 /* Added to libpng-1.5.4 */

#define PNG_FLAG_LIBRARY_MISMATCH 0x20000

#define PNG_FLAG_STRIP_ERROR_NUMBERS 0x40000

#define PNG_FLAG_STRIP_ERROR_TEXT 0x80000

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

#define PNG_FLAG_APP_WARNINGS_WARN 0x200000 /* Added to libpng-1.6.0 */

#define PNG_FLAG_APP_ERRORS_WARN 0x400000 /* Added to libpng-1.6.0 */

#define PNG_FLAG_CRC_ANCILLARY_MASK

Value:

(PNG_FLAG_CRC_ANCILLARY_USE | \

PNG_FLAG_CRC_ANCILLARY_NOWARN)

PNG_FLAG_CRC_ANCILLARY_USE

#define PNG_FLAG_CRC_ANCILLARY_USE

Definition: pngpriv.h:609

PNG_FLAG_CRC_ANCILLARY_NOWARN

#define PNG_FLAG_CRC_ANCILLARY_NOWARN

Definition: pngpriv.h:610

#define PNG_FLAG_CRC_CRITICAL_MASK

Value:

(PNG_FLAG_CRC_CRITICAL_USE | \

PNG_FLAG_CRC_CRITICAL_IGNORE)

PNG_FLAG_CRC_CRITICAL_IGNORE

#define PNG_FLAG_CRC_CRITICAL_IGNORE

Definition: pngpriv.h:612

PNG_FLAG_CRC_CRITICAL_USE

#define PNG_FLAG_CRC_CRITICAL_USE

Definition: pngpriv.h:611

#define PNG_FLAG_CRC_MASK

Value:

(PNG_FLAG_CRC_ANCILLARY_MASK | \

PNG_FLAG_CRC_CRITICAL_MASK)

PNG_FLAG_CRC_ANCILLARY_MASK

#define PNG_FLAG_CRC_ANCILLARY_MASK

Definition: pngpriv.h:633

PNG_FLAG_CRC_CRITICAL_MASK

#define PNG_FLAG_CRC_CRITICAL_MASK

Definition: pngpriv.h:636

#define PNG_COLOR_DIST	(	c1,
		c2
	)

Value:

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

#define PNG_DIV65535 ( v24 ) (((v24) + 32895) >> 16)

#define PNG_DIV257 ( v16 ) PNG_DIV65535((png_uint_32)(v16) * 255)

#define PNG_ROWBYTES	(	pixel_bits,
		width
	)

Value:

((pixel_bits) >= 8 ? \
    ((png_size_t)(width) * (((png_size_t)(pixel_bits)) >> 3)) : \
    (( ((png_size_t)(width) * ((png_size_t)(pixel_bits))) + 7) >> 3) )

#define PNG_OUT_OF_RANGE	(	value,
		ideal,
		delta
	)	( (value) < (ideal)-(delta) \|\| (value) > (ideal)+(delta) )

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

#define PNG_32b	(	b,
		s
	)	((png_uint_32)(b) << (s))

#define PNG_U32	(	b1,
		b2,
		b3,
		b4
	)	(PNG_32b(b1,24) \| PNG_32b(b2,16) \| PNG_32b(b3,8) \| PNG_32b(b4,0))

#define png_IDAT PNG_U32( 73, 68, 65, 84)

#define png_IEND PNG_U32( 73, 69, 78, 68)

#define png_IHDR PNG_U32( 73, 72, 68, 82)

#define png_PLTE PNG_U32( 80, 76, 84, 69)

#define png_bKGD PNG_U32( 98, 75, 71, 68)

#define png_cHRM PNG_U32( 99, 72, 82, 77)

#define png_fRAc PNG_U32(102, 82, 65, 99) /* registered, not defined */

#define png_gAMA PNG_U32(103, 65, 77, 65)

#define png_gIFg PNG_U32(103, 73, 70, 103)

#define png_gIFt PNG_U32(103, 73, 70, 116) /* deprecated */

#define png_gIFx PNG_U32(103, 73, 70, 120)

#define png_hIST PNG_U32(104, 73, 83, 84)

#define png_iCCP PNG_U32(105, 67, 67, 80)

#define png_iTXt PNG_U32(105, 84, 88, 116)

#define png_oFFs PNG_U32(111, 70, 70, 115)

#define png_pCAL PNG_U32(112, 67, 65, 76)

#define png_pHYs PNG_U32(112, 72, 89, 115)

#define png_sBIT PNG_U32(115, 66, 73, 84)

#define png_sCAL PNG_U32(115, 67, 65, 76)

#define png_sPLT PNG_U32(115, 80, 76, 84)

#define png_sRGB PNG_U32(115, 82, 71, 66)

#define png_sTER PNG_U32(115, 84, 69, 82)

#define png_tEXt PNG_U32(116, 69, 88, 116)

#define png_tIME PNG_U32(116, 73, 77, 69)

#define png_tRNS PNG_U32(116, 82, 78, 83)

#define png_zTXt PNG_U32(122, 84, 88, 116)

#define PNG_CHUNK_FROM_STRING ( s ) PNG_U32(0xff&(s)[0], 0xff&(s)[1], 0xff&(s)[2], 0xff&(s)[3])

#define PNG_STRING_FROM_CHUNK	(	s,
		c
	)

Value:

(void)(((char*)(s))[0]=(char)((c)>>24), ((char*)(s))[1]=(char)((c)>>16),\

((char*)(s))[2]=(char)((c)>>8), ((char*)(s))[3]=(char)((c)))

#define PNG_CSTRING_FROM_CHUNK	(	s,
		c
	)	(void)(PNG_STRING_FROM_CHUNK(s,c), ((char*)(s))[4] = 0)

#define PNG_CHUNK_ANCILLARY ( c ) (1 & ((c) >> 29))

#define PNG_CHUNK_CRITICAL ( c ) (!PNG_CHUNK_ANCILLARY(c))

#define PNG_CHUNK_PRIVATE ( c ) (1 & ((c) >> 21))

#define PNG_CHUNK_RESERVED ( c ) (1 & ((c) >> 13))

#define PNG_CHUNK_SAFE_TO_COPY ( c ) (1 & ((c) >> 5))

#define PNG_GAMMA_MAC_OLD 151724 /* Assume '1.8' is really 2.2/1.45! */

#define PNG_GAMMA_MAC_INVERSE 65909

#define PNG_GAMMA_sRGB_INVERSE 45455

#define PNG_sRGB_FROM_LINEAR ( linear )

Value:

((png_byte)((png_sRGB_base[(linear)>>15] +\

((((linear)&0x7fff)*png_sRGB_delta[(linear)>>15])>>12)) >> 8))

png_sRGB_delta

const png_byte png_sRGB_delta[512]

Definition: png.c:4366

png_sRGB_base

const png_uint_16 png_sRGB_base[512]

Definition: png.c:4298

#define PNG_UNEXPECTED_ZLIB_RETURN (-7)

#define PNG_USE_COMPILE_TIME_MASKS 1

#define PNG_FORMAT_NUMBER	(	buffer,
		format,
		number
	)	png_format_number(buffer, buffer + (sizeof buffer), format, number)

#define PNG_NUMBER_BUFFER_SIZE 24

#define PNG_NUMBER_FORMAT_u 1 /* chose unsigned API! */

#define PNG_NUMBER_FORMAT_02u 2

#define PNG_NUMBER_FORMAT_d 1 /* chose signed API! */

#define PNG_NUMBER_FORMAT_02d 2

#define PNG_NUMBER_FORMAT_x 3

#define PNG_NUMBER_FORMAT_02x 4

#define PNG_NUMBER_FORMAT_fixed 5 /* choose the signed API */

#define PNG_WARNING_PARAMETER_SIZE 32

#define PNG_WARNING_PARAMETER_COUNT 8 /* Maximum 9; see pngerror.c */

#define PNG_CHUNK_WARNING 0 /* never an error */

#define PNG_CHUNK_WRITE_ERROR 1 /* an error only on write */

#define PNG_CHUNK_ERROR 2 /* always an error */

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

#define PNG_FP_INTEGER 0 /* before or in integer */

#define PNG_FP_FRACTION 1 /* before or in fraction */

#define PNG_FP_EXPONENT 2 /* before or in exponent */

#define PNG_FP_STATE 3 /* mask for the above */

#define PNG_FP_SAW_SIGN 4 /* Saw +/- in current state */

#define PNG_FP_SAW_DIGIT 8 /* Saw a digit in current state */

#define PNG_FP_SAW_DOT 16 /* Saw a dot in current state */

#define PNG_FP_SAW_E 32 /* Saw an E (or e) in current state */

#define PNG_FP_SAW_ANY 60 /* Saw any of the above 4 */

#define PNG_FP_WAS_VALID 64 /* Preceding substring is a valid fp number */

#define PNG_FP_NEGATIVE 128 /* A negative number, including "-0" */

#define PNG_FP_NONZERO 256 /* A non-zero value */

#define PNG_FP_STICKY 448 /* The above three flags */

#define PNG_FP_INVALID 512 /* Available for callers as a distinct value */

#define PNG_FP_MAYBE 0 /* The number may be valid in the future */

#define PNG_FP_OK 1 /* The number is valid */

#define PNG_FP_NZ_MASK (PNG_FP_SAW_DIGIT | PNG_FP_NEGATIVE | PNG_FP_NONZERO)

#define PNG_FP_Z_MASK (PNG_FP_SAW_DIGIT | PNG_FP_NONZERO)

#define PNG_FP_IS_ZERO ( state ) (((state) & PNG_FP_Z_MASK) == PNG_FP_SAW_DIGIT)

#define PNG_FP_IS_POSITIVE ( state ) (((state) & PNG_FP_NZ_MASK) == PNG_FP_Z_MASK)

#define PNG_FP_IS_NEGATIVE ( state ) (((state) & PNG_FP_NZ_MASK) == PNG_FP_NZ_MASK)

#define png_control_jmp_buf ( pc ) ((pc)->error_buf)

Typedef Documentation

typedef const png_uint_16p* png_const_uint_16pp

typedef char png_warning_parameters[8][32]

typedef struct png_control png_control

Function Documentation

void png_zstream_error	(	png_structrp	png_ptr,
		int	ret
	)

 {
    /* Translate 'ret' into an appropriate error string, priority is given to the
     * one in zstream if set.  This always returns a string, even in cases like
     * Z_OK or Z_STREAM_END where the error code is a success code.
     */
    if (png_ptr->zstream.msg == NULL) switch (ret)
    {
       default:
       case Z_OK:
          png_ptr->zstream.msg = PNGZ_MSG_CAST("unexpected zlib return code");
          break;
 
       case Z_STREAM_END:
          /* Normal exit */
          png_ptr->zstream.msg = PNGZ_MSG_CAST("unexpected end of LZ stream");
          break;
 
       case Z_NEED_DICT:
          /* This means the deflate stream did not have a dictionary; this
           * indicates a bogus PNG.
           */
          png_ptr->zstream.msg = PNGZ_MSG_CAST("missing LZ dictionary");
          break;
 
       case Z_ERRNO:
          /* gz APIs only: should not happen */
          png_ptr->zstream.msg = PNGZ_MSG_CAST("zlib IO error");
          break;
 
       case Z_STREAM_ERROR:
          /* internal libpng error */
          png_ptr->zstream.msg = PNGZ_MSG_CAST("bad parameters to zlib");
          break;
 
       case Z_DATA_ERROR:
          png_ptr->zstream.msg = PNGZ_MSG_CAST("damaged LZ stream");
          break;
 
       case Z_MEM_ERROR:
          png_ptr->zstream.msg = PNGZ_MSG_CAST("insufficient memory");
          break;
 
       case Z_BUF_ERROR:
          /* End of input or output; not a problem if the caller is doing
           * incremental read or write.
           */
          png_ptr->zstream.msg = PNGZ_MSG_CAST("truncated");
          break;
 
       case Z_VERSION_ERROR:
          png_ptr->zstream.msg = PNGZ_MSG_CAST("unsupported zlib version");
          break;
 
       case PNG_UNEXPECTED_ZLIB_RETURN:
          /* Compile errors here mean that zlib now uses the value co-opted in
           * pngpriv.h for PNG_UNEXPECTED_ZLIB_RETURN; update the switch above
           * and change pngpriv.h.  Note that this message is "... return",
           * whereas the default/Z_OK one is "... return code".
           */
          png_ptr->zstream.msg = PNGZ_MSG_CAST("unexpected zlib return");
          break;
    }
 }

void png_free_buffer_list	(	png_structrp	png_ptr,
		png_compression_bufferp *	list
	)

 {
    png_compression_bufferp list = *listp;
 
    if (list != NULL)
    {
       *listp = NULL;
 
       do
       {
          png_compression_bufferp next = list->next;
 
          png_free(png_ptr, list);
          list = next;
       }
       while (list != NULL);
    }
 }

png_fixed_point png_fixed	(	png_const_structrp	png_ptr,
		double	fp,
		png_const_charp	text
	)

 {
    double r = floor(100000 * fp + .5);
 
    if (r > 2147483647. || r < -2147483648.)
       png_fixed_error(png_ptr, text);
 
 #  ifndef PNG_ERROR_TEXT_SUPPORTED
       PNG_UNUSED(text)
 #  endif
 
    return (png_fixed_point)r;
 }

int png_user_version_check	(	png_structrp	png_ptr,
		png_const_charp	user_png_ver
	)

 {
      /* Libpng versions 1.0.0 and later are binary compatible if the version
       * string matches through the second '.'; we must recompile any
       * applications that use any older library version.
       */
 
    if (user_png_ver != NULL)
    {
       int i = -1;
       int found_dots = 0;
 
       do
       {
          i++;
          if (user_png_ver[i] != PNG_LIBPNG_VER_STRING[i])
             png_ptr->flags |= PNG_FLAG_LIBRARY_MISMATCH;
          if (user_png_ver[i] == '.')
             found_dots++;
       } while (found_dots < 2 && user_png_ver[i] != 0 &&
             PNG_LIBPNG_VER_STRING[i] != 0);
    }
 
    else
       png_ptr->flags |= PNG_FLAG_LIBRARY_MISMATCH;
 
    if ((png_ptr->flags & PNG_FLAG_LIBRARY_MISMATCH) != 0)
    {
 #ifdef PNG_WARNINGS_SUPPORTED
       size_t pos = 0;
       char m[128];
 
       pos = png_safecat(m, (sizeof m), pos,
           "Application built with libpng-");
       pos = png_safecat(m, (sizeof m), pos, user_png_ver);
       pos = png_safecat(m, (sizeof m), pos, " but running with ");
       pos = png_safecat(m, (sizeof m), pos, PNG_LIBPNG_VER_STRING);
       PNG_UNUSED(pos)
 
       png_warning(png_ptr, m);
 #endif
 
 #ifdef PNG_ERROR_NUMBERS_SUPPORTED
       png_ptr->flags = 0;
 #endif
 
       return 0;
    }
 
    /* Success return. */
    return 1;
 }

png_voidp png_malloc_base	(	png_const_structrp	png_ptr,
		png_alloc_size_t	size
	)

 {
    /* Moved to png_malloc_base from png_malloc_default in 1.6.0; the DOS
     * allocators have also been removed in 1.6.0, so any 16-bit system now has
     * to implement a user memory handler.  This checks to be sure it isn't
     * called with big numbers.
     */
 #ifndef PNG_USER_MEM_SUPPORTED
    PNG_UNUSED(png_ptr)
 #endif
 
    if (size > 0 && size <= PNG_SIZE_MAX
 #     ifdef PNG_MAX_MALLOC_64K
          && size <= 65536U
 #     endif
       )
    {
 #ifdef PNG_USER_MEM_SUPPORTED
       if (png_ptr != NULL && png_ptr->malloc_fn != NULL)
          return png_ptr->malloc_fn(png_constcast(png_structrp,png_ptr), size);
 
       else
 #endif
          return malloc((size_t)size); /* checked for truncation above */
    }
 
    else
       return NULL;
 }

png_voidp png_malloc_array	(	png_const_structrp	png_ptr,
		int	nelements,
		size_t	element_size
	)

 {
    if (nelements <= 0 || element_size == 0)
       png_error(png_ptr, "internal error: array alloc");
 
    return png_malloc_array_checked(png_ptr, nelements, element_size);
 }

png_voidp png_realloc_array	(	png_const_structrp	png_ptr,
		png_const_voidp	array,
		int	old_elements,
		int	add_elements,
		size_t	element_size
	)

 {
    /* These are internal errors: */
    if (add_elements <= 0 || element_size == 0 || old_elements < 0 ||
       (old_array == NULL && old_elements > 0))
       png_error(png_ptr, "internal error: array realloc");
 
    /* Check for overflow on the elements count (so the caller does not have to
     * check.)
     */
    if (add_elements <= INT_MAX - old_elements)
    {
       png_voidp new_array = png_malloc_array_checked(png_ptr,
          old_elements+add_elements, element_size);
 
       if (new_array != NULL)
       {
          /* Because png_malloc_array worked the size calculations below cannot
           * overflow.
           */
          if (old_elements > 0)
             memcpy(new_array, old_array, element_size*(unsigned)old_elements);
 
          memset((char*)new_array + element_size*(unsigned)old_elements, 0,
             element_size*(unsigned)add_elements);
 
          return new_array;
       }
    }
 
    return NULL; /* error */
 }

png_structp png_create_png_struct	(	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_struct create_struct;
 #  ifdef PNG_SETJMP_SUPPORTED
       jmp_buf create_jmp_buf;
 #  endif
 
    /* This temporary stack-allocated structure is used to provide a place to
     * build enough context to allow the user provided memory allocator (if any)
     * to be called.
     */
    memset(&create_struct, 0, (sizeof create_struct));
 
    /* Added at libpng-1.2.6 */
 #  ifdef PNG_USER_LIMITS_SUPPORTED
       create_struct.user_width_max = PNG_USER_WIDTH_MAX;
       create_struct.user_height_max = PNG_USER_HEIGHT_MAX;
 
 #     ifdef PNG_USER_CHUNK_CACHE_MAX
          /* Added at libpng-1.2.43 and 1.4.0 */
          create_struct.user_chunk_cache_max = PNG_USER_CHUNK_CACHE_MAX;
 #     endif
 
 #     ifdef PNG_USER_CHUNK_MALLOC_MAX
          /* Added at libpng-1.2.43 and 1.4.1, required only for read but exists
           * in png_struct regardless.
           */
          create_struct.user_chunk_malloc_max = PNG_USER_CHUNK_MALLOC_MAX;
 #     endif
 #  endif
 
    /* The following two API calls simply set fields in png_struct, so it is safe
     * to do them now even though error handling is not yet set up.
     */
 #  ifdef PNG_USER_MEM_SUPPORTED
       png_set_mem_fn(&create_struct, mem_ptr, malloc_fn, free_fn);
 #  else
       PNG_UNUSED(mem_ptr)
       PNG_UNUSED(malloc_fn)
       PNG_UNUSED(free_fn)
 #  endif
 
    /* (*error_fn) can return control to the caller after the error_ptr is set,
     * this will result in a memory leak unless the error_fn does something
     * extremely sophisticated.  The design lacks merit but is implicit in the
     * API.
     */
    png_set_error_fn(&create_struct, error_ptr, error_fn, warn_fn);
 
 #  ifdef PNG_SETJMP_SUPPORTED
       if (!setjmp(create_jmp_buf))
       {
          /* Temporarily fake out the longjmp information until we have
           * successfully completed this function.  This only works if we have
           * setjmp() support compiled in, but it is safe - this stuff should
           * never happen.
           */
          create_struct.jmp_buf_ptr = &create_jmp_buf;
          create_struct.jmp_buf_size = 0; /*stack allocation*/
          create_struct.longjmp_fn = longjmp;
 #  else
       {
 #  endif
          /* Call the general version checker (shared with read and write code):
           */
          if (png_user_version_check(&create_struct, user_png_ver) != 0)
          {
             png_structrp png_ptr = png_voidcast(png_structrp,
                png_malloc_warn(&create_struct, (sizeof *png_ptr)));
 
             if (png_ptr != NULL)
             {
                /* png_ptr->zstream holds a back-pointer to the png_struct, so
                 * this can only be done now:
                 */
                create_struct.zstream.zalloc = png_zalloc;
                create_struct.zstream.zfree = png_zfree;
                create_struct.zstream.opaque = png_ptr;
 
 #              ifdef PNG_SETJMP_SUPPORTED
                   /* Eliminate the local error handling: */
                   create_struct.jmp_buf_ptr = NULL;
                   create_struct.jmp_buf_size = 0;
                   create_struct.longjmp_fn = 0;
 #              endif
 
                *png_ptr = create_struct;
 
                /* This is the successful return point */
                return png_ptr;
             }
          }
       }
 
    /* A longjmp because of a bug in the application storage allocator or a
     * simple failure to allocate the png_struct.
     */
    return NULL;
 }

void png_destroy_png_struct ( png_structrp png_ptr )

 {
    if (png_ptr != NULL)
    {
       /* png_free might call png_error and may certainly call
        * png_get_mem_ptr, so fake a temporary png_struct to support this.
        */
       png_struct dummy_struct = *png_ptr;
       memset(png_ptr, 0, (sizeof *png_ptr));
       png_free(&dummy_struct, png_ptr);
 
 #     ifdef PNG_SETJMP_SUPPORTED
          /* We may have a jmp_buf left to deallocate. */
          png_free_jmpbuf(&dummy_struct);
 #     endif
    }
 }

void png_free_jmpbuf ( png_structrp png_ptr )

 {
    if (png_ptr != NULL)
    {
       jmp_buf *jb = png_ptr->jmp_buf_ptr;
 
       /* A size of 0 is used to indicate a local, stack, allocation of the
        * pointer; used here and in png.c
        */
       if (jb != NULL && png_ptr->jmp_buf_size > 0)
       {
 
          /* This stuff is so that a failure to free the error control structure
           * does not leave libpng in a state with no valid error handling: the
           * free always succeeds, if there is an error it gets ignored.
           */
          if (jb != &png_ptr->jmp_buf_local)
          {
             /* Make an internal, libpng, jmp_buf to return here */
             jmp_buf free_jmp_buf;
 
             if (!setjmp(free_jmp_buf))
             {
                png_ptr->jmp_buf_ptr = &free_jmp_buf; /* come back here */
                png_ptr->jmp_buf_size = 0; /* stack allocation */
                png_ptr->longjmp_fn = longjmp;
                png_free(png_ptr, jb); /* Return to setjmp on error */
             }
          }
       }
 
       /* *Always* cancel everything out: */
       png_ptr->jmp_buf_size = 0;
       png_ptr->jmp_buf_ptr = NULL;
       png_ptr->longjmp_fn = 0;
    }
 }

voidpf png_zalloc	(	voidpf	png_ptr,
		uInt	items,
		uInt	size
	)

 {
    png_alloc_size_t num_bytes = size;
 
    if (png_ptr == NULL)
       return NULL;
 
    if (items >= (~(png_alloc_size_t)0)/size)
    {
       png_warning (png_voidcast(png_structrp, png_ptr),
          "Potential overflow in png_zalloc()");
       return NULL;
    }
 
    num_bytes *= items;
    return png_malloc_warn(png_voidcast(png_structrp, png_ptr), num_bytes);
 }

void png_zfree	(	voidpf	png_ptr,
		voidpf	ptr
	)

 {
    png_free(png_voidcast(png_const_structrp,png_ptr), ptr);
 }

void png_default_read_data	(	png_structp	png_ptr,
		png_bytep	data,
		png_size_t	length
	)

 {
    png_size_t check;
 
    if (png_ptr == NULL)
       return;
 
    /* fread() returns 0 on error, so it is OK to store this in a png_size_t
     * instead of an int, which is what fread() actually returns.
     */
    check = fread(data, 1, length, png_voidcast(png_FILE_p, png_ptr->io_ptr));
 
    if (check != length)
       png_error(png_ptr, "Read Error");
 }

void png_push_fill_buffer	(	png_structp	png_ptr,
		png_bytep	buffer,
		png_size_t	length
	)

 {
    png_bytep ptr;
 
    if (png_ptr == NULL)
       return;
 
    ptr = buffer;
    if (png_ptr->save_buffer_size != 0)
    {
       png_size_t save_size;
 
       if (length < png_ptr->save_buffer_size)
          save_size = length;
 
       else
          save_size = png_ptr->save_buffer_size;
 
       memcpy(ptr, png_ptr->save_buffer_ptr, save_size);
       length -= save_size;
       ptr += save_size;
       png_ptr->buffer_size -= save_size;
       png_ptr->save_buffer_size -= save_size;
       png_ptr->save_buffer_ptr += save_size;
    }
    if (length != 0 && png_ptr->current_buffer_size != 0)
    {
       png_size_t save_size;
 
       if (length < png_ptr->current_buffer_size)
          save_size = length;
 
       else
          save_size = png_ptr->current_buffer_size;
 
       memcpy(ptr, png_ptr->current_buffer_ptr, save_size);
       png_ptr->buffer_size -= save_size;
       png_ptr->current_buffer_size -= save_size;
       png_ptr->current_buffer_ptr += save_size;
    }
 }

void png_default_write_data	(	png_structp	png_ptr,
		png_bytep	data,
		png_size_t	length
	)

 {
    png_size_t check;
 
    if (png_ptr == NULL)
       return;
 
    check = fwrite(data, 1, length, (png_FILE_p)(png_ptr->io_ptr));
 
    if (check != length)
       png_error(png_ptr, "Write Error");
 }

void png_default_flush ( png_structp png_ptr )

 {
    png_FILE_p io_ptr;
 
    if (png_ptr == NULL)
       return;
 
    io_ptr = png_voidcast(png_FILE_p, (png_ptr->io_ptr));
    fflush(io_ptr);
 }

void png_reset_crc ( png_structrp png_ptr )

 {
    /* The cast is safe because the crc is a 32 bit value. */
    png_ptr->crc = (png_uint_32)crc32(0, Z_NULL, 0);
 }

void png_write_data	(	png_structrp	png_ptr,
		png_const_bytep	data,
		png_size_t	length
	)

 {
    /* NOTE: write_data_fn must not change the buffer! */
    if (png_ptr->write_data_fn != NULL )
       (*(png_ptr->write_data_fn))(png_ptr, png_constcast(png_bytep,data),
          length);
 
    else
       png_error(png_ptr, "Call to NULL write function");
 }

void png_read_sig	(	png_structrp	png_ptr,
		png_inforp	info_ptr
	)

 {
    png_size_t num_checked, num_to_check;
 
    /* Exit if the user application does not expect a signature. */
    if (png_ptr->sig_bytes >= 8)
       return;
 
    num_checked = png_ptr->sig_bytes;
    num_to_check = 8 - num_checked;
 
 #ifdef PNG_IO_STATE_SUPPORTED
    png_ptr->io_state = PNG_IO_READING | PNG_IO_SIGNATURE;
 #endif
 
    /* The signature must be serialized in a single I/O call. */
    png_read_data(png_ptr, &(info_ptr->signature[num_checked]), num_to_check);
    png_ptr->sig_bytes = 8;
 
    if (png_sig_cmp(info_ptr->signature, num_checked, num_to_check) != 0)
    {
       if (num_checked < 4 &&
           png_sig_cmp(info_ptr->signature, num_checked, num_to_check - 4))
          png_error(png_ptr, "Not a PNG file");
       else
          png_error(png_ptr, "PNG file corrupted by ASCII conversion");
    }
    if (num_checked < 3)
       png_ptr->mode |= PNG_HAVE_PNG_SIGNATURE;
 }

png_uint_32 png_read_chunk_header ( png_structrp png_ptr )

 {
    png_byte buf[8];
    png_uint_32 length;
 
 #ifdef PNG_IO_STATE_SUPPORTED
    png_ptr->io_state = PNG_IO_READING | PNG_IO_CHUNK_HDR;
 #endif
 
    /* Read the length and the chunk name.
     * This must be performed in a single I/O call.
     */
    png_read_data(png_ptr, buf, 8);
    length = png_get_uint_31(png_ptr, buf);
 
    /* Put the chunk name into png_ptr->chunk_name. */
    png_ptr->chunk_name = PNG_CHUNK_FROM_STRING(buf+4);
 
    png_debug2(0, "Reading %lx chunk, length = %lu",
        (unsigned long)png_ptr->chunk_name, (unsigned long)length);
 
    /* Reset the crc and run it over the chunk name. */
    png_reset_crc(png_ptr);
    png_calculate_crc(png_ptr, buf + 4, 4);
 
    /* Check to see if chunk name is valid. */
    png_check_chunk_name(png_ptr, png_ptr->chunk_name);
 
 #ifdef PNG_IO_STATE_SUPPORTED
    png_ptr->io_state = PNG_IO_READING | PNG_IO_CHUNK_DATA;
 #endif
 
    return length;
 }

void png_read_data	(	png_structrp	png_ptr,
		png_bytep	data,
		png_size_t	length
	)

 {
    png_debug1(4, "reading %d bytes", (int)length);
 
    if (png_ptr->read_data_fn != NULL)
       (*(png_ptr->read_data_fn))(png_ptr, data, length);
 
    else
       png_error(png_ptr, "Call to NULL read function");
 }

void png_crc_read	(	png_structrp	png_ptr,
		png_bytep	buf,
		png_uint_32	length
	)

 {
    if (png_ptr == NULL)
       return;
 
    png_read_data(png_ptr, buf, length);
    png_calculate_crc(png_ptr, buf, length);
 }

int png_crc_finish	(	png_structrp	png_ptr,
		png_uint_32	skip
	)

 {
    /* The size of the local buffer for inflate is a good guess as to a
     * reasonable size to use for buffering reads from the application.
     */
    while (skip > 0)
    {
       png_uint_32 len;
       png_byte tmpbuf[PNG_INFLATE_BUF_SIZE];
 
       len = (sizeof tmpbuf);
       if (len > skip)
          len = skip;
       skip -= len;
 
       png_crc_read(png_ptr, tmpbuf, len);
    }
 
    if (png_crc_error(png_ptr) != 0)
    {
       if (PNG_CHUNK_ANCILLARY(png_ptr->chunk_name) != 0 ?
           (png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_NOWARN) == 0 :
           (png_ptr->flags & PNG_FLAG_CRC_CRITICAL_USE) != 0)
       {
          png_chunk_warning(png_ptr, "CRC error");
       }
 
       else
          png_chunk_error(png_ptr, "CRC error");
 
       return (1);
    }
 
    return (0);
 }

int png_crc_error ( png_structrp png_ptr )

 {
    png_byte crc_bytes[4];
    png_uint_32 crc;
    int need_crc = 1;
 
    if (PNG_CHUNK_ANCILLARY(png_ptr->chunk_name) != 0)
    {
       if ((png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_MASK) ==
           (PNG_FLAG_CRC_ANCILLARY_USE | PNG_FLAG_CRC_ANCILLARY_NOWARN))
          need_crc = 0;
    }
 
    else /* critical */
    {
       if ((png_ptr->flags & PNG_FLAG_CRC_CRITICAL_IGNORE) != 0)
          need_crc = 0;
    }
 
 #ifdef PNG_IO_STATE_SUPPORTED
    png_ptr->io_state = PNG_IO_READING | PNG_IO_CHUNK_CRC;
 #endif
 
    /* The chunk CRC must be serialized in a single I/O call. */
    png_read_data(png_ptr, crc_bytes, 4);
 
    if (need_crc != 0)
    {
       crc = png_get_uint_32(crc_bytes);
       return ((int)(crc != png_ptr->crc));
    }
 
    else
       return (0);
 }

void png_calculate_crc	(	png_structrp	png_ptr,
		png_const_bytep	ptr,
		png_size_t	length
	)

 {
    int need_crc = 1;
 
    if (PNG_CHUNK_ANCILLARY(png_ptr->chunk_name) != 0)
    {
       if ((png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_MASK) ==
           (PNG_FLAG_CRC_ANCILLARY_USE | PNG_FLAG_CRC_ANCILLARY_NOWARN))
          need_crc = 0;
    }
 
    else /* critical */
    {
       if ((png_ptr->flags & PNG_FLAG_CRC_CRITICAL_IGNORE) != 0)
          need_crc = 0;
    }
 
    /* 'uLong' is defined in zlib.h as unsigned long; this means that on some
     * systems it is a 64 bit value.  crc32, however, returns 32 bits so the
     * following cast is safe.  'uInt' may be no more than 16 bits, so it is
     * necessary to perform a loop here.
     */
    if (need_crc != 0 && length > 0)
    {
       uLong crc = png_ptr->crc; /* Should never issue a warning */
 
       do
       {
          uInt safe_length = (uInt)length;
          if (safe_length == 0)
             safe_length = (uInt)-1; /* evil, but safe */
 
          crc = crc32(crc, ptr, safe_length);
 
          /* The following should never issue compiler warnings; if they do the
           * target system has characteristics that will probably violate other
           * assumptions within the libpng code.
           */
          ptr += safe_length;
          length -= safe_length;
       }
       while (length > 0);
 
       /* And the following is always safe because the crc is only 32 bits. */
       png_ptr->crc = (png_uint_32)crc;
    }
 }

void png_flush ( png_structrp png_ptr )

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

void png_write_IHDR	(	png_structrp	png_ptr,
		png_uint_32	width,
		png_uint_32	height,
		int	bit_depth,
		int	color_type,
		int	compression_method,
		int	filter_method,
		int	interlace_method
	)

 {
    png_byte buf[13]; /* Buffer to store the IHDR info */
 
    png_debug(1, "in png_write_IHDR");
 
    /* Check that we have valid input data from the application info */
    switch (color_type)
    {
       case PNG_COLOR_TYPE_GRAY:
          switch (bit_depth)
          {
             case 1:
             case 2:
             case 4:
             case 8:
 #ifdef PNG_WRITE_16BIT_SUPPORTED
             case 16:
 #endif
                png_ptr->channels = 1; break;
 
             default:
                png_error(png_ptr,
                    "Invalid bit depth for grayscale image");
          }
          break;
 
       case PNG_COLOR_TYPE_RGB:
 #ifdef PNG_WRITE_16BIT_SUPPORTED
          if (bit_depth != 8 && bit_depth != 16)
 #else
          if (bit_depth != 8)
 #endif
             png_error(png_ptr, "Invalid bit depth for RGB image");
 
          png_ptr->channels = 3;
          break;
 
       case PNG_COLOR_TYPE_PALETTE:
          switch (bit_depth)
          {
             case 1:
             case 2:
             case 4:
             case 8:
                png_ptr->channels = 1;
                break;
 
             default:
                png_error(png_ptr, "Invalid bit depth for paletted image");
          }
          break;
 
       case PNG_COLOR_TYPE_GRAY_ALPHA:
          if (bit_depth != 8 && bit_depth != 16)
             png_error(png_ptr, "Invalid bit depth for grayscale+alpha image");
 
          png_ptr->channels = 2;
          break;
 
       case PNG_COLOR_TYPE_RGB_ALPHA:
 #ifdef PNG_WRITE_16BIT_SUPPORTED
          if (bit_depth != 8 && bit_depth != 16)
 #else
          if (bit_depth != 8)
 #endif
             png_error(png_ptr, "Invalid bit depth for RGBA image");
 
          png_ptr->channels = 4;
          break;
 
       default:
          png_error(png_ptr, "Invalid image color type specified");
    }
 
    if (compression_type != PNG_COMPRESSION_TYPE_BASE)
    {
       png_warning(png_ptr, "Invalid compression type specified");
       compression_type = PNG_COMPRESSION_TYPE_BASE;
    }
 
    /* 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 (
 #ifdef PNG_MNG_FEATURES_SUPPORTED
        !((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) != 0 &&
        ((png_ptr->mode & PNG_HAVE_PNG_SIGNATURE) == 0) &&
        (color_type == PNG_COLOR_TYPE_RGB ||
         color_type == PNG_COLOR_TYPE_RGB_ALPHA) &&
        (filter_type == PNG_INTRAPIXEL_DIFFERENCING)) &&
 #endif
        filter_type != PNG_FILTER_TYPE_BASE)
    {
       png_warning(png_ptr, "Invalid filter type specified");
       filter_type = PNG_FILTER_TYPE_BASE;
    }
 
 #ifdef PNG_WRITE_INTERLACING_SUPPORTED
    if (interlace_type != PNG_INTERLACE_NONE &&
        interlace_type != PNG_INTERLACE_ADAM7)
    {
       png_warning(png_ptr, "Invalid interlace type specified");
       interlace_type = PNG_INTERLACE_ADAM7;
    }
 #else
    interlace_type=PNG_INTERLACE_NONE;
 #endif
 
    /* Save the relevent information */
    png_ptr->bit_depth = (png_byte)bit_depth;
    png_ptr->color_type = (png_byte)color_type;
    png_ptr->interlaced = (png_byte)interlace_type;
 #ifdef PNG_MNG_FEATURES_SUPPORTED
    png_ptr->filter_type = (png_byte)filter_type;
 #endif
    png_ptr->compression_type = (png_byte)compression_type;
    png_ptr->width = width;
    png_ptr->height = height;
 
    png_ptr->pixel_depth = (png_byte)(bit_depth * png_ptr->channels);
    png_ptr->rowbytes = PNG_ROWBYTES(png_ptr->pixel_depth, width);
    /* Set the usr info, so any transformations can modify it */
    png_ptr->usr_width = png_ptr->width;
    png_ptr->usr_bit_depth = png_ptr->bit_depth;
    png_ptr->usr_channels = png_ptr->channels;
 
    /* Pack the header information into the buffer */
    png_save_uint_32(buf, width);
    png_save_uint_32(buf + 4, height);
    buf[8] = (png_byte)bit_depth;
    buf[9] = (png_byte)color_type;
    buf[10] = (png_byte)compression_type;
    buf[11] = (png_byte)filter_type;
    buf[12] = (png_byte)interlace_type;
 
    /* Write the chunk */
    png_write_complete_chunk(png_ptr, png_IHDR, buf, (png_size_t)13);
 
    if ((png_ptr->do_filter) == PNG_NO_FILTERS)
    {
       if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE ||
           png_ptr->bit_depth < 8)
          png_ptr->do_filter = PNG_FILTER_NONE;
 
       else
          png_ptr->do_filter = PNG_ALL_FILTERS;
    }
 
    png_ptr->mode = PNG_HAVE_IHDR; /* not READY_FOR_ZTXT */
 }

void png_write_PLTE	(	png_structrp	png_ptr,
		png_const_colorp	palette,
		png_uint_32	num_pal
	)

 {
    png_uint_32 i;
    png_const_colorp pal_ptr;
    png_byte buf[3];
 
    png_debug(1, "in png_write_PLTE");
 
    if ((
 #ifdef PNG_MNG_FEATURES_SUPPORTED
        (png_ptr->mng_features_permitted & PNG_FLAG_MNG_EMPTY_PLTE) == 0 &&
 #endif
        num_pal == 0) || num_pal > 256)
    {
       if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
       {
          png_error(png_ptr, "Invalid number of colors in palette");
       }
 
       else
       {
          png_warning(png_ptr, "Invalid number of colors in palette");
          return;
       }
    }
 
    if ((png_ptr->color_type & PNG_COLOR_MASK_COLOR) == 0)
    {
       png_warning(png_ptr,
           "Ignoring request to write a PLTE chunk in grayscale PNG");
 
       return;
    }
 
    png_ptr->num_palette = (png_uint_16)num_pal;
    png_debug1(3, "num_palette = %d", png_ptr->num_palette);
 
    png_write_chunk_header(png_ptr, png_PLTE, (png_uint_32)(num_pal * 3));
 #ifdef PNG_POINTER_INDEXING_SUPPORTED
 
    for (i = 0, pal_ptr = palette; i < num_pal; i++, pal_ptr++)
    {
       buf[0] = pal_ptr->red;
       buf[1] = pal_ptr->green;
       buf[2] = pal_ptr->blue;
       png_write_chunk_data(png_ptr, buf, (png_size_t)3);
    }
 
 #else
    /* This is a little slower but some buggy compilers need to do this
     * instead
     */
    pal_ptr=palette;
 
    for (i = 0; i < num_pal; i++)
    {
       buf[0] = pal_ptr[i].red;
       buf[1] = pal_ptr[i].green;
       buf[2] = pal_ptr[i].blue;
       png_write_chunk_data(png_ptr, buf, (png_size_t)3);
    }
 
 #endif
    png_write_chunk_end(png_ptr);
    png_ptr->mode |= PNG_HAVE_PLTE;
 }

void png_compress_IDAT	(	png_structrp	png_ptr,
		png_const_bytep	row_data,
		png_alloc_size_t	row_data_length,
		int	flush
	)

 {
    if (png_ptr->zowner != png_IDAT)
    {
       /* First time.   Ensure we have a temporary buffer for compression and
        * trim the buffer list if it has more than one entry to free memory.
        * If 'WRITE_COMPRESSED_TEXT' is not set the list will never have been
        * created at this point, but the check here is quick and safe.
        */
       if (png_ptr->zbuffer_list == NULL)
       {
          png_ptr->zbuffer_list = png_voidcast(png_compression_bufferp,
             png_malloc(png_ptr, PNG_COMPRESSION_BUFFER_SIZE(png_ptr)));
          png_ptr->zbuffer_list->next = NULL;
       }
 
       else
          png_free_buffer_list(png_ptr, &png_ptr->zbuffer_list->next);
 
       /* It is a terminal error if we can't claim the zstream. */
       if (png_deflate_claim(png_ptr, png_IDAT, png_image_size(png_ptr)) != Z_OK)
          png_error(png_ptr, png_ptr->zstream.msg);
 
       /* The output state is maintained in png_ptr->zstream, so it must be
        * initialized here after the claim.
        */
       png_ptr->zstream.next_out = png_ptr->zbuffer_list->output;
       png_ptr->zstream.avail_out = png_ptr->zbuffer_size;
    }
 
    /* Now loop reading and writing until all the input is consumed or an error
     * terminates the operation.  The _out values are maintained across calls to
     * this function, but the input must be reset each time.
     */
    png_ptr->zstream.next_in = PNGZ_INPUT_CAST(input);
    png_ptr->zstream.avail_in = 0; /* set below */
    for (;;)
    {
       int ret;
 
       /* INPUT: from the row data */
       uInt avail = ZLIB_IO_MAX;
 
       if (avail > input_len)
          avail = (uInt)input_len; /* safe because of the check */
 
       png_ptr->zstream.avail_in = avail;
       input_len -= avail;
 
       ret = deflate(&png_ptr->zstream, input_len > 0 ? Z_NO_FLUSH : flush);
 
       /* Include as-yet unconsumed input */
       input_len += png_ptr->zstream.avail_in;
       png_ptr->zstream.avail_in = 0;
 
       /* OUTPUT: write complete IDAT chunks when avail_out drops to zero. Note
        * that these two zstream fields are preserved across the calls, therefore
        * there is no need to set these up on entry to the loop.
        */
       if (png_ptr->zstream.avail_out == 0)
       {
          png_bytep data = png_ptr->zbuffer_list->output;
          uInt size = png_ptr->zbuffer_size;
 
          /* Write an IDAT containing the data then reset the buffer.  The
           * first IDAT may need deflate header optimization.
           */
 #ifdef PNG_WRITE_OPTIMIZE_CMF_SUPPORTED
             if ((png_ptr->mode & PNG_HAVE_IDAT) == 0 &&
                 png_ptr->compression_type == PNG_COMPRESSION_TYPE_BASE)
                optimize_cmf(data, png_image_size(png_ptr));
 #endif
 
          png_write_complete_chunk(png_ptr, png_IDAT, data, size);
          png_ptr->mode |= PNG_HAVE_IDAT;
 
          png_ptr->zstream.next_out = data;
          png_ptr->zstream.avail_out = size;
 
          /* For SYNC_FLUSH or FINISH it is essential to keep calling zlib with
           * the same flush parameter until it has finished output, for NO_FLUSH
           * it doesn't matter.
           */
          if (ret == Z_OK && flush != Z_NO_FLUSH)
             continue;
       }
 
       /* The order of these checks doesn't matter much; it just affects which
        * possible error might be detected if multiple things go wrong at once.
        */
       if (ret == Z_OK) /* most likely return code! */
       {
          /* If all the input has been consumed then just return.  If Z_FINISH
           * was used as the flush parameter something has gone wrong if we get
           * here.
           */
          if (input_len == 0)
          {
             if (flush == Z_FINISH)
                png_error(png_ptr, "Z_OK on Z_FINISH with output space");
 
             return;
          }
       }
 
       else if (ret == Z_STREAM_END && flush == Z_FINISH)
       {
          /* This is the end of the IDAT data; any pending output must be
           * flushed.  For small PNG files we may still be at the beginning.
           */
          png_bytep data = png_ptr->zbuffer_list->output;
          uInt size = png_ptr->zbuffer_size - png_ptr->zstream.avail_out;
 
 #ifdef PNG_WRITE_OPTIMIZE_CMF_SUPPORTED
          if ((png_ptr->mode & PNG_HAVE_IDAT) == 0 &&
              png_ptr->compression_type == PNG_COMPRESSION_TYPE_BASE)
             optimize_cmf(data, png_image_size(png_ptr));
 #endif
 
          png_write_complete_chunk(png_ptr, png_IDAT, data, size);
          png_ptr->zstream.avail_out = 0;
          png_ptr->zstream.next_out = NULL;
          png_ptr->mode |= PNG_HAVE_IDAT | PNG_AFTER_IDAT;
 
          png_ptr->zowner = 0; /* Release the stream */
          return;
       }
 
       else
       {
          /* This is an error condition. */
          png_zstream_error(png_ptr, ret);
          png_error(png_ptr, png_ptr->zstream.msg);
       }
    }
 }

void png_write_IEND ( png_structrp png_ptr )

 {
    png_debug(1, "in png_write_IEND");
 
    png_write_complete_chunk(png_ptr, png_IEND, NULL, (png_size_t)0);
    png_ptr->mode |= PNG_HAVE_IEND;
 }

void png_write_gAMA_fixed	(	png_structrp	png_ptr,
		png_fixed_point	file_gamma
	)

 {
    png_byte buf[4];
 
    png_debug(1, "in png_write_gAMA");
 
    /* file_gamma is saved in 1/100,000ths */
    png_save_uint_32(buf, (png_uint_32)file_gamma);
    png_write_complete_chunk(png_ptr, png_gAMA, buf, (png_size_t)4);
 }

void png_write_sBIT	(	png_structrp	png_ptr,
		png_const_color_8p	sbit,
		int	color_type
	)

 {
    png_byte buf[4];
    png_size_t size;
 
    png_debug(1, "in png_write_sBIT");
 
    /* Make sure we don't depend upon the order of PNG_COLOR_8 */
    if ((color_type & PNG_COLOR_MASK_COLOR) != 0)
    {
       png_byte maxbits;
 
       maxbits = (png_byte)(color_type==PNG_COLOR_TYPE_PALETTE ? 8 :
           png_ptr->usr_bit_depth);
 
       if (sbit->red == 0 || sbit->red > maxbits ||
           sbit->green == 0 || sbit->green > maxbits ||
           sbit->blue == 0 || sbit->blue > maxbits)
       {
          png_warning(png_ptr, "Invalid sBIT depth specified");
          return;
       }
 
       buf[0] = sbit->red;
       buf[1] = sbit->green;
       buf[2] = sbit->blue;
       size = 3;
    }
 
    else
    {
       if (sbit->gray == 0 || sbit->gray > png_ptr->usr_bit_depth)
       {
          png_warning(png_ptr, "Invalid sBIT depth specified");
          return;
       }
 
       buf[0] = sbit->gray;
       size = 1;
    }
 
    if ((color_type & PNG_COLOR_MASK_ALPHA) != 0)
    {
       if (sbit->alpha == 0 || sbit->alpha > png_ptr->usr_bit_depth)
       {
          png_warning(png_ptr, "Invalid sBIT depth specified");
          return;
       }
 
       buf[size++] = sbit->alpha;
    }
 
    png_write_complete_chunk(png_ptr, png_sBIT, buf, size);
 }

void png_write_cHRM_fixed	(	png_structrp	png_ptr,
		const png_xy *	xy
	)

 {
    png_byte buf[32];
 
    png_debug(1, "in png_write_cHRM");
 
    /* Each value is saved in 1/100,000ths */
    png_save_int_32(buf,      xy->whitex);
    png_save_int_32(buf +  4, xy->whitey);
 
    png_save_int_32(buf +  8, xy->redx);
    png_save_int_32(buf + 12, xy->redy);
 
    png_save_int_32(buf + 16, xy->greenx);
    png_save_int_32(buf + 20, xy->greeny);
 
    png_save_int_32(buf + 24, xy->bluex);
    png_save_int_32(buf + 28, xy->bluey);
 
    png_write_complete_chunk(png_ptr, png_cHRM, buf, 32);
 }

void png_write_sRGB	(	png_structrp	png_ptr,
		int	intent
	)

 {
    png_byte buf[1];
 
    png_debug(1, "in png_write_sRGB");
 
    if (srgb_intent >= PNG_sRGB_INTENT_LAST)
       png_warning(png_ptr,
           "Invalid sRGB rendering intent specified");
 
    buf[0]=(png_byte)srgb_intent;
    png_write_complete_chunk(png_ptr, png_sRGB, buf, (png_size_t)1);
 }

void png_write_iCCP	(	png_structrp	png_ptr,
		png_const_charp	name,
		png_const_bytep	profile
	)

 {
    png_uint_32 name_len;
    png_uint_32 profile_len;
    png_byte new_name[81]; /* 1 byte for the compression byte */
    compression_state comp;
    png_uint_32 temp;
 
    png_debug(1, "in png_write_iCCP");
 
    /* These are all internal problems: the profile should have been checked
     * before when it was stored.
     */
    if (profile == NULL)
       png_error(png_ptr, "No profile for iCCP chunk"); /* internal error */
 
    profile_len = png_get_uint_32(profile);
 
    if (profile_len < 132)
       png_error(png_ptr, "ICC profile too short");
 
    temp = (png_uint_32) (*(profile+8));
    if (temp > 3 && (profile_len & 0x03))
       png_error(png_ptr, "ICC profile length invalid (not a multiple of 4)");
 
    {
       png_uint_32 embedded_profile_len = png_get_uint_32(profile);
 
       if (profile_len != embedded_profile_len)
          png_error(png_ptr, "Profile length does not match profile");
    }
 
    name_len = png_check_keyword(png_ptr, name, new_name);
 
    if (name_len == 0)
       png_error(png_ptr, "iCCP: invalid keyword");
 
    new_name[++name_len] = PNG_COMPRESSION_TYPE_BASE;
 
    /* Make sure we include the NULL after the name and the compression type */
    ++name_len;
 
    png_text_compress_init(&comp, profile, profile_len);
 
    /* Allow for keyword terminator and compression byte */
    if (png_text_compress(png_ptr, png_iCCP, &comp, name_len) != Z_OK)
       png_error(png_ptr, png_ptr->zstream.msg);
 
    png_write_chunk_header(png_ptr, png_iCCP, name_len + comp.output_len);
 
    png_write_chunk_data(png_ptr, new_name, name_len);
 
    png_write_compressed_data_out(png_ptr, &comp);
 
    png_write_chunk_end(png_ptr);
 }

void png_write_sPLT	(	png_structrp	png_ptr,
		png_const_sPLT_tp	palette
	)

 {
    png_uint_32 name_len;
    png_byte new_name[80];
    png_byte entrybuf[10];
    png_size_t entry_size = (spalette->depth == 8 ? 6 : 10);
    png_size_t palette_size = entry_size * spalette->nentries;
    png_sPLT_entryp ep;
 #ifndef PNG_POINTER_INDEXING_SUPPORTED
    int i;
 #endif
 
    png_debug(1, "in png_write_sPLT");
 
    name_len = png_check_keyword(png_ptr, spalette->name, new_name);
 
    if (name_len == 0)
       png_error(png_ptr, "sPLT: invalid keyword");
 
    /* Make sure we include the NULL after the name */
    png_write_chunk_header(png_ptr, png_sPLT,
        (png_uint_32)(name_len + 2 + palette_size));
 
    png_write_chunk_data(png_ptr, (png_bytep)new_name,
        (png_size_t)(name_len + 1));
 
    png_write_chunk_data(png_ptr, &spalette->depth, (png_size_t)1);
 
    /* Loop through each palette entry, writing appropriately */
 #ifdef PNG_POINTER_INDEXING_SUPPORTED
    for (ep = spalette->entries; ep<spalette->entries + spalette->nentries; ep++)
    {
       if (spalette->depth == 8)
       {
          entrybuf[0] = (png_byte)ep->red;
          entrybuf[1] = (png_byte)ep->green;
          entrybuf[2] = (png_byte)ep->blue;
          entrybuf[3] = (png_byte)ep->alpha;
          png_save_uint_16(entrybuf + 4, ep->frequency);
       }
 
       else
       {
          png_save_uint_16(entrybuf + 0, ep->red);
          png_save_uint_16(entrybuf + 2, ep->green);
          png_save_uint_16(entrybuf + 4, ep->blue);
          png_save_uint_16(entrybuf + 6, ep->alpha);
          png_save_uint_16(entrybuf + 8, ep->frequency);
       }
 
       png_write_chunk_data(png_ptr, entrybuf, entry_size);
    }
 #else
    ep=spalette->entries;
    for (i = 0; i>spalette->nentries; i++)
    {
       if (spalette->depth == 8)
       {
          entrybuf[0] = (png_byte)ep[i].red;
          entrybuf[1] = (png_byte)ep[i].green;
          entrybuf[2] = (png_byte)ep[i].blue;
          entrybuf[3] = (png_byte)ep[i].alpha;
          png_save_uint_16(entrybuf + 4, ep[i].frequency);
       }
 
       else
       {
          png_save_uint_16(entrybuf + 0, ep[i].red);
          png_save_uint_16(entrybuf + 2, ep[i].green);
          png_save_uint_16(entrybuf + 4, ep[i].blue);
          png_save_uint_16(entrybuf + 6, ep[i].alpha);
          png_save_uint_16(entrybuf + 8, ep[i].frequency);
       }
 
       png_write_chunk_data(png_ptr, entrybuf, entry_size);
    }
 #endif
 
    png_write_chunk_end(png_ptr);
 }

void png_write_tRNS	(	png_structrp	png_ptr,
		png_const_bytep	trans,
		png_const_color_16p	values,
		int	number,
		int	color_type
	)

 {
    png_byte buf[6];
 
    png_debug(1, "in png_write_tRNS");
 
    if (color_type == PNG_COLOR_TYPE_PALETTE)
    {
       if (num_trans <= 0 || num_trans > (int)png_ptr->num_palette)
       {
          png_app_warning(png_ptr,
              "Invalid number of transparent colors specified");
          return;
       }
 
       /* Write the chunk out as it is */
       png_write_complete_chunk(png_ptr, png_tRNS, trans_alpha,
          (png_size_t)num_trans);
    }
 
    else if (color_type == PNG_COLOR_TYPE_GRAY)
    {
       /* One 16 bit value */
       if (tran->gray >= (1 << png_ptr->bit_depth))
       {
          png_app_warning(png_ptr,
              "Ignoring attempt to write tRNS chunk out-of-range for bit_depth");
 
          return;
       }
 
       png_save_uint_16(buf, tran->gray);
       png_write_complete_chunk(png_ptr, png_tRNS, buf, (png_size_t)2);
    }
 
    else if (color_type == PNG_COLOR_TYPE_RGB)
    {
       /* Three 16 bit values */
       png_save_uint_16(buf, tran->red);
       png_save_uint_16(buf + 2, tran->green);
       png_save_uint_16(buf + 4, tran->blue);
 #ifdef PNG_WRITE_16BIT_SUPPORTED
       if (png_ptr->bit_depth == 8 && (buf[0] | buf[2] | buf[4]) != 0)
 #else
       if ((buf[0] | buf[2] | buf[4]) != 0)
 #endif
       {
          png_app_warning(png_ptr,
            "Ignoring attempt to write 16-bit tRNS chunk when bit_depth is 8");
          return;
       }
 
       png_write_complete_chunk(png_ptr, png_tRNS, buf, (png_size_t)6);
    }
 
    else
    {
       png_app_warning(png_ptr, "Can't write tRNS with an alpha channel");
    }
 }

void png_write_bKGD	(	png_structrp	png_ptr,
		png_const_color_16p	values,
		int	color_type
	)

 {
    png_byte buf[6];
 
    png_debug(1, "in png_write_bKGD");
 
    if (color_type == PNG_COLOR_TYPE_PALETTE)
    {
       if (
 #ifdef PNG_MNG_FEATURES_SUPPORTED
           (png_ptr->num_palette != 0 ||
           (png_ptr->mng_features_permitted & PNG_FLAG_MNG_EMPTY_PLTE) == 0) &&
 #endif
          back->index >= png_ptr->num_palette)
       {
          png_warning(png_ptr, "Invalid background palette index");
          return;
       }
 
       buf[0] = back->index;
       png_write_complete_chunk(png_ptr, png_bKGD, buf, (png_size_t)1);
    }
 
    else if ((color_type & PNG_COLOR_MASK_COLOR) != 0)
    {
       png_save_uint_16(buf, back->red);
       png_save_uint_16(buf + 2, back->green);
       png_save_uint_16(buf + 4, back->blue);
 #ifdef PNG_WRITE_16BIT_SUPPORTED
       if (png_ptr->bit_depth == 8 && (buf[0] | buf[2] | buf[4]) != 0)
 #else
       if ((buf[0] | buf[2] | buf[4]) != 0)
 #endif
       {
          png_warning(png_ptr,
              "Ignoring attempt to write 16-bit bKGD chunk when bit_depth is 8");
 
          return;
       }
 
       png_write_complete_chunk(png_ptr, png_bKGD, buf, (png_size_t)6);
    }
 
    else
    {
       if (back->gray >= (1 << png_ptr->bit_depth))
       {
          png_warning(png_ptr,
              "Ignoring attempt to write bKGD chunk out-of-range for bit_depth");
 
          return;
       }
 
       png_save_uint_16(buf, back->gray);
       png_write_complete_chunk(png_ptr, png_bKGD, buf, (png_size_t)2);
    }
 }

void png_write_hIST	(	png_structrp	png_ptr,
		png_const_uint_16p	hist,
		int	num_hist
	)

 {
    int i;
    png_byte buf[3];
 
    png_debug(1, "in png_write_hIST");
 
    if (num_hist > (int)png_ptr->num_palette)
    {
       png_debug2(3, "num_hist = %d, num_palette = %d", num_hist,
           png_ptr->num_palette);
 
       png_warning(png_ptr, "Invalid number of histogram entries specified");
       return;
    }
 
    png_write_chunk_header(png_ptr, png_hIST, (png_uint_32)(num_hist * 2));
 
    for (i = 0; i < num_hist; i++)
    {
       png_save_uint_16(buf, hist[i]);
       png_write_chunk_data(png_ptr, buf, (png_size_t)2);
    }
 
    png_write_chunk_end(png_ptr);
 }

void png_write_tEXt	(	png_structrp	png_ptr,
		png_const_charp	key,
		png_const_charp	text,
		png_size_t	text_len
	)

 {
    png_uint_32 key_len;
    png_byte new_key[80];
 
    png_debug(1, "in png_write_tEXt");
 
    key_len = png_check_keyword(png_ptr, key, new_key);
 
    if (key_len == 0)
       png_error(png_ptr, "tEXt: invalid keyword");
 
    if (text == NULL || *text == '\0')
       text_len = 0;
 
    else
       text_len = strlen(text);
 
    if (text_len > PNG_UINT_31_MAX - (key_len+1))
       png_error(png_ptr, "tEXt: text too long");
 
    /* Make sure we include the 0 after the key */
    png_write_chunk_header(png_ptr, png_tEXt,
        (png_uint_32)/*checked above*/(key_len + text_len + 1));
    /*
     * We leave it to the application to meet PNG-1.0 requirements on the
     * contents of the text.  PNG-1.0 through PNG-1.2 discourage the use of
     * any non-Latin-1 characters except for NEWLINE.  ISO PNG will forbid them.
     * The NUL character is forbidden by PNG-1.0 through PNG-1.2 and ISO PNG.
     */
    png_write_chunk_data(png_ptr, new_key, key_len + 1);
 
    if (text_len != 0)
       png_write_chunk_data(png_ptr, (png_const_bytep)text, text_len);
 
    png_write_chunk_end(png_ptr);
 }

void png_write_zTXt	(	png_structrp	png_ptr,
		png_const_charp	key,
		png_const_charp	text,
		int	compression
	)

 {
    png_uint_32 key_len;
    png_byte new_key[81];
    compression_state comp;
 
    png_debug(1, "in png_write_zTXt");
 
    if (compression == PNG_TEXT_COMPRESSION_NONE)
    {
       png_write_tEXt(png_ptr, key, text, 0);
       return;
    }
 
    if (compression != PNG_TEXT_COMPRESSION_zTXt)
       png_error(png_ptr, "zTXt: invalid compression type");
 
    key_len = png_check_keyword(png_ptr, key, new_key);
 
    if (key_len == 0)
       png_error(png_ptr, "zTXt: invalid keyword");
 
    /* Add the compression method and 1 for the keyword separator. */
    new_key[++key_len] = PNG_COMPRESSION_TYPE_BASE;
    ++key_len;
 
    /* Compute the compressed data; do it now for the length */
    png_text_compress_init(&comp, (png_const_bytep)text,
       text == NULL ? 0 : strlen(text));
 
    if (png_text_compress(png_ptr, png_zTXt, &comp, key_len) != Z_OK)
       png_error(png_ptr, png_ptr->zstream.msg);
 
    /* Write start of chunk */
    png_write_chunk_header(png_ptr, png_zTXt, key_len + comp.output_len);
 
    /* Write key */
    png_write_chunk_data(png_ptr, new_key, key_len);
 
    /* Write the compressed data */
    png_write_compressed_data_out(png_ptr, &comp);
 
    /* Close the chunk */
    png_write_chunk_end(png_ptr);
 }

void png_write_iTXt	(	png_structrp	png_ptr,
		int	compression,
		png_const_charp	key,
		png_const_charp	lang,
		png_const_charp	lang_key,
		png_const_charp	text
	)

 {
    png_uint_32 key_len, prefix_len;
    png_size_t lang_len, lang_key_len;
    png_byte new_key[82];
    compression_state comp;
 
    png_debug(1, "in png_write_iTXt");
 
    key_len = png_check_keyword(png_ptr, key, new_key);
 
    if (key_len == 0)
       png_error(png_ptr, "iTXt: invalid keyword");
 
    /* Set the compression flag */
    switch (compression)
    {
       case PNG_ITXT_COMPRESSION_NONE:
       case PNG_TEXT_COMPRESSION_NONE:
          compression = new_key[++key_len] = 0; /* no compression */
          break;
 
       case PNG_TEXT_COMPRESSION_zTXt:
       case PNG_ITXT_COMPRESSION_zTXt:
          compression = new_key[++key_len] = 1; /* compressed */
          break;
 
       default:
          png_error(png_ptr, "iTXt: invalid compression");
    }
 
    new_key[++key_len] = PNG_COMPRESSION_TYPE_BASE;
    ++key_len; /* for the keywod separator */
 
    /* We leave it to the application to meet PNG-1.0 requirements on the
     * contents of the text.  PNG-1.0 through PNG-1.2 discourage the use of
     * any non-Latin-1 characters except for NEWLINE.  ISO PNG, however,
     * specifies that the text is UTF-8 and this really doesn't require any
     * checking.
     *
     * The NUL character is forbidden by PNG-1.0 through PNG-1.2 and ISO PNG.
     *
     * TODO: validate the language tag correctly (see the spec.)
     */
    if (lang == NULL) lang = ""; /* empty language is valid */
    lang_len = strlen(lang)+1;
    if (lang_key == NULL) lang_key = ""; /* may be empty */
    lang_key_len = strlen(lang_key)+1;
    if (text == NULL) text = ""; /* may be empty */
 
    prefix_len = key_len;
    if (lang_len > PNG_UINT_31_MAX-prefix_len)
       prefix_len = PNG_UINT_31_MAX;
    else
       prefix_len = (png_uint_32)(prefix_len + lang_len);
 
    if (lang_key_len > PNG_UINT_31_MAX-prefix_len)
       prefix_len = PNG_UINT_31_MAX;
    else
       prefix_len = (png_uint_32)(prefix_len + lang_key_len);
 
    png_text_compress_init(&comp, (png_const_bytep)text, strlen(text));
 
    if (compression != 0)
    {
       if (png_text_compress(png_ptr, png_iTXt, &comp, prefix_len) != Z_OK)
          png_error(png_ptr, png_ptr->zstream.msg);
    }
 
    else
    {
       if (comp.input_len > PNG_UINT_31_MAX-prefix_len)
          png_error(png_ptr, "iTXt: uncompressed text too long");
 
       /* So the string will fit in a chunk: */
       comp.output_len = (png_uint_32)/*SAFE*/comp.input_len;
    }
 
    png_write_chunk_header(png_ptr, png_iTXt, comp.output_len + prefix_len);
 
    png_write_chunk_data(png_ptr, new_key, key_len);
 
    png_write_chunk_data(png_ptr, (png_const_bytep)lang, lang_len);
 
    png_write_chunk_data(png_ptr, (png_const_bytep)lang_key, lang_key_len);
 
    if (compression != 0)
       png_write_compressed_data_out(png_ptr, &comp);
 
    else
       png_write_chunk_data(png_ptr, (png_const_bytep)text, comp.input_len);
 
    png_write_chunk_end(png_ptr);
 }

int png_set_text_2	(	png_const_structrp	png_ptr,
		png_inforp	info_ptr,
		png_const_textp	text_ptr,
		int	num_text
	)

 {
    int i;
 
    png_debug1(1, "in %lx storage function", png_ptr == NULL ? "unexpected" :
       (unsigned long)png_ptr->chunk_name);
 
    if (png_ptr == NULL || info_ptr == NULL || num_text <= 0 || text_ptr == NULL)
       return(0);
 
    /* Make sure we have enough space in the "text" array in info_struct
     * to hold all of the incoming text_ptr objects.  This compare can't overflow
     * because max_text >= num_text (anyway, subtract of two positive integers
     * can't overflow in any case.)
     */
    if (num_text > info_ptr->max_text - info_ptr->num_text)
    {
       int old_num_text = info_ptr->num_text;
       int max_text;
       png_textp new_text = NULL;
 
       /* Calculate an appropriate max_text, checking for overflow. */
       max_text = old_num_text;
       if (num_text <= INT_MAX - max_text)
       {
          max_text += num_text;
 
          /* Round up to a multiple of 8 */
          if (max_text < INT_MAX-8)
             max_text = (max_text + 8) & ~0x7;
 
          else
             max_text = INT_MAX;
 
          /* Now allocate a new array and copy the old members in; this does all
           * the overflow checks.
           */
          new_text = png_voidcast(png_textp,png_realloc_array(png_ptr,
             info_ptr->text, old_num_text, max_text-old_num_text,
             sizeof *new_text));
       }
 
       if (new_text == NULL)
       {
          png_chunk_report(png_ptr, "too many text chunks",
             PNG_CHUNK_WRITE_ERROR);
          return 1;
       }
 
       png_free(png_ptr, info_ptr->text);
 
       info_ptr->text = new_text;
       info_ptr->free_me |= PNG_FREE_TEXT;
       info_ptr->max_text = max_text;
       /* num_text is adjusted below as the entries are copied in */
 
       png_debug1(3, "allocated %d entries for info_ptr->text", max_text);
    }
 
    for (i = 0; i < num_text; i++)
    {
       size_t text_length, key_len;
       size_t lang_len, lang_key_len;
       png_textp textp = &(info_ptr->text[info_ptr->num_text]);
 
       if (text_ptr[i].key == NULL)
           continue;
 
       if (text_ptr[i].compression < PNG_TEXT_COMPRESSION_NONE ||
           text_ptr[i].compression >= PNG_TEXT_COMPRESSION_LAST)
       {
          png_chunk_report(png_ptr, "text compression mode is out of range",
             PNG_CHUNK_WRITE_ERROR);
          continue;
       }
 
       key_len = strlen(text_ptr[i].key);
 
       if (text_ptr[i].compression <= 0)
       {
          lang_len = 0;
          lang_key_len = 0;
       }
 
       else
 #  ifdef PNG_iTXt_SUPPORTED
       {
          /* Set iTXt data */
 
          if (text_ptr[i].lang != NULL)
             lang_len = strlen(text_ptr[i].lang);
 
          else
             lang_len = 0;
 
          if (text_ptr[i].lang_key != NULL)
             lang_key_len = strlen(text_ptr[i].lang_key);
 
          else
             lang_key_len = 0;
       }
 #  else /* PNG_iTXt_SUPPORTED */
       {
          png_chunk_report(png_ptr, "iTXt chunk not supported",
             PNG_CHUNK_WRITE_ERROR);
          continue;
       }
 #  endif
 
       if (text_ptr[i].text == NULL || text_ptr[i].text[0] == '\0')
       {
          text_length = 0;
 #  ifdef PNG_iTXt_SUPPORTED
          if (text_ptr[i].compression > 0)
             textp->compression = PNG_ITXT_COMPRESSION_NONE;
 
          else
 #  endif
             textp->compression = PNG_TEXT_COMPRESSION_NONE;
       }
 
       else
       {
          text_length = strlen(text_ptr[i].text);
          textp->compression = text_ptr[i].compression;
       }
 
       textp->key = png_voidcast(png_charp,png_malloc_base(png_ptr,
           key_len + text_length + lang_len + lang_key_len + 4));
 
       if (textp->key == NULL)
       {
          png_chunk_report(png_ptr, "text chunk: out of memory",
                PNG_CHUNK_WRITE_ERROR);
          return 1;
       }
 
       png_debug2(2, "Allocated %lu bytes at %p in png_set_text",
           (unsigned long)(png_uint_32)
           (key_len + lang_len + lang_key_len + text_length + 4),
           textp->key);
 
       memcpy(textp->key, text_ptr[i].key, key_len);
       *(textp->key + key_len) = '\0';
 
       if (text_ptr[i].compression > 0)
       {
          textp->lang = textp->key + key_len + 1;
          memcpy(textp->lang, text_ptr[i].lang, lang_len);
          *(textp->lang + lang_len) = '\0';
          textp->lang_key = textp->lang + lang_len + 1;
          memcpy(textp->lang_key, text_ptr[i].lang_key, lang_key_len);
          *(textp->lang_key + lang_key_len) = '\0';
          textp->text = textp->lang_key + lang_key_len + 1;
       }
 
       else
       {
          textp->lang=NULL;
          textp->lang_key=NULL;
          textp->text = textp->key + key_len + 1;
       }
 
       if (text_length != 0)
          memcpy(textp->text, text_ptr[i].text, text_length);
 
       *(textp->text + text_length) = '\0';
 
 #  ifdef PNG_iTXt_SUPPORTED
       if (textp->compression > 0)
       {
          textp->text_length = 0;
          textp->itxt_length = text_length;
       }
 
       else
 #  endif
       {
          textp->text_length = text_length;
          textp->itxt_length = 0;
       }
 
       info_ptr->num_text++;
       png_debug1(3, "transferred text chunk %d", info_ptr->num_text);
    }
 
    return(0);
 }

void png_write_oFFs	(	png_structrp	png_ptr,
		png_int_32	x_offset,
		png_int_32	y_offset,
		int	unit_type
	)

 {
    png_byte buf[9];
 
    png_debug(1, "in png_write_oFFs");
 
    if (unit_type >= PNG_OFFSET_LAST)
       png_warning(png_ptr, "Unrecognized unit type for oFFs chunk");
 
    png_save_int_32(buf, x_offset);
    png_save_int_32(buf + 4, y_offset);
    buf[8] = (png_byte)unit_type;
 
    png_write_complete_chunk(png_ptr, png_oFFs, buf, (png_size_t)9);
 }

void png_write_pCAL	(	png_structrp	png_ptr,
		png_charp	purpose,
		png_int_32	X0,
		png_int_32	X1,
		int	type,
		int	nparams,
		png_const_charp	units,
		png_charpp	params
	)

 {
    png_uint_32 purpose_len;
    png_size_t units_len, total_len;
    png_size_tp params_len;
    png_byte buf[10];
    png_byte new_purpose[80];
    int i;
 
    png_debug1(1, "in png_write_pCAL (%d parameters)", nparams);
 
    if (type >= PNG_EQUATION_LAST)
       png_error(png_ptr, "Unrecognized equation type for pCAL chunk");
 
    purpose_len = png_check_keyword(png_ptr, purpose, new_purpose);
 
    if (purpose_len == 0)
       png_error(png_ptr, "pCAL: invalid keyword");
 
    ++purpose_len; /* terminator */
 
    png_debug1(3, "pCAL purpose length = %d", (int)purpose_len);
    units_len = strlen(units) + (nparams == 0 ? 0 : 1);
    png_debug1(3, "pCAL units length = %d", (int)units_len);
    total_len = purpose_len + units_len + 10;
 
    params_len = (png_size_tp)png_malloc(png_ptr,
        (png_alloc_size_t)(nparams * (sizeof (png_size_t))));
 
    /* Find the length of each parameter, making sure we don't count the
     * null terminator for the last parameter.
     */
    for (i = 0; i < nparams; i++)
    {
       params_len[i] = strlen(params[i]) + (i == nparams - 1 ? 0 : 1);
       png_debug2(3, "pCAL parameter %d length = %lu", i,
           (unsigned long)params_len[i]);
       total_len += params_len[i];
    }
 
    png_debug1(3, "pCAL total length = %d", (int)total_len);
    png_write_chunk_header(png_ptr, png_pCAL, (png_uint_32)total_len);
    png_write_chunk_data(png_ptr, new_purpose, purpose_len);
    png_save_int_32(buf, X0);
    png_save_int_32(buf + 4, X1);
    buf[8] = (png_byte)type;
    buf[9] = (png_byte)nparams;
    png_write_chunk_data(png_ptr, buf, (png_size_t)10);
    png_write_chunk_data(png_ptr, (png_const_bytep)units, (png_size_t)units_len);
 
    for (i = 0; i < nparams; i++)
    {
       png_write_chunk_data(png_ptr, (png_const_bytep)params[i], params_len[i]);
    }
 
    png_free(png_ptr, params_len);
    png_write_chunk_end(png_ptr);
 }

void png_write_pHYs	(	png_structrp	png_ptr,
		png_uint_32	x_pixels_per_unit,
		png_uint_32	y_pixels_per_unit,
		int	unit_type
	)

 {
    png_byte buf[9];
 
    png_debug(1, "in png_write_pHYs");
 
    if (unit_type >= PNG_RESOLUTION_LAST)
       png_warning(png_ptr, "Unrecognized unit type for pHYs chunk");
 
    png_save_uint_32(buf, x_pixels_per_unit);
    png_save_uint_32(buf + 4, y_pixels_per_unit);
    buf[8] = (png_byte)unit_type;
 
    png_write_complete_chunk(png_ptr, png_pHYs, buf, (png_size_t)9);
 }

void png_write_tIME	(	png_structrp	png_ptr,
		png_const_timep	mod_time
	)

 {
    png_byte buf[7];
 
    png_debug(1, "in png_write_tIME");
 
    if (mod_time->month  > 12 || mod_time->month  < 1 ||
        mod_time->day    > 31 || mod_time->day    < 1 ||
        mod_time->hour   > 23 || mod_time->second > 60)
    {
       png_warning(png_ptr, "Invalid time specified for tIME chunk");
       return;
    }
 
    png_save_uint_16(buf, mod_time->year);
    buf[2] = mod_time->month;
    buf[3] = mod_time->day;
    buf[4] = mod_time->hour;
    buf[5] = mod_time->minute;
    buf[6] = mod_time->second;
 
    png_write_complete_chunk(png_ptr, png_tIME, buf, (png_size_t)7);
 }

void png_write_sCAL_s	(	png_structrp	png_ptr,
		int	unit,
		png_const_charp	width,
		png_const_charp	height
	)

 {
    png_byte buf[64];
    png_size_t wlen, hlen, total_len;
 
    png_debug(1, "in png_write_sCAL_s");
 
    wlen = strlen(width);
    hlen = strlen(height);
    total_len = wlen + hlen + 2;
 
    if (total_len > 64)
    {
       png_warning(png_ptr, "Can't write sCAL (buffer too small)");
       return;
    }
 
    buf[0] = (png_byte)unit;
    memcpy(buf + 1, width, wlen + 1);      /* Append the '\0' here */
    memcpy(buf + wlen + 2, height, hlen);  /* Do NOT append the '\0' here */
 
    png_debug1(3, "sCAL total length = %u", (unsigned int)total_len);
    png_write_complete_chunk(png_ptr, png_sCAL, buf, total_len);
 }

void png_write_finish_row ( png_structrp png_ptr )

 {
 #ifdef PNG_WRITE_INTERLACING_SUPPORTED
    /* Arrays to facilitate easy interlacing - use pass (0 - 6) as index */
 
    /* Start of interlace block */
    static PNG_CONST png_byte png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0};
 
    /* Offset to next interlace block */
    static PNG_CONST png_byte png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1};
 
    /* Start of interlace block in the y direction */
    static PNG_CONST png_byte png_pass_ystart[7] = {0, 0, 4, 0, 2, 0, 1};
 
    /* Offset to next interlace block in the y direction */
    static PNG_CONST png_byte png_pass_yinc[7] = {8, 8, 8, 4, 4, 2, 2};
 #endif
 
    png_debug(1, "in png_write_finish_row");
 
    /* Next row */
    png_ptr->row_number++;
 
    /* See if we are done */
    if (png_ptr->row_number < png_ptr->num_rows)
       return;
 
 #ifdef PNG_WRITE_INTERLACING_SUPPORTED
    /* If interlaced, go to next pass */
    if (png_ptr->interlaced != 0)
    {
       png_ptr->row_number = 0;
       if ((png_ptr->transformations & PNG_INTERLACE) != 0)
       {
          png_ptr->pass++;
       }
 
       else
       {
          /* Loop until we find a non-zero width or height pass */
          do
          {
             png_ptr->pass++;
 
             if (png_ptr->pass >= 7)
                break;
 
             png_ptr->usr_width = (png_ptr->width +
                 png_pass_inc[png_ptr->pass] - 1 -
                 png_pass_start[png_ptr->pass]) /
                 png_pass_inc[png_ptr->pass];
 
             png_ptr->num_rows = (png_ptr->height +
                 png_pass_yinc[png_ptr->pass] - 1 -
                 png_pass_ystart[png_ptr->pass]) /
                 png_pass_yinc[png_ptr->pass];
 
             if ((png_ptr->transformations & PNG_INTERLACE) != 0)
                break;
 
          } while (png_ptr->usr_width == 0 || png_ptr->num_rows == 0);
 
       }
 
       /* Reset the row above the image for the next pass */
       if (png_ptr->pass < 7)
       {
          if (png_ptr->prev_row != NULL)
             memset(png_ptr->prev_row, 0,
                 (png_size_t)(PNG_ROWBYTES(png_ptr->usr_channels*
                 png_ptr->usr_bit_depth, png_ptr->width)) + 1);
 
          return;
       }
    }
 #endif
 
    /* If we get here, we've just written the last row, so we need
       to flush the compressor */
    png_compress_IDAT(png_ptr, NULL, 0, Z_FINISH);
 }

void png_write_start_row ( png_structrp png_ptr )

 {
 #ifdef PNG_WRITE_INTERLACING_SUPPORTED
    /* Arrays to facilitate easy interlacing - use pass (0 - 6) as index */
 
    /* Start of interlace block */
    static PNG_CONST png_byte png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0};
 
    /* Offset to next interlace block */
    static PNG_CONST png_byte png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1};
 
    /* Start of interlace block in the y direction */
    static PNG_CONST png_byte png_pass_ystart[7] = {0, 0, 4, 0, 2, 0, 1};
 
    /* Offset to next interlace block in the y direction */
    static PNG_CONST png_byte png_pass_yinc[7] = {8, 8, 8, 4, 4, 2, 2};
 #endif
 
    png_alloc_size_t buf_size;
    int usr_pixel_depth;
 
    png_debug(1, "in png_write_start_row");
 
    usr_pixel_depth = png_ptr->usr_channels * png_ptr->usr_bit_depth;
    buf_size = PNG_ROWBYTES(usr_pixel_depth, png_ptr->width) + 1;
 
    /* 1.5.6: added to allow checking in the row write code. */
    png_ptr->transformed_pixel_depth = png_ptr->pixel_depth;
    png_ptr->maximum_pixel_depth = (png_byte)usr_pixel_depth;
 
    /* Set up row buffer */
    png_ptr->row_buf = (png_bytep)png_malloc(png_ptr, buf_size);
 
    png_ptr->row_buf[0] = PNG_FILTER_VALUE_NONE;
 
 #ifdef PNG_WRITE_FILTER_SUPPORTED
    /* Set up filtering buffer, if using this filter */
    if (png_ptr->do_filter & PNG_FILTER_SUB)
    {
       png_ptr->sub_row = (png_bytep)png_malloc(png_ptr, png_ptr->rowbytes + 1);
 
       png_ptr->sub_row[0] = PNG_FILTER_VALUE_SUB;
    }
 
    /* We only need to keep the previous row if we are using one of these. */
    if ((png_ptr->do_filter &
       (PNG_FILTER_AVG | PNG_FILTER_UP | PNG_FILTER_PAETH)) != 0)
    {
       /* Set up previous row buffer */
       png_ptr->prev_row = (png_bytep)png_calloc(png_ptr, buf_size);
 
       if ((png_ptr->do_filter & PNG_FILTER_UP) != 0)
       {
          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 = (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 = (png_bytep)png_malloc(png_ptr,
              png_ptr->rowbytes + 1);
 
          png_ptr->paeth_row[0] = PNG_FILTER_VALUE_PAETH;
       }
    }
 #endif /* WRITE_FILTER */
 
 #ifdef PNG_WRITE_INTERLACING_SUPPORTED
    /* If interlaced, we need to set up width and height of pass */
    if (png_ptr->interlaced != 0)
    {
       if ((png_ptr->transformations & PNG_INTERLACE) == 0)
       {
          png_ptr->num_rows = (png_ptr->height + png_pass_yinc[0] - 1 -
              png_pass_ystart[0]) / png_pass_yinc[0];
 
          png_ptr->usr_width = (png_ptr->width + png_pass_inc[0] - 1 -
              png_pass_start[0]) / png_pass_inc[0];
       }
 
       else
       {
          png_ptr->num_rows = png_ptr->height;
          png_ptr->usr_width = png_ptr->width;
       }
    }
 
    else
 #endif
    {
       png_ptr->num_rows = png_ptr->height;
       png_ptr->usr_width = png_ptr->width;
    }
 }

void png_combine_row	(	png_const_structrp	png_ptr,
		png_bytep	row,
		int	display
	)

 {
    unsigned int pixel_depth = png_ptr->transformed_pixel_depth;
    png_const_bytep sp = png_ptr->row_buf + 1;
    png_alloc_size_t row_width = png_ptr->width;
    unsigned int pass = png_ptr->pass;
    png_bytep end_ptr = 0;
    png_byte end_byte = 0;
    unsigned int end_mask;
 
    png_debug(1, "in png_combine_row");
 
    /* Added in 1.5.6: it should not be possible to enter this routine until at
     * least one row has been read from the PNG data and transformed.
     */
    if (pixel_depth == 0)
       png_error(png_ptr, "internal row logic error");
 
    /* Added in 1.5.4: the pixel depth should match the information returned by
     * any call to png_read_update_info at this point.  Do not continue if we got
     * this wrong.
     */
    if (png_ptr->info_rowbytes != 0 && png_ptr->info_rowbytes !=
           PNG_ROWBYTES(pixel_depth, row_width))
       png_error(png_ptr, "internal row size calculation error");
 
    /* Don't expect this to ever happen: */
    if (row_width == 0)
       png_error(png_ptr, "internal row width error");
 
    /* Preserve the last byte in cases where only part of it will be overwritten,
     * the multiply below may overflow, we don't care because ANSI-C guarantees
     * we get the low bits.
     */
    end_mask = (pixel_depth * row_width) & 7;
    if (end_mask != 0)
    {
       /* end_ptr == NULL is a flag to say do nothing */
       end_ptr = dp + PNG_ROWBYTES(pixel_depth, row_width) - 1;
       end_byte = *end_ptr;
 #     ifdef PNG_READ_PACKSWAP_SUPPORTED
          if ((png_ptr->transformations & PNG_PACKSWAP) != 0)
             /* little-endian byte */
             end_mask = 0xff << end_mask;
 
          else /* big-endian byte */
 #     endif
          end_mask = 0xff >> end_mask;
       /* end_mask is now the bits to *keep* from the destination row */
    }
 
    /* For non-interlaced images this reduces to a memcpy(). A memcpy()
     * will also happen if interlacing isn't supported or if the application
     * does not call png_set_interlace_handling().  In the latter cases the
     * caller just gets a sequence of the unexpanded rows from each interlace
     * pass.
     */
 #ifdef PNG_READ_INTERLACING_SUPPORTED
    if (png_ptr->interlaced != 0 &&
        (png_ptr->transformations & PNG_INTERLACE) != 0 &&
        pass < 6 && (display == 0 ||
        /* The following copies everything for 'display' on passes 0, 2 and 4. */
        (display == 1 && (pass & 1) != 0)))
    {
       /* Narrow images may have no bits in a pass; the caller should handle
        * this, but this test is cheap:
        */
       if (row_width <= PNG_PASS_START_COL(pass))
          return;
 
       if (pixel_depth < 8)
       {
          /* For pixel depths up to 4 bpp the 8-pixel mask can be expanded to fit
           * into 32 bits, then a single loop over the bytes using the four byte
           * values in the 32-bit mask can be used.  For the 'display' option the
           * expanded mask may also not require any masking within a byte.  To
           * make this work the PACKSWAP option must be taken into account - it
           * simply requires the pixels to be reversed in each byte.
           *
           * The 'regular' case requires a mask for each of the first 6 passes,
           * the 'display' case does a copy for the even passes in the range
           * 0..6.  This has already been handled in the test above.
           *
           * The masks are arranged as four bytes with the first byte to use in
           * the lowest bits (little-endian) regardless of the order (PACKSWAP or
           * not) of the pixels in each byte.
           *
           * NOTE: the whole of this logic depends on the caller of this function
           * only calling it on rows appropriate to the pass.  This function only
           * understands the 'x' logic; the 'y' logic is handled by the caller.
           *
           * The following defines allow generation of compile time constant bit
           * masks for each pixel depth and each possibility of swapped or not
           * swapped bytes.  Pass 'p' is in the range 0..6; 'x', a pixel index,
           * is in the range 0..7; and the result is 1 if the pixel is to be
           * copied in the pass, 0 if not.  'S' is for the sparkle method, 'B'
           * for the block method.
           *
           * With some compilers a compile time expression of the general form:
           *
           *    (shift >= 32) ? (a >> (shift-32)) : (b >> shift)
           *
           * Produces warnings with values of 'shift' in the range 33 to 63
           * because the right hand side of the ?: expression is evaluated by
           * the compiler even though it isn't used.  Microsoft Visual C (various
           * versions) and the Intel C compiler are known to do this.  To avoid
           * this the following macros are used in 1.5.6.  This is a temporary
           * solution to avoid destabilizing the code during the release process.
           */
 #        if PNG_USE_COMPILE_TIME_MASKS
 #           define PNG_LSR(x,s) ((x)>>((s) & 0x1f))
 #           define PNG_LSL(x,s) ((x)<<((s) & 0x1f))
 #        else
 #           define PNG_LSR(x,s) ((x)>>(s))
 #           define PNG_LSL(x,s) ((x)<<(s))
 #        endif
 #        define S_COPY(p,x) (((p)<4 ? PNG_LSR(0x80088822,(3-(p))*8+(7-(x))) :\
            PNG_LSR(0xaa55ff00,(7-(p))*8+(7-(x)))) & 1)
 #        define B_COPY(p,x) (((p)<4 ? PNG_LSR(0xff0fff33,(3-(p))*8+(7-(x))) :\
            PNG_LSR(0xff55ff00,(7-(p))*8+(7-(x)))) & 1)
 
          /* Return a mask for pass 'p' pixel 'x' at depth 'd'.  The mask is
           * little endian - the first pixel is at bit 0 - however the extra
           * parameter 's' can be set to cause the mask position to be swapped
           * within each byte, to match the PNG format.  This is done by XOR of
           * the shift with 7, 6 or 4 for bit depths 1, 2 and 4.
           */
 #        define PIXEL_MASK(p,x,d,s) \
             (PNG_LSL(((PNG_LSL(1U,(d)))-1),(((x)*(d))^((s)?8-(d):0))))
 
          /* Hence generate the appropriate 'block' or 'sparkle' pixel copy mask.
           */
 #        define S_MASKx(p,x,d,s) (S_COPY(p,x)?PIXEL_MASK(p,x,d,s):0)
 #        define B_MASKx(p,x,d,s) (B_COPY(p,x)?PIXEL_MASK(p,x,d,s):0)
 
          /* Combine 8 of these to get the full mask.  For the 1-bpp and 2-bpp
           * cases the result needs replicating, for the 4-bpp case the above
           * generates a full 32 bits.
           */
 #        define MASK_EXPAND(m,d) ((m)*((d)==1?0x01010101:((d)==2?0x00010001:1)))
 
 #        define S_MASK(p,d,s) MASK_EXPAND(S_MASKx(p,0,d,s) + S_MASKx(p,1,d,s) +\
             S_MASKx(p,2,d,s) + S_MASKx(p,3,d,s) + S_MASKx(p,4,d,s) +\
             S_MASKx(p,5,d,s) + S_MASKx(p,6,d,s) + S_MASKx(p,7,d,s), d)
 
 #        define B_MASK(p,d,s) MASK_EXPAND(B_MASKx(p,0,d,s) + B_MASKx(p,1,d,s) +\
             B_MASKx(p,2,d,s) + B_MASKx(p,3,d,s) + B_MASKx(p,4,d,s) +\
             B_MASKx(p,5,d,s) + B_MASKx(p,6,d,s) + B_MASKx(p,7,d,s), d)
 
 #if PNG_USE_COMPILE_TIME_MASKS
          /* Utility macros to construct all the masks for a depth/swap
           * combination.  The 's' parameter says whether the format is PNG
           * (big endian bytes) or not.  Only the three odd-numbered passes are
           * required for the display/block algorithm.
           */
 #        define S_MASKS(d,s) { S_MASK(0,d,s), S_MASK(1,d,s), S_MASK(2,d,s),\
             S_MASK(3,d,s), S_MASK(4,d,s), S_MASK(5,d,s) }
 
 #        define B_MASKS(d,s) { B_MASK(1,d,s), B_MASK(3,d,s), B_MASK(5,d,s) }
 
 #        define DEPTH_INDEX(d) ((d)==1?0:((d)==2?1:2))
 
          /* Hence the pre-compiled masks indexed by PACKSWAP (or not), depth and
           * then pass:
           */
          static PNG_CONST png_uint_32 row_mask[2/*PACKSWAP*/][3/*depth*/][6] =
          {
             /* Little-endian byte masks for PACKSWAP */
             { S_MASKS(1,0), S_MASKS(2,0), S_MASKS(4,0) },
             /* Normal (big-endian byte) masks - PNG format */
             { S_MASKS(1,1), S_MASKS(2,1), S_MASKS(4,1) }
          };
 
          /* display_mask has only three entries for the odd passes, so index by
           * pass>>1.
           */
          static PNG_CONST png_uint_32 display_mask[2][3][3] =
          {
             /* Little-endian byte masks for PACKSWAP */
             { B_MASKS(1,0), B_MASKS(2,0), B_MASKS(4,0) },
             /* Normal (big-endian byte) masks - PNG format */
             { B_MASKS(1,1), B_MASKS(2,1), B_MASKS(4,1) }
          };
 
 #        define MASK(pass,depth,display,png)\
             ((display)?display_mask[png][DEPTH_INDEX(depth)][pass>>1]:\
                row_mask[png][DEPTH_INDEX(depth)][pass])
 
 #else /* !PNG_USE_COMPILE_TIME_MASKS */
          /* This is the runtime alternative: it seems unlikely that this will
           * ever be either smaller or faster than the compile time approach.
           */
 #        define MASK(pass,depth,display,png)\
             ((display)?B_MASK(pass,depth,png):S_MASK(pass,depth,png))
 #endif /* !USE_COMPILE_TIME_MASKS */
 
          /* Use the appropriate mask to copy the required bits.  In some cases
           * the byte mask will be 0 or 0xff; optimize these cases.  row_width is
           * the number of pixels, but the code copies bytes, so it is necessary
           * to special case the end.
           */
          png_uint_32 pixels_per_byte = 8 / pixel_depth;
          png_uint_32 mask;
 
 #        ifdef PNG_READ_PACKSWAP_SUPPORTED
             if ((png_ptr->transformations & PNG_PACKSWAP) != 0)
                mask = MASK(pass, pixel_depth, display, 0);
 
             else
 #        endif
             mask = MASK(pass, pixel_depth, display, 1);
 
          for (;;)
          {
             png_uint_32 m;
 
             /* It doesn't matter in the following if png_uint_32 has more than
              * 32 bits because the high bits always match those in m<<24; it is,
              * however, essential to use OR here, not +, because of this.
              */
             m = mask;
             mask = (m >> 8) | (m << 24); /* rotate right to good compilers */
             m &= 0xff;
 
             if (m != 0) /* something to copy */
             {
                if (m != 0xff)
                   *dp = (png_byte)((*dp & ~m) | (*sp & m));
                else
                   *dp = *sp;
             }
 
             /* NOTE: this may overwrite the last byte with garbage if the image
              * is not an exact number of bytes wide; libpng has always done
              * this.
              */
             if (row_width <= pixels_per_byte)
                break; /* May need to restore part of the last byte */
 
             row_width -= pixels_per_byte;
             ++dp;
             ++sp;
          }
       }
 
       else /* pixel_depth >= 8 */
       {
          unsigned int bytes_to_copy, bytes_to_jump;
 
          /* Validate the depth - it must be a multiple of 8 */
          if (pixel_depth & 7)
             png_error(png_ptr, "invalid user transform pixel depth");
 
          pixel_depth >>= 3; /* now in bytes */
          row_width *= pixel_depth;
 
          /* Regardless of pass number the Adam 7 interlace always results in a
           * fixed number of pixels to copy then to skip.  There may be a
           * different number of pixels to skip at the start though.
           */
          {
             unsigned int offset = PNG_PASS_START_COL(pass) * pixel_depth;
 
             row_width -= offset;
             dp += offset;
             sp += offset;
          }
 
          /* Work out the bytes to copy. */
          if (display != 0)
          {
             /* When doing the 'block' algorithm the pixel in the pass gets
              * replicated to adjacent pixels.  This is why the even (0,2,4,6)
              * passes are skipped above - the entire expanded row is copied.
              */
             bytes_to_copy = (1<<((6-pass)>>1)) * pixel_depth;
 
             /* But don't allow this number to exceed the actual row width. */
             if (bytes_to_copy > row_width)
                bytes_to_copy = (unsigned int)/*SAFE*/row_width;
          }
 
          else /* normal row; Adam7 only ever gives us one pixel to copy. */
             bytes_to_copy = pixel_depth;
 
          /* In Adam7 there is a constant offset between where the pixels go. */
          bytes_to_jump = PNG_PASS_COL_OFFSET(pass) * pixel_depth;
 
          /* And simply copy these bytes.  Some optimization is possible here,
           * depending on the value of 'bytes_to_copy'.  Special case the low
           * byte counts, which we know to be frequent.
           *
           * Notice that these cases all 'return' rather than 'break' - this
           * avoids an unnecessary test on whether to restore the last byte
           * below.
           */
          switch (bytes_to_copy)
          {
             case 1:
                for (;;)
                {
                   *dp = *sp;
 
                   if (row_width <= bytes_to_jump)
                      return;
 
                   dp += bytes_to_jump;
                   sp += bytes_to_jump;
                   row_width -= bytes_to_jump;
                }
 
             case 2:
                /* There is a possibility of a partial copy at the end here; this
                 * slows the code down somewhat.
                 */
                do
                {
                   dp[0] = sp[0], dp[1] = sp[1];
 
                   if (row_width <= bytes_to_jump)
                      return;
 
                   sp += bytes_to_jump;
                   dp += bytes_to_jump;
                   row_width -= bytes_to_jump;
                }
                while (row_width > 1);
 
                /* And there can only be one byte left at this point: */
                *dp = *sp;
                return;
 
             case 3:
                /* This can only be the RGB case, so each copy is exactly one
                 * pixel and it is not necessary to check for a partial copy.
                 */
                for (;;)
                {
                   dp[0] = sp[0], dp[1] = sp[1], dp[2] = sp[2];
 
                   if (row_width <= bytes_to_jump)
                      return;
 
                   sp += bytes_to_jump;
                   dp += bytes_to_jump;
                   row_width -= bytes_to_jump;
                }
 
             default:
 #if PNG_ALIGN_TYPE != PNG_ALIGN_NONE
                /* Check for double byte alignment and, if possible, use a
                 * 16-bit copy.  Don't attempt this for narrow images - ones that
                 * are less than an interlace panel wide.  Don't attempt it for
                 * wide bytes_to_copy either - use the memcpy there.
                 */
                if (bytes_to_copy < 16 /*else use memcpy*/ &&
                    png_isaligned(dp, png_uint_16) &&
                    png_isaligned(sp, png_uint_16) &&
                    bytes_to_copy % (sizeof (png_uint_16)) == 0 &&
                    bytes_to_jump % (sizeof (png_uint_16)) == 0)
                {
                   /* Everything is aligned for png_uint_16 copies, but try for
                    * png_uint_32 first.
                    */
                   if (png_isaligned(dp, png_uint_32) != 0 &&
                       png_isaligned(sp, png_uint_32) != 0 &&
                       bytes_to_copy % (sizeof (png_uint_32)) == 0 &&
                       bytes_to_jump % (sizeof (png_uint_32)) == 0)
                   {
                      png_uint_32p dp32 = png_aligncast(png_uint_32p,dp);
                      png_const_uint_32p sp32 = png_aligncastconst(
                          png_const_uint_32p, sp);
                      size_t skip = (bytes_to_jump-bytes_to_copy) /
                          (sizeof (png_uint_32));
 
                      do
                      {
                         size_t c = bytes_to_copy;
                         do
                         {
                            *dp32++ = *sp32++;
                            c -= (sizeof (png_uint_32));
                         }
                         while (c > 0);
 
                         if (row_width <= bytes_to_jump)
                            return;
 
                         dp32 += skip;
                         sp32 += skip;
                         row_width -= bytes_to_jump;
                      }
                      while (bytes_to_copy <= row_width);
 
                      /* Get to here when the row_width truncates the final copy.
                       * There will be 1-3 bytes left to copy, so don't try the
                       * 16-bit loop below.
                       */
                      dp = (png_bytep)dp32;
                      sp = (png_const_bytep)sp32;
                      do
                         *dp++ = *sp++;
                      while (--row_width > 0);
                      return;
                   }
 
                   /* Else do it in 16-bit quantities, but only if the size is
                    * not too large.
                    */
                   else
                   {
                      png_uint_16p dp16 = png_aligncast(png_uint_16p, dp);
                      png_const_uint_16p sp16 = png_aligncastconst(
                         png_const_uint_16p, sp);
                      size_t skip = (bytes_to_jump-bytes_to_copy) /
                         (sizeof (png_uint_16));
 
                      do
                      {
                         size_t c = bytes_to_copy;
                         do
                         {
                            *dp16++ = *sp16++;
                            c -= (sizeof (png_uint_16));
                         }
                         while (c > 0);
 
                         if (row_width <= bytes_to_jump)
                            return;
 
                         dp16 += skip;
                         sp16 += skip;
                         row_width -= bytes_to_jump;
                      }
                      while (bytes_to_copy <= row_width);
 
                      /* End of row - 1 byte left, bytes_to_copy > row_width: */
                      dp = (png_bytep)dp16;
                      sp = (png_const_bytep)sp16;
                      do
                         *dp++ = *sp++;
                      while (--row_width > 0);
                      return;
                   }
                }
 #endif /* ALIGN_TYPE code */
 
                /* The true default - use a memcpy: */
                for (;;)
                {
                   memcpy(dp, sp, bytes_to_copy);
 
                   if (row_width <= bytes_to_jump)
                      return;
 
                   sp += bytes_to_jump;
                   dp += bytes_to_jump;
                   row_width -= bytes_to_jump;
                   if (bytes_to_copy > row_width)
                      bytes_to_copy = (unsigned int)/*SAFE*/row_width;
                }
          }
 
          /* NOT REACHED*/
       } /* pixel_depth >= 8 */
 
       /* Here if pixel_depth < 8 to check 'end_ptr' below. */
    }
    else
 #endif /* READ_INTERLACING */
 
    /* If here then the switch above wasn't used so just memcpy the whole row
     * from the temporary row buffer (notice that this overwrites the end of the
     * destination row if it is a partial byte.)
     */
    memcpy(dp, sp, PNG_ROWBYTES(pixel_depth, row_width));
 
    /* Restore the overwritten bits from the last byte if necessary. */
    if (end_ptr != NULL)
       *end_ptr = (png_byte)((end_byte & end_mask) | (*end_ptr & ~end_mask));
 }

void png_do_read_interlace	(	png_row_infop	row_info,
		png_bytep	row,
		int	pass,
		png_uint_32	transformations
	)

 {
    /* Arrays to facilitate easy interlacing - use pass (0 - 6) as index */
    /* Offset to next interlace block */
    static PNG_CONST int png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1};
 
    png_debug(1, "in png_do_read_interlace");
    if (row != NULL && row_info != NULL)
    {
       png_uint_32 final_width;
 
       final_width = row_info->width * png_pass_inc[pass];
 
       switch (row_info->pixel_depth)
       {
          case 1:
          {
             png_bytep sp = row + (png_size_t)((row_info->width - 1) >> 3);
             png_bytep dp = row + (png_size_t)((final_width - 1) >> 3);
             int sshift, dshift;
             int s_start, s_end, s_inc;
             int jstop = png_pass_inc[pass];
             png_byte v;
             png_uint_32 i;
             int j;
 
 #ifdef PNG_READ_PACKSWAP_SUPPORTED
             if ((transformations & PNG_PACKSWAP) != 0)
             {
                 sshift = (int)((row_info->width + 7) & 0x07);
                 dshift = (int)((final_width + 7) & 0x07);
                 s_start = 7;
                 s_end = 0;
                 s_inc = -1;
             }
 
             else
 #endif
             {
                 sshift = 7 - (int)((row_info->width + 7) & 0x07);
                 dshift = 7 - (int)((final_width + 7) & 0x07);
                 s_start = 0;
                 s_end = 7;
                 s_inc = 1;
             }
 
             for (i = 0; i < row_info->width; i++)
             {
                v = (png_byte)((*sp >> sshift) & 0x01);
                for (j = 0; j < jstop; j++)
                {
                   unsigned int tmp = *dp & (0x7f7f >> (7 - dshift));
                   tmp |= v << dshift;
                   *dp = (png_byte)(tmp & 0xff);
 
                   if (dshift == s_end)
                   {
                      dshift = s_start;
                      dp--;
                   }
 
                   else
                      dshift += s_inc;
                }
 
                if (sshift == s_end)
                {
                   sshift = s_start;
                   sp--;
                }
 
                else
                   sshift += s_inc;
             }
             break;
          }
 
          case 2:
          {
             png_bytep sp = row + (png_uint_32)((row_info->width - 1) >> 2);
             png_bytep dp = row + (png_uint_32)((final_width - 1) >> 2);
             int sshift, dshift;
             int s_start, s_end, s_inc;
             int jstop = png_pass_inc[pass];
             png_uint_32 i;
 
 #ifdef PNG_READ_PACKSWAP_SUPPORTED
             if ((transformations & PNG_PACKSWAP) != 0)
             {
                sshift = (int)(((row_info->width + 3) & 0x03) << 1);
                dshift = (int)(((final_width + 3) & 0x03) << 1);
                s_start = 6;
                s_end = 0;
                s_inc = -2;
             }
 
             else
 #endif
             {
                sshift = (int)((3 - ((row_info->width + 3) & 0x03)) << 1);
                dshift = (int)((3 - ((final_width + 3) & 0x03)) << 1);
                s_start = 0;
                s_end = 6;
                s_inc = 2;
             }
 
             for (i = 0; i < row_info->width; i++)
             {
                png_byte v;
                int j;
 
                v = (png_byte)((*sp >> sshift) & 0x03);
                for (j = 0; j < jstop; j++)
                {
                   unsigned int tmp = *dp & (0x3f3f >> (6 - dshift));
                   tmp |= v << dshift;
                   *dp = (png_byte)(tmp & 0xff);
 
                   if (dshift == s_end)
                   {
                      dshift = s_start;
                      dp--;
                   }
 
                   else
                      dshift += s_inc;
                }
 
                if (sshift == s_end)
                {
                   sshift = s_start;
                   sp--;
                }
 
                else
                   sshift += s_inc;
             }
             break;
          }
 
          case 4:
          {
             png_bytep sp = row + (png_size_t)((row_info->width - 1) >> 1);
             png_bytep dp = row + (png_size_t)((final_width - 1) >> 1);
             int sshift, dshift;
             int s_start, s_end, s_inc;
             png_uint_32 i;
             int jstop = png_pass_inc[pass];
 
 #ifdef PNG_READ_PACKSWAP_SUPPORTED
             if ((transformations & PNG_PACKSWAP) != 0)
             {
                sshift = (int)(((row_info->width + 1) & 0x01) << 2);
                dshift = (int)(((final_width + 1) & 0x01) << 2);
                s_start = 4;
                s_end = 0;
                s_inc = -4;
             }
 
             else
 #endif
             {
                sshift = (int)((1 - ((row_info->width + 1) & 0x01)) << 2);
                dshift = (int)((1 - ((final_width + 1) & 0x01)) << 2);
                s_start = 0;
                s_end = 4;
                s_inc = 4;
             }
 
             for (i = 0; i < row_info->width; i++)
             {
                png_byte v = (png_byte)((*sp >> sshift) & 0x0f);
                int j;
 
                for (j = 0; j < jstop; j++)
                {
                   unsigned int tmp = *dp & (0xf0f >> (4 - dshift));
                   tmp |= v << dshift;
                   *dp = (png_byte)(tmp & 0xff);
 
                   if (dshift == s_end)
                   {
                      dshift = s_start;
                      dp--;
                   }
 
                   else
                      dshift += s_inc;
                }
 
                if (sshift == s_end)
                {
                   sshift = s_start;
                   sp--;
                }
 
                else
                   sshift += s_inc;
             }
             break;
          }
 
          default:
          {
             png_size_t pixel_bytes = (row_info->pixel_depth >> 3);
 
             png_bytep sp = row + (png_size_t)(row_info->width - 1)
                 * pixel_bytes;
 
             png_bytep dp = row + (png_size_t)(final_width - 1) * pixel_bytes;
 
             int jstop = png_pass_inc[pass];
             png_uint_32 i;
 
             for (i = 0; i < row_info->width; i++)
             {
                png_byte v[8]; /* SAFE; pixel_depth does not exceed 64 */
                int j;
 
                memcpy(v, sp, pixel_bytes);
 
                for (j = 0; j < jstop; j++)
                {
                   memcpy(dp, v, pixel_bytes);
                   dp -= pixel_bytes;
                }
 
                sp -= pixel_bytes;
             }
             break;
          }
       }
 
       row_info->width = final_width;
       row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth, final_width);
    }
 #ifndef PNG_READ_PACKSWAP_SUPPORTED
    PNG_UNUSED(transformations)  /* Silence compiler warning */
 #endif
 }

void png_do_write_interlace	(	png_row_infop	row_info,
		png_bytep	row,
		int	pass
	)

 {
    /* Arrays to facilitate easy interlacing - use pass (0 - 6) as index */
 
    /* Start of interlace block */
    static PNG_CONST png_byte png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0};
 
    /* Offset to next interlace block */
    static PNG_CONST png_byte  png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1};
 
    png_debug(1, "in png_do_write_interlace");
 
    /* We don't have to do anything on the last pass (6) */
    if (pass < 6)
    {
       /* Each pixel depth is handled separately */
       switch (row_info->pixel_depth)
       {
          case 1:
          {
             png_bytep sp;
             png_bytep dp;
             int shift;
             int d;
             int value;
             png_uint_32 i;
             png_uint_32 row_width = row_info->width;
 
             dp = row;
             d = 0;
             shift = 7;
 
             for (i = png_pass_start[pass]; i < row_width;
                i += png_pass_inc[pass])
             {
                sp = row + (png_size_t)(i >> 3);
                value = (int)(*sp >> (7 - (int)(i & 0x07))) & 0x01;
                d |= (value << shift);
 
                if (shift == 0)
                {
                   shift = 7;
                   *dp++ = (png_byte)d;
                   d = 0;
                }
 
                else
                   shift--;
 
             }
             if (shift != 7)
                *dp = (png_byte)d;
 
             break;
          }
 
          case 2:
          {
             png_bytep sp;
             png_bytep dp;
             int shift;
             int d;
             int value;
             png_uint_32 i;
             png_uint_32 row_width = row_info->width;
 
             dp = row;
             shift = 6;
             d = 0;
 
             for (i = png_pass_start[pass]; i < row_width;
                i += png_pass_inc[pass])
             {
                sp = row + (png_size_t)(i >> 2);
                value = (*sp >> ((3 - (int)(i & 0x03)) << 1)) & 0x03;
                d |= (value << shift);
 
                if (shift == 0)
                {
                   shift = 6;
                   *dp++ = (png_byte)d;
                   d = 0;
                }
 
                else
                   shift -= 2;
             }
             if (shift != 6)
                *dp = (png_byte)d;
 
             break;
          }
 
          case 4:
          {
             png_bytep sp;
             png_bytep dp;
             int shift;
             int d;
             int value;
             png_uint_32 i;
             png_uint_32 row_width = row_info->width;
 
             dp = row;
             shift = 4;
             d = 0;
             for (i = png_pass_start[pass]; i < row_width;
                 i += png_pass_inc[pass])
             {
                sp = row + (png_size_t)(i >> 1);
                value = (*sp >> ((1 - (int)(i & 0x01)) << 2)) & 0x0f;
                d |= (value << shift);
 
                if (shift == 0)
                {
                   shift = 4;
                   *dp++ = (png_byte)d;
                   d = 0;
                }
 
                else
                   shift -= 4;
             }
             if (shift != 4)
                *dp = (png_byte)d;
 
             break;
          }
 
          default:
          {
             png_bytep sp;
             png_bytep dp;
             png_uint_32 i;
             png_uint_32 row_width = row_info->width;
             png_size_t pixel_bytes;
 
             /* Start at the beginning */
             dp = row;
 
             /* Find out how many bytes each pixel takes up */
             pixel_bytes = (row_info->pixel_depth >> 3);
 
             /* Loop through the row, only looking at the pixels that matter */
             for (i = png_pass_start[pass]; i < row_width;
                i += png_pass_inc[pass])
             {
                /* Find out where the original pixel is */
                sp = row + (png_size_t)i * pixel_bytes;
 
                /* Move the pixel */
                if (dp != sp)
                   memcpy(dp, sp, pixel_bytes);
 
                /* Next pixel */
                dp += pixel_bytes;
             }
             break;
          }
       }
       /* Set new row width */
       row_info->width = (row_info->width +
           png_pass_inc[pass] - 1 -
           png_pass_start[pass]) /
           png_pass_inc[pass];
 
       row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth,
           row_info->width);
    }
 }

void png_read_filter_row	(	png_structrp	pp,
		png_row_infop	row_info,
		png_bytep	row,
		png_const_bytep	prev_row,
		int	filter
	)

 {
    /* OPTIMIZATION: DO NOT MODIFY THIS FUNCTION, instead #define
     * PNG_FILTER_OPTIMIZATIONS to a function that overrides the generic
     * implementations.  See png_init_filter_functions above.
     */
    if (filter > PNG_FILTER_VALUE_NONE && filter < PNG_FILTER_VALUE_LAST)
    {
       if (pp->read_filter[0] == NULL)
          png_init_filter_functions(pp);
 
       pp->read_filter[filter-1](row_info, row, prev_row);
    }
 }

void png_read_filter_row_up_neon	(	png_row_infop	row_info,
		png_bytep	row,
		png_const_bytep	prev_row
	)

void png_read_filter_row_sub3_neon	(	png_row_infop	row_info,
		png_bytep	row,
		png_const_bytep	prev_row
	)

void png_read_filter_row_sub4_neon	(	png_row_infop	row_info,
		png_bytep	row,
		png_const_bytep	prev_row
	)

void png_read_filter_row_avg3_neon	(	png_row_infop	row_info,
		png_bytep	row,
		png_const_bytep	prev_row
	)

void png_read_filter_row_avg4_neon	(	png_row_infop	row_info,
		png_bytep	row,
		png_const_bytep	prev_row
	)

void png_read_filter_row_paeth3_neon	(	png_row_infop	row_info,
		png_bytep	row,
		png_const_bytep	prev_row
	)

void png_read_filter_row_paeth4_neon	(	png_row_infop	row_info,
		png_bytep	row,
		png_const_bytep	prev_row
	)

void png_write_find_filter	(	png_structrp	png_ptr,
		png_row_infop	row_info
	)

 {
    png_bytep best_row;
 #ifdef PNG_WRITE_FILTER_SUPPORTED
    png_bytep prev_row, row_buf;
    png_uint_32 mins, bpp;
    png_byte filter_to_do = png_ptr->do_filter;
    png_size_t row_bytes = row_info->rowbytes;
 #ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED
    int num_p_filters = png_ptr->num_prev_filters;
 #endif
 
    png_debug(1, "in png_write_find_filter");
 
 #ifndef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED
   if (png_ptr->row_number == 0 && filter_to_do == PNG_ALL_FILTERS)
   {
      /* These will never be selected so we need not test them. */
      filter_to_do &= ~(PNG_FILTER_UP | PNG_FILTER_PAETH);
   }
 #endif
 
    /* Find out how many bytes offset each pixel is */
    bpp = (row_info->pixel_depth + 7) >> 3;
 
    prev_row = png_ptr->prev_row;
 #endif
    best_row = png_ptr->row_buf;
 #ifdef PNG_WRITE_FILTER_SUPPORTED
    row_buf = best_row;
    mins = PNG_MAXSUM;
 
    /* The prediction method we use is to find which method provides the
     * smallest value when summing the absolute values of the distances
     * from zero, using anything >= 128 as negative numbers.  This is known
     * as the "minimum sum of absolute differences" heuristic.  Other
     * heuristics are the "weighted minimum sum of absolute differences"
     * (experimental and can in theory improve compression), and the "zlib
     * predictive" method (not implemented yet), which does test compressions
     * of lines using different filter methods, and then chooses the
     * (series of) filter(s) that give minimum compressed data size (VERY
     * computationally expensive).
     *
     * GRR 980525:  consider also
     *
     *   (1) minimum sum of absolute differences from running average (i.e.,
     *       keep running sum of non-absolute differences & count of bytes)
     *       [track dispersion, too?  restart average if dispersion too large?]
     *
     *  (1b) minimum sum of absolute differences from sliding average, probably
     *       with window size <= deflate window (usually 32K)
     *
     *   (2) minimum sum of squared differences from zero or running average
     *       (i.e., ~ root-mean-square approach)
     */
 
 
    /* We don't need to test the 'no filter' case if this is the only filter
     * that has been chosen, as it doesn't actually do anything to the data.
     */
    if ((filter_to_do & PNG_FILTER_NONE) != 0 && filter_to_do != PNG_FILTER_NONE)
    {
       png_bytep rp;
       png_uint_32 sum = 0;
       png_size_t i;
       int v;
 
       for (i = 0, rp = row_buf + 1; i < row_bytes; i++, rp++)
       {
          v = *rp;
          sum += (v < 128) ? v : 256 - v;
       }
 
 #ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED
       if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED)
       {
          png_uint_32 sumhi, sumlo;
          int j;
          sumlo = sum & PNG_LOMASK;
          sumhi = (sum >> PNG_HISHIFT) & PNG_HIMASK; /* Gives us some footroom */
 
          /* Reduce the sum if we match any of the previous rows */
          for (j = 0; j < num_p_filters; j++)
          {
             if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_NONE)
             {
                sumlo = (sumlo * png_ptr->filter_weights[j]) >>
                    PNG_WEIGHT_SHIFT;
 
                sumhi = (sumhi * png_ptr->filter_weights[j]) >>
                    PNG_WEIGHT_SHIFT;
             }
          }
 
          /* Factor in the cost of this filter (this is here for completeness,
           * but it makes no sense to have a "cost" for the NONE filter, as
           * it has the minimum possible computational cost - none).
           */
          sumlo = (sumlo * png_ptr->filter_costs[PNG_FILTER_VALUE_NONE]) >>
              PNG_COST_SHIFT;
 
          sumhi = (sumhi * png_ptr->filter_costs[PNG_FILTER_VALUE_NONE]) >>
              PNG_COST_SHIFT;
 
          if (sumhi > PNG_HIMASK)
             sum = PNG_MAXSUM;
 
          else
             sum = (sumhi << PNG_HISHIFT) + sumlo;
       }
 #endif
       mins = sum;
    }
 
    /* Sub filter */
    if (filter_to_do == PNG_FILTER_SUB)
    /* It's the only filter so no testing is needed */
    {
       png_bytep rp, lp, dp;
       png_size_t i;
 
       for (i = 0, rp = row_buf + 1, dp = png_ptr->sub_row + 1; i < bpp;
            i++, rp++, dp++)
       {
          *dp = *rp;
       }
 
       for (lp = row_buf + 1; i < row_bytes;
          i++, rp++, lp++, dp++)
       {
          *dp = (png_byte)(((int)*rp - (int)*lp) & 0xff);
       }
 
       best_row = png_ptr->sub_row;
    }
 
    else if ((filter_to_do & PNG_FILTER_SUB) != 0)
    {
       png_bytep rp, dp, lp;
       png_uint_32 sum = 0, lmins = mins;
       png_size_t i;
       int v;
 
 #ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED
       /* We temporarily increase the "minimum sum" by the factor we
        * would reduce the sum of this filter, so that we can do the
        * early exit comparison without scaling the sum each time.
        */
       if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED)
       {
          int j;
          png_uint_32 lmhi, lmlo;
          lmlo = lmins & PNG_LOMASK;
          lmhi = (lmins >> PNG_HISHIFT) & PNG_HIMASK;
 
          for (j = 0; j < num_p_filters; j++)
          {
             if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_SUB)
             {
                lmlo = (lmlo * png_ptr->inv_filter_weights[j]) >>
                    PNG_WEIGHT_SHIFT;
 
                lmhi = (lmhi * png_ptr->inv_filter_weights[j]) >>
                    PNG_WEIGHT_SHIFT;
             }
          }
 
          lmlo = (lmlo * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_SUB]) >>
              PNG_COST_SHIFT;
 
          lmhi = (lmhi * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_SUB]) >>
              PNG_COST_SHIFT;
 
          if (lmhi > PNG_HIMASK)
             lmins = PNG_MAXSUM;
 
          else
             lmins = (lmhi << PNG_HISHIFT) + lmlo;
       }
 #endif
 
       for (i = 0, rp = row_buf + 1, dp = png_ptr->sub_row + 1; i < bpp;
            i++, rp++, dp++)
       {
          v = *dp = *rp;
 
          sum += (v < 128) ? v : 256 - v;
       }
 
       for (lp = row_buf + 1; i < row_bytes;
          i++, rp++, lp++, dp++)
       {
          v = *dp = (png_byte)(((int)*rp - (int)*lp) & 0xff);
 
          sum += (v < 128) ? v : 256 - v;
 
          if (sum > lmins)  /* We are already worse, don't continue. */
             break;
       }
 
 #ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED
       if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED)
       {
          int j;
          png_uint_32 sumhi, sumlo;
          sumlo = sum & PNG_LOMASK;
          sumhi = (sum >> PNG_HISHIFT) & PNG_HIMASK;
 
          for (j = 0; j < num_p_filters; j++)
          {
             if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_SUB)
             {
                sumlo = (sumlo * png_ptr->inv_filter_weights[j]) >>
                    PNG_WEIGHT_SHIFT;
 
                sumhi = (sumhi * png_ptr->inv_filter_weights[j]) >>
                    PNG_WEIGHT_SHIFT;
             }
          }
 
          sumlo = (sumlo * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_SUB]) >>
              PNG_COST_SHIFT;
 
          sumhi = (sumhi * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_SUB]) >>
              PNG_COST_SHIFT;
 
          if (sumhi > PNG_HIMASK)
             sum = PNG_MAXSUM;
 
          else
             sum = (sumhi << PNG_HISHIFT) + sumlo;
       }
 #endif
 
       if (sum < mins)
       {
          mins = sum;
          best_row = png_ptr->sub_row;
       }
    }
 
    /* Up filter */
    if (filter_to_do == PNG_FILTER_UP)
    {
       png_bytep rp, dp, pp;
       png_size_t i;
 
       for (i = 0, rp = row_buf + 1, dp = png_ptr->up_row + 1,
           pp = prev_row + 1; i < row_bytes;
           i++, rp++, pp++, dp++)
       {
          *dp = (png_byte)(((int)*rp - (int)*pp) & 0xff);
       }
 
       best_row = png_ptr->up_row;
    }
 
    else if ((filter_to_do & PNG_FILTER_UP) != 0)
    {
       png_bytep rp, dp, pp;
       png_uint_32 sum = 0, lmins = mins;
       png_size_t i;
       int v;
 
 
 #ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED
       if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED)
       {
          int j;
          png_uint_32 lmhi, lmlo;
          lmlo = lmins & PNG_LOMASK;
          lmhi = (lmins >> PNG_HISHIFT) & PNG_HIMASK;
 
          for (j = 0; j < num_p_filters; j++)
          {
             if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_UP)
             {
                lmlo = (lmlo * png_ptr->inv_filter_weights[j]) >>
                    PNG_WEIGHT_SHIFT;
 
                lmhi = (lmhi * png_ptr->inv_filter_weights[j]) >>
                    PNG_WEIGHT_SHIFT;
             }
          }
 
          lmlo = (lmlo * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_UP]) >>
              PNG_COST_SHIFT;
 
          lmhi = (lmhi * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_UP]) >>
              PNG_COST_SHIFT;
 
          if (lmhi > PNG_HIMASK)
             lmins = PNG_MAXSUM;
 
          else
             lmins = (lmhi << PNG_HISHIFT) + lmlo;
       }
 #endif
 
       for (i = 0, rp = row_buf + 1, dp = png_ptr->up_row + 1,
           pp = prev_row + 1; i < row_bytes; i++)
       {
          v = *dp++ = (png_byte)(((int)*rp++ - (int)*pp++) & 0xff);
 
          sum += (v < 128) ? v : 256 - v;
 
          if (sum > lmins)  /* We are already worse, don't continue. */
             break;
       }
 
 #ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED
       if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED)
       {
          int j;
          png_uint_32 sumhi, sumlo;
          sumlo = sum & PNG_LOMASK;
          sumhi = (sum >> PNG_HISHIFT) & PNG_HIMASK;
 
          for (j = 0; j < num_p_filters; j++)
          {
             if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_UP)
             {
                sumlo = (sumlo * png_ptr->filter_weights[j]) >>
                    PNG_WEIGHT_SHIFT;
 
                sumhi = (sumhi * png_ptr->filter_weights[j]) >>
                    PNG_WEIGHT_SHIFT;
             }
          }
 
          sumlo = (sumlo * png_ptr->filter_costs[PNG_FILTER_VALUE_UP]) >>
              PNG_COST_SHIFT;
 
          sumhi = (sumhi * png_ptr->filter_costs[PNG_FILTER_VALUE_UP]) >>
              PNG_COST_SHIFT;
 
          if (sumhi > PNG_HIMASK)
             sum = PNG_MAXSUM;
 
          else
             sum = (sumhi << PNG_HISHIFT) + sumlo;
       }
 #endif
 
       if (sum < mins)
       {
          mins = sum;
          best_row = png_ptr->up_row;
       }
    }
 
    /* Avg filter */
    if (filter_to_do == PNG_FILTER_AVG)
    {
       png_bytep rp, dp, pp, lp;
       png_uint_32 i;
 
       for (i = 0, rp = row_buf + 1, dp = png_ptr->avg_row + 1,
            pp = prev_row + 1; i < bpp; i++)
       {
          *dp++ = (png_byte)(((int)*rp++ - ((int)*pp++ / 2)) & 0xff);
       }
 
       for (lp = row_buf + 1; i < row_bytes; i++)
       {
          *dp++ = (png_byte)(((int)*rp++ - (((int)*pp++ + (int)*lp++) / 2))
                  & 0xff);
       }
       best_row = png_ptr->avg_row;
    }
 
    else if ((filter_to_do & PNG_FILTER_AVG) != 0)
    {
       png_bytep rp, dp, pp, lp;
       png_uint_32 sum = 0, lmins = mins;
       png_size_t i;
       int v;
 
 #ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED
       if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED)
       {
          int j;
          png_uint_32 lmhi, lmlo;
          lmlo = lmins & PNG_LOMASK;
          lmhi = (lmins >> PNG_HISHIFT) & PNG_HIMASK;
 
          for (j = 0; j < num_p_filters; j++)
          {
             if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_AVG)
             {
                lmlo = (lmlo * png_ptr->inv_filter_weights[j]) >>
                    PNG_WEIGHT_SHIFT;
 
                lmhi = (lmhi * png_ptr->inv_filter_weights[j]) >>
                    PNG_WEIGHT_SHIFT;
             }
          }
 
          lmlo = (lmlo * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_AVG]) >>
              PNG_COST_SHIFT;
 
          lmhi = (lmhi * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_AVG]) >>
              PNG_COST_SHIFT;
 
          if (lmhi > PNG_HIMASK)
             lmins = PNG_MAXSUM;
 
          else
             lmins = (lmhi << PNG_HISHIFT) + lmlo;
       }
 #endif
 
       for (i = 0, rp = row_buf + 1, dp = png_ptr->avg_row + 1,
            pp = prev_row + 1; i < bpp; i++)
       {
          v = *dp++ = (png_byte)(((int)*rp++ - ((int)*pp++ / 2)) & 0xff);
 
          sum += (v < 128) ? v : 256 - v;
       }
 
       for (lp = row_buf + 1; i < row_bytes; i++)
       {
          v = *dp++ =
              (png_byte)(((int)*rp++ - (((int)*pp++ + (int)*lp++) / 2)) & 0xff);
 
          sum += (v < 128) ? v : 256 - v;
 
          if (sum > lmins)  /* We are already worse, don't continue. */
             break;
       }
 
 #ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED
       if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED)
       {
          int j;
          png_uint_32 sumhi, sumlo;
          sumlo = sum & PNG_LOMASK;
          sumhi = (sum >> PNG_HISHIFT) & PNG_HIMASK;
 
          for (j = 0; j < num_p_filters; j++)
          {
             if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_NONE)
             {
                sumlo = (sumlo * png_ptr->filter_weights[j]) >>
                    PNG_WEIGHT_SHIFT;
 
                sumhi = (sumhi * png_ptr->filter_weights[j]) >>
                    PNG_WEIGHT_SHIFT;
             }
          }
 
          sumlo = (sumlo * png_ptr->filter_costs[PNG_FILTER_VALUE_AVG]) >>
              PNG_COST_SHIFT;
 
          sumhi = (sumhi * png_ptr->filter_costs[PNG_FILTER_VALUE_AVG]) >>
              PNG_COST_SHIFT;
 
          if (sumhi > PNG_HIMASK)
             sum = PNG_MAXSUM;
 
          else
             sum = (sumhi << PNG_HISHIFT) + sumlo;
       }
 #endif
 
       if (sum < mins)
       {
          mins = sum;
          best_row = png_ptr->avg_row;
       }
    }
 
    /* Paeth filter */
    if ((filter_to_do == PNG_FILTER_PAETH) != 0)
    {
       png_bytep rp, dp, pp, cp, lp;
       png_size_t i;
 
       for (i = 0, rp = row_buf + 1, dp = png_ptr->paeth_row + 1,
           pp = prev_row + 1; i < bpp; i++)
       {
          *dp++ = (png_byte)(((int)*rp++ - (int)*pp++) & 0xff);
       }
 
       for (lp = row_buf + 1, cp = prev_row + 1; i < row_bytes; i++)
       {
          int a, b, c, pa, pb, pc, p;
 
          b = *pp++;
          c = *cp++;
          a = *lp++;
 
          p = b - c;
          pc = a - c;
 
 #ifdef PNG_USE_ABS
          pa = abs(p);
          pb = abs(pc);
          pc = abs(p + pc);
 #else
          pa = p < 0 ? -p : p;
          pb = pc < 0 ? -pc : pc;
          pc = (p + pc) < 0 ? -(p + pc) : p + pc;
 #endif
 
          p = (pa <= pb && pa <=pc) ? a : (pb <= pc) ? b : c;
 
          *dp++ = (png_byte)(((int)*rp++ - p) & 0xff);
       }
       best_row = png_ptr->paeth_row;
    }
 
    else if ((filter_to_do & PNG_FILTER_PAETH) != 0)
    {
       png_bytep rp, dp, pp, cp, lp;
       png_uint_32 sum = 0, lmins = mins;
       png_size_t i;
       int v;
 
 #ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED
       if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED)
       {
          int j;
          png_uint_32 lmhi, lmlo;
          lmlo = lmins & PNG_LOMASK;
          lmhi = (lmins >> PNG_HISHIFT) & PNG_HIMASK;
 
          for (j = 0; j < num_p_filters; j++)
          {
             if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_PAETH)
             {
                lmlo = (lmlo * png_ptr->inv_filter_weights[j]) >>
                    PNG_WEIGHT_SHIFT;
 
                lmhi = (lmhi * png_ptr->inv_filter_weights[j]) >>
                    PNG_WEIGHT_SHIFT;
             }
          }
 
          lmlo = (lmlo * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_PAETH]) >>
              PNG_COST_SHIFT;
 
          lmhi = (lmhi * png_ptr->inv_filter_costs[PNG_FILTER_VALUE_PAETH]) >>
              PNG_COST_SHIFT;
 
          if (lmhi > PNG_HIMASK)
             lmins = PNG_MAXSUM;
 
          else
             lmins = (lmhi << PNG_HISHIFT) + lmlo;
       }
 #endif
 
       for (i = 0, rp = row_buf + 1, dp = png_ptr->paeth_row + 1,
           pp = prev_row + 1; i < bpp; i++)
       {
          v = *dp++ = (png_byte)(((int)*rp++ - (int)*pp++) & 0xff);
 
          sum += (v < 128) ? v : 256 - v;
       }
 
       for (lp = row_buf + 1, cp = prev_row + 1; i < row_bytes; i++)
       {
          int a, b, c, pa, pb, pc, p;
 
          b = *pp++;
          c = *cp++;
          a = *lp++;
 
 #ifndef PNG_SLOW_PAETH
          p = b - c;
          pc = a - c;
 #ifdef PNG_USE_ABS
          pa = abs(p);
          pb = abs(pc);
          pc = abs(p + pc);
 #else
          pa = p < 0 ? -p : p;
          pb = pc < 0 ? -pc : pc;
          pc = (p + pc) < 0 ? -(p + pc) : p + pc;
 #endif
          p = (pa <= pb && pa <=pc) ? a : (pb <= pc) ? b : c;
 #else /* SLOW_PAETH */
          p = a + b - c;
          pa = abs(p - a);
          pb = abs(p - b);
          pc = abs(p - c);
 
          if (pa <= pb && pa <= pc)
             p = a;
 
          else if (pb <= pc)
             p = b;
 
          else
             p = c;
 #endif /* SLOW_PAETH */
 
          v = *dp++ = (png_byte)(((int)*rp++ - p) & 0xff);
 
          sum += (v < 128) ? v : 256 - v;
 
          if (sum > lmins)  /* We are already worse, don't continue. */
             break;
       }
 
 #ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED
       if (png_ptr->heuristic_method == PNG_FILTER_HEURISTIC_WEIGHTED)
       {
          int j;
          png_uint_32 sumhi, sumlo;
          sumlo = sum & PNG_LOMASK;
          sumhi = (sum >> PNG_HISHIFT) & PNG_HIMASK;
 
          for (j = 0; j < num_p_filters; j++)
          {
             if (png_ptr->prev_filters[j] == PNG_FILTER_VALUE_PAETH)
             {
                sumlo = (sumlo * png_ptr->filter_weights[j]) >>
                    PNG_WEIGHT_SHIFT;
 
                sumhi = (sumhi * png_ptr->filter_weights[j]) >>
                    PNG_WEIGHT_SHIFT;
             }
          }
 
          sumlo = (sumlo * png_ptr->filter_costs[PNG_FILTER_VALUE_PAETH]) >>
              PNG_COST_SHIFT;
 
          sumhi = (sumhi * png_ptr->filter_costs[PNG_FILTER_VALUE_PAETH]) >>
              PNG_COST_SHIFT;
 
          if (sumhi > PNG_HIMASK)
             sum = PNG_MAXSUM;
 
          else
             sum = (sumhi << PNG_HISHIFT) + sumlo;
       }
 #endif
 
       if (sum < mins)
       {
          best_row = png_ptr->paeth_row;
       }
    }
 #endif /* WRITE_FILTER */
 
    /* Do the actual writing of the filtered row data from the chosen filter. */
    png_write_filtered_row(png_ptr, best_row, row_info->rowbytes+1);
 
 #ifdef PNG_WRITE_FILTER_SUPPORTED
 #ifdef PNG_WRITE_WEIGHTED_FILTER_SUPPORTED
    /* Save the type of filter we picked this time for future calculations */
    if (png_ptr->num_prev_filters > 0)
    {
       int j;
 
       for (j = 1; j < num_p_filters; j++)
       {
          png_ptr->prev_filters[j] = png_ptr->prev_filters[j - 1];
       }
 
       png_ptr->prev_filters[j] = best_row[0];
    }
 #endif
 #endif /* WRITE_FILTER */
 }

void png_read_IDAT_data	(	png_structrp	png_ptr,
		png_bytep	output,
		png_alloc_size_t	avail_out
	)

 {
    /* Loop reading IDATs and decompressing the result into output[avail_out] */
    png_ptr->zstream.next_out = output;
    png_ptr->zstream.avail_out = 0; /* safety: set below */
 
    if (output == NULL)
       avail_out = 0;
 
    do
    {
       int ret;
       png_byte tmpbuf[PNG_INFLATE_BUF_SIZE];
 
       if (png_ptr->zstream.avail_in == 0)
       {
          uInt avail_in;
          png_bytep buffer;
 
          while (png_ptr->idat_size == 0)
          {
             png_crc_finish(png_ptr, 0);
 
             png_ptr->idat_size = png_read_chunk_header(png_ptr);
             /* This is an error even in the 'check' case because the code just
              * consumed a non-IDAT header.
              */
             if (png_ptr->chunk_name != png_IDAT)
                png_error(png_ptr, "Not enough image data");
          }
 
          avail_in = png_ptr->IDAT_read_size;
 
          if (avail_in > png_ptr->idat_size)
             avail_in = (uInt)png_ptr->idat_size;
 
          /* A PNG with a gradually increasing IDAT size will defeat this attempt
           * to minimize memory usage by causing lots of re-allocs, but
           * realistically doing IDAT_read_size re-allocs is not likely to be a
           * big problem.
           */
          buffer = png_read_buffer(png_ptr, avail_in, 0/*error*/);
 
          png_crc_read(png_ptr, buffer, avail_in);
          png_ptr->idat_size -= avail_in;
 
          png_ptr->zstream.next_in = buffer;
          png_ptr->zstream.avail_in = avail_in;
       }
 
       /* And set up the output side. */
       if (output != NULL) /* standard read */
       {
          uInt out = ZLIB_IO_MAX;
 
          if (out > avail_out)
             out = (uInt)avail_out;
 
          avail_out -= out;
          png_ptr->zstream.avail_out = out;
       }
 
       else /* after last row, checking for end */
       {
          png_ptr->zstream.next_out = tmpbuf;
          png_ptr->zstream.avail_out = (sizeof tmpbuf);
       }
 
       /* Use NO_FLUSH; this gives zlib the maximum opportunity to optimize the
        * process.  If the LZ stream is truncated the sequential reader will
        * terminally damage the stream, above, by reading the chunk header of the
        * following chunk (it then exits with png_error).
        *
        * TODO: deal more elegantly with truncated IDAT lists.
        */
       ret = inflate(&png_ptr->zstream, Z_NO_FLUSH);
 
       /* Take the unconsumed output back. */
       if (output != NULL)
          avail_out += png_ptr->zstream.avail_out;
 
       else /* avail_out counts the extra bytes */
          avail_out += (sizeof tmpbuf) - png_ptr->zstream.avail_out;
 
       png_ptr->zstream.avail_out = 0;
 
       if (ret == Z_STREAM_END)
       {
          /* Do this for safety; we won't read any more into this row. */
          png_ptr->zstream.next_out = NULL;
 
          png_ptr->mode |= PNG_AFTER_IDAT;
          png_ptr->flags |= PNG_FLAG_ZSTREAM_ENDED;
 
          if (png_ptr->zstream.avail_in > 0 || png_ptr->idat_size > 0)
             png_chunk_benign_error(png_ptr, "Extra compressed data");
          break;
       }
 
       if (ret != Z_OK)
       {
          png_zstream_error(png_ptr, ret);
 
          if (output != NULL)
             png_chunk_error(png_ptr, png_ptr->zstream.msg);
 
          else /* checking */
          {
             png_chunk_benign_error(png_ptr, png_ptr->zstream.msg);
             return;
          }
       }
    } while (avail_out > 0);
 
    if (avail_out > 0)
    {
       /* The stream ended before the image; this is the same as too few IDATs so
        * should be handled the same way.
        */
       if (output != NULL)
          png_error(png_ptr, "Not enough image data");
 
       else /* the deflate stream contained extra data */
          png_chunk_benign_error(png_ptr, "Too much image data");
    }
 }

void png_read_finish_IDAT ( png_structrp png_ptr )

 {
    /* We don't need any more data and the stream should have ended, however the
     * LZ end code may actually not have been processed.  In this case we must
     * read it otherwise stray unread IDAT data or, more likely, an IDAT chunk
     * may still remain to be consumed.
     */
    if ((png_ptr->flags & PNG_FLAG_ZSTREAM_ENDED) == 0)
    {
       /* The NULL causes png_read_IDAT_data to swallow any remaining bytes in
        * the compressed stream, but the stream may be damaged too, so even after
        * this call we may need to terminate the zstream ownership.
        */
       png_read_IDAT_data(png_ptr, NULL, 0);
       png_ptr->zstream.next_out = NULL; /* safety */
 
       /* Now clear everything out for safety; the following may not have been
        * done.
        */
       if ((png_ptr->flags & PNG_FLAG_ZSTREAM_ENDED) == 0)
       {
          png_ptr->mode |= PNG_AFTER_IDAT;
          png_ptr->flags |= PNG_FLAG_ZSTREAM_ENDED;
       }
    }
 
    /* If the zstream has not been released do it now *and* terminate the reading
     * of the final IDAT chunk.
     */
    if (png_ptr->zowner == png_IDAT)
    {
       /* Always do this; the pointers otherwise point into the read buffer. */
       png_ptr->zstream.next_in = NULL;
       png_ptr->zstream.avail_in = 0;
 
       /* Now we no longer own the zstream. */
       png_ptr->zowner = 0;
 
       /* The slightly weird semantics of the sequential IDAT reading is that we
        * are always in or at the end of an IDAT chunk, so we always need to do a
        * crc_finish here.  If idat_size is non-zero we also need to read the
        * spurious bytes at the end of the chunk now.
        */
       (void)png_crc_finish(png_ptr, png_ptr->idat_size);
    }
 }

void png_read_finish_row ( png_structrp png_ptr )

 {
    /* Arrays to facilitate easy interlacing - use pass (0 - 6) as index */
 
    /* Start of interlace block */
    static PNG_CONST png_byte png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0};
 
    /* Offset to next interlace block */
    static PNG_CONST png_byte png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1};
 
    /* Start of interlace block in the y direction */
    static PNG_CONST png_byte png_pass_ystart[7] = {0, 0, 4, 0, 2, 0, 1};
 
    /* Offset to next interlace block in the y direction */
    static PNG_CONST png_byte png_pass_yinc[7] = {8, 8, 8, 4, 4, 2, 2};
 
    png_debug(1, "in png_read_finish_row");
    png_ptr->row_number++;
    if (png_ptr->row_number < png_ptr->num_rows)
       return;
 
    if (png_ptr->interlaced != 0)
    {
       png_ptr->row_number = 0;
 
       /* TO DO: don't do this if prev_row isn't needed (requires
        * read-ahead of the next row's filter byte.
        */
       memset(png_ptr->prev_row, 0, png_ptr->rowbytes + 1);
 
       do
       {
          png_ptr->pass++;
 
          if (png_ptr->pass >= 7)
             break;
 
          png_ptr->iwidth = (png_ptr->width +
             png_pass_inc[png_ptr->pass] - 1 -
             png_pass_start[png_ptr->pass]) /
             png_pass_inc[png_ptr->pass];
 
          if ((png_ptr->transformations & PNG_INTERLACE) == 0)
          {
             png_ptr->num_rows = (png_ptr->height +
                 png_pass_yinc[png_ptr->pass] - 1 -
                 png_pass_ystart[png_ptr->pass]) /
                 png_pass_yinc[png_ptr->pass];
          }
 
          else  /* if (png_ptr->transformations & PNG_INTERLACE) */
             break; /* libpng deinterlacing sees every row */
 
       } while (png_ptr->num_rows == 0 || png_ptr->iwidth == 0);
 
       if (png_ptr->pass < 7)
          return;
    }
 
    /* Here after at the end of the last row of the last pass. */
    png_read_finish_IDAT(png_ptr);
 }

void png_read_start_row ( png_structrp png_ptr )

 {
    /* Arrays to facilitate easy interlacing - use pass (0 - 6) as index */
 
    /* Start of interlace block */
    static PNG_CONST png_byte png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0};
 
    /* Offset to next interlace block */
    static PNG_CONST png_byte png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1};
 
    /* Start of interlace block in the y direction */
    static PNG_CONST png_byte png_pass_ystart[7] = {0, 0, 4, 0, 2, 0, 1};
 
    /* Offset to next interlace block in the y direction */
    static PNG_CONST png_byte png_pass_yinc[7] = {8, 8, 8, 4, 4, 2, 2};
 
    int max_pixel_depth;
    png_size_t row_bytes;
 
    png_debug(1, "in png_read_start_row");
 
 #ifdef PNG_READ_TRANSFORMS_SUPPORTED
    png_init_read_transformations(png_ptr);
 #endif
    if (png_ptr->interlaced != 0)
    {
       if ((png_ptr->transformations & PNG_INTERLACE) == 0)
          png_ptr->num_rows = (png_ptr->height + png_pass_yinc[0] - 1 -
              png_pass_ystart[0]) / png_pass_yinc[0];
 
       else
          png_ptr->num_rows = png_ptr->height;
 
       png_ptr->iwidth = (png_ptr->width +
           png_pass_inc[png_ptr->pass] - 1 -
           png_pass_start[png_ptr->pass]) /
           png_pass_inc[png_ptr->pass];
    }
 
    else
    {
       png_ptr->num_rows = png_ptr->height;
       png_ptr->iwidth = png_ptr->width;
    }
 
    max_pixel_depth = png_ptr->pixel_depth;
 
    /* WARNING: * png_read_transform_info (pngrtran.c) performs a simpler set of
     * calculations to calculate the final pixel depth, then
     * png_do_read_transforms actually does the transforms.  This means that the
     * code which effectively calculates this value is actually repeated in three
     * separate places.  They must all match.  Innocent changes to the order of
     * transformations can and will break libpng in a way that causes memory
     * overwrites.
     *
     * TODO: fix this.
     */
 #ifdef PNG_READ_PACK_SUPPORTED
    if ((png_ptr->transformations & PNG_PACK) != 0 && png_ptr->bit_depth < 8)
       max_pixel_depth = 8;
 #endif
 
 #ifdef PNG_READ_EXPAND_SUPPORTED
    if ((png_ptr->transformations & PNG_EXPAND) != 0)
    {
       if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
       {
          if (png_ptr->num_trans != 0)
             max_pixel_depth = 32;
 
          else
             max_pixel_depth = 24;
       }
 
       else if (png_ptr->color_type == PNG_COLOR_TYPE_GRAY)
       {
          if (max_pixel_depth < 8)
             max_pixel_depth = 8;
 
          if (png_ptr->num_trans != 0)
             max_pixel_depth *= 2;
       }
 
       else if (png_ptr->color_type == PNG_COLOR_TYPE_RGB)
       {
          if (png_ptr->num_trans != 0)
          {
             max_pixel_depth *= 4;
             max_pixel_depth /= 3;
          }
       }
    }
 #endif
 
 #ifdef PNG_READ_EXPAND_16_SUPPORTED
    if ((png_ptr->transformations & PNG_EXPAND_16) != 0)
    {
 #     ifdef PNG_READ_EXPAND_SUPPORTED
          /* In fact it is an error if it isn't supported, but checking is
           * the safe way.
           */
          if ((png_ptr->transformations & PNG_EXPAND) != 0)
          {
             if (png_ptr->bit_depth < 16)
                max_pixel_depth *= 2;
          }
          else
 #     endif
          png_ptr->transformations &= ~PNG_EXPAND_16;
    }
 #endif
 
 #ifdef PNG_READ_FILLER_SUPPORTED
    if ((png_ptr->transformations & (PNG_FILLER)) != 0)
    {
       if (png_ptr->color_type == PNG_COLOR_TYPE_GRAY)
       {
          if (max_pixel_depth <= 8)
             max_pixel_depth = 16;
 
          else
             max_pixel_depth = 32;
       }
 
       else if (png_ptr->color_type == PNG_COLOR_TYPE_RGB ||
          png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
       {
          if (max_pixel_depth <= 32)
             max_pixel_depth = 32;
 
          else
             max_pixel_depth = 64;
       }
    }
 #endif
 
 #ifdef PNG_READ_GRAY_TO_RGB_SUPPORTED
    if ((png_ptr->transformations & PNG_GRAY_TO_RGB) != 0)
    {
       if (
 #ifdef PNG_READ_EXPAND_SUPPORTED
           (png_ptr->num_trans != 0 &&
           (png_ptr->transformations & PNG_EXPAND) != 0) ||
 #endif
 #ifdef PNG_READ_FILLER_SUPPORTED
           (png_ptr->transformations & (PNG_FILLER)) != 0 ||
 #endif
           png_ptr->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
       {
          if (max_pixel_depth <= 16)
             max_pixel_depth = 32;
 
          else
             max_pixel_depth = 64;
       }
 
       else
       {
          if (max_pixel_depth <= 8)
          {
             if (png_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
                max_pixel_depth = 32;
 
             else
                max_pixel_depth = 24;
          }
 
          else if (png_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
             max_pixel_depth = 64;
 
          else
             max_pixel_depth = 48;
       }
    }
 #endif
 
 #if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) && \
 defined(PNG_USER_TRANSFORM_PTR_SUPPORTED)
    if ((png_ptr->transformations & PNG_USER_TRANSFORM) != 0)
    {
       int user_pixel_depth = png_ptr->user_transform_depth *
          png_ptr->user_transform_channels;
 
       if (user_pixel_depth > max_pixel_depth)
          max_pixel_depth = user_pixel_depth;
    }
 #endif
 
    /* This value is stored in png_struct and double checked in the row read
     * code.
     */
    png_ptr->maximum_pixel_depth = (png_byte)max_pixel_depth;
    png_ptr->transformed_pixel_depth = 0; /* calculated on demand */
 
    /* Align the width on the next larger 8 pixels.  Mainly used
     * for interlacing
     */
    row_bytes = ((png_ptr->width + 7) & ~((png_uint_32)7));
    /* Calculate the maximum bytes needed, adding a byte and a pixel
     * for safety's sake
     */
    row_bytes = PNG_ROWBYTES(max_pixel_depth, row_bytes) +
        1 + ((max_pixel_depth + 7) >> 3);
 
 #ifdef PNG_MAX_MALLOC_64K
    if (row_bytes > (png_uint_32)65536L)
       png_error(png_ptr, "This image requires a row greater than 64KB");
 #endif
 
    if (row_bytes + 48 > png_ptr->old_big_row_buf_size)
    {
      png_free(png_ptr, png_ptr->big_row_buf);
      png_free(png_ptr, png_ptr->big_prev_row);
 
      if (png_ptr->interlaced != 0)
         png_ptr->big_row_buf = (png_bytep)png_calloc(png_ptr,
             row_bytes + 48);
 
      else
         png_ptr->big_row_buf = (png_bytep)png_malloc(png_ptr, row_bytes + 48);
 
      png_ptr->big_prev_row = (png_bytep)png_malloc(png_ptr, row_bytes + 48);
 
 #ifdef PNG_ALIGNED_MEMORY_SUPPORTED
      /* Use 16-byte aligned memory for row_buf with at least 16 bytes
       * of padding before and after row_buf; treat prev_row similarly.
       * NOTE: the alignment is to the start of the pixels, one beyond the start
       * of the buffer, because of the filter byte.  Prior to libpng 1.5.6 this
       * was incorrect; the filter byte was aligned, which had the exact
       * opposite effect of that intended.
       */
      {
         png_bytep temp = png_ptr->big_row_buf + 32;
         int extra = (int)((temp - (png_bytep)0) & 0x0f);
         png_ptr->row_buf = temp - extra - 1/*filter byte*/;
 
         temp = png_ptr->big_prev_row + 32;
         extra = (int)((temp - (png_bytep)0) & 0x0f);
         png_ptr->prev_row = temp - extra - 1/*filter byte*/;
      }
 
 #else
      /* Use 31 bytes of padding before and 17 bytes after row_buf. */
      png_ptr->row_buf = png_ptr->big_row_buf + 31;
      png_ptr->prev_row = png_ptr->big_prev_row + 31;
 #endif
      png_ptr->old_big_row_buf_size = row_bytes + 48;
    }
 
 #ifdef PNG_MAX_MALLOC_64K
    if (png_ptr->rowbytes > 65535)
       png_error(png_ptr, "This image requires a row greater than 64KB");
 
 #endif
    if (png_ptr->rowbytes > (PNG_SIZE_MAX - 1))
       png_error(png_ptr, "Row has too many bytes to allocate in memory");
 
    memset(png_ptr->prev_row, 0, png_ptr->rowbytes + 1);
 
    png_debug1(3, "width = %u,", png_ptr->width);
    png_debug1(3, "height = %u,", png_ptr->height);
    png_debug1(3, "iwidth = %u,", png_ptr->iwidth);
    png_debug1(3, "num_rows = %u,", png_ptr->num_rows);
    png_debug1(3, "rowbytes = %lu,", (unsigned long)png_ptr->rowbytes);
    png_debug1(3, "irowbytes = %lu",
        (unsigned long)PNG_ROWBYTES(png_ptr->pixel_depth, png_ptr->iwidth) + 1);
 
    /* The sequential reader needs a buffer for IDAT, but the progressive reader
     * does not, so free the read buffer now regardless; the sequential reader
     * reallocates it on demand.
     */
    if (png_ptr->read_buffer != 0)
    {
       png_bytep buffer = png_ptr->read_buffer;
 
       png_ptr->read_buffer_size = 0;
       png_ptr->read_buffer = NULL;
       png_free(png_ptr, buffer);
    }
 
    /* Finally claim the zstream for the inflate of the IDAT data, use the bits
     * value from the stream (note that this will result in a fatal error if the
     * IDAT stream has a bogus deflate header window_bits value, but this should
     * not be happening any longer!)
     */
    if (png_inflate_claim(png_ptr, png_IDAT) != Z_OK)
       png_error(png_ptr, png_ptr->zstream.msg);
 
    png_ptr->flags |= PNG_FLAG_ROW_INIT;
 }

void png_read_transform_info	(	png_structrp	png_ptr,
		png_inforp	info_ptr
	)

 {
    png_debug(1, "in png_read_transform_info");
 
 #ifdef PNG_READ_EXPAND_SUPPORTED
    if ((png_ptr->transformations & PNG_EXPAND) != 0)
    {
       if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
       {
          /* This check must match what actually happens in
           * png_do_expand_palette; if it ever checks the tRNS chunk to see if
           * it is all opaque we must do the same (at present it does not.)
           */
          if (png_ptr->num_trans > 0)
             info_ptr->color_type = PNG_COLOR_TYPE_RGB_ALPHA;
 
          else
             info_ptr->color_type = PNG_COLOR_TYPE_RGB;
 
          info_ptr->bit_depth = 8;
          info_ptr->num_trans = 0;
 
          if (png_ptr->palette == NULL)
             png_error (png_ptr, "Palette is NULL in indexed image");
       }
       else
       {
          if (png_ptr->num_trans != 0)
          {
             if ((png_ptr->transformations & PNG_EXPAND_tRNS) != 0)
                info_ptr->color_type |= PNG_COLOR_MASK_ALPHA;
          }
          if (info_ptr->bit_depth < 8)
             info_ptr->bit_depth = 8;
 
          info_ptr->num_trans = 0;
       }
    }
 #endif
 
 #if defined(PNG_READ_BACKGROUND_SUPPORTED) ||\
    defined(PNG_READ_ALPHA_MODE_SUPPORTED)
    /* The following is almost certainly wrong unless the background value is in
     * the screen space!
     */
    if ((png_ptr->transformations & PNG_COMPOSE) != 0)
       info_ptr->background = png_ptr->background;
 #endif
 
 #ifdef PNG_READ_GAMMA_SUPPORTED
    /* The following used to be conditional on PNG_GAMMA (prior to 1.5.4),
     * however it seems that the code in png_init_read_transformations, which has
     * been called before this from png_read_update_info->png_read_start_row
     * sometimes does the gamma transform and cancels the flag.
     *
     * TODO: this looks wrong; the info_ptr should end up with a gamma equal to
     * the screen_gamma value.  The following probably results in weirdness if
     * the info_ptr is used by the app after the rows have been read.
     */
    info_ptr->colorspace.gamma = png_ptr->colorspace.gamma;
 #endif
 
    if (info_ptr->bit_depth == 16)
    {
 #  ifdef PNG_READ_16BIT_SUPPORTED
 #     ifdef PNG_READ_SCALE_16_TO_8_SUPPORTED
          if ((png_ptr->transformations & PNG_SCALE_16_TO_8) != 0)
             info_ptr->bit_depth = 8;
 #     endif
 
 #     ifdef PNG_READ_STRIP_16_TO_8_SUPPORTED
          if ((png_ptr->transformations & PNG_16_TO_8) != 0)
             info_ptr->bit_depth = 8;
 #     endif
 
 #  else
       /* No 16 bit support: force chopping 16-bit input down to 8, in this case
        * the app program can chose if both APIs are available by setting the
        * correct scaling to use.
        */
 #     ifdef PNG_READ_STRIP_16_TO_8_SUPPORTED
          /* For compatibility with previous versions use the strip method by
           * default.  This code works because if PNG_SCALE_16_TO_8 is already
           * set the code below will do that in preference to the chop.
           */
          png_ptr->transformations |= PNG_16_TO_8;
          info_ptr->bit_depth = 8;
 #     else
 
 #        ifdef PNG_READ_SCALE_16_TO_8_SUPPORTED
             png_ptr->transformations |= PNG_SCALE_16_TO_8;
             info_ptr->bit_depth = 8;
 #        else
 
             CONFIGURATION ERROR: you must enable at least one 16 to 8 method
 #        endif
 #    endif
 #endif /* !READ_16BIT */
    }
 
 #ifdef PNG_READ_GRAY_TO_RGB_SUPPORTED
    if ((png_ptr->transformations & PNG_GRAY_TO_RGB) != 0)
       info_ptr->color_type = (png_byte)(info_ptr->color_type |
          PNG_COLOR_MASK_COLOR);
 #endif
 
 #ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED
    if ((png_ptr->transformations & PNG_RGB_TO_GRAY) != 0)
       info_ptr->color_type = (png_byte)(info_ptr->color_type &
          ~PNG_COLOR_MASK_COLOR);
 #endif
 
 #ifdef PNG_READ_QUANTIZE_SUPPORTED
    if ((png_ptr->transformations & PNG_QUANTIZE) != 0)
    {
       if (((info_ptr->color_type == PNG_COLOR_TYPE_RGB) ||
           (info_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA)) &&
           png_ptr->palette_lookup != 0 && info_ptr->bit_depth == 8)
       {
          info_ptr->color_type = PNG_COLOR_TYPE_PALETTE;
       }
    }
 #endif
 
 #ifdef PNG_READ_EXPAND_16_SUPPORTED
    if ((png_ptr->transformations & PNG_EXPAND_16) != 0 &&
        info_ptr->bit_depth == 8 &&
        info_ptr->color_type != PNG_COLOR_TYPE_PALETTE)
    {
       info_ptr->bit_depth = 16;
    }
 #endif
 
 #ifdef PNG_READ_PACK_SUPPORTED
    if ((png_ptr->transformations & PNG_PACK) != 0 &&
        (info_ptr->bit_depth < 8))
       info_ptr->bit_depth = 8;
 #endif
 
    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;
 
 #ifdef PNG_READ_STRIP_ALPHA_SUPPORTED
    if ((png_ptr->transformations & PNG_STRIP_ALPHA) != 0)
    {
       info_ptr->color_type = (png_byte)(info_ptr->color_type &
          ~PNG_COLOR_MASK_ALPHA);
       info_ptr->num_trans = 0;
    }
 #endif
 
    if ((info_ptr->color_type & PNG_COLOR_MASK_ALPHA) != 0)
       info_ptr->channels++;
 
 #ifdef PNG_READ_FILLER_SUPPORTED
    /* STRIP_ALPHA and FILLER allowed:  MASK_ALPHA bit stripped above */
    if ((png_ptr->transformations & PNG_FILLER) != 0 &&
        (info_ptr->color_type == PNG_COLOR_TYPE_RGB ||
        info_ptr->color_type == PNG_COLOR_TYPE_GRAY))
    {
       info_ptr->channels++;
       /* If adding a true alpha channel not just filler */
       if ((png_ptr->transformations & PNG_ADD_ALPHA) != 0)
          info_ptr->color_type |= PNG_COLOR_MASK_ALPHA;
    }
 #endif
 
 #if defined(PNG_USER_TRANSFORM_PTR_SUPPORTED) && \
 defined(PNG_READ_USER_TRANSFORM_SUPPORTED)
    if ((png_ptr->transformations & PNG_USER_TRANSFORM) != 0)
    {
       if (info_ptr->bit_depth < png_ptr->user_transform_depth)
          info_ptr->bit_depth = png_ptr->user_transform_depth;
 
       if (info_ptr->channels < png_ptr->user_transform_channels)
          info_ptr->channels = png_ptr->user_transform_channels;
    }
 #endif
 
    info_ptr->pixel_depth = (png_byte)(info_ptr->channels *
        info_ptr->bit_depth);
 
    info_ptr->rowbytes = PNG_ROWBYTES(info_ptr->pixel_depth, info_ptr->width);
 
    /* Adding in 1.5.4: cache the above value in png_struct so that we can later
     * check in png_rowbytes that the user buffer won't get overwritten.  Note
     * that the field is not always set - if png_read_update_info isn't called
     * the application has to either not do any transforms or get the calculation
     * right itself.
     */
    png_ptr->info_rowbytes = info_ptr->rowbytes;
 
 #ifndef PNG_READ_EXPAND_SUPPORTED
    if (png_ptr != NULL)
       return;
 #endif
 }

void png_do_strip_channel	(	png_row_infop	row_info,
		png_bytep	row,
		int	at_start
	)

 {
    png_bytep sp = row; /* source pointer */
    png_bytep dp = row; /* destination pointer */
    png_bytep ep = row + row_info->rowbytes; /* One beyond end of row */
 
    /* At the start sp will point to the first byte to copy and dp to where
     * it is copied to.  ep always points just beyond the end of the row, so
     * the loop simply copies (channels-1) channels until sp reaches ep.
     *
     * at_start:        0 -- convert AG, XG, ARGB, XRGB, AAGG, XXGG, etc.
     *            nonzero -- convert GA, GX, RGBA, RGBX, GGAA, RRGGBBXX, etc.
     */
 
    /* GA, GX, XG cases */
    if (row_info->channels == 2)
    {
       if (row_info->bit_depth == 8)
       {
          if (at_start != 0) /* Skip initial filler */
             ++sp;
          else          /* Skip initial channel and, for sp, the filler */
             sp += 2, ++dp;
 
          /* For a 1 pixel wide image there is nothing to do */
          while (sp < ep)
             *dp++ = *sp, sp += 2;
 
          row_info->pixel_depth = 8;
       }
 
       else if (row_info->bit_depth == 16)
       {
          if (at_start != 0) /* Skip initial filler */
             sp += 2;
          else          /* Skip initial channel and, for sp, the filler */
             sp += 4, dp += 2;
 
          while (sp < ep)
             *dp++ = *sp++, *dp++ = *sp, sp += 3;
 
          row_info->pixel_depth = 16;
       }
 
       else
          return; /* bad bit depth */
 
       row_info->channels = 1;
 
       /* Finally fix the color type if it records an alpha channel */
       if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
          row_info->color_type = PNG_COLOR_TYPE_GRAY;
    }
 
    /* RGBA, RGBX, XRGB cases */
    else if (row_info->channels == 4)
    {
       if (row_info->bit_depth == 8)
       {
          if (at_start != 0) /* Skip initial filler */
             ++sp;
          else          /* Skip initial channels and, for sp, the filler */
             sp += 4, dp += 3;
 
          /* Note that the loop adds 3 to dp and 4 to sp each time. */
          while (sp < ep)
             *dp++ = *sp++, *dp++ = *sp++, *dp++ = *sp, sp += 2;
 
          row_info->pixel_depth = 24;
       }
 
       else if (row_info->bit_depth == 16)
       {
          if (at_start != 0) /* Skip initial filler */
             sp += 2;
          else          /* Skip initial channels and, for sp, the filler */
             sp += 8, dp += 6;
 
          while (sp < ep)
          {
             /* Copy 6 bytes, skip 2 */
             *dp++ = *sp++, *dp++ = *sp++;
             *dp++ = *sp++, *dp++ = *sp++;
             *dp++ = *sp++, *dp++ = *sp, sp += 3;
          }
 
          row_info->pixel_depth = 48;
       }
 
       else
          return; /* bad bit depth */
 
       row_info->channels = 3;
 
       /* Finally fix the color type if it records an alpha channel */
       if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
          row_info->color_type = PNG_COLOR_TYPE_RGB;
    }
 
    else
       return; /* The filler channel has gone already */
 
    /* Fix the rowbytes value. */
    row_info->rowbytes = dp-row;
 }

void png_do_swap	(	png_row_infop	row_info,
		png_bytep	row
	)

 {
    png_debug(1, "in png_do_swap");
 
    if (row_info->bit_depth == 16)
    {
       png_bytep rp = row;
       png_uint_32 i;
       png_uint_32 istop= row_info->width * row_info->channels;
 
       for (i = 0; i < istop; i++, rp += 2)
       {
 #ifdef PNG_BUILTIN_BSWAP16_SUPPORTED
          /* Feature added to libpng-1.6.11 for testing purposes, not
           * enabled by default.
           */
          *(png_uint_16*)rp = __builtin_bswap16(*(png_uint_16*)rp);
 #else
          png_byte t = *rp;
          *rp = *(rp + 1);
          *(rp + 1) = t;
 #endif
       }
    }
 }

void png_do_packswap	(	png_row_infop	row_info,
		png_bytep	row
	)

 {
    png_debug(1, "in png_do_packswap");
 
    if (row_info->bit_depth < 8)
    {
       png_bytep rp;
       png_const_bytep end, table;
 
       end = row + row_info->rowbytes;
 
       if (row_info->bit_depth == 1)
          table = onebppswaptable;
 
       else if (row_info->bit_depth == 2)
          table = twobppswaptable;
 
       else if (row_info->bit_depth == 4)
          table = fourbppswaptable;
 
       else
          return;
 
       for (rp = row; rp < end; rp++)
          *rp = table[*rp];
    }
 }

void png_do_invert	(	png_row_infop	row_info,
		png_bytep	row
	)

 {
    png_debug(1, "in png_do_invert");
 
   /* This test removed from libpng version 1.0.13 and 1.2.0:
    *   if (row_info->bit_depth == 1 &&
    */
    if (row_info->color_type == PNG_COLOR_TYPE_GRAY)
    {
       png_bytep rp = row;
       png_size_t i;
       png_size_t istop = row_info->rowbytes;
 
       for (i = 0; i < istop; i++)
       {
          *rp = (png_byte)(~(*rp));
          rp++;
       }
    }
 
    else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA &&
       row_info->bit_depth == 8)
    {
       png_bytep rp = row;
       png_size_t i;
       png_size_t istop = row_info->rowbytes;
 
       for (i = 0; i < istop; i += 2)
       {
          *rp = (png_byte)(~(*rp));
          rp += 2;
       }
    }
 
 #ifdef PNG_16BIT_SUPPORTED
    else if (row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA &&
       row_info->bit_depth == 16)
    {
       png_bytep rp = row;
       png_size_t i;
       png_size_t istop = row_info->rowbytes;
 
       for (i = 0; i < istop; i += 4)
       {
          *rp = (png_byte)(~(*rp));
          *(rp + 1) = (png_byte)(~(*(rp + 1)));
          rp += 4;
       }
    }
 #endif
 }

void png_do_bgr	(	png_row_infop	row_info,
		png_bytep	row
	)

 {
    png_debug(1, "in png_do_bgr");
 
    if ((row_info->color_type & PNG_COLOR_MASK_COLOR) != 0)
    {
       png_uint_32 row_width = row_info->width;
       if (row_info->bit_depth == 8)
       {
          if (row_info->color_type == PNG_COLOR_TYPE_RGB)
          {
             png_bytep rp;
             png_uint_32 i;
 
             for (i = 0, rp = row; i < row_width; i++, rp += 3)
             {
                png_byte save = *rp;
                *rp = *(rp + 2);
                *(rp + 2) = save;
             }
          }
 
          else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
          {
             png_bytep rp;
             png_uint_32 i;
 
             for (i = 0, rp = row; i < row_width; i++, rp += 4)
             {
                png_byte save = *rp;
                *rp = *(rp + 2);
                *(rp + 2) = save;
             }
          }
       }
 
 #ifdef PNG_16BIT_SUPPORTED
       else if (row_info->bit_depth == 16)
       {
          if (row_info->color_type == PNG_COLOR_TYPE_RGB)
          {
             png_bytep rp;
             png_uint_32 i;
 
             for (i = 0, rp = row; i < row_width; i++, rp += 6)
             {
                png_byte save = *rp;
                *rp = *(rp + 4);
                *(rp + 4) = save;
                save = *(rp + 1);
                *(rp + 1) = *(rp + 5);
                *(rp + 5) = save;
             }
          }
 
          else if (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
          {
             png_bytep rp;
             png_uint_32 i;
 
             for (i = 0, rp = row; i < row_width; i++, rp += 8)
             {
                png_byte save = *rp;
                *rp = *(rp + 4);
                *(rp + 4) = save;
                save = *(rp + 1);
                *(rp + 1) = *(rp + 5);
                *(rp + 5) = save;
             }
          }
       }
 #endif
    }
 }

void png_handle_IHDR	(	png_structrp	png_ptr,
		png_inforp	info_ptr,
		png_uint_32	length
	)

 {
    png_byte buf[13];
    png_uint_32 width, height;
    int bit_depth, color_type, compression_type, filter_type;
    int interlace_type;
 
    png_debug(1, "in png_handle_IHDR");
 
    if ((png_ptr->mode & PNG_HAVE_IHDR) != 0)
       png_chunk_error(png_ptr, "out of place");
 
    /* Check the length */
    if (length != 13)
       png_chunk_error(png_ptr, "invalid");
 
    png_ptr->mode |= PNG_HAVE_IHDR;
 
    png_crc_read(png_ptr, buf, 13);
    png_crc_finish(png_ptr, 0);
 
    width = png_get_uint_31(png_ptr, buf);
    height = png_get_uint_31(png_ptr, buf + 4);
    bit_depth = buf[8];
    color_type = buf[9];
    compression_type = buf[10];
    filter_type = buf[11];
    interlace_type = buf[12];
 
    /* Set internal variables */
    png_ptr->width = width;
    png_ptr->height = height;
    png_ptr->bit_depth = (png_byte)bit_depth;
    png_ptr->interlaced = (png_byte)interlace_type;
    png_ptr->color_type = (png_byte)color_type;
 #ifdef PNG_MNG_FEATURES_SUPPORTED
    png_ptr->filter_type = (png_byte)filter_type;
 #endif
    png_ptr->compression_type = (png_byte)compression_type;
 
    /* Find number of channels */
    switch (png_ptr->color_type)
    {
       default: /* invalid, png_set_IHDR calls png_error */
       case PNG_COLOR_TYPE_GRAY:
       case PNG_COLOR_TYPE_PALETTE:
          png_ptr->channels = 1;
          break;
 
       case PNG_COLOR_TYPE_RGB:
          png_ptr->channels = 3;
          break;
 
       case PNG_COLOR_TYPE_GRAY_ALPHA:
          png_ptr->channels = 2;
          break;
 
       case PNG_COLOR_TYPE_RGB_ALPHA:
          png_ptr->channels = 4;
          break;
    }
 
    /* Set up other useful info */
    png_ptr->pixel_depth = (png_byte)(png_ptr->bit_depth * png_ptr->channels);
    png_ptr->rowbytes = PNG_ROWBYTES(png_ptr->pixel_depth, png_ptr->width);
    png_debug1(3, "bit_depth = %d", png_ptr->bit_depth);
    png_debug1(3, "channels = %d", png_ptr->channels);
    png_debug1(3, "rowbytes = %lu", (unsigned long)png_ptr->rowbytes);
    png_set_IHDR(png_ptr, info_ptr, width, height, bit_depth,
        color_type, interlace_type, compression_type, filter_type);
 }

void png_handle_PLTE	(	png_structrp	png_ptr,
		png_inforp	info_ptr,
		png_uint_32	length
	)

 {
    png_color palette[PNG_MAX_PALETTE_LENGTH];
    int num, i;
 #ifdef PNG_POINTER_INDEXING_SUPPORTED
    png_colorp pal_ptr;
 #endif
 
    png_debug(1, "in png_handle_PLTE");
 
    if ((png_ptr->mode & PNG_HAVE_IHDR) == 0)
       png_chunk_error(png_ptr, "missing IHDR");
 
    /* Moved to before the 'after IDAT' check below because otherwise duplicate
     * PLTE chunks are potentially ignored (the spec says there shall not be more
     * than one PLTE, the error is not treated as benign, so this check trumps
     * the requirement that PLTE appears before IDAT.)
     */
    else if ((png_ptr->mode & PNG_HAVE_PLTE) != 0)
       png_chunk_error(png_ptr, "duplicate");
 
    else if ((png_ptr->mode & PNG_HAVE_IDAT) != 0)
    {
       /* This is benign because the non-benign error happened before, when an
        * IDAT was encountered in a color-mapped image with no PLTE.
        */
       png_crc_finish(png_ptr, length);
       png_chunk_benign_error(png_ptr, "out of place");
       return;
    }
 
    png_ptr->mode |= PNG_HAVE_PLTE;
 
    if ((png_ptr->color_type & PNG_COLOR_MASK_COLOR) == 0)
    {
       png_crc_finish(png_ptr, length);
       png_chunk_benign_error(png_ptr, "ignored in grayscale PNG");
       return;
    }
 
 #ifndef PNG_READ_OPT_PLTE_SUPPORTED
    if (png_ptr->color_type != PNG_COLOR_TYPE_PALETTE)
    {
       png_crc_finish(png_ptr, length);
       return;
    }
 #endif
 
    if (length > 3*PNG_MAX_PALETTE_LENGTH || length % 3)
    {
       png_crc_finish(png_ptr, length);
 
       if (png_ptr->color_type != PNG_COLOR_TYPE_PALETTE)
          png_chunk_benign_error(png_ptr, "invalid");
 
       else
          png_chunk_error(png_ptr, "invalid");
 
       return;
    }
 
    /* The cast is safe because 'length' is less than 3*PNG_MAX_PALETTE_LENGTH */
    num = (int)length / 3;
 
 #ifdef PNG_POINTER_INDEXING_SUPPORTED
    for (i = 0, pal_ptr = palette; i < num; i++, pal_ptr++)
    {
       png_byte buf[3];
 
       png_crc_read(png_ptr, buf, 3);
       pal_ptr->red = buf[0];
       pal_ptr->green = buf[1];
       pal_ptr->blue = buf[2];
    }
 #else
    for (i = 0; i < num; i++)
    {
       png_byte buf[3];
 
       png_crc_read(png_ptr, buf, 3);
       /* Don't depend upon png_color being any order */
       palette[i].red = buf[0];
       palette[i].green = buf[1];
       palette[i].blue = buf[2];
    }
 #endif
 
    /* If we actually need the PLTE chunk (ie for a paletted image), we do
     * whatever the normal CRC configuration tells us.  However, if we
     * have an RGB image, the PLTE can be considered ancillary, so
     * we will act as though it is.
     */
 #ifndef PNG_READ_OPT_PLTE_SUPPORTED
    if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
 #endif
    {
       png_crc_finish(png_ptr, 0);
    }
 
 #ifndef PNG_READ_OPT_PLTE_SUPPORTED
    else if (png_crc_error(png_ptr) != 0)  /* Only if we have a CRC error */
    {
       /* If we don't want to use the data from an ancillary chunk,
        * we have two options: an error abort, or a warning and we
        * ignore the data in this chunk (which should be OK, since
        * it's considered ancillary for a RGB or RGBA image).
        *
        * IMPLEMENTATION NOTE: this is only here because png_crc_finish uses the
        * chunk type to determine whether to check the ancillary or the critical
        * flags.
        */
       if ((png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_USE) == 0)
       {
          if ((png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_NOWARN) != 0)
             return;
 
          else
             png_chunk_error(png_ptr, "CRC error");
       }
 
       /* Otherwise, we (optionally) emit a warning and use the chunk. */
       else if ((png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_NOWARN) == 0)
          png_chunk_warning(png_ptr, "CRC error");
    }
 #endif
 
    /* TODO: png_set_PLTE has the side effect of setting png_ptr->palette to its
     * own copy of the palette.  This has the side effect that when png_start_row
     * is called (this happens after any call to png_read_update_info) the
     * info_ptr palette gets changed.  This is extremely unexpected and
     * confusing.
     *
     * Fix this by not sharing the palette in this way.
     */
    png_set_PLTE(png_ptr, info_ptr, palette, num);
 
    /* The three chunks, bKGD, hIST and tRNS *must* appear after PLTE and before
     * IDAT.  Prior to 1.6.0 this was not checked; instead the code merely
     * checked the apparent validity of a tRNS chunk inserted before PLTE on a
     * palette PNG.  1.6.0 attempts to rigorously follow the standard and
     * therefore does a benign error if the erroneous condition is detected *and*
     * cancels the tRNS if the benign error returns.  The alternative is to
     * amend the standard since it would be rather hypocritical of the standards
     * maintainers to ignore it.
     */
 #ifdef PNG_READ_tRNS_SUPPORTED
    if (png_ptr->num_trans > 0 ||
        (info_ptr != NULL && (info_ptr->valid & PNG_INFO_tRNS) != 0))
    {
       /* Cancel this because otherwise it would be used if the transforms
        * require it.  Don't cancel the 'valid' flag because this would prevent
        * detection of duplicate chunks.
        */
       png_ptr->num_trans = 0;
 
       if (info_ptr != NULL)
          info_ptr->num_trans = 0;
 
       png_chunk_benign_error(png_ptr, "tRNS must be after");
    }
 #endif
 
 #ifdef PNG_READ_hIST_SUPPORTED
    if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_hIST) != 0)
       png_chunk_benign_error(png_ptr, "hIST must be after");
 #endif
 
 #ifdef PNG_READ_bKGD_SUPPORTED
    if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_bKGD) != 0)
       png_chunk_benign_error(png_ptr, "bKGD must be after");
 #endif
 }

void png_handle_IEND	(	png_structrp	png_ptr,
		png_inforp	info_ptr,
		png_uint_32	length
	)

 {
    png_debug(1, "in png_handle_IEND");
 
    if ((png_ptr->mode & PNG_HAVE_IHDR) == 0 ||
        (png_ptr->mode & PNG_HAVE_IDAT) == 0)
       png_chunk_error(png_ptr, "out of place");
 
    png_ptr->mode |= (PNG_AFTER_IDAT | PNG_HAVE_IEND);
 
    png_crc_finish(png_ptr, length);
 
    if (length != 0)
       png_chunk_benign_error(png_ptr, "invalid");
 
    PNG_UNUSED(info_ptr)
 }

void png_handle_bKGD	(	png_structrp	png_ptr,
		png_inforp	info_ptr,
		png_uint_32	length
	)

 {
    unsigned int truelen;
    png_byte buf[6];
    png_color_16 background;
 
    png_debug(1, "in png_handle_bKGD");
 
    if ((png_ptr->mode & PNG_HAVE_IHDR) == 0)
       png_chunk_error(png_ptr, "missing IHDR");
 
    else if ((png_ptr->mode & PNG_HAVE_IDAT) != 0 ||
        (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE &&
        (png_ptr->mode & PNG_HAVE_PLTE) == 0))
    {
       png_crc_finish(png_ptr, length);
       png_chunk_benign_error(png_ptr, "out of place");
       return;
    }
 
    else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_bKGD) != 0)
    {
       png_crc_finish(png_ptr, length);
       png_chunk_benign_error(png_ptr, "duplicate");
       return;
    }
 
    if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
       truelen = 1;
 
    else if ((png_ptr->color_type & PNG_COLOR_MASK_COLOR) != 0)
       truelen = 6;
 
    else
       truelen = 2;
 
    if (length != truelen)
    {
       png_crc_finish(png_ptr, length);
       png_chunk_benign_error(png_ptr, "invalid");
       return;
    }
 
    png_crc_read(png_ptr, buf, truelen);
 
    if (png_crc_finish(png_ptr, 0) != 0)
       return;
 
    /* We convert the index value into RGB components so that we can allow
     * arbitrary RGB values for background when we have transparency, and
     * so it is easy to determine the RGB values of the background color
     * from the info_ptr struct.
     */
    if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
    {
       background.index = buf[0];
 
       if (info_ptr != NULL && info_ptr->num_palette != 0)
       {
          if (buf[0] >= info_ptr->num_palette)
          {
             png_chunk_benign_error(png_ptr, "invalid index");
             return;
          }
 
          background.red = (png_uint_16)png_ptr->palette[buf[0]].red;
          background.green = (png_uint_16)png_ptr->palette[buf[0]].green;
          background.blue = (png_uint_16)png_ptr->palette[buf[0]].blue;
       }
 
       else
          background.red = background.green = background.blue = 0;
 
       background.gray = 0;
    }
 
    else if ((png_ptr->color_type & PNG_COLOR_MASK_COLOR) == 0) /* GRAY */
    {
       background.index = 0;
       background.red =
       background.green =
       background.blue =
       background.gray = png_get_uint_16(buf);
    }
 
    else
    {
       background.index = 0;
       background.red = png_get_uint_16(buf);
       background.green = png_get_uint_16(buf + 2);
       background.blue = png_get_uint_16(buf + 4);
       background.gray = 0;
    }
 
    png_set_bKGD(png_ptr, info_ptr, &background);
 }

void png_handle_cHRM	(	png_structrp	png_ptr,
		png_inforp	info_ptr,
		png_uint_32	length
	)

 {
    png_byte buf[32];
    png_xy xy;
 
    png_debug(1, "in png_handle_cHRM");
 
    if ((png_ptr->mode & PNG_HAVE_IHDR) == 0)
       png_chunk_error(png_ptr, "missing IHDR");
 
    else if ((png_ptr->mode & (PNG_HAVE_IDAT|PNG_HAVE_PLTE)) != 0)
    {
       png_crc_finish(png_ptr, length);
       png_chunk_benign_error(png_ptr, "out of place");
       return;
    }
 
    if (length != 32)
    {
       png_crc_finish(png_ptr, length);
       png_chunk_benign_error(png_ptr, "invalid");
       return;
    }
 
    png_crc_read(png_ptr, buf, 32);
 
    if (png_crc_finish(png_ptr, 0) != 0)
       return;
 
    xy.whitex = png_get_fixed_point(NULL, buf);
    xy.whitey = png_get_fixed_point(NULL, buf + 4);
    xy.redx   = png_get_fixed_point(NULL, buf + 8);
    xy.redy   = png_get_fixed_point(NULL, buf + 12);
    xy.greenx = png_get_fixed_point(NULL, buf + 16);
    xy.greeny = png_get_fixed_point(NULL, buf + 20);
    xy.bluex  = png_get_fixed_point(NULL, buf + 24);
    xy.bluey  = png_get_fixed_point(NULL, buf + 28);
 
    if (xy.whitex == PNG_FIXED_ERROR ||
        xy.whitey == PNG_FIXED_ERROR ||
        xy.redx   == PNG_FIXED_ERROR ||
        xy.redy   == PNG_FIXED_ERROR ||
        xy.greenx == PNG_FIXED_ERROR ||
        xy.greeny == PNG_FIXED_ERROR ||
        xy.bluex  == PNG_FIXED_ERROR ||
        xy.bluey  == PNG_FIXED_ERROR)
    {
       png_chunk_benign_error(png_ptr, "invalid values");
       return;
    }
 
    /* If a colorspace error has already been output skip this chunk */
    if ((png_ptr->colorspace.flags & PNG_COLORSPACE_INVALID) != 0)
       return;
 
    if ((png_ptr->colorspace.flags & PNG_COLORSPACE_FROM_cHRM) != 0)
    {
       png_ptr->colorspace.flags |= PNG_COLORSPACE_INVALID;
       png_colorspace_sync(png_ptr, info_ptr);
       png_chunk_benign_error(png_ptr, "duplicate");
       return;
    }
 
    png_ptr->colorspace.flags |= PNG_COLORSPACE_FROM_cHRM;
    (void)png_colorspace_set_chromaticities(png_ptr, &png_ptr->colorspace, &xy,
       1/*prefer cHRM values*/);
    png_colorspace_sync(png_ptr, info_ptr);
 }

void png_handle_gAMA	(	png_structrp	png_ptr,
		png_inforp	info_ptr,
		png_uint_32	length
	)

 {
    png_fixed_point igamma;
    png_byte buf[4];
 
    png_debug(1, "in png_handle_gAMA");
 
    if ((png_ptr->mode & PNG_HAVE_IHDR) == 0)
       png_chunk_error(png_ptr, "missing IHDR");
 
    else if ((png_ptr->mode & (PNG_HAVE_IDAT|PNG_HAVE_PLTE)) != 0)
    {
       png_crc_finish(png_ptr, length);
       png_chunk_benign_error(png_ptr, "out of place");
       return;
    }
 
    if (length != 4)
    {
       png_crc_finish(png_ptr, length);
       png_chunk_benign_error(png_ptr, "invalid");
       return;
    }
 
    png_crc_read(png_ptr, buf, 4);
 
    if (png_crc_finish(png_ptr, 0) != 0)
       return;
 
    igamma = png_get_fixed_point(NULL, buf);
 
    png_colorspace_set_gamma(png_ptr, &png_ptr->colorspace, igamma);
    png_colorspace_sync(png_ptr, info_ptr);
 }

void png_handle_hIST	(	png_structrp	png_ptr,
		png_inforp	info_ptr,
		png_uint_32	length
	)

 {
    unsigned int num, i;
    png_uint_16 readbuf[PNG_MAX_PALETTE_LENGTH];
 
    png_debug(1, "in png_handle_hIST");
 
    if ((png_ptr->mode & PNG_HAVE_IHDR) == 0)
       png_chunk_error(png_ptr, "missing IHDR");
 
    else if ((png_ptr->mode & PNG_HAVE_IDAT) != 0 ||
        (png_ptr->mode & PNG_HAVE_PLTE) == 0)
    {
       png_crc_finish(png_ptr, length);
       png_chunk_benign_error(png_ptr, "out of place");
       return;
    }
 
    else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_hIST) != 0)
    {
       png_crc_finish(png_ptr, length);
       png_chunk_benign_error(png_ptr, "duplicate");
       return;
    }
 
    num = length / 2 ;
 
    if (num != png_ptr->num_palette || num > PNG_MAX_PALETTE_LENGTH)
    {
       png_crc_finish(png_ptr, length);
       png_chunk_benign_error(png_ptr, "invalid");
       return;
    }
 
    for (i = 0; i < num; i++)
    {
       png_byte buf[2];
 
       png_crc_read(png_ptr, buf, 2);
       readbuf[i] = png_get_uint_16(buf);
    }
 
    if (png_crc_finish(png_ptr, 0) != 0)
       return;
 
    png_set_hIST(png_ptr, info_ptr, readbuf);
 }

void png_handle_iCCP	(	png_structrp	png_ptr,
		png_inforp	info_ptr,
		png_uint_32	length
	)

 {
    png_const_charp errmsg = NULL; /* error message output, or no error */
    int finished = 0; /* crc checked */
 
    png_debug(1, "in png_handle_iCCP");
 
    if ((png_ptr->mode & PNG_HAVE_IHDR) == 0)
       png_chunk_error(png_ptr, "missing IHDR");
 
    else if ((png_ptr->mode & (PNG_HAVE_IDAT|PNG_HAVE_PLTE)) != 0)
    {
       png_crc_finish(png_ptr, length);
       png_chunk_benign_error(png_ptr, "out of place");
       return;
    }
 
    /* Consistent with all the above colorspace handling an obviously *invalid*
     * chunk is just ignored, so does not invalidate the color space.  An
     * alternative is to set the 'invalid' flags at the start of this routine
     * and only clear them in they were not set before and all the tests pass.
     * The minimum 'deflate' stream is assumed to be just the 2 byte header and
     * 4 byte checksum.  The keyword must be at least one character and there is
     * a terminator (0) byte and the compression method.
     */
    if (length < 9)
    {
       png_crc_finish(png_ptr, length);
       png_chunk_benign_error(png_ptr, "too short");
       return;
    }
 
    /* If a colorspace error has already been output skip this chunk */
    if ((png_ptr->colorspace.flags & PNG_COLORSPACE_INVALID) != 0)
    {
       png_crc_finish(png_ptr, length);
       return;
    }
 
    /* Only one sRGB or iCCP chunk is allowed, use the HAVE_INTENT flag to detect
     * this.
     */
    if ((png_ptr->colorspace.flags & PNG_COLORSPACE_HAVE_INTENT) == 0)
    {
       uInt read_length, keyword_length;
       char keyword[81];
 
       /* Find the keyword; the keyword plus separator and compression method
        * bytes can be at most 81 characters long.
        */
       read_length = 81; /* maximum */
       if (read_length > length)
          read_length = (uInt)length;
 
       png_crc_read(png_ptr, (png_bytep)keyword, read_length);
       length -= read_length;
 
       keyword_length = 0;
       while (keyword_length < 80 && keyword_length < read_length &&
          keyword[keyword_length] != 0)
          ++keyword_length;
 
       /* TODO: make the keyword checking common */
       if (keyword_length >= 1 && keyword_length <= 79)
       {
          /* We only understand '0' compression - deflate - so if we get a
           * different value we can't safely decode the chunk.
           */
          if (keyword_length+1 < read_length &&
             keyword[keyword_length+1] == PNG_COMPRESSION_TYPE_BASE)
          {
             read_length -= keyword_length+2;
 
             if (png_inflate_claim(png_ptr, png_iCCP) == Z_OK)
             {
                Byte profile_header[132];
                Byte local_buffer[PNG_INFLATE_BUF_SIZE];
                png_alloc_size_t size = (sizeof profile_header);
 
                png_ptr->zstream.next_in = (Bytef*)keyword + (keyword_length+2);
                png_ptr->zstream.avail_in = read_length;
                (void)png_inflate_read(png_ptr, local_buffer,
                   (sizeof local_buffer), &length, profile_header, &size,
                   0/*finish: don't, because the output is too small*/);
 
                if (size == 0)
                {
                   /* We have the ICC profile header; do the basic header checks.
                    */
                   const png_uint_32 profile_length =
                      png_get_uint_32(profile_header);
 
                   if (png_icc_check_length(png_ptr, &png_ptr->colorspace,
                      keyword, profile_length) != 0)
                   {
                      /* The length is apparently ok, so we can check the 132
                       * byte header.
                       */
                      if (png_icc_check_header(png_ptr, &png_ptr->colorspace,
                         keyword, profile_length, profile_header,
                         png_ptr->color_type) != 0)
                      {
                         /* Now read the tag table; a variable size buffer is
                          * needed at this point, allocate one for the whole
                          * profile.  The header check has already validated
                          * that none of these stuff will overflow.
                          */
                         const png_uint_32 tag_count = png_get_uint_32(
                            profile_header+128);
                         png_bytep profile = png_read_buffer(png_ptr,
                            profile_length, 2/*silent*/);
 
                         if (profile != NULL)
                         {
                            memcpy(profile, profile_header,
                               (sizeof profile_header));
 
                            size = 12 * tag_count;
 
                            (void)png_inflate_read(png_ptr, local_buffer,
                               (sizeof local_buffer), &length,
                               profile + (sizeof profile_header), &size, 0);
 
                            /* Still expect a buffer error because we expect
                             * there to be some tag data!
                             */
                            if (size == 0)
                            {
                               if (png_icc_check_tag_table(png_ptr,
                                  &png_ptr->colorspace, keyword, profile_length,
                                  profile) != 0)
                               {
                                  /* The profile has been validated for basic
                                   * security issues, so read the whole thing in.
                                   */
                                  size = profile_length - (sizeof profile_header)
                                     - 12 * tag_count;
 
                                  (void)png_inflate_read(png_ptr, local_buffer,
                                     (sizeof local_buffer), &length,
                                     profile + (sizeof profile_header) +
                                     12 * tag_count, &size, 1/*finish*/);
 
                                  if (length > 0 && !(png_ptr->flags &
                                        PNG_FLAG_BENIGN_ERRORS_WARN))
                                     errmsg = "extra compressed data";
 
                                  /* But otherwise allow extra data: */
                                  else if (size == 0)
                                  {
                                     if (length > 0)
                                     {
                                        /* This can be handled completely, so
                                         * keep going.
                                         */
                                        png_chunk_warning(png_ptr,
                                           "extra compressed data");
                                     }
 
                                     png_crc_finish(png_ptr, length);
                                     finished = 1;
 
 #                                   ifdef PNG_sRGB_SUPPORTED
                                        /* Check for a match against sRGB */
                                        png_icc_set_sRGB(png_ptr,
                                           &png_ptr->colorspace, profile,
                                           png_ptr->zstream.adler);
 #                                   endif
 
                                     /* Steal the profile for info_ptr. */
                                     if (info_ptr != NULL)
                                     {
                                        png_free_data(png_ptr, info_ptr,
                                           PNG_FREE_ICCP, 0);
 
                                        info_ptr->iccp_name = png_voidcast(char*,
                                           png_malloc_base(png_ptr,
                                           keyword_length+1));
                                        if (info_ptr->iccp_name != NULL)
                                        {
                                           memcpy(info_ptr->iccp_name, keyword,
                                              keyword_length+1);
                                           info_ptr->iccp_proflen =
                                              profile_length;
                                           info_ptr->iccp_profile = profile;
                                           png_ptr->read_buffer = NULL; /*steal*/
                                           info_ptr->free_me |= PNG_FREE_ICCP;
                                           info_ptr->valid |= PNG_INFO_iCCP;
                                        }
 
                                        else
                                        {
                                           png_ptr->colorspace.flags |=
                                              PNG_COLORSPACE_INVALID;
                                           errmsg = "out of memory";
                                        }
                                     }
 
                                     /* else the profile remains in the read
                                      * buffer which gets reused for subsequent
                                      * chunks.
                                      */
 
                                     if (info_ptr != NULL)
                                        png_colorspace_sync(png_ptr, info_ptr);
 
                                     if (errmsg == NULL)
                                     {
                                        png_ptr->zowner = 0;
                                        return;
                                     }
                                  }
 
                                  else if (size > 0)
                                     errmsg = "truncated";
 
                                  else
                                     errmsg = png_ptr->zstream.msg;
                               }
 
                               /* else png_icc_check_tag_table output an error */
                            }
 
                            else /* profile truncated */
                               errmsg = png_ptr->zstream.msg;
                         }
 
                         else
                            errmsg = "out of memory";
                      }
 
                      /* else png_icc_check_header output an error */
                   }
 
                   /* else png_icc_check_length output an error */
                }
 
                else /* profile truncated */
                   errmsg = png_ptr->zstream.msg;
 
                /* Release the stream */
                png_ptr->zowner = 0;
             }
 
             else /* png_inflate_claim failed */
                errmsg = png_ptr->zstream.msg;
          }
 
          else
             errmsg = "bad compression method"; /* or missing */
       }
 
       else
          errmsg = "bad keyword";
    }
 
    else
       errmsg = "too many profiles";
 
    /* Failure: the reason is in 'errmsg' */
    if (finished == 0)
       png_crc_finish(png_ptr, length);
 
    png_ptr->colorspace.flags |= PNG_COLORSPACE_INVALID;
    png_colorspace_sync(png_ptr, info_ptr);
    if (errmsg != NULL) /* else already output */
       png_chunk_benign_error(png_ptr, errmsg);
 }

void png_handle_iTXt	(	png_structrp	png_ptr,
		png_inforp	info_ptr,
		png_uint_32	length
	)

 {
    png_const_charp errmsg = NULL;
    png_bytep buffer;
    png_uint_32 prefix_length;
 
    png_debug(1, "in png_handle_iTXt");
 
 #ifdef PNG_USER_LIMITS_SUPPORTED
    if (png_ptr->user_chunk_cache_max != 0)
    {
       if (png_ptr->user_chunk_cache_max == 1)
       {
          png_crc_finish(png_ptr, length);
          return;
       }
 
       if (--png_ptr->user_chunk_cache_max == 1)
       {
          png_crc_finish(png_ptr, length);
          png_chunk_benign_error(png_ptr, "no space in chunk cache");
          return;
       }
    }
 #endif
 
    if ((png_ptr->mode & PNG_HAVE_IHDR) == 0)
       png_chunk_error(png_ptr, "missing IHDR");
 
    if ((png_ptr->mode & PNG_HAVE_IDAT) != 0)
       png_ptr->mode |= PNG_AFTER_IDAT;
 
    buffer = png_read_buffer(png_ptr, length+1, 1/*warn*/);
 
    if (buffer == NULL)
    {
       png_crc_finish(png_ptr, length);
       png_chunk_benign_error(png_ptr, "out of memory");
       return;
    }
 
    png_crc_read(png_ptr, buffer, length);
 
    if (png_crc_finish(png_ptr, 0) != 0)
       return;
 
    /* First the keyword. */
    for (prefix_length=0;
       prefix_length < length && buffer[prefix_length] != 0;
       ++prefix_length)
       /* Empty loop */ ;
 
    /* Perform a basic check on the keyword length here. */
    if (prefix_length > 79 || prefix_length < 1)
       errmsg = "bad keyword";
 
    /* Expect keyword, compression flag, compression type, language, translated
     * keyword (both may be empty but are 0 terminated) then the text, which may
     * be empty.
     */
    else if (prefix_length + 5 > length)
       errmsg = "truncated";
 
    else if (buffer[prefix_length+1] == 0 ||
       (buffer[prefix_length+1] == 1 &&
       buffer[prefix_length+2] == PNG_COMPRESSION_TYPE_BASE))
    {
       int compressed = buffer[prefix_length+1] != 0;
       png_uint_32 language_offset, translated_keyword_offset;
       png_alloc_size_t uncompressed_length = 0;
 
       /* Now the language tag */
       prefix_length += 3;
       language_offset = prefix_length;
 
       for (; prefix_length < length && buffer[prefix_length] != 0;
          ++prefix_length)
          /* Empty loop */ ;
 
       /* WARNING: the length may be invalid here, this is checked below. */
       translated_keyword_offset = ++prefix_length;
 
       for (; prefix_length < length && buffer[prefix_length] != 0;
          ++prefix_length)
          /* Empty loop */ ;
 
       /* prefix_length should now be at the trailing '\0' of the translated
        * keyword, but it may already be over the end.  None of this arithmetic
        * can overflow because chunks are at most 2^31 bytes long, but on 16-bit
        * systems the available allocation may overflow.
        */
       ++prefix_length;
 
       if (compressed == 0 && prefix_length <= length)
          uncompressed_length = length - prefix_length;
 
       else if (compressed != 0 && prefix_length < length)
       {
          uncompressed_length = PNG_SIZE_MAX;
 
          /* TODO: at present png_decompress_chunk imposes a single application
           * level memory limit, this should be split to different values for
           * iCCP and text chunks.
           */
          if (png_decompress_chunk(png_ptr, length, prefix_length,
             &uncompressed_length, 1/*terminate*/) == Z_STREAM_END)
             buffer = png_ptr->read_buffer;
 
          else
             errmsg = png_ptr->zstream.msg;
       }
 
       else
          errmsg = "truncated";
 
       if (errmsg == NULL)
       {
          png_text text;
 
          buffer[uncompressed_length+prefix_length] = 0;
 
          if (compressed == 0)
             text.compression = PNG_ITXT_COMPRESSION_NONE;
 
          else
             text.compression = PNG_ITXT_COMPRESSION_zTXt;
 
          text.key = (png_charp)buffer;
          text.lang = (png_charp)buffer + language_offset;
          text.lang_key = (png_charp)buffer + translated_keyword_offset;
          text.text = (png_charp)buffer + prefix_length;
          text.text_length = 0;
          text.itxt_length = uncompressed_length;
 
          if (png_set_text_2(png_ptr, info_ptr, &text, 1) != 0)
             errmsg = "insufficient memory";
       }
    }
 
    else
       errmsg = "bad compression info";
 
    if (errmsg != NULL)
       png_chunk_benign_error(png_ptr, errmsg);
 }

void png_handle_oFFs	(	png_structrp	png_ptr,
		png_inforp	info_ptr,
		png_uint_32	length
	)

 {
    png_byte buf[9];
    png_int_32 offset_x, offset_y;
    int unit_type;
 
    png_debug(1, "in png_handle_oFFs");
 
    if ((png_ptr->mode & PNG_HAVE_IHDR) == 0)
       png_chunk_error(png_ptr, "missing IHDR");
 
    else if ((png_ptr->mode & PNG_HAVE_IDAT) != 0)
    {
       png_crc_finish(png_ptr, length);
       png_chunk_benign_error(png_ptr, "out of place");
       return;
    }
 
    else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_oFFs) != 0)
    {
       png_crc_finish(png_ptr, length);
       png_chunk_benign_error(png_ptr, "duplicate");
       return;
    }
 
    if (length != 9)
    {
       png_crc_finish(png_ptr, length);
       png_chunk_benign_error(png_ptr, "invalid");
       return;
    }
 
    png_crc_read(png_ptr, buf, 9);
 
    if (png_crc_finish(png_ptr, 0) != 0)
       return;
 
    offset_x = png_get_int_32(buf);
    offset_y = png_get_int_32(buf + 4);
    unit_type = buf[8];
    png_set_oFFs(png_ptr, info_ptr, offset_x, offset_y, unit_type);
 }

void png_handle_pCAL	(	png_structrp	png_ptr,
		png_inforp	info_ptr,
		png_uint_32	length
	)

 {
    png_int_32 X0, X1;
    png_byte type, nparams;
    png_bytep buffer, buf, units, endptr;
    png_charpp params;
    int i;
 
    png_debug(1, "in png_handle_pCAL");
 
    if ((png_ptr->mode & PNG_HAVE_IHDR) == 0)
       png_chunk_error(png_ptr, "missing IHDR");
 
    else if ((png_ptr->mode & PNG_HAVE_IDAT) != 0)
    {
       png_crc_finish(png_ptr, length);
       png_chunk_benign_error(png_ptr, "out of place");
       return;
    }
 
    else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_pCAL) != 0)
    {
       png_crc_finish(png_ptr, length);
       png_chunk_benign_error(png_ptr, "duplicate");
       return;
    }
 
    png_debug1(2, "Allocating and reading pCAL chunk data (%u bytes)",
        length + 1);
 
    buffer = png_read_buffer(png_ptr, length+1, 2/*silent*/);
 
    if (buffer == NULL)
    {
       png_crc_finish(png_ptr, length);
       png_chunk_benign_error(png_ptr, "out of memory");
       return;
    }
 
    png_crc_read(png_ptr, buffer, length);
 
    if (png_crc_finish(png_ptr, 0) != 0)
       return;
 
    buffer[length] = 0; /* Null terminate the last string */
 
    png_debug(3, "Finding end of pCAL purpose string");
    for (buf = buffer; *buf; buf++)
       /* Empty loop */ ;
 
    endptr = buffer + length;
 
    /* We need to have at least 12 bytes after the purpose string
     * in order to get the parameter information.
     */
    if (endptr <= buf + 12)
    {
       png_chunk_benign_error(png_ptr, "invalid");
       return;
    }
 
    png_debug(3, "Reading pCAL X0, X1, type, nparams, and units");
    X0 = png_get_int_32((png_bytep)buf+1);
    X1 = png_get_int_32((png_bytep)buf+5);
    type = buf[9];
    nparams = buf[10];
    units = buf + 11;
 
    png_debug(3, "Checking pCAL equation type and number of parameters");
    /* Check that we have the right number of parameters for known
     * equation types.
     */
    if ((type == PNG_EQUATION_LINEAR && nparams != 2) ||
        (type == PNG_EQUATION_BASE_E && nparams != 3) ||
        (type == PNG_EQUATION_ARBITRARY && nparams != 3) ||
        (type == PNG_EQUATION_HYPERBOLIC && nparams != 4))
    {
       png_chunk_benign_error(png_ptr, "invalid parameter count");
       return;
    }
 
    else if (type >= PNG_EQUATION_LAST)
    {
       png_chunk_benign_error(png_ptr, "unrecognized equation type");
    }
 
    for (buf = units; *buf; buf++)
       /* Empty loop to move past the units string. */ ;
 
    png_debug(3, "Allocating pCAL parameters array");
 
    params = png_voidcast(png_charpp, png_malloc_warn(png_ptr,
        nparams * (sizeof (png_charp))));
 
    if (params == NULL)
    {
       png_chunk_benign_error(png_ptr, "out of memory");
       return;
    }
 
    /* Get pointers to the start of each parameter string. */
    for (i = 0; i < nparams; i++)
    {
       buf++; /* Skip the null string terminator from previous parameter. */
 
       png_debug1(3, "Reading pCAL parameter %d", i);
 
       for (params[i] = (png_charp)buf; buf <= endptr && *buf != 0; buf++)
          /* Empty loop to move past each parameter string */ ;
 
       /* Make sure we haven't run out of data yet */
       if (buf > endptr)
       {
          png_free(png_ptr, params);
          png_chunk_benign_error(png_ptr, "invalid data");
          return;
       }
    }
 
    png_set_pCAL(png_ptr, info_ptr, (png_charp)buffer, X0, X1, type, nparams,
       (png_charp)units, params);
 
    png_free(png_ptr, params);
 }

void png_handle_pHYs	(	png_structrp	png_ptr,
		png_inforp	info_ptr,
		png_uint_32	length
	)

 {
    png_byte buf[9];
    png_uint_32 res_x, res_y;
    int unit_type;
 
    png_debug(1, "in png_handle_pHYs");
 
    if ((png_ptr->mode & PNG_HAVE_IHDR) == 0)
       png_chunk_error(png_ptr, "missing IHDR");
 
    else if ((png_ptr->mode & PNG_HAVE_IDAT) != 0)
    {
       png_crc_finish(png_ptr, length);
       png_chunk_benign_error(png_ptr, "out of place");
       return;
    }
 
    else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_pHYs) != 0)
    {
       png_crc_finish(png_ptr, length);
       png_chunk_benign_error(png_ptr, "duplicate");
       return;
    }
 
    if (length != 9)
    {
       png_crc_finish(png_ptr, length);
       png_chunk_benign_error(png_ptr, "invalid");
       return;
    }
 
    png_crc_read(png_ptr, buf, 9);
 
    if (png_crc_finish(png_ptr, 0) != 0)
       return;
 
    res_x = png_get_uint_32(buf);
    res_y = png_get_uint_32(buf + 4);
    unit_type = buf[8];
    png_set_pHYs(png_ptr, info_ptr, res_x, res_y, unit_type);
 }

void png_handle_sBIT	(	png_structrp	png_ptr,
		png_inforp	info_ptr,
		png_uint_32	length
	)

 {
    unsigned int truelen, i;
    png_byte sample_depth;
    png_byte buf[4];
 
    png_debug(1, "in png_handle_sBIT");
 
    if ((png_ptr->mode & PNG_HAVE_IHDR) == 0)
       png_chunk_error(png_ptr, "missing IHDR");
 
    else if ((png_ptr->mode & (PNG_HAVE_IDAT|PNG_HAVE_PLTE)) != 0)
    {
       png_crc_finish(png_ptr, length);
       png_chunk_benign_error(png_ptr, "out of place");
       return;
    }
 
    if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_sBIT) != 0)
    {
       png_crc_finish(png_ptr, length);
       png_chunk_benign_error(png_ptr, "duplicate");
       return;
    }
 
    if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
    {
       truelen = 3;
       sample_depth = 8;
    }
 
    else
    {
       truelen = png_ptr->channels;
       sample_depth = png_ptr->bit_depth;
    }
 
    if (length != truelen || length > 4)
    {
       png_chunk_benign_error(png_ptr, "invalid");
       png_crc_finish(png_ptr, length);
       return;
    }
 
    buf[0] = buf[1] = buf[2] = buf[3] = sample_depth;
    png_crc_read(png_ptr, buf, truelen);
 
    if (png_crc_finish(png_ptr, 0) != 0)
       return;
 
    for (i=0; i<truelen; ++i)
       if (buf[i] == 0 || buf[i] > sample_depth)
       {
          png_chunk_benign_error(png_ptr, "invalid");
          return;
       }
 
    if ((png_ptr->color_type & PNG_COLOR_MASK_COLOR) != 0)
    {
       png_ptr->sig_bit.red = buf[0];
       png_ptr->sig_bit.green = buf[1];
       png_ptr->sig_bit.blue = buf[2];
       png_ptr->sig_bit.alpha = buf[3];
    }
 
    else
    {
       png_ptr->sig_bit.gray = buf[0];
       png_ptr->sig_bit.red = buf[0];
       png_ptr->sig_bit.green = buf[0];
       png_ptr->sig_bit.blue = buf[0];
       png_ptr->sig_bit.alpha = buf[1];
    }
 
    png_set_sBIT(png_ptr, info_ptr, &(png_ptr->sig_bit));
 }

void png_handle_sCAL	(	png_structrp	png_ptr,
		png_inforp	info_ptr,
		png_uint_32	length
	)

 {
    png_bytep buffer;
    png_size_t i;
    int state;
 
    png_debug(1, "in png_handle_sCAL");
 
    if ((png_ptr->mode & PNG_HAVE_IHDR) == 0)
       png_chunk_error(png_ptr, "missing IHDR");
 
    else if ((png_ptr->mode & PNG_HAVE_IDAT) != 0)
    {
       png_crc_finish(png_ptr, length);
       png_chunk_benign_error(png_ptr, "out of place");
       return;
    }
 
    else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_sCAL) != 0)
    {
       png_crc_finish(png_ptr, length);
       png_chunk_benign_error(png_ptr, "duplicate");
       return;
    }
 
    /* Need unit type, width, \0, height: minimum 4 bytes */
    else if (length < 4)
    {
       png_crc_finish(png_ptr, length);
       png_chunk_benign_error(png_ptr, "invalid");
       return;
    }
 
    png_debug1(2, "Allocating and reading sCAL chunk data (%u bytes)",
       length + 1);
 
    buffer = png_read_buffer(png_ptr, length+1, 2/*silent*/);
 
    if (buffer == NULL)
    {
       png_chunk_benign_error(png_ptr, "out of memory");
       png_crc_finish(png_ptr, length);
       return;
    }
 
    png_crc_read(png_ptr, buffer, length);
    buffer[length] = 0; /* Null terminate the last string */
 
    if (png_crc_finish(png_ptr, 0) != 0)
       return;
 
    /* Validate the unit. */
    if (buffer[0] != 1 && buffer[0] != 2)
    {
       png_chunk_benign_error(png_ptr, "invalid unit");
       return;
    }
 
    /* Validate the ASCII numbers, need two ASCII numbers separated by
     * a '\0' and they need to fit exactly in the chunk data.
     */
    i = 1;
    state = 0;
 
    if (png_check_fp_number((png_const_charp)buffer, length, &state, &i) == 0 ||
        i >= length || buffer[i++] != 0)
       png_chunk_benign_error(png_ptr, "bad width format");
 
    else if (PNG_FP_IS_POSITIVE(state) == 0)
       png_chunk_benign_error(png_ptr, "non-positive width");
 
    else
    {
       png_size_t heighti = i;
 
       state = 0;
       if (png_check_fp_number((png_const_charp)buffer, length,
           &state, &i) == 0 || i != length)
          png_chunk_benign_error(png_ptr, "bad height format");
 
       else if (PNG_FP_IS_POSITIVE(state) == 0)
          png_chunk_benign_error(png_ptr, "non-positive height");
 
       else
          /* This is the (only) success case. */
          png_set_sCAL_s(png_ptr, info_ptr, buffer[0],
             (png_charp)buffer+1, (png_charp)buffer+heighti);
    }
 }

void png_handle_sPLT	(	png_structrp	png_ptr,
		png_inforp	info_ptr,
		png_uint_32	length
	)

 {
    png_bytep entry_start, buffer;
    png_sPLT_t new_palette;
    png_sPLT_entryp pp;
    png_uint_32 data_length;
    int entry_size, i;
    png_uint_32 skip = 0;
    png_uint_32 dl;
    png_size_t max_dl;
 
    png_debug(1, "in png_handle_sPLT");
 
 #ifdef PNG_USER_LIMITS_SUPPORTED
    if (png_ptr->user_chunk_cache_max != 0)
    {
       if (png_ptr->user_chunk_cache_max == 1)
       {
          png_crc_finish(png_ptr, length);
          return;
       }
 
       if (--png_ptr->user_chunk_cache_max == 1)
       {
          png_warning(png_ptr, "No space in chunk cache for sPLT");
          png_crc_finish(png_ptr, length);
          return;
       }
    }
 #endif
 
    if ((png_ptr->mode & PNG_HAVE_IHDR) == 0)
       png_chunk_error(png_ptr, "missing IHDR");
 
    else if ((png_ptr->mode & PNG_HAVE_IDAT) != 0)
    {
       png_crc_finish(png_ptr, length);
       png_chunk_benign_error(png_ptr, "out of place");
       return;
    }
 
 #ifdef PNG_MAX_MALLOC_64K
    if (length > 65535U)
    {
       png_crc_finish(png_ptr, length);
       png_chunk_benign_error(png_ptr, "too large to fit in memory");
       return;
    }
 #endif
 
    buffer = png_read_buffer(png_ptr, length+1, 2/*silent*/);
    if (buffer == NULL)
    {
       png_crc_finish(png_ptr, length);
       png_chunk_benign_error(png_ptr, "out of memory");
       return;
    }
 
 
    /* WARNING: this may break if size_t is less than 32 bits; it is assumed
     * that the PNG_MAX_MALLOC_64K test is enabled in this case, but this is a
     * potential breakage point if the types in pngconf.h aren't exactly right.
     */
    png_crc_read(png_ptr, buffer, length);
 
    if (png_crc_finish(png_ptr, skip) != 0)
       return;
 
    buffer[length] = 0;
 
    for (entry_start = buffer; *entry_start; entry_start++)
       /* Empty loop to find end of name */ ;
 
    ++entry_start;
 
    /* A sample depth should follow the separator, and we should be on it  */
    if (entry_start > buffer + length - 2)
    {
       png_warning(png_ptr, "malformed sPLT chunk");
       return;
    }
 
    new_palette.depth = *entry_start++;
    entry_size = (new_palette.depth == 8 ? 6 : 10);
    /* This must fit in a png_uint_32 because it is derived from the original
     * chunk data length.
     */
    data_length = length - (png_uint_32)(entry_start - buffer);
 
    /* Integrity-check the data length */
    if ((data_length % entry_size) != 0)
    {
       png_warning(png_ptr, "sPLT chunk has bad length");
       return;
    }
 
    dl = (png_int_32)(data_length / entry_size);
    max_dl = PNG_SIZE_MAX / (sizeof (png_sPLT_entry));
 
    if (dl > max_dl)
    {
        png_warning(png_ptr, "sPLT chunk too long");
        return;
    }
 
    new_palette.nentries = (png_int_32)(data_length / entry_size);
 
    new_palette.entries = (png_sPLT_entryp)png_malloc_warn(
        png_ptr, new_palette.nentries * (sizeof (png_sPLT_entry)));
 
    if (new_palette.entries == NULL)
    {
        png_warning(png_ptr, "sPLT chunk requires too much memory");
        return;
    }
 
 #ifdef PNG_POINTER_INDEXING_SUPPORTED
    for (i = 0; i < new_palette.nentries; i++)
    {
       pp = new_palette.entries + i;
 
       if (new_palette.depth == 8)
       {
          pp->red = *entry_start++;
          pp->green = *entry_start++;
          pp->blue = *entry_start++;
          pp->alpha = *entry_start++;
       }
 
       else
       {
          pp->red   = png_get_uint_16(entry_start); entry_start += 2;
          pp->green = png_get_uint_16(entry_start); entry_start += 2;
          pp->blue  = png_get_uint_16(entry_start); entry_start += 2;
          pp->alpha = png_get_uint_16(entry_start); entry_start += 2;
       }
 
       pp->frequency = png_get_uint_16(entry_start); entry_start += 2;
    }
 #else
    pp = new_palette.entries;
 
    for (i = 0; i < new_palette.nentries; i++)
    {
 
       if (new_palette.depth == 8)
       {
          pp[i].red   = *entry_start++;
          pp[i].green = *entry_start++;
          pp[i].blue  = *entry_start++;
          pp[i].alpha = *entry_start++;
       }
 
       else
       {
          pp[i].red   = png_get_uint_16(entry_start); entry_start += 2;
          pp[i].green = png_get_uint_16(entry_start); entry_start += 2;
          pp[i].blue  = png_get_uint_16(entry_start); entry_start += 2;
          pp[i].alpha = png_get_uint_16(entry_start); entry_start += 2;
       }
 
       pp[i].frequency = png_get_uint_16(entry_start); entry_start += 2;
    }
 #endif
 
    /* Discard all chunk data except the name and stash that */
    new_palette.name = (png_charp)buffer;
 
    png_set_sPLT(png_ptr, info_ptr, &new_palette, 1);
 
    png_free(png_ptr, new_palette.entries);
 }

void png_handle_sRGB	(	png_structrp	png_ptr,
		png_inforp	info_ptr,
		png_uint_32	length
	)

 {
    png_byte intent;
 
    png_debug(1, "in png_handle_sRGB");
 
    if ((png_ptr->mode & PNG_HAVE_IHDR) == 0)
       png_chunk_error(png_ptr, "missing IHDR");
 
    else if ((png_ptr->mode & (PNG_HAVE_IDAT|PNG_HAVE_PLTE)) != 0)
    {
       png_crc_finish(png_ptr, length);
       png_chunk_benign_error(png_ptr, "out of place");
       return;
    }
 
    if (length != 1)
    {
       png_crc_finish(png_ptr, length);
       png_chunk_benign_error(png_ptr, "invalid");
       return;
    }
 
    png_crc_read(png_ptr, &intent, 1);
 
    if (png_crc_finish(png_ptr, 0) != 0)
       return;
 
    /* If a colorspace error has already been output skip this chunk */
    if ((png_ptr->colorspace.flags & PNG_COLORSPACE_INVALID) != 0)
       return;
 
    /* Only one sRGB or iCCP chunk is allowed, use the HAVE_INTENT flag to detect
     * this.
     */
    if ((png_ptr->colorspace.flags & PNG_COLORSPACE_HAVE_INTENT) != 0)
    {
       png_ptr->colorspace.flags |= PNG_COLORSPACE_INVALID;
       png_colorspace_sync(png_ptr, info_ptr);
       png_chunk_benign_error(png_ptr, "too many profiles");
       return;
    }
 
    (void)png_colorspace_set_sRGB(png_ptr, &png_ptr->colorspace, intent);
    png_colorspace_sync(png_ptr, info_ptr);
 }

void png_handle_tEXt	(	png_structrp	png_ptr,
		png_inforp	info_ptr,
		png_uint_32	length
	)

 {
    png_text  text_info;
    png_bytep buffer;
    png_charp key;
    png_charp text;
    png_uint_32 skip = 0;
 
    png_debug(1, "in png_handle_tEXt");
 
 #ifdef PNG_USER_LIMITS_SUPPORTED
    if (png_ptr->user_chunk_cache_max != 0)
    {
       if (png_ptr->user_chunk_cache_max == 1)
       {
          png_crc_finish(png_ptr, length);
          return;
       }
 
       if (--png_ptr->user_chunk_cache_max == 1)
       {
          png_crc_finish(png_ptr, length);
          png_chunk_benign_error(png_ptr, "no space in chunk cache");
          return;
       }
    }
 #endif
 
    if ((png_ptr->mode & PNG_HAVE_IHDR) == 0)
       png_chunk_error(png_ptr, "missing IHDR");
 
    if ((png_ptr->mode & PNG_HAVE_IDAT) != 0)
       png_ptr->mode |= PNG_AFTER_IDAT;
 
 #ifdef PNG_MAX_MALLOC_64K
    if (length > 65535U)
    {
       png_crc_finish(png_ptr, length);
       png_chunk_benign_error(png_ptr, "too large to fit in memory");
       return;
    }
 #endif
 
    buffer = png_read_buffer(png_ptr, length+1, 1/*warn*/);
 
    if (buffer == NULL)
    {
      png_chunk_benign_error(png_ptr, "out of memory");
      return;
    }
 
    png_crc_read(png_ptr, buffer, length);
 
    if (png_crc_finish(png_ptr, skip) != 0)
       return;
 
    key = (png_charp)buffer;
    key[length] = 0;
 
    for (text = key; *text; text++)
       /* Empty loop to find end of key */ ;
 
    if (text != key + length)
       text++;
 
    text_info.compression = PNG_TEXT_COMPRESSION_NONE;
    text_info.key = key;
    text_info.lang = NULL;
    text_info.lang_key = NULL;
    text_info.itxt_length = 0;
    text_info.text = text;
    text_info.text_length = strlen(text);
 
    if (png_set_text_2(png_ptr, info_ptr, &text_info, 1) != 0)
       png_warning(png_ptr, "Insufficient memory to process text chunk");
 }

void png_handle_tIME	(	png_structrp	png_ptr,
		png_inforp	info_ptr,
		png_uint_32	length
	)

 {
    png_byte buf[7];
    png_time mod_time;
 
    png_debug(1, "in png_handle_tIME");
 
    if ((png_ptr->mode & PNG_HAVE_IHDR) == 0)
       png_chunk_error(png_ptr, "missing IHDR");
 
    else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_tIME) != 0)
    {
       png_crc_finish(png_ptr, length);
       png_chunk_benign_error(png_ptr, "duplicate");
       return;
    }
 
    if ((png_ptr->mode & PNG_HAVE_IDAT) != 0)
       png_ptr->mode |= PNG_AFTER_IDAT;
 
    if (length != 7)
    {
       png_crc_finish(png_ptr, length);
       png_chunk_benign_error(png_ptr, "invalid");
       return;
    }
 
    png_crc_read(png_ptr, buf, 7);
 
    if (png_crc_finish(png_ptr, 0) != 0)
       return;
 
    mod_time.second = buf[6];
    mod_time.minute = buf[5];
    mod_time.hour = buf[4];
    mod_time.day = buf[3];
    mod_time.month = buf[2];
    mod_time.year = png_get_uint_16(buf);
 
    png_set_tIME(png_ptr, info_ptr, &mod_time);
 }

void png_handle_tRNS	(	png_structrp	png_ptr,
		png_inforp	info_ptr,
		png_uint_32	length
	)

 {
    png_byte readbuf[PNG_MAX_PALETTE_LENGTH];
 
    png_debug(1, "in png_handle_tRNS");
 
    if ((png_ptr->mode & PNG_HAVE_IHDR) == 0)
       png_chunk_error(png_ptr, "missing IHDR");
 
    else if ((png_ptr->mode & PNG_HAVE_IDAT) != 0)
    {
       png_crc_finish(png_ptr, length);
       png_chunk_benign_error(png_ptr, "out of place");
       return;
    }
 
    else if (info_ptr != NULL && (info_ptr->valid & PNG_INFO_tRNS) != 0)
    {
       png_crc_finish(png_ptr, length);
       png_chunk_benign_error(png_ptr, "duplicate");
       return;
    }
 
    if (png_ptr->color_type == PNG_COLOR_TYPE_GRAY)
    {
       png_byte buf[2];
 
       if (length != 2)
       {
          png_crc_finish(png_ptr, length);
          png_chunk_benign_error(png_ptr, "invalid");
          return;
       }
 
       png_crc_read(png_ptr, buf, 2);
       png_ptr->num_trans = 1;
       png_ptr->trans_color.gray = png_get_uint_16(buf);
    }
 
    else if (png_ptr->color_type == PNG_COLOR_TYPE_RGB)
    {
       png_byte buf[6];
 
       if (length != 6)
       {
          png_crc_finish(png_ptr, length);
          png_chunk_benign_error(png_ptr, "invalid");
          return;
       }
 
       png_crc_read(png_ptr, buf, length);
       png_ptr->num_trans = 1;
       png_ptr->trans_color.red = png_get_uint_16(buf);
       png_ptr->trans_color.green = png_get_uint_16(buf + 2);
       png_ptr->trans_color.blue = png_get_uint_16(buf + 4);
    }
 
    else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
    {
       if ((png_ptr->mode & PNG_HAVE_PLTE) == 0)
       {
          /* TODO: is this actually an error in the ISO spec? */
          png_crc_finish(png_ptr, length);
          png_chunk_benign_error(png_ptr, "out of place");
          return;
       }
 
       if (length > png_ptr->num_palette || length > PNG_MAX_PALETTE_LENGTH ||
          length == 0)
       {
          png_crc_finish(png_ptr, length);
          png_chunk_benign_error(png_ptr, "invalid");
          return;
       }
 
       png_crc_read(png_ptr, readbuf, length);
       png_ptr->num_trans = (png_uint_16)length;
    }
 
    else
    {
       png_crc_finish(png_ptr, length);
       png_chunk_benign_error(png_ptr, "invalid with alpha channel");
       return;
    }
 
    if (png_crc_finish(png_ptr, 0) != 0)
    {
       png_ptr->num_trans = 0;
       return;
    }
 
    /* TODO: this is a horrible side effect in the palette case because the
     * png_struct ends up with a pointer to the tRNS buffer owned by the
     * png_info.  Fix this.
     */
    png_set_tRNS(png_ptr, info_ptr, readbuf, png_ptr->num_trans,
        &(png_ptr->trans_color));
 }

void png_handle_zTXt	(	png_structrp	png_ptr,
		png_inforp	info_ptr,
		png_uint_32	length
	)

 {
    png_const_charp errmsg = NULL;
    png_bytep       buffer;
    png_uint_32     keyword_length;
 
    png_debug(1, "in png_handle_zTXt");
 
 #ifdef PNG_USER_LIMITS_SUPPORTED
    if (png_ptr->user_chunk_cache_max != 0)
    {
       if (png_ptr->user_chunk_cache_max == 1)
       {
          png_crc_finish(png_ptr, length);
          return;
       }
 
       if (--png_ptr->user_chunk_cache_max == 1)
       {
          png_crc_finish(png_ptr, length);
          png_chunk_benign_error(png_ptr, "no space in chunk cache");
          return;
       }
    }
 #endif
 
    if ((png_ptr->mode & PNG_HAVE_IHDR) == 0)
       png_chunk_error(png_ptr, "missing IHDR");
 
    if ((png_ptr->mode & PNG_HAVE_IDAT) != 0)
       png_ptr->mode |= PNG_AFTER_IDAT;
 
    buffer = png_read_buffer(png_ptr, length, 2/*silent*/);
 
    if (buffer == NULL)
    {
       png_crc_finish(png_ptr, length);
       png_chunk_benign_error(png_ptr, "out of memory");
       return;
    }
 
    png_crc_read(png_ptr, buffer, length);
 
    if (png_crc_finish(png_ptr, 0) != 0)
       return;
 
    /* TODO: also check that the keyword contents match the spec! */
    for (keyword_length = 0;
       keyword_length < length && buffer[keyword_length] != 0;
       ++keyword_length)
       /* Empty loop to find end of name */ ;
 
    if (keyword_length > 79 || keyword_length < 1)
       errmsg = "bad keyword";
 
    /* zTXt must have some LZ data after the keyword, although it may expand to
     * zero bytes; we need a '\0' at the end of the keyword, the compression type
     * then the LZ data:
     */
    else if (keyword_length + 3 > length)
       errmsg = "truncated";
 
    else if (buffer[keyword_length+1] != PNG_COMPRESSION_TYPE_BASE)
       errmsg = "unknown compression type";
 
    else
    {
       png_alloc_size_t uncompressed_length = PNG_SIZE_MAX;
 
       /* TODO: at present png_decompress_chunk imposes a single application
        * level memory limit, this should be split to different values for iCCP
        * and text chunks.
        */
       if (png_decompress_chunk(png_ptr, length, keyword_length+2,
          &uncompressed_length, 1/*terminate*/) == Z_STREAM_END)
       {
          png_text text;
 
          /* It worked; png_ptr->read_buffer now looks like a tEXt chunk except
           * for the extra compression type byte and the fact that it isn't
           * necessarily '\0' terminated.
           */
          buffer = png_ptr->read_buffer;
          buffer[uncompressed_length+(keyword_length+2)] = 0;
 
          text.compression = PNG_TEXT_COMPRESSION_zTXt;
          text.key = (png_charp)buffer;
          text.text = (png_charp)(buffer + keyword_length+2);
          text.text_length = uncompressed_length;
          text.itxt_length = 0;
          text.lang = NULL;
          text.lang_key = NULL;
 
          if (png_set_text_2(png_ptr, info_ptr, &text, 1) != 0)
             errmsg = "insufficient memory";
       }
 
       else
          errmsg = png_ptr->zstream.msg;
    }
 
    if (errmsg != NULL)
       png_chunk_benign_error(png_ptr, errmsg);
 }

void png_check_chunk_name	(	png_structrp	png_ptr,
		png_uint_32	chunk_name
	)

 {
    int i;
 
    png_debug(1, "in png_check_chunk_name");
 
    for (i=1; i<=4; ++i)
    {
       int c = chunk_name & 0xff;
 
       if (c < 65 || c > 122 || (c > 90 && c < 97))
          png_chunk_error(png_ptr, "invalid chunk type");
 
       chunk_name >>= 8;
    }
 }

void png_handle_unknown	(	png_structrp	png_ptr,
		png_inforp	info_ptr,
		png_uint_32	length,
		int	keep
	)

 {
    int handled = 0; /* the chunk was handled */
 
    png_debug(1, "in png_handle_unknown");
 
 #ifdef PNG_READ_UNKNOWN_CHUNKS_SUPPORTED
    /* NOTE: this code is based on the code in libpng-1.4.12 except for fixing
     * the bug which meant that setting a non-default behavior for a specific
     * chunk would be ignored (the default was always used unless a user
     * callback was installed).
     *
     * 'keep' is the value from the png_chunk_unknown_handling, the setting for
     * this specific chunk_name, if PNG_HANDLE_AS_UNKNOWN_SUPPORTED, if not it
     * will always be PNG_HANDLE_CHUNK_AS_DEFAULT and it needs to be set here.
     * This is just an optimization to avoid multiple calls to the lookup
     * function.
     */
 #  ifndef PNG_HANDLE_AS_UNKNOWN_SUPPORTED
 #     ifdef PNG_SET_UNKNOWN_CHUNKS_SUPPORTED
          keep = png_chunk_unknown_handling(png_ptr, png_ptr->chunk_name);
 #     endif
 #  endif
 
    /* One of the following methods will read the chunk or skip it (at least one
     * of these is always defined because this is the only way to switch on
     * PNG_READ_UNKNOWN_CHUNKS_SUPPORTED)
     */
 #  ifdef PNG_READ_USER_CHUNKS_SUPPORTED
       /* The user callback takes precedence over the chunk keep value, but the
        * keep value is still required to validate a save of a critical chunk.
        */
       if (png_ptr->read_user_chunk_fn != NULL)
       {
          if (png_cache_unknown_chunk(png_ptr, length) != 0)
          {
             /* Callback to user unknown chunk handler */
             int ret = (*(png_ptr->read_user_chunk_fn))(png_ptr,
                &png_ptr->unknown_chunk);
 
             /* ret is:
              * negative: An error occured, png_chunk_error will be called.
              *     zero: The chunk was not handled, the chunk will be discarded
              *           unless png_set_keep_unknown_chunks has been used to set
              *           a 'keep' behavior for this particular chunk, in which
              *           case that will be used.  A critical chunk will cause an
              *           error at this point unless it is to be saved.
              * positive: The chunk was handled, libpng will ignore/discard it.
              */
             if (ret < 0)
                png_chunk_error(png_ptr, "error in user chunk");
 
             else if (ret == 0)
             {
                /* If the keep value is 'default' or 'never' override it, but
                 * still error out on critical chunks unless the keep value is
                 * 'always'  While this is weird it is the behavior in 1.4.12.
                 * A possible improvement would be to obey the value set for the
                 * chunk, but this would be an API change that would probably
                 * damage some applications.
                 *
                 * The png_app_warning below catches the case that matters, where
                 * the application has not set specific save or ignore for this
                 * chunk or global save or ignore.
                 */
                if (keep < PNG_HANDLE_CHUNK_IF_SAFE)
                {
 #                 ifdef PNG_SET_UNKNOWN_CHUNKS_SUPPORTED
                      if (png_ptr->unknown_default < PNG_HANDLE_CHUNK_IF_SAFE)
                      {
                         png_chunk_warning(png_ptr, "Saving unknown chunk:");
                         png_app_warning(png_ptr,
                            "forcing save of an unhandled chunk;"
                            " please call png_set_keep_unknown_chunks");
                            /* with keep = PNG_HANDLE_CHUNK_IF_SAFE */
                      }
 #                 endif
                   keep = PNG_HANDLE_CHUNK_IF_SAFE;
                }
             }
 
             else /* chunk was handled */
             {
                handled = 1;
                /* Critical chunks can be safely discarded at this point. */
                keep = PNG_HANDLE_CHUNK_NEVER;
             }
          }
 
          else
             keep = PNG_HANDLE_CHUNK_NEVER; /* insufficient memory */
       }
 
       else
          /* Use the SAVE_UNKNOWN_CHUNKS code or skip the chunk */
 #  endif /* READ_USER_CHUNKS */
 
 #  ifdef PNG_SAVE_UNKNOWN_CHUNKS_SUPPORTED
       {
          /* keep is currently just the per-chunk setting, if there was no
           * setting change it to the global default now (not that this may
           * still be AS_DEFAULT) then obtain the cache of the chunk if required,
           * if not simply skip the chunk.
           */
          if (keep == PNG_HANDLE_CHUNK_AS_DEFAULT)
             keep = png_ptr->unknown_default;
 
          if (keep == PNG_HANDLE_CHUNK_ALWAYS ||
             (keep == PNG_HANDLE_CHUNK_IF_SAFE &&
              PNG_CHUNK_ANCILLARY(png_ptr->chunk_name)))
          {
             if (png_cache_unknown_chunk(png_ptr, length) == 0)
                keep = PNG_HANDLE_CHUNK_NEVER;
          }
 
          else
             png_crc_finish(png_ptr, length);
       }
 #  else
 #     ifndef PNG_READ_USER_CHUNKS_SUPPORTED
 #        error no method to support READ_UNKNOWN_CHUNKS
 #     endif
 
       {
          /* If here there is no read callback pointer set and no support is
           * compiled in to just save the unknown chunks, so simply skip this
           * chunk.  If 'keep' is something other than AS_DEFAULT or NEVER then
           * the app has erroneously asked for unknown chunk saving when there
           * is no support.
           */
          if (keep > PNG_HANDLE_CHUNK_NEVER)
             png_app_error(png_ptr, "no unknown chunk support available");
 
          png_crc_finish(png_ptr, length);
       }
 #  endif
 
 #  ifdef PNG_STORE_UNKNOWN_CHUNKS_SUPPORTED
       /* Now store the chunk in the chunk list if appropriate, and if the limits
        * permit it.
        */
       if (keep == PNG_HANDLE_CHUNK_ALWAYS ||
          (keep == PNG_HANDLE_CHUNK_IF_SAFE &&
           PNG_CHUNK_ANCILLARY(png_ptr->chunk_name)))
       {
 #     ifdef PNG_USER_LIMITS_SUPPORTED
          switch (png_ptr->user_chunk_cache_max)
          {
             case 2:
                png_ptr->user_chunk_cache_max = 1;
                png_chunk_benign_error(png_ptr, "no space in chunk cache");
                /* FALL THROUGH */
             case 1:
                /* NOTE: prior to 1.6.0 this case resulted in an unknown critical
                 * chunk being skipped, now there will be a hard error below.
                 */
                break;
 
             default: /* not at limit */
                --(png_ptr->user_chunk_cache_max);
                /* FALL THROUGH */
             case 0: /* no limit */
 #     endif /* USER_LIMITS */
                /* Here when the limit isn't reached or when limits are compiled
                 * out; store the chunk.
                 */
                png_set_unknown_chunks(png_ptr, info_ptr,
                   &png_ptr->unknown_chunk, 1);
                handled = 1;
 #     ifdef PNG_USER_LIMITS_SUPPORTED
                break;
          }
 #     endif
       }
 #  else /* no store support: the chunk must be handled by the user callback */
       PNG_UNUSED(info_ptr)
 #  endif
 
    /* Regardless of the error handling below the cached data (if any) can be
     * freed now.  Notice that the data is not freed if there is a png_error, but
     * it will be freed by destroy_read_struct.
     */
    if (png_ptr->unknown_chunk.data != NULL)
       png_free(png_ptr, png_ptr->unknown_chunk.data);
    png_ptr->unknown_chunk.data = NULL;
 
 #else /* !PNG_READ_UNKNOWN_CHUNKS_SUPPORTED */
    /* There is no support to read an unknown chunk, so just skip it. */
    png_crc_finish(png_ptr, length);
    PNG_UNUSED(info_ptr)
    PNG_UNUSED(keep)
 #endif /* !READ_UNKNOWN_CHUNKS */
 
    /* Check for unhandled critical chunks */
    if (handled == 0 && PNG_CHUNK_CRITICAL(png_ptr->chunk_name))
       png_chunk_error(png_ptr, "unhandled critical chunk");
 }

int png_chunk_unknown_handling	(	png_const_structrp	png_ptr,
		png_uint_32	chunk_name
	)

 {
    png_byte chunk_string[5];
 
    PNG_CSTRING_FROM_CHUNK(chunk_string, chunk_name);
    return png_handle_as_unknown(png_ptr, chunk_string);
 }

void png_do_read_transformations	(	png_structrp	png_ptr,
		png_row_infop	row_info
	)

 {
    png_debug(1, "in png_do_read_transformations");
 
    if (png_ptr->row_buf == NULL)
    {
       /* Prior to 1.5.4 this output row/pass where the NULL pointer is, but this
        * error is incredibly rare and incredibly easy to debug without this
        * information.
        */
       png_error(png_ptr, "NULL row buffer");
    }
 
    /* The following is debugging; prior to 1.5.4 the code was never compiled in;
     * in 1.5.4 PNG_FLAG_DETECT_UNINITIALIZED was added and the macro
     * PNG_WARN_UNINITIALIZED_ROW removed.  In 1.6 the new flag is set only for
     * all transformations, however in practice the ROW_INIT always gets done on
     * demand, if necessary.
     */
    if ((png_ptr->flags & PNG_FLAG_DETECT_UNINITIALIZED) != 0 &&
        (png_ptr->flags & PNG_FLAG_ROW_INIT) == 0)
    {
       /* Application has failed to call either png_read_start_image() or
        * png_read_update_info() after setting transforms that expand pixels.
        * This check added to libpng-1.2.19 (but not enabled until 1.5.4).
        */
       png_error(png_ptr, "Uninitialized row");
    }
 
 #ifdef PNG_READ_EXPAND_SUPPORTED
    if ((png_ptr->transformations & PNG_EXPAND) != 0)
    {
       if (row_info->color_type == PNG_COLOR_TYPE_PALETTE)
       {
          png_do_expand_palette(row_info, png_ptr->row_buf + 1,
              png_ptr->palette, png_ptr->trans_alpha, png_ptr->num_trans);
       }
 
       else
       {
          if (png_ptr->num_trans != 0 &&
              (png_ptr->transformations & PNG_EXPAND_tRNS) != 0)
             png_do_expand(row_info, png_ptr->row_buf + 1,
                 &(png_ptr->trans_color));
 
          else
             png_do_expand(row_info, png_ptr->row_buf + 1,
                 NULL);
       }
    }
 #endif
 
 #ifdef PNG_READ_STRIP_ALPHA_SUPPORTED
    if ((png_ptr->transformations & PNG_STRIP_ALPHA) != 0 &&
        (png_ptr->transformations & PNG_COMPOSE) == 0 &&
        (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA ||
        row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA))
       png_do_strip_channel(row_info, png_ptr->row_buf + 1,
          0 /* at_start == false, because SWAP_ALPHA happens later */);
 #endif
 
 #ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED
    if ((png_ptr->transformations & PNG_RGB_TO_GRAY) != 0)
    {
       int rgb_error =
           png_do_rgb_to_gray(png_ptr, row_info,
               png_ptr->row_buf + 1);
 
       if (rgb_error != 0)
       {
          png_ptr->rgb_to_gray_status=1;
          if ((png_ptr->transformations & PNG_RGB_TO_GRAY) ==
              PNG_RGB_TO_GRAY_WARN)
             png_warning(png_ptr, "png_do_rgb_to_gray found nongray pixel");
 
          if ((png_ptr->transformations & PNG_RGB_TO_GRAY) ==
              PNG_RGB_TO_GRAY_ERR)
             png_error(png_ptr, "png_do_rgb_to_gray found nongray pixel");
       }
    }
 #endif
 
 /* From Andreas Dilger e-mail to png-implement, 26 March 1998:
  *
  *   In most cases, the "simple transparency" should be done prior to doing
  *   gray-to-RGB, or you will have to test 3x as many bytes to check if a
  *   pixel is transparent.  You would also need to make sure that the
  *   transparency information is upgraded to RGB.
  *
  *   To summarize, the current flow is:
  *   - Gray + simple transparency -> compare 1 or 2 gray bytes and composite
  *                                   with background "in place" if transparent,
  *                                   convert to RGB if necessary
  *   - Gray + alpha -> composite with gray background and remove alpha bytes,
  *                                   convert to RGB if necessary
  *
  *   To support RGB backgrounds for gray images we need:
  *   - Gray + simple transparency -> convert to RGB + simple transparency,
  *                                   compare 3 or 6 bytes and composite with
  *                                   background "in place" if transparent
  *                                   (3x compare/pixel compared to doing
  *                                   composite with gray bkgrnd)
  *   - Gray + alpha -> convert to RGB + alpha, composite with background and
  *                                   remove alpha bytes (3x float
  *                                   operations/pixel compared with composite
  *                                   on gray background)
  *
  *  Greg's change will do this.  The reason it wasn't done before is for
  *  performance, as this increases the per-pixel operations.  If we would check
  *  in advance if the background was gray or RGB, and position the gray-to-RGB
  *  transform appropriately, then it would save a lot of work/time.
  */
 
 #ifdef PNG_READ_GRAY_TO_RGB_SUPPORTED
    /* If gray -> RGB, do so now only if background is non-gray; else do later
     * for performance reasons
     */
    if ((png_ptr->transformations & PNG_GRAY_TO_RGB) != 0 &&
        (png_ptr->mode & PNG_BACKGROUND_IS_GRAY) == 0)
       png_do_gray_to_rgb(row_info, png_ptr->row_buf + 1);
 #endif
 
 #if defined(PNG_READ_BACKGROUND_SUPPORTED) ||\
    defined(PNG_READ_ALPHA_MODE_SUPPORTED)
    if ((png_ptr->transformations & PNG_COMPOSE) != 0)
       png_do_compose(row_info, png_ptr->row_buf + 1, png_ptr);
 #endif
 
 #ifdef PNG_READ_GAMMA_SUPPORTED
    if ((png_ptr->transformations & PNG_GAMMA) != 0 &&
 #ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED
       /* Because RGB_TO_GRAY does the gamma transform. */
       (png_ptr->transformations & PNG_RGB_TO_GRAY) == 0 &&
 #endif
 #if defined(PNG_READ_BACKGROUND_SUPPORTED) ||\
    defined(PNG_READ_ALPHA_MODE_SUPPORTED)
       /* Because PNG_COMPOSE does the gamma transform if there is something to
        * do (if there is an alpha channel or transparency.)
        */
        !((png_ptr->transformations & PNG_COMPOSE) &&
        ((png_ptr->num_trans != 0) ||
        (png_ptr->color_type & PNG_COLOR_MASK_ALPHA) != 0)) &&
 #endif
       /* Because png_init_read_transformations transforms the palette, unless
        * RGB_TO_GRAY will do the transform.
        */
        (png_ptr->color_type != PNG_COLOR_TYPE_PALETTE))
       png_do_gamma(row_info, png_ptr->row_buf + 1, png_ptr);
 #endif
 
 #ifdef PNG_READ_STRIP_ALPHA_SUPPORTED
    if ((png_ptr->transformations & PNG_STRIP_ALPHA) != 0 &&
        (png_ptr->transformations & PNG_COMPOSE) != 0 &&
        (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA ||
        row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA))
       png_do_strip_channel(row_info, png_ptr->row_buf + 1,
           0 /* at_start == false, because SWAP_ALPHA happens later */);
 #endif
 
 #ifdef PNG_READ_ALPHA_MODE_SUPPORTED
    if ((png_ptr->transformations & PNG_ENCODE_ALPHA) != 0 &&
        (row_info->color_type & PNG_COLOR_MASK_ALPHA) != 0)
       png_do_encode_alpha(row_info, png_ptr->row_buf + 1, png_ptr);
 #endif
 
 #ifdef PNG_READ_SCALE_16_TO_8_SUPPORTED
    if ((png_ptr->transformations & PNG_SCALE_16_TO_8) != 0)
       png_do_scale_16_to_8(row_info, png_ptr->row_buf + 1);
 #endif
 
 #ifdef PNG_READ_STRIP_16_TO_8_SUPPORTED
    /* There is no harm in doing both of these because only one has any effect,
     * by putting the 'scale' option first if the app asks for scale (either by
     * calling the API or in a TRANSFORM flag) this is what happens.
     */
    if ((png_ptr->transformations & PNG_16_TO_8) != 0)
       png_do_chop(row_info, png_ptr->row_buf + 1);
 #endif
 
 #ifdef PNG_READ_QUANTIZE_SUPPORTED
    if ((png_ptr->transformations & PNG_QUANTIZE) != 0)
    {
       png_do_quantize(row_info, png_ptr->row_buf + 1,
           png_ptr->palette_lookup, png_ptr->quantize_index);
 
       if (row_info->rowbytes == 0)
          png_error(png_ptr, "png_do_quantize returned rowbytes=0");
    }
 #endif /* READ_QUANTIZE */
 
 #ifdef PNG_READ_EXPAND_16_SUPPORTED
    /* Do the expansion now, after all the arithmetic has been done.  Notice
     * that previous transformations can handle the PNG_EXPAND_16 flag if this
     * is efficient (particularly true in the case of gamma correction, where
     * better accuracy results faster!)
     */
    if ((png_ptr->transformations & PNG_EXPAND_16) != 0)
       png_do_expand_16(row_info, png_ptr->row_buf + 1);
 #endif
 
 #ifdef PNG_READ_GRAY_TO_RGB_SUPPORTED
    /* NOTE: moved here in 1.5.4 (from much later in this list.) */
    if ((png_ptr->transformations & PNG_GRAY_TO_RGB) != 0 &&
        (png_ptr->mode & PNG_BACKGROUND_IS_GRAY) != 0)
       png_do_gray_to_rgb(row_info, png_ptr->row_buf + 1);
 #endif
 
 #ifdef PNG_READ_INVERT_SUPPORTED
    if ((png_ptr->transformations & PNG_INVERT_MONO) != 0)
       png_do_invert(row_info, png_ptr->row_buf + 1);
 #endif
 
 #ifdef PNG_READ_INVERT_ALPHA_SUPPORTED
    if ((png_ptr->transformations & PNG_INVERT_ALPHA) != 0)
       png_do_read_invert_alpha(row_info, png_ptr->row_buf + 1);
 #endif
 
 #ifdef PNG_READ_SHIFT_SUPPORTED
    if ((png_ptr->transformations & PNG_SHIFT) != 0)
       png_do_unshift(row_info, png_ptr->row_buf + 1,
           &(png_ptr->shift));
 #endif
 
 #ifdef PNG_READ_PACK_SUPPORTED
    if ((png_ptr->transformations & PNG_PACK) != 0)
       png_do_unpack(row_info, png_ptr->row_buf + 1);
 #endif
 
 #ifdef PNG_READ_CHECK_FOR_INVALID_INDEX_SUPPORTED
    /* Added at libpng-1.5.10 */
    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
 
 #ifdef PNG_READ_BGR_SUPPORTED
    if ((png_ptr->transformations & PNG_BGR) != 0)
       png_do_bgr(row_info, png_ptr->row_buf + 1);
 #endif
 
 #ifdef PNG_READ_PACKSWAP_SUPPORTED
    if ((png_ptr->transformations & PNG_PACKSWAP) != 0)
       png_do_packswap(row_info, png_ptr->row_buf + 1);
 #endif
 
 #ifdef PNG_READ_FILLER_SUPPORTED
    if ((png_ptr->transformations & PNG_FILLER) != 0)
       png_do_read_filler(row_info, png_ptr->row_buf + 1,
           (png_uint_32)png_ptr->filler, png_ptr->flags);
 #endif
 
 #ifdef PNG_READ_SWAP_ALPHA_SUPPORTED
    if ((png_ptr->transformations & PNG_SWAP_ALPHA) != 0)
       png_do_read_swap_alpha(row_info, png_ptr->row_buf + 1);
 #endif
 
 #ifdef PNG_READ_16BIT_SUPPORTED
 #ifdef PNG_READ_SWAP_SUPPORTED
    if ((png_ptr->transformations & PNG_SWAP_BYTES) != 0)
       png_do_swap(row_info, png_ptr->row_buf + 1);
 #endif
 #endif
 
 #ifdef PNG_READ_USER_TRANSFORM_SUPPORTED
    if ((png_ptr->transformations & PNG_USER_TRANSFORM) != 0)
    {
       if (png_ptr->read_user_transform_fn != NULL)
          (*(png_ptr->read_user_transform_fn)) /* User read transform function */
              (png_ptr,     /* png_ptr */
              row_info,     /* row_info: */
                 /*  png_uint_32 width;       width of row */
                 /*  png_size_t rowbytes;     number of bytes in row */
                 /*  png_byte color_type;     color type of pixels */
                 /*  png_byte bit_depth;      bit depth of samples */
                 /*  png_byte channels;       number of channels (1-4) */
                 /*  png_byte pixel_depth;    bits per pixel (depth*channels) */
              png_ptr->row_buf + 1);    /* start of pixel data for row */
 #ifdef PNG_USER_TRANSFORM_PTR_SUPPORTED
       if (png_ptr->user_transform_depth != 0)
          row_info->bit_depth = png_ptr->user_transform_depth;
 
       if (png_ptr->user_transform_channels != 0)
          row_info->channels = png_ptr->user_transform_channels;
 #endif
       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);
    }
 #endif
 }

void png_do_write_transformations	(	png_structrp	png_ptr,
		png_row_infop	row_info
	)

 {
    png_debug(1, "in png_do_write_transformations");
 
    if (png_ptr == NULL)
       return;
 
 #ifdef PNG_WRITE_USER_TRANSFORM_SUPPORTED
    if ((png_ptr->transformations & PNG_USER_TRANSFORM) != 0)
       if (png_ptr->write_user_transform_fn != NULL)
          (*(png_ptr->write_user_transform_fn)) /* User write transform
                                                  function */
              (png_ptr,  /* png_ptr */
              row_info,  /* row_info: */
                 /*  png_uint_32 width;       width of row */
                 /*  png_size_t rowbytes;     number of bytes in row */
                 /*  png_byte color_type;     color type of pixels */
                 /*  png_byte bit_depth;      bit depth of samples */
                 /*  png_byte channels;       number of channels (1-4) */
                 /*  png_byte pixel_depth;    bits per pixel (depth*channels) */
              png_ptr->row_buf + 1);      /* start of pixel data for row */
 #endif
 
 #ifdef PNG_WRITE_FILLER_SUPPORTED
    if ((png_ptr->transformations & PNG_FILLER) != 0)
       png_do_strip_channel(row_info, png_ptr->row_buf + 1,
          !(png_ptr->flags & PNG_FLAG_FILLER_AFTER));
 #endif
 
 #ifdef PNG_WRITE_PACKSWAP_SUPPORTED
    if ((png_ptr->transformations & PNG_PACKSWAP) != 0)
       png_do_packswap(row_info, png_ptr->row_buf + 1);
 #endif
 
 #ifdef PNG_WRITE_PACK_SUPPORTED
    if ((png_ptr->transformations & PNG_PACK) != 0)
       png_do_pack(row_info, png_ptr->row_buf + 1,
           (png_uint_32)png_ptr->bit_depth);
 #endif
 
 #ifdef PNG_WRITE_SWAP_SUPPORTED
 #  ifdef PNG_16BIT_SUPPORTED
    if ((png_ptr->transformations & PNG_SWAP_BYTES) != 0)
       png_do_swap(row_info, png_ptr->row_buf + 1);
 #  endif
 #endif
 
 #ifdef PNG_WRITE_SHIFT_SUPPORTED
    if ((png_ptr->transformations & PNG_SHIFT) != 0)
       png_do_shift(row_info, png_ptr->row_buf + 1,
           &(png_ptr->shift));
 #endif
 
 #ifdef PNG_WRITE_SWAP_ALPHA_SUPPORTED
    if ((png_ptr->transformations & PNG_SWAP_ALPHA) != 0)
       png_do_write_swap_alpha(row_info, png_ptr->row_buf + 1);
 #endif
 
 #ifdef PNG_WRITE_INVERT_ALPHA_SUPPORTED
    if ((png_ptr->transformations & PNG_INVERT_ALPHA) != 0)
       png_do_write_invert_alpha(row_info, png_ptr->row_buf + 1);
 #endif
 
 #ifdef PNG_WRITE_BGR_SUPPORTED
    if ((png_ptr->transformations & PNG_BGR) != 0)
       png_do_bgr(row_info, png_ptr->row_buf + 1);
 #endif
 
 #ifdef PNG_WRITE_INVERT_SUPPORTED
    if ((png_ptr->transformations & PNG_INVERT_MONO) != 0)
       png_do_invert(row_info, png_ptr->row_buf + 1);
 #endif
 }

void png_init_read_transformations ( png_structrp png_ptr )

 {
    png_debug(1, "in png_init_read_transformations");
 
    /* This internal function is called from png_read_start_row in pngrutil.c
     * and it is called before the 'rowbytes' calculation is done, so the code
     * in here can change or update the transformations flags.
     *
     * First do updates that do not depend on the details of the PNG image data
     * being processed.
     */
 
 #ifdef PNG_READ_GAMMA_SUPPORTED
    /* Prior to 1.5.4 these tests were performed from png_set_gamma, 1.5.4 adds
     * png_set_alpha_mode and this is another source for a default file gamma so
     * the test needs to be performed later - here.  In addition prior to 1.5.4
     * the tests were repeated for the PALETTE color type here - this is no
     * longer necessary (and doesn't seem to have been necessary before.)
     */
    {
       /* The following temporary indicates if overall gamma correction is
        * required.
        */
       int gamma_correction = 0;
 
       if (png_ptr->colorspace.gamma != 0) /* has been set */
       {
          if (png_ptr->screen_gamma != 0) /* screen set too */
             gamma_correction = png_gamma_threshold(png_ptr->colorspace.gamma,
                png_ptr->screen_gamma);
 
          else
             /* Assume the output matches the input; a long time default behavior
              * of libpng, although the standard has nothing to say about this.
              */
             png_ptr->screen_gamma = png_reciprocal(png_ptr->colorspace.gamma);
       }
 
       else if (png_ptr->screen_gamma != 0)
          /* The converse - assume the file matches the screen, note that this
           * perhaps undesireable default can (from 1.5.4) be changed by calling
           * png_set_alpha_mode (even if the alpha handling mode isn't required
           * or isn't changed from the default.)
           */
          png_ptr->colorspace.gamma = png_reciprocal(png_ptr->screen_gamma);
 
       else /* neither are set */
          /* Just in case the following prevents any processing - file and screen
           * are both assumed to be linear and there is no way to introduce a
           * third gamma value other than png_set_background with 'UNIQUE', and,
           * prior to 1.5.4
           */
          png_ptr->screen_gamma = png_ptr->colorspace.gamma = PNG_FP_1;
 
       /* We have a gamma value now. */
       png_ptr->colorspace.flags |= PNG_COLORSPACE_HAVE_GAMMA;
 
       /* Now turn the gamma transformation on or off as appropriate.  Notice
        * that PNG_GAMMA just refers to the file->screen correction.  Alpha
        * composition may independently cause gamma correction because it needs
        * linear data (e.g. if the file has a gAMA chunk but the screen gamma
        * hasn't been specified.)  In any case this flag may get turned off in
        * the code immediately below if the transform can be handled outside the
        * row loop.
        */
       if (gamma_correction != 0)
          png_ptr->transformations |= PNG_GAMMA;
 
       else
          png_ptr->transformations &= ~PNG_GAMMA;
    }
 #endif
 
    /* Certain transformations have the effect of preventing other
     * transformations that happen afterward in png_do_read_transformations;
     * resolve the interdependencies here.  From the code of
     * png_do_read_transformations the order is:
     *
     *  1) PNG_EXPAND (including PNG_EXPAND_tRNS)
     *  2) PNG_STRIP_ALPHA (if no compose)
     *  3) PNG_RGB_TO_GRAY
     *  4) PNG_GRAY_TO_RGB iff !PNG_BACKGROUND_IS_GRAY
     *  5) PNG_COMPOSE
     *  6) PNG_GAMMA
     *  7) PNG_STRIP_ALPHA (if compose)
     *  8) PNG_ENCODE_ALPHA
     *  9) PNG_SCALE_16_TO_8
     * 10) PNG_16_TO_8
     * 11) PNG_QUANTIZE (converts to palette)
     * 12) PNG_EXPAND_16
     * 13) PNG_GRAY_TO_RGB iff PNG_BACKGROUND_IS_GRAY
     * 14) PNG_INVERT_MONO
     * 15) PNG_INVERT_ALPHA
     * 16) PNG_SHIFT
     * 17) PNG_PACK
     * 18) PNG_BGR
     * 19) PNG_PACKSWAP
     * 20) PNG_FILLER (includes PNG_ADD_ALPHA)
     * 21) PNG_SWAP_ALPHA
     * 22) PNG_SWAP_BYTES
     * 23) PNG_USER_TRANSFORM [must be last]
     */
 #ifdef PNG_READ_STRIP_ALPHA_SUPPORTED
    if ((png_ptr->transformations & PNG_STRIP_ALPHA) != 0 &&
        (png_ptr->transformations & PNG_COMPOSE) == 0)
    {
       /* Stripping the alpha channel happens immediately after the 'expand'
        * transformations, before all other transformation, so it cancels out
        * the alpha handling.  It has the side effect negating the effect of
        * PNG_EXPAND_tRNS too:
        */
       png_ptr->transformations &= ~(PNG_BACKGROUND_EXPAND | PNG_ENCODE_ALPHA |
          PNG_EXPAND_tRNS);
       png_ptr->flags &= ~PNG_FLAG_OPTIMIZE_ALPHA;
 
       /* Kill the tRNS chunk itself too.  Prior to 1.5.4 this did not happen
        * so transparency information would remain just so long as it wasn't
        * expanded.  This produces unexpected API changes if the set of things
        * that do PNG_EXPAND_tRNS changes (perfectly possible given the
        * documentation - which says ask for what you want, accept what you
        * get.)  This makes the behavior consistent from 1.5.4:
        */
       png_ptr->num_trans = 0;
    }
 #endif /* STRIP_ALPHA supported, no COMPOSE */
 
 #ifdef PNG_READ_ALPHA_MODE_SUPPORTED
    /* If the screen gamma is about 1.0 then the OPTIMIZE_ALPHA and ENCODE_ALPHA
     * settings will have no effect.
     */
    if (png_gamma_significant(png_ptr->screen_gamma) == 0)
    {
       png_ptr->transformations &= ~PNG_ENCODE_ALPHA;
       png_ptr->flags &= ~PNG_FLAG_OPTIMIZE_ALPHA;
    }
 #endif
 
 #ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED
    /* Make sure the coefficients for the rgb to gray conversion are set
     * appropriately.
     */
    if ((png_ptr->transformations & PNG_RGB_TO_GRAY) != 0)
       png_colorspace_set_rgb_coefficients(png_ptr);
 #endif
 
 #ifdef PNG_READ_GRAY_TO_RGB_SUPPORTED
 #if defined(PNG_READ_EXPAND_SUPPORTED) && defined(PNG_READ_BACKGROUND_SUPPORTED)
    /* Detect gray background and attempt to enable optimization for
     * gray --> RGB case.
     *
     * Note:  if PNG_BACKGROUND_EXPAND is set and color_type is either RGB or
     * RGB_ALPHA (in which case need_expand is superfluous anyway), the
     * background color might actually be gray yet not be flagged as such.
     * This is not a problem for the current code, which uses
     * PNG_BACKGROUND_IS_GRAY only to decide when to do the
     * png_do_gray_to_rgb() transformation.
     *
     * TODO: this code needs to be revised to avoid the complexity and
     * interdependencies.  The color type of the background should be recorded in
     * png_set_background, along with the bit depth, then the code has a record
     * of exactly what color space the background is currently in.
     */
    if ((png_ptr->transformations & PNG_BACKGROUND_EXPAND) != 0)
    {
       /* PNG_BACKGROUND_EXPAND: the background is in the file color space, so if
        * the file was grayscale the background value is gray.
        */
       if ((png_ptr->color_type & PNG_COLOR_MASK_COLOR) == 0)
          png_ptr->mode |= PNG_BACKGROUND_IS_GRAY;
    }
 
    else if ((png_ptr->transformations & PNG_COMPOSE) != 0)
    {
       /* PNG_COMPOSE: png_set_background was called with need_expand false,
        * so the color is in the color space of the output or png_set_alpha_mode
        * was called and the color is black.  Ignore RGB_TO_GRAY because that
        * happens before GRAY_TO_RGB.
        */
       if ((png_ptr->transformations & PNG_GRAY_TO_RGB) != 0)
       {
          if (png_ptr->background.red == png_ptr->background.green &&
              png_ptr->background.red == png_ptr->background.blue)
          {
             png_ptr->mode |= PNG_BACKGROUND_IS_GRAY;
             png_ptr->background.gray = png_ptr->background.red;
          }
       }
    }
 #endif /* READ_EXPAND && READ_BACKGROUND */
 #endif /* READ_GRAY_TO_RGB */
 
    /* For indexed PNG data (PNG_COLOR_TYPE_PALETTE) many of the transformations
     * can be performed directly on the palette, and some (such as rgb to gray)
     * can be optimized inside the palette.  This is particularly true of the
     * composite (background and alpha) stuff, which can be pretty much all done
     * in the palette even if the result is expanded to RGB or gray afterward.
     *
     * NOTE: this is Not Yet Implemented, the code behaves as in 1.5.1 and
     * earlier and the palette stuff is actually handled on the first row.  This
     * leads to the reported bug that the palette returned by png_get_PLTE is not
     * updated.
     */
    if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
       png_init_palette_transformations(png_ptr);
 
    else
       png_init_rgb_transformations(png_ptr);
 
 #if defined(PNG_READ_BACKGROUND_SUPPORTED) && \
    defined(PNG_READ_EXPAND_16_SUPPORTED)
    if ((png_ptr->transformations & PNG_EXPAND_16) != 0 &&
        (png_ptr->transformations & PNG_COMPOSE) != 0 &&
        (png_ptr->transformations & PNG_BACKGROUND_EXPAND) == 0 &&
        png_ptr->bit_depth != 16)
    {
       /* TODO: fix this.  Because the expand_16 operation is after the compose
        * handling the background color must be 8, not 16, bits deep, but the
        * application will supply a 16-bit value so reduce it here.
        *
        * The PNG_BACKGROUND_EXPAND code above does not expand to 16 bits at
        * present, so that case is ok (until do_expand_16 is moved.)
        *
        * NOTE: this discards the low 16 bits of the user supplied background
        * color, but until expand_16 works properly there is no choice!
        */
 #     define CHOP(x) (x)=((png_uint_16)PNG_DIV257(x))
       CHOP(png_ptr->background.red);
       CHOP(png_ptr->background.green);
       CHOP(png_ptr->background.blue);
       CHOP(png_ptr->background.gray);
 #     undef CHOP
    }
 #endif /* READ_BACKGROUND && READ_EXPAND_16 */
 
 #if defined(PNG_READ_BACKGROUND_SUPPORTED) && \
    (defined(PNG_READ_SCALE_16_TO_8_SUPPORTED) || \
    defined(PNG_READ_STRIP_16_TO_8_SUPPORTED))
    if ((png_ptr->transformations & (PNG_16_TO_8|PNG_SCALE_16_TO_8)) != 0 &&
        (png_ptr->transformations & PNG_COMPOSE) != 0 &&
        (png_ptr->transformations & PNG_BACKGROUND_EXPAND) == 0 &&
        png_ptr->bit_depth == 16)
    {
       /* On the other hand, if a 16-bit file is to be reduced to 8-bits per
        * component this will also happen after PNG_COMPOSE and so the background
        * color must be pre-expanded here.
        *
        * TODO: fix this too.
        */
       png_ptr->background.red = (png_uint_16)(png_ptr->background.red * 257);
       png_ptr->background.green =
          (png_uint_16)(png_ptr->background.green * 257);
       png_ptr->background.blue = (png_uint_16)(png_ptr->background.blue * 257);
       png_ptr->background.gray = (png_uint_16)(png_ptr->background.gray * 257);
    }
 #endif
 
    /* NOTE: below 'PNG_READ_ALPHA_MODE_SUPPORTED' is presumed to also enable the
     * background support (see the comments in scripts/pnglibconf.dfa), this
     * allows pre-multiplication of the alpha channel to be implemented as
     * compositing on black.  This is probably sub-optimal and has been done in
     * 1.5.4 betas simply to enable external critique and testing (i.e. to
     * implement the new API quickly, without lots of internal changes.)
     */
 
 #ifdef PNG_READ_GAMMA_SUPPORTED
 #  ifdef PNG_READ_BACKGROUND_SUPPORTED
       /* Includes ALPHA_MODE */
       png_ptr->background_1 = png_ptr->background;
 #  endif
 
    /* This needs to change - in the palette image case a whole set of tables are
     * built when it would be quicker to just calculate the correct value for
     * each palette entry directly.  Also, the test is too tricky - why check
     * PNG_RGB_TO_GRAY if PNG_GAMMA is not set?  The answer seems to be that
     * PNG_GAMMA is cancelled even if the gamma is known?  The test excludes the
     * PNG_COMPOSE case, so apparently if there is no *overall* gamma correction
     * the gamma tables will not be built even if composition is required on a
     * gamma encoded value.
     *
     * In 1.5.4 this is addressed below by an additional check on the individual
     * file gamma - if it is not 1.0 both RGB_TO_GRAY and COMPOSE need the
     * tables.
     */
    if ((png_ptr->transformations & PNG_GAMMA) != 0 ||
        ((png_ptr->transformations & PNG_RGB_TO_GRAY) != 0 &&
         (png_gamma_significant(png_ptr->colorspace.gamma) != 0 ||
          png_gamma_significant(png_ptr->screen_gamma) != 0)) ||
         ((png_ptr->transformations & PNG_COMPOSE) != 0 &&
          (png_gamma_significant(png_ptr->colorspace.gamma) != 0 ||
           png_gamma_significant(png_ptr->screen_gamma) != 0
 #  ifdef PNG_READ_BACKGROUND_SUPPORTED
          || (png_ptr->background_gamma_type == PNG_BACKGROUND_GAMMA_UNIQUE &&
            png_gamma_significant(png_ptr->background_gamma) != 0)
 #  endif
         )) || ((png_ptr->transformations & PNG_ENCODE_ALPHA) != 0 &&
        png_gamma_significant(png_ptr->screen_gamma) != 0))
    {
       png_build_gamma_table(png_ptr, png_ptr->bit_depth);
 
 #ifdef PNG_READ_BACKGROUND_SUPPORTED
       if ((png_ptr->transformations & PNG_COMPOSE) != 0)
       {
          /* Issue a warning about this combination: because RGB_TO_GRAY is
           * optimized to do the gamma transform if present yet do_background has
           * to do the same thing if both options are set a
           * double-gamma-correction happens.  This is true in all versions of
           * libpng to date.
           */
          if ((png_ptr->transformations & PNG_RGB_TO_GRAY) != 0)
             png_warning(png_ptr,
                "libpng does not support gamma+background+rgb_to_gray");
 
          if ((png_ptr->color_type == PNG_COLOR_TYPE_PALETTE) != 0)
          {
             /* We don't get to here unless there is a tRNS chunk with non-opaque
              * entries - see the checking code at the start of this function.
              */
             png_color back, back_1;
             png_colorp palette = png_ptr->palette;
             int num_palette = png_ptr->num_palette;
             int i;
             if (png_ptr->background_gamma_type == PNG_BACKGROUND_GAMMA_FILE)
             {
 
                back.red = png_ptr->gamma_table[png_ptr->background.red];
                back.green = png_ptr->gamma_table[png_ptr->background.green];
                back.blue = png_ptr->gamma_table[png_ptr->background.blue];
 
                back_1.red = png_ptr->gamma_to_1[png_ptr->background.red];
                back_1.green = png_ptr->gamma_to_1[png_ptr->background.green];
                back_1.blue = png_ptr->gamma_to_1[png_ptr->background.blue];
             }
             else
             {
                png_fixed_point g, gs;
 
                switch (png_ptr->background_gamma_type)
                {
                   case PNG_BACKGROUND_GAMMA_SCREEN:
                      g = (png_ptr->screen_gamma);
                      gs = PNG_FP_1;
                      break;
 
                   case PNG_BACKGROUND_GAMMA_FILE:
                      g = png_reciprocal(png_ptr->colorspace.gamma);
                      gs = png_reciprocal2(png_ptr->colorspace.gamma,
                         png_ptr->screen_gamma);
                      break;
 
                   case PNG_BACKGROUND_GAMMA_UNIQUE:
                      g = png_reciprocal(png_ptr->background_gamma);
                      gs = png_reciprocal2(png_ptr->background_gamma,
                         png_ptr->screen_gamma);
                      break;
                   default:
                      g = PNG_FP_1;    /* back_1 */
                      gs = PNG_FP_1;   /* back */
                      break;
                }
 
                if (png_gamma_significant(gs) != 0)
                {
                   back.red = png_gamma_8bit_correct(png_ptr->background.red,
                       gs);
                   back.green = png_gamma_8bit_correct(png_ptr->background.green,
                       gs);
                   back.blue = png_gamma_8bit_correct(png_ptr->background.blue,
                       gs);
                }
 
                else
                {
                   back.red   = (png_byte)png_ptr->background.red;
                   back.green = (png_byte)png_ptr->background.green;
                   back.blue  = (png_byte)png_ptr->background.blue;
                }
 
                if (png_gamma_significant(g) != 0)
                {
                   back_1.red = png_gamma_8bit_correct(png_ptr->background.red,
                      g);
                   back_1.green = png_gamma_8bit_correct(
                      png_ptr->background.green, g);
                   back_1.blue = png_gamma_8bit_correct(png_ptr->background.blue,
                      g);
                }
 
                else
                {
                   back_1.red   = (png_byte)png_ptr->background.red;
                   back_1.green = (png_byte)png_ptr->background.green;
                   back_1.blue  = (png_byte)png_ptr->background.blue;
                }
             }
 
             for (i = 0; i < num_palette; i++)
             {
                if (i < (int)png_ptr->num_trans &&
                    png_ptr->trans_alpha[i] != 0xff)
                {
                   if (png_ptr->trans_alpha[i] == 0)
                   {
                      palette[i] = back;
                   }
                   else /* if (png_ptr->trans_alpha[i] != 0xff) */
                   {
                      png_byte v, w;
 
                      v = png_ptr->gamma_to_1[palette[i].red];
                      png_composite(w, v, png_ptr->trans_alpha[i], back_1.red);
                      palette[i].red = png_ptr->gamma_from_1[w];
 
                      v = png_ptr->gamma_to_1[palette[i].green];
                      png_composite(w, v, png_ptr->trans_alpha[i], back_1.green);
                      palette[i].green = png_ptr->gamma_from_1[w];
 
                      v = png_ptr->gamma_to_1[palette[i].blue];
                      png_composite(w, v, png_ptr->trans_alpha[i], back_1.blue);
                      palette[i].blue = png_ptr->gamma_from_1[w];
                   }
                }
                else
                {
                   palette[i].red = png_ptr->gamma_table[palette[i].red];
                   palette[i].green = png_ptr->gamma_table[palette[i].green];
                   palette[i].blue = png_ptr->gamma_table[palette[i].blue];
                }
             }
 
             /* Prevent the transformations being done again.
              *
              * NOTE: this is highly dubious; it removes the transformations in
              * place.  This seems inconsistent with the general treatment of the
              * transformations elsewhere.
              */
             png_ptr->transformations &= ~(PNG_COMPOSE | PNG_GAMMA);
          } /* color_type == PNG_COLOR_TYPE_PALETTE */
 
          /* if (png_ptr->background_gamma_type!=PNG_BACKGROUND_GAMMA_UNKNOWN) */
          else /* color_type != PNG_COLOR_TYPE_PALETTE */
          {
             int gs_sig, g_sig;
             png_fixed_point g = PNG_FP_1;  /* Correction to linear */
             png_fixed_point gs = PNG_FP_1; /* Correction to screen */
 
             switch (png_ptr->background_gamma_type)
             {
                case PNG_BACKGROUND_GAMMA_SCREEN:
                   g = png_ptr->screen_gamma;
                   /* gs = PNG_FP_1; */
                   break;
 
                case PNG_BACKGROUND_GAMMA_FILE:
                   g = png_reciprocal(png_ptr->colorspace.gamma);
                   gs = png_reciprocal2(png_ptr->colorspace.gamma,
                      png_ptr->screen_gamma);
                   break;
 
                case PNG_BACKGROUND_GAMMA_UNIQUE:
                   g = png_reciprocal(png_ptr->background_gamma);
                   gs = png_reciprocal2(png_ptr->background_gamma,
                       png_ptr->screen_gamma);
                   break;
 
                default:
                   png_error(png_ptr, "invalid background gamma type");
             }
 
             g_sig = png_gamma_significant(g);
             gs_sig = png_gamma_significant(gs);
 
             if (g_sig != 0)
                png_ptr->background_1.gray = png_gamma_correct(png_ptr,
                    png_ptr->background.gray, g);
 
             if (gs_sig != 0)
                png_ptr->background.gray = png_gamma_correct(png_ptr,
                    png_ptr->background.gray, gs);
 
             if ((png_ptr->background.red != png_ptr->background.green) ||
                 (png_ptr->background.red != png_ptr->background.blue) ||
                 (png_ptr->background.red != png_ptr->background.gray))
             {
                /* RGB or RGBA with color background */
                if (g_sig != 0)
                {
                   png_ptr->background_1.red = png_gamma_correct(png_ptr,
                       png_ptr->background.red, g);
 
                   png_ptr->background_1.green = png_gamma_correct(png_ptr,
                       png_ptr->background.green, g);
 
                   png_ptr->background_1.blue = png_gamma_correct(png_ptr,
                       png_ptr->background.blue, g);
                }
 
                if (gs_sig != 0)
                {
                   png_ptr->background.red = png_gamma_correct(png_ptr,
                       png_ptr->background.red, gs);
 
                   png_ptr->background.green = png_gamma_correct(png_ptr,
                       png_ptr->background.green, gs);
 
                   png_ptr->background.blue = png_gamma_correct(png_ptr,
                       png_ptr->background.blue, gs);
                }
             }
 
             else
             {
                /* GRAY, GRAY ALPHA, RGB, or RGBA with gray background */
                png_ptr->background_1.red = png_ptr->background_1.green
                    = png_ptr->background_1.blue = png_ptr->background_1.gray;
 
                png_ptr->background.red = png_ptr->background.green
                    = png_ptr->background.blue = png_ptr->background.gray;
             }
 
             /* The background is now in screen gamma: */
             png_ptr->background_gamma_type = PNG_BACKGROUND_GAMMA_SCREEN;
          } /* color_type != PNG_COLOR_TYPE_PALETTE */
       }/* png_ptr->transformations & PNG_BACKGROUND */
 
       else
       /* Transformation does not include PNG_BACKGROUND */
 #endif /* READ_BACKGROUND */
       if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE
 #ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED
          /* RGB_TO_GRAY needs to have non-gamma-corrected values! */
          && ((png_ptr->transformations & PNG_EXPAND) == 0 ||
          (png_ptr->transformations & PNG_RGB_TO_GRAY) == 0)
 #endif
          )
       {
          png_colorp palette = png_ptr->palette;
          int num_palette = png_ptr->num_palette;
          int i;
 
          /* NOTE: there are other transformations that should probably be in
           * here too.
           */
          for (i = 0; i < num_palette; i++)
          {
             palette[i].red = png_ptr->gamma_table[palette[i].red];
             palette[i].green = png_ptr->gamma_table[palette[i].green];
             palette[i].blue = png_ptr->gamma_table[palette[i].blue];
          }
 
          /* Done the gamma correction. */
          png_ptr->transformations &= ~PNG_GAMMA;
       } /* color_type == PALETTE && !PNG_BACKGROUND transformation */
    }
 #ifdef PNG_READ_BACKGROUND_SUPPORTED
    else
 #endif
 #endif /* READ_GAMMA */
 
 #ifdef PNG_READ_BACKGROUND_SUPPORTED
    /* No GAMMA transformation (see the hanging else 4 lines above) */
    if ((png_ptr->transformations & PNG_COMPOSE) != 0 &&
        (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE))
    {
       int i;
       int istop = (int)png_ptr->num_trans;
       png_color back;
       png_colorp palette = png_ptr->palette;
 
       back.red   = (png_byte)png_ptr->background.red;
       back.green = (png_byte)png_ptr->background.green;
       back.blue  = (png_byte)png_ptr->background.blue;
 
       for (i = 0; i < istop; i++)
       {
          if (png_ptr->trans_alpha[i] == 0)
          {
             palette[i] = back;
          }
 
          else if (png_ptr->trans_alpha[i] != 0xff)
          {
             /* The png_composite() macro is defined in png.h */
             png_composite(palette[i].red, palette[i].red,
                 png_ptr->trans_alpha[i], back.red);
 
             png_composite(palette[i].green, palette[i].green,
                 png_ptr->trans_alpha[i], back.green);
 
             png_composite(palette[i].blue, palette[i].blue,
                 png_ptr->trans_alpha[i], back.blue);
          }
       }
 
       png_ptr->transformations &= ~PNG_COMPOSE;
    }
 #endif /* READ_BACKGROUND */
 
 #ifdef PNG_READ_SHIFT_SUPPORTED
    if ((png_ptr->transformations & PNG_SHIFT) != 0 &&
        (png_ptr->transformations & PNG_EXPAND) == 0 &&
        (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE))
    {
       int i;
       int istop = png_ptr->num_palette;
       int shift = 8 - png_ptr->sig_bit.red;
 
       png_ptr->transformations &= ~PNG_SHIFT;
 
       /* significant bits can be in the range 1 to 7 for a meaninful result, if
        * the number of significant bits is 0 then no shift is done (this is an
        * error condition which is silently ignored.)
        */
       if (shift > 0 && shift < 8)
          for (i=0; i<istop; ++i)
          {
             int component = png_ptr->palette[i].red;
 
             component >>= shift;
             png_ptr->palette[i].red = (png_byte)component;
          }
 
       shift = 8 - png_ptr->sig_bit.green;
       if (shift > 0 && shift < 8)
          for (i=0; i<istop; ++i)
          {
             int component = png_ptr->palette[i].green;
 
             component >>= shift;
             png_ptr->palette[i].green = (png_byte)component;
          }
 
       shift = 8 - png_ptr->sig_bit.blue;
       if (shift > 0 && shift < 8)
          for (i=0; i<istop; ++i)
          {
             int component = png_ptr->palette[i].blue;
 
             component >>= shift;
             png_ptr->palette[i].blue = (png_byte)component;
          }
    }
 #endif  /* READ_SHIFT */
 }

void png_push_read_chunk	(	png_structrp	png_ptr,
		png_inforp	info_ptr
	)

 {
    png_uint_32 chunk_name;
 #ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED
    int keep; /* unknown handling method */
 #endif
 
    /* First we make sure we have enough data for the 4-byte chunk name
     * and the 4-byte chunk length before proceeding with decoding the
     * chunk data.  To fully decode each of these chunks, we also make
     * sure we have enough data in the buffer for the 4-byte CRC at the
     * end of every chunk (except IDAT, which is handled separately).
     */
    if ((png_ptr->mode & PNG_HAVE_CHUNK_HEADER) == 0)
    {
       png_byte chunk_length[4];
       png_byte chunk_tag[4];
 
       PNG_PUSH_SAVE_BUFFER_IF_LT(8)
       png_push_fill_buffer(png_ptr, chunk_length, 4);
       png_ptr->push_length = png_get_uint_31(png_ptr, chunk_length);
       png_reset_crc(png_ptr);
       png_crc_read(png_ptr, chunk_tag, 4);
       png_ptr->chunk_name = PNG_CHUNK_FROM_STRING(chunk_tag);
       png_check_chunk_name(png_ptr, png_ptr->chunk_name);
       png_ptr->mode |= PNG_HAVE_CHUNK_HEADER;
    }
 
    chunk_name = png_ptr->chunk_name;
 
    if (chunk_name == png_IDAT)
    {
       if ((png_ptr->mode & PNG_AFTER_IDAT) != 0)
          png_ptr->mode |= PNG_HAVE_CHUNK_AFTER_IDAT;
 
       /* If we reach an IDAT chunk, this means we have read all of the
        * header chunks, and we can start reading the image (or if this
        * is called after the image has been read - we have an error).
        */
       if ((png_ptr->mode & PNG_HAVE_IHDR) == 0)
          png_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_error(png_ptr, "Missing PLTE before IDAT");
 
       png_ptr->mode |= PNG_HAVE_IDAT;
       png_ptr->process_mode = PNG_READ_IDAT_MODE;
 
       if ((png_ptr->mode & PNG_HAVE_CHUNK_AFTER_IDAT) == 0)
          if (png_ptr->push_length == 0)
             return;
 
       if ((png_ptr->mode & PNG_AFTER_IDAT) != 0)
          png_benign_error(png_ptr, "Too many IDATs found");
    }
 
    if (chunk_name == png_IHDR)
    {
       if (png_ptr->push_length != 13)
          png_error(png_ptr, "Invalid IHDR length");
 
       PNG_PUSH_SAVE_BUFFER_IF_FULL
       png_handle_IHDR(png_ptr, info_ptr, png_ptr->push_length);
    }
 
    else if (chunk_name == png_IEND)
    {
       PNG_PUSH_SAVE_BUFFER_IF_FULL
       png_handle_IEND(png_ptr, info_ptr, png_ptr->push_length);
 
       png_ptr->process_mode = PNG_READ_DONE_MODE;
       png_push_have_end(png_ptr, info_ptr);
    }
 
 #ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED
    else if ((keep = png_chunk_unknown_handling(png_ptr, chunk_name)) != 0)
    {
       PNG_PUSH_SAVE_BUFFER_IF_FULL
       png_handle_unknown(png_ptr, info_ptr, png_ptr->push_length, keep);
 
       if (chunk_name == png_PLTE)
          png_ptr->mode |= PNG_HAVE_PLTE;
    }
 #endif
 
    else if (chunk_name == png_PLTE)
    {
       PNG_PUSH_SAVE_BUFFER_IF_FULL
       png_handle_PLTE(png_ptr, info_ptr, png_ptr->push_length);
    }
 
    else if (chunk_name == png_IDAT)
    {
       png_ptr->idat_size = png_ptr->push_length;
       png_ptr->process_mode = PNG_READ_IDAT_MODE;
       png_push_have_info(png_ptr, info_ptr);
       png_ptr->zstream.avail_out =
           (uInt) PNG_ROWBYTES(png_ptr->pixel_depth,
           png_ptr->iwidth) + 1;
       png_ptr->zstream.next_out = png_ptr->row_buf;
       return;
    }
 
 #ifdef PNG_READ_gAMA_SUPPORTED
    else if (png_ptr->chunk_name == png_gAMA)
    {
       PNG_PUSH_SAVE_BUFFER_IF_FULL
       png_handle_gAMA(png_ptr, info_ptr, png_ptr->push_length);
    }
 
 #endif
 #ifdef PNG_READ_sBIT_SUPPORTED
    else if (png_ptr->chunk_name == png_sBIT)
    {
       PNG_PUSH_SAVE_BUFFER_IF_FULL
       png_handle_sBIT(png_ptr, info_ptr, png_ptr->push_length);
    }
 
 #endif
 #ifdef PNG_READ_cHRM_SUPPORTED
    else if (png_ptr->chunk_name == png_cHRM)
    {
       PNG_PUSH_SAVE_BUFFER_IF_FULL
       png_handle_cHRM(png_ptr, info_ptr, png_ptr->push_length);
    }
 
 #endif
 #ifdef PNG_READ_sRGB_SUPPORTED
    else if (chunk_name == png_sRGB)
    {
       PNG_PUSH_SAVE_BUFFER_IF_FULL
       png_handle_sRGB(png_ptr, info_ptr, png_ptr->push_length);
    }
 
 #endif
 #ifdef PNG_READ_iCCP_SUPPORTED
    else if (png_ptr->chunk_name == png_iCCP)
    {
       PNG_PUSH_SAVE_BUFFER_IF_FULL
       png_handle_iCCP(png_ptr, info_ptr, png_ptr->push_length);
    }
 
 #endif
 #ifdef PNG_READ_sPLT_SUPPORTED
    else if (chunk_name == png_sPLT)
    {
       PNG_PUSH_SAVE_BUFFER_IF_FULL
       png_handle_sPLT(png_ptr, info_ptr, png_ptr->push_length);
    }
 
 #endif
 #ifdef PNG_READ_tRNS_SUPPORTED
    else if (chunk_name == png_tRNS)
    {
       PNG_PUSH_SAVE_BUFFER_IF_FULL
       png_handle_tRNS(png_ptr, info_ptr, png_ptr->push_length);
    }
 
 #endif
 #ifdef PNG_READ_bKGD_SUPPORTED
    else if (chunk_name == png_bKGD)
    {
       PNG_PUSH_SAVE_BUFFER_IF_FULL
       png_handle_bKGD(png_ptr, info_ptr, png_ptr->push_length);
    }
 
 #endif
 #ifdef PNG_READ_hIST_SUPPORTED
    else if (chunk_name == png_hIST)
    {
       PNG_PUSH_SAVE_BUFFER_IF_FULL
       png_handle_hIST(png_ptr, info_ptr, png_ptr->push_length);
    }
 
 #endif
 #ifdef PNG_READ_pHYs_SUPPORTED
    else if (chunk_name == png_pHYs)
    {
       PNG_PUSH_SAVE_BUFFER_IF_FULL
       png_handle_pHYs(png_ptr, info_ptr, png_ptr->push_length);
    }
 
 #endif
 #ifdef PNG_READ_oFFs_SUPPORTED
    else if (chunk_name == png_oFFs)
    {
       PNG_PUSH_SAVE_BUFFER_IF_FULL
       png_handle_oFFs(png_ptr, info_ptr, png_ptr->push_length);
    }
 #endif
 
 #ifdef PNG_READ_pCAL_SUPPORTED
    else if (chunk_name == png_pCAL)
    {
       PNG_PUSH_SAVE_BUFFER_IF_FULL
       png_handle_pCAL(png_ptr, info_ptr, png_ptr->push_length);
    }
 
 #endif
 #ifdef PNG_READ_sCAL_SUPPORTED
    else if (chunk_name == png_sCAL)
    {
       PNG_PUSH_SAVE_BUFFER_IF_FULL
       png_handle_sCAL(png_ptr, info_ptr, png_ptr->push_length);
    }
 
 #endif
 #ifdef PNG_READ_tIME_SUPPORTED
    else if (chunk_name == png_tIME)
    {
       PNG_PUSH_SAVE_BUFFER_IF_FULL
       png_handle_tIME(png_ptr, info_ptr, png_ptr->push_length);
    }
 
 #endif
 #ifdef PNG_READ_tEXt_SUPPORTED
    else if (chunk_name == png_tEXt)
    {
       PNG_PUSH_SAVE_BUFFER_IF_FULL
       png_handle_tEXt(png_ptr, info_ptr, png_ptr->push_length);
    }
 
 #endif
 #ifdef PNG_READ_zTXt_SUPPORTED
    else if (chunk_name == png_zTXt)
    {
       PNG_PUSH_SAVE_BUFFER_IF_FULL
       png_handle_zTXt(png_ptr, info_ptr, png_ptr->push_length);
    }
 
 #endif
 #ifdef PNG_READ_iTXt_SUPPORTED
    else if (chunk_name == png_iTXt)
    {
       PNG_PUSH_SAVE_BUFFER_IF_FULL
       png_handle_iTXt(png_ptr, info_ptr, png_ptr->push_length);
    }
 #endif
 
    else
    {
       PNG_PUSH_SAVE_BUFFER_IF_FULL
       png_handle_unknown(png_ptr, info_ptr, png_ptr->push_length,
          PNG_HANDLE_CHUNK_AS_DEFAULT);
    }
 
    png_ptr->mode &= ~PNG_HAVE_CHUNK_HEADER;
 }

void png_push_read_sig	(	png_structrp	png_ptr,
		png_inforp	info_ptr
	)

 {
    png_size_t num_checked = png_ptr->sig_bytes, /* SAFE, does not exceed 8 */ 
              num_to_check = 8 - num_checked;
 
    if (png_ptr->buffer_size < num_to_check)
    {
       num_to_check = png_ptr->buffer_size;
    }
 
    png_push_fill_buffer(png_ptr, &(info_ptr->signature[num_checked]),
        num_to_check);
    png_ptr->sig_bytes = (png_byte)(png_ptr->sig_bytes + num_to_check);
 
    if (png_sig_cmp(info_ptr->signature, num_checked, num_to_check))
    {
       if (num_checked < 4 &&
           png_sig_cmp(info_ptr->signature, num_checked, num_to_check - 4))
          png_error(png_ptr, "Not a PNG file");
 
       else
          png_error(png_ptr, "PNG file corrupted by ASCII conversion");
    }
    else
    {
       if (png_ptr->sig_bytes >= 8)
       {
          png_ptr->process_mode = PNG_READ_CHUNK_MODE;
       }
    }
 }

void png_push_check_crc ( png_structrp png_ptr )

void png_push_crc_skip	(	png_structrp	png_ptr,
		png_uint_32	length
	)

 {
    png_ptr->process_mode = PNG_SKIP_MODE;
    png_ptr->skip_length = skip;
 }

void png_push_crc_finish ( png_structrp png_ptr )

 {
    if (png_ptr->skip_length != 0 && png_ptr->save_buffer_size != 0)
    {
       png_size_t save_size = png_ptr->save_buffer_size;
       png_uint_32 skip_length = png_ptr->skip_length;
 
       /* We want the smaller of 'skip_length' and 'save_buffer_size', but
        * they are of different types and we don't know which variable has the
        * fewest bits.  Carefully select the smaller and cast it to the type of
        * the larger - this cannot overflow.  Do not cast in the following test
        * - it will break on either 16 or 64 bit platforms.
        */
       if (skip_length < save_size)
          save_size = (png_size_t)skip_length;
 
       else
          skip_length = (png_uint_32)save_size;
 
       png_calculate_crc(png_ptr, png_ptr->save_buffer_ptr, save_size);
 
       png_ptr->skip_length -= skip_length;
       png_ptr->buffer_size -= save_size;
       png_ptr->save_buffer_size -= save_size;
       png_ptr->save_buffer_ptr += save_size;
    }
    if (png_ptr->skip_length != 0 && png_ptr->current_buffer_size != 0)
    {
       png_size_t save_size = png_ptr->current_buffer_size;
       png_uint_32 skip_length = png_ptr->skip_length;
 
       /* We want the smaller of 'skip_length' and 'current_buffer_size', here,
        * the same problem exists as above and the same solution.
        */
       if (skip_length < save_size)
          save_size = (png_size_t)skip_length;
 
       else
          skip_length = (png_uint_32)save_size;
 
       png_calculate_crc(png_ptr, png_ptr->current_buffer_ptr, save_size);
 
       png_ptr->skip_length -= skip_length;
       png_ptr->buffer_size -= save_size;
       png_ptr->current_buffer_size -= save_size;
       png_ptr->current_buffer_ptr += save_size;
    }
    if (png_ptr->skip_length == 0)
    {
       PNG_PUSH_SAVE_BUFFER_IF_LT(4)
       png_crc_finish(png_ptr, 0);
       png_ptr->process_mode = PNG_READ_CHUNK_MODE;
    }
 }

void png_push_save_buffer ( png_structrp png_ptr )

 {
    if (png_ptr->save_buffer_size != 0)
    {
       if (png_ptr->save_buffer_ptr != png_ptr->save_buffer)
       {
          png_size_t i, istop;
          png_bytep sp;
          png_bytep dp;
 
          istop = png_ptr->save_buffer_size;
          for (i = 0, sp = png_ptr->save_buffer_ptr, dp = png_ptr->save_buffer;
              i < istop; i++, sp++, dp++)
          {
             *dp = *sp;
          }
       }
    }
    if (png_ptr->save_buffer_size + png_ptr->current_buffer_size >
        png_ptr->save_buffer_max)
    {
       png_size_t new_max;
       png_bytep old_buffer;
 
       if (png_ptr->save_buffer_size > PNG_SIZE_MAX -
           (png_ptr->current_buffer_size + 256))
       {
          png_error(png_ptr, "Potential overflow of save_buffer");
       }
 
       new_max = png_ptr->save_buffer_size + png_ptr->current_buffer_size + 256;
       old_buffer = png_ptr->save_buffer;
       png_ptr->save_buffer = (png_bytep)png_malloc_warn(png_ptr,
           (png_size_t)new_max);
 
       if (png_ptr->save_buffer == NULL)
       {
          png_free(png_ptr, old_buffer);
          old_buffer = NULL;
          png_error(png_ptr, "Insufficient memory for save_buffer");
       }
 
       memcpy(png_ptr->save_buffer, old_buffer, png_ptr->save_buffer_size);
       png_free(png_ptr, old_buffer);
       old_buffer = NULL;
       png_ptr->save_buffer_max = new_max;
    }
    if (png_ptr->current_buffer_size)
    {
       memcpy(png_ptr->save_buffer + png_ptr->save_buffer_size,
          png_ptr->current_buffer_ptr, png_ptr->current_buffer_size);
       png_ptr->save_buffer_size += png_ptr->current_buffer_size;
       png_ptr->current_buffer_size = 0;
    }
    png_ptr->save_buffer_ptr = png_ptr->save_buffer;
    png_ptr->buffer_size = 0;
 }

void png_push_restore_buffer	(	png_structrp	png_ptr,
		png_bytep	buffer,
		png_size_t	buffer_length
	)

 {
    png_ptr->current_buffer = buffer;
    png_ptr->current_buffer_size = buffer_length;
    png_ptr->buffer_size = buffer_length + png_ptr->save_buffer_size;
    png_ptr->current_buffer_ptr = png_ptr->current_buffer;
 }

void png_push_read_IDAT ( png_structrp png_ptr )

 {
    if ((png_ptr->mode & PNG_HAVE_CHUNK_HEADER) == 0)
    {
       png_byte chunk_length[4];
       png_byte chunk_tag[4];
 
       /* TODO: this code can be commoned up with the same code in push_read */
       PNG_PUSH_SAVE_BUFFER_IF_LT(8)
       png_push_fill_buffer(png_ptr, chunk_length, 4);
       png_ptr->push_length = png_get_uint_31(png_ptr, chunk_length);
       png_reset_crc(png_ptr);
       png_crc_read(png_ptr, chunk_tag, 4);
       png_ptr->chunk_name = PNG_CHUNK_FROM_STRING(chunk_tag);
       png_ptr->mode |= PNG_HAVE_CHUNK_HEADER;
 
       if (png_ptr->chunk_name != png_IDAT)
       {
          png_ptr->process_mode = PNG_READ_CHUNK_MODE;
 
          if ((png_ptr->flags & PNG_FLAG_ZSTREAM_ENDED) == 0)
             png_error(png_ptr, "Not enough compressed data");
 
          return;
       }
 
       png_ptr->idat_size = png_ptr->push_length;
    }
 
    if (png_ptr->idat_size != 0 && png_ptr->save_buffer_size != 0)
    {
       png_size_t save_size = png_ptr->save_buffer_size;
       png_uint_32 idat_size = png_ptr->idat_size;
 
       /* We want the smaller of 'idat_size' and 'current_buffer_size', but they
        * are of different types and we don't know which variable has the fewest
        * bits.  Carefully select the smaller and cast it to the type of the
        * larger - this cannot overflow.  Do not cast in the following test - it
        * will break on either 16 or 64 bit platforms.
        */
       if (idat_size < save_size)
          save_size = (png_size_t)idat_size;
 
       else
          idat_size = (png_uint_32)save_size;
 
       png_calculate_crc(png_ptr, png_ptr->save_buffer_ptr, save_size);
 
       png_process_IDAT_data(png_ptr, png_ptr->save_buffer_ptr, save_size);
 
       png_ptr->idat_size -= idat_size;
       png_ptr->buffer_size -= save_size;
       png_ptr->save_buffer_size -= save_size;
       png_ptr->save_buffer_ptr += save_size;
    }
 
    if (png_ptr->idat_size != 0 && png_ptr->current_buffer_size != 0)
    {
       png_size_t save_size = png_ptr->current_buffer_size;
       png_uint_32 idat_size = png_ptr->idat_size;
 
       /* We want the smaller of 'idat_size' and 'current_buffer_size', but they
        * are of different types and we don't know which variable has the fewest
        * bits.  Carefully select the smaller and cast it to the type of the
        * larger - this cannot overflow.
        */
       if (idat_size < save_size)
          save_size = (png_size_t)idat_size;
 
       else
          idat_size = (png_uint_32)save_size;
 
       png_calculate_crc(png_ptr, png_ptr->current_buffer_ptr, save_size);
 
       png_process_IDAT_data(png_ptr, png_ptr->current_buffer_ptr, save_size);
 
       png_ptr->idat_size -= idat_size;
       png_ptr->buffer_size -= save_size;
       png_ptr->current_buffer_size -= save_size;
       png_ptr->current_buffer_ptr += save_size;
    }
    if (png_ptr->idat_size == 0)
    {
       PNG_PUSH_SAVE_BUFFER_IF_LT(4)
       png_crc_finish(png_ptr, 0);
       png_ptr->mode &= ~PNG_HAVE_CHUNK_HEADER;
       png_ptr->mode |= PNG_AFTER_IDAT;
       png_ptr->zowner = 0;
    }
 }

void png_process_IDAT_data	(	png_structrp	png_ptr,
		png_bytep	buffer,
		png_size_t	buffer_length
	)

 {
    /* The caller checks for a non-zero buffer length. */
    if (!(buffer_length > 0) || buffer == NULL)
       png_error(png_ptr, "No IDAT data (internal error)");
 
    /* This routine must process all the data it has been given
     * before returning, calling the row callback as required to
     * handle the uncompressed results.
     */
    png_ptr->zstream.next_in = buffer;
    /* TODO: WARNING: TRUNCATION ERROR: DANGER WILL ROBINSON: */
    png_ptr->zstream.avail_in = (uInt)buffer_length;
 
    /* Keep going until the decompressed data is all processed
     * or the stream marked as finished.
     */
    while (png_ptr->zstream.avail_in > 0 &&
       !(png_ptr->flags & PNG_FLAG_ZSTREAM_ENDED))
    {
       int ret;
 
       /* We have data for zlib, but we must check that zlib
        * has someplace to put the results.  It doesn't matter
        * if we don't expect any results -- it may be the input
        * data is just the LZ end code.
        */
       if (!(png_ptr->zstream.avail_out > 0))
       {
          /* TODO: WARNING: TRUNCATION ERROR: DANGER WILL ROBINSON: */
          png_ptr->zstream.avail_out = (uInt)(PNG_ROWBYTES(png_ptr->pixel_depth,
              png_ptr->iwidth) + 1);
 
          png_ptr->zstream.next_out = png_ptr->row_buf;
       }
 
       /* Using Z_SYNC_FLUSH here means that an unterminated
        * LZ stream (a stream with a missing end code) can still
        * be handled, otherwise (Z_NO_FLUSH) a future zlib
        * implementation might defer output and therefore
        * change the current behavior (see comments in inflate.c
        * for why this doesn't happen at present with zlib 1.2.5).
        */
       ret = inflate(&png_ptr->zstream, Z_SYNC_FLUSH);
 
       /* Check for any failure before proceeding. */
       if (ret != Z_OK && ret != Z_STREAM_END)
       {
          /* Terminate the decompression. */
          png_ptr->flags |= PNG_FLAG_ZSTREAM_ENDED;
          png_ptr->zowner = 0;
 
          /* This may be a truncated stream (missing or
           * damaged end code).  Treat that as a warning.
           */
          if (png_ptr->row_number >= png_ptr->num_rows ||
              png_ptr->pass > 6)
             png_warning(png_ptr, "Truncated compressed data in IDAT");
 
          else
             png_error(png_ptr, "Decompression error in IDAT");
 
          /* Skip the check on unprocessed input */
          return;
       }
 
       /* Did inflate output any data? */
       if (png_ptr->zstream.next_out != png_ptr->row_buf)
       {
          /* Is this unexpected data after the last row?
           * If it is, artificially terminate the LZ output
           * here.
           */
          if (png_ptr->row_number >= png_ptr->num_rows ||
              png_ptr->pass > 6)
          {
             /* Extra data. */
             png_warning(png_ptr, "Extra compressed data in IDAT");
             png_ptr->flags |= PNG_FLAG_ZSTREAM_ENDED;
             png_ptr->zowner = 0;
 
             /* Do no more processing; skip the unprocessed
              * input check below.
              */
             return;
          }
 
          /* Do we have a complete row? */
          if (png_ptr->zstream.avail_out == 0)
             png_push_process_row(png_ptr);
       }
 
       /* And check for the end of the stream. */
       if (ret == Z_STREAM_END)
          png_ptr->flags |= PNG_FLAG_ZSTREAM_ENDED;
    }
 
    /* All the data should have been processed, if anything
     * is left at this point we have bytes of IDAT data
     * after the zlib end code.
     */
    if (png_ptr->zstream.avail_in > 0)
       png_warning(png_ptr, "Extra compression data in IDAT");
 }

void png_push_process_row ( png_structrp png_ptr )

 {
    /* 1.5.6: row_info moved out of png_struct to a local here. */
    png_row_info row_info;
 
    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);
 
    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 row count:
     */
    memcpy(png_ptr->prev_row, png_ptr->row_buf, row_info.rowbytes + 1);
 
 #ifdef PNG_READ_TRANSFORMS_SUPPORTED
    if (png_ptr->transformations != 0)
       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, "progressive row overflow");
    }
 
    else if (png_ptr->transformed_pixel_depth != row_info.pixel_depth)
       png_error(png_ptr, "internal progressive 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);
 
       switch (png_ptr->pass)
       {
          case 0:
          {
             int i;
             for (i = 0; i < 8 && png_ptr->pass == 0; i++)
             {
                png_push_have_row(png_ptr, png_ptr->row_buf + 1);
                png_read_push_finish_row(png_ptr); /* Updates png_ptr->pass */
             }
 
             if (png_ptr->pass == 2) /* Pass 1 might be empty */
             {
                for (i = 0; i < 4 && png_ptr->pass == 2; i++)
                {
                   png_push_have_row(png_ptr, NULL);
                   png_read_push_finish_row(png_ptr);
                }
             }
 
             if (png_ptr->pass == 4 && png_ptr->height <= 4)
             {
                for (i = 0; i < 2 && png_ptr->pass == 4; i++)
                {
                   png_push_have_row(png_ptr, NULL);
                   png_read_push_finish_row(png_ptr);
                }
             }
 
             if (png_ptr->pass == 6 && png_ptr->height <= 4)
             {
                 png_push_have_row(png_ptr, NULL);
                 png_read_push_finish_row(png_ptr);
             }
 
             break;
          }
 
          case 1:
          {
             int i;
             for (i = 0; i < 8 && png_ptr->pass == 1; i++)
             {
                png_push_have_row(png_ptr, png_ptr->row_buf + 1);
                png_read_push_finish_row(png_ptr);
             }
 
             if (png_ptr->pass == 2) /* Skip top 4 generated rows */
             {
                for (i = 0; i < 4 && png_ptr->pass == 2; i++)
                {
                   png_push_have_row(png_ptr, NULL);
                   png_read_push_finish_row(png_ptr);
                }
             }
 
             break;
          }
 
          case 2:
          {
             int i;
 
             for (i = 0; i < 4 && png_ptr->pass == 2; i++)
             {
                png_push_have_row(png_ptr, png_ptr->row_buf + 1);
                png_read_push_finish_row(png_ptr);
             }
 
             for (i = 0; i < 4 && png_ptr->pass == 2; i++)
             {
                png_push_have_row(png_ptr, NULL);
                png_read_push_finish_row(png_ptr);
             }
 
             if (png_ptr->pass == 4) /* Pass 3 might be empty */
             {
                for (i = 0; i < 2 && png_ptr->pass == 4; i++)
                {
                   png_push_have_row(png_ptr, NULL);
                   png_read_push_finish_row(png_ptr);
                }
             }
 
             break;
          }
 
          case 3:
          {
             int i;
 
             for (i = 0; i < 4 && png_ptr->pass == 3; i++)
             {
                png_push_have_row(png_ptr, png_ptr->row_buf + 1);
                png_read_push_finish_row(png_ptr);
             }
 
             if (png_ptr->pass == 4) /* Skip top two generated rows */
             {
                for (i = 0; i < 2 && png_ptr->pass == 4; i++)
                {
                   png_push_have_row(png_ptr, NULL);
                   png_read_push_finish_row(png_ptr);
                }
             }
 
             break;
          }
 
          case 4:
          {
             int i;
 
             for (i = 0; i < 2 && png_ptr->pass == 4; i++)
             {
                png_push_have_row(png_ptr, png_ptr->row_buf + 1);
                png_read_push_finish_row(png_ptr);
             }
 
             for (i = 0; i < 2 && png_ptr->pass == 4; i++)
             {
                png_push_have_row(png_ptr, NULL);
                png_read_push_finish_row(png_ptr);
             }
 
             if (png_ptr->pass == 6) /* Pass 5 might be empty */
             {
                png_push_have_row(png_ptr, NULL);
                png_read_push_finish_row(png_ptr);
             }
 
             break;
          }
 
          case 5:
          {
             int i;
 
             for (i = 0; i < 2 && png_ptr->pass == 5; i++)
             {
                png_push_have_row(png_ptr, png_ptr->row_buf + 1);
                png_read_push_finish_row(png_ptr);
             }
 
             if (png_ptr->pass == 6) /* Skip top generated row */
             {
                png_push_have_row(png_ptr, NULL);
                png_read_push_finish_row(png_ptr);
             }
 
             break;
          }
 
          default:
          case 6:
          {
             png_push_have_row(png_ptr, png_ptr->row_buf + 1);
             png_read_push_finish_row(png_ptr);
 
             if (png_ptr->pass != 6)
                break;
 
             png_push_have_row(png_ptr, NULL);
             png_read_push_finish_row(png_ptr);
          }
       }
    }
    else
    {
       png_push_have_row(png_ptr, png_ptr->row_buf + 1);
       png_read_push_finish_row(png_ptr);
    }
 }

void png_push_handle_unknown	(	png_structrp	png_ptr,
		png_inforp	info_ptr,
		png_uint_32	length
	)

void png_push_have_info	(	png_structrp	png_ptr,
		png_inforp	info_ptr
	)

 {
    if (png_ptr->info_fn != NULL)
       (*(png_ptr->info_fn))(png_ptr, info_ptr);
 }

void png_push_have_end	(	png_structrp	png_ptr,
		png_inforp	info_ptr
	)

 {
    if (png_ptr->end_fn != NULL)
       (*(png_ptr->end_fn))(png_ptr, info_ptr);
 }

void png_push_have_row	(	png_structrp	png_ptr,
		png_bytep	row
	)

 {
    if (png_ptr->row_fn != NULL)
       (*(png_ptr->row_fn))(png_ptr, row, png_ptr->row_number,
          (int)png_ptr->pass);
 }

void png_push_read_end	(	png_structrp	png_ptr,
		png_inforp	info_ptr
	)

void png_process_some_data	(	png_structrp	png_ptr,
		png_inforp	info_ptr
	)

 {
    if (png_ptr == NULL)
       return;
 
    switch (png_ptr->process_mode)
    {
       case PNG_READ_SIG_MODE:
       {
          png_push_read_sig(png_ptr, info_ptr);
          break;
       }
 
       case PNG_READ_CHUNK_MODE:
       {
          png_push_read_chunk(png_ptr, info_ptr);
          break;
       }
 
       case PNG_READ_IDAT_MODE:
       {
          png_push_read_IDAT(png_ptr);
          break;
       }
 
       case PNG_SKIP_MODE:
       {
          png_push_crc_finish(png_ptr);
          break;
       }
 
       default:
       {
          png_ptr->buffer_size = 0;
          break;
       }
    }
 }

void png_read_push_finish_row ( png_structrp png_ptr )

 {
    /* Arrays to facilitate easy interlacing - use pass (0 - 6) as index */
 
    /* Start of interlace block */
    static PNG_CONST png_byte png_pass_start[] = {0, 4, 0, 2, 0, 1, 0};
 
    /* Offset to next interlace block */
    static PNG_CONST png_byte png_pass_inc[] = {8, 8, 4, 4, 2, 2, 1};
 
    /* Start of interlace block in the y direction */
    static PNG_CONST png_byte png_pass_ystart[] = {0, 0, 4, 0, 2, 0, 1};
 
    /* Offset to next interlace block in the y direction */
    static PNG_CONST png_byte png_pass_yinc[] = {8, 8, 8, 4, 4, 2, 2};
 
    /* Height of interlace block.  This is not currently used - if you need
     * it, uncomment it here and in png.h
    static PNG_CONST png_byte png_pass_height[] = {8, 8, 4, 4, 2, 2, 1};
    */
 #endif
 
    png_ptr->row_number++;
    if (png_ptr->row_number < png_ptr->num_rows)
       return;
 
    if (png_ptr->interlaced != 0)
    {
       png_ptr->row_number = 0;
       memset(png_ptr->prev_row, 0, png_ptr->rowbytes + 1);
 
       do
       {
          png_ptr->pass++;
          if ((png_ptr->pass == 1 && png_ptr->width < 5) ||
              (png_ptr->pass == 3 && png_ptr->width < 3) ||
              (png_ptr->pass == 5 && png_ptr->width < 2))
             png_ptr->pass++;
 
          if (png_ptr->pass > 7)
             png_ptr->pass--;
 
          if (png_ptr->pass >= 7)
             break;
 
          png_ptr->iwidth = (png_ptr->width +
              png_pass_inc[png_ptr->pass] - 1 -
              png_pass_start[png_ptr->pass]) /
              png_pass_inc[png_ptr->pass];
 
          if ((png_ptr->transformations & PNG_INTERLACE) != 0)
             break;
 
          png_ptr->num_rows = (png_ptr->height +
              png_pass_yinc[png_ptr->pass] - 1 -
              png_pass_ystart[png_ptr->pass]) /
              png_pass_yinc[png_ptr->pass];
 
       } while (png_ptr->iwidth == 0 || png_ptr->num_rows == 0);
    }
 }

void png_push_handle_tEXt	(	png_structrp	png_ptr,
		png_inforp	info_ptr,
		png_uint_32	length
	)

void png_push_read_tEXt	(	png_structrp	png_ptr,
		png_inforp	info_ptr
	)

void png_push_handle_zTXt	(	png_structrp	png_ptr,
		png_inforp	info_ptr,
		png_uint_32	length
	)

void png_push_read_zTXt	(	png_structrp	png_ptr,
		png_inforp	info_ptr
	)

void png_push_handle_iTXt	(	png_structrp	png_ptr,
		png_inforp	info_ptr,
		png_uint_32	length
	)

void png_push_read_iTXt	(	png_structrp	png_ptr,
		png_inforp	info_ptr
	)

void png_colorspace_set_gamma	(	png_const_structrp	png_ptr,
		png_colorspacerp	colorspace,
		png_fixed_point	gAMA
	)

 {
    /* Changed in libpng-1.5.4 to limit the values to ensure overflow can't
     * occur.  Since the fixed point representation is asymetrical it is
     * possible for 1/gamma to overflow the limit of 21474 and this means the
     * gamma value must be at least 5/100000 and hence at most 20000.0.  For
     * safety the limits here are a little narrower.  The values are 0.00016 to
     * 6250.0, which are truly ridiculous gamma values (and will produce
     * displays that are all black or all white.)
     *
     * In 1.6.0 this test replaces the ones in pngrutil.c, in the gAMA chunk
     * handling code, which only required the value to be >0.
     */
    png_const_charp errmsg;
 
    if (gAMA < 16 || gAMA > 625000000)
       errmsg = "gamma value out of range";
 
 #  ifdef PNG_READ_gAMA_SUPPORTED
       /* Allow the application to set the gamma value more than once */
       else if ((png_ptr->mode & PNG_IS_READ_STRUCT) != 0 &&
          (colorspace->flags & PNG_COLORSPACE_FROM_gAMA) != 0)
          errmsg = "duplicate";
 #  endif
 
    /* Do nothing if the colorspace is already invalid */
    else if ((colorspace->flags & PNG_COLORSPACE_INVALID) != 0)
       return;
 
    else
    {
       if (png_colorspace_check_gamma(png_ptr, colorspace, gAMA,
           1/*from gAMA*/) != 0)
       {
          /* Store this gamma value. */
          colorspace->gamma = gAMA;
          colorspace->flags |=
             (PNG_COLORSPACE_HAVE_GAMMA | PNG_COLORSPACE_FROM_gAMA);
       }
 
       /* At present if the check_gamma test fails the gamma of the colorspace is
        * not updated however the colorspace is not invalidated.  This
        * corresponds to the case where the existing gamma comes from an sRGB
        * chunk or profile.  An error message has already been output.
        */
       return;
    }
 
    /* Error exit - errmsg has been set. */
    colorspace->flags |= PNG_COLORSPACE_INVALID;
    png_chunk_report(png_ptr, errmsg, PNG_CHUNK_WRITE_ERROR);
 }

void png_colorspace_sync_info	(	png_const_structrp	png_ptr,
		png_inforp	info_ptr
	)

 {
    if ((info_ptr->colorspace.flags & PNG_COLORSPACE_INVALID) != 0)
    {
       /* Everything is invalid */
       info_ptr->valid &= ~(PNG_INFO_gAMA|PNG_INFO_cHRM|PNG_INFO_sRGB|
          PNG_INFO_iCCP);
 
 #     ifdef PNG_COLORSPACE_SUPPORTED
          /* Clean up the iCCP profile now if it won't be used. */
          png_free_data(png_ptr, info_ptr, PNG_FREE_ICCP, -1/*not used*/);
 #     else
          PNG_UNUSED(png_ptr)
 #     endif
    }
 
    else
    {
 #     ifdef PNG_COLORSPACE_SUPPORTED
          /* Leave the INFO_iCCP flag set if the pngset.c code has already set
           * it; this allows a PNG to contain a profile which matches sRGB and
           * yet still have that profile retrievable by the application.
           */
          if ((info_ptr->colorspace.flags & PNG_COLORSPACE_MATCHES_sRGB) != 0)
             info_ptr->valid |= PNG_INFO_sRGB;
 
          else
             info_ptr->valid &= ~PNG_INFO_sRGB;
 
          if ((info_ptr->colorspace.flags & PNG_COLORSPACE_HAVE_ENDPOINTS) != 0)
             info_ptr->valid |= PNG_INFO_cHRM;
 
          else
             info_ptr->valid &= ~PNG_INFO_cHRM;
 #     endif
 
       if ((info_ptr->colorspace.flags & PNG_COLORSPACE_HAVE_GAMMA) != 0)
          info_ptr->valid |= PNG_INFO_gAMA;
 
       else
          info_ptr->valid &= ~PNG_INFO_gAMA;
    }
 }

void png_colorspace_sync	(	png_const_structrp	png_ptr,
		png_inforp	info_ptr
	)

 {
    if (info_ptr == NULL) /* reduce code size; check here not in the caller */
       return;
 
    info_ptr->colorspace = png_ptr->colorspace;
    png_colorspace_sync_info(png_ptr, info_ptr);
 }

int png_colorspace_set_chromaticities	(	png_const_structrp	png_ptr,
		png_colorspacerp	colorspace,
		const png_xy *	xy,
		int	preferred
	)

 {
    /* We must check the end points to ensure they are reasonable - in the past
     * color management systems have crashed as a result of getting bogus
     * colorant values, while this isn't the fault of libpng it is the
     * responsibility of libpng because PNG carries the bomb and libpng is in a
     * position to protect against it.
     */
    png_XYZ XYZ;
 
    switch (png_colorspace_check_xy(&XYZ, xy))
    {
       case 0: /* success */
          return png_colorspace_set_xy_and_XYZ(png_ptr, colorspace, xy, &XYZ,
             preferred);
 
       case 1:
          /* We can't invert the chromaticities so we can't produce value XYZ
           * values.  Likely as not a color management system will fail too.
           */
          colorspace->flags |= PNG_COLORSPACE_INVALID;
          png_benign_error(png_ptr, "invalid chromaticities");
          break;
 
       default:
          /* libpng is broken; this should be a warning but if it happens we
           * want error reports so for the moment it is an error.
           */
          colorspace->flags |= PNG_COLORSPACE_INVALID;
          png_error(png_ptr, "internal error checking chromaticities");
          break;
    }
 
    return 0; /* failed */
 }

int png_colorspace_set_endpoints	(	png_const_structrp	png_ptr,
		png_colorspacerp	colorspace,
		const png_XYZ *	XYZ,
		int	preferred
	)

 {
    png_XYZ XYZ = *XYZ_in;
    png_xy xy;
 
    switch (png_colorspace_check_XYZ(&xy, &XYZ))
    {
       case 0:
          return png_colorspace_set_xy_and_XYZ(png_ptr, colorspace, &xy, &XYZ,
             preferred);
 
       case 1:
          /* End points are invalid. */
          colorspace->flags |= PNG_COLORSPACE_INVALID;
          png_benign_error(png_ptr, "invalid end points");
          break;
 
       default:
          colorspace->flags |= PNG_COLORSPACE_INVALID;
          png_error(png_ptr, "internal error checking chromaticities");
          break;
    }
 
    return 0; /* failed */
 }

int png_colorspace_set_sRGB	(	png_const_structrp	png_ptr,
		png_colorspacerp	colorspace,
		int	intent
	)

 {
    /* sRGB sets known gamma, end points and (from the chunk) intent. */
    /* IMPORTANT: these are not necessarily the values found in an ICC profile
     * because ICC profiles store values adapted to a D50 environment; it is
     * expected that the ICC profile mediaWhitePointTag will be D50; see the
     * checks and code elsewhere to understand this better.
     *
     * These XYZ values, which are accurate to 5dp, produce rgb to gray
     * coefficients of (6968,23435,2366), which are reduced (because they add up
     * to 32769 not 32768) to (6968,23434,2366).  These are the values that
     * libpng has traditionally used (and are the best values given the 15bit
     * algorithm used by the rgb to gray code.)
     */
    static const png_XYZ sRGB_XYZ = /* D65 XYZ (*not* the D50 adapted values!) */
    {
       /* color      X      Y      Z */
       /* red   */ 41239, 21264,  1933,
       /* green */ 35758, 71517, 11919,
       /* blue  */ 18048,  7219, 95053
    };
 
    /* Do nothing if the colorspace is already invalidated. */
    if ((colorspace->flags & PNG_COLORSPACE_INVALID) != 0)
       return 0;
 
    /* Check the intent, then check for existing settings.  It is valid for the
     * PNG file to have cHRM or gAMA chunks along with sRGB, but the values must
     * be consistent with the correct values.  If, however, this function is
     * called below because an iCCP chunk matches sRGB then it is quite
     * conceivable that an older app recorded incorrect gAMA and cHRM because of
     * an incorrect calculation based on the values in the profile - this does
     * *not* invalidate the profile (though it still produces an error, which can
     * be ignored.)
     */
    if (intent < 0 || intent >= PNG_sRGB_INTENT_LAST)
       return png_icc_profile_error(png_ptr, colorspace, "sRGB",
          (unsigned)intent, "invalid sRGB rendering intent");
 
    if ((colorspace->flags & PNG_COLORSPACE_HAVE_INTENT) != 0 &&
       colorspace->rendering_intent != intent)
       return png_icc_profile_error(png_ptr, colorspace, "sRGB",
          (unsigned)intent, "inconsistent rendering intents");
 
    if ((colorspace->flags & PNG_COLORSPACE_FROM_sRGB) != 0)
    {
       png_benign_error(png_ptr, "duplicate sRGB information ignored");
       return 0;
    }
 
    /* If the standard sRGB cHRM chunk does not match the one from the PNG file
     * warn but overwrite the value with the correct one.
     */
    if ((colorspace->flags & PNG_COLORSPACE_HAVE_ENDPOINTS) != 0 &&
       !png_colorspace_endpoints_match(&sRGB_xy, &colorspace->end_points_xy,
          100))
       png_chunk_report(png_ptr, "cHRM chunk does not match sRGB",
          PNG_CHUNK_ERROR);
 
    /* This check is just done for the error reporting - the routine always
     * returns true when the 'from' argument corresponds to sRGB (2).
     */
    (void)png_colorspace_check_gamma(png_ptr, colorspace, PNG_GAMMA_sRGB_INVERSE,
       2/*from sRGB*/);
 
    /* intent: bugs in GCC force 'int' to be used as the parameter type. */
    colorspace->rendering_intent = (png_uint_16)intent;
    colorspace->flags |= PNG_COLORSPACE_HAVE_INTENT;
 
    /* endpoints */
    colorspace->end_points_xy = sRGB_xy;
    colorspace->end_points_XYZ = sRGB_XYZ;
    colorspace->flags |=
       (PNG_COLORSPACE_HAVE_ENDPOINTS|PNG_COLORSPACE_ENDPOINTS_MATCH_sRGB);
 
    /* gamma */
    colorspace->gamma = PNG_GAMMA_sRGB_INVERSE;
    colorspace->flags |= PNG_COLORSPACE_HAVE_GAMMA;
 
    /* Finally record that we have an sRGB profile */
    colorspace->flags |=
       (PNG_COLORSPACE_MATCHES_sRGB|PNG_COLORSPACE_FROM_sRGB);
 
    return 1; /* set */
 }

int png_colorspace_set_ICC	(	png_const_structrp	png_ptr,
		png_colorspacerp	colorspace,
		png_const_charp	name,
		png_uint_32	profile_length,
		png_const_bytep	profile,
		int	color_type
	)

 {
    if ((colorspace->flags & PNG_COLORSPACE_INVALID) != 0)
       return 0;
 
    if (png_icc_check_length(png_ptr, colorspace, name, profile_length) != 0 &&
        png_icc_check_header(png_ptr, colorspace, name, profile_length, profile,
           color_type) != 0 &&
        png_icc_check_tag_table(png_ptr, colorspace, name, profile_length,
           profile) != 0)
    {
 #     ifdef PNG_sRGB_SUPPORTED
          /* If no sRGB support, don't try storing sRGB information */
          png_icc_set_sRGB(png_ptr, colorspace, profile, 0);
 #     endif
       return 1;
    }
 
    /* Failure case */
    return 0;
 }

int png_icc_check_length	(	png_const_structrp	png_ptr,
		png_colorspacerp	colorspace,
		png_const_charp	name,
		png_uint_32	profile_length
	)

 {
    if (profile_length < 132)
       return png_icc_profile_error(png_ptr, colorspace, name, profile_length,
          "too short");
 
    return 1;
 }

int png_icc_check_header	(	png_const_structrp	png_ptr,
		png_colorspacerp	colorspace,
		png_const_charp	name,
		png_uint_32	profile_length,
		png_const_bytep	profile,
		int	color_type
	)

 {
    png_uint_32 temp;
 
    /* Length check; this cannot be ignored in this code because profile_length
     * is used later to check the tag table, so even if the profile seems over
     * long profile_length from the caller must be correct.  The caller can fix
     * this up on read or write by just passing in the profile header length.
     */
    temp = png_get_uint_32(profile);
    if (temp != profile_length)
       return png_icc_profile_error(png_ptr, colorspace, name, temp,
          "length does not match profile");
 
    temp = (png_uint_32) (*(profile+8));
    if (temp > 3 && (profile_length & 3))
       return png_icc_profile_error(png_ptr, colorspace, name, profile_length,
          "invalid length");
 
    temp = png_get_uint_32(profile+128); /* tag count: 12 bytes/tag */
    if (temp > 357913930 || /* (2^32-4-132)/12: maximum possible tag count */
       profile_length < 132+12*temp) /* truncated tag table */
       return png_icc_profile_error(png_ptr, colorspace, name, temp,
          "tag count too large");
 
    /* The 'intent' must be valid or we can't store it, ICC limits the intent to
     * 16 bits.
     */
    temp = png_get_uint_32(profile+64);
    if (temp >= 0xffff) /* The ICC limit */
       return png_icc_profile_error(png_ptr, colorspace, name, temp,
          "invalid rendering intent");
 
    /* This is just a warning because the profile may be valid in future
     * versions.
     */
    if (temp >= PNG_sRGB_INTENT_LAST)
       (void)png_icc_profile_error(png_ptr, NULL, name, temp,
          "intent outside defined range");
 
    /* At this point the tag table can't be checked because it hasn't necessarily
     * been loaded; however, various header fields can be checked.  These checks
     * are for values permitted by the PNG spec in an ICC profile; the PNG spec
     * restricts the profiles that can be passed in an iCCP chunk (they must be
     * appropriate to processing PNG data!)
     */
 
    /* Data checks (could be skipped).  These checks must be independent of the
     * version number; however, the version number doesn't accomodate changes in
     * the header fields (just the known tags and the interpretation of the
     * data.)
     */
    temp = png_get_uint_32(profile+36); /* signature 'ascp' */
    if (temp != 0x61637370)
       return png_icc_profile_error(png_ptr, colorspace, name, temp,
          "invalid signature");
 
    /* Currently the PCS illuminant/adopted white point (the computational
     * white point) are required to be D50,
     * however the profile contains a record of the illuminant so perhaps ICC
     * expects to be able to change this in the future (despite the rationale in
     * the introduction for using a fixed PCS adopted white.)  Consequently the
     * following is just a warning.
     */
    if (memcmp(profile+68, D50_nCIEXYZ, 12) != 0)
       (void)png_icc_profile_error(png_ptr, NULL, name, 0/*no tag value*/,
          "PCS illuminant is not D50");
 
    /* The PNG spec requires this:
     * "If the iCCP chunk is present, the image samples conform to the colour
     * space represented by the embedded ICC profile as defined by the
     * International Color Consortium [ICC]. The colour space of the ICC profile
     * shall be an RGB colour space for colour images (PNG colour types 2, 3, and
     * 6), or a greyscale colour space for greyscale images (PNG colour types 0
     * and 4)."
     *
     * This checking code ensures the embedded profile (on either read or write)
     * conforms to the specification requirements.  Notice that an ICC 'gray'
     * color-space profile contains the information to transform the monochrome
     * data to XYZ or L*a*b (according to which PCS the profile uses) and this
     * should be used in preference to the standard libpng K channel replication
     * into R, G and B channels.
     *
     * Previously it was suggested that an RGB profile on grayscale data could be
     * handled.  However it it is clear that using an RGB profile in this context
     * must be an error - there is no specification of what it means.  Thus it is
     * almost certainly more correct to ignore the profile.
     */
    temp = png_get_uint_32(profile+16); /* data colour space field */
    switch (temp)
    {
       case 0x52474220: /* 'RGB ' */
          if ((color_type & PNG_COLOR_MASK_COLOR) == 0)
             return png_icc_profile_error(png_ptr, colorspace, name, temp,
                "RGB color space not permitted on grayscale PNG");
          break;
 
       case 0x47524159: /* 'GRAY' */
          if ((color_type & PNG_COLOR_MASK_COLOR) != 0)
             return png_icc_profile_error(png_ptr, colorspace, name, temp,
                "Gray color space not permitted on RGB PNG");
          break;
 
       default:
          return png_icc_profile_error(png_ptr, colorspace, name, temp,
             "invalid ICC profile color space");
    }
 
    /* It is up to the application to check that the profile class matches the
     * application requirements; the spec provides no guidance, but it's pretty
     * weird if the profile is not scanner ('scnr'), monitor ('mntr'), printer
     * ('prtr') or 'spac' (for generic color spaces).  Issue a warning in these
     * cases.  Issue an error for device link or abstract profiles - these don't
     * contain the records necessary to transform the color-space to anything
     * other than the target device (and not even that for an abstract profile).
     * Profiles of these classes may not be embedded in images.
     */
    temp = png_get_uint_32(profile+12); /* profile/device class */
    switch (temp)
    {
       case 0x73636E72: /* 'scnr' */
       case 0x6D6E7472: /* 'mntr' */
       case 0x70727472: /* 'prtr' */
       case 0x73706163: /* 'spac' */
          /* All supported */
          break;
 
       case 0x61627374: /* 'abst' */
          /* May not be embedded in an image */
          return png_icc_profile_error(png_ptr, colorspace, name, temp,
             "invalid embedded Abstract ICC profile");
 
       case 0x6C696E6B: /* 'link' */
          /* DeviceLink profiles cannot be interpreted in a non-device specific
           * fashion, if an app uses the AToB0Tag in the profile the results are
           * undefined unless the result is sent to the intended device,
           * therefore a DeviceLink profile should not be found embedded in a
           * PNG.
           */
          return png_icc_profile_error(png_ptr, colorspace, name, temp,
             "unexpected DeviceLink ICC profile class");
 
       case 0x6E6D636C: /* 'nmcl' */
          /* A NamedColor profile is also device specific, however it doesn't
           * contain an AToB0 tag that is open to misinterpretation.  Almost
           * certainly it will fail the tests below.
           */
          (void)png_icc_profile_error(png_ptr, NULL, name, temp,
             "unexpected NamedColor ICC profile class");
          break;
 
       default:
          /* To allow for future enhancements to the profile accept unrecognized
           * profile classes with a warning, these then hit the test below on the
           * tag content to ensure they are backward compatible with one of the
           * understood profiles.
           */
          (void)png_icc_profile_error(png_ptr, NULL, name, temp,
             "unrecognized ICC profile class");
          break;
    }
 
    /* For any profile other than a device link one the PCS must be encoded
     * either in XYZ or Lab.
     */
    temp = png_get_uint_32(profile+20);
    switch (temp)
    {
       case 0x58595A20: /* 'XYZ ' */
       case 0x4C616220: /* 'Lab ' */
          break;
 
       default:
          return png_icc_profile_error(png_ptr, colorspace, name, temp,
             "unexpected ICC PCS encoding");
    }
 
    return 1;
 }

int png_icc_check_tag_table	(	png_const_structrp	png_ptr,
		png_colorspacerp	colorspace,
		png_const_charp	name,
		png_uint_32	profile_length,
		png_const_bytep	profile
	)

 {
    png_uint_32 tag_count = png_get_uint_32(profile+128);
    png_uint_32 itag;
    png_const_bytep tag = profile+132; /* The first tag */
 
    /* First scan all the tags in the table and add bits to the icc_info value
     * (temporarily in 'tags').
     */
    for (itag=0; itag < tag_count; ++itag, tag += 12)
    {
       png_uint_32 tag_id = png_get_uint_32(tag+0);
       png_uint_32 tag_start = png_get_uint_32(tag+4); /* must be aligned */
       png_uint_32 tag_length = png_get_uint_32(tag+8);/* not padded */
 
       /* The ICC specification does not exclude zero length tags, therefore the
        * start might actually be anywhere if there is no data, but this would be
        * a clear abuse of the intent of the standard so the start is checked for
        * being in range.  All defined tag types have an 8 byte header - a 4 byte
        * type signature then 0.
        */
       if ((tag_start & 3) != 0)
       {
          /* CNHP730S.icc shipped with Microsoft Windows 64 violates this, it is
           * only a warning here because libpng does not care about the
           * alignment.
           */
          (void)png_icc_profile_error(png_ptr, NULL, name, tag_id,
             "ICC profile tag start not a multiple of 4");
       }
 
       /* This is a hard error; potentially it can cause read outside the
        * profile.
        */
       if (tag_start > profile_length || tag_length > profile_length - tag_start)
          return png_icc_profile_error(png_ptr, colorspace, name, tag_id,
             "ICC profile tag outside profile");
    }
 
    return 1; /* success, maybe with warnings */
 }

void png_icc_set_sRGB	(	png_const_structrp	png_ptr,
		png_colorspacerp	colorspace,
		png_const_bytep	profile,
		uLong	adler
	)

 {
    /* Is this profile one of the known ICC sRGB profiles?  If it is, just set
     * the sRGB information.
     */
 #if PNG_sRGB_PROFILE_CHECKS >= 0
    if (png_compare_ICC_profile_with_sRGB(png_ptr, profile, adler) != 0)
 #endif
       (void)png_colorspace_set_sRGB(png_ptr, colorspace,
          (int)/*already checked*/png_get_uint_32(profile+64));
 }

void png_colorspace_set_rgb_coefficients ( png_structrp png_ptr )

 {
    /* Set the rgb_to_gray coefficients from the colorspace. */
    if (png_ptr->rgb_to_gray_coefficients_set == 0 &&
       (png_ptr->colorspace.flags & PNG_COLORSPACE_HAVE_ENDPOINTS) != 0)
    {
       /* png_set_background has not been called, get the coefficients from the Y
        * values of the colorspace colorants.
        */
       png_fixed_point r = png_ptr->colorspace.end_points_XYZ.red_Y;
       png_fixed_point g = png_ptr->colorspace.end_points_XYZ.green_Y;
       png_fixed_point b = png_ptr->colorspace.end_points_XYZ.blue_Y;
       png_fixed_point total = r+g+b;
 
       if (total > 0 &&
          r >= 0 && png_muldiv(&r, r, 32768, total) && r >= 0 && r <= 32768 &&
          g >= 0 && png_muldiv(&g, g, 32768, total) && g >= 0 && g <= 32768 &&
          b >= 0 && png_muldiv(&b, b, 32768, total) && b >= 0 && b <= 32768 &&
          r+g+b <= 32769)
       {
          /* We allow 0 coefficients here.  r+g+b may be 32769 if two or
           * all of the coefficients were rounded up.  Handle this by
           * reducing the *largest* coefficient by 1; this matches the
           * approach used for the default coefficients in pngrtran.c
           */
          int add = 0;
 
          if (r+g+b > 32768)
             add = -1;
          else if (r+g+b < 32768)
             add = 1;
 
          if (add != 0)
          {
             if (g >= r && g >= b)
                g += add;
             else if (r >= g && r >= b)
                r += add;
             else
                b += add;
          }
 
          /* Check for an internal error. */
          if (r+g+b != 32768)
             png_error(png_ptr,
                "internal error handling cHRM coefficients");
 
          else
          {
             png_ptr->rgb_to_gray_red_coeff   = (png_uint_16)r;
             png_ptr->rgb_to_gray_green_coeff = (png_uint_16)g;
          }
       }
 
       /* This is a png_error at present even though it could be ignored -
        * it should never happen, but it is important that if it does, the
        * bug is fixed.
        */
       else
          png_error(png_ptr, "internal error handling cHRM->XYZ");
    }
 }

void png_check_IHDR	(	png_const_structrp	png_ptr,
		png_uint_32	width,
		png_uint_32	height,
		int	bit_depth,
		int	color_type,
		int	interlace_type,
		int	compression_type,
		int	filter_type
	)

 {
    int error = 0;
 
    /* Check for width and height valid values */
    if (width == 0)
    {
       png_warning(png_ptr, "Image width is zero in IHDR");
       error = 1;
    }
    else if (width > PNG_UINT_31_MAX)
    {
       png_warning(png_ptr, "Invalid image width in IHDR");
       error = 1;
    }
 
    else if (png_gt(width,
                    (PNG_SIZE_MAX >> 3) /* 8-byte RGBA pixels */
                    - 48                /* big_row_buf hack */
                    - 1                 /* filter byte */
                    - 7*8               /* rounding width to multiple of 8 pix */
                    - 8))               /* extra max_pixel_depth pad */
    {
       /* The size of the row must be within the limits of this architecture.
        * Because the read code can perform arbitrary transformations the
        * maximum size is checked here.  Because the code in png_read_start_row
        * adds extra space "for safety's sake" in several places a conservative
        * limit is used here.
        *
        * NOTE: it would be far better to check the size that is actually used,
        * but the effect in the real world is minor and the changes are more
        * extensive, therefore much more dangerous and much more difficult to
        * write in a way that avoids compiler warnings.
        */
       png_warning(png_ptr, "Image width is too large for this architecture");
       error = 1;
    }
    else
    {
 #     ifdef PNG_SET_USER_LIMITS_SUPPORTED
       if (width > png_ptr->user_width_max)
 #     else
       if (width > PNG_USER_WIDTH_MAX)
 #     endif
       {
          png_warning(png_ptr, "Image width exceeds user limit in IHDR");
          error = 1;
       }
    }
 
    if (height == 0)
    {
       png_warning(png_ptr, "Image height is zero in IHDR");
       error = 1;
    }
    else if (height > PNG_UINT_31_MAX)
    {
       png_warning(png_ptr, "Invalid image height in IHDR");
       error = 1;
    }
    else
    {
 #     ifdef PNG_SET_USER_LIMITS_SUPPORTED
       if (height > png_ptr->user_height_max)
 #     else
       if (height > PNG_USER_HEIGHT_MAX)
 #     endif
       {
          png_warning(png_ptr, "Image height exceeds user limit in IHDR");
          error = 1;
       }
    }
 
    /* Check other values */
    if (bit_depth != 1 && bit_depth != 2 && bit_depth != 4 &&
        bit_depth != 8 && bit_depth != 16)
    {
       png_warning(png_ptr, "Invalid bit depth in IHDR");
       error = 1;
    }
 
    if (color_type < 0 || color_type == 1 ||
        color_type == 5 || color_type > 6)
    {
       png_warning(png_ptr, "Invalid color type in IHDR");
       error = 1;
    }
 
    if (((color_type == PNG_COLOR_TYPE_PALETTE) && bit_depth > 8) ||
        ((color_type == PNG_COLOR_TYPE_RGB ||
          color_type == PNG_COLOR_TYPE_GRAY_ALPHA ||
          color_type == PNG_COLOR_TYPE_RGB_ALPHA) && bit_depth < 8))
    {
       png_warning(png_ptr, "Invalid color type/bit depth combination in IHDR");
       error = 1;
    }
 
    if (interlace_type >= PNG_INTERLACE_LAST)
    {
       png_warning(png_ptr, "Unknown interlace method in IHDR");
       error = 1;
    }
 
    if (compression_type != PNG_COMPRESSION_TYPE_BASE)
    {
       png_warning(png_ptr, "Unknown compression method in IHDR");
       error = 1;
    }
 
 #  ifdef PNG_MNG_FEATURES_SUPPORTED
    /* Accept filter_method 64 (intrapixel differencing) only if
     * 1. Libpng was compiled with PNG_MNG_FEATURES_SUPPORTED and
     * 2. Libpng did not read 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->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");
 
    if (filter_type != PNG_FILTER_TYPE_BASE)
    {
       if (!((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) != 0 &&
           (filter_type == PNG_INTRAPIXEL_DIFFERENCING) &&
           ((png_ptr->mode & PNG_HAVE_PNG_SIGNATURE) == 0) &&
           (color_type == PNG_COLOR_TYPE_RGB ||
           color_type == PNG_COLOR_TYPE_RGB_ALPHA)))
       {
          png_warning(png_ptr, "Unknown filter method in IHDR");
          error = 1;
       }
 
       if ((png_ptr->mode & PNG_HAVE_PNG_SIGNATURE) != 0)
       {
          png_warning(png_ptr, "Invalid filter method in IHDR");
          error = 1;
       }
    }
 
 #  else
    if (filter_type != PNG_FILTER_TYPE_BASE)
    {
       png_warning(png_ptr, "Unknown filter method in IHDR");
       error = 1;
    }
 #  endif
 
    if (error == 1)
       png_error(png_ptr, "Invalid IHDR data");
 }

void png_do_check_palette_indexes	(	png_structrp	png_ptr,
		png_row_infop	row_info
	)

 {
    if (png_ptr->num_palette < (1 << row_info->bit_depth) &&
       png_ptr->num_palette > 0) /* num_palette can be 0 in MNG files */
    {
       /* Calculations moved outside switch in an attempt to stop different
        * compiler warnings.  'padding' is in *bits* within the last byte, it is
        * an 'int' because pixel_depth becomes an 'int' in the expression below,
        * and this calculation is used because it avoids warnings that other
        * forms produced on either GCC or MSVC.
        */
       int padding = (-row_info->pixel_depth * row_info->width) & 7;
       png_bytep rp = png_ptr->row_buf + row_info->rowbytes;
 
       switch (row_info->bit_depth)
       {
          case 1:
          {
             /* in this case, all bytes must be 0 so we don't need
              * to unpack the pixels except for the rightmost one.
              */
             for (; rp > png_ptr->row_buf; rp--)
             {
               if (*rp >> padding != 0)
                  png_ptr->num_palette_max = 1;
               padding = 0;
             }
 
             break;
          }
 
          case 2:
          {
             for (; rp > png_ptr->row_buf; rp--)
             {
               int i = ((*rp >> padding) & 0x03);
 
               if (i > png_ptr->num_palette_max)
                  png_ptr->num_palette_max = i;
 
               i = (((*rp >> padding) >> 2) & 0x03);
 
               if (i > png_ptr->num_palette_max)
                  png_ptr->num_palette_max = i;
 
               i = (((*rp >> padding) >> 4) & 0x03);
 
               if (i > png_ptr->num_palette_max)
                  png_ptr->num_palette_max = i;
 
               i = (((*rp >> padding) >> 6) & 0x03);
 
               if (i > png_ptr->num_palette_max)
                  png_ptr->num_palette_max = i;
 
               padding = 0;
             }
 
             break;
          }
 
          case 4:
          {
             for (; rp > png_ptr->row_buf; rp--)
             {
               int i = ((*rp >> padding) & 0x0f);
 
               if (i > png_ptr->num_palette_max)
                  png_ptr->num_palette_max = i;
 
               i = (((*rp >> padding) >> 4) & 0x0f);
 
               if (i > png_ptr->num_palette_max)
                  png_ptr->num_palette_max = i;
 
               padding = 0;
             }
 
             break;
          }
 
          case 8:
          {
             for (; rp > png_ptr->row_buf; rp--)
             {
                if (*rp > png_ptr->num_palette_max)
                   png_ptr->num_palette_max = (int) *rp;
             }
 
             break;
          }
 
          default:
             break;
       }
    }
 }

void png_fixed_error	(	png_const_structrp	png_ptr,
		png_const_charp	name
	)

 {
 #  define fixed_message "fixed point overflow in "
 #  define fixed_message_ln ((sizeof fixed_message)-1)
    int  iin;
    char msg[fixed_message_ln+PNG_MAX_ERROR_TEXT];
    memcpy(msg, fixed_message, fixed_message_ln);
    iin = 0;
    if (name != NULL)
       while (iin < (PNG_MAX_ERROR_TEXT-1) && name[iin] != 0)
       {
          msg[fixed_message_ln + iin] = name[iin];
          ++iin;
       }
    msg[fixed_message_ln + iin] = 0;
    png_error(png_ptr, msg);
 }

size_t png_safecat	(	png_charp	buffer,
		size_t	bufsize,
		size_t	pos,
		png_const_charp	string
	)

 {
    if (buffer != NULL && pos < bufsize)
    {
       if (string != NULL)
          while (*string != '\0' && pos < bufsize-1)
            buffer[pos++] = *string++;
 
       buffer[pos] = '\0';
    }
 
    return pos;
 }

png_charp png_format_number	(	png_const_charp	start,
		png_charp	end,
		int	format,
		png_alloc_size_t	number
	)

 {
    int count = 0;    /* number of digits output */
    int mincount = 1; /* minimum number required */
    int output = 0;   /* digit output (for the fixed point format) */
 
    *--end = '\0';
 
    /* This is written so that the loop always runs at least once, even with
     * number zero.
     */
    while (end > start && (number != 0 || count < mincount))
    {
 
       static const char digits[] = "0123456789ABCDEF";
 
       switch (format)
       {
          case PNG_NUMBER_FORMAT_fixed:
             /* Needs five digits (the fraction) */
             mincount = 5;
             if (output != 0 || number % 10 != 0)
             {
                *--end = digits[number % 10];
                output = 1;
             }
             number /= 10;
             break;
 
          case PNG_NUMBER_FORMAT_02u:
             /* Expects at least 2 digits. */
             mincount = 2;
             /* FALL THROUGH */
 
          case PNG_NUMBER_FORMAT_u:
             *--end = digits[number % 10];
             number /= 10;
             break;
 
          case PNG_NUMBER_FORMAT_02x:
             /* This format expects at least two digits */
             mincount = 2;
             /* FALL THROUGH */
 
          case PNG_NUMBER_FORMAT_x:
             *--end = digits[number & 0xf];
             number >>= 4;
             break;
 
          default: /* an error */
             number = 0;
             break;
       }
 
       /* Keep track of the number of digits added */
       ++count;
 
       /* Float a fixed number here: */
       if ((format == PNG_NUMBER_FORMAT_fixed) && (count == 5) && (end > start))
       {
          /* End of the fraction, but maybe nothing was output?  In that case
           * drop the decimal point.  If the number is a true zero handle that
           * here.
           */
          if (output != 0)
             *--end = '.';
          else if (number == 0) /* and !output */
             *--end = '0';
       }
    }
 
    return end;
 }

void png_warning_parameter	(	png_warning_parameters	p,
		int	number,
		png_const_charp	string
	)

 {
    if (number > 0 && number <= PNG_WARNING_PARAMETER_COUNT)
       (void)png_safecat(p[number-1], (sizeof p[number-1]), 0, string);
 }

void png_warning_parameter_unsigned	(	png_warning_parameters	p,
		int	number,
		int	format,
		png_alloc_size_t	value
	)

 {
    char buffer[PNG_NUMBER_BUFFER_SIZE];
    png_warning_parameter(p, number, PNG_FORMAT_NUMBER(buffer, format, value));
 }

void png_warning_parameter_signed	(	png_warning_parameters	p,
		int	number,
		int	format,
		png_int_32	value
	)

 {
    png_alloc_size_t u;
    png_charp str;
    char buffer[PNG_NUMBER_BUFFER_SIZE];
 
    /* Avoid overflow by doing the negate in a png_alloc_size_t: */
    u = (png_alloc_size_t)value;
    if (value < 0)
       u = ~u + 1;
 
    str = PNG_FORMAT_NUMBER(buffer, format, u);
 
    if (value < 0 && str > buffer)
       *--str = '-';
 
    png_warning_parameter(p, number, str);
 }

void png_formatted_warning	(	png_const_structrp	png_ptr,
		png_warning_parameters	p,
		png_const_charp	message
	)

 {
    /* The internal buffer is just 192 bytes - enough for all our messages,
     * overflow doesn't happen because this code checks!  If someone figures
     * out how to send us a message longer than 192 bytes, all that will
     * happen is that the message will be truncated appropriately.
     */
    size_t i = 0; /* Index in the msg[] buffer: */
    char msg[192];
 
    /* Each iteration through the following loop writes at most one character
     * to msg[i++] then returns here to validate that there is still space for
     * the trailing '\0'.  It may (in the case of a parameter) read more than
     * one character from message[]; it must check for '\0' and continue to the
     * test if it finds the end of string.
     */
    while (i<(sizeof msg)-1 && *message != '\0')
    {
       /* '@' at end of string is now just printed (previously it was skipped);
        * it is an error in the calling code to terminate the string with @.
        */
       if (p != NULL && *message == '@' && message[1] != '\0')
       {
          int parameter_char = *++message; /* Consume the '@' */
          static const char valid_parameters[] = "123456789";
          int parameter = 0;
 
          /* Search for the parameter digit, the index in the string is the
           * parameter to use.
           */
          while (valid_parameters[parameter] != parameter_char &&
             valid_parameters[parameter] != '\0')
             ++parameter;
 
          /* If the parameter digit is out of range it will just get printed. */
          if (parameter < PNG_WARNING_PARAMETER_COUNT)
          {
             /* Append this parameter */
             png_const_charp parm = p[parameter];
             png_const_charp pend = p[parameter] + (sizeof p[parameter]);
 
             /* No need to copy the trailing '\0' here, but there is no guarantee
              * that parm[] has been initialized, so there is no guarantee of a
              * trailing '\0':
              */
             while (i<(sizeof msg)-1 && *parm != '\0' && parm < pend)
                msg[i++] = *parm++;
 
             /* Consume the parameter digit too: */
             ++message;
             continue;
          }
 
          /* else not a parameter and there is a character after the @ sign; just
           * copy that.  This is known not to be '\0' because of the test above.
           */
       }
 
       /* At this point *message can't be '\0', even in the bad parameter case
        * above where there is a lone '@' at the end of the message string.
        */
       msg[i++] = *message++;
    }
 
    /* i is always less than (sizeof msg), so: */
    msg[i] = '\0';
 
    /* And this is the formatted message. It may be larger than
     * PNG_MAX_ERROR_TEXT, but that is only used for 'chunk' errors and these
     * are not (currently) formatted.
     */
    png_warning(png_ptr, msg);
 }

void png_app_warning	(	png_const_structrp	png_ptr,
		png_const_charp	message
	)

 {
   if ((png_ptr->flags & PNG_FLAG_APP_WARNINGS_WARN) != 0)
      png_warning(png_ptr, error_message);
   else
      png_error(png_ptr, error_message);
 
 #  ifndef PNG_ERROR_TEXT_SUPPORTED
       PNG_UNUSED(error_message)
 #  endif
 }

void png_app_error	(	png_const_structrp	png_ptr,
		png_const_charp	message
	)

 {
   if ((png_ptr->flags & PNG_FLAG_APP_ERRORS_WARN) != 0)
      png_warning(png_ptr, error_message);
   else
      png_error(png_ptr, error_message);
 
 #  ifndef PNG_ERROR_TEXT_SUPPORTED
       PNG_UNUSED(error_message)
 #  endif
 }

void png_chunk_report	(	png_const_structrp	png_ptr,
		png_const_charp	message,
		int	error
	)

 {
 #  ifndef PNG_WARNINGS_SUPPORTED
       PNG_UNUSED(message)
 #  endif
 
    /* This is always supported, but for just read or just write it
     * unconditionally does the right thing.
     */
 #  if defined(PNG_READ_SUPPORTED) && defined(PNG_WRITE_SUPPORTED)
       if ((png_ptr->mode & PNG_IS_READ_STRUCT) != 0)
 #  endif
 
 #  ifdef PNG_READ_SUPPORTED
       {
          if (error < PNG_CHUNK_ERROR)
             png_chunk_warning(png_ptr, message);
 
          else
             png_chunk_benign_error(png_ptr, message);
       }
 #  endif
 
 #  if defined(PNG_READ_SUPPORTED) && defined(PNG_WRITE_SUPPORTED)
       else if ((png_ptr->mode & PNG_IS_READ_STRUCT) == 0)
 #  endif
 
 #  ifdef PNG_WRITE_SUPPORTED
       {
          if (error < PNG_CHUNK_WRITE_ERROR)
             png_app_warning(png_ptr, message);
 
          else
             png_app_error(png_ptr, message);
       }
 #  endif
 }

void png_ascii_from_fp	(	png_const_structrp	png_ptr,
		png_charp	ascii,
		png_size_t	size,
		double	fp,
		unsigned int	precision
	)

 {
    /* We use standard functions from math.h, but not printf because
     * that would require stdio.  The caller must supply a buffer of
     * sufficient size or we will png_error.  The tests on size and
     * the space in ascii[] consumed are indicated below.
     */
    if (precision < 1)
       precision = DBL_DIG;
 
    /* Enforce the limit of the implementation precision too. */
    if (precision > DBL_DIG+1)
       precision = DBL_DIG+1;
 
    /* Basic sanity checks */
    if (size >= precision+5) /* See the requirements below. */
    {
       if (fp < 0)
       {
          fp = -fp;
          *ascii++ = 45; /* '-'  PLUS 1 TOTAL 1 */
          --size;
       }
 
       if (fp >= DBL_MIN && fp <= DBL_MAX)
       {
          int exp_b10;       /* A base 10 exponent */
          double base;   /* 10^exp_b10 */
 
          /* First extract a base 10 exponent of the number,
           * the calculation below rounds down when converting
           * from base 2 to base 10 (multiply by log10(2) -
           * 0.3010, but 77/256 is 0.3008, so exp_b10 needs to
           * be increased.  Note that the arithmetic shift
           * performs a floor() unlike C arithmetic - using a
           * C multiply would break the following for negative
           * exponents.
           */
          (void)frexp(fp, &exp_b10); /* exponent to base 2 */
 
          exp_b10 = (exp_b10 * 77) >> 8; /* <= exponent to base 10 */
 
          /* Avoid underflow here. */
          base = png_pow10(exp_b10); /* May underflow */
 
          while (base < DBL_MIN || base < fp)
          {
             /* And this may overflow. */
             double test = png_pow10(exp_b10+1);
 
             if (test <= DBL_MAX)
                ++exp_b10, base = test;
 
             else
                break;
          }
 
          /* Normalize fp and correct exp_b10, after this fp is in the
           * range [.1,1) and exp_b10 is both the exponent and the digit
           * *before* which the decimal point should be inserted
           * (starting with 0 for the first digit).  Note that this
           * works even if 10^exp_b10 is out of range because of the
           * test on DBL_MAX above.
           */
          fp /= base;
          while (fp >= 1) fp /= 10, ++exp_b10;
 
          /* Because of the code above fp may, at this point, be
           * less than .1, this is ok because the code below can
           * handle the leading zeros this generates, so no attempt
           * is made to correct that here.
           */
 
          {
             int czero, clead, cdigits;
             char exponent[10];
 
             /* Allow up to two leading zeros - this will not lengthen
              * the number compared to using E-n.
              */
             if (exp_b10 < 0 && exp_b10 > -3) /* PLUS 3 TOTAL 4 */
             {
                czero = -exp_b10; /* PLUS 2 digits: TOTAL 3 */
                exp_b10 = 0;      /* Dot added below before first output. */
             }
             else
                czero = 0;    /* No zeros to add */
 
             /* Generate the digit list, stripping trailing zeros and
              * inserting a '.' before a digit if the exponent is 0.
              */
             clead = czero; /* Count of leading zeros */
             cdigits = 0;   /* Count of digits in list. */
 
             do
             {
                double d;
 
                fp *= 10;
                /* Use modf here, not floor and subtract, so that
                 * the separation is done in one step.  At the end
                 * of the loop don't break the number into parts so
                 * that the final digit is rounded.
                 */
                if (cdigits+czero-clead+1 < (int)precision)
                   fp = modf(fp, &d);
 
                else
                {
                   d = floor(fp + .5);
 
                   if (d > 9)
                   {
                      /* Rounding up to 10, handle that here. */
                      if (czero > 0)
                      {
                         --czero, d = 1;
                         if (cdigits == 0) --clead;
                      }
                      else
                      {
                         while (cdigits > 0 && d > 9)
                         {
                            int ch = *--ascii;
 
                            if (exp_b10 != (-1))
                               ++exp_b10;
 
                            else if (ch == 46)
                            {
                               ch = *--ascii, ++size;
                               /* Advance exp_b10 to '1', so that the
                                * decimal point happens after the
                                * previous digit.
                                */
                               exp_b10 = 1;
                            }
 
                            --cdigits;
                            d = ch - 47;  /* I.e. 1+(ch-48) */
                         }
 
                         /* Did we reach the beginning? If so adjust the
                          * exponent but take into account the leading
                          * decimal point.
                          */
                         if (d > 9)  /* cdigits == 0 */
                         {
                            if (exp_b10 == (-1))
                            {
                               /* Leading decimal point (plus zeros?), if
                                * we lose the decimal point here it must
                                * be reentered below.
                                */
                               int ch = *--ascii;
 
                               if (ch == 46)
                                  ++size, exp_b10 = 1;
 
                               /* Else lost a leading zero, so 'exp_b10' is
                                * still ok at (-1)
                                */
                            }
                            else
                               ++exp_b10;
 
                            /* In all cases we output a '1' */
                            d = 1;
                         }
                      }
                   }
                   fp = 0; /* Guarantees termination below. */
                }
 
                if (d == 0)
                {
                   ++czero;
                   if (cdigits == 0) ++clead;
                }
                else
                {
                   /* Included embedded zeros in the digit count. */
                   cdigits += czero - clead;
                   clead = 0;
 
                   while (czero > 0)
                   {
                      /* exp_b10 == (-1) means we just output the decimal
                       * place - after the DP don't adjust 'exp_b10' any
                       * more!
                       */
                      if (exp_b10 != (-1))
                      {
                         if (exp_b10 == 0) *ascii++ = 46, --size;
                         /* PLUS 1: TOTAL 4 */
                         --exp_b10;
                      }
                      *ascii++ = 48, --czero;
                   }
 
                   if (exp_b10 != (-1))
                   {
                      if (exp_b10 == 0)
                         *ascii++ = 46, --size; /* counted above */
 
                      --exp_b10;
                   }
                   *ascii++ = (char)(48 + (int)d), ++cdigits;
                }
             }
             while (cdigits+czero-clead < (int)precision && fp > DBL_MIN);
 
             /* The total output count (max) is now 4+precision */
 
             /* Check for an exponent, if we don't need one we are
              * done and just need to terminate the string.  At
              * this point exp_b10==(-1) is effectively if flag - it got
              * to '-1' because of the decrement after outputing
              * the decimal point above (the exponent required is
              * *not* -1!)
              */
             if (exp_b10 >= (-1) && exp_b10 <= 2)
             {
                /* The following only happens if we didn't output the
                 * leading zeros above for negative exponent, so this
                 * doest add to the digit requirement.  Note that the
                 * two zeros here can only be output if the two leading
                 * zeros were *not* output, so this doesn't increase
                 * the output count.
                 */
                while (--exp_b10 >= 0) *ascii++ = 48;
 
                *ascii = 0;
 
                /* Total buffer requirement (including the '\0') is
                 * 5+precision - see check at the start.
                 */
                return;
             }
 
             /* Here if an exponent is required, adjust size for
              * the digits we output but did not count.  The total
              * digit output here so far is at most 1+precision - no
              * decimal point and no leading or trailing zeros have
              * been output.
              */
             size -= cdigits;
 
             *ascii++ = 69, --size;    /* 'E': PLUS 1 TOTAL 2+precision */
 
             /* The following use of an unsigned temporary avoids ambiguities in
              * the signed arithmetic on exp_b10 and permits GCC at least to do
              * better optimization.
              */
             {
                unsigned int uexp_b10;
 
                if (exp_b10 < 0)
                {
                   *ascii++ = 45, --size; /* '-': PLUS 1 TOTAL 3+precision */
                   uexp_b10 = -exp_b10;
                }
 
                else
                   uexp_b10 = exp_b10;
 
                cdigits = 0;
 
                while (uexp_b10 > 0)
                {
                   exponent[cdigits++] = (char)(48 + uexp_b10 % 10);
                   uexp_b10 /= 10;
                }
             }
 
             /* Need another size check here for the exponent digits, so
              * this need not be considered above.
              */
             if ((int)size > cdigits)
             {
                while (cdigits > 0) *ascii++ = exponent[--cdigits];
 
                *ascii = 0;
 
                return;
             }
          }
       }
       else if (!(fp >= DBL_MIN))
       {
          *ascii++ = 48; /* '0' */
          *ascii = 0;
          return;
       }
       else
       {
          *ascii++ = 105; /* 'i' */
          *ascii++ = 110; /* 'n' */
          *ascii++ = 102; /* 'f' */
          *ascii = 0;
          return;
       }
    }
 
    /* Here on buffer too small. */
    png_error(png_ptr, "ASCII conversion buffer too small");
 }

void png_ascii_from_fixed	(	png_const_structrp	png_ptr,
		png_charp	ascii,
		png_size_t	size,
		png_fixed_point	fp
	)

 {
    /* Require space for 10 decimal digits, a decimal point, a minus sign and a
     * trailing \0, 13 characters:
     */
    if (size > 12)
    {
       png_uint_32 num;
 
       /* Avoid overflow here on the minimum integer. */
       if (fp < 0)
          *ascii++ = 45, --size, num = -fp;
       else
          num = fp;
 
       if (num <= 0x80000000) /* else overflowed */
       {
          unsigned int ndigits = 0, first = 16 /* flag value */;
          char digits[10];
 
          while (num)
          {
             /* Split the low digit off num: */
             unsigned int tmp = num/10;
             num -= tmp*10;
             digits[ndigits++] = (char)(48 + num);
             /* Record the first non-zero digit, note that this is a number
              * starting at 1, it's not actually the array index.
              */
             if (first == 16 && num > 0)
                first = ndigits;
             num = tmp;
          }
 
          if (ndigits > 0)
          {
             while (ndigits > 5) *ascii++ = digits[--ndigits];
             /* The remaining digits are fractional digits, ndigits is '5' or
              * smaller at this point.  It is certainly not zero.  Check for a
              * non-zero fractional digit:
              */
             if (first <= 5)
             {
                unsigned int i;
                *ascii++ = 46; /* decimal point */
                /* ndigits may be <5 for small numbers, output leading zeros
                 * then ndigits digits to first:
                 */
                i = 5;
                while (ndigits < i) *ascii++ = 48, --i;
                while (ndigits >= first) *ascii++ = digits[--ndigits];
                /* Don't output the trailing zeros! */
             }
          }
          else
             *ascii++ = 48;
 
          /* And null terminate the string: */
          *ascii = 0;
          return;
       }
    }
 
    /* Here on buffer too small. */
    png_error(png_ptr, "ASCII conversion buffer too small");
 }

int png_check_fp_number	(	png_const_charp	string,
		png_size_t	size,
		int *	statep,
		png_size_tp	whereami
	)

 {
    int state = *statep;
    png_size_t i = *whereami;
 
    while (i < size)
    {
       int type;
       /* First find the type of the next character */
       switch (string[i])
       {
       case 43:  type = PNG_FP_SAW_SIGN;                   break;
       case 45:  type = PNG_FP_SAW_SIGN + PNG_FP_NEGATIVE; break;
       case 46:  type = PNG_FP_SAW_DOT;                    break;
       case 48:  type = PNG_FP_SAW_DIGIT;                  break;
       case 49: case 50: case 51: case 52:
       case 53: case 54: case 55: case 56:
       case 57:  type = PNG_FP_SAW_DIGIT + PNG_FP_NONZERO; break;
       case 69:
       case 101: type = PNG_FP_SAW_E;                      break;
       default:  goto PNG_FP_End;
       }
 
       /* Now deal with this type according to the current
        * state, the type is arranged to not overlap the
        * bits of the PNG_FP_STATE.
        */
       switch ((state & PNG_FP_STATE) + (type & PNG_FP_SAW_ANY))
       {
       case PNG_FP_INTEGER + PNG_FP_SAW_SIGN:
          if ((state & PNG_FP_SAW_ANY) != 0)
             goto PNG_FP_End; /* not a part of the number */
 
          png_fp_add(state, type);
          break;
 
       case PNG_FP_INTEGER + PNG_FP_SAW_DOT:
          /* Ok as trailer, ok as lead of fraction. */
          if ((state & PNG_FP_SAW_DOT) != 0) /* two dots */
             goto PNG_FP_End;
 
          else if ((state & PNG_FP_SAW_DIGIT) != 0) /* trailing dot? */
             png_fp_add(state, type);
 
          else
             png_fp_set(state, PNG_FP_FRACTION | type);
 
          break;
 
       case PNG_FP_INTEGER + PNG_FP_SAW_DIGIT:
          if ((state & PNG_FP_SAW_DOT) != 0) /* delayed fraction */
             png_fp_set(state, PNG_FP_FRACTION | PNG_FP_SAW_DOT);
 
          png_fp_add(state, type | PNG_FP_WAS_VALID);
 
          break;
 
       case PNG_FP_INTEGER + PNG_FP_SAW_E:
          if ((state & PNG_FP_SAW_DIGIT) == 0)
             goto PNG_FP_End;
 
          png_fp_set(state, PNG_FP_EXPONENT);
 
          break;
 
    /* case PNG_FP_FRACTION + PNG_FP_SAW_SIGN:
          goto PNG_FP_End; ** no sign in fraction */
 
    /* case PNG_FP_FRACTION + PNG_FP_SAW_DOT:
          goto PNG_FP_End; ** Because SAW_DOT is always set */
 
       case PNG_FP_FRACTION + PNG_FP_SAW_DIGIT:
          png_fp_add(state, type | PNG_FP_WAS_VALID);
          break;
 
       case PNG_FP_FRACTION + PNG_FP_SAW_E:
          /* This is correct because the trailing '.' on an
           * integer is handled above - so we can only get here
           * with the sequence ".E" (with no preceding digits).
           */
          if ((state & PNG_FP_SAW_DIGIT) == 0)
             goto PNG_FP_End;
 
          png_fp_set(state, PNG_FP_EXPONENT);
 
          break;
 
       case PNG_FP_EXPONENT + PNG_FP_SAW_SIGN:
          if ((state & PNG_FP_SAW_ANY) != 0)
             goto PNG_FP_End; /* not a part of the number */
 
          png_fp_add(state, PNG_FP_SAW_SIGN);
 
          break;
 
    /* case PNG_FP_EXPONENT + PNG_FP_SAW_DOT:
          goto PNG_FP_End; */
 
       case PNG_FP_EXPONENT + PNG_FP_SAW_DIGIT:
          png_fp_add(state, PNG_FP_SAW_DIGIT | PNG_FP_WAS_VALID);
 
          break;
 
    /* case PNG_FP_EXPONEXT + PNG_FP_SAW_E:
          goto PNG_FP_End; */
 
       default: goto PNG_FP_End; /* I.e. break 2 */
       }
 
       /* The character seems ok, continue. */
       ++i;
    }
 
 PNG_FP_End:
    /* Here at the end, update the state and return the correct
     * return code.
     */
    *statep = state;
    *whereami = i;
 
    return (state & PNG_FP_SAW_DIGIT) != 0;
 }

int png_check_fp_string	(	png_const_charp	string,
		png_size_t	size
	)

 {
    int        state=0;
    png_size_t char_index=0;
 
    if (png_check_fp_number(string, size, &state, &char_index) != 0 &&
       (char_index == size || string[char_index] == 0))
       return state /* must be non-zero - see above */;
 
    return 0; /* i.e. fail */
 }

int png_muldiv	(	png_fixed_point_p	res,
		png_fixed_point	a,
		png_int_32	multiplied_by,
		png_int_32	divided_by
	)

 {
    /* Return a * times / divisor, rounded. */
    if (divisor != 0)
    {
       if (a == 0 || times == 0)
       {
          *res = 0;
          return 1;
       }
       else
       {
 #ifdef PNG_FLOATING_ARITHMETIC_SUPPORTED
          double r = a;
          r *= times;
          r /= divisor;
          r = floor(r+.5);
 
          /* A png_fixed_point is a 32-bit integer. */
          if (r <= 2147483647. && r >= -2147483648.)
          {
             *res = (png_fixed_point)r;
             return 1;
          }
 #else
          int negative = 0;
          png_uint_32 A, T, D;
          png_uint_32 s16, s32, s00;
 
          if (a < 0)
             negative = 1, A = -a;
          else
             A = a;
 
          if (times < 0)
             negative = !negative, T = -times;
          else
             T = times;
 
          if (divisor < 0)
             negative = !negative, D = -divisor;
          else
             D = divisor;
 
          /* Following can't overflow because the arguments only
           * have 31 bits each, however the result may be 32 bits.
           */
          s16 = (A >> 16) * (T & 0xffff) +
                            (A & 0xffff) * (T >> 16);
          /* Can't overflow because the a*times bit is only 30
           * bits at most.
           */
          s32 = (A >> 16) * (T >> 16) + (s16 >> 16);
          s00 = (A & 0xffff) * (T & 0xffff);
 
          s16 = (s16 & 0xffff) << 16;
          s00 += s16;
 
          if (s00 < s16)
             ++s32; /* carry */
 
          if (s32 < D) /* else overflow */
          {
             /* s32.s00 is now the 64-bit product, do a standard
              * division, we know that s32 < D, so the maximum
              * required shift is 31.
              */
             int bitshift = 32;
             png_fixed_point result = 0; /* NOTE: signed */
 
             while (--bitshift >= 0)
             {
                png_uint_32 d32, d00;
 
                if (bitshift > 0)
                   d32 = D >> (32-bitshift), d00 = D << bitshift;
 
                else
                   d32 = 0, d00 = D;
 
                if (s32 > d32)
                {
                   if (s00 < d00) --s32; /* carry */
                   s32 -= d32, s00 -= d00, result += 1<<bitshift;
                }
 
                else
                   if (s32 == d32 && s00 >= d00)
                      s32 = 0, s00 -= d00, result += 1<<bitshift;
             }
 
             /* Handle the rounding. */
             if (s00 >= (D >> 1))
                ++result;
 
             if (negative != 0)
                result = -result;
 
             /* Check for overflow. */
             if ((negative != 0 && result <= 0) ||
                 (negative == 0 && result >= 0))
             {
                *res = result;
                return 1;
             }
          }
 #endif
       }
    }
 
    return 0;
 }

png_fixed_point png_muldiv_warn	(	png_const_structrp	png_ptr,
		png_fixed_point	a,
		png_int_32	multiplied_by,
		png_int_32	divided_by
	)

 {
    png_fixed_point result;
 
    if (png_muldiv(&result, a, times, divisor) != 0)
       return result;
 
    png_warning(png_ptr, "fixed point overflow ignored");
    return 0;
 }

png_fixed_point png_reciprocal ( png_fixed_point a )

 {
 #ifdef PNG_FLOATING_ARITHMETIC_SUPPORTED
    double r = floor(1E10/a+.5);
 
    if (r <= 2147483647. && r >= -2147483648.)
       return (png_fixed_point)r;
 #else
    png_fixed_point res;
 
    if (png_muldiv(&res, 100000, 100000, a) != 0)
       return res;
 #endif
 
    return 0; /* error/overflow */
 }

png_fixed_point png_reciprocal2	(	png_fixed_point	a,
		png_fixed_point	b
	)

 {
    /* The required result is 1/a * 1/b; the following preserves accuracy. */
 #ifdef PNG_FLOATING_ARITHMETIC_SUPPORTED
    double r = 1E15/a;
    r /= b;
    r = floor(r+.5);
 
    if (r <= 2147483647. && r >= -2147483648.)
       return (png_fixed_point)r;
 #else
    /* This may overflow because the range of png_fixed_point isn't symmetric,
     * but this API is only used for the product of file and screen gamma so it
     * doesn't matter that the smallest number it can produce is 1/21474, not
     * 1/100000
     */
    png_fixed_point res = png_product2(a, b);
 
    if (res != 0)
       return png_reciprocal(res);
 #endif
 
    return 0; /* overflow */
 }

int png_gamma_significant ( png_fixed_point gamma_value )

 {
    return gamma_val < PNG_FP_1 - PNG_GAMMA_THRESHOLD_FIXED ||
        gamma_val > PNG_FP_1 + PNG_GAMMA_THRESHOLD_FIXED;
 }

png_uint_16 png_gamma_correct	(	png_structrp	png_ptr,
		unsigned int	value,
		png_fixed_point	gamma_value
	)

 {
    if (png_ptr->bit_depth == 8)
       return png_gamma_8bit_correct(value, gamma_val);
 
 #ifdef PNG_16BIT_SUPPORTED
    else
       return png_gamma_16bit_correct(value, gamma_val);
 #else
       /* should not reach this */
       return 0;
 #endif /* 16BIT */
 }

png_uint_16 png_gamma_16bit_correct	(	unsigned int	value,
		png_fixed_point	gamma_value
	)

 {
    if (value > 0 && value < 65535)
    {
 #     ifdef PNG_FLOATING_ARITHMETIC_SUPPORTED
          /* The same (unsigned int)->(double) constraints apply here as above,
           * however in this case the (unsigned int) to (int) conversion can
           * overflow on an ANSI-C90 compliant system so the cast needs to ensure
           * that this is not possible.
           */
          double r = floor(65535*pow((png_int_32)value/65535.,
                      gamma_val*.00001)+.5);
          return (png_uint_16)r;
 #     else
          png_int_32 lg2 = png_log16bit(value);
          png_fixed_point res;
 
          if (png_muldiv(&res, gamma_val, lg2, PNG_FP_1) != 0)
             return png_exp16bit(res);
 
          /* Overflow. */
          value = 0;
 #     endif
    }
 
    return (png_uint_16)value;
 }

png_byte png_gamma_8bit_correct	(	unsigned int	value,
		png_fixed_point	gamma_value
	)

 {
    if (value > 0 && value < 255)
    {
 #     ifdef PNG_FLOATING_ARITHMETIC_SUPPORTED
          /* 'value' is unsigned, ANSI-C90 requires the compiler to correctly
           * convert this to a floating point value.  This includes values that
           * would overflow if 'value' were to be converted to 'int'.
           *
           * Apparently GCC, however, does an intermediate conversion to (int)
           * on some (ARM) but not all (x86) platforms, possibly because of
           * hardware FP limitations.  (E.g. if the hardware conversion always
           * assumes the integer register contains a signed value.)  This results
           * in ANSI-C undefined behavior for large values.
           *
           * Other implementations on the same machine might actually be ANSI-C90
           * conformant and therefore compile spurious extra code for the large
           * values.
           *
           * We can be reasonably sure that an unsigned to float conversion
           * won't be faster than an int to float one.  Therefore this code
           * assumes responsibility for the undefined behavior, which it knows
           * can't happen because of the check above.
           *
           * Note the argument to this routine is an (unsigned int) because, on
           * 16-bit platforms, it is assigned a value which might be out of
           * range for an (int); that would result in undefined behavior in the
           * caller if the *argument* ('value') were to be declared (int).
           */
          double r = floor(255*pow((int)/*SAFE*/value/255.,gamma_val*.00001)+.5);
          return (png_byte)r;
 #     else
          png_int_32 lg2 = png_log8bit(value);
          png_fixed_point res;
 
          if (png_muldiv(&res, gamma_val, lg2, PNG_FP_1) != 0)
             return png_exp8bit(res);
 
          /* Overflow. */
          value = 0;
 #     endif
    }
 
    return (png_byte)value;
 }

void png_destroy_gamma_table ( png_structrp png_ptr )

 {
    png_free(png_ptr, png_ptr->gamma_table);
    png_ptr->gamma_table = NULL;
 
 #ifdef PNG_16BIT_SUPPORTED
    if (png_ptr->gamma_16_table != NULL)
    {
       int i;
       int istop = (1 << (8 - png_ptr->gamma_shift));
       for (i = 0; i < istop; i++)
       {
          png_free(png_ptr, png_ptr->gamma_16_table[i]);
       }
    png_free(png_ptr, png_ptr->gamma_16_table);
    png_ptr->gamma_16_table = NULL;
    }
 #endif /* 16BIT */
 
 #if defined(PNG_READ_BACKGROUND_SUPPORTED) || \
    defined(PNG_READ_ALPHA_MODE_SUPPORTED) || \
    defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)
    png_free(png_ptr, png_ptr->gamma_from_1);
    png_ptr->gamma_from_1 = NULL;
    png_free(png_ptr, png_ptr->gamma_to_1);
    png_ptr->gamma_to_1 = NULL;
 
 #ifdef PNG_16BIT_SUPPORTED
    if (png_ptr->gamma_16_from_1 != NULL)
    {
       int i;
       int istop = (1 << (8 - png_ptr->gamma_shift));
       for (i = 0; i < istop; i++)
       {
          png_free(png_ptr, png_ptr->gamma_16_from_1[i]);
       }
    png_free(png_ptr, png_ptr->gamma_16_from_1);
    png_ptr->gamma_16_from_1 = NULL;
    }
    if (png_ptr->gamma_16_to_1 != NULL)
    {
       int i;
       int istop = (1 << (8 - png_ptr->gamma_shift));
       for (i = 0; i < istop; i++)
       {
          png_free(png_ptr, png_ptr->gamma_16_to_1[i]);
       }
    png_free(png_ptr, png_ptr->gamma_16_to_1);
    png_ptr->gamma_16_to_1 = NULL;
    }
 #endif /* 16BIT */
 #endif /* READ_BACKGROUND || READ_ALPHA_MODE || RGB_TO_GRAY */
 }

void png_build_gamma_table	(	png_structrp	png_ptr,
		int	bit_depth
	)

 {
   png_debug(1, "in png_build_gamma_table");
 
   /* Remove any existing table; this copes with multiple calls to
    * png_read_update_info.  The warning is because building the gamma tables
    * multiple times is a performance hit - it's harmless but the ability to call
    * png_read_update_info() multiple times is new in 1.5.6 so it seems sensible
    * to warn if the app introduces such a hit.
    */
   if (png_ptr->gamma_table != NULL || png_ptr->gamma_16_table != NULL)
   {
     png_warning(png_ptr, "gamma table being rebuilt");
     png_destroy_gamma_table(png_ptr);
   }
 
   if (bit_depth <= 8)
   {
      png_build_8bit_table(png_ptr, &png_ptr->gamma_table,
          png_ptr->screen_gamma > 0 ?  png_reciprocal2(png_ptr->colorspace.gamma,
          png_ptr->screen_gamma) : PNG_FP_1);
 
 #if defined(PNG_READ_BACKGROUND_SUPPORTED) || \
    defined(PNG_READ_ALPHA_MODE_SUPPORTED) || \
    defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)
      if ((png_ptr->transformations & (PNG_COMPOSE | PNG_RGB_TO_GRAY)) != 0)
      {
         png_build_8bit_table(png_ptr, &png_ptr->gamma_to_1,
             png_reciprocal(png_ptr->colorspace.gamma));
 
         png_build_8bit_table(png_ptr, &png_ptr->gamma_from_1,
             png_ptr->screen_gamma > 0 ?  png_reciprocal(png_ptr->screen_gamma) :
             png_ptr->colorspace.gamma/* Probably doing rgb_to_gray */);
      }
 #endif /* READ_BACKGROUND || READ_ALPHA_MODE || RGB_TO_GRAY */
   }
 #ifdef PNG_16BIT_SUPPORTED
   else
   {
      png_byte shift, sig_bit;
 
      if ((png_ptr->color_type & PNG_COLOR_MASK_COLOR) != 0)
      {
         sig_bit = png_ptr->sig_bit.red;
 
         if (png_ptr->sig_bit.green > sig_bit)
            sig_bit = png_ptr->sig_bit.green;
 
         if (png_ptr->sig_bit.blue > sig_bit)
            sig_bit = png_ptr->sig_bit.blue;
      }
      else
         sig_bit = png_ptr->sig_bit.gray;
 
      /* 16-bit gamma code uses this equation:
       *
       *   ov = table[(iv & 0xff) >> gamma_shift][iv >> 8]
       *
       * Where 'iv' is the input color value and 'ov' is the output value -
       * pow(iv, gamma).
       *
       * Thus the gamma table consists of up to 256 256-entry tables.  The table
       * is selected by the (8-gamma_shift) most significant of the low 8 bits of
       * the color value then indexed by the upper 8 bits:
       *
       *   table[low bits][high 8 bits]
       *
       * So the table 'n' corresponds to all those 'iv' of:
       *
       *   <all high 8-bit values><n << gamma_shift>..<(n+1 << gamma_shift)-1>
       *
       */
      if (sig_bit > 0 && sig_bit < 16U)
         shift = (png_byte)(16U - sig_bit); /* shift == insignificant bits */
 
      else
         shift = 0; /* keep all 16 bits */
 
      if ((png_ptr->transformations & (PNG_16_TO_8 | PNG_SCALE_16_TO_8)) != 0)
      {
         /* PNG_MAX_GAMMA_8 is the number of bits to keep - effectively
          * the significant bits in the *input* when the output will
          * eventually be 8 bits.  By default it is 11.
          */
         if (shift < (16U - PNG_MAX_GAMMA_8))
            shift = (16U - PNG_MAX_GAMMA_8);
      }
 
      if (shift > 8U)
         shift = 8U; /* Guarantees at least one table! */
 
      png_ptr->gamma_shift = shift;
 
      /* NOTE: prior to 1.5.4 this test used to include PNG_BACKGROUND (now
       * PNG_COMPOSE).  This effectively smashed the background calculation for
       * 16-bit output because the 8-bit table assumes the result will be reduced
       * to 8 bits.
       */
      if ((png_ptr->transformations & (PNG_16_TO_8 | PNG_SCALE_16_TO_8)) != 0)
          png_build_16to8_table(png_ptr, &png_ptr->gamma_16_table, shift,
          png_ptr->screen_gamma > 0 ? png_product2(png_ptr->colorspace.gamma,
          png_ptr->screen_gamma) : PNG_FP_1);
 
      else
          png_build_16bit_table(png_ptr, &png_ptr->gamma_16_table, shift,
          png_ptr->screen_gamma > 0 ? png_reciprocal2(png_ptr->colorspace.gamma,
          png_ptr->screen_gamma) : PNG_FP_1);
 
 #if defined(PNG_READ_BACKGROUND_SUPPORTED) || \
    defined(PNG_READ_ALPHA_MODE_SUPPORTED) || \
    defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)
      if ((png_ptr->transformations & (PNG_COMPOSE | PNG_RGB_TO_GRAY)) != 0)
      {
         png_build_16bit_table(png_ptr, &png_ptr->gamma_16_to_1, shift,
             png_reciprocal(png_ptr->colorspace.gamma));
 
         /* Notice that the '16 from 1' table should be full precision, however
          * the lookup on this table still uses gamma_shift, so it can't be.
          * TODO: fix this.
          */
         png_build_16bit_table(png_ptr, &png_ptr->gamma_16_from_1, shift,
             png_ptr->screen_gamma > 0 ? png_reciprocal(png_ptr->screen_gamma) :
             png_ptr->colorspace.gamma/* Probably doing rgb_to_gray */);
      }
 #endif /* READ_BACKGROUND || READ_ALPHA_MODE || RGB_TO_GRAY */
   }
 #endif /* 16BIT */
 }

void() png_safe_error	(	png_structp	png_ptr,
		png_const_charp	error_message
	)

 {
    const png_const_structrp png_ptr = png_nonconst_ptr;
    png_imagep image = png_voidcast(png_imagep, png_ptr->error_ptr);
 
    /* An error is always logged here, overwriting anything (typically a warning)
     * that is already there:
     */
    if (image != NULL)
    {
       png_safecat(image->message, (sizeof image->message), 0, error_message);
       image->warning_or_error |= PNG_IMAGE_ERROR;
 
       /* Retrieve the jmp_buf from within the png_control, making this work for
        * C++ compilation too is pretty tricky: C++ wants a pointer to the first
        * element of a jmp_buf, but C doesn't tell us the type of that.
        */
       if (image->opaque != NULL && image->opaque->error_buf != NULL)
          longjmp(png_control_jmp_buf(image->opaque), 1);
 
       /* Missing longjmp buffer, the following is to help debugging: */
       {
          size_t pos = png_safecat(image->message, (sizeof image->message), 0,
             "bad longjmp: ");
          png_safecat(image->message, (sizeof image->message), pos,
              error_message);
       }
    }
 
    /* Here on an internal programming error. */
    abort();
 }

void() png_safe_warning	(	png_structp	png_ptr,
		png_const_charp	warning_message
	)

 {
    const png_const_structrp png_ptr = png_nonconst_ptr;
    png_imagep image = png_voidcast(png_imagep, png_ptr->error_ptr);
 
    /* A warning is only logged if there is no prior warning or error. */
    if (image->warning_or_error == 0)
    {
       png_safecat(image->message, (sizeof image->message), 0, warning_message);
       image->warning_or_error |= PNG_IMAGE_WARNING;
    }
 }

int png_safe_execute	(	png_imagep	image,
		int(*)(png_voidp)	function,
		png_voidp	arg
	)

 {
    volatile png_imagep image = image_in;
    volatile int result;
    volatile png_voidp saved_error_buf;
    jmp_buf safe_jmpbuf;
 
    /* Safely execute function(arg) with png_error returning to this function. */
    saved_error_buf = image->opaque->error_buf;
    result = setjmp(safe_jmpbuf) == 0;
 
    if (result != 0)
    {
 
       image->opaque->error_buf = safe_jmpbuf;
       result = function(arg);
    }
 
    image->opaque->error_buf = saved_error_buf;
 
    /* And do the cleanup prior to any failure return. */
    if (result == 0)
       png_image_free(image);
 
    return result;
 }

int png_image_error	(	png_imagep	image,
		png_const_charp	error_message
	)

 {
    /* Utility to log an error. */
    png_safecat(image->message, (sizeof image->message), 0, error_message);
    image->warning_or_error |= PNG_IMAGE_ERROR;
    png_image_free(image);
    return 0;
 }

void png_init_filter_functions_neon	(	png_structp	png_ptr,
		unsigned int	bpp
	)

Variable Documentation

const png_uint_16 png_sRGB_table[256]

const png_uint_16 png_sRGB_base[512]

const png_byte png_sRGB_delta[512]

Classes

Macros

Typedefs

Functions

Variables

Macro Definition Documentation

Typedef Documentation

Function Documentation

Variable Documentation