2 SDL - Simple DirectMedia Layer
3 Copyright (C) 1997-2009 Sam Lantinga
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.
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.
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
22 #include "SDL_config.h"
24 #include "SDL_video.h"
25 #include "SDL_endian.h"
26 #include "SDL_cpuinfo.h"
29 /* Functions to blit from N-bit surfaces to other surfaces */
31 #if SDL_ALTIVEC_BLITTERS
33 #pragma altivec_model on
40 #include <sys/sysctl.h>
41 static size_t GetL3CacheSize( void )
43 const char key[] = "hw.l3cachesize";
45 size_t typeSize = sizeof( result );
48 int err = sysctlbyname( key, &result, &typeSize, NULL, 0 );
49 if( 0 != err ) return 0;
54 static size_t GetL3CacheSize( void )
56 /* XXX: Just guess G4 */
59 #endif /* __MACOSX__ */
61 #if (defined(__MACOSX__) && (__GNUC__ < 4))
62 #define VECUINT8_LITERAL(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p) \
63 (vector unsigned char) ( a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p )
64 #define VECUINT16_LITERAL(a,b,c,d,e,f,g,h) \
65 (vector unsigned short) ( a,b,c,d,e,f,g,h )
67 #define VECUINT8_LITERAL(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p) \
68 (vector unsigned char) { a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p }
69 #define VECUINT16_LITERAL(a,b,c,d,e,f,g,h) \
70 (vector unsigned short) { a,b,c,d,e,f,g,h }
73 #define UNALIGNED_PTR(x) (((size_t) x) & 0x0000000F)
74 #define VSWIZZLE32(a,b,c,d) (vector unsigned char) \
75 ( 0x00+a, 0x00+b, 0x00+c, 0x00+d, \
76 0x04+a, 0x04+b, 0x04+c, 0x04+d, \
77 0x08+a, 0x08+b, 0x08+c, 0x08+d, \
78 0x0C+a, 0x0C+b, 0x0C+c, 0x0C+d )
80 #define MAKE8888(dstfmt, r, g, b, a) \
81 ( ((r<<dstfmt->Rshift)&dstfmt->Rmask) | \
82 ((g<<dstfmt->Gshift)&dstfmt->Gmask) | \
83 ((b<<dstfmt->Bshift)&dstfmt->Bmask) | \
84 ((a<<dstfmt->Ashift)&dstfmt->Amask) )
87 * Data Stream Touch...Altivec cache prefetching.
89 * Don't use this on a G5...however, the speed boost is very significant
92 #define DST_CHAN_SRC 1
93 #define DST_CHAN_DEST 2
95 /* macro to set DST control word value... */
96 #define DST_CTRL(size, count, stride) \
97 (((size) << 24) | ((count) << 16) | (stride))
99 #define VEC_ALIGNER(src) ((UNALIGNED_PTR(src)) \
101 : vec_add(vec_lvsl(8, src), vec_splat_u8(8)))
103 /* Calculate the permute vector used for 32->32 swizzling */
104 static vector unsigned char calc_swizzle32(const SDL_PixelFormat *srcfmt,
105 const SDL_PixelFormat *dstfmt)
108 * We have to assume that the bits that aren't used by other
109 * colors is alpha, and it's one complete byte, since some formats
110 * leave alpha with a zero mask, but we should still swizzle the bits.
113 const static struct SDL_PixelFormat default_pixel_format = {
117 0x00FF0000, 0x0000FF00, 0x000000FF, 0xFF000000,
120 srcfmt = &default_pixel_format;
123 dstfmt = &default_pixel_format;
125 const vector unsigned char plus = VECUINT8_LITERAL(
126 0x00, 0x00, 0x00, 0x00,
127 0x04, 0x04, 0x04, 0x04,
128 0x08, 0x08, 0x08, 0x08,
129 0x0C, 0x0C, 0x0C, 0x0C );
130 vector unsigned char vswiz;
131 vector unsigned int srcvec;
132 #define RESHIFT(X) (3 - ((X) >> 3))
133 Uint32 rmask = RESHIFT(srcfmt->Rshift) << (dstfmt->Rshift);
134 Uint32 gmask = RESHIFT(srcfmt->Gshift) << (dstfmt->Gshift);
135 Uint32 bmask = RESHIFT(srcfmt->Bshift) << (dstfmt->Bshift);
137 /* Use zero for alpha if either surface doesn't have alpha */
139 amask = ((srcfmt->Amask) ? RESHIFT(srcfmt->Ashift) : 0x10) << (dstfmt->Ashift);
141 amask = 0x10101010 & ((dstfmt->Rmask | dstfmt->Gmask | dstfmt->Bmask) ^ 0xFFFFFFFF);
144 ((unsigned int *)(char*)&srcvec)[0] = (rmask | gmask | bmask | amask);
145 vswiz = vec_add(plus, (vector unsigned char)vec_splat(srcvec, 0));
149 static void Blit_RGB888_RGB565(SDL_BlitInfo *info);
150 static void Blit_RGB888_RGB565Altivec(SDL_BlitInfo *info) {
151 int height = info->d_height;
152 Uint8 *src = (Uint8 *) info->s_pixels;
153 int srcskip = info->s_skip;
154 Uint8 *dst = (Uint8 *) info->d_pixels;
155 int dstskip = info->d_skip;
156 SDL_PixelFormat *srcfmt = info->src;
157 vector unsigned char valpha = vec_splat_u8(0);
158 vector unsigned char vpermute = calc_swizzle32(srcfmt, NULL);
159 vector unsigned char vgmerge = VECUINT8_LITERAL(
160 0x00, 0x02, 0x00, 0x06,
161 0x00, 0x0a, 0x00, 0x0e,
162 0x00, 0x12, 0x00, 0x16,
163 0x00, 0x1a, 0x00, 0x1e);
164 vector unsigned short v1 = vec_splat_u16(1);
165 vector unsigned short v3 = vec_splat_u16(3);
166 vector unsigned short v3f = VECUINT16_LITERAL(
167 0x003f, 0x003f, 0x003f, 0x003f,
168 0x003f, 0x003f, 0x003f, 0x003f);
169 vector unsigned short vfc = VECUINT16_LITERAL(
170 0x00fc, 0x00fc, 0x00fc, 0x00fc,
171 0x00fc, 0x00fc, 0x00fc, 0x00fc);
172 vector unsigned short vf800 = (vector unsigned short)vec_splat_u8(-7);
173 vf800 = vec_sl(vf800, vec_splat_u16(8));
176 vector unsigned char valigner;
177 vector unsigned char voverflow;
178 vector unsigned char vsrc;
180 int width = info->d_width;
183 /* do scalar until we can align... */
184 #define ONE_PIXEL_BLEND(condition, widthvar) \
185 while (condition) { \
187 unsigned sR, sG, sB, sA; \
188 DISEMBLE_RGBA((Uint8 *)src, 4, srcfmt, Pixel, \
190 *(Uint16 *)(dst) = (((sR << 8) & 0x0000F800) | \
191 ((sG << 3) & 0x000007E0) | \
192 ((sB >> 3) & 0x0000001F)); \
198 ONE_PIXEL_BLEND(((UNALIGNED_PTR(dst)) && (width)), width);
200 /* After all that work, here's the vector part! */
201 extrawidth = (width % 8); /* trailing unaligned stores */
203 vsrc = vec_ld(0, src);
204 valigner = VEC_ALIGNER(src);
207 vector unsigned short vpixel, vrpixel, vgpixel, vbpixel;
208 vector unsigned int vsrc1, vsrc2;
209 vector unsigned char vdst;
211 voverflow = vec_ld(15, src);
212 vsrc = vec_perm(vsrc, voverflow, valigner);
213 vsrc1 = (vector unsigned int)vec_perm(vsrc, valpha, vpermute);
216 voverflow = vec_ld(15, src);
217 vsrc = vec_perm(vsrc, voverflow, valigner);
218 vsrc2 = (vector unsigned int)vec_perm(vsrc, valpha, vpermute);
220 vpixel = (vector unsigned short)vec_packpx(vsrc1, vsrc2);
221 vgpixel = (vector unsigned short)vec_perm(vsrc1, vsrc2, vgmerge);
222 vgpixel = vec_and(vgpixel, vfc);
223 vgpixel = vec_sl(vgpixel, v3);
224 vrpixel = vec_sl(vpixel, v1);
225 vrpixel = vec_and(vrpixel, vf800);
226 vbpixel = vec_and(vpixel, v3f);
227 vdst = vec_or((vector unsigned char)vrpixel, (vector unsigned char)vgpixel);
229 vdst = vec_or(vdst, (vector unsigned char)vbpixel);
230 vec_st(vdst, 0, dst);
240 /* do scalar until we can align... */
241 ONE_PIXEL_BLEND((extrawidth), extrawidth);
242 #undef ONE_PIXEL_BLEND
244 src += srcskip; /* move to next row, accounting for pitch. */
251 static void Blit_RGB565_32Altivec(SDL_BlitInfo *info) {
252 int height = info->d_height;
253 Uint8 *src = (Uint8 *) info->s_pixels;
254 int srcskip = info->s_skip;
255 Uint8 *dst = (Uint8 *) info->d_pixels;
256 int dstskip = info->d_skip;
257 SDL_PixelFormat *srcfmt = info->src;
258 SDL_PixelFormat *dstfmt = info->dst;
260 vector unsigned char valpha;
261 vector unsigned char vpermute;
262 vector unsigned short vf800;
263 vector unsigned int v8 = vec_splat_u32(8);
264 vector unsigned int v16 = vec_add(v8, v8);
265 vector unsigned short v2 = vec_splat_u16(2);
266 vector unsigned short v3 = vec_splat_u16(3);
268 0x10 - 0x1f is the alpha
269 0x00 - 0x0e evens are the red
270 0x01 - 0x0f odds are zero
272 vector unsigned char vredalpha1 = VECUINT8_LITERAL(
273 0x10, 0x00, 0x01, 0x01,
274 0x10, 0x02, 0x01, 0x01,
275 0x10, 0x04, 0x01, 0x01,
276 0x10, 0x06, 0x01, 0x01
278 vector unsigned char vredalpha2 = (vector unsigned char) (
279 vec_add((vector unsigned int)vredalpha1, vec_sl(v8, v16))
282 0x00 - 0x0f is ARxx ARxx ARxx ARxx
283 0x11 - 0x0f odds are blue
285 vector unsigned char vblue1 = VECUINT8_LITERAL(
286 0x00, 0x01, 0x02, 0x11,
287 0x04, 0x05, 0x06, 0x13,
288 0x08, 0x09, 0x0a, 0x15,
289 0x0c, 0x0d, 0x0e, 0x17
291 vector unsigned char vblue2 = (vector unsigned char)(
292 vec_add((vector unsigned int)vblue1, v8)
295 0x00 - 0x0f is ARxB ARxB ARxB ARxB
296 0x10 - 0x0e evens are green
298 vector unsigned char vgreen1 = VECUINT8_LITERAL(
299 0x00, 0x01, 0x10, 0x03,
300 0x04, 0x05, 0x12, 0x07,
301 0x08, 0x09, 0x14, 0x0b,
302 0x0c, 0x0d, 0x16, 0x0f
304 vector unsigned char vgreen2 = (vector unsigned char)(
305 vec_add((vector unsigned int)vgreen1, vec_sl(v8, v8))
309 assert(srcfmt->BytesPerPixel == 2);
310 assert(dstfmt->BytesPerPixel == 4);
312 vf800 = (vector unsigned short)vec_splat_u8(-7);
313 vf800 = vec_sl(vf800, vec_splat_u16(8));
315 if (dstfmt->Amask && srcfmt->alpha) {
316 ((unsigned char *)&valpha)[0] = alpha = srcfmt->alpha;
317 valpha = vec_splat(valpha, 0);
320 valpha = vec_splat_u8(0);
323 vpermute = calc_swizzle32(NULL, dstfmt);
325 vector unsigned char valigner;
326 vector unsigned char voverflow;
327 vector unsigned char vsrc;
329 int width = info->d_width;
332 /* do scalar until we can align... */
333 #define ONE_PIXEL_BLEND(condition, widthvar) \
334 while (condition) { \
335 unsigned sR, sG, sB; \
336 unsigned short Pixel = *((unsigned short *)src); \
337 sR = (Pixel >> 8) & 0xf8; \
338 sG = (Pixel >> 3) & 0xfc; \
339 sB = (Pixel << 3) & 0xf8; \
340 ASSEMBLE_RGBA(dst, 4, dstfmt, sR, sG, sB, alpha); \
345 ONE_PIXEL_BLEND(((UNALIGNED_PTR(dst)) && (width)), width);
347 /* After all that work, here's the vector part! */
348 extrawidth = (width % 8); /* trailing unaligned stores */
350 vsrc = vec_ld(0, src);
351 valigner = VEC_ALIGNER(src);
354 vector unsigned short vR, vG, vB;
355 vector unsigned char vdst1, vdst2;
357 voverflow = vec_ld(15, src);
358 vsrc = vec_perm(vsrc, voverflow, valigner);
360 vR = vec_and((vector unsigned short)vsrc, vf800);
361 vB = vec_sl((vector unsigned short)vsrc, v3);
364 vdst1 = (vector unsigned char)vec_perm((vector unsigned char)vR, valpha, vredalpha1);
365 vdst1 = vec_perm(vdst1, (vector unsigned char)vB, vblue1);
366 vdst1 = vec_perm(vdst1, (vector unsigned char)vG, vgreen1);
367 vdst1 = vec_perm(vdst1, valpha, vpermute);
368 vec_st(vdst1, 0, dst);
370 vdst2 = (vector unsigned char)vec_perm((vector unsigned char)vR, valpha, vredalpha2);
371 vdst2 = vec_perm(vdst2, (vector unsigned char)vB, vblue2);
372 vdst2 = vec_perm(vdst2, (vector unsigned char)vG, vgreen2);
373 vdst2 = vec_perm(vdst2, valpha, vpermute);
374 vec_st(vdst2, 16, dst);
385 /* do scalar until we can align... */
386 ONE_PIXEL_BLEND((extrawidth), extrawidth);
387 #undef ONE_PIXEL_BLEND
389 src += srcskip; /* move to next row, accounting for pitch. */
396 static void Blit_RGB555_32Altivec(SDL_BlitInfo *info) {
397 int height = info->d_height;
398 Uint8 *src = (Uint8 *) info->s_pixels;
399 int srcskip = info->s_skip;
400 Uint8 *dst = (Uint8 *) info->d_pixels;
401 int dstskip = info->d_skip;
402 SDL_PixelFormat *srcfmt = info->src;
403 SDL_PixelFormat *dstfmt = info->dst;
405 vector unsigned char valpha;
406 vector unsigned char vpermute;
407 vector unsigned short vf800;
408 vector unsigned int v8 = vec_splat_u32(8);
409 vector unsigned int v16 = vec_add(v8, v8);
410 vector unsigned short v1 = vec_splat_u16(1);
411 vector unsigned short v3 = vec_splat_u16(3);
413 0x10 - 0x1f is the alpha
414 0x00 - 0x0e evens are the red
415 0x01 - 0x0f odds are zero
417 vector unsigned char vredalpha1 = VECUINT8_LITERAL(
418 0x10, 0x00, 0x01, 0x01,
419 0x10, 0x02, 0x01, 0x01,
420 0x10, 0x04, 0x01, 0x01,
421 0x10, 0x06, 0x01, 0x01
423 vector unsigned char vredalpha2 = (vector unsigned char)(
424 vec_add((vector unsigned int)vredalpha1, vec_sl(v8, v16))
427 0x00 - 0x0f is ARxx ARxx ARxx ARxx
428 0x11 - 0x0f odds are blue
430 vector unsigned char vblue1 = VECUINT8_LITERAL(
431 0x00, 0x01, 0x02, 0x11,
432 0x04, 0x05, 0x06, 0x13,
433 0x08, 0x09, 0x0a, 0x15,
434 0x0c, 0x0d, 0x0e, 0x17
436 vector unsigned char vblue2 = (vector unsigned char)(
437 vec_add((vector unsigned int)vblue1, v8)
440 0x00 - 0x0f is ARxB ARxB ARxB ARxB
441 0x10 - 0x0e evens are green
443 vector unsigned char vgreen1 = VECUINT8_LITERAL(
444 0x00, 0x01, 0x10, 0x03,
445 0x04, 0x05, 0x12, 0x07,
446 0x08, 0x09, 0x14, 0x0b,
447 0x0c, 0x0d, 0x16, 0x0f
449 vector unsigned char vgreen2 = (vector unsigned char)(
450 vec_add((vector unsigned int)vgreen1, vec_sl(v8, v8))
454 assert(srcfmt->BytesPerPixel == 2);
455 assert(dstfmt->BytesPerPixel == 4);
457 vf800 = (vector unsigned short)vec_splat_u8(-7);
458 vf800 = vec_sl(vf800, vec_splat_u16(8));
460 if (dstfmt->Amask && srcfmt->alpha) {
461 ((unsigned char *)&valpha)[0] = alpha = srcfmt->alpha;
462 valpha = vec_splat(valpha, 0);
465 valpha = vec_splat_u8(0);
468 vpermute = calc_swizzle32(NULL, dstfmt);
470 vector unsigned char valigner;
471 vector unsigned char voverflow;
472 vector unsigned char vsrc;
474 int width = info->d_width;
477 /* do scalar until we can align... */
478 #define ONE_PIXEL_BLEND(condition, widthvar) \
479 while (condition) { \
480 unsigned sR, sG, sB; \
481 unsigned short Pixel = *((unsigned short *)src); \
482 sR = (Pixel >> 7) & 0xf8; \
483 sG = (Pixel >> 2) & 0xf8; \
484 sB = (Pixel << 3) & 0xf8; \
485 ASSEMBLE_RGBA(dst, 4, dstfmt, sR, sG, sB, alpha); \
490 ONE_PIXEL_BLEND(((UNALIGNED_PTR(dst)) && (width)), width);
492 /* After all that work, here's the vector part! */
493 extrawidth = (width % 8); /* trailing unaligned stores */
495 vsrc = vec_ld(0, src);
496 valigner = VEC_ALIGNER(src);
499 vector unsigned short vR, vG, vB;
500 vector unsigned char vdst1, vdst2;
502 voverflow = vec_ld(15, src);
503 vsrc = vec_perm(vsrc, voverflow, valigner);
505 vR = vec_and(vec_sl((vector unsigned short)vsrc,v1), vf800);
506 vB = vec_sl((vector unsigned short)vsrc, v3);
509 vdst1 = (vector unsigned char)vec_perm((vector unsigned char)vR, valpha, vredalpha1);
510 vdst1 = vec_perm(vdst1, (vector unsigned char)vB, vblue1);
511 vdst1 = vec_perm(vdst1, (vector unsigned char)vG, vgreen1);
512 vdst1 = vec_perm(vdst1, valpha, vpermute);
513 vec_st(vdst1, 0, dst);
515 vdst2 = (vector unsigned char)vec_perm((vector unsigned char)vR, valpha, vredalpha2);
516 vdst2 = vec_perm(vdst2, (vector unsigned char)vB, vblue2);
517 vdst2 = vec_perm(vdst2, (vector unsigned char)vG, vgreen2);
518 vdst2 = vec_perm(vdst2, valpha, vpermute);
519 vec_st(vdst2, 16, dst);
530 /* do scalar until we can align... */
531 ONE_PIXEL_BLEND((extrawidth), extrawidth);
532 #undef ONE_PIXEL_BLEND
534 src += srcskip; /* move to next row, accounting for pitch. */
540 static void BlitNtoNKey(SDL_BlitInfo *info);
541 static void BlitNtoNKeyCopyAlpha(SDL_BlitInfo *info);
542 static void Blit32to32KeyAltivec(SDL_BlitInfo *info)
544 int height = info->d_height;
545 Uint32 *srcp = (Uint32 *) info->s_pixels;
546 int srcskip = info->s_skip;
547 Uint32 *dstp = (Uint32 *) info->d_pixels;
548 int dstskip = info->d_skip;
549 SDL_PixelFormat *srcfmt = info->src;
550 int srcbpp = srcfmt->BytesPerPixel;
551 SDL_PixelFormat *dstfmt = info->dst;
552 int dstbpp = dstfmt->BytesPerPixel;
553 int copy_alpha = (srcfmt->Amask && dstfmt->Amask);
554 unsigned alpha = dstfmt->Amask ? srcfmt->alpha : 0;
555 Uint32 rgbmask = srcfmt->Rmask | srcfmt->Gmask | srcfmt->Bmask;
556 Uint32 ckey = info->src->colorkey;
557 vector unsigned int valpha;
558 vector unsigned char vpermute;
559 vector unsigned char vzero;
560 vector unsigned int vckey;
561 vector unsigned int vrgbmask;
562 vpermute = calc_swizzle32(srcfmt, dstfmt);
563 if (info->d_width < 16) {
565 BlitNtoNKeyCopyAlpha(info);
571 vzero = vec_splat_u8(0);
573 ((unsigned char *)&valpha)[0] = (unsigned char)alpha;
574 valpha = (vector unsigned int)vec_splat((vector unsigned char)valpha, 0);
576 valpha = (vector unsigned int)vzero;
579 ((unsigned int *)(char*)&vckey)[0] = ckey;
580 vckey = vec_splat(vckey, 0);
581 ((unsigned int *)(char*)&vrgbmask)[0] = rgbmask;
582 vrgbmask = vec_splat(vrgbmask, 0);
585 #define ONE_PIXEL_BLEND(condition, widthvar) \
587 while (condition) { \
589 unsigned sR, sG, sB, sA; \
590 DISEMBLE_RGBA((Uint8 *)srcp, srcbpp, srcfmt, Pixel, \
592 if ( (Pixel & rgbmask) != ckey ) { \
593 ASSEMBLE_RGBA((Uint8 *)dstp, dstbpp, dstfmt, \
596 dstp = (Uint32 *) (((Uint8 *) dstp) + dstbpp); \
597 srcp = (Uint32 *) (((Uint8 *) srcp) + srcbpp); \
601 while (condition) { \
603 unsigned sR, sG, sB; \
604 RETRIEVE_RGB_PIXEL((Uint8 *)srcp, srcbpp, Pixel); \
605 if ( Pixel != ckey ) { \
606 RGB_FROM_PIXEL(Pixel, srcfmt, sR, sG, sB); \
607 ASSEMBLE_RGBA((Uint8 *)dstp, dstbpp, dstfmt, \
608 sR, sG, sB, alpha); \
610 dstp = (Uint32 *) (((Uint8 *)dstp) + dstbpp); \
611 srcp = (Uint32 *) (((Uint8 *)srcp) + srcbpp); \
615 int width = info->d_width;
616 ONE_PIXEL_BLEND((UNALIGNED_PTR(dstp)) && (width), width);
619 int extrawidth = (width % 4);
620 vector unsigned char valigner = VEC_ALIGNER(srcp);
621 vector unsigned int vs = vec_ld(0, srcp);
625 vector unsigned char vsel;
626 vector unsigned int vd;
627 vector unsigned int voverflow = vec_ld(15, srcp);
628 /* load the source vec */
629 vs = vec_perm(vs, voverflow, valigner);
630 /* vsel is set for items that match the key */
631 vsel = (vector unsigned char)vec_and(vs, vrgbmask);
632 vsel = (vector unsigned char)vec_cmpeq(vs, vckey);
633 /* permute the src vec to the dest format */
634 vs = vec_perm(vs, valpha, vpermute);
635 /* load the destination vec */
636 vd = vec_ld(0, dstp);
637 /* select the source and dest into vs */
638 vd = (vector unsigned int)vec_sel((vector unsigned char)vs, (vector unsigned char)vd, vsel);
646 ONE_PIXEL_BLEND((extrawidth), extrawidth);
647 #undef ONE_PIXEL_BLEND
648 srcp += srcskip >> 2;
649 dstp += dstskip >> 2;
654 /* Altivec code to swizzle one 32-bit surface to a different 32-bit format. */
655 /* Use this on a G5 */
656 static void ConvertAltivec32to32_noprefetch(SDL_BlitInfo *info)
658 int height = info->d_height;
659 Uint32 *src = (Uint32 *) info->s_pixels;
660 int srcskip = info->s_skip;
661 Uint32 *dst = (Uint32 *) info->d_pixels;
662 int dstskip = info->d_skip;
663 SDL_PixelFormat *srcfmt = info->src;
664 SDL_PixelFormat *dstfmt = info->dst;
665 vector unsigned int vzero = vec_splat_u32(0);
666 vector unsigned char vpermute = calc_swizzle32(srcfmt, dstfmt);
667 if (dstfmt->Amask && !srcfmt->Amask) {
669 vector unsigned char valpha;
670 ((unsigned char *)&valpha)[0] = srcfmt->alpha;
671 vzero = (vector unsigned int)vec_splat(valpha, 0);
675 assert(srcfmt->BytesPerPixel == 4);
676 assert(dstfmt->BytesPerPixel == 4);
679 vector unsigned char valigner;
680 vector unsigned int vbits;
681 vector unsigned int voverflow;
685 int width = info->d_width;
688 /* do scalar until we can align... */
689 while ((UNALIGNED_PTR(dst)) && (width)) {
691 RGBA_FROM_8888(bits, srcfmt, r, g, b, a);
692 *(dst++) = MAKE8888(dstfmt, r, g, b, a);
696 /* After all that work, here's the vector part! */
697 extrawidth = (width % 4);
699 valigner = VEC_ALIGNER(src);
700 vbits = vec_ld(0, src);
703 voverflow = vec_ld(15, src);
706 vbits = vec_perm(vbits, voverflow, valigner); /* src is ready. */
707 vbits = vec_perm(vbits, vzero, vpermute); /* swizzle it. */
708 vec_st(vbits, 0, dst); /* store it back out. */
715 /* cover pixels at the end of the row that didn't fit in 16 bytes. */
717 bits = *(src++); /* max 7 pixels, don't bother with prefetch. */
718 RGBA_FROM_8888(bits, srcfmt, r, g, b, a);
719 *(dst++) = MAKE8888(dstfmt, r, g, b, a);
723 src += srcskip >> 2; /* move to next row, accounting for pitch. */
729 /* Altivec code to swizzle one 32-bit surface to a different 32-bit format. */
730 /* Use this on a G4 */
731 static void ConvertAltivec32to32_prefetch(SDL_BlitInfo *info)
733 const int scalar_dst_lead = sizeof (Uint32) * 4;
734 const int vector_dst_lead = sizeof (Uint32) * 16;
736 int height = info->d_height;
737 Uint32 *src = (Uint32 *) info->s_pixels;
738 int srcskip = info->s_skip;
739 Uint32 *dst = (Uint32 *) info->d_pixels;
740 int dstskip = info->d_skip;
741 SDL_PixelFormat *srcfmt = info->src;
742 SDL_PixelFormat *dstfmt = info->dst;
743 vector unsigned int vzero = vec_splat_u32(0);
744 vector unsigned char vpermute = calc_swizzle32(srcfmt, dstfmt);
745 if (dstfmt->Amask && !srcfmt->Amask) {
747 vector unsigned char valpha;
748 ((unsigned char *)&valpha)[0] = srcfmt->alpha;
749 vzero = (vector unsigned int)vec_splat(valpha, 0);
753 assert(srcfmt->BytesPerPixel == 4);
754 assert(dstfmt->BytesPerPixel == 4);
757 vector unsigned char valigner;
758 vector unsigned int vbits;
759 vector unsigned int voverflow;
763 int width = info->d_width;
766 /* do scalar until we can align... */
767 while ((UNALIGNED_PTR(dst)) && (width)) {
768 vec_dstt(src+scalar_dst_lead, DST_CTRL(2,32,1024), DST_CHAN_SRC);
769 vec_dstst(dst+scalar_dst_lead, DST_CTRL(2,32,1024), DST_CHAN_DEST);
771 RGBA_FROM_8888(bits, srcfmt, r, g, b, a);
772 *(dst++) = MAKE8888(dstfmt, r, g, b, a);
776 /* After all that work, here's the vector part! */
777 extrawidth = (width % 4);
779 valigner = VEC_ALIGNER(src);
780 vbits = vec_ld(0, src);
783 vec_dstt(src+vector_dst_lead, DST_CTRL(2,32,1024), DST_CHAN_SRC);
784 vec_dstst(dst+vector_dst_lead, DST_CTRL(2,32,1024), DST_CHAN_DEST);
785 voverflow = vec_ld(15, src);
788 vbits = vec_perm(vbits, voverflow, valigner); /* src is ready. */
789 vbits = vec_perm(vbits, vzero, vpermute); /* swizzle it. */
790 vec_st(vbits, 0, dst); /* store it back out. */
797 /* cover pixels at the end of the row that didn't fit in 16 bytes. */
799 bits = *(src++); /* max 7 pixels, don't bother with prefetch. */
800 RGBA_FROM_8888(bits, srcfmt, r, g, b, a);
801 *(dst++) = MAKE8888(dstfmt, r, g, b, a);
805 src += srcskip >> 2; /* move to next row, accounting for pitch. */
809 vec_dss(DST_CHAN_SRC);
810 vec_dss(DST_CHAN_DEST);
813 static Uint32 GetBlitFeatures( void )
815 static Uint32 features = 0xffffffff;
816 if (features == 0xffffffff) {
817 /* Provide an override for testing .. */
818 char *override = SDL_getenv("SDL_ALTIVEC_BLIT_FEATURES");
821 SDL_sscanf(override, "%u", &features);
824 /* Feature 1 is has-MMX */
825 | ((SDL_HasMMX()) ? 1 : 0)
826 /* Feature 2 is has-AltiVec */
827 | ((SDL_HasAltiVec()) ? 2 : 0)
828 /* Feature 4 is dont-use-prefetch */
829 /* !!!! FIXME: Check for G5 or later, not the cache size! Always prefetch on a G4. */
830 | ((GetL3CacheSize() == 0) ? 4 : 0)
837 #pragma altivec_model off
840 /* Feature 1 is has-MMX */
841 #define GetBlitFeatures() ((Uint32)(SDL_HasMMX() ? 1 : 0))
844 /* This is now endian dependent */
845 #if SDL_BYTEORDER == SDL_LIL_ENDIAN
848 #else /* SDL_BYTEORDER == SDL_BIG_ENDIAN */
853 #if SDL_HERMES_BLITTERS
855 /* Heheheh, we coerce Hermes into using SDL blit information */
856 #define X86_ASSEMBLER
857 #define HermesConverterInterface SDL_BlitInfo
858 #define HermesClearInterface void
861 #include "../hermes/HeadMMX.h"
862 #include "../hermes/HeadX86.h"
866 /* Special optimized blit for RGB 8-8-8 --> RGB 3-3-2 */
867 #define RGB888_RGB332(dst, src) { \
868 dst = (Uint8)((((src)&0x00E00000)>>16)| \
869 (((src)&0x0000E000)>>11)| \
870 (((src)&0x000000C0)>>6)); \
872 static void Blit_RGB888_index8(SDL_BlitInfo *info)
874 #ifndef USE_DUFFS_LOOP
881 int srcskip, dstskip;
883 /* Set up some basic variables */
884 width = info->d_width;
885 height = info->d_height;
886 src = (Uint32 *)info->s_pixels;
887 srcskip = info->s_skip/4;
888 dst = info->d_pixels;
889 dstskip = info->d_skip;
894 #ifdef USE_DUFFS_LOOP
896 RGB888_RGB332(*dst++, *src);
899 for ( c=width/4; c; --c ) {
900 /* Pack RGB into 8bit pixel */
902 RGB888_RGB332(*dst++, *src);
904 RGB888_RGB332(*dst++, *src);
906 RGB888_RGB332(*dst++, *src);
909 switch ( width & 3 ) {
911 RGB888_RGB332(*dst++, *src);
914 RGB888_RGB332(*dst++, *src);
917 RGB888_RGB332(*dst++, *src);
920 #endif /* USE_DUFFS_LOOP */
928 #ifdef USE_DUFFS_LOOP
930 RGB888_RGB332(Pixel, *src);
935 for ( c=width/4; c; --c ) {
936 /* Pack RGB into 8bit pixel */
937 RGB888_RGB332(Pixel, *src);
940 RGB888_RGB332(Pixel, *src);
943 RGB888_RGB332(Pixel, *src);
946 RGB888_RGB332(Pixel, *src);
950 switch ( width & 3 ) {
952 RGB888_RGB332(Pixel, *src);
956 RGB888_RGB332(Pixel, *src);
960 RGB888_RGB332(Pixel, *src);
964 #endif /* USE_DUFFS_LOOP */
970 /* Special optimized blit for RGB 8-8-8 --> RGB 5-5-5 */
971 #define RGB888_RGB555(dst, src) { \
972 *(Uint16 *)(dst) = (Uint16)((((*src)&0x00F80000)>>9)| \
973 (((*src)&0x0000F800)>>6)| \
974 (((*src)&0x000000F8)>>3)); \
976 #define RGB888_RGB555_TWO(dst, src) { \
977 *(Uint32 *)(dst) = (((((src[HI])&0x00F80000)>>9)| \
978 (((src[HI])&0x0000F800)>>6)| \
979 (((src[HI])&0x000000F8)>>3))<<16)| \
980 (((src[LO])&0x00F80000)>>9)| \
981 (((src[LO])&0x0000F800)>>6)| \
982 (((src[LO])&0x000000F8)>>3); \
984 static void Blit_RGB888_RGB555(SDL_BlitInfo *info)
986 #ifndef USE_DUFFS_LOOP
992 int srcskip, dstskip;
994 /* Set up some basic variables */
995 width = info->d_width;
996 height = info->d_height;
997 src = (Uint32 *)info->s_pixels;
998 srcskip = info->s_skip/4;
999 dst = (Uint16 *)info->d_pixels;
1000 dstskip = info->d_skip/2;
1002 #ifdef USE_DUFFS_LOOP
1003 while ( height-- ) {
1005 RGB888_RGB555(dst, src);
1013 /* Memory align at 4-byte boundary, if necessary */
1014 if ( (long)dst & 0x03 ) {
1015 /* Don't do anything if width is 0 */
1021 while ( height-- ) {
1022 /* Perform copy alignment */
1023 RGB888_RGB555(dst, src);
1027 /* Copy in 4 pixel chunks */
1028 for ( c=width/4; c; --c ) {
1029 RGB888_RGB555_TWO(dst, src);
1032 RGB888_RGB555_TWO(dst, src);
1036 /* Get any leftovers */
1037 switch (width & 3) {
1039 RGB888_RGB555(dst, src);
1043 RGB888_RGB555_TWO(dst, src);
1048 RGB888_RGB555(dst, src);
1057 while ( height-- ) {
1058 /* Copy in 4 pixel chunks */
1059 for ( c=width/4; c; --c ) {
1060 RGB888_RGB555_TWO(dst, src);
1063 RGB888_RGB555_TWO(dst, src);
1067 /* Get any leftovers */
1068 switch (width & 3) {
1070 RGB888_RGB555(dst, src);
1074 RGB888_RGB555_TWO(dst, src);
1079 RGB888_RGB555(dst, src);
1088 #endif /* USE_DUFFS_LOOP */
1090 /* Special optimized blit for RGB 8-8-8 --> RGB 5-6-5 */
1091 #define RGB888_RGB565(dst, src) { \
1092 *(Uint16 *)(dst) = (Uint16)((((*src)&0x00F80000)>>8)| \
1093 (((*src)&0x0000FC00)>>5)| \
1094 (((*src)&0x000000F8)>>3)); \
1096 #define RGB888_RGB565_TWO(dst, src) { \
1097 *(Uint32 *)(dst) = (((((src[HI])&0x00F80000)>>8)| \
1098 (((src[HI])&0x0000FC00)>>5)| \
1099 (((src[HI])&0x000000F8)>>3))<<16)| \
1100 (((src[LO])&0x00F80000)>>8)| \
1101 (((src[LO])&0x0000FC00)>>5)| \
1102 (((src[LO])&0x000000F8)>>3); \
1104 static void Blit_RGB888_RGB565(SDL_BlitInfo *info)
1106 #ifndef USE_DUFFS_LOOP
1112 int srcskip, dstskip;
1114 /* Set up some basic variables */
1115 width = info->d_width;
1116 height = info->d_height;
1117 src = (Uint32 *)info->s_pixels;
1118 srcskip = info->s_skip/4;
1119 dst = (Uint16 *)info->d_pixels;
1120 dstskip = info->d_skip/2;
1122 #ifdef USE_DUFFS_LOOP
1123 while ( height-- ) {
1125 RGB888_RGB565(dst, src);
1133 /* Memory align at 4-byte boundary, if necessary */
1134 if ( (long)dst & 0x03 ) {
1135 /* Don't do anything if width is 0 */
1141 while ( height-- ) {
1142 /* Perform copy alignment */
1143 RGB888_RGB565(dst, src);
1147 /* Copy in 4 pixel chunks */
1148 for ( c=width/4; c; --c ) {
1149 RGB888_RGB565_TWO(dst, src);
1152 RGB888_RGB565_TWO(dst, src);
1156 /* Get any leftovers */
1157 switch (width & 3) {
1159 RGB888_RGB565(dst, src);
1163 RGB888_RGB565_TWO(dst, src);
1168 RGB888_RGB565(dst, src);
1177 while ( height-- ) {
1178 /* Copy in 4 pixel chunks */
1179 for ( c=width/4; c; --c ) {
1180 RGB888_RGB565_TWO(dst, src);
1183 RGB888_RGB565_TWO(dst, src);
1187 /* Get any leftovers */
1188 switch (width & 3) {
1190 RGB888_RGB565(dst, src);
1194 RGB888_RGB565_TWO(dst, src);
1199 RGB888_RGB565(dst, src);
1208 #endif /* USE_DUFFS_LOOP */
1211 #endif /* SDL_HERMES_BLITTERS */
1215 /* NEON optimized blitter callers */
1216 #define make_neon_caller(name, neon_name) \
1217 extern void neon_name(void *dst, const void *src, int count, unsigned int abits); \
1218 static void name(SDL_BlitInfo *info) \
1220 int width = info->d_width; \
1221 int height = info->d_height; \
1222 Uint8 *src = info->s_pixels; \
1223 Uint8 *dst = info->d_pixels; \
1224 int srcskip = info->s_skip; \
1225 int dstskip = info->d_skip; \
1226 unsigned int abits = info->dst->Amask ? 0xff : 0; \
1228 while ( height-- ) { \
1229 neon_name(dst, src, width, abits); \
1230 src += width * 4 + srcskip; \
1231 dst += width * 4 + dstskip; \
1235 make_neon_caller(BlitABGRtoXRGB_neon, neon_ABGRtoXRGB)
1236 make_neon_caller(BlitARGBtoXRGB_neon, neon_ARGBtoXRGB)
1238 #endif /* __ARM_NEON__ */
1241 /* Special optimized blit for RGB 5-6-5 --> 32-bit RGB surfaces */
1242 #define RGB565_32(dst, src, map) (map[src[LO]*2] + map[src[HI]*2+1])
1243 static void Blit_RGB565_32(SDL_BlitInfo *info, const Uint32 *map)
1245 #ifndef USE_DUFFS_LOOP
1251 int srcskip, dstskip;
1253 /* Set up some basic variables */
1254 width = info->d_width;
1255 height = info->d_height;
1256 src = (Uint8 *)info->s_pixels;
1257 srcskip = info->s_skip;
1258 dst = (Uint32 *)info->d_pixels;
1259 dstskip = info->d_skip/4;
1261 #ifdef USE_DUFFS_LOOP
1262 while ( height-- ) {
1265 *dst++ = RGB565_32(dst, src, map);
1273 while ( height-- ) {
1274 /* Copy in 4 pixel chunks */
1275 for ( c=width/4; c; --c ) {
1276 *dst++ = RGB565_32(dst, src, map);
1278 *dst++ = RGB565_32(dst, src, map);
1280 *dst++ = RGB565_32(dst, src, map);
1282 *dst++ = RGB565_32(dst, src, map);
1285 /* Get any leftovers */
1286 switch (width & 3) {
1288 *dst++ = RGB565_32(dst, src, map);
1291 *dst++ = RGB565_32(dst, src, map);
1294 *dst++ = RGB565_32(dst, src, map);
1301 #endif /* USE_DUFFS_LOOP */
1304 /* Special optimized blit for RGB 5-6-5 --> ARGB 8-8-8-8 */
1305 static const Uint32 RGB565_ARGB8888_LUT[512] = {
1306 0x00000000, 0xff000000, 0x00000008, 0xff002000,
1307 0x00000010, 0xff004000, 0x00000018, 0xff006100,
1308 0x00000020, 0xff008100, 0x00000029, 0xff00a100,
1309 0x00000031, 0xff00c200, 0x00000039, 0xff00e200,
1310 0x00000041, 0xff080000, 0x0000004a, 0xff082000,
1311 0x00000052, 0xff084000, 0x0000005a, 0xff086100,
1312 0x00000062, 0xff088100, 0x0000006a, 0xff08a100,
1313 0x00000073, 0xff08c200, 0x0000007b, 0xff08e200,
1314 0x00000083, 0xff100000, 0x0000008b, 0xff102000,
1315 0x00000094, 0xff104000, 0x0000009c, 0xff106100,
1316 0x000000a4, 0xff108100, 0x000000ac, 0xff10a100,
1317 0x000000b4, 0xff10c200, 0x000000bd, 0xff10e200,
1318 0x000000c5, 0xff180000, 0x000000cd, 0xff182000,
1319 0x000000d5, 0xff184000, 0x000000de, 0xff186100,
1320 0x000000e6, 0xff188100, 0x000000ee, 0xff18a100,
1321 0x000000f6, 0xff18c200, 0x000000ff, 0xff18e200,
1322 0x00000400, 0xff200000, 0x00000408, 0xff202000,
1323 0x00000410, 0xff204000, 0x00000418, 0xff206100,
1324 0x00000420, 0xff208100, 0x00000429, 0xff20a100,
1325 0x00000431, 0xff20c200, 0x00000439, 0xff20e200,
1326 0x00000441, 0xff290000, 0x0000044a, 0xff292000,
1327 0x00000452, 0xff294000, 0x0000045a, 0xff296100,
1328 0x00000462, 0xff298100, 0x0000046a, 0xff29a100,
1329 0x00000473, 0xff29c200, 0x0000047b, 0xff29e200,
1330 0x00000483, 0xff310000, 0x0000048b, 0xff312000,
1331 0x00000494, 0xff314000, 0x0000049c, 0xff316100,
1332 0x000004a4, 0xff318100, 0x000004ac, 0xff31a100,
1333 0x000004b4, 0xff31c200, 0x000004bd, 0xff31e200,
1334 0x000004c5, 0xff390000, 0x000004cd, 0xff392000,
1335 0x000004d5, 0xff394000, 0x000004de, 0xff396100,
1336 0x000004e6, 0xff398100, 0x000004ee, 0xff39a100,
1337 0x000004f6, 0xff39c200, 0x000004ff, 0xff39e200,
1338 0x00000800, 0xff410000, 0x00000808, 0xff412000,
1339 0x00000810, 0xff414000, 0x00000818, 0xff416100,
1340 0x00000820, 0xff418100, 0x00000829, 0xff41a100,
1341 0x00000831, 0xff41c200, 0x00000839, 0xff41e200,
1342 0x00000841, 0xff4a0000, 0x0000084a, 0xff4a2000,
1343 0x00000852, 0xff4a4000, 0x0000085a, 0xff4a6100,
1344 0x00000862, 0xff4a8100, 0x0000086a, 0xff4aa100,
1345 0x00000873, 0xff4ac200, 0x0000087b, 0xff4ae200,
1346 0x00000883, 0xff520000, 0x0000088b, 0xff522000,
1347 0x00000894, 0xff524000, 0x0000089c, 0xff526100,
1348 0x000008a4, 0xff528100, 0x000008ac, 0xff52a100,
1349 0x000008b4, 0xff52c200, 0x000008bd, 0xff52e200,
1350 0x000008c5, 0xff5a0000, 0x000008cd, 0xff5a2000,
1351 0x000008d5, 0xff5a4000, 0x000008de, 0xff5a6100,
1352 0x000008e6, 0xff5a8100, 0x000008ee, 0xff5aa100,
1353 0x000008f6, 0xff5ac200, 0x000008ff, 0xff5ae200,
1354 0x00000c00, 0xff620000, 0x00000c08, 0xff622000,
1355 0x00000c10, 0xff624000, 0x00000c18, 0xff626100,
1356 0x00000c20, 0xff628100, 0x00000c29, 0xff62a100,
1357 0x00000c31, 0xff62c200, 0x00000c39, 0xff62e200,
1358 0x00000c41, 0xff6a0000, 0x00000c4a, 0xff6a2000,
1359 0x00000c52, 0xff6a4000, 0x00000c5a, 0xff6a6100,
1360 0x00000c62, 0xff6a8100, 0x00000c6a, 0xff6aa100,
1361 0x00000c73, 0xff6ac200, 0x00000c7b, 0xff6ae200,
1362 0x00000c83, 0xff730000, 0x00000c8b, 0xff732000,
1363 0x00000c94, 0xff734000, 0x00000c9c, 0xff736100,
1364 0x00000ca4, 0xff738100, 0x00000cac, 0xff73a100,
1365 0x00000cb4, 0xff73c200, 0x00000cbd, 0xff73e200,
1366 0x00000cc5, 0xff7b0000, 0x00000ccd, 0xff7b2000,
1367 0x00000cd5, 0xff7b4000, 0x00000cde, 0xff7b6100,
1368 0x00000ce6, 0xff7b8100, 0x00000cee, 0xff7ba100,
1369 0x00000cf6, 0xff7bc200, 0x00000cff, 0xff7be200,
1370 0x00001000, 0xff830000, 0x00001008, 0xff832000,
1371 0x00001010, 0xff834000, 0x00001018, 0xff836100,
1372 0x00001020, 0xff838100, 0x00001029, 0xff83a100,
1373 0x00001031, 0xff83c200, 0x00001039, 0xff83e200,
1374 0x00001041, 0xff8b0000, 0x0000104a, 0xff8b2000,
1375 0x00001052, 0xff8b4000, 0x0000105a, 0xff8b6100,
1376 0x00001062, 0xff8b8100, 0x0000106a, 0xff8ba100,
1377 0x00001073, 0xff8bc200, 0x0000107b, 0xff8be200,
1378 0x00001083, 0xff940000, 0x0000108b, 0xff942000,
1379 0x00001094, 0xff944000, 0x0000109c, 0xff946100,
1380 0x000010a4, 0xff948100, 0x000010ac, 0xff94a100,
1381 0x000010b4, 0xff94c200, 0x000010bd, 0xff94e200,
1382 0x000010c5, 0xff9c0000, 0x000010cd, 0xff9c2000,
1383 0x000010d5, 0xff9c4000, 0x000010de, 0xff9c6100,
1384 0x000010e6, 0xff9c8100, 0x000010ee, 0xff9ca100,
1385 0x000010f6, 0xff9cc200, 0x000010ff, 0xff9ce200,
1386 0x00001400, 0xffa40000, 0x00001408, 0xffa42000,
1387 0x00001410, 0xffa44000, 0x00001418, 0xffa46100,
1388 0x00001420, 0xffa48100, 0x00001429, 0xffa4a100,
1389 0x00001431, 0xffa4c200, 0x00001439, 0xffa4e200,
1390 0x00001441, 0xffac0000, 0x0000144a, 0xffac2000,
1391 0x00001452, 0xffac4000, 0x0000145a, 0xffac6100,
1392 0x00001462, 0xffac8100, 0x0000146a, 0xffaca100,
1393 0x00001473, 0xffacc200, 0x0000147b, 0xfface200,
1394 0x00001483, 0xffb40000, 0x0000148b, 0xffb42000,
1395 0x00001494, 0xffb44000, 0x0000149c, 0xffb46100,
1396 0x000014a4, 0xffb48100, 0x000014ac, 0xffb4a100,
1397 0x000014b4, 0xffb4c200, 0x000014bd, 0xffb4e200,
1398 0x000014c5, 0xffbd0000, 0x000014cd, 0xffbd2000,
1399 0x000014d5, 0xffbd4000, 0x000014de, 0xffbd6100,
1400 0x000014e6, 0xffbd8100, 0x000014ee, 0xffbda100,
1401 0x000014f6, 0xffbdc200, 0x000014ff, 0xffbde200,
1402 0x00001800, 0xffc50000, 0x00001808, 0xffc52000,
1403 0x00001810, 0xffc54000, 0x00001818, 0xffc56100,
1404 0x00001820, 0xffc58100, 0x00001829, 0xffc5a100,
1405 0x00001831, 0xffc5c200, 0x00001839, 0xffc5e200,
1406 0x00001841, 0xffcd0000, 0x0000184a, 0xffcd2000,
1407 0x00001852, 0xffcd4000, 0x0000185a, 0xffcd6100,
1408 0x00001862, 0xffcd8100, 0x0000186a, 0xffcda100,
1409 0x00001873, 0xffcdc200, 0x0000187b, 0xffcde200,
1410 0x00001883, 0xffd50000, 0x0000188b, 0xffd52000,
1411 0x00001894, 0xffd54000, 0x0000189c, 0xffd56100,
1412 0x000018a4, 0xffd58100, 0x000018ac, 0xffd5a100,
1413 0x000018b4, 0xffd5c200, 0x000018bd, 0xffd5e200,
1414 0x000018c5, 0xffde0000, 0x000018cd, 0xffde2000,
1415 0x000018d5, 0xffde4000, 0x000018de, 0xffde6100,
1416 0x000018e6, 0xffde8100, 0x000018ee, 0xffdea100,
1417 0x000018f6, 0xffdec200, 0x000018ff, 0xffdee200,
1418 0x00001c00, 0xffe60000, 0x00001c08, 0xffe62000,
1419 0x00001c10, 0xffe64000, 0x00001c18, 0xffe66100,
1420 0x00001c20, 0xffe68100, 0x00001c29, 0xffe6a100,
1421 0x00001c31, 0xffe6c200, 0x00001c39, 0xffe6e200,
1422 0x00001c41, 0xffee0000, 0x00001c4a, 0xffee2000,
1423 0x00001c52, 0xffee4000, 0x00001c5a, 0xffee6100,
1424 0x00001c62, 0xffee8100, 0x00001c6a, 0xffeea100,
1425 0x00001c73, 0xffeec200, 0x00001c7b, 0xffeee200,
1426 0x00001c83, 0xfff60000, 0x00001c8b, 0xfff62000,
1427 0x00001c94, 0xfff64000, 0x00001c9c, 0xfff66100,
1428 0x00001ca4, 0xfff68100, 0x00001cac, 0xfff6a100,
1429 0x00001cb4, 0xfff6c200, 0x00001cbd, 0xfff6e200,
1430 0x00001cc5, 0xffff0000, 0x00001ccd, 0xffff2000,
1431 0x00001cd5, 0xffff4000, 0x00001cde, 0xffff6100,
1432 0x00001ce6, 0xffff8100, 0x00001cee, 0xffffa100,
1433 0x00001cf6, 0xffffc200, 0x00001cff, 0xffffe200
1435 static void Blit_RGB565_ARGB8888(SDL_BlitInfo *info)
1437 Blit_RGB565_32(info, RGB565_ARGB8888_LUT);
1440 /* Special optimized blit for RGB 5-6-5 --> ABGR 8-8-8-8 */
1441 static const Uint32 RGB565_ABGR8888_LUT[512] = {
1442 0xff000000, 0x00000000, 0xff080000, 0x00002000,
1443 0xff100000, 0x00004000, 0xff180000, 0x00006100,
1444 0xff200000, 0x00008100, 0xff290000, 0x0000a100,
1445 0xff310000, 0x0000c200, 0xff390000, 0x0000e200,
1446 0xff410000, 0x00000008, 0xff4a0000, 0x00002008,
1447 0xff520000, 0x00004008, 0xff5a0000, 0x00006108,
1448 0xff620000, 0x00008108, 0xff6a0000, 0x0000a108,
1449 0xff730000, 0x0000c208, 0xff7b0000, 0x0000e208,
1450 0xff830000, 0x00000010, 0xff8b0000, 0x00002010,
1451 0xff940000, 0x00004010, 0xff9c0000, 0x00006110,
1452 0xffa40000, 0x00008110, 0xffac0000, 0x0000a110,
1453 0xffb40000, 0x0000c210, 0xffbd0000, 0x0000e210,
1454 0xffc50000, 0x00000018, 0xffcd0000, 0x00002018,
1455 0xffd50000, 0x00004018, 0xffde0000, 0x00006118,
1456 0xffe60000, 0x00008118, 0xffee0000, 0x0000a118,
1457 0xfff60000, 0x0000c218, 0xffff0000, 0x0000e218,
1458 0xff000400, 0x00000020, 0xff080400, 0x00002020,
1459 0xff100400, 0x00004020, 0xff180400, 0x00006120,
1460 0xff200400, 0x00008120, 0xff290400, 0x0000a120,
1461 0xff310400, 0x0000c220, 0xff390400, 0x0000e220,
1462 0xff410400, 0x00000029, 0xff4a0400, 0x00002029,
1463 0xff520400, 0x00004029, 0xff5a0400, 0x00006129,
1464 0xff620400, 0x00008129, 0xff6a0400, 0x0000a129,
1465 0xff730400, 0x0000c229, 0xff7b0400, 0x0000e229,
1466 0xff830400, 0x00000031, 0xff8b0400, 0x00002031,
1467 0xff940400, 0x00004031, 0xff9c0400, 0x00006131,
1468 0xffa40400, 0x00008131, 0xffac0400, 0x0000a131,
1469 0xffb40400, 0x0000c231, 0xffbd0400, 0x0000e231,
1470 0xffc50400, 0x00000039, 0xffcd0400, 0x00002039,
1471 0xffd50400, 0x00004039, 0xffde0400, 0x00006139,
1472 0xffe60400, 0x00008139, 0xffee0400, 0x0000a139,
1473 0xfff60400, 0x0000c239, 0xffff0400, 0x0000e239,
1474 0xff000800, 0x00000041, 0xff080800, 0x00002041,
1475 0xff100800, 0x00004041, 0xff180800, 0x00006141,
1476 0xff200800, 0x00008141, 0xff290800, 0x0000a141,
1477 0xff310800, 0x0000c241, 0xff390800, 0x0000e241,
1478 0xff410800, 0x0000004a, 0xff4a0800, 0x0000204a,
1479 0xff520800, 0x0000404a, 0xff5a0800, 0x0000614a,
1480 0xff620800, 0x0000814a, 0xff6a0800, 0x0000a14a,
1481 0xff730800, 0x0000c24a, 0xff7b0800, 0x0000e24a,
1482 0xff830800, 0x00000052, 0xff8b0800, 0x00002052,
1483 0xff940800, 0x00004052, 0xff9c0800, 0x00006152,
1484 0xffa40800, 0x00008152, 0xffac0800, 0x0000a152,
1485 0xffb40800, 0x0000c252, 0xffbd0800, 0x0000e252,
1486 0xffc50800, 0x0000005a, 0xffcd0800, 0x0000205a,
1487 0xffd50800, 0x0000405a, 0xffde0800, 0x0000615a,
1488 0xffe60800, 0x0000815a, 0xffee0800, 0x0000a15a,
1489 0xfff60800, 0x0000c25a, 0xffff0800, 0x0000e25a,
1490 0xff000c00, 0x00000062, 0xff080c00, 0x00002062,
1491 0xff100c00, 0x00004062, 0xff180c00, 0x00006162,
1492 0xff200c00, 0x00008162, 0xff290c00, 0x0000a162,
1493 0xff310c00, 0x0000c262, 0xff390c00, 0x0000e262,
1494 0xff410c00, 0x0000006a, 0xff4a0c00, 0x0000206a,
1495 0xff520c00, 0x0000406a, 0xff5a0c00, 0x0000616a,
1496 0xff620c00, 0x0000816a, 0xff6a0c00, 0x0000a16a,
1497 0xff730c00, 0x0000c26a, 0xff7b0c00, 0x0000e26a,
1498 0xff830c00, 0x00000073, 0xff8b0c00, 0x00002073,
1499 0xff940c00, 0x00004073, 0xff9c0c00, 0x00006173,
1500 0xffa40c00, 0x00008173, 0xffac0c00, 0x0000a173,
1501 0xffb40c00, 0x0000c273, 0xffbd0c00, 0x0000e273,
1502 0xffc50c00, 0x0000007b, 0xffcd0c00, 0x0000207b,
1503 0xffd50c00, 0x0000407b, 0xffde0c00, 0x0000617b,
1504 0xffe60c00, 0x0000817b, 0xffee0c00, 0x0000a17b,
1505 0xfff60c00, 0x0000c27b, 0xffff0c00, 0x0000e27b,
1506 0xff001000, 0x00000083, 0xff081000, 0x00002083,
1507 0xff101000, 0x00004083, 0xff181000, 0x00006183,
1508 0xff201000, 0x00008183, 0xff291000, 0x0000a183,
1509 0xff311000, 0x0000c283, 0xff391000, 0x0000e283,
1510 0xff411000, 0x0000008b, 0xff4a1000, 0x0000208b,
1511 0xff521000, 0x0000408b, 0xff5a1000, 0x0000618b,
1512 0xff621000, 0x0000818b, 0xff6a1000, 0x0000a18b,
1513 0xff731000, 0x0000c28b, 0xff7b1000, 0x0000e28b,
1514 0xff831000, 0x00000094, 0xff8b1000, 0x00002094,
1515 0xff941000, 0x00004094, 0xff9c1000, 0x00006194,
1516 0xffa41000, 0x00008194, 0xffac1000, 0x0000a194,
1517 0xffb41000, 0x0000c294, 0xffbd1000, 0x0000e294,
1518 0xffc51000, 0x0000009c, 0xffcd1000, 0x0000209c,
1519 0xffd51000, 0x0000409c, 0xffde1000, 0x0000619c,
1520 0xffe61000, 0x0000819c, 0xffee1000, 0x0000a19c,
1521 0xfff61000, 0x0000c29c, 0xffff1000, 0x0000e29c,
1522 0xff001400, 0x000000a4, 0xff081400, 0x000020a4,
1523 0xff101400, 0x000040a4, 0xff181400, 0x000061a4,
1524 0xff201400, 0x000081a4, 0xff291400, 0x0000a1a4,
1525 0xff311400, 0x0000c2a4, 0xff391400, 0x0000e2a4,
1526 0xff411400, 0x000000ac, 0xff4a1400, 0x000020ac,
1527 0xff521400, 0x000040ac, 0xff5a1400, 0x000061ac,
1528 0xff621400, 0x000081ac, 0xff6a1400, 0x0000a1ac,
1529 0xff731400, 0x0000c2ac, 0xff7b1400, 0x0000e2ac,
1530 0xff831400, 0x000000b4, 0xff8b1400, 0x000020b4,
1531 0xff941400, 0x000040b4, 0xff9c1400, 0x000061b4,
1532 0xffa41400, 0x000081b4, 0xffac1400, 0x0000a1b4,
1533 0xffb41400, 0x0000c2b4, 0xffbd1400, 0x0000e2b4,
1534 0xffc51400, 0x000000bd, 0xffcd1400, 0x000020bd,
1535 0xffd51400, 0x000040bd, 0xffde1400, 0x000061bd,
1536 0xffe61400, 0x000081bd, 0xffee1400, 0x0000a1bd,
1537 0xfff61400, 0x0000c2bd, 0xffff1400, 0x0000e2bd,
1538 0xff001800, 0x000000c5, 0xff081800, 0x000020c5,
1539 0xff101800, 0x000040c5, 0xff181800, 0x000061c5,
1540 0xff201800, 0x000081c5, 0xff291800, 0x0000a1c5,
1541 0xff311800, 0x0000c2c5, 0xff391800, 0x0000e2c5,
1542 0xff411800, 0x000000cd, 0xff4a1800, 0x000020cd,
1543 0xff521800, 0x000040cd, 0xff5a1800, 0x000061cd,
1544 0xff621800, 0x000081cd, 0xff6a1800, 0x0000a1cd,
1545 0xff731800, 0x0000c2cd, 0xff7b1800, 0x0000e2cd,
1546 0xff831800, 0x000000d5, 0xff8b1800, 0x000020d5,
1547 0xff941800, 0x000040d5, 0xff9c1800, 0x000061d5,
1548 0xffa41800, 0x000081d5, 0xffac1800, 0x0000a1d5,
1549 0xffb41800, 0x0000c2d5, 0xffbd1800, 0x0000e2d5,
1550 0xffc51800, 0x000000de, 0xffcd1800, 0x000020de,
1551 0xffd51800, 0x000040de, 0xffde1800, 0x000061de,
1552 0xffe61800, 0x000081de, 0xffee1800, 0x0000a1de,
1553 0xfff61800, 0x0000c2de, 0xffff1800, 0x0000e2de,
1554 0xff001c00, 0x000000e6, 0xff081c00, 0x000020e6,
1555 0xff101c00, 0x000040e6, 0xff181c00, 0x000061e6,
1556 0xff201c00, 0x000081e6, 0xff291c00, 0x0000a1e6,
1557 0xff311c00, 0x0000c2e6, 0xff391c00, 0x0000e2e6,
1558 0xff411c00, 0x000000ee, 0xff4a1c00, 0x000020ee,
1559 0xff521c00, 0x000040ee, 0xff5a1c00, 0x000061ee,
1560 0xff621c00, 0x000081ee, 0xff6a1c00, 0x0000a1ee,
1561 0xff731c00, 0x0000c2ee, 0xff7b1c00, 0x0000e2ee,
1562 0xff831c00, 0x000000f6, 0xff8b1c00, 0x000020f6,
1563 0xff941c00, 0x000040f6, 0xff9c1c00, 0x000061f6,
1564 0xffa41c00, 0x000081f6, 0xffac1c00, 0x0000a1f6,
1565 0xffb41c00, 0x0000c2f6, 0xffbd1c00, 0x0000e2f6,
1566 0xffc51c00, 0x000000ff, 0xffcd1c00, 0x000020ff,
1567 0xffd51c00, 0x000040ff, 0xffde1c00, 0x000061ff,
1568 0xffe61c00, 0x000081ff, 0xffee1c00, 0x0000a1ff,
1569 0xfff61c00, 0x0000c2ff, 0xffff1c00, 0x0000e2ff
1571 static void Blit_RGB565_ABGR8888(SDL_BlitInfo *info)
1573 Blit_RGB565_32(info, RGB565_ABGR8888_LUT);
1576 /* Special optimized blit for RGB 5-6-5 --> RGBA 8-8-8-8 */
1577 static const Uint32 RGB565_RGBA8888_LUT[512] = {
1578 0x000000ff, 0x00000000, 0x000008ff, 0x00200000,
1579 0x000010ff, 0x00400000, 0x000018ff, 0x00610000,
1580 0x000020ff, 0x00810000, 0x000029ff, 0x00a10000,
1581 0x000031ff, 0x00c20000, 0x000039ff, 0x00e20000,
1582 0x000041ff, 0x08000000, 0x00004aff, 0x08200000,
1583 0x000052ff, 0x08400000, 0x00005aff, 0x08610000,
1584 0x000062ff, 0x08810000, 0x00006aff, 0x08a10000,
1585 0x000073ff, 0x08c20000, 0x00007bff, 0x08e20000,
1586 0x000083ff, 0x10000000, 0x00008bff, 0x10200000,
1587 0x000094ff, 0x10400000, 0x00009cff, 0x10610000,
1588 0x0000a4ff, 0x10810000, 0x0000acff, 0x10a10000,
1589 0x0000b4ff, 0x10c20000, 0x0000bdff, 0x10e20000,
1590 0x0000c5ff, 0x18000000, 0x0000cdff, 0x18200000,
1591 0x0000d5ff, 0x18400000, 0x0000deff, 0x18610000,
1592 0x0000e6ff, 0x18810000, 0x0000eeff, 0x18a10000,
1593 0x0000f6ff, 0x18c20000, 0x0000ffff, 0x18e20000,
1594 0x000400ff, 0x20000000, 0x000408ff, 0x20200000,
1595 0x000410ff, 0x20400000, 0x000418ff, 0x20610000,
1596 0x000420ff, 0x20810000, 0x000429ff, 0x20a10000,
1597 0x000431ff, 0x20c20000, 0x000439ff, 0x20e20000,
1598 0x000441ff, 0x29000000, 0x00044aff, 0x29200000,
1599 0x000452ff, 0x29400000, 0x00045aff, 0x29610000,
1600 0x000462ff, 0x29810000, 0x00046aff, 0x29a10000,
1601 0x000473ff, 0x29c20000, 0x00047bff, 0x29e20000,
1602 0x000483ff, 0x31000000, 0x00048bff, 0x31200000,
1603 0x000494ff, 0x31400000, 0x00049cff, 0x31610000,
1604 0x0004a4ff, 0x31810000, 0x0004acff, 0x31a10000,
1605 0x0004b4ff, 0x31c20000, 0x0004bdff, 0x31e20000,
1606 0x0004c5ff, 0x39000000, 0x0004cdff, 0x39200000,
1607 0x0004d5ff, 0x39400000, 0x0004deff, 0x39610000,
1608 0x0004e6ff, 0x39810000, 0x0004eeff, 0x39a10000,
1609 0x0004f6ff, 0x39c20000, 0x0004ffff, 0x39e20000,
1610 0x000800ff, 0x41000000, 0x000808ff, 0x41200000,
1611 0x000810ff, 0x41400000, 0x000818ff, 0x41610000,
1612 0x000820ff, 0x41810000, 0x000829ff, 0x41a10000,
1613 0x000831ff, 0x41c20000, 0x000839ff, 0x41e20000,
1614 0x000841ff, 0x4a000000, 0x00084aff, 0x4a200000,
1615 0x000852ff, 0x4a400000, 0x00085aff, 0x4a610000,
1616 0x000862ff, 0x4a810000, 0x00086aff, 0x4aa10000,
1617 0x000873ff, 0x4ac20000, 0x00087bff, 0x4ae20000,
1618 0x000883ff, 0x52000000, 0x00088bff, 0x52200000,
1619 0x000894ff, 0x52400000, 0x00089cff, 0x52610000,
1620 0x0008a4ff, 0x52810000, 0x0008acff, 0x52a10000,
1621 0x0008b4ff, 0x52c20000, 0x0008bdff, 0x52e20000,
1622 0x0008c5ff, 0x5a000000, 0x0008cdff, 0x5a200000,
1623 0x0008d5ff, 0x5a400000, 0x0008deff, 0x5a610000,
1624 0x0008e6ff, 0x5a810000, 0x0008eeff, 0x5aa10000,
1625 0x0008f6ff, 0x5ac20000, 0x0008ffff, 0x5ae20000,
1626 0x000c00ff, 0x62000000, 0x000c08ff, 0x62200000,
1627 0x000c10ff, 0x62400000, 0x000c18ff, 0x62610000,
1628 0x000c20ff, 0x62810000, 0x000c29ff, 0x62a10000,
1629 0x000c31ff, 0x62c20000, 0x000c39ff, 0x62e20000,
1630 0x000c41ff, 0x6a000000, 0x000c4aff, 0x6a200000,
1631 0x000c52ff, 0x6a400000, 0x000c5aff, 0x6a610000,
1632 0x000c62ff, 0x6a810000, 0x000c6aff, 0x6aa10000,
1633 0x000c73ff, 0x6ac20000, 0x000c7bff, 0x6ae20000,
1634 0x000c83ff, 0x73000000, 0x000c8bff, 0x73200000,
1635 0x000c94ff, 0x73400000, 0x000c9cff, 0x73610000,
1636 0x000ca4ff, 0x73810000, 0x000cacff, 0x73a10000,
1637 0x000cb4ff, 0x73c20000, 0x000cbdff, 0x73e20000,
1638 0x000cc5ff, 0x7b000000, 0x000ccdff, 0x7b200000,
1639 0x000cd5ff, 0x7b400000, 0x000cdeff, 0x7b610000,
1640 0x000ce6ff, 0x7b810000, 0x000ceeff, 0x7ba10000,
1641 0x000cf6ff, 0x7bc20000, 0x000cffff, 0x7be20000,
1642 0x001000ff, 0x83000000, 0x001008ff, 0x83200000,
1643 0x001010ff, 0x83400000, 0x001018ff, 0x83610000,
1644 0x001020ff, 0x83810000, 0x001029ff, 0x83a10000,
1645 0x001031ff, 0x83c20000, 0x001039ff, 0x83e20000,
1646 0x001041ff, 0x8b000000, 0x00104aff, 0x8b200000,
1647 0x001052ff, 0x8b400000, 0x00105aff, 0x8b610000,
1648 0x001062ff, 0x8b810000, 0x00106aff, 0x8ba10000,
1649 0x001073ff, 0x8bc20000, 0x00107bff, 0x8be20000,
1650 0x001083ff, 0x94000000, 0x00108bff, 0x94200000,
1651 0x001094ff, 0x94400000, 0x00109cff, 0x94610000,
1652 0x0010a4ff, 0x94810000, 0x0010acff, 0x94a10000,
1653 0x0010b4ff, 0x94c20000, 0x0010bdff, 0x94e20000,
1654 0x0010c5ff, 0x9c000000, 0x0010cdff, 0x9c200000,
1655 0x0010d5ff, 0x9c400000, 0x0010deff, 0x9c610000,
1656 0x0010e6ff, 0x9c810000, 0x0010eeff, 0x9ca10000,
1657 0x0010f6ff, 0x9cc20000, 0x0010ffff, 0x9ce20000,
1658 0x001400ff, 0xa4000000, 0x001408ff, 0xa4200000,
1659 0x001410ff, 0xa4400000, 0x001418ff, 0xa4610000,
1660 0x001420ff, 0xa4810000, 0x001429ff, 0xa4a10000,
1661 0x001431ff, 0xa4c20000, 0x001439ff, 0xa4e20000,
1662 0x001441ff, 0xac000000, 0x00144aff, 0xac200000,
1663 0x001452ff, 0xac400000, 0x00145aff, 0xac610000,
1664 0x001462ff, 0xac810000, 0x00146aff, 0xaca10000,
1665 0x001473ff, 0xacc20000, 0x00147bff, 0xace20000,
1666 0x001483ff, 0xb4000000, 0x00148bff, 0xb4200000,
1667 0x001494ff, 0xb4400000, 0x00149cff, 0xb4610000,
1668 0x0014a4ff, 0xb4810000, 0x0014acff, 0xb4a10000,
1669 0x0014b4ff, 0xb4c20000, 0x0014bdff, 0xb4e20000,
1670 0x0014c5ff, 0xbd000000, 0x0014cdff, 0xbd200000,
1671 0x0014d5ff, 0xbd400000, 0x0014deff, 0xbd610000,
1672 0x0014e6ff, 0xbd810000, 0x0014eeff, 0xbda10000,
1673 0x0014f6ff, 0xbdc20000, 0x0014ffff, 0xbde20000,
1674 0x001800ff, 0xc5000000, 0x001808ff, 0xc5200000,
1675 0x001810ff, 0xc5400000, 0x001818ff, 0xc5610000,
1676 0x001820ff, 0xc5810000, 0x001829ff, 0xc5a10000,
1677 0x001831ff, 0xc5c20000, 0x001839ff, 0xc5e20000,
1678 0x001841ff, 0xcd000000, 0x00184aff, 0xcd200000,
1679 0x001852ff, 0xcd400000, 0x00185aff, 0xcd610000,
1680 0x001862ff, 0xcd810000, 0x00186aff, 0xcda10000,
1681 0x001873ff, 0xcdc20000, 0x00187bff, 0xcde20000,
1682 0x001883ff, 0xd5000000, 0x00188bff, 0xd5200000,
1683 0x001894ff, 0xd5400000, 0x00189cff, 0xd5610000,
1684 0x0018a4ff, 0xd5810000, 0x0018acff, 0xd5a10000,
1685 0x0018b4ff, 0xd5c20000, 0x0018bdff, 0xd5e20000,
1686 0x0018c5ff, 0xde000000, 0x0018cdff, 0xde200000,
1687 0x0018d5ff, 0xde400000, 0x0018deff, 0xde610000,
1688 0x0018e6ff, 0xde810000, 0x0018eeff, 0xdea10000,
1689 0x0018f6ff, 0xdec20000, 0x0018ffff, 0xdee20000,
1690 0x001c00ff, 0xe6000000, 0x001c08ff, 0xe6200000,
1691 0x001c10ff, 0xe6400000, 0x001c18ff, 0xe6610000,
1692 0x001c20ff, 0xe6810000, 0x001c29ff, 0xe6a10000,
1693 0x001c31ff, 0xe6c20000, 0x001c39ff, 0xe6e20000,
1694 0x001c41ff, 0xee000000, 0x001c4aff, 0xee200000,
1695 0x001c52ff, 0xee400000, 0x001c5aff, 0xee610000,
1696 0x001c62ff, 0xee810000, 0x001c6aff, 0xeea10000,
1697 0x001c73ff, 0xeec20000, 0x001c7bff, 0xeee20000,
1698 0x001c83ff, 0xf6000000, 0x001c8bff, 0xf6200000,
1699 0x001c94ff, 0xf6400000, 0x001c9cff, 0xf6610000,
1700 0x001ca4ff, 0xf6810000, 0x001cacff, 0xf6a10000,
1701 0x001cb4ff, 0xf6c20000, 0x001cbdff, 0xf6e20000,
1702 0x001cc5ff, 0xff000000, 0x001ccdff, 0xff200000,
1703 0x001cd5ff, 0xff400000, 0x001cdeff, 0xff610000,
1704 0x001ce6ff, 0xff810000, 0x001ceeff, 0xffa10000,
1705 0x001cf6ff, 0xffc20000, 0x001cffff, 0xffe20000,
1707 static void Blit_RGB565_RGBA8888(SDL_BlitInfo *info)
1709 Blit_RGB565_32(info, RGB565_RGBA8888_LUT);
1712 /* Special optimized blit for RGB 5-6-5 --> BGRA 8-8-8-8 */
1713 static const Uint32 RGB565_BGRA8888_LUT[512] = {
1714 0x00000000, 0x000000ff, 0x08000000, 0x002000ff,
1715 0x10000000, 0x004000ff, 0x18000000, 0x006100ff,
1716 0x20000000, 0x008100ff, 0x29000000, 0x00a100ff,
1717 0x31000000, 0x00c200ff, 0x39000000, 0x00e200ff,
1718 0x41000000, 0x000008ff, 0x4a000000, 0x002008ff,
1719 0x52000000, 0x004008ff, 0x5a000000, 0x006108ff,
1720 0x62000000, 0x008108ff, 0x6a000000, 0x00a108ff,
1721 0x73000000, 0x00c208ff, 0x7b000000, 0x00e208ff,
1722 0x83000000, 0x000010ff, 0x8b000000, 0x002010ff,
1723 0x94000000, 0x004010ff, 0x9c000000, 0x006110ff,
1724 0xa4000000, 0x008110ff, 0xac000000, 0x00a110ff,
1725 0xb4000000, 0x00c210ff, 0xbd000000, 0x00e210ff,
1726 0xc5000000, 0x000018ff, 0xcd000000, 0x002018ff,
1727 0xd5000000, 0x004018ff, 0xde000000, 0x006118ff,
1728 0xe6000000, 0x008118ff, 0xee000000, 0x00a118ff,
1729 0xf6000000, 0x00c218ff, 0xff000000, 0x00e218ff,
1730 0x00040000, 0x000020ff, 0x08040000, 0x002020ff,
1731 0x10040000, 0x004020ff, 0x18040000, 0x006120ff,
1732 0x20040000, 0x008120ff, 0x29040000, 0x00a120ff,
1733 0x31040000, 0x00c220ff, 0x39040000, 0x00e220ff,
1734 0x41040000, 0x000029ff, 0x4a040000, 0x002029ff,
1735 0x52040000, 0x004029ff, 0x5a040000, 0x006129ff,
1736 0x62040000, 0x008129ff, 0x6a040000, 0x00a129ff,
1737 0x73040000, 0x00c229ff, 0x7b040000, 0x00e229ff,
1738 0x83040000, 0x000031ff, 0x8b040000, 0x002031ff,
1739 0x94040000, 0x004031ff, 0x9c040000, 0x006131ff,
1740 0xa4040000, 0x008131ff, 0xac040000, 0x00a131ff,
1741 0xb4040000, 0x00c231ff, 0xbd040000, 0x00e231ff,
1742 0xc5040000, 0x000039ff, 0xcd040000, 0x002039ff,
1743 0xd5040000, 0x004039ff, 0xde040000, 0x006139ff,
1744 0xe6040000, 0x008139ff, 0xee040000, 0x00a139ff,
1745 0xf6040000, 0x00c239ff, 0xff040000, 0x00e239ff,
1746 0x00080000, 0x000041ff, 0x08080000, 0x002041ff,
1747 0x10080000, 0x004041ff, 0x18080000, 0x006141ff,
1748 0x20080000, 0x008141ff, 0x29080000, 0x00a141ff,
1749 0x31080000, 0x00c241ff, 0x39080000, 0x00e241ff,
1750 0x41080000, 0x00004aff, 0x4a080000, 0x00204aff,
1751 0x52080000, 0x00404aff, 0x5a080000, 0x00614aff,
1752 0x62080000, 0x00814aff, 0x6a080000, 0x00a14aff,
1753 0x73080000, 0x00c24aff, 0x7b080000, 0x00e24aff,
1754 0x83080000, 0x000052ff, 0x8b080000, 0x002052ff,
1755 0x94080000, 0x004052ff, 0x9c080000, 0x006152ff,
1756 0xa4080000, 0x008152ff, 0xac080000, 0x00a152ff,
1757 0xb4080000, 0x00c252ff, 0xbd080000, 0x00e252ff,
1758 0xc5080000, 0x00005aff, 0xcd080000, 0x00205aff,
1759 0xd5080000, 0x00405aff, 0xde080000, 0x00615aff,
1760 0xe6080000, 0x00815aff, 0xee080000, 0x00a15aff,
1761 0xf6080000, 0x00c25aff, 0xff080000, 0x00e25aff,
1762 0x000c0000, 0x000062ff, 0x080c0000, 0x002062ff,
1763 0x100c0000, 0x004062ff, 0x180c0000, 0x006162ff,
1764 0x200c0000, 0x008162ff, 0x290c0000, 0x00a162ff,
1765 0x310c0000, 0x00c262ff, 0x390c0000, 0x00e262ff,
1766 0x410c0000, 0x00006aff, 0x4a0c0000, 0x00206aff,
1767 0x520c0000, 0x00406aff, 0x5a0c0000, 0x00616aff,
1768 0x620c0000, 0x00816aff, 0x6a0c0000, 0x00a16aff,
1769 0x730c0000, 0x00c26aff, 0x7b0c0000, 0x00e26aff,
1770 0x830c0000, 0x000073ff, 0x8b0c0000, 0x002073ff,
1771 0x940c0000, 0x004073ff, 0x9c0c0000, 0x006173ff,
1772 0xa40c0000, 0x008173ff, 0xac0c0000, 0x00a173ff,
1773 0xb40c0000, 0x00c273ff, 0xbd0c0000, 0x00e273ff,
1774 0xc50c0000, 0x00007bff, 0xcd0c0000, 0x00207bff,
1775 0xd50c0000, 0x00407bff, 0xde0c0000, 0x00617bff,
1776 0xe60c0000, 0x00817bff, 0xee0c0000, 0x00a17bff,
1777 0xf60c0000, 0x00c27bff, 0xff0c0000, 0x00e27bff,
1778 0x00100000, 0x000083ff, 0x08100000, 0x002083ff,
1779 0x10100000, 0x004083ff, 0x18100000, 0x006183ff,
1780 0x20100000, 0x008183ff, 0x29100000, 0x00a183ff,
1781 0x31100000, 0x00c283ff, 0x39100000, 0x00e283ff,
1782 0x41100000, 0x00008bff, 0x4a100000, 0x00208bff,
1783 0x52100000, 0x00408bff, 0x5a100000, 0x00618bff,
1784 0x62100000, 0x00818bff, 0x6a100000, 0x00a18bff,
1785 0x73100000, 0x00c28bff, 0x7b100000, 0x00e28bff,
1786 0x83100000, 0x000094ff, 0x8b100000, 0x002094ff,
1787 0x94100000, 0x004094ff, 0x9c100000, 0x006194ff,
1788 0xa4100000, 0x008194ff, 0xac100000, 0x00a194ff,
1789 0xb4100000, 0x00c294ff, 0xbd100000, 0x00e294ff,
1790 0xc5100000, 0x00009cff, 0xcd100000, 0x00209cff,
1791 0xd5100000, 0x00409cff, 0xde100000, 0x00619cff,
1792 0xe6100000, 0x00819cff, 0xee100000, 0x00a19cff,
1793 0xf6100000, 0x00c29cff, 0xff100000, 0x00e29cff,
1794 0x00140000, 0x0000a4ff, 0x08140000, 0x0020a4ff,
1795 0x10140000, 0x0040a4ff, 0x18140000, 0x0061a4ff,
1796 0x20140000, 0x0081a4ff, 0x29140000, 0x00a1a4ff,
1797 0x31140000, 0x00c2a4ff, 0x39140000, 0x00e2a4ff,
1798 0x41140000, 0x0000acff, 0x4a140000, 0x0020acff,
1799 0x52140000, 0x0040acff, 0x5a140000, 0x0061acff,
1800 0x62140000, 0x0081acff, 0x6a140000, 0x00a1acff,
1801 0x73140000, 0x00c2acff, 0x7b140000, 0x00e2acff,
1802 0x83140000, 0x0000b4ff, 0x8b140000, 0x0020b4ff,
1803 0x94140000, 0x0040b4ff, 0x9c140000, 0x0061b4ff,
1804 0xa4140000, 0x0081b4ff, 0xac140000, 0x00a1b4ff,
1805 0xb4140000, 0x00c2b4ff, 0xbd140000, 0x00e2b4ff,
1806 0xc5140000, 0x0000bdff, 0xcd140000, 0x0020bdff,
1807 0xd5140000, 0x0040bdff, 0xde140000, 0x0061bdff,
1808 0xe6140000, 0x0081bdff, 0xee140000, 0x00a1bdff,
1809 0xf6140000, 0x00c2bdff, 0xff140000, 0x00e2bdff,
1810 0x00180000, 0x0000c5ff, 0x08180000, 0x0020c5ff,
1811 0x10180000, 0x0040c5ff, 0x18180000, 0x0061c5ff,
1812 0x20180000, 0x0081c5ff, 0x29180000, 0x00a1c5ff,
1813 0x31180000, 0x00c2c5ff, 0x39180000, 0x00e2c5ff,
1814 0x41180000, 0x0000cdff, 0x4a180000, 0x0020cdff,
1815 0x52180000, 0x0040cdff, 0x5a180000, 0x0061cdff,
1816 0x62180000, 0x0081cdff, 0x6a180000, 0x00a1cdff,
1817 0x73180000, 0x00c2cdff, 0x7b180000, 0x00e2cdff,
1818 0x83180000, 0x0000d5ff, 0x8b180000, 0x0020d5ff,
1819 0x94180000, 0x0040d5ff, 0x9c180000, 0x0061d5ff,
1820 0xa4180000, 0x0081d5ff, 0xac180000, 0x00a1d5ff,
1821 0xb4180000, 0x00c2d5ff, 0xbd180000, 0x00e2d5ff,
1822 0xc5180000, 0x0000deff, 0xcd180000, 0x0020deff,
1823 0xd5180000, 0x0040deff, 0xde180000, 0x0061deff,
1824 0xe6180000, 0x0081deff, 0xee180000, 0x00a1deff,
1825 0xf6180000, 0x00c2deff, 0xff180000, 0x00e2deff,
1826 0x001c0000, 0x0000e6ff, 0x081c0000, 0x0020e6ff,
1827 0x101c0000, 0x0040e6ff, 0x181c0000, 0x0061e6ff,
1828 0x201c0000, 0x0081e6ff, 0x291c0000, 0x00a1e6ff,
1829 0x311c0000, 0x00c2e6ff, 0x391c0000, 0x00e2e6ff,
1830 0x411c0000, 0x0000eeff, 0x4a1c0000, 0x0020eeff,
1831 0x521c0000, 0x0040eeff, 0x5a1c0000, 0x0061eeff,
1832 0x621c0000, 0x0081eeff, 0x6a1c0000, 0x00a1eeff,
1833 0x731c0000, 0x00c2eeff, 0x7b1c0000, 0x00e2eeff,
1834 0x831c0000, 0x0000f6ff, 0x8b1c0000, 0x0020f6ff,
1835 0x941c0000, 0x0040f6ff, 0x9c1c0000, 0x0061f6ff,
1836 0xa41c0000, 0x0081f6ff, 0xac1c0000, 0x00a1f6ff,
1837 0xb41c0000, 0x00c2f6ff, 0xbd1c0000, 0x00e2f6ff,
1838 0xc51c0000, 0x0000ffff, 0xcd1c0000, 0x0020ffff,
1839 0xd51c0000, 0x0040ffff, 0xde1c0000, 0x0061ffff,
1840 0xe61c0000, 0x0081ffff, 0xee1c0000, 0x00a1ffff,
1841 0xf61c0000, 0x00c2ffff, 0xff1c0000, 0x00e2ffff
1843 static void Blit_RGB565_BGRA8888(SDL_BlitInfo *info)
1845 Blit_RGB565_32(info, RGB565_BGRA8888_LUT);
1848 /* Special optimized blit for RGB 8-8-8 --> RGB 3-3-2 */
1849 #ifndef RGB888_RGB332
1850 #define RGB888_RGB332(dst, src) { \
1851 dst = (((src)&0x00E00000)>>16)| \
1852 (((src)&0x0000E000)>>11)| \
1853 (((src)&0x000000C0)>>6); \
1856 static void Blit_RGB888_index8_map(SDL_BlitInfo *info)
1858 #ifndef USE_DUFFS_LOOP
1866 int srcskip, dstskip;
1868 /* Set up some basic variables */
1869 width = info->d_width;
1870 height = info->d_height;
1871 src = (Uint32 *)info->s_pixels;
1872 srcskip = info->s_skip/4;
1873 dst = info->d_pixels;
1874 dstskip = info->d_skip;
1877 #ifdef USE_DUFFS_LOOP
1878 while ( height-- ) {
1880 RGB888_RGB332(Pixel, *src);
1881 *dst++ = map[Pixel];
1888 while ( height-- ) {
1889 for ( c=width/4; c; --c ) {
1890 /* Pack RGB into 8bit pixel */
1891 RGB888_RGB332(Pixel, *src);
1892 *dst++ = map[Pixel];
1894 RGB888_RGB332(Pixel, *src);
1895 *dst++ = map[Pixel];
1897 RGB888_RGB332(Pixel, *src);
1898 *dst++ = map[Pixel];
1900 RGB888_RGB332(Pixel, *src);
1901 *dst++ = map[Pixel];
1904 switch ( width & 3 ) {
1906 RGB888_RGB332(Pixel, *src);
1907 *dst++ = map[Pixel];
1910 RGB888_RGB332(Pixel, *src);
1911 *dst++ = map[Pixel];
1914 RGB888_RGB332(Pixel, *src);
1915 *dst++ = map[Pixel];
1921 #endif /* USE_DUFFS_LOOP */
1923 static void BlitNto1(SDL_BlitInfo *info)
1925 #ifndef USE_DUFFS_LOOP
1932 int srcskip, dstskip;
1936 SDL_PixelFormat *srcfmt;
1938 /* Set up some basic variables */
1939 width = info->d_width;
1940 height = info->d_height;
1941 src = info->s_pixels;
1942 srcskip = info->s_skip;
1943 dst = info->d_pixels;
1944 dstskip = info->d_skip;
1947 srcbpp = srcfmt->BytesPerPixel;
1949 if ( map == NULL ) {
1950 while ( height-- ) {
1951 #ifdef USE_DUFFS_LOOP
1953 DISEMBLE_RGB(src, srcbpp, srcfmt, Pixel,
1956 /* Pack RGB into 8bit pixel */
1957 *dst = ((sR>>5)<<(3+2))|
1965 for ( c=width; c; --c ) {
1966 DISEMBLE_RGB(src, srcbpp, srcfmt, Pixel,
1969 /* Pack RGB into 8bit pixel */
1970 *dst = ((sR>>5)<<(3+2))|
1982 while ( height-- ) {
1983 #ifdef USE_DUFFS_LOOP
1985 DISEMBLE_RGB(src, srcbpp, srcfmt, Pixel,
1988 /* Pack RGB into 8bit pixel */
1989 *dst = map[((sR>>5)<<(3+2))|
1997 for ( c=width; c; --c ) {
1998 DISEMBLE_RGB(src, srcbpp, srcfmt, Pixel,
2001 /* Pack RGB into 8bit pixel */
2002 *dst = map[((sR>>5)<<(3+2))|
2009 #endif /* USE_DUFFS_LOOP */
2016 /* blits 32 bit RGB<->RGBA with both surfaces having the same R,G,B fields */
2017 static void Blit4to4MaskAlpha(SDL_BlitInfo *info)
2019 int width = info->d_width;
2020 int height = info->d_height;
2021 Uint32 *src = (Uint32 *)info->s_pixels;
2022 int srcskip = info->s_skip;
2023 Uint32 *dst = (Uint32 *)info->d_pixels;
2024 int dstskip = info->d_skip;
2025 SDL_PixelFormat *srcfmt = info->src;
2026 SDL_PixelFormat *dstfmt = info->dst;
2028 if (dstfmt->Amask) {
2029 /* RGB->RGBA, SET_ALPHA */
2030 Uint32 mask = (srcfmt->alpha >> dstfmt->Aloss) << dstfmt->Ashift;
2032 while ( height-- ) {
2040 src = (Uint32*)((Uint8*)src + srcskip);
2041 dst = (Uint32*)((Uint8*)dst + dstskip);
2044 /* RGBA->RGB, NO_ALPHA */
2045 Uint32 mask = srcfmt->Rmask | srcfmt->Gmask | srcfmt->Bmask;
2047 while ( height-- ) {
2055 src = (Uint32*)((Uint8*)src + srcskip);
2056 dst = (Uint32*)((Uint8*)dst + dstskip);
2061 static void BlitNtoN(SDL_BlitInfo *info)
2063 int width = info->d_width;
2064 int height = info->d_height;
2065 Uint8 *src = info->s_pixels;
2066 int srcskip = info->s_skip;
2067 Uint8 *dst = info->d_pixels;
2068 int dstskip = info->d_skip;
2069 SDL_PixelFormat *srcfmt = info->src;
2070 int srcbpp = srcfmt->BytesPerPixel;
2071 SDL_PixelFormat *dstfmt = info->dst;
2072 int dstbpp = dstfmt->BytesPerPixel;
2073 unsigned alpha = dstfmt->Amask ? srcfmt->alpha : 0;
2075 while ( height-- ) {
2082 DISEMBLE_RGB(src, srcbpp, srcfmt, Pixel, sR, sG, sB);
2083 ASSEMBLE_RGBA(dst, dstbpp, dstfmt, sR, sG, sB, alpha);
2093 static void BlitNtoNCopyAlpha(SDL_BlitInfo *info)
2095 int width = info->d_width;
2096 int height = info->d_height;
2097 Uint8 *src = info->s_pixels;
2098 int srcskip = info->s_skip;
2099 Uint8 *dst = info->d_pixels;
2100 int dstskip = info->d_skip;
2101 SDL_PixelFormat *srcfmt = info->src;
2102 int srcbpp = srcfmt->BytesPerPixel;
2103 SDL_PixelFormat *dstfmt = info->dst;
2104 int dstbpp = dstfmt->BytesPerPixel;
2107 /* FIXME: should map alpha to [0..255] correctly! */
2108 while ( height-- ) {
2109 for ( c=width; c; --c ) {
2111 unsigned sR, sG, sB, sA;
2112 DISEMBLE_RGBA(src, srcbpp, srcfmt, Pixel,
2114 ASSEMBLE_RGBA(dst, dstbpp, dstfmt,
2124 static void BlitNto1Key(SDL_BlitInfo *info)
2126 int width = info->d_width;
2127 int height = info->d_height;
2128 Uint8 *src = info->s_pixels;
2129 int srcskip = info->s_skip;
2130 Uint8 *dst = info->d_pixels;
2131 int dstskip = info->d_skip;
2132 SDL_PixelFormat *srcfmt = info->src;
2133 const Uint8 *palmap = info->table;
2134 Uint32 ckey = srcfmt->colorkey;
2135 Uint32 rgbmask = ~srcfmt->Amask;
2138 unsigned sR, sG, sB;
2140 /* Set up some basic variables */
2141 srcbpp = srcfmt->BytesPerPixel;
2144 if ( palmap == NULL ) {
2145 while ( height-- ) {
2148 DISEMBLE_RGB(src, srcbpp, srcfmt, Pixel,
2150 if ( (Pixel & rgbmask) != ckey ) {
2151 /* Pack RGB into 8bit pixel */
2152 *dst = (Uint8)(((sR>>5)<<(3+2))|
2164 while ( height-- ) {
2167 DISEMBLE_RGB(src, srcbpp, srcfmt, Pixel,
2169 if ( (Pixel & rgbmask) != ckey ) {
2170 /* Pack RGB into 8bit pixel */
2171 *dst = (Uint8)palmap[((sR>>5)<<(3+2))|
2185 static void Blit2to2Key(SDL_BlitInfo *info)
2187 int width = info->d_width;
2188 int height = info->d_height;
2189 Uint16 *srcp = (Uint16 *)info->s_pixels;
2190 int srcskip = info->s_skip;
2191 Uint16 *dstp = (Uint16 *)info->d_pixels;
2192 int dstskip = info->d_skip;
2193 Uint32 ckey = info->src->colorkey;
2194 Uint32 rgbmask = ~info->src->Amask;
2196 /* Set up some basic variables */
2201 while ( height-- ) {
2204 if ( (*srcp & rgbmask) != ckey ) {
2216 static void BlitNtoNKey(SDL_BlitInfo *info)
2218 int width = info->d_width;
2219 int height = info->d_height;
2220 Uint8 *src = info->s_pixels;
2221 int srcskip = info->s_skip;
2222 Uint8 *dst = info->d_pixels;
2223 int dstskip = info->d_skip;
2224 Uint32 ckey = info->src->colorkey;
2225 SDL_PixelFormat *srcfmt = info->src;
2226 SDL_PixelFormat *dstfmt = info->dst;
2227 int srcbpp = srcfmt->BytesPerPixel;
2228 int dstbpp = dstfmt->BytesPerPixel;
2229 unsigned alpha = dstfmt->Amask ? srcfmt->alpha : 0;
2230 Uint32 rgbmask = ~srcfmt->Amask;
2232 /* Set up some basic variables */
2235 while ( height-- ) {
2242 RETRIEVE_RGB_PIXEL(src, srcbpp, Pixel);
2243 if ( (Pixel & rgbmask) != ckey ) {
2244 RGB_FROM_PIXEL(Pixel, srcfmt, sR, sG, sB);
2245 ASSEMBLE_RGBA(dst, dstbpp, dstfmt,
2257 static void BlitNtoNKeyCopyAlpha(SDL_BlitInfo *info)
2259 int width = info->d_width;
2260 int height = info->d_height;
2261 Uint8 *src = info->s_pixels;
2262 int srcskip = info->s_skip;
2263 Uint8 *dst = info->d_pixels;
2264 int dstskip = info->d_skip;
2265 Uint32 ckey = info->src->colorkey;
2266 SDL_PixelFormat *srcfmt = info->src;
2267 SDL_PixelFormat *dstfmt = info->dst;
2268 Uint32 rgbmask = ~srcfmt->Amask;
2273 unsigned sR, sG, sB, sA;
2275 /* Set up some basic variables */
2276 srcbpp = srcfmt->BytesPerPixel;
2277 dstbpp = dstfmt->BytesPerPixel;
2280 /* FIXME: should map alpha to [0..255] correctly! */
2281 while ( height-- ) {
2284 DISEMBLE_RGBA(src, srcbpp, srcfmt, Pixel,
2286 if ( (Pixel & rgbmask) != ckey ) {
2287 ASSEMBLE_RGBA(dst, dstbpp, dstfmt,
2299 /* Normal N to N optimized blitters */
2301 Uint32 srcR, srcG, srcB;
2303 Uint32 dstR, dstG, dstB;
2304 Uint32 blit_features;
2306 SDL_loblit blitfunc;
2307 enum { NO_ALPHA=1, SET_ALPHA=2, COPY_ALPHA=4 } alpha;
2309 static const struct blit_table normal_blit_1[] = {
2310 /* Default for 8-bit RGB source, an invalid combination */
2311 { 0,0,0, 0, 0,0,0, 0, NULL, NULL },
2313 static const struct blit_table normal_blit_2[] = {
2314 #if SDL_HERMES_BLITTERS
2315 { 0x0000F800,0x000007E0,0x0000001F, 2, 0x0000001F,0x000007E0,0x0000F800,
2316 0, ConvertX86p16_16BGR565, ConvertX86, NO_ALPHA },
2317 { 0x0000F800,0x000007E0,0x0000001F, 2, 0x00007C00,0x000003E0,0x0000001F,
2318 0, ConvertX86p16_16RGB555, ConvertX86, NO_ALPHA },
2319 { 0x0000F800,0x000007E0,0x0000001F, 2, 0x0000001F,0x000003E0,0x00007C00,
2320 0, ConvertX86p16_16BGR555, ConvertX86, NO_ALPHA },
2321 #elif SDL_ALTIVEC_BLITTERS
2323 { 0x0000F800,0x000007E0,0x0000001F, 4, 0x00000000,0x00000000,0x00000000,
2324 2, NULL, Blit_RGB565_32Altivec, NO_ALPHA | COPY_ALPHA | SET_ALPHA },
2325 { 0x00007C00,0x000003E0,0x0000001F, 4, 0x00000000,0x00000000,0x00000000,
2326 2, NULL, Blit_RGB555_32Altivec, NO_ALPHA | COPY_ALPHA | SET_ALPHA },
2328 { 0x0000F800,0x000007E0,0x0000001F, 4, 0x00FF0000,0x0000FF00,0x000000FF,
2329 0, NULL, Blit_RGB565_ARGB8888, SET_ALPHA },
2330 { 0x0000F800,0x000007E0,0x0000001F, 4, 0x000000FF,0x0000FF00,0x00FF0000,
2331 0, NULL, Blit_RGB565_ABGR8888, SET_ALPHA },
2332 { 0x0000F800,0x000007E0,0x0000001F, 4, 0xFF000000,0x00FF0000,0x0000FF00,
2333 0, NULL, Blit_RGB565_RGBA8888, SET_ALPHA },
2334 { 0x0000F800,0x000007E0,0x0000001F, 4, 0x0000FF00,0x00FF0000,0xFF000000,
2335 0, NULL, Blit_RGB565_BGRA8888, SET_ALPHA },
2337 /* Default for 16-bit RGB source, used if no other blitter matches */
2338 { 0,0,0, 0, 0,0,0, 0, NULL, BlitNtoN, 0 }
2340 static const struct blit_table normal_blit_3[] = {
2341 /* Default for 24-bit RGB source, never optimized */
2342 { 0,0,0, 0, 0,0,0, 0, NULL, BlitNtoN, 0 }
2344 static const struct blit_table normal_blit_4[] = {
2345 #if SDL_HERMES_BLITTERS
2346 { 0x00FF0000,0x0000FF00,0x000000FF, 2, 0x0000F800,0x000007E0,0x0000001F,
2347 1, ConvertMMXpII32_16RGB565, ConvertMMX, NO_ALPHA },
2348 { 0x00FF0000,0x0000FF00,0x000000FF, 2, 0x0000F800,0x000007E0,0x0000001F,
2349 0, ConvertX86p32_16RGB565, ConvertX86, NO_ALPHA },
2350 { 0x00FF0000,0x0000FF00,0x000000FF, 2, 0x0000001F,0x000007E0,0x0000F800,
2351 1, ConvertMMXpII32_16BGR565, ConvertMMX, NO_ALPHA },
2352 { 0x00FF0000,0x0000FF00,0x000000FF, 2, 0x0000001F,0x000007E0,0x0000F800,
2353 0, ConvertX86p32_16BGR565, ConvertX86, NO_ALPHA },
2354 { 0x00FF0000,0x0000FF00,0x000000FF, 2, 0x00007C00,0x000003E0,0x0000001F,
2355 1, ConvertMMXpII32_16RGB555, ConvertMMX, NO_ALPHA },
2356 { 0x00FF0000,0x0000FF00,0x000000FF, 2, 0x00007C00,0x000003E0,0x0000001F,
2357 0, ConvertX86p32_16RGB555, ConvertX86, NO_ALPHA },
2358 { 0x00FF0000,0x0000FF00,0x000000FF, 2, 0x0000001F,0x000003E0,0x00007C00,
2359 1, ConvertMMXpII32_16BGR555, ConvertMMX, NO_ALPHA },
2360 { 0x00FF0000,0x0000FF00,0x000000FF, 2, 0x0000001F,0x000003E0,0x00007C00,
2361 0, ConvertX86p32_16BGR555, ConvertX86, NO_ALPHA },
2362 { 0x00FF0000,0x0000FF00,0x000000FF, 3, 0x00FF0000,0x0000FF00,0x000000FF,
2363 1, ConvertMMXpII32_24RGB888, ConvertMMX, NO_ALPHA },
2364 { 0x00FF0000,0x0000FF00,0x000000FF, 3, 0x00FF0000,0x0000FF00,0x000000FF,
2365 0, ConvertX86p32_24RGB888, ConvertX86, NO_ALPHA },
2366 { 0x00FF0000,0x0000FF00,0x000000FF, 3, 0x000000FF,0x0000FF00,0x00FF0000,
2367 0, ConvertX86p32_24BGR888, ConvertX86, NO_ALPHA },
2368 { 0x00FF0000,0x0000FF00,0x000000FF, 4, 0x000000FF,0x0000FF00,0x00FF0000,
2369 0, ConvertX86p32_32BGR888, ConvertX86, NO_ALPHA },
2370 { 0x00FF0000,0x0000FF00,0x000000FF, 4, 0xFF000000,0x00FF0000,0x0000FF00,
2371 0, ConvertX86p32_32RGBA888, ConvertX86, NO_ALPHA },
2372 { 0x00FF0000,0x0000FF00,0x000000FF, 4, 0x0000FF00,0x00FF0000,0xFF000000,
2373 0, ConvertX86p32_32BGRA888, ConvertX86, NO_ALPHA },
2375 #if SDL_ALTIVEC_BLITTERS
2376 /* has-altivec | dont-use-prefetch */
2377 { 0x00000000,0x00000000,0x00000000, 4, 0x00000000,0x00000000,0x00000000,
2378 6, NULL, ConvertAltivec32to32_noprefetch, NO_ALPHA | COPY_ALPHA | SET_ALPHA },
2380 { 0x00000000,0x00000000,0x00000000, 4, 0x00000000,0x00000000,0x00000000,
2381 2, NULL, ConvertAltivec32to32_prefetch, NO_ALPHA | COPY_ALPHA | SET_ALPHA },
2383 { 0x00000000,0x00000000,0x00000000, 2, 0x0000F800,0x000007E0,0x0000001F,
2384 2, NULL, Blit_RGB888_RGB565Altivec, NO_ALPHA },
2386 { 0x00FF0000,0x0000FF00,0x000000FF, 2, 0x0000F800,0x000007E0,0x0000001F,
2387 0, NULL, Blit_RGB888_RGB565, NO_ALPHA },
2388 { 0x00FF0000,0x0000FF00,0x000000FF, 2, 0x00007C00,0x000003E0,0x0000001F,
2389 0, NULL, Blit_RGB888_RGB555, NO_ALPHA },
2392 { 0x00FF0000,0x0000FF00,0x000000FF, 4, 0x00FF0000,0x0000FF00,0x000000FF,
2393 0, NULL, BlitARGBtoXRGB_neon, NO_ALPHA | SET_ALPHA },
2394 { 0x000000FF,0x0000FF00,0x00FF0000, 4, 0x00FF0000,0x0000FF00,0x000000FF,
2395 0, NULL, BlitABGRtoXRGB_neon, NO_ALPHA | SET_ALPHA },
2396 /* RGB->BGR is same as BGR->RGB */
2397 { 0x00FF0000,0x0000FF00,0x000000FF, 4, 0x000000FF,0x0000FF00,0x00FF0000,
2398 0, NULL, BlitABGRtoXRGB_neon, NO_ALPHA | SET_ALPHA },
2400 /* Default for 32-bit RGB source, used if no other blitter matches */
2401 { 0,0,0, 0, 0,0,0, 0, NULL, BlitNtoN, 0 }
2403 static const struct blit_table *normal_blit[] = {
2404 normal_blit_1, normal_blit_2, normal_blit_3, normal_blit_4
2407 /* Mask matches table, or table entry is zero */
2408 #define MASKOK(x, y) (((x) == (y)) || ((y) == 0x00000000))
2410 SDL_loblit SDL_CalculateBlitN(SDL_Surface *surface, int blit_index)
2412 struct private_swaccel *sdata;
2413 SDL_PixelFormat *srcfmt;
2414 SDL_PixelFormat *dstfmt;
2415 const struct blit_table *table;
2419 /* Set up data for choosing the blit */
2420 sdata = surface->map->sw_data;
2421 srcfmt = surface->format;
2422 dstfmt = surface->map->dst->format;
2424 if ( blit_index & 2 ) {
2425 /* alpha or alpha+colorkey */
2426 return SDL_CalculateAlphaBlit(surface, blit_index);
2429 /* We don't support destinations less than 8-bits */
2430 if ( dstfmt->BitsPerPixel < 8 ) {
2434 if(blit_index == 1) {
2435 /* colorkey blit: Here we don't have too many options, mostly
2436 because RLE is the preferred fast way to deal with this.
2437 If a particular case turns out to be useful we'll add it. */
2439 if(srcfmt->BytesPerPixel == 2
2440 && surface->map->identity)
2442 else if(dstfmt->BytesPerPixel == 1)
2445 #if SDL_ALTIVEC_BLITTERS
2446 if((srcfmt->BytesPerPixel == 4) && (dstfmt->BytesPerPixel == 4) && SDL_HasAltiVec()) {
2447 return Blit32to32KeyAltivec;
2451 if(srcfmt->Amask && dstfmt->Amask)
2452 return BlitNtoNKeyCopyAlpha;
2459 if ( dstfmt->BitsPerPixel == 8 ) {
2460 /* We assume 8-bit destinations are palettized */
2461 if ( (srcfmt->BytesPerPixel == 4) &&
2462 (srcfmt->Rmask == 0x00FF0000) &&
2463 (srcfmt->Gmask == 0x0000FF00) &&
2464 (srcfmt->Bmask == 0x000000FF) ) {
2465 if ( surface->map->table ) {
2466 blitfun = Blit_RGB888_index8_map;
2468 #if SDL_HERMES_BLITTERS
2469 sdata->aux_data = ConvertX86p32_8RGB332;
2470 blitfun = ConvertX86;
2472 blitfun = Blit_RGB888_index8;
2479 /* Now the meat, choose the blitter we want */
2480 int a_need = NO_ALPHA;
2482 a_need = srcfmt->Amask ? COPY_ALPHA : SET_ALPHA;
2483 table = normal_blit[srcfmt->BytesPerPixel-1];
2484 for ( which=0; table[which].dstbpp; ++which ) {
2485 if ( MASKOK(srcfmt->Rmask, table[which].srcR) &&
2486 MASKOK(srcfmt->Gmask, table[which].srcG) &&
2487 MASKOK(srcfmt->Bmask, table[which].srcB) &&
2488 MASKOK(dstfmt->Rmask, table[which].dstR) &&
2489 MASKOK(dstfmt->Gmask, table[which].dstG) &&
2490 MASKOK(dstfmt->Bmask, table[which].dstB) &&
2491 dstfmt->BytesPerPixel == table[which].dstbpp &&
2492 (a_need & table[which].alpha) == a_need &&
2493 ((table[which].blit_features & GetBlitFeatures()) == table[which].blit_features) )
2496 sdata->aux_data = table[which].aux_data;
2497 blitfun = table[which].blitfunc;
2499 if(blitfun == BlitNtoN) { /* default C fallback catch-all. Slow! */
2500 /* Fastpath C fallback: 32bit RGB<->RGBA blit with matching RGB */
2501 if ( srcfmt->BytesPerPixel == 4 && dstfmt->BytesPerPixel == 4 &&
2502 srcfmt->Rmask == dstfmt->Rmask &&
2503 srcfmt->Gmask == dstfmt->Gmask &&
2504 srcfmt->Bmask == dstfmt->Bmask ) {
2505 blitfun = Blit4to4MaskAlpha;
2506 } else if ( a_need == COPY_ALPHA ) {
2507 blitfun = BlitNtoNCopyAlpha;
2513 #if SDL_HERMES_BLITTERS
2514 if ( blitfun == ConvertMMX )
2515 fprintf(stderr, "Using mmx blit\n");
2517 if ( blitfun == ConvertX86 )
2518 fprintf(stderr, "Using asm blit\n");
2521 if ( (blitfun == BlitNtoN) || (blitfun == BlitNto1) )
2522 fprintf(stderr, "Using C blit\n");
2524 fprintf(stderr, "Using optimized C blit\n");
2525 #endif /* DEBUG_ASM */