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 #ifdef USE_IMLIB2
  25 #include <Imlib2.h>
  26 #endif
  27 #ifdef USE_LIBRSVG
  28 #include <librsvg/rsvg.h>
  29 #endif
  30
  31 #include <glib.h>
  32
  33 #define FRACTION        12
  34 #define FLOOR(i)        ((i) & (~0UL << FRACTION))
  35 #define AVERAGE(a, b)   (((((a) ^ (b)) & 0xfefefefeL) >> 1) + ((a) & (b)))
  36
  37 /************************************************************************
  38  RrImagePic functions.
  39
  40  RrImagePics are pictures that are grouped together into RrImageSets.  Each
  41  RrImagePic in the set has the same logical image inside it, but they are
  42  of different sizes.  An RrImagePic can be an original (which comes from some
  43  outside source, such as an image file), or resized from some other RrImagePic
  44  to meet the needs of the user.
  45 **************************************************************************/
  46
  47
  48 /*! Set up an RrImagePic.
  49   This does _not_ make a copy of the data. So the value of data must be
  50   owned by the caller of this function, and not freed afterward.
  51   This function does not allocate an RrImagePic, and can be used for setting
  52   up a temporary RrImagePic on the stack.  Such an object would then also
  53   not be freed with RrImagePicFree.
  54 */
  55 static void RrImagePicInit(RrImagePic *pic, gint w, gint h, RrPixel32 *data)
  56 {
  57     gint i;
  58
  59     pic->width = w;
  60     pic->height = h;
  61     pic->data = data;
  62     pic->sum = 0;
  63     for (i = w*h; i > 0; --i)
  64         pic->sum += *(data++);
  65 }
  66
  67 /*! Create a new RrImagePic from some picture data.
  68   This makes a duplicate of the data.
  69 */
  70 static RrImagePic* RrImagePicNew(gint w, gint h, RrPixel32 *data)
  71 {
  72     RrImagePic *pic;
  73
  74     pic = g_slice_new(RrImagePic);
  75     RrImagePicInit(pic, w, h, g_memdup(data, w*h*sizeof(RrPixel32)));
  76     return pic;
  77 }
  78
  79
  80 /*! Destroy an RrImagePic.
  81   This frees the RrImagePic object and everything inside it.
  82 */
  83 static void RrImagePicFree(RrImagePic *pic)
  84 {
  85     if (pic) {
  86         g_free(pic->data);
  87         g_slice_free(RrImagePic, pic);
  88     }
  89 }
  90
  91 /************************************************************************
  92  RrImageSet functions.
  93
  94  RrImageSets hold a group of pictures, each of which represent the same logical
  95  image, but are physically different sizes.
  96  At any time, it may be discovered that two different RrImageSets are actually
  97  holding the same logical image.  At that time, they would be merged.
  98  An RrImageSet holds both original images which come from an outside source,
  99  and resized images, which are generated when requests for a specific size are
 100  made, and kept around in case they are request again.  There is a maximum
 101  number of resized images that an RrImageSet will keep around, however.
 102
 103  Each RrImage points to a single RrImageSet, which keeps track of which
 104  RrImages point to it.  If two RrImageSets are merged, then the RrImages which
 105  pointed to the two RrImageSets will all point at the resulting merged set.
 106 **************************************************************************/
 107
 108
 109 /*! Free an RrImageSet and the stuff inside it.
 110   This should only occur when there are no more RrImages pointing to the set.
 111 */
 112 static void RrImageSetFree(RrImageSet *self)
 113 {
 114     GSList *it;
 115     gint i;
 116
 117     if (self) {
 118         g_assert(self->images == NULL);
 119
 120         /* remove all names associated with this RrImageSet */
 121         for (it = self->names; it; it = g_slist_next(it)) {
 122             g_hash_table_remove(self->cache->name_table, it->data);
 123             g_free(it->data);
 124         }
 125         g_slist_free(self->names);
 126
 127         /* destroy the RrImagePic objects stored in the RrImageSet.  they will
 128            be keys in the cache to RrImageSet objects, so remove them from
 129            the cache's pic_table as well. */
 130         for (i = 0; i < self->n_original; ++i) {
 131             g_hash_table_remove(self->cache->pic_table, self->original[i]);
 132             RrImagePicFree(self->original[i]);
 133         }
 134         g_free(self->original);
 135         for (i = 0; i < self->n_resized; ++i) {
 136             g_hash_table_remove(self->cache->pic_table, self->resized[i]);
 137             RrImagePicFree(self->resized[i]);
 138         }
 139         g_free(self->resized);
 140
 141         g_slice_free(RrImageSet, self);
 142     }
 143 }
 144
 145 /*! Remove a picture from an RrImageSet as a given position.
 146    @param set The RrImageSet to remove the picture from.
 147    @param i The index of the picture in the RrImageSet in the list of
 148      originals (if @original is TRUE), or in the list of resized pictures (if
 149      @original is FALSE).
 150    @param original TRUE if the picture is an original, FALSE if it is a resized
 151      version of another picture in the RrImageSet.
 152  */
 153 static void RrImageSetRemovePictureAt(RrImageSet *self, gint i,
 154                                       gboolean original)
 155 {
 156     RrImagePic ***list;
 157     gint *len;
 158
 159     if (original) {
 160         list = &self->original;
 161         len = &self->n_original;
 162     }
 163     else {
 164         list = &self->resized;
 165         len = &self->n_resized;
 166     }
 167
 168     g_assert(i >= 0 && i < *len);
 169
 170     /* remove the picture data as a key in the cache */
 171     g_hash_table_remove(self->cache->pic_table, (*list)[i]);
 172
 173     /* free the picture being removed */
 174     RrImagePicFree((*list)[i]);
 175
 176     /* copy the elements after the removed one in the array forward one space
 177        and shrink the array down one size */
 178     for (i = i+1; i < *len; ++i)
 179         (*list)[i-1] = (*list)[i];
 180     --(*len);
 181     *list = g_renew(RrImagePic*, *list, *len);
 182 }
 183
 184 /*! Add an RrImagePic to an RrImageSet.
 185   The RrImagePic should _not_ exist in the image cache already.
 186   Pictures are added to the front of the list, to maintain the ordering of
 187   newest to oldest.
 188 */
 189 static void RrImageSetAddPicture(RrImageSet *self, RrImagePic *pic,
 190                                  gboolean original)
 191 {
 192     gint i;
 193     RrImagePic ***list;
 194     gint *len;
 195
 196     g_assert(pic->width > 0 && pic->height > 0);
 197     g_assert(g_hash_table_lookup(self->cache->pic_table, pic) == NULL);
 198
 199     /* choose which list in the RrImageSet to add the new picture to. */
 200     if (original) {
 201         /* remove the resized picture of the same size if one exists */
 202         for (i = 0; i < self->n_resized; ++i)
 203             if (self->resized[i]->width == pic->width ||
 204                 self->resized[i]->height == pic->height)
 205             {
 206                 RrImageSetRemovePictureAt(self, i, FALSE);
 207                 break;
 208             }
 209
 210         list = &self->original;
 211         len = &self->n_original;
 212     }
 213     else {
 214         list = &self->resized;
 215         len = &self->n_resized;
 216     }
 217
 218     /* grow the list by one spot, shift everything down one, and insert the new
 219        picture at the front of the list */
 220     *list = g_renew(RrImagePic*, *list, ++*len);
 221     for (i = *len-1; i > 0; --i)
 222         (*list)[i] = (*list)[i-1];
 223     (*list)[0] = pic;
 224
 225     /* add the picture as a key to point to this image in the cache */
 226     g_hash_table_insert(self->cache->pic_table, (*list)[0], self);
 227
 228 /*
 229 #ifdef DEBUG
 230     g_debug("Adding %s picture to the cache:\n    "
 231             "Image 0x%lx, w %d h %d Hash %u",
 232             (*list == self->original ? "ORIGINAL" : "RESIZED"),
 233             (gulong)self, pic->width, pic->height, RrImagePicHash(pic));
 234 #endif
 235 */
 236 }
 237
 238 /*! Merges two image sets, destroying one, and returning the other. */
 239 RrImageSet* RrImageSetMergeSets(RrImageSet *b, RrImageSet *a)
 240 {
 241     gint a_i, b_i, merged_i;
 242     RrImagePic **original, **resized;
 243     gint n_original, n_resized, tmp;
 244     GSList *it;
 245
 246     const gint max_resized = a->cache->max_resized_saved;
 247
 248     if (!a)
 249         return b;
 250     if (!b)
 251         return a;
 252     if (a == b)
 253         return b;
 254
 255     /* the original and resized picture lists in an RrImageSet are kept ordered
 256        as newest to oldest.  we don't have timestamps for them, so we cannot
 257        preserve this in the merged RrImageSet exactly.  a decent approximation,
 258        i think, is to add them in alternating order (one from a, one from b,
 259        repeat).  this way, the newest from each will be near the front at
 260        least, and in the resized list, when we drop an old picture, we will
 261        not always only drop from a or b only, but from each of them equally (or
 262        from whichever has more resized pictures.
 263     */
 264
 265     g_assert(b->cache == a->cache);
 266
 267     a_i = b_i = merged_i = 0;
 268     n_original = a->n_original + b->n_original;
 269     original = g_new(RrImagePic*, n_original);
 270     while (merged_i < n_original) {
 271         if (a_i < a->n_original)
 272             original[merged_i++] = a->original[a_i++];
 273         if (b_i < b->n_original)
 274             original[merged_i++] = b->original[b_i++];
 275     }
 276
 277     a_i = b_i = merged_i = 0;
 278     n_resized = MIN(max_resized, a->n_resized + b->n_resized);
 279     resized = g_new(RrImagePic*, n_resized);
 280     while (merged_i < n_resized) {
 281         if (a_i < a->n_resized)
 282             resized[merged_i++] = a->resized[a_i++];
 283         if (b_i < b->n_resized && merged_i < n_resized)
 284             resized[merged_i++] = b->resized[b_i++];
 285     }
 286
 287     /* if there are any RrImagePic objects left over in a->resized or
 288        b->resized, they need to be disposed of, and removed from the cache.
 289
 290        updates the size of the list, as we want to remember which pointers
 291        were merged from which list (and don't want to remember the ones we
 292        did not merge and have freed).
 293     */
 294     tmp = a_i;
 295     for (; a_i < a->n_resized; ++a_i) {
 296         g_hash_table_remove(a->cache->pic_table, a->resized[a_i]);
 297         RrImagePicFree(a->resized[a_i]);
 298     }
 299     a->n_resized = tmp;
 300
 301     tmp = b_i;
 302     for (; b_i < b->n_resized; ++b_i) {
 303         g_hash_table_remove(a->cache->pic_table, b->resized[b_i]);
 304         RrImagePicFree(b->resized[b_i]);
 305     }
 306     b->n_resized = tmp;
 307
 308     /* we will use the a object as the merge destination, so things in b will
 309        be moving.
 310
 311        the cache's name_table will point to b for all the names in b->names,
 312        so these need to be updated to point at a instead.
 313        also, the cache's pic_table will point to b for all the pictures in b,
 314        so these need to be updated to point at a as well.
 315
 316        any RrImage objects that were using b should now use a instead.
 317
 318        the names and images will be all moved into a, and the merged picture
 319        lists will be placed in a.  the pictures in a and b are moved to new
 320        arrays, so the arrays in a and b need to be freed explicitly (the
 321        RrImageSetFree function would free the picture data too which we do not
 322        want here). then b can be freed.
 323     */
 324
 325     for (it = b->names; it; it = g_slist_next(it))
 326         g_hash_table_insert(a->cache->name_table, it->data, a);
 327     for (b_i = 0; b_i < b->n_original; ++b_i)
 328         g_hash_table_insert(a->cache->pic_table, b->original[b_i], a);
 329     for (b_i = 0; b_i < b->n_resized; ++b_i)
 330         g_hash_table_insert(a->cache->pic_table, b->resized[b_i], a);
 331
 332     for (it = b->images; it; it = g_slist_next(it))
 333         ((RrImage*)it->data)->set = a;
 334
 335     a->images = g_slist_concat(a->images, b->images);
 336     b->images = NULL;
 337     a->names = g_slist_concat(a->names, b->names);
 338     b->names = NULL;
 339
 340     a->n_original = a->n_resized = 0;
 341     g_free(a->original);
 342     g_free(a->resized);
 343     a->original = a->resized = NULL;
 344     b->n_original = b->n_resized = 0;
 345     g_free(b->original);
 346     g_free(b->resized);
 347     b->original = b->resized = NULL;
 348
 349     a->n_original = n_original;
 350     a->original = original;
 351     a->n_resized = n_resized;
 352     a->resized = resized;
 353
 354     RrImageSetFree(b);
 355
 356     return a;
 357 }
 358
 359 static void RrImageSetAddName(RrImageSet *set, const gchar *name)
 360 {
 361     gchar *n;
 362
 363     n = g_strdup(name);
 364     set->names = g_slist_prepend(set->names, n);
 365
 366     /* add the new name to the hash table */
 367     g_assert(g_hash_table_lookup(set->cache->name_table, n) == NULL);
 368     g_hash_table_insert(set->cache->name_table, n, set);
 369 }
 370
 371
 372 /************************************************************************
 373  RrImage functions.
 374 **************************************************************************/
 375
 376
 377 void RrImageRef(RrImage *self)
 378 {
 379     ++self->ref;
 380 }
 381
 382 void RrImageUnref(RrImage *self)
 383 {
 384     if (self && --self->ref == 0) {
 385         RrImageSet *set;
 386 /*
 387 #ifdef DEBUG
 388         g_debug("Refcount to 0, removing ALL pictures from the cache:\n    "
 389                 "Image 0x%lx", (gulong)self);
 390 #endif
 391 */
 392         if (self->destroy_func)
 393             self->destroy_func(self, self->destroy_data);
 394
 395         set = self->set;
 396         set->images = g_slist_remove(set->images, self);
 397
 398         /* free the set as well if there are no images pointing to it */
 399         if (!set->images)
 400             RrImageSetFree(set);
 401         g_slice_free(RrImage, self);
 402     }
 403 }
 404
 405 /*! Set function that will be called just before RrImage is destroyed. */
 406 void RrImageSetDestroyFunc(RrImage *self, RrImageDestroyFunc func,
 407                            gpointer data)
 408 {
 409     self->destroy_func = func;
 410     self->destroy_data = data;
 411 }
 412
 413 void RrImageAddFromData(RrImage *self, RrPixel32 *data, gint w, gint h)
 414 {
 415     RrImagePic pic, *ppic;
 416     RrImageSet *set;
 417
 418     g_return_if_fail(self != NULL);
 419     g_return_if_fail(data != NULL);
 420     g_return_if_fail(w > 0 && h > 0);
 421
 422     RrImagePicInit(&pic, w, h, data);
 423     set = g_hash_table_lookup(self->set->cache->pic_table, &pic);
 424     if (set)
 425         self->set = RrImageSetMergeSets(self->set, set);
 426     else {
 427         ppic = RrImagePicNew(w, h, data);
 428         RrImageSetAddPicture(self->set, ppic, TRUE);
 429     }
 430 }
 431
 432 RrImage* RrImageNewFromData(RrImageCache *cache, RrPixel32 *data,
 433                             gint w, gint h)
 434 {
 435     RrImagePic pic, *ppic;
 436     RrImage *self;
 437     RrImageSet *set;
 438
 439     g_return_val_if_fail(cache != NULL, NULL);
 440     g_return_val_if_fail(data != NULL, NULL);
 441     g_return_val_if_fail(w > 0 && h > 0, NULL);
 442
 443     /* finds a picture in the cache, if it is already in there, and use the
 444        RrImageSet the picture lives in. */
 445     RrImagePicInit(&pic, w, h, data);
 446     set = g_hash_table_lookup(cache->pic_table, &pic);
 447     if (set) {
 448         self = set->images->data; /* just grab any RrImage from the list */
 449         RrImageRef(self);
 450         return self;
 451     }
 452
 453     /* the image does not exist in any RrImageSet in the cache, so make
 454        a new RrImageSet, and a new RrImage that points to it, and place the
 455        new image inside the new RrImageSet */
 456
 457     self = g_slice_new0(RrImage);
 458     self->ref = 1;
 459     self->set = g_slice_new0(RrImageSet);
 460     self->set->cache = cache;
 461     self->set->images = g_slist_append(self->set->images, self);
 462
 463     ppic = RrImagePicNew(w, h, data);
 464     RrImageSetAddPicture(self->set, ppic, TRUE);
 465
 466     return self;
 467 }
 468
 469 #if defined(USE_IMLIB2)
 470 typedef struct _ImlibLoader ImlibLoader;
 471
 472 struct _ImlibLoader
 473 {
 474     Imlib_Image img;
 475 };
 476
 477 void DestroyImlibLoader(ImlibLoader *loader)
 478 {
 479     if (!loader)
 480         return;
 481
 482     imlib_free_image();
 483     g_slice_free(ImlibLoader, loader);
 484 }
 485
 486 ImlibLoader* LoadWithImlib(gchar *path,
 487                            RrPixel32 **pixel_data,
 488                            gint *width,
 489                            gint *height)
 490 {
 491     ImlibLoader *loader = g_slice_new0(ImlibLoader);
 492     if (!(loader->img = imlib_load_image(path))) {
 493         DestroyImlibLoader(loader);
 494         return NULL;
 495     }
 496
 497     /* Get data and dimensions of the image.
 498
 499        WARNING: This stuff is NOT threadsafe !!
 500     */
 501     imlib_context_set_image(loader->img);
 502     *pixel_data = imlib_image_get_data_for_reading_only();
 503     *width = imlib_image_get_width();
 504     *height = imlib_image_get_height();
 505
 506     return loader;
 507 }
 508 #endif  /* USE_IMLIB2 */
 509
 510 #if defined(USE_LIBRSVG)
 511 typedef struct _RsvgLoader RsvgLoader;
 512
 513 struct _RsvgLoader
 514 {
 515     RsvgHandle *handle;
 516     cairo_surface_t *surface;
 517     RrPixel32 *pixel_data;
 518 };
 519
 520 void DestroyRsvgLoader(RsvgLoader *loader)
 521 {
 522     if (!loader)
 523         return;
 524
 525     if (loader->pixel_data)
 526         g_free(loader->pixel_data);
 527     if (loader->surface)
 528         cairo_surface_destroy(loader->surface);
 529     if (loader->handle)
 530         g_object_unref(loader->handle);
 531     g_slice_free(RsvgLoader, loader);
 532 }
 533
 534 RsvgLoader* LoadWithRsvg(gchar *path,
 535                          RrPixel32 **pixel_data,
 536                          gint *width,
 537                          gint *height)
 538 {
 539     RsvgLoader *loader = g_slice_new0(RsvgLoader);
 540
 541     if (!(loader->handle = rsvg_handle_new_from_file(path, NULL))) {
 542         DestroyRsvgLoader(loader);
 543         return NULL;
 544     }
 545
 546     if (!rsvg_handle_close(loader->handle, NULL)) {
 547         DestroyRsvgLoader(loader);
 548         return NULL;
 549     }
 550
 551     RsvgDimensionData dimension_data;
 552     rsvg_handle_get_dimensions(loader->handle, &dimension_data);
 553     *width = dimension_data.width;
 554     *height = dimension_data.height;
 555
 556     loader->surface = cairo_image_surface_create(
 557         CAIRO_FORMAT_ARGB32, *width, *height);
 558
 559     cairo_t* context = cairo_create(loader->surface);
 560     gboolean success = rsvg_handle_render_cairo(loader->handle, context);
 561     cairo_destroy(context);
 562
 563     if (!success) {
 564         DestroyRsvgLoader(loader);
 565         return NULL;
 566     }
 567
 568     loader->pixel_data = g_new(guint32, *width * *height);
 569
 570     /*
 571       Cairo has its data in ARGB with premultiplied alpha, but RrPixel32
 572       non-premultipled, so convert that. Also, RrPixel32 doesn't allow
 573       strides not equal to the width of the image.
 574     */
 575
 576     /* Verify that RrPixel32 has the same ordering as cairo. */
 577     g_assert(RrDefaultAlphaOffset == 24);
 578     g_assert(RrDefaultRedOffset == 16);
 579     g_assert(RrDefaultGreenOffset == 8);
 580     g_assert(RrDefaultBlueOffset == 0);
 581
 582     guint32 *out_row = loader->pixel_data;
 583
 584     guint32 *in_row =
 585         (guint32*)cairo_image_surface_get_data(loader->surface);
 586     gint in_stride = cairo_image_surface_get_stride(loader->surface);
 587
 588     gint y;
 589     for (y = 0; y < *height; ++y) {
 590         gint x;
 591         for (x = 0; x < *width; ++x) {
 592             guchar a = in_row[x] >> 24;
 593             guchar r = (in_row[x] >> 16) & 0xff;
 594             guchar g = (in_row[x] >> 8) & 0xff;
 595             guchar b = in_row[x] & 0xff;
 596             out_row[x] =
 597                 ((r * 256 / (a + 1)) << RrDefaultRedOffset) +
 598                 ((g * 256 / (a + 1)) << RrDefaultGreenOffset) +
 599                 ((b * 256 / (a + 1)) << RrDefaultBlueOffset) +
 600                 (a << RrDefaultAlphaOffset);
 601         }
 602         in_row += in_stride / 4;
 603         out_row += *width;
 604     }
 605
 606     *pixel_data = loader->pixel_data;
 607
 608     return loader;
 609 }
 610 #endif  /* USE_LIBRSVG */
 611
 612 RrImage* RrImageNewFromName(RrImageCache *cache, const gchar *name)
 613 {
 614     RrImage *self;
 615     RrImageSet *set;
 616     gint w, h;
 617     RrPixel32 *data;
 618     gchar *path;
 619     gboolean loaded;
 620
 621 #if defined(USE_IMLIB2)
 622     ImlibLoader *imlib_loader = NULL;
 623 #endif
 624 #if defined(USE_LIBRSVG)
 625     RsvgLoader *rsvg_loader = NULL;
 626 #endif
 627
 628     g_return_val_if_fail(cache != NULL, NULL);
 629     g_return_val_if_fail(name != NULL, NULL);
 630
 631     set = g_hash_table_lookup(cache->name_table, name);
 632     if (set) {
 633         self = set->images->data;
 634         RrImageRef(self);
 635         return self;
 636     }
 637
 638     /* XXX find the path via freedesktop icon spec (use obt) ! */
 639     path = g_strdup(name);
 640
 641     loaded = FALSE;
 642 #if defined(USE_LIBRSVG)
 643     if (!loaded) {
 644         rsvg_loader = LoadWithRsvg(path, &data, &w, &h);
 645         loaded = !!rsvg_loader;
 646     }
 647 #endif
 648 #if defined(USE_IMLIB2)
 649     if (!loaded) {
 650         imlib_loader = LoadWithImlib(path, &data, &w, &h);
 651         loaded = !!imlib_loader;
 652     }
 653 #endif
 654
 655     g_free(path);
 656
 657     if (!loaded) {
 658         g_message("Cannot load image \"%s\" from file \"%s\"", name, path);
 659 #if defined(USE_LIBRSVG)
 660         DestroyRsvgLoader(rsvg_loader);
 661 #endif
 662 #if defined(USE_IMLIB2)
 663         DestroyImlibLoader(imlib_loader);
 664 #endif
 665         return NULL;
 666     }
 667
 668     /* get an RrImage that contains an RrImageSet with this picture in it.
 669        the RrImage might be new, or reused if the picture was already in the
 670        cache.
 671
 672        either way, we get back an RrImageSet (via the RrImage), and we must add
 673        the name to that RrImageSet.  because of the check above, we know that
 674        there is no RrImageSet in the cache which already has the given name
 675        asosciated with it.
 676     */
 677
 678     self = RrImageNewFromData(cache, data, w, h);
 679     RrImageSetAddName(self->set, name);
 680
 681 #if defined(USE_LIBRSVG)
 682     DestroyRsvgLoader(rsvg_loader);
 683 #endif
 684 #if defined(USE_IMLIB2)
 685     DestroyImlibLoader(imlib_loader);
 686 #endif
 687
 688     return self;
 689 }
 690
 691 /************************************************************************
 692  Image drawing and resizing operations.
 693 **************************************************************************/
 694
 695 /*! Given a picture in RGBA format, of a specified size, resize it to the new
 696   requested size (but keep its aspect ratio).  If the image does not need to
 697   be resized (it is already the right size) then this returns NULL.  Otherwise
 698   it returns a newly allocated RrImagePic with the resized picture inside it
 699   @return Returns a newly allocated RrImagePic object with a new version of the
 700     image in the requested size (keeping aspect ratio).
 701 */
 702 static RrImagePic* ResizeImage(RrPixel32 *src,
 703                                gulong srcW, gulong srcH,
 704                                gulong dstW, gulong dstH)
 705 {
 706     RrPixel32 *dst, *dststart;
 707     RrImagePic *pic;
 708     gulong dstX, dstY, srcX, srcY;
 709     gulong srcX1, srcX2, srcY1, srcY2;
 710     gulong ratioX, ratioY;
 711     gulong aspectW, aspectH;
 712
 713     g_assert(srcW > 0);
 714     g_assert(srcH > 0);
 715     g_assert(dstW > 0);
 716     g_assert(dstH > 0);
 717
 718     /* keep the aspect ratio */
 719     aspectW = dstW;
 720     aspectH = (gint)(dstW * ((gdouble)srcH / srcW));
 721     if (aspectH > dstH) {
 722         aspectH = dstH;
 723         aspectW = (gint)(dstH * ((gdouble)srcW / srcH));
 724     }
 725     dstW = aspectW ? aspectW : 1;
 726     dstH = aspectH ? aspectH : 1;
 727
 728     if (srcW == dstW && srcH == dstH)
 729         return NULL; /* no scaling needed! */
 730
 731     dststart = dst = g_new(RrPixel32, dstW * dstH);
 732
 733     ratioX = (srcW << FRACTION) / dstW;
 734     ratioY = (srcH << FRACTION) / dstH;
 735
 736     srcY2 = 0;
 737     for (dstY = 0; dstY < dstH; dstY++) {
 738         srcY1 = srcY2;
 739         srcY2 += ratioY;
 740
 741         srcX2 = 0;
 742         for (dstX = 0; dstX < dstW; dstX++) {
 743             gulong red = 0, green = 0, blue = 0, alpha = 0;
 744             gulong portionX, portionY, portionXY, sumXY = 0;
 745             RrPixel32 pixel;
 746
 747             srcX1 = srcX2;
 748             srcX2 += ratioX;
 749
 750             for (srcY = srcY1; srcY < srcY2; srcY += (1UL << FRACTION)) {
 751                 if (srcY == srcY1) {
 752                     srcY = FLOOR(srcY);
 753                     portionY = (1UL << FRACTION) - (srcY1 - srcY);
 754                     if (portionY > srcY2 - srcY1)
 755                         portionY = srcY2 - srcY1;
 756                 }
 757                 else if (srcY == FLOOR(srcY2))
 758                     portionY = srcY2 - srcY;
 759                 else
 760                     portionY = (1UL << FRACTION);
 761
 762                 for (srcX = srcX1; srcX < srcX2; srcX += (1UL << FRACTION)) {
 763                     if (srcX == srcX1) {
 764                         srcX = FLOOR(srcX);
 765                         portionX = (1UL << FRACTION) - (srcX1 - srcX);
 766                         if (portionX > srcX2 - srcX1)
 767                             portionX = srcX2 - srcX1;
 768                     }
 769                     else if (srcX == FLOOR(srcX2))
 770                         portionX = srcX2 - srcX;
 771                     else
 772                         portionX = (1UL << FRACTION);
 773
 774                     portionXY = (portionX * portionY) >> FRACTION;
 775                     sumXY += portionXY;
 776
 777                     pixel = *(src + (srcY >> FRACTION) * srcW
 778                             + (srcX >> FRACTION));
 779                     red   += ((pixel >> RrDefaultRedOffset)   & 0xFF)
 780                              * portionXY;
 781                     green += ((pixel >> RrDefaultGreenOffset) & 0xFF)
 782                              * portionXY;
 783                     blue  += ((pixel >> RrDefaultBlueOffset)  & 0xFF)
 784                              * portionXY;
 785                     alpha += ((pixel >> RrDefaultAlphaOffset) & 0xFF)
 786                              * portionXY;
 787                 }
 788             }
 789
 790             g_assert(sumXY != 0);
 791             red   /= sumXY;
 792             green /= sumXY;
 793             blue  /= sumXY;
 794             alpha /= sumXY;
 795
 796             *dst++ = (red   << RrDefaultRedOffset)   |
 797                      (green << RrDefaultGreenOffset) |
 798                      (blue  << RrDefaultBlueOffset)  |
 799                      (alpha << RrDefaultAlphaOffset);
 800         }
 801     }
 802
 803     pic = g_slice_new(RrImagePic);
 804     RrImagePicInit(pic, dstW, dstH, dststart);
 805
 806     return pic;
 807 }
 808
 809 /*! This draws an RGBA picture into the target, within the rectangle specified
 810   by the area parameter.  If the area's size differs from the source's then it
 811   will be centered within the rectangle */
 812 void DrawRGBA(RrPixel32 *target, gint target_w, gint target_h,
 813               RrPixel32 *source, gint source_w, gint source_h,
 814               gint alpha, RrRect *area)
 815 {
 816     RrPixel32 *dest;
 817     gint col, num_pixels;
 818     gint dw, dh;
 819
 820     g_assert(source_w <= area->width && source_h <= area->height);
 821     g_assert(area->x + area->width <= target_w);
 822     g_assert(area->y + area->height <= target_h);
 823
 824     /* keep the aspect ratio */
 825     dw = area->width;
 826     dh = (gint)(dw * ((gdouble)source_h / source_w));
 827     if (dh > area->height) {
 828         dh = area->height;
 829         dw = (gint)(dh * ((gdouble)source_w / source_h));
 830     }
 831
 832     /* copy source -> dest, and apply the alpha channel.
 833        center the image if it is smaller than the area */
 834     col = 0;
 835     num_pixels = dw * dh;
 836     dest = target + area->x + (area->width - dw) / 2 +
 837         (target_w * (area->y + (area->height - dh) / 2));
 838     while (num_pixels-- > 0) {
 839         guchar a, r, g, b, bgr, bgg, bgb;
 840
 841         /* apply the rgba's opacity as well */
 842         a = ((*source >> RrDefaultAlphaOffset) * alpha) >> 8;
 843         r = *source >> RrDefaultRedOffset;
 844         g = *source >> RrDefaultGreenOffset;
 845         b = *source >> RrDefaultBlueOffset;
 846
 847         /* background color */
 848         bgr = *dest >> RrDefaultRedOffset;
 849         bgg = *dest >> RrDefaultGreenOffset;
 850         bgb = *dest >> RrDefaultBlueOffset;
 851
 852         r = bgr + (((r - bgr) * a) >> 8);
 853         g = bgg + (((g - bgg) * a) >> 8);
 854         b = bgb + (((b - bgb) * a) >> 8);
 855
 856         *dest = ((r << RrDefaultRedOffset) |
 857                  (g << RrDefaultGreenOffset) |
 858                  (b << RrDefaultBlueOffset));
 859
 860         dest++;
 861         source++;
 862
 863         if (++col >= dw) {
 864             col = 0;
 865             dest += target_w - dw;
 866         }
 867     }
 868 }
 869
 870 /*! Draw an RGBA texture into a target pixel buffer. */
 871 void RrImageDrawRGBA(RrPixel32 *target, RrTextureRGBA *rgba,
 872                      gint target_w, gint target_h,
 873                      RrRect *area)
 874 {
 875     RrImagePic *scaled;
 876
 877     scaled = ResizeImage(rgba->data, rgba->width, rgba->height,
 878                          area->width, area->height);
 879
 880     if (scaled) {
 881 #ifdef DEBUG
 882             g_warning("Scaling an RGBA! You should avoid this and just make "
 883                       "it the right size yourself!");
 884 #endif
 885             DrawRGBA(target, target_w, target_h,
 886                      scaled->data, scaled->width, scaled->height,
 887                      rgba->alpha, area);
 888             RrImagePicFree(scaled);
 889     }
 890     else
 891         DrawRGBA(target, target_w, target_h,
 892                  rgba->data, rgba->width, rgba->height,
 893                  rgba->alpha, area);
 894 }
 895
 896 /*! Draw an RrImage texture into a target pixel buffer.  If the RrImage does
 897   not contain a picture of the appropriate size, then one of its "original"
 898   pictures will be resized and used (and stored in the RrImage as a "resized"
 899   picture).
 900  */
 901 void RrImageDrawImage(RrPixel32 *target, RrTextureImage *img,
 902                       gint target_w, gint target_h,
 903                       RrRect *area)
 904 {
 905     gint i, min_diff, min_i, min_aspect_diff, min_aspect_i;
 906     RrImage *self;
 907     RrImageSet *set;
 908     RrImagePic *pic;
 909     gboolean free_pic;
 910
 911     self = img->image;
 912     set = self->set;
 913     pic = NULL;
 914     free_pic = FALSE;
 915
 916     /* is there an original of this size? (only the larger of
 917        w or h has to be right cuz we maintain aspect ratios) */
 918     for (i = 0; i < set->n_original; ++i)
 919         if ((set->original[i]->width >= set->original[i]->height &&
 920              set->original[i]->width == area->width) ||
 921             (set->original[i]->width <= set->original[i]->height &&
 922              set->original[i]->height == area->height))
 923         {
 924             pic = set->original[i];
 925             break;
 926         }
 927
 928     /* is there a resize of this size? */
 929     for (i = 0; i < set->n_resized; ++i)
 930         if ((set->resized[i]->width >= set->resized[i]->height &&
 931              set->resized[i]->width == area->width) ||
 932             (set->resized[i]->width <= set->resized[i]->height &&
 933              set->resized[i]->height == area->height))
 934         {
 935             gint j;
 936             RrImagePic *saved;
 937
 938             /* save the selected one */
 939             saved = set->resized[i];
 940
 941             /* shift all the others down */
 942             for (j = i; j > 0; --j)
 943                 set->resized[j] = set->resized[j-1];
 944
 945             /* and move the selected one to the top of the list */
 946             set->resized[0] = saved;
 947
 948             pic = set->resized[0];
 949             break;
 950         }
 951
 952     if (!pic) {
 953         gdouble aspect;
 954         RrImageSet *cache_set;
 955
 956         /* find an original with a close size */
 957         min_diff = min_aspect_diff = -1;
 958         min_i = min_aspect_i = 0;
 959         aspect = ((gdouble)area->width) / area->height;
 960         for (i = 0; i < set->n_original; ++i) {
 961             gint diff;
 962             gint wdiff, hdiff;
 963             gdouble myasp;
 964
 965             /* our size difference metric.. */
 966             wdiff = set->original[i]->width - area->width;
 967             if (wdiff < 0) wdiff *= 2; /* prefer scaling down than up */
 968             hdiff = set->original[i]->height - area->height;
 969             if (hdiff < 0) hdiff *= 2; /* prefer scaling down than up */
 970             diff = (wdiff * wdiff) + (hdiff * hdiff);
 971
 972             /* find the smallest difference */
 973             if (min_diff < 0 || diff < min_diff) {
 974                 min_diff = diff;
 975                 min_i = i;
 976             }
 977             /* and also find the smallest difference with the same aspect
 978                ratio (and prefer this one) */
 979             myasp = ((gdouble)set->original[i]->width) /
 980                 set->original[i]->height;
 981             if (ABS(aspect - myasp) < 0.0000001 &&
 982                 (min_aspect_diff < 0 || diff < min_aspect_diff))
 983             {
 984                 min_aspect_diff = diff;
 985                 min_aspect_i = i;
 986             }
 987         }
 988
 989         /* use the aspect ratio correct source if there is one */
 990         if (min_aspect_i >= 0)
 991             min_i = min_aspect_i;
 992
 993         /* resize the original to the given area */
 994         pic = ResizeImage(set->original[min_i]->data,
 995                           set->original[min_i]->width,
 996                           set->original[min_i]->height,
 997                           area->width, area->height);
 998
 999         /* is it already in the cache ? */
1000         cache_set = g_hash_table_lookup(set->cache->pic_table, pic);
1001         if (cache_set) {
1002             /* merge this set with the one found in the cache - they are
1003                apparently the same image !  then next time we won't have to do
1004                this resizing, we will use the cache_set's pic instead. */
1005             set = RrImageSetMergeSets(set, cache_set);
1006             free_pic = TRUE;
1007         }
1008         else {
1009             /* add the resized image to the image, as the first in the resized
1010                list */
1011             while (set->n_resized >= set->cache->max_resized_saved)
1012                 /* remove the last one (last used one) to make space for
1013                  adding our resized picture */
1014                 RrImageSetRemovePictureAt(set, set->n_resized-1, FALSE);
1015             if (set->cache->max_resized_saved)
1016                 /* add it to the resized list */
1017                 RrImageSetAddPicture(set, pic, FALSE);
1018             else
1019                 free_pic = TRUE; /* don't leak mem! */
1020         }
1021     }
1022
1023     /* The RrImageSet may have changed if we merged it with another, so the
1024        RrImage object needs to be updated to use the new merged RrImageSet. */
1025     self->set = set;
1026
1027     g_assert(pic != NULL);
1028
1029     DrawRGBA(target, target_w, target_h,
1030              pic->data, pic->width, pic->height,
1031              img->alpha, area);
1032     if (free_pic)
1033         RrImagePicFree(pic);
1034 }