obrender/image.c

   1 /* -*- indent-tabs-mode: nil; tab-width: 4; c-basic-offset: 4; -*-
   2
   3    image.c for the Openbox window manager
   4    Copyright (c) 2006        Mikael Magnusson
   5    Copyright (c) 2003-2007   Dana Jansens
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2 of the License, or
  10    (at your option) any later version.
  11
  12    This program 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
  15    GNU General Public License for more details.
  16
  17    See the COPYING file for a copy of the GNU General Public License.
  18 */
  19
  20 #include "geom.h"
  21 #include "image.h"
  22 #include "color.h"
  23 #include "imagecache.h"
  24
  25 #include <glib.h>
  26
  27 #define FRACTION        12
  28 #define FLOOR(i)        ((i) & (~0UL << FRACTION))
  29 #define AVERAGE(a, b)   (((((a) ^ (b)) & 0xfefefefeL) >> 1) + ((a) & (b)))
  30
  31 void RrImagePicInit(RrImagePic *pic, gint w, gint h, RrPixel32 *data)
  32 {
  33     gint i;
  34
  35     pic->width = w;
  36     pic->height = h;
  37     pic->data = data;
  38     pic->sum = 0;
  39     for (i = w*h; i > 0; --i)
  40         pic->sum += *(data++);
  41 }
  42
  43 static void RrImagePicFree(RrImagePic *pic)
  44 {
  45     if (pic) {
  46         g_free(pic->data);
  47         g_free(pic);
  48     }
  49 }
  50
  51 /*! Add a picture to an Image, that is, add another copy of the image at
  52   another size.  This may add it to the "originals" list or to the
  53   "resized" list. */
  54 static void AddPicture(RrImage *self, RrImagePic ***list, gint *len,
  55                        RrImagePic *pic)
  56 {
  57     gint i;
  58
  59     g_assert(pic->width > 0 && pic->height > 0);
  60
  61     g_assert(g_hash_table_lookup(self->cache->table, pic) == NULL);
  62
  63     /* grow the list */
  64     *list = g_renew(RrImagePic*, *list, ++*len);
  65
  66     /* move everything else down one */
  67     for (i = *len-1; i > 0; --i)
  68         (*list)[i] = (*list)[i-1];
  69
  70     /* set the new picture up at the front of the list */
  71     (*list)[0] = pic;
  72
  73     /* add the picture as a key to point to this image in the cache */
  74     g_hash_table_insert(self->cache->table, (*list)[0], self);
  75
  76 /*
  77 #ifdef DEBUG
  78     g_debug("Adding %s picture to the cache:\n    "
  79             "Image 0x%lx, w %d h %d Hash %u",
  80             (*list == self->original ? "ORIGINAL" : "RESIZED"),
  81             (gulong)self, pic->width, pic->height, RrImagePicHash(pic));
  82 #endif
  83 */
  84 }
  85
  86 /*! Remove a picture from an Image.  This may remove it from the "originals"
  87   list or the "resized" list. */
  88 static void RemovePicture(RrImage *self, RrImagePic ***list,
  89                           gint i, gint *len)
  90 {
  91     gint j;
  92
  93 /*
  94 #ifdef DEBUG
  95     g_debug("Removing %s picture from the cache:\n    "
  96             "Image 0x%lx, w %d h %d Hash %u",
  97             (*list == self->original ? "ORIGINAL" : "RESIZED"),
  98             (gulong)self, (*list)[i]->width, (*list)[i]->height,
  99             RrImagePicHash((*list)[i]));
 100 #endif
 101 */
 102
 103     /* remove the picture as a key in the cache */
 104     g_hash_table_remove(self->cache->table, (*list)[i]);
 105
 106     /* free the picture */
 107     RrImagePicFree((*list)[i]);
 108     /* shift everything down one */
 109     for (j = i; j < *len-1; ++j)
 110         (*list)[j] = (*list)[j+1];
 111     /* shrink the list */
 112     *list = g_renew(RrImagePic*, *list, --*len);
 113 }
 114
 115 /*! Given a picture in RGBA format, of a specified size, resize it to the new
 116   requested size (but keep its aspect ratio).  If the image does not need to
 117   be resized (it is already the right size) then this returns NULL.  Otherwise
 118   it returns a newly allocated RrImagePic with the resized picture inside it
 119 */
 120 static RrImagePic* ResizeImage(RrPixel32 *src,
 121                                gulong srcW, gulong srcH,
 122                                gulong dstW, gulong dstH)
 123 {
 124     RrPixel32 *dst, *dststart;
 125     RrImagePic *pic;
 126     gulong dstX, dstY, srcX, srcY;
 127     gulong srcX1, srcX2, srcY1, srcY2;
 128     gulong ratioX, ratioY;
 129     gulong aspectW, aspectH;
 130
 131     /* XXX should these variables be ensured to not be zero in the callers? */
 132     srcW = srcW ? srcW : 1;
 133     srcH = srcH ? srcH : 1;
 134     dstW = dstW ? dstW : 1;
 135     dstH = dstH ? dstH : 1;
 136
 137     /* keep the aspect ratio */
 138     aspectW = dstW;
 139     aspectH = (gint)(dstW * ((gdouble)srcH / srcW));
 140     if (aspectH > dstH) {
 141         aspectH = dstH;
 142         aspectW = (gint)(dstH * ((gdouble)srcW / srcH));
 143     }
 144     dstW = aspectW ? aspectW : 1;
 145     dstH = aspectH ? aspectH : 1;
 146
 147     if (srcW == dstW && srcH == dstH)
 148         return NULL; /* no scaling needed! */
 149
 150     dststart = dst = g_new(RrPixel32, dstW * dstH);
 151
 152     ratioX = (srcW << FRACTION) / dstW;
 153     ratioY = (srcH << FRACTION) / dstH;
 154
 155     srcY2 = 0;
 156     for (dstY = 0; dstY < dstH; dstY++) {
 157         srcY1 = srcY2;
 158         srcY2 += ratioY;
 159
 160         srcX2 = 0;
 161         for (dstX = 0; dstX < dstW; dstX++) {
 162             gulong red = 0, green = 0, blue = 0, alpha = 0;
 163             gulong portionX, portionY, portionXY, sumXY = 0;
 164             RrPixel32 pixel;
 165
 166             srcX1 = srcX2;
 167             srcX2 += ratioX;
 168
 169             for (srcY = srcY1; srcY < srcY2; srcY += (1UL << FRACTION)) {
 170                 if (srcY == srcY1) {
 171                     srcY = FLOOR(srcY);
 172                     portionY = (1UL << FRACTION) - (srcY1 - srcY);
 173                     if (portionY > srcY2 - srcY1)
 174                         portionY = srcY2 - srcY1;
 175                 }
 176                 else if (srcY == FLOOR(srcY2))
 177                     portionY = srcY2 - srcY;
 178                 else
 179                     portionY = (1UL << FRACTION);
 180
 181                 for (srcX = srcX1; srcX < srcX2; srcX += (1UL << FRACTION)) {
 182                     if (srcX == srcX1) {
 183                         srcX = FLOOR(srcX);
 184                         portionX = (1UL << FRACTION) - (srcX1 - srcX);
 185                         if (portionX > srcX2 - srcX1)
 186                             portionX = srcX2 - srcX1;
 187                     }
 188                     else if (srcX == FLOOR(srcX2))
 189                         portionX = srcX2 - srcX;
 190                     else
 191                         portionX = (1UL << FRACTION);
 192
 193                     portionXY = (portionX * portionY) >> FRACTION;
 194                     sumXY += portionXY;
 195
 196                     pixel = *(src + (srcY >> FRACTION) * srcW
 197                             + (srcX >> FRACTION));
 198                     red   += ((pixel >> RrDefaultRedOffset)   & 0xFF)
 199                              * portionXY;
 200                     green += ((pixel >> RrDefaultGreenOffset) & 0xFF)
 201                              * portionXY;
 202                     blue  += ((pixel >> RrDefaultBlueOffset)  & 0xFF)
 203                              * portionXY;
 204                     alpha += ((pixel >> RrDefaultAlphaOffset) & 0xFF)
 205                              * portionXY;
 206                 }
 207             }
 208
 209             g_assert(sumXY != 0);
 210             red   /= sumXY;
 211             green /= sumXY;
 212             blue  /= sumXY;
 213             alpha /= sumXY;
 214
 215             *dst++ = (red   << RrDefaultRedOffset)   |
 216                      (green << RrDefaultGreenOffset) |
 217                      (blue  << RrDefaultBlueOffset)  |
 218                      (alpha << RrDefaultAlphaOffset);
 219         }
 220     }
 221
 222     pic = g_new(RrImagePic, 1);
 223     RrImagePicInit(pic, dstW, dstH, dststart);
 224
 225     return pic;
 226 }
 227
 228 /*! This draws an RGBA picture into the target, within the rectangle specified
 229   by the area parameter.  If the area's size differs from the source's then it
 230   will be centered within the rectangle */
 231 void DrawRGBA(RrPixel32 *target, gint target_w, gint target_h,
 232               RrPixel32 *source, gint source_w, gint source_h,
 233               gint alpha, RrRect *area)
 234 {
 235     RrPixel32 *dest;
 236     gint col, num_pixels;
 237     gint dw, dh;
 238
 239     g_assert(source_w <= area->width && source_h <= area->height);
 240     g_assert(area->x + area->width <= target_w);
 241     g_assert(area->y + area->height <= target_h);
 242
 243     /* keep the aspect ratio */
 244     dw = area->width;
 245     dh = (gint)(dw * ((gdouble)source_h / source_w));
 246     if (dh > area->height) {
 247         dh = area->height;
 248         dw = (gint)(dh * ((gdouble)source_w / source_h));
 249     }
 250
 251     /* copy source -> dest, and apply the alpha channel.
 252        center the image if it is smaller than the area */
 253     col = 0;
 254     num_pixels = dw * dh;
 255     dest = target + area->x + (area->width - dw) / 2 +
 256         (target_w * (area->y + (area->height - dh) / 2));
 257     while (num_pixels-- > 0) {
 258         guchar a, r, g, b, bgr, bgg, bgb;
 259
 260         /* apply the rgba's opacity as well */
 261         a = ((*source >> RrDefaultAlphaOffset) * alpha) >> 8;
 262         r = *source >> RrDefaultRedOffset;
 263         g = *source >> RrDefaultGreenOffset;
 264         b = *source >> RrDefaultBlueOffset;
 265
 266         /* background color */
 267         bgr = *dest >> RrDefaultRedOffset;
 268         bgg = *dest >> RrDefaultGreenOffset;
 269         bgb = *dest >> RrDefaultBlueOffset;
 270
 271         r = bgr + (((r - bgr) * a) >> 8);
 272         g = bgg + (((g - bgg) * a) >> 8);
 273         b = bgb + (((b - bgb) * a) >> 8);
 274
 275         *dest = ((r << RrDefaultRedOffset) |
 276                  (g << RrDefaultGreenOffset) |
 277                  (b << RrDefaultBlueOffset));
 278
 279         dest++;
 280         source++;
 281
 282         if (++col >= dw) {
 283             col = 0;
 284             dest += target_w - dw;
 285         }
 286     }
 287 }
 288
 289 /*! Draw an RGBA texture into a target pixel buffer. */
 290 void RrImageDrawRGBA(RrPixel32 *target, RrTextureRGBA *rgba,
 291                      gint target_w, gint target_h,
 292                      RrRect *area)
 293 {
 294     RrImagePic *scaled;
 295
 296     scaled = ResizeImage(rgba->data, rgba->width, rgba->height,
 297                          area->width, area->height);
 298
 299     if (scaled) {
 300 #ifdef DEBUG
 301             g_warning("Scaling an RGBA! You should avoid this and just make "
 302                       "it the right size yourself!");
 303 #endif
 304             DrawRGBA(target, target_w, target_h,
 305                      scaled->data, scaled->width, scaled->height,
 306                      rgba->alpha, area);
 307             RrImagePicFree(scaled);
 308     }
 309     else
 310         DrawRGBA(target, target_w, target_h,
 311                  rgba->data, rgba->width, rgba->height,
 312                  rgba->alpha, area);
 313 }
 314
 315 /*! Create a new RrImage, which is linked to an image cache */
 316 RrImage* RrImageNew(RrImageCache *cache)
 317 {
 318     RrImage *self;
 319
 320     g_assert(cache != NULL);
 321
 322     self = g_new0(RrImage, 1);
 323     self->ref = 1;
 324     self->cache = cache;
 325     return self;
 326 }
 327
 328 void RrImageRef(RrImage *self)
 329 {
 330     ++self->ref;
 331 }
 332
 333 void RrImageUnref(RrImage *self)
 334 {
 335     if (self && --self->ref == 0) {
 336 /*
 337 #ifdef DEBUG
 338         g_debug("Refcount to 0, removing ALL pictures from the cache:\n    "
 339                 "Image 0x%lx", (gulong)self);
 340 #endif
 341 */
 342         while (self->n_original > 0)
 343             RemovePicture(self, &self->original, 0, &self->n_original);
 344         while (self->n_resized > 0)
 345             RemovePicture(self, &self->resized, 0, &self->n_resized);
 346         g_free(self);
 347     }
 348 }
 349
 350 /*! Add a new picture with the given RGBA pixel data and dimensions into the
 351   RrImage.  This adds an "original" picture to the image.
 352 */
 353 void RrImageAddPicture(RrImage *self, RrPixel32 *data, gint w, gint h)
 354 {
 355     gint i;
 356     RrImagePic *pic;
 357
 358     /* make sure we don't already have this size.. */
 359     for (i = 0; i < self->n_original; ++i)
 360         if (self->original[i]->width == w && self->original[i]->height == h) {
 361 /*
 362 #ifdef DEBUG
 363             g_debug("Found duplicate ORIGINAL image:\n    "
 364                     "Image 0x%lx, w %d h %d", (gulong)self, w, h);
 365 #endif
 366 */
 367             return;
 368         }
 369
 370     /* remove any resized pictures of this same size */
 371     for (i = 0; i < self->n_resized; ++i)
 372         if (self->resized[i]->width == w || self->resized[i]->height == h) {
 373             RemovePicture(self, &self->resized, i, &self->n_resized);
 374             break;
 375         }
 376
 377     /* add the new picture */
 378     pic = g_new(RrImagePic, 1);
 379     RrImagePicInit(pic, w, h, g_memdup(data, w*h*sizeof(RrPixel32)));
 380     AddPicture(self, &self->original, &self->n_original, pic);
 381 }
 382
 383 /*! Remove the picture from the RrImage which has the given dimensions. This
 384  removes an "original" picture from the image.
 385 */
 386 void RrImageRemovePicture(RrImage *self, gint w, gint h)
 387 {
 388     gint i;
 389
 390     /* remove any resized pictures of this same size */
 391     for (i = 0; i < self->n_original; ++i)
 392         if (self->original[i]->width == w && self->original[i]->height == h) {
 393             RemovePicture(self, &self->original, i, &self->n_original);
 394             break;
 395         }
 396 }
 397
 398 /*! Draw an RrImage texture into a target pixel buffer.  If the RrImage does
 399   not contain a picture of the appropriate size, then one of its "original"
 400   pictures will be resized and used (and stored in the RrImage as a "resized"
 401   picture).
 402  */
 403 void RrImageDrawImage(RrPixel32 *target, RrTextureImage *img,
 404                       gint target_w, gint target_h,
 405                       RrRect *area)
 406 {
 407     gint i, min_diff, min_i, min_aspect_diff, min_aspect_i;
 408     RrImage *self;
 409     RrImagePic *pic;
 410     gboolean free_pic;
 411
 412     self = img->image;
 413     pic = NULL;
 414     free_pic = FALSE;
 415
 416     /* is there an original of this size? (only the larger of
 417        w or h has to be right cuz we maintain aspect ratios) */
 418     for (i = 0; i < self->n_original; ++i)
 419         if ((self->original[i]->width >= self->original[i]->height &&
 420              self->original[i]->width == area->width) ||
 421             (self->original[i]->width <= self->original[i]->height &&
 422              self->original[i]->height == area->height))
 423         {
 424             pic = self->original[i];
 425             break;
 426         }
 427
 428     /* is there a resize of this size? */
 429     for (i = 0; i < self->n_resized; ++i)
 430         if ((self->resized[i]->width >= self->resized[i]->height &&
 431              self->resized[i]->width == area->width) ||
 432             (self->resized[i]->width <= self->resized[i]->height &&
 433              self->resized[i]->height == area->height))
 434         {
 435             gint j;
 436             RrImagePic *saved;
 437
 438             /* save the selected one */
 439             saved = self->resized[i];
 440
 441             /* shift all the others down */
 442             for (j = i; j > 0; --j)
 443                 self->resized[j] = self->resized[j-1];
 444
 445             /* and move the selected one to the top of the list */
 446             self->resized[0] = saved;
 447
 448             pic = self->resized[0];
 449             break;
 450         }
 451
 452     if (!pic) {
 453         gdouble aspect;
 454
 455         /* find an original with a close size */
 456         min_diff = min_aspect_diff = -1;
 457         min_i = min_aspect_i = 0;
 458         aspect = ((gdouble)area->width) / area->height;
 459         for (i = 0; i < self->n_original; ++i) {
 460             gint diff;
 461             gint wdiff, hdiff;
 462             gdouble myasp;
 463
 464             /* our size difference metric.. */
 465             wdiff = self->original[i]->width - area->width;
 466             hdiff = self->original[i]->height - area->height;
 467             diff = (wdiff * wdiff) + (hdiff * hdiff);
 468
 469             /* find the smallest difference */
 470             if (min_diff < 0 || diff < min_diff) {
 471                 min_diff = diff;
 472                 min_i = i;
 473             }
 474             /* and also find the smallest difference with the same aspect
 475                ratio (and prefer this one) */
 476             myasp = ((gdouble)self->original[i]->width) /
 477                 self->original[i]->height;
 478             if (ABS(aspect - myasp) < 0.0000001 &&
 479                 (min_aspect_diff < 0 || diff < min_aspect_diff))
 480             {
 481                 min_aspect_diff = diff;
 482                 min_aspect_i = i;
 483             }
 484         }
 485
 486         /* use the aspect ratio correct source if there is one */
 487         if (min_aspect_i >= 0)
 488             min_i = min_aspect_i;
 489
 490         /* resize the original to the given area */
 491         pic = ResizeImage(self->original[min_i]->data,
 492                           self->original[min_i]->width,
 493                           self->original[min_i]->height,
 494                           area->width, area->height);
 495
 496         /* add the resized image to the image, as the first in the resized
 497            list */
 498         if (self->n_resized >= self->cache->max_resized_saved)
 499             /* remove the last one (last used one) */
 500             RemovePicture(self, &self->resized, self->n_resized - 1,
 501                           &self->n_resized);
 502         if (self->cache->max_resized_saved)
 503             /* add it to the top of the resized list */
 504             AddPicture(self, &self->resized, &self->n_resized, pic);
 505         else
 506             free_pic = TRUE; /* don't leak mem! */
 507     }
 508
 509     g_assert(pic != NULL);
 510
 511     DrawRGBA(target, target_w, target_h,
 512              pic->data, pic->width, pic->height,
 513              img->alpha, area);
 514     if (free_pic)
 515         RrImagePicFree(pic);
 516 }