BGD_DECLARE(gdImagePtr) gdImageCreateFromGdCtx (gdIOCtxPtr in)
{
int sx, sy;
int x, y;
gdImagePtr im;
/* Read the header */
im = _gdCreateFromFile (in, &sx, &sy);
if (im == NULL)
{
goto fail1;
};
/* Then the data... */
/* 2.0.12: support truecolor properly in .gd as well as in .gd2.
Problem reported by Andreas Pfaller. */
if (im->trueColor)
{
for (y = 0; (y < sy); y++)
{
for (x = 0; (x < sx); x++)
{
int pix;
if (!gdGetInt (&pix, in))
{
goto fail2;
}
im->tpixels[y][x] = pix;
}
}
}
else
{
for (y = 0; (y < sy); y++)
{
for (x = 0; (x < sx); x++)
{
int ch;
ch = gdGetC (in);
if (ch == EOF)
{
goto fail2;
}
/* ROW-MAJOR IN GD 1.3 */
im->pixels[y][x] = ch;
}
}
}
return im;
fail2:
gdImageDestroy (im);
fail1:
return 0;
}
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 (printf ("Reading gd2 header info\n"));
for (i = 0; i < 4; i++)
{
ch = gdGetC (in);
if (ch == EOF)
{
goto fail1;
};
id[i] = ch;
};
id[4] = 0;
GD2_DBG (printf ("Got file code: %s\n", id));
/* Equiv. of 'magick'. */
if (strcmp (id, GD2_ID) != 0)
{
GD2_DBG (printf ("Not a valid gd2 file\n"));
goto fail1;
};
/* Version */
if (gdGetWord (vers, in) != 1)
{
goto fail1;
};
GD2_DBG (printf ("Version: %d\n", *vers));
if ((*vers != 1) && (*vers != 2))
{
GD2_DBG (printf ("Bad version: %d\n", *vers));
goto fail1;
};
/* Image Size */
if (!gdGetWord (sx, in))
{
GD2_DBG (printf ("Could not get x-size\n"));
goto fail1;
}
if (!gdGetWord (sy, in))
{
GD2_DBG (printf ("Could not get y-size\n"));
goto fail1;
}
GD2_DBG (printf ("Image is %dx%d\n", *sx, *sy));
/* Chunk Size (pixels, not bytes!) */
if (gdGetWord (cs, in) != 1)
{
goto fail1;
};
GD2_DBG (printf ("ChunkSize: %d\n", *cs));
if ((*cs < GD2_CHUNKSIZE_MIN) || (*cs > GD2_CHUNKSIZE_MAX))
{
GD2_DBG (printf ("Bad chunk size: %d\n", *cs));
goto fail1;
};
/* Data Format */
if (gdGetWord (fmt, in) != 1)
{
goto fail1;
};
GD2_DBG (printf ("Format: %d\n", *fmt));
if ((*fmt != GD2_FMT_RAW) && (*fmt != GD2_FMT_COMPRESSED) &&
(*fmt != GD2_FMT_TRUECOLOR_RAW) &&
(*fmt != GD2_FMT_TRUECOLOR_COMPRESSED))
{
GD2_DBG (printf ("Bad data format: %d\n", *fmt));
goto fail1;
};
/* # of chunks wide */
if (gdGetWord (ncx, in) != 1)
{
goto fail1;
};
GD2_DBG (printf ("%d Chunks Wide\n", *ncx));
/* # of chunks high */
if (gdGetWord (ncy, in) != 1)
{
goto fail1;
};
GD2_DBG (printf ("%d Chunks vertically\n", *ncy));
if (gd2_compressed (*fmt))
{
nc = (*ncx) * (*ncy);
GD2_DBG (printf ("Reading %d chunk index entries\n", nc));
sidx = sizeof (t_chunk_info) * nc;
cidx = gdCalloc (sidx, 1);
if (!cidx) {
goto fail1;
}
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 (printf ("gd2 header complete\n"));
return 1;
fail1:
return 0;
}
BGD_DECLARE(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;
/* */
/* 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 (printf ("File size is %dx%d\n", 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 (printf ("Image palette completed: %d colours\n", 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;
}
chunkBuf = gdCalloc (chunkMax, 1);
if (!chunkBuf) {
goto fail2;
}
compBuf = gdCalloc (compMax, 1);
if (!compBuf) {
goto fail2;
}
};
/* Don't bother with this... */
/* if ( (ncx != sx / cs) || (ncy != sy / cs)) { */
/* goto fail2; */
/* }; */
/* 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 (printf ("Data starts at %d\n", 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 (printf
("Processing Chunk (%d, %d), from %d to %d\n", cx, cy, ylo,
yhi));
if (!gd2_compressed (fmt))
{
GD2_DBG (printf ("Using raw format data\n"));
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))
{
fprintf (stderr, "Seek error\n");
goto fail2;
};
GD2_DBG (printf
("Reading (%d, %d) from position %d\n", cx, cy,
dpos - dstart));
}
else
{
chunkNum = cx + cy * ncx;
chunkLen = chunkMax;
if (!_gd2ReadChunk (chunkIdx[chunkNum].offset,
compBuf,
chunkIdx[chunkNum].size,
(char *) chunkBuf, &chunkLen, in))
{
printf ("Error reading comproessed chunk\n");
goto fail2;
};
chunkPos = 0;
GD2_DBG (printf
("Reading (%d, %d) from chunk %d\n", cx, cy,
chunkNum));
};
GD2_DBG (printf
(" into (%d, %d) - (%d, %d)\n", 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;
/*printf("EOF while reading file\n"); */
/*goto fail2; */
}
}
else
{
ch = gdGetC (in);
if ((int) ch == EOF)
{
ch = 0;
/*printf("EOF while reading file\n"); */
/*goto fail2; */
}
}
}
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))
{
/* 2.0.11: tpixels */
if (im->trueColor)
{
im->tpixels[y - srcy][x - srcx] = ch;
}
else
{
im->pixels[y - srcy][x - srcx] = ch;
}
}
};
};
};
};
gdFree (chunkBuf);
gdFree (compBuf);
gdFree (chunkIdx);
return im;
fail2:
gdImageDestroy (im);
fail1:
if (chunkBuf) {
gdFree (chunkBuf);
}
if (compBuf) {
gdFree (compBuf);
}
if (chunkIdx) {
gdFree (chunkIdx);
}
return 0;
}
BGD_DECLARE(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 */
im =
_gd2CreateFromFile (in, &sx, &sy, &cs, &vers, &fmt, &ncx, &ncy,
&chunkIdx);
if (im == NULL)
{
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;
chunkBuf = gdCalloc (chunkMax, 1);
if (!chunkBuf) {
goto fail;
}
compBuf = gdCalloc (compMax, 1);
if (!compBuf) {
goto fail;
}
GD2_DBG (printf ("Largest compressed chunk is %d bytes\n", compMax));
};
/* if ( (ncx != sx / cs) || (ncy != sy / cs)) { */
/* goto fail2; */
/* }; */
/* 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 (printf
("Processing Chunk %d (%d, %d), y from %d to %d\n",
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 (printf ("Error reading comproessed chunk\n"));
goto fail;
};
chunkPos = 0;
};
for (y = ylo; (y < yhi); y++)
{
xlo = cx * cs;
xhi = xlo + cs;
if (xhi > im->sx)
{
xhi = im->sx;
};
/*GD2_DBG(printf("y=%d: ",y)); */
if (!gd2_compressed (fmt))
{
for (x = xlo; x < xhi; x++)
{
if (im->trueColor)
{
if (!gdGetInt (&im->tpixels[y][x], in))
{
/*printf("EOF while reading\n"); */
/*gdImageDestroy(im); */
/*return 0; */
im->tpixels[y][x] = 0;
}
}
else
{
int ch;
if (!gdGetByte (&ch, in))
{
/*printf("EOF while reading\n"); */
/*gdImageDestroy(im); */
/*return 0; */
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++];
/* 2.0.11: tpixels */
im->tpixels[y][x] = a + r + g + b;
}
else
{
im->pixels[y][x] = chunkBuf[chunkPos++];
}
};
};
/*GD2_DBG(printf("\n")); */
};
chunkNum++;
};
};
GD2_DBG (printf ("Freeing memory\n"));
gdFree (chunkBuf);
gdFree (compBuf);
gdFree (chunkIdx);
GD2_DBG (printf ("Done\n"));
return im;
fail:
gdImageDestroy (im);
if (chunkBuf) {
gdFree (chunkBuf);
}
if (compBuf) {
gdFree (compBuf);
}
if (chunkIdx) {
gdFree (chunkIdx);
}
return 0;
}
int
_gdGetColors (gdIOCtx * in, gdImagePtr im, int gd2xFlag)
{
int i;
if (gd2xFlag) {
int trueColorFlag;
if (!gdGetByte (&trueColorFlag, in)) {
goto fail1;
}
/* 2.0.12: detect bad truecolor .gd files created by pre-2.0.12.
Beginning in 2.0.12 truecolor is indicated by the initial 2-byte
signature. */
if (trueColorFlag != im->trueColor) {
goto fail1;
}
/* This should have been a word all along */
if (!im->trueColor) {
if (!gdGetWord (&im->colorsTotal, in)) {
goto fail1;
}
if (im->colorsTotal > gdMaxColors) {
goto fail1;
}
}
/* Int to accommodate truecolor single-color transparency */
if (!gdGetInt (&im->transparent, in)) {
goto fail1;
}
} else {
if (!gdGetByte (&im->colorsTotal, in)) {
goto fail1;
}
if (!gdGetWord (&im->transparent, in)) {
goto fail1;
}
if (im->transparent == 257) {
im->transparent = (-1);
}
}
GD2_DBG (printf
("Palette had %d colours (T=%d)\n", im->colorsTotal,
im->transparent));
if (im->trueColor) {
return TRUE;
}
for (i = 0; (i < gdMaxColors); i++) {
if (!gdGetByte (&im->red[i], in)) {
goto fail1;
}
if (!gdGetByte (&im->green[i], in)) {
goto fail1;
}
if (!gdGetByte (&im->blue[i], in)) {
goto fail1;
}
if (gd2xFlag) {
if (!gdGetByte (&im->alpha[i], in)) {
goto fail1;
}
}
}
for (i = 0; (i < im->colorsTotal); i++) {
im->open[i] = 0;
};
return TRUE;
fail1:
return FALSE;
}
int
_gdGetColors (gdIOCtx * in, gdImagePtr im, int gd2xFlag)
{
int i;
if (gd2xFlag)
{
if (!gdGetByte (&im->trueColor, in))
{
goto fail1;
}
/* This should have been a word all along */
if (!im->trueColor)
{
if (!gdGetWord (&im->colorsTotal, in))
{
goto fail1;
}
}
/* Int to accommodate truecolor single-color transparency */
if (!gdGetInt (&im->transparent, in))
{
goto fail1;
}
}
else
{
if (!gdGetByte (&im->colorsTotal, in))
{
goto fail1;
}
if (!gdGetWord (&im->transparent, in))
{
goto fail1;
}
if (im->transparent == 257)
{
im->transparent = (-1);
}
}
GD2_DBG (printf ("Pallette had %d colours (T=%d)\n", im->colorsTotal, im->transparent));
for (i = 0; (i < gdMaxColors); i++)
{
if (!gdGetByte (&im->red[i], in))
{
goto fail1;
}
if (!gdGetByte (&im->green[i], in))
{
goto fail1;
}
if (!gdGetByte (&im->blue[i], in))
{
goto fail1;
}
if (gd2xFlag)
{
if (!gdGetByte (&im->alpha[i], in))
{
goto fail1;
}
}
}
for (i = 0; (i < im->colorsTotal); i++)
{
im->open[i] = 0;
};
return TRUE;
fail1:
return FALSE;
}
