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