1 | /* |
2 | +----------------------------------------------------------------------+ |
3 | | PHP Version 5 | |
4 | +----------------------------------------------------------------------+ |
5 | | Copyright (c) 1997-2015 The PHP Group | |
6 | +----------------------------------------------------------------------+ |
7 | | This source file is subject to version 3.01 of the PHP license, | |
8 | | that is bundled with this package in the file LICENSE, and is | |
9 | | available through the world-wide-web at the following url: | |
10 | | http://www.php.net/license/3_01.txt | |
11 | | If you did not receive a copy of the PHP license and are unable to | |
12 | | obtain it through the world-wide-web, please send a note to | |
13 | | license@php.net so we can mail you a copy immediately. | |
14 | +----------------------------------------------------------------------+ |
15 | | Authors: Rasmus Lerdorf <rasmus@php.net> | |
16 | | Marcus Boerger <helly@php.net> | |
17 | +----------------------------------------------------------------------+ |
18 | */ |
19 | |
20 | /* $Id$ */ |
21 | |
22 | #include "php.h" |
23 | #include <stdio.h> |
24 | #if HAVE_FCNTL_H |
25 | #include <fcntl.h> |
26 | #endif |
27 | #include "fopen_wrappers.h" |
28 | #include "ext/standard/fsock.h" |
29 | #if HAVE_UNISTD_H |
30 | #include <unistd.h> |
31 | #endif |
32 | #include "php_image.h" |
33 | #ifdef PHP_WIN32 |
34 | #include "win32/php_stdint.h" |
35 | #endif |
36 | |
37 | #if HAVE_ZLIB && !defined(COMPILE_DL_ZLIB) |
38 | #include "zlib.h" |
39 | #endif |
40 | |
41 | /* file type markers */ |
42 | PHPAPI const char php_sig_gif[3] = {'G', 'I', 'F'}; |
43 | PHPAPI const char php_sig_psd[4] = {'8', 'B', 'P', 'S'}; |
44 | PHPAPI const char php_sig_bmp[2] = {'B', 'M'}; |
45 | PHPAPI const char php_sig_swf[3] = {'F', 'W', 'S'}; |
46 | PHPAPI const char php_sig_swc[3] = {'C', 'W', 'S'}; |
47 | PHPAPI const char php_sig_jpg[3] = {(char) 0xff, (char) 0xd8, (char) 0xff}; |
48 | PHPAPI const char php_sig_png[8] = {(char) 0x89, (char) 0x50, (char) 0x4e, (char) 0x47, |
49 | (char) 0x0d, (char) 0x0a, (char) 0x1a, (char) 0x0a}; |
50 | PHPAPI const char php_sig_tif_ii[4] = {'I','I', (char)0x2A, (char)0x00}; |
51 | PHPAPI const char php_sig_tif_mm[4] = {'M','M', (char)0x00, (char)0x2A}; |
52 | PHPAPI const char php_sig_jpc[3] = {(char)0xff, (char)0x4f, (char)0xff}; |
53 | PHPAPI const char php_sig_jp2[12] = {(char)0x00, (char)0x00, (char)0x00, (char)0x0c, |
54 | (char)0x6a, (char)0x50, (char)0x20, (char)0x20, |
55 | (char)0x0d, (char)0x0a, (char)0x87, (char)0x0a}; |
56 | PHPAPI const char php_sig_iff[4] = {'F','O','R','M'}; |
57 | PHPAPI const char php_sig_ico[4] = {(char)0x00, (char)0x00, (char)0x01, (char)0x00}; |
58 | |
59 | /* REMEMBER TO ADD MIME-TYPE TO FUNCTION php_image_type_to_mime_type */ |
60 | /* PCX must check first 64bytes and byte 0=0x0a and byte2 < 0x06 */ |
61 | |
62 | /* return info as a struct, to make expansion easier */ |
63 | |
64 | struct gfxinfo { |
65 | unsigned int width; |
66 | unsigned int height; |
67 | unsigned int bits; |
68 | unsigned int channels; |
69 | }; |
70 | |
71 | /* {{{ PHP_MINIT_FUNCTION(imagetypes) |
72 | * Register IMAGETYPE_<xxx> constants used by GetImageSize(), image_type_to_mime_type, ext/exif */ |
73 | PHP_MINIT_FUNCTION(imagetypes) |
74 | { |
75 | REGISTER_LONG_CONSTANT("IMAGETYPE_GIF" , IMAGE_FILETYPE_GIF, CONST_CS | CONST_PERSISTENT); |
76 | REGISTER_LONG_CONSTANT("IMAGETYPE_JPEG" , IMAGE_FILETYPE_JPEG, CONST_CS | CONST_PERSISTENT); |
77 | REGISTER_LONG_CONSTANT("IMAGETYPE_PNG" , IMAGE_FILETYPE_PNG, CONST_CS | CONST_PERSISTENT); |
78 | REGISTER_LONG_CONSTANT("IMAGETYPE_SWF" , IMAGE_FILETYPE_SWF, CONST_CS | CONST_PERSISTENT); |
79 | REGISTER_LONG_CONSTANT("IMAGETYPE_PSD" , IMAGE_FILETYPE_PSD, CONST_CS | CONST_PERSISTENT); |
80 | REGISTER_LONG_CONSTANT("IMAGETYPE_BMP" , IMAGE_FILETYPE_BMP, CONST_CS | CONST_PERSISTENT); |
81 | REGISTER_LONG_CONSTANT("IMAGETYPE_TIFF_II" , IMAGE_FILETYPE_TIFF_II, CONST_CS | CONST_PERSISTENT); |
82 | REGISTER_LONG_CONSTANT("IMAGETYPE_TIFF_MM" , IMAGE_FILETYPE_TIFF_MM, CONST_CS | CONST_PERSISTENT); |
83 | REGISTER_LONG_CONSTANT("IMAGETYPE_JPC" , IMAGE_FILETYPE_JPC, CONST_CS | CONST_PERSISTENT); |
84 | REGISTER_LONG_CONSTANT("IMAGETYPE_JP2" , IMAGE_FILETYPE_JP2, CONST_CS | CONST_PERSISTENT); |
85 | REGISTER_LONG_CONSTANT("IMAGETYPE_JPX" , IMAGE_FILETYPE_JPX, CONST_CS | CONST_PERSISTENT); |
86 | REGISTER_LONG_CONSTANT("IMAGETYPE_JB2" , IMAGE_FILETYPE_JB2, CONST_CS | CONST_PERSISTENT); |
87 | #if HAVE_ZLIB && !defined(COMPILE_DL_ZLIB) |
88 | REGISTER_LONG_CONSTANT("IMAGETYPE_SWC" , IMAGE_FILETYPE_SWC, CONST_CS | CONST_PERSISTENT); |
89 | #endif |
90 | REGISTER_LONG_CONSTANT("IMAGETYPE_IFF" , IMAGE_FILETYPE_IFF, CONST_CS | CONST_PERSISTENT); |
91 | REGISTER_LONG_CONSTANT("IMAGETYPE_WBMP" , IMAGE_FILETYPE_WBMP, CONST_CS | CONST_PERSISTENT); |
92 | REGISTER_LONG_CONSTANT("IMAGETYPE_JPEG2000" ,IMAGE_FILETYPE_JPC, CONST_CS | CONST_PERSISTENT); /* keep alias */ |
93 | REGISTER_LONG_CONSTANT("IMAGETYPE_XBM" , IMAGE_FILETYPE_XBM, CONST_CS | CONST_PERSISTENT); |
94 | REGISTER_LONG_CONSTANT("IMAGETYPE_ICO" , IMAGE_FILETYPE_ICO, CONST_CS | CONST_PERSISTENT); |
95 | REGISTER_LONG_CONSTANT("IMAGETYPE_UNKNOWN" , IMAGE_FILETYPE_UNKNOWN, CONST_CS | CONST_PERSISTENT); |
96 | REGISTER_LONG_CONSTANT("IMAGETYPE_COUNT" , IMAGE_FILETYPE_COUNT, CONST_CS | CONST_PERSISTENT); |
97 | return SUCCESS; |
98 | } |
99 | /* }}} */ |
100 | |
101 | /* {{{ php_handle_gif |
102 | * routine to handle GIF files. If only everything were that easy... ;} */ |
103 | static struct gfxinfo *php_handle_gif (php_stream * stream TSRMLS_DC) |
104 | { |
105 | struct gfxinfo *result = NULL; |
106 | unsigned char dim[5]; |
107 | |
108 | if (php_stream_seek(stream, 3, SEEK_CUR)) |
109 | return NULL; |
110 | |
111 | if (php_stream_read(stream, dim, sizeof(dim)) != sizeof(dim)) |
112 | return NULL; |
113 | |
114 | result = (struct gfxinfo *) ecalloc(1, sizeof(struct gfxinfo)); |
115 | result->width = (unsigned int)dim[0] | (((unsigned int)dim[1])<<8); |
116 | result->height = (unsigned int)dim[2] | (((unsigned int)dim[3])<<8); |
117 | result->bits = dim[4]&0x80 ? ((((unsigned int)dim[4])&0x07) + 1) : 0; |
118 | result->channels = 3; /* always */ |
119 | |
120 | return result; |
121 | } |
122 | /* }}} */ |
123 | |
124 | /* {{{ php_handle_psd |
125 | */ |
126 | static struct gfxinfo *php_handle_psd (php_stream * stream TSRMLS_DC) |
127 | { |
128 | struct gfxinfo *result = NULL; |
129 | unsigned char dim[8]; |
130 | |
131 | if (php_stream_seek(stream, 11, SEEK_CUR)) |
132 | return NULL; |
133 | |
134 | if (php_stream_read(stream, dim, sizeof(dim)) != sizeof(dim)) |
135 | return NULL; |
136 | |
137 | result = (struct gfxinfo *) ecalloc(1, sizeof(struct gfxinfo)); |
138 | result->height = (((unsigned int)dim[0]) << 24) + (((unsigned int)dim[1]) << 16) + (((unsigned int)dim[2]) << 8) + ((unsigned int)dim[3]); |
139 | result->width = (((unsigned int)dim[4]) << 24) + (((unsigned int)dim[5]) << 16) + (((unsigned int)dim[6]) << 8) + ((unsigned int)dim[7]); |
140 | |
141 | return result; |
142 | } |
143 | /* }}} */ |
144 | |
145 | /* {{{ php_handle_bmp |
146 | */ |
147 | static struct gfxinfo *php_handle_bmp (php_stream * stream TSRMLS_DC) |
148 | { |
149 | struct gfxinfo *result = NULL; |
150 | unsigned char dim[16]; |
151 | int size; |
152 | |
153 | if (php_stream_seek(stream, 11, SEEK_CUR)) |
154 | return NULL; |
155 | |
156 | if (php_stream_read(stream, dim, sizeof(dim)) != sizeof(dim)) |
157 | return NULL; |
158 | |
159 | size = (((unsigned int)dim[ 3]) << 24) + (((unsigned int)dim[ 2]) << 16) + (((unsigned int)dim[ 1]) << 8) + ((unsigned int) dim[ 0]); |
160 | if (size == 12) { |
161 | result = (struct gfxinfo *) ecalloc (1, sizeof(struct gfxinfo)); |
162 | result->width = (((unsigned int)dim[ 5]) << 8) + ((unsigned int) dim[ 4]); |
163 | result->height = (((unsigned int)dim[ 7]) << 8) + ((unsigned int) dim[ 6]); |
164 | result->bits = ((unsigned int)dim[11]); |
165 | } else if (size > 12 && (size <= 64 || size == 108 || size == 124)) { |
166 | result = (struct gfxinfo *) ecalloc (1, sizeof(struct gfxinfo)); |
167 | result->width = (((unsigned int)dim[ 7]) << 24) + (((unsigned int)dim[ 6]) << 16) + (((unsigned int)dim[ 5]) << 8) + ((unsigned int) dim[ 4]); |
168 | result->height = (((unsigned int)dim[11]) << 24) + (((unsigned int)dim[10]) << 16) + (((unsigned int)dim[ 9]) << 8) + ((unsigned int) dim[ 8]); |
169 | result->height = abs((int32_t)result->height); |
170 | result->bits = (((unsigned int)dim[15]) << 8) + ((unsigned int)dim[14]); |
171 | } else { |
172 | return NULL; |
173 | } |
174 | |
175 | return result; |
176 | } |
177 | /* }}} */ |
178 | |
179 | /* {{{ php_swf_get_bits |
180 | * routines to handle SWF files. */ |
181 | static unsigned long int php_swf_get_bits (unsigned char* buffer, unsigned int pos, unsigned int count) |
182 | { |
183 | unsigned int loop; |
184 | unsigned long int result = 0; |
185 | |
186 | for (loop = pos; loop < pos + count; loop++) |
187 | { |
188 | result = result + |
189 | ((((buffer[loop / 8]) >> (7 - (loop % 8))) & 0x01) << (count - (loop - pos) - 1)); |
190 | } |
191 | return result; |
192 | } |
193 | /* }}} */ |
194 | |
195 | #if HAVE_ZLIB && !defined(COMPILE_DL_ZLIB) |
196 | /* {{{ php_handle_swc |
197 | */ |
198 | static struct gfxinfo *php_handle_swc(php_stream * stream TSRMLS_DC) |
199 | { |
200 | struct gfxinfo *result = NULL; |
201 | |
202 | long bits; |
203 | unsigned char a[64]; |
204 | unsigned long len=64, szlength; |
205 | int factor=1,maxfactor=16; |
206 | int slength, status=0; |
207 | char *b, *buf=NULL, *bufz=NULL; |
208 | |
209 | b = ecalloc (1, len + 1); |
210 | |
211 | if (php_stream_seek(stream, 5, SEEK_CUR)) |
212 | return NULL; |
213 | |
214 | if (php_stream_read(stream, a, sizeof(a)) != sizeof(a)) |
215 | return NULL; |
216 | |
217 | if (uncompress(b, &len, a, sizeof(a)) != Z_OK) { |
218 | /* failed to decompress the file, will try reading the rest of the file */ |
219 | if (php_stream_seek(stream, 8, SEEK_SET)) |
220 | return NULL; |
221 | |
222 | slength = php_stream_copy_to_mem(stream, &bufz, PHP_STREAM_COPY_ALL, 0); |
223 | |
224 | /* |
225 | * zlib::uncompress() wants to know the output data length |
226 | * if none was given as a parameter |
227 | * we try from input length * 2 up to input length * 2^8 |
228 | * doubling it whenever it wasn't big enough |
229 | * that should be eneugh for all real life cases |
230 | */ |
231 | |
232 | do { |
233 | szlength=slength*(1<<factor++); |
234 | buf = (char *) erealloc(buf,szlength); |
235 | status = uncompress(buf, &szlength, bufz, slength); |
236 | } while ((status==Z_BUF_ERROR)&&(factor<maxfactor)); |
237 | |
238 | if (bufz) { |
239 | pefree(bufz, 0); |
240 | } |
241 | |
242 | if (status == Z_OK) { |
243 | memcpy(b, buf, len); |
244 | } |
245 | |
246 | if (buf) { |
247 | efree(buf); |
248 | } |
249 | } |
250 | |
251 | if (!status) { |
252 | result = (struct gfxinfo *) ecalloc (1, sizeof (struct gfxinfo)); |
253 | bits = php_swf_get_bits (b, 0, 5); |
254 | result->width = (php_swf_get_bits (b, 5 + bits, bits) - |
255 | php_swf_get_bits (b, 5, bits)) / 20; |
256 | result->height = (php_swf_get_bits (b, 5 + (3 * bits), bits) - |
257 | php_swf_get_bits (b, 5 + (2 * bits), bits)) / 20; |
258 | } else { |
259 | result = NULL; |
260 | } |
261 | |
262 | efree (b); |
263 | return result; |
264 | } |
265 | /* }}} */ |
266 | #endif |
267 | |
268 | /* {{{ php_handle_swf |
269 | */ |
270 | static struct gfxinfo *php_handle_swf (php_stream * stream TSRMLS_DC) |
271 | { |
272 | struct gfxinfo *result = NULL; |
273 | long bits; |
274 | unsigned char a[32]; |
275 | |
276 | if (php_stream_seek(stream, 5, SEEK_CUR)) |
277 | return NULL; |
278 | |
279 | if (php_stream_read(stream, a, sizeof(a)) != sizeof(a)) |
280 | return NULL; |
281 | |
282 | result = (struct gfxinfo *) ecalloc (1, sizeof (struct gfxinfo)); |
283 | bits = php_swf_get_bits (a, 0, 5); |
284 | result->width = (php_swf_get_bits (a, 5 + bits, bits) - |
285 | php_swf_get_bits (a, 5, bits)) / 20; |
286 | result->height = (php_swf_get_bits (a, 5 + (3 * bits), bits) - |
287 | php_swf_get_bits (a, 5 + (2 * bits), bits)) / 20; |
288 | result->bits = 0; |
289 | result->channels = 0; |
290 | return result; |
291 | } |
292 | /* }}} */ |
293 | |
294 | /* {{{ php_handle_png |
295 | * routine to handle PNG files */ |
296 | static struct gfxinfo *php_handle_png (php_stream * stream TSRMLS_DC) |
297 | { |
298 | struct gfxinfo *result = NULL; |
299 | unsigned char dim[9]; |
300 | /* Width: 4 bytes |
301 | * Height: 4 bytes |
302 | * Bit depth: 1 byte |
303 | * Color type: 1 byte |
304 | * Compression method: 1 byte |
305 | * Filter method: 1 byte |
306 | * Interlace method: 1 byte |
307 | */ |
308 | |
309 | if (php_stream_seek(stream, 8, SEEK_CUR)) |
310 | return NULL; |
311 | |
312 | if((php_stream_read(stream, dim, sizeof(dim))) < sizeof(dim)) |
313 | return NULL; |
314 | |
315 | result = (struct gfxinfo *) ecalloc(1, sizeof(struct gfxinfo)); |
316 | result->width = (((unsigned int)dim[0]) << 24) + (((unsigned int)dim[1]) << 16) + (((unsigned int)dim[2]) << 8) + ((unsigned int)dim[3]); |
317 | result->height = (((unsigned int)dim[4]) << 24) + (((unsigned int)dim[5]) << 16) + (((unsigned int)dim[6]) << 8) + ((unsigned int)dim[7]); |
318 | result->bits = (unsigned int)dim[8]; |
319 | return result; |
320 | } |
321 | /* }}} */ |
322 | |
323 | /* routines to handle JPEG data */ |
324 | |
325 | /* some defines for the different JPEG block types */ |
326 | #define M_SOF0 0xC0 /* Start Of Frame N */ |
327 | #define M_SOF1 0xC1 /* N indicates which compression process */ |
328 | #define M_SOF2 0xC2 /* Only SOF0-SOF2 are now in common use */ |
329 | #define M_SOF3 0xC3 |
330 | #define M_SOF5 0xC5 /* NB: codes C4 and CC are NOT SOF markers */ |
331 | #define M_SOF6 0xC6 |
332 | #define M_SOF7 0xC7 |
333 | #define M_SOF9 0xC9 |
334 | #define M_SOF10 0xCA |
335 | #define M_SOF11 0xCB |
336 | #define M_SOF13 0xCD |
337 | #define M_SOF14 0xCE |
338 | #define M_SOF15 0xCF |
339 | #define M_SOI 0xD8 |
340 | #define M_EOI 0xD9 /* End Of Image (end of datastream) */ |
341 | #define M_SOS 0xDA /* Start Of Scan (begins compressed data) */ |
342 | #define M_APP0 0xe0 |
343 | #define M_APP1 0xe1 |
344 | #define M_APP2 0xe2 |
345 | #define M_APP3 0xe3 |
346 | #define M_APP4 0xe4 |
347 | #define M_APP5 0xe5 |
348 | #define M_APP6 0xe6 |
349 | #define M_APP7 0xe7 |
350 | #define M_APP8 0xe8 |
351 | #define M_APP9 0xe9 |
352 | #define M_APP10 0xea |
353 | #define M_APP11 0xeb |
354 | #define M_APP12 0xec |
355 | #define M_APP13 0xed |
356 | #define M_APP14 0xee |
357 | #define M_APP15 0xef |
358 | #define M_COM 0xFE /* COMment */ |
359 | |
360 | #define M_PSEUDO 0xFFD8 /* pseudo marker for start of image(byte 0) */ |
361 | |
362 | /* {{{ php_read2 |
363 | */ |
364 | static unsigned short php_read2(php_stream * stream TSRMLS_DC) |
365 | { |
366 | unsigned char a[2]; |
367 | |
368 | /* return 0 if we couldn't read enough data */ |
369 | if((php_stream_read(stream, a, sizeof(a))) < sizeof(a)) return 0; |
370 | |
371 | return (((unsigned short)a[0]) << 8) + ((unsigned short)a[1]); |
372 | } |
373 | /* }}} */ |
374 | |
375 | /* {{{ php_next_marker |
376 | * get next marker byte from file */ |
377 | static unsigned int php_next_marker(php_stream * stream, int last_marker, int , int ff_read TSRMLS_DC) |
378 | { |
379 | int a=0, marker; |
380 | |
381 | /* get marker byte, swallowing possible padding */ |
382 | if (last_marker==M_COM && comment_correction) { |
383 | /* some software does not count the length bytes of COM section */ |
384 | /* one company doing so is very much envolved in JPEG... so we accept too */ |
385 | /* by the way: some of those companies changed their code now... */ |
386 | comment_correction = 2; |
387 | } else { |
388 | last_marker = 0; |
389 | comment_correction = 0; |
390 | } |
391 | if (ff_read) { |
392 | a = 1; /* already read 0xff in filetype detection */ |
393 | } |
394 | do { |
395 | if ((marker = php_stream_getc(stream)) == EOF) |
396 | { |
397 | return M_EOI;/* we hit EOF */ |
398 | } |
399 | if (last_marker==M_COM && comment_correction>0) |
400 | { |
401 | if (marker != 0xFF) |
402 | { |
403 | marker = 0xff; |
404 | comment_correction--; |
405 | } else { |
406 | last_marker = M_PSEUDO; /* stop skipping non 0xff for M_COM */ |
407 | } |
408 | } |
409 | a++; |
410 | } while (marker == 0xff); |
411 | if (a < 2) |
412 | { |
413 | return M_EOI; /* at least one 0xff is needed before marker code */ |
414 | } |
415 | if ( last_marker==M_COM && comment_correction) |
416 | { |
417 | return M_EOI; /* ah illegal: char after COM section not 0xFF */ |
418 | } |
419 | return (unsigned int)marker; |
420 | } |
421 | /* }}} */ |
422 | |
423 | /* {{{ php_skip_variable |
424 | * skip over a variable-length block; assumes proper length marker */ |
425 | static int php_skip_variable(php_stream * stream TSRMLS_DC) |
426 | { |
427 | off_t length = ((unsigned int)php_read2(stream TSRMLS_CC)); |
428 | |
429 | if (length < 2) { |
430 | return 0; |
431 | } |
432 | length = length - 2; |
433 | php_stream_seek(stream, (long)length, SEEK_CUR); |
434 | return 1; |
435 | } |
436 | /* }}} */ |
437 | |
438 | /* {{{ php_read_APP |
439 | */ |
440 | static int php_read_APP(php_stream * stream, unsigned int marker, zval *info TSRMLS_DC) |
441 | { |
442 | unsigned short length; |
443 | unsigned char *buffer; |
444 | unsigned char markername[16]; |
445 | zval *tmp; |
446 | |
447 | length = php_read2(stream TSRMLS_CC); |
448 | if (length < 2) { |
449 | return 0; |
450 | } |
451 | length -= 2; /* length includes itself */ |
452 | |
453 | buffer = emalloc(length); |
454 | |
455 | if (php_stream_read(stream, buffer, (long) length) <= 0) { |
456 | efree(buffer); |
457 | return 0; |
458 | } |
459 | |
460 | snprintf(markername, sizeof(markername), "APP%d" , marker - M_APP0); |
461 | |
462 | if (zend_hash_find(Z_ARRVAL_P(info), markername, strlen(markername)+1, (void **) &tmp) == FAILURE) { |
463 | /* XXX we only catch the 1st tag of it's kind! */ |
464 | add_assoc_stringl(info, markername, buffer, length, 1); |
465 | } |
466 | |
467 | efree(buffer); |
468 | return 1; |
469 | } |
470 | /* }}} */ |
471 | |
472 | /* {{{ php_handle_jpeg |
473 | main loop to parse JPEG structure */ |
474 | static struct gfxinfo *php_handle_jpeg (php_stream * stream, zval *info TSRMLS_DC) |
475 | { |
476 | struct gfxinfo *result = NULL; |
477 | unsigned int marker = M_PSEUDO; |
478 | unsigned short length, ff_read=1; |
479 | |
480 | for (;;) { |
481 | marker = php_next_marker(stream, marker, 1, ff_read TSRMLS_CC); |
482 | ff_read = 0; |
483 | switch (marker) { |
484 | case M_SOF0: |
485 | case M_SOF1: |
486 | case M_SOF2: |
487 | case M_SOF3: |
488 | case M_SOF5: |
489 | case M_SOF6: |
490 | case M_SOF7: |
491 | case M_SOF9: |
492 | case M_SOF10: |
493 | case M_SOF11: |
494 | case M_SOF13: |
495 | case M_SOF14: |
496 | case M_SOF15: |
497 | if (result == NULL) { |
498 | /* handle SOFn block */ |
499 | result = (struct gfxinfo *) ecalloc(1, sizeof(struct gfxinfo)); |
500 | length = php_read2(stream TSRMLS_CC); |
501 | result->bits = php_stream_getc(stream); |
502 | result->height = php_read2(stream TSRMLS_CC); |
503 | result->width = php_read2(stream TSRMLS_CC); |
504 | result->channels = php_stream_getc(stream); |
505 | if (!info || length < 8) { /* if we don't want an extanded info -> return */ |
506 | return result; |
507 | } |
508 | if (php_stream_seek(stream, length - 8, SEEK_CUR)) { /* file error after info */ |
509 | return result; |
510 | } |
511 | } else { |
512 | if (!php_skip_variable(stream TSRMLS_CC)) { |
513 | return result; |
514 | } |
515 | } |
516 | break; |
517 | |
518 | case M_APP0: |
519 | case M_APP1: |
520 | case M_APP2: |
521 | case M_APP3: |
522 | case M_APP4: |
523 | case M_APP5: |
524 | case M_APP6: |
525 | case M_APP7: |
526 | case M_APP8: |
527 | case M_APP9: |
528 | case M_APP10: |
529 | case M_APP11: |
530 | case M_APP12: |
531 | case M_APP13: |
532 | case M_APP14: |
533 | case M_APP15: |
534 | if (info) { |
535 | if (!php_read_APP(stream, marker, info TSRMLS_CC)) { /* read all the app marks... */ |
536 | return result; |
537 | } |
538 | } else { |
539 | if (!php_skip_variable(stream TSRMLS_CC)) { |
540 | return result; |
541 | } |
542 | } |
543 | break; |
544 | |
545 | case M_SOS: |
546 | case M_EOI: |
547 | return result; /* we're about to hit image data, or are at EOF. stop processing. */ |
548 | |
549 | default: |
550 | if (!php_skip_variable(stream TSRMLS_CC)) { /* anything else isn't interesting */ |
551 | return result; |
552 | } |
553 | break; |
554 | } |
555 | } |
556 | |
557 | return result; /* perhaps image broken -> no info but size */ |
558 | } |
559 | /* }}} */ |
560 | |
561 | /* {{{ php_read4 |
562 | */ |
563 | static unsigned int php_read4(php_stream * stream TSRMLS_DC) |
564 | { |
565 | unsigned char a[4]; |
566 | |
567 | /* just return 0 if we hit the end-of-file */ |
568 | if ((php_stream_read(stream, a, sizeof(a))) != sizeof(a)) return 0; |
569 | |
570 | return (((unsigned int)a[0]) << 24) |
571 | + (((unsigned int)a[1]) << 16) |
572 | + (((unsigned int)a[2]) << 8) |
573 | + (((unsigned int)a[3])); |
574 | } |
575 | /* }}} */ |
576 | |
577 | /* {{{ JPEG 2000 Marker Codes */ |
578 | #define JPEG2000_MARKER_PREFIX 0xFF /* All marker codes start with this */ |
579 | #define JPEG2000_MARKER_SOC 0x4F /* Start of Codestream */ |
580 | #define JPEG2000_MARKER_SOT 0x90 /* Start of Tile part */ |
581 | #define JPEG2000_MARKER_SOD 0x93 /* Start of Data */ |
582 | #define JPEG2000_MARKER_EOC 0xD9 /* End of Codestream */ |
583 | #define JPEG2000_MARKER_SIZ 0x51 /* Image and tile size */ |
584 | #define JPEG2000_MARKER_COD 0x52 /* Coding style default */ |
585 | #define JPEG2000_MARKER_COC 0x53 /* Coding style component */ |
586 | #define JPEG2000_MARKER_RGN 0x5E /* Region of interest */ |
587 | #define JPEG2000_MARKER_QCD 0x5C /* Quantization default */ |
588 | #define JPEG2000_MARKER_QCC 0x5D /* Quantization component */ |
589 | #define JPEG2000_MARKER_POC 0x5F /* Progression order change */ |
590 | #define JPEG2000_MARKER_TLM 0x55 /* Tile-part lengths */ |
591 | #define JPEG2000_MARKER_PLM 0x57 /* Packet length, main header */ |
592 | #define JPEG2000_MARKER_PLT 0x58 /* Packet length, tile-part header */ |
593 | #define JPEG2000_MARKER_PPM 0x60 /* Packed packet headers, main header */ |
594 | #define JPEG2000_MARKER_PPT 0x61 /* Packed packet headers, tile part header */ |
595 | #define JPEG2000_MARKER_SOP 0x91 /* Start of packet */ |
596 | #define JPEG2000_MARKER_EPH 0x92 /* End of packet header */ |
597 | #define JPEG2000_MARKER_CRG 0x63 /* Component registration */ |
598 | #define JPEG2000_MARKER_COM 0x64 /* Comment */ |
599 | /* }}} */ |
600 | |
601 | /* {{{ php_handle_jpc |
602 | Main loop to parse JPEG2000 raw codestream structure */ |
603 | static struct gfxinfo *php_handle_jpc(php_stream * stream TSRMLS_DC) |
604 | { |
605 | struct gfxinfo *result = NULL; |
606 | unsigned short dummy_short; |
607 | int highest_bit_depth, bit_depth; |
608 | unsigned char first_marker_id; |
609 | unsigned int i; |
610 | |
611 | /* JPEG 2000 components can be vastly different from one another. |
612 | Each component can be sampled at a different resolution, use |
613 | a different colour space, have a separate colour depth, and |
614 | be compressed totally differently! This makes giving a single |
615 | "bit depth" answer somewhat problematic. For this implementation |
616 | we'll use the highest depth encountered. */ |
617 | |
618 | /* Get the single byte that remains after the file type indentification */ |
619 | first_marker_id = php_stream_getc(stream); |
620 | |
621 | /* Ensure that this marker is SIZ (as is mandated by the standard) */ |
622 | if (first_marker_id != JPEG2000_MARKER_SIZ) { |
623 | php_error_docref(NULL TSRMLS_CC, E_WARNING, "JPEG2000 codestream corrupt(Expected SIZ marker not found after SOC)" ); |
624 | return NULL; |
625 | } |
626 | |
627 | result = (struct gfxinfo *)ecalloc(1, sizeof(struct gfxinfo)); |
628 | |
629 | dummy_short = php_read2(stream TSRMLS_CC); /* Lsiz */ |
630 | dummy_short = php_read2(stream TSRMLS_CC); /* Rsiz */ |
631 | result->width = php_read4(stream TSRMLS_CC); /* Xsiz */ |
632 | result->height = php_read4(stream TSRMLS_CC); /* Ysiz */ |
633 | |
634 | #if MBO_0 |
635 | php_read4(stream TSRMLS_CC); /* XOsiz */ |
636 | php_read4(stream TSRMLS_CC); /* YOsiz */ |
637 | php_read4(stream TSRMLS_CC); /* XTsiz */ |
638 | php_read4(stream TSRMLS_CC); /* YTsiz */ |
639 | php_read4(stream TSRMLS_CC); /* XTOsiz */ |
640 | php_read4(stream TSRMLS_CC); /* YTOsiz */ |
641 | #else |
642 | if (php_stream_seek(stream, 24, SEEK_CUR)) { |
643 | efree(result); |
644 | return NULL; |
645 | } |
646 | #endif |
647 | |
648 | result->channels = php_read2(stream TSRMLS_CC); /* Csiz */ |
649 | if (result->channels == 0 && php_stream_eof(stream) || result->channels > 256) { |
650 | efree(result); |
651 | return NULL; |
652 | } |
653 | |
654 | /* Collect bit depth info */ |
655 | highest_bit_depth = 0; |
656 | for (i = 0; i < result->channels; i++) { |
657 | bit_depth = php_stream_getc(stream); /* Ssiz[i] */ |
658 | bit_depth++; |
659 | if (bit_depth > highest_bit_depth) { |
660 | highest_bit_depth = bit_depth; |
661 | } |
662 | |
663 | php_stream_getc(stream); /* XRsiz[i] */ |
664 | php_stream_getc(stream); /* YRsiz[i] */ |
665 | } |
666 | |
667 | result->bits = highest_bit_depth; |
668 | |
669 | return result; |
670 | } |
671 | /* }}} */ |
672 | |
673 | /* {{{ php_handle_jp2 |
674 | main loop to parse JPEG 2000 JP2 wrapper format structure */ |
675 | static struct gfxinfo *php_handle_jp2(php_stream *stream TSRMLS_DC) |
676 | { |
677 | struct gfxinfo *result = NULL; |
678 | unsigned int box_length; |
679 | unsigned int box_type; |
680 | char jp2c_box_id[] = {(char)0x6a, (char)0x70, (char)0x32, (char)0x63}; |
681 | |
682 | /* JP2 is a wrapper format for JPEG 2000. Data is contained within "boxes". |
683 | Boxes themselves can be contained within "super-boxes". Super-Boxes can |
684 | contain super-boxes which provides us with a hierarchical storage system. |
685 | |
686 | It is valid for a JP2 file to contain multiple individual codestreams. |
687 | We'll just look for the first codestream at the root of the box structure |
688 | and handle that. |
689 | */ |
690 | |
691 | for (;;) |
692 | { |
693 | box_length = php_read4(stream TSRMLS_CC); /* LBox */ |
694 | /* TBox */ |
695 | if (php_stream_read(stream, (void *)&box_type, sizeof(box_type)) != sizeof(box_type)) { |
696 | /* Use this as a general "out of stream" error */ |
697 | break; |
698 | } |
699 | |
700 | if (box_length == 1) { |
701 | /* We won't handle XLBoxes */ |
702 | return NULL; |
703 | } |
704 | |
705 | if (!memcmp(&box_type, jp2c_box_id, 4)) |
706 | { |
707 | /* Skip the first 3 bytes to emulate the file type examination */ |
708 | php_stream_seek(stream, 3, SEEK_CUR); |
709 | |
710 | result = php_handle_jpc(stream TSRMLS_CC); |
711 | break; |
712 | } |
713 | |
714 | /* Stop if this was the last box */ |
715 | if ((int)box_length <= 0) { |
716 | break; |
717 | } |
718 | |
719 | /* Skip over LBox (Which includes both TBox and LBox itself */ |
720 | if (php_stream_seek(stream, box_length - 8, SEEK_CUR)) { |
721 | break; |
722 | } |
723 | } |
724 | |
725 | if (result == NULL) { |
726 | php_error_docref(NULL TSRMLS_CC, E_WARNING, "JP2 file has no codestreams at root level" ); |
727 | } |
728 | |
729 | return result; |
730 | } |
731 | /* }}} */ |
732 | |
733 | /* {{{ tiff constants |
734 | */ |
735 | PHPAPI const int php_tiff_bytes_per_format[] = {0, 1, 1, 2, 4, 8, 1, 1, 2, 4, 8, 4, 8}; |
736 | |
737 | /* uncompressed only */ |
738 | #define TAG_IMAGEWIDTH 0x0100 |
739 | #define TAG_IMAGEHEIGHT 0x0101 |
740 | /* compressed images only */ |
741 | #define TAG_COMP_IMAGEWIDTH 0xA002 |
742 | #define TAG_COMP_IMAGEHEIGHT 0xA003 |
743 | |
744 | #define TAG_FMT_BYTE 1 |
745 | #define TAG_FMT_STRING 2 |
746 | #define TAG_FMT_USHORT 3 |
747 | #define TAG_FMT_ULONG 4 |
748 | #define TAG_FMT_URATIONAL 5 |
749 | #define TAG_FMT_SBYTE 6 |
750 | #define TAG_FMT_UNDEFINED 7 |
751 | #define TAG_FMT_SSHORT 8 |
752 | #define TAG_FMT_SLONG 9 |
753 | #define TAG_FMT_SRATIONAL 10 |
754 | #define TAG_FMT_SINGLE 11 |
755 | #define TAG_FMT_DOUBLE 12 |
756 | /* }}} */ |
757 | |
758 | /* {{{ php_ifd_get16u |
759 | * Convert a 16 bit unsigned value from file's native byte order */ |
760 | static int php_ifd_get16u(void *Short, int motorola_intel) |
761 | { |
762 | if (motorola_intel) { |
763 | return (((unsigned char *)Short)[0] << 8) | ((unsigned char *)Short)[1]; |
764 | } else { |
765 | return (((unsigned char *)Short)[1] << 8) | ((unsigned char *)Short)[0]; |
766 | } |
767 | } |
768 | /* }}} */ |
769 | |
770 | /* {{{ php_ifd_get16s |
771 | * Convert a 16 bit signed value from file's native byte order */ |
772 | static signed short php_ifd_get16s(void *Short, int motorola_intel) |
773 | { |
774 | return (signed short)php_ifd_get16u(Short, motorola_intel); |
775 | } |
776 | /* }}} */ |
777 | |
778 | /* {{{ php_ifd_get32s |
779 | * Convert a 32 bit signed value from file's native byte order */ |
780 | static int php_ifd_get32s(void *Long, int motorola_intel) |
781 | { |
782 | if (motorola_intel) { |
783 | return ((( char *)Long)[0] << 24) | (((unsigned char *)Long)[1] << 16) |
784 | | (((unsigned char *)Long)[2] << 8 ) | (((unsigned char *)Long)[3] << 0 ); |
785 | } else { |
786 | return ((( char *)Long)[3] << 24) | (((unsigned char *)Long)[2] << 16) |
787 | | (((unsigned char *)Long)[1] << 8 ) | (((unsigned char *)Long)[0] << 0 ); |
788 | } |
789 | } |
790 | /* }}} */ |
791 | |
792 | /* {{{ php_ifd_get32u |
793 | * Convert a 32 bit unsigned value from file's native byte order */ |
794 | static unsigned php_ifd_get32u(void *Long, int motorola_intel) |
795 | { |
796 | return (unsigned)php_ifd_get32s(Long, motorola_intel) & 0xffffffff; |
797 | } |
798 | /* }}} */ |
799 | |
800 | /* {{{ php_handle_tiff |
801 | main loop to parse TIFF structure */ |
802 | static struct gfxinfo *php_handle_tiff (php_stream * stream, zval *info, int motorola_intel TSRMLS_DC) |
803 | { |
804 | struct gfxinfo *result = NULL; |
805 | int i, num_entries; |
806 | unsigned char *dir_entry; |
807 | size_t ifd_size, dir_size, entry_value, width=0, height=0, ifd_addr; |
808 | int entry_tag , entry_type; |
809 | char *ifd_data, ifd_ptr[4]; |
810 | |
811 | if (php_stream_read(stream, ifd_ptr, 4) != 4) |
812 | return NULL; |
813 | ifd_addr = php_ifd_get32u(ifd_ptr, motorola_intel); |
814 | if (php_stream_seek(stream, ifd_addr-8, SEEK_CUR)) |
815 | return NULL; |
816 | ifd_size = 2; |
817 | ifd_data = emalloc(ifd_size); |
818 | if (php_stream_read(stream, ifd_data, 2) != 2) { |
819 | efree(ifd_data); |
820 | return NULL; |
821 | } |
822 | num_entries = php_ifd_get16u(ifd_data, motorola_intel); |
823 | dir_size = 2/*num dir entries*/ +12/*length of entry*/*num_entries +4/* offset to next ifd (points to thumbnail or NULL)*/; |
824 | ifd_size = dir_size; |
825 | ifd_data = erealloc(ifd_data,ifd_size); |
826 | if (php_stream_read(stream, ifd_data+2, dir_size-2) != dir_size-2) { |
827 | efree(ifd_data); |
828 | return NULL; |
829 | } |
830 | /* now we have the directory we can look how long it should be */ |
831 | ifd_size = dir_size; |
832 | for(i=0;i<num_entries;i++) { |
833 | dir_entry = ifd_data+2+i*12; |
834 | entry_tag = php_ifd_get16u(dir_entry+0, motorola_intel); |
835 | entry_type = php_ifd_get16u(dir_entry+2, motorola_intel); |
836 | switch(entry_type) { |
837 | case TAG_FMT_BYTE: |
838 | case TAG_FMT_SBYTE: |
839 | entry_value = (size_t)(dir_entry[8]); |
840 | break; |
841 | case TAG_FMT_USHORT: |
842 | entry_value = php_ifd_get16u(dir_entry+8, motorola_intel); |
843 | break; |
844 | case TAG_FMT_SSHORT: |
845 | entry_value = php_ifd_get16s(dir_entry+8, motorola_intel); |
846 | break; |
847 | case TAG_FMT_ULONG: |
848 | entry_value = php_ifd_get32u(dir_entry+8, motorola_intel); |
849 | break; |
850 | case TAG_FMT_SLONG: |
851 | entry_value = php_ifd_get32s(dir_entry+8, motorola_intel); |
852 | break; |
853 | default: |
854 | continue; |
855 | } |
856 | switch(entry_tag) { |
857 | case TAG_IMAGEWIDTH: |
858 | case TAG_COMP_IMAGEWIDTH: |
859 | width = entry_value; |
860 | break; |
861 | case TAG_IMAGEHEIGHT: |
862 | case TAG_COMP_IMAGEHEIGHT: |
863 | height = entry_value; |
864 | break; |
865 | } |
866 | } |
867 | efree(ifd_data); |
868 | if ( width && height) { |
869 | /* not the same when in for-loop */ |
870 | result = (struct gfxinfo *) ecalloc(1, sizeof(struct gfxinfo)); |
871 | result->height = height; |
872 | result->width = width; |
873 | result->bits = 0; |
874 | result->channels = 0; |
875 | return result; |
876 | } |
877 | return NULL; |
878 | } |
879 | /* }}} */ |
880 | |
881 | /* {{{ php_handle_psd |
882 | */ |
883 | static struct gfxinfo *php_handle_iff(php_stream * stream TSRMLS_DC) |
884 | { |
885 | struct gfxinfo * result; |
886 | unsigned char a[10]; |
887 | int chunkId; |
888 | int size; |
889 | short width, height, bits; |
890 | |
891 | if (php_stream_read(stream, a, 8) != 8) { |
892 | return NULL; |
893 | } |
894 | if (strncmp(a+4, "ILBM" , 4) && strncmp(a+4, "PBM " , 4)) { |
895 | return NULL; |
896 | } |
897 | |
898 | /* loop chunks to find BMHD chunk */ |
899 | do { |
900 | if (php_stream_read(stream, a, 8) != 8) { |
901 | return NULL; |
902 | } |
903 | chunkId = php_ifd_get32s(a+0, 1); |
904 | size = php_ifd_get32s(a+4, 1); |
905 | if (size < 0) { |
906 | return NULL; |
907 | } |
908 | if ((size & 1) == 1) { |
909 | size++; |
910 | } |
911 | if (chunkId == 0x424d4844) { /* BMHD chunk */ |
912 | if (size < 9 || php_stream_read(stream, a, 9) != 9) { |
913 | return NULL; |
914 | } |
915 | width = php_ifd_get16s(a+0, 1); |
916 | height = php_ifd_get16s(a+2, 1); |
917 | bits = a[8] & 0xff; |
918 | if (width > 0 && height > 0 && bits > 0 && bits < 33) { |
919 | result = (struct gfxinfo *) ecalloc(1, sizeof(struct gfxinfo)); |
920 | result->width = width; |
921 | result->height = height; |
922 | result->bits = bits; |
923 | result->channels = 0; |
924 | return result; |
925 | } |
926 | } else { |
927 | if (php_stream_seek(stream, size, SEEK_CUR)) { |
928 | return NULL; |
929 | } |
930 | } |
931 | } while (1); |
932 | } |
933 | /* }}} */ |
934 | |
935 | /* {{{ php_get_wbmp |
936 | * int WBMP file format type |
937 | * byte Header Type |
938 | * byte Extended Header |
939 | * byte Header Data (type 00 = multibyte) |
940 | * byte Header Data (type 11 = name/pairs) |
941 | * int Number of columns |
942 | * int Number of rows |
943 | */ |
944 | static int php_get_wbmp(php_stream *stream, struct gfxinfo **result, int check TSRMLS_DC) |
945 | { |
946 | int i, width = 0, height = 0; |
947 | |
948 | if (php_stream_rewind(stream)) { |
949 | return 0; |
950 | } |
951 | |
952 | /* get type */ |
953 | if (php_stream_getc(stream) != 0) { |
954 | return 0; |
955 | } |
956 | |
957 | /* skip header */ |
958 | do { |
959 | i = php_stream_getc(stream); |
960 | if (i < 0) { |
961 | return 0; |
962 | } |
963 | } while (i & 0x80); |
964 | |
965 | /* get width */ |
966 | do { |
967 | i = php_stream_getc(stream); |
968 | if (i < 0) { |
969 | return 0; |
970 | } |
971 | width = (width << 7) | (i & 0x7f); |
972 | } while (i & 0x80); |
973 | |
974 | /* get height */ |
975 | do { |
976 | i = php_stream_getc(stream); |
977 | if (i < 0) { |
978 | return 0; |
979 | } |
980 | height = (height << 7) | (i & 0x7f); |
981 | } while (i & 0x80); |
982 | |
983 | /* maximum valid sizes for wbmp (although 127x127 may be a more accurate one) */ |
984 | if (!height || !width || height > 2048 || width > 2048) { |
985 | return 0; |
986 | } |
987 | |
988 | if (!check) { |
989 | (*result)->width = width; |
990 | (*result)->height = height; |
991 | } |
992 | |
993 | return IMAGE_FILETYPE_WBMP; |
994 | } |
995 | /* }}} */ |
996 | |
997 | /* {{{ php_handle_wbmp |
998 | */ |
999 | static struct gfxinfo *php_handle_wbmp(php_stream * stream TSRMLS_DC) |
1000 | { |
1001 | struct gfxinfo *result = (struct gfxinfo *) ecalloc(1, sizeof(struct gfxinfo)); |
1002 | |
1003 | if (!php_get_wbmp(stream, &result, 0 TSRMLS_CC)) { |
1004 | efree(result); |
1005 | return NULL; |
1006 | } |
1007 | |
1008 | return result; |
1009 | } |
1010 | /* }}} */ |
1011 | |
1012 | /* {{{ php_get_xbm |
1013 | */ |
1014 | static int php_get_xbm(php_stream *stream, struct gfxinfo **result TSRMLS_DC) |
1015 | { |
1016 | char *fline; |
1017 | char *iname; |
1018 | char *type; |
1019 | int value; |
1020 | unsigned int width = 0, height = 0; |
1021 | |
1022 | if (result) { |
1023 | *result = NULL; |
1024 | } |
1025 | if (php_stream_rewind(stream)) { |
1026 | return 0; |
1027 | } |
1028 | while ((fline=php_stream_gets(stream, NULL, 0)) != NULL) { |
1029 | iname = estrdup(fline); /* simple way to get necessary buffer of required size */ |
1030 | if (sscanf(fline, "#define %s %d" , iname, &value) == 2) { |
1031 | if (!(type = strrchr(iname, '_'))) { |
1032 | type = iname; |
1033 | } else { |
1034 | type++; |
1035 | } |
1036 | |
1037 | if (!strcmp("width" , type)) { |
1038 | width = (unsigned int) value; |
1039 | if (height) { |
1040 | efree(iname); |
1041 | break; |
1042 | } |
1043 | } |
1044 | if (!strcmp("height" , type)) { |
1045 | height = (unsigned int) value; |
1046 | if (width) { |
1047 | efree(iname); |
1048 | break; |
1049 | } |
1050 | } |
1051 | } |
1052 | efree(fline); |
1053 | efree(iname); |
1054 | } |
1055 | if (fline) { |
1056 | efree(fline); |
1057 | } |
1058 | |
1059 | if (width && height) { |
1060 | if (result) { |
1061 | *result = (struct gfxinfo *) ecalloc(1, sizeof(struct gfxinfo)); |
1062 | (*result)->width = width; |
1063 | (*result)->height = height; |
1064 | } |
1065 | return IMAGE_FILETYPE_XBM; |
1066 | } |
1067 | |
1068 | return 0; |
1069 | } |
1070 | /* }}} */ |
1071 | |
1072 | /* {{{ php_handle_xbm |
1073 | */ |
1074 | static struct gfxinfo *php_handle_xbm(php_stream * stream TSRMLS_DC) |
1075 | { |
1076 | struct gfxinfo *result; |
1077 | php_get_xbm(stream, &result TSRMLS_CC); |
1078 | return result; |
1079 | } |
1080 | /* }}} */ |
1081 | |
1082 | /* {{{ php_handle_ico |
1083 | */ |
1084 | static struct gfxinfo *php_handle_ico(php_stream * stream TSRMLS_DC) |
1085 | { |
1086 | struct gfxinfo *result = NULL; |
1087 | unsigned char dim[16]; |
1088 | int num_icons = 0; |
1089 | |
1090 | if (php_stream_read(stream, dim, 2) != 2) |
1091 | return NULL; |
1092 | |
1093 | num_icons = (((unsigned int)dim[1]) << 8) + ((unsigned int) dim[0]); |
1094 | |
1095 | if (num_icons < 1 || num_icons > 255) |
1096 | return NULL; |
1097 | |
1098 | result = (struct gfxinfo *) ecalloc(1, sizeof(struct gfxinfo)); |
1099 | |
1100 | while (num_icons > 0) |
1101 | { |
1102 | if (php_stream_read(stream, dim, sizeof(dim)) != sizeof(dim)) |
1103 | break; |
1104 | |
1105 | if ((((unsigned int)dim[7]) << 8) + ((unsigned int)dim[6]) >= result->bits) |
1106 | { |
1107 | result->width = (unsigned int)dim[0]; |
1108 | result->height = (unsigned int)dim[1]; |
1109 | result->bits = (((unsigned int)dim[7]) << 8) + ((unsigned int)dim[6]); |
1110 | } |
1111 | num_icons--; |
1112 | } |
1113 | |
1114 | return result; |
1115 | } |
1116 | /* }}} */ |
1117 | |
1118 | /* {{{ php_image_type_to_mime_type |
1119 | * Convert internal image_type to mime type */ |
1120 | PHPAPI char * php_image_type_to_mime_type(int image_type) |
1121 | { |
1122 | switch( image_type) { |
1123 | case IMAGE_FILETYPE_GIF: |
1124 | return "image/gif" ; |
1125 | case IMAGE_FILETYPE_JPEG: |
1126 | return "image/jpeg" ; |
1127 | case IMAGE_FILETYPE_PNG: |
1128 | return "image/png" ; |
1129 | case IMAGE_FILETYPE_SWF: |
1130 | case IMAGE_FILETYPE_SWC: |
1131 | return "application/x-shockwave-flash" ; |
1132 | case IMAGE_FILETYPE_PSD: |
1133 | return "image/psd" ; |
1134 | case IMAGE_FILETYPE_BMP: |
1135 | return "image/x-ms-bmp" ; |
1136 | case IMAGE_FILETYPE_TIFF_II: |
1137 | case IMAGE_FILETYPE_TIFF_MM: |
1138 | return "image/tiff" ; |
1139 | case IMAGE_FILETYPE_IFF: |
1140 | return "image/iff" ; |
1141 | case IMAGE_FILETYPE_WBMP: |
1142 | return "image/vnd.wap.wbmp" ; |
1143 | case IMAGE_FILETYPE_JPC: |
1144 | return "application/octet-stream" ; |
1145 | case IMAGE_FILETYPE_JP2: |
1146 | return "image/jp2" ; |
1147 | case IMAGE_FILETYPE_XBM: |
1148 | return "image/xbm" ; |
1149 | case IMAGE_FILETYPE_ICO: |
1150 | return "image/vnd.microsoft.icon" ; |
1151 | default: |
1152 | case IMAGE_FILETYPE_UNKNOWN: |
1153 | return "application/octet-stream" ; /* suppose binary format */ |
1154 | } |
1155 | } |
1156 | /* }}} */ |
1157 | |
1158 | /* {{{ proto string image_type_to_mime_type(int imagetype) |
1159 | Get Mime-Type for image-type returned by getimagesize, exif_read_data, exif_thumbnail, exif_imagetype */ |
1160 | PHP_FUNCTION(image_type_to_mime_type) |
1161 | { |
1162 | long p_image_type; |
1163 | |
1164 | if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l" , &p_image_type) == FAILURE) { |
1165 | return; |
1166 | } |
1167 | |
1168 | ZVAL_STRING(return_value, (char*)php_image_type_to_mime_type(p_image_type), 1); |
1169 | } |
1170 | /* }}} */ |
1171 | |
1172 | /* {{{ proto string image_type_to_extension(int imagetype [, bool include_dot]) |
1173 | Get file extension for image-type returned by getimagesize, exif_read_data, exif_thumbnail, exif_imagetype */ |
1174 | PHP_FUNCTION(image_type_to_extension) |
1175 | { |
1176 | long image_type; |
1177 | zend_bool inc_dot=1; |
1178 | |
1179 | if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l|b" , &image_type, &inc_dot) == FAILURE) { |
1180 | RETURN_FALSE; |
1181 | } |
1182 | |
1183 | switch (image_type) { |
1184 | case IMAGE_FILETYPE_GIF: |
1185 | RETURN_STRING(".gif" + !inc_dot, 1); |
1186 | case IMAGE_FILETYPE_JPEG: |
1187 | RETURN_STRING(".jpeg" + !inc_dot, 1); |
1188 | case IMAGE_FILETYPE_PNG: |
1189 | RETURN_STRING(".png" + !inc_dot, 1); |
1190 | case IMAGE_FILETYPE_SWF: |
1191 | case IMAGE_FILETYPE_SWC: |
1192 | RETURN_STRING(".swf" + !inc_dot, 1); |
1193 | case IMAGE_FILETYPE_PSD: |
1194 | RETURN_STRING(".psd" + !inc_dot, 1); |
1195 | case IMAGE_FILETYPE_BMP: |
1196 | case IMAGE_FILETYPE_WBMP: |
1197 | RETURN_STRING(".bmp" + !inc_dot, 1); |
1198 | case IMAGE_FILETYPE_TIFF_II: |
1199 | case IMAGE_FILETYPE_TIFF_MM: |
1200 | RETURN_STRING(".tiff" + !inc_dot, 1); |
1201 | case IMAGE_FILETYPE_IFF: |
1202 | RETURN_STRING(".iff" + !inc_dot, 1); |
1203 | case IMAGE_FILETYPE_JPC: |
1204 | RETURN_STRING(".jpc" + !inc_dot, 1); |
1205 | case IMAGE_FILETYPE_JP2: |
1206 | RETURN_STRING(".jp2" + !inc_dot, 1); |
1207 | case IMAGE_FILETYPE_JPX: |
1208 | RETURN_STRING(".jpx" + !inc_dot, 1); |
1209 | case IMAGE_FILETYPE_JB2: |
1210 | RETURN_STRING(".jb2" + !inc_dot, 1); |
1211 | case IMAGE_FILETYPE_XBM: |
1212 | RETURN_STRING(".xbm" + !inc_dot, 1); |
1213 | case IMAGE_FILETYPE_ICO: |
1214 | RETURN_STRING(".ico" + !inc_dot, 1); |
1215 | } |
1216 | |
1217 | RETURN_FALSE; |
1218 | } |
1219 | /* }}} */ |
1220 | |
1221 | /* {{{ php_imagetype |
1222 | detect filetype from first bytes */ |
1223 | PHPAPI int php_getimagetype(php_stream * stream, char *filetype TSRMLS_DC) |
1224 | { |
1225 | char tmp[12]; |
1226 | |
1227 | if ( !filetype) filetype = tmp; |
1228 | if((php_stream_read(stream, filetype, 3)) != 3) { |
1229 | php_error_docref(NULL TSRMLS_CC, E_NOTICE, "Read error!" ); |
1230 | return IMAGE_FILETYPE_UNKNOWN; |
1231 | } |
1232 | |
1233 | /* BYTES READ: 3 */ |
1234 | if (!memcmp(filetype, php_sig_gif, 3)) { |
1235 | return IMAGE_FILETYPE_GIF; |
1236 | } else if (!memcmp(filetype, php_sig_jpg, 3)) { |
1237 | return IMAGE_FILETYPE_JPEG; |
1238 | } else if (!memcmp(filetype, php_sig_png, 3)) { |
1239 | if (php_stream_read(stream, filetype+3, 5) != 5) { |
1240 | php_error_docref(NULL TSRMLS_CC, E_NOTICE, "Read error!" ); |
1241 | return IMAGE_FILETYPE_UNKNOWN; |
1242 | } |
1243 | if (!memcmp(filetype, php_sig_png, 8)) { |
1244 | return IMAGE_FILETYPE_PNG; |
1245 | } else { |
1246 | php_error_docref(NULL TSRMLS_CC, E_WARNING, "PNG file corrupted by ASCII conversion" ); |
1247 | return IMAGE_FILETYPE_UNKNOWN; |
1248 | } |
1249 | } else if (!memcmp(filetype, php_sig_swf, 3)) { |
1250 | return IMAGE_FILETYPE_SWF; |
1251 | } else if (!memcmp(filetype, php_sig_swc, 3)) { |
1252 | return IMAGE_FILETYPE_SWC; |
1253 | } else if (!memcmp(filetype, php_sig_psd, 3)) { |
1254 | return IMAGE_FILETYPE_PSD; |
1255 | } else if (!memcmp(filetype, php_sig_bmp, 2)) { |
1256 | return IMAGE_FILETYPE_BMP; |
1257 | } else if (!memcmp(filetype, php_sig_jpc, 3)) { |
1258 | return IMAGE_FILETYPE_JPC; |
1259 | } |
1260 | |
1261 | if (php_stream_read(stream, filetype+3, 1) != 1) { |
1262 | php_error_docref(NULL TSRMLS_CC, E_NOTICE, "Read error!" ); |
1263 | return IMAGE_FILETYPE_UNKNOWN; |
1264 | } |
1265 | /* BYTES READ: 4 */ |
1266 | if (!memcmp(filetype, php_sig_tif_ii, 4)) { |
1267 | return IMAGE_FILETYPE_TIFF_II; |
1268 | } else if (!memcmp(filetype, php_sig_tif_mm, 4)) { |
1269 | return IMAGE_FILETYPE_TIFF_MM; |
1270 | } else if (!memcmp(filetype, php_sig_iff, 4)) { |
1271 | return IMAGE_FILETYPE_IFF; |
1272 | } else if (!memcmp(filetype, php_sig_ico, 4)) { |
1273 | return IMAGE_FILETYPE_ICO; |
1274 | } |
1275 | |
1276 | if (php_stream_read(stream, filetype+4, 8) != 8) { |
1277 | php_error_docref(NULL TSRMLS_CC, E_NOTICE, "Read error!" ); |
1278 | return IMAGE_FILETYPE_UNKNOWN; |
1279 | } |
1280 | /* BYTES READ: 12 */ |
1281 | if (!memcmp(filetype, php_sig_jp2, 12)) { |
1282 | return IMAGE_FILETYPE_JP2; |
1283 | } |
1284 | |
1285 | /* AFTER ALL ABOVE FAILED */ |
1286 | if (php_get_wbmp(stream, NULL, 1 TSRMLS_CC)) { |
1287 | return IMAGE_FILETYPE_WBMP; |
1288 | } |
1289 | if (php_get_xbm(stream, NULL TSRMLS_CC)) { |
1290 | return IMAGE_FILETYPE_XBM; |
1291 | } |
1292 | return IMAGE_FILETYPE_UNKNOWN; |
1293 | } |
1294 | /* }}} */ |
1295 | |
1296 | static void php_getimagesize_from_stream(php_stream *stream, zval **info, INTERNAL_FUNCTION_PARAMETERS) /* {{{ */ |
1297 | { |
1298 | char *temp; |
1299 | int itype = 0; |
1300 | struct gfxinfo *result = NULL; |
1301 | |
1302 | if (!stream) { |
1303 | RETURN_FALSE; |
1304 | } |
1305 | |
1306 | itype = php_getimagetype(stream, NULL TSRMLS_CC); |
1307 | switch( itype) { |
1308 | case IMAGE_FILETYPE_GIF: |
1309 | result = php_handle_gif(stream TSRMLS_CC); |
1310 | break; |
1311 | case IMAGE_FILETYPE_JPEG: |
1312 | if (info) { |
1313 | result = php_handle_jpeg(stream, *info TSRMLS_CC); |
1314 | } else { |
1315 | result = php_handle_jpeg(stream, NULL TSRMLS_CC); |
1316 | } |
1317 | break; |
1318 | case IMAGE_FILETYPE_PNG: |
1319 | result = php_handle_png(stream TSRMLS_CC); |
1320 | break; |
1321 | case IMAGE_FILETYPE_SWF: |
1322 | result = php_handle_swf(stream TSRMLS_CC); |
1323 | break; |
1324 | case IMAGE_FILETYPE_SWC: |
1325 | #if HAVE_ZLIB && !defined(COMPILE_DL_ZLIB) |
1326 | result = php_handle_swc(stream TSRMLS_CC); |
1327 | #else |
1328 | php_error_docref(NULL TSRMLS_CC, E_NOTICE, "The image is a compressed SWF file, but you do not have a static version of the zlib extension enabled" ); |
1329 | #endif |
1330 | break; |
1331 | case IMAGE_FILETYPE_PSD: |
1332 | result = php_handle_psd(stream TSRMLS_CC); |
1333 | break; |
1334 | case IMAGE_FILETYPE_BMP: |
1335 | result = php_handle_bmp(stream TSRMLS_CC); |
1336 | break; |
1337 | case IMAGE_FILETYPE_TIFF_II: |
1338 | result = php_handle_tiff(stream, NULL, 0 TSRMLS_CC); |
1339 | break; |
1340 | case IMAGE_FILETYPE_TIFF_MM: |
1341 | result = php_handle_tiff(stream, NULL, 1 TSRMLS_CC); |
1342 | break; |
1343 | case IMAGE_FILETYPE_JPC: |
1344 | result = php_handle_jpc(stream TSRMLS_CC); |
1345 | break; |
1346 | case IMAGE_FILETYPE_JP2: |
1347 | result = php_handle_jp2(stream TSRMLS_CC); |
1348 | break; |
1349 | case IMAGE_FILETYPE_IFF: |
1350 | result = php_handle_iff(stream TSRMLS_CC); |
1351 | break; |
1352 | case IMAGE_FILETYPE_WBMP: |
1353 | result = php_handle_wbmp(stream TSRMLS_CC); |
1354 | break; |
1355 | case IMAGE_FILETYPE_XBM: |
1356 | result = php_handle_xbm(stream TSRMLS_CC); |
1357 | break; |
1358 | case IMAGE_FILETYPE_ICO: |
1359 | result = php_handle_ico(stream TSRMLS_CC); |
1360 | break; |
1361 | default: |
1362 | case IMAGE_FILETYPE_UNKNOWN: |
1363 | break; |
1364 | } |
1365 | |
1366 | if (result) { |
1367 | array_init(return_value); |
1368 | add_index_long(return_value, 0, result->width); |
1369 | add_index_long(return_value, 1, result->height); |
1370 | add_index_long(return_value, 2, itype); |
1371 | spprintf(&temp, 0, "width=\"%d\" height=\"%d\"" , result->width, result->height); |
1372 | add_index_string(return_value, 3, temp, 0); |
1373 | |
1374 | if (result->bits != 0) { |
1375 | add_assoc_long(return_value, "bits" , result->bits); |
1376 | } |
1377 | if (result->channels != 0) { |
1378 | add_assoc_long(return_value, "channels" , result->channels); |
1379 | } |
1380 | add_assoc_string(return_value, "mime" , (char*)php_image_type_to_mime_type(itype), 1); |
1381 | efree(result); |
1382 | } else { |
1383 | RETURN_FALSE; |
1384 | } |
1385 | } |
1386 | /* }}} */ |
1387 | |
1388 | #define FROM_DATA 0 |
1389 | #define FROM_PATH 1 |
1390 | |
1391 | static void php_getimagesize_from_any(INTERNAL_FUNCTION_PARAMETERS, int mode) { /* {{{ */ |
1392 | zval **info = NULL; |
1393 | php_stream *stream = NULL; |
1394 | char *input; |
1395 | int input_len; |
1396 | const int argc = ZEND_NUM_ARGS(); |
1397 | |
1398 | if (zend_parse_parameters(argc TSRMLS_CC, "s|Z" , &input, &input_len, &info) == FAILURE) { |
1399 | return; |
1400 | } |
1401 | |
1402 | if (argc == 2) { |
1403 | zval_dtor(*info); |
1404 | array_init(*info); |
1405 | } |
1406 | |
1407 | |
1408 | if (mode == FROM_PATH) { |
1409 | stream = php_stream_open_wrapper(input, "rb" , STREAM_MUST_SEEK|REPORT_ERRORS|IGNORE_PATH, NULL); |
1410 | } else { |
1411 | stream = php_stream_memory_open(TEMP_STREAM_READONLY, input, input_len); |
1412 | } |
1413 | |
1414 | if (!stream) { |
1415 | RETURN_FALSE; |
1416 | } |
1417 | |
1418 | php_getimagesize_from_stream(stream, info, INTERNAL_FUNCTION_PARAM_PASSTHRU); |
1419 | php_stream_close(stream); |
1420 | } |
1421 | /* }}} */ |
1422 | |
1423 | /* {{{ proto array getimagesize(string imagefile [, array info]) |
1424 | Get the size of an image as 4-element array */ |
1425 | PHP_FUNCTION(getimagesize) |
1426 | { |
1427 | php_getimagesize_from_any(INTERNAL_FUNCTION_PARAM_PASSTHRU, FROM_PATH); |
1428 | } |
1429 | /* }}} */ |
1430 | |
1431 | /* {{{ proto array getimagesizefromstring(string data [, array info]) |
1432 | Get the size of an image as 4-element array */ |
1433 | PHP_FUNCTION(getimagesizefromstring) |
1434 | { |
1435 | php_getimagesize_from_any(INTERNAL_FUNCTION_PARAM_PASSTHRU, FROM_DATA); |
1436 | } |
1437 | |
1438 | /* |
1439 | * Local variables: |
1440 | * tab-width: 4 |
1441 | * c-basic-offset: 4 |
1442 | * End: |
1443 | * vim600: sw=4 ts=4 fdm=marker |
1444 | * vim<600: sw=4 ts=4 |
1445 | */ |
1446 | |