don't need to &0xff
[mikachu/openbox.git] / render / 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
24 #include <glib.h>
25
26 #define FRACTION        12
27 #define FLOOR(i)        ((i) & (~0UL << FRACTION))
28 #define AVERAGE(a, b)   (((((a) ^ (b)) & 0xfefefefeL) >> 1) + ((a) & (b)))
29
30 static void ImageCopyResampled(RrPixel32 *dst, RrPixel32 *src,
31                                gulong dstW, gulong dstH,
32                                gulong srcW, gulong srcH)
33 {
34     gulong dstX, dstY, srcX, srcY;
35     gulong srcX1, srcX2, srcY1, srcY2;
36     gulong ratioX, ratioY;
37     
38     ratioX = (srcW << FRACTION) / dstW;
39     ratioY = (srcH << FRACTION) / dstH;
40     
41     srcY2 = 0;
42     for (dstY = 0; dstY < dstH; dstY++) {
43         srcY1 = srcY2;
44         srcY2 += ratioY;
45         
46         srcX2 = 0;
47         for (dstX = 0; dstX < dstW; dstX++) {
48             gulong red = 0, green = 0, blue = 0, alpha = 0;
49             gulong portionX, portionY, portionXY, sumXY = 0;
50             RrPixel32 pixel;
51             
52             srcX1 = srcX2;
53             srcX2 += ratioX;
54             
55             for (srcY = srcY1; srcY < srcY2; srcY += (1UL << FRACTION)) {
56                 if (srcY == srcY1) {
57                     srcY = FLOOR(srcY);
58                     portionY = (1UL << FRACTION) - (srcY1 - srcY);
59                     if (portionY > srcY2 - srcY1)
60                         portionY = srcY2 - srcY1;
61                 }
62                 else if (srcY == FLOOR(srcY2))
63                     portionY = srcY2 - srcY;
64                 else
65                     portionY = (1UL << FRACTION);
66                 
67                 for (srcX = srcX1; srcX < srcX2; srcX += (1UL << FRACTION)) {
68                     if (srcX == srcX1) {
69                         srcX = FLOOR(srcX);
70                         portionX = (1UL << FRACTION) - (srcX1 - srcX);
71                         if (portionX > srcX2 - srcX1)
72                             portionX = srcX2 - srcX1;
73                     }
74                     else if (srcX == FLOOR(srcX2))
75                         portionX = srcX2 - srcX;
76                     else
77                         portionX = (1UL << FRACTION);
78                     
79                     portionXY = (portionX * portionY) >> FRACTION;
80                     sumXY += portionXY;
81                     
82                     pixel = *(src + (srcY >> FRACTION) * srcW
83                             + (srcX >> FRACTION));
84                     red   += ((pixel >> RrDefaultRedOffset)   & 0xFF)
85                              * portionXY;
86                     green += ((pixel >> RrDefaultGreenOffset) & 0xFF)
87                              * portionXY;
88                     blue  += ((pixel >> RrDefaultBlueOffset)  & 0xFF)
89                              * portionXY;
90                     alpha += ((pixel >> RrDefaultAlphaOffset) & 0xFF)
91                              * portionXY;
92                 }
93             }
94             
95             g_assert(sumXY != 0);
96             red   /= sumXY;
97             green /= sumXY;
98             blue  /= sumXY;
99             alpha /= sumXY;
100             
101             *dst++ = (red   << RrDefaultRedOffset)   |
102                      (green << RrDefaultGreenOffset) |
103                      (blue  << RrDefaultBlueOffset)  |
104                      (alpha << RrDefaultAlphaOffset);
105         }
106     }
107 }
108
109 void RrImageDraw(RrPixel32 *target, RrTextureRGBA *rgba,
110                  gint target_w, gint target_h,
111                  RrRect *area)
112 {
113     RrPixel32 *dest;
114     RrPixel32 *source;
115     gint sw, sh, dw, dh;
116     gint col, num_pixels;
117
118     sw = rgba->width;
119     sh = rgba->height;
120
121     /* keep the ratio */
122     dw = area->width;
123     dh = (gint)(dw * ((gdouble)sh / sw));
124     if (dh > area->height) {
125         dh = area->height;
126         dw = (gint)(dh * ((gdouble)sw / sh));
127     }
128
129     if (!(dw && dh))
130         return; /* XXX sanity check */
131
132     if (sw != dw || sh != dh) {
133         /*if (!(rgba->cache && dw == rgba->cwidth && dh == rgba->cheight))*/ {
134             g_free(rgba->cache);
135             rgba->cache = g_new(RrPixel32, dw * dh);
136             ImageCopyResampled(rgba->cache, rgba->data, dw, dh, sw, sh);
137             rgba->cwidth = dw;
138             rgba->cheight = dh;
139         }
140         source = rgba->cache;
141     } else {
142         source = rgba->data;
143     }
144
145     /* copy source -> dest, and apply the alpha channel.
146
147        center the image if it is smaller than the area */
148     col = 0;
149     num_pixels = dw * dh;
150     dest = target + area->x + (area->width - dw) / 2 +
151         (target_w * (area->y + (area->height - dh) / 2));
152     while (num_pixels-- > 0) {
153         guchar alpha, r, g, b, bgr, bgg, bgb;
154
155         /* apply the rgba's opacity as well */
156         alpha = ((*source >> RrDefaultAlphaOffset) * rgba->alpha) >> 8;
157         r = *source >> RrDefaultRedOffset;
158         g = *source >> RrDefaultGreenOffset;
159         b = *source >> RrDefaultBlueOffset;
160
161         /* background color */
162         bgr = *dest >> RrDefaultRedOffset;
163         bgg = *dest >> RrDefaultGreenOffset;
164         bgb = *dest >> RrDefaultBlueOffset;
165
166         r = bgr + (((r - bgr) * alpha) >> 8);
167         g = bgg + (((g - bgg) * alpha) >> 8);
168         b = bgb + (((b - bgb) * alpha) >> 8);
169
170         *dest = ((r << RrDefaultRedOffset) |
171                  (g << RrDefaultGreenOffset) |
172                  (b << RrDefaultBlueOffset));
173
174         dest++;
175         source++;
176
177         if (++col >= dw) {
178             col = 0;
179             dest += target_w - dw;
180         }
181     }
182 }