xref: /PHP-5.5/ext/gd/libgd/gd_gif_in.c (revision bd31cb75)
1 #include <stdio.h>
2 #include <math.h>
3 #include <string.h>
4 #include <stdlib.h>
5 #include "gd.h"
6 
7 #include "php.h"
8 
9 /* Used only when debugging GIF compression code */
10 /* #define DEBUGGING_ENVARS */
11 
12 #ifdef DEBUGGING_ENVARS
13 
14 static int verbose_set = 0;
15 static int verbose;
16 #define VERBOSE (verbose_set?verbose:set_verbose())
17 
set_verbose(void)18 static int set_verbose(void)
19 {
20 	verbose = !!getenv("GIF_VERBOSE");
21 	verbose_set = 1;
22 	return(verbose);
23 }
24 
25 #else
26 
27 #define VERBOSE 0
28 
29 #endif
30 
31 
32 #define        MAXCOLORMAPSIZE         256
33 
34 #define        TRUE    1
35 #define        FALSE   0
36 
37 #define CM_RED         0
38 #define CM_GREEN       1
39 #define CM_BLUE                2
40 
41 #define        MAX_LWZ_BITS            12
42 
43 #define INTERLACE              0x40
44 #define LOCALCOLORMAP  0x80
45 #define BitSet(byte, bit)      (((byte) & (bit)) == (bit))
46 
47 #define        ReadOK(file,buffer,len) (gdGetBuf(buffer, len, file) > 0)
48 
49 #define LM_to_uint(a,b)                        (((b)<<8)|(a))
50 
51 /* We may eventually want to use this information, but def it out for now */
52 #if 0
53 static struct {
54 	unsigned int    Width;
55 	unsigned int    Height;
56 	unsigned char   ColorMap[3][MAXCOLORMAPSIZE];
57 	unsigned int    BitPixel;
58 	unsigned int    ColorResolution;
59 	unsigned int    Background;
60 	unsigned int    AspectRatio;
61 } GifScreen;
62 #endif
63 
64 #if 0
65 static struct {
66 	int     transparent;
67 	int     delayTime;
68 	int     inputFlag;
69 	int     disposal;
70 } Gif89 = { -1, -1, -1, 0 };
71 #endif
72 
73 #define STACK_SIZE ((1<<(MAX_LWZ_BITS))*2)
74 
75 #define CSD_BUF_SIZE 280
76 
77 typedef struct {
78 	unsigned char    buf[CSD_BUF_SIZE];
79 	int              curbit, lastbit, done, last_byte;
80 } CODE_STATIC_DATA;
81 
82 typedef struct {
83 	int fresh;
84 	int code_size, set_code_size;
85 	int max_code, max_code_size;
86 	int firstcode, oldcode;
87 	int clear_code, end_code;
88 	int table[2][(1<< MAX_LWZ_BITS)];
89 	int stack[STACK_SIZE], *sp;
90 	CODE_STATIC_DATA scd;
91 } LZW_STATIC_DATA;
92 
93 static int ReadColorMap (gdIOCtx *fd, int number, unsigned char (*buffer)[256]);
94 static int DoExtension (gdIOCtx *fd, int label, int *Transparent, int *ZeroDataBlockP);
95 static int GetDataBlock (gdIOCtx *fd, unsigned char *buf, int *ZeroDataBlockP);
96 static int GetCode (gdIOCtx *fd, CODE_STATIC_DATA *scd, int code_size, int flag, int *ZeroDataBlockP);
97 static int LWZReadByte (gdIOCtx *fd, LZW_STATIC_DATA *sd, char flag, int input_code_size, int *ZeroDataBlockP);
98 
99 static void ReadImage (gdImagePtr im, gdIOCtx *fd, int len, int height, unsigned char (*cmap)[256], int interlace, int *ZeroDataBlockP); /*1.4//, int ignore); */
100 
gdImageCreateFromGifSource(gdSourcePtr inSource)101 gdImagePtr gdImageCreateFromGifSource(gdSourcePtr inSource) /* {{{ */
102 {
103 	gdIOCtx         *in = gdNewSSCtx(inSource, NULL);
104 	gdImagePtr      im;
105 
106 	im = gdImageCreateFromGifCtx(in);
107 
108 	in->gd_free(in);
109 
110 	return im;
111 }
112 /* }}} */
113 
gdImageCreateFromGif(FILE * fdFile)114 gdImagePtr gdImageCreateFromGif(FILE *fdFile) /* {{{ */
115 {
116 	gdIOCtx		*fd = gdNewFileCtx(fdFile);
117 	gdImagePtr    	im = 0;
118 
119 	im = gdImageCreateFromGifCtx(fd);
120 
121 	fd->gd_free(fd);
122 
123 	return im;
124 }
125 /* }}} */
126 
gdImageCreateFromGifCtx(gdIOCtxPtr fd)127 gdImagePtr gdImageCreateFromGifCtx(gdIOCtxPtr fd) /* {{{ */
128 {
129 	int BitPixel;
130 #if 0
131 	int ColorResolution;
132 	int Background;
133 	int AspectRatio;
134 #endif
135 	int Transparent = (-1);
136 	unsigned char   buf[16];
137 	unsigned char   c;
138 	unsigned char   ColorMap[3][MAXCOLORMAPSIZE];
139 	unsigned char   localColorMap[3][MAXCOLORMAPSIZE];
140 	int             imw, imh, screen_width, screen_height;
141 	int             gif87a, useGlobalColormap;
142 	int             bitPixel;
143 	int	       i;
144 	/*1.4//int             imageCount = 0; */
145 
146 	int ZeroDataBlock = FALSE;
147 	int haveGlobalColormap;
148 	gdImagePtr im = 0;
149 
150 	/*1.4//imageNumber = 1; */
151 	if (! ReadOK(fd,buf,6)) {
152 		return 0;
153 	}
154 	if (strncmp((char *)buf,"GIF",3) != 0) {
155 		return 0;
156 	}
157 
158 	if (memcmp((char *)buf+3, "87a", 3) == 0) {
159 		gif87a = 1;
160 	} else if (memcmp((char *)buf+3, "89a", 3) == 0) {
161 		gif87a = 0;
162 	} else {
163 		return 0;
164 	}
165 
166 	if (! ReadOK(fd,buf,7)) {
167 		return 0;
168 	}
169 
170 	BitPixel        = 2<<(buf[4]&0x07);
171 #if 0
172 	ColorResolution = (int) (((buf[4]&0x70)>>3)+1);
173 	Background      = buf[5];
174 	AspectRatio     = buf[6];
175 #endif
176 	screen_width = imw = LM_to_uint(buf[0],buf[1]);
177 	screen_height = imh = LM_to_uint(buf[2],buf[3]);
178 
179 	haveGlobalColormap = BitSet(buf[4], LOCALCOLORMAP);    /* Global Colormap */
180 	if (haveGlobalColormap) {
181 		if (ReadColorMap(fd, BitPixel, ColorMap)) {
182 			return 0;
183 		}
184 	}
185 
186 	for (;;) {
187 		int top, left;
188 		int width, height;
189 
190 		if (! ReadOK(fd,&c,1)) {
191 			return 0;
192 		}
193 		if (c == ';') {         /* GIF terminator */
194 			goto terminated;
195 		}
196 
197 		if (c == '!') {         /* Extension */
198 			if (! ReadOK(fd,&c,1)) {
199 				return 0;
200 			}
201 			DoExtension(fd, c, &Transparent, &ZeroDataBlock);
202 			continue;
203 		}
204 
205 		if (c != ',') {         /* Not a valid start character */
206 			continue;
207 		}
208 
209 		/*1.4//++imageCount; */
210 
211 		if (! ReadOK(fd,buf,9)) {
212 			return 0;
213 		}
214 
215 		useGlobalColormap = ! BitSet(buf[8], LOCALCOLORMAP);
216 
217 		bitPixel = 1<<((buf[8]&0x07)+1);
218 		left = LM_to_uint(buf[0], buf[1]);
219 		top = LM_to_uint(buf[2], buf[3]);
220 		width = LM_to_uint(buf[4], buf[5]);
221 		height = LM_to_uint(buf[6], buf[7]);
222 
223 		if (left + width > screen_width || top + height > screen_height) {
224 			if (VERBOSE) {
225 				printf("Frame is not confined to screen dimension.\n");
226 			}
227 			return 0;
228 		}
229 
230 		if (!(im = gdImageCreate(width, height))) {
231 			return 0;
232 		}
233 		im->interlace = BitSet(buf[8], INTERLACE);
234 		if (!useGlobalColormap) {
235 			if (ReadColorMap(fd, bitPixel, localColorMap)) {
236 				gdImageDestroy(im);
237 				return 0;
238 			}
239 			ReadImage(im, fd, width, height, localColorMap,
240 					BitSet(buf[8], INTERLACE), &ZeroDataBlock);
241 		} else {
242 			if (!haveGlobalColormap) {
243 				gdImageDestroy(im);
244 				return 0;
245 			}
246 			ReadImage(im, fd, width, height,
247 						ColorMap,
248 						BitSet(buf[8], INTERLACE), &ZeroDataBlock);
249 		}
250 		if (Transparent != (-1)) {
251 			gdImageColorTransparent(im, Transparent);
252 		}
253 		goto terminated;
254 	}
255 
256 terminated:
257 	/* Terminator before any image was declared! */
258 	if (!im) {
259 		return 0;
260 	}
261 	if (!im->colorsTotal) {
262 		gdImageDestroy(im);
263 		return 0;
264 	}
265 	/* Check for open colors at the end, so
266 	   we can reduce colorsTotal and ultimately
267 	   BitsPerPixel */
268 	for (i=((im->colorsTotal-1)); (i>=0); i--) {
269 		if (im->open[i]) {
270 			im->colorsTotal--;
271 		} else {
272 			break;
273 		}
274 	}
275 	return im;
276 }
277 /* }}} */
278 
ReadColorMap(gdIOCtx * fd,int number,unsigned char (* buffer)[256])279 static int ReadColorMap(gdIOCtx *fd, int number, unsigned char (*buffer)[256]) /* {{{ */
280 {
281 	int             i;
282 	unsigned char   rgb[3];
283 
284 
285 	for (i = 0; i < number; ++i) {
286 		if (! ReadOK(fd, rgb, sizeof(rgb))) {
287 			return TRUE;
288 		}
289 		buffer[CM_RED][i] = rgb[0] ;
290 		buffer[CM_GREEN][i] = rgb[1] ;
291 		buffer[CM_BLUE][i] = rgb[2] ;
292 	}
293 
294 
295 	return FALSE;
296 }
297 /* }}} */
298 
299 static int
DoExtension(gdIOCtx * fd,int label,int * Transparent,int * ZeroDataBlockP)300 DoExtension(gdIOCtx *fd, int label, int *Transparent, int *ZeroDataBlockP)
301 {
302 	unsigned char buf[256];
303 
304 	switch (label) {
305 		case 0xf9:              /* Graphic Control Extension */
306 			memset(buf, 0, 4); /* initialize a few bytes in the case the next function fails */
307                (void) GetDataBlock(fd, (unsigned char*) buf, ZeroDataBlockP);
308 #if 0
309 			Gif89.disposal    = (buf[0] >> 2) & 0x7;
310 			Gif89.inputFlag   = (buf[0] >> 1) & 0x1;
311 			Gif89.delayTime   = LM_to_uint(buf[1],buf[2]);
312 #endif
313 			if ((buf[0] & 0x1) != 0)
314 				*Transparent = buf[3];
315 
316 			while (GetDataBlock(fd, (unsigned char*) buf, ZeroDataBlockP) > 0);
317 			return FALSE;
318 		default:
319 			break;
320 	}
321        while (GetDataBlock(fd, (unsigned char*) buf, ZeroDataBlockP) > 0)
322 		;
323 
324 	return FALSE;
325 }
326 /* }}} */
327 
328 static int
GetDataBlock_(gdIOCtx * fd,unsigned char * buf,int * ZeroDataBlockP)329 GetDataBlock_(gdIOCtx *fd, unsigned char *buf, int *ZeroDataBlockP)
330 {
331 	unsigned char   count;
332 
333 	if (! ReadOK(fd,&count,1)) {
334 		return -1;
335 	}
336 
337 	*ZeroDataBlockP = count == 0;
338 
339 	if ((count != 0) && (! ReadOK(fd, buf, count))) {
340 		return -1;
341 	}
342 
343 	return count;
344 }
345 /* }}} */
346 
347 static int
GetDataBlock(gdIOCtx * fd,unsigned char * buf,int * ZeroDataBlockP)348 GetDataBlock(gdIOCtx *fd, unsigned char *buf, int *ZeroDataBlockP)
349 {
350 	int rv;
351 	int i;
352 
353 	rv = GetDataBlock_(fd,buf, ZeroDataBlockP);
354 	if (VERBOSE) {
355 		char *tmp = NULL;
356 		if (rv > 0) {
357 			tmp = safe_emalloc(3 * rv, sizeof(char), 1);
358 			for (i=0;i<rv;i++) {
359 				sprintf(&tmp[3*sizeof(char)*i], " %02x", buf[i]);
360 			}
361 		} else {
362 			tmp = estrdup("");
363 		}
364 		php_gd_error_ex(E_NOTICE, "[GetDataBlock returning %d: %s]", rv, tmp);
365 		efree(tmp);
366 	}
367 	return(rv);
368 }
369 /* }}} */
370 
371 static int
GetCode_(gdIOCtx * fd,CODE_STATIC_DATA * scd,int code_size,int flag,int * ZeroDataBlockP)372 GetCode_(gdIOCtx *fd, CODE_STATIC_DATA *scd, int code_size, int flag, int *ZeroDataBlockP)
373 {
374 	int           i, j, ret;
375 	unsigned char count;
376 
377 	if (flag) {
378 		scd->curbit = 0;
379 		scd->lastbit = 0;
380 		scd->last_byte = 0;
381 		scd->done = FALSE;
382 		return 0;
383 	}
384 
385 	if ( (scd->curbit + code_size) >= scd->lastbit) {
386 		if (scd->done) {
387 			if (scd->curbit >= scd->lastbit) {
388 				/* Oh well */
389 			}
390 			return -1;
391 		}
392 		scd->buf[0] = scd->buf[scd->last_byte-2];
393 		scd->buf[1] = scd->buf[scd->last_byte-1];
394 
395                if ((count = GetDataBlock(fd, &scd->buf[2], ZeroDataBlockP)) <= 0)
396 			scd->done = TRUE;
397 
398 		scd->last_byte = 2 + count;
399 		scd->curbit = (scd->curbit - scd->lastbit) + 16;
400 		scd->lastbit = (2+count)*8 ;
401 	}
402 
403 	if ((scd->curbit + code_size - 1) >= (CSD_BUF_SIZE * 8)) {
404 		ret = -1;
405 	} else {
406 		ret = 0;
407 		for (i = scd->curbit, j = 0; j < code_size; ++i, ++j) {
408 			ret |= ((scd->buf[i / 8] & (1 << (i % 8))) != 0) << j;
409 		}
410 	}
411 
412 	scd->curbit += code_size;
413 	return ret;
414 }
415 
416 static int
GetCode(gdIOCtx * fd,CODE_STATIC_DATA * scd,int code_size,int flag,int * ZeroDataBlockP)417 GetCode(gdIOCtx *fd, CODE_STATIC_DATA *scd, int code_size, int flag, int *ZeroDataBlockP)
418 {
419 	int rv;
420 
421  rv = GetCode_(fd, scd, code_size,flag, ZeroDataBlockP);
422  if (VERBOSE) printf("[GetCode(,%d,%d) returning %d]\n",code_size,flag,rv);
423 	return(rv);
424 }
425 /* }}} */
426 
427 static int
LWZReadByte_(gdIOCtx * fd,LZW_STATIC_DATA * sd,char flag,int input_code_size,int * ZeroDataBlockP)428 LWZReadByte_(gdIOCtx *fd, LZW_STATIC_DATA *sd, char flag, int input_code_size, int *ZeroDataBlockP)
429 {
430 	int code, incode, i;
431 
432 	if (flag) {
433 		sd->set_code_size = input_code_size;
434 		sd->code_size = sd->set_code_size+1;
435 		sd->clear_code = 1 << sd->set_code_size ;
436 		sd->end_code = sd->clear_code + 1;
437 		sd->max_code_size = 2*sd->clear_code;
438 		sd->max_code = sd->clear_code+2;
439 
440 		GetCode(fd, &sd->scd, 0, TRUE, ZeroDataBlockP);
441 
442 		sd->fresh = TRUE;
443 
444 		for (i = 0; i < sd->clear_code; ++i) {
445 			sd->table[0][i] = 0;
446 			sd->table[1][i] = i;
447 		}
448 		for (; i < (1<<MAX_LWZ_BITS); ++i)
449 			sd->table[0][i] = sd->table[1][0] = 0;
450 
451 		sd->sp = sd->stack;
452 
453 		return 0;
454 	} else if (sd->fresh) {
455 		sd->fresh = FALSE;
456 		do {
457 			sd->firstcode = sd->oldcode =
458 			GetCode(fd, &sd->scd, sd->code_size, FALSE, ZeroDataBlockP);
459 		} while (sd->firstcode == sd->clear_code);
460 		return sd->firstcode;
461 	}
462 
463 	if (sd->sp > sd->stack)
464 		return *--sd->sp;
465 
466 		while ((code = GetCode(fd, &sd->scd, sd->code_size, FALSE, ZeroDataBlockP)) >= 0) {
467 		if (code == sd->clear_code) {
468 			for (i = 0; i < sd->clear_code; ++i) {
469 				sd->table[0][i] = 0;
470 				sd->table[1][i] = i;
471 			}
472 			for (; i < (1<<MAX_LWZ_BITS); ++i)
473 				sd->table[0][i] = sd->table[1][i] = 0;
474 			sd->code_size = sd->set_code_size+1;
475 			sd->max_code_size = 2*sd->clear_code;
476 			sd->max_code = sd->clear_code+2;
477 			sd->sp = sd->stack;
478 			sd->firstcode = sd->oldcode =
479 								GetCode(fd, &sd->scd, sd->code_size, FALSE, ZeroDataBlockP);
480 			return sd->firstcode;
481 		} else if (code == sd->end_code) {
482 			int             count;
483 			unsigned char   buf[260];
484 
485 			if (*ZeroDataBlockP)
486 				return -2;
487 
488 			while ((count = GetDataBlock(fd, buf, ZeroDataBlockP)) > 0)
489 				;
490 
491 			if (count != 0)
492 				return -2;
493 		}
494 
495 		incode = code;
496 
497 		if (sd->sp == (sd->stack + STACK_SIZE)) {
498 			/* Bad compressed data stream */
499 			return -1;
500 		}
501 
502 		if (code >= sd->max_code) {
503 			*sd->sp++ = sd->firstcode;
504 			code = sd->oldcode;
505 		}
506 
507 		while (code >= sd->clear_code) {
508 			if (sd->sp == (sd->stack + STACK_SIZE)) {
509 				/* Bad compressed data stream */
510 				return -1;
511 			}
512 			*sd->sp++ = sd->table[1][code];
513 			if (code == sd->table[0][code]) {
514 				/* Oh well */
515 			}
516 			code = sd->table[0][code];
517 		}
518 
519 		*sd->sp++ = sd->firstcode = sd->table[1][code];
520 
521 		if ((code = sd->max_code) <(1<<MAX_LWZ_BITS)) {
522 			sd->table[0][code] = sd->oldcode;
523 			sd->table[1][code] = sd->firstcode;
524 			++sd->max_code;
525 			if ((sd->max_code >= sd->max_code_size) &&
526 					(sd->max_code_size < (1<<MAX_LWZ_BITS))) {
527 				sd->max_code_size *= 2;
528 				++sd->code_size;
529 			}
530 		}
531 
532 		sd->oldcode = incode;
533 
534 		if (sd->sp > sd->stack)
535 			return *--sd->sp;
536 	}
537 	return code;
538 }
539 /* }}} */
540 
541 static int
LWZReadByte(gdIOCtx * fd,LZW_STATIC_DATA * sd,char flag,int input_code_size,int * ZeroDataBlockP)542 LWZReadByte(gdIOCtx *fd, LZW_STATIC_DATA *sd, char flag, int input_code_size, int *ZeroDataBlockP)
543 {
544 	int rv;
545 
546  rv = LWZReadByte_(fd, sd, flag, input_code_size, ZeroDataBlockP);
547  if (VERBOSE) printf("[LWZReadByte(,%d,%d) returning %d]\n",flag,input_code_size,rv);
548 	return(rv);
549 }
550 /* }}} */
551 
552 static void
ReadImage(gdImagePtr im,gdIOCtx * fd,int len,int height,unsigned char (* cmap)[256],int interlace,int * ZeroDataBlockP)553 ReadImage(gdImagePtr im, gdIOCtx *fd, int len, int height, unsigned char (*cmap)[256], int interlace, int *ZeroDataBlockP) /*1.4//, int ignore) */
554 {
555 	unsigned char   c;
556 	int             v;
557 	int             xpos = 0, ypos = 0, pass = 0;
558 	int i;
559 	LZW_STATIC_DATA sd;
560 
561 
562 	/*
563 	 **  Initialize the Compression routines
564 	 */
565 	if (! ReadOK(fd,&c,1)) {
566 		return;
567 	}
568 
569 	if (c > MAX_LWZ_BITS) {
570 		return;
571 	}
572 
573 	/* Stash the color map into the image */
574 	for (i=0; (i<gdMaxColors); i++) {
575 		im->red[i] = cmap[CM_RED][i];
576 		im->green[i] = cmap[CM_GREEN][i];
577 		im->blue[i] = cmap[CM_BLUE][i];
578 		im->open[i] = 1;
579 	}
580 	/* Many (perhaps most) of these colors will remain marked open. */
581 	im->colorsTotal = gdMaxColors;
582 	if (LWZReadByte(fd, &sd, TRUE, c, ZeroDataBlockP) < 0) {
583 		return;
584 	}
585 
586 	/*
587 	 **  If this is an "uninteresting picture" ignore it.
588 	 **  REMOVED For 1.4
589 	 */
590 	/*if (ignore) { */
591 	/*        while (LWZReadByte(fd, &sd, FALSE, c) >= 0) */
592 	/*                ; */
593 	/*        return; */
594 	/*} */
595 
596 	while ((v = LWZReadByte(fd, &sd, FALSE, c, ZeroDataBlockP)) >= 0) {
597 		if (v >= gdMaxColors) {
598 			v = 0;
599 		}
600 		/* This how we recognize which colors are actually used. */
601 		if (im->open[v]) {
602 			im->open[v] = 0;
603 		}
604 		gdImageSetPixel(im, xpos, ypos, v);
605 		++xpos;
606 		if (xpos == len) {
607 			xpos = 0;
608 			if (interlace) {
609 				switch (pass) {
610 					case 0:
611 					case 1:
612 						ypos += 8; break;
613 					case 2:
614 						ypos += 4; break;
615 					case 3:
616 						ypos += 2; break;
617 				}
618 
619 				if (ypos >= height) {
620 					++pass;
621 					switch (pass) {
622 						case 1:
623 							ypos = 4; break;
624 						case 2:
625 							ypos = 2; break;
626 						case 3:
627 							ypos = 1; break;
628 						default:
629 							goto fini;
630 					}
631 				}
632 			} else {
633 				++ypos;
634 			}
635 		}
636 		if (ypos >= height)
637 			break;
638 	}
639 
640 fini:
641 	if (LWZReadByte(fd, &sd, FALSE, c, ZeroDataBlockP) >=0) {
642 		/* Ignore extra */
643 	}
644 }
645 /* }}} */
646