Mercurial > sdl-ios-xcode
annotate src/video/SDL_stretch.c @ 937:1e6366bde299
Date: Tue, 27 Jul 2004 17:14:00 +0200
From: "Eckhard Stolberg"
Subject: Controller names in SDL for Windows
I'm working on an Atari 2600 emulator for different systems that uses
the SDL. Some time ago someone created an adaptor that lets you use
your old Atari controllers with your computer through the USB port.
Some of the Atari controllers require special handling by the emulator,
so it would be nice, if it would be possible to detect if any of the
controllers connected to the computer is this adaptor.
SDL would allow that with the SDL_JoystickName function, but unfortunately
it doesn't work properly on Windows. On Linux and MacOSX this function
returns the name of the controller, but on Windows you'll only get the
name of the joystick driver. Most joysticks nowadays use the generic
Microsoft driver, so they all return the same name.
In an old MSDN article
(http://msdn.microsoft.com/archive/default.asp?url=/archive/en-us/dnarinput/html/msdn_extdirect.asp)
Microsoft describes how to read out the OEM controller names from the registry.
I have implemented this for the SDL controller handler on Windows,
and now reading the joystick name works properly there too.
author | Sam Lantinga <slouken@libsdl.org> |
---|---|
date | Sat, 21 Aug 2004 03:45:58 +0000 |
parents | 1d1a823904d8 |
children | 10b3fb28c86b |
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:
627
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:
0
diff
changeset
|
20 slouken@libsdl.org |
0 | 21 */ |
22 | |
23 #ifdef SAVE_RCSID | |
24 static char rcsid = | |
25 "@(#) $Id$"; | |
26 #endif | |
27 | |
28 /* This a stretch blit implementation based on ideas given to me by | |
29 Tomasz Cejner - thanks! :) | |
30 | |
31 April 27, 2000 - Sam Lantinga | |
32 */ | |
33 | |
34 #include "SDL_error.h" | |
35 #include "SDL_video.h" | |
36 #include "SDL_blit.h" | |
37 | |
38 /* This isn't ready for general consumption yet - it should be folded | |
39 into the general blitting mechanism. | |
40 */ | |
41 | |
288
2f5a6062db86
Updated for Watcom C++ and LCC compilers
Sam Lantinga <slouken@libsdl.org>
parents:
274
diff
changeset
|
42 #if (defined(WIN32) && !defined(_M_ALPHA) && !defined(_WIN32_WCE) && \ |
2f5a6062db86
Updated for Watcom C++ and LCC compilers
Sam Lantinga <slouken@libsdl.org>
parents:
274
diff
changeset
|
43 !defined(__WATCOMC__) && !defined(__LCC__) && !defined(__FREEBCC__)) || \ |
2f5a6062db86
Updated for Watcom C++ and LCC compilers
Sam Lantinga <slouken@libsdl.org>
parents:
274
diff
changeset
|
44 (defined(i386) && defined(__GNUC__) && defined(USE_ASMBLIT)) |
0 | 45 #define USE_ASM_STRETCH |
46 #endif | |
47 | |
48 #ifdef USE_ASM_STRETCH | |
49 | |
50 #if defined(WIN32) || defined(i386) | |
51 #define PREFIX16 0x66 | |
52 #define STORE_BYTE 0xAA | |
53 #define STORE_WORD 0xAB | |
54 #define LOAD_BYTE 0xAC | |
55 #define LOAD_WORD 0xAD | |
56 #define RETURN 0xC3 | |
57 #else | |
58 #error Need assembly opcodes for this architecture | |
59 #endif | |
60 | |
61 #if defined(__ELF__) && defined(__GNUC__) | |
62 extern unsigned char _copy_row[4096] __attribute__ ((alias ("copy_row"))); | |
63 #endif | |
64 static unsigned char copy_row[4096]; | |
65 | |
66 static int generate_rowbytes(int src_w, int dst_w, int bpp) | |
67 { | |
68 static struct { | |
69 int bpp; | |
70 int src_w; | |
71 int dst_w; | |
72 } last; | |
73 | |
74 int i; | |
75 int pos, inc; | |
76 unsigned char *eip; | |
77 unsigned char load, store; | |
78 | |
79 /* See if we need to regenerate the copy buffer */ | |
80 if ( (src_w == last.src_w) && | |
81 (dst_w == last.src_w) && (bpp == last.bpp) ) { | |
82 return(0); | |
83 } | |
84 last.bpp = bpp; | |
85 last.src_w = src_w; | |
86 last.dst_w = dst_w; | |
87 | |
88 switch (bpp) { | |
89 case 1: | |
90 load = LOAD_BYTE; | |
91 store = STORE_BYTE; | |
92 break; | |
93 case 2: | |
94 case 4: | |
95 load = LOAD_WORD; | |
96 store = STORE_WORD; | |
97 break; | |
98 default: | |
99 SDL_SetError("ASM stretch of %d bytes isn't supported\n", bpp); | |
100 return(-1); | |
101 } | |
102 pos = 0x10000; | |
103 inc = (src_w << 16) / dst_w; | |
104 eip = copy_row; | |
105 for ( i=0; i<dst_w; ++i ) { | |
106 while ( pos >= 0x10000L ) { | |
107 if ( bpp == 2 ) { | |
108 *eip++ = PREFIX16; | |
109 } | |
110 *eip++ = load; | |
111 pos -= 0x10000L; | |
112 } | |
113 if ( bpp == 2 ) { | |
114 *eip++ = PREFIX16; | |
115 } | |
116 *eip++ = store; | |
117 pos += inc; | |
118 } | |
119 *eip++ = RETURN; | |
120 | |
121 /* Verify that we didn't overflow (too late) */ | |
122 if ( eip > (copy_row+sizeof(copy_row)) ) { | |
123 SDL_SetError("Copy buffer overflow"); | |
124 return(-1); | |
125 } | |
126 return(0); | |
127 } | |
128 | |
129 #else | |
130 | |
131 #define DEFINE_COPY_ROW(name, type) \ | |
132 void name(type *src, int src_w, type *dst, int dst_w) \ | |
133 { \ | |
134 int i; \ | |
135 int pos, inc; \ | |
136 type pixel = 0; \ | |
137 \ | |
138 pos = 0x10000; \ | |
139 inc = (src_w << 16) / dst_w; \ | |
140 for ( i=dst_w; i>0; --i ) { \ | |
141 while ( pos >= 0x10000L ) { \ | |
142 pixel = *src++; \ | |
143 pos -= 0x10000L; \ | |
144 } \ | |
145 *dst++ = pixel; \ | |
146 pos += inc; \ | |
147 } \ | |
148 } | |
149 DEFINE_COPY_ROW(copy_row1, Uint8) | |
150 DEFINE_COPY_ROW(copy_row2, Uint16) | |
151 DEFINE_COPY_ROW(copy_row4, Uint32) | |
152 | |
153 #endif /* USE_ASM_STRETCH */ | |
154 | |
155 /* The ASM code doesn't handle 24-bpp stretch blits */ | |
156 void copy_row3(Uint8 *src, int src_w, Uint8 *dst, int dst_w) | |
157 { | |
158 int i; | |
159 int pos, inc; | |
160 Uint8 pixel[3]; | |
161 | |
162 pos = 0x10000; | |
163 inc = (src_w << 16) / dst_w; | |
164 for ( i=dst_w; i>0; --i ) { | |
165 while ( pos >= 0x10000L ) { | |
166 pixel[0] = *src++; | |
167 pixel[1] = *src++; | |
168 pixel[2] = *src++; | |
169 pos -= 0x10000L; | |
170 } | |
171 *dst++ = pixel[0]; | |
172 *dst++ = pixel[1]; | |
173 *dst++ = pixel[2]; | |
174 pos += inc; | |
175 } | |
176 } | |
177 | |
178 /* Perform a stretch blit between two surfaces of the same format. | |
179 NOTE: This function is not safe to call from multiple threads! | |
180 */ | |
181 int SDL_SoftStretch(SDL_Surface *src, SDL_Rect *srcrect, | |
182 SDL_Surface *dst, SDL_Rect *dstrect) | |
183 { | |
894
1d1a823904d8
Don't crash if the stretch routines are used on hardware surfaces
Sam Lantinga <slouken@libsdl.org>
parents:
769
diff
changeset
|
184 int src_locked; |
1d1a823904d8
Don't crash if the stretch routines are used on hardware surfaces
Sam Lantinga <slouken@libsdl.org>
parents:
769
diff
changeset
|
185 int dst_locked; |
0 | 186 int pos, inc; |
187 int dst_width; | |
188 int dst_maxrow; | |
189 int src_row, dst_row; | |
190 Uint8 *srcp = NULL; | |
191 Uint8 *dstp; | |
192 SDL_Rect full_src; | |
193 SDL_Rect full_dst; | |
194 #if defined(USE_ASM_STRETCH) && defined(__GNUC__) | |
195 int u1, u2; | |
196 #endif | |
197 const int bpp = dst->format->BytesPerPixel; | |
198 | |
199 if ( src->format->BitsPerPixel != dst->format->BitsPerPixel ) { | |
200 SDL_SetError("Only works with same format surfaces"); | |
201 return(-1); | |
202 } | |
203 | |
204 /* Verify the blit rectangles */ | |
205 if ( srcrect ) { | |
206 if ( (srcrect->x < 0) || (srcrect->y < 0) || | |
207 ((srcrect->x+srcrect->w) > src->w) || | |
208 ((srcrect->y+srcrect->h) > src->h) ) { | |
209 SDL_SetError("Invalid source blit rectangle"); | |
210 return(-1); | |
211 } | |
212 } else { | |
213 full_src.x = 0; | |
214 full_src.y = 0; | |
215 full_src.w = src->w; | |
216 full_src.h = src->h; | |
217 srcrect = &full_src; | |
218 } | |
219 if ( dstrect ) { | |
220 if ( (dstrect->x < 0) || (dstrect->y < 0) || | |
221 ((dstrect->x+dstrect->w) > dst->w) || | |
222 ((dstrect->y+dstrect->h) > dst->h) ) { | |
223 SDL_SetError("Invalid destination blit rectangle"); | |
224 return(-1); | |
225 } | |
226 } else { | |
227 full_dst.x = 0; | |
228 full_dst.y = 0; | |
229 full_dst.w = dst->w; | |
230 full_dst.h = dst->h; | |
231 dstrect = &full_dst; | |
232 } | |
233 | |
894
1d1a823904d8
Don't crash if the stretch routines are used on hardware surfaces
Sam Lantinga <slouken@libsdl.org>
parents:
769
diff
changeset
|
234 /* Lock the destination if it's in hardware */ |
1d1a823904d8
Don't crash if the stretch routines are used on hardware surfaces
Sam Lantinga <slouken@libsdl.org>
parents:
769
diff
changeset
|
235 dst_locked = 0; |
1d1a823904d8
Don't crash if the stretch routines are used on hardware surfaces
Sam Lantinga <slouken@libsdl.org>
parents:
769
diff
changeset
|
236 if ( SDL_MUSTLOCK(dst) ) { |
1d1a823904d8
Don't crash if the stretch routines are used on hardware surfaces
Sam Lantinga <slouken@libsdl.org>
parents:
769
diff
changeset
|
237 if ( SDL_LockSurface(dst) < 0 ) { |
1d1a823904d8
Don't crash if the stretch routines are used on hardware surfaces
Sam Lantinga <slouken@libsdl.org>
parents:
769
diff
changeset
|
238 SDL_SetError("Unable to lock destination surface"); |
1d1a823904d8
Don't crash if the stretch routines are used on hardware surfaces
Sam Lantinga <slouken@libsdl.org>
parents:
769
diff
changeset
|
239 return(-1); |
1d1a823904d8
Don't crash if the stretch routines are used on hardware surfaces
Sam Lantinga <slouken@libsdl.org>
parents:
769
diff
changeset
|
240 } |
1d1a823904d8
Don't crash if the stretch routines are used on hardware surfaces
Sam Lantinga <slouken@libsdl.org>
parents:
769
diff
changeset
|
241 dst_locked = 1; |
1d1a823904d8
Don't crash if the stretch routines are used on hardware surfaces
Sam Lantinga <slouken@libsdl.org>
parents:
769
diff
changeset
|
242 } |
1d1a823904d8
Don't crash if the stretch routines are used on hardware surfaces
Sam Lantinga <slouken@libsdl.org>
parents:
769
diff
changeset
|
243 /* Lock the source if it's in hardware */ |
1d1a823904d8
Don't crash if the stretch routines are used on hardware surfaces
Sam Lantinga <slouken@libsdl.org>
parents:
769
diff
changeset
|
244 src_locked = 0; |
1d1a823904d8
Don't crash if the stretch routines are used on hardware surfaces
Sam Lantinga <slouken@libsdl.org>
parents:
769
diff
changeset
|
245 if ( SDL_MUSTLOCK(src) ) { |
1d1a823904d8
Don't crash if the stretch routines are used on hardware surfaces
Sam Lantinga <slouken@libsdl.org>
parents:
769
diff
changeset
|
246 if ( SDL_LockSurface(src) < 0 ) { |
1d1a823904d8
Don't crash if the stretch routines are used on hardware surfaces
Sam Lantinga <slouken@libsdl.org>
parents:
769
diff
changeset
|
247 if ( dst_locked ) { |
1d1a823904d8
Don't crash if the stretch routines are used on hardware surfaces
Sam Lantinga <slouken@libsdl.org>
parents:
769
diff
changeset
|
248 SDL_UnlockSurface(dst); |
1d1a823904d8
Don't crash if the stretch routines are used on hardware surfaces
Sam Lantinga <slouken@libsdl.org>
parents:
769
diff
changeset
|
249 } |
1d1a823904d8
Don't crash if the stretch routines are used on hardware surfaces
Sam Lantinga <slouken@libsdl.org>
parents:
769
diff
changeset
|
250 SDL_SetError("Unable to lock source surface"); |
1d1a823904d8
Don't crash if the stretch routines are used on hardware surfaces
Sam Lantinga <slouken@libsdl.org>
parents:
769
diff
changeset
|
251 return(-1); |
1d1a823904d8
Don't crash if the stretch routines are used on hardware surfaces
Sam Lantinga <slouken@libsdl.org>
parents:
769
diff
changeset
|
252 } |
1d1a823904d8
Don't crash if the stretch routines are used on hardware surfaces
Sam Lantinga <slouken@libsdl.org>
parents:
769
diff
changeset
|
253 src_locked = 1; |
1d1a823904d8
Don't crash if the stretch routines are used on hardware surfaces
Sam Lantinga <slouken@libsdl.org>
parents:
769
diff
changeset
|
254 } |
1d1a823904d8
Don't crash if the stretch routines are used on hardware surfaces
Sam Lantinga <slouken@libsdl.org>
parents:
769
diff
changeset
|
255 |
0 | 256 /* Set up the data... */ |
257 pos = 0x10000; | |
258 inc = (srcrect->h << 16) / dstrect->h; | |
259 src_row = srcrect->y; | |
260 dst_row = dstrect->y; | |
261 dst_width = dstrect->w*bpp; | |
262 | |
263 #ifdef USE_ASM_STRETCH | |
264 /* Write the opcodes for this stretch */ | |
265 if ( (bpp != 3) && | |
266 (generate_rowbytes(srcrect->w, dstrect->w, bpp) < 0) ) { | |
267 return(-1); | |
268 } | |
269 #endif | |
270 | |
271 /* Perform the stretch blit */ | |
272 for ( dst_maxrow = dst_row+dstrect->h; dst_row<dst_maxrow; ++dst_row ) { | |
273 dstp = (Uint8 *)dst->pixels + (dst_row*dst->pitch) | |
274 + (dstrect->x*bpp); | |
275 while ( pos >= 0x10000L ) { | |
276 srcp = (Uint8 *)src->pixels + (src_row*src->pitch) | |
277 + (srcrect->x*bpp); | |
278 ++src_row; | |
279 pos -= 0x10000L; | |
280 } | |
281 #ifdef USE_ASM_STRETCH | |
282 switch (bpp) { | |
283 case 3: | |
284 copy_row3(srcp, srcrect->w, dstp, dstrect->w); | |
285 break; | |
286 default: | |
287 #ifdef __GNUC__ | |
627
8b9ac38381d0
Fixed compile problem in SDL_stretch.c with gcc 3.3
Sam Lantinga <slouken@libsdl.org>
parents:
297
diff
changeset
|
288 __asm__ __volatile__ ( |
8b9ac38381d0
Fixed compile problem in SDL_stretch.c with gcc 3.3
Sam Lantinga <slouken@libsdl.org>
parents:
297
diff
changeset
|
289 "call _copy_row" |
0 | 290 : "=&D" (u1), "=&S" (u2) |
291 : "0" (dstp), "1" (srcp) | |
292 : "memory" ); | |
293 #else | |
294 #ifdef WIN32 | |
295 { void *code = ©_row; | |
296 __asm { | |
297 push edi | |
298 push esi | |
299 | |
300 mov edi, dstp | |
301 mov esi, srcp | |
302 call dword ptr code | |
303 | |
304 pop esi | |
305 pop edi | |
306 } | |
307 } | |
308 #else | |
309 #error Need inline assembly for this compiler | |
310 #endif | |
311 #endif /* __GNUC__ */ | |
312 break; | |
313 } | |
314 #else | |
315 switch (bpp) { | |
316 case 1: | |
317 copy_row1(srcp, srcrect->w, dstp, dstrect->w); | |
318 break; | |
319 case 2: | |
320 copy_row2((Uint16 *)srcp, srcrect->w, | |
321 (Uint16 *)dstp, dstrect->w); | |
322 break; | |
323 case 3: | |
324 copy_row3(srcp, srcrect->w, dstp, dstrect->w); | |
325 break; | |
326 case 4: | |
327 copy_row4((Uint32 *)srcp, srcrect->w, | |
328 (Uint32 *)dstp, dstrect->w); | |
329 break; | |
330 } | |
331 #endif | |
332 pos += inc; | |
333 } | |
894
1d1a823904d8
Don't crash if the stretch routines are used on hardware surfaces
Sam Lantinga <slouken@libsdl.org>
parents:
769
diff
changeset
|
334 |
1d1a823904d8
Don't crash if the stretch routines are used on hardware surfaces
Sam Lantinga <slouken@libsdl.org>
parents:
769
diff
changeset
|
335 /* We need to unlock the surfaces if they're locked */ |
1d1a823904d8
Don't crash if the stretch routines are used on hardware surfaces
Sam Lantinga <slouken@libsdl.org>
parents:
769
diff
changeset
|
336 if ( dst_locked ) { |
1d1a823904d8
Don't crash if the stretch routines are used on hardware surfaces
Sam Lantinga <slouken@libsdl.org>
parents:
769
diff
changeset
|
337 SDL_UnlockSurface(dst); |
1d1a823904d8
Don't crash if the stretch routines are used on hardware surfaces
Sam Lantinga <slouken@libsdl.org>
parents:
769
diff
changeset
|
338 } |
1d1a823904d8
Don't crash if the stretch routines are used on hardware surfaces
Sam Lantinga <slouken@libsdl.org>
parents:
769
diff
changeset
|
339 if ( src_locked ) { |
1d1a823904d8
Don't crash if the stretch routines are used on hardware surfaces
Sam Lantinga <slouken@libsdl.org>
parents:
769
diff
changeset
|
340 SDL_UnlockSurface(src); |
1d1a823904d8
Don't crash if the stretch routines are used on hardware surfaces
Sam Lantinga <slouken@libsdl.org>
parents:
769
diff
changeset
|
341 } |
0 | 342 return(0); |
343 } | |
344 |