upgrade to tcl/tk 8.6.8

1 files changed, 0 insertions, 3563 deletions

diff --git a/tk8.6/generic/tkImgPNG.c b/tk8.6/generic/tkImgPNG.c
deleted file mode 100644
index 6e64afa..0000000
--- a/tk8.6/generic/tkImgPNG.c
+++ /dev/null
@@ -1,3563 +0,0 @@
-/*
- * tkImgPNG.c --
- *
- *	A Tk photo image file handler for PNG files.
- *
- * Copyright (c) 2006-2008 Muonics, Inc.
- * Copyright (c) 2008 Donal K. Fellows
- *
- * See the file "license.terms" for information on usage and redistribution of
- * this file, and for a DISCLAIMER OF ALL WARRANTIES.
- */
-
-#include "assert.h"
-#include "tkInt.h"
-
-#define	PNG_INT32(a,b,c,d)	\
-	(((long)(a) << 24) | ((long)(b) << 16) | ((long)(c) << 8) | (long)(d))
-#define	PNG_BLOCK_SZ	1024		/* Process up to 1k at a time. */
-#define PNG_MIN(a, b) (((a) < (b)) ? (a) : (b))
-
-/*
- * Every PNG image starts with the following 8-byte signature.
- */
-
-#define PNG_SIG_SZ	8
-static const unsigned char pngSignature[] = {
-    137, 80, 78, 71, 13, 10, 26, 10
-};
-
-static const int startLine[8] = {
-    0, 0, 0, 4, 0, 2, 0, 1
-};
-
-/*
- * Chunk type flags.
- */
-
-#define PNG_CF_ANCILLARY 0x10000000L	/* Non-critical chunk (can ignore). */
-#define PNG_CF_PRIVATE   0x00100000L	/* Application-specific chunk. */
-#define PNG_CF_RESERVED  0x00001000L	/* Not used. */
-#define PNG_CF_COPYSAFE  0x00000010L	/* Opaque data safe for copying. */
-
-/*
- * Chunk types, not all of which have support implemented. Note that there are
- * others in the official extension set which we will never support (as they
- * are officially deprecated).
- */
-
-#define CHUNK_IDAT	PNG_INT32('I','D','A','T')	/* Pixel data. */
-#define CHUNK_IEND	PNG_INT32('I','E','N','D')	/* End of Image. */
-#define CHUNK_IHDR	PNG_INT32('I','H','D','R')	/* Header. */
-#define CHUNK_PLTE	PNG_INT32('P','L','T','E')	/* Palette. */
-
-#define CHUNK_bKGD	PNG_INT32('b','K','G','D')	/* Background Color */
-#define CHUNK_cHRM	PNG_INT32('c','H','R','M')	/* Chroma values. */
-#define CHUNK_gAMA	PNG_INT32('g','A','M','A')	/* Gamma. */
-#define CHUNK_hIST	PNG_INT32('h','I','S','T')	/* Histogram. */
-#define CHUNK_iCCP	PNG_INT32('i','C','C','P')	/* Color profile. */
-#define CHUNK_iTXt	PNG_INT32('i','T','X','t')	/* Internationalized
-							 * text (comments,
-							 * etc.) */
-#define CHUNK_oFFs	PNG_INT32('o','F','F','s')	/* Image offset. */
-#define CHUNK_pCAL	PNG_INT32('p','C','A','L')	/* Pixel calibration
-							 * data. */
-#define CHUNK_pHYs	PNG_INT32('p','H','Y','s')	/* Physical pixel
-							 * dimensions. */
-#define CHUNK_sBIT	PNG_INT32('s','B','I','T')	/* Significant bits */
-#define CHUNK_sCAL	PNG_INT32('s','C','A','L')	/* Physical scale. */
-#define CHUNK_sPLT	PNG_INT32('s','P','L','T')	/* Suggested
-							 * palette. */
-#define CHUNK_sRGB	PNG_INT32('s','R','G','B')	/* Standard RGB space
-							 * declaration. */
-#define CHUNK_tEXt	PNG_INT32('t','E','X','t')	/* Plain Latin-1
-							 * text. */
-#define CHUNK_tIME	PNG_INT32('t','I','M','E')	/* Time stamp. */
-#define CHUNK_tRNS	PNG_INT32('t','R','N','S')	/* Transparency. */
-#define CHUNK_zTXt	PNG_INT32('z','T','X','t')	/* Compressed Latin-1
-							 * text. */
-
-/*
- * Color flags.
- */
-
-#define PNG_COLOR_INDEXED	1
-#define PNG_COLOR_USED		2
-#define PNG_COLOR_ALPHA		4
-
-/*
- * Actual color types.
- */
-
-#define PNG_COLOR_GRAY		0
-#define PNG_COLOR_RGB		(PNG_COLOR_USED)
-#define PNG_COLOR_PLTE		(PNG_COLOR_USED | PNG_COLOR_INDEXED)
-#define PNG_COLOR_GRAYALPHA	(PNG_COLOR_GRAY | PNG_COLOR_ALPHA)
-#define PNG_COLOR_RGBA		(PNG_COLOR_USED | PNG_COLOR_ALPHA)
-
-/*
- * Compression Methods.
- */
-
-#define PNG_COMPRESS_DEFLATE	0
-
-/*
- * Filter Methods.
- */
-
-#define PNG_FILTMETH_STANDARD	0
-
-/*
- * Interlacing Methods.
- */
-
-#define	PNG_INTERLACE_NONE	0
-#define PNG_INTERLACE_ADAM7	1
-
-/*
- * State information, used to store everything about the PNG image being
- * currently parsed or created.
- */
-
-typedef struct {
-    /*
-     * PNG data source/destination channel/object/byte array.
-     */
-
-    Tcl_Channel channel;	/* Channel for from-file reads. */
-    Tcl_Obj *objDataPtr;
-    unsigned char *strDataBuf;	/* Raw source data for from-string reads. */
-    int strDataLen;		/* Length of source data. */
-    unsigned char *base64Data;	/* base64 encoded string data. */
-    unsigned char base64Bits;	/* Remaining bits from last base64 read. */
-    unsigned char base64State;	/* Current state of base64 decoder. */
-    double alpha;		/* Alpha from -format option. */
-
-    /*
-     * Image header information.
-     */
-
-    unsigned char bitDepth;	/* Number of bits per pixel. */
-    unsigned char colorType;	/* Grayscale, TrueColor, etc. */
-    unsigned char compression;	/* Compression Mode (always zlib). */
-    unsigned char filter;	/* Filter mode (0 - 3). */
-    unsigned char interlace;	/* Type of interlacing (if any). */
-    unsigned char numChannels;	/* Number of channels per pixel. */
-    unsigned char bytesPerPixel;/* Bytes per pixel in scan line. */
-    int bitScale;		/* Scale factor for RGB/Gray depths < 8. */
-    int currentLine;		/* Current line being unfiltered. */
-    unsigned char phase;	/* Interlacing phase (0..6). */
-    Tk_PhotoImageBlock block;
-    int blockLen;		/* Number of bytes in Tk image pixels. */
-
-    /*
-     * For containing data read from PLTE (palette) and tRNS (transparency)
-     * chunks.
-     */
-
-    int paletteLen;		/* Number of PLTE entries (1..256). */
-    int useTRNS;		/* Flag to indicate whether there was a
-				 * palette given. */
-    struct {
-	unsigned char red;
-	unsigned char green;
-	unsigned char blue;
-	unsigned char alpha;
-    } palette[256];		/* Palette RGB/Transparency table. */
-    unsigned char transVal[6];	/* Fully-transparent RGB/Gray Value. */
-
-    /*
-     * For compressing and decompressing IDAT chunks.
-     */
-
-    Tcl_ZlibStream stream;	/* Inflating or deflating stream; this one is
-				 * not bound to a Tcl command. */
-    Tcl_Obj *lastLineObj;	/* Last line of pixels, for unfiltering. */
-    Tcl_Obj *thisLineObj;	/* Current line of pixels to process. */
-    int lineSize;		/* Number of bytes in a PNG line. */
-    int phaseSize;		/* Number of bytes/line in current phase. */
-} PNGImage;
-
-/*
- * Maximum size of various chunks.
- */
-
-#define	PNG_PLTE_MAXSZ 768	/* 3 bytes/RGB entry, 256 entries max */
-#define	PNG_TRNS_MAXSZ 256	/* 1-byte alpha, 256 entries max */
-
-/*
- * Forward declarations of non-global functions defined in this file:
- */
-
-static void		ApplyAlpha(PNGImage *pngPtr);
-static int		CheckColor(Tcl_Interp *interp, PNGImage *pngPtr);
-static inline int	CheckCRC(Tcl_Interp *interp, PNGImage *pngPtr,
-			    unsigned long calculated);
-static void		CleanupPNGImage(PNGImage *pngPtr);
-static int		DecodeLine(Tcl_Interp *interp, PNGImage *pngPtr);
-static int		DecodePNG(Tcl_Interp *interp, PNGImage *pngPtr,
-			    Tcl_Obj *fmtObj, Tk_PhotoHandle imageHandle,
-			    int destX, int destY);
-static int		EncodePNG(Tcl_Interp *interp,
-			    Tk_PhotoImageBlock *blockPtr, PNGImage *pngPtr);
-static int		FileMatchPNG(Tcl_Channel chan, const char *fileName,
-			    Tcl_Obj *fmtObj, int *widthPtr, int *heightPtr,
-			    Tcl_Interp *interp);
-static int		FileReadPNG(Tcl_Interp *interp, Tcl_Channel chan,
-			    const char *fileName, Tcl_Obj *fmtObj,
-			    Tk_PhotoHandle imageHandle, int destX, int destY,
-			    int width, int height, int srcX, int srcY);
-static int		FileWritePNG(Tcl_Interp *interp, const char *filename,
-			    Tcl_Obj *fmtObj, Tk_PhotoImageBlock *blockPtr);
-static int		InitPNGImage(Tcl_Interp *interp, PNGImage *pngPtr,
-			    Tcl_Channel chan, Tcl_Obj *objPtr, int dir);
-static inline unsigned char Paeth(int a, int b, int c);
-static int		ParseFormat(Tcl_Interp *interp, Tcl_Obj *fmtObj,
-			    PNGImage *pngPtr);
-static int		ReadBase64(Tcl_Interp *interp, PNGImage *pngPtr,
-			    unsigned char *destPtr, int destSz,
-			    unsigned long *crcPtr);
-static int		ReadByteArray(Tcl_Interp *interp, PNGImage *pngPtr,
-			    unsigned char *destPtr, int destSz,
-			    unsigned long *crcPtr);
-static int		ReadData(Tcl_Interp *interp, PNGImage *pngPtr,
-			    unsigned char *destPtr, int destSz,
-			    unsigned long *crcPtr);
-static int		ReadChunkHeader(Tcl_Interp *interp, PNGImage *pngPtr,
-			    int *sizePtr, unsigned long *typePtr,
-			    unsigned long *crcPtr);
-static int		ReadIDAT(Tcl_Interp *interp, PNGImage *pngPtr,
-			    int chunkSz, unsigned long crc);
-static int		ReadIHDR(Tcl_Interp *interp, PNGImage *pngPtr);
-static inline int	ReadInt32(Tcl_Interp *interp, PNGImage *pngPtr,
-			    unsigned long *resultPtr, unsigned long *crcPtr);
-static int		ReadPLTE(Tcl_Interp *interp, PNGImage *pngPtr,
-			    int chunkSz, unsigned long crc);
-static int		ReadTRNS(Tcl_Interp *interp, PNGImage *pngPtr,
-			    int chunkSz, unsigned long crc);
-static int		SkipChunk(Tcl_Interp *interp, PNGImage *pngPtr,
-			    int chunkSz, unsigned long crc);
-static int		StringMatchPNG(Tcl_Obj *dataObj, Tcl_Obj *fmtObj,
-			    int *widthPtr, int *heightPtr,
-			    Tcl_Interp *interp);
-static int		StringReadPNG(Tcl_Interp *interp, Tcl_Obj *dataObj,
-			    Tcl_Obj *fmtObj, Tk_PhotoHandle imageHandle,
-			    int destX, int destY, int width, int height,
-			    int srcX, int srcY);
-static int		StringWritePNG(Tcl_Interp *interp, Tcl_Obj *fmtObj,
-			    Tk_PhotoImageBlock *blockPtr);
-static int		UnfilterLine(Tcl_Interp *interp, PNGImage *pngPtr);
-static inline int	WriteByte(Tcl_Interp *interp, PNGImage *pngPtr,
-			    unsigned char c, unsigned long *crcPtr);
-static inline int	WriteChunk(Tcl_Interp *interp, PNGImage *pngPtr,
-			    unsigned long chunkType,
-			    const unsigned char *dataPtr, int dataSize);
-static int		WriteData(Tcl_Interp *interp, PNGImage *pngPtr,
-			    const unsigned char *srcPtr, int srcSz,
-			    unsigned long *crcPtr);
-static int		WriteExtraChunks(Tcl_Interp *interp,
-			    PNGImage *pngPtr);
-static int		WriteIHDR(Tcl_Interp *interp, PNGImage *pngPtr,
-			    Tk_PhotoImageBlock *blockPtr);
-static int		WriteIDAT(Tcl_Interp *interp, PNGImage *pngPtr,
-			    Tk_PhotoImageBlock *blockPtr);
-static inline int	WriteInt32(Tcl_Interp *interp, PNGImage *pngPtr,
-			    unsigned long l, unsigned long *crcPtr);
-
-/*
- * The format record for the PNG file format:
- */
-
-Tk_PhotoImageFormat tkImgFmtPNG = {
-    "png",			/* name */
-    FileMatchPNG,		/* fileMatchProc */
-    StringMatchPNG,		/* stringMatchProc */
-    FileReadPNG,		/* fileReadProc */
-    StringReadPNG,		/* stringReadProc */
-    FileWritePNG,		/* fileWriteProc */
-    StringWritePNG,		/* stringWriteProc */
-    NULL
-};
-
-/*
- *----------------------------------------------------------------------
- *
- * InitPNGImage --
- *
- *	This function is invoked by each of the Tk image handler procs
- *	(MatchStringProc, etc.) to initialize state information used during
- *	the course of encoding or decoding a PNG image.
- *
- * Results:
- *	TCL_OK, or TCL_ERROR if initialization failed.
- *
- * Side effects:
- *	The reference count of the -data Tcl_Obj*, if any, is incremented.
- *
- *----------------------------------------------------------------------
- */
-
-static int
-InitPNGImage(
-    Tcl_Interp *interp,
-    PNGImage *pngPtr,
-    Tcl_Channel chan,
-    Tcl_Obj *objPtr,
-    int dir)
-{
-    memset(pngPtr, 0, sizeof(PNGImage));
-
-    pngPtr->channel = chan;
-    pngPtr->alpha = 1.0;
-
-    /*
-     * If decoding from a -data string object, increment its reference count
-     * for the duration of the decode and get its length and byte array for
-     * reading with ReadData().
-     */
-
-    if (objPtr) {
-	Tcl_IncrRefCount(objPtr);
-	pngPtr->objDataPtr = objPtr;
-	pngPtr->strDataBuf =
-		Tcl_GetByteArrayFromObj(objPtr, &pngPtr->strDataLen);
-    }
-
-    /*
-     * Initialize the palette transparency table to fully opaque.
-     */
-
-    memset(pngPtr->palette, 255, sizeof(pngPtr->palette));
-
-    /*
-     * Initialize Zlib inflate/deflate stream.
-     */
-
-    if (Tcl_ZlibStreamInit(NULL, dir, TCL_ZLIB_FORMAT_ZLIB,
-	    TCL_ZLIB_COMPRESS_DEFAULT, NULL, &pngPtr->stream) != TCL_OK) {
-	if (interp) {
-	    Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		    "zlib initialization failed", -1));
-	    Tcl_SetErrorCode(interp, "TK", "IMAGE", "PNG", "ZLIB_INIT", NULL);
-	}
-	if (objPtr) {
-	    Tcl_DecrRefCount(objPtr);
-	}
-	return TCL_ERROR;
-    }
-
-    return TCL_OK;
-}
-
-/*
- *----------------------------------------------------------------------
- *
- * CleanupPNGImage --
- *
- *	This function is invoked by each of the Tk image handler procs
- *	(MatchStringProc, etc.) prior to returning to Tcl in order to clean up
- *	any allocated memory and call other cleanup handlers such as zlib's
- *	inflateEnd/deflateEnd.
- *
- * Results:
- *	None.
- *
- * Side effects:
- *	The reference count of the -data Tcl_Obj*, if any, is decremented.
- *	Buffers are freed, streams are closed. The PNGImage should not be used
- *	for any purpose without being reinitialized post-cleanup.
- *
- *----------------------------------------------------------------------
- */
-
-static void
-CleanupPNGImage(
-    PNGImage *pngPtr)
-{
-    /*
-     * Don't need the object containing the -data value anymore.
-     */
-
-    if (pngPtr->objDataPtr) {
-	Tcl_DecrRefCount(pngPtr->objDataPtr);
-    }
-
-    /*
-     * Discard pixel buffer.
-     */
-
-    if (pngPtr->stream) {
-	Tcl_ZlibStreamClose(pngPtr->stream);
-    }
-
-    if (pngPtr->block.pixelPtr) {
-	ckfree(pngPtr->block.pixelPtr);
-    }
-    if (pngPtr->thisLineObj) {
-	Tcl_DecrRefCount(pngPtr->thisLineObj);
-    }
-    if (pngPtr->lastLineObj) {
-	Tcl_DecrRefCount(pngPtr->lastLineObj);
-    }
-
-    memset(pngPtr, 0, sizeof(PNGImage));
-}
-
-/*
- *----------------------------------------------------------------------
- *
- * ReadBase64 --
- *
- *	This function is invoked to read the specified number of bytes from
- *	base-64 encoded image data.
- *
- *	Note: It would be better if the Tk_PhotoImage stuff handled this by
- *	creating a channel from the -data value, which would take care of
- *	base64 decoding and made the data readable as if it were coming from a
- *	file.
- *
- * Results:
- *	TCL_OK, or TCL_ERROR if an I/O error occurs.
- *
- * Side effects:
- *	The file position will change. The running CRC is updated if a pointer
- *	to it is provided.
- *
- *----------------------------------------------------------------------
- */
-
-static int
-ReadBase64(
-    Tcl_Interp *interp,
-    PNGImage *pngPtr,
-    unsigned char *destPtr,
-    int destSz,
-    unsigned long *crcPtr)
-{
-    static const unsigned char from64[] = {
-	0x82, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x80, 0x80,
-	0x83, 0x80, 0x80, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83,
-	0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x80,
-	0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x3e,
-	0x83, 0x83, 0x83, 0x3f, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a,
-	0x3b, 0x3c, 0x3d, 0x83, 0x83, 0x83, 0x81, 0x83, 0x83, 0x83, 0x00,
-	0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b,
-	0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16,
-	0x17, 0x18, 0x19, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x1a, 0x1b,
-	0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26,
-	0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31,
-	0x32, 0x33, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83,
-	0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83,
-	0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83,
-	0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83,
-	0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83,
-	0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83,
-	0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83,
-	0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83,
-	0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83,
-	0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83,
-	0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83,
-	0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83,
-	0x83, 0x83
-    };
-
-    /*
-     * Definitions for the base-64 decoder.
-     */
-
-#define PNG64_SPECIAL	0x80	/* Flag bit */
-#define PNG64_SPACE	0x80	/* Whitespace */
-#define PNG64_PAD	0x81	/* Padding */
-#define PNG64_DONE	0x82	/* End of data */
-#define PNG64_BAD	0x83	/* Ooooh, naughty! */
-
-    while (destSz && pngPtr->strDataLen) {
-	unsigned char c = 0;
-	unsigned char c64 = from64[*pngPtr->strDataBuf++];
-
-	pngPtr->strDataLen--;
-
-	if (PNG64_SPACE == c64) {
-	    continue;
-	}
-
-	if (c64 & PNG64_SPECIAL) {
-	    c = (unsigned char) pngPtr->base64Bits;
-	} else {
-	    switch (pngPtr->base64State++) {
-	    case 0:
-		pngPtr->base64Bits = c64 << 2;
-		continue;
-	    case 1:
-		c = (unsigned char) (pngPtr->base64Bits | (c64 >> 4));
-		pngPtr->base64Bits = (c64 & 0xF) << 4;
-		break;
-	    case 2:
-		c = (unsigned char) (pngPtr->base64Bits | (c64 >> 2));
-		pngPtr->base64Bits = (c64 & 0x3) << 6;
-		break;
-	    case 3:
-		c = (unsigned char) (pngPtr->base64Bits | c64);
-		pngPtr->base64State = 0;
-		pngPtr->base64Bits = 0;
-		break;
-	    }
-	}
-
-	if (crcPtr) {
-	    *crcPtr = Tcl_ZlibCRC32(*crcPtr, &c, 1);
-	}
-
-	if (destPtr) {
-	    *destPtr++ = c;
-	}
-
-	destSz--;
-
-	if (c64 & PNG64_SPECIAL) {
-	    break;
-	}
-    }
-
-    if (destSz) {
-	Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		"unexpected end of image data", -1));
-	Tcl_SetErrorCode(interp, "TK", "IMAGE", "PNG", "EARLY_END", NULL);
-	return TCL_ERROR;
-    }
-
-    return TCL_OK;
-}
-
-/*
- *----------------------------------------------------------------------
- *
- * ReadByteArray --
- *
- *	This function is invoked to read the specified number of bytes from a
- *	non-base64-encoded byte array provided via the -data option.
- *
- *	Note: It would be better if the Tk_PhotoImage stuff handled this by
- *	creating a channel from the -data value and made the data readable as
- *	if it were coming from a file.
- *
- * Results:
- *	TCL_OK, or TCL_ERROR if an I/O error occurs.
- *
- * Side effects:
- *	The file position will change. The running CRC is updated if a pointer
- *	to it is provided.
- *
- *----------------------------------------------------------------------
- */
-
-static int
-ReadByteArray(
-    Tcl_Interp *interp,
-    PNGImage *pngPtr,
-    unsigned char *destPtr,
-    int destSz,
-    unsigned long *crcPtr)
-{
-    /*
-     * Check to make sure the number of requested bytes are available.
-     */
-
-    if (pngPtr->strDataLen < destSz) {
-	Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		"unexpected end of image data", -1));
-	Tcl_SetErrorCode(interp, "TK", "IMAGE", "PNG", "EARLY_END", NULL);
-	return TCL_ERROR;
-    }
-
-    while (destSz) {
-	int blockSz = PNG_MIN(destSz, PNG_BLOCK_SZ);
-
-	memcpy(destPtr, pngPtr->strDataBuf, blockSz);
-
-	pngPtr->strDataBuf += blockSz;
-	pngPtr->strDataLen -= blockSz;
-
-	if (crcPtr) {
-	    *crcPtr = Tcl_ZlibCRC32(*crcPtr, destPtr, blockSz);
-	}
-
-	destPtr += blockSz;
-	destSz -= blockSz;
-    }
-
-    return TCL_OK;
-}
-
-/*
- *----------------------------------------------------------------------
- *
- * ReadData --
- *
- *	This function is invoked to read the specified number of bytes from
- *	the image file or data. It is a wrapper around the choice of byte
- *	array Tcl_Obj or Tcl_Channel which depends on whether the image data
- *	is coming from a file or -data.
- *
- * Results:
- *	TCL_OK, or TCL_ERROR if an I/O error occurs.
- *
- * Side effects:
- *	The file position will change. The running CRC is updated if a pointer
- *	to it is provided.
- *
- *----------------------------------------------------------------------
- */
-
-static int
-ReadData(
-    Tcl_Interp *interp,
-    PNGImage *pngPtr,
-    unsigned char *destPtr,
-    int destSz,
-    unsigned long *crcPtr)
-{
-    if (pngPtr->base64Data) {
-	return ReadBase64(interp, pngPtr, destPtr, destSz, crcPtr);
-    } else if (pngPtr->strDataBuf) {
-	return ReadByteArray(interp, pngPtr, destPtr, destSz, crcPtr);
-    }
-
-    while (destSz) {
-	int blockSz = PNG_MIN(destSz, PNG_BLOCK_SZ);
-
-	blockSz = Tcl_Read(pngPtr->channel, (char *)destPtr, blockSz);
-	if (blockSz < 0) {
-	    /* TODO: failure info... */
-	    Tcl_SetObjResult(interp, Tcl_ObjPrintf(
-		    "channel read failed: %s", Tcl_PosixError(interp)));
-	    return TCL_ERROR;
-	}
-
-	/*
-	 * Update CRC, pointer, and remaining count if anything was read.
-	 */
-
-	if (blockSz) {
-	    if (crcPtr) {
-		*crcPtr = Tcl_ZlibCRC32(*crcPtr, destPtr, blockSz);
-	    }
-
-	    destPtr += blockSz;
-	    destSz -= blockSz;
-	}
-
-	/*
-	 * Check for EOF before all desired data was read.
-	 */
-
-	if (destSz && Tcl_Eof(pngPtr->channel)) {
-	    Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		    "unexpected end of file", -1));
-	    Tcl_SetErrorCode(interp, "TK", "IMAGE", "PNG", "EOF", NULL);
-	    return TCL_ERROR;
-	}
-    }
-
-    return TCL_OK;
-}
-
-/*
- *----------------------------------------------------------------------
- *
- * ReadInt32 --
- *
- *	This function is invoked to read a 32-bit integer in network byte
- *	order from the image data and return the value in host byte order.
- *	This is used, for example, to read the 32-bit CRC value for a chunk
- *	stored in the image file for comparison with the calculated CRC value.
- *
- * Results:
- *	TCL_OK, or TCL_ERROR if an I/O error occurs.
- *
- * Side effects:
- *	The file position will change. The running CRC is updated if a pointer
- *	to it is provided.
- *
- *----------------------------------------------------------------------
- */
-
-static inline int
-ReadInt32(
-    Tcl_Interp *interp,
-    PNGImage *pngPtr,
-    unsigned long *resultPtr,
-    unsigned long *crcPtr)
-{
-    unsigned char p[4];
-
-    if (ReadData(interp, pngPtr, p, 4, crcPtr) == TCL_ERROR) {
-	return TCL_ERROR;
-    }
-
-    *resultPtr = PNG_INT32(p[0], p[1], p[2], p[3]);
-
-    return TCL_OK;
-}
-
-/*
- *----------------------------------------------------------------------
- *
- * CheckCRC --
- *
- *	This function is reads the final 4-byte integer CRC from a chunk and
- *	compares it to the running CRC calculated over the chunk type and data
- *	fields.
- *
- * Results:
- *	TCL_OK, or TCL_ERROR if an I/O error or CRC mismatch occurs.
- *
- * Side effects:
- *	The file position will change.
- *
- *----------------------------------------------------------------------
- */
-
-static inline int
-CheckCRC(
-    Tcl_Interp *interp,
-    PNGImage *pngPtr,
-    unsigned long calculated)
-{
-    unsigned long chunked;
-
-    /*
-     * Read the CRC field at the end of the chunk.
-     */
-
-    if (ReadInt32(interp, pngPtr, &chunked, NULL) == TCL_ERROR) {
-	return TCL_ERROR;
-    }
-
-    /*
-     * Compare the read CRC to what we calculate to make sure they match.
-     */
-
-    if (calculated != chunked) {
-	Tcl_SetObjResult(interp, Tcl_NewStringObj("CRC check failed", -1));
-	Tcl_SetErrorCode(interp, "TK", "IMAGE", "PNG", "CRC", NULL);
-	return TCL_ERROR;
-    }
-
-    return TCL_OK;
-}
-
-/*
- *----------------------------------------------------------------------
- *
- * SkipChunk --
- *
- *	This function is used to skip a PNG chunk that is not used by this
- *	implementation. Given the input stream has had the chunk length and
- *	chunk type fields already read, this function will read the number of
- *	bytes indicated by the chunk length, plus four for the CRC, and will
- *	verify that CRC is correct for the skipped data.
- *
- * Results:
- *	TCL_OK, or TCL_ERROR if an I/O error or CRC mismatch occurs.
- *
- * Side effects:
- *	The file position will change.
- *
- *----------------------------------------------------------------------
- */
-
-static int
-SkipChunk(
-    Tcl_Interp *interp,
-    PNGImage *pngPtr,
-    int chunkSz,
-    unsigned long crc)
-{
-    unsigned char buffer[PNG_BLOCK_SZ];
-
-    /*
-     * Skip data in blocks until none is left. Read up to PNG_BLOCK_SZ bytes
-     * at a time, rather than trusting the claimed chunk size, which may not
-     * be trustworthy.
-     */
-
-    while (chunkSz) {
-	int blockSz = PNG_MIN(chunkSz, PNG_BLOCK_SZ);
-
-	if (ReadData(interp, pngPtr, buffer, blockSz, &crc) == TCL_ERROR) {
-	    return TCL_ERROR;
-	}
-
-	chunkSz -= blockSz;
-    }
-
-    if (CheckCRC(interp, pngPtr, crc) == TCL_ERROR) {
-	return TCL_ERROR;
-    }
-
-    return TCL_OK;
-}
-
-/*
- * 4.3. Summary of standard chunks
- *
- * This table summarizes some properties of the standard chunk types.
- *
- *	Critical chunks (must appear in this order, except PLTE is optional):
- *
- *		Name   Multiple	 Ordering constraints OK?
- *
- *		IHDR	No	 Must be first
- *		PLTE	No	 Before IDAT
- *		IDAT	Yes	 Multiple IDATs must be consecutive
- *		IEND	No	 Must be last
- *
- *	Ancillary chunks (need not appear in this order):
- *
- *		Name   Multiple	 Ordering constraints OK?
- *
- *		cHRM	No	 Before PLTE and IDAT
- *		gAMA	No	 Before PLTE and IDAT
- *		iCCP	No	 Before PLTE and IDAT
- *		sBIT	No	 Before PLTE and IDAT
- *		sRGB	No	 Before PLTE and IDAT
- *		bKGD	No	 After PLTE; before IDAT
- *		hIST	No	 After PLTE; before IDAT
- *		tRNS	No	 After PLTE; before IDAT
- *		pHYs	No	 Before IDAT
- *		sPLT	Yes	 Before IDAT
- *		tIME	No	 None
- *		iTXt	Yes	 None
- *		tEXt	Yes	 None
- *		zTXt	Yes	 None
- *
- *	[From the PNG specification.]
- */
-
-/*
- *----------------------------------------------------------------------
- *
- * ReadChunkHeader --
- *
- *	This function is used at the start of each chunk to extract the
- *	four-byte chunk length and four-byte chunk type fields. It will
- *	continue reading until it finds a chunk type that is handled by this
- *	implementation, checking the CRC of any chunks it skips.
- *
- * Results:
- *	TCL_OK, or TCL_ERROR if an I/O error occurs or an unknown critical
- *	chunk type is encountered.
- *
- * Side effects:
- *	The file position will change. The running CRC is updated.
- *
- *----------------------------------------------------------------------
- */
-
-static int
-ReadChunkHeader(
-    Tcl_Interp *interp,
-    PNGImage *pngPtr,
-    int *sizePtr,
-    unsigned long *typePtr,
-    unsigned long *crcPtr)
-{
-    unsigned long chunkType = 0;
-    int chunkSz = 0;
-    unsigned long crc = 0;
-
-    /*
-     * Continue until finding a chunk type that is handled.
-     */
-
-    while (!chunkType) {
-	unsigned long temp;
-	unsigned char pc[4];
-	int i;
-
-	/*
-	 * Read the 4-byte length field for the chunk. The length field is not
-	 * included in the CRC calculation, so the running CRC must be reset
-	 * afterward. Limit chunk lengths to INT_MAX, to align with the
-	 * maximum size for Tcl_Read, Tcl_GetByteArrayFromObj, etc.
-	 */
-
-	if (ReadData(interp, pngPtr, pc, 4, NULL) == TCL_ERROR) {
-	    return TCL_ERROR;
-	}
-
-	temp = PNG_INT32(pc[0], pc[1], pc[2], pc[3]);
-
-	if (temp > INT_MAX) {
-	    Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		    "chunk size is out of supported range on this architecture",
-		    -1));
-	    Tcl_SetErrorCode(interp, "TK", "IMAGE", "PNG", "OUTSIZE", NULL);
-	    return TCL_ERROR;
-	}
-
-	chunkSz = (int) temp;
-	crc = Tcl_ZlibCRC32(0, NULL, 0);
-
-	/*
-	 * Read the 4-byte chunk type.
-	 */
-
-	if (ReadData(interp, pngPtr, pc, 4, &crc) == TCL_ERROR) {
-	    return TCL_ERROR;
-	}
-
-	/*
-	 * Convert it to a host-order integer for simple comparison.
-	 */
-
-	chunkType = PNG_INT32(pc[0], pc[1], pc[2], pc[3]);
-
-	/*
-	 * Check to see if this is a known/supported chunk type. Note that the
-	 * PNG specs require non-critical (i.e., ancillary) chunk types that
-	 * are not recognized to be ignored, rather than be treated as an
-	 * error. It does, however, recommend that an unknown critical chunk
-	 * type be treated as a failure.
-	 *
-	 * This switch/loop acts as a filter of sorts for undesired chunk
-	 * types. The chunk type should still be checked elsewhere for
-	 * determining it is in the correct order.
-	 */
-
-	switch (chunkType) {
-	    /*
-	     * These chunk types are required and/or supported.
-	     */
-
-	case CHUNK_IDAT:
-	case CHUNK_IEND:
-	case CHUNK_IHDR:
-	case CHUNK_PLTE:
-	case CHUNK_tRNS:
-	    break;
-
-	    /*
-	     * These chunk types are part of the standard, but are not used by
-	     * this implementation (at least not yet). Note that these are all
-	     * ancillary chunks (lowercase first letter).
-	     */
-
-	case CHUNK_bKGD:
-	case CHUNK_cHRM:
-	case CHUNK_gAMA:
-	case CHUNK_hIST:
-	case CHUNK_iCCP:
-	case CHUNK_iTXt:
-	case CHUNK_oFFs:
-	case CHUNK_pCAL:
-	case CHUNK_pHYs:
-	case CHUNK_sBIT:
-	case CHUNK_sCAL:
-	case CHUNK_sPLT:
-	case CHUNK_sRGB:
-	case CHUNK_tEXt:
-	case CHUNK_tIME:
-	case CHUNK_zTXt:
-	    /*
-	     * TODO: might want to check order here.
-	     */
-
-	    if (SkipChunk(interp, pngPtr, chunkSz, crc) == TCL_ERROR) {
-		return TCL_ERROR;
-	    }
-
-	    chunkType = 0;
-	    break;
-
-	default:
-	    /*
-	     * Unknown chunk type. If it's critical, we can't continue.
-	     */
-
-	    if (!(chunkType & PNG_CF_ANCILLARY)) {
-		if (chunkType & PNG_INT32(128,128,128,128)) {
-		    /*
-		     * No nice ASCII conversion; shouldn't happen either, but
-		     * we'll be doubly careful.
-		     */
-
-		    Tcl_SetObjResult(interp, Tcl_NewStringObj(
-			    "encountered an unsupported criticial chunk type",
-			    -1));
-		} else {
-		    char typeString[5];
-
-		    typeString[0] = (char) ((chunkType >> 24) & 255);
-		    typeString[1] = (char) ((chunkType >> 16) & 255);
-		    typeString[2] = (char) ((chunkType >> 8) & 255);
-		    typeString[3] = (char) (chunkType & 255);
-		    typeString[4] = '\0';
-		    Tcl_SetObjResult(interp, Tcl_ObjPrintf(
-			    "encountered an unsupported criticial chunk type"
-			    " \"%s\"", typeString));
-		}
-		Tcl_SetErrorCode(interp, "TK", "IMAGE", "PNG",
-			"UNSUPPORTED_CRITICAL", NULL);
-		return TCL_ERROR;
-	    }
-
-	    /*
-	     * Check to see if the chunk type has legal bytes.
-	     */
-
-	    for (i=0 ; i<4 ; i++) {
-		if ((pc[i] < 65) || (pc[i] > 122) ||
-			((pc[i] > 90) && (pc[i] < 97))) {
-		    Tcl_SetObjResult(interp, Tcl_NewStringObj(
-			    "invalid chunk type", -1));
-		    Tcl_SetErrorCode(interp, "TK", "IMAGE", "PNG",
-			    "INVALID_CHUNK", NULL);
-		    return TCL_ERROR;
-		}
-	    }
-
-	    /*
-	     * It seems to be an otherwise legally labelled ancillary chunk
-	     * that we don't want, so skip it after at least checking its CRC.
-	     */
-
-	    if (SkipChunk(interp, pngPtr, chunkSz, crc) == TCL_ERROR) {
-		return TCL_ERROR;
-	    }
-
-	    chunkType = 0;
-	}
-    }
-
-    /*
-     * Found a known chunk type that's handled, albiet possibly not in the
-     * right order. Send back the chunk type (for further checking or
-     * handling), the chunk size and the current CRC for the rest of the
-     * calculation.
-     */
-
-    *typePtr = chunkType;
-    *sizePtr = chunkSz;
-    *crcPtr = crc;
-
-    return TCL_OK;
-}
-
-/*
- *----------------------------------------------------------------------
- *
- * CheckColor --
- *
- *	Do validation on color type, depth, and related information, and
- *	calculates storage requirements and offsets based on image dimensions
- *	and color.
- *
- * Results:
- *	TCL_OK, or TCL_ERROR if color information is invalid or some other
- *	failure occurs.
- *
- * Side effects:
- *	None
- *
- *----------------------------------------------------------------------
- */
-
-static int
-CheckColor(
-    Tcl_Interp *interp,
-    PNGImage *pngPtr)
-{
-    int offset;
-
-    /*
-     * Verify the color type is valid and the bit depth is allowed.
-     */
-
-    switch (pngPtr->colorType) {
-    case PNG_COLOR_GRAY:
-	pngPtr->numChannels = 1;
-	if ((1 != pngPtr->bitDepth) && (2 != pngPtr->bitDepth) &&
-		(4 != pngPtr->bitDepth) && (8 != pngPtr->bitDepth) &&
-		(16 != pngPtr->bitDepth)) {
-	    goto unsupportedDepth;
-	}
-	break;
-
-    case PNG_COLOR_RGB:
-	pngPtr->numChannels = 3;
-	if ((8 != pngPtr->bitDepth) && (16 != pngPtr->bitDepth)) {
-	    goto unsupportedDepth;
-	}
-	break;
-
-    case PNG_COLOR_PLTE:
-	pngPtr->numChannels = 1;
-	if ((1 != pngPtr->bitDepth) && (2 != pngPtr->bitDepth) &&
-		(4 != pngPtr->bitDepth) && (8 != pngPtr->bitDepth)) {
-	    goto unsupportedDepth;
-	}
-	break;
-
-    case PNG_COLOR_GRAYALPHA:
-	pngPtr->numChannels = 2;
-	if ((8 != pngPtr->bitDepth) && (16 != pngPtr->bitDepth)) {
-	    goto unsupportedDepth;
-	}
-	break;
-
-    case PNG_COLOR_RGBA:
-	pngPtr->numChannels = 4;
-	if ((8 != pngPtr->bitDepth) && (16 != pngPtr->bitDepth)) {
-	unsupportedDepth:
-	    Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		    "bit depth is not allowed for given color type", -1));
-	    Tcl_SetErrorCode(interp, "TK", "IMAGE", "PNG", "BAD_DEPTH", NULL);
-	    return TCL_ERROR;
-	}
-	break;
-
-    default:
-	Tcl_SetObjResult(interp, Tcl_ObjPrintf(
-		"unknown color type field %d", pngPtr->colorType));
-	Tcl_SetErrorCode(interp, "TK", "IMAGE", "PNG", "UNKNOWN_COLOR", NULL);
-	return TCL_ERROR;
-    }
-
-    /*
-     * Set up the Tk photo block's pixel size and channel offsets. offset
-     * array elements should already be 0 from the memset during InitPNGImage.
-     */
-
-    offset = (pngPtr->bitDepth > 8) ? 2 : 1;
-
-    if (pngPtr->colorType & PNG_COLOR_USED) {
-	pngPtr->block.pixelSize = offset * 4;
-	pngPtr->block.offset[1] = offset;
-	pngPtr->block.offset[2] = offset * 2;
-	pngPtr->block.offset[3] = offset * 3;
-    } else {
-	pngPtr->block.pixelSize = offset * 2;
-	pngPtr->block.offset[3] = offset;
-    }
-
-    /*
-     * Calculate the block pitch, which is the number of bytes per line in the
-     * image, given image width and depth of color. Make sure that it it isn't
-     * larger than Tk can handle.
-     */
-
-    if (pngPtr->block.width > INT_MAX / pngPtr->block.pixelSize) {
-	Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		"image pitch is out of supported range on this architecture",
-		-1));
-	Tcl_SetErrorCode(interp, "TK", "IMAGE", "PNG", "PITCH", NULL);
-	return TCL_ERROR;
-    }
-
-    pngPtr->block.pitch = pngPtr->block.pixelSize * pngPtr->block.width;
-
-    /*
-     * Calculate the total size of the image as represented to Tk given pitch
-     * and image height. Make sure that it isn't larger than Tk can handle.
-     */
-
-    if (pngPtr->block.height > INT_MAX / pngPtr->block.pitch) {
-	Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		"image total size is out of supported range on this architecture",
-		-1));
-	Tcl_SetErrorCode(interp, "TK", "IMAGE", "PNG", "SIZE", NULL);
-	return TCL_ERROR;
-    }
-
-    pngPtr->blockLen = pngPtr->block.height * pngPtr->block.pitch;
-
-    /*
-     * Determine number of bytes per pixel in the source for later use.
-     */
-
-    switch (pngPtr->colorType) {
-    case PNG_COLOR_GRAY:
-	pngPtr->bytesPerPixel = (pngPtr->bitDepth > 8) ? 2 : 1;
-	break;
-    case PNG_COLOR_RGB:
-	pngPtr->bytesPerPixel = (pngPtr->bitDepth > 8) ? 6 : 3;
-	break;
-    case PNG_COLOR_PLTE:
-	pngPtr->bytesPerPixel = 1;
-	break;
-    case PNG_COLOR_GRAYALPHA:
-	pngPtr->bytesPerPixel = (pngPtr->bitDepth > 8) ? 4 : 2;
-	break;
-    case PNG_COLOR_RGBA:
-	pngPtr->bytesPerPixel = (pngPtr->bitDepth > 8) ? 8 : 4;
-	break;
-    default:
-	Tcl_SetObjResult(interp, Tcl_ObjPrintf(
-		"unknown color type %d", pngPtr->colorType));
-	Tcl_SetErrorCode(interp, "TK", "IMAGE", "PNG", "UNKNOWN_COLOR", NULL);
-	return TCL_ERROR;
-    }
-
-    /*
-     * Calculate scale factor for bit depths less than 8, in order to adjust
-     * them to a minimum of 8 bits per pixel in the Tk image.
-     */
-
-    if (pngPtr->bitDepth < 8) {
-	pngPtr->bitScale = 255 / (int)(pow(2, pngPtr->bitDepth) - 1);
-    } else {
-	pngPtr->bitScale = 1;
-    }
-
-    return TCL_OK;
-}
-
-/*
- *----------------------------------------------------------------------
- *
- * ReadIHDR --
- *
- *	This function reads the PNG header from the beginning of a PNG file
- *	and returns the dimensions of the image.
- *
- * Results:
- *	The return value is 1 if file "f" appears to start with a valid PNG
- *	header, 0 otherwise. If the header is valid, then *widthPtr and
- *	*heightPtr are modified to hold the dimensions of the image.
- *
- * Side effects:
- *	The access position in f advances.
- *
- *----------------------------------------------------------------------
- */
-
-static int
-ReadIHDR(
-    Tcl_Interp *interp,
-    PNGImage *pngPtr)
-{
-    unsigned char sigBuf[PNG_SIG_SZ];
-    unsigned long chunkType;
-    int chunkSz;
-    unsigned long crc;
-    unsigned long width, height;
-    int mismatch;
-
-    /*
-     * Read the appropriate number of bytes for the PNG signature.
-     */
-
-    if (ReadData(interp, pngPtr, sigBuf, PNG_SIG_SZ, NULL) == TCL_ERROR) {
-	return TCL_ERROR;
-    }
-
-    /*
-     * Compare the read bytes to the expected signature.
-     */
-
-    mismatch = memcmp(sigBuf, pngSignature, PNG_SIG_SZ);
-
-    /*
-     * If reading from string, reset position and try base64 decode.
-     */
-
-    if (mismatch && pngPtr->strDataBuf) {
-	pngPtr->strDataBuf = Tcl_GetByteArrayFromObj(pngPtr->objDataPtr,
-		&pngPtr->strDataLen);
-	pngPtr->base64Data = pngPtr->strDataBuf;
-
-	if (ReadData(interp, pngPtr, sigBuf, PNG_SIG_SZ, NULL) == TCL_ERROR) {
-	    return TCL_ERROR;
-	}
-
-	mismatch = memcmp(sigBuf, pngSignature, PNG_SIG_SZ);
-    }
-
-    if (mismatch) {
-	Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		"data stream does not have a PNG signature", -1));
-	Tcl_SetErrorCode(interp, "TK", "IMAGE", "PNG", "NO_SIG", NULL);
-	return TCL_ERROR;
-    }
-
-    if (ReadChunkHeader(interp, pngPtr, &chunkSz, &chunkType,
-	    &crc) == TCL_ERROR) {
-	return TCL_ERROR;
-    }
-
-    /*
-     * Read in the IHDR (header) chunk for width, height, etc.
-     *
-     * The first chunk in the file must be the IHDR (headr) chunk.
-     */
-
-    if (chunkType != CHUNK_IHDR) {
-	Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		"expected IHDR chunk type", -1));
-	Tcl_SetErrorCode(interp, "TK", "IMAGE", "PNG", "NO_IHDR", NULL);
-	return TCL_ERROR;
-    }
-
-    if (chunkSz != 13) {
-	Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		"invalid IHDR chunk size", -1));
-	Tcl_SetErrorCode(interp, "TK", "IMAGE", "PNG", "BAD_IHDR", NULL);
-	return TCL_ERROR;
-    }
-
-    /*
-     * Read and verify the image width and height to be sure Tk can handle its
-     * dimensions. The PNG specification does not permit zero-width or
-     * zero-height images.
-     */
-
-    if (ReadInt32(interp, pngPtr, &width, &crc) == TCL_ERROR) {
-	return TCL_ERROR;
-    }
-
-    if (ReadInt32(interp, pngPtr, &height, &crc) == TCL_ERROR) {
-	return TCL_ERROR;
-    }
-
-    if (!width || !height || (width > INT_MAX) || (height > INT_MAX)) {
-	Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		"image dimensions are invalid or beyond architecture limits",
-		-1));
-	Tcl_SetErrorCode(interp, "TK", "IMAGE", "PNG", "DIMENSIONS", NULL);
-	return TCL_ERROR;
-    }
-
-    /*
-     * Set height and width for the Tk photo block.
-     */
-
-    pngPtr->block.width = (int) width;
-    pngPtr->block.height = (int) height;
-
-    /*
-     * Read and the Bit Depth and Color Type.
-     */
-
-    if (ReadData(interp, pngPtr, &pngPtr->bitDepth, 1, &crc) == TCL_ERROR) {
-	return TCL_ERROR;
-    }
-
-    if (ReadData(interp, pngPtr, &pngPtr->colorType, 1, &crc) == TCL_ERROR) {
-	return TCL_ERROR;
-    }
-
-    /*
-     * Verify that the color type is valid, the bit depth is allowed for the
-     * color type, and calculate the number of channels and pixel depth (bits
-     * per pixel * channels). Also set up offsets and sizes in the Tk photo
-     * block for the pixel data.
-     */
-
-    if (CheckColor(interp, pngPtr) == TCL_ERROR) {
-	return TCL_ERROR;
-    }
-
-    /*
-     * Only one compression method is currently defined by the standard.
-     */
-
-    if (ReadData(interp, pngPtr, &pngPtr->compression, 1, &crc) == TCL_ERROR) {
-	return TCL_ERROR;
-    }
-
-    if (pngPtr->compression != PNG_COMPRESS_DEFLATE) {
-	Tcl_SetObjResult(interp, Tcl_ObjPrintf(
-		"unknown compression method %d", pngPtr->compression));
-	Tcl_SetErrorCode(interp, "TK", "IMAGE", "PNG", "BAD_COMPRESS", NULL);
-	return TCL_ERROR;
-    }
-
-    /*
-     * Only one filter method is currently defined by the standard; the method
-     * has five actual filter types associated with it.
-     */
-
-    if (ReadData(interp, pngPtr, &pngPtr->filter, 1, &crc) == TCL_ERROR) {
-	return TCL_ERROR;
-    }
-
-    if (pngPtr->filter != PNG_FILTMETH_STANDARD) {
-	Tcl_SetObjResult(interp, Tcl_ObjPrintf(
-		"unknown filter method %d", pngPtr->filter));
-	Tcl_SetErrorCode(interp, "TK", "IMAGE", "PNG", "BAD_FILTER", NULL);
-	return TCL_ERROR;
-    }
-
-    if (ReadData(interp, pngPtr, &pngPtr->interlace, 1, &crc) == TCL_ERROR) {
-	return TCL_ERROR;
-    }
-
-    switch (pngPtr->interlace) {
-    case PNG_INTERLACE_NONE:
-    case PNG_INTERLACE_ADAM7:
-	break;
-
-    default:
-	Tcl_SetObjResult(interp, Tcl_ObjPrintf(
-		"unknown interlace method %d", pngPtr->interlace));
-	Tcl_SetErrorCode(interp, "TK", "IMAGE", "PNG", "BAD_INTERLACE", NULL);
-	return TCL_ERROR;
-    }
-
-    return CheckCRC(interp, pngPtr, crc);
-}
-
-/*
- *----------------------------------------------------------------------
- *
- * ReadPLTE --
- *
- *	This function reads the PLTE (indexed color palette) chunk data from
- *	the PNG file and populates the palette table in the PNGImage
- *	structure.
- *
- * Results:
- *	TCL_OK, or TCL_ERROR if an I/O error occurs or the PLTE chunk is
- *	invalid.
- *
- * Side effects:
- *	The access position in f advances.
- *
- *----------------------------------------------------------------------
- */
-
-static int
-ReadPLTE(
-    Tcl_Interp *interp,
-    PNGImage *pngPtr,
-    int chunkSz,
-    unsigned long crc)
-{
-    unsigned char buffer[PNG_PLTE_MAXSZ];
-    int i, c;
-
-    /*
-     * This chunk is mandatory for color type 3 and forbidden for 2 and 6.
-     */
-
-    switch (pngPtr->colorType) {
-    case PNG_COLOR_GRAY:
-    case PNG_COLOR_GRAYALPHA:
-	Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		"PLTE chunk type forbidden for grayscale", -1));
-	Tcl_SetErrorCode(interp, "TK", "IMAGE", "PNG", "PLTE_UNEXPECTED",
-		NULL);
-	return TCL_ERROR;
-
-    default:
-	break;
-    }
-
-    /*
-     * The palette chunk contains from 1 to 256 palette entries. Each entry
-     * consists of a 3-byte RGB value. It must therefore contain a non-zero
-     * multiple of 3 bytes, up to 768.
-     */
-
-    if (!chunkSz || (chunkSz > PNG_PLTE_MAXSZ) || (chunkSz % 3)) {
-	Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		"invalid palette chunk size", -1));
-	Tcl_SetErrorCode(interp, "TK", "IMAGE", "PNG", "BAD_PLTE", NULL);
-	return TCL_ERROR;
-    }
-
-    /*
-     * Read the palette contents and stash them for later, possibly.
-     */
-
-    if (ReadData(interp, pngPtr, buffer, chunkSz, &crc) == TCL_ERROR) {
-	return TCL_ERROR;
-    }
-
-    if (CheckCRC(interp, pngPtr, crc) == TCL_ERROR) {
-	return TCL_ERROR;
-    }
-
-    /*
-     * Stash away the palette entries and entry count for later mapping each
-     * pixel's palette index to its color.
-     */
-
-    for (i=0, c=0 ; c<chunkSz ; i++) {
-	pngPtr->palette[i].red = buffer[c++];
-	pngPtr->palette[i].green = buffer[c++];
-	pngPtr->palette[i].blue = buffer[c++];
-    }
-
-    pngPtr->paletteLen = i;
-    return TCL_OK;
-}
-
-/*
- *----------------------------------------------------------------------
- *
- * ReadTRNS --
- *
- *	This function reads the tRNS (transparency) chunk data from the PNG
- *	file and populates the alpha field of the palette table in the
- *	PNGImage structure or the single color transparency, as appropriate
- *	for the color type.
- *
- * Results:
- *	TCL_OK, or TCL_ERROR if an I/O error occurs or the tRNS chunk is
- *	invalid.
- *
- * Side effects:
- *	The access position in f advances.
- *
- *----------------------------------------------------------------------
- */
-
-static int
-ReadTRNS(
-    Tcl_Interp *interp,
-    PNGImage *pngPtr,
-    int chunkSz,
-    unsigned long crc)
-{
-    unsigned char buffer[PNG_TRNS_MAXSZ];
-    int i;
-
-    if (pngPtr->colorType & PNG_COLOR_ALPHA) {
-	Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		"tRNS chunk not allowed color types with a full alpha channel",
-		-1));
-	Tcl_SetErrorCode(interp, "TK", "IMAGE", "PNG", "INVALID_TRNS", NULL);
-	return TCL_ERROR;
-    }
-
-    /*
-     * For indexed color, there is up to one single-byte transparency value
-     * per palette entry (thus a max of 256).
-     */
-
-    if (chunkSz > PNG_TRNS_MAXSZ) {
-	Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		"invalid tRNS chunk size", -1));
-	Tcl_SetErrorCode(interp, "TK", "IMAGE", "PNG", "BAD_TRNS", NULL);
-	return TCL_ERROR;
-    }
-
-    /*
-     * Read in the raw transparency information.
-     */
-
-    if (ReadData(interp, pngPtr, buffer, chunkSz, &crc) == TCL_ERROR) {
-	return TCL_ERROR;
-    }
-
-    if (CheckCRC(interp, pngPtr, crc) == TCL_ERROR) {
-	return TCL_ERROR;
-    }
-
-    switch (pngPtr->colorType) {
-    case PNG_COLOR_GRAYALPHA:
-    case PNG_COLOR_RGBA:
-	break;
-
-    case PNG_COLOR_PLTE:
-	/*
-	 * The number of tRNS entries must be less than or equal to the number
-	 * of PLTE entries, and consists of a single-byte alpha level for the
-	 * corresponding PLTE entry.
-	 */
-
-	if (chunkSz > pngPtr->paletteLen) {
-	    Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		    "size of tRNS chunk is too large for the palette", -1));
-	    Tcl_SetErrorCode(interp, "TK", "IMAGE", "PNG", "TRNS_SIZE", NULL);
-	    return TCL_ERROR;
-	}
-
-	for (i=0 ; i<chunkSz ; i++) {
-	    pngPtr->palette[i].alpha = buffer[i];
-	}
-	break;
-
-    case PNG_COLOR_GRAY:
-	/*
-	 * Grayscale uses a single 2-byte gray level, which we'll store in
-	 * palette index 0, since we're not using the palette.
-	 */
-
-	if (chunkSz != 2) {
-	    Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		    "invalid tRNS chunk size - must 2 bytes for grayscale",
-		    -1));
-	    Tcl_SetErrorCode(interp, "TK", "IMAGE", "PNG", "BAD_TRNS", NULL);
-	    return TCL_ERROR;
-	}
-
-	/*
-	 * According to the PNG specs, if the bit depth is less than 16, then
-	 * only the lower byte is used.
-	 */
-
-	if (16 == pngPtr->bitDepth) {
-	    pngPtr->transVal[0] = buffer[0];
-	    pngPtr->transVal[1] = buffer[1];
-	} else {
-	    pngPtr->transVal[0] = buffer[1];
-	}
-	pngPtr->useTRNS = 1;
-	break;
-
-    case PNG_COLOR_RGB:
-	/*
-	 * TrueColor uses a single RRGGBB triplet.
-	 */
-
-	if (chunkSz != 6) {
-	    Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		    "invalid tRNS chunk size - must 6 bytes for RGB", -1));
-	    Tcl_SetErrorCode(interp, "TK", "IMAGE", "PNG", "BAD_TRNS", NULL);
-	    return TCL_ERROR;
-	}
-
-	/*
-	 * According to the PNG specs, if the bit depth is less than 16, then
-	 * only the lower byte is used. But the tRNS chunk still contains two
-	 * bytes per channel.
-	 */
-
-	if (16 == pngPtr->bitDepth) {
-	    memcpy(pngPtr->transVal, buffer, 6);
-	} else {
-	    pngPtr->transVal[0] = buffer[1];
-	    pngPtr->transVal[1] = buffer[3];
-	    pngPtr->transVal[2] = buffer[5];
-	}
-	pngPtr->useTRNS = 1;
-	break;
-    }
-
-    return TCL_OK;
-}
-
-/*
- *----------------------------------------------------------------------
- *
- * Paeth --
- *
- *	Utility function for applying the Paeth filter to a pixel. The Paeth
- *	filter is a linear function of the pixel to be filtered and the pixels
- *	to the left, above, and above-left of the pixel to be unfiltered.
- *
- * Results:
- *	Result of the Paeth function for the left, above, and above-left
- *	pixels.
- *
- * Side effects:
- *	None
- *
- *----------------------------------------------------------------------
- */
-
-static inline unsigned char
-Paeth(
-    int a,
-    int b,
-    int c)
-{
-    int pa = abs(b - c);
-    int pb = abs(a - c);
-    int pc = abs(a + b - c - c);
-
-    if ((pa <= pb) && (pa <= pc)) {
-	return (unsigned char) a;
-    }
-
-    if (pb <= pc) {
-	return (unsigned char) b;
-    }
-
-    return (unsigned char) c;
-}
-
-/*
- *----------------------------------------------------------------------
- *
- * UnfilterLine --
- *
- *	Applies the filter algorithm specified in first byte of a line to the
- *	line of pixels being read from a PNG image.
- *
- *	PNG specifies four filter algorithms (Sub, Up, Average, and Paeth)
- *	that combine a pixel's value with those of other pixels in the same
- *	and/or previous lines. Filtering is intended to make an image more
- *	compressible.
- *
- * Results:
- *	TCL_OK, or TCL_ERROR if the filter type is not recognized.
- *
- * Side effects:
- *	Pixel data in thisLineObj are modified.
- *
- *----------------------------------------------------------------------
- */
-
-static int
-UnfilterLine(
-    Tcl_Interp *interp,
-    PNGImage *pngPtr)
-{
-    unsigned char *thisLine =
-	    Tcl_GetByteArrayFromObj(pngPtr->thisLineObj, NULL);
-    unsigned char *lastLine =
-	    Tcl_GetByteArrayFromObj(pngPtr->lastLineObj, NULL);
-
-#define	PNG_FILTER_NONE		0
-#define	PNG_FILTER_SUB		1
-#define	PNG_FILTER_UP		2
-#define	PNG_FILTER_AVG		3
-#define	PNG_FILTER_PAETH	4
-
-    switch (*thisLine) {
-    case PNG_FILTER_NONE:	/* Nothing to do */
-	break;
-    case PNG_FILTER_SUB: {	/* Sub(x) = Raw(x) - Raw(x-bpp) */
-	unsigned char *rawBpp = thisLine + 1;
-	unsigned char *raw = rawBpp + pngPtr->bytesPerPixel;
-	unsigned char *end = thisLine + pngPtr->phaseSize;
-
-	while (raw < end) {
-	    *raw++ += *rawBpp++;
-	}
-	break;
-    }
-    case PNG_FILTER_UP:		/* Up(x) = Raw(x) - Prior(x) */
-	if (pngPtr->currentLine > startLine[pngPtr->phase]) {
-	    unsigned char *prior = lastLine + 1;
-	    unsigned char *raw = thisLine + 1;
-	    unsigned char *end = thisLine + pngPtr->phaseSize;
-
-	    while (raw < end) {
-		*raw++ += *prior++;
-	    }
-	}
-	break;
-    case PNG_FILTER_AVG:
-	/* Avg(x) = Raw(x) - floor((Raw(x-bpp)+Prior(x))/2) */
-	if (pngPtr->currentLine > startLine[pngPtr->phase]) {
-	    unsigned char *prior = lastLine + 1;
-	    unsigned char *rawBpp = thisLine + 1;
-	    unsigned char *raw = rawBpp;
-	    unsigned char *end = thisLine + pngPtr->phaseSize;
-	    unsigned char *end2 = raw + pngPtr->bytesPerPixel;
-
-	    while ((raw < end2) && (raw < end)) {
-		*raw++ += *prior++ / 2;
-	    }
-
-	    while (raw < end) {
-		*raw++ += (unsigned char)
-			(((int) *rawBpp++ + (int) *prior++) / 2);
-	    }
-	} else {
-	    unsigned char *rawBpp = thisLine + 1;
-	    unsigned char *raw = rawBpp + pngPtr->bytesPerPixel;
-	    unsigned char *end = thisLine + pngPtr->phaseSize;
-
-	    while (raw < end) {
-		*raw++ += *rawBpp++ / 2;
-	    }
-	}
-	break;
-    case PNG_FILTER_PAETH:
-	/* Paeth(x) = Raw(x) - PaethPredictor(Raw(x-bpp), Prior(x), Prior(x-bpp)) */
-	if (pngPtr->currentLine > startLine[pngPtr->phase]) {
-	    unsigned char *priorBpp = lastLine + 1;
-	    unsigned char *prior = priorBpp;
-	    unsigned char *rawBpp = thisLine + 1;
-	    unsigned char *raw = rawBpp;
-	    unsigned char *end = thisLine + pngPtr->phaseSize;
-	    unsigned char *end2 = rawBpp + pngPtr->bytesPerPixel;
-
-	    while ((raw < end) && (raw < end2)) {
-		*raw++ += *prior++;
-	    }
-
-	    while (raw < end) {
-		*raw++ += Paeth(*rawBpp++, *prior++, *priorBpp++);
-	    }
-	} else {
-	    unsigned char *rawBpp = thisLine + 1;
-	    unsigned char *raw = rawBpp + pngPtr->bytesPerPixel;
-	    unsigned char *end = thisLine + pngPtr->phaseSize;
-
-	    while (raw < end) {
-		*raw++ += *rawBpp++;
-	    }
-	}
-	break;
-    default:
-	Tcl_SetObjResult(interp, Tcl_ObjPrintf(
-		"invalid filter type %d", *thisLine));
-	Tcl_SetErrorCode(interp, "TK", "IMAGE", "PNG", "BAD_FILTER", NULL);
-	return TCL_ERROR;
-    }
-
-    return TCL_OK;
-}
-
-/*
- *----------------------------------------------------------------------
- *
- * DecodeLine --
- *
- *	Unfilters a line of pixels from the PNG source data and decodes the
- *	data into the Tk_PhotoImageBlock for later copying into the Tk image.
- *
- * Results:
- *	TCL_OK, or TCL_ERROR if the filter type is not recognized.
- *
- * Side effects:
- *	Pixel data in thisLine and block are modified and state information
- *	updated.
- *
- *----------------------------------------------------------------------
- */
-
-static int
-DecodeLine(
-    Tcl_Interp *interp,
-    PNGImage *pngPtr)
-{
-    unsigned char *pixelPtr = pngPtr->block.pixelPtr;
-    int colNum = 0;		/* Current pixel column */
-    unsigned char chan = 0;	/* Current channel (0..3) = (R, G, B, A) */
-    unsigned char readByte = 0;	/* Current scan line byte */
-    int haveBits = 0;		/* Number of bits remaining in current byte */
-    unsigned char pixBits = 0;	/* Extracted bits for current channel */
-    int shifts = 0;		/* Number of channels extracted from byte */
-    int offset = 0;		/* Current offset into pixelPtr */
-    int colStep = 1;		/* Column increment each pass */
-    int pixStep = 0;		/* extra pixelPtr increment each pass */
-    unsigned char lastPixel[6];
-    unsigned char *p = Tcl_GetByteArrayFromObj(pngPtr->thisLineObj, NULL);
-
-    p++;
-    if (UnfilterLine(interp, pngPtr) == TCL_ERROR) {
-	return TCL_ERROR;
-    }
-    if (pngPtr->currentLine >= pngPtr->block.height) {
-	Tcl_SetObjResult(interp, Tcl_ObjPrintf(
-		"PNG image data overflow"));
-	Tcl_SetErrorCode(interp, "TK", "IMAGE", "PNG", "DATA_OVERFLOW", NULL);
-	return TCL_ERROR;
-    }
-
-
-    if (pngPtr->interlace) {
-	switch (pngPtr->phase) {
-	case 1:			/* Phase 1: */
-	    colStep = 8;	/* 1 pixel per block of 8 per line */
-	    break;		/* Start at column 0 */
-	case 2:			/* Phase 2: */
-	    colStep = 8;	/* 1 pixels per block of 8 per line */
-	    colNum = 4;		/* Start at column 4 */
-	    break;
-	case 3:			/* Phase 3: */
-	    colStep = 4;	/* 2 pixels per block of 8 per line */
-	    break;		/* Start at column 0 */
-	case 4:			/* Phase 4: */
-	    colStep = 4;	/* 2 pixels per block of 8 per line */
-	    colNum = 2;		/* Start at column 2 */
-	    break;
-	case 5:			/* Phase 5: */
-	    colStep = 2;	/* 4 pixels per block of 8 per line */
-	    break;		/* Start at column 0 */
-	case 6:			/* Phase 6: */
-	    colStep = 2;	/* 4 pixels per block of 8 per line */
-	    colNum = 1;		/* Start at column 1 */
-	    break;
-				/* Phase 7: */
-				/* 8 pixels per block of 8 per line */
-				/* Start at column 0 */
-	}
-    }
-
-    /*
-     * Calculate offset into pixelPtr for the first pixel of the line.
-     */
-
-    offset = pngPtr->currentLine * pngPtr->block.pitch;
-
-    /*
-     * Adjust up for the starting pixel of the line.
-     */
-
-    offset += colNum * pngPtr->block.pixelSize;
-
-    /*
-     * Calculate the extra number of bytes to skip between columns.
-     */
-
-    pixStep = (colStep - 1) * pngPtr->block.pixelSize;
-
-    for ( ; colNum < pngPtr->block.width ; colNum += colStep) {
-	if (haveBits < (pngPtr->bitDepth * pngPtr->numChannels)) {
-	    haveBits = 0;
-	}
-
-	for (chan = 0 ; chan < pngPtr->numChannels ; chan++) {
-	    if (!haveBits) {
-		shifts = 0;
-		readByte = *p++;
-		haveBits += 8;
-	    }
-
-	    if (16 == pngPtr->bitDepth) {
-		pngPtr->block.pixelPtr[offset++] = readByte;
-
-		if (pngPtr->useTRNS) {
-		    lastPixel[chan * 2] = readByte;
-		}
-
-		readByte = *p++;
-
-		if (pngPtr->useTRNS) {
-		    lastPixel[(chan * 2) + 1] = readByte;
-		}
-
-		pngPtr->block.pixelPtr[offset++] = readByte;
-
-		haveBits = 0;
-		continue;
-	    }
-
-	    switch (pngPtr->bitDepth) {
-	    case 1:
-		pixBits = (unsigned char)((readByte >> (7-shifts)) & 0x01);
-		break;
-	    case 2:
-		pixBits = (unsigned char)((readByte >> (6-shifts*2)) & 0x03);
-		break;
-	    case 4:
-		pixBits = (unsigned char)((readByte >> (4-shifts*4)) & 0x0f);
-		break;
-	    case 8:
-		pixBits = readByte;
-		break;
-	    }
-
-	    if (PNG_COLOR_PLTE == pngPtr->colorType) {
-		pixelPtr[offset++] = pngPtr->palette[pixBits].red;
-		pixelPtr[offset++] = pngPtr->palette[pixBits].green;
-		pixelPtr[offset++] = pngPtr->palette[pixBits].blue;
-		pixelPtr[offset++] = pngPtr->palette[pixBits].alpha;
-		chan += 2;
-	    } else {
-		pixelPtr[offset++] = (unsigned char)
-			(pixBits * pngPtr->bitScale);
-
-		if (pngPtr->useTRNS) {
-		    lastPixel[chan] = pixBits;
-		}
-	    }
-
-	    haveBits -= pngPtr->bitDepth;
-	    shifts++;
-	}
-
-	/*
-	 * Apply boolean transparency via tRNS data if necessary (where
-	 * necessary means a tRNS chunk was provided and we're not using an
-	 * alpha channel or indexed alpha).
-	 */
-
-	if ((PNG_COLOR_PLTE != pngPtr->colorType) &&
-		!(pngPtr->colorType & PNG_COLOR_ALPHA)) {
-	    unsigned char alpha;
-
-	    if (pngPtr->useTRNS) {
-		if (memcmp(lastPixel, pngPtr->transVal,
-			pngPtr->bytesPerPixel) == 0) {
-		    alpha = 0x00;
-		} else {
-		    alpha = 0xff;
-		}
-	    } else {
-		alpha = 0xff;
-	    }
-
-	    pixelPtr[offset++] = alpha;
-
-	    if (16 == pngPtr->bitDepth) {
-		pixelPtr[offset++] = alpha;
-	    }
-	}
-
-	offset += pixStep;
-    }
-
-    if (pngPtr->interlace) {
-	/* Skip lines */
-
-	switch (pngPtr->phase) {
-	case 1: case 2: case 3:
-	    pngPtr->currentLine += 8;
-	    break;
-	case 4: case 5:
-	    pngPtr->currentLine += 4;
-	    break;
-	case 6: case 7:
-	    pngPtr->currentLine += 2;
-	    break;
-	}
-
-	/*
-	 * Start the next phase if there are no more lines to do.
-	 */
-
-	if (pngPtr->currentLine >= pngPtr->block.height) {
-	    unsigned long pixels = 0;
-
-	    while ((!pixels || (pngPtr->currentLine >= pngPtr->block.height))
-		    && (pngPtr->phase < 7)) {
-		pngPtr->phase++;
-
-		switch (pngPtr->phase) {
-		case 2:
-		    pixels = (pngPtr->block.width + 3) >> 3;
-		    pngPtr->currentLine = 0;
-		    break;
-		case 3:
-		    pixels = (pngPtr->block.width + 3) >> 2;
-		    pngPtr->currentLine = 4;
-		    break;
-		case 4:
-		    pixels = (pngPtr->block.width + 1) >> 2;
-		    pngPtr->currentLine = 0;
-		    break;
-		case 5:
-		    pixels = (pngPtr->block.width + 1) >> 1;
-		    pngPtr->currentLine = 2;
-		    break;
-		case 6:
-		    pixels = pngPtr->block.width >> 1;
-		    pngPtr->currentLine = 0;
-		    break;
-		case 7:
-		    pngPtr->currentLine = 1;
-		    pixels = pngPtr->block.width;
-		    break;
-		}
-	    }
-
-	    if (16 == pngPtr->bitDepth) {
-		pngPtr->phaseSize = 1 + (pngPtr->numChannels * pixels * 2);
-	    } else {
-		pngPtr->phaseSize = 1 + ((pngPtr->numChannels * pixels *
-			pngPtr->bitDepth + 7) >> 3);
-	    }
-	}
-    } else {
-	pngPtr->currentLine++;
-    }
-
-    return TCL_OK;
-}
-
-/*
- *----------------------------------------------------------------------
- *
- * ReadIDAT --
- *
- *	This function reads the IDAT (pixel data) chunk from the PNG file to
- *	build the image. It will continue reading until all IDAT chunks have
- *	been processed or an error occurs.
- *
- * Results:
- *	TCL_OK, or TCL_ERROR if an I/O error occurs or an IDAT chunk is
- *	invalid.
- *
- * Side effects:
- *	The access position in f advances. Memory may be allocated by zlib
- *	through PNGZAlloc.
- *
- *----------------------------------------------------------------------
- */
-
-static int
-ReadIDAT(
-    Tcl_Interp *interp,
-    PNGImage *pngPtr,
-    int chunkSz,
-    unsigned long crc)
-{
-    /*
-     * Process IDAT contents until there is no more in this chunk.
-     */
-
-    while (chunkSz && !Tcl_ZlibStreamEof(pngPtr->stream)) {
-	int len1, len2;
-
-	/*
-	 * Read another block of input into the zlib stream if data remains.
-	 */
-
-	if (chunkSz) {
-	    Tcl_Obj *inputObj = NULL;
-	    int blockSz = PNG_MIN(chunkSz, PNG_BLOCK_SZ);
-	    unsigned char *inputPtr = NULL;
-
-	    /*
-	     * Check for end of zlib stream.
-	     */
-
-	    if (Tcl_ZlibStreamEof(pngPtr->stream)) {
-		Tcl_SetObjResult(interp, Tcl_NewStringObj(
-			"extra data after end of zlib stream", -1));
-		Tcl_SetErrorCode(interp, "TK", "IMAGE", "PNG", "EXTRA_DATA",
-			NULL);
-		return TCL_ERROR;
-	    }
-
-	    inputObj = Tcl_NewObj();
-	    Tcl_IncrRefCount(inputObj);
-	    inputPtr = Tcl_SetByteArrayLength(inputObj, blockSz);
-
-	    /*
-	     * Read the next bit of IDAT chunk data, up to read buffer size.
-	     */
-
-	    if (ReadData(interp, pngPtr, inputPtr, blockSz,
-		    &crc) == TCL_ERROR) {
-		Tcl_DecrRefCount(inputObj);
-		return TCL_ERROR;
-	    }
-
-	    chunkSz -= blockSz;
-
-	    Tcl_ZlibStreamPut(pngPtr->stream, inputObj, TCL_ZLIB_NO_FLUSH);
-	    Tcl_DecrRefCount(inputObj);
-	}
-
-	/*
-	 * Inflate, processing each output buffer's worth as a line of pixels,
-	 * until we cannot fill the buffer any more.
-	 */
-
-    getNextLine:
-	Tcl_GetByteArrayFromObj(pngPtr->thisLineObj, &len1);
-	if (Tcl_ZlibStreamGet(pngPtr->stream, pngPtr->thisLineObj,
-		pngPtr->phaseSize - len1) == TCL_ERROR) {
-	    return TCL_ERROR;
-	}
-	Tcl_GetByteArrayFromObj(pngPtr->thisLineObj, &len2);
-
-	if (len2 == pngPtr->phaseSize) {
-	    if (pngPtr->phase > 7) {
-		Tcl_SetObjResult(interp, Tcl_NewStringObj(
-			"extra data after final scan line of final phase",
-			-1));
-		Tcl_SetErrorCode(interp, "TK", "IMAGE", "PNG", "EXTRA_DATA",
-			NULL);
-		return TCL_ERROR;
-	    }
-
-	    if (DecodeLine(interp, pngPtr) == TCL_ERROR) {
-		return TCL_ERROR;
-	    }
-
-	    /*
-	     * Swap the current/last lines so that we always have the last
-	     * line processed available, which is necessary for filtering.
-	     */
-
-	    {
-		Tcl_Obj *temp = pngPtr->lastLineObj;
-
-		pngPtr->lastLineObj = pngPtr->thisLineObj;
-		pngPtr->thisLineObj = temp;
-	    }
-	    Tcl_SetByteArrayLength(pngPtr->thisLineObj, 0);
-
-	    /*
-	     * Try to read another line of pixels out of the buffer
-	     * immediately, but don't allow write past end of block.
-	     */
-
-	    if (pngPtr->currentLine < pngPtr->block.height) {
-		goto getNextLine;
-	    }
-
-	}
-
-	/*
-	 * Got less than a whole buffer-load of pixels. Either we're going to
-	 * be getting more data from the next IDAT, or we've done what we can
-	 * here.
-	 */
-    }
-
-    /*
-     * Ensure that if we've got to the end of the compressed data, we've
-     * also got to the end of the compressed stream. This sanity check is
-     * enforced by most PNG readers.
-     */
-
-    if (chunkSz != 0) {
-	Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		"compressed data after stream finalize in PNG data", -1));
-	Tcl_SetErrorCode(interp, "TK", "IMAGE", "PNG", "EXTRA_DATA", NULL);
-	return TCL_ERROR;
-    }
-
-    return CheckCRC(interp, pngPtr, crc);
-}
-
-/*
- *----------------------------------------------------------------------
- *
- * ApplyAlpha --
- *
- *	Applies an overall alpha value to a complete image that has been read.
- *	This alpha value is specified using the -format option to [image
- *	create photo].
- *
- * Results:
- *	N/A
- *
- * Side effects:
- *	The access position in f may change.
- *
- *----------------------------------------------------------------------
- */
-
-static void
-ApplyAlpha(
-    PNGImage *pngPtr)
-{
-    if (pngPtr->alpha != 1.0) {
-	register unsigned char *p = pngPtr->block.pixelPtr;
-	unsigned char *endPtr = p + pngPtr->blockLen;
-	int offset = pngPtr->block.offset[3];
-
-	p += offset;
-
-	if (16 == pngPtr->bitDepth) {
-	    register unsigned int channel;
-
-	    while (p < endPtr) {
-		channel = (unsigned int)
-			(((p[0] << 8) | p[1]) * pngPtr->alpha);
-
-		*p++ = (unsigned char) (channel >> 8);
-		*p++ = (unsigned char) (channel & 0xff);
-
-		p += offset;
-	    }
-	} else {
-	    while (p < endPtr) {
-		p[0] = (unsigned char) (pngPtr->alpha * p[0]);
-		p += 1 + offset;
-	    }
-	}
-    }
-}
-
-/*
- *----------------------------------------------------------------------
- *
- * ParseFormat --
- *
- *	This function parses the -format string that can be specified to the
- *	[image create photo] command to extract options for postprocessing of
- *	loaded images. Currently, this just allows specifying and applying an
- *	overall alpha value to the loaded image (for example, to make it
- *	entirely 50% as transparent as the actual image file).
- *
- * Results:
- *	TCL_OK, or TCL_ERROR if the format specification is invalid.
- *
- * Side effects:
- *	None
- *
- *----------------------------------------------------------------------
- */
-
-static int
-ParseFormat(
-    Tcl_Interp *interp,
-    Tcl_Obj *fmtObj,
-    PNGImage *pngPtr)
-{
-    Tcl_Obj **objv = NULL;
-    int objc = 0;
-    static const char *const fmtOptions[] = {
-	"-alpha", NULL
-    };
-    enum fmtOptions {
-	OPT_ALPHA
-    };
-
-    /*
-     * Extract elements of format specification as a list.
-     */
-
-    if (fmtObj &&
-	    Tcl_ListObjGetElements(interp, fmtObj, &objc, &objv) != TCL_OK) {
-	return TCL_ERROR;
-    }
-
-    for (; objc>0 ; objc--, objv++) {
-	int optIndex;
-
-	/*
-	 * Ignore the "png" part of the format specification.
-	 */
-
-	if (!strcasecmp(Tcl_GetString(objv[0]), "png")) {
-	    continue;
-	}
-
-	if (Tcl_GetIndexFromObjStruct(interp, objv[0], fmtOptions,
-		sizeof(char *), "option", 0, &optIndex) == TCL_ERROR) {
-	    return TCL_ERROR;
-	}
-
-	if (objc < 2) {
-	    Tcl_WrongNumArgs(interp, 1, objv, "value");
-	    return TCL_ERROR;
-	}
-
-	objc--;
-	objv++;
-
-	switch ((enum fmtOptions) optIndex) {
-	case OPT_ALPHA:
-	    if (Tcl_GetDoubleFromObj(interp, objv[0],
-		    &pngPtr->alpha) == TCL_ERROR) {
-		return TCL_ERROR;
-	    }
-
-	    if ((pngPtr->alpha < 0.0) || (pngPtr->alpha > 1.0)) {
-		Tcl_SetObjResult(interp, Tcl_NewStringObj(
-			"-alpha value must be between 0.0 and 1.0", -1));
-		Tcl_SetErrorCode(interp, "TK", "IMAGE", "PNG", "BAD_ALPHA",
-			NULL);
-		return TCL_ERROR;
-	    }
-	    break;
-	}
-    }
-
-    return TCL_OK;
-}
-
-/*
- *----------------------------------------------------------------------
- *
- * DecodePNG --
- *
- *	This function handles the entirety of reading a PNG file (or data)
- *	from the first byte to the last.
- *
- * Results:
- *	TCL_OK, or TCL_ERROR if an I/O error occurs or any problems are
- *	detected in the PNG file.
- *
- * Side effects:
- *	The access position in f advances. Memory may be allocated and image
- *	dimensions and contents may change.
- *
- *----------------------------------------------------------------------
- */
-
-static int
-DecodePNG(
-    Tcl_Interp *interp,
-    PNGImage *pngPtr,
-    Tcl_Obj *fmtObj,
-    Tk_PhotoHandle imageHandle,
-    int destX,
-    int destY)
-{
-    unsigned long chunkType;
-    int chunkSz;
-    unsigned long crc;
-
-    /*
-     * Parse the PNG signature and IHDR (header) chunk.
-     */
-
-    if (ReadIHDR(interp, pngPtr) == TCL_ERROR) {
-	return TCL_ERROR;
-    }
-
-    /*
-     * Extract alpha value from -format object, if specified.
-     */
-
-    if (ParseFormat(interp, fmtObj, pngPtr) == TCL_ERROR) {
-	return TCL_ERROR;
-    }
-
-    /*
-     * The next chunk may either be a PLTE (Palette) chunk or the first of at
-     * least one IDAT (data) chunks. It could also be one of a number of
-     * ancillary chunks, but those are skipped for us by the switch in
-     * ReadChunkHeader().
-     *
-     * PLTE is mandatory for color type 3 and forbidden for 2 and 6
-     */
-
-    if (ReadChunkHeader(interp, pngPtr, &chunkSz, &chunkType,
-	    &crc) == TCL_ERROR) {
-	return TCL_ERROR;
-    }
-
-    if (CHUNK_PLTE == chunkType) {
-	/*
-	 * Finish parsing the PLTE chunk.
-	 */
-
-	if (ReadPLTE(interp, pngPtr, chunkSz, crc) == TCL_ERROR) {
-	    return TCL_ERROR;
-	}
-
-	/*
-	 * Begin the next chunk.
-	 */
-
-	if (ReadChunkHeader(interp, pngPtr, &chunkSz, &chunkType,
-		&crc) == TCL_ERROR) {
-	    return TCL_ERROR;
-	}
-    } else if (PNG_COLOR_PLTE == pngPtr->colorType) {
-	Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		"PLTE chunk required for indexed color", -1));
-	Tcl_SetErrorCode(interp, "TK", "IMAGE", "PNG", "NEED_PLTE", NULL);
-	return TCL_ERROR;
-    }
-
-    /*
-     * The next chunk may be a tRNS (palette transparency) chunk, depending on
-     * the color type. It must come after the PLTE chunk and before the IDAT
-     * chunk, but can be present if there is no PLTE chunk because it can be
-     * used for Grayscale and TrueColor in lieu of an alpha channel.
-     */
-
-    if (CHUNK_tRNS == chunkType) {
-	/*
-	 * Finish parsing the tRNS chunk.
-	 */
-
-	if (ReadTRNS(interp, pngPtr, chunkSz, crc) == TCL_ERROR) {
-	    return TCL_ERROR;
-	}
-
-	/*
-	 * Begin the next chunk.
-	 */
-
-	if (ReadChunkHeader(interp, pngPtr, &chunkSz, &chunkType,
-		&crc) == TCL_ERROR) {
-	    return TCL_ERROR;
-	}
-    }
-
-    /*
-     * Other ancillary chunk types could appear here, but for now we're only
-     * interested in IDAT. The others should have been skipped.
-     */
-
-    if (chunkType != CHUNK_IDAT) {
-	Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		"at least one IDAT chunk is required", -1));
-	Tcl_SetErrorCode(interp, "TK", "IMAGE", "PNG", "NEED_IDAT", NULL);
-	return TCL_ERROR;
-    }
-
-    /*
-     * Expand the photo size (if not set by the user) to provide enough space
-     * for the image being parsed. It does not matter if width or height wrap
-     * to negative here: Tk will not shrink the image.
-     */
-
-    if (Tk_PhotoExpand(interp, imageHandle, destX + pngPtr->block.width,
-	    destY + pngPtr->block.height) == TCL_ERROR) {
-	return TCL_ERROR;
-    }
-
-    /*
-     * A scan line consists of one byte for a filter type, plus the number of
-     * bits per color sample times the number of color samples per pixel.
-     */
-
-    if (pngPtr->block.width > ((INT_MAX - 1) / (pngPtr->numChannels * 2))) {
-	Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		"line size is out of supported range on this architecture",
-		-1));
-	Tcl_SetErrorCode(interp, "TK", "IMAGE", "PNG", "LINE_SIZE", NULL);
-	return TCL_ERROR;
-    }
-
-    if (16 == pngPtr->bitDepth) {
-	pngPtr->lineSize = 1 + (pngPtr->numChannels * pngPtr->block.width*2);
-    } else {
-	pngPtr->lineSize = 1 + ((pngPtr->numChannels * pngPtr->block.width) /
-		(8 / pngPtr->bitDepth));
-	if (pngPtr->block.width % (8 / pngPtr->bitDepth)) {
-	    pngPtr->lineSize++;
-	}
-    }
-
-    /*
-     * Allocate space for decoding the scan lines.
-     */
-
-    pngPtr->lastLineObj = Tcl_NewObj();
-    Tcl_IncrRefCount(pngPtr->lastLineObj);
-    pngPtr->thisLineObj = Tcl_NewObj();
-    Tcl_IncrRefCount(pngPtr->thisLineObj);
-
-    pngPtr->block.pixelPtr = attemptckalloc(pngPtr->blockLen);
-    if (!pngPtr->block.pixelPtr) {
-	Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		"memory allocation failed", -1));
-	Tcl_SetErrorCode(interp, "TK", "MALLOC", NULL);
-	return TCL_ERROR;
-    }
-
-    /*
-     * Determine size of the first phase if interlaced. Phase size should
-     * always be <= line size, so probably not necessary to check for
-     * arithmetic overflow here: should be covered by line size check.
-     */
-
-    if (pngPtr->interlace) {
-	/*
-	 * Only one pixel per block of 8 per line in the first phase.
-	 */
-
-	unsigned int pixels = (pngPtr->block.width + 7) >> 3;
-
-	pngPtr->phase = 1;
-	if (16 == pngPtr->bitDepth) {
-	    pngPtr->phaseSize = 1 + pngPtr->numChannels*pixels*2;
-	} else {
-	    pngPtr->phaseSize = 1 +
-		    ((pngPtr->numChannels*pixels*pngPtr->bitDepth + 7) >> 3);
-	}
-    } else {
-	pngPtr->phaseSize = pngPtr->lineSize;
-    }
-
-    /*
-     * All of the IDAT (data) chunks must be consecutive.
-     */
-
-    while (CHUNK_IDAT == chunkType) {
-	if (ReadIDAT(interp, pngPtr, chunkSz, crc) == TCL_ERROR) {
-	    return TCL_ERROR;
-	}
-
-	if (ReadChunkHeader(interp, pngPtr, &chunkSz, &chunkType,
-		&crc) == TCL_ERROR) {
-	    return TCL_ERROR;
-	}
-    }
-
-    /*
-     * Ensure that we've got to the end of the compressed stream now that
-     * there are no more IDAT segments. This sanity check is enforced by most
-     * PNG readers.
-     */
-
-    if (!Tcl_ZlibStreamEof(pngPtr->stream)) {
-	Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		"unfinalized data stream in PNG data", -1));
-	Tcl_SetErrorCode(interp, "TK", "IMAGE", "PNG", "EXTRA_DATA", NULL);
-	return TCL_ERROR;
-    }
-
-    /*
-     * Now skip the remaining chunks which we're also not interested in.
-     */
-
-    while (CHUNK_IEND != chunkType) {
-	if (SkipChunk(interp, pngPtr, chunkSz, crc) == TCL_ERROR) {
-	    return TCL_ERROR;
-	}
-
-	if (ReadChunkHeader(interp, pngPtr, &chunkSz, &chunkType,
-		&crc) == TCL_ERROR) {
-	    return TCL_ERROR;
-	}
-    }
-
-    /*
-     * Got the IEND (end of image) chunk. Do some final checks...
-     */
-
-    if (chunkSz) {
-	Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		"IEND chunk contents must be empty", -1));
-	Tcl_SetErrorCode(interp, "TK", "IMAGE", "PNG", "BAD_IEND", NULL);
-	return TCL_ERROR;
-    }
-
-    /*
-     * Check the CRC on the IEND chunk.
-     */
-
-    if (CheckCRC(interp, pngPtr, crc) == TCL_ERROR) {
-	return TCL_ERROR;
-    }
-
-    /*
-     * TODO: verify that nothing else comes after the IEND chunk, or do we
-     * really care?
-     */
-
-#if 0
-    if (ReadData(interp, pngPtr, &c, 1, NULL) != TCL_ERROR) {
-	Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		"extra data following IEND chunk", -1));
-	Tcl_SetErrorCode(interp, "TK", "IMAGE", "PNG", "BAD_IEND", NULL);
-	return TCL_ERROR;
-    }
-#endif
-
-    /*
-     * Apply overall image alpha if specified.
-     */
-
-    ApplyAlpha(pngPtr);
-
-    /*
-     * Copy the decoded image block into the Tk photo image.
-     */
-
-    if (Tk_PhotoPutBlock(interp, imageHandle, &pngPtr->block, destX, destY,
-	    pngPtr->block.width, pngPtr->block.height,
-	    TK_PHOTO_COMPOSITE_SET) == TCL_ERROR) {
-	return TCL_ERROR;
-    }
-
-    return TCL_OK;
-}
-
-/*
- *----------------------------------------------------------------------
- *
- * FileMatchPNG --
- *
- *	This function is invoked by the photo image type to see if a file
- *	contains image data in PNG format.
- *
- * Results:
- *	The return value is 1 if the first characters in file f look like PNG
- *	data, and 0 otherwise.
- *
- * Side effects:
- *	The access position in f may change.
- *
- *----------------------------------------------------------------------
- */
-
-static int
-FileMatchPNG(
-    Tcl_Channel chan,
-    const char *fileName,
-    Tcl_Obj *fmtObj,
-    int *widthPtr,
-    int *heightPtr,
-    Tcl_Interp *interp)
-{
-    PNGImage png;
-    int match = 0;
-
-    InitPNGImage(NULL, &png, chan, NULL, TCL_ZLIB_STREAM_INFLATE);
-
-    if (ReadIHDR(interp, &png) == TCL_OK) {
-	*widthPtr = png.block.width;
-	*heightPtr = png.block.height;
-	match = 1;
-    }
-
-    CleanupPNGImage(&png);
-
-    return match;
-}
-
-/*
- *----------------------------------------------------------------------
- *
- * FileReadPNG --
- *
- *	This function is called by the photo image type to read PNG format
- *	data from a file and write it into a given photo image.
- *
- * Results:
- *	A standard TCL completion code. If TCL_ERROR is returned then an error
- *	message is left in the interp's result.
- *
- * Side effects:
- *	The access position in file f is changed, and new data is added to the
- *	image given by imageHandle.
- *
- *----------------------------------------------------------------------
- */
-
-static int
-FileReadPNG(
-    Tcl_Interp *interp,
-    Tcl_Channel chan,
-    const char *fileName,
-    Tcl_Obj *fmtObj,
-    Tk_PhotoHandle imageHandle,
-    int destX,
-    int destY,
-    int width,
-    int height,
-    int srcX,
-    int srcY)
-{
-    PNGImage png;
-    int result = TCL_ERROR;
-
-    result = InitPNGImage(interp, &png, chan, NULL, TCL_ZLIB_STREAM_INFLATE);
-
-    if (TCL_OK == result) {
-	result = DecodePNG(interp, &png, fmtObj, imageHandle, destX, destY);
-    }
-
-    CleanupPNGImage(&png);
-    return result;
-}
-
-/*
- *----------------------------------------------------------------------
- *
- * StringMatchPNG --
- *
- *	This function is invoked by the photo image type to see if an object
- *	contains image data in PNG format.
- *
- * Results:
- *	The return value is 1 if the first characters in the data are like PNG
- *	data, and 0 otherwise.
- *
- * Side effects:
- *	The size of the image is placed in widthPre and heightPtr.
- *
- *----------------------------------------------------------------------
- */
-
-static int
-StringMatchPNG(
-    Tcl_Obj *pObjData,
-    Tcl_Obj *fmtObj,
-    int *widthPtr,
-    int *heightPtr,
-    Tcl_Interp *interp)
-{
-    PNGImage png;
-    int match = 0;
-
-    InitPNGImage(NULL, &png, NULL, pObjData, TCL_ZLIB_STREAM_INFLATE);
-
-    png.strDataBuf = Tcl_GetByteArrayFromObj(pObjData, &png.strDataLen);
-
-    if (ReadIHDR(interp, &png) == TCL_OK) {
-	*widthPtr = png.block.width;
-	*heightPtr = png.block.height;
-	match = 1;
-    }
-
-    CleanupPNGImage(&png);
-    return match;
-}
-
-/*
- *----------------------------------------------------------------------
- *
- * StringReadPNG --
- *
- *	This function is called by the photo image type to read PNG format
- *	data from an object and give it to the photo image.
- *
- * Results:
- *	A standard TCL completion code. If TCL_ERROR is returned then an error
- *	message is left in the interp's result.
- *
- * Side effects:
- *	New data is added to the image given by imageHandle.
- *
- *----------------------------------------------------------------------
- */
-
-static int
-StringReadPNG(
-    Tcl_Interp *interp,
-    Tcl_Obj *pObjData,
-    Tcl_Obj *fmtObj,
-    Tk_PhotoHandle imageHandle,
-    int destX,
-    int destY,
-    int width,
-    int height,
-    int srcX,
-    int srcY)
-{
-    PNGImage png;
-    int result = TCL_ERROR;
-
-    result = InitPNGImage(interp, &png, NULL, pObjData,
-	    TCL_ZLIB_STREAM_INFLATE);
-
-    if (TCL_OK == result) {
-	result = DecodePNG(interp, &png, fmtObj, imageHandle, destX, destY);
-    }
-
-    CleanupPNGImage(&png);
-    return result;
-}
-
-/*
- *----------------------------------------------------------------------
- *
- * WriteData --
- *
- *	This function writes a bytes from a buffer out to the PNG image.
- *
- * Results:
- *	TCL_OK, or TCL_ERROR if the write fails.
- *
- * Side effects:
- *	File or buffer will be modified.
- *
- *----------------------------------------------------------------------
- */
-
-static int
-WriteData(
-    Tcl_Interp *interp,
-    PNGImage *pngPtr,
-    const unsigned char *srcPtr,
-    int srcSz,
-    unsigned long *crcPtr)
-{
-    if (!srcPtr || !srcSz) {
-	return TCL_OK;
-    }
-
-    if (crcPtr) {
-	*crcPtr = Tcl_ZlibCRC32(*crcPtr, srcPtr, srcSz);
-    }
-
-    /*
-     * TODO: is Tcl_AppendObjToObj faster here? i.e., does Tcl join the
-     * objects immediately or store them in a multi-object rep?
-     */
-
-    if (pngPtr->objDataPtr) {
-	int objSz;
-	unsigned char *destPtr;
-
-	Tcl_GetByteArrayFromObj(pngPtr->objDataPtr, &objSz);
-
-	if (objSz > INT_MAX - srcSz) {
-	    Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		    "image too large to store completely in byte array", -1));
-	    Tcl_SetErrorCode(interp, "TK", "IMAGE", "PNG", "TOO_LARGE", NULL);
-	    return TCL_ERROR;
-	}
-
-	destPtr = Tcl_SetByteArrayLength(pngPtr->objDataPtr, objSz + srcSz);
-
-	if (!destPtr) {
-	    Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		    "memory allocation failed", -1));
-	    Tcl_SetErrorCode(interp, "TK", "MALLOC", NULL);
-	    return TCL_ERROR;
-	}
-
-	memcpy(destPtr+objSz, srcPtr, srcSz);
-    } else if (Tcl_Write(pngPtr->channel, (const char *) srcPtr, srcSz) < 0) {
-	Tcl_SetObjResult(interp, Tcl_ObjPrintf(
-		"write to channel failed: %s", Tcl_PosixError(interp)));
-	return TCL_ERROR;
-    }
-
-    return TCL_OK;
-}
-
-static inline int
-WriteByte(
-    Tcl_Interp *interp,
-    PNGImage *pngPtr,
-    unsigned char c,
-    unsigned long *crcPtr)
-{
-    return WriteData(interp, pngPtr, &c, 1, crcPtr);
-}
-
-/*
- *----------------------------------------------------------------------
- *
- * WriteInt32 --
- *
- *	This function writes a 32-bit integer value out to the PNG image as
- *	four bytes in network byte order.
- *
- * Results:
- *	TCL_OK, or TCL_ERROR if the write fails.
- *
- * Side effects:
- *	File or buffer will be modified.
- *
- *----------------------------------------------------------------------
- */
-
-static inline int
-WriteInt32(
-    Tcl_Interp *interp,
-    PNGImage *pngPtr,
-    unsigned long l,
-    unsigned long *crcPtr)
-{
-    unsigned char pc[4];
-
-    pc[0] = (unsigned char) ((l & 0xff000000) >> 24);
-    pc[1] = (unsigned char) ((l & 0x00ff0000) >> 16);
-    pc[2] = (unsigned char) ((l & 0x0000ff00) >> 8);
-    pc[3] = (unsigned char) ((l & 0x000000ff) >> 0);
-
-    return WriteData(interp, pngPtr, pc, 4, crcPtr);
-}
-
-/*
- *----------------------------------------------------------------------
- *
- * WriteChunk --
- *
- *	Writes a complete chunk to the PNG image, including chunk type,
- *	length, contents, and CRC.
- *
- * Results:
- *	TCL_OK, or TCL_ERROR if the write fails.
- *
- * Side effects:
- *	None
- *
- *----------------------------------------------------------------------
- */
-
-static inline int
-WriteChunk(
-    Tcl_Interp *interp,
-    PNGImage *pngPtr,
-    unsigned long chunkType,
-    const unsigned char *dataPtr,
-    int dataSize)
-{
-    unsigned long crc = Tcl_ZlibCRC32(0, NULL, 0);
-    int result = TCL_OK;
-
-    /*
-     * Write the length field for the chunk.
-     */
-
-    result = WriteInt32(interp, pngPtr, dataSize, NULL);
-
-    /*
-     * Write the Chunk Type.
-     */
-
-    if (TCL_OK == result) {
-	result = WriteInt32(interp, pngPtr, chunkType, &crc);
-    }
-
-    /*
-     * Write the contents (if any).
-     */
-
-    if (TCL_OK == result) {
-	result = WriteData(interp, pngPtr, dataPtr, dataSize, &crc);
-    }
-
-    /*
-     * Write out the CRC at the end of the chunk.
-     */
-
-    if (TCL_OK == result) {
-	result = WriteInt32(interp, pngPtr, crc, NULL);
-    }
-
-    return result;
-}
-
-/*
- *----------------------------------------------------------------------
- *
- * WriteIHDR --
- *
- *	This function writes the PNG header at the beginning of a PNG file,
- *	which includes information such as dimensions and color type.
- *
- * Results:
- *	TCL_OK, or TCL_ERROR if the write fails.
- *
- * Side effects:
- *	File or buffer will be modified.
- *
- *----------------------------------------------------------------------
- */
-
-static int
-WriteIHDR(
-    Tcl_Interp *interp,
-    PNGImage *pngPtr,
-    Tk_PhotoImageBlock *blockPtr)
-{
-    unsigned long crc = Tcl_ZlibCRC32(0, NULL, 0);
-    int result = TCL_OK;
-
-    /*
-     * The IHDR (header) chunk has a fixed size of 13 bytes.
-     */
-
-    result = WriteInt32(interp, pngPtr, 13, NULL);
-
-    /*
-     * Write the IHDR Chunk Type.
-     */
-
-    if (TCL_OK == result) {
-	result = WriteInt32(interp, pngPtr, CHUNK_IHDR, &crc);
-    }
-
-    /*
-     * Write the image width, height.
-     */
-
-    if (TCL_OK == result) {
-	result = WriteInt32(interp, pngPtr, (unsigned long) blockPtr->width,
-		&crc);
-    }
-
-    if (TCL_OK == result) {
-	result = WriteInt32(interp, pngPtr, (unsigned long) blockPtr->height,
-		&crc);
-    }
-
-    /*
-     * Write bit depth. Although the PNG format supports 16 bits per channel,
-     * Tk supports only 8 in the internal representation, which blockPtr
-     * points to.
-     */
-
-    if (TCL_OK == result) {
-	result = WriteByte(interp, pngPtr, 8, &crc);
-    }
-
-    /*
-     * Write out the color type, previously determined.
-     */
-
-    if (TCL_OK == result) {
-	result = WriteByte(interp, pngPtr, pngPtr->colorType, &crc);
-    }
-
-    /*
-     * Write compression method (only one method is defined).
-     */
-
-    if (TCL_OK == result) {
-	result = WriteByte(interp, pngPtr, PNG_COMPRESS_DEFLATE, &crc);
-    }
-
-    /*
-     * Write filter method (only one method is defined).
-     */
-
-    if (TCL_OK == result) {
-	result = WriteByte(interp, pngPtr, PNG_FILTMETH_STANDARD, &crc);
-    }
-
-    /*
-     * Write interlace method as not interlaced.
-     *
-     * TODO: support interlace through -format?
-     */
-
-    if (TCL_OK == result) {
-	result = WriteByte(interp, pngPtr, PNG_INTERLACE_NONE, &crc);
-    }
-
-    /*
-     * Write out the CRC at the end of the chunk.
-     */
-
-    if (TCL_OK == result) {
-	result = WriteInt32(interp, pngPtr, crc, NULL);
-    }
-
-    return result;
-}
-
-/*
- *----------------------------------------------------------------------
- *
- * WriteIDAT --
- *
- *	Writes the IDAT (data) chunk to the PNG image, containing the pixel
- *	channel data. Currently, image lines are not filtered and writing
- *	interlaced pixels is not supported.
- *
- * Results:
- *	TCL_OK, or TCL_ERROR if the write fails.
- *
- * Side effects:
- *	None
- *
- *----------------------------------------------------------------------
- */
-
-static int
-WriteIDAT(
-    Tcl_Interp *interp,
-    PNGImage *pngPtr,
-    Tk_PhotoImageBlock *blockPtr)
-{
-    int rowNum, flush = TCL_ZLIB_NO_FLUSH, outputSize, result;
-    Tcl_Obj *outputObj;
-    unsigned char *outputBytes;
-
-    /*
-     * Filter and compress each row one at a time.
-     */
-
-    for (rowNum=0 ; rowNum < blockPtr->height ; rowNum++) {
-	int colNum;
-	unsigned char *srcPtr, *destPtr;
-
-	srcPtr = blockPtr->pixelPtr + (rowNum * blockPtr->pitch);
-	destPtr = Tcl_SetByteArrayLength(pngPtr->thisLineObj,
-		pngPtr->lineSize);
-
-	/*
-	 * TODO: use Paeth filtering.
-	 */
-
-	*destPtr++ = PNG_FILTER_NONE;
-
-	/*
-	 * Copy each pixel into the destination buffer after the filter type
-	 * before filtering.
-	 */
-
-	for (colNum = 0 ; colNum < blockPtr->width ; colNum++) {
-	    /*
-	     * Copy red or gray channel.
-	     */
-
-	    *destPtr++ = srcPtr[blockPtr->offset[0]];
-
-	    /*
-	     * If not grayscale, copy the green and blue channels.
-	     */
-
-	    if (pngPtr->colorType & PNG_COLOR_USED) {
-		*destPtr++ = srcPtr[blockPtr->offset[1]];
-		*destPtr++ = srcPtr[blockPtr->offset[2]];
-	    }
-
-	    /*
-	     * Copy the alpha channel, if used.
-	     */
-
-	    if (pngPtr->colorType & PNG_COLOR_ALPHA) {
-		*destPtr++ = srcPtr[blockPtr->offset[3]];
-	    }
-
-	    /*
-	     * Point to the start of the next pixel.
-	     */
-
-	    srcPtr += blockPtr->pixelSize;
-	}
-
-	/*
-	 * Compress the line of pixels into the destination. If this is the
-	 * last line, finalize the compressor at the same time. Note that this
-	 * can't be just a flush; that leads to a file that some PNG readers
-	 * choke on. [Bug 2984787]
-	 */
-
-	if (rowNum + 1 == blockPtr->height) {
-	    flush = TCL_ZLIB_FINALIZE;
-	}
-	if (Tcl_ZlibStreamPut(pngPtr->stream, pngPtr->thisLineObj,
-		flush) != TCL_OK) {
-	    Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		    "deflate() returned error", -1));
-	    Tcl_SetErrorCode(interp, "TK", "IMAGE", "PNG", "DEFLATE", NULL);
-	    return TCL_ERROR;
-	}
-
-	/*
-	 * Swap line buffers to keep the last around for filtering next.
-	 */
-
-	{
-	    Tcl_Obj *temp = pngPtr->lastLineObj;
-
-	    pngPtr->lastLineObj = pngPtr->thisLineObj;
-	    pngPtr->thisLineObj = temp;
-	}
-    }
-
-    /*
-     * Now get the compressed data and write it as one big IDAT chunk.
-     */
-
-    outputObj = Tcl_NewObj();
-    (void) Tcl_ZlibStreamGet(pngPtr->stream, outputObj, -1);
-    outputBytes = Tcl_GetByteArrayFromObj(outputObj, &outputSize);
-    result = WriteChunk(interp, pngPtr, CHUNK_IDAT, outputBytes, outputSize);
-    Tcl_DecrRefCount(outputObj);
-    return result;
-}
-
-/*
- *----------------------------------------------------------------------
- *
- * WriteExtraChunks --
- *
- *	Writes an sBIT and a tEXt chunks to the PNG image, describing a bunch
- *	of not very important metadata that many readers seem to need anyway.
- *
- * Results:
- *	TCL_OK, or TCL_ERROR if the write fails.
- *
- * Side effects:
- *	None
- *
- *----------------------------------------------------------------------
- */
-
-static int
-WriteExtraChunks(
-    Tcl_Interp *interp,
-    PNGImage *pngPtr)
-{
-    static const unsigned char sBIT_contents[] = {
-	8, 8, 8, 8
-    };
-    int sBIT_length = 4;
-    Tcl_DString buf;
-
-    /*
-     * Each byte of each channel is always significant; we always write RGBA
-     * images with 8 bits per channel as that is what the photo image's basic
-     * data model is.
-     */
-
-    switch (pngPtr->colorType) {
-    case PNG_COLOR_GRAY:
-	sBIT_length = 1;
-	break;
-    case PNG_COLOR_GRAYALPHA:
-	sBIT_length = 2;
-	break;
-    case PNG_COLOR_RGB:
-    case PNG_COLOR_PLTE:
-	sBIT_length = 3;
-	break;
-    case PNG_COLOR_RGBA:
-	sBIT_length = 4;
-	break;
-    }
-    if (WriteChunk(interp, pngPtr, CHUNK_sBIT, sBIT_contents, sBIT_length)
-	    != TCL_OK) {
-	return TCL_ERROR;
-    }
-
-    /*
-     * Say that it is Tk that made the PNG. Note that we *need* the NUL at the
-     * end of "Software" to be transferred; do *not* change the length
-     * parameter to -1 there!
-     */
-
-    Tcl_DStringInit(&buf);
-    Tcl_DStringAppend(&buf, "Software", 9);
-    Tcl_DStringAppend(&buf, "Tk Toolkit v", -1);
-    Tcl_DStringAppend(&buf, TK_PATCH_LEVEL, -1);
-    if (WriteChunk(interp, pngPtr, CHUNK_tEXt,
-	    (unsigned char *) Tcl_DStringValue(&buf),
-	    Tcl_DStringLength(&buf)) != TCL_OK) {
-	Tcl_DStringFree(&buf);
-	return TCL_ERROR;
-    }
-    Tcl_DStringFree(&buf);
-
-    return TCL_OK;
-}
-
-/*
- *----------------------------------------------------------------------
- *
- * EncodePNG --
- *
- *	This function handles the entirety of writing a PNG file (or data)
- *	from the first byte to the last. No effort is made to optimize the
- *	image data for best compression.
- *
- * Results:
- *	TCL_OK, or TCL_ERROR if an I/O or memory error occurs.
- *
- * Side effects:
- *	None
- *
- *----------------------------------------------------------------------
- */
-
-static int
-EncodePNG(
-    Tcl_Interp *interp,
-    Tk_PhotoImageBlock *blockPtr,
-    PNGImage *pngPtr)
-{
-    int greenOffset, blueOffset, alphaOffset;
-
-    /*
-     * Determine appropriate color type based on color usage (e.g., only red
-     * and maybe alpha channel = grayscale).
-     *
-     * TODO: Check whether this is doing any good; Tk might just be pushing
-     * full RGBA data all the time through here, even though the actual image
-     * doesn't need it...
-     */
-
-    greenOffset = blockPtr->offset[1] - blockPtr->offset[0];
-    blueOffset = blockPtr->offset[2] - blockPtr->offset[0];
-    alphaOffset = blockPtr->offset[3];
-    if ((alphaOffset >= blockPtr->pixelSize) || (alphaOffset < 0)) {
-	alphaOffset = 0;
-    } else {
-	alphaOffset -= blockPtr->offset[0];
-    }
-
-    if ((greenOffset != 0) || (blueOffset != 0)) {
-	if (alphaOffset) {
-	    pngPtr->colorType = PNG_COLOR_RGBA;
-	    pngPtr->bytesPerPixel = 4;
-	} else {
-	    pngPtr->colorType = PNG_COLOR_RGB;
-	    pngPtr->bytesPerPixel = 3;
-	}
-    } else {
-	if (alphaOffset) {
-	    pngPtr->colorType = PNG_COLOR_GRAYALPHA;
-	    pngPtr->bytesPerPixel = 2;
-	} else {
-	    pngPtr->colorType = PNG_COLOR_GRAY;
-	    pngPtr->bytesPerPixel = 1;
-	}
-    }
-
-    /*
-     * Allocate buffers for lines for filtering and compressed data.
-     */
-
-    pngPtr->lineSize = 1 + (pngPtr->bytesPerPixel * blockPtr->width);
-    pngPtr->blockLen = pngPtr->lineSize * blockPtr->height;
-
-    if ((blockPtr->width > (INT_MAX - 1) / (pngPtr->bytesPerPixel)) ||
-	    (blockPtr->height > INT_MAX / pngPtr->lineSize)) {
-	Tcl_SetObjResult(interp, Tcl_NewStringObj(
-		"image is too large to encode pixel data", -1));
-	Tcl_SetErrorCode(interp, "TK", "IMAGE", "PNG", "TOO_LARGE", NULL);
-	return TCL_ERROR;
-    }
-
-    pngPtr->lastLineObj = Tcl_NewObj();
-    Tcl_IncrRefCount(pngPtr->lastLineObj);
-    pngPtr->thisLineObj = Tcl_NewObj();
-    Tcl_IncrRefCount(pngPtr->thisLineObj);
-
-    /*
-     * Write out the PNG Signature that all PNGs begin with.
-     */
-
-    if (WriteData(interp, pngPtr, pngSignature, PNG_SIG_SZ,
-	    NULL) == TCL_ERROR) {
-	return TCL_ERROR;
-    }
-
-    /*
-     * Write out the IHDR (header) chunk containing image dimensions, color
-     * type, etc.
-     */
-
-    if (WriteIHDR(interp, pngPtr, blockPtr) == TCL_ERROR) {
-	return TCL_ERROR;
-    }
-
-    /*
-     * Write out the extra chunks containing metadata that is of interest to
-     * other programs more than us.
-     */
-
-    if (WriteExtraChunks(interp, pngPtr) == TCL_ERROR) {
-	return TCL_ERROR;
-    }
-
-    /*
-     * Write out the image pixels in the IDAT (data) chunk.
-     */
-
-    if (WriteIDAT(interp, pngPtr, blockPtr) == TCL_ERROR) {
-	return TCL_ERROR;
-    }
-
-    /*
-     * Write out the IEND chunk that all PNGs end with.
-     */
-
-    return WriteChunk(interp, pngPtr, CHUNK_IEND, NULL, 0);
-}
-
-/*
- *----------------------------------------------------------------------
- *
- * FileWritePNG --
- *
- *	This function is called by the photo image type to write PNG format
- *	data to a file.
- *
- * Results:
- *	A standard TCL completion code. If TCL_ERROR is returned then an error
- *	message is left in the interp's result.
- *
- * Side effects:
- *	The specified file is overwritten.
- *
- *----------------------------------------------------------------------
- */
-
-static int
-FileWritePNG(
-    Tcl_Interp *interp,
-    const char *filename,
-    Tcl_Obj *fmtObj,
-    Tk_PhotoImageBlock *blockPtr)
-{
-    Tcl_Channel chan;
-    PNGImage png;
-    int result = TCL_ERROR;
-
-    /*
-     * Open a Tcl file channel where the image data will be stored. Tk ought
-     * to take care of this, and just provide a channel, but it doesn't.
-     */
-
-    chan = Tcl_OpenFileChannel(interp, filename, "w", 0644);
-
-    if (!chan) {
-	return TCL_ERROR;
-    }
-
-    /*
-     * Initalize PNGImage instance for encoding.
-     */
-
-    if (InitPNGImage(interp, &png, chan, NULL,
-	    TCL_ZLIB_STREAM_DEFLATE) == TCL_ERROR) {
-	goto cleanup;
-    }
-
-    /*
-     * Set the translation mode to binary so that CR and LF are not to the
-     * platform's EOL sequence.
-     */
-
-    if (Tcl_SetChannelOption(interp, chan, "-translation",
-	    "binary") != TCL_OK) {
-	goto cleanup;
-    }
-
-    /*
-     * Write the raw PNG data out to the file.
-     */
-
-    result = EncodePNG(interp, blockPtr, &png);
-
-  cleanup:
-    Tcl_Close(interp, chan);
-    CleanupPNGImage(&png);
-    return result;
-}
-
-/*
- *----------------------------------------------------------------------
- *
- * StringWritePNG --
- *
- *	This function is called by the photo image type to write PNG format
- *	data to a Tcl object and return it in the result.
- *
- * Results:
- *	A standard TCL completion code. If TCL_ERROR is returned then an error
- *	message is left in the interp's result.
- *
- * Side effects:
- *	None
- *
- *----------------------------------------------------------------------
- */
-
-static int
-StringWritePNG(
-    Tcl_Interp *interp,
-    Tcl_Obj *fmtObj,
-    Tk_PhotoImageBlock *blockPtr)
-{
-    Tcl_Obj *resultObj = Tcl_NewObj();
-    PNGImage png;
-    int result = TCL_ERROR;
-
-    /*
-     * Initalize PNGImage instance for encoding.
-     */
-
-    if (InitPNGImage(interp, &png, NULL, resultObj,
-	    TCL_ZLIB_STREAM_DEFLATE) == TCL_ERROR) {
-	goto cleanup;
-    }
-
-    /*
-     * Write the raw PNG data into the prepared Tcl_Obj buffer. Set the result
-     * back to the interpreter if successful.
-     */
-
-    result = EncodePNG(interp, blockPtr, &png);
-
-    if (TCL_OK == result) {
-	Tcl_SetObjResult(interp, png.objDataPtr);
-    }
-
-  cleanup:
-    CleanupPNGImage(&png);
-    return result;
-}
-
-/*
- * Local Variables:
- * c-basic-offset: 4
- * fill-column: 78
- * End:
- */