diff options
author | Franklin Wei <git@fwei.tk> | 2018-02-07 20:04:46 -0500 |
---|---|---|
committer | Franklin Wei <git@fwei.tk> | 2018-03-12 20:52:01 -0400 |
commit | 6039eb05ba6d82ef56f2868c96654c552d117bf9 (patch) | |
tree | 9db7016bcbf66cfdf7b9bc998d84c6eaff9c8378 /apps/plugins/sdl/src/video/macdsp | |
parent | ef373c03b96b0be08babca581d9f10bccfd4931f (diff) | |
download | rockbox-6039eb05ba6d82ef56f2868c96654c552d117bf9.tar.gz rockbox-6039eb05ba6d82ef56f2868c96654c552d117bf9.zip |
sdl: remove non-rockbox drivers
We never use any of these other drivers, so having them around just takes
up space.
Change-Id: Iced812162df1fef3fd55522b7e700acb6c3bcd41
Diffstat (limited to 'apps/plugins/sdl/src/video/macdsp')
-rw-r--r-- | apps/plugins/sdl/src/video/macdsp/SDL_dspvideo.c | 1422 | ||||
-rw-r--r-- | apps/plugins/sdl/src/video/macdsp/SDL_dspvideo.h | 54 |
2 files changed, 0 insertions, 1476 deletions
diff --git a/apps/plugins/sdl/src/video/macdsp/SDL_dspvideo.c b/apps/plugins/sdl/src/video/macdsp/SDL_dspvideo.c deleted file mode 100644 index aa31127669..0000000000 --- a/apps/plugins/sdl/src/video/macdsp/SDL_dspvideo.c +++ /dev/null | |||
@@ -1,1422 +0,0 @@ | |||
1 | /* | ||
2 | SDL - Simple DirectMedia Layer | ||
3 | Copyright (C) 1997-2012 Sam Lantinga | ||
4 | |||
5 | This library is free software; you can redistribute it and/or | ||
6 | modify it under the terms of the GNU Lesser General Public | ||
7 | License as published by the Free Software Foundation; either | ||
8 | version 2.1 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 | Lesser General Public License for more details. | ||
14 | |||
15 | You should have received a copy of the GNU Lesser General Public | ||
16 | License along with this library; if not, write to the Free Software | ||
17 | Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA | ||
18 | |||
19 | Sam Lantinga | ||
20 | slouken@libsdl.org | ||
21 | */ | ||
22 | #include "SDL_config.h" | ||
23 | |||
24 | /* | ||
25 | Written by Darrell Walisser <dwaliss1@purdue.edu> | ||
26 | |||
27 | Implementation notes ---------------------------------------------------------------------- | ||
28 | |||
29 | A bit on GWorlds in VRAM from technote 1182: | ||
30 | |||
31 | There are two important things to note about GWorld's allocated in | ||
32 | VRAM. First, the base address retrieved through GetPixBaseAddr or | ||
33 | read directly from the PixMap structure can become invalid anytime | ||
34 | memory is allocated in VRAM. This can occur either by explicit | ||
35 | allocations, such as calls to NewGWorld, or by implicit ones, such as | ||
36 | those associated with the internal texture allocation of OpenGL. The | ||
37 | stored pixel images themselves will still be valid but may have been | ||
38 | moved in VRAM, thus rendering any stored base addresses invalid. | ||
39 | You should never store an image's base address for longer than is | ||
40 | necessary and especially never across calls to NewGWorld or | ||
41 | texture-creation routines. | ||
42 | |||
43 | Secondly, an offscreen pixel image allocated in VRAM can be | ||
44 | purged at system task time by the display driver. This means any | ||
45 | time your application yields time such by calling WaitNextEvent or | ||
46 | SystemTask you can lose your VRAM GWorld contents. While this | ||
47 | happens infrequently, usually associated with display resolution or | ||
48 | pixel depth changes you must code for this eventuality. This purge | ||
49 | can occur whether or not the GWorld is locked or not. A return value | ||
50 | of false from LockPixels, a NULL return value from GetPixBaseAddr | ||
51 | or NULL in the baseAddr field of the PixMap mean that the pixel | ||
52 | image has been purged. To reallocate it you can either call | ||
53 | UpdateGWorld or Dispose your current GWorld through | ||
54 | DisposeGWorld and reallocate it via NewGWorld. Either way you must | ||
55 | then rebuild the pixel image. | ||
56 | |||
57 | ------------------------------------------------------------------------------------ | ||
58 | |||
59 | Currently, I don't account for (1). In my testing, NewGWorld never invalidated | ||
60 | other existing GWorlds in VRAM. However, I do have protection for (2). | ||
61 | Namely, I am using GetOSEvent() instead of WaitNextEvent() so that there are no | ||
62 | context switches (the app hogs the CPU). Eventually a book-keeping system should | ||
63 | be coded to take care of (1) and (2). | ||
64 | |||
65 | ------------------------------------------------------------------------------------ | ||
66 | |||
67 | System requirements (* denotes optional): | ||
68 | |||
69 | 1. DrawSprocket 1.7.3 | ||
70 | 2. *MacOS 9 or later (but *not* Mac OS X) for hardware accelerated blit / fill | ||
71 | 3. *May also require certain graphics hardware for (2). I trust that all Apple OEM | ||
72 | hardware will work. Third party accelerators may work if they have QuickDraw | ||
73 | acceleration in the drivers and the drivers have been updated for OS 9. The current | ||
74 | Voodoo 3 drivers (1.0b12) do not work. | ||
75 | |||
76 | Coding suggestions: | ||
77 | |||
78 | 1. Use SDL_UpdateRects ! | ||
79 | |||
80 | If no QuickDraw acceleration is present, double-buffered surfaces will use a back buffer | ||
81 | in System memory. I recommend you use SDL_UpdateRects with double-buffered surfaces | ||
82 | for best performance on these cards, since the overhead is nearly zero for VRAM back buffer. | ||
83 | |||
84 | 2. Load most-resident surfaces first. | ||
85 | |||
86 | If you fill up VRAM or AGP memory, there is no contingency for purging to make room for the next one. | ||
87 | Therefore, you should load the surfaces you plan to use the most frequently first. | ||
88 | Sooner or later, I will code LRU replacement to help this. | ||
89 | |||
90 | TODO: | ||
91 | Some kind of posterized mode for resolutions < 640x480. | ||
92 | Window support / fullscreen toggle. | ||
93 | Figure out how much VRAM is available. Put in video->info->video_mem. | ||
94 | Track VRAM usage. | ||
95 | |||
96 | BUGS: | ||
97 | I can't create a hardware surface the same size as the screen?! How to fix? | ||
98 | |||
99 | |||
100 | |||
101 | COMPILE OPTIONS: | ||
102 | |||
103 | DSP_TRY_CC_AND_AA - Define if you want to try HWA color-key and alpha blitters | ||
104 | HW color-key blitting gives substantial improvements, | ||
105 | but hw alpha is neck-and-neck with SDL's soft bitter. | ||
106 | |||
107 | DSP_NO_SYNC_VBL - Define for HWA double-buffered surfaces: don't sync | ||
108 | pseudo-flip to monitor redraw. | ||
109 | |||
110 | DSP_NO_SYNC_OPENGL - Define for OpenGL surfaces: don't sync buffer swap. Synching buffer | ||
111 | swap may result in reduced performance, but can eliminate some | ||
112 | tearing artifacts. | ||
113 | CHANGELOG: | ||
114 | 09/17/00 Lots of little tweaks. Build modelist in reverse order so largest contexts | ||
115 | list first. Compared various methods with ROM methods and fixed rez switch | ||
116 | crashing bug in GL Tron. (Woohoo!) | ||
117 | */ | ||
118 | |||
119 | #define DSP_TRY_CC_AND_AA | ||
120 | |||
121 | /* #define DSP_NO_SYNC_VBL */ | ||
122 | |||
123 | #define DSP_NO_SYNC_OPENGL | ||
124 | |||
125 | |||
126 | #if defined(__APPLE__) && defined(__MACH__) | ||
127 | #include <Carbon/Carbon.h> | ||
128 | #include <DrawSprocket/DrawSprocket.h> | ||
129 | #elif TARGET_API_MAC_CARBON && (UNIVERSAL_INTERFACES_VERSION > 0x0335) | ||
130 | #include <Carbon.h> | ||
131 | #include <DrawSprocket.h> | ||
132 | #else | ||
133 | #include <LowMem.h> | ||
134 | #include <Gestalt.h> | ||
135 | #include <Devices.h> | ||
136 | #include <DiskInit.h> | ||
137 | #include <QDOffscreen.h> | ||
138 | #include <DrawSprocket.h> | ||
139 | #endif | ||
140 | |||
141 | #include "SDL_video.h" | ||
142 | #include "SDL_syswm.h" | ||
143 | #include "../SDL_sysvideo.h" | ||
144 | #include "../SDL_blit.h" | ||
145 | #include "../SDL_pixels_c.h" | ||
146 | #include "SDL_dspvideo.h" | ||
147 | #include "../maccommon/SDL_macgl_c.h" | ||
148 | #include "../maccommon/SDL_macwm_c.h" | ||
149 | #include "../maccommon/SDL_macmouse_c.h" | ||
150 | #include "../maccommon/SDL_macevents_c.h" | ||
151 | |||
152 | /* Initialization/Query functions */ | ||
153 | static int DSp_VideoInit(_THIS, SDL_PixelFormat *vformat); | ||
154 | static SDL_Rect **DSp_ListModes(_THIS, SDL_PixelFormat *format, Uint32 flags); | ||
155 | static SDL_Surface *DSp_SetVideoMode(_THIS, SDL_Surface *current, int width, int height, int bpp, Uint32 flags); | ||
156 | static int DSp_SetColors(_THIS, int firstcolor, int ncolors, | ||
157 | SDL_Color *colors); | ||
158 | static int DSp_CreatePalette(_THIS); | ||
159 | static int DSp_DestroyPalette(_THIS); | ||
160 | static void DSp_VideoQuit(_THIS); | ||
161 | |||
162 | static int DSp_GetMainDevice (_THIS, GDHandle *device); | ||
163 | static void DSp_IsHWAvailable (_THIS, SDL_PixelFormat *vformat); | ||
164 | static void DSp_DSpUpdate(_THIS, int numrects, SDL_Rect *sdl_rects); | ||
165 | static void DSp_DirectUpdate(_THIS, int numrects, SDL_Rect *sdl_rects); | ||
166 | |||
167 | /* Hardware surface functions */ | ||
168 | static int DSp_SetHWAlpha(_THIS, SDL_Surface *surface, UInt8 alpha); | ||
169 | static int DSp_SetHWColorKey(_THIS, SDL_Surface *surface, Uint32 key); | ||
170 | static int DSp_NewHWSurface(_THIS, CGrafPtr *port, int depth, int width, int height); | ||
171 | static int DSp_AllocHWSurface(_THIS, SDL_Surface *surface); | ||
172 | static int DSp_LockHWSurface(_THIS, SDL_Surface *surface); | ||
173 | static void DSp_UnlockHWSurface(_THIS, SDL_Surface *surface); | ||
174 | static void DSp_FreeHWSurface(_THIS, SDL_Surface *surface); | ||
175 | static int DSp_FlipHWSurface(_THIS, SDL_Surface *surface); | ||
176 | static int DSp_CheckHWBlit(_THIS, SDL_Surface *src, SDL_Surface *dest); | ||
177 | static int DSp_HWAccelBlit(SDL_Surface *src, SDL_Rect *srcrect, | ||
178 | SDL_Surface *dst, SDL_Rect *dstrect); | ||
179 | static int DSp_FillHWRect(_THIS, SDL_Surface *dst, SDL_Rect *rect, Uint32 color); | ||
180 | |||
181 | #if SDL_VIDEO_OPENGL | ||
182 | static void DSp_GL_SwapBuffers (_THIS); | ||
183 | #endif | ||
184 | |||
185 | #if ! TARGET_API_MAC_CARBON | ||
186 | |||
187 | #define GetPortPixRowBytes(x) ( (*(x->portPixMap))->rowBytes ) | ||
188 | #define GetGDevPixMap(x) ((**(x)).gdPMap) | ||
189 | #define GetPortPixMap(x) ((*(x)).portPixMap) | ||
190 | |||
191 | #define GetPixDepth(y) ((**(y)).pixelSize) | ||
192 | //#define GetPixRowBytes(y) ((**(y)).rowBytes) | ||
193 | //#define GetPixBaseAddr(y) ((**(y)).baseAddr) | ||
194 | #define GetPixCTab(y) ((**(y)).pmTable) | ||
195 | #define GetPortBitMapForCopyBits(x) (&(((GrafPtr)(x))->portBits)) | ||
196 | |||
197 | #else | ||
198 | #define GetPortPixRowBytes(x) (GetPixRowBytes(GetPortPixMap(x)) ) | ||
199 | #define GetGDevPixMap(x) ((**(x)).gdPMap) | ||
200 | |||
201 | #endif | ||
202 | |||
203 | typedef struct private_hwdata { | ||
204 | |||
205 | GWorldPtr offscreen; // offscreen gworld in VRAM or AGP | ||
206 | |||
207 | #ifdef DSP_TRY_CC_AND_AA | ||
208 | GWorldPtr mask; // transparent mask | ||
209 | RGBColor alpha; // alpha color | ||
210 | RGBColor trans; // transparent color | ||
211 | #endif | ||
212 | |||
213 | } private_hwdata; | ||
214 | |||
215 | typedef private_hwdata private_swdata ; /* have same fields */ | ||
216 | |||
217 | /* Macintosh toolbox driver bootstrap functions */ | ||
218 | |||
219 | static int DSp_Available(void) | ||
220 | { | ||
221 | /* Check for DrawSprocket */ | ||
222 | #if ! TARGET_API_MAC_OSX | ||
223 | /* This check is only meaningful if you weak-link DrawSprocketLib */ | ||
224 | return ((Ptr)DSpStartup != (Ptr)kUnresolvedCFragSymbolAddress); | ||
225 | #else | ||
226 | return 1; // DrawSprocket.framework doesn't have it all, but it's there | ||
227 | #endif | ||
228 | } | ||
229 | |||
230 | static void DSp_DeleteDevice(SDL_VideoDevice *device) | ||
231 | { | ||
232 | /* -dw- taking no chances with null pointers */ | ||
233 | if (device) { | ||
234 | |||
235 | if (device->hidden) { | ||
236 | |||
237 | if (device->hidden->dspinfo) | ||
238 | SDL_free(device->hidden->dspinfo); | ||
239 | |||
240 | SDL_free(device->hidden); | ||
241 | } | ||
242 | SDL_free(device); | ||
243 | } | ||
244 | } | ||
245 | |||
246 | static SDL_VideoDevice *DSp_CreateDevice(int devindex) | ||
247 | { | ||
248 | SDL_VideoDevice *device; | ||
249 | |||
250 | /* Initialize all variables that we clean on shutdown */ | ||
251 | device = (SDL_VideoDevice *)SDL_malloc(sizeof(SDL_VideoDevice)); | ||
252 | if ( device ) { | ||
253 | SDL_memset(device, 0, sizeof (*device)); | ||
254 | device->hidden = (struct SDL_PrivateVideoData *) | ||
255 | SDL_malloc((sizeof *device->hidden)); | ||
256 | if (device->hidden) | ||
257 | SDL_memset(device->hidden, 0, sizeof ( *(device->hidden) ) ); | ||
258 | } | ||
259 | if ( (device == NULL) || (device->hidden == NULL) ) { | ||
260 | SDL_OutOfMemory(); | ||
261 | |||
262 | if ( device ) { | ||
263 | |||
264 | if (device->hidden) | ||
265 | SDL_free(device->hidden); | ||
266 | |||
267 | SDL_free(device); | ||
268 | } | ||
269 | |||
270 | return(NULL); | ||
271 | } | ||
272 | |||
273 | /* Allocate DrawSprocket information */ | ||
274 | device->hidden->dspinfo = (struct DSpInfo *)SDL_malloc( | ||
275 | (sizeof *device->hidden->dspinfo)); | ||
276 | if ( device->hidden->dspinfo == NULL ) { | ||
277 | SDL_OutOfMemory(); | ||
278 | SDL_free(device->hidden); | ||
279 | SDL_free(device); | ||
280 | return(0); | ||
281 | } | ||
282 | SDL_memset(device->hidden->dspinfo, 0, (sizeof *device->hidden->dspinfo)); | ||
283 | |||
284 | /* Set the function pointers */ | ||
285 | device->VideoInit = DSp_VideoInit; | ||
286 | device->ListModes = DSp_ListModes; | ||
287 | device->SetVideoMode = DSp_SetVideoMode; | ||
288 | device->SetColors = DSp_SetColors; | ||
289 | device->UpdateRects = NULL; | ||
290 | device->VideoQuit = DSp_VideoQuit; | ||
291 | device->AllocHWSurface = DSp_AllocHWSurface; | ||
292 | device->CheckHWBlit = NULL; | ||
293 | device->FillHWRect = NULL; | ||
294 | device->SetHWColorKey = NULL; | ||
295 | device->SetHWAlpha = NULL; | ||
296 | device->LockHWSurface = DSp_LockHWSurface; | ||
297 | device->UnlockHWSurface = DSp_UnlockHWSurface; | ||
298 | device->FlipHWSurface = DSp_FlipHWSurface; | ||
299 | device->FreeHWSurface = DSp_FreeHWSurface; | ||
300 | #if SDL_MACCLASSIC_GAMMA_SUPPORT | ||
301 | device->SetGammaRamp = Mac_SetGammaRamp; | ||
302 | device->GetGammaRamp = Mac_GetGammaRamp; | ||
303 | #endif | ||
304 | #if SDL_VIDEO_OPENGL | ||
305 | device->GL_MakeCurrent = Mac_GL_MakeCurrent; | ||
306 | device->GL_SwapBuffers = DSp_GL_SwapBuffers; | ||
307 | device->GL_LoadLibrary = Mac_GL_LoadLibrary; | ||
308 | device->GL_GetProcAddress = Mac_GL_GetProcAddress; | ||
309 | #endif | ||
310 | device->SetCaption = NULL; | ||
311 | device->SetIcon = NULL; | ||
312 | device->IconifyWindow = NULL; | ||
313 | device->GrabInput = NULL; | ||
314 | device->GetWMInfo = NULL; | ||
315 | device->FreeWMCursor = Mac_FreeWMCursor; | ||
316 | device->CreateWMCursor = Mac_CreateWMCursor; | ||
317 | device->ShowWMCursor = Mac_ShowWMCursor; | ||
318 | device->WarpWMCursor = Mac_WarpWMCursor; | ||
319 | device->InitOSKeymap = Mac_InitOSKeymap; | ||
320 | device->PumpEvents = Mac_PumpEvents; | ||
321 | |||
322 | device->GrabInput = NULL; | ||
323 | device->CheckMouseMode = NULL; | ||
324 | |||
325 | device->free = DSp_DeleteDevice; | ||
326 | |||
327 | return device; | ||
328 | } | ||
329 | |||
330 | VideoBootStrap DSp_bootstrap = { | ||
331 | "DSp", "MacOS DrawSprocket", | ||
332 | DSp_Available, DSp_CreateDevice | ||
333 | }; | ||
334 | |||
335 | /* Use DSp/Display Manager to build mode list for given screen */ | ||
336 | static SDL_Rect** DSp_BuildModeList (const GDHandle gDevice, int *displayWidth, int *displayHeight) | ||
337 | { | ||
338 | DSpContextAttributes attributes; | ||
339 | DSpContextReference context; | ||
340 | DisplayIDType displayID; | ||
341 | SDL_Rect temp_list [16]; | ||
342 | SDL_Rect **mode_list; | ||
343 | int width, height, i, j; | ||
344 | |||
345 | #if TARGET_API_MAC_OSX | ||
346 | |||
347 | displayID = 0; | ||
348 | |||
349 | #else | ||
350 | /* Ask Display Manager for integer id of screen device */ | ||
351 | if ( DMGetDisplayIDByGDevice (gDevice, &displayID, SDL_TRUE) != noErr ) { | ||
352 | return NULL; | ||
353 | } | ||
354 | #endif | ||
355 | /* Get the first possible DSp context on this device */ | ||
356 | if ( DSpGetFirstContext (displayID, &context) != noErr ) { | ||
357 | return NULL; | ||
358 | } | ||
359 | |||
360 | if ( DSpContext_GetAttributes (context, &attributes) != noErr ) | ||
361 | return NULL; | ||
362 | |||
363 | *displayWidth = attributes.displayWidth; | ||
364 | *displayHeight = attributes.displayHeight; | ||
365 | |||
366 | for ( i = 0; i < SDL_arraysize(temp_list); i++ ) { | ||
367 | width = attributes.displayWidth; | ||
368 | height = attributes.displayHeight; | ||
369 | |||
370 | temp_list [i].x = 0 | attributes.displayBestDepth; | ||
371 | temp_list [i].y = 0; | ||
372 | temp_list [i].w = width; | ||
373 | temp_list [i].h = height; | ||
374 | |||
375 | /* DSp will report many different contexts with the same width and height. */ | ||
376 | /* They will differ in bit depth and refresh rate. */ | ||
377 | /* We will ignore them until we reach one with a different width/height */ | ||
378 | /* When there are no more contexts to look at, we will quit building the list*/ | ||
379 | while ( width == attributes.displayWidth && height == attributes.displayHeight ) { | ||
380 | |||
381 | OSStatus err = DSpGetNextContext (context, &context); | ||
382 | if (err != noErr) | ||
383 | if (err == kDSpContextNotFoundErr) | ||
384 | goto done; | ||
385 | else | ||
386 | return NULL; | ||
387 | |||
388 | if ( DSpContext_GetAttributes (context, &attributes) != noErr ) | ||
389 | return NULL; | ||
390 | |||
391 | temp_list [i].x |= attributes.displayBestDepth; | ||
392 | } | ||
393 | } | ||
394 | done: | ||
395 | i++; /* i was not incremented before kicking out of the loop */ | ||
396 | |||
397 | mode_list = (SDL_Rect**) SDL_malloc (sizeof (SDL_Rect*) * (i+1)); | ||
398 | if (mode_list) { | ||
399 | |||
400 | /* -dw- new stuff: build in reverse order so largest sizes list first */ | ||
401 | for (j = i-1; j >= 0; j--) { | ||
402 | mode_list [j] = (SDL_Rect*) SDL_malloc (sizeof (SDL_Rect)); | ||
403 | if (mode_list [j]) | ||
404 | SDL_memcpy (mode_list [j], &(temp_list [j]), sizeof (SDL_Rect)); | ||
405 | else { | ||
406 | SDL_OutOfMemory (); | ||
407 | return NULL; | ||
408 | } | ||
409 | } | ||
410 | mode_list [i] = NULL; /* append null to the end */ | ||
411 | } | ||
412 | else { | ||
413 | SDL_OutOfMemory (); | ||
414 | return NULL; | ||
415 | } | ||
416 | |||
417 | return mode_list; | ||
418 | } | ||
419 | |||
420 | static void DSp_IsHWAvailable (_THIS, SDL_PixelFormat *vformat) | ||
421 | { | ||
422 | /* | ||
423 | VRAM GWorlds are only available on OS 9 or later. | ||
424 | Even with OS 9, some display drivers won't support it, | ||
425 | so we create a test GWorld and check for errors. | ||
426 | */ | ||
427 | |||
428 | long versionSystem; | ||
429 | |||
430 | dsp_vram_available = SDL_FALSE; | ||
431 | dsp_agp_available = SDL_FALSE; | ||
432 | |||
433 | Gestalt ('sysv', &versionSystem); | ||
434 | if (0x00000860 < (versionSystem & 0x0000FFFF)) { | ||
435 | |||
436 | GWorldPtr offscreen; | ||
437 | OSStatus err; | ||
438 | Rect bounds; | ||
439 | |||
440 | SetRect (&bounds, 0, 0, 320, 240); | ||
441 | |||
442 | #if useDistantHdwrMem && useLocalHdwrMem | ||
443 | err = NewGWorld (&offscreen, vformat->BitsPerPixel, &bounds, NULL, SDL_Display, useDistantHdwrMem | noNewDevice); | ||
444 | if (err == noErr) { | ||
445 | dsp_vram_available = SDL_TRUE; | ||
446 | DisposeGWorld (offscreen); | ||
447 | } | ||
448 | |||
449 | err = NewGWorld (&offscreen, vformat->BitsPerPixel, &bounds, NULL, SDL_Display, useLocalHdwrMem | noNewDevice); | ||
450 | if (err == noErr) { | ||
451 | DisposeGWorld (offscreen); | ||
452 | dsp_agp_available = SDL_TRUE; | ||
453 | } | ||
454 | #endif | ||
455 | } | ||
456 | } | ||
457 | |||
458 | static int DSp_GetMainDevice (_THIS, GDHandle *device) | ||
459 | { | ||
460 | |||
461 | #if TARGET_API_MAC_OSX | ||
462 | /* DSpUserSelectContext not available on OS X */ | ||
463 | *device = GetMainDevice(); | ||
464 | return 0; | ||
465 | #else | ||
466 | |||
467 | DSpContextAttributes attrib; | ||
468 | DSpContextReference context; | ||
469 | DisplayIDType display_id; | ||
470 | GDHandle main_device; | ||
471 | GDHandle device_list; | ||
472 | |||
473 | device_list = GetDeviceList (); | ||
474 | main_device = GetMainDevice (); | ||
475 | |||
476 | /* Quick check to avoid slower method when only one display exists */ | ||
477 | if ( (**device_list).gdNextGD == NULL ) { | ||
478 | *device = main_device; | ||
479 | return 0; | ||
480 | } | ||
481 | |||
482 | SDL_memset (&attrib, 0, sizeof (DSpContextAttributes)); | ||
483 | |||
484 | /* These attributes are hopefully supported on all devices...*/ | ||
485 | attrib.displayWidth = 640; | ||
486 | attrib.displayHeight = 480; | ||
487 | attrib.displayBestDepth = 8; | ||
488 | attrib.backBufferBestDepth = 8; | ||
489 | attrib.displayDepthMask = kDSpDepthMask_All; | ||
490 | attrib.backBufferDepthMask = kDSpDepthMask_All; | ||
491 | attrib.colorNeeds = kDSpColorNeeds_Require; | ||
492 | attrib.pageCount = 1; | ||
493 | |||
494 | if (noErr != DMGetDisplayIDByGDevice (main_device, &display_id, SDL_FALSE)) { | ||
495 | SDL_SetError ("Display Manager couldn't associate GDevice with a Display ID"); | ||
496 | return (-1); | ||
497 | } | ||
498 | |||
499 | /* Put up dialog on main display to select which display to use */ | ||
500 | if (noErr != DSpUserSelectContext (&attrib, display_id, NULL, &context)) { | ||
501 | SDL_SetError ("DrawSprocket couldn't create a context"); | ||
502 | return (-1); | ||
503 | } | ||
504 | |||
505 | if (noErr != DSpContext_GetDisplayID (context, &display_id)) { | ||
506 | SDL_SetError ("DrawSprocket couldn't get display ID"); | ||
507 | return (-1); | ||
508 | } | ||
509 | |||
510 | if (noErr != DMGetGDeviceByDisplayID (display_id, &main_device, SDL_FALSE)) { | ||
511 | SDL_SetError ("Display Manager couldn't associate Display ID with GDevice"); | ||
512 | return (-1); | ||
513 | } | ||
514 | |||
515 | *device = main_device; | ||
516 | return (0); | ||
517 | #endif | ||
518 | } | ||
519 | |||
520 | static int DSp_VideoInit(_THIS, SDL_PixelFormat *vformat) | ||
521 | { | ||
522 | NumVersion dsp_version = { 0x01, 0x00, 0x00, 0x00 }; | ||
523 | |||
524 | #if UNIVERSAL_INTERFACES_VERSION > 0x0320 | ||
525 | dsp_version = DSpGetVersion (); | ||
526 | #endif | ||
527 | |||
528 | if ( (dsp_version.majorRev == 1 && dsp_version.minorAndBugRev < 0x73) || | ||
529 | (dsp_version.majorRev < 1) ) { | ||
530 | |||
531 | /* StandardAlert (kAlertStopAlert, "\pError!", | ||
532 | "\pI need DrawSprocket 1.7.3 or later!\n" | ||
533 | "You can find a newer version at http://www.apple.com/swupdates.", | ||
534 | NULL, NULL); | ||
535 | */ | ||
536 | SDL_SetError ("DrawSprocket version is too old. Need 1.7.3 or later."); | ||
537 | return (-1); | ||
538 | } | ||
539 | |||
540 | if ( DSpStartup () != noErr ) { | ||
541 | SDL_SetError ("DrawSprocket couldn't startup"); | ||
542 | return(-1); | ||
543 | } | ||
544 | |||
545 | /* Start DSpintosh events */ | ||
546 | Mac_InitEvents(this); | ||
547 | |||
548 | /* Get a handle to the main monitor, or choose one on multiple monitor setups */ | ||
549 | if ( DSp_GetMainDevice(this, &SDL_Display) < 0) | ||
550 | return (-1); | ||
551 | |||
552 | /* Determine pixel format */ | ||
553 | vformat->BitsPerPixel = GetPixDepth ( (**SDL_Display).gdPMap ); | ||
554 | dsp_old_depth = vformat->BitsPerPixel; | ||
555 | |||
556 | switch (vformat->BitsPerPixel) { | ||
557 | case 16: | ||
558 | vformat->Rmask = 0x00007c00; | ||
559 | vformat->Gmask = 0x000003e0; | ||
560 | vformat->Bmask = 0x0000001f; | ||
561 | break; | ||
562 | default: | ||
563 | break; | ||
564 | } | ||
565 | |||
566 | if ( DSp_CreatePalette (this) < 0 ) { | ||
567 | SDL_SetError ("Could not create palette"); | ||
568 | return (-1); | ||
569 | } | ||
570 | |||
571 | /* Get a list of available fullscreen modes */ | ||
572 | SDL_modelist = DSp_BuildModeList (SDL_Display, | ||
573 | &this->info.current_w, &this->info.current_h); | ||
574 | if (SDL_modelist == NULL) { | ||
575 | SDL_SetError ("DrawSprocket could not build a mode list"); | ||
576 | return (-1); | ||
577 | } | ||
578 | |||
579 | /* Check for VRAM and AGP GWorlds for HW Blitting */ | ||
580 | DSp_IsHWAvailable (this, vformat); | ||
581 | |||
582 | this->info.wm_available = 0; | ||
583 | |||
584 | if (dsp_vram_available || dsp_agp_available) { | ||
585 | |||
586 | this->info.hw_available = SDL_TRUE; | ||
587 | |||
588 | this->CheckHWBlit = DSp_CheckHWBlit; | ||
589 | this->info.blit_hw = SDL_TRUE; | ||
590 | |||
591 | this->FillHWRect = DSp_FillHWRect; | ||
592 | this->info.blit_fill = SDL_TRUE; | ||
593 | |||
594 | #ifdef DSP_TRY_CC_AND_AA | ||
595 | this->SetHWColorKey = DSp_SetHWColorKey; | ||
596 | this->info.blit_hw_CC = SDL_TRUE; | ||
597 | |||
598 | this->SetHWAlpha = DSp_SetHWAlpha; | ||
599 | this->info.blit_hw_A = SDL_TRUE; | ||
600 | #endif | ||
601 | |||
602 | } | ||
603 | |||
604 | return(0); | ||
605 | } | ||
606 | |||
607 | static SDL_Rect **DSp_ListModes(_THIS, SDL_PixelFormat *format, Uint32 flags) | ||
608 | { | ||
609 | static SDL_Rect *dsp_modes[16]; | ||
610 | int i = 0, j = 0; | ||
611 | |||
612 | if ( format->BitsPerPixel == 0 ) | ||
613 | return ( (SDL_Rect**) NULL ); | ||
614 | |||
615 | while (SDL_modelist[i] != NULL) { | ||
616 | |||
617 | if (SDL_modelist[i]->x & format->BitsPerPixel) { | ||
618 | dsp_modes[j] = SDL_modelist[i]; | ||
619 | j++; | ||
620 | } | ||
621 | i++; | ||
622 | } | ||
623 | |||
624 | dsp_modes[j] = NULL; | ||
625 | |||
626 | return dsp_modes; | ||
627 | } | ||
628 | |||
629 | /* Various screen update functions available */ | ||
630 | static void DSp_DirectUpdate(_THIS, int numrects, SDL_Rect *rects); | ||
631 | |||
632 | #if ! TARGET_API_MAC_OSX | ||
633 | |||
634 | static volatile unsigned int retrace_count = 0; /* -dw- need volatile because it updates asychronously */ | ||
635 | |||
636 | Boolean DSp_VBLProc ( DSpContextReference context, void *ref_con ) | ||
637 | { | ||
638 | retrace_count++; | ||
639 | |||
640 | return 1; /* Darrell, is this right? */ | ||
641 | } | ||
642 | |||
643 | static void DSp_SetHWError (OSStatus err, int is_agp) | ||
644 | { | ||
645 | char message[1024]; | ||
646 | const char *fmt, *mem; | ||
647 | |||
648 | if ( is_agp ) { | ||
649 | mem = "AGP Memory"; | ||
650 | } else { | ||
651 | mem = "VRAM"; | ||
652 | } | ||
653 | switch(err) { | ||
654 | case memFullErr: | ||
655 | fmt = "Hardware surface possible but not enough %s available"; | ||
656 | break; | ||
657 | case cDepthErr: | ||
658 | fmt = "Hardware surface possible but invalid color depth"; | ||
659 | break; | ||
660 | default: | ||
661 | fmt = "Hardware surface could not be allocated in %s - unknown error"; | ||
662 | break; | ||
663 | } | ||
664 | SDL_snprintf(message, SDL_arraysize(message), fmt, mem); | ||
665 | SDL_SetError(message); | ||
666 | } | ||
667 | #endif // TARGET_API_MAC_OSX | ||
668 | |||
669 | /* put up a dialog to verify display change */ | ||
670 | static int DSp_ConfirmSwitch () { | ||
671 | |||
672 | /* resource id's for dialog */ | ||
673 | const int rDialog = 1002; | ||
674 | const int bCancel = 1; | ||
675 | const int bOK = 2; | ||
676 | |||
677 | DialogPtr dialog; | ||
678 | OSStatus err; | ||
679 | SInt32 response; | ||
680 | DialogItemIndex item = 0; | ||
681 | GrafPtr savePort; | ||
682 | |||
683 | GetPort (&savePort); | ||
684 | |||
685 | dialog = GetNewDialog (rDialog, NULL, (WindowPtr) -1); | ||
686 | if (dialog == NULL) | ||
687 | return (0); | ||
688 | |||
689 | #if TARGET_API_MAC_CARBON | ||
690 | SetPort (GetDialogPort(dialog)); | ||
691 | #else | ||
692 | SetPort ((WindowPtr) dialog); | ||
693 | #endif | ||
694 | |||
695 | SetDialogDefaultItem (dialog, bCancel); | ||
696 | SetDialogCancelItem (dialog, bCancel); | ||
697 | |||
698 | SetEventMask (everyEvent); | ||
699 | FlushEvents (everyEvent, 0); | ||
700 | |||
701 | /* On MacOS 8.5 or later, we can make the dialog go away after 15 seconds */ | ||
702 | /* This is good since it's possible user can't even see the dialog! */ | ||
703 | /* Requires linking to DialogsLib */ | ||
704 | err = Gestalt(gestaltSystemVersion,&response); | ||
705 | if (err == noErr && response >= 0x00000850) { | ||
706 | SetDialogTimeout(dialog, bCancel, 15); | ||
707 | } | ||
708 | |||
709 | do { | ||
710 | |||
711 | ModalDialog ( NULL, &item ); | ||
712 | |||
713 | } while ( item != bCancel && item != bOK && err != noErr); | ||
714 | |||
715 | |||
716 | DisposeDialog (dialog); | ||
717 | SetPort (savePort); | ||
718 | |||
719 | SetEventMask(everyEvent - autoKeyMask); | ||
720 | FlushEvents(everyEvent, 0); | ||
721 | |||
722 | return (item - 1); | ||
723 | } | ||
724 | |||
725 | static void DSp_UnsetVideoMode(_THIS, SDL_Surface *current) | ||
726 | { | ||
727 | |||
728 | |||
729 | if ( current->flags & SDL_OPENGL ) { | ||
730 | Mac_GL_Quit (this); | ||
731 | } | ||
732 | |||
733 | if (dsp_context != NULL) { | ||
734 | |||
735 | GWorldPtr front; | ||
736 | DSpContext_GetFrontBuffer (dsp_context, &front); | ||
737 | |||
738 | if (front != dsp_back_buffer) | ||
739 | DisposeGWorld (dsp_back_buffer); | ||
740 | |||
741 | if (current->hwdata) | ||
742 | SDL_free(current->hwdata); | ||
743 | |||
744 | DSpContext_SetState (dsp_context, kDSpContextState_Inactive ); | ||
745 | DSpContext_Release (dsp_context); | ||
746 | |||
747 | dsp_context = NULL; | ||
748 | } | ||
749 | |||
750 | if (SDL_Window != NULL) { | ||
751 | DisposeWindow (SDL_Window); | ||
752 | SDL_Window = NULL; | ||
753 | } | ||
754 | |||
755 | current->pixels = NULL; | ||
756 | current->flags = 0; | ||
757 | } | ||
758 | |||
759 | static SDL_Surface *DSp_SetVideoMode(_THIS, | ||
760 | SDL_Surface *current, int width, int height, int bpp, Uint32 flags) | ||
761 | { | ||
762 | |||
763 | #if !TARGET_API_MAC_OSX | ||
764 | DisplayIDType display_id; | ||
765 | Fixed freq; | ||
766 | #endif | ||
767 | DSpContextAttributes attrib; | ||
768 | OSStatus err; | ||
769 | UInt32 rmask = 0, gmask = 0, bmask = 0; | ||
770 | |||
771 | int page_count; | ||
772 | int double_buf; | ||
773 | int hw_surface; | ||
774 | int use_dsp_back_buffer; | ||
775 | |||
776 | DSp_UnsetVideoMode (this, current); | ||
777 | |||
778 | if (bpp != dsp_old_depth) | ||
779 | DSp_DestroyPalette (this); | ||
780 | |||
781 | double_buf = (flags & SDL_DOUBLEBUF) != 0; | ||
782 | hw_surface = (flags & SDL_HWSURFACE) != 0; | ||
783 | use_dsp_back_buffer = !dsp_vram_available || !hw_surface ; | ||
784 | |||
785 | current->flags |= SDL_FULLSCREEN; | ||
786 | |||
787 | rebuild: | ||
788 | |||
789 | if ( double_buf && use_dsp_back_buffer ) { | ||
790 | page_count = 2; | ||
791 | } else { | ||
792 | page_count = 1; | ||
793 | } | ||
794 | |||
795 | SDL_memset (&attrib, 0, sizeof (DSpContextAttributes)); | ||
796 | attrib.displayWidth = width; | ||
797 | attrib.displayHeight = height; | ||
798 | attrib.displayBestDepth = bpp; | ||
799 | attrib.backBufferBestDepth = bpp; | ||
800 | attrib.displayDepthMask = kDSpDepthMask_All; | ||
801 | attrib.backBufferDepthMask = kDSpDepthMask_All; | ||
802 | attrib.colorNeeds = kDSpColorNeeds_Require; | ||
803 | attrib.colorTable = 0; | ||
804 | attrib.pageCount = page_count; | ||
805 | #if TARGET_API_MAC_OSX || UNIVERSAL_INTERFACES_VERSION == 0x0320 | ||
806 | |||
807 | if ( DSpFindBestContext (&attrib, &dsp_context) != noErr ) { | ||
808 | SDL_SetError ("DrawSprocket couldn't find a context"); | ||
809 | return NULL; | ||
810 | } | ||
811 | |||
812 | #else | ||
813 | if ( noErr != DMGetDisplayIDByGDevice (SDL_Display, &display_id, SDL_FALSE) ) { | ||
814 | SDL_SetError ("Display Manager couldn't associate GDevice with display_id"); | ||
815 | return NULL; | ||
816 | } | ||
817 | if ( DSpFindBestContextOnDisplayID(&attrib, &dsp_context, display_id) != noErr ) { | ||
818 | SDL_SetError ("DrawSprocket couldn't find a suitable context on given display"); | ||
819 | return NULL; | ||
820 | } | ||
821 | |||
822 | #endif | ||
823 | if ( DSpContext_Reserve (dsp_context, &attrib) != noErr ) { | ||
824 | SDL_SetError ("DrawSprocket couldn't get the needed resources to build the display"); | ||
825 | return NULL; | ||
826 | } | ||
827 | |||
828 | if ( (err = DSpContext_SetState (dsp_context, kDSpContextState_Active)) != noErr ) { | ||
829 | |||
830 | if (err == kDSpConfirmSwitchWarning) { | ||
831 | |||
832 | if ( ! DSp_ConfirmSwitch () ) { | ||
833 | |||
834 | DSpContext_Release (dsp_context); | ||
835 | dsp_context = NULL; | ||
836 | SDL_SetError ("User cancelled display switch"); | ||
837 | return NULL; | ||
838 | } | ||
839 | else | ||
840 | /* Have to reactivate context. Why? */ | ||
841 | DSpContext_SetState (dsp_context, kDSpContextState_Active); | ||
842 | |||
843 | } | ||
844 | else { | ||
845 | SDL_SetError ("DrawSprocket couldn't activate the context"); | ||
846 | return NULL; | ||
847 | } | ||
848 | } | ||
849 | |||
850 | |||
851 | if (bpp != dsp_old_depth) { | ||
852 | |||
853 | DSp_CreatePalette (this); | ||
854 | |||
855 | /* update format if display depth changed */ | ||
856 | if (bpp == 16) { | ||
857 | |||
858 | rmask = 0x00007c00; | ||
859 | gmask = 0x000003e0; | ||
860 | bmask = 0x0000001f; | ||
861 | } | ||
862 | if ( ! SDL_ReallocFormat (current, bpp, rmask, gmask, bmask, 0 ) ) { | ||
863 | |||
864 | SDL_SetError ("Could not reallocate video format."); | ||
865 | return(NULL); | ||
866 | } | ||
867 | } | ||
868 | |||
869 | if (!double_buf) { | ||
870 | |||
871 | /* single-buffer context */ | ||
872 | DSpContext_GetFrontBuffer (dsp_context, &dsp_back_buffer); | ||
873 | |||
874 | current->hwdata = (private_hwdata*) SDL_malloc (sizeof (private_hwdata)); | ||
875 | if (current ->hwdata == NULL) { | ||
876 | SDL_OutOfMemory (); | ||
877 | return NULL; | ||
878 | } | ||
879 | current->hwdata->offscreen = dsp_back_buffer; | ||
880 | current->flags |= SDL_HWSURFACE; | ||
881 | this->UpdateRects = DSp_DirectUpdate; | ||
882 | } | ||
883 | else if ( use_dsp_back_buffer ) { | ||
884 | |||
885 | DSpContext_GetBackBuffer (dsp_context, kDSpBufferKind_Normal, &dsp_back_buffer); | ||
886 | |||
887 | current->flags |= SDL_DOUBLEBUF | SDL_SWSURFACE; /* only front buffer is in VRAM */ | ||
888 | this->UpdateRects = DSp_DSpUpdate; | ||
889 | } | ||
890 | else if ( DSp_NewHWSurface(this, &dsp_back_buffer, bpp, width-1, height-1) == 0 ) { | ||
891 | |||
892 | current->hwdata = (private_hwdata*) SDL_malloc (sizeof (private_hwdata)); | ||
893 | if (current ->hwdata == NULL) { | ||
894 | SDL_OutOfMemory (); | ||
895 | return NULL; | ||
896 | } | ||
897 | |||
898 | SDL_memset (current->hwdata, 0, sizeof (private_hwdata)); | ||
899 | current->hwdata->offscreen = dsp_back_buffer; | ||
900 | current->flags |= SDL_DOUBLEBUF | SDL_HWSURFACE; | ||
901 | this->UpdateRects = DSp_DirectUpdate; /* hardware doesn't do update rects, must be page-flipped */ | ||
902 | } | ||
903 | else { | ||
904 | |||
905 | DSpContext_Release (dsp_context); | ||
906 | use_dsp_back_buffer = SDL_TRUE; | ||
907 | goto rebuild; | ||
908 | } | ||
909 | |||
910 | current->pitch = GetPortPixRowBytes(dsp_back_buffer) & 0x3FFF; | ||
911 | current->pixels = GetPixBaseAddr(GetPortPixMap(dsp_back_buffer)); | ||
912 | |||
913 | current->w = width; | ||
914 | current->h = height; | ||
915 | |||
916 | #if ! TARGET_API_MAC_OSX | ||
917 | |||
918 | if (use_dsp_back_buffer) { | ||
919 | |||
920 | DSpContext_GetMonitorFrequency (dsp_context, &freq); | ||
921 | DSpContext_SetMaxFrameRate (dsp_context, freq >> 16); | ||
922 | } | ||
923 | |||
924 | |||
925 | if ( (current->flags & SDL_HWSURFACE) || (current->flags & SDL_OPENGL) ) | ||
926 | DSpContext_SetVBLProc (dsp_context, DSp_VBLProc, NULL); | ||
927 | #endif | ||
928 | |||
929 | if (bpp == 8) | ||
930 | current->flags |= SDL_HWPALETTE; | ||
931 | |||
932 | if (flags & SDL_OPENGL) { | ||
933 | |||
934 | Rect rect; | ||
935 | RGBColor rgb = { 0.0, 0.0, 0.0 }; | ||
936 | GrafPtr save_port; | ||
937 | |||
938 | SetRect (&rect, 0, 0, width, height); | ||
939 | SDL_Window = NewCWindow(nil, &( (**SDL_Display).gdRect), "\p", SDL_TRUE, plainDBox, (WindowPtr)-1, SDL_FALSE, 0); | ||
940 | |||
941 | if (SDL_Window == NULL) { | ||
942 | |||
943 | SDL_SetError ("DSp_SetVideoMode : OpenGL window could not be created."); | ||
944 | return NULL; | ||
945 | } | ||
946 | |||
947 | /* Set window color to black to avoid white flash*/ | ||
948 | GetPort (&save_port); | ||
949 | #if TARGET_API_MAC_CARBON | ||
950 | SetPort (GetWindowPort(SDL_Window)); | ||
951 | #else | ||
952 | SetPort (SDL_Window); | ||
953 | #endif | ||
954 | RGBForeColor (&rgb); | ||
955 | PaintRect (&rect); | ||
956 | SetPort (save_port); | ||
957 | |||
958 | SetPortWindowPort (SDL_Window); | ||
959 | SelectWindow (SDL_Window); | ||
960 | |||
961 | if ( Mac_GL_Init (this) < 0 ) { | ||
962 | |||
963 | SDL_SetError ("DSp_SetVideoMode : could not create OpenGL context."); | ||
964 | return NULL; | ||
965 | } | ||
966 | |||
967 | current->flags |= SDL_OPENGL; | ||
968 | } | ||
969 | |||
970 | return current; | ||
971 | } | ||
972 | |||
973 | #ifdef DSP_TRY_CC_AND_AA | ||
974 | |||
975 | static int DSp_MakeHWMask (_THIS, SDL_Surface *surface) | ||
976 | { | ||
977 | GDHandle save_device; | ||
978 | CGrafPtr save_port; | ||
979 | GWorldPtr temp; | ||
980 | RGBColor black = { 0, 0, 0 }; | ||
981 | RGBColor white = { 0xFFFF, 0xFFFF, 0xFFFF }; | ||
982 | Rect rect; | ||
983 | |||
984 | Uint32 depth = GetPixDepth ( GetGDevPixMap (SDL_Display) ); | ||
985 | |||
986 | SetRect (&rect, 0, 0, surface->w, surface->h); | ||
987 | |||
988 | if ( noErr != NewGWorld (&(surface->hwdata->mask), depth, &rect, 0, SDL_Display, 0 ) < 0 ) { | ||
989 | |||
990 | SDL_OutOfMemory (); | ||
991 | return (-1); | ||
992 | } | ||
993 | |||
994 | if ( noErr != NewGWorld (&temp, depth, &rect, 0 , SDL_Display, 0 ) ) { | ||
995 | |||
996 | SDL_OutOfMemory (); | ||
997 | return (-1); | ||
998 | } | ||
999 | |||
1000 | |||
1001 | GetGWorld (&save_port, &save_device); | ||
1002 | SetGWorld (surface->hwdata->mask, SDL_Display); | ||
1003 | |||
1004 | RGBForeColor (&white); | ||
1005 | PaintRect (&rect); | ||
1006 | |||
1007 | RGBBackColor (&(surface->hwdata->trans)); | ||
1008 | |||
1009 | CopyBits ( GetPortBitMapForCopyBits(surface->hwdata->offscreen), | ||
1010 | GetPortBitMapForCopyBits(surface->hwdata->mask), | ||
1011 | &rect, &rect, transparent, NULL ); | ||
1012 | |||
1013 | SetGWorld (surface->hwdata->mask, SDL_Display); | ||
1014 | SetGWorld (save_port, save_device); | ||
1015 | return (0); | ||
1016 | } | ||
1017 | |||
1018 | static int DSp_SetHWAlpha(_THIS, SDL_Surface *surface, UInt8 alpha) | ||
1019 | { | ||
1020 | surface->hwdata->alpha.red = (alpha / 255.0) * 65535; | ||
1021 | surface->hwdata->alpha.blue = (alpha / 255.0) * 65535; | ||
1022 | surface->hwdata->alpha.green = (alpha / 255.0) * 65535; | ||
1023 | |||
1024 | surface->flags |= SDL_SRCALPHA; | ||
1025 | |||
1026 | if (surface->flags & SDL_SRCCOLORKEY) { | ||
1027 | return(DSp_MakeHWMask (this, surface)); | ||
1028 | } | ||
1029 | return(0); | ||
1030 | } | ||
1031 | |||
1032 | static int DSp_SetHWColorKey(_THIS, SDL_Surface *surface, Uint32 key) | ||
1033 | { | ||
1034 | CGrafPtr save_port; | ||
1035 | GDHandle save_device; | ||
1036 | |||
1037 | GetGWorld (&save_port, &save_device); | ||
1038 | SetGWorld (surface->hwdata->offscreen, NULL); | ||
1039 | |||
1040 | Index2Color (key, &(surface->hwdata->trans)); | ||
1041 | surface->flags |= SDL_SRCCOLORKEY; | ||
1042 | |||
1043 | SetGWorld (save_port, save_device); | ||
1044 | |||
1045 | if ( surface->flags & SDL_SRCALPHA ) { | ||
1046 | return(DSp_MakeHWMask (this, surface)); | ||
1047 | } | ||
1048 | return(0); | ||
1049 | } | ||
1050 | |||
1051 | #endif /* DSP_TRY_CC_AND_AA */ | ||
1052 | |||
1053 | static int DSp_NewHWSurface(_THIS, CGrafPtr *port, int depth, int width, int height) { | ||
1054 | |||
1055 | OSStatus err; | ||
1056 | Rect bounds; | ||
1057 | |||
1058 | SetRect (&bounds, 0, 0, width, height); | ||
1059 | |||
1060 | #if useDistantHdwrMem && useLocalHdwrMem | ||
1061 | if (dsp_vram_available) { | ||
1062 | /* try VRAM */ | ||
1063 | err = NewGWorld (port, depth, &bounds, 0 , SDL_Display, useDistantHdwrMem | noNewDevice ); | ||
1064 | if (err != noErr) | ||
1065 | DSp_SetHWError (err, SDL_FALSE); | ||
1066 | else | ||
1067 | return (0); | ||
1068 | } | ||
1069 | |||
1070 | if (dsp_agp_available) { | ||
1071 | /* try AGP */ | ||
1072 | err = NewGWorld (port, depth, &bounds, 0 , SDL_Display, useLocalHdwrMem | noNewDevice ); | ||
1073 | |||
1074 | if (err != noErr) | ||
1075 | DSp_SetHWError (err, SDL_TRUE); | ||
1076 | else | ||
1077 | return (0); | ||
1078 | } | ||
1079 | #endif | ||
1080 | |||
1081 | return (-1); | ||
1082 | } | ||
1083 | |||
1084 | static int DSp_AllocHWSurface(_THIS, SDL_Surface *surface) | ||
1085 | { | ||
1086 | GWorldPtr temp; | ||
1087 | |||
1088 | if ( DSp_NewHWSurface (this, &temp, surface->format->BitsPerPixel, surface->w, surface->h) < 0 ) | ||
1089 | return (-1); | ||
1090 | |||
1091 | surface->hwdata = (private_hwdata*) SDL_malloc (sizeof (private_hwdata)); | ||
1092 | if (surface->hwdata == NULL) { | ||
1093 | SDL_OutOfMemory (); | ||
1094 | return -1; | ||
1095 | } | ||
1096 | |||
1097 | SDL_memset (surface->hwdata, 0, sizeof(private_hwdata)); | ||
1098 | surface->hwdata->offscreen = temp; | ||
1099 | surface->pitch = GetPixRowBytes (GetPortPixMap (temp)) & 0x3FFF; | ||
1100 | surface->pixels = GetPixBaseAddr (GetPortPixMap (temp)); | ||
1101 | surface->flags |= SDL_HWSURFACE; | ||
1102 | #ifdef DSP_TRY_CC_AND_AA | ||
1103 | surface->flags |= SDL_HWACCEL; | ||
1104 | #endif | ||
1105 | return 0; | ||
1106 | } | ||
1107 | |||
1108 | static void DSp_FreeHWSurface(_THIS, SDL_Surface *surface) | ||
1109 | { | ||
1110 | if (surface->hwdata->offscreen != NULL) | ||
1111 | DisposeGWorld (surface->hwdata->offscreen); | ||
1112 | SDL_free(surface->hwdata); | ||
1113 | |||
1114 | surface->pixels = NULL; | ||
1115 | } | ||
1116 | |||
1117 | static int DSp_CheckHWBlit(_THIS, SDL_Surface *src, SDL_Surface *dest) | ||
1118 | { | ||
1119 | int accelerated; | ||
1120 | |||
1121 | /* Set initial acceleration on */ | ||
1122 | src->flags |= SDL_HWACCEL; | ||
1123 | |||
1124 | /* Set the surface attributes */ | ||
1125 | if ( (src->flags & SDL_SRCALPHA) == SDL_SRCALPHA ) { | ||
1126 | if ( ! this->info.blit_hw_A ) { | ||
1127 | src->flags &= ~SDL_HWACCEL; | ||
1128 | } | ||
1129 | } | ||
1130 | if ( (src->flags & SDL_SRCCOLORKEY) == SDL_SRCCOLORKEY ) { | ||
1131 | if ( ! this->info.blit_hw_CC ) { | ||
1132 | src->flags &= ~SDL_HWACCEL; | ||
1133 | } | ||
1134 | } | ||
1135 | |||
1136 | /* Check to see if final surface blit is accelerated */ | ||
1137 | accelerated = !!(src->flags & SDL_HWACCEL); | ||
1138 | if ( accelerated ) { | ||
1139 | src->map->hw_blit = DSp_HWAccelBlit; | ||
1140 | } | ||
1141 | return(accelerated); | ||
1142 | } | ||
1143 | |||
1144 | static int DSp_HWAccelBlit(SDL_Surface *src, SDL_Rect *srcrect, | ||
1145 | SDL_Surface *dst, SDL_Rect *dstrect) | ||
1146 | { | ||
1147 | CGrafPtr save_port; | ||
1148 | GDHandle save_device; | ||
1149 | Rect src_rect, dst_rect; | ||
1150 | RGBColor black = { 0, 0, 0 }; | ||
1151 | RGBColor white = { 0xFFFF, 0xFFFF, 0xFFFF }; | ||
1152 | |||
1153 | #ifdef DSP_TRY_CC_AND_AA | ||
1154 | UInt32 mode; | ||
1155 | #endif | ||
1156 | |||
1157 | SetRect (&src_rect, srcrect->x, srcrect->y, srcrect->x + srcrect->w, srcrect->y + srcrect->h); | ||
1158 | SetRect (&dst_rect, dstrect->x, dstrect->y, dstrect->x + dstrect->w, dstrect->y + dstrect->h); | ||
1159 | |||
1160 | GetGWorld (&save_port, &save_device); | ||
1161 | SetGWorld (dst->hwdata->offscreen, NULL); | ||
1162 | |||
1163 | RGBForeColor (&black); | ||
1164 | RGBBackColor (&white); | ||
1165 | |||
1166 | #ifdef DSP_TRY_CC_AND_AA | ||
1167 | |||
1168 | if ( (src->flags & SDL_SRCCOLORKEY) && | ||
1169 | (src->flags & SDL_SRCALPHA) ) { | ||
1170 | |||
1171 | OpColor (&(src->hwdata->alpha)); | ||
1172 | |||
1173 | CopyDeepMask ( GetPortBitMapForCopyBits(src->hwdata->offscreen), | ||
1174 | GetPortBitMapForCopyBits(src->hwdata->mask), | ||
1175 | GetPortBitMapForCopyBits(dst->hwdata->offscreen), | ||
1176 | &src_rect, &src_rect, &dst_rect, | ||
1177 | blend, | ||
1178 | NULL ); | ||
1179 | } | ||
1180 | else { | ||
1181 | |||
1182 | if ( src->flags & SDL_SRCCOLORKEY) { | ||
1183 | RGBBackColor (&(src->hwdata->trans) ); | ||
1184 | mode = transparent; | ||
1185 | } | ||
1186 | else if (src->flags & SDL_SRCALPHA) { | ||
1187 | |||
1188 | OpColor (&(src->hwdata->alpha)); | ||
1189 | mode = blend; | ||
1190 | } | ||
1191 | else { | ||
1192 | |||
1193 | mode = srcCopy; | ||
1194 | } | ||
1195 | |||
1196 | CopyBits ( GetPortBitMapForCopyBits(src->hwdata->offscreen), | ||
1197 | GetPortBitMapForCopyBits(dst->hwdata->offscreen), | ||
1198 | &src_rect, &dst_rect, mode, NULL ); | ||
1199 | } | ||
1200 | #else | ||
1201 | |||
1202 | CopyBits ( &(((GrafPtr)(src->hwdata->offscreen))->portBits), | ||
1203 | &(((GrafPtr)(dst->hwdata->offscreen))->portBits), | ||
1204 | &src_rect, &dst_rect, srcCopy, NULL ); | ||
1205 | |||
1206 | #endif /* DSP_TRY_CC_AND_AA */ | ||
1207 | |||
1208 | SetGWorld (save_port, save_device); | ||
1209 | |||
1210 | return(0); | ||
1211 | } | ||
1212 | |||
1213 | static int DSp_FillHWRect(_THIS, SDL_Surface *dst, SDL_Rect *rect, Uint32 color) | ||
1214 | { | ||
1215 | CGrafPtr save_port; | ||
1216 | GDHandle save_device; | ||
1217 | Rect fill_rect; | ||
1218 | RGBColor rgb; | ||
1219 | |||
1220 | SetRect (&fill_rect, rect->x, rect->y, rect->x + rect->w, rect->y + rect->h); | ||
1221 | |||
1222 | GetGWorld (&save_port, &save_device); | ||
1223 | SetGWorld (dst->hwdata->offscreen, NULL); | ||
1224 | |||
1225 | Index2Color (color, &rgb); | ||
1226 | |||
1227 | RGBForeColor (&rgb); | ||
1228 | PaintRect (&fill_rect); | ||
1229 | |||
1230 | SetGWorld (save_port, save_device); | ||
1231 | |||
1232 | return(0); | ||
1233 | } | ||
1234 | |||
1235 | static int DSp_FlipHWSurface(_THIS, SDL_Surface *surface) | ||
1236 | { | ||
1237 | if ( (surface->flags & SDL_HWSURFACE) ) { | ||
1238 | CGrafPtr dsp_front_buffer, save_port; | ||
1239 | Rect rect; | ||
1240 | |||
1241 | #if ! TARGET_API_MAC_OSX | ||
1242 | unsigned int old_count; | ||
1243 | #endif | ||
1244 | |||
1245 | /* pseudo page flipping for VRAM back buffer*/ | ||
1246 | DSpContext_GetFrontBuffer (dsp_context, &dsp_front_buffer); | ||
1247 | SetRect (&rect, 0, 0, surface->w-1, surface->h-1); | ||
1248 | |||
1249 | GetPort ((GrafPtr *)&save_port); | ||
1250 | SetPort ((GrafPtr)dsp_front_buffer); | ||
1251 | |||
1252 | /* wait for retrace */ | ||
1253 | /* I have tried doing the swap in interrupt routine (VBL Proc) to do */ | ||
1254 | /* it asynchronously, but apparently CopyBits isn't interrupt safe */ | ||
1255 | |||
1256 | #if ! TARGET_API_MAC_OSX | ||
1257 | #ifndef DSP_NO_SYNC_VBL | ||
1258 | old_count = retrace_count; | ||
1259 | while (old_count == retrace_count) | ||
1260 | ; | ||
1261 | #endif | ||
1262 | #endif | ||
1263 | |||
1264 | CopyBits ( GetPortBitMapForCopyBits(dsp_back_buffer), | ||
1265 | GetPortBitMapForCopyBits(dsp_front_buffer), | ||
1266 | &rect, &rect, srcCopy, NULL ); | ||
1267 | |||
1268 | SetPort ((GrafPtr)save_port); | ||
1269 | |||
1270 | } else { | ||
1271 | /* not really page flipping at all: DSp just blits the dirty rectangles from DSp_UpdateRects */ | ||
1272 | Boolean busy_flag; | ||
1273 | DSpContext_SwapBuffers (dsp_context, NULL, &busy_flag); /* this waits for VBL */ | ||
1274 | DSpContext_GetBackBuffer (dsp_context, kDSpBufferKind_Normal, &dsp_back_buffer); | ||
1275 | surface->pixels = GetPixBaseAddr( GetPortPixMap(dsp_back_buffer) ); | ||
1276 | } | ||
1277 | return(0); | ||
1278 | } | ||
1279 | |||
1280 | static int DSp_LockHWSurface(_THIS, SDL_Surface *surface) | ||
1281 | { | ||
1282 | if ( LockPixels (GetGWorldPixMap (surface->hwdata->offscreen)) ) | ||
1283 | return 0; | ||
1284 | else | ||
1285 | return -1; | ||
1286 | } | ||
1287 | |||
1288 | static void DSp_UnlockHWSurface(_THIS, SDL_Surface *surface) | ||
1289 | { | ||
1290 | UnlockPixels (GetGWorldPixMap (surface->hwdata->offscreen)); | ||
1291 | } | ||
1292 | |||
1293 | static void DSp_DirectUpdate(_THIS, int numrects, SDL_Rect *sdl_rects) | ||
1294 | { | ||
1295 | return; | ||
1296 | } | ||
1297 | |||
1298 | static void DSp_DSpUpdate(_THIS, int numrects, SDL_Rect *sdl_rects) | ||
1299 | { | ||
1300 | #if ! TARGET_API_MAC_OSX /* Unsupported DSp in here */ | ||
1301 | int i; | ||
1302 | Rect rect; | ||
1303 | |||
1304 | for (i = 0; i < numrects; i++) { | ||
1305 | |||
1306 | rect.top = sdl_rects[i].y; | ||
1307 | rect.left = sdl_rects[i].x; | ||
1308 | rect.bottom = sdl_rects[i].h + sdl_rects[i].y; | ||
1309 | rect.right = sdl_rects[i].w + sdl_rects[i].x; | ||
1310 | |||
1311 | DSpContext_InvalBackBufferRect (dsp_context, &rect); | ||
1312 | } | ||
1313 | #endif | ||
1314 | } | ||
1315 | |||
1316 | static int DSp_CreatePalette(_THIS) { | ||
1317 | |||
1318 | |||
1319 | /* Create our palette */ | ||
1320 | SDL_CTab = (CTabHandle)NewHandle(sizeof(ColorSpec)*256 + 8); | ||
1321 | if ( SDL_CTab == nil ) { | ||
1322 | SDL_OutOfMemory(); | ||
1323 | return(-1); | ||
1324 | } | ||
1325 | (**SDL_CTab).ctSeed = GetCTSeed(); | ||
1326 | (**SDL_CTab).ctFlags = 0; | ||
1327 | (**SDL_CTab).ctSize = 255; | ||
1328 | CTabChanged(SDL_CTab); | ||
1329 | SDL_CPal = NewPalette(256, SDL_CTab, pmExplicit+pmTolerant, 0); | ||
1330 | |||
1331 | return 0; | ||
1332 | } | ||
1333 | |||
1334 | static int DSp_DestroyPalette(_THIS) { | ||
1335 | |||
1336 | /* Free palette and restore original one */ | ||
1337 | if ( SDL_CTab != nil ) { | ||
1338 | DisposeHandle((Handle)SDL_CTab); | ||
1339 | SDL_CTab = nil; | ||
1340 | } | ||
1341 | if ( SDL_CPal != nil ) { | ||
1342 | DisposePalette(SDL_CPal); | ||
1343 | SDL_CPal = nil; | ||
1344 | } | ||
1345 | RestoreDeviceClut(SDL_Display); | ||
1346 | |||
1347 | return (0); | ||
1348 | } | ||
1349 | |||
1350 | static int DSp_SetColors(_THIS, int firstcolor, int ncolors, SDL_Color *colors) | ||
1351 | { | ||
1352 | CTabHandle cTab; | ||
1353 | |||
1354 | int i; | ||
1355 | |||
1356 | cTab = SDL_CTab; | ||
1357 | |||
1358 | /* Verify the range of colors */ | ||
1359 | if ( (firstcolor+ncolors) > ((**cTab).ctSize+1) ) { | ||
1360 | return(0); | ||
1361 | } | ||
1362 | |||
1363 | /* Set the screen palette and update the display */ | ||
1364 | for(i = 0; i < ncolors; i++) { | ||
1365 | int j = firstcolor + i; | ||
1366 | (**cTab).ctTable[j].value = j; | ||
1367 | (**cTab).ctTable[j].rgb.red = colors[i].r << 8 | colors[i].r; | ||
1368 | (**cTab).ctTable[j].rgb.green = colors[i].g << 8 | colors[i].g; | ||
1369 | (**cTab).ctTable[j].rgb.blue = colors[i].b << 8 | colors[i].b; | ||
1370 | } | ||
1371 | |||
1372 | SetGDevice(SDL_Display); | ||
1373 | SetEntries(0, (**cTab).ctSize, (ColorSpec *)&(**cTab).ctTable); | ||
1374 | |||
1375 | return(1); | ||
1376 | } | ||
1377 | |||
1378 | void DSp_VideoQuit(_THIS) | ||
1379 | { | ||
1380 | int i; | ||
1381 | |||
1382 | /* Free current video mode */ | ||
1383 | DSp_UnsetVideoMode(this, this->screen); | ||
1384 | |||
1385 | /* Free Palette and restore original */ | ||
1386 | DSp_DestroyPalette (this); | ||
1387 | |||
1388 | #if SDL_MACCLASSIC_GAMMA_SUPPORT | ||
1389 | Mac_QuitGamma(this); | ||
1390 | #endif | ||
1391 | |||
1392 | /* Free list of video modes */ | ||
1393 | if ( SDL_modelist != NULL ) { | ||
1394 | for ( i=0; SDL_modelist[i]; i++ ) { | ||
1395 | SDL_free(SDL_modelist[i]); | ||
1396 | } | ||
1397 | SDL_free(SDL_modelist); | ||
1398 | SDL_modelist = NULL; | ||
1399 | } | ||
1400 | |||
1401 | /* Unload DrawSprocket */ | ||
1402 | DSpShutdown (); | ||
1403 | } | ||
1404 | |||
1405 | #if SDL_VIDEO_OPENGL | ||
1406 | |||
1407 | /* swap buffers with v-sync */ | ||
1408 | static void DSp_GL_SwapBuffers (_THIS) { | ||
1409 | |||
1410 | #ifndef DSP_NO_SYNC_OPENGL | ||
1411 | |||
1412 | unsigned int old_count; | ||
1413 | |||
1414 | old_count = retrace_count; | ||
1415 | while (old_count == retrace_count) | ||
1416 | ; | ||
1417 | #endif | ||
1418 | |||
1419 | aglSwapBuffers (glContext); | ||
1420 | } | ||
1421 | |||
1422 | #endif | ||
diff --git a/apps/plugins/sdl/src/video/macdsp/SDL_dspvideo.h b/apps/plugins/sdl/src/video/macdsp/SDL_dspvideo.h deleted file mode 100644 index 7fc0896d1d..0000000000 --- a/apps/plugins/sdl/src/video/macdsp/SDL_dspvideo.h +++ /dev/null | |||
@@ -1,54 +0,0 @@ | |||
1 | /* | ||
2 | SDL - Simple DirectMedia Layer | ||
3 | Copyright (C) 1997-2012 Sam Lantinga | ||
4 | |||
5 | This library is free software; you can redistribute it and/or | ||
6 | modify it under the terms of the GNU Lesser General Public | ||
7 | License as published by the Free Software Foundation; either | ||
8 | version 2.1 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 | Lesser General Public License for more details. | ||
14 | |||
15 | You should have received a copy of the GNU Lesser General Public | ||
16 | License along with this library; if not, write to the Free Software | ||
17 | Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA | ||
18 | |||
19 | Sam Lantinga | ||
20 | slouken@libsdl.org | ||
21 | */ | ||
22 | #include "SDL_config.h" | ||
23 | |||
24 | #ifndef _SDL_dspvideo_h | ||
25 | #define _SDL_dspvideo_h | ||
26 | |||
27 | #if TARGET_API_MAC_OSX | ||
28 | # include <DrawSprocket/DrawSprocket.h> /* Drawsprocket.framework */ | ||
29 | #else | ||
30 | #include <DrawSprocket.h> | ||
31 | #endif | ||
32 | |||
33 | #include "../maccommon/SDL_lowvideo.h" | ||
34 | |||
35 | /* DrawSprocket specific information */ | ||
36 | struct DSpInfo { | ||
37 | DSpContextReference dsp_context; | ||
38 | CGrafPtr dsp_back_buffer; | ||
39 | int dsp_old_depth; | ||
40 | |||
41 | /* Flags for hw acceleration */ | ||
42 | int dsp_vram_available; | ||
43 | int dsp_agp_available; | ||
44 | |||
45 | |||
46 | }; | ||
47 | /* Old variable names */ | ||
48 | #define dsp_context (this->hidden->dspinfo->dsp_context) | ||
49 | #define dsp_back_buffer (this->hidden->dspinfo->dsp_back_buffer) | ||
50 | #define dsp_old_depth (this->hidden->dspinfo->dsp_old_depth) | ||
51 | #define dsp_vram_available (this->hidden->dspinfo->dsp_vram_available) | ||
52 | #define dsp_agp_available (this->hidden->dspinfo->dsp_agp_available) | ||
53 | |||
54 | #endif /* _SDL_dspvideo_h */ | ||