diff options
author | Franklin Wei <git@fwei.tk> | 2017-01-21 15:18:31 -0500 |
---|---|---|
committer | Franklin Wei <git@fwei.tk> | 2017-12-23 21:01:26 -0500 |
commit | a855d6202536ff28e5aae4f22a0f31d8f5b325d0 (patch) | |
tree | 8c75f224dd64ed360505afa8843d016b0d75000b /apps/plugins/sdl/src/video/SDL_pixels.c | |
parent | 01c6dcf6c7b9bb1ad2fa0450f99bacc5f3d3e04b (diff) | |
download | rockbox-a855d6202536ff28e5aae4f22a0f31d8f5b325d0.tar.gz rockbox-a855d6202536ff28e5aae4f22a0f31d8f5b325d0.zip |
Port of Duke Nukem 3D
This ports Fabien Sanglard's Chocolate Duke to run on a version of SDL
for Rockbox.
Change-Id: I8f2c4c78af19de10c1633ed7bb7a997b43256dd9
Diffstat (limited to 'apps/plugins/sdl/src/video/SDL_pixels.c')
-rw-r--r-- | apps/plugins/sdl/src/video/SDL_pixels.c | 626 |
1 files changed, 626 insertions, 0 deletions
diff --git a/apps/plugins/sdl/src/video/SDL_pixels.c b/apps/plugins/sdl/src/video/SDL_pixels.c new file mode 100644 index 0000000000..1a7fd518f1 --- /dev/null +++ b/apps/plugins/sdl/src/video/SDL_pixels.c | |||
@@ -0,0 +1,626 @@ | |||
1 | /* | ||
2 | SDL - Simple DirectMedia Layer | ||
3 | Copyright (C) 1997-2012 Sam Lantinga | ||
4 | |||
5 | This library is free software; you can redistribute it and/or | ||
6 | modify it under the terms of the GNU Lesser General Public | ||
7 | License as published by the Free Software Foundation; either | ||
8 | version 2.1 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 | Lesser General Public License for more details. | ||
14 | |||
15 | You should have received a copy of the GNU Lesser General Public | ||
16 | License along with this library; if not, write to the Free Software | ||
17 | Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA | ||
18 | |||
19 | Sam Lantinga | ||
20 | slouken@libsdl.org | ||
21 | */ | ||
22 | #include "SDL_config.h" | ||
23 | |||
24 | /* General (mostly internal) pixel/color manipulation routines for SDL */ | ||
25 | |||
26 | #include "SDL_endian.h" | ||
27 | #include "SDL_video.h" | ||
28 | #include "SDL_sysvideo.h" | ||
29 | #include "SDL_blit.h" | ||
30 | #include "SDL_pixels_c.h" | ||
31 | #include "SDL_RLEaccel_c.h" | ||
32 | |||
33 | /* Helper functions */ | ||
34 | /* | ||
35 | * Allocate a pixel format structure and fill it according to the given info. | ||
36 | */ | ||
37 | SDL_PixelFormat *SDL_AllocFormat(int bpp, | ||
38 | Uint32 Rmask, Uint32 Gmask, Uint32 Bmask, Uint32 Amask) | ||
39 | { | ||
40 | SDL_PixelFormat *format; | ||
41 | Uint32 mask; | ||
42 | |||
43 | /* Allocate an empty pixel format structure */ | ||
44 | format = SDL_malloc(sizeof(*format)); | ||
45 | if ( format == NULL ) { | ||
46 | SDL_OutOfMemory(); | ||
47 | return(NULL); | ||
48 | } | ||
49 | SDL_memset(format, 0, sizeof(*format)); | ||
50 | format->alpha = SDL_ALPHA_OPAQUE; | ||
51 | |||
52 | /* Set up the format */ | ||
53 | format->BitsPerPixel = bpp; | ||
54 | format->BytesPerPixel = (bpp+7)/8; | ||
55 | if ( Rmask || Bmask || Gmask ) { /* Packed pixels with custom mask */ | ||
56 | format->palette = NULL; | ||
57 | format->Rshift = 0; | ||
58 | format->Rloss = 8; | ||
59 | if ( Rmask ) { | ||
60 | for ( mask = Rmask; !(mask&0x01); mask >>= 1 ) | ||
61 | ++format->Rshift; | ||
62 | for ( ; (mask&0x01); mask >>= 1 ) | ||
63 | --format->Rloss; | ||
64 | } | ||
65 | format->Gshift = 0; | ||
66 | format->Gloss = 8; | ||
67 | if ( Gmask ) { | ||
68 | for ( mask = Gmask; !(mask&0x01); mask >>= 1 ) | ||
69 | ++format->Gshift; | ||
70 | for ( ; (mask&0x01); mask >>= 1 ) | ||
71 | --format->Gloss; | ||
72 | } | ||
73 | format->Bshift = 0; | ||
74 | format->Bloss = 8; | ||
75 | if ( Bmask ) { | ||
76 | for ( mask = Bmask; !(mask&0x01); mask >>= 1 ) | ||
77 | ++format->Bshift; | ||
78 | for ( ; (mask&0x01); mask >>= 1 ) | ||
79 | --format->Bloss; | ||
80 | } | ||
81 | format->Ashift = 0; | ||
82 | format->Aloss = 8; | ||
83 | if ( Amask ) { | ||
84 | for ( mask = Amask; !(mask&0x01); mask >>= 1 ) | ||
85 | ++format->Ashift; | ||
86 | for ( ; (mask&0x01); mask >>= 1 ) | ||
87 | --format->Aloss; | ||
88 | } | ||
89 | format->Rmask = Rmask; | ||
90 | format->Gmask = Gmask; | ||
91 | format->Bmask = Bmask; | ||
92 | format->Amask = Amask; | ||
93 | } else if ( bpp > 8 ) { /* Packed pixels with standard mask */ | ||
94 | /* R-G-B */ | ||
95 | if ( bpp > 24 ) | ||
96 | bpp = 24; | ||
97 | format->Rloss = 8-(bpp/3); | ||
98 | format->Gloss = 8-(bpp/3)-(bpp%3); | ||
99 | format->Bloss = 8-(bpp/3); | ||
100 | format->Rshift = ((bpp/3)+(bpp%3))+(bpp/3); | ||
101 | format->Gshift = (bpp/3); | ||
102 | format->Bshift = 0; | ||
103 | format->Rmask = ((0xFF>>format->Rloss)<<format->Rshift); | ||
104 | format->Gmask = ((0xFF>>format->Gloss)<<format->Gshift); | ||
105 | format->Bmask = ((0xFF>>format->Bloss)<<format->Bshift); | ||
106 | } else { | ||
107 | /* Palettized formats have no mask info */ | ||
108 | format->Rloss = 8; | ||
109 | format->Gloss = 8; | ||
110 | format->Bloss = 8; | ||
111 | format->Aloss = 8; | ||
112 | format->Rshift = 0; | ||
113 | format->Gshift = 0; | ||
114 | format->Bshift = 0; | ||
115 | format->Ashift = 0; | ||
116 | format->Rmask = 0; | ||
117 | format->Gmask = 0; | ||
118 | format->Bmask = 0; | ||
119 | format->Amask = 0; | ||
120 | } | ||
121 | if ( bpp <= 8 ) { /* Palettized mode */ | ||
122 | int ncolors = 1<<bpp; | ||
123 | #ifdef DEBUG_PALETTE | ||
124 | fprintf(stderr,"bpp=%d ncolors=%d\n",bpp,ncolors); | ||
125 | #endif | ||
126 | format->palette = (SDL_Palette *)SDL_malloc(sizeof(SDL_Palette)); | ||
127 | if ( format->palette == NULL ) { | ||
128 | SDL_FreeFormat(format); | ||
129 | SDL_OutOfMemory(); | ||
130 | return(NULL); | ||
131 | } | ||
132 | (format->palette)->ncolors = ncolors; | ||
133 | (format->palette)->colors = (SDL_Color *)SDL_malloc( | ||
134 | (format->palette)->ncolors*sizeof(SDL_Color)); | ||
135 | if ( (format->palette)->colors == NULL ) { | ||
136 | SDL_FreeFormat(format); | ||
137 | SDL_OutOfMemory(); | ||
138 | return(NULL); | ||
139 | } | ||
140 | if ( Rmask || Bmask || Gmask ) { | ||
141 | /* create palette according to masks */ | ||
142 | int i; | ||
143 | int Rm=0,Gm=0,Bm=0; | ||
144 | int Rw=0,Gw=0,Bw=0; | ||
145 | #ifdef ENABLE_PALETTE_ALPHA | ||
146 | int Am=0,Aw=0; | ||
147 | #endif | ||
148 | if(Rmask) | ||
149 | { | ||
150 | Rw=8-format->Rloss; | ||
151 | for(i=format->Rloss;i>0;i-=Rw) | ||
152 | Rm|=1<<i; | ||
153 | } | ||
154 | #ifdef DEBUG_PALETTE | ||
155 | fprintf(stderr,"Rw=%d Rm=0x%02X\n",Rw,Rm); | ||
156 | #endif | ||
157 | if(Gmask) | ||
158 | { | ||
159 | Gw=8-format->Gloss; | ||
160 | for(i=format->Gloss;i>0;i-=Gw) | ||
161 | Gm|=1<<i; | ||
162 | } | ||
163 | #ifdef DEBUG_PALETTE | ||
164 | fprintf(stderr,"Gw=%d Gm=0x%02X\n",Gw,Gm); | ||
165 | #endif | ||
166 | if(Bmask) | ||
167 | { | ||
168 | Bw=8-format->Bloss; | ||
169 | for(i=format->Bloss;i>0;i-=Bw) | ||
170 | Bm|=1<<i; | ||
171 | } | ||
172 | #ifdef DEBUG_PALETTE | ||
173 | fprintf(stderr,"Bw=%d Bm=0x%02X\n",Bw,Bm); | ||
174 | #endif | ||
175 | #ifdef ENABLE_PALETTE_ALPHA | ||
176 | if(Amask) | ||
177 | { | ||
178 | Aw=8-format->Aloss; | ||
179 | for(i=format->Aloss;i>0;i-=Aw) | ||
180 | Am|=1<<i; | ||
181 | } | ||
182 | # ifdef DEBUG_PALETTE | ||
183 | fprintf(stderr,"Aw=%d Am=0x%02X\n",Aw,Am); | ||
184 | # endif | ||
185 | #endif | ||
186 | for(i=0; i < ncolors; ++i) { | ||
187 | int r,g,b; | ||
188 | r=(i&Rmask)>>format->Rshift; | ||
189 | r=(r<<format->Rloss)|((r*Rm)>>Rw); | ||
190 | format->palette->colors[i].r=r; | ||
191 | |||
192 | g=(i&Gmask)>>format->Gshift; | ||
193 | g=(g<<format->Gloss)|((g*Gm)>>Gw); | ||
194 | format->palette->colors[i].g=g; | ||
195 | |||
196 | b=(i&Bmask)>>format->Bshift; | ||
197 | b=(b<<format->Bloss)|((b*Bm)>>Bw); | ||
198 | format->palette->colors[i].b=b; | ||
199 | |||
200 | #ifdef ENABLE_PALETTE_ALPHA | ||
201 | a=(i&Amask)>>format->Ashift; | ||
202 | a=(a<<format->Aloss)|((a*Am)>>Aw); | ||
203 | format->palette->colors[i].unused=a; | ||
204 | #else | ||
205 | format->palette->colors[i].unused=0; | ||
206 | #endif | ||
207 | } | ||
208 | } else if ( ncolors == 2 ) { | ||
209 | /* Create a black and white bitmap palette */ | ||
210 | format->palette->colors[0].r = 0xFF; | ||
211 | format->palette->colors[0].g = 0xFF; | ||
212 | format->palette->colors[0].b = 0xFF; | ||
213 | format->palette->colors[1].r = 0x00; | ||
214 | format->palette->colors[1].g = 0x00; | ||
215 | format->palette->colors[1].b = 0x00; | ||
216 | } else { | ||
217 | /* Create an empty palette */ | ||
218 | SDL_memset((format->palette)->colors, 0, | ||
219 | (format->palette)->ncolors*sizeof(SDL_Color)); | ||
220 | } | ||
221 | } | ||
222 | return(format); | ||
223 | } | ||
224 | SDL_PixelFormat *SDL_ReallocFormat(SDL_Surface *surface, int bpp, | ||
225 | Uint32 Rmask, Uint32 Gmask, Uint32 Bmask, Uint32 Amask) | ||
226 | { | ||
227 | if ( surface->format ) { | ||
228 | SDL_FreeFormat(surface->format); | ||
229 | SDL_FormatChanged(surface); | ||
230 | } | ||
231 | surface->format = SDL_AllocFormat(bpp, Rmask, Gmask, Bmask, Amask); | ||
232 | return surface->format; | ||
233 | } | ||
234 | |||
235 | /* | ||
236 | * Change any previous mappings from/to the new surface format | ||
237 | */ | ||
238 | void SDL_FormatChanged(SDL_Surface *surface) | ||
239 | { | ||
240 | static int format_version = 0; | ||
241 | ++format_version; | ||
242 | if ( format_version < 0 ) { /* It wrapped... */ | ||
243 | format_version = 1; | ||
244 | } | ||
245 | surface->format_version = format_version; | ||
246 | SDL_InvalidateMap(surface->map); | ||
247 | } | ||
248 | /* | ||
249 | * Free a previously allocated format structure | ||
250 | */ | ||
251 | void SDL_FreeFormat(SDL_PixelFormat *format) | ||
252 | { | ||
253 | if ( format ) { | ||
254 | if ( format->palette ) { | ||
255 | if ( format->palette->colors ) { | ||
256 | SDL_free(format->palette->colors); | ||
257 | } | ||
258 | SDL_free(format->palette); | ||
259 | } | ||
260 | SDL_free(format); | ||
261 | } | ||
262 | } | ||
263 | /* | ||
264 | * Calculate an 8-bit (3 red, 3 green, 2 blue) dithered palette of colors | ||
265 | */ | ||
266 | void SDL_DitherColors(SDL_Color *colors, int bpp) | ||
267 | { | ||
268 | int i; | ||
269 | if(bpp != 8) | ||
270 | return; /* only 8bpp supported right now */ | ||
271 | |||
272 | for(i = 0; i < 256; i++) { | ||
273 | int r, g, b; | ||
274 | /* map each bit field to the full [0, 255] interval, | ||
275 | so 0 is mapped to (0, 0, 0) and 255 to (255, 255, 255) */ | ||
276 | r = i & 0xe0; | ||
277 | r |= r >> 3 | r >> 6; | ||
278 | colors[i].r = r; | ||
279 | g = (i << 3) & 0xe0; | ||
280 | g |= g >> 3 | g >> 6; | ||
281 | colors[i].g = g; | ||
282 | b = i & 0x3; | ||
283 | b |= b << 2; | ||
284 | b |= b << 4; | ||
285 | colors[i].b = b; | ||
286 | } | ||
287 | } | ||
288 | /* | ||
289 | * Calculate the pad-aligned scanline width of a surface | ||
290 | */ | ||
291 | Uint16 SDL_CalculatePitch(SDL_Surface *surface) | ||
292 | { | ||
293 | Uint16 pitch; | ||
294 | |||
295 | /* Surface should be 4-byte aligned for speed */ | ||
296 | pitch = surface->w*surface->format->BytesPerPixel; | ||
297 | switch (surface->format->BitsPerPixel) { | ||
298 | case 1: | ||
299 | pitch = (pitch+7)/8; | ||
300 | break; | ||
301 | case 4: | ||
302 | pitch = (pitch+1)/2; | ||
303 | break; | ||
304 | default: | ||
305 | break; | ||
306 | } | ||
307 | pitch = (pitch + 3) & ~3; /* 4-byte aligning */ | ||
308 | return(pitch); | ||
309 | } | ||
310 | /* | ||
311 | * Match an RGB value to a particular palette index | ||
312 | */ | ||
313 | Uint8 SDL_FindColor(SDL_Palette *pal, Uint8 r, Uint8 g, Uint8 b) | ||
314 | { | ||
315 | /* Do colorspace distance matching */ | ||
316 | unsigned int smallest; | ||
317 | unsigned int distance; | ||
318 | int rd, gd, bd; | ||
319 | int i; | ||
320 | Uint8 pixel=0; | ||
321 | |||
322 | smallest = ~0; | ||
323 | for ( i=0; i<pal->ncolors; ++i ) { | ||
324 | rd = pal->colors[i].r - r; | ||
325 | gd = pal->colors[i].g - g; | ||
326 | bd = pal->colors[i].b - b; | ||
327 | distance = (rd*rd)+(gd*gd)+(bd*bd); | ||
328 | if ( distance < smallest ) { | ||
329 | pixel = i; | ||
330 | if ( distance == 0 ) { /* Perfect match! */ | ||
331 | break; | ||
332 | } | ||
333 | smallest = distance; | ||
334 | } | ||
335 | } | ||
336 | return(pixel); | ||
337 | } | ||
338 | |||
339 | /* Find the opaque pixel value corresponding to an RGB triple */ | ||
340 | Uint32 SDL_MapRGB | ||
341 | (const SDL_PixelFormat * const format, | ||
342 | const Uint8 r, const Uint8 g, const Uint8 b) | ||
343 | { | ||
344 | if ( format->palette == NULL ) { | ||
345 | return (r >> format->Rloss) << format->Rshift | ||
346 | | (g >> format->Gloss) << format->Gshift | ||
347 | | (b >> format->Bloss) << format->Bshift | ||
348 | | format->Amask; | ||
349 | } else { | ||
350 | return SDL_FindColor(format->palette, r, g, b); | ||
351 | } | ||
352 | } | ||
353 | |||
354 | /* Find the pixel value corresponding to an RGBA quadruple */ | ||
355 | Uint32 SDL_MapRGBA | ||
356 | (const SDL_PixelFormat * const format, | ||
357 | const Uint8 r, const Uint8 g, const Uint8 b, const Uint8 a) | ||
358 | { | ||
359 | if ( format->palette == NULL ) { | ||
360 | return (r >> format->Rloss) << format->Rshift | ||
361 | | (g >> format->Gloss) << format->Gshift | ||
362 | | (b >> format->Bloss) << format->Bshift | ||
363 | | ((a >> format->Aloss) << format->Ashift & format->Amask); | ||
364 | } else { | ||
365 | return SDL_FindColor(format->palette, r, g, b); | ||
366 | } | ||
367 | } | ||
368 | |||
369 | void SDL_GetRGBA(Uint32 pixel, const SDL_PixelFormat * const fmt, | ||
370 | Uint8 *r, Uint8 *g, Uint8 *b, Uint8 *a) | ||
371 | { | ||
372 | if ( fmt->palette == NULL ) { | ||
373 | /* | ||
374 | * This makes sure that the result is mapped to the | ||
375 | * interval [0..255], and the maximum value for each | ||
376 | * component is 255. This is important to make sure | ||
377 | * that white is indeed reported as (255, 255, 255), | ||
378 | * and that opaque alpha is 255. | ||
379 | * This only works for RGB bit fields at least 4 bit | ||
380 | * wide, which is almost always the case. | ||
381 | */ | ||
382 | unsigned v; | ||
383 | v = (pixel & fmt->Rmask) >> fmt->Rshift; | ||
384 | *r = (v << fmt->Rloss) + (v >> (8 - (fmt->Rloss << 1))); | ||
385 | v = (pixel & fmt->Gmask) >> fmt->Gshift; | ||
386 | *g = (v << fmt->Gloss) + (v >> (8 - (fmt->Gloss << 1))); | ||
387 | v = (pixel & fmt->Bmask) >> fmt->Bshift; | ||
388 | *b = (v << fmt->Bloss) + (v >> (8 - (fmt->Bloss << 1))); | ||
389 | if(fmt->Amask) { | ||
390 | v = (pixel & fmt->Amask) >> fmt->Ashift; | ||
391 | *a = (v << fmt->Aloss) + (v >> (8 - (fmt->Aloss << 1))); | ||
392 | } else { | ||
393 | *a = SDL_ALPHA_OPAQUE; | ||
394 | } | ||
395 | } else { | ||
396 | *r = fmt->palette->colors[pixel].r; | ||
397 | *g = fmt->palette->colors[pixel].g; | ||
398 | *b = fmt->palette->colors[pixel].b; | ||
399 | *a = SDL_ALPHA_OPAQUE; | ||
400 | } | ||
401 | } | ||
402 | |||
403 | void SDL_GetRGB(Uint32 pixel, const SDL_PixelFormat * const fmt, | ||
404 | Uint8 *r,Uint8 *g,Uint8 *b) | ||
405 | { | ||
406 | if ( fmt->palette == NULL ) { | ||
407 | /* the note for SDL_GetRGBA above applies here too */ | ||
408 | unsigned v; | ||
409 | v = (pixel & fmt->Rmask) >> fmt->Rshift; | ||
410 | *r = (v << fmt->Rloss) + (v >> (8 - (fmt->Rloss << 1))); | ||
411 | v = (pixel & fmt->Gmask) >> fmt->Gshift; | ||
412 | *g = (v << fmt->Gloss) + (v >> (8 - (fmt->Gloss << 1))); | ||
413 | v = (pixel & fmt->Bmask) >> fmt->Bshift; | ||
414 | *b = (v << fmt->Bloss) + (v >> (8 - (fmt->Bloss << 1))); | ||
415 | } else { | ||
416 | *r = fmt->palette->colors[pixel].r; | ||
417 | *g = fmt->palette->colors[pixel].g; | ||
418 | *b = fmt->palette->colors[pixel].b; | ||
419 | } | ||
420 | } | ||
421 | |||
422 | /* Apply gamma to a set of colors - this is easy. :) */ | ||
423 | void SDL_ApplyGamma(Uint16 *gamma, SDL_Color *colors, SDL_Color *output, | ||
424 | int ncolors) | ||
425 | { | ||
426 | int i; | ||
427 | |||
428 | for ( i=0; i<ncolors; ++i ) { | ||
429 | output[i].r = gamma[0*256 + colors[i].r] >> 8; | ||
430 | output[i].g = gamma[1*256 + colors[i].g] >> 8; | ||
431 | output[i].b = gamma[2*256 + colors[i].b] >> 8; | ||
432 | } | ||
433 | } | ||
434 | |||
435 | /* Map from Palette to Palette */ | ||
436 | static Uint8 *Map1to1(SDL_Palette *src, SDL_Palette *dst, int *identical) | ||
437 | { | ||
438 | Uint8 *map; | ||
439 | int i; | ||
440 | |||
441 | if ( identical ) { | ||
442 | if ( src->ncolors <= dst->ncolors ) { | ||
443 | /* If an identical palette, no need to map */ | ||
444 | if ( SDL_memcmp(src->colors, dst->colors, src->ncolors* | ||
445 | sizeof(SDL_Color)) == 0 ) { | ||
446 | *identical = 1; | ||
447 | return(NULL); | ||
448 | } | ||
449 | } | ||
450 | *identical = 0; | ||
451 | } | ||
452 | map = (Uint8 *)SDL_malloc(src->ncolors); | ||
453 | if ( map == NULL ) { | ||
454 | SDL_OutOfMemory(); | ||
455 | return(NULL); | ||
456 | } | ||
457 | for ( i=0; i<src->ncolors; ++i ) { | ||
458 | map[i] = SDL_FindColor(dst, | ||
459 | src->colors[i].r, src->colors[i].g, src->colors[i].b); | ||
460 | } | ||
461 | return(map); | ||
462 | } | ||
463 | /* Map from Palette to BitField */ | ||
464 | static Uint8 *Map1toN(SDL_PixelFormat *src, SDL_PixelFormat *dst) | ||
465 | { | ||
466 | Uint8 *map; | ||
467 | int i; | ||
468 | int bpp; | ||
469 | unsigned alpha; | ||
470 | SDL_Palette *pal = src->palette; | ||
471 | |||
472 | bpp = ((dst->BytesPerPixel == 3) ? 4 : dst->BytesPerPixel); | ||
473 | map = (Uint8 *)SDL_malloc(pal->ncolors*bpp); | ||
474 | if ( map == NULL ) { | ||
475 | SDL_OutOfMemory(); | ||
476 | return(NULL); | ||
477 | } | ||
478 | |||
479 | alpha = dst->Amask ? src->alpha : 0; | ||
480 | /* We memory copy to the pixel map so the endianness is preserved */ | ||
481 | for ( i=0; i<pal->ncolors; ++i ) { | ||
482 | ASSEMBLE_RGBA(&map[i*bpp], dst->BytesPerPixel, dst, | ||
483 | pal->colors[i].r, pal->colors[i].g, | ||
484 | pal->colors[i].b, alpha); | ||
485 | } | ||
486 | return(map); | ||
487 | } | ||
488 | /* Map from BitField to Dithered-Palette to Palette */ | ||
489 | static Uint8 *MapNto1(SDL_PixelFormat *src, SDL_PixelFormat *dst, int *identical) | ||
490 | { | ||
491 | /* Generate a 256 color dither palette */ | ||
492 | SDL_Palette dithered; | ||
493 | SDL_Color colors[256]; | ||
494 | SDL_Palette *pal = dst->palette; | ||
495 | |||
496 | /* SDL_DitherColors does not initialize the 'unused' component of colors, | ||
497 | but Map1to1 compares it against pal, so we should initialize it. */ | ||
498 | SDL_memset(colors, 0, sizeof(colors)); | ||
499 | |||
500 | dithered.ncolors = 256; | ||
501 | SDL_DitherColors(colors, 8); | ||
502 | dithered.colors = colors; | ||
503 | return(Map1to1(&dithered, pal, identical)); | ||
504 | } | ||
505 | |||
506 | SDL_BlitMap *SDL_AllocBlitMap(void) | ||
507 | { | ||
508 | SDL_BlitMap *map; | ||
509 | |||
510 | /* Allocate the empty map */ | ||
511 | map = (SDL_BlitMap *)SDL_malloc(sizeof(*map)); | ||
512 | if ( map == NULL ) { | ||
513 | SDL_OutOfMemory(); | ||
514 | return(NULL); | ||
515 | } | ||
516 | SDL_memset(map, 0, sizeof(*map)); | ||
517 | |||
518 | /* Allocate the software blit data */ | ||
519 | map->sw_data = (struct private_swaccel *)SDL_malloc(sizeof(*map->sw_data)); | ||
520 | if ( map->sw_data == NULL ) { | ||
521 | SDL_FreeBlitMap(map); | ||
522 | SDL_OutOfMemory(); | ||
523 | return(NULL); | ||
524 | } | ||
525 | SDL_memset(map->sw_data, 0, sizeof(*map->sw_data)); | ||
526 | |||
527 | /* It's ready to go */ | ||
528 | return(map); | ||
529 | } | ||
530 | void SDL_InvalidateMap(SDL_BlitMap *map) | ||
531 | { | ||
532 | if ( ! map ) { | ||
533 | return; | ||
534 | } | ||
535 | map->dst = NULL; | ||
536 | map->format_version = (unsigned int)-1; | ||
537 | if ( map->table ) { | ||
538 | SDL_free(map->table); | ||
539 | map->table = NULL; | ||
540 | } | ||
541 | } | ||
542 | int SDL_MapSurface (SDL_Surface *src, SDL_Surface *dst) | ||
543 | { | ||
544 | SDL_PixelFormat *srcfmt; | ||
545 | SDL_PixelFormat *dstfmt; | ||
546 | SDL_BlitMap *map; | ||
547 | |||
548 | /* Clear out any previous mapping */ | ||
549 | map = src->map; | ||
550 | if ( (src->flags & SDL_RLEACCEL) == SDL_RLEACCEL ) { | ||
551 | SDL_UnRLESurface(src, 1); | ||
552 | } | ||
553 | SDL_InvalidateMap(map); | ||
554 | |||
555 | /* Figure out what kind of mapping we're doing */ | ||
556 | map->identity = 0; | ||
557 | srcfmt = src->format; | ||
558 | dstfmt = dst->format; | ||
559 | switch (srcfmt->BytesPerPixel) { | ||
560 | case 1: | ||
561 | switch (dstfmt->BytesPerPixel) { | ||
562 | case 1: | ||
563 | /* Palette --> Palette */ | ||
564 | /* If both SDL_HWSURFACE, assume have same palette */ | ||
565 | if ( ((src->flags & SDL_HWSURFACE) == SDL_HWSURFACE) && | ||
566 | ((dst->flags & SDL_HWSURFACE) == SDL_HWSURFACE) ) { | ||
567 | map->identity = 1; | ||
568 | } else { | ||
569 | map->table = Map1to1(srcfmt->palette, | ||
570 | dstfmt->palette, &map->identity); | ||
571 | } | ||
572 | if ( ! map->identity ) { | ||
573 | if ( map->table == NULL ) { | ||
574 | return(-1); | ||
575 | } | ||
576 | } | ||
577 | if (srcfmt->BitsPerPixel!=dstfmt->BitsPerPixel) | ||
578 | map->identity = 0; | ||
579 | break; | ||
580 | |||
581 | default: | ||
582 | /* Palette --> BitField */ | ||
583 | map->table = Map1toN(srcfmt, dstfmt); | ||
584 | if ( map->table == NULL ) { | ||
585 | return(-1); | ||
586 | } | ||
587 | break; | ||
588 | } | ||
589 | break; | ||
590 | default: | ||
591 | switch (dstfmt->BytesPerPixel) { | ||
592 | case 1: | ||
593 | /* BitField --> Palette */ | ||
594 | map->table = MapNto1(srcfmt, dstfmt, &map->identity); | ||
595 | if ( ! map->identity ) { | ||
596 | if ( map->table == NULL ) { | ||
597 | return(-1); | ||
598 | } | ||
599 | } | ||
600 | map->identity = 0; /* Don't optimize to copy */ | ||
601 | break; | ||
602 | default: | ||
603 | /* BitField --> BitField */ | ||
604 | if ( FORMAT_EQUAL(srcfmt, dstfmt) ) | ||
605 | map->identity = 1; | ||
606 | break; | ||
607 | } | ||
608 | break; | ||
609 | } | ||
610 | |||
611 | map->dst = dst; | ||
612 | map->format_version = dst->format_version; | ||
613 | |||
614 | /* Choose your blitters wisely */ | ||
615 | return(SDL_CalculateBlit(src)); | ||
616 | } | ||
617 | void SDL_FreeBlitMap(SDL_BlitMap *map) | ||
618 | { | ||
619 | if ( map ) { | ||
620 | SDL_InvalidateMap(map); | ||
621 | if ( map->sw_data != NULL ) { | ||
622 | SDL_free(map->sw_data); | ||
623 | } | ||
624 | SDL_free(map); | ||
625 | } | ||
626 | } | ||