src/video/SDL_blit_N.c
author Sam Lantinga <slouken@libsdl.org>
Fri, 11 Feb 2011 22:37:15 -0800
changeset 5262 b530ef003506
parent 5259 6a65c1fc07af
child 5389 24903690f48a
permissions -rw-r--r--
Happy 2011! :)
     1 /*
     2     SDL - Simple DirectMedia Layer
     3     Copyright (C) 1997-2011 Sam Lantinga
     4 
     5     This library is free software; you can redistribute it and/or
     6     modify it under the terms of the GNU Lesser General Public
     7     License as published by the Free Software Foundation; either
     8     version 2.1 of the License, or (at your option) any later version.
     9 
    10     This library is distributed in the hope that it will be useful,
    11     but WITHOUT ANY WARRANTY; without even the implied warranty of
    12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    13     Lesser General Public License for more details.
    14 
    15     You should have received a copy of the GNU Lesser General Public
    16     License along with this library; if not, write to the Free Software
    17     Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
    18 
    19     Sam Lantinga
    20     slouken@libsdl.org
    21 */
    22 #include "SDL_config.h"
    23 
    24 #include "SDL_video.h"
    25 #include "SDL_endian.h"
    26 #include "SDL_cpuinfo.h"
    27 #include "SDL_blit.h"
    28 
    29 /* Functions to blit from N-bit surfaces to other surfaces */
    30 
    31 /* Feature 1 is has-MMX */
    32 #define GetBlitFeatures() ((Uint32)(SDL_HasMMX() ? 1 : 0))
    33 
    34 /* This is now endian dependent */
    35 #if SDL_BYTEORDER == SDL_LIL_ENDIAN
    36 #define HI	1
    37 #define LO	0
    38 #else /* SDL_BYTEORDER == SDL_BIG_ENDIAN */
    39 #define HI	0
    40 #define LO	1
    41 #endif
    42 
    43 /* Special optimized blit for RGB 8-8-8 --> RGB 3-3-2 */
    44 #define RGB888_RGB332(dst, src) { \
    45 	dst = (Uint8)((((src)&0x00E00000)>>16)| \
    46 	              (((src)&0x0000E000)>>11)| \
    47 	              (((src)&0x000000C0)>>6)); \
    48 }
    49 static void
    50 Blit_RGB888_index8(SDL_BlitInfo * info)
    51 {
    52 #ifndef USE_DUFFS_LOOP
    53     int c;
    54 #endif
    55     int width, height;
    56     Uint32 *src;
    57     const Uint8 *map;
    58     Uint8 *dst;
    59     int srcskip, dstskip;
    60 
    61     /* Set up some basic variables */
    62     width = info->dst_w;
    63     height = info->dst_h;
    64     src = (Uint32 *) info->src;
    65     srcskip = info->src_skip / 4;
    66     dst = info->dst;
    67     dstskip = info->dst_skip;
    68     map = info->table;
    69 
    70     if (map == NULL) {
    71         while (height--) {
    72 #ifdef USE_DUFFS_LOOP
    73 			/* *INDENT-OFF* */
    74 			DUFFS_LOOP(
    75 				RGB888_RGB332(*dst++, *src);
    76 			, width);
    77 			/* *INDENT-ON* */
    78 #else
    79             for (c = width / 4; c; --c) {
    80                 /* Pack RGB into 8bit pixel */
    81                 ++src;
    82                 RGB888_RGB332(*dst++, *src);
    83                 ++src;
    84                 RGB888_RGB332(*dst++, *src);
    85                 ++src;
    86                 RGB888_RGB332(*dst++, *src);
    87                 ++src;
    88             }
    89             switch (width & 3) {
    90             case 3:
    91                 RGB888_RGB332(*dst++, *src);
    92                 ++src;
    93             case 2:
    94                 RGB888_RGB332(*dst++, *src);
    95                 ++src;
    96             case 1:
    97                 RGB888_RGB332(*dst++, *src);
    98                 ++src;
    99             }
   100 #endif /* USE_DUFFS_LOOP */
   101             src += srcskip;
   102             dst += dstskip;
   103         }
   104     } else {
   105         int Pixel;
   106 
   107         while (height--) {
   108 #ifdef USE_DUFFS_LOOP
   109 			/* *INDENT-OFF* */
   110 			DUFFS_LOOP(
   111 				RGB888_RGB332(Pixel, *src);
   112 				*dst++ = map[Pixel];
   113 				++src;
   114 			, width);
   115 			/* *INDENT-ON* */
   116 #else
   117             for (c = width / 4; c; --c) {
   118                 /* Pack RGB into 8bit pixel */
   119                 RGB888_RGB332(Pixel, *src);
   120                 *dst++ = map[Pixel];
   121                 ++src;
   122                 RGB888_RGB332(Pixel, *src);
   123                 *dst++ = map[Pixel];
   124                 ++src;
   125                 RGB888_RGB332(Pixel, *src);
   126                 *dst++ = map[Pixel];
   127                 ++src;
   128                 RGB888_RGB332(Pixel, *src);
   129                 *dst++ = map[Pixel];
   130                 ++src;
   131             }
   132             switch (width & 3) {
   133             case 3:
   134                 RGB888_RGB332(Pixel, *src);
   135                 *dst++ = map[Pixel];
   136                 ++src;
   137             case 2:
   138                 RGB888_RGB332(Pixel, *src);
   139                 *dst++ = map[Pixel];
   140                 ++src;
   141             case 1:
   142                 RGB888_RGB332(Pixel, *src);
   143                 *dst++ = map[Pixel];
   144                 ++src;
   145             }
   146 #endif /* USE_DUFFS_LOOP */
   147             src += srcskip;
   148             dst += dstskip;
   149         }
   150     }
   151 }
   152 
   153 /* Special optimized blit for RGB 8-8-8 --> RGB 5-5-5 */
   154 #define RGB888_RGB555(dst, src) { \
   155 	*(Uint16 *)(dst) = (Uint16)((((*src)&0x00F80000)>>9)| \
   156 	                            (((*src)&0x0000F800)>>6)| \
   157 	                            (((*src)&0x000000F8)>>3)); \
   158 }
   159 #define RGB888_RGB555_TWO(dst, src) { \
   160 	*(Uint32 *)(dst) = (((((src[HI])&0x00F80000)>>9)| \
   161 	                     (((src[HI])&0x0000F800)>>6)| \
   162 	                     (((src[HI])&0x000000F8)>>3))<<16)| \
   163 	                     (((src[LO])&0x00F80000)>>9)| \
   164 	                     (((src[LO])&0x0000F800)>>6)| \
   165 	                     (((src[LO])&0x000000F8)>>3); \
   166 }
   167 static void
   168 Blit_RGB888_RGB555(SDL_BlitInfo * info)
   169 {
   170 #ifndef USE_DUFFS_LOOP
   171     int c;
   172 #endif
   173     int width, height;
   174     Uint32 *src;
   175     Uint16 *dst;
   176     int srcskip, dstskip;
   177 
   178     /* Set up some basic variables */
   179     width = info->dst_w;
   180     height = info->dst_h;
   181     src = (Uint32 *) info->src;
   182     srcskip = info->src_skip / 4;
   183     dst = (Uint16 *) info->dst;
   184     dstskip = info->dst_skip / 2;
   185 
   186 #ifdef USE_DUFFS_LOOP
   187     while (height--) {
   188 		/* *INDENT-OFF* */
   189 		DUFFS_LOOP(
   190 			RGB888_RGB555(dst, src);
   191 			++src;
   192 			++dst;
   193 		, width);
   194 		/* *INDENT-ON* */
   195         src += srcskip;
   196         dst += dstskip;
   197     }
   198 #else
   199     /* Memory align at 4-byte boundary, if necessary */
   200     if ((long) dst & 0x03) {
   201         /* Don't do anything if width is 0 */
   202         if (width == 0) {
   203             return;
   204         }
   205         --width;
   206 
   207         while (height--) {
   208             /* Perform copy alignment */
   209             RGB888_RGB555(dst, src);
   210             ++src;
   211             ++dst;
   212 
   213             /* Copy in 4 pixel chunks */
   214             for (c = width / 4; c; --c) {
   215                 RGB888_RGB555_TWO(dst, src);
   216                 src += 2;
   217                 dst += 2;
   218                 RGB888_RGB555_TWO(dst, src);
   219                 src += 2;
   220                 dst += 2;
   221             }
   222             /* Get any leftovers */
   223             switch (width & 3) {
   224             case 3:
   225                 RGB888_RGB555(dst, src);
   226                 ++src;
   227                 ++dst;
   228             case 2:
   229                 RGB888_RGB555_TWO(dst, src);
   230                 src += 2;
   231                 dst += 2;
   232                 break;
   233             case 1:
   234                 RGB888_RGB555(dst, src);
   235                 ++src;
   236                 ++dst;
   237                 break;
   238             }
   239             src += srcskip;
   240             dst += dstskip;
   241         }
   242     } else {
   243         while (height--) {
   244             /* Copy in 4 pixel chunks */
   245             for (c = width / 4; c; --c) {
   246                 RGB888_RGB555_TWO(dst, src);
   247                 src += 2;
   248                 dst += 2;
   249                 RGB888_RGB555_TWO(dst, src);
   250                 src += 2;
   251                 dst += 2;
   252             }
   253             /* Get any leftovers */
   254             switch (width & 3) {
   255             case 3:
   256                 RGB888_RGB555(dst, src);
   257                 ++src;
   258                 ++dst;
   259             case 2:
   260                 RGB888_RGB555_TWO(dst, src);
   261                 src += 2;
   262                 dst += 2;
   263                 break;
   264             case 1:
   265                 RGB888_RGB555(dst, src);
   266                 ++src;
   267                 ++dst;
   268                 break;
   269             }
   270             src += srcskip;
   271             dst += dstskip;
   272         }
   273     }
   274 #endif /* USE_DUFFS_LOOP */
   275 }
   276 
   277 /* Special optimized blit for RGB 8-8-8 --> RGB 5-6-5 */
   278 #define RGB888_RGB565(dst, src) { \
   279 	*(Uint16 *)(dst) = (Uint16)((((*src)&0x00F80000)>>8)| \
   280 	                            (((*src)&0x0000FC00)>>5)| \
   281 	                            (((*src)&0x000000F8)>>3)); \
   282 }
   283 #define RGB888_RGB565_TWO(dst, src) { \
   284 	*(Uint32 *)(dst) = (((((src[HI])&0x00F80000)>>8)| \
   285 	                     (((src[HI])&0x0000FC00)>>5)| \
   286 	                     (((src[HI])&0x000000F8)>>3))<<16)| \
   287 	                     (((src[LO])&0x00F80000)>>8)| \
   288 	                     (((src[LO])&0x0000FC00)>>5)| \
   289 	                     (((src[LO])&0x000000F8)>>3); \
   290 }
   291 static void
   292 Blit_RGB888_RGB565(SDL_BlitInfo * info)
   293 {
   294 #ifndef USE_DUFFS_LOOP
   295     int c;
   296 #endif
   297     int width, height;
   298     Uint32 *src;
   299     Uint16 *dst;
   300     int srcskip, dstskip;
   301 
   302     /* Set up some basic variables */
   303     width = info->dst_w;
   304     height = info->dst_h;
   305     src = (Uint32 *) info->src;
   306     srcskip = info->src_skip / 4;
   307     dst = (Uint16 *) info->dst;
   308     dstskip = info->dst_skip / 2;
   309 
   310 #ifdef USE_DUFFS_LOOP
   311     while (height--) {
   312 		/* *INDENT-OFF* */
   313 		DUFFS_LOOP(
   314 			RGB888_RGB565(dst, src);
   315 			++src;
   316 			++dst;
   317 		, width);
   318 		/* *INDENT-ON* */
   319         src += srcskip;
   320         dst += dstskip;
   321     }
   322 #else
   323     /* Memory align at 4-byte boundary, if necessary */
   324     if ((long) dst & 0x03) {
   325         /* Don't do anything if width is 0 */
   326         if (width == 0) {
   327             return;
   328         }
   329         --width;
   330 
   331         while (height--) {
   332             /* Perform copy alignment */
   333             RGB888_RGB565(dst, src);
   334             ++src;
   335             ++dst;
   336 
   337             /* Copy in 4 pixel chunks */
   338             for (c = width / 4; c; --c) {
   339                 RGB888_RGB565_TWO(dst, src);
   340                 src += 2;
   341                 dst += 2;
   342                 RGB888_RGB565_TWO(dst, src);
   343                 src += 2;
   344                 dst += 2;
   345             }
   346             /* Get any leftovers */
   347             switch (width & 3) {
   348             case 3:
   349                 RGB888_RGB565(dst, src);
   350                 ++src;
   351                 ++dst;
   352             case 2:
   353                 RGB888_RGB565_TWO(dst, src);
   354                 src += 2;
   355                 dst += 2;
   356                 break;
   357             case 1:
   358                 RGB888_RGB565(dst, src);
   359                 ++src;
   360                 ++dst;
   361                 break;
   362             }
   363             src += srcskip;
   364             dst += dstskip;
   365         }
   366     } else {
   367         while (height--) {
   368             /* Copy in 4 pixel chunks */
   369             for (c = width / 4; c; --c) {
   370                 RGB888_RGB565_TWO(dst, src);
   371                 src += 2;
   372                 dst += 2;
   373                 RGB888_RGB565_TWO(dst, src);
   374                 src += 2;
   375                 dst += 2;
   376             }
   377             /* Get any leftovers */
   378             switch (width & 3) {
   379             case 3:
   380                 RGB888_RGB565(dst, src);
   381                 ++src;
   382                 ++dst;
   383             case 2:
   384                 RGB888_RGB565_TWO(dst, src);
   385                 src += 2;
   386                 dst += 2;
   387                 break;
   388             case 1:
   389                 RGB888_RGB565(dst, src);
   390                 ++src;
   391                 ++dst;
   392                 break;
   393             }
   394             src += srcskip;
   395             dst += dstskip;
   396         }
   397     }
   398 #endif /* USE_DUFFS_LOOP */
   399 }
   400 
   401 
   402 /* Special optimized blit for RGB 5-6-5 --> 32-bit RGB surfaces */
   403 #define RGB565_32(dst, src, map) (map[src[LO]*2] + map[src[HI]*2+1])
   404 static void
   405 Blit_RGB565_32(SDL_BlitInfo * info, const Uint32 * map)
   406 {
   407 #ifndef USE_DUFFS_LOOP
   408     int c;
   409 #endif
   410     int width, height;
   411     Uint8 *src;
   412     Uint32 *dst;
   413     int srcskip, dstskip;
   414 
   415     /* Set up some basic variables */
   416     width = info->dst_w;
   417     height = info->dst_h;
   418     src = (Uint8 *) info->src;
   419     srcskip = info->src_skip;
   420     dst = (Uint32 *) info->dst;
   421     dstskip = info->dst_skip / 4;
   422 
   423 #ifdef USE_DUFFS_LOOP
   424     while (height--) {
   425 		/* *INDENT-OFF* */
   426 		DUFFS_LOOP(
   427 		{
   428 			*dst++ = RGB565_32(dst, src, map);
   429 			src += 2;
   430 		},
   431 		width);
   432 		/* *INDENT-ON* */
   433         src += srcskip;
   434         dst += dstskip;
   435     }
   436 #else
   437     while (height--) {
   438         /* Copy in 4 pixel chunks */
   439         for (c = width / 4; c; --c) {
   440             *dst++ = RGB565_32(dst, src, map);
   441             src += 2;
   442             *dst++ = RGB565_32(dst, src, map);
   443             src += 2;
   444             *dst++ = RGB565_32(dst, src, map);
   445             src += 2;
   446             *dst++ = RGB565_32(dst, src, map);
   447             src += 2;
   448         }
   449         /* Get any leftovers */
   450         switch (width & 3) {
   451         case 3:
   452             *dst++ = RGB565_32(dst, src, map);
   453             src += 2;
   454         case 2:
   455             *dst++ = RGB565_32(dst, src, map);
   456             src += 2;
   457         case 1:
   458             *dst++ = RGB565_32(dst, src, map);
   459             src += 2;
   460             break;
   461         }
   462         src += srcskip;
   463         dst += dstskip;
   464     }
   465 #endif /* USE_DUFFS_LOOP */
   466 }
   467 
   468 /* Special optimized blit for RGB 5-6-5 --> ARGB 8-8-8-8 */
   469 static const Uint32 RGB565_ARGB8888_LUT[512] = {
   470     0x00000000, 0xff000000, 0x00000008, 0xff002000,
   471     0x00000010, 0xff004000, 0x00000018, 0xff006100,
   472     0x00000020, 0xff008100, 0x00000029, 0xff00a100,
   473     0x00000031, 0xff00c200, 0x00000039, 0xff00e200,
   474     0x00000041, 0xff080000, 0x0000004a, 0xff082000,
   475     0x00000052, 0xff084000, 0x0000005a, 0xff086100,
   476     0x00000062, 0xff088100, 0x0000006a, 0xff08a100,
   477     0x00000073, 0xff08c200, 0x0000007b, 0xff08e200,
   478     0x00000083, 0xff100000, 0x0000008b, 0xff102000,
   479     0x00000094, 0xff104000, 0x0000009c, 0xff106100,
   480     0x000000a4, 0xff108100, 0x000000ac, 0xff10a100,
   481     0x000000b4, 0xff10c200, 0x000000bd, 0xff10e200,
   482     0x000000c5, 0xff180000, 0x000000cd, 0xff182000,
   483     0x000000d5, 0xff184000, 0x000000de, 0xff186100,
   484     0x000000e6, 0xff188100, 0x000000ee, 0xff18a100,
   485     0x000000f6, 0xff18c200, 0x000000ff, 0xff18e200,
   486     0x00000400, 0xff200000, 0x00000408, 0xff202000,
   487     0x00000410, 0xff204000, 0x00000418, 0xff206100,
   488     0x00000420, 0xff208100, 0x00000429, 0xff20a100,
   489     0x00000431, 0xff20c200, 0x00000439, 0xff20e200,
   490     0x00000441, 0xff290000, 0x0000044a, 0xff292000,
   491     0x00000452, 0xff294000, 0x0000045a, 0xff296100,
   492     0x00000462, 0xff298100, 0x0000046a, 0xff29a100,
   493     0x00000473, 0xff29c200, 0x0000047b, 0xff29e200,
   494     0x00000483, 0xff310000, 0x0000048b, 0xff312000,
   495     0x00000494, 0xff314000, 0x0000049c, 0xff316100,
   496     0x000004a4, 0xff318100, 0x000004ac, 0xff31a100,
   497     0x000004b4, 0xff31c200, 0x000004bd, 0xff31e200,
   498     0x000004c5, 0xff390000, 0x000004cd, 0xff392000,
   499     0x000004d5, 0xff394000, 0x000004de, 0xff396100,
   500     0x000004e6, 0xff398100, 0x000004ee, 0xff39a100,
   501     0x000004f6, 0xff39c200, 0x000004ff, 0xff39e200,
   502     0x00000800, 0xff410000, 0x00000808, 0xff412000,
   503     0x00000810, 0xff414000, 0x00000818, 0xff416100,
   504     0x00000820, 0xff418100, 0x00000829, 0xff41a100,
   505     0x00000831, 0xff41c200, 0x00000839, 0xff41e200,
   506     0x00000841, 0xff4a0000, 0x0000084a, 0xff4a2000,
   507     0x00000852, 0xff4a4000, 0x0000085a, 0xff4a6100,
   508     0x00000862, 0xff4a8100, 0x0000086a, 0xff4aa100,
   509     0x00000873, 0xff4ac200, 0x0000087b, 0xff4ae200,
   510     0x00000883, 0xff520000, 0x0000088b, 0xff522000,
   511     0x00000894, 0xff524000, 0x0000089c, 0xff526100,
   512     0x000008a4, 0xff528100, 0x000008ac, 0xff52a100,
   513     0x000008b4, 0xff52c200, 0x000008bd, 0xff52e200,
   514     0x000008c5, 0xff5a0000, 0x000008cd, 0xff5a2000,
   515     0x000008d5, 0xff5a4000, 0x000008de, 0xff5a6100,
   516     0x000008e6, 0xff5a8100, 0x000008ee, 0xff5aa100,
   517     0x000008f6, 0xff5ac200, 0x000008ff, 0xff5ae200,
   518     0x00000c00, 0xff620000, 0x00000c08, 0xff622000,
   519     0x00000c10, 0xff624000, 0x00000c18, 0xff626100,
   520     0x00000c20, 0xff628100, 0x00000c29, 0xff62a100,
   521     0x00000c31, 0xff62c200, 0x00000c39, 0xff62e200,
   522     0x00000c41, 0xff6a0000, 0x00000c4a, 0xff6a2000,
   523     0x00000c52, 0xff6a4000, 0x00000c5a, 0xff6a6100,
   524     0x00000c62, 0xff6a8100, 0x00000c6a, 0xff6aa100,
   525     0x00000c73, 0xff6ac200, 0x00000c7b, 0xff6ae200,
   526     0x00000c83, 0xff730000, 0x00000c8b, 0xff732000,
   527     0x00000c94, 0xff734000, 0x00000c9c, 0xff736100,
   528     0x00000ca4, 0xff738100, 0x00000cac, 0xff73a100,
   529     0x00000cb4, 0xff73c200, 0x00000cbd, 0xff73e200,
   530     0x00000cc5, 0xff7b0000, 0x00000ccd, 0xff7b2000,
   531     0x00000cd5, 0xff7b4000, 0x00000cde, 0xff7b6100,
   532     0x00000ce6, 0xff7b8100, 0x00000cee, 0xff7ba100,
   533     0x00000cf6, 0xff7bc200, 0x00000cff, 0xff7be200,
   534     0x00001000, 0xff830000, 0x00001008, 0xff832000,
   535     0x00001010, 0xff834000, 0x00001018, 0xff836100,
   536     0x00001020, 0xff838100, 0x00001029, 0xff83a100,
   537     0x00001031, 0xff83c200, 0x00001039, 0xff83e200,
   538     0x00001041, 0xff8b0000, 0x0000104a, 0xff8b2000,
   539     0x00001052, 0xff8b4000, 0x0000105a, 0xff8b6100,
   540     0x00001062, 0xff8b8100, 0x0000106a, 0xff8ba100,
   541     0x00001073, 0xff8bc200, 0x0000107b, 0xff8be200,
   542     0x00001083, 0xff940000, 0x0000108b, 0xff942000,
   543     0x00001094, 0xff944000, 0x0000109c, 0xff946100,
   544     0x000010a4, 0xff948100, 0x000010ac, 0xff94a100,
   545     0x000010b4, 0xff94c200, 0x000010bd, 0xff94e200,
   546     0x000010c5, 0xff9c0000, 0x000010cd, 0xff9c2000,
   547     0x000010d5, 0xff9c4000, 0x000010de, 0xff9c6100,
   548     0x000010e6, 0xff9c8100, 0x000010ee, 0xff9ca100,
   549     0x000010f6, 0xff9cc200, 0x000010ff, 0xff9ce200,
   550     0x00001400, 0xffa40000, 0x00001408, 0xffa42000,
   551     0x00001410, 0xffa44000, 0x00001418, 0xffa46100,
   552     0x00001420, 0xffa48100, 0x00001429, 0xffa4a100,
   553     0x00001431, 0xffa4c200, 0x00001439, 0xffa4e200,
   554     0x00001441, 0xffac0000, 0x0000144a, 0xffac2000,
   555     0x00001452, 0xffac4000, 0x0000145a, 0xffac6100,
   556     0x00001462, 0xffac8100, 0x0000146a, 0xffaca100,
   557     0x00001473, 0xffacc200, 0x0000147b, 0xfface200,
   558     0x00001483, 0xffb40000, 0x0000148b, 0xffb42000,
   559     0x00001494, 0xffb44000, 0x0000149c, 0xffb46100,
   560     0x000014a4, 0xffb48100, 0x000014ac, 0xffb4a100,
   561     0x000014b4, 0xffb4c200, 0x000014bd, 0xffb4e200,
   562     0x000014c5, 0xffbd0000, 0x000014cd, 0xffbd2000,
   563     0x000014d5, 0xffbd4000, 0x000014de, 0xffbd6100,
   564     0x000014e6, 0xffbd8100, 0x000014ee, 0xffbda100,
   565     0x000014f6, 0xffbdc200, 0x000014ff, 0xffbde200,
   566     0x00001800, 0xffc50000, 0x00001808, 0xffc52000,
   567     0x00001810, 0xffc54000, 0x00001818, 0xffc56100,
   568     0x00001820, 0xffc58100, 0x00001829, 0xffc5a100,
   569     0x00001831, 0xffc5c200, 0x00001839, 0xffc5e200,
   570     0x00001841, 0xffcd0000, 0x0000184a, 0xffcd2000,
   571     0x00001852, 0xffcd4000, 0x0000185a, 0xffcd6100,
   572     0x00001862, 0xffcd8100, 0x0000186a, 0xffcda100,
   573     0x00001873, 0xffcdc200, 0x0000187b, 0xffcde200,
   574     0x00001883, 0xffd50000, 0x0000188b, 0xffd52000,
   575     0x00001894, 0xffd54000, 0x0000189c, 0xffd56100,
   576     0x000018a4, 0xffd58100, 0x000018ac, 0xffd5a100,
   577     0x000018b4, 0xffd5c200, 0x000018bd, 0xffd5e200,
   578     0x000018c5, 0xffde0000, 0x000018cd, 0xffde2000,
   579     0x000018d5, 0xffde4000, 0x000018de, 0xffde6100,
   580     0x000018e6, 0xffde8100, 0x000018ee, 0xffdea100,
   581     0x000018f6, 0xffdec200, 0x000018ff, 0xffdee200,
   582     0x00001c00, 0xffe60000, 0x00001c08, 0xffe62000,
   583     0x00001c10, 0xffe64000, 0x00001c18, 0xffe66100,
   584     0x00001c20, 0xffe68100, 0x00001c29, 0xffe6a100,
   585     0x00001c31, 0xffe6c200, 0x00001c39, 0xffe6e200,
   586     0x00001c41, 0xffee0000, 0x00001c4a, 0xffee2000,
   587     0x00001c52, 0xffee4000, 0x00001c5a, 0xffee6100,
   588     0x00001c62, 0xffee8100, 0x00001c6a, 0xffeea100,
   589     0x00001c73, 0xffeec200, 0x00001c7b, 0xffeee200,
   590     0x00001c83, 0xfff60000, 0x00001c8b, 0xfff62000,
   591     0x00001c94, 0xfff64000, 0x00001c9c, 0xfff66100,
   592     0x00001ca4, 0xfff68100, 0x00001cac, 0xfff6a100,
   593     0x00001cb4, 0xfff6c200, 0x00001cbd, 0xfff6e200,
   594     0x00001cc5, 0xffff0000, 0x00001ccd, 0xffff2000,
   595     0x00001cd5, 0xffff4000, 0x00001cde, 0xffff6100,
   596     0x00001ce6, 0xffff8100, 0x00001cee, 0xffffa100,
   597     0x00001cf6, 0xffffc200, 0x00001cff, 0xffffe200
   598 };
   599 
   600 static void
   601 Blit_RGB565_ARGB8888(SDL_BlitInfo * info)
   602 {
   603     Blit_RGB565_32(info, RGB565_ARGB8888_LUT);
   604 }
   605 
   606 /* Special optimized blit for RGB 5-6-5 --> ABGR 8-8-8-8 */
   607 static const Uint32 RGB565_ABGR8888_LUT[512] = {
   608     0xff000000, 0x00000000, 0xff080000, 0x00002000,
   609     0xff100000, 0x00004000, 0xff180000, 0x00006100,
   610     0xff200000, 0x00008100, 0xff290000, 0x0000a100,
   611     0xff310000, 0x0000c200, 0xff390000, 0x0000e200,
   612     0xff410000, 0x00000008, 0xff4a0000, 0x00002008,
   613     0xff520000, 0x00004008, 0xff5a0000, 0x00006108,
   614     0xff620000, 0x00008108, 0xff6a0000, 0x0000a108,
   615     0xff730000, 0x0000c208, 0xff7b0000, 0x0000e208,
   616     0xff830000, 0x00000010, 0xff8b0000, 0x00002010,
   617     0xff940000, 0x00004010, 0xff9c0000, 0x00006110,
   618     0xffa40000, 0x00008110, 0xffac0000, 0x0000a110,
   619     0xffb40000, 0x0000c210, 0xffbd0000, 0x0000e210,
   620     0xffc50000, 0x00000018, 0xffcd0000, 0x00002018,
   621     0xffd50000, 0x00004018, 0xffde0000, 0x00006118,
   622     0xffe60000, 0x00008118, 0xffee0000, 0x0000a118,
   623     0xfff60000, 0x0000c218, 0xffff0000, 0x0000e218,
   624     0xff000400, 0x00000020, 0xff080400, 0x00002020,
   625     0xff100400, 0x00004020, 0xff180400, 0x00006120,
   626     0xff200400, 0x00008120, 0xff290400, 0x0000a120,
   627     0xff310400, 0x0000c220, 0xff390400, 0x0000e220,
   628     0xff410400, 0x00000029, 0xff4a0400, 0x00002029,
   629     0xff520400, 0x00004029, 0xff5a0400, 0x00006129,
   630     0xff620400, 0x00008129, 0xff6a0400, 0x0000a129,
   631     0xff730400, 0x0000c229, 0xff7b0400, 0x0000e229,
   632     0xff830400, 0x00000031, 0xff8b0400, 0x00002031,
   633     0xff940400, 0x00004031, 0xff9c0400, 0x00006131,
   634     0xffa40400, 0x00008131, 0xffac0400, 0x0000a131,
   635     0xffb40400, 0x0000c231, 0xffbd0400, 0x0000e231,
   636     0xffc50400, 0x00000039, 0xffcd0400, 0x00002039,
   637     0xffd50400, 0x00004039, 0xffde0400, 0x00006139,
   638     0xffe60400, 0x00008139, 0xffee0400, 0x0000a139,
   639     0xfff60400, 0x0000c239, 0xffff0400, 0x0000e239,
   640     0xff000800, 0x00000041, 0xff080800, 0x00002041,
   641     0xff100800, 0x00004041, 0xff180800, 0x00006141,
   642     0xff200800, 0x00008141, 0xff290800, 0x0000a141,
   643     0xff310800, 0x0000c241, 0xff390800, 0x0000e241,
   644     0xff410800, 0x0000004a, 0xff4a0800, 0x0000204a,
   645     0xff520800, 0x0000404a, 0xff5a0800, 0x0000614a,
   646     0xff620800, 0x0000814a, 0xff6a0800, 0x0000a14a,
   647     0xff730800, 0x0000c24a, 0xff7b0800, 0x0000e24a,
   648     0xff830800, 0x00000052, 0xff8b0800, 0x00002052,
   649     0xff940800, 0x00004052, 0xff9c0800, 0x00006152,
   650     0xffa40800, 0x00008152, 0xffac0800, 0x0000a152,
   651     0xffb40800, 0x0000c252, 0xffbd0800, 0x0000e252,
   652     0xffc50800, 0x0000005a, 0xffcd0800, 0x0000205a,
   653     0xffd50800, 0x0000405a, 0xffde0800, 0x0000615a,
   654     0xffe60800, 0x0000815a, 0xffee0800, 0x0000a15a,
   655     0xfff60800, 0x0000c25a, 0xffff0800, 0x0000e25a,
   656     0xff000c00, 0x00000062, 0xff080c00, 0x00002062,
   657     0xff100c00, 0x00004062, 0xff180c00, 0x00006162,
   658     0xff200c00, 0x00008162, 0xff290c00, 0x0000a162,
   659     0xff310c00, 0x0000c262, 0xff390c00, 0x0000e262,
   660     0xff410c00, 0x0000006a, 0xff4a0c00, 0x0000206a,
   661     0xff520c00, 0x0000406a, 0xff5a0c00, 0x0000616a,
   662     0xff620c00, 0x0000816a, 0xff6a0c00, 0x0000a16a,
   663     0xff730c00, 0x0000c26a, 0xff7b0c00, 0x0000e26a,
   664     0xff830c00, 0x00000073, 0xff8b0c00, 0x00002073,
   665     0xff940c00, 0x00004073, 0xff9c0c00, 0x00006173,
   666     0xffa40c00, 0x00008173, 0xffac0c00, 0x0000a173,
   667     0xffb40c00, 0x0000c273, 0xffbd0c00, 0x0000e273,
   668     0xffc50c00, 0x0000007b, 0xffcd0c00, 0x0000207b,
   669     0xffd50c00, 0x0000407b, 0xffde0c00, 0x0000617b,
   670     0xffe60c00, 0x0000817b, 0xffee0c00, 0x0000a17b,
   671     0xfff60c00, 0x0000c27b, 0xffff0c00, 0x0000e27b,
   672     0xff001000, 0x00000083, 0xff081000, 0x00002083,
   673     0xff101000, 0x00004083, 0xff181000, 0x00006183,
   674     0xff201000, 0x00008183, 0xff291000, 0x0000a183,
   675     0xff311000, 0x0000c283, 0xff391000, 0x0000e283,
   676     0xff411000, 0x0000008b, 0xff4a1000, 0x0000208b,
   677     0xff521000, 0x0000408b, 0xff5a1000, 0x0000618b,
   678     0xff621000, 0x0000818b, 0xff6a1000, 0x0000a18b,
   679     0xff731000, 0x0000c28b, 0xff7b1000, 0x0000e28b,
   680     0xff831000, 0x00000094, 0xff8b1000, 0x00002094,
   681     0xff941000, 0x00004094, 0xff9c1000, 0x00006194,
   682     0xffa41000, 0x00008194, 0xffac1000, 0x0000a194,
   683     0xffb41000, 0x0000c294, 0xffbd1000, 0x0000e294,
   684     0xffc51000, 0x0000009c, 0xffcd1000, 0x0000209c,
   685     0xffd51000, 0x0000409c, 0xffde1000, 0x0000619c,
   686     0xffe61000, 0x0000819c, 0xffee1000, 0x0000a19c,
   687     0xfff61000, 0x0000c29c, 0xffff1000, 0x0000e29c,
   688     0xff001400, 0x000000a4, 0xff081400, 0x000020a4,
   689     0xff101400, 0x000040a4, 0xff181400, 0x000061a4,
   690     0xff201400, 0x000081a4, 0xff291400, 0x0000a1a4,
   691     0xff311400, 0x0000c2a4, 0xff391400, 0x0000e2a4,
   692     0xff411400, 0x000000ac, 0xff4a1400, 0x000020ac,
   693     0xff521400, 0x000040ac, 0xff5a1400, 0x000061ac,
   694     0xff621400, 0x000081ac, 0xff6a1400, 0x0000a1ac,
   695     0xff731400, 0x0000c2ac, 0xff7b1400, 0x0000e2ac,
   696     0xff831400, 0x000000b4, 0xff8b1400, 0x000020b4,
   697     0xff941400, 0x000040b4, 0xff9c1400, 0x000061b4,
   698     0xffa41400, 0x000081b4, 0xffac1400, 0x0000a1b4,
   699     0xffb41400, 0x0000c2b4, 0xffbd1400, 0x0000e2b4,
   700     0xffc51400, 0x000000bd, 0xffcd1400, 0x000020bd,
   701     0xffd51400, 0x000040bd, 0xffde1400, 0x000061bd,
   702     0xffe61400, 0x000081bd, 0xffee1400, 0x0000a1bd,
   703     0xfff61400, 0x0000c2bd, 0xffff1400, 0x0000e2bd,
   704     0xff001800, 0x000000c5, 0xff081800, 0x000020c5,
   705     0xff101800, 0x000040c5, 0xff181800, 0x000061c5,
   706     0xff201800, 0x000081c5, 0xff291800, 0x0000a1c5,
   707     0xff311800, 0x0000c2c5, 0xff391800, 0x0000e2c5,
   708     0xff411800, 0x000000cd, 0xff4a1800, 0x000020cd,
   709     0xff521800, 0x000040cd, 0xff5a1800, 0x000061cd,
   710     0xff621800, 0x000081cd, 0xff6a1800, 0x0000a1cd,
   711     0xff731800, 0x0000c2cd, 0xff7b1800, 0x0000e2cd,
   712     0xff831800, 0x000000d5, 0xff8b1800, 0x000020d5,
   713     0xff941800, 0x000040d5, 0xff9c1800, 0x000061d5,
   714     0xffa41800, 0x000081d5, 0xffac1800, 0x0000a1d5,
   715     0xffb41800, 0x0000c2d5, 0xffbd1800, 0x0000e2d5,
   716     0xffc51800, 0x000000de, 0xffcd1800, 0x000020de,
   717     0xffd51800, 0x000040de, 0xffde1800, 0x000061de,
   718     0xffe61800, 0x000081de, 0xffee1800, 0x0000a1de,
   719     0xfff61800, 0x0000c2de, 0xffff1800, 0x0000e2de,
   720     0xff001c00, 0x000000e6, 0xff081c00, 0x000020e6,
   721     0xff101c00, 0x000040e6, 0xff181c00, 0x000061e6,
   722     0xff201c00, 0x000081e6, 0xff291c00, 0x0000a1e6,
   723     0xff311c00, 0x0000c2e6, 0xff391c00, 0x0000e2e6,
   724     0xff411c00, 0x000000ee, 0xff4a1c00, 0x000020ee,
   725     0xff521c00, 0x000040ee, 0xff5a1c00, 0x000061ee,
   726     0xff621c00, 0x000081ee, 0xff6a1c00, 0x0000a1ee,
   727     0xff731c00, 0x0000c2ee, 0xff7b1c00, 0x0000e2ee,
   728     0xff831c00, 0x000000f6, 0xff8b1c00, 0x000020f6,
   729     0xff941c00, 0x000040f6, 0xff9c1c00, 0x000061f6,
   730     0xffa41c00, 0x000081f6, 0xffac1c00, 0x0000a1f6,
   731     0xffb41c00, 0x0000c2f6, 0xffbd1c00, 0x0000e2f6,
   732     0xffc51c00, 0x000000ff, 0xffcd1c00, 0x000020ff,
   733     0xffd51c00, 0x000040ff, 0xffde1c00, 0x000061ff,
   734     0xffe61c00, 0x000081ff, 0xffee1c00, 0x0000a1ff,
   735     0xfff61c00, 0x0000c2ff, 0xffff1c00, 0x0000e2ff
   736 };
   737 
   738 static void
   739 Blit_RGB565_ABGR8888(SDL_BlitInfo * info)
   740 {
   741     Blit_RGB565_32(info, RGB565_ABGR8888_LUT);
   742 }
   743 
   744 /* Special optimized blit for RGB 5-6-5 --> RGBA 8-8-8-8 */
   745 static const Uint32 RGB565_RGBA8888_LUT[512] = {
   746     0x000000ff, 0x00000000, 0x000008ff, 0x00200000,
   747     0x000010ff, 0x00400000, 0x000018ff, 0x00610000,
   748     0x000020ff, 0x00810000, 0x000029ff, 0x00a10000,
   749     0x000031ff, 0x00c20000, 0x000039ff, 0x00e20000,
   750     0x000041ff, 0x08000000, 0x00004aff, 0x08200000,
   751     0x000052ff, 0x08400000, 0x00005aff, 0x08610000,
   752     0x000062ff, 0x08810000, 0x00006aff, 0x08a10000,
   753     0x000073ff, 0x08c20000, 0x00007bff, 0x08e20000,
   754     0x000083ff, 0x10000000, 0x00008bff, 0x10200000,
   755     0x000094ff, 0x10400000, 0x00009cff, 0x10610000,
   756     0x0000a4ff, 0x10810000, 0x0000acff, 0x10a10000,
   757     0x0000b4ff, 0x10c20000, 0x0000bdff, 0x10e20000,
   758     0x0000c5ff, 0x18000000, 0x0000cdff, 0x18200000,
   759     0x0000d5ff, 0x18400000, 0x0000deff, 0x18610000,
   760     0x0000e6ff, 0x18810000, 0x0000eeff, 0x18a10000,
   761     0x0000f6ff, 0x18c20000, 0x0000ffff, 0x18e20000,
   762     0x000400ff, 0x20000000, 0x000408ff, 0x20200000,
   763     0x000410ff, 0x20400000, 0x000418ff, 0x20610000,
   764     0x000420ff, 0x20810000, 0x000429ff, 0x20a10000,
   765     0x000431ff, 0x20c20000, 0x000439ff, 0x20e20000,
   766     0x000441ff, 0x29000000, 0x00044aff, 0x29200000,
   767     0x000452ff, 0x29400000, 0x00045aff, 0x29610000,
   768     0x000462ff, 0x29810000, 0x00046aff, 0x29a10000,
   769     0x000473ff, 0x29c20000, 0x00047bff, 0x29e20000,
   770     0x000483ff, 0x31000000, 0x00048bff, 0x31200000,
   771     0x000494ff, 0x31400000, 0x00049cff, 0x31610000,
   772     0x0004a4ff, 0x31810000, 0x0004acff, 0x31a10000,
   773     0x0004b4ff, 0x31c20000, 0x0004bdff, 0x31e20000,
   774     0x0004c5ff, 0x39000000, 0x0004cdff, 0x39200000,
   775     0x0004d5ff, 0x39400000, 0x0004deff, 0x39610000,
   776     0x0004e6ff, 0x39810000, 0x0004eeff, 0x39a10000,
   777     0x0004f6ff, 0x39c20000, 0x0004ffff, 0x39e20000,
   778     0x000800ff, 0x41000000, 0x000808ff, 0x41200000,
   779     0x000810ff, 0x41400000, 0x000818ff, 0x41610000,
   780     0x000820ff, 0x41810000, 0x000829ff, 0x41a10000,
   781     0x000831ff, 0x41c20000, 0x000839ff, 0x41e20000,
   782     0x000841ff, 0x4a000000, 0x00084aff, 0x4a200000,
   783     0x000852ff, 0x4a400000, 0x00085aff, 0x4a610000,
   784     0x000862ff, 0x4a810000, 0x00086aff, 0x4aa10000,
   785     0x000873ff, 0x4ac20000, 0x00087bff, 0x4ae20000,
   786     0x000883ff, 0x52000000, 0x00088bff, 0x52200000,
   787     0x000894ff, 0x52400000, 0x00089cff, 0x52610000,
   788     0x0008a4ff, 0x52810000, 0x0008acff, 0x52a10000,
   789     0x0008b4ff, 0x52c20000, 0x0008bdff, 0x52e20000,
   790     0x0008c5ff, 0x5a000000, 0x0008cdff, 0x5a200000,
   791     0x0008d5ff, 0x5a400000, 0x0008deff, 0x5a610000,
   792     0x0008e6ff, 0x5a810000, 0x0008eeff, 0x5aa10000,
   793     0x0008f6ff, 0x5ac20000, 0x0008ffff, 0x5ae20000,
   794     0x000c00ff, 0x62000000, 0x000c08ff, 0x62200000,
   795     0x000c10ff, 0x62400000, 0x000c18ff, 0x62610000,
   796     0x000c20ff, 0x62810000, 0x000c29ff, 0x62a10000,
   797     0x000c31ff, 0x62c20000, 0x000c39ff, 0x62e20000,
   798     0x000c41ff, 0x6a000000, 0x000c4aff, 0x6a200000,
   799     0x000c52ff, 0x6a400000, 0x000c5aff, 0x6a610000,
   800     0x000c62ff, 0x6a810000, 0x000c6aff, 0x6aa10000,
   801     0x000c73ff, 0x6ac20000, 0x000c7bff, 0x6ae20000,
   802     0x000c83ff, 0x73000000, 0x000c8bff, 0x73200000,
   803     0x000c94ff, 0x73400000, 0x000c9cff, 0x73610000,
   804     0x000ca4ff, 0x73810000, 0x000cacff, 0x73a10000,
   805     0x000cb4ff, 0x73c20000, 0x000cbdff, 0x73e20000,
   806     0x000cc5ff, 0x7b000000, 0x000ccdff, 0x7b200000,
   807     0x000cd5ff, 0x7b400000, 0x000cdeff, 0x7b610000,
   808     0x000ce6ff, 0x7b810000, 0x000ceeff, 0x7ba10000,
   809     0x000cf6ff, 0x7bc20000, 0x000cffff, 0x7be20000,
   810     0x001000ff, 0x83000000, 0x001008ff, 0x83200000,
   811     0x001010ff, 0x83400000, 0x001018ff, 0x83610000,
   812     0x001020ff, 0x83810000, 0x001029ff, 0x83a10000,
   813     0x001031ff, 0x83c20000, 0x001039ff, 0x83e20000,
   814     0x001041ff, 0x8b000000, 0x00104aff, 0x8b200000,
   815     0x001052ff, 0x8b400000, 0x00105aff, 0x8b610000,
   816     0x001062ff, 0x8b810000, 0x00106aff, 0x8ba10000,
   817     0x001073ff, 0x8bc20000, 0x00107bff, 0x8be20000,
   818     0x001083ff, 0x94000000, 0x00108bff, 0x94200000,
   819     0x001094ff, 0x94400000, 0x00109cff, 0x94610000,
   820     0x0010a4ff, 0x94810000, 0x0010acff, 0x94a10000,
   821     0x0010b4ff, 0x94c20000, 0x0010bdff, 0x94e20000,
   822     0x0010c5ff, 0x9c000000, 0x0010cdff, 0x9c200000,
   823     0x0010d5ff, 0x9c400000, 0x0010deff, 0x9c610000,
   824     0x0010e6ff, 0x9c810000, 0x0010eeff, 0x9ca10000,
   825     0x0010f6ff, 0x9cc20000, 0x0010ffff, 0x9ce20000,
   826     0x001400ff, 0xa4000000, 0x001408ff, 0xa4200000,
   827     0x001410ff, 0xa4400000, 0x001418ff, 0xa4610000,
   828     0x001420ff, 0xa4810000, 0x001429ff, 0xa4a10000,
   829     0x001431ff, 0xa4c20000, 0x001439ff, 0xa4e20000,
   830     0x001441ff, 0xac000000, 0x00144aff, 0xac200000,
   831     0x001452ff, 0xac400000, 0x00145aff, 0xac610000,
   832     0x001462ff, 0xac810000, 0x00146aff, 0xaca10000,
   833     0x001473ff, 0xacc20000, 0x00147bff, 0xace20000,
   834     0x001483ff, 0xb4000000, 0x00148bff, 0xb4200000,
   835     0x001494ff, 0xb4400000, 0x00149cff, 0xb4610000,
   836     0x0014a4ff, 0xb4810000, 0x0014acff, 0xb4a10000,
   837     0x0014b4ff, 0xb4c20000, 0x0014bdff, 0xb4e20000,
   838     0x0014c5ff, 0xbd000000, 0x0014cdff, 0xbd200000,
   839     0x0014d5ff, 0xbd400000, 0x0014deff, 0xbd610000,
   840     0x0014e6ff, 0xbd810000, 0x0014eeff, 0xbda10000,
   841     0x0014f6ff, 0xbdc20000, 0x0014ffff, 0xbde20000,
   842     0x001800ff, 0xc5000000, 0x001808ff, 0xc5200000,
   843     0x001810ff, 0xc5400000, 0x001818ff, 0xc5610000,
   844     0x001820ff, 0xc5810000, 0x001829ff, 0xc5a10000,
   845     0x001831ff, 0xc5c20000, 0x001839ff, 0xc5e20000,
   846     0x001841ff, 0xcd000000, 0x00184aff, 0xcd200000,
   847     0x001852ff, 0xcd400000, 0x00185aff, 0xcd610000,
   848     0x001862ff, 0xcd810000, 0x00186aff, 0xcda10000,
   849     0x001873ff, 0xcdc20000, 0x00187bff, 0xcde20000,
   850     0x001883ff, 0xd5000000, 0x00188bff, 0xd5200000,
   851     0x001894ff, 0xd5400000, 0x00189cff, 0xd5610000,
   852     0x0018a4ff, 0xd5810000, 0x0018acff, 0xd5a10000,
   853     0x0018b4ff, 0xd5c20000, 0x0018bdff, 0xd5e20000,
   854     0x0018c5ff, 0xde000000, 0x0018cdff, 0xde200000,
   855     0x0018d5ff, 0xde400000, 0x0018deff, 0xde610000,
   856     0x0018e6ff, 0xde810000, 0x0018eeff, 0xdea10000,
   857     0x0018f6ff, 0xdec20000, 0x0018ffff, 0xdee20000,
   858     0x001c00ff, 0xe6000000, 0x001c08ff, 0xe6200000,
   859     0x001c10ff, 0xe6400000, 0x001c18ff, 0xe6610000,
   860     0x001c20ff, 0xe6810000, 0x001c29ff, 0xe6a10000,
   861     0x001c31ff, 0xe6c20000, 0x001c39ff, 0xe6e20000,
   862     0x001c41ff, 0xee000000, 0x001c4aff, 0xee200000,
   863     0x001c52ff, 0xee400000, 0x001c5aff, 0xee610000,
   864     0x001c62ff, 0xee810000, 0x001c6aff, 0xeea10000,
   865     0x001c73ff, 0xeec20000, 0x001c7bff, 0xeee20000,
   866     0x001c83ff, 0xf6000000, 0x001c8bff, 0xf6200000,
   867     0x001c94ff, 0xf6400000, 0x001c9cff, 0xf6610000,
   868     0x001ca4ff, 0xf6810000, 0x001cacff, 0xf6a10000,
   869     0x001cb4ff, 0xf6c20000, 0x001cbdff, 0xf6e20000,
   870     0x001cc5ff, 0xff000000, 0x001ccdff, 0xff200000,
   871     0x001cd5ff, 0xff400000, 0x001cdeff, 0xff610000,
   872     0x001ce6ff, 0xff810000, 0x001ceeff, 0xffa10000,
   873     0x001cf6ff, 0xffc20000, 0x001cffff, 0xffe20000,
   874 };
   875 
   876 static void
   877 Blit_RGB565_RGBA8888(SDL_BlitInfo * info)
   878 {
   879     Blit_RGB565_32(info, RGB565_RGBA8888_LUT);
   880 }
   881 
   882 /* Special optimized blit for RGB 5-6-5 --> BGRA 8-8-8-8 */
   883 static const Uint32 RGB565_BGRA8888_LUT[512] = {
   884     0x00000000, 0x000000ff, 0x08000000, 0x002000ff,
   885     0x10000000, 0x004000ff, 0x18000000, 0x006100ff,
   886     0x20000000, 0x008100ff, 0x29000000, 0x00a100ff,
   887     0x31000000, 0x00c200ff, 0x39000000, 0x00e200ff,
   888     0x41000000, 0x000008ff, 0x4a000000, 0x002008ff,
   889     0x52000000, 0x004008ff, 0x5a000000, 0x006108ff,
   890     0x62000000, 0x008108ff, 0x6a000000, 0x00a108ff,
   891     0x73000000, 0x00c208ff, 0x7b000000, 0x00e208ff,
   892     0x83000000, 0x000010ff, 0x8b000000, 0x002010ff,
   893     0x94000000, 0x004010ff, 0x9c000000, 0x006110ff,
   894     0xa4000000, 0x008110ff, 0xac000000, 0x00a110ff,
   895     0xb4000000, 0x00c210ff, 0xbd000000, 0x00e210ff,
   896     0xc5000000, 0x000018ff, 0xcd000000, 0x002018ff,
   897     0xd5000000, 0x004018ff, 0xde000000, 0x006118ff,
   898     0xe6000000, 0x008118ff, 0xee000000, 0x00a118ff,
   899     0xf6000000, 0x00c218ff, 0xff000000, 0x00e218ff,
   900     0x00040000, 0x000020ff, 0x08040000, 0x002020ff,
   901     0x10040000, 0x004020ff, 0x18040000, 0x006120ff,
   902     0x20040000, 0x008120ff, 0x29040000, 0x00a120ff,
   903     0x31040000, 0x00c220ff, 0x39040000, 0x00e220ff,
   904     0x41040000, 0x000029ff, 0x4a040000, 0x002029ff,
   905     0x52040000, 0x004029ff, 0x5a040000, 0x006129ff,
   906     0x62040000, 0x008129ff, 0x6a040000, 0x00a129ff,
   907     0x73040000, 0x00c229ff, 0x7b040000, 0x00e229ff,
   908     0x83040000, 0x000031ff, 0x8b040000, 0x002031ff,
   909     0x94040000, 0x004031ff, 0x9c040000, 0x006131ff,
   910     0xa4040000, 0x008131ff, 0xac040000, 0x00a131ff,
   911     0xb4040000, 0x00c231ff, 0xbd040000, 0x00e231ff,
   912     0xc5040000, 0x000039ff, 0xcd040000, 0x002039ff,
   913     0xd5040000, 0x004039ff, 0xde040000, 0x006139ff,
   914     0xe6040000, 0x008139ff, 0xee040000, 0x00a139ff,
   915     0xf6040000, 0x00c239ff, 0xff040000, 0x00e239ff,
   916     0x00080000, 0x000041ff, 0x08080000, 0x002041ff,
   917     0x10080000, 0x004041ff, 0x18080000, 0x006141ff,
   918     0x20080000, 0x008141ff, 0x29080000, 0x00a141ff,
   919     0x31080000, 0x00c241ff, 0x39080000, 0x00e241ff,
   920     0x41080000, 0x00004aff, 0x4a080000, 0x00204aff,
   921     0x52080000, 0x00404aff, 0x5a080000, 0x00614aff,
   922     0x62080000, 0x00814aff, 0x6a080000, 0x00a14aff,
   923     0x73080000, 0x00c24aff, 0x7b080000, 0x00e24aff,
   924     0x83080000, 0x000052ff, 0x8b080000, 0x002052ff,
   925     0x94080000, 0x004052ff, 0x9c080000, 0x006152ff,
   926     0xa4080000, 0x008152ff, 0xac080000, 0x00a152ff,
   927     0xb4080000, 0x00c252ff, 0xbd080000, 0x00e252ff,
   928     0xc5080000, 0x00005aff, 0xcd080000, 0x00205aff,
   929     0xd5080000, 0x00405aff, 0xde080000, 0x00615aff,
   930     0xe6080000, 0x00815aff, 0xee080000, 0x00a15aff,
   931     0xf6080000, 0x00c25aff, 0xff080000, 0x00e25aff,
   932     0x000c0000, 0x000062ff, 0x080c0000, 0x002062ff,
   933     0x100c0000, 0x004062ff, 0x180c0000, 0x006162ff,
   934     0x200c0000, 0x008162ff, 0x290c0000, 0x00a162ff,
   935     0x310c0000, 0x00c262ff, 0x390c0000, 0x00e262ff,
   936     0x410c0000, 0x00006aff, 0x4a0c0000, 0x00206aff,
   937     0x520c0000, 0x00406aff, 0x5a0c0000, 0x00616aff,
   938     0x620c0000, 0x00816aff, 0x6a0c0000, 0x00a16aff,
   939     0x730c0000, 0x00c26aff, 0x7b0c0000, 0x00e26aff,
   940     0x830c0000, 0x000073ff, 0x8b0c0000, 0x002073ff,
   941     0x940c0000, 0x004073ff, 0x9c0c0000, 0x006173ff,
   942     0xa40c0000, 0x008173ff, 0xac0c0000, 0x00a173ff,
   943     0xb40c0000, 0x00c273ff, 0xbd0c0000, 0x00e273ff,
   944     0xc50c0000, 0x00007bff, 0xcd0c0000, 0x00207bff,
   945     0xd50c0000, 0x00407bff, 0xde0c0000, 0x00617bff,
   946     0xe60c0000, 0x00817bff, 0xee0c0000, 0x00a17bff,
   947     0xf60c0000, 0x00c27bff, 0xff0c0000, 0x00e27bff,
   948     0x00100000, 0x000083ff, 0x08100000, 0x002083ff,
   949     0x10100000, 0x004083ff, 0x18100000, 0x006183ff,
   950     0x20100000, 0x008183ff, 0x29100000, 0x00a183ff,
   951     0x31100000, 0x00c283ff, 0x39100000, 0x00e283ff,
   952     0x41100000, 0x00008bff, 0x4a100000, 0x00208bff,
   953     0x52100000, 0x00408bff, 0x5a100000, 0x00618bff,
   954     0x62100000, 0x00818bff, 0x6a100000, 0x00a18bff,
   955     0x73100000, 0x00c28bff, 0x7b100000, 0x00e28bff,
   956     0x83100000, 0x000094ff, 0x8b100000, 0x002094ff,
   957     0x94100000, 0x004094ff, 0x9c100000, 0x006194ff,
   958     0xa4100000, 0x008194ff, 0xac100000, 0x00a194ff,
   959     0xb4100000, 0x00c294ff, 0xbd100000, 0x00e294ff,
   960     0xc5100000, 0x00009cff, 0xcd100000, 0x00209cff,
   961     0xd5100000, 0x00409cff, 0xde100000, 0x00619cff,
   962     0xe6100000, 0x00819cff, 0xee100000, 0x00a19cff,
   963     0xf6100000, 0x00c29cff, 0xff100000, 0x00e29cff,
   964     0x00140000, 0x0000a4ff, 0x08140000, 0x0020a4ff,
   965     0x10140000, 0x0040a4ff, 0x18140000, 0x0061a4ff,
   966     0x20140000, 0x0081a4ff, 0x29140000, 0x00a1a4ff,
   967     0x31140000, 0x00c2a4ff, 0x39140000, 0x00e2a4ff,
   968     0x41140000, 0x0000acff, 0x4a140000, 0x0020acff,
   969     0x52140000, 0x0040acff, 0x5a140000, 0x0061acff,
   970     0x62140000, 0x0081acff, 0x6a140000, 0x00a1acff,
   971     0x73140000, 0x00c2acff, 0x7b140000, 0x00e2acff,
   972     0x83140000, 0x0000b4ff, 0x8b140000, 0x0020b4ff,
   973     0x94140000, 0x0040b4ff, 0x9c140000, 0x0061b4ff,
   974     0xa4140000, 0x0081b4ff, 0xac140000, 0x00a1b4ff,
   975     0xb4140000, 0x00c2b4ff, 0xbd140000, 0x00e2b4ff,
   976     0xc5140000, 0x0000bdff, 0xcd140000, 0x0020bdff,
   977     0xd5140000, 0x0040bdff, 0xde140000, 0x0061bdff,
   978     0xe6140000, 0x0081bdff, 0xee140000, 0x00a1bdff,
   979     0xf6140000, 0x00c2bdff, 0xff140000, 0x00e2bdff,
   980     0x00180000, 0x0000c5ff, 0x08180000, 0x0020c5ff,
   981     0x10180000, 0x0040c5ff, 0x18180000, 0x0061c5ff,
   982     0x20180000, 0x0081c5ff, 0x29180000, 0x00a1c5ff,
   983     0x31180000, 0x00c2c5ff, 0x39180000, 0x00e2c5ff,
   984     0x41180000, 0x0000cdff, 0x4a180000, 0x0020cdff,
   985     0x52180000, 0x0040cdff, 0x5a180000, 0x0061cdff,
   986     0x62180000, 0x0081cdff, 0x6a180000, 0x00a1cdff,
   987     0x73180000, 0x00c2cdff, 0x7b180000, 0x00e2cdff,
   988     0x83180000, 0x0000d5ff, 0x8b180000, 0x0020d5ff,
   989     0x94180000, 0x0040d5ff, 0x9c180000, 0x0061d5ff,
   990     0xa4180000, 0x0081d5ff, 0xac180000, 0x00a1d5ff,
   991     0xb4180000, 0x00c2d5ff, 0xbd180000, 0x00e2d5ff,
   992     0xc5180000, 0x0000deff, 0xcd180000, 0x0020deff,
   993     0xd5180000, 0x0040deff, 0xde180000, 0x0061deff,
   994     0xe6180000, 0x0081deff, 0xee180000, 0x00a1deff,
   995     0xf6180000, 0x00c2deff, 0xff180000, 0x00e2deff,
   996     0x001c0000, 0x0000e6ff, 0x081c0000, 0x0020e6ff,
   997     0x101c0000, 0x0040e6ff, 0x181c0000, 0x0061e6ff,
   998     0x201c0000, 0x0081e6ff, 0x291c0000, 0x00a1e6ff,
   999     0x311c0000, 0x00c2e6ff, 0x391c0000, 0x00e2e6ff,
  1000     0x411c0000, 0x0000eeff, 0x4a1c0000, 0x0020eeff,
  1001     0x521c0000, 0x0040eeff, 0x5a1c0000, 0x0061eeff,
  1002     0x621c0000, 0x0081eeff, 0x6a1c0000, 0x00a1eeff,
  1003     0x731c0000, 0x00c2eeff, 0x7b1c0000, 0x00e2eeff,
  1004     0x831c0000, 0x0000f6ff, 0x8b1c0000, 0x0020f6ff,
  1005     0x941c0000, 0x0040f6ff, 0x9c1c0000, 0x0061f6ff,
  1006     0xa41c0000, 0x0081f6ff, 0xac1c0000, 0x00a1f6ff,
  1007     0xb41c0000, 0x00c2f6ff, 0xbd1c0000, 0x00e2f6ff,
  1008     0xc51c0000, 0x0000ffff, 0xcd1c0000, 0x0020ffff,
  1009     0xd51c0000, 0x0040ffff, 0xde1c0000, 0x0061ffff,
  1010     0xe61c0000, 0x0081ffff, 0xee1c0000, 0x00a1ffff,
  1011     0xf61c0000, 0x00c2ffff, 0xff1c0000, 0x00e2ffff
  1012 };
  1013 
  1014 static void
  1015 Blit_RGB565_BGRA8888(SDL_BlitInfo * info)
  1016 {
  1017     Blit_RGB565_32(info, RGB565_BGRA8888_LUT);
  1018 }
  1019 
  1020 /* Special optimized blit for RGB 8-8-8 --> RGB 3-3-2 */
  1021 #ifndef RGB888_RGB332
  1022 #define RGB888_RGB332(dst, src) { \
  1023 	dst = (((src)&0x00E00000)>>16)| \
  1024 	      (((src)&0x0000E000)>>11)| \
  1025 	      (((src)&0x000000C0)>>6); \
  1026 }
  1027 #endif
  1028 static void
  1029 Blit_RGB888_index8_map(SDL_BlitInfo * info)
  1030 {
  1031 #ifndef USE_DUFFS_LOOP
  1032     int c;
  1033 #endif
  1034     int Pixel;
  1035     int width, height;
  1036     Uint32 *src;
  1037     const Uint8 *map;
  1038     Uint8 *dst;
  1039     int srcskip, dstskip;
  1040 
  1041     /* Set up some basic variables */
  1042     width = info->dst_w;
  1043     height = info->dst_h;
  1044     src = (Uint32 *) info->src;
  1045     srcskip = info->src_skip / 4;
  1046     dst = info->dst;
  1047     dstskip = info->dst_skip;
  1048     map = info->table;
  1049 
  1050 #ifdef USE_DUFFS_LOOP
  1051     while (height--) {
  1052 		/* *INDENT-OFF* */
  1053 		DUFFS_LOOP(
  1054 			RGB888_RGB332(Pixel, *src);
  1055 			*dst++ = map[Pixel];
  1056 			++src;
  1057 		, width);
  1058 		/* *INDENT-ON* */
  1059         src += srcskip;
  1060         dst += dstskip;
  1061     }
  1062 #else
  1063     while (height--) {
  1064         for (c = width / 4; c; --c) {
  1065             /* Pack RGB into 8bit pixel */
  1066             RGB888_RGB332(Pixel, *src);
  1067             *dst++ = map[Pixel];
  1068             ++src;
  1069             RGB888_RGB332(Pixel, *src);
  1070             *dst++ = map[Pixel];
  1071             ++src;
  1072             RGB888_RGB332(Pixel, *src);
  1073             *dst++ = map[Pixel];
  1074             ++src;
  1075             RGB888_RGB332(Pixel, *src);
  1076             *dst++ = map[Pixel];
  1077             ++src;
  1078         }
  1079         switch (width & 3) {
  1080         case 3:
  1081             RGB888_RGB332(Pixel, *src);
  1082             *dst++ = map[Pixel];
  1083             ++src;
  1084         case 2:
  1085             RGB888_RGB332(Pixel, *src);
  1086             *dst++ = map[Pixel];
  1087             ++src;
  1088         case 1:
  1089             RGB888_RGB332(Pixel, *src);
  1090             *dst++ = map[Pixel];
  1091             ++src;
  1092         }
  1093         src += srcskip;
  1094         dst += dstskip;
  1095     }
  1096 #endif /* USE_DUFFS_LOOP */
  1097 }
  1098 
  1099 static void
  1100 BlitNto1(SDL_BlitInfo * info)
  1101 {
  1102 #ifndef USE_DUFFS_LOOP
  1103     int c;
  1104 #endif
  1105     int width, height;
  1106     Uint8 *src;
  1107     const Uint8 *map;
  1108     Uint8 *dst;
  1109     int srcskip, dstskip;
  1110     int srcbpp;
  1111     Uint32 Pixel;
  1112     int sR, sG, sB;
  1113     SDL_PixelFormat *srcfmt;
  1114 
  1115     /* Set up some basic variables */
  1116     width = info->dst_w;
  1117     height = info->dst_h;
  1118     src = info->src;
  1119     srcskip = info->src_skip;
  1120     dst = info->dst;
  1121     dstskip = info->dst_skip;
  1122     map = info->table;
  1123     srcfmt = info->src_fmt;
  1124     srcbpp = srcfmt->BytesPerPixel;
  1125 
  1126     if (map == NULL) {
  1127         while (height--) {
  1128 #ifdef USE_DUFFS_LOOP
  1129 			/* *INDENT-OFF* */
  1130 			DUFFS_LOOP(
  1131 				DISEMBLE_RGB(src, srcbpp, srcfmt, Pixel,
  1132 								sR, sG, sB);
  1133 				if ( 1 ) {
  1134 				  	/* Pack RGB into 8bit pixel */
  1135 				  	*dst = ((sR>>5)<<(3+2))|
  1136 					        ((sG>>5)<<(2)) |
  1137 					        ((sB>>6)<<(0)) ;
  1138 				}
  1139 				dst++;
  1140 				src += srcbpp;
  1141 			, width);
  1142 			/* *INDENT-ON* */
  1143 #else
  1144             for (c = width; c; --c) {
  1145                 DISEMBLE_RGB(src, srcbpp, srcfmt, Pixel, sR, sG, sB);
  1146                 if (1) {
  1147                     /* Pack RGB into 8bit pixel */
  1148                     *dst = ((sR >> 5) << (3 + 2)) |
  1149                         ((sG >> 5) << (2)) | ((sB >> 6) << (0));
  1150                 }
  1151                 dst++;
  1152                 src += srcbpp;
  1153             }
  1154 #endif
  1155             src += srcskip;
  1156             dst += dstskip;
  1157         }
  1158     } else {
  1159         while (height--) {
  1160 #ifdef USE_DUFFS_LOOP
  1161 			/* *INDENT-OFF* */
  1162 			DUFFS_LOOP(
  1163 				DISEMBLE_RGB(src, srcbpp, srcfmt, Pixel,
  1164 								sR, sG, sB);
  1165 				if ( 1 ) {
  1166 				  	/* Pack RGB into 8bit pixel */
  1167 				  	*dst = map[((sR>>5)<<(3+2))|
  1168 						   ((sG>>5)<<(2))  |
  1169 						   ((sB>>6)<<(0))  ];
  1170 				}
  1171 				dst++;
  1172 				src += srcbpp;
  1173 			, width);
  1174 			/* *INDENT-ON* */
  1175 #else
  1176             for (c = width; c; --c) {
  1177                 DISEMBLE_RGB(src, srcbpp, srcfmt, Pixel, sR, sG, sB);
  1178                 if (1) {
  1179                     /* Pack RGB into 8bit pixel */
  1180                     *dst = map[((sR >> 5) << (3 + 2)) |
  1181                                ((sG >> 5) << (2)) | ((sB >> 6) << (0))];
  1182                 }
  1183                 dst++;
  1184                 src += srcbpp;
  1185             }
  1186 #endif /* USE_DUFFS_LOOP */
  1187             src += srcskip;
  1188             dst += dstskip;
  1189         }
  1190     }
  1191 }
  1192 
  1193 /* blits 32 bit RGB<->RGBA with both surfaces having the same R,G,B fields */
  1194 static void
  1195 Blit4to4MaskAlpha(SDL_BlitInfo * info)
  1196 {
  1197     int width = info->dst_w;
  1198     int height = info->dst_h;
  1199     Uint32 *src = (Uint32 *) info->src;
  1200     int srcskip = info->src_skip;
  1201     Uint32 *dst = (Uint32 *) info->dst;
  1202     int dstskip = info->dst_skip;
  1203     SDL_PixelFormat *srcfmt = info->src_fmt;
  1204     SDL_PixelFormat *dstfmt = info->dst_fmt;
  1205 
  1206     if (dstfmt->Amask) {
  1207         /* RGB->RGBA, SET_ALPHA */
  1208         Uint32 mask = (info->a >> dstfmt->Aloss) << dstfmt->Ashift;
  1209 
  1210         while (height--) {
  1211 			/* *INDENT-OFF* */
  1212 			DUFFS_LOOP(
  1213 			{
  1214 				*dst = *src | mask;
  1215 				++dst;
  1216 				++src;
  1217 			},
  1218 			width);
  1219 			/* *INDENT-ON* */
  1220             src = (Uint32 *) ((Uint8 *) src + srcskip);
  1221             dst = (Uint32 *) ((Uint8 *) dst + dstskip);
  1222         }
  1223     } else {
  1224         /* RGBA->RGB, NO_ALPHA */
  1225         Uint32 mask = srcfmt->Rmask | srcfmt->Gmask | srcfmt->Bmask;
  1226 
  1227         while (height--) {
  1228 			/* *INDENT-OFF* */
  1229 			DUFFS_LOOP(
  1230 			{
  1231 				*dst = *src & mask;
  1232 				++dst;
  1233 				++src;
  1234 			},
  1235 			width);
  1236 			/* *INDENT-ON* */
  1237             src = (Uint32 *) ((Uint8 *) src + srcskip);
  1238             dst = (Uint32 *) ((Uint8 *) dst + dstskip);
  1239         }
  1240     }
  1241 }
  1242 
  1243 static void
  1244 BlitNtoN(SDL_BlitInfo * info)
  1245 {
  1246     int width = info->dst_w;
  1247     int height = info->dst_h;
  1248     Uint8 *src = info->src;
  1249     int srcskip = info->src_skip;
  1250     Uint8 *dst = info->dst;
  1251     int dstskip = info->dst_skip;
  1252     SDL_PixelFormat *srcfmt = info->src_fmt;
  1253     int srcbpp = srcfmt->BytesPerPixel;
  1254     SDL_PixelFormat *dstfmt = info->dst_fmt;
  1255     int dstbpp = dstfmt->BytesPerPixel;
  1256     unsigned alpha = dstfmt->Amask ? info->a : 0;
  1257 
  1258     while (height--) {
  1259 		/* *INDENT-OFF* */
  1260 		DUFFS_LOOP(
  1261 		{
  1262             Uint32 Pixel;
  1263 			unsigned sR;
  1264 			unsigned sG;
  1265 			unsigned sB;
  1266 			DISEMBLE_RGB(src, srcbpp, srcfmt, Pixel, sR, sG, sB);
  1267 			ASSEMBLE_RGBA(dst, dstbpp, dstfmt, sR, sG, sB, alpha);
  1268 			dst += dstbpp;
  1269 			src += srcbpp;
  1270 		},
  1271 		width);
  1272 		/* *INDENT-ON* */
  1273         src += srcskip;
  1274         dst += dstskip;
  1275     }
  1276 }
  1277 
  1278 static void
  1279 BlitNtoNCopyAlpha(SDL_BlitInfo * info)
  1280 {
  1281     int width = info->dst_w;
  1282     int height = info->dst_h;
  1283     Uint8 *src = info->src;
  1284     int srcskip = info->src_skip;
  1285     Uint8 *dst = info->dst;
  1286     int dstskip = info->dst_skip;
  1287     SDL_PixelFormat *srcfmt = info->src_fmt;
  1288     int srcbpp = srcfmt->BytesPerPixel;
  1289     SDL_PixelFormat *dstfmt = info->dst_fmt;
  1290     int dstbpp = dstfmt->BytesPerPixel;
  1291     int c;
  1292 
  1293     /* FIXME: should map alpha to [0..255] correctly! */
  1294     while (height--) {
  1295         for (c = width; c; --c) {
  1296             Uint32 Pixel;
  1297             unsigned sR, sG, sB, sA;
  1298             DISEMBLE_RGBA(src, srcbpp, srcfmt, Pixel, sR, sG, sB, sA);
  1299             ASSEMBLE_RGBA(dst, dstbpp, dstfmt, sR, sG, sB, sA);
  1300             dst += dstbpp;
  1301             src += srcbpp;
  1302         }
  1303         src += srcskip;
  1304         dst += dstskip;
  1305     }
  1306 }
  1307 
  1308 static void
  1309 BlitNto1Key(SDL_BlitInfo * info)
  1310 {
  1311     int width = info->dst_w;
  1312     int height = info->dst_h;
  1313     Uint8 *src = info->src;
  1314     int srcskip = info->src_skip;
  1315     Uint8 *dst = info->dst;
  1316     int dstskip = info->dst_skip;
  1317     SDL_PixelFormat *srcfmt = info->src_fmt;
  1318     const Uint8 *palmap = info->table;
  1319     Uint32 ckey = info->colorkey;
  1320     Uint32 rgbmask = ~srcfmt->Amask;
  1321     int srcbpp;
  1322     Uint32 Pixel;
  1323     unsigned sR, sG, sB;
  1324 
  1325     /* Set up some basic variables */
  1326     srcbpp = srcfmt->BytesPerPixel;
  1327     ckey &= rgbmask;
  1328 
  1329     if (palmap == NULL) {
  1330         while (height--) {
  1331 			/* *INDENT-OFF* */
  1332 			DUFFS_LOOP(
  1333 			{
  1334 				DISEMBLE_RGB(src, srcbpp, srcfmt, Pixel,
  1335 								sR, sG, sB);
  1336 				if ( (Pixel & rgbmask) != ckey ) {
  1337 				  	/* Pack RGB into 8bit pixel */
  1338 				  	*dst = (Uint8)(((sR>>5)<<(3+2))|
  1339 						           ((sG>>5)<<(2)) |
  1340 						           ((sB>>6)<<(0)));
  1341 				}
  1342 				dst++;
  1343 				src += srcbpp;
  1344 			},
  1345 			width);
  1346 			/* *INDENT-ON* */
  1347             src += srcskip;
  1348             dst += dstskip;
  1349         }
  1350     } else {
  1351         while (height--) {
  1352 			/* *INDENT-OFF* */
  1353 			DUFFS_LOOP(
  1354 			{
  1355 				DISEMBLE_RGB(src, srcbpp, srcfmt, Pixel,
  1356 								sR, sG, sB);
  1357 				if ( (Pixel & rgbmask) != ckey ) {
  1358 				  	/* Pack RGB into 8bit pixel */
  1359 				  	*dst = (Uint8)palmap[((sR>>5)<<(3+2))|
  1360 							             ((sG>>5)<<(2))  |
  1361 							             ((sB>>6)<<(0))  ];
  1362 				}
  1363 				dst++;
  1364 				src += srcbpp;
  1365 			},
  1366 			width);
  1367 			/* *INDENT-ON* */
  1368             src += srcskip;
  1369             dst += dstskip;
  1370         }
  1371     }
  1372 }
  1373 
  1374 static void
  1375 Blit2to2Key(SDL_BlitInfo * info)
  1376 {
  1377     int width = info->dst_w;
  1378     int height = info->dst_h;
  1379     Uint16 *srcp = (Uint16 *) info->src;
  1380     int srcskip = info->src_skip;
  1381     Uint16 *dstp = (Uint16 *) info->dst;
  1382     int dstskip = info->dst_skip;
  1383     Uint32 ckey = info->colorkey;
  1384     Uint32 rgbmask = ~info->src_fmt->Amask;
  1385 
  1386     /* Set up some basic variables */
  1387     srcskip /= 2;
  1388     dstskip /= 2;
  1389     ckey &= rgbmask;
  1390 
  1391     while (height--) {
  1392 		/* *INDENT-OFF* */
  1393 		DUFFS_LOOP(
  1394 		{
  1395 			if ( (*srcp & rgbmask) != ckey ) {
  1396 				*dstp = *srcp;
  1397 			}
  1398 			dstp++;
  1399 			srcp++;
  1400 		},
  1401 		width);
  1402 		/* *INDENT-ON* */
  1403         srcp += srcskip;
  1404         dstp += dstskip;
  1405     }
  1406 }
  1407 
  1408 static void
  1409 BlitNtoNKey(SDL_BlitInfo * info)
  1410 {
  1411     int width = info->dst_w;
  1412     int height = info->dst_h;
  1413     Uint8 *src = info->src;
  1414     int srcskip = info->src_skip;
  1415     Uint8 *dst = info->dst;
  1416     int dstskip = info->dst_skip;
  1417     Uint32 ckey = info->colorkey;
  1418     SDL_PixelFormat *srcfmt = info->src_fmt;
  1419     SDL_PixelFormat *dstfmt = info->dst_fmt;
  1420     int srcbpp = srcfmt->BytesPerPixel;
  1421     int dstbpp = dstfmt->BytesPerPixel;
  1422     unsigned alpha = dstfmt->Amask ? info->a : 0;
  1423     Uint32 rgbmask = ~srcfmt->Amask;
  1424 
  1425     /* Set up some basic variables */
  1426     ckey &= rgbmask;
  1427 
  1428     while (height--) {
  1429 		/* *INDENT-OFF* */
  1430 		DUFFS_LOOP(
  1431 		{
  1432             Uint32 Pixel;
  1433 			unsigned sR;
  1434 			unsigned sG;
  1435 			unsigned sB;
  1436 			RETRIEVE_RGB_PIXEL(src, srcbpp, Pixel);
  1437 			if ( (Pixel & rgbmask) != ckey ) {
  1438                 RGB_FROM_PIXEL(Pixel, srcfmt, sR, sG, sB);
  1439 				ASSEMBLE_RGBA(dst, dstbpp, dstfmt, sR, sG, sB, alpha);
  1440 			}
  1441 			dst += dstbpp;
  1442 			src += srcbpp;
  1443 		},
  1444 		width);
  1445 		/* *INDENT-ON* */
  1446         src += srcskip;
  1447         dst += dstskip;
  1448     }
  1449 }
  1450 
  1451 static void
  1452 BlitNtoNKeyCopyAlpha(SDL_BlitInfo * info)
  1453 {
  1454     int width = info->dst_w;
  1455     int height = info->dst_h;
  1456     Uint8 *src = info->src;
  1457     int srcskip = info->src_skip;
  1458     Uint8 *dst = info->dst;
  1459     int dstskip = info->dst_skip;
  1460     Uint32 ckey = info->colorkey;
  1461     SDL_PixelFormat *srcfmt = info->src_fmt;
  1462     SDL_PixelFormat *dstfmt = info->dst_fmt;
  1463     Uint32 rgbmask = ~srcfmt->Amask;
  1464 
  1465     Uint8 srcbpp;
  1466     Uint8 dstbpp;
  1467     Uint32 Pixel;
  1468     unsigned sR, sG, sB, sA;
  1469 
  1470     /* Set up some basic variables */
  1471     srcbpp = srcfmt->BytesPerPixel;
  1472     dstbpp = dstfmt->BytesPerPixel;
  1473     ckey &= rgbmask;
  1474 
  1475     /* FIXME: should map alpha to [0..255] correctly! */
  1476     while (height--) {
  1477 		/* *INDENT-OFF* */
  1478 		DUFFS_LOOP(
  1479 		{
  1480 			DISEMBLE_RGBA(src, srcbpp, srcfmt, Pixel, sR, sG, sB, sA);
  1481 			if ( (Pixel & rgbmask) != ckey ) {
  1482 				  ASSEMBLE_RGBA(dst, dstbpp, dstfmt, sR, sG, sB, sA);
  1483 			}
  1484 			dst += dstbpp;
  1485 			src += srcbpp;
  1486 		},
  1487 		width);
  1488 		/* *INDENT-ON* */
  1489         src += srcskip;
  1490         dst += dstskip;
  1491     }
  1492 }
  1493 
  1494 /* Normal N to N optimized blitters */
  1495 struct blit_table
  1496 {
  1497     Uint32 srcR, srcG, srcB;
  1498     int dstbpp;
  1499     Uint32 dstR, dstG, dstB;
  1500     Uint32 blit_features;
  1501     SDL_BlitFunc blitfunc;
  1502     enum
  1503     { NO_ALPHA = 1, SET_ALPHA = 2, COPY_ALPHA = 4 } alpha;
  1504 };
  1505 static const struct blit_table normal_blit_1[] = {
  1506     /* Default for 8-bit RGB source, an invalid combination */
  1507     {0, 0, 0, 0, 0, 0, 0, 0, NULL},
  1508 };
  1509 
  1510 static const struct blit_table normal_blit_2[] = {
  1511     {0x0000F800, 0x000007E0, 0x0000001F, 4, 0x00FF0000, 0x0000FF00,
  1512      0x000000FF,
  1513      0, Blit_RGB565_ARGB8888, SET_ALPHA},
  1514     {0x0000F800, 0x000007E0, 0x0000001F, 4, 0x000000FF, 0x0000FF00,
  1515      0x00FF0000,
  1516      0, Blit_RGB565_ABGR8888, SET_ALPHA},
  1517     {0x0000F800, 0x000007E0, 0x0000001F, 4, 0xFF000000, 0x00FF0000,
  1518      0x0000FF00,
  1519      0, Blit_RGB565_RGBA8888, SET_ALPHA},
  1520     {0x0000F800, 0x000007E0, 0x0000001F, 4, 0x0000FF00, 0x00FF0000,
  1521      0xFF000000,
  1522      0, Blit_RGB565_BGRA8888, SET_ALPHA},
  1523 
  1524     /* Default for 16-bit RGB source, used if no other blitter matches */
  1525     {0, 0, 0, 0, 0, 0, 0, 0, BlitNtoN, 0}
  1526 };
  1527 
  1528 static const struct blit_table normal_blit_3[] = {
  1529     /* Default for 24-bit RGB source, never optimized */
  1530     {0, 0, 0, 0, 0, 0, 0, 0, BlitNtoN, 0}
  1531 };
  1532 
  1533 static const struct blit_table normal_blit_4[] = {
  1534     {0x00FF0000, 0x0000FF00, 0x000000FF, 2, 0x0000F800, 0x000007E0,
  1535      0x0000001F,
  1536      0, Blit_RGB888_RGB565, NO_ALPHA},
  1537     {0x00FF0000, 0x0000FF00, 0x000000FF, 2, 0x00007C00, 0x000003E0,
  1538      0x0000001F,
  1539      0, Blit_RGB888_RGB555, NO_ALPHA},
  1540     /* Default for 32-bit RGB source, used if no other blitter matches */
  1541     {0, 0, 0, 0, 0, 0, 0, 0, BlitNtoN, 0}
  1542 };
  1543 
  1544 static const struct blit_table *const normal_blit[] = {
  1545     normal_blit_1, normal_blit_2, normal_blit_3, normal_blit_4
  1546 };
  1547 
  1548 /* Mask matches table, or table entry is zero */
  1549 #define MASKOK(x, y) (((x) == (y)) || ((y) == 0x00000000))
  1550 
  1551 SDL_BlitFunc
  1552 SDL_CalculateBlitN(SDL_Surface * surface)
  1553 {
  1554     SDL_PixelFormat *srcfmt;
  1555     SDL_PixelFormat *dstfmt;
  1556     const struct blit_table *table;
  1557     int which;
  1558     SDL_BlitFunc blitfun;
  1559 
  1560     /* Set up data for choosing the blit */
  1561     srcfmt = surface->format;
  1562     dstfmt = surface->map->dst->format;
  1563 
  1564     /* We don't support destinations less than 8-bits */
  1565     if (dstfmt->BitsPerPixel < 8) {
  1566         return (NULL);
  1567     }
  1568 
  1569     switch (surface->map->info.flags & ~SDL_COPY_RLE_MASK) {
  1570     case 0:
  1571         blitfun = NULL;
  1572         if (dstfmt->BitsPerPixel == 8) {
  1573             /* We assume 8-bit destinations are palettized */
  1574             if ((srcfmt->BytesPerPixel == 4) &&
  1575                 (srcfmt->Rmask == 0x00FF0000) &&
  1576                 (srcfmt->Gmask == 0x0000FF00) &&
  1577                 (srcfmt->Bmask == 0x000000FF)) {
  1578                 if (surface->map->info.table) {
  1579                     blitfun = Blit_RGB888_index8_map;
  1580                 } else {
  1581                     blitfun = Blit_RGB888_index8;
  1582                 }
  1583             } else {
  1584                 blitfun = BlitNto1;
  1585             }
  1586         } else {
  1587             /* Now the meat, choose the blitter we want */
  1588             int a_need = NO_ALPHA;
  1589             if (dstfmt->Amask)
  1590                 a_need = srcfmt->Amask ? COPY_ALPHA : SET_ALPHA;
  1591             table = normal_blit[srcfmt->BytesPerPixel - 1];
  1592             for (which = 0; table[which].dstbpp; ++which) {
  1593                 if (MASKOK(srcfmt->Rmask, table[which].srcR) &&
  1594                     MASKOK(srcfmt->Gmask, table[which].srcG) &&
  1595                     MASKOK(srcfmt->Bmask, table[which].srcB) &&
  1596                     MASKOK(dstfmt->Rmask, table[which].dstR) &&
  1597                     MASKOK(dstfmt->Gmask, table[which].dstG) &&
  1598                     MASKOK(dstfmt->Bmask, table[which].dstB) &&
  1599                     dstfmt->BytesPerPixel == table[which].dstbpp &&
  1600                     (a_need & table[which].alpha) == a_need &&
  1601                     ((table[which].blit_features & GetBlitFeatures()) ==
  1602                      table[which].blit_features))
  1603                     break;
  1604             }
  1605             blitfun = table[which].blitfunc;
  1606 
  1607             if (blitfun == BlitNtoN) {  /* default C fallback catch-all. Slow! */
  1608                 /* Fastpath C fallback: 32bit RGB<->RGBA blit with matching RGB */
  1609                 if (srcfmt->BytesPerPixel == 4 && dstfmt->BytesPerPixel == 4
  1610                     && srcfmt->Rmask == dstfmt->Rmask
  1611                     && srcfmt->Gmask == dstfmt->Gmask
  1612                     && srcfmt->Bmask == dstfmt->Bmask) {
  1613                     blitfun = Blit4to4MaskAlpha;
  1614                 } else if (a_need == COPY_ALPHA) {
  1615                     blitfun = BlitNtoNCopyAlpha;
  1616                 }
  1617             }
  1618         }
  1619         return (blitfun);
  1620 
  1621     case SDL_COPY_COLORKEY:
  1622         /* colorkey blit: Here we don't have too many options, mostly
  1623            because RLE is the preferred fast way to deal with this.
  1624            If a particular case turns out to be useful we'll add it. */
  1625 
  1626         if (srcfmt->BytesPerPixel == 2 && surface->map->identity)
  1627             return Blit2to2Key;
  1628         else if (dstfmt->BytesPerPixel == 1)
  1629             return BlitNto1Key;
  1630         else {
  1631             if (srcfmt->Amask && dstfmt->Amask) {
  1632                 return BlitNtoNKeyCopyAlpha;
  1633             } else {
  1634                 return BlitNtoNKey;
  1635             }
  1636         }
  1637     }
  1638 
  1639     return NULL;
  1640 }
  1641 
  1642 /* vi: set ts=4 sw=4 expandtab: */