Cleaning up whitespace, comments, declarations. No functional changes.

1 files changed, 825 insertions, 830 deletions

diff --git a/generic/tkImgPPM.c b/generic/tkImgPPM.c
index b1b4ad4..dc1c9e4 100644
--- a/generic/tkImgPPM.c
+++ b/generic/tkImgPPM.c
@@ -1,830 +1,825 @@
-/*
- * tkImgPPM.c --
- *
- *	A photo image file handler for PPM (Portable PixMap) files.
- *
- * Copyright (c) 1994 The Australian National University.
- * Copyright (c) 1994-1997 Sun Microsystems, Inc.
- *
- * See the file "license.terms" for information on usage and redistribution of
- * this file, and for a DISCLAIMER OF ALL WARRANTIES.
- *
- * Author: Paul Mackerras (paulus@cs.anu.edu.au),
- *	   Department of Computer Science,
- *	   Australian National University.
- *
- * RCS: @(#) $Id: tkImgPPM.c,v 1.16 2005/11/17 16:21:55 dkf Exp $
- */
-
-#include "tkInt.h"
-#include "tkPort.h"
-
-/*
- * The maximum amount of memory to allocate for data read from the file. If we
- * need more than this, we do it in pieces.
- */
-
-#define MAX_MEMORY	10000		/* don't allocate > 10KB */
-
-/*
- * Define PGM and PPM, i.e. gray images and color images.
- */
-
-#define PGM 1
-#define PPM 2
-
-/*
- * The format record for the PPM file format:
- */
-
-static int		FileMatchPPM(Tcl_Channel chan, CONST char *fileName,
-			    Tcl_Obj *format, int *widthPtr, int *heightPtr,
-			    Tcl_Interp *interp);
-static int		FileReadPPM(Tcl_Interp *interp, Tcl_Channel chan,
-			    CONST char *fileName, Tcl_Obj *format,
-			    Tk_PhotoHandle imageHandle, int destX, int destY,
-			    int width, int height, int srcX, int srcY);
-static int		FileWritePPM(Tcl_Interp *interp, CONST char *fileName,
-			    Tcl_Obj *format, Tk_PhotoImageBlock *blockPtr);
-static int		StringWritePPM(Tcl_Interp *interp, Tcl_Obj *format,
-			    Tk_PhotoImageBlock *blockPtr);
-static int		StringMatchPPM(Tcl_Obj *dataObj, Tcl_Obj *format,
-			    int *widthPtr, int *heightPtr, Tcl_Interp *interp);
-static int		StringReadPPM(Tcl_Interp *interp, Tcl_Obj *dataObj,
-			    Tcl_Obj *format, Tk_PhotoHandle imageHandle,
-			    int destX, int destY, int width, int height,
-			    int srcX, int srcY);
-
-Tk_PhotoImageFormat tkImgFmtPPM = {
-    "ppm",			/* name */
-    FileMatchPPM,		/* fileMatchProc */
-    StringMatchPPM,		/* stringMatchProc */
-    FileReadPPM,		/* fileReadProc */
-    StringReadPPM,		/* stringReadProc */
-    FileWritePPM,		/* fileWriteProc */
-    StringWritePPM,		/* stringWriteProc */
-};
-
-/*
- * Prototypes for local functions defined in this file:
- */
-
-static int		ReadPPMFileHeader(Tcl_Channel chan, int *widthPtr,
-			    int *heightPtr, int *maxIntensityPtr);
-static int		ReadPPMStringHeader(Tcl_Obj *dataObj, int *widthPtr,
-			    int *heightPtr, int *maxIntensityPtr,
-			    unsigned char **dataBufferPtr, int *dataSizePtr);
-
-/*
- *----------------------------------------------------------------------
- *
- * FileMatchPPM --
- *
- *	This function is invoked by the photo image type to see if a file
- *	contains image data in PPM format.
- *
- * Results:
- *	The return value is >0 if the first characters in file "f" look like
- *	PPM data, and 0 otherwise.
- *
- * Side effects:
- *	The access position in f may change.
- *
- *----------------------------------------------------------------------
- */
-
-static int
-FileMatchPPM(
-    Tcl_Channel chan,		/* The image file, open for reading. */
-    CONST char *fileName,	/* The name of the image file. */
-    Tcl_Obj *format,		/* User-specified format string, or NULL. */
-    int *widthPtr, int *heightPtr,
-				/* The dimensions of the image are returned
-				 * here if the file is a valid raw PPM
-				 * file. */
-    Tcl_Interp *interp)		/* unused */
-{
-    int dummy;
-
-    return ReadPPMFileHeader(chan, widthPtr, heightPtr, &dummy);
-}
-
-/*
- *----------------------------------------------------------------------
- *
- * FileReadPPM --
- *
- *	This function is called by the photo image type to read PPM 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
-FileReadPPM(
-    Tcl_Interp *interp,		/* Interpreter to use for reporting errors. */
-    Tcl_Channel chan,		/* The image file, open for reading. */
-    CONST char *fileName,	/* The name of the image file. */
-    Tcl_Obj *format,		/* User-specified format string, or NULL. */
-    Tk_PhotoHandle imageHandle,	/* The photo image to write into. */
-    int destX, int destY,	/* Coordinates of top-left pixel in photo
-				 * image to be written to. */
-    int width, int height,	/* Dimensions of block of photo image to be
-				 * written to. */
-    int srcX, int srcY)		/* Coordinates of top-left pixel to be used in
-				 * image being read. */
-{
-    int fileWidth, fileHeight, maxIntensity;
-    int nLines, nBytes, h, type, count;
-    unsigned char *pixelPtr;
-    Tk_PhotoImageBlock block;
-
-    type = ReadPPMFileHeader(chan, &fileWidth, &fileHeight, &maxIntensity);
-    if (type == 0) {
-	Tcl_AppendResult(interp, "couldn't read raw PPM header from file \"",
-		fileName, "\"", NULL);
-	return TCL_ERROR;
-    }
-    if ((fileWidth <= 0) || (fileHeight <= 0)) {
-	Tcl_AppendResult(interp, "PPM image file \"", fileName,
-		"\" has dimension(s) <= 0", NULL);
-	return TCL_ERROR;
-    }
-    if ((maxIntensity <= 0) || (maxIntensity >= 256)) {
-	char buffer[TCL_INTEGER_SPACE];
-
-	sprintf(buffer, "%d", maxIntensity);
-	Tcl_AppendResult(interp, "PPM image file \"", fileName,
-		"\" has bad maximum intensity value ", buffer, NULL);
-	return TCL_ERROR;
-    }
-
-    if ((srcX + width) > fileWidth) {
-	width = fileWidth - srcX;
-    }
-    if ((srcY + height) > fileHeight) {
-	height = fileHeight - srcY;
-    }
-    if ((width <= 0) || (height <= 0)
-	|| (srcX >= fileWidth) || (srcY >= fileHeight)) {
-	return TCL_OK;
-    }
-
-    if (type == PGM) {
-        block.pixelSize = 1;
-        block.offset[0] = 0;
-	block.offset[1] = 0;
-	block.offset[2] = 0;
-    } else {
-        block.pixelSize = 3;
-        block.offset[0] = 0;
-	block.offset[1] = 1;
-	block.offset[2] = 2;
-    }
-    block.offset[3] = 0;
-    block.width = width;
-    block.pitch = block.pixelSize * fileWidth;
-
-    if (Tk_PhotoExpand(interp, imageHandle,
-	    destX + width, destY + height) != TCL_OK) {
-	return TCL_ERROR;
-    }
-
-    if (srcY > 0) {
-	Tcl_Seek(chan, (Tcl_WideInt)(srcY * block.pitch), SEEK_CUR);
-    }
-
-    nLines = (MAX_MEMORY + block.pitch - 1) / block.pitch;
-    if (nLines > height) {
-	nLines = height;
-    }
-    if (nLines <= 0) {
-	nLines = 1;
-    }
-    nBytes = nLines * block.pitch;
-    pixelPtr = (unsigned char *) ckalloc((unsigned) nBytes);
-    block.pixelPtr = pixelPtr + srcX * block.pixelSize;
-
-    for (h = height; h > 0; h -= nLines) {
-	if (nLines > h) {
-	    nLines = h;
-	    nBytes = nLines * block.pitch;
-	}
-	count = Tcl_Read(chan, (char *) pixelPtr, nBytes);
-	if (count != nBytes) {
-	    Tcl_AppendResult(interp, "error reading PPM image file \"",
-		    fileName, "\": ",
-		    Tcl_Eof(chan) ? "not enough data" : Tcl_PosixError(interp),
-		    NULL);
-	    ckfree((char *) pixelPtr);
-	    return TCL_ERROR;
-	}
-	if (maxIntensity != 255) {
-	    unsigned char *p;
-
-	    for (p = pixelPtr; count > 0; count--, p++) {
-		*p = (((int) *p) * 255)/maxIntensity;
-	    }
-	}
-	block.height = nLines;
-	if (Tk_PhotoPutBlock(interp, imageHandle, &block, destX, destY,
-		width, nLines, TK_PHOTO_COMPOSITE_SET) != TCL_OK) {
-	    ckfree((char *) pixelPtr);
-	    return TCL_ERROR;
-	}
-	destY += nLines;
-    }
-
-    ckfree((char *) pixelPtr);
-    return TCL_OK;
-}
-
-/*
- *----------------------------------------------------------------------
- *
- * FileWritePPM --
- *
- *	This function is invoked to write image data to a file in PPM format
- *	(although we can read PGM files, we never write them).
- *
- * Results:
- *	A standard TCL completion code. If TCL_ERROR is returned then an error
- *	message is left in the interp's result.
- *
- * Side effects:
- *	Data is written to the file given by "fileName".
- *
- *----------------------------------------------------------------------
- */
-
-static int
-FileWritePPM(
-    Tcl_Interp *interp,
-    CONST char *fileName,
-    Tcl_Obj *format,
-    Tk_PhotoImageBlock *blockPtr)
-{
-    Tcl_Channel chan;
-    int w, h;
-    int greenOffset, blueOffset, nBytes;
-    unsigned char *pixelPtr, *pixLinePtr;
-    char header[16 + TCL_INTEGER_SPACE * 2];
-
-    chan = Tcl_OpenFileChannel(interp, fileName, "w", 0666);
-    if (chan == NULL) {
-	return TCL_ERROR;
-    }
-
-    if (Tcl_SetChannelOption(interp, chan, "-translation", "binary")
-	    != TCL_OK) {
-	Tcl_Close(NULL, chan);
-	return TCL_ERROR;
-    }
-    if (Tcl_SetChannelOption(interp, chan, "-encoding", "binary")
-	    != TCL_OK) {
-	Tcl_Close(NULL, chan);
-	return TCL_ERROR;
-    }
-
-    sprintf(header, "P6\n%d %d\n255\n", blockPtr->width, blockPtr->height);
-    Tcl_Write(chan, header, -1);
-
-    pixLinePtr = blockPtr->pixelPtr + blockPtr->offset[0];
-    greenOffset = blockPtr->offset[1] - blockPtr->offset[0];
-    blueOffset = blockPtr->offset[2] - blockPtr->offset[0];
-
-    if ((greenOffset == 1) && (blueOffset == 2) && (blockPtr->pixelSize == 3)
-	    && (blockPtr->pitch == (blockPtr->width * 3))) {
-	nBytes = blockPtr->height * blockPtr->pitch;
-	if (Tcl_Write(chan, (char *) pixLinePtr, nBytes) != nBytes) {
-	    goto writeerror;
-	}
-    } else {
-	for (h = blockPtr->height; h > 0; h--) {
-	    pixelPtr = pixLinePtr;
-	    for (w = blockPtr->width; w > 0; w--) {
-		if (    Tcl_Write(chan,(char *)&pixelPtr[0], 1) == -1 ||
-			Tcl_Write(chan,(char *)&pixelPtr[greenOffset],1)==-1 ||
-			Tcl_Write(chan,(char *)&pixelPtr[blueOffset],1) ==-1) {
-		    goto writeerror;
-		}
-		pixelPtr += blockPtr->pixelSize;
-	    }
-	    pixLinePtr += blockPtr->pitch;
-	}
-    }
-
-    if (Tcl_Close(NULL, chan) == 0) {
-	return TCL_OK;
-    }
-    chan = NULL;
-
-  writeerror:
-    Tcl_AppendResult(interp, "error writing \"", fileName, "\": ",
-	    Tcl_PosixError(interp), NULL);
-    if (chan != NULL) {
-	Tcl_Close(NULL, chan);
-    }
-    return TCL_ERROR;
-}
-
-/*
- *----------------------------------------------------------------------
- *
- * StringWritePPM --
- *
- *	This function is invoked to write image data to a string in PPM
- *	format.
- *
- * 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
-StringWritePPM(
-    Tcl_Interp *interp,
-    Tcl_Obj *format,
-    Tk_PhotoImageBlock *blockPtr)
-{
-    int w, h, size, greenOffset, blueOffset;
-    unsigned char *pixLinePtr, *byteArray;
-    char header[16 + TCL_INTEGER_SPACE * 2];
-    Tcl_Obj *byteArrayObj;
-
-    sprintf(header, "P6\n%d %d\n255\n", blockPtr->width, blockPtr->height);
-
-    /*
-     * Construct a byte array of the right size with the header and
-     * get a pointer to the data part of it.
-     */
-
-    size = strlen(header);
-    byteArrayObj = Tcl_NewByteArrayObj((unsigned char *)header, size);
-    byteArray = Tcl_SetByteArrayLength(byteArrayObj,
-	    size + 3*blockPtr->width*blockPtr->height);
-    byteArray += size;
-
-    pixLinePtr = blockPtr->pixelPtr + blockPtr->offset[0];
-    greenOffset = blockPtr->offset[1] - blockPtr->offset[0];
-    blueOffset = blockPtr->offset[2] - blockPtr->offset[0];
-
-    /*
-     * Check if we can do the data move in single action.
-     */
-
-    if ((greenOffset == 1) && (blueOffset == 2) && (blockPtr->pixelSize == 3)
-	    && (blockPtr->pitch == (blockPtr->width * 3))) {
-	memcpy(byteArray, pixLinePtr,
-		(unsigned)blockPtr->height * blockPtr->pitch);
-    } else {
-	for (h = blockPtr->height; h > 0; h--) {
-	    unsigned char *pixelPtr = pixLinePtr;
-
-	    for (w = blockPtr->width; w > 0; w--) {
-		*byteArray++ = pixelPtr[0];
-		*byteArray++ = pixelPtr[greenOffset];
-		*byteArray++ = pixelPtr[blueOffset];
-		pixelPtr += blockPtr->pixelSize;
-	    }
-	    pixLinePtr += blockPtr->pitch;
-	}
-    }
-
-    /*
-     * Return the object in the interpreter result.
-     */
-
-    Tcl_SetObjResult(interp, byteArrayObj);
-    return TCL_OK;
-}
-
-/*
- *----------------------------------------------------------------------
- *
- * StringMatchPPM --
- *
- *	This function is invoked by the photo image type to see if a string
- *	contains image data in PPM format.
- *
- * Results:
- *	The return value is >0 if the first characters in file "f" look like
- *	PPM data, and 0 otherwise.
- *
- * Side effects:
- *	The access position in f may change.
- *
- *----------------------------------------------------------------------
- */
-
-static int
-StringMatchPPM(
-    Tcl_Obj *dataObj,		/* The image data. */
-    Tcl_Obj *format,		/* User-specified format string, or NULL. */
-    int *widthPtr, int *heightPtr,
-				/* The dimensions of the image are returned
-				 * here if the file is a valid raw PPM
-				 * file. */
-    Tcl_Interp *interp)		/* unused */
-{
-    int dummy;
-
-    return ReadPPMStringHeader(dataObj, widthPtr, heightPtr,
-	    &dummy, NULL, NULL);
-}
-
-/*
- *----------------------------------------------------------------------
- *
- * StringReadPPM --
- *
- *	This function is called by the photo image type to read PPM format
- *	data from a string 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:
- *	New data is added to the image given by imageHandle.
- *
- *----------------------------------------------------------------------
- */
-
-static int
-StringReadPPM(
-    Tcl_Interp *interp,		/* Interpreter to use for reporting errors. */
-    Tcl_Obj *dataObj,		/* The image data. */
-    Tcl_Obj *format,		/* User-specified format string, or NULL. */
-    Tk_PhotoHandle imageHandle,	/* The photo image to write into. */
-    int destX, int destY,	/* Coordinates of top-left pixel in photo
-				 * image to be written to. */
-    int width, int height,	/* Dimensions of block of photo image to be
-				 * written to. */
-    int srcX, int srcY)		/* Coordinates of top-left pixel to be used in
-				 * image being read. */
-{
-    int fileWidth, fileHeight, maxIntensity;
-    int nLines, nBytes, h, type, count, dataSize;
-    unsigned char *pixelPtr, *dataBuffer;
-    Tk_PhotoImageBlock block;
-
-    type = ReadPPMStringHeader(dataObj, &fileWidth, &fileHeight,
-	    &maxIntensity, &dataBuffer, &dataSize);
-    if (type == 0) {
-	Tcl_AppendResult(interp, "couldn't read raw PPM header from string",
-		NULL);
-	return TCL_ERROR;
-    }
-    if ((fileWidth <= 0) || (fileHeight <= 0)) {
-	Tcl_AppendResult(interp, "PPM image data has dimension(s) <= 0",
-		NULL);
-	return TCL_ERROR;
-    }
-    if ((maxIntensity <= 0) || (maxIntensity >= 256)) {
-	char buffer[TCL_INTEGER_SPACE];
-
-	sprintf(buffer, "%d", maxIntensity);
-	Tcl_AppendResult(interp,
-		"PPM image data has bad maximum intensity value ", buffer,
-		NULL);
-	return TCL_ERROR;
-    }
-
-    if ((srcX + width) > fileWidth) {
-	width = fileWidth - srcX;
-    }
-    if ((srcY + height) > fileHeight) {
-	height = fileHeight - srcY;
-    }
-    if ((width <= 0) || (height <= 0)
-	|| (srcX >= fileWidth) || (srcY >= fileHeight)) {
-	return TCL_OK;
-    }
-
-    if (type == PGM) {
-        block.pixelSize = 1;
-        block.offset[0] = 0;
-	block.offset[1] = 0;
-	block.offset[2] = 0;
-    } else {
-        block.pixelSize = 3;
-        block.offset[0] = 0;
-	block.offset[1] = 1;
-	block.offset[2] = 2;
-    }
-    block.offset[3] = 0;
-    block.width = width;
-    block.pitch = block.pixelSize * fileWidth;
-
-    if (srcY > 0) {
-	dataBuffer += srcY * block.pitch;
-	dataSize -= srcY * block.pitch;
-    }
-
-    if (maxIntensity == 255) {
-	/*
-	 * We have all the data in memory, so write everything in one go.
-	 */
-
-	if (block.pitch*height < dataSize) {
-	    Tcl_AppendResult(interp, "truncated PPM data", NULL);
-	    return TCL_ERROR;
-	}
-	block.pixelPtr = dataBuffer + srcX * block.pixelSize;
-	block.height = height;
-	return Tk_PhotoPutBlock(interp, imageHandle, &block, destX, destY,
-		width, height, TK_PHOTO_COMPOSITE_SET);
-    }
-
-    if (Tk_PhotoExpand(interp, imageHandle,
-	    destX + width, destY + height) != TCL_OK) {
-	return TCL_ERROR;
-    }
-
-    nLines = (MAX_MEMORY + block.pitch - 1) / block.pitch;
-    if (nLines > height) {
-	nLines = height;
-    }
-    if (nLines <= 0) {
-	nLines = 1;
-    }
-    nBytes = nLines * block.pitch;
-    pixelPtr = (unsigned char *) ckalloc((unsigned) nBytes);
-    block.pixelPtr = pixelPtr + srcX * block.pixelSize;
-
-    for (h = height; h > 0; h -= nLines) {
-	unsigned char *p;
-
-	if (nLines > h) {
-	    nLines = h;
-	    nBytes = nLines * block.pitch;
-	}
-	if (dataSize < nBytes) {
-	    ckfree((char *) pixelPtr);
-	    Tcl_AppendResult(interp, "truncated PPM data", NULL);
-	    return TCL_ERROR;
-	}
-	for (p=pixelPtr,count=nBytes ; count>0 ; count--,p++,dataBuffer++) {
-	    *p = (((int) *dataBuffer) * 255)/maxIntensity;
-	}
-	dataSize -= nBytes;
-	block.height = nLines;
-	if (Tk_PhotoPutBlock(interp, imageHandle, &block, destX, destY,
-		width, nLines, TK_PHOTO_COMPOSITE_SET) != TCL_OK) {
-	    ckfree((char *) pixelPtr);
-	    return TCL_ERROR;
-	}
-	destY += nLines;
-    }
-
-    ckfree((char *) pixelPtr);
-    return TCL_OK;
-}
-
-/*
- *----------------------------------------------------------------------
- *
- * ReadPPMFileHeader --
- *
- *	This function reads the PPM header from the beginning of a PPM file
- *	and returns information from the header.
- *
- * Results:
- *	The return value is PGM if file "f" appears to start with a valid PGM
- *	header, PPM if "f" appears to start with a valid PPM header, and 0
- *	otherwise. If the header is valid, then *widthPtr and *heightPtr are
- *	modified to hold the dimensions of the image and *maxIntensityPtr is
- *	modified to hold the value of a "fully on" intensity value.
- *
- * Side effects:
- *	The access position in f advances.
- *
- *----------------------------------------------------------------------
- */
-
-static int
-ReadPPMFileHeader(
-    Tcl_Channel chan,		/* Image file to read the header from. */
-    int *widthPtr, int *heightPtr,
-				/* The dimensions of the image are returned
-				 * here. */
-    int *maxIntensityPtr)	/* The maximum intensity value for the image
-				 * is stored here. */
-{
-#define BUFFER_SIZE 1000
-    char buffer[BUFFER_SIZE];
-    int i, numFields;
-    int type = 0;
-    char c;
-
-    /*
-     * Read 4 space-separated fields from the file, ignoring comments (any
-     * line that starts with "#").
-     */
-
-    if (Tcl_Read(chan, &c, 1) != 1) {
-	return 0;
-    }
-    i = 0;
-    for (numFields = 0; numFields < 4; numFields++) {
-	/*
-	 * Skip comments and white space.
-	 */
-
-	while (1) {
-	    while (isspace(UCHAR(c))) {
-		if (Tcl_Read(chan, &c, 1) != 1) {
-		    return 0;
-		}
-	    }
-	    if (c != '#') {
-		break;
-	    }
-	    do {
-		if (Tcl_Read(chan, &c, 1) != 1) {
-		    return 0;
-		}
-	    } while (c != '\n');
-	}
-
-	/*
-	 * Read a field (everything up to the next white space).
-	 */
-
-	while (!isspace(UCHAR(c))) {
-	    if (i < (BUFFER_SIZE-2)) {
-		buffer[i] = c;
-		i++;
-	    }
-	    if (Tcl_Read(chan, &c, 1) != 1) {
-		goto done;
-	    }
-	}
-	if (i < (BUFFER_SIZE-1)) {
-	    buffer[i] = ' ';
-	    i++;
-	}
-    }
-
-  done:
-    buffer[i] = 0;
-
-    /*
-     * Parse the fields, which are: id, width, height, maxIntensity.
-     */
-
-    if (strncmp(buffer, "P6 ", 3) == 0) {
-	type = PPM;
-    } else if (strncmp(buffer, "P5 ", 3) == 0) {
-	type = PGM;
-    } else {
-	return 0;
-    }
-    if (sscanf(buffer+3, "%d %d %d", widthPtr, heightPtr, maxIntensityPtr)
-	    != 3) {
-	return 0;
-    }
-    return type;
-}
-
-/*
- *----------------------------------------------------------------------
- *
- * ReadPPMStringHeader --
- *
- *	This function reads the PPM header from the beginning of a PPM-format
- *	string and returns information from the header.
- *
- * Results:
- *	The return value is PGM if the string appears to start with a valid
- *	PGM header, PPM if the string appears to start with a valid PPM
- *	header, and 0 otherwise. If the header is valid, then *widthPtr and
- *	*heightPtr are modified to hold the dimensions of the image and
- *	*maxIntensityPtr is modified to hold the value of a "fully on"
- *	intensity value.
- *
- * Side effects:
- *	None
- *
- *----------------------------------------------------------------------
- */
-
-static int
-ReadPPMStringHeader(
-    Tcl_Obj *dataPtr,		/* Object to read the header from. */
-    int *widthPtr, int *heightPtr,
-				/* The dimensions of the image are returned
-				 * here. */
-    int *maxIntensityPtr,	/* The maximum intensity value for the image
-				 * is stored here. */
-    unsigned char **dataBufferPtr,
-    int *dataSizePtr)
-{
-#define BUFFER_SIZE 1000
-    char buffer[BUFFER_SIZE];
-    int i, numFields, dataSize;
-    int type = 0;
-    char c;
-    unsigned char *dataBuffer;
-
-    dataBuffer = Tcl_GetByteArrayFromObj(dataPtr, &dataSize);
-
-    /*
-     * Read 4 space-separated fields from the string, ignoring comments (any
-     * line that starts with "#").
-     */
-
-    if (dataSize-- < 1) {
-	return 0;
-    }
-    c = (char) (*dataBuffer++);
-    i = 0;
-    for (numFields = 0; numFields < 4; numFields++) {
-	/*
-	 * Skip comments and white space.
-	 */
-
-	while (1) {
-	    while (isspace(UCHAR(c))) {
-		if (dataSize-- < 1) {
-		    return 0;
-		}
-		c = (char) (*dataBuffer++);
-	    }
-	    if (c != '#') {
-		break;
-	    }
-	    do {
-		if (dataSize-- < 1) {
-		    return 0;
-		}
-		c = (char) (*dataBuffer++);
-	    } while (c != '\n');
-	}
-
-	/*
-	 * Read a field (everything up to the next white space).
-	 */
-
-	while (!isspace(UCHAR(c))) {
-	    if (i < (BUFFER_SIZE-2)) {
-		buffer[i] = c;
-		i++;
-	    }
-	    if (dataSize-- < 1) {
-		goto done;
-	    }
-	    c = (char) (*dataBuffer++);
-	}
-	if (i < (BUFFER_SIZE-1)) {
-	    buffer[i] = ' ';
-	    i++;
-	}
-    }
-
-  done:
-    buffer[i] = 0;
-
-    /*
-     * Parse the fields, which are: id, width, height, maxIntensity.
-     */
-
-    if (strncmp(buffer, "P6 ", 3) == 0) {
-	type = PPM;
-    } else if (strncmp(buffer, "P5 ", 3) == 0) {
-	type = PGM;
-    } else {
-	return 0;
-    }
-    if (sscanf(buffer+3, "%d %d %d", widthPtr, heightPtr, maxIntensityPtr)
-	    != 3) {
-	return 0;
-    }
-    if (dataBufferPtr != NULL) {
-	*dataBufferPtr = dataBuffer;
-	*dataSizePtr = dataSize;
-    }
-    return type;
-}
-
-/*
- * Local Variables:
- * mode: c
- * c-basic-offset: 4
- * fill-column: 78
- * End:
- */
+/*

+ * tkImgPPM.c --

+ *

+ *	A photo image file handler for PPM (Portable PixMap) files.

+ *

+ * Copyright (c) 1994 The Australian National University.

+ * Copyright (c) 1994-1997 Sun Microsystems, Inc.

+ *

+ * See the file "license.terms" for information on usage and redistribution of

+ * this file, and for a DISCLAIMER OF ALL WARRANTIES.

+ *

+ * Author: Paul Mackerras (paulus@cs.anu.edu.au),

+ *	Department of Computer Science,

+ *	Australian National University.

+ *

+ * RCS: @(#) $Id: tkImgPPM.c,v 1.17 2007/06/24 16:20:41 dkf Exp $

+ */

