wrlib/raster.c

   1 /* raster.c - main and other misc stuff
   2  *
   3  *  Raster graphics library
   4  *
   5  *  Copyright (c) 1997-2002 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 #include <config.h>
  23
  24 #include <stdlib.h>
  25 #include <stdio.h>
  26 #include <string.h>
  27 #include <limits.h>
  28 #include <X11/Xlib.h>
  29 #include "wraster.h"
  30
  31 #include <assert.h>
  32
  33
  34 char *WRasterLibVersion="0.9";
  35
  36 int RErrorCode=RERR_NONE;
  37
  38
  39 #define HAS_ALPHA(I)    ((I)->format == RRGBAFormat)
  40
  41
  42 RImage*
  43 RCreateImage(unsigned width, unsigned height, int alpha)
  44 {
  45     RImage *image=NULL;
  46     unsigned bla1, bla2;
  47
  48     assert(width>0 && height>0);
  49
  50     /* detect overflow (gr33tz to ruda :D) */
  51     bla1 = width*height;
  52     bla2 = bla1*4;
  53     if (bla1/height != width || bla2/4 != bla1 || bla2 > INT_MAX-32) {
  54         RErrorCode = RERR_NOMEMORY;
  55         return NULL;
  56     }
  57
  58     image = malloc(sizeof(RImage));
  59     if (!image) {
  60         RErrorCode = RERR_NOMEMORY;
  61         return NULL;
  62     }
  63
  64     memset(image, 0, sizeof(RImage));
  65     image->width = width;
  66     image->height = height;
  67     image->format = alpha ? RRGBAFormat : RRGBFormat;
  68     image->refCount = 1;
  69
  70     /* the +4 is to give extra bytes at the end of the buffer,
  71      * so that we can optimize image conversion for MMX(tm).. see convert.c
  72      */
  73     image->data = malloc(width * height * (alpha ? 4 : 3) + 4);
  74     if (!image->data) {
  75         RErrorCode = RERR_NOMEMORY;
  76         free(image);
  77         image = NULL;
  78     }
  79
  80     return image;
  81 }
  82
  83
  84 RImage*
  85 RRetainImage(RImage *image)
  86 {
  87     if (image)
  88         image->refCount++;
  89
  90     return image;
  91 }
  92
  93
  94 void
  95 RReleaseImage(RImage *image)
  96 {
  97     assert(image!=NULL);
  98
  99     image->refCount--;
 100
 101     if (image->refCount < 1) {
 102         free(image->data);
 103         free(image);
 104     }
 105 }
 106
 107
 108 RImage*
 109 RCloneImage(RImage *image)
 110 {
 111     RImage *new_image;
 112
 113     assert(image!=NULL);
 114
 115     new_image = RCreateImage(image->width, image->height, HAS_ALPHA(image));
 116     if (!new_image)
 117       return NULL;
 118
 119     new_image->background = image->background;
 120     memcpy(new_image->data, image->data,
 121            image->width*image->height*(HAS_ALPHA(image) ? 4 : 3));
 122
 123     return new_image;
 124 }
 125
 126
 127 RImage*
 128 RGetSubImage(RImage *image, int x, int y, unsigned width, unsigned height)
 129 {
 130     int i, ofs;
 131     RImage *new_image;
 132     unsigned total_line_size, line_size;
 133
 134     assert(image!=NULL);
 135     assert(x>=0 && y>=0);
 136     assert(x<image->width && y<image->height);
 137     assert(width>0 && height>0);
 138
 139     if (x+width > image->width)
 140         width = image->width-x;
 141     if (y+height > image->height)
 142         height = image->height-y;
 143
 144     new_image = RCreateImage(width, height, HAS_ALPHA(image));
 145
 146     if (!new_image)
 147         return NULL;
 148     new_image->background = image->background;
 149
 150     total_line_size = image->width * (HAS_ALPHA(image) ? 4 : 3);
 151     line_size = width * (HAS_ALPHA(image) ? 4 : 3);
 152
 153     ofs = x*(HAS_ALPHA(image) ? 4 : 3) + y*total_line_size;;
 154
 155     for (i=0; i<height; i++) {
 156         memcpy(&new_image->data[i*line_size],
 157                &image->data[i*total_line_size+ofs], line_size);
 158     }
 159     return new_image;
 160 }
 161
 162
 163 /*
 164  *----------------------------------------------------------------------
 165  * RCombineImages-
 166  *      Combines two equal sized images with alpha image. The second
 167  * image will be placed on top of the first one.
 168  *----------------------------------------------------------------------
 169  */
 170 void
 171 RCombineImages(RImage *image, RImage *src)
 172 {
 173     assert(image->width == src->width);
 174     assert(image->height == src->height);
 175
 176     if (!HAS_ALPHA(src)) {
 177         if (!HAS_ALPHA(image)) {
 178             memcpy(image->data, src->data, image->height*image->width*3);
 179         } else {
 180             int x, y;
 181             unsigned char *d, *s;
 182
 183             d = image->data;
 184             s = src->data;
 185             for (y = 0; y < image->height; y++) {
 186                 for (x = 0; x < image->width; x++) {
 187                     *d++ = *s++;
 188                     *d++ = *s++;
 189                     *d++ = *s++;
 190                     d++;
 191                 }
 192             }
 193         }
 194     } else {
 195         register int i;
 196         unsigned char *d;
 197         unsigned char *s;
 198         int alpha, calpha;
 199
 200         d = image->data;
 201         s = src->data;
 202
 203         if (!HAS_ALPHA(image)) {
 204             for (i=0; i<image->height*image->width; i++) {
 205                 alpha = *(s+3);
 206                 calpha = 255 - alpha;
 207                 *d = (((int)*d * calpha) + ((int)*s * alpha))/256; d++; s++;
 208                 *d = (((int)*d * calpha) + ((int)*s * alpha))/256; d++; s++;
 209                 *d = (((int)*d * calpha) + ((int)*s * alpha))/256; d++; s++;
 210                 s++;
 211             }
 212         } else {
 213             for (i=0; i<image->height*image->width; i++) {
 214                 alpha = *(s+3);
 215                 calpha = 255 - alpha;
 216                 *d = (((int)*d * calpha) + ((int)*s * alpha))/256; d++; s++;
 217                 *d = (((int)*d * calpha) + ((int)*s * alpha))/256; d++; s++;
 218                 *d = (((int)*d * calpha) + ((int)*s * alpha))/256; d++; s++;
 219                 *d++ |= *s++;
 220             }
 221         }
 222     }
 223 }
 224
 225
 226
 227
 228 void
 229 RCombineImagesWithOpaqueness(RImage *image, RImage *src, int opaqueness)
 230 {
 231     register int i;
 232     unsigned char *d;
 233     unsigned char *s;
 234     int c_opaqueness;
 235
 236     assert(image->width == src->width);
 237     assert(image->height == src->height);
 238
 239     d = image->data;
 240     s = src->data;
 241
 242     c_opaqueness = 255 - opaqueness;
 243
 244 #define OP opaqueness
 245 #define COP c_opaqueness
 246
 247     if (!HAS_ALPHA(src)) {
 248         int dalpha = HAS_ALPHA(image);
 249         for (i=0; i < image->width*image->height; i++) {
 250             *d = (((int)*d *(int)COP) + ((int)*s *(int)OP))/256; d++; s++;
 251             *d = (((int)*d *(int)COP) + ((int)*s *(int)OP))/256; d++; s++;
 252             *d = (((int)*d *(int)COP) + ((int)*s *(int)OP))/256; d++; s++;
 253             if (dalpha) {
 254                 d++;
 255             }
 256         }
 257     } else {
 258         int tmp;
 259
 260         if (!HAS_ALPHA(image)) {
 261             for (i=0; i<image->width*image->height; i++) {
 262                 tmp = (*(s+3) * opaqueness)/256;
 263                 *d = (((int)*d * (255-tmp)) + ((int)*s * tmp))/256; d++; s++;
 264                 *d = (((int)*d * (255-tmp)) + ((int)*s * tmp))/256; d++; s++;
 265                 *d = (((int)*d * (255-tmp)) + ((int)*s * tmp))/256; d++; s++;
 266                 s++;
 267             }
 268         } else {
 269             for (i=0; i<image->width*image->height; i++) {
 270                 tmp = (*(s+3) * opaqueness)/256;
 271                 *d = (((int)*d * (255-tmp)) + ((int)*s * tmp))/256; d++; s++;
 272                 *d = (((int)*d * (255-tmp)) + ((int)*s * tmp))/256; d++; s++;
 273                 *d = (((int)*d * (255-tmp)) + ((int)*s * tmp))/256; d++; s++;
 274                 *d |= tmp;
 275                 d++; s++;
 276             }
 277         }
 278     }
 279 #undef OP
 280 #undef COP
 281 }
 282
 283 int
 284 calculateCombineArea(RImage *des, RImage *src, int *sx, int *sy,
 285                      int *swidth, int *sheight, int *dx, int *dy)
 286 {
 287     if (*dx < 0) {
 288         *sx = -*dx;
 289         *swidth = *swidth + *dx;
 290         *dx = 0;
 291     }
 292
 293     if (*dx + *swidth > des->width) {
 294         *swidth = des->width - *dx;
 295     }
 296
 297     if (*dy < 0) {
 298         *sy = -*dy;
 299         *sheight = *sheight + *dy;
 300         *dy = 0;
 301     }
 302
 303     if (*dy + *sheight > des->height) {
 304         *sheight = des->height - *dy;
 305     }
 306
 307     if (*sheight > 0 && *swidth > 0) {
 308         return True;
 309     } else return False;
 310 }
 311
 312 void
 313 RCombineArea(RImage *image, RImage *src, int sx, int sy, unsigned width,
 314              unsigned height, int dx, int dy)
 315 {
 316     int x, y, dwi, swi;
 317     unsigned char *d;
 318     unsigned char *s;
 319     int alpha, calpha;
 320
 321     if(!calculateCombineArea(image, src, &sx, &sy, &width, &height, &dx, &dy))
 322         return;
 323
 324     if (!HAS_ALPHA(src)) {
 325         if (!HAS_ALPHA(image)) {
 326             swi = src->width * 3;
 327             dwi = image->width * 3;
 328
 329             s = src->data + (sy*(int)src->width + sx) * 3;
 330             d = image->data + (dy*(int)image->width + dx) * 3;
 331
 332             for (y=0; y < height; y++) {
 333                 memcpy(d, s, width*3);
 334                 d += dwi;
 335                 s += swi;
 336             }
 337         } else {
 338             swi = (src->width - width) * 3;
 339             dwi = (image->width - width) * 4;
 340
 341             s = src->data + (sy*(int)src->width + sx) * 3;
 342             d = image->data + (dy*(int)image->width + dx) * 4;
 343
 344             for (y=0; y < height; y++) {
 345                 for (x=0; x < width; x++) {
 346                     *d++ = *s++;
 347                     *d++ = *s++;
 348                     *d++ = *s++;
 349                     d++;
 350                 }
 351                 d += dwi;
 352                 s += swi;
 353             }
 354         }
 355     } else {
 356         int dalpha = HAS_ALPHA(image);
 357
 358         swi = (src->width - width) * 4;
 359         s = src->data + (sy*(int)src->width + sx) * 4;
 360         if (dalpha) {
 361             dwi = (image->width - width) * 4;
 362             d = image->data + (dy*(int)image->width + dx) * 4;
 363         } else {
 364             dwi = (image->width - width) * 3;
 365             d = image->data + (dy*(int)image->width + dx) * 3;
 366         }
 367
 368         for (y=0; y < height; y++) {
 369             for (x=0; x < width; x++) {
 370                 alpha = *(s+3);
 371                 calpha = 255 - alpha;
 372                 *d = (((int)*d * calpha) + ((int)*s * alpha))/256; s++; d++;
 373                 *d = (((int)*d * calpha) + ((int)*s * alpha))/256; s++; d++;
 374                 *d = (((int)*d * calpha) + ((int)*s * alpha))/256; s++; d++;
 375                 s++;
 376                 if (dalpha)
 377                     d++;
 378             }
 379             d += dwi;
 380             s += swi;
 381         }
 382     }
 383 }
 384
 385
 386 void
 387 RCombineAreaWithOpaqueness(RImage *image, RImage *src, int sx, int sy,
 388                            unsigned width, unsigned height, int dx, int dy,
 389                            int opaqueness)
 390 {
 391     int x, y, dwi, swi;
 392     int c_opaqueness;
 393     unsigned char *s, *d;
 394     int dalpha = HAS_ALPHA(image);
 395     int dch = (dalpha ? 4 : 3);
 396
 397     if(!calculateCombineArea(image, src, &sx, &sy, &width, &height, &dx, &dy))
 398         return;
 399
 400     d = image->data + (dy*image->width + dx) * dch;
 401     dwi = (image->width - width)*dch;
 402
 403     c_opaqueness = 255 - opaqueness;
 404
 405 #define OP opaqueness
 406 #define COP c_opaqueness
 407
 408     if (!HAS_ALPHA(src)) {
 409
 410         s = src->data + (sy*src->width + sx)*3;
 411         swi = (src->width - width) * 3;
 412
 413         for (y=0; y < height; y++) {
 414             for (x=0; x < width; x++) {
 415                 *d = (((int)*d *(int)COP) + ((int)*s *(int)OP))/256; s++; d++;
 416                 *d = (((int)*d *(int)COP) + ((int)*s *(int)OP))/256; s++; d++;
 417                 *d = (((int)*d *(int)COP) + ((int)*s *(int)OP))/256; s++; d++;
 418                 if (dalpha)
 419                     d++;
 420             }
 421             d += dwi; s += swi;
 422         }
 423     } else {
 424         int tmp;
 425
 426         s = src->data + (sy*src->width + sx)*4;
 427         swi = (src->width - width) * 4;
 428
 429         for (y=0; y < height; y++) {
 430             for (x=0; x < width; x++) {
 431                 tmp = (*(s+3) * opaqueness)/256;
 432                 *d = (((int)*d * (255-tmp)) + ((int)*s * tmp))/256; d++; s++;
 433                 *d = (((int)*d * (255-tmp)) + ((int)*s * tmp))/256; d++; s++;
 434                 *d = (((int)*d * (255-tmp)) + ((int)*s * tmp))/256; d++; s++;
 435                 s++;
 436                 if (dalpha)
 437                     d++;
 438             }
 439             d += dwi; s += swi;
 440         }
 441     }
 442 #undef OP
 443 #undef COP
 444 }
 445
 446
 447
 448 void
 449 RCombineImageWithColor(RImage *image, RColor *color)
 450 {
 451     register int i;
 452     unsigned char *d;
 453     int alpha, nalpha, r, g, b;
 454
 455     d = image->data;
 456
 457     if (!HAS_ALPHA(image)) {
 458         /* Image has no alpha channel, so we consider it to be all 255.
 459          * Thus there are no transparent parts to be filled. */
 460         return;
 461     }
 462     r = color->red;
 463     g = color->green;
 464     b = color->blue;
 465
 466     for (i=0; i < image->width*image->height; i++) {
 467         alpha = *(d+3);
 468         nalpha = 255 - alpha;
 469
 470         *d = (((int)*d * alpha) + (r * nalpha))/256; d++;
 471         *d = (((int)*d * alpha) + (g * nalpha))/256; d++;
 472         *d = (((int)*d * alpha) + (b * nalpha))/256; d++;
 473         d++;
 474     }
 475 }
 476
 477
 478
 479
 480 RImage*
 481 RMakeTiledImage(RImage *tile, unsigned width, unsigned height)
 482 {
 483     int x, y;
 484     unsigned w;
 485     unsigned long tile_size = tile->width * tile->height;
 486     unsigned long tx = 0;
 487     RImage *image;
 488     unsigned char *s, *d;
 489
 490     if (width == tile->width && height == tile->height)
 491         image = RCloneImage(tile);
 492     else if (width <= tile->width && height <= tile->height)
 493         image = RGetSubImage(tile, 0, 0, width, height);
 494     else {
 495         int has_alpha = HAS_ALPHA(tile);
 496
 497         image = RCreateImage(width, height, has_alpha);
 498
 499         d = image->data;
 500         s = tile->data;
 501
 502         for (y = 0; y < height; y++) {
 503             for (x = 0; x < width; x += tile->width) {
 504
 505                 w = (width - x < tile->width) ? width - x : tile->width;
 506
 507                 if (has_alpha) {
 508                     w *= 4;
 509                     memcpy(d, s+tx*4, w);
 510                 } else {
 511                     w *= 3;
 512                     memcpy(d, s+tx*3, w);
 513                 }
 514                 d += w;
 515             }
 516
 517             tx = (tx + tile->width) % tile_size;
 518         }
 519     }
 520     return image;
 521 }
 522
 523
 524 RImage*
 525 RMakeCenteredImage(RImage *image, unsigned width, unsigned height, RColor *color)
 526 {
 527     int x, y, w, h, sx, sy;
 528     RImage *tmp;
 529
 530     tmp = RCreateImage(width, height, False);
 531     if (!tmp) {
 532         return NULL;
 533     }
 534
 535     RClearImage(tmp, color);
 536
 537     if (image->height < height) {
 538         h = image->height;
 539         y = (height - h)/2;
 540         sy = 0;
 541     } else {
 542         sy = (image->height - height)/2;
 543         y = 0;
 544         h = height;
 545     }
 546     if (image->width < width) {
 547         w = image->width;
 548         x = (width - w)/2;
 549         sx = 0;
 550     } else {
 551         sx = (image->width - width)/2;
 552         x = 0;
 553         w = width;
 554     }
 555     RCombineArea(tmp, image, sx, sy, w, h, x, y);
 556
 557     return tmp;
 558 }