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