?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
wmaker: removed unused constant SCROLL_STEPS in the switchpanel code
[wmaker-crm.git] / wrlib / convert.c
blob23df5c6663faab2cba9c1e96278bcc1d43f142d8
1 /* convert.c - convert RImage to Pixmap
2 *
3 * Raster graphics library
4 *
5 * Copyright (c) 1997-2003 Alfredo K. Kojima
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Library General Public
9 * License as published by the Free Software Foundation; either
10 * version 2 of the License, or (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Library General Public License for more details.
16 *
17 * You should have received a copy of the GNU Library General Public
18 * License along with this library; if not, write to the Free
19 * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston,
20 * MA 02110-1301, USA.
21 */
22
23 /* Problems:
24 * 1. Using Grayscale visual with Dithering crashes wmaker
25 * 2. Ghost dock/appicon is wrong in Pseudocolor, Staticgray, Grayscale
26 */
27
28 #include <config.h>
29 #include <X11/Xlib.h>
30 #include <X11/Xutil.h>
31 #include <stdlib.h>
32 #include <stdio.h>
33 #include <string.h>
34 #include <assert.h>
35
36 #include "wraster.h"
37 #include "convert.h"
38 #include "xutil.h"
39
40
41 #define NFREE(n) if (n) free(n)
42
43 #define HAS_ALPHA(I) ((I)->format == RRGBAFormat)
44
45 typedef struct RConversionTable {
46 unsigned short table[256];
47 unsigned short index;
48
49 struct RConversionTable *next;
50 } RConversionTable;
51
52 typedef struct RStdConversionTable {
53 unsigned int table[256];
54
55 unsigned short mult;
56 unsigned short max;
57
58 struct RStdConversionTable *next;
59 } RStdConversionTable;
60
61 static RConversionTable *conversionTable = NULL;
62 static RStdConversionTable *stdConversionTable = NULL;
63
64 static void release_conversion_table(void)
65 {
66 RConversionTable *tmp = conversionTable;
67
68 while (tmp) {
69 RConversionTable *tmp_to_delete = tmp;
70
71 tmp = tmp->next;
72 free(tmp_to_delete);
73 }
74 conversionTable = NULL;
75 }
76
77 static void release_std_conversion_table(void)
78 {
79 RStdConversionTable *tmp = stdConversionTable;
80
81 while (tmp) {
82 RStdConversionTable *tmp_to_delete = tmp;
83
84 tmp = tmp->next;
85 free(tmp_to_delete);
86 }
87 stdConversionTable = NULL;
88 }
89
90 void r_destroy_conversion_tables(void)
91 {
92 release_conversion_table();
93 release_std_conversion_table();
94 }
95
96 static unsigned short *computeTable(unsigned short mask)
97 {
98 RConversionTable *tmp = conversionTable;
99 int i;
100
101 while (tmp) {
102 if (tmp->index == mask)
103 break;
104 tmp = tmp->next;
105 }
106
107 if (tmp)
108 return tmp->table;
109
110 tmp = (RConversionTable *) malloc(sizeof(RConversionTable));
111 if (tmp == NULL)
112 return NULL;
113
114 for (i = 0; i < 256; i++)
115 tmp->table[i] = (i * mask + 0x7f) / 0xff;
116
117 tmp->index = mask;
118 tmp->next = conversionTable;
119 conversionTable = tmp;
120 return tmp->table;
121 }
122
123 static unsigned int *computeStdTable(unsigned int mult, unsigned int max)
124 {
125 RStdConversionTable *tmp = stdConversionTable;
126 unsigned int i;
127
128 while (tmp) {
129 if (tmp->mult == mult && tmp->max == max)
130 break;
131 tmp = tmp->next;
132 }
133
134 if (tmp)
135 return tmp->table;
136
137 tmp = (RStdConversionTable *) malloc(sizeof(RStdConversionTable));
138 if (tmp == NULL)
139 return NULL;
140
141 for (i = 0; i < 256; i++) {
142 tmp->table[i] = (i * max) / 0xff * mult;
143 }
144 tmp->mult = mult;
145 tmp->max = max;
146
147 tmp->next = stdConversionTable;
148 stdConversionTable = tmp;
149
150 return tmp->table;
151 }
152
153 /***************************************************************************/
154
155 static void
156 convertTrueColor_generic(RXImage * ximg, RImage * image,
157 signed char *err, signed char *nerr,
158 const unsigned short *rtable,
159 const unsigned short *gtable,
160 const unsigned short *btable,
161 const int dr, const int dg, const int db,
162 const unsigned short roffs, const unsigned short goffs, const unsigned short boffs)
163 {
164 signed char *terr;
165 int x, y, r, g, b;
166 int pixel;
167 int rer, ger, ber;
168 unsigned char *ptr = image->data;
169 int channels = (HAS_ALPHA(image) ? 4 : 3);
170
171 /* convert and dither the image to XImage */
172 for (y = 0; y < image->height; y++) {
173 nerr[0] = 0;
174 nerr[1] = 0;
175 nerr[2] = 0;
176 for (x = 0; x < image->width; x++, ptr += channels) {
177
178 /* reduce pixel */
179 pixel = *ptr + err[x];
180 if (pixel < 0)
181 pixel = 0;
182 else if (pixel > 0xff)
183 pixel = 0xff;
184 r = rtable[pixel];
185 /* calc error */
186 rer = pixel - r * dr;
187
188 /* reduce pixel */
189 pixel = *(ptr + 1) + err[x + 1];
190 if (pixel < 0)
191 pixel = 0;
192 else if (pixel > 0xff)
193 pixel = 0xff;
194 g = gtable[pixel];
195 /* calc error */
196 ger = pixel - g * dg;
197
198 /* reduce pixel */
199 pixel = *(ptr + 2) + err[x + 2];
200 if (pixel < 0)
201 pixel = 0;
202 else if (pixel > 0xff)
203 pixel = 0xff;
204 b = btable[pixel];
205 /* calc error */
206 ber = pixel - b * db;
207
208 pixel = (r << roffs) | (g << goffs) | (b << boffs);
209 XPutPixel(ximg->image, x, y, pixel);
210
211 /* distribute error */
212 r = (rer * 3) / 8;
213 g = (ger * 3) / 8;
214 b = (ber * 3) / 8;
215 /* x+1, y */
216 err[x + 3 * 1] += r;
217 err[x + 1 + 3 * 1] += g;
218 err[x + 2 + 3 * 1] += b;
219 /* x, y+1 */
220 nerr[x] += r;
221 nerr[x + 1] += g;
222 nerr[x + 2] += b;
223 /* x+1, y+1 */
224 nerr[x + 3 * 1] = rer - 2 * r;
225 nerr[x + 1 + 3 * 1] = ger - 2 * g;
226 nerr[x + 2 + 3 * 1] = ber - 2 * b;
227 }
228 /* skip to next line */
229 terr = err;
230 err = nerr;
231 nerr = terr;
232 }
233
234 /* redither the 1st line to distribute error better */
235 ptr = image->data;
236 y = 0;
237 nerr[0] = 0;
238 nerr[1] = 0;
239 nerr[2] = 0;
240 for (x = 0; x < image->width; x++, ptr += channels) {
241
242 /* reduce pixel */
243 pixel = *ptr + err[x];
244 if (pixel < 0)
245 pixel = 0;
246 else if (pixel > 0xff)
247 pixel = 0xff;
248 r = rtable[pixel];
249 /* calc error */
250 rer = pixel - r * dr;
251
252 /* reduce pixel */
253 pixel = *(ptr + 1) + err[x + 1];
254 if (pixel < 0)
255 pixel = 0;
256 else if (pixel > 0xff)
257 pixel = 0xff;
258 g = gtable[pixel];
259 /* calc error */
260 ger = pixel - g * dg;
261
262 /* reduce pixel */
263 pixel = *(ptr + 2) + err[x + 2];
264 if (pixel < 0)
265 pixel = 0;
266 else if (pixel > 0xff)
267 pixel = 0xff;
268 b = btable[pixel];
269 /* calc error */
270 ber = pixel - b * db;
271
272 pixel = (r << roffs) | (g << goffs) | (b << boffs);
273 XPutPixel(ximg->image, x, y, pixel);
274
275 /* distribute error */
276 r = (rer * 3) / 8;
277 g = (ger * 3) / 8;
278 b = (ber * 3) / 8;
279 /* x+1, y */
280 err[x + 3 * 1] += r;
281 err[x + 1 + 3 * 1] += g;
282 err[x + 2 + 3 * 1] += b;
283 /* x, y+1 */
284 nerr[x] += r;
285 nerr[x + 1] += g;
286 nerr[x + 2] += b;
287 /* x+1, y+1 */
288 nerr[x + 3 * 1] = rer - 2 * r;
289 nerr[x + 1 + 3 * 1] = ger - 2 * g;
290 nerr[x + 2 + 3 * 1] = ber - 2 * b;
291 }
292 }
293
294 static RXImage *image2TrueColor(RContext * ctx, RImage * image)
295 {
296 RXImage *ximg;
297 unsigned short rmask, gmask, bmask;
298 unsigned short roffs, goffs, boffs;
299 unsigned short *rtable, *gtable, *btable;
300 int channels = (HAS_ALPHA(image) ? 4 : 3);
301
302 ximg = RCreateXImage(ctx, ctx->depth, image->width, image->height);
303 if (!ximg) {
304 return NULL;
305 }
306
307 roffs = ctx->red_offset;
308 goffs = ctx->green_offset;
309 boffs = ctx->blue_offset;
310
311 rmask = ctx->visual->red_mask >> roffs;
312 gmask = ctx->visual->green_mask >> goffs;
313 bmask = ctx->visual->blue_mask >> boffs;
314
315 rtable = computeTable(rmask);
316 gtable = computeTable(gmask);
317 btable = computeTable(bmask);
318
319 if (rtable == NULL || gtable == NULL || btable == NULL) {
320 RErrorCode = RERR_NOMEMORY;
321 RDestroyXImage(ctx, ximg);
322 return NULL;
323 }
324
325 if (ctx->attribs->render_mode == RBestMatchRendering) {
326 int ofs;
327 unsigned long r, g, b;
328 int x, y;
329 unsigned long pixel;
330 unsigned char *ptr = image->data;
331
332 /* fake match */
333 #ifdef WRLIB_DEBUG
334 fputs("true color match\n", stderr);
335 #endif
336 if (rmask == 0xff && gmask == 0xff && bmask == 0xff) {
337 for (y = 0; y < image->height; y++) {
338 for (x = 0; x < image->width; x++, ptr += channels) {
339 /* reduce pixel */
340 r = ptr[0];
341 g = ptr[1];
342 b = ptr[2];
343 pixel = (r << roffs) | (g << goffs) | (b << boffs);
344 XPutPixel(ximg->image, x, y, pixel);
345 }
346 }
347 } else {
348 for (y = 0, ofs = 0; y < image->height; y++) {
349 for (x = 0; x < image->width; x++, ofs += channels - 3) {
350 /* reduce pixel */
351 r = rtable[ptr[ofs++]];
352 g = gtable[ptr[ofs++]];
353 b = btable[ptr[ofs++]];
354 pixel = (r << roffs) | (g << goffs) | (b << boffs);
355 XPutPixel(ximg->image, x, y, pixel);
356 }
357 }
358 }
359 } else {
360 /* dither */
361 const int dr = 0xff / rmask;
362 const int dg = 0xff / gmask;
363 const int db = 0xff / bmask;
364
365 #ifdef WRLIB_DEBUG
366 fputs("true color dither\n", stderr);
367 #endif
368
369 {
370 signed char *err;
371 signed char *nerr;
372 int ch = (HAS_ALPHA(image) ? 4 : 3);
373
374 err = malloc(ch * (image->width + 2));
375 nerr = malloc(ch * (image->width + 2));
376 if (!err || !nerr) {
377 NFREE(err);
378 NFREE(nerr);
379 RErrorCode = RERR_NOMEMORY;
380 RDestroyXImage(ctx, ximg);
381 return NULL;
382 }
383
384 memset(err, 0, ch * (image->width + 2));
385 memset(nerr, 0, ch * (image->width + 2));
386
387 convertTrueColor_generic(ximg, image, err, nerr,
388 rtable, gtable, btable, dr, dg, db, roffs, goffs, boffs);
389 free(err);
390 free(nerr);
391 }
392
393 }
394
395 return ximg;
396 }
397
398 /***************************************************************************/
399
400 static void
401 convertPseudoColor_to_8(RXImage * ximg, RImage * image,
402 signed char *err, signed char *nerr,
403 const unsigned short *rtable,
404 const unsigned short *gtable,
405 const unsigned short *btable,
406 const int dr, const int dg, const int db, unsigned long *pixels, int cpc)
407 {
408 signed char *terr;
409 int x, y, r, g, b;
410 int pixel;
411 int rer, ger, ber;
412 unsigned char *ptr = image->data;
413 unsigned char *optr = (unsigned char *)ximg->image->data;
414 int channels = (HAS_ALPHA(image) ? 4 : 3);
415 int cpcpc = cpc * cpc;
416
417 /* convert and dither the image to XImage */
418 for (y = 0; y < image->height; y++) {
419 nerr[0] = 0;
420 nerr[1] = 0;
421 nerr[2] = 0;
422 for (x = 0; x < image->width * 3; x += 3, ptr += channels) {
423
424 /* reduce pixel */
425 pixel = *ptr + err[x];
426 if (pixel < 0)
427 pixel = 0;
428 else if (pixel > 0xff)
429 pixel = 0xff;
430 r = rtable[pixel];
431 /* calc error */
432 rer = pixel - r * dr;
433
434 /* reduce pixel */
435 pixel = *(ptr + 1) + err[x + 1];
436 if (pixel < 0)
437 pixel = 0;
438 else if (pixel > 0xff)
439 pixel = 0xff;
440 g = gtable[pixel];
441 /* calc error */
442 ger = pixel - g * dg;
443
444 /* reduce pixel */
445 pixel = *(ptr + 2) + err[x + 2];
446 if (pixel < 0)
447 pixel = 0;
448 else if (pixel > 0xff)
449 pixel = 0xff;
450 b = btable[pixel];
451 /* calc error */
452 ber = pixel - b * db;
453
454 *optr++ = pixels[r * cpcpc + g * cpc + b];
455
456 /* distribute error */
457 r = (rer * 3) / 8;
458 g = (ger * 3) / 8;
459 b = (ber * 3) / 8;
460
461 /* x+1, y */
462 err[x + 3 * 1] += r;
463 err[x + 1 + 3 * 1] += g;
464 err[x + 2 + 3 * 1] += b;
465 /* x, y+1 */
466 nerr[x] += r;
467 nerr[x + 1] += g;
468 nerr[x + 2] += b;
469 /* x+1, y+1 */
470 nerr[x + 3 * 1] = rer - 2 * r;
471 nerr[x + 1 + 3 * 1] = ger - 2 * g;
472 nerr[x + 2 + 3 * 1] = ber - 2 * b;
473 }
474 /* skip to next line */
475 terr = err;
476 err = nerr;
477 nerr = terr;
478
479 optr += ximg->image->bytes_per_line - image->width;
480 }
481 }
482
483 static RXImage *image2PseudoColor(RContext * ctx, RImage * image)
484 {
485 RXImage *ximg;
486 register int x, y, r, g, b;
487 unsigned char *ptr;
488 unsigned long pixel;
489 const int cpc = ctx->attribs->colors_per_channel;
490 const unsigned short rmask = cpc - 1; /* different sizes could be used */
491 const unsigned short gmask = rmask; /* for r,g,b */
492 const unsigned short bmask = rmask;
493 unsigned short *rtable, *gtable, *btable;
494 const int cpccpc = cpc * cpc;
495 int channels = (HAS_ALPHA(image) ? 4 : 3);
496
497 ximg = RCreateXImage(ctx, ctx->depth, image->width, image->height);
498 if (!ximg) {
499 return NULL;
500 }
501
502 ptr = image->data;
503
504 /* Tables are same at the moment because rmask==gmask==bmask. */
505 rtable = computeTable(rmask);
506 gtable = computeTable(gmask);
507 btable = computeTable(bmask);
508
509 if (rtable == NULL || gtable == NULL || btable == NULL) {
510 RErrorCode = RERR_NOMEMORY;
511 RDestroyXImage(ctx, ximg);
512 return NULL;
513 }
514
515 if (ctx->attribs->render_mode == RBestMatchRendering) {
516 /* fake match */
517 #ifdef WRLIB_DEBUG
518 fprintf(stderr, "pseudo color match with %d colors per channel\n", cpc);
519 #endif
520 for (y = 0; y < image->height; y++) {
521 for (x = 0; x < image->width; x++, ptr += channels - 3) {
522 /* reduce pixel */
523 r = rtable[*ptr++];
524 g = gtable[*ptr++];
525 b = btable[*ptr++];
526 pixel = r * cpccpc + g * cpc + b;
527 /*data[ofs] = ctx->colors[pixel].pixel; */
528 XPutPixel(ximg->image, x, y, ctx->colors[pixel].pixel);
529 }
530 }
531 } else {
532 /* dither */
533 signed char *err;
534 signed char *nerr;
535 const int dr = 0xff / rmask;
536 const int dg = 0xff / gmask;
537 const int db = 0xff / bmask;
538
539 #ifdef WRLIB_DEBUG
540 fprintf(stderr, "pseudo color dithering with %d colors per channel\n", cpc);
541 #endif
542 err = malloc(4 * (image->width + 3));
543 nerr = malloc(4 * (image->width + 3));
544 if (!err || !nerr) {
545 NFREE(err);
546 NFREE(nerr);
547 RErrorCode = RERR_NOMEMORY;
548 RDestroyXImage(ctx, ximg);
549 return NULL;
550 }
551 memset(err, 0, 4 * (image->width + 3));
552 memset(nerr, 0, 4 * (image->width + 3));
553
554 convertPseudoColor_to_8(ximg, image, err + 4, nerr + 4,
555 rtable, gtable, btable, dr, dg, db, ctx->pixels, cpc);
556
557 free(err);
558 free(nerr);
559 }
560
561 return ximg;
562 }
563
564 /*
565 * For standard colormap
566 */
567 static RXImage *image2StandardPseudoColor(RContext * ctx, RImage * image)
568 {
569 RXImage *ximg;
570 register int x, y, r, g, b;
571 unsigned char *ptr;
572 unsigned long pixel;
573 unsigned char *data;
574 unsigned int *rtable, *gtable, *btable;
575 unsigned int base_pixel = ctx->std_rgb_map->base_pixel;
576 int channels = (HAS_ALPHA(image) ? 4 : 3);
577
578 ximg = RCreateXImage(ctx, ctx->depth, image->width, image->height);
579 if (!ximg) {
580 return NULL;
581 }
582
583 ptr = image->data;
584
585 data = (unsigned char *)ximg->image->data;
586
587 rtable = computeStdTable(ctx->std_rgb_map->red_mult, ctx->std_rgb_map->red_max);
588
589 gtable = computeStdTable(ctx->std_rgb_map->green_mult, ctx->std_rgb_map->green_max);
590
591 btable = computeStdTable(ctx->std_rgb_map->blue_mult, ctx->std_rgb_map->blue_max);
592
593 if (rtable == NULL || gtable == NULL || btable == NULL) {
594 RErrorCode = RERR_NOMEMORY;
595 RDestroyXImage(ctx, ximg);
596 return NULL;
597 }
598
599 if (ctx->attribs->render_mode == RBestMatchRendering) {
600 for (y = 0; y < image->height; y++) {
601 for (x = 0; x < image->width; x++, ptr += channels) {
602 /* reduce pixel */
603 pixel = (rtable[*ptr] + gtable[*(ptr + 1)]
604 + btable[*(ptr + 2)] + base_pixel) & 0xffffffff;
605
606 XPutPixel(ximg->image, x, y, pixel);
607 }
608 }
609 } else {
610 /* dither */
611 signed short *err, *nerr;
612 signed short *terr;
613 int rer, ger, ber;
614 int x1, ofs;
615
616 #ifdef WRLIB_DEBUG
617 fprintf(stderr, "pseudo color dithering with %d colors per channel\n",
618 ctx->attribs->colors_per_channel);
619 #endif
620 err = (short *)malloc(3 * (image->width + 2) * sizeof(short));
621 nerr = (short *)malloc(3 * (image->width + 2) * sizeof(short));
622 if (!err || !nerr) {
623 NFREE(err);
624 NFREE(nerr);
625 RErrorCode = RERR_NOMEMORY;
626 RDestroyXImage(ctx, ximg);
627 return NULL;
628 }
629 for (x = 0, x1 = 0; x < image->width * 3; x1 += channels - 3) {
630 err[x++] = ptr[x1++];
631 err[x++] = ptr[x1++];
632 err[x++] = ptr[x1++];
633 }
634 err[x] = err[x + 1] = err[x + 2] = 0;
635 /* convert and dither the image to XImage */
636 for (y = 0, ofs = 0; y < image->height; y++) {
637 if (y < image->height - 1) {
638 int x1;
639 for (x = 0, x1 = (y + 1) * image->width * channels;
640 x < image->width * 3; x1 += channels - 3) {
641 nerr[x++] = ptr[x1++];
642 nerr[x++] = ptr[x1++];
643 nerr[x++] = ptr[x1++];
644 }
645 /* last column */
646 x1 -= channels;
647 nerr[x++] = ptr[x1++];
648 nerr[x++] = ptr[x1++];
649 nerr[x++] = ptr[x1++];
650 }
651 for (x = 0; x < image->width * 3; x += 3, ofs++) {
652 /* reduce pixel */
653 if (err[x] > 0xff)
654 err[x] = 0xff;
655 else if (err[x] < 0)
656 err[x] = 0;
657 if (err[x + 1] > 0xff)
658 err[x + 1] = 0xff;
659 else if (err[x + 1] < 0)
660 err[x + 1] = 0;
661 if (err[x + 2] > 0xff)
662 err[x + 2] = 0xff;
663 else if (err[x + 2] < 0)
664 err[x + 2] = 0;
665
666 r = rtable[err[x]];
667 g = gtable[err[x + 1]];
668 b = btable[err[x + 2]];
669
670 pixel = r + g + b;
671
672 data[ofs] = base_pixel + pixel;
673
674 /* calc error */
675 rer = err[x] - (ctx->colors[pixel].red >> 8);
676 ger = err[x + 1] - (ctx->colors[pixel].green >> 8);
677 ber = err[x + 2] - (ctx->colors[pixel].blue >> 8);
678
679 /* distribute error */
680 err[x + 3 * 1] += (rer * 7) / 16;
681 err[x + 1 + 3 * 1] += (ger * 7) / 16;
682 err[x + 2 + 3 * 1] += (ber * 7) / 16;
683
684 nerr[x] += (rer * 5) / 16;
685 nerr[x + 1] += (ger * 5) / 16;
686 nerr[x + 2] += (ber * 5) / 16;
687
688 if (x > 0) {
689 nerr[x - 3 * 1] += (rer * 3) / 16;
690 nerr[x - 3 * 1 + 1] += (ger * 3) / 16;
691 nerr[x - 3 * 1 + 2] += (ber * 3) / 16;
692 }
693
694 nerr[x + 3 * 1] += rer / 16;
695 nerr[x + 1 + 3 * 1] += ger / 16;
696 nerr[x + 2 + 3 * 1] += ber / 16;
697 }
698 /* skip to next line */
699 terr = err;
700 err = nerr;
701 nerr = terr;
702
703 ofs += ximg->image->bytes_per_line - image->width;
704 }
705 free(err);
706 free(nerr);
707 }
708 ximg->image->data = (char *)data;
709
710 return ximg;
711 }
712
713 static RXImage *image2GrayScale(RContext * ctx, RImage * image)
714 {
715 RXImage *ximg;
716 register int x, y, g;
717 unsigned char *ptr;
718 const int cpc = ctx->attribs->colors_per_channel;
719 unsigned short gmask;
720 unsigned short *table;
721 unsigned char *data;
722 int channels = (HAS_ALPHA(image) ? 4 : 3);
723
724 ximg = RCreateXImage(ctx, ctx->depth, image->width, image->height);
725 if (!ximg) {
726 return NULL;
727 }
728
729 ptr = image->data;
730
731 data = (unsigned char *)ximg->image->data;
732
733 if (ctx->vclass == StaticGray)
734 gmask = (1 << ctx->depth) - 1; /* use all grays */
735 else
736 gmask = cpc * cpc * cpc - 1;
737
738 table = computeTable(gmask);
739
740 if (table == NULL) {
741 RErrorCode = RERR_NOMEMORY;
742 RDestroyXImage(ctx, ximg);
743 return NULL;
744 }
745
746 if (ctx->attribs->render_mode == RBestMatchRendering) {
747 /* fake match */
748 #ifdef WRLIB_DEBUG
749 fprintf(stderr, "grayscale match with %d colors per channel\n", cpc);
750 #endif
751 for (y = 0; y < image->height; y++) {
752 for (x = 0; x < image->width; x++) {
753 /* reduce pixel */
754 g = table[(*ptr * 30 + *(ptr + 1) * 59 + *(ptr + 2) * 11) / 100];
755 ptr += channels;
756 /*data[ofs] = ctx->colors[g].pixel; */
757 XPutPixel(ximg->image, x, y, ctx->colors[g].pixel);
758 }
759 }
760 } else {
761 /* dither */
762 short *gerr;
763 short *ngerr;
764 short *terr;
765 int ger;
766 const int dg = 0xff / gmask;
767
768 #ifdef WRLIB_DEBUG
769 fprintf(stderr, "grayscale dither with %d colors per channel\n", cpc);
770 #endif
771 gerr = (short *)malloc((image->width + 2) * sizeof(short));
772 ngerr = (short *)malloc((image->width + 2) * sizeof(short));
773 if (!gerr || !ngerr) {
774 NFREE(gerr);
775 NFREE(ngerr);
776 RErrorCode = RERR_NOMEMORY;
777 RDestroyXImage(ctx, ximg);
778 return NULL;
779 }
780 for (x = 0, y = 0; x < image->width; x++, y += channels) {
781 gerr[x] = (ptr[y] * 30 + ptr[y + 1] * 59 + ptr[y + 2] * 11) / 100;
782 }
783 gerr[x] = 0;
784 /* convert and dither the image to XImage */
785 for (y = 0; y < image->height; y++) {
786 if (y < image->height - 1) {
787 int x1;
788 for (x = 0, x1 = (y + 1) * image->width * channels; x < image->width;
789 x++, x1 += channels) {
790 ngerr[x] = (ptr[x1] * 30 + ptr[x1 + 1] * 59 + ptr[x1 + 2] * 11) / 100;
791 }
792 /* last column */
793 x1 -= channels;
794 ngerr[x] = (ptr[x1] * 30 + ptr[x1 + 1] * 59 + ptr[x1 + 2] * 11) / 100;
795 }
796 for (x = 0; x < image->width; x++) {
797 /* reduce pixel */
798 if (gerr[x] > 0xff)
799 gerr[x] = 0xff;
800 else if (gerr[x] < 0)
801 gerr[x] = 0;
802
803 g = table[gerr[x]];
804
805 /*data[ofs] = ctx->colors[g].pixel; */
806 XPutPixel(ximg->image, x, y, ctx->colors[g].pixel);
807 /* calc error */
808 ger = gerr[x] - g * dg;
809
810 /* distribute error */
811 g = (ger * 3) / 8;
812 /* x+1, y */
813 gerr[x + 1] += g;
814 /* x, y+1 */
815 ngerr[x] += g;
816 /* x+1, y+1 */
817 ngerr[x + 1] += ger - 2 * g;
818 }
819 /* skip to next line */
820 terr = gerr;
821 gerr = ngerr;
822 ngerr = terr;
823 }
824 free(gerr);
825 free(ngerr);
826 }
827 ximg->image->data = (char *)data;
828
829 return ximg;
830 }
831
832 static RXImage *image2Bitmap(RContext * ctx, RImage * image, int threshold)
833 {
834 RXImage *ximg;
835 unsigned char *alpha;
836 int x, y;
837
838 ximg = RCreateXImage(ctx, 1, image->width, image->height);
839 if (!ximg) {
840 return NULL;
841 }
842 alpha = image->data + 3;
843
844 for (y = 0; y < image->height; y++) {
845 for (x = 0; x < image->width; x++) {
846 XPutPixel(ximg->image, x, y, (*alpha <= threshold ? 0 : 1));
847 alpha += 4;
848 }
849 }
850
851 return ximg;
852 }
853
854 int RConvertImage(RContext * context, RImage * image, Pixmap * pixmap)
855 {
856 RXImage *ximg = NULL;
857 #ifdef USE_XSHM
858 Pixmap tmp;
859 #endif
860
861 assert(context != NULL);
862 assert(image != NULL);
863 assert(pixmap != NULL);
864
865 switch (context->vclass) {
866 case TrueColor:
867 ximg = image2TrueColor(context, image);
868 break;
869
870 case PseudoColor:
871 case StaticColor:
872 if (context->attribs->standard_colormap_mode != RIgnoreStdColormap)
873 ximg = image2StandardPseudoColor(context, image);
874 else
875 ximg = image2PseudoColor(context, image);
876 break;
877
878 case GrayScale:
879 case StaticGray:
880 ximg = image2GrayScale(context, image);
881 break;
882 }
883
884 if (!ximg) {
885 return False;
886 }
887
888 *pixmap = XCreatePixmap(context->dpy, context->drawable, image->width, image->height, context->depth);
889
890 #ifdef USE_XSHM
891 if (context->flags.use_shared_pixmap && ximg->is_shared)
892 tmp = R_CreateXImageMappedPixmap(context, ximg);
893 else
894 tmp = None;
895 if (tmp) {
896 /*
897 * We have to copy the shm Pixmap into a normal Pixmap because
898 * otherwise, we would have to control when Pixmaps are freed so
899 * that we can detach their shm segments. This is a problem if the
900 * program crash, leaving stale shared memory segments in the
901 * system (lots of them). But with some work, we can optimize
902 * things and remove this XCopyArea. This will require
903 * explicitly freeing all pixmaps when exiting or restarting
904 * wmaker.
905 */
906 XCopyArea(context->dpy, tmp, *pixmap, context->copy_gc, 0, 0, image->width, image->height, 0, 0);
907 XFreePixmap(context->dpy, tmp);
908 } else {
909 RPutXImage(context, *pixmap, context->copy_gc, ximg, 0, 0, 0, 0, image->width, image->height);
910 }
911 #else /* !USE_XSHM */
912 RPutXImage(context, *pixmap, context->copy_gc, ximg, 0, 0, 0, 0, image->width, image->height);
913 #endif /* !USE_XSHM */
914
915 RDestroyXImage(context, ximg);
916
917 return True;
918 }
919
920 /* make the gc permanent (create with context creation).
921 * GC creation is very expensive. altering its properties is not. -Dan
922 */
923 int RConvertImageMask(RContext * context, RImage * image, Pixmap * pixmap, Pixmap * mask, int threshold)
924 {
925 GC gc;
926 XGCValues gcv;
927 RXImage *ximg = NULL;
928
929 assert(context != NULL);
930 assert(image != NULL);
931 assert(pixmap != NULL);
932 assert(mask != NULL);
933
934 if (!RConvertImage(context, image, pixmap))
935 return False;
936
937 if (image->format == RRGBFormat) {
938 *mask = None;
939 return True;
940 }
941
942 ximg = image2Bitmap(context, image, threshold);
943
944 if (!ximg) {
945 return False;
946 }
947 *mask = XCreatePixmap(context->dpy, context->drawable, image->width, image->height, 1);
948 gcv.foreground = context->black;
949 gcv.background = context->white;
950 gcv.graphics_exposures = False;
951 gc = XCreateGC(context->dpy, *mask, GCForeground | GCBackground | GCGraphicsExposures, &gcv);
952 RPutXImage(context, *mask, gc, ximg, 0, 0, 0, 0, image->width, image->height);
953 RDestroyXImage(context, ximg);
954 XFreeGC(context->dpy, gc);
955
956 return True;
957 }
958
959 Bool RGetClosestXColor(RContext * context, const RColor * color, XColor * retColor)
960 {
961 if (context->vclass == TrueColor) {
962 unsigned short rmask, gmask, bmask;
963 unsigned short roffs, goffs, boffs;
964 unsigned short *rtable, *gtable, *btable;
965
966 roffs = context->red_offset;
967 goffs = context->green_offset;
968 boffs = context->blue_offset;
969
970 rmask = context->visual->red_mask >> roffs;
971 gmask = context->visual->green_mask >> goffs;
972 bmask = context->visual->blue_mask >> boffs;
973
974 rtable = computeTable(rmask);
975 gtable = computeTable(gmask);
976 btable = computeTable(bmask);
977
978 retColor->pixel = (((unsigned long) rtable[color->red]) << roffs)
979 | (((unsigned long) gtable[color->green]) << goffs)
980 | (((unsigned long) btable[color->blue]) << boffs);
981
982 retColor->red = color->red << 8;
983 retColor->green = color->green << 8;
984 retColor->blue = color->blue << 8;
985 retColor->flags = DoRed | DoGreen | DoBlue;
986
987 } else if (context->vclass == PseudoColor || context->vclass == StaticColor) {
988
989 if (context->attribs->standard_colormap_mode != RIgnoreStdColormap) {
990 unsigned int *rtable, *gtable, *btable;
991
992 rtable = computeStdTable(context->std_rgb_map->red_mult, context->std_rgb_map->red_max);
993
994 gtable = computeStdTable(context->std_rgb_map->green_mult,
995 context->std_rgb_map->green_max);
996
997 btable = computeStdTable(context->std_rgb_map->blue_mult, context->std_rgb_map->blue_max);
998
999 if (rtable == NULL || gtable == NULL || btable == NULL) {
1000 RErrorCode = RERR_NOMEMORY;
1001 return False;
1002 }
1003
1004 retColor->pixel = (rtable[color->red]
1005 + gtable[color->green]
1006 + btable[color->blue]
1007 + context->std_rgb_map->base_pixel) & 0xffffffff;
1008 retColor->red = color->red << 8;
1009 retColor->green = color->green << 8;
1010 retColor->blue = color->blue << 8;
1011 retColor->flags = DoRed | DoGreen | DoBlue;
1012
1013 } else {
1014 const int cpc = context->attribs->colors_per_channel;
1015 const unsigned short rmask = cpc - 1; /* different sizes could be used */
1016 const unsigned short gmask = rmask; /* for r,g,b */
1017 const unsigned short bmask = rmask;
1018 unsigned short *rtable, *gtable, *btable;
1019 const int cpccpc = cpc * cpc;
1020 int index;
1021
1022 rtable = computeTable(rmask);
1023 gtable = computeTable(gmask);
1024 btable = computeTable(bmask);
1025
1026 if (rtable == NULL || gtable == NULL || btable == NULL) {
1027 RErrorCode = RERR_NOMEMORY;
1028 return False;
1029 }
1030 index = rtable[color->red] * cpccpc + gtable[color->green] * cpc + btable[color->blue];
1031 *retColor = context->colors[index];
1032 }
1033
1034 } else if (context->vclass == GrayScale || context->vclass == StaticGray) {
1035
1036 const int cpc = context->attribs->colors_per_channel;
1037 unsigned short gmask;
1038 unsigned short *table;
1039 int index;
1040
1041 if (context->vclass == StaticGray)
1042 gmask = (1 << context->depth) - 1; /* use all grays */
1043 else
1044 gmask = cpc * cpc * cpc - 1;
1045
1046 table = computeTable(gmask);
1047 if (!table)
1048 return False;
1049
1050 index = table[(color->red * 30 + color->green * 59 + color->blue * 11) / 100];
1051
1052 *retColor = context->colors[index];
1053 } else {
1054 RErrorCode = RERR_INTERNAL;
1055 return False;
1056 }
1057
1058 return True;
1059 }
The Window Maker window manager