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