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