Some fixes from Alban
[wmaker-crm.git] / wrlib / raster.c
blob47038739174ae4be8760b594fe7875b969db2e8c
1 /* raster.c - main and other misc stuff
2 *
3 * Raster graphics library
4 *
5 * Copyright (c) 1997-2000 Alfredo K. Kojima
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.
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.
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.
22 #include <config.h>
24 #include <stdlib.h>
25 #include <stdio.h>
26 #include <string.h>
27 #include <X11/Xlib.h>
28 #include "wraster.h"
30 #include <assert.h>
33 char *WRasterLibVersion="0.9";
35 int RErrorCode=RERR_NONE;
38 #define HAS_ALPHA(I) ((I)->format == RRGBAFormat)
41 RImage*
42 RCreateImage(unsigned width, unsigned height, int alpha)
44 RImage *image=NULL;
46 assert(width>0 && height>0);
48 image = malloc(sizeof(RImage));
49 if (!image) {
50 RErrorCode = RERR_NOMEMORY;
51 return NULL;
54 memset(image, 0, sizeof(RImage));
55 image->width = width;
56 image->height = height;
57 if (alpha) {
58 image->format = RRGBAFormat;
59 } else {
60 image->format = RRGBFormat;
62 /* the +4 is to give extra bytes at the end of the buffer,
63 * so that we can optimize image conversion for MMX(tm).. see convert.c
65 image->data = malloc(width * height * (alpha ? 4 : 3) + 4);
66 if (!image->data) {
67 RErrorCode = RERR_NOMEMORY;
68 free(image);
69 image = NULL;
72 return image;
77 RImage*
78 RCloneImage(RImage *image)
80 RImage *new_image;
82 assert(image!=NULL);
84 new_image = RCreateImage(image->width, image->height, HAS_ALPHA(image));
85 if (!new_image)
86 return NULL;
88 new_image->background = image->background;
89 memcpy(new_image->data, image->data,
90 image->width*image->height*(HAS_ALPHA(image) ? 4 : 3));
92 return new_image;
96 RImage*
97 RGetSubImage(RImage *image, int x, int y, unsigned width, unsigned height)
99 int i, ofs;
100 RImage *new_image;
101 unsigned total_line_size, line_size;
103 assert(image!=NULL);
104 assert(x>=0 && y>=0);
105 assert(x<image->width && y<image->height);
106 assert(width>0 && height>0);
108 if (x+width > image->width)
109 width = image->width-x;
110 if (y+height > image->height)
111 height = image->height-y;
113 new_image = RCreateImage(width, height, HAS_ALPHA(image));
115 if (!new_image)
116 return NULL;
117 new_image->background = image->background;
119 total_line_size = image->width * (HAS_ALPHA(image) ? 4 : 3);
120 line_size = width * (HAS_ALPHA(image) ? 4 : 3);
122 ofs = x*(HAS_ALPHA(image) ? 4 : 3) + y*total_line_size;;
124 for (i=0; i<height; i++) {
125 memcpy(&new_image->data[i*line_size],
126 &image->data[i*total_line_size+ofs], line_size);
128 return new_image;
132 void
133 RDestroyImage(RImage *image)
135 assert(image!=NULL);
137 free(image->data);
138 free(image);
143 *----------------------------------------------------------------------
144 * RCombineImages-
145 * Combines two equal sized images with alpha image. The second
146 * image will be placed on top of the first one.
147 *----------------------------------------------------------------------
149 void
150 RCombineImages(RImage *image, RImage *src)
152 assert(image->width == src->width);
153 assert(image->height == src->height);
155 if (!HAS_ALPHA(src)) {
156 if (!HAS_ALPHA(image)) {
157 memcpy(image->data, src->data, image->height*image->width*3);
158 } else {
159 int x, y;
160 unsigned char *d, *s;
162 d = image->data;
163 s = src->data;
164 for (y = 0; y < image->height; y++) {
165 for (x = 0; x < image->width; x++) {
166 *d++ = *s++;
167 *d++ = *s++;
168 *d++ = *s++;
169 d++;
173 } else {
174 register int i;
175 unsigned char *d;
176 unsigned char *s;
177 int alpha, calpha;
179 d = image->data;
180 s = src->data;
182 if (!HAS_ALPHA(image)) {
183 for (i=0; i<image->height*image->width; i++) {
184 alpha = *(s+3);
185 calpha = 255 - alpha;
186 *d = (((int)*d * calpha) + ((int)*s * alpha))/256;
187 d++; s++;
188 *d = (((int)*d * calpha) + ((int)*s * alpha))/256;
189 d++; s++;
190 *d = (((int)*d * calpha) + ((int)*s * alpha))/256;
191 d++; s++;
192 s++;
194 } else {
195 for (i=0; i<image->height*image->width; i++) {
196 alpha = *(s+3);
197 calpha = 255 - alpha;
198 *d = (((int)*d * calpha) + ((int)*s * alpha))/256;
199 d++; s++;
200 *d = (((int)*d * calpha) + ((int)*s * alpha))/256;
201 d++; s++;
202 *d = (((int)*d * calpha) + ((int)*s * alpha))/256;
203 d++; s++;
204 *d++ |= *s++;
213 void
214 RCombineImagesWithOpaqueness(RImage *image, RImage *src, int opaqueness)
216 register int i;
217 unsigned char *d;
218 unsigned char *s;
219 int c_opaqueness;
221 assert(image->width == src->width);
222 assert(image->height == src->height);
224 d = image->data;
225 s = src->data;
227 c_opaqueness = 255 - opaqueness;
228 #define OP opaqueness
229 if (!HAS_ALPHA(src)) {
230 int dalpha = HAS_ALPHA(image);
231 #define COP c_opaqueness
232 for (i=0; i < image->width*image->height; i++) {
233 *d = (((int)*d *(int)COP) + ((int)*s *(int)OP))/256;
234 d++; s++;
235 *d = (((int)*d *(int)COP) + ((int)*s *(int)OP))/256;
236 d++; s++;
237 *d = (((int)*d *(int)COP) + ((int)*s *(int)OP))/256;
238 d++; s++;
239 if (dalpha) {
240 d++;
243 #undef COP
244 } else {
245 int tmp;
247 if (!HAS_ALPHA(image)) {
248 for (i=0; i<image->width*image->height; i++) {
249 tmp = (*(s+3) * opaqueness)/256;
250 *d = (((int)*d * (255-tmp)) + ((int)*s * tmp))/256;
251 d++; s++;
252 *d = (((int)*d * (255-tmp)) + ((int)*s * tmp))/256;
253 d++; s++;
254 *d = (((int)*d * (255-tmp)) + ((int)*s * tmp))/256;
255 d++; s++;
256 s++;
258 } else {
259 for (i=0; i<image->width*image->height; i++) {
260 tmp = (*(s+3) * opaqueness)/256;
261 *d = (((int)*d * (255-tmp)) + ((int)*s * tmp))/256;
262 d++; s++;
263 *d = (((int)*d * (255-tmp)) + ((int)*s * tmp))/256;
264 d++; s++;
265 *d = (((int)*d * (255-tmp)) + ((int)*s * tmp))/256;
266 d++; s++;
267 *d |= tmp;
268 d++; s++;
272 #undef OP
276 void
277 RCombineArea(RImage *image, RImage *src, int sx, int sy, unsigned width,
278 unsigned height, int dx, int dy)
280 int x, y, dwi, swi;
281 unsigned char *d;
282 unsigned char *s;
283 int alpha, calpha;
286 assert(dy < image->height);
287 assert(dx < image->width);
289 assert(sy + height <= src->height);
290 assert(sx + width <= src->width);
293 if (height > image->height - dy)
294 height = image->height - dy;
296 if (!HAS_ALPHA(src)) {
297 if (!HAS_ALPHA(image)) {
298 swi = (src->width - width) * 3;
299 dwi = (image->width - width) * 3;
301 d = image->data + dy*(int)image->width*3 + dx;
302 s = src->data + sy*(int)src->width*3 + sx;
304 for (y=0; y < height; y++) {
305 memcpy(d, s, width*3);
306 d += dwi;
307 s += swi;
309 } else {
310 swi = (src->width - width) * 3;
311 dwi = (image->width - width) * 4;
313 d = image->data + dy*(int)image->width*4 + dx;
314 s = src->data + sy*(int)src->width*3 + sx;
316 for (y=0; y < height; y++) {
317 for (x=0; x < width; x++) {
318 *d++ = *s++;
319 *d++ = *s++;
320 *d++ = *s++;
321 d++;
323 d += dwi;
324 s += swi;
327 } else {
328 int dalpha = HAS_ALPHA(image);
330 swi = (src->width - width) * 4;
331 s = src->data + sy*(int)src->width*4 + sx;
332 if (!HAS_ALPHA(image)) {
333 dwi = (image->width - width) * 3;
334 d = image->data + (dy*(int)image->width+dx)*3;
335 } else {
336 dwi = (image->width - width) * 4;
337 d = image->data + (dy*(int)image->width+dx)*4;
340 for (y=0; y < height; y++) {
341 for (x=0; x < width; x++) {
342 alpha = *(s+3);
343 calpha = 255 - alpha;
344 *d = (((int)*d * calpha) + ((int)*s * alpha))/256;
345 s++; d++;
346 *d = (((int)*d * calpha) + ((int)*s * alpha))/256;
347 s++; d++;
348 *d = (((int)*d * calpha) + ((int)*s * alpha))/256;
349 s++; d++;
350 s++;
351 if (dalpha)
352 d++;
354 d += dwi;
355 s += swi;
361 void
362 RCombineAreaWithOpaqueness(RImage *image, RImage *src, int sx, int sy,
363 unsigned width, unsigned height, int dx, int dy,
364 int opaqueness)
366 int x, y, dwi, swi;
367 int c_opaqueness;
368 unsigned char *d;
369 unsigned char *s;
370 int dalpha = HAS_ALPHA(image);
371 int dch = (dalpha ? 4 : 3);
373 assert(dy <= image->height);
374 assert(dx <= image->width);
376 assert(sy <= height);
377 assert(sx <= width);
380 /* clip */
381 width -= sx;
382 height -= sy;
384 if (height > image->height - dy)
385 height = image->height - dy;
387 d = image->data + dy*image->width*dch + dx;
388 dwi = (image->width - width)*dch;
390 c_opaqueness = 255 - opaqueness;
391 #define OP opaqueness
392 if (!HAS_ALPHA(src)) {
393 #define COP c_opaqueness
395 s = src->data + sy*src->width*3;
396 swi = (src->width - width) * 3;
398 for (y=0; y < height; y++) {
399 for (x=0; x < width; x++) {
400 *d = (((int)*d *(int)COP) + ((int)*s *(int)OP))/256;
401 s++; d++;
402 *d = (((int)*d *(int)COP) + ((int)*s *(int)OP))/256;
403 s++; d++;
404 *d = (((int)*d *(int)COP) + ((int)*s *(int)OP))/256;
405 s++; d++;
406 if (dalpha)
407 d++;
409 d += dwi; s += swi;
411 #undef COP
412 } else {
413 int tmp;
415 s = src->data + sy*src->width*4;
416 swi = (src->width - width) * 4;
418 for (y=0; y < height; y++) {
419 for (x=0; x < width; x++) {
420 tmp= (*(s+3) * opaqueness)/256;
421 *d = (((int)*d *(int)(255-tmp)) + ((int)*s *(int)tmp))/256;
422 d++; s++;
423 *d = (((int)*d *(int)(255-tmp)) + ((int)*s *(int)tmp))/256;
424 d++; s++;
425 *d = (((int)*d *(int)(255-tmp)) + ((int)*s *(int)tmp))/256;
426 d++; s++;
427 s++;
428 if (dalpha)
429 d++;
431 d += dwi; s += swi;
434 #undef OP
440 void
441 RCombineImageWithColor(RImage *image, RColor *color)
443 register int i;
444 unsigned char *d;
445 int alpha, nalpha, r, g, b;
447 d = image->data;
449 if (!HAS_ALPHA(image)) {
450 /* Image has no alpha channel, so we consider it to be all 255.
451 * Thus there are no transparent parts to be filled. */
452 return;
454 r = color->red;
455 g = color->green;
456 b = color->blue;
458 for (i=0; i < image->width*image->height; i++) {
459 alpha = *(d+3);
460 nalpha = 255 - alpha;
462 *d = (((int)*d * alpha) + (r * nalpha))/256;
463 d++;
464 *d = (((int)*d * alpha) + (g * nalpha))/256;
465 d++;
466 *d = (((int)*d * alpha) + (b * nalpha))/256;
467 d++;
468 d++;
475 RImage*
476 RMakeTiledImage(RImage *tile, unsigned width, unsigned height)
478 int x, y;
479 unsigned w;
480 unsigned long tile_size = tile->width * tile->height;
481 unsigned long tx = 0;
482 RImage *image;
483 unsigned char *s, *d;
485 if (width == tile->width && height == tile->height)
486 image = RCloneImage(tile);
487 else if (width <= tile->width && height <= tile->height)
488 image = RGetSubImage(tile, 0, 0, width, height);
489 else {
490 int has_alpha = HAS_ALPHA(tile);
492 image = RCreateImage(width, height, has_alpha);
494 d = image->data;
495 s = tile->data;
497 for (y = 0; y < height; y++) {
498 for (x = 0; x < width; x += tile->width) {
500 w = (width - x < tile->width) ? width - x : tile->width;
502 if (has_alpha) {
503 w *= 4;
504 memcpy(d, s+tx*4, w);
505 } else {
506 w *= 3;
507 memcpy(d, s+tx*3, w);
509 d += w;
512 tx = (tx + tile->width) % tile_size;
515 return image;
519 RImage*
520 RMakeCenteredImage(RImage *image, unsigned width, unsigned height, RColor *color)
522 int x, y, w, h, sx, sy;
523 RImage *tmp;
525 tmp = RCreateImage(width, height, False);
526 if (!tmp) {
527 return NULL;
530 RClearImage(tmp, color);
532 if (image->height < height) {
533 h = image->height;
534 y = (height - h)/2;
535 sy = 0;
536 } else {
537 sy = (image->height - height)/2;
538 y = 0;
539 h = height;
541 if (image->width < width) {
542 w = image->width;
543 x = (width - w)/2;
544 sx = 0;
545 } else {
546 sx = (image->width - width)/2;
547 x = 0;
548 w = width;
550 RCombineArea(tmp, image, sx, sy, w, h, x, y);
552 return tmp;