|
0
|
1 /*
|
|
|
2 SDL - Simple DirectMedia Layer
|
|
|
3 Copyright (C) 1997, 1998, 1999, 2000, 2001 Sam Lantinga
|
|
|
4
|
|
|
5 This library is free software; you can redistribute it and/or
|
|
|
6 modify it under the terms of the GNU Library General Public
|
|
|
7 License as published by the Free Software Foundation; either
|
|
|
8 version 2 of the License, or (at your option) any later version.
|
|
|
9
|
|
|
10 This library is distributed in the hope that it will be useful,
|
|
|
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
|
13 Library General Public License for more details.
|
|
|
14
|
|
|
15 You should have received a copy of the GNU Library General Public
|
|
|
16 License along with this library; if not, write to the Free
|
|
|
17 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
|
18
|
|
|
19 Sam Lantinga
|
|
|
20 slouken@devolution.com
|
|
|
21 */
|
|
|
22
|
|
|
23 #ifdef SAVE_RCSID
|
|
|
24 static char rcsid =
|
|
|
25 "@(#) $Id$";
|
|
|
26 #endif
|
|
|
27
|
|
|
28 /*
|
|
|
29 * RLE encoding for software colorkey and alpha-channel acceleration
|
|
|
30 *
|
|
|
31 * Original version by Sam Lantinga
|
|
|
32 *
|
|
|
33 * Mattias Engdegård (Yorick): Rewrite. New encoding format, encoder and
|
|
|
34 * decoder. Added per-surface alpha blitter. Added per-pixel alpha
|
|
|
35 * format, encoder and blitter.
|
|
|
36 *
|
|
|
37 * Many thanks to Xark and johns for hints, benchmarks and useful comments
|
|
|
38 * leading to this code.
|
|
|
39 *
|
|
|
40 * Welcome to Macro Mayhem.
|
|
|
41 */
|
|
|
42
|
|
|
43 /*
|
|
|
44 * The encoding translates the image data to a stream of segments of the form
|
|
|
45 *
|
|
|
46 * <skip> <run> <data>
|
|
|
47 *
|
|
|
48 * where <skip> is the number of transparent pixels to skip,
|
|
|
49 * <run> is the number of opaque pixels to blit,
|
|
|
50 * and <data> are the pixels themselves.
|
|
|
51 *
|
|
|
52 * This basic structure is used both for colorkeyed surfaces, used for simple
|
|
|
53 * binary transparency and for per-surface alpha blending, and for surfaces
|
|
|
54 * with per-pixel alpha. The details differ, however:
|
|
|
55 *
|
|
|
56 * Encoding of colorkeyed surfaces:
|
|
|
57 *
|
|
|
58 * Encoded pixels always have the same format as the target surface.
|
|
|
59 * <skip> and <run> are unsigned 8 bit integers, except for 32 bit depth
|
|
|
60 * where they are 16 bit. This makes the pixel data aligned at all times.
|
|
|
61 * Segments never wrap around from one scan line to the next.
|
|
|
62 *
|
|
|
63 * The end of the sequence is marked by a zero <skip>,<run> pair at the *
|
|
|
64 * beginning of a line.
|
|
|
65 *
|
|
|
66 * Encoding of surfaces with per-pixel alpha:
|
|
|
67 *
|
|
|
68 * The sequence begins with a struct RLEDestFormat describing the target
|
|
|
69 * pixel format, to provide reliable un-encoding.
|
|
|
70 *
|
|
|
71 * Each scan line is encoded twice: First all completely opaque pixels,
|
|
|
72 * encoded in the target format as described above, and then all
|
|
|
73 * partially transparent (translucent) pixels (where 1 <= alpha <= 254),
|
|
|
74 * in the following 32-bit format:
|
|
|
75 *
|
|
|
76 * For 32-bit targets, each pixel has the target RGB format but with
|
|
|
77 * the alpha value occupying the highest 8 bits. The <skip> and <run>
|
|
|
78 * counts are 16 bit.
|
|
|
79 *
|
|
|
80 * For 16-bit targets, each pixel has the target RGB format, but with
|
|
|
81 * the middle component (usually green) shifted 16 steps to the left,
|
|
|
82 * and the hole filled with the 5 most significant bits of the alpha value.
|
|
|
83 * i.e. if the target has the format rrrrrggggggbbbbb,
|
|
|
84 * the encoded pixel will be 00000gggggg00000rrrrr0aaaaabbbbb.
|
|
|
85 * The <skip> and <run> counts are 8 bit for the opaque lines, 16 bit
|
|
|
86 * for the translucent lines. Two padding bytes may be inserted
|
|
|
87 * before each translucent line to keep them 32-bit aligned.
|
|
|
88 *
|
|
|
89 * The end of the sequence is marked by a zero <skip>,<run> pair at the
|
|
|
90 * beginning of an opaque line.
|
|
|
91 */
|
|
|
92
|
|
|
93 #include <stdio.h>
|
|
|
94 #include <stdlib.h>
|
|
|
95 #include <string.h>
|
|
|
96
|
|
|
97 #include "SDL_types.h"
|
|
|
98 #include "SDL_video.h"
|
|
|
99 #include "SDL_error.h"
|
|
|
100 #include "SDL_sysvideo.h"
|
|
|
101 #include "SDL_blit.h"
|
|
|
102 #include "SDL_memops.h"
|
|
|
103 #include "SDL_RLEaccel_c.h"
|
|
|
104
|
|
|
105 #ifndef MAX
|
|
|
106 #define MAX(a, b) ((a) > (b) ? (a) : (b))
|
|
|
107 #endif
|
|
|
108 #ifndef MIN
|
|
|
109 #define MIN(a, b) ((a) < (b) ? (a) : (b))
|
|
|
110 #endif
|
|
|
111
|
|
|
112 /*
|
|
|
113 * Various colorkey blit methods, for opaque and per-surface alpha
|
|
|
114 */
|
|
|
115
|
|
|
116 #define OPAQUE_BLIT(to, from, length, bpp, alpha) \
|
|
|
117 SDL_memcpy(to, from, (unsigned)(length * bpp))
|
|
|
118
|
|
|
119 /*
|
|
|
120 * For 32bpp pixels on the form 0x00rrggbb:
|
|
|
121 * If we treat the middle component separately, we can process the two
|
|
|
122 * remaining in parallel. This is safe to do because of the gap to the left
|
|
|
123 * of each component, so the bits from the multiplication don't collide.
|
|
|
124 * This can be used for any RGB permutation of course.
|
|
|
125 */
|
|
|
126 #define ALPHA_BLIT32_888(to, from, length, bpp, alpha) \
|
|
|
127 do { \
|
|
|
128 int i; \
|
|
|
129 Uint32 *src = (Uint32 *)(from); \
|
|
|
130 Uint32 *dst = (Uint32 *)(to); \
|
|
|
131 for(i = 0; i < (int)(length); i++) { \
|
|
|
132 Uint32 s = *src++; \
|
|
|
133 Uint32 d = *dst; \
|
|
|
134 Uint32 s1 = s & 0xff00ff; \
|
|
|
135 Uint32 d1 = d & 0xff00ff; \
|
|
|
136 d1 = (d1 + ((s1 - d1) * alpha >> 8)) & 0xff00ff; \
|
|
|
137 s &= 0xff00; \
|
|
|
138 d &= 0xff00; \
|
|
|
139 d = (d + ((s - d) * alpha >> 8)) & 0xff00; \
|
|
|
140 *dst++ = d1 | d; \
|
|
|
141 } \
|
|
|
142 } while(0)
|
|
|
143
|
|
|
144 /*
|
|
|
145 * For 16bpp pixels we can go a step further: put the middle component
|
|
|
146 * in the high 16 bits of a 32 bit word, and process all three RGB
|
|
|
147 * components at the same time. Since the smallest gap is here just
|
|
|
148 * 5 bits, we have to scale alpha down to 5 bits as well.
|
|
|
149 */
|
|
|
150 #define ALPHA_BLIT16_565(to, from, length, bpp, alpha) \
|
|
|
151 do { \
|
|
|
152 int i; \
|
|
|
153 Uint16 *src = (Uint16 *)(from); \
|
|
|
154 Uint16 *dst = (Uint16 *)(to); \
|
|
|
155 for(i = 0; i < (int)(length); i++) { \
|
|
|
156 Uint32 s = *src++; \
|
|
|
157 Uint32 d = *dst; \
|
|
|
158 s = (s | s << 16) & 0x07e0f81f; \
|
|
|
159 d = (d | d << 16) & 0x07e0f81f; \
|
|
|
160 d += (s - d) * alpha >> 5; \
|
|
|
161 d &= 0x07e0f81f; \
|
|
|
162 *dst++ = d | d >> 16; \
|
|
|
163 } \
|
|
|
164 } while(0)
|
|
|
165
|
|
|
166 #define ALPHA_BLIT16_555(to, from, length, bpp, alpha) \
|
|
|
167 do { \
|
|
|
168 int i; \
|
|
|
169 Uint16 *src = (Uint16 *)(from); \
|
|
|
170 Uint16 *dst = (Uint16 *)(to); \
|
|
|
171 for(i = 0; i < (int)(length); i++) { \
|
|
|
172 Uint32 s = *src++; \
|
|
|
173 Uint32 d = *dst; \
|
|
|
174 s = (s | s << 16) & 0x03e07c1f; \
|
|
|
175 d = (d | d << 16) & 0x03e07c1f; \
|
|
|
176 d += (s - d) * alpha >> 5; \
|
|
|
177 d &= 0x03e07c1f; \
|
|
|
178 *dst++ = d | d >> 16; \
|
|
|
179 } \
|
|
|
180 } while(0)
|
|
|
181
|
|
|
182 /*
|
|
|
183 * The general slow catch-all function, for remaining depths and formats
|
|
|
184 */
|
|
|
185 #define ALPHA_BLIT_ANY(to, from, length, bpp, alpha) \
|
|
|
186 do { \
|
|
|
187 int i; \
|
|
|
188 Uint8 *src = from; \
|
|
|
189 Uint8 *dst = to; \
|
|
|
190 for(i = 0; i < (int)(length); i++) { \
|
|
|
191 Uint32 s, d; \
|
|
|
192 unsigned rs, gs, bs, rd, gd, bd; \
|
|
|
193 switch(bpp) { \
|
|
|
194 case 2: \
|
|
|
195 s = *(Uint16 *)src; \
|
|
|
196 d = *(Uint16 *)dst; \
|
|
|
197 break; \
|
|
|
198 case 3: \
|
|
|
199 if(SDL_BYTEORDER == SDL_BIG_ENDIAN) { \
|
|
|
200 s = (src[0] << 16) | (src[1] << 8) | src[2]; \
|
|
|
201 d = (dst[0] << 16) | (dst[1] << 8) | dst[2]; \
|
|
|
202 } else { \
|
|
|
203 s = (src[2] << 16) | (src[1] << 8) | src[0]; \
|
|
|
204 d = (dst[2] << 16) | (dst[1] << 8) | dst[0]; \
|
|
|
205 } \
|
|
|
206 break; \
|
|
|
207 case 4: \
|
|
|
208 s = *(Uint32 *)src; \
|
|
|
209 d = *(Uint32 *)dst; \
|
|
|
210 break; \
|
|
|
211 } \
|
|
|
212 RGB_FROM_PIXEL(s, fmt, rs, gs, bs); \
|
|
|
213 RGB_FROM_PIXEL(d, fmt, rd, gd, bd); \
|
|
|
214 rd += (rs - rd) * alpha >> 8; \
|
|
|
215 gd += (gs - gd) * alpha >> 8; \
|
|
|
216 bd += (bs - bd) * alpha >> 8; \
|
|
|
217 PIXEL_FROM_RGB(d, fmt, rd, gd, bd); \
|
|
|
218 switch(bpp) { \
|
|
|
219 case 2: \
|
|
|
220 *(Uint16 *)dst = d; \
|
|
|
221 break; \
|
|
|
222 case 3: \
|
|
|
223 if(SDL_BYTEORDER == SDL_BIG_ENDIAN) { \
|
|
|
224 dst[0] = d >> 16; \
|
|
|
225 dst[1] = d >> 8; \
|
|
|
226 dst[2] = d; \
|
|
|
227 } else { \
|
|
|
228 dst[0] = d; \
|
|
|
229 dst[1] = d >> 8; \
|
|
|
230 dst[2] = d >> 16; \
|
|
|
231 } \
|
|
|
232 break; \
|
|
|
233 case 4: \
|
|
|
234 *(Uint32 *)dst = d; \
|
|
|
235 break; \
|
|
|
236 } \
|
|
|
237 src += bpp; \
|
|
|
238 dst += bpp; \
|
|
|
239 } \
|
|
|
240 } while(0)
|
|
|
241
|
|
|
242
|
|
|
243 /*
|
|
|
244 * Special case: 50% alpha (alpha=128)
|
|
|
245 * This is treated specially because it can be optimized very well, and
|
|
|
246 * since it is good for many cases of semi-translucency.
|
|
|
247 * The theory is to do all three components at the same time:
|
|
|
248 * First zero the lowest bit of each component, which gives us room to
|
|
|
249 * add them. Then shift right and add the sum of the lowest bits.
|
|
|
250 */
|
|
|
251 #define ALPHA_BLIT32_888_50(to, from, length, bpp, alpha) \
|
|
|
252 do { \
|
|
|
253 int i; \
|
|
|
254 Uint32 *src = (Uint32 *)(from); \
|
|
|
255 Uint32 *dst = (Uint32 *)(to); \
|
|
|
256 for(i = 0; i < (int)(length); i++) { \
|
|
|
257 Uint32 s = *src++; \
|
|
|
258 Uint32 d = *dst; \
|
|
|
259 *dst++ = (((s & 0x00fefefe) + (d & 0x00fefefe)) >> 1) \
|
|
|
260 + (s & d & 0x00010101); \
|
|
|
261 } \
|
|
|
262 } while(0)
|
|
|
263
|
|
|
264 /*
|
|
|
265 * For 16bpp, we can actually blend two pixels in parallel, if we take
|
|
|
266 * care to shift before we add, not after.
|
|
|
267 */
|
|
|
268
|
|
|
269 /* helper: blend a single 16 bit pixel at 50% */
|
|
|
270 #define BLEND16_50(dst, src, mask) \
|
|
|
271 do { \
|
|
|
272 Uint32 s = *src++; \
|
|
|
273 Uint32 d = *dst; \
|
|
|
274 *dst++ = (((s & mask) + (d & mask)) >> 1) \
|
|
|
275 + (s & d & (~mask & 0xffff)); \
|
|
|
276 } while(0)
|
|
|
277
|
|
|
278 /* basic 16bpp blender. mask is the pixels to keep when adding. */
|
|
|
279 #define ALPHA_BLIT16_50(to, from, length, bpp, alpha, mask) \
|
|
|
280 do { \
|
|
|
281 unsigned n = (length); \
|
|
|
282 Uint16 *src = (Uint16 *)(from); \
|
|
|
283 Uint16 *dst = (Uint16 *)(to); \
|
|
|
284 if(((unsigned long)src ^ (unsigned long)dst) & 3) { \
|
|
|
285 /* source and destination not in phase, blit one by one */ \
|
|
|
286 while(n--) \
|
|
|
287 BLEND16_50(dst, src, mask); \
|
|
|
288 } else { \
|
|
|
289 if((unsigned long)src & 3) { \
|
|
|
290 /* first odd pixel */ \
|
|
|
291 BLEND16_50(dst, src, mask); \
|
|
|
292 n--; \
|
|
|
293 } \
|
|
|
294 for(; n > 1; n -= 2) { \
|
|
|
295 Uint32 s = *(Uint32 *)src; \
|
|
|
296 Uint32 d = *(Uint32 *)dst; \
|
|
|
297 *(Uint32 *)dst = ((s & (mask | mask << 16)) >> 1) \
|
|
|
298 + ((d & (mask | mask << 16)) >> 1) \
|
|
|
299 + (s & d & (~(mask | mask << 16))); \
|
|
|
300 src += 2; \
|
|
|
301 dst += 2; \
|
|
|
302 } \
|
|
|
303 if(n) \
|
|
|
304 BLEND16_50(dst, src, mask); /* last odd pixel */ \
|
|
|
305 } \
|
|
|
306 } while(0)
|
|
|
307
|
|
|
308 #define ALPHA_BLIT16_565_50(to, from, length, bpp, alpha) \
|
|
|
309 ALPHA_BLIT16_50(to, from, length, bpp, alpha, 0xf7de)
|
|
|
310
|
|
|
311 #define ALPHA_BLIT16_555_50(to, from, length, bpp, alpha) \
|
|
|
312 ALPHA_BLIT16_50(to, from, length, bpp, alpha, 0xfbde)
|
|
|
313
|
|
|
314
|
|
|
315 #define CHOOSE_BLIT(blitter, alpha, fmt) \
|
|
|
316 do { \
|
|
|
317 if(alpha == 255) { \
|
|
|
318 switch(fmt->BytesPerPixel) { \
|
|
|
319 case 1: blitter(1, Uint8, OPAQUE_BLIT); break; \
|
|
|
320 case 2: blitter(2, Uint8, OPAQUE_BLIT); break; \
|
|
|
321 case 3: blitter(3, Uint8, OPAQUE_BLIT); break; \
|
|
|
322 case 4: blitter(4, Uint16, OPAQUE_BLIT); break; \
|
|
|
323 } \
|
|
|
324 } else { \
|
|
|
325 switch(fmt->BytesPerPixel) { \
|
|
|
326 case 1: \
|
|
|
327 /* No 8bpp alpha blitting */ \
|
|
|
328 break; \
|
|
|
329 \
|
|
|
330 case 2: \
|
|
|
331 switch(fmt->Rmask | fmt->Gmask | fmt->Bmask) { \
|
|
|
332 case 0xffff: \
|
|
|
333 if(fmt->Gmask == 0x07e0 \
|
|
|
334 || fmt->Rmask == 0x07e0 \
|
|
|
335 || fmt->Bmask == 0x07e0) { \
|
|
|
336 if(alpha == 128) \
|
|
|
337 blitter(2, Uint8, ALPHA_BLIT16_565_50); \
|
|
|
338 else { \
|
|
|
339 alpha >>= 3; /* use 5 bit alpha */ \
|
|
|
340 blitter(2, Uint8, ALPHA_BLIT16_565); \
|
|
|
341 } \
|
|
|
342 } else \
|
|
|
343 goto general16; \
|
|
|
344 break; \
|
|
|
345 \
|
|
|
346 case 0x7fff: \
|
|
|
347 if(fmt->Gmask == 0x03e0 \
|
|
|
348 || fmt->Rmask == 0x03e0 \
|
|
|
349 || fmt->Bmask == 0x03e0) { \
|
|
|
350 if(alpha == 128) \
|
|
|
351 blitter(2, Uint8, ALPHA_BLIT16_555_50); \
|
|
|
352 else { \
|
|
|
353 alpha >>= 3; /* use 5 bit alpha */ \
|
|
|
354 blitter(2, Uint8, ALPHA_BLIT16_555); \
|
|
|
355 } \
|
|
|
356 break; \
|
|
|
357 } \
|
|
|
358 /* fallthrough */ \
|
|
|
359 \
|
|
|
360 default: \
|
|
|
361 general16: \
|
|
|
362 blitter(2, Uint8, ALPHA_BLIT_ANY); \
|
|
|
363 } \
|
|
|
364 break; \
|
|
|
365 \
|
|
|
366 case 3: \
|
|
|
367 blitter(3, Uint8, ALPHA_BLIT_ANY); \
|
|
|
368 break; \
|
|
|
369 \
|
|
|
370 case 4: \
|
|
|
371 if((fmt->Rmask | fmt->Gmask | fmt->Bmask) == 0x00ffffff \
|
|
|
372 && (fmt->Gmask == 0xff00 || fmt->Rmask == 0xff00 \
|
|
|
373 || fmt->Bmask == 0xff00)) { \
|
|
|
374 if(alpha == 128) \
|
|
|
375 blitter(4, Uint16, ALPHA_BLIT32_888_50); \
|
|
|
376 else \
|
|
|
377 blitter(4, Uint16, ALPHA_BLIT32_888); \
|
|
|
378 } else \
|
|
|
379 blitter(4, Uint16, ALPHA_BLIT_ANY); \
|
|
|
380 break; \
|
|
|
381 } \
|
|
|
382 } \
|
|
|
383 } while(0)
|
|
|
384
|
|
|
385
|
|
|
386 /*
|
|
|
387 * This takes care of the case when the surface is clipped on the left and/or
|
|
|
388 * right. Top clipping has already been taken care of.
|
|
|
389 */
|
|
|
390 static void RLEClipBlit(int w, Uint8 *srcbuf, SDL_Surface *dst,
|
|
|
391 Uint8 *dstbuf, SDL_Rect *srcrect, unsigned alpha)
|
|
|
392 {
|
|
|
393 SDL_PixelFormat *fmt = dst->format;
|
|
|
394
|
|
|
395 #define RLECLIPBLIT(bpp, Type, do_blit) \
|
|
|
396 do { \
|
|
|
397 int linecount = srcrect->h; \
|
|
|
398 int ofs = 0; \
|
|
|
399 int left = srcrect->x; \
|
|
|
400 int right = left + srcrect->w; \
|
|
|
401 dstbuf -= left * bpp; \
|
|
|
402 for(;;) { \
|
|
|
403 int run; \
|
|
|
404 ofs += *(Type *)srcbuf; \
|
|
|
405 run = ((Type *)srcbuf)[1]; \
|
|
|
406 srcbuf += 2 * sizeof(Type); \
|
|
|
407 if(run) { \
|
|
|
408 /* clip to left and right borders */ \
|
|
|
409 if(ofs < right) { \
|
|
|
410 int start = 0; \
|
|
|
411 int len = run; \
|
|
|
412 int startcol; \
|
|
|
413 if(left - ofs > 0) { \
|
|
|
414 start = left - ofs; \
|
|
|
415 len -= start; \
|
|
|
416 if(len <= 0) \
|
|
|
417 goto nocopy ## bpp ## do_blit; \
|
|
|
418 } \
|
|
|
419 startcol = ofs + start; \
|
|
|
420 if(len > right - startcol) \
|
|
|
421 len = right - startcol; \
|
|
|
422 do_blit(dstbuf + startcol * bpp, srcbuf + start * bpp, \
|
|
|
423 len, bpp, alpha); \
|
|
|
424 } \
|
|
|
425 nocopy ## bpp ## do_blit: \
|
|
|
426 srcbuf += run * bpp; \
|
|
|
427 ofs += run; \
|
|
|
428 } else if(!ofs) \
|
|
|
429 break; \
|
|
|
430 if(ofs == w) { \
|
|
|
431 ofs = 0; \
|
|
|
432 dstbuf += dst->pitch; \
|
|
|
433 if(!--linecount) \
|
|
|
434 break; \
|
|
|
435 } \
|
|
|
436 } \
|
|
|
437 } while(0)
|
|
|
438
|
|
|
439 CHOOSE_BLIT(RLECLIPBLIT, alpha, fmt);
|
|
|
440
|
|
|
441 #undef RLECLIPBLIT
|
|
|
442
|
|
|
443 }
|
|
|
444
|
|
|
445
|
|
|
446 /* blit a colorkeyed RLE surface */
|
|
|
447 int SDL_RLEBlit(SDL_Surface *src, SDL_Rect *srcrect,
|
|
|
448 SDL_Surface *dst, SDL_Rect *dstrect)
|
|
|
449 {
|
|
|
450 Uint8 *dstbuf;
|
|
|
451 Uint8 *srcbuf;
|
|
|
452 int x, y;
|
|
|
453 int w = src->w;
|
|
|
454 unsigned alpha;
|
|
|
455
|
|
|
456 /* Lock the destination if necessary */
|
|
|
457 if ( dst->flags & (SDL_HWSURFACE|SDL_ASYNCBLIT) ) {
|
|
|
458 SDL_VideoDevice *video = current_video;
|
|
|
459 SDL_VideoDevice *this = current_video;
|
|
|
460 if ( video->LockHWSurface(this, dst) < 0 ) {
|
|
|
461 return(-1);
|
|
|
462 }
|
|
|
463 }
|
|
|
464
|
|
|
465 /* Set up the source and destination pointers */
|
|
|
466 x = dstrect->x;
|
|
|
467 y = dstrect->y;
|
|
|
468 dstbuf = (Uint8 *)dst->pixels + dst->offset
|
|
|
469 + y * dst->pitch + x * src->format->BytesPerPixel;
|
|
|
470 srcbuf = (Uint8 *)src->map->sw_data->aux_data;
|
|
|
471
|
|
|
472 {
|
|
|
473 /* skip lines at the top if neccessary */
|
|
|
474 int vskip = srcrect->y;
|
|
|
475 int ofs = 0;
|
|
|
476 if(vskip) {
|
|
|
477
|
|
|
478 #define RLESKIP(bpp, Type) \
|
|
|
479 for(;;) { \
|
|
|
480 int run; \
|
|
|
481 ofs += *(Type *)srcbuf; \
|
|
|
482 run = ((Type *)srcbuf)[1]; \
|
|
|
483 srcbuf += sizeof(Type) * 2; \
|
|
|
484 if(run) { \
|
|
|
485 srcbuf += run * bpp; \
|
|
|
486 ofs += run; \
|
|
|
487 } else if(!ofs) \
|
|
|
488 goto done; \
|
|
|
489 if(ofs == w) { \
|
|
|
490 ofs = 0; \
|
|
|
491 if(!--vskip) \
|
|
|
492 break; \
|
|
|
493 } \
|
|
|
494 }
|
|
|
495
|
|
|
496 switch(src->format->BytesPerPixel) {
|
|
|
497 case 1: RLESKIP(1, Uint8); break;
|
|
|
498 case 2: RLESKIP(2, Uint8); break;
|
|
|
499 case 3: RLESKIP(3, Uint8); break;
|
|
|
500 case 4: RLESKIP(4, Uint16); break;
|
|
|
501 }
|
|
|
502
|
|
|
503 #undef RLESKIP
|
|
|
504
|
|
|
505 }
|
|
|
506 }
|
|
|
507
|
|
|
508 alpha = (src->flags & SDL_SRCALPHA) == SDL_SRCALPHA
|
|
|
509 ? src->format->alpha : 255;
|
|
|
510 /* if left or right edge clipping needed, call clip blit */
|
|
|
511 if ( srcrect->x || srcrect->w != src->w ) {
|
|
|
512 RLEClipBlit(w, srcbuf, dst, dstbuf, srcrect, alpha);
|
|
|
513 } else {
|
|
|
514 SDL_PixelFormat *fmt = src->format;
|
|
|
515
|
|
|
516 #define RLEBLIT(bpp, Type, do_blit) \
|
|
|
517 do { \
|
|
|
518 int linecount = srcrect->h; \
|
|
|
519 int ofs = 0; \
|
|
|
520 for(;;) { \
|
|
|
521 unsigned run; \
|
|
|
522 ofs += *(Type *)srcbuf; \
|
|
|
523 run = ((Type *)srcbuf)[1]; \
|
|
|
524 srcbuf += 2 * sizeof(Type); \
|
|
|
525 if(run) { \
|
|
|
526 do_blit(dstbuf + ofs * bpp, srcbuf, run, bpp, alpha); \
|
|
|
527 srcbuf += run * bpp; \
|
|
|
528 ofs += run; \
|
|
|
529 } else if(!ofs) \
|
|
|
530 break; \
|
|
|
531 if(ofs == w) { \
|
|
|
532 ofs = 0; \
|
|
|
533 dstbuf += dst->pitch; \
|
|
|
534 if(!--linecount) \
|
|
|
535 break; \
|
|
|
536 } \
|
|
|
537 } \
|
|
|
538 } while(0)
|
|
|
539
|
|
|
540 CHOOSE_BLIT(RLEBLIT, alpha, fmt);
|
|
|
541
|
|
|
542 #undef RLEBLIT
|
|
|
543 }
|
|
|
544
|
|
|
545 done:
|
|
|
546 /* Unlock the destination if necessary */
|
|
|
547 if ( dst->flags & (SDL_HWSURFACE|SDL_ASYNCBLIT) ) {
|
|
|
548 SDL_VideoDevice *video = current_video;
|
|
|
549 SDL_VideoDevice *this = current_video;
|
|
|
550 video->UnlockHWSurface(this, dst);
|
|
|
551 }
|
|
|
552 return(0);
|
|
|
553 }
|
|
|
554
|
|
|
555 #undef OPAQUE_BLIT
|
|
|
556
|
|
|
557 /*
|
|
|
558 * Per-pixel blitting macros for translucent pixels:
|
|
|
559 * These use the same techniques as the per-surface blitting macros
|
|
|
560 */
|
|
|
561
|
|
|
562 /*
|
|
|
563 * For 32bpp pixels, we have made sure the alpha is stored in the top
|
|
|
564 * 8 bits, so proceed as usual
|
|
|
565 */
|
|
|
566 #define BLIT_TRANSL_888(src, dst) \
|
|
|
567 do { \
|
|
|
568 Uint32 s = src; \
|
|
|
569 Uint32 d = dst; \
|
|
|
570 unsigned alpha = s >> 24; \
|
|
|
571 Uint32 s1 = s & 0xff00ff; \
|
|
|
572 Uint32 d1 = d & 0xff00ff; \
|
|
|
573 d1 = (d1 + ((s1 - d1) * alpha >> 8)) & 0xff00ff; \
|
|
|
574 s &= 0xff00; \
|
|
|
575 d &= 0xff00; \
|
|
|
576 d = (d + ((s - d) * alpha >> 8)) & 0xff00; \
|
|
|
577 dst = d1 | d; \
|
|
|
578 } while(0)
|
|
|
579
|
|
|
580 /*
|
|
|
581 * For 16bpp pixels, we have stored the 5 most significant alpha bits in
|
|
|
582 * bits 5-10. As before, we can process all 3 RGB components at the same time.
|
|
|
583 */
|
|
|
584 #define BLIT_TRANSL_565(src, dst) \
|
|
|
585 do { \
|
|
|
586 Uint32 s = src; \
|
|
|
587 Uint32 d = dst; \
|
|
|
588 unsigned alpha = (s & 0x3e0) >> 5; \
|
|
|
589 s &= 0x07e0f81f; \
|
|
|
590 d = (d | d << 16) & 0x07e0f81f; \
|
|
|
591 d += (s - d) * alpha >> 5; \
|
|
|
592 d &= 0x07e0f81f; \
|
|
|
593 dst = d | d >> 16; \
|
|
|
594 } while(0)
|
|
|
595
|
|
|
596 #define BLIT_TRANSL_555(src, dst) \
|
|
|
597 do { \
|
|
|
598 Uint32 s = src; \
|
|
|
599 Uint32 d = dst; \
|
|
|
600 unsigned alpha = (s & 0x3e0) >> 5; \
|
|
|
601 s &= 0x03e07c1f; \
|
|
|
602 d = (d | d << 16) & 0x03e07c1f; \
|
|
|
603 d += (s - d) * alpha >> 5; \
|
|
|
604 d &= 0x03e07c1f; \
|
|
|
605 dst = d | d >> 16; \
|
|
|
606 } while(0)
|
|
|
607
|
|
|
608 /* used to save the destination format in the encoding. Designed to be
|
|
|
609 macro-compatible with SDL_PixelFormat but without the unneeded fields */
|
|
|
610 typedef struct {
|
|
|
611 Uint8 BytesPerPixel;
|
|
|
612 Uint8 Rloss;
|
|
|
613 Uint8 Gloss;
|
|
|
614 Uint8 Bloss;
|
|
|
615 Uint8 Rshift;
|
|
|
616 Uint8 Gshift;
|
|
|
617 Uint8 Bshift;
|
|
|
618 Uint8 Ashift;
|
|
|
619 Uint32 Rmask;
|
|
|
620 Uint32 Gmask;
|
|
|
621 Uint32 Bmask;
|
|
|
622 Uint32 Amask;
|
|
|
623 } RLEDestFormat;
|
|
|
624
|
|
|
625 /* blit a pixel-alpha RLE surface clipped at the right and/or left edges */
|
|
|
626 static void RLEAlphaClipBlit(int w, Uint8 *srcbuf, SDL_Surface *dst,
|
|
|
627 Uint8 *dstbuf, SDL_Rect *srcrect)
|
|
|
628 {
|
|
|
629 SDL_PixelFormat *df = dst->format;
|
|
|
630 /*
|
|
|
631 * clipped blitter: Ptype is the destination pixel type,
|
|
|
632 * Ctype the translucent count type, and do_blend the macro
|
|
|
633 * to blend one pixel.
|
|
|
634 */
|
|
|
635 #define RLEALPHACLIPBLIT(Ptype, Ctype, do_blend) \
|
|
|
636 do { \
|
|
|
637 int linecount = srcrect->h; \
|
|
|
638 int left = srcrect->x; \
|
|
|
639 int right = left + srcrect->w; \
|
|
|
640 dstbuf -= left * sizeof(Ptype); \
|
|
|
641 do { \
|
|
|
642 int ofs = 0; \
|
|
|
643 /* blit opaque pixels on one line */ \
|
|
|
644 do { \
|
|
|
645 unsigned run; \
|
|
|
646 ofs += ((Ctype *)srcbuf)[0]; \
|
|
|
647 run = ((Ctype *)srcbuf)[1]; \
|
|
|
648 srcbuf += 2 * sizeof(Ctype); \
|
|
|
649 if(run) { \
|
|
|
650 /* clip to left and right borders */ \
|
|
|
651 int cofs = ofs; \
|
|
|
652 int crun = run; \
|
|
|
653 if(left - cofs > 0) { \
|
|
|
654 crun -= left - cofs; \
|
|
|
655 cofs = left; \
|
|
|
656 } \
|
|
|
657 if(crun > right - cofs) \
|
|
|
658 crun = right - cofs; \
|
|
|
659 if(crun > 0) \
|
|
|
660 SDL_memcpy(dstbuf + cofs * sizeof(Ptype), \
|
|
|
661 srcbuf + (cofs - ofs) * sizeof(Ptype), \
|
|
|
662 (unsigned)crun * sizeof(Ptype)); \
|
|
|
663 srcbuf += run * sizeof(Ptype); \
|
|
|
664 ofs += run; \
|
|
|
665 } else if(!ofs) \
|
|
|
666 return; \
|
|
|
667 } while(ofs < w); \
|
|
|
668 /* skip padding if necessary */ \
|
|
|
669 if(sizeof(Ptype) == 2) \
|
|
|
670 srcbuf += (unsigned long)srcbuf & 2; \
|
|
|
671 /* blit translucent pixels on the same line */ \
|
|
|
672 ofs = 0; \
|
|
|
673 do { \
|
|
|
674 unsigned run; \
|
|
|
675 ofs += ((Uint16 *)srcbuf)[0]; \
|
|
|
676 run = ((Uint16 *)srcbuf)[1]; \
|
|
|
677 srcbuf += 4; \
|
|
|
678 if(run) { \
|
|
|
679 /* clip to left and right borders */ \
|
|
|
680 int cofs = ofs; \
|
|
|
681 int crun = run; \
|
|
|
682 if(left - cofs > 0) { \
|
|
|
683 crun -= left - cofs; \
|
|
|
684 cofs = left; \
|
|
|
685 } \
|
|
|
686 if(crun > right - cofs) \
|
|
|
687 crun = right - cofs; \
|
|
|
688 if(crun > 0) { \
|
|
|
689 Ptype *dst = (Ptype *)dstbuf + cofs; \
|
|
|
690 Uint32 *src = (Uint32 *)srcbuf + (cofs - ofs); \
|
|
|
691 int i; \
|
|
|
692 for(i = 0; i < crun; i++) \
|
|
|
693 do_blend(src[i], dst[i]); \
|
|
|
694 } \
|
|
|
695 srcbuf += run * 4; \
|
|
|
696 ofs += run; \
|
|
|
697 } \
|
|
|
698 } while(ofs < w); \
|
|
|
699 dstbuf += dst->pitch; \
|
|
|
700 } while(--linecount); \
|
|
|
701 } while(0)
|
|
|
702
|
|
|
703 switch(df->BytesPerPixel) {
|
|
|
704 case 2:
|
|
|
705 if(df->Gmask == 0x07e0 || df->Rmask == 0x07e0
|
|
|
706 || df->Bmask == 0x07e0)
|
|
|
707 RLEALPHACLIPBLIT(Uint16, Uint8, BLIT_TRANSL_565);
|
|
|
708 else
|
|
|
709 RLEALPHACLIPBLIT(Uint16, Uint8, BLIT_TRANSL_555);
|
|
|
710 break;
|
|
|
711 case 4:
|
|
|
712 RLEALPHACLIPBLIT(Uint32, Uint16, BLIT_TRANSL_888);
|
|
|
713 break;
|
|
|
714 }
|
|
|
715 }
|
|
|
716
|
|
|
717 /* blit a pixel-alpha RLE surface */
|
|
|
718 int SDL_RLEAlphaBlit(SDL_Surface *src, SDL_Rect *srcrect,
|
|
|
719 SDL_Surface *dst, SDL_Rect *dstrect)
|
|
|
720 {
|
|
|
721 int x, y;
|
|
|
722 int w = src->w;
|
|
|
723 Uint8 *srcbuf, *dstbuf;
|
|
|
724 SDL_PixelFormat *df = dst->format;
|
|
|
725
|
|
|
726 /* Lock the destination if necessary */
|
|
|
727 if(dst->flags & (SDL_HWSURFACE|SDL_ASYNCBLIT)) {
|
|
|
728 SDL_VideoDevice *video = current_video;
|
|
|
729 SDL_VideoDevice *this = current_video;
|
|
|
730 if(video->LockHWSurface(this, dst) < 0) {
|
|
|
731 return -1;
|
|
|
732 }
|
|
|
733 }
|
|
|
734
|
|
|
735 x = dstrect->x;
|
|
|
736 y = dstrect->y;
|
|
|
737 dstbuf = (Uint8 *)dst->pixels + dst->offset
|
|
|
738 + y * dst->pitch + x * df->BytesPerPixel;
|
|
|
739 srcbuf = (Uint8 *)src->map->sw_data->aux_data + sizeof(RLEDestFormat);
|
|
|
740
|
|
|
741 {
|
|
|
742 /* skip lines at the top if necessary */
|
|
|
743 int vskip = srcrect->y;
|
|
|
744 if(vskip) {
|
|
|
745 int ofs;
|
|
|
746 if(df->BytesPerPixel == 2) {
|
|
|
747 /* the 16/32 interleaved format */
|
|
|
748 do {
|
|
|
749 /* skip opaque line */
|
|
|
750 ofs = 0;
|
|
|
751 do {
|
|
|
752 int run;
|
|
|
753 ofs += srcbuf[0];
|
|
|
754 run = srcbuf[1];
|
|
|
755 srcbuf += 2;
|
|
|
756 if(run) {
|
|
|
757 srcbuf += 2 * run;
|
|
|
758 ofs += run;
|
|
|
759 } else if(!ofs)
|
|
|
760 goto done;
|
|
|
761 } while(ofs < w);
|
|
|
762
|
|
|
763 /* skip padding */
|
|
|
764 srcbuf += (unsigned long)srcbuf & 2;
|
|
|
765
|
|
|
766 /* skip translucent line */
|
|
|
767 ofs = 0;
|
|
|
768 do {
|
|
|
769 int run;
|
|
|
770 ofs += ((Uint16 *)srcbuf)[0];
|
|
|
771 run = ((Uint16 *)srcbuf)[1];
|
|
|
772 srcbuf += 4 * (run + 1);
|
|
|
773 ofs += run;
|
|
|
774 } while(ofs < w);
|
|
|
775 } while(--vskip);
|
|
|
776 } else {
|
|
|
777 /* the 32/32 interleaved format */
|
|
|
778 vskip <<= 1; /* opaque and translucent have same format */
|
|
|
779 do {
|
|
|
780 ofs = 0;
|
|
|
781 do {
|
|
|
782 int run;
|
|
|
783 ofs += ((Uint16 *)srcbuf)[0];
|
|
|
784 run = ((Uint16 *)srcbuf)[1];
|
|
|
785 srcbuf += 4;
|
|
|
786 if(run) {
|
|
|
787 srcbuf += 4 * run;
|
|
|
788 ofs += run;
|
|
|
789 } else if(!ofs)
|
|
|
790 goto done;
|
|
|
791 } while(ofs < w);
|
|
|
792 } while(--vskip);
|
|
|
793 }
|
|
|
794 }
|
|
|
795 }
|
|
|
796
|
|
|
797 /* if left or right edge clipping needed, call clip blit */
|
|
|
798 if(srcrect->x || srcrect->w != src->w) {
|
|
|
799 RLEAlphaClipBlit(w, srcbuf, dst, dstbuf, srcrect);
|
|
|
800 } else {
|
|
|
801
|
|
|
802 /*
|
|
|
803 * non-clipped blitter. Ptype is the destination pixel type,
|
|
|
804 * Ctype the translucent count type, and do_blend the
|
|
|
805 * macro to blend one pixel.
|
|
|
806 */
|
|
|
807 #define RLEALPHABLIT(Ptype, Ctype, do_blend) \
|
|
|
808 do { \
|
|
|
809 int linecount = srcrect->h; \
|
|
|
810 do { \
|
|
|
811 int ofs = 0; \
|
|
|
812 /* blit opaque pixels on one line */ \
|
|
|
813 do { \
|
|
|
814 unsigned run; \
|
|
|
815 ofs += ((Ctype *)srcbuf)[0]; \
|
|
|
816 run = ((Ctype *)srcbuf)[1]; \
|
|
|
817 srcbuf += 2 * sizeof(Ctype); \
|
|
|
818 if(run) { \
|
|
|
819 SDL_memcpy(dstbuf + ofs * sizeof(Ptype), srcbuf, \
|
|
|
820 run * sizeof(Ptype)); \
|
|
|
821 srcbuf += run * sizeof(Ptype); \
|
|
|
822 ofs += run; \
|
|
|
823 } else if(!ofs) \
|
|
|
824 goto done; \
|
|
|
825 } while(ofs < w); \
|
|
|
826 /* skip padding if necessary */ \
|
|
|
827 if(sizeof(Ptype) == 2) \
|
|
|
828 srcbuf += (unsigned long)srcbuf & 2; \
|
|
|
829 /* blit translucent pixels on the same line */ \
|
|
|
830 ofs = 0; \
|
|
|
831 do { \
|
|
|
832 unsigned run; \
|
|
|
833 ofs += ((Uint16 *)srcbuf)[0]; \
|
|
|
834 run = ((Uint16 *)srcbuf)[1]; \
|
|
|
835 srcbuf += 4; \
|
|
|
836 if(run) { \
|
|
|
837 Ptype *dst = (Ptype *)dstbuf + ofs; \
|
|
|
838 unsigned i; \
|
|
|
839 for(i = 0; i < run; i++) { \
|
|
|
840 Uint32 src = *(Uint32 *)srcbuf; \
|
|
|
841 do_blend(src, *dst); \
|
|
|
842 srcbuf += 4; \
|
|
|
843 dst++; \
|
|
|
844 } \
|
|
|
845 ofs += run; \
|
|
|
846 } \
|
|
|
847 } while(ofs < w); \
|
|
|
848 dstbuf += dst->pitch; \
|
|
|
849 } while(--linecount); \
|
|
|
850 } while(0)
|
|
|
851
|
|
|
852 switch(df->BytesPerPixel) {
|
|
|
853 case 2:
|
|
|
854 if(df->Gmask == 0x07e0 || df->Rmask == 0x07e0
|
|
|
855 || df->Bmask == 0x07e0)
|
|
|
856 RLEALPHABLIT(Uint16, Uint8, BLIT_TRANSL_565);
|
|
|
857 else
|
|
|
858 RLEALPHABLIT(Uint16, Uint8, BLIT_TRANSL_555);
|
|
|
859 break;
|
|
|
860 case 4:
|
|
|
861 RLEALPHABLIT(Uint32, Uint16, BLIT_TRANSL_888);
|
|
|
862 break;
|
|
|
863 }
|
|
|
864 }
|
|
|
865
|
|
|
866 done:
|
|
|
867 /* Unlock the destination if necessary */
|
|
|
868 if(dst->flags & (SDL_HWSURFACE|SDL_ASYNCBLIT)) {
|
|
|
869 SDL_VideoDevice *video = current_video;
|
|
|
870 SDL_VideoDevice *this = current_video;
|
|
|
871 video->UnlockHWSurface(this, dst);
|
|
|
872 }
|
|
|
873 return 0;
|
|
|
874 }
|
|
|
875
|
|
|
876 /*
|
|
|
877 * Auxiliary functions:
|
|
|
878 * The encoding functions take 32bpp rgb + a, and
|
|
|
879 * return the number of bytes copied to the destination.
|
|
|
880 * The decoding functions copy to 32bpp rgb + a, and
|
|
|
881 * return the number of bytes copied from the source.
|
|
|
882 * These are only used in the encoder and un-RLE code and are therefore not
|
|
|
883 * highly optimised.
|
|
|
884 */
|
|
|
885
|
|
|
886 /* encode 32bpp rgb + a into 16bpp rgb, losing alpha */
|
|
|
887 static int copy_opaque_16(void *dst, Uint32 *src, int n,
|
|
|
888 SDL_PixelFormat *sfmt, SDL_PixelFormat *dfmt)
|
|
|
889 {
|
|
|
890 int i;
|
|
|
891 Uint16 *d = dst;
|
|
|
892 for(i = 0; i < n; i++) {
|
|
|
893 unsigned r, g, b;
|
|
|
894 RGB_FROM_PIXEL(*src, sfmt, r, g, b);
|
|
|
895 PIXEL_FROM_RGB(*d, dfmt, r, g, b);
|
|
|
896 src++;
|
|
|
897 d++;
|
|
|
898 }
|
|
|
899 return n * 2;
|
|
|
900 }
|
|
|
901
|
|
|
902 /* decode opaque pixels from 16bpp to 32bpp rgb + a */
|
|
|
903 static int uncopy_opaque_16(Uint32 *dst, void *src, int n,
|
|
|
904 RLEDestFormat *sfmt, SDL_PixelFormat *dfmt)
|
|
|
905 {
|
|
|
906 int i;
|
|
|
907 Uint16 *s = src;
|
|
|
908 unsigned alpha = dfmt->Amask ? 255 : 0;
|
|
|
909 for(i = 0; i < n; i++) {
|
|
|
910 unsigned r, g, b;
|
|
|
911 RGB_FROM_PIXEL(*s, sfmt, r, g, b);
|
|
|
912 PIXEL_FROM_RGBA(*dst, dfmt, r, g, b, alpha);
|
|
|
913 s++;
|
|
|
914 dst++;
|
|
|
915 }
|
|
|
916 return n * 2;
|
|
|
917 }
|
|
|
918
|
|
|
919
|
|
|
920
|
|
|
921 /* encode 32bpp rgb + a into 32bpp G0RAB format for blitting into 565 */
|
|
|
922 static int copy_transl_565(void *dst, Uint32 *src, int n,
|
|
|
923 SDL_PixelFormat *sfmt, SDL_PixelFormat *dfmt)
|
|
|
924 {
|
|
|
925 int i;
|
|
|
926 Uint32 *d = dst;
|
|
|
927 for(i = 0; i < n; i++) {
|
|
|
928 unsigned r, g, b, a;
|
|
|
929 Uint16 pix;
|
|
|
930 RGBA_FROM_8888(*src, sfmt, r, g, b, a);
|
|
|
931 PIXEL_FROM_RGB(pix, dfmt, r, g, b);
|
|
|
932 *d = ((pix & 0x7e0) << 16) | (pix & 0xf81f) | ((a << 2) & 0x7e0);
|
|
|
933 src++;
|
|
|
934 d++;
|
|
|
935 }
|
|
|
936 return n * 4;
|
|
|
937 }
|
|
|
938
|
|
|
939 /* encode 32bpp rgb + a into 32bpp G0RAB format for blitting into 555 */
|
|
|
940 static int copy_transl_555(void *dst, Uint32 *src, int n,
|
|
|
941 SDL_PixelFormat *sfmt, SDL_PixelFormat *dfmt)
|
|
|
942 {
|
|
|
943 int i;
|
|
|
944 Uint32 *d = dst;
|
|
|
945 for(i = 0; i < n; i++) {
|
|
|
946 unsigned r, g, b, a;
|
|
|
947 Uint16 pix;
|
|
|
948 RGBA_FROM_8888(*src, sfmt, r, g, b, a);
|
|
|
949 PIXEL_FROM_RGB(pix, dfmt, r, g, b);
|
|
|
950 *d = ((pix & 0x3e0) << 16) | (pix & 0xfc1f) | ((a << 2) & 0x3e0);
|
|
|
951 src++;
|
|
|
952 d++;
|
|
|
953 }
|
|
|
954 return n * 4;
|
|
|
955 }
|
|
|
956
|
|
|
957 /* decode translucent pixels from 32bpp GORAB to 32bpp rgb + a */
|
|
|
958 static int uncopy_transl_16(Uint32 *dst, void *src, int n,
|
|
|
959 RLEDestFormat *sfmt, SDL_PixelFormat *dfmt)
|
|
|
960 {
|
|
|
961 int i;
|
|
|
962 Uint32 *s = src;
|
|
|
963 for(i = 0; i < n; i++) {
|
|
|
964 unsigned r, g, b, a;
|
|
|
965 Uint32 pix = *s++;
|
|
|
966 a = (pix & 0x3e0) >> 2;
|
|
|
967 pix = (pix & ~0x3e0) | pix >> 16;
|
|
|
968 RGB_FROM_PIXEL(pix, sfmt, r, g, b);
|
|
|
969 PIXEL_FROM_RGBA(*dst, dfmt, r, g, b, a);
|
|
|
970 dst++;
|
|
|
971 }
|
|
|
972 return n * 4;
|
|
|
973 }
|
|
|
974
|
|
|
975 /* encode 32bpp rgba into 32bpp rgba, keeping alpha (dual purpose) */
|
|
|
976 static int copy_32(void *dst, Uint32 *src, int n,
|
|
|
977 SDL_PixelFormat *sfmt, SDL_PixelFormat *dfmt)
|
|
|
978 {
|
|
|
979 int i;
|
|
|
980 Uint32 *d = dst;
|
|
|
981 for(i = 0; i < n; i++) {
|
|
|
982 unsigned r, g, b, a;
|
|
|
983 Uint32 pixel;
|
|
|
984 RGBA_FROM_8888(*src, sfmt, r, g, b, a);
|
|
|
985 PIXEL_FROM_RGB(pixel, dfmt, r, g, b);
|
|
|
986 *d++ = pixel | a << 24;
|
|
|
987 src++;
|
|
|
988 }
|
|
|
989 return n * 4;
|
|
|
990 }
|
|
|
991
|
|
|
992 /* decode 32bpp rgba into 32bpp rgba, keeping alpha (dual purpose) */
|
|
|
993 static int uncopy_32(Uint32 *dst, void *src, int n,
|
|
|
994 RLEDestFormat *sfmt, SDL_PixelFormat *dfmt)
|
|
|
995 {
|
|
|
996 int i;
|
|
|
997 Uint32 *s = src;
|
|
|
998 for(i = 0; i < n; i++) {
|
|
|
999 unsigned r, g, b, a;
|
|
|
1000 Uint32 pixel = *s++;
|
|
|
1001 RGB_FROM_PIXEL(pixel, sfmt, r, g, b);
|
|
|
1002 a = pixel >> 24;
|
|
|
1003 PIXEL_FROM_RGBA(*dst, dfmt, r, g, b, a);
|
|
|
1004 dst++;
|
|
|
1005 }
|
|
|
1006 return n * 4;
|
|
|
1007 }
|
|
|
1008
|
|
|
1009 #define ISOPAQUE(pixel, fmt) ((((pixel) & fmt->Amask) >> fmt->Ashift) == 255)
|
|
|
1010
|
|
|
1011 #define ISTRANSL(pixel, fmt) \
|
|
|
1012 ((unsigned)((((pixel) & fmt->Amask) >> fmt->Ashift) - 1U) < 254U)
|
|
|
1013
|
|
|
1014 /* convert surface to be quickly alpha-blittable onto dest, if possible */
|
|
|
1015 static int RLEAlphaSurface(SDL_Surface *surface)
|
|
|
1016 {
|
|
|
1017 SDL_Surface *dest;
|
|
|
1018 SDL_PixelFormat *df;
|
|
|
1019 int maxsize = 0;
|
|
|
1020 int max_opaque_run;
|
|
|
1021 int max_transl_run = 65535;
|
|
|
1022 unsigned masksum;
|
|
|
1023 Uint8 *rlebuf, *dst;
|
|
|
1024 int (*copy_opaque)(void *, Uint32 *, int,
|
|
|
1025 SDL_PixelFormat *, SDL_PixelFormat *);
|
|
|
1026 int (*copy_transl)(void *, Uint32 *, int,
|
|
|
1027 SDL_PixelFormat *, SDL_PixelFormat *);
|
|
|
1028
|
|
|
1029 dest = surface->map->dst;
|
|
|
1030 if(!dest)
|
|
|
1031 return -1;
|
|
|
1032 df = dest->format;
|
|
|
1033 if(surface->format->BitsPerPixel != 32)
|
|
|
1034 return -1; /* only 32bpp source supported */
|
|
|
1035
|
|
|
1036 /* find out whether the destination is one we support,
|
|
|
1037 and determine the max size of the encoded result */
|
|
|
1038 masksum = df->Rmask | df->Gmask | df->Bmask;
|
|
|
1039 switch(df->BytesPerPixel) {
|
|
|
1040 case 2:
|
|
|
1041 /* 16bpp: only support 565 and 555 formats */
|
|
|
1042 switch(masksum) {
|
|
|
1043 case 0xffff:
|
|
|
1044 if(df->Gmask == 0x07e0
|
|
|
1045 || df->Rmask == 0x07e0 || df->Bmask == 0x07e0) {
|
|
|
1046 copy_opaque = copy_opaque_16;
|
|
|
1047 copy_transl = copy_transl_565;
|
|
|
1048 } else
|
|
|
1049 return -1;
|
|
|
1050 break;
|
|
|
1051 case 0x7fff:
|
|
|
1052 if(df->Gmask == 0x03e0
|
|
|
1053 || df->Rmask == 0x03e0 || df->Bmask == 0x03e0) {
|
|
|
1054 copy_opaque = copy_opaque_16;
|
|
|
1055 copy_transl = copy_transl_555;
|
|
|
1056 } else
|
|
|
1057 return -1;
|
|
|
1058 break;
|
|
|
1059 default:
|
|
|
1060 return -1;
|
|
|
1061 }
|
|
|
1062 max_opaque_run = 255; /* runs stored as bytes */
|
|
|
1063
|
|
|
1064 /* worst case is alternating opaque and translucent pixels,
|
|
|
1065 with room for alignment padding between lines */
|
|
|
1066 maxsize = surface->h * (2 + (4 + 2) * (surface->w + 1)) + 2;
|
|
|
1067 break;
|
|
|
1068 case 4:
|
|
|
1069 if(masksum != 0x00ffffff)
|
|
|
1070 return -1; /* requires unused high byte */
|
|
|
1071 copy_opaque = copy_32;
|
|
|
1072 copy_transl = copy_32;
|
|
|
1073 max_opaque_run = 255; /* runs stored as short ints */
|
|
|
1074
|
|
|
1075 /* worst case is alternating opaque and translucent pixels */
|
|
|
1076 maxsize = surface->h * 2 * 4 * (surface->w + 1) + 4;
|
|
|
1077 break;
|
|
|
1078 default:
|
|
|
1079 return -1; /* anything else unsupported right now */
|
|
|
1080 }
|
|
|
1081
|
|
|
1082 maxsize += sizeof(RLEDestFormat);
|
|
|
1083 rlebuf = (Uint8 *)malloc(maxsize);
|
|
|
1084 if(!rlebuf) {
|
|
|
1085 SDL_OutOfMemory();
|
|
|
1086 return -1;
|
|
|
1087 }
|
|
|
1088 {
|
|
|
1089 /* save the destination format so we can undo the encoding later */
|
|
|
1090 RLEDestFormat *r = (RLEDestFormat *)rlebuf;
|
|
|
1091 r->BytesPerPixel = df->BytesPerPixel;
|
|
|
1092 r->Rloss = df->Rloss;
|
|
|
1093 r->Gloss = df->Gloss;
|
|
|
1094 r->Bloss = df->Bloss;
|
|
|
1095 r->Rshift = df->Rshift;
|
|
|
1096 r->Gshift = df->Gshift;
|
|
|
1097 r->Bshift = df->Bshift;
|
|
|
1098 r->Ashift = df->Ashift;
|
|
|
1099 r->Rmask = df->Rmask;
|
|
|
1100 r->Gmask = df->Gmask;
|
|
|
1101 r->Bmask = df->Bmask;
|
|
|
1102 r->Amask = df->Amask;
|
|
|
1103 }
|
|
|
1104 dst = rlebuf + sizeof(RLEDestFormat);
|
|
|
1105
|
|
|
1106 /* Do the actual encoding */
|
|
|
1107 {
|
|
|
1108 int x, y;
|
|
|
1109 int h = surface->h, w = surface->w;
|
|
|
1110 SDL_PixelFormat *sf = surface->format;
|
|
|
1111 Uint32 *src = (Uint32 *)((Uint8 *)surface->pixels + surface->offset);
|
|
|
1112 Uint8 *lastline = dst; /* end of last non-blank line */
|
|
|
1113
|
|
|
1114 /* opaque counts are 8 or 16 bits, depending on target depth */
|
|
|
1115 #define ADD_OPAQUE_COUNTS(n, m) \
|
|
|
1116 if(df->BytesPerPixel == 4) { \
|
|
|
1117 ((Uint16 *)dst)[0] = n; \
|
|
|
1118 ((Uint16 *)dst)[1] = m; \
|
|
|
1119 dst += 4; \
|
|
|
1120 } else { \
|
|
|
1121 dst[0] = n; \
|
|
|
1122 dst[1] = m; \
|
|
|
1123 dst += 2; \
|
|
|
1124 }
|
|
|
1125
|
|
|
1126 /* translucent counts are always 16 bit */
|
|
|
1127 #define ADD_TRANSL_COUNTS(n, m) \
|
|
|
1128 (((Uint16 *)dst)[0] = n, ((Uint16 *)dst)[1] = m, dst += 4)
|
|
|
1129
|
|
|
1130 for(y = 0; y < h; y++) {
|
|
|
1131 int runstart, skipstart;
|
|
|
1132 int blankline = 0;
|
|
|
1133 /* First encode all opaque pixels of a scan line */
|
|
|
1134 x = 0;
|
|
|
1135 do {
|
|
|
1136 int run, skip, len;
|
|
|
1137 skipstart = x;
|
|
|
1138 while(x < w && !ISOPAQUE(src[x], sf))
|
|
|
1139 x++;
|
|
|
1140 runstart = x;
|
|
|
1141 while(x < w && ISOPAQUE(src[x], sf))
|
|
|
1142 x++;
|
|
|
1143 skip = runstart - skipstart;
|
|
|
1144 if(skip == w)
|
|
|
1145 blankline = 1;
|
|
|
1146 run = x - runstart;
|
|
|
1147 while(skip > max_opaque_run) {
|
|
|
1148 ADD_OPAQUE_COUNTS(max_opaque_run, 0);
|
|
|
1149 skip -= max_opaque_run;
|
|
|
1150 }
|
|
|
1151 len = MIN(run, max_opaque_run);
|
|
|
1152 ADD_OPAQUE_COUNTS(skip, len);
|
|
|
1153 dst += copy_opaque(dst, src + runstart, len, sf, df);
|
|
|
1154 runstart += len;
|
|
|
1155 run -= len;
|
|
|
1156 while(run) {
|
|
|
1157 len = MIN(run, max_opaque_run);
|
|
|
1158 ADD_OPAQUE_COUNTS(0, len);
|
|
|
1159 dst += copy_opaque(dst, src + runstart, len, sf, df);
|
|
|
1160 runstart += len;
|
|
|
1161 run -= len;
|
|
|
1162 }
|
|
|
1163 } while(x < w);
|
|
|
1164
|
|
|
1165 /* Make sure the next output address is 32-bit aligned */
|
|
|
1166 dst += (unsigned long)dst & 2;
|
|
|
1167
|
|
|
1168 /* Next, encode all translucent pixels of the same scan line */
|
|
|
1169 x = 0;
|
|
|
1170 do {
|
|
|
1171 int run, skip, len;
|
|
|
1172 skipstart = x;
|
|
|
1173 while(x < w && !ISTRANSL(src[x], sf))
|
|
|
1174 x++;
|
|
|
1175 runstart = x;
|
|
|
1176 while(x < w && ISTRANSL(src[x], sf))
|
|
|
1177 x++;
|
|
|
1178 skip = runstart - skipstart;
|
|
|
1179 blankline &= (skip == w);
|
|
|
1180 run = x - runstart;
|
|
|
1181 while(skip > max_transl_run) {
|
|
|
1182 ADD_TRANSL_COUNTS(max_transl_run, 0);
|
|
|
1183 skip -= max_transl_run;
|
|
|
1184 }
|
|
|
1185 len = MIN(run, max_transl_run);
|
|
|
1186 ADD_TRANSL_COUNTS(skip, len);
|
|
|
1187 dst += copy_transl(dst, src + runstart, len, sf, df);
|
|
|
1188 runstart += len;
|
|
|
1189 run -= len;
|
|
|
1190 while(run) {
|
|
|
1191 len = MIN(run, max_transl_run);
|
|
|
1192 ADD_TRANSL_COUNTS(0, len);
|
|
|
1193 dst += copy_transl(dst, src + runstart, len, sf, df);
|
|
|
1194 runstart += len;
|
|
|
1195 run -= len;
|
|
|
1196 }
|
|
|
1197 if(!blankline)
|
|
|
1198 lastline = dst;
|
|
|
1199 } while(x < w);
|
|
|
1200
|
|
|
1201 src += surface->pitch >> 2;
|
|
|
1202 }
|
|
|
1203 dst = lastline; /* back up past trailing blank lines */
|
|
|
1204 ADD_OPAQUE_COUNTS(0, 0);
|
|
|
1205 }
|
|
|
1206
|
|
|
1207 #undef ADD_OPAQUE_COUNTS
|
|
|
1208 #undef ADD_TRANSL_COUNTS
|
|
|
1209
|
|
|
1210 /* Now that we have it encoded, release the original pixels */
|
|
|
1211 if((surface->flags & SDL_PREALLOC) != SDL_PREALLOC
|
|
|
1212 && (surface->flags & SDL_HWSURFACE) != SDL_HWSURFACE) {
|
|
|
1213 free( surface->pixels );
|
|
|
1214 surface->pixels = NULL;
|
|
|
1215 }
|
|
|
1216
|
|
|
1217 /* realloc the buffer to release unused memory */
|
|
|
1218 {
|
|
|
1219 Uint8 *p = realloc(rlebuf, dst - rlebuf);
|
|
|
1220 if(!p)
|
|
|
1221 p = rlebuf;
|
|
|
1222 surface->map->sw_data->aux_data = p;
|
|
|
1223 }
|
|
|
1224
|
|
|
1225 return 0;
|
|
|
1226 }
|
|
|
1227
|
|
|
1228 static Uint32 getpix_8(Uint8 *srcbuf)
|
|
|
1229 {
|
|
|
1230 return *srcbuf;
|
|
|
1231 }
|
|
|
1232
|
|
|
1233 static Uint32 getpix_16(Uint8 *srcbuf)
|
|
|
1234 {
|
|
|
1235 return *(Uint16 *)srcbuf;
|
|
|
1236 }
|
|
|
1237
|
|
|
1238 static Uint32 getpix_24(Uint8 *srcbuf)
|
|
|
1239 {
|
|
|
1240 if(SDL_BYTEORDER == SDL_LIL_ENDIAN)
|
|
|
1241 return srcbuf[0] + (srcbuf[1] << 8) + (srcbuf[2] << 16);
|
|
|
1242 else
|
|
|
1243 return (srcbuf[0] << 16) + (srcbuf[1] << 8) + srcbuf[2];
|
|
|
1244 }
|
|
|
1245
|
|
|
1246 static Uint32 getpix_32(Uint8 *srcbuf)
|
|
|
1247 {
|
|
|
1248 return *(Uint32 *)srcbuf;
|
|
|
1249 }
|
|
|
1250
|
|
|
1251 typedef Uint32 (*getpix_func)(Uint8 *);
|
|
|
1252
|
|
|
1253 static getpix_func getpixes[4] = {
|
|
|
1254 getpix_8, getpix_16, getpix_24, getpix_32
|
|
|
1255 };
|
|
|
1256
|
|
|
1257 static int RLEColorkeySurface(SDL_Surface *surface)
|
|
|
1258 {
|
|
|
1259 Uint8 *rlebuf, *dst;
|
|
|
1260 int maxn;
|
|
|
1261 int y;
|
|
|
1262 Uint8 *srcbuf, *curbuf, *lastline;
|
|
|
1263 int maxsize = 0;
|
|
|
1264 int skip, run;
|
|
|
1265 int bpp = surface->format->BytesPerPixel;
|
|
|
1266 getpix_func getpix;
|
|
|
1267 Uint32 ckey, rgbmask;
|
|
|
1268 int w, h;
|
|
|
1269
|
|
|
1270 /* calculate the worst case size for the compressed surface */
|
|
|
1271 switch(bpp) {
|
|
|
1272 case 1:
|
|
|
1273 /* worst case is alternating opaque and transparent pixels,
|
|
|
1274 starting with an opaque pixel */
|
|
|
1275 maxsize = surface->h * 3 * (surface->w / 2 + 1) + 2;
|
|
|
1276 break;
|
|
|
1277 case 2:
|
|
|
1278 case 3:
|
|
|
1279 /* worst case is solid runs, at most 255 pixels wide */
|
|
|
1280 maxsize = surface->h * (2 * (surface->w / 255 + 1)
|
|
|
1281 + surface->w * bpp) + 2;
|
|
|
1282 break;
|
|
|
1283 case 4:
|
|
|
1284 /* worst case is solid runs, at most 65535 pixels wide */
|
|
|
1285 maxsize = surface->h * (4 * (surface->w / 65535 + 1)
|
|
|
1286 + surface->w * 4) + 4;
|
|
|
1287 break;
|
|
|
1288 }
|
|
|
1289
|
|
|
1290 rlebuf = (Uint8 *)malloc(maxsize);
|
|
|
1291 if ( rlebuf == NULL ) {
|
|
|
1292 SDL_OutOfMemory();
|
|
|
1293 return(-1);
|
|
|
1294 }
|
|
|
1295
|
|
|
1296 /* Set up the conversion */
|
|
|
1297 srcbuf = (Uint8 *)surface->pixels+surface->offset;
|
|
|
1298 curbuf = srcbuf;
|
|
|
1299 maxn = bpp == 4 ? 65535 : 255;
|
|
|
1300 skip = run = 0;
|
|
|
1301 dst = rlebuf;
|
|
|
1302 rgbmask = ~surface->format->Amask;
|
|
|
1303 ckey = surface->format->colorkey & rgbmask;
|
|
|
1304 lastline = dst;
|
|
|
1305 getpix = getpixes[bpp - 1];
|
|
|
1306 w = surface->w;
|
|
|
1307 h = surface->h;
|
|
|
1308
|
|
|
1309 #define ADD_COUNTS(n, m) \
|
|
|
1310 if(bpp == 4) { \
|
|
|
1311 ((Uint16 *)dst)[0] = n; \
|
|
|
1312 ((Uint16 *)dst)[1] = m; \
|
|
|
1313 dst += 4; \
|
|
|
1314 } else { \
|
|
|
1315 dst[0] = n; \
|
|
|
1316 dst[1] = m; \
|
|
|
1317 dst += 2; \
|
|
|
1318 }
|
|
|
1319
|
|
|
1320 for(y = 0; y < h; y++) {
|
|
|
1321 int x = 0;
|
|
|
1322 int blankline = 0;
|
|
|
1323 do {
|
|
|
1324 int run, skip, len;
|
|
|
1325 int runstart;
|
|
|
1326 int skipstart = x;
|
|
|
1327
|
|
|
1328 /* find run of transparent, then opaque pixels */
|
|
|
1329 while(x < w && (getpix(srcbuf + x * bpp) & rgbmask) == ckey)
|
|
|
1330 x++;
|
|
|
1331 runstart = x;
|
|
|
1332 while(x < w && (getpix(srcbuf + x * bpp) & rgbmask) != ckey)
|
|
|
1333 x++;
|
|
|
1334 skip = runstart - skipstart;
|
|
|
1335 if(skip == w)
|
|
|
1336 blankline = 1;
|
|
|
1337 run = x - runstart;
|
|
|
1338
|
|
|
1339 /* encode segment */
|
|
|
1340 while(skip > maxn) {
|
|
|
1341 ADD_COUNTS(maxn, 0);
|
|
|
1342 skip -= maxn;
|
|
|
1343 }
|
|
|
1344 len = MIN(run, maxn);
|
|
|
1345 ADD_COUNTS(skip, len);
|
|
|
1346 memcpy(dst, srcbuf + runstart * bpp, len * bpp);
|
|
|
1347 dst += len * bpp;
|
|
|
1348 run -= len;
|
|
|
1349 runstart += len;
|
|
|
1350 while(run) {
|
|
|
1351 len = MIN(run, maxn);
|
|
|
1352 ADD_COUNTS(0, len);
|
|
|
1353 memcpy(dst, srcbuf + runstart * bpp, len * bpp);
|
|
|
1354 dst += len * bpp;
|
|
|
1355 runstart += len;
|
|
|
1356 run -= len;
|
|
|
1357 }
|
|
|
1358 if(!blankline)
|
|
|
1359 lastline = dst;
|
|
|
1360 } while(x < w);
|
|
|
1361
|
|
|
1362 srcbuf += surface->pitch;
|
|
|
1363 }
|
|
|
1364 dst = lastline; /* back up bast trailing blank lines */
|
|
|
1365 ADD_COUNTS(0, 0);
|
|
|
1366
|
|
|
1367 #undef ADD_COUNTS
|
|
|
1368
|
|
|
1369 /* Now that we have it encoded, release the original pixels */
|
|
|
1370 if((surface->flags & SDL_PREALLOC) != SDL_PREALLOC
|
|
|
1371 && (surface->flags & SDL_HWSURFACE) != SDL_HWSURFACE) {
|
|
|
1372 free( surface->pixels );
|
|
|
1373 surface->pixels = NULL;
|
|
|
1374 }
|
|
|
1375
|
|
|
1376 /* realloc the buffer to release unused memory */
|
|
|
1377 {
|
|
|
1378 /* If realloc returns NULL, the original block is left intact */
|
|
|
1379 Uint8 *p = realloc(rlebuf, dst - rlebuf);
|
|
|
1380 if(!p)
|
|
|
1381 p = rlebuf;
|
|
|
1382 surface->map->sw_data->aux_data = p;
|
|
|
1383 }
|
|
|
1384
|
|
|
1385 return(0);
|
|
|
1386 }
|
|
|
1387
|
|
|
1388 int SDL_RLESurface(SDL_Surface *surface)
|
|
|
1389 {
|
|
|
1390 int retcode;
|
|
|
1391
|
|
|
1392 /* Clear any previous RLE conversion */
|
|
|
1393 if ( (surface->flags & SDL_RLEACCEL) == SDL_RLEACCEL ) {
|
|
|
1394 SDL_UnRLESurface(surface, 1);
|
|
|
1395 }
|
|
|
1396
|
|
|
1397 /* We don't support RLE encoding of bitmaps */
|
|
|
1398 if ( surface->format->BitsPerPixel < 8 ) {
|
|
|
1399 return(-1);
|
|
|
1400 }
|
|
|
1401
|
|
|
1402 /* Lock the surface if it's in hardware */
|
|
|
1403 if ( surface->flags & (SDL_HWSURFACE|SDL_ASYNCBLIT) ) {
|
|
|
1404 SDL_VideoDevice *video = current_video;
|
|
|
1405 SDL_VideoDevice *this = current_video;
|
|
|
1406 if ( video->LockHWSurface(this, surface) < 0 ) {
|
|
|
1407 return(-1);
|
|
|
1408 }
|
|
|
1409 }
|
|
|
1410
|
|
|
1411 /* Encode */
|
|
|
1412 if((surface->flags & SDL_SRCCOLORKEY) == SDL_SRCCOLORKEY) {
|
|
|
1413 retcode = RLEColorkeySurface(surface);
|
|
|
1414 } else {
|
|
|
1415 if((surface->flags & SDL_SRCALPHA) == SDL_SRCALPHA
|
|
|
1416 && surface->format->Amask != 0)
|
|
|
1417 retcode = RLEAlphaSurface(surface);
|
|
|
1418 else
|
|
|
1419 retcode = -1; /* no RLE for per-surface alpha sans ckey */
|
|
|
1420 }
|
|
|
1421
|
|
|
1422 /* Unlock the surface if it's in hardware */
|
|
|
1423 if ( surface->flags & (SDL_HWSURFACE|SDL_ASYNCBLIT) ) {
|
|
|
1424 SDL_VideoDevice *video = current_video;
|
|
|
1425 SDL_VideoDevice *this = current_video;
|
|
|
1426 video->UnlockHWSurface(this, surface);
|
|
|
1427 }
|
|
|
1428
|
|
|
1429 if(retcode < 0)
|
|
|
1430 return -1;
|
|
|
1431
|
|
|
1432 /* The surface is now accelerated */
|
|
|
1433 surface->flags |= SDL_RLEACCEL;
|
|
|
1434
|
|
|
1435 return(0);
|
|
|
1436 }
|
|
|
1437
|
|
|
1438 /*
|
|
|
1439 * Un-RLE a surface with pixel alpha
|
|
|
1440 * This may not give back exactly the image before RLE-encoding; all
|
|
|
1441 * completely transparent pixels will be lost, and colour and alpha depth
|
|
|
1442 * may have been reduced (when encoding for 16bpp targets).
|
|
|
1443 */
|
|
|
1444 static void UnRLEAlpha(SDL_Surface *surface)
|
|
|
1445 {
|
|
|
1446 Uint8 *srcbuf;
|
|
|
1447 Uint32 *dst;
|
|
|
1448 SDL_PixelFormat *sf = surface->format;
|
|
|
1449 RLEDestFormat *df = surface->map->sw_data->aux_data;
|
|
|
1450 int (*uncopy_opaque)(Uint32 *, void *, int,
|
|
|
1451 RLEDestFormat *, SDL_PixelFormat *);
|
|
|
1452 int (*uncopy_transl)(Uint32 *, void *, int,
|
|
|
1453 RLEDestFormat *, SDL_PixelFormat *);
|
|
|
1454 int w = surface->w;
|
|
|
1455 int bpp = df->BytesPerPixel;
|
|
|
1456
|
|
|
1457 if(bpp == 2) {
|
|
|
1458 uncopy_opaque = uncopy_opaque_16;
|
|
|
1459 uncopy_transl = uncopy_transl_16;
|
|
|
1460 } else {
|
|
|
1461 uncopy_opaque = uncopy_transl = uncopy_32;
|
|
|
1462 }
|
|
|
1463
|
|
|
1464 surface->pixels = malloc(surface->h * surface->pitch);
|
|
|
1465 /* fill background with transparent pixels */
|
|
|
1466 memset(surface->pixels, 0, surface->h * surface->pitch);
|
|
|
1467
|
|
|
1468 dst = surface->pixels;
|
|
|
1469 srcbuf = (Uint8 *)(df + 1);
|
|
|
1470 for(;;) {
|
|
|
1471 /* copy opaque pixels */
|
|
|
1472 int ofs = 0;
|
|
|
1473 do {
|
|
|
1474 unsigned run;
|
|
|
1475 if(bpp == 2) {
|
|
|
1476 ofs += srcbuf[0];
|
|
|
1477 run = srcbuf[1];
|
|
|
1478 srcbuf += 2;
|
|
|
1479 } else {
|
|
|
1480 ofs += ((Uint16 *)srcbuf)[0];
|
|
|
1481 run = ((Uint16 *)srcbuf)[1];
|
|
|
1482 srcbuf += 4;
|
|
|
1483 }
|
|
|
1484 if(run) {
|
|
|
1485 srcbuf += uncopy_opaque(dst + ofs, srcbuf, run, df, sf);
|
|
|
1486 ofs += run;
|
|
|
1487 } else if(!ofs)
|
|
|
1488 return;
|
|
|
1489 } while(ofs < w);
|
|
|
1490
|
|
|
1491 /* skip padding if needed */
|
|
|
1492 if(bpp == 2)
|
|
|
1493 srcbuf += (unsigned long)srcbuf & 2;
|
|
|
1494
|
|
|
1495 /* copy translucent pixels */
|
|
|
1496 ofs = 0;
|
|
|
1497 do {
|
|
|
1498 unsigned run;
|
|
|
1499 ofs += ((Uint16 *)srcbuf)[0];
|
|
|
1500 run = ((Uint16 *)srcbuf)[1];
|
|
|
1501 srcbuf += 4;
|
|
|
1502 if(run) {
|
|
|
1503 srcbuf += uncopy_transl(dst + ofs, srcbuf, run, df, sf);
|
|
|
1504 ofs += run;
|
|
|
1505 }
|
|
|
1506 } while(ofs < w);
|
|
|
1507 dst += surface->pitch >> 2;
|
|
|
1508 }
|
|
|
1509 }
|
|
|
1510
|
|
|
1511 void SDL_UnRLESurface(SDL_Surface *surface, int recode)
|
|
|
1512 {
|
|
|
1513 if ( (surface->flags & SDL_RLEACCEL) == SDL_RLEACCEL ) {
|
|
|
1514 surface->flags &= ~SDL_RLEACCEL;
|
|
|
1515
|
|
|
1516 if(recode && (surface->flags & SDL_PREALLOC) != SDL_PREALLOC
|
|
|
1517 && (surface->flags & SDL_HWSURFACE) != SDL_HWSURFACE) {
|
|
|
1518 if((surface->flags & SDL_SRCCOLORKEY) == SDL_SRCCOLORKEY) {
|
|
|
1519 SDL_Rect full;
|
|
|
1520 unsigned alpha_flag;
|
|
|
1521
|
|
|
1522 /* re-create the original surface */
|
|
|
1523 surface->pixels = malloc(surface->h * surface->pitch);
|
|
|
1524
|
|
|
1525 /* fill it with the background colour */
|
|
|
1526 SDL_FillRect(surface, NULL, surface->format->colorkey);
|
|
|
1527
|
|
|
1528 /* now render the encoded surface */
|
|
|
1529 full.x = full.y = 0;
|
|
|
1530 full.w = surface->w;
|
|
|
1531 full.h = surface->h;
|
|
|
1532 alpha_flag = surface->flags & SDL_SRCALPHA;
|
|
|
1533 surface->flags &= ~SDL_SRCALPHA; /* opaque blit */
|
|
|
1534 SDL_RLEBlit(surface, &full, surface, &full);
|
|
|
1535 surface->flags |= alpha_flag;
|
|
|
1536 } else
|
|
|
1537 UnRLEAlpha(surface);
|
|
|
1538 }
|
|
|
1539
|
|
|
1540 if ( surface->map && surface->map->sw_data->aux_data ) {
|
|
|
1541 free(surface->map->sw_data->aux_data);
|
|
|
1542 surface->map->sw_data->aux_data = NULL;
|
|
|
1543 }
|
|
|
1544 }
|
|
|
1545 }
|
|
|
1546
|
|
|
1547
|
