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