zenilib: zenilib/jni/external/sdl/src/video/SDL_blit_N.c Source File

zenilib 0.5.3.0

- Main Page
- Modules
- Namespaces
- Classes
- Files

- File List
- File Members

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Groups Pages
SDL_blit_N.c
Go to the documentation of this file.
1 /*
2 Simple DirectMedia Layer
3 Copyright (C) 1997-2013 Sam Lantinga <slouken@libsdl.org>
4
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.
8
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:
12
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.
20 */
21 #include "SDL_config.h"
22
23 #include "SDL_video.h"
24 #include "SDL_endian.h"
25 #include "SDL_cpuinfo.h"
26 #include "SDL_blit.h"
27
28 #include "SDL_assert.h"
29
30 /* Functions to blit from N-bit surfaces to other surfaces */
31
32 #if SDL_ALTIVEC_BLITTERS
33 #ifdef HAVE_ALTIVEC_H
34 #include <altivec.h>
35 #endif
36 #ifdef __MACOSX__
37 #include <sys/sysctl.h>
38 static size_t
39 GetL3CacheSize(void)
40 {
41 const char key[] = "hw.l3cachesize";
42 u_int64_t result = 0;
43 size_t typeSize = sizeof(result);
44
45
46 int err = sysctlbyname(key, &result, &typeSize, NULL, 0);
47 if (0 != err)
48 return 0;
49
50 return result;
51 }
52 #else
53 static size_t
54 GetL3CacheSize(void)
55 {
56 /* XXX: Just guess G4 */
57 return 2097152;
58 }
59 #endif /* __MACOSX__ */
60
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 )
66 #else
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 }
71 #endif
72
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 )
79
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) )
85
86 /*
87 * Data Stream Touch...Altivec cache prefetching.
88 *
89 * Don't use this on a G5...however, the speed boost is very significant
90 * on a G4.
91 */
92 #define DST_CHAN_SRC 1
93 #define DST_CHAN_DEST 2
94
95 /* macro to set DST control word value... */
96 #define DST_CTRL(size, count, stride) \
97 (((size) << 24) | ((count) << 16) | (stride))
98
99 #define VEC_ALIGNER(src) ((UNALIGNED_PTR(src)) \
100 ? vec_lvsl(0, src) \
101 : vec_add(vec_lvsl(8, src), vec_splat_u8(8)))
102
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)
106 {
107 /*
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.
111 */
112 /* ARGB */
113 const static const struct SDL_PixelFormat default_pixel_format = {
114 0, NULL, 0, 0,
115 {0, 0},
116 0x00FF0000, 0x0000FF00, 0x000000FF, 0xFF000000,
117 0, 0, 0, 0,
118 16, 8, 0, 24,
119 0, NULL
120 };
121 if (!srcfmt) {
122 srcfmt = &default_pixel_format;
123 }
124 if (!dstfmt) {
125 dstfmt = &default_pixel_format;
126 }
127 const vector unsigned char plus = VECUINT8_LITERAL(0x00, 0x00, 0x00, 0x00,
128 0x04, 0x04, 0x04, 0x04,
129 0x08, 0x08, 0x08, 0x08,
130 0x0C, 0x0C, 0x0C,
131 0x0C);
132 vector unsigned char vswiz;
133 vector unsigned int srcvec;
134 #define RESHIFT(X) (3 - ((X) >> 3))
135 Uint32 rmask = RESHIFT(srcfmt->Rshift) << (dstfmt->Rshift);
136 Uint32 gmask = RESHIFT(srcfmt->Gshift) << (dstfmt->Gshift);
137 Uint32 bmask = RESHIFT(srcfmt->Bshift) << (dstfmt->Bshift);
138 Uint32 amask;
139 /* Use zero for alpha if either surface doesn't have alpha */
140 if (dstfmt->Amask) {
141 amask =
142 ((srcfmt->Amask) ? RESHIFT(srcfmt->
143 Ashift) : 0x10) << (dstfmt->Ashift);
144 } else {
145 amask =
146 0x10101010 & ((dstfmt->Rmask | dstfmt->Gmask | dstfmt->Bmask) ^
147 0xFFFFFFFF);
148 }
149 #undef RESHIFT
150 ((unsigned int *) (char *) &srcvec)[0] = (rmask | gmask | bmask | amask);
151 vswiz = vec_add(plus, (vector unsigned char) vec_splat(srcvec, 0));
152 return (vswiz);
153 }
154
155 static void Blit_RGB888_RGB565(SDL_BlitInfo * info);
156 static void
157 Blit_RGB888_RGB565Altivec(SDL_BlitInfo * info)
158 {
159 int height = info->dst_h;
160 Uint8 *src = (Uint8 *) info->src;
161 int srcskip = info->src_skip;
162 Uint8 *dst = (Uint8 *) info->dst;
163 int dstskip = info->dst_skip;
164 SDL_PixelFormat *srcfmt = info->src_fmt;
165 vector unsigned char valpha = vec_splat_u8(0);
166 vector unsigned char vpermute = calc_swizzle32(srcfmt, NULL);
167 vector unsigned char vgmerge = VECUINT8_LITERAL(0x00, 0x02, 0x00, 0x06,
168 0x00, 0x0a, 0x00, 0x0e,
169 0x00, 0x12, 0x00, 0x16,
170 0x00, 0x1a, 0x00, 0x1e);
171 vector unsigned short v1 = vec_splat_u16(1);
172 vector unsigned short v3 = vec_splat_u16(3);
173 vector unsigned short v3f =
174 VECUINT16_LITERAL(0x003f, 0x003f, 0x003f, 0x003f,
175 0x003f, 0x003f, 0x003f, 0x003f);
176 vector unsigned short vfc =
177 VECUINT16_LITERAL(0x00fc, 0x00fc, 0x00fc, 0x00fc,
178 0x00fc, 0x00fc, 0x00fc, 0x00fc);
179 vector unsigned short vf800 = (vector unsigned short) vec_splat_u8(-7);
180 vf800 = vec_sl(vf800, vec_splat_u16(8));
181
182 while (height--) {
183 vector unsigned char valigner;
184 vector unsigned char voverflow;
185 vector unsigned char vsrc;
186
187 int width = info->dst_w;
188 int extrawidth;
189
190 /* do scalar until we can align... */
191 #define ONE_PIXEL_BLEND(condition, widthvar) \
192 while (condition) { \
193 Uint32 Pixel; \
194 unsigned sR, sG, sB, sA; \
195 DISEMBLE_RGBA((Uint8 *)src, 4, srcfmt, Pixel, \
196 sR, sG, sB, sA); \
197 *(Uint16 *)(dst) = (((sR << 8) & 0x0000F800) | \
198 ((sG << 3) & 0x000007E0) | \
199 ((sB >> 3) & 0x0000001F)); \
200 dst += 2; \
201 src += 4; \
202 widthvar--; \
203 }
204
205 ONE_PIXEL_BLEND(((UNALIGNED_PTR(dst)) && (width)), width);
206
207 /* After all that work, here's the vector part! */
208 extrawidth = (width % 8); /* trailing unaligned stores */
209 width -= extrawidth;
210 vsrc = vec_ld(0, src);
211 valigner = VEC_ALIGNER(src);
212
213 while (width) {
214 vector unsigned short vpixel, vrpixel, vgpixel, vbpixel;
215 vector unsigned int vsrc1, vsrc2;
216 vector unsigned char vdst;
217
218 voverflow = vec_ld(15, src);
219 vsrc = vec_perm(vsrc, voverflow, valigner);
220 vsrc1 = (vector unsigned int) vec_perm(vsrc, valpha, vpermute);
221 src += 16;
222 vsrc = voverflow;
223 voverflow = vec_ld(15, src);
224 vsrc = vec_perm(vsrc, voverflow, valigner);
225 vsrc2 = (vector unsigned int) vec_perm(vsrc, valpha, vpermute);
226 /* 1555 */
227 vpixel = (vector unsigned short) vec_packpx(vsrc1, vsrc2);
228 vgpixel = (vector unsigned short) vec_perm(vsrc1, vsrc2, vgmerge);
229 vgpixel = vec_and(vgpixel, vfc);
230 vgpixel = vec_sl(vgpixel, v3);
231 vrpixel = vec_sl(vpixel, v1);
232 vrpixel = vec_and(vrpixel, vf800);
233 vbpixel = vec_and(vpixel, v3f);
234 vdst =
235 vec_or((vector unsigned char) vrpixel,
236 (vector unsigned char) vgpixel);
237 /* 565 */
238 vdst = vec_or(vdst, (vector unsigned char) vbpixel);
239 vec_st(vdst, 0, dst);
240
241 width -= 8;
242 src += 16;
243 dst += 16;
244 vsrc = voverflow;
245 }
246
247 SDL_assert(width == 0);
248
249 /* do scalar until we can align... */
250 ONE_PIXEL_BLEND((extrawidth), extrawidth);
251 #undef ONE_PIXEL_BLEND
252
253 src += srcskip; /* move to next row, accounting for pitch. */
254 dst += dstskip;
255 }
256
257
258 }
259
260 static void
261 Blit_RGB565_32Altivec(SDL_BlitInfo * info)
262 {
263 int height = info->dst_h;
264 Uint8 *src = (Uint8 *) info->src;
265 int srcskip = info->src_skip;
266 Uint8 *dst = (Uint8 *) info->dst;
267 int dstskip = info->dst_skip;
268 SDL_PixelFormat *srcfmt = info->src_fmt;
269 SDL_PixelFormat *dstfmt = info->dst_fmt;
270 unsigned alpha;
271 vector unsigned char valpha;
272 vector unsigned char vpermute;
273 vector unsigned short vf800;
274 vector unsigned int v8 = vec_splat_u32(8);
275 vector unsigned int v16 = vec_add(v8, v8);
276 vector unsigned short v2 = vec_splat_u16(2);
277 vector unsigned short v3 = vec_splat_u16(3);
278 /*
279 0x10 - 0x1f is the alpha
280 0x00 - 0x0e evens are the red
281 0x01 - 0x0f odds are zero
282 */
283 vector unsigned char vredalpha1 = VECUINT8_LITERAL(0x10, 0x00, 0x01, 0x01,
284 0x10, 0x02, 0x01, 0x01,
285 0x10, 0x04, 0x01, 0x01,
286 0x10, 0x06, 0x01,
287 0x01);
288 vector unsigned char vredalpha2 =
289 (vector unsigned
290 char) (vec_add((vector unsigned int) vredalpha1, vec_sl(v8, v16))
291 );
292 /*
293 0x00 - 0x0f is ARxx ARxx ARxx ARxx
294 0x11 - 0x0f odds are blue
295 */
296 vector unsigned char vblue1 = VECUINT8_LITERAL(0x00, 0x01, 0x02, 0x11,
297 0x04, 0x05, 0x06, 0x13,
298 0x08, 0x09, 0x0a, 0x15,
299 0x0c, 0x0d, 0x0e, 0x17);
300 vector unsigned char vblue2 =
301 (vector unsigned char) (vec_add((vector unsigned int) vblue1, v8)
302 );
303 /*
304 0x00 - 0x0f is ARxB ARxB ARxB ARxB
305 0x10 - 0x0e evens are green
306 */
307 vector unsigned char vgreen1 = VECUINT8_LITERAL(0x00, 0x01, 0x10, 0x03,
308 0x04, 0x05, 0x12, 0x07,
309 0x08, 0x09, 0x14, 0x0b,
310 0x0c, 0x0d, 0x16, 0x0f);
311 vector unsigned char vgreen2 =
312 (vector unsigned
313 char) (vec_add((vector unsigned int) vgreen1, vec_sl(v8, v8))
314 );
315
316 SDL_assert(srcfmt->BytesPerPixel == 2);
317 SDL_assert(dstfmt->BytesPerPixel == 4);
318
319 vf800 = (vector unsigned short) vec_splat_u8(-7);
320 vf800 = vec_sl(vf800, vec_splat_u16(8));
321
322 if (dstfmt->Amask && info->a) {
323 ((unsigned char *) &valpha)[0] = alpha = info->a;
324 valpha = vec_splat(valpha, 0);
325 } else {
326 alpha = 0;
327 valpha = vec_splat_u8(0);
328 }
329
330 vpermute = calc_swizzle32(NULL, dstfmt);
331 while (height--) {
332 vector unsigned char valigner;
333 vector unsigned char voverflow;
334 vector unsigned char vsrc;
335
336 int width = info->dst_w;
337 int extrawidth;
338
339 /* do scalar until we can align... */
340 #define ONE_PIXEL_BLEND(condition, widthvar) \
341 while (condition) { \
342 unsigned sR, sG, sB; \
343 unsigned short Pixel = *((unsigned short *)src); \
344 sR = (Pixel >> 8) & 0xf8; \
345 sG = (Pixel >> 3) & 0xfc; \
346 sB = (Pixel << 3) & 0xf8; \
347 ASSEMBLE_RGBA(dst, 4, dstfmt, sR, sG, sB, alpha); \
348 src += 2; \
349 dst += 4; \
350 widthvar--; \
351 }
352 ONE_PIXEL_BLEND(((UNALIGNED_PTR(dst)) && (width)), width);
353
354 /* After all that work, here's the vector part! */
355 extrawidth = (width % 8); /* trailing unaligned stores */
356 width -= extrawidth;
357 vsrc = vec_ld(0, src);
358 valigner = VEC_ALIGNER(src);
359
360 while (width) {
361 vector unsigned short vR, vG, vB;
362 vector unsigned char vdst1, vdst2;
363
364 voverflow = vec_ld(15, src);
365 vsrc = vec_perm(vsrc, voverflow, valigner);
366
367 vR = vec_and((vector unsigned short) vsrc, vf800);
368 vB = vec_sl((vector unsigned short) vsrc, v3);
369 vG = vec_sl(vB, v2);
370
371 vdst1 =
372 (vector unsigned char) vec_perm((vector unsigned char) vR,
373 valpha, vredalpha1);
374 vdst1 = vec_perm(vdst1, (vector unsigned char) vB, vblue1);
375 vdst1 = vec_perm(vdst1, (vector unsigned char) vG, vgreen1);
376 vdst1 = vec_perm(vdst1, valpha, vpermute);
377 vec_st(vdst1, 0, dst);
378
379 vdst2 =
380 (vector unsigned char) vec_perm((vector unsigned char) vR,
381 valpha, vredalpha2);
382 vdst2 = vec_perm(vdst2, (vector unsigned char) vB, vblue2);
383 vdst2 = vec_perm(vdst2, (vector unsigned char) vG, vgreen2);
384 vdst2 = vec_perm(vdst2, valpha, vpermute);
385 vec_st(vdst2, 16, dst);
386
387 width -= 8;
388 dst += 32;
389 src += 16;
390 vsrc = voverflow;
391 }
392
393 SDL_assert(width == 0);
394
395
396 /* do scalar until we can align... */
397 ONE_PIXEL_BLEND((extrawidth), extrawidth);
398 #undef ONE_PIXEL_BLEND
399
400 src += srcskip; /* move to next row, accounting for pitch. */
401 dst += dstskip;
402 }
403
404 }
405
406
407 static void
408 Blit_RGB555_32Altivec(SDL_BlitInfo * info)
409 {
410 int height = info->dst_h;
411 Uint8 *src = (Uint8 *) info->src;
412 int srcskip = info->src_skip;
413 Uint8 *dst = (Uint8 *) info->dst;
414 int dstskip = info->dst_skip;
415 SDL_PixelFormat *srcfmt = info->src_fmt;
416 SDL_PixelFormat *dstfmt = info->dst_fmt;
417 unsigned alpha;
418 vector unsigned char valpha;
419 vector unsigned char vpermute;
420 vector unsigned short vf800;
421 vector unsigned int v8 = vec_splat_u32(8);
422 vector unsigned int v16 = vec_add(v8, v8);
423 vector unsigned short v1 = vec_splat_u16(1);
424 vector unsigned short v3 = vec_splat_u16(3);
425 /*
426 0x10 - 0x1f is the alpha
427 0x00 - 0x0e evens are the red
428 0x01 - 0x0f odds are zero
429 */
430 vector unsigned char vredalpha1 = VECUINT8_LITERAL(0x10, 0x00, 0x01, 0x01,
431 0x10, 0x02, 0x01, 0x01,
432 0x10, 0x04, 0x01, 0x01,
433 0x10, 0x06, 0x01,
434 0x01);
435 vector unsigned char vredalpha2 =
436 (vector unsigned
437 char) (vec_add((vector unsigned int) vredalpha1, vec_sl(v8, v16))
438 );
439 /*
440 0x00 - 0x0f is ARxx ARxx ARxx ARxx
441 0x11 - 0x0f odds are blue
442 */
443 vector unsigned char vblue1 = VECUINT8_LITERAL(0x00, 0x01, 0x02, 0x11,
444 0x04, 0x05, 0x06, 0x13,
445 0x08, 0x09, 0x0a, 0x15,
446 0x0c, 0x0d, 0x0e, 0x17);
447 vector unsigned char vblue2 =
448 (vector unsigned char) (vec_add((vector unsigned int) vblue1, v8)
449 );
450 /*
451 0x00 - 0x0f is ARxB ARxB ARxB ARxB
452 0x10 - 0x0e evens are green
453 */
454 vector unsigned char vgreen1 = VECUINT8_LITERAL(0x00, 0x01, 0x10, 0x03,
455 0x04, 0x05, 0x12, 0x07,
456 0x08, 0x09, 0x14, 0x0b,
457 0x0c, 0x0d, 0x16, 0x0f);
458 vector unsigned char vgreen2 =
459 (vector unsigned
460 char) (vec_add((vector unsigned int) vgreen1, vec_sl(v8, v8))
461 );
462
463 SDL_assert(srcfmt->BytesPerPixel == 2);
464 SDL_assert(dstfmt->BytesPerPixel == 4);
465
466 vf800 = (vector unsigned short) vec_splat_u8(-7);
467 vf800 = vec_sl(vf800, vec_splat_u16(8));
468
469 if (dstfmt->Amask && info->a) {
470 ((unsigned char *) &valpha)[0] = alpha = info->a;
471 valpha = vec_splat(valpha, 0);
472 } else {
473 alpha = 0;
474 valpha = vec_splat_u8(0);
475 }
476
477 vpermute = calc_swizzle32(NULL, dstfmt);
478 while (height--) {
479 vector unsigned char valigner;
480 vector unsigned char voverflow;
481 vector unsigned char vsrc;
482
483 int width = info->dst_w;
484 int extrawidth;
485
486 /* do scalar until we can align... */
487 #define ONE_PIXEL_BLEND(condition, widthvar) \
488 while (condition) { \
489 unsigned sR, sG, sB; \
490 unsigned short Pixel = *((unsigned short *)src); \
491 sR = (Pixel >> 7) & 0xf8; \
492 sG = (Pixel >> 2) & 0xf8; \
493 sB = (Pixel << 3) & 0xf8; \
494 ASSEMBLE_RGBA(dst, 4, dstfmt, sR, sG, sB, alpha); \
495 src += 2; \
496 dst += 4; \
497 widthvar--; \
498 }
499 ONE_PIXEL_BLEND(((UNALIGNED_PTR(dst)) && (width)), width);
500
501 /* After all that work, here's the vector part! */
502 extrawidth = (width % 8); /* trailing unaligned stores */
503 width -= extrawidth;
504 vsrc = vec_ld(0, src);
505 valigner = VEC_ALIGNER(src);
506
507 while (width) {
508 vector unsigned short vR, vG, vB;
509 vector unsigned char vdst1, vdst2;
510
511 voverflow = vec_ld(15, src);
512 vsrc = vec_perm(vsrc, voverflow, valigner);
513
514 vR = vec_and(vec_sl((vector unsigned short) vsrc, v1), vf800);
515 vB = vec_sl((vector unsigned short) vsrc, v3);
516 vG = vec_sl(vB, v3);
517
518 vdst1 =
519 (vector unsigned char) vec_perm((vector unsigned char) vR,
520 valpha, vredalpha1);
521 vdst1 = vec_perm(vdst1, (vector unsigned char) vB, vblue1);
522 vdst1 = vec_perm(vdst1, (vector unsigned char) vG, vgreen1);
523 vdst1 = vec_perm(vdst1, valpha, vpermute);
524 vec_st(vdst1, 0, dst);
525
526 vdst2 =
527 (vector unsigned char) vec_perm((vector unsigned char) vR,
528 valpha, vredalpha2);
529 vdst2 = vec_perm(vdst2, (vector unsigned char) vB, vblue2);
530 vdst2 = vec_perm(vdst2, (vector unsigned char) vG, vgreen2);
531 vdst2 = vec_perm(vdst2, valpha, vpermute);
532 vec_st(vdst2, 16, dst);
533
534 width -= 8;
535 dst += 32;
536 src += 16;
537 vsrc = voverflow;
538 }
539
540 SDL_assert(width == 0);
541
542
543 /* do scalar until we can align... */
544 ONE_PIXEL_BLEND((extrawidth), extrawidth);
545 #undef ONE_PIXEL_BLEND
546
547 src += srcskip; /* move to next row, accounting for pitch. */
548 dst += dstskip;
549 }
550
551 }
552
553 static void BlitNtoNKey(SDL_BlitInfo * info);
554 static void BlitNtoNKeyCopyAlpha(SDL_BlitInfo * info);
555 static void
556 Blit32to32KeyAltivec(SDL_BlitInfo * info)
557 {
558 int height = info->dst_h;
559 Uint32 *srcp = (Uint32 *) info->src;
560 int srcskip = info->src_skip / 4;
561 Uint32 *dstp = (Uint32 *) info->dst;
562 int dstskip = info->dst_skip / 4;
563 SDL_PixelFormat *srcfmt = info->src_fmt;
564 int srcbpp = srcfmt->BytesPerPixel;
565 SDL_PixelFormat *dstfmt = info->dst_fmt;
566 int dstbpp = dstfmt->BytesPerPixel;
567 int copy_alpha = (srcfmt->Amask && dstfmt->Amask);
568 unsigned alpha = dstfmt->Amask ? info->a : 0;
569 Uint32 rgbmask = srcfmt->Rmask | srcfmt->Gmask | srcfmt->Bmask;
570 Uint32 ckey = info->colorkey;
571 vector unsigned int valpha;
572 vector unsigned char vpermute;
573 vector unsigned char vzero;
574 vector unsigned int vckey;
575 vector unsigned int vrgbmask;
576 vpermute = calc_swizzle32(srcfmt, dstfmt);
577 if (info->dst_w < 16) {
578 if (copy_alpha) {
579 BlitNtoNKeyCopyAlpha(info);
580 } else {
581 BlitNtoNKey(info);
582 }
583 return;
584 }
585 vzero = vec_splat_u8(0);
586 if (alpha) {
587 ((unsigned char *) &valpha)[0] = (unsigned char) alpha;
588 valpha =
589 (vector unsigned int) vec_splat((vector unsigned char) valpha, 0);
590 } else {
591 valpha = (vector unsigned int) vzero;
592 }
593 ckey &= rgbmask;
594 ((unsigned int *) (char *) &vckey)[0] = ckey;
595 vckey = vec_splat(vckey, 0);
596 ((unsigned int *) (char *) &vrgbmask)[0] = rgbmask;
597 vrgbmask = vec_splat(vrgbmask, 0);
598
599 while (height--) {
600 #define ONE_PIXEL_BLEND(condition, widthvar) \
601 if (copy_alpha) { \
602 while (condition) { \
603 Uint32 Pixel; \
604 unsigned sR, sG, sB, sA; \
605 DISEMBLE_RGBA((Uint8 *)srcp, srcbpp, srcfmt, Pixel, \
606 sR, sG, sB, sA); \
607 if ( (Pixel & rgbmask) != ckey ) { \
608 ASSEMBLE_RGBA((Uint8 *)dstp, dstbpp, dstfmt, \
609 sR, sG, sB, sA); \
610 } \
611 dstp = (Uint32 *) (((Uint8 *) dstp) + dstbpp); \
612 srcp = (Uint32 *) (((Uint8 *) srcp) + srcbpp); \
613 widthvar--; \
614 } \
615 } else { \
616 while (condition) { \
617 Uint32 Pixel; \
618 unsigned sR, sG, sB; \
619 RETRIEVE_RGB_PIXEL((Uint8 *)srcp, srcbpp, Pixel); \
620 if ( Pixel != ckey ) { \
621 RGB_FROM_PIXEL(Pixel, srcfmt, sR, sG, sB); \
622 ASSEMBLE_RGBA((Uint8 *)dstp, dstbpp, dstfmt, \
623 sR, sG, sB, alpha); \
624 } \
625 dstp = (Uint32 *) (((Uint8 *)dstp) + dstbpp); \
626 srcp = (Uint32 *) (((Uint8 *)srcp) + srcbpp); \
627 widthvar--; \
628 } \
629 }
630 int width = info->dst_w;
631 ONE_PIXEL_BLEND((UNALIGNED_PTR(dstp)) && (width), width);
632 SDL_assert(width > 0);
633 if (width > 0) {
634 int extrawidth = (width % 4);
635 vector unsigned char valigner = VEC_ALIGNER(srcp);
636 vector unsigned int vs = vec_ld(0, srcp);
637 width -= extrawidth;
638 SDL_assert(width >= 4);
639 while (width) {
640 vector unsigned char vsel;
641 vector unsigned int vd;
642 vector unsigned int voverflow = vec_ld(15, srcp);
643 /* load the source vec */
644 vs = vec_perm(vs, voverflow, valigner);
645 /* vsel is set for items that match the key */
646 vsel = (vector unsigned char) vec_and(vs, vrgbmask);
647 vsel = (vector unsigned char) vec_cmpeq(vs, vckey);
648 /* permute the src vec to the dest format */
649 vs = vec_perm(vs, valpha, vpermute);
650 /* load the destination vec */
651 vd = vec_ld(0, dstp);
652 /* select the source and dest into vs */
653 vd = (vector unsigned int) vec_sel((vector unsigned char) vs,
654 (vector unsigned char) vd,
655 vsel);
656
657 vec_st(vd, 0, dstp);
658 srcp += 4;
659 width -= 4;
660 dstp += 4;
661 vs = voverflow;
662 }
663 ONE_PIXEL_BLEND((extrawidth), extrawidth);
664 #undef ONE_PIXEL_BLEND
665 srcp += srcskip;
666 dstp += dstskip;
667 }
668 }
669 }
670
671 /* Altivec code to swizzle one 32-bit surface to a different 32-bit format. */
672 /* Use this on a G5 */
673 static void
674 ConvertAltivec32to32_noprefetch(SDL_BlitInfo * info)
675 {
676 int height = info->dst_h;
677 Uint32 *src = (Uint32 *) info->src;
678 int srcskip = info->src_skip / 4;
679 Uint32 *dst = (Uint32 *) info->dst;
680 int dstskip = info->dst_skip / 4;
681 SDL_PixelFormat *srcfmt = info->src_fmt;
682 SDL_PixelFormat *dstfmt = info->dst_fmt;
683 vector unsigned int vzero = vec_splat_u32(0);
684 vector unsigned char vpermute = calc_swizzle32(srcfmt, dstfmt);
685 if (dstfmt->Amask && !srcfmt->Amask) {
686 if (info->a) {
687 vector unsigned char valpha;
688 ((unsigned char *) &valpha)[0] = info->a;
689 vzero = (vector unsigned int) vec_splat(valpha, 0);
690 }
691 }
692
693 SDL_assert(srcfmt->BytesPerPixel == 4);
694 SDL_assert(dstfmt->BytesPerPixel == 4);
695
696 while (height--) {
697 vector unsigned char valigner;
698 vector unsigned int vbits;
699 vector unsigned int voverflow;
700 Uint32 bits;
701 Uint8 r, g, b, a;
702
703 int width = info->dst_w;
704 int extrawidth;
705
706 /* do scalar until we can align... */
707 while ((UNALIGNED_PTR(dst)) && (width)) {
708 bits = *(src++);
709 RGBA_FROM_8888(bits, srcfmt, r, g, b, a);
710 if(!srcfmt->Amask)
711 a = info->a;
712 *(dst++) = MAKE8888(dstfmt, r, g, b, a);
713 width--;
714 }
715
716 /* After all that work, here's the vector part! */
717 extrawidth = (width % 4);
718 width -= extrawidth;
719 valigner = VEC_ALIGNER(src);
720 vbits = vec_ld(0, src);
721
722 while (width) {
723 voverflow = vec_ld(15, src);
724 src += 4;
725 width -= 4;
726 vbits = vec_perm(vbits, voverflow, valigner); /* src is ready. */
727 vbits = vec_perm(vbits, vzero, vpermute); /* swizzle it. */
728 vec_st(vbits, 0, dst); /* store it back out. */
729 dst += 4;
730 vbits = voverflow;
731 }
732
733 SDL_assert(width == 0);
734
735 /* cover pixels at the end of the row that didn't fit in 16 bytes. */
736 while (extrawidth) {
737 bits = *(src++); /* max 7 pixels, don't bother with prefetch. */
738 RGBA_FROM_8888(bits, srcfmt, r, g, b, a);
739 if(!srcfmt->Amask)
740 a = info->a;
741 *(dst++) = MAKE8888(dstfmt, r, g, b, a);
742 extrawidth--;
743 }
744
745 src += srcskip;
746 dst += dstskip;
747 }
748
749 }
750
751 /* Altivec code to swizzle one 32-bit surface to a different 32-bit format. */
752 /* Use this on a G4 */
753 static void
754 ConvertAltivec32to32_prefetch(SDL_BlitInfo * info)
755 {
756 const int scalar_dst_lead = sizeof(Uint32) * 4;
757 const int vector_dst_lead = sizeof(Uint32) * 16;
758
759 int height = info->dst_h;
760 Uint32 *src = (Uint32 *) info->src;
761 int srcskip = info->src_skip / 4;
762 Uint32 *dst = (Uint32 *) info->dst;
763 int dstskip = info->dst_skip / 4;
764 SDL_PixelFormat *srcfmt = info->src_fmt;
765 SDL_PixelFormat *dstfmt = info->dst_fmt;
766 vector unsigned int vzero = vec_splat_u32(0);
767 vector unsigned char vpermute = calc_swizzle32(srcfmt, dstfmt);
768 if (dstfmt->Amask && !srcfmt->Amask) {
769 if (info->a) {
770 vector unsigned char valpha;
771 ((unsigned char *) &valpha)[0] = info->a;
772 vzero = (vector unsigned int) vec_splat(valpha, 0);
773 }
774 }
775
776 SDL_assert(srcfmt->BytesPerPixel == 4);
777 SDL_assert(dstfmt->BytesPerPixel == 4);
778
779 while (height--) {
780 vector unsigned char valigner;
781 vector unsigned int vbits;
782 vector unsigned int voverflow;
783 Uint32 bits;
784 Uint8 r, g, b, a;
785
786 int width = info->dst_w;
787 int extrawidth;
788
789 /* do scalar until we can align... */
790 while ((UNALIGNED_PTR(dst)) && (width)) {
791 vec_dstt(src + scalar_dst_lead, DST_CTRL(2, 32, 1024),
792 DST_CHAN_SRC);
793 vec_dstst(dst + scalar_dst_lead, DST_CTRL(2, 32, 1024),
794 DST_CHAN_DEST);
795 bits = *(src++);
796 RGBA_FROM_8888(bits, srcfmt, r, g, b, a);
797 if(!srcfmt->Amask)
798 a = info->a;
799 *(dst++) = MAKE8888(dstfmt, r, g, b, a);
800 width--;
801 }
802
803 /* After all that work, here's the vector part! */
804 extrawidth = (width % 4);
805 width -= extrawidth;
806 valigner = VEC_ALIGNER(src);
807 vbits = vec_ld(0, src);
808
809 while (width) {
810 vec_dstt(src + vector_dst_lead, DST_CTRL(2, 32, 1024),
811 DST_CHAN_SRC);
812 vec_dstst(dst + vector_dst_lead, DST_CTRL(2, 32, 1024),
813 DST_CHAN_DEST);
814 voverflow = vec_ld(15, src);
815 src += 4;
816 width -= 4;
817 vbits = vec_perm(vbits, voverflow, valigner); /* src is ready. */
818 vbits = vec_perm(vbits, vzero, vpermute); /* swizzle it. */
819 vec_st(vbits, 0, dst); /* store it back out. */
820 dst += 4;
821 vbits = voverflow;
822 }
823
824 SDL_assert(width == 0);
825
826 /* cover pixels at the end of the row that didn't fit in 16 bytes. */
827 while (extrawidth) {
828 bits = *(src++); /* max 7 pixels, don't bother with prefetch. */
829 RGBA_FROM_8888(bits, srcfmt, r, g, b, a);
830 if(!srcfmt->Amask)
831 a = info->a;
832 *(dst++) = MAKE8888(dstfmt, r, g, b, a);
833 extrawidth--;
834 }
835
836 src += srcskip;
837 dst += dstskip;
838 }
839
840 vec_dss(DST_CHAN_SRC);
841 vec_dss(DST_CHAN_DEST);
842 }
843
844 static Uint32
845 GetBlitFeatures(void)
846 {
847 static Uint32 features = 0xffffffff;
848 if (features == 0xffffffff) {
849 /* Provide an override for testing .. */
850 char *override = SDL_getenv("SDL_ALTIVEC_BLIT_FEATURES");
851 if (override) {
852 features = 0;
853 SDL_sscanf(override, "%u", &features);
854 } else {
855 features = (0
856 /* Feature 1 is has-MMX */
857 | ((SDL_HasMMX())? 1 : 0)
858 /* Feature 2 is has-AltiVec */
859 | ((SDL_HasAltiVec())? 2 : 0)
860 /* Feature 4 is dont-use-prefetch */
861 /* !!!! FIXME: Check for G5 or later, not the cache size! Always prefetch on a G4. */
862 | ((GetL3CacheSize() == 0) ? 4 : 0)
863 );
864 }
865 }
866 return features;
867 }
868
869 #if __MWERKS__
870 #pragma altivec_model off
871 #endif
872 #else
873 /* Feature 1 is has-MMX */
874 #define GetBlitFeatures() ((Uint32)(SDL_HasMMX() ? 1 : 0))
875 #endif
876
877 /* This is now endian dependent */
878 #if SDL_BYTEORDER == SDL_LIL_ENDIAN
879 #define HI 1
880 #define LO 0
881 #else /* SDL_BYTEORDER == SDL_BIG_ENDIAN */
882 #define HI 0
883 #define LO 1
884 #endif
885
886 /* Special optimized blit for RGB 8-8-8 --> RGB 3-3-2 */
887 #define RGB888_RGB332(dst, src) { \
888 dst = (Uint8)((((src)&0x00E00000)>>16)| \
889 (((src)&0x0000E000)>>11)| \
890 (((src)&0x000000C0)>>6)); \
891 }
892 static void
893 Blit_RGB888_index8(SDL_BlitInfo * info)
894 {
895 #ifndef USE_DUFFS_LOOP
896 int c;
897 #endif
898 int width, height;
899 Uint32 *src;
900 const Uint8 *map;
901 Uint8 *dst;
902 int srcskip, dstskip;
903
904 /* Set up some basic variables */
905 width = info->dst_w;
906 height = info->dst_h;
907 src = (Uint32 *) info->src;
908 srcskip = info->src_skip / 4;
909 dst = info->dst;
910 dstskip = info->dst_skip;
911 map = info->table;
912
913 if (map == NULL) {
914 while (height--) {
915 #ifdef USE_DUFFS_LOOP
916 /* *INDENT-OFF* */
917 DUFFS_LOOP(
918 RGB888_RGB332(*dst++, *src);
919 , width);
920 /* *INDENT-ON* */
921 #else
922 for (c = width / 4; c; --c) {
923 /* Pack RGB into 8bit pixel */
924 ++src;
925 RGB888_RGB332(*dst++, *src);
926 ++src;
927 RGB888_RGB332(*dst++, *src);
928 ++src;
929 RGB888_RGB332(*dst++, *src);
930 ++src;
931 }
932 switch (width & 3) {
933 case 3:
934 RGB888_RGB332(*dst++, *src);
935 ++src;
936 case 2:
937 RGB888_RGB332(*dst++, *src);
938 ++src;
939 case 1:
940 RGB888_RGB332(*dst++, *src);
941 ++src;
942 }
943 #endif /* USE_DUFFS_LOOP */
944 src += srcskip;
945 dst += dstskip;
946 }
947 } else {
948 int Pixel;
949
950 while (height--) {
951 #ifdef USE_DUFFS_LOOP
952 /* *INDENT-OFF* */
953 DUFFS_LOOP(
954 RGB888_RGB332(Pixel, *src);
955 *dst++ = map[Pixel];
956 ++src;
957 , width);
958 /* *INDENT-ON* */
959 #else
960 for (c = width / 4; c; --c) {
961 /* Pack RGB into 8bit pixel */
962 RGB888_RGB332(Pixel, *src);
963 *dst++ = map[Pixel];
964 ++src;
965 RGB888_RGB332(Pixel, *src);
966 *dst++ = map[Pixel];
967 ++src;
968 RGB888_RGB332(Pixel, *src);
969 *dst++ = map[Pixel];
970 ++src;
971 RGB888_RGB332(Pixel, *src);
972 *dst++ = map[Pixel];
973 ++src;
974 }
975 switch (width & 3) {
976 case 3:
977 RGB888_RGB332(Pixel, *src);
978 *dst++ = map[Pixel];
979 ++src;
980 case 2:
981 RGB888_RGB332(Pixel, *src);
982 *dst++ = map[Pixel];
983 ++src;
984 case 1:
985 RGB888_RGB332(Pixel, *src);
986 *dst++ = map[Pixel];
987 ++src;
988 }
989 #endif /* USE_DUFFS_LOOP */
990 src += srcskip;
991 dst += dstskip;
992 }
993 }
994 }
995
996 /* Special optimized blit for RGB 10-10-10 --> RGB 3-3-2 */
997 #define RGB101010_RGB332(dst, src) { \
998 dst = (Uint8)((((src)&0x38000000)>>22)| \
999 (((src)&0x000E0000)>>15)| \
1000 (((src)&0x00000300)>>8)); \
1001 }
1002 static void
1003 Blit_RGB101010_index8(SDL_BlitInfo * info)
1004 {
1005 #ifndef USE_DUFFS_LOOP
1006 int c;
1007 #endif
1008 int width, height;
1009 Uint32 *src;
1010 const Uint8 *map;
1011 Uint8 *dst;
1012 int srcskip, dstskip;
1013
1014 /* Set up some basic variables */
1015 width = info->dst_w;
1016 height = info->dst_h;
1017 src = (Uint32 *) info->src;
1018 srcskip = info->src_skip / 4;
1019 dst = info->dst;
1020 dstskip = info->dst_skip;
1021 map = info->table;
1022
1023 if (map == NULL) {
1024 while (height--) {
1025 #ifdef USE_DUFFS_LOOP
1026 /* *INDENT-OFF* */
1027 DUFFS_LOOP(
1028 RGB101010_RGB332(*dst++, *src);
1029 , width);
1030 /* *INDENT-ON* */
1031 #else
1032 for (c = width / 4; c; --c) {
1033 /* Pack RGB into 8bit pixel */
1034 ++src;
1035 RGB101010_RGB332(*dst++, *src);
1036 ++src;
1037 RGB101010_RGB332(*dst++, *src);
1038 ++src;
1039 RGB101010_RGB332(*dst++, *src);
1040 ++src;
1041 }
1042 switch (width & 3) {
1043 case 3:
1044 RGB101010_RGB332(*dst++, *src);
1045 ++src;
1046 case 2:
1047 RGB101010_RGB332(*dst++, *src);
1048 ++src;
1049 case 1:
1050 RGB101010_RGB332(*dst++, *src);
1051 ++src;
1052 }
1053 #endif /* USE_DUFFS_LOOP */
1054 src += srcskip;
1055 dst += dstskip;
1056 }
1057 } else {
1058 int Pixel;
1059
1060 while (height--) {
1061 #ifdef USE_DUFFS_LOOP
1062 /* *INDENT-OFF* */
1063 DUFFS_LOOP(
1064 RGB101010_RGB332(Pixel, *src);
1065 *dst++ = map[Pixel];
1066 ++src;
1067 , width);
1068 /* *INDENT-ON* */
1069 #else
1070 for (c = width / 4; c; --c) {
1071 /* Pack RGB into 8bit pixel */
1072 RGB101010_RGB332(Pixel, *src);
1073 *dst++ = map[Pixel];
1074 ++src;
1075 RGB101010_RGB332(Pixel, *src);
1076 *dst++ = map[Pixel];
1077 ++src;
1078 RGB101010_RGB332(Pixel, *src);
1079 *dst++ = map[Pixel];
1080 ++src;
1081 RGB101010_RGB332(Pixel, *src);
1082 *dst++ = map[Pixel];
1083 ++src;
1084 }
1085 switch (width & 3) {
1086 case 3:
1087 RGB101010_RGB332(Pixel, *src);
1088 *dst++ = map[Pixel];
1089 ++src;
1090 case 2:
1091 RGB101010_RGB332(Pixel, *src);
1092 *dst++ = map[Pixel];
1093 ++src;
1094 case 1:
1095 RGB101010_RGB332(Pixel, *src);
1096 *dst++ = map[Pixel];
1097 ++src;
1098 }
1099 #endif /* USE_DUFFS_LOOP */
1100 src += srcskip;
1101 dst += dstskip;
1102 }
1103 }
1104 }
1105
1106 /* Special optimized blit for RGB 8-8-8 --> RGB 5-5-5 */
1107 #define RGB888_RGB555(dst, src) { \
1108 *(Uint16 *)(dst) = (Uint16)((((*src)&0x00F80000)>>9)| \
1109 (((*src)&0x0000F800)>>6)| \
1110 (((*src)&0x000000F8)>>3)); \
1111 }
1112 #define RGB888_RGB555_TWO(dst, src) { \
1113 *(Uint32 *)(dst) = (((((src[HI])&0x00F80000)>>9)| \
1114 (((src[HI])&0x0000F800)>>6)| \
1115 (((src[HI])&0x000000F8)>>3))<<16)| \
1116 (((src[LO])&0x00F80000)>>9)| \
1117 (((src[LO])&0x0000F800)>>6)| \
1118 (((src[LO])&0x000000F8)>>3); \
1119 }
1120 static void
1121 Blit_RGB888_RGB555(SDL_BlitInfo * info)
1122 {
1123 #ifndef USE_DUFFS_LOOP
1124 int c;
1125 #endif
1126 int width, height;
1127 Uint32 *src;
1128 Uint16 *dst;
1129 int srcskip, dstskip;
1130
1131 /* Set up some basic variables */
1132 width = info->dst_w;
1133 height = info->dst_h;
1134 src = (Uint32 *) info->src;
1135 srcskip = info->src_skip / 4;
1136 dst = (Uint16 *) info->dst;
1137 dstskip = info->dst_skip / 2;
1138
1139 #ifdef USE_DUFFS_LOOP
1140 while (height--) {
1141 /* *INDENT-OFF* */
1142 DUFFS_LOOP(
1143 RGB888_RGB555(dst, src);
1144 ++src;
1145 ++dst;
1146 , width);
1147 /* *INDENT-ON* */
1148 src += srcskip;
1149 dst += dstskip;
1150 }
1151 #else
1152 /* Memory align at 4-byte boundary, if necessary */
1153 if ((long) dst & 0x03) {
1154 /* Don't do anything if width is 0 */
1155 if (width == 0) {
1156 return;
1157 }
1158 --width;
1159
1160 while (height--) {
1161 /* Perform copy alignment */
1162 RGB888_RGB555(dst, src);
1163 ++src;
1164 ++dst;
1165
1166 /* Copy in 4 pixel chunks */
1167 for (c = width / 4; c; --c) {
1168 RGB888_RGB555_TWO(dst, src);
1169 src += 2;
1170 dst += 2;
1171 RGB888_RGB555_TWO(dst, src);
1172 src += 2;
1173 dst += 2;
1174 }
1175 /* Get any leftovers */
1176 switch (width & 3) {
1177 case 3:
1178 RGB888_RGB555(dst, src);
1179 ++src;
1180 ++dst;
1181 case 2:
1182 RGB888_RGB555_TWO(dst, src);
1183 src += 2;
1184 dst += 2;
1185 break;
1186 case 1:
1187 RGB888_RGB555(dst, src);
1188 ++src;
1189 ++dst;
1190 break;
1191 }
1192 src += srcskip;
1193 dst += dstskip;
1194 }
1195 } else {
1196 while (height--) {
1197 /* Copy in 4 pixel chunks */
1198 for (c = width / 4; c; --c) {
1199 RGB888_RGB555_TWO(dst, src);
1200 src += 2;
1201 dst += 2;
1202 RGB888_RGB555_TWO(dst, src);
1203 src += 2;
1204 dst += 2;
1205 }
1206 /* Get any leftovers */
1207 switch (width & 3) {
1208 case 3:
1209 RGB888_RGB555(dst, src);
1210 ++src;
1211 ++dst;
1212 case 2:
1213 RGB888_RGB555_TWO(dst, src);
1214 src += 2;
1215 dst += 2;
1216 break;
1217 case 1:
1218 RGB888_RGB555(dst, src);
1219 ++src;
1220 ++dst;
1221 break;
1222 }
1223 src += srcskip;
1224 dst += dstskip;
1225 }
1226 }
1227 #endif /* USE_DUFFS_LOOP */
1228 }
1229
1230 /* Special optimized blit for RGB 8-8-8 --> RGB 5-6-5 */
1231 #define RGB888_RGB565(dst, src) { \
1232 *(Uint16 *)(dst) = (Uint16)((((*src)&0x00F80000)>>8)| \
1233 (((*src)&0x0000FC00)>>5)| \
1234 (((*src)&0x000000F8)>>3)); \
1235 }
1236 #define RGB888_RGB565_TWO(dst, src) { \
1237 *(Uint32 *)(dst) = (((((src[HI])&0x00F80000)>>8)| \
1238 (((src[HI])&0x0000FC00)>>5)| \
1239 (((src[HI])&0x000000F8)>>3))<<16)| \
1240 (((src[LO])&0x00F80000)>>8)| \
1241 (((src[LO])&0x0000FC00)>>5)| \
1242 (((src[LO])&0x000000F8)>>3); \
1243 }
1244 static void
1245 Blit_RGB888_RGB565(SDL_BlitInfo * info)
1246 {
1247 #ifndef USE_DUFFS_LOOP
1248 int c;
1249 #endif
1250 int width, height;
1251 Uint32 *src;
1252 Uint16 *dst;
1253 int srcskip, dstskip;
1254
1255 /* Set up some basic variables */
1256 width = info->dst_w;
1257 height = info->dst_h;
1258 src = (Uint32 *) info->src;
1259 srcskip = info->src_skip / 4;
1260 dst = (Uint16 *) info->dst;
1261 dstskip = info->dst_skip / 2;
1262
1263 #ifdef USE_DUFFS_LOOP
1264 while (height--) {
1265 /* *INDENT-OFF* */
1266 DUFFS_LOOP(
1267 RGB888_RGB565(dst, src);
1268 ++src;
1269 ++dst;
1270 , width);
1271 /* *INDENT-ON* */
1272 src += srcskip;
1273 dst += dstskip;
1274 }
1275 #else
1276 /* Memory align at 4-byte boundary, if necessary */
1277 if ((long) dst & 0x03) {
1278 /* Don't do anything if width is 0 */
1279 if (width == 0) {
1280 return;
1281 }
1282 --width;
1283
1284 while (height--) {
1285 /* Perform copy alignment */
1286 RGB888_RGB565(dst, src);
1287 ++src;
1288 ++dst;
1289
1290 /* Copy in 4 pixel chunks */
1291 for (c = width / 4; c; --c) {
1292 RGB888_RGB565_TWO(dst, src);
1293 src += 2;
1294 dst += 2;
1295 RGB888_RGB565_TWO(dst, src);
1296 src += 2;
1297 dst += 2;
1298 }
1299 /* Get any leftovers */
1300 switch (width & 3) {
1301 case 3:
1302 RGB888_RGB565(dst, src);
1303 ++src;
1304 ++dst;
1305 case 2:
1306 RGB888_RGB565_TWO(dst, src);
1307 src += 2;
1308 dst += 2;
1309 break;
1310 case 1:
1311 RGB888_RGB565(dst, src);
1312 ++src;
1313 ++dst;
1314 break;
1315 }
1316 src += srcskip;
1317 dst += dstskip;
1318 }
1319 } else {
1320 while (height--) {
1321 /* Copy in 4 pixel chunks */
1322 for (c = width / 4; c; --c) {
1323 RGB888_RGB565_TWO(dst, src);
1324 src += 2;
1325 dst += 2;
1326 RGB888_RGB565_TWO(dst, src);
1327 src += 2;
1328 dst += 2;
1329 }
1330 /* Get any leftovers */
1331 switch (width & 3) {
1332 case 3:
1333 RGB888_RGB565(dst, src);
1334 ++src;
1335 ++dst;
1336 case 2:
1337 RGB888_RGB565_TWO(dst, src);
1338 src += 2;
1339 dst += 2;
1340 break;
1341 case 1:
1342 RGB888_RGB565(dst, src);
1343 ++src;
1344 ++dst;
1345 break;
1346 }
1347 src += srcskip;
1348 dst += dstskip;
1349 }
1350 }
1351 #endif /* USE_DUFFS_LOOP */
1352 }
1353
1354
1355 /* Special optimized blit for RGB 5-6-5 --> 32-bit RGB surfaces */
1356 #define RGB565_32(dst, src, map) (map[src[LO]*2] + map[src[HI]*2+1])
1357 static void
1358 Blit_RGB565_32(SDL_BlitInfo * info, const Uint32 * map)
1359 {
1360 #ifndef USE_DUFFS_LOOP
1361 int c;
1362 #endif
1363 int width, height;
1364 Uint8 *src;
1365 Uint32 *dst;
1366 int srcskip, dstskip;
1367
1368 /* Set up some basic variables */
1369 width = info->dst_w;
1370 height = info->dst_h;
1371 src = (Uint8 *) info->src;
1372 srcskip = info->src_skip;
1373 dst = (Uint32 *) info->dst;
1374 dstskip = info->dst_skip / 4;
1375
1376 #ifdef USE_DUFFS_LOOP
1377 while (height--) {
1378 /* *INDENT-OFF* */
1379 DUFFS_LOOP(
1380 {
1381 *dst++ = RGB565_32(dst, src, map);
1382 src += 2;
1383 },
1384 width);
1385 /* *INDENT-ON* */
1386 src += srcskip;
1387 dst += dstskip;
1388 }
1389 #else
1390 while (height--) {
1391 /* Copy in 4 pixel chunks */
1392 for (c = width / 4; c; --c) {
1393 *dst++ = RGB565_32(dst, src, map);
1394 src += 2;
1395 *dst++ = RGB565_32(dst, src, map);
1396 src += 2;
1397 *dst++ = RGB565_32(dst, src, map);
1398 src += 2;
1399 *dst++ = RGB565_32(dst, src, map);
1400 src += 2;
1401 }
1402 /* Get any leftovers */
1403 switch (width & 3) {
1404 case 3:
1405 *dst++ = RGB565_32(dst, src, map);
1406 src += 2;
1407 case 2:
1408 *dst++ = RGB565_32(dst, src, map);
1409 src += 2;
1410 case 1:
1411 *dst++ = RGB565_32(dst, src, map);
1412 src += 2;
1413 break;
1414 }
1415 src += srcskip;
1416 dst += dstskip;
1417 }
1418 #endif /* USE_DUFFS_LOOP */
1419 }
1420
1421 /* Special optimized blit for RGB 5-6-5 --> ARGB 8-8-8-8 */
1422 static const Uint32 RGB565_ARGB8888_LUT[512] = {
1423 0x00000000, 0xff000000, 0x00000008, 0xff002000,
1424 0x00000010, 0xff004000, 0x00000018, 0xff006100,
1425 0x00000020, 0xff008100, 0x00000029, 0xff00a100,
1426 0x00000031, 0xff00c200, 0x00000039, 0xff00e200,
1427 0x00000041, 0xff080000, 0x0000004a, 0xff082000,
1428 0x00000052, 0xff084000, 0x0000005a, 0xff086100,
1429 0x00000062, 0xff088100, 0x0000006a, 0xff08a100,
1430 0x00000073, 0xff08c200, 0x0000007b, 0xff08e200,
1431 0x00000083, 0xff100000, 0x0000008b, 0xff102000,
1432 0x00000094, 0xff104000, 0x0000009c, 0xff106100,
1433 0x000000a4, 0xff108100, 0x000000ac, 0xff10a100,
1434 0x000000b4, 0xff10c200, 0x000000bd, 0xff10e200,
1435 0x000000c5, 0xff180000, 0x000000cd, 0xff182000,
1436 0x000000d5, 0xff184000, 0x000000de, 0xff186100,
1437 0x000000e6, 0xff188100, 0x000000ee, 0xff18a100,
1438 0x000000f6, 0xff18c200, 0x000000ff, 0xff18e200,
1439 0x00000400, 0xff200000, 0x00000408, 0xff202000,
1440 0x00000410, 0xff204000, 0x00000418, 0xff206100,
1441 0x00000420, 0xff208100, 0x00000429, 0xff20a100,
1442 0x00000431, 0xff20c200, 0x00000439, 0xff20e200,
1443 0x00000441, 0xff290000, 0x0000044a, 0xff292000,
1444 0x00000452, 0xff294000, 0x0000045a, 0xff296100,
1445 0x00000462, 0xff298100, 0x0000046a, 0xff29a100,
1446 0x00000473, 0xff29c200, 0x0000047b, 0xff29e200,
1447 0x00000483, 0xff310000, 0x0000048b, 0xff312000,
1448 0x00000494, 0xff314000, 0x0000049c, 0xff316100,
1449 0x000004a4, 0xff318100, 0x000004ac, 0xff31a100,
1450 0x000004b4, 0xff31c200, 0x000004bd, 0xff31e200,
1451 0x000004c5, 0xff390000, 0x000004cd, 0xff392000,
1452 0x000004d5, 0xff394000, 0x000004de, 0xff396100,
1453 0x000004e6, 0xff398100, 0x000004ee, 0xff39a100,
1454 0x000004f6, 0xff39c200, 0x000004ff, 0xff39e200,
1455 0x00000800, 0xff410000, 0x00000808, 0xff412000,
1456 0x00000810, 0xff414000, 0x00000818, 0xff416100,
1457 0x00000820, 0xff418100, 0x00000829, 0xff41a100,
1458 0x00000831, 0xff41c200, 0x00000839, 0xff41e200,
1459 0x00000841, 0xff4a0000, 0x0000084a, 0xff4a2000,
1460 0x00000852, 0xff4a4000, 0x0000085a, 0xff4a6100,
1461 0x00000862, 0xff4a8100, 0x0000086a, 0xff4aa100,
1462 0x00000873, 0xff4ac200, 0x0000087b, 0xff4ae200,
1463 0x00000883, 0xff520000, 0x0000088b, 0xff522000,
1464 0x00000894, 0xff524000, 0x0000089c, 0xff526100,
1465 0x000008a4, 0xff528100, 0x000008ac, 0xff52a100,
1466 0x000008b4, 0xff52c200, 0x000008bd, 0xff52e200,
1467 0x000008c5, 0xff5a0000, 0x000008cd, 0xff5a2000,
1468 0x000008d5, 0xff5a4000, 0x000008de, 0xff5a6100,
1469 0x000008e6, 0xff5a8100, 0x000008ee, 0xff5aa100,
1470 0x000008f6, 0xff5ac200, 0x000008ff, 0xff5ae200,
1471 0x00000c00, 0xff620000, 0x00000c08, 0xff622000,
1472 0x00000c10, 0xff624000, 0x00000c18, 0xff626100,
1473 0x00000c20, 0xff628100, 0x00000c29, 0xff62a100,
1474 0x00000c31, 0xff62c200, 0x00000c39, 0xff62e200,
1475 0x00000c41, 0xff6a0000, 0x00000c4a, 0xff6a2000,
1476 0x00000c52, 0xff6a4000, 0x00000c5a, 0xff6a6100,
1477 0x00000c62, 0xff6a8100, 0x00000c6a, 0xff6aa100,
1478 0x00000c73, 0xff6ac200, 0x00000c7b, 0xff6ae200,
1479 0x00000c83, 0xff730000, 0x00000c8b, 0xff732000,
1480 0x00000c94, 0xff734000, 0x00000c9c, 0xff736100,
1481 0x00000ca4, 0xff738100, 0x00000cac, 0xff73a100,
1482 0x00000cb4, 0xff73c200, 0x00000cbd, 0xff73e200,
1483 0x00000cc5, 0xff7b0000, 0x00000ccd, 0xff7b2000,
1484 0x00000cd5, 0xff7b4000, 0x00000cde, 0xff7b6100,
1485 0x00000ce6, 0xff7b8100, 0x00000cee, 0xff7ba100,
1486 0x00000cf6, 0xff7bc200, 0x00000cff, 0xff7be200,
1487 0x00001000, 0xff830000, 0x00001008, 0xff832000,
1488 0x00001010, 0xff834000, 0x00001018, 0xff836100,
1489 0x00001020, 0xff838100, 0x00001029, 0xff83a100,
1490 0x00001031, 0xff83c200, 0x00001039, 0xff83e200,
1491 0x00001041, 0xff8b0000, 0x0000104a, 0xff8b2000,
1492 0x00001052, 0xff8b4000, 0x0000105a, 0xff8b6100,
1493 0x00001062, 0xff8b8100, 0x0000106a, 0xff8ba100,
1494 0x00001073, 0xff8bc200, 0x0000107b, 0xff8be200,
1495 0x00001083, 0xff940000, 0x0000108b, 0xff942000,
1496 0x00001094, 0xff944000, 0x0000109c, 0xff946100,
1497 0x000010a4, 0xff948100, 0x000010ac, 0xff94a100,
1498 0x000010b4, 0xff94c200, 0x000010bd, 0xff94e200,
1499 0x000010c5, 0xff9c0000, 0x000010cd, 0xff9c2000,
1500 0x000010d5, 0xff9c4000, 0x000010de, 0xff9c6100,
1501 0x000010e6, 0xff9c8100, 0x000010ee, 0xff9ca100,
1502 0x000010f6, 0xff9cc200, 0x000010ff, 0xff9ce200,
1503 0x00001400, 0xffa40000, 0x00001408, 0xffa42000,
1504 0x00001410, 0xffa44000, 0x00001418, 0xffa46100,
1505 0x00001420, 0xffa48100, 0x00001429, 0xffa4a100,
1506 0x00001431, 0xffa4c200, 0x00001439, 0xffa4e200,
1507 0x00001441, 0xffac0000, 0x0000144a, 0xffac2000,
1508 0x00001452, 0xffac4000, 0x0000145a, 0xffac6100,
1509 0x00001462, 0xffac8100, 0x0000146a, 0xffaca100,
1510 0x00001473, 0xffacc200, 0x0000147b, 0xfface200,
1511 0x00001483, 0xffb40000, 0x0000148b, 0xffb42000,
1512 0x00001494, 0xffb44000, 0x0000149c, 0xffb46100,
1513 0x000014a4, 0xffb48100, 0x000014ac, 0xffb4a100,
1514 0x000014b4, 0xffb4c200, 0x000014bd, 0xffb4e200,
1515 0x000014c5, 0xffbd0000, 0x000014cd, 0xffbd2000,
1516 0x000014d5, 0xffbd4000, 0x000014de, 0xffbd6100,
1517 0x000014e6, 0xffbd8100, 0x000014ee, 0xffbda100,
1518 0x000014f6, 0xffbdc200, 0x000014ff, 0xffbde200,
1519 0x00001800, 0xffc50000, 0x00001808, 0xffc52000,
1520 0x00001810, 0xffc54000, 0x00001818, 0xffc56100,
1521 0x00001820, 0xffc58100, 0x00001829, 0xffc5a100,
1522 0x00001831, 0xffc5c200, 0x00001839, 0xffc5e200,
1523 0x00001841, 0xffcd0000, 0x0000184a, 0xffcd2000,
1524 0x00001852, 0xffcd4000, 0x0000185a, 0xffcd6100,
1525 0x00001862, 0xffcd8100, 0x0000186a, 0xffcda100,
1526 0x00001873, 0xffcdc200, 0x0000187b, 0xffcde200,
1527 0x00001883, 0xffd50000, 0x0000188b, 0xffd52000,
1528 0x00001894, 0xffd54000, 0x0000189c, 0xffd56100,
1529 0x000018a4, 0xffd58100, 0x000018ac, 0xffd5a100,
1530 0x000018b4, 0xffd5c200, 0x000018bd, 0xffd5e200,
1531 0x000018c5, 0xffde0000, 0x000018cd, 0xffde2000,
1532 0x000018d5, 0xffde4000, 0x000018de, 0xffde6100,
1533 0x000018e6, 0xffde8100, 0x000018ee, 0xffdea100,
1534 0x000018f6, 0xffdec200, 0x000018ff, 0xffdee200,
1535 0x00001c00, 0xffe60000, 0x00001c08, 0xffe62000,
1536 0x00001c10, 0xffe64000, 0x00001c18, 0xffe66100,
1537 0x00001c20, 0xffe68100, 0x00001c29, 0xffe6a100,
1538 0x00001c31, 0xffe6c200, 0x00001c39, 0xffe6e200,
1539 0x00001c41, 0xffee0000, 0x00001c4a, 0xffee2000,
1540 0x00001c52, 0xffee4000, 0x00001c5a, 0xffee6100,
1541 0x00001c62, 0xffee8100, 0x00001c6a, 0xffeea100,
1542 0x00001c73, 0xffeec200, 0x00001c7b, 0xffeee200,
1543 0x00001c83, 0xfff60000, 0x00001c8b, 0xfff62000,
1544 0x00001c94, 0xfff64000, 0x00001c9c, 0xfff66100,
1545 0x00001ca4, 0xfff68100, 0x00001cac, 0xfff6a100,
1546 0x00001cb4, 0xfff6c200, 0x00001cbd, 0xfff6e200,
1547 0x00001cc5, 0xffff0000, 0x00001ccd, 0xffff2000,
1548 0x00001cd5, 0xffff4000, 0x00001cde, 0xffff6100,
1549 0x00001ce6, 0xffff8100, 0x00001cee, 0xffffa100,
1550 0x00001cf6, 0xffffc200, 0x00001cff, 0xffffe200
1551 };
1552
1553 static void
1554 Blit_RGB565_ARGB8888(SDL_BlitInfo * info)
1555 {
1556 Blit_RGB565_32(info, RGB565_ARGB8888_LUT);
1557 }
1558
1559 /* Special optimized blit for RGB 5-6-5 --> ABGR 8-8-8-8 */
1560 static const Uint32 RGB565_ABGR8888_LUT[512] = {
1561 0xff000000, 0x00000000, 0xff080000, 0x00002000,
1562 0xff100000, 0x00004000, 0xff180000, 0x00006100,
1563 0xff200000, 0x00008100, 0xff290000, 0x0000a100,
1564 0xff310000, 0x0000c200, 0xff390000, 0x0000e200,
1565 0xff410000, 0x00000008, 0xff4a0000, 0x00002008,
1566 0xff520000, 0x00004008, 0xff5a0000, 0x00006108,
1567 0xff620000, 0x00008108, 0xff6a0000, 0x0000a108,
1568 0xff730000, 0x0000c208, 0xff7b0000, 0x0000e208,
1569 0xff830000, 0x00000010, 0xff8b0000, 0x00002010,
1570 0xff940000, 0x00004010, 0xff9c0000, 0x00006110,
1571 0xffa40000, 0x00008110, 0xffac0000, 0x0000a110,
1572 0xffb40000, 0x0000c210, 0xffbd0000, 0x0000e210,
1573 0xffc50000, 0x00000018, 0xffcd0000, 0x00002018,
1574 0xffd50000, 0x00004018, 0xffde0000, 0x00006118,
1575 0xffe60000, 0x00008118, 0xffee0000, 0x0000a118,
1576 0xfff60000, 0x0000c218, 0xffff0000, 0x0000e218,
1577 0xff000400, 0x00000020, 0xff080400, 0x00002020,
1578 0xff100400, 0x00004020, 0xff180400, 0x00006120,
1579 0xff200400, 0x00008120, 0xff290400, 0x0000a120,
1580 0xff310400, 0x0000c220, 0xff390400, 0x0000e220,
1581 0xff410400, 0x00000029, 0xff4a0400, 0x00002029,
1582 0xff520400, 0x00004029, 0xff5a0400, 0x00006129,
1583 0xff620400, 0x00008129, 0xff6a0400, 0x0000a129,
1584 0xff730400, 0x0000c229, 0xff7b0400, 0x0000e229,
1585 0xff830400, 0x00000031, 0xff8b0400, 0x00002031,
1586 0xff940400, 0x00004031, 0xff9c0400, 0x00006131,
1587 0xffa40400, 0x00008131, 0xffac0400, 0x0000a131,
1588 0xffb40400, 0x0000c231, 0xffbd0400, 0x0000e231,
1589 0xffc50400, 0x00000039, 0xffcd0400, 0x00002039,
1590 0xffd50400, 0x00004039, 0xffde0400, 0x00006139,
1591 0xffe60400, 0x00008139, 0xffee0400, 0x0000a139,
1592 0xfff60400, 0x0000c239, 0xffff0400, 0x0000e239,
1593 0xff000800, 0x00000041, 0xff080800, 0x00002041,
1594 0xff100800, 0x00004041, 0xff180800, 0x00006141,
1595 0xff200800, 0x00008141, 0xff290800, 0x0000a141,
1596 0xff310800, 0x0000c241, 0xff390800, 0x0000e241,
1597 0xff410800, 0x0000004a, 0xff4a0800, 0x0000204a,
1598 0xff520800, 0x0000404a, 0xff5a0800, 0x0000614a,
1599 0xff620800, 0x0000814a, 0xff6a0800, 0x0000a14a,
1600 0xff730800, 0x0000c24a, 0xff7b0800, 0x0000e24a,
1601 0xff830800, 0x00000052, 0xff8b0800, 0x00002052,
1602 0xff940800, 0x00004052, 0xff9c0800, 0x00006152,
1603 0xffa40800, 0x00008152, 0xffac0800, 0x0000a152,
1604 0xffb40800, 0x0000c252, 0xffbd0800, 0x0000e252,
1605 0xffc50800, 0x0000005a, 0xffcd0800, 0x0000205a,
1606 0xffd50800, 0x0000405a, 0xffde0800, 0x0000615a,
1607 0xffe60800, 0x0000815a, 0xffee0800, 0x0000a15a,
1608 0xfff60800, 0x0000c25a, 0xffff0800, 0x0000e25a,
1609 0xff000c00, 0x00000062, 0xff080c00, 0x00002062,
1610 0xff100c00, 0x00004062, 0xff180c00, 0x00006162,
1611 0xff200c00, 0x00008162, 0xff290c00, 0x0000a162,
1612 0xff310c00, 0x0000c262, 0xff390c00, 0x0000e262,
1613 0xff410c00, 0x0000006a, 0xff4a0c00, 0x0000206a,
1614 0xff520c00, 0x0000406a, 0xff5a0c00, 0x0000616a,
1615 0xff620c00, 0x0000816a, 0xff6a0c00, 0x0000a16a,
1616 0xff730c00, 0x0000c26a, 0xff7b0c00, 0x0000e26a,
1617 0xff830c00, 0x00000073, 0xff8b0c00, 0x00002073,
1618 0xff940c00, 0x00004073, 0xff9c0c00, 0x00006173,
1619 0xffa40c00, 0x00008173, 0xffac0c00, 0x0000a173,
1620 0xffb40c00, 0x0000c273, 0xffbd0c00, 0x0000e273,
1621 0xffc50c00, 0x0000007b, 0xffcd0c00, 0x0000207b,
1622 0xffd50c00, 0x0000407b, 0xffde0c00, 0x0000617b,
1623 0xffe60c00, 0x0000817b, 0xffee0c00, 0x0000a17b,
1624 0xfff60c00, 0x0000c27b, 0xffff0c00, 0x0000e27b,
1625 0xff001000, 0x00000083, 0xff081000, 0x00002083,
1626 0xff101000, 0x00004083, 0xff181000, 0x00006183,
1627 0xff201000, 0x00008183, 0xff291000, 0x0000a183,
1628 0xff311000, 0x0000c283, 0xff391000, 0x0000e283,
1629 0xff411000, 0x0000008b, 0xff4a1000, 0x0000208b,
1630 0xff521000, 0x0000408b, 0xff5a1000, 0x0000618b,
1631 0xff621000, 0x0000818b, 0xff6a1000, 0x0000a18b,
1632 0xff731000, 0x0000c28b, 0xff7b1000, 0x0000e28b,
1633 0xff831000, 0x00000094, 0xff8b1000, 0x00002094,
1634 0xff941000, 0x00004094, 0xff9c1000, 0x00006194,
1635 0xffa41000, 0x00008194, 0xffac1000, 0x0000a194,
1636 0xffb41000, 0x0000c294, 0xffbd1000, 0x0000e294,
1637 0xffc51000, 0x0000009c, 0xffcd1000, 0x0000209c,
1638 0xffd51000, 0x0000409c, 0xffde1000, 0x0000619c,
1639 0xffe61000, 0x0000819c, 0xffee1000, 0x0000a19c,
1640 0xfff61000, 0x0000c29c, 0xffff1000, 0x0000e29c,
1641 0xff001400, 0x000000a4, 0xff081400, 0x000020a4,
1642 0xff101400, 0x000040a4, 0xff181400, 0x000061a4,
1643 0xff201400, 0x000081a4, 0xff291400, 0x0000a1a4,
1644 0xff311400, 0x0000c2a4, 0xff391400, 0x0000e2a4,
1645 0xff411400, 0x000000ac, 0xff4a1400, 0x000020ac,
1646 0xff521400, 0x000040ac, 0xff5a1400, 0x000061ac,
1647 0xff621400, 0x000081ac, 0xff6a1400, 0x0000a1ac,
1648 0xff731400, 0x0000c2ac, 0xff7b1400, 0x0000e2ac,
1649 0xff831400, 0x000000b4, 0xff8b1400, 0x000020b4,
1650 0xff941400, 0x000040b4, 0xff9c1400, 0x000061b4,
1651 0xffa41400, 0x000081b4, 0xffac1400, 0x0000a1b4,
1652 0xffb41400, 0x0000c2b4, 0xffbd1400, 0x0000e2b4,
1653 0xffc51400, 0x000000bd, 0xffcd1400, 0x000020bd,
1654 0xffd51400, 0x000040bd, 0xffde1400, 0x000061bd,
1655 0xffe61400, 0x000081bd, 0xffee1400, 0x0000a1bd,
1656 0xfff61400, 0x0000c2bd, 0xffff1400, 0x0000e2bd,
1657 0xff001800, 0x000000c5, 0xff081800, 0x000020c5,
1658 0xff101800, 0x000040c5, 0xff181800, 0x000061c5,
1659 0xff201800, 0x000081c5, 0xff291800, 0x0000a1c5,
1660 0xff311800, 0x0000c2c5, 0xff391800, 0x0000e2c5,
1661 0xff411800, 0x000000cd, 0xff4a1800, 0x000020cd,
1662 0xff521800, 0x000040cd, 0xff5a1800, 0x000061cd,
1663 0xff621800, 0x000081cd, 0xff6a1800, 0x0000a1cd,
1664 0xff731800, 0x0000c2cd, 0xff7b1800, 0x0000e2cd,
1665 0xff831800, 0x000000d5, 0xff8b1800, 0x000020d5,
1666 0xff941800, 0x000040d5, 0xff9c1800, 0x000061d5,
1667 0xffa41800, 0x000081d5, 0xffac1800, 0x0000a1d5,
1668 0xffb41800, 0x0000c2d5, 0xffbd1800, 0x0000e2d5,
1669 0xffc51800, 0x000000de, 0xffcd1800, 0x000020de,
1670 0xffd51800, 0x000040de, 0xffde1800, 0x000061de,
1671 0xffe61800, 0x000081de, 0xffee1800, 0x0000a1de,
1672 0xfff61800, 0x0000c2de, 0xffff1800, 0x0000e2de,
1673 0xff001c00, 0x000000e6, 0xff081c00, 0x000020e6,
1674 0xff101c00, 0x000040e6, 0xff181c00, 0x000061e6,
1675 0xff201c00, 0x000081e6, 0xff291c00, 0x0000a1e6,
1676 0xff311c00, 0x0000c2e6, 0xff391c00, 0x0000e2e6,
1677 0xff411c00, 0x000000ee, 0xff4a1c00, 0x000020ee,
1678 0xff521c00, 0x000040ee, 0xff5a1c00, 0x000061ee,
1679 0xff621c00, 0x000081ee, 0xff6a1c00, 0x0000a1ee,
1680 0xff731c00, 0x0000c2ee, 0xff7b1c00, 0x0000e2ee,
1681 0xff831c00, 0x000000f6, 0xff8b1c00, 0x000020f6,
1682 0xff941c00, 0x000040f6, 0xff9c1c00, 0x000061f6,
1683 0xffa41c00, 0x000081f6, 0xffac1c00, 0x0000a1f6,
1684 0xffb41c00, 0x0000c2f6, 0xffbd1c00, 0x0000e2f6,
1685 0xffc51c00, 0x000000ff, 0xffcd1c00, 0x000020ff,
1686 0xffd51c00, 0x000040ff, 0xffde1c00, 0x000061ff,
1687 0xffe61c00, 0x000081ff, 0xffee1c00, 0x0000a1ff,
1688 0xfff61c00, 0x0000c2ff, 0xffff1c00, 0x0000e2ff
1689 };
1690
1691 static void
1692 Blit_RGB565_ABGR8888(SDL_BlitInfo * info)
1693 {
1694 Blit_RGB565_32(info, RGB565_ABGR8888_LUT);
1695 }
1696
1697 /* Special optimized blit for RGB 5-6-5 --> RGBA 8-8-8-8 */
1698 static const Uint32 RGB565_RGBA8888_LUT[512] = {
1699 0x000000ff, 0x00000000, 0x000008ff, 0x00200000,
1700 0x000010ff, 0x00400000, 0x000018ff, 0x00610000,
1701 0x000020ff, 0x00810000, 0x000029ff, 0x00a10000,
1702 0x000031ff, 0x00c20000, 0x000039ff, 0x00e20000,
1703 0x000041ff, 0x08000000, 0x00004aff, 0x08200000,
1704 0x000052ff, 0x08400000, 0x00005aff, 0x08610000,
1705 0x000062ff, 0x08810000, 0x00006aff, 0x08a10000,
1706 0x000073ff, 0x08c20000, 0x00007bff, 0x08e20000,
1707 0x000083ff, 0x10000000, 0x00008bff, 0x10200000,
1708 0x000094ff, 0x10400000, 0x00009cff, 0x10610000,
1709 0x0000a4ff, 0x10810000, 0x0000acff, 0x10a10000,
1710 0x0000b4ff, 0x10c20000, 0x0000bdff, 0x10e20000,
1711 0x0000c5ff, 0x18000000, 0x0000cdff, 0x18200000,
1712 0x0000d5ff, 0x18400000, 0x0000deff, 0x18610000,
1713 0x0000e6ff, 0x18810000, 0x0000eeff, 0x18a10000,
1714 0x0000f6ff, 0x18c20000, 0x0000ffff, 0x18e20000,
1715 0x000400ff, 0x20000000, 0x000408ff, 0x20200000,
1716 0x000410ff, 0x20400000, 0x000418ff, 0x20610000,
1717 0x000420ff, 0x20810000, 0x000429ff, 0x20a10000,
1718 0x000431ff, 0x20c20000, 0x000439ff, 0x20e20000,
1719 0x000441ff, 0x29000000, 0x00044aff, 0x29200000,
1720 0x000452ff, 0x29400000, 0x00045aff, 0x29610000,
1721 0x000462ff, 0x29810000, 0x00046aff, 0x29a10000,
1722 0x000473ff, 0x29c20000, 0x00047bff, 0x29e20000,
1723 0x000483ff, 0x31000000, 0x00048bff, 0x31200000,
1724 0x000494ff, 0x31400000, 0x00049cff, 0x31610000,
1725 0x0004a4ff, 0x31810000, 0x0004acff, 0x31a10000,
1726 0x0004b4ff, 0x31c20000, 0x0004bdff, 0x31e20000,
1727 0x0004c5ff, 0x39000000, 0x0004cdff, 0x39200000,
1728 0x0004d5ff, 0x39400000, 0x0004deff, 0x39610000,
1729 0x0004e6ff, 0x39810000, 0x0004eeff, 0x39a10000,
1730 0x0004f6ff, 0x39c20000, 0x0004ffff, 0x39e20000,
1731 0x000800ff, 0x41000000, 0x000808ff, 0x41200000,
1732 0x000810ff, 0x41400000, 0x000818ff, 0x41610000,
1733 0x000820ff, 0x41810000, 0x000829ff, 0x41a10000,
1734 0x000831ff, 0x41c20000, 0x000839ff, 0x41e20000,
1735 0x000841ff, 0x4a000000, 0x00084aff, 0x4a200000,
1736 0x000852ff, 0x4a400000, 0x00085aff, 0x4a610000,
1737 0x000862ff, 0x4a810000, 0x00086aff, 0x4aa10000,
1738 0x000873ff, 0x4ac20000, 0x00087bff, 0x4ae20000,
1739 0x000883ff, 0x52000000, 0x00088bff, 0x52200000,
1740 0x000894ff, 0x52400000, 0x00089cff, 0x52610000,
1741 0x0008a4ff, 0x52810000, 0x0008acff, 0x52a10000,
1742 0x0008b4ff, 0x52c20000, 0x0008bdff, 0x52e20000,
1743 0x0008c5ff, 0x5a000000, 0x0008cdff, 0x5a200000,
1744 0x0008d5ff, 0x5a400000, 0x0008deff, 0x5a610000,
1745 0x0008e6ff, 0x5a810000, 0x0008eeff, 0x5aa10000,
1746 0x0008f6ff, 0x5ac20000, 0x0008ffff, 0x5ae20000,
1747 0x000c00ff, 0x62000000, 0x000c08ff, 0x62200000,
1748 0x000c10ff, 0x62400000, 0x000c18ff, 0x62610000,
1749 0x000c20ff, 0x62810000, 0x000c29ff, 0x62a10000,
1750 0x000c31ff, 0x62c20000, 0x000c39ff, 0x62e20000,
1751 0x000c41ff, 0x6a000000, 0x000c4aff, 0x6a200000,
1752 0x000c52ff, 0x6a400000, 0x000c5aff, 0x6a610000,
1753 0x000c62ff, 0x6a810000, 0x000c6aff, 0x6aa10000,
1754 0x000c73ff, 0x6ac20000, 0x000c7bff, 0x6ae20000,
1755 0x000c83ff, 0x73000000, 0x000c8bff, 0x73200000,
1756 0x000c94ff, 0x73400000, 0x000c9cff, 0x73610000,
1757 0x000ca4ff, 0x73810000, 0x000cacff, 0x73a10000,
1758 0x000cb4ff, 0x73c20000, 0x000cbdff, 0x73e20000,
1759 0x000cc5ff, 0x7b000000, 0x000ccdff, 0x7b200000,
1760 0x000cd5ff, 0x7b400000, 0x000cdeff, 0x7b610000,
1761 0x000ce6ff, 0x7b810000, 0x000ceeff, 0x7ba10000,
1762 0x000cf6ff, 0x7bc20000, 0x000cffff, 0x7be20000,
1763 0x001000ff, 0x83000000, 0x001008ff, 0x83200000,
1764 0x001010ff, 0x83400000, 0x001018ff, 0x83610000,
1765 0x001020ff, 0x83810000, 0x001029ff, 0x83a10000,
1766 0x001031ff, 0x83c20000, 0x001039ff, 0x83e20000,
1767 0x001041ff, 0x8b000000, 0x00104aff, 0x8b200000,
1768 0x001052ff, 0x8b400000, 0x00105aff, 0x8b610000,
1769 0x001062ff, 0x8b810000, 0x00106aff, 0x8ba10000,
1770 0x001073ff, 0x8bc20000, 0x00107bff, 0x8be20000,
1771 0x001083ff, 0x94000000, 0x00108bff, 0x94200000,
1772 0x001094ff, 0x94400000, 0x00109cff, 0x94610000,
1773 0x0010a4ff, 0x94810000, 0x0010acff, 0x94a10000,
1774 0x0010b4ff, 0x94c20000, 0x0010bdff, 0x94e20000,
1775 0x0010c5ff, 0x9c000000, 0x0010cdff, 0x9c200000,
1776 0x0010d5ff, 0x9c400000, 0x0010deff, 0x9c610000,
1777 0x0010e6ff, 0x9c810000, 0x0010eeff, 0x9ca10000,
1778 0x0010f6ff, 0x9cc20000, 0x0010ffff, 0x9ce20000,
1779 0x001400ff, 0xa4000000, 0x001408ff, 0xa4200000,
1780 0x001410ff, 0xa4400000, 0x001418ff, 0xa4610000,
1781 0x001420ff, 0xa4810000, 0x001429ff, 0xa4a10000,
1782 0x001431ff, 0xa4c20000, 0x001439ff, 0xa4e20000,
1783 0x001441ff, 0xac000000, 0x00144aff, 0xac200000,
1784 0x001452ff, 0xac400000, 0x00145aff, 0xac610000,
1785 0x001462ff, 0xac810000, 0x00146aff, 0xaca10000,
1786 0x001473ff, 0xacc20000, 0x00147bff, 0xace20000,
1787 0x001483ff, 0xb4000000, 0x00148bff, 0xb4200000,
1788 0x001494ff, 0xb4400000, 0x00149cff, 0xb4610000,
1789 0x0014a4ff, 0xb4810000, 0x0014acff, 0xb4a10000,
1790 0x0014b4ff, 0xb4c20000, 0x0014bdff, 0xb4e20000,
1791 0x0014c5ff, 0xbd000000, 0x0014cdff, 0xbd200000,
1792 0x0014d5ff, 0xbd400000, 0x0014deff, 0xbd610000,
1793 0x0014e6ff, 0xbd810000, 0x0014eeff, 0xbda10000,
1794 0x0014f6ff, 0xbdc20000, 0x0014ffff, 0xbde20000,
1795 0x001800ff, 0xc5000000, 0x001808ff, 0xc5200000,
1796 0x001810ff, 0xc5400000, 0x001818ff, 0xc5610000,
1797 0x001820ff, 0xc5810000, 0x001829ff, 0xc5a10000,
1798 0x001831ff, 0xc5c20000, 0x001839ff, 0xc5e20000,
1799 0x001841ff, 0xcd000000, 0x00184aff, 0xcd200000,
1800 0x001852ff, 0xcd400000, 0x00185aff, 0xcd610000,
1801 0x001862ff, 0xcd810000, 0x00186aff, 0xcda10000,
1802 0x001873ff, 0xcdc20000, 0x00187bff, 0xcde20000,
1803 0x001883ff, 0xd5000000, 0x00188bff, 0xd5200000,
1804 0x001894ff, 0xd5400000, 0x00189cff, 0xd5610000,
1805 0x0018a4ff, 0xd5810000, 0x0018acff, 0xd5a10000,
1806 0x0018b4ff, 0xd5c20000, 0x0018bdff, 0xd5e20000,
1807 0x0018c5ff, 0xde000000, 0x0018cdff, 0xde200000,
1808 0x0018d5ff, 0xde400000, 0x0018deff, 0xde610000,
1809 0x0018e6ff, 0xde810000, 0x0018eeff, 0xdea10000,
1810 0x0018f6ff, 0xdec20000, 0x0018ffff, 0xdee20000,
1811 0x001c00ff, 0xe6000000, 0x001c08ff, 0xe6200000,
1812 0x001c10ff, 0xe6400000, 0x001c18ff, 0xe6610000,
1813 0x001c20ff, 0xe6810000, 0x001c29ff, 0xe6a10000,
1814 0x001c31ff, 0xe6c20000, 0x001c39ff, 0xe6e20000,
1815 0x001c41ff, 0xee000000, 0x001c4aff, 0xee200000,
1816 0x001c52ff, 0xee400000, 0x001c5aff, 0xee610000,
1817 0x001c62ff, 0xee810000, 0x001c6aff, 0xeea10000,
1818 0x001c73ff, 0xeec20000, 0x001c7bff, 0xeee20000,
1819 0x001c83ff, 0xf6000000, 0x001c8bff, 0xf6200000,
1820 0x001c94ff, 0xf6400000, 0x001c9cff, 0xf6610000,
1821 0x001ca4ff, 0xf6810000, 0x001cacff, 0xf6a10000,
1822 0x001cb4ff, 0xf6c20000, 0x001cbdff, 0xf6e20000,
1823 0x001cc5ff, 0xff000000, 0x001ccdff, 0xff200000,
1824 0x001cd5ff, 0xff400000, 0x001cdeff, 0xff610000,
1825 0x001ce6ff, 0xff810000, 0x001ceeff, 0xffa10000,
1826 0x001cf6ff, 0xffc20000, 0x001cffff, 0xffe20000,
1827 };
1828
1829 static void
1830 Blit_RGB565_RGBA8888(SDL_BlitInfo * info)
1831 {
1832 Blit_RGB565_32(info, RGB565_RGBA8888_LUT);
1833 }
1834
1835 /* Special optimized blit for RGB 5-6-5 --> BGRA 8-8-8-8 */
1836 static const Uint32 RGB565_BGRA8888_LUT[512] = {
1837 0x00000000, 0x000000ff, 0x08000000, 0x002000ff,
1838 0x10000000, 0x004000ff, 0x18000000, 0x006100ff,
1839 0x20000000, 0x008100ff, 0x29000000, 0x00a100ff,
1840 0x31000000, 0x00c200ff, 0x39000000, 0x00e200ff,
1841 0x41000000, 0x000008ff, 0x4a000000, 0x002008ff,
1842 0x52000000, 0x004008ff, 0x5a000000, 0x006108ff,
1843 0x62000000, 0x008108ff, 0x6a000000, 0x00a108ff,
1844 0x73000000, 0x00c208ff, 0x7b000000, 0x00e208ff,
1845 0x83000000, 0x000010ff, 0x8b000000, 0x002010ff,
1846 0x94000000, 0x004010ff, 0x9c000000, 0x006110ff,
1847 0xa4000000, 0x008110ff, 0xac000000, 0x00a110ff,
1848 0xb4000000, 0x00c210ff, 0xbd000000, 0x00e210ff,
1849 0xc5000000, 0x000018ff, 0xcd000000, 0x002018ff,
1850 0xd5000000, 0x004018ff, 0xde000000, 0x006118ff,
1851 0xe6000000, 0x008118ff, 0xee000000, 0x00a118ff,
1852 0xf6000000, 0x00c218ff, 0xff000000, 0x00e218ff,
1853 0x00040000, 0x000020ff, 0x08040000, 0x002020ff,
1854 0x10040000, 0x004020ff, 0x18040000, 0x006120ff,
1855 0x20040000, 0x008120ff, 0x29040000, 0x00a120ff,
1856 0x31040000, 0x00c220ff, 0x39040000, 0x00e220ff,
1857 0x41040000, 0x000029ff, 0x4a040000, 0x002029ff,
1858 0x52040000, 0x004029ff, 0x5a040000, 0x006129ff,
1859 0x62040000, 0x008129ff, 0x6a040000, 0x00a129ff,
1860 0x73040000, 0x00c229ff, 0x7b040000, 0x00e229ff,
1861 0x83040000, 0x000031ff, 0x8b040000, 0x002031ff,
1862 0x94040000, 0x004031ff, 0x9c040000, 0x006131ff,
1863 0xa4040000, 0x008131ff, 0xac040000, 0x00a131ff,
1864 0xb4040000, 0x00c231ff, 0xbd040000, 0x00e231ff,
1865 0xc5040000, 0x000039ff, 0xcd040000, 0x002039ff,
1866 0xd5040000, 0x004039ff, 0xde040000, 0x006139ff,
1867 0xe6040000, 0x008139ff, 0xee040000, 0x00a139ff,
1868 0xf6040000, 0x00c239ff, 0xff040000, 0x00e239ff,
1869 0x00080000, 0x000041ff, 0x08080000, 0x002041ff,
1870 0x10080000, 0x004041ff, 0x18080000, 0x006141ff,
1871 0x20080000, 0x008141ff, 0x29080000, 0x00a141ff,
1872 0x31080000, 0x00c241ff, 0x39080000, 0x00e241ff,
1873 0x41080000, 0x00004aff, 0x4a080000, 0x00204aff,
1874 0x52080000, 0x00404aff, 0x5a080000, 0x00614aff,
1875 0x62080000, 0x00814aff, 0x6a080000, 0x00a14aff,
1876 0x73080000, 0x00c24aff, 0x7b080000, 0x00e24aff,
1877 0x83080000, 0x000052ff, 0x8b080000, 0x002052ff,
1878 0x94080000, 0x004052ff, 0x9c080000, 0x006152ff,
1879 0xa4080000, 0x008152ff, 0xac080000, 0x00a152ff,
1880 0xb4080000, 0x00c252ff, 0xbd080000, 0x00e252ff,
1881 0xc5080000, 0x00005aff, 0xcd080000, 0x00205aff,
1882 0xd5080000, 0x00405aff, 0xde080000, 0x00615aff,
1883 0xe6080000, 0x00815aff, 0xee080000, 0x00a15aff,
1884 0xf6080000, 0x00c25aff, 0xff080000, 0x00e25aff,
1885 0x000c0000, 0x000062ff, 0x080c0000, 0x002062ff,
1886 0x100c0000, 0x004062ff, 0x180c0000, 0x006162ff,
1887 0x200c0000, 0x008162ff, 0x290c0000, 0x00a162ff,
1888 0x310c0000, 0x00c262ff, 0x390c0000, 0x00e262ff,
1889 0x410c0000, 0x00006aff, 0x4a0c0000, 0x00206aff,
1890 0x520c0000, 0x00406aff, 0x5a0c0000, 0x00616aff,
1891 0x620c0000, 0x00816aff, 0x6a0c0000, 0x00a16aff,
1892 0x730c0000, 0x00c26aff, 0x7b0c0000, 0x00e26aff,
1893 0x830c0000, 0x000073ff, 0x8b0c0000, 0x002073ff,
1894 0x940c0000, 0x004073ff, 0x9c0c0000, 0x006173ff,
1895 0xa40c0000, 0x008173ff, 0xac0c0000, 0x00a173ff,
1896 0xb40c0000, 0x00c273ff, 0xbd0c0000, 0x00e273ff,
1897 0xc50c0000, 0x00007bff, 0xcd0c0000, 0x00207bff,
1898 0xd50c0000, 0x00407bff, 0xde0c0000, 0x00617bff,
1899 0xe60c0000, 0x00817bff, 0xee0c0000, 0x00a17bff,
1900 0xf60c0000, 0x00c27bff, 0xff0c0000, 0x00e27bff,
1901 0x00100000, 0x000083ff, 0x08100000, 0x002083ff,
1902 0x10100000, 0x004083ff, 0x18100000, 0x006183ff,
1903 0x20100000, 0x008183ff, 0x29100000, 0x00a183ff,
1904 0x31100000, 0x00c283ff, 0x39100000, 0x00e283ff,
1905 0x41100000, 0x00008bff, 0x4a100000, 0x00208bff,
1906 0x52100000, 0x00408bff, 0x5a100000, 0x00618bff,
1907 0x62100000, 0x00818bff, 0x6a100000, 0x00a18bff,
1908 0x73100000, 0x00c28bff, 0x7b100000, 0x00e28bff,
1909 0x83100000, 0x000094ff, 0x8b100000, 0x002094ff,
1910 0x94100000, 0x004094ff, 0x9c100000, 0x006194ff,
1911 0xa4100000, 0x008194ff, 0xac100000, 0x00a194ff,
1912 0xb4100000, 0x00c294ff, 0xbd100000, 0x00e294ff,
1913 0xc5100000, 0x00009cff, 0xcd100000, 0x00209cff,
1914 0xd5100000, 0x00409cff, 0xde100000, 0x00619cff,
1915 0xe6100000, 0x00819cff, 0xee100000, 0x00a19cff,
1916 0xf6100000, 0x00c29cff, 0xff100000, 0x00e29cff,
1917 0x00140000, 0x0000a4ff, 0x08140000, 0x0020a4ff,
1918 0x10140000, 0x0040a4ff, 0x18140000, 0x0061a4ff,
1919 0x20140000, 0x0081a4ff, 0x29140000, 0x00a1a4ff,
1920 0x31140000, 0x00c2a4ff, 0x39140000, 0x00e2a4ff,
1921 0x41140000, 0x0000acff, 0x4a140000, 0x0020acff,
1922 0x52140000, 0x0040acff, 0x5a140000, 0x0061acff,
1923 0x62140000, 0x0081acff, 0x6a140000, 0x00a1acff,
1924 0x73140000, 0x00c2acff, 0x7b140000, 0x00e2acff,
1925 0x83140000, 0x0000b4ff, 0x8b140000, 0x0020b4ff,
1926 0x94140000, 0x0040b4ff, 0x9c140000, 0x0061b4ff,
1927 0xa4140000, 0x0081b4ff, 0xac140000, 0x00a1b4ff,
1928 0xb4140000, 0x00c2b4ff, 0xbd140000, 0x00e2b4ff,
1929 0xc5140000, 0x0000bdff, 0xcd140000, 0x0020bdff,
1930 0xd5140000, 0x0040bdff, 0xde140000, 0x0061bdff,
1931 0xe6140000, 0x0081bdff, 0xee140000, 0x00a1bdff,
1932 0xf6140000, 0x00c2bdff, 0xff140000, 0x00e2bdff,
1933 0x00180000, 0x0000c5ff, 0x08180000, 0x0020c5ff,
1934 0x10180000, 0x0040c5ff, 0x18180000, 0x0061c5ff,
1935 0x20180000, 0x0081c5ff, 0x29180000, 0x00a1c5ff,
1936 0x31180000, 0x00c2c5ff, 0x39180000, 0x00e2c5ff,
1937 0x41180000, 0x0000cdff, 0x4a180000, 0x0020cdff,
1938 0x52180000, 0x0040cdff, 0x5a180000, 0x0061cdff,
1939 0x62180000, 0x0081cdff, 0x6a180000, 0x00a1cdff,
1940 0x73180000, 0x00c2cdff, 0x7b180000, 0x00e2cdff,
1941 0x83180000, 0x0000d5ff, 0x8b180000, 0x0020d5ff,
1942 0x94180000, 0x0040d5ff, 0x9c180000, 0x0061d5ff,
1943 0xa4180000, 0x0081d5ff, 0xac180000, 0x00a1d5ff,
1944 0xb4180000, 0x00c2d5ff, 0xbd180000, 0x00e2d5ff,
1945 0xc5180000, 0x0000deff, 0xcd180000, 0x0020deff,
1946 0xd5180000, 0x0040deff, 0xde180000, 0x0061deff,
1947 0xe6180000, 0x0081deff, 0xee180000, 0x00a1deff,
1948 0xf6180000, 0x00c2deff, 0xff180000, 0x00e2deff,
1949 0x001c0000, 0x0000e6ff, 0x081c0000, 0x0020e6ff,
1950 0x101c0000, 0x0040e6ff, 0x181c0000, 0x0061e6ff,
1951 0x201c0000, 0x0081e6ff, 0x291c0000, 0x00a1e6ff,
1952 0x311c0000, 0x00c2e6ff, 0x391c0000, 0x00e2e6ff,
1953 0x411c0000, 0x0000eeff, 0x4a1c0000, 0x0020eeff,
1954 0x521c0000, 0x0040eeff, 0x5a1c0000, 0x0061eeff,
1955 0x621c0000, 0x0081eeff, 0x6a1c0000, 0x00a1eeff,
1956 0x731c0000, 0x00c2eeff, 0x7b1c0000, 0x00e2eeff,
1957 0x831c0000, 0x0000f6ff, 0x8b1c0000, 0x0020f6ff,
1958 0x941c0000, 0x0040f6ff, 0x9c1c0000, 0x0061f6ff,
1959 0xa41c0000, 0x0081f6ff, 0xac1c0000, 0x00a1f6ff,
1960 0xb41c0000, 0x00c2f6ff, 0xbd1c0000, 0x00e2f6ff,
1961 0xc51c0000, 0x0000ffff, 0xcd1c0000, 0x0020ffff,
1962 0xd51c0000, 0x0040ffff, 0xde1c0000, 0x0061ffff,
1963 0xe61c0000, 0x0081ffff, 0xee1c0000, 0x00a1ffff,
1964 0xf61c0000, 0x00c2ffff, 0xff1c0000, 0x00e2ffff
1965 };
1966
1967 static void
1968 Blit_RGB565_BGRA8888(SDL_BlitInfo * info)
1969 {
1970 Blit_RGB565_32(info, RGB565_BGRA8888_LUT);
1971 }
1972
1973 static void
1974 BlitNto1(SDL_BlitInfo * info)
1975 {
1976 #ifndef USE_DUFFS_LOOP
1977 int c;
1978 #endif
1979 int width, height;
1980 Uint8 *src;
1981 const Uint8 *map;
1982 Uint8 *dst;
1983 int srcskip, dstskip;
1984 int srcbpp;
1985 Uint32 Pixel;
1986 int sR, sG, sB;
1987 SDL_PixelFormat *srcfmt;
1988
1989 /* Set up some basic variables */
1990 width = info->dst_w;
1991 height = info->dst_h;
1992 src = info->src;
1993 srcskip = info->src_skip;
1994 dst = info->dst;
1995 dstskip = info->dst_skip;
1996 map = info->table;
1997 srcfmt = info->src_fmt;
1998 srcbpp = srcfmt->BytesPerPixel;
1999
2000 if (map == NULL) {
2001 while (height--) {
2002 #ifdef USE_DUFFS_LOOP
2003 /* *INDENT-OFF* */
2004 DUFFS_LOOP(
2005 DISEMBLE_RGB(src, srcbpp, srcfmt, Pixel,
2006 sR, sG, sB);
2007 if ( 1 ) {
2008 /* Pack RGB into 8bit pixel */
2009 *dst = ((sR>>5)<<(3+2))|
2010 ((sG>>5)<<(2)) |
2011 ((sB>>6)<<(0)) ;
2012 }
2013 dst++;
2014 src += srcbpp;
2015 , width);
2016 /* *INDENT-ON* */
2017 #else
2018 for (c = width; c; --c) {
2019 DISEMBLE_RGB(src, srcbpp, srcfmt, Pixel, sR, sG, sB);
2020 if (1) {
2021 /* Pack RGB into 8bit pixel */
2022 *dst = ((sR >> 5) << (3 + 2)) |
2023 ((sG >> 5) << (2)) | ((sB >> 6) << (0));
2024 }
2025 dst++;
2026 src += srcbpp;
2027 }
2028 #endif
2029 src += srcskip;
2030 dst += dstskip;
2031 }
2032 } else {
2033 while (height--) {
2034 #ifdef USE_DUFFS_LOOP
2035 /* *INDENT-OFF* */
2036 DUFFS_LOOP(
2037 DISEMBLE_RGB(src, srcbpp, srcfmt, Pixel,
2038 sR, sG, sB);
2039 if ( 1 ) {
2040 /* Pack RGB into 8bit pixel */
2041 *dst = map[((sR>>5)<<(3+2))|
2042 ((sG>>5)<<(2)) |
2043 ((sB>>6)<<(0)) ];
2044 }
2045 dst++;
2046 src += srcbpp;
2047 , width);
2048 /* *INDENT-ON* */
2049 #else
2050 for (c = width; c; --c) {
2051 DISEMBLE_RGB(src, srcbpp, srcfmt, Pixel, sR, sG, sB);
2052 if (1) {
2053 /* Pack RGB into 8bit pixel */
2054 *dst = map[((sR >> 5) << (3 + 2)) |
2055 ((sG >> 5) << (2)) | ((sB >> 6) << (0))];
2056 }
2057 dst++;
2058 src += srcbpp;
2059 }
2060 #endif /* USE_DUFFS_LOOP */
2061 src += srcskip;
2062 dst += dstskip;
2063 }
2064 }
2065 }
2066
2067 /* blits 32 bit RGB<->RGBA with both surfaces having the same R,G,B fields */
2068 static void
2069 Blit4to4MaskAlpha(SDL_BlitInfo * info)
2070 {
2071 int width = info->dst_w;
2072 int height = info->dst_h;
2073 Uint32 *src = (Uint32 *) info->src;
2074 int srcskip = info->src_skip;
2075 Uint32 *dst = (Uint32 *) info->dst;
2076 int dstskip = info->dst_skip;
2077 SDL_PixelFormat *srcfmt = info->src_fmt;
2078 SDL_PixelFormat *dstfmt = info->dst_fmt;
2079
2080 if (dstfmt->Amask) {
2081 /* RGB->RGBA, SET_ALPHA */
2082 Uint32 mask = (info->a >> dstfmt->Aloss) << dstfmt->Ashift;
2083
2084 while (height--) {
2085 /* *INDENT-OFF* */
2086 DUFFS_LOOP(
2087 {
2088 *dst = *src | mask;
2089 ++dst;
2090 ++src;
2091 },
2092 width);
2093 /* *INDENT-ON* */
2094 src = (Uint32 *) ((Uint8 *) src + srcskip);
2095 dst = (Uint32 *) ((Uint8 *) dst + dstskip);
2096 }
2097 } else {
2098 /* RGBA->RGB, NO_ALPHA */
2099 Uint32 mask = srcfmt->Rmask | srcfmt->Gmask | srcfmt->Bmask;
2100
2101 while (height--) {
2102 /* *INDENT-OFF* */
2103 DUFFS_LOOP(
2104 {
2105 *dst = *src & mask;
2106 ++dst;
2107 ++src;
2108 },
2109 width);
2110 /* *INDENT-ON* */
2111 src = (Uint32 *) ((Uint8 *) src + srcskip);
2112 dst = (Uint32 *) ((Uint8 *) dst + dstskip);
2113 }
2114 }
2115 }
2116
2117 static void
2118 BlitNtoN(SDL_BlitInfo * info)
2119 {
2120 int width = info->dst_w;
2121 int height = info->dst_h;
2122 Uint8 *src = info->src;
2123 int srcskip = info->src_skip;
2124 Uint8 *dst = info->dst;
2125 int dstskip = info->dst_skip;
2126 SDL_PixelFormat *srcfmt = info->src_fmt;
2127 int srcbpp = srcfmt->BytesPerPixel;
2128 SDL_PixelFormat *dstfmt = info->dst_fmt;
2129 int dstbpp = dstfmt->BytesPerPixel;
2130 unsigned alpha = dstfmt->Amask ? info->a : 0;
2131
2132 while (height--) {
2133 /* *INDENT-OFF* */
2134 DUFFS_LOOP(
2135 {
2136 Uint32 Pixel;
2137 unsigned sR;
2138 unsigned sG;
2139 unsigned sB;
2140 DISEMBLE_RGB(src, srcbpp, srcfmt, Pixel, sR, sG, sB);
2141 ASSEMBLE_RGBA(dst, dstbpp, dstfmt, sR, sG, sB, alpha);
2142 dst += dstbpp;
2143 src += srcbpp;
2144 },
2145 width);
2146 /* *INDENT-ON* */
2147 src += srcskip;
2148 dst += dstskip;
2149 }
2150 }
2151
2152 static void
2153 BlitNtoNCopyAlpha(SDL_BlitInfo * info)
2154 {
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 int c;
2166
2167 while (height--) {
2168 for (c = width; c; --c) {
2169 Uint32 Pixel;
2170 unsigned sR, sG, sB, sA;
2171 DISEMBLE_RGBA(src, srcbpp, srcfmt, Pixel, sR, sG, sB, sA);
2172 ASSEMBLE_RGBA(dst, dstbpp, dstfmt, sR, sG, sB, sA);
2173 dst += dstbpp;
2174 src += srcbpp;
2175 }
2176 src += srcskip;
2177 dst += dstskip;
2178 }
2179 }
2180
2181 static void
2182 BlitNto1Key(SDL_BlitInfo * info)
2183 {
2184 int width = info->dst_w;
2185 int height = info->dst_h;
2186 Uint8 *src = info->src;
2187 int srcskip = info->src_skip;
2188 Uint8 *dst = info->dst;
2189 int dstskip = info->dst_skip;
2190 SDL_PixelFormat *srcfmt = info->src_fmt;
2191 const Uint8 *palmap = info->table;
2192 Uint32 ckey = info->colorkey;
2193 Uint32 rgbmask = ~srcfmt->Amask;
2194 int srcbpp;
2195 Uint32 Pixel;
2196 unsigned sR, sG, sB;
2197
2198 /* Set up some basic variables */
2199 srcbpp = srcfmt->BytesPerPixel;
2200 ckey &= rgbmask;
2201
2202 if (palmap == NULL) {
2203 while (height--) {
2204 /* *INDENT-OFF* */
2205 DUFFS_LOOP(
2206 {
2207 DISEMBLE_RGB(src, srcbpp, srcfmt, Pixel,
2208 sR, sG, sB);
2209 if ( (Pixel & rgbmask) != ckey ) {
2210 /* Pack RGB into 8bit pixel */
2211 *dst = (Uint8)(((sR>>5)<<(3+2))|
2212 ((sG>>5)<<(2)) |
2213 ((sB>>6)<<(0)));
2214 }
2215 dst++;
2216 src += srcbpp;
2217 },
2218 width);
2219 /* *INDENT-ON* */
2220 src += srcskip;
2221 dst += dstskip;
2222 }
2223 } else {
2224 while (height--) {
2225 /* *INDENT-OFF* */
2226 DUFFS_LOOP(
2227 {
2228 DISEMBLE_RGB(src, srcbpp, srcfmt, Pixel,
2229 sR, sG, sB);
2230 if ( (Pixel & rgbmask) != ckey ) {
2231 /* Pack RGB into 8bit pixel */
2232 *dst = (Uint8)palmap[((sR>>5)<<(3+2))|
2233 ((sG>>5)<<(2)) |
2234 ((sB>>6)<<(0)) ];
2235 }
2236 dst++;
2237 src += srcbpp;
2238 },
2239 width);
2240 /* *INDENT-ON* */
2241 src += srcskip;
2242 dst += dstskip;
2243 }
2244 }
2245 }
2246
2247 static void
2248 Blit2to2Key(SDL_BlitInfo * info)
2249 {
2250 int width = info->dst_w;
2251 int height = info->dst_h;
2252 Uint16 *srcp = (Uint16 *) info->src;
2253 int srcskip = info->src_skip;
2254 Uint16 *dstp = (Uint16 *) info->dst;
2255 int dstskip = info->dst_skip;
2256 Uint32 ckey = info->colorkey;
2257 Uint32 rgbmask = ~info->src_fmt->Amask;
2258
2259 /* Set up some basic variables */
2260 srcskip /= 2;
2261 dstskip /= 2;
2262 ckey &= rgbmask;
2263
2264 while (height--) {
2265 /* *INDENT-OFF* */
2266 DUFFS_LOOP(
2267 {
2268 if ( (*srcp & rgbmask) != ckey ) {
2269 *dstp = *srcp;
2270 }
2271 dstp++;
2272 srcp++;
2273 },
2274 width);
2275 /* *INDENT-ON* */
2276 srcp += srcskip;
2277 dstp += dstskip;
2278 }
2279 }
2280
2281 static void
2282 BlitNtoNKey(SDL_BlitInfo * info)
2283 {
2284 int width = info->dst_w;
2285 int height = info->dst_h;
2286 Uint8 *src = info->src;
2287 int srcskip = info->src_skip;
2288 Uint8 *dst = info->dst;
2289 int dstskip = info->dst_skip;
2290 Uint32 ckey = info->colorkey;
2291 SDL_PixelFormat *srcfmt = info->src_fmt;
2292 SDL_PixelFormat *dstfmt = info->dst_fmt;
2293 int srcbpp = srcfmt->BytesPerPixel;
2294 int dstbpp = dstfmt->BytesPerPixel;
2295 unsigned alpha = dstfmt->Amask ? info->a : 0;
2296 Uint32 rgbmask = ~srcfmt->Amask;
2297
2298 /* Set up some basic variables */
2299 ckey &= rgbmask;
2300
2301 while (height--) {
2302 /* *INDENT-OFF* */
2303 DUFFS_LOOP(
2304 {
2305 Uint32 Pixel;
2306 unsigned sR;
2307 unsigned sG;
2308 unsigned sB;
2309 RETRIEVE_RGB_PIXEL(src, srcbpp, Pixel);
2310 if ( (Pixel & rgbmask) != ckey ) {
2311 RGB_FROM_PIXEL(Pixel, srcfmt, sR, sG, sB);
2312 ASSEMBLE_RGBA(dst, dstbpp, dstfmt, sR, sG, sB, alpha);
2313 }
2314 dst += dstbpp;
2315 src += srcbpp;
2316 },
2317 width);
2318 /* *INDENT-ON* */
2319 src += srcskip;
2320 dst += dstskip;
2321 }
2322 }
2323
2324 static void
2325 BlitNtoNKeyCopyAlpha(SDL_BlitInfo * info)
2326 {
2327 int width = info->dst_w;
2328 int height = info->dst_h;
2329 Uint8 *src = info->src;
2330 int srcskip = info->src_skip;
2331 Uint8 *dst = info->dst;
2332 int dstskip = info->dst_skip;
2333 Uint32 ckey = info->colorkey;
2334 SDL_PixelFormat *srcfmt = info->src_fmt;
2335 SDL_PixelFormat *dstfmt = info->dst_fmt;
2336 Uint32 rgbmask = ~srcfmt->Amask;
2337
2338 Uint8 srcbpp;
2339 Uint8 dstbpp;
2340 Uint32 Pixel;
2341 unsigned sR, sG, sB, sA;
2342
2343 /* Set up some basic variables */
2344 srcbpp = srcfmt->BytesPerPixel;
2345 dstbpp = dstfmt->BytesPerPixel;
2346 ckey &= rgbmask;
2347
2348 while (height--) {
2349 /* *INDENT-OFF* */
2350 DUFFS_LOOP(
2351 {
2352 DISEMBLE_RGBA(src, srcbpp, srcfmt, Pixel, sR, sG, sB, sA);
2353 if ( (Pixel & rgbmask) != ckey ) {
2354 ASSEMBLE_RGBA(dst, dstbpp, dstfmt, sR, sG, sB, sA);
2355 }
2356 dst += dstbpp;
2357 src += srcbpp;
2358 },
2359 width);
2360 /* *INDENT-ON* */
2361 src += srcskip;
2362 dst += dstskip;
2363 }
2364 }
2365
2366 /* Special optimized blit for ARGB 2-10-10-10 --> RGBA */
2367 static void
2368 Blit2101010toN(SDL_BlitInfo * info)
2369 {
2370 int width = info->dst_w;
2371 int height = info->dst_h;
2372 Uint8 *src = info->src;
2373 int srcskip = info->src_skip;
2374 Uint8 *dst = info->dst;
2375 int dstskip = info->dst_skip;
2376 SDL_PixelFormat *dstfmt = info->dst_fmt;
2377 int dstbpp = dstfmt->BytesPerPixel;
2378 Uint32 Pixel;
2379 unsigned sR, sG, sB, sA;
2380
2381 while (height--) {
2382 /* *INDENT-OFF* */
2383 DUFFS_LOOP(
2384 {
2385 Pixel = *(Uint32 *)src;
2386 RGBA_FROM_ARGB2101010(Pixel, sR, sG, sB, sA);
2387 ASSEMBLE_RGBA(dst, dstbpp, dstfmt, sR, sG, sB, sA);
2388 dst += dstbpp;
2389 src += 4;
2390 },
2391 width);
2392 /* *INDENT-ON* */
2393 src += srcskip;
2394 dst += dstskip;
2395 }
2396 }
2397
2398 /* Special optimized blit for RGBA --> ARGB 2-10-10-10 */
2399 static void
2400 BlitNto2101010(SDL_BlitInfo * info)
2401 {
2402 int width = info->dst_w;
2403 int height = info->dst_h;
2404 Uint8 *src = info->src;
2405 int srcskip = info->src_skip;
2406 Uint8 *dst = info->dst;
2407 int dstskip = info->dst_skip;
2408 SDL_PixelFormat *srcfmt = info->src_fmt;
2409 int srcbpp = srcfmt->BytesPerPixel;
2410 Uint32 Pixel;
2411 unsigned sR, sG, sB, sA;
2412
2413 while (height--) {
2414 /* *INDENT-OFF* */
2415 DUFFS_LOOP(
2416 {
2417 DISEMBLE_RGBA(src, srcbpp, srcfmt, Pixel, sR, sG, sB, sA);
2418 ARGB2101010_FROM_RGBA(Pixel, sR, sG, sB, sA);
2419 *(Uint32 *)dst = Pixel;
2420 dst += 4;
2421 src += srcbpp;
2422 },
2423 width);
2424 /* *INDENT-ON* */
2425 src += srcskip;
2426 dst += dstskip;
2427 }
2428 }
2429
2430 /* Normal N to N optimized blitters */
2431 struct blit_table
2432 {
2433 Uint32 srcR, srcG, srcB;
2434 int dstbpp;
2435 Uint32 dstR, dstG, dstB;
2436 Uint32 blit_features;
2437 SDL_BlitFunc blitfunc;
2438 enum
2439 { NO_ALPHA = 1, SET_ALPHA = 2, COPY_ALPHA = 4 } alpha;
2440 };
2441 static const struct blit_table normal_blit_1[] = {
2442 /* Default for 8-bit RGB source, never optimized */
2443 {0, 0, 0, 0, 0, 0, 0, 0, BlitNtoN, 0}
2444 };
2445
2446 static const struct blit_table normal_blit_2[] = {
2447 #if SDL_ALTIVEC_BLITTERS
2448 /* has-altivec */
2449 {0x0000F800, 0x000007E0, 0x0000001F, 4, 0x00000000, 0x00000000, 0x00000000,
2450 2, Blit_RGB565_32Altivec, NO_ALPHA | COPY_ALPHA | SET_ALPHA},
2451 {0x00007C00, 0x000003E0, 0x0000001F, 4, 0x00000000, 0x00000000, 0x00000000,
2452 2, Blit_RGB555_32Altivec, NO_ALPHA | COPY_ALPHA | SET_ALPHA},
2453 #endif
2454 {0x0000F800, 0x000007E0, 0x0000001F, 4, 0x00FF0000, 0x0000FF00, 0x000000FF,
2455 0, Blit_RGB565_ARGB8888, NO_ALPHA | COPY_ALPHA | SET_ALPHA},
2456 {0x0000F800, 0x000007E0, 0x0000001F, 4, 0x000000FF, 0x0000FF00, 0x00FF0000,
2457 0, Blit_RGB565_ABGR8888, NO_ALPHA | COPY_ALPHA | SET_ALPHA},
2458 {0x0000F800, 0x000007E0, 0x0000001F, 4, 0xFF000000, 0x00FF0000, 0x0000FF00,
2459 0, Blit_RGB565_RGBA8888, NO_ALPHA | COPY_ALPHA | SET_ALPHA},
2460 {0x0000F800, 0x000007E0, 0x0000001F, 4, 0x0000FF00, 0x00FF0000, 0xFF000000,
2461 0, Blit_RGB565_BGRA8888, NO_ALPHA | COPY_ALPHA | SET_ALPHA},
2462
2463 /* Default for 16-bit RGB source, used if no other blitter matches */
2464 {0, 0, 0, 0, 0, 0, 0, 0, BlitNtoN, 0}
2465 };
2466
2467 static const struct blit_table normal_blit_3[] = {
2468 /* Default for 24-bit RGB source, never optimized */
2469 {0, 0, 0, 0, 0, 0, 0, 0, BlitNtoN, 0}
2470 };
2471
2472 static const struct blit_table normal_blit_4[] = {
2473 #if SDL_ALTIVEC_BLITTERS
2474 /* has-altivec | dont-use-prefetch */
2475 {0x00000000, 0x00000000, 0x00000000, 4, 0x00000000, 0x00000000, 0x00000000,
2476 6, ConvertAltivec32to32_noprefetch, NO_ALPHA | COPY_ALPHA | SET_ALPHA},
2477 /* has-altivec */
2478 {0x00000000, 0x00000000, 0x00000000, 4, 0x00000000, 0x00000000, 0x00000000,
2479 2, ConvertAltivec32to32_prefetch, NO_ALPHA | COPY_ALPHA | SET_ALPHA},
2480 /* has-altivec */
2481 {0x00000000, 0x00000000, 0x00000000, 2, 0x0000F800, 0x000007E0, 0x0000001F,
2482 2, Blit_RGB888_RGB565Altivec, NO_ALPHA},
2483 #endif
2484 {0x00FF0000, 0x0000FF00, 0x000000FF, 2, 0x0000F800, 0x000007E0, 0x0000001F,
2485 0, Blit_RGB888_RGB565, NO_ALPHA},
2486 {0x00FF0000, 0x0000FF00, 0x000000FF, 2, 0x00007C00, 0x000003E0, 0x0000001F,
2487 0, Blit_RGB888_RGB555, NO_ALPHA},
2488 /* Default for 32-bit RGB source, used if no other blitter matches */
2489 {0, 0, 0, 0, 0, 0, 0, 0, BlitNtoN, 0}
2490 };
2491
2492 static const struct blit_table *const normal_blit[] = {
2493 normal_blit_1, normal_blit_2, normal_blit_3, normal_blit_4
2494 };
2495
2496 /* Mask matches table, or table entry is zero */
2497 #define MASKOK(x, y) (((x) == (y)) || ((y) == 0x00000000))
2498
2499 SDL_BlitFunc
2500 SDL_CalculateBlitN(SDL_Surface * surface)
2501 {
2502 SDL_PixelFormat *srcfmt;
2503 SDL_PixelFormat *dstfmt;
2504 const struct blit_table *table;
2505 int which;
2506 SDL_BlitFunc blitfun;
2507
2508 /* Set up data for choosing the blit */
2509 srcfmt = surface->format;
2510 dstfmt = surface->map->dst->format;
2511
2512 /* We don't support destinations less than 8-bits */
2513 if (dstfmt->BitsPerPixel < 8) {
2514 return (NULL);
2515 }
2516
2517 switch (surface->map->info.flags & ~SDL_COPY_RLE_MASK) {
2518 case 0:
2519 blitfun = NULL;
2520 if (dstfmt->BitsPerPixel == 8) {
2521 if ((srcfmt->BytesPerPixel == 4) &&
2522 (srcfmt->Rmask == 0x00FF0000) &&
2523 (srcfmt->Gmask == 0x0000FF00) &&
2524 (srcfmt->Bmask == 0x000000FF)) {
2525 blitfun = Blit_RGB888_index8;
2526 } else if ((srcfmt->BytesPerPixel == 4) &&
2527 (srcfmt->Rmask == 0x3FF00000) &&
2528 (srcfmt->Gmask == 0x000FFC00) &&
2529 (srcfmt->Bmask == 0x000003FF)) {
2530 blitfun = Blit_RGB101010_index8;
2531 } else {
2532 blitfun = BlitNto1;
2533 }
2534 } else {
2535 /* Now the meat, choose the blitter we want */
2536 int a_need = NO_ALPHA;
2537 if (dstfmt->Amask)
2538 a_need = srcfmt->Amask ? COPY_ALPHA : SET_ALPHA;
2539 table = normal_blit[srcfmt->BytesPerPixel - 1];
2540 for (which = 0; table[which].dstbpp; ++which) {
2541 if (MASKOK(srcfmt->Rmask, table[which].srcR) &&
2542 MASKOK(srcfmt->Gmask, table[which].srcG) &&
2543 MASKOK(srcfmt->Bmask, table[which].srcB) &&
2544 MASKOK(dstfmt->Rmask, table[which].dstR) &&
2545 MASKOK(dstfmt->Gmask, table[which].dstG) &&
2546 MASKOK(dstfmt->Bmask, table[which].dstB) &&
2547 dstfmt->BytesPerPixel == table[which].dstbpp &&
2548 (a_need & table[which].alpha) == a_need &&
2549 ((table[which].blit_features & GetBlitFeatures()) ==
2550 table[which].blit_features))
2551 break;
2552 }
2553 blitfun = table[which].blitfunc;
2554
2555 if (blitfun == BlitNtoN) { /* default C fallback catch-all. Slow! */
2556 if (srcfmt->format == SDL_PIXELFORMAT_ARGB2101010) {
2557 blitfun = Blit2101010toN;
2558 } else if (dstfmt->format == SDL_PIXELFORMAT_ARGB2101010) {
2559 blitfun = BlitNto2101010;
2560 } else if (srcfmt->BytesPerPixel == 4 &&
2561 dstfmt->BytesPerPixel == 4 &&
2562 srcfmt->Rmask == dstfmt->Rmask &&
2563 srcfmt->Gmask == dstfmt->Gmask &&
2564 srcfmt->Bmask == dstfmt->Bmask) {
2565 /* Fastpath C fallback: 32bit RGB<->RGBA blit with matching RGB */
2566 blitfun = Blit4to4MaskAlpha;
2567 } else if (a_need == COPY_ALPHA) {
2568 blitfun = BlitNtoNCopyAlpha;
2569 }
2570 }
2571 }
2572 return (blitfun);
2573
2574 case SDL_COPY_COLORKEY:
2575 /* colorkey blit: Here we don't have too many options, mostly
2576 because RLE is the preferred fast way to deal with this.
2577 If a particular case turns out to be useful we'll add it. */
2578
2579 if (srcfmt->BytesPerPixel == 2 && surface->map->identity)
2580 return Blit2to2Key;
2581 else if (dstfmt->BytesPerPixel == 1)
2582 return BlitNto1Key;
2583 else {
2584 #if SDL_ALTIVEC_BLITTERS
2585 if ((srcfmt->BytesPerPixel == 4) && (dstfmt->BytesPerPixel == 4)
2586 && SDL_HasAltiVec()) {
2587 return Blit32to32KeyAltivec;
2588 } else
2589 #endif
2590 if (srcfmt->Amask && dstfmt->Amask) {
2591 return BlitNtoNKeyCopyAlpha;
2592 } else {
2593 return BlitNtoNKey;
2594 }
2595 }
2596 }
2597
2598 return NULL;
2599 }
2600
2601 /* vi: set ts=4 sw=4 expandtab: */
SDL_PixelFormat::Aloss
Uint8 Aloss
Definition: SDL_pixels.h:286
SDL_BlitInfo::table
Uint8 * table
Definition: SDL_blit.h:67
table
GLenum GLsizei GLenum GLenum const GLvoid * table
Definition: glew.h:4422
v1
GLfloat GLfloat v1
Definition: glew.h:1838
RGB888_RGB555_TWO
#define RGB888_RGB555_TWO(dst, src)
Definition: SDL_blit_N.c:1112
Blit_RGB565_32
static void Blit_RGB565_32(SDL_BlitInfo *info, const Uint32 *map)
Definition: SDL_blit_N.c:1358
MASKOK
#define MASKOK(x, y)
Definition: SDL_blit_N.c:2497
SDL_COPY_COLORKEY
#define SDL_COPY_COLORKEY
Definition: SDL_blit.h:39
SDL_CalculateBlitN
SDL_BlitFunc SDL_CalculateBlitN(SDL_Surface *surface)
Definition: SDL_blit_N.c:2500
SDL_BlitInfo::src_skip
int src_skip
Definition: SDL_blit.h:60
RETRIEVE_RGB_PIXEL
#define RETRIEVE_RGB_PIXEL(buf, bpp, Pixel)
Definition: SDL_blit.h:145
RGB888_RGB332
#define RGB888_RGB332(dst, src)
Definition: SDL_blit_N.c:887
SDL_PixelFormat::Gmask
Uint32 Gmask
Definition: SDL_pixels.h:280
g
GLboolean GLboolean g
Definition: glew.h:8736
NULL
#define NULL
Definition: ftobjs.h:61
RGB888_RGB565
#define RGB888_RGB565(dst, src)
Definition: SDL_blit_N.c:1231
SDL_PixelFormat::BytesPerPixel
Uint8 BytesPerPixel
Definition: SDL_pixels.h:277
SDL_BlitInfo::flags
int flags
Definition: SDL_blit.h:68
SDL_BlitInfo::src_fmt
SDL_PixelFormat * src_fmt
Definition: SDL_blit.h:65
BlitNto2101010
static void BlitNto2101010(SDL_BlitInfo *info)
Definition: SDL_blit_N.c:2400
surface
EGLSurface surface
Definition: eglext.h:74
ASSEMBLE_RGBA
#define ASSEMBLE_RGBA(buf, bpp, fmt, r, g, b, a)
Definition: SDL_blit.h:401
SDL_Surface
A collection of pixels used in software blitting.
Definition: SDL_surface.h:69
SDL_HasMMX
DECLSPEC SDL_bool SDLCALL SDL_HasMMX(void)
Definition: SDL_cpuinfo.c:548
RGB565_RGBA8888_LUT
static const Uint32 RGB565_RGBA8888_LUT[512]
Definition: SDL_blit_N.c:1698
SDL_PixelFormat::Bmask
Uint32 Bmask
Definition: SDL_pixels.h:281
v3
GLfloat GLfloat GLfloat GLfloat v3
Definition: glew.h:1846
SDL_PixelFormat::Ashift
Uint8 Ashift
Definition: SDL_pixels.h:290
height
EGLSurface EGLint EGLint EGLint EGLint height
Definition: eglext.h:293
SDL_sscanf
DECLSPEC int SDLCALL SDL_sscanf(const char *text, const char *fmt,...)
Definition: SDL_string.c:1011
a
GLboolean GLboolean GLboolean GLboolean a
Definition: glew.h:8736
SDL_COPY_RLE_MASK
#define SDL_COPY_RLE_MASK
Definition: SDL_blit.h:44
RGBA_FROM_ARGB2101010
#define RGBA_FROM_ARGB2101010(Pixel, r, g, b, a)
Definition: SDL_blit.h:345
SDL_BlitInfo::dst_skip
int dst_skip
Definition: SDL_blit.h:64
RGB565_ABGR8888_LUT
static const Uint32 RGB565_ABGR8888_LUT[512]
Definition: SDL_blit_N.c:1560
bits
#define bits
Definition: infblock.c:15
if
if(!yyg->yy_init)
Definition: glslang_lex.cpp:1037
SDL_BlitInfo::dst_h
int dst_h
Definition: SDL_blit.h:62
Blit_RGB565_ARGB8888
static void Blit_RGB565_ARGB8888(SDL_BlitInfo *info)
Definition: SDL_blit_N.c:1554
SDL_config.h
SDL_PIXELFORMAT_ARGB2101010
Definition: SDL_pixels.h:236
SDL_BlitInfo::colorkey
Uint32 colorkey
Definition: SDL_blit.h:69
SDL_cpuinfo.h
Uint32
uint32_t Uint32
An unsigned 32-bit integer type.
Definition: SDL_stdinc.h:145
SDL_BlitInfo::dst
Uint8 * dst
Definition: SDL_blit.h:61
BlitNtoNCopyAlpha
static void BlitNtoNCopyAlpha(SDL_BlitInfo *info)
Definition: SDL_blit_N.c:2153
SDL_Surface::map
struct SDL_BlitMap * map
Definition: SDL_surface.h:88
RGB565_ARGB8888_LUT
static const Uint32 RGB565_ARGB8888_LUT[512]
Definition: SDL_blit_N.c:1422
RGB565_BGRA8888_LUT
static const Uint32 RGB565_BGRA8888_LUT[512]
Definition: SDL_blit_N.c:1836
SDL_video.h
result
GLuint64EXT * result
Definition: glew.h:12708
DISEMBLE_RGBA
#define DISEMBLE_RGBA(buf, bpp, fmt, Pixel, r, g, b, a)
Definition: SDL_blit.h:352
dst
GLenum GLenum dst
Definition: glew.h:2396
RGB101010_RGB332
#define RGB101010_RGB332(dst, src)
Definition: SDL_blit_N.c:997
Blit2to2Key
static void Blit2to2Key(SDL_BlitInfo *info)
Definition: SDL_blit_N.c:2248
int
int
Definition: SDL_systhread.c:37
SDL_BlitInfo
Definition: SDL_blit.h:55
SDL_PixelFormat::Bshift
Uint8 Bshift
Definition: SDL_pixels.h:289
width
EGLSurface EGLint EGLint EGLint width
Definition: eglext.h:293
SDL_PixelFormat::Rshift
Uint8 Rshift
Definition: SDL_pixels.h:287
RGB_FROM_PIXEL
#define RGB_FROM_PIXEL(Pixel, fmt, r, g, b)
Definition: SDL_blit.h:121
SDL_PixelFormat::BitsPerPixel
Uint8 BitsPerPixel
Definition: SDL_pixels.h:276
Blit4to4MaskAlpha
static void Blit4to4MaskAlpha(SDL_BlitInfo *info)
Definition: SDL_blit_N.c:2069
BlitNto1Key
static void BlitNto1Key(SDL_BlitInfo *info)
Definition: SDL_blit_N.c:2182
c
const GLfloat * c
Definition: glew.h:14913
RGB888_RGB565_TWO
#define RGB888_RGB565_TWO(dst, src)
Definition: SDL_blit_N.c:1236
normal_blit
static struct blit_table *const normal_blit[]
Definition: SDL_blit_N.c:2492
DUFFS_LOOP
#define DUFFS_LOOP(pixel_copy_increment, width)
Definition: SDL_blit.h:499
Blit_RGB888_index8
static void Blit_RGB888_index8(SDL_BlitInfo *info)
Definition: SDL_blit_N.c:893
Blit_RGB565_RGBA8888
static void Blit_RGB565_RGBA8888(SDL_BlitInfo *info)
Definition: SDL_blit_N.c:1830
normal_blit_2
static struct blit_table normal_blit_2[]
Definition: SDL_blit_N.c:2446
Blit_RGB565_BGRA8888
static void Blit_RGB565_BGRA8888(SDL_BlitInfo *info)
Definition: SDL_blit_N.c:1968
alpha
GLclampf GLclampf GLclampf alpha
Definition: glew.h:1506
SDL_BlitInfo::src
Uint8 * src
Definition: SDL_blit.h:57
SDL_BlitInfo::dst_fmt
SDL_PixelFormat * dst_fmt
Definition: SDL_blit.h:66
normal_blit_3
static struct blit_table normal_blit_3[]
Definition: SDL_blit_N.c:2467
SDL_endian.h
normal_blit_4
static struct blit_table normal_blit_4[]
Definition: SDL_blit_N.c:2472
RGB565_32
#define RGB565_32(dst, src, map)
Definition: SDL_blit_N.c:1356
SDL_assert
#define SDL_assert(condition)
Definition: SDL_assert.h:159
SDL_BlitMap::dst
SDL_Surface * dst
Definition: SDL_blit.h:87
SDL_Surface::format
SDL_PixelFormat * format
Definition: SDL_surface.h:72
BlitNtoNKey
static void BlitNtoNKey(SDL_BlitInfo *info)
Definition: SDL_blit_N.c:2282
Blit2101010toN
static void Blit2101010toN(SDL_BlitInfo *info)
Definition: SDL_blit_N.c:2368
SDL_PixelFormat::Gshift
Uint8 Gshift
Definition: SDL_pixels.h:288
SDL_PixelFormat::Rmask
Uint32 Rmask
Definition: SDL_pixels.h:279
SDL_HasAltiVec
DECLSPEC SDL_bool SDLCALL SDL_HasAltiVec(void)
Definition: SDL_cpuinfo.c:539
SDL_blit.h
BlitNtoNKeyCopyAlpha
static void BlitNtoNKeyCopyAlpha(SDL_BlitInfo *info)
Definition: SDL_blit_N.c:2325
Uint8
uint8_t Uint8
An unsigned 8-bit integer type.
Definition: SDL_stdinc.h:129
GetBlitFeatures
#define GetBlitFeatures()
Definition: SDL_blit_N.c:874
mask
GLint GLint GLint GLint GLint GLint GLint GLbitfield mask
Definition: gl2ext.h:961
SDL_PixelFormat
Definition: SDL_pixels.h:272
r
GLdouble GLdouble GLdouble r
Definition: glew.h:1392
b
GLdouble GLdouble GLdouble b
Definition: glew.h:8383
DISEMBLE_RGB
#define DISEMBLE_RGB(buf, bpp, fmt, Pixel, r, g, b)
Definition: SDL_blit.h:176
Blit_RGB101010_index8
static void Blit_RGB101010_index8(SDL_BlitInfo *info)
Definition: SDL_blit_N.c:1003
ARGB2101010_FROM_RGBA
#define ARGB2101010_FROM_RGBA(Pixel, r, g, b, a)
Definition: SDL_blit.h:252
Uint16
uint16_t Uint16
An unsigned 16-bit integer type.
Definition: SDL_stdinc.h:137
BlitNtoN
static void BlitNtoN(SDL_BlitInfo *info)
Definition: SDL_blit_N.c:2118
SDL_PixelFormat::Amask
Uint32 Amask
Definition: SDL_pixels.h:282
SDL_getenv
DECLSPEC char *SDLCALL SDL_getenv(const char *name)
Definition: SDL_getenv.c:179
RGBA_FROM_8888
#define RGBA_FROM_8888(Pixel, fmt, r, g, b, a)
Definition: SDL_blit.h:310
src
GLenum src
Definition: glew.h:2396
SDL_PixelFormat::format
Uint32 format
Definition: SDL_pixels.h:274
SDL_BlitInfo::dst_w
int dst_w
Definition: SDL_blit.h:62
map
const GLubyte GLuint GLuint GLuint GLuint alpha GLboolean GLboolean GLboolean GLboolean alpha GLint GLint GLsizei GLsizei GLenum type GLenum GLint GLenum GLint GLint GLsizei GLsizei GLint border GLenum GLint GLint GLint GLint GLint GLsizei GLsizei height GLsizei GLsizei GLenum GLenum const GLvoid *pixels GLenum GLint GLint GLint GLint j2 GLdouble GLdouble GLdouble GLdouble GLdouble GLdouble zFar GLenum GLenum GLint *params GLenum GLenum GLint *params GLenum GLenum GLint *params GLenum GLenum GLfloat *params GLenum GLint GLenum GLenum GLvoid *pixels GLenum GLint GLenum GLint *params GLenum GLenum GLint *params GLenum GLsizei const GLvoid *pointer GLenum GLenum const GLint *params GLenum GLfloat GLfloat GLint GLint const GLfloat *points GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat *points GLint GLfloat GLfloat GLint GLfloat GLfloat v2 GLenum GLenum const GLint *params GLdouble GLdouble GLdouble GLdouble GLdouble GLdouble zFar GLenum map
Definition: SDL_glfuncs.h:268
while
while(1)
Definition: glslang_lex.cpp:1063
Blit_RGB565_ABGR8888
static void Blit_RGB565_ABGR8888(SDL_BlitInfo *info)
Definition: SDL_blit_N.c:1692
normal_blit_1
static struct blit_table normal_blit_1[]
Definition: SDL_blit_N.c:2441
SDL_BlitMap::identity
int identity
Definition: SDL_blit.h:88
Blit_RGB888_RGB555
static void Blit_RGB888_RGB555(SDL_BlitInfo *info)
Definition: SDL_blit_N.c:1121
SDL_BlitMap::info
SDL_BlitInfo info
Definition: SDL_blit.h:91
v2
GLfloat GLfloat GLfloat v2
Definition: glew.h:1842
SDL_assert.h
Blit_RGB888_RGB565
static void Blit_RGB888_RGB565(SDL_BlitInfo *info)
Definition: SDL_blit_N.c:1245
RGB888_RGB555
#define RGB888_RGB555(dst, src)
Definition: SDL_blit_N.c:1107
SDL_BlitInfo::a
Uint8 a
Definition: SDL_blit.h:70
BlitNto1
static void BlitNto1(SDL_BlitInfo *info)
Definition: SDL_blit_N.c:1974