1
2 #include <math.h>
3 #include <string.h>
4 #include <stdlib.h>
5 #include "gd.h"
6 #include "gdhelpers.h"
7 #include "gd_errors.h"
8
9 #include "php.h"
10
11 #ifdef _MSC_VER
12 # if _MSC_VER >= 1300
13 /* in MSVC.NET these are available but only for __cplusplus and not _MSC_EXTENSIONS */
14 # if !defined(_MSC_EXTENSIONS) && defined(__cplusplus)
15 # define HAVE_FABSF 1
16 extern float fabsf(float x);
17 # define HAVE_FLOORF 1
18 extern float floorf(float x);
19 # endif /*MSVC.NET */
20 # endif /* MSC */
21 #endif
22 #ifndef HAVE_FABSF
23 # define HAVE_FABSF 0
24 #endif
25 #ifndef HAVE_FLOORF
26 # define HAVE_FLOORF 0
27 #endif
28 #if HAVE_FABSF == 0
29 /* float fabsf(float x); */
30 # ifndef fabsf
31 # define fabsf(x) ((float)(fabs(x)))
32 # endif
33 #endif
34 #if HAVE_FLOORF == 0
35 # ifndef floorf
36 /* float floorf(float x);*/
37 # define floorf(x) ((float)(floor(x)))
38 # endif
39 #endif
40
41 #ifdef _OSD_POSIX /* BS2000 uses the EBCDIC char set instead of ASCII */
42 #define CHARSET_EBCDIC
43 #define __attribute__(any) /*nothing */
44 #endif
45 /*_OSD_POSIX*/
46
47 #ifndef CHARSET_EBCDIC
48 #define ASC(ch) ch
49 #else /*CHARSET_EBCDIC */
50 #define ASC(ch) gd_toascii[(unsigned char)ch]
51 static const unsigned char gd_toascii[256] =
52 {
53 /*00 */ 0x00, 0x01, 0x02, 0x03, 0x85, 0x09, 0x86, 0x7f,
54 0x87, 0x8d, 0x8e, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, /*................ */
55 /*10 */ 0x10, 0x11, 0x12, 0x13, 0x8f, 0x0a, 0x08, 0x97,
56 0x18, 0x19, 0x9c, 0x9d, 0x1c, 0x1d, 0x1e, 0x1f, /*................ */
57 /*20 */ 0x80, 0x81, 0x82, 0x83, 0x84, 0x92, 0x17, 0x1b,
58 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x05, 0x06, 0x07, /*................ */
59 /*30 */ 0x90, 0x91, 0x16, 0x93, 0x94, 0x95, 0x96, 0x04,
60 0x98, 0x99, 0x9a, 0x9b, 0x14, 0x15, 0x9e, 0x1a, /*................ */
61 /*40 */ 0x20, 0xa0, 0xe2, 0xe4, 0xe0, 0xe1, 0xe3, 0xe5,
62 0xe7, 0xf1, 0x60, 0x2e, 0x3c, 0x28, 0x2b, 0x7c, /* .........`.<(+| */
63 /*50 */ 0x26, 0xe9, 0xea, 0xeb, 0xe8, 0xed, 0xee, 0xef,
64 0xec, 0xdf, 0x21, 0x24, 0x2a, 0x29, 0x3b, 0x9f, /*&.........!$*);. */
65 /*60 */ 0x2d, 0x2f, 0xc2, 0xc4, 0xc0, 0xc1, 0xc3, 0xc5,
66 0xc7, 0xd1, 0x5e, 0x2c, 0x25, 0x5f, 0x3e, 0x3f,
67 /*-/........^,%_>?*/
68 /*70 */ 0xf8, 0xc9, 0xca, 0xcb, 0xc8, 0xcd, 0xce, 0xcf,
69 0xcc, 0xa8, 0x3a, 0x23, 0x40, 0x27, 0x3d, 0x22, /*..........:#@'=" */
70 /*80 */ 0xd8, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67,
71 0x68, 0x69, 0xab, 0xbb, 0xf0, 0xfd, 0xfe, 0xb1, /*.abcdefghi...... */
72 /*90 */ 0xb0, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70,
73 0x71, 0x72, 0xaa, 0xba, 0xe6, 0xb8, 0xc6, 0xa4, /*.jklmnopqr...... */
74 /*a0 */ 0xb5, 0xaf, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78,
75 0x79, 0x7a, 0xa1, 0xbf, 0xd0, 0xdd, 0xde, 0xae, /*..stuvwxyz...... */
76 /*b0 */ 0xa2, 0xa3, 0xa5, 0xb7, 0xa9, 0xa7, 0xb6, 0xbc,
77 0xbd, 0xbe, 0xac, 0x5b, 0x5c, 0x5d, 0xb4, 0xd7, /*...........[\].. */
78 /*c0 */ 0xf9, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
79 0x48, 0x49, 0xad, 0xf4, 0xf6, 0xf2, 0xf3, 0xf5, /*.ABCDEFGHI...... */
80 /*d0 */ 0xa6, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50,
81 0x51, 0x52, 0xb9, 0xfb, 0xfc, 0xdb, 0xfa, 0xff, /*.JKLMNOPQR...... */
82 /*e0 */ 0xd9, 0xf7, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58,
83 0x59, 0x5a, 0xb2, 0xd4, 0xd6, 0xd2, 0xd3, 0xd5, /*..STUVWXYZ...... */
84 /*f0 */ 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
85 0x38, 0x39, 0xb3, 0x7b, 0xdc, 0x7d, 0xda, 0x7e /*0123456789.{.}.~ */
86 };
87 #endif /*CHARSET_EBCDIC */
88
89 /* 2.0.10: cast instead of floor() yields 35% performance improvement. Thanks to John Buckman. */
90 #define floor_cast(exp) ((long) exp)
91
92 extern int gdCosT[];
93 extern int gdSinT[];
94
95 /**
96 * Group: Error Handling
97 */
98
gd_stderr_error(int priority,const char * format,va_list args)99 void gd_stderr_error(int priority, const char *format, va_list args)
100 {
101 switch (priority) {
102 case GD_ERROR:
103 fputs("GD Error: ", stderr);
104 break;
105 case GD_WARNING:
106 fputs("GD Warning: ", stderr);
107 break;
108 case GD_NOTICE:
109 fputs("GD Notice: ", stderr);
110 break;
111 #ifndef PHP_WIN32
112 case GD_INFO:
113 fputs("GD Info: ", stderr);
114 break;
115 case GD_DEBUG:
116 fputs("GD Debug: ", stderr);
117 break;
118 #endif
119 }
120 vfprintf(stderr, format, args);
121 fflush(stderr);
122 }
123
124 static gdErrorMethod gd_error_method = gd_stderr_error;
125
_gd_error_ex(int priority,const char * format,va_list args)126 static void _gd_error_ex(int priority, const char *format, va_list args)
127 {
128 if (gd_error_method) {
129 gd_error_method(priority, format, args);
130 }
131 }
132
gd_error(const char * format,...)133 void gd_error(const char *format, ...)
134 {
135 va_list args;
136
137 va_start(args, format);
138 _gd_error_ex(GD_WARNING, format, args);
139 va_end(args);
140 }
gd_error_ex(int priority,const char * format,...)141 void gd_error_ex(int priority, const char *format, ...)
142 {
143 va_list args;
144
145 va_start(args, format);
146 _gd_error_ex(priority, format, args);
147 va_end(args);
148 }
149
150 /*
151 Function: gdSetErrorMethod
152 */
gdSetErrorMethod(gdErrorMethod error_method)153 void gdSetErrorMethod(gdErrorMethod error_method)
154 {
155 gd_error_method = error_method;
156 }
157
158 /*
159 Function: gdClearErrorMethod
160 */
gdClearErrorMethod(void)161 void gdClearErrorMethod(void)
162 {
163 gd_error_method = gd_stderr_error;
164 }
165
166 static void gdImageBrushApply(gdImagePtr im, int x, int y);
167 static void gdImageTileApply(gdImagePtr im, int x, int y);
168 static int gdAlphaOverlayColor(int src, int dst, int max);
169 int gdImageGetTrueColorPixel(gdImagePtr im, int x, int y);
170
gdImageCreate(int sx,int sy)171 gdImagePtr gdImageCreate (int sx, int sy)
172 {
173 int i;
174 gdImagePtr im;
175
176 if (overflow2(sx, sy)) {
177 return NULL;
178 }
179 if (overflow2(sizeof(unsigned char *), sy)) {
180 return NULL;
181 }
182 if (overflow2(sizeof(unsigned char), sx)) {
183 return NULL;
184 }
185
186 im = (gdImage *) gdCalloc(1, sizeof(gdImage));
187
188 /* Row-major ever since gd 1.3 */
189 im->pixels = (unsigned char **) gdMalloc(sizeof(unsigned char *) * sy);
190 im->polyInts = 0;
191 im->polyAllocated = 0;
192 im->brush = 0;
193 im->tile = 0;
194 im->style = 0;
195 for (i = 0; i < sy; i++) {
196 /* Row-major ever since gd 1.3 */
197 im->pixels[i] = (unsigned char *) gdCalloc(sx, sizeof(unsigned char));
198 }
199 im->sx = sx;
200 im->sy = sy;
201 im->colorsTotal = 0;
202 im->transparent = (-1);
203 im->interlace = 0;
204 im->thick = 1;
205 im->AA = 0;
206 for (i = 0; i < gdMaxColors; i++) {
207 im->open[i] = 1;
208 im->red[i] = 0;
209 im->green[i] = 0;
210 im->blue[i] = 0;
211 }
212 im->trueColor = 0;
213 im->tpixels = 0;
214 im->cx1 = 0;
215 im->cy1 = 0;
216 im->cx2 = im->sx - 1;
217 im->cy2 = im->sy - 1;
218 im->res_x = GD_RESOLUTION;
219 im->res_y = GD_RESOLUTION;
220 im->interpolation = NULL;
221 im->interpolation_id = GD_BILINEAR_FIXED;
222 return im;
223 }
224
gdImageCreateTrueColor(int sx,int sy)225 gdImagePtr gdImageCreateTrueColor (int sx, int sy)
226 {
227 int i;
228 gdImagePtr im;
229
230 if (overflow2(sx, sy)) {
231 return NULL;
232 }
233 if (overflow2(sizeof(int *), sy)) {
234 return NULL;
235 }
236 if (overflow2(sizeof(int), sx)) {
237 return NULL;
238 }
239
240 im = (gdImage *) gdMalloc(sizeof(gdImage));
241 memset(im, 0, sizeof(gdImage));
242 im->tpixels = (int **) gdMalloc(sizeof(int *) * sy);
243 im->polyInts = 0;
244 im->polyAllocated = 0;
245 im->brush = 0;
246 im->tile = 0;
247 im->style = 0;
248 for (i = 0; i < sy; i++) {
249 im->tpixels[i] = (int *) gdCalloc(sx, sizeof(int));
250 }
251 im->sx = sx;
252 im->sy = sy;
253 im->transparent = (-1);
254 im->interlace = 0;
255 im->trueColor = 1;
256 /* 2.0.2: alpha blending is now on by default, and saving of alpha is
257 * off by default. This allows font antialiasing to work as expected
258 * on the first try in JPEGs -- quite important -- and also allows
259 * for smaller PNGs when saving of alpha channel is not really
260 * desired, which it usually isn't!
261 */
262 im->saveAlphaFlag = 0;
263 im->alphaBlendingFlag = 1;
264 im->thick = 1;
265 im->AA = 0;
266 im->cx1 = 0;
267 im->cy1 = 0;
268 im->cx2 = im->sx - 1;
269 im->cy2 = im->sy - 1;
270 im->res_x = GD_RESOLUTION;
271 im->res_y = GD_RESOLUTION;
272 im->interpolation = NULL;
273 im->interpolation_id = GD_BILINEAR_FIXED;
274 return im;
275 }
276
gdImageDestroy(gdImagePtr im)277 void gdImageDestroy (gdImagePtr im)
278 {
279 int i;
280 if (im->pixels) {
281 for (i = 0; i < im->sy; i++) {
282 gdFree(im->pixels[i]);
283 }
284 gdFree(im->pixels);
285 }
286 if (im->tpixels) {
287 for (i = 0; i < im->sy; i++) {
288 gdFree(im->tpixels[i]);
289 }
290 gdFree(im->tpixels);
291 }
292 if (im->polyInts) {
293 gdFree(im->polyInts);
294 }
295 if (im->style) {
296 gdFree(im->style);
297 }
298 gdFree(im);
299 }
300
gdImageColorClosest(gdImagePtr im,int r,int g,int b)301 int gdImageColorClosest (gdImagePtr im, int r, int g, int b)
302 {
303 return gdImageColorClosestAlpha (im, r, g, b, gdAlphaOpaque);
304 }
305
gdImageColorClosestAlpha(gdImagePtr im,int r,int g,int b,int a)306 int gdImageColorClosestAlpha (gdImagePtr im, int r, int g, int b, int a)
307 {
308 int i;
309 long rd, gd, bd, ad;
310 int ct = (-1);
311 int first = 1;
312 long mindist = 0;
313
314 if (im->trueColor) {
315 return gdTrueColorAlpha(r, g, b, a);
316 }
317 for (i = 0; i < im->colorsTotal; i++) {
318 long dist;
319 if (im->open[i]) {
320 continue;
321 }
322 rd = im->red[i] - r;
323 gd = im->green[i] - g;
324 bd = im->blue[i] - b;
325 /* gd 2.02: whoops, was - b (thanks to David Marwood) */
326 ad = im->alpha[i] - a;
327 dist = rd * rd + gd * gd + bd * bd + ad * ad;
328 if (first || (dist < mindist)) {
329 mindist = dist;
330 ct = i;
331 first = 0;
332 }
333 }
334 return ct;
335 }
336
337 /* This code is taken from http://www.acm.org/jgt/papers/SmithLyons96/hwb_rgb.html, an article
338 * on colour conversion to/from RBG and HWB colour systems.
339 * It has been modified to return the converted value as a * parameter.
340 */
341
342 #define RETURN_HWB(h, w, b) {HWB->H = h; HWB->W = w; HWB->B = b; return HWB;}
343 #define RETURN_RGB(r, g, b) {RGB->R = r; RGB->G = g; RGB->B = b; return RGB;}
344 #define HWB_UNDEFINED -1
345 #define SETUP_RGB(s, r, g, b) {s.R = r/255.0f; s.G = g/255.0f; s.B = b/255.0f;}
346
347 #ifndef MIN
348 #define MIN(a,b) ((a)<(b)?(a):(b))
349 #endif
350 #define MIN3(a,b,c) ((a)<(b)?(MIN(a,c)):(MIN(b,c)))
351 #ifndef MAX
352 #define MAX(a,b) ((a)<(b)?(b):(a))
353 #endif
354 #define MAX3(a,b,c) ((a)<(b)?(MAX(b,c)):(MAX(a,c)))
355
356
357 /*
358 * Theoretically, hue 0 (pure red) is identical to hue 6 in these transforms. Pure
359 * red always maps to 6 in this implementation. Therefore UNDEFINED can be
360 * defined as 0 in situations where only unsigned numbers are desired.
361 */
362 typedef struct
363 {
364 float R, G, B;
365 }
366 RGBType;
367 typedef struct
368 {
369 float H, W, B;
370 }
371 HWBType;
372
RGB_to_HWB(RGBType RGB,HWBType * HWB)373 static HWBType * RGB_to_HWB (RGBType RGB, HWBType * HWB)
374 {
375 /*
376 * RGB are each on [0, 1]. W and B are returned on [0, 1] and H is
377 * returned on [0, 6]. Exception: H is returned UNDEFINED if W == 1 - B.
378 */
379
380 float R = RGB.R, G = RGB.G, B = RGB.B, w, v, b, f;
381 int i;
382
383 w = MIN3 (R, G, B);
384 v = MAX3 (R, G, B);
385 b = 1 - v;
386 if (v == w) {
387 RETURN_HWB(HWB_UNDEFINED, w, b);
388 }
389 f = (R == w) ? G - B : ((G == w) ? B - R : R - G);
390 i = (R == w) ? 3 : ((G == w) ? 5 : 1);
391
392 RETURN_HWB(i - f / (v - w), w, b);
393 }
394
HWB_Diff(int r1,int g1,int b1,int r2,int g2,int b2)395 static float HWB_Diff (int r1, int g1, int b1, int r2, int g2, int b2)
396 {
397 RGBType RGB1, RGB2;
398 HWBType HWB1, HWB2;
399 float diff;
400
401 SETUP_RGB(RGB1, r1, g1, b1);
402 SETUP_RGB(RGB2, r2, g2, b2);
403
404 RGB_to_HWB(RGB1, &HWB1);
405 RGB_to_HWB(RGB2, &HWB2);
406
407 /*
408 * I made this bit up; it seems to produce OK results, and it is certainly
409 * more visually correct than the current RGB metric. (PJW)
410 */
411
412 if ((HWB1.H == HWB_UNDEFINED) || (HWB2.H == HWB_UNDEFINED)) {
413 diff = 0.0f; /* Undefined hues always match... */
414 } else {
415 diff = fabsf(HWB1.H - HWB2.H);
416 if (diff > 3.0f) {
417 diff = 6.0f - diff; /* Remember, it's a colour circle */
418 }
419 }
420
421 diff = diff * diff + (HWB1.W - HWB2.W) * (HWB1.W - HWB2.W) + (HWB1.B - HWB2.B) * (HWB1.B - HWB2.B);
422
423 return diff;
424 }
425
426
427 #if 0
428 /*
429 * This is not actually used, but is here for completeness, in case someone wants to
430 * use the HWB stuff for anything else...
431 */
432 static RGBType * HWB_to_RGB (HWBType HWB, RGBType * RGB)
433 {
434 /*
435 * H is given on [0, 6] or UNDEFINED. W and B are given on [0, 1].
436 * RGB are each returned on [0, 1].
437 */
438
439 float h = HWB.H, w = HWB.W, b = HWB.B, v, n, f;
440 int i;
441
442 v = 1 - b;
443 if (h == HWB_UNDEFINED) {
444 RETURN_RGB(v, v, v);
445 }
446 i = floor(h);
447 f = h - i;
448 if (i & 1) {
449 f = 1 - f; /* if i is odd */
450 }
451 n = w + f * (v - w); /* linear interpolation between w and v */
452 switch (i) {
453 case 6:
454 case 0:
455 RETURN_RGB(v, n, w);
456 case 1:
457 RETURN_RGB(n, v, w);
458 case 2:
459 RETURN_RGB(w, v, n);
460 case 3:
461 RETURN_RGB(w, n, v);
462 case 4:
463 RETURN_RGB(n, w, v);
464 case 5:
465 RETURN_RGB(v, w, n);
466 }
467
468 return RGB;
469 }
470 #endif
471
gdImageColorClosestHWB(gdImagePtr im,int r,int g,int b)472 int gdImageColorClosestHWB (gdImagePtr im, int r, int g, int b)
473 {
474 int i;
475 /* long rd, gd, bd; */
476 int ct = (-1);
477 int first = 1;
478 float mindist = 0;
479 if (im->trueColor) {
480 return gdTrueColor(r, g, b);
481 }
482 for (i = 0; i < im->colorsTotal; i++) {
483 float dist;
484 if (im->open[i]) {
485 continue;
486 }
487 dist = HWB_Diff(im->red[i], im->green[i], im->blue[i], r, g, b);
488 if (first || (dist < mindist)) {
489 mindist = dist;
490 ct = i;
491 first = 0;
492 }
493 }
494 return ct;
495 }
496
gdImageColorExact(gdImagePtr im,int r,int g,int b)497 int gdImageColorExact (gdImagePtr im, int r, int g, int b)
498 {
499 return gdImageColorExactAlpha (im, r, g, b, gdAlphaOpaque);
500 }
501
gdImageColorExactAlpha(gdImagePtr im,int r,int g,int b,int a)502 int gdImageColorExactAlpha (gdImagePtr im, int r, int g, int b, int a)
503 {
504 int i;
505 if (im->trueColor) {
506 return gdTrueColorAlpha(r, g, b, a);
507 }
508 for (i = 0; i < im->colorsTotal; i++) {
509 if (im->open[i]) {
510 continue;
511 }
512 if ((im->red[i] == r) && (im->green[i] == g) && (im->blue[i] == b) && (im->alpha[i] == a)) {
513 return i;
514 }
515 }
516 return -1;
517 }
518
gdImageColorAllocate(gdImagePtr im,int r,int g,int b)519 int gdImageColorAllocate (gdImagePtr im, int r, int g, int b)
520 {
521 return gdImageColorAllocateAlpha (im, r, g, b, gdAlphaOpaque);
522 }
523
gdImageColorAllocateAlpha(gdImagePtr im,int r,int g,int b,int a)524 int gdImageColorAllocateAlpha (gdImagePtr im, int r, int g, int b, int a)
525 {
526 int i;
527 int ct = (-1);
528 if (im->trueColor) {
529 return gdTrueColorAlpha(r, g, b, a);
530 }
531 for (i = 0; i < im->colorsTotal; i++) {
532 if (im->open[i]) {
533 ct = i;
534 break;
535 }
536 }
537 if (ct == (-1)) {
538 ct = im->colorsTotal;
539 if (ct == gdMaxColors) {
540 return -1;
541 }
542 im->colorsTotal++;
543 }
544 im->red[ct] = r;
545 im->green[ct] = g;
546 im->blue[ct] = b;
547 im->alpha[ct] = a;
548 im->open[ct] = 0;
549
550 return ct;
551 }
552
553 /*
554 * gdImageColorResolve is an alternative for the code fragment:
555 *
556 * if ((color=gdImageColorExact(im,R,G,B)) < 0)
557 * if ((color=gdImageColorAllocate(im,R,G,B)) < 0)
558 * color=gdImageColorClosest(im,R,G,B);
559 *
560 * in a single function. Its advantage is that it is guaranteed to
561 * return a color index in one search over the color table.
562 */
563
gdImageColorResolve(gdImagePtr im,int r,int g,int b)564 int gdImageColorResolve (gdImagePtr im, int r, int g, int b)
565 {
566 return gdImageColorResolveAlpha(im, r, g, b, gdAlphaOpaque);
567 }
568
gdImageColorResolveAlpha(gdImagePtr im,int r,int g,int b,int a)569 int gdImageColorResolveAlpha (gdImagePtr im, int r, int g, int b, int a)
570 {
571 int c;
572 int ct = -1;
573 int op = -1;
574 long rd, gd, bd, ad, dist;
575 long mindist = 4 * 255 * 255; /* init to max poss dist */
576 if (im->trueColor)
577 {
578 return gdTrueColorAlpha (r, g, b, a);
579 }
580
581 for (c = 0; c < im->colorsTotal; c++)
582 {
583 if (im->open[c])
584 {
585 op = c; /* Save open slot */
586 continue; /* Color not in use */
587 }
588 if (c == im->transparent)
589 {
590 /* don't ever resolve to the color that has
591 * been designated as the transparent color */
592 continue;
593 }
594 rd = (long) (im->red[c] - r);
595 gd = (long) (im->green[c] - g);
596 bd = (long) (im->blue[c] - b);
597 ad = (long) (im->alpha[c] - a);
598 dist = rd * rd + gd * gd + bd * bd + ad * ad;
599 if (dist < mindist)
600 {
601 if (dist == 0)
602 {
603 return c; /* Return exact match color */
604 }
605 mindist = dist;
606 ct = c;
607 }
608 }
609 /* no exact match. We now know closest, but first try to allocate exact */
610 if (op == -1)
611 {
612 op = im->colorsTotal;
613 if (op == gdMaxColors)
614 { /* No room for more colors */
615 return ct; /* Return closest available color */
616 }
617 im->colorsTotal++;
618 }
619 im->red[op] = r;
620 im->green[op] = g;
621 im->blue[op] = b;
622 im->alpha[op] = a;
623 im->open[op] = 0;
624 return op; /* Return newly allocated color */
625 }
626
gdImageColorDeallocate(gdImagePtr im,int color)627 void gdImageColorDeallocate (gdImagePtr im, int color)
628 {
629 if (im->trueColor) {
630 return;
631 }
632 /* Mark it open. */
633 im->open[color] = 1;
634 }
635
gdImageColorTransparent(gdImagePtr im,int color)636 void gdImageColorTransparent (gdImagePtr im, int color)
637 {
638 if (color < 0) {
639 return;
640 }
641 if (!im->trueColor) {
642 if((color >= im->colorsTotal)) {
643 return;
644 }
645 /* Make the old transparent color opaque again */
646 if (im->transparent != -1) {
647 im->alpha[im->transparent] = gdAlphaOpaque;
648 }
649 im->alpha[color] = gdAlphaTransparent;
650 }
651 im->transparent = color;
652 }
653
gdImagePaletteCopy(gdImagePtr to,gdImagePtr from)654 void gdImagePaletteCopy (gdImagePtr to, gdImagePtr from)
655 {
656 int i;
657 int x, y, p;
658 int xlate[256];
659 if (to->trueColor || from->trueColor) {
660 return;
661 }
662
663 for (i = 0; i < 256; i++) {
664 xlate[i] = -1;
665 }
666
667 for (y = 0; y < to->sy; y++) {
668 for (x = 0; x < to->sx; x++) {
669 p = gdImageGetPixel(to, x, y);
670 if (xlate[p] == -1) {
671 /* This ought to use HWB, but we don't have an alpha-aware version of that yet. */
672 xlate[p] = gdImageColorClosestAlpha (from, to->red[p], to->green[p], to->blue[p], to->alpha[p]);
673 }
674 gdImageSetPixel(to, x, y, xlate[p]);
675 }
676 }
677
678 for (i = 0; i < from->colorsTotal; i++) {
679 to->red[i] = from->red[i];
680 to->blue[i] = from->blue[i];
681 to->green[i] = from->green[i];
682 to->alpha[i] = from->alpha[i];
683 to->open[i] = 0;
684 }
685
686 for (i = from->colorsTotal; i < to->colorsTotal; i++) {
687 to->open[i] = 1;
688 }
689
690 to->colorsTotal = from->colorsTotal;
691 }
692
693 /* 2.0.10: before the drawing routines, some code to clip points that are
694 * outside the drawing window. Nick Atty (nick@canalplan.org.uk)
695 *
696 * This is the Sutherland Hodgman Algorithm, as implemented by
697 * Duvanenko, Robbins and Gyurcsik - SH(DRG) for short. See Dr Dobb's
698 * Journal, January 1996, pp107-110 and 116-117
699 *
700 * Given the end points of a line, and a bounding rectangle (which we
701 * know to be from (0,0) to (SX,SY)), adjust the endpoints to be on
702 * the edges of the rectangle if the line should be drawn at all,
703 * otherwise return a failure code
704 */
705
706 /* this does "one-dimensional" clipping: note that the second time it
707 * is called, all the x parameters refer to height and the y to width
708 * - the comments ignore this (if you can understand it when it's
709 * looking at the X parameters, it should become clear what happens on
710 * the second call!) The code is simplified from that in the article,
711 * as we know that gd images always start at (0,0)
712 */
713
clip_1d(int * x0,int * y0,int * x1,int * y1,int maxdim)714 static int clip_1d(int *x0, int *y0, int *x1, int *y1, int maxdim) {
715 double m; /* gradient of line */
716
717 if (*x0 < 0) { /* start of line is left of window */
718 if(*x1 < 0) { /* as is the end, so the line never cuts the window */
719 return 0;
720 }
721 m = (*y1 - *y0)/(double)(*x1 - *x0); /* calculate the slope of the line */
722 /* adjust x0 to be on the left boundary (ie to be zero), and y0 to match */
723 *y0 -= (int)(m * *x0);
724 *x0 = 0;
725 /* now, perhaps, adjust the far end of the line as well */
726 if (*x1 > maxdim) {
727 *y1 += (int)(m * (maxdim - *x1));
728 *x1 = maxdim;
729 }
730 return 1;
731 }
732 if (*x0 > maxdim) { /* start of line is right of window - complement of above */
733 if (*x1 > maxdim) { /* as is the end, so the line misses the window */
734 return 0;
735 }
736 m = (*y1 - *y0)/(double)(*x1 - *x0); /* calculate the slope of the line */
737 *y0 += (int)(m * (maxdim - *x0)); /* adjust so point is on the right boundary */
738 *x0 = maxdim;
739 /* now, perhaps, adjust the end of the line */
740 if (*x1 < 0) {
741 *y1 -= (int)(m * *x1);
742 *x1 = 0;
743 }
744 return 1;
745 }
746 /* the final case - the start of the line is inside the window */
747 if (*x1 > maxdim) { /* other end is outside to the right */
748 m = (*y1 - *y0)/(double)(*x1 - *x0); /* calculate the slope of the line */
749 *y1 += (int)(m * (maxdim - *x1));
750 *x1 = maxdim;
751 return 1;
752 }
753 if (*x1 < 0) { /* other end is outside to the left */
754 m = (*y1 - *y0)/(double)(*x1 - *x0); /* calculate the slope of the line */
755 *y1 -= (int)(m * *x1);
756 *x1 = 0;
757 return 1;
758 }
759 /* only get here if both points are inside the window */
760 return 1;
761 }
762
gdImageSetPixel(gdImagePtr im,int x,int y,int color)763 void gdImageSetPixel (gdImagePtr im, int x, int y, int color)
764 {
765 int p;
766 switch (color) {
767 case gdStyled:
768 if (!im->style) {
769 /* Refuse to draw if no style is set. */
770 return;
771 } else {
772 p = im->style[im->stylePos++];
773 }
774 if (p != gdTransparent) {
775 gdImageSetPixel(im, x, y, p);
776 }
777 im->stylePos = im->stylePos % im->styleLength;
778 break;
779 case gdStyledBrushed:
780 if (!im->style) {
781 /* Refuse to draw if no style is set. */
782 return;
783 }
784 p = im->style[im->stylePos++];
785 if (p != gdTransparent && p != 0) {
786 gdImageSetPixel(im, x, y, gdBrushed);
787 }
788 im->stylePos = im->stylePos % im->styleLength;
789 break;
790 case gdBrushed:
791 gdImageBrushApply(im, x, y);
792 break;
793 case gdTiled:
794 gdImageTileApply(im, x, y);
795 break;
796 case gdAntiAliased:
797 /* This shouldn't happen (2.0.26) because we just call
798 gdImageAALine now, but do something sane. */
799 gdImageSetPixel(im, x, y, im->AA_color);
800 break;
801 default:
802 if (gdImageBoundsSafe(im, x, y)) {
803 if (im->trueColor) {
804 switch (im->alphaBlendingFlag) {
805 default:
806 case gdEffectReplace:
807 im->tpixels[y][x] = color;
808 break;
809 case gdEffectAlphaBlend:
810 case gdEffectNormal:
811 im->tpixels[y][x] = gdAlphaBlend(im->tpixels[y][x], color);
812 break;
813 case gdEffectOverlay :
814 im->tpixels[y][x] = gdLayerOverlay(im->tpixels[y][x], color);
815 break;
816 case gdEffectMultiply :
817 im->tpixels[y][x] = gdLayerMultiply(im->tpixels[y][x], color);
818 break;
819 }
820 } else {
821 im->pixels[y][x] = color;
822 }
823 }
824 break;
825 }
826 }
827
gdImageGetTrueColorPixel(gdImagePtr im,int x,int y)828 int gdImageGetTrueColorPixel (gdImagePtr im, int x, int y)
829 {
830 int p = gdImageGetPixel(im, x, y);
831
832 if (!im->trueColor) {
833 return gdTrueColorAlpha(im->red[p], im->green[p], im->blue[p], (im->transparent == p) ? gdAlphaTransparent : im->alpha[p]);
834 } else {
835 return p;
836 }
837 }
838
gdImageBrushApply(gdImagePtr im,int x,int y)839 static void gdImageBrushApply (gdImagePtr im, int x, int y)
840 {
841 int lx, ly;
842 int hy, hx;
843 int x1, y1, x2, y2;
844 int srcx, srcy;
845
846 if (!im->brush) {
847 return;
848 }
849
850 hy = gdImageSY(im->brush) / 2;
851 y1 = y - hy;
852 y2 = y1 + gdImageSY(im->brush);
853 hx = gdImageSX(im->brush) / 2;
854 x1 = x - hx;
855 x2 = x1 + gdImageSX(im->brush);
856 srcy = 0;
857
858 if (im->trueColor) {
859 if (im->brush->trueColor) {
860 for (ly = y1; ly < y2; ly++) {
861 srcx = 0;
862 for (lx = x1; (lx < x2); lx++) {
863 int p;
864 p = gdImageGetTrueColorPixel(im->brush, srcx, srcy);
865 /* 2.0.9, Thomas Winzig: apply simple full transparency */
866 if (p != gdImageGetTransparent(im->brush)) {
867 gdImageSetPixel(im, lx, ly, p);
868 }
869 srcx++;
870 }
871 srcy++;
872 }
873 } else {
874 /* 2.0.12: Brush palette, image truecolor (thanks to Thorben Kundinger for pointing out the issue) */
875 for (ly = y1; ly < y2; ly++) {
876 srcx = 0;
877 for (lx = x1; lx < x2; lx++) {
878 int p, tc;
879 p = gdImageGetPixel(im->brush, srcx, srcy);
880 tc = gdImageGetTrueColorPixel(im->brush, srcx, srcy);
881 /* 2.0.9, Thomas Winzig: apply simple full transparency */
882 if (p != gdImageGetTransparent(im->brush)) {
883 gdImageSetPixel(im, lx, ly, tc);
884 }
885 srcx++;
886 }
887 srcy++;
888 }
889 }
890 } else {
891 for (ly = y1; ly < y2; ly++) {
892 srcx = 0;
893 for (lx = x1; lx < x2; lx++) {
894 int p;
895 p = gdImageGetPixel(im->brush, srcx, srcy);
896 /* Allow for non-square brushes! */
897 if (p != gdImageGetTransparent(im->brush)) {
898 /* Truecolor brush. Very slow on a palette destination. */
899 if (im->brush->trueColor) {
900 gdImageSetPixel(im, lx, ly, gdImageColorResolveAlpha(im, gdTrueColorGetRed(p),
901 gdTrueColorGetGreen(p),
902 gdTrueColorGetBlue(p),
903 gdTrueColorGetAlpha(p)));
904 } else {
905 gdImageSetPixel(im, lx, ly, im->brushColorMap[p]);
906 }
907 }
908 srcx++;
909 }
910 srcy++;
911 }
912 }
913 }
914
gdImageTileApply(gdImagePtr im,int x,int y)915 static void gdImageTileApply (gdImagePtr im, int x, int y)
916 {
917 gdImagePtr tile = im->tile;
918 int srcx, srcy;
919 int p;
920 if (!tile) {
921 return;
922 }
923 srcx = x % gdImageSX(tile);
924 srcy = y % gdImageSY(tile);
925 if (im->trueColor) {
926 p = gdImageGetPixel(tile, srcx, srcy);
927 if (p != gdImageGetTransparent (tile)) {
928 if (!tile->trueColor) {
929 p = gdTrueColorAlpha(tile->red[p], tile->green[p], tile->blue[p], tile->alpha[p]);
930 }
931 gdImageSetPixel(im, x, y, p);
932 }
933 } else {
934 p = gdImageGetPixel(tile, srcx, srcy);
935 /* Allow for transparency */
936 if (p != gdImageGetTransparent(tile)) {
937 if (tile->trueColor) {
938 /* Truecolor tile. Very slow on a palette destination. */
939 gdImageSetPixel(im, x, y, gdImageColorResolveAlpha(im,
940 gdTrueColorGetRed(p),
941 gdTrueColorGetGreen(p),
942 gdTrueColorGetBlue(p),
943 gdTrueColorGetAlpha(p)));
944 } else {
945 gdImageSetPixel(im, x, y, im->tileColorMap[p]);
946 }
947 }
948 }
949 }
950
951
gdImageTileGet(gdImagePtr im,int x,int y)952 static int gdImageTileGet (gdImagePtr im, int x, int y)
953 {
954 int srcx, srcy;
955 int tileColor,p;
956 if (!im->tile) {
957 return -1;
958 }
959 srcx = x % gdImageSX(im->tile);
960 srcy = y % gdImageSY(im->tile);
961 p = gdImageGetPixel(im->tile, srcx, srcy);
962
963 if (im->trueColor) {
964 if (im->tile->trueColor) {
965 tileColor = p;
966 } else {
967 tileColor = gdTrueColorAlpha( gdImageRed(im->tile,p), gdImageGreen(im->tile,p), gdImageBlue (im->tile,p), gdImageAlpha (im->tile,p));
968 }
969 } else {
970 if (im->tile->trueColor) {
971 tileColor = gdImageColorResolveAlpha(im, gdTrueColorGetRed (p), gdTrueColorGetGreen (p), gdTrueColorGetBlue (p), gdTrueColorGetAlpha (p));
972 } else {
973 tileColor = p;
974 tileColor = gdImageColorResolveAlpha(im, gdImageRed (im->tile,p), gdImageGreen (im->tile,p), gdImageBlue (im->tile,p), gdImageAlpha (im->tile,p));
975 }
976 }
977 return tileColor;
978 }
979
980
gdImageGetPixel(gdImagePtr im,int x,int y)981 int gdImageGetPixel (gdImagePtr im, int x, int y)
982 {
983 if (gdImageBoundsSafe(im, x, y)) {
984 if (im->trueColor) {
985 return im->tpixels[y][x];
986 } else {
987 return im->pixels[y][x];
988 }
989 } else {
990 return 0;
991 }
992 }
993
gdImageAABlend(gdImagePtr im)994 void gdImageAABlend (gdImagePtr im)
995 {
996 (void)im;
997 }
998
999 static void _gdImageFilledHRectangle (gdImagePtr im, int x1, int y1, int x2, int y2, int color);
1000
gdImageHLine(gdImagePtr im,int y,int x1,int x2,int col)1001 static void gdImageHLine(gdImagePtr im, int y, int x1, int x2, int col)
1002 {
1003 if (im->thick > 1) {
1004 int thickhalf = im->thick >> 1;
1005 _gdImageFilledHRectangle(im, x1, y - thickhalf, x2, y + im->thick - thickhalf - 1, col);
1006 } else {
1007 if (x2 < x1) {
1008 int t = x2;
1009 x2 = x1;
1010 x1 = t;
1011 }
1012
1013 for (;x1 <= x2; x1++) {
1014 gdImageSetPixel(im, x1, y, col);
1015 }
1016 }
1017 return;
1018 }
1019
gdImageVLine(gdImagePtr im,int x,int y1,int y2,int col)1020 static void gdImageVLine(gdImagePtr im, int x, int y1, int y2, int col)
1021 {
1022 if (im->thick > 1) {
1023 int thickhalf = im->thick >> 1;
1024 gdImageFilledRectangle(im, x - thickhalf, y1, x + im->thick - thickhalf - 1, y2, col);
1025 } else {
1026 if (y2 < y1) {
1027 int t = y1;
1028 y1 = y2;
1029 y2 = t;
1030 }
1031
1032 for (;y1 <= y2; y1++) {
1033 gdImageSetPixel(im, x, y1, col);
1034 }
1035 }
1036 return;
1037 }
1038
1039 /* Bresenham as presented in Foley & Van Dam */
gdImageLine(gdImagePtr im,int x1,int y1,int x2,int y2,int color)1040 void gdImageLine (gdImagePtr im, int x1, int y1, int x2, int y2, int color)
1041 {
1042 int dx, dy, incr1, incr2, d, x, y, xend, yend, xdirflag, ydirflag;
1043 int wid;
1044 int w, wstart;
1045 int thick = im->thick;
1046
1047 if (color == gdAntiAliased) {
1048 /*
1049 gdAntiAliased passed as color: use the much faster, much cheaper
1050 and equally attractive gdImageAALine implementation. That
1051 clips too, so don't clip twice.
1052 */
1053 gdImageAALine(im, x1, y1, x2, y2, im->AA_color);
1054 return;
1055 }
1056
1057 /* 2.0.10: Nick Atty: clip to edges of drawing rectangle, return if no points need to be drawn */
1058 if (!clip_1d(&x1,&y1,&x2,&y2,gdImageSX(im)-1) || !clip_1d(&y1,&x1,&y2,&x2,gdImageSY(im)-1)) {
1059 return;
1060 }
1061
1062 dx = abs (x2 - x1);
1063 dy = abs (y2 - y1);
1064
1065 if (dx == 0) {
1066 gdImageVLine(im, x1, y1, y2, color);
1067 return;
1068 } else if (dy == 0) {
1069 gdImageHLine(im, y1, x1, x2, color);
1070 return;
1071 }
1072
1073 if (dy <= dx) {
1074 /* More-or-less horizontal. use wid for vertical stroke */
1075 /* Doug Claar: watch out for NaN in atan2 (2.0.5) */
1076 if ((dx == 0) && (dy == 0)) {
1077 wid = 1;
1078 } else {
1079 /* 2.0.12: Michael Schwartz: divide rather than multiply;
1080 TBB: but watch out for /0! */
1081 double ac = cos (atan2 (dy, dx));
1082 if (ac != 0) {
1083 wid = thick / ac;
1084 } else {
1085 wid = 1;
1086 }
1087 if (wid == 0) {
1088 wid = 1;
1089 }
1090 }
1091 d = 2 * dy - dx;
1092 incr1 = 2 * dy;
1093 incr2 = 2 * (dy - dx);
1094 if (x1 > x2) {
1095 x = x2;
1096 y = y2;
1097 ydirflag = (-1);
1098 xend = x1;
1099 } else {
1100 x = x1;
1101 y = y1;
1102 ydirflag = 1;
1103 xend = x2;
1104 }
1105
1106 /* Set up line thickness */
1107 wstart = y - wid / 2;
1108 for (w = wstart; w < wstart + wid; w++) {
1109 gdImageSetPixel(im, x, w, color);
1110 }
1111
1112 if (((y2 - y1) * ydirflag) > 0) {
1113 while (x < xend) {
1114 x++;
1115 if (d < 0) {
1116 d += incr1;
1117 } else {
1118 y++;
1119 d += incr2;
1120 }
1121 wstart = y - wid / 2;
1122 for (w = wstart; w < wstart + wid; w++) {
1123 gdImageSetPixel (im, x, w, color);
1124 }
1125 }
1126 } else {
1127 while (x < xend) {
1128 x++;
1129 if (d < 0) {
1130 d += incr1;
1131 } else {
1132 y--;
1133 d += incr2;
1134 }
1135 wstart = y - wid / 2;
1136 for (w = wstart; w < wstart + wid; w++) {
1137 gdImageSetPixel (im, x, w, color);
1138 }
1139 }
1140 }
1141 } else {
1142 /* More-or-less vertical. use wid for horizontal stroke */
1143 /* 2.0.12: Michael Schwartz: divide rather than multiply;
1144 TBB: but watch out for /0! */
1145 double as = sin (atan2 (dy, dx));
1146 if (as != 0) {
1147 wid = thick / as;
1148 } else {
1149 wid = 1;
1150 }
1151 if (wid == 0) {
1152 wid = 1;
1153 }
1154
1155 d = 2 * dx - dy;
1156 incr1 = 2 * dx;
1157 incr2 = 2 * (dx - dy);
1158 if (y1 > y2) {
1159 y = y2;
1160 x = x2;
1161 yend = y1;
1162 xdirflag = (-1);
1163 } else {
1164 y = y1;
1165 x = x1;
1166 yend = y2;
1167 xdirflag = 1;
1168 }
1169
1170 /* Set up line thickness */
1171 wstart = x - wid / 2;
1172 for (w = wstart; w < wstart + wid; w++) {
1173 gdImageSetPixel (im, w, y, color);
1174 }
1175
1176 if (((x2 - x1) * xdirflag) > 0) {
1177 while (y < yend) {
1178 y++;
1179 if (d < 0) {
1180 d += incr1;
1181 } else {
1182 x++;
1183 d += incr2;
1184 }
1185 wstart = x - wid / 2;
1186 for (w = wstart; w < wstart + wid; w++) {
1187 gdImageSetPixel (im, w, y, color);
1188 }
1189 }
1190 } else {
1191 while (y < yend) {
1192 y++;
1193 if (d < 0) {
1194 d += incr1;
1195 } else {
1196 x--;
1197 d += incr2;
1198 }
1199 wstart = x - wid / 2;
1200 for (w = wstart; w < wstart + wid; w++) {
1201 gdImageSetPixel (im, w, y, color);
1202 }
1203 }
1204 }
1205 }
1206 }
1207
1208
1209 /*
1210 * Added on 2003/12 by Pierre-Alain Joye (pajoye@pearfr.org)
1211 * */
1212 #define BLEND_COLOR(a, nc, c, cc) \
1213 nc = (cc) + (((((c) - (cc)) * (a)) + ((((c) - (cc)) * (a)) >> 8) + 0x80) >> 8);
1214
gdImageSetAAPixelColor(gdImagePtr im,int x,int y,int color,int t)1215 inline static void gdImageSetAAPixelColor(gdImagePtr im, int x, int y, int color, int t)
1216 {
1217 int dr,dg,db,p,r,g,b;
1218 dr = gdTrueColorGetRed(color);
1219 dg = gdTrueColorGetGreen(color);
1220 db = gdTrueColorGetBlue(color);
1221
1222 p = gdImageGetPixel(im,x,y);
1223 r = gdTrueColorGetRed(p);
1224 g = gdTrueColorGetGreen(p);
1225 b = gdTrueColorGetBlue(p);
1226
1227 BLEND_COLOR(t, dr, r, dr);
1228 BLEND_COLOR(t, dg, g, dg);
1229 BLEND_COLOR(t, db, b, db);
1230 im->tpixels[y][x]=gdTrueColorAlpha(dr, dg, db, gdAlphaOpaque);
1231 }
1232
1233 /*
1234 * Added on 2003/12 by Pierre-Alain Joye (pajoye@pearfr.org)
1235 **/
gdImageAALine(gdImagePtr im,int x1,int y1,int x2,int y2,int col)1236 void gdImageAALine (gdImagePtr im, int x1, int y1, int x2, int y2, int col)
1237 {
1238 /* keep them as 32bits */
1239 long x, y, inc, frac;
1240 long dx, dy,tmp;
1241
1242 if (!im->trueColor) {
1243 /* TBB: don't crash when the image is of the wrong type */
1244 gdImageLine(im, x1, y1, x2, y2, col);
1245 return;
1246 }
1247
1248 /* 2.0.10: Nick Atty: clip to edges of drawing rectangle, return if no points need to be drawn */
1249 if (!clip_1d(&x1,&y1,&x2,&y2,gdImageSX(im)-1) || !clip_1d(&y1,&x1,&y2,&x2,gdImageSY(im)-1)) {
1250 return;
1251 }
1252
1253 dx = x2 - x1;
1254 dy = y2 - y1;
1255
1256 if (dx == 0 && dy == 0) {
1257 return;
1258 }
1259 if (abs((int)dx) > abs((int)dy)) {
1260 if (dx < 0) {
1261 tmp = x1;
1262 x1 = x2;
1263 x2 = tmp;
1264 tmp = y1;
1265 y1 = y2;
1266 y2 = tmp;
1267 dx = x2 - x1;
1268 dy = y2 - y1;
1269 }
1270 y = y1;
1271 inc = (dy * 65536) / dx;
1272 frac = 0;
1273 for (x = x1; x <= x2; x++) {
1274 gdImageSetAAPixelColor(im, x, y, col, (frac >> 8) & 0xFF);
1275 if (y + 1 < im->sy) {
1276 gdImageSetAAPixelColor(im, x, y + 1, col, (~frac >> 8) & 0xFF);
1277 }
1278 frac += inc;
1279 if (frac >= 65536) {
1280 frac -= 65536;
1281 y++;
1282 } else if (frac < 0) {
1283 frac += 65536;
1284 y--;
1285 }
1286 }
1287 } else {
1288 if (dy < 0) {
1289 tmp = x1;
1290 x1 = x2;
1291 x2 = tmp;
1292 tmp = y1;
1293 y1 = y2;
1294 y2 = tmp;
1295 dx = x2 - x1;
1296 dy = y2 - y1;
1297 }
1298 x = x1;
1299 inc = (dx * 65536) / dy;
1300 frac = 0;
1301 for (y = y1; y <= y2; y++) {
1302 gdImageSetAAPixelColor(im, x, y, col, (frac >> 8) & 0xFF);
1303 if (x + 1 < im->sx) {
1304 gdImageSetAAPixelColor(im, x + 1, y, col, (~frac >> 8) & 0xFF);
1305 }
1306 frac += inc;
1307 if (frac >= 65536) {
1308 frac -= 65536;
1309 x++;
1310 } else if (frac < 0) {
1311 frac += 65536;
1312 x--;
1313 }
1314 }
1315 }
1316 }
1317
1318 static void dashedSet (gdImagePtr im, int x, int y, int color, int *onP, int *dashStepP, int wid, int vert);
1319
gdImageDashedLine(gdImagePtr im,int x1,int y1,int x2,int y2,int color)1320 void gdImageDashedLine (gdImagePtr im, int x1, int y1, int x2, int y2, int color)
1321 {
1322 int dx, dy, incr1, incr2, d, x, y, xend, yend, xdirflag, ydirflag;
1323 int dashStep = 0;
1324 int on = 1;
1325 int wid;
1326 int vert;
1327 int thick = im->thick;
1328
1329 dx = abs(x2 - x1);
1330 dy = abs(y2 - y1);
1331 if (dy <= dx) {
1332 /* More-or-less horizontal. use wid for vertical stroke */
1333 /* 2.0.12: Michael Schwartz: divide rather than multiply;
1334 TBB: but watch out for /0! */
1335 double as = sin(atan2(dy, dx));
1336 if (as != 0) {
1337 wid = thick / as;
1338 } else {
1339 wid = 1;
1340 }
1341 vert = 1;
1342
1343 d = 2 * dy - dx;
1344 incr1 = 2 * dy;
1345 incr2 = 2 * (dy - dx);
1346 if (x1 > x2) {
1347 x = x2;
1348 y = y2;
1349 ydirflag = (-1);
1350 xend = x1;
1351 } else {
1352 x = x1;
1353 y = y1;
1354 ydirflag = 1;
1355 xend = x2;
1356 }
1357 dashedSet(im, x, y, color, &on, &dashStep, wid, vert);
1358 if (((y2 - y1) * ydirflag) > 0) {
1359 while (x < xend) {
1360 x++;
1361 if (d < 0) {
1362 d += incr1;
1363 } else {
1364 y++;
1365 d += incr2;
1366 }
1367 dashedSet(im, x, y, color, &on, &dashStep, wid, vert);
1368 }
1369 } else {
1370 while (x < xend) {
1371 x++;
1372 if (d < 0) {
1373 d += incr1;
1374 } else {
1375 y--;
1376 d += incr2;
1377 }
1378 dashedSet(im, x, y, color, &on, &dashStep, wid, vert);
1379 }
1380 }
1381 } else {
1382 /* 2.0.12: Michael Schwartz: divide rather than multiply;
1383 TBB: but watch out for /0! */
1384 double as = sin (atan2 (dy, dx));
1385 if (as != 0) {
1386 wid = thick / as;
1387 } else {
1388 wid = 1;
1389 }
1390 vert = 0;
1391
1392 d = 2 * dx - dy;
1393 incr1 = 2 * dx;
1394 incr2 = 2 * (dx - dy);
1395 if (y1 > y2) {
1396 y = y2;
1397 x = x2;
1398 yend = y1;
1399 xdirflag = (-1);
1400 } else {
1401 y = y1;
1402 x = x1;
1403 yend = y2;
1404 xdirflag = 1;
1405 }
1406 dashedSet(im, x, y, color, &on, &dashStep, wid, vert);
1407 if (((x2 - x1) * xdirflag) > 0) {
1408 while (y < yend) {
1409 y++;
1410 if (d < 0) {
1411 d += incr1;
1412 } else {
1413 x++;
1414 d += incr2;
1415 }
1416 dashedSet(im, x, y, color, &on, &dashStep, wid, vert);
1417 }
1418 } else {
1419 while (y < yend) {
1420 y++;
1421 if (d < 0) {
1422 d += incr1;
1423 } else {
1424 x--;
1425 d += incr2;
1426 }
1427 dashedSet(im, x, y, color, &on, &dashStep, wid, vert);
1428 }
1429 }
1430 }
1431 }
1432
dashedSet(gdImagePtr im,int x,int y,int color,int * onP,int * dashStepP,int wid,int vert)1433 static void dashedSet (gdImagePtr im, int x, int y, int color, int *onP, int *dashStepP, int wid, int vert)
1434 {
1435 int dashStep = *dashStepP;
1436 int on = *onP;
1437 int w, wstart;
1438
1439 dashStep++;
1440 if (dashStep == gdDashSize) {
1441 dashStep = 0;
1442 on = !on;
1443 }
1444 if (on) {
1445 if (vert) {
1446 wstart = y - wid / 2;
1447 for (w = wstart; w < wstart + wid; w++) {
1448 gdImageSetPixel(im, x, w, color);
1449 }
1450 } else {
1451 wstart = x - wid / 2;
1452 for (w = wstart; w < wstart + wid; w++) {
1453 gdImageSetPixel(im, w, y, color);
1454 }
1455 }
1456 }
1457 *dashStepP = dashStep;
1458 *onP = on;
1459 }
1460
gdImageChar(gdImagePtr im,gdFontPtr f,int x,int y,int c,int color)1461 void gdImageChar (gdImagePtr im, gdFontPtr f, int x, int y, int c, int color)
1462 {
1463 int cx, cy;
1464 int px, py;
1465 int fline;
1466 const int xuppper = (x > INT_MAX - f->w) ? INT_MAX : x + f->w;
1467 const int yuppper = (y > INT_MAX - f->h) ? INT_MAX : y + f->h;
1468 cx = 0;
1469 cy = 0;
1470 #ifdef CHARSET_EBCDIC
1471 c = ASC (c);
1472 #endif /*CHARSET_EBCDIC */
1473 if ((c < f->offset) || (c >= (f->offset + f->nchars))) {
1474 return;
1475 }
1476 fline = (c - f->offset) * f->h * f->w;
1477 for (py = y; py < yuppper; py++) {
1478 for (px = x; px < xuppper; px++) {
1479 if (f->data[fline + cy * f->w + cx]) {
1480 gdImageSetPixel(im, px, py, color);
1481 }
1482 cx++;
1483 }
1484 cx = 0;
1485 cy++;
1486 }
1487 }
1488
gdImageCharUp(gdImagePtr im,gdFontPtr f,int x,int y,int c,int color)1489 void gdImageCharUp (gdImagePtr im, gdFontPtr f, int x, int y, int c, int color)
1490 {
1491 int cx, cy;
1492 int px, py;
1493 int fline;
1494 const int xuppper = (x > INT_MAX - f->h) ? INT_MAX : x + f->h;
1495 const int ylower = (y < INT_MIN + f->w) ? INT_MIN : y - f->w;
1496 cx = 0;
1497 cy = 0;
1498 #ifdef CHARSET_EBCDIC
1499 c = ASC (c);
1500 #endif /*CHARSET_EBCDIC */
1501 if ((c < f->offset) || (c >= (f->offset + f->nchars))) {
1502 return;
1503 }
1504 fline = (c - f->offset) * f->h * f->w;
1505 for (py = y; py > ylower; py--) {
1506 for (px = x; px < xuppper; px++) {
1507 if (f->data[fline + cy * f->w + cx]) {
1508 gdImageSetPixel(im, px, py, color);
1509 }
1510 cy++;
1511 }
1512 cy = 0;
1513 cx++;
1514 }
1515 }
1516
gdImageString(gdImagePtr im,gdFontPtr f,int x,int y,unsigned char * s,int color)1517 void gdImageString (gdImagePtr im, gdFontPtr f, int x, int y, unsigned char *s, int color)
1518 {
1519 int i;
1520 int l;
1521 l = strlen ((char *) s);
1522 for (i = 0; (i < l); i++) {
1523 gdImageChar(im, f, x, y, s[i], color);
1524 x += f->w;
1525 }
1526 }
1527
gdImageStringUp(gdImagePtr im,gdFontPtr f,int x,int y,unsigned char * s,int color)1528 void gdImageStringUp (gdImagePtr im, gdFontPtr f, int x, int y, unsigned char *s, int color)
1529 {
1530 int i;
1531 int l;
1532 l = strlen ((char *) s);
1533 for (i = 0; (i < l); i++) {
1534 gdImageCharUp(im, f, x, y, s[i], color);
1535 y -= f->w;
1536 }
1537 }
1538
1539 static int strlen16 (unsigned short *s);
1540
gdImageString16(gdImagePtr im,gdFontPtr f,int x,int y,unsigned short * s,int color)1541 void gdImageString16 (gdImagePtr im, gdFontPtr f, int x, int y, unsigned short *s, int color)
1542 {
1543 int i;
1544 int l;
1545 l = strlen16(s);
1546 for (i = 0; (i < l); i++) {
1547 gdImageChar(im, f, x, y, s[i], color);
1548 x += f->w;
1549 }
1550 }
1551
gdImageStringUp16(gdImagePtr im,gdFontPtr f,int x,int y,unsigned short * s,int color)1552 void gdImageStringUp16 (gdImagePtr im, gdFontPtr f, int x, int y, unsigned short *s, int color)
1553 {
1554 int i;
1555 int l;
1556 l = strlen16(s);
1557 for (i = 0; i < l; i++) {
1558 gdImageCharUp(im, f, x, y, s[i], color);
1559 y -= f->w;
1560 }
1561 }
1562
strlen16(unsigned short * s)1563 static int strlen16 (unsigned short *s)
1564 {
1565 int len = 0;
1566 while (*s) {
1567 s++;
1568 len++;
1569 }
1570 return len;
1571 }
1572
1573 #ifndef HAVE_LSQRT
1574 /* If you don't have a nice square root function for longs, you can use
1575 ** this hack
1576 */
lsqrt(long n)1577 long lsqrt (long n)
1578 {
1579 long result = (long) sqrt ((double) n);
1580 return result;
1581 }
1582 #endif
1583
1584 /* s and e are integers modulo 360 (degrees), with 0 degrees
1585 being the rightmost extreme and degrees changing clockwise.
1586 cx and cy are the center in pixels; w and h are the horizontal
1587 and vertical diameter in pixels. */
1588
gdImageArc(gdImagePtr im,int cx,int cy,int w,int h,int s,int e,int color)1589 void gdImageArc (gdImagePtr im, int cx, int cy, int w, int h, int s, int e, int color)
1590 {
1591 gdImageFilledArc(im, cx, cy, w, h, s, e, color, gdNoFill);
1592 }
1593
gdImageFilledArc(gdImagePtr im,int cx,int cy,int w,int h,int s,int e,int color,int style)1594 void gdImageFilledArc (gdImagePtr im, int cx, int cy, int w, int h, int s, int e, int color, int style)
1595 {
1596 gdPoint pts[363];
1597 int i, pti;
1598 int lx = 0, ly = 0;
1599 int fx = 0, fy = 0;
1600 int startx = -1, starty = -1, endx = -1, endy = -1;
1601
1602 if ((s % 360) == (e % 360)) {
1603 s = 0; e = 360;
1604 } else {
1605 if (s > 360) {
1606 s = s % 360;
1607 }
1608
1609 if (e > 360) {
1610 e = e % 360;
1611 }
1612
1613 while (s < 0) {
1614 s += 360;
1615 }
1616
1617 while (e < s) {
1618 e += 360;
1619 }
1620 if (s == e) {
1621 s = 0; e = 360;
1622 }
1623 }
1624
1625 for (i = s, pti = 1; i <= e; i++, pti++) {
1626 int x, y;
1627 x = endx = ((long) gdCosT[i % 360] * (long) w / (2 * 1024)) + cx;
1628 y = endy = ((long) gdSinT[i % 360] * (long) h / (2 * 1024)) + cy;
1629 if (i != s) {
1630 if (!(style & gdChord)) {
1631 if (style & gdNoFill) {
1632 gdImageLine(im, lx, ly, x, y, color);
1633 } else {
1634 if (y == ly) {
1635 pti--; /* don't add this point */
1636 if (((i > 270 || i < 90) && x > lx) || ((i > 90 && i < 270) && x < lx)) {
1637 /* replace the old x coord, if increasing on the
1638 right side or decreasing on the left side */
1639 pts[pti].x = x;
1640 }
1641 } else {
1642 pts[pti].x = x;
1643 pts[pti].y = y;
1644 }
1645 }
1646 }
1647 } else {
1648 fx = x;
1649 fy = y;
1650 if (!(style & (gdChord | gdNoFill))) {
1651 pts[0].x = cx;
1652 pts[0].y = cy;
1653 pts[pti].x = startx = x;
1654 pts[pti].y = starty = y;
1655 }
1656 }
1657 lx = x;
1658 ly = y;
1659 }
1660 if (style & gdChord) {
1661 if (style & gdNoFill) {
1662 if (style & gdEdged) {
1663 gdImageLine(im, cx, cy, lx, ly, color);
1664 gdImageLine(im, cx, cy, fx, fy, color);
1665 }
1666 gdImageLine(im, fx, fy, lx, ly, color);
1667 } else {
1668 pts[0].x = fx;
1669 pts[0].y = fy;
1670 pts[1].x = lx;
1671 pts[1].y = ly;
1672 pts[2].x = cx;
1673 pts[2].y = cy;
1674 gdImageFilledPolygon(im, pts, 3, color);
1675 }
1676 } else {
1677 if (style & gdNoFill) {
1678 if (style & gdEdged) {
1679 gdImageLine(im, cx, cy, lx, ly, color);
1680 gdImageLine(im, cx, cy, fx, fy, color);
1681 }
1682 } else {
1683 if (e - s < 360) {
1684 if (pts[1].x != startx && pts[1].y == starty) {
1685 /* start point has been removed due to y-coord fix => insert it */
1686 for (i = pti; i > 1; i--) {
1687 pts[i].x = pts[i-1].x;
1688 pts[i].y = pts[i-1].y;
1689 }
1690 pts[1].x = startx;
1691 pts[1].y = starty;
1692 pti++;
1693 }
1694 if (pts[pti-1].x != endx && pts[pti-1].y == endy) {
1695 /* end point has been removed due to y-coord fix => insert it */
1696 pts[pti].x = endx;
1697 pts[pti].y = endy;
1698 pti++;
1699 }
1700 }
1701 pts[pti].x = cx;
1702 pts[pti].y = cy;
1703 gdImageFilledPolygon(im, pts, pti+1, color);
1704 }
1705 }
1706 }
1707
1708 /**
1709 * Integer Ellipse functions (gdImageEllipse and gdImageFilledEllipse)
1710 * Function added by Pierre-Alain Joye 02/08/2003 (paj@pearfr.org)
1711 * See the ellipse function simplification for the equation
1712 * as well as the midpoint algorithm.
1713 */
1714
gdImageEllipse(gdImagePtr im,int mx,int my,int w,int h,int c)1715 void gdImageEllipse(gdImagePtr im, int mx, int my, int w, int h, int c)
1716 {
1717 int x=0,mx1=0,mx2=0,my1=0,my2=0;
1718 int64_t aq,bq,dx,dy,r,rx,ry,a,b;
1719
1720 a=w>>1;
1721 b=h>>1;
1722 gdImageSetPixel(im,mx+a, my, c);
1723 gdImageSetPixel(im,mx-a, my, c);
1724 mx1 = mx-a;my1 = my;
1725 mx2 = mx+a;my2 = my;
1726
1727 aq = a * a;
1728 bq = b * b;
1729 dx = aq << 1;
1730 dy = bq << 1;
1731 r = a * bq;
1732 rx = r << 1;
1733 ry = 0;
1734 x = a;
1735 while (x > 0){
1736 if (r > 0) {
1737 my1++;my2--;
1738 ry +=dx;
1739 r -=ry;
1740 }
1741 if (r <= 0){
1742 x--;
1743 mx1++;mx2--;
1744 rx -=dy;
1745 r +=rx;
1746 }
1747 gdImageSetPixel(im,mx1, my1, c);
1748 gdImageSetPixel(im,mx1, my2, c);
1749 gdImageSetPixel(im,mx2, my1, c);
1750 gdImageSetPixel(im,mx2, my2, c);
1751 }
1752 }
1753
gdImageFilledEllipse(gdImagePtr im,int mx,int my,int w,int h,int c)1754 void gdImageFilledEllipse (gdImagePtr im, int mx, int my, int w, int h, int c)
1755 {
1756 int x=0,mx1=0,mx2=0,my1=0,my2=0;
1757 int64_t aq,bq,dx,dy,r,rx,ry,a,b;
1758 int i;
1759 int old_y2;
1760
1761 a=w>>1;
1762 b=h>>1;
1763
1764 for (x = mx-a; x <= mx+a; x++) {
1765 gdImageSetPixel(im, x, my, c);
1766 }
1767
1768 mx1 = mx-a;my1 = my;
1769 mx2 = mx+a;my2 = my;
1770
1771 aq = a * a;
1772 bq = b * b;
1773 dx = aq << 1;
1774 dy = bq << 1;
1775 r = a * bq;
1776 rx = r << 1;
1777 ry = 0;
1778 x = a;
1779 old_y2=-2;
1780 while (x > 0){
1781 if (r > 0) {
1782 my1++;my2--;
1783 ry +=dx;
1784 r -=ry;
1785 }
1786 if (r <= 0){
1787 x--;
1788 mx1++;mx2--;
1789 rx -=dy;
1790 r +=rx;
1791 }
1792 if(old_y2!=my2){
1793 for(i=mx1;i<=mx2;i++){
1794 gdImageSetPixel(im,i,my1,c);
1795 gdImageSetPixel(im,i,my2,c);
1796 }
1797 }
1798 old_y2 = my2;
1799 }
1800 }
1801
gdImageFillToBorder(gdImagePtr im,int x,int y,int border,int color)1802 void gdImageFillToBorder (gdImagePtr im, int x, int y, int border, int color)
1803 {
1804 int lastBorder;
1805 /* Seek left */
1806 int leftLimit = -1, rightLimit;
1807 int i, restoreAlphaBlending = 0;
1808
1809 if (border < 0 || color < 0) {
1810 /* Refuse to fill to a non-solid border */
1811 return;
1812 }
1813
1814 if (!im->trueColor) {
1815 if ((color > (im->colorsTotal - 1)) || (border > (im->colorsTotal - 1)) || (color < 0)) {
1816 return;
1817 }
1818 }
1819
1820 restoreAlphaBlending = im->alphaBlendingFlag;
1821 im->alphaBlendingFlag = 0;
1822
1823 if (x >= im->sx) {
1824 x = im->sx - 1;
1825 } else if (x < 0) {
1826 x = 0;
1827 }
1828 if (y >= im->sy) {
1829 y = im->sy - 1;
1830 } else if (y < 0) {
1831 y = 0;
1832 }
1833
1834 for (i = x; i >= 0; i--) {
1835 if (gdImageGetPixel(im, i, y) == border) {
1836 break;
1837 }
1838 gdImageSetPixel(im, i, y, color);
1839 leftLimit = i;
1840 }
1841 if (leftLimit == -1) {
1842 im->alphaBlendingFlag = restoreAlphaBlending;
1843 return;
1844 }
1845 /* Seek right */
1846 rightLimit = x;
1847 for (i = (x + 1); i < im->sx; i++) {
1848 if (gdImageGetPixel(im, i, y) == border) {
1849 break;
1850 }
1851 gdImageSetPixel(im, i, y, color);
1852 rightLimit = i;
1853 }
1854 /* Look at lines above and below and start paints */
1855 /* Above */
1856 if (y > 0) {
1857 lastBorder = 1;
1858 for (i = leftLimit; i <= rightLimit; i++) {
1859 int c = gdImageGetPixel(im, i, y - 1);
1860 if (lastBorder) {
1861 if ((c != border) && (c != color)) {
1862 gdImageFillToBorder(im, i, y - 1, border, color);
1863 lastBorder = 0;
1864 }
1865 } else if ((c == border) || (c == color)) {
1866 lastBorder = 1;
1867 }
1868 }
1869 }
1870
1871 /* Below */
1872 if (y < ((im->sy) - 1)) {
1873 lastBorder = 1;
1874 for (i = leftLimit; i <= rightLimit; i++) {
1875 int c = gdImageGetPixel(im, i, y + 1);
1876
1877 if (lastBorder) {
1878 if ((c != border) && (c != color)) {
1879 gdImageFillToBorder(im, i, y + 1, border, color);
1880 lastBorder = 0;
1881 }
1882 } else if ((c == border) || (c == color)) {
1883 lastBorder = 1;
1884 }
1885 }
1886 }
1887 im->alphaBlendingFlag = restoreAlphaBlending;
1888 }
1889
1890 /*
1891 * set the pixel at (x,y) and its 4-connected neighbors
1892 * with the same pixel value to the new pixel value nc (new color).
1893 * A 4-connected neighbor: pixel above, below, left, or right of a pixel.
1894 * ideas from comp.graphics discussions.
1895 * For tiled fill, the use of a flag buffer is mandatory. As the tile image can
1896 * contain the same color as the color to fill. To do not bloat normal filling
1897 * code I added a 2nd private function.
1898 */
1899
1900 /* horizontal segment of scan line y */
1901 struct seg {int y, xl, xr, dy;};
1902
1903 /* max depth of stack */
1904 #define FILL_MAX ((int)(im->sy*im->sx)/4)
1905 #define FILL_PUSH(Y, XL, XR, DY) \
1906 if (sp<stack+FILL_MAX && Y+(DY)>=0 && Y+(DY)<wy2) \
1907 {sp->y = Y; sp->xl = XL; sp->xr = XR; sp->dy = DY; sp++;}
1908
1909 #define FILL_POP(Y, XL, XR, DY) \
1910 {sp--; Y = sp->y+(DY = sp->dy); XL = sp->xl; XR = sp->xr;}
1911
1912 static void _gdImageFillTiled(gdImagePtr im, int x, int y, int nc);
1913
gdImageFill(gdImagePtr im,int x,int y,int nc)1914 void gdImageFill(gdImagePtr im, int x, int y, int nc)
1915 {
1916 int l, x1, x2, dy;
1917 int oc; /* old pixel value */
1918 int wx2,wy2;
1919
1920 int alphablending_bak;
1921
1922 /* stack of filled segments */
1923 /* struct seg stack[FILL_MAX],*sp = stack; */
1924 struct seg *stack = NULL;
1925 struct seg *sp;
1926
1927 if (!im->trueColor && nc > (im->colorsTotal -1)) {
1928 return;
1929 }
1930
1931 alphablending_bak = im->alphaBlendingFlag;
1932 im->alphaBlendingFlag = 0;
1933
1934 if (nc==gdTiled){
1935 _gdImageFillTiled(im,x,y,nc);
1936 im->alphaBlendingFlag = alphablending_bak;
1937 return;
1938 }
1939
1940 wx2=im->sx;wy2=im->sy;
1941 oc = gdImageGetPixel(im, x, y);
1942 if (oc==nc || x<0 || x>wx2 || y<0 || y>wy2) {
1943 im->alphaBlendingFlag = alphablending_bak;
1944 return;
1945 }
1946
1947 /* Do not use the 4 neighbors implementation with
1948 * small images
1949 */
1950 if (im->sx < 4) {
1951 int ix = x, iy = y, c;
1952 do {
1953 do {
1954 c = gdImageGetPixel(im, ix, iy);
1955 if (c != oc) {
1956 goto done;
1957 }
1958 gdImageSetPixel(im, ix, iy, nc);
1959 } while(ix++ < (im->sx -1));
1960 ix = x;
1961 } while(iy++ < (im->sy -1));
1962 goto done;
1963 }
1964
1965 stack = (struct seg *)safe_emalloc(sizeof(struct seg), ((int)(im->sy*im->sx)/4), 1);
1966 sp = stack;
1967
1968 /* required! */
1969 FILL_PUSH(y,x,x,1);
1970 /* seed segment (popped 1st) */
1971 FILL_PUSH(y+1, x, x, -1);
1972 while (sp>stack) {
1973 FILL_POP(y, x1, x2, dy);
1974
1975 for (x=x1; x>=0 && gdImageGetPixel(im,x, y)==oc; x--) {
1976 gdImageSetPixel(im,x, y, nc);
1977 }
1978 if (x>=x1) {
1979 goto skip;
1980 }
1981 l = x+1;
1982
1983 /* leak on left? */
1984 if (l<x1) {
1985 FILL_PUSH(y, l, x1-1, -dy);
1986 }
1987 x = x1+1;
1988 do {
1989 for (; x<=wx2 && gdImageGetPixel(im,x, y)==oc; x++) {
1990 gdImageSetPixel(im, x, y, nc);
1991 }
1992 FILL_PUSH(y, l, x-1, dy);
1993 /* leak on right? */
1994 if (x>x2+1) {
1995 FILL_PUSH(y, x2+1, x-1, -dy);
1996 }
1997 skip:
1998 for (x++; x<=x2 && (gdImageGetPixel(im, x, y)!=oc); x++);
1999
2000 l = x;
2001 } while (x<=x2);
2002 }
2003
2004 efree(stack);
2005
2006 done:
2007 im->alphaBlendingFlag = alphablending_bak;
2008 }
2009
_gdImageFillTiled(gdImagePtr im,int x,int y,int nc)2010 static void _gdImageFillTiled(gdImagePtr im, int x, int y, int nc)
2011 {
2012 int i, l, x1, x2, dy;
2013 int oc; /* old pixel value */
2014 int wx2,wy2;
2015 /* stack of filled segments */
2016 struct seg *stack;
2017 struct seg *sp;
2018 char **pts;
2019
2020 if (!im->tile) {
2021 return;
2022 }
2023
2024 wx2=im->sx;wy2=im->sy;
2025
2026 nc = gdImageTileGet(im,x,y);
2027
2028 pts = (char **) ecalloc(im->sy + 1, sizeof(char *));
2029 for (i = 0; i < im->sy + 1; i++) {
2030 pts[i] = (char *) ecalloc(im->sx + 1, sizeof(char));
2031 }
2032
2033 stack = (struct seg *)safe_emalloc(sizeof(struct seg), ((int)(im->sy*im->sx)/4), 1);
2034 sp = stack;
2035
2036 oc = gdImageGetPixel(im, x, y);
2037
2038 /* required! */
2039 FILL_PUSH(y,x,x,1);
2040 /* seed segment (popped 1st) */
2041 FILL_PUSH(y+1, x, x, -1);
2042 while (sp>stack) {
2043 FILL_POP(y, x1, x2, dy);
2044 for (x=x1; x>=0 && (!pts[y][x] && gdImageGetPixel(im,x,y)==oc); x--) {
2045 nc = gdImageTileGet(im,x,y);
2046 pts[y][x] = 1;
2047 gdImageSetPixel(im,x, y, nc);
2048 }
2049 if (x>=x1) {
2050 goto skip;
2051 }
2052 l = x+1;
2053
2054 /* leak on left? */
2055 if (l<x1) {
2056 FILL_PUSH(y, l, x1-1, -dy);
2057 }
2058 x = x1+1;
2059 do {
2060 for(; x<wx2 && (!pts[y][x] && gdImageGetPixel(im,x, y)==oc); x++) {
2061 nc = gdImageTileGet(im,x,y);
2062 pts[y][x] = 1;
2063 gdImageSetPixel(im, x, y, nc);
2064 }
2065 FILL_PUSH(y, l, x-1, dy);
2066 /* leak on right? */
2067 if (x>x2+1) {
2068 FILL_PUSH(y, x2+1, x-1, -dy);
2069 }
2070 skip:
2071 for(x++; x<=x2 && (pts[y][x] || gdImageGetPixel(im,x, y)!=oc); x++);
2072 l = x;
2073 } while (x<=x2);
2074 }
2075
2076 for(i = 0; i < im->sy + 1; i++) {
2077 efree(pts[i]);
2078 }
2079
2080 efree(pts);
2081 efree(stack);
2082 }
2083
2084
2085
gdImageRectangle(gdImagePtr im,int x1,int y1,int x2,int y2,int color)2086 void gdImageRectangle (gdImagePtr im, int x1, int y1, int x2, int y2, int color)
2087 {
2088 int thick = im->thick;
2089 int t;
2090
2091 if (x1 == x2 && y1 == y2 && thick == 1) {
2092 gdImageSetPixel(im, x1, y1, color);
2093 return;
2094 }
2095
2096 if (y2 < y1) {
2097 t=y1;
2098 y1 = y2;
2099 y2 = t;
2100 }
2101
2102 if (x2 < x1) {
2103 t = x1;
2104 x1 = x2;
2105 x2 = t;
2106 }
2107
2108 if (thick > 1) {
2109 int cx, cy, x1ul, y1ul, x2lr, y2lr;
2110 int half = thick >> 1;
2111
2112 x1ul = x1 - half;
2113 y1ul = y1 - half;
2114
2115 x2lr = x2 + half;
2116 y2lr = y2 + half;
2117
2118 cy = y1ul + thick;
2119 while (cy-- > y1ul) {
2120 cx = x1ul - 1;
2121 while (cx++ < x2lr) {
2122 gdImageSetPixel(im, cx, cy, color);
2123 }
2124 }
2125
2126 cy = y2lr - thick;
2127 while (cy++ < y2lr) {
2128 cx = x1ul - 1;
2129 while (cx++ < x2lr) {
2130 gdImageSetPixel(im, cx, cy, color);
2131 }
2132 }
2133
2134 cy = y1ul + thick - 1;
2135 while (cy++ < y2lr -thick) {
2136 cx = x1ul - 1;
2137 while (cx++ < x1ul + thick) {
2138 gdImageSetPixel(im, cx, cy, color);
2139 }
2140 }
2141
2142 cy = y1ul + thick - 1;
2143 while (cy++ < y2lr -thick) {
2144 cx = x2lr - thick - 1;
2145 while (cx++ < x2lr) {
2146 gdImageSetPixel(im, cx, cy, color);
2147 }
2148 }
2149
2150 return;
2151 } else {
2152 if (x1 == x2 || y1 == y2) {
2153 gdImageLine(im, x1, y1, x2, y2, color);
2154 } else {
2155 gdImageLine(im, x1, y1, x2, y1, color);
2156 gdImageLine(im, x1, y2, x2, y2, color);
2157 gdImageLine(im, x1, y1 + 1, x1, y2 - 1, color);
2158 gdImageLine(im, x2, y1 + 1, x2, y2 - 1, color);
2159 }
2160 }
2161 }
2162
_gdImageFilledHRectangle(gdImagePtr im,int x1,int y1,int x2,int y2,int color)2163 static void _gdImageFilledHRectangle (gdImagePtr im, int x1, int y1, int x2, int y2, int color)
2164 {
2165 int x, y;
2166
2167 if (x1 == x2 && y1 == y2) {
2168 gdImageSetPixel(im, x1, y1, color);
2169 return;
2170 }
2171
2172 if (x1 > x2) {
2173 x = x1;
2174 x1 = x2;
2175 x2 = x;
2176 }
2177
2178 if (y1 > y2) {
2179 y = y1;
2180 y1 = y2;
2181 y2 = y;
2182 }
2183
2184 if (x1 < 0) {
2185 x1 = 0;
2186 }
2187
2188 if (x2 >= gdImageSX(im)) {
2189 x2 = gdImageSX(im) - 1;
2190 }
2191
2192 if (y1 < 0) {
2193 y1 = 0;
2194 }
2195
2196 if (y2 >= gdImageSY(im)) {
2197 y2 = gdImageSY(im) - 1;
2198 }
2199
2200 for (x = x1; (x <= x2); x++) {
2201 for (y = y1; (y <= y2); y++) {
2202 gdImageSetPixel (im, x, y, color);
2203 }
2204 }
2205 }
2206
_gdImageFilledVRectangle(gdImagePtr im,int x1,int y1,int x2,int y2,int color)2207 static void _gdImageFilledVRectangle (gdImagePtr im, int x1, int y1, int x2, int y2, int color)
2208 {
2209 int x, y;
2210
2211 if (x1 == x2 && y1 == y2) {
2212 gdImageSetPixel(im, x1, y1, color);
2213 return;
2214 }
2215
2216 if (x1 > x2) {
2217 x = x1;
2218 x1 = x2;
2219 x2 = x;
2220 }
2221
2222 if (y1 > y2) {
2223 y = y1;
2224 y1 = y2;
2225 y2 = y;
2226 }
2227
2228 if (x1 < 0) {
2229 x1 = 0;
2230 }
2231
2232 if (x2 >= gdImageSX(im)) {
2233 x2 = gdImageSX(im) - 1;
2234 }
2235
2236 if (y1 < 0) {
2237 y1 = 0;
2238 }
2239
2240 if (y2 >= gdImageSY(im)) {
2241 y2 = gdImageSY(im) - 1;
2242 }
2243
2244 for (y = y1; (y <= y2); y++) {
2245 for (x = x1; (x <= x2); x++) {
2246 gdImageSetPixel (im, x, y, color);
2247 }
2248 }
2249 }
2250
gdImageFilledRectangle(gdImagePtr im,int x1,int y1,int x2,int y2,int color)2251 void gdImageFilledRectangle (gdImagePtr im, int x1, int y1, int x2, int y2, int color)
2252 {
2253 _gdImageFilledVRectangle(im, x1, y1, x2, y2, color);
2254 }
2255
gdImageCopy(gdImagePtr dst,gdImagePtr src,int dstX,int dstY,int srcX,int srcY,int w,int h)2256 void gdImageCopy (gdImagePtr dst, gdImagePtr src, int dstX, int dstY, int srcX, int srcY, int w, int h)
2257 {
2258 int c;
2259 int x, y;
2260 int tox, toy;
2261 int i;
2262 int colorMap[gdMaxColors];
2263
2264 if (dst->trueColor) {
2265 /* 2.0: much easier when the destination is truecolor. */
2266 /* 2.0.10: needs a transparent-index check that is still valid if
2267 * the source is not truecolor. Thanks to Frank Warmerdam.
2268 */
2269
2270 if (src->trueColor) {
2271 for (y = 0; (y < h); y++) {
2272 for (x = 0; (x < w); x++) {
2273 int c = gdImageGetTrueColorPixel (src, srcX + x, srcY + y);
2274 if (c != src->transparent) {
2275 gdImageSetPixel (dst, dstX + x, dstY + y, c);
2276 }
2277 }
2278 }
2279 } else {
2280 /* source is palette based */
2281 for (y = 0; (y < h); y++) {
2282 for (x = 0; (x < w); x++) {
2283 int c = gdImageGetPixel (src, srcX + x, srcY + y);
2284 if (c != src->transparent) {
2285 gdImageSetPixel(dst, dstX + x, dstY + y, gdTrueColorAlpha(src->red[c], src->green[c], src->blue[c], src->alpha[c]));
2286 }
2287 }
2288 }
2289 }
2290 return;
2291 }
2292
2293 /* Palette based to palette based */
2294 for (i = 0; i < gdMaxColors; i++) {
2295 colorMap[i] = (-1);
2296 }
2297 toy = dstY;
2298 for (y = srcY; y < (srcY + h); y++) {
2299 tox = dstX;
2300 for (x = srcX; x < (srcX + w); x++) {
2301 int nc;
2302 int mapTo;
2303 c = gdImageGetPixel (src, x, y);
2304 /* Added 7/24/95: support transparent copies */
2305 if (gdImageGetTransparent (src) == c) {
2306 tox++;
2307 continue;
2308 }
2309 /* Have we established a mapping for this color? */
2310 if (src->trueColor) {
2311 /* 2.05: remap to the palette available in the destination image. This is slow and
2312 * works badly, but it beats crashing! Thanks to Padhrig McCarthy.
2313 */
2314 mapTo = gdImageColorResolveAlpha (dst, gdTrueColorGetRed (c), gdTrueColorGetGreen (c), gdTrueColorGetBlue (c), gdTrueColorGetAlpha (c));
2315 } else if (colorMap[c] == (-1)) {
2316 /* If it's the same image, mapping is trivial */
2317 if (dst == src) {
2318 nc = c;
2319 } else {
2320 /* Get best match possible. This function never returns error. */
2321 nc = gdImageColorResolveAlpha (dst, src->red[c], src->green[c], src->blue[c], src->alpha[c]);
2322 }
2323 colorMap[c] = nc;
2324 mapTo = colorMap[c];
2325 } else {
2326 mapTo = colorMap[c];
2327 }
2328 gdImageSetPixel (dst, tox, toy, mapTo);
2329 tox++;
2330 }
2331 toy++;
2332 }
2333 }
2334
2335 /* This function is a substitute for real alpha channel operations,
2336 so it doesn't pay attention to the alpha channel. */
gdImageCopyMerge(gdImagePtr dst,gdImagePtr src,int dstX,int dstY,int srcX,int srcY,int w,int h,int pct)2337 void gdImageCopyMerge (gdImagePtr dst, gdImagePtr src, int dstX, int dstY, int srcX, int srcY, int w, int h, int pct)
2338 {
2339 int c, dc;
2340 int x, y;
2341 int tox, toy;
2342 int ncR, ncG, ncB;
2343 toy = dstY;
2344
2345 for (y = srcY; y < (srcY + h); y++) {
2346 tox = dstX;
2347 for (x = srcX; x < (srcX + w); x++) {
2348 int nc;
2349 c = gdImageGetPixel(src, x, y);
2350 /* Added 7/24/95: support transparent copies */
2351 if (gdImageGetTransparent(src) == c) {
2352 tox++;
2353 continue;
2354 }
2355 /* If it's the same image, mapping is trivial */
2356 if (dst == src) {
2357 nc = c;
2358 } else {
2359 dc = gdImageGetPixel(dst, tox, toy);
2360
2361 ncR = (int)(gdImageRed (src, c) * (pct / 100.0) + gdImageRed (dst, dc) * ((100 - pct) / 100.0));
2362 ncG = (int)(gdImageGreen (src, c) * (pct / 100.0) + gdImageGreen (dst, dc) * ((100 - pct) / 100.0));
2363 ncB = (int)(gdImageBlue (src, c) * (pct / 100.0) + gdImageBlue (dst, dc) * ((100 - pct) / 100.0));
2364
2365 /* Find a reasonable color */
2366 nc = gdImageColorResolve (dst, ncR, ncG, ncB);
2367 }
2368 gdImageSetPixel (dst, tox, toy, nc);
2369 tox++;
2370 }
2371 toy++;
2372 }
2373 }
2374
2375 /* This function is a substitute for real alpha channel operations,
2376 so it doesn't pay attention to the alpha channel. */
gdImageCopyMergeGray(gdImagePtr dst,gdImagePtr src,int dstX,int dstY,int srcX,int srcY,int w,int h,int pct)2377 void gdImageCopyMergeGray (gdImagePtr dst, gdImagePtr src, int dstX, int dstY, int srcX, int srcY, int w, int h, int pct)
2378 {
2379 int c, dc;
2380 int x, y;
2381 int tox, toy;
2382 int ncR, ncG, ncB;
2383 float g;
2384 toy = dstY;
2385
2386 for (y = srcY; (y < (srcY + h)); y++) {
2387 tox = dstX;
2388 for (x = srcX; (x < (srcX + w)); x++) {
2389 int nc;
2390 c = gdImageGetPixel (src, x, y);
2391 /* Added 7/24/95: support transparent copies */
2392 if (gdImageGetTransparent(src) == c) {
2393 tox++;
2394 continue;
2395 }
2396
2397 /*
2398 * If it's the same image, mapping is NOT trivial since we
2399 * merge with greyscale target, but if pct is 100, the grey
2400 * value is not used, so it becomes trivial. pjw 2.0.12.
2401 */
2402 if (dst == src && pct == 100) {
2403 nc = c;
2404 } else {
2405 dc = gdImageGetPixel(dst, tox, toy);
2406 g = (0.29900f * gdImageRed(dst, dc)) + (0.58700f * gdImageGreen(dst, dc)) + (0.11400f * gdImageBlue(dst, dc));
2407
2408 ncR = (int)(gdImageRed (src, c) * (pct / 100.0f) + g * ((100 - pct) / 100.0));
2409 ncG = (int)(gdImageGreen (src, c) * (pct / 100.0f) + g * ((100 - pct) / 100.0));
2410 ncB = (int)(gdImageBlue (src, c) * (pct / 100.0f) + g * ((100 - pct) / 100.0));
2411
2412
2413 /* First look for an exact match */
2414 nc = gdImageColorExact(dst, ncR, ncG, ncB);
2415 if (nc == (-1)) {
2416 /* No, so try to allocate it */
2417 nc = gdImageColorAllocate(dst, ncR, ncG, ncB);
2418 /* If we're out of colors, go for the closest color */
2419 if (nc == (-1)) {
2420 nc = gdImageColorClosest(dst, ncR, ncG, ncB);
2421 }
2422 }
2423 }
2424 gdImageSetPixel(dst, tox, toy, nc);
2425 tox++;
2426 }
2427 toy++;
2428 }
2429 }
2430
gdImageCopyResized(gdImagePtr dst,gdImagePtr src,int dstX,int dstY,int srcX,int srcY,int dstW,int dstH,int srcW,int srcH)2431 void gdImageCopyResized (gdImagePtr dst, gdImagePtr src, int dstX, int dstY, int srcX, int srcY, int dstW, int dstH, int srcW, int srcH)
2432 {
2433 int c;
2434 int x, y;
2435 int tox, toy;
2436 int ydest;
2437 int i;
2438 int colorMap[gdMaxColors];
2439 /* Stretch vectors */
2440 int *stx, *sty;
2441
2442 if (overflow2(sizeof(int), srcW)) {
2443 return;
2444 }
2445 if (overflow2(sizeof(int), srcH)) {
2446 return;
2447 }
2448
2449 stx = (int *) gdMalloc (sizeof (int) * srcW);
2450 sty = (int *) gdMalloc (sizeof (int) * srcH);
2451
2452 /* Fixed by Mao Morimoto 2.0.16 */
2453 for (i = 0; (i < srcW); i++) {
2454 stx[i] = dstW * (i+1) / srcW - dstW * i / srcW ;
2455 }
2456 for (i = 0; (i < srcH); i++) {
2457 sty[i] = dstH * (i+1) / srcH - dstH * i / srcH ;
2458 }
2459 for (i = 0; (i < gdMaxColors); i++) {
2460 colorMap[i] = (-1);
2461 }
2462 toy = dstY;
2463 for (y = srcY; (y < (srcY + srcH)); y++) {
2464 for (ydest = 0; (ydest < sty[y - srcY]); ydest++) {
2465 tox = dstX;
2466 for (x = srcX; (x < (srcX + srcW)); x++) {
2467 int nc = 0;
2468 int mapTo;
2469 if (!stx[x - srcX]) {
2470 continue;
2471 }
2472 if (dst->trueColor) {
2473 /* 2.0.9: Thorben Kundinger: Maybe the source image is not a truecolor image */
2474 if (!src->trueColor) {
2475 int tmp = gdImageGetPixel (src, x, y);
2476 mapTo = gdImageGetTrueColorPixel (src, x, y);
2477 if (gdImageGetTransparent (src) == tmp) {
2478 /* 2.0.21, TK: not tox++ */
2479 tox += stx[x - srcX];
2480 continue;
2481 }
2482 } else {
2483 /* TK: old code follows */
2484 mapTo = gdImageGetTrueColorPixel (src, x, y);
2485 /* Added 7/24/95: support transparent copies */
2486 if (gdImageGetTransparent (src) == mapTo) {
2487 /* 2.0.21, TK: not tox++ */
2488 tox += stx[x - srcX];
2489 continue;
2490 }
2491 }
2492 } else {
2493 c = gdImageGetPixel (src, x, y);
2494 /* Added 7/24/95: support transparent copies */
2495 if (gdImageGetTransparent (src) == c) {
2496 tox += stx[x - srcX];
2497 continue;
2498 }
2499 if (src->trueColor) {
2500 /* Remap to the palette available in the destination image. This is slow and works badly. */
2501 mapTo = gdImageColorResolveAlpha(dst, gdTrueColorGetRed(c),
2502 gdTrueColorGetGreen(c),
2503 gdTrueColorGetBlue(c),
2504 gdTrueColorGetAlpha (c));
2505 } else {
2506 /* Have we established a mapping for this color? */
2507 if (colorMap[c] == (-1)) {
2508 /* If it's the same image, mapping is trivial */
2509 if (dst == src) {
2510 nc = c;
2511 } else {
2512 /* Find or create the best match */
2513 /* 2.0.5: can't use gdTrueColorGetRed, etc with palette */
2514 nc = gdImageColorResolveAlpha(dst, gdImageRed(src, c),
2515 gdImageGreen(src, c),
2516 gdImageBlue(src, c),
2517 gdImageAlpha(src, c));
2518 }
2519 colorMap[c] = nc;
2520 }
2521 mapTo = colorMap[c];
2522 }
2523 }
2524 for (i = 0; (i < stx[x - srcX]); i++) {
2525 gdImageSetPixel (dst, tox, toy, mapTo);
2526 tox++;
2527 }
2528 }
2529 toy++;
2530 }
2531 }
2532 gdFree (stx);
2533 gdFree (sty);
2534 }
2535
2536 /* When gd 1.x was first created, floating point was to be avoided.
2537 These days it is often faster than table lookups or integer
2538 arithmetic. The routine below is shamelessly, gloriously
2539 floating point. TBB */
2540
gdImageCopyResampled(gdImagePtr dst,gdImagePtr src,int dstX,int dstY,int srcX,int srcY,int dstW,int dstH,int srcW,int srcH)2541 void gdImageCopyResampled (gdImagePtr dst, gdImagePtr src, int dstX, int dstY, int srcX, int srcY, int dstW, int dstH, int srcW, int srcH)
2542 {
2543 int x, y;
2544 double sy1, sy2, sx1, sx2;
2545
2546 if (!dst->trueColor) {
2547 gdImageCopyResized (dst, src, dstX, dstY, srcX, srcY, dstW, dstH, srcW, srcH);
2548 return;
2549 }
2550 for (y = dstY; (y < dstY + dstH); y++) {
2551 sy1 = ((double) y - (double) dstY) * (double) srcH / (double) dstH;
2552 sy2 = ((double) (y + 1) - (double) dstY) * (double) srcH / (double) dstH;
2553 for (x = dstX; (x < dstX + dstW); x++) {
2554 double sx, sy;
2555 double spixels = 0;
2556 double red = 0.0, green = 0.0, blue = 0.0, alpha = 0.0;
2557 double alpha_factor, alpha_sum = 0.0, contrib_sum = 0.0;
2558 sx1 = ((double) x - (double) dstX) * (double) srcW / dstW;
2559 sx2 = ((double) (x + 1) - (double) dstX) * (double) srcW / dstW;
2560 sy = sy1;
2561 do {
2562 double yportion;
2563 if (floor_cast(sy) == floor_cast(sy1)) {
2564 yportion = 1.0f - (sy - floor_cast(sy));
2565 if (yportion > sy2 - sy1) {
2566 yportion = sy2 - sy1;
2567 }
2568 sy = floor_cast(sy);
2569 } else if (sy == floorf(sy2)) {
2570 yportion = sy2 - floor_cast(sy2);
2571 } else {
2572 yportion = 1.0f;
2573 }
2574 sx = sx1;
2575 do {
2576 double xportion;
2577 double pcontribution;
2578 int p;
2579 if (floorf(sx) == floor_cast(sx1)) {
2580 xportion = 1.0f - (sx - floor_cast(sx));
2581 if (xportion > sx2 - sx1) {
2582 xportion = sx2 - sx1;
2583 }
2584 sx = floor_cast(sx);
2585 } else if (sx == floorf(sx2)) {
2586 xportion = sx2 - floor_cast(sx2);
2587 } else {
2588 xportion = 1.0f;
2589 }
2590 pcontribution = xportion * yportion;
2591 p = gdImageGetTrueColorPixel(src, (int) sx + srcX, (int) sy + srcY);
2592
2593 alpha_factor = ((gdAlphaMax - gdTrueColorGetAlpha(p))) * pcontribution;
2594 red += gdTrueColorGetRed (p) * alpha_factor;
2595 green += gdTrueColorGetGreen (p) * alpha_factor;
2596 blue += gdTrueColorGetBlue (p) * alpha_factor;
2597 alpha += gdTrueColorGetAlpha (p) * pcontribution;
2598 alpha_sum += alpha_factor;
2599 contrib_sum += pcontribution;
2600 spixels += xportion * yportion;
2601 sx += 1.0f;
2602 }
2603 while (sx < sx2);
2604
2605 sy += 1.0f;
2606 }
2607
2608 while (sy < sy2);
2609
2610 if (spixels != 0.0f) {
2611 red /= spixels;
2612 green /= spixels;
2613 blue /= spixels;
2614 alpha /= spixels;
2615 }
2616 if ( alpha_sum != 0.0f) {
2617 if( contrib_sum != 0.0f) {
2618 alpha_sum /= contrib_sum;
2619 }
2620 red /= alpha_sum;
2621 green /= alpha_sum;
2622 blue /= alpha_sum;
2623 }
2624 /* Round up closest next channel value and clamp to max channel value */
2625 red = red >= 255.5 ? 255 : red+0.5;
2626 blue = blue >= 255.5 ? 255 : blue+0.5;
2627 green = green >= 255.5 ? 255 : green+0.5;
2628 alpha = alpha >= gdAlphaMax+0.5 ? gdAlphaMax : alpha+0.5;
2629 gdImageSetPixel(dst, x, y, gdTrueColorAlpha ((int)red, (int)green, (int)blue, (int)alpha));
2630 }
2631 }
2632 }
2633
gdImagePolygon(gdImagePtr im,gdPointPtr p,int n,int c)2634 void gdImagePolygon (gdImagePtr im, gdPointPtr p, int n, int c)
2635 {
2636 if (n <= 0) {
2637 return;
2638 }
2639
2640
2641 gdImageLine (im, p->x, p->y, p[n - 1].x, p[n - 1].y, c);
2642 gdImageOpenPolygon (im, p, n, c);
2643 }
2644
gdImageOpenPolygon(gdImagePtr im,gdPointPtr p,int n,int c)2645 void gdImageOpenPolygon (gdImagePtr im, gdPointPtr p, int n, int c)
2646 {
2647 int i;
2648 int lx, ly;
2649
2650 if (n <= 0) {
2651 return;
2652 }
2653
2654 lx = p->x;
2655 ly = p->y;
2656 for (i = 1; i < n; i++) {
2657 p++;
2658 gdImageLine(im, lx, ly, p->x, p->y, c);
2659 lx = p->x;
2660 ly = p->y;
2661 }
2662 }
2663
2664 int gdCompareInt (const void *a, const void *b);
2665
2666 /* THANKS to Kirsten Schulz for the polygon fixes! */
2667
2668 /* The intersection finding technique of this code could be improved
2669 * by remembering the previous intertersection, and by using the slope.
2670 * That could help to adjust intersections to produce a nice
2671 * interior_extrema.
2672 */
2673
gdImageFilledPolygon(gdImagePtr im,gdPointPtr p,int n,int c)2674 void gdImageFilledPolygon (gdImagePtr im, gdPointPtr p, int n, int c)
2675 {
2676 int i;
2677 int y;
2678 int miny, maxy, pmaxy;
2679 int x1, y1;
2680 int x2, y2;
2681 int ind1, ind2;
2682 int ints;
2683 int fill_color;
2684
2685 if (n <= 0) {
2686 return;
2687 }
2688
2689 if (overflow2(sizeof(int), n)) {
2690 return;
2691 }
2692
2693 if (c == gdAntiAliased) {
2694 fill_color = im->AA_color;
2695 } else {
2696 fill_color = c;
2697 }
2698
2699 if (!im->polyAllocated) {
2700 im->polyInts = (int *) gdMalloc(sizeof(int) * n);
2701 im->polyAllocated = n;
2702 }
2703 if (im->polyAllocated < n) {
2704 while (im->polyAllocated < n) {
2705 im->polyAllocated *= 2;
2706 }
2707 if (overflow2(sizeof(int), im->polyAllocated)) {
2708 return;
2709 }
2710 im->polyInts = (int *) gdRealloc(im->polyInts, sizeof(int) * im->polyAllocated);
2711 }
2712 miny = p[0].y;
2713 maxy = p[0].y;
2714 for (i = 1; i < n; i++) {
2715 if (p[i].y < miny) {
2716 miny = p[i].y;
2717 }
2718 if (p[i].y > maxy) {
2719 maxy = p[i].y;
2720 }
2721 }
2722 /* necessary special case: horizontal line */
2723 if (n > 1 && miny == maxy) {
2724 x1 = x2 = p[0].x;
2725 for (i = 1; (i < n); i++) {
2726 if (p[i].x < x1) {
2727 x1 = p[i].x;
2728 } else if (p[i].x > x2) {
2729 x2 = p[i].x;
2730 }
2731 }
2732 gdImageLine(im, x1, miny, x2, miny, c);
2733 return;
2734 }
2735 pmaxy = maxy;
2736 /* 2.0.16: Optimization by Ilia Chipitsine -- don't waste time offscreen */
2737 if (miny < 0) {
2738 miny = 0;
2739 }
2740 if (maxy >= gdImageSY(im)) {
2741 maxy = gdImageSY(im) - 1;
2742 }
2743
2744 /* Fix in 1.3: count a vertex only once */
2745 for (y = miny; y <= maxy; y++) {
2746 /*1.4 int interLast = 0; */
2747 /* int dirLast = 0; */
2748 /* int interFirst = 1; */
2749 ints = 0;
2750 for (i = 0; i < n; i++) {
2751 if (!i) {
2752 ind1 = n - 1;
2753 ind2 = 0;
2754 } else {
2755 ind1 = i - 1;
2756 ind2 = i;
2757 }
2758 y1 = p[ind1].y;
2759 y2 = p[ind2].y;
2760 if (y1 < y2) {
2761 x1 = p[ind1].x;
2762 x2 = p[ind2].x;
2763 } else if (y1 > y2) {
2764 y2 = p[ind1].y;
2765 y1 = p[ind2].y;
2766 x2 = p[ind1].x;
2767 x1 = p[ind2].x;
2768 } else {
2769 continue;
2770 }
2771 /* Do the following math as float intermediately, and round to ensure
2772 * that Polygon and FilledPolygon for the same set of points have the
2773 * same footprint.
2774 */
2775 if (y >= y1 && y < y2) {
2776 im->polyInts[ints++] = (float) ((y - y1) * (x2 - x1)) / (float) (y2 - y1) + 0.5 + x1;
2777 } else if (y == pmaxy && y == y2) {
2778 im->polyInts[ints++] = x2;
2779 }
2780 }
2781 qsort(im->polyInts, ints, sizeof(int), gdCompareInt);
2782
2783 for (i = 0; i < ints - 1; i += 2) {
2784 gdImageLine(im, im->polyInts[i], y, im->polyInts[i + 1], y, fill_color);
2785 }
2786 }
2787
2788 /* If we are drawing this AA, then redraw the border with AA lines. */
2789 if (c == gdAntiAliased) {
2790 gdImagePolygon(im, p, n, c);
2791 }
2792 }
2793
gdCompareInt(const void * a,const void * b)2794 int gdCompareInt (const void *a, const void *b)
2795 {
2796 return (*(const int *) a) - (*(const int *) b);
2797 }
2798
gdImageSetStyle(gdImagePtr im,int * style,int noOfPixels)2799 void gdImageSetStyle (gdImagePtr im, int *style, int noOfPixels)
2800 {
2801 if (im->style) {
2802 gdFree(im->style);
2803 }
2804 if (overflow2(sizeof (int), noOfPixels)) {
2805 return;
2806 }
2807 im->style = (int *) gdMalloc(sizeof(int) * noOfPixels);
2808 memcpy(im->style, style, sizeof(int) * noOfPixels);
2809 im->styleLength = noOfPixels;
2810 im->stylePos = 0;
2811 }
2812
gdImageSetThickness(gdImagePtr im,int thickness)2813 void gdImageSetThickness (gdImagePtr im, int thickness)
2814 {
2815 im->thick = thickness;
2816 }
2817
gdImageSetBrush(gdImagePtr im,gdImagePtr brush)2818 void gdImageSetBrush (gdImagePtr im, gdImagePtr brush)
2819 {
2820 int i;
2821 im->brush = brush;
2822 if (!im->trueColor && !im->brush->trueColor) {
2823 for (i = 0; i < gdImageColorsTotal(brush); i++) {
2824 int index;
2825 index = gdImageColorResolveAlpha(im, gdImageRed(brush, i), gdImageGreen(brush, i), gdImageBlue(brush, i), gdImageAlpha(brush, i));
2826 im->brushColorMap[i] = index;
2827 }
2828 }
2829 }
2830
gdImageSetTile(gdImagePtr im,gdImagePtr tile)2831 void gdImageSetTile (gdImagePtr im, gdImagePtr tile)
2832 {
2833 int i;
2834 im->tile = tile;
2835 if (!im->trueColor && !im->tile->trueColor) {
2836 for (i = 0; i < gdImageColorsTotal(tile); i++) {
2837 int index;
2838 index = gdImageColorResolveAlpha(im, gdImageRed(tile, i), gdImageGreen(tile, i), gdImageBlue(tile, i), gdImageAlpha(tile, i));
2839 im->tileColorMap[i] = index;
2840 }
2841 }
2842 }
2843
gdImageSetAntiAliased(gdImagePtr im,int c)2844 void gdImageSetAntiAliased (gdImagePtr im, int c)
2845 {
2846 im->AA = 1;
2847 im->AA_color = c;
2848 im->AA_dont_blend = -1;
2849 }
2850
gdImageSetAntiAliasedDontBlend(gdImagePtr im,int c,int dont_blend)2851 void gdImageSetAntiAliasedDontBlend (gdImagePtr im, int c, int dont_blend)
2852 {
2853 im->AA = 1;
2854 im->AA_color = c;
2855 im->AA_dont_blend = dont_blend;
2856 }
2857
2858
gdImageInterlace(gdImagePtr im,int interlaceArg)2859 void gdImageInterlace (gdImagePtr im, int interlaceArg)
2860 {
2861 im->interlace = interlaceArg;
2862 }
2863
gdImageCompare(gdImagePtr im1,gdImagePtr im2)2864 int gdImageCompare (gdImagePtr im1, gdImagePtr im2)
2865 {
2866 int x, y;
2867 int p1, p2;
2868 int cmpStatus = 0;
2869 int sx, sy;
2870
2871 if (im1->interlace != im2->interlace) {
2872 cmpStatus |= GD_CMP_INTERLACE;
2873 }
2874
2875 if (im1->transparent != im2->transparent) {
2876 cmpStatus |= GD_CMP_TRANSPARENT;
2877 }
2878
2879 if (im1->trueColor != im2->trueColor) {
2880 cmpStatus |= GD_CMP_TRUECOLOR;
2881 }
2882
2883 sx = im1->sx;
2884 if (im1->sx != im2->sx) {
2885 cmpStatus |= GD_CMP_SIZE_X + GD_CMP_IMAGE;
2886 if (im2->sx < im1->sx) {
2887 sx = im2->sx;
2888 }
2889 }
2890
2891 sy = im1->sy;
2892 if (im1->sy != im2->sy) {
2893 cmpStatus |= GD_CMP_SIZE_Y + GD_CMP_IMAGE;
2894 if (im2->sy < im1->sy) {
2895 sy = im2->sy;
2896 }
2897 }
2898
2899 if (im1->colorsTotal != im2->colorsTotal) {
2900 cmpStatus |= GD_CMP_NUM_COLORS;
2901 }
2902
2903 for (y = 0; y < sy; y++) {
2904 for (x = 0; x < sx; x++) {
2905 p1 = im1->trueColor ? gdImageTrueColorPixel(im1, x, y) : gdImagePalettePixel(im1, x, y);
2906 p2 = im2->trueColor ? gdImageTrueColorPixel(im2, x, y) : gdImagePalettePixel(im2, x, y);
2907
2908 if (gdImageRed(im1, p1) != gdImageRed(im2, p2)) {
2909 cmpStatus |= GD_CMP_COLOR + GD_CMP_IMAGE;
2910 break;
2911 }
2912 if (gdImageGreen(im1, p1) != gdImageGreen(im2, p2)) {
2913 cmpStatus |= GD_CMP_COLOR + GD_CMP_IMAGE;
2914 break;
2915 }
2916 if (gdImageBlue(im1, p1) != gdImageBlue(im2, p2)) {
2917 cmpStatus |= GD_CMP_COLOR + GD_CMP_IMAGE;
2918 break;
2919 }
2920 #if 0
2921 /* Soon we'll add alpha channel to palettes */
2922 if (gdImageAlpha(im1, p1) != gdImageAlpha(im2, p2)) {
2923 cmpStatus |= GD_CMP_COLOR + GD_CMP_IMAGE;
2924 break;
2925 }
2926 #endif
2927 }
2928 if (cmpStatus & GD_CMP_COLOR) {
2929 break;
2930 }
2931 }
2932
2933 return cmpStatus;
2934 }
2935
gdAlphaBlend(int dst,int src)2936 int gdAlphaBlend (int dst, int src) {
2937 int src_alpha = gdTrueColorGetAlpha(src);
2938 int dst_alpha, alpha, red, green, blue;
2939 int src_weight, dst_weight, tot_weight;
2940
2941 /* -------------------------------------------------------------------- */
2942 /* Simple cases we want to handle fast. */
2943 /* -------------------------------------------------------------------- */
2944 if( src_alpha == gdAlphaOpaque )
2945 return src;
2946
2947 dst_alpha = gdTrueColorGetAlpha(dst);
2948 if( src_alpha == gdAlphaTransparent )
2949 return dst;
2950 if( dst_alpha == gdAlphaTransparent )
2951 return src;
2952
2953 /* -------------------------------------------------------------------- */
2954 /* What will the source and destination alphas be? Note that */
2955 /* the destination weighting is substantially reduced as the */
2956 /* overlay becomes quite opaque. */
2957 /* -------------------------------------------------------------------- */
2958 src_weight = gdAlphaTransparent - src_alpha;
2959 dst_weight = (gdAlphaTransparent - dst_alpha) * src_alpha / gdAlphaMax;
2960 tot_weight = src_weight + dst_weight;
2961
2962 /* -------------------------------------------------------------------- */
2963 /* What red, green and blue result values will we use? */
2964 /* -------------------------------------------------------------------- */
2965 alpha = src_alpha * dst_alpha / gdAlphaMax;
2966
2967 red = (gdTrueColorGetRed(src) * src_weight
2968 + gdTrueColorGetRed(dst) * dst_weight) / tot_weight;
2969 green = (gdTrueColorGetGreen(src) * src_weight
2970 + gdTrueColorGetGreen(dst) * dst_weight) / tot_weight;
2971 blue = (gdTrueColorGetBlue(src) * src_weight
2972 + gdTrueColorGetBlue(dst) * dst_weight) / tot_weight;
2973
2974 /* -------------------------------------------------------------------- */
2975 /* Return merged result. */
2976 /* -------------------------------------------------------------------- */
2977 return ((alpha << 24) + (red << 16) + (green << 8) + blue);
2978
2979 }
2980
gdImageAlphaBlending(gdImagePtr im,int alphaBlendingArg)2981 void gdImageAlphaBlending (gdImagePtr im, int alphaBlendingArg)
2982 {
2983 im->alphaBlendingFlag = alphaBlendingArg;
2984 }
2985
gdImageSaveAlpha(gdImagePtr im,int saveAlphaArg)2986 void gdImageSaveAlpha (gdImagePtr im, int saveAlphaArg)
2987 {
2988 im->saveAlphaFlag = saveAlphaArg;
2989 }
2990
gdLayerOverlay(int dst,int src)2991 int gdLayerOverlay (int dst, int src)
2992 {
2993 int a1, a2;
2994 a1 = gdAlphaMax - gdTrueColorGetAlpha(dst);
2995 a2 = gdAlphaMax - gdTrueColorGetAlpha(src);
2996 return ( ((gdAlphaMax - a1*a2/gdAlphaMax) << 24) +
2997 (gdAlphaOverlayColor( gdTrueColorGetRed(src), gdTrueColorGetRed(dst), gdRedMax ) << 16) +
2998 (gdAlphaOverlayColor( gdTrueColorGetGreen(src), gdTrueColorGetGreen(dst), gdGreenMax ) << 8) +
2999 (gdAlphaOverlayColor( gdTrueColorGetBlue(src), gdTrueColorGetBlue(dst), gdBlueMax ))
3000 );
3001 }
3002
gdAlphaOverlayColor(int src,int dst,int max)3003 static int gdAlphaOverlayColor (int src, int dst, int max )
3004 {
3005 /* this function implements the algorithm
3006 *
3007 * for dst[rgb] < 0.5,
3008 * c[rgb] = 2.src[rgb].dst[rgb]
3009 * and for dst[rgb] > 0.5,
3010 * c[rgb] = -2.src[rgb].dst[rgb] + 2.dst[rgb] + 2.src[rgb] - 1
3011 *
3012 */
3013
3014 dst = dst << 1;
3015 if( dst > max ) {
3016 /* in the "light" zone */
3017 return dst + (src << 1) - (dst * src / max) - max;
3018 } else {
3019 /* in the "dark" zone */
3020 return dst * src / max;
3021 }
3022 }
3023
gdLayerMultiply(int dst,int src)3024 int gdLayerMultiply (int dst, int src)
3025 {
3026 int a1, a2, r1, r2, g1, g2, b1, b2;
3027 a1 = gdAlphaMax - gdTrueColorGetAlpha(src);
3028 a2 = gdAlphaMax - gdTrueColorGetAlpha(dst);
3029
3030 r1 = gdRedMax - (a1 * (gdRedMax - gdTrueColorGetRed(src))) / gdAlphaMax;
3031 r2 = gdRedMax - (a2 * (gdRedMax - gdTrueColorGetRed(dst))) / gdAlphaMax;
3032 g1 = gdGreenMax - (a1 * (gdGreenMax - gdTrueColorGetGreen(src))) / gdAlphaMax;
3033 g2 = gdGreenMax - (a2 * (gdGreenMax - gdTrueColorGetGreen(dst))) / gdAlphaMax;
3034 b1 = gdBlueMax - (a1 * (gdBlueMax - gdTrueColorGetBlue(src))) / gdAlphaMax;
3035 b2 = gdBlueMax - (a2 * (gdBlueMax - gdTrueColorGetBlue(dst))) / gdAlphaMax ;
3036
3037 a1 = gdAlphaMax - a1;
3038 a2 = gdAlphaMax - a2;
3039 return ( ((a1*a2/gdAlphaMax) << 24) +
3040 ((r1*r2/gdRedMax) << 16) +
3041 ((g1*g2/gdGreenMax) << 8) +
3042 ((b1*b2/gdBlueMax))
3043 );
3044 }
3045
gdImageSetClip(gdImagePtr im,int x1,int y1,int x2,int y2)3046 void gdImageSetClip (gdImagePtr im, int x1, int y1, int x2, int y2)
3047 {
3048 if (x1 < 0) {
3049 x1 = 0;
3050 }
3051 if (x1 >= im->sx) {
3052 x1 = im->sx - 1;
3053 }
3054 if (x2 < 0) {
3055 x2 = 0;
3056 }
3057 if (x2 >= im->sx) {
3058 x2 = im->sx - 1;
3059 }
3060 if (y1 < 0) {
3061 y1 = 0;
3062 }
3063 if (y1 >= im->sy) {
3064 y1 = im->sy - 1;
3065 }
3066 if (y2 < 0) {
3067 y2 = 0;
3068 }
3069 if (y2 >= im->sy) {
3070 y2 = im->sy - 1;
3071 }
3072 im->cx1 = x1;
3073 im->cy1 = y1;
3074 im->cx2 = x2;
3075 im->cy2 = y2;
3076 }
3077
gdImageGetClip(gdImagePtr im,int * x1P,int * y1P,int * x2P,int * y2P)3078 void gdImageGetClip (gdImagePtr im, int *x1P, int *y1P, int *x2P, int *y2P)
3079 {
3080 *x1P = im->cx1;
3081 *y1P = im->cy1;
3082 *x2P = im->cx2;
3083 *y2P = im->cy2;
3084 }
3085
gdImageSetResolution(gdImagePtr im,const unsigned int res_x,const unsigned int res_y)3086 void gdImageSetResolution(gdImagePtr im, const unsigned int res_x, const unsigned int res_y)
3087 {
3088 if (res_x > 0) im->res_x = res_x;
3089 if (res_y > 0) im->res_y = res_y;
3090 }
3091
3092 /* convert a palette image to true color */
gdImagePaletteToTrueColor(gdImagePtr src)3093 int gdImagePaletteToTrueColor(gdImagePtr src)
3094 {
3095 unsigned int y;
3096 unsigned int yy;
3097
3098 if (src == NULL) {
3099 return 0;
3100 }
3101
3102 if (src->trueColor == 1) {
3103 return 1;
3104 } else {
3105 unsigned int x;
3106 const unsigned int sy = gdImageSY(src);
3107 const unsigned int sx = gdImageSX(src);
3108
3109 src->tpixels = (int **) gdMalloc(sizeof(int *) * sy);
3110 if (src->tpixels == NULL) {
3111 return 0;
3112 }
3113
3114 for (y = 0; y < sy; y++) {
3115 const unsigned char *src_row = src->pixels[y];
3116 int * dst_row;
3117
3118 /* no need to calloc it, we overwrite all pxl anyway */
3119 src->tpixels[y] = (int *) gdMalloc(sx * sizeof(int));
3120 if (src->tpixels[y] == NULL) {
3121 goto clean_on_error;
3122 }
3123
3124 dst_row = src->tpixels[y];
3125 for (x = 0; x < sx; x++) {
3126 const unsigned char c = *(src_row + x);
3127 if (c == src->transparent) {
3128 *(dst_row + x) = gdTrueColorAlpha(0, 0, 0, 127);
3129 } else {
3130 *(dst_row + x) = gdTrueColorAlpha(src->red[c], src->green[c], src->blue[c], src->alpha[c]);
3131 }
3132 }
3133 }
3134 }
3135
3136 /* free old palette buffer (y is sy) */
3137 for (yy = 0; yy < y; yy++) {
3138 gdFree(src->pixels[yy]);
3139 }
3140 gdFree(src->pixels);
3141 src->trueColor = 1;
3142 src->pixels = NULL;
3143 src->alphaBlendingFlag = 0;
3144 src->saveAlphaFlag = 1;
3145
3146 if (src->transparent >= 0) {
3147 const unsigned char c = src->transparent;
3148 src->transparent = gdTrueColorAlpha(src->red[c], src->green[c], src->blue[c], src->alpha[c]);
3149 }
3150
3151 return 1;
3152
3153 clean_on_error:
3154 /* free new true color buffer (y is not allocated, have failed) */
3155 for (yy = 0; yy < y; yy++) {
3156 gdFree(src->tpixels[yy]);
3157 }
3158 gdFree(src->tpixels);
3159 return 0;
3160 }
3161
