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