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