Mercurial > sdl-ios-xcode
annotate src/video/SDL_blit_N.c @ 1302:94643e9bad18
Date: Sat, 14 Jan 2006 15:16:01 -0500
From: Andrew Fuller
Subject: [SDL] [PATCH] ML-8866 PS2->USB converter
This converter seems to go by several names -- Super Dual Box, Dual
USB Joypad, and who knows what else. Also branded differently with
different colour cases, etc. But it seems to all be the same
internals. It is a common converter used for StepMania, with several
posts Googleable trying to make it work in Linux. I got mine
yesterday and wanted to play stepmania, so I went ahead and made a
crude patch for libsdl to split this baby into two logical joysticks.
A couple notes about the patch:
This patch works well for two dance mats hooked up and playing
stepmania, however the mapping of the other buttons may be off. I
have no joystick which uses all the buttons the converter reports, so
I have no way of testing them.
The name I used 0925:8866 which is the USB ID, and what SDLjoytest-GL
reported is the name, even though lsusb shows Wisegroup, Ltd MP-8866
Dual USB Joypad, and the existing virtual joystick mapping uses the
Wisegroup... name. Not sure why the discrepency.
I'm not subscribed to this mailing list, so please CC me on any
comments to this.
-Andrew
author | Sam Lantinga <slouken@libsdl.org> |
---|---|
date | Tue, 31 Jan 2006 14:59:43 +0000 |
parents | 0aa0000081d5 |
children | c9b51268668f |
rev | line source |
---|---|
0 | 1 /* |
2 SDL - Simple DirectMedia Layer | |
769
b8d311d90021
Updated copyright information for 2004 (Happy New Year!)
Sam Lantinga <slouken@libsdl.org>
parents:
739
diff
changeset
|
3 Copyright (C) 1997-2004 Sam Lantinga |
0 | 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 | |
252
e8157fcb3114
Updated the source with the correct e-mail address
Sam Lantinga <slouken@libsdl.org>
parents:
91
diff
changeset
|
20 slouken@libsdl.org |
0 | 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" | |
739
22dbf364c017
Added SDL_HasMMX(), SDL_Has3DNow(), SDL_HasSSE() in SDL_cpuinfo.h
Sam Lantinga <slouken@libsdl.org>
parents:
431
diff
changeset
|
34 #include "SDL_cpuinfo.h" |
0 | 35 |
36 /* Functions to blit from N-bit surfaces to other surfaces */ | |
37 | |
1047
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
38 #ifdef USE_ALTIVEC_BLITTERS |
1175
867f521591e5
Fixed Altivec support on Mac OS X.
Ryan C. Gordon <icculus@icculus.org>
parents:
1162
diff
changeset
|
39 #ifdef HAVE_ALTIVEC_H |
1162
2651158f59b8
Enable altivec blitters on PowerPC Linux, and some fixes for recent
Ryan C. Gordon <icculus@icculus.org>
parents:
1139
diff
changeset
|
40 #include <altivec.h> |
1175
867f521591e5
Fixed Altivec support on Mac OS X.
Ryan C. Gordon <icculus@icculus.org>
parents:
1162
diff
changeset
|
41 #endif |
1047
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
42 #include <assert.h> |
1162
2651158f59b8
Enable altivec blitters on PowerPC Linux, and some fixes for recent
Ryan C. Gordon <icculus@icculus.org>
parents:
1139
diff
changeset
|
43 #include <stdlib.h> |
1047
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
44 #ifdef MACOSX |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
45 #include <sys/sysctl.h> |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
46 static size_t GetL3CacheSize( void ) |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
47 { |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
48 const char key[] = "hw.l3cachesize"; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
49 u_int64_t result = 0; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
50 size_t typeSize = sizeof( result ); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
51 |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
52 |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
53 int err = sysctlbyname( key, &result, &typeSize, NULL, 0 ); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
54 if( 0 != err ) return 0; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
55 |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
56 return result; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
57 } |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
58 #else |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
59 static size_t GetL3CacheSize( void ) |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
60 { |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
61 /* XXX: Just guess G4 */ |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
62 return 2097152; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
63 } |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
64 #endif /* MACOSX */ |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
65 |
1162
2651158f59b8
Enable altivec blitters on PowerPC Linux, and some fixes for recent
Ryan C. Gordon <icculus@icculus.org>
parents:
1139
diff
changeset
|
66 #if ((defined MACOSX) && (__GNUC__ < 4)) |
2651158f59b8
Enable altivec blitters on PowerPC Linux, and some fixes for recent
Ryan C. Gordon <icculus@icculus.org>
parents:
1139
diff
changeset
|
67 #define VECUINT8_LITERAL(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p) \ |
2651158f59b8
Enable altivec blitters on PowerPC Linux, and some fixes for recent
Ryan C. Gordon <icculus@icculus.org>
parents:
1139
diff
changeset
|
68 (vector unsigned char) ( a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p ) |
2651158f59b8
Enable altivec blitters on PowerPC Linux, and some fixes for recent
Ryan C. Gordon <icculus@icculus.org>
parents:
1139
diff
changeset
|
69 #define VECUINT16_LITERAL(a,b,c,d,e,f,g,h) \ |
2651158f59b8
Enable altivec blitters on PowerPC Linux, and some fixes for recent
Ryan C. Gordon <icculus@icculus.org>
parents:
1139
diff
changeset
|
70 (vector unsigned short) ( a,b,c,d,e,f,g,h ) |
2651158f59b8
Enable altivec blitters on PowerPC Linux, and some fixes for recent
Ryan C. Gordon <icculus@icculus.org>
parents:
1139
diff
changeset
|
71 #else |
2651158f59b8
Enable altivec blitters on PowerPC Linux, and some fixes for recent
Ryan C. Gordon <icculus@icculus.org>
parents:
1139
diff
changeset
|
72 #define VECUINT8_LITERAL(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p) \ |
2651158f59b8
Enable altivec blitters on PowerPC Linux, and some fixes for recent
Ryan C. Gordon <icculus@icculus.org>
parents:
1139
diff
changeset
|
73 (vector unsigned char) { a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p } |
2651158f59b8
Enable altivec blitters on PowerPC Linux, and some fixes for recent
Ryan C. Gordon <icculus@icculus.org>
parents:
1139
diff
changeset
|
74 #define VECUINT16_LITERAL(a,b,c,d,e,f,g,h) \ |
2651158f59b8
Enable altivec blitters on PowerPC Linux, and some fixes for recent
Ryan C. Gordon <icculus@icculus.org>
parents:
1139
diff
changeset
|
75 (vector unsigned short) { a,b,c,d,e,f,g,h } |
2651158f59b8
Enable altivec blitters on PowerPC Linux, and some fixes for recent
Ryan C. Gordon <icculus@icculus.org>
parents:
1139
diff
changeset
|
76 #endif |
2651158f59b8
Enable altivec blitters on PowerPC Linux, and some fixes for recent
Ryan C. Gordon <icculus@icculus.org>
parents:
1139
diff
changeset
|
77 |
1047
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
78 #define UNALIGNED_PTR(x) (((size_t) x) & 0x0000000F) |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
79 #define VSWIZZLE32(a,b,c,d) (vector unsigned char) \ |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
80 ( 0x00+a, 0x00+b, 0x00+c, 0x00+d, \ |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
81 0x04+a, 0x04+b, 0x04+c, 0x04+d, \ |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
82 0x08+a, 0x08+b, 0x08+c, 0x08+d, \ |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
83 0x0C+a, 0x0C+b, 0x0C+c, 0x0C+d ) |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
84 |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
85 #define MAKE8888(dstfmt, r, g, b, a) \ |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
86 ( ((r<<dstfmt->Rshift)&dstfmt->Rmask) | \ |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
87 ((g<<dstfmt->Gshift)&dstfmt->Gmask) | \ |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
88 ((b<<dstfmt->Bshift)&dstfmt->Bmask) | \ |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
89 ((a<<dstfmt->Ashift)&dstfmt->Amask) ) |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
90 |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
91 /* |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
92 * Data Stream Touch...Altivec cache prefetching. |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
93 * |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
94 * Don't use this on a G5...however, the speed boost is very significant |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
95 * on a G4. |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
96 */ |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
97 #define DST_CHAN_SRC 1 |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
98 #define DST_CHAN_DEST 2 |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
99 |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
100 /* macro to set DST control word value... */ |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
101 #define DST_CTRL(size, count, stride) \ |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
102 (((size) << 24) | ((count) << 16) | (stride)) |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
103 |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
104 #define VEC_ALIGNER(src) ((UNALIGNED_PTR(src)) \ |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
105 ? vec_lvsl(0, src) \ |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
106 : vec_add(vec_lvsl(8, src), vec_splat_u8(8))) |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
107 |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
108 /* Calculate the permute vector used for 32->32 swizzling */ |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
109 static vector unsigned char calc_swizzle32(const SDL_PixelFormat *srcfmt, |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
110 const SDL_PixelFormat *dstfmt) |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
111 { |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
112 /* |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
113 * We have to assume that the bits that aren't used by other |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
114 * colors is alpha, and it's one complete byte, since some formats |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
115 * leave alpha with a zero mask, but we should still swizzle the bits. |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
116 */ |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
117 /* ARGB */ |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
118 const static struct SDL_PixelFormat default_pixel_format = { |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
119 NULL, 0, 0, |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
120 0, 0, 0, 0, |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
121 16, 8, 0, 24, |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
122 0x00FF0000, 0x0000FF00, 0x000000FF, 0xFF000000, |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
123 0, 0}; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
124 if (!srcfmt) { |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
125 srcfmt = &default_pixel_format; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
126 } |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
127 if (!dstfmt) { |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
128 dstfmt = &default_pixel_format; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
129 } |
1162
2651158f59b8
Enable altivec blitters on PowerPC Linux, and some fixes for recent
Ryan C. Gordon <icculus@icculus.org>
parents:
1139
diff
changeset
|
130 vector unsigned char plus = VECUINT8_LITERAL( |
2651158f59b8
Enable altivec blitters on PowerPC Linux, and some fixes for recent
Ryan C. Gordon <icculus@icculus.org>
parents:
1139
diff
changeset
|
131 0x00, 0x00, 0x00, 0x00, |
1047
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
132 0x04, 0x04, 0x04, 0x04, |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
133 0x08, 0x08, 0x08, 0x08, |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
134 0x0C, 0x0C, 0x0C, 0x0C ); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
135 vector unsigned char vswiz; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
136 vector unsigned int srcvec; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
137 #define RESHIFT(X) (3 - ((X) >> 3)) |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
138 Uint32 rmask = RESHIFT(srcfmt->Rshift) << (dstfmt->Rshift); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
139 Uint32 gmask = RESHIFT(srcfmt->Gshift) << (dstfmt->Gshift); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
140 Uint32 bmask = RESHIFT(srcfmt->Bshift) << (dstfmt->Bshift); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
141 Uint32 amask; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
142 /* Use zero for alpha if either surface doesn't have alpha */ |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
143 if (dstfmt->Amask) { |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
144 amask = ((srcfmt->Amask) ? RESHIFT(srcfmt->Ashift) : 0x10) << (dstfmt->Ashift); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
145 } else { |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
146 amask = 0x10101010 & ((dstfmt->Rmask | dstfmt->Gmask | dstfmt->Bmask) ^ 0xFFFFFFFF); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
147 } |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
148 #undef RESHIFT |
1162
2651158f59b8
Enable altivec blitters on PowerPC Linux, and some fixes for recent
Ryan C. Gordon <icculus@icculus.org>
parents:
1139
diff
changeset
|
149 ((unsigned int *)(char*)&srcvec)[0] = (rmask | gmask | bmask | amask); |
1047
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
150 vswiz = vec_add(plus, (vector unsigned char)vec_splat(srcvec, 0)); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
151 return(vswiz); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
152 } |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
153 |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
154 static void Blit_RGB888_RGB565(SDL_BlitInfo *info); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
155 static void Blit_RGB888_RGB565Altivec(SDL_BlitInfo *info) { |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
156 int height = info->d_height; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
157 Uint8 *src = (Uint8 *) info->s_pixels; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
158 int srcskip = info->s_skip; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
159 Uint8 *dst = (Uint8 *) info->d_pixels; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
160 int dstskip = info->d_skip; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
161 SDL_PixelFormat *srcfmt = info->src; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
162 vector unsigned char valpha = vec_splat_u8(0); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
163 vector unsigned char vpermute = calc_swizzle32(srcfmt, NULL); |
1162
2651158f59b8
Enable altivec blitters on PowerPC Linux, and some fixes for recent
Ryan C. Gordon <icculus@icculus.org>
parents:
1139
diff
changeset
|
164 vector unsigned char vgmerge = VECUINT8_LITERAL( |
1047
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
165 0x00, 0x02, 0x00, 0x06, |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
166 0x00, 0x0a, 0x00, 0x0e, |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
167 0x00, 0x12, 0x00, 0x16, |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
168 0x00, 0x1a, 0x00, 0x1e); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
169 vector unsigned short v1 = vec_splat_u16(1); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
170 vector unsigned short v3 = vec_splat_u16(3); |
1162
2651158f59b8
Enable altivec blitters on PowerPC Linux, and some fixes for recent
Ryan C. Gordon <icculus@icculus.org>
parents:
1139
diff
changeset
|
171 vector unsigned short v3f = VECUINT16_LITERAL( |
1047
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
172 0x003f, 0x003f, 0x003f, 0x003f, |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
173 0x003f, 0x003f, 0x003f, 0x003f); |
1162
2651158f59b8
Enable altivec blitters on PowerPC Linux, and some fixes for recent
Ryan C. Gordon <icculus@icculus.org>
parents:
1139
diff
changeset
|
174 vector unsigned short vfc = VECUINT16_LITERAL( |
1047
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
175 0x00fc, 0x00fc, 0x00fc, 0x00fc, |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
176 0x00fc, 0x00fc, 0x00fc, 0x00fc); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
177 vector unsigned short vf800 = (vector unsigned short)vec_splat_u8(-7); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
178 vf800 = vec_sl(vf800, vec_splat_u16(8)); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
179 |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
180 while (height--) { |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
181 vector unsigned char valigner; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
182 vector unsigned char voverflow; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
183 vector unsigned char vsrc; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
184 |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
185 int width = info->d_width; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
186 int extrawidth; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
187 |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
188 /* do scalar until we can align... */ |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
189 #define ONE_PIXEL_BLEND(condition, widthvar) \ |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
190 while (condition) { \ |
1162
2651158f59b8
Enable altivec blitters on PowerPC Linux, and some fixes for recent
Ryan C. Gordon <icculus@icculus.org>
parents:
1139
diff
changeset
|
191 Uint32 Pixel; \ |
1047
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
192 unsigned sR, sG, sB, sA; \ |
1162
2651158f59b8
Enable altivec blitters on PowerPC Linux, and some fixes for recent
Ryan C. Gordon <icculus@icculus.org>
parents:
1139
diff
changeset
|
193 DISEMBLE_RGBA((Uint8 *)src, 4, srcfmt, Pixel, \ |
1047
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
194 sR, sG, sB, sA); \ |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
195 *(Uint16 *)(dst) = (((sR << 8) & 0x0000F800) | \ |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
196 ((sG << 3) & 0x000007E0) | \ |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
197 ((sB >> 3) & 0x0000001F)); \ |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
198 dst += 2; \ |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
199 src += 4; \ |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
200 widthvar--; \ |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
201 } |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
202 |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
203 ONE_PIXEL_BLEND(((UNALIGNED_PTR(dst)) && (width)), width); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
204 |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
205 /* After all that work, here's the vector part! */ |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
206 extrawidth = (width % 8); /* trailing unaligned stores */ |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
207 width -= extrawidth; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
208 vsrc = vec_ld(0, src); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
209 valigner = VEC_ALIGNER(src); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
210 |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
211 while (width) { |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
212 vector unsigned short vpixel, vrpixel, vgpixel, vbpixel; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
213 vector unsigned int vsrc1, vsrc2; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
214 vector unsigned char vdst; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
215 |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
216 voverflow = vec_ld(15, src); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
217 vsrc = vec_perm(vsrc, voverflow, valigner); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
218 vsrc1 = (vector unsigned int)vec_perm(vsrc, valpha, vpermute); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
219 src += 16; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
220 vsrc = voverflow; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
221 voverflow = vec_ld(15, src); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
222 vsrc = vec_perm(vsrc, voverflow, valigner); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
223 vsrc2 = (vector unsigned int)vec_perm(vsrc, valpha, vpermute); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
224 /* 1555 */ |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
225 vpixel = (vector unsigned short)vec_packpx(vsrc1, vsrc2); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
226 vgpixel = (vector unsigned short)vec_perm(vsrc1, vsrc2, vgmerge); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
227 vgpixel = vec_and(vgpixel, vfc); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
228 vgpixel = vec_sl(vgpixel, v3); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
229 vrpixel = vec_sl(vpixel, v1); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
230 vrpixel = vec_and(vrpixel, vf800); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
231 vbpixel = vec_and(vpixel, v3f); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
232 vdst = vec_or((vector unsigned char)vrpixel, (vector unsigned char)vgpixel); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
233 /* 565 */ |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
234 vdst = vec_or(vdst, (vector unsigned char)vbpixel); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
235 vec_st(vdst, 0, dst); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
236 |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
237 width -= 8; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
238 src += 16; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
239 dst += 16; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
240 vsrc = voverflow; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
241 } |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
242 |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
243 assert(width == 0); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
244 |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
245 |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
246 /* do scalar until we can align... */ |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
247 ONE_PIXEL_BLEND((extrawidth), extrawidth); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
248 #undef ONE_PIXEL_BLEND |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
249 |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
250 src += srcskip; /* move to next row, accounting for pitch. */ |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
251 dst += dstskip; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
252 } |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
253 |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
254 |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
255 } |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
256 |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
257 static void Blit_RGB565_32Altivec(SDL_BlitInfo *info) { |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
258 int height = info->d_height; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
259 Uint8 *src = (Uint8 *) info->s_pixels; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
260 int srcskip = info->s_skip; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
261 Uint8 *dst = (Uint8 *) info->d_pixels; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
262 int dstskip = info->d_skip; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
263 SDL_PixelFormat *srcfmt = info->src; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
264 SDL_PixelFormat *dstfmt = info->dst; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
265 unsigned alpha; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
266 vector unsigned char valpha; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
267 vector unsigned char vpermute; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
268 vector unsigned short vf800; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
269 vector unsigned int v8 = vec_splat_u32(8); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
270 vector unsigned int v16 = vec_add(v8, v8); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
271 vector unsigned short v2 = vec_splat_u16(2); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
272 vector unsigned short v3 = vec_splat_u16(3); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
273 /* |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
274 0x10 - 0x1f is the alpha |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
275 0x00 - 0x0e evens are the red |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
276 0x01 - 0x0f odds are zero |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
277 */ |
1162
2651158f59b8
Enable altivec blitters on PowerPC Linux, and some fixes for recent
Ryan C. Gordon <icculus@icculus.org>
parents:
1139
diff
changeset
|
278 vector unsigned char vredalpha1 = VECUINT8_LITERAL( |
1047
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
279 0x10, 0x00, 0x01, 0x01, |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
280 0x10, 0x02, 0x01, 0x01, |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
281 0x10, 0x04, 0x01, 0x01, |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
282 0x10, 0x06, 0x01, 0x01 |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
283 ); |
1162
2651158f59b8
Enable altivec blitters on PowerPC Linux, and some fixes for recent
Ryan C. Gordon <icculus@icculus.org>
parents:
1139
diff
changeset
|
284 vector unsigned char vredalpha2 = (vector unsigned char) ( |
1047
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
285 vec_add((vector unsigned int)vredalpha1, vec_sl(v8, v16)) |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
286 ); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
287 /* |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
288 0x00 - 0x0f is ARxx ARxx ARxx ARxx |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
289 0x11 - 0x0f odds are blue |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
290 */ |
1162
2651158f59b8
Enable altivec blitters on PowerPC Linux, and some fixes for recent
Ryan C. Gordon <icculus@icculus.org>
parents:
1139
diff
changeset
|
291 vector unsigned char vblue1 = VECUINT8_LITERAL( |
1047
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
292 0x00, 0x01, 0x02, 0x11, |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
293 0x04, 0x05, 0x06, 0x13, |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
294 0x08, 0x09, 0x0a, 0x15, |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
295 0x0c, 0x0d, 0x0e, 0x17 |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
296 ); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
297 vector unsigned char vblue2 = (vector unsigned char)( |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
298 vec_add((vector unsigned int)vblue1, v8) |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
299 ); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
300 /* |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
301 0x00 - 0x0f is ARxB ARxB ARxB ARxB |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
302 0x10 - 0x0e evens are green |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
303 */ |
1162
2651158f59b8
Enable altivec blitters on PowerPC Linux, and some fixes for recent
Ryan C. Gordon <icculus@icculus.org>
parents:
1139
diff
changeset
|
304 vector unsigned char vgreen1 = VECUINT8_LITERAL( |
1047
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
305 0x00, 0x01, 0x10, 0x03, |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
306 0x04, 0x05, 0x12, 0x07, |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
307 0x08, 0x09, 0x14, 0x0b, |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
308 0x0c, 0x0d, 0x16, 0x0f |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
309 ); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
310 vector unsigned char vgreen2 = (vector unsigned char)( |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
311 vec_add((vector unsigned int)vgreen1, vec_sl(v8, v8)) |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
312 ); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
313 |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
314 |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
315 assert(srcfmt->BytesPerPixel == 2); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
316 assert(dstfmt->BytesPerPixel == 4); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
317 |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
318 vf800 = (vector unsigned short)vec_splat_u8(-7); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
319 vf800 = vec_sl(vf800, vec_splat_u16(8)); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
320 |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
321 if (dstfmt->Amask && srcfmt->alpha) { |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
322 ((unsigned char *)&valpha)[0] = alpha = srcfmt->alpha; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
323 valpha = vec_splat(valpha, 0); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
324 } else { |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
325 alpha = 0; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
326 valpha = vec_splat_u8(0); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
327 } |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
328 |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
329 vpermute = calc_swizzle32(NULL, dstfmt); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
330 while (height--) { |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
331 vector unsigned char valigner; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
332 vector unsigned char voverflow; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
333 vector unsigned char vsrc; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
334 |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
335 int width = info->d_width; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
336 int extrawidth; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
337 |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
338 /* do scalar until we can align... */ |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
339 #define ONE_PIXEL_BLEND(condition, widthvar) \ |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
340 while (condition) { \ |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
341 unsigned sR, sG, sB; \ |
1162
2651158f59b8
Enable altivec blitters on PowerPC Linux, and some fixes for recent
Ryan C. Gordon <icculus@icculus.org>
parents:
1139
diff
changeset
|
342 unsigned short Pixel = *((unsigned short *)src); \ |
2651158f59b8
Enable altivec blitters on PowerPC Linux, and some fixes for recent
Ryan C. Gordon <icculus@icculus.org>
parents:
1139
diff
changeset
|
343 sR = (Pixel >> 8) & 0xf8; \ |
2651158f59b8
Enable altivec blitters on PowerPC Linux, and some fixes for recent
Ryan C. Gordon <icculus@icculus.org>
parents:
1139
diff
changeset
|
344 sG = (Pixel >> 3) & 0xfc; \ |
2651158f59b8
Enable altivec blitters on PowerPC Linux, and some fixes for recent
Ryan C. Gordon <icculus@icculus.org>
parents:
1139
diff
changeset
|
345 sB = (Pixel << 3) & 0xf8; \ |
1047
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
346 ASSEMBLE_RGBA(dst, 4, dstfmt, sR, sG, sB, alpha); \ |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
347 src += 2; \ |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
348 dst += 4; \ |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
349 widthvar--; \ |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
350 } |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
351 ONE_PIXEL_BLEND(((UNALIGNED_PTR(dst)) && (width)), width); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
352 |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
353 /* After all that work, here's the vector part! */ |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
354 extrawidth = (width % 8); /* trailing unaligned stores */ |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
355 width -= extrawidth; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
356 vsrc = vec_ld(0, src); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
357 valigner = VEC_ALIGNER(src); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
358 |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
359 while (width) { |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
360 vector unsigned short vR, vG, vB; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
361 vector unsigned char vdst1, vdst2; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
362 |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
363 voverflow = vec_ld(15, src); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
364 vsrc = vec_perm(vsrc, voverflow, valigner); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
365 |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
366 vR = vec_and((vector unsigned short)vsrc, vf800); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
367 vB = vec_sl((vector unsigned short)vsrc, v3); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
368 vG = vec_sl(vB, v2); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
369 |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
370 vdst1 = (vector unsigned char)vec_perm((vector unsigned char)vR, valpha, vredalpha1); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
371 vdst1 = vec_perm(vdst1, (vector unsigned char)vB, vblue1); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
372 vdst1 = vec_perm(vdst1, (vector unsigned char)vG, vgreen1); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
373 vdst1 = vec_perm(vdst1, valpha, vpermute); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
374 vec_st(vdst1, 0, dst); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
375 |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
376 vdst2 = (vector unsigned char)vec_perm((vector unsigned char)vR, valpha, vredalpha2); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
377 vdst2 = vec_perm(vdst2, (vector unsigned char)vB, vblue2); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
378 vdst2 = vec_perm(vdst2, (vector unsigned char)vG, vgreen2); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
379 vdst2 = vec_perm(vdst2, valpha, vpermute); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
380 vec_st(vdst2, 16, dst); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
381 |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
382 width -= 8; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
383 dst += 32; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
384 src += 16; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
385 vsrc = voverflow; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
386 } |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
387 |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
388 assert(width == 0); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
389 |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
390 |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
391 /* do scalar until we can align... */ |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
392 ONE_PIXEL_BLEND((extrawidth), extrawidth); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
393 #undef ONE_PIXEL_BLEND |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
394 |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
395 src += srcskip; /* move to next row, accounting for pitch. */ |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
396 dst += dstskip; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
397 } |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
398 |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
399 } |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
400 |
1139
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
401 |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
402 static void Blit_RGB555_32Altivec(SDL_BlitInfo *info) { |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
403 int height = info->d_height; |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
404 Uint8 *src = (Uint8 *) info->s_pixels; |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
405 int srcskip = info->s_skip; |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
406 Uint8 *dst = (Uint8 *) info->d_pixels; |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
407 int dstskip = info->d_skip; |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
408 SDL_PixelFormat *srcfmt = info->src; |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
409 SDL_PixelFormat *dstfmt = info->dst; |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
410 unsigned alpha; |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
411 vector unsigned char valpha; |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
412 vector unsigned char vpermute; |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
413 vector unsigned short vf800; |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
414 vector unsigned int v8 = vec_splat_u32(8); |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
415 vector unsigned int v16 = vec_add(v8, v8); |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
416 vector unsigned short v1 = vec_splat_u16(1); |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
417 vector unsigned short v3 = vec_splat_u16(3); |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
418 /* |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
419 0x10 - 0x1f is the alpha |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
420 0x00 - 0x0e evens are the red |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
421 0x01 - 0x0f odds are zero |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
422 */ |
1162
2651158f59b8
Enable altivec blitters on PowerPC Linux, and some fixes for recent
Ryan C. Gordon <icculus@icculus.org>
parents:
1139
diff
changeset
|
423 vector unsigned char vredalpha1 = VECUINT8_LITERAL( |
1139
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
424 0x10, 0x00, 0x01, 0x01, |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
425 0x10, 0x02, 0x01, 0x01, |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
426 0x10, 0x04, 0x01, 0x01, |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
427 0x10, 0x06, 0x01, 0x01 |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
428 ); |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
429 vector unsigned char vredalpha2 = (vector unsigned char)( |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
430 vec_add((vector unsigned int)vredalpha1, vec_sl(v8, v16)) |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
431 ); |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
432 /* |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
433 0x00 - 0x0f is ARxx ARxx ARxx ARxx |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
434 0x11 - 0x0f odds are blue |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
435 */ |
1162
2651158f59b8
Enable altivec blitters on PowerPC Linux, and some fixes for recent
Ryan C. Gordon <icculus@icculus.org>
parents:
1139
diff
changeset
|
436 vector unsigned char vblue1 = VECUINT8_LITERAL( |
1139
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
437 0x00, 0x01, 0x02, 0x11, |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
438 0x04, 0x05, 0x06, 0x13, |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
439 0x08, 0x09, 0x0a, 0x15, |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
440 0x0c, 0x0d, 0x0e, 0x17 |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
441 ); |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
442 vector unsigned char vblue2 = (vector unsigned char)( |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
443 vec_add((vector unsigned int)vblue1, v8) |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
444 ); |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
445 /* |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
446 0x00 - 0x0f is ARxB ARxB ARxB ARxB |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
447 0x10 - 0x0e evens are green |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
448 */ |
1162
2651158f59b8
Enable altivec blitters on PowerPC Linux, and some fixes for recent
Ryan C. Gordon <icculus@icculus.org>
parents:
1139
diff
changeset
|
449 vector unsigned char vgreen1 = VECUINT8_LITERAL( |
1139
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
450 0x00, 0x01, 0x10, 0x03, |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
451 0x04, 0x05, 0x12, 0x07, |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
452 0x08, 0x09, 0x14, 0x0b, |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
453 0x0c, 0x0d, 0x16, 0x0f |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
454 ); |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
455 vector unsigned char vgreen2 = (vector unsigned char)( |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
456 vec_add((vector unsigned int)vgreen1, vec_sl(v8, v8)) |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
457 ); |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
458 |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
459 |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
460 assert(srcfmt->BytesPerPixel == 2); |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
461 assert(dstfmt->BytesPerPixel == 4); |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
462 |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
463 vf800 = (vector unsigned short)vec_splat_u8(-7); |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
464 vf800 = vec_sl(vf800, vec_splat_u16(8)); |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
465 |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
466 if (dstfmt->Amask && srcfmt->alpha) { |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
467 ((unsigned char *)&valpha)[0] = alpha = srcfmt->alpha; |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
468 valpha = vec_splat(valpha, 0); |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
469 } else { |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
470 alpha = 0; |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
471 valpha = vec_splat_u8(0); |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
472 } |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
473 |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
474 vpermute = calc_swizzle32(NULL, dstfmt); |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
475 while (height--) { |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
476 vector unsigned char valigner; |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
477 vector unsigned char voverflow; |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
478 vector unsigned char vsrc; |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
479 |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
480 int width = info->d_width; |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
481 int extrawidth; |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
482 |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
483 /* do scalar until we can align... */ |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
484 #define ONE_PIXEL_BLEND(condition, widthvar) \ |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
485 while (condition) { \ |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
486 unsigned sR, sG, sB; \ |
1162
2651158f59b8
Enable altivec blitters on PowerPC Linux, and some fixes for recent
Ryan C. Gordon <icculus@icculus.org>
parents:
1139
diff
changeset
|
487 unsigned short Pixel = *((unsigned short *)src); \ |
2651158f59b8
Enable altivec blitters on PowerPC Linux, and some fixes for recent
Ryan C. Gordon <icculus@icculus.org>
parents:
1139
diff
changeset
|
488 sR = (Pixel >> 7) & 0xf8; \ |
2651158f59b8
Enable altivec blitters on PowerPC Linux, and some fixes for recent
Ryan C. Gordon <icculus@icculus.org>
parents:
1139
diff
changeset
|
489 sG = (Pixel >> 2) & 0xf8; \ |
2651158f59b8
Enable altivec blitters on PowerPC Linux, and some fixes for recent
Ryan C. Gordon <icculus@icculus.org>
parents:
1139
diff
changeset
|
490 sB = (Pixel << 3) & 0xf8; \ |
1139
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
491 ASSEMBLE_RGBA(dst, 4, dstfmt, sR, sG, sB, alpha); \ |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
492 src += 2; \ |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
493 dst += 4; \ |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
494 widthvar--; \ |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
495 } |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
496 ONE_PIXEL_BLEND(((UNALIGNED_PTR(dst)) && (width)), width); |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
497 |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
498 /* After all that work, here's the vector part! */ |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
499 extrawidth = (width % 8); /* trailing unaligned stores */ |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
500 width -= extrawidth; |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
501 vsrc = vec_ld(0, src); |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
502 valigner = VEC_ALIGNER(src); |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
503 |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
504 while (width) { |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
505 vector unsigned short vR, vG, vB; |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
506 vector unsigned char vdst1, vdst2; |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
507 |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
508 voverflow = vec_ld(15, src); |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
509 vsrc = vec_perm(vsrc, voverflow, valigner); |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
510 |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
511 vR = vec_and(vec_sl((vector unsigned short)vsrc,v1), vf800); |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
512 vB = vec_sl((vector unsigned short)vsrc, v3); |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
513 vG = vec_sl(vB, v3); |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
514 |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
515 vdst1 = (vector unsigned char)vec_perm((vector unsigned char)vR, valpha, vredalpha1); |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
516 vdst1 = vec_perm(vdst1, (vector unsigned char)vB, vblue1); |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
517 vdst1 = vec_perm(vdst1, (vector unsigned char)vG, vgreen1); |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
518 vdst1 = vec_perm(vdst1, valpha, vpermute); |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
519 vec_st(vdst1, 0, dst); |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
520 |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
521 vdst2 = (vector unsigned char)vec_perm((vector unsigned char)vR, valpha, vredalpha2); |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
522 vdst2 = vec_perm(vdst2, (vector unsigned char)vB, vblue2); |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
523 vdst2 = vec_perm(vdst2, (vector unsigned char)vG, vgreen2); |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
524 vdst2 = vec_perm(vdst2, valpha, vpermute); |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
525 vec_st(vdst2, 16, dst); |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
526 |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
527 width -= 8; |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
528 dst += 32; |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
529 src += 16; |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
530 vsrc = voverflow; |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
531 } |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
532 |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
533 assert(width == 0); |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
534 |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
535 |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
536 /* do scalar until we can align... */ |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
537 ONE_PIXEL_BLEND((extrawidth), extrawidth); |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
538 #undef ONE_PIXEL_BLEND |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
539 |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
540 src += srcskip; /* move to next row, accounting for pitch. */ |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
541 dst += dstskip; |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
542 } |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
543 |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
544 } |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
545 |
1047
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
546 static void BlitNtoNKey(SDL_BlitInfo *info); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
547 static void BlitNtoNKeyCopyAlpha(SDL_BlitInfo *info); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
548 static void Blit32to32KeyAltivec(SDL_BlitInfo *info) |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
549 { |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
550 int height = info->d_height; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
551 Uint32 *srcp = (Uint32 *) info->s_pixels; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
552 int srcskip = info->s_skip; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
553 Uint32 *dstp = (Uint32 *) info->d_pixels; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
554 int dstskip = info->d_skip; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
555 SDL_PixelFormat *srcfmt = info->src; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
556 int srcbpp = srcfmt->BytesPerPixel; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
557 SDL_PixelFormat *dstfmt = info->dst; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
558 int dstbpp = dstfmt->BytesPerPixel; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
559 int copy_alpha = (srcfmt->Amask && dstfmt->Amask); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
560 unsigned alpha = dstfmt->Amask ? srcfmt->alpha : 0; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
561 Uint32 rgbmask = srcfmt->Rmask | srcfmt->Gmask | srcfmt->Bmask; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
562 Uint32 ckey = info->src->colorkey; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
563 vector unsigned int valpha; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
564 vector unsigned char vpermute; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
565 vector unsigned char vzero; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
566 vector unsigned int vckey; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
567 vector unsigned int vrgbmask; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
568 vpermute = calc_swizzle32(srcfmt, dstfmt); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
569 if (info->d_width < 16) { |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
570 if(copy_alpha) { |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
571 return BlitNtoNKeyCopyAlpha(info); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
572 } else { |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
573 return BlitNtoNKey(info); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
574 } |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
575 } |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
576 vzero = vec_splat_u8(0); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
577 if (alpha) { |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
578 ((unsigned char *)&valpha)[0] = (unsigned char)alpha; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
579 valpha = (vector unsigned int)vec_splat((vector unsigned char)valpha, 0); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
580 } else { |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
581 valpha = (vector unsigned int)vzero; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
582 } |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
583 ckey &= rgbmask; |
1162
2651158f59b8
Enable altivec blitters on PowerPC Linux, and some fixes for recent
Ryan C. Gordon <icculus@icculus.org>
parents:
1139
diff
changeset
|
584 ((unsigned int *)(char*)&vckey)[0] = ckey; |
1047
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
585 vckey = vec_splat(vckey, 0); |
1162
2651158f59b8
Enable altivec blitters on PowerPC Linux, and some fixes for recent
Ryan C. Gordon <icculus@icculus.org>
parents:
1139
diff
changeset
|
586 ((unsigned int *)(char*)&vrgbmask)[0] = rgbmask; |
1047
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
587 vrgbmask = vec_splat(vrgbmask, 0); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
588 |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
589 while (height--) { |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
590 #define ONE_PIXEL_BLEND(condition, widthvar) \ |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
591 if (copy_alpha) { \ |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
592 while (condition) { \ |
1162
2651158f59b8
Enable altivec blitters on PowerPC Linux, and some fixes for recent
Ryan C. Gordon <icculus@icculus.org>
parents:
1139
diff
changeset
|
593 Uint32 Pixel; \ |
1047
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
594 unsigned sR, sG, sB, sA; \ |
1162
2651158f59b8
Enable altivec blitters on PowerPC Linux, and some fixes for recent
Ryan C. Gordon <icculus@icculus.org>
parents:
1139
diff
changeset
|
595 DISEMBLE_RGBA((Uint8 *)srcp, srcbpp, srcfmt, Pixel, \ |
1047
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
596 sR, sG, sB, sA); \ |
1162
2651158f59b8
Enable altivec blitters on PowerPC Linux, and some fixes for recent
Ryan C. Gordon <icculus@icculus.org>
parents:
1139
diff
changeset
|
597 if ( (Pixel & rgbmask) != ckey ) { \ |
1047
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
598 ASSEMBLE_RGBA((Uint8 *)dstp, dstbpp, dstfmt, \ |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
599 sR, sG, sB, sA); \ |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
600 } \ |
1162
2651158f59b8
Enable altivec blitters on PowerPC Linux, and some fixes for recent
Ryan C. Gordon <icculus@icculus.org>
parents:
1139
diff
changeset
|
601 dstp = (Uint32 *) (((Uint8 *) dstp) + dstbpp); \ |
2651158f59b8
Enable altivec blitters on PowerPC Linux, and some fixes for recent
Ryan C. Gordon <icculus@icculus.org>
parents:
1139
diff
changeset
|
602 srcp = (Uint32 *) (((Uint8 *) srcp) + srcbpp); \ |
1047
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
603 widthvar--; \ |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
604 } \ |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
605 } else { \ |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
606 while (condition) { \ |
1162
2651158f59b8
Enable altivec blitters on PowerPC Linux, and some fixes for recent
Ryan C. Gordon <icculus@icculus.org>
parents:
1139
diff
changeset
|
607 Uint32 Pixel; \ |
1047
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
608 unsigned sR, sG, sB; \ |
1162
2651158f59b8
Enable altivec blitters on PowerPC Linux, and some fixes for recent
Ryan C. Gordon <icculus@icculus.org>
parents:
1139
diff
changeset
|
609 RETRIEVE_RGB_PIXEL((Uint8 *)srcp, srcbpp, Pixel); \ |
2651158f59b8
Enable altivec blitters on PowerPC Linux, and some fixes for recent
Ryan C. Gordon <icculus@icculus.org>
parents:
1139
diff
changeset
|
610 if ( Pixel != ckey ) { \ |
2651158f59b8
Enable altivec blitters on PowerPC Linux, and some fixes for recent
Ryan C. Gordon <icculus@icculus.org>
parents:
1139
diff
changeset
|
611 RGB_FROM_PIXEL(Pixel, srcfmt, sR, sG, sB); \ |
1047
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
612 ASSEMBLE_RGBA((Uint8 *)dstp, dstbpp, dstfmt, \ |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
613 sR, sG, sB, alpha); \ |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
614 } \ |
1162
2651158f59b8
Enable altivec blitters on PowerPC Linux, and some fixes for recent
Ryan C. Gordon <icculus@icculus.org>
parents:
1139
diff
changeset
|
615 dstp = (Uint32 *) (((Uint8 *)dstp) + dstbpp); \ |
2651158f59b8
Enable altivec blitters on PowerPC Linux, and some fixes for recent
Ryan C. Gordon <icculus@icculus.org>
parents:
1139
diff
changeset
|
616 srcp = (Uint32 *) (((Uint8 *)srcp) + srcbpp); \ |
1047
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
617 widthvar--; \ |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
618 } \ |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
619 } |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
620 int width = info->d_width; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
621 ONE_PIXEL_BLEND((UNALIGNED_PTR(dstp)) && (width), width); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
622 assert(width > 0); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
623 if (width > 0) { |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
624 int extrawidth = (width % 4); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
625 vector unsigned char valigner = VEC_ALIGNER(srcp); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
626 vector unsigned int vs = vec_ld(0, srcp); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
627 width -= extrawidth; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
628 assert(width >= 4); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
629 while (width) { |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
630 vector unsigned char vsel; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
631 vector unsigned int vd; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
632 vector unsigned int voverflow = vec_ld(15, srcp); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
633 /* load the source vec */ |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
634 vs = vec_perm(vs, voverflow, valigner); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
635 /* vsel is set for items that match the key */ |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
636 vsel = (vector unsigned char)vec_and(vs, vrgbmask); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
637 vsel = (vector unsigned char)vec_cmpeq(vs, vckey); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
638 /* permute the src vec to the dest format */ |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
639 vs = vec_perm(vs, valpha, vpermute); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
640 /* load the destination vec */ |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
641 vd = vec_ld(0, dstp); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
642 /* select the source and dest into vs */ |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
643 vd = (vector unsigned int)vec_sel((vector unsigned char)vs, (vector unsigned char)vd, vsel); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
644 |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
645 vec_st(vd, 0, dstp); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
646 srcp += 4; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
647 width -= 4; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
648 dstp += 4; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
649 vs = voverflow; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
650 } |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
651 ONE_PIXEL_BLEND((extrawidth), extrawidth); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
652 #undef ONE_PIXEL_BLEND |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
653 srcp += srcskip >> 2; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
654 dstp += dstskip >> 2; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
655 } |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
656 } |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
657 } |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
658 |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
659 /* Altivec code to swizzle one 32-bit surface to a different 32-bit format. */ |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
660 /* Use this on a G5 */ |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
661 static void ConvertAltivec32to32_noprefetch(SDL_BlitInfo *info) |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
662 { |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
663 int height = info->d_height; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
664 Uint32 *src = (Uint32 *) info->s_pixels; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
665 int srcskip = info->s_skip; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
666 Uint32 *dst = (Uint32 *) info->d_pixels; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
667 int dstskip = info->d_skip; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
668 SDL_PixelFormat *srcfmt = info->src; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
669 int srcbpp = srcfmt->BytesPerPixel; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
670 SDL_PixelFormat *dstfmt = info->dst; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
671 int dstbpp = dstfmt->BytesPerPixel; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
672 vector unsigned int vzero = vec_splat_u32(0); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
673 vector unsigned char vpermute = calc_swizzle32(srcfmt, dstfmt); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
674 if (dstfmt->Amask && !srcfmt->Amask) { |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
675 if (srcfmt->alpha) { |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
676 vector unsigned char valpha; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
677 ((unsigned char *)&valpha)[0] = srcfmt->alpha; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
678 vzero = (vector unsigned int)vec_splat(valpha, 0); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
679 } |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
680 } |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
681 |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
682 assert(srcbpp == 4); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
683 assert(dstbpp == 4); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
684 |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
685 while (height--) { |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
686 vector unsigned char valigner; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
687 vector unsigned int vbits; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
688 vector unsigned int voverflow; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
689 Uint32 bits; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
690 Uint8 r, g, b, a; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
691 |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
692 int width = info->d_width; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
693 int extrawidth; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
694 |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
695 /* do scalar until we can align... */ |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
696 while ((UNALIGNED_PTR(dst)) && (width)) { |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
697 bits = *(src++); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
698 RGBA_FROM_8888(bits, srcfmt, r, g, b, a); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
699 *(dst++) = MAKE8888(dstfmt, r, g, b, a); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
700 width--; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
701 } |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
702 |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
703 /* After all that work, here's the vector part! */ |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
704 extrawidth = (width % 4); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
705 width -= extrawidth; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
706 valigner = VEC_ALIGNER(src); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
707 vbits = vec_ld(0, src); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
708 |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
709 while (width) { |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
710 voverflow = vec_ld(15, src); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
711 src += 4; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
712 width -= 4; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
713 vbits = vec_perm(vbits, voverflow, valigner); /* src is ready. */ |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
714 vbits = vec_perm(vbits, vzero, vpermute); /* swizzle it. */ |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
715 vec_st(vbits, 0, dst); /* store it back out. */ |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
716 dst += 4; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
717 vbits = voverflow; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
718 } |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
719 |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
720 assert(width == 0); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
721 |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
722 /* cover pixels at the end of the row that didn't fit in 16 bytes. */ |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
723 while (extrawidth) { |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
724 bits = *(src++); /* max 7 pixels, don't bother with prefetch. */ |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
725 RGBA_FROM_8888(bits, srcfmt, r, g, b, a); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
726 *(dst++) = MAKE8888(dstfmt, r, g, b, a); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
727 extrawidth--; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
728 } |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
729 |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
730 src += srcskip >> 2; /* move to next row, accounting for pitch. */ |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
731 dst += dstskip >> 2; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
732 } |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
733 |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
734 } |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
735 |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
736 /* Altivec code to swizzle one 32-bit surface to a different 32-bit format. */ |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
737 /* Use this on a G4 */ |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
738 static void ConvertAltivec32to32_prefetch(SDL_BlitInfo *info) |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
739 { |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
740 const int scalar_dst_lead = sizeof (Uint32) * 4; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
741 const int vector_dst_lead = sizeof (Uint32) * 16; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
742 |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
743 int height = info->d_height; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
744 Uint32 *src = (Uint32 *) info->s_pixels; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
745 int srcskip = info->s_skip; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
746 Uint32 *dst = (Uint32 *) info->d_pixels; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
747 int dstskip = info->d_skip; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
748 SDL_PixelFormat *srcfmt = info->src; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
749 int srcbpp = srcfmt->BytesPerPixel; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
750 SDL_PixelFormat *dstfmt = info->dst; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
751 int dstbpp = dstfmt->BytesPerPixel; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
752 vector unsigned int vzero = vec_splat_u32(0); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
753 vector unsigned char vpermute = calc_swizzle32(srcfmt, dstfmt); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
754 if (dstfmt->Amask && !srcfmt->Amask) { |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
755 if (srcfmt->alpha) { |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
756 vector unsigned char valpha; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
757 ((unsigned char *)&valpha)[0] = srcfmt->alpha; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
758 vzero = (vector unsigned int)vec_splat(valpha, 0); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
759 } |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
760 } |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
761 |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
762 assert(srcbpp == 4); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
763 assert(dstbpp == 4); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
764 |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
765 while (height--) { |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
766 vector unsigned char valigner; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
767 vector unsigned int vbits; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
768 vector unsigned int voverflow; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
769 Uint32 bits; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
770 Uint8 r, g, b, a; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
771 |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
772 int width = info->d_width; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
773 int extrawidth; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
774 |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
775 /* do scalar until we can align... */ |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
776 while ((UNALIGNED_PTR(dst)) && (width)) { |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
777 vec_dstt(src+scalar_dst_lead, DST_CTRL(2,32,1024), DST_CHAN_SRC); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
778 vec_dstst(dst+scalar_dst_lead, DST_CTRL(2,32,1024), DST_CHAN_DEST); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
779 bits = *(src++); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
780 RGBA_FROM_8888(bits, srcfmt, r, g, b, a); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
781 *(dst++) = MAKE8888(dstfmt, r, g, b, a); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
782 width--; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
783 } |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
784 |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
785 /* After all that work, here's the vector part! */ |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
786 extrawidth = (width % 4); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
787 width -= extrawidth; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
788 valigner = VEC_ALIGNER(src); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
789 vbits = vec_ld(0, src); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
790 |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
791 while (width) { |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
792 vec_dstt(src+vector_dst_lead, DST_CTRL(2,32,1024), DST_CHAN_SRC); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
793 vec_dstst(dst+vector_dst_lead, DST_CTRL(2,32,1024), DST_CHAN_DEST); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
794 voverflow = vec_ld(15, src); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
795 src += 4; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
796 width -= 4; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
797 vbits = vec_perm(vbits, voverflow, valigner); /* src is ready. */ |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
798 vbits = vec_perm(vbits, vzero, vpermute); /* swizzle it. */ |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
799 vec_st(vbits, 0, dst); /* store it back out. */ |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
800 dst += 4; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
801 vbits = voverflow; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
802 } |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
803 |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
804 assert(width == 0); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
805 |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
806 /* cover pixels at the end of the row that didn't fit in 16 bytes. */ |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
807 while (extrawidth) { |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
808 bits = *(src++); /* max 7 pixels, don't bother with prefetch. */ |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
809 RGBA_FROM_8888(bits, srcfmt, r, g, b, a); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
810 *(dst++) = MAKE8888(dstfmt, r, g, b, a); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
811 extrawidth--; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
812 } |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
813 |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
814 src += srcskip >> 2; /* move to next row, accounting for pitch. */ |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
815 dst += dstskip >> 2; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
816 } |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
817 |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
818 vec_dss(DST_CHAN_SRC); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
819 vec_dss(DST_CHAN_DEST); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
820 } |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
821 |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
822 static Uint32 GetBlitFeatures( void ) |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
823 { |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
824 static Uint32 features = 0xffffffff; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
825 if (features == 0xffffffff) { |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
826 /* Provide an override for testing .. */ |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
827 char *override = getenv("SDL_ALTIVEC_BLIT_FEATURES"); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
828 if (override) { |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
829 features = 0; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
830 sscanf(override, "%u", &features); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
831 } else { |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
832 features = ( 0 |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
833 /* Feature 1 is has-MMX */ |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
834 | ((SDL_HasMMX()) ? 1 : 0) |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
835 /* Feature 2 is has-AltiVec */ |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
836 | ((SDL_HasAltiVec()) ? 2 : 0) |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
837 /* Feature 4 is dont-use-prefetch */ |
1162
2651158f59b8
Enable altivec blitters on PowerPC Linux, and some fixes for recent
Ryan C. Gordon <icculus@icculus.org>
parents:
1139
diff
changeset
|
838 /* !!!! FIXME: Check for G5 or later, not the cache size! Always prefetch on a G4. */ |
1047
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
839 | ((GetL3CacheSize() == 0) ? 4 : 0) |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
840 ); |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
841 } |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
842 } |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
843 return features; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
844 } |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
845 #else |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
846 /* Feature 1 is has-MMX */ |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
847 #define GetBlitFeatures() ((Uint32)(SDL_HasMMX() ? 1 : 0)) |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
848 #endif |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
849 |
1053
f596fa4f17a6
Patched to compile again on x86 systems that use the assembly blitters.
Ryan C. Gordon <icculus@icculus.org>
parents:
1047
diff
changeset
|
850 /* This is now endian dependent */ |
f596fa4f17a6
Patched to compile again on x86 systems that use the assembly blitters.
Ryan C. Gordon <icculus@icculus.org>
parents:
1047
diff
changeset
|
851 #if ( SDL_BYTEORDER == SDL_LIL_ENDIAN ) |
f596fa4f17a6
Patched to compile again on x86 systems that use the assembly blitters.
Ryan C. Gordon <icculus@icculus.org>
parents:
1047
diff
changeset
|
852 #define HI 1 |
f596fa4f17a6
Patched to compile again on x86 systems that use the assembly blitters.
Ryan C. Gordon <icculus@icculus.org>
parents:
1047
diff
changeset
|
853 #define LO 0 |
f596fa4f17a6
Patched to compile again on x86 systems that use the assembly blitters.
Ryan C. Gordon <icculus@icculus.org>
parents:
1047
diff
changeset
|
854 #else /* ( SDL_BYTEORDER == SDL_BIG_ENDIAN ) */ |
f596fa4f17a6
Patched to compile again on x86 systems that use the assembly blitters.
Ryan C. Gordon <icculus@icculus.org>
parents:
1047
diff
changeset
|
855 #define HI 0 |
f596fa4f17a6
Patched to compile again on x86 systems that use the assembly blitters.
Ryan C. Gordon <icculus@icculus.org>
parents:
1047
diff
changeset
|
856 #define LO 1 |
f596fa4f17a6
Patched to compile again on x86 systems that use the assembly blitters.
Ryan C. Gordon <icculus@icculus.org>
parents:
1047
diff
changeset
|
857 #endif |
f596fa4f17a6
Patched to compile again on x86 systems that use the assembly blitters.
Ryan C. Gordon <icculus@icculus.org>
parents:
1047
diff
changeset
|
858 |
0 | 859 #ifdef USE_ASMBLIT |
860 | |
861 /* Heheheh, we coerce Hermes into using SDL blit information */ | |
862 #define X86_ASSEMBLER | |
863 #define HermesConverterInterface SDL_BlitInfo | |
864 #define HermesClearInterface void | |
865 #define STACKCALL | |
866 | |
867 #include "HeadMMX.h" | |
868 #include "HeadX86.h" | |
869 | |
870 #else | |
871 | |
872 /* Special optimized blit for RGB 8-8-8 --> RGB 3-3-2 */ | |
873 #define RGB888_RGB332(dst, src) { \ | |
874 dst = (((src)&0x00E00000)>>16)| \ | |
875 (((src)&0x0000E000)>>11)| \ | |
876 (((src)&0x000000C0)>>6); \ | |
877 } | |
878 static void Blit_RGB888_index8(SDL_BlitInfo *info) | |
879 { | |
880 #ifndef USE_DUFFS_LOOP | |
881 int c; | |
882 #endif | |
883 int width, height; | |
884 Uint32 *src; | |
91
e85e03f195b4
From: "Markus F.X.J. Oberhumer"
Sam Lantinga <slouken@lokigames.com>
parents:
0
diff
changeset
|
885 const Uint8 *map; |
e85e03f195b4
From: "Markus F.X.J. Oberhumer"
Sam Lantinga <slouken@lokigames.com>
parents:
0
diff
changeset
|
886 Uint8 *dst; |
0 | 887 int srcskip, dstskip; |
888 | |
889 /* Set up some basic variables */ | |
890 width = info->d_width; | |
891 height = info->d_height; | |
892 src = (Uint32 *)info->s_pixels; | |
893 srcskip = info->s_skip/4; | |
894 dst = info->d_pixels; | |
895 dstskip = info->d_skip; | |
896 map = info->table; | |
897 | |
898 if ( map == NULL ) { | |
899 while ( height-- ) { | |
900 #ifdef USE_DUFFS_LOOP | |
901 DUFFS_LOOP( | |
902 RGB888_RGB332(*dst++, *src); | |
903 , width); | |
904 #else | |
905 for ( c=width/4; c; --c ) { | |
906 /* Pack RGB into 8bit pixel */ | |
907 ++src; | |
908 RGB888_RGB332(*dst++, *src); | |
909 ++src; | |
910 RGB888_RGB332(*dst++, *src); | |
911 ++src; | |
912 RGB888_RGB332(*dst++, *src); | |
913 ++src; | |
914 } | |
91
e85e03f195b4
From: "Markus F.X.J. Oberhumer"
Sam Lantinga <slouken@lokigames.com>
parents:
0
diff
changeset
|
915 switch ( width & 3 ) { |
0 | 916 case 3: |
917 RGB888_RGB332(*dst++, *src); | |
918 ++src; | |
919 case 2: | |
920 RGB888_RGB332(*dst++, *src); | |
921 ++src; | |
922 case 1: | |
923 RGB888_RGB332(*dst++, *src); | |
924 ++src; | |
925 } | |
926 #endif /* USE_DUFFS_LOOP */ | |
927 src += srcskip; | |
928 dst += dstskip; | |
929 } | |
930 } else { | |
1162
2651158f59b8
Enable altivec blitters on PowerPC Linux, and some fixes for recent
Ryan C. Gordon <icculus@icculus.org>
parents:
1139
diff
changeset
|
931 int Pixel; |
0 | 932 |
933 while ( height-- ) { | |
934 #ifdef USE_DUFFS_LOOP | |
935 DUFFS_LOOP( | |
1162
2651158f59b8
Enable altivec blitters on PowerPC Linux, and some fixes for recent
Ryan C. Gordon <icculus@icculus.org>
parents:
1139
diff
changeset
|
936 RGB888_RGB332(Pixel, *src); |
2651158f59b8
Enable altivec blitters on PowerPC Linux, and some fixes for recent
Ryan C. Gordon <icculus@icculus.org>
parents:
1139
diff
changeset
|
937 *dst++ = map[Pixel]; |
0 | 938 ++src; |
939 , width); | |
940 #else | |
941 for ( c=width/4; c; --c ) { | |
942 /* Pack RGB into 8bit pixel */ | |
1162
2651158f59b8
Enable altivec blitters on PowerPC Linux, and some fixes for recent
Ryan C. Gordon <icculus@icculus.org>
parents:
1139
diff
changeset
|
943 RGB888_RGB332(Pixel, *src); |
2651158f59b8
Enable altivec blitters on PowerPC Linux, and some fixes for recent
Ryan C. Gordon <icculus@icculus.org>
parents:
1139
diff
changeset
|
944 *dst++ = map[Pixel]; |
0 | 945 ++src; |
1162
2651158f59b8
Enable altivec blitters on PowerPC Linux, and some fixes for recent
Ryan C. Gordon <icculus@icculus.org>
parents:
1139
diff
changeset
|
946 RGB888_RGB332(Pixel, *src); |
2651158f59b8
Enable altivec blitters on PowerPC Linux, and some fixes for recent
Ryan C. Gordon <icculus@icculus.org>
parents:
1139
diff
changeset
|
947 *dst++ = map[Pixel]; |
0 | 948 ++src; |
1162
2651158f59b8
Enable altivec blitters on PowerPC Linux, and some fixes for recent
Ryan C. Gordon <icculus@icculus.org>
parents:
1139
diff
changeset
|
949 RGB888_RGB332(Pixel, *src); |
2651158f59b8
Enable altivec blitters on PowerPC Linux, and some fixes for recent
Ryan C. Gordon <icculus@icculus.org>
parents:
1139
diff
changeset
|
950 *dst++ = map[Pixel]; |
0 | 951 ++src; |
1162
2651158f59b8
Enable altivec blitters on PowerPC Linux, and some fixes for recent
Ryan C. Gordon <icculus@icculus.org>
parents:
1139
diff
changeset
|
952 RGB888_RGB332(Pixel, *src); |
2651158f59b8
Enable altivec blitters on PowerPC Linux, and some fixes for recent
Ryan C. Gordon <icculus@icculus.org>
parents:
1139
diff
changeset
|
953 *dst++ = map[Pixel]; |
0 | 954 ++src; |
955 } | |
91
e85e03f195b4
From: "Markus F.X.J. Oberhumer"
Sam Lantinga <slouken@lokigames.com>
parents:
0
diff
changeset
|
956 switch ( width & 3 ) { |
0 | 957 case 3: |
1162
2651158f59b8
Enable altivec blitters on PowerPC Linux, and some fixes for recent
Ryan C. Gordon <icculus@icculus.org>
parents:
1139
diff
changeset
|
958 RGB888_RGB332(Pixel, *src); |
2651158f59b8
Enable altivec blitters on PowerPC Linux, and some fixes for recent
Ryan C. Gordon <icculus@icculus.org>
parents:
1139
diff
changeset
|
959 *dst++ = map[Pixel]; |
0 | 960 ++src; |
961 case 2: | |
1162
2651158f59b8
Enable altivec blitters on PowerPC Linux, and some fixes for recent
Ryan C. Gordon <icculus@icculus.org>
parents:
1139
diff
changeset
|
962 RGB888_RGB332(Pixel, *src); |
2651158f59b8
Enable altivec blitters on PowerPC Linux, and some fixes for recent
Ryan C. Gordon <icculus@icculus.org>
parents:
1139
diff
changeset
|
963 *dst++ = map[Pixel]; |
0 | 964 ++src; |
965 case 1: | |
1162
2651158f59b8
Enable altivec blitters on PowerPC Linux, and some fixes for recent
Ryan C. Gordon <icculus@icculus.org>
parents:
1139
diff
changeset
|
966 RGB888_RGB332(Pixel, *src); |
2651158f59b8
Enable altivec blitters on PowerPC Linux, and some fixes for recent
Ryan C. Gordon <icculus@icculus.org>
parents:
1139
diff
changeset
|
967 *dst++ = map[Pixel]; |
0 | 968 ++src; |
969 } | |
970 #endif /* USE_DUFFS_LOOP */ | |
971 src += srcskip; | |
972 dst += dstskip; | |
973 } | |
974 } | |
975 } | |
976 /* Special optimized blit for RGB 8-8-8 --> RGB 5-5-5 */ | |
977 #define RGB888_RGB555(dst, src) { \ | |
978 *(Uint16 *)(dst) = (((*src)&0x00F80000)>>9)| \ | |
979 (((*src)&0x0000F800)>>6)| \ | |
980 (((*src)&0x000000F8)>>3); \ | |
981 } | |
982 #define RGB888_RGB555_TWO(dst, src) { \ | |
983 *(Uint32 *)(dst) = (((((src[HI])&0x00F80000)>>9)| \ | |
984 (((src[HI])&0x0000F800)>>6)| \ | |
985 (((src[HI])&0x000000F8)>>3))<<16)| \ | |
986 (((src[LO])&0x00F80000)>>9)| \ | |
987 (((src[LO])&0x0000F800)>>6)| \ | |
988 (((src[LO])&0x000000F8)>>3); \ | |
989 } | |
990 static void Blit_RGB888_RGB555(SDL_BlitInfo *info) | |
991 { | |
992 #ifndef USE_DUFFS_LOOP | |
993 int c; | |
994 #endif | |
995 int width, height; | |
996 Uint32 *src; | |
997 Uint16 *dst; | |
998 int srcskip, dstskip; | |
999 | |
1000 /* Set up some basic variables */ | |
1001 width = info->d_width; | |
1002 height = info->d_height; | |
1003 src = (Uint32 *)info->s_pixels; | |
1004 srcskip = info->s_skip/4; | |
1005 dst = (Uint16 *)info->d_pixels; | |
1006 dstskip = info->d_skip/2; | |
1007 | |
1008 #ifdef USE_DUFFS_LOOP | |
1009 while ( height-- ) { | |
1010 DUFFS_LOOP( | |
1011 RGB888_RGB555(dst, src); | |
1012 ++src; | |
1013 ++dst; | |
1014 , width); | |
1015 src += srcskip; | |
1016 dst += dstskip; | |
1017 } | |
1018 #else | |
1019 /* Memory align at 4-byte boundary, if necessary */ | |
1020 if ( (long)dst & 0x03 ) { | |
1021 /* Don't do anything if width is 0 */ | |
1022 if ( width == 0 ) { | |
1023 return; | |
1024 } | |
1025 --width; | |
1026 | |
1027 while ( height-- ) { | |
1028 /* Perform copy alignment */ | |
1029 RGB888_RGB555(dst, src); | |
1030 ++src; | |
1031 ++dst; | |
1032 | |
1033 /* Copy in 4 pixel chunks */ | |
1034 for ( c=width/4; c; --c ) { | |
1035 RGB888_RGB555_TWO(dst, src); | |
1036 src += 2; | |
1037 dst += 2; | |
1038 RGB888_RGB555_TWO(dst, src); | |
1039 src += 2; | |
1040 dst += 2; | |
1041 } | |
1042 /* Get any leftovers */ | |
91
e85e03f195b4
From: "Markus F.X.J. Oberhumer"
Sam Lantinga <slouken@lokigames.com>
parents:
0
diff
changeset
|
1043 switch (width & 3) { |
0 | 1044 case 3: |
1045 RGB888_RGB555(dst, src); | |
1046 ++src; | |
1047 ++dst; | |
1048 case 2: | |
1049 RGB888_RGB555_TWO(dst, src); | |
1050 src += 2; | |
1051 dst += 2; | |
1052 break; | |
1053 case 1: | |
1054 RGB888_RGB555(dst, src); | |
1055 ++src; | |
1056 ++dst; | |
1057 break; | |
1058 } | |
1059 src += srcskip; | |
1060 dst += dstskip; | |
1061 } | |
1062 } else { | |
1063 while ( height-- ) { | |
1064 /* Copy in 4 pixel chunks */ | |
1065 for ( c=width/4; c; --c ) { | |
1066 RGB888_RGB555_TWO(dst, src); | |
1067 src += 2; | |
1068 dst += 2; | |
1069 RGB888_RGB555_TWO(dst, src); | |
1070 src += 2; | |
1071 dst += 2; | |
1072 } | |
1073 /* Get any leftovers */ | |
91
e85e03f195b4
From: "Markus F.X.J. Oberhumer"
Sam Lantinga <slouken@lokigames.com>
parents:
0
diff
changeset
|
1074 switch (width & 3) { |
0 | 1075 case 3: |
1076 RGB888_RGB555(dst, src); | |
1077 ++src; | |
1078 ++dst; | |
1079 case 2: | |
1080 RGB888_RGB555_TWO(dst, src); | |
1081 src += 2; | |
1082 dst += 2; | |
1083 break; | |
1084 case 1: | |
1085 RGB888_RGB555(dst, src); | |
1086 ++src; | |
1087 ++dst; | |
1088 break; | |
1089 } | |
1090 src += srcskip; | |
1091 dst += dstskip; | |
1092 } | |
1093 } | |
1094 #endif /* USE_DUFFS_LOOP */ | |
1095 } | |
1096 /* Special optimized blit for RGB 8-8-8 --> RGB 5-6-5 */ | |
1097 #define RGB888_RGB565(dst, src) { \ | |
1098 *(Uint16 *)(dst) = (((*src)&0x00F80000)>>8)| \ | |
1099 (((*src)&0x0000FC00)>>5)| \ | |
1100 (((*src)&0x000000F8)>>3); \ | |
1101 } | |
1102 #define RGB888_RGB565_TWO(dst, src) { \ | |
1103 *(Uint32 *)(dst) = (((((src[HI])&0x00F80000)>>8)| \ | |
1104 (((src[HI])&0x0000FC00)>>5)| \ | |
1105 (((src[HI])&0x000000F8)>>3))<<16)| \ | |
1106 (((src[LO])&0x00F80000)>>8)| \ | |
1107 (((src[LO])&0x0000FC00)>>5)| \ | |
1108 (((src[LO])&0x000000F8)>>3); \ | |
1109 } | |
1110 static void Blit_RGB888_RGB565(SDL_BlitInfo *info) | |
1111 { | |
1112 #ifndef USE_DUFFS_LOOP | |
1113 int c; | |
1114 #endif | |
1115 int width, height; | |
1116 Uint32 *src; | |
1117 Uint16 *dst; | |
1118 int srcskip, dstskip; | |
1119 | |
1120 /* Set up some basic variables */ | |
1121 width = info->d_width; | |
1122 height = info->d_height; | |
1123 src = (Uint32 *)info->s_pixels; | |
1124 srcskip = info->s_skip/4; | |
1125 dst = (Uint16 *)info->d_pixels; | |
1126 dstskip = info->d_skip/2; | |
1127 | |
1128 #ifdef USE_DUFFS_LOOP | |
1129 while ( height-- ) { | |
1130 DUFFS_LOOP( | |
1131 RGB888_RGB565(dst, src); | |
1132 ++src; | |
1133 ++dst; | |
1134 , width); | |
1135 src += srcskip; | |
1136 dst += dstskip; | |
1137 } | |
1138 #else | |
1139 /* Memory align at 4-byte boundary, if necessary */ | |
1140 if ( (long)dst & 0x03 ) { | |
1141 /* Don't do anything if width is 0 */ | |
1142 if ( width == 0 ) { | |
1143 return; | |
1144 } | |
1145 --width; | |
1146 | |
1147 while ( height-- ) { | |
1148 /* Perform copy alignment */ | |
1149 RGB888_RGB565(dst, src); | |
1150 ++src; | |
1151 ++dst; | |
1152 | |
1153 /* Copy in 4 pixel chunks */ | |
1154 for ( c=width/4; c; --c ) { | |
1155 RGB888_RGB565_TWO(dst, src); | |
1156 src += 2; | |
1157 dst += 2; | |
1158 RGB888_RGB565_TWO(dst, src); | |
1159 src += 2; | |
1160 dst += 2; | |
1161 } | |
1162 /* Get any leftovers */ | |
91
e85e03f195b4
From: "Markus F.X.J. Oberhumer"
Sam Lantinga <slouken@lokigames.com>
parents:
0
diff
changeset
|
1163 switch (width & 3) { |
0 | 1164 case 3: |
1165 RGB888_RGB565(dst, src); | |
1166 ++src; | |
1167 ++dst; | |
1168 case 2: | |
1169 RGB888_RGB565_TWO(dst, src); | |
1170 src += 2; | |
1171 dst += 2; | |
1172 break; | |
1173 case 1: | |
1174 RGB888_RGB565(dst, src); | |
1175 ++src; | |
1176 ++dst; | |
1177 break; | |
1178 } | |
1179 src += srcskip; | |
1180 dst += dstskip; | |
1181 } | |
1182 } else { | |
1183 while ( height-- ) { | |
1184 /* Copy in 4 pixel chunks */ | |
1185 for ( c=width/4; c; --c ) { | |
1186 RGB888_RGB565_TWO(dst, src); | |
1187 src += 2; | |
1188 dst += 2; | |
1189 RGB888_RGB565_TWO(dst, src); | |
1190 src += 2; | |
1191 dst += 2; | |
1192 } | |
1193 /* Get any leftovers */ | |
91
e85e03f195b4
From: "Markus F.X.J. Oberhumer"
Sam Lantinga <slouken@lokigames.com>
parents:
0
diff
changeset
|
1194 switch (width & 3) { |
0 | 1195 case 3: |
1196 RGB888_RGB565(dst, src); | |
1197 ++src; | |
1198 ++dst; | |
1199 case 2: | |
1200 RGB888_RGB565_TWO(dst, src); | |
1201 src += 2; | |
1202 dst += 2; | |
1203 break; | |
1204 case 1: | |
1205 RGB888_RGB565(dst, src); | |
1206 ++src; | |
1207 ++dst; | |
1208 break; | |
1209 } | |
1210 src += srcskip; | |
1211 dst += dstskip; | |
1212 } | |
1213 } | |
1214 #endif /* USE_DUFFS_LOOP */ | |
1215 } | |
1216 | |
1217 #endif /* USE_ASMBLIT */ | |
1218 | |
1219 | |
1220 /* Special optimized blit for RGB 5-6-5 --> 32-bit RGB surfaces */ | |
1047
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
1221 #define RGB565_32(dst, src, map) (map[src[LO]*2] + map[src[HI]*2+1]) |
91
e85e03f195b4
From: "Markus F.X.J. Oberhumer"
Sam Lantinga <slouken@lokigames.com>
parents:
0
diff
changeset
|
1222 static void Blit_RGB565_32(SDL_BlitInfo *info, const Uint32 *map) |
0 | 1223 { |
1224 #ifndef USE_DUFFS_LOOP | |
1225 int c; | |
1226 #endif | |
1227 int width, height; | |
1228 Uint8 *src; | |
1229 Uint32 *dst; | |
1230 int srcskip, dstskip; | |
1231 | |
1232 /* Set up some basic variables */ | |
1233 width = info->d_width; | |
1234 height = info->d_height; | |
1235 src = (Uint8 *)info->s_pixels; | |
1236 srcskip = info->s_skip; | |
1237 dst = (Uint32 *)info->d_pixels; | |
1238 dstskip = info->d_skip/4; | |
1239 | |
1240 #ifdef USE_DUFFS_LOOP | |
1241 while ( height-- ) { | |
1242 DUFFS_LOOP( | |
1243 { | |
1244 *dst++ = RGB565_32(dst, src, map); | |
1245 src += 2; | |
1246 }, | |
1247 width); | |
1248 src += srcskip; | |
1249 dst += dstskip; | |
1250 } | |
1251 #else | |
1252 while ( height-- ) { | |
1253 /* Copy in 4 pixel chunks */ | |
1254 for ( c=width/4; c; --c ) { | |
1255 *dst++ = RGB565_32(dst, src, map); | |
1256 src += 2; | |
1257 *dst++ = RGB565_32(dst, src, map); | |
1258 src += 2; | |
1259 *dst++ = RGB565_32(dst, src, map); | |
1260 src += 2; | |
1261 *dst++ = RGB565_32(dst, src, map); | |
1262 src += 2; | |
1263 } | |
1264 /* Get any leftovers */ | |
91
e85e03f195b4
From: "Markus F.X.J. Oberhumer"
Sam Lantinga <slouken@lokigames.com>
parents:
0
diff
changeset
|
1265 switch (width & 3) { |
0 | 1266 case 3: |
1267 *dst++ = RGB565_32(dst, src, map); | |
1268 src += 2; | |
1269 case 2: | |
1270 *dst++ = RGB565_32(dst, src, map); | |
1271 src += 2; | |
1272 case 1: | |
1273 *dst++ = RGB565_32(dst, src, map); | |
1274 src += 2; | |
1275 break; | |
1276 } | |
1277 src += srcskip; | |
1278 dst += dstskip; | |
1279 } | |
1280 #endif /* USE_DUFFS_LOOP */ | |
1281 } | |
1282 | |
1283 /* Special optimized blit for RGB 5-6-5 --> ARGB 8-8-8-8 */ | |
91
e85e03f195b4
From: "Markus F.X.J. Oberhumer"
Sam Lantinga <slouken@lokigames.com>
parents:
0
diff
changeset
|
1284 static const Uint32 RGB565_ARGB8888_LUT[512] = { |
0 | 1285 0x00000000, 0xff000000, 0x00000008, 0xff002000, |
1286 0x00000010, 0xff004000, 0x00000018, 0xff006100, | |
1287 0x00000020, 0xff008100, 0x00000029, 0xff00a100, | |
1288 0x00000031, 0xff00c200, 0x00000039, 0xff00e200, | |
1289 0x00000041, 0xff080000, 0x0000004a, 0xff082000, | |
1290 0x00000052, 0xff084000, 0x0000005a, 0xff086100, | |
1291 0x00000062, 0xff088100, 0x0000006a, 0xff08a100, | |
1292 0x00000073, 0xff08c200, 0x0000007b, 0xff08e200, | |
1293 0x00000083, 0xff100000, 0x0000008b, 0xff102000, | |
1294 0x00000094, 0xff104000, 0x0000009c, 0xff106100, | |
1295 0x000000a4, 0xff108100, 0x000000ac, 0xff10a100, | |
1296 0x000000b4, 0xff10c200, 0x000000bd, 0xff10e200, | |
1297 0x000000c5, 0xff180000, 0x000000cd, 0xff182000, | |
1298 0x000000d5, 0xff184000, 0x000000de, 0xff186100, | |
1299 0x000000e6, 0xff188100, 0x000000ee, 0xff18a100, | |
1300 0x000000f6, 0xff18c200, 0x000000ff, 0xff18e200, | |
1301 0x00000400, 0xff200000, 0x00000408, 0xff202000, | |
1302 0x00000410, 0xff204000, 0x00000418, 0xff206100, | |
1303 0x00000420, 0xff208100, 0x00000429, 0xff20a100, | |
1304 0x00000431, 0xff20c200, 0x00000439, 0xff20e200, | |
1305 0x00000441, 0xff290000, 0x0000044a, 0xff292000, | |
1306 0x00000452, 0xff294000, 0x0000045a, 0xff296100, | |
1307 0x00000462, 0xff298100, 0x0000046a, 0xff29a100, | |
1308 0x00000473, 0xff29c200, 0x0000047b, 0xff29e200, | |
1309 0x00000483, 0xff310000, 0x0000048b, 0xff312000, | |
1310 0x00000494, 0xff314000, 0x0000049c, 0xff316100, | |
1311 0x000004a4, 0xff318100, 0x000004ac, 0xff31a100, | |
1312 0x000004b4, 0xff31c200, 0x000004bd, 0xff31e200, | |
1313 0x000004c5, 0xff390000, 0x000004cd, 0xff392000, | |
1314 0x000004d5, 0xff394000, 0x000004de, 0xff396100, | |
1315 0x000004e6, 0xff398100, 0x000004ee, 0xff39a100, | |
1316 0x000004f6, 0xff39c200, 0x000004ff, 0xff39e200, | |
1317 0x00000800, 0xff410000, 0x00000808, 0xff412000, | |
1318 0x00000810, 0xff414000, 0x00000818, 0xff416100, | |
1319 0x00000820, 0xff418100, 0x00000829, 0xff41a100, | |
1320 0x00000831, 0xff41c200, 0x00000839, 0xff41e200, | |
1321 0x00000841, 0xff4a0000, 0x0000084a, 0xff4a2000, | |
1322 0x00000852, 0xff4a4000, 0x0000085a, 0xff4a6100, | |
1323 0x00000862, 0xff4a8100, 0x0000086a, 0xff4aa100, | |
1324 0x00000873, 0xff4ac200, 0x0000087b, 0xff4ae200, | |
1325 0x00000883, 0xff520000, 0x0000088b, 0xff522000, | |
1326 0x00000894, 0xff524000, 0x0000089c, 0xff526100, | |
1327 0x000008a4, 0xff528100, 0x000008ac, 0xff52a100, | |
1328 0x000008b4, 0xff52c200, 0x000008bd, 0xff52e200, | |
1329 0x000008c5, 0xff5a0000, 0x000008cd, 0xff5a2000, | |
1330 0x000008d5, 0xff5a4000, 0x000008de, 0xff5a6100, | |
1331 0x000008e6, 0xff5a8100, 0x000008ee, 0xff5aa100, | |
1332 0x000008f6, 0xff5ac200, 0x000008ff, 0xff5ae200, | |
1333 0x00000c00, 0xff620000, 0x00000c08, 0xff622000, | |
1334 0x00000c10, 0xff624000, 0x00000c18, 0xff626100, | |
1335 0x00000c20, 0xff628100, 0x00000c29, 0xff62a100, | |
1336 0x00000c31, 0xff62c200, 0x00000c39, 0xff62e200, | |
1337 0x00000c41, 0xff6a0000, 0x00000c4a, 0xff6a2000, | |
1338 0x00000c52, 0xff6a4000, 0x00000c5a, 0xff6a6100, | |
1339 0x00000c62, 0xff6a8100, 0x00000c6a, 0xff6aa100, | |
1340 0x00000c73, 0xff6ac200, 0x00000c7b, 0xff6ae200, | |
1341 0x00000c83, 0xff730000, 0x00000c8b, 0xff732000, | |
1342 0x00000c94, 0xff734000, 0x00000c9c, 0xff736100, | |
1343 0x00000ca4, 0xff738100, 0x00000cac, 0xff73a100, | |
1344 0x00000cb4, 0xff73c200, 0x00000cbd, 0xff73e200, | |
1345 0x00000cc5, 0xff7b0000, 0x00000ccd, 0xff7b2000, | |
1346 0x00000cd5, 0xff7b4000, 0x00000cde, 0xff7b6100, | |
1347 0x00000ce6, 0xff7b8100, 0x00000cee, 0xff7ba100, | |
1348 0x00000cf6, 0xff7bc200, 0x00000cff, 0xff7be200, | |
1349 0x00001000, 0xff830000, 0x00001008, 0xff832000, | |
1350 0x00001010, 0xff834000, 0x00001018, 0xff836100, | |
1351 0x00001020, 0xff838100, 0x00001029, 0xff83a100, | |
1352 0x00001031, 0xff83c200, 0x00001039, 0xff83e200, | |
1353 0x00001041, 0xff8b0000, 0x0000104a, 0xff8b2000, | |
1354 0x00001052, 0xff8b4000, 0x0000105a, 0xff8b6100, | |
1355 0x00001062, 0xff8b8100, 0x0000106a, 0xff8ba100, | |
1356 0x00001073, 0xff8bc200, 0x0000107b, 0xff8be200, | |
1357 0x00001083, 0xff940000, 0x0000108b, 0xff942000, | |
1358 0x00001094, 0xff944000, 0x0000109c, 0xff946100, | |
1359 0x000010a4, 0xff948100, 0x000010ac, 0xff94a100, | |
1360 0x000010b4, 0xff94c200, 0x000010bd, 0xff94e200, | |
1361 0x000010c5, 0xff9c0000, 0x000010cd, 0xff9c2000, | |
1362 0x000010d5, 0xff9c4000, 0x000010de, 0xff9c6100, | |
1363 0x000010e6, 0xff9c8100, 0x000010ee, 0xff9ca100, | |
1364 0x000010f6, 0xff9cc200, 0x000010ff, 0xff9ce200, | |
1365 0x00001400, 0xffa40000, 0x00001408, 0xffa42000, | |
1366 0x00001410, 0xffa44000, 0x00001418, 0xffa46100, | |
1367 0x00001420, 0xffa48100, 0x00001429, 0xffa4a100, | |
1368 0x00001431, 0xffa4c200, 0x00001439, 0xffa4e200, | |
1369 0x00001441, 0xffac0000, 0x0000144a, 0xffac2000, | |
1370 0x00001452, 0xffac4000, 0x0000145a, 0xffac6100, | |
1371 0x00001462, 0xffac8100, 0x0000146a, 0xffaca100, | |
1372 0x00001473, 0xffacc200, 0x0000147b, 0xfface200, | |
1373 0x00001483, 0xffb40000, 0x0000148b, 0xffb42000, | |
1374 0x00001494, 0xffb44000, 0x0000149c, 0xffb46100, | |
1375 0x000014a4, 0xffb48100, 0x000014ac, 0xffb4a100, | |
1376 0x000014b4, 0xffb4c200, 0x000014bd, 0xffb4e200, | |
1377 0x000014c5, 0xffbd0000, 0x000014cd, 0xffbd2000, | |
1378 0x000014d5, 0xffbd4000, 0x000014de, 0xffbd6100, | |
1379 0x000014e6, 0xffbd8100, 0x000014ee, 0xffbda100, | |
1380 0x000014f6, 0xffbdc200, 0x000014ff, 0xffbde200, | |
1381 0x00001800, 0xffc50000, 0x00001808, 0xffc52000, | |
1382 0x00001810, 0xffc54000, 0x00001818, 0xffc56100, | |
1383 0x00001820, 0xffc58100, 0x00001829, 0xffc5a100, | |
1384 0x00001831, 0xffc5c200, 0x00001839, 0xffc5e200, | |
1385 0x00001841, 0xffcd0000, 0x0000184a, 0xffcd2000, | |
1386 0x00001852, 0xffcd4000, 0x0000185a, 0xffcd6100, | |
1387 0x00001862, 0xffcd8100, 0x0000186a, 0xffcda100, | |
1388 0x00001873, 0xffcdc200, 0x0000187b, 0xffcde200, | |
1389 0x00001883, 0xffd50000, 0x0000188b, 0xffd52000, | |
1390 0x00001894, 0xffd54000, 0x0000189c, 0xffd56100, | |
1391 0x000018a4, 0xffd58100, 0x000018ac, 0xffd5a100, | |
1392 0x000018b4, 0xffd5c200, 0x000018bd, 0xffd5e200, | |
1393 0x000018c5, 0xffde0000, 0x000018cd, 0xffde2000, | |
1394 0x000018d5, 0xffde4000, 0x000018de, 0xffde6100, | |
1395 0x000018e6, 0xffde8100, 0x000018ee, 0xffdea100, | |
1396 0x000018f6, 0xffdec200, 0x000018ff, 0xffdee200, | |
1397 0x00001c00, 0xffe60000, 0x00001c08, 0xffe62000, | |
1398 0x00001c10, 0xffe64000, 0x00001c18, 0xffe66100, | |
1399 0x00001c20, 0xffe68100, 0x00001c29, 0xffe6a100, | |
1400 0x00001c31, 0xffe6c200, 0x00001c39, 0xffe6e200, | |
1401 0x00001c41, 0xffee0000, 0x00001c4a, 0xffee2000, | |
1402 0x00001c52, 0xffee4000, 0x00001c5a, 0xffee6100, | |
1403 0x00001c62, 0xffee8100, 0x00001c6a, 0xffeea100, | |
1404 0x00001c73, 0xffeec200, 0x00001c7b, 0xffeee200, | |
1405 0x00001c83, 0xfff60000, 0x00001c8b, 0xfff62000, | |
1406 0x00001c94, 0xfff64000, 0x00001c9c, 0xfff66100, | |
1407 0x00001ca4, 0xfff68100, 0x00001cac, 0xfff6a100, | |
1408 0x00001cb4, 0xfff6c200, 0x00001cbd, 0xfff6e200, | |
1409 0x00001cc5, 0xffff0000, 0x00001ccd, 0xffff2000, | |
1410 0x00001cd5, 0xffff4000, 0x00001cde, 0xffff6100, | |
1411 0x00001ce6, 0xffff8100, 0x00001cee, 0xffffa100, | |
1412 0x00001cf6, 0xffffc200, 0x00001cff, 0xffffe200 | |
1413 }; | |
1414 static void Blit_RGB565_ARGB8888(SDL_BlitInfo *info) | |
1415 { | |
1416 Blit_RGB565_32(info, RGB565_ARGB8888_LUT); | |
1417 } | |
1418 | |
1419 /* Special optimized blit for RGB 5-6-5 --> ABGR 8-8-8-8 */ | |
91
e85e03f195b4
From: "Markus F.X.J. Oberhumer"
Sam Lantinga <slouken@lokigames.com>
parents:
0
diff
changeset
|
1420 static const Uint32 RGB565_ABGR8888_LUT[512] = { |
0 | 1421 0xff000000, 0x00000000, 0xff080000, 0x00002000, |
1422 0xff100000, 0x00004000, 0xff180000, 0x00006100, | |
1423 0xff200000, 0x00008100, 0xff290000, 0x0000a100, | |
1424 0xff310000, 0x0000c200, 0xff390000, 0x0000e200, | |
1425 0xff410000, 0x00000008, 0xff4a0000, 0x00002008, | |
1426 0xff520000, 0x00004008, 0xff5a0000, 0x00006108, | |
1427 0xff620000, 0x00008108, 0xff6a0000, 0x0000a108, | |
1428 0xff730000, 0x0000c208, 0xff7b0000, 0x0000e208, | |
1429 0xff830000, 0x00000010, 0xff8b0000, 0x00002010, | |
1430 0xff940000, 0x00004010, 0xff9c0000, 0x00006110, | |
1431 0xffa40000, 0x00008110, 0xffac0000, 0x0000a110, | |
1432 0xffb40000, 0x0000c210, 0xffbd0000, 0x0000e210, | |
1433 0xffc50000, 0x00000018, 0xffcd0000, 0x00002018, | |
1434 0xffd50000, 0x00004018, 0xffde0000, 0x00006118, | |
1435 0xffe60000, 0x00008118, 0xffee0000, 0x0000a118, | |
1436 0xfff60000, 0x0000c218, 0xffff0000, 0x0000e218, | |
1437 0xff000400, 0x00000020, 0xff080400, 0x00002020, | |
1438 0xff100400, 0x00004020, 0xff180400, 0x00006120, | |
1439 0xff200400, 0x00008120, 0xff290400, 0x0000a120, | |
1440 0xff310400, 0x0000c220, 0xff390400, 0x0000e220, | |
1441 0xff410400, 0x00000029, 0xff4a0400, 0x00002029, | |
1442 0xff520400, 0x00004029, 0xff5a0400, 0x00006129, | |
1443 0xff620400, 0x00008129, 0xff6a0400, 0x0000a129, | |
1444 0xff730400, 0x0000c229, 0xff7b0400, 0x0000e229, | |
1445 0xff830400, 0x00000031, 0xff8b0400, 0x00002031, | |
1446 0xff940400, 0x00004031, 0xff9c0400, 0x00006131, | |
1447 0xffa40400, 0x00008131, 0xffac0400, 0x0000a131, | |
1448 0xffb40400, 0x0000c231, 0xffbd0400, 0x0000e231, | |
1449 0xffc50400, 0x00000039, 0xffcd0400, 0x00002039, | |
1450 0xffd50400, 0x00004039, 0xffde0400, 0x00006139, | |
1451 0xffe60400, 0x00008139, 0xffee0400, 0x0000a139, | |
1452 0xfff60400, 0x0000c239, 0xffff0400, 0x0000e239, | |
1453 0xff000800, 0x00000041, 0xff080800, 0x00002041, | |
1454 0xff100800, 0x00004041, 0xff180800, 0x00006141, | |
1455 0xff200800, 0x00008141, 0xff290800, 0x0000a141, | |
1456 0xff310800, 0x0000c241, 0xff390800, 0x0000e241, | |
1457 0xff410800, 0x0000004a, 0xff4a0800, 0x0000204a, | |
1458 0xff520800, 0x0000404a, 0xff5a0800, 0x0000614a, | |
1459 0xff620800, 0x0000814a, 0xff6a0800, 0x0000a14a, | |
1460 0xff730800, 0x0000c24a, 0xff7b0800, 0x0000e24a, | |
1461 0xff830800, 0x00000052, 0xff8b0800, 0x00002052, | |
1462 0xff940800, 0x00004052, 0xff9c0800, 0x00006152, | |
1463 0xffa40800, 0x00008152, 0xffac0800, 0x0000a152, | |
1464 0xffb40800, 0x0000c252, 0xffbd0800, 0x0000e252, | |
1465 0xffc50800, 0x0000005a, 0xffcd0800, 0x0000205a, | |
1466 0xffd50800, 0x0000405a, 0xffde0800, 0x0000615a, | |
1467 0xffe60800, 0x0000815a, 0xffee0800, 0x0000a15a, | |
1468 0xfff60800, 0x0000c25a, 0xffff0800, 0x0000e25a, | |
1469 0xff000c00, 0x00000062, 0xff080c00, 0x00002062, | |
1470 0xff100c00, 0x00004062, 0xff180c00, 0x00006162, | |
1471 0xff200c00, 0x00008162, 0xff290c00, 0x0000a162, | |
1472 0xff310c00, 0x0000c262, 0xff390c00, 0x0000e262, | |
1473 0xff410c00, 0x0000006a, 0xff4a0c00, 0x0000206a, | |
1474 0xff520c00, 0x0000406a, 0xff5a0c00, 0x0000616a, | |
1475 0xff620c00, 0x0000816a, 0xff6a0c00, 0x0000a16a, | |
1476 0xff730c00, 0x0000c26a, 0xff7b0c00, 0x0000e26a, | |
1477 0xff830c00, 0x00000073, 0xff8b0c00, 0x00002073, | |
1478 0xff940c00, 0x00004073, 0xff9c0c00, 0x00006173, | |
1479 0xffa40c00, 0x00008173, 0xffac0c00, 0x0000a173, | |
1480 0xffb40c00, 0x0000c273, 0xffbd0c00, 0x0000e273, | |
1481 0xffc50c00, 0x0000007b, 0xffcd0c00, 0x0000207b, | |
1482 0xffd50c00, 0x0000407b, 0xffde0c00, 0x0000617b, | |
1483 0xffe60c00, 0x0000817b, 0xffee0c00, 0x0000a17b, | |
1484 0xfff60c00, 0x0000c27b, 0xffff0c00, 0x0000e27b, | |
1485 0xff001000, 0x00000083, 0xff081000, 0x00002083, | |
1486 0xff101000, 0x00004083, 0xff181000, 0x00006183, | |
1487 0xff201000, 0x00008183, 0xff291000, 0x0000a183, | |
1488 0xff311000, 0x0000c283, 0xff391000, 0x0000e283, | |
1489 0xff411000, 0x0000008b, 0xff4a1000, 0x0000208b, | |
1490 0xff521000, 0x0000408b, 0xff5a1000, 0x0000618b, | |
1491 0xff621000, 0x0000818b, 0xff6a1000, 0x0000a18b, | |
1492 0xff731000, 0x0000c28b, 0xff7b1000, 0x0000e28b, | |
1493 0xff831000, 0x00000094, 0xff8b1000, 0x00002094, | |
1494 0xff941000, 0x00004094, 0xff9c1000, 0x00006194, | |
1495 0xffa41000, 0x00008194, 0xffac1000, 0x0000a194, | |
1496 0xffb41000, 0x0000c294, 0xffbd1000, 0x0000e294, | |
1497 0xffc51000, 0x0000009c, 0xffcd1000, 0x0000209c, | |
1498 0xffd51000, 0x0000409c, 0xffde1000, 0x0000619c, | |
1499 0xffe61000, 0x0000819c, 0xffee1000, 0x0000a19c, | |
1500 0xfff61000, 0x0000c29c, 0xffff1000, 0x0000e29c, | |
1501 0xff001400, 0x000000a4, 0xff081400, 0x000020a4, | |
1502 0xff101400, 0x000040a4, 0xff181400, 0x000061a4, | |
1503 0xff201400, 0x000081a4, 0xff291400, 0x0000a1a4, | |
1504 0xff311400, 0x0000c2a4, 0xff391400, 0x0000e2a4, | |
1505 0xff411400, 0x000000ac, 0xff4a1400, 0x000020ac, | |
1506 0xff521400, 0x000040ac, 0xff5a1400, 0x000061ac, | |
1507 0xff621400, 0x000081ac, 0xff6a1400, 0x0000a1ac, | |
1508 0xff731400, 0x0000c2ac, 0xff7b1400, 0x0000e2ac, | |
1509 0xff831400, 0x000000b4, 0xff8b1400, 0x000020b4, | |
1510 0xff941400, 0x000040b4, 0xff9c1400, 0x000061b4, | |
1511 0xffa41400, 0x000081b4, 0xffac1400, 0x0000a1b4, | |
1512 0xffb41400, 0x0000c2b4, 0xffbd1400, 0x0000e2b4, | |
1513 0xffc51400, 0x000000bd, 0xffcd1400, 0x000020bd, | |
1514 0xffd51400, 0x000040bd, 0xffde1400, 0x000061bd, | |
1515 0xffe61400, 0x000081bd, 0xffee1400, 0x0000a1bd, | |
1516 0xfff61400, 0x0000c2bd, 0xffff1400, 0x0000e2bd, | |
1517 0xff001800, 0x000000c5, 0xff081800, 0x000020c5, | |
1518 0xff101800, 0x000040c5, 0xff181800, 0x000061c5, | |
1519 0xff201800, 0x000081c5, 0xff291800, 0x0000a1c5, | |
1520 0xff311800, 0x0000c2c5, 0xff391800, 0x0000e2c5, | |
1521 0xff411800, 0x000000cd, 0xff4a1800, 0x000020cd, | |
1522 0xff521800, 0x000040cd, 0xff5a1800, 0x000061cd, | |
1523 0xff621800, 0x000081cd, 0xff6a1800, 0x0000a1cd, | |
1524 0xff731800, 0x0000c2cd, 0xff7b1800, 0x0000e2cd, | |
1525 0xff831800, 0x000000d5, 0xff8b1800, 0x000020d5, | |
1526 0xff941800, 0x000040d5, 0xff9c1800, 0x000061d5, | |
1527 0xffa41800, 0x000081d5, 0xffac1800, 0x0000a1d5, | |
1528 0xffb41800, 0x0000c2d5, 0xffbd1800, 0x0000e2d5, | |
1529 0xffc51800, 0x000000de, 0xffcd1800, 0x000020de, | |
1530 0xffd51800, 0x000040de, 0xffde1800, 0x000061de, | |
1531 0xffe61800, 0x000081de, 0xffee1800, 0x0000a1de, | |
1532 0xfff61800, 0x0000c2de, 0xffff1800, 0x0000e2de, | |
1533 0xff001c00, 0x000000e6, 0xff081c00, 0x000020e6, | |
1534 0xff101c00, 0x000040e6, 0xff181c00, 0x000061e6, | |
1535 0xff201c00, 0x000081e6, 0xff291c00, 0x0000a1e6, | |
1536 0xff311c00, 0x0000c2e6, 0xff391c00, 0x0000e2e6, | |
1537 0xff411c00, 0x000000ee, 0xff4a1c00, 0x000020ee, | |
1538 0xff521c00, 0x000040ee, 0xff5a1c00, 0x000061ee, | |
1539 0xff621c00, 0x000081ee, 0xff6a1c00, 0x0000a1ee, | |
1540 0xff731c00, 0x0000c2ee, 0xff7b1c00, 0x0000e2ee, | |
1541 0xff831c00, 0x000000f6, 0xff8b1c00, 0x000020f6, | |
1542 0xff941c00, 0x000040f6, 0xff9c1c00, 0x000061f6, | |
1543 0xffa41c00, 0x000081f6, 0xffac1c00, 0x0000a1f6, | |
1544 0xffb41c00, 0x0000c2f6, 0xffbd1c00, 0x0000e2f6, | |
1545 0xffc51c00, 0x000000ff, 0xffcd1c00, 0x000020ff, | |
1546 0xffd51c00, 0x000040ff, 0xffde1c00, 0x000061ff, | |
1547 0xffe61c00, 0x000081ff, 0xffee1c00, 0x0000a1ff, | |
1548 0xfff61c00, 0x0000c2ff, 0xffff1c00, 0x0000e2ff | |
1549 }; | |
1550 static void Blit_RGB565_ABGR8888(SDL_BlitInfo *info) | |
1551 { | |
1552 Blit_RGB565_32(info, RGB565_ABGR8888_LUT); | |
1553 } | |
1554 | |
1555 /* Special optimized blit for RGB 5-6-5 --> RGBA 8-8-8-8 */ | |
91
e85e03f195b4
From: "Markus F.X.J. Oberhumer"
Sam Lantinga <slouken@lokigames.com>
parents:
0
diff
changeset
|
1556 static const Uint32 RGB565_RGBA8888_LUT[512] = { |
0 | 1557 0x000000ff, 0x00000000, 0x000008ff, 0x00200000, |
1558 0x000010ff, 0x00400000, 0x000018ff, 0x00610000, | |
1559 0x000020ff, 0x00810000, 0x000029ff, 0x00a10000, | |
1560 0x000031ff, 0x00c20000, 0x000039ff, 0x00e20000, | |
1561 0x000041ff, 0x08000000, 0x00004aff, 0x08200000, | |
1562 0x000052ff, 0x08400000, 0x00005aff, 0x08610000, | |
1563 0x000062ff, 0x08810000, 0x00006aff, 0x08a10000, | |
1564 0x000073ff, 0x08c20000, 0x00007bff, 0x08e20000, | |
1565 0x000083ff, 0x10000000, 0x00008bff, 0x10200000, | |
1566 0x000094ff, 0x10400000, 0x00009cff, 0x10610000, | |
1567 0x0000a4ff, 0x10810000, 0x0000acff, 0x10a10000, | |
1568 0x0000b4ff, 0x10c20000, 0x0000bdff, 0x10e20000, | |
1569 0x0000c5ff, 0x18000000, 0x0000cdff, 0x18200000, | |
1570 0x0000d5ff, 0x18400000, 0x0000deff, 0x18610000, | |
1571 0x0000e6ff, 0x18810000, 0x0000eeff, 0x18a10000, | |
1572 0x0000f6ff, 0x18c20000, 0x0000ffff, 0x18e20000, | |
1573 0x000400ff, 0x20000000, 0x000408ff, 0x20200000, | |
1574 0x000410ff, 0x20400000, 0x000418ff, 0x20610000, | |
1575 0x000420ff, 0x20810000, 0x000429ff, 0x20a10000, | |
1576 0x000431ff, 0x20c20000, 0x000439ff, 0x20e20000, | |
1577 0x000441ff, 0x29000000, 0x00044aff, 0x29200000, | |
1578 0x000452ff, 0x29400000, 0x00045aff, 0x29610000, | |
1579 0x000462ff, 0x29810000, 0x00046aff, 0x29a10000, | |
1580 0x000473ff, 0x29c20000, 0x00047bff, 0x29e20000, | |
1581 0x000483ff, 0x31000000, 0x00048bff, 0x31200000, | |
1582 0x000494ff, 0x31400000, 0x00049cff, 0x31610000, | |
1583 0x0004a4ff, 0x31810000, 0x0004acff, 0x31a10000, | |
1584 0x0004b4ff, 0x31c20000, 0x0004bdff, 0x31e20000, | |
1585 0x0004c5ff, 0x39000000, 0x0004cdff, 0x39200000, | |
1586 0x0004d5ff, 0x39400000, 0x0004deff, 0x39610000, | |
1587 0x0004e6ff, 0x39810000, 0x0004eeff, 0x39a10000, | |
1588 0x0004f6ff, 0x39c20000, 0x0004ffff, 0x39e20000, | |
1589 0x000800ff, 0x41000000, 0x000808ff, 0x41200000, | |
1590 0x000810ff, 0x41400000, 0x000818ff, 0x41610000, | |
1591 0x000820ff, 0x41810000, 0x000829ff, 0x41a10000, | |
1592 0x000831ff, 0x41c20000, 0x000839ff, 0x41e20000, | |
1593 0x000841ff, 0x4a000000, 0x00084aff, 0x4a200000, | |
1594 0x000852ff, 0x4a400000, 0x00085aff, 0x4a610000, | |
1595 0x000862ff, 0x4a810000, 0x00086aff, 0x4aa10000, | |
1596 0x000873ff, 0x4ac20000, 0x00087bff, 0x4ae20000, | |
1597 0x000883ff, 0x52000000, 0x00088bff, 0x52200000, | |
1598 0x000894ff, 0x52400000, 0x00089cff, 0x52610000, | |
1599 0x0008a4ff, 0x52810000, 0x0008acff, 0x52a10000, | |
1600 0x0008b4ff, 0x52c20000, 0x0008bdff, 0x52e20000, | |
1601 0x0008c5ff, 0x5a000000, 0x0008cdff, 0x5a200000, | |
1602 0x0008d5ff, 0x5a400000, 0x0008deff, 0x5a610000, | |
1603 0x0008e6ff, 0x5a810000, 0x0008eeff, 0x5aa10000, | |
1604 0x0008f6ff, 0x5ac20000, 0x0008ffff, 0x5ae20000, | |
1605 0x000c00ff, 0x62000000, 0x000c08ff, 0x62200000, | |
1606 0x000c10ff, 0x62400000, 0x000c18ff, 0x62610000, | |
1607 0x000c20ff, 0x62810000, 0x000c29ff, 0x62a10000, | |
1608 0x000c31ff, 0x62c20000, 0x000c39ff, 0x62e20000, | |
1609 0x000c41ff, 0x6a000000, 0x000c4aff, 0x6a200000, | |
1610 0x000c52ff, 0x6a400000, 0x000c5aff, 0x6a610000, | |
1611 0x000c62ff, 0x6a810000, 0x000c6aff, 0x6aa10000, | |
1612 0x000c73ff, 0x6ac20000, 0x000c7bff, 0x6ae20000, | |
1613 0x000c83ff, 0x73000000, 0x000c8bff, 0x73200000, | |
1614 0x000c94ff, 0x73400000, 0x000c9cff, 0x73610000, | |
1615 0x000ca4ff, 0x73810000, 0x000cacff, 0x73a10000, | |
1616 0x000cb4ff, 0x73c20000, 0x000cbdff, 0x73e20000, | |
1617 0x000cc5ff, 0x7b000000, 0x000ccdff, 0x7b200000, | |
1618 0x000cd5ff, 0x7b400000, 0x000cdeff, 0x7b610000, | |
1619 0x000ce6ff, 0x7b810000, 0x000ceeff, 0x7ba10000, | |
1620 0x000cf6ff, 0x7bc20000, 0x000cffff, 0x7be20000, | |
1621 0x001000ff, 0x83000000, 0x001008ff, 0x83200000, | |
1622 0x001010ff, 0x83400000, 0x001018ff, 0x83610000, | |
1623 0x001020ff, 0x83810000, 0x001029ff, 0x83a10000, | |
1624 0x001031ff, 0x83c20000, 0x001039ff, 0x83e20000, | |
1625 0x001041ff, 0x8b000000, 0x00104aff, 0x8b200000, | |
1626 0x001052ff, 0x8b400000, 0x00105aff, 0x8b610000, | |
1627 0x001062ff, 0x8b810000, 0x00106aff, 0x8ba10000, | |
1628 0x001073ff, 0x8bc20000, 0x00107bff, 0x8be20000, | |
1629 0x001083ff, 0x94000000, 0x00108bff, 0x94200000, | |
1630 0x001094ff, 0x94400000, 0x00109cff, 0x94610000, | |
1631 0x0010a4ff, 0x94810000, 0x0010acff, 0x94a10000, | |
1632 0x0010b4ff, 0x94c20000, 0x0010bdff, 0x94e20000, | |
1633 0x0010c5ff, 0x9c000000, 0x0010cdff, 0x9c200000, | |
1634 0x0010d5ff, 0x9c400000, 0x0010deff, 0x9c610000, | |
1635 0x0010e6ff, 0x9c810000, 0x0010eeff, 0x9ca10000, | |
1636 0x0010f6ff, 0x9cc20000, 0x0010ffff, 0x9ce20000, | |
1637 0x001400ff, 0xa4000000, 0x001408ff, 0xa4200000, | |
1638 0x001410ff, 0xa4400000, 0x001418ff, 0xa4610000, | |
1639 0x001420ff, 0xa4810000, 0x001429ff, 0xa4a10000, | |
1640 0x001431ff, 0xa4c20000, 0x001439ff, 0xa4e20000, | |
1641 0x001441ff, 0xac000000, 0x00144aff, 0xac200000, | |
1642 0x001452ff, 0xac400000, 0x00145aff, 0xac610000, | |
1643 0x001462ff, 0xac810000, 0x00146aff, 0xaca10000, | |
1644 0x001473ff, 0xacc20000, 0x00147bff, 0xace20000, | |
1645 0x001483ff, 0xb4000000, 0x00148bff, 0xb4200000, | |
1646 0x001494ff, 0xb4400000, 0x00149cff, 0xb4610000, | |
1647 0x0014a4ff, 0xb4810000, 0x0014acff, 0xb4a10000, | |
1648 0x0014b4ff, 0xb4c20000, 0x0014bdff, 0xb4e20000, | |
1649 0x0014c5ff, 0xbd000000, 0x0014cdff, 0xbd200000, | |
1650 0x0014d5ff, 0xbd400000, 0x0014deff, 0xbd610000, | |
1651 0x0014e6ff, 0xbd810000, 0x0014eeff, 0xbda10000, | |
1652 0x0014f6ff, 0xbdc20000, 0x0014ffff, 0xbde20000, | |
1653 0x001800ff, 0xc5000000, 0x001808ff, 0xc5200000, | |
1654 0x001810ff, 0xc5400000, 0x001818ff, 0xc5610000, | |
1655 0x001820ff, 0xc5810000, 0x001829ff, 0xc5a10000, | |
1656 0x001831ff, 0xc5c20000, 0x001839ff, 0xc5e20000, | |
1657 0x001841ff, 0xcd000000, 0x00184aff, 0xcd200000, | |
1658 0x001852ff, 0xcd400000, 0x00185aff, 0xcd610000, | |
1659 0x001862ff, 0xcd810000, 0x00186aff, 0xcda10000, | |
1660 0x001873ff, 0xcdc20000, 0x00187bff, 0xcde20000, | |
1661 0x001883ff, 0xd5000000, 0x00188bff, 0xd5200000, | |
1662 0x001894ff, 0xd5400000, 0x00189cff, 0xd5610000, | |
1663 0x0018a4ff, 0xd5810000, 0x0018acff, 0xd5a10000, | |
1664 0x0018b4ff, 0xd5c20000, 0x0018bdff, 0xd5e20000, | |
1665 0x0018c5ff, 0xde000000, 0x0018cdff, 0xde200000, | |
1666 0x0018d5ff, 0xde400000, 0x0018deff, 0xde610000, | |
1667 0x0018e6ff, 0xde810000, 0x0018eeff, 0xdea10000, | |
1668 0x0018f6ff, 0xdec20000, 0x0018ffff, 0xdee20000, | |
1669 0x001c00ff, 0xe6000000, 0x001c08ff, 0xe6200000, | |
1670 0x001c10ff, 0xe6400000, 0x001c18ff, 0xe6610000, | |
1671 0x001c20ff, 0xe6810000, 0x001c29ff, 0xe6a10000, | |
1672 0x001c31ff, 0xe6c20000, 0x001c39ff, 0xe6e20000, | |
1673 0x001c41ff, 0xee000000, 0x001c4aff, 0xee200000, | |
1674 0x001c52ff, 0xee400000, 0x001c5aff, 0xee610000, | |
1675 0x001c62ff, 0xee810000, 0x001c6aff, 0xeea10000, | |
1676 0x001c73ff, 0xeec20000, 0x001c7bff, 0xeee20000, | |
1677 0x001c83ff, 0xf6000000, 0x001c8bff, 0xf6200000, | |
1678 0x001c94ff, 0xf6400000, 0x001c9cff, 0xf6610000, | |
1679 0x001ca4ff, 0xf6810000, 0x001cacff, 0xf6a10000, | |
1680 0x001cb4ff, 0xf6c20000, 0x001cbdff, 0xf6e20000, | |
1681 0x001cc5ff, 0xff000000, 0x001ccdff, 0xff200000, | |
1682 0x001cd5ff, 0xff400000, 0x001cdeff, 0xff610000, | |
1683 0x001ce6ff, 0xff810000, 0x001ceeff, 0xffa10000, | |
1684 0x001cf6ff, 0xffc20000, 0x001cffff, 0xffe20000, | |
1685 }; | |
1686 static void Blit_RGB565_RGBA8888(SDL_BlitInfo *info) | |
1687 { | |
1688 Blit_RGB565_32(info, RGB565_RGBA8888_LUT); | |
1689 } | |
1690 | |
1691 /* Special optimized blit for RGB 5-6-5 --> BGRA 8-8-8-8 */ | |
91
e85e03f195b4
From: "Markus F.X.J. Oberhumer"
Sam Lantinga <slouken@lokigames.com>
parents:
0
diff
changeset
|
1692 static const Uint32 RGB565_BGRA8888_LUT[512] = { |
0 | 1693 0x00000000, 0x000000ff, 0x08000000, 0x002000ff, |
1694 0x10000000, 0x004000ff, 0x18000000, 0x006100ff, | |
1695 0x20000000, 0x008100ff, 0x29000000, 0x00a100ff, | |
1696 0x31000000, 0x00c200ff, 0x39000000, 0x00e200ff, | |
1697 0x41000000, 0x000008ff, 0x4a000000, 0x002008ff, | |
1698 0x52000000, 0x004008ff, 0x5a000000, 0x006108ff, | |
1699 0x62000000, 0x008108ff, 0x6a000000, 0x00a108ff, | |
1700 0x73000000, 0x00c208ff, 0x7b000000, 0x00e208ff, | |
1701 0x83000000, 0x000010ff, 0x8b000000, 0x002010ff, | |
1702 0x94000000, 0x004010ff, 0x9c000000, 0x006110ff, | |
1703 0xa4000000, 0x008110ff, 0xac000000, 0x00a110ff, | |
1704 0xb4000000, 0x00c210ff, 0xbd000000, 0x00e210ff, | |
1705 0xc5000000, 0x000018ff, 0xcd000000, 0x002018ff, | |
1706 0xd5000000, 0x004018ff, 0xde000000, 0x006118ff, | |
1707 0xe6000000, 0x008118ff, 0xee000000, 0x00a118ff, | |
1708 0xf6000000, 0x00c218ff, 0xff000000, 0x00e218ff, | |
1709 0x00040000, 0x000020ff, 0x08040000, 0x002020ff, | |
1710 0x10040000, 0x004020ff, 0x18040000, 0x006120ff, | |
1711 0x20040000, 0x008120ff, 0x29040000, 0x00a120ff, | |
1712 0x31040000, 0x00c220ff, 0x39040000, 0x00e220ff, | |
1713 0x41040000, 0x000029ff, 0x4a040000, 0x002029ff, | |
1714 0x52040000, 0x004029ff, 0x5a040000, 0x006129ff, | |
1715 0x62040000, 0x008129ff, 0x6a040000, 0x00a129ff, | |
1716 0x73040000, 0x00c229ff, 0x7b040000, 0x00e229ff, | |
1717 0x83040000, 0x000031ff, 0x8b040000, 0x002031ff, | |
1718 0x94040000, 0x004031ff, 0x9c040000, 0x006131ff, | |
1719 0xa4040000, 0x008131ff, 0xac040000, 0x00a131ff, | |
1720 0xb4040000, 0x00c231ff, 0xbd040000, 0x00e231ff, | |
1721 0xc5040000, 0x000039ff, 0xcd040000, 0x002039ff, | |
1722 0xd5040000, 0x004039ff, 0xde040000, 0x006139ff, | |
1723 0xe6040000, 0x008139ff, 0xee040000, 0x00a139ff, | |
1724 0xf6040000, 0x00c239ff, 0xff040000, 0x00e239ff, | |
1725 0x00080000, 0x000041ff, 0x08080000, 0x002041ff, | |
1726 0x10080000, 0x004041ff, 0x18080000, 0x006141ff, | |
1727 0x20080000, 0x008141ff, 0x29080000, 0x00a141ff, | |
1728 0x31080000, 0x00c241ff, 0x39080000, 0x00e241ff, | |
1729 0x41080000, 0x00004aff, 0x4a080000, 0x00204aff, | |
1730 0x52080000, 0x00404aff, 0x5a080000, 0x00614aff, | |
1731 0x62080000, 0x00814aff, 0x6a080000, 0x00a14aff, | |
1732 0x73080000, 0x00c24aff, 0x7b080000, 0x00e24aff, | |
1733 0x83080000, 0x000052ff, 0x8b080000, 0x002052ff, | |
1734 0x94080000, 0x004052ff, 0x9c080000, 0x006152ff, | |
1735 0xa4080000, 0x008152ff, 0xac080000, 0x00a152ff, | |
1736 0xb4080000, 0x00c252ff, 0xbd080000, 0x00e252ff, | |
1737 0xc5080000, 0x00005aff, 0xcd080000, 0x00205aff, | |
1738 0xd5080000, 0x00405aff, 0xde080000, 0x00615aff, | |
1739 0xe6080000, 0x00815aff, 0xee080000, 0x00a15aff, | |
1740 0xf6080000, 0x00c25aff, 0xff080000, 0x00e25aff, | |
1741 0x000c0000, 0x000062ff, 0x080c0000, 0x002062ff, | |
1742 0x100c0000, 0x004062ff, 0x180c0000, 0x006162ff, | |
1743 0x200c0000, 0x008162ff, 0x290c0000, 0x00a162ff, | |
1744 0x310c0000, 0x00c262ff, 0x390c0000, 0x00e262ff, | |
1745 0x410c0000, 0x00006aff, 0x4a0c0000, 0x00206aff, | |
1746 0x520c0000, 0x00406aff, 0x5a0c0000, 0x00616aff, | |
1747 0x620c0000, 0x00816aff, 0x6a0c0000, 0x00a16aff, | |
1748 0x730c0000, 0x00c26aff, 0x7b0c0000, 0x00e26aff, | |
1749 0x830c0000, 0x000073ff, 0x8b0c0000, 0x002073ff, | |
1750 0x940c0000, 0x004073ff, 0x9c0c0000, 0x006173ff, | |
1751 0xa40c0000, 0x008173ff, 0xac0c0000, 0x00a173ff, | |
1752 0xb40c0000, 0x00c273ff, 0xbd0c0000, 0x00e273ff, | |
1753 0xc50c0000, 0x00007bff, 0xcd0c0000, 0x00207bff, | |
1754 0xd50c0000, 0x00407bff, 0xde0c0000, 0x00617bff, | |
1755 0xe60c0000, 0x00817bff, 0xee0c0000, 0x00a17bff, | |
1756 0xf60c0000, 0x00c27bff, 0xff0c0000, 0x00e27bff, | |
1757 0x00100000, 0x000083ff, 0x08100000, 0x002083ff, | |
1758 0x10100000, 0x004083ff, 0x18100000, 0x006183ff, | |
1759 0x20100000, 0x008183ff, 0x29100000, 0x00a183ff, | |
1760 0x31100000, 0x00c283ff, 0x39100000, 0x00e283ff, | |
1761 0x41100000, 0x00008bff, 0x4a100000, 0x00208bff, | |
1762 0x52100000, 0x00408bff, 0x5a100000, 0x00618bff, | |
1763 0x62100000, 0x00818bff, 0x6a100000, 0x00a18bff, | |
1764 0x73100000, 0x00c28bff, 0x7b100000, 0x00e28bff, | |
1765 0x83100000, 0x000094ff, 0x8b100000, 0x002094ff, | |
1766 0x94100000, 0x004094ff, 0x9c100000, 0x006194ff, | |
1767 0xa4100000, 0x008194ff, 0xac100000, 0x00a194ff, | |
1768 0xb4100000, 0x00c294ff, 0xbd100000, 0x00e294ff, | |
1769 0xc5100000, 0x00009cff, 0xcd100000, 0x00209cff, | |
1770 0xd5100000, 0x00409cff, 0xde100000, 0x00619cff, | |
1771 0xe6100000, 0x00819cff, 0xee100000, 0x00a19cff, | |
1772 0xf6100000, 0x00c29cff, 0xff100000, 0x00e29cff, | |
1773 0x00140000, 0x0000a4ff, 0x08140000, 0x0020a4ff, | |
1774 0x10140000, 0x0040a4ff, 0x18140000, 0x0061a4ff, | |
1775 0x20140000, 0x0081a4ff, 0x29140000, 0x00a1a4ff, | |
1776 0x31140000, 0x00c2a4ff, 0x39140000, 0x00e2a4ff, | |
1777 0x41140000, 0x0000acff, 0x4a140000, 0x0020acff, | |
1778 0x52140000, 0x0040acff, 0x5a140000, 0x0061acff, | |
1779 0x62140000, 0x0081acff, 0x6a140000, 0x00a1acff, | |
1780 0x73140000, 0x00c2acff, 0x7b140000, 0x00e2acff, | |
1781 0x83140000, 0x0000b4ff, 0x8b140000, 0x0020b4ff, | |
1782 0x94140000, 0x0040b4ff, 0x9c140000, 0x0061b4ff, | |
1783 0xa4140000, 0x0081b4ff, 0xac140000, 0x00a1b4ff, | |
1784 0xb4140000, 0x00c2b4ff, 0xbd140000, 0x00e2b4ff, | |
1785 0xc5140000, 0x0000bdff, 0xcd140000, 0x0020bdff, | |
1786 0xd5140000, 0x0040bdff, 0xde140000, 0x0061bdff, | |
1787 0xe6140000, 0x0081bdff, 0xee140000, 0x00a1bdff, | |
1788 0xf6140000, 0x00c2bdff, 0xff140000, 0x00e2bdff, | |
1789 0x00180000, 0x0000c5ff, 0x08180000, 0x0020c5ff, | |
1790 0x10180000, 0x0040c5ff, 0x18180000, 0x0061c5ff, | |
1791 0x20180000, 0x0081c5ff, 0x29180000, 0x00a1c5ff, | |
1792 0x31180000, 0x00c2c5ff, 0x39180000, 0x00e2c5ff, | |
1793 0x41180000, 0x0000cdff, 0x4a180000, 0x0020cdff, | |
1794 0x52180000, 0x0040cdff, 0x5a180000, 0x0061cdff, | |
1795 0x62180000, 0x0081cdff, 0x6a180000, 0x00a1cdff, | |
1796 0x73180000, 0x00c2cdff, 0x7b180000, 0x00e2cdff, | |
1797 0x83180000, 0x0000d5ff, 0x8b180000, 0x0020d5ff, | |
1798 0x94180000, 0x0040d5ff, 0x9c180000, 0x0061d5ff, | |
1799 0xa4180000, 0x0081d5ff, 0xac180000, 0x00a1d5ff, | |
1800 0xb4180000, 0x00c2d5ff, 0xbd180000, 0x00e2d5ff, | |
1801 0xc5180000, 0x0000deff, 0xcd180000, 0x0020deff, | |
1802 0xd5180000, 0x0040deff, 0xde180000, 0x0061deff, | |
1803 0xe6180000, 0x0081deff, 0xee180000, 0x00a1deff, | |
1804 0xf6180000, 0x00c2deff, 0xff180000, 0x00e2deff, | |
1805 0x001c0000, 0x0000e6ff, 0x081c0000, 0x0020e6ff, | |
1806 0x101c0000, 0x0040e6ff, 0x181c0000, 0x0061e6ff, | |
1807 0x201c0000, 0x0081e6ff, 0x291c0000, 0x00a1e6ff, | |
1808 0x311c0000, 0x00c2e6ff, 0x391c0000, 0x00e2e6ff, | |
1809 0x411c0000, 0x0000eeff, 0x4a1c0000, 0x0020eeff, | |
1810 0x521c0000, 0x0040eeff, 0x5a1c0000, 0x0061eeff, | |
1811 0x621c0000, 0x0081eeff, 0x6a1c0000, 0x00a1eeff, | |
1812 0x731c0000, 0x00c2eeff, 0x7b1c0000, 0x00e2eeff, | |
1813 0x831c0000, 0x0000f6ff, 0x8b1c0000, 0x0020f6ff, | |
1814 0x941c0000, 0x0040f6ff, 0x9c1c0000, 0x0061f6ff, | |
1815 0xa41c0000, 0x0081f6ff, 0xac1c0000, 0x00a1f6ff, | |
1816 0xb41c0000, 0x00c2f6ff, 0xbd1c0000, 0x00e2f6ff, | |
1817 0xc51c0000, 0x0000ffff, 0xcd1c0000, 0x0020ffff, | |
1818 0xd51c0000, 0x0040ffff, 0xde1c0000, 0x0061ffff, | |
1819 0xe61c0000, 0x0081ffff, 0xee1c0000, 0x00a1ffff, | |
1820 0xf61c0000, 0x00c2ffff, 0xff1c0000, 0x00e2ffff | |
1821 }; | |
1822 static void Blit_RGB565_BGRA8888(SDL_BlitInfo *info) | |
1823 { | |
1824 Blit_RGB565_32(info, RGB565_BGRA8888_LUT); | |
1825 } | |
1826 | |
1827 /* Special optimized blit for RGB 8-8-8 --> RGB 3-3-2 */ | |
1828 #ifndef RGB888_RGB332 | |
1829 #define RGB888_RGB332(dst, src) { \ | |
1830 dst = (((src)&0x00E00000)>>16)| \ | |
1831 (((src)&0x0000E000)>>11)| \ | |
1832 (((src)&0x000000C0)>>6); \ | |
1833 } | |
1834 #endif | |
1835 static void Blit_RGB888_index8_map(SDL_BlitInfo *info) | |
1836 { | |
1837 #ifndef USE_DUFFS_LOOP | |
1838 int c; | |
1839 #endif | |
1162
2651158f59b8
Enable altivec blitters on PowerPC Linux, and some fixes for recent
Ryan C. Gordon <icculus@icculus.org>
parents:
1139
diff
changeset
|
1840 int Pixel; |
0 | 1841 int width, height; |
1842 Uint32 *src; | |
91
e85e03f195b4
From: "Markus F.X.J. Oberhumer"
Sam Lantinga <slouken@lokigames.com>
parents:
0
diff
changeset
|
1843 const Uint8 *map; |
e85e03f195b4
From: "Markus F.X.J. Oberhumer"
Sam Lantinga <slouken@lokigames.com>
parents:
0
diff
changeset
|
1844 Uint8 *dst; |
0 | 1845 int srcskip, dstskip; |
1846 | |
1847 /* Set up some basic variables */ | |
1848 width = info->d_width; | |
1849 height = info->d_height; | |
1850 src = (Uint32 *)info->s_pixels; | |
1851 srcskip = info->s_skip/4; | |
1852 dst = info->d_pixels; | |
1853 dstskip = info->d_skip; | |
1854 map = info->table; | |
1855 | |
1856 #ifdef USE_DUFFS_LOOP | |
1857 while ( height-- ) { | |
1858 DUFFS_LOOP( | |
1162
2651158f59b8
Enable altivec blitters on PowerPC Linux, and some fixes for recent
Ryan C. Gordon <icculus@icculus.org>
parents:
1139
diff
changeset
|
1859 RGB888_RGB332(Pixel, *src); |
2651158f59b8
Enable altivec blitters on PowerPC Linux, and some fixes for recent
Ryan C. Gordon <icculus@icculus.org>
parents:
1139
diff
changeset
|
1860 *dst++ = map[Pixel]; |
0 | 1861 ++src; |
1862 , width); | |
1863 src += srcskip; | |
1864 dst += dstskip; | |
1865 } | |
1866 #else | |
1867 while ( height-- ) { | |
1868 for ( c=width/4; c; --c ) { | |
1869 /* Pack RGB into 8bit pixel */ | |
1162
2651158f59b8
Enable altivec blitters on PowerPC Linux, and some fixes for recent
Ryan C. Gordon <icculus@icculus.org>
parents:
1139
diff
changeset
|
1870 RGB888_RGB332(Pixel, *src); |
2651158f59b8
Enable altivec blitters on PowerPC Linux, and some fixes for recent
Ryan C. Gordon <icculus@icculus.org>
parents:
1139
diff
changeset
|
1871 *dst++ = map[Pixel]; |
0 | 1872 ++src; |
1162
2651158f59b8
Enable altivec blitters on PowerPC Linux, and some fixes for recent
Ryan C. Gordon <icculus@icculus.org>
parents:
1139
diff
changeset
|
1873 RGB888_RGB332(Pixel, *src); |
2651158f59b8
Enable altivec blitters on PowerPC Linux, and some fixes for recent
Ryan C. Gordon <icculus@icculus.org>
parents:
1139
diff
changeset
|
1874 *dst++ = map[Pixel]; |
0 | 1875 ++src; |
1162
2651158f59b8
Enable altivec blitters on PowerPC Linux, and some fixes for recent
Ryan C. Gordon <icculus@icculus.org>
parents:
1139
diff
changeset
|
1876 RGB888_RGB332(Pixel, *src); |
2651158f59b8
Enable altivec blitters on PowerPC Linux, and some fixes for recent
Ryan C. Gordon <icculus@icculus.org>
parents:
1139
diff
changeset
|
1877 *dst++ = map[Pixel]; |
0 | 1878 ++src; |
1162
2651158f59b8
Enable altivec blitters on PowerPC Linux, and some fixes for recent
Ryan C. Gordon <icculus@icculus.org>
parents:
1139
diff
changeset
|
1879 RGB888_RGB332(Pixel, *src); |
2651158f59b8
Enable altivec blitters on PowerPC Linux, and some fixes for recent
Ryan C. Gordon <icculus@icculus.org>
parents:
1139
diff
changeset
|
1880 *dst++ = map[Pixel]; |
0 | 1881 ++src; |
1882 } | |
91
e85e03f195b4
From: "Markus F.X.J. Oberhumer"
Sam Lantinga <slouken@lokigames.com>
parents:
0
diff
changeset
|
1883 switch ( width & 3 ) { |
0 | 1884 case 3: |
1162
2651158f59b8
Enable altivec blitters on PowerPC Linux, and some fixes for recent
Ryan C. Gordon <icculus@icculus.org>
parents:
1139
diff
changeset
|
1885 RGB888_RGB332(Pixel, *src); |
2651158f59b8
Enable altivec blitters on PowerPC Linux, and some fixes for recent
Ryan C. Gordon <icculus@icculus.org>
parents:
1139
diff
changeset
|
1886 *dst++ = map[Pixel]; |
0 | 1887 ++src; |
1888 case 2: | |
1162
2651158f59b8
Enable altivec blitters on PowerPC Linux, and some fixes for recent
Ryan C. Gordon <icculus@icculus.org>
parents:
1139
diff
changeset
|
1889 RGB888_RGB332(Pixel, *src); |
2651158f59b8
Enable altivec blitters on PowerPC Linux, and some fixes for recent
Ryan C. Gordon <icculus@icculus.org>
parents:
1139
diff
changeset
|
1890 *dst++ = map[Pixel]; |
0 | 1891 ++src; |
1892 case 1: | |
1162
2651158f59b8
Enable altivec blitters on PowerPC Linux, and some fixes for recent
Ryan C. Gordon <icculus@icculus.org>
parents:
1139
diff
changeset
|
1893 RGB888_RGB332(Pixel, *src); |
2651158f59b8
Enable altivec blitters on PowerPC Linux, and some fixes for recent
Ryan C. Gordon <icculus@icculus.org>
parents:
1139
diff
changeset
|
1894 *dst++ = map[Pixel]; |
0 | 1895 ++src; |
1896 } | |
1897 src += srcskip; | |
1898 dst += dstskip; | |
1899 } | |
1900 #endif /* USE_DUFFS_LOOP */ | |
1901 } | |
1902 static void BlitNto1(SDL_BlitInfo *info) | |
1903 { | |
1904 #ifndef USE_DUFFS_LOOP | |
1905 int c; | |
1906 #endif | |
1907 int width, height; | |
91
e85e03f195b4
From: "Markus F.X.J. Oberhumer"
Sam Lantinga <slouken@lokigames.com>
parents:
0
diff
changeset
|
1908 Uint8 *src; |
e85e03f195b4
From: "Markus F.X.J. Oberhumer"
Sam Lantinga <slouken@lokigames.com>
parents:
0
diff
changeset
|
1909 const Uint8 *map; |
e85e03f195b4
From: "Markus F.X.J. Oberhumer"
Sam Lantinga <slouken@lokigames.com>
parents:
0
diff
changeset
|
1910 Uint8 *dst; |
0 | 1911 int srcskip, dstskip; |
1912 int srcbpp; | |
1162
2651158f59b8
Enable altivec blitters on PowerPC Linux, and some fixes for recent
Ryan C. Gordon <icculus@icculus.org>
parents:
1139
diff
changeset
|
1913 Uint32 Pixel; |
0 | 1914 int sR, sG, sB; |
1915 SDL_PixelFormat *srcfmt; | |
1916 | |
1917 /* Set up some basic variables */ | |
1918 width = info->d_width; | |
1919 height = info->d_height; | |
1920 src = info->s_pixels; | |
1921 srcskip = info->s_skip; | |
1922 dst = info->d_pixels; | |
1923 dstskip = info->d_skip; | |
1924 map = info->table; | |
1925 srcfmt = info->src; | |
1926 srcbpp = srcfmt->BytesPerPixel; | |
1927 | |
1928 if ( map == NULL ) { | |
1929 while ( height-- ) { | |
1930 #ifdef USE_DUFFS_LOOP | |
1931 DUFFS_LOOP( | |
1162
2651158f59b8
Enable altivec blitters on PowerPC Linux, and some fixes for recent
Ryan C. Gordon <icculus@icculus.org>
parents:
1139
diff
changeset
|
1932 DISEMBLE_RGB(src, srcbpp, srcfmt, Pixel, |
0 | 1933 sR, sG, sB); |
1934 if ( 1 ) { | |
1935 /* Pack RGB into 8bit pixel */ | |
1936 *dst = ((sR>>5)<<(3+2))| | |
1937 ((sG>>5)<<(2)) | | |
1938 ((sB>>6)<<(0)) ; | |
1939 } | |
1940 dst++; | |
1941 src += srcbpp; | |
1942 , width); | |
1943 #else | |
1944 for ( c=width; c; --c ) { | |
1162
2651158f59b8
Enable altivec blitters on PowerPC Linux, and some fixes for recent
Ryan C. Gordon <icculus@icculus.org>
parents:
1139
diff
changeset
|
1945 DISEMBLE_RGB(src, srcbpp, srcfmt, Pixel, |
0 | 1946 sR, sG, sB); |
1947 if ( 1 ) { | |
1948 /* Pack RGB into 8bit pixel */ | |
1949 *dst = ((sR>>5)<<(3+2))| | |
1950 ((sG>>5)<<(2)) | | |
1951 ((sB>>6)<<(0)) ; | |
1952 } | |
1953 dst++; | |
1954 src += srcbpp; | |
1955 } | |
1956 #endif | |
1957 src += srcskip; | |
1958 dst += dstskip; | |
1959 } | |
1960 } else { | |
1961 while ( height-- ) { | |
1962 #ifdef USE_DUFFS_LOOP | |
1963 DUFFS_LOOP( | |
1162
2651158f59b8
Enable altivec blitters on PowerPC Linux, and some fixes for recent
Ryan C. Gordon <icculus@icculus.org>
parents:
1139
diff
changeset
|
1964 DISEMBLE_RGB(src, srcbpp, srcfmt, Pixel, |
0 | 1965 sR, sG, sB); |
1966 if ( 1 ) { | |
1967 /* Pack RGB into 8bit pixel */ | |
1968 *dst = map[((sR>>5)<<(3+2))| | |
1969 ((sG>>5)<<(2)) | | |
1970 ((sB>>6)<<(0)) ]; | |
1971 } | |
1972 dst++; | |
1973 src += srcbpp; | |
1974 , width); | |
1975 #else | |
1976 for ( c=width; c; --c ) { | |
1162
2651158f59b8
Enable altivec blitters on PowerPC Linux, and some fixes for recent
Ryan C. Gordon <icculus@icculus.org>
parents:
1139
diff
changeset
|
1977 DISEMBLE_RGB(src, srcbpp, srcfmt, Pixel, |
0 | 1978 sR, sG, sB); |
1979 if ( 1 ) { | |
1980 /* Pack RGB into 8bit pixel */ | |
1981 *dst = map[((sR>>5)<<(3+2))| | |
1982 ((sG>>5)<<(2)) | | |
1983 ((sB>>6)<<(0)) ]; | |
1984 } | |
1985 dst++; | |
1986 src += srcbpp; | |
1987 } | |
1988 #endif /* USE_DUFFS_LOOP */ | |
1989 src += srcskip; | |
1990 dst += dstskip; | |
1991 } | |
1992 } | |
1993 } | |
1232
0aa0000081d5
Added optimized C 32bit RGB<->RGBA alpha masking blitter from Alex Volkov.
Ryan C. Gordon <icculus@icculus.org>
parents:
1224
diff
changeset
|
1994 |
0aa0000081d5
Added optimized C 32bit RGB<->RGBA alpha masking blitter from Alex Volkov.
Ryan C. Gordon <icculus@icculus.org>
parents:
1224
diff
changeset
|
1995 /* blits 32 bit RGB<->RGBA with both surfaces having the same R,G,B fields */ |
0aa0000081d5
Added optimized C 32bit RGB<->RGBA alpha masking blitter from Alex Volkov.
Ryan C. Gordon <icculus@icculus.org>
parents:
1224
diff
changeset
|
1996 static void Blit4to4MaskAlpha(SDL_BlitInfo *info) |
0aa0000081d5
Added optimized C 32bit RGB<->RGBA alpha masking blitter from Alex Volkov.
Ryan C. Gordon <icculus@icculus.org>
parents:
1224
diff
changeset
|
1997 { |
0aa0000081d5
Added optimized C 32bit RGB<->RGBA alpha masking blitter from Alex Volkov.
Ryan C. Gordon <icculus@icculus.org>
parents:
1224
diff
changeset
|
1998 int width = info->d_width; |
0aa0000081d5
Added optimized C 32bit RGB<->RGBA alpha masking blitter from Alex Volkov.
Ryan C. Gordon <icculus@icculus.org>
parents:
1224
diff
changeset
|
1999 int height = info->d_height; |
0aa0000081d5
Added optimized C 32bit RGB<->RGBA alpha masking blitter from Alex Volkov.
Ryan C. Gordon <icculus@icculus.org>
parents:
1224
diff
changeset
|
2000 Uint32 *src = (Uint32 *)info->s_pixels; |
0aa0000081d5
Added optimized C 32bit RGB<->RGBA alpha masking blitter from Alex Volkov.
Ryan C. Gordon <icculus@icculus.org>
parents:
1224
diff
changeset
|
2001 int srcskip = info->s_skip; |
0aa0000081d5
Added optimized C 32bit RGB<->RGBA alpha masking blitter from Alex Volkov.
Ryan C. Gordon <icculus@icculus.org>
parents:
1224
diff
changeset
|
2002 Uint32 *dst = (Uint32 *)info->d_pixels; |
0aa0000081d5
Added optimized C 32bit RGB<->RGBA alpha masking blitter from Alex Volkov.
Ryan C. Gordon <icculus@icculus.org>
parents:
1224
diff
changeset
|
2003 int dstskip = info->d_skip; |
0aa0000081d5
Added optimized C 32bit RGB<->RGBA alpha masking blitter from Alex Volkov.
Ryan C. Gordon <icculus@icculus.org>
parents:
1224
diff
changeset
|
2004 SDL_PixelFormat *srcfmt = info->src; |
0aa0000081d5
Added optimized C 32bit RGB<->RGBA alpha masking blitter from Alex Volkov.
Ryan C. Gordon <icculus@icculus.org>
parents:
1224
diff
changeset
|
2005 SDL_PixelFormat *dstfmt = info->dst; |
0aa0000081d5
Added optimized C 32bit RGB<->RGBA alpha masking blitter from Alex Volkov.
Ryan C. Gordon <icculus@icculus.org>
parents:
1224
diff
changeset
|
2006 |
0aa0000081d5
Added optimized C 32bit RGB<->RGBA alpha masking blitter from Alex Volkov.
Ryan C. Gordon <icculus@icculus.org>
parents:
1224
diff
changeset
|
2007 if (dstfmt->Amask) { |
0aa0000081d5
Added optimized C 32bit RGB<->RGBA alpha masking blitter from Alex Volkov.
Ryan C. Gordon <icculus@icculus.org>
parents:
1224
diff
changeset
|
2008 /* RGB->RGBA, SET_ALPHA */ |
0aa0000081d5
Added optimized C 32bit RGB<->RGBA alpha masking blitter from Alex Volkov.
Ryan C. Gordon <icculus@icculus.org>
parents:
1224
diff
changeset
|
2009 Uint32 mask = (srcfmt->alpha >> dstfmt->Aloss) << dstfmt->Ashift; |
0aa0000081d5
Added optimized C 32bit RGB<->RGBA alpha masking blitter from Alex Volkov.
Ryan C. Gordon <icculus@icculus.org>
parents:
1224
diff
changeset
|
2010 |
0aa0000081d5
Added optimized C 32bit RGB<->RGBA alpha masking blitter from Alex Volkov.
Ryan C. Gordon <icculus@icculus.org>
parents:
1224
diff
changeset
|
2011 while ( height-- ) { |
0aa0000081d5
Added optimized C 32bit RGB<->RGBA alpha masking blitter from Alex Volkov.
Ryan C. Gordon <icculus@icculus.org>
parents:
1224
diff
changeset
|
2012 DUFFS_LOOP( |
0aa0000081d5
Added optimized C 32bit RGB<->RGBA alpha masking blitter from Alex Volkov.
Ryan C. Gordon <icculus@icculus.org>
parents:
1224
diff
changeset
|
2013 { |
0aa0000081d5
Added optimized C 32bit RGB<->RGBA alpha masking blitter from Alex Volkov.
Ryan C. Gordon <icculus@icculus.org>
parents:
1224
diff
changeset
|
2014 *dst = *src | mask; |
0aa0000081d5
Added optimized C 32bit RGB<->RGBA alpha masking blitter from Alex Volkov.
Ryan C. Gordon <icculus@icculus.org>
parents:
1224
diff
changeset
|
2015 ++dst; |
0aa0000081d5
Added optimized C 32bit RGB<->RGBA alpha masking blitter from Alex Volkov.
Ryan C. Gordon <icculus@icculus.org>
parents:
1224
diff
changeset
|
2016 ++src; |
0aa0000081d5
Added optimized C 32bit RGB<->RGBA alpha masking blitter from Alex Volkov.
Ryan C. Gordon <icculus@icculus.org>
parents:
1224
diff
changeset
|
2017 }, |
0aa0000081d5
Added optimized C 32bit RGB<->RGBA alpha masking blitter from Alex Volkov.
Ryan C. Gordon <icculus@icculus.org>
parents:
1224
diff
changeset
|
2018 width); |
0aa0000081d5
Added optimized C 32bit RGB<->RGBA alpha masking blitter from Alex Volkov.
Ryan C. Gordon <icculus@icculus.org>
parents:
1224
diff
changeset
|
2019 src = (Uint32*)((Uint8*)src + srcskip); |
0aa0000081d5
Added optimized C 32bit RGB<->RGBA alpha masking blitter from Alex Volkov.
Ryan C. Gordon <icculus@icculus.org>
parents:
1224
diff
changeset
|
2020 dst = (Uint32*)((Uint8*)dst + dstskip); |
0aa0000081d5
Added optimized C 32bit RGB<->RGBA alpha masking blitter from Alex Volkov.
Ryan C. Gordon <icculus@icculus.org>
parents:
1224
diff
changeset
|
2021 } |
0aa0000081d5
Added optimized C 32bit RGB<->RGBA alpha masking blitter from Alex Volkov.
Ryan C. Gordon <icculus@icculus.org>
parents:
1224
diff
changeset
|
2022 } else { |
0aa0000081d5
Added optimized C 32bit RGB<->RGBA alpha masking blitter from Alex Volkov.
Ryan C. Gordon <icculus@icculus.org>
parents:
1224
diff
changeset
|
2023 /* RGBA->RGB, NO_ALPHA */ |
0aa0000081d5
Added optimized C 32bit RGB<->RGBA alpha masking blitter from Alex Volkov.
Ryan C. Gordon <icculus@icculus.org>
parents:
1224
diff
changeset
|
2024 Uint32 mask = srcfmt->Rmask | srcfmt->Gmask | srcfmt->Bmask; |
0aa0000081d5
Added optimized C 32bit RGB<->RGBA alpha masking blitter from Alex Volkov.
Ryan C. Gordon <icculus@icculus.org>
parents:
1224
diff
changeset
|
2025 |
0aa0000081d5
Added optimized C 32bit RGB<->RGBA alpha masking blitter from Alex Volkov.
Ryan C. Gordon <icculus@icculus.org>
parents:
1224
diff
changeset
|
2026 while ( height-- ) { |
0aa0000081d5
Added optimized C 32bit RGB<->RGBA alpha masking blitter from Alex Volkov.
Ryan C. Gordon <icculus@icculus.org>
parents:
1224
diff
changeset
|
2027 DUFFS_LOOP( |
0aa0000081d5
Added optimized C 32bit RGB<->RGBA alpha masking blitter from Alex Volkov.
Ryan C. Gordon <icculus@icculus.org>
parents:
1224
diff
changeset
|
2028 { |
0aa0000081d5
Added optimized C 32bit RGB<->RGBA alpha masking blitter from Alex Volkov.
Ryan C. Gordon <icculus@icculus.org>
parents:
1224
diff
changeset
|
2029 *dst = *src & mask; |
0aa0000081d5
Added optimized C 32bit RGB<->RGBA alpha masking blitter from Alex Volkov.
Ryan C. Gordon <icculus@icculus.org>
parents:
1224
diff
changeset
|
2030 ++dst; |
0aa0000081d5
Added optimized C 32bit RGB<->RGBA alpha masking blitter from Alex Volkov.
Ryan C. Gordon <icculus@icculus.org>
parents:
1224
diff
changeset
|
2031 ++src; |
0aa0000081d5
Added optimized C 32bit RGB<->RGBA alpha masking blitter from Alex Volkov.
Ryan C. Gordon <icculus@icculus.org>
parents:
1224
diff
changeset
|
2032 }, |
0aa0000081d5
Added optimized C 32bit RGB<->RGBA alpha masking blitter from Alex Volkov.
Ryan C. Gordon <icculus@icculus.org>
parents:
1224
diff
changeset
|
2033 width); |
0aa0000081d5
Added optimized C 32bit RGB<->RGBA alpha masking blitter from Alex Volkov.
Ryan C. Gordon <icculus@icculus.org>
parents:
1224
diff
changeset
|
2034 src = (Uint32*)((Uint8*)src + srcskip); |
0aa0000081d5
Added optimized C 32bit RGB<->RGBA alpha masking blitter from Alex Volkov.
Ryan C. Gordon <icculus@icculus.org>
parents:
1224
diff
changeset
|
2035 dst = (Uint32*)((Uint8*)dst + dstskip); |
0aa0000081d5
Added optimized C 32bit RGB<->RGBA alpha masking blitter from Alex Volkov.
Ryan C. Gordon <icculus@icculus.org>
parents:
1224
diff
changeset
|
2036 } |
0aa0000081d5
Added optimized C 32bit RGB<->RGBA alpha masking blitter from Alex Volkov.
Ryan C. Gordon <icculus@icculus.org>
parents:
1224
diff
changeset
|
2037 } |
0aa0000081d5
Added optimized C 32bit RGB<->RGBA alpha masking blitter from Alex Volkov.
Ryan C. Gordon <icculus@icculus.org>
parents:
1224
diff
changeset
|
2038 } |
0aa0000081d5
Added optimized C 32bit RGB<->RGBA alpha masking blitter from Alex Volkov.
Ryan C. Gordon <icculus@icculus.org>
parents:
1224
diff
changeset
|
2039 |
0 | 2040 static void BlitNtoN(SDL_BlitInfo *info) |
2041 { | |
2042 int width = info->d_width; | |
2043 int height = info->d_height; | |
2044 Uint8 *src = info->s_pixels; | |
2045 int srcskip = info->s_skip; | |
2046 Uint8 *dst = info->d_pixels; | |
2047 int dstskip = info->d_skip; | |
2048 SDL_PixelFormat *srcfmt = info->src; | |
2049 int srcbpp = srcfmt->BytesPerPixel; | |
2050 SDL_PixelFormat *dstfmt = info->dst; | |
2051 int dstbpp = dstfmt->BytesPerPixel; | |
431
41cadcba32e8
Fixed SDL_DisplayFormatAlpha() on RGB surfaces with alpha
Sam Lantinga <slouken@libsdl.org>
parents:
366
diff
changeset
|
2052 unsigned alpha = dstfmt->Amask ? srcfmt->alpha : 0; |
0 | 2053 |
2054 while ( height-- ) { | |
2055 DUFFS_LOOP( | |
2056 { | |
1162
2651158f59b8
Enable altivec blitters on PowerPC Linux, and some fixes for recent
Ryan C. Gordon <icculus@icculus.org>
parents:
1139
diff
changeset
|
2057 Uint32 Pixel; |
0 | 2058 unsigned sR; |
2059 unsigned sG; | |
2060 unsigned sB; | |
1162
2651158f59b8
Enable altivec blitters on PowerPC Linux, and some fixes for recent
Ryan C. Gordon <icculus@icculus.org>
parents:
1139
diff
changeset
|
2061 DISEMBLE_RGB(src, srcbpp, srcfmt, Pixel, sR, sG, sB); |
0 | 2062 ASSEMBLE_RGBA(dst, dstbpp, dstfmt, sR, sG, sB, alpha); |
2063 dst += dstbpp; | |
2064 src += srcbpp; | |
2065 }, | |
2066 width); | |
2067 src += srcskip; | |
2068 dst += dstskip; | |
2069 } | |
2070 } | |
2071 | |
2072 static void BlitNtoNCopyAlpha(SDL_BlitInfo *info) | |
2073 { | |
2074 int width = info->d_width; | |
2075 int height = info->d_height; | |
2076 Uint8 *src = info->s_pixels; | |
2077 int srcskip = info->s_skip; | |
2078 Uint8 *dst = info->d_pixels; | |
2079 int dstskip = info->d_skip; | |
2080 SDL_PixelFormat *srcfmt = info->src; | |
2081 int srcbpp = srcfmt->BytesPerPixel; | |
2082 SDL_PixelFormat *dstfmt = info->dst; | |
2083 int dstbpp = dstfmt->BytesPerPixel; | |
2084 int c; | |
2085 | |
2086 /* FIXME: should map alpha to [0..255] correctly! */ | |
2087 while ( height-- ) { | |
2088 for ( c=width; c; --c ) { | |
1162
2651158f59b8
Enable altivec blitters on PowerPC Linux, and some fixes for recent
Ryan C. Gordon <icculus@icculus.org>
parents:
1139
diff
changeset
|
2089 Uint32 Pixel; |
0 | 2090 unsigned sR, sG, sB, sA; |
1162
2651158f59b8
Enable altivec blitters on PowerPC Linux, and some fixes for recent
Ryan C. Gordon <icculus@icculus.org>
parents:
1139
diff
changeset
|
2091 DISEMBLE_RGBA(src, srcbpp, srcfmt, Pixel, |
0 | 2092 sR, sG, sB, sA); |
2093 ASSEMBLE_RGBA(dst, dstbpp, dstfmt, | |
2094 sR, sG, sB, sA); | |
2095 dst += dstbpp; | |
2096 src += srcbpp; | |
2097 } | |
2098 src += srcskip; | |
2099 dst += dstskip; | |
2100 } | |
2101 } | |
2102 | |
2103 static void BlitNto1Key(SDL_BlitInfo *info) | |
2104 { | |
2105 int width = info->d_width; | |
2106 int height = info->d_height; | |
2107 Uint8 *src = info->s_pixels; | |
2108 int srcskip = info->s_skip; | |
2109 Uint8 *dst = info->d_pixels; | |
2110 int dstskip = info->d_skip; | |
2111 SDL_PixelFormat *srcfmt = info->src; | |
91
e85e03f195b4
From: "Markus F.X.J. Oberhumer"
Sam Lantinga <slouken@lokigames.com>
parents:
0
diff
changeset
|
2112 const Uint8 *palmap = info->table; |
0 | 2113 Uint32 ckey = srcfmt->colorkey; |
2114 Uint32 rgbmask = ~srcfmt->Amask; | |
2115 int srcbpp; | |
1162
2651158f59b8
Enable altivec blitters on PowerPC Linux, and some fixes for recent
Ryan C. Gordon <icculus@icculus.org>
parents:
1139
diff
changeset
|
2116 Uint32 Pixel; |
0 | 2117 Uint8 sR, sG, sB; |
2118 | |
2119 /* Set up some basic variables */ | |
2120 srcbpp = srcfmt->BytesPerPixel; | |
2121 ckey &= rgbmask; | |
2122 | |
2123 if ( palmap == NULL ) { | |
2124 while ( height-- ) { | |
2125 DUFFS_LOOP( | |
2126 { | |
1162
2651158f59b8
Enable altivec blitters on PowerPC Linux, and some fixes for recent
Ryan C. Gordon <icculus@icculus.org>
parents:
1139
diff
changeset
|
2127 DISEMBLE_RGB(src, srcbpp, srcfmt, Pixel, |
0 | 2128 sR, sG, sB); |
1162
2651158f59b8
Enable altivec blitters on PowerPC Linux, and some fixes for recent
Ryan C. Gordon <icculus@icculus.org>
parents:
1139
diff
changeset
|
2129 if ( (Pixel & rgbmask) != ckey ) { |
0 | 2130 /* Pack RGB into 8bit pixel */ |
2131 *dst = ((sR>>5)<<(3+2))| | |
2132 ((sG>>5)<<(2)) | | |
2133 ((sB>>6)<<(0)) ; | |
2134 } | |
2135 dst++; | |
2136 src += srcbpp; | |
2137 }, | |
2138 width); | |
2139 src += srcskip; | |
2140 dst += dstskip; | |
2141 } | |
2142 } else { | |
2143 while ( height-- ) { | |
2144 DUFFS_LOOP( | |
2145 { | |
1162
2651158f59b8
Enable altivec blitters on PowerPC Linux, and some fixes for recent
Ryan C. Gordon <icculus@icculus.org>
parents:
1139
diff
changeset
|
2146 DISEMBLE_RGB(src, srcbpp, srcfmt, Pixel, |
0 | 2147 sR, sG, sB); |
1162
2651158f59b8
Enable altivec blitters on PowerPC Linux, and some fixes for recent
Ryan C. Gordon <icculus@icculus.org>
parents:
1139
diff
changeset
|
2148 if ( (Pixel & rgbmask) != ckey ) { |
0 | 2149 /* Pack RGB into 8bit pixel */ |
2150 *dst = palmap[((sR>>5)<<(3+2))| | |
2151 ((sG>>5)<<(2)) | | |
2152 ((sB>>6)<<(0)) ]; | |
2153 } | |
2154 dst++; | |
2155 src += srcbpp; | |
2156 }, | |
2157 width); | |
2158 src += srcskip; | |
2159 dst += dstskip; | |
2160 } | |
2161 } | |
2162 } | |
2163 | |
2164 static void Blit2to2Key(SDL_BlitInfo *info) | |
2165 { | |
2166 int width = info->d_width; | |
2167 int height = info->d_height; | |
2168 Uint16 *srcp = (Uint16 *)info->s_pixels; | |
2169 int srcskip = info->s_skip; | |
2170 Uint16 *dstp = (Uint16 *)info->d_pixels; | |
2171 int dstskip = info->d_skip; | |
2172 Uint32 ckey = info->src->colorkey; | |
2173 Uint32 rgbmask = ~info->src->Amask; | |
2174 | |
2175 /* Set up some basic variables */ | |
2176 srcskip /= 2; | |
2177 dstskip /= 2; | |
2178 ckey &= rgbmask; | |
2179 | |
2180 while ( height-- ) { | |
2181 DUFFS_LOOP( | |
2182 { | |
2183 if ( (*srcp & rgbmask) != ckey ) { | |
2184 *dstp = *srcp; | |
2185 } | |
2186 dstp++; | |
2187 srcp++; | |
2188 }, | |
2189 width); | |
2190 srcp += srcskip; | |
2191 dstp += dstskip; | |
2192 } | |
2193 } | |
2194 | |
2195 static void BlitNtoNKey(SDL_BlitInfo *info) | |
2196 { | |
2197 int width = info->d_width; | |
2198 int height = info->d_height; | |
2199 Uint8 *src = info->s_pixels; | |
2200 int srcskip = info->s_skip; | |
2201 Uint8 *dst = info->d_pixels; | |
2202 int dstskip = info->d_skip; | |
2203 Uint32 ckey = info->src->colorkey; | |
2204 SDL_PixelFormat *srcfmt = info->src; | |
2205 SDL_PixelFormat *dstfmt = info->dst; | |
2206 int srcbpp = srcfmt->BytesPerPixel; | |
2207 int dstbpp = dstfmt->BytesPerPixel; | |
431
41cadcba32e8
Fixed SDL_DisplayFormatAlpha() on RGB surfaces with alpha
Sam Lantinga <slouken@libsdl.org>
parents:
366
diff
changeset
|
2208 unsigned alpha = dstfmt->Amask ? srcfmt->alpha : 0; |
0 | 2209 |
2210 while ( height-- ) { | |
2211 DUFFS_LOOP( | |
2212 { | |
1162
2651158f59b8
Enable altivec blitters on PowerPC Linux, and some fixes for recent
Ryan C. Gordon <icculus@icculus.org>
parents:
1139
diff
changeset
|
2213 Uint32 Pixel; |
0 | 2214 unsigned sR; |
2215 unsigned sG; | |
2216 unsigned sB; | |
1162
2651158f59b8
Enable altivec blitters on PowerPC Linux, and some fixes for recent
Ryan C. Gordon <icculus@icculus.org>
parents:
1139
diff
changeset
|
2217 RETRIEVE_RGB_PIXEL(src, srcbpp, Pixel); |
2651158f59b8
Enable altivec blitters on PowerPC Linux, and some fixes for recent
Ryan C. Gordon <icculus@icculus.org>
parents:
1139
diff
changeset
|
2218 if ( Pixel != ckey ) { |
2651158f59b8
Enable altivec blitters on PowerPC Linux, and some fixes for recent
Ryan C. Gordon <icculus@icculus.org>
parents:
1139
diff
changeset
|
2219 RGB_FROM_PIXEL(Pixel, srcfmt, sR, sG, sB); |
0 | 2220 ASSEMBLE_RGBA(dst, dstbpp, dstfmt, |
2221 sR, sG, sB, alpha); | |
2222 } | |
2223 dst += dstbpp; | |
2224 src += srcbpp; | |
2225 }, | |
2226 width); | |
2227 src += srcskip; | |
2228 dst += dstskip; | |
2229 } | |
2230 } | |
2231 | |
2232 static void BlitNtoNKeyCopyAlpha(SDL_BlitInfo *info) | |
2233 { | |
2234 int width = info->d_width; | |
2235 int height = info->d_height; | |
2236 Uint8 *src = info->s_pixels; | |
2237 int srcskip = info->s_skip; | |
2238 Uint8 *dst = info->d_pixels; | |
2239 int dstskip = info->d_skip; | |
2240 Uint32 ckey = info->src->colorkey; | |
2241 SDL_PixelFormat *srcfmt = info->src; | |
2242 SDL_PixelFormat *dstfmt = info->dst; | |
2243 Uint32 rgbmask = ~srcfmt->Amask; | |
2244 | |
2245 Uint8 srcbpp; | |
2246 Uint8 dstbpp; | |
1162
2651158f59b8
Enable altivec blitters on PowerPC Linux, and some fixes for recent
Ryan C. Gordon <icculus@icculus.org>
parents:
1139
diff
changeset
|
2247 Uint32 Pixel; |
0 | 2248 Uint8 sR, sG, sB, sA; |
2249 | |
2250 /* Set up some basic variables */ | |
2251 srcbpp = srcfmt->BytesPerPixel; | |
2252 dstbpp = dstfmt->BytesPerPixel; | |
2253 ckey &= rgbmask; | |
2254 | |
2255 /* FIXME: should map alpha to [0..255] correctly! */ | |
2256 while ( height-- ) { | |
2257 DUFFS_LOOP( | |
2258 { | |
1162
2651158f59b8
Enable altivec blitters on PowerPC Linux, and some fixes for recent
Ryan C. Gordon <icculus@icculus.org>
parents:
1139
diff
changeset
|
2259 DISEMBLE_RGBA(src, srcbpp, srcfmt, Pixel, |
0 | 2260 sR, sG, sB, sA); |
1162
2651158f59b8
Enable altivec blitters on PowerPC Linux, and some fixes for recent
Ryan C. Gordon <icculus@icculus.org>
parents:
1139
diff
changeset
|
2261 if ( (Pixel & rgbmask) != ckey ) { |
0 | 2262 ASSEMBLE_RGBA(dst, dstbpp, dstfmt, |
2263 sR, sG, sB, sA); | |
2264 } | |
2265 dst += dstbpp; | |
2266 src += srcbpp; | |
2267 }, | |
2268 width); | |
2269 src += srcskip; | |
2270 dst += dstskip; | |
2271 } | |
2272 } | |
2273 | |
2274 /* Normal N to N optimized blitters */ | |
2275 struct blit_table { | |
2276 Uint32 srcR, srcG, srcB; | |
2277 int dstbpp; | |
2278 Uint32 dstR, dstG, dstB; | |
1047
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
2279 Uint32 blit_features; |
0 | 2280 void *aux_data; |
2281 SDL_loblit blitfunc; | |
1047
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
2282 enum { NO_ALPHA=1, SET_ALPHA=2, COPY_ALPHA=4 } alpha; |
0 | 2283 }; |
91
e85e03f195b4
From: "Markus F.X.J. Oberhumer"
Sam Lantinga <slouken@lokigames.com>
parents:
0
diff
changeset
|
2284 static const struct blit_table normal_blit_1[] = { |
0 | 2285 /* Default for 8-bit RGB source, an invalid combination */ |
2286 { 0,0,0, 0, 0,0,0, 0, NULL, NULL }, | |
2287 }; | |
91
e85e03f195b4
From: "Markus F.X.J. Oberhumer"
Sam Lantinga <slouken@lokigames.com>
parents:
0
diff
changeset
|
2288 static const struct blit_table normal_blit_2[] = { |
0 | 2289 #ifdef USE_ASMBLIT |
2290 { 0x0000F800,0x000007E0,0x0000001F, 2, 0x0000001F,0x000007E0,0x0000F800, | |
2291 0, ConvertX86p16_16BGR565, ConvertX86, NO_ALPHA }, | |
2292 { 0x0000F800,0x000007E0,0x0000001F, 2, 0x00007C00,0x000003E0,0x0000001F, | |
2293 0, ConvertX86p16_16RGB555, ConvertX86, NO_ALPHA }, | |
2294 { 0x0000F800,0x000007E0,0x0000001F, 2, 0x0000001F,0x000003E0,0x00007C00, | |
2295 0, ConvertX86p16_16BGR555, ConvertX86, NO_ALPHA }, | |
2296 #endif | |
1047
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
2297 #ifdef USE_ALTIVEC_BLITTERS |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
2298 /* has-altivec */ |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
2299 { 0x0000F800,0x000007E0,0x0000001F, 4, 0x00000000,0x00000000,0x00000000, |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
2300 2, NULL, Blit_RGB565_32Altivec, NO_ALPHA | COPY_ALPHA | SET_ALPHA }, |
1139
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
2301 { 0x00007C00,0x000003E0,0x0000001F, 4, 0x00000000,0x00000000,0x00000000, |
d0ae4dff7208
Altivec blitter for 555 -> 8888 surface, written by me.
Ryan C. Gordon <icculus@icculus.org>
parents:
1053
diff
changeset
|
2302 2, NULL, Blit_RGB555_32Altivec, NO_ALPHA | COPY_ALPHA | SET_ALPHA }, |
1047
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
2303 #endif |
0 | 2304 { 0x0000F800,0x000007E0,0x0000001F, 4, 0x00FF0000,0x0000FF00,0x000000FF, |
2305 0, NULL, Blit_RGB565_ARGB8888, SET_ALPHA }, | |
2306 { 0x0000F800,0x000007E0,0x0000001F, 4, 0x000000FF,0x0000FF00,0x00FF0000, | |
2307 0, NULL, Blit_RGB565_ABGR8888, SET_ALPHA }, | |
2308 { 0x0000F800,0x000007E0,0x0000001F, 4, 0xFF000000,0x00FF0000,0x0000FF00, | |
2309 0, NULL, Blit_RGB565_RGBA8888, SET_ALPHA }, | |
2310 { 0x0000F800,0x000007E0,0x0000001F, 4, 0x0000FF00,0x00FF0000,0xFF000000, | |
2311 0, NULL, Blit_RGB565_BGRA8888, SET_ALPHA }, | |
2312 | |
2313 /* Default for 16-bit RGB source, used if no other blitter matches */ | |
2314 { 0,0,0, 0, 0,0,0, 0, NULL, BlitNtoN, 0 } | |
2315 }; | |
91
e85e03f195b4
From: "Markus F.X.J. Oberhumer"
Sam Lantinga <slouken@lokigames.com>
parents:
0
diff
changeset
|
2316 static const struct blit_table normal_blit_3[] = { |
0 | 2317 /* Default for 24-bit RGB source, never optimized */ |
2318 { 0,0,0, 0, 0,0,0, 0, NULL, BlitNtoN, 0 } | |
2319 }; | |
91
e85e03f195b4
From: "Markus F.X.J. Oberhumer"
Sam Lantinga <slouken@lokigames.com>
parents:
0
diff
changeset
|
2320 static const struct blit_table normal_blit_4[] = { |
0 | 2321 #ifdef USE_ASMBLIT |
2322 { 0x00FF0000,0x0000FF00,0x000000FF, 2, 0x0000F800,0x000007E0,0x0000001F, | |
739
22dbf364c017
Added SDL_HasMMX(), SDL_Has3DNow(), SDL_HasSSE() in SDL_cpuinfo.h
Sam Lantinga <slouken@libsdl.org>
parents:
431
diff
changeset
|
2323 1, ConvertMMXpII32_16RGB565, ConvertMMX, NO_ALPHA }, |
0 | 2324 { 0x00FF0000,0x0000FF00,0x000000FF, 2, 0x0000F800,0x000007E0,0x0000001F, |
2325 0, ConvertX86p32_16RGB565, ConvertX86, NO_ALPHA }, | |
2326 { 0x00FF0000,0x0000FF00,0x000000FF, 2, 0x0000001F,0x000007E0,0x0000F800, | |
739
22dbf364c017
Added SDL_HasMMX(), SDL_Has3DNow(), SDL_HasSSE() in SDL_cpuinfo.h
Sam Lantinga <slouken@libsdl.org>
parents:
431
diff
changeset
|
2327 1, ConvertMMXpII32_16BGR565, ConvertMMX, NO_ALPHA }, |
0 | 2328 { 0x00FF0000,0x0000FF00,0x000000FF, 2, 0x0000001F,0x000007E0,0x0000F800, |
2329 0, ConvertX86p32_16BGR565, ConvertX86, NO_ALPHA }, | |
2330 { 0x00FF0000,0x0000FF00,0x000000FF, 2, 0x00007C00,0x000003E0,0x0000001F, | |
739
22dbf364c017
Added SDL_HasMMX(), SDL_Has3DNow(), SDL_HasSSE() in SDL_cpuinfo.h
Sam Lantinga <slouken@libsdl.org>
parents:
431
diff
changeset
|
2331 1, ConvertMMXpII32_16RGB555, ConvertMMX, NO_ALPHA }, |
0 | 2332 { 0x00FF0000,0x0000FF00,0x000000FF, 2, 0x00007C00,0x000003E0,0x0000001F, |
2333 0, ConvertX86p32_16RGB555, ConvertX86, NO_ALPHA }, | |
2334 { 0x00FF0000,0x0000FF00,0x000000FF, 2, 0x0000001F,0x000003E0,0x00007C00, | |
739
22dbf364c017
Added SDL_HasMMX(), SDL_Has3DNow(), SDL_HasSSE() in SDL_cpuinfo.h
Sam Lantinga <slouken@libsdl.org>
parents:
431
diff
changeset
|
2335 1, ConvertMMXpII32_16BGR555, ConvertMMX, NO_ALPHA }, |
0 | 2336 { 0x00FF0000,0x0000FF00,0x000000FF, 2, 0x0000001F,0x000003E0,0x00007C00, |
2337 0, ConvertX86p32_16BGR555, ConvertX86, NO_ALPHA }, | |
2338 { 0x00FF0000,0x0000FF00,0x000000FF, 3, 0x00FF0000,0x0000FF00,0x000000FF, | |
2339 0, ConvertX86p32_24RGB888, ConvertX86, NO_ALPHA }, | |
2340 { 0x00FF0000,0x0000FF00,0x000000FF, 3, 0x000000FF,0x0000FF00,0x00FF0000, | |
2341 0, ConvertX86p32_24BGR888, ConvertX86, NO_ALPHA }, | |
2342 { 0x00FF0000,0x0000FF00,0x000000FF, 4, 0x000000FF,0x0000FF00,0x00FF0000, | |
2343 0, ConvertX86p32_32BGR888, ConvertX86, NO_ALPHA }, | |
2344 { 0x00FF0000,0x0000FF00,0x000000FF, 4, 0xFF000000,0x00FF0000,0x0000FF00, | |
2345 0, ConvertX86p32_32RGBA888, ConvertX86, NO_ALPHA }, | |
2346 { 0x00FF0000,0x0000FF00,0x000000FF, 4, 0x0000FF00,0x00FF0000,0xFF000000, | |
2347 0, ConvertX86p32_32BGRA888, ConvertX86, NO_ALPHA }, | |
2348 #else | |
1047
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
2349 #ifdef USE_ALTIVEC_BLITTERS |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
2350 /* has-altivec | dont-use-prefetch */ |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
2351 { 0x00000000,0x00000000,0x00000000, 4, 0x00000000,0x00000000,0x00000000, |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
2352 6, NULL, ConvertAltivec32to32_noprefetch, NO_ALPHA | COPY_ALPHA | SET_ALPHA }, |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
2353 /* has-altivec */ |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
2354 { 0x00000000,0x00000000,0x00000000, 4, 0x00000000,0x00000000,0x00000000, |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
2355 2, NULL, ConvertAltivec32to32_prefetch, NO_ALPHA | COPY_ALPHA | SET_ALPHA }, |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
2356 /* has-altivec */ |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
2357 { 0x00000000,0x00000000,0x00000000, 2, 0x0000F800,0x000007E0,0x0000001F, |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
2358 2, NULL, Blit_RGB888_RGB565Altivec, NO_ALPHA }, |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
2359 #endif |
0 | 2360 { 0x00FF0000,0x0000FF00,0x000000FF, 2, 0x0000F800,0x000007E0,0x0000001F, |
2361 0, NULL, Blit_RGB888_RGB565, NO_ALPHA }, | |
2362 { 0x00FF0000,0x0000FF00,0x000000FF, 2, 0x00007C00,0x000003E0,0x0000001F, | |
2363 0, NULL, Blit_RGB888_RGB555, NO_ALPHA }, | |
2364 #endif | |
2365 /* Default for 32-bit RGB source, used if no other blitter matches */ | |
2366 { 0,0,0, 0, 0,0,0, 0, NULL, BlitNtoN, 0 } | |
2367 }; | |
91
e85e03f195b4
From: "Markus F.X.J. Oberhumer"
Sam Lantinga <slouken@lokigames.com>
parents:
0
diff
changeset
|
2368 static const struct blit_table *normal_blit[] = { |
0 | 2369 normal_blit_1, normal_blit_2, normal_blit_3, normal_blit_4 |
2370 }; | |
2371 | |
1047
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
2372 /* Mask matches table, or table entry is zero */ |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
2373 #define MASKOK(x, y) (((x) == (y)) || ((y) == 0x00000000)) |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
2374 |
0 | 2375 SDL_loblit SDL_CalculateBlitN(SDL_Surface *surface, int blit_index) |
2376 { | |
2377 struct private_swaccel *sdata; | |
2378 SDL_PixelFormat *srcfmt; | |
2379 SDL_PixelFormat *dstfmt; | |
91
e85e03f195b4
From: "Markus F.X.J. Oberhumer"
Sam Lantinga <slouken@lokigames.com>
parents:
0
diff
changeset
|
2380 const struct blit_table *table; |
0 | 2381 int which; |
2382 SDL_loblit blitfun; | |
2383 | |
2384 /* Set up data for choosing the blit */ | |
2385 sdata = surface->map->sw_data; | |
2386 srcfmt = surface->format; | |
2387 dstfmt = surface->map->dst->format; | |
2388 | |
2389 if ( blit_index & 2 ) { | |
2390 /* alpha or alpha+colorkey */ | |
2391 return SDL_CalculateAlphaBlit(surface, blit_index); | |
2392 } | |
2393 | |
2394 /* We don't support destinations less than 8-bits */ | |
2395 if ( dstfmt->BitsPerPixel < 8 ) { | |
2396 return(NULL); | |
2397 } | |
2398 | |
2399 if(blit_index == 1) { | |
2400 /* colorkey blit: Here we don't have too many options, mostly | |
2401 because RLE is the preferred fast way to deal with this. | |
2402 If a particular case turns out to be useful we'll add it. */ | |
2403 | |
2404 if(srcfmt->BytesPerPixel == 2 | |
2405 && surface->map->identity) | |
2406 return Blit2to2Key; | |
2407 else if(dstfmt->BytesPerPixel == 1) | |
2408 return BlitNto1Key; | |
2409 else { | |
1047
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
2410 #ifdef USE_ALTIVEC_BLITTERS |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
2411 if((srcfmt->BytesPerPixel == 4) && (dstfmt->BytesPerPixel == 4) && SDL_HasAltiVec()) { |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
2412 return Blit32to32KeyAltivec; |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
2413 } else |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
2414 #endif |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
2415 |
0 | 2416 if(srcfmt->Amask && dstfmt->Amask) |
2417 return BlitNtoNKeyCopyAlpha; | |
2418 else | |
2419 return BlitNtoNKey; | |
2420 } | |
2421 } | |
2422 | |
2423 blitfun = NULL; | |
2424 if ( dstfmt->BitsPerPixel == 8 ) { | |
2425 /* We assume 8-bit destinations are palettized */ | |
2426 if ( (srcfmt->BytesPerPixel == 4) && | |
2427 (srcfmt->Rmask == 0x00FF0000) && | |
2428 (srcfmt->Gmask == 0x0000FF00) && | |
2429 (srcfmt->Bmask == 0x000000FF) ) { | |
2430 if ( surface->map->table ) { | |
2431 blitfun = Blit_RGB888_index8_map; | |
2432 } else { | |
2433 #ifdef USE_ASMBLIT | |
2434 sdata->aux_data = ConvertX86p32_8RGB332; | |
2435 blitfun = ConvertX86; | |
2436 #else | |
2437 blitfun = Blit_RGB888_index8; | |
2438 #endif | |
2439 } | |
2440 } else { | |
2441 blitfun = BlitNto1; | |
2442 } | |
2443 } else { | |
2444 /* Now the meat, choose the blitter we want */ | |
1047
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
2445 int a_need = 0; |
0 | 2446 if(dstfmt->Amask) |
2447 a_need = srcfmt->Amask ? COPY_ALPHA : SET_ALPHA; | |
2448 table = normal_blit[srcfmt->BytesPerPixel-1]; | |
1047
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
2449 for ( which=0; table[which].dstbpp; ++which ) { |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
2450 if ( MASKOK(srcfmt->Rmask, table[which].srcR) && |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
2451 MASKOK(srcfmt->Gmask, table[which].srcG) && |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
2452 MASKOK(srcfmt->Bmask, table[which].srcB) && |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
2453 MASKOK(dstfmt->Rmask, table[which].dstR) && |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
2454 MASKOK(dstfmt->Gmask, table[which].dstG) && |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
2455 MASKOK(dstfmt->Bmask, table[which].dstB) && |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
2456 dstfmt->BytesPerPixel == table[which].dstbpp && |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
2457 (a_need & table[which].alpha) == a_need && |
ffaaf7ecf685
Altivec-optimized blitters!
Ryan C. Gordon <icculus@icculus.org>
parents:
769
diff
changeset
|
2458 ((table[which].blit_features & GetBlitFeatures()) == table[which].blit_features) ) |
0 | 2459 break; |
2460 } | |
2461 sdata->aux_data = table[which].aux_data; | |
2462 blitfun = table[which].blitfunc; | |
1232
0aa0000081d5
Added optimized C 32bit RGB<->RGBA alpha masking blitter from Alex Volkov.
Ryan C. Gordon <icculus@icculus.org>
parents:
1224
diff
changeset
|
2463 |
0aa0000081d5
Added optimized C 32bit RGB<->RGBA alpha masking blitter from Alex Volkov.
Ryan C. Gordon <icculus@icculus.org>
parents:
1224
diff
changeset
|
2464 if(blitfun == BlitNtoN) { /* default C fallback catch-all. Slow! */ |
0aa0000081d5
Added optimized C 32bit RGB<->RGBA alpha masking blitter from Alex Volkov.
Ryan C. Gordon <icculus@icculus.org>
parents:
1224
diff
changeset
|
2465 /* Fastpath C fallback: 32bit RGB<->RGBA blit with matching RGB */ |
0aa0000081d5
Added optimized C 32bit RGB<->RGBA alpha masking blitter from Alex Volkov.
Ryan C. Gordon <icculus@icculus.org>
parents:
1224
diff
changeset
|
2466 if ( srcfmt->BytesPerPixel == 4 && dstfmt->BytesPerPixel == 4 && |
0aa0000081d5
Added optimized C 32bit RGB<->RGBA alpha masking blitter from Alex Volkov.
Ryan C. Gordon <icculus@icculus.org>
parents:
1224
diff
changeset
|
2467 srcfmt->Rmask == dstfmt->Rmask && |
0aa0000081d5
Added optimized C 32bit RGB<->RGBA alpha masking blitter from Alex Volkov.
Ryan C. Gordon <icculus@icculus.org>
parents:
1224
diff
changeset
|
2468 srcfmt->Gmask == dstfmt->Gmask && |
0aa0000081d5
Added optimized C 32bit RGB<->RGBA alpha masking blitter from Alex Volkov.
Ryan C. Gordon <icculus@icculus.org>
parents:
1224
diff
changeset
|
2469 srcfmt->Bmask == dstfmt->Bmask ) { |
0aa0000081d5
Added optimized C 32bit RGB<->RGBA alpha masking blitter from Alex Volkov.
Ryan C. Gordon <icculus@icculus.org>
parents:
1224
diff
changeset
|
2470 blitfun = Blit4to4MaskAlpha; |
0aa0000081d5
Added optimized C 32bit RGB<->RGBA alpha masking blitter from Alex Volkov.
Ryan C. Gordon <icculus@icculus.org>
parents:
1224
diff
changeset
|
2471 } else if ( a_need == COPY_ALPHA ) { |
0aa0000081d5
Added optimized C 32bit RGB<->RGBA alpha masking blitter from Alex Volkov.
Ryan C. Gordon <icculus@icculus.org>
parents:
1224
diff
changeset
|
2472 blitfun = BlitNtoNCopyAlpha; |
0aa0000081d5
Added optimized C 32bit RGB<->RGBA alpha masking blitter from Alex Volkov.
Ryan C. Gordon <icculus@icculus.org>
parents:
1224
diff
changeset
|
2473 } |
0aa0000081d5
Added optimized C 32bit RGB<->RGBA alpha masking blitter from Alex Volkov.
Ryan C. Gordon <icculus@icculus.org>
parents:
1224
diff
changeset
|
2474 } |
0 | 2475 } |
2476 | |
2477 #ifdef DEBUG_ASM | |
2478 #ifdef USE_ASMBLIT | |
2479 if ( blitfun == ConvertMMX ) | |
2480 fprintf(stderr, "Using mmx blit\n"); | |
2481 else | |
2482 if ( blitfun == ConvertX86 ) | |
2483 fprintf(stderr, "Using asm blit\n"); | |
2484 else | |
2485 #endif | |
1224
f033d9589ca1
Debug code should check right function names.
Ryan C. Gordon <icculus@icculus.org>
parents:
1175
diff
changeset
|
2486 if ( (blitfun == BlitNtoN) || (blitfun == BlitNto1) ) |
0 | 2487 fprintf(stderr, "Using C blit\n"); |
2488 else | |
2489 fprintf(stderr, "Using optimized C blit\n"); | |
2490 #endif /* DEBUG_ASM */ | |
2491 | |
2492 return(blitfun); | |
2493 } |