consistant glib type usage
[dana/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) 2003        Ben Jansens
5
6    This program is free software; you can redistribute it and/or modify
7    it under the terms of the GNU General Public License as published by
8    the Free Software Foundation; either version 2 of the License, or
9    (at your option) any later version.
10
11    This program is distributed in the hope that it will be useful,
12    but WITHOUT ANY WARRANTY; without even the implied warranty of
13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14    GNU General Public License for more details.
15
16    See the COPYING file for a copy of the GNU General Public License.
17 */
18
19 #include "geom.h"
20 #include "image.h"
21 #include "color.h"
22
23 #include <glib.h>
24
25 #define AVERAGE(a, b)   ( ((((a) ^ (b)) & 0xfefefefeL) >> 1) + ((a) & (b)) )
26
27 static void scale_line(RrPixel32 *dest, RrPixel32 *source, gint w, gint dw)
28 {
29     gint num_pixels = dw;
30     gint int_part = w / dw;
31     gint fract_part = w % dw;
32     gint err = 0;
33
34     while (num_pixels-- > 0) {
35         *dest++ = *source;
36         source += int_part;
37         err += fract_part;
38         if (err >= dw) {
39             err -= dw;
40             source++;
41         }
42     }
43 }
44
45 static RrPixel32* scale_half(RrPixel32 *source, gint w, gint h)
46 {
47     RrPixel32 *out, *dest, *sourceline, *sourceline2;
48     gint dw, dh, x, y;
49
50     sourceline = source;
51     sourceline2 = source + w;
52
53     dw = w >> 1;
54     dh = h >> 1;
55
56     out = dest = g_new(RrPixel32, dw * dh);
57
58     for (y = 0; y < dh; ++y) {
59         RrPixel32 *s, *s2;
60
61         s = sourceline;
62         s2 = sourceline2;
63
64         for (x = 0; x < dw; ++x) {
65             *dest++ = AVERAGE(AVERAGE(*s, *(s+1)),
66                               AVERAGE(*s2, *(s2+1)));
67             s += 2;
68             s2 += 2;
69         }
70         sourceline += w << 1;
71         sourceline2 += w << 1;
72     }
73     return out;
74 }
75
76 static RrPixel32* scale_rect(RrPixel32 *fullsource,
77                              gint w, gint h, gint dw, gint dh)
78 {
79     RrPixel32 *out, *dest;
80     RrPixel32 *source = fullsource;
81     RrPixel32 *oldsource = NULL;
82     RrPixel32 *prev_source = NULL;
83     gint num_pixels;
84     gint int_part;
85     gint fract_part;
86     gint err = 0;
87
88     while (dw <= (w >> 1) && dh <= (h >> 1)) {
89         source = scale_half(source, w, h);
90         w >>= 1; h >>= 1;
91         g_free(oldsource);
92         oldsource = source;
93     }
94
95     num_pixels = dh;
96     int_part = (h / dh) * w;
97     fract_part = h % dh;
98
99     out = dest = g_new(RrPixel32, dw * dh);
100
101     while (num_pixels-- > 0) {
102         if (source == prev_source) {
103             memcpy(dest, dest - dw, dw * sizeof(RrPixel32));
104         } else {
105             scale_line(dest, source, w, dw);
106             prev_source = source;
107         }
108         dest += dw;
109         source += int_part;
110         err += fract_part;
111         if (err >= dh) {
112             err -= dh;
113             source += w;
114         }
115     }
116
117     g_free(oldsource);
118
119     return out;
120 }
121
122 void RrImageDraw(RrPixel32 *target, RrTextureRGBA *rgba,
123                  gint target_w, gint target_h,
124                  RrRect *area)
125 {
126     RrPixel32 *dest;
127     RrPixel32 *source;
128     gint sw, sh, dw, dh;
129     gint col, num_pixels;
130
131     sw = rgba->width;
132     sh = rgba->height;
133
134     /* keep the ratio */
135     dw = area->width;
136     dh = (gint)(dw * ((gdouble)sh / sw));
137     if (dh > area->height) {
138         dh = area->height;
139         dw = (gint)(dh * ((gdouble)sw / sh));
140     }
141
142     if (sw != dw || sh != dh) {
143         /*if (!(rgba->cache && dw == rgba->cwidth && dh == rgba->cheight))*/ {
144             g_free(rgba->cache);
145             rgba->cache = scale_rect(rgba->data, sw, sh, dw, dh);
146             rgba->cwidth = dw;
147             rgba->cheight = dh;
148         }
149         source = rgba->cache;
150     } else {
151         source = rgba->data;
152     }
153
154     /* copy source -> dest, and apply the alpha channel */
155     col = 0;
156     num_pixels = dw * dh;
157     dest = target + area->x + target_w * area->y;
158     while (num_pixels-- > 0) {
159         guchar alpha, r, g, b, bgr, bgg, bgb;
160
161         alpha = *source >> RrDefaultAlphaOffset;
162         r = *source >> RrDefaultRedOffset;
163         g = *source >> RrDefaultGreenOffset;
164         b = *source >> RrDefaultBlueOffset;
165         
166         /* background color */
167         bgr = *dest >> RrDefaultRedOffset;
168         bgg = *dest >> RrDefaultGreenOffset;
169         bgb = *dest >> RrDefaultBlueOffset;
170
171         r = bgr + (((r - bgr) * alpha) >> 8);
172         g = bgg + (((g - bgg) * alpha) >> 8);
173         b = bgb + (((b - bgb) * alpha) >> 8);
174
175         *dest = ((r << RrDefaultRedOffset) |
176                  (g << RrDefaultGreenOffset) |
177                  (b << RrDefaultBlueOffset));
178
179         dest++;
180         source++;
181
182         if (col++ >= dw) {
183             col = 0;
184             dest += target_w - dw;
185         }
186     }
187 }