Implementation of TIP #244, PNG image support.

3 files changed, 3385 insertions, 2 deletions

diff --git a/generic/tkImgPNG.c b/generic/tkImgPNG.c
new file mode 100644
index 0000000..eb5ef7c
--- /dev/null
+++ b/generic/tkImgPNG.c
@@ -0,0 +1,3381 @@
+/*
+ * 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.
+ *
+ * RCS: @(#) $Id: tkImgPNG.c,v 1.1 2008/12/28 13:08:39 dkf Exp $
+ */
+
+#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		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 */
+};
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * 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) {
+	Tcl_SetResult(interp, "zlib initialization failed", TCL_STATIC);
+	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((char *) 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_SetResult(interp, "Unexpected end of image data", TCL_STATIC);
+	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_SetResult(interp, "Unexpected end of image data", TCL_STATIC);
+	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);
+
+	/*
+	 * Check for read failure.
+	 */
+
+	if (blockSz < 0) {
+	    /* TODO: failure info... */
+	    Tcl_SetResult(interp, "Channel read failed", TCL_STATIC);
+	    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_SetResult(interp, "Unexpected end of file ", TCL_STATIC);
+	    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_SetResult(interp, "CRC check failed", TCL_STATIC);
+	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_SetResult(interp, "Chunk size is out of supported range "
+		    "on this architecture", TCL_STATIC);
+	    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)) {
+		Tcl_SetResult(interp,
+			"Encountered an unsupported criticial chunk type",
+			TCL_STATIC);
+		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_SetResult(interp, "Invalid chunk type", TCL_STATIC);
+		    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 result = TCL_OK;
+    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)) {
+	    result = TCL_ERROR;
+	}
+	break;
+
+    case PNG_COLOR_RGB:
+	pngPtr->numChannels = 3;
+	if ((8 != pngPtr->bitDepth) && (16 != pngPtr->bitDepth)) {
+	    result = TCL_ERROR;
+	}
+	break;
+
+    case PNG_COLOR_PLTE:
+	pngPtr->numChannels = 1;
+	if ((1 != pngPtr->bitDepth) && (2 != pngPtr->bitDepth) &&
+		(4 != pngPtr->bitDepth) && (8 != pngPtr->bitDepth)) {
+	    result = TCL_ERROR;
+	}
+	break;
+
+    case PNG_COLOR_GRAYALPHA:
+	pngPtr->numChannels = 2;
+	if ((8 != pngPtr->bitDepth) && (16 != pngPtr->bitDepth)) {
+	    result = TCL_ERROR;
+	}
+	break;
+
+    case PNG_COLOR_RGBA:
+	pngPtr->numChannels = 4;
+	if ((8 != pngPtr->bitDepth) && (16 != pngPtr->bitDepth)) {
+	    result = TCL_ERROR;
+	}
+	break;
+
+    default:
+	Tcl_SetResult(interp, "Unknown Color Type field", TCL_STATIC);
+	return TCL_ERROR;
+    }
+
+    if (TCL_ERROR == result) {
+	Tcl_SetResult(interp, "Bit depth is not allowed for given color type",
+		TCL_STATIC);
+	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_SetResult(interp,
+		"Image pitch is out of supported range on this architecture",
+		TCL_STATIC);
+	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_SetResult(interp, "Image total size is out of supported range "
+		"on this architecture", TCL_STATIC);
+	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_SetResult(interp, "internal error - unknown color type",
+		TCL_STATIC);
+	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 / (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_SetResult(interp, "Data stream does not have a PNG signature",
+		TCL_STATIC);
+	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_SetResult(interp, "Expected IHDR chunk type", TCL_STATIC);
+	return TCL_ERROR;
+    }
+
+    if (chunkSz != 13) {
+	Tcl_SetResult(interp, "Invalid IHDR chunk size", TCL_STATIC);
+	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_SetResult(interp,
+		"Image dimensions are invalid or beyond architecture limits",
+		TCL_STATIC);
+	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 (PNG_COMPRESS_DEFLATE != pngPtr->compression) {
+	Tcl_SetResult(interp, "Unknown compression method", TCL_STATIC);
+	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 (PNG_FILTMETH_STANDARD != pngPtr->filter) {
+	Tcl_SetResult(interp, "Unknown filter method", TCL_STATIC);
+	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_SetResult(interp, "Unknown interlace method", TCL_STATIC);
+	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_SetResult(interp, "PLTE chunk type forbidden for grayscale",
+		TCL_STATIC);
+	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_SetResult(interp, "Invalid palette chunk size", TCL_STATIC);
+	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_SetResult(interp,
+		"tRNS chunk not allowed color types with a full alpha channel",
+		TCL_STATIC);
+	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_SetResult(interp, "Invalid tRNS chunk size", TCL_STATIC);
+	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_SetResult(interp,
+		    "Size of tRNS chunk is too large for the palette",
+		    TCL_STATIC);
+	    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_SetResult(interp,
+		    "Invalid tRNS chunk size - must 2 bytes for grayscale",
+		    TCL_STATIC);
+	    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_SetResult(interp,
+		    "Invalid tRNS chunk size - must 6 bytes for RGB",
+		    TCL_STATIC);
+	    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_SetResult(interp, "Invalid filter type", TCL_STATIC);
+	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->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) == 0)) {
+	    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_SetResult(interp, "Extra data after end of zlib stream",
+			TCL_STATIC);
+		return TCL_ERROR;
+	    }
+
+	    inputObj = Tcl_NewObj();
+	    Tcl_SetByteArrayLength(inputObj, PNG_BLOCK_SZ);
+	    Tcl_IncrRefCount(inputObj);
+
+	    /*
+	     * Read the next bit of IDAT chunk data, up to read buffer size.
+	     */
+
+	    inputPtr = Tcl_GetByteArrayFromObj(inputObj, NULL);
+	    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_SetResult(interp,
+			"Extra data after final scan line of final phase",
+			TCL_STATIC);
+		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.
+	     */
+
+	    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.
+	 */
+    }
+
+    if (CheckCRC(interp, pngPtr, crc) == TCL_ERROR) {
+	return TCL_ERROR;
+    }
+
+    return TCL_OK;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * 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 int channel;
+
+	    while (p < endPtr) {
+		channel = (unsigned char)
+			(((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 *fmtOptions[] = {
+	"png", "-alpha", NULL
+    };
+    enum fmtOptions {
+	OPT_PNG, 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;
+
+        if (Tcl_GetIndexFromObj(interp, objv[0], fmtOptions, "option", 0,
+		&optIndex) == TCL_ERROR) {
+            return TCL_ERROR;
+	}
+
+	/*
+	 * Ignore the "png" part of the format specification.
+	 */
+
+	if (OPT_PNG == optIndex) {
+	    continue;
+	}
+
+    	if (objc < 2) {
+	    Tcl_WrongNumArgs(interp, 1, objv, "value");
+	    return TCL_ERROR;
+    	}
+
+	objc--;
+	objv++;
+
+	switch ((enum fmtOptions) optIndex) {
+	case OPT_PNG:
+	    break;
+
+	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_SetResult(interp,
+			"-alpha value must be between 0.0 and 1.0",
+			TCL_STATIC);
+		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_SetResult(interp, "PLTE chunk required for indexed color",
+		TCL_STATIC);
+	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 (CHUNK_IDAT != chunkType) {
+	Tcl_SetResult(interp, "At least one IDAT chunk is required",
+		TCL_STATIC);
+	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_SetResult(interp,
+		"Line size is out of supported range on this architecture",
+		TCL_STATIC);
+	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 = (unsigned char *)
+	    attemptckalloc(pngPtr->blockLen);
+
+    if (!pngPtr->block.pixelPtr) {
+	Tcl_SetResult(interp, "Memory allocation failed", TCL_STATIC);
+	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;
+	}
+    }
+
+    /*
+     * 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_SetResult(interp, "IEND chunk contents must be empty",
+		TCL_STATIC);
+	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_SetResult(interp, "Extra data following IEND chunk", TCL_STATIC);
+	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;
+    Tcl_SavedResult sya;
+
+    Tcl_SaveResult(interp, &sya);
+
+    InitPNGImage(interp, &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);
+    Tcl_RestoreResult(interp, &sya);
+
+    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;
+    Tcl_SavedResult sya;
+
+    Tcl_SaveResult(interp, &sya);
+    InitPNGImage(interp, &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);
+    Tcl_RestoreResult(interp, &sya);
+    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_SetResult(interp,
+		    "Image too large to store completely in byte array",
+		    TCL_STATIC);
+	    return TCL_ERROR;
+	}
+
+	destPtr = Tcl_SetByteArrayLength(pngPtr->objDataPtr, objSz + srcSz);
+
+	if (!destPtr) {
+	    Tcl_SetResult(interp, "Memory allocation failed", TCL_STATIC);
+	    return TCL_ERROR;
+	}
+
+	memcpy(destPtr+objSz, srcPtr, srcSz);
+    } else if (Tcl_Write(pngPtr->channel, (const char *) srcPtr, srcSz) < 0) {
+	/* TODO: reason */
+
+	Tcl_SetResult(interp, "Write to channel failed", TCL_STATIC);
+	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, flush at the same time.
+	 */
+
+	if (rowNum + 1 == blockPtr->height) {
+	    flush = TCL_ZLIB_FLUSH;
+	}
+	if (Tcl_ZlibStreamPut(pngPtr->stream, pngPtr->thisLineObj,
+		flush) != TCL_OK) {
+	    Tcl_SetResult(interp, "deflate() returned error", TCL_STATIC);
+	    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;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * 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_RGBA;
+	    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_SetResult(interp, "Image is too large to encode pixel data",
+		TCL_STATIC);
+	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 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:
+ */
diff --git a/generic/tkInt.h b/generic/tkInt.h
index 214b428..41ba794 100644
--- a/generic/tkInt.h
+++ b/generic/tkInt.h
@@ -11,7 +11,7 @@
  * See the file "license.terms" for information on usage and redistribution of
  * this file, and for a DISCLAIMER OF ALL WARRANTIES.
  *
- * RCS: $Id: tkInt.h,v 1.98 2008/12/10 05:02:51 das Exp $
+ * RCS: $Id: tkInt.h,v 1.99 2008/12/28 13:08:39 dkf Exp $
  */
 
 #ifndef _TKINT
@@ -962,6 +962,7 @@ MODULE_SCOPE const Tk_SmoothMethod tkBezierSmoothMethod;
 MODULE_SCOPE Tk_ImageType	tkBitmapImageType;
 MODULE_SCOPE Tk_PhotoImageFormat tkImgFmtGIF;
 MODULE_SCOPE void		(*tkHandleEventProc) (XEvent* eventPtr);
+MODULE_SCOPE Tk_PhotoImageFormat tkImgFmtPNG;
 MODULE_SCOPE Tk_PhotoImageFormat tkImgFmtPPM;
 MODULE_SCOPE TkMainInfo		*tkMainWindowList;
 MODULE_SCOPE Tk_ImageType	tkPhotoImageType;
diff --git a/generic/tkWindow.c b/generic/tkWindow.c
index 597b329..37b4a43 100644
--- a/generic/tkWindow.c
+++ b/generic/tkWindow.c
@@ -11,7 +11,7 @@
  * See the file "license.terms" for information on usage and redistribution of
  * this file, and for a DISCLAIMER OF ALL WARRANTIES.
  *
- * RCS: @(#) $Id: tkWindow.c,v 1.101 2008/12/10 00:34:51 das Exp $
+ * RCS: @(#) $Id: tkWindow.c,v 1.102 2008/12/28 13:08:39 dkf Exp $
  */
 
 #include "tkInt.h"
@@ -373,6 +373,7 @@ CreateTopLevelWindow(
 	 */
 
 	Tk_CreatePhotoImageFormat(&tkImgFmtGIF);
+	Tk_CreatePhotoImageFormat(&tkImgFmtPNG);
 	Tk_CreatePhotoImageFormat(&tkImgFmtPPM);
     }