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