wrlib/raster.c

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