2 SDL - Simple DirectMedia Layer
3 Copyright (C) 1997-2006 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
37 #include <sys/sysctl.h>
38 static size_t GetL3CacheSize( void )
40 const char key[] = "hw.l3cachesize";
42 size_t typeSize = sizeof( result );
45 int err = sysctlbyname( key, &result, &typeSize, NULL, 0 );
46 if( 0 != err ) return 0;
51 static size_t GetL3CacheSize( void )
53 /* XXX: Just guess G4 */
56 #endif /* __MACOSX__ */
58 #if (defined(__MACOSX__) && (__GNUC__ < 4))
59 #define VECUINT8_LITERAL(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p) \
60 (vector unsigned char) ( a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p )
61 #define VECUINT16_LITERAL(a,b,c,d,e,f,g,h) \
62 (vector unsigned short) ( a,b,c,d,e,f,g,h )
64 #define VECUINT8_LITERAL(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p) \
65 (vector unsigned char) { a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p }
66 #define VECUINT16_LITERAL(a,b,c,d,e,f,g,h) \
67 (vector unsigned short) { a,b,c,d,e,f,g,h }
70 #define UNALIGNED_PTR(x) (((size_t) x) & 0x0000000F)
71 #define VSWIZZLE32(a,b,c,d) (vector unsigned char) \
72 ( 0x00+a, 0x00+b, 0x00+c, 0x00+d, \
73 0x04+a, 0x04+b, 0x04+c, 0x04+d, \
74 0x08+a, 0x08+b, 0x08+c, 0x08+d, \
75 0x0C+a, 0x0C+b, 0x0C+c, 0x0C+d )
77 #define MAKE8888(dstfmt, r, g, b, a) \
78 ( ((r<<dstfmt->Rshift)&dstfmt->Rmask) | \
79 ((g<<dstfmt->Gshift)&dstfmt->Gmask) | \
80 ((b<<dstfmt->Bshift)&dstfmt->Bmask) | \
81 ((a<<dstfmt->Ashift)&dstfmt->Amask) )
84 * Data Stream Touch...Altivec cache prefetching.
86 * Don't use this on a G5...however, the speed boost is very significant
89 #define DST_CHAN_SRC 1
90 #define DST_CHAN_DEST 2
92 /* macro to set DST control word value... */
93 #define DST_CTRL(size, count, stride) \
94 (((size) << 24) | ((count) << 16) | (stride))
96 #define VEC_ALIGNER(src) ((UNALIGNED_PTR(src)) \
98 : vec_add(vec_lvsl(8, src), vec_splat_u8(8)))
100 /* Calculate the permute vector used for 32->32 swizzling */
101 static vector unsigned char calc_swizzle32(const SDL_PixelFormat *srcfmt,
102 const SDL_PixelFormat *dstfmt)
105 * We have to assume that the bits that aren't used by other
106 * colors is alpha, and it's one complete byte, since some formats
107 * leave alpha with a zero mask, but we should still swizzle the bits.
110 const static struct SDL_PixelFormat default_pixel_format = {
114 0x00FF0000, 0x0000FF00, 0x000000FF, 0xFF000000,
117 srcfmt = &default_pixel_format;
120 dstfmt = &default_pixel_format;
122 vector unsigned char plus = VECUINT8_LITERAL(
123 0x00, 0x00, 0x00, 0x00,
124 0x04, 0x04, 0x04, 0x04,
125 0x08, 0x08, 0x08, 0x08,
126 0x0C, 0x0C, 0x0C, 0x0C );
127 vector unsigned char vswiz;
128 vector unsigned int srcvec;
129 #define RESHIFT(X) (3 - ((X) >> 3))
130 Uint32 rmask = RESHIFT(srcfmt->Rshift) << (dstfmt->Rshift);
131 Uint32 gmask = RESHIFT(srcfmt->Gshift) << (dstfmt->Gshift);
132 Uint32 bmask = RESHIFT(srcfmt->Bshift) << (dstfmt->Bshift);
134 /* Use zero for alpha if either surface doesn't have alpha */
136 amask = ((srcfmt->Amask) ? RESHIFT(srcfmt->Ashift) : 0x10) << (dstfmt->Ashift);
138 amask = 0x10101010 & ((dstfmt->Rmask | dstfmt->Gmask | dstfmt->Bmask) ^ 0xFFFFFFFF);
141 ((unsigned int *)(char*)&srcvec)[0] = (rmask | gmask | bmask | amask);
142 vswiz = vec_add(plus, (vector unsigned char)vec_splat(srcvec, 0));
146 static void Blit_RGB888_RGB565(SDL_BlitInfo *info);
147 static void Blit_RGB888_RGB565Altivec(SDL_BlitInfo *info) {
148 int height = info->d_height;
149 Uint8 *src = (Uint8 *) info->s_pixels;
150 int srcskip = info->s_skip;
151 Uint8 *dst = (Uint8 *) info->d_pixels;
152 int dstskip = info->d_skip;
153 SDL_PixelFormat *srcfmt = info->src;
154 vector unsigned char valpha = vec_splat_u8(0);
155 vector unsigned char vpermute = calc_swizzle32(srcfmt, NULL);
156 vector unsigned char vgmerge = VECUINT8_LITERAL(
157 0x00, 0x02, 0x00, 0x06,
158 0x00, 0x0a, 0x00, 0x0e,
159 0x00, 0x12, 0x00, 0x16,
160 0x00, 0x1a, 0x00, 0x1e);
161 vector unsigned short v1 = vec_splat_u16(1);
162 vector unsigned short v3 = vec_splat_u16(3);
163 vector unsigned short v3f = VECUINT16_LITERAL(
164 0x003f, 0x003f, 0x003f, 0x003f,
165 0x003f, 0x003f, 0x003f, 0x003f);
166 vector unsigned short vfc = VECUINT16_LITERAL(
167 0x00fc, 0x00fc, 0x00fc, 0x00fc,
168 0x00fc, 0x00fc, 0x00fc, 0x00fc);
169 vector unsigned short vf800 = (vector unsigned short)vec_splat_u8(-7);
170 vf800 = vec_sl(vf800, vec_splat_u16(8));
173 vector unsigned char valigner;
174 vector unsigned char voverflow;
175 vector unsigned char vsrc;
177 int width = info->d_width;
180 /* do scalar until we can align... */
181 #define ONE_PIXEL_BLEND(condition, widthvar) \
182 while (condition) { \
184 unsigned sR, sG, sB, sA; \
185 DISEMBLE_RGBA((Uint8 *)src, 4, srcfmt, Pixel, \
187 *(Uint16 *)(dst) = (((sR << 8) & 0x0000F800) | \
188 ((sG << 3) & 0x000007E0) | \
189 ((sB >> 3) & 0x0000001F)); \
195 ONE_PIXEL_BLEND(((UNALIGNED_PTR(dst)) && (width)), width);
197 /* After all that work, here's the vector part! */
198 extrawidth = (width % 8); /* trailing unaligned stores */
200 vsrc = vec_ld(0, src);
201 valigner = VEC_ALIGNER(src);
204 vector unsigned short vpixel, vrpixel, vgpixel, vbpixel;
205 vector unsigned int vsrc1, vsrc2;
206 vector unsigned char vdst;
208 voverflow = vec_ld(15, src);
209 vsrc = vec_perm(vsrc, voverflow, valigner);
210 vsrc1 = (vector unsigned int)vec_perm(vsrc, valpha, vpermute);
213 voverflow = vec_ld(15, src);
214 vsrc = vec_perm(vsrc, voverflow, valigner);
215 vsrc2 = (vector unsigned int)vec_perm(vsrc, valpha, vpermute);
217 vpixel = (vector unsigned short)vec_packpx(vsrc1, vsrc2);
218 vgpixel = (vector unsigned short)vec_perm(vsrc1, vsrc2, vgmerge);
219 vgpixel = vec_and(vgpixel, vfc);
220 vgpixel = vec_sl(vgpixel, v3);
221 vrpixel = vec_sl(vpixel, v1);
222 vrpixel = vec_and(vrpixel, vf800);
223 vbpixel = vec_and(vpixel, v3f);
224 vdst = vec_or((vector unsigned char)vrpixel, (vector unsigned char)vgpixel);
226 vdst = vec_or(vdst, (vector unsigned char)vbpixel);
227 vec_st(vdst, 0, dst);
237 /* do scalar until we can align... */
238 ONE_PIXEL_BLEND((extrawidth), extrawidth);
239 #undef ONE_PIXEL_BLEND
241 src += srcskip; /* move to next row, accounting for pitch. */
248 static void Blit_RGB565_32Altivec(SDL_BlitInfo *info) {
249 int height = info->d_height;
250 Uint8 *src = (Uint8 *) info->s_pixels;
251 int srcskip = info->s_skip;
252 Uint8 *dst = (Uint8 *) info->d_pixels;
253 int dstskip = info->d_skip;
254 SDL_PixelFormat *srcfmt = info->src;
255 SDL_PixelFormat *dstfmt = info->dst;
257 vector unsigned char valpha;
258 vector unsigned char vpermute;
259 vector unsigned short vf800;
260 vector unsigned int v8 = vec_splat_u32(8);
261 vector unsigned int v16 = vec_add(v8, v8);
262 vector unsigned short v2 = vec_splat_u16(2);
263 vector unsigned short v3 = vec_splat_u16(3);
265 0x10 - 0x1f is the alpha
266 0x00 - 0x0e evens are the red
267 0x01 - 0x0f odds are zero
269 vector unsigned char vredalpha1 = VECUINT8_LITERAL(
270 0x10, 0x00, 0x01, 0x01,
271 0x10, 0x02, 0x01, 0x01,
272 0x10, 0x04, 0x01, 0x01,
273 0x10, 0x06, 0x01, 0x01
275 vector unsigned char vredalpha2 = (vector unsigned char) (
276 vec_add((vector unsigned int)vredalpha1, vec_sl(v8, v16))
279 0x00 - 0x0f is ARxx ARxx ARxx ARxx
280 0x11 - 0x0f odds are blue
282 vector unsigned char vblue1 = VECUINT8_LITERAL(
283 0x00, 0x01, 0x02, 0x11,
284 0x04, 0x05, 0x06, 0x13,
285 0x08, 0x09, 0x0a, 0x15,
286 0x0c, 0x0d, 0x0e, 0x17
288 vector unsigned char vblue2 = (vector unsigned char)(
289 vec_add((vector unsigned int)vblue1, v8)
292 0x00 - 0x0f is ARxB ARxB ARxB ARxB
293 0x10 - 0x0e evens are green
295 vector unsigned char vgreen1 = VECUINT8_LITERAL(
296 0x00, 0x01, 0x10, 0x03,
297 0x04, 0x05, 0x12, 0x07,
298 0x08, 0x09, 0x14, 0x0b,
299 0x0c, 0x0d, 0x16, 0x0f
301 vector unsigned char vgreen2 = (vector unsigned char)(
302 vec_add((vector unsigned int)vgreen1, vec_sl(v8, v8))
306 assert(srcfmt->BytesPerPixel == 2);
307 assert(dstfmt->BytesPerPixel == 4);
309 vf800 = (vector unsigned short)vec_splat_u8(-7);
310 vf800 = vec_sl(vf800, vec_splat_u16(8));
312 if (dstfmt->Amask && srcfmt->alpha) {
313 ((unsigned char *)&valpha)[0] = alpha = srcfmt->alpha;
314 valpha = vec_splat(valpha, 0);
317 valpha = vec_splat_u8(0);
320 vpermute = calc_swizzle32(NULL, dstfmt);
322 vector unsigned char valigner;
323 vector unsigned char voverflow;
324 vector unsigned char vsrc;
326 int width = info->d_width;
329 /* do scalar until we can align... */
330 #define ONE_PIXEL_BLEND(condition, widthvar) \
331 while (condition) { \
332 unsigned sR, sG, sB; \
333 unsigned short Pixel = *((unsigned short *)src); \
334 sR = (Pixel >> 8) & 0xf8; \
335 sG = (Pixel >> 3) & 0xfc; \
336 sB = (Pixel << 3) & 0xf8; \
337 ASSEMBLE_RGBA(dst, 4, dstfmt, sR, sG, sB, alpha); \
342 ONE_PIXEL_BLEND(((UNALIGNED_PTR(dst)) && (width)), width);
344 /* After all that work, here's the vector part! */
345 extrawidth = (width % 8); /* trailing unaligned stores */
347 vsrc = vec_ld(0, src);
348 valigner = VEC_ALIGNER(src);
351 vector unsigned short vR, vG, vB;
352 vector unsigned char vdst1, vdst2;
354 voverflow = vec_ld(15, src);
355 vsrc = vec_perm(vsrc, voverflow, valigner);
357 vR = vec_and((vector unsigned short)vsrc, vf800);
358 vB = vec_sl((vector unsigned short)vsrc, v3);
361 vdst1 = (vector unsigned char)vec_perm((vector unsigned char)vR, valpha, vredalpha1);
362 vdst1 = vec_perm(vdst1, (vector unsigned char)vB, vblue1);
363 vdst1 = vec_perm(vdst1, (vector unsigned char)vG, vgreen1);
364 vdst1 = vec_perm(vdst1, valpha, vpermute);
365 vec_st(vdst1, 0, dst);
367 vdst2 = (vector unsigned char)vec_perm((vector unsigned char)vR, valpha, vredalpha2);
368 vdst2 = vec_perm(vdst2, (vector unsigned char)vB, vblue2);
369 vdst2 = vec_perm(vdst2, (vector unsigned char)vG, vgreen2);
370 vdst2 = vec_perm(vdst2, valpha, vpermute);
371 vec_st(vdst2, 16, dst);
382 /* do scalar until we can align... */
383 ONE_PIXEL_BLEND((extrawidth), extrawidth);
384 #undef ONE_PIXEL_BLEND
386 src += srcskip; /* move to next row, accounting for pitch. */
393 static void Blit_RGB555_32Altivec(SDL_BlitInfo *info) {
394 int height = info->d_height;
395 Uint8 *src = (Uint8 *) info->s_pixels;
396 int srcskip = info->s_skip;
397 Uint8 *dst = (Uint8 *) info->d_pixels;
398 int dstskip = info->d_skip;
399 SDL_PixelFormat *srcfmt = info->src;
400 SDL_PixelFormat *dstfmt = info->dst;
402 vector unsigned char valpha;
403 vector unsigned char vpermute;
404 vector unsigned short vf800;
405 vector unsigned int v8 = vec_splat_u32(8);
406 vector unsigned int v16 = vec_add(v8, v8);
407 vector unsigned short v1 = vec_splat_u16(1);
408 vector unsigned short v3 = vec_splat_u16(3);
410 0x10 - 0x1f is the alpha
411 0x00 - 0x0e evens are the red
412 0x01 - 0x0f odds are zero
414 vector unsigned char vredalpha1 = VECUINT8_LITERAL(
415 0x10, 0x00, 0x01, 0x01,
416 0x10, 0x02, 0x01, 0x01,
417 0x10, 0x04, 0x01, 0x01,
418 0x10, 0x06, 0x01, 0x01
420 vector unsigned char vredalpha2 = (vector unsigned char)(
421 vec_add((vector unsigned int)vredalpha1, vec_sl(v8, v16))
424 0x00 - 0x0f is ARxx ARxx ARxx ARxx
425 0x11 - 0x0f odds are blue
427 vector unsigned char vblue1 = VECUINT8_LITERAL(
428 0x00, 0x01, 0x02, 0x11,
429 0x04, 0x05, 0x06, 0x13,
430 0x08, 0x09, 0x0a, 0x15,
431 0x0c, 0x0d, 0x0e, 0x17
433 vector unsigned char vblue2 = (vector unsigned char)(
434 vec_add((vector unsigned int)vblue1, v8)
437 0x00 - 0x0f is ARxB ARxB ARxB ARxB
438 0x10 - 0x0e evens are green
440 vector unsigned char vgreen1 = VECUINT8_LITERAL(
441 0x00, 0x01, 0x10, 0x03,
442 0x04, 0x05, 0x12, 0x07,
443 0x08, 0x09, 0x14, 0x0b,
444 0x0c, 0x0d, 0x16, 0x0f
446 vector unsigned char vgreen2 = (vector unsigned char)(
447 vec_add((vector unsigned int)vgreen1, vec_sl(v8, v8))
451 assert(srcfmt->BytesPerPixel == 2);
452 assert(dstfmt->BytesPerPixel == 4);
454 vf800 = (vector unsigned short)vec_splat_u8(-7);
455 vf800 = vec_sl(vf800, vec_splat_u16(8));
457 if (dstfmt->Amask && srcfmt->alpha) {
458 ((unsigned char *)&valpha)[0] = alpha = srcfmt->alpha;
459 valpha = vec_splat(valpha, 0);
462 valpha = vec_splat_u8(0);
465 vpermute = calc_swizzle32(NULL, dstfmt);
467 vector unsigned char valigner;
468 vector unsigned char voverflow;
469 vector unsigned char vsrc;
471 int width = info->d_width;
474 /* do scalar until we can align... */
475 #define ONE_PIXEL_BLEND(condition, widthvar) \
476 while (condition) { \
477 unsigned sR, sG, sB; \
478 unsigned short Pixel = *((unsigned short *)src); \
479 sR = (Pixel >> 7) & 0xf8; \
480 sG = (Pixel >> 2) & 0xf8; \
481 sB = (Pixel << 3) & 0xf8; \
482 ASSEMBLE_RGBA(dst, 4, dstfmt, sR, sG, sB, alpha); \
487 ONE_PIXEL_BLEND(((UNALIGNED_PTR(dst)) && (width)), width);
489 /* After all that work, here's the vector part! */
490 extrawidth = (width % 8); /* trailing unaligned stores */
492 vsrc = vec_ld(0, src);
493 valigner = VEC_ALIGNER(src);
496 vector unsigned short vR, vG, vB;
497 vector unsigned char vdst1, vdst2;
499 voverflow = vec_ld(15, src);
500 vsrc = vec_perm(vsrc, voverflow, valigner);
502 vR = vec_and(vec_sl((vector unsigned short)vsrc,v1), vf800);
503 vB = vec_sl((vector unsigned short)vsrc, v3);
506 vdst1 = (vector unsigned char)vec_perm((vector unsigned char)vR, valpha, vredalpha1);
507 vdst1 = vec_perm(vdst1, (vector unsigned char)vB, vblue1);
508 vdst1 = vec_perm(vdst1, (vector unsigned char)vG, vgreen1);
509 vdst1 = vec_perm(vdst1, valpha, vpermute);
510 vec_st(vdst1, 0, dst);
512 vdst2 = (vector unsigned char)vec_perm((vector unsigned char)vR, valpha, vredalpha2);
513 vdst2 = vec_perm(vdst2, (vector unsigned char)vB, vblue2);
514 vdst2 = vec_perm(vdst2, (vector unsigned char)vG, vgreen2);
515 vdst2 = vec_perm(vdst2, valpha, vpermute);
516 vec_st(vdst2, 16, dst);
527 /* do scalar until we can align... */
528 ONE_PIXEL_BLEND((extrawidth), extrawidth);
529 #undef ONE_PIXEL_BLEND
531 src += srcskip; /* move to next row, accounting for pitch. */
537 static void BlitNtoNKey(SDL_BlitInfo *info);
538 static void BlitNtoNKeyCopyAlpha(SDL_BlitInfo *info);
539 static void Blit32to32KeyAltivec(SDL_BlitInfo *info)
541 int height = info->d_height;
542 Uint32 *srcp = (Uint32 *) info->s_pixels;
543 int srcskip = info->s_skip;
544 Uint32 *dstp = (Uint32 *) info->d_pixels;
545 int dstskip = info->d_skip;
546 SDL_PixelFormat *srcfmt = info->src;
547 int srcbpp = srcfmt->BytesPerPixel;
548 SDL_PixelFormat *dstfmt = info->dst;
549 int dstbpp = dstfmt->BytesPerPixel;
550 int copy_alpha = (srcfmt->Amask && dstfmt->Amask);
551 unsigned alpha = dstfmt->Amask ? srcfmt->alpha : 0;
552 Uint32 rgbmask = srcfmt->Rmask | srcfmt->Gmask | srcfmt->Bmask;
553 Uint32 ckey = info->src->colorkey;
554 vector unsigned int valpha;
555 vector unsigned char vpermute;
556 vector unsigned char vzero;
557 vector unsigned int vckey;
558 vector unsigned int vrgbmask;
559 vpermute = calc_swizzle32(srcfmt, dstfmt);
560 if (info->d_width < 16) {
562 return BlitNtoNKeyCopyAlpha(info);
564 return BlitNtoNKey(info);
567 vzero = vec_splat_u8(0);
569 ((unsigned char *)&valpha)[0] = (unsigned char)alpha;
570 valpha = (vector unsigned int)vec_splat((vector unsigned char)valpha, 0);
572 valpha = (vector unsigned int)vzero;
575 ((unsigned int *)(char*)&vckey)[0] = ckey;
576 vckey = vec_splat(vckey, 0);
577 ((unsigned int *)(char*)&vrgbmask)[0] = rgbmask;
578 vrgbmask = vec_splat(vrgbmask, 0);
581 #define ONE_PIXEL_BLEND(condition, widthvar) \
583 while (condition) { \
585 unsigned sR, sG, sB, sA; \
586 DISEMBLE_RGBA((Uint8 *)srcp, srcbpp, srcfmt, Pixel, \
588 if ( (Pixel & rgbmask) != ckey ) { \
589 ASSEMBLE_RGBA((Uint8 *)dstp, dstbpp, dstfmt, \
592 dstp = (Uint32 *) (((Uint8 *) dstp) + dstbpp); \
593 srcp = (Uint32 *) (((Uint8 *) srcp) + srcbpp); \
597 while (condition) { \
599 unsigned sR, sG, sB; \
600 RETRIEVE_RGB_PIXEL((Uint8 *)srcp, srcbpp, Pixel); \
601 if ( Pixel != ckey ) { \
602 RGB_FROM_PIXEL(Pixel, srcfmt, sR, sG, sB); \
603 ASSEMBLE_RGBA((Uint8 *)dstp, dstbpp, dstfmt, \
604 sR, sG, sB, alpha); \
606 dstp = (Uint32 *) (((Uint8 *)dstp) + dstbpp); \
607 srcp = (Uint32 *) (((Uint8 *)srcp) + srcbpp); \
611 int width = info->d_width;
612 ONE_PIXEL_BLEND((UNALIGNED_PTR(dstp)) && (width), width);
615 int extrawidth = (width % 4);
616 vector unsigned char valigner = VEC_ALIGNER(srcp);
617 vector unsigned int vs = vec_ld(0, srcp);
621 vector unsigned char vsel;
622 vector unsigned int vd;
623 vector unsigned int voverflow = vec_ld(15, srcp);
624 /* load the source vec */
625 vs = vec_perm(vs, voverflow, valigner);
626 /* vsel is set for items that match the key */
627 vsel = (vector unsigned char)vec_and(vs, vrgbmask);
628 vsel = (vector unsigned char)vec_cmpeq(vs, vckey);
629 /* permute the src vec to the dest format */
630 vs = vec_perm(vs, valpha, vpermute);
631 /* load the destination vec */
632 vd = vec_ld(0, dstp);
633 /* select the source and dest into vs */
634 vd = (vector unsigned int)vec_sel((vector unsigned char)vs, (vector unsigned char)vd, vsel);
642 ONE_PIXEL_BLEND((extrawidth), extrawidth);
643 #undef ONE_PIXEL_BLEND
644 srcp += srcskip >> 2;
645 dstp += dstskip >> 2;
650 /* Altivec code to swizzle one 32-bit surface to a different 32-bit format. */
651 /* Use this on a G5 */
652 static void ConvertAltivec32to32_noprefetch(SDL_BlitInfo *info)
654 int height = info->d_height;
655 Uint32 *src = (Uint32 *) info->s_pixels;
656 int srcskip = info->s_skip;
657 Uint32 *dst = (Uint32 *) info->d_pixels;
658 int dstskip = info->d_skip;
659 SDL_PixelFormat *srcfmt = info->src;
660 SDL_PixelFormat *dstfmt = info->dst;
661 vector unsigned int vzero = vec_splat_u32(0);
662 vector unsigned char vpermute = calc_swizzle32(srcfmt, dstfmt);
663 if (dstfmt->Amask && !srcfmt->Amask) {
665 vector unsigned char valpha;
666 ((unsigned char *)&valpha)[0] = srcfmt->alpha;
667 vzero = (vector unsigned int)vec_splat(valpha, 0);
671 assert(srcfmt->BytesPerPixel == 4);
672 assert(dstfmt->BytesPerPixel == 4);
675 vector unsigned char valigner;
676 vector unsigned int vbits;
677 vector unsigned int voverflow;
681 int width = info->d_width;
684 /* do scalar until we can align... */
685 while ((UNALIGNED_PTR(dst)) && (width)) {
687 RGBA_FROM_8888(bits, srcfmt, r, g, b, a);
688 *(dst++) = MAKE8888(dstfmt, r, g, b, a);
692 /* After all that work, here's the vector part! */
693 extrawidth = (width % 4);
695 valigner = VEC_ALIGNER(src);
696 vbits = vec_ld(0, src);
699 voverflow = vec_ld(15, src);
702 vbits = vec_perm(vbits, voverflow, valigner); /* src is ready. */
703 vbits = vec_perm(vbits, vzero, vpermute); /* swizzle it. */
704 vec_st(vbits, 0, dst); /* store it back out. */
711 /* cover pixels at the end of the row that didn't fit in 16 bytes. */
713 bits = *(src++); /* max 7 pixels, don't bother with prefetch. */
714 RGBA_FROM_8888(bits, srcfmt, r, g, b, a);
715 *(dst++) = MAKE8888(dstfmt, r, g, b, a);
719 src += srcskip >> 2; /* move to next row, accounting for pitch. */
725 /* Altivec code to swizzle one 32-bit surface to a different 32-bit format. */
726 /* Use this on a G4 */
727 static void ConvertAltivec32to32_prefetch(SDL_BlitInfo *info)
729 const int scalar_dst_lead = sizeof (Uint32) * 4;
730 const int vector_dst_lead = sizeof (Uint32) * 16;
732 int height = info->d_height;
733 Uint32 *src = (Uint32 *) info->s_pixels;
734 int srcskip = info->s_skip;
735 Uint32 *dst = (Uint32 *) info->d_pixels;
736 int dstskip = info->d_skip;
737 SDL_PixelFormat *srcfmt = info->src;
738 SDL_PixelFormat *dstfmt = info->dst;
739 vector unsigned int vzero = vec_splat_u32(0);
740 vector unsigned char vpermute = calc_swizzle32(srcfmt, dstfmt);
741 if (dstfmt->Amask && !srcfmt->Amask) {
743 vector unsigned char valpha;
744 ((unsigned char *)&valpha)[0] = srcfmt->alpha;
745 vzero = (vector unsigned int)vec_splat(valpha, 0);
749 assert(srcfmt->BytesPerPixel == 4);
750 assert(dstfmt->BytesPerPixel == 4);
753 vector unsigned char valigner;
754 vector unsigned int vbits;
755 vector unsigned int voverflow;
759 int width = info->d_width;
762 /* do scalar until we can align... */
763 while ((UNALIGNED_PTR(dst)) && (width)) {
764 vec_dstt(src+scalar_dst_lead, DST_CTRL(2,32,1024), DST_CHAN_SRC);
765 vec_dstst(dst+scalar_dst_lead, DST_CTRL(2,32,1024), DST_CHAN_DEST);
767 RGBA_FROM_8888(bits, srcfmt, r, g, b, a);
768 *(dst++) = MAKE8888(dstfmt, r, g, b, a);
772 /* After all that work, here's the vector part! */
773 extrawidth = (width % 4);
775 valigner = VEC_ALIGNER(src);
776 vbits = vec_ld(0, src);
779 vec_dstt(src+vector_dst_lead, DST_CTRL(2,32,1024), DST_CHAN_SRC);
780 vec_dstst(dst+vector_dst_lead, DST_CTRL(2,32,1024), DST_CHAN_DEST);
781 voverflow = vec_ld(15, src);
784 vbits = vec_perm(vbits, voverflow, valigner); /* src is ready. */
785 vbits = vec_perm(vbits, vzero, vpermute); /* swizzle it. */
786 vec_st(vbits, 0, dst); /* store it back out. */
793 /* cover pixels at the end of the row that didn't fit in 16 bytes. */
795 bits = *(src++); /* max 7 pixels, don't bother with prefetch. */
796 RGBA_FROM_8888(bits, srcfmt, r, g, b, a);
797 *(dst++) = MAKE8888(dstfmt, r, g, b, a);
801 src += srcskip >> 2; /* move to next row, accounting for pitch. */
805 vec_dss(DST_CHAN_SRC);
806 vec_dss(DST_CHAN_DEST);
809 static Uint32 GetBlitFeatures( void )
811 static Uint32 features = 0xffffffff;
812 if (features == 0xffffffff) {
813 /* Provide an override for testing .. */
814 char *override = SDL_getenv("SDL_ALTIVEC_BLIT_FEATURES");
817 SDL_sscanf(override, "%u", &features);
820 /* Feature 1 is has-MMX */
821 | ((SDL_HasMMX()) ? 1 : 0)
822 /* Feature 2 is has-AltiVec */
823 | ((SDL_HasAltiVec()) ? 2 : 0)
824 /* Feature 4 is dont-use-prefetch */
825 /* !!!! FIXME: Check for G5 or later, not the cache size! Always prefetch on a G4. */
826 | ((GetL3CacheSize() == 0) ? 4 : 0)
833 /* Feature 1 is has-MMX */
834 #define GetBlitFeatures() ((Uint32)(SDL_HasMMX() ? 1 : 0))
837 /* This is now endian dependent */
838 #if SDL_BYTEORDER == SDL_LIL_ENDIAN
841 #else /* SDL_BYTEORDER == SDL_BIG_ENDIAN */
846 #if SDL_HERMES_BLITTERS
848 /* Heheheh, we coerce Hermes into using SDL blit information */
849 #define X86_ASSEMBLER
850 #define HermesConverterInterface SDL_BlitInfo
851 #define HermesClearInterface void
854 #include "../hermes/HeadMMX.h"
855 #include "../hermes/HeadX86.h"
859 /* Special optimized blit for RGB 8-8-8 --> RGB 3-3-2 */
860 #define RGB888_RGB332(dst, src) { \
861 dst = (Uint8)((((src)&0x00E00000)>>16)| \
862 (((src)&0x0000E000)>>11)| \
863 (((src)&0x000000C0)>>6)); \
865 static void Blit_RGB888_index8(SDL_BlitInfo *info)
867 #ifndef USE_DUFFS_LOOP
874 int srcskip, dstskip;
876 /* Set up some basic variables */
877 width = info->d_width;
878 height = info->d_height;
879 src = (Uint32 *)info->s_pixels;
880 srcskip = info->s_skip/4;
881 dst = info->d_pixels;
882 dstskip = info->d_skip;
887 #ifdef USE_DUFFS_LOOP
889 RGB888_RGB332(*dst++, *src);
892 for ( c=width/4; c; --c ) {
893 /* Pack RGB into 8bit pixel */
895 RGB888_RGB332(*dst++, *src);
897 RGB888_RGB332(*dst++, *src);
899 RGB888_RGB332(*dst++, *src);
902 switch ( width & 3 ) {
904 RGB888_RGB332(*dst++, *src);
907 RGB888_RGB332(*dst++, *src);
910 RGB888_RGB332(*dst++, *src);
913 #endif /* USE_DUFFS_LOOP */
921 #ifdef USE_DUFFS_LOOP
923 RGB888_RGB332(Pixel, *src);
928 for ( c=width/4; c; --c ) {
929 /* Pack RGB into 8bit pixel */
930 RGB888_RGB332(Pixel, *src);
933 RGB888_RGB332(Pixel, *src);
936 RGB888_RGB332(Pixel, *src);
939 RGB888_RGB332(Pixel, *src);
943 switch ( width & 3 ) {
945 RGB888_RGB332(Pixel, *src);
949 RGB888_RGB332(Pixel, *src);
953 RGB888_RGB332(Pixel, *src);
957 #endif /* USE_DUFFS_LOOP */
963 /* Special optimized blit for RGB 8-8-8 --> RGB 5-5-5 */
964 #define RGB888_RGB555(dst, src) { \
965 *(Uint16 *)(dst) = (Uint16)((((*src)&0x00F80000)>>9)| \
966 (((*src)&0x0000F800)>>6)| \
967 (((*src)&0x000000F8)>>3)); \
969 #define RGB888_RGB555_TWO(dst, src) { \
970 *(Uint32 *)(dst) = (((((src[HI])&0x00F80000)>>9)| \
971 (((src[HI])&0x0000F800)>>6)| \
972 (((src[HI])&0x000000F8)>>3))<<16)| \
973 (((src[LO])&0x00F80000)>>9)| \
974 (((src[LO])&0x0000F800)>>6)| \
975 (((src[LO])&0x000000F8)>>3); \
977 static void Blit_RGB888_RGB555(SDL_BlitInfo *info)
979 #ifndef USE_DUFFS_LOOP
985 int srcskip, dstskip;
987 /* Set up some basic variables */
988 width = info->d_width;
989 height = info->d_height;
990 src = (Uint32 *)info->s_pixels;
991 srcskip = info->s_skip/4;
992 dst = (Uint16 *)info->d_pixels;
993 dstskip = info->d_skip/2;
995 #ifdef USE_DUFFS_LOOP
998 RGB888_RGB555(dst, src);
1006 /* Memory align at 4-byte boundary, if necessary */
1007 if ( (long)dst & 0x03 ) {
1008 /* Don't do anything if width is 0 */
1014 while ( height-- ) {
1015 /* Perform copy alignment */
1016 RGB888_RGB555(dst, src);
1020 /* Copy in 4 pixel chunks */
1021 for ( c=width/4; c; --c ) {
1022 RGB888_RGB555_TWO(dst, src);
1025 RGB888_RGB555_TWO(dst, src);
1029 /* Get any leftovers */
1030 switch (width & 3) {
1032 RGB888_RGB555(dst, src);
1036 RGB888_RGB555_TWO(dst, src);
1041 RGB888_RGB555(dst, src);
1050 while ( height-- ) {
1051 /* Copy in 4 pixel chunks */
1052 for ( c=width/4; c; --c ) {
1053 RGB888_RGB555_TWO(dst, src);
1056 RGB888_RGB555_TWO(dst, src);
1060 /* Get any leftovers */
1061 switch (width & 3) {
1063 RGB888_RGB555(dst, src);
1067 RGB888_RGB555_TWO(dst, src);
1072 RGB888_RGB555(dst, src);
1081 #endif /* USE_DUFFS_LOOP */
1083 /* Special optimized blit for RGB 8-8-8 --> RGB 5-6-5 */
1084 #define RGB888_RGB565(dst, src) { \
1085 *(Uint16 *)(dst) = (Uint16)((((*src)&0x00F80000)>>8)| \
1086 (((*src)&0x0000FC00)>>5)| \
1087 (((*src)&0x000000F8)>>3)); \
1089 #define RGB888_RGB565_TWO(dst, src) { \
1090 *(Uint32 *)(dst) = (((((src[HI])&0x00F80000)>>8)| \
1091 (((src[HI])&0x0000FC00)>>5)| \
1092 (((src[HI])&0x000000F8)>>3))<<16)| \
1093 (((src[LO])&0x00F80000)>>8)| \
1094 (((src[LO])&0x0000FC00)>>5)| \
1095 (((src[LO])&0x000000F8)>>3); \
1097 static void Blit_RGB888_RGB565(SDL_BlitInfo *info)
1099 #ifndef USE_DUFFS_LOOP
1105 int srcskip, dstskip;
1107 /* Set up some basic variables */
1108 width = info->d_width;
1109 height = info->d_height;
1110 src = (Uint32 *)info->s_pixels;
1111 srcskip = info->s_skip/4;
1112 dst = (Uint16 *)info->d_pixels;
1113 dstskip = info->d_skip/2;
1115 #ifdef USE_DUFFS_LOOP
1116 while ( height-- ) {
1118 RGB888_RGB565(dst, src);
1126 /* Memory align at 4-byte boundary, if necessary */
1127 if ( (long)dst & 0x03 ) {
1128 /* Don't do anything if width is 0 */
1134 while ( height-- ) {
1135 /* Perform copy alignment */
1136 RGB888_RGB565(dst, src);
1140 /* Copy in 4 pixel chunks */
1141 for ( c=width/4; c; --c ) {
1142 RGB888_RGB565_TWO(dst, src);
1145 RGB888_RGB565_TWO(dst, src);
1149 /* Get any leftovers */
1150 switch (width & 3) {
1152 RGB888_RGB565(dst, src);
1156 RGB888_RGB565_TWO(dst, src);
1161 RGB888_RGB565(dst, src);
1170 while ( height-- ) {
1171 /* Copy in 4 pixel chunks */
1172 for ( c=width/4; c; --c ) {
1173 RGB888_RGB565_TWO(dst, src);
1176 RGB888_RGB565_TWO(dst, src);
1180 /* Get any leftovers */
1181 switch (width & 3) {
1183 RGB888_RGB565(dst, src);
1187 RGB888_RGB565_TWO(dst, src);
1192 RGB888_RGB565(dst, src);
1201 #endif /* USE_DUFFS_LOOP */
1204 #endif /* SDL_HERMES_BLITTERS */
1207 /* Special optimized blit for RGB 5-6-5 --> 32-bit RGB surfaces */
1208 #define RGB565_32(dst, src, map) (map[src[LO]*2] + map[src[HI]*2+1])
1209 static void Blit_RGB565_32(SDL_BlitInfo *info, const Uint32 *map)
1211 #ifndef USE_DUFFS_LOOP
1217 int srcskip, dstskip;
1219 /* Set up some basic variables */
1220 width = info->d_width;
1221 height = info->d_height;
1222 src = (Uint8 *)info->s_pixels;
1223 srcskip = info->s_skip;
1224 dst = (Uint32 *)info->d_pixels;
1225 dstskip = info->d_skip/4;
1227 #ifdef USE_DUFFS_LOOP
1228 while ( height-- ) {
1231 *dst++ = RGB565_32(dst, src, map);
1239 while ( height-- ) {
1240 /* Copy in 4 pixel chunks */
1241 for ( c=width/4; c; --c ) {
1242 *dst++ = RGB565_32(dst, src, map);
1244 *dst++ = RGB565_32(dst, src, map);
1246 *dst++ = RGB565_32(dst, src, map);
1248 *dst++ = RGB565_32(dst, src, map);
1251 /* Get any leftovers */
1252 switch (width & 3) {
1254 *dst++ = RGB565_32(dst, src, map);
1257 *dst++ = RGB565_32(dst, src, map);
1260 *dst++ = RGB565_32(dst, src, map);
1267 #endif /* USE_DUFFS_LOOP */
1270 /* Special optimized blit for RGB 5-6-5 --> ARGB 8-8-8-8 */
1271 static const Uint32 RGB565_ARGB8888_LUT[512] = {
1272 0x00000000, 0xff000000, 0x00000008, 0xff002000,
1273 0x00000010, 0xff004000, 0x00000018, 0xff006100,
1274 0x00000020, 0xff008100, 0x00000029, 0xff00a100,
1275 0x00000031, 0xff00c200, 0x00000039, 0xff00e200,
1276 0x00000041, 0xff080000, 0x0000004a, 0xff082000,
1277 0x00000052, 0xff084000, 0x0000005a, 0xff086100,
1278 0x00000062, 0xff088100, 0x0000006a, 0xff08a100,
1279 0x00000073, 0xff08c200, 0x0000007b, 0xff08e200,
1280 0x00000083, 0xff100000, 0x0000008b, 0xff102000,
1281 0x00000094, 0xff104000, 0x0000009c, 0xff106100,
1282 0x000000a4, 0xff108100, 0x000000ac, 0xff10a100,
1283 0x000000b4, 0xff10c200, 0x000000bd, 0xff10e200,
1284 0x000000c5, 0xff180000, 0x000000cd, 0xff182000,
1285 0x000000d5, 0xff184000, 0x000000de, 0xff186100,
1286 0x000000e6, 0xff188100, 0x000000ee, 0xff18a100,
1287 0x000000f6, 0xff18c200, 0x000000ff, 0xff18e200,
1288 0x00000400, 0xff200000, 0x00000408, 0xff202000,
1289 0x00000410, 0xff204000, 0x00000418, 0xff206100,
1290 0x00000420, 0xff208100, 0x00000429, 0xff20a100,
1291 0x00000431, 0xff20c200, 0x00000439, 0xff20e200,
1292 0x00000441, 0xff290000, 0x0000044a, 0xff292000,
1293 0x00000452, 0xff294000, 0x0000045a, 0xff296100,
1294 0x00000462, 0xff298100, 0x0000046a, 0xff29a100,
1295 0x00000473, 0xff29c200, 0x0000047b, 0xff29e200,
1296 0x00000483, 0xff310000, 0x0000048b, 0xff312000,
1297 0x00000494, 0xff314000, 0x0000049c, 0xff316100,
1298 0x000004a4, 0xff318100, 0x000004ac, 0xff31a100,
1299 0x000004b4, 0xff31c200, 0x000004bd, 0xff31e200,
1300 0x000004c5, 0xff390000, 0x000004cd, 0xff392000,
1301 0x000004d5, 0xff394000, 0x000004de, 0xff396100,
1302 0x000004e6, 0xff398100, 0x000004ee, 0xff39a100,
1303 0x000004f6, 0xff39c200, 0x000004ff, 0xff39e200,
1304 0x00000800, 0xff410000, 0x00000808, 0xff412000,
1305 0x00000810, 0xff414000, 0x00000818, 0xff416100,
1306 0x00000820, 0xff418100, 0x00000829, 0xff41a100,
1307 0x00000831, 0xff41c200, 0x00000839, 0xff41e200,
1308 0x00000841, 0xff4a0000, 0x0000084a, 0xff4a2000,
1309 0x00000852, 0xff4a4000, 0x0000085a, 0xff4a6100,
1310 0x00000862, 0xff4a8100, 0x0000086a, 0xff4aa100,
1311 0x00000873, 0xff4ac200, 0x0000087b, 0xff4ae200,
1312 0x00000883, 0xff520000, 0x0000088b, 0xff522000,
1313 0x00000894, 0xff524000, 0x0000089c, 0xff526100,
1314 0x000008a4, 0xff528100, 0x000008ac, 0xff52a100,
1315 0x000008b4, 0xff52c200, 0x000008bd, 0xff52e200,
1316 0x000008c5, 0xff5a0000, 0x000008cd, 0xff5a2000,
1317 0x000008d5, 0xff5a4000, 0x000008de, 0xff5a6100,
1318 0x000008e6, 0xff5a8100, 0x000008ee, 0xff5aa100,
1319 0x000008f6, 0xff5ac200, 0x000008ff, 0xff5ae200,
1320 0x00000c00, 0xff620000, 0x00000c08, 0xff622000,
1321 0x00000c10, 0xff624000, 0x00000c18, 0xff626100,
1322 0x00000c20, 0xff628100, 0x00000c29, 0xff62a100,
1323 0x00000c31, 0xff62c200, 0x00000c39, 0xff62e200,
1324 0x00000c41, 0xff6a0000, 0x00000c4a, 0xff6a2000,
1325 0x00000c52, 0xff6a4000, 0x00000c5a, 0xff6a6100,
1326 0x00000c62, 0xff6a8100, 0x00000c6a, 0xff6aa100,
1327 0x00000c73, 0xff6ac200, 0x00000c7b, 0xff6ae200,
1328 0x00000c83, 0xff730000, 0x00000c8b, 0xff732000,
1329 0x00000c94, 0xff734000, 0x00000c9c, 0xff736100,
1330 0x00000ca4, 0xff738100, 0x00000cac, 0xff73a100,
1331 0x00000cb4, 0xff73c200, 0x00000cbd, 0xff73e200,
1332 0x00000cc5, 0xff7b0000, 0x00000ccd, 0xff7b2000,
1333 0x00000cd5, 0xff7b4000, 0x00000cde, 0xff7b6100,
1334 0x00000ce6, 0xff7b8100, 0x00000cee, 0xff7ba100,
1335 0x00000cf6, 0xff7bc200, 0x00000cff, 0xff7be200,
1336 0x00001000, 0xff830000, 0x00001008, 0xff832000,
1337 0x00001010, 0xff834000, 0x00001018, 0xff836100,
1338 0x00001020, 0xff838100, 0x00001029, 0xff83a100,
1339 0x00001031, 0xff83c200, 0x00001039, 0xff83e200,
1340 0x00001041, 0xff8b0000, 0x0000104a, 0xff8b2000,
1341 0x00001052, 0xff8b4000, 0x0000105a, 0xff8b6100,
1342 0x00001062, 0xff8b8100, 0x0000106a, 0xff8ba100,
1343 0x00001073, 0xff8bc200, 0x0000107b, 0xff8be200,
1344 0x00001083, 0xff940000, 0x0000108b, 0xff942000,
1345 0x00001094, 0xff944000, 0x0000109c, 0xff946100,
1346 0x000010a4, 0xff948100, 0x000010ac, 0xff94a100,
1347 0x000010b4, 0xff94c200, 0x000010bd, 0xff94e200,
1348 0x000010c5, 0xff9c0000, 0x000010cd, 0xff9c2000,
1349 0x000010d5, 0xff9c4000, 0x000010de, 0xff9c6100,
1350 0x000010e6, 0xff9c8100, 0x000010ee, 0xff9ca100,
1351 0x000010f6, 0xff9cc200, 0x000010ff, 0xff9ce200,
1352 0x00001400, 0xffa40000, 0x00001408, 0xffa42000,
1353 0x00001410, 0xffa44000, 0x00001418, 0xffa46100,
1354 0x00001420, 0xffa48100, 0x00001429, 0xffa4a100,
1355 0x00001431, 0xffa4c200, 0x00001439, 0xffa4e200,
1356 0x00001441, 0xffac0000, 0x0000144a, 0xffac2000,
1357 0x00001452, 0xffac4000, 0x0000145a, 0xffac6100,
1358 0x00001462, 0xffac8100, 0x0000146a, 0xffaca100,
1359 0x00001473, 0xffacc200, 0x0000147b, 0xfface200,
1360 0x00001483, 0xffb40000, 0x0000148b, 0xffb42000,
1361 0x00001494, 0xffb44000, 0x0000149c, 0xffb46100,
1362 0x000014a4, 0xffb48100, 0x000014ac, 0xffb4a100,
1363 0x000014b4, 0xffb4c200, 0x000014bd, 0xffb4e200,
1364 0x000014c5, 0xffbd0000, 0x000014cd, 0xffbd2000,
1365 0x000014d5, 0xffbd4000, 0x000014de, 0xffbd6100,
1366 0x000014e6, 0xffbd8100, 0x000014ee, 0xffbda100,
1367 0x000014f6, 0xffbdc200, 0x000014ff, 0xffbde200,
1368 0x00001800, 0xffc50000, 0x00001808, 0xffc52000,
1369 0x00001810, 0xffc54000, 0x00001818, 0xffc56100,
1370 0x00001820, 0xffc58100, 0x00001829, 0xffc5a100,
1371 0x00001831, 0xffc5c200, 0x00001839, 0xffc5e200,
1372 0x00001841, 0xffcd0000, 0x0000184a, 0xffcd2000,
1373 0x00001852, 0xffcd4000, 0x0000185a, 0xffcd6100,
1374 0x00001862, 0xffcd8100, 0x0000186a, 0xffcda100,
1375 0x00001873, 0xffcdc200, 0x0000187b, 0xffcde200,
1376 0x00001883, 0xffd50000, 0x0000188b, 0xffd52000,
1377 0x00001894, 0xffd54000, 0x0000189c, 0xffd56100,
1378 0x000018a4, 0xffd58100, 0x000018ac, 0xffd5a100,
1379 0x000018b4, 0xffd5c200, 0x000018bd, 0xffd5e200,
1380 0x000018c5, 0xffde0000, 0x000018cd, 0xffde2000,
1381 0x000018d5, 0xffde4000, 0x000018de, 0xffde6100,
1382 0x000018e6, 0xffde8100, 0x000018ee, 0xffdea100,
1383 0x000018f6, 0xffdec200, 0x000018ff, 0xffdee200,
1384 0x00001c00, 0xffe60000, 0x00001c08, 0xffe62000,
1385 0x00001c10, 0xffe64000, 0x00001c18, 0xffe66100,
1386 0x00001c20, 0xffe68100, 0x00001c29, 0xffe6a100,
1387 0x00001c31, 0xffe6c200, 0x00001c39, 0xffe6e200,
1388 0x00001c41, 0xffee0000, 0x00001c4a, 0xffee2000,
1389 0x00001c52, 0xffee4000, 0x00001c5a, 0xffee6100,
1390 0x00001c62, 0xffee8100, 0x00001c6a, 0xffeea100,
1391 0x00001c73, 0xffeec200, 0x00001c7b, 0xffeee200,
1392 0x00001c83, 0xfff60000, 0x00001c8b, 0xfff62000,
1393 0x00001c94, 0xfff64000, 0x00001c9c, 0xfff66100,
1394 0x00001ca4, 0xfff68100, 0x00001cac, 0xfff6a100,
1395 0x00001cb4, 0xfff6c200, 0x00001cbd, 0xfff6e200,
1396 0x00001cc5, 0xffff0000, 0x00001ccd, 0xffff2000,
1397 0x00001cd5, 0xffff4000, 0x00001cde, 0xffff6100,
1398 0x00001ce6, 0xffff8100, 0x00001cee, 0xffffa100,
1399 0x00001cf6, 0xffffc200, 0x00001cff, 0xffffe200
1401 static void Blit_RGB565_ARGB8888(SDL_BlitInfo *info)
1403 Blit_RGB565_32(info, RGB565_ARGB8888_LUT);
1406 /* Special optimized blit for RGB 5-6-5 --> ABGR 8-8-8-8 */
1407 static const Uint32 RGB565_ABGR8888_LUT[512] = {
1408 0xff000000, 0x00000000, 0xff080000, 0x00002000,
1409 0xff100000, 0x00004000, 0xff180000, 0x00006100,
1410 0xff200000, 0x00008100, 0xff290000, 0x0000a100,
1411 0xff310000, 0x0000c200, 0xff390000, 0x0000e200,
1412 0xff410000, 0x00000008, 0xff4a0000, 0x00002008,
1413 0xff520000, 0x00004008, 0xff5a0000, 0x00006108,
1414 0xff620000, 0x00008108, 0xff6a0000, 0x0000a108,
1415 0xff730000, 0x0000c208, 0xff7b0000, 0x0000e208,
1416 0xff830000, 0x00000010, 0xff8b0000, 0x00002010,
1417 0xff940000, 0x00004010, 0xff9c0000, 0x00006110,
1418 0xffa40000, 0x00008110, 0xffac0000, 0x0000a110,
1419 0xffb40000, 0x0000c210, 0xffbd0000, 0x0000e210,
1420 0xffc50000, 0x00000018, 0xffcd0000, 0x00002018,
1421 0xffd50000, 0x00004018, 0xffde0000, 0x00006118,
1422 0xffe60000, 0x00008118, 0xffee0000, 0x0000a118,
1423 0xfff60000, 0x0000c218, 0xffff0000, 0x0000e218,
1424 0xff000400, 0x00000020, 0xff080400, 0x00002020,
1425 0xff100400, 0x00004020, 0xff180400, 0x00006120,
1426 0xff200400, 0x00008120, 0xff290400, 0x0000a120,
1427 0xff310400, 0x0000c220, 0xff390400, 0x0000e220,
1428 0xff410400, 0x00000029, 0xff4a0400, 0x00002029,
1429 0xff520400, 0x00004029, 0xff5a0400, 0x00006129,
1430 0xff620400, 0x00008129, 0xff6a0400, 0x0000a129,
1431 0xff730400, 0x0000c229, 0xff7b0400, 0x0000e229,
1432 0xff830400, 0x00000031, 0xff8b0400, 0x00002031,
1433 0xff940400, 0x00004031, 0xff9c0400, 0x00006131,
1434 0xffa40400, 0x00008131, 0xffac0400, 0x0000a131,
1435 0xffb40400, 0x0000c231, 0xffbd0400, 0x0000e231,
1436 0xffc50400, 0x00000039, 0xffcd0400, 0x00002039,
1437 0xffd50400, 0x00004039, 0xffde0400, 0x00006139,
1438 0xffe60400, 0x00008139, 0xffee0400, 0x0000a139,
1439 0xfff60400, 0x0000c239, 0xffff0400, 0x0000e239,
1440 0xff000800, 0x00000041, 0xff080800, 0x00002041,
1441 0xff100800, 0x00004041, 0xff180800, 0x00006141,
1442 0xff200800, 0x00008141, 0xff290800, 0x0000a141,
1443 0xff310800, 0x0000c241, 0xff390800, 0x0000e241,
1444 0xff410800, 0x0000004a, 0xff4a0800, 0x0000204a,
1445 0xff520800, 0x0000404a, 0xff5a0800, 0x0000614a,
1446 0xff620800, 0x0000814a, 0xff6a0800, 0x0000a14a,
1447 0xff730800, 0x0000c24a, 0xff7b0800, 0x0000e24a,
1448 0xff830800, 0x00000052, 0xff8b0800, 0x00002052,
1449 0xff940800, 0x00004052, 0xff9c0800, 0x00006152,
1450 0xffa40800, 0x00008152, 0xffac0800, 0x0000a152,
1451 0xffb40800, 0x0000c252, 0xffbd0800, 0x0000e252,
1452 0xffc50800, 0x0000005a, 0xffcd0800, 0x0000205a,
1453 0xffd50800, 0x0000405a, 0xffde0800, 0x0000615a,
1454 0xffe60800, 0x0000815a, 0xffee0800, 0x0000a15a,
1455 0xfff60800, 0x0000c25a, 0xffff0800, 0x0000e25a,
1456 0xff000c00, 0x00000062, 0xff080c00, 0x00002062,
1457 0xff100c00, 0x00004062, 0xff180c00, 0x00006162,
1458 0xff200c00, 0x00008162, 0xff290c00, 0x0000a162,
1459 0xff310c00, 0x0000c262, 0xff390c00, 0x0000e262,
1460 0xff410c00, 0x0000006a, 0xff4a0c00, 0x0000206a,
1461 0xff520c00, 0x0000406a, 0xff5a0c00, 0x0000616a,
1462 0xff620c00, 0x0000816a, 0xff6a0c00, 0x0000a16a,
1463 0xff730c00, 0x0000c26a, 0xff7b0c00, 0x0000e26a,
1464 0xff830c00, 0x00000073, 0xff8b0c00, 0x00002073,
1465 0xff940c00, 0x00004073, 0xff9c0c00, 0x00006173,
1466 0xffa40c00, 0x00008173, 0xffac0c00, 0x0000a173,
1467 0xffb40c00, 0x0000c273, 0xffbd0c00, 0x0000e273,
1468 0xffc50c00, 0x0000007b, 0xffcd0c00, 0x0000207b,
1469 0xffd50c00, 0x0000407b, 0xffde0c00, 0x0000617b,
1470 0xffe60c00, 0x0000817b, 0xffee0c00, 0x0000a17b,
1471 0xfff60c00, 0x0000c27b, 0xffff0c00, 0x0000e27b,
1472 0xff001000, 0x00000083, 0xff081000, 0x00002083,
1473 0xff101000, 0x00004083, 0xff181000, 0x00006183,
1474 0xff201000, 0x00008183, 0xff291000, 0x0000a183,
1475 0xff311000, 0x0000c283, 0xff391000, 0x0000e283,
1476 0xff411000, 0x0000008b, 0xff4a1000, 0x0000208b,
1477 0xff521000, 0x0000408b, 0xff5a1000, 0x0000618b,
1478 0xff621000, 0x0000818b, 0xff6a1000, 0x0000a18b,
1479 0xff731000, 0x0000c28b, 0xff7b1000, 0x0000e28b,
1480 0xff831000, 0x00000094, 0xff8b1000, 0x00002094,
1481 0xff941000, 0x00004094, 0xff9c1000, 0x00006194,
1482 0xffa41000, 0x00008194, 0xffac1000, 0x0000a194,
1483 0xffb41000, 0x0000c294, 0xffbd1000, 0x0000e294,
1484 0xffc51000, 0x0000009c, 0xffcd1000, 0x0000209c,
1485 0xffd51000, 0x0000409c, 0xffde1000, 0x0000619c,
1486 0xffe61000, 0x0000819c, 0xffee1000, 0x0000a19c,
1487 0xfff61000, 0x0000c29c, 0xffff1000, 0x0000e29c,
1488 0xff001400, 0x000000a4, 0xff081400, 0x000020a4,
1489 0xff101400, 0x000040a4, 0xff181400, 0x000061a4,
1490 0xff201400, 0x000081a4, 0xff291400, 0x0000a1a4,
1491 0xff311400, 0x0000c2a4, 0xff391400, 0x0000e2a4,
1492 0xff411400, 0x000000ac, 0xff4a1400, 0x000020ac,
1493 0xff521400, 0x000040ac, 0xff5a1400, 0x000061ac,
1494 0xff621400, 0x000081ac, 0xff6a1400, 0x0000a1ac,
1495 0xff731400, 0x0000c2ac, 0xff7b1400, 0x0000e2ac,
1496 0xff831400, 0x000000b4, 0xff8b1400, 0x000020b4,
1497 0xff941400, 0x000040b4, 0xff9c1400, 0x000061b4,
1498 0xffa41400, 0x000081b4, 0xffac1400, 0x0000a1b4,
1499 0xffb41400, 0x0000c2b4, 0xffbd1400, 0x0000e2b4,
1500 0xffc51400, 0x000000bd, 0xffcd1400, 0x000020bd,
1501 0xffd51400, 0x000040bd, 0xffde1400, 0x000061bd,
1502 0xffe61400, 0x000081bd, 0xffee1400, 0x0000a1bd,
1503 0xfff61400, 0x0000c2bd, 0xffff1400, 0x0000e2bd,
1504 0xff001800, 0x000000c5, 0xff081800, 0x000020c5,
1505 0xff101800, 0x000040c5, 0xff181800, 0x000061c5,
1506 0xff201800, 0x000081c5, 0xff291800, 0x0000a1c5,
1507 0xff311800, 0x0000c2c5, 0xff391800, 0x0000e2c5,
1508 0xff411800, 0x000000cd, 0xff4a1800, 0x000020cd,
1509 0xff521800, 0x000040cd, 0xff5a1800, 0x000061cd,
1510 0xff621800, 0x000081cd, 0xff6a1800, 0x0000a1cd,
1511 0xff731800, 0x0000c2cd, 0xff7b1800, 0x0000e2cd,
1512 0xff831800, 0x000000d5, 0xff8b1800, 0x000020d5,
1513 0xff941800, 0x000040d5, 0xff9c1800, 0x000061d5,
1514 0xffa41800, 0x000081d5, 0xffac1800, 0x0000a1d5,
1515 0xffb41800, 0x0000c2d5, 0xffbd1800, 0x0000e2d5,
1516 0xffc51800, 0x000000de, 0xffcd1800, 0x000020de,
1517 0xffd51800, 0x000040de, 0xffde1800, 0x000061de,
1518 0xffe61800, 0x000081de, 0xffee1800, 0x0000a1de,
1519 0xfff61800, 0x0000c2de, 0xffff1800, 0x0000e2de,
1520 0xff001c00, 0x000000e6, 0xff081c00, 0x000020e6,
1521 0xff101c00, 0x000040e6, 0xff181c00, 0x000061e6,
1522 0xff201c00, 0x000081e6, 0xff291c00, 0x0000a1e6,
1523 0xff311c00, 0x0000c2e6, 0xff391c00, 0x0000e2e6,
1524 0xff411c00, 0x000000ee, 0xff4a1c00, 0x000020ee,
1525 0xff521c00, 0x000040ee, 0xff5a1c00, 0x000061ee,
1526 0xff621c00, 0x000081ee, 0xff6a1c00, 0x0000a1ee,
1527 0xff731c00, 0x0000c2ee, 0xff7b1c00, 0x0000e2ee,
1528 0xff831c00, 0x000000f6, 0xff8b1c00, 0x000020f6,
1529 0xff941c00, 0x000040f6, 0xff9c1c00, 0x000061f6,
1530 0xffa41c00, 0x000081f6, 0xffac1c00, 0x0000a1f6,
1531 0xffb41c00, 0x0000c2f6, 0xffbd1c00, 0x0000e2f6,
1532 0xffc51c00, 0x000000ff, 0xffcd1c00, 0x000020ff,
1533 0xffd51c00, 0x000040ff, 0xffde1c00, 0x000061ff,
1534 0xffe61c00, 0x000081ff, 0xffee1c00, 0x0000a1ff,
1535 0xfff61c00, 0x0000c2ff, 0xffff1c00, 0x0000e2ff
1537 static void Blit_RGB565_ABGR8888(SDL_BlitInfo *info)
1539 Blit_RGB565_32(info, RGB565_ABGR8888_LUT);
1542 /* Special optimized blit for RGB 5-6-5 --> RGBA 8-8-8-8 */
1543 static const Uint32 RGB565_RGBA8888_LUT[512] = {
1544 0x000000ff, 0x00000000, 0x000008ff, 0x00200000,
1545 0x000010ff, 0x00400000, 0x000018ff, 0x00610000,
1546 0x000020ff, 0x00810000, 0x000029ff, 0x00a10000,
1547 0x000031ff, 0x00c20000, 0x000039ff, 0x00e20000,
1548 0x000041ff, 0x08000000, 0x00004aff, 0x08200000,
1549 0x000052ff, 0x08400000, 0x00005aff, 0x08610000,
1550 0x000062ff, 0x08810000, 0x00006aff, 0x08a10000,
1551 0x000073ff, 0x08c20000, 0x00007bff, 0x08e20000,
1552 0x000083ff, 0x10000000, 0x00008bff, 0x10200000,
1553 0x000094ff, 0x10400000, 0x00009cff, 0x10610000,
1554 0x0000a4ff, 0x10810000, 0x0000acff, 0x10a10000,
1555 0x0000b4ff, 0x10c20000, 0x0000bdff, 0x10e20000,
1556 0x0000c5ff, 0x18000000, 0x0000cdff, 0x18200000,
1557 0x0000d5ff, 0x18400000, 0x0000deff, 0x18610000,
1558 0x0000e6ff, 0x18810000, 0x0000eeff, 0x18a10000,
1559 0x0000f6ff, 0x18c20000, 0x0000ffff, 0x18e20000,
1560 0x000400ff, 0x20000000, 0x000408ff, 0x20200000,
1561 0x000410ff, 0x20400000, 0x000418ff, 0x20610000,
1562 0x000420ff, 0x20810000, 0x000429ff, 0x20a10000,
1563 0x000431ff, 0x20c20000, 0x000439ff, 0x20e20000,
1564 0x000441ff, 0x29000000, 0x00044aff, 0x29200000,
1565 0x000452ff, 0x29400000, 0x00045aff, 0x29610000,
1566 0x000462ff, 0x29810000, 0x00046aff, 0x29a10000,
1567 0x000473ff, 0x29c20000, 0x00047bff, 0x29e20000,
1568 0x000483ff, 0x31000000, 0x00048bff, 0x31200000,
1569 0x000494ff, 0x31400000, 0x00049cff, 0x31610000,
1570 0x0004a4ff, 0x31810000, 0x0004acff, 0x31a10000,
1571 0x0004b4ff, 0x31c20000, 0x0004bdff, 0x31e20000,
1572 0x0004c5ff, 0x39000000, 0x0004cdff, 0x39200000,
1573 0x0004d5ff, 0x39400000, 0x0004deff, 0x39610000,
1574 0x0004e6ff, 0x39810000, 0x0004eeff, 0x39a10000,
1575 0x0004f6ff, 0x39c20000, 0x0004ffff, 0x39e20000,
1576 0x000800ff, 0x41000000, 0x000808ff, 0x41200000,
1577 0x000810ff, 0x41400000, 0x000818ff, 0x41610000,
1578 0x000820ff, 0x41810000, 0x000829ff, 0x41a10000,
1579 0x000831ff, 0x41c20000, 0x000839ff, 0x41e20000,
1580 0x000841ff, 0x4a000000, 0x00084aff, 0x4a200000,
1581 0x000852ff, 0x4a400000, 0x00085aff, 0x4a610000,
1582 0x000862ff, 0x4a810000, 0x00086aff, 0x4aa10000,
1583 0x000873ff, 0x4ac20000, 0x00087bff, 0x4ae20000,
1584 0x000883ff, 0x52000000, 0x00088bff, 0x52200000,
1585 0x000894ff, 0x52400000, 0x00089cff, 0x52610000,
1586 0x0008a4ff, 0x52810000, 0x0008acff, 0x52a10000,
1587 0x0008b4ff, 0x52c20000, 0x0008bdff, 0x52e20000,
1588 0x0008c5ff, 0x5a000000, 0x0008cdff, 0x5a200000,
1589 0x0008d5ff, 0x5a400000, 0x0008deff, 0x5a610000,
1590 0x0008e6ff, 0x5a810000, 0x0008eeff, 0x5aa10000,
1591 0x0008f6ff, 0x5ac20000, 0x0008ffff, 0x5ae20000,
1592 0x000c00ff, 0x62000000, 0x000c08ff, 0x62200000,
1593 0x000c10ff, 0x62400000, 0x000c18ff, 0x62610000,
1594 0x000c20ff, 0x62810000, 0x000c29ff, 0x62a10000,
1595 0x000c31ff, 0x62c20000, 0x000c39ff, 0x62e20000,
1596 0x000c41ff, 0x6a000000, 0x000c4aff, 0x6a200000,
1597 0x000c52ff, 0x6a400000, 0x000c5aff, 0x6a610000,
1598 0x000c62ff, 0x6a810000, 0x000c6aff, 0x6aa10000,
1599 0x000c73ff, 0x6ac20000, 0x000c7bff, 0x6ae20000,
1600 0x000c83ff, 0x73000000, 0x000c8bff, 0x73200000,
1601 0x000c94ff, 0x73400000, 0x000c9cff, 0x73610000,
1602 0x000ca4ff, 0x73810000, 0x000cacff, 0x73a10000,
1603 0x000cb4ff, 0x73c20000, 0x000cbdff, 0x73e20000,
1604 0x000cc5ff, 0x7b000000, 0x000ccdff, 0x7b200000,
1605 0x000cd5ff, 0x7b400000, 0x000cdeff, 0x7b610000,
1606 0x000ce6ff, 0x7b810000, 0x000ceeff, 0x7ba10000,
1607 0x000cf6ff, 0x7bc20000, 0x000cffff, 0x7be20000,
1608 0x001000ff, 0x83000000, 0x001008ff, 0x83200000,
1609 0x001010ff, 0x83400000, 0x001018ff, 0x83610000,
1610 0x001020ff, 0x83810000, 0x001029ff, 0x83a10000,
1611 0x001031ff, 0x83c20000, 0x001039ff, 0x83e20000,
1612 0x001041ff, 0x8b000000, 0x00104aff, 0x8b200000,
1613 0x001052ff, 0x8b400000, 0x00105aff, 0x8b610000,
1614 0x001062ff, 0x8b810000, 0x00106aff, 0x8ba10000,
1615 0x001073ff, 0x8bc20000, 0x00107bff, 0x8be20000,
1616 0x001083ff, 0x94000000, 0x00108bff, 0x94200000,
1617 0x001094ff, 0x94400000, 0x00109cff, 0x94610000,
1618 0x0010a4ff, 0x94810000, 0x0010acff, 0x94a10000,
1619 0x0010b4ff, 0x94c20000, 0x0010bdff, 0x94e20000,
1620 0x0010c5ff, 0x9c000000, 0x0010cdff, 0x9c200000,
1621 0x0010d5ff, 0x9c400000, 0x0010deff, 0x9c610000,
1622 0x0010e6ff, 0x9c810000, 0x0010eeff, 0x9ca10000,
1623 0x0010f6ff, 0x9cc20000, 0x0010ffff, 0x9ce20000,
1624 0x001400ff, 0xa4000000, 0x001408ff, 0xa4200000,
1625 0x001410ff, 0xa4400000, 0x001418ff, 0xa4610000,
1626 0x001420ff, 0xa4810000, 0x001429ff, 0xa4a10000,
1627 0x001431ff, 0xa4c20000, 0x001439ff, 0xa4e20000,
1628 0x001441ff, 0xac000000, 0x00144aff, 0xac200000,
1629 0x001452ff, 0xac400000, 0x00145aff, 0xac610000,
1630 0x001462ff, 0xac810000, 0x00146aff, 0xaca10000,
1631 0x001473ff, 0xacc20000, 0x00147bff, 0xace20000,
1632 0x001483ff, 0xb4000000, 0x00148bff, 0xb4200000,
1633 0x001494ff, 0xb4400000, 0x00149cff, 0xb4610000,
1634 0x0014a4ff, 0xb4810000, 0x0014acff, 0xb4a10000,
1635 0x0014b4ff, 0xb4c20000, 0x0014bdff, 0xb4e20000,
1636 0x0014c5ff, 0xbd000000, 0x0014cdff, 0xbd200000,
1637 0x0014d5ff, 0xbd400000, 0x0014deff, 0xbd610000,
1638 0x0014e6ff, 0xbd810000, 0x0014eeff, 0xbda10000,
1639 0x0014f6ff, 0xbdc20000, 0x0014ffff, 0xbde20000,
1640 0x001800ff, 0xc5000000, 0x001808ff, 0xc5200000,
1641 0x001810ff, 0xc5400000, 0x001818ff, 0xc5610000,
1642 0x001820ff, 0xc5810000, 0x001829ff, 0xc5a10000,
1643 0x001831ff, 0xc5c20000, 0x001839ff, 0xc5e20000,
1644 0x001841ff, 0xcd000000, 0x00184aff, 0xcd200000,
1645 0x001852ff, 0xcd400000, 0x00185aff, 0xcd610000,
1646 0x001862ff, 0xcd810000, 0x00186aff, 0xcda10000,
1647 0x001873ff, 0xcdc20000, 0x00187bff, 0xcde20000,
1648 0x001883ff, 0xd5000000, 0x00188bff, 0xd5200000,
1649 0x001894ff, 0xd5400000, 0x00189cff, 0xd5610000,
1650 0x0018a4ff, 0xd5810000, 0x0018acff, 0xd5a10000,
1651 0x0018b4ff, 0xd5c20000, 0x0018bdff, 0xd5e20000,
1652 0x0018c5ff, 0xde000000, 0x0018cdff, 0xde200000,
1653 0x0018d5ff, 0xde400000, 0x0018deff, 0xde610000,
1654 0x0018e6ff, 0xde810000, 0x0018eeff, 0xdea10000,
1655 0x0018f6ff, 0xdec20000, 0x0018ffff, 0xdee20000,
1656 0x001c00ff, 0xe6000000, 0x001c08ff, 0xe6200000,
1657 0x001c10ff, 0xe6400000, 0x001c18ff, 0xe6610000,
1658 0x001c20ff, 0xe6810000, 0x001c29ff, 0xe6a10000,
1659 0x001c31ff, 0xe6c20000, 0x001c39ff, 0xe6e20000,
1660 0x001c41ff, 0xee000000, 0x001c4aff, 0xee200000,
1661 0x001c52ff, 0xee400000, 0x001c5aff, 0xee610000,
1662 0x001c62ff, 0xee810000, 0x001c6aff, 0xeea10000,
1663 0x001c73ff, 0xeec20000, 0x001c7bff, 0xeee20000,
1664 0x001c83ff, 0xf6000000, 0x001c8bff, 0xf6200000,
1665 0x001c94ff, 0xf6400000, 0x001c9cff, 0xf6610000,
1666 0x001ca4ff, 0xf6810000, 0x001cacff, 0xf6a10000,
1667 0x001cb4ff, 0xf6c20000, 0x001cbdff, 0xf6e20000,
1668 0x001cc5ff, 0xff000000, 0x001ccdff, 0xff200000,
1669 0x001cd5ff, 0xff400000, 0x001cdeff, 0xff610000,
1670 0x001ce6ff, 0xff810000, 0x001ceeff, 0xffa10000,
1671 0x001cf6ff, 0xffc20000, 0x001cffff, 0xffe20000,
1673 static void Blit_RGB565_RGBA8888(SDL_BlitInfo *info)
1675 Blit_RGB565_32(info, RGB565_RGBA8888_LUT);
1678 /* Special optimized blit for RGB 5-6-5 --> BGRA 8-8-8-8 */
1679 static const Uint32 RGB565_BGRA8888_LUT[512] = {
1680 0x00000000, 0x000000ff, 0x08000000, 0x002000ff,
1681 0x10000000, 0x004000ff, 0x18000000, 0x006100ff,
1682 0x20000000, 0x008100ff, 0x29000000, 0x00a100ff,
1683 0x31000000, 0x00c200ff, 0x39000000, 0x00e200ff,
1684 0x41000000, 0x000008ff, 0x4a000000, 0x002008ff,
1685 0x52000000, 0x004008ff, 0x5a000000, 0x006108ff,
1686 0x62000000, 0x008108ff, 0x6a000000, 0x00a108ff,
1687 0x73000000, 0x00c208ff, 0x7b000000, 0x00e208ff,
1688 0x83000000, 0x000010ff, 0x8b000000, 0x002010ff,
1689 0x94000000, 0x004010ff, 0x9c000000, 0x006110ff,
1690 0xa4000000, 0x008110ff, 0xac000000, 0x00a110ff,
1691 0xb4000000, 0x00c210ff, 0xbd000000, 0x00e210ff,
1692 0xc5000000, 0x000018ff, 0xcd000000, 0x002018ff,
1693 0xd5000000, 0x004018ff, 0xde000000, 0x006118ff,
1694 0xe6000000, 0x008118ff, 0xee000000, 0x00a118ff,
1695 0xf6000000, 0x00c218ff, 0xff000000, 0x00e218ff,
1696 0x00040000, 0x000020ff, 0x08040000, 0x002020ff,
1697 0x10040000, 0x004020ff, 0x18040000, 0x006120ff,
1698 0x20040000, 0x008120ff, 0x29040000, 0x00a120ff,
1699 0x31040000, 0x00c220ff, 0x39040000, 0x00e220ff,
1700 0x41040000, 0x000029ff, 0x4a040000, 0x002029ff,
1701 0x52040000, 0x004029ff, 0x5a040000, 0x006129ff,
1702 0x62040000, 0x008129ff, 0x6a040000, 0x00a129ff,
1703 0x73040000, 0x00c229ff, 0x7b040000, 0x00e229ff,
1704 0x83040000, 0x000031ff, 0x8b040000, 0x002031ff,
1705 0x94040000, 0x004031ff, 0x9c040000, 0x006131ff,
1706 0xa4040000, 0x008131ff, 0xac040000, 0x00a131ff,
1707 0xb4040000, 0x00c231ff, 0xbd040000, 0x00e231ff,
1708 0xc5040000, 0x000039ff, 0xcd040000, 0x002039ff,
1709 0xd5040000, 0x004039ff, 0xde040000, 0x006139ff,
1710 0xe6040000, 0x008139ff, 0xee040000, 0x00a139ff,
1711 0xf6040000, 0x00c239ff, 0xff040000, 0x00e239ff,
1712 0x00080000, 0x000041ff, 0x08080000, 0x002041ff,
1713 0x10080000, 0x004041ff, 0x18080000, 0x006141ff,
1714 0x20080000, 0x008141ff, 0x29080000, 0x00a141ff,
1715 0x31080000, 0x00c241ff, 0x39080000, 0x00e241ff,
1716 0x41080000, 0x00004aff, 0x4a080000, 0x00204aff,
1717 0x52080000, 0x00404aff, 0x5a080000, 0x00614aff,
1718 0x62080000, 0x00814aff, 0x6a080000, 0x00a14aff,
1719 0x73080000, 0x00c24aff, 0x7b080000, 0x00e24aff,
1720 0x83080000, 0x000052ff, 0x8b080000, 0x002052ff,
1721 0x94080000, 0x004052ff, 0x9c080000, 0x006152ff,
1722 0xa4080000, 0x008152ff, 0xac080000, 0x00a152ff,
1723 0xb4080000, 0x00c252ff, 0xbd080000, 0x00e252ff,
1724 0xc5080000, 0x00005aff, 0xcd080000, 0x00205aff,
1725 0xd5080000, 0x00405aff, 0xde080000, 0x00615aff,
1726 0xe6080000, 0x00815aff, 0xee080000, 0x00a15aff,
1727 0xf6080000, 0x00c25aff, 0xff080000, 0x00e25aff,
1728 0x000c0000, 0x000062ff, 0x080c0000, 0x002062ff,
1729 0x100c0000, 0x004062ff, 0x180c0000, 0x006162ff,
1730 0x200c0000, 0x008162ff, 0x290c0000, 0x00a162ff,
1731 0x310c0000, 0x00c262ff, 0x390c0000, 0x00e262ff,
1732 0x410c0000, 0x00006aff, 0x4a0c0000, 0x00206aff,
1733 0x520c0000, 0x00406aff, 0x5a0c0000, 0x00616aff,
1734 0x620c0000, 0x00816aff, 0x6a0c0000, 0x00a16aff,
1735 0x730c0000, 0x00c26aff, 0x7b0c0000, 0x00e26aff,
1736 0x830c0000, 0x000073ff, 0x8b0c0000, 0x002073ff,
1737 0x940c0000, 0x004073ff, 0x9c0c0000, 0x006173ff,
1738 0xa40c0000, 0x008173ff, 0xac0c0000, 0x00a173ff,
1739 0xb40c0000, 0x00c273ff, 0xbd0c0000, 0x00e273ff,
1740 0xc50c0000, 0x00007bff, 0xcd0c0000, 0x00207bff,
1741 0xd50c0000, 0x00407bff, 0xde0c0000, 0x00617bff,
1742 0xe60c0000, 0x00817bff, 0xee0c0000, 0x00a17bff,
1743 0xf60c0000, 0x00c27bff, 0xff0c0000, 0x00e27bff,
1744 0x00100000, 0x000083ff, 0x08100000, 0x002083ff,
1745 0x10100000, 0x004083ff, 0x18100000, 0x006183ff,
1746 0x20100000, 0x008183ff, 0x29100000, 0x00a183ff,
1747 0x31100000, 0x00c283ff, 0x39100000, 0x00e283ff,
1748 0x41100000, 0x00008bff, 0x4a100000, 0x00208bff,
1749 0x52100000, 0x00408bff, 0x5a100000, 0x00618bff,
1750 0x62100000, 0x00818bff, 0x6a100000, 0x00a18bff,
1751 0x73100000, 0x00c28bff, 0x7b100000, 0x00e28bff,
1752 0x83100000, 0x000094ff, 0x8b100000, 0x002094ff,
1753 0x94100000, 0x004094ff, 0x9c100000, 0x006194ff,
1754 0xa4100000, 0x008194ff, 0xac100000, 0x00a194ff,
1755 0xb4100000, 0x00c294ff, 0xbd100000, 0x00e294ff,
1756 0xc5100000, 0x00009cff, 0xcd100000, 0x00209cff,
1757 0xd5100000, 0x00409cff, 0xde100000, 0x00619cff,
1758 0xe6100000, 0x00819cff, 0xee100000, 0x00a19cff,
1759 0xf6100000, 0x00c29cff, 0xff100000, 0x00e29cff,
1760 0x00140000, 0x0000a4ff, 0x08140000, 0x0020a4ff,
1761 0x10140000, 0x0040a4ff, 0x18140000, 0x0061a4ff,
1762 0x20140000, 0x0081a4ff, 0x29140000, 0x00a1a4ff,
1763 0x31140000, 0x00c2a4ff, 0x39140000, 0x00e2a4ff,
1764 0x41140000, 0x0000acff, 0x4a140000, 0x0020acff,
1765 0x52140000, 0x0040acff, 0x5a140000, 0x0061acff,
1766 0x62140000, 0x0081acff, 0x6a140000, 0x00a1acff,
1767 0x73140000, 0x00c2acff, 0x7b140000, 0x00e2acff,
1768 0x83140000, 0x0000b4ff, 0x8b140000, 0x0020b4ff,
1769 0x94140000, 0x0040b4ff, 0x9c140000, 0x0061b4ff,
1770 0xa4140000, 0x0081b4ff, 0xac140000, 0x00a1b4ff,
1771 0xb4140000, 0x00c2b4ff, 0xbd140000, 0x00e2b4ff,
1772 0xc5140000, 0x0000bdff, 0xcd140000, 0x0020bdff,
1773 0xd5140000, 0x0040bdff, 0xde140000, 0x0061bdff,
1774 0xe6140000, 0x0081bdff, 0xee140000, 0x00a1bdff,
1775 0xf6140000, 0x00c2bdff, 0xff140000, 0x00e2bdff,
1776 0x00180000, 0x0000c5ff, 0x08180000, 0x0020c5ff,
1777 0x10180000, 0x0040c5ff, 0x18180000, 0x0061c5ff,
1778 0x20180000, 0x0081c5ff, 0x29180000, 0x00a1c5ff,
1779 0x31180000, 0x00c2c5ff, 0x39180000, 0x00e2c5ff,
1780 0x41180000, 0x0000cdff, 0x4a180000, 0x0020cdff,
1781 0x52180000, 0x0040cdff, 0x5a180000, 0x0061cdff,
1782 0x62180000, 0x0081cdff, 0x6a180000, 0x00a1cdff,
1783 0x73180000, 0x00c2cdff, 0x7b180000, 0x00e2cdff,
1784 0x83180000, 0x0000d5ff, 0x8b180000, 0x0020d5ff,
1785 0x94180000, 0x0040d5ff, 0x9c180000, 0x0061d5ff,
1786 0xa4180000, 0x0081d5ff, 0xac180000, 0x00a1d5ff,
1787 0xb4180000, 0x00c2d5ff, 0xbd180000, 0x00e2d5ff,
1788 0xc5180000, 0x0000deff, 0xcd180000, 0x0020deff,
1789 0xd5180000, 0x0040deff, 0xde180000, 0x0061deff,
1790 0xe6180000, 0x0081deff, 0xee180000, 0x00a1deff,
1791 0xf6180000, 0x00c2deff, 0xff180000, 0x00e2deff,
1792 0x001c0000, 0x0000e6ff, 0x081c0000, 0x0020e6ff,
1793 0x101c0000, 0x0040e6ff, 0x181c0000, 0x0061e6ff,
1794 0x201c0000, 0x0081e6ff, 0x291c0000, 0x00a1e6ff,
1795 0x311c0000, 0x00c2e6ff, 0x391c0000, 0x00e2e6ff,
1796 0x411c0000, 0x0000eeff, 0x4a1c0000, 0x0020eeff,
1797 0x521c0000, 0x0040eeff, 0x5a1c0000, 0x0061eeff,
1798 0x621c0000, 0x0081eeff, 0x6a1c0000, 0x00a1eeff,
1799 0x731c0000, 0x00c2eeff, 0x7b1c0000, 0x00e2eeff,
1800 0x831c0000, 0x0000f6ff, 0x8b1c0000, 0x0020f6ff,
1801 0x941c0000, 0x0040f6ff, 0x9c1c0000, 0x0061f6ff,
1802 0xa41c0000, 0x0081f6ff, 0xac1c0000, 0x00a1f6ff,
1803 0xb41c0000, 0x00c2f6ff, 0xbd1c0000, 0x00e2f6ff,
1804 0xc51c0000, 0x0000ffff, 0xcd1c0000, 0x0020ffff,
1805 0xd51c0000, 0x0040ffff, 0xde1c0000, 0x0061ffff,
1806 0xe61c0000, 0x0081ffff, 0xee1c0000, 0x00a1ffff,
1807 0xf61c0000, 0x00c2ffff, 0xff1c0000, 0x00e2ffff
1809 static void Blit_RGB565_BGRA8888(SDL_BlitInfo *info)
1811 Blit_RGB565_32(info, RGB565_BGRA8888_LUT);
1814 /* Special optimized blit for RGB 8-8-8 --> RGB 3-3-2 */
1815 #ifndef RGB888_RGB332
1816 #define RGB888_RGB332(dst, src) { \
1817 dst = (((src)&0x00E00000)>>16)| \
1818 (((src)&0x0000E000)>>11)| \
1819 (((src)&0x000000C0)>>6); \
1822 static void Blit_RGB888_index8_map(SDL_BlitInfo *info)
1824 #ifndef USE_DUFFS_LOOP
1832 int srcskip, dstskip;
1834 /* Set up some basic variables */
1835 width = info->d_width;
1836 height = info->d_height;
1837 src = (Uint32 *)info->s_pixels;
1838 srcskip = info->s_skip/4;
1839 dst = info->d_pixels;
1840 dstskip = info->d_skip;
1843 #ifdef USE_DUFFS_LOOP
1844 while ( height-- ) {
1846 RGB888_RGB332(Pixel, *src);
1847 *dst++ = map[Pixel];
1854 while ( height-- ) {
1855 for ( c=width/4; c; --c ) {
1856 /* Pack RGB into 8bit pixel */
1857 RGB888_RGB332(Pixel, *src);
1858 *dst++ = map[Pixel];
1860 RGB888_RGB332(Pixel, *src);
1861 *dst++ = map[Pixel];
1863 RGB888_RGB332(Pixel, *src);
1864 *dst++ = map[Pixel];
1866 RGB888_RGB332(Pixel, *src);
1867 *dst++ = map[Pixel];
1870 switch ( width & 3 ) {
1872 RGB888_RGB332(Pixel, *src);
1873 *dst++ = map[Pixel];
1876 RGB888_RGB332(Pixel, *src);
1877 *dst++ = map[Pixel];
1880 RGB888_RGB332(Pixel, *src);
1881 *dst++ = map[Pixel];
1887 #endif /* USE_DUFFS_LOOP */
1889 static void BlitNto1(SDL_BlitInfo *info)
1891 #ifndef USE_DUFFS_LOOP
1898 int srcskip, dstskip;
1902 SDL_PixelFormat *srcfmt;
1904 /* Set up some basic variables */
1905 width = info->d_width;
1906 height = info->d_height;
1907 src = info->s_pixels;
1908 srcskip = info->s_skip;
1909 dst = info->d_pixels;
1910 dstskip = info->d_skip;
1913 srcbpp = srcfmt->BytesPerPixel;
1915 if ( map == NULL ) {
1916 while ( height-- ) {
1917 #ifdef USE_DUFFS_LOOP
1919 DISEMBLE_RGB(src, srcbpp, srcfmt, Pixel,
1922 /* Pack RGB into 8bit pixel */
1923 *dst = ((sR>>5)<<(3+2))|
1931 for ( c=width; c; --c ) {
1932 DISEMBLE_RGB(src, srcbpp, srcfmt, Pixel,
1935 /* Pack RGB into 8bit pixel */
1936 *dst = ((sR>>5)<<(3+2))|
1948 while ( height-- ) {
1949 #ifdef USE_DUFFS_LOOP
1951 DISEMBLE_RGB(src, srcbpp, srcfmt, Pixel,
1954 /* Pack RGB into 8bit pixel */
1955 *dst = map[((sR>>5)<<(3+2))|
1963 for ( c=width; c; --c ) {
1964 DISEMBLE_RGB(src, srcbpp, srcfmt, Pixel,
1967 /* Pack RGB into 8bit pixel */
1968 *dst = map[((sR>>5)<<(3+2))|
1975 #endif /* USE_DUFFS_LOOP */
1982 /* blits 32 bit RGB<->RGBA with both surfaces having the same R,G,B fields */
1983 static void Blit4to4MaskAlpha(SDL_BlitInfo *info)
1985 int width = info->d_width;
1986 int height = info->d_height;
1987 Uint32 *src = (Uint32 *)info->s_pixels;
1988 int srcskip = info->s_skip;
1989 Uint32 *dst = (Uint32 *)info->d_pixels;
1990 int dstskip = info->d_skip;
1991 SDL_PixelFormat *srcfmt = info->src;
1992 SDL_PixelFormat *dstfmt = info->dst;
1994 if (dstfmt->Amask) {
1995 /* RGB->RGBA, SET_ALPHA */
1996 Uint32 mask = (srcfmt->alpha >> dstfmt->Aloss) << dstfmt->Ashift;
1998 while ( height-- ) {
2006 src = (Uint32*)((Uint8*)src + srcskip);
2007 dst = (Uint32*)((Uint8*)dst + dstskip);
2010 /* RGBA->RGB, NO_ALPHA */
2011 Uint32 mask = srcfmt->Rmask | srcfmt->Gmask | srcfmt->Bmask;
2013 while ( height-- ) {
2021 src = (Uint32*)((Uint8*)src + srcskip);
2022 dst = (Uint32*)((Uint8*)dst + dstskip);
2027 static void BlitNtoN(SDL_BlitInfo *info)
2029 int width = info->d_width;
2030 int height = info->d_height;
2031 Uint8 *src = info->s_pixels;
2032 int srcskip = info->s_skip;
2033 Uint8 *dst = info->d_pixels;
2034 int dstskip = info->d_skip;
2035 SDL_PixelFormat *srcfmt = info->src;
2036 int srcbpp = srcfmt->BytesPerPixel;
2037 SDL_PixelFormat *dstfmt = info->dst;
2038 int dstbpp = dstfmt->BytesPerPixel;
2039 unsigned alpha = dstfmt->Amask ? srcfmt->alpha : 0;
2041 while ( height-- ) {
2048 DISEMBLE_RGB(src, srcbpp, srcfmt, Pixel, sR, sG, sB);
2049 ASSEMBLE_RGBA(dst, dstbpp, dstfmt, sR, sG, sB, alpha);
2059 static void BlitNtoNCopyAlpha(SDL_BlitInfo *info)
2061 int width = info->d_width;
2062 int height = info->d_height;
2063 Uint8 *src = info->s_pixels;
2064 int srcskip = info->s_skip;
2065 Uint8 *dst = info->d_pixels;
2066 int dstskip = info->d_skip;
2067 SDL_PixelFormat *srcfmt = info->src;
2068 int srcbpp = srcfmt->BytesPerPixel;
2069 SDL_PixelFormat *dstfmt = info->dst;
2070 int dstbpp = dstfmt->BytesPerPixel;
2073 /* FIXME: should map alpha to [0..255] correctly! */
2074 while ( height-- ) {
2075 for ( c=width; c; --c ) {
2077 unsigned sR, sG, sB, sA;
2078 DISEMBLE_RGBA(src, srcbpp, srcfmt, Pixel,
2080 ASSEMBLE_RGBA(dst, dstbpp, dstfmt,
2090 static void BlitNto1Key(SDL_BlitInfo *info)
2092 int width = info->d_width;
2093 int height = info->d_height;
2094 Uint8 *src = info->s_pixels;
2095 int srcskip = info->s_skip;
2096 Uint8 *dst = info->d_pixels;
2097 int dstskip = info->d_skip;
2098 SDL_PixelFormat *srcfmt = info->src;
2099 const Uint8 *palmap = info->table;
2100 Uint32 ckey = srcfmt->colorkey;
2101 Uint32 rgbmask = ~srcfmt->Amask;
2104 unsigned sR, sG, sB;
2106 /* Set up some basic variables */
2107 srcbpp = srcfmt->BytesPerPixel;
2110 if ( palmap == NULL ) {
2111 while ( height-- ) {
2114 DISEMBLE_RGB(src, srcbpp, srcfmt, Pixel,
2116 if ( (Pixel & rgbmask) != ckey ) {
2117 /* Pack RGB into 8bit pixel */
2118 *dst = (Uint8)(((sR>>5)<<(3+2))|
2130 while ( height-- ) {
2133 DISEMBLE_RGB(src, srcbpp, srcfmt, Pixel,
2135 if ( (Pixel & rgbmask) != ckey ) {
2136 /* Pack RGB into 8bit pixel */
2137 *dst = (Uint8)palmap[((sR>>5)<<(3+2))|
2151 static void Blit2to2Key(SDL_BlitInfo *info)
2153 int width = info->d_width;
2154 int height = info->d_height;
2155 Uint16 *srcp = (Uint16 *)info->s_pixels;
2156 int srcskip = info->s_skip;
2157 Uint16 *dstp = (Uint16 *)info->d_pixels;
2158 int dstskip = info->d_skip;
2159 Uint32 ckey = info->src->colorkey;
2160 Uint32 rgbmask = ~info->src->Amask;
2162 /* Set up some basic variables */
2167 while ( height-- ) {
2170 if ( (*srcp & rgbmask) != ckey ) {
2182 static void BlitNtoNKey(SDL_BlitInfo *info)
2184 int width = info->d_width;
2185 int height = info->d_height;
2186 Uint8 *src = info->s_pixels;
2187 int srcskip = info->s_skip;
2188 Uint8 *dst = info->d_pixels;
2189 int dstskip = info->d_skip;
2190 Uint32 ckey = info->src->colorkey;
2191 SDL_PixelFormat *srcfmt = info->src;
2192 SDL_PixelFormat *dstfmt = info->dst;
2193 int srcbpp = srcfmt->BytesPerPixel;
2194 int dstbpp = dstfmt->BytesPerPixel;
2195 unsigned alpha = dstfmt->Amask ? srcfmt->alpha : 0;
2197 while ( height-- ) {
2204 RETRIEVE_RGB_PIXEL(src, srcbpp, Pixel);
2205 if ( Pixel != ckey ) {
2206 RGB_FROM_PIXEL(Pixel, srcfmt, sR, sG, sB);
2207 ASSEMBLE_RGBA(dst, dstbpp, dstfmt,
2219 static void BlitNtoNKeyCopyAlpha(SDL_BlitInfo *info)
2221 int width = info->d_width;
2222 int height = info->d_height;
2223 Uint8 *src = info->s_pixels;
2224 int srcskip = info->s_skip;
2225 Uint8 *dst = info->d_pixels;
2226 int dstskip = info->d_skip;
2227 Uint32 ckey = info->src->colorkey;
2228 SDL_PixelFormat *srcfmt = info->src;
2229 SDL_PixelFormat *dstfmt = info->dst;
2230 Uint32 rgbmask = ~srcfmt->Amask;
2235 unsigned sR, sG, sB, sA;
2237 /* Set up some basic variables */
2238 srcbpp = srcfmt->BytesPerPixel;
2239 dstbpp = dstfmt->BytesPerPixel;
2242 /* FIXME: should map alpha to [0..255] correctly! */
2243 while ( height-- ) {
2246 DISEMBLE_RGBA(src, srcbpp, srcfmt, Pixel,
2248 if ( (Pixel & rgbmask) != ckey ) {
2249 ASSEMBLE_RGBA(dst, dstbpp, dstfmt,
2261 /* Normal N to N optimized blitters */
2263 Uint32 srcR, srcG, srcB;
2265 Uint32 dstR, dstG, dstB;
2266 Uint32 blit_features;
2268 SDL_loblit blitfunc;
2269 enum { NO_ALPHA=1, SET_ALPHA=2, COPY_ALPHA=4 } alpha;
2271 static const struct blit_table normal_blit_1[] = {
2272 /* Default for 8-bit RGB source, an invalid combination */
2273 { 0,0,0, 0, 0,0,0, 0, NULL, NULL },
2275 static const struct blit_table normal_blit_2[] = {
2276 #if SDL_HERMES_BLITTERS
2277 { 0x0000F800,0x000007E0,0x0000001F, 2, 0x0000001F,0x000007E0,0x0000F800,
2278 0, ConvertX86p16_16BGR565, ConvertX86, NO_ALPHA },
2279 { 0x0000F800,0x000007E0,0x0000001F, 2, 0x00007C00,0x000003E0,0x0000001F,
2280 0, ConvertX86p16_16RGB555, ConvertX86, NO_ALPHA },
2281 { 0x0000F800,0x000007E0,0x0000001F, 2, 0x0000001F,0x000003E0,0x00007C00,
2282 0, ConvertX86p16_16BGR555, ConvertX86, NO_ALPHA },
2283 #elif SDL_ALTIVEC_BLITTERS
2285 { 0x0000F800,0x000007E0,0x0000001F, 4, 0x00000000,0x00000000,0x00000000,
2286 2, NULL, Blit_RGB565_32Altivec, NO_ALPHA | COPY_ALPHA | SET_ALPHA },
2287 { 0x00007C00,0x000003E0,0x0000001F, 4, 0x00000000,0x00000000,0x00000000,
2288 2, NULL, Blit_RGB555_32Altivec, NO_ALPHA | COPY_ALPHA | SET_ALPHA },
2290 { 0x0000F800,0x000007E0,0x0000001F, 4, 0x00FF0000,0x0000FF00,0x000000FF,
2291 0, NULL, Blit_RGB565_ARGB8888, SET_ALPHA },
2292 { 0x0000F800,0x000007E0,0x0000001F, 4, 0x000000FF,0x0000FF00,0x00FF0000,
2293 0, NULL, Blit_RGB565_ABGR8888, SET_ALPHA },
2294 { 0x0000F800,0x000007E0,0x0000001F, 4, 0xFF000000,0x00FF0000,0x0000FF00,
2295 0, NULL, Blit_RGB565_RGBA8888, SET_ALPHA },
2296 { 0x0000F800,0x000007E0,0x0000001F, 4, 0x0000FF00,0x00FF0000,0xFF000000,
2297 0, NULL, Blit_RGB565_BGRA8888, SET_ALPHA },
2299 /* Default for 16-bit RGB source, used if no other blitter matches */
2300 { 0,0,0, 0, 0,0,0, 0, NULL, BlitNtoN, 0 }
2302 static const struct blit_table normal_blit_3[] = {
2303 /* Default for 24-bit RGB source, never optimized */
2304 { 0,0,0, 0, 0,0,0, 0, NULL, BlitNtoN, 0 }
2306 static const struct blit_table normal_blit_4[] = {
2307 #if SDL_HERMES_BLITTERS
2308 { 0x00FF0000,0x0000FF00,0x000000FF, 2, 0x0000F800,0x000007E0,0x0000001F,
2309 1, ConvertMMXpII32_16RGB565, ConvertMMX, NO_ALPHA },
2310 { 0x00FF0000,0x0000FF00,0x000000FF, 2, 0x0000F800,0x000007E0,0x0000001F,
2311 0, ConvertX86p32_16RGB565, ConvertX86, NO_ALPHA },
2312 { 0x00FF0000,0x0000FF00,0x000000FF, 2, 0x0000001F,0x000007E0,0x0000F800,
2313 1, ConvertMMXpII32_16BGR565, ConvertMMX, NO_ALPHA },
2314 { 0x00FF0000,0x0000FF00,0x000000FF, 2, 0x0000001F,0x000007E0,0x0000F800,
2315 0, ConvertX86p32_16BGR565, ConvertX86, NO_ALPHA },
2316 { 0x00FF0000,0x0000FF00,0x000000FF, 2, 0x00007C00,0x000003E0,0x0000001F,
2317 1, ConvertMMXpII32_16RGB555, ConvertMMX, NO_ALPHA },
2318 { 0x00FF0000,0x0000FF00,0x000000FF, 2, 0x00007C00,0x000003E0,0x0000001F,
2319 0, ConvertX86p32_16RGB555, ConvertX86, NO_ALPHA },
2320 { 0x00FF0000,0x0000FF00,0x000000FF, 2, 0x0000001F,0x000003E0,0x00007C00,
2321 1, ConvertMMXpII32_16BGR555, ConvertMMX, NO_ALPHA },
2322 { 0x00FF0000,0x0000FF00,0x000000FF, 2, 0x0000001F,0x000003E0,0x00007C00,
2323 0, ConvertX86p32_16BGR555, ConvertX86, NO_ALPHA },
2324 { 0x00FF0000,0x0000FF00,0x000000FF, 3, 0x00FF0000,0x0000FF00,0x000000FF,
2325 0, ConvertX86p32_24RGB888, ConvertX86, NO_ALPHA },
2326 { 0x00FF0000,0x0000FF00,0x000000FF, 3, 0x000000FF,0x0000FF00,0x00FF0000,
2327 0, ConvertX86p32_24BGR888, ConvertX86, NO_ALPHA },
2328 { 0x00FF0000,0x0000FF00,0x000000FF, 4, 0x000000FF,0x0000FF00,0x00FF0000,
2329 0, ConvertX86p32_32BGR888, ConvertX86, NO_ALPHA },
2330 { 0x00FF0000,0x0000FF00,0x000000FF, 4, 0xFF000000,0x00FF0000,0x0000FF00,
2331 0, ConvertX86p32_32RGBA888, ConvertX86, NO_ALPHA },
2332 { 0x00FF0000,0x0000FF00,0x000000FF, 4, 0x0000FF00,0x00FF0000,0xFF000000,
2333 0, ConvertX86p32_32BGRA888, ConvertX86, NO_ALPHA },
2335 #if SDL_ALTIVEC_BLITTERS
2336 /* has-altivec | dont-use-prefetch */
2337 { 0x00000000,0x00000000,0x00000000, 4, 0x00000000,0x00000000,0x00000000,
2338 6, NULL, ConvertAltivec32to32_noprefetch, NO_ALPHA | COPY_ALPHA | SET_ALPHA },
2340 { 0x00000000,0x00000000,0x00000000, 4, 0x00000000,0x00000000,0x00000000,
2341 2, NULL, ConvertAltivec32to32_prefetch, NO_ALPHA | COPY_ALPHA | SET_ALPHA },
2343 { 0x00000000,0x00000000,0x00000000, 2, 0x0000F800,0x000007E0,0x0000001F,
2344 2, NULL, Blit_RGB888_RGB565Altivec, NO_ALPHA },
2346 { 0x00FF0000,0x0000FF00,0x000000FF, 2, 0x0000F800,0x000007E0,0x0000001F,
2347 0, NULL, Blit_RGB888_RGB565, NO_ALPHA },
2348 { 0x00FF0000,0x0000FF00,0x000000FF, 2, 0x00007C00,0x000003E0,0x0000001F,
2349 0, NULL, Blit_RGB888_RGB555, NO_ALPHA },
2351 /* Default for 32-bit RGB source, used if no other blitter matches */
2352 { 0,0,0, 0, 0,0,0, 0, NULL, BlitNtoN, 0 }
2354 static const struct blit_table *normal_blit[] = {
2355 normal_blit_1, normal_blit_2, normal_blit_3, normal_blit_4
2358 /* Mask matches table, or table entry is zero */
2359 #define MASKOK(x, y) (((x) == (y)) || ((y) == 0x00000000))
2361 SDL_loblit SDL_CalculateBlitN(SDL_Surface *surface, int blit_index)
2363 struct private_swaccel *sdata;
2364 SDL_PixelFormat *srcfmt;
2365 SDL_PixelFormat *dstfmt;
2366 const struct blit_table *table;
2370 /* Set up data for choosing the blit */
2371 sdata = surface->map->sw_data;
2372 srcfmt = surface->format;
2373 dstfmt = surface->map->dst->format;
2375 if ( blit_index & 2 ) {
2376 /* alpha or alpha+colorkey */
2377 return SDL_CalculateAlphaBlit(surface, blit_index);
2380 /* We don't support destinations less than 8-bits */
2381 if ( dstfmt->BitsPerPixel < 8 ) {
2385 if(blit_index == 1) {
2386 /* colorkey blit: Here we don't have too many options, mostly
2387 because RLE is the preferred fast way to deal with this.
2388 If a particular case turns out to be useful we'll add it. */
2390 if(srcfmt->BytesPerPixel == 2
2391 && surface->map->identity)
2393 else if(dstfmt->BytesPerPixel == 1)
2396 #if SDL_ALTIVEC_BLITTERS
2397 if((srcfmt->BytesPerPixel == 4) && (dstfmt->BytesPerPixel == 4) && SDL_HasAltiVec()) {
2398 return Blit32to32KeyAltivec;
2402 if(srcfmt->Amask && dstfmt->Amask)
2403 return BlitNtoNKeyCopyAlpha;
2410 if ( dstfmt->BitsPerPixel == 8 ) {
2411 /* We assume 8-bit destinations are palettized */
2412 if ( (srcfmt->BytesPerPixel == 4) &&
2413 (srcfmt->Rmask == 0x00FF0000) &&
2414 (srcfmt->Gmask == 0x0000FF00) &&
2415 (srcfmt->Bmask == 0x000000FF) ) {
2416 if ( surface->map->table ) {
2417 blitfun = Blit_RGB888_index8_map;
2419 #if SDL_HERMES_BLITTERS
2420 sdata->aux_data = ConvertX86p32_8RGB332;
2421 blitfun = ConvertX86;
2423 blitfun = Blit_RGB888_index8;
2430 /* Now the meat, choose the blitter we want */
2433 a_need = srcfmt->Amask ? COPY_ALPHA : SET_ALPHA;
2434 table = normal_blit[srcfmt->BytesPerPixel-1];
2435 for ( which=0; table[which].dstbpp; ++which ) {
2436 if ( MASKOK(srcfmt->Rmask, table[which].srcR) &&
2437 MASKOK(srcfmt->Gmask, table[which].srcG) &&
2438 MASKOK(srcfmt->Bmask, table[which].srcB) &&
2439 MASKOK(dstfmt->Rmask, table[which].dstR) &&
2440 MASKOK(dstfmt->Gmask, table[which].dstG) &&
2441 MASKOK(dstfmt->Bmask, table[which].dstB) &&
2442 dstfmt->BytesPerPixel == table[which].dstbpp &&
2443 (a_need & table[which].alpha) == a_need &&
2444 ((table[which].blit_features & GetBlitFeatures()) == table[which].blit_features) )
2447 sdata->aux_data = table[which].aux_data;
2448 blitfun = table[which].blitfunc;
2450 if(blitfun == BlitNtoN) { /* default C fallback catch-all. Slow! */
2451 /* Fastpath C fallback: 32bit RGB<->RGBA blit with matching RGB */
2452 if ( srcfmt->BytesPerPixel == 4 && dstfmt->BytesPerPixel == 4 &&
2453 srcfmt->Rmask == dstfmt->Rmask &&
2454 srcfmt->Gmask == dstfmt->Gmask &&
2455 srcfmt->Bmask == dstfmt->Bmask ) {
2456 blitfun = Blit4to4MaskAlpha;
2457 } else if ( a_need == COPY_ALPHA ) {
2458 blitfun = BlitNtoNCopyAlpha;
2464 #if SDL_HERMES_BLITTERS
2465 if ( blitfun == ConvertMMX )
2466 fprintf(stderr, "Using mmx blit\n");
2468 if ( blitfun == ConvertX86 )
2469 fprintf(stderr, "Using asm blit\n");
2472 if ( (blitfun == BlitNtoN) || (blitfun == BlitNto1) )
2473 fprintf(stderr, "Using C blit\n");
2475 fprintf(stderr, "Using optimized C blit\n");
2476 #endif /* DEBUG_ASM */