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