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