1
2 #include <SDL/SDL.h>
3 #include <SDL/SDL_image.h>
4 #include <stdlib.h>
5
6 typedef struct tColorRGBA {
7 Uint8 r;
8 Uint8 g;
9 Uint8 b;
10 Uint8 a;
11 } tColorRGBA;
12
13
14 #define ZOOM_VALUE_LIMIT 0.0001
15
zoomSurface(SDL_Surface * src,double zoomx,double zoomy)16 SDL_Surface *zoomSurface(SDL_Surface * src, double zoomx, double zoomy)
17 {
18 SDL_Surface *rz_src;
19 SDL_Surface *rz_dst;
20 int dstwidth, dstheight;
21 int is32bit;
22 int i, src_converted;
23 int flipx, flipy;
24
25 /*
26 * Sanity check
27 */
28 if (src == NULL)
29 return (NULL);
30
31 /*
32 * Determine if source surface is 32bit or 8bit
33 */
34 is32bit = (src->format->BitsPerPixel == 32);
35 if ((is32bit) || (src->format->BitsPerPixel == 8)) {
36 /*
37 * Use source surface 'as is'
38 */
39 rz_src = src;
40 src_converted = 0;
41 } else {
42 /*
43 * New source surface is 32bit with a defined RGBA ordering
44 */
45 rz_src =
46 SDL_CreateRGBSurface(SDL_SWSURFACE, src->w, src->h, 32, 0x000000ff, 0x0000ff00, 0x00ff0000, 0xff000000);
47 SDL_BlitSurface(src, NULL, rz_src, NULL);
48 src_converted = 1;
49 is32bit = 1;
50 }
51
52 flipx = (zoomx<0);
53 if (flipx) zoomx = -zoomx;
54 flipy = (zoomy<0);
55 if (flipy) zoomy = -zoomy;
56
57 /* Get size if target */
58 /*
59 * Sanity check zoom factors
60 */
61 if (zoomx < ZOOM_VALUE_LIMIT) {
62 zoomx = ZOOM_VALUE_LIMIT;
63 }
64 if (zoomy < ZOOM_VALUE_LIMIT) {
65 zoomy = ZOOM_VALUE_LIMIT;
66 }
67
68 /*
69 * Calculate target size
70 */
71 dstwidth = (int) ((double) rz_src->w * zoomx);
72 dstheight = (int) ((double) rz_src->h * zoomy);
73 if (dstwidth < 1) {
74 dstwidth = 1;
75 }
76 if (dstheight < 1) {
77 dstheight = 1;
78 }
79
80
81
82 /*
83 * Alloc space to completely contain the zoomed surface
84 */
85 rz_dst = NULL;
86 if (is32bit) {
87 /*
88 * Target surface is 32bit with source RGBA/ABGR ordering
89 */
90 rz_dst =
91 SDL_CreateRGBSurface(SDL_SWSURFACE, dstwidth, dstheight, 32,
92 rz_src->format->Rmask, rz_src->format->Gmask,
93 rz_src->format->Bmask, rz_src->format->Amask);
94 } else {
95 /*
96 * Target surface is 8bit
97 */
98 rz_dst = SDL_CreateRGBSurface(SDL_SWSURFACE, dstwidth, dstheight, 8, 0, 0, 0, 0);
99 }
100
101 /*
102 * Lock source surface
103 */
104 SDL_LockSurface(rz_src);
105 /*
106 * Check which kind of surface we have
107 */
108 if (is32bit) {
109 /*
110 * Call the 32bit transformation routine to do the zooming (using alpha)
111 */
112 // zoomSurfaceRGBA(rz_src, rz_dst, flipx, flipy);
113
114 int x, y, sx, sy, *sax, *say, *csax, *csay, csx, csy, ex, ey, t1, t2, sstep;
115 tColorRGBA *c00, *c01, *c10, *c11;
116 tColorRGBA *sp, *csp, *dp;
117 int dgap;
118
119 /*
120 * For interpolation: assume source dimension is one pixel
121 */
122 /*
123 * smaller to avoid overflow on right and bottom edge.
124 */
125 sx = (int) (65536.0 * (float) (src->w - 1) / (float) rz_dst->w);
126 sy = (int) (65536.0 * (float) (src->h - 1) / (float) rz_dst->h);
127
128
129 /*
130 * Allocate memory for row increments
131 */
132 if ((sax = (int *) malloc((rz_dst->w + 1) * sizeof(Uint32))) == NULL) {
133 return NULL;
134 }
135 if ((say = (int *) malloc((rz_dst->h + 1) * sizeof(Uint32))) == NULL) {
136 free(sax);
137 return NULL;
138 }
139
140 /*
141 * Precalculate row increments
142 */
143 sp = csp = (tColorRGBA *) rz_src->pixels;
144 dp = (tColorRGBA *) rz_dst->pixels;
145
146 if (flipx) csp += (rz_src->w-1);
147 if (flipy) csp = (tColorRGBA*)( (Uint8*)csp + rz_src->pitch*(src->h-1) );
148
149 csx = 0;
150 csax = sax;
151 for (x = 0; x <= rz_dst->w; x++) {
152 *csax = csx;
153 csax++;
154 csx &= 0xffff;
155 csx += sx;
156 }
157 csy = 0;
158 csay = say;
159 for (y = 0; y <= rz_dst->h; y++) {
160 *csay = csy;
161 csay++;
162 csy &= 0xffff;
163 csy += sy;
164 }
165
166 dgap = rz_dst->pitch - rz_dst->w * 4;
167
168 /*
169 * Interpolating Zoom
170 */
171
172 /*
173 * Scan destination
174 */
175 csay = say;
176 for (y = 0; y < rz_dst->h; y++) {
177 /*
178 * Setup color source pointers
179 */
180 c00 = csp;
181 c01 = csp;
182 c01++;
183 c10 = (tColorRGBA *) ((Uint8 *) csp + rz_src->pitch);
184 c11 = c10;
185 c11++;
186 csax = sax;
187 for (x = 0; x < rz_dst->w; x++) {
188
189 /*
190 * Interpolate colors
191 */
192 ex = (*csax & 0xffff);
193 ey = (*csay & 0xffff);
194 t1 = ((((c01->r - c00->r) * ex) >> 16) + c00->r) & 0xff;
195 t2 = ((((c11->r - c10->r) * ex) >> 16) + c10->r) & 0xff;
196 dp->r = (((t2 - t1) * ey) >> 16) + t1;
197 t1 = ((((c01->g - c00->g) * ex) >> 16) + c00->g) & 0xff;
198 t2 = ((((c11->g - c10->g) * ex) >> 16) + c10->g) & 0xff;
199 dp->g = (((t2 - t1) * ey) >> 16) + t1;
200 t1 = ((((c01->b - c00->b) * ex) >> 16) + c00->b) & 0xff;
201 t2 = ((((c11->b - c10->b) * ex) >> 16) + c10->b) & 0xff;
202 dp->b = (((t2 - t1) * ey) >> 16) + t1;
203 t1 = ((((c01->a - c00->a) * ex) >> 16) + c00->a) & 0xff;
204 t2 = ((((c11->a - c10->a) * ex) >> 16) + c10->a) & 0xff;
205 dp->a = (((t2 - t1) * ey) >> 16) + t1;
206
207 /*
208 * Advance source pointers
209 */
210 csax++;
211 sstep = (*csax >> 16);
212 c00 += sstep;
213 c01 += sstep;
214 c10 += sstep;
215 c11 += sstep;
216 /*
217 * Advance destination pointer
218 */
219 dp++;
220 }
221 /*
222 * Advance source pointer
223 */
224 csay++;
225 csp = (tColorRGBA *) ((Uint8 *) csp + (*csay >> 16) * rz_src->pitch);
226 /*
227 * Advance destination pointers
228 */
229 dp = (tColorRGBA *) ((Uint8 *) dp + dgap);
230 }
231
232 /*
233 * Remove temp arrays
234 */
235 free(sax);
236 free(say);
237
238
239
240
241
242 /*
243 * Turn on source-alpha support
244 */
245 SDL_SetAlpha(rz_dst, SDL_SRCALPHA, 255);
246 } else {
247 /*
248 * Copy palette and colorkey info
249 */
250 for (i = 0; i < rz_src->format->palette->ncolors; i++) {
251 rz_dst->format->palette->colors[i] = rz_src->format->palette->colors[i];
252 }
253 rz_dst->format->palette->ncolors = rz_src->format->palette->ncolors;
254 /*
255 * Call the 8bit transformation routine to do the zooming
256 */
257 Uint32 x, y, sx, sy, *sax, *say, *csax, *csay, csx, csy;
258 Uint8 *sp, *dp, *csp;
259 int dgap;
260
261 /*
262 * Variable setup
263 */
264 sx = (Uint32) (65536.0 * (float) rz_src->w / (float) rz_dst->w);
265 sy = (Uint32) (65536.0 * (float) rz_src->h / (float) rz_dst->h);
266
267 /*
268 * Allocate memory for row increments
269 */
270 if ((sax = (Uint32 *) malloc(rz_dst->w * sizeof(Uint32))) == NULL) {
271 return NULL;
272 }
273 if ((say = (Uint32 *) malloc(rz_dst->h * sizeof(Uint32))) == NULL) {
274 if (sax != NULL) {
275 free(sax);
276 }
277 return NULL;
278 }
279
280 /*
281 * Precalculate row increments
282 */
283 csx = 0;
284 csax = sax;
285 for (x = 0; x < rz_dst->w; x++) {
286 csx += sx;
287 *csax = (csx >> 16);
288 csx &= 0xffff;
289 csax++;
290 }
291 csy = 0;
292 csay = say;
293 for (y = 0; y < rz_dst->h; y++) {
294 csy += sy;
295 *csay = (csy >> 16);
296 csy &= 0xffff;
297 csay++;
298 }
299
300 csx = 0;
301 csax = sax;
302 for (x = 0; x < rz_dst->w; x++) {
303 csx += (*csax);
304 csax++;
305 }
306 csy = 0;
307 csay = say;
308 for (y = 0; y < rz_dst->h; y++) {
309 csy += (*csay);
310 csay++;
311 }
312
313 /*
314 * Pointer setup
315 */
316 sp = csp = (Uint8 *) rz_src->pixels;
317 dp = (Uint8 *) rz_dst->pixels;
318 dgap = rz_dst->pitch - rz_dst->w;
319
320 /*
321 * Draw
322 */
323 csay = say;
324 for (y = 0; y < rz_dst->h; y++) {
325 csax = sax;
326 sp = csp;
327 for (x = 0; x < rz_dst->w; x++) {
328 /*
329 * Draw
330 */
331 *dp = *sp;
332 /*
333 * Advance source pointers
334 */
335 sp += (*csax);
336 csax++;
337 /*
338 * Advance destination pointer
339 */
340 dp++;
341 }
342 /*
343 * Advance source pointer (for row)
344 */
345 csp += ((*csay) * src->pitch);
346 csay++;
347 /*
348 * Advance destination pointers
349 */
350 dp += dgap;
351 }
352
353 /*
354 * Remove temp arrays
355 */
356 free(sax);
357 free(say);
358
359
360 SDL_SetColorKey(rz_dst, SDL_SRCCOLORKEY | SDL_RLEACCEL, rz_src->format->colorkey);
361 }
362 /*
363 * Unlock source surface
364 */
365 SDL_UnlockSurface(rz_src);
366
367 /*
368 * Cleanup temp surface
369 */
370 if (src_converted) {
371 SDL_FreeSurface(rz_src);
372 }
373
374 /*
375 * Return destination surface
376 */
377 return (rz_dst);
378 }
379