src/video/SDL_blit_N.c
author Sam Lantinga <slouken@libsdl.org>
Sat, 22 Oct 2016 11:01:55 -0700
changeset 10558 5184186d4366
parent 9998 f67cf37e9cd4
child 10559 fbf9b0e3589a
permissions -rw-r--r--
Fixed bug 3466 - Can't build 2.0.5 on ppc64

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