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