1/*
2   +----------------------------------------------------------------------+
3   | PHP Version 5                                                        |
4   +----------------------------------------------------------------------+
5   | Copyright (c) 1997-2014 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 */
42PHPAPI const char php_sig_gif[3] = {'G', 'I', 'F'};
43PHPAPI const char php_sig_psd[4] = {'8', 'B', 'P', 'S'};
44PHPAPI const char php_sig_bmp[2] = {'B', 'M'};
45PHPAPI const char php_sig_swf[3] = {'F', 'W', 'S'};
46PHPAPI const char php_sig_swc[3] = {'C', 'W', 'S'};
47PHPAPI const char php_sig_jpg[3] = {(char) 0xff, (char) 0xd8, (char) 0xff};
48PHPAPI const char php_sig_png[8] = {(char) 0x89, (char) 0x50, (char) 0x4e, (char) 0x47,
49                                    (char) 0x0d, (char) 0x0a, (char) 0x1a, (char) 0x0a};
50PHPAPI const char php_sig_tif_ii[4] = {'I','I', (char)0x2A, (char)0x00};
51PHPAPI const char php_sig_tif_mm[4] = {'M','M', (char)0x00, (char)0x2A};
52PHPAPI const char php_sig_jpc[3]  = {(char)0xff, (char)0x4f, (char)0xff};
53PHPAPI 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};
56PHPAPI const char php_sig_iff[4] = {'F','O','R','M'};
57PHPAPI 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
64struct 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 */
73PHP_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... ;} */
103static 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 */
126static 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 */
147static 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. */
181static 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 */
198static 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 */
270static 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 */
296static 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 */
364static unsigned short php_read2(php_stream * stream TSRMLS_DC)
365{
366    unsigned char a[2];
367
368    /* just return 0 if we hit the end-of-file */
369    if((php_stream_read(stream, a, sizeof(a))) <= 0) 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 */
377static unsigned int php_next_marker(php_stream * stream, int last_marker, int comment_correction, 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 */
425static 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 */
440static 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 onyl 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 */
474static 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 markes... */
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 */
563static 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 */
603static 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 || 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 */
675static 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 */
735PHPAPI 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 */
760static 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 */
772static 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 */
780static 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 */
794static 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 */
802static 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 */
883static 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 */
944static 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*/
999static 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 */
1014static 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 */
1074static 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 */
1084static 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 */
1120PHPAPI 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 */
1160PHP_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 */
1174PHP_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 */
1223PHPAPI 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
1296static 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
1391static 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 */
1425PHP_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 */
1433PHP_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