diff options
Diffstat (limited to 'ext/gd/libgd/gd_gd2.c')
| -rw-r--r-- | ext/gd/libgd/gd_gd2.c | 829 |
1 files changed, 829 insertions, 0 deletions
diff --git a/ext/gd/libgd/gd_gd2.c b/ext/gd/libgd/gd_gd2.c new file mode 100644 index 0000000..efc6ef4 --- /dev/null +++ b/ext/gd/libgd/gd_gd2.c @@ -0,0 +1,829 @@ +/* + * gd_gd2.c + * + * Implements the I/O and support for the GD2 format. + * + * Changing the definition of GD2_DBG (below) will cause copious messages + * to be displayed while it processes requests. + * + * Designed, Written & Copyright 1999, Philip Warner. + * + */ + +#include <stdio.h> +#include <errno.h> +#include <math.h> +#include <string.h> +#include <stdlib.h> +#include "gd.h" +#include "gdhelpers.h" + +#include <zlib.h> + +#define TRUE 1 +#define FALSE 0 + +/* 2.11: not part of the API, as the save routine can figure it out + * from im->trueColor, and the load routine doesn't need to tell + * the end user the saved format. NOTE: adding 2 is assumed + * to result in the correct format value for truecolor! +*/ +#define GD2_FMT_TRUECOLOR_RAW 3 +#define GD2_FMT_TRUECOLOR_COMPRESSED 4 + +#define gd2_compressed(fmt) (((fmt) == GD2_FMT_COMPRESSED) || ((fmt) == GD2_FMT_TRUECOLOR_COMPRESSED)) +#define gd2_truecolor(fmt) (((fmt) == GD2_FMT_TRUECOLOR_RAW) || ((fmt) == GD2_FMT_TRUECOLOR_COMPRESSED)) + +/* Use this for commenting out debug-print statements. */ +/* Just use the first '#define' to allow all the prints... */ +/* #define GD2_DBG(s) (s) */ +#define GD2_DBG(s) + +typedef struct +{ + int offset; + int size; +} t_chunk_info; + +extern int _gdGetColors(gdIOCtx * in, gdImagePtr im, int gd2xFlag); +extern void _gdPutColors(gdImagePtr im, gdIOCtx * out); + +/* */ +/* Read the extra info in the gd2 header. */ +/* */ +static int _gd2GetHeader(gdIOCtxPtr in, int *sx, int *sy, int *cs, int *vers, int *fmt, int *ncx, int *ncy, t_chunk_info ** chunkIdx) +{ + int i; + int ch; + char id[5]; + t_chunk_info *cidx; + int sidx; + int nc; + + GD2_DBG(php_gd_error("Reading gd2 header info")); + + for (i = 0; i < 4; i++) { + ch = gdGetC(in); + if (ch == EOF) { + goto fail1; + } + id[i] = ch; + } + id[4] = 0; + + GD2_DBG(php_gd_error("Got file code: %s", id)); + + /* Equiv. of 'magick'. */ + if (strcmp(id, GD2_ID) != 0) { + GD2_DBG(php_gd_error("Not a valid gd2 file")); + goto fail1; + } + + /* Version */ + if (gdGetWord(vers, in) != 1) { + goto fail1; + } + GD2_DBG(php_gd_error("Version: %d", *vers)); + + if ((*vers != 1) && (*vers != 2)) { + GD2_DBG(php_gd_error("Bad version: %d", *vers)); + goto fail1; + } + + /* Image Size */ + if (!gdGetWord(sx, in)) { + GD2_DBG(php_gd_error("Could not get x-size")); + goto fail1; + } + if (!gdGetWord(sy, in)) { + GD2_DBG(php_gd_error("Could not get y-size")); + goto fail1; + } + GD2_DBG(php_gd_error("Image is %dx%d", *sx, *sy)); + + /* Chunk Size (pixels, not bytes!) */ + if (gdGetWord(cs, in) != 1) { + goto fail1; + } + GD2_DBG(php_gd_error("ChunkSize: %d", *cs)); + + if ((*cs < GD2_CHUNKSIZE_MIN) || (*cs > GD2_CHUNKSIZE_MAX)) { + GD2_DBG(php_gd_error("Bad chunk size: %d", *cs)); + goto fail1; + } + + /* Data Format */ + if (gdGetWord(fmt, in) != 1) { + goto fail1; + } + GD2_DBG(php_gd_error("Format: %d", *fmt)); + + if ((*fmt != GD2_FMT_RAW) && (*fmt != GD2_FMT_COMPRESSED) && (*fmt != GD2_FMT_TRUECOLOR_RAW) && (*fmt != GD2_FMT_TRUECOLOR_COMPRESSED)) { + GD2_DBG(php_gd_error("Bad data format: %d", *fmt)); + goto fail1; + } + + /* # of chunks wide */ + if (gdGetWord(ncx, in) != 1) { + goto fail1; + } + GD2_DBG(php_gd_error("%d Chunks Wide", *ncx)); + + /* # of chunks high */ + if (gdGetWord(ncy, in) != 1) { + goto fail1; + } + GD2_DBG(php_gd_error("%d Chunks vertically", *ncy)); + + if (gd2_compressed(*fmt)) { + nc = (*ncx) * (*ncy); + GD2_DBG(php_gd_error("Reading %d chunk index entries", nc)); + sidx = sizeof(t_chunk_info) * nc; + if (sidx <= 0) { + goto fail1; + } + cidx = gdCalloc(sidx, 1); + for (i = 0; i < nc; i++) { + if (gdGetInt(&cidx[i].offset, in) != 1) { + goto fail1; + } + if (gdGetInt(&cidx[i].size, in) != 1) { + goto fail1; + } + } + *chunkIdx = cidx; + } + + GD2_DBG(php_gd_error("gd2 header complete")); + + return 1; + +fail1: + return 0; +} + +static gdImagePtr _gd2CreateFromFile (gdIOCtxPtr in, int *sx, int *sy, int *cs, int *vers, int *fmt, int *ncx, int *ncy, t_chunk_info ** cidx) +{ + gdImagePtr im; + + if (_gd2GetHeader (in, sx, sy, cs, vers, fmt, ncx, ncy, cidx) != 1) { + GD2_DBG(php_gd_error("Bad GD2 header")); + goto fail1; + } + + if (gd2_truecolor(*fmt)) { + im = gdImageCreateTrueColor(*sx, *sy); + } else { + im = gdImageCreate(*sx, *sy); + } + if (im == NULL) { + GD2_DBG(php_gd_error("Could not create gdImage")); + goto fail1; + } + + if (!_gdGetColors(in, im, (*vers) == 2)) { + GD2_DBG(php_gd_error("Could not read color palette")); + goto fail2; + } + GD2_DBG(php_gd_error("Image palette completed: %d colours", im->colorsTotal)); + + return im; + +fail2: + gdImageDestroy(im); + return 0; + +fail1: + return 0; +} + +static int _gd2ReadChunk (int offset, char *compBuf, int compSize, char *chunkBuf, uLongf * chunkLen, gdIOCtx * in) +{ + int zerr; + + if (gdTell(in) != offset) { + GD2_DBG(php_gd_error("Positioning in file to %d", offset)); + gdSeek(in, offset); + } else { + GD2_DBG(php_gd_error("Already Positioned in file to %d", offset)); + } + + /* Read and uncompress an entire chunk. */ + GD2_DBG(php_gd_error("Reading file")); + if (gdGetBuf(compBuf, compSize, in) != compSize) { + return FALSE; + } + GD2_DBG(php_gd_error("Got %d bytes. Uncompressing into buffer of %d bytes", compSize, (int)*chunkLen)); + zerr = uncompress((unsigned char *) chunkBuf, chunkLen, (unsigned char *) compBuf, compSize); + if (zerr != Z_OK) { + GD2_DBG(php_gd_error("Error %d from uncompress", zerr)); + return FALSE; + } + GD2_DBG(php_gd_error("Got chunk")); + + return TRUE; +} + +gdImagePtr gdImageCreateFromGd2 (FILE * inFile) +{ + gdIOCtx *in = gdNewFileCtx(inFile); + gdImagePtr im; + + im = gdImageCreateFromGd2Ctx(in); + + in->gd_free(in); + + return im; +} + +gdImagePtr gdImageCreateFromGd2Ptr (int size, void *data) +{ + gdImagePtr im; + gdIOCtx *in = gdNewDynamicCtxEx(size, data, 0); + im = gdImageCreateFromGd2Ctx(in); + in->gd_free(in); + + return im; +} + +gdImagePtr gdImageCreateFromGd2Ctx (gdIOCtxPtr in) +{ + int sx, sy; + int i; + int ncx, ncy, nc, cs, cx, cy; + int x, y, ylo, yhi, xlo, xhi; + int vers, fmt; + t_chunk_info *chunkIdx = NULL; /* So we can gdFree it with impunity. */ + unsigned char *chunkBuf = NULL; /* So we can gdFree it with impunity. */ + int chunkNum = 0; + int chunkMax = 0; + uLongf chunkLen; + int chunkPos = 0; + int compMax = 0; + int bytesPerPixel; + char *compBuf = NULL; /* So we can gdFree it with impunity. */ + + gdImagePtr im; + + /* Get the header */ + if (!(im = _gd2CreateFromFile(in, &sx, &sy, &cs, &vers, &fmt, &ncx, &ncy, &chunkIdx))) { + return 0; + } + + bytesPerPixel = im->trueColor ? 4 : 1; + nc = ncx * ncy; + + if (gd2_compressed(fmt)) { + /* Find the maximum compressed chunk size. */ + compMax = 0; + for (i = 0; (i < nc); i++) { + if (chunkIdx[i].size > compMax) { + compMax = chunkIdx[i].size; + } + } + compMax++; + + /* Allocate buffers */ + chunkMax = cs * bytesPerPixel * cs; + if (chunkMax <= 0) { + return 0; + } + chunkBuf = gdCalloc(chunkMax, 1); + compBuf = gdCalloc(compMax, 1); + + GD2_DBG(php_gd_error("Largest compressed chunk is %d bytes", compMax)); + } + + /* Read the data... */ + for (cy = 0; (cy < ncy); cy++) { + for (cx = 0; (cx < ncx); cx++) { + ylo = cy * cs; + yhi = ylo + cs; + if (yhi > im->sy) { + yhi = im->sy; + } + + GD2_DBG(php_gd_error("Processing Chunk %d (%d, %d), y from %d to %d", chunkNum, cx, cy, ylo, yhi)); + + if (gd2_compressed(fmt)) { + chunkLen = chunkMax; + + if (!_gd2ReadChunk(chunkIdx[chunkNum].offset, compBuf, chunkIdx[chunkNum].size, (char *) chunkBuf, &chunkLen, in)) { + GD2_DBG(php_gd_error("Error reading comproessed chunk")); + goto fail2; + } + + chunkPos = 0; + } + + for (y = ylo; (y < yhi); y++) { + xlo = cx * cs; + xhi = xlo + cs; + if (xhi > im->sx) { + xhi = im->sx; + } + + if (!gd2_compressed(fmt)) { + for (x = xlo; x < xhi; x++) { + if (im->trueColor) { + if (!gdGetInt(&im->tpixels[y][x], in)) { + im->tpixels[y][x] = 0; + } + } else { + int ch; + if (!gdGetByte(&ch, in)) { + ch = 0; + } + im->pixels[y][x] = ch; + } + } + } else { + for (x = xlo; x < xhi; x++) { + if (im->trueColor) { + /* 2.0.1: work around a gcc bug by being verbose. TBB */ + int a = chunkBuf[chunkPos++] << 24; + int r = chunkBuf[chunkPos++] << 16; + int g = chunkBuf[chunkPos++] << 8; + int b = chunkBuf[chunkPos++]; + im->tpixels[y][x] = a + r + g + b; + } else { + im->pixels[y][x] = chunkBuf[chunkPos++]; + } + } + } + } + chunkNum++; + } + } + + GD2_DBG(php_gd_error("Freeing memory")); + + if (chunkBuf) { + gdFree(chunkBuf); + } + if (compBuf) { + gdFree(compBuf); + } + if (chunkIdx) { + gdFree(chunkIdx); + } + + GD2_DBG(php_gd_error("Done")); + + return im; + +fail2: + gdImageDestroy(im); + if (chunkBuf) { + gdFree(chunkBuf); + } + if (compBuf) { + gdFree(compBuf); + } + if (chunkIdx) { + gdFree(chunkIdx); + } + + return 0; +} + +gdImagePtr gdImageCreateFromGd2PartPtr (int size, void *data, int srcx, int srcy, int w, int h) +{ + gdImagePtr im; + gdIOCtx *in = gdNewDynamicCtxEx(size, data, 0); + im = gdImageCreateFromGd2PartCtx(in, srcx, srcy, w, h); + in->gd_free(in); + + return im; +} + +gdImagePtr gdImageCreateFromGd2Part (FILE * inFile, int srcx, int srcy, int w, int h) +{ + gdImagePtr im; + gdIOCtx *in = gdNewFileCtx(inFile); + + im = gdImageCreateFromGd2PartCtx(in, srcx, srcy, w, h); + + in->gd_free(in); + + return im; +} + +gdImagePtr gdImageCreateFromGd2PartCtx (gdIOCtx * in, int srcx, int srcy, int w, int h) +{ + int scx, scy, ecx, ecy, fsx, fsy; + int nc, ncx, ncy, cs, cx, cy; + int x, y, ylo, yhi, xlo, xhi; + int dstart, dpos; + int i; + /* 2.0.12: unsigned is correct; fixes problems with color munging. Thanks to Steven Brown. */ + unsigned int ch; + int vers, fmt; + t_chunk_info *chunkIdx = NULL; + unsigned char *chunkBuf = NULL; + int chunkNum; + int chunkMax = 0; + uLongf chunkLen; + int chunkPos = 0; + int compMax; + char *compBuf = NULL; + + gdImagePtr im; + + if (w<1 || h <1) { + return 0; + } + + /* The next few lines are basically copied from gd2CreateFromFile + * we change the file size, so don't want to use the code directly. + * but we do need to know the file size. + */ + if (_gd2GetHeader(in, &fsx, &fsy, &cs, &vers, &fmt, &ncx, &ncy, &chunkIdx) != 1) { + goto fail1; + } + + GD2_DBG(php_gd_error("File size is %dx%d", fsx, fsy)); + + /* This is the difference - make a file based on size of chunks. */ + if (gd2_truecolor(fmt)) { + im = gdImageCreateTrueColor(w, h); + } else { + im = gdImageCreate(w, h); + } + if (im == NULL) { + goto fail1; + } + + if (!_gdGetColors(in, im, vers == 2)) { + goto fail2; + } + GD2_DBG(php_gd_error("Image palette completed: %d colours", im->colorsTotal)); + + /* Process the header info */ + nc = ncx * ncy; + + if (gd2_compressed(fmt)) { + /* Find the maximum compressed chunk size. */ + compMax = 0; + for (i = 0; (i < nc); i++) { + if (chunkIdx[i].size > compMax) { + compMax = chunkIdx[i].size; + } + } + compMax++; + + if (im->trueColor) { + chunkMax = cs * cs * 4; + } else { + chunkMax = cs * cs; + } + if (chunkMax <= 0) { + goto fail2; + } + + chunkBuf = gdCalloc(chunkMax, 1); + compBuf = gdCalloc(compMax, 1); + } + + /* Work out start/end chunks */ + scx = srcx / cs; + scy = srcy / cs; + if (scx < 0) { + scx = 0; + } + if (scy < 0) { + scy = 0; + } + + ecx = (srcx + w) / cs; + ecy = (srcy + h) / cs; + if (ecx >= ncx) { + ecx = ncx - 1; + } + if (ecy >= ncy) { + ecy = ncy - 1; + } + + /* Remember file position of image data. */ + dstart = gdTell(in); + GD2_DBG(php_gd_error("Data starts at %d", dstart)); + + /* Loop through the chunks. */ + for (cy = scy; (cy <= ecy); cy++) { + ylo = cy * cs; + yhi = ylo + cs; + if (yhi > fsy) { + yhi = fsy; + } + + for (cx = scx; cx <= ecx; cx++) { + + xlo = cx * cs; + xhi = xlo + cs; + if (xhi > fsx) { + xhi = fsx; + } + + GD2_DBG(php_gd_error("Processing Chunk (%d, %d), from %d to %d", cx, cy, ylo, yhi)); + + if (!gd2_compressed(fmt)) { + GD2_DBG(php_gd_error("Using raw format data")); + if (im->trueColor) { + dpos = (cy * (cs * fsx) * 4 + cx * cs * (yhi - ylo) * 4) + dstart; + } else { + dpos = cy * (cs * fsx) + cx * cs * (yhi - ylo) + dstart; + } + + /* gd 2.0.11: gdSeek returns TRUE on success, not 0. Longstanding bug. 01/16/03 */ + if (!gdSeek(in, dpos)) { + php_gd_error_ex(E_WARNING, "Error from seek: %d", errno); + goto fail2; + } + GD2_DBG(php_gd_error("Reading (%d, %d) from position %d", cx, cy, dpos - dstart)); + } else { + chunkNum = cx + cy * ncx; + + chunkLen = chunkMax; + if (!_gd2ReadChunk (chunkIdx[chunkNum].offset, compBuf, chunkIdx[chunkNum].size, (char *)chunkBuf, &chunkLen, in)) { + php_gd_error("Error reading comproessed chunk"); + goto fail2; + } + chunkPos = 0; + GD2_DBG(php_gd_error("Reading (%d, %d) from chunk %d", cx, cy, chunkNum)); + } + + GD2_DBG(php_gd_error(" into (%d, %d) - (%d, %d)", xlo, ylo, xhi, yhi)); + + for (y = ylo; (y < yhi); y++) { + for (x = xlo; x < xhi; x++) { + if (!gd2_compressed(fmt)) { + if (im->trueColor) { + if (!gdGetInt((int *)&ch, in)) { + ch = 0; + } + } else { + ch = gdGetC(in); + if ((int)ch == EOF) { + ch = 0; + } + } + } else { + if (im->trueColor) { + ch = chunkBuf[chunkPos++]; + ch = (ch << 8) + chunkBuf[chunkPos++]; + ch = (ch << 8) + chunkBuf[chunkPos++]; + ch = (ch << 8) + chunkBuf[chunkPos++]; + } else { + ch = chunkBuf[chunkPos++]; + } + } + + /* Only use a point that is in the image. */ + if ((x >= srcx) && (x < (srcx + w)) && (x < fsx) && (x >= 0) && (y >= srcy) && (y < (srcy + h)) && (y < fsy) && (y >= 0)) { + if (im->trueColor) { + im->tpixels[y - srcy][x - srcx] = ch; + } else { + im->pixels[y - srcy][x - srcx] = ch; + } + } + } + } + } + } + + if (chunkBuf) { + gdFree(chunkBuf); + } + if (compBuf) { + gdFree(compBuf); + } + if (chunkIdx) { + gdFree(chunkIdx); + } + + return im; + +fail2: + gdImageDestroy(im); +fail1: + if (chunkBuf) { + gdFree(chunkBuf); + } + if (compBuf) { + gdFree(compBuf); + } + if (chunkIdx) { + gdFree(chunkIdx); + } + + return 0; +} + +static void _gd2PutHeader (gdImagePtr im, gdIOCtx * out, int cs, int fmt, int cx, int cy) +{ + int i; + + /* Send the gd2 id, to verify file format. */ + for (i = 0; i < 4; i++) { + gdPutC((unsigned char) (GD2_ID[i]), out); + } + + /* We put the version info first, so future versions can easily change header info. */ + + gdPutWord(GD2_VERS, out); + gdPutWord(im->sx, out); + gdPutWord(im->sy, out); + gdPutWord(cs, out); + gdPutWord(fmt, out); + gdPutWord(cx, out); + gdPutWord(cy, out); +} + +static void _gdImageGd2 (gdImagePtr im, gdIOCtx * out, int cs, int fmt) +{ + int ncx, ncy, cx, cy; + int x, y, ylo, yhi, xlo, xhi; + int chunkLen; + int chunkNum = 0; + char *chunkData = NULL; /* So we can gdFree it with impunity. */ + char *compData = NULL; /* So we can gdFree it with impunity. */ + uLongf compLen; + int idxPos = 0; + int idxSize; + t_chunk_info *chunkIdx = NULL; /* So we can gdFree it with impunity. */ + int posSave; + int bytesPerPixel = im->trueColor ? 4 : 1; + int compMax = 0; + + /* Force fmt to a valid value since we don't return anything. */ + if ((fmt != GD2_FMT_RAW) && (fmt != GD2_FMT_COMPRESSED)) { + fmt = im->trueColor ? GD2_FMT_TRUECOLOR_COMPRESSED : GD2_FMT_COMPRESSED; + } + if (im->trueColor) { + fmt += 2; + } + /* Make sure chunk size is valid. These are arbitrary values; 64 because it seems + * a little silly to expect performance improvements on a 64x64 bit scale, and + * 4096 because we buffer one chunk, and a 16MB buffer seems a little large - it may be + * OK for one user, but for another to read it, they require the buffer. + */ + if (cs == 0) { + cs = GD2_CHUNKSIZE; + } else if (cs < GD2_CHUNKSIZE_MIN) { + cs = GD2_CHUNKSIZE_MIN; + } else if (cs > GD2_CHUNKSIZE_MAX) { + cs = GD2_CHUNKSIZE_MAX; + } + + /* Work out number of chunks. */ + ncx = im->sx / cs + 1; + ncy = im->sy / cs + 1; + + /* Write the standard header. */ + _gd2PutHeader (im, out, cs, fmt, ncx, ncy); + + if (gd2_compressed(fmt)) { + /* Work out size of buffer for compressed data, If CHUNKSIZE is large, + * then these will be large! + */ + + /* The zlib notes say output buffer size should be (input size) * 1.01 * 12 + * - we'll use 1.02 to be paranoid. + */ + compMax = (int)(cs * bytesPerPixel * cs * 1.02f) + 12; + + /* Allocate the buffers. */ + chunkData = safe_emalloc(cs * bytesPerPixel, cs, 0); + memset(chunkData, 0, cs * bytesPerPixel * cs); + if (compMax <= 0) { + goto fail; + } + compData = gdCalloc(compMax, 1); + + /* Save the file position of chunk index, and allocate enough space for + * each chunk_info block . + */ + idxPos = gdTell(out); + idxSize = ncx * ncy * sizeof(t_chunk_info); + GD2_DBG(php_gd_error("Index size is %d", idxSize)); + gdSeek(out, idxPos + idxSize); + + chunkIdx = safe_emalloc(idxSize, sizeof(t_chunk_info), 0); + memset(chunkIdx, 0, idxSize * sizeof(t_chunk_info)); + } + + _gdPutColors (im, out); + + GD2_DBG(php_gd_error("Size: %dx%d", im->sx, im->sy)); + GD2_DBG(php_gd_error("Chunks: %dx%d", ncx, ncy)); + + for (cy = 0; (cy < ncy); cy++) { + for (cx = 0; (cx < ncx); cx++) { + ylo = cy * cs; + yhi = ylo + cs; + if (yhi > im->sy) { + yhi = im->sy; + } + + GD2_DBG(php_gd_error("Processing Chunk (%dx%d), y from %d to %d", cx, cy, ylo, yhi)); + chunkLen = 0; + for (y = ylo; (y < yhi); y++) { + GD2_DBG(php_gd_error("y=%d: ",y)); + xlo = cx * cs; + xhi = xlo + cs; + if (xhi > im->sx) { + xhi = im->sx; + } + + if (gd2_compressed(fmt)) { + for (x = xlo; x < xhi; x++) { + GD2_DBG(php_gd_error("%d...",x)); + if (im->trueColor) { + int p = im->tpixels[y][x]; + chunkData[chunkLen++] = gdTrueColorGetAlpha(p); + chunkData[chunkLen++] = gdTrueColorGetRed(p); + chunkData[chunkLen++] = gdTrueColorGetGreen(p); + chunkData[chunkLen++] = gdTrueColorGetBlue(p); + } else { + chunkData[chunkLen++] = im->pixels[y][x]; + } + } + } else { + for (x = xlo; x < xhi; x++) { + GD2_DBG(php_gd_error("%d, ",x)); + + if (im->trueColor) { + gdPutInt(im->tpixels[y][x], out); + } else { + gdPutC((unsigned char) im->pixels[y][x], out); + } + } + } + GD2_DBG(php_gd_error("y=%d done.",y)); + } + + if (gd2_compressed(fmt)) { + compLen = compMax; + if (compress((unsigned char *) &compData[0], &compLen, (unsigned char *) &chunkData[0], chunkLen) != Z_OK) { + php_gd_error("Error from compressing"); + } else { + chunkIdx[chunkNum].offset = gdTell(out); + chunkIdx[chunkNum++].size = compLen; + GD2_DBG(php_gd_error("Chunk %d size %d offset %d", chunkNum, chunkIdx[chunkNum - 1].size, chunkIdx[chunkNum - 1].offset)); + + if (gdPutBuf (compData, compLen, out) <= 0) { + /* Any alternate suggestions for handling this? */ + php_gd_error_ex(E_WARNING, "Error %d on write", errno); + } + } + } + } + } + + if (gd2_compressed(fmt)) { + /* Save the position, write the index, restore position (paranoia). */ + GD2_DBG(php_gd_error("Seeking %d to write index", idxPos)); + posSave = gdTell(out); + gdSeek(out, idxPos); + GD2_DBG(php_gd_error("Writing index")); + for (x = 0; x < chunkNum; x++) { + GD2_DBG(php_gd_error("Chunk %d size %d offset %d", x, chunkIdx[x].size, chunkIdx[x].offset)); + gdPutInt(chunkIdx[x].offset, out); + gdPutInt(chunkIdx[x].size, out); + } + gdSeek(out, posSave); + } +fail: + GD2_DBG(php_gd_error("Freeing memory")); + if (chunkData) { + gdFree(chunkData); + } + if (compData) { + gdFree(compData); + } + if (chunkIdx) { + gdFree(chunkIdx); + } + GD2_DBG(php_gd_error("Done")); +} + +void gdImageGd2 (gdImagePtr im, FILE * outFile, int cs, int fmt) +{ + gdIOCtx *out = gdNewFileCtx(outFile); + + _gdImageGd2(im, out, cs, fmt); + + out->gd_free(out); +} + +void *gdImageGd2Ptr (gdImagePtr im, int cs, int fmt, int *size) +{ + void *rv; + gdIOCtx *out = gdNewDynamicCtx(2048, NULL); + + _gdImageGd2(im, out, cs, fmt); + rv = gdDPExtractData(out, size); + out->gd_free(out); + + return rv; +} |