![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to gd_gd2.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / php / ext / gd / libgd|
Return to gd_gd2.c CVS log | Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / php / ext / gd / libgd |
1.1 misho 1: /*
2: * gd_gd2.c
3: *
4: * Implements the I/O and support for the GD2 format.
5: *
6: * Changing the definition of GD2_DBG (below) will cause copious messages
7: * to be displayed while it processes requests.
8: *
9: * Designed, Written & Copyright 1999, Philip Warner.
10: *
11: */
12:
13: #include <stdio.h>
14: #include <errno.h>
15: #include <math.h>
16: #include <string.h>
17: #include <stdlib.h>
18: #include "gd.h"
19: #include "gdhelpers.h"
20:
21: #include <zlib.h>
22:
23: #define TRUE 1
24: #define FALSE 0
25:
26: /* 2.11: not part of the API, as the save routine can figure it out
27: * from im->trueColor, and the load routine doesn't need to tell
28: * the end user the saved format. NOTE: adding 2 is assumed
29: * to result in the correct format value for truecolor!
30: */
31: #define GD2_FMT_TRUECOLOR_RAW 3
32: #define GD2_FMT_TRUECOLOR_COMPRESSED 4
33:
34: #define gd2_compressed(fmt) (((fmt) == GD2_FMT_COMPRESSED) || ((fmt) == GD2_FMT_TRUECOLOR_COMPRESSED))
35: #define gd2_truecolor(fmt) (((fmt) == GD2_FMT_TRUECOLOR_RAW) || ((fmt) == GD2_FMT_TRUECOLOR_COMPRESSED))
36:
37: /* Use this for commenting out debug-print statements. */
38: /* Just use the first '#define' to allow all the prints... */
39: /* #define GD2_DBG(s) (s) */
40: #define GD2_DBG(s)
41:
42: typedef struct
43: {
44: int offset;
45: int size;
46: } t_chunk_info;
47:
48: extern int _gdGetColors(gdIOCtx * in, gdImagePtr im, int gd2xFlag);
49: extern void _gdPutColors(gdImagePtr im, gdIOCtx * out);
50:
51: /* */
52: /* Read the extra info in the gd2 header. */
53: /* */
54: static int _gd2GetHeader(gdIOCtxPtr in, int *sx, int *sy, int *cs, int *vers, int *fmt, int *ncx, int *ncy, t_chunk_info ** chunkIdx)
55: {
56: int i;
57: int ch;
58: char id[5];
59: t_chunk_info *cidx;
60: int sidx;
61: int nc;
62:
63: GD2_DBG(php_gd_error("Reading gd2 header info"));
64:
65: for (i = 0; i < 4; i++) {
66: ch = gdGetC(in);
67: if (ch == EOF) {
68: goto fail1;
69: }
70: id[i] = ch;
71: }
72: id[4] = 0;
73:
74: GD2_DBG(php_gd_error("Got file code: %s", id));
75:
76: /* Equiv. of 'magick'. */
77: if (strcmp(id, GD2_ID) != 0) {
78: GD2_DBG(php_gd_error("Not a valid gd2 file"));
79: goto fail1;
80: }
81:
82: /* Version */
83: if (gdGetWord(vers, in) != 1) {
84: goto fail1;
85: }
86: GD2_DBG(php_gd_error("Version: %d", *vers));
87:
88: if ((*vers != 1) && (*vers != 2)) {
89: GD2_DBG(php_gd_error("Bad version: %d", *vers));
90: goto fail1;
91: }
92:
93: /* Image Size */
94: if (!gdGetWord(sx, in)) {
95: GD2_DBG(php_gd_error("Could not get x-size"));
96: goto fail1;
97: }
98: if (!gdGetWord(sy, in)) {
99: GD2_DBG(php_gd_error("Could not get y-size"));
100: goto fail1;
101: }
102: GD2_DBG(php_gd_error("Image is %dx%d", *sx, *sy));
103:
104: /* Chunk Size (pixels, not bytes!) */
105: if (gdGetWord(cs, in) != 1) {
106: goto fail1;
107: }
108: GD2_DBG(php_gd_error("ChunkSize: %d", *cs));
109:
110: if ((*cs < GD2_CHUNKSIZE_MIN) || (*cs > GD2_CHUNKSIZE_MAX)) {
111: GD2_DBG(php_gd_error("Bad chunk size: %d", *cs));
112: goto fail1;
113: }
114:
115: /* Data Format */
116: if (gdGetWord(fmt, in) != 1) {
117: goto fail1;
118: }
119: GD2_DBG(php_gd_error("Format: %d", *fmt));
120:
121: if ((*fmt != GD2_FMT_RAW) && (*fmt != GD2_FMT_COMPRESSED) && (*fmt != GD2_FMT_TRUECOLOR_RAW) && (*fmt != GD2_FMT_TRUECOLOR_COMPRESSED)) {
122: GD2_DBG(php_gd_error("Bad data format: %d", *fmt));
123: goto fail1;
124: }
125:
126: /* # of chunks wide */
127: if (gdGetWord(ncx, in) != 1) {
128: goto fail1;
129: }
130: GD2_DBG(php_gd_error("%d Chunks Wide", *ncx));
131:
132: /* # of chunks high */
133: if (gdGetWord(ncy, in) != 1) {
134: goto fail1;
135: }
136: GD2_DBG(php_gd_error("%d Chunks vertically", *ncy));
137:
138: if (gd2_compressed(*fmt)) {
139: nc = (*ncx) * (*ncy);
140: GD2_DBG(php_gd_error("Reading %d chunk index entries", nc));
141: sidx = sizeof(t_chunk_info) * nc;
142: if (sidx <= 0) {
143: goto fail1;
144: }
145: cidx = gdCalloc(sidx, 1);
146: for (i = 0; i < nc; i++) {
147: if (gdGetInt(&cidx[i].offset, in) != 1) {
148: goto fail1;
149: }
150: if (gdGetInt(&cidx[i].size, in) != 1) {
151: goto fail1;
152: }
153: }
154: *chunkIdx = cidx;
155: }
156:
157: GD2_DBG(php_gd_error("gd2 header complete"));
158:
159: return 1;
160:
161: fail1:
162: return 0;
163: }
164:
165: static gdImagePtr _gd2CreateFromFile (gdIOCtxPtr in, int *sx, int *sy, int *cs, int *vers, int *fmt, int *ncx, int *ncy, t_chunk_info ** cidx)
166: {
167: gdImagePtr im;
168:
169: if (_gd2GetHeader (in, sx, sy, cs, vers, fmt, ncx, ncy, cidx) != 1) {
170: GD2_DBG(php_gd_error("Bad GD2 header"));
171: goto fail1;
172: }
173:
174: if (gd2_truecolor(*fmt)) {
175: im = gdImageCreateTrueColor(*sx, *sy);
176: } else {
177: im = gdImageCreate(*sx, *sy);
178: }
179: if (im == NULL) {
180: GD2_DBG(php_gd_error("Could not create gdImage"));
181: goto fail1;
182: }
183:
184: if (!_gdGetColors(in, im, (*vers) == 2)) {
185: GD2_DBG(php_gd_error("Could not read color palette"));
186: goto fail2;
187: }
188: GD2_DBG(php_gd_error("Image palette completed: %d colours", im->colorsTotal));
189:
190: return im;
191:
192: fail2:
193: gdImageDestroy(im);
194: return 0;
195:
196: fail1:
197: return 0;
198: }
199:
200: static int _gd2ReadChunk (int offset, char *compBuf, int compSize, char *chunkBuf, uLongf * chunkLen, gdIOCtx * in)
201: {
202: int zerr;
203:
204: if (gdTell(in) != offset) {
205: GD2_DBG(php_gd_error("Positioning in file to %d", offset));
206: gdSeek(in, offset);
207: } else {
208: GD2_DBG(php_gd_error("Already Positioned in file to %d", offset));
209: }
210:
211: /* Read and uncompress an entire chunk. */
212: GD2_DBG(php_gd_error("Reading file"));
213: if (gdGetBuf(compBuf, compSize, in) != compSize) {
214: return FALSE;
215: }
216: GD2_DBG(php_gd_error("Got %d bytes. Uncompressing into buffer of %d bytes", compSize, (int)*chunkLen));
217: zerr = uncompress((unsigned char *) chunkBuf, chunkLen, (unsigned char *) compBuf, compSize);
218: if (zerr != Z_OK) {
219: GD2_DBG(php_gd_error("Error %d from uncompress", zerr));
220: return FALSE;
221: }
222: GD2_DBG(php_gd_error("Got chunk"));
223:
224: return TRUE;
225: }
226:
227: gdImagePtr gdImageCreateFromGd2 (FILE * inFile)
228: {
229: gdIOCtx *in = gdNewFileCtx(inFile);
230: gdImagePtr im;
231:
232: im = gdImageCreateFromGd2Ctx(in);
233:
234: in->gd_free(in);
235:
236: return im;
237: }
238:
239: gdImagePtr gdImageCreateFromGd2Ptr (int size, void *data)
240: {
241: gdImagePtr im;
242: gdIOCtx *in = gdNewDynamicCtxEx(size, data, 0);
243: im = gdImageCreateFromGd2Ctx(in);
244: in->gd_free(in);
245:
246: return im;
247: }
248:
249: gdImagePtr gdImageCreateFromGd2Ctx (gdIOCtxPtr in)
250: {
251: int sx, sy;
252: int i;
253: int ncx, ncy, nc, cs, cx, cy;
254: int x, y, ylo, yhi, xlo, xhi;
255: int vers, fmt;
256: t_chunk_info *chunkIdx = NULL; /* So we can gdFree it with impunity. */
257: unsigned char *chunkBuf = NULL; /* So we can gdFree it with impunity. */
258: int chunkNum = 0;
259: int chunkMax = 0;
260: uLongf chunkLen;
261: int chunkPos = 0;
262: int compMax = 0;
263: int bytesPerPixel;
264: char *compBuf = NULL; /* So we can gdFree it with impunity. */
265:
266: gdImagePtr im;
267:
268: /* Get the header */
269: if (!(im = _gd2CreateFromFile(in, &sx, &sy, &cs, &vers, &fmt, &ncx, &ncy, &chunkIdx))) {
270: return 0;
271: }
272:
273: bytesPerPixel = im->trueColor ? 4 : 1;
274: nc = ncx * ncy;
275:
276: if (gd2_compressed(fmt)) {
277: /* Find the maximum compressed chunk size. */
278: compMax = 0;
279: for (i = 0; (i < nc); i++) {
280: if (chunkIdx[i].size > compMax) {
281: compMax = chunkIdx[i].size;
282: }
283: }
284: compMax++;
285:
286: /* Allocate buffers */
287: chunkMax = cs * bytesPerPixel * cs;
288: if (chunkMax <= 0) {
289: return 0;
290: }
291: chunkBuf = gdCalloc(chunkMax, 1);
292: compBuf = gdCalloc(compMax, 1);
293:
294: GD2_DBG(php_gd_error("Largest compressed chunk is %d bytes", compMax));
295: }
296:
297: /* Read the data... */
298: for (cy = 0; (cy < ncy); cy++) {
299: for (cx = 0; (cx < ncx); cx++) {
300: ylo = cy * cs;
301: yhi = ylo + cs;
302: if (yhi > im->sy) {
303: yhi = im->sy;
304: }
305:
306: GD2_DBG(php_gd_error("Processing Chunk %d (%d, %d), y from %d to %d", chunkNum, cx, cy, ylo, yhi));
307:
308: if (gd2_compressed(fmt)) {
309: chunkLen = chunkMax;
310:
311: if (!_gd2ReadChunk(chunkIdx[chunkNum].offset, compBuf, chunkIdx[chunkNum].size, (char *) chunkBuf, &chunkLen, in)) {
312: GD2_DBG(php_gd_error("Error reading comproessed chunk"));
313: goto fail2;
314: }
315:
316: chunkPos = 0;
317: }
318:
319: for (y = ylo; (y < yhi); y++) {
320: xlo = cx * cs;
321: xhi = xlo + cs;
322: if (xhi > im->sx) {
323: xhi = im->sx;
324: }
325:
326: if (!gd2_compressed(fmt)) {
327: for (x = xlo; x < xhi; x++) {
328: if (im->trueColor) {
329: if (!gdGetInt(&im->tpixels[y][x], in)) {
330: im->tpixels[y][x] = 0;
331: }
332: } else {
333: int ch;
334: if (!gdGetByte(&ch, in)) {
335: ch = 0;
336: }
337: im->pixels[y][x] = ch;
338: }
339: }
340: } else {
341: for (x = xlo; x < xhi; x++) {
342: if (im->trueColor) {
343: /* 2.0.1: work around a gcc bug by being verbose. TBB */
344: int a = chunkBuf[chunkPos++] << 24;
345: int r = chunkBuf[chunkPos++] << 16;
346: int g = chunkBuf[chunkPos++] << 8;
347: int b = chunkBuf[chunkPos++];
348: im->tpixels[y][x] = a + r + g + b;
349: } else {
350: im->pixels[y][x] = chunkBuf[chunkPos++];
351: }
352: }
353: }
354: }
355: chunkNum++;
356: }
357: }
358:
359: GD2_DBG(php_gd_error("Freeing memory"));
360:
361: if (chunkBuf) {
362: gdFree(chunkBuf);
363: }
364: if (compBuf) {
365: gdFree(compBuf);
366: }
367: if (chunkIdx) {
368: gdFree(chunkIdx);
369: }
370:
371: GD2_DBG(php_gd_error("Done"));
372:
373: return im;
374:
375: fail2:
376: gdImageDestroy(im);
377: if (chunkBuf) {
378: gdFree(chunkBuf);
379: }
380: if (compBuf) {
381: gdFree(compBuf);
382: }
383: if (chunkIdx) {
384: gdFree(chunkIdx);
385: }
386:
387: return 0;
388: }
389:
390: gdImagePtr gdImageCreateFromGd2PartPtr (int size, void *data, int srcx, int srcy, int w, int h)
391: {
392: gdImagePtr im;
393: gdIOCtx *in = gdNewDynamicCtxEx(size, data, 0);
394: im = gdImageCreateFromGd2PartCtx(in, srcx, srcy, w, h);
395: in->gd_free(in);
396:
397: return im;
398: }
399:
400: gdImagePtr gdImageCreateFromGd2Part (FILE * inFile, int srcx, int srcy, int w, int h)
401: {
402: gdImagePtr im;
403: gdIOCtx *in = gdNewFileCtx(inFile);
404:
405: im = gdImageCreateFromGd2PartCtx(in, srcx, srcy, w, h);
406:
407: in->gd_free(in);
408:
409: return im;
410: }
411:
412: gdImagePtr gdImageCreateFromGd2PartCtx (gdIOCtx * in, int srcx, int srcy, int w, int h)
413: {
414: int scx, scy, ecx, ecy, fsx, fsy;
415: int nc, ncx, ncy, cs, cx, cy;
416: int x, y, ylo, yhi, xlo, xhi;
417: int dstart, dpos;
418: int i;
419: /* 2.0.12: unsigned is correct; fixes problems with color munging. Thanks to Steven Brown. */
420: unsigned int ch;
421: int vers, fmt;
422: t_chunk_info *chunkIdx = NULL;
423: unsigned char *chunkBuf = NULL;
424: int chunkNum;
425: int chunkMax = 0;
426: uLongf chunkLen;
427: int chunkPos = 0;
428: int compMax;
429: char *compBuf = NULL;
430:
431: gdImagePtr im;
432:
433: if (w<1 || h <1) {
434: return 0;
435: }
436:
437: /* The next few lines are basically copied from gd2CreateFromFile
438: * we change the file size, so don't want to use the code directly.
439: * but we do need to know the file size.
440: */
441: if (_gd2GetHeader(in, &fsx, &fsy, &cs, &vers, &fmt, &ncx, &ncy, &chunkIdx) != 1) {
442: goto fail1;
443: }
444:
445: GD2_DBG(php_gd_error("File size is %dx%d", fsx, fsy));
446:
447: /* This is the difference - make a file based on size of chunks. */
448: if (gd2_truecolor(fmt)) {
449: im = gdImageCreateTrueColor(w, h);
450: } else {
451: im = gdImageCreate(w, h);
452: }
453: if (im == NULL) {
454: goto fail1;
455: }
456:
457: if (!_gdGetColors(in, im, vers == 2)) {
458: goto fail2;
459: }
460: GD2_DBG(php_gd_error("Image palette completed: %d colours", im->colorsTotal));
461:
462: /* Process the header info */
463: nc = ncx * ncy;
464:
465: if (gd2_compressed(fmt)) {
466: /* Find the maximum compressed chunk size. */
467: compMax = 0;
468: for (i = 0; (i < nc); i++) {
469: if (chunkIdx[i].size > compMax) {
470: compMax = chunkIdx[i].size;
471: }
472: }
473: compMax++;
474:
475: if (im->trueColor) {
476: chunkMax = cs * cs * 4;
477: } else {
478: chunkMax = cs * cs;
479: }
480: if (chunkMax <= 0) {
481: goto fail2;
482: }
483:
484: chunkBuf = gdCalloc(chunkMax, 1);
485: compBuf = gdCalloc(compMax, 1);
486: }
487:
488: /* Work out start/end chunks */
489: scx = srcx / cs;
490: scy = srcy / cs;
491: if (scx < 0) {
492: scx = 0;
493: }
494: if (scy < 0) {
495: scy = 0;
496: }
497:
498: ecx = (srcx + w) / cs;
499: ecy = (srcy + h) / cs;
500: if (ecx >= ncx) {
501: ecx = ncx - 1;
502: }
503: if (ecy >= ncy) {
504: ecy = ncy - 1;
505: }
506:
507: /* Remember file position of image data. */
508: dstart = gdTell(in);
509: GD2_DBG(php_gd_error("Data starts at %d", dstart));
510:
511: /* Loop through the chunks. */
512: for (cy = scy; (cy <= ecy); cy++) {
513: ylo = cy * cs;
514: yhi = ylo + cs;
515: if (yhi > fsy) {
516: yhi = fsy;
517: }
518:
519: for (cx = scx; cx <= ecx; cx++) {
520:
521: xlo = cx * cs;
522: xhi = xlo + cs;
523: if (xhi > fsx) {
524: xhi = fsx;
525: }
526:
527: GD2_DBG(php_gd_error("Processing Chunk (%d, %d), from %d to %d", cx, cy, ylo, yhi));
528:
529: if (!gd2_compressed(fmt)) {
530: GD2_DBG(php_gd_error("Using raw format data"));
531: if (im->trueColor) {
532: dpos = (cy * (cs * fsx) * 4 + cx * cs * (yhi - ylo) * 4) + dstart;
533: } else {
534: dpos = cy * (cs * fsx) + cx * cs * (yhi - ylo) + dstart;
535: }
536:
537: /* gd 2.0.11: gdSeek returns TRUE on success, not 0. Longstanding bug. 01/16/03 */
538: if (!gdSeek(in, dpos)) {
539: php_gd_error_ex(E_WARNING, "Error from seek: %d", errno);
540: goto fail2;
541: }
542: GD2_DBG(php_gd_error("Reading (%d, %d) from position %d", cx, cy, dpos - dstart));
543: } else {
544: chunkNum = cx + cy * ncx;
545:
546: chunkLen = chunkMax;
547: if (!_gd2ReadChunk (chunkIdx[chunkNum].offset, compBuf, chunkIdx[chunkNum].size, (char *)chunkBuf, &chunkLen, in)) {
548: php_gd_error("Error reading comproessed chunk");
549: goto fail2;
550: }
551: chunkPos = 0;
552: GD2_DBG(php_gd_error("Reading (%d, %d) from chunk %d", cx, cy, chunkNum));
553: }
554:
555: GD2_DBG(php_gd_error(" into (%d, %d) - (%d, %d)", xlo, ylo, xhi, yhi));
556:
557: for (y = ylo; (y < yhi); y++) {
558: for (x = xlo; x < xhi; x++) {
559: if (!gd2_compressed(fmt)) {
560: if (im->trueColor) {
561: if (!gdGetInt((int *)&ch, in)) {
562: ch = 0;
563: }
564: } else {
565: ch = gdGetC(in);
566: if ((int)ch == EOF) {
567: ch = 0;
568: }
569: }
570: } else {
571: if (im->trueColor) {
572: ch = chunkBuf[chunkPos++];
573: ch = (ch << 8) + chunkBuf[chunkPos++];
574: ch = (ch << 8) + chunkBuf[chunkPos++];
575: ch = (ch << 8) + chunkBuf[chunkPos++];
576: } else {
577: ch = chunkBuf[chunkPos++];
578: }
579: }
580:
581: /* Only use a point that is in the image. */
582: if ((x >= srcx) && (x < (srcx + w)) && (x < fsx) && (x >= 0) && (y >= srcy) && (y < (srcy + h)) && (y < fsy) && (y >= 0)) {
583: if (im->trueColor) {
584: im->tpixels[y - srcy][x - srcx] = ch;
585: } else {
586: im->pixels[y - srcy][x - srcx] = ch;
587: }
588: }
589: }
590: }
591: }
592: }
593:
594: if (chunkBuf) {
595: gdFree(chunkBuf);
596: }
597: if (compBuf) {
598: gdFree(compBuf);
599: }
600: if (chunkIdx) {
601: gdFree(chunkIdx);
602: }
603:
604: return im;
605:
606: fail2:
607: gdImageDestroy(im);
608: fail1:
609: if (chunkBuf) {
610: gdFree(chunkBuf);
611: }
612: if (compBuf) {
613: gdFree(compBuf);
614: }
615: if (chunkIdx) {
616: gdFree(chunkIdx);
617: }
618:
619: return 0;
620: }
621:
622: static void _gd2PutHeader (gdImagePtr im, gdIOCtx * out, int cs, int fmt, int cx, int cy)
623: {
624: int i;
625:
626: /* Send the gd2 id, to verify file format. */
627: for (i = 0; i < 4; i++) {
628: gdPutC((unsigned char) (GD2_ID[i]), out);
629: }
630:
631: /* We put the version info first, so future versions can easily change header info. */
632:
633: gdPutWord(GD2_VERS, out);
634: gdPutWord(im->sx, out);
635: gdPutWord(im->sy, out);
636: gdPutWord(cs, out);
637: gdPutWord(fmt, out);
638: gdPutWord(cx, out);
639: gdPutWord(cy, out);
640: }
641:
642: static void _gdImageGd2 (gdImagePtr im, gdIOCtx * out, int cs, int fmt)
643: {
644: int ncx, ncy, cx, cy;
645: int x, y, ylo, yhi, xlo, xhi;
646: int chunkLen;
647: int chunkNum = 0;
648: char *chunkData = NULL; /* So we can gdFree it with impunity. */
649: char *compData = NULL; /* So we can gdFree it with impunity. */
650: uLongf compLen;
651: int idxPos = 0;
652: int idxSize;
653: t_chunk_info *chunkIdx = NULL; /* So we can gdFree it with impunity. */
654: int posSave;
655: int bytesPerPixel = im->trueColor ? 4 : 1;
656: int compMax = 0;
657:
658: /* Force fmt to a valid value since we don't return anything. */
659: if ((fmt != GD2_FMT_RAW) && (fmt != GD2_FMT_COMPRESSED)) {
660: fmt = im->trueColor ? GD2_FMT_TRUECOLOR_COMPRESSED : GD2_FMT_COMPRESSED;
661: }
662: if (im->trueColor) {
663: fmt += 2;
664: }
665: /* Make sure chunk size is valid. These are arbitrary values; 64 because it seems
666: * a little silly to expect performance improvements on a 64x64 bit scale, and
667: * 4096 because we buffer one chunk, and a 16MB buffer seems a little large - it may be
668: * OK for one user, but for another to read it, they require the buffer.
669: */
670: if (cs == 0) {
671: cs = GD2_CHUNKSIZE;
672: } else if (cs < GD2_CHUNKSIZE_MIN) {
673: cs = GD2_CHUNKSIZE_MIN;
674: } else if (cs > GD2_CHUNKSIZE_MAX) {
675: cs = GD2_CHUNKSIZE_MAX;
676: }
677:
678: /* Work out number of chunks. */
679: ncx = im->sx / cs + 1;
680: ncy = im->sy / cs + 1;
681:
682: /* Write the standard header. */
683: _gd2PutHeader (im, out, cs, fmt, ncx, ncy);
684:
685: if (gd2_compressed(fmt)) {
686: /* Work out size of buffer for compressed data, If CHUNKSIZE is large,
687: * then these will be large!
688: */
689:
690: /* The zlib notes say output buffer size should be (input size) * 1.01 * 12
691: * - we'll use 1.02 to be paranoid.
692: */
693: compMax = (int)(cs * bytesPerPixel * cs * 1.02f) + 12;
694:
695: /* Allocate the buffers. */
696: chunkData = safe_emalloc(cs * bytesPerPixel, cs, 0);
697: memset(chunkData, 0, cs * bytesPerPixel * cs);
698: if (compMax <= 0) {
699: goto fail;
700: }
701: compData = gdCalloc(compMax, 1);
702:
703: /* Save the file position of chunk index, and allocate enough space for
704: * each chunk_info block .
705: */
706: idxPos = gdTell(out);
707: idxSize = ncx * ncy * sizeof(t_chunk_info);
708: GD2_DBG(php_gd_error("Index size is %d", idxSize));
709: gdSeek(out, idxPos + idxSize);
710:
711: chunkIdx = safe_emalloc(idxSize, sizeof(t_chunk_info), 0);
712: memset(chunkIdx, 0, idxSize * sizeof(t_chunk_info));
713: }
714:
715: _gdPutColors (im, out);
716:
717: GD2_DBG(php_gd_error("Size: %dx%d", im->sx, im->sy));
718: GD2_DBG(php_gd_error("Chunks: %dx%d", ncx, ncy));
719:
720: for (cy = 0; (cy < ncy); cy++) {
721: for (cx = 0; (cx < ncx); cx++) {
722: ylo = cy * cs;
723: yhi = ylo + cs;
724: if (yhi > im->sy) {
725: yhi = im->sy;
726: }
727:
728: GD2_DBG(php_gd_error("Processing Chunk (%dx%d), y from %d to %d", cx, cy, ylo, yhi));
729: chunkLen = 0;
730: for (y = ylo; (y < yhi); y++) {
731: GD2_DBG(php_gd_error("y=%d: ",y));
732: xlo = cx * cs;
733: xhi = xlo + cs;
734: if (xhi > im->sx) {
735: xhi = im->sx;
736: }
737:
738: if (gd2_compressed(fmt)) {
739: for (x = xlo; x < xhi; x++) {
740: GD2_DBG(php_gd_error("%d...",x));
741: if (im->trueColor) {
742: int p = im->tpixels[y][x];
743: chunkData[chunkLen++] = gdTrueColorGetAlpha(p);
744: chunkData[chunkLen++] = gdTrueColorGetRed(p);
745: chunkData[chunkLen++] = gdTrueColorGetGreen(p);
746: chunkData[chunkLen++] = gdTrueColorGetBlue(p);
747: } else {
748: chunkData[chunkLen++] = im->pixels[y][x];
749: }
750: }
751: } else {
752: for (x = xlo; x < xhi; x++) {
753: GD2_DBG(php_gd_error("%d, ",x));
754:
755: if (im->trueColor) {
756: gdPutInt(im->tpixels[y][x], out);
757: } else {
758: gdPutC((unsigned char) im->pixels[y][x], out);
759: }
760: }
761: }
762: GD2_DBG(php_gd_error("y=%d done.",y));
763: }
764:
765: if (gd2_compressed(fmt)) {
766: compLen = compMax;
767: if (compress((unsigned char *) &compData[0], &compLen, (unsigned char *) &chunkData[0], chunkLen) != Z_OK) {
768: php_gd_error("Error from compressing");
769: } else {
770: chunkIdx[chunkNum].offset = gdTell(out);
771: chunkIdx[chunkNum++].size = compLen;
772: GD2_DBG(php_gd_error("Chunk %d size %d offset %d", chunkNum, chunkIdx[chunkNum - 1].size, chunkIdx[chunkNum - 1].offset));
773:
774: if (gdPutBuf (compData, compLen, out) <= 0) {
775: /* Any alternate suggestions for handling this? */
776: php_gd_error_ex(E_WARNING, "Error %d on write", errno);
777: }
778: }
779: }
780: }
781: }
782:
783: if (gd2_compressed(fmt)) {
784: /* Save the position, write the index, restore position (paranoia). */
785: GD2_DBG(php_gd_error("Seeking %d to write index", idxPos));
786: posSave = gdTell(out);
787: gdSeek(out, idxPos);
788: GD2_DBG(php_gd_error("Writing index"));
789: for (x = 0; x < chunkNum; x++) {
790: GD2_DBG(php_gd_error("Chunk %d size %d offset %d", x, chunkIdx[x].size, chunkIdx[x].offset));
791: gdPutInt(chunkIdx[x].offset, out);
792: gdPutInt(chunkIdx[x].size, out);
793: }
794: gdSeek(out, posSave);
795: }
796: fail:
797: GD2_DBG(php_gd_error("Freeing memory"));
798: if (chunkData) {
799: gdFree(chunkData);
800: }
801: if (compData) {
802: gdFree(compData);
803: }
804: if (chunkIdx) {
805: gdFree(chunkIdx);
806: }
807: GD2_DBG(php_gd_error("Done"));
808: }
809:
810: void gdImageGd2 (gdImagePtr im, FILE * outFile, int cs, int fmt)
811: {
812: gdIOCtx *out = gdNewFileCtx(outFile);
813:
814: _gdImageGd2(im, out, cs, fmt);
815:
816: out->gd_free(out);
817: }
818:
819: void *gdImageGd2Ptr (gdImagePtr im, int cs, int fmt, int *size)
820: {
821: void *rv;
822: gdIOCtx *out = gdNewDynamicCtx(2048, NULL);
823:
824: _gdImageGd2(im, out, cs, fmt);
825: rv = gdDPExtractData(out, size);
826: out->gd_free(out);
827:
828: return rv;
829: }