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