1 #ifdef HAVE_CONFIG_H
2 #include "config.h"
3 #endif
4
5 #include "Imlib.h"
6 #include "Imlib_private.h"
7
8 int
Imlib_best_color_match(ImlibData * id,int * r,int * g,int * b)9 Imlib_best_color_match(ImlibData * id, int *r, int *g, int *b)
10 {
11 int i;
12 int dif;
13 int dr, dg, db;
14 int col;
15 int mindif = 0x7fffffff;
16
17 col = 0;
18 if (!id)
19 {
20 fprintf(stderr, "ImLib ERROR: No ImlibData initialised\n");
21 return -1;
22 }
23 if ((id->render_type == RT_PLAIN_TRUECOL) ||
24 (id->render_type == RT_DITHER_TRUECOL))
25 {
26 dr = *r;
27 dg = *g;
28 db = *b;
29 switch (id->x.depth)
30 {
31 case 15:
32 *r = dr - (dr & 0xf8);
33 *g = dg - (dg & 0xf8);
34 *b = db - (db & 0xf8);
35 return ((dr & 0xf8) << 7) | ((dg & 0xf8) << 2) | ((db & 0xf8) >> 3);
36 break;
37 case 16:
38 *r = dr - (dr & 0xf8);
39 *g = dg - (dg & 0xfc);
40 *b = db - (db & 0xf8);
41 return ((dr & 0xf8) << 8) | ((dg & 0xfc) << 3) | ((db & 0xf8) >> 3);
42 break;
43 case 24:
44 case 32:
45 *r = 0;
46 *g = 0;
47 *b = 0;
48 switch (id->byte_order)
49 {
50 case BYTE_ORD_24_RGB:
51 return ((dr & 0xff) << 16) | ((dg & 0xff) << 8) | (db & 0xff);
52 break;
53 case BYTE_ORD_24_RBG:
54 return ((dr & 0xff) << 16) | ((db & 0xff) << 8) | (dg & 0xff);
55 break;
56 case BYTE_ORD_24_BRG:
57 return ((db & 0xff) << 16) | ((dr & 0xff) << 8) | (dg & 0xff);
58 break;
59 case BYTE_ORD_24_BGR:
60 return ((db & 0xff) << 16) | ((dg & 0xff) << 8) | (dr & 0xff);
61 break;
62 case BYTE_ORD_24_GRB:
63 return ((dg & 0xff) << 16) | ((dr & 0xff) << 8) | (db & 0xff);
64 break;
65 case BYTE_ORD_24_GBR:
66 return ((dg & 0xff) << 16) | ((db & 0xff) << 8) | (dr & 0xff);
67 break;
68 default:
69 return 0;
70 break;
71 }
72 break;
73 default:
74 return 0;
75 break;
76 }
77 return 0;
78 }
79 for (i = 0; i < id->num_colors; i++)
80 {
81 dr = *r - id->palette[i].r;
82 if (dr < 0)
83 dr = -dr;
84 dg = *g - id->palette[i].g;
85 if (dg < 0)
86 dg = -dg;
87 db = *b - id->palette[i].b;
88 if (db < 0)
89 db = -db;
90 dif = dr + dg + db;
91 if (dif < mindif)
92 {
93 mindif = dif;
94 col = i;
95 }
96 }
97 *r -= id->palette[col].r;
98 *g -= id->palette[col].g;
99 *b -= id->palette[col].b;
100 col = id->palette[col].pixel;
101 return col;
102 }
103
104 int
index_best_color_match(ImlibData * id,int * r,int * g,int * b)105 index_best_color_match(ImlibData * id, int *r, int *g, int *b)
106 {
107 int i;
108 int dif;
109 int dr, dg, db;
110 int col;
111 int mindif = 0x7fffffff;
112
113 col = 0;
114 if (!id)
115 {
116 fprintf(stderr, "ImLib ERROR: No ImlibData initialised\n");
117 return -1;
118 }
119 if ((id->render_type == RT_PLAIN_TRUECOL) ||
120 (id->render_type == RT_DITHER_TRUECOL))
121 {
122 dr = *r;
123 dg = *g;
124 db = *b;
125 switch (id->x.depth)
126 {
127 case 15:
128 *r = dr - (dr & 0xf8);
129 *g = dg - (dg & 0xf8);
130 *b = db - (db & 0xf8);
131 return ((dr & 0xf8) << 7) | ((dg & 0xf8) << 2) | ((db & 0xf8) >> 3);
132 break;
133 case 16:
134 *r = dr - (dr & 0xf8);
135 *g = dg - (dg & 0xfc);
136 *b = db - (db & 0xf8);
137 return ((dr & 0xf8) << 8) | ((dg & 0xfc) << 3) | ((db & 0xf8) >> 3);
138 break;
139 case 24:
140 case 32:
141 *r = 0;
142 *g = 0;
143 *b = 0;
144 switch (id->byte_order)
145 {
146 case BYTE_ORD_24_RGB:
147 return ((dr & 0xff) << 16) | ((dg & 0xff) << 8) | (db & 0xff);
148 break;
149 case BYTE_ORD_24_RBG:
150 return ((dr & 0xff) << 16) | ((db & 0xff) << 8) | (dg & 0xff);
151 break;
152 case BYTE_ORD_24_BRG:
153 return ((db & 0xff) << 16) | ((dr & 0xff) << 8) | (dg & 0xff);
154 break;
155 case BYTE_ORD_24_BGR:
156 return ((db & 0xff) << 16) | ((dg & 0xff) << 8) | (dr & 0xff);
157 break;
158 case BYTE_ORD_24_GRB:
159 return ((dg & 0xff) << 16) | ((dr & 0xff) << 8) | (db & 0xff);
160 break;
161 case BYTE_ORD_24_GBR:
162 return ((dg & 0xff) << 16) | ((db & 0xff) << 8) | (dr & 0xff);
163 break;
164 default:
165 return 0;
166 break;
167 }
168 break;
169 default:
170 return 0;
171 break;
172 }
173 return 0;
174 }
175 for (i = 0; i < id->num_colors; i++)
176 {
177 dr = *r - id->palette[i].r;
178 if (dr < 0)
179 dr = -dr;
180 dg = *g - id->palette[i].g;
181 if (dg < 0)
182 dg = -dg;
183 db = *b - id->palette[i].b;
184 if (db < 0)
185 db = -db;
186 dif = dr + dg + db;
187 if (dif < mindif)
188 {
189 mindif = dif;
190 col = i;
191 }
192 }
193 *r -= id->palette[col].r;
194 *g -= id->palette[col].g;
195 *b -= id->palette[col].b;
196 return col;
197 }
198
199 static void
render_shaped_15_fast_dither(ImlibData * id,ImlibImage * im,int w,int h,XImage * xim,XImage * sxim,int * er1,int * er2,int * xarray,unsigned char ** yarray)200 render_shaped_15_fast_dither(ImlibData * id, ImlibImage * im, int w, int h, XImage * xim,
201 XImage * sxim, int *er1, int *er2, int *xarray,
202 unsigned char **yarray)
203 {
204 int x, y, val, r, g, b, *ter, ex, er, eg, eb;
205 unsigned char *ptr2;
206 unsigned short *img;
207 int jmp;
208
209 jmp = (xim->bytes_per_line >> 1) - w;
210 img = (unsigned short *)xim->data;
211 for (y = 0; y < h; y++)
212 {
213 ter = er1;
214 er1 = er2;
215 er2 = ter;
216 for (ex = 0; ex < (w + 2) * 3; ex++)
217 er2[ex] = 0;
218 ex = 3;
219 for (x = 0; x < w; x++)
220 {
221 ptr2 = yarray[y] + xarray[x];
222 r = (int)*ptr2++;
223 g = (int)*ptr2++;
224 b = (int)*ptr2;
225 if ((r == im->shape_color.r) &&
226 (g == im->shape_color.g) &&
227 (b == im->shape_color.b))
228 {
229 XPutPixel(sxim, x, y, 0);
230 img++;
231 ex += 3;
232 }
233 else
234 {
235 XPutPixel(sxim, x, y, 1);
236 er = r + er1[ex++];
237 eg = g + er1[ex++];
238 eb = b + er1[ex++];
239 if (er > 255)
240 er = 255;
241 if (eg > 255)
242 eg = 255;
243 if (eb > 255)
244 eb = 255;
245 val = ((er & 0xf8) << 7) | ((eg & 0xf8) << 2) | ((eb & 0xf8) >> 3);
246 er = er & 0x07;
247 eg = eg & 0x07;
248 eb = eb & 0x07;
249 DITHER_ERROR(er1, er2, ex, er, eg, eb);
250 *img++ = val;
251 }
252 }
253 img += jmp;
254 }
255 }
256
257 #if 0
258 static void
259 render_shaped_15_fast_dither_ordered(ImlibData * id, ImlibImage * im, int w, int h, XImage * xim,
260 XImage * sxim, int *er1, int *er2, int *xarray,
261 unsigned char **yarray)
262 {
263 int x, y, val, r, g, b, er, eg, eb;
264 unsigned char *ptr2;
265 unsigned short *img;
266 int jmp;
267
268 unsigned char dither[4][4] =
269 {
270 {0, 4, 1, 5},
271 {6, 2, 7, 3},
272 {1, 5, 0, 4},
273 {7, 3, 6, 2}
274 };
275 int dithy, dithx;
276
277 jmp = (xim->bytes_per_line >> 1) - w;
278 img = (unsigned short *)xim->data;
279 for (y = 0; y < h; y++)
280 {
281 dithy = y & 0x3;
282 for (x = 0; x < w; x++)
283 {
284 ptr2 = yarray[y] + xarray[x];
285 r = (int)*ptr2++;
286 g = (int)*ptr2++;
287 b = (int)*ptr2;
288 if ((r == im->shape_color.r) &&
289 (g == im->shape_color.g) &&
290 (b == im->shape_color.b))
291 {
292 XPutPixel(sxim, x, y, 0);
293 img++;
294 }
295 else
296 {
297 XPutPixel(sxim, x, y, 1);
298 er = r & 0x07;
299 eg = g & 0x07;
300 eb = b & 0x07;
301 dithx = x & 0x3;
302 if ((dither[dithy][dithx] < er) && (r < (256 - 8)))
303 r += 8;
304 if ((dither[dithy][dithx] < eg) && (g < (256 - 8)))
305 g += 8;
306 if ((dither[dithy][dithx] < eb) && (b < (256 - 8)))
307 b += 8;
308 val = ((r & 0xf8) << 7) | ((g & 0xf8) << 2) | ((b & 0xf8) >> 3);
309 *img++ = val;
310 }
311 }
312 img += jmp;
313 }
314 }
315 #endif
316
317 static void
render_15_fast_dither(ImlibData * id,ImlibImage * im,int w,int h,XImage * xim,XImage * sxim,int * er1,int * er2,int * xarray,unsigned char ** yarray)318 render_15_fast_dither(ImlibData * id, ImlibImage * im, int w, int h, XImage * xim,
319 XImage * sxim, int *er1, int *er2, int *xarray,
320 unsigned char **yarray)
321 {
322 int x, y, val, r, g, b, *ter, ex, er, eg, eb;
323 unsigned char *ptr2;
324 unsigned short *img;
325 int jmp;
326
327 jmp = (xim->bytes_per_line >> 1) - w;
328 img = (unsigned short *)xim->data;
329 for (y = 0; y < h; y++)
330 {
331 ter = er1;
332 er1 = er2;
333 er2 = ter;
334 for (ex = 0; ex < (w + 2) * 3; ex++)
335 er2[ex] = 0;
336 ex = 3;
337 for (x = 0; x < w; x++)
338 {
339 ptr2 = yarray[y] + xarray[x];
340 r = (int)*ptr2++;
341 g = (int)*ptr2++;
342 b = (int)*ptr2;
343 er = r + er1[ex++];
344 eg = g + er1[ex++];
345 eb = b + er1[ex++];
346 if (er > 255)
347 er = 255;
348 if (eg > 255)
349 eg = 255;
350 if (eb > 255)
351 eb = 255;
352 val = ((er & 0xf8) << 7) | ((eg & 0xf8) << 2) | ((eb & 0xf8) >> 3);
353 er = er & 0x07;
354 eg = eg & 0x07;
355 eb = eb & 0x07;
356 DITHER_ERROR(er1, er2, ex, er, eg, eb);
357 *img++ = val;
358 }
359 img += jmp;
360 }
361 }
362
363 static void
render_15_fast_dither_ordered(ImlibData * id,ImlibImage * im,int w,int h,XImage * xim,XImage * sxim,int * er1,int * er2,int * xarray,unsigned char ** yarray)364 render_15_fast_dither_ordered(ImlibData * id, ImlibImage * im, int w, int h, XImage * xim,
365 XImage * sxim, int *er1, int *er2, int *xarray,
366 unsigned char **yarray)
367 {
368 int x, y, val, r, g, b, er, eg, eb;
369 unsigned char *ptr2;
370
371 unsigned short *img;
372 int jmp;
373
374 unsigned char dither[4][4] =
375 {
376 {0, 4, 1, 5},
377 {6, 2, 7, 3},
378 {1, 5, 0, 4},
379 {7, 3, 6, 2}
380 };
381 int dithy, dithx;
382
383 jmp = (xim->bytes_per_line >> 1) - w;
384 img = (unsigned short *)xim->data;
385 for (y = 0; y < h; y++)
386 {
387 dithy = y & 0x3;
388 for (x = 0; x < w; x++)
389 {
390 ptr2 = yarray[y] + xarray[x];
391 r = (int)*ptr2++;
392 g = (int)*ptr2++;
393 b = (int)*ptr2;
394 er = r & 0x07;
395 eg = g & 0x07;
396 eb = b & 0x07;
397 dithx = x & 0x3;
398 if ((dither[dithy][dithx] < er) && (r < (256 - 8)))
399 r += 8;
400 if ((dither[dithy][dithx] < eg) && (g < (256 - 8)))
401 g += 8;
402 if ((dither[dithy][dithx] < eb) && (b < (256 - 8)))
403 b += 8;
404 val = ((r & 0xf8) << 7) | ((g & 0xf8) << 2) | ((b & 0xf8) >> 3);
405 *img++ = val;
406 }
407 img += jmp;
408 }
409 }
410
411 static void
render_shaped_16_fast_dither(ImlibData * id,ImlibImage * im,int w,int h,XImage * xim,XImage * sxim,int * er1,int * er2,int * xarray,unsigned char ** yarray)412 render_shaped_16_fast_dither(ImlibData * id, ImlibImage * im, int w, int h, XImage * xim,
413 XImage * sxim, int *er1, int *er2, int *xarray,
414 unsigned char **yarray)
415 {
416 int x, y, val, r, g, b, *ter, ex, er, eg, eb;
417 unsigned char *ptr2;
418 unsigned short *img;
419 int jmp;
420
421 jmp = (xim->bytes_per_line >> 1) - w;
422 img = (unsigned short *)xim->data;
423 for (y = 0; y < h; y++)
424 {
425 ter = er1;
426 er1 = er2;
427 er2 = ter;
428 for (ex = 0; ex < (w + 2) * 3; ex++)
429 er2[ex] = 0;
430 ex = 3;
431 for (x = 0; x < w; x++)
432 {
433 ptr2 = yarray[y] + xarray[x];
434 r = (int)*ptr2++;
435 g = (int)*ptr2++;
436 b = (int)*ptr2;
437 if ((r == im->shape_color.r) &&
438 (g == im->shape_color.g) &&
439 (b == im->shape_color.b))
440 {
441 XPutPixel(sxim, x, y, 0);
442 img++;
443 ex += 3;
444 }
445 else
446 {
447 XPutPixel(sxim, x, y, 1);
448 er = r + er1[ex++];
449 eg = g + er1[ex++];
450 eb = b + er1[ex++];
451 if (er > 255)
452 er = 255;
453 if (eg > 255)
454 eg = 255;
455 if (eb > 255)
456 eb = 255;
457 val = ((er & 0xf8) << 8) | ((eg & 0xfc) << 3) | ((eb & 0xf8) >> 3);
458 er = er & 0x07;
459 eg = eg & 0x03;
460 eb = eb & 0x07;
461 DITHER_ERROR(er1, er2, ex, er, eg, eb);
462 *img++ = val;
463 }
464 }
465 img += jmp;
466 }
467 }
468
469 #if 0
470 static void
471 render_shaped_16_fast_dither_ordered(ImlibData * id, ImlibImage * im, int w, int h, XImage * xim,
472 XImage * sxim, int *er1, int *er2, int *xarray,
473 unsigned char **yarray)
474 {
475 int x, y, val, r, g, b, er, eg, eb;
476 unsigned char *ptr2;
477 unsigned short *img;
478 int jmp;
479
480 unsigned char dither[4][4] =
481 {
482 {0, 4, 1, 5},
483 {6, 2, 7, 3},
484 {1, 5, 0, 4},
485 {7, 3, 6, 2}
486 };
487 int dithy, dithx;
488
489 jmp = (xim->bytes_per_line >> 1) - w;
490 img = (unsigned short *)xim->data;
491 for (y = 0; y < h; y++)
492 {
493 dithy = y & 0x3;
494 for (x = 0; x < w; x++)
495 {
496 ptr2 = yarray[y] + xarray[x];
497 r = (int)*ptr2++;
498 g = (int)*ptr2++;
499 b = (int)*ptr2;
500 if ((r == im->shape_color.r) &&
501 (g == im->shape_color.g) &&
502 (b == im->shape_color.b))
503 {
504 XPutPixel(sxim, x, y, 0);
505 img++;
506 }
507 else
508 {
509 XPutPixel(sxim, x, y, 1);
510 er = r & 0x07;
511 eg = g & 0x03;
512 eb = b & 0x07;
513 dithx = x & 0x3;
514 if ((dither[dithy][dithx] < er) && (r < (256 - 8)))
515 r += 8;
516 if ((dither[dithy][dithx] < (eg << 1)) && (g < (256 - 4)))
517 g += 4;
518 if ((dither[dithy][dithx] < eb) && (b < (256 - 8)))
519 b += 8;
520 val = ((r & 0xf8) << 8) | ((g & 0xfc) << 3) | ((b & 0xf8) >> 3);
521 *img++ = val;
522 }
523 }
524 img += jmp;
525 }
526 }
527 #endif
528
529 static void
render_16_fast_dither(ImlibData * id,ImlibImage * im,int w,int h,XImage * xim,XImage * sxim,int * er1,int * er2,int * xarray,unsigned char ** yarray)530 render_16_fast_dither(ImlibData * id, ImlibImage * im, int w, int h, XImage * xim,
531 XImage * sxim, int *er1, int *er2, int *xarray,
532 unsigned char **yarray)
533 {
534 int x, y, val, r, g, b, *ter, ex, er, eg, eb;
535 unsigned char *ptr2;
536
537 unsigned short *img;
538 int jmp;
539
540 jmp = (xim->bytes_per_line >> 1) - w;
541 img = (unsigned short *)xim->data;
542 for (y = 0; y < h; y++)
543 {
544 ter = er1;
545 er1 = er2;
546 er2 = ter;
547 for (ex = 0; ex < (w + 2) * 3; ex++)
548 er2[ex] = 0;
549 ex = 3;
550 for (x = 0; x < w; x++)
551 {
552 ptr2 = yarray[y] + xarray[x];
553 r = (int)*ptr2++;
554 g = (int)*ptr2++;
555 b = (int)*ptr2;
556 er = r + er1[ex++];
557 eg = g + er1[ex++];
558 eb = b + er1[ex++];
559 if (er > 255)
560 er = 255;
561 if (eg > 255)
562 eg = 255;
563 if (eb > 255)
564 eb = 255;
565 val = ((er & 0xf8) << 8) | ((eg & 0xfc) << 3) | ((eb & 0xf8) >> 3);
566 er = er & 0x07;
567 eg = eg & 0x03;
568 eb = eb & 0x07;
569 DITHER_ERROR(er1, er2, ex, er, eg, eb);
570 *img++ = val;
571 }
572 img += jmp;
573 }
574 }
575
576 static void
render_16_fast_dither_ordered(ImlibData * id,ImlibImage * im,int w,int h,XImage * xim,XImage * sxim,int * er1,int * er2,int * xarray,unsigned char ** yarray)577 render_16_fast_dither_ordered(ImlibData * id, ImlibImage * im, int w, int h, XImage * xim,
578 XImage * sxim, int *er1, int *er2, int *xarray,
579 unsigned char **yarray)
580 {
581 int x, y, val, r, g, b, er, eg, eb;
582 unsigned char *ptr2;
583
584 unsigned short *img;
585 int jmp;
586
587 unsigned char dither[4][4] =
588 {
589 {0, 4, 1, 5},
590 {6, 2, 7, 3},
591 {1, 5, 0, 4},
592 {7, 3, 6, 2}
593 };
594 int dithy, dithx;
595
596 jmp = (xim->bytes_per_line >> 1) - w;
597 img = (unsigned short *)xim->data;
598 for (y = 0; y < h; y++)
599 {
600 dithy = y & 0x3;
601 for (x = 0; x < w; x++)
602 {
603 ptr2 = yarray[y] + xarray[x];
604 r = (int)*ptr2++;
605 g = (int)*ptr2++;
606 b = (int)*ptr2;
607 er = r & 0x07;
608 eg = g & 0x03;
609 eb = b & 0x07;
610 dithx = x & 0x3;
611 if ((dither[dithy][dithx] < er) && (r < (256 - 8)))
612 r += 8;
613 if ((dither[dithy][dithx] < (eg << 1)) && (g < (256 - 4)))
614 g += 4;
615 if ((dither[dithy][dithx] < eb) && (b < (256 - 8)))
616 b += 8;
617 val = ((r & 0xf8) << 8) | ((g & 0xfc) << 3) | ((b & 0xf8) >> 3);
618 *img++ = val;
619 }
620 img += jmp;
621 }
622 }
623
624 static void
render_shaped_15_dither(ImlibData * id,ImlibImage * im,int w,int h,XImage * xim,XImage * sxim,int * er1,int * er2,int * xarray,unsigned char ** yarray)625 render_shaped_15_dither(ImlibData * id, ImlibImage * im, int w, int h, XImage * xim,
626 XImage * sxim, int *er1, int *er2, int *xarray,
627 unsigned char **yarray)
628 {
629 int x, y, val, r, g, b, *ter, ex, er, eg, eb;
630 unsigned char *ptr2;
631
632 for (y = 0; y < h; y++)
633 {
634 ter = er1;
635 er1 = er2;
636 er2 = ter;
637 for (ex = 0; ex < (w + 2) * 3; ex++)
638 er2[ex] = 0;
639 ex = 3;
640 for (x = 0; x < w; x++)
641 {
642 ptr2 = yarray[y] + xarray[x];
643 r = (int)*ptr2++;
644 g = (int)*ptr2++;
645 b = (int)*ptr2;
646 if ((r == im->shape_color.r) &&
647 (g == im->shape_color.g) &&
648 (b == im->shape_color.b))
649 {
650 XPutPixel(sxim, x, y, 0);
651 ex += 3;
652 }
653 else
654 {
655 XPutPixel(sxim, x, y, 1);
656 er = r + er1[ex++];
657 eg = g + er1[ex++];
658 eb = b + er1[ex++];
659 if (er > 255)
660 er = 255;
661 if (eg > 255)
662 eg = 255;
663 if (eb > 255)
664 eb = 255;
665 val = ((er & 0xf8) << 7) | ((eg & 0xf8) << 2) | ((eb & 0xf8) >> 3);
666 er = er & 0x07;
667 eg = eg & 0x07;
668 eb = eb & 0x07;
669 if (er > 255)
670 er = 255;
671 else if (er < 0)
672 er = 0;
673 if (eg > 255)
674 eg = 255;
675 else if (eg < 0)
676 eg = 0;
677 if (eb > 255)
678 eb = 255;
679 else if (eb < 0)
680 eb = 0;
681 val = ((r & 0xf8) << 7) | ((g & 0xf8) << 2) | ((b & 0xf8) >> 3);
682 er = r & 0x07;
683 eg = g & 0x07;
684 eb = b & 0x07;
685 DITHER_ERROR(er1, er2, ex, er, eg, eb);
686 XPutPixel(xim, x, y, val);
687 }
688 }
689 }
690 }
691
692 #if 0
693 static void
694 render_shaped_15_dither_ordered(ImlibData * id, ImlibImage * im, int w, int h, XImage * xim,
695 XImage * sxim, int *er1, int *er2, int *xarray,
696 unsigned char **yarray)
697 {
698 int x, y, val, r, g, b, er, eg, eb;
699 unsigned char *ptr2;
700
701 unsigned char dither[4][4] =
702 {
703 {0, 4, 6, 5},
704 {6, 2, 7, 3},
705 {2, 6, 1, 5},
706 {7, 4, 7, 3}
707 };
708 int dithy, dithx;
709
710 for (y = 0; y < h; y++)
711 {
712 dithy = y & 0x3;
713 for (x = 0; x < w; x++)
714 {
715 ptr2 = yarray[y] + xarray[x];
716 r = (int)*ptr2++;
717 g = (int)*ptr2++;
718 b = (int)*ptr2;
719 if ((r == im->shape_color.r) &&
720 (g == im->shape_color.g) &&
721 (b == im->shape_color.b))
722 {
723 XPutPixel(sxim, x, y, 0);
724 }
725 else
726 {
727 XPutPixel(sxim, x, y, 1);
728 er = r & 0x07;
729 eg = g & 0x07;
730 eb = b & 0x07;
731 dithx = x & 0x3;
732 if ((dither[dithy][dithx] < er) && (r < (256 - 8)))
733 r += 8;
734 if ((dither[dithy][dithx] < eg) && (g < (256 - 8)))
735 g += 8;
736 if ((dither[dithy][dithx] < eb) && (b < (256 - 8)))
737 b += 8;
738 val = ((r & 0xf8) << 7) | ((g & 0xf8) << 2) | ((b & 0xf8) >> 3);
739 XPutPixel(xim, x, y, val);
740 }
741 }
742 }
743 }
744 #endif
745
746 static void
render_15_dither(ImlibData * id,ImlibImage * im,int w,int h,XImage * xim,XImage * sxim,int * er1,int * er2,int * xarray,unsigned char ** yarray)747 render_15_dither(ImlibData * id, ImlibImage * im, int w, int h, XImage * xim,
748 XImage * sxim, int *er1, int *er2, int *xarray,
749 unsigned char **yarray)
750 {
751 int x, y, val, r, g, b, *ter, ex, er, eg, eb;
752 unsigned char *ptr2;
753
754 for (y = 0; y < h; y++)
755 {
756 ter = er1;
757 er1 = er2;
758 er2 = ter;
759 for (ex = 0; ex < (w + 2) * 3; ex++)
760 er2[ex] = 0;
761 ex = 3;
762 for (x = 0; x < w; x++)
763 {
764 ptr2 = yarray[y] + xarray[x];
765 r = (int)*ptr2++;
766 g = (int)*ptr2++;
767 b = (int)*ptr2;
768 er = r + er1[ex++];
769 eg = g + er1[ex++];
770 eb = b + er1[ex++];
771 if (er > 255)
772 er = 255;
773 if (eg > 255)
774 eg = 255;
775 if (eb > 255)
776 eb = 255;
777 val = ((er & 0xf8) << 7) | ((eg & 0xf8) << 2) | ((eb & 0xf8) >> 3);
778 er = er & 0x07;
779 eg = eg & 0x07;
780 eb = eb & 0x07;
781 DITHER_ERROR(er1, er2, ex, er, eg, eb);
782 XPutPixel(xim, x, y, val);
783 }
784 }
785 }
786
787 static void
render_15_dither_ordered(ImlibData * id,ImlibImage * im,int w,int h,XImage * xim,XImage * sxim,int * er1,int * er2,int * xarray,unsigned char ** yarray)788 render_15_dither_ordered(ImlibData * id, ImlibImage * im, int w, int h, XImage * xim,
789 XImage * sxim, int *er1, int *er2, int *xarray,
790 unsigned char **yarray)
791 {
792 int x, y, val, r, g, b, er, eg, eb;
793 unsigned char *ptr2;
794
795 unsigned char dither[4][4] =
796 {
797 {0, 4, 6, 5},
798 {6, 2, 7, 3},
799 {2, 6, 1, 5},
800 {7, 4, 7, 3}
801 };
802 int dithy, dithx;
803
804 for (y = 0; y < h; y++)
805 {
806 dithy = y & 0x3;
807 for (x = 0; x < w; x++)
808 {
809 ptr2 = yarray[y] + xarray[x];
810 r = (int)*ptr2++;
811 g = (int)*ptr2++;
812 b = (int)*ptr2;
813 er = r & 0x07;
814 eg = g & 0x07;
815 eb = b & 0x07;
816 dithx = x & 0x3;
817 if ((dither[dithy][dithx] < er) && (r < (256 - 8)))
818 r += 8;
819 if ((dither[dithy][dithx] < eg) && (g < (256 - 8)))
820 g += 8;
821 if ((dither[dithy][dithx] < eb) && (b < (256 - 8)))
822 b += 8;
823 val = ((r & 0xf8) << 7) | ((g & 0xf8) << 2) | ((b & 0xf8) >> 3);
824 XPutPixel(xim, x, y, val);
825 }
826 }
827 }
828
829 static void
render_shaped_16_dither(ImlibData * id,ImlibImage * im,int w,int h,XImage * xim,XImage * sxim,int * er1,int * er2,int * xarray,unsigned char ** yarray)830 render_shaped_16_dither(ImlibData * id, ImlibImage * im, int w, int h, XImage * xim,
831 XImage * sxim, int *er1, int *er2, int *xarray,
832 unsigned char **yarray)
833 {
834 int x, y, val, r, g, b, *ter, ex, er, eg, eb;
835 unsigned char *ptr2;
836
837 for (y = 0; y < h; y++)
838 {
839 ter = er1;
840 er1 = er2;
841 er2 = ter;
842 for (ex = 0; ex < (w + 2) * 3; ex++)
843 er2[ex] = 0;
844 ex = 3;
845 for (x = 0; x < w; x++)
846 {
847 ptr2 = yarray[y] + xarray[x];
848 r = (int)*ptr2++;
849 g = (int)*ptr2++;
850 b = (int)*ptr2;
851 if ((r == im->shape_color.r) &&
852 (g == im->shape_color.g) &&
853 (b == im->shape_color.b))
854 {
855 XPutPixel(sxim, x, y, 0);
856 ex += 3;
857 }
858 else
859 {
860 XPutPixel(sxim, x, y, 1);
861 er = r + er1[ex++];
862 eg = g + er1[ex++];
863 eb = b + er1[ex++];
864 if (er > 255)
865 er = 255;
866 if (eg > 255)
867 eg = 255;
868 if (eb > 255)
869 eb = 255;
870 val = ((er & 0xf8) << 8) | ((eg & 0xfc) << 3) | ((eb & 0xf8) >> 3);
871 er = er & 0x07;
872 eg = eg & 0x03;
873 eb = eb & 0x07;
874 DITHER_ERROR(er1, er2, ex, er, eg, eb);
875 XPutPixel(xim, x, y, val);
876 }
877 }
878 }
879 }
880
881 #if 0
882 static void
883 render_shaped_16_dither_ordered(ImlibData * id, ImlibImage * im, int w, int h, XImage * xim,
884 XImage * sxim, int *er1, int *er2, int *xarray,
885 unsigned char **yarray)
886 {
887 int x, y, val, r, g, b, er, eg, eb;
888 unsigned char *ptr2;
889
890 unsigned char dither[4][4] =
891 {
892 {0, 4, 6, 5},
893 {6, 2, 7, 3},
894 {2, 6, 1, 5},
895 {7, 4, 7, 3}
896 };
897 int dithy, dithx;
898
899 for (y = 0; y < h; y++)
900 {
901 dithy = y & 0x3;
902 for (x = 0; x < w; x++)
903 {
904 ptr2 = yarray[y] + xarray[x];
905 r = (int)*ptr2++;
906 g = (int)*ptr2++;
907 b = (int)*ptr2;
908 if ((r == im->shape_color.r) &&
909 (g == im->shape_color.g) &&
910 (b == im->shape_color.b))
911 {
912 XPutPixel(sxim, x, y, 0);
913 }
914 else
915 {
916 XPutPixel(sxim, x, y, 1);
917 er = r & 0x07;
918 eg = g & 0x03;
919 eb = b & 0x07;
920 dithx = x & 0x3;
921 if ((dither[dithy][dithx] < er) && (r < (256 - 8)))
922 r += 8;
923 if ((dither[dithy][dithx] < (eg << 1)) && (g < (256 - 4)))
924 g += 4;
925 if ((dither[dithy][dithx] < eb) && (b < (256 - 8)))
926 b += 8;
927 val = ((r & 0xf8) << 8) | ((g & 0xfc) << 3) | ((b & 0xf8) >> 3);
928 XPutPixel(xim, x, y, val);
929 }
930 }
931 }
932 }
933 #endif
934
935 static void
render_16_dither(ImlibData * id,ImlibImage * im,int w,int h,XImage * xim,XImage * sxim,int * er1,int * er2,int * xarray,unsigned char ** yarray)936 render_16_dither(ImlibData * id, ImlibImage * im, int w, int h, XImage * xim,
937 XImage * sxim, int *er1, int *er2, int *xarray,
938 unsigned char **yarray)
939 {
940 int x, y, val, r, g, b, *ter, ex, er, eg, eb;
941 unsigned char *ptr2;
942
943 for (y = 0; y < h; y++)
944 {
945 ter = er1;
946 er1 = er2;
947 er2 = ter;
948 for (ex = 0; ex < (w + 2) * 3; ex++)
949 er2[ex] = 0;
950 ex = 3;
951 for (x = 0; x < w; x++)
952 {
953 ptr2 = yarray[y] + xarray[x];
954 r = (int)*ptr2++;
955 g = (int)*ptr2++;
956 b = (int)*ptr2;
957 er = r + er1[ex++];
958 eg = g + er1[ex++];
959 eb = b + er1[ex++];
960 if (er > 255)
961 er = 255;
962 if (eg > 255)
963 eg = 255;
964 if (eb > 255)
965 eb = 255;
966 val = ((er & 0xf8) << 8) | ((eg & 0xfc) << 3) | ((eb & 0xf8) >> 3);
967 er = er & 0x07;
968 eg = eg & 0x03;
969 eb = eb & 0x07;
970 DITHER_ERROR(er1, er2, ex, er, eg, eb);
971 XPutPixel(xim, x, y, val);
972 }
973 }
974 }
975
976 static void
render_16_dither_ordered(ImlibData * id,ImlibImage * im,int w,int h,XImage * xim,XImage * sxim,int * er1,int * er2,int * xarray,unsigned char ** yarray)977 render_16_dither_ordered(ImlibData * id, ImlibImage * im, int w, int h, XImage * xim,
978 XImage * sxim, int *er1, int *er2, int *xarray,
979 unsigned char **yarray)
980 {
981 int x, y, val, r, g, b, er, eg, eb;
982 unsigned char *ptr2;
983
984 unsigned char dither[4][4] =
985 {
986 {0, 4, 6, 5},
987 {6, 2, 7, 3},
988 {2, 6, 1, 5},
989 {7, 4, 7, 3}
990 };
991 int dithy, dithx;
992
993 for (y = 0; y < h; y++)
994 {
995 dithy = y & 0x3;
996 for (x = 0; x < w; x++)
997 {
998 ptr2 = yarray[y] + xarray[x];
999 r = (int)*ptr2++;
1000 g = (int)*ptr2++;
1001 b = (int)*ptr2;
1002 er = r & 0x07;
1003 eg = g & 0x03;
1004 eb = b & 0x07;
1005 dithx = x & 0x3;
1006 if ((dither[dithy][dithx] < er) && (r < (256 - 8)))
1007 r += 8;
1008 if ((dither[dithy][dithx] < (eg << 1)) && (g < (256 - 4)))
1009 g += 4;
1010 if ((dither[dithy][dithx] < eb) && (b < (256 - 8)))
1011 b += 8;
1012 val = ((r & 0xf8) << 8) | ((g & 0xfc) << 3) | ((b & 0xf8) >> 3);
1013 XPutPixel(xim, x, y, val);
1014 }
1015 }
1016 }
1017
1018 static void
render_shaped_15_fast(ImlibData * id,ImlibImage * im,int w,int h,XImage * xim,XImage * sxim,int * er1,int * er2,int * xarray,unsigned char ** yarray)1019 render_shaped_15_fast(ImlibData * id, ImlibImage * im, int w, int h, XImage * xim,
1020 XImage * sxim, int *er1, int *er2, int *xarray,
1021 unsigned char **yarray)
1022 {
1023 int x, y, val, r, g, b;
1024 unsigned char *ptr2;
1025 unsigned short *img;
1026 int jmp;
1027
1028 jmp = (xim->bytes_per_line >> 1) - w;
1029 img = (unsigned short *)xim->data;
1030 for (y = 0; y < h; y++)
1031 {
1032 for (x = 0; x < w; x++)
1033 {
1034 ptr2 = yarray[y] + xarray[x];
1035 r = (int)*ptr2++;
1036 g = (int)*ptr2++;
1037 b = (int)*ptr2;
1038 if ((r == im->shape_color.r) &&
1039 (g == im->shape_color.g) &&
1040 (b == im->shape_color.b))
1041 {
1042 XPutPixel(sxim, x, y, 0);
1043 img++;
1044 }
1045 else
1046 {
1047 XPutPixel(sxim, x, y, 1);
1048 val = ((r & 0xf8) << 7) | ((g & 0xf8) << 2) | ((b & 0xf8) >> 3);
1049 *img++ = val;
1050 }
1051 }
1052 img += jmp;
1053 }
1054 }
1055
1056 static void
render_15_fast(ImlibData * id,ImlibImage * im,int w,int h,XImage * xim,XImage * sxim,int * er1,int * er2,int * xarray,unsigned char ** yarray)1057 render_15_fast(ImlibData * id, ImlibImage * im, int w, int h, XImage * xim,
1058 XImage * sxim, int *er1, int *er2, int *xarray,
1059 unsigned char **yarray)
1060 {
1061 int x, y, val, r, g, b;
1062 unsigned char *ptr2;
1063 unsigned short *img;
1064 int jmp;
1065
1066 jmp = (xim->bytes_per_line >> 1) - w;
1067 img = (unsigned short *)xim->data;
1068 for (y = 0; y < h; y++)
1069 {
1070 for (x = 0; x < w; x++)
1071 {
1072 ptr2 = yarray[y] + xarray[x];
1073 r = (int)*ptr2++;
1074 g = (int)*ptr2++;
1075 b = (int)*ptr2;
1076 val = ((r & 0xf8) << 7) | ((g & 0xf8) << 2) | ((b & 0xf8) >> 3);
1077 *img++ = val;
1078 }
1079 img += jmp;
1080 }
1081 }
1082
1083 static void
render_shaped_16_fast(ImlibData * id,ImlibImage * im,int w,int h,XImage * xim,XImage * sxim,int * er1,int * er2,int * xarray,unsigned char ** yarray)1084 render_shaped_16_fast(ImlibData * id, ImlibImage * im, int w, int h, XImage * xim,
1085 XImage * sxim, int *er1, int *er2, int *xarray,
1086 unsigned char **yarray)
1087 {
1088 int x, y, val, r, g, b;
1089 unsigned char *ptr2;
1090 unsigned short *img;
1091 int jmp;
1092
1093 jmp = (xim->bytes_per_line >> 1) - w;
1094 img = (unsigned short *)xim->data;
1095 for (y = 0; y < h; y++)
1096 {
1097 for (x = 0; x < w; x++)
1098 {
1099 ptr2 = yarray[y] + xarray[x];
1100 r = (int)*ptr2++;
1101 g = (int)*ptr2++;
1102 b = (int)*ptr2;
1103 if ((r == im->shape_color.r) &&
1104 (g == im->shape_color.g) &&
1105 (b == im->shape_color.b))
1106 {
1107 XPutPixel(sxim, x, y, 0);
1108 img++;
1109 }
1110 else
1111 {
1112 XPutPixel(sxim, x, y, 1);
1113 val = ((r & 0xf8) << 8) | ((g & 0xfc) << 3) | ((b & 0xf8) >> 3);
1114 *img++ = val;
1115 }
1116 }
1117 img += jmp;
1118 }
1119 }
1120
1121 static void
render_16_fast(ImlibData * id,ImlibImage * im,int w,int h,XImage * xim,XImage * sxim,int * er1,int * er2,int * xarray,unsigned char ** yarray)1122 render_16_fast(ImlibData * id, ImlibImage * im, int w, int h, XImage * xim,
1123 XImage * sxim, int *er1, int *er2, int *xarray,
1124 unsigned char **yarray)
1125 {
1126 int x, y, val, r, g, b;
1127 unsigned char *ptr2;
1128
1129 unsigned short *img;
1130 int jmp;
1131
1132 jmp = (xim->bytes_per_line >> 1) - w;
1133 img = (unsigned short *)xim->data;
1134 for (y = 0; y < h; y++)
1135 {
1136 for (x = 0; x < w; x++)
1137 {
1138 ptr2 = yarray[y] + xarray[x];
1139 r = (int)*ptr2++;
1140 g = (int)*ptr2++;
1141 b = (int)*ptr2;
1142 val = ((r & 0xf8) << 8) | ((g & 0xfc) << 3) | ((b & 0xf8) >> 3);
1143 *img++ = val;
1144 }
1145 img += jmp;
1146 }
1147 }
1148
1149 static void
render_shaped_24_fast(ImlibData * id,ImlibImage * im,int w,int h,XImage * xim,XImage * sxim,int * er1,int * er2,int * xarray,unsigned char ** yarray)1150 render_shaped_24_fast(ImlibData * id, ImlibImage * im, int w, int h, XImage * xim,
1151 XImage * sxim, int *er1, int *er2, int *xarray,
1152 unsigned char **yarray)
1153 {
1154 int x, y, r, g, b;
1155 unsigned char *ptr2;
1156 unsigned char *img;
1157 int jmp;
1158
1159 jmp = (xim->bytes_per_line) - w * 3;
1160 img = (unsigned char *)xim->data;
1161
1162 if (id->x.byte_order == MSBFirst)
1163 {
1164 if (id->byte_order == BYTE_ORD_24_RGB)
1165 {
1166 for (y = 0; y < h; y++)
1167 {
1168 for (x = 0; x < w; x++)
1169 {
1170 ptr2 = yarray[y] + xarray[x];
1171 r = (int)*ptr2++;
1172 g = (int)*ptr2++;
1173 b = (int)*ptr2;
1174 if ((r == im->shape_color.r) &&
1175 (g == im->shape_color.g) &&
1176 (b == im->shape_color.b))
1177 {
1178 XPutPixel(sxim, x, y, 0);
1179 img += 3;
1180 }
1181 else
1182 {
1183 XPutPixel(sxim, x, y, 1);
1184 *img++ = r;
1185 *img++ = g;
1186 *img++ = b;
1187 }
1188 }
1189 img += jmp;
1190 }
1191 }
1192 else if (id->byte_order == BYTE_ORD_24_RBG)
1193 {
1194 for (y = 0; y < h; y++)
1195 {
1196 for (x = 0; x < w; x++)
1197 {
1198 ptr2 = yarray[y] + xarray[x];
1199 r = (int)*ptr2++;
1200 g = (int)*ptr2++;
1201 b = (int)*ptr2;
1202 if ((r == im->shape_color.r) &&
1203 (g == im->shape_color.g) &&
1204 (b == im->shape_color.b))
1205 {
1206 XPutPixel(sxim, x, y, 0);
1207 img += 3;
1208 }
1209 else
1210 {
1211 XPutPixel(sxim, x, y, 1);
1212 *img++ = r;
1213 *img++ = b;
1214 *img++ = g;
1215 }
1216 }
1217 img += jmp;
1218 }
1219 }
1220 else if (id->byte_order == BYTE_ORD_24_BRG)
1221 {
1222 for (y = 0; y < h; y++)
1223 {
1224 for (x = 0; x < w; x++)
1225 {
1226 ptr2 = yarray[y] + xarray[x];
1227 r = (int)*ptr2++;
1228 g = (int)*ptr2++;
1229 b = (int)*ptr2;
1230 if ((r == im->shape_color.r) &&
1231 (g == im->shape_color.g) &&
1232 (b == im->shape_color.b))
1233 {
1234 XPutPixel(sxim, x, y, 0);
1235 img += 3;
1236 }
1237 else
1238 {
1239 XPutPixel(sxim, x, y, 1);
1240 *img++ = b;
1241 *img++ = r;
1242 *img++ = g;
1243 }
1244 }
1245 img += jmp;
1246 }
1247 }
1248 else if (id->byte_order == BYTE_ORD_24_BGR)
1249 {
1250 for (y = 0; y < h; y++)
1251 {
1252 for (x = 0; x < w; x++)
1253 {
1254 ptr2 = yarray[y] + xarray[x];
1255 r = (int)*ptr2++;
1256 g = (int)*ptr2++;
1257 b = (int)*ptr2;
1258 if ((r == im->shape_color.r) &&
1259 (g == im->shape_color.g) &&
1260 (b == im->shape_color.b))
1261 {
1262 XPutPixel(sxim, x, y, 0);
1263 img += 3;
1264 }
1265 else
1266 {
1267 XPutPixel(sxim, x, y, 1);
1268 *img++ = b;
1269 *img++ = g;
1270 *img++ = r;
1271 }
1272 }
1273 img += jmp;
1274 }
1275 }
1276 else if (id->byte_order == BYTE_ORD_24_GRB)
1277 {
1278 for (y = 0; y < h; y++)
1279 {
1280 for (x = 0; x < w; x++)
1281 {
1282 ptr2 = yarray[y] + xarray[x];
1283 r = (int)*ptr2++;
1284 g = (int)*ptr2++;
1285 b = (int)*ptr2;
1286 if ((r == im->shape_color.r) &&
1287 (g == im->shape_color.g) &&
1288 (b == im->shape_color.b))
1289 {
1290 XPutPixel(sxim, x, y, 0);
1291 img += 3;
1292 }
1293 else
1294 {
1295 XPutPixel(sxim, x, y, 1);
1296 *img++ = g;
1297 *img++ = r;
1298 *img++ = b;
1299 }
1300 }
1301 img += jmp;
1302 }
1303 }
1304 else if (id->byte_order == BYTE_ORD_24_GBR)
1305 {
1306 for (y = 0; y < h; y++)
1307 {
1308 for (x = 0; x < w; x++)
1309 {
1310 ptr2 = yarray[y] + xarray[x];
1311 r = (int)*ptr2++;
1312 g = (int)*ptr2++;
1313 b = (int)*ptr2;
1314 if ((r == im->shape_color.r) &&
1315 (g == im->shape_color.g) &&
1316 (b == im->shape_color.b))
1317 {
1318 XPutPixel(sxim, x, y, 0);
1319 img += 3;
1320 }
1321 else
1322 {
1323 XPutPixel(sxim, x, y, 1);
1324 *img++ = g;
1325 *img++ = b;
1326 *img++ = r;
1327 }
1328 }
1329 img += jmp;
1330 }
1331 }
1332 }
1333 else
1334 {
1335 if (id->byte_order == BYTE_ORD_24_RGB)
1336 {
1337 for (y = 0; y < h; y++)
1338 {
1339 for (x = 0; x < w; x++)
1340 {
1341 ptr2 = yarray[y] + xarray[x];
1342 r = (int)*ptr2++;
1343 g = (int)*ptr2++;
1344 b = (int)*ptr2;
1345 if ((r == im->shape_color.r) &&
1346 (g == im->shape_color.g) &&
1347 (b == im->shape_color.b))
1348 {
1349 XPutPixel(sxim, x, y, 0);
1350 img += 3;
1351 }
1352 else
1353 {
1354 XPutPixel(sxim, x, y, 1);
1355 *img++ = b;
1356 *img++ = g;
1357 *img++ = r;
1358 }
1359 }
1360 img += jmp;
1361 }
1362 }
1363 else if (id->byte_order == BYTE_ORD_24_RBG)
1364 {
1365 for (y = 0; y < h; y++)
1366 {
1367 for (x = 0; x < w; x++)
1368 {
1369 ptr2 = yarray[y] + xarray[x];
1370 r = (int)*ptr2++;
1371 g = (int)*ptr2++;
1372 b = (int)*ptr2;
1373 if ((r == im->shape_color.r) &&
1374 (g == im->shape_color.g) &&
1375 (b == im->shape_color.b))
1376 {
1377 XPutPixel(sxim, x, y, 0);
1378 img += 3;
1379 }
1380 else
1381 {
1382 XPutPixel(sxim, x, y, 1);
1383 *img++ = g;
1384 *img++ = b;
1385 *img++ = r;
1386 }
1387 }
1388 img += jmp;
1389 }
1390 }
1391 else if (id->byte_order == BYTE_ORD_24_BRG)
1392 {
1393 for (y = 0; y < h; y++)
1394 {
1395 for (x = 0; x < w; x++)
1396 {
1397 ptr2 = yarray[y] + xarray[x];
1398 r = (int)*ptr2++;
1399 g = (int)*ptr2++;
1400 b = (int)*ptr2;
1401 if ((r == im->shape_color.r) &&
1402 (g == im->shape_color.g) &&
1403 (b == im->shape_color.b))
1404 {
1405 XPutPixel(sxim, x, y, 0);
1406 img += 3;
1407 }
1408 else
1409 {
1410 XPutPixel(sxim, x, y, 1);
1411 *img++ = g;
1412 *img++ = r;
1413 *img++ = b;
1414 }
1415 }
1416 img += jmp;
1417 }
1418 }
1419 else if (id->byte_order == BYTE_ORD_24_BGR)
1420 {
1421 for (y = 0; y < h; y++)
1422 {
1423 for (x = 0; x < w; x++)
1424 {
1425 ptr2 = yarray[y] + xarray[x];
1426 r = (int)*ptr2++;
1427 g = (int)*ptr2++;
1428 b = (int)*ptr2;
1429 if ((r == im->shape_color.r) &&
1430 (g == im->shape_color.g) &&
1431 (b == im->shape_color.b))
1432 {
1433 XPutPixel(sxim, x, y, 0);
1434 img += 3;
1435 }
1436 else
1437 {
1438 XPutPixel(sxim, x, y, 1);
1439 *img++ = r;
1440 *img++ = g;
1441 *img++ = b;
1442 }
1443 }
1444 img += jmp;
1445 }
1446 }
1447 else if (id->byte_order == BYTE_ORD_24_GRB)
1448 {
1449 for (y = 0; y < h; y++)
1450 {
1451 for (x = 0; x < w; x++)
1452 {
1453 ptr2 = yarray[y] + xarray[x];
1454 r = (int)*ptr2++;
1455 g = (int)*ptr2++;
1456 b = (int)*ptr2;
1457 if ((r == im->shape_color.r) &&
1458 (g == im->shape_color.g) &&
1459 (b == im->shape_color.b))
1460 {
1461 XPutPixel(sxim, x, y, 0);
1462 img += 3;
1463 }
1464 else
1465 {
1466 XPutPixel(sxim, x, y, 1);
1467 *img++ = b;
1468 *img++ = r;
1469 *img++ = g;
1470 }
1471 }
1472 img += jmp;
1473 }
1474 }
1475 else if (id->byte_order == BYTE_ORD_24_GBR)
1476 {
1477 for (y = 0; y < h; y++)
1478 {
1479 for (x = 0; x < w; x++)
1480 {
1481 ptr2 = yarray[y] + xarray[x];
1482 r = (int)*ptr2++;
1483 g = (int)*ptr2++;
1484 b = (int)*ptr2;
1485 if ((r == im->shape_color.r) &&
1486 (g == im->shape_color.g) &&
1487 (b == im->shape_color.b))
1488 {
1489 XPutPixel(sxim, x, y, 0);
1490 img += 3;
1491 }
1492 else
1493 {
1494 XPutPixel(sxim, x, y, 1);
1495 *img++ = r;
1496 *img++ = b;
1497 *img++ = g;
1498 }
1499 }
1500 img += jmp;
1501 }
1502 }
1503 }
1504 }
1505
1506 static void
render_24_fast(ImlibData * id,ImlibImage * im,int w,int h,XImage * xim,XImage * sxim,int * er1,int * er2,int * xarray,unsigned char ** yarray)1507 render_24_fast(ImlibData * id, ImlibImage * im, int w, int h, XImage * xim,
1508 XImage * sxim, int *er1, int *er2, int *xarray,
1509 unsigned char **yarray)
1510 {
1511 int x, y, r, g, b;
1512 unsigned char *ptr2;
1513 unsigned char *img;
1514 int jmp;
1515
1516 jmp = (xim->bytes_per_line) - w * 3;
1517 img = (unsigned char *)xim->data;
1518 if (id->x.byte_order == MSBFirst)
1519 {
1520 if (id->byte_order == BYTE_ORD_24_RGB)
1521 {
1522 for (y = 0; y < h; y++)
1523 {
1524 for (x = 0; x < w; x++)
1525 {
1526 ptr2 = yarray[y] + xarray[x];
1527 r = (int)*ptr2++;
1528 g = (int)*ptr2++;
1529 b = (int)*ptr2;
1530 *img++ = r;
1531 *img++ = g;
1532 *img++ = b;
1533 }
1534 img += jmp;
1535 }
1536 }
1537 else if (id->byte_order == BYTE_ORD_24_RBG)
1538 {
1539 for (y = 0; y < h; y++)
1540 {
1541 for (x = 0; x < w; x++)
1542 {
1543 ptr2 = yarray[y] + xarray[x];
1544 r = (int)*ptr2++;
1545 g = (int)*ptr2++;
1546 b = (int)*ptr2;
1547 *img++ = r;
1548 *img++ = b;
1549 *img++ = g;
1550 }
1551 img += jmp;
1552 }
1553 }
1554 else if (id->byte_order == BYTE_ORD_24_BRG)
1555 {
1556 for (y = 0; y < h; y++)
1557 {
1558 for (x = 0; x < w; x++)
1559 {
1560 ptr2 = yarray[y] + xarray[x];
1561 r = (int)*ptr2++;
1562 g = (int)*ptr2++;
1563 b = (int)*ptr2;
1564 *img++ = b;
1565 *img++ = r;
1566 *img++ = g;
1567 }
1568 img += jmp;
1569 }
1570 }
1571 else if (id->byte_order == BYTE_ORD_24_BGR)
1572 {
1573 for (y = 0; y < h; y++)
1574 {
1575 for (x = 0; x < w; x++)
1576 {
1577 ptr2 = yarray[y] + xarray[x];
1578 r = (int)*ptr2++;
1579 g = (int)*ptr2++;
1580 b = (int)*ptr2;
1581 *img++ = b;
1582 *img++ = g;
1583 *img++ = r;
1584 }
1585 img += jmp;
1586 }
1587 }
1588 else if (id->byte_order == BYTE_ORD_24_GRB)
1589 {
1590 for (y = 0; y < h; y++)
1591 {
1592 for (x = 0; x < w; x++)
1593 {
1594 ptr2 = yarray[y] + xarray[x];
1595 r = (int)*ptr2++;
1596 g = (int)*ptr2++;
1597 b = (int)*ptr2;
1598 *img++ = g;
1599 *img++ = r;
1600 *img++ = b;
1601 }
1602 img += jmp;
1603 }
1604 }
1605 else if (id->byte_order == BYTE_ORD_24_GBR)
1606 {
1607 for (y = 0; y < h; y++)
1608 {
1609 for (x = 0; x < w; x++)
1610 {
1611 ptr2 = yarray[y] + xarray[x];
1612 r = (int)*ptr2++;
1613 g = (int)*ptr2++;
1614 b = (int)*ptr2;
1615 *img++ = g;
1616 *img++ = b;
1617 *img++ = r;
1618 }
1619 img += jmp;
1620 }
1621 }
1622 }
1623 else
1624 {
1625 if (id->byte_order == BYTE_ORD_24_RGB)
1626 {
1627 for (y = 0; y < h; y++)
1628 {
1629 for (x = 0; x < w; x++)
1630 {
1631 ptr2 = yarray[y] + xarray[x];
1632 r = (int)*ptr2++;
1633 g = (int)*ptr2++;
1634 b = (int)*ptr2;
1635 *img++ = b;
1636 *img++ = g;
1637 *img++ = r;
1638 }
1639 img += jmp;
1640 }
1641 }
1642 else if (id->byte_order == BYTE_ORD_24_RBG)
1643 {
1644 for (y = 0; y < h; y++)
1645 {
1646 for (x = 0; x < w; x++)
1647 {
1648 ptr2 = yarray[y] + xarray[x];
1649 r = (int)*ptr2++;
1650 g = (int)*ptr2++;
1651 b = (int)*ptr2;
1652 *img++ = g;
1653 *img++ = b;
1654 *img++ = r;
1655 }
1656 img += jmp;
1657 }
1658 }
1659 else if (id->byte_order == BYTE_ORD_24_BRG)
1660 {
1661 for (y = 0; y < h; y++)
1662 {
1663 for (x = 0; x < w; x++)
1664 {
1665 ptr2 = yarray[y] + xarray[x];
1666 r = (int)*ptr2++;
1667 g = (int)*ptr2++;
1668 b = (int)*ptr2;
1669 *img++ = g;
1670 *img++ = r;
1671 *img++ = b;
1672 }
1673 img += jmp;
1674 }
1675 }
1676 else if (id->byte_order == BYTE_ORD_24_BGR)
1677 {
1678 for (y = 0; y < h; y++)
1679 {
1680 for (x = 0; x < w; x++)
1681 {
1682 ptr2 = yarray[y] + xarray[x];
1683 r = (int)*ptr2++;
1684 g = (int)*ptr2++;
1685 b = (int)*ptr2;
1686 *img++ = r;
1687 *img++ = g;
1688 *img++ = b;
1689 }
1690 img += jmp;
1691 }
1692 }
1693 else if (id->byte_order == BYTE_ORD_24_GRB)
1694 {
1695 for (y = 0; y < h; y++)
1696 {
1697 for (x = 0; x < w; x++)
1698 {
1699 ptr2 = yarray[y] + xarray[x];
1700 r = (int)*ptr2++;
1701 g = (int)*ptr2++;
1702 b = (int)*ptr2;
1703 *img++ = b;
1704 *img++ = r;
1705 *img++ = g;
1706 }
1707 img += jmp;
1708 }
1709 }
1710 else if (id->byte_order == BYTE_ORD_24_GBR)
1711 {
1712 for (y = 0; y < h; y++)
1713 {
1714 for (x = 0; x < w; x++)
1715 {
1716 ptr2 = yarray[y] + xarray[x];
1717 r = (int)*ptr2++;
1718 g = (int)*ptr2++;
1719 b = (int)*ptr2;
1720 *img++ = r;
1721 *img++ = b;
1722 *img++ = g;
1723 }
1724 img += jmp;
1725 }
1726 }
1727 }
1728 }
1729
1730 static void
render_shaped_32_fast(ImlibData * id,ImlibImage * im,int w,int h,XImage * xim,XImage * sxim,int * er1,int * er2,int * xarray,unsigned char ** yarray)1731 render_shaped_32_fast(ImlibData * id, ImlibImage * im, int w, int h, XImage * xim,
1732 XImage * sxim, int *er1, int *er2, int *xarray,
1733 unsigned char **yarray)
1734 {
1735 int x, y, val, r, g, b;
1736 unsigned char *ptr2;
1737 unsigned int *img;
1738 int jmp;
1739
1740 jmp = (xim->bytes_per_line >> 2) - w;
1741 img = (unsigned int *)xim->data;
1742 if (id->byte_order == BYTE_ORD_24_RGB)
1743 {
1744 for (y = 0; y < h; y++)
1745 {
1746 for (x = 0; x < w; x++)
1747 {
1748 ptr2 = yarray[y] + xarray[x];
1749 r = (int)*ptr2++;
1750 g = (int)*ptr2++;
1751 b = (int)*ptr2;
1752 if ((r == im->shape_color.r) &&
1753 (g == im->shape_color.g) &&
1754 (b == im->shape_color.b))
1755 {
1756 XPutPixel(sxim, x, y, 0);
1757 img++;
1758 }
1759 else
1760 {
1761 XPutPixel(sxim, x, y, 1);
1762 val = (r << 16) | (g << 8) | b;
1763 *img++ = val;
1764 }
1765 }
1766 img += jmp;
1767 }
1768 }
1769 else if (id->byte_order == BYTE_ORD_24_RBG)
1770 {
1771 for (y = 0; y < h; y++)
1772 {
1773 for (x = 0; x < w; x++)
1774 {
1775 ptr2 = yarray[y] + xarray[x];
1776 r = (int)*ptr2++;
1777 g = (int)*ptr2++;
1778 b = (int)*ptr2;
1779 if ((r == im->shape_color.r) &&
1780 (g == im->shape_color.g) &&
1781 (b == im->shape_color.b))
1782 {
1783 XPutPixel(sxim, x, y, 0);
1784 img++;
1785 }
1786 else
1787 {
1788 XPutPixel(sxim, x, y, 1);
1789 val = (r << 16) | (b << 8) | g;
1790 *img++ = val;
1791 }
1792 }
1793 img += jmp;
1794 }
1795 }
1796 else if (id->byte_order == BYTE_ORD_24_BRG)
1797 {
1798 for (y = 0; y < h; y++)
1799 {
1800 for (x = 0; x < w; x++)
1801 {
1802 ptr2 = yarray[y] + xarray[x];
1803 r = (int)*ptr2++;
1804 g = (int)*ptr2++;
1805 b = (int)*ptr2;
1806 if ((r == im->shape_color.r) &&
1807 (g == im->shape_color.g) &&
1808 (b == im->shape_color.b))
1809 {
1810 XPutPixel(sxim, x, y, 0);
1811 img++;
1812 }
1813 else
1814 {
1815 XPutPixel(sxim, x, y, 1);
1816 val = (b << 16) | (r << 8) | g;
1817 *img++ = val;
1818 }
1819 }
1820 img += jmp;
1821 }
1822 }
1823 else if (id->byte_order == BYTE_ORD_24_BGR)
1824 {
1825 for (y = 0; y < h; y++)
1826 {
1827 for (x = 0; x < w; x++)
1828 {
1829 ptr2 = yarray[y] + xarray[x];
1830 r = (int)*ptr2++;
1831 g = (int)*ptr2++;
1832 b = (int)*ptr2;
1833 if ((r == im->shape_color.r) &&
1834 (g == im->shape_color.g) &&
1835 (b == im->shape_color.b))
1836 {
1837 XPutPixel(sxim, x, y, 0);
1838 img++;
1839 }
1840 else
1841 {
1842 XPutPixel(sxim, x, y, 1);
1843 val = (b << 16) | (g << 8) | r;
1844 *img++ = val;
1845 }
1846 }
1847 img += jmp;
1848 }
1849 }
1850 else if (id->byte_order == BYTE_ORD_24_GRB)
1851 {
1852 for (y = 0; y < h; y++)
1853 {
1854 for (x = 0; x < w; x++)
1855 {
1856 ptr2 = yarray[y] + xarray[x];
1857 r = (int)*ptr2++;
1858 g = (int)*ptr2++;
1859 b = (int)*ptr2;
1860 if ((r == im->shape_color.r) &&
1861 (g == im->shape_color.g) &&
1862 (b == im->shape_color.b))
1863 {
1864 XPutPixel(sxim, x, y, 0);
1865 img++;
1866 }
1867 else
1868 {
1869 XPutPixel(sxim, x, y, 1);
1870 val = (g << 16) | (r << 8) | b;
1871 *img++ = val;
1872 }
1873 }
1874 img += jmp;
1875 }
1876 }
1877 else if (id->byte_order == BYTE_ORD_24_GBR)
1878 {
1879 for (y = 0; y < h; y++)
1880 {
1881 for (x = 0; x < w; x++)
1882 {
1883 ptr2 = yarray[y] + xarray[x];
1884 r = (int)*ptr2++;
1885 g = (int)*ptr2++;
1886 b = (int)*ptr2;
1887 if ((r == im->shape_color.r) &&
1888 (g == im->shape_color.g) &&
1889 (b == im->shape_color.b))
1890 {
1891 XPutPixel(sxim, x, y, 0);
1892 img++;
1893 }
1894 else
1895 {
1896 XPutPixel(sxim, x, y, 1);
1897 val = (g << 16) | (b << 8) | r;
1898 *img++ = val;
1899 }
1900 }
1901 img += jmp;
1902 }
1903 }
1904 }
1905
1906 static void
render_32_fast(ImlibData * id,ImlibImage * im,int w,int h,XImage * xim,XImage * sxim,int * er1,int * er2,int * xarray,unsigned char ** yarray)1907 render_32_fast(ImlibData * id, ImlibImage * im, int w, int h, XImage * xim,
1908 XImage * sxim, int *er1, int *er2, int *xarray,
1909 unsigned char **yarray)
1910 {
1911 int x, y, val, r, g, b;
1912 unsigned char *ptr2;
1913 unsigned int *img;
1914 int jmp;
1915
1916 jmp = (xim->bytes_per_line >> 2) - w;
1917 img = (unsigned int *)xim->data;
1918 if (id->byte_order == BYTE_ORD_24_RGB)
1919 {
1920 for (y = 0; y < h; y++)
1921 {
1922 for (x = 0; x < w; x++)
1923 {
1924 ptr2 = yarray[y] + xarray[x];
1925 r = (int)*ptr2++;
1926 g = (int)*ptr2++;
1927 b = (int)*ptr2;
1928 val = (r << 16) | (g << 8) | b;
1929 *img++ = val;
1930 }
1931 img += jmp;
1932 }
1933 }
1934 else if (id->byte_order == BYTE_ORD_24_RBG)
1935 {
1936 for (y = 0; y < h; y++)
1937 {
1938 for (x = 0; x < w; x++)
1939 {
1940 ptr2 = yarray[y] + xarray[x];
1941 r = (int)*ptr2++;
1942 g = (int)*ptr2++;
1943 b = (int)*ptr2;
1944 val = (r << 16) | (b << 8) | g;
1945 *img++ = val;
1946 }
1947 img += jmp;
1948 }
1949 }
1950 else if (id->byte_order == BYTE_ORD_24_BRG)
1951 {
1952 for (y = 0; y < h; y++)
1953 {
1954 for (x = 0; x < w; x++)
1955 {
1956 ptr2 = yarray[y] + xarray[x];
1957 r = (int)*ptr2++;
1958 g = (int)*ptr2++;
1959 b = (int)*ptr2;
1960 val = (b << 16) | (r << 8) | g;
1961 *img++ = val;
1962 }
1963 img += jmp;
1964 }
1965 }
1966 else if (id->byte_order == BYTE_ORD_24_BGR)
1967 {
1968 for (y = 0; y < h; y++)
1969 {
1970 for (x = 0; x < w; x++)
1971 {
1972 ptr2 = yarray[y] + xarray[x];
1973 r = (int)*ptr2++;
1974 g = (int)*ptr2++;
1975 b = (int)*ptr2;
1976 val = (b << 16) | (g << 8) | r;
1977 *img++ = val;
1978 }
1979 img += jmp;
1980 }
1981 }
1982 else if (id->byte_order == BYTE_ORD_24_GRB)
1983 {
1984 for (y = 0; y < h; y++)
1985 {
1986 for (x = 0; x < w; x++)
1987 {
1988 ptr2 = yarray[y] + xarray[x];
1989 r = (int)*ptr2++;
1990 g = (int)*ptr2++;
1991 b = (int)*ptr2;
1992 val = (g << 16) | (r << 8) | b;
1993 *img++ = val;
1994 }
1995 img += jmp;
1996 }
1997 }
1998 else if (id->byte_order == BYTE_ORD_24_GBR)
1999 {
2000 for (y = 0; y < h; y++)
2001 {
2002 for (x = 0; x < w; x++)
2003 {
2004 ptr2 = yarray[y] + xarray[x];
2005 r = (int)*ptr2++;
2006 g = (int)*ptr2++;
2007 b = (int)*ptr2;
2008 val = (g << 16) | (b << 8) | r;
2009 *img++ = val;
2010 }
2011 img += jmp;
2012 }
2013 }
2014 }
2015
2016 static void
render_shaped_15(ImlibData * id,ImlibImage * im,int w,int h,XImage * xim,XImage * sxim,int * er1,int * er2,int * xarray,unsigned char ** yarray)2017 render_shaped_15(ImlibData * id, ImlibImage * im, int w, int h, XImage * xim,
2018 XImage * sxim, int *er1, int *er2, int *xarray,
2019 unsigned char **yarray)
2020 {
2021 int x, y, val, r, g, b;
2022 unsigned char *ptr2;
2023
2024 for (y = 0; y < h; y++)
2025 {
2026 for (x = 0; x < w; x++)
2027 {
2028 ptr2 = yarray[y] + xarray[x];
2029 r = (int)*ptr2++;
2030 g = (int)*ptr2++;
2031 b = (int)*ptr2;
2032 if ((r == im->shape_color.r) &&
2033 (g == im->shape_color.g) &&
2034 (b == im->shape_color.b))
2035 XPutPixel(sxim, x, y, 0);
2036 else
2037 {
2038 XPutPixel(sxim, x, y, 1);
2039 val = ((r & 0xf8) << 7) | ((g & 0xf8) << 2) | ((b & 0xf8) >> 3);
2040 XPutPixel(xim, x, y, val);
2041 }
2042 }
2043 }
2044 }
2045
2046 static void
render_15(ImlibData * id,ImlibImage * im,int w,int h,XImage * xim,XImage * sxim,int * er1,int * er2,int * xarray,unsigned char ** yarray)2047 render_15(ImlibData * id, ImlibImage * im, int w, int h, XImage * xim,
2048 XImage * sxim, int *er1, int *er2, int *xarray,
2049 unsigned char **yarray)
2050 {
2051 int x, y, val, r, g, b;
2052 unsigned char *ptr2;
2053
2054 for (y = 0; y < h; y++)
2055 {
2056 for (x = 0; x < w; x++)
2057 {
2058 ptr2 = yarray[y] + xarray[x];
2059 r = (int)*ptr2++;
2060 g = (int)*ptr2++;
2061 b = (int)*ptr2;
2062 val = ((r & 0xf8) << 7) | ((g & 0xf8) << 2) | ((b & 0xf8) >> 3);
2063 XPutPixel(xim, x, y, val);
2064 }
2065 }
2066 }
2067
2068 static void
render_shaped_16(ImlibData * id,ImlibImage * im,int w,int h,XImage * xim,XImage * sxim,int * er1,int * er2,int * xarray,unsigned char ** yarray)2069 render_shaped_16(ImlibData * id, ImlibImage * im, int w, int h, XImage * xim,
2070 XImage * sxim, int *er1, int *er2, int *xarray,
2071 unsigned char **yarray)
2072 {
2073 int x, y, val, r, g, b;
2074 unsigned char *ptr2;
2075
2076 for (y = 0; y < h; y++)
2077 {
2078 for (x = 0; x < w; x++)
2079 {
2080 ptr2 = yarray[y] + xarray[x];
2081 r = (int)*ptr2++;
2082 g = (int)*ptr2++;
2083 b = (int)*ptr2;
2084 if ((r == im->shape_color.r) &&
2085 (g == im->shape_color.g) &&
2086 (b == im->shape_color.b))
2087 XPutPixel(sxim, x, y, 0);
2088 else
2089 {
2090 XPutPixel(sxim, x, y, 1);
2091 val = ((r & 0xf8) << 8) | ((g & 0xfc) << 3) | ((b & 0xf8) >> 3);
2092 XPutPixel(xim, x, y, val);
2093 }
2094 }
2095 }
2096 }
2097
2098 static void
render_16(ImlibData * id,ImlibImage * im,int w,int h,XImage * xim,XImage * sxim,int * er1,int * er2,int * xarray,unsigned char ** yarray)2099 render_16(ImlibData * id, ImlibImage * im, int w, int h, XImage * xim,
2100 XImage * sxim, int *er1, int *er2, int *xarray,
2101 unsigned char **yarray)
2102 {
2103 int x, y, val, r, g, b;
2104 unsigned char *ptr2;
2105
2106 for (y = 0; y < h; y++)
2107 {
2108 for (x = 0; x < w; x++)
2109 {
2110 ptr2 = yarray[y] + xarray[x];
2111 r = (int)*ptr2++;
2112 g = (int)*ptr2++;
2113 b = (int)*ptr2;
2114 val = ((r & 0xf8) << 8) | ((g & 0xfc) << 3) | ((b & 0xf8) >> 3);
2115 XPutPixel(xim, x, y, val);
2116 }
2117 }
2118 }
2119
2120 static void
render_shaped_24(ImlibData * id,ImlibImage * im,int w,int h,XImage * xim,XImage * sxim,int * er1,int * er2,int * xarray,unsigned char ** yarray)2121 render_shaped_24(ImlibData * id, ImlibImage * im, int w, int h, XImage * xim,
2122 XImage * sxim, int *er1, int *er2, int *xarray,
2123 unsigned char **yarray)
2124 {
2125 int x, y, val, r, g, b;
2126 unsigned char *ptr2;
2127
2128 if (id->byte_order == BYTE_ORD_24_RGB)
2129 {
2130 for (y = 0; y < h; y++)
2131 {
2132 for (x = 0; x < w; x++)
2133 {
2134 ptr2 = yarray[y] + xarray[x];
2135 r = (int)*ptr2++;
2136 g = (int)*ptr2++;
2137 b = (int)*ptr2;
2138 if ((r == im->shape_color.r) &&
2139 (g == im->shape_color.g) &&
2140 (b == im->shape_color.b))
2141 XPutPixel(sxim, x, y, 0);
2142 else
2143 {
2144 XPutPixel(sxim, x, y, 1);
2145 val = (r << 16) | (g << 8) | b;
2146 XPutPixel(xim, x, y, val);
2147 }
2148 }
2149 }
2150 }
2151 else if (id->byte_order == BYTE_ORD_24_RBG)
2152 {
2153 for (y = 0; y < h; y++)
2154 {
2155 for (x = 0; x < w; x++)
2156 {
2157 ptr2 = yarray[y] + xarray[x];
2158 r = (int)*ptr2++;
2159 g = (int)*ptr2++;
2160 b = (int)*ptr2;
2161 if ((r == im->shape_color.r) &&
2162 (g == im->shape_color.g) &&
2163 (b == im->shape_color.b))
2164 XPutPixel(sxim, x, y, 0);
2165 else
2166 {
2167 XPutPixel(sxim, x, y, 1);
2168 val = (r << 16) | (b << 8) | g;
2169 XPutPixel(xim, x, y, val);
2170 }
2171 }
2172 }
2173 }
2174 else if (id->byte_order == BYTE_ORD_24_BRG)
2175 {
2176 for (y = 0; y < h; y++)
2177 {
2178 for (x = 0; x < w; x++)
2179 {
2180 ptr2 = yarray[y] + xarray[x];
2181 r = (int)*ptr2++;
2182 g = (int)*ptr2++;
2183 b = (int)*ptr2;
2184 if ((r == im->shape_color.r) &&
2185 (g == im->shape_color.g) &&
2186 (b == im->shape_color.b))
2187 XPutPixel(sxim, x, y, 0);
2188 else
2189 {
2190 XPutPixel(sxim, x, y, 1);
2191 val = (b << 16) | (r << 8) | g;
2192 XPutPixel(xim, x, y, val);
2193 }
2194 }
2195 }
2196 }
2197 else if (id->byte_order == BYTE_ORD_24_BGR)
2198 {
2199 for (y = 0; y < h; y++)
2200 {
2201 for (x = 0; x < w; x++)
2202 {
2203 ptr2 = yarray[y] + xarray[x];
2204 r = (int)*ptr2++;
2205 g = (int)*ptr2++;
2206 b = (int)*ptr2;
2207 if ((r == im->shape_color.r) &&
2208 (g == im->shape_color.g) &&
2209 (b == im->shape_color.b))
2210 XPutPixel(sxim, x, y, 0);
2211 else
2212 {
2213 XPutPixel(sxim, x, y, 1);
2214 val = (b << 16) | (g << 8) | r;
2215 XPutPixel(xim, x, y, val);
2216 }
2217 }
2218 }
2219 }
2220 else if (id->byte_order == BYTE_ORD_24_GRB)
2221 {
2222 for (y = 0; y < h; y++)
2223 {
2224 for (x = 0; x < w; x++)
2225 {
2226 ptr2 = yarray[y] + xarray[x];
2227 r = (int)*ptr2++;
2228 g = (int)*ptr2++;
2229 b = (int)*ptr2;
2230 if ((r == im->shape_color.r) &&
2231 (g == im->shape_color.g) &&
2232 (b == im->shape_color.b))
2233 XPutPixel(sxim, x, y, 0);
2234 else
2235 {
2236 XPutPixel(sxim, x, y, 1);
2237 val = (g << 16) | (r << 8) | b;
2238 XPutPixel(xim, x, y, val);
2239 }
2240 }
2241 }
2242 }
2243 else if (id->byte_order == BYTE_ORD_24_GBR)
2244 {
2245 for (y = 0; y < h; y++)
2246 {
2247 for (x = 0; x < w; x++)
2248 {
2249 ptr2 = yarray[y] + xarray[x];
2250 r = (int)*ptr2++;
2251 g = (int)*ptr2++;
2252 b = (int)*ptr2;
2253 if ((r == im->shape_color.r) &&
2254 (g == im->shape_color.g) &&
2255 (b == im->shape_color.b))
2256 XPutPixel(sxim, x, y, 0);
2257 else
2258 {
2259 XPutPixel(sxim, x, y, 1);
2260 val = (g << 16) | (b << 8) | r;
2261 XPutPixel(xim, x, y, val);
2262 }
2263 }
2264 }
2265 }
2266 }
2267
2268 static void
render_24(ImlibData * id,ImlibImage * im,int w,int h,XImage * xim,XImage * sxim,int * er1,int * er2,int * xarray,unsigned char ** yarray)2269 render_24(ImlibData * id, ImlibImage * im, int w, int h, XImage * xim,
2270 XImage * sxim, int *er1, int *er2, int *xarray,
2271 unsigned char **yarray)
2272 {
2273 int x, y, val, r, g, b;
2274 unsigned char *ptr2;
2275
2276 if (id->byte_order == BYTE_ORD_24_RGB)
2277 {
2278 for (y = 0; y < h; y++)
2279 {
2280 for (x = 0; x < w; x++)
2281 {
2282 ptr2 = yarray[y] + xarray[x];
2283 r = (int)*ptr2++;
2284 g = (int)*ptr2++;
2285 b = (int)*ptr2;
2286 val = (r << 16) | (g << 8) | b;
2287 XPutPixel(xim, x, y, val);
2288 }
2289 }
2290 }
2291 else if (id->byte_order == BYTE_ORD_24_RBG)
2292 {
2293 for (y = 0; y < h; y++)
2294 {
2295 for (x = 0; x < w; x++)
2296 {
2297 ptr2 = yarray[y] + xarray[x];
2298 r = (int)*ptr2++;
2299 g = (int)*ptr2++;
2300 b = (int)*ptr2;
2301 val = (r << 16) | (b << 8) | g;
2302 XPutPixel(xim, x, y, val);
2303 }
2304 }
2305 }
2306 else if (id->byte_order == BYTE_ORD_24_BRG)
2307 {
2308 for (y = 0; y < h; y++)
2309 {
2310 for (x = 0; x < w; x++)
2311 {
2312 ptr2 = yarray[y] + xarray[x];
2313 r = (int)*ptr2++;
2314 g = (int)*ptr2++;
2315 b = (int)*ptr2;
2316 val = (b << 16) | (r << 8) | g;
2317 XPutPixel(xim, x, y, val);
2318 }
2319 }
2320 }
2321 else if (id->byte_order == BYTE_ORD_24_BGR)
2322 {
2323 for (y = 0; y < h; y++)
2324 {
2325 for (x = 0; x < w; x++)
2326 {
2327 ptr2 = yarray[y] + xarray[x];
2328 r = (int)*ptr2++;
2329 g = (int)*ptr2++;
2330 b = (int)*ptr2;
2331 val = (b << 16) | (g << 8) | r;
2332 XPutPixel(xim, x, y, val);
2333 }
2334 }
2335 }
2336 else if (id->byte_order == BYTE_ORD_24_GRB)
2337 {
2338 for (y = 0; y < h; y++)
2339 {
2340 for (x = 0; x < w; x++)
2341 {
2342 ptr2 = yarray[y] + xarray[x];
2343 r = (int)*ptr2++;
2344 g = (int)*ptr2++;
2345 b = (int)*ptr2;
2346 val = (g << 16) | (r << 8) | b;
2347 XPutPixel(xim, x, y, val);
2348 }
2349 }
2350 }
2351 else if (id->byte_order == BYTE_ORD_24_GBR)
2352 {
2353 for (y = 0; y < h; y++)
2354 {
2355 for (x = 0; x < w; x++)
2356 {
2357 ptr2 = yarray[y] + xarray[x];
2358 r = (int)*ptr2++;
2359 g = (int)*ptr2++;
2360 b = (int)*ptr2;
2361 val = (g << 16) | (b << 8) | r;
2362 XPutPixel(xim, x, y, val);
2363 }
2364 }
2365 }
2366 }
2367
2368 static void
render_shaped(ImlibData * id,ImlibImage * im,int w,int h,XImage * xim,XImage * sxim,int * er1,int * er2,int * xarray,unsigned char ** yarray,int bpp)2369 render_shaped(ImlibData * id, ImlibImage * im, int w, int h, XImage * xim,
2370 XImage * sxim, int *er1, int *er2, int *xarray,
2371 unsigned char **yarray, int bpp)
2372 {
2373 int x, y, val, r, g, b, *ter, ex, er, eg, eb;
2374 unsigned char *ptr2;
2375 unsigned char *img;
2376 int jmp;
2377
2378 jmp = (xim->bytes_per_line) - w * (bpp >> 3);
2379 img = (unsigned char *)xim->data;
2380 switch (id->render_type)
2381 {
2382 case RT_PLAIN_PALETTE:
2383 if ((id->fastrend) && (xim->bits_per_pixel == 8))
2384 {
2385 for (y = 0; y < h; y++)
2386 {
2387 for (x = 0; x < w; x++)
2388 {
2389 ptr2 = yarray[y] + xarray[x];
2390 r = (int)*ptr2++;
2391 g = (int)*ptr2++;
2392 b = (int)*ptr2;
2393 if ((r == im->shape_color.r) &&
2394 (g == im->shape_color.g) &&
2395 (b == im->shape_color.b))
2396 {
2397 XPutPixel(sxim, x, y, 0);
2398 img++;
2399 }
2400 else
2401 {
2402 XPutPixel(sxim, x, y, 1);
2403 val = Imlib_best_color_match(id, &r, &g, &b);
2404 *img++ = val;
2405 }
2406 }
2407 img += jmp;
2408 }
2409 }
2410 else
2411 {
2412 for (y = 0; y < h; y++)
2413 {
2414 for (x = 0; x < w; x++)
2415 {
2416 ptr2 = yarray[y] + xarray[x];
2417 r = (int)*ptr2++;
2418 g = (int)*ptr2++;
2419 b = (int)*ptr2;
2420 if ((r == im->shape_color.r) &&
2421 (g == im->shape_color.g) &&
2422 (b == im->shape_color.b))
2423 XPutPixel(sxim, x, y, 0);
2424 else
2425 {
2426 XPutPixel(sxim, x, y, 1);
2427 val = Imlib_best_color_match(id, &r, &g, &b);
2428 XPutPixel(xim, x, y, val);
2429 }
2430 }
2431 }
2432 }
2433 break;
2434 case RT_PLAIN_PALETTE_FAST:
2435 if ((id->fastrend) && (xim->bits_per_pixel == 8))
2436 {
2437 for (y = 0; y < h; y++)
2438 {
2439 for (x = 0; x < w; x++)
2440 {
2441 ptr2 = yarray[y] + xarray[x];
2442 r = (int)*ptr2++;
2443 g = (int)*ptr2++;
2444 b = (int)*ptr2;
2445 if ((r == im->shape_color.r) &&
2446 (g == im->shape_color.g) &&
2447 (b == im->shape_color.b))
2448 {
2449 XPutPixel(sxim, x, y, 0);
2450 img++;
2451 }
2452 else
2453 {
2454 XPutPixel(sxim, x, y, 1);
2455 val = COLOR_RGB(r >> 3, g >> 3, b >> 3);
2456 *img++ = val;
2457 }
2458 }
2459 img += jmp;
2460 }
2461 }
2462 else
2463 {
2464 for (y = 0; y < h; y++)
2465 {
2466 for (x = 0; x < w; x++)
2467 {
2468 ptr2 = yarray[y] + xarray[x];
2469 r = (int)*ptr2++;
2470 g = (int)*ptr2++;
2471 b = (int)*ptr2;
2472 if ((r == im->shape_color.r) &&
2473 (g == im->shape_color.g) &&
2474 (b == im->shape_color.b))
2475 XPutPixel(sxim, x, y, 0);
2476 else
2477 {
2478 XPutPixel(sxim, x, y, 1);
2479 val = COLOR_RGB(r >> 3, g >> 3, b >> 3);
2480 XPutPixel(xim, x, y, val);
2481 }
2482 }
2483 }
2484 }
2485 break;
2486 case RT_DITHER_PALETTE:
2487 if ((id->fastrend) && (xim->bits_per_pixel == 8))
2488 {
2489 for (y = 0; y < h; y++)
2490 {
2491 ter = er1;
2492 er1 = er2;
2493 er2 = ter;
2494 for (ex = 0; ex < (w + 2) * 3; ex++)
2495 er2[ex] = 0;
2496 ex = 3;
2497 for (x = 0; x < w; x++)
2498 {
2499 ptr2 = yarray[y] + xarray[x];
2500 r = (int)*ptr2++;
2501 g = (int)*ptr2++;
2502 b = (int)*ptr2;
2503 if ((r == im->shape_color.r) &&
2504 (g == im->shape_color.g) &&
2505 (b == im->shape_color.b))
2506 {
2507 {
2508 XPutPixel(sxim, x, y, 0);
2509 img++;
2510 }
2511 ex += 3;
2512 }
2513 else
2514 {
2515 XPutPixel(sxim, x, y, 1);
2516 er = r + er1[ex++];
2517 eg = g + er1[ex++];
2518 eb = b + er1[ex++];
2519 if (er > 255)
2520 er = 255;
2521 else if (er < 0)
2522 er = 0;
2523 if (eg > 255)
2524 eg = 255;
2525 else if (eg < 0)
2526 eg = 0;
2527 if (eb > 255)
2528 eb = 255;
2529 else if (eb < 0)
2530 eb = 0;
2531 val = Imlib_best_color_match(id, &er, &eg, &eb);
2532 DITHER_ERROR(er1, er2, ex, er, eg, eb);
2533 *img++ = val;
2534 }
2535 }
2536 img += jmp;
2537 }
2538 }
2539 else
2540 {
2541 for (y = 0; y < h; y++)
2542 {
2543 ter = er1;
2544 er1 = er2;
2545 er2 = ter;
2546 for (ex = 0; ex < (w + 2) * 3; ex++)
2547 er2[ex] = 0;
2548 ex = 3;
2549 for (x = 0; x < w; x++)
2550 {
2551 ptr2 = yarray[y] + xarray[x];
2552 r = (int)*ptr2++;
2553 g = (int)*ptr2++;
2554 b = (int)*ptr2;
2555 if ((r == im->shape_color.r) &&
2556 (g == im->shape_color.g) &&
2557 (b == im->shape_color.b))
2558 {
2559 XPutPixel(sxim, x, y, 0);
2560 ex += 3;
2561 }
2562 else
2563 {
2564 XPutPixel(sxim, x, y, 1);
2565 er = r + er1[ex++];
2566 eg = g + er1[ex++];
2567 eb = b + er1[ex++];
2568 if (er > 255)
2569 er = 255;
2570 else if (er < 0)
2571 er = 0;
2572 if (eg > 255)
2573 eg = 255;
2574 else if (eg < 0)
2575 eg = 0;
2576 if (eb > 255)
2577 eb = 255;
2578 else if (eb < 0)
2579 eb = 0;
2580 val = Imlib_best_color_match(id, &er, &eg, &eb);
2581 DITHER_ERROR(er1, er2, ex, er, eg, eb);
2582 XPutPixel(xim, x, y, val);
2583 }
2584 }
2585 }
2586 }
2587 break;
2588 case RT_DITHER_PALETTE_FAST:
2589 if ((id->fastrend) && (xim->bits_per_pixel == 8))
2590 {
2591 for (y = 0; y < h; y++)
2592 {
2593 ter = er1;
2594 er1 = er2;
2595 er2 = ter;
2596 for (ex = 0; ex < (w + 2) * 3; ex++)
2597 er2[ex] = 0;
2598 ex = 3;
2599 for (x = 0; x < w; x++)
2600 {
2601 ptr2 = yarray[y] + xarray[x];
2602 r = (int)*ptr2++;
2603 g = (int)*ptr2++;
2604 b = (int)*ptr2;
2605 if ((r == im->shape_color.r) &&
2606 (g == im->shape_color.g) &&
2607 (b == im->shape_color.b))
2608 {
2609 {
2610 XPutPixel(sxim, x, y, 0);
2611 img++;
2612 }
2613 ex += 3;
2614 }
2615 else
2616 {
2617 XPutPixel(sxim, x, y, 1);
2618 er = r + er1[ex++];
2619 eg = g + er1[ex++];
2620 eb = b + er1[ex++];
2621 if (er > 255)
2622 er = 255;
2623 else if (er < 0)
2624 er = 0;
2625 if (eg > 255)
2626 eg = 255;
2627 else if (eg < 0)
2628 eg = 0;
2629 if (eb > 255)
2630 eb = 255;
2631 else if (eb < 0)
2632 eb = 0;
2633 val = INDEX_RGB(er >> 3, eg >> 3, eb >> 3);
2634 er = ERROR_RED(er, val);
2635 eg = ERROR_GRN(eg, val);
2636 eb = ERROR_BLU(eb, val);
2637 DITHER_ERROR(er1, er2, ex, er, eg, eb);
2638 *img++ = COLOR_INDEX(val);
2639 }
2640 }
2641 img += jmp;
2642 }
2643 }
2644 else
2645 {
2646 for (y = 0; y < h; y++)
2647 {
2648 ter = er1;
2649 er1 = er2;
2650 er2 = ter;
2651 for (ex = 0; ex < (w + 2) * 3; ex++)
2652 er2[ex] = 0;
2653 ex = 3;
2654 for (x = 0; x < w; x++)
2655 {
2656 ptr2 = yarray[y] + xarray[x];
2657 r = (int)*ptr2++;
2658 g = (int)*ptr2++;
2659 b = (int)*ptr2;
2660 if ((r == im->shape_color.r) &&
2661 (g == im->shape_color.g) &&
2662 (b == im->shape_color.b))
2663 {
2664 XPutPixel(sxim, x, y, 0);
2665 ex += 3;
2666 }
2667 else
2668 {
2669 XPutPixel(sxim, x, y, 1);
2670 er = r + er1[ex++];
2671 eg = g + er1[ex++];
2672 eb = b + er1[ex++];
2673 if (er > 255)
2674 er = 255;
2675 else if (er < 0)
2676 er = 0;
2677 if (eg > 255)
2678 eg = 255;
2679 else if (eg < 0)
2680 eg = 0;
2681 if (eb > 255)
2682 eb = 255;
2683 else if (eb < 0)
2684 eb = 0;
2685 val = INDEX_RGB(er >> 3, eg >> 3, eb >> 3);
2686 er = ERROR_RED(er, val);
2687 eg = ERROR_GRN(eg, val);
2688 eb = ERROR_BLU(eb, val);
2689 DITHER_ERROR(er1, er2, ex, er, eg, eb);
2690 XPutPixel(xim, x, y, COLOR_INDEX(val));
2691 }
2692 }
2693 }
2694 }
2695 break;
2696 default:
2697 if (id->fastrend)
2698 {
2699 switch (bpp)
2700 {
2701 case 8:
2702 break;
2703 case 15:
2704 if (id->render_type == RT_DITHER_TRUECOL)
2705 render_shaped_15_fast_dither(id, im, w, h, xim, sxim, er1, er2, xarray, yarray);
2706 else
2707 render_shaped_15_fast(id, im, w, h, xim, sxim, er1, er2, xarray, yarray);
2708 break;
2709 case 16:
2710 if (id->render_type == RT_DITHER_TRUECOL)
2711 render_shaped_16_fast_dither(id, im, w, h, xim, sxim, er1, er2, xarray, yarray);
2712 else
2713 render_shaped_16_fast(id, im, w, h, xim, sxim, er1, er2, xarray, yarray);
2714 break;
2715 case 24:
2716 case 32:
2717 if (xim->bits_per_pixel == 24)
2718 render_shaped_24_fast(id, im, w, h, xim, sxim, er1, er2, xarray, yarray);
2719 else
2720 render_shaped_32_fast(id, im, w, h, xim, sxim, er1, er2, xarray, yarray);
2721 break;
2722 default:
2723 break;
2724 }
2725 }
2726 else
2727 {
2728 switch (bpp)
2729 {
2730 case 8:
2731 break;
2732 case 15:
2733 if (id->render_type == RT_DITHER_TRUECOL)
2734 render_shaped_15_dither(id, im, w, h, xim, sxim, er1, er2, xarray, yarray);
2735 else
2736 render_shaped_15(id, im, w, h, xim, sxim, er1, er2, xarray, yarray);
2737 break;
2738 case 16:
2739 if (id->render_type == RT_DITHER_TRUECOL)
2740 render_shaped_16_dither(id, im, w, h, xim, sxim, er1, er2, xarray, yarray);
2741 else
2742 render_shaped_16(id, im, w, h, xim, sxim, er1, er2, xarray, yarray);
2743 break;
2744 case 24:
2745 render_shaped_24(id, im, w, h, xim, sxim, er1, er2, xarray, yarray);
2746 case 32:
2747 render_shaped_24(id, im, w, h, xim, sxim, er1, er2, xarray, yarray);
2748 break;
2749 default:
2750 break;
2751 }
2752 }
2753 break;
2754 }
2755 }
2756
2757 static void
render(ImlibData * id,ImlibImage * im,int w,int h,XImage * xim,XImage * sxim,int * er1,int * er2,int * xarray,unsigned char ** yarray,int bpp)2758 render(ImlibData * id, ImlibImage * im, int w, int h, XImage * xim,
2759 XImage * sxim, int *er1, int *er2, int *xarray,
2760 unsigned char **yarray, int bpp)
2761 {
2762 int x, y, val, r, g, b, *ter, ex, er, eg, eb;
2763 unsigned char *ptr2;
2764 unsigned char *img;
2765 int jmp;
2766
2767 jmp = (xim->bytes_per_line) - w * (bpp >> 3);
2768 img = (unsigned char *)xim->data;
2769 switch (id->render_type)
2770 {
2771 case RT_PLAIN_PALETTE:
2772 if ((id->fastrend) && (xim->bits_per_pixel == 8))
2773 {
2774 for (y = 0; y < h; y++)
2775 {
2776 for (x = 0; x < w; x++)
2777 {
2778 ptr2 = yarray[y] + xarray[x];
2779 r = (int)*ptr2++;
2780 g = (int)*ptr2++;
2781 b = (int)*ptr2;
2782 val = Imlib_best_color_match(id, &r, &g, &b);
2783 *img++ = val;
2784 }
2785 img += jmp;
2786 }
2787 }
2788 else
2789 {
2790 for (y = 0; y < h; y++)
2791 {
2792 for (x = 0; x < w; x++)
2793 {
2794 ptr2 = yarray[y] + xarray[x];
2795 r = (int)*ptr2++;
2796 g = (int)*ptr2++;
2797 b = (int)*ptr2;
2798 val = Imlib_best_color_match(id, &r, &g, &b);
2799 XPutPixel(xim, x, y, val);
2800 }
2801 }
2802 }
2803 break;
2804 case RT_PLAIN_PALETTE_FAST:
2805 if ((id->fastrend) && (xim->bits_per_pixel == 8))
2806 {
2807 for (y = 0; y < h; y++)
2808 {
2809 for (x = 0; x < w; x++)
2810 {
2811 ptr2 = yarray[y] + xarray[x];
2812 r = (int)*ptr2++;
2813 g = (int)*ptr2++;
2814 b = (int)*ptr2;
2815 val = COLOR_RGB(r >> 3, g >> 3, b >> 3);
2816 *img++ = val;
2817 }
2818 img += jmp;
2819 }
2820 }
2821 else
2822 {
2823 for (y = 0; y < h; y++)
2824 {
2825 for (x = 0; x < w; x++)
2826 {
2827 ptr2 = yarray[y] + xarray[x];
2828 r = (int)*ptr2++;
2829 g = (int)*ptr2++;
2830 b = (int)*ptr2;
2831 val = COLOR_RGB(r >> 3, g >> 3, b >> 3);
2832 XPutPixel(xim, x, y, val);
2833 }
2834 }
2835 }
2836 break;
2837 case RT_DITHER_PALETTE:
2838 if ((id->fastrend) && (xim->bits_per_pixel == 8))
2839 {
2840 for (y = 0; y < h; y++)
2841 {
2842 ter = er1;
2843 er1 = er2;
2844 er2 = ter;
2845 for (ex = 0; ex < (w + 2) * 3; ex++)
2846 er2[ex] = 0;
2847 ex = 3;
2848 for (x = 0; x < w; x++)
2849 {
2850 ptr2 = yarray[y] + xarray[x];
2851 r = (int)*ptr2++;
2852 g = (int)*ptr2++;
2853 b = (int)*ptr2;
2854 er = r + er1[ex++];
2855 eg = g + er1[ex++];
2856 eb = b + er1[ex++];
2857 if (er > 255)
2858 er = 255;
2859 else if (er < 0)
2860 er = 0;
2861 if (eg > 255)
2862 eg = 255;
2863 else if (eg < 0)
2864 eg = 0;
2865 if (eb > 255)
2866 eb = 255;
2867 else if (eb < 0)
2868 eb = 0;
2869 val = Imlib_best_color_match(id, &er, &eg, &eb);
2870 DITHER_ERROR(er1, er2, ex, er, eg, eb);
2871 *img++ = val;
2872 }
2873 img += jmp;
2874 }
2875 }
2876 else
2877 {
2878 for (y = 0; y < h; y++)
2879 {
2880 ter = er1;
2881 er1 = er2;
2882 er2 = ter;
2883 for (ex = 0; ex < (w + 2) * 3; ex++)
2884 er2[ex] = 0;
2885 ex = 3;
2886 for (x = 0; x < w; x++)
2887 {
2888 ptr2 = yarray[y] + xarray[x];
2889 r = (int)*ptr2++;
2890 g = (int)*ptr2++;
2891 b = (int)*ptr2;
2892 er = r + er1[ex++];
2893 eg = g + er1[ex++];
2894 eb = b + er1[ex++];
2895 if (er > 255)
2896 er = 255;
2897 else if (er < 0)
2898 er = 0;
2899 if (eg > 255)
2900 eg = 255;
2901 else if (eg < 0)
2902 eg = 0;
2903 if (eb > 255)
2904 eb = 255;
2905 else if (eb < 0)
2906 eb = 0;
2907 val = Imlib_best_color_match(id, &er, &eg, &eb);
2908 DITHER_ERROR(er1, er2, ex, er, eg, eb);
2909 XPutPixel(xim, x, y, val);
2910 }
2911 }
2912 }
2913 break;
2914 case RT_DITHER_PALETTE_FAST:
2915 if ((id->fastrend) && (xim->bits_per_pixel == 8))
2916 {
2917 for (y = 0; y < h; y++)
2918 {
2919 ter = er1;
2920 er1 = er2;
2921 er2 = ter;
2922 for (ex = 0; ex < (w + 2) * 3; ex++)
2923 er2[ex] = 0;
2924 ex = 3;
2925 for (x = 0; x < w; x++)
2926 {
2927 ptr2 = yarray[y] + xarray[x];
2928 r = (int)*ptr2++;
2929 g = (int)*ptr2++;
2930 b = (int)*ptr2;
2931 er = r + er1[ex++];
2932 eg = g + er1[ex++];
2933 eb = b + er1[ex++];
2934 if (er > 255)
2935 er = 255;
2936 else if (er < 0)
2937 er = 0;
2938 if (eg > 255)
2939 eg = 255;
2940 else if (eg < 0)
2941 eg = 0;
2942 if (eb > 255)
2943 eb = 255;
2944 else if (eb < 0)
2945 eb = 0;
2946 val = INDEX_RGB(er >> 3, eg >> 3, eb >> 3);
2947 er = ERROR_RED(er, val);
2948 eg = ERROR_GRN(eg, val);
2949 eb = ERROR_BLU(eb, val);
2950 DITHER_ERROR(er1, er2, ex, er, eg, eb);
2951 *img++ = COLOR_INDEX(val);
2952 }
2953 img += jmp;
2954 }
2955 }
2956 else
2957 {
2958 for (y = 0; y < h; y++)
2959 {
2960 ter = er1;
2961 er1 = er2;
2962 er2 = ter;
2963 for (ex = 0; ex < (w + 2) * 3; ex++)
2964 er2[ex] = 0;
2965 ex = 3;
2966 for (x = 0; x < w; x++)
2967 {
2968 ptr2 = yarray[y] + xarray[x];
2969 r = (int)*ptr2++;
2970 g = (int)*ptr2++;
2971 b = (int)*ptr2;
2972 er = r + er1[ex++];
2973 eg = g + er1[ex++];
2974 eb = b + er1[ex++];
2975 if (er > 255)
2976 er = 255;
2977 else if (er < 0)
2978 er = 0;
2979 if (eg > 255)
2980 eg = 255;
2981 else if (eg < 0)
2982 eg = 0;
2983 if (eb > 255)
2984 eb = 255;
2985 else if (eb < 0)
2986 eb = 0;
2987 val = INDEX_RGB(er >> 3, eg >> 3, eb >> 3);
2988 er = ERROR_RED(er, val);
2989 eg = ERROR_GRN(eg, val);
2990 eb = ERROR_BLU(eb, val);
2991 DITHER_ERROR(er1, er2, ex, er, eg, eb);
2992 XPutPixel(xim, x, y, COLOR_INDEX(val));
2993 }
2994 }
2995 }
2996 break;
2997 default:
2998 if (id->fastrend)
2999 {
3000 switch (bpp)
3001 {
3002 case 8:
3003 break;
3004 case 15:
3005 if (id->render_type == RT_DITHER_TRUECOL)
3006 {
3007 if (id->ordered_dither)
3008 render_15_fast_dither_ordered(id, im, w, h, xim, sxim, er1, er2, xarray, yarray);
3009 else
3010 render_15_fast_dither(id, im, w, h, xim, sxim, er1, er2, xarray, yarray);
3011 }
3012 else
3013 render_15_fast(id, im, w, h, xim, sxim, er1, er2, xarray, yarray);
3014 break;
3015 case 16:
3016 if (id->render_type == RT_DITHER_TRUECOL)
3017 {
3018 if (id->ordered_dither)
3019 render_16_fast_dither_ordered(id, im, w, h, xim, sxim, er1, er2, xarray, yarray);
3020 else
3021 render_16_fast_dither(id, im, w, h, xim, sxim, er1, er2, xarray, yarray);
3022 }
3023 else
3024 render_16_fast(id, im, w, h, xim, sxim, er1, er2, xarray, yarray);
3025 break;
3026 case 24:
3027 case 32:
3028 if (xim->bits_per_pixel == 24)
3029 render_24_fast(id, im, w, h, xim, sxim, er1, er2, xarray, yarray);
3030 else
3031 render_32_fast(id, im, w, h, xim, sxim, er1, er2, xarray, yarray);
3032 break;
3033 default:
3034 break;
3035 }
3036 }
3037 else
3038 {
3039 switch (bpp)
3040 {
3041 case 8:
3042 break;
3043 case 15:
3044 if (id->render_type == RT_DITHER_TRUECOL)
3045 {
3046 if (id->ordered_dither)
3047 render_15_dither_ordered(id, im, w, h, xim, sxim, er1, er2, xarray, yarray);
3048 else
3049 render_15_dither(id, im, w, h, xim, sxim, er1, er2, xarray, yarray);
3050 }
3051 else
3052 render_15(id, im, w, h, xim, sxim, er1, er2, xarray, yarray);
3053 break;
3054 case 16:
3055 if (id->render_type == RT_DITHER_TRUECOL)
3056 {
3057 if (id->ordered_dither)
3058 render_16_dither_ordered(id, im, w, h, xim, sxim, er1, er2, xarray, yarray);
3059 else
3060 render_16_dither(id, im, w, h, xim, sxim, er1, er2, xarray, yarray);
3061 }
3062 else
3063 render_16(id, im, w, h, xim, sxim, er1, er2, xarray, yarray);
3064 break;
3065 case 24:
3066 render_24(id, im, w, h, xim, sxim, er1, er2, xarray, yarray);
3067 break;
3068 case 32:
3069 render_24(id, im, w, h, xim, sxim, er1, er2, xarray, yarray);
3070 break;
3071 default:
3072 break;
3073 }
3074 break;
3075 }
3076 }
3077 }
3078
3079 static void
render_shaped_15_fast_dither_mod(ImlibData * id,ImlibImage * im,int w,int h,XImage * xim,XImage * sxim,int * er1,int * er2,int * xarray,unsigned char ** yarray)3080 render_shaped_15_fast_dither_mod(ImlibData * id, ImlibImage * im, int w, int h, XImage * xim,
3081 XImage * sxim, int *er1, int *er2, int *xarray,
3082 unsigned char **yarray)
3083 {
3084 int x, y, val, r, g, b, *ter, ex, er, eg, eb;
3085 unsigned char *ptr2;
3086 unsigned short *img;
3087 int jmp;
3088
3089 jmp = (xim->bytes_per_line >> 1) - w;
3090 img = (unsigned short *)xim->data;
3091 for (y = 0; y < h; y++)
3092 {
3093 ter = er1;
3094 er1 = er2;
3095 er2 = ter;
3096 for (ex = 0; ex < (w + 2) * 3; ex++)
3097 er2[ex] = 0;
3098 ex = 3;
3099 for (x = 0; x < w; x++)
3100 {
3101 ptr2 = yarray[y] + xarray[x];
3102 r = (int)*ptr2++;
3103 g = (int)*ptr2++;
3104 b = (int)*ptr2;
3105 if ((r == im->shape_color.r) &&
3106 (g == im->shape_color.g) &&
3107 (b == im->shape_color.b))
3108 {
3109 XPutPixel(sxim, x, y, 0);
3110 img++;
3111 ex += 3;
3112 }
3113 else
3114 {
3115 r = im->rmap[r];
3116 g = im->gmap[g];
3117 b = im->bmap[b];
3118 XPutPixel(sxim, x, y, 1);
3119 er = r + er1[ex++];
3120 eg = g + er1[ex++];
3121 eb = b + er1[ex++];
3122 if (er > 255)
3123 er = 255;
3124 if (eg > 255)
3125 eg = 255;
3126 if (eb > 255)
3127 eb = 255;
3128 val = ((er & 0xf8) << 7) | ((eg & 0xf8) << 2) | ((eb & 0xf8) >> 3);
3129 er = er & 0x07;
3130 eg = eg & 0x07;
3131 eb = eb & 0x07;
3132 DITHER_ERROR(er1, er2, ex, er, eg, eb);
3133 *img++ = val;
3134 }
3135 }
3136 img += jmp;
3137 }
3138 }
3139
3140 static void
render_shaped_15_fast_dither_mod_ordered(ImlibData * id,ImlibImage * im,int w,int h,XImage * xim,XImage * sxim,int * er1,int * er2,int * xarray,unsigned char ** yarray)3141 render_shaped_15_fast_dither_mod_ordered(ImlibData * id, ImlibImage * im, int w, int h, XImage * xim,
3142 XImage * sxim, int *er1, int *er2, int *xarray,
3143 unsigned char **yarray)
3144 {
3145 int x, y, val, r, g, b, er, eg, eb;
3146 unsigned char *ptr2;
3147 unsigned short *img;
3148 int jmp;
3149
3150 unsigned char dither[4][4] =
3151 {
3152 {0, 4, 6, 5},
3153 {6, 2, 7, 3},
3154 {2, 6, 1, 5},
3155 {7, 4, 7, 3}
3156 };
3157 int dithy, dithx;
3158
3159 jmp = (xim->bytes_per_line >> 1) - w;
3160 img = (unsigned short *)xim->data;
3161 for (y = 0; y < h; y++)
3162 {
3163 dithy = y & 0x3;
3164 for (x = 0; x < w; x++)
3165 {
3166 ptr2 = yarray[y] + xarray[x];
3167 r = (int)*ptr2++;
3168 g = (int)*ptr2++;
3169 b = (int)*ptr2;
3170 if ((r == im->shape_color.r) &&
3171 (g == im->shape_color.g) &&
3172 (b == im->shape_color.b))
3173 {
3174 XPutPixel(sxim, x, y, 0);
3175 img++;
3176 }
3177 else
3178 {
3179 r = im->rmap[r];
3180 g = im->gmap[g];
3181 b = im->bmap[b];
3182 XPutPixel(sxim, x, y, 1);
3183 er = r & 0x07;
3184 eg = g & 0x07;
3185 eb = b & 0x07;
3186 dithx = x & 0x3;
3187 if ((dither[dithy][dithx] < er) && (r < (256 - 8)))
3188 r += 8;
3189 if ((dither[dithy][dithx] < eg) && (g < (256 - 8)))
3190 g += 8;
3191 if ((dither[dithy][dithx] < eb) && (b < (256 - 8)))
3192 b += 8;
3193 val = ((r & 0xf8) << 7) | ((g & 0xf8) << 2) | ((b & 0xf8) >> 3);
3194 *img++ = val;
3195 }
3196 }
3197 img += jmp;
3198 }
3199 }
3200
3201 static void
render_15_fast_dither_mod(ImlibData * id,ImlibImage * im,int w,int h,XImage * xim,XImage * sxim,int * er1,int * er2,int * xarray,unsigned char ** yarray)3202 render_15_fast_dither_mod(ImlibData * id, ImlibImage * im, int w, int h, XImage * xim,
3203 XImage * sxim, int *er1, int *er2, int *xarray,
3204 unsigned char **yarray)
3205 {
3206 int x, y, val, r, g, b, *ter, ex, er, eg, eb;
3207 unsigned char *ptr2;
3208 unsigned short *img;
3209 int jmp;
3210
3211 jmp = (xim->bytes_per_line >> 1) - w;
3212 img = (unsigned short *)xim->data;
3213 for (y = 0; y < h; y++)
3214 {
3215 ter = er1;
3216 er1 = er2;
3217 er2 = ter;
3218 for (ex = 0; ex < (w + 2) * 3; ex++)
3219 er2[ex] = 0;
3220 ex = 3;
3221 for (x = 0; x < w; x++)
3222 {
3223 ptr2 = yarray[y] + xarray[x];
3224 r = (int)*ptr2++;
3225 g = (int)*ptr2++;
3226 b = (int)*ptr2;
3227 r = im->rmap[r];
3228 g = im->gmap[g];
3229 b = im->bmap[b];
3230 er = r + er1[ex++];
3231 eg = g + er1[ex++];
3232 eb = b + er1[ex++];
3233 if (er > 255)
3234 er = 255;
3235 if (eg > 255)
3236 eg = 255;
3237 if (eb > 255)
3238 eb = 255;
3239 val = ((er & 0xf8) << 7) | ((eg & 0xf8) << 2) | ((eb & 0xf8) >> 3);
3240 er = er & 0x07;
3241 eg = eg & 0x07;
3242 eb = eb & 0x07;
3243 DITHER_ERROR(er1, er2, ex, er, eg, eb);
3244 *img++ = val;
3245 }
3246 img += jmp;
3247 }
3248 }
3249
3250 static void
render_15_fast_dither_mod_ordered(ImlibData * id,ImlibImage * im,int w,int h,XImage * xim,XImage * sxim,int * er1,int * er2,int * xarray,unsigned char ** yarray)3251 render_15_fast_dither_mod_ordered(ImlibData * id, ImlibImage * im, int w, int h, XImage * xim,
3252 XImage * sxim, int *er1, int *er2, int *xarray,
3253 unsigned char **yarray)
3254 {
3255 int x, y, val, r, g, b, er, eg, eb;
3256 unsigned char *ptr2;
3257
3258 unsigned short *img;
3259 int jmp;
3260
3261 unsigned char dither[4][4] =
3262 {
3263 {0, 4, 6, 5},
3264 {6, 2, 7, 3},
3265 {2, 6, 1, 5},
3266 {7, 4, 7, 3}
3267 };
3268 int dithy, dithx;
3269
3270 jmp = (xim->bytes_per_line >> 1) - w;
3271 img = (unsigned short *)xim->data;
3272 for (y = 0; y < h; y++)
3273 {
3274 dithy = y & 0x3;
3275 for (x = 0; x < w; x++)
3276 {
3277 ptr2 = yarray[y] + xarray[x];
3278 r = (int)*ptr2++;
3279 g = (int)*ptr2++;
3280 b = (int)*ptr2;
3281 r = im->rmap[r];
3282 g = im->gmap[g];
3283 b = im->bmap[b];
3284 er = r & 0x07;
3285 eg = g & 0x07;
3286 eb = b & 0x07;
3287 dithx = x & 0x3;
3288 if ((dither[dithy][dithx] < er) && (r < (256 - 8)))
3289 r += 8;
3290 if ((dither[dithy][dithx] < eg) && (g < (256 - 8)))
3291 g += 8;
3292 if ((dither[dithy][dithx] < eb) && (b < (256 - 8)))
3293 b += 8;
3294 val = ((r & 0xf8) << 7) | ((g & 0xf8) << 2) | ((b & 0xf8) >> 3);
3295 *img++ = val;
3296 }
3297 img += jmp;
3298 }
3299 }
3300
3301 static void
render_shaped_16_fast_dither_mod(ImlibData * id,ImlibImage * im,int w,int h,XImage * xim,XImage * sxim,int * er1,int * er2,int * xarray,unsigned char ** yarray)3302 render_shaped_16_fast_dither_mod(ImlibData * id, ImlibImage * im, int w, int h, XImage * xim,
3303 XImage * sxim, int *er1, int *er2, int *xarray,
3304 unsigned char **yarray)
3305 {
3306 int x, y, val, r, g, b, *ter, ex, er, eg, eb;
3307 unsigned char *ptr2;
3308 unsigned short *img;
3309 int jmp;
3310
3311 jmp = (xim->bytes_per_line >> 1) - w;
3312 img = (unsigned short *)xim->data;
3313 for (y = 0; y < h; y++)
3314 {
3315 ter = er1;
3316 er1 = er2;
3317 er2 = ter;
3318 for (ex = 0; ex < (w + 2) * 3; ex++)
3319 er2[ex] = 0;
3320 ex = 3;
3321 for (x = 0; x < w; x++)
3322 {
3323 ptr2 = yarray[y] + xarray[x];
3324 r = (int)*ptr2++;
3325 g = (int)*ptr2++;
3326 b = (int)*ptr2;
3327 if ((r == im->shape_color.r) &&
3328 (g == im->shape_color.g) &&
3329 (b == im->shape_color.b))
3330 {
3331 XPutPixel(sxim, x, y, 0);
3332 img++;
3333 ex += 3;
3334 }
3335 else
3336 {
3337 XPutPixel(sxim, x, y, 1);
3338 r = im->rmap[r];
3339 g = im->gmap[g];
3340 b = im->bmap[b];
3341 er = r + er1[ex++];
3342 eg = g + er1[ex++];
3343 eb = b + er1[ex++];
3344 if (er > 255)
3345 er = 255;
3346 if (eg > 255)
3347 eg = 255;
3348 if (eb > 255)
3349 eb = 255;
3350 val = ((er & 0xf8) << 8) | ((eg & 0xfc) << 3) | ((eb & 0xf8) >> 3);
3351 er = er & 0x07;
3352 eg = eg & 0x03;
3353 eb = eb & 0x07;
3354 DITHER_ERROR(er1, er2, ex, er, eg, eb);
3355 *img++ = val;
3356 }
3357 }
3358 img += jmp;
3359 }
3360 }
3361
3362 static void
render_shaped_16_fast_dither_mod_ordered(ImlibData * id,ImlibImage * im,int w,int h,XImage * xim,XImage * sxim,int * er1,int * er2,int * xarray,unsigned char ** yarray)3363 render_shaped_16_fast_dither_mod_ordered(ImlibData * id, ImlibImage * im, int w, int h, XImage * xim,
3364 XImage * sxim, int *er1, int *er2, int *xarray,
3365 unsigned char **yarray)
3366 {
3367 int x, y, val, r, g, b, er, eg, eb;
3368 unsigned char *ptr2;
3369 unsigned short *img;
3370 int jmp;
3371
3372 unsigned char dither[4][4] =
3373 {
3374 {0, 4, 6, 5},
3375 {6, 2, 7, 3},
3376 {2, 6, 1, 5},
3377 {7, 4, 7, 3}
3378 };
3379 int dithy, dithx;
3380
3381 jmp = (xim->bytes_per_line >> 1) - w;
3382 img = (unsigned short *)xim->data;
3383 for (y = 0; y < h; y++)
3384 {
3385 dithy = y & 0x3;
3386 for (x = 0; x < w; x++)
3387 {
3388 ptr2 = yarray[y] + xarray[x];
3389 r = (int)*ptr2++;
3390 g = (int)*ptr2++;
3391 b = (int)*ptr2;
3392 if ((r == im->shape_color.r) &&
3393 (g == im->shape_color.g) &&
3394 (b == im->shape_color.b))
3395 {
3396 XPutPixel(sxim, x, y, 0);
3397 img++;
3398 }
3399 else
3400 {
3401 r = im->rmap[r];
3402 g = im->gmap[g];
3403 b = im->bmap[b];
3404 XPutPixel(sxim, x, y, 1);
3405 er = r & 0x07;
3406 eg = g & 0x03;
3407 eb = b & 0x07;
3408 dithx = x & 0x3;
3409 if ((dither[dithy][dithx] < er) && (r < (256 - 8)))
3410 r += 8;
3411 if ((dither[dithy][dithx] < (eg << 1)) && (g < (256 - 4)))
3412 g += 4;
3413 if ((dither[dithy][dithx] < eb) && (b < (256 - 8)))
3414 b += 8;
3415 val = ((r & 0xf8) << 8) | ((g & 0xfc) << 3) | ((b & 0xf8) >> 3);
3416 *img++ = val;
3417 }
3418 }
3419 img += jmp;
3420 }
3421 }
3422
3423 static void
render_16_fast_dither_mod(ImlibData * id,ImlibImage * im,int w,int h,XImage * xim,XImage * sxim,int * er1,int * er2,int * xarray,unsigned char ** yarray)3424 render_16_fast_dither_mod(ImlibData * id, ImlibImage * im, int w, int h, XImage * xim,
3425 XImage * sxim, int *er1, int *er2, int *xarray,
3426 unsigned char **yarray)
3427 {
3428 int x, y, val, r, g, b, *ter, ex, er, eg, eb;
3429 unsigned char *ptr2;
3430
3431 unsigned short *img;
3432 int jmp;
3433
3434 jmp = (xim->bytes_per_line >> 1) - w;
3435 img = (unsigned short *)xim->data;
3436 for (y = 0; y < h; y++)
3437 {
3438 ter = er1;
3439 er1 = er2;
3440 er2 = ter;
3441 for (ex = 0; ex < (w + 2) * 3; ex++)
3442 er2[ex] = 0;
3443 ex = 3;
3444 for (x = 0; x < w; x++)
3445 {
3446 ptr2 = yarray[y] + xarray[x];
3447 r = (int)*ptr2++;
3448 g = (int)*ptr2++;
3449 b = (int)*ptr2;
3450 r = im->rmap[r];
3451 g = im->gmap[g];
3452 b = im->bmap[b];
3453 er = r + er1[ex++];
3454 eg = g + er1[ex++];
3455 eb = b + er1[ex++];
3456 if (er > 255)
3457 er = 255;
3458 if (eg > 255)
3459 eg = 255;
3460 if (eb > 255)
3461 eb = 255;
3462 val = ((er & 0xf8) << 8) | ((eg & 0xfc) << 3) | ((eb & 0xf8) >> 3);
3463 er = er & 0x07;
3464 eg = eg & 0x03;
3465 eb = eb & 0x07;
3466 DITHER_ERROR(er1, er2, ex, er, eg, eb);
3467 *img++ = val;
3468 }
3469 img += jmp;
3470 }
3471 }
3472
3473 static void
render_16_fast_dither_mod_ordered(ImlibData * id,ImlibImage * im,int w,int h,XImage * xim,XImage * sxim,int * er1,int * er2,int * xarray,unsigned char ** yarray)3474 render_16_fast_dither_mod_ordered(ImlibData * id, ImlibImage * im, int w, int h, XImage * xim,
3475 XImage * sxim, int *er1, int *er2, int *xarray,
3476 unsigned char **yarray)
3477 {
3478 int x, y, val, r, g, b, er, eg, eb;
3479 unsigned char *ptr2;
3480
3481 unsigned short *img;
3482 int jmp;
3483
3484 unsigned char dither[4][4] =
3485 {
3486 {0, 4, 6, 5},
3487 {6, 2, 7, 3},
3488 {2, 6, 1, 5},
3489 {7, 4, 7, 3}
3490 };
3491 int dithy, dithx;
3492
3493 jmp = (xim->bytes_per_line >> 1) - w;
3494 img = (unsigned short *)xim->data;
3495 for (y = 0; y < h; y++)
3496 {
3497 dithy = y & 0x3;
3498 for (x = 0; x < w; x++)
3499 {
3500 ptr2 = yarray[y] + xarray[x];
3501 r = (int)*ptr2++;
3502 g = (int)*ptr2++;
3503 b = (int)*ptr2;
3504 r = im->rmap[r];
3505 g = im->gmap[g];
3506 b = im->bmap[b];
3507 er = r & 0x07;
3508 eg = g & 0x03;
3509 eb = b & 0x07;
3510 dithx = x & 0x3;
3511 if ((dither[dithy][dithx] < er) && (r < (256 - 8)))
3512 r += 8;
3513 if ((dither[dithy][dithx] < (eg << 1)) && (g < (256 - 4)))
3514 g += 4;
3515 if ((dither[dithy][dithx] < eb) && (b < (256 - 8)))
3516 b += 8;
3517 val = ((r & 0xf8) << 8) | ((g & 0xfc) << 3) | ((b & 0xf8) >> 3);
3518 *img++ = val;
3519 }
3520 img += jmp;
3521 }
3522 }
3523
3524 static void
render_shaped_15_dither_mod_ordered(ImlibData * id,ImlibImage * im,int w,int h,XImage * xim,XImage * sxim,int * er1,int * er2,int * xarray,unsigned char ** yarray)3525 render_shaped_15_dither_mod_ordered(ImlibData * id, ImlibImage * im, int w, int h, XImage * xim,
3526 XImage * sxim, int *er1, int *er2, int *xarray,
3527 unsigned char **yarray)
3528 {
3529 int x, y, val, r, g, b, er, eg, eb;
3530 unsigned char *ptr2;
3531
3532 unsigned char dither[4][4] =
3533 {
3534 {0, 4, 6, 5},
3535 {6, 2, 7, 3},
3536 {2, 6, 1, 5},
3537 {7, 4, 7, 3}
3538 };
3539 int dithy, dithx;
3540
3541 for (y = 0; y < h; y++)
3542 {
3543 dithy = y & 0x3;
3544 for (x = 0; x < w; x++)
3545 {
3546 ptr2 = yarray[y] + xarray[x];
3547 r = (int)*ptr2++;
3548 g = (int)*ptr2++;
3549 b = (int)*ptr2;
3550 if ((r == im->shape_color.r) &&
3551 (g == im->shape_color.g) &&
3552 (b == im->shape_color.b))
3553 {
3554 XPutPixel(sxim, x, y, 0);
3555 }
3556 else
3557 {
3558 r = im->rmap[r];
3559 g = im->gmap[g];
3560 b = im->bmap[b];
3561 XPutPixel(sxim, x, y, 1);
3562 er = r & 0x07;
3563 eg = g & 0x07;
3564 eb = b & 0x07;
3565 dithx = x & 0x3;
3566 if ((dither[dithy][dithx] < er) && (r < (256 - 8)))
3567 r += 8;
3568 if ((dither[dithy][dithx] < eg) && (g < (256 - 8)))
3569 g += 8;
3570 if ((dither[dithy][dithx] < eb) && (b < (256 - 8)))
3571 b += 8;
3572 val = ((r & 0xf8) << 7) | ((g & 0xf8) << 2) | ((b & 0xf8) >> 3);
3573 XPutPixel(xim, x, y, val);
3574 }
3575 }
3576 }
3577 }
3578
3579 static void
render_15_dither_mod_ordered(ImlibData * id,ImlibImage * im,int w,int h,XImage * xim,XImage * sxim,int * er1,int * er2,int * xarray,unsigned char ** yarray)3580 render_15_dither_mod_ordered(ImlibData * id, ImlibImage * im, int w, int h, XImage * xim,
3581 XImage * sxim, int *er1, int *er2, int *xarray,
3582 unsigned char **yarray)
3583 {
3584 int x, y, val, r, g, b, er, eg, eb;
3585 unsigned char *ptr2;
3586
3587 unsigned char dither[4][4] =
3588 {
3589 {0, 4, 6, 5},
3590 {6, 2, 7, 3},
3591 {2, 6, 1, 5},
3592 {7, 4, 7, 3}
3593 };
3594 int dithy, dithx;
3595
3596 for (y = 0; y < h; y++)
3597 {
3598 dithy = y & 0x3;
3599 for (x = 0; x < w; x++)
3600 {
3601 ptr2 = yarray[y] + xarray[x];
3602 r = (int)*ptr2++;
3603 g = (int)*ptr2++;
3604 b = (int)*ptr2;
3605 r = im->rmap[r];
3606 g = im->gmap[g];
3607 b = im->bmap[b];
3608 er = r & 0x07;
3609 eg = g & 0x07;
3610 eb = b & 0x07;
3611 dithx = x & 0x3;
3612 if ((dither[dithy][dithx] < er) && (r < (256 - 8)))
3613 r += 8;
3614 if ((dither[dithy][dithx] < eg) && (g < (256 - 8)))
3615 g += 8;
3616 if ((dither[dithy][dithx] < eb) && (b < (256 - 8)))
3617 b += 8;
3618 val = ((r & 0xf8) << 7) | ((g & 0xf8) << 2) | ((b & 0xf8) >> 3);
3619 XPutPixel(xim, x, y, val);
3620 }
3621 }
3622 }
3623
3624 static void
render_shaped_16_dither_mod_ordered(ImlibData * id,ImlibImage * im,int w,int h,XImage * xim,XImage * sxim,int * er1,int * er2,int * xarray,unsigned char ** yarray)3625 render_shaped_16_dither_mod_ordered(ImlibData * id, ImlibImage * im, int w, int h, XImage * xim,
3626 XImage * sxim, int *er1, int *er2, int *xarray,
3627 unsigned char **yarray)
3628 {
3629 int x, y, val, r, g, b, er, eg, eb;
3630 unsigned char *ptr2;
3631
3632 unsigned char dither[4][4] =
3633 {
3634 {0, 4, 6, 5},
3635 {6, 2, 7, 3},
3636 {2, 6, 1, 5},
3637 {7, 4, 7, 3}
3638 };
3639 int dithy, dithx;
3640
3641 for (y = 0; y < h; y++)
3642 {
3643 dithy = y & 0x3;
3644 for (x = 0; x < w; x++)
3645 {
3646 ptr2 = yarray[y] + xarray[x];
3647 r = (int)*ptr2++;
3648 g = (int)*ptr2++;
3649 b = (int)*ptr2;
3650 if ((r == im->shape_color.r) &&
3651 (g == im->shape_color.g) &&
3652 (b == im->shape_color.b))
3653 {
3654 XPutPixel(sxim, x, y, 0);
3655 }
3656 else
3657 {
3658 r = im->rmap[r];
3659 g = im->gmap[g];
3660 b = im->bmap[b];
3661 XPutPixel(sxim, x, y, 1);
3662 er = r & 0x07;
3663 eg = g & 0x03;
3664 eb = b & 0x07;
3665 dithx = x & 0x3;
3666 if ((dither[dithy][dithx] < er) && (r < (256 - 8)))
3667 r += 8;
3668 if ((dither[dithy][dithx] < (eg << 1)) && (g < (256 - 4)))
3669 g += 4;
3670 if ((dither[dithy][dithx] < eb) && (b < (256 - 8)))
3671 b += 8;
3672 val = ((r & 0xf8) << 8) | ((g & 0xfc) << 3) | ((b & 0xf8) >> 3);
3673 XPutPixel(xim, x, y, val);
3674 }
3675 }
3676 }
3677 }
3678
3679 static void
render_16_dither_mod_ordered(ImlibData * id,ImlibImage * im,int w,int h,XImage * xim,XImage * sxim,int * er1,int * er2,int * xarray,unsigned char ** yarray)3680 render_16_dither_mod_ordered(ImlibData * id, ImlibImage * im, int w, int h, XImage * xim,
3681 XImage * sxim, int *er1, int *er2, int *xarray,
3682 unsigned char **yarray)
3683 {
3684 int x, y, val, r, g, b, er, eg, eb;
3685 unsigned char *ptr2;
3686
3687 unsigned char dither[4][4] =
3688 {
3689 {0, 4, 6, 5},
3690 {6, 2, 7, 3},
3691 {2, 6, 1, 5},
3692 {7, 4, 7, 3}
3693 };
3694 int dithy, dithx;
3695
3696 for (y = 0; y < h; y++)
3697 {
3698 dithy = y & 0x3;
3699 for (x = 0; x < w; x++)
3700 {
3701 ptr2 = yarray[y] + xarray[x];
3702 r = (int)*ptr2++;
3703 g = (int)*ptr2++;
3704 b = (int)*ptr2;
3705 r = im->rmap[r];
3706 g = im->gmap[g];
3707 b = im->bmap[b];
3708 er = r & 0x07;
3709 eg = g & 0x03;
3710 eb = b & 0x07;
3711 dithx = x & 0x3;
3712 if ((dither[dithy][dithx] < er) && (r < (256 - 8)))
3713 r += 8;
3714 if ((dither[dithy][dithx] < (eg << 1)) && (g < (256 - 4)))
3715 g += 4;
3716 if ((dither[dithy][dithx] < eb) && (b < (256 - 8)))
3717 b += 8;
3718 val = ((r & 0xf8) << 8) | ((g & 0xfc) << 3) | ((b & 0xf8) >> 3);
3719 XPutPixel(xim, x, y, val);
3720 }
3721 }
3722 }
3723
3724 static void
render_shaped_15_dither_mod(ImlibData * id,ImlibImage * im,int w,int h,XImage * xim,XImage * sxim,int * er1,int * er2,int * xarray,unsigned char ** yarray)3725 render_shaped_15_dither_mod(ImlibData * id, ImlibImage * im, int w, int h, XImage * xim,
3726 XImage * sxim, int *er1, int *er2, int *xarray,
3727 unsigned char **yarray)
3728 {
3729 int x, y, val, r, g, b, *ter, ex, er, eg, eb;
3730 unsigned char *ptr2;
3731
3732 for (y = 0; y < h; y++)
3733 {
3734 ter = er1;
3735 er1 = er2;
3736 er2 = ter;
3737 for (ex = 0; ex < (w + 2) * 3; ex++)
3738 er2[ex] = 0;
3739 ex = 3;
3740 for (x = 0; x < w; x++)
3741 {
3742 ptr2 = yarray[y] + xarray[x];
3743 r = (int)*ptr2++;
3744 g = (int)*ptr2++;
3745 b = (int)*ptr2;
3746 if ((r == im->shape_color.r) &&
3747 (g == im->shape_color.g) &&
3748 (b == im->shape_color.b))
3749 {
3750 XPutPixel(sxim, x, y, 0);
3751 ex += 3;
3752 }
3753 else
3754 {
3755 XPutPixel(sxim, x, y, 1);
3756 r = im->rmap[r];
3757 g = im->gmap[g];
3758 b = im->bmap[b];
3759 er = r + er1[ex++];
3760 eg = g + er1[ex++];
3761 eb = b + er1[ex++];
3762 if (er > 255)
3763 er = 255;
3764 if (eg > 255)
3765 eg = 255;
3766 if (eb > 255)
3767 eb = 255;
3768 val = ((er & 0xf8) << 7) | ((eg & 0xf8) << 2) | ((eb & 0xf8) >> 3);
3769 er = er & 0x07;
3770 eg = eg & 0x07;
3771 eb = eb & 0x07;
3772 if (er > 255)
3773 er = 255;
3774 else if (er < 0)
3775 er = 0;
3776 if (eg > 255)
3777 eg = 255;
3778 else if (eg < 0)
3779 eg = 0;
3780 if (eb > 255)
3781 eb = 255;
3782 else if (eb < 0)
3783 eb = 0;
3784 val = ((r & 0xf8) << 7) | ((g & 0xf8) << 2) | ((b & 0xf8) >> 3);
3785 er = r & 0x07;
3786 eg = g & 0x07;
3787 eb = b & 0x07;
3788 DITHER_ERROR(er1, er2, ex, er, eg, eb);
3789 XPutPixel(xim, x, y, val);
3790 }
3791 }
3792 }
3793 }
3794
3795 static void
render_15_dither_mod(ImlibData * id,ImlibImage * im,int w,int h,XImage * xim,XImage * sxim,int * er1,int * er2,int * xarray,unsigned char ** yarray)3796 render_15_dither_mod(ImlibData * id, ImlibImage * im, int w, int h, XImage * xim,
3797 XImage * sxim, int *er1, int *er2, int *xarray,
3798 unsigned char **yarray)
3799 {
3800 int x, y, val, r, g, b, *ter, ex, er, eg, eb;
3801 unsigned char *ptr2;
3802
3803 for (y = 0; y < h; y++)
3804 {
3805 ter = er1;
3806 er1 = er2;
3807 er2 = ter;
3808 for (ex = 0; ex < (w + 2) * 3; ex++)
3809 er2[ex] = 0;
3810 ex = 3;
3811 for (x = 0; x < w; x++)
3812 {
3813 ptr2 = yarray[y] + xarray[x];
3814 r = (int)*ptr2++;
3815 g = (int)*ptr2++;
3816 b = (int)*ptr2;
3817 r = im->rmap[r];
3818 g = im->gmap[g];
3819 b = im->bmap[b];
3820 er = r + er1[ex++];
3821 eg = g + er1[ex++];
3822 eb = b + er1[ex++];
3823 if (er > 255)
3824 er = 255;
3825 if (eg > 255)
3826 eg = 255;
3827 if (eb > 255)
3828 eb = 255;
3829 val = ((er & 0xf8) << 7) | ((eg & 0xf8) << 2) | ((eb & 0xf8) >> 3);
3830 er = er & 0x07;
3831 eg = eg & 0x07;
3832 eb = eb & 0x07;
3833 DITHER_ERROR(er1, er2, ex, er, eg, eb);
3834 XPutPixel(xim, x, y, val);
3835 }
3836 }
3837 }
3838
3839 static void
render_shaped_16_dither_mod(ImlibData * id,ImlibImage * im,int w,int h,XImage * xim,XImage * sxim,int * er1,int * er2,int * xarray,unsigned char ** yarray)3840 render_shaped_16_dither_mod(ImlibData * id, ImlibImage * im, int w, int h, XImage * xim,
3841 XImage * sxim, int *er1, int *er2, int *xarray,
3842 unsigned char **yarray)
3843 {
3844 int x, y, val, r, g, b, *ter, ex, er, eg, eb;
3845 unsigned char *ptr2;
3846
3847 for (y = 0; y < h; y++)
3848 {
3849 ter = er1;
3850 er1 = er2;
3851 er2 = ter;
3852 for (ex = 0; ex < (w + 2) * 3; ex++)
3853 er2[ex] = 0;
3854 ex = 3;
3855 for (x = 0; x < w; x++)
3856 {
3857 ptr2 = yarray[y] + xarray[x];
3858 r = (int)*ptr2++;
3859 g = (int)*ptr2++;
3860 b = (int)*ptr2;
3861 if ((r == im->shape_color.r) &&
3862 (g == im->shape_color.g) &&
3863 (b == im->shape_color.b))
3864 {
3865 XPutPixel(sxim, x, y, 0);
3866 ex += 3;
3867 }
3868 else
3869 {
3870 XPutPixel(sxim, x, y, 1);
3871 r = im->rmap[r];
3872 g = im->gmap[g];
3873 b = im->bmap[b];
3874 er = r + er1[ex++];
3875 eg = g + er1[ex++];
3876 eb = b + er1[ex++];
3877 if (er > 255)
3878 er = 255;
3879 if (eg > 255)
3880 eg = 255;
3881 if (eb > 255)
3882 eb = 255;
3883 val = ((er & 0xf8) << 8) | ((eg & 0xfc) << 3) | ((eb & 0xf8) >> 3);
3884 er = er & 0x07;
3885 eg = eg & 0x03;
3886 eb = eb & 0x07;
3887 DITHER_ERROR(er1, er2, ex, er, eg, eb);
3888 XPutPixel(xim, x, y, val);
3889 }
3890 }
3891 }
3892 }
3893
3894 static void
render_16_dither_mod(ImlibData * id,ImlibImage * im,int w,int h,XImage * xim,XImage * sxim,int * er1,int * er2,int * xarray,unsigned char ** yarray)3895 render_16_dither_mod(ImlibData * id, ImlibImage * im, int w, int h, XImage * xim,
3896 XImage * sxim, int *er1, int *er2, int *xarray,
3897 unsigned char **yarray)
3898 {
3899 int x, y, val, r, g, b, *ter, ex, er, eg, eb;
3900 unsigned char *ptr2;
3901
3902 for (y = 0; y < h; y++)
3903 {
3904 ter = er1;
3905 er1 = er2;
3906 er2 = ter;
3907 for (ex = 0; ex < (w + 2) * 3; ex++)
3908 er2[ex] = 0;
3909 ex = 3;
3910 for (x = 0; x < w; x++)
3911 {
3912 ptr2 = yarray[y] + xarray[x];
3913 r = (int)*ptr2++;
3914 g = (int)*ptr2++;
3915 b = (int)*ptr2;
3916 r = im->rmap[r];
3917 g = im->gmap[g];
3918 b = im->bmap[b];
3919 er = r + er1[ex++];
3920 eg = g + er1[ex++];
3921 eb = b + er1[ex++];
3922 if (er > 255)
3923 er = 255;
3924 if (eg > 255)
3925 eg = 255;
3926 if (eb > 255)
3927 eb = 255;
3928 val = ((er & 0xf8) << 8) | ((eg & 0xfc) << 3) | ((eb & 0xf8) >> 3);
3929 er = er & 0x07;
3930 eg = eg & 0x03;
3931 eb = eb & 0x07;
3932 DITHER_ERROR(er1, er2, ex, er, eg, eb);
3933 XPutPixel(xim, x, y, val);
3934 }
3935 }
3936 }
3937
3938 static void
render_shaped_15_fast_mod(ImlibData * id,ImlibImage * im,int w,int h,XImage * xim,XImage * sxim,int * er1,int * er2,int * xarray,unsigned char ** yarray)3939 render_shaped_15_fast_mod(ImlibData * id, ImlibImage * im, int w, int h, XImage * xim,
3940 XImage * sxim, int *er1, int *er2, int *xarray,
3941 unsigned char **yarray)
3942 {
3943 int x, y, val, r, g, b;
3944 unsigned char *ptr2;
3945 unsigned short *img;
3946 int jmp;
3947
3948 jmp = (xim->bytes_per_line >> 1) - w;
3949 img = (unsigned short *)xim->data;
3950 for (y = 0; y < h; y++)
3951 {
3952 for (x = 0; x < w; x++)
3953 {
3954 ptr2 = yarray[y] + xarray[x];
3955 r = (int)*ptr2++;
3956 g = (int)*ptr2++;
3957 b = (int)*ptr2;
3958 if ((r == im->shape_color.r) &&
3959 (g == im->shape_color.g) &&
3960 (b == im->shape_color.b))
3961 {
3962 XPutPixel(sxim, x, y, 0);
3963 img++;
3964 }
3965 else
3966 {
3967 XPutPixel(sxim, x, y, 1);
3968 r = im->rmap[r];
3969 g = im->gmap[g];
3970 b = im->bmap[b];
3971 val = ((r & 0xf8) << 7) | ((g & 0xf8) << 2) | ((b & 0xf8) >> 3);
3972 *img++ = val;
3973 }
3974 }
3975 img += jmp;
3976 }
3977 }
3978
3979 static void
render_15_fast_mod(ImlibData * id,ImlibImage * im,int w,int h,XImage * xim,XImage * sxim,int * er1,int * er2,int * xarray,unsigned char ** yarray)3980 render_15_fast_mod(ImlibData * id, ImlibImage * im, int w, int h, XImage * xim,
3981 XImage * sxim, int *er1, int *er2, int *xarray,
3982 unsigned char **yarray)
3983 {
3984 int x, y, val, r, g, b;
3985 unsigned char *ptr2;
3986 unsigned short *img;
3987 int jmp;
3988
3989 jmp = (xim->bytes_per_line >> 1) - w;
3990 img = (unsigned short *)xim->data;
3991 for (y = 0; y < h; y++)
3992 {
3993 for (x = 0; x < w; x++)
3994 {
3995 ptr2 = yarray[y] + xarray[x];
3996 r = (int)*ptr2++;
3997 g = (int)*ptr2++;
3998 b = (int)*ptr2;
3999 r = im->rmap[r];
4000 g = im->gmap[g];
4001 b = im->bmap[b];
4002 val = ((r & 0xf8) << 7) | ((g & 0xf8) << 2) | ((b & 0xf8) >> 3);
4003 *img++ = val;
4004 }
4005 img += jmp;
4006 }
4007 }
4008
4009 static void
render_shaped_16_fast_mod(ImlibData * id,ImlibImage * im,int w,int h,XImage * xim,XImage * sxim,int * er1,int * er2,int * xarray,unsigned char ** yarray)4010 render_shaped_16_fast_mod(ImlibData * id, ImlibImage * im, int w, int h, XImage * xim,
4011 XImage * sxim, int *er1, int *er2, int *xarray,
4012 unsigned char **yarray)
4013 {
4014 int x, y, val, r, g, b;
4015 unsigned char *ptr2;
4016 unsigned short *img;
4017 int jmp;
4018
4019 jmp = (xim->bytes_per_line >> 1) - w;
4020 img = (unsigned short *)xim->data;
4021 for (y = 0; y < h; y++)
4022 {
4023 for (x = 0; x < w; x++)
4024 {
4025 ptr2 = yarray[y] + xarray[x];
4026 r = (int)*ptr2++;
4027 g = (int)*ptr2++;
4028 b = (int)*ptr2;
4029 if ((r == im->shape_color.r) &&
4030 (g == im->shape_color.g) &&
4031 (b == im->shape_color.b))
4032 {
4033 XPutPixel(sxim, x, y, 0);
4034 img++;
4035 }
4036 else
4037 {
4038 XPutPixel(sxim, x, y, 1);
4039 r = im->rmap[r];
4040 g = im->gmap[g];
4041 b = im->bmap[b];
4042 val = ((r & 0xf8) << 8) | ((g & 0xfc) << 3) | ((b & 0xf8) >> 3);
4043 *img++ = val;
4044 }
4045 }
4046 img += jmp;
4047 }
4048 }
4049
4050 static void
render_16_fast_mod(ImlibData * id,ImlibImage * im,int w,int h,XImage * xim,XImage * sxim,int * er1,int * er2,int * xarray,unsigned char ** yarray)4051 render_16_fast_mod(ImlibData * id, ImlibImage * im, int w, int h, XImage * xim,
4052 XImage * sxim, int *er1, int *er2, int *xarray,
4053 unsigned char **yarray)
4054 {
4055 int x, y, val, r, g, b;
4056 unsigned char *ptr2;
4057
4058 unsigned short *img;
4059 int jmp;
4060
4061 jmp = (xim->bytes_per_line >> 1) - w;
4062 img = (unsigned short *)xim->data;
4063 for (y = 0; y < h; y++)
4064 {
4065 for (x = 0; x < w; x++)
4066 {
4067 ptr2 = yarray[y] + xarray[x];
4068 r = (int)*ptr2++;
4069 g = (int)*ptr2++;
4070 b = (int)*ptr2;
4071 r = im->rmap[r];
4072 g = im->gmap[g];
4073 b = im->bmap[b];
4074 val = ((r & 0xf8) << 8) | ((g & 0xfc) << 3) | ((b & 0xf8) >> 3);
4075 *img++ = val;
4076 }
4077 img += jmp;
4078 }
4079 }
4080
4081 static void
render_shaped_24_fast_mod(ImlibData * id,ImlibImage * im,int w,int h,XImage * xim,XImage * sxim,int * er1,int * er2,int * xarray,unsigned char ** yarray)4082 render_shaped_24_fast_mod(ImlibData * id, ImlibImage * im, int w, int h, XImage * xim,
4083 XImage * sxim, int *er1, int *er2, int *xarray,
4084 unsigned char **yarray)
4085 {
4086 int x, y, r, g, b;
4087 unsigned char *ptr2;
4088 unsigned char *img;
4089 int jmp;
4090
4091 jmp = (xim->bytes_per_line) - w * 3;
4092 img = (unsigned char *)xim->data;
4093
4094 if (id->x.byte_order == MSBFirst)
4095 {
4096 if (id->byte_order == BYTE_ORD_24_RGB)
4097 {
4098 for (y = 0; y < h; y++)
4099 {
4100 for (x = 0; x < w; x++)
4101 {
4102 ptr2 = yarray[y] + xarray[x];
4103 r = (int)*ptr2++;
4104 g = (int)*ptr2++;
4105 b = (int)*ptr2;
4106 if ((r == im->shape_color.r) &&
4107 (g == im->shape_color.g) &&
4108 (b == im->shape_color.b))
4109 {
4110 XPutPixel(sxim, x, y, 0);
4111 img += 3;
4112 }
4113 else
4114 {
4115 XPutPixel(sxim, x, y, 1);
4116 r = im->rmap[r];
4117 g = im->gmap[g];
4118 b = im->bmap[b];
4119 *img++ = r;
4120 *img++ = g;
4121 *img++ = b;
4122 }
4123 }
4124 img += jmp;
4125 }
4126 }
4127 else if (id->byte_order == BYTE_ORD_24_RBG)
4128 {
4129 for (y = 0; y < h; y++)
4130 {
4131 for (x = 0; x < w; x++)
4132 {
4133 ptr2 = yarray[y] + xarray[x];
4134 r = (int)*ptr2++;
4135 g = (int)*ptr2++;
4136 b = (int)*ptr2;
4137 if ((r == im->shape_color.r) &&
4138 (g == im->shape_color.g) &&
4139 (b == im->shape_color.b))
4140 {
4141 XPutPixel(sxim, x, y, 0);
4142 img += 3;
4143 }
4144 else
4145 {
4146 XPutPixel(sxim, x, y, 1);
4147 r = im->rmap[r];
4148 g = im->gmap[g];
4149 b = im->bmap[b];
4150 *img++ = r;
4151 *img++ = b;
4152 *img++ = g;
4153 }
4154 }
4155 img += jmp;
4156 }
4157 }
4158 else if (id->byte_order == BYTE_ORD_24_BRG)
4159 {
4160 for (y = 0; y < h; y++)
4161 {
4162 for (x = 0; x < w; x++)
4163 {
4164 ptr2 = yarray[y] + xarray[x];
4165 r = (int)*ptr2++;
4166 g = (int)*ptr2++;
4167 b = (int)*ptr2;
4168 if ((r == im->shape_color.r) &&
4169 (g == im->shape_color.g) &&
4170 (b == im->shape_color.b))
4171 {
4172 XPutPixel(sxim, x, y, 0);
4173 img += 3;
4174 }
4175 else
4176 {
4177 XPutPixel(sxim, x, y, 1);
4178 r = im->rmap[r];
4179 g = im->gmap[g];
4180 b = im->bmap[b];
4181 *img++ = b;
4182 *img++ = r;
4183 *img++ = g;
4184 }
4185 }
4186 img += jmp;
4187 }
4188 }
4189 else if (id->byte_order == BYTE_ORD_24_BGR)
4190 {
4191 for (y = 0; y < h; y++)
4192 {
4193 for (x = 0; x < w; x++)
4194 {
4195 ptr2 = yarray[y] + xarray[x];
4196 r = (int)*ptr2++;
4197 g = (int)*ptr2++;
4198 b = (int)*ptr2;
4199 if ((r == im->shape_color.r) &&
4200 (g == im->shape_color.g) &&
4201 (b == im->shape_color.b))
4202 {
4203 XPutPixel(sxim, x, y, 0);
4204 img += 3;
4205 }
4206 else
4207 {
4208 XPutPixel(sxim, x, y, 1);
4209 r = im->rmap[r];
4210 g = im->gmap[g];
4211 b = im->bmap[b];
4212 *img++ = b;
4213 *img++ = g;
4214 *img++ = r;
4215 }
4216 }
4217 img += jmp;
4218 }
4219 }
4220 else if (id->byte_order == BYTE_ORD_24_GRB)
4221 {
4222 for (y = 0; y < h; y++)
4223 {
4224 for (x = 0; x < w; x++)
4225 {
4226 ptr2 = yarray[y] + xarray[x];
4227 r = (int)*ptr2++;
4228 g = (int)*ptr2++;
4229 b = (int)*ptr2;
4230 if ((r == im->shape_color.r) &&
4231 (g == im->shape_color.g) &&
4232 (b == im->shape_color.b))
4233 {
4234 XPutPixel(sxim, x, y, 0);
4235 img += 3;
4236 }
4237 else
4238 {
4239 XPutPixel(sxim, x, y, 1);
4240 *img++ = g;
4241 *img++ = r;
4242 *img++ = b;
4243 r = im->rmap[r];
4244 g = im->gmap[g];
4245 b = im->bmap[b];
4246 }
4247 }
4248 img += jmp;
4249 }
4250 }
4251 else if (id->byte_order == BYTE_ORD_24_GBR)
4252 {
4253 for (y = 0; y < h; y++)
4254 {
4255 for (x = 0; x < w; x++)
4256 {
4257 ptr2 = yarray[y] + xarray[x];
4258 r = (int)*ptr2++;
4259 g = (int)*ptr2++;
4260 b = (int)*ptr2;
4261 if ((r == im->shape_color.r) &&
4262 (g == im->shape_color.g) &&
4263 (b == im->shape_color.b))
4264 {
4265 XPutPixel(sxim, x, y, 0);
4266 img += 3;
4267 }
4268 else
4269 {
4270 XPutPixel(sxim, x, y, 1);
4271 *img++ = g;
4272 *img++ = b;
4273 *img++ = r;
4274 r = im->rmap[r];
4275 g = im->gmap[g];
4276 b = im->bmap[b];
4277 }
4278 }
4279 img += jmp;
4280 }
4281 }
4282 }
4283 else
4284 {
4285 if (id->byte_order == BYTE_ORD_24_RGB)
4286 {
4287 for (y = 0; y < h; y++)
4288 {
4289 for (x = 0; x < w; x++)
4290 {
4291 ptr2 = yarray[y] + xarray[x];
4292 r = (int)*ptr2++;
4293 g = (int)*ptr2++;
4294 b = (int)*ptr2;
4295 if ((r == im->shape_color.r) &&
4296 (g == im->shape_color.g) &&
4297 (b == im->shape_color.b))
4298 {
4299 XPutPixel(sxim, x, y, 0);
4300 img += 3;
4301 }
4302 else
4303 {
4304 XPutPixel(sxim, x, y, 1);
4305 r = im->rmap[r];
4306 g = im->gmap[g];
4307 b = im->bmap[b];
4308 *img++ = b;
4309 *img++ = g;
4310 *img++ = r;
4311 }
4312 }
4313 img += jmp;
4314 }
4315 }
4316 else if (id->byte_order == BYTE_ORD_24_RBG)
4317 {
4318 for (y = 0; y < h; y++)
4319 {
4320 for (x = 0; x < w; x++)
4321 {
4322 ptr2 = yarray[y] + xarray[x];
4323 r = (int)*ptr2++;
4324 g = (int)*ptr2++;
4325 b = (int)*ptr2;
4326 if ((r == im->shape_color.r) &&
4327 (g == im->shape_color.g) &&
4328 (b == im->shape_color.b))
4329 {
4330 XPutPixel(sxim, x, y, 0);
4331 img += 3;
4332 }
4333 else
4334 {
4335 XPutPixel(sxim, x, y, 1);
4336 r = im->rmap[r];
4337 g = im->gmap[g];
4338 b = im->bmap[b];
4339 *img++ = g;
4340 *img++ = b;
4341 *img++ = r;
4342 }
4343 }
4344 img += jmp;
4345 }
4346 }
4347 else if (id->byte_order == BYTE_ORD_24_BRG)
4348 {
4349 for (y = 0; y < h; y++)
4350 {
4351 for (x = 0; x < w; x++)
4352 {
4353 ptr2 = yarray[y] + xarray[x];
4354 r = (int)*ptr2++;
4355 g = (int)*ptr2++;
4356 b = (int)*ptr2;
4357 if ((r == im->shape_color.r) &&
4358 (g == im->shape_color.g) &&
4359 (b == im->shape_color.b))
4360 {
4361 XPutPixel(sxim, x, y, 0);
4362 img += 3;
4363 }
4364 else
4365 {
4366 XPutPixel(sxim, x, y, 1);
4367 r = im->rmap[r];
4368 g = im->gmap[g];
4369 b = im->bmap[b];
4370 *img++ = g;
4371 *img++ = r;
4372 *img++ = b;
4373 }
4374 }
4375 img += jmp;
4376 }
4377 }
4378 else if (id->byte_order == BYTE_ORD_24_BGR)
4379 {
4380 for (y = 0; y < h; y++)
4381 {
4382 for (x = 0; x < w; x++)
4383 {
4384 ptr2 = yarray[y] + xarray[x];
4385 r = (int)*ptr2++;
4386 g = (int)*ptr2++;
4387 b = (int)*ptr2;
4388 if ((r == im->shape_color.r) &&
4389 (g == im->shape_color.g) &&
4390 (b == im->shape_color.b))
4391 {
4392 XPutPixel(sxim, x, y, 0);
4393 img += 3;
4394 }
4395 else
4396 {
4397 XPutPixel(sxim, x, y, 1);
4398 r = im->rmap[r];
4399 g = im->gmap[g];
4400 b = im->bmap[b];
4401 *img++ = r;
4402 *img++ = g;
4403 *img++ = b;
4404 }
4405 }
4406 img += jmp;
4407 }
4408 }
4409 else if (id->byte_order == BYTE_ORD_24_GRB)
4410 {
4411 for (y = 0; y < h; y++)
4412 {
4413 for (x = 0; x < w; x++)
4414 {
4415 ptr2 = yarray[y] + xarray[x];
4416 r = (int)*ptr2++;
4417 g = (int)*ptr2++;
4418 b = (int)*ptr2;
4419 if ((r == im->shape_color.r) &&
4420 (g == im->shape_color.g) &&
4421 (b == im->shape_color.b))
4422 {
4423 XPutPixel(sxim, x, y, 0);
4424 img += 3;
4425 }
4426 else
4427 {
4428 XPutPixel(sxim, x, y, 1);
4429 *img++ = b;
4430 *img++ = r;
4431 *img++ = g;
4432 r = im->rmap[r];
4433 g = im->gmap[g];
4434 b = im->bmap[b];
4435 }
4436 }
4437 img += jmp;
4438 }
4439 }
4440 else if (id->byte_order == BYTE_ORD_24_GBR)
4441 {
4442 for (y = 0; y < h; y++)
4443 {
4444 for (x = 0; x < w; x++)
4445 {
4446 ptr2 = yarray[y] + xarray[x];
4447 r = (int)*ptr2++;
4448 g = (int)*ptr2++;
4449 b = (int)*ptr2;
4450 if ((r == im->shape_color.r) &&
4451 (g == im->shape_color.g) &&
4452 (b == im->shape_color.b))
4453 {
4454 XPutPixel(sxim, x, y, 0);
4455 img += 3;
4456 }
4457 else
4458 {
4459 XPutPixel(sxim, x, y, 1);
4460 *img++ = r;
4461 *img++ = b;
4462 *img++ = g;
4463 r = im->rmap[r];
4464 g = im->gmap[g];
4465 b = im->bmap[b];
4466 }
4467 }
4468 img += jmp;
4469 }
4470 }
4471 }
4472 }
4473
4474 static void
render_24_fast_mod(ImlibData * id,ImlibImage * im,int w,int h,XImage * xim,XImage * sxim,int * er1,int * er2,int * xarray,unsigned char ** yarray)4475 render_24_fast_mod(ImlibData * id, ImlibImage * im, int w, int h, XImage * xim,
4476 XImage * sxim, int *er1, int *er2, int *xarray,
4477 unsigned char **yarray)
4478 {
4479 int x, y, r, g, b;
4480 unsigned char *ptr2;
4481 unsigned char *img;
4482 int jmp;
4483
4484 jmp = (xim->bytes_per_line) - w * 3;
4485 img = (unsigned char *)xim->data;
4486
4487 if (id->x.byte_order == MSBFirst)
4488 {
4489 if (id->byte_order == BYTE_ORD_24_RGB)
4490 {
4491 for (y = 0; y < h; y++)
4492 {
4493 for (x = 0; x < w; x++)
4494 {
4495 ptr2 = yarray[y] + xarray[x];
4496 r = (int)*ptr2++;
4497 g = (int)*ptr2++;
4498 b = (int)*ptr2;
4499 r = im->rmap[r];
4500 g = im->gmap[g];
4501 b = im->bmap[b];
4502 *img++ = r;
4503 *img++ = g;
4504 *img++ = b;
4505 }
4506 img += jmp;
4507 }
4508 }
4509 else if (id->byte_order == BYTE_ORD_24_RBG)
4510 {
4511 for (y = 0; y < h; y++)
4512 {
4513 for (x = 0; x < w; x++)
4514 {
4515 ptr2 = yarray[y] + xarray[x];
4516 r = (int)*ptr2++;
4517 g = (int)*ptr2++;
4518 b = (int)*ptr2;
4519 r = im->rmap[r];
4520 g = im->gmap[g];
4521 b = im->bmap[b];
4522 *img++ = r;
4523 *img++ = b;
4524 *img++ = g;
4525 }
4526 img += jmp;
4527 }
4528 }
4529 else if (id->byte_order == BYTE_ORD_24_BRG)
4530 {
4531 for (y = 0; y < h; y++)
4532 {
4533 for (x = 0; x < w; x++)
4534 {
4535 ptr2 = yarray[y] + xarray[x];
4536 r = (int)*ptr2++;
4537 g = (int)*ptr2++;
4538 b = (int)*ptr2;
4539 r = im->rmap[r];
4540 g = im->gmap[g];
4541 b = im->bmap[b];
4542 *img++ = b;
4543 *img++ = r;
4544 *img++ = g;
4545 }
4546 img += jmp;
4547 }
4548 }
4549 else if (id->byte_order == BYTE_ORD_24_BGR)
4550 {
4551 for (y = 0; y < h; y++)
4552 {
4553 for (x = 0; x < w; x++)
4554 {
4555 ptr2 = yarray[y] + xarray[x];
4556 r = (int)*ptr2++;
4557 g = (int)*ptr2++;
4558 b = (int)*ptr2;
4559 r = im->rmap[r];
4560 g = im->gmap[g];
4561 b = im->bmap[b];
4562 *img++ = b;
4563 *img++ = g;
4564 *img++ = r;
4565 }
4566 img += jmp;
4567 }
4568 }
4569 else if (id->byte_order == BYTE_ORD_24_GRB)
4570 {
4571 for (y = 0; y < h; y++)
4572 {
4573 for (x = 0; x < w; x++)
4574 {
4575 ptr2 = yarray[y] + xarray[x];
4576 r = (int)*ptr2++;
4577 g = (int)*ptr2++;
4578 b = (int)*ptr2;
4579 r = im->rmap[r];
4580 g = im->gmap[g];
4581 b = im->bmap[b];
4582 *img++ = g;
4583 *img++ = r;
4584 *img++ = b;
4585 }
4586 img += jmp;
4587 }
4588 }
4589 else if (id->byte_order == BYTE_ORD_24_GBR)
4590 {
4591 for (y = 0; y < h; y++)
4592 {
4593 for (x = 0; x < w; x++)
4594 {
4595 ptr2 = yarray[y] + xarray[x];
4596 r = (int)*ptr2++;
4597 g = (int)*ptr2++;
4598 b = (int)*ptr2;
4599 r = im->rmap[r];
4600 g = im->gmap[g];
4601 b = im->bmap[b];
4602 *img++ = g;
4603 *img++ = b;
4604 *img++ = r;
4605 }
4606 img += jmp;
4607 }
4608 }
4609 }
4610 else
4611 {
4612 if (id->byte_order == BYTE_ORD_24_RGB)
4613 {
4614 for (y = 0; y < h; y++)
4615 {
4616 for (x = 0; x < w; x++)
4617 {
4618 ptr2 = yarray[y] + xarray[x];
4619 r = (int)*ptr2++;
4620 g = (int)*ptr2++;
4621 b = (int)*ptr2;
4622 r = im->rmap[r];
4623 g = im->gmap[g];
4624 b = im->bmap[b];
4625 *img++ = b;
4626 *img++ = g;
4627 *img++ = r;
4628 }
4629 img += jmp;
4630 }
4631 }
4632 else if (id->byte_order == BYTE_ORD_24_RBG)
4633 {
4634 for (y = 0; y < h; y++)
4635 {
4636 for (x = 0; x < w; x++)
4637 {
4638 ptr2 = yarray[y] + xarray[x];
4639 r = (int)*ptr2++;
4640 g = (int)*ptr2++;
4641 b = (int)*ptr2;
4642 r = im->rmap[r];
4643 g = im->gmap[g];
4644 b = im->bmap[b];
4645 *img++ = g;
4646 *img++ = b;
4647 *img++ = r;
4648 }
4649 img += jmp;
4650 }
4651 }
4652 else if (id->byte_order == BYTE_ORD_24_BRG)
4653 {
4654 for (y = 0; y < h; y++)
4655 {
4656 for (x = 0; x < w; x++)
4657 {
4658 ptr2 = yarray[y] + xarray[x];
4659 r = (int)*ptr2++;
4660 g = (int)*ptr2++;
4661 b = (int)*ptr2;
4662 r = im->rmap[r];
4663 g = im->gmap[g];
4664 b = im->bmap[b];
4665 *img++ = g;
4666 *img++ = r;
4667 *img++ = b;
4668 }
4669 img += jmp;
4670 }
4671 }
4672 else if (id->byte_order == BYTE_ORD_24_BGR)
4673 {
4674 for (y = 0; y < h; y++)
4675 {
4676 for (x = 0; x < w; x++)
4677 {
4678 ptr2 = yarray[y] + xarray[x];
4679 r = (int)*ptr2++;
4680 g = (int)*ptr2++;
4681 b = (int)*ptr2;
4682 r = im->rmap[r];
4683 g = im->gmap[g];
4684 b = im->bmap[b];
4685 *img++ = r;
4686 *img++ = g;
4687 *img++ = b;
4688 }
4689 img += jmp;
4690 }
4691 }
4692 else if (id->byte_order == BYTE_ORD_24_GRB)
4693 {
4694 for (y = 0; y < h; y++)
4695 {
4696 for (x = 0; x < w; x++)
4697 {
4698 ptr2 = yarray[y] + xarray[x];
4699 r = (int)*ptr2++;
4700 g = (int)*ptr2++;
4701 b = (int)*ptr2;
4702 r = im->rmap[r];
4703 g = im->gmap[g];
4704 b = im->bmap[b];
4705 *img++ = b;
4706 *img++ = r;
4707 *img++ = g;
4708 }
4709 img += jmp;
4710 }
4711 }
4712 else if (id->byte_order == BYTE_ORD_24_GBR)
4713 {
4714 for (y = 0; y < h; y++)
4715 {
4716 for (x = 0; x < w; x++)
4717 {
4718 ptr2 = yarray[y] + xarray[x];
4719 r = (int)*ptr2++;
4720 g = (int)*ptr2++;
4721 b = (int)*ptr2;
4722 r = im->rmap[r];
4723 g = im->gmap[g];
4724 b = im->bmap[b];
4725 *img++ = r;
4726 *img++ = b;
4727 *img++ = g;
4728 }
4729 img += jmp;
4730 }
4731 }
4732 }
4733 }
4734
4735 static void
render_shaped_32_fast_mod(ImlibData * id,ImlibImage * im,int w,int h,XImage * xim,XImage * sxim,int * er1,int * er2,int * xarray,unsigned char ** yarray)4736 render_shaped_32_fast_mod(ImlibData * id, ImlibImage * im, int w, int h, XImage * xim,
4737 XImage * sxim, int *er1, int *er2, int *xarray,
4738 unsigned char **yarray)
4739 {
4740 int x, y, val, r, g, b;
4741 unsigned char *ptr2;
4742 unsigned int *img;
4743 int jmp;
4744
4745 jmp = (xim->bytes_per_line >> 2) - w;
4746 img = (unsigned int *)xim->data;
4747 if (id->byte_order == BYTE_ORD_24_RGB)
4748 {
4749 for (y = 0; y < h; y++)
4750 {
4751 for (x = 0; x < w; x++)
4752 {
4753 ptr2 = yarray[y] + xarray[x];
4754 r = (int)*ptr2++;
4755 g = (int)*ptr2++;
4756 b = (int)*ptr2;
4757 if ((r == im->shape_color.r) &&
4758 (g == im->shape_color.g) &&
4759 (b == im->shape_color.b))
4760 {
4761 XPutPixel(sxim, x, y, 0);
4762 img++;
4763 }
4764 else
4765 {
4766 XPutPixel(sxim, x, y, 1);
4767 r = im->rmap[r];
4768 g = im->gmap[g];
4769 b = im->bmap[b];
4770 val = (r << 16) | (g << 8) | b;
4771 *img++ = val;
4772 }
4773 }
4774 img += jmp;
4775 }
4776 }
4777 else if (id->byte_order == BYTE_ORD_24_RBG)
4778 {
4779 for (y = 0; y < h; y++)
4780 {
4781 for (x = 0; x < w; x++)
4782 {
4783 ptr2 = yarray[y] + xarray[x];
4784 r = (int)*ptr2++;
4785 g = (int)*ptr2++;
4786 b = (int)*ptr2;
4787 if ((r == im->shape_color.r) &&
4788 (g == im->shape_color.g) &&
4789 (b == im->shape_color.b))
4790 {
4791 XPutPixel(sxim, x, y, 0);
4792 img++;
4793 }
4794 else
4795 {
4796 XPutPixel(sxim, x, y, 1);
4797 r = im->rmap[r];
4798 g = im->gmap[g];
4799 b = im->bmap[b];
4800 val = (r << 16) | (b << 8) | g;
4801 *img++ = val;
4802 }
4803 }
4804 img += jmp;
4805 }
4806 }
4807 else if (id->byte_order == BYTE_ORD_24_BRG)
4808 {
4809 for (y = 0; y < h; y++)
4810 {
4811 for (x = 0; x < w; x++)
4812 {
4813 ptr2 = yarray[y] + xarray[x];
4814 r = (int)*ptr2++;
4815 g = (int)*ptr2++;
4816 b = (int)*ptr2;
4817 if ((r == im->shape_color.r) &&
4818 (g == im->shape_color.g) &&
4819 (b == im->shape_color.b))
4820 {
4821 XPutPixel(sxim, x, y, 0);
4822 img++;
4823 }
4824 else
4825 {
4826 XPutPixel(sxim, x, y, 1);
4827 r = im->rmap[r];
4828 g = im->gmap[g];
4829 b = im->bmap[b];
4830 val = (b << 16) | (r << 8) | g;
4831 *img++ = val;
4832 }
4833 }
4834 img += jmp;
4835 }
4836 }
4837 else if (id->byte_order == BYTE_ORD_24_BGR)
4838 {
4839 for (y = 0; y < h; y++)
4840 {
4841 for (x = 0; x < w; x++)
4842 {
4843 ptr2 = yarray[y] + xarray[x];
4844 r = (int)*ptr2++;
4845 g = (int)*ptr2++;
4846 b = (int)*ptr2;
4847 if ((r == im->shape_color.r) &&
4848 (g == im->shape_color.g) &&
4849 (b == im->shape_color.b))
4850 {
4851 XPutPixel(sxim, x, y, 0);
4852 img++;
4853 }
4854 else
4855 {
4856 XPutPixel(sxim, x, y, 1);
4857 r = im->rmap[r];
4858 g = im->gmap[g];
4859 b = im->bmap[b];
4860 val = (b << 16) | (g << 8) | r;
4861 *img++ = val;
4862 }
4863 }
4864 img += jmp;
4865 }
4866 }
4867 else if (id->byte_order == BYTE_ORD_24_GRB)
4868 {
4869 for (y = 0; y < h; y++)
4870 {
4871 for (x = 0; x < w; x++)
4872 {
4873 ptr2 = yarray[y] + xarray[x];
4874 r = (int)*ptr2++;
4875 g = (int)*ptr2++;
4876 b = (int)*ptr2;
4877 if ((r == im->shape_color.r) &&
4878 (g == im->shape_color.g) &&
4879 (b == im->shape_color.b))
4880 {
4881 XPutPixel(sxim, x, y, 0);
4882 img++;
4883 }
4884 else
4885 {
4886 XPutPixel(sxim, x, y, 1);
4887 r = im->rmap[r];
4888 g = im->gmap[g];
4889 b = im->bmap[b];
4890 val = (g << 16) | (r << 8) | b;
4891 *img++ = val;
4892 }
4893 }
4894 img += jmp;
4895 }
4896 }
4897 else if (id->byte_order == BYTE_ORD_24_GBR)
4898 {
4899 for (y = 0; y < h; y++)
4900 {
4901 for (x = 0; x < w; x++)
4902 {
4903 ptr2 = yarray[y] + xarray[x];
4904 r = (int)*ptr2++;
4905 g = (int)*ptr2++;
4906 b = (int)*ptr2;
4907 if ((r == im->shape_color.r) &&
4908 (g == im->shape_color.g) &&
4909 (b == im->shape_color.b))
4910 {
4911 XPutPixel(sxim, x, y, 0);
4912 img++;
4913 }
4914 else
4915 {
4916 XPutPixel(sxim, x, y, 1);
4917 r = im->rmap[r];
4918 g = im->gmap[g];
4919 b = im->bmap[b];
4920 val = (g << 16) | (b << 8) | r;
4921 *img++ = val;
4922 }
4923 }
4924 img += jmp;
4925 }
4926 }
4927 }
4928
4929 static void
render_32_fast_mod(ImlibData * id,ImlibImage * im,int w,int h,XImage * xim,XImage * sxim,int * er1,int * er2,int * xarray,unsigned char ** yarray)4930 render_32_fast_mod(ImlibData * id, ImlibImage * im, int w, int h, XImage * xim,
4931 XImage * sxim, int *er1, int *er2, int *xarray,
4932 unsigned char **yarray)
4933 {
4934 int x, y, val, r, g, b;
4935 unsigned char *ptr2;
4936 unsigned int *img;
4937 int jmp;
4938
4939 jmp = (xim->bytes_per_line >> 2) - w;
4940 img = (unsigned int *)xim->data;
4941 if (id->byte_order == BYTE_ORD_24_RGB)
4942 {
4943 for (y = 0; y < h; y++)
4944 {
4945 for (x = 0; x < w; x++)
4946 {
4947 ptr2 = yarray[y] + xarray[x];
4948 r = (int)*ptr2++;
4949 g = (int)*ptr2++;
4950 b = (int)*ptr2;
4951 r = im->rmap[r];
4952 g = im->gmap[g];
4953 b = im->bmap[b];
4954 val = (r << 16) | (g << 8) | b;
4955 *img++ = val;
4956 }
4957 img += jmp;
4958 }
4959 }
4960 else if (id->byte_order == BYTE_ORD_24_RBG)
4961 {
4962 for (y = 0; y < h; y++)
4963 {
4964 for (x = 0; x < w; x++)
4965 {
4966 ptr2 = yarray[y] + xarray[x];
4967 r = (int)*ptr2++;
4968 g = (int)*ptr2++;
4969 b = (int)*ptr2;
4970 r = im->rmap[r];
4971 g = im->gmap[g];
4972 b = im->bmap[b];
4973 val = (r << 16) | (b << 8) | g;
4974 *img++ = val;
4975 }
4976 img += jmp;
4977 }
4978 }
4979 else if (id->byte_order == BYTE_ORD_24_BRG)
4980 {
4981 for (y = 0; y < h; y++)
4982 {
4983 for (x = 0; x < w; x++)
4984 {
4985 ptr2 = yarray[y] + xarray[x];
4986 r = (int)*ptr2++;
4987 g = (int)*ptr2++;
4988 b = (int)*ptr2;
4989 r = im->rmap[r];
4990 g = im->gmap[g];
4991 b = im->bmap[b];
4992 val = (b << 16) | (r << 8) | g;
4993 *img++ = val;
4994 }
4995 img += jmp;
4996 }
4997 }
4998 else if (id->byte_order == BYTE_ORD_24_BGR)
4999 {
5000 for (y = 0; y < h; y++)
5001 {
5002 for (x = 0; x < w; x++)
5003 {
5004 ptr2 = yarray[y] + xarray[x];
5005 r = (int)*ptr2++;
5006 g = (int)*ptr2++;
5007 b = (int)*ptr2;
5008 r = im->rmap[r];
5009 g = im->gmap[g];
5010 b = im->bmap[b];
5011 val = (b << 16) | (g << 8) | r;
5012 *img++ = val;
5013 }
5014 img += jmp;
5015 }
5016 }
5017 else if (id->byte_order == BYTE_ORD_24_GRB)
5018 {
5019 for (y = 0; y < h; y++)
5020 {
5021 for (x = 0; x < w; x++)
5022 {
5023 ptr2 = yarray[y] + xarray[x];
5024 r = (int)*ptr2++;
5025 g = (int)*ptr2++;
5026 b = (int)*ptr2;
5027 r = im->rmap[r];
5028 g = im->gmap[g];
5029 b = im->bmap[b];
5030 val = (g << 16) | (r << 8) | b;
5031 *img++ = val;
5032 }
5033 img += jmp;
5034 }
5035 }
5036 else if (id->byte_order == BYTE_ORD_24_GBR)
5037 {
5038 for (y = 0; y < h; y++)
5039 {
5040 for (x = 0; x < w; x++)
5041 {
5042 ptr2 = yarray[y] + xarray[x];
5043 r = (int)*ptr2++;
5044 g = (int)*ptr2++;
5045 b = (int)*ptr2;
5046 r = im->rmap[r];
5047 g = im->gmap[g];
5048 b = im->bmap[b];
5049 val = (g << 16) | (b << 8) | r;
5050 *img++ = val;
5051 }
5052 img += jmp;
5053 }
5054 }
5055 }
5056
5057 static void
render_shaped_15_mod(ImlibData * id,ImlibImage * im,int w,int h,XImage * xim,XImage * sxim,int * er1,int * er2,int * xarray,unsigned char ** yarray)5058 render_shaped_15_mod(ImlibData * id, ImlibImage * im, int w, int h, XImage * xim,
5059 XImage * sxim, int *er1, int *er2, int *xarray,
5060 unsigned char **yarray)
5061 {
5062 int x, y, val, r, g, b;
5063 unsigned char *ptr2;
5064
5065 for (y = 0; y < h; y++)
5066 {
5067 for (x = 0; x < w; x++)
5068 {
5069 ptr2 = yarray[y] + xarray[x];
5070 r = (int)*ptr2++;
5071 g = (int)*ptr2++;
5072 b = (int)*ptr2;
5073 if ((r == im->shape_color.r) &&
5074 (g == im->shape_color.g) &&
5075 (b == im->shape_color.b))
5076 XPutPixel(sxim, x, y, 0);
5077 else
5078 {
5079 XPutPixel(sxim, x, y, 1);
5080 r = im->rmap[r];
5081 g = im->gmap[g];
5082 b = im->bmap[b];
5083 val = ((r & 0xf8) << 7) | ((g & 0xf8) << 2) | ((b & 0xf8) >> 3);
5084 XPutPixel(xim, x, y, val);
5085 }
5086 }
5087 }
5088 }
5089
5090 static void
render_15_mod(ImlibData * id,ImlibImage * im,int w,int h,XImage * xim,XImage * sxim,int * er1,int * er2,int * xarray,unsigned char ** yarray)5091 render_15_mod(ImlibData * id, ImlibImage * im, int w, int h, XImage * xim,
5092 XImage * sxim, int *er1, int *er2, int *xarray,
5093 unsigned char **yarray)
5094 {
5095 int x, y, val, r, g, b;
5096 unsigned char *ptr2;
5097
5098 for (y = 0; y < h; y++)
5099 {
5100 for (x = 0; x < w; x++)
5101 {
5102 ptr2 = yarray[y] + xarray[x];
5103 r = (int)*ptr2++;
5104 g = (int)*ptr2++;
5105 b = (int)*ptr2;
5106 r = im->rmap[r];
5107 g = im->gmap[g];
5108 b = im->bmap[b];
5109 val = ((r & 0xf8) << 7) | ((g & 0xf8) << 2) | ((b & 0xf8) >> 3);
5110 XPutPixel(xim, x, y, val);
5111 }
5112 }
5113 }
5114
5115 static void
render_shaped_16_mod(ImlibData * id,ImlibImage * im,int w,int h,XImage * xim,XImage * sxim,int * er1,int * er2,int * xarray,unsigned char ** yarray)5116 render_shaped_16_mod(ImlibData * id, ImlibImage * im, int w, int h, XImage * xim,
5117 XImage * sxim, int *er1, int *er2, int *xarray,
5118 unsigned char **yarray)
5119 {
5120 int x, y, val, r, g, b;
5121 unsigned char *ptr2;
5122
5123 for (y = 0; y < h; y++)
5124 {
5125 for (x = 0; x < w; x++)
5126 {
5127 ptr2 = yarray[y] + xarray[x];
5128 r = (int)*ptr2++;
5129 g = (int)*ptr2++;
5130 b = (int)*ptr2;
5131 if ((r == im->shape_color.r) &&
5132 (g == im->shape_color.g) &&
5133 (b == im->shape_color.b))
5134 XPutPixel(sxim, x, y, 0);
5135 else
5136 {
5137 XPutPixel(sxim, x, y, 1);
5138 r = im->rmap[r];
5139 g = im->gmap[g];
5140 b = im->bmap[b];
5141 val = ((r & 0xf8) << 8) | ((g & 0xfc) << 3) | ((b & 0xf8) >> 3);
5142 XPutPixel(xim, x, y, val);
5143 }
5144 }
5145 }
5146 }
5147
5148 static void
render_16_mod(ImlibData * id,ImlibImage * im,int w,int h,XImage * xim,XImage * sxim,int * er1,int * er2,int * xarray,unsigned char ** yarray)5149 render_16_mod(ImlibData * id, ImlibImage * im, int w, int h, XImage * xim,
5150 XImage * sxim, int *er1, int *er2, int *xarray,
5151 unsigned char **yarray)
5152 {
5153 int x, y, val, r, g, b;
5154 unsigned char *ptr2;
5155
5156 for (y = 0; y < h; y++)
5157 {
5158 for (x = 0; x < w; x++)
5159 {
5160 ptr2 = yarray[y] + xarray[x];
5161 r = (int)*ptr2++;
5162 g = (int)*ptr2++;
5163 b = (int)*ptr2;
5164 r = im->rmap[r];
5165 g = im->gmap[g];
5166 b = im->bmap[b];
5167 val = ((r & 0xf8) << 8) | ((g & 0xfc) << 3) | ((b & 0xf8) >> 3);
5168 XPutPixel(xim, x, y, val);
5169 }
5170 }
5171 }
5172
5173 static void
render_shaped_24_mod(ImlibData * id,ImlibImage * im,int w,int h,XImage * xim,XImage * sxim,int * er1,int * er2,int * xarray,unsigned char ** yarray)5174 render_shaped_24_mod(ImlibData * id, ImlibImage * im, int w, int h, XImage * xim,
5175 XImage * sxim, int *er1, int *er2, int *xarray,
5176 unsigned char **yarray)
5177 {
5178 int x, y, val, r, g, b;
5179 unsigned char *ptr2;
5180
5181 if (id->byte_order == BYTE_ORD_24_RGB)
5182 {
5183 for (y = 0; y < h; y++)
5184 {
5185 for (x = 0; x < w; x++)
5186 {
5187 ptr2 = yarray[y] + xarray[x];
5188 r = (int)*ptr2++;
5189 g = (int)*ptr2++;
5190 b = (int)*ptr2;
5191 if ((r == im->shape_color.r) &&
5192 (g == im->shape_color.g) &&
5193 (b == im->shape_color.b))
5194 XPutPixel(sxim, x, y, 0);
5195 else
5196 {
5197 XPutPixel(sxim, x, y, 1);
5198 r = im->rmap[r];
5199 g = im->gmap[g];
5200 b = im->bmap[b];
5201 val = (r << 16) | (g << 8) | b;
5202 XPutPixel(xim, x, y, val);
5203 }
5204 }
5205 }
5206 }
5207 else if (id->byte_order == BYTE_ORD_24_RBG)
5208 {
5209 for (y = 0; y < h; y++)
5210 {
5211 for (x = 0; x < w; x++)
5212 {
5213 ptr2 = yarray[y] + xarray[x];
5214 r = (int)*ptr2++;
5215 g = (int)*ptr2++;
5216 b = (int)*ptr2;
5217 if ((r == im->shape_color.r) &&
5218 (g == im->shape_color.g) &&
5219 (b == im->shape_color.b))
5220 XPutPixel(sxim, x, y, 0);
5221 else
5222 {
5223 XPutPixel(sxim, x, y, 1);
5224 r = im->rmap[r];
5225 g = im->gmap[g];
5226 b = im->bmap[b];
5227 val = (r << 16) | (b << 8) | g;
5228 XPutPixel(xim, x, y, val);
5229 }
5230 }
5231 }
5232 }
5233 else if (id->byte_order == BYTE_ORD_24_BRG)
5234 {
5235 for (y = 0; y < h; y++)
5236 {
5237 for (x = 0; x < w; x++)
5238 {
5239 ptr2 = yarray[y] + xarray[x];
5240 r = (int)*ptr2++;
5241 g = (int)*ptr2++;
5242 b = (int)*ptr2;
5243 if ((r == im->shape_color.r) &&
5244 (g == im->shape_color.g) &&
5245 (b == im->shape_color.b))
5246 XPutPixel(sxim, x, y, 0);
5247 else
5248 {
5249 XPutPixel(sxim, x, y, 1);
5250 r = im->rmap[r];
5251 g = im->gmap[g];
5252 b = im->bmap[b];
5253 val = (b << 16) | (r << 8) | g;
5254 XPutPixel(xim, x, y, val);
5255 }
5256 }
5257 }
5258 }
5259 else if (id->byte_order == BYTE_ORD_24_BGR)
5260 {
5261 for (y = 0; y < h; y++)
5262 {
5263 for (x = 0; x < w; x++)
5264 {
5265 ptr2 = yarray[y] + xarray[x];
5266 r = (int)*ptr2++;
5267 g = (int)*ptr2++;
5268 b = (int)*ptr2;
5269 if ((r == im->shape_color.r) &&
5270 (g == im->shape_color.g) &&
5271 (b == im->shape_color.b))
5272 XPutPixel(sxim, x, y, 0);
5273 else
5274 {
5275 XPutPixel(sxim, x, y, 1);
5276 r = im->rmap[r];
5277 g = im->gmap[g];
5278 b = im->bmap[b];
5279 val = (b << 16) | (g << 8) | r;
5280 XPutPixel(xim, x, y, val);
5281 }
5282 }
5283 }
5284 }
5285 else if (id->byte_order == BYTE_ORD_24_GRB)
5286 {
5287 for (y = 0; y < h; y++)
5288 {
5289 for (x = 0; x < w; x++)
5290 {
5291 ptr2 = yarray[y] + xarray[x];
5292 r = (int)*ptr2++;
5293 g = (int)*ptr2++;
5294 b = (int)*ptr2;
5295 if ((r == im->shape_color.r) &&
5296 (g == im->shape_color.g) &&
5297 (b == im->shape_color.b))
5298 XPutPixel(sxim, x, y, 0);
5299 else
5300 {
5301 XPutPixel(sxim, x, y, 1);
5302 r = im->rmap[r];
5303 g = im->gmap[g];
5304 b = im->bmap[b];
5305 val = (g << 16) | (r << 8) | b;
5306 XPutPixel(xim, x, y, val);
5307 }
5308 }
5309 }
5310 }
5311 else if (id->byte_order == BYTE_ORD_24_GBR)
5312 {
5313 for (y = 0; y < h; y++)
5314 {
5315 for (x = 0; x < w; x++)
5316 {
5317 ptr2 = yarray[y] + xarray[x];
5318 r = (int)*ptr2++;
5319 g = (int)*ptr2++;
5320 b = (int)*ptr2;
5321 if ((r == im->shape_color.r) &&
5322 (g == im->shape_color.g) &&
5323 (b == im->shape_color.b))
5324 XPutPixel(sxim, x, y, 0);
5325 else
5326 {
5327 XPutPixel(sxim, x, y, 1);
5328 r = im->rmap[r];
5329 g = im->gmap[g];
5330 b = im->bmap[b];
5331 val = (g << 16) | (b << 8) | r;
5332 XPutPixel(xim, x, y, val);
5333 }
5334 }
5335 }
5336 }
5337 }
5338
5339 static void
render_24_mod(ImlibData * id,ImlibImage * im,int w,int h,XImage * xim,XImage * sxim,int * er1,int * er2,int * xarray,unsigned char ** yarray)5340 render_24_mod(ImlibData * id, ImlibImage * im, int w, int h, XImage * xim,
5341 XImage * sxim, int *er1, int *er2, int *xarray,
5342 unsigned char **yarray)
5343 {
5344 int x, y, val, r, g, b;
5345 unsigned char *ptr2;
5346
5347 if (id->byte_order == BYTE_ORD_24_RGB)
5348 {
5349 for (y = 0; y < h; y++)
5350 {
5351 for (x = 0; x < w; x++)
5352 {
5353 ptr2 = yarray[y] + xarray[x];
5354 r = (int)*ptr2++;
5355 g = (int)*ptr2++;
5356 b = (int)*ptr2;
5357 r = im->rmap[r];
5358 g = im->gmap[g];
5359 b = im->bmap[b];
5360 val = (r << 16) | (g << 8) | b;
5361 XPutPixel(xim, x, y, val);
5362 }
5363 }
5364 }
5365 else if (id->byte_order == BYTE_ORD_24_RBG)
5366 {
5367 for (y = 0; y < h; y++)
5368 {
5369 for (x = 0; x < w; x++)
5370 {
5371 ptr2 = yarray[y] + xarray[x];
5372 r = (int)*ptr2++;
5373 g = (int)*ptr2++;
5374 b = (int)*ptr2;
5375 r = im->rmap[r];
5376 g = im->gmap[g];
5377 b = im->bmap[b];
5378 val = (r << 16) | (b << 8) | g;
5379 XPutPixel(xim, x, y, val);
5380 }
5381 }
5382 }
5383 else if (id->byte_order == BYTE_ORD_24_BRG)
5384 {
5385 for (y = 0; y < h; y++)
5386 {
5387 for (x = 0; x < w; x++)
5388 {
5389 ptr2 = yarray[y] + xarray[x];
5390 r = (int)*ptr2++;
5391 g = (int)*ptr2++;
5392 b = (int)*ptr2;
5393 r = im->rmap[r];
5394 g = im->gmap[g];
5395 b = im->bmap[b];
5396 val = (b << 16) | (r << 8) | g;
5397 XPutPixel(xim, x, y, val);
5398 }
5399 }
5400 }
5401 else if (id->byte_order == BYTE_ORD_24_BGR)
5402 {
5403 for (y = 0; y < h; y++)
5404 {
5405 for (x = 0; x < w; x++)
5406 {
5407 ptr2 = yarray[y] + xarray[x];
5408 r = (int)*ptr2++;
5409 g = (int)*ptr2++;
5410 b = (int)*ptr2;
5411 r = im->rmap[r];
5412 g = im->gmap[g];
5413 b = im->bmap[b];
5414 val = (b << 16) | (g << 8) | r;
5415 XPutPixel(xim, x, y, val);
5416 }
5417 }
5418 }
5419 else if (id->byte_order == BYTE_ORD_24_GRB)
5420 {
5421 for (y = 0; y < h; y++)
5422 {
5423 for (x = 0; x < w; x++)
5424 {
5425 ptr2 = yarray[y] + xarray[x];
5426 r = (int)*ptr2++;
5427 g = (int)*ptr2++;
5428 b = (int)*ptr2;
5429 r = im->rmap[r];
5430 g = im->gmap[g];
5431 b = im->bmap[b];
5432 val = (g << 16) | (r << 8) | b;
5433 XPutPixel(xim, x, y, val);
5434 }
5435 }
5436 }
5437 else if (id->byte_order == BYTE_ORD_24_GBR)
5438 {
5439 for (y = 0; y < h; y++)
5440 {
5441 for (x = 0; x < w; x++)
5442 {
5443 ptr2 = yarray[y] + xarray[x];
5444 r = (int)*ptr2++;
5445 g = (int)*ptr2++;
5446 b = (int)*ptr2;
5447 r = im->rmap[r];
5448 g = im->gmap[g];
5449 b = im->bmap[b];
5450 val = (g << 16) | (b << 8) | r;
5451 XPutPixel(xim, x, y, val);
5452 }
5453 }
5454 }
5455 }
5456
5457 static void
render_shaped_mod(ImlibData * id,ImlibImage * im,int w,int h,XImage * xim,XImage * sxim,int * er1,int * er2,int * xarray,unsigned char ** yarray,int bpp)5458 render_shaped_mod(ImlibData * id, ImlibImage * im, int w, int h, XImage * xim,
5459 XImage * sxim, int *er1, int *er2, int *xarray,
5460 unsigned char **yarray, int bpp)
5461 {
5462 int x, y, val, r, g, b, *ter, ex, er, eg, eb;
5463 unsigned char *ptr2;
5464 unsigned char *img;
5465 int jmp;
5466
5467 jmp = (xim->bytes_per_line) - w * (bpp >> 3);
5468 img = (unsigned char *)xim->data;
5469 switch (id->render_type)
5470 {
5471 case RT_PLAIN_PALETTE:
5472 if ((id->fastrend) && (xim->bits_per_pixel == 8))
5473 {
5474 for (y = 0; y < h; y++)
5475 {
5476 for (x = 0; x < w; x++)
5477 {
5478 ptr2 = yarray[y] + xarray[x];
5479 r = (int)*ptr2++;
5480 g = (int)*ptr2++;
5481 b = (int)*ptr2;
5482 if ((r == im->shape_color.r) &&
5483 (g == im->shape_color.g) &&
5484 (b == im->shape_color.b))
5485 {
5486 XPutPixel(sxim, x, y, 0);
5487 img++;
5488 }
5489 else
5490 {
5491 XPutPixel(sxim, x, y, 1);
5492 r = im->rmap[r];
5493 g = im->gmap[g];
5494 b = im->bmap[b];
5495 val = Imlib_best_color_match(id, &r, &g, &b);
5496 *img++ = val;
5497 }
5498 }
5499 img += jmp;
5500 }
5501 }
5502 else
5503 {
5504 for (y = 0; y < h; y++)
5505 {
5506 for (x = 0; x < w; x++)
5507 {
5508 ptr2 = yarray[y] + xarray[x];
5509 r = (int)*ptr2++;
5510 g = (int)*ptr2++;
5511 b = (int)*ptr2;
5512 if ((r == im->shape_color.r) &&
5513 (g == im->shape_color.g) &&
5514 (b == im->shape_color.b))
5515 XPutPixel(sxim, x, y, 0);
5516 else
5517 {
5518 XPutPixel(sxim, x, y, 1);
5519 r = im->rmap[r];
5520 g = im->gmap[g];
5521 b = im->bmap[b];
5522 val = Imlib_best_color_match(id, &r, &g, &b);
5523 XPutPixel(xim, x, y, val);
5524 }
5525 }
5526 }
5527 }
5528 break;
5529 case RT_PLAIN_PALETTE_FAST:
5530 if ((id->fastrend) && (xim->bits_per_pixel == 8))
5531 {
5532 for (y = 0; y < h; y++)
5533 {
5534 for (x = 0; x < w; x++)
5535 {
5536 ptr2 = yarray[y] + xarray[x];
5537 r = (int)*ptr2++;
5538 g = (int)*ptr2++;
5539 b = (int)*ptr2;
5540 if ((r == im->shape_color.r) &&
5541 (g == im->shape_color.g) &&
5542 (b == im->shape_color.b))
5543 {
5544 XPutPixel(sxim, x, y, 0);
5545 img++;
5546 }
5547 else
5548 {
5549 XPutPixel(sxim, x, y, 1);
5550 r = im->rmap[r];
5551 g = im->gmap[g];
5552 b = im->bmap[b];
5553 val = COLOR_RGB(r >> 3, g >> 3, b >> 3);
5554 *img++ = val;
5555 }
5556 }
5557 img += jmp;
5558 }
5559 }
5560 else
5561 {
5562 for (y = 0; y < h; y++)
5563 {
5564 for (x = 0; x < w; x++)
5565 {
5566 ptr2 = yarray[y] + xarray[x];
5567 r = (int)*ptr2++;
5568 g = (int)*ptr2++;
5569 b = (int)*ptr2;
5570 if ((r == im->shape_color.r) &&
5571 (g == im->shape_color.g) &&
5572 (b == im->shape_color.b))
5573 XPutPixel(sxim, x, y, 0);
5574 else
5575 {
5576 XPutPixel(sxim, x, y, 1);
5577 r = im->rmap[r];
5578 g = im->gmap[g];
5579 b = im->bmap[b];
5580 val = COLOR_RGB(r >> 3, g >> 3, b >> 3);
5581 XPutPixel(xim, x, y, val);
5582 }
5583 }
5584 }
5585 }
5586 break;
5587 case RT_DITHER_PALETTE:
5588 if ((id->fastrend) && (xim->bits_per_pixel == 8))
5589 {
5590 for (y = 0; y < h; y++)
5591 {
5592 ter = er1;
5593 er1 = er2;
5594 er2 = ter;
5595 for (ex = 0; ex < (w + 2) * 3; ex++)
5596 er2[ex] = 0;
5597 ex = 3;
5598 for (x = 0; x < w; x++)
5599 {
5600 ptr2 = yarray[y] + xarray[x];
5601 r = (int)*ptr2++;
5602 g = (int)*ptr2++;
5603 b = (int)*ptr2;
5604 if ((r == im->shape_color.r) &&
5605 (g == im->shape_color.g) &&
5606 (b == im->shape_color.b))
5607 {
5608 {
5609 XPutPixel(sxim, x, y, 0);
5610 img++;
5611 }
5612 ex += 3;
5613 }
5614 else
5615 {
5616 XPutPixel(sxim, x, y, 1);
5617 r = im->rmap[r];
5618 g = im->gmap[g];
5619 b = im->bmap[b];
5620 er = r + er1[ex++];
5621 eg = g + er1[ex++];
5622 eb = b + er1[ex++];
5623 if (er > 255)
5624 er = 255;
5625 else if (er < 0)
5626 er = 0;
5627 if (eg > 255)
5628 eg = 255;
5629 else if (eg < 0)
5630 eg = 0;
5631 if (eb > 255)
5632 eb = 255;
5633 else if (eb < 0)
5634 eb = 0;
5635 val = Imlib_best_color_match(id, &er, &eg, &eb);
5636 DITHER_ERROR(er1, er2, ex, er, eg, eb);
5637 *img++ = val;
5638 }
5639 }
5640 img += jmp;
5641 }
5642 }
5643 else
5644 {
5645 for (y = 0; y < h; y++)
5646 {
5647 ter = er1;
5648 er1 = er2;
5649 er2 = ter;
5650 for (ex = 0; ex < (w + 2) * 3; ex++)
5651 er2[ex] = 0;
5652 ex = 3;
5653 for (x = 0; x < w; x++)
5654 {
5655 ptr2 = yarray[y] + xarray[x];
5656 r = (int)*ptr2++;
5657 g = (int)*ptr2++;
5658 b = (int)*ptr2;
5659 if ((r == im->shape_color.r) &&
5660 (g == im->shape_color.g) &&
5661 (b == im->shape_color.b))
5662 {
5663 XPutPixel(sxim, x, y, 0);
5664 ex += 3;
5665 }
5666 else
5667 {
5668 XPutPixel(sxim, x, y, 1);
5669 r = im->rmap[r];
5670 g = im->gmap[g];
5671 b = im->bmap[b];
5672 er = r + er1[ex++];
5673 eg = g + er1[ex++];
5674 eb = b + er1[ex++];
5675 if (er > 255)
5676 er = 255;
5677 else if (er < 0)
5678 er = 0;
5679 if (eg > 255)
5680 eg = 255;
5681 else if (eg < 0)
5682 eg = 0;
5683 if (eb > 255)
5684 eb = 255;
5685 else if (eb < 0)
5686 eb = 0;
5687 val = Imlib_best_color_match(id, &er, &eg, &eb);
5688 DITHER_ERROR(er1, er2, ex, er, eg, eb);
5689 XPutPixel(xim, x, y, val);
5690 }
5691 }
5692 }
5693 }
5694 break;
5695 case RT_DITHER_PALETTE_FAST:
5696 if ((id->fastrend) && (xim->bits_per_pixel == 8))
5697 {
5698 for (y = 0; y < h; y++)
5699 {
5700 ter = er1;
5701 er1 = er2;
5702 er2 = ter;
5703 for (ex = 0; ex < (w + 2) * 3; ex++)
5704 er2[ex] = 0;
5705 ex = 3;
5706 for (x = 0; x < w; x++)
5707 {
5708 ptr2 = yarray[y] + xarray[x];
5709 r = (int)*ptr2++;
5710 g = (int)*ptr2++;
5711 b = (int)*ptr2;
5712 if ((r == im->shape_color.r) &&
5713 (g == im->shape_color.g) &&
5714 (b == im->shape_color.b))
5715 {
5716 {
5717 XPutPixel(sxim, x, y, 0);
5718 img++;
5719 }
5720 ex += 3;
5721 }
5722 else
5723 {
5724 XPutPixel(sxim, x, y, 1);
5725 r = im->rmap[r];
5726 g = im->gmap[g];
5727 b = im->bmap[b];
5728 er = r + er1[ex++];
5729 eg = g + er1[ex++];
5730 eb = b + er1[ex++];
5731 if (er > 255)
5732 er = 255;
5733 else if (er < 0)
5734 er = 0;
5735 if (eg > 255)
5736 eg = 255;
5737 else if (eg < 0)
5738 eg = 0;
5739 if (eb > 255)
5740 eb = 255;
5741 else if (eb < 0)
5742 eb = 0;
5743 val = INDEX_RGB(er >> 3, eg >> 3, eb >> 3);
5744 er = ERROR_RED(er, val);
5745 eg = ERROR_GRN(eg, val);
5746 eb = ERROR_BLU(eb, val);
5747 DITHER_ERROR(er1, er2, ex, er, eg, eb);
5748 *img++ = COLOR_INDEX(val);
5749 }
5750 }
5751 img += jmp;
5752 }
5753 }
5754 else
5755 {
5756 for (y = 0; y < h; y++)
5757 {
5758 ter = er1;
5759 er1 = er2;
5760 er2 = ter;
5761 for (ex = 0; ex < (w + 2) * 3; ex++)
5762 er2[ex] = 0;
5763 ex = 3;
5764 for (x = 0; x < w; x++)
5765 {
5766 ptr2 = yarray[y] + xarray[x];
5767 r = (int)*ptr2++;
5768 g = (int)*ptr2++;
5769 b = (int)*ptr2;
5770 if ((r == im->shape_color.r) &&
5771 (g == im->shape_color.g) &&
5772 (b == im->shape_color.b))
5773 {
5774 XPutPixel(sxim, x, y, 0);
5775 ex += 3;
5776 }
5777 else
5778 {
5779 XPutPixel(sxim, x, y, 1);
5780 r = im->rmap[r];
5781 g = im->gmap[g];
5782 b = im->bmap[b];
5783 er = r + er1[ex++];
5784 eg = g + er1[ex++];
5785 eb = b + er1[ex++];
5786 if (er > 255)
5787 er = 255;
5788 else if (er < 0)
5789 er = 0;
5790 if (eg > 255)
5791 eg = 255;
5792 else if (eg < 0)
5793 eg = 0;
5794 if (eb > 255)
5795 eb = 255;
5796 else if (eb < 0)
5797 eb = 0;
5798 val = INDEX_RGB(er >> 3, eg >> 3, eb >> 3);
5799 er = ERROR_RED(er, val);
5800 eg = ERROR_GRN(eg, val);
5801 eb = ERROR_BLU(eb, val);
5802 DITHER_ERROR(er1, er2, ex, er, eg, eb);
5803 XPutPixel(xim, x, y, COLOR_INDEX(val));
5804 }
5805 }
5806 }
5807 }
5808 break;
5809 default:
5810 if (id->fastrend)
5811 {
5812 switch (bpp)
5813 {
5814 case 8:
5815 break;
5816 case 15:
5817 if (id->render_type == RT_DITHER_TRUECOL)
5818 {
5819 if (id->ordered_dither)
5820 render_shaped_15_fast_dither_mod_ordered(id, im, w, h, xim, sxim, er1, er2, xarray, yarray);
5821 else
5822 render_shaped_15_fast_dither_mod(id, im, w, h, xim, sxim, er1, er2, xarray, yarray);
5823 }
5824 else
5825 render_shaped_15_fast_mod(id, im, w, h, xim, sxim, er1, er2, xarray, yarray);
5826 break;
5827 case 16:
5828 if (id->render_type == RT_DITHER_TRUECOL)
5829 {
5830 if (id->ordered_dither)
5831 render_shaped_16_fast_dither_mod_ordered(id, im, w, h, xim, sxim, er1, er2, xarray, yarray);
5832 else
5833 render_shaped_16_fast_dither_mod(id, im, w, h, xim, sxim, er1, er2, xarray, yarray);
5834 }
5835 else
5836 render_shaped_16_fast_mod(id, im, w, h, xim, sxim, er1, er2, xarray, yarray);
5837 break;
5838 case 24:
5839 case 32:
5840 if (xim->bits_per_pixel == 24)
5841 render_shaped_24_fast_mod(id, im, w, h, xim, sxim, er1, er2, xarray, yarray);
5842 else
5843 render_shaped_32_fast_mod(id, im, w, h, xim, sxim, er1, er2, xarray, yarray);
5844 break;
5845 default:
5846 break;
5847 }
5848 }
5849 else
5850 {
5851 switch (bpp)
5852 {
5853 case 8:
5854 break;
5855 case 15:
5856 if (id->render_type == RT_DITHER_TRUECOL)
5857 {
5858 if (id->ordered_dither)
5859 render_shaped_15_dither_mod_ordered(id, im, w, h, xim, sxim, er1, er2, xarray, yarray);
5860 else
5861 render_shaped_15_dither_mod(id, im, w, h, xim, sxim, er1, er2, xarray, yarray);
5862 }
5863 else
5864 render_shaped_15_mod(id, im, w, h, xim, sxim, er1, er2, xarray, yarray);
5865 break;
5866 case 16:
5867 if (id->render_type == RT_DITHER_TRUECOL)
5868 {
5869 if (id->ordered_dither)
5870 render_shaped_16_dither_mod_ordered(id, im, w, h, xim, sxim, er1, er2, xarray, yarray);
5871 else
5872 render_shaped_16_dither_mod(id, im, w, h, xim, sxim, er1, er2, xarray, yarray);
5873 }
5874 else
5875 render_shaped_16_mod(id, im, w, h, xim, sxim, er1, er2, xarray, yarray);
5876 break;
5877 case 24:
5878 render_shaped_24_mod(id, im, w, h, xim, sxim, er1, er2, xarray, yarray);
5879 case 32:
5880 render_shaped_24_mod(id, im, w, h, xim, sxim, er1, er2, xarray, yarray);
5881 break;
5882 default:
5883 break;
5884 }
5885 }
5886 break;
5887 }
5888 }
5889
5890 static void
render_mod(ImlibData * id,ImlibImage * im,int w,int h,XImage * xim,XImage * sxim,int * er1,int * er2,int * xarray,unsigned char ** yarray,int bpp)5891 render_mod(ImlibData * id, ImlibImage * im, int w, int h, XImage * xim,
5892 XImage * sxim, int *er1, int *er2, int *xarray,
5893 unsigned char **yarray, int bpp)
5894 {
5895 int x, y, val, r, g, b, *ter, ex, er, eg, eb;
5896 unsigned char *ptr2;
5897 unsigned char *img;
5898 int jmp;
5899
5900 jmp = (xim->bytes_per_line) - w * (bpp >> 3);
5901 img = (unsigned char *)xim->data;
5902 switch (id->render_type)
5903 {
5904 case RT_PLAIN_PALETTE:
5905 if ((id->fastrend) && (xim->bits_per_pixel == 8))
5906 {
5907 for (y = 0; y < h; y++)
5908 {
5909 for (x = 0; x < w; x++)
5910 {
5911 ptr2 = yarray[y] + xarray[x];
5912 r = (int)*ptr2++;
5913 g = (int)*ptr2++;
5914 b = (int)*ptr2;
5915 r = im->rmap[r];
5916 g = im->gmap[g];
5917 b = im->bmap[b];
5918 val = Imlib_best_color_match(id, &r, &g, &b);
5919 *img++ = val;
5920 }
5921 img += jmp;
5922 }
5923 }
5924 else
5925 {
5926 for (y = 0; y < h; y++)
5927 {
5928 for (x = 0; x < w; x++)
5929 {
5930 ptr2 = yarray[y] + xarray[x];
5931 r = (int)*ptr2++;
5932 g = (int)*ptr2++;
5933 b = (int)*ptr2;
5934 r = im->rmap[r];
5935 g = im->gmap[g];
5936 b = im->bmap[b];
5937 val = Imlib_best_color_match(id, &r, &g, &b);
5938 XPutPixel(xim, x, y, val);
5939 }
5940 }
5941 }
5942 break;
5943 case RT_PLAIN_PALETTE_FAST:
5944 if ((id->fastrend) && (xim->bits_per_pixel == 8))
5945 {
5946 for (y = 0; y < h; y++)
5947 {
5948 for (x = 0; x < w; x++)
5949 {
5950 ptr2 = yarray[y] + xarray[x];
5951 r = (int)*ptr2++;
5952 g = (int)*ptr2++;
5953 b = (int)*ptr2;
5954 r = im->rmap[r];
5955 g = im->gmap[g];
5956 b = im->bmap[b];
5957 val = COLOR_RGB(r >> 3, g >> 3, b >> 3);
5958 *img++ = val;
5959 }
5960 img += jmp;
5961 }
5962 }
5963 else
5964 {
5965 for (y = 0; y < h; y++)
5966 {
5967 for (x = 0; x < w; x++)
5968 {
5969 ptr2 = yarray[y] + xarray[x];
5970 r = (int)*ptr2++;
5971 g = (int)*ptr2++;
5972 b = (int)*ptr2;
5973 r = im->rmap[r];
5974 g = im->gmap[g];
5975 b = im->bmap[b];
5976 val = COLOR_RGB(r >> 3, g >> 3, b >> 3);
5977 XPutPixel(xim, x, y, val);
5978 }
5979 }
5980 }
5981 break;
5982 case RT_DITHER_PALETTE:
5983 if ((id->fastrend) && (xim->bits_per_pixel == 8))
5984 {
5985 for (y = 0; y < h; y++)
5986 {
5987 ter = er1;
5988 er1 = er2;
5989 er2 = ter;
5990 for (ex = 0; ex < (w + 2) * 3; ex++)
5991 er2[ex] = 0;
5992 ex = 3;
5993 for (x = 0; x < w; x++)
5994 {
5995 ptr2 = yarray[y] + xarray[x];
5996 r = (int)*ptr2++;
5997 g = (int)*ptr2++;
5998 b = (int)*ptr2;
5999 r = im->rmap[r];
6000 g = im->gmap[g];
6001 b = im->bmap[b];
6002 er = r + er1[ex++];
6003 eg = g + er1[ex++];
6004 eb = b + er1[ex++];
6005 if (er > 255)
6006 er = 255;
6007 else if (er < 0)
6008 er = 0;
6009 if (eg > 255)
6010 eg = 255;
6011 else if (eg < 0)
6012 eg = 0;
6013 if (eb > 255)
6014 eb = 255;
6015 else if (eb < 0)
6016 eb = 0;
6017 val = Imlib_best_color_match(id, &er, &eg, &eb);
6018 DITHER_ERROR(er1, er2, ex, er, eg, eb);
6019 *img++ = val;
6020 }
6021 img += jmp;
6022 }
6023 }
6024 else
6025 {
6026 for (y = 0; y < h; y++)
6027 {
6028 ter = er1;
6029 er1 = er2;
6030 er2 = ter;
6031 for (ex = 0; ex < (w + 2) * 3; ex++)
6032 er2[ex] = 0;
6033 ex = 3;
6034 for (x = 0; x < w; x++)
6035 {
6036 ptr2 = yarray[y] + xarray[x];
6037 r = (int)*ptr2++;
6038 g = (int)*ptr2++;
6039 b = (int)*ptr2;
6040 r = im->rmap[r];
6041 g = im->gmap[g];
6042 b = im->bmap[b];
6043 er = r + er1[ex++];
6044 eg = g + er1[ex++];
6045 eb = b + er1[ex++];
6046 if (er > 255)
6047 er = 255;
6048 else if (er < 0)
6049 er = 0;
6050 if (eg > 255)
6051 eg = 255;
6052 else if (eg < 0)
6053 eg = 0;
6054 if (eb > 255)
6055 eb = 255;
6056 else if (eb < 0)
6057 eb = 0;
6058 val = Imlib_best_color_match(id, &er, &eg, &eb);
6059 DITHER_ERROR(er1, er2, ex, er, eg, eb);
6060 XPutPixel(xim, x, y, val);
6061 }
6062 }
6063 }
6064 break;
6065 case RT_DITHER_PALETTE_FAST:
6066 if ((id->fastrend) && (xim->bits_per_pixel == 8))
6067 {
6068 for (y = 0; y < h; y++)
6069 {
6070 ter = er1;
6071 er1 = er2;
6072 er2 = ter;
6073 for (ex = 0; ex < (w + 2) * 3; ex++)
6074 er2[ex] = 0;
6075 ex = 3;
6076 for (x = 0; x < w; x++)
6077 {
6078 ptr2 = yarray[y] + xarray[x];
6079 r = (int)*ptr2++;
6080 g = (int)*ptr2++;
6081 b = (int)*ptr2;
6082 r = im->rmap[r];
6083 g = im->gmap[g];
6084 b = im->bmap[b];
6085 er = r + er1[ex++];
6086 eg = g + er1[ex++];
6087 eb = b + er1[ex++];
6088 if (er > 255)
6089 er = 255;
6090 else if (er < 0)
6091 er = 0;
6092 if (eg > 255)
6093 eg = 255;
6094 else if (eg < 0)
6095 eg = 0;
6096 if (eb > 255)
6097 eb = 255;
6098 else if (eb < 0)
6099 eb = 0;
6100 val = INDEX_RGB(er >> 3, eg >> 3, eb >> 3);
6101 er = ERROR_RED(er, val);
6102 eg = ERROR_GRN(eg, val);
6103 eb = ERROR_BLU(eb, val);
6104 DITHER_ERROR(er1, er2, ex, er, eg, eb);
6105 *img++ = COLOR_INDEX(val);
6106 }
6107 img += jmp;
6108 }
6109 }
6110 else
6111 {
6112 for (y = 0; y < h; y++)
6113 {
6114 ter = er1;
6115 er1 = er2;
6116 er2 = ter;
6117 for (ex = 0; ex < (w + 2) * 3; ex++)
6118 er2[ex] = 0;
6119 ex = 3;
6120 for (x = 0; x < w; x++)
6121 {
6122 ptr2 = yarray[y] + xarray[x];
6123 r = (int)*ptr2++;
6124 g = (int)*ptr2++;
6125 b = (int)*ptr2;
6126 r = im->rmap[r];
6127 g = im->gmap[g];
6128 b = im->bmap[b];
6129 er = r + er1[ex++];
6130 eg = g + er1[ex++];
6131 eb = b + er1[ex++];
6132 if (er > 255)
6133 er = 255;
6134 else if (er < 0)
6135 er = 0;
6136 if (eg > 255)
6137 eg = 255;
6138 else if (eg < 0)
6139 eg = 0;
6140 if (eb > 255)
6141 eb = 255;
6142 else if (eb < 0)
6143 eb = 0;
6144 val = INDEX_RGB(er >> 3, eg >> 3, eb >> 3);
6145 er = ERROR_RED(er, val);
6146 eg = ERROR_GRN(eg, val);
6147 eb = ERROR_BLU(eb, val);
6148 DITHER_ERROR(er1, er2, ex, er, eg, eb);
6149 XPutPixel(xim, x, y, COLOR_INDEX(val));
6150 }
6151 }
6152 }
6153 break;
6154 default:
6155 if (id->fastrend)
6156 {
6157 switch (bpp)
6158 {
6159 case 8:
6160 break;
6161 case 15:
6162 if (id->render_type == RT_DITHER_TRUECOL)
6163 {
6164 if (id->ordered_dither)
6165 render_15_fast_dither_mod_ordered(id, im, w, h, xim, sxim, er1, er2, xarray, yarray);
6166 else
6167 render_15_fast_dither_mod(id, im, w, h, xim, sxim, er1, er2, xarray, yarray);
6168 }
6169 else
6170 render_15_fast_mod(id, im, w, h, xim, sxim, er1, er2, xarray, yarray);
6171 break;
6172 case 16:
6173 if (id->render_type == RT_DITHER_TRUECOL)
6174 {
6175 if (id->ordered_dither)
6176 render_16_fast_dither_mod_ordered(id, im, w, h, xim, sxim, er1, er2, xarray, yarray);
6177 else
6178 render_16_fast_dither_mod(id, im, w, h, xim, sxim, er1, er2, xarray, yarray);
6179 }
6180 else
6181 render_16_fast_mod(id, im, w, h, xim, sxim, er1, er2, xarray, yarray);
6182 break;
6183 case 24:
6184 case 32:
6185 if (xim->bits_per_pixel == 24)
6186 render_24_fast_mod(id, im, w, h, xim, sxim, er1, er2, xarray, yarray);
6187 else
6188 render_32_fast_mod(id, im, w, h, xim, sxim, er1, er2, xarray, yarray);
6189 break;
6190 default:
6191 break;
6192 }
6193 }
6194 else
6195 {
6196 switch (bpp)
6197 {
6198 case 8:
6199 break;
6200 case 15:
6201 if (id->render_type == RT_DITHER_TRUECOL)
6202 {
6203 if (id->ordered_dither)
6204 render_15_dither_mod_ordered(id, im, w, h, xim, sxim, er1, er2, xarray, yarray);
6205 else
6206 render_15_dither_mod(id, im, w, h, xim, sxim, er1, er2, xarray, yarray);
6207 }
6208 else
6209 render_15_mod(id, im, w, h, xim, sxim, er1, er2, xarray, yarray);
6210 break;
6211 case 16:
6212 if (id->render_type == RT_DITHER_TRUECOL)
6213 {
6214 if (id->ordered_dither)
6215 render_16_dither_mod_ordered(id, im, w, h, xim, sxim, er1, er2, xarray, yarray);
6216 else
6217 render_16_dither_mod(id, im, w, h, xim, sxim, er1, er2, xarray, yarray);
6218 }
6219 else
6220 render_16_mod(id, im, w, h, xim, sxim, er1, er2, xarray, yarray);
6221 break;
6222 case 24:
6223 render_24_mod(id, im, w, h, xim, sxim, er1, er2, xarray, yarray);
6224 break;
6225 case 32:
6226 render_24_mod(id, im, w, h, xim, sxim, er1, er2, xarray, yarray);
6227 break;
6228 default:
6229 break;
6230 }
6231 break;
6232 }
6233 }
6234 }
6235
6236 int
Imlib_render(ImlibData * id,ImlibImage * im,int w,int h)6237 Imlib_render(ImlibData * id, ImlibImage * im, int w, int h)
6238 {
6239 XImage *xim, *sxim;
6240 static Display *pd = NULL;
6241 static GC tgc = 0, stgc = 0;
6242 XGCValues gcv;
6243 unsigned char *tmp, *stmp, **yarray, *ptr22;
6244 int w3, x, inc, pos, *error, *er1, *er2, *xarray, ex, bpp;
6245 Pixmap pmap, mask;
6246 #ifdef HAVE_SHM
6247 int shared_pixmap, shared_image, ok, huge;
6248 #endif
6249
6250 if (!pd)
6251 pd = id->x.disp;
6252 if (tgc)
6253 {
6254 if (id->x.disp != pd)
6255 {
6256 XFreeGC(pd, tgc);
6257 tgc = 0;
6258 }
6259 }
6260 if (stgc)
6261 {
6262 if (id->x.disp != pd)
6263 {
6264 XFreeGC(pd, stgc);
6265 stgc = 0;
6266 }
6267 }
6268 pd = id->x.disp;
6269
6270 sxim = NULL;
6271 xim = NULL;
6272 tmp = NULL;
6273 stmp = NULL;
6274 pmap = 0;
6275 mask = 0;
6276 inc = 0;
6277 if (!im)
6278 return 0;
6279 if (w <= 0)
6280 return 0;
6281 if (h <= 0)
6282 return 0;
6283 gcv.graphics_exposures = False;
6284
6285 /* look for the pixmap in cache first */
6286 if (id->cache.on_pixmap)
6287 {
6288 pmap = 0;
6289 find_pixmap(id, im, w, h, &pmap, &mask);
6290 if (pmap)
6291 {
6292 im->width = w;
6293 im->height = h;
6294 im->pixmap = pmap;
6295 if (mask)
6296 im->shape_mask = mask;
6297 else
6298 im->shape_mask = 0;
6299 return 1;
6300 }
6301 }
6302 if (im->pixmap)
6303 free_pixmappmap(id, im->pixmap);
6304 im->pixmap = 0;
6305 im->shape_mask = 0;
6306 /* setup stuff */
6307 if (id->x.depth <= 8)
6308 bpp = 1;
6309 else if (id->x.depth <= 16)
6310 bpp = 2;
6311 else if (id->x.depth <= 24)
6312 bpp = 3;
6313 else
6314 bpp = 4;
6315
6316 #ifdef HAVE_SHM
6317 huge = 0;
6318 if ((id->max_shm) && ((bpp * w * h) > id->max_shm))
6319 huge = 1;
6320 #endif
6321 im->width = w;
6322 im->height = h;
6323
6324 /* dithering array */
6325 error = (int *)calloc((w + 2), sizeof(int) * 2 * 3);
6326
6327 if (!error)
6328 {
6329 fprintf(stderr, "ERROR: Cannot allocate RAM for image dither buffer\n");
6330 return 0;
6331 }
6332
6333 /* setup pointers to point right */
6334 er1 = error;
6335 er2 = error + ((w + 2) * 3);
6336 w3 = im->rgb_width * 3;
6337 ptr22 = im->rgb_data;
6338
6339 /* setup coord-mapping array (specially for border scaling) */
6340 xarray = calloc(w, sizeof(int));
6341
6342 if (!xarray)
6343 {
6344 fprintf(stderr, "ERROR: Cannot allocate X co-ord buffer\n");
6345 free(error);
6346 return 0;
6347 }
6348 yarray = calloc(h, sizeof(unsigned char *));
6349
6350 if (!yarray)
6351 {
6352 fprintf(stderr, "ERROR: Cannot allocate Y co-ord buffer\n");
6353 free(xarray);
6354 free(error);
6355 return 0;
6356 }
6357 for (ex = 0; ex < ((w + 2) * 3 * 2); ex++)
6358 error[ex] = 0;
6359 {
6360 int l, r, m;
6361
6362 if (w < im->border.left + im->border.right)
6363 {
6364 l = w >> 1;
6365 r = w - l;
6366 m = 0;
6367 }
6368 else
6369 {
6370 l = im->border.left;
6371 r = im->border.right;
6372 m = w - l - r;
6373 }
6374 if (m > 0)
6375 inc = ((im->rgb_width - im->border.left - im->border.right) << 16) / m;
6376 pos = 0;
6377 if (l)
6378 for (x = 0; x < l; x++)
6379 {
6380 xarray[x] = (pos >> 16) + (pos >> 16) + (pos >> 16);
6381 pos += 0x10000;
6382 }
6383 if (m)
6384 {
6385 for (x = l; x < l + m; x++)
6386 {
6387 xarray[x] = (pos >> 16) + (pos >> 16) + (pos >> 16);
6388 pos += inc;
6389 }
6390 }
6391 pos = (im->rgb_width - r) << 16;
6392 for (x = w - r; x < w; x++)
6393 {
6394 xarray[x] = (pos >> 16) + (pos >> 16) + (pos >> 16);
6395 pos += 0x10000;
6396 }
6397
6398 if (h < im->border.top + im->border.bottom)
6399 {
6400 l = h >> 1;
6401 r = h - l;
6402 m = 0;
6403 }
6404 else
6405 {
6406 l = im->border.top;
6407 r = im->border.bottom;
6408 m = h - l - r;
6409 }
6410 if (m > 0)
6411 inc = ((im->rgb_height - im->border.top - im->border.bottom) << 16) / m;
6412 pos = 0;
6413 for (x = 0; x < l; x++)
6414 {
6415 yarray[x] = ptr22 + ((pos >> 16) * w3);
6416 pos += 0x10000;
6417 }
6418 if (m)
6419 {
6420 for (x = l; x < l + m; x++)
6421 {
6422 yarray[x] = ptr22 + ((pos >> 16) * w3);
6423 pos += inc;
6424 }
6425 }
6426 pos = (im->rgb_height - r) << 16;
6427 for (x = h - r; x < h; x++)
6428 {
6429 yarray[x] = ptr22 + ((pos >> 16) * w3);
6430 pos += 0x10000;
6431 }
6432 }
6433
6434 /* work out if we should use shared pixmap. images etc */
6435 #ifdef HAVE_SHM
6436 shared_pixmap = 0;
6437 shared_image = 0;
6438 if ((id->x.shmp) && (id->x.shm) && (!huge))
6439 {
6440 #if defined(__alpha__)
6441 shared_pixmap = 0;
6442 shared_image = 1;
6443 #else
6444 shared_pixmap = 1;
6445 shared_image = 0;
6446 #endif
6447 }
6448 else if ((id->x.shm) && (!huge))
6449 {
6450 shared_pixmap = 0;
6451 shared_image = 1;
6452 }
6453 else
6454 {
6455 shared_pixmap = 0;
6456 shared_image = 0;
6457 }
6458 #endif
6459
6460 /* init images and pixmaps */
6461 #ifdef HAVE_SHM
6462 ok = 1;
6463 if (shared_pixmap)
6464 {
6465 xim = XShmCreateImage(id->x.disp, id->x.visual, id->x.depth, ZPixmap, NULL, &id->x.last_shminfo, w, h);
6466 if (!xim)
6467 {
6468 fprintf(stderr, "IMLIB ERROR: Mit-SHM can't create XImage for Shared Pixmap Wrapper\n");
6469 fprintf(stderr, " Falling back on Shared XImages\n");
6470 shared_pixmap = 0;
6471 shared_image = 1;
6472 ok = 0;
6473 }
6474 if (ok)
6475 {
6476 id->x.last_shminfo.shmid = shmget(IPC_PRIVATE, xim->bytes_per_line * xim->height, IPC_CREAT | 0777);
6477 if (id->x.last_shminfo.shmid == -1)
6478 {
6479 fprintf(stderr, "IMLIB ERROR: SHM can't get SHM Identifier for Shared Pixmap Wrapper\n");
6480 fprintf(stderr, " Falling back on Shared XImages\n");
6481 XDestroyImage(xim);
6482 shared_pixmap = 0;
6483 shared_image = 1;
6484 ok = 0;
6485 }
6486 if (ok)
6487 {
6488 id->x.last_shminfo.shmaddr = xim->data = shmat(id->x.last_shminfo.shmid, 0, 0);
6489 if (xim->data == (char *)-1)
6490 {
6491 fprintf(stderr, "IMLIB ERROR: SHM can't attach SHM Segment for Shared Pixmap Wrapper\n");
6492 fprintf(stderr, " Falling back on Shared XImages\n");
6493 XDestroyImage(xim);
6494 shmctl(id->x.last_shminfo.shmid, IPC_RMID, 0);
6495 shared_pixmap = 0;
6496 shared_image = 1;
6497 ok = 0;
6498 }
6499 if (ok)
6500 {
6501 id->x.last_shminfo.readOnly = False;
6502 XShmAttach(id->x.disp, &id->x.last_shminfo);
6503 tmp = (unsigned char *)xim->data;
6504 id->x.last_xim = xim;
6505 pmap = XShmCreatePixmap(id->x.disp, id->x.base_window,
6506 id->x.last_shminfo.shmaddr,
6507 &id->x.last_shminfo, w, h, id->x.depth);
6508 if (!tgc)
6509 tgc = XCreateGC(id->x.disp, pmap, GCGraphicsExposures, &gcv);
6510 if ((im->shape_color.r >= 0) && (im->shape_color.g >= 0) && (im->shape_color.b >= 0))
6511 {
6512 sxim = XShmCreateImage(id->x.disp, id->x.visual, 1, ZPixmap, NULL, &id->x.last_sshminfo, w, h);
6513 if (!sxim)
6514 {
6515 fprintf(stderr, "IMLIB ERROR: Mit-SHM can't create XImage for Shared Pixmap mask Wrapper\n");
6516 fprintf(stderr, " Falling back on Shared XImages\n");
6517 XShmDetach(id->x.disp, &id->x.last_shminfo);
6518 XDestroyImage(xim);
6519 shmdt(id->x.last_shminfo.shmaddr);
6520 shared_pixmap = 0;
6521 shared_image = 1;
6522 ok = 0;
6523 }
6524 if (ok)
6525 {
6526 id->x.last_sshminfo.shmid = shmget(IPC_PRIVATE, sxim->bytes_per_line * sxim->height, IPC_CREAT | 0777);
6527 if (id->x.last_sshminfo.shmid == -1)
6528 {
6529 fprintf(stderr, "IMLIB ERROR: SHM can't get SHM Identifier for Shared Pixmap mask Wrapper\n");
6530 fprintf(stderr, " Falling back on Shared XImages\n");
6531 XShmDetach(id->x.disp, &id->x.last_shminfo);
6532 XDestroyImage(xim);
6533 shmdt(xim->data);
6534 /* missing shmctl(RMID) */
6535 XDestroyImage(sxim);
6536 shared_pixmap = 0;
6537 shared_image = 1;
6538 ok = 0;
6539 }
6540 if (ok)
6541 {
6542 id->x.last_sshminfo.shmaddr = sxim->data = shmat(id->x.last_sshminfo.shmid, 0, 0);
6543 if (sxim->data == (char *)-1)
6544 {
6545 fprintf(stderr, "IMLIB ERROR: SHM can't attach SHM Segment for Shared Pixmap mask Wrapper\n");
6546 fprintf(stderr, " Falling back on Shared XImages\n");
6547 XShmDetach(id->x.disp, &id->x.last_shminfo);
6548 XDestroyImage(xim);
6549 shmdt(xim->data);
6550 /* missing shmctl(RMID) */
6551 XDestroyImage(sxim);
6552 shmctl(id->x.last_shminfo.shmid, IPC_RMID, 0);
6553 shared_pixmap = 0;
6554 shared_image = 1;
6555 ok = 0;
6556 }
6557 if (ok)
6558 {
6559 id->x.last_sshminfo.readOnly = False;
6560 XShmAttach(id->x.disp, &id->x.last_sshminfo);
6561 stmp = (unsigned char *)sxim->data;
6562 id->x.last_sxim = sxim;
6563 mask = XShmCreatePixmap(id->x.disp, id->x.base_window,
6564 id->x.last_sshminfo.shmaddr,
6565 &id->x.last_sshminfo, w, h, 1);
6566 if (!stgc)
6567 stgc = XCreateGC(id->x.disp, mask, GCGraphicsExposures, &gcv);
6568 }
6569 }
6570 }
6571 }
6572 }
6573 }
6574 }
6575 }
6576 ok = 1;
6577 if (shared_image)
6578 {
6579 xim = XShmCreateImage(id->x.disp, id->x.visual, id->x.depth, ZPixmap, NULL, &id->x.last_shminfo, w, h);
6580 if (!xim)
6581 {
6582 fprintf(stderr, "IMLIB ERROR: Mit-SHM can't create Shared XImage\n");
6583 fprintf(stderr, " Falling back on XImages\n");
6584 shared_pixmap = 0;
6585 shared_image = 0;
6586 ok = 0;
6587 }
6588 if (ok)
6589 {
6590 id->x.last_shminfo.shmid = shmget(IPC_PRIVATE, xim->bytes_per_line * xim->height, IPC_CREAT | 0777);
6591 if (id->x.last_shminfo.shmid == -1)
6592 {
6593 fprintf(stderr, "IMLIB ERROR: SHM can't get SHM Identifier for Shared XImage\n");
6594 fprintf(stderr, " Falling back on XImages\n");
6595 XDestroyImage(xim);
6596 shared_pixmap = 0;
6597 shared_image = 0;
6598 ok = 0;
6599 }
6600 if (ok)
6601 {
6602 id->x.last_shminfo.shmaddr = xim->data = shmat(id->x.last_shminfo.shmid, 0, 0);
6603
6604 if (xim->data == (char *)-1)
6605 {
6606 fprintf(stderr, "IMLIB ERROR: SHM can't attach SHM Segment for Shared XImage\n");
6607 fprintf(stderr, " Falling back on XImages\n");
6608 XDestroyImage(xim);
6609 shmctl(id->x.last_shminfo.shmid, IPC_RMID, 0);
6610 shared_pixmap = 0;
6611 shared_image = 0;
6612 ok = 0;
6613 }
6614 if (ok)
6615 {
6616 id->x.last_shminfo.readOnly = False;
6617 XShmAttach(id->x.disp, &id->x.last_shminfo);
6618 tmp = (unsigned char *)xim->data;
6619 id->x.last_xim = xim;
6620 pmap = XCreatePixmap(id->x.disp, id->x.base_window, w, h, id->x.depth);
6621 if (!tgc)
6622 tgc = XCreateGC(id->x.disp, pmap, GCGraphicsExposures, &gcv);
6623 im->pixmap = pmap;
6624 if ((im->shape_color.r >= 0) && (im->shape_color.g >= 0) && (im->shape_color.b >= 0))
6625 {
6626 sxim = XShmCreateImage(id->x.disp, id->x.visual, 1, ZPixmap, NULL, &id->x.last_sshminfo, w, h);
6627 if (!sxim)
6628 {
6629 fprintf(stderr, "IMLIB ERROR: Mit-SHM can't create Shared XImage mask\n");
6630 fprintf(stderr, " Falling back on XImages\n");
6631 XShmDetach(id->x.disp, &id->x.last_shminfo);
6632 XDestroyImage(xim);
6633 shmdt(id->x.last_shminfo.shmaddr);
6634 shmctl(id->x.last_shminfo.shmid, IPC_RMID, 0);
6635 shared_pixmap = 0;
6636 shared_image = 0;
6637 ok = 0;
6638 }
6639 if (ok)
6640 {
6641 id->x.last_sshminfo.shmid = shmget(IPC_PRIVATE, sxim->bytes_per_line * sxim->height, IPC_CREAT | 0777);
6642 if (id->x.last_sshminfo.shmid == -1)
6643 {
6644 fprintf(stderr, "Imlib ERROR: SHM can't get SHM Identifier for Shared XImage mask\n");
6645 fprintf(stderr, " Falling back on XImages\n");
6646 XShmDetach(id->x.disp, &id->x.last_shminfo);
6647 XDestroyImage(xim);
6648 shmdt(xim->data);
6649 /* missing shmctl(RMID) */
6650 XDestroyImage(sxim);
6651 shared_pixmap = 0;
6652 shared_image = 0;
6653 ok = 0;
6654 }
6655 if (ok)
6656 {
6657 id->x.last_sshminfo.shmaddr = sxim->data = shmat(id->x.last_sshminfo.shmid, 0, 0);
6658 if (sxim->data == (char *)-1)
6659 {
6660 fprintf(stderr, "Imlib ERROR: SHM can't attach SHM Segment for Shared XImage mask\n");
6661 fprintf(stderr, " Falling back on XImages\n");
6662 XShmDetach(id->x.disp, &id->x.last_shminfo);
6663 XDestroyImage(xim);
6664 shmdt(xim->data);
6665 /* missing shmctl(RMID) */
6666 XDestroyImage(sxim);
6667 shmctl(id->x.last_shminfo.shmid, IPC_RMID, 0);
6668 shared_pixmap = 0;
6669 shared_image = 0;
6670 ok = 0;
6671 }
6672
6673 if (ok)
6674 {
6675 id->x.last_sshminfo.readOnly = False;
6676 XShmAttach(id->x.disp, &id->x.last_sshminfo);
6677 stmp = (unsigned char *)sxim->data;
6678 id->x.last_sxim = sxim;
6679 mask = XCreatePixmap(id->x.disp, id->x.base_window, w, h, 1);
6680 if (!stgc)
6681 stgc = XCreateGC(id->x.disp, mask, GCGraphicsExposures, &gcv);
6682 im->shape_mask = mask;
6683 }
6684 }
6685 }
6686 }
6687 }
6688 }
6689 }
6690 }
6691 ok = 1;
6692 if ((!shared_pixmap) && (!shared_image))
6693 #endif /* HAVE_SHM */
6694 {
6695 tmp = (unsigned char *)malloc(w * h * bpp);
6696 if (!tmp)
6697 {
6698 fprintf(stderr, "IMLIB ERROR: Cannot allocate RAM for XImage data\n");
6699 free(xarray);
6700 free(yarray);
6701 free(error);
6702 return 0;
6703 }
6704 xim = XCreateImage(id->x.disp, id->x.visual, id->x.depth, ZPixmap, 0, (char *)tmp, w, h, 8, 0);
6705 if (!xim)
6706 {
6707 fprintf(stderr, "IMLIB ERROR: Cannot allocate XImage buffer\n");
6708 free(xarray);
6709 free(yarray);
6710 free(error);
6711 free(tmp);
6712 return 0;
6713 }
6714 if (xim->bytes_per_line != bpp * w)
6715 xim->data = realloc(xim->data, xim->bytes_per_line * xim->height);
6716 pmap = XCreatePixmap(id->x.disp, id->x.base_window, w, h, id->x.depth);
6717 if (!pmap)
6718 {
6719 fprintf(stderr, "IMLIB ERROR: Cannot create pixmap\n");
6720 free(xarray);
6721 free(yarray);
6722 free(error);
6723 XDestroyImage(xim);
6724 return 0;
6725 }
6726 im->pixmap = pmap;
6727 if (!tgc)
6728 tgc = XCreateGC(id->x.disp, pmap, GCGraphicsExposures, &gcv);
6729 if ((im->shape_color.r >= 0) && (im->shape_color.g >= 0) && (im->shape_color.b >= 0))
6730 {
6731 stmp = (unsigned char *)calloc(((w >> 3) + 8), h);
6732 if (!stmp)
6733 {
6734 fprintf(stderr, "IMLIB ERROR: Cannot allocate RAM for shape XImage data\n");
6735 free(xarray);
6736 free(yarray);
6737 free(error);
6738 XDestroyImage(xim);
6739 return 0;
6740 }
6741 sxim = XCreateImage(id->x.disp, id->x.visual, 1, ZPixmap, 0, (char *)stmp, w, h, 8, 0);
6742 if (!sxim)
6743 {
6744 fprintf(stderr, "IMLIB ERROR: Cannot allocate XImage shape buffer\n");
6745 free(xarray);
6746 free(yarray);
6747 free(error);
6748 free(stmp);
6749 XDestroyImage(xim);
6750 return 0;
6751 }
6752 mask = XCreatePixmap(id->x.disp, id->x.base_window, w, h, 1);
6753 if (!mask)
6754 {
6755 fprintf(stderr, "IMLIB ERROR: Cannot create shape pixmap\n");
6756 free(xarray);
6757 free(yarray);
6758 free(error);
6759 XDestroyImage(sxim);
6760 XDestroyImage(xim);
6761 return 0;
6762 }
6763 im->shape_mask = mask;
6764 if (!stgc)
6765 stgc = XCreateGC(id->x.disp, mask, GCGraphicsExposures, &gcv);
6766 }
6767 }
6768 /* copy XImage to the pixmap, if not a shared pixmap */
6769 if ((im->shape_color.r >= 0) && (im->shape_color.g >= 0) && (im->shape_color.b >= 0))
6770 {
6771 if ((im->mod.gamma == 256) && (im->mod.brightness == 256) && (im->mod.contrast == 256) &&
6772 (im->rmod.gamma == 256) && (im->rmod.brightness == 256) && (im->rmod.contrast == 256) &&
6773 (im->gmod.gamma == 256) && (im->gmod.brightness == 256) && (im->gmod.contrast == 256) &&
6774 (im->bmod.gamma == 256) && (im->bmod.brightness == 256) && (im->bmod.contrast == 256))
6775 {
6776 if (id->x.depth <= 8)
6777 render_shaped(id, im, w, h, xim, sxim, er1, er2, xarray, yarray, 8);
6778 else
6779 render_shaped(id, im, w, h, xim, sxim, er1, er2, xarray, yarray, id->x.render_depth);
6780 }
6781 else
6782 {
6783 if (id->x.depth <= 8)
6784 render_shaped_mod(id, im, w, h, xim, sxim, er1, er2, xarray, yarray, 8);
6785 else
6786 render_shaped_mod(id, im, w, h, xim, sxim, er1, er2, xarray, yarray, id->x.render_depth);
6787 }
6788 #ifdef HAVE_SHM
6789 if (shared_image)
6790 {
6791 XShmPutImage(id->x.disp, pmap, tgc, xim, 0, 0, 0, 0, w, h, False);
6792 XShmPutImage(id->x.disp, mask, stgc, sxim, 0, 0, 0, 0, w, h, False);
6793 XSync(id->x.disp, False);
6794 XShmDetach(id->x.disp, &id->x.last_shminfo);
6795 XDestroyImage(xim);
6796 shmdt(id->x.last_shminfo.shmaddr);
6797 shmctl(id->x.last_shminfo.shmid, IPC_RMID, 0);
6798 XShmDetach(id->x.disp, &id->x.last_sshminfo);
6799 XDestroyImage(sxim);
6800 shmdt(id->x.last_sshminfo.shmaddr);
6801 shmctl(id->x.last_sshminfo.shmid, IPC_RMID, 0);
6802 id->x.last_xim = NULL;
6803 id->x.last_sxim = NULL;
6804 xim = NULL;
6805 sxim = NULL;
6806 /* XFreeGC(id->x.disp, tgc);*/
6807 /* XFreeGC(id->x.disp, stgc);*/
6808 }
6809 else if (shared_pixmap)
6810 {
6811 Pixmap p2, m2;
6812
6813 p2 = XCreatePixmap(id->x.disp, id->x.base_window, w, h, id->x.depth);
6814 m2 = XCreatePixmap(id->x.disp, id->x.base_window, w, h, 1);
6815 XCopyArea(id->x.disp, pmap, p2, tgc, 0, 0, w, h, 0, 0);
6816 XCopyArea(id->x.disp, mask, m2, stgc, 0, 0, w, h, 0, 0);
6817 im->pixmap = p2;
6818 im->shape_mask = m2;
6819 /* XFreeGC(id->x.disp, tgc);*/
6820 /* XFreeGC(id->x.disp, stgc);*/
6821 XFreePixmap(id->x.disp, pmap);
6822 XFreePixmap(id->x.disp, mask);
6823 XSync(id->x.disp, False);
6824 XShmDetach(id->x.disp, &id->x.last_shminfo);
6825 XDestroyImage(xim);
6826 shmdt(id->x.last_shminfo.shmaddr);
6827 shmctl(id->x.last_shminfo.shmid, IPC_RMID, 0);
6828 XShmDetach(id->x.disp, &id->x.last_sshminfo);
6829 XDestroyImage(sxim);
6830 shmdt(id->x.last_sshminfo.shmaddr);
6831 shmctl(id->x.last_sshminfo.shmid, IPC_RMID, 0);
6832 id->x.last_xim = NULL;
6833 id->x.last_sxim = NULL;
6834 xim = NULL;
6835 sxim = NULL;
6836 }
6837 else
6838 #endif /* HAVE_SHM */
6839 {
6840 XPutImage(id->x.disp, pmap, tgc, xim, 0, 0, 0, 0, w, h);
6841 XPutImage(id->x.disp, mask, stgc, sxim, 0, 0, 0, 0, w, h);
6842 XDestroyImage(xim);
6843 XDestroyImage(sxim);
6844 xim = NULL;
6845 sxim = NULL;
6846 /* XFreeGC(id->x.disp, tgc);*/
6847 /* XFreeGC(id->x.disp, stgc);*/
6848 }
6849 }
6850 else
6851 {
6852 if ((im->mod.gamma == 256) && (im->mod.brightness == 256) && (im->mod.contrast == 256) &&
6853 (im->rmod.gamma == 256) && (im->rmod.brightness == 256) && (im->rmod.contrast == 256) &&
6854 (im->gmod.gamma == 256) && (im->gmod.brightness == 256) && (im->gmod.contrast == 256) &&
6855 (im->bmod.gamma == 256) && (im->bmod.brightness == 256) && (im->bmod.contrast == 256))
6856 {
6857 if (id->x.depth <= 8)
6858 render(id, im, w, h, xim, sxim, er1, er2, xarray, yarray, 8);
6859 else
6860 render(id, im, w, h, xim, sxim, er1, er2, xarray, yarray, id->x.render_depth);
6861 }
6862 else
6863 {
6864 if (id->x.depth <= 8)
6865 render_mod(id, im, w, h, xim, sxim, er1, er2, xarray, yarray, 8);
6866 else
6867 render_mod(id, im, w, h, xim, sxim, er1, er2, xarray, yarray, id->x.render_depth);
6868 }
6869 #ifdef HAVE_SHM
6870 if (shared_image)
6871 {
6872 XShmPutImage(id->x.disp, pmap, tgc, xim, 0, 0, 0, 0, w, h, False);
6873 XSync(id->x.disp, False);
6874 XShmDetach(id->x.disp, &id->x.last_shminfo);
6875 XDestroyImage(xim);
6876 shmdt(id->x.last_shminfo.shmaddr);
6877 shmctl(id->x.last_shminfo.shmid, IPC_RMID, 0);
6878 id->x.last_xim = NULL;
6879 xim = NULL;
6880 sxim = NULL;
6881 /* XFreeGC(id->x.disp, tgc);*/
6882 }
6883 else if (shared_pixmap)
6884 {
6885 Pixmap p2;
6886
6887 p2 = XCreatePixmap(id->x.disp, id->x.base_window, w, h, id->x.depth);
6888 XCopyArea(id->x.disp, pmap, p2, tgc, 0, 0, w, h, 0, 0);
6889 im->pixmap = p2;
6890 /* XFreeGC(id->x.disp, tgc);*/
6891 XFreePixmap(id->x.disp, pmap);
6892 XSync(id->x.disp, False);
6893 XShmDetach(id->x.disp, &id->x.last_shminfo);
6894 XDestroyImage(xim);
6895 shmdt(id->x.last_shminfo.shmaddr);
6896 shmctl(id->x.last_shminfo.shmid, IPC_RMID, 0);
6897 id->x.last_xim = NULL;
6898 xim = NULL;
6899 sxim = NULL;
6900 }
6901 else
6902 #endif /* HAVE_SHM */
6903 {
6904 XPutImage(id->x.disp, pmap, tgc, xim, 0, 0, 0, 0, w, h);
6905 XDestroyImage(xim);
6906 xim = NULL;
6907 sxim = NULL;
6908 /* XFreeGC(id->x.disp, tgc);*/
6909 }
6910 }
6911
6912 /* cleanup */
6913 /* XSync(id->x.disp, False);*/
6914 free(error);
6915 free(xarray);
6916 free(yarray);
6917
6918 /* add this pixmap to the cache */
6919 add_pixmap(id, im, w, h, xim, sxim);
6920 return 1;
6921 }
6922