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