+

+#include "tkInt.h"

+#include "tkPort.h"

+

+/*

+ * The maximum amount of memory to allocate for data read from the file. If we

+ * need more than this, we do it in pieces.

+ */

+

+#define MAX_MEMORY	10000		/* don't allocate > 10KB */

+

+/*

+ * Define PGM and PPM, i.e. gray images and color images.

+ */

+

+#define PGM 1

+#define PPM 2

+

+/*

+ * The format record for the PPM file format:

+ */

+

+static int		FileMatchPPM(Tcl_Channel chan, CONST char *fileName,

+			    Tcl_Obj *format, int *widthPtr, int *heightPtr,

+			    Tcl_Interp *interp);

+static int		FileReadPPM(Tcl_Interp *interp, Tcl_Channel chan,

+			    CONST char *fileName, Tcl_Obj *format,

+			    Tk_PhotoHandle imageHandle, int destX, int destY,

+			    int width, int height, int srcX, int srcY);

+static int		FileWritePPM(Tcl_Interp *interp, CONST char *fileName,

+			    Tcl_Obj *format, Tk_PhotoImageBlock *blockPtr);

+static int		StringWritePPM(Tcl_Interp *interp, Tcl_Obj *format,

+			    Tk_PhotoImageBlock *blockPtr);

+static int		StringMatchPPM(Tcl_Obj *dataObj, Tcl_Obj *format,

+			    int *widthPtr, int *heightPtr, Tcl_Interp *interp);

+static int		StringReadPPM(Tcl_Interp *interp, Tcl_Obj *dataObj,

+			    Tcl_Obj *format, Tk_PhotoHandle imageHandle,

+			    int destX, int destY, int width, int height,

+			    int srcX, int srcY);

+

+Tk_PhotoImageFormat tkImgFmtPPM = {

+    "ppm",			/* name */

+    FileMatchPPM,		/* fileMatchProc */

+    StringMatchPPM,		/* stringMatchProc */

+    FileReadPPM,		/* fileReadProc */

+    StringReadPPM,		/* stringReadProc */

+    FileWritePPM,		/* fileWriteProc */

+    StringWritePPM,		/* stringWriteProc */

+};

+

+/*

+ * Prototypes for local functions defined in this file:

+ */

+

+static int		ReadPPMFileHeader(Tcl_Channel chan, int *widthPtr,

+			    int *heightPtr, int *maxIntensityPtr);

+static int		ReadPPMStringHeader(Tcl_Obj *dataObj, int *widthPtr,

+			    int *heightPtr, int *maxIntensityPtr,

+			    unsigned char **dataBufferPtr, int *dataSizePtr);

+

+/*

+ *----------------------------------------------------------------------

+ *

+ * FileMatchPPM --

+ *

+ *	This function is invoked by the photo image type to see if a file

+ *	contains image data in PPM format.

+ *

+ * Results:

+ *	The return value is >0 if the first characters in file "f" look like

+ *	PPM data, and 0 otherwise.

+ *

+ * Side effects:

+ *	The access position in f may change.

+ *

+ *----------------------------------------------------------------------

+ */

+

+static int

+FileMatchPPM(

+    Tcl_Channel chan,		/* The image file, open for reading. */

+    CONST char *fileName,	/* The name of the image file. */

+    Tcl_Obj *format,		/* User-specified format string, or NULL. */

+    int *widthPtr, int *heightPtr,

+				/* The dimensions of the image are returned

+				 * here if the file is a valid raw PPM

+				 * file. */

+    Tcl_Interp *interp)		/* unused */

+{

+    int dummy;

+

+    return ReadPPMFileHeader(chan, widthPtr, heightPtr, &dummy);

+}

+

+/*

+ *----------------------------------------------------------------------

+ *

+ * FileReadPPM --

+ *

+ *	This function is called by the photo image type to read PPM 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

+FileReadPPM(

+    Tcl_Interp *interp,		/* Interpreter to use for reporting errors. */

+    Tcl_Channel chan,		/* The image file, open for reading. */

+    CONST char *fileName,	/* The name of the image file. */

+    Tcl_Obj *format,		/* User-specified format string, or NULL. */

+    Tk_PhotoHandle imageHandle,	/* The photo image to write into. */

+    int destX, int destY,	/* Coordinates of top-left pixel in photo

+				 * image to be written to. */

+    int width, int height,	/* Dimensions of block of photo image to be

+				 * written to. */

+    int srcX, int srcY)		/* Coordinates of top-left pixel to be used in

+				 * image being read. */

+{

+    int fileWidth, fileHeight, maxIntensity;

+    int nLines, nBytes, h, type, count;

+    unsigned char *pixelPtr;

+    Tk_PhotoImageBlock block;

+

+    type = ReadPPMFileHeader(chan, &fileWidth, &fileHeight, &maxIntensity);

+    if (type == 0) {

+	Tcl_AppendResult(interp, "couldn't read raw PPM header from file \"",

+		fileName, "\"", NULL);

+	return TCL_ERROR;

+    }

+    if ((fileWidth <= 0) || (fileHeight <= 0)) {

+	Tcl_AppendResult(interp, "PPM image file \"", fileName,

+		"\" has dimension(s) <= 0", NULL);

+	return TCL_ERROR;

+    }

+    if ((maxIntensity <= 0) || (maxIntensity >= 256)) {

+	char buffer[TCL_INTEGER_SPACE];

+

+	sprintf(buffer, "%d", maxIntensity);

+	Tcl_AppendResult(interp, "PPM image file \"", fileName,

+		"\" has bad maximum intensity value ", buffer, NULL);

+	return TCL_ERROR;

+    }

+

+    if ((srcX + width) > fileWidth) {

+	width = fileWidth - srcX;

+    }

+    if ((srcY + height) > fileHeight) {

+	height = fileHeight - srcY;

+    }

+    if ((width <= 0) || (height <= 0)

+	|| (srcX >= fileWidth) || (srcY >= fileHeight)) {

+	return TCL_OK;

+    }

+

+    if (type == PGM) {

+	block.pixelSize = 1;

+	block.offset[0] = 0;

+	block.offset[1] = 0;

+	block.offset[2] = 0;

+    } else {

+	block.pixelSize = 3;

+	block.offset[0] = 0;

+	block.offset[1] = 1;

+	block.offset[2] = 2;

+    }

+    block.offset[3] = 0;

+    block.width = width;

+    block.pitch = block.pixelSize * fileWidth;

+

+    if (Tk_PhotoExpand(interp, imageHandle,

+	    destX + width, destY + height) != TCL_OK) {

+	return TCL_ERROR;

+    }

+

+    if (srcY > 0) {

+	Tcl_Seek(chan, (Tcl_WideInt)(srcY * block.pitch), SEEK_CUR);

+    }

+

+    nLines = (MAX_MEMORY + block.pitch - 1) / block.pitch;

+    if (nLines > height) {

+	nLines = height;

+    }

+    if (nLines <= 0) {

+	nLines = 1;

+    }

+    nBytes = nLines * block.pitch;

+    pixelPtr = (unsigned char *) ckalloc((unsigned) nBytes);

+    block.pixelPtr = pixelPtr + srcX * block.pixelSize;

+

+    for (h = height; h > 0; h -= nLines) {

+	if (nLines > h) {

+	    nLines = h;

+	    nBytes = nLines * block.pitch;

+	}

+	count = Tcl_Read(chan, (char *) pixelPtr, nBytes);

+	if (count != nBytes) {

+	    Tcl_AppendResult(interp, "error reading PPM image file \"",

+		    fileName, "\": ",

+		    Tcl_Eof(chan) ? "not enough data" : Tcl_PosixError(interp),

+		    NULL);

+	    ckfree((char *) pixelPtr);

+	    return TCL_ERROR;

+	}

+	if (maxIntensity != 255) {

+	    unsigned char *p;

+

+	    for (p = pixelPtr; count > 0; count--, p++) {

+		*p = (((int) *p) * 255)/maxIntensity;

+	    }

+	}

+	block.height = nLines;

+	if (Tk_PhotoPutBlock(interp, imageHandle, &block, destX, destY,

+		width, nLines, TK_PHOTO_COMPOSITE_SET) != TCL_OK) {

+	    ckfree((char *) pixelPtr);

+	    return TCL_ERROR;

+	}

+	destY += nLines;

+    }

+

+    ckfree((char *) pixelPtr);

+    return TCL_OK;

+}

+

+/*

+ *----------------------------------------------------------------------

+ *

+ * FileWritePPM --

+ *

+ *	This function is invoked to write image data to a file in PPM format

+ *	(although we can read PGM files, we never write them).

+ *

+ * Results:

+ *	A standard TCL completion code. If TCL_ERROR is returned then an error

+ *	message is left in the interp's result.

+ *

+ * Side effects:

+ *	Data is written to the file given by "fileName".

+ *

+ *----------------------------------------------------------------------

+ */

+

+static int

+FileWritePPM(

+    Tcl_Interp *interp,

+    CONST char *fileName,

+    Tcl_Obj *format,

+    Tk_PhotoImageBlock *blockPtr)

+{

+    Tcl_Channel chan;

+    int w, h, greenOffset, blueOffset, nBytes;

+    unsigned char *pixelPtr, *pixLinePtr;

+    char header[16 + TCL_INTEGER_SPACE * 2];

+

+    chan = Tcl_OpenFileChannel(interp, fileName, "w", 0666);

+    if (chan == NULL) {

+	return TCL_ERROR;

+    }

+

+    if (Tcl_SetChannelOption(interp, chan, "-translation", "binary")

+	    != TCL_OK) {

+	Tcl_Close(NULL, chan);

+	return TCL_ERROR;

+    }

+    if (Tcl_SetChannelOption(interp, chan, "-encoding", "binary")

+	    != TCL_OK) {

+	Tcl_Close(NULL, chan);

+	return TCL_ERROR;

+    }

+

+    sprintf(header, "P6\n%d %d\n255\n", blockPtr->width, blockPtr->height);

+    Tcl_Write(chan, header, -1);

+

+    pixLinePtr = blockPtr->pixelPtr + blockPtr->offset[0];

+    greenOffset = blockPtr->offset[1] - blockPtr->offset[0];

+    blueOffset = blockPtr->offset[2] - blockPtr->offset[0];

+

+    if ((greenOffset == 1) && (blueOffset == 2) && (blockPtr->pixelSize == 3)

+	    && (blockPtr->pitch == (blockPtr->width * 3))) {

+	nBytes = blockPtr->height * blockPtr->pitch;

+	if (Tcl_Write(chan, (char *) pixLinePtr, nBytes) != nBytes) {

+	    goto writeerror;

+	}

+    } else {

+	for (h = blockPtr->height; h > 0; h--) {

+	    pixelPtr = pixLinePtr;

+	    for (w = blockPtr->width; w > 0; w--) {

+		if (    Tcl_Write(chan,(char *)&pixelPtr[0], 1) == -1 ||

+			Tcl_Write(chan,(char *)&pixelPtr[greenOffset],1)==-1 ||

+			Tcl_Write(chan,(char *)&pixelPtr[blueOffset],1) ==-1) {

+		    goto writeerror;

+		}

+		pixelPtr += blockPtr->pixelSize;

+	    }

+	    pixLinePtr += blockPtr->pitch;

+	}

+    }

+

+    if (Tcl_Close(NULL, chan) == 0) {

+	return TCL_OK;

+    }

+    chan = NULL;

+

+  writeerror:

+    Tcl_AppendResult(interp, "error writing \"", fileName, "\": ",

+	    Tcl_PosixError(interp), NULL);

+    if (chan != NULL) {

+	Tcl_Close(NULL, chan);

+    }

+    return TCL_ERROR;

+}

+

+/*

+ *----------------------------------------------------------------------

+ *

+ * StringWritePPM --

+ *

+ *	This function is invoked to write image data to a string in PPM

+ *	format.

+ *

+ * 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

+StringWritePPM(

+    Tcl_Interp *interp,

+    Tcl_Obj *format,

+    Tk_PhotoImageBlock *blockPtr)

+{

+    int w, h, size, greenOffset, blueOffset;

+    unsigned char *pixLinePtr, *byteArray;

+    char header[16 + TCL_INTEGER_SPACE * 2];

+    Tcl_Obj *byteArrayObj;

+

+    sprintf(header, "P6\n%d %d\n255\n", blockPtr->width, blockPtr->height);

+

+    /*

+     * Construct a byte array of the right size with the header and

+     * get a pointer to the data part of it.

+     */

+

+    size = strlen(header);

+    byteArrayObj = Tcl_NewByteArrayObj((unsigned char *)header, size);

+    byteArray = Tcl_SetByteArrayLength(byteArrayObj,

+	    size + 3*blockPtr->width*blockPtr->height);

+    byteArray += size;

+

+    pixLinePtr = blockPtr->pixelPtr + blockPtr->offset[0];

+    greenOffset = blockPtr->offset[1] - blockPtr->offset[0];

+    blueOffset = blockPtr->offset[2] - blockPtr->offset[0];

+

+    /*

+     * Check if we can do the data move in single action.

+     */

+

+    if ((greenOffset == 1) && (blueOffset == 2) && (blockPtr->pixelSize == 3)

+	    && (blockPtr->pitch == (blockPtr->width * 3))) {

+	memcpy(byteArray, pixLinePtr,

+		(unsigned)blockPtr->height * blockPtr->pitch);

+    } else {

+	for (h = blockPtr->height; h > 0; h--) {

+	    unsigned char *pixelPtr = pixLinePtr;

+

+	    for (w = blockPtr->width; w > 0; w--) {

+		*byteArray++ = pixelPtr[0];

+		*byteArray++ = pixelPtr[greenOffset];

+		*byteArray++ = pixelPtr[blueOffset];

+		pixelPtr += blockPtr->pixelSize;

+	    }

+	    pixLinePtr += blockPtr->pitch;

+	}

+    }

+

+    /*

+     * Return the object in the interpreter result.

+     */

+

+    Tcl_SetObjResult(interp, byteArrayObj);

+    return TCL_OK;

+}

+

+/*

+ *----------------------------------------------------------------------

+ *

+ * StringMatchPPM --

+ *

+ *	This function is invoked by the photo image type to see if a string

+ *	contains image data in PPM format.

+ *

+ * Results:

+ *	The return value is >0 if the first characters in file "f" look like

+ *	PPM data, and 0 otherwise.

+ *

+ * Side effects:

+ *	The access position in f may change.

+ *

+ *----------------------------------------------------------------------

+ */

+

+static int

+StringMatchPPM(

+    Tcl_Obj *dataObj,		/* The image data. */

+    Tcl_Obj *format,		/* User-specified format string, or NULL. */

+    int *widthPtr, int *heightPtr,

+				/* The dimensions of the image are returned

+				 * here if the file is a valid raw PPM

+				 * file. */

+    Tcl_Interp *interp)		/* unused */

+{

+    int dummy;

+

+    return ReadPPMStringHeader(dataObj, widthPtr, heightPtr,

+	    &dummy, NULL, NULL);

+}

+

+/*

+ *----------------------------------------------------------------------

+ *

+ * StringReadPPM --

+ *

+ *	This function is called by the photo image type to read PPM format

+ *	data from a string 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:

+ *	New data is added to the image given by imageHandle.

+ *

+ *----------------------------------------------------------------------

+ */

+

+static int

+StringReadPPM(

+    Tcl_Interp *interp,		/* Interpreter to use for reporting errors. */

+    Tcl_Obj *dataObj,		/* The image data. */

+    Tcl_Obj *format,		/* User-specified format string, or NULL. */

+    Tk_PhotoHandle imageHandle,	/* The photo image to write into. */

+    int destX, int destY,	/* Coordinates of top-left pixel in photo

+				 * image to be written to. */

+    int width, int height,	/* Dimensions of block of photo image to be

+				 * written to. */

+    int srcX, int srcY)		/* Coordinates of top-left pixel to be used in

+				 * image being read. */

+{

+    int fileWidth, fileHeight, maxIntensity;

+    int nLines, nBytes, h, type, count, dataSize;

+    unsigned char *pixelPtr, *dataBuffer;

+    Tk_PhotoImageBlock block;

+

+    type = ReadPPMStringHeader(dataObj, &fileWidth, &fileHeight,

+	    &maxIntensity, &dataBuffer, &dataSize);

+    if (type == 0) {

+	Tcl_AppendResult(interp, "couldn't read raw PPM header from string",

+		NULL);

+	return TCL_ERROR;

+    }

+    if ((fileWidth <= 0) || (fileHeight <= 0)) {

+	Tcl_AppendResult(interp, "PPM image data has dimension(s) <= 0",

+		NULL);

+	return TCL_ERROR;

+    }

+    if ((maxIntensity <= 0) || (maxIntensity >= 256)) {

+	char buffer[TCL_INTEGER_SPACE];

+

+	sprintf(buffer, "%d", maxIntensity);

+	Tcl_AppendResult(interp,

+		"PPM image data has bad maximum intensity value ", buffer,

+		NULL);

+	return TCL_ERROR;

+    }

+

+    if ((srcX + width) > fileWidth) {

+	width = fileWidth - srcX;

+    }

+    if ((srcY + height) > fileHeight) {

+	height = fileHeight - srcY;

+    }

+    if ((width <= 0) || (height <= 0)

+	|| (srcX >= fileWidth) || (srcY >= fileHeight)) {

+	return TCL_OK;

+    }

+

+    if (type == PGM) {

+	block.pixelSize = 1;

+	block.offset[0] = 0;

+	block.offset[1] = 0;

+	block.offset[2] = 0;

+    } else {

+	block.pixelSize = 3;

+	block.offset[0] = 0;

+	block.offset[1] = 1;

+	block.offset[2] = 2;

+    }

+    block.offset[3] = 0;

+    block.width = width;

+    block.pitch = block.pixelSize * fileWidth;

+

+    if (srcY > 0) {

+	dataBuffer += srcY * block.pitch;

+	dataSize -= srcY * block.pitch;

+    }

+

+    if (maxIntensity == 255) {

+	/*

+	 * We have all the data in memory, so write everything in one go.

+	 */

+

+	if (block.pitch*height < dataSize) {

+	    Tcl_AppendResult(interp, "truncated PPM data", NULL);

+	    return TCL_ERROR;

+	}

+	block.pixelPtr = dataBuffer + srcX * block.pixelSize;

+	block.height = height;

+	return Tk_PhotoPutBlock(interp, imageHandle, &block, destX, destY,

+		width, height, TK_PHOTO_COMPOSITE_SET);

+    }

+

+    if (Tk_PhotoExpand(interp, imageHandle,

+	    destX + width, destY + height) != TCL_OK) {

+	return TCL_ERROR;

+    }

+

+    nLines = (MAX_MEMORY + block.pitch - 1) / block.pitch;

+    if (nLines > height) {

+	nLines = height;

+    }

+    if (nLines <= 0) {

+	nLines = 1;

+    }

+    nBytes = nLines * block.pitch;

+    pixelPtr = (unsigned char *) ckalloc((unsigned) nBytes);

+    block.pixelPtr = pixelPtr + srcX * block.pixelSize;

+

+    for (h = height; h > 0; h -= nLines) {

+	unsigned char *p;

+

+	if (nLines > h) {

+	    nLines = h;

+	    nBytes = nLines * block.pitch;

+	}

+	if (dataSize < nBytes) {

+	    ckfree((char *) pixelPtr);

+	    Tcl_AppendResult(interp, "truncated PPM data", NULL);

+	    return TCL_ERROR;

+	}

+	for (p=pixelPtr,count=nBytes ; count>0 ; count--,p++,dataBuffer++) {

+	    *p = (((int) *dataBuffer) * 255)/maxIntensity;

+	}

+	dataSize -= nBytes;

+	block.height = nLines;

+	if (Tk_PhotoPutBlock(interp, imageHandle, &block, destX, destY,

+		width, nLines, TK_PHOTO_COMPOSITE_SET) != TCL_OK) {

+	    ckfree((char *) pixelPtr);

+	    return TCL_ERROR;

+	}

+	destY += nLines;

+    }

+

+    ckfree((char *) pixelPtr);

+    return TCL_OK;

+}

+

+/*

+ *----------------------------------------------------------------------

+ *

+ * ReadPPMFileHeader --

+ *

+ *	This function reads the PPM header from the beginning of a PPM file

+ *	and returns information from the header.

+ *

+ * Results:

+ *	The return value is PGM if file "f" appears to start with a valid PGM

+ *	header, PPM if "f" appears to start with a valid PPM header, and 0

+ *	otherwise. If the header is valid, then *widthPtr and *heightPtr are

+ *	modified to hold the dimensions of the image and *maxIntensityPtr is

+ *	modified to hold the value of a "fully on" intensity value.

+ *

+ * Side effects:

+ *	The access position in f advances.

+ *

+ *----------------------------------------------------------------------

+ */

+

+static int

+ReadPPMFileHeader(

+    Tcl_Channel chan,		/* Image file to read the header from. */

+    int *widthPtr, int *heightPtr,

+				/* The dimensions of the image are returned

+				 * here. */

+    int *maxIntensityPtr)	/* The maximum intensity value for the image

+				 * is stored here. */

+{

+#define BUFFER_SIZE 1000

+    char buffer[BUFFER_SIZE], c;

+    int i, numFields, type = 0;

+

+    /*

+     * Read 4 space-separated fields from the file, ignoring comments (any

+     * line that starts with "#").

+     */

+

+    if (Tcl_Read(chan, &c, 1) != 1) {

+	return 0;

+    }

+    i = 0;

+    for (numFields = 0; numFields < 4; numFields++) {

+	/*

+	 * Skip comments and white space.

+	 */

+

+	while (1) {

+	    while (isspace(UCHAR(c))) {

+		if (Tcl_Read(chan, &c, 1) != 1) {

+		    return 0;

+		}

+	    }

+	    if (c != '#') {

+		break;

+	    }

+	    do {

+		if (Tcl_Read(chan, &c, 1) != 1) {

+		    return 0;

+		}

+	    } while (c != '\n');

+	}

+

+	/*

+	 * Read a field (everything up to the next white space).

+	 */

+

+	while (!isspace(UCHAR(c))) {

+	    if (i < (BUFFER_SIZE-2)) {

+		buffer[i] = c;

+		i++;

+	    }

+	    if (Tcl_Read(chan, &c, 1) != 1) {

+		goto done;

+	    }

+	}

+	if (i < (BUFFER_SIZE-1)) {

+	    buffer[i] = ' ';

+	    i++;

+	}

+    }

+

+  done:

+    buffer[i] = 0;

+

+    /*

+     * Parse the fields, which are: id, width, height, maxIntensity.

+     */

+

+    if (strncmp(buffer, "P6 ", 3) == 0) {

+	type = PPM;

+    } else if (strncmp(buffer, "P5 ", 3) == 0) {

+	type = PGM;

+    } else {

+	return 0;

+    }

+    if (sscanf(buffer+3, "%d %d %d", widthPtr, heightPtr, maxIntensityPtr)

+	    != 3) {

+	return 0;

+    }

+    return type;

+}

+

+/*

+ *----------------------------------------------------------------------

+ *

+ * ReadPPMStringHeader --

+ *

+ *	This function reads the PPM header from the beginning of a PPM-format

+ *	string and returns information from the header.

+ *

+ * Results:

+ *	The return value is PGM if the string appears to start with a valid

+ *	PGM header, PPM if the string appears to start with a valid PPM

+ *	header, and 0 otherwise. If the header is valid, then *widthPtr and

+ *	*heightPtr are modified to hold the dimensions of the image and

+ *	*maxIntensityPtr is modified to hold the value of a "fully on"

+ *	intensity value.

+ *

+ * Side effects:

+ *	None

+ *

+ *----------------------------------------------------------------------

+ */

+

+static int

+ReadPPMStringHeader(

+    Tcl_Obj *dataPtr,		/* Object to read the header from. */

+    int *widthPtr, int *heightPtr,

+				/* The dimensions of the image are returned

+				 * here. */

+    int *maxIntensityPtr,	/* The maximum intensity value for the image

+				 * is stored here. */

+    unsigned char **dataBufferPtr,

+    int *dataSizePtr)

+{

+#define BUFFER_SIZE 1000

+    char buffer[BUFFER_SIZE], c;

+    int i, numFields, dataSize, type = 0;

+    unsigned char *dataBuffer;

+

+    dataBuffer = Tcl_GetByteArrayFromObj(dataPtr, &dataSize);

+

+    /*

+     * Read 4 space-separated fields from the string, ignoring comments (any

+     * line that starts with "#").

+     */

+

+    if (dataSize-- < 1) {

+	return 0;

+    }

+    c = (char) (*dataBuffer++);

+    i = 0;

+    for (numFields = 0; numFields < 4; numFields++) {

+	/*

+	 * Skip comments and white space.

+	 */

+

+	while (1) {

+	    while (isspace(UCHAR(c))) {

+		if (dataSize-- < 1) {

+		    return 0;

+		}

+		c = (char) (*dataBuffer++);

+	    }

+	    if (c != '#') {

+		break;

+	    }

+	    do {

+		if (dataSize-- < 1) {

+		    return 0;

+		}

+		c = (char) (*dataBuffer++);

+	    } while (c != '\n');

+	}

+

+	/*

+	 * Read a field (everything up to the next white space).

+	 */

+

+	while (!isspace(UCHAR(c))) {

+	    if (i < (BUFFER_SIZE-2)) {

+		buffer[i] = c;

+		i++;

+	    }

+	    if (dataSize-- < 1) {

+		goto done;

+	    }

+	    c = (char) (*dataBuffer++);

+	}

+	if (i < (BUFFER_SIZE-1)) {

+	    buffer[i] = ' ';

+	    i++;

+	}

+    }

+

+  done:

+    buffer[i] = 0;

+

+    /*

+     * Parse the fields, which are: id, width, height, maxIntensity.

+     */

+

+    if (strncmp(buffer, "P6 ", 3) == 0) {

+	type = PPM;

+    } else if (strncmp(buffer, "P5 ", 3) == 0) {

+	type = PGM;

+    } else {

+	return 0;

+    }

+    if (sscanf(buffer+3, "%d %d %d", widthPtr, heightPtr, maxIntensityPtr)

+	    != 3) {

+	return 0;

+    }

+    if (dataBufferPtr != NULL) {

+	*dataBufferPtr = dataBuffer;

+	*dataSizePtr = dataSize;

+    }

+    return type;

+}

+

+/*

+ * Local Variables:

+ * mode: c

+ * c-basic-offset: 4

+ * fill-column: 78

+ * End:

+ */