keep the PID file locked for the lifetime of the process
[qemu.git] / ui / sdl_zoom_template.h
1 /*
2 * SDL_zoom_template - surface scaling
3 *
4 * Copyright (c) 2009 Citrix Systems, Inc.
5 *
6 * Derived from: SDL_rotozoom, LGPL (c) A. Schiffler from the SDL_gfx library.
7 * Modifications by Stefano Stabellini.
8 *
9 * This work is licensed under the terms of the GNU GPL version 2.
10 * See the COPYING file in the top-level directory.
11 *
12 */
13
14 #if BPP == 16
15 #define SDL_TYPE Uint16
16 #elif BPP == 32
17 #define SDL_TYPE Uint32
18 #else
19 #error unsupport depth
20 #endif
21
22 /*
23 * Simple helper functions to make the code looks nicer
24 *
25 * Assume spf = source SDL_PixelFormat
26 * dpf = dest SDL_PixelFormat
27 *
28 */
29 #define getRed(color) (((color) & spf->Rmask) >> spf->Rshift)
30 #define getGreen(color) (((color) & spf->Gmask) >> spf->Gshift)
31 #define getBlue(color) (((color) & spf->Bmask) >> spf->Bshift)
32 #define getAlpha(color) (((color) & spf->Amask) >> spf->Ashift)
33
34 #define setRed(r, pcolor) do { \
35 *pcolor = ((*pcolor) & (~(dpf->Rmask))) + \
36 (((r) & (dpf->Rmask >> dpf->Rshift)) << dpf->Rshift); \
37 } while (0);
38
39 #define setGreen(g, pcolor) do { \
40 *pcolor = ((*pcolor) & (~(dpf->Gmask))) + \
41 (((g) & (dpf->Gmask >> dpf->Gshift)) << dpf->Gshift); \
42 } while (0);
43
44 #define setBlue(b, pcolor) do { \
45 *pcolor = ((*pcolor) & (~(dpf->Bmask))) + \
46 (((b) & (dpf->Bmask >> dpf->Bshift)) << dpf->Bshift); \
47 } while (0);
48
49 #define setAlpha(a, pcolor) do { \
50 *pcolor = ((*pcolor) & (~(dpf->Amask))) + \
51 (((a) & (dpf->Amask >> dpf->Ashift)) << dpf->Ashift); \
52 } while (0);
53
54 static int glue(sdl_zoom_rgb, BPP)(SDL_Surface *src, SDL_Surface *dst, int smooth,
55 SDL_Rect *dst_rect)
56 {
57 int x, y, sx, sy, *sax, *say, *csax, *csay, csx, csy, ex, ey, t1, t2, sstep, sstep_jump;
58 SDL_TYPE *c00, *c01, *c10, *c11, *sp, *csp, *dp;
59 int d_gap;
60 SDL_PixelFormat *spf = src->format;
61 SDL_PixelFormat *dpf = dst->format;
62
63 if (smooth) {
64 /* For interpolation: assume source dimension is one pixel.
65 * Smaller here to avoid overflow on right and bottom edge.
66 */
67 sx = (int) (65536.0 * (float) (src->w - 1) / (float) dst->w);
68 sy = (int) (65536.0 * (float) (src->h - 1) / (float) dst->h);
69 } else {
70 sx = (int) (65536.0 * (float) src->w / (float) dst->w);
71 sy = (int) (65536.0 * (float) src->h / (float) dst->h);
72 }
73
74 if ((sax = (int *) malloc((dst->w + 1) * sizeof(Uint32))) == NULL) {
75 return (-1);
76 }
77 if ((say = (int *) malloc((dst->h + 1) * sizeof(Uint32))) == NULL) {
78 free(sax);
79 return (-1);
80 }
81
82 sp = csp = (SDL_TYPE *) src->pixels;
83 dp = (SDL_TYPE *) (dst->pixels + dst_rect->y * dst->pitch +
84 dst_rect->x * dst->format->BytesPerPixel);
85
86 csx = 0;
87 csax = sax;
88 for (x = 0; x <= dst->w; x++) {
89 *csax = csx;
90 csax++;
91 csx &= 0xffff;
92 csx += sx;
93 }
94 csy = 0;
95 csay = say;
96 for (y = 0; y <= dst->h; y++) {
97 *csay = csy;
98 csay++;
99 csy &= 0xffff;
100 csy += sy;
101 }
102
103 d_gap = dst->pitch - dst_rect->w * dst->format->BytesPerPixel;
104
105 if (smooth) {
106 csay = say;
107 for (y = 0; y < dst_rect->y; y++) {
108 csay++;
109 sstep = (*csay >> 16) * src->pitch;
110 csp = (SDL_TYPE *) ((Uint8 *) csp + sstep);
111 }
112
113 /* Calculate sstep_jump */
114 csax = sax;
115 sstep_jump = 0;
116 for (x = 0; x < dst_rect->x; x++) {
117 csax++;
118 sstep = (*csax >> 16);
119 sstep_jump += sstep;
120 }
121
122 for (y = 0; y < dst_rect->h ; y++) {
123 /* Setup colour source pointers */
124 c00 = csp + sstep_jump;
125 c01 = c00 + 1;
126 c10 = (SDL_TYPE *) ((Uint8 *) csp + src->pitch) + sstep_jump;
127 c11 = c10 + 1;
128 csax = sax + dst_rect->x;
129
130 for (x = 0; x < dst_rect->w; x++) {
131
132 /* Interpolate colours */
133 ex = (*csax & 0xffff);
134 ey = (*csay & 0xffff);
135 t1 = ((((getRed(*c01) - getRed(*c00)) * ex) >> 16) +
136 getRed(*c00)) & (dpf->Rmask >> dpf->Rshift);
137 t2 = ((((getRed(*c11) - getRed(*c10)) * ex) >> 16) +
138 getRed(*c10)) & (dpf->Rmask >> dpf->Rshift);
139 setRed((((t2 - t1) * ey) >> 16) + t1, dp);
140 t1 = ((((getGreen(*c01) - getGreen(*c00)) * ex) >> 16) +
141 getGreen(*c00)) & (dpf->Gmask >> dpf->Gshift);
142 t2 = ((((getGreen(*c11) - getGreen(*c10)) * ex) >> 16) +
143 getGreen(*c10)) & (dpf->Gmask >> dpf->Gshift);
144 setGreen((((t2 - t1) * ey) >> 16) + t1, dp);
145 t1 = ((((getBlue(*c01) - getBlue(*c00)) * ex) >> 16) +
146 getBlue(*c00)) & (dpf->Bmask >> dpf->Bshift);
147 t2 = ((((getBlue(*c11) - getBlue(*c10)) * ex) >> 16) +
148 getBlue(*c10)) & (dpf->Bmask >> dpf->Bshift);
149 setBlue((((t2 - t1) * ey) >> 16) + t1, dp);
150 t1 = ((((getAlpha(*c01) - getAlpha(*c00)) * ex) >> 16) +
151 getAlpha(*c00)) & (dpf->Amask >> dpf->Ashift);
152 t2 = ((((getAlpha(*c11) - getAlpha(*c10)) * ex) >> 16) +
153 getAlpha(*c10)) & (dpf->Amask >> dpf->Ashift);
154 setAlpha((((t2 - t1) * ey) >> 16) + t1, dp);
155
156 /* Advance source pointers */
157 csax++;
158 sstep = (*csax >> 16);
159 c00 += sstep;
160 c01 += sstep;
161 c10 += sstep;
162 c11 += sstep;
163 /* Advance destination pointer */
164 dp++;
165 }
166 /* Advance source pointer */
167 csay++;
168 csp = (SDL_TYPE *) ((Uint8 *) csp + (*csay >> 16) * src->pitch);
169 /* Advance destination pointers */
170 dp = (SDL_TYPE *) ((Uint8 *) dp + d_gap);
171 }
172
173
174 } else {
175 csay = say;
176
177 for (y = 0; y < dst_rect->y; y++) {
178 csay++;
179 sstep = (*csay >> 16) * src->pitch;
180 csp = (SDL_TYPE *) ((Uint8 *) csp + sstep);
181 }
182
183 /* Calculate sstep_jump */
184 csax = sax;
185 sstep_jump = 0;
186 for (x = 0; x < dst_rect->x; x++) {
187 csax++;
188 sstep = (*csax >> 16);
189 sstep_jump += sstep;
190 }
191
192 for (y = 0 ; y < dst_rect->h ; y++) {
193 sp = csp + sstep_jump;
194 csax = sax + dst_rect->x;
195
196 for (x = 0; x < dst_rect->w; x++) {
197
198 /* Draw */
199 *dp = *sp;
200
201 /* Advance source pointers */
202 csax++;
203 sstep = (*csax >> 16);
204 sp += sstep;
205
206 /* Advance destination pointer */
207 dp++;
208 }
209 /* Advance source pointers */
210 csay++;
211 sstep = (*csay >> 16) * src->pitch;
212 csp = (SDL_TYPE *) ((Uint8 *) csp + sstep);
213
214 /* Advance destination pointer */
215 dp = (SDL_TYPE *) ((Uint8 *) dp + d_gap);
216 }
217 }
218
219 free(sax);
220 free(say);
221 return (0);
222 }
223
224 #undef SDL_TYPE
225