2 Simple DirectMedia Layer
3 Copyright (C) 1997-2018 Sam Lantinga <slouken@libsdl.org>
5 This software is provided 'as-is', without any express or implied
6 warranty. In no event will the authors be held liable for any damages
7 arising from the use of this software.
9 Permission is granted to anyone to use this software for any purpose,
10 including commercial applications, and to alter it and redistribute it
11 freely, subject to the following restrictions:
13 1. The origin of this software must not be misrepresented; you must not
14 claim that you wrote the original software. If you use this software
15 in a product, an acknowledgment in the product documentation would be
16 appreciated but is not required.
17 2. Altered source versions must be plainly marked as such, and must not be
18 misrepresented as being the original software.
19 3. This notice may not be removed or altered from any source distribution.
21 #include "../SDL_internal.h"
23 #include "SDL_video.h"
24 #include "SDL_endian.h"
25 #include "SDL_cpuinfo.h"
28 #include "SDL_assert.h"
30 /* Functions to blit from N-bit surfaces to other surfaces */
32 #if SDL_ALTIVEC_BLITTERS
37 #include <sys/sysctl.h>
41 const char key[] = "hw.l3cachesize";
43 size_t typeSize = sizeof(result);
46 int err = sysctlbyname(key, &result, &typeSize, NULL, 0);
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
105 calc_swizzle32(const SDL_PixelFormat * srcfmt, 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 const struct SDL_PixelFormat default_pixel_format = {
116 0x00FF0000, 0x0000FF00, 0x000000FF, 0xFF000000,
121 const vector unsigned char plus = VECUINT8_LITERAL(0x00, 0x00, 0x00, 0x00,
122 0x04, 0x04, 0x04, 0x04,
123 0x08, 0x08, 0x08, 0x08,
126 vector unsigned char vswiz;
127 vector unsigned int srcvec;
128 Uint32 rmask, gmask, bmask, amask;
131 srcfmt = &default_pixel_format;
134 dstfmt = &default_pixel_format;
137 #define RESHIFT(X) (3 - ((X) >> 3))
138 rmask = RESHIFT(srcfmt->Rshift) << (dstfmt->Rshift);
139 gmask = RESHIFT(srcfmt->Gshift) << (dstfmt->Gshift);
140 bmask = RESHIFT(srcfmt->Bshift) << (dstfmt->Bshift);
142 /* Use zero for alpha if either surface doesn't have alpha */
145 ((srcfmt->Amask) ? RESHIFT(srcfmt->
146 Ashift) : 0x10) << (dstfmt->Ashift);
149 0x10101010 & ((dstfmt->Rmask | dstfmt->Gmask | dstfmt->Bmask) ^
154 ((unsigned int *) (char *) &srcvec)[0] = (rmask | gmask | bmask | amask);
155 vswiz = vec_add(plus, (vector unsigned char) vec_splat(srcvec, 0));
159 static void Blit_RGB888_RGB565(SDL_BlitInfo * info);
161 Blit_RGB888_RGB565Altivec(SDL_BlitInfo * info)
163 int height = info->dst_h;
164 Uint8 *src = (Uint8 *) info->src;
165 int srcskip = info->src_skip;
166 Uint8 *dst = (Uint8 *) info->dst;
167 int dstskip = info->dst_skip;
168 SDL_PixelFormat *srcfmt = info->src_fmt;
169 vector unsigned char valpha = vec_splat_u8(0);
170 vector unsigned char vpermute = calc_swizzle32(srcfmt, NULL);
171 vector unsigned char vgmerge = VECUINT8_LITERAL(0x00, 0x02, 0x00, 0x06,
172 0x00, 0x0a, 0x00, 0x0e,
173 0x00, 0x12, 0x00, 0x16,
174 0x00, 0x1a, 0x00, 0x1e);
175 vector unsigned short v1 = vec_splat_u16(1);
176 vector unsigned short v3 = vec_splat_u16(3);
177 vector unsigned short v3f =
178 VECUINT16_LITERAL(0x003f, 0x003f, 0x003f, 0x003f,
179 0x003f, 0x003f, 0x003f, 0x003f);
180 vector unsigned short vfc =
181 VECUINT16_LITERAL(0x00fc, 0x00fc, 0x00fc, 0x00fc,
182 0x00fc, 0x00fc, 0x00fc, 0x00fc);
183 vector unsigned short vf800 = (vector unsigned short) vec_splat_u8(-7);
184 vf800 = vec_sl(vf800, vec_splat_u16(8));
187 vector unsigned char valigner;
188 vector unsigned char voverflow;
189 vector unsigned char vsrc;
191 int width = info->dst_w;
194 /* do scalar until we can align... */
195 #define ONE_PIXEL_BLEND(condition, widthvar) \
196 while (condition) { \
198 unsigned sR, sG, sB, sA; \
199 DISEMBLE_RGBA((Uint8 *)src, 4, srcfmt, Pixel, \
201 *(Uint16 *)(dst) = (((sR << 8) & 0x0000F800) | \
202 ((sG << 3) & 0x000007E0) | \
203 ((sB >> 3) & 0x0000001F)); \
209 ONE_PIXEL_BLEND(((UNALIGNED_PTR(dst)) && (width)), width);
211 /* After all that work, here's the vector part! */
212 extrawidth = (width % 8); /* trailing unaligned stores */
214 vsrc = vec_ld(0, src);
215 valigner = VEC_ALIGNER(src);
218 vector unsigned short vpixel, vrpixel, vgpixel, vbpixel;
219 vector unsigned int vsrc1, vsrc2;
220 vector unsigned char vdst;
222 voverflow = vec_ld(15, src);
223 vsrc = vec_perm(vsrc, voverflow, valigner);
224 vsrc1 = (vector unsigned int) vec_perm(vsrc, valpha, vpermute);
227 voverflow = vec_ld(15, src);
228 vsrc = vec_perm(vsrc, voverflow, valigner);
229 vsrc2 = (vector unsigned int) vec_perm(vsrc, valpha, vpermute);
231 vpixel = (vector unsigned short) vec_packpx(vsrc1, vsrc2);
232 vgpixel = (vector unsigned short) vec_perm(vsrc1, vsrc2, vgmerge);
233 vgpixel = vec_and(vgpixel, vfc);
234 vgpixel = vec_sl(vgpixel, v3);
235 vrpixel = vec_sl(vpixel, v1);
236 vrpixel = vec_and(vrpixel, vf800);
237 vbpixel = vec_and(vpixel, v3f);
239 vec_or((vector unsigned char) vrpixel,
240 (vector unsigned char) vgpixel);
242 vdst = vec_or(vdst, (vector unsigned char) vbpixel);
243 vec_st(vdst, 0, dst);
251 SDL_assert(width == 0);
253 /* do scalar until we can align... */
254 ONE_PIXEL_BLEND((extrawidth), extrawidth);
255 #undef ONE_PIXEL_BLEND
257 src += srcskip; /* move to next row, accounting for pitch. */
265 Blit_RGB565_32Altivec(SDL_BlitInfo * info)
267 int height = info->dst_h;
268 Uint8 *src = (Uint8 *) info->src;
269 int srcskip = info->src_skip;
270 Uint8 *dst = (Uint8 *) info->dst;
271 int dstskip = info->dst_skip;
272 SDL_PixelFormat *srcfmt = info->src_fmt;
273 SDL_PixelFormat *dstfmt = info->dst_fmt;
275 vector unsigned char valpha;
276 vector unsigned char vpermute;
277 vector unsigned short vf800;
278 vector unsigned int v8 = vec_splat_u32(8);
279 vector unsigned int v16 = vec_add(v8, v8);
280 vector unsigned short v2 = vec_splat_u16(2);
281 vector unsigned short v3 = vec_splat_u16(3);
283 0x10 - 0x1f is the alpha
284 0x00 - 0x0e evens are the red
285 0x01 - 0x0f odds are zero
287 vector unsigned char vredalpha1 = VECUINT8_LITERAL(0x10, 0x00, 0x01, 0x01,
288 0x10, 0x02, 0x01, 0x01,
289 0x10, 0x04, 0x01, 0x01,
292 vector unsigned char vredalpha2 =
294 char) (vec_add((vector unsigned int) vredalpha1, vec_sl(v8, v16))
297 0x00 - 0x0f is ARxx ARxx ARxx ARxx
298 0x11 - 0x0f odds are blue
300 vector unsigned char vblue1 = VECUINT8_LITERAL(0x00, 0x01, 0x02, 0x11,
301 0x04, 0x05, 0x06, 0x13,
302 0x08, 0x09, 0x0a, 0x15,
303 0x0c, 0x0d, 0x0e, 0x17);
304 vector unsigned char vblue2 =
305 (vector unsigned char) (vec_add((vector unsigned int) vblue1, v8)
308 0x00 - 0x0f is ARxB ARxB ARxB ARxB
309 0x10 - 0x0e evens are green
311 vector unsigned char vgreen1 = VECUINT8_LITERAL(0x00, 0x01, 0x10, 0x03,
312 0x04, 0x05, 0x12, 0x07,
313 0x08, 0x09, 0x14, 0x0b,
314 0x0c, 0x0d, 0x16, 0x0f);
315 vector unsigned char vgreen2 =
317 char) (vec_add((vector unsigned int) vgreen1, vec_sl(v8, v8))
320 SDL_assert(srcfmt->BytesPerPixel == 2);
321 SDL_assert(dstfmt->BytesPerPixel == 4);
323 vf800 = (vector unsigned short) vec_splat_u8(-7);
324 vf800 = vec_sl(vf800, vec_splat_u16(8));
326 if (dstfmt->Amask && info->a) {
327 ((unsigned char *) &valpha)[0] = alpha = info->a;
328 valpha = vec_splat(valpha, 0);
331 valpha = vec_splat_u8(0);
334 vpermute = calc_swizzle32(NULL, dstfmt);
336 vector unsigned char valigner;
337 vector unsigned char voverflow;
338 vector unsigned char vsrc;
340 int width = info->dst_w;
343 /* do scalar until we can align... */
344 #define ONE_PIXEL_BLEND(condition, widthvar) \
345 while (condition) { \
346 unsigned sR, sG, sB; \
347 unsigned short Pixel = *((unsigned short *)src); \
348 sR = (Pixel >> 8) & 0xf8; \
349 sG = (Pixel >> 3) & 0xfc; \
350 sB = (Pixel << 3) & 0xf8; \
351 ASSEMBLE_RGBA(dst, 4, dstfmt, sR, sG, sB, alpha); \
356 ONE_PIXEL_BLEND(((UNALIGNED_PTR(dst)) && (width)), width);
358 /* After all that work, here's the vector part! */
359 extrawidth = (width % 8); /* trailing unaligned stores */
361 vsrc = vec_ld(0, src);
362 valigner = VEC_ALIGNER(src);
365 vector unsigned short vR, vG, vB;
366 vector unsigned char vdst1, vdst2;
368 voverflow = vec_ld(15, src);
369 vsrc = vec_perm(vsrc, voverflow, valigner);
371 vR = vec_and((vector unsigned short) vsrc, vf800);
372 vB = vec_sl((vector unsigned short) vsrc, v3);
376 (vector unsigned char) vec_perm((vector unsigned char) vR,
378 vdst1 = vec_perm(vdst1, (vector unsigned char) vB, vblue1);
379 vdst1 = vec_perm(vdst1, (vector unsigned char) vG, vgreen1);
380 vdst1 = vec_perm(vdst1, valpha, vpermute);
381 vec_st(vdst1, 0, dst);
384 (vector unsigned char) vec_perm((vector unsigned char) vR,
386 vdst2 = vec_perm(vdst2, (vector unsigned char) vB, vblue2);
387 vdst2 = vec_perm(vdst2, (vector unsigned char) vG, vgreen2);
388 vdst2 = vec_perm(vdst2, valpha, vpermute);
389 vec_st(vdst2, 16, dst);
397 SDL_assert(width == 0);
400 /* do scalar until we can align... */
401 ONE_PIXEL_BLEND((extrawidth), extrawidth);
402 #undef ONE_PIXEL_BLEND
404 src += srcskip; /* move to next row, accounting for pitch. */
412 Blit_RGB555_32Altivec(SDL_BlitInfo * info)
414 int height = info->dst_h;
415 Uint8 *src = (Uint8 *) info->src;
416 int srcskip = info->src_skip;
417 Uint8 *dst = (Uint8 *) info->dst;
418 int dstskip = info->dst_skip;
419 SDL_PixelFormat *srcfmt = info->src_fmt;
420 SDL_PixelFormat *dstfmt = info->dst_fmt;
422 vector unsigned char valpha;
423 vector unsigned char vpermute;
424 vector unsigned short vf800;
425 vector unsigned int v8 = vec_splat_u32(8);
426 vector unsigned int v16 = vec_add(v8, v8);
427 vector unsigned short v1 = vec_splat_u16(1);
428 vector unsigned short v3 = vec_splat_u16(3);
430 0x10 - 0x1f is the alpha
431 0x00 - 0x0e evens are the red
432 0x01 - 0x0f odds are zero
434 vector unsigned char vredalpha1 = VECUINT8_LITERAL(0x10, 0x00, 0x01, 0x01,
435 0x10, 0x02, 0x01, 0x01,
436 0x10, 0x04, 0x01, 0x01,
439 vector unsigned char vredalpha2 =
441 char) (vec_add((vector unsigned int) vredalpha1, vec_sl(v8, v16))
444 0x00 - 0x0f is ARxx ARxx ARxx ARxx
445 0x11 - 0x0f odds are blue
447 vector unsigned char vblue1 = VECUINT8_LITERAL(0x00, 0x01, 0x02, 0x11,
448 0x04, 0x05, 0x06, 0x13,
449 0x08, 0x09, 0x0a, 0x15,
450 0x0c, 0x0d, 0x0e, 0x17);
451 vector unsigned char vblue2 =
452 (vector unsigned char) (vec_add((vector unsigned int) vblue1, v8)
455 0x00 - 0x0f is ARxB ARxB ARxB ARxB
456 0x10 - 0x0e evens are green
458 vector unsigned char vgreen1 = VECUINT8_LITERAL(0x00, 0x01, 0x10, 0x03,
459 0x04, 0x05, 0x12, 0x07,
460 0x08, 0x09, 0x14, 0x0b,
461 0x0c, 0x0d, 0x16, 0x0f);
462 vector unsigned char vgreen2 =
464 char) (vec_add((vector unsigned int) vgreen1, vec_sl(v8, v8))
467 SDL_assert(srcfmt->BytesPerPixel == 2);
468 SDL_assert(dstfmt->BytesPerPixel == 4);
470 vf800 = (vector unsigned short) vec_splat_u8(-7);
471 vf800 = vec_sl(vf800, vec_splat_u16(8));
473 if (dstfmt->Amask && info->a) {
474 ((unsigned char *) &valpha)[0] = alpha = info->a;
475 valpha = vec_splat(valpha, 0);
478 valpha = vec_splat_u8(0);
481 vpermute = calc_swizzle32(NULL, dstfmt);
483 vector unsigned char valigner;
484 vector unsigned char voverflow;
485 vector unsigned char vsrc;
487 int width = info->dst_w;
490 /* do scalar until we can align... */
491 #define ONE_PIXEL_BLEND(condition, widthvar) \
492 while (condition) { \
493 unsigned sR, sG, sB; \
494 unsigned short Pixel = *((unsigned short *)src); \
495 sR = (Pixel >> 7) & 0xf8; \
496 sG = (Pixel >> 2) & 0xf8; \
497 sB = (Pixel << 3) & 0xf8; \
498 ASSEMBLE_RGBA(dst, 4, dstfmt, sR, sG, sB, alpha); \
503 ONE_PIXEL_BLEND(((UNALIGNED_PTR(dst)) && (width)), width);
505 /* After all that work, here's the vector part! */
506 extrawidth = (width % 8); /* trailing unaligned stores */
508 vsrc = vec_ld(0, src);
509 valigner = VEC_ALIGNER(src);
512 vector unsigned short vR, vG, vB;
513 vector unsigned char vdst1, vdst2;
515 voverflow = vec_ld(15, src);
516 vsrc = vec_perm(vsrc, voverflow, valigner);
518 vR = vec_and(vec_sl((vector unsigned short) vsrc, v1), vf800);
519 vB = vec_sl((vector unsigned short) vsrc, v3);
523 (vector unsigned char) vec_perm((vector unsigned char) vR,
525 vdst1 = vec_perm(vdst1, (vector unsigned char) vB, vblue1);
526 vdst1 = vec_perm(vdst1, (vector unsigned char) vG, vgreen1);
527 vdst1 = vec_perm(vdst1, valpha, vpermute);
528 vec_st(vdst1, 0, dst);
531 (vector unsigned char) vec_perm((vector unsigned char) vR,
533 vdst2 = vec_perm(vdst2, (vector unsigned char) vB, vblue2);
534 vdst2 = vec_perm(vdst2, (vector unsigned char) vG, vgreen2);
535 vdst2 = vec_perm(vdst2, valpha, vpermute);
536 vec_st(vdst2, 16, dst);
544 SDL_assert(width == 0);
547 /* do scalar until we can align... */
548 ONE_PIXEL_BLEND((extrawidth), extrawidth);
549 #undef ONE_PIXEL_BLEND
551 src += srcskip; /* move to next row, accounting for pitch. */
557 static void BlitNtoNKey(SDL_BlitInfo * info);
558 static void BlitNtoNKeyCopyAlpha(SDL_BlitInfo * info);
560 Blit32to32KeyAltivec(SDL_BlitInfo * info)
562 int height = info->dst_h;
563 Uint32 *srcp = (Uint32 *) info->src;
564 int srcskip = info->src_skip / 4;
565 Uint32 *dstp = (Uint32 *) info->dst;
566 int dstskip = info->dst_skip / 4;
567 SDL_PixelFormat *srcfmt = info->src_fmt;
568 int srcbpp = srcfmt->BytesPerPixel;
569 SDL_PixelFormat *dstfmt = info->dst_fmt;
570 int dstbpp = dstfmt->BytesPerPixel;
571 int copy_alpha = (srcfmt->Amask && dstfmt->Amask);
572 unsigned alpha = dstfmt->Amask ? info->a : 0;
573 Uint32 rgbmask = srcfmt->Rmask | srcfmt->Gmask | srcfmt->Bmask;
574 Uint32 ckey = info->colorkey;
575 vector unsigned int valpha;
576 vector unsigned char vpermute;
577 vector unsigned char vzero;
578 vector unsigned int vckey;
579 vector unsigned int vrgbmask;
580 vpermute = calc_swizzle32(srcfmt, dstfmt);
581 if (info->dst_w < 16) {
583 BlitNtoNKeyCopyAlpha(info);
589 vzero = vec_splat_u8(0);
591 ((unsigned char *) &valpha)[0] = (unsigned char) alpha;
593 (vector unsigned int) vec_splat((vector unsigned char) valpha, 0);
595 valpha = (vector unsigned int) vzero;
598 ((unsigned int *) (char *) &vckey)[0] = ckey;
599 vckey = vec_splat(vckey, 0);
600 ((unsigned int *) (char *) &vrgbmask)[0] = rgbmask;
601 vrgbmask = vec_splat(vrgbmask, 0);
604 #define ONE_PIXEL_BLEND(condition, widthvar) \
606 while (condition) { \
608 unsigned sR, sG, sB, sA; \
609 DISEMBLE_RGBA((Uint8 *)srcp, srcbpp, srcfmt, Pixel, \
611 if ( (Pixel & rgbmask) != ckey ) { \
612 ASSEMBLE_RGBA((Uint8 *)dstp, dstbpp, dstfmt, \
615 dstp = (Uint32 *) (((Uint8 *) dstp) + dstbpp); \
616 srcp = (Uint32 *) (((Uint8 *) srcp) + srcbpp); \
620 while (condition) { \
622 unsigned sR, sG, sB; \
623 RETRIEVE_RGB_PIXEL((Uint8 *)srcp, srcbpp, Pixel); \
624 if ( Pixel != ckey ) { \
625 RGB_FROM_PIXEL(Pixel, srcfmt, sR, sG, sB); \
626 ASSEMBLE_RGBA((Uint8 *)dstp, dstbpp, dstfmt, \
627 sR, sG, sB, alpha); \
629 dstp = (Uint32 *) (((Uint8 *)dstp) + dstbpp); \
630 srcp = (Uint32 *) (((Uint8 *)srcp) + srcbpp); \
634 int width = info->dst_w;
635 ONE_PIXEL_BLEND((UNALIGNED_PTR(dstp)) && (width), width);
636 SDL_assert(width > 0);
638 int extrawidth = (width % 4);
639 vector unsigned char valigner = VEC_ALIGNER(srcp);
640 vector unsigned int vs = vec_ld(0, srcp);
642 SDL_assert(width >= 4);
644 vector unsigned char vsel;
645 vector unsigned int vd;
646 vector unsigned int voverflow = vec_ld(15, srcp);
647 /* load the source vec */
648 vs = vec_perm(vs, voverflow, valigner);
649 /* vsel is set for items that match the key */
650 vsel = (vector unsigned char) vec_and(vs, vrgbmask);
651 vsel = (vector unsigned char) vec_cmpeq(vs, vckey);
652 /* permute the src vec to the dest format */
653 vs = vec_perm(vs, valpha, vpermute);
654 /* load the destination vec */
655 vd = vec_ld(0, dstp);
656 /* select the source and dest into vs */
657 vd = (vector unsigned int) vec_sel((vector unsigned char) vs,
658 (vector unsigned char) vd,
667 ONE_PIXEL_BLEND((extrawidth), extrawidth);
668 #undef ONE_PIXEL_BLEND
675 /* Altivec code to swizzle one 32-bit surface to a different 32-bit format. */
676 /* Use this on a G5 */
678 ConvertAltivec32to32_noprefetch(SDL_BlitInfo * info)
680 int height = info->dst_h;
681 Uint32 *src = (Uint32 *) info->src;
682 int srcskip = info->src_skip / 4;
683 Uint32 *dst = (Uint32 *) info->dst;
684 int dstskip = info->dst_skip / 4;
685 SDL_PixelFormat *srcfmt = info->src_fmt;
686 SDL_PixelFormat *dstfmt = info->dst_fmt;
687 vector unsigned int vzero = vec_splat_u32(0);
688 vector unsigned char vpermute = calc_swizzle32(srcfmt, dstfmt);
689 if (dstfmt->Amask && !srcfmt->Amask) {
691 vector unsigned char valpha;
692 ((unsigned char *) &valpha)[0] = info->a;
693 vzero = (vector unsigned int) vec_splat(valpha, 0);
697 SDL_assert(srcfmt->BytesPerPixel == 4);
698 SDL_assert(dstfmt->BytesPerPixel == 4);
701 vector unsigned char valigner;
702 vector unsigned int vbits;
703 vector unsigned int voverflow;
707 int width = info->dst_w;
710 /* do scalar until we can align... */
711 while ((UNALIGNED_PTR(dst)) && (width)) {
713 RGBA_FROM_8888(bits, srcfmt, r, g, b, a);
716 *(dst++) = MAKE8888(dstfmt, r, g, b, a);
720 /* After all that work, here's the vector part! */
721 extrawidth = (width % 4);
723 valigner = VEC_ALIGNER(src);
724 vbits = vec_ld(0, src);
727 voverflow = vec_ld(15, src);
730 vbits = vec_perm(vbits, voverflow, valigner); /* src is ready. */
731 vbits = vec_perm(vbits, vzero, vpermute); /* swizzle it. */
732 vec_st(vbits, 0, dst); /* store it back out. */
737 SDL_assert(width == 0);
739 /* cover pixels at the end of the row that didn't fit in 16 bytes. */
741 bits = *(src++); /* max 7 pixels, don't bother with prefetch. */
742 RGBA_FROM_8888(bits, srcfmt, r, g, b, a);
745 *(dst++) = MAKE8888(dstfmt, r, g, b, a);
755 /* Altivec code to swizzle one 32-bit surface to a different 32-bit format. */
756 /* Use this on a G4 */
758 ConvertAltivec32to32_prefetch(SDL_BlitInfo * info)
760 const int scalar_dst_lead = sizeof(Uint32) * 4;
761 const int vector_dst_lead = sizeof(Uint32) * 16;
763 int height = info->dst_h;
764 Uint32 *src = (Uint32 *) info->src;
765 int srcskip = info->src_skip / 4;
766 Uint32 *dst = (Uint32 *) info->dst;
767 int dstskip = info->dst_skip / 4;
768 SDL_PixelFormat *srcfmt = info->src_fmt;
769 SDL_PixelFormat *dstfmt = info->dst_fmt;
770 vector unsigned int vzero = vec_splat_u32(0);
771 vector unsigned char vpermute = calc_swizzle32(srcfmt, dstfmt);
772 if (dstfmt->Amask && !srcfmt->Amask) {
774 vector unsigned char valpha;
775 ((unsigned char *) &valpha)[0] = info->a;
776 vzero = (vector unsigned int) vec_splat(valpha, 0);
780 SDL_assert(srcfmt->BytesPerPixel == 4);
781 SDL_assert(dstfmt->BytesPerPixel == 4);
784 vector unsigned char valigner;
785 vector unsigned int vbits;
786 vector unsigned int voverflow;
790 int width = info->dst_w;
793 /* do scalar until we can align... */
794 while ((UNALIGNED_PTR(dst)) && (width)) {
795 vec_dstt(src + scalar_dst_lead, DST_CTRL(2, 32, 1024),
797 vec_dstst(dst + scalar_dst_lead, DST_CTRL(2, 32, 1024),
800 RGBA_FROM_8888(bits, srcfmt, r, g, b, a);
803 *(dst++) = MAKE8888(dstfmt, r, g, b, a);
807 /* After all that work, here's the vector part! */
808 extrawidth = (width % 4);
810 valigner = VEC_ALIGNER(src);
811 vbits = vec_ld(0, src);
814 vec_dstt(src + vector_dst_lead, DST_CTRL(2, 32, 1024),
816 vec_dstst(dst + vector_dst_lead, DST_CTRL(2, 32, 1024),
818 voverflow = vec_ld(15, src);
821 vbits = vec_perm(vbits, voverflow, valigner); /* src is ready. */
822 vbits = vec_perm(vbits, vzero, vpermute); /* swizzle it. */
823 vec_st(vbits, 0, dst); /* store it back out. */
828 SDL_assert(width == 0);
830 /* cover pixels at the end of the row that didn't fit in 16 bytes. */
832 bits = *(src++); /* max 7 pixels, don't bother with prefetch. */
833 RGBA_FROM_8888(bits, srcfmt, r, g, b, a);
836 *(dst++) = MAKE8888(dstfmt, r, g, b, a);
844 vec_dss(DST_CHAN_SRC);
845 vec_dss(DST_CHAN_DEST);
849 GetBlitFeatures(void)
851 static Uint32 features = 0xffffffff;
852 if (features == 0xffffffff) {
853 /* Provide an override for testing .. */
854 char *override = SDL_getenv("SDL_ALTIVEC_BLIT_FEATURES");
857 SDL_sscanf(override, "%u", &features);
860 /* Feature 1 is has-MMX */
861 | ((SDL_HasMMX())? 1 : 0)
862 /* Feature 2 is has-AltiVec */
863 | ((SDL_HasAltiVec())? 2 : 0)
864 /* Feature 4 is dont-use-prefetch */
865 /* !!!! FIXME: Check for G5 or later, not the cache size! Always prefetch on a G4. */
866 | ((GetL3CacheSize() == 0) ? 4 : 0)
874 #pragma altivec_model off
877 /* Feature 1 is has-MMX */
878 #define GetBlitFeatures() ((Uint32)(SDL_HasMMX() ? 1 : 0))
881 /* This is now endian dependent */
882 #if SDL_BYTEORDER == SDL_LIL_ENDIAN
885 #else /* SDL_BYTEORDER == SDL_BIG_ENDIAN */
890 /* Special optimized blit for RGB 8-8-8 --> RGB 3-3-2 */
891 #define RGB888_RGB332(dst, src) { \
892 dst = (Uint8)((((src)&0x00E00000)>>16)| \
893 (((src)&0x0000E000)>>11)| \
894 (((src)&0x000000C0)>>6)); \
897 Blit_RGB888_index8(SDL_BlitInfo * info)
899 #ifndef USE_DUFFS_LOOP
906 int srcskip, dstskip;
908 /* Set up some basic variables */
910 height = info->dst_h;
911 src = (Uint32 *) info->src;
912 srcskip = info->src_skip / 4;
914 dstskip = info->dst_skip;
919 #ifdef USE_DUFFS_LOOP
922 RGB888_RGB332(*dst++, *src);
926 for (c = width / 4; c; --c) {
927 /* Pack RGB into 8bit pixel */
929 RGB888_RGB332(*dst++, *src);
931 RGB888_RGB332(*dst++, *src);
933 RGB888_RGB332(*dst++, *src);
938 RGB888_RGB332(*dst++, *src);
941 RGB888_RGB332(*dst++, *src);
944 RGB888_RGB332(*dst++, *src);
947 #endif /* USE_DUFFS_LOOP */
955 #ifdef USE_DUFFS_LOOP
958 RGB888_RGB332(Pixel, *src);
964 for (c = width / 4; c; --c) {
965 /* Pack RGB into 8bit pixel */
966 RGB888_RGB332(Pixel, *src);
969 RGB888_RGB332(Pixel, *src);
972 RGB888_RGB332(Pixel, *src);
975 RGB888_RGB332(Pixel, *src);
981 RGB888_RGB332(Pixel, *src);
985 RGB888_RGB332(Pixel, *src);
989 RGB888_RGB332(Pixel, *src);
993 #endif /* USE_DUFFS_LOOP */
1000 /* Special optimized blit for RGB 10-10-10 --> RGB 3-3-2 */
1001 #define RGB101010_RGB332(dst, src) { \
1002 dst = (Uint8)((((src)&0x38000000)>>22)| \
1003 (((src)&0x000E0000)>>15)| \
1004 (((src)&0x00000300)>>8)); \
1007 Blit_RGB101010_index8(SDL_BlitInfo * info)
1009 #ifndef USE_DUFFS_LOOP
1016 int srcskip, dstskip;
1018 /* Set up some basic variables */
1019 width = info->dst_w;
1020 height = info->dst_h;
1021 src = (Uint32 *) info->src;
1022 srcskip = info->src_skip / 4;
1024 dstskip = info->dst_skip;
1029 #ifdef USE_DUFFS_LOOP
1032 RGB101010_RGB332(*dst++, *src);
1036 for (c = width / 4; c; --c) {
1037 /* Pack RGB into 8bit pixel */
1039 RGB101010_RGB332(*dst++, *src);
1041 RGB101010_RGB332(*dst++, *src);
1043 RGB101010_RGB332(*dst++, *src);
1046 switch (width & 3) {
1048 RGB101010_RGB332(*dst++, *src);
1051 RGB101010_RGB332(*dst++, *src);
1054 RGB101010_RGB332(*dst++, *src);
1057 #endif /* USE_DUFFS_LOOP */
1065 #ifdef USE_DUFFS_LOOP
1068 RGB101010_RGB332(Pixel, *src);
1069 *dst++ = map[Pixel];
1074 for (c = width / 4; c; --c) {
1075 /* Pack RGB into 8bit pixel */
1076 RGB101010_RGB332(Pixel, *src);
1077 *dst++ = map[Pixel];
1079 RGB101010_RGB332(Pixel, *src);
1080 *dst++ = map[Pixel];
1082 RGB101010_RGB332(Pixel, *src);
1083 *dst++ = map[Pixel];
1085 RGB101010_RGB332(Pixel, *src);
1086 *dst++ = map[Pixel];
1089 switch (width & 3) {
1091 RGB101010_RGB332(Pixel, *src);
1092 *dst++ = map[Pixel];
1095 RGB101010_RGB332(Pixel, *src);
1096 *dst++ = map[Pixel];
1099 RGB101010_RGB332(Pixel, *src);
1100 *dst++ = map[Pixel];
1103 #endif /* USE_DUFFS_LOOP */
1110 /* Special optimized blit for RGB 8-8-8 --> RGB 5-5-5 */
1111 #define RGB888_RGB555(dst, src) { \
1112 *(Uint16 *)(dst) = (Uint16)((((*src)&0x00F80000)>>9)| \
1113 (((*src)&0x0000F800)>>6)| \
1114 (((*src)&0x000000F8)>>3)); \
1116 #ifndef USE_DUFFS_LOOP
1117 #define RGB888_RGB555_TWO(dst, src) { \
1118 *(Uint32 *)(dst) = (((((src[HI])&0x00F80000)>>9)| \
1119 (((src[HI])&0x0000F800)>>6)| \
1120 (((src[HI])&0x000000F8)>>3))<<16)| \
1121 (((src[LO])&0x00F80000)>>9)| \
1122 (((src[LO])&0x0000F800)>>6)| \
1123 (((src[LO])&0x000000F8)>>3); \
1127 Blit_RGB888_RGB555(SDL_BlitInfo * info)
1129 #ifndef USE_DUFFS_LOOP
1135 int srcskip, dstskip;
1137 /* Set up some basic variables */
1138 width = info->dst_w;
1139 height = info->dst_h;
1140 src = (Uint32 *) info->src;
1141 srcskip = info->src_skip / 4;
1142 dst = (Uint16 *) info->dst;
1143 dstskip = info->dst_skip / 2;
1145 #ifdef USE_DUFFS_LOOP
1149 RGB888_RGB555(dst, src);
1158 /* Memory align at 4-byte boundary, if necessary */
1159 if ((long) dst & 0x03) {
1160 /* Don't do anything if width is 0 */
1167 /* Perform copy alignment */
1168 RGB888_RGB555(dst, src);
1172 /* Copy in 4 pixel chunks */
1173 for (c = width / 4; c; --c) {
1174 RGB888_RGB555_TWO(dst, src);
1177 RGB888_RGB555_TWO(dst, src);
1181 /* Get any leftovers */
1182 switch (width & 3) {
1184 RGB888_RGB555(dst, src);
1188 RGB888_RGB555_TWO(dst, src);
1193 RGB888_RGB555(dst, src);
1203 /* Copy in 4 pixel chunks */
1204 for (c = width / 4; c; --c) {
1205 RGB888_RGB555_TWO(dst, src);
1208 RGB888_RGB555_TWO(dst, src);
1212 /* Get any leftovers */
1213 switch (width & 3) {
1215 RGB888_RGB555(dst, src);
1219 RGB888_RGB555_TWO(dst, src);
1224 RGB888_RGB555(dst, src);
1233 #endif /* USE_DUFFS_LOOP */
1236 /* Special optimized blit for RGB 8-8-8 --> RGB 5-6-5 */
1237 #define RGB888_RGB565(dst, src) { \
1238 *(Uint16 *)(dst) = (Uint16)((((*src)&0x00F80000)>>8)| \
1239 (((*src)&0x0000FC00)>>5)| \
1240 (((*src)&0x000000F8)>>3)); \
1242 #ifndef USE_DUFFS_LOOP
1243 #define RGB888_RGB565_TWO(dst, src) { \
1244 *(Uint32 *)(dst) = (((((src[HI])&0x00F80000)>>8)| \
1245 (((src[HI])&0x0000FC00)>>5)| \
1246 (((src[HI])&0x000000F8)>>3))<<16)| \
1247 (((src[LO])&0x00F80000)>>8)| \
1248 (((src[LO])&0x0000FC00)>>5)| \
1249 (((src[LO])&0x000000F8)>>3); \
1253 Blit_RGB888_RGB565(SDL_BlitInfo * info)
1255 #ifndef USE_DUFFS_LOOP
1261 int srcskip, dstskip;
1263 /* Set up some basic variables */
1264 width = info->dst_w;
1265 height = info->dst_h;
1266 src = (Uint32 *) info->src;
1267 srcskip = info->src_skip / 4;
1268 dst = (Uint16 *) info->dst;
1269 dstskip = info->dst_skip / 2;
1271 #ifdef USE_DUFFS_LOOP
1275 RGB888_RGB565(dst, src);
1284 /* Memory align at 4-byte boundary, if necessary */
1285 if ((long) dst & 0x03) {
1286 /* Don't do anything if width is 0 */
1293 /* Perform copy alignment */
1294 RGB888_RGB565(dst, src);
1298 /* Copy in 4 pixel chunks */
1299 for (c = width / 4; c; --c) {
1300 RGB888_RGB565_TWO(dst, src);
1303 RGB888_RGB565_TWO(dst, src);
1307 /* Get any leftovers */
1308 switch (width & 3) {
1310 RGB888_RGB565(dst, src);
1314 RGB888_RGB565_TWO(dst, src);
1319 RGB888_RGB565(dst, src);
1329 /* Copy in 4 pixel chunks */
1330 for (c = width / 4; c; --c) {
1331 RGB888_RGB565_TWO(dst, src);
1334 RGB888_RGB565_TWO(dst, src);
1338 /* Get any leftovers */
1339 switch (width & 3) {
1341 RGB888_RGB565(dst, src);
1345 RGB888_RGB565_TWO(dst, src);
1350 RGB888_RGB565(dst, src);
1359 #endif /* USE_DUFFS_LOOP */
1363 /* Special optimized blit for RGB 5-6-5 --> 32-bit RGB surfaces */
1364 #define RGB565_32(dst, src, map) (map[src[LO]*2] + map[src[HI]*2+1])
1366 Blit_RGB565_32(SDL_BlitInfo * info, const Uint32 * map)
1368 #ifndef USE_DUFFS_LOOP
1374 int srcskip, dstskip;
1376 /* Set up some basic variables */
1377 width = info->dst_w;
1378 height = info->dst_h;
1379 src = (Uint8 *) info->src;
1380 srcskip = info->src_skip;
1381 dst = (Uint32 *) info->dst;
1382 dstskip = info->dst_skip / 4;
1384 #ifdef USE_DUFFS_LOOP
1389 *dst++ = RGB565_32(dst, src, map);
1399 /* Copy in 4 pixel chunks */
1400 for (c = width / 4; c; --c) {
1401 *dst++ = RGB565_32(dst, src, map);
1403 *dst++ = RGB565_32(dst, src, map);
1405 *dst++ = RGB565_32(dst, src, map);
1407 *dst++ = RGB565_32(dst, src, map);
1410 /* Get any leftovers */
1411 switch (width & 3) {
1413 *dst++ = RGB565_32(dst, src, map);
1416 *dst++ = RGB565_32(dst, src, map);
1419 *dst++ = RGB565_32(dst, src, map);
1426 #endif /* USE_DUFFS_LOOP */
1429 /* Special optimized blit for RGB 5-6-5 --> ARGB 8-8-8-8 */
1430 static const Uint32 RGB565_ARGB8888_LUT[512] = {
1431 0x00000000, 0xff000000, 0x00000008, 0xff002000,
1432 0x00000010, 0xff004000, 0x00000018, 0xff006100,
1433 0x00000020, 0xff008100, 0x00000029, 0xff00a100,
1434 0x00000031, 0xff00c200, 0x00000039, 0xff00e200,
1435 0x00000041, 0xff080000, 0x0000004a, 0xff082000,
1436 0x00000052, 0xff084000, 0x0000005a, 0xff086100,
1437 0x00000062, 0xff088100, 0x0000006a, 0xff08a100,
1438 0x00000073, 0xff08c200, 0x0000007b, 0xff08e200,
1439 0x00000083, 0xff100000, 0x0000008b, 0xff102000,
1440 0x00000094, 0xff104000, 0x0000009c, 0xff106100,
1441 0x000000a4, 0xff108100, 0x000000ac, 0xff10a100,
1442 0x000000b4, 0xff10c200, 0x000000bd, 0xff10e200,
1443 0x000000c5, 0xff180000, 0x000000cd, 0xff182000,
1444 0x000000d5, 0xff184000, 0x000000de, 0xff186100,
1445 0x000000e6, 0xff188100, 0x000000ee, 0xff18a100,
1446 0x000000f6, 0xff18c200, 0x000000ff, 0xff18e200,
1447 0x00000400, 0xff200000, 0x00000408, 0xff202000,
1448 0x00000410, 0xff204000, 0x00000418, 0xff206100,
1449 0x00000420, 0xff208100, 0x00000429, 0xff20a100,
1450 0x00000431, 0xff20c200, 0x00000439, 0xff20e200,
1451 0x00000441, 0xff290000, 0x0000044a, 0xff292000,
1452 0x00000452, 0xff294000, 0x0000045a, 0xff296100,
1453 0x00000462, 0xff298100, 0x0000046a, 0xff29a100,
1454 0x00000473, 0xff29c200, 0x0000047b, 0xff29e200,
1455 0x00000483, 0xff310000, 0x0000048b, 0xff312000,
1456 0x00000494, 0xff314000, 0x0000049c, 0xff316100,
1457 0x000004a4, 0xff318100, 0x000004ac, 0xff31a100,
1458 0x000004b4, 0xff31c200, 0x000004bd, 0xff31e200,
1459 0x000004c5, 0xff390000, 0x000004cd, 0xff392000,
1460 0x000004d5, 0xff394000, 0x000004de, 0xff396100,
1461 0x000004e6, 0xff398100, 0x000004ee, 0xff39a100,
1462 0x000004f6, 0xff39c200, 0x000004ff, 0xff39e200,
1463 0x00000800, 0xff410000, 0x00000808, 0xff412000,
1464 0x00000810, 0xff414000, 0x00000818, 0xff416100,
1465 0x00000820, 0xff418100, 0x00000829, 0xff41a100,
1466 0x00000831, 0xff41c200, 0x00000839, 0xff41e200,
1467 0x00000841, 0xff4a0000, 0x0000084a, 0xff4a2000,
1468 0x00000852, 0xff4a4000, 0x0000085a, 0xff4a6100,
1469 0x00000862, 0xff4a8100, 0x0000086a, 0xff4aa100,
1470 0x00000873, 0xff4ac200, 0x0000087b, 0xff4ae200,
1471 0x00000883, 0xff520000, 0x0000088b, 0xff522000,
1472 0x00000894, 0xff524000, 0x0000089c, 0xff526100,
1473 0x000008a4, 0xff528100, 0x000008ac, 0xff52a100,
1474 0x000008b4, 0xff52c200, 0x000008bd, 0xff52e200,
1475 0x000008c5, 0xff5a0000, 0x000008cd, 0xff5a2000,
1476 0x000008d5, 0xff5a4000, 0x000008de, 0xff5a6100,
1477 0x000008e6, 0xff5a8100, 0x000008ee, 0xff5aa100,
1478 0x000008f6, 0xff5ac200, 0x000008ff, 0xff5ae200,
1479 0x00000c00, 0xff620000, 0x00000c08, 0xff622000,
1480 0x00000c10, 0xff624000, 0x00000c18, 0xff626100,
1481 0x00000c20, 0xff628100, 0x00000c29, 0xff62a100,
1482 0x00000c31, 0xff62c200, 0x00000c39, 0xff62e200,
1483 0x00000c41, 0xff6a0000, 0x00000c4a, 0xff6a2000,
1484 0x00000c52, 0xff6a4000, 0x00000c5a, 0xff6a6100,
1485 0x00000c62, 0xff6a8100, 0x00000c6a, 0xff6aa100,
1486 0x00000c73, 0xff6ac200, 0x00000c7b, 0xff6ae200,
1487 0x00000c83, 0xff730000, 0x00000c8b, 0xff732000,
1488 0x00000c94, 0xff734000, 0x00000c9c, 0xff736100,
1489 0x00000ca4, 0xff738100, 0x00000cac, 0xff73a100,
1490 0x00000cb4, 0xff73c200, 0x00000cbd, 0xff73e200,
1491 0x00000cc5, 0xff7b0000, 0x00000ccd, 0xff7b2000,
1492 0x00000cd5, 0xff7b4000, 0x00000cde, 0xff7b6100,
1493 0x00000ce6, 0xff7b8100, 0x00000cee, 0xff7ba100,
1494 0x00000cf6, 0xff7bc200, 0x00000cff, 0xff7be200,
1495 0x00001000, 0xff830000, 0x00001008, 0xff832000,
1496 0x00001010, 0xff834000, 0x00001018, 0xff836100,
1497 0x00001020, 0xff838100, 0x00001029, 0xff83a100,
1498 0x00001031, 0xff83c200, 0x00001039, 0xff83e200,
1499 0x00001041, 0xff8b0000, 0x0000104a, 0xff8b2000,
1500 0x00001052, 0xff8b4000, 0x0000105a, 0xff8b6100,
1501 0x00001062, 0xff8b8100, 0x0000106a, 0xff8ba100,
1502 0x00001073, 0xff8bc200, 0x0000107b, 0xff8be200,
1503 0x00001083, 0xff940000, 0x0000108b, 0xff942000,
1504 0x00001094, 0xff944000, 0x0000109c, 0xff946100,
1505 0x000010a4, 0xff948100, 0x000010ac, 0xff94a100,
1506 0x000010b4, 0xff94c200, 0x000010bd, 0xff94e200,
1507 0x000010c5, 0xff9c0000, 0x000010cd, 0xff9c2000,
1508 0x000010d5, 0xff9c4000, 0x000010de, 0xff9c6100,
1509 0x000010e6, 0xff9c8100, 0x000010ee, 0xff9ca100,
1510 0x000010f6, 0xff9cc200, 0x000010ff, 0xff9ce200,
1511 0x00001400, 0xffa40000, 0x00001408, 0xffa42000,
1512 0x00001410, 0xffa44000, 0x00001418, 0xffa46100,
1513 0x00001420, 0xffa48100, 0x00001429, 0xffa4a100,
1514 0x00001431, 0xffa4c200, 0x00001439, 0xffa4e200,
1515 0x00001441, 0xffac0000, 0x0000144a, 0xffac2000,
1516 0x00001452, 0xffac4000, 0x0000145a, 0xffac6100,
1517 0x00001462, 0xffac8100, 0x0000146a, 0xffaca100,
1518 0x00001473, 0xffacc200, 0x0000147b, 0xfface200,
1519 0x00001483, 0xffb40000, 0x0000148b, 0xffb42000,
1520 0x00001494, 0xffb44000, 0x0000149c, 0xffb46100,
1521 0x000014a4, 0xffb48100, 0x000014ac, 0xffb4a100,
1522 0x000014b4, 0xffb4c200, 0x000014bd, 0xffb4e200,
1523 0x000014c5, 0xffbd0000, 0x000014cd, 0xffbd2000,
1524 0x000014d5, 0xffbd4000, 0x000014de, 0xffbd6100,
1525 0x000014e6, 0xffbd8100, 0x000014ee, 0xffbda100,
1526 0x000014f6, 0xffbdc200, 0x000014ff, 0xffbde200,
1527 0x00001800, 0xffc50000, 0x00001808, 0xffc52000,
1528 0x00001810, 0xffc54000, 0x00001818, 0xffc56100,
1529 0x00001820, 0xffc58100, 0x00001829, 0xffc5a100,
1530 0x00001831, 0xffc5c200, 0x00001839, 0xffc5e200,
1531 0x00001841, 0xffcd0000, 0x0000184a, 0xffcd2000,
1532 0x00001852, 0xffcd4000, 0x0000185a, 0xffcd6100,
1533 0x00001862, 0xffcd8100, 0x0000186a, 0xffcda100,
1534 0x00001873, 0xffcdc200, 0x0000187b, 0xffcde200,
1535 0x00001883, 0xffd50000, 0x0000188b, 0xffd52000,
1536 0x00001894, 0xffd54000, 0x0000189c, 0xffd56100,
1537 0x000018a4, 0xffd58100, 0x000018ac, 0xffd5a100,
1538 0x000018b4, 0xffd5c200, 0x000018bd, 0xffd5e200,
1539 0x000018c5, 0xffde0000, 0x000018cd, 0xffde2000,
1540 0x000018d5, 0xffde4000, 0x000018de, 0xffde6100,
1541 0x000018e6, 0xffde8100, 0x000018ee, 0xffdea100,
1542 0x000018f6, 0xffdec200, 0x000018ff, 0xffdee200,
1543 0x00001c00, 0xffe60000, 0x00001c08, 0xffe62000,
1544 0x00001c10, 0xffe64000, 0x00001c18, 0xffe66100,
1545 0x00001c20, 0xffe68100, 0x00001c29, 0xffe6a100,
1546 0x00001c31, 0xffe6c200, 0x00001c39, 0xffe6e200,
1547 0x00001c41, 0xffee0000, 0x00001c4a, 0xffee2000,
1548 0x00001c52, 0xffee4000, 0x00001c5a, 0xffee6100,
1549 0x00001c62, 0xffee8100, 0x00001c6a, 0xffeea100,
1550 0x00001c73, 0xffeec200, 0x00001c7b, 0xffeee200,
1551 0x00001c83, 0xfff60000, 0x00001c8b, 0xfff62000,
1552 0x00001c94, 0xfff64000, 0x00001c9c, 0xfff66100,
1553 0x00001ca4, 0xfff68100, 0x00001cac, 0xfff6a100,
1554 0x00001cb4, 0xfff6c200, 0x00001cbd, 0xfff6e200,
1555 0x00001cc5, 0xffff0000, 0x00001ccd, 0xffff2000,
1556 0x00001cd5, 0xffff4000, 0x00001cde, 0xffff6100,
1557 0x00001ce6, 0xffff8100, 0x00001cee, 0xffffa100,
1558 0x00001cf6, 0xffffc200, 0x00001cff, 0xffffe200
1562 Blit_RGB565_ARGB8888(SDL_BlitInfo * info)
1564 Blit_RGB565_32(info, RGB565_ARGB8888_LUT);
1567 /* Special optimized blit for RGB 5-6-5 --> ABGR 8-8-8-8 */
1568 static const Uint32 RGB565_ABGR8888_LUT[512] = {
1569 0xff000000, 0x00000000, 0xff080000, 0x00002000,
1570 0xff100000, 0x00004000, 0xff180000, 0x00006100,
1571 0xff200000, 0x00008100, 0xff290000, 0x0000a100,
1572 0xff310000, 0x0000c200, 0xff390000, 0x0000e200,
1573 0xff410000, 0x00000008, 0xff4a0000, 0x00002008,
1574 0xff520000, 0x00004008, 0xff5a0000, 0x00006108,
1575 0xff620000, 0x00008108, 0xff6a0000, 0x0000a108,
1576 0xff730000, 0x0000c208, 0xff7b0000, 0x0000e208,
1577 0xff830000, 0x00000010, 0xff8b0000, 0x00002010,
1578 0xff940000, 0x00004010, 0xff9c0000, 0x00006110,
1579 0xffa40000, 0x00008110, 0xffac0000, 0x0000a110,
1580 0xffb40000, 0x0000c210, 0xffbd0000, 0x0000e210,
1581 0xffc50000, 0x00000018, 0xffcd0000, 0x00002018,
1582 0xffd50000, 0x00004018, 0xffde0000, 0x00006118,
1583 0xffe60000, 0x00008118, 0xffee0000, 0x0000a118,
1584 0xfff60000, 0x0000c218, 0xffff0000, 0x0000e218,
1585 0xff000400, 0x00000020, 0xff080400, 0x00002020,
1586 0xff100400, 0x00004020, 0xff180400, 0x00006120,
1587 0xff200400, 0x00008120, 0xff290400, 0x0000a120,
1588 0xff310400, 0x0000c220, 0xff390400, 0x0000e220,
1589 0xff410400, 0x00000029, 0xff4a0400, 0x00002029,
1590 0xff520400, 0x00004029, 0xff5a0400, 0x00006129,
1591 0xff620400, 0x00008129, 0xff6a0400, 0x0000a129,
1592 0xff730400, 0x0000c229, 0xff7b0400, 0x0000e229,
1593 0xff830400, 0x00000031, 0xff8b0400, 0x00002031,
1594 0xff940400, 0x00004031, 0xff9c0400, 0x00006131,
1595 0xffa40400, 0x00008131, 0xffac0400, 0x0000a131,
1596 0xffb40400, 0x0000c231, 0xffbd0400, 0x0000e231,
1597 0xffc50400, 0x00000039, 0xffcd0400, 0x00002039,
1598 0xffd50400, 0x00004039, 0xffde0400, 0x00006139,
1599 0xffe60400, 0x00008139, 0xffee0400, 0x0000a139,
1600 0xfff60400, 0x0000c239, 0xffff0400, 0x0000e239,
1601 0xff000800, 0x00000041, 0xff080800, 0x00002041,
1602 0xff100800, 0x00004041, 0xff180800, 0x00006141,
1603 0xff200800, 0x00008141, 0xff290800, 0x0000a141,
1604 0xff310800, 0x0000c241, 0xff390800, 0x0000e241,
1605 0xff410800, 0x0000004a, 0xff4a0800, 0x0000204a,
1606 0xff520800, 0x0000404a, 0xff5a0800, 0x0000614a,
1607 0xff620800, 0x0000814a, 0xff6a0800, 0x0000a14a,
1608 0xff730800, 0x0000c24a, 0xff7b0800, 0x0000e24a,
1609 0xff830800, 0x00000052, 0xff8b0800, 0x00002052,
1610 0xff940800, 0x00004052, 0xff9c0800, 0x00006152,
1611 0xffa40800, 0x00008152, 0xffac0800, 0x0000a152,
1612 0xffb40800, 0x0000c252, 0xffbd0800, 0x0000e252,
1613 0xffc50800, 0x0000005a, 0xffcd0800, 0x0000205a,
1614 0xffd50800, 0x0000405a, 0xffde0800, 0x0000615a,
1615 0xffe60800, 0x0000815a, 0xffee0800, 0x0000a15a,
1616 0xfff60800, 0x0000c25a, 0xffff0800, 0x0000e25a,
1617 0xff000c00, 0x00000062, 0xff080c00, 0x00002062,
1618 0xff100c00, 0x00004062, 0xff180c00, 0x00006162,
1619 0xff200c00, 0x00008162, 0xff290c00, 0x0000a162,
1620 0xff310c00, 0x0000c262, 0xff390c00, 0x0000e262,
1621 0xff410c00, 0x0000006a, 0xff4a0c00, 0x0000206a,
1622 0xff520c00, 0x0000406a, 0xff5a0c00, 0x0000616a,
1623 0xff620c00, 0x0000816a, 0xff6a0c00, 0x0000a16a,
1624 0xff730c00, 0x0000c26a, 0xff7b0c00, 0x0000e26a,
1625 0xff830c00, 0x00000073, 0xff8b0c00, 0x00002073,
1626 0xff940c00, 0x00004073, 0xff9c0c00, 0x00006173,
1627 0xffa40c00, 0x00008173, 0xffac0c00, 0x0000a173,
1628 0xffb40c00, 0x0000c273, 0xffbd0c00, 0x0000e273,
1629 0xffc50c00, 0x0000007b, 0xffcd0c00, 0x0000207b,
1630 0xffd50c00, 0x0000407b, 0xffde0c00, 0x0000617b,
1631 0xffe60c00, 0x0000817b, 0xffee0c00, 0x0000a17b,
1632 0xfff60c00, 0x0000c27b, 0xffff0c00, 0x0000e27b,
1633 0xff001000, 0x00000083, 0xff081000, 0x00002083,
1634 0xff101000, 0x00004083, 0xff181000, 0x00006183,
1635 0xff201000, 0x00008183, 0xff291000, 0x0000a183,
1636 0xff311000, 0x0000c283, 0xff391000, 0x0000e283,
1637 0xff411000, 0x0000008b, 0xff4a1000, 0x0000208b,
1638 0xff521000, 0x0000408b, 0xff5a1000, 0x0000618b,
1639 0xff621000, 0x0000818b, 0xff6a1000, 0x0000a18b,
1640 0xff731000, 0x0000c28b, 0xff7b1000, 0x0000e28b,
1641 0xff831000, 0x00000094, 0xff8b1000, 0x00002094,
1642 0xff941000, 0x00004094, 0xff9c1000, 0x00006194,
1643 0xffa41000, 0x00008194, 0xffac1000, 0x0000a194,
1644 0xffb41000, 0x0000c294, 0xffbd1000, 0x0000e294,
1645 0xffc51000, 0x0000009c, 0xffcd1000, 0x0000209c,
1646 0xffd51000, 0x0000409c, 0xffde1000, 0x0000619c,
1647 0xffe61000, 0x0000819c, 0xffee1000, 0x0000a19c,
1648 0xfff61000, 0x0000c29c, 0xffff1000, 0x0000e29c,
1649 0xff001400, 0x000000a4, 0xff081400, 0x000020a4,
1650 0xff101400, 0x000040a4, 0xff181400, 0x000061a4,
1651 0xff201400, 0x000081a4, 0xff291400, 0x0000a1a4,
1652 0xff311400, 0x0000c2a4, 0xff391400, 0x0000e2a4,
1653 0xff411400, 0x000000ac, 0xff4a1400, 0x000020ac,
1654 0xff521400, 0x000040ac, 0xff5a1400, 0x000061ac,
1655 0xff621400, 0x000081ac, 0xff6a1400, 0x0000a1ac,
1656 0xff731400, 0x0000c2ac, 0xff7b1400, 0x0000e2ac,
1657 0xff831400, 0x000000b4, 0xff8b1400, 0x000020b4,
1658 0xff941400, 0x000040b4, 0xff9c1400, 0x000061b4,
1659 0xffa41400, 0x000081b4, 0xffac1400, 0x0000a1b4,
1660 0xffb41400, 0x0000c2b4, 0xffbd1400, 0x0000e2b4,
1661 0xffc51400, 0x000000bd, 0xffcd1400, 0x000020bd,
1662 0xffd51400, 0x000040bd, 0xffde1400, 0x000061bd,
1663 0xffe61400, 0x000081bd, 0xffee1400, 0x0000a1bd,
1664 0xfff61400, 0x0000c2bd, 0xffff1400, 0x0000e2bd,
1665 0xff001800, 0x000000c5, 0xff081800, 0x000020c5,
1666 0xff101800, 0x000040c5, 0xff181800, 0x000061c5,
1667 0xff201800, 0x000081c5, 0xff291800, 0x0000a1c5,
1668 0xff311800, 0x0000c2c5, 0xff391800, 0x0000e2c5,
1669 0xff411800, 0x000000cd, 0xff4a1800, 0x000020cd,
1670 0xff521800, 0x000040cd, 0xff5a1800, 0x000061cd,
1671 0xff621800, 0x000081cd, 0xff6a1800, 0x0000a1cd,
1672 0xff731800, 0x0000c2cd, 0xff7b1800, 0x0000e2cd,
1673 0xff831800, 0x000000d5, 0xff8b1800, 0x000020d5,
1674 0xff941800, 0x000040d5, 0xff9c1800, 0x000061d5,
1675 0xffa41800, 0x000081d5, 0xffac1800, 0x0000a1d5,
1676 0xffb41800, 0x0000c2d5, 0xffbd1800, 0x0000e2d5,
1677 0xffc51800, 0x000000de, 0xffcd1800, 0x000020de,
1678 0xffd51800, 0x000040de, 0xffde1800, 0x000061de,
1679 0xffe61800, 0x000081de, 0xffee1800, 0x0000a1de,
1680 0xfff61800, 0x0000c2de, 0xffff1800, 0x0000e2de,
1681 0xff001c00, 0x000000e6, 0xff081c00, 0x000020e6,
1682 0xff101c00, 0x000040e6, 0xff181c00, 0x000061e6,
1683 0xff201c00, 0x000081e6, 0xff291c00, 0x0000a1e6,
1684 0xff311c00, 0x0000c2e6, 0xff391c00, 0x0000e2e6,
1685 0xff411c00, 0x000000ee, 0xff4a1c00, 0x000020ee,
1686 0xff521c00, 0x000040ee, 0xff5a1c00, 0x000061ee,
1687 0xff621c00, 0x000081ee, 0xff6a1c00, 0x0000a1ee,
1688 0xff731c00, 0x0000c2ee, 0xff7b1c00, 0x0000e2ee,
1689 0xff831c00, 0x000000f6, 0xff8b1c00, 0x000020f6,
1690 0xff941c00, 0x000040f6, 0xff9c1c00, 0x000061f6,
1691 0xffa41c00, 0x000081f6, 0xffac1c00, 0x0000a1f6,
1692 0xffb41c00, 0x0000c2f6, 0xffbd1c00, 0x0000e2f6,
1693 0xffc51c00, 0x000000ff, 0xffcd1c00, 0x000020ff,
1694 0xffd51c00, 0x000040ff, 0xffde1c00, 0x000061ff,
1695 0xffe61c00, 0x000081ff, 0xffee1c00, 0x0000a1ff,
1696 0xfff61c00, 0x0000c2ff, 0xffff1c00, 0x0000e2ff
1700 Blit_RGB565_ABGR8888(SDL_BlitInfo * info)
1702 Blit_RGB565_32(info, RGB565_ABGR8888_LUT);
1705 /* Special optimized blit for RGB 5-6-5 --> RGBA 8-8-8-8 */
1706 static const Uint32 RGB565_RGBA8888_LUT[512] = {
1707 0x000000ff, 0x00000000, 0x000008ff, 0x00200000,
1708 0x000010ff, 0x00400000, 0x000018ff, 0x00610000,
1709 0x000020ff, 0x00810000, 0x000029ff, 0x00a10000,
1710 0x000031ff, 0x00c20000, 0x000039ff, 0x00e20000,
1711 0x000041ff, 0x08000000, 0x00004aff, 0x08200000,
1712 0x000052ff, 0x08400000, 0x00005aff, 0x08610000,
1713 0x000062ff, 0x08810000, 0x00006aff, 0x08a10000,
1714 0x000073ff, 0x08c20000, 0x00007bff, 0x08e20000,
1715 0x000083ff, 0x10000000, 0x00008bff, 0x10200000,
1716 0x000094ff, 0x10400000, 0x00009cff, 0x10610000,
1717 0x0000a4ff, 0x10810000, 0x0000acff, 0x10a10000,
1718 0x0000b4ff, 0x10c20000, 0x0000bdff, 0x10e20000,
1719 0x0000c5ff, 0x18000000, 0x0000cdff, 0x18200000,
1720 0x0000d5ff, 0x18400000, 0x0000deff, 0x18610000,
1721 0x0000e6ff, 0x18810000, 0x0000eeff, 0x18a10000,
1722 0x0000f6ff, 0x18c20000, 0x0000ffff, 0x18e20000,
1723 0x000400ff, 0x20000000, 0x000408ff, 0x20200000,
1724 0x000410ff, 0x20400000, 0x000418ff, 0x20610000,
1725 0x000420ff, 0x20810000, 0x000429ff, 0x20a10000,
1726 0x000431ff, 0x20c20000, 0x000439ff, 0x20e20000,
1727 0x000441ff, 0x29000000, 0x00044aff, 0x29200000,
1728 0x000452ff, 0x29400000, 0x00045aff, 0x29610000,
1729 0x000462ff, 0x29810000, 0x00046aff, 0x29a10000,
1730 0x000473ff, 0x29c20000, 0x00047bff, 0x29e20000,
1731 0x000483ff, 0x31000000, 0x00048bff, 0x31200000,
1732 0x000494ff, 0x31400000, 0x00049cff, 0x31610000,
1733 0x0004a4ff, 0x31810000, 0x0004acff, 0x31a10000,
1734 0x0004b4ff, 0x31c20000, 0x0004bdff, 0x31e20000,
1735 0x0004c5ff, 0x39000000, 0x0004cdff, 0x39200000,
1736 0x0004d5ff, 0x39400000, 0x0004deff, 0x39610000,
1737 0x0004e6ff, 0x39810000, 0x0004eeff, 0x39a10000,
1738 0x0004f6ff, 0x39c20000, 0x0004ffff, 0x39e20000,
1739 0x000800ff, 0x41000000, 0x000808ff, 0x41200000,
1740 0x000810ff, 0x41400000, 0x000818ff, 0x41610000,
1741 0x000820ff, 0x41810000, 0x000829ff, 0x41a10000,
1742 0x000831ff, 0x41c20000, 0x000839ff, 0x41e20000,
1743 0x000841ff, 0x4a000000, 0x00084aff, 0x4a200000,
1744 0x000852ff, 0x4a400000, 0x00085aff, 0x4a610000,
1745 0x000862ff, 0x4a810000, 0x00086aff, 0x4aa10000,
1746 0x000873ff, 0x4ac20000, 0x00087bff, 0x4ae20000,
1747 0x000883ff, 0x52000000, 0x00088bff, 0x52200000,
1748 0x000894ff, 0x52400000, 0x00089cff, 0x52610000,
1749 0x0008a4ff, 0x52810000, 0x0008acff, 0x52a10000,
1750 0x0008b4ff, 0x52c20000, 0x0008bdff, 0x52e20000,
1751 0x0008c5ff, 0x5a000000, 0x0008cdff, 0x5a200000,
1752 0x0008d5ff, 0x5a400000, 0x0008deff, 0x5a610000,
1753 0x0008e6ff, 0x5a810000, 0x0008eeff, 0x5aa10000,
1754 0x0008f6ff, 0x5ac20000, 0x0008ffff, 0x5ae20000,
1755 0x000c00ff, 0x62000000, 0x000c08ff, 0x62200000,
1756 0x000c10ff, 0x62400000, 0x000c18ff, 0x62610000,
1757 0x000c20ff, 0x62810000, 0x000c29ff, 0x62a10000,
1758 0x000c31ff, 0x62c20000, 0x000c39ff, 0x62e20000,
1759 0x000c41ff, 0x6a000000, 0x000c4aff, 0x6a200000,
1760 0x000c52ff, 0x6a400000, 0x000c5aff, 0x6a610000,
1761 0x000c62ff, 0x6a810000, 0x000c6aff, 0x6aa10000,
1762 0x000c73ff, 0x6ac20000, 0x000c7bff, 0x6ae20000,
1763 0x000c83ff, 0x73000000, 0x000c8bff, 0x73200000,
1764 0x000c94ff, 0x73400000, 0x000c9cff, 0x73610000,
1765 0x000ca4ff, 0x73810000, 0x000cacff, 0x73a10000,
1766 0x000cb4ff, 0x73c20000, 0x000cbdff, 0x73e20000,
1767 0x000cc5ff, 0x7b000000, 0x000ccdff, 0x7b200000,
1768 0x000cd5ff, 0x7b400000, 0x000cdeff, 0x7b610000,
1769 0x000ce6ff, 0x7b810000, 0x000ceeff, 0x7ba10000,
1770 0x000cf6ff, 0x7bc20000, 0x000cffff, 0x7be20000,
1771 0x001000ff, 0x83000000, 0x001008ff, 0x83200000,
1772 0x001010ff, 0x83400000, 0x001018ff, 0x83610000,
1773 0x001020ff, 0x83810000, 0x001029ff, 0x83a10000,
1774 0x001031ff, 0x83c20000, 0x001039ff, 0x83e20000,
1775 0x001041ff, 0x8b000000, 0x00104aff, 0x8b200000,
1776 0x001052ff, 0x8b400000, 0x00105aff, 0x8b610000,
1777 0x001062ff, 0x8b810000, 0x00106aff, 0x8ba10000,
1778 0x001073ff, 0x8bc20000, 0x00107bff, 0x8be20000,
1779 0x001083ff, 0x94000000, 0x00108bff, 0x94200000,
1780 0x001094ff, 0x94400000, 0x00109cff, 0x94610000,
1781 0x0010a4ff, 0x94810000, 0x0010acff, 0x94a10000,
1782 0x0010b4ff, 0x94c20000, 0x0010bdff, 0x94e20000,
1783 0x0010c5ff, 0x9c000000, 0x0010cdff, 0x9c200000,
1784 0x0010d5ff, 0x9c400000, 0x0010deff, 0x9c610000,
1785 0x0010e6ff, 0x9c810000, 0x0010eeff, 0x9ca10000,
1786 0x0010f6ff, 0x9cc20000, 0x0010ffff, 0x9ce20000,
1787 0x001400ff, 0xa4000000, 0x001408ff, 0xa4200000,
1788 0x001410ff, 0xa4400000, 0x001418ff, 0xa4610000,
1789 0x001420ff, 0xa4810000, 0x001429ff, 0xa4a10000,
1790 0x001431ff, 0xa4c20000, 0x001439ff, 0xa4e20000,
1791 0x001441ff, 0xac000000, 0x00144aff, 0xac200000,
1792 0x001452ff, 0xac400000, 0x00145aff, 0xac610000,
1793 0x001462ff, 0xac810000, 0x00146aff, 0xaca10000,
1794 0x001473ff, 0xacc20000, 0x00147bff, 0xace20000,
1795 0x001483ff, 0xb4000000, 0x00148bff, 0xb4200000,
1796 0x001494ff, 0xb4400000, 0x00149cff, 0xb4610000,
1797 0x0014a4ff, 0xb4810000, 0x0014acff, 0xb4a10000,
1798 0x0014b4ff, 0xb4c20000, 0x0014bdff, 0xb4e20000,
1799 0x0014c5ff, 0xbd000000, 0x0014cdff, 0xbd200000,
1800 0x0014d5ff, 0xbd400000, 0x0014deff, 0xbd610000,
1801 0x0014e6ff, 0xbd810000, 0x0014eeff, 0xbda10000,
1802 0x0014f6ff, 0xbdc20000, 0x0014ffff, 0xbde20000,
1803 0x001800ff, 0xc5000000, 0x001808ff, 0xc5200000,
1804 0x001810ff, 0xc5400000, 0x001818ff, 0xc5610000,
1805 0x001820ff, 0xc5810000, 0x001829ff, 0xc5a10000,
1806 0x001831ff, 0xc5c20000, 0x001839ff, 0xc5e20000,
1807 0x001841ff, 0xcd000000, 0x00184aff, 0xcd200000,
1808 0x001852ff, 0xcd400000, 0x00185aff, 0xcd610000,
1809 0x001862ff, 0xcd810000, 0x00186aff, 0xcda10000,
1810 0x001873ff, 0xcdc20000, 0x00187bff, 0xcde20000,
1811 0x001883ff, 0xd5000000, 0x00188bff, 0xd5200000,
1812 0x001894ff, 0xd5400000, 0x00189cff, 0xd5610000,
1813 0x0018a4ff, 0xd5810000, 0x0018acff, 0xd5a10000,
1814 0x0018b4ff, 0xd5c20000, 0x0018bdff, 0xd5e20000,
1815 0x0018c5ff, 0xde000000, 0x0018cdff, 0xde200000,
1816 0x0018d5ff, 0xde400000, 0x0018deff, 0xde610000,
1817 0x0018e6ff, 0xde810000, 0x0018eeff, 0xdea10000,
1818 0x0018f6ff, 0xdec20000, 0x0018ffff, 0xdee20000,
1819 0x001c00ff, 0xe6000000, 0x001c08ff, 0xe6200000,
1820 0x001c10ff, 0xe6400000, 0x001c18ff, 0xe6610000,
1821 0x001c20ff, 0xe6810000, 0x001c29ff, 0xe6a10000,
1822 0x001c31ff, 0xe6c20000, 0x001c39ff, 0xe6e20000,
1823 0x001c41ff, 0xee000000, 0x001c4aff, 0xee200000,
1824 0x001c52ff, 0xee400000, 0x001c5aff, 0xee610000,
1825 0x001c62ff, 0xee810000, 0x001c6aff, 0xeea10000,
1826 0x001c73ff, 0xeec20000, 0x001c7bff, 0xeee20000,
1827 0x001c83ff, 0xf6000000, 0x001c8bff, 0xf6200000,
1828 0x001c94ff, 0xf6400000, 0x001c9cff, 0xf6610000,
1829 0x001ca4ff, 0xf6810000, 0x001cacff, 0xf6a10000,
1830 0x001cb4ff, 0xf6c20000, 0x001cbdff, 0xf6e20000,
1831 0x001cc5ff, 0xff000000, 0x001ccdff, 0xff200000,
1832 0x001cd5ff, 0xff400000, 0x001cdeff, 0xff610000,
1833 0x001ce6ff, 0xff810000, 0x001ceeff, 0xffa10000,
1834 0x001cf6ff, 0xffc20000, 0x001cffff, 0xffe20000,
1838 Blit_RGB565_RGBA8888(SDL_BlitInfo * info)
1840 Blit_RGB565_32(info, RGB565_RGBA8888_LUT);
1843 /* Special optimized blit for RGB 5-6-5 --> BGRA 8-8-8-8 */
1844 static const Uint32 RGB565_BGRA8888_LUT[512] = {
1845 0x00000000, 0x000000ff, 0x08000000, 0x002000ff,
1846 0x10000000, 0x004000ff, 0x18000000, 0x006100ff,
1847 0x20000000, 0x008100ff, 0x29000000, 0x00a100ff,
1848 0x31000000, 0x00c200ff, 0x39000000, 0x00e200ff,
1849 0x41000000, 0x000008ff, 0x4a000000, 0x002008ff,
1850 0x52000000, 0x004008ff, 0x5a000000, 0x006108ff,
1851 0x62000000, 0x008108ff, 0x6a000000, 0x00a108ff,
1852 0x73000000, 0x00c208ff, 0x7b000000, 0x00e208ff,
1853 0x83000000, 0x000010ff, 0x8b000000, 0x002010ff,
1854 0x94000000, 0x004010ff, 0x9c000000, 0x006110ff,
1855 0xa4000000, 0x008110ff, 0xac000000, 0x00a110ff,
1856 0xb4000000, 0x00c210ff, 0xbd000000, 0x00e210ff,
1857 0xc5000000, 0x000018ff, 0xcd000000, 0x002018ff,
1858 0xd5000000, 0x004018ff, 0xde000000, 0x006118ff,
1859 0xe6000000, 0x008118ff, 0xee000000, 0x00a118ff,
1860 0xf6000000, 0x00c218ff, 0xff000000, 0x00e218ff,
1861 0x00040000, 0x000020ff, 0x08040000, 0x002020ff,
1862 0x10040000, 0x004020ff, 0x18040000, 0x006120ff,
1863 0x20040000, 0x008120ff, 0x29040000, 0x00a120ff,
1864 0x31040000, 0x00c220ff, 0x39040000, 0x00e220ff,
1865 0x41040000, 0x000029ff, 0x4a040000, 0x002029ff,
1866 0x52040000, 0x004029ff, 0x5a040000, 0x006129ff,
1867 0x62040000, 0x008129ff, 0x6a040000, 0x00a129ff,
1868 0x73040000, 0x00c229ff, 0x7b040000, 0x00e229ff,
1869 0x83040000, 0x000031ff, 0x8b040000, 0x002031ff,
1870 0x94040000, 0x004031ff, 0x9c040000, 0x006131ff,
1871 0xa4040000, 0x008131ff, 0xac040000, 0x00a131ff,
1872 0xb4040000, 0x00c231ff, 0xbd040000, 0x00e231ff,
1873 0xc5040000, 0x000039ff, 0xcd040000, 0x002039ff,
1874 0xd5040000, 0x004039ff, 0xde040000, 0x006139ff,
1875 0xe6040000, 0x008139ff, 0xee040000, 0x00a139ff,
1876 0xf6040000, 0x00c239ff, 0xff040000, 0x00e239ff,
1877 0x00080000, 0x000041ff, 0x08080000, 0x002041ff,
1878 0x10080000, 0x004041ff, 0x18080000, 0x006141ff,
1879 0x20080000, 0x008141ff, 0x29080000, 0x00a141ff,
1880 0x31080000, 0x00c241ff, 0x39080000, 0x00e241ff,
1881 0x41080000, 0x00004aff, 0x4a080000, 0x00204aff,
1882 0x52080000, 0x00404aff, 0x5a080000, 0x00614aff,
1883 0x62080000, 0x00814aff, 0x6a080000, 0x00a14aff,
1884 0x73080000, 0x00c24aff, 0x7b080000, 0x00e24aff,
1885 0x83080000, 0x000052ff, 0x8b080000, 0x002052ff,
1886 0x94080000, 0x004052ff, 0x9c080000, 0x006152ff,
1887 0xa4080000, 0x008152ff, 0xac080000, 0x00a152ff,
1888 0xb4080000, 0x00c252ff, 0xbd080000, 0x00e252ff,
1889 0xc5080000, 0x00005aff, 0xcd080000, 0x00205aff,
1890 0xd5080000, 0x00405aff, 0xde080000, 0x00615aff,
1891 0xe6080000, 0x00815aff, 0xee080000, 0x00a15aff,
1892 0xf6080000, 0x00c25aff, 0xff080000, 0x00e25aff,
1893 0x000c0000, 0x000062ff, 0x080c0000, 0x002062ff,
1894 0x100c0000, 0x004062ff, 0x180c0000, 0x006162ff,
1895 0x200c0000, 0x008162ff, 0x290c0000, 0x00a162ff,
1896 0x310c0000, 0x00c262ff, 0x390c0000, 0x00e262ff,
1897 0x410c0000, 0x00006aff, 0x4a0c0000, 0x00206aff,
1898 0x520c0000, 0x00406aff, 0x5a0c0000, 0x00616aff,
1899 0x620c0000, 0x00816aff, 0x6a0c0000, 0x00a16aff,
1900 0x730c0000, 0x00c26aff, 0x7b0c0000, 0x00e26aff,
1901 0x830c0000, 0x000073ff, 0x8b0c0000, 0x002073ff,
1902 0x940c0000, 0x004073ff, 0x9c0c0000, 0x006173ff,
1903 0xa40c0000, 0x008173ff, 0xac0c0000, 0x00a173ff,
1904 0xb40c0000, 0x00c273ff, 0xbd0c0000, 0x00e273ff,
1905 0xc50c0000, 0x00007bff, 0xcd0c0000, 0x00207bff,
1906 0xd50c0000, 0x00407bff, 0xde0c0000, 0x00617bff,
1907 0xe60c0000, 0x00817bff, 0xee0c0000, 0x00a17bff,
1908 0xf60c0000, 0x00c27bff, 0xff0c0000, 0x00e27bff,
1909 0x00100000, 0x000083ff, 0x08100000, 0x002083ff,
1910 0x10100000, 0x004083ff, 0x18100000, 0x006183ff,
1911 0x20100000, 0x008183ff, 0x29100000, 0x00a183ff,
1912 0x31100000, 0x00c283ff, 0x39100000, 0x00e283ff,
1913 0x41100000, 0x00008bff, 0x4a100000, 0x00208bff,
1914 0x52100000, 0x00408bff, 0x5a100000, 0x00618bff,
1915 0x62100000, 0x00818bff, 0x6a100000, 0x00a18bff,
1916 0x73100000, 0x00c28bff, 0x7b100000, 0x00e28bff,
1917 0x83100000, 0x000094ff, 0x8b100000, 0x002094ff,
1918 0x94100000, 0x004094ff, 0x9c100000, 0x006194ff,
1919 0xa4100000, 0x008194ff, 0xac100000, 0x00a194ff,
1920 0xb4100000, 0x00c294ff, 0xbd100000, 0x00e294ff,
1921 0xc5100000, 0x00009cff, 0xcd100000, 0x00209cff,
1922 0xd5100000, 0x00409cff, 0xde100000, 0x00619cff,
1923 0xe6100000, 0x00819cff, 0xee100000, 0x00a19cff,
1924 0xf6100000, 0x00c29cff, 0xff100000, 0x00e29cff,
1925 0x00140000, 0x0000a4ff, 0x08140000, 0x0020a4ff,
1926 0x10140000, 0x0040a4ff, 0x18140000, 0x0061a4ff,
1927 0x20140000, 0x0081a4ff, 0x29140000, 0x00a1a4ff,
1928 0x31140000, 0x00c2a4ff, 0x39140000, 0x00e2a4ff,
1929 0x41140000, 0x0000acff, 0x4a140000, 0x0020acff,
1930 0x52140000, 0x0040acff, 0x5a140000, 0x0061acff,
1931 0x62140000, 0x0081acff, 0x6a140000, 0x00a1acff,
1932 0x73140000, 0x00c2acff, 0x7b140000, 0x00e2acff,
1933 0x83140000, 0x0000b4ff, 0x8b140000, 0x0020b4ff,
1934 0x94140000, 0x0040b4ff, 0x9c140000, 0x0061b4ff,
1935 0xa4140000, 0x0081b4ff, 0xac140000, 0x00a1b4ff,
1936 0xb4140000, 0x00c2b4ff, 0xbd140000, 0x00e2b4ff,
1937 0xc5140000, 0x0000bdff, 0xcd140000, 0x0020bdff,
1938 0xd5140000, 0x0040bdff, 0xde140000, 0x0061bdff,
1939 0xe6140000, 0x0081bdff, 0xee140000, 0x00a1bdff,
1940 0xf6140000, 0x00c2bdff, 0xff140000, 0x00e2bdff,
1941 0x00180000, 0x0000c5ff, 0x08180000, 0x0020c5ff,
1942 0x10180000, 0x0040c5ff, 0x18180000, 0x0061c5ff,
1943 0x20180000, 0x0081c5ff, 0x29180000, 0x00a1c5ff,
1944 0x31180000, 0x00c2c5ff, 0x39180000, 0x00e2c5ff,
1945 0x41180000, 0x0000cdff, 0x4a180000, 0x0020cdff,
1946 0x52180000, 0x0040cdff, 0x5a180000, 0x0061cdff,
1947 0x62180000, 0x0081cdff, 0x6a180000, 0x00a1cdff,
1948 0x73180000, 0x00c2cdff, 0x7b180000, 0x00e2cdff,
1949 0x83180000, 0x0000d5ff, 0x8b180000, 0x0020d5ff,
1950 0x94180000, 0x0040d5ff, 0x9c180000, 0x0061d5ff,
1951 0xa4180000, 0x0081d5ff, 0xac180000, 0x00a1d5ff,
1952 0xb4180000, 0x00c2d5ff, 0xbd180000, 0x00e2d5ff,
1953 0xc5180000, 0x0000deff, 0xcd180000, 0x0020deff,
1954 0xd5180000, 0x0040deff, 0xde180000, 0x0061deff,
1955 0xe6180000, 0x0081deff, 0xee180000, 0x00a1deff,
1956 0xf6180000, 0x00c2deff, 0xff180000, 0x00e2deff,
1957 0x001c0000, 0x0000e6ff, 0x081c0000, 0x0020e6ff,
1958 0x101c0000, 0x0040e6ff, 0x181c0000, 0x0061e6ff,
1959 0x201c0000, 0x0081e6ff, 0x291c0000, 0x00a1e6ff,
1960 0x311c0000, 0x00c2e6ff, 0x391c0000, 0x00e2e6ff,
1961 0x411c0000, 0x0000eeff, 0x4a1c0000, 0x0020eeff,
1962 0x521c0000, 0x0040eeff, 0x5a1c0000, 0x0061eeff,
1963 0x621c0000, 0x0081eeff, 0x6a1c0000, 0x00a1eeff,
1964 0x731c0000, 0x00c2eeff, 0x7b1c0000, 0x00e2eeff,
1965 0x831c0000, 0x0000f6ff, 0x8b1c0000, 0x0020f6ff,
1966 0x941c0000, 0x0040f6ff, 0x9c1c0000, 0x0061f6ff,
1967 0xa41c0000, 0x0081f6ff, 0xac1c0000, 0x00a1f6ff,
1968 0xb41c0000, 0x00c2f6ff, 0xbd1c0000, 0x00e2f6ff,
1969 0xc51c0000, 0x0000ffff, 0xcd1c0000, 0x0020ffff,
1970 0xd51c0000, 0x0040ffff, 0xde1c0000, 0x0061ffff,
1971 0xe61c0000, 0x0081ffff, 0xee1c0000, 0x00a1ffff,
1972 0xf61c0000, 0x00c2ffff, 0xff1c0000, 0x00e2ffff
1976 Blit_RGB565_BGRA8888(SDL_BlitInfo * info)
1978 Blit_RGB565_32(info, RGB565_BGRA8888_LUT);
1982 BlitNto1(SDL_BlitInfo * info)
1984 #ifndef USE_DUFFS_LOOP
1991 int srcskip, dstskip;
1995 SDL_PixelFormat *srcfmt;
1997 /* Set up some basic variables */
1998 width = info->dst_w;
1999 height = info->dst_h;
2001 srcskip = info->src_skip;
2003 dstskip = info->dst_skip;
2005 srcfmt = info->src_fmt;
2006 srcbpp = srcfmt->BytesPerPixel;
2010 #ifdef USE_DUFFS_LOOP
2013 DISEMBLE_RGB(src, srcbpp, srcfmt, Pixel,
2016 /* Pack RGB into 8bit pixel */
2017 *dst = ((sR>>5)<<(3+2))|
2026 for (c = width; c; --c) {
2027 DISEMBLE_RGB(src, srcbpp, srcfmt, Pixel, sR, sG, sB);
2029 /* Pack RGB into 8bit pixel */
2030 *dst = ((sR >> 5) << (3 + 2)) |
2031 ((sG >> 5) << (2)) | ((sB >> 6) << (0));
2042 #ifdef USE_DUFFS_LOOP
2045 DISEMBLE_RGB(src, srcbpp, srcfmt, Pixel,
2048 /* Pack RGB into 8bit pixel */
2049 *dst = map[((sR>>5)<<(3+2))|
2058 for (c = width; c; --c) {
2059 DISEMBLE_RGB(src, srcbpp, srcfmt, Pixel, sR, sG, sB);
2061 /* Pack RGB into 8bit pixel */
2062 *dst = map[((sR >> 5) << (3 + 2)) |
2063 ((sG >> 5) << (2)) | ((sB >> 6) << (0))];
2068 #endif /* USE_DUFFS_LOOP */
2075 /* blits 32 bit RGB<->RGBA with both surfaces having the same R,G,B fields */
2077 Blit4to4MaskAlpha(SDL_BlitInfo * info)
2079 int width = info->dst_w;
2080 int height = info->dst_h;
2081 Uint32 *src = (Uint32 *) info->src;
2082 int srcskip = info->src_skip;
2083 Uint32 *dst = (Uint32 *) info->dst;
2084 int dstskip = info->dst_skip;
2085 SDL_PixelFormat *srcfmt = info->src_fmt;
2086 SDL_PixelFormat *dstfmt = info->dst_fmt;
2088 if (dstfmt->Amask) {
2089 /* RGB->RGBA, SET_ALPHA */
2090 Uint32 mask = (info->a >> dstfmt->Aloss) << dstfmt->Ashift;
2102 src = (Uint32 *) ((Uint8 *) src + srcskip);
2103 dst = (Uint32 *) ((Uint8 *) dst + dstskip);
2106 /* RGBA->RGB, NO_ALPHA */
2107 Uint32 mask = srcfmt->Rmask | srcfmt->Gmask | srcfmt->Bmask;
2119 src = (Uint32 *) ((Uint8 *) src + srcskip);
2120 dst = (Uint32 *) ((Uint8 *) dst + dstskip);
2125 /* blits 32 bit RGBA<->RGBA with both surfaces having the same R,G,B,A fields */
2127 Blit4to4CopyAlpha(SDL_BlitInfo * info)
2129 int width = info->dst_w;
2130 int height = info->dst_h;
2131 Uint32 *src = (Uint32 *) info->src;
2132 int srcskip = info->src_skip;
2133 Uint32 *dst = (Uint32 *) info->dst;
2134 int dstskip = info->dst_skip;
2136 /* RGBA->RGBA, COPY_ALPHA */
2147 src = (Uint32 *) ((Uint8 *) src + srcskip);
2148 dst = (Uint32 *) ((Uint8 *) dst + dstskip);
2153 BlitNtoN(SDL_BlitInfo * info)
2155 int width = info->dst_w;
2156 int height = info->dst_h;
2157 Uint8 *src = info->src;
2158 int srcskip = info->src_skip;
2159 Uint8 *dst = info->dst;
2160 int dstskip = info->dst_skip;
2161 SDL_PixelFormat *srcfmt = info->src_fmt;
2162 int srcbpp = srcfmt->BytesPerPixel;
2163 SDL_PixelFormat *dstfmt = info->dst_fmt;
2164 int dstbpp = dstfmt->BytesPerPixel;
2165 unsigned alpha = dstfmt->Amask ? info->a : 0;
2175 DISEMBLE_RGB(src, srcbpp, srcfmt, Pixel, sR, sG, sB);
2176 ASSEMBLE_RGBA(dst, dstbpp, dstfmt, sR, sG, sB, alpha);
2188 BlitNtoNCopyAlpha(SDL_BlitInfo * info)
2190 int width = info->dst_w;
2191 int height = info->dst_h;
2192 Uint8 *src = info->src;
2193 int srcskip = info->src_skip;
2194 Uint8 *dst = info->dst;
2195 int dstskip = info->dst_skip;
2196 SDL_PixelFormat *srcfmt = info->src_fmt;
2197 int srcbpp = srcfmt->BytesPerPixel;
2198 SDL_PixelFormat *dstfmt = info->dst_fmt;
2199 int dstbpp = dstfmt->BytesPerPixel;
2203 for (c = width; c; --c) {
2205 unsigned sR, sG, sB, sA;
2206 DISEMBLE_RGBA(src, srcbpp, srcfmt, Pixel, sR, sG, sB, sA);
2207 ASSEMBLE_RGBA(dst, dstbpp, dstfmt, sR, sG, sB, sA);
2217 BlitNto1Key(SDL_BlitInfo * info)
2219 int width = info->dst_w;
2220 int height = info->dst_h;
2221 Uint8 *src = info->src;
2222 int srcskip = info->src_skip;
2223 Uint8 *dst = info->dst;
2224 int dstskip = info->dst_skip;
2225 SDL_PixelFormat *srcfmt = info->src_fmt;
2226 const Uint8 *palmap = info->table;
2227 Uint32 ckey = info->colorkey;
2228 Uint32 rgbmask = ~srcfmt->Amask;
2231 unsigned sR, sG, sB;
2233 /* Set up some basic variables */
2234 srcbpp = srcfmt->BytesPerPixel;
2237 if (palmap == NULL) {
2242 DISEMBLE_RGB(src, srcbpp, srcfmt, Pixel,
2244 if ( (Pixel & rgbmask) != ckey ) {
2245 /* Pack RGB into 8bit pixel */
2246 *dst = (Uint8)(((sR>>5)<<(3+2))|
2263 DISEMBLE_RGB(src, srcbpp, srcfmt, Pixel,
2265 if ( (Pixel & rgbmask) != ckey ) {
2266 /* Pack RGB into 8bit pixel */
2267 *dst = (Uint8)palmap[((sR>>5)<<(3+2))|
2283 Blit2to2Key(SDL_BlitInfo * info)
2285 int width = info->dst_w;
2286 int height = info->dst_h;
2287 Uint16 *srcp = (Uint16 *) info->src;
2288 int srcskip = info->src_skip;
2289 Uint16 *dstp = (Uint16 *) info->dst;
2290 int dstskip = info->dst_skip;
2291 Uint32 ckey = info->colorkey;
2292 Uint32 rgbmask = ~info->src_fmt->Amask;
2294 /* Set up some basic variables */
2303 if ( (*srcp & rgbmask) != ckey ) {
2317 BlitNtoNKey(SDL_BlitInfo * info)
2319 int width = info->dst_w;
2320 int height = info->dst_h;
2321 Uint8 *src = info->src;
2322 int srcskip = info->src_skip;
2323 Uint8 *dst = info->dst;
2324 int dstskip = info->dst_skip;
2325 Uint32 ckey = info->colorkey;
2326 SDL_PixelFormat *srcfmt = info->src_fmt;
2327 SDL_PixelFormat *dstfmt = info->dst_fmt;
2328 int srcbpp = srcfmt->BytesPerPixel;
2329 int dstbpp = dstfmt->BytesPerPixel;
2330 unsigned alpha = dstfmt->Amask ? info->a : 0;
2331 Uint32 rgbmask = ~srcfmt->Amask;
2333 /* Set up some basic variables */
2344 RETRIEVE_RGB_PIXEL(src, srcbpp, Pixel);
2345 if ( (Pixel & rgbmask) != ckey ) {
2346 RGB_FROM_PIXEL(Pixel, srcfmt, sR, sG, sB);
2347 ASSEMBLE_RGBA(dst, dstbpp, dstfmt, sR, sG, sB, alpha);
2360 BlitNtoNKeyCopyAlpha(SDL_BlitInfo * info)
2362 int width = info->dst_w;
2363 int height = info->dst_h;
2364 Uint8 *src = info->src;
2365 int srcskip = info->src_skip;
2366 Uint8 *dst = info->dst;
2367 int dstskip = info->dst_skip;
2368 Uint32 ckey = info->colorkey;
2369 SDL_PixelFormat *srcfmt = info->src_fmt;
2370 SDL_PixelFormat *dstfmt = info->dst_fmt;
2371 Uint32 rgbmask = ~srcfmt->Amask;
2376 unsigned sR, sG, sB, sA;
2378 /* Set up some basic variables */
2379 srcbpp = srcfmt->BytesPerPixel;
2380 dstbpp = dstfmt->BytesPerPixel;
2387 DISEMBLE_RGBA(src, srcbpp, srcfmt, Pixel, sR, sG, sB, sA);
2388 if ( (Pixel & rgbmask) != ckey ) {
2389 ASSEMBLE_RGBA(dst, dstbpp, dstfmt, sR, sG, sB, sA);
2401 /* Special optimized blit for ARGB 2-10-10-10 --> RGBA */
2403 Blit2101010toN(SDL_BlitInfo * info)
2405 int width = info->dst_w;
2406 int height = info->dst_h;
2407 Uint8 *src = info->src;
2408 int srcskip = info->src_skip;
2409 Uint8 *dst = info->dst;
2410 int dstskip = info->dst_skip;
2411 SDL_PixelFormat *dstfmt = info->dst_fmt;
2412 int dstbpp = dstfmt->BytesPerPixel;
2414 unsigned sR, sG, sB, sA;
2420 Pixel = *(Uint32 *)src;
2421 RGBA_FROM_ARGB2101010(Pixel, sR, sG, sB, sA);
2422 ASSEMBLE_RGBA(dst, dstbpp, dstfmt, sR, sG, sB, sA);
2433 /* Special optimized blit for RGBA --> ARGB 2-10-10-10 */
2435 BlitNto2101010(SDL_BlitInfo * info)
2437 int width = info->dst_w;
2438 int height = info->dst_h;
2439 Uint8 *src = info->src;
2440 int srcskip = info->src_skip;
2441 Uint8 *dst = info->dst;
2442 int dstskip = info->dst_skip;
2443 SDL_PixelFormat *srcfmt = info->src_fmt;
2444 int srcbpp = srcfmt->BytesPerPixel;
2446 unsigned sR, sG, sB, sA;
2452 DISEMBLE_RGBA(src, srcbpp, srcfmt, Pixel, sR, sG, sB, sA);
2453 ARGB2101010_FROM_RGBA(Pixel, sR, sG, sB, sA);
2454 *(Uint32 *)dst = Pixel;
2465 /* Normal N to N optimized blitters */
2468 #define COPY_ALPHA 4
2471 Uint32 srcR, srcG, srcB;
2473 Uint32 dstR, dstG, dstB;
2474 Uint32 blit_features;
2475 SDL_BlitFunc blitfunc;
2476 Uint32 alpha; /* bitwise NO_ALPHA, SET_ALPHA, COPY_ALPHA */
2478 static const struct blit_table normal_blit_1[] = {
2479 /* Default for 8-bit RGB source, never optimized */
2480 {0, 0, 0, 0, 0, 0, 0, 0, BlitNtoN, 0}
2483 static const struct blit_table normal_blit_2[] = {
2484 #if SDL_ALTIVEC_BLITTERS
2486 {0x0000F800, 0x000007E0, 0x0000001F, 4, 0x00000000, 0x00000000, 0x00000000,
2487 2, Blit_RGB565_32Altivec, NO_ALPHA | COPY_ALPHA | SET_ALPHA},
2488 {0x00007C00, 0x000003E0, 0x0000001F, 4, 0x00000000, 0x00000000, 0x00000000,
2489 2, Blit_RGB555_32Altivec, NO_ALPHA | COPY_ALPHA | SET_ALPHA},
2491 {0x0000F800, 0x000007E0, 0x0000001F, 4, 0x00FF0000, 0x0000FF00, 0x000000FF,
2492 0, Blit_RGB565_ARGB8888, NO_ALPHA | COPY_ALPHA | SET_ALPHA},
2493 {0x0000F800, 0x000007E0, 0x0000001F, 4, 0x000000FF, 0x0000FF00, 0x00FF0000,
2494 0, Blit_RGB565_ABGR8888, NO_ALPHA | COPY_ALPHA | SET_ALPHA},
2495 {0x0000F800, 0x000007E0, 0x0000001F, 4, 0xFF000000, 0x00FF0000, 0x0000FF00,
2496 0, Blit_RGB565_RGBA8888, NO_ALPHA | COPY_ALPHA | SET_ALPHA},
2497 {0x0000F800, 0x000007E0, 0x0000001F, 4, 0x0000FF00, 0x00FF0000, 0xFF000000,
2498 0, Blit_RGB565_BGRA8888, NO_ALPHA | COPY_ALPHA | SET_ALPHA},
2500 /* Default for 16-bit RGB source, used if no other blitter matches */
2501 {0, 0, 0, 0, 0, 0, 0, 0, BlitNtoN, 0}
2504 static const struct blit_table normal_blit_3[] = {
2505 /* Default for 24-bit RGB source, never optimized */
2506 {0, 0, 0, 0, 0, 0, 0, 0, BlitNtoN, 0}
2509 static const struct blit_table normal_blit_4[] = {
2510 #if SDL_ALTIVEC_BLITTERS
2511 /* has-altivec | dont-use-prefetch */
2512 {0x00000000, 0x00000000, 0x00000000, 4, 0x00000000, 0x00000000, 0x00000000,
2513 6, ConvertAltivec32to32_noprefetch, NO_ALPHA | COPY_ALPHA | SET_ALPHA},
2515 {0x00000000, 0x00000000, 0x00000000, 4, 0x00000000, 0x00000000, 0x00000000,
2516 2, ConvertAltivec32to32_prefetch, NO_ALPHA | COPY_ALPHA | SET_ALPHA},
2518 {0x00000000, 0x00000000, 0x00000000, 2, 0x0000F800, 0x000007E0, 0x0000001F,
2519 2, Blit_RGB888_RGB565Altivec, NO_ALPHA},
2521 {0x00FF0000, 0x0000FF00, 0x000000FF, 2, 0x0000F800, 0x000007E0, 0x0000001F,
2522 0, Blit_RGB888_RGB565, NO_ALPHA},
2523 {0x00FF0000, 0x0000FF00, 0x000000FF, 2, 0x00007C00, 0x000003E0, 0x0000001F,
2524 0, Blit_RGB888_RGB555, NO_ALPHA},
2525 /* Default for 32-bit RGB source, used if no other blitter matches */
2526 {0, 0, 0, 0, 0, 0, 0, 0, BlitNtoN, 0}
2529 static const struct blit_table *const normal_blit[] = {
2530 normal_blit_1, normal_blit_2, normal_blit_3, normal_blit_4
2533 /* Mask matches table, or table entry is zero */
2534 #define MASKOK(x, y) (((x) == (y)) || ((y) == 0x00000000))
2537 SDL_CalculateBlitN(SDL_Surface * surface)
2539 SDL_PixelFormat *srcfmt;
2540 SDL_PixelFormat *dstfmt;
2541 const struct blit_table *table;
2543 SDL_BlitFunc blitfun;
2545 /* Set up data for choosing the blit */
2546 srcfmt = surface->format;
2547 dstfmt = surface->map->dst->format;
2549 /* We don't support destinations less than 8-bits */
2550 if (dstfmt->BitsPerPixel < 8) {
2554 switch (surface->map->info.flags & ~SDL_COPY_RLE_MASK) {
2557 if (dstfmt->BitsPerPixel == 8) {
2558 if ((srcfmt->BytesPerPixel == 4) &&
2559 (srcfmt->Rmask == 0x00FF0000) &&
2560 (srcfmt->Gmask == 0x0000FF00) &&
2561 (srcfmt->Bmask == 0x000000FF)) {
2562 blitfun = Blit_RGB888_index8;
2563 } else if ((srcfmt->BytesPerPixel == 4) &&
2564 (srcfmt->Rmask == 0x3FF00000) &&
2565 (srcfmt->Gmask == 0x000FFC00) &&
2566 (srcfmt->Bmask == 0x000003FF)) {
2567 blitfun = Blit_RGB101010_index8;
2572 /* Now the meat, choose the blitter we want */
2573 int a_need = NO_ALPHA;
2575 a_need = srcfmt->Amask ? COPY_ALPHA : SET_ALPHA;
2576 table = normal_blit[srcfmt->BytesPerPixel - 1];
2577 for (which = 0; table[which].dstbpp; ++which) {
2578 if (MASKOK(srcfmt->Rmask, table[which].srcR) &&
2579 MASKOK(srcfmt->Gmask, table[which].srcG) &&
2580 MASKOK(srcfmt->Bmask, table[which].srcB) &&
2581 MASKOK(dstfmt->Rmask, table[which].dstR) &&
2582 MASKOK(dstfmt->Gmask, table[which].dstG) &&
2583 MASKOK(dstfmt->Bmask, table[which].dstB) &&
2584 dstfmt->BytesPerPixel == table[which].dstbpp &&
2585 (a_need & table[which].alpha) == a_need &&
2586 ((table[which].blit_features & GetBlitFeatures()) ==
2587 table[which].blit_features))
2590 blitfun = table[which].blitfunc;
2592 if (blitfun == BlitNtoN) { /* default C fallback catch-all. Slow! */
2593 if (srcfmt->format == SDL_PIXELFORMAT_ARGB2101010) {
2594 blitfun = Blit2101010toN;
2595 } else if (dstfmt->format == SDL_PIXELFORMAT_ARGB2101010) {
2596 blitfun = BlitNto2101010;
2597 } else if (srcfmt->BytesPerPixel == 4 &&
2598 dstfmt->BytesPerPixel == 4 &&
2599 srcfmt->Rmask == dstfmt->Rmask &&
2600 srcfmt->Gmask == dstfmt->Gmask &&
2601 srcfmt->Bmask == dstfmt->Bmask) {
2602 if (a_need == COPY_ALPHA) {
2603 if (srcfmt->Amask == dstfmt->Amask) {
2604 /* Fastpath C fallback: 32bit RGBA<->RGBA blit with matching RGBA */
2605 blitfun = Blit4to4CopyAlpha;
2607 blitfun = BlitNtoNCopyAlpha;
2610 /* Fastpath C fallback: 32bit RGB<->RGBA blit with matching RGB */
2611 blitfun = Blit4to4MaskAlpha;
2613 } else if (a_need == COPY_ALPHA) {
2614 blitfun = BlitNtoNCopyAlpha;
2620 case SDL_COPY_COLORKEY:
2621 /* colorkey blit: Here we don't have too many options, mostly
2622 because RLE is the preferred fast way to deal with this.
2623 If a particular case turns out to be useful we'll add it. */
2625 if (srcfmt->BytesPerPixel == 2 && surface->map->identity)
2627 else if (dstfmt->BytesPerPixel == 1)
2630 #if SDL_ALTIVEC_BLITTERS
2631 if ((srcfmt->BytesPerPixel == 4) && (dstfmt->BytesPerPixel == 4)
2632 && SDL_HasAltiVec()) {
2633 return Blit32to32KeyAltivec;
2636 if (srcfmt->Amask && dstfmt->Amask) {
2637 return BlitNtoNKeyCopyAlpha;
2647 /* vi: set ts=4 sw=4 expandtab: */