1 /* -*- indent-tabs-mode: nil; tab-width: 4; c-basic-offset: 4; -*-
3 image.c for the Openbox window manager
4 Copyright (c) 2006 Mikael Magnusson
5 Copyright (c) 2003-2007 Dana Jansens
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.
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.
17 See the COPYING file for a copy of the GNU General Public License.
23 #include "imagecache.h"
28 #define FLOOR(i) ((i) & (~0UL << FRACTION))
29 #define AVERAGE(a, b) (((((a) ^ (b)) & 0xfefefefeL) >> 1) + ((a) & (b)))
31 void RrImagePicInit(RrImagePic *pic, gint w, gint h, RrPixel32 *data)
39 for (i = w*h; i > 0; --i)
40 pic->sum += *(data++);
43 static void RrImagePicFree(RrImagePic *pic)
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
54 static void AddPicture(RrImage *self, RrImagePic ***list, gint *len,
59 g_assert(pic->width > 0 && pic->height > 0);
61 g_assert(g_hash_table_lookup(self->cache->table, pic) == NULL);
64 *list = g_renew(RrImagePic*, *list, ++*len);
66 /* move everything else down one */
67 for (i = *len-1; i > 0; --i)
68 (*list)[i] = (*list)[i-1];
70 /* set the new picture up at the front of the list */
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);
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));
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,
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]));
103 /* remove the picture as a key in the cache */
104 g_hash_table_remove(self->cache->table, (*list)[i]);
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);
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
120 static RrImagePic* ResizeImage(RrPixel32 *src,
121 gulong srcW, gulong srcH,
122 gulong dstW, gulong dstH)
124 RrPixel32 *dst, *dststart;
126 gulong dstX, dstY, srcX, srcY;
127 gulong srcX1, srcX2, srcY1, srcY2;
128 gulong ratioX, ratioY;
129 gulong aspectW, aspectH;
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;
137 /* keep the aspect ratio */
139 aspectH = (gint)(dstW * ((gdouble)srcH / srcW));
140 if (aspectH > dstH) {
142 aspectW = (gint)(dstH * ((gdouble)srcW / srcH));
144 dstW = aspectW ? aspectW : 1;
145 dstH = aspectH ? aspectH : 1;
147 if (srcW == dstW && srcH == dstH)
148 return NULL; /* no scaling needed! */
150 dststart = dst = g_new(RrPixel32, dstW * dstH);
152 ratioX = (srcW << FRACTION) / dstW;
153 ratioY = (srcH << FRACTION) / dstH;
156 for (dstY = 0; dstY < dstH; dstY++) {
161 for (dstX = 0; dstX < dstW; dstX++) {
162 gulong red = 0, green = 0, blue = 0, alpha = 0;
163 gulong portionX, portionY, portionXY, sumXY = 0;
169 for (srcY = srcY1; srcY < srcY2; srcY += (1UL << FRACTION)) {
172 portionY = (1UL << FRACTION) - (srcY1 - srcY);
173 if (portionY > srcY2 - srcY1)
174 portionY = srcY2 - srcY1;
176 else if (srcY == FLOOR(srcY2))
177 portionY = srcY2 - srcY;
179 portionY = (1UL << FRACTION);
181 for (srcX = srcX1; srcX < srcX2; srcX += (1UL << FRACTION)) {
184 portionX = (1UL << FRACTION) - (srcX1 - srcX);
185 if (portionX > srcX2 - srcX1)
186 portionX = srcX2 - srcX1;
188 else if (srcX == FLOOR(srcX2))
189 portionX = srcX2 - srcX;
191 portionX = (1UL << FRACTION);
193 portionXY = (portionX * portionY) >> FRACTION;
196 pixel = *(src + (srcY >> FRACTION) * srcW
197 + (srcX >> FRACTION));
198 red += ((pixel >> RrDefaultRedOffset) & 0xFF)
200 green += ((pixel >> RrDefaultGreenOffset) & 0xFF)
202 blue += ((pixel >> RrDefaultBlueOffset) & 0xFF)
204 alpha += ((pixel >> RrDefaultAlphaOffset) & 0xFF)
209 g_assert(sumXY != 0);
215 *dst++ = (red << RrDefaultRedOffset) |
216 (green << RrDefaultGreenOffset) |
217 (blue << RrDefaultBlueOffset) |
218 (alpha << RrDefaultAlphaOffset);
222 pic = g_new(RrImagePic, 1);
223 RrImagePicInit(pic, dstW, dstH, dststart);
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)
236 gint col, num_pixels;
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);
243 /* keep the aspect ratio */
245 dh = (gint)(dw * ((gdouble)source_h / source_w));
246 if (dh > area->height) {
248 dw = (gint)(dh * ((gdouble)source_w / source_h));
251 /* copy source -> dest, and apply the alpha channel.
252 center the image if it is smaller than the area */
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;
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;
266 /* background color */
267 bgr = *dest >> RrDefaultRedOffset;
268 bgg = *dest >> RrDefaultGreenOffset;
269 bgb = *dest >> RrDefaultBlueOffset;
271 r = bgr + (((r - bgr) * a) >> 8);
272 g = bgg + (((g - bgg) * a) >> 8);
273 b = bgb + (((b - bgb) * a) >> 8);
275 *dest = ((r << RrDefaultRedOffset) |
276 (g << RrDefaultGreenOffset) |
277 (b << RrDefaultBlueOffset));
284 dest += target_w - dw;
289 /*! Draw an RGBA texture into a target pixel buffer. */
290 void RrImageDrawRGBA(RrPixel32 *target, RrTextureRGBA *rgba,
291 gint target_w, gint target_h,
296 scaled = ResizeImage(rgba->data, rgba->width, rgba->height,
297 area->width, area->height);
301 g_warning("Scaling an RGBA! You should avoid this and just make "
302 "it the right size yourself!");
304 DrawRGBA(target, target_w, target_h,
305 scaled->data, scaled->width, scaled->height,
307 RrImagePicFree(scaled);
310 DrawRGBA(target, target_w, target_h,
311 rgba->data, rgba->width, rgba->height,
315 /*! Create a new RrImage, which is linked to an image cache */
316 RrImage* RrImageNew(RrImageCache *cache)
320 g_assert(cache != NULL);
322 self = g_new0(RrImage, 1);
328 /*! Set function that will be called just before RrImage is destroyed. */
329 void RrImageSetDestroyFunc(RrImage *image, RrImageDestroyFunc func)
331 image->destroy_func = func;
334 void RrImageRef(RrImage *self)
339 void RrImageUnref(RrImage *self)
341 if (self && --self->ref == 0) {
344 g_debug("Refcount to 0, removing ALL pictures from the cache:\n "
345 "Image 0x%lx", (gulong)self);
348 if (self->destroy_func)
349 self->destroy_func(self);
350 while (self->n_original > 0)
351 RemovePicture(self, &self->original, 0, &self->n_original);
352 while (self->n_resized > 0)
353 RemovePicture(self, &self->resized, 0, &self->n_resized);
358 /*! Add a new picture with the given RGBA pixel data and dimensions into the
359 RrImage. This adds an "original" picture to the image.
361 void RrImageAddPicture(RrImage *self, RrPixel32 *data, gint w, gint h)
366 /* make sure we don't already have this size.. */
367 for (i = 0; i < self->n_original; ++i)
368 if (self->original[i]->width == w && self->original[i]->height == h) {
371 g_debug("Found duplicate ORIGINAL image:\n "
372 "Image 0x%lx, w %d h %d", (gulong)self, w, h);
378 /* remove any resized pictures of this same size */
379 for (i = 0; i < self->n_resized; ++i)
380 if (self->resized[i]->width == w || self->resized[i]->height == h) {
381 RemovePicture(self, &self->resized, i, &self->n_resized);
385 /* add the new picture */
386 pic = g_new(RrImagePic, 1);
387 RrImagePicInit(pic, w, h, g_memdup(data, w*h*sizeof(RrPixel32)));
388 AddPicture(self, &self->original, &self->n_original, pic);
391 /*! Remove the picture from the RrImage which has the given dimensions. This
392 removes an "original" picture from the image.
394 void RrImageRemovePicture(RrImage *self, gint w, gint h)
398 /* remove any resized pictures of this same size */
399 for (i = 0; i < self->n_original; ++i)
400 if (self->original[i]->width == w && self->original[i]->height == h) {
401 RemovePicture(self, &self->original, i, &self->n_original);
406 /*! Draw an RrImage texture into a target pixel buffer. If the RrImage does
407 not contain a picture of the appropriate size, then one of its "original"
408 pictures will be resized and used (and stored in the RrImage as a "resized"
411 void RrImageDrawImage(RrPixel32 *target, RrTextureImage *img,
412 gint target_w, gint target_h,
415 gint i, min_diff, min_i, min_aspect_diff, min_aspect_i;
424 /* is there an original of this size? (only the larger of
425 w or h has to be right cuz we maintain aspect ratios) */
426 for (i = 0; i < self->n_original; ++i)
427 if ((self->original[i]->width >= self->original[i]->height &&
428 self->original[i]->width == area->width) ||
429 (self->original[i]->width <= self->original[i]->height &&
430 self->original[i]->height == area->height))
432 pic = self->original[i];
436 /* is there a resize of this size? */
437 for (i = 0; i < self->n_resized; ++i)
438 if ((self->resized[i]->width >= self->resized[i]->height &&
439 self->resized[i]->width == area->width) ||
440 (self->resized[i]->width <= self->resized[i]->height &&
441 self->resized[i]->height == area->height))
446 /* save the selected one */
447 saved = self->resized[i];
449 /* shift all the others down */
450 for (j = i; j > 0; --j)
451 self->resized[j] = self->resized[j-1];
453 /* and move the selected one to the top of the list */
454 self->resized[0] = saved;
456 pic = self->resized[0];
463 /* find an original with a close size */
464 min_diff = min_aspect_diff = -1;
465 min_i = min_aspect_i = 0;
466 aspect = ((gdouble)area->width) / area->height;
467 for (i = 0; i < self->n_original; ++i) {
472 /* our size difference metric.. */
473 wdiff = self->original[i]->width - area->width;
474 hdiff = self->original[i]->height - area->height;
475 diff = (wdiff * wdiff) + (hdiff * hdiff);
477 /* find the smallest difference */
478 if (min_diff < 0 || diff < min_diff) {
482 /* and also find the smallest difference with the same aspect
483 ratio (and prefer this one) */
484 myasp = ((gdouble)self->original[i]->width) /
485 self->original[i]->height;
486 if (ABS(aspect - myasp) < 0.0000001 &&
487 (min_aspect_diff < 0 || diff < min_aspect_diff))
489 min_aspect_diff = diff;
494 /* use the aspect ratio correct source if there is one */
495 if (min_aspect_i >= 0)
496 min_i = min_aspect_i;
498 /* resize the original to the given area */
499 pic = ResizeImage(self->original[min_i]->data,
500 self->original[min_i]->width,
501 self->original[min_i]->height,
502 area->width, area->height);
504 /* add the resized image to the image, as the first in the resized
506 if (self->n_resized >= self->cache->max_resized_saved)
507 /* remove the last one (last used one) */
508 RemovePicture(self, &self->resized, self->n_resized - 1,
510 if (self->cache->max_resized_saved)
511 /* add it to the top of the resized list */
512 AddPicture(self, &self->resized, &self->n_resized, pic);
514 free_pic = TRUE; /* don't leak mem! */
517 g_assert(pic != NULL);
519 DrawRGBA(target, target_w, target_h,
520 pic->data, pic->width, pic->height,