Mercurial > sdl-ios-xcode

comparison src/video/SDL_blit_N.c @ 0:74212992fb08

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Initial revision
author Sam Lantinga <slouken@lokigames.com>
date Thu, 26 Apr 2001 16:45:43 +0000
parents
children e85e03f195b4
comparison
equal deleted inserted replaced
-1:000000000000 0:74212992fb08
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 #include <stdio.h>
29
30 #include "SDL_types.h"
31 #include "SDL_video.h"
32 #include "SDL_blit.h"
33 #include "SDL_byteorder.h"
34
35 /* Function to check the CPU flags */
36 #define MMX_CPU 0x800000
37 #ifdef USE_ASMBLIT
38 #define CPU_Flags() Hermes_X86_CPU()
39 #else
40 #define CPU_Flags() 0L
41 #endif
42
43 /* Functions to blit from N-bit surfaces to other surfaces */
44
45 #ifdef USE_ASMBLIT
46
47 /* Heheheh, we coerce Hermes into using SDL blit information */
48 #define X86_ASSEMBLER
49 #define HermesConverterInterface SDL_BlitInfo
50 #define HermesClearInterface void
51 #define STACKCALL
52 typedef Uint32 int32;
53
54 #include "HeadMMX.h"
55 #include "HeadX86.h"
56
57 #else
58
59 /* This is now endian dependent */
60 #if ( SDL_BYTEORDER == SDL_LIL_ENDIAN )
61 #define HI 1
62 #define LO 0
63 #else /* ( SDL_BYTEORDER == SDL_BIG_ENDIAN ) */
64 #define HI 0
65 #define LO 1
66 #endif
67
68 /* Special optimized blit for RGB 8-8-8 --> RGB 3-3-2 */
69 #define RGB888_RGB332(dst, src) { \
70 dst = (((src)&0x00E00000)>>16)| \
71 (((src)&0x0000E000)>>11)| \
72 (((src)&0x000000C0)>>6); \
73 }
74 static void Blit_RGB888_index8(SDL_BlitInfo *info)
75 {
76 #ifndef USE_DUFFS_LOOP
77 int c;
78 #endif
79 int width, height;
80 Uint32 *src;
81 Uint8 *map, *dst;
82 int srcskip, dstskip;
83
84 /* Set up some basic variables */
85 width = info->d_width;
86 height = info->d_height;
87 src = (Uint32 *)info->s_pixels;
88 srcskip = info->s_skip/4;
89 dst = info->d_pixels;
90 dstskip = info->d_skip;
91 map = info->table;
92
93 if ( map == NULL ) {
94 while ( height-- ) {
95 #ifdef USE_DUFFS_LOOP
96 DUFFS_LOOP(
97 RGB888_RGB332(*dst++, *src);
98 , width);
99 #else
100 for ( c=width/4; c; --c ) {
101 /* Pack RGB into 8bit pixel */
102 ++src;
103 RGB888_RGB332(*dst++, *src);
104 ++src;
105 RGB888_RGB332(*dst++, *src);
106 ++src;
107 RGB888_RGB332(*dst++, *src);
108 ++src;
109 }
110 switch ( width % 4 ) {
111 case 3:
112 RGB888_RGB332(*dst++, *src);
113 ++src;
114 case 2:
115 RGB888_RGB332(*dst++, *src);
116 ++src;
117 case 1:
118 RGB888_RGB332(*dst++, *src);
119 ++src;
120 }
121 #endif /* USE_DUFFS_LOOP */
122 src += srcskip;
123 dst += dstskip;
124 }
125 } else {
126 int pixel;
127
128 while ( height-- ) {
129 #ifdef USE_DUFFS_LOOP
130 DUFFS_LOOP(
131 RGB888_RGB332(pixel, *src);
132 *dst++ = map[pixel];
133 ++src;
134 , width);
135 #else
136 for ( c=width/4; c; --c ) {
137 /* Pack RGB into 8bit pixel */
138 RGB888_RGB332(pixel, *src);
139 *dst++ = map[pixel];
140 ++src;
141 RGB888_RGB332(pixel, *src);
142 *dst++ = map[pixel];
143 ++src;
144 RGB888_RGB332(pixel, *src);
145 *dst++ = map[pixel];
146 ++src;
147 RGB888_RGB332(pixel, *src);
148 *dst++ = map[pixel];
149 ++src;
150 }
151 switch ( width % 4 ) {
152 case 3:
153 RGB888_RGB332(pixel, *src);
154 *dst++ = map[pixel];
155 ++src;
156 case 2:
157 RGB888_RGB332(pixel, *src);
158 *dst++ = map[pixel];
159 ++src;
160 case 1:
161 RGB888_RGB332(pixel, *src);
162 *dst++ = map[pixel];
163 ++src;
164 }
165 #endif /* USE_DUFFS_LOOP */
166 src += srcskip;
167 dst += dstskip;
168 }
169 }
170 }
171 /* Special optimized blit for RGB 8-8-8 --> RGB 5-5-5 */
172 #define RGB888_RGB555(dst, src) { \
173 *(Uint16 *)(dst) = (((*src)&0x00F80000)>>9)| \
174 (((*src)&0x0000F800)>>6)| \
175 (((*src)&0x000000F8)>>3); \
176 }
177 #define RGB888_RGB555_TWO(dst, src) { \
178 *(Uint32 *)(dst) = (((((src[HI])&0x00F80000)>>9)| \
179 (((src[HI])&0x0000F800)>>6)| \
180 (((src[HI])&0x000000F8)>>3))<<16)| \
181 (((src[LO])&0x00F80000)>>9)| \
182 (((src[LO])&0x0000F800)>>6)| \
183 (((src[LO])&0x000000F8)>>3); \
184 }
185 static void Blit_RGB888_RGB555(SDL_BlitInfo *info)
186 {
187 #ifndef USE_DUFFS_LOOP
188 int c;
189 #endif
190 int width, height;
191 Uint32 *src;
192 Uint16 *dst;
193 int srcskip, dstskip;
194
195 /* Set up some basic variables */
196 width = info->d_width;
197 height = info->d_height;
198 src = (Uint32 *)info->s_pixels;
199 srcskip = info->s_skip/4;
200 dst = (Uint16 *)info->d_pixels;
201 dstskip = info->d_skip/2;
202
203 #ifdef USE_DUFFS_LOOP
204 while ( height-- ) {
205 DUFFS_LOOP(
206 RGB888_RGB555(dst, src);
207 ++src;
208 ++dst;
209 , width);
210 src += srcskip;
211 dst += dstskip;
212 }
213 #else
214 /* Memory align at 4-byte boundary, if necessary */
215 if ( (long)dst & 0x03 ) {
216 /* Don't do anything if width is 0 */
217 if ( width == 0 ) {
218 return;
219 }
220 --width;
221
222 while ( height-- ) {
223 /* Perform copy alignment */
224 RGB888_RGB555(dst, src);
225 ++src;
226 ++dst;
227
228 /* Copy in 4 pixel chunks */
229 for ( c=width/4; c; --c ) {
230 RGB888_RGB555_TWO(dst, src);
231 src += 2;
232 dst += 2;
233 RGB888_RGB555_TWO(dst, src);
234 src += 2;
235 dst += 2;
236 }
237 /* Get any leftovers */
238 switch (width % 4) {
239 case 3:
240 RGB888_RGB555(dst, src);
241 ++src;
242 ++dst;
243 case 2:
244 RGB888_RGB555_TWO(dst, src);
245 src += 2;
246 dst += 2;
247 break;
248 case 1:
249 RGB888_RGB555(dst, src);
250 ++src;
251 ++dst;
252 break;
253 }
254 src += srcskip;
255 dst += dstskip;
256 }
257 } else {
258 while ( height-- ) {
259 /* Copy in 4 pixel chunks */
260 for ( c=width/4; c; --c ) {
261 RGB888_RGB555_TWO(dst, src);
262 src += 2;
263 dst += 2;
264 RGB888_RGB555_TWO(dst, src);
265 src += 2;
266 dst += 2;
267 }
268 /* Get any leftovers */
269 switch (width % 4) {
270 case 3:
271 RGB888_RGB555(dst, src);
272 ++src;
273 ++dst;
274 case 2:
275 RGB888_RGB555_TWO(dst, src);
276 src += 2;
277 dst += 2;
278 break;
279 case 1:
280 RGB888_RGB555(dst, src);
281 ++src;
282 ++dst;
283 break;
284 }
285 src += srcskip;
286 dst += dstskip;
287 }
288 }
289 #endif /* USE_DUFFS_LOOP */
290 }
291 /* Special optimized blit for RGB 8-8-8 --> RGB 5-6-5 */
292 #define RGB888_RGB565(dst, src) { \
293 *(Uint16 *)(dst) = (((*src)&0x00F80000)>>8)| \
294 (((*src)&0x0000FC00)>>5)| \
295 (((*src)&0x000000F8)>>3); \
296 }
297 #define RGB888_RGB565_TWO(dst, src) { \
298 *(Uint32 *)(dst) = (((((src[HI])&0x00F80000)>>8)| \
299 (((src[HI])&0x0000FC00)>>5)| \
300 (((src[HI])&0x000000F8)>>3))<<16)| \
301 (((src[LO])&0x00F80000)>>8)| \
302 (((src[LO])&0x0000FC00)>>5)| \
303 (((src[LO])&0x000000F8)>>3); \
304 }
305 static void Blit_RGB888_RGB565(SDL_BlitInfo *info)
306 {
307 #ifndef USE_DUFFS_LOOP
308 int c;
309 #endif
310 int width, height;
311 Uint32 *src;
312 Uint16 *dst;
313 int srcskip, dstskip;
314
315 /* Set up some basic variables */
316 width = info->d_width;
317 height = info->d_height;
318 src = (Uint32 *)info->s_pixels;
319 srcskip = info->s_skip/4;
320 dst = (Uint16 *)info->d_pixels;
321 dstskip = info->d_skip/2;
322
323 #ifdef USE_DUFFS_LOOP
324 while ( height-- ) {
325 DUFFS_LOOP(
326 RGB888_RGB565(dst, src);
327 ++src;
328 ++dst;
329 , width);
330 src += srcskip;
331 dst += dstskip;
332 }
333 #else
334 /* Memory align at 4-byte boundary, if necessary */
335 if ( (long)dst & 0x03 ) {
336 /* Don't do anything if width is 0 */
337 if ( width == 0 ) {
338 return;
339 }
340 --width;
341
342 while ( height-- ) {
343 /* Perform copy alignment */
344 RGB888_RGB565(dst, src);
345 ++src;
346 ++dst;
347
348 /* Copy in 4 pixel chunks */
349 for ( c=width/4; c; --c ) {
350 RGB888_RGB565_TWO(dst, src);
351 src += 2;
352 dst += 2;
353 RGB888_RGB565_TWO(dst, src);
354 src += 2;
355 dst += 2;
356 }
357 /* Get any leftovers */
358 switch (width % 4) {
359 case 3:
360 RGB888_RGB565(dst, src);
361 ++src;
362 ++dst;
363 case 2:
364 RGB888_RGB565_TWO(dst, src);
365 src += 2;
366 dst += 2;
367 break;
368 case 1:
369 RGB888_RGB565(dst, src);
370 ++src;
371 ++dst;
372 break;
373 }
374 src += srcskip;
375 dst += dstskip;
376 }
377 } else {
378 while ( height-- ) {
379 /* Copy in 4 pixel chunks */
380 for ( c=width/4; c; --c ) {
381 RGB888_RGB565_TWO(dst, src);
382 src += 2;
383 dst += 2;
384 RGB888_RGB565_TWO(dst, src);
385 src += 2;
386 dst += 2;
387 }
388 /* Get any leftovers */
389 switch (width % 4) {
390 case 3:
391 RGB888_RGB565(dst, src);
392 ++src;
393 ++dst;
394 case 2:
395 RGB888_RGB565_TWO(dst, src);
396 src += 2;
397 dst += 2;
398 break;
399 case 1:
400 RGB888_RGB565(dst, src);
401 ++src;
402 ++dst;
403 break;
404 }
405 src += srcskip;
406 dst += dstskip;
407 }
408 }
409 #endif /* USE_DUFFS_LOOP */
410 }
411
412 #endif /* USE_ASMBLIT */
413
414
415 /* Special optimized blit for RGB 5-6-5 --> 32-bit RGB surfaces */
416 #if ( SDL_BYTEORDER == SDL_LIL_ENDIAN )
417 #define RGB565_32(dst, src, map) (map[src[0]*2] + map[src[1]*2+1])
418 #else /* ( SDL_BYTEORDER == SDL_BIG_ENDIAN ) */
419 #define RGB565_32(dst, src, map) (map[src[1]*2] + map[src[0]*2+1])
420 #endif
421 static void Blit_RGB565_32(SDL_BlitInfo *info, Uint32 *map)
422 {
423 #ifndef USE_DUFFS_LOOP
424 int c;
425 #endif
426 int width, height;
427 Uint8 *src;
428 Uint32 *dst;
429 int srcskip, dstskip;
430
431 /* Set up some basic variables */
432 width = info->d_width;
433 height = info->d_height;
434 src = (Uint8 *)info->s_pixels;
435 srcskip = info->s_skip;
436 dst = (Uint32 *)info->d_pixels;
437 dstskip = info->d_skip/4;
438
439 #ifdef USE_DUFFS_LOOP
440 while ( height-- ) {
441 DUFFS_LOOP(
442 {
443 *dst++ = RGB565_32(dst, src, map);
444 src += 2;
445 },
446 width);
447 src += srcskip;
448 dst += dstskip;
449 }
450 #else
451 while ( height-- ) {
452 /* Copy in 4 pixel chunks */
453 for ( c=width/4; c; --c ) {
454 *dst++ = RGB565_32(dst, src, map);
455 src += 2;
456 *dst++ = RGB565_32(dst, src, map);
457 src += 2;
458 *dst++ = RGB565_32(dst, src, map);
459 src += 2;
460 *dst++ = RGB565_32(dst, src, map);
461 src += 2;
462 }
463 /* Get any leftovers */
464 switch (width % 4) {
465 case 3:
466 *dst++ = RGB565_32(dst, src, map);
467 src += 2;
468 case 2:
469 *dst++ = RGB565_32(dst, src, map);
470 src += 2;
471 case 1:
472 *dst++ = RGB565_32(dst, src, map);
473 src += 2;
474 break;
475 }
476 src += srcskip;
477 dst += dstskip;
478 }
479 #endif /* USE_DUFFS_LOOP */
480 }
481
482 /* Special optimized blit for RGB 5-6-5 --> ARGB 8-8-8-8 */
483 static Uint32 RGB565_ARGB8888_LUT[512] = {
484 0x00000000, 0xff000000, 0x00000008, 0xff002000,
485 0x00000010, 0xff004000, 0x00000018, 0xff006100,
486 0x00000020, 0xff008100, 0x00000029, 0xff00a100,
487 0x00000031, 0xff00c200, 0x00000039, 0xff00e200,
488 0x00000041, 0xff080000, 0x0000004a, 0xff082000,
489 0x00000052, 0xff084000, 0x0000005a, 0xff086100,
490 0x00000062, 0xff088100, 0x0000006a, 0xff08a100,
491 0x00000073, 0xff08c200, 0x0000007b, 0xff08e200,
492 0x00000083, 0xff100000, 0x0000008b, 0xff102000,
493 0x00000094, 0xff104000, 0x0000009c, 0xff106100,
494 0x000000a4, 0xff108100, 0x000000ac, 0xff10a100,
495 0x000000b4, 0xff10c200, 0x000000bd, 0xff10e200,
496 0x000000c5, 0xff180000, 0x000000cd, 0xff182000,
497 0x000000d5, 0xff184000, 0x000000de, 0xff186100,
498 0x000000e6, 0xff188100, 0x000000ee, 0xff18a100,
499 0x000000f6, 0xff18c200, 0x000000ff, 0xff18e200,
500 0x00000400, 0xff200000, 0x00000408, 0xff202000,
501 0x00000410, 0xff204000, 0x00000418, 0xff206100,
502 0x00000420, 0xff208100, 0x00000429, 0xff20a100,
503 0x00000431, 0xff20c200, 0x00000439, 0xff20e200,
504 0x00000441, 0xff290000, 0x0000044a, 0xff292000,
505 0x00000452, 0xff294000, 0x0000045a, 0xff296100,
506 0x00000462, 0xff298100, 0x0000046a, 0xff29a100,
507 0x00000473, 0xff29c200, 0x0000047b, 0xff29e200,
508 0x00000483, 0xff310000, 0x0000048b, 0xff312000,
509 0x00000494, 0xff314000, 0x0000049c, 0xff316100,
510 0x000004a4, 0xff318100, 0x000004ac, 0xff31a100,
511 0x000004b4, 0xff31c200, 0x000004bd, 0xff31e200,
512 0x000004c5, 0xff390000, 0x000004cd, 0xff392000,
513 0x000004d5, 0xff394000, 0x000004de, 0xff396100,
514 0x000004e6, 0xff398100, 0x000004ee, 0xff39a100,
515 0x000004f6, 0xff39c200, 0x000004ff, 0xff39e200,
516 0x00000800, 0xff410000, 0x00000808, 0xff412000,
517 0x00000810, 0xff414000, 0x00000818, 0xff416100,
518 0x00000820, 0xff418100, 0x00000829, 0xff41a100,
519 0x00000831, 0xff41c200, 0x00000839, 0xff41e200,
520 0x00000841, 0xff4a0000, 0x0000084a, 0xff4a2000,
521 0x00000852, 0xff4a4000, 0x0000085a, 0xff4a6100,
522 0x00000862, 0xff4a8100, 0x0000086a, 0xff4aa100,
523 0x00000873, 0xff4ac200, 0x0000087b, 0xff4ae200,
524 0x00000883, 0xff520000, 0x0000088b, 0xff522000,
525 0x00000894, 0xff524000, 0x0000089c, 0xff526100,
526 0x000008a4, 0xff528100, 0x000008ac, 0xff52a100,
527 0x000008b4, 0xff52c200, 0x000008bd, 0xff52e200,
528 0x000008c5, 0xff5a0000, 0x000008cd, 0xff5a2000,
529 0x000008d5, 0xff5a4000, 0x000008de, 0xff5a6100,
530 0x000008e6, 0xff5a8100, 0x000008ee, 0xff5aa100,
531 0x000008f6, 0xff5ac200, 0x000008ff, 0xff5ae200,
532 0x00000c00, 0xff620000, 0x00000c08, 0xff622000,
533 0x00000c10, 0xff624000, 0x00000c18, 0xff626100,
534 0x00000c20, 0xff628100, 0x00000c29, 0xff62a100,
535 0x00000c31, 0xff62c200, 0x00000c39, 0xff62e200,
536 0x00000c41, 0xff6a0000, 0x00000c4a, 0xff6a2000,
537 0x00000c52, 0xff6a4000, 0x00000c5a, 0xff6a6100,
538 0x00000c62, 0xff6a8100, 0x00000c6a, 0xff6aa100,
539 0x00000c73, 0xff6ac200, 0x00000c7b, 0xff6ae200,
540 0x00000c83, 0xff730000, 0x00000c8b, 0xff732000,
541 0x00000c94, 0xff734000, 0x00000c9c, 0xff736100,
542 0x00000ca4, 0xff738100, 0x00000cac, 0xff73a100,
543 0x00000cb4, 0xff73c200, 0x00000cbd, 0xff73e200,
544 0x00000cc5, 0xff7b0000, 0x00000ccd, 0xff7b2000,
545 0x00000cd5, 0xff7b4000, 0x00000cde, 0xff7b6100,
546 0x00000ce6, 0xff7b8100, 0x00000cee, 0xff7ba100,
547 0x00000cf6, 0xff7bc200, 0x00000cff, 0xff7be200,
548 0x00001000, 0xff830000, 0x00001008, 0xff832000,
549 0x00001010, 0xff834000, 0x00001018, 0xff836100,
550 0x00001020, 0xff838100, 0x00001029, 0xff83a100,
551 0x00001031, 0xff83c200, 0x00001039, 0xff83e200,
552 0x00001041, 0xff8b0000, 0x0000104a, 0xff8b2000,
553 0x00001052, 0xff8b4000, 0x0000105a, 0xff8b6100,
554 0x00001062, 0xff8b8100, 0x0000106a, 0xff8ba100,
555 0x00001073, 0xff8bc200, 0x0000107b, 0xff8be200,
556 0x00001083, 0xff940000, 0x0000108b, 0xff942000,
557 0x00001094, 0xff944000, 0x0000109c, 0xff946100,
558 0x000010a4, 0xff948100, 0x000010ac, 0xff94a100,
559 0x000010b4, 0xff94c200, 0x000010bd, 0xff94e200,
560 0x000010c5, 0xff9c0000, 0x000010cd, 0xff9c2000,
561 0x000010d5, 0xff9c4000, 0x000010de, 0xff9c6100,
562 0x000010e6, 0xff9c8100, 0x000010ee, 0xff9ca100,
563 0x000010f6, 0xff9cc200, 0x000010ff, 0xff9ce200,
564 0x00001400, 0xffa40000, 0x00001408, 0xffa42000,
565 0x00001410, 0xffa44000, 0x00001418, 0xffa46100,
566 0x00001420, 0xffa48100, 0x00001429, 0xffa4a100,
567 0x00001431, 0xffa4c200, 0x00001439, 0xffa4e200,
568 0x00001441, 0xffac0000, 0x0000144a, 0xffac2000,
569 0x00001452, 0xffac4000, 0x0000145a, 0xffac6100,
570 0x00001462, 0xffac8100, 0x0000146a, 0xffaca100,
571 0x00001473, 0xffacc200, 0x0000147b, 0xfface200,
572 0x00001483, 0xffb40000, 0x0000148b, 0xffb42000,
573 0x00001494, 0xffb44000, 0x0000149c, 0xffb46100,
574 0x000014a4, 0xffb48100, 0x000014ac, 0xffb4a100,
575 0x000014b4, 0xffb4c200, 0x000014bd, 0xffb4e200,
576 0x000014c5, 0xffbd0000, 0x000014cd, 0xffbd2000,
577 0x000014d5, 0xffbd4000, 0x000014de, 0xffbd6100,
578 0x000014e6, 0xffbd8100, 0x000014ee, 0xffbda100,
579 0x000014f6, 0xffbdc200, 0x000014ff, 0xffbde200,
580 0x00001800, 0xffc50000, 0x00001808, 0xffc52000,
581 0x00001810, 0xffc54000, 0x00001818, 0xffc56100,
582 0x00001820, 0xffc58100, 0x00001829, 0xffc5a100,
583 0x00001831, 0xffc5c200, 0x00001839, 0xffc5e200,
584 0x00001841, 0xffcd0000, 0x0000184a, 0xffcd2000,
585 0x00001852, 0xffcd4000, 0x0000185a, 0xffcd6100,
586 0x00001862, 0xffcd8100, 0x0000186a, 0xffcda100,
587 0x00001873, 0xffcdc200, 0x0000187b, 0xffcde200,
588 0x00001883, 0xffd50000, 0x0000188b, 0xffd52000,
589 0x00001894, 0xffd54000, 0x0000189c, 0xffd56100,
590 0x000018a4, 0xffd58100, 0x000018ac, 0xffd5a100,
591 0x000018b4, 0xffd5c200, 0x000018bd, 0xffd5e200,
592 0x000018c5, 0xffde0000, 0x000018cd, 0xffde2000,
593 0x000018d5, 0xffde4000, 0x000018de, 0xffde6100,
594 0x000018e6, 0xffde8100, 0x000018ee, 0xffdea100,
595 0x000018f6, 0xffdec200, 0x000018ff, 0xffdee200,
596 0x00001c00, 0xffe60000, 0x00001c08, 0xffe62000,
597 0x00001c10, 0xffe64000, 0x00001c18, 0xffe66100,
598 0x00001c20, 0xffe68100, 0x00001c29, 0xffe6a100,
599 0x00001c31, 0xffe6c200, 0x00001c39, 0xffe6e200,
600 0x00001c41, 0xffee0000, 0x00001c4a, 0xffee2000,
601 0x00001c52, 0xffee4000, 0x00001c5a, 0xffee6100,
602 0x00001c62, 0xffee8100, 0x00001c6a, 0xffeea100,
603 0x00001c73, 0xffeec200, 0x00001c7b, 0xffeee200,
604 0x00001c83, 0xfff60000, 0x00001c8b, 0xfff62000,
605 0x00001c94, 0xfff64000, 0x00001c9c, 0xfff66100,
606 0x00001ca4, 0xfff68100, 0x00001cac, 0xfff6a100,
607 0x00001cb4, 0xfff6c200, 0x00001cbd, 0xfff6e200,
608 0x00001cc5, 0xffff0000, 0x00001ccd, 0xffff2000,
609 0x00001cd5, 0xffff4000, 0x00001cde, 0xffff6100,
610 0x00001ce6, 0xffff8100, 0x00001cee, 0xffffa100,
611 0x00001cf6, 0xffffc200, 0x00001cff, 0xffffe200
612 };
613 static void Blit_RGB565_ARGB8888(SDL_BlitInfo *info)
614 {
615 Blit_RGB565_32(info, RGB565_ARGB8888_LUT);
616 }
617
618 /* Special optimized blit for RGB 5-6-5 --> ABGR 8-8-8-8 */
619 static Uint32 RGB565_ABGR8888_LUT[512] = {
620 0xff000000, 0x00000000, 0xff080000, 0x00002000,
621 0xff100000, 0x00004000, 0xff180000, 0x00006100,
622 0xff200000, 0x00008100, 0xff290000, 0x0000a100,
623 0xff310000, 0x0000c200, 0xff390000, 0x0000e200,
624 0xff410000, 0x00000008, 0xff4a0000, 0x00002008,
625 0xff520000, 0x00004008, 0xff5a0000, 0x00006108,
626 0xff620000, 0x00008108, 0xff6a0000, 0x0000a108,
627 0xff730000, 0x0000c208, 0xff7b0000, 0x0000e208,
628 0xff830000, 0x00000010, 0xff8b0000, 0x00002010,
629 0xff940000, 0x00004010, 0xff9c0000, 0x00006110,
630 0xffa40000, 0x00008110, 0xffac0000, 0x0000a110,
631 0xffb40000, 0x0000c210, 0xffbd0000, 0x0000e210,
632 0xffc50000, 0x00000018, 0xffcd0000, 0x00002018,
633 0xffd50000, 0x00004018, 0xffde0000, 0x00006118,
634 0xffe60000, 0x00008118, 0xffee0000, 0x0000a118,
635 0xfff60000, 0x0000c218, 0xffff0000, 0x0000e218,
636 0xff000400, 0x00000020, 0xff080400, 0x00002020,
637 0xff100400, 0x00004020, 0xff180400, 0x00006120,
638 0xff200400, 0x00008120, 0xff290400, 0x0000a120,
639 0xff310400, 0x0000c220, 0xff390400, 0x0000e220,
640 0xff410400, 0x00000029, 0xff4a0400, 0x00002029,
641 0xff520400, 0x00004029, 0xff5a0400, 0x00006129,
642 0xff620400, 0x00008129, 0xff6a0400, 0x0000a129,
643 0xff730400, 0x0000c229, 0xff7b0400, 0x0000e229,
644 0xff830400, 0x00000031, 0xff8b0400, 0x00002031,
645 0xff940400, 0x00004031, 0xff9c0400, 0x00006131,
646 0xffa40400, 0x00008131, 0xffac0400, 0x0000a131,
647 0xffb40400, 0x0000c231, 0xffbd0400, 0x0000e231,
648 0xffc50400, 0x00000039, 0xffcd0400, 0x00002039,
649 0xffd50400, 0x00004039, 0xffde0400, 0x00006139,
650 0xffe60400, 0x00008139, 0xffee0400, 0x0000a139,
651 0xfff60400, 0x0000c239, 0xffff0400, 0x0000e239,
652 0xff000800, 0x00000041, 0xff080800, 0x00002041,
653 0xff100800, 0x00004041, 0xff180800, 0x00006141,
654 0xff200800, 0x00008141, 0xff290800, 0x0000a141,
655 0xff310800, 0x0000c241, 0xff390800, 0x0000e241,
656 0xff410800, 0x0000004a, 0xff4a0800, 0x0000204a,
657 0xff520800, 0x0000404a, 0xff5a0800, 0x0000614a,
658 0xff620800, 0x0000814a, 0xff6a0800, 0x0000a14a,
659 0xff730800, 0x0000c24a, 0xff7b0800, 0x0000e24a,
660 0xff830800, 0x00000052, 0xff8b0800, 0x00002052,
661 0xff940800, 0x00004052, 0xff9c0800, 0x00006152,
662 0xffa40800, 0x00008152, 0xffac0800, 0x0000a152,
663 0xffb40800, 0x0000c252, 0xffbd0800, 0x0000e252,
664 0xffc50800, 0x0000005a, 0xffcd0800, 0x0000205a,
665 0xffd50800, 0x0000405a, 0xffde0800, 0x0000615a,
666 0xffe60800, 0x0000815a, 0xffee0800, 0x0000a15a,
667 0xfff60800, 0x0000c25a, 0xffff0800, 0x0000e25a,
668 0xff000c00, 0x00000062, 0xff080c00, 0x00002062,
669 0xff100c00, 0x00004062, 0xff180c00, 0x00006162,
670 0xff200c00, 0x00008162, 0xff290c00, 0x0000a162,
671 0xff310c00, 0x0000c262, 0xff390c00, 0x0000e262,
672 0xff410c00, 0x0000006a, 0xff4a0c00, 0x0000206a,
673 0xff520c00, 0x0000406a, 0xff5a0c00, 0x0000616a,
674 0xff620c00, 0x0000816a, 0xff6a0c00, 0x0000a16a,
675 0xff730c00, 0x0000c26a, 0xff7b0c00, 0x0000e26a,
676 0xff830c00, 0x00000073, 0xff8b0c00, 0x00002073,
677 0xff940c00, 0x00004073, 0xff9c0c00, 0x00006173,
678 0xffa40c00, 0x00008173, 0xffac0c00, 0x0000a173,
679 0xffb40c00, 0x0000c273, 0xffbd0c00, 0x0000e273,
680 0xffc50c00, 0x0000007b, 0xffcd0c00, 0x0000207b,
681 0xffd50c00, 0x0000407b, 0xffde0c00, 0x0000617b,
682 0xffe60c00, 0x0000817b, 0xffee0c00, 0x0000a17b,
683 0xfff60c00, 0x0000c27b, 0xffff0c00, 0x0000e27b,
684 0xff001000, 0x00000083, 0xff081000, 0x00002083,
685 0xff101000, 0x00004083, 0xff181000, 0x00006183,
686 0xff201000, 0x00008183, 0xff291000, 0x0000a183,
687 0xff311000, 0x0000c283, 0xff391000, 0x0000e283,
688 0xff411000, 0x0000008b, 0xff4a1000, 0x0000208b,
689 0xff521000, 0x0000408b, 0xff5a1000, 0x0000618b,
690 0xff621000, 0x0000818b, 0xff6a1000, 0x0000a18b,
691 0xff731000, 0x0000c28b, 0xff7b1000, 0x0000e28b,
692 0xff831000, 0x00000094, 0xff8b1000, 0x00002094,
693 0xff941000, 0x00004094, 0xff9c1000, 0x00006194,
694 0xffa41000, 0x00008194, 0xffac1000, 0x0000a194,
695 0xffb41000, 0x0000c294, 0xffbd1000, 0x0000e294,
696 0xffc51000, 0x0000009c, 0xffcd1000, 0x0000209c,
697 0xffd51000, 0x0000409c, 0xffde1000, 0x0000619c,
698 0xffe61000, 0x0000819c, 0xffee1000, 0x0000a19c,
699 0xfff61000, 0x0000c29c, 0xffff1000, 0x0000e29c,
700 0xff001400, 0x000000a4, 0xff081400, 0x000020a4,
701 0xff101400, 0x000040a4, 0xff181400, 0x000061a4,
702 0xff201400, 0x000081a4, 0xff291400, 0x0000a1a4,
703 0xff311400, 0x0000c2a4, 0xff391400, 0x0000e2a4,
704 0xff411400, 0x000000ac, 0xff4a1400, 0x000020ac,
705 0xff521400, 0x000040ac, 0xff5a1400, 0x000061ac,
706 0xff621400, 0x000081ac, 0xff6a1400, 0x0000a1ac,
707 0xff731400, 0x0000c2ac, 0xff7b1400, 0x0000e2ac,
708 0xff831400, 0x000000b4, 0xff8b1400, 0x000020b4,
709 0xff941400, 0x000040b4, 0xff9c1400, 0x000061b4,
710 0xffa41400, 0x000081b4, 0xffac1400, 0x0000a1b4,
711 0xffb41400, 0x0000c2b4, 0xffbd1400, 0x0000e2b4,
712 0xffc51400, 0x000000bd, 0xffcd1400, 0x000020bd,
713 0xffd51400, 0x000040bd, 0xffde1400, 0x000061bd,
714 0xffe61400, 0x000081bd, 0xffee1400, 0x0000a1bd,
715 0xfff61400, 0x0000c2bd, 0xffff1400, 0x0000e2bd,
716 0xff001800, 0x000000c5, 0xff081800, 0x000020c5,
717 0xff101800, 0x000040c5, 0xff181800, 0x000061c5,
718 0xff201800, 0x000081c5, 0xff291800, 0x0000a1c5,
719 0xff311800, 0x0000c2c5, 0xff391800, 0x0000e2c5,
720 0xff411800, 0x000000cd, 0xff4a1800, 0x000020cd,
721 0xff521800, 0x000040cd, 0xff5a1800, 0x000061cd,
722 0xff621800, 0x000081cd, 0xff6a1800, 0x0000a1cd,
723 0xff731800, 0x0000c2cd, 0xff7b1800, 0x0000e2cd,
724 0xff831800, 0x000000d5, 0xff8b1800, 0x000020d5,
725 0xff941800, 0x000040d5, 0xff9c1800, 0x000061d5,
726 0xffa41800, 0x000081d5, 0xffac1800, 0x0000a1d5,
727 0xffb41800, 0x0000c2d5, 0xffbd1800, 0x0000e2d5,
728 0xffc51800, 0x000000de, 0xffcd1800, 0x000020de,
729 0xffd51800, 0x000040de, 0xffde1800, 0x000061de,
730 0xffe61800, 0x000081de, 0xffee1800, 0x0000a1de,
731 0xfff61800, 0x0000c2de, 0xffff1800, 0x0000e2de,
732 0xff001c00, 0x000000e6, 0xff081c00, 0x000020e6,
733 0xff101c00, 0x000040e6, 0xff181c00, 0x000061e6,
734 0xff201c00, 0x000081e6, 0xff291c00, 0x0000a1e6,
735 0xff311c00, 0x0000c2e6, 0xff391c00, 0x0000e2e6,
736 0xff411c00, 0x000000ee, 0xff4a1c00, 0x000020ee,
737 0xff521c00, 0x000040ee, 0xff5a1c00, 0x000061ee,
738 0xff621c00, 0x000081ee, 0xff6a1c00, 0x0000a1ee,
739 0xff731c00, 0x0000c2ee, 0xff7b1c00, 0x0000e2ee,
740 0xff831c00, 0x000000f6, 0xff8b1c00, 0x000020f6,
741 0xff941c00, 0x000040f6, 0xff9c1c00, 0x000061f6,
742 0xffa41c00, 0x000081f6, 0xffac1c00, 0x0000a1f6,
743 0xffb41c00, 0x0000c2f6, 0xffbd1c00, 0x0000e2f6,
744 0xffc51c00, 0x000000ff, 0xffcd1c00, 0x000020ff,
745 0xffd51c00, 0x000040ff, 0xffde1c00, 0x000061ff,
746 0xffe61c00, 0x000081ff, 0xffee1c00, 0x0000a1ff,
747 0xfff61c00, 0x0000c2ff, 0xffff1c00, 0x0000e2ff
748 };
749 static void Blit_RGB565_ABGR8888(SDL_BlitInfo *info)
750 {
751 Blit_RGB565_32(info, RGB565_ABGR8888_LUT);
752 }
753
754 /* Special optimized blit for RGB 5-6-5 --> RGBA 8-8-8-8 */
755 static Uint32 RGB565_RGBA8888_LUT[512] = {
756 0x000000ff, 0x00000000, 0x000008ff, 0x00200000,
757 0x000010ff, 0x00400000, 0x000018ff, 0x00610000,
758 0x000020ff, 0x00810000, 0x000029ff, 0x00a10000,
759 0x000031ff, 0x00c20000, 0x000039ff, 0x00e20000,
760 0x000041ff, 0x08000000, 0x00004aff, 0x08200000,
761 0x000052ff, 0x08400000, 0x00005aff, 0x08610000,
762 0x000062ff, 0x08810000, 0x00006aff, 0x08a10000,
763 0x000073ff, 0x08c20000, 0x00007bff, 0x08e20000,
764 0x000083ff, 0x10000000, 0x00008bff, 0x10200000,
765 0x000094ff, 0x10400000, 0x00009cff, 0x10610000,
766 0x0000a4ff, 0x10810000, 0x0000acff, 0x10a10000,
767 0x0000b4ff, 0x10c20000, 0x0000bdff, 0x10e20000,
768 0x0000c5ff, 0x18000000, 0x0000cdff, 0x18200000,
769 0x0000d5ff, 0x18400000, 0x0000deff, 0x18610000,
770 0x0000e6ff, 0x18810000, 0x0000eeff, 0x18a10000,
771 0x0000f6ff, 0x18c20000, 0x0000ffff, 0x18e20000,
772 0x000400ff, 0x20000000, 0x000408ff, 0x20200000,
773 0x000410ff, 0x20400000, 0x000418ff, 0x20610000,
774 0x000420ff, 0x20810000, 0x000429ff, 0x20a10000,
775 0x000431ff, 0x20c20000, 0x000439ff, 0x20e20000,
776 0x000441ff, 0x29000000, 0x00044aff, 0x29200000,
777 0x000452ff, 0x29400000, 0x00045aff, 0x29610000,
778 0x000462ff, 0x29810000, 0x00046aff, 0x29a10000,
779 0x000473ff, 0x29c20000, 0x00047bff, 0x29e20000,
780 0x000483ff, 0x31000000, 0x00048bff, 0x31200000,
781 0x000494ff, 0x31400000, 0x00049cff, 0x31610000,
782 0x0004a4ff, 0x31810000, 0x0004acff, 0x31a10000,
783 0x0004b4ff, 0x31c20000, 0x0004bdff, 0x31e20000,
784 0x0004c5ff, 0x39000000, 0x0004cdff, 0x39200000,
785 0x0004d5ff, 0x39400000, 0x0004deff, 0x39610000,
786 0x0004e6ff, 0x39810000, 0x0004eeff, 0x39a10000,
787 0x0004f6ff, 0x39c20000, 0x0004ffff, 0x39e20000,
788 0x000800ff, 0x41000000, 0x000808ff, 0x41200000,
789 0x000810ff, 0x41400000, 0x000818ff, 0x41610000,
790 0x000820ff, 0x41810000, 0x000829ff, 0x41a10000,
791 0x000831ff, 0x41c20000, 0x000839ff, 0x41e20000,
792 0x000841ff, 0x4a000000, 0x00084aff, 0x4a200000,
793 0x000852ff, 0x4a400000, 0x00085aff, 0x4a610000,
794 0x000862ff, 0x4a810000, 0x00086aff, 0x4aa10000,
795 0x000873ff, 0x4ac20000, 0x00087bff, 0x4ae20000,
796 0x000883ff, 0x52000000, 0x00088bff, 0x52200000,
797 0x000894ff, 0x52400000, 0x00089cff, 0x52610000,
798 0x0008a4ff, 0x52810000, 0x0008acff, 0x52a10000,
799 0x0008b4ff, 0x52c20000, 0x0008bdff, 0x52e20000,
800 0x0008c5ff, 0x5a000000, 0x0008cdff, 0x5a200000,
801 0x0008d5ff, 0x5a400000, 0x0008deff, 0x5a610000,
802 0x0008e6ff, 0x5a810000, 0x0008eeff, 0x5aa10000,
803 0x0008f6ff, 0x5ac20000, 0x0008ffff, 0x5ae20000,
804 0x000c00ff, 0x62000000, 0x000c08ff, 0x62200000,
805 0x000c10ff, 0x62400000, 0x000c18ff, 0x62610000,
806 0x000c20ff, 0x62810000, 0x000c29ff, 0x62a10000,
807 0x000c31ff, 0x62c20000, 0x000c39ff, 0x62e20000,
808 0x000c41ff, 0x6a000000, 0x000c4aff, 0x6a200000,
809 0x000c52ff, 0x6a400000, 0x000c5aff, 0x6a610000,
810 0x000c62ff, 0x6a810000, 0x000c6aff, 0x6aa10000,
811 0x000c73ff, 0x6ac20000, 0x000c7bff, 0x6ae20000,
812 0x000c83ff, 0x73000000, 0x000c8bff, 0x73200000,
813 0x000c94ff, 0x73400000, 0x000c9cff, 0x73610000,
814 0x000ca4ff, 0x73810000, 0x000cacff, 0x73a10000,
815 0x000cb4ff, 0x73c20000, 0x000cbdff, 0x73e20000,
816 0x000cc5ff, 0x7b000000, 0x000ccdff, 0x7b200000,
817 0x000cd5ff, 0x7b400000, 0x000cdeff, 0x7b610000,
818 0x000ce6ff, 0x7b810000, 0x000ceeff, 0x7ba10000,
819 0x000cf6ff, 0x7bc20000, 0x000cffff, 0x7be20000,
820 0x001000ff, 0x83000000, 0x001008ff, 0x83200000,
821 0x001010ff, 0x83400000, 0x001018ff, 0x83610000,
822 0x001020ff, 0x83810000, 0x001029ff, 0x83a10000,
823 0x001031ff, 0x83c20000, 0x001039ff, 0x83e20000,
824 0x001041ff, 0x8b000000, 0x00104aff, 0x8b200000,
825 0x001052ff, 0x8b400000, 0x00105aff, 0x8b610000,
826 0x001062ff, 0x8b810000, 0x00106aff, 0x8ba10000,
827 0x001073ff, 0x8bc20000, 0x00107bff, 0x8be20000,
828 0x001083ff, 0x94000000, 0x00108bff, 0x94200000,
829 0x001094ff, 0x94400000, 0x00109cff, 0x94610000,
830 0x0010a4ff, 0x94810000, 0x0010acff, 0x94a10000,
831 0x0010b4ff, 0x94c20000, 0x0010bdff, 0x94e20000,
832 0x0010c5ff, 0x9c000000, 0x0010cdff, 0x9c200000,
833 0x0010d5ff, 0x9c400000, 0x0010deff, 0x9c610000,
834 0x0010e6ff, 0x9c810000, 0x0010eeff, 0x9ca10000,
835 0x0010f6ff, 0x9cc20000, 0x0010ffff, 0x9ce20000,
836 0x001400ff, 0xa4000000, 0x001408ff, 0xa4200000,
837 0x001410ff, 0xa4400000, 0x001418ff, 0xa4610000,
838 0x001420ff, 0xa4810000, 0x001429ff, 0xa4a10000,
839 0x001431ff, 0xa4c20000, 0x001439ff, 0xa4e20000,
840 0x001441ff, 0xac000000, 0x00144aff, 0xac200000,
841 0x001452ff, 0xac400000, 0x00145aff, 0xac610000,
842 0x001462ff, 0xac810000, 0x00146aff, 0xaca10000,
843 0x001473ff, 0xacc20000, 0x00147bff, 0xace20000,
844 0x001483ff, 0xb4000000, 0x00148bff, 0xb4200000,
845 0x001494ff, 0xb4400000, 0x00149cff, 0xb4610000,
846 0x0014a4ff, 0xb4810000, 0x0014acff, 0xb4a10000,
847 0x0014b4ff, 0xb4c20000, 0x0014bdff, 0xb4e20000,
848 0x0014c5ff, 0xbd000000, 0x0014cdff, 0xbd200000,
849 0x0014d5ff, 0xbd400000, 0x0014deff, 0xbd610000,
850 0x0014e6ff, 0xbd810000, 0x0014eeff, 0xbda10000,
851 0x0014f6ff, 0xbdc20000, 0x0014ffff, 0xbde20000,
852 0x001800ff, 0xc5000000, 0x001808ff, 0xc5200000,
853 0x001810ff, 0xc5400000, 0x001818ff, 0xc5610000,
854 0x001820ff, 0xc5810000, 0x001829ff, 0xc5a10000,
855 0x001831ff, 0xc5c20000, 0x001839ff, 0xc5e20000,
856 0x001841ff, 0xcd000000, 0x00184aff, 0xcd200000,
857 0x001852ff, 0xcd400000, 0x00185aff, 0xcd610000,
858 0x001862ff, 0xcd810000, 0x00186aff, 0xcda10000,
859 0x001873ff, 0xcdc20000, 0x00187bff, 0xcde20000,
860 0x001883ff, 0xd5000000, 0x00188bff, 0xd5200000,
861 0x001894ff, 0xd5400000, 0x00189cff, 0xd5610000,
862 0x0018a4ff, 0xd5810000, 0x0018acff, 0xd5a10000,
863 0x0018b4ff, 0xd5c20000, 0x0018bdff, 0xd5e20000,
864 0x0018c5ff, 0xde000000, 0x0018cdff, 0xde200000,
865 0x0018d5ff, 0xde400000, 0x0018deff, 0xde610000,
866 0x0018e6ff, 0xde810000, 0x0018eeff, 0xdea10000,
867 0x0018f6ff, 0xdec20000, 0x0018ffff, 0xdee20000,
868 0x001c00ff, 0xe6000000, 0x001c08ff, 0xe6200000,
869 0x001c10ff, 0xe6400000, 0x001c18ff, 0xe6610000,
870 0x001c20ff, 0xe6810000, 0x001c29ff, 0xe6a10000,
871 0x001c31ff, 0xe6c20000, 0x001c39ff, 0xe6e20000,
872 0x001c41ff, 0xee000000, 0x001c4aff, 0xee200000,
873 0x001c52ff, 0xee400000, 0x001c5aff, 0xee610000,
874 0x001c62ff, 0xee810000, 0x001c6aff, 0xeea10000,
875 0x001c73ff, 0xeec20000, 0x001c7bff, 0xeee20000,
876 0x001c83ff, 0xf6000000, 0x001c8bff, 0xf6200000,
877 0x001c94ff, 0xf6400000, 0x001c9cff, 0xf6610000,
878 0x001ca4ff, 0xf6810000, 0x001cacff, 0xf6a10000,
879 0x001cb4ff, 0xf6c20000, 0x001cbdff, 0xf6e20000,
880 0x001cc5ff, 0xff000000, 0x001ccdff, 0xff200000,
881 0x001cd5ff, 0xff400000, 0x001cdeff, 0xff610000,
882 0x001ce6ff, 0xff810000, 0x001ceeff, 0xffa10000,
883 0x001cf6ff, 0xffc20000, 0x001cffff, 0xffe20000,
884 };
885 static void Blit_RGB565_RGBA8888(SDL_BlitInfo *info)
886 {
887 Blit_RGB565_32(info, RGB565_RGBA8888_LUT);
888 }
889
890 /* Special optimized blit for RGB 5-6-5 --> BGRA 8-8-8-8 */
891 static Uint32 RGB565_BGRA8888_LUT[512] = {
892 0x00000000, 0x000000ff, 0x08000000, 0x002000ff,
893 0x10000000, 0x004000ff, 0x18000000, 0x006100ff,
894 0x20000000, 0x008100ff, 0x29000000, 0x00a100ff,
895 0x31000000, 0x00c200ff, 0x39000000, 0x00e200ff,
896 0x41000000, 0x000008ff, 0x4a000000, 0x002008ff,
897 0x52000000, 0x004008ff, 0x5a000000, 0x006108ff,
898 0x62000000, 0x008108ff, 0x6a000000, 0x00a108ff,
899 0x73000000, 0x00c208ff, 0x7b000000, 0x00e208ff,
900 0x83000000, 0x000010ff, 0x8b000000, 0x002010ff,
901 0x94000000, 0x004010ff, 0x9c000000, 0x006110ff,
902 0xa4000000, 0x008110ff, 0xac000000, 0x00a110ff,
903 0xb4000000, 0x00c210ff, 0xbd000000, 0x00e210ff,
904 0xc5000000, 0x000018ff, 0xcd000000, 0x002018ff,
905 0xd5000000, 0x004018ff, 0xde000000, 0x006118ff,
906 0xe6000000, 0x008118ff, 0xee000000, 0x00a118ff,
907 0xf6000000, 0x00c218ff, 0xff000000, 0x00e218ff,
908 0x00040000, 0x000020ff, 0x08040000, 0x002020ff,
909 0x10040000, 0x004020ff, 0x18040000, 0x006120ff,
910 0x20040000, 0x008120ff, 0x29040000, 0x00a120ff,
911 0x31040000, 0x00c220ff, 0x39040000, 0x00e220ff,
912 0x41040000, 0x000029ff, 0x4a040000, 0x002029ff,
913 0x52040000, 0x004029ff, 0x5a040000, 0x006129ff,
914 0x62040000, 0x008129ff, 0x6a040000, 0x00a129ff,
915 0x73040000, 0x00c229ff, 0x7b040000, 0x00e229ff,
916 0x83040000, 0x000031ff, 0x8b040000, 0x002031ff,
917 0x94040000, 0x004031ff, 0x9c040000, 0x006131ff,
918 0xa4040000, 0x008131ff, 0xac040000, 0x00a131ff,
919 0xb4040000, 0x00c231ff, 0xbd040000, 0x00e231ff,
920 0xc5040000, 0x000039ff, 0xcd040000, 0x002039ff,
921 0xd5040000, 0x004039ff, 0xde040000, 0x006139ff,
922 0xe6040000, 0x008139ff, 0xee040000, 0x00a139ff,
923 0xf6040000, 0x00c239ff, 0xff040000, 0x00e239ff,
924 0x00080000, 0x000041ff, 0x08080000, 0x002041ff,
925 0x10080000, 0x004041ff, 0x18080000, 0x006141ff,
926 0x20080000, 0x008141ff, 0x29080000, 0x00a141ff,
927 0x31080000, 0x00c241ff, 0x39080000, 0x00e241ff,
928 0x41080000, 0x00004aff, 0x4a080000, 0x00204aff,
929 0x52080000, 0x00404aff, 0x5a080000, 0x00614aff,
930 0x62080000, 0x00814aff, 0x6a080000, 0x00a14aff,
931 0x73080000, 0x00c24aff, 0x7b080000, 0x00e24aff,
932 0x83080000, 0x000052ff, 0x8b080000, 0x002052ff,
933 0x94080000, 0x004052ff, 0x9c080000, 0x006152ff,
934 0xa4080000, 0x008152ff, 0xac080000, 0x00a152ff,
935 0xb4080000, 0x00c252ff, 0xbd080000, 0x00e252ff,
936 0xc5080000, 0x00005aff, 0xcd080000, 0x00205aff,
937 0xd5080000, 0x00405aff, 0xde080000, 0x00615aff,
938 0xe6080000, 0x00815aff, 0xee080000, 0x00a15aff,
939 0xf6080000, 0x00c25aff, 0xff080000, 0x00e25aff,
940 0x000c0000, 0x000062ff, 0x080c0000, 0x002062ff,
941 0x100c0000, 0x004062ff, 0x180c0000, 0x006162ff,
942 0x200c0000, 0x008162ff, 0x290c0000, 0x00a162ff,
943 0x310c0000, 0x00c262ff, 0x390c0000, 0x00e262ff,
944 0x410c0000, 0x00006aff, 0x4a0c0000, 0x00206aff,
945 0x520c0000, 0x00406aff, 0x5a0c0000, 0x00616aff,
946 0x620c0000, 0x00816aff, 0x6a0c0000, 0x00a16aff,
947 0x730c0000, 0x00c26aff, 0x7b0c0000, 0x00e26aff,
948 0x830c0000, 0x000073ff, 0x8b0c0000, 0x002073ff,
949 0x940c0000, 0x004073ff, 0x9c0c0000, 0x006173ff,
950 0xa40c0000, 0x008173ff, 0xac0c0000, 0x00a173ff,
951 0xb40c0000, 0x00c273ff, 0xbd0c0000, 0x00e273ff,
952 0xc50c0000, 0x00007bff, 0xcd0c0000, 0x00207bff,
953 0xd50c0000, 0x00407bff, 0xde0c0000, 0x00617bff,
954 0xe60c0000, 0x00817bff, 0xee0c0000, 0x00a17bff,
955 0xf60c0000, 0x00c27bff, 0xff0c0000, 0x00e27bff,
956 0x00100000, 0x000083ff, 0x08100000, 0x002083ff,
957 0x10100000, 0x004083ff, 0x18100000, 0x006183ff,
958 0x20100000, 0x008183ff, 0x29100000, 0x00a183ff,
959 0x31100000, 0x00c283ff, 0x39100000, 0x00e283ff,
960 0x41100000, 0x00008bff, 0x4a100000, 0x00208bff,
961 0x52100000, 0x00408bff, 0x5a100000, 0x00618bff,
962 0x62100000, 0x00818bff, 0x6a100000, 0x00a18bff,
963 0x73100000, 0x00c28bff, 0x7b100000, 0x00e28bff,
964 0x83100000, 0x000094ff, 0x8b100000, 0x002094ff,
965 0x94100000, 0x004094ff, 0x9c100000, 0x006194ff,
966 0xa4100000, 0x008194ff, 0xac100000, 0x00a194ff,
967 0xb4100000, 0x00c294ff, 0xbd100000, 0x00e294ff,
968 0xc5100000, 0x00009cff, 0xcd100000, 0x00209cff,
969 0xd5100000, 0x00409cff, 0xde100000, 0x00619cff,
970 0xe6100000, 0x00819cff, 0xee100000, 0x00a19cff,
971 0xf6100000, 0x00c29cff, 0xff100000, 0x00e29cff,
972 0x00140000, 0x0000a4ff, 0x08140000, 0x0020a4ff,
973 0x10140000, 0x0040a4ff, 0x18140000, 0x0061a4ff,
974 0x20140000, 0x0081a4ff, 0x29140000, 0x00a1a4ff,
975 0x31140000, 0x00c2a4ff, 0x39140000, 0x00e2a4ff,
976 0x41140000, 0x0000acff, 0x4a140000, 0x0020acff,
977 0x52140000, 0x0040acff, 0x5a140000, 0x0061acff,
978 0x62140000, 0x0081acff, 0x6a140000, 0x00a1acff,
979 0x73140000, 0x00c2acff, 0x7b140000, 0x00e2acff,
980 0x83140000, 0x0000b4ff, 0x8b140000, 0x0020b4ff,
981 0x94140000, 0x0040b4ff, 0x9c140000, 0x0061b4ff,
982 0xa4140000, 0x0081b4ff, 0xac140000, 0x00a1b4ff,
983 0xb4140000, 0x00c2b4ff, 0xbd140000, 0x00e2b4ff,
984 0xc5140000, 0x0000bdff, 0xcd140000, 0x0020bdff,
985 0xd5140000, 0x0040bdff, 0xde140000, 0x0061bdff,
986 0xe6140000, 0x0081bdff, 0xee140000, 0x00a1bdff,
987 0xf6140000, 0x00c2bdff, 0xff140000, 0x00e2bdff,
988 0x00180000, 0x0000c5ff, 0x08180000, 0x0020c5ff,
989 0x10180000, 0x0040c5ff, 0x18180000, 0x0061c5ff,
990 0x20180000, 0x0081c5ff, 0x29180000, 0x00a1c5ff,
991 0x31180000, 0x00c2c5ff, 0x39180000, 0x00e2c5ff,
992 0x41180000, 0x0000cdff, 0x4a180000, 0x0020cdff,
993 0x52180000, 0x0040cdff, 0x5a180000, 0x0061cdff,
994 0x62180000, 0x0081cdff, 0x6a180000, 0x00a1cdff,
995 0x73180000, 0x00c2cdff, 0x7b180000, 0x00e2cdff,
996 0x83180000, 0x0000d5ff, 0x8b180000, 0x0020d5ff,
997 0x94180000, 0x0040d5ff, 0x9c180000, 0x0061d5ff,
998 0xa4180000, 0x0081d5ff, 0xac180000, 0x00a1d5ff,
999 0xb4180000, 0x00c2d5ff, 0xbd180000, 0x00e2d5ff,
1000 0xc5180000, 0x0000deff, 0xcd180000, 0x0020deff,
1001 0xd5180000, 0x0040deff, 0xde180000, 0x0061deff,
1002 0xe6180000, 0x0081deff, 0xee180000, 0x00a1deff,
1003 0xf6180000, 0x00c2deff, 0xff180000, 0x00e2deff,
1004 0x001c0000, 0x0000e6ff, 0x081c0000, 0x0020e6ff,
1005 0x101c0000, 0x0040e6ff, 0x181c0000, 0x0061e6ff,
1006 0x201c0000, 0x0081e6ff, 0x291c0000, 0x00a1e6ff,
1007 0x311c0000, 0x00c2e6ff, 0x391c0000, 0x00e2e6ff,
1008 0x411c0000, 0x0000eeff, 0x4a1c0000, 0x0020eeff,
1009 0x521c0000, 0x0040eeff, 0x5a1c0000, 0x0061eeff,
1010 0x621c0000, 0x0081eeff, 0x6a1c0000, 0x00a1eeff,
1011 0x731c0000, 0x00c2eeff, 0x7b1c0000, 0x00e2eeff,
1012 0x831c0000, 0x0000f6ff, 0x8b1c0000, 0x0020f6ff,
1013 0x941c0000, 0x0040f6ff, 0x9c1c0000, 0x0061f6ff,
1014 0xa41c0000, 0x0081f6ff, 0xac1c0000, 0x00a1f6ff,
1015 0xb41c0000, 0x00c2f6ff, 0xbd1c0000, 0x00e2f6ff,
1016 0xc51c0000, 0x0000ffff, 0xcd1c0000, 0x0020ffff,
1017 0xd51c0000, 0x0040ffff, 0xde1c0000, 0x0061ffff,
1018 0xe61c0000, 0x0081ffff, 0xee1c0000, 0x00a1ffff,
1019 0xf61c0000, 0x00c2ffff, 0xff1c0000, 0x00e2ffff
1020 };
1021 static void Blit_RGB565_BGRA8888(SDL_BlitInfo *info)
1022 {
1023 Blit_RGB565_32(info, RGB565_BGRA8888_LUT);
1024 }
1025
1026 /* Special optimized blit for RGB 8-8-8 --> RGB 3-3-2 */
1027 #ifndef RGB888_RGB332
1028 #define RGB888_RGB332(dst, src) { \
1029 dst = (((src)&0x00E00000)>>16)| \
1030 (((src)&0x0000E000)>>11)| \
1031 (((src)&0x000000C0)>>6); \
1032 }
1033 #endif
1034 static void Blit_RGB888_index8_map(SDL_BlitInfo *info)
1035 {
1036 #ifndef USE_DUFFS_LOOP
1037 int c;
1038 #endif
1039 int pixel;
1040 int width, height;
1041 Uint32 *src;
1042 Uint8 *map, *dst;
1043 int srcskip, dstskip;
1044
1045 /* Set up some basic variables */
1046 width = info->d_width;
1047 height = info->d_height;
1048 src = (Uint32 *)info->s_pixels;
1049 srcskip = info->s_skip/4;
1050 dst = info->d_pixels;
1051 dstskip = info->d_skip;
1052 map = info->table;
1053
1054 #ifdef USE_DUFFS_LOOP
1055 while ( height-- ) {
1056 DUFFS_LOOP(
1057 RGB888_RGB332(pixel, *src);
1058 *dst++ = map[pixel];
1059 ++src;
1060 , width);
1061 src += srcskip;
1062 dst += dstskip;
1063 }
1064 #else
1065 while ( height-- ) {
1066 for ( c=width/4; c; --c ) {
1067 /* Pack RGB into 8bit pixel */
1068 RGB888_RGB332(pixel, *src);
1069 *dst++ = map[pixel];
1070 ++src;
1071 RGB888_RGB332(pixel, *src);
1072 *dst++ = map[pixel];
1073 ++src;
1074 RGB888_RGB332(pixel, *src);
1075 *dst++ = map[pixel];
1076 ++src;
1077 RGB888_RGB332(pixel, *src);
1078 *dst++ = map[pixel];
1079 ++src;
1080 }
1081 switch ( width % 4 ) {
1082 case 3:
1083 RGB888_RGB332(pixel, *src);
1084 *dst++ = map[pixel];
1085 ++src;
1086 case 2:
1087 RGB888_RGB332(pixel, *src);
1088 *dst++ = map[pixel];
1089 ++src;
1090 case 1:
1091 RGB888_RGB332(pixel, *src);
1092 *dst++ = map[pixel];
1093 ++src;
1094 }
1095 src += srcskip;
1096 dst += dstskip;
1097 }
1098 #endif /* USE_DUFFS_LOOP */
1099 }
1100 static void BlitNto1(SDL_BlitInfo *info)
1101 {
1102 #ifndef USE_DUFFS_LOOP
1103 int c;
1104 #endif
1105 int width, height;
1106 Uint8 *src, *map, *dst;
1107 int srcskip, dstskip;
1108 int srcbpp;
1109 Uint32 pixel;
1110 int sR, sG, sB;
1111 SDL_PixelFormat *srcfmt;
1112
1113 /* Set up some basic variables */
1114 width = info->d_width;
1115 height = info->d_height;
1116 src = info->s_pixels;
1117 srcskip = info->s_skip;
1118 dst = info->d_pixels;
1119 dstskip = info->d_skip;
1120 map = info->table;
1121 srcfmt = info->src;
1122 srcbpp = srcfmt->BytesPerPixel;
1123
1124 if ( map == NULL ) {
1125 while ( height-- ) {
1126 #ifdef USE_DUFFS_LOOP
1127 DUFFS_LOOP(
1128 DISEMBLE_RGB(src, srcbpp, srcfmt, pixel,
1129 sR, sG, sB);
1130 if ( 1 ) {
1131 /* Pack RGB into 8bit pixel */
1132 *dst = ((sR>>5)<<(3+2))|
1133 ((sG>>5)<<(2)) |
1134 ((sB>>6)<<(0)) ;
1135 }
1136 dst++;
1137 src += srcbpp;
1138 , width);
1139 #else
1140 for ( c=width; c; --c ) {
1141 DISEMBLE_RGB(src, srcbpp, srcfmt, pixel,
1142 sR, sG, sB);
1143 if ( 1 ) {
1144 /* Pack RGB into 8bit pixel */
1145 *dst = ((sR>>5)<<(3+2))|
1146 ((sG>>5)<<(2)) |
1147 ((sB>>6)<<(0)) ;
1148 }
1149 dst++;
1150 src += srcbpp;
1151 }
1152 #endif
1153 src += srcskip;
1154 dst += dstskip;
1155 }
1156 } else {
1157 while ( height-- ) {
1158 #ifdef USE_DUFFS_LOOP
1159 DUFFS_LOOP(
1160 DISEMBLE_RGB(src, srcbpp, srcfmt, pixel,
1161 sR, sG, sB);
1162 if ( 1 ) {
1163 /* Pack RGB into 8bit pixel */
1164 *dst = map[((sR>>5)<<(3+2))|
1165 ((sG>>5)<<(2)) |
1166 ((sB>>6)<<(0)) ];
1167 }
1168 dst++;
1169 src += srcbpp;
1170 , width);
1171 #else
1172 for ( c=width; c; --c ) {
1173 DISEMBLE_RGB(src, srcbpp, srcfmt, pixel,
1174 sR, sG, sB);
1175 if ( 1 ) {
1176 /* Pack RGB into 8bit pixel */
1177 *dst = map[((sR>>5)<<(3+2))|
1178 ((sG>>5)<<(2)) |
1179 ((sB>>6)<<(0)) ];
1180 }
1181 dst++;
1182 src += srcbpp;
1183 }
1184 #endif /* USE_DUFFS_LOOP */
1185 src += srcskip;
1186 dst += dstskip;
1187 }
1188 }
1189 }
1190 static void BlitNtoN(SDL_BlitInfo *info)
1191 {
1192 int width = info->d_width;
1193 int height = info->d_height;
1194 Uint8 *src = info->s_pixels;
1195 int srcskip = info->s_skip;
1196 Uint8 *dst = info->d_pixels;
1197 int dstskip = info->d_skip;
1198 SDL_PixelFormat *srcfmt = info->src;
1199 int srcbpp = srcfmt->BytesPerPixel;
1200 SDL_PixelFormat *dstfmt = info->dst;
1201 int dstbpp = dstfmt->BytesPerPixel;
1202 unsigned alpha = dstfmt->Amask ? SDL_ALPHA_OPAQUE : 0;
1203
1204 while ( height-- ) {
1205 DUFFS_LOOP(
1206 {
1207 Uint32 pixel;
1208 unsigned sR;
1209 unsigned sG;
1210 unsigned sB;
1211 DISEMBLE_RGB(src, srcbpp, srcfmt, pixel, sR, sG, sB);
1212 ASSEMBLE_RGBA(dst, dstbpp, dstfmt, sR, sG, sB, alpha);
1213 dst += dstbpp;
1214 src += srcbpp;
1215 },
1216 width);
1217 src += srcskip;
1218 dst += dstskip;
1219 }
1220 }
1221
1222 static void BlitNtoNCopyAlpha(SDL_BlitInfo *info)
1223 {
1224 int width = info->d_width;
1225 int height = info->d_height;
1226 Uint8 *src = info->s_pixels;
1227 int srcskip = info->s_skip;
1228 Uint8 *dst = info->d_pixels;
1229 int dstskip = info->d_skip;
1230 SDL_PixelFormat *srcfmt = info->src;
1231 int srcbpp = srcfmt->BytesPerPixel;
1232 SDL_PixelFormat *dstfmt = info->dst;
1233 int dstbpp = dstfmt->BytesPerPixel;
1234 int c;
1235
1236 /* FIXME: should map alpha to [0..255] correctly! */
1237 while ( height-- ) {
1238 for ( c=width; c; --c ) {
1239 Uint32 pixel;
1240 unsigned sR, sG, sB, sA;
1241 DISEMBLE_RGBA(src, srcbpp, srcfmt, pixel,
1242 sR, sG, sB, sA);
1243 ASSEMBLE_RGBA(dst, dstbpp, dstfmt,
1244 sR, sG, sB, sA);
1245 dst += dstbpp;
1246 src += srcbpp;
1247 }
1248 src += srcskip;
1249 dst += dstskip;
1250 }
1251 }
1252
1253 static void BlitNto1Key(SDL_BlitInfo *info)
1254 {
1255 int width = info->d_width;
1256 int height = info->d_height;
1257 Uint8 *src = info->s_pixels;
1258 int srcskip = info->s_skip;
1259 Uint8 *dst = info->d_pixels;
1260 int dstskip = info->d_skip;
1261 SDL_PixelFormat *srcfmt = info->src;
1262 Uint8 *palmap = info->table;
1263 Uint32 ckey = srcfmt->colorkey;
1264 Uint32 rgbmask = ~srcfmt->Amask;
1265 int srcbpp;
1266 Uint32 pixel;
1267 Uint8 sR, sG, sB;
1268
1269 /* Set up some basic variables */
1270 srcbpp = srcfmt->BytesPerPixel;
1271 ckey &= rgbmask;
1272
1273 if ( palmap == NULL ) {
1274 while ( height-- ) {
1275 DUFFS_LOOP(
1276 {
1277 DISEMBLE_RGB(src, srcbpp, srcfmt, pixel,
1278 sR, sG, sB);
1279 if ( (pixel & rgbmask) != ckey ) {
1280 /* Pack RGB into 8bit pixel */
1281 *dst = ((sR>>5)<<(3+2))|
1282 ((sG>>5)<<(2)) |
1283 ((sB>>6)<<(0)) ;
1284 }
1285 dst++;
1286 src += srcbpp;
1287 },
1288 width);
1289 src += srcskip;
1290 dst += dstskip;
1291 }
1292 } else {
1293 while ( height-- ) {
1294 DUFFS_LOOP(
1295 {
1296 DISEMBLE_RGB(src, srcbpp, srcfmt, pixel,
1297 sR, sG, sB);
1298 if ( (pixel & rgbmask) != ckey ) {
1299 /* Pack RGB into 8bit pixel */
1300 *dst = palmap[((sR>>5)<<(3+2))|
1301 ((sG>>5)<<(2)) |
1302 ((sB>>6)<<(0)) ];
1303 }
1304 dst++;
1305 src += srcbpp;
1306 },
1307 width);
1308 src += srcskip;
1309 dst += dstskip;
1310 }
1311 }
1312 }
1313
1314 static void Blit2to2Key(SDL_BlitInfo *info)
1315 {
1316 int width = info->d_width;
1317 int height = info->d_height;
1318 Uint16 *srcp = (Uint16 *)info->s_pixels;
1319 int srcskip = info->s_skip;
1320 Uint16 *dstp = (Uint16 *)info->d_pixels;
1321 int dstskip = info->d_skip;
1322 Uint32 ckey = info->src->colorkey;
1323 Uint32 rgbmask = ~info->src->Amask;
1324
1325 /* Set up some basic variables */
1326 srcskip /= 2;
1327 dstskip /= 2;
1328 ckey &= rgbmask;
1329
1330 while ( height-- ) {
1331 DUFFS_LOOP(
1332 {
1333 if ( (*srcp & rgbmask) != ckey ) {
1334 *dstp = *srcp;
1335 }
1336 dstp++;
1337 srcp++;
1338 },
1339 width);
1340 srcp += srcskip;
1341 dstp += dstskip;
1342 }
1343 }
1344
1345 static void BlitNtoNKey(SDL_BlitInfo *info)
1346 {
1347 int width = info->d_width;
1348 int height = info->d_height;
1349 Uint8 *src = info->s_pixels;
1350 int srcskip = info->s_skip;
1351 Uint8 *dst = info->d_pixels;
1352 int dstskip = info->d_skip;
1353 Uint32 ckey = info->src->colorkey;
1354 SDL_PixelFormat *srcfmt = info->src;
1355 SDL_PixelFormat *dstfmt = info->dst;
1356 int srcbpp = srcfmt->BytesPerPixel;
1357 int dstbpp = dstfmt->BytesPerPixel;
1358 unsigned alpha = dstfmt->Amask ? SDL_ALPHA_OPAQUE : 0;
1359
1360 while ( height-- ) {
1361 DUFFS_LOOP(
1362 {
1363 Uint32 pixel;
1364 unsigned sR;
1365 unsigned sG;
1366 unsigned sB;
1367 RETRIEVE_RGB_PIXEL(src, srcbpp, pixel);
1368 if ( pixel != ckey ) {
1369 RGB_FROM_PIXEL(pixel, srcfmt, sR, sG, sB);
1370 ASSEMBLE_RGBA(dst, dstbpp, dstfmt,
1371 sR, sG, sB, alpha);
1372 }
1373 dst += dstbpp;
1374 src += srcbpp;
1375 },
1376 width);
1377 src += srcskip;
1378 dst += dstskip;
1379 }
1380 }
1381
1382 static void BlitNtoNKeyCopyAlpha(SDL_BlitInfo *info)
1383 {
1384 int width = info->d_width;
1385 int height = info->d_height;
1386 Uint8 *src = info->s_pixels;
1387 int srcskip = info->s_skip;
1388 Uint8 *dst = info->d_pixels;
1389 int dstskip = info->d_skip;
1390 Uint32 ckey = info->src->colorkey;
1391 SDL_PixelFormat *srcfmt = info->src;
1392 SDL_PixelFormat *dstfmt = info->dst;
1393 Uint32 rgbmask = ~srcfmt->Amask;
1394
1395 Uint8 srcbpp;
1396 Uint8 dstbpp;
1397 Uint32 pixel;
1398 Uint8 sR, sG, sB, sA;
1399
1400 /* Set up some basic variables */
1401 srcbpp = srcfmt->BytesPerPixel;
1402 dstbpp = dstfmt->BytesPerPixel;
1403 ckey &= rgbmask;
1404
1405 /* FIXME: should map alpha to [0..255] correctly! */
1406 while ( height-- ) {
1407 DUFFS_LOOP(
1408 {
1409 DISEMBLE_RGBA(src, srcbpp, srcfmt, pixel,
1410 sR, sG, sB, sA);
1411 if ( (pixel & rgbmask) != ckey ) {
1412 ASSEMBLE_RGBA(dst, dstbpp, dstfmt,
1413 sR, sG, sB, sA);
1414 }
1415 dst += dstbpp;
1416 src += srcbpp;
1417 },
1418 width);
1419 src += srcskip;
1420 dst += dstskip;
1421 }
1422 }
1423
1424 /* Normal N to N optimized blitters */
1425 struct blit_table {
1426 Uint32 srcR, srcG, srcB;
1427 int dstbpp;
1428 Uint32 dstR, dstG, dstB;
1429 Uint32 cpu_flags;
1430 void *aux_data;
1431 SDL_loblit blitfunc;
1432 enum { NO_ALPHA, SET_ALPHA, COPY_ALPHA } alpha;
1433 };
1434 static struct blit_table normal_blit_1[] = {
1435 /* Default for 8-bit RGB source, an invalid combination */
1436 { 0,0,0, 0, 0,0,0, 0, NULL, NULL },
1437 };
1438 static struct blit_table normal_blit_2[] = {
1439 #ifdef USE_ASMBLIT
1440 { 0x0000F800,0x000007E0,0x0000001F, 2, 0x0000001F,0x000007E0,0x0000F800,
1441 0, ConvertX86p16_16BGR565, ConvertX86, NO_ALPHA },
1442 { 0x0000F800,0x000007E0,0x0000001F, 2, 0x00007C00,0x000003E0,0x0000001F,
1443 0, ConvertX86p16_16RGB555, ConvertX86, NO_ALPHA },
1444 { 0x0000F800,0x000007E0,0x0000001F, 2, 0x0000001F,0x000003E0,0x00007C00,
1445 0, ConvertX86p16_16BGR555, ConvertX86, NO_ALPHA },
1446 #endif
1447 { 0x0000F800,0x000007E0,0x0000001F, 4, 0x00FF0000,0x0000FF00,0x000000FF,
1448 0, NULL, Blit_RGB565_ARGB8888, SET_ALPHA },
1449 { 0x0000F800,0x000007E0,0x0000001F, 4, 0x000000FF,0x0000FF00,0x00FF0000,
1450 0, NULL, Blit_RGB565_ABGR8888, SET_ALPHA },
1451 { 0x0000F800,0x000007E0,0x0000001F, 4, 0xFF000000,0x00FF0000,0x0000FF00,
1452 0, NULL, Blit_RGB565_RGBA8888, SET_ALPHA },
1453 { 0x0000F800,0x000007E0,0x0000001F, 4, 0x0000FF00,0x00FF0000,0xFF000000,
1454 0, NULL, Blit_RGB565_BGRA8888, SET_ALPHA },
1455
1456 /* Default for 16-bit RGB source, used if no other blitter matches */
1457 { 0,0,0, 0, 0,0,0, 0, NULL, BlitNtoN, 0 }
1458 };
1459 static struct blit_table normal_blit_3[] = {
1460 /* Default for 24-bit RGB source, never optimized */
1461 { 0,0,0, 0, 0,0,0, 0, NULL, BlitNtoN, 0 }
1462 };
1463 static struct blit_table normal_blit_4[] = {
1464 #ifdef USE_ASMBLIT
1465 { 0x00FF0000,0x0000FF00,0x000000FF, 2, 0x0000F800,0x000007E0,0x0000001F,
1466 MMX_CPU, ConvertMMXpII32_16RGB565, ConvertMMX, NO_ALPHA },
1467 { 0x00FF0000,0x0000FF00,0x000000FF, 2, 0x0000F800,0x000007E0,0x0000001F,
1468 0, ConvertX86p32_16RGB565, ConvertX86, NO_ALPHA },
1469 { 0x00FF0000,0x0000FF00,0x000000FF, 2, 0x0000001F,0x000007E0,0x0000F800,
1470 MMX_CPU, ConvertMMXpII32_16BGR565, ConvertMMX, NO_ALPHA },
1471 { 0x00FF0000,0x0000FF00,0x000000FF, 2, 0x0000001F,0x000007E0,0x0000F800,
1472 0, ConvertX86p32_16BGR565, ConvertX86, NO_ALPHA },
1473 { 0x00FF0000,0x0000FF00,0x000000FF, 2, 0x00007C00,0x000003E0,0x0000001F,
1474 MMX_CPU, ConvertMMXpII32_16RGB555, ConvertMMX, NO_ALPHA },
1475 { 0x00FF0000,0x0000FF00,0x000000FF, 2, 0x00007C00,0x000003E0,0x0000001F,
1476 0, ConvertX86p32_16RGB555, ConvertX86, NO_ALPHA },
1477 { 0x00FF0000,0x0000FF00,0x000000FF, 2, 0x0000001F,0x000003E0,0x00007C00,
1478 MMX_CPU, ConvertMMXpII32_16BGR555, ConvertMMX, NO_ALPHA },
1479 { 0x00FF0000,0x0000FF00,0x000000FF, 2, 0x0000001F,0x000003E0,0x00007C00,
1480 0, ConvertX86p32_16BGR555, ConvertX86, NO_ALPHA },
1481 { 0x00FF0000,0x0000FF00,0x000000FF, 3, 0x00FF0000,0x0000FF00,0x000000FF,
1482 0, ConvertX86p32_24RGB888, ConvertX86, NO_ALPHA },
1483 { 0x00FF0000,0x0000FF00,0x000000FF, 3, 0x000000FF,0x0000FF00,0x00FF0000,
1484 0, ConvertX86p32_24BGR888, ConvertX86, NO_ALPHA },
1485 { 0x00FF0000,0x0000FF00,0x000000FF, 4, 0x000000FF,0x0000FF00,0x00FF0000,
1486 0, ConvertX86p32_32BGR888, ConvertX86, NO_ALPHA },
1487 { 0x00FF0000,0x0000FF00,0x000000FF, 4, 0xFF000000,0x00FF0000,0x0000FF00,
1488 0, ConvertX86p32_32RGBA888, ConvertX86, NO_ALPHA },
1489 { 0x00FF0000,0x0000FF00,0x000000FF, 4, 0x0000FF00,0x00FF0000,0xFF000000,
1490 0, ConvertX86p32_32BGRA888, ConvertX86, NO_ALPHA },
1491 #else
1492 { 0x00FF0000,0x0000FF00,0x000000FF, 2, 0x0000F800,0x000007E0,0x0000001F,
1493 0, NULL, Blit_RGB888_RGB565, NO_ALPHA },
1494 { 0x00FF0000,0x0000FF00,0x000000FF, 2, 0x00007C00,0x000003E0,0x0000001F,
1495 0, NULL, Blit_RGB888_RGB555, NO_ALPHA },
1496 #endif
1497 /* Default for 32-bit RGB source, used if no other blitter matches */
1498 { 0,0,0, 0, 0,0,0, 0, NULL, BlitNtoN, 0 }
1499 };
1500 static struct blit_table *normal_blit[] = {
1501 normal_blit_1, normal_blit_2, normal_blit_3, normal_blit_4
1502 };
1503
1504 SDL_loblit SDL_CalculateBlitN(SDL_Surface *surface, int blit_index)
1505 {
1506 struct private_swaccel *sdata;
1507 SDL_PixelFormat *srcfmt;
1508 SDL_PixelFormat *dstfmt;
1509 struct blit_table *table;
1510 int which;
1511 SDL_loblit blitfun;
1512
1513 /* Set up data for choosing the blit */
1514 sdata = surface->map->sw_data;
1515 srcfmt = surface->format;
1516 dstfmt = surface->map->dst->format;
1517
1518 if ( blit_index & 2 ) {
1519 /* alpha or alpha+colorkey */
1520 return SDL_CalculateAlphaBlit(surface, blit_index);
1521 }
1522
1523 /* We don't support destinations less than 8-bits */
1524 if ( dstfmt->BitsPerPixel < 8 ) {
1525 return(NULL);
1526 }
1527
1528 if(blit_index == 1) {
1529 /* colorkey blit: Here we don't have too many options, mostly
1530 because RLE is the preferred fast way to deal with this.
1531 If a particular case turns out to be useful we'll add it. */
1532
1533 if(srcfmt->BytesPerPixel == 2
1534 && surface->map->identity)
1535 return Blit2to2Key;
1536 else if(dstfmt->BytesPerPixel == 1)
1537 return BlitNto1Key;
1538 else {
1539 if(srcfmt->Amask && dstfmt->Amask)
1540 return BlitNtoNKeyCopyAlpha;
1541 else
1542 return BlitNtoNKey;
1543 }
1544 }
1545
1546 blitfun = NULL;
1547 if ( dstfmt->BitsPerPixel == 8 ) {
1548 /* We assume 8-bit destinations are palettized */
1549 if ( (srcfmt->BytesPerPixel == 4) &&
1550 (srcfmt->Rmask == 0x00FF0000) &&
1551 (srcfmt->Gmask == 0x0000FF00) &&
1552 (srcfmt->Bmask == 0x000000FF) ) {
1553 if ( surface->map->table ) {
1554 blitfun = Blit_RGB888_index8_map;
1555 } else {
1556 #ifdef USE_ASMBLIT
1557 sdata->aux_data = ConvertX86p32_8RGB332;
1558 blitfun = ConvertX86;
1559 #else
1560 blitfun = Blit_RGB888_index8;
1561 #endif
1562 }
1563 } else {
1564 blitfun = BlitNto1;
1565 }
1566 } else {
1567 /* Now the meat, choose the blitter we want */
1568 int a_need = 0;
1569 if(dstfmt->Amask)
1570 a_need = srcfmt->Amask ? COPY_ALPHA : SET_ALPHA;
1571 table = normal_blit[srcfmt->BytesPerPixel-1];
1572 for ( which=0; table[which].srcR; ++which ) {
1573 if ( srcfmt->Rmask == table[which].srcR &&
1574 srcfmt->Gmask == table[which].srcG &&
1575 srcfmt->Bmask == table[which].srcB &&
1576 dstfmt->BytesPerPixel == table[which].dstbpp &&
1577 dstfmt->Rmask == table[which].dstR &&
1578 dstfmt->Gmask == table[which].dstG &&
1579 dstfmt->Bmask == table[which].dstB &&
1580 (a_need & table[which].alpha) == a_need &&
1581 (CPU_Flags()&table[which].cpu_flags) ==
1582 table[which].cpu_flags )
1583 break;
1584 }
1585 sdata->aux_data = table[which].aux_data;
1586 blitfun = table[which].blitfunc;
1587 if(a_need == COPY_ALPHA && blitfun == BlitNtoN)
1588 blitfun = BlitNtoNCopyAlpha;
1589 }
1590
1591 #ifdef DEBUG_ASM
1592 #ifdef USE_ASMBLIT
1593 if ( blitfun == ConvertMMX )
1594 fprintf(stderr, "Using mmx blit\n");
1595 else
1596 if ( blitfun == ConvertX86 )
1597 fprintf(stderr, "Using asm blit\n");
1598 else
1599 #endif
1600 if ( (blitfun == SDL_BlitNtoN) || (blitfun == SDL_BlitNto1) )
1601 fprintf(stderr, "Using C blit\n");
1602 else
1603 fprintf(stderr, "Using optimized C blit\n");
1604 #endif /* DEBUG_ASM */
1605
1606 return(blitfun);
1607 }