xref: /PHP-5.6/ext/gd/gd.c (revision b92216b9) 
1 /*
2    +----------------------------------------------------------------------+
3    | PHP Version 5                                                        |
4    +----------------------------------------------------------------------+
5    | Copyright (c) 1997-2016 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    |          Stig Bakken <ssb@php.net>                                   |
17    |          Jim Winstead <jimw@php.net>                                 |
18    +----------------------------------------------------------------------+
19  */
20 
21 /* $Id$ */
22 
23 /* gd 1.2 is copyright 1994, 1995, Quest Protein Database Center,
24    Cold Spring Harbor Labs. */
25 
26 /* Note that there is no code from the gd package in this file */
27 
28 #ifdef HAVE_CONFIG_H
29 #include "config.h"
30 #endif
31 
32 #include "php.h"
33 #include "php_ini.h"
34 #include "ext/standard/head.h"
35 #include <math.h>
36 #include "SAPI.h"
37 #include "php_gd.h"
38 #include "ext/standard/info.h"
39 #include "php_open_temporary_file.h"
40 
41 
42 #if HAVE_SYS_WAIT_H
43 # include <sys/wait.h>
44 #endif
45 #if HAVE_UNISTD_H
46 # include <unistd.h>
47 #endif
48 #ifdef PHP_WIN32
49 # include <io.h>
50 # include <fcntl.h>
51 # include <windows.h>
52 # include <Winuser.h>
53 # include <Wingdi.h>
54 #endif
55 
56 #ifdef HAVE_GD_XPM
57 # include <X11/xpm.h>
58 #endif
59 
60 # include "gd_compat.h"
61 
62 
63 static int le_gd, le_gd_font;
64 #if HAVE_LIBT1
65 #include <t1lib.h>
66 static int le_ps_font, le_ps_enc;
67 static void php_free_ps_font(zend_rsrc_list_entry *rsrc TSRMLS_DC);
68 static void php_free_ps_enc(zend_rsrc_list_entry *rsrc TSRMLS_DC);
69 #endif
70 
71 #include <gd.h>
72 #ifndef HAVE_GD_BUNDLED
73 # include <gd_errors.h>
74 #endif
75 #include <gdfontt.h>  /* 1 Tiny font */
76 #include <gdfonts.h>  /* 2 Small font */
77 #include <gdfontmb.h> /* 3 Medium bold font */
78 #include <gdfontl.h>  /* 4 Large font */
79 #include <gdfontg.h>  /* 5 Giant font */
80 
81 #ifdef ENABLE_GD_TTF
82 # ifdef HAVE_LIBFREETYPE
83 #  include <ft2build.h>
84 #  include FT_FREETYPE_H
85 # endif
86 #endif
87 
88 #if defined(HAVE_GD_XPM) && defined(HAVE_GD_BUNDLED)
89 # include "X11/xpm.h"
90 #endif
91 
92 #ifndef M_PI
93 #define M_PI 3.14159265358979323846
94 #endif
95 
96 #ifdef ENABLE_GD_TTF
97 static void php_imagettftext_common(INTERNAL_FUNCTION_PARAMETERS, int, int);
98 #endif
99 
100 #include "gd_ctx.c"
101 
102 /* as it is not really public, duplicate declaration here to avoid
103    pointless warnings */
104 int overflow2(int a, int b);
105 
106 /* Section Filters Declarations */
107 /* IMPORTANT NOTE FOR NEW FILTER
108  * Do not forget to update:
109  * IMAGE_FILTER_MAX: define the last filter index
110  * IMAGE_FILTER_MAX_ARGS: define the biggest amount of arguments
111  * image_filter array in PHP_FUNCTION(imagefilter)
112  * */
113 #define IMAGE_FILTER_NEGATE         0
114 #define IMAGE_FILTER_GRAYSCALE      1
115 #define IMAGE_FILTER_BRIGHTNESS     2
116 #define IMAGE_FILTER_CONTRAST       3
117 #define IMAGE_FILTER_COLORIZE       4
118 #define IMAGE_FILTER_EDGEDETECT     5
119 #define IMAGE_FILTER_EMBOSS         6
120 #define IMAGE_FILTER_GAUSSIAN_BLUR  7
121 #define IMAGE_FILTER_SELECTIVE_BLUR 8
122 #define IMAGE_FILTER_MEAN_REMOVAL   9
123 #define IMAGE_FILTER_SMOOTH         10
124 #define IMAGE_FILTER_PIXELATE       11
125 #define IMAGE_FILTER_MAX            11
126 #define IMAGE_FILTER_MAX_ARGS       6
127 static void php_image_filter_negate(INTERNAL_FUNCTION_PARAMETERS);
128 static void php_image_filter_grayscale(INTERNAL_FUNCTION_PARAMETERS);
129 static void php_image_filter_brightness(INTERNAL_FUNCTION_PARAMETERS);
130 static void php_image_filter_contrast(INTERNAL_FUNCTION_PARAMETERS);
131 static void php_image_filter_colorize(INTERNAL_FUNCTION_PARAMETERS);
132 static void php_image_filter_edgedetect(INTERNAL_FUNCTION_PARAMETERS);
133 static void php_image_filter_emboss(INTERNAL_FUNCTION_PARAMETERS);
134 static void php_image_filter_gaussian_blur(INTERNAL_FUNCTION_PARAMETERS);
135 static void php_image_filter_selective_blur(INTERNAL_FUNCTION_PARAMETERS);
136 static void php_image_filter_mean_removal(INTERNAL_FUNCTION_PARAMETERS);
137 static void php_image_filter_smooth(INTERNAL_FUNCTION_PARAMETERS);
138 static void php_image_filter_pixelate(INTERNAL_FUNCTION_PARAMETERS);
139 
140 /* End Section filters declarations */
141 static gdImagePtr _php_image_create_from_string (zval **Data, char *tn, gdImagePtr (*ioctx_func_p)() TSRMLS_DC);
142 static void _php_image_create_from(INTERNAL_FUNCTION_PARAMETERS, int image_type, char *tn, gdImagePtr (*func_p)(), gdImagePtr (*ioctx_func_p)());
143 static void _php_image_output(INTERNAL_FUNCTION_PARAMETERS, int image_type, char *tn, void (*func_p)());
144 static int _php_image_type(char data[8]);
145 static void _php_image_convert(INTERNAL_FUNCTION_PARAMETERS, int image_type);
146 static void _php_image_bw_convert(gdImagePtr im_org, gdIOCtx *out, int threshold);
147 
148 /* {{{ arginfo */
149 ZEND_BEGIN_ARG_INFO(arginfo_gd_info, 0)
150 ZEND_END_ARG_INFO()
151 
152 ZEND_BEGIN_ARG_INFO(arginfo_imageloadfont, 0)
153 	ZEND_ARG_INFO(0, filename)
154 ZEND_END_ARG_INFO()
155 
156 ZEND_BEGIN_ARG_INFO(arginfo_imagesetstyle, 0)
157 	ZEND_ARG_INFO(0, im)
158 	ZEND_ARG_INFO(0, styles) /* ARRAY_INFO(0, styles, 0) */
159 ZEND_END_ARG_INFO()
160 
161 ZEND_BEGIN_ARG_INFO(arginfo_imagecreatetruecolor, 0)
162 	ZEND_ARG_INFO(0, x_size)
163 	ZEND_ARG_INFO(0, y_size)
164 ZEND_END_ARG_INFO()
165 
166 ZEND_BEGIN_ARG_INFO(arginfo_imageistruecolor, 0)
167 	ZEND_ARG_INFO(0, im)
168 ZEND_END_ARG_INFO()
169 
170 ZEND_BEGIN_ARG_INFO(arginfo_imagetruecolortopalette, 0)
171 	ZEND_ARG_INFO(0, im)
172 	ZEND_ARG_INFO(0, ditherFlag)
173 	ZEND_ARG_INFO(0, colorsWanted)
174 ZEND_END_ARG_INFO()
175 
176 ZEND_BEGIN_ARG_INFO(arginfo_imagepalettetotruecolor, 0)
177 	ZEND_ARG_INFO(0, im)
178 ZEND_END_ARG_INFO()
179 
180 ZEND_BEGIN_ARG_INFO(arginfo_imagecolormatch, 0)
181 	ZEND_ARG_INFO(0, im1)
182 	ZEND_ARG_INFO(0, im2)
183 ZEND_END_ARG_INFO()
184 
185 ZEND_BEGIN_ARG_INFO(arginfo_imagesetthickness, 0)
186 	ZEND_ARG_INFO(0, im)
187 	ZEND_ARG_INFO(0, thickness)
188 ZEND_END_ARG_INFO()
189 
190 ZEND_BEGIN_ARG_INFO(arginfo_imagefilledellipse, 0)
191 	ZEND_ARG_INFO(0, im)
192 	ZEND_ARG_INFO(0, cx)
193 	ZEND_ARG_INFO(0, cy)
194 	ZEND_ARG_INFO(0, w)
195 	ZEND_ARG_INFO(0, h)
196 	ZEND_ARG_INFO(0, color)
197 ZEND_END_ARG_INFO()
198 
199 ZEND_BEGIN_ARG_INFO(arginfo_imagefilledarc, 0)
200 	ZEND_ARG_INFO(0, im)
201 	ZEND_ARG_INFO(0, cx)
202 	ZEND_ARG_INFO(0, cy)
203 	ZEND_ARG_INFO(0, w)
204 	ZEND_ARG_INFO(0, h)
205 	ZEND_ARG_INFO(0, s)
206 	ZEND_ARG_INFO(0, e)
207 	ZEND_ARG_INFO(0, col)
208 	ZEND_ARG_INFO(0, style)
209 ZEND_END_ARG_INFO()
210 
211 ZEND_BEGIN_ARG_INFO(arginfo_imagealphablending, 0)
212 	ZEND_ARG_INFO(0, im)
213 	ZEND_ARG_INFO(0, blend)
214 ZEND_END_ARG_INFO()
215 
216 ZEND_BEGIN_ARG_INFO(arginfo_imagesavealpha, 0)
217 	ZEND_ARG_INFO(0, im)
218 	ZEND_ARG_INFO(0, save)
219 ZEND_END_ARG_INFO()
220 
221 ZEND_BEGIN_ARG_INFO(arginfo_imagelayereffect, 0)
222 	ZEND_ARG_INFO(0, im)
223 	ZEND_ARG_INFO(0, effect)
224 ZEND_END_ARG_INFO()
225 
226 ZEND_BEGIN_ARG_INFO(arginfo_imagecolorallocatealpha, 0)
227 	ZEND_ARG_INFO(0, im)
228 	ZEND_ARG_INFO(0, red)
229 	ZEND_ARG_INFO(0, green)
230 	ZEND_ARG_INFO(0, blue)
231 	ZEND_ARG_INFO(0, alpha)
232 ZEND_END_ARG_INFO()
233 
234 ZEND_BEGIN_ARG_INFO(arginfo_imagecolorresolvealpha, 0)
235 	ZEND_ARG_INFO(0, im)
236 	ZEND_ARG_INFO(0, red)
237 	ZEND_ARG_INFO(0, green)
238 	ZEND_ARG_INFO(0, blue)
239 	ZEND_ARG_INFO(0, alpha)
240 ZEND_END_ARG_INFO()
241 
242 ZEND_BEGIN_ARG_INFO(arginfo_imagecolorclosestalpha, 0)
243 	ZEND_ARG_INFO(0, im)
244 	ZEND_ARG_INFO(0, red)
245 	ZEND_ARG_INFO(0, green)
246 	ZEND_ARG_INFO(0, blue)
247 	ZEND_ARG_INFO(0, alpha)
248 ZEND_END_ARG_INFO()
249 
250 ZEND_BEGIN_ARG_INFO(arginfo_imagecolorexactalpha, 0)
251 	ZEND_ARG_INFO(0, im)
252 	ZEND_ARG_INFO(0, red)
253 	ZEND_ARG_INFO(0, green)
254 	ZEND_ARG_INFO(0, blue)
255 	ZEND_ARG_INFO(0, alpha)
256 ZEND_END_ARG_INFO()
257 
258 ZEND_BEGIN_ARG_INFO(arginfo_imagecopyresampled, 0)
259 	ZEND_ARG_INFO(0, dst_im)
260 	ZEND_ARG_INFO(0, src_im)
261 	ZEND_ARG_INFO(0, dst_x)
262 	ZEND_ARG_INFO(0, dst_y)
263 	ZEND_ARG_INFO(0, src_x)
264 	ZEND_ARG_INFO(0, src_y)
265 	ZEND_ARG_INFO(0, dst_w)
266 	ZEND_ARG_INFO(0, dst_h)
267 	ZEND_ARG_INFO(0, src_w)
268 	ZEND_ARG_INFO(0, src_h)
269 ZEND_END_ARG_INFO()
270 
271 #ifdef PHP_WIN32
272 ZEND_BEGIN_ARG_INFO_EX(arginfo_imagegrabwindow, 0, 0, 1)
273 	ZEND_ARG_INFO(0, handle)
274 	ZEND_ARG_INFO(0, client_area)
275 ZEND_END_ARG_INFO()
276 
277 ZEND_BEGIN_ARG_INFO(arginfo_imagegrabscreen, 0)
278 ZEND_END_ARG_INFO()
279 #endif
280 
281 ZEND_BEGIN_ARG_INFO_EX(arginfo_imagerotate, 0, 0, 3)
282 	ZEND_ARG_INFO(0, im)
283 	ZEND_ARG_INFO(0, angle)
284 	ZEND_ARG_INFO(0, bgdcolor)
285 	ZEND_ARG_INFO(0, ignoretransparent)
286 ZEND_END_ARG_INFO()
287 
288 ZEND_BEGIN_ARG_INFO(arginfo_imagesettile, 0)
289 	ZEND_ARG_INFO(0, im)
290 	ZEND_ARG_INFO(0, tile)
291 ZEND_END_ARG_INFO()
292 
293 ZEND_BEGIN_ARG_INFO(arginfo_imagesetbrush, 0)
294 	ZEND_ARG_INFO(0, im)
295 	ZEND_ARG_INFO(0, brush)
296 ZEND_END_ARG_INFO()
297 
298 ZEND_BEGIN_ARG_INFO(arginfo_imagecreate, 0)
299 	ZEND_ARG_INFO(0, x_size)
300 	ZEND_ARG_INFO(0, y_size)
301 ZEND_END_ARG_INFO()
302 
303 ZEND_BEGIN_ARG_INFO(arginfo_imagetypes, 0)
304 ZEND_END_ARG_INFO()
305 
306 ZEND_BEGIN_ARG_INFO(arginfo_imagecreatefromstring, 0)
307 	ZEND_ARG_INFO(0, image)
308 ZEND_END_ARG_INFO()
309 
310 ZEND_BEGIN_ARG_INFO(arginfo_imagecreatefromgif, 0)
311 	ZEND_ARG_INFO(0, filename)
312 ZEND_END_ARG_INFO()
313 
314 #ifdef HAVE_GD_JPG
315 ZEND_BEGIN_ARG_INFO(arginfo_imagecreatefromjpeg, 0)
316 	ZEND_ARG_INFO(0, filename)
317 ZEND_END_ARG_INFO()
318 #endif
319 
320 #ifdef HAVE_GD_PNG
321 ZEND_BEGIN_ARG_INFO(arginfo_imagecreatefrompng, 0)
322 	ZEND_ARG_INFO(0, filename)
323 ZEND_END_ARG_INFO()
324 #endif
325 
326 #ifdef HAVE_GD_WEBP
327 ZEND_BEGIN_ARG_INFO(arginfo_imagecreatefromwebp, 0)
328 	ZEND_ARG_INFO(0, filename)
329 ZEND_END_ARG_INFO()
330 #endif
331 
332 ZEND_BEGIN_ARG_INFO(arginfo_imagecreatefromxbm, 0)
333 	ZEND_ARG_INFO(0, filename)
334 ZEND_END_ARG_INFO()
335 
336 #if defined(HAVE_GD_XPM)
337 ZEND_BEGIN_ARG_INFO(arginfo_imagecreatefromxpm, 0)
338 	ZEND_ARG_INFO(0, filename)
339 ZEND_END_ARG_INFO()
340 #endif
341 
342 ZEND_BEGIN_ARG_INFO(arginfo_imagecreatefromwbmp, 0)
343 	ZEND_ARG_INFO(0, filename)
344 ZEND_END_ARG_INFO()
345 
346 ZEND_BEGIN_ARG_INFO(arginfo_imagecreatefromgd, 0)
347 	ZEND_ARG_INFO(0, filename)
348 ZEND_END_ARG_INFO()
349 
350 ZEND_BEGIN_ARG_INFO(arginfo_imagecreatefromgd2, 0)
351 	ZEND_ARG_INFO(0, filename)
352 ZEND_END_ARG_INFO()
353 
354 ZEND_BEGIN_ARG_INFO(arginfo_imagecreatefromgd2part, 0)
355 	ZEND_ARG_INFO(0, filename)
356 	ZEND_ARG_INFO(0, srcX)
357 	ZEND_ARG_INFO(0, srcY)
358 	ZEND_ARG_INFO(0, width)
359 	ZEND_ARG_INFO(0, height)
360 ZEND_END_ARG_INFO()
361 
362 ZEND_BEGIN_ARG_INFO_EX(arginfo_imagexbm, 0, 0, 2)
363 	ZEND_ARG_INFO(0, im)
364 	ZEND_ARG_INFO(0, filename)
365 	ZEND_ARG_INFO(0, foreground)
366 ZEND_END_ARG_INFO()
367 
368 ZEND_BEGIN_ARG_INFO_EX(arginfo_imagegif, 0, 0, 1)
369 	ZEND_ARG_INFO(0, im)
370 	ZEND_ARG_INFO(0, filename)
371 ZEND_END_ARG_INFO()
372 
373 #ifdef HAVE_GD_PNG
374 ZEND_BEGIN_ARG_INFO_EX(arginfo_imagepng, 0, 0, 1)
375 	ZEND_ARG_INFO(0, im)
376 	ZEND_ARG_INFO(0, filename)
377 ZEND_END_ARG_INFO()
378 #endif
379 
380 #ifdef HAVE_GD_WEBP
381 ZEND_BEGIN_ARG_INFO_EX(arginfo_imagewebp, 0, 0, 1)
382 	ZEND_ARG_INFO(0, im)
383 	ZEND_ARG_INFO(0, filename)
384 ZEND_END_ARG_INFO()
385 #endif
386 
387 #ifdef HAVE_GD_JPG
388 ZEND_BEGIN_ARG_INFO_EX(arginfo_imagejpeg, 0, 0, 1)
389 	ZEND_ARG_INFO(0, im)
390 	ZEND_ARG_INFO(0, filename)
391 	ZEND_ARG_INFO(0, quality)
392 ZEND_END_ARG_INFO()
393 #endif
394 
395 ZEND_BEGIN_ARG_INFO_EX(arginfo_imagewbmp, 0, 0, 1)
396 	ZEND_ARG_INFO(0, im)
397 	ZEND_ARG_INFO(0, filename)
398 	ZEND_ARG_INFO(0, foreground)
399 ZEND_END_ARG_INFO()
400 
401 ZEND_BEGIN_ARG_INFO_EX(arginfo_imagegd, 0, 0, 1)
402 	ZEND_ARG_INFO(0, im)
403 	ZEND_ARG_INFO(0, filename)
404 ZEND_END_ARG_INFO()
405 
406 ZEND_BEGIN_ARG_INFO_EX(arginfo_imagegd2, 0, 0, 1)
407 	ZEND_ARG_INFO(0, im)
408 	ZEND_ARG_INFO(0, filename)
409 	ZEND_ARG_INFO(0, chunk_size)
410 	ZEND_ARG_INFO(0, type)
411 ZEND_END_ARG_INFO()
412 
413 ZEND_BEGIN_ARG_INFO(arginfo_imagedestroy, 0)
414 	ZEND_ARG_INFO(0, im)
415 ZEND_END_ARG_INFO()
416 
417 ZEND_BEGIN_ARG_INFO(arginfo_imagecolorallocate, 0)
418 	ZEND_ARG_INFO(0, im)
419 	ZEND_ARG_INFO(0, red)
420 	ZEND_ARG_INFO(0, green)
421 	ZEND_ARG_INFO(0, blue)
422 ZEND_END_ARG_INFO()
423 
424 ZEND_BEGIN_ARG_INFO(arginfo_imagepalettecopy, 0)
425 	ZEND_ARG_INFO(0, dst)
426 	ZEND_ARG_INFO(0, src)
427 ZEND_END_ARG_INFO()
428 
429 ZEND_BEGIN_ARG_INFO(arginfo_imagecolorat, 0)
430 	ZEND_ARG_INFO(0, im)
431 	ZEND_ARG_INFO(0, x)
432 	ZEND_ARG_INFO(0, y)
433 ZEND_END_ARG_INFO()
434 
435 ZEND_BEGIN_ARG_INFO(arginfo_imagecolorclosest, 0)
436 	ZEND_ARG_INFO(0, im)
437 	ZEND_ARG_INFO(0, red)
438 	ZEND_ARG_INFO(0, green)
439 	ZEND_ARG_INFO(0, blue)
440 ZEND_END_ARG_INFO()
441 
442 ZEND_BEGIN_ARG_INFO(arginfo_imagecolorclosesthwb, 0)
443 	ZEND_ARG_INFO(0, im)
444 	ZEND_ARG_INFO(0, red)
445 	ZEND_ARG_INFO(0, green)
446 	ZEND_ARG_INFO(0, blue)
447 ZEND_END_ARG_INFO()
448 
449 ZEND_BEGIN_ARG_INFO(arginfo_imagecolordeallocate, 0)
450 	ZEND_ARG_INFO(0, im)
451 	ZEND_ARG_INFO(0, index)
452 ZEND_END_ARG_INFO()
453 
454 ZEND_BEGIN_ARG_INFO(arginfo_imagecolorresolve, 0)
455 	ZEND_ARG_INFO(0, im)
456 	ZEND_ARG_INFO(0, red)
457 	ZEND_ARG_INFO(0, green)
458 	ZEND_ARG_INFO(0, blue)
459 ZEND_END_ARG_INFO()
460 
461 ZEND_BEGIN_ARG_INFO(arginfo_imagecolorexact, 0)
462 	ZEND_ARG_INFO(0, im)
463 	ZEND_ARG_INFO(0, red)
464 	ZEND_ARG_INFO(0, green)
465 	ZEND_ARG_INFO(0, blue)
466 ZEND_END_ARG_INFO()
467 
468 ZEND_BEGIN_ARG_INFO_EX(arginfo_imagecolorset, 0, 0, 5)
469 	ZEND_ARG_INFO(0, im)
470 	ZEND_ARG_INFO(0, color)
471 	ZEND_ARG_INFO(0, red)
472 	ZEND_ARG_INFO(0, green)
473 	ZEND_ARG_INFO(0, blue)
474 	ZEND_ARG_INFO(0, alpha)
475 ZEND_END_ARG_INFO()
476 
477 ZEND_BEGIN_ARG_INFO(arginfo_imagecolorsforindex, 0)
478 	ZEND_ARG_INFO(0, im)
479 	ZEND_ARG_INFO(0, index)
480 ZEND_END_ARG_INFO()
481 
482 ZEND_BEGIN_ARG_INFO(arginfo_imagegammacorrect, 0)
483 	ZEND_ARG_INFO(0, im)
484 	ZEND_ARG_INFO(0, inputgamma)
485 	ZEND_ARG_INFO(0, outputgamma)
486 ZEND_END_ARG_INFO()
487 
488 ZEND_BEGIN_ARG_INFO(arginfo_imagesetpixel, 0)
489 	ZEND_ARG_INFO(0, im)
490 	ZEND_ARG_INFO(0, x)
491 	ZEND_ARG_INFO(0, y)
492 	ZEND_ARG_INFO(0, col)
493 ZEND_END_ARG_INFO()
494 
495 ZEND_BEGIN_ARG_INFO(arginfo_imageline, 0)
496 	ZEND_ARG_INFO(0, im)
497 	ZEND_ARG_INFO(0, x1)
498 	ZEND_ARG_INFO(0, y1)
499 	ZEND_ARG_INFO(0, x2)
500 	ZEND_ARG_INFO(0, y2)
501 	ZEND_ARG_INFO(0, col)
502 ZEND_END_ARG_INFO()
503 
504 ZEND_BEGIN_ARG_INFO(arginfo_imagedashedline, 0)
505 	ZEND_ARG_INFO(0, im)
506 	ZEND_ARG_INFO(0, x1)
507 	ZEND_ARG_INFO(0, y1)
508 	ZEND_ARG_INFO(0, x2)
509 	ZEND_ARG_INFO(0, y2)
510 	ZEND_ARG_INFO(0, col)
511 ZEND_END_ARG_INFO()
512 
513 ZEND_BEGIN_ARG_INFO(arginfo_imagerectangle, 0)
514 	ZEND_ARG_INFO(0, im)
515 	ZEND_ARG_INFO(0, x1)
516 	ZEND_ARG_INFO(0, y1)
517 	ZEND_ARG_INFO(0, x2)
518 	ZEND_ARG_INFO(0, y2)
519 	ZEND_ARG_INFO(0, col)
520 ZEND_END_ARG_INFO()
521 
522 ZEND_BEGIN_ARG_INFO(arginfo_imagefilledrectangle, 0)
523 	ZEND_ARG_INFO(0, im)
524 	ZEND_ARG_INFO(0, x1)
525 	ZEND_ARG_INFO(0, y1)
526 	ZEND_ARG_INFO(0, x2)
527 	ZEND_ARG_INFO(0, y2)
528 	ZEND_ARG_INFO(0, col)
529 ZEND_END_ARG_INFO()
530 
531 ZEND_BEGIN_ARG_INFO(arginfo_imagearc, 0)
532 	ZEND_ARG_INFO(0, im)
533 	ZEND_ARG_INFO(0, cx)
534 	ZEND_ARG_INFO(0, cy)
535 	ZEND_ARG_INFO(0, w)
536 	ZEND_ARG_INFO(0, h)
537 	ZEND_ARG_INFO(0, s)
538 	ZEND_ARG_INFO(0, e)
539 	ZEND_ARG_INFO(0, col)
540 ZEND_END_ARG_INFO()
541 
542 ZEND_BEGIN_ARG_INFO(arginfo_imageellipse, 0)
543 	ZEND_ARG_INFO(0, im)
544 	ZEND_ARG_INFO(0, cx)
545 	ZEND_ARG_INFO(0, cy)
546 	ZEND_ARG_INFO(0, w)
547 	ZEND_ARG_INFO(0, h)
548 	ZEND_ARG_INFO(0, color)
549 ZEND_END_ARG_INFO()
550 
551 ZEND_BEGIN_ARG_INFO(arginfo_imagefilltoborder, 0)
552 	ZEND_ARG_INFO(0, im)
553 	ZEND_ARG_INFO(0, x)
554 	ZEND_ARG_INFO(0, y)
555 	ZEND_ARG_INFO(0, border)
556 	ZEND_ARG_INFO(0, col)
557 ZEND_END_ARG_INFO()
558 
559 ZEND_BEGIN_ARG_INFO(arginfo_imagefill, 0)
560 	ZEND_ARG_INFO(0, im)
561 	ZEND_ARG_INFO(0, x)
562 	ZEND_ARG_INFO(0, y)
563 	ZEND_ARG_INFO(0, col)
564 ZEND_END_ARG_INFO()
565 
566 ZEND_BEGIN_ARG_INFO(arginfo_imagecolorstotal, 0)
567 	ZEND_ARG_INFO(0, im)
568 ZEND_END_ARG_INFO()
569 
570 ZEND_BEGIN_ARG_INFO_EX(arginfo_imagecolortransparent, 0, 0, 1)
571 	ZEND_ARG_INFO(0, im)
572 	ZEND_ARG_INFO(0, col)
573 ZEND_END_ARG_INFO()
574 
575 ZEND_BEGIN_ARG_INFO_EX(arginfo_imageinterlace, 0, 0, 1)
576 	ZEND_ARG_INFO(0, im)
577 	ZEND_ARG_INFO(0, interlace)
578 ZEND_END_ARG_INFO()
579 
580 ZEND_BEGIN_ARG_INFO(arginfo_imagepolygon, 0)
581 	ZEND_ARG_INFO(0, im)
582 	ZEND_ARG_INFO(0, points) /* ARRAY_INFO(0, points, 0) */
583 	ZEND_ARG_INFO(0, num_pos)
584 	ZEND_ARG_INFO(0, col)
585 ZEND_END_ARG_INFO()
586 
587 ZEND_BEGIN_ARG_INFO(arginfo_imagefilledpolygon, 0)
588 	ZEND_ARG_INFO(0, im)
589 	ZEND_ARG_INFO(0, points) /* ARRAY_INFO(0, points, 0) */
590 	ZEND_ARG_INFO(0, num_pos)
591 	ZEND_ARG_INFO(0, col)
592 ZEND_END_ARG_INFO()
593 
594 ZEND_BEGIN_ARG_INFO(arginfo_imagefontwidth, 0)
595 	ZEND_ARG_INFO(0, font)
596 ZEND_END_ARG_INFO()
597 
598 ZEND_BEGIN_ARG_INFO(arginfo_imagefontheight, 0)
599 	ZEND_ARG_INFO(0, font)
600 ZEND_END_ARG_INFO()
601 
602 ZEND_BEGIN_ARG_INFO(arginfo_imagechar, 0)
603 	ZEND_ARG_INFO(0, im)
604 	ZEND_ARG_INFO(0, font)
605 	ZEND_ARG_INFO(0, x)
606 	ZEND_ARG_INFO(0, y)
607 	ZEND_ARG_INFO(0, c)
608 	ZEND_ARG_INFO(0, col)
609 ZEND_END_ARG_INFO()
610 
611 ZEND_BEGIN_ARG_INFO(arginfo_imagecharup, 0)
612 	ZEND_ARG_INFO(0, im)
613 	ZEND_ARG_INFO(0, font)
614 	ZEND_ARG_INFO(0, x)
615 	ZEND_ARG_INFO(0, y)
616 	ZEND_ARG_INFO(0, c)
617 	ZEND_ARG_INFO(0, col)
618 ZEND_END_ARG_INFO()
619 
620 ZEND_BEGIN_ARG_INFO(arginfo_imagestring, 0)
621 	ZEND_ARG_INFO(0, im)
622 	ZEND_ARG_INFO(0, font)
623 	ZEND_ARG_INFO(0, x)
624 	ZEND_ARG_INFO(0, y)
625 	ZEND_ARG_INFO(0, str)
626 	ZEND_ARG_INFO(0, col)
627 ZEND_END_ARG_INFO()
628 
629 ZEND_BEGIN_ARG_INFO(arginfo_imagestringup, 0)
630 	ZEND_ARG_INFO(0, im)
631 	ZEND_ARG_INFO(0, font)
632 	ZEND_ARG_INFO(0, x)
633 	ZEND_ARG_INFO(0, y)
634 	ZEND_ARG_INFO(0, str)
635 	ZEND_ARG_INFO(0, col)
636 ZEND_END_ARG_INFO()
637 
638 ZEND_BEGIN_ARG_INFO(arginfo_imagecopy, 0)
639 	ZEND_ARG_INFO(0, dst_im)
640 	ZEND_ARG_INFO(0, src_im)
641 	ZEND_ARG_INFO(0, dst_x)
642 	ZEND_ARG_INFO(0, dst_y)
643 	ZEND_ARG_INFO(0, src_x)
644 	ZEND_ARG_INFO(0, src_y)
645 	ZEND_ARG_INFO(0, src_w)
646 	ZEND_ARG_INFO(0, src_h)
647 ZEND_END_ARG_INFO()
648 
649 ZEND_BEGIN_ARG_INFO(arginfo_imagecopymerge, 0)
650 	ZEND_ARG_INFO(0, src_im)
651 	ZEND_ARG_INFO(0, dst_im)
652 	ZEND_ARG_INFO(0, dst_x)
653 	ZEND_ARG_INFO(0, dst_y)
654 	ZEND_ARG_INFO(0, src_x)
655 	ZEND_ARG_INFO(0, src_y)
656 	ZEND_ARG_INFO(0, src_w)
657 	ZEND_ARG_INFO(0, src_h)
658 	ZEND_ARG_INFO(0, pct)
659 ZEND_END_ARG_INFO()
660 
661 ZEND_BEGIN_ARG_INFO(arginfo_imagecopymergegray, 0)
662 	ZEND_ARG_INFO(0, src_im)
663 	ZEND_ARG_INFO(0, dst_im)
664 	ZEND_ARG_INFO(0, dst_x)
665 	ZEND_ARG_INFO(0, dst_y)
666 	ZEND_ARG_INFO(0, src_x)
667 	ZEND_ARG_INFO(0, src_y)
668 	ZEND_ARG_INFO(0, src_w)
669 	ZEND_ARG_INFO(0, src_h)
670 	ZEND_ARG_INFO(0, pct)
671 ZEND_END_ARG_INFO()
672 
673 ZEND_BEGIN_ARG_INFO(arginfo_imagecopyresized, 0)
674 	ZEND_ARG_INFO(0, dst_im)
675 	ZEND_ARG_INFO(0, src_im)
676 	ZEND_ARG_INFO(0, dst_x)
677 	ZEND_ARG_INFO(0, dst_y)
678 	ZEND_ARG_INFO(0, src_x)
679 	ZEND_ARG_INFO(0, src_y)
680 	ZEND_ARG_INFO(0, dst_w)
681 	ZEND_ARG_INFO(0, dst_h)
682 	ZEND_ARG_INFO(0, src_w)
683 	ZEND_ARG_INFO(0, src_h)
684 ZEND_END_ARG_INFO()
685 
686 ZEND_BEGIN_ARG_INFO(arginfo_imagesx, 0)
687 	ZEND_ARG_INFO(0, im)
688 ZEND_END_ARG_INFO()
689 
690 ZEND_BEGIN_ARG_INFO(arginfo_imagesy, 0)
691 	ZEND_ARG_INFO(0, im)
692 ZEND_END_ARG_INFO()
693 
694 #ifdef ENABLE_GD_TTF
695 #if HAVE_LIBFREETYPE
696 ZEND_BEGIN_ARG_INFO_EX(arginfo_imageftbbox, 0, 0, 4)
697 	ZEND_ARG_INFO(0, size)
698 	ZEND_ARG_INFO(0, angle)
699 	ZEND_ARG_INFO(0, font_file)
700 	ZEND_ARG_INFO(0, text)
701 	ZEND_ARG_INFO(0, extrainfo) /* ARRAY_INFO(0, extrainfo, 0) */
702 ZEND_END_ARG_INFO()
703 
704 ZEND_BEGIN_ARG_INFO_EX(arginfo_imagefttext, 0, 0, 8)
705 	ZEND_ARG_INFO(0, im)
706 	ZEND_ARG_INFO(0, size)
707 	ZEND_ARG_INFO(0, angle)
708 	ZEND_ARG_INFO(0, x)
709 	ZEND_ARG_INFO(0, y)
710 	ZEND_ARG_INFO(0, col)
711 	ZEND_ARG_INFO(0, font_file)
712 	ZEND_ARG_INFO(0, text)
713 	ZEND_ARG_INFO(0, extrainfo) /* ARRAY_INFO(0, extrainfo, 0) */
714 ZEND_END_ARG_INFO()
715 #endif
716 
717 ZEND_BEGIN_ARG_INFO(arginfo_imagettfbbox, 0)
718 	ZEND_ARG_INFO(0, size)
719 	ZEND_ARG_INFO(0, angle)
720 	ZEND_ARG_INFO(0, font_file)
721 	ZEND_ARG_INFO(0, text)
722 ZEND_END_ARG_INFO()
723 
724 ZEND_BEGIN_ARG_INFO(arginfo_imagettftext, 0)
725 	ZEND_ARG_INFO(0, im)
726 	ZEND_ARG_INFO(0, size)
727 	ZEND_ARG_INFO(0, angle)
728 	ZEND_ARG_INFO(0, x)
729 	ZEND_ARG_INFO(0, y)
730 	ZEND_ARG_INFO(0, col)
731 	ZEND_ARG_INFO(0, font_file)
732 	ZEND_ARG_INFO(0, text)
733 ZEND_END_ARG_INFO()
734 #endif
735 
736 #ifdef HAVE_LIBT1
737 ZEND_BEGIN_ARG_INFO(arginfo_imagepsloadfont, 0)
738 	ZEND_ARG_INFO(0, pathname)
739 ZEND_END_ARG_INFO()
740 
741 /*
742 ZEND_BEGIN_ARG_INFO(arginfo_imagepscopyfont, 0)
743 	ZEND_ARG_INFO(0, font_index)
744 ZEND_END_ARG_INFO()
745 */
746 
747 ZEND_BEGIN_ARG_INFO(arginfo_imagepsfreefont, 0)
748 	ZEND_ARG_INFO(0, font_index)
749 ZEND_END_ARG_INFO()
750 
751 ZEND_BEGIN_ARG_INFO(arginfo_imagepsencodefont, 0)
752 	ZEND_ARG_INFO(0, font_index)
753 	ZEND_ARG_INFO(0, filename)
754 ZEND_END_ARG_INFO()
755 
756 ZEND_BEGIN_ARG_INFO(arginfo_imagepsextendfont, 0)
757 	ZEND_ARG_INFO(0, font_index)
758 	ZEND_ARG_INFO(0, extend)
759 ZEND_END_ARG_INFO()
760 
761 ZEND_BEGIN_ARG_INFO(arginfo_imagepsslantfont, 0)
762 	ZEND_ARG_INFO(0, font_index)
763 	ZEND_ARG_INFO(0, slant)
764 ZEND_END_ARG_INFO()
765 
766 ZEND_BEGIN_ARG_INFO_EX(arginfo_imagepstext, 0, 0, 8)
767 	ZEND_ARG_INFO(0, im)
768 	ZEND_ARG_INFO(0, text)
769 	ZEND_ARG_INFO(0, font)
770 	ZEND_ARG_INFO(0, size)
771 	ZEND_ARG_INFO(0, foreground)
772 	ZEND_ARG_INFO(0, background)
773 	ZEND_ARG_INFO(0, xcoord)
774 	ZEND_ARG_INFO(0, ycoord)
775 	ZEND_ARG_INFO(0, space)
776 	ZEND_ARG_INFO(0, tightness)
777 	ZEND_ARG_INFO(0, angle)
778 	ZEND_ARG_INFO(0, antialias)
779 ZEND_END_ARG_INFO()
780 
781 ZEND_BEGIN_ARG_INFO_EX(arginfo_imagepsbbox, 0, 0, 3)
782 	ZEND_ARG_INFO(0, text)
783 	ZEND_ARG_INFO(0, font)
784 	ZEND_ARG_INFO(0, size)
785 	ZEND_ARG_INFO(0, space)
786 	ZEND_ARG_INFO(0, tightness)
787 	ZEND_ARG_INFO(0, angle)
788 ZEND_END_ARG_INFO()
789 #endif
790 
791 ZEND_BEGIN_ARG_INFO_EX(arginfo_image2wbmp, 0, 0, 1)
792 	ZEND_ARG_INFO(0, im)
793 	ZEND_ARG_INFO(0, filename)
794 	ZEND_ARG_INFO(0, threshold)
795 ZEND_END_ARG_INFO()
796 
797 #if defined(HAVE_GD_JPG)
798 ZEND_BEGIN_ARG_INFO(arginfo_jpeg2wbmp, 0)
799 	ZEND_ARG_INFO(0, f_org)
800 	ZEND_ARG_INFO(0, f_dest)
801 	ZEND_ARG_INFO(0, d_height)
802 	ZEND_ARG_INFO(0, d_width)
803 	ZEND_ARG_INFO(0, d_threshold)
804 ZEND_END_ARG_INFO()
805 #endif
806 
807 #if defined(HAVE_GD_PNG)
808 ZEND_BEGIN_ARG_INFO(arginfo_png2wbmp, 0)
809 	ZEND_ARG_INFO(0, f_org)
810 	ZEND_ARG_INFO(0, f_dest)
811 	ZEND_ARG_INFO(0, d_height)
812 	ZEND_ARG_INFO(0, d_width)
813 	ZEND_ARG_INFO(0, d_threshold)
814 ZEND_END_ARG_INFO()
815 #endif
816 
817 ZEND_BEGIN_ARG_INFO_EX(arginfo_imagefilter, 0, 0, 2)
818 	ZEND_ARG_INFO(0, im)
819 	ZEND_ARG_INFO(0, filtertype)
820 	ZEND_ARG_INFO(0, arg1)
821 	ZEND_ARG_INFO(0, arg2)
822 	ZEND_ARG_INFO(0, arg3)
823 	ZEND_ARG_INFO(0, arg4)
824 ZEND_END_ARG_INFO()
825 
826 ZEND_BEGIN_ARG_INFO(arginfo_imageconvolution, 0)
827 	ZEND_ARG_INFO(0, im)
828 	ZEND_ARG_INFO(0, matrix3x3) /* ARRAY_INFO(0, matrix3x3, 0) */
829 	ZEND_ARG_INFO(0, div)
830 	ZEND_ARG_INFO(0, offset)
831 ZEND_END_ARG_INFO()
832 
833 ZEND_BEGIN_ARG_INFO(arginfo_imageflip, 0)
834 	ZEND_ARG_INFO(0, im)
835 	ZEND_ARG_INFO(0, mode)
836 ZEND_END_ARG_INFO()
837 
838 #ifdef HAVE_GD_BUNDLED
839 ZEND_BEGIN_ARG_INFO(arginfo_imageantialias, 0)
840 	ZEND_ARG_INFO(0, im)
841 	ZEND_ARG_INFO(0, on)
842 ZEND_END_ARG_INFO()
843 #endif
844 
845 ZEND_BEGIN_ARG_INFO(arginfo_imagecrop, 0)
846 	ZEND_ARG_INFO(0, im)
847 	ZEND_ARG_INFO(0, rect)
848 ZEND_END_ARG_INFO()
849 
850 ZEND_BEGIN_ARG_INFO_EX(arginfo_imagecropauto, 0, 0, 1)
851 	ZEND_ARG_INFO(0, im)
852 	ZEND_ARG_INFO(0, mode)
853 	ZEND_ARG_INFO(0, threshold)
854 	ZEND_ARG_INFO(0, color)
855 ZEND_END_ARG_INFO()
856 
857 ZEND_BEGIN_ARG_INFO_EX(arginfo_imagescale, 0, 0, 2)
858 	ZEND_ARG_INFO(0, im)
859 	ZEND_ARG_INFO(0, new_width)
860 	ZEND_ARG_INFO(0, new_height)
861 	ZEND_ARG_INFO(0, mode)
862 ZEND_END_ARG_INFO()
863 
864 ZEND_BEGIN_ARG_INFO_EX(arginfo_imageaffine, 0, 0, 2)
865 	ZEND_ARG_INFO(0, im)
866 	ZEND_ARG_INFO(0, affine)
867 	ZEND_ARG_INFO(0, clip)
868 ZEND_END_ARG_INFO()
869 
870 ZEND_BEGIN_ARG_INFO_EX(arginfo_imageaffinematrixget, 0, 0, 1)
871 	ZEND_ARG_INFO(0, type)
872 	ZEND_ARG_INFO(0, options)
873 ZEND_END_ARG_INFO()
874 
875 ZEND_BEGIN_ARG_INFO(arginfo_imageaffinematrixconcat, 0)
876 	ZEND_ARG_INFO(0, m1)
877 	ZEND_ARG_INFO(0, m2)
878 ZEND_END_ARG_INFO()
879 
880 ZEND_BEGIN_ARG_INFO(arginfo_imagesetinterpolation, 0)
881 	ZEND_ARG_INFO(0, im)
882 	ZEND_ARG_INFO(0, method)
883 ZEND_END_ARG_INFO()
884 
885 /* }}} */
886 
887 /* {{{ gd_functions[]
888  */
889 const zend_function_entry gd_functions[] = {
890 	PHP_FE(gd_info,                                 arginfo_gd_info)
891 	PHP_FE(imagearc,								arginfo_imagearc)
892 	PHP_FE(imageellipse,							arginfo_imageellipse)
893 	PHP_FE(imagechar,								arginfo_imagechar)
894 	PHP_FE(imagecharup,								arginfo_imagecharup)
895 	PHP_FE(imagecolorat,							arginfo_imagecolorat)
896 	PHP_FE(imagecolorallocate,						arginfo_imagecolorallocate)
897 	PHP_FE(imagepalettecopy,						arginfo_imagepalettecopy)
898 	PHP_FE(imagecreatefromstring,					arginfo_imagecreatefromstring)
899 	PHP_FE(imagecolorclosest,						arginfo_imagecolorclosest)
900 	PHP_FE(imagecolorclosesthwb,					arginfo_imagecolorclosesthwb)
901 	PHP_FE(imagecolordeallocate,					arginfo_imagecolordeallocate)
902 	PHP_FE(imagecolorresolve,						arginfo_imagecolorresolve)
903 	PHP_FE(imagecolorexact,							arginfo_imagecolorexact)
904 	PHP_FE(imagecolorset,							arginfo_imagecolorset)
905 	PHP_FE(imagecolortransparent,					arginfo_imagecolortransparent)
906 	PHP_FE(imagecolorstotal,						arginfo_imagecolorstotal)
907 	PHP_FE(imagecolorsforindex,						arginfo_imagecolorsforindex)
908 	PHP_FE(imagecopy,								arginfo_imagecopy)
909 	PHP_FE(imagecopymerge,							arginfo_imagecopymerge)
910 	PHP_FE(imagecopymergegray,						arginfo_imagecopymergegray)
911 	PHP_FE(imagecopyresized,						arginfo_imagecopyresized)
912 	PHP_FE(imagecreate,								arginfo_imagecreate)
913 	PHP_FE(imagecreatetruecolor,					arginfo_imagecreatetruecolor)
914 	PHP_FE(imageistruecolor,						arginfo_imageistruecolor)
915 	PHP_FE(imagetruecolortopalette,					arginfo_imagetruecolortopalette)
916 	PHP_FE(imagepalettetotruecolor,					arginfo_imagepalettetotruecolor)
917 	PHP_FE(imagesetthickness,						arginfo_imagesetthickness)
918 	PHP_FE(imagefilledarc,							arginfo_imagefilledarc)
919 	PHP_FE(imagefilledellipse,						arginfo_imagefilledellipse)
920 	PHP_FE(imagealphablending,						arginfo_imagealphablending)
921 	PHP_FE(imagesavealpha,							arginfo_imagesavealpha)
922 	PHP_FE(imagecolorallocatealpha,					arginfo_imagecolorallocatealpha)
923 	PHP_FE(imagecolorresolvealpha, 					arginfo_imagecolorresolvealpha)
924 	PHP_FE(imagecolorclosestalpha,					arginfo_imagecolorclosestalpha)
925 	PHP_FE(imagecolorexactalpha,					arginfo_imagecolorexactalpha)
926 	PHP_FE(imagecopyresampled,						arginfo_imagecopyresampled)
927 
928 #ifdef PHP_WIN32
929 	PHP_FE(imagegrabwindow,							arginfo_imagegrabwindow)
930 	PHP_FE(imagegrabscreen,							arginfo_imagegrabscreen)
931 #endif
932 
933 	PHP_FE(imagerotate,     						arginfo_imagerotate)
934 	PHP_FE(imageflip,								arginfo_imageflip)
935 
936 #ifdef HAVE_GD_BUNDLED
937 	PHP_FE(imageantialias,							arginfo_imageantialias)
938 #endif
939 	PHP_FE(imagecrop,								arginfo_imagecrop)
940 	PHP_FE(imagecropauto,							arginfo_imagecropauto)
941 	PHP_FE(imagescale,								arginfo_imagescale)
942 	PHP_FE(imageaffine,								arginfo_imageaffine)
943 	PHP_FE(imageaffinematrixconcat,					arginfo_imageaffinematrixconcat)
944 	PHP_FE(imageaffinematrixget,					arginfo_imageaffinematrixget)
945 	PHP_FE(imagesetinterpolation,                   arginfo_imagesetinterpolation)
946 	PHP_FE(imagesettile,							arginfo_imagesettile)
947 	PHP_FE(imagesetbrush,							arginfo_imagesetbrush)
948 	PHP_FE(imagesetstyle,							arginfo_imagesetstyle)
949 
950 #ifdef HAVE_GD_PNG
951 	PHP_FE(imagecreatefrompng,						arginfo_imagecreatefrompng)
952 #endif
953 #ifdef HAVE_GD_WEBP
954 	PHP_FE(imagecreatefromwebp,						arginfo_imagecreatefromwebp)
955 #endif
956 	PHP_FE(imagecreatefromgif,						arginfo_imagecreatefromgif)
957 #ifdef HAVE_GD_JPG
958 	PHP_FE(imagecreatefromjpeg,						arginfo_imagecreatefromjpeg)
959 #endif
960 	PHP_FE(imagecreatefromwbmp,						arginfo_imagecreatefromwbmp)
961 	PHP_FE(imagecreatefromxbm,						arginfo_imagecreatefromxbm)
962 #if defined(HAVE_GD_XPM)
963 	PHP_FE(imagecreatefromxpm,						arginfo_imagecreatefromxpm)
964 #endif
965 	PHP_FE(imagecreatefromgd,						arginfo_imagecreatefromgd)
966 	PHP_FE(imagecreatefromgd2,						arginfo_imagecreatefromgd2)
967 	PHP_FE(imagecreatefromgd2part,					arginfo_imagecreatefromgd2part)
968 #ifdef HAVE_GD_PNG
969 	PHP_FE(imagepng,								arginfo_imagepng)
970 #endif
971 #ifdef HAVE_GD_WEBP
972 	PHP_FE(imagewebp,								arginfo_imagewebp)
973 #endif
974 	PHP_FE(imagegif,								arginfo_imagegif)
975 #ifdef HAVE_GD_JPG
976 	PHP_FE(imagejpeg,								arginfo_imagejpeg)
977 #endif
978 	PHP_FE(imagewbmp,                               arginfo_imagewbmp)
979 	PHP_FE(imagegd,									arginfo_imagegd)
980 	PHP_FE(imagegd2,								arginfo_imagegd2)
981 
982 	PHP_FE(imagedestroy,							arginfo_imagedestroy)
983 	PHP_FE(imagegammacorrect,						arginfo_imagegammacorrect)
984 	PHP_FE(imagefill,								arginfo_imagefill)
985 	PHP_FE(imagefilledpolygon,						arginfo_imagefilledpolygon)
986 	PHP_FE(imagefilledrectangle,					arginfo_imagefilledrectangle)
987 	PHP_FE(imagefilltoborder,						arginfo_imagefilltoborder)
988 	PHP_FE(imagefontwidth,							arginfo_imagefontwidth)
989 	PHP_FE(imagefontheight,							arginfo_imagefontheight)
990 	PHP_FE(imageinterlace,							arginfo_imageinterlace)
991 	PHP_FE(imageline,								arginfo_imageline)
992 	PHP_FE(imageloadfont,							arginfo_imageloadfont)
993 	PHP_FE(imagepolygon,							arginfo_imagepolygon)
994 	PHP_FE(imagerectangle,							arginfo_imagerectangle)
995 	PHP_FE(imagesetpixel,							arginfo_imagesetpixel)
996 	PHP_FE(imagestring,								arginfo_imagestring)
997 	PHP_FE(imagestringup,							arginfo_imagestringup)
998 	PHP_FE(imagesx,									arginfo_imagesx)
999 	PHP_FE(imagesy,									arginfo_imagesy)
1000 	PHP_FE(imagedashedline,							arginfo_imagedashedline)
1001 
1002 #ifdef ENABLE_GD_TTF
1003 	PHP_FE(imagettfbbox,							arginfo_imagettfbbox)
1004 	PHP_FE(imagettftext,							arginfo_imagettftext)
1005 #if HAVE_GD_FREETYPE && HAVE_LIBFREETYPE
1006 	PHP_FE(imageftbbox,								arginfo_imageftbbox)
1007 	PHP_FE(imagefttext,								arginfo_imagefttext)
1008 #endif
1009 #endif
1010 
1011 #ifdef HAVE_LIBT1
1012 	PHP_FE(imagepsloadfont,							arginfo_imagepsloadfont)
1013 	/*
1014 	PHP_FE(imagepscopyfont,							arginfo_imagepscopyfont)
1015 	*/
1016 	PHP_FE(imagepsfreefont,							arginfo_imagepsfreefont)
1017 	PHP_FE(imagepsencodefont,						arginfo_imagepsencodefont)
1018 	PHP_FE(imagepsextendfont,						arginfo_imagepsextendfont)
1019 	PHP_FE(imagepsslantfont,						arginfo_imagepsslantfont)
1020 	PHP_FE(imagepstext,								arginfo_imagepstext)
1021 	PHP_FE(imagepsbbox,								arginfo_imagepsbbox)
1022 #endif
1023 	PHP_FE(imagetypes,								arginfo_imagetypes)
1024 
1025 #if defined(HAVE_GD_JPG)
1026 	PHP_FE(jpeg2wbmp,								arginfo_jpeg2wbmp)
1027 #endif
1028 #if defined(HAVE_GD_PNG)
1029 	PHP_FE(png2wbmp,								arginfo_png2wbmp)
1030 #endif
1031 	PHP_FE(image2wbmp,								arginfo_image2wbmp)
1032 	PHP_FE(imagelayereffect,						arginfo_imagelayereffect)
1033 	PHP_FE(imagexbm,                                arginfo_imagexbm)
1034 
1035 	PHP_FE(imagecolormatch,							arginfo_imagecolormatch)
1036 
1037 /* gd filters */
1038 	PHP_FE(imagefilter,     						arginfo_imagefilter)
1039 	PHP_FE(imageconvolution,						arginfo_imageconvolution)
1040 
1041 	PHP_FE_END
1042 };
1043 /* }}} */
1044 
1045 zend_module_entry gd_module_entry = {
1046 	STANDARD_MODULE_HEADER,
1047 	"gd",
1048 	gd_functions,
1049 	PHP_MINIT(gd),
1050 #if HAVE_LIBT1
1051 	PHP_MSHUTDOWN(gd),
1052 #else
1053 	NULL,
1054 #endif
1055 	NULL,
1056 #if HAVE_GD_FREETYPE && HAVE_LIBFREETYPE
1057 	PHP_RSHUTDOWN(gd),
1058 #else
1059 	NULL,
1060 #endif
1061 	PHP_MINFO(gd),
1062 	NO_VERSION_YET,
1063 	STANDARD_MODULE_PROPERTIES
1064 };
1065 
1066 #ifdef COMPILE_DL_GD
1067 ZEND_GET_MODULE(gd)
1068 #endif
1069 
1070 /* {{{ PHP_INI_BEGIN */
PHP_INI_BEGIN()1071 PHP_INI_BEGIN()
1072 	PHP_INI_ENTRY("gd.jpeg_ignore_warning", "0", PHP_INI_ALL, NULL)
1073 PHP_INI_END()
1074 /* }}} */
1075 
1076 /* {{{ php_free_gd_image
1077  */
1078 static void php_free_gd_image(zend_rsrc_list_entry *rsrc TSRMLS_DC)
1079 {
1080 	gdImageDestroy((gdImagePtr) rsrc->ptr);
1081 }
1082 /* }}} */
1083 
1084 /* {{{ php_free_gd_font
1085  */
php_free_gd_font(zend_rsrc_list_entry * rsrc TSRMLS_DC)1086 static void php_free_gd_font(zend_rsrc_list_entry *rsrc TSRMLS_DC)
1087 {
1088 	gdFontPtr fp = (gdFontPtr) rsrc->ptr;
1089 
1090 	if (fp->data) {
1091 		efree(fp->data);
1092 	}
1093 
1094 	efree(fp);
1095 }
1096 /* }}} */
1097 
1098 #ifndef HAVE_GD_BUNDLED
1099 /* {{{ php_gd_error_method
1100  */
php_gd_error_method(int type,const char * format,va_list args)1101 void php_gd_error_method(int type, const char *format, va_list args)
1102 {
1103 	TSRMLS_FETCH();
1104 
1105 	switch (type) {
1106 		case GD_DEBUG:
1107 		case GD_INFO:
1108 		case GD_NOTICE:
1109 			type = E_NOTICE;
1110 			break;
1111 		case GD_WARNING:
1112 			type = E_WARNING;
1113 			break;
1114 		default:
1115 			type = E_ERROR;
1116 	}
1117 	php_verror(NULL, "", type, format, args TSRMLS_CC);
1118 }
1119 /* }}} */
1120 #endif
1121 
1122 /* {{{ PHP_MSHUTDOWN_FUNCTION
1123  */
1124 #if HAVE_LIBT1
PHP_MSHUTDOWN_FUNCTION(gd)1125 PHP_MSHUTDOWN_FUNCTION(gd)
1126 {
1127 	T1_CloseLib();
1128 #if HAVE_GD_BUNDLED && HAVE_LIBFREETYPE
1129 	gdFontCacheMutexShutdown();
1130 #endif
1131 	UNREGISTER_INI_ENTRIES();
1132 	return SUCCESS;
1133 }
1134 #endif
1135 /* }}} */
1136 
1137 
1138 /* {{{ PHP_MINIT_FUNCTION
1139  */
PHP_MINIT_FUNCTION(gd)1140 PHP_MINIT_FUNCTION(gd)
1141 {
1142 	le_gd = zend_register_list_destructors_ex(php_free_gd_image, NULL, "gd", module_number);
1143 	le_gd_font = zend_register_list_destructors_ex(php_free_gd_font, NULL, "gd font", module_number);
1144 
1145 #if HAVE_GD_BUNDLED && HAVE_LIBFREETYPE
1146 	gdFontCacheMutexSetup();
1147 #endif
1148 #if HAVE_LIBT1
1149 	T1_SetBitmapPad(8);
1150 	T1_InitLib(NO_LOGFILE | IGNORE_CONFIGFILE | IGNORE_FONTDATABASE);
1151 	T1_SetLogLevel(T1LOG_DEBUG);
1152 	le_ps_font = zend_register_list_destructors_ex(php_free_ps_font, NULL, "gd PS font", module_number);
1153 	le_ps_enc = zend_register_list_destructors_ex(php_free_ps_enc, NULL, "gd PS encoding", module_number);
1154 #endif
1155 #ifndef HAVE_GD_BUNDLED
1156 	gdSetErrorMethod(php_gd_error_method);
1157 #endif
1158 	REGISTER_INI_ENTRIES();
1159 
1160 	REGISTER_LONG_CONSTANT("IMG_GIF", 1, CONST_CS | CONST_PERSISTENT);
1161 	REGISTER_LONG_CONSTANT("IMG_JPG", 2, CONST_CS | CONST_PERSISTENT);
1162 	REGISTER_LONG_CONSTANT("IMG_JPEG", 2, CONST_CS | CONST_PERSISTENT);
1163 	REGISTER_LONG_CONSTANT("IMG_PNG", 4, CONST_CS | CONST_PERSISTENT);
1164 	REGISTER_LONG_CONSTANT("IMG_WBMP", 8, CONST_CS | CONST_PERSISTENT);
1165 	REGISTER_LONG_CONSTANT("IMG_XPM", 16, CONST_CS | CONST_PERSISTENT);
1166 	REGISTER_LONG_CONSTANT("IMG_WEBP", 32, CONST_CS | CONST_PERSISTENT);
1167 
1168 	/* special colours for gd */
1169 	REGISTER_LONG_CONSTANT("IMG_COLOR_TILED", gdTiled, CONST_CS | CONST_PERSISTENT);
1170 	REGISTER_LONG_CONSTANT("IMG_COLOR_STYLED", gdStyled, CONST_CS | CONST_PERSISTENT);
1171 	REGISTER_LONG_CONSTANT("IMG_COLOR_BRUSHED", gdBrushed, CONST_CS | CONST_PERSISTENT);
1172 	REGISTER_LONG_CONSTANT("IMG_COLOR_STYLEDBRUSHED", gdStyledBrushed, CONST_CS | CONST_PERSISTENT);
1173 	REGISTER_LONG_CONSTANT("IMG_COLOR_TRANSPARENT", gdTransparent, CONST_CS | CONST_PERSISTENT);
1174 
1175 	/* for imagefilledarc */
1176 	REGISTER_LONG_CONSTANT("IMG_ARC_ROUNDED", gdArc, CONST_CS | CONST_PERSISTENT);
1177 	REGISTER_LONG_CONSTANT("IMG_ARC_PIE", gdPie, CONST_CS | CONST_PERSISTENT);
1178 	REGISTER_LONG_CONSTANT("IMG_ARC_CHORD", gdChord, CONST_CS | CONST_PERSISTENT);
1179 	REGISTER_LONG_CONSTANT("IMG_ARC_NOFILL", gdNoFill, CONST_CS | CONST_PERSISTENT);
1180 	REGISTER_LONG_CONSTANT("IMG_ARC_EDGED", gdEdged, CONST_CS | CONST_PERSISTENT);
1181 
1182     /* GD2 image format types */
1183 	REGISTER_LONG_CONSTANT("IMG_GD2_RAW", GD2_FMT_RAW, CONST_CS | CONST_PERSISTENT);
1184 	REGISTER_LONG_CONSTANT("IMG_GD2_COMPRESSED", GD2_FMT_COMPRESSED, CONST_CS | CONST_PERSISTENT);
1185 	REGISTER_LONG_CONSTANT("IMG_FLIP_HORIZONTAL", GD_FLIP_HORINZONTAL, CONST_CS | CONST_PERSISTENT);
1186 	REGISTER_LONG_CONSTANT("IMG_FLIP_VERTICAL", GD_FLIP_VERTICAL, CONST_CS | CONST_PERSISTENT);
1187 	REGISTER_LONG_CONSTANT("IMG_FLIP_BOTH", GD_FLIP_BOTH, CONST_CS | CONST_PERSISTENT);
1188 	REGISTER_LONG_CONSTANT("IMG_EFFECT_REPLACE", gdEffectReplace, CONST_CS | CONST_PERSISTENT);
1189 	REGISTER_LONG_CONSTANT("IMG_EFFECT_ALPHABLEND", gdEffectAlphaBlend, CONST_CS | CONST_PERSISTENT);
1190 	REGISTER_LONG_CONSTANT("IMG_EFFECT_NORMAL", gdEffectNormal, CONST_CS | CONST_PERSISTENT);
1191 	REGISTER_LONG_CONSTANT("IMG_EFFECT_OVERLAY", gdEffectOverlay, CONST_CS | CONST_PERSISTENT);
1192 
1193 	REGISTER_LONG_CONSTANT("IMG_CROP_DEFAULT", GD_CROP_DEFAULT, CONST_CS | CONST_PERSISTENT);
1194 	REGISTER_LONG_CONSTANT("IMG_CROP_TRANSPARENT", GD_CROP_TRANSPARENT, CONST_CS | CONST_PERSISTENT);
1195 	REGISTER_LONG_CONSTANT("IMG_CROP_BLACK", GD_CROP_BLACK, CONST_CS | CONST_PERSISTENT);
1196 	REGISTER_LONG_CONSTANT("IMG_CROP_WHITE", GD_CROP_WHITE, CONST_CS | CONST_PERSISTENT);
1197 	REGISTER_LONG_CONSTANT("IMG_CROP_SIDES", GD_CROP_SIDES, CONST_CS | CONST_PERSISTENT);
1198 	REGISTER_LONG_CONSTANT("IMG_CROP_THRESHOLD", GD_CROP_THRESHOLD, CONST_CS | CONST_PERSISTENT);
1199 
1200 
1201 	REGISTER_LONG_CONSTANT("IMG_BELL", GD_BELL, CONST_CS | CONST_PERSISTENT);
1202 	REGISTER_LONG_CONSTANT("IMG_BESSEL", GD_BESSEL, CONST_CS | CONST_PERSISTENT);
1203 	REGISTER_LONG_CONSTANT("IMG_BILINEAR_FIXED", GD_BILINEAR_FIXED, CONST_CS | CONST_PERSISTENT);
1204 	REGISTER_LONG_CONSTANT("IMG_BICUBIC", GD_BICUBIC, CONST_CS | CONST_PERSISTENT);
1205 	REGISTER_LONG_CONSTANT("IMG_BICUBIC_FIXED", GD_BICUBIC_FIXED, CONST_CS | CONST_PERSISTENT);
1206 	REGISTER_LONG_CONSTANT("IMG_BLACKMAN", GD_BLACKMAN, CONST_CS | CONST_PERSISTENT);
1207 	REGISTER_LONG_CONSTANT("IMG_BOX", GD_BOX, CONST_CS | CONST_PERSISTENT);
1208 	REGISTER_LONG_CONSTANT("IMG_BSPLINE", GD_BSPLINE, CONST_CS | CONST_PERSISTENT);
1209 	REGISTER_LONG_CONSTANT("IMG_CATMULLROM", GD_CATMULLROM, CONST_CS | CONST_PERSISTENT);
1210 	REGISTER_LONG_CONSTANT("IMG_GAUSSIAN", GD_GAUSSIAN, CONST_CS | CONST_PERSISTENT);
1211 	REGISTER_LONG_CONSTANT("IMG_GENERALIZED_CUBIC", GD_GENERALIZED_CUBIC, CONST_CS | CONST_PERSISTENT);
1212 	REGISTER_LONG_CONSTANT("IMG_HERMITE", GD_HERMITE, CONST_CS | CONST_PERSISTENT);
1213 	REGISTER_LONG_CONSTANT("IMG_HAMMING", GD_HAMMING, CONST_CS | CONST_PERSISTENT);
1214 	REGISTER_LONG_CONSTANT("IMG_HANNING", GD_HANNING, CONST_CS | CONST_PERSISTENT);
1215 	REGISTER_LONG_CONSTANT("IMG_MITCHELL", GD_MITCHELL, CONST_CS | CONST_PERSISTENT);
1216 	REGISTER_LONG_CONSTANT("IMG_POWER", GD_POWER, CONST_CS | CONST_PERSISTENT);
1217 	REGISTER_LONG_CONSTANT("IMG_QUADRATIC", GD_QUADRATIC, CONST_CS | CONST_PERSISTENT);
1218 	REGISTER_LONG_CONSTANT("IMG_SINC", GD_SINC, CONST_CS | CONST_PERSISTENT);
1219 	REGISTER_LONG_CONSTANT("IMG_NEAREST_NEIGHBOUR", GD_NEAREST_NEIGHBOUR, CONST_CS | CONST_PERSISTENT);
1220 	REGISTER_LONG_CONSTANT("IMG_WEIGHTED4", GD_WEIGHTED4, CONST_CS | CONST_PERSISTENT);
1221 	REGISTER_LONG_CONSTANT("IMG_TRIANGLE", GD_TRIANGLE, CONST_CS | CONST_PERSISTENT);
1222 
1223 	REGISTER_LONG_CONSTANT("IMG_AFFINE_TRANSLATE", GD_AFFINE_TRANSLATE, CONST_CS | CONST_PERSISTENT);
1224 	REGISTER_LONG_CONSTANT("IMG_AFFINE_SCALE", GD_AFFINE_SCALE, CONST_CS | CONST_PERSISTENT);
1225 	REGISTER_LONG_CONSTANT("IMG_AFFINE_ROTATE", GD_AFFINE_ROTATE, CONST_CS | CONST_PERSISTENT);
1226 	REGISTER_LONG_CONSTANT("IMG_AFFINE_SHEAR_HORIZONTAL", GD_AFFINE_SHEAR_HORIZONTAL, CONST_CS | CONST_PERSISTENT);
1227 	REGISTER_LONG_CONSTANT("IMG_AFFINE_SHEAR_VERTICAL", GD_AFFINE_SHEAR_VERTICAL, CONST_CS | CONST_PERSISTENT);
1228 
1229 #if defined(HAVE_GD_BUNDLED)
1230 	REGISTER_LONG_CONSTANT("GD_BUNDLED", 1, CONST_CS | CONST_PERSISTENT);
1231 #else
1232 	REGISTER_LONG_CONSTANT("GD_BUNDLED", 0, CONST_CS | CONST_PERSISTENT);
1233 #endif
1234 
1235 	/* Section Filters */
1236 	REGISTER_LONG_CONSTANT("IMG_FILTER_NEGATE", IMAGE_FILTER_NEGATE, CONST_CS | CONST_PERSISTENT);
1237 	REGISTER_LONG_CONSTANT("IMG_FILTER_GRAYSCALE", IMAGE_FILTER_GRAYSCALE, CONST_CS | CONST_PERSISTENT);
1238 	REGISTER_LONG_CONSTANT("IMG_FILTER_BRIGHTNESS", IMAGE_FILTER_BRIGHTNESS, CONST_CS | CONST_PERSISTENT);
1239 	REGISTER_LONG_CONSTANT("IMG_FILTER_CONTRAST", IMAGE_FILTER_CONTRAST, CONST_CS | CONST_PERSISTENT);
1240 	REGISTER_LONG_CONSTANT("IMG_FILTER_COLORIZE", IMAGE_FILTER_COLORIZE, CONST_CS | CONST_PERSISTENT);
1241 	REGISTER_LONG_CONSTANT("IMG_FILTER_EDGEDETECT", IMAGE_FILTER_EDGEDETECT, CONST_CS | CONST_PERSISTENT);
1242 	REGISTER_LONG_CONSTANT("IMG_FILTER_GAUSSIAN_BLUR", IMAGE_FILTER_GAUSSIAN_BLUR, CONST_CS | CONST_PERSISTENT);
1243 	REGISTER_LONG_CONSTANT("IMG_FILTER_SELECTIVE_BLUR", IMAGE_FILTER_SELECTIVE_BLUR, CONST_CS | CONST_PERSISTENT);
1244 	REGISTER_LONG_CONSTANT("IMG_FILTER_EMBOSS", IMAGE_FILTER_EMBOSS, CONST_CS | CONST_PERSISTENT);
1245 	REGISTER_LONG_CONSTANT("IMG_FILTER_MEAN_REMOVAL", IMAGE_FILTER_MEAN_REMOVAL, CONST_CS | CONST_PERSISTENT);
1246 	REGISTER_LONG_CONSTANT("IMG_FILTER_SMOOTH", IMAGE_FILTER_SMOOTH, CONST_CS | CONST_PERSISTENT);
1247 	REGISTER_LONG_CONSTANT("IMG_FILTER_PIXELATE", IMAGE_FILTER_PIXELATE, CONST_CS | CONST_PERSISTENT);
1248 	/* End Section Filters */
1249 
1250 #ifdef GD_VERSION_STRING
1251 	REGISTER_STRING_CONSTANT("GD_VERSION", GD_VERSION_STRING, CONST_CS | CONST_PERSISTENT);
1252 #endif
1253 
1254 #if defined(GD_MAJOR_VERSION) && defined(GD_MINOR_VERSION) && defined(GD_RELEASE_VERSION) && defined(GD_EXTRA_VERSION)
1255 	REGISTER_LONG_CONSTANT("GD_MAJOR_VERSION", GD_MAJOR_VERSION, CONST_CS | CONST_PERSISTENT);
1256 	REGISTER_LONG_CONSTANT("GD_MINOR_VERSION", GD_MINOR_VERSION, CONST_CS | CONST_PERSISTENT);
1257 	REGISTER_LONG_CONSTANT("GD_RELEASE_VERSION", GD_RELEASE_VERSION, CONST_CS | CONST_PERSISTENT);
1258 	REGISTER_STRING_CONSTANT("GD_EXTRA_VERSION", GD_EXTRA_VERSION, CONST_CS | CONST_PERSISTENT);
1259 #endif
1260 
1261 
1262 #ifdef HAVE_GD_PNG
1263 
1264 	/*
1265 	 * cannot include #include "png.h"
1266 	 * /usr/include/pngconf.h:310:2: error: #error png.h already includes setjmp.h with some additional fixup.
1267 	 * as error, use the values for now...
1268 	 */
1269 	REGISTER_LONG_CONSTANT("PNG_NO_FILTER",	    0x00, CONST_CS | CONST_PERSISTENT);
1270 	REGISTER_LONG_CONSTANT("PNG_FILTER_NONE",   0x08, CONST_CS | CONST_PERSISTENT);
1271 	REGISTER_LONG_CONSTANT("PNG_FILTER_SUB",    0x10, CONST_CS | CONST_PERSISTENT);
1272 	REGISTER_LONG_CONSTANT("PNG_FILTER_UP",     0x20, CONST_CS | CONST_PERSISTENT);
1273 	REGISTER_LONG_CONSTANT("PNG_FILTER_AVG",    0x40, CONST_CS | CONST_PERSISTENT);
1274 	REGISTER_LONG_CONSTANT("PNG_FILTER_PAETH",  0x80, CONST_CS | CONST_PERSISTENT);
1275 	REGISTER_LONG_CONSTANT("PNG_ALL_FILTERS",   0x08 | 0x10 | 0x20 | 0x40 | 0x80, CONST_CS | CONST_PERSISTENT);
1276 #endif
1277 
1278 	return SUCCESS;
1279 }
1280 /* }}} */
1281 
1282 /* {{{ PHP_RSHUTDOWN_FUNCTION
1283  */
1284 #if HAVE_GD_FREETYPE && HAVE_LIBFREETYPE
PHP_RSHUTDOWN_FUNCTION(gd)1285 PHP_RSHUTDOWN_FUNCTION(gd)
1286 {
1287 	gdFontCacheShutdown();
1288 	return SUCCESS;
1289 }
1290 #endif
1291 /* }}} */
1292 
1293 #if defined(HAVE_GD_BUNDLED)
1294 #define PHP_GD_VERSION_STRING "bundled (2.1.0 compatible)"
1295 #else
1296 # define PHP_GD_VERSION_STRING GD_VERSION_STRING
1297 #endif
1298 
1299 /* {{{ PHP_MINFO_FUNCTION
1300  */
PHP_MINFO_FUNCTION(gd)1301 PHP_MINFO_FUNCTION(gd)
1302 {
1303 	php_info_print_table_start();
1304 	php_info_print_table_row(2, "GD Support", "enabled");
1305 
1306 	/* need to use a PHPAPI function here because it is external module in windows */
1307 
1308 #if defined(HAVE_GD_BUNDLED)
1309 	php_info_print_table_row(2, "GD Version", PHP_GD_VERSION_STRING);
1310 #else
1311 	php_info_print_table_row(2, "GD headers Version", PHP_GD_VERSION_STRING);
1312 #if defined(HAVE_GD_LIBVERSION)
1313 	php_info_print_table_row(2, "GD library Version", gdVersionString());
1314 #endif
1315 #endif
1316 
1317 #ifdef ENABLE_GD_TTF
1318 	php_info_print_table_row(2, "FreeType Support", "enabled");
1319 #if HAVE_LIBFREETYPE
1320 	php_info_print_table_row(2, "FreeType Linkage", "with freetype");
1321 	{
1322 		char tmp[256];
1323 
1324 #ifdef FREETYPE_PATCH
1325 		snprintf(tmp, sizeof(tmp), "%d.%d.%d", FREETYPE_MAJOR, FREETYPE_MINOR, FREETYPE_PATCH);
1326 #elif defined(FREETYPE_MAJOR)
1327 		snprintf(tmp, sizeof(tmp), "%d.%d", FREETYPE_MAJOR, FREETYPE_MINOR);
1328 #else
1329 		snprintf(tmp, sizeof(tmp), "1.x");
1330 #endif
1331 		php_info_print_table_row(2, "FreeType Version", tmp);
1332 	}
1333 #else
1334 	php_info_print_table_row(2, "FreeType Linkage", "with unknown library");
1335 #endif
1336 #endif
1337 
1338 #ifdef HAVE_LIBT1
1339 	php_info_print_table_row(2, "T1Lib Support", "enabled");
1340 #endif
1341 
1342 	php_info_print_table_row(2, "GIF Read Support", "enabled");
1343 	php_info_print_table_row(2, "GIF Create Support", "enabled");
1344 
1345 #ifdef HAVE_GD_JPG
1346 	{
1347 		php_info_print_table_row(2, "JPEG Support", "enabled");
1348 		php_info_print_table_row(2, "libJPEG Version", gdJpegGetVersionString());
1349 	}
1350 #endif
1351 
1352 #ifdef HAVE_GD_PNG
1353 	php_info_print_table_row(2, "PNG Support", "enabled");
1354 	php_info_print_table_row(2, "libPNG Version", gdPngGetVersionString());
1355 #endif
1356 	php_info_print_table_row(2, "WBMP Support", "enabled");
1357 #if defined(HAVE_GD_XPM)
1358 	php_info_print_table_row(2, "XPM Support", "enabled");
1359 	{
1360 		char tmp[12];
1361 		snprintf(tmp, sizeof(tmp), "%d", XpmLibraryVersion());
1362 		php_info_print_table_row(2, "libXpm Version", tmp);
1363 	}
1364 #endif
1365 	php_info_print_table_row(2, "XBM Support", "enabled");
1366 #if defined(USE_GD_JISX0208)
1367 	php_info_print_table_row(2, "JIS-mapped Japanese Font Support", "enabled");
1368 #endif
1369 #ifdef HAVE_GD_WEBP
1370 	php_info_print_table_row(2, "WebP Support", "enabled");
1371 #endif
1372 	php_info_print_table_end();
1373 	DISPLAY_INI_ENTRIES();
1374 }
1375 /* }}} */
1376 
1377 /* {{{ proto array gd_info()
1378  */
PHP_FUNCTION(gd_info)1379 PHP_FUNCTION(gd_info)
1380 {
1381 	if (zend_parse_parameters_none() == FAILURE) {
1382 		RETURN_FALSE;
1383 	}
1384 
1385 	array_init(return_value);
1386 
1387 	add_assoc_string(return_value, "GD Version", PHP_GD_VERSION_STRING, 1);
1388 
1389 #ifdef ENABLE_GD_TTF
1390 	add_assoc_bool(return_value, "FreeType Support", 1);
1391 #if HAVE_LIBFREETYPE
1392 	add_assoc_string(return_value, "FreeType Linkage", "with freetype", 1);
1393 #else
1394 	add_assoc_string(return_value, "FreeType Linkage", "with unknown library", 1);
1395 #endif
1396 #else
1397 	add_assoc_bool(return_value, "FreeType Support", 0);
1398 #endif
1399 
1400 #ifdef HAVE_LIBT1
1401 	add_assoc_bool(return_value, "T1Lib Support", 1);
1402 #else
1403 	add_assoc_bool(return_value, "T1Lib Support", 0);
1404 #endif
1405 	add_assoc_bool(return_value, "GIF Read Support", 1);
1406 	add_assoc_bool(return_value, "GIF Create Support", 1);
1407 #ifdef HAVE_GD_JPG
1408 	add_assoc_bool(return_value, "JPEG Support", 1);
1409 #else
1410 	add_assoc_bool(return_value, "JPEG Support", 0);
1411 #endif
1412 #ifdef HAVE_GD_PNG
1413 	add_assoc_bool(return_value, "PNG Support", 1);
1414 #else
1415 	add_assoc_bool(return_value, "PNG Support", 0);
1416 #endif
1417 	add_assoc_bool(return_value, "WBMP Support", 1);
1418 #if defined(HAVE_GD_XPM)
1419 	add_assoc_bool(return_value, "XPM Support", 1);
1420 #else
1421 	add_assoc_bool(return_value, "XPM Support", 0);
1422 #endif
1423 	add_assoc_bool(return_value, "XBM Support", 1);
1424 #ifdef HAVE_GD_WEBP
1425 	add_assoc_bool(return_value, "WebP Support", 1);
1426 #else
1427 	add_assoc_bool(return_value, "WebP Support", 0);
1428 #endif
1429 #if defined(USE_GD_JISX0208)
1430 	add_assoc_bool(return_value, "JIS-mapped Japanese Font Support", 1);
1431 #else
1432 	add_assoc_bool(return_value, "JIS-mapped Japanese Font Support", 0);
1433 #endif
1434 }
1435 /* }}} */
1436 
1437 /* Need this for cpdf. See also comment in file.c php3i_get_le_fp() */
phpi_get_le_gd(void)1438 PHP_GD_API int phpi_get_le_gd(void)
1439 {
1440 	return le_gd;
1441 }
1442 /* }}} */
1443 
1444 #define FLIPWORD(a) (((a & 0xff000000) >> 24) | ((a & 0x00ff0000) >> 8) | ((a & 0x0000ff00) << 8) | ((a & 0x000000ff) << 24))
1445 
1446 /* {{{ proto int imageloadfont(string filename)
1447    Load a new font */
PHP_FUNCTION(imageloadfont)1448 PHP_FUNCTION(imageloadfont)
1449 {
1450 	char *file;
1451 	int file_name, hdr_size = sizeof(gdFont) - sizeof(char *);
1452 	int ind, body_size, n = 0, b, i, body_size_check;
1453 	gdFontPtr font;
1454 	php_stream *stream;
1455 
1456 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "p", &file, &file_name) == FAILURE) {
1457 		return;
1458 	}
1459 
1460 	stream = php_stream_open_wrapper(file, "rb", IGNORE_PATH | IGNORE_URL_WIN | REPORT_ERRORS, NULL);
1461 	if (stream == NULL) {
1462 		RETURN_FALSE;
1463 	}
1464 
1465 	/* Only supports a architecture-dependent binary dump format
1466 	 * at the moment.
1467 	 * The file format is like this on machines with 32-byte integers:
1468 	 *
1469 	 * byte 0-3:   (int) number of characters in the font
1470 	 * byte 4-7:   (int) value of first character in the font (often 32, space)
1471 	 * byte 8-11:  (int) pixel width of each character
1472 	 * byte 12-15: (int) pixel height of each character
1473 	 * bytes 16-:  (char) array with character data, one byte per pixel
1474 	 *                    in each character, for a total of
1475 	 *                    (nchars*width*height) bytes.
1476 	 */
1477 	font = (gdFontPtr) emalloc(sizeof(gdFont));
1478 	b = 0;
1479 	while (b < hdr_size && (n = php_stream_read(stream, (char*)&font[b], hdr_size - b))) {
1480 		b += n;
1481 	}
1482 
1483 	if (!n) {
1484 		efree(font);
1485 		if (php_stream_eof(stream)) {
1486 			php_error_docref(NULL TSRMLS_CC, E_WARNING, "End of file while reading header");
1487 		} else {
1488 			php_error_docref(NULL TSRMLS_CC, E_WARNING, "Error while reading header");
1489 		}
1490 		php_stream_close(stream);
1491 		RETURN_FALSE;
1492 	}
1493 	i = php_stream_tell(stream);
1494 	php_stream_seek(stream, 0, SEEK_END);
1495 	body_size_check = php_stream_tell(stream) - hdr_size;
1496 	php_stream_seek(stream, i, SEEK_SET);
1497 
1498 	body_size = font->w * font->h * font->nchars;
1499 	if (body_size != body_size_check) {
1500 		font->w = FLIPWORD(font->w);
1501 		font->h = FLIPWORD(font->h);
1502 		font->nchars = FLIPWORD(font->nchars);
1503 		body_size = font->w * font->h * font->nchars;
1504 	}
1505 
1506 	if (overflow2(font->nchars, font->h) || overflow2(font->nchars * font->h, font->w )) {
1507 		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Error reading font, invalid font header");
1508 		efree(font);
1509 		php_stream_close(stream);
1510 		RETURN_FALSE;
1511 	}
1512 
1513 	if (body_size != body_size_check) {
1514 		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Error reading font");
1515 		efree(font);
1516 		php_stream_close(stream);
1517 		RETURN_FALSE;
1518 	}
1519 
1520 	font->data = emalloc(body_size);
1521 	b = 0;
1522 	while (b < body_size && (n = php_stream_read(stream, &font->data[b], body_size - b))) {
1523 		b += n;
1524 	}
1525 
1526 	if (!n) {
1527 		efree(font->data);
1528 		efree(font);
1529 		if (php_stream_eof(stream)) {
1530 			php_error_docref(NULL TSRMLS_CC, E_WARNING, "End of file while reading body");
1531 		} else {
1532 			php_error_docref(NULL TSRMLS_CC, E_WARNING, "Error while reading body");
1533 		}
1534 		php_stream_close(stream);
1535 		RETURN_FALSE;
1536 	}
1537 	php_stream_close(stream);
1538 
1539 	/* Adding 5 to the font index so we will never have font indices
1540 	 * that overlap with the old fonts (with indices 1-5).  The first
1541 	 * list index given out is always 1.
1542 	 */
1543 	ind = 5 + zend_list_insert(font, le_gd_font TSRMLS_CC);
1544 
1545 	RETURN_LONG(ind);
1546 }
1547 /* }}} */
1548 
1549 /* {{{ proto bool imagesetstyle(resource im, array styles)
1550    Set the line drawing styles for use with imageline and IMG_COLOR_STYLED. */
PHP_FUNCTION(imagesetstyle)1551 PHP_FUNCTION(imagesetstyle)
1552 {
1553 	zval *IM, *styles;
1554 	gdImagePtr im;
1555 	int * stylearr;
1556 	int index;
1557 	HashPosition pos;
1558     int num_styles;
1559 
1560 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ra", &IM, &styles) == FAILURE)  {
1561 		return;
1562 	}
1563 
1564 	ZEND_FETCH_RESOURCE(im, gdImagePtr, &IM, -1, "Image", le_gd);
1565 
1566     num_styles = zend_hash_num_elements(HASH_OF(styles));
1567     if (num_styles == 0) {
1568         php_error_docref(NULL TSRMLS_CC, E_WARNING, "styles array must not be empty");
1569         RETURN_FALSE;
1570     }
1571 
1572 	/* copy the style values in the stylearr */
1573 	stylearr = safe_emalloc(sizeof(int), num_styles, 0);
1574 
1575 	zend_hash_internal_pointer_reset_ex(HASH_OF(styles), &pos);
1576 
1577 	for (index = 0;; zend_hash_move_forward_ex(HASH_OF(styles), &pos))	{
1578 		zval ** item;
1579 
1580 		if (zend_hash_get_current_data_ex(HASH_OF(styles), (void **) &item, &pos) == FAILURE) {
1581 			break;
1582 		}
1583 
1584 		if (Z_TYPE_PP(item) != IS_LONG) {
1585 			zval lval;
1586 			lval = **item;
1587 			zval_copy_ctor(&lval);
1588 			convert_to_long(&lval);
1589 			stylearr[index++] = Z_LVAL(lval);
1590 		} else {
1591 			stylearr[index++] = Z_LVAL_PP(item);
1592 		}
1593 	}
1594 
1595 	gdImageSetStyle(im, stylearr, index);
1596 
1597 	efree(stylearr);
1598 
1599 	RETURN_TRUE;
1600 }
1601 /* }}} */
1602 
1603 /* {{{ proto resource imagecreatetruecolor(int x_size, int y_size)
1604    Create a new true color image */
PHP_FUNCTION(imagecreatetruecolor)1605 PHP_FUNCTION(imagecreatetruecolor)
1606 {
1607 	long x_size, y_size;
1608 	gdImagePtr im;
1609 
1610 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ll", &x_size, &y_size) == FAILURE) {
1611 		return;
1612 	}
1613 
1614 	if (x_size <= 0 || y_size <= 0 || x_size >= INT_MAX || y_size >= INT_MAX) {
1615 		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid image dimensions");
1616 		RETURN_FALSE;
1617 	}
1618 
1619 	im = gdImageCreateTrueColor(x_size, y_size);
1620 
1621 	if (!im) {
1622 		RETURN_FALSE;
1623 	}
1624 
1625 	ZEND_REGISTER_RESOURCE(return_value, im, le_gd);
1626 }
1627 /* }}} */
1628 
1629 /* {{{ proto bool imageistruecolor(resource im)
1630    return true if the image uses truecolor */
PHP_FUNCTION(imageistruecolor)1631 PHP_FUNCTION(imageistruecolor)
1632 {
1633 	zval *IM;
1634 	gdImagePtr im;
1635 
1636 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &IM) == FAILURE) {
1637 		return;
1638 	}
1639 
1640 	ZEND_FETCH_RESOURCE(im, gdImagePtr, &IM, -1, "Image", le_gd);
1641 
1642 	RETURN_BOOL(im->trueColor);
1643 }
1644 /* }}} */
1645 
1646 /* {{{ proto void imagetruecolortopalette(resource im, bool ditherFlag, int colorsWanted)
1647    Convert a true color image to a palette based image with a number of colors, optionally using dithering. */
PHP_FUNCTION(imagetruecolortopalette)1648 PHP_FUNCTION(imagetruecolortopalette)
1649 {
1650 	zval *IM;
1651 	zend_bool dither;
1652 	long ncolors;
1653 	gdImagePtr im;
1654 
1655 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rbl", &IM, &dither, &ncolors) == FAILURE)  {
1656 		return;
1657 	}
1658 
1659 	ZEND_FETCH_RESOURCE(im, gdImagePtr, &IM, -1, "Image", le_gd);
1660 
1661 	if (ncolors <= 0 || ncolors > INT_MAX) {
1662 		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Number of colors has to be greater than zero and no more than %d", INT_MAX);
1663 		RETURN_FALSE;
1664 	}
1665 	gdImageTrueColorToPalette(im, dither, (int)ncolors);
1666 
1667 	RETURN_TRUE;
1668 }
1669 /* }}} */
1670 
1671 
1672 
1673 /* {{{ proto void imagepalettetotruecolor(resource im)
1674    Convert a palette based image to a true color image. */
PHP_FUNCTION(imagepalettetotruecolor)1675 PHP_FUNCTION(imagepalettetotruecolor)
1676 {
1677 	zval *IM;
1678 	gdImagePtr im;
1679 
1680 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &IM) == FAILURE)  {
1681 		return;
1682 	}
1683 
1684 	ZEND_FETCH_RESOURCE(im, gdImagePtr, &IM, -1, "Image", le_gd);
1685 
1686 	if (gdImagePaletteToTrueColor(im) == 0) {
1687 		RETURN_FALSE;
1688 	}
1689 
1690 	RETURN_TRUE;
1691 }
1692 /* }}} */
1693 
1694 /* {{{ proto bool imagecolormatch(resource im1, resource im2)
1695    Makes the colors of the palette version of an image more closely match the true color version */
PHP_FUNCTION(imagecolormatch)1696 PHP_FUNCTION(imagecolormatch)
1697 {
1698 	zval *IM1, *IM2;
1699 	gdImagePtr im1, im2;
1700 	int result;
1701 
1702 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rr", &IM1, &IM2) == FAILURE) {
1703 		return;
1704 	}
1705 
1706 	ZEND_FETCH_RESOURCE(im1, gdImagePtr, &IM1, -1, "Image", le_gd);
1707 	ZEND_FETCH_RESOURCE(im2, gdImagePtr, &IM2, -1, "Image", le_gd);
1708 
1709 	result = gdImageColorMatch(im1, im2);
1710 	switch (result) {
1711 		case -1:
1712 			php_error_docref(NULL TSRMLS_CC, E_WARNING, "Image1 must be TrueColor" );
1713 			RETURN_FALSE;
1714 			break;
1715 		case -2:
1716 			php_error_docref(NULL TSRMLS_CC, E_WARNING, "Image2 must be Palette" );
1717 			RETURN_FALSE;
1718 			break;
1719 		case -3:
1720 			php_error_docref(NULL TSRMLS_CC, E_WARNING, "Image1 and Image2 must be the same size" );
1721 			RETURN_FALSE;
1722 			break;
1723 		case -4:
1724 			php_error_docref(NULL TSRMLS_CC, E_WARNING, "Image2 must have at least one color" );
1725 			RETURN_FALSE;
1726 			break;
1727 	}
1728 
1729 	RETURN_TRUE;
1730 }
1731 /* }}} */
1732 
1733 /* {{{ proto bool imagesetthickness(resource im, int thickness)
1734    Set line thickness for drawing lines, ellipses, rectangles, polygons etc. */
PHP_FUNCTION(imagesetthickness)1735 PHP_FUNCTION(imagesetthickness)
1736 {
1737 	zval *IM;
1738 	long thick;
1739 	gdImagePtr im;
1740 
1741 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rl", &IM, &thick) == FAILURE) {
1742 		return;
1743 	}
1744 
1745 	ZEND_FETCH_RESOURCE(im, gdImagePtr, &IM, -1, "Image", le_gd);
1746 
1747 	gdImageSetThickness(im, thick);
1748 
1749 	RETURN_TRUE;
1750 }
1751 /* }}} */
1752 
1753 /* {{{ proto bool imagefilledellipse(resource im, int cx, int cy, int w, int h, int color)
1754    Draw an ellipse */
PHP_FUNCTION(imagefilledellipse)1755 PHP_FUNCTION(imagefilledellipse)
1756 {
1757 	zval *IM;
1758 	long cx, cy, w, h, color;
1759 	gdImagePtr im;
1760 
1761 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rlllll", &IM, &cx, &cy, &w, &h, &color) == FAILURE) {
1762 		return;
1763 	}
1764 
1765 	ZEND_FETCH_RESOURCE(im, gdImagePtr, &IM, -1, "Image", le_gd);
1766 
1767 	gdImageFilledEllipse(im, cx, cy, w, h, color);
1768 
1769 	RETURN_TRUE;
1770 }
1771 /* }}} */
1772 
1773 /* {{{ proto bool imagefilledarc(resource im, int cx, int cy, int w, int h, int s, int e, int col, int style)
1774    Draw a filled partial ellipse */
PHP_FUNCTION(imagefilledarc)1775 PHP_FUNCTION(imagefilledarc)
1776 {
1777 	zval *IM;
1778 	long cx, cy, w, h, ST, E, col, style;
1779 	gdImagePtr im;
1780 	int e, st;
1781 
1782 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rllllllll", &IM, &cx, &cy, &w, &h, &ST, &E, &col, &style) == FAILURE) {
1783 		return;
1784 	}
1785 
1786 	ZEND_FETCH_RESOURCE(im, gdImagePtr, &IM, -1, "Image", le_gd);
1787 
1788 	e = E;
1789 	if (e < 0) {
1790 		e %= 360;
1791 	}
1792 
1793 	st = ST;
1794 	if (st < 0) {
1795 		st %= 360;
1796 	}
1797 
1798 	gdImageFilledArc(im, cx, cy, w, h, st, e, col, style);
1799 
1800 	RETURN_TRUE;
1801 }
1802 /* }}} */
1803 
1804 /* {{{ proto bool imagealphablending(resource im, bool on)
1805    Turn alpha blending mode on or off for the given image */
PHP_FUNCTION(imagealphablending)1806 PHP_FUNCTION(imagealphablending)
1807 {
1808 	zval *IM;
1809 	zend_bool blend;
1810 	gdImagePtr im;
1811 
1812 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rb", &IM, &blend) == FAILURE) {
1813 		return;
1814 	}
1815 
1816 	ZEND_FETCH_RESOURCE(im, gdImagePtr, &IM, -1, "Image", le_gd);
1817 	gdImageAlphaBlending(im, blend);
1818 
1819 	RETURN_TRUE;
1820 }
1821 /* }}} */
1822 
1823 /* {{{ proto bool imagesavealpha(resource im, bool on)
1824    Include alpha channel to a saved image */
PHP_FUNCTION(imagesavealpha)1825 PHP_FUNCTION(imagesavealpha)
1826 {
1827 	zval *IM;
1828 	zend_bool save;
1829 	gdImagePtr im;
1830 
1831 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rb", &IM, &save) == FAILURE) {
1832 		return;
1833 	}
1834 
1835 	ZEND_FETCH_RESOURCE(im, gdImagePtr, &IM, -1, "Image", le_gd);
1836 	gdImageSaveAlpha(im, save);
1837 
1838 	RETURN_TRUE;
1839 }
1840 /* }}} */
1841 
1842 /* {{{ proto bool imagelayereffect(resource im, int effect)
1843    Set the alpha blending flag to use the bundled libgd layering effects */
PHP_FUNCTION(imagelayereffect)1844 PHP_FUNCTION(imagelayereffect)
1845 {
1846 	zval *IM;
1847 	long effect;
1848 	gdImagePtr im;
1849 
1850 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rl", &IM, &effect) == FAILURE) {
1851 		return;
1852 	}
1853 
1854 	ZEND_FETCH_RESOURCE(im, gdImagePtr, &IM, -1, "Image", le_gd);
1855 	gdImageAlphaBlending(im, effect);
1856 
1857 	RETURN_TRUE;
1858 }
1859 /* }}} */
1860 
1861 /* {{{ proto int imagecolorallocatealpha(resource im, int red, int green, int blue, int alpha)
1862    Allocate a color with an alpha level.  Works for true color and palette based images */
PHP_FUNCTION(imagecolorallocatealpha)1863 PHP_FUNCTION(imagecolorallocatealpha)
1864 {
1865 	zval *IM;
1866 	long red, green, blue, alpha;
1867 	gdImagePtr im;
1868 	int ct = (-1);
1869 
1870 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rllll", &IM, &red, &green, &blue, &alpha) == FAILURE) {
1871 		RETURN_FALSE;
1872 	}
1873 
1874 	ZEND_FETCH_RESOURCE(im, gdImagePtr, &IM, -1, "Image", le_gd);
1875 	ct = gdImageColorAllocateAlpha(im, red, green, blue, alpha);
1876 	if (ct < 0) {
1877 		RETURN_FALSE;
1878 	}
1879 	RETURN_LONG((long)ct);
1880 }
1881 /* }}} */
1882 
1883 /* {{{ proto int imagecolorresolvealpha(resource im, int red, int green, int blue, int alpha)
1884    Resolve/Allocate a colour with an alpha level.  Works for true colour and palette based images */
PHP_FUNCTION(imagecolorresolvealpha)1885 PHP_FUNCTION(imagecolorresolvealpha)
1886 {
1887 	zval *IM;
1888 	long red, green, blue, alpha;
1889 	gdImagePtr im;
1890 
1891 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rllll", &IM, &red, &green, &blue, &alpha) == FAILURE) {
1892 		return;
1893 	}
1894 
1895 	ZEND_FETCH_RESOURCE(im, gdImagePtr, &IM, -1, "Image", le_gd);
1896 
1897 	RETURN_LONG(gdImageColorResolveAlpha(im, red, green, blue, alpha));
1898 }
1899 /* }}} */
1900 
1901 /* {{{ proto int imagecolorclosestalpha(resource im, int red, int green, int blue, int alpha)
1902    Find the closest matching colour with alpha transparency */
PHP_FUNCTION(imagecolorclosestalpha)1903 PHP_FUNCTION(imagecolorclosestalpha)
1904 {
1905 	zval *IM;
1906 	long red, green, blue, alpha;
1907 	gdImagePtr im;
1908 
1909 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rllll", &IM, &red, &green, &blue, &alpha) == FAILURE) {
1910 		return;
1911 	}
1912 
1913 	ZEND_FETCH_RESOURCE(im, gdImagePtr, &IM, -1, "Image", le_gd);
1914 
1915 	RETURN_LONG(gdImageColorClosestAlpha(im, red, green, blue, alpha));
1916 }
1917 /* }}} */
1918 
1919 /* {{{ proto int imagecolorexactalpha(resource im, int red, int green, int blue, int alpha)
1920    Find exact match for colour with transparency */
PHP_FUNCTION(imagecolorexactalpha)1921 PHP_FUNCTION(imagecolorexactalpha)
1922 {
1923 	zval *IM;
1924 	long red, green, blue, alpha;
1925 	gdImagePtr im;
1926 
1927 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rllll", &IM, &red, &green, &blue, &alpha) == FAILURE) {
1928 		return;
1929 	}
1930 
1931 	ZEND_FETCH_RESOURCE(im, gdImagePtr, &IM, -1, "Image", le_gd);
1932 
1933 	RETURN_LONG(gdImageColorExactAlpha(im, red, green, blue, alpha));
1934 }
1935 /* }}} */
1936 
1937 /* {{{ proto bool imagecopyresampled(resource dst_im, resource src_im, int dst_x, int dst_y, int src_x, int src_y, int dst_w, int dst_h, int src_w, int src_h)
1938    Copy and resize part of an image using resampling to help ensure clarity */
PHP_FUNCTION(imagecopyresampled)1939 PHP_FUNCTION(imagecopyresampled)
1940 {
1941 	zval *SIM, *DIM;
1942 	long SX, SY, SW, SH, DX, DY, DW, DH;
1943 	gdImagePtr im_dst, im_src;
1944 	int srcH, srcW, dstH, dstW, srcY, srcX, dstY, dstX;
1945 
1946 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rrllllllll", &DIM, &SIM, &DX, &DY, &SX, &SY, &DW, &DH, &SW, &SH) == FAILURE) {
1947 		return;
1948 	}
1949 
1950 	ZEND_FETCH_RESOURCE(im_dst, gdImagePtr, &DIM, -1, "Image", le_gd);
1951 	ZEND_FETCH_RESOURCE(im_src, gdImagePtr, &SIM, -1, "Image", le_gd);
1952 
1953 	srcX = SX;
1954 	srcY = SY;
1955 	srcH = SH;
1956 	srcW = SW;
1957 	dstX = DX;
1958 	dstY = DY;
1959 	dstH = DH;
1960 	dstW = DW;
1961 
1962 	gdImageCopyResampled(im_dst, im_src, dstX, dstY, srcX, srcY, dstW, dstH, srcW, srcH);
1963 
1964 	RETURN_TRUE;
1965 }
1966 /* }}} */
1967 
1968 #ifdef PHP_WIN32
1969 /* {{{ proto resource imagegrabwindow(int window_handle [, int client_area])
1970    Grab a window or its client area using a windows handle (HWND property in COM instance) */
PHP_FUNCTION(imagegrabwindow)1971 PHP_FUNCTION(imagegrabwindow)
1972 {
1973 	HWND window;
1974 	long client_area = 0;
1975 	RECT rc = {0};
1976 	RECT rc_win = {0};
1977 	int Width, Height;
1978 	HDC		hdc;
1979 	HDC memDC;
1980 	HBITMAP memBM;
1981 	HBITMAP hOld;
1982 	HINSTANCE handle;
1983 	long lwindow_handle;
1984 	typedef BOOL (WINAPI *tPrintWindow)(HWND, HDC,UINT);
1985 	tPrintWindow pPrintWindow = 0;
1986 	gdImagePtr im;
1987 
1988 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l|l", &lwindow_handle, &client_area) == FAILURE) {
1989 		RETURN_FALSE;
1990 	}
1991 
1992 	window = (HWND) lwindow_handle;
1993 
1994 	if (!IsWindow(window)) {
1995 		php_error_docref(NULL TSRMLS_CC, E_NOTICE, "Invalid window handle");
1996 		RETURN_FALSE;
1997 	}
1998 
1999 	hdc		= GetDC(0);
2000 
2001 	if (client_area) {
2002 		GetClientRect(window, &rc);
2003 		Width = rc.right;
2004 		Height = rc.bottom;
2005 	} else {
2006 		GetWindowRect(window, &rc);
2007 		Width	= rc.right - rc.left;
2008 		Height	= rc.bottom - rc.top;
2009 	}
2010 
2011 	Width		= (Width/4)*4;
2012 
2013 	memDC	= CreateCompatibleDC(hdc);
2014 	memBM	= CreateCompatibleBitmap(hdc, Width, Height);
2015 	hOld	= (HBITMAP) SelectObject (memDC, memBM);
2016 
2017 
2018 	handle = LoadLibrary("User32.dll");
2019 	if ( handle == 0 ) {
2020 		goto clean;
2021 	}
2022 	pPrintWindow = (tPrintWindow) GetProcAddress(handle, "PrintWindow");
2023 
2024 	if ( pPrintWindow )  {
2025 		pPrintWindow(window, memDC, (UINT) client_area);
2026 	} else {
2027 		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Windows API too old");
2028 		goto clean;
2029 	}
2030 
2031 	FreeLibrary(handle);
2032 
2033 	im = gdImageCreateTrueColor(Width, Height);
2034 	if (im) {
2035 		int x,y;
2036 		for (y=0; y <= Height; y++) {
2037 			for (x=0; x <= Width; x++) {
2038 				int c = GetPixel(memDC, x,y);
2039 				gdImageSetPixel(im, x, y, gdTrueColor(GetRValue(c), GetGValue(c), GetBValue(c)));
2040 			}
2041 		}
2042 	}
2043 
2044 clean:
2045 	SelectObject(memDC,hOld);
2046 	DeleteObject(memBM);
2047 	DeleteDC(memDC);
2048 	ReleaseDC( 0, hdc );
2049 
2050 	if (!im) {
2051 		RETURN_FALSE;
2052 	} else {
2053 		ZEND_REGISTER_RESOURCE(return_value, im, le_gd);
2054 	}
2055 }
2056 /* }}} */
2057 
2058 /* {{{ proto resource imagegrabscreen()
2059    Grab a screenshot */
PHP_FUNCTION(imagegrabscreen)2060 PHP_FUNCTION(imagegrabscreen)
2061 {
2062 	HWND window = GetDesktopWindow();
2063 	RECT rc = {0};
2064 	int Width, Height;
2065 	HDC		hdc;
2066 	HDC memDC;
2067 	HBITMAP memBM;
2068 	HBITMAP hOld;
2069 	typedef BOOL (WINAPI *tPrintWindow)(HWND, HDC,UINT);
2070 	tPrintWindow pPrintWindow = 0;
2071 	gdImagePtr im;
2072 	hdc		= GetDC(0);
2073 
2074 	if (zend_parse_parameters_none() == FAILURE) {
2075 		return;
2076 	}
2077 
2078 	if (!hdc) {
2079 		RETURN_FALSE;
2080 	}
2081 
2082 	GetWindowRect(window, &rc);
2083 	Width	= rc.right - rc.left;
2084 	Height	= rc.bottom - rc.top;
2085 
2086 	Width		= (Width/4)*4;
2087 
2088 	memDC	= CreateCompatibleDC(hdc);
2089 	memBM	= CreateCompatibleBitmap(hdc, Width, Height);
2090 	hOld	= (HBITMAP) SelectObject (memDC, memBM);
2091 	BitBlt( memDC, 0, 0, Width, Height , hdc, rc.left, rc.top , SRCCOPY );
2092 
2093 	im = gdImageCreateTrueColor(Width, Height);
2094 	if (im) {
2095 		int x,y;
2096 		for (y=0; y <= Height; y++) {
2097 			for (x=0; x <= Width; x++) {
2098 				int c = GetPixel(memDC, x,y);
2099 				gdImageSetPixel(im, x, y, gdTrueColor(GetRValue(c), GetGValue(c), GetBValue(c)));
2100 			}
2101 		}
2102 	}
2103 
2104 	SelectObject(memDC,hOld);
2105 	DeleteObject(memBM);
2106 	DeleteDC(memDC);
2107 	ReleaseDC( 0, hdc );
2108 
2109 	if (!im) {
2110 		RETURN_FALSE;
2111 	} else {
2112 		ZEND_REGISTER_RESOURCE(return_value, im, le_gd);
2113 	}
2114 }
2115 /* }}} */
2116 #endif /* PHP_WIN32 */
2117 
2118 /* {{{ proto resource imagerotate(resource src_im, float angle, int bgdcolor [, int ignoretransparent])
2119    Rotate an image using a custom angle */
PHP_FUNCTION(imagerotate)2120 PHP_FUNCTION(imagerotate)
2121 {
2122 	zval *SIM;
2123 	gdImagePtr im_dst, im_src;
2124 	double degrees;
2125 	long color;
2126 	long ignoretransparent = 0;
2127 
2128 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rdl|l", &SIM, &degrees, &color, &ignoretransparent) == FAILURE) {
2129 		RETURN_FALSE;
2130 	}
2131 
2132 	ZEND_FETCH_RESOURCE(im_src, gdImagePtr, &SIM, -1, "Image", le_gd);
2133 
2134 	im_dst = gdImageRotateInterpolated(im_src, (const float)degrees, color);
2135 
2136 	if (im_dst != NULL) {
2137 		ZEND_REGISTER_RESOURCE(return_value, im_dst, le_gd);
2138 	} else {
2139 		RETURN_FALSE;
2140 	}
2141 }
2142 /* }}} */
2143 
2144 /* {{{ proto bool imagesettile(resource image, resource tile)
2145    Set the tile image to $tile when filling $image with the "IMG_COLOR_TILED" color */
PHP_FUNCTION(imagesettile)2146 PHP_FUNCTION(imagesettile)
2147 {
2148 	zval *IM, *TILE;
2149 	gdImagePtr im, tile;
2150 
2151 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rr", &IM, &TILE) == FAILURE) {
2152 		return;
2153 	}
2154 
2155 	ZEND_FETCH_RESOURCE(im, gdImagePtr, &IM, -1, "Image", le_gd);
2156 	ZEND_FETCH_RESOURCE(tile, gdImagePtr, &TILE, -1, "Image", le_gd);
2157 
2158 	gdImageSetTile(im, tile);
2159 
2160 	RETURN_TRUE;
2161 }
2162 /* }}} */
2163 
2164 /* {{{ proto bool imagesetbrush(resource image, resource brush)
2165    Set the brush image to $brush when filling $image with the "IMG_COLOR_BRUSHED" color */
PHP_FUNCTION(imagesetbrush)2166 PHP_FUNCTION(imagesetbrush)
2167 {
2168 	zval *IM, *TILE;
2169 	gdImagePtr im, tile;
2170 
2171 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rr", &IM, &TILE) == FAILURE) {
2172 		return;
2173 	}
2174 
2175 	ZEND_FETCH_RESOURCE(im, gdImagePtr, &IM, -1, "Image", le_gd);
2176 	ZEND_FETCH_RESOURCE(tile, gdImagePtr, &TILE, -1, "Image", le_gd);
2177 
2178 	gdImageSetBrush(im, tile);
2179 
2180 	RETURN_TRUE;
2181 }
2182 /* }}} */
2183 
2184 /* {{{ proto resource imagecreate(int x_size, int y_size)
2185    Create a new image */
PHP_FUNCTION(imagecreate)2186 PHP_FUNCTION(imagecreate)
2187 {
2188 	long x_size, y_size;
2189 	gdImagePtr im;
2190 
2191 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ll", &x_size, &y_size) == FAILURE) {
2192 		return;
2193 	}
2194 
2195 	if (x_size <= 0 || y_size <= 0 || x_size >= INT_MAX || y_size >= INT_MAX) {
2196 		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid image dimensions");
2197 		RETURN_FALSE;
2198 	}
2199 
2200 	im = gdImageCreate(x_size, y_size);
2201 
2202 	if (!im) {
2203 		RETURN_FALSE;
2204 	}
2205 
2206 	ZEND_REGISTER_RESOURCE(return_value, im, le_gd);
2207 }
2208 /* }}} */
2209 
2210 /* {{{ proto int imagetypes(void)
2211    Return the types of images supported in a bitfield - 1=GIF, 2=JPEG, 4=PNG, 8=WBMP, 16=XPM */
PHP_FUNCTION(imagetypes)2212 PHP_FUNCTION(imagetypes)
2213 {
2214 	int ret=0;
2215 	ret = 1;
2216 #ifdef HAVE_GD_JPG
2217 	ret |= 2;
2218 #endif
2219 #ifdef HAVE_GD_PNG
2220 	ret |= 4;
2221 #endif
2222 	ret |= 8;
2223 #if defined(HAVE_GD_XPM)
2224 	ret |= 16;
2225 #endif
2226 #ifdef HAVE_GD_WEBP
2227 	ret |= 32;
2228 #endif
2229 
2230 	if (zend_parse_parameters_none() == FAILURE) {
2231 		return;
2232 	}
2233 
2234 	RETURN_LONG(ret);
2235 }
2236 /* }}} */
2237 
2238 /* {{{ _php_ctx_getmbi
2239  */
2240 
_php_ctx_getmbi(gdIOCtx * ctx)2241 static int _php_ctx_getmbi(gdIOCtx *ctx)
2242 {
2243 	int i, mbi = 0;
2244 
2245 	do {
2246 		i = (ctx->getC)(ctx);
2247 		if (i < 0) {
2248 			return -1;
2249 		}
2250 		mbi = (mbi << 7) | (i & 0x7f);
2251 	} while (i & 0x80);
2252 
2253 	return mbi;
2254 }
2255 /* }}} */
2256 
2257 /* {{{ _php_image_type
2258  */
2259 static const char php_sig_gd2[3] = {'g', 'd', '2'};
2260 
_php_image_type(char data[8])2261 static int _php_image_type (char data[8])
2262 {
2263 	/* Based on ext/standard/image.c */
2264 
2265 	if (data == NULL) {
2266 		return -1;
2267 	}
2268 
2269 	if (!memcmp(data, php_sig_gd2, 3)) {
2270 		return PHP_GDIMG_TYPE_GD2;
2271 	} else if (!memcmp(data, php_sig_jpg, 3)) {
2272 		return PHP_GDIMG_TYPE_JPG;
2273 	} else if (!memcmp(data, php_sig_png, 3)) {
2274 		if (!memcmp(data, php_sig_png, 8)) {
2275 			return PHP_GDIMG_TYPE_PNG;
2276 		}
2277 	} else if (!memcmp(data, php_sig_gif, 3)) {
2278 		return PHP_GDIMG_TYPE_GIF;
2279 	}
2280 	else {
2281 		gdIOCtx *io_ctx;
2282 		io_ctx = gdNewDynamicCtxEx(8, data, 0);
2283 		if (io_ctx) {
2284 			if (_php_ctx_getmbi(io_ctx) == 0 && _php_ctx_getmbi(io_ctx) >= 0) {
2285 				io_ctx->gd_free(io_ctx);
2286 				return PHP_GDIMG_TYPE_WBM;
2287 			} else {
2288 				io_ctx->gd_free(io_ctx);
2289 			}
2290 		}
2291 	}
2292 	return -1;
2293 }
2294 /* }}} */
2295 
2296 /* {{{ _php_image_create_from_string
2297  */
_php_image_create_from_string(zval ** data,char * tn,gdImagePtr (* ioctx_func_p)()TSRMLS_DC)2298 gdImagePtr _php_image_create_from_string(zval **data, char *tn, gdImagePtr (*ioctx_func_p)() TSRMLS_DC)
2299 {
2300 	gdImagePtr im;
2301 	gdIOCtx *io_ctx;
2302 
2303 	io_ctx = gdNewDynamicCtxEx(Z_STRLEN_PP(data), Z_STRVAL_PP(data), 0);
2304 
2305 	if (!io_ctx) {
2306 		return NULL;
2307 	}
2308 
2309 	im = (*ioctx_func_p)(io_ctx);
2310 	if (!im) {
2311 		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Passed data is not in '%s' format", tn);
2312 		io_ctx->gd_free(io_ctx);
2313 		return NULL;
2314 	}
2315 
2316 	io_ctx->gd_free(io_ctx);
2317 
2318 	return im;
2319 }
2320 /* }}} */
2321 
2322 /* {{{ proto resource imagecreatefromstring(string image)
2323    Create a new image from the image stream in the string */
PHP_FUNCTION(imagecreatefromstring)2324 PHP_FUNCTION(imagecreatefromstring)
2325 {
2326 	zval **data;
2327 	gdImagePtr im;
2328 	int imtype;
2329 	char sig[8];
2330 
2331 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Z", &data) == FAILURE) {
2332 		return;
2333 	}
2334 
2335 	convert_to_string_ex(data);
2336 	if (Z_STRLEN_PP(data) < 8) {
2337 		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Empty string or invalid image");
2338 		RETURN_FALSE;
2339 	}
2340 
2341 	memcpy(sig, Z_STRVAL_PP(data), 8);
2342 
2343 	imtype = _php_image_type(sig);
2344 
2345 	switch (imtype) {
2346 		case PHP_GDIMG_TYPE_JPG:
2347 #ifdef HAVE_GD_JPG
2348 			im = _php_image_create_from_string(data, "JPEG", gdImageCreateFromJpegCtx TSRMLS_CC);
2349 #else
2350 			php_error_docref(NULL TSRMLS_CC, E_WARNING, "No JPEG support in this PHP build");
2351 			RETURN_FALSE;
2352 #endif
2353 			break;
2354 
2355 		case PHP_GDIMG_TYPE_PNG:
2356 #ifdef HAVE_GD_PNG
2357 			im = _php_image_create_from_string(data, "PNG", gdImageCreateFromPngCtx TSRMLS_CC);
2358 #else
2359 			php_error_docref(NULL TSRMLS_CC, E_WARNING, "No PNG support in this PHP build");
2360 			RETURN_FALSE;
2361 #endif
2362 			break;
2363 
2364 		case PHP_GDIMG_TYPE_GIF:
2365 			im = _php_image_create_from_string(data, "GIF", gdImageCreateFromGifCtx TSRMLS_CC);
2366 			break;
2367 
2368 		case PHP_GDIMG_TYPE_WBM:
2369 			im = _php_image_create_from_string(data, "WBMP", gdImageCreateFromWBMPCtx TSRMLS_CC);
2370 			break;
2371 
2372 		case PHP_GDIMG_TYPE_GD2:
2373 			im = _php_image_create_from_string(data, "GD2", gdImageCreateFromGd2Ctx TSRMLS_CC);
2374 			break;
2375 
2376 		default:
2377 			php_error_docref(NULL TSRMLS_CC, E_WARNING, "Data is not in a recognized format");
2378 			RETURN_FALSE;
2379 	}
2380 
2381 	if (!im) {
2382 		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Couldn't create GD Image Stream out of Data");
2383 		RETURN_FALSE;
2384 	}
2385 
2386 	ZEND_REGISTER_RESOURCE(return_value, im, le_gd);
2387 }
2388 /* }}} */
2389 
2390 /* {{{ _php_image_create_from
2391  */
_php_image_create_from(INTERNAL_FUNCTION_PARAMETERS,int image_type,char * tn,gdImagePtr (* func_p)(),gdImagePtr (* ioctx_func_p)())2392 static void _php_image_create_from(INTERNAL_FUNCTION_PARAMETERS, int image_type, char *tn, gdImagePtr (*func_p)(), gdImagePtr (*ioctx_func_p)())
2393 {
2394 	char *file;
2395 	int file_len;
2396 	long srcx, srcy, width, height;
2397 	gdImagePtr im = NULL;
2398 	php_stream *stream;
2399 	FILE * fp = NULL;
2400 	long ignore_warning;
2401 
2402 	if (image_type == PHP_GDIMG_TYPE_GD2PART) {
2403 		if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "pllll", &file, &file_len, &srcx, &srcy, &width, &height) == FAILURE) {
2404 			return;
2405 		}
2406 		if (width < 1 || height < 1) {
2407 			php_error_docref(NULL TSRMLS_CC, E_WARNING, "Zero width or height not allowed");
2408 			RETURN_FALSE;
2409 		}
2410 	} else {
2411 		if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "p", &file, &file_len) == FAILURE) {
2412 			return;
2413 		}
2414 	}
2415 
2416 
2417 	stream = php_stream_open_wrapper(file, "rb", REPORT_ERRORS|IGNORE_PATH|IGNORE_URL_WIN, NULL);
2418 	if (stream == NULL)	{
2419 		RETURN_FALSE;
2420 	}
2421 
2422 	/* try and avoid allocating a FILE* if the stream is not naturally a FILE* */
2423 	if (php_stream_is(stream, PHP_STREAM_IS_STDIO))	{
2424 		if (FAILURE == php_stream_cast(stream, PHP_STREAM_AS_STDIO, (void**)&fp, REPORT_ERRORS)) {
2425 			goto out_err;
2426 		}
2427 	} else if (ioctx_func_p) {
2428 		/* we can create an io context */
2429 		gdIOCtx* io_ctx;
2430 		size_t buff_size;
2431 		char *buff;
2432 
2433 		/* needs to be malloc (persistent) - GD will free() it later */
2434 		buff_size = php_stream_copy_to_mem(stream, &buff, PHP_STREAM_COPY_ALL, 1);
2435 
2436 		if (!buff_size) {
2437 			php_error_docref(NULL TSRMLS_CC, E_WARNING,"Cannot read image data");
2438 			goto out_err;
2439 		}
2440 
2441 		io_ctx = gdNewDynamicCtxEx(buff_size, buff, 0);
2442 		if (!io_ctx) {
2443 			pefree(buff, 1);
2444 			php_error_docref(NULL TSRMLS_CC, E_WARNING,"Cannot allocate GD IO context");
2445 			goto out_err;
2446 		}
2447 
2448 		if (image_type == PHP_GDIMG_TYPE_GD2PART) {
2449 			im = (*ioctx_func_p)(io_ctx, srcx, srcy, width, height);
2450 		} else {
2451 			im = (*ioctx_func_p)(io_ctx);
2452 		}
2453 		io_ctx->gd_free(io_ctx);
2454 		pefree(buff, 1);
2455 	}
2456 	else if (php_stream_can_cast(stream, PHP_STREAM_AS_STDIO)) {
2457 		/* try and force the stream to be FILE* */
2458 		if (FAILURE == php_stream_cast(stream, PHP_STREAM_AS_STDIO | PHP_STREAM_CAST_TRY_HARD, (void **) &fp, REPORT_ERRORS)) {
2459 			goto out_err;
2460 		}
2461 	}
2462 
2463 	if (!im && fp) {
2464 		switch (image_type) {
2465 			case PHP_GDIMG_TYPE_GD2PART:
2466 				im = (*func_p)(fp, srcx, srcy, width, height);
2467 				break;
2468 #if defined(HAVE_GD_XPM)
2469 			case PHP_GDIMG_TYPE_XPM:
2470 				im = gdImageCreateFromXpm(file);
2471 				break;
2472 #endif
2473 
2474 #ifdef HAVE_GD_JPG
2475 			case PHP_GDIMG_TYPE_JPG:
2476 				ignore_warning = INI_INT("gd.jpeg_ignore_warning");
2477 				im = gdImageCreateFromJpegEx(fp, ignore_warning);
2478 			break;
2479 #endif
2480 
2481 			default:
2482 				im = (*func_p)(fp);
2483 				break;
2484 		}
2485 
2486 		fflush(fp);
2487 	}
2488 
2489 /* register_im: */
2490 	if (im) {
2491 		ZEND_REGISTER_RESOURCE(return_value, im, le_gd);
2492 		php_stream_close(stream);
2493 		return;
2494 	}
2495 
2496 	php_error_docref(NULL TSRMLS_CC, E_WARNING, "'%s' is not a valid %s file", file, tn);
2497 out_err:
2498 	php_stream_close(stream);
2499 	RETURN_FALSE;
2500 
2501 }
2502 /* }}} */
2503 
2504 /* {{{ proto resource imagecreatefromgif(string filename)
2505    Create a new image from GIF file or URL */
PHP_FUNCTION(imagecreatefromgif)2506 PHP_FUNCTION(imagecreatefromgif)
2507 {
2508 	_php_image_create_from(INTERNAL_FUNCTION_PARAM_PASSTHRU, PHP_GDIMG_TYPE_GIF, "GIF", gdImageCreateFromGif, gdImageCreateFromGifCtx);
2509 }
2510 /* }}} */
2511 
2512 #ifdef HAVE_GD_JPG
2513 /* {{{ proto resource imagecreatefromjpeg(string filename)
2514    Create a new image from JPEG file or URL */
PHP_FUNCTION(imagecreatefromjpeg)2515 PHP_FUNCTION(imagecreatefromjpeg)
2516 {
2517 	_php_image_create_from(INTERNAL_FUNCTION_PARAM_PASSTHRU, PHP_GDIMG_TYPE_JPG, "JPEG", gdImageCreateFromJpeg, gdImageCreateFromJpegCtx);
2518 }
2519 /* }}} */
2520 #endif /* HAVE_GD_JPG */
2521 
2522 #ifdef HAVE_GD_PNG
2523 /* {{{ proto resource imagecreatefrompng(string filename)
2524    Create a new image from PNG file or URL */
PHP_FUNCTION(imagecreatefrompng)2525 PHP_FUNCTION(imagecreatefrompng)
2526 {
2527 	_php_image_create_from(INTERNAL_FUNCTION_PARAM_PASSTHRU, PHP_GDIMG_TYPE_PNG, "PNG", gdImageCreateFromPng, gdImageCreateFromPngCtx);
2528 }
2529 /* }}} */
2530 #endif /* HAVE_GD_PNG */
2531 
2532 #ifdef HAVE_GD_WEBP
2533 /* {{{ proto resource imagecreatefromwebp(string filename)
2534    Create a new image from WEBP file or URL */
PHP_FUNCTION(imagecreatefromwebp)2535 PHP_FUNCTION(imagecreatefromwebp)
2536 {
2537 	_php_image_create_from(INTERNAL_FUNCTION_PARAM_PASSTHRU, PHP_GDIMG_TYPE_WEBP, "WEBP", gdImageCreateFromWebp, gdImageCreateFromWebpCtx);
2538 }
2539 /* }}} */
2540 #endif /* HAVE_GD_VPX */
2541 
2542 /* {{{ proto resource imagecreatefromxbm(string filename)
2543    Create a new image from XBM file or URL */
PHP_FUNCTION(imagecreatefromxbm)2544 PHP_FUNCTION(imagecreatefromxbm)
2545 {
2546 	_php_image_create_from(INTERNAL_FUNCTION_PARAM_PASSTHRU, PHP_GDIMG_TYPE_XBM, "XBM", gdImageCreateFromXbm, NULL);
2547 }
2548 /* }}} */
2549 
2550 #if defined(HAVE_GD_XPM)
2551 /* {{{ proto resource imagecreatefromxpm(string filename)
2552    Create a new image from XPM file or URL */
PHP_FUNCTION(imagecreatefromxpm)2553 PHP_FUNCTION(imagecreatefromxpm)
2554 {
2555 	_php_image_create_from(INTERNAL_FUNCTION_PARAM_PASSTHRU, PHP_GDIMG_TYPE_XPM, "XPM", gdImageCreateFromXpm, NULL);
2556 }
2557 /* }}} */
2558 #endif
2559 
2560 /* {{{ proto resource imagecreatefromwbmp(string filename)
2561    Create a new image from WBMP file or URL */
PHP_FUNCTION(imagecreatefromwbmp)2562 PHP_FUNCTION(imagecreatefromwbmp)
2563 {
2564 	_php_image_create_from(INTERNAL_FUNCTION_PARAM_PASSTHRU, PHP_GDIMG_TYPE_WBM, "WBMP", gdImageCreateFromWBMP, gdImageCreateFromWBMPCtx);
2565 }
2566 /* }}} */
2567 
2568 /* {{{ proto resource imagecreatefromgd(string filename)
2569    Create a new image from GD file or URL */
PHP_FUNCTION(imagecreatefromgd)2570 PHP_FUNCTION(imagecreatefromgd)
2571 {
2572 	_php_image_create_from(INTERNAL_FUNCTION_PARAM_PASSTHRU, PHP_GDIMG_TYPE_GD, "GD", gdImageCreateFromGd, gdImageCreateFromGdCtx);
2573 }
2574 /* }}} */
2575 
2576 /* {{{ proto resource imagecreatefromgd2(string filename)
2577    Create a new image from GD2 file or URL */
PHP_FUNCTION(imagecreatefromgd2)2578 PHP_FUNCTION(imagecreatefromgd2)
2579 {
2580 	_php_image_create_from(INTERNAL_FUNCTION_PARAM_PASSTHRU, PHP_GDIMG_TYPE_GD2, "GD2", gdImageCreateFromGd2, gdImageCreateFromGd2Ctx);
2581 }
2582 /* }}} */
2583 
2584 /* {{{ proto resource imagecreatefromgd2part(string filename, int srcX, int srcY, int width, int height)
2585    Create a new image from a given part of GD2 file or URL */
PHP_FUNCTION(imagecreatefromgd2part)2586 PHP_FUNCTION(imagecreatefromgd2part)
2587 {
2588 	_php_image_create_from(INTERNAL_FUNCTION_PARAM_PASSTHRU, PHP_GDIMG_TYPE_GD2PART, "GD2", gdImageCreateFromGd2Part, gdImageCreateFromGd2PartCtx);
2589 }
2590 /* }}} */
2591 
2592 /* {{{ _php_image_output
2593  */
_php_image_output(INTERNAL_FUNCTION_PARAMETERS,int image_type,char * tn,void (* func_p)())2594 static void _php_image_output(INTERNAL_FUNCTION_PARAMETERS, int image_type, char *tn, void (*func_p)())
2595 {
2596 	zval *imgind;
2597 	char *file = NULL;
2598 	long quality = 0, type = 0;
2599 	gdImagePtr im;
2600 	char *fn = NULL;
2601 	FILE *fp;
2602 	int file_len = 0, argc = ZEND_NUM_ARGS();
2603 	int q = -1, i, t = 1;
2604 
2605 	/* The quality parameter for Wbmp stands for the threshold when called from image2wbmp() */
2606 	/* When called from imagewbmp() the quality parameter stands for the foreground color. Default: black. */
2607 	/* The quality parameter for gd2 stands for chunk size */
2608 
2609 	if (zend_parse_parameters(argc TSRMLS_CC, "r|pll", &imgind, &file, &file_len, &quality, &type) == FAILURE) {
2610 		return;
2611 	}
2612 
2613 	ZEND_FETCH_RESOURCE(im, gdImagePtr, &imgind, -1, "Image", le_gd);
2614 
2615 	if (argc > 1) {
2616 		fn = file;
2617 		if (argc >= 3) {
2618 			q = quality;
2619 			if (argc == 4) {
2620 				t = type;
2621 			}
2622 		}
2623 	}
2624 
2625 	if (argc >= 2 && file_len) {
2626 		PHP_GD_CHECK_OPEN_BASEDIR(fn, "Invalid filename");
2627 
2628 		fp = VCWD_FOPEN(fn, "wb");
2629 		if (!fp) {
2630 			php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to open '%s' for writing", fn);
2631 			RETURN_FALSE;
2632 		}
2633 
2634 		switch (image_type) {
2635 			case PHP_GDIMG_CONVERT_WBM:
2636 				if (q == -1) {
2637 					q = 0;
2638 				} else if (q < 0 || q > 255) {
2639 					php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid threshold value '%d'. It must be between 0 and 255", q);
2640 					q = 0;
2641 				}
2642 				gdImageWBMP(im, q, fp);
2643 				break;
2644 			case PHP_GDIMG_TYPE_JPG:
2645 				(*func_p)(im, fp, q);
2646 				break;
2647 			case PHP_GDIMG_TYPE_WBM:
2648 				for (i = 0; i < gdImageColorsTotal(im); i++) {
2649 					if (gdImageRed(im, i) == 0) break;
2650 				}
2651 				(*func_p)(im, i, fp);
2652 				break;
2653 			case PHP_GDIMG_TYPE_GD:
2654 				if (im->trueColor){
2655 					gdImageTrueColorToPalette(im,1,256);
2656 				}
2657 				(*func_p)(im, fp);
2658 				break;
2659 			case PHP_GDIMG_TYPE_GD2:
2660 				if (q == -1) {
2661 					q = 128;
2662 				}
2663 				(*func_p)(im, fp, q, t);
2664 				break;
2665 			default:
2666 				if (q == -1) {
2667 					q = 128;
2668 				}
2669 				(*func_p)(im, fp, q, t);
2670 				break;
2671 		}
2672 		fflush(fp);
2673 		fclose(fp);
2674 	} else {
2675 		int   b;
2676 		FILE *tmp;
2677 		char  buf[4096];
2678 		char *path;
2679 
2680 		tmp = php_open_temporary_file(NULL, NULL, &path TSRMLS_CC);
2681 		if (tmp == NULL) {
2682 			php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to open temporary file");
2683 			RETURN_FALSE;
2684 		}
2685 
2686 		switch (image_type) {
2687 			case PHP_GDIMG_CONVERT_WBM:
2688  				if (q == -1) {
2689   					q = 0;
2690   				} else if (q < 0 || q > 255) {
2691   					php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid threshold value '%d'. It must be between 0 and 255", q);
2692  					q = 0;
2693   				}
2694 				gdImageWBMP(im, q, tmp);
2695 				break;
2696 			case PHP_GDIMG_TYPE_JPG:
2697 				(*func_p)(im, tmp, q);
2698 				break;
2699 			case PHP_GDIMG_TYPE_WBM:
2700 				for (i = 0; i < gdImageColorsTotal(im); i++) {
2701 					if (gdImageRed(im, i) == 0) {
2702 						break;
2703 					}
2704 				}
2705 				(*func_p)(im, q, tmp);
2706 				break;
2707 			case PHP_GDIMG_TYPE_GD:
2708 				if (im->trueColor) {
2709 					gdImageTrueColorToPalette(im,1,256);
2710 				}
2711 				(*func_p)(im, tmp);
2712 				break;
2713 			case PHP_GDIMG_TYPE_GD2:
2714 				if (q == -1) {
2715 					q = 128;
2716 				}
2717 				(*func_p)(im, tmp, q, t);
2718 				break;
2719 			default:
2720 				(*func_p)(im, tmp);
2721 				break;
2722 		}
2723 
2724 		fseek(tmp, 0, SEEK_SET);
2725 
2726 #if APACHE && defined(CHARSET_EBCDIC)
2727 		/* XXX this is unlikely to work any more thies@thieso.net */
2728 
2729 		/* This is a binary file already: avoid EBCDIC->ASCII conversion */
2730 		ap_bsetflag(php3_rqst->connection->client, B_EBCDIC2ASCII, 0);
2731 #endif
2732 		while ((b = fread(buf, 1, sizeof(buf), tmp)) > 0) {
2733 			php_write(buf, b TSRMLS_CC);
2734 		}
2735 
2736 		fclose(tmp);
2737 		VCWD_UNLINK((const char *)path); /* make sure that the temporary file is removed */
2738 		efree(path);
2739 	}
2740 	RETURN_TRUE;
2741 }
2742 /* }}} */
2743 
2744 /* {{{ proto int imagexbm(int im, string filename [, int foreground])
2745    Output XBM image to browser or file */
PHP_FUNCTION(imagexbm)2746 PHP_FUNCTION(imagexbm)
2747 {
2748 	_php_image_output_ctx(INTERNAL_FUNCTION_PARAM_PASSTHRU, PHP_GDIMG_TYPE_XBM, "XBM", gdImageXbmCtx);
2749 }
2750 /* }}} */
2751 
2752 /* {{{ proto bool imagegif(resource im [, string filename])
2753    Output GIF image to browser or file */
PHP_FUNCTION(imagegif)2754 PHP_FUNCTION(imagegif)
2755 {
2756 	_php_image_output_ctx(INTERNAL_FUNCTION_PARAM_PASSTHRU, PHP_GDIMG_TYPE_GIF, "GIF", gdImageGifCtx);
2757 }
2758 /* }}} */
2759 
2760 #ifdef HAVE_GD_PNG
2761 /* {{{ proto bool imagepng(resource im [, string filename])
2762    Output PNG image to browser or file */
PHP_FUNCTION(imagepng)2763 PHP_FUNCTION(imagepng)
2764 {
2765 	_php_image_output_ctx(INTERNAL_FUNCTION_PARAM_PASSTHRU, PHP_GDIMG_TYPE_PNG, "PNG", gdImagePngCtxEx);
2766 }
2767 /* }}} */
2768 #endif /* HAVE_GD_PNG */
2769 
2770 
2771 #ifdef HAVE_GD_WEBP
2772 /* {{{ proto bool imagewebp(resource im [, string filename[, quality]] )
2773    Output WEBP image to browser or file */
PHP_FUNCTION(imagewebp)2774 PHP_FUNCTION(imagewebp)
2775 {
2776 	_php_image_output_ctx(INTERNAL_FUNCTION_PARAM_PASSTHRU, PHP_GDIMG_TYPE_WEBP, "WEBP", gdImageWebpCtx);
2777 }
2778 /* }}} */
2779 #endif /* HAVE_GD_WEBP */
2780 
2781 
2782 #ifdef HAVE_GD_JPG
2783 /* {{{ proto bool imagejpeg(resource im [, string filename [, int quality]])
2784    Output JPEG image to browser or file */
PHP_FUNCTION(imagejpeg)2785 PHP_FUNCTION(imagejpeg)
2786 {
2787 	_php_image_output_ctx(INTERNAL_FUNCTION_PARAM_PASSTHRU, PHP_GDIMG_TYPE_JPG, "JPEG", gdImageJpegCtx);
2788 }
2789 /* }}} */
2790 #endif /* HAVE_GD_JPG */
2791 
2792 /* {{{ proto bool imagewbmp(resource im [, string filename, [, int foreground]])
2793    Output WBMP image to browser or file */
PHP_FUNCTION(imagewbmp)2794 PHP_FUNCTION(imagewbmp)
2795 {
2796 	_php_image_output_ctx(INTERNAL_FUNCTION_PARAM_PASSTHRU, PHP_GDIMG_TYPE_WBM, "WBMP", gdImageWBMPCtx);
2797 }
2798 /* }}} */
2799 
2800 /* {{{ proto bool imagegd(resource im [, string filename])
2801    Output GD image to browser or file */
PHP_FUNCTION(imagegd)2802 PHP_FUNCTION(imagegd)
2803 {
2804 	_php_image_output(INTERNAL_FUNCTION_PARAM_PASSTHRU, PHP_GDIMG_TYPE_GD, "GD", gdImageGd);
2805 }
2806 /* }}} */
2807 
2808 /* {{{ proto bool imagegd2(resource im [, string filename, [, int chunk_size, [, int type]]])
2809    Output GD2 image to browser or file */
PHP_FUNCTION(imagegd2)2810 PHP_FUNCTION(imagegd2)
2811 {
2812 	_php_image_output(INTERNAL_FUNCTION_PARAM_PASSTHRU, PHP_GDIMG_TYPE_GD2, "GD2", gdImageGd2);
2813 }
2814 /* }}} */
2815 
2816 /* {{{ proto bool imagedestroy(resource im)
2817    Destroy an image */
PHP_FUNCTION(imagedestroy)2818 PHP_FUNCTION(imagedestroy)
2819 {
2820 	zval *IM;
2821 	gdImagePtr im;
2822 
2823 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &IM) == FAILURE) {
2824 		return;
2825 	}
2826 
2827 	ZEND_FETCH_RESOURCE(im, gdImagePtr, &IM, -1, "Image", le_gd);
2828 
2829 	zend_list_delete(Z_LVAL_P(IM));
2830 
2831 	RETURN_TRUE;
2832 }
2833 /* }}} */
2834 
2835 
2836 /* {{{ proto int imagecolorallocate(resource im, int red, int green, int blue)
2837    Allocate a color for an image */
PHP_FUNCTION(imagecolorallocate)2838 PHP_FUNCTION(imagecolorallocate)
2839 {
2840 	zval *IM;
2841 	long red, green, blue;
2842 	gdImagePtr im;
2843 	int ct = (-1);
2844 
2845 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rlll", &IM, &red, &green, &blue) == FAILURE) {
2846 		return;
2847 	}
2848 
2849 	ZEND_FETCH_RESOURCE(im, gdImagePtr, &IM, -1, "Image", le_gd);
2850 
2851 	ct = gdImageColorAllocate(im, red, green, blue);
2852 	if (ct < 0) {
2853 		RETURN_FALSE;
2854 	}
2855 	RETURN_LONG(ct);
2856 }
2857 /* }}} */
2858 
2859 /* {{{ proto void imagepalettecopy(resource dst, resource src)
2860    Copy the palette from the src image onto the dst image */
PHP_FUNCTION(imagepalettecopy)2861 PHP_FUNCTION(imagepalettecopy)
2862 {
2863 	zval *dstim, *srcim;
2864 	gdImagePtr dst, src;
2865 
2866 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rr", &dstim, &srcim) == FAILURE) {
2867 		return;
2868 	}
2869 
2870 	ZEND_FETCH_RESOURCE(dst, gdImagePtr, &dstim, -1, "Image", le_gd);
2871 	ZEND_FETCH_RESOURCE(src, gdImagePtr, &srcim, -1, "Image", le_gd);
2872 
2873 	gdImagePaletteCopy(dst, src);
2874 }
2875 /* }}} */
2876 
2877 /* {{{ proto int imagecolorat(resource im, int x, int y)
2878    Get the index of the color of a pixel */
PHP_FUNCTION(imagecolorat)2879 PHP_FUNCTION(imagecolorat)
2880 {
2881 	zval *IM;
2882 	long x, y;
2883 	gdImagePtr im;
2884 
2885 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rll", &IM, &x, &y) == FAILURE) {
2886 		return;
2887 	}
2888 
2889 	ZEND_FETCH_RESOURCE(im, gdImagePtr, &IM, -1, "Image", le_gd);
2890 
2891 	if (gdImageTrueColor(im)) {
2892 		if (im->tpixels && gdImageBoundsSafe(im, x, y)) {
2893 			RETURN_LONG(gdImageTrueColorPixel(im, x, y));
2894 		} else {
2895 			php_error_docref(NULL TSRMLS_CC, E_NOTICE, "%ld,%ld is out of bounds", x, y);
2896 			RETURN_FALSE;
2897 		}
2898 	} else {
2899 		if (im->pixels && gdImageBoundsSafe(im, x, y)) {
2900 			RETURN_LONG(im->pixels[y][x]);
2901 		} else {
2902 			php_error_docref(NULL TSRMLS_CC, E_NOTICE, "%ld,%ld is out of bounds", x, y);
2903 			RETURN_FALSE;
2904 		}
2905 	}
2906 }
2907 /* }}} */
2908 
2909 /* {{{ proto int imagecolorclosest(resource im, int red, int green, int blue)
2910    Get the index of the closest color to the specified color */
PHP_FUNCTION(imagecolorclosest)2911 PHP_FUNCTION(imagecolorclosest)
2912 {
2913 	zval *IM;
2914 	long red, green, blue;
2915 	gdImagePtr im;
2916 
2917 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rlll", &IM, &red, &green, &blue) == FAILURE) {
2918 		return;
2919 	}
2920 
2921 	ZEND_FETCH_RESOURCE(im, gdImagePtr, &IM, -1, "Image", le_gd);
2922 
2923 	RETURN_LONG(gdImageColorClosest(im, red, green, blue));
2924 }
2925 /* }}} */
2926 
2927 /* {{{ proto int imagecolorclosesthwb(resource im, int red, int green, int blue)
2928    Get the index of the color which has the hue, white and blackness nearest to the given color */
PHP_FUNCTION(imagecolorclosesthwb)2929 PHP_FUNCTION(imagecolorclosesthwb)
2930 {
2931 	zval *IM;
2932 	long red, green, blue;
2933 	gdImagePtr im;
2934 
2935 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rlll", &IM, &red, &green, &blue) == FAILURE) {
2936 		return;
2937 	}
2938 
2939 	ZEND_FETCH_RESOURCE(im, gdImagePtr, &IM, -1, "Image", le_gd);
2940 
2941 	RETURN_LONG(gdImageColorClosestHWB(im, red, green, blue));
2942 }
2943 /* }}} */
2944 
2945 /* {{{ proto bool imagecolordeallocate(resource im, int index)
2946    De-allocate a color for an image */
PHP_FUNCTION(imagecolordeallocate)2947 PHP_FUNCTION(imagecolordeallocate)
2948 {
2949 	zval *IM;
2950 	long index;
2951 	int col;
2952 	gdImagePtr im;
2953 
2954 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rl", &IM, &index) == FAILURE) {
2955 		return;
2956 	}
2957 
2958 	ZEND_FETCH_RESOURCE(im, gdImagePtr, &IM, -1, "Image", le_gd);
2959 
2960 	/* We can return right away for a truecolor image as deallocating colours is meaningless here */
2961 	if (gdImageTrueColor(im)) {
2962 		RETURN_TRUE;
2963 	}
2964 
2965 	col = index;
2966 
2967 	if (col >= 0 && col < gdImageColorsTotal(im)) {
2968 		gdImageColorDeallocate(im, col);
2969 		RETURN_TRUE;
2970 	} else {
2971 		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Color index %d out of range",	col);
2972 		RETURN_FALSE;
2973 	}
2974 }
2975 /* }}} */
2976 
2977 /* {{{ proto int imagecolorresolve(resource im, int red, int green, int blue)
2978    Get the index of the specified color or its closest possible alternative */
PHP_FUNCTION(imagecolorresolve)2979 PHP_FUNCTION(imagecolorresolve)
2980 {
2981 	zval *IM;
2982 	long red, green, blue;
2983 	gdImagePtr im;
2984 
2985 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rlll", &IM, &red, &green, &blue) == FAILURE) {
2986 		return;
2987 	}
2988 
2989 	ZEND_FETCH_RESOURCE(im, gdImagePtr, &IM, -1, "Image", le_gd);
2990 
2991 	RETURN_LONG(gdImageColorResolve(im, red, green, blue));
2992 }
2993 /* }}} */
2994 
2995 /* {{{ proto int imagecolorexact(resource im, int red, int green, int blue)
2996    Get the index of the specified color */
PHP_FUNCTION(imagecolorexact)2997 PHP_FUNCTION(imagecolorexact)
2998 {
2999 	zval *IM;
3000 	long red, green, blue;
3001 	gdImagePtr im;
3002 
3003 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rlll", &IM, &red, &green, &blue) == FAILURE) {
3004 		return;
3005 	}
3006 
3007 	ZEND_FETCH_RESOURCE(im, gdImagePtr, &IM, -1, "Image", le_gd);
3008 
3009 	RETURN_LONG(gdImageColorExact(im, red, green, blue));
3010 }
3011 /* }}} */
3012 
3013 /* {{{ proto void imagecolorset(resource im, int col, int red, int green, int blue)
3014    Set the color for the specified palette index */
PHP_FUNCTION(imagecolorset)3015 PHP_FUNCTION(imagecolorset)
3016 {
3017 	zval *IM;
3018 	long color, red, green, blue, alpha = 0;
3019 	int col;
3020 	gdImagePtr im;
3021 
3022 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rllll|l", &IM, &color, &red, &green, &blue, &alpha) == FAILURE) {
3023 		return;
3024 	}
3025 
3026 	ZEND_FETCH_RESOURCE(im, gdImagePtr, &IM, -1, "Image", le_gd);
3027 
3028 	col = color;
3029 
3030 	if (col >= 0 && col < gdImageColorsTotal(im)) {
3031 		im->red[col]   = red;
3032 		im->green[col] = green;
3033 		im->blue[col]  = blue;
3034 		im->alpha[col]  = alpha;
3035 	} else {
3036 		RETURN_FALSE;
3037 	}
3038 }
3039 /* }}} */
3040 
3041 /* {{{ proto array imagecolorsforindex(resource im, int col)
3042    Get the colors for an index */
PHP_FUNCTION(imagecolorsforindex)3043 PHP_FUNCTION(imagecolorsforindex)
3044 {
3045 	zval *IM;
3046 	long index;
3047 	int col;
3048 	gdImagePtr im;
3049 
3050 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rl", &IM, &index) == FAILURE) {
3051 		return;
3052 	}
3053 
3054 	ZEND_FETCH_RESOURCE(im, gdImagePtr, &IM, -1, "Image", le_gd);
3055 
3056 	col = index;
3057 
3058 	if ((col >= 0 && gdImageTrueColor(im)) || (!gdImageTrueColor(im) && col >= 0 && col < gdImageColorsTotal(im))) {
3059 		array_init(return_value);
3060 
3061 		add_assoc_long(return_value,"red",  gdImageRed(im,col));
3062 		add_assoc_long(return_value,"green", gdImageGreen(im,col));
3063 		add_assoc_long(return_value,"blue", gdImageBlue(im,col));
3064 		add_assoc_long(return_value,"alpha", gdImageAlpha(im,col));
3065 	} else {
3066 		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Color index %d out of range", col);
3067 		RETURN_FALSE;
3068 	}
3069 }
3070 /* }}} */
3071 
3072 /* {{{ proto bool imagegammacorrect(resource im, float inputgamma, float outputgamma)
3073    Apply a gamma correction to a GD image */
PHP_FUNCTION(imagegammacorrect)3074 PHP_FUNCTION(imagegammacorrect)
3075 {
3076 	zval *IM;
3077 	gdImagePtr im;
3078 	int i;
3079 	double input, output;
3080 
3081 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rdd", &IM, &input, &output) == FAILURE) {
3082 		return;
3083 	}
3084 
3085 	if ( input <= 0.0 || output <= 0.0 ) {
3086 		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Gamma values should be positive");
3087 		RETURN_FALSE;
3088 	}
3089 
3090 	ZEND_FETCH_RESOURCE(im, gdImagePtr, &IM, -1, "Image", le_gd);
3091 
3092 	if (gdImageTrueColor(im))	{
3093 		int x, y, c;
3094 
3095 		for (y = 0; y < gdImageSY(im); y++)	{
3096 			for (x = 0; x < gdImageSX(im); x++)	{
3097 				c = gdImageGetPixel(im, x, y);
3098 				gdImageSetPixel(im, x, y,
3099 					gdTrueColorAlpha(
3100 						(int) ((pow((pow((gdTrueColorGetRed(c)   / 255.0), input)), 1.0 / output) * 255) + .5),
3101 						(int) ((pow((pow((gdTrueColorGetGreen(c) / 255.0), input)), 1.0 / output) * 255) + .5),
3102 						(int) ((pow((pow((gdTrueColorGetBlue(c)  / 255.0), input)), 1.0 / output) * 255) + .5),
3103 						gdTrueColorGetAlpha(c)
3104 					)
3105 				);
3106 			}
3107 		}
3108 		RETURN_TRUE;
3109 	}
3110 
3111 	for (i = 0; i < gdImageColorsTotal(im); i++) {
3112 		im->red[i]   = (int)((pow((pow((im->red[i]   / 255.0), input)), 1.0 / output) * 255) + .5);
3113 		im->green[i] = (int)((pow((pow((im->green[i] / 255.0), input)), 1.0 / output) * 255) + .5);
3114 		im->blue[i]  = (int)((pow((pow((im->blue[i]  / 255.0), input)), 1.0 / output) * 255) + .5);
3115 	}
3116 
3117 	RETURN_TRUE;
3118 }
3119 /* }}} */
3120 
3121 /* {{{ proto bool imagesetpixel(resource im, int x, int y, int col)
3122    Set a single pixel */
PHP_FUNCTION(imagesetpixel)3123 PHP_FUNCTION(imagesetpixel)
3124 {
3125 	zval *IM;
3126 	long x, y, col;
3127 	gdImagePtr im;
3128 
3129 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rlll", &IM, &x, &y, &col) == FAILURE) {
3130 		return;
3131 	}
3132 
3133 	ZEND_FETCH_RESOURCE(im, gdImagePtr, &IM, -1, "Image", le_gd);
3134 	gdImageSetPixel(im, x, y, col);
3135 	RETURN_TRUE;
3136 }
3137 /* }}} */
3138 
3139 /* {{{ proto bool imageline(resource im, int x1, int y1, int x2, int y2, int col)
3140    Draw a line */
PHP_FUNCTION(imageline)3141 PHP_FUNCTION(imageline)
3142 {
3143 	zval *IM;
3144 	long x1, y1, x2, y2, col;
3145 	gdImagePtr im;
3146 
3147 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rlllll", &IM, &x1, &y1, &x2, &y2, &col) == FAILURE) {
3148 		return;
3149 	}
3150 
3151 	ZEND_FETCH_RESOURCE(im, gdImagePtr, &IM, -1, "Image", le_gd);
3152 
3153 #ifdef HAVE_GD_BUNDLED
3154 	if (im->antialias) {
3155 		gdImageAALine(im, x1, y1, x2, y2, col);
3156 	} else
3157 #endif
3158 	{
3159 		gdImageLine(im, x1, y1, x2, y2, col);
3160 	}
3161 	RETURN_TRUE;
3162 }
3163 /* }}} */
3164 
3165 /* {{{ proto bool imagedashedline(resource im, int x1, int y1, int x2, int y2, int col)
3166    Draw a dashed line */
PHP_FUNCTION(imagedashedline)3167 PHP_FUNCTION(imagedashedline)
3168 {
3169 	zval *IM;
3170 	long x1, y1, x2, y2, col;
3171 	gdImagePtr im;
3172 
3173 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rlllll", &IM, &x1, &y1, &x2, &y2, &col) == FAILURE) {
3174 		return;
3175 	}
3176 
3177 	ZEND_FETCH_RESOURCE(im, gdImagePtr, &IM, -1, "Image", le_gd);
3178 	gdImageDashedLine(im, x1, y1, x2, y2, col);
3179 	RETURN_TRUE;
3180 }
3181 /* }}} */
3182 
3183 /* {{{ proto bool imagerectangle(resource im, int x1, int y1, int x2, int y2, int col)
3184    Draw a rectangle */
PHP_FUNCTION(imagerectangle)3185 PHP_FUNCTION(imagerectangle)
3186 {
3187 	zval *IM;
3188 	long x1, y1, x2, y2, col;
3189 	gdImagePtr im;
3190 
3191 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rlllll", &IM, &x1, &y1, &x2, &y2, &col) == FAILURE) {
3192 		return;
3193 	}
3194 
3195 	ZEND_FETCH_RESOURCE(im, gdImagePtr, &IM, -1, "Image", le_gd);
3196 	gdImageRectangle(im, x1, y1, x2, y2, col);
3197 	RETURN_TRUE;
3198 }
3199 /* }}} */
3200 
3201 /* {{{ proto bool imagefilledrectangle(resource im, int x1, int y1, int x2, int y2, int col)
3202    Draw a filled rectangle */
PHP_FUNCTION(imagefilledrectangle)3203 PHP_FUNCTION(imagefilledrectangle)
3204 {
3205 	zval *IM;
3206 	long x1, y1, x2, y2, col;
3207 	gdImagePtr im;
3208 
3209 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rlllll", &IM, &x1, &y1, &x2, &y2, &col) == FAILURE) {
3210 		return;
3211 	}
3212 
3213 	ZEND_FETCH_RESOURCE(im, gdImagePtr, &IM, -1, "Image", le_gd);
3214 	gdImageFilledRectangle(im, x1, y1, x2, y2, col);
3215 	RETURN_TRUE;
3216 }
3217 /* }}} */
3218 
3219 /* {{{ proto bool imagearc(resource im, int cx, int cy, int w, int h, int s, int e, int col)
3220    Draw a partial ellipse */
PHP_FUNCTION(imagearc)3221 PHP_FUNCTION(imagearc)
3222 {
3223 	zval *IM;
3224 	long cx, cy, w, h, ST, E, col;
3225 	gdImagePtr im;
3226 	int e, st;
3227 
3228 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rlllllll", &IM, &cx, &cy, &w, &h, &ST, &E, &col) == FAILURE) {
3229 		return;
3230 	}
3231 
3232 	ZEND_FETCH_RESOURCE(im, gdImagePtr, &IM, -1, "Image", le_gd);
3233 
3234 	e = E;
3235 	if (e < 0) {
3236 		e %= 360;
3237 	}
3238 
3239 	st = ST;
3240 	if (st < 0) {
3241 		st %= 360;
3242 	}
3243 
3244 	gdImageArc(im, cx, cy, w, h, st, e, col);
3245 	RETURN_TRUE;
3246 }
3247 /* }}} */
3248 
3249 /* {{{ proto bool imageellipse(resource im, int cx, int cy, int w, int h, int color)
3250    Draw an ellipse */
PHP_FUNCTION(imageellipse)3251 PHP_FUNCTION(imageellipse)
3252 {
3253 	zval *IM;
3254 	long cx, cy, w, h, color;
3255 	gdImagePtr im;
3256 
3257 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rlllll", &IM, &cx, &cy, &w, &h, &color) == FAILURE) {
3258 		return;
3259 	}
3260 
3261 	ZEND_FETCH_RESOURCE(im, gdImagePtr, &IM, -1, "Image", le_gd);
3262 
3263 	gdImageEllipse(im, cx, cy, w, h, color);
3264 	RETURN_TRUE;
3265 }
3266 /* }}} */
3267 
3268 /* {{{ proto bool imagefilltoborder(resource im, int x, int y, int border, int col)
3269    Flood fill to specific color */
PHP_FUNCTION(imagefilltoborder)3270 PHP_FUNCTION(imagefilltoborder)
3271 {
3272 	zval *IM;
3273 	long x, y, border, col;
3274 	gdImagePtr im;
3275 
3276 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rllll", &IM, &x, &y, &border, &col) == FAILURE) {
3277 		return;
3278 	}
3279 
3280 	ZEND_FETCH_RESOURCE(im, gdImagePtr, &IM, -1, "Image", le_gd);
3281 	gdImageFillToBorder(im, x, y, border, col);
3282 	RETURN_TRUE;
3283 }
3284 /* }}} */
3285 
3286 /* {{{ proto bool imagefill(resource im, int x, int y, int col)
3287    Flood fill */
PHP_FUNCTION(imagefill)3288 PHP_FUNCTION(imagefill)
3289 {
3290 	zval *IM;
3291 	long x, y, col;
3292 	gdImagePtr im;
3293 
3294 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rlll", &IM, &x, &y, &col) == FAILURE) {
3295 		return;
3296 	}
3297 
3298 	ZEND_FETCH_RESOURCE(im, gdImagePtr, &IM, -1, "Image", le_gd);
3299 	gdImageFill(im, x, y, col);
3300 	RETURN_TRUE;
3301 }
3302 /* }}} */
3303 
3304 /* {{{ proto int imagecolorstotal(resource im)
3305    Find out the number of colors in an image's palette */
PHP_FUNCTION(imagecolorstotal)3306 PHP_FUNCTION(imagecolorstotal)
3307 {
3308 	zval *IM;
3309 	gdImagePtr im;
3310 
3311 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &IM) == FAILURE) {
3312 		return;
3313 	}
3314 
3315 	ZEND_FETCH_RESOURCE(im, gdImagePtr, &IM, -1, "Image", le_gd);
3316 
3317 	RETURN_LONG(gdImageColorsTotal(im));
3318 }
3319 /* }}} */
3320 
3321 /* {{{ proto int imagecolortransparent(resource im [, int col])
3322    Define a color as transparent */
PHP_FUNCTION(imagecolortransparent)3323 PHP_FUNCTION(imagecolortransparent)
3324 {
3325 	zval *IM;
3326 	long COL = 0;
3327 	gdImagePtr im;
3328 	int argc = ZEND_NUM_ARGS();
3329 
3330 	if (zend_parse_parameters(argc TSRMLS_CC, "r|l", &IM, &COL) == FAILURE) {
3331 		return;
3332 	}
3333 
3334 	ZEND_FETCH_RESOURCE(im, gdImagePtr, &IM, -1, "Image", le_gd);
3335 
3336 	if (argc > 1) {
3337 		gdImageColorTransparent(im, COL);
3338 	}
3339 
3340 	RETURN_LONG(gdImageGetTransparent(im));
3341 }
3342 /* }}} */
3343 
3344 /* {{{ proto int imageinterlace(resource im [, int interlace])
3345    Enable or disable interlace */
PHP_FUNCTION(imageinterlace)3346 PHP_FUNCTION(imageinterlace)
3347 {
3348 	zval *IM;
3349 	int argc = ZEND_NUM_ARGS();
3350 	long INT = 0;
3351 	gdImagePtr im;
3352 
3353 	if (zend_parse_parameters(argc TSRMLS_CC, "r|l", &IM, &INT) == FAILURE) {
3354 		return;
3355 	}
3356 
3357 	ZEND_FETCH_RESOURCE(im, gdImagePtr, &IM, -1, "Image", le_gd);
3358 
3359 	if (argc > 1) {
3360 		gdImageInterlace(im, INT);
3361 	}
3362 
3363 	RETURN_LONG(gdImageGetInterlaced(im));
3364 }
3365 /* }}} */
3366 
3367 /* {{{ php_imagepolygon
3368    arg = 0  normal polygon
3369    arg = 1  filled polygon */
3370 /* im, points, num_points, col */
php_imagepolygon(INTERNAL_FUNCTION_PARAMETERS,int filled)3371 static void php_imagepolygon(INTERNAL_FUNCTION_PARAMETERS, int filled)
3372 {
3373 	zval *IM, *POINTS;
3374 	long NPOINTS, COL;
3375 	zval **var = NULL;
3376 	gdImagePtr im;
3377 	gdPointPtr points;
3378 	int npoints, col, nelem, i;
3379 
3380 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rall", &IM, &POINTS, &NPOINTS, &COL) == FAILURE) {
3381 		return;
3382 	}
3383 
3384 	ZEND_FETCH_RESOURCE(im, gdImagePtr, &IM, -1, "Image", le_gd);
3385 
3386 	npoints = NPOINTS;
3387 	col = COL;
3388 
3389 	nelem = zend_hash_num_elements(Z_ARRVAL_P(POINTS));
3390 	if (nelem < 6) {
3391 		php_error_docref(NULL TSRMLS_CC, E_WARNING, "You must have at least 3 points in your array");
3392 		RETURN_FALSE;
3393 	}
3394 	if (npoints <= 0) {
3395 		php_error_docref(NULL TSRMLS_CC, E_WARNING, "You must give a positive number of points");
3396 		RETURN_FALSE;
3397 	}
3398 	if (nelem < npoints * 2) {
3399 		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Trying to use %d points in array with only %d points", npoints, nelem/2);
3400 		RETURN_FALSE;
3401 	}
3402 
3403 	points = (gdPointPtr) safe_emalloc(npoints, sizeof(gdPoint), 0);
3404 
3405 	for (i = 0; i < npoints; i++) {
3406 		if (zend_hash_index_find(Z_ARRVAL_P(POINTS), (i * 2), (void **) &var) == SUCCESS) {
3407 			if (Z_TYPE_PP(var) != IS_LONG) {
3408 				zval lval;
3409 				lval = **var;
3410 				zval_copy_ctor(&lval);
3411 				convert_to_long(&lval);
3412 				points[i].x = Z_LVAL(lval);
3413 			} else {
3414 				points[i].x = Z_LVAL_PP(var);
3415 			}
3416 		}
3417 		if (zend_hash_index_find(Z_ARRVAL_P(POINTS), (i * 2) + 1, (void **) &var) == SUCCESS) {
3418 			if (Z_TYPE_PP(var) != IS_LONG) {
3419 				zval lval;
3420 				lval = **var;
3421 				zval_copy_ctor(&lval);
3422 				convert_to_long(&lval);
3423 				points[i].y = Z_LVAL(lval);
3424 			} else {
3425 				points[i].y = Z_LVAL_PP(var);
3426 			}
3427 		}
3428 	}
3429 
3430 	if (filled) {
3431 		gdImageFilledPolygon(im, points, npoints, col);
3432 	} else {
3433 		gdImagePolygon(im, points, npoints, col);
3434 	}
3435 
3436 	efree(points);
3437 	RETURN_TRUE;
3438 }
3439 /* }}} */
3440 
3441 /* {{{ proto bool imagepolygon(resource im, array point, int num_points, int col)
3442    Draw a polygon */
PHP_FUNCTION(imagepolygon)3443 PHP_FUNCTION(imagepolygon)
3444 {
3445 	php_imagepolygon(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0);
3446 }
3447 /* }}} */
3448 
3449 /* {{{ proto bool imagefilledpolygon(resource im, array point, int num_points, int col)
3450    Draw a filled polygon */
PHP_FUNCTION(imagefilledpolygon)3451 PHP_FUNCTION(imagefilledpolygon)
3452 {
3453 	php_imagepolygon(INTERNAL_FUNCTION_PARAM_PASSTHRU, 1);
3454 }
3455 /* }}} */
3456 
3457 /* {{{ php_find_gd_font
3458  */
php_find_gd_font(int size TSRMLS_DC)3459 static gdFontPtr php_find_gd_font(int size TSRMLS_DC)
3460 {
3461 	gdFontPtr font;
3462 	int ind_type;
3463 
3464 	switch (size) {
3465 		case 1:
3466 			 font = gdFontTiny;
3467 			 break;
3468 		case 2:
3469 			 font = gdFontSmall;
3470 			 break;
3471 		case 3:
3472 			 font = gdFontMediumBold;
3473 			 break;
3474 		case 4:
3475 			 font = gdFontLarge;
3476 			 break;
3477 		case 5:
3478 			 font = gdFontGiant;
3479 			 break;
3480 		default:
3481 			font = zend_list_find(size - 5, &ind_type);
3482 			 if (!font || ind_type != le_gd_font) {
3483 				  if (size < 1) {
3484 					   font = gdFontTiny;
3485 				  } else {
3486 					   font = gdFontGiant;
3487 				  }
3488 			 }
3489 			 break;
3490 	}
3491 
3492 	return font;
3493 }
3494 /* }}} */
3495 
3496 /* {{{ php_imagefontsize
3497  * arg = 0  ImageFontWidth
3498  * arg = 1  ImageFontHeight
3499  */
php_imagefontsize(INTERNAL_FUNCTION_PARAMETERS,int arg)3500 static void php_imagefontsize(INTERNAL_FUNCTION_PARAMETERS, int arg)
3501 {
3502 	long SIZE;
3503 	gdFontPtr font;
3504 
3505 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &SIZE) == FAILURE) {
3506 		return;
3507 	}
3508 
3509 	font = php_find_gd_font(SIZE TSRMLS_CC);
3510 	RETURN_LONG(arg ? font->h : font->w);
3511 }
3512 /* }}} */
3513 
3514 /* {{{ proto int imagefontwidth(int font)
3515    Get font width */
PHP_FUNCTION(imagefontwidth)3516 PHP_FUNCTION(imagefontwidth)
3517 {
3518 	php_imagefontsize(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0);
3519 }
3520 /* }}} */
3521 
3522 /* {{{ proto int imagefontheight(int font)
3523    Get font height */
PHP_FUNCTION(imagefontheight)3524 PHP_FUNCTION(imagefontheight)
3525 {
3526 	php_imagefontsize(INTERNAL_FUNCTION_PARAM_PASSTHRU, 1);
3527 }
3528 /* }}} */
3529 
3530 /* {{{ php_gdimagecharup
3531  * workaround for a bug in gd 1.2 */
php_gdimagecharup(gdImagePtr im,gdFontPtr f,int x,int y,int c,int color)3532 static void php_gdimagecharup(gdImagePtr im, gdFontPtr f, int x, int y, int c, int color)
3533 {
3534 	int cx, cy, px, py, fline;
3535 	cx = 0;
3536 	cy = 0;
3537 
3538 	if ((c < f->offset) || (c >= (f->offset + f->nchars))) {
3539 		return;
3540 	}
3541 
3542 	fline = (c - f->offset) * f->h * f->w;
3543 	for (py = y; (py > (y - f->w)); py--) {
3544 		for (px = x; (px < (x + f->h)); px++) {
3545 			if (f->data[fline + cy * f->w + cx]) {
3546 				gdImageSetPixel(im, px, py, color);
3547 			}
3548 			cy++;
3549 		}
3550 		cy = 0;
3551 		cx++;
3552 	}
3553 }
3554 /* }}} */
3555 
3556 /* {{{ php_imagechar
3557  * arg = 0  ImageChar
3558  * arg = 1  ImageCharUp
3559  * arg = 2  ImageString
3560  * arg = 3  ImageStringUp
3561  */
php_imagechar(INTERNAL_FUNCTION_PARAMETERS,int mode)3562 static void php_imagechar(INTERNAL_FUNCTION_PARAMETERS, int mode)
3563 {
3564 	zval *IM;
3565 	long SIZE, X, Y, COL;
3566 	char *C;
3567 	int C_len;
3568 	gdImagePtr im;
3569 	int ch = 0, col, x, y, size, i, l = 0;
3570 	unsigned char *str = NULL;
3571 	gdFontPtr font;
3572 
3573 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rlllsl", &IM, &SIZE, &X, &Y, &C, &C_len, &COL) == FAILURE) {
3574 		return;
3575 	}
3576 
3577 	ZEND_FETCH_RESOURCE(im, gdImagePtr, &IM, -1, "Image", le_gd);
3578 
3579 	col = COL;
3580 
3581 	if (mode < 2) {
3582 		ch = (int)((unsigned char)*C);
3583 	} else {
3584 		str = (unsigned char *) estrndup(C, C_len);
3585 		l = strlen((char *)str);
3586 	}
3587 
3588 	y = Y;
3589 	x = X;
3590 	size = SIZE;
3591 
3592 	font = php_find_gd_font(size TSRMLS_CC);
3593 
3594 	switch (mode) {
3595 		case 0:
3596 			gdImageChar(im, font, x, y, ch, col);
3597 			break;
3598 		case 1:
3599 			php_gdimagecharup(im, font, x, y, ch, col);
3600 			break;
3601 		case 2:
3602 			for (i = 0; (i < l); i++) {
3603 				gdImageChar(im, font, x, y, (int) ((unsigned char) str[i]), col);
3604 				x += font->w;
3605 			}
3606 			break;
3607 		case 3: {
3608 			for (i = 0; (i < l); i++) {
3609 				/* php_gdimagecharup(im, font, x, y, (int) str[i], col); */
3610 				gdImageCharUp(im, font, x, y, (int) str[i], col);
3611 				y -= font->w;
3612 			}
3613 			break;
3614 		}
3615 	}
3616 	if (str) {
3617 		efree(str);
3618 	}
3619 	RETURN_TRUE;
3620 }
3621 /* }}} */
3622 
3623 /* {{{ proto bool imagechar(resource im, int font, int x, int y, string c, int col)
3624    Draw a character */
PHP_FUNCTION(imagechar)3625 PHP_FUNCTION(imagechar)
3626 {
3627 	php_imagechar(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0);
3628 }
3629 /* }}} */
3630 
3631 /* {{{ proto bool imagecharup(resource im, int font, int x, int y, string c, int col)
3632    Draw a character rotated 90 degrees counter-clockwise */
PHP_FUNCTION(imagecharup)3633 PHP_FUNCTION(imagecharup)
3634 {
3635 	php_imagechar(INTERNAL_FUNCTION_PARAM_PASSTHRU, 1);
3636 }
3637 /* }}} */
3638 
3639 /* {{{ proto bool imagestring(resource im, int font, int x, int y, string str, int col)
3640    Draw a string horizontally */
PHP_FUNCTION(imagestring)3641 PHP_FUNCTION(imagestring)
3642 {
3643 	php_imagechar(INTERNAL_FUNCTION_PARAM_PASSTHRU, 2);
3644 }
3645 /* }}} */
3646 
3647 /* {{{ proto bool imagestringup(resource im, int font, int x, int y, string str, int col)
3648    Draw a string vertically - rotated 90 degrees counter-clockwise */
PHP_FUNCTION(imagestringup)3649 PHP_FUNCTION(imagestringup)
3650 {
3651 	php_imagechar(INTERNAL_FUNCTION_PARAM_PASSTHRU, 3);
3652 }
3653 /* }}} */
3654 
3655 /* {{{ proto bool imagecopy(resource dst_im, resource src_im, int dst_x, int dst_y, int src_x, int src_y, int src_w, int src_h)
3656    Copy part of an image */
PHP_FUNCTION(imagecopy)3657 PHP_FUNCTION(imagecopy)
3658 {
3659 	zval *SIM, *DIM;
3660 	long SX, SY, SW, SH, DX, DY;
3661 	gdImagePtr im_dst, im_src;
3662 	int srcH, srcW, srcY, srcX, dstY, dstX;
3663 
3664 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rrllllll", &DIM, &SIM, &DX, &DY, &SX, &SY, &SW, &SH) == FAILURE) {
3665 		return;
3666 	}
3667 
3668 	ZEND_FETCH_RESOURCE(im_src, gdImagePtr, &SIM, -1, "Image", le_gd);
3669 	ZEND_FETCH_RESOURCE(im_dst, gdImagePtr, &DIM, -1, "Image", le_gd);
3670 
3671 	srcX = SX;
3672 	srcY = SY;
3673 	srcH = SH;
3674 	srcW = SW;
3675 	dstX = DX;
3676 	dstY = DY;
3677 
3678 	gdImageCopy(im_dst, im_src, dstX, dstY, srcX, srcY, srcW, srcH);
3679 	RETURN_TRUE;
3680 }
3681 /* }}} */
3682 
3683 /* {{{ proto bool imagecopymerge(resource src_im, resource dst_im, int dst_x, int dst_y, int src_x, int src_y, int src_w, int src_h, int pct)
3684    Merge one part of an image with another */
PHP_FUNCTION(imagecopymerge)3685 PHP_FUNCTION(imagecopymerge)
3686 {
3687 	zval *SIM, *DIM;
3688 	long SX, SY, SW, SH, DX, DY, PCT;
3689 	gdImagePtr im_dst, im_src;
3690 	int srcH, srcW, srcY, srcX, dstY, dstX, pct;
3691 
3692 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rrlllllll", &DIM, &SIM, &DX, &DY, &SX, &SY, &SW, &SH, &PCT) == FAILURE) {
3693 		return;
3694 	}
3695 
3696 	ZEND_FETCH_RESOURCE(im_src, gdImagePtr, &SIM, -1, "Image", le_gd);
3697 	ZEND_FETCH_RESOURCE(im_dst, gdImagePtr, &DIM, -1, "Image", le_gd);
3698 
3699 	srcX = SX;
3700 	srcY = SY;
3701 	srcH = SH;
3702 	srcW = SW;
3703 	dstX = DX;
3704 	dstY = DY;
3705 	pct  = PCT;
3706 
3707 	gdImageCopyMerge(im_dst, im_src, dstX, dstY, srcX, srcY, srcW, srcH, pct);
3708 	RETURN_TRUE;
3709 }
3710 /* }}} */
3711 
3712 /* {{{ proto bool imagecopymergegray(resource src_im, resource dst_im, int dst_x, int dst_y, int src_x, int src_y, int src_w, int src_h, int pct)
3713    Merge one part of an image with another */
PHP_FUNCTION(imagecopymergegray)3714 PHP_FUNCTION(imagecopymergegray)
3715 {
3716 	zval *SIM, *DIM;
3717 	long SX, SY, SW, SH, DX, DY, PCT;
3718 	gdImagePtr im_dst, im_src;
3719 	int srcH, srcW, srcY, srcX, dstY, dstX, pct;
3720 
3721 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rrlllllll", &DIM, &SIM, &DX, &DY, &SX, &SY, &SW, &SH, &PCT) == FAILURE) {
3722 		return;
3723 	}
3724 
3725 	ZEND_FETCH_RESOURCE(im_src, gdImagePtr, &SIM, -1, "Image", le_gd);
3726 	ZEND_FETCH_RESOURCE(im_dst, gdImagePtr, &DIM, -1, "Image", le_gd);
3727 
3728 	srcX = SX;
3729 	srcY = SY;
3730 	srcH = SH;
3731 	srcW = SW;
3732 	dstX = DX;
3733 	dstY = DY;
3734 	pct  = PCT;
3735 
3736 	gdImageCopyMergeGray(im_dst, im_src, dstX, dstY, srcX, srcY, srcW, srcH, pct);
3737 	RETURN_TRUE;
3738 }
3739 /* }}} */
3740 
3741 /* {{{ proto bool imagecopyresized(resource dst_im, resource src_im, int dst_x, int dst_y, int src_x, int src_y, int dst_w, int dst_h, int src_w, int src_h)
3742    Copy and resize part of an image */
PHP_FUNCTION(imagecopyresized)3743 PHP_FUNCTION(imagecopyresized)
3744 {
3745 	zval *SIM, *DIM;
3746 	long SX, SY, SW, SH, DX, DY, DW, DH;
3747 	gdImagePtr im_dst, im_src;
3748 	int srcH, srcW, dstH, dstW, srcY, srcX, dstY, dstX;
3749 
3750 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rrllllllll", &DIM, &SIM, &DX, &DY, &SX, &SY, &DW, &DH, &SW, &SH) == FAILURE) {
3751 		return;
3752 	}
3753 
3754 	ZEND_FETCH_RESOURCE(im_dst, gdImagePtr, &DIM, -1, "Image", le_gd);
3755 	ZEND_FETCH_RESOURCE(im_src, gdImagePtr, &SIM, -1, "Image", le_gd);
3756 
3757 	srcX = SX;
3758 	srcY = SY;
3759 	srcH = SH;
3760 	srcW = SW;
3761 	dstX = DX;
3762 	dstY = DY;
3763 	dstH = DH;
3764 	dstW = DW;
3765 
3766 	if (dstW <= 0 || dstH <= 0 || srcW <= 0 || srcH <= 0) {
3767 		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid image dimensions");
3768 		RETURN_FALSE;
3769 	}
3770 
3771 	gdImageCopyResized(im_dst, im_src, dstX, dstY, srcX, srcY, dstW, dstH, srcW, srcH);
3772 	RETURN_TRUE;
3773 }
3774 /* }}} */
3775 
3776 /* {{{ proto int imagesx(resource im)
3777    Get image width */
PHP_FUNCTION(imagesx)3778 PHP_FUNCTION(imagesx)
3779 {
3780 	zval *IM;
3781 	gdImagePtr im;
3782 
3783 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &IM) == FAILURE) {
3784 		return;
3785 	}
3786 
3787 	ZEND_FETCH_RESOURCE(im, gdImagePtr, &IM, -1, "Image", le_gd);
3788 
3789 	RETURN_LONG(gdImageSX(im));
3790 }
3791 /* }}} */
3792 
3793 /* {{{ proto int imagesy(resource im)
3794    Get image height */
PHP_FUNCTION(imagesy)3795 PHP_FUNCTION(imagesy)
3796 {
3797 	zval *IM;
3798 	gdImagePtr im;
3799 
3800 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &IM) == FAILURE) {
3801 		return;
3802 	}
3803 
3804 	ZEND_FETCH_RESOURCE(im, gdImagePtr, &IM, -1, "Image", le_gd);
3805 
3806 	RETURN_LONG(gdImageSY(im));
3807 }
3808 /* }}} */
3809 
3810 #ifdef ENABLE_GD_TTF
3811 #define TTFTEXT_DRAW 0
3812 #define TTFTEXT_BBOX 1
3813 #endif
3814 
3815 #ifdef ENABLE_GD_TTF
3816 
3817 #if HAVE_GD_FREETYPE && HAVE_LIBFREETYPE
3818 /* {{{ proto array imageftbbox(float size, float angle, string font_file, string text [, array extrainfo])
3819    Give the bounding box of a text using fonts via freetype2 */
PHP_FUNCTION(imageftbbox)3820 PHP_FUNCTION(imageftbbox)
3821 {
3822 	php_imagettftext_common(INTERNAL_FUNCTION_PARAM_PASSTHRU, TTFTEXT_BBOX, 1);
3823 }
3824 /* }}} */
3825 
3826 /* {{{ proto array imagefttext(resource im, float size, float angle, int x, int y, int col, string font_file, string text [, array extrainfo])
3827    Write text to the image using fonts via freetype2 */
PHP_FUNCTION(imagefttext)3828 PHP_FUNCTION(imagefttext)
3829 {
3830 	php_imagettftext_common(INTERNAL_FUNCTION_PARAM_PASSTHRU, TTFTEXT_DRAW, 1);
3831 }
3832 /* }}} */
3833 #endif /* HAVE_GD_FREETYPE && HAVE_LIBFREETYPE */
3834 
3835 /* {{{ proto array imagettfbbox(float size, float angle, string font_file, string text)
3836    Give the bounding box of a text using TrueType fonts */
PHP_FUNCTION(imagettfbbox)3837 PHP_FUNCTION(imagettfbbox)
3838 {
3839 	php_imagettftext_common(INTERNAL_FUNCTION_PARAM_PASSTHRU, TTFTEXT_BBOX, 0);
3840 }
3841 /* }}} */
3842 
3843 /* {{{ proto array imagettftext(resource im, float size, float angle, int x, int y, int col, string font_file, string text)
3844    Write text to the image using a TrueType font */
PHP_FUNCTION(imagettftext)3845 PHP_FUNCTION(imagettftext)
3846 {
3847 	php_imagettftext_common(INTERNAL_FUNCTION_PARAM_PASSTHRU, TTFTEXT_DRAW, 0);
3848 }
3849 /* }}} */
3850 
3851 /* {{{ php_imagettftext_common
3852  */
php_imagettftext_common(INTERNAL_FUNCTION_PARAMETERS,int mode,int extended)3853 static void php_imagettftext_common(INTERNAL_FUNCTION_PARAMETERS, int mode, int extended)
3854 {
3855 	zval *IM, *EXT = NULL;
3856 	gdImagePtr im=NULL;
3857 	long col = -1, x = 0, y = 0;
3858 	int str_len, fontname_len, i, brect[8];
3859 	double ptsize, angle;
3860 	char *str = NULL, *fontname = NULL;
3861 	char *error = NULL;
3862 	int argc = ZEND_NUM_ARGS();
3863 	gdFTStringExtra strex = {0};
3864 
3865 	if (mode == TTFTEXT_BBOX) {
3866 		if (argc < 4 || argc > ((extended) ? 5 : 4)) {
3867 			ZEND_WRONG_PARAM_COUNT();
3868 		} else if (zend_parse_parameters(argc TSRMLS_CC, "ddss|a", &ptsize, &angle, &fontname, &fontname_len, &str, &str_len, &EXT) == FAILURE) {
3869 			RETURN_FALSE;
3870 		}
3871 	} else {
3872 		if (argc < 8 || argc > ((extended) ? 9 : 8)) {
3873 			ZEND_WRONG_PARAM_COUNT();
3874 		} else if (zend_parse_parameters(argc TSRMLS_CC, "rddlllss|a", &IM, &ptsize, &angle, &x, &y, &col, &fontname, &fontname_len, &str, &str_len, &EXT) == FAILURE) {
3875 			RETURN_FALSE;
3876 		}
3877 		ZEND_FETCH_RESOURCE(im, gdImagePtr, &IM, -1, "Image", le_gd);
3878 	}
3879 
3880 	/* convert angle to radians */
3881 	angle = angle * (M_PI/180);
3882 
3883 	if (extended && EXT) {	/* parse extended info */
3884 		HashPosition pos;
3885 
3886 		/* walk the assoc array */
3887 		zend_hash_internal_pointer_reset_ex(HASH_OF(EXT), &pos);
3888 		do {
3889 			zval ** item;
3890 			char * key;
3891 			ulong num_key;
3892 
3893 			if (zend_hash_get_current_key_ex(HASH_OF(EXT), &key, NULL, &num_key, 0, &pos) != HASH_KEY_IS_STRING) {
3894 				continue;
3895 			}
3896 
3897 			if (zend_hash_get_current_data_ex(HASH_OF(EXT), (void **) &item, &pos) == FAILURE) {
3898 				continue;
3899 			}
3900 
3901 			if (strcmp("linespacing", key) == 0) {
3902 				convert_to_double_ex(item);
3903 				strex.flags |= gdFTEX_LINESPACE;
3904 				strex.linespacing = Z_DVAL_PP(item);
3905 			}
3906 
3907 		} while (zend_hash_move_forward_ex(HASH_OF(EXT), &pos) == SUCCESS);
3908 	}
3909 
3910 #ifdef VIRTUAL_DIR
3911 	{
3912 		char tmp_font_path[MAXPATHLEN];
3913 
3914 		if (!VCWD_REALPATH(fontname, tmp_font_path)) {
3915 			fontname = NULL;
3916 		}
3917 	}
3918 #endif /* VIRTUAL_DIR */
3919 
3920 	PHP_GD_CHECK_OPEN_BASEDIR(fontname, "Invalid font filename");
3921 
3922 #ifdef HAVE_GD_FREETYPE
3923 	if (extended) {
3924 		error = gdImageStringFTEx(im, brect, col, fontname, ptsize, angle, x, y, str, &strex);
3925 	}
3926 	else
3927 		error = gdImageStringFT(im, brect, col, fontname, ptsize, angle, x, y, str);
3928 
3929 #endif /* HAVE_GD_FREETYPE */
3930 
3931 	if (error) {
3932 		php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", error);
3933 		RETURN_FALSE;
3934 	}
3935 
3936 	array_init(return_value);
3937 
3938 	/* return array with the text's bounding box */
3939 	for (i = 0; i < 8; i++) {
3940 		add_next_index_long(return_value, brect[i]);
3941 	}
3942 }
3943 /* }}} */
3944 #endif	/* ENABLE_GD_TTF */
3945 
3946 #if HAVE_LIBT1
3947 
3948 /* {{{ php_free_ps_font
3949  */
php_free_ps_font(zend_rsrc_list_entry * rsrc TSRMLS_DC)3950 static void php_free_ps_font(zend_rsrc_list_entry *rsrc TSRMLS_DC)
3951 {
3952 	int *font = (int *) rsrc->ptr;
3953 
3954 	T1_DeleteFont(*font);
3955 	efree(font);
3956 }
3957 /* }}} */
3958 
3959 /* {{{ php_free_ps_enc
3960  */
php_free_ps_enc(zend_rsrc_list_entry * rsrc TSRMLS_DC)3961 static void php_free_ps_enc(zend_rsrc_list_entry *rsrc TSRMLS_DC)
3962 {
3963 	char **enc = (char **) rsrc->ptr;
3964 
3965 	T1_DeleteEncoding(enc);
3966 }
3967 /* }}} */
3968 
3969 /* {{{ proto resource imagepsloadfont(string pathname)
3970    Load a new font from specified file */
PHP_FUNCTION(imagepsloadfont)3971 PHP_FUNCTION(imagepsloadfont)
3972 {
3973 	char *file;
3974 	int file_len, f_ind, *font;
3975 #ifdef PHP_WIN32
3976 	struct stat st;
3977 #endif
3978 
3979 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "p", &file, &file_len) == FAILURE) {
3980 		return;
3981 	}
3982 
3983 #ifdef PHP_WIN32
3984 	if (VCWD_STAT(file, &st) < 0) {
3985 		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Font file not found (%s)", file);
3986 		RETURN_FALSE;
3987 	}
3988 #endif
3989 
3990 	f_ind = T1_AddFont(file);
3991 
3992 	if (f_ind < 0) {
3993 		php_error_docref(NULL TSRMLS_CC, E_WARNING, "T1Lib Error (%i): %s", f_ind, T1_StrError(f_ind));
3994 		RETURN_FALSE;
3995 	}
3996 
3997 	if (T1_LoadFont(f_ind)) {
3998 		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Couldn't load the font");
3999 		RETURN_FALSE;
4000 	}
4001 
4002 	font = (int *) emalloc(sizeof(int));
4003 	*font = f_ind;
4004 	ZEND_REGISTER_RESOURCE(return_value, font, le_ps_font);
4005 }
4006 /* }}} */
4007 
4008 /* {{{ proto int imagepscopyfont(int font_index)
4009    Make a copy of a font for purposes like extending or reenconding */
4010 /* The function in t1lib which this function uses seem to be buggy...
4011 PHP_FUNCTION(imagepscopyfont)
4012 {
4013 	int l_ind, type;
4014 	gd_ps_font *nf_ind, *of_ind;
4015 	long fnt;
4016 
4017 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &fnt) == FAILURE) {
4018 		return;
4019 	}
4020 
4021 	of_ind = zend_list_find(fnt, &type);
4022 
4023 	if (type != le_ps_font) {
4024 		php_error_docref(NULL TSRMLS_CC, E_WARNING, "%ld is not a Type 1 font index", fnt);
4025 		RETURN_FALSE;
4026 	}
4027 
4028 	nf_ind = emalloc(sizeof(gd_ps_font));
4029 	nf_ind->font_id = T1_CopyFont(of_ind->font_id);
4030 
4031 	if (nf_ind->font_id < 0) {
4032 		l_ind = nf_ind->font_id;
4033 		efree(nf_ind);
4034 		switch (l_ind) {
4035 			case -1:
4036 				php_error_docref(NULL TSRMLS_CC, E_WARNING, "FontID %d is not loaded in memory", l_ind);
4037 				RETURN_FALSE;
4038 				break;
4039 			case -2:
4040 				php_error_docref(NULL TSRMLS_CC, E_WARNING, "Tried to copy a logical font");
4041 				RETURN_FALSE;
4042 				break;
4043 			case -3:
4044 				php_error_docref(NULL TSRMLS_CC, E_WARNING, "Memory allocation fault in t1lib");
4045 				RETURN_FALSE;
4046 				break;
4047 			default:
4048 				php_error_docref(NULL TSRMLS_CC, E_WARNING, "An unknown error occurred in t1lib");
4049 				RETURN_FALSE;
4050 				break;
4051 		}
4052 	}
4053 
4054 	nf_ind->extend = 1;
4055 	l_ind = zend_list_insert(nf_ind, le_ps_font TSRMLS_CC);
4056 	RETURN_LONG(l_ind);
4057 }
4058 */
4059 /* }}} */
4060 
4061 /* {{{ proto bool imagepsfreefont(resource font_index)
4062    Free memory used by a font */
PHP_FUNCTION(imagepsfreefont)4063 PHP_FUNCTION(imagepsfreefont)
4064 {
4065 	zval *fnt;
4066 	int *f_ind;
4067 
4068 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &fnt) == FAILURE) {
4069 		return;
4070 	}
4071 
4072 	ZEND_FETCH_RESOURCE(f_ind, int *, &fnt, -1, "Type 1 font", le_ps_font);
4073 	zend_list_delete(Z_LVAL_P(fnt));
4074 	RETURN_TRUE;
4075 }
4076 /* }}} */
4077 
4078 /* {{{ proto bool imagepsencodefont(resource font_index, string filename)
4079    To change a fonts character encoding vector */
PHP_FUNCTION(imagepsencodefont)4080 PHP_FUNCTION(imagepsencodefont)
4081 {
4082 	zval *fnt;
4083 	char *enc, **enc_vector;
4084 	int enc_len, *f_ind;
4085 
4086 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rp", &fnt, &enc, &enc_len) == FAILURE) {
4087 		return;
4088 	}
4089 
4090 	ZEND_FETCH_RESOURCE(f_ind, int *, &fnt, -1, "Type 1 font", le_ps_font);
4091 
4092 	if ((enc_vector = T1_LoadEncoding(enc)) == NULL) {
4093 		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Couldn't load encoding vector from %s", enc);
4094 		RETURN_FALSE;
4095 	}
4096 
4097 	T1_DeleteAllSizes(*f_ind);
4098 	if (T1_ReencodeFont(*f_ind, enc_vector)) {
4099 		T1_DeleteEncoding(enc_vector);
4100 		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Couldn't re-encode font");
4101 		RETURN_FALSE;
4102 	}
4103 
4104 	zend_list_insert(enc_vector, le_ps_enc TSRMLS_CC);
4105 
4106 	RETURN_TRUE;
4107 }
4108 /* }}} */
4109 
4110 /* {{{ proto bool imagepsextendfont(resource font_index, float extend)
4111    Extend or or condense (if extend < 1) a font */
PHP_FUNCTION(imagepsextendfont)4112 PHP_FUNCTION(imagepsextendfont)
4113 {
4114 	zval *fnt;
4115 	double ext;
4116 	int *f_ind;
4117 
4118 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rd", &fnt, &ext) == FAILURE) {
4119 		return;
4120 	}
4121 
4122 	ZEND_FETCH_RESOURCE(f_ind, int *, &fnt, -1, "Type 1 font", le_ps_font);
4123 
4124 	T1_DeleteAllSizes(*f_ind);
4125 
4126 	if (ext <= 0) {
4127 		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Second parameter %F out of range (must be > 0)", ext);
4128 		RETURN_FALSE;
4129 	}
4130 
4131 	if (T1_ExtendFont(*f_ind, ext) != 0) {
4132 		RETURN_FALSE;
4133 	}
4134 
4135 	RETURN_TRUE;
4136 }
4137 /* }}} */
4138 
4139 /* {{{ proto bool imagepsslantfont(resource font_index, float slant)
4140    Slant a font */
PHP_FUNCTION(imagepsslantfont)4141 PHP_FUNCTION(imagepsslantfont)
4142 {
4143 	zval *fnt;
4144 	double slt;
4145 	int *f_ind;
4146 
4147 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rd", &fnt, &slt) == FAILURE) {
4148 		return;
4149 	}
4150 
4151 	ZEND_FETCH_RESOURCE(f_ind, int *, &fnt, -1, "Type 1 font", le_ps_font);
4152 
4153 	if (T1_SlantFont(*f_ind, slt) != 0) {
4154 		RETURN_FALSE;
4155 	}
4156 
4157 	RETURN_TRUE;
4158 }
4159 /* }}} */
4160 
4161 /* {{{ proto array imagepstext(resource image, string text, resource font, int size, int foreground, int background, int xcoord, int ycoord [, int space [, int tightness [, float angle [, int antialias])
4162    Rasterize a string over an image */
PHP_FUNCTION(imagepstext)4163 PHP_FUNCTION(imagepstext)
4164 {
4165 	zval *img, *fnt;
4166 	int i, j;
4167 	long _fg, _bg, x, y, size, space = 0, aa_steps = 4, width = 0;
4168 	int *f_ind;
4169 	int h_lines, v_lines, c_ind;
4170 	int rd, gr, bl, fg_rd, fg_gr, fg_bl, bg_rd, bg_gr, bg_bl;
4171 	int fg_al, bg_al, al;
4172 	int aa[16];
4173 	int amount_kern, add_width;
4174 	double angle = 0.0, extend;
4175 	unsigned long aa_greys[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
4176 	gdImagePtr bg_img;
4177 	GLYPH *str_img;
4178 	T1_OUTLINE *char_path, *str_path;
4179 	T1_TMATRIX *transform = NULL;
4180 	char *str;
4181 	int str_len;
4182 
4183 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rsrlllll|lldl", &img, &str, &str_len, &fnt, &size, &_fg, &_bg, &x, &y, &space, &width, &angle, &aa_steps) == FAILURE) {
4184 		return;
4185 	}
4186 
4187 	if (aa_steps != 4 && aa_steps != 16) {
4188 		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Antialias steps must be 4 or 16");
4189 		RETURN_FALSE;
4190 	}
4191 
4192 	ZEND_FETCH_RESOURCE(bg_img, gdImagePtr, &img, -1, "Image", le_gd);
4193 	ZEND_FETCH_RESOURCE(f_ind, int *, &fnt, -1, "Type 1 font", le_ps_font);
4194 
4195 	/* Ensure that the provided colors are valid */
4196 	if (_fg < 0 || (!gdImageTrueColor(bg_img) && _fg > gdImageColorsTotal(bg_img))) {
4197 		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Foreground color index %ld out of range", _fg);
4198 		RETURN_FALSE;
4199 	}
4200 
4201 	if (_bg < 0 || (!gdImageTrueColor(bg_img) && _fg > gdImageColorsTotal(bg_img))) {
4202 		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Background color index %ld out of range", _bg);
4203 		RETURN_FALSE;
4204 	}
4205 
4206 	fg_rd = gdImageRed  (bg_img, _fg);
4207 	fg_gr = gdImageGreen(bg_img, _fg);
4208 	fg_bl = gdImageBlue (bg_img, _fg);
4209 	fg_al = gdImageAlpha(bg_img, _fg);
4210 
4211 	bg_rd = gdImageRed  (bg_img, _bg);
4212 	bg_gr = gdImageGreen(bg_img, _bg);
4213 	bg_bl = gdImageBlue (bg_img, _bg);
4214 	bg_al = gdImageAlpha(bg_img, _bg);
4215 
4216 	for (i = 0; i < aa_steps; i++) {
4217 		rd = bg_rd + (double) (fg_rd - bg_rd) / aa_steps * (i + 1);
4218 		gr = bg_gr + (double) (fg_gr - bg_gr) / aa_steps * (i + 1);
4219 		bl = bg_bl + (double) (fg_bl - bg_bl) / aa_steps * (i + 1);
4220 		al = bg_al + (double) (fg_al - bg_al) / aa_steps * (i + 1);
4221 		aa[i] = gdImageColorResolveAlpha(bg_img, rd, gr, bl, al);
4222 	}
4223 
4224 	T1_AASetBitsPerPixel(8);
4225 
4226 	switch (aa_steps) {
4227 		case 4:
4228 			T1_AASetGrayValues(0, 1, 2, 3, 4);
4229 			T1_AASetLevel(T1_AA_LOW);
4230 			break;
4231 		case 16:
4232 			T1_AAHSetGrayValues(aa_greys);
4233 			T1_AASetLevel(T1_AA_HIGH);
4234 			break;
4235 		default:
4236 			php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid value %ld as number of steps for antialiasing", aa_steps);
4237 			RETURN_FALSE;
4238 	}
4239 
4240 	if (angle) {
4241 		transform = T1_RotateMatrix(NULL, angle);
4242 	}
4243 
4244 	if (width) {
4245 		extend = T1_GetExtend(*f_ind);
4246 		str_path = T1_GetCharOutline(*f_ind, str[0], size, transform);
4247 
4248 		if (!str_path) {
4249 			if (T1_errno) {
4250 				php_error_docref(NULL TSRMLS_CC, E_WARNING, "T1Lib Error: %s", T1_StrError(T1_errno));
4251 			}
4252 			RETURN_FALSE;
4253 		}
4254 
4255 		for (i = 1; i < str_len; i++) {
4256 			amount_kern = (int) T1_GetKerning(*f_ind, str[i - 1], str[i]);
4257 			amount_kern += str[i - 1] == ' ' ? space : 0;
4258 			add_width = (int) (amount_kern + width) / extend;
4259 
4260 			char_path = T1_GetMoveOutline(*f_ind, add_width, 0, 0, size, transform);
4261 			str_path = T1_ConcatOutlines(str_path, char_path);
4262 
4263 			char_path = T1_GetCharOutline(*f_ind, str[i], size, transform);
4264 			str_path = T1_ConcatOutlines(str_path, char_path);
4265 		}
4266 		str_img = T1_AAFillOutline(str_path, 0);
4267 	} else {
4268 		str_img = T1_AASetString(*f_ind, str,  str_len, space, T1_KERNING, size, transform);
4269 	}
4270 	if (T1_errno) {
4271 		php_error_docref(NULL TSRMLS_CC, E_WARNING, "T1Lib Error: %s", T1_StrError(T1_errno));
4272 		RETURN_FALSE;
4273 	}
4274 
4275 	h_lines = str_img->metrics.ascent -  str_img->metrics.descent;
4276 	v_lines = str_img->metrics.rightSideBearing - str_img->metrics.leftSideBearing;
4277 
4278 	for (i = 0; i < v_lines; i++) {
4279 		for (j = 0; j < h_lines; j++) {
4280 			switch (str_img->bits[j * v_lines + i]) {
4281 				case 0:
4282 					break;
4283 				default:
4284 					c_ind = aa[str_img->bits[j * v_lines + i] - 1];
4285 					gdImageSetPixel(bg_img, x + str_img->metrics.leftSideBearing + i, y - str_img->metrics.ascent + j, c_ind);
4286 					break;
4287 			}
4288 		}
4289 	}
4290 
4291 	array_init(return_value);
4292 
4293 	add_next_index_long(return_value, str_img->metrics.leftSideBearing);
4294 	add_next_index_long(return_value, str_img->metrics.descent);
4295 	add_next_index_long(return_value, str_img->metrics.rightSideBearing);
4296 	add_next_index_long(return_value, str_img->metrics.ascent);
4297 }
4298 /* }}} */
4299 
4300 /* {{{ proto array imagepsbbox(string text, resource font, int size [, int space, int tightness, float angle])
4301    Return the bounding box needed by a string if rasterized */
PHP_FUNCTION(imagepsbbox)4302 PHP_FUNCTION(imagepsbbox)
4303 {
4304 	zval *fnt;
4305 	long sz = 0, sp = 0, wd = 0;
4306 	char *str;
4307 	int i, space = 0, add_width = 0, char_width, amount_kern;
4308 	int cur_x, cur_y, dx, dy;
4309 	int x1, y1, x2, y2, x3, y3, x4, y4;
4310 	int *f_ind;
4311 	int str_len, per_char = 0;
4312 	int argc = ZEND_NUM_ARGS();
4313 	double angle = 0, sin_a = 0, cos_a = 0;
4314 	BBox char_bbox, str_bbox = {0, 0, 0, 0};
4315 
4316 	if (argc != 3 && argc != 6) {
4317 		ZEND_WRONG_PARAM_COUNT();
4318 	}
4319 
4320 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "srl|lld", &str, &str_len, &fnt, &sz, &sp, &wd, &angle) == FAILURE) {
4321 		return;
4322 	}
4323 
4324 	if (argc == 6) {
4325 		space = sp;
4326 		add_width = wd;
4327 		angle = angle * M_PI / 180;
4328 		sin_a = sin(angle);
4329 		cos_a = cos(angle);
4330 		per_char =  add_width || angle ? 1 : 0;
4331 	}
4332 
4333 	ZEND_FETCH_RESOURCE(f_ind, int *, &fnt, -1, "Type 1 font", le_ps_font);
4334 
4335 #define max(a, b) (a > b ? a : b)
4336 #define min(a, b) (a < b ? a : b)
4337 #define new_x(a, b) (int) ((a) * cos_a - (b) * sin_a)
4338 #define new_y(a, b) (int) ((a) * sin_a + (b) * cos_a)
4339 
4340 	if (per_char) {
4341 		space += T1_GetCharWidth(*f_ind, ' ');
4342 		cur_x = cur_y = 0;
4343 
4344 		for (i = 0; i < str_len; i++) {
4345 			if (str[i] == ' ') {
4346 				char_bbox.llx = char_bbox.lly = char_bbox.ury = 0;
4347 				char_bbox.urx = char_width = space;
4348 			} else {
4349 				char_bbox = T1_GetCharBBox(*f_ind, str[i]);
4350 				char_width = T1_GetCharWidth(*f_ind, str[i]);
4351 			}
4352 			amount_kern = i ? T1_GetKerning(*f_ind, str[i - 1], str[i]) : 0;
4353 
4354 			/* Transfer character bounding box to right place */
4355 			x1 = new_x(char_bbox.llx, char_bbox.lly) + cur_x;
4356 			y1 = new_y(char_bbox.llx, char_bbox.lly) + cur_y;
4357 			x2 = new_x(char_bbox.llx, char_bbox.ury) + cur_x;
4358 			y2 = new_y(char_bbox.llx, char_bbox.ury) + cur_y;
4359 			x3 = new_x(char_bbox.urx, char_bbox.ury) + cur_x;
4360 			y3 = new_y(char_bbox.urx, char_bbox.ury) + cur_y;
4361 			x4 = new_x(char_bbox.urx, char_bbox.lly) + cur_x;
4362 			y4 = new_y(char_bbox.urx, char_bbox.lly) + cur_y;
4363 
4364 			/* Find min & max values and compare them with current bounding box */
4365 			str_bbox.llx = min(str_bbox.llx, min(x1, min(x2, min(x3, x4))));
4366 			str_bbox.lly = min(str_bbox.lly, min(y1, min(y2, min(y3, y4))));
4367 			str_bbox.urx = max(str_bbox.urx, max(x1, max(x2, max(x3, x4))));
4368 			str_bbox.ury = max(str_bbox.ury, max(y1, max(y2, max(y3, y4))));
4369 
4370 			/* Move to the next base point */
4371 			dx = new_x(char_width + add_width + amount_kern, 0);
4372 			dy = new_y(char_width + add_width + amount_kern, 0);
4373 			cur_x += dx;
4374 			cur_y += dy;
4375 			/*
4376 			printf("%d\t%d\t%d\t%d\t%d\t%d\t%d\t%d\t%d\t%d\t%d\t%d\t%d\t%d\t%d\t%d\t%d\t%d\n", x1, y1, x2, y2, x3, y3, x4, y4, char_bbox.llx, char_bbox.lly, char_bbox.urx, char_bbox.ury, char_width, amount_kern, cur_x, cur_y, dx, dy);
4377 			*/
4378 		}
4379 
4380 	} else {
4381 		str_bbox = T1_GetStringBBox(*f_ind, str, str_len, space, T1_KERNING);
4382 	}
4383 
4384 	if (T1_errno) {
4385 		RETURN_FALSE;
4386 	}
4387 
4388 	array_init(return_value);
4389 	/*
4390 	printf("%d %d %d %d\n", str_bbox.llx, str_bbox.lly, str_bbox.urx, str_bbox.ury);
4391 	*/
4392 	add_next_index_long(return_value, (int) ceil(((double) str_bbox.llx)*sz/1000));
4393 	add_next_index_long(return_value, (int) ceil(((double) str_bbox.lly)*sz/1000));
4394 	add_next_index_long(return_value, (int) ceil(((double) str_bbox.urx)*sz/1000));
4395 	add_next_index_long(return_value, (int) ceil(((double) str_bbox.ury)*sz/1000));
4396 }
4397 /* }}} */
4398 #endif
4399 
4400 /* {{{ proto bool image2wbmp(resource im [, string filename [, int threshold]])
4401    Output WBMP image to browser or file */
PHP_FUNCTION(image2wbmp)4402 PHP_FUNCTION(image2wbmp)
4403 {
4404 	_php_image_output(INTERNAL_FUNCTION_PARAM_PASSTHRU, PHP_GDIMG_CONVERT_WBM, "WBMP", _php_image_bw_convert);
4405 }
4406 /* }}} */
4407 
4408 #if defined(HAVE_GD_JPG)
4409 /* {{{ proto bool jpeg2wbmp (string f_org, string f_dest, int d_height, int d_width, int threshold)
4410    Convert JPEG image to WBMP image */
PHP_FUNCTION(jpeg2wbmp)4411 PHP_FUNCTION(jpeg2wbmp)
4412 {
4413 	_php_image_convert(INTERNAL_FUNCTION_PARAM_PASSTHRU, PHP_GDIMG_TYPE_JPG);
4414 }
4415 /* }}} */
4416 #endif
4417 
4418 #if defined(HAVE_GD_PNG)
4419 /* {{{ proto bool png2wbmp (string f_org, string f_dest, int d_height, int d_width, int threshold)
4420    Convert PNG image to WBMP image */
PHP_FUNCTION(png2wbmp)4421 PHP_FUNCTION(png2wbmp)
4422 {
4423 	_php_image_convert(INTERNAL_FUNCTION_PARAM_PASSTHRU, PHP_GDIMG_TYPE_PNG);
4424 }
4425 /* }}} */
4426 #endif
4427 
4428 /* {{{ _php_image_bw_convert
4429  * It converts a gd Image to bw using a threshold value */
_php_image_bw_convert(gdImagePtr im_org,gdIOCtx * out,int threshold)4430 static void _php_image_bw_convert(gdImagePtr im_org, gdIOCtx *out, int threshold)
4431 {
4432 	gdImagePtr im_dest;
4433 	int white, black;
4434 	int color, color_org, median;
4435 	int dest_height = gdImageSY(im_org);
4436 	int dest_width = gdImageSX(im_org);
4437 	int x, y;
4438 	TSRMLS_FETCH();
4439 
4440 	im_dest = gdImageCreate(dest_width, dest_height);
4441 	if (im_dest == NULL) {
4442 		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to allocate temporary buffer");
4443 		return;
4444 	}
4445 
4446 	white = gdImageColorAllocate(im_dest, 255, 255, 255);
4447 	if (white == -1) {
4448 		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to allocate the colors for the destination buffer");
4449 		return;
4450 	}
4451 
4452 	black = gdImageColorAllocate(im_dest, 0, 0, 0);
4453 	if (black == -1) {
4454 		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to allocate the colors for the destination buffer");
4455 		return;
4456 	}
4457 
4458 	if (im_org->trueColor) {
4459 		gdImageTrueColorToPalette(im_org, 1, 256);
4460 	}
4461 
4462 	for (y = 0; y < dest_height; y++) {
4463 		for (x = 0; x < dest_width; x++) {
4464 			color_org = gdImageGetPixel(im_org, x, y);
4465 			median = (im_org->red[color_org] + im_org->green[color_org] + im_org->blue[color_org]) / 3;
4466 			if (median < threshold) {
4467 				color = black;
4468 			} else {
4469 				color = white;
4470 			}
4471 			gdImageSetPixel (im_dest, x, y, color);
4472 		}
4473 	}
4474 	gdImageWBMPCtx (im_dest, black, out);
4475 
4476 }
4477 /* }}} */
4478 
4479 /* {{{ _php_image_convert
4480  * _php_image_convert converts jpeg/png images to wbmp and resizes them as needed  */
_php_image_convert(INTERNAL_FUNCTION_PARAMETERS,int image_type)4481 static void _php_image_convert(INTERNAL_FUNCTION_PARAMETERS, int image_type )
4482 {
4483 	char *f_org, *f_dest;
4484 	int f_org_len, f_dest_len;
4485 	long height, width, threshold;
4486 	gdImagePtr im_org, im_dest, im_tmp;
4487 	char *fn_org = NULL;
4488 	char *fn_dest = NULL;
4489 	FILE *org, *dest;
4490 	int dest_height = -1;
4491 	int dest_width = -1;
4492 	int org_height, org_width;
4493 	int white, black;
4494 	int color, color_org, median;
4495 	int int_threshold;
4496 	int x, y;
4497 	float x_ratio, y_ratio;
4498     long ignore_warning;
4499 
4500 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "pplll", &f_org, &f_org_len, &f_dest, &f_dest_len, &height, &width, &threshold) == FAILURE) {
4501 		return;
4502 	}
4503 
4504 	fn_org  = f_org;
4505 	fn_dest = f_dest;
4506 	dest_height = height;
4507 	dest_width = width;
4508 	int_threshold = threshold;
4509 
4510 	/* Check threshold value */
4511 	if (int_threshold < 0 || int_threshold > 8) {
4512 		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid threshold value '%d'", int_threshold);
4513 		RETURN_FALSE;
4514 	}
4515 
4516 	/* Check origin file */
4517 	PHP_GD_CHECK_OPEN_BASEDIR(fn_org, "Invalid origin filename");
4518 
4519 	/* Check destination file */
4520 	PHP_GD_CHECK_OPEN_BASEDIR(fn_dest, "Invalid destination filename");
4521 
4522 	/* Open origin file */
4523 	org = VCWD_FOPEN(fn_org, "rb");
4524 	if (!org) {
4525 		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to open '%s' for reading", fn_org);
4526 		RETURN_FALSE;
4527 	}
4528 
4529 	/* Open destination file */
4530 	dest = VCWD_FOPEN(fn_dest, "wb");
4531 	if (!dest) {
4532 		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to open '%s' for writing", fn_dest);
4533         fclose(org);
4534 		RETURN_FALSE;
4535 	}
4536 
4537 	switch (image_type) {
4538 		case PHP_GDIMG_TYPE_GIF:
4539 			im_org = gdImageCreateFromGif(org);
4540 			if (im_org == NULL) {
4541 				php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to open '%s' Not a valid GIF file", fn_dest);
4542                 fclose(org);
4543                 fclose(dest);
4544 				RETURN_FALSE;
4545 			}
4546 			break;
4547 
4548 #ifdef HAVE_GD_JPG
4549 		case PHP_GDIMG_TYPE_JPG:
4550 			ignore_warning = INI_INT("gd.jpeg_ignore_warning");
4551 			im_org = gdImageCreateFromJpegEx(org, ignore_warning);
4552 			if (im_org == NULL) {
4553 				php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to open '%s' Not a valid JPEG file", fn_dest);
4554                 fclose(org);
4555                 fclose(dest);
4556 				RETURN_FALSE;
4557 			}
4558 			break;
4559 #endif /* HAVE_GD_JPG */
4560 
4561 #ifdef HAVE_GD_PNG
4562 		case PHP_GDIMG_TYPE_PNG:
4563 			im_org = gdImageCreateFromPng(org);
4564 			if (im_org == NULL) {
4565 				php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to open '%s' Not a valid PNG file", fn_dest);
4566                 fclose(org);
4567                 fclose(dest);
4568 				RETURN_FALSE;
4569 			}
4570 			break;
4571 #endif /* HAVE_GD_PNG */
4572 
4573 		default:
4574 			php_error_docref(NULL TSRMLS_CC, E_WARNING, "Format not supported");
4575             fclose(org);
4576             fclose(dest);
4577 			RETURN_FALSE;
4578 			break;
4579 	}
4580 
4581 	fclose(org);
4582 
4583 	org_width  = gdImageSX (im_org);
4584 	org_height = gdImageSY (im_org);
4585 
4586 	x_ratio = (float) org_width / (float) dest_width;
4587 	y_ratio = (float) org_height / (float) dest_height;
4588 
4589 	if (x_ratio > 1 && y_ratio > 1) {
4590 		if (y_ratio > x_ratio) {
4591 			x_ratio = y_ratio;
4592 		} else {
4593 			y_ratio = x_ratio;
4594 		}
4595 		dest_width = (int) (org_width / x_ratio);
4596 		dest_height = (int) (org_height / y_ratio);
4597 	} else {
4598 		x_ratio = (float) dest_width / (float) org_width;
4599 		y_ratio = (float) dest_height / (float) org_height;
4600 
4601 		if (y_ratio < x_ratio) {
4602 			x_ratio = y_ratio;
4603 		} else {
4604 			y_ratio = x_ratio;
4605 		}
4606 		dest_width = (int) (org_width * x_ratio);
4607 		dest_height = (int) (org_height * y_ratio);
4608 	}
4609 
4610 	im_tmp = gdImageCreate (dest_width, dest_height);
4611 	if (im_tmp == NULL ) {
4612 		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to allocate temporary buffer");
4613         fclose(dest);
4614         gdImageDestroy(im_org);
4615 		RETURN_FALSE;
4616 	}
4617 
4618 	gdImageCopyResized (im_tmp, im_org, 0, 0, 0, 0, dest_width, dest_height, org_width, org_height);
4619 
4620 	gdImageDestroy(im_org);
4621 
4622 	im_dest = gdImageCreate(dest_width, dest_height);
4623 	if (im_dest == NULL) {
4624 		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to allocate destination buffer");
4625         fclose(dest);
4626         gdImageDestroy(im_tmp);
4627 		RETURN_FALSE;
4628 	}
4629 
4630 	white = gdImageColorAllocate(im_dest, 255, 255, 255);
4631 	if (white == -1) {
4632 		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to allocate the colors for the destination buffer");
4633         fclose(dest);
4634         gdImageDestroy(im_tmp);
4635         gdImageDestroy(im_dest);
4636 		RETURN_FALSE;
4637 	}
4638 
4639 	black = gdImageColorAllocate(im_dest, 0, 0, 0);
4640 	if (black == -1) {
4641 		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to allocate the colors for the destination buffer");
4642         fclose(dest);
4643         gdImageDestroy(im_tmp);
4644         gdImageDestroy(im_dest);
4645 		RETURN_FALSE;
4646 	}
4647 
4648 	int_threshold = int_threshold * 32;
4649 
4650 	for (y = 0; y < dest_height; y++) {
4651 		for (x = 0; x < dest_width; x++) {
4652 			color_org = gdImageGetPixel (im_tmp, x, y);
4653 			median = (im_tmp->red[color_org] + im_tmp->green[color_org] + im_tmp->blue[color_org]) / 3;
4654 			if (median < int_threshold) {
4655 				color = black;
4656 			} else {
4657 				color = white;
4658 			}
4659 			gdImageSetPixel (im_dest, x, y, color);
4660 		}
4661 	}
4662 
4663 	gdImageDestroy (im_tmp );
4664 
4665 	gdImageWBMP(im_dest, black , dest);
4666 
4667 	fflush(dest);
4668 	fclose(dest);
4669 
4670 	gdImageDestroy(im_dest);
4671 
4672 	RETURN_TRUE;
4673 }
4674 /* }}} */
4675 
4676 /* Section Filters */
4677 #define PHP_GD_SINGLE_RES	\
4678 	zval *SIM;	\
4679 	gdImagePtr im_src;	\
4680 	if (zend_parse_parameters(1 TSRMLS_CC, "r", &SIM) == FAILURE) {	\
4681 		RETURN_FALSE;	\
4682 	}	\
4683 	ZEND_FETCH_RESOURCE(im_src, gdImagePtr, &SIM, -1, "Image", le_gd);	\
4684 	if (im_src == NULL) {	\
4685 		RETURN_FALSE;	\
4686 	}
4687 
php_image_filter_negate(INTERNAL_FUNCTION_PARAMETERS)4688 static void php_image_filter_negate(INTERNAL_FUNCTION_PARAMETERS)
4689 {
4690 	PHP_GD_SINGLE_RES
4691 
4692 	if (gdImageNegate(im_src) == 1) {
4693 		RETURN_TRUE;
4694 	}
4695 
4696 	RETURN_FALSE;
4697 }
4698 
php_image_filter_grayscale(INTERNAL_FUNCTION_PARAMETERS)4699 static void php_image_filter_grayscale(INTERNAL_FUNCTION_PARAMETERS)
4700 {
4701 	PHP_GD_SINGLE_RES
4702 
4703 	if (gdImageGrayScale(im_src) == 1) {
4704 		RETURN_TRUE;
4705 	}
4706 
4707 	RETURN_FALSE;
4708 }
4709 
php_image_filter_brightness(INTERNAL_FUNCTION_PARAMETERS)4710 static void php_image_filter_brightness(INTERNAL_FUNCTION_PARAMETERS)
4711 {
4712 	zval *SIM;
4713 	gdImagePtr im_src;
4714 	long brightness, tmp;
4715 
4716 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zll", &SIM, &tmp, &brightness) == FAILURE) {
4717 		RETURN_FALSE;
4718 	}
4719 
4720 	ZEND_FETCH_RESOURCE(im_src, gdImagePtr, &SIM, -1, "Image", le_gd);
4721 
4722 	if (im_src == NULL) {
4723 		RETURN_FALSE;
4724 	}
4725 
4726 	if (gdImageBrightness(im_src, (int)brightness) == 1) {
4727 		RETURN_TRUE;
4728 	}
4729 
4730 	RETURN_FALSE;
4731 }
4732 
php_image_filter_contrast(INTERNAL_FUNCTION_PARAMETERS)4733 static void php_image_filter_contrast(INTERNAL_FUNCTION_PARAMETERS)
4734 {
4735 	zval *SIM;
4736 	gdImagePtr im_src;
4737 	long contrast, tmp;
4738 
4739 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rll", &SIM, &tmp, &contrast) == FAILURE) {
4740 		RETURN_FALSE;
4741 	}
4742 
4743 	ZEND_FETCH_RESOURCE(im_src, gdImagePtr, &SIM, -1, "Image", le_gd);
4744 
4745 	if (im_src == NULL) {
4746 		RETURN_FALSE;
4747 	}
4748 
4749 	if (gdImageContrast(im_src, (int)contrast) == 1) {
4750 		RETURN_TRUE;
4751 	}
4752 
4753 	RETURN_FALSE;
4754 }
4755 
php_image_filter_colorize(INTERNAL_FUNCTION_PARAMETERS)4756 static void php_image_filter_colorize(INTERNAL_FUNCTION_PARAMETERS)
4757 {
4758 	zval *SIM;
4759 	gdImagePtr im_src;
4760 	long r,g,b,tmp;
4761 	long a = 0;
4762 
4763 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rllll|l", &SIM, &tmp, &r, &g, &b, &a) == FAILURE) {
4764 		RETURN_FALSE;
4765 	}
4766 
4767 	ZEND_FETCH_RESOURCE(im_src, gdImagePtr, &SIM, -1, "Image", le_gd);
4768 
4769 	if (im_src == NULL) {
4770 		RETURN_FALSE;
4771 	}
4772 
4773 	if (gdImageColor(im_src, (int) r, (int) g, (int) b, (int) a) == 1) {
4774 		RETURN_TRUE;
4775 	}
4776 
4777 	RETURN_FALSE;
4778 }
4779 
php_image_filter_edgedetect(INTERNAL_FUNCTION_PARAMETERS)4780 static void php_image_filter_edgedetect(INTERNAL_FUNCTION_PARAMETERS)
4781 {
4782 	PHP_GD_SINGLE_RES
4783 
4784 	if (gdImageEdgeDetectQuick(im_src) == 1) {
4785 		RETURN_TRUE;
4786 	}
4787 
4788 	RETURN_FALSE;
4789 }
4790 
php_image_filter_emboss(INTERNAL_FUNCTION_PARAMETERS)4791 static void php_image_filter_emboss(INTERNAL_FUNCTION_PARAMETERS)
4792 {
4793 	PHP_GD_SINGLE_RES
4794 
4795 	if (gdImageEmboss(im_src) == 1) {
4796 		RETURN_TRUE;
4797 	}
4798 
4799 	RETURN_FALSE;
4800 }
4801 
php_image_filter_gaussian_blur(INTERNAL_FUNCTION_PARAMETERS)4802 static void php_image_filter_gaussian_blur(INTERNAL_FUNCTION_PARAMETERS)
4803 {
4804 	PHP_GD_SINGLE_RES
4805 
4806 	if (gdImageGaussianBlur(im_src) == 1) {
4807 		RETURN_TRUE;
4808 	}
4809 
4810 	RETURN_FALSE;
4811 }
4812 
php_image_filter_selective_blur(INTERNAL_FUNCTION_PARAMETERS)4813 static void php_image_filter_selective_blur(INTERNAL_FUNCTION_PARAMETERS)
4814 {
4815 	PHP_GD_SINGLE_RES
4816 
4817 	if (gdImageSelectiveBlur(im_src) == 1) {
4818 		RETURN_TRUE;
4819 	}
4820 
4821 	RETURN_FALSE;
4822 }
4823 
php_image_filter_mean_removal(INTERNAL_FUNCTION_PARAMETERS)4824 static void php_image_filter_mean_removal(INTERNAL_FUNCTION_PARAMETERS)
4825 {
4826 	PHP_GD_SINGLE_RES
4827 
4828 	if (gdImageMeanRemoval(im_src) == 1) {
4829 		RETURN_TRUE;
4830 	}
4831 
4832 	RETURN_FALSE;
4833 }
4834 
php_image_filter_smooth(INTERNAL_FUNCTION_PARAMETERS)4835 static void php_image_filter_smooth(INTERNAL_FUNCTION_PARAMETERS)
4836 {
4837 	zval *SIM;
4838 	long tmp;
4839 	gdImagePtr im_src;
4840 	double weight;
4841 
4842 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rld", &SIM, &tmp, &weight) == FAILURE) {
4843 		RETURN_FALSE;
4844 	}
4845 
4846 	ZEND_FETCH_RESOURCE(im_src, gdImagePtr, &SIM, -1, "Image", le_gd);
4847 
4848 	if (im_src == NULL) {
4849 		RETURN_FALSE;
4850 	}
4851 
4852 	if (gdImageSmooth(im_src, (float)weight)==1) {
4853 		RETURN_TRUE;
4854 	}
4855 
4856 	RETURN_FALSE;
4857 }
4858 
php_image_filter_pixelate(INTERNAL_FUNCTION_PARAMETERS)4859 static void php_image_filter_pixelate(INTERNAL_FUNCTION_PARAMETERS)
4860 {
4861 	zval *IM;
4862 	gdImagePtr im;
4863 	long tmp, blocksize;
4864 	zend_bool mode = 0;
4865 
4866 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rll|b", &IM, &tmp, &blocksize, &mode) == FAILURE) {
4867 		RETURN_FALSE;
4868 	}
4869 
4870 	ZEND_FETCH_RESOURCE(im, gdImagePtr, &IM, -1, "Image", le_gd);
4871 
4872 	if (im == NULL) {
4873 		RETURN_FALSE;
4874 	}
4875 
4876 	if (gdImagePixelate(im, (int) blocksize, (const unsigned int) mode)) {
4877 		RETURN_TRUE;
4878 	}
4879 
4880 	RETURN_FALSE;
4881 }
4882 
4883 /* {{{ proto bool imagefilter(resource src_im, int filtertype, [args] )
4884    Applies Filter an image using a custom angle */
PHP_FUNCTION(imagefilter)4885 PHP_FUNCTION(imagefilter)
4886 {
4887 	zval *tmp;
4888 
4889 	typedef void (*image_filter)(INTERNAL_FUNCTION_PARAMETERS);
4890 	long filtertype;
4891 	image_filter filters[] =
4892 	{
4893 		php_image_filter_negate ,
4894 		php_image_filter_grayscale,
4895 		php_image_filter_brightness,
4896 		php_image_filter_contrast,
4897 		php_image_filter_colorize,
4898 		php_image_filter_edgedetect,
4899 		php_image_filter_emboss,
4900 		php_image_filter_gaussian_blur,
4901 		php_image_filter_selective_blur,
4902 		php_image_filter_mean_removal,
4903 		php_image_filter_smooth,
4904 		php_image_filter_pixelate
4905 	};
4906 
4907 	if (ZEND_NUM_ARGS() < 2 || ZEND_NUM_ARGS() > IMAGE_FILTER_MAX_ARGS) {
4908 		WRONG_PARAM_COUNT;
4909 	} else if (zend_parse_parameters(2 TSRMLS_CC, "rl", &tmp, &filtertype) == FAILURE) {
4910 		return;
4911 	}
4912 
4913 	if (filtertype >= 0 && filtertype <= IMAGE_FILTER_MAX) {
4914 		filters[filtertype](INTERNAL_FUNCTION_PARAM_PASSTHRU);
4915 	}
4916 }
4917 /* }}} */
4918 
4919 /* {{{ proto resource imageconvolution(resource src_im, array matrix3x3, double div, double offset)
4920    Apply a 3x3 convolution matrix, using coefficient div and offset */
PHP_FUNCTION(imageconvolution)4921 PHP_FUNCTION(imageconvolution)
4922 {
4923 	zval *SIM, *hash_matrix;
4924 	zval **var = NULL, **var2 = NULL;
4925 	gdImagePtr im_src = NULL;
4926 	double div, offset;
4927 	int nelem, i, j, res;
4928 	float matrix[3][3] = {{0,0,0}, {0,0,0}, {0,0,0}};
4929 
4930 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "radd", &SIM, &hash_matrix, &div, &offset) == FAILURE) {
4931 		RETURN_FALSE;
4932 	}
4933 
4934 	ZEND_FETCH_RESOURCE(im_src, gdImagePtr, &SIM, -1, "Image", le_gd);
4935 
4936 	nelem = zend_hash_num_elements(Z_ARRVAL_P(hash_matrix));
4937 	if (nelem != 3) {
4938 		php_error_docref(NULL TSRMLS_CC, E_WARNING, "You must have 3x3 array");
4939 		RETURN_FALSE;
4940 	}
4941 
4942 	for (i=0; i<3; i++) {
4943 		if (zend_hash_index_find(Z_ARRVAL_P(hash_matrix), (i), (void **) &var) == SUCCESS && Z_TYPE_PP(var) == IS_ARRAY) {
4944 			if (Z_TYPE_PP(var) != IS_ARRAY || zend_hash_num_elements(Z_ARRVAL_PP(var)) != 3 ) {
4945 				php_error_docref(NULL TSRMLS_CC, E_WARNING, "You must have 3x3 array");
4946 				RETURN_FALSE;
4947 			}
4948 
4949 			for (j=0; j<3; j++) {
4950 				if (zend_hash_index_find(Z_ARRVAL_PP(var), (j), (void **) &var2) == SUCCESS) {
4951 					if (Z_TYPE_PP(var2) != IS_DOUBLE) {
4952 						zval dval;
4953 						dval = **var2;
4954 						zval_copy_ctor(&dval);
4955 						convert_to_double(&dval);
4956 						matrix[i][j] = (float)Z_DVAL(dval);
4957 					} else {
4958 						matrix[i][j] = (float)Z_DVAL_PP(var2);
4959 					}
4960 				} else {
4961 					php_error_docref(NULL TSRMLS_CC, E_WARNING, "You must have a 3x3 matrix");
4962 					RETURN_FALSE;
4963 				}
4964 			}
4965 		}
4966 	}
4967 	res = gdImageConvolution(im_src, matrix, (float)div, (float)offset);
4968 
4969 	if (res) {
4970 		RETURN_TRUE;
4971 	} else {
4972 		RETURN_FALSE;
4973 	}
4974 }
4975 /* }}} */
4976 /* End section: Filters */
4977 
4978 /* {{{ proto void imageflip(resource im, int mode)
4979    Flip an image (in place) horizontally, vertically or both directions. */
PHP_FUNCTION(imageflip)4980 PHP_FUNCTION(imageflip)
4981 {
4982 	zval *IM;
4983 	long mode;
4984 	gdImagePtr im;
4985 
4986 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rl", &IM, &mode) == FAILURE)  {
4987 		return;
4988 	}
4989 
4990 	ZEND_FETCH_RESOURCE(im, gdImagePtr, &IM, -1, "Image", le_gd);
4991 
4992 	switch (mode) {
4993 		case GD_FLIP_VERTICAL:
4994 			gdImageFlipVertical(im);
4995 			break;
4996 
4997 		case GD_FLIP_HORINZONTAL:
4998 			gdImageFlipHorizontal(im);
4999 			break;
5000 
5001 		case GD_FLIP_BOTH:
5002 			gdImageFlipBoth(im);
5003 			break;
5004 
5005 		default:
5006 			php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unknown flip mode");
5007 			RETURN_FALSE;
5008 	}
5009 
5010 	RETURN_TRUE;
5011 }
5012 /* }}} */
5013 
5014 #ifdef HAVE_GD_BUNDLED
5015 /* {{{ proto bool imageantialias(resource im, bool on)
5016    Should antialiased functions used or not*/
PHP_FUNCTION(imageantialias)5017 PHP_FUNCTION(imageantialias)
5018 {
5019 	zval *IM;
5020 	zend_bool alias;
5021 	gdImagePtr im;
5022 
5023 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rb", &IM, &alias) == FAILURE) {
5024 		return;
5025 	}
5026 
5027 	ZEND_FETCH_RESOURCE(im, gdImagePtr, &IM, -1, "Image", le_gd);
5028 	gdImageAntialias(im, alias);
5029 	RETURN_TRUE;
5030 }
5031 /* }}} */
5032 #endif
5033 
5034 /* {{{ proto void imagecrop(resource im, array rect)
5035    Crop an image using the given coordinates and size, x, y, width and height. */
PHP_FUNCTION(imagecrop)5036 PHP_FUNCTION(imagecrop)
5037 {
5038 	zval *IM;
5039 	gdImagePtr im;
5040 	gdImagePtr im_crop;
5041 	gdRect rect;
5042 	zval *z_rect;
5043 	zval **tmp;
5044 
5045 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ra", &IM, &z_rect) == FAILURE)  {
5046 		return;
5047 	}
5048 
5049 	ZEND_FETCH_RESOURCE(im, gdImagePtr, &IM, -1, "Image", le_gd);
5050 
5051 	if (zend_hash_find(HASH_OF(z_rect), "x", sizeof("x"), (void **)&tmp) != FAILURE) {
5052 		if (Z_TYPE_PP(tmp) != IS_LONG) {
5053 			zval lval;
5054 			lval = **tmp;
5055 			zval_copy_ctor(&lval);
5056 			convert_to_long(&lval);
5057 			rect.x = Z_LVAL(lval);
5058 		} else {
5059 			rect.x = Z_LVAL_PP(tmp);
5060 		}
5061 	} else {
5062 		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Missing x position");
5063 		RETURN_FALSE;
5064 	}
5065 
5066 	if (zend_hash_find(HASH_OF(z_rect), "y", sizeof("x"), (void **)&tmp) != FAILURE) {
5067 		if (Z_TYPE_PP(tmp) != IS_LONG) {
5068 			zval lval;
5069 			lval = **tmp;
5070 			zval_copy_ctor(&lval);
5071 			convert_to_long(&lval);
5072 			rect.y = Z_LVAL(lval);
5073 		} else {
5074 			rect.y = Z_LVAL_PP(tmp);
5075 		}
5076 	} else {
5077 		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Missing y position");
5078 		RETURN_FALSE;
5079 	}
5080 
5081 	if (zend_hash_find(HASH_OF(z_rect), "width", sizeof("width"), (void **)&tmp) != FAILURE) {
5082 		if (Z_TYPE_PP(tmp) != IS_LONG) {
5083 			zval lval;
5084 			lval = **tmp;
5085 			zval_copy_ctor(&lval);
5086 			convert_to_long(&lval);
5087 			rect.width = Z_LVAL(lval);
5088 		} else {
5089 			rect.width = Z_LVAL_PP(tmp);
5090 		}
5091 	} else {
5092 		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Missing width");
5093 		RETURN_FALSE;
5094 	}
5095 
5096 	if (zend_hash_find(HASH_OF(z_rect), "height", sizeof("height"), (void **)&tmp) != FAILURE) {
5097 		if (Z_TYPE_PP(tmp) != IS_LONG) {
5098 			zval lval;
5099 			lval = **tmp;
5100 			zval_copy_ctor(&lval);
5101 			convert_to_long(&lval);
5102 			rect.height = Z_LVAL(lval);
5103 		} else {
5104 			rect.height = Z_LVAL_PP(tmp);
5105 		}
5106 	} else {
5107 		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Missing height");
5108 		RETURN_FALSE;
5109 	}
5110 
5111 	im_crop = gdImageCrop(im, &rect);
5112 
5113 	if (im_crop == NULL) {
5114 		RETURN_FALSE;
5115 	} else {
5116 		ZEND_REGISTER_RESOURCE(return_value, im_crop, le_gd);
5117 	}
5118 }
5119 /* }}} */
5120 
5121 /* {{{ proto void imagecropauto(resource im [, int mode [, threshold [, color]]])
5122    Crop an image automatically using one of the available modes. */
PHP_FUNCTION(imagecropauto)5123 PHP_FUNCTION(imagecropauto)
5124 {
5125 	zval *IM;
5126 	long mode = -1;
5127 	long color = -1;
5128 	double threshold = 0.5f;
5129 	gdImagePtr im;
5130 	gdImagePtr im_crop;
5131 
5132 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r|ldl", &IM, &mode, &threshold, &color) == FAILURE)  {
5133 		return;
5134 	}
5135 
5136 	ZEND_FETCH_RESOURCE(im, gdImagePtr, &IM, -1, "Image", le_gd);
5137 
5138 	switch (mode) {
5139 		case -1:
5140 			mode = GD_CROP_DEFAULT;
5141 		case GD_CROP_DEFAULT:
5142 		case GD_CROP_TRANSPARENT:
5143 		case GD_CROP_BLACK:
5144 		case GD_CROP_WHITE:
5145 		case GD_CROP_SIDES:
5146 			im_crop = gdImageCropAuto(im, mode);
5147 			break;
5148 
5149 		case GD_CROP_THRESHOLD:
5150 			if (color < 0 || (!gdImageTrueColor(im) && color >= gdImageColorsTotal(im))) {
5151 				php_error_docref(NULL TSRMLS_CC, E_WARNING, "Color argument missing with threshold mode");
5152 				RETURN_FALSE;
5153 			}
5154 			im_crop = gdImageCropThreshold(im, color, (float) threshold);
5155 			break;
5156 
5157 		default:
5158 			php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unknown crop mode");
5159 			RETURN_FALSE;
5160 	}
5161 	if (im_crop == NULL) {
5162 		RETURN_FALSE;
5163 	} else {
5164 		ZEND_REGISTER_RESOURCE(return_value, im_crop, le_gd);
5165 	}
5166 }
5167 /* }}} */
5168 
5169 /* {{{ proto resource imagescale(resource im, new_width[, new_height[, method]])
5170    Scale an image using the given new width and height. */
PHP_FUNCTION(imagescale)5171 PHP_FUNCTION(imagescale)
5172 {
5173 	zval *IM;
5174 	gdImagePtr im;
5175 	gdImagePtr im_scaled = NULL;
5176 	int new_width, new_height;
5177 	long tmp_w, tmp_h=-1, tmp_m = GD_BILINEAR_FIXED;
5178 	gdInterpolationMethod method, old_method;
5179 
5180 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rl|ll", &IM, &tmp_w, &tmp_h, &tmp_m) == FAILURE)  {
5181 		return;
5182 	}
5183 	method = tmp_m;
5184 
5185 	ZEND_FETCH_RESOURCE(im, gdImagePtr, &IM, -1, "Image", le_gd);
5186 
5187 	if (tmp_h < 0) {
5188 		/* preserve ratio */
5189 		long src_x, src_y;
5190 
5191 		src_x = gdImageSX(im);
5192 		src_y = gdImageSY(im);
5193 		if (src_x) {
5194 			tmp_h = tmp_w * src_y / src_x;
5195 		}
5196 	}
5197 
5198 	if (tmp_h <= 0 || tmp_w <= 0) {
5199 		RETURN_FALSE;
5200 	}
5201 
5202 	new_width = tmp_w;
5203 	new_height = tmp_h;
5204 
5205 	/* gdImageGetInterpolationMethod() is only available as of GD 2.1.1 */
5206 	old_method = im->interpolation_id;
5207 	if (gdImageSetInterpolationMethod(im, method)) {
5208 		im_scaled = gdImageScale(im, new_width, new_height);
5209 	}
5210 	gdImageSetInterpolationMethod(im, old_method);
5211 
5212 	if (im_scaled == NULL) {
5213 		RETURN_FALSE;
5214 	} else {
5215 		ZEND_REGISTER_RESOURCE(return_value, im_scaled, le_gd);
5216 	}
5217 }
5218 /* }}} */
5219 
5220 /* {{{ proto resource imageaffine(resource src, array affine[, array clip])
5221    Return an image containing the affine tramsformed src image, using an optional clipping area */
PHP_FUNCTION(imageaffine)5222 PHP_FUNCTION(imageaffine)
5223 {
5224 	zval *IM;
5225 	gdImagePtr src;
5226 	gdImagePtr dst;
5227 	gdRect rect;
5228 	gdRectPtr pRect = NULL;
5229 	zval *z_rect = NULL;
5230 	zval *z_affine;
5231 	zval **tmp;
5232 	double affine[6];
5233 	int i, nelems;
5234 	zval **zval_affine_elem = NULL;
5235 
5236 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ra|a", &IM, &z_affine, &z_rect) == FAILURE)  {
5237 		return;
5238 	}
5239 
5240 	ZEND_FETCH_RESOURCE(src, gdImagePtr, &IM, -1, "Image", le_gd);
5241 
5242 	if ((nelems = zend_hash_num_elements(Z_ARRVAL_P(z_affine))) != 6) {
5243 		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Affine array must have six elements");
5244 		RETURN_FALSE;
5245 	}
5246 
5247 	for (i = 0; i < nelems; i++) {
5248 		if (zend_hash_index_find(Z_ARRVAL_P(z_affine), i, (void **) &zval_affine_elem) == SUCCESS) {
5249 			switch (Z_TYPE_PP(zval_affine_elem)) {
5250 				case IS_LONG:
5251 					affine[i]  = Z_LVAL_PP(zval_affine_elem);
5252 					break;
5253 				case IS_DOUBLE:
5254 					affine[i] = Z_DVAL_PP(zval_affine_elem);
5255 					break;
5256 				case IS_STRING:
5257 					{
5258 						zval dval;
5259 						dval = **zval_affine_elem;
5260 						zval_copy_ctor(&dval);
5261 						convert_to_double(&dval);
5262 						affine[i] = Z_DVAL(dval);
5263 					}
5264 					break;
5265 				default:
5266 					php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid type for element %i", i);
5267 					RETURN_FALSE;
5268 			}
5269 		}
5270 	}
5271 
5272 	if (z_rect != NULL) {
5273 		if (zend_hash_find(HASH_OF(z_rect), "x", sizeof("x"), (void **)&tmp) != FAILURE) {
5274 			if (Z_TYPE_PP(tmp) != IS_LONG) {
5275 				zval lval;
5276 				lval = **tmp;
5277 				zval_copy_ctor(&lval);
5278 				convert_to_long(&lval);
5279 				rect.x = Z_LVAL(lval);
5280 			} else {
5281 				rect.x = Z_LVAL_PP(tmp);
5282 			}
5283 		} else {
5284 			php_error_docref(NULL TSRMLS_CC, E_WARNING, "Missing x position");
5285 			RETURN_FALSE;
5286 		}
5287 
5288 		if (zend_hash_find(HASH_OF(z_rect), "y", sizeof("x"), (void **)&tmp) != FAILURE) {
5289 			if (Z_TYPE_PP(tmp) != IS_LONG) {
5290 				zval lval;
5291 				lval = **tmp;
5292 				zval_copy_ctor(&lval);
5293 				convert_to_long(&lval);
5294 				rect.y = Z_LVAL(lval);
5295 			} else {
5296 				rect.y = Z_LVAL_PP(tmp);
5297 			}
5298 		} else {
5299 			php_error_docref(NULL TSRMLS_CC, E_WARNING, "Missing y position");
5300 			RETURN_FALSE;
5301 		}
5302 
5303 		if (zend_hash_find(HASH_OF(z_rect), "width", sizeof("width"), (void **)&tmp) != FAILURE) {
5304 			if (Z_TYPE_PP(tmp) != IS_LONG) {
5305 				zval lval;
5306 				lval = **tmp;
5307 				zval_copy_ctor(&lval);
5308 				convert_to_long(&lval);
5309 				rect.width = Z_LVAL(lval);
5310 			} else {
5311 				rect.width = Z_LVAL_PP(tmp);
5312 			}
5313 		} else {
5314 			php_error_docref(NULL TSRMLS_CC, E_WARNING, "Missing width");
5315 			RETURN_FALSE;
5316 		}
5317 
5318 		if (zend_hash_find(HASH_OF(z_rect), "height", sizeof("height"), (void **)&tmp) != FAILURE) {
5319 			if (Z_TYPE_PP(tmp) != IS_LONG) {
5320 				zval lval;
5321 				lval = **tmp;
5322 				zval_copy_ctor(&lval);
5323 				convert_to_long(&lval);
5324 				rect.height = Z_LVAL(lval);
5325 			} else {
5326 				rect.height = Z_LVAL_PP(tmp);
5327 			}
5328 		} else {
5329 			php_error_docref(NULL TSRMLS_CC, E_WARNING, "Missing height");
5330 			RETURN_FALSE;
5331 		}
5332 		pRect = &rect;
5333 	} else {
5334 		rect.x = -1;
5335 		rect.y = -1;
5336 		rect.width = gdImageSX(src);
5337 		rect.height = gdImageSY(src);
5338 		pRect = NULL;
5339 	}
5340 
5341 	if (gdTransformAffineGetImage(&dst, src, pRect, affine) != GD_TRUE) {
5342 		RETURN_FALSE;
5343 	}
5344 
5345 	if (dst == NULL) {
5346 		RETURN_FALSE;
5347 	} else {
5348 		ZEND_REGISTER_RESOURCE(return_value, dst, le_gd);
5349 	}
5350 }
5351 /* }}} */
5352 
5353 /* {{{ proto array imageaffinematrixget(type[, options])
5354    Return an image containing the affine tramsformed src image, using an optional clipping area */
PHP_FUNCTION(imageaffinematrixget)5355 PHP_FUNCTION(imageaffinematrixget)
5356 {
5357 	double affine[6];
5358 	long type;
5359 	zval *options = NULL;
5360 	zval **tmp;
5361 	int res = GD_FALSE, i;
5362 
5363 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l|z", &type, &options) == FAILURE)  {
5364 		return;
5365 	}
5366 
5367 	switch((gdAffineStandardMatrix)type) {
5368 		case GD_AFFINE_TRANSLATE:
5369 		case GD_AFFINE_SCALE: {
5370 			double x, y;
5371 			if (!options || Z_TYPE_P(options) != IS_ARRAY) {
5372 				php_error_docref(NULL TSRMLS_CC, E_WARNING, "Array expected as options");
5373 				RETURN_FALSE;
5374 			}
5375 			if (zend_hash_find(HASH_OF(options), "x", sizeof("x"), (void **)&tmp) != FAILURE) {
5376 				if (Z_TYPE_PP(tmp) != IS_DOUBLE) {
5377 					zval dval;
5378 					dval = **tmp;
5379 					zval_copy_ctor(&dval);
5380 					convert_to_double(&dval);
5381 					x = Z_DVAL(dval);
5382 				} else {
5383 					x = Z_DVAL_PP(tmp);
5384 				}
5385 			} else {
5386 				php_error_docref(NULL TSRMLS_CC, E_WARNING, "Missing x position");
5387 				RETURN_FALSE;
5388 			}
5389 
5390 			if (zend_hash_find(HASH_OF(options), "y", sizeof("y"), (void **)&tmp) != FAILURE) {
5391 				if (Z_TYPE_PP(tmp) != IS_DOUBLE) {
5392 					zval dval;
5393 					dval = **tmp;
5394 					zval_copy_ctor(&dval);
5395 					convert_to_double(&dval);
5396 					y = Z_DVAL(dval);
5397 				} else {
5398 					y = Z_DVAL_PP(tmp);
5399 				}
5400 			} else {
5401 				php_error_docref(NULL TSRMLS_CC, E_WARNING, "Missing y position");
5402 				RETURN_FALSE;
5403 			}
5404 
5405 			if (type == GD_AFFINE_TRANSLATE) {
5406 				res = gdAffineTranslate(affine, x, y);
5407 			} else {
5408 				res = gdAffineScale(affine, x, y);
5409 			}
5410 			break;
5411 		}
5412 
5413 		case GD_AFFINE_ROTATE:
5414 		case GD_AFFINE_SHEAR_HORIZONTAL:
5415 		case GD_AFFINE_SHEAR_VERTICAL: {
5416 			double angle;
5417 
5418 			if (!options) {
5419 				php_error_docref(NULL TSRMLS_CC, E_WARNING, "Number is expected as option");
5420 				RETURN_FALSE;
5421 			}
5422 			if(Z_TYPE_P(options) != IS_DOUBLE) {
5423 				zval dval;
5424 				dval = *options;
5425 				zval_copy_ctor(&dval);
5426 				convert_to_double(&dval);
5427 				angle = Z_DVAL(dval);
5428 			} else {
5429 				angle = Z_DVAL_P(options);
5430 			}
5431 
5432 			if (type == GD_AFFINE_SHEAR_HORIZONTAL) {
5433 				res = gdAffineShearHorizontal(affine, angle);
5434 			} else if (type == GD_AFFINE_SHEAR_VERTICAL) {
5435 				res = gdAffineShearVertical(affine, angle);
5436 			} else {
5437 				res = gdAffineRotate(affine, angle);
5438 			}
5439 			break;
5440 		}
5441 
5442 		default:
5443 			php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid type for element %li", type);
5444 			RETURN_FALSE;
5445 	}
5446 
5447 	if (res == GD_FALSE) {
5448 		RETURN_FALSE;
5449 	} else {
5450 		array_init(return_value);
5451 		for (i = 0; i < 6; i++) {
5452 			add_index_double(return_value, i, affine[i]);
5453 		}
5454 	}
5455 }
5456 
5457 
5458 /* {{{ proto array imageaffineconcat(array m1, array m2)
5459    Concat two matrices (as in doing many ops in one go) */
PHP_FUNCTION(imageaffinematrixconcat)5460 PHP_FUNCTION(imageaffinematrixconcat)
5461 {
5462 	double m1[6];
5463 	double m2[6];
5464 	double mr[6];
5465 
5466 	zval **tmp;
5467 	zval *z_m1;
5468 	zval *z_m2;
5469 	int i, nelems;
5470 
5471 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "aa", &z_m1, &z_m2) == FAILURE)  {
5472 		return;
5473 	}
5474 
5475 	if (((nelems = zend_hash_num_elements(Z_ARRVAL_P(z_m1))) != 6) || (nelems = zend_hash_num_elements(Z_ARRVAL_P(z_m2))) != 6) {
5476 		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Affine arrays must have six elements");
5477 		RETURN_FALSE;
5478 	}
5479 
5480 	for (i = 0; i < 6; i++) {
5481 		if (zend_hash_index_find(Z_ARRVAL_P(z_m1), i, (void **) &tmp) == SUCCESS) {
5482 			switch (Z_TYPE_PP(tmp)) {
5483 				case IS_LONG:
5484 					m1[i]  = Z_LVAL_PP(tmp);
5485 					break;
5486 				case IS_DOUBLE:
5487 					m1[i] = Z_DVAL_PP(tmp);
5488 					break;
5489 				case IS_STRING:
5490 					{
5491 						zval dval;
5492 						dval = **tmp;
5493 						zval_copy_ctor(&dval);
5494 						convert_to_double(&dval);
5495 						m1[i] = Z_DVAL(dval);
5496 					}
5497 					break;
5498 				default:
5499 					php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid type for element %i", i);
5500 					RETURN_FALSE;
5501 			}
5502 		}
5503 		if (zend_hash_index_find(Z_ARRVAL_P(z_m2), i, (void **) &tmp) == SUCCESS) {
5504 			switch (Z_TYPE_PP(tmp)) {
5505 				case IS_LONG:
5506 					m2[i]  = Z_LVAL_PP(tmp);
5507 					break;
5508 				case IS_DOUBLE:
5509 					m2[i] = Z_DVAL_PP(tmp);
5510 					break;
5511 				case IS_STRING:
5512 					{
5513 						zval dval;
5514 						dval = **tmp;
5515 						zval_copy_ctor(&dval);
5516 						convert_to_double(&dval);
5517 						m2[i] = Z_DVAL(dval);
5518 					}
5519 					break;
5520 				default:
5521 					php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid type for element %i", i);
5522 					RETURN_FALSE;
5523 			}
5524 		}
5525 	}
5526 
5527 	if (gdAffineConcat (mr, m1, m2) != GD_TRUE) {
5528 		RETURN_FALSE;
5529 	}
5530 
5531 	array_init(return_value);
5532 	for (i = 0; i < 6; i++) {
5533 		add_index_double(return_value, i, mr[i]);
5534 	}
5535 }
5536 
5537 /* {{{ proto resource imagesetinterpolation(resource im, [, method]])
5538    Set the default interpolation method, passing -1 or 0 sets it to the libgd default (bilinear). */
PHP_FUNCTION(imagesetinterpolation)5539 PHP_FUNCTION(imagesetinterpolation)
5540 {
5541 	zval *IM;
5542 	gdImagePtr im;
5543 	long method = GD_BILINEAR_FIXED;
5544 
5545 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r|l", &IM, &method) == FAILURE)  {
5546 		return;
5547 	}
5548 
5549 	ZEND_FETCH_RESOURCE(im, gdImagePtr, &IM, -1, "Image", le_gd);
5550 
5551 	if (method == -1) {
5552 		 method = GD_BILINEAR_FIXED;
5553 	}
5554 	RETURN_BOOL(gdImageSetInterpolationMethod(im, (gdInterpolationMethod) method));
5555 }
5556 /* }}} */
5557 
5558 /*
5559  * Local variables:
5560  * tab-width: 4
5561  * c-basic-offset: 4
5562  * End:
5563  * vim600: sw=4 ts=4 fdm=marker
5564  * vim<600: sw=4 ts=4
5565  */
5566