aboutsummaryrefslogtreecommitdiffstats
path: root/distrib/sdl-1.2.15/src/video/macdsp/SDL_dspvideo.c
diff options
context:
space:
mode:
authorJesse Hall <jessehall@google.com>2012-07-23 10:12:30 -0700
committerandroid code review <noreply-gerritcodereview@google.com>2012-07-23 10:12:30 -0700
commit2b3a42e7d0b441f71fc2e2b07269dd1f8151c977 (patch)
treeded6ee18c4e1f33df235e53615a6d65e2d64f4ef /distrib/sdl-1.2.15/src/video/macdsp/SDL_dspvideo.c
parent3dcbebfd43e409c3bbff7fc79288e40666a947fd (diff)
parent9682c8870b8ff5e4ac2e4c70b759f791c6f38c1f (diff)
downloadexternal_qemu-2b3a42e7d0b441f71fc2e2b07269dd1f8151c977.zip
external_qemu-2b3a42e7d0b441f71fc2e2b07269dd1f8151c977.tar.gz
external_qemu-2b3a42e7d0b441f71fc2e2b07269dd1f8151c977.tar.bz2
Merge changes I505c4aea,I2ae0529c
* changes: Import SDL release-1.2.15 Handle SDL windows with BGRA color
Diffstat (limited to 'distrib/sdl-1.2.15/src/video/macdsp/SDL_dspvideo.c')
-rw-r--r--distrib/sdl-1.2.15/src/video/macdsp/SDL_dspvideo.c1422
1 files changed, 1422 insertions, 0 deletions
diff --git a/distrib/sdl-1.2.15/src/video/macdsp/SDL_dspvideo.c b/distrib/sdl-1.2.15/src/video/macdsp/SDL_dspvideo.c
new file mode 100644
index 0000000..aa31127
--- /dev/null
+++ b/distrib/sdl-1.2.15/src/video/macdsp/SDL_dspvideo.c
@@ -0,0 +1,1422 @@
+/*
+ SDL - Simple DirectMedia Layer
+ Copyright (C) 1997-2012 Sam Lantinga
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+ Sam Lantinga
+ slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+/*
+ Written by Darrell Walisser <dwaliss1@purdue.edu>
+
+ Implementation notes ----------------------------------------------------------------------
+
+ A bit on GWorlds in VRAM from technote 1182:
+
+ There are two important things to note about GWorld's allocated in
+ VRAM. First, the base address retrieved through GetPixBaseAddr or
+ read directly from the PixMap structure can become invalid anytime
+ memory is allocated in VRAM. This can occur either by explicit
+ allocations, such as calls to NewGWorld, or by implicit ones, such as
+ those associated with the internal texture allocation of OpenGL. The
+ stored pixel images themselves will still be valid but may have been
+ moved in VRAM, thus rendering any stored base addresses invalid.
+ You should never store an image's base address for longer than is
+ necessary and especially never across calls to NewGWorld or
+ texture-creation routines.
+
+ Secondly, an offscreen pixel image allocated in VRAM can be
+ purged at system task time by the display driver. This means any
+ time your application yields time such by calling WaitNextEvent or
+ SystemTask you can lose your VRAM GWorld contents. While this
+ happens infrequently, usually associated with display resolution or
+ pixel depth changes you must code for this eventuality. This purge
+ can occur whether or not the GWorld is locked or not. A return value
+ of false from LockPixels, a NULL return value from GetPixBaseAddr
+ or NULL in the baseAddr field of the PixMap mean that the pixel
+ image has been purged. To reallocate it you can either call
+ UpdateGWorld or Dispose your current GWorld through
+ DisposeGWorld and reallocate it via NewGWorld. Either way you must
+ then rebuild the pixel image.
+
+------------------------------------------------------------------------------------
+
+ Currently, I don't account for (1). In my testing, NewGWorld never invalidated
+ other existing GWorlds in VRAM. However, I do have protection for (2).
+ Namely, I am using GetOSEvent() instead of WaitNextEvent() so that there are no
+ context switches (the app hogs the CPU). Eventually a book-keeping system should
+ be coded to take care of (1) and (2).
+
+------------------------------------------------------------------------------------
+
+ System requirements (* denotes optional):
+
+ 1. DrawSprocket 1.7.3
+ 2. *MacOS 9 or later (but *not* Mac OS X) for hardware accelerated blit / fill
+ 3. *May also require certain graphics hardware for (2). I trust that all Apple OEM
+ hardware will work. Third party accelerators may work if they have QuickDraw
+ acceleration in the drivers and the drivers have been updated for OS 9. The current
+ Voodoo 3 drivers (1.0b12) do not work.
+
+ Coding suggestions:
+
+ 1. Use SDL_UpdateRects !
+
+ If no QuickDraw acceleration is present, double-buffered surfaces will use a back buffer
+ in System memory. I recommend you use SDL_UpdateRects with double-buffered surfaces
+ for best performance on these cards, since the overhead is nearly zero for VRAM back buffer.
+
+ 2. Load most-resident surfaces first.
+
+ If you fill up VRAM or AGP memory, there is no contingency for purging to make room for the next one.
+ Therefore, you should load the surfaces you plan to use the most frequently first.
+ Sooner or later, I will code LRU replacement to help this.
+
+ TODO:
+ Some kind of posterized mode for resolutions < 640x480.
+ Window support / fullscreen toggle.
+ Figure out how much VRAM is available. Put in video->info->video_mem.
+ Track VRAM usage.
+
+ BUGS:
+ I can't create a hardware surface the same size as the screen?! How to fix?
+
+
+
+ COMPILE OPTIONS:
+
+ DSP_TRY_CC_AND_AA - Define if you want to try HWA color-key and alpha blitters
+ HW color-key blitting gives substantial improvements,
+ but hw alpha is neck-and-neck with SDL's soft bitter.
+
+ DSP_NO_SYNC_VBL - Define for HWA double-buffered surfaces: don't sync
+ pseudo-flip to monitor redraw.
+
+ DSP_NO_SYNC_OPENGL - Define for OpenGL surfaces: don't sync buffer swap. Synching buffer
+ swap may result in reduced performance, but can eliminate some
+ tearing artifacts.
+ CHANGELOG:
+ 09/17/00 Lots of little tweaks. Build modelist in reverse order so largest contexts
+ list first. Compared various methods with ROM methods and fixed rez switch
+ crashing bug in GL Tron. (Woohoo!)
+*/
+
+#define DSP_TRY_CC_AND_AA
+
+/* #define DSP_NO_SYNC_VBL */
+
+#define DSP_NO_SYNC_OPENGL
+
+
+#if defined(__APPLE__) && defined(__MACH__)
+#include <Carbon/Carbon.h>
+#include <DrawSprocket/DrawSprocket.h>
+#elif TARGET_API_MAC_CARBON && (UNIVERSAL_INTERFACES_VERSION > 0x0335)
+#include <Carbon.h>
+#include <DrawSprocket.h>
+#else
+#include <LowMem.h>
+#include <Gestalt.h>
+#include <Devices.h>
+#include <DiskInit.h>
+#include <QDOffscreen.h>
+#include <DrawSprocket.h>
+#endif
+
+#include "SDL_video.h"
+#include "SDL_syswm.h"
+#include "../SDL_sysvideo.h"
+#include "../SDL_blit.h"
+#include "../SDL_pixels_c.h"
+#include "SDL_dspvideo.h"
+#include "../maccommon/SDL_macgl_c.h"
+#include "../maccommon/SDL_macwm_c.h"
+#include "../maccommon/SDL_macmouse_c.h"
+#include "../maccommon/SDL_macevents_c.h"
+
+/* Initialization/Query functions */
+static int DSp_VideoInit(_THIS, SDL_PixelFormat *vformat);
+static SDL_Rect **DSp_ListModes(_THIS, SDL_PixelFormat *format, Uint32 flags);
+static SDL_Surface *DSp_SetVideoMode(_THIS, SDL_Surface *current, int width, int height, int bpp, Uint32 flags);
+static int DSp_SetColors(_THIS, int firstcolor, int ncolors,
+ SDL_Color *colors);
+static int DSp_CreatePalette(_THIS);
+static int DSp_DestroyPalette(_THIS);
+static void DSp_VideoQuit(_THIS);
+
+static int DSp_GetMainDevice (_THIS, GDHandle *device);
+static void DSp_IsHWAvailable (_THIS, SDL_PixelFormat *vformat);
+static void DSp_DSpUpdate(_THIS, int numrects, SDL_Rect *sdl_rects);
+static void DSp_DirectUpdate(_THIS, int numrects, SDL_Rect *sdl_rects);
+
+/* Hardware surface functions */
+static int DSp_SetHWAlpha(_THIS, SDL_Surface *surface, UInt8 alpha);
+static int DSp_SetHWColorKey(_THIS, SDL_Surface *surface, Uint32 key);
+static int DSp_NewHWSurface(_THIS, CGrafPtr *port, int depth, int width, int height);
+static int DSp_AllocHWSurface(_THIS, SDL_Surface *surface);
+static int DSp_LockHWSurface(_THIS, SDL_Surface *surface);
+static void DSp_UnlockHWSurface(_THIS, SDL_Surface *surface);
+static void DSp_FreeHWSurface(_THIS, SDL_Surface *surface);
+static int DSp_FlipHWSurface(_THIS, SDL_Surface *surface);
+static int DSp_CheckHWBlit(_THIS, SDL_Surface *src, SDL_Surface *dest);
+static int DSp_HWAccelBlit(SDL_Surface *src, SDL_Rect *srcrect,
+ SDL_Surface *dst, SDL_Rect *dstrect);
+static int DSp_FillHWRect(_THIS, SDL_Surface *dst, SDL_Rect *rect, Uint32 color);
+
+#if SDL_VIDEO_OPENGL
+ static void DSp_GL_SwapBuffers (_THIS);
+#endif
+
+#if ! TARGET_API_MAC_CARBON
+
+ #define GetPortPixRowBytes(x) ( (*(x->portPixMap))->rowBytes )
+ #define GetGDevPixMap(x) ((**(x)).gdPMap)
+ #define GetPortPixMap(x) ((*(x)).portPixMap)
+
+ #define GetPixDepth(y) ((**(y)).pixelSize)
+ //#define GetPixRowBytes(y) ((**(y)).rowBytes)
+ //#define GetPixBaseAddr(y) ((**(y)).baseAddr)
+ #define GetPixCTab(y) ((**(y)).pmTable)
+ #define GetPortBitMapForCopyBits(x) (&(((GrafPtr)(x))->portBits))
+
+#else
+ #define GetPortPixRowBytes(x) (GetPixRowBytes(GetPortPixMap(x)) )
+ #define GetGDevPixMap(x) ((**(x)).gdPMap)
+
+#endif
+
+typedef struct private_hwdata {
+
+ GWorldPtr offscreen; // offscreen gworld in VRAM or AGP
+
+ #ifdef DSP_TRY_CC_AND_AA
+ GWorldPtr mask; // transparent mask
+ RGBColor alpha; // alpha color
+ RGBColor trans; // transparent color
+ #endif
+
+} private_hwdata;
+
+typedef private_hwdata private_swdata ; /* have same fields */
+
+/* Macintosh toolbox driver bootstrap functions */
+
+static int DSp_Available(void)
+{
+ /* Check for DrawSprocket */
+#if ! TARGET_API_MAC_OSX
+ /* This check is only meaningful if you weak-link DrawSprocketLib */
+ return ((Ptr)DSpStartup != (Ptr)kUnresolvedCFragSymbolAddress);
+#else
+ return 1; // DrawSprocket.framework doesn't have it all, but it's there
+#endif
+}
+
+static void DSp_DeleteDevice(SDL_VideoDevice *device)
+{
+ /* -dw- taking no chances with null pointers */
+ if (device) {
+
+ if (device->hidden) {
+
+ if (device->hidden->dspinfo)
+ SDL_free(device->hidden->dspinfo);
+
+ SDL_free(device->hidden);
+ }
+ SDL_free(device);
+ }
+}
+
+static SDL_VideoDevice *DSp_CreateDevice(int devindex)
+{
+ SDL_VideoDevice *device;
+
+ /* Initialize all variables that we clean on shutdown */
+ device = (SDL_VideoDevice *)SDL_malloc(sizeof(SDL_VideoDevice));
+ if ( device ) {
+ SDL_memset(device, 0, sizeof (*device));
+ device->hidden = (struct SDL_PrivateVideoData *)
+ SDL_malloc((sizeof *device->hidden));
+ if (device->hidden)
+ SDL_memset(device->hidden, 0, sizeof ( *(device->hidden) ) );
+ }
+ if ( (device == NULL) || (device->hidden == NULL) ) {
+ SDL_OutOfMemory();
+
+ if ( device ) {
+
+ if (device->hidden)
+ SDL_free(device->hidden);
+
+ SDL_free(device);
+ }
+
+ return(NULL);
+ }
+
+ /* Allocate DrawSprocket information */
+ device->hidden->dspinfo = (struct DSpInfo *)SDL_malloc(
+ (sizeof *device->hidden->dspinfo));
+ if ( device->hidden->dspinfo == NULL ) {
+ SDL_OutOfMemory();
+ SDL_free(device->hidden);
+ SDL_free(device);
+ return(0);
+ }
+ SDL_memset(device->hidden->dspinfo, 0, (sizeof *device->hidden->dspinfo));
+
+ /* Set the function pointers */
+ device->VideoInit = DSp_VideoInit;
+ device->ListModes = DSp_ListModes;
+ device->SetVideoMode = DSp_SetVideoMode;
+ device->SetColors = DSp_SetColors;
+ device->UpdateRects = NULL;
+ device->VideoQuit = DSp_VideoQuit;
+ device->AllocHWSurface = DSp_AllocHWSurface;
+ device->CheckHWBlit = NULL;
+ device->FillHWRect = NULL;
+ device->SetHWColorKey = NULL;
+ device->SetHWAlpha = NULL;
+ device->LockHWSurface = DSp_LockHWSurface;
+ device->UnlockHWSurface = DSp_UnlockHWSurface;
+ device->FlipHWSurface = DSp_FlipHWSurface;
+ device->FreeHWSurface = DSp_FreeHWSurface;
+#if SDL_MACCLASSIC_GAMMA_SUPPORT
+ device->SetGammaRamp = Mac_SetGammaRamp;
+ device->GetGammaRamp = Mac_GetGammaRamp;
+#endif
+#if SDL_VIDEO_OPENGL
+ device->GL_MakeCurrent = Mac_GL_MakeCurrent;
+ device->GL_SwapBuffers = DSp_GL_SwapBuffers;
+ device->GL_LoadLibrary = Mac_GL_LoadLibrary;
+ device->GL_GetProcAddress = Mac_GL_GetProcAddress;
+#endif
+ device->SetCaption = NULL;
+ device->SetIcon = NULL;
+ device->IconifyWindow = NULL;
+ device->GrabInput = NULL;
+ device->GetWMInfo = NULL;
+ device->FreeWMCursor = Mac_FreeWMCursor;
+ device->CreateWMCursor = Mac_CreateWMCursor;
+ device->ShowWMCursor = Mac_ShowWMCursor;
+ device->WarpWMCursor = Mac_WarpWMCursor;
+ device->InitOSKeymap = Mac_InitOSKeymap;
+ device->PumpEvents = Mac_PumpEvents;
+
+ device->GrabInput = NULL;
+ device->CheckMouseMode = NULL;
+
+ device->free = DSp_DeleteDevice;
+
+ return device;
+}
+
+VideoBootStrap DSp_bootstrap = {
+ "DSp", "MacOS DrawSprocket",
+ DSp_Available, DSp_CreateDevice
+};
+
+/* Use DSp/Display Manager to build mode list for given screen */
+static SDL_Rect** DSp_BuildModeList (const GDHandle gDevice, int *displayWidth, int *displayHeight)
+{
+ DSpContextAttributes attributes;
+ DSpContextReference context;
+ DisplayIDType displayID;
+ SDL_Rect temp_list [16];
+ SDL_Rect **mode_list;
+ int width, height, i, j;
+
+ #if TARGET_API_MAC_OSX
+
+ displayID = 0;
+
+ #else
+ /* Ask Display Manager for integer id of screen device */
+ if ( DMGetDisplayIDByGDevice (gDevice, &displayID, SDL_TRUE) != noErr ) {
+ return NULL;
+ }
+ #endif
+ /* Get the first possible DSp context on this device */
+ if ( DSpGetFirstContext (displayID, &context) != noErr ) {
+ return NULL;
+ }
+
+ if ( DSpContext_GetAttributes (context, &attributes) != noErr )
+ return NULL;
+
+ *displayWidth = attributes.displayWidth;
+ *displayHeight = attributes.displayHeight;
+
+ for ( i = 0; i < SDL_arraysize(temp_list); i++ ) {
+ width = attributes.displayWidth;
+ height = attributes.displayHeight;
+
+ temp_list [i].x = 0 | attributes.displayBestDepth;
+ temp_list [i].y = 0;
+ temp_list [i].w = width;
+ temp_list [i].h = height;
+
+ /* DSp will report many different contexts with the same width and height. */
+ /* They will differ in bit depth and refresh rate. */
+ /* We will ignore them until we reach one with a different width/height */
+ /* When there are no more contexts to look at, we will quit building the list*/
+ while ( width == attributes.displayWidth && height == attributes.displayHeight ) {
+
+ OSStatus err = DSpGetNextContext (context, &context);
+ if (err != noErr)
+ if (err == kDSpContextNotFoundErr)
+ goto done;
+ else
+ return NULL;
+
+ if ( DSpContext_GetAttributes (context, &attributes) != noErr )
+ return NULL;
+
+ temp_list [i].x |= attributes.displayBestDepth;
+ }
+ }
+done:
+ i++; /* i was not incremented before kicking out of the loop */
+
+ mode_list = (SDL_Rect**) SDL_malloc (sizeof (SDL_Rect*) * (i+1));
+ if (mode_list) {
+
+ /* -dw- new stuff: build in reverse order so largest sizes list first */
+ for (j = i-1; j >= 0; j--) {
+ mode_list [j] = (SDL_Rect*) SDL_malloc (sizeof (SDL_Rect));
+ if (mode_list [j])
+ SDL_memcpy (mode_list [j], &(temp_list [j]), sizeof (SDL_Rect));
+ else {
+ SDL_OutOfMemory ();
+ return NULL;
+ }
+ }
+ mode_list [i] = NULL; /* append null to the end */
+ }
+ else {
+ SDL_OutOfMemory ();
+ return NULL;
+ }
+
+ return mode_list;
+}
+
+static void DSp_IsHWAvailable (_THIS, SDL_PixelFormat *vformat)
+{
+ /*
+ VRAM GWorlds are only available on OS 9 or later.
+ Even with OS 9, some display drivers won't support it,
+ so we create a test GWorld and check for errors.
+ */
+
+ long versionSystem;
+
+ dsp_vram_available = SDL_FALSE;
+ dsp_agp_available = SDL_FALSE;
+
+ Gestalt ('sysv', &versionSystem);
+ if (0x00000860 < (versionSystem & 0x0000FFFF)) {
+
+ GWorldPtr offscreen;
+ OSStatus err;
+ Rect bounds;
+
+ SetRect (&bounds, 0, 0, 320, 240);
+
+#if useDistantHdwrMem && useLocalHdwrMem
+ err = NewGWorld (&offscreen, vformat->BitsPerPixel, &bounds, NULL, SDL_Display, useDistantHdwrMem | noNewDevice);
+ if (err == noErr) {
+ dsp_vram_available = SDL_TRUE;
+ DisposeGWorld (offscreen);
+ }
+
+ err = NewGWorld (&offscreen, vformat->BitsPerPixel, &bounds, NULL, SDL_Display, useLocalHdwrMem | noNewDevice);
+ if (err == noErr) {
+ DisposeGWorld (offscreen);
+ dsp_agp_available = SDL_TRUE;
+ }
+#endif
+ }
+}
+
+static int DSp_GetMainDevice (_THIS, GDHandle *device)
+{
+
+#if TARGET_API_MAC_OSX
+ /* DSpUserSelectContext not available on OS X */
+ *device = GetMainDevice();
+ return 0;
+#else
+
+ DSpContextAttributes attrib;
+ DSpContextReference context;
+ DisplayIDType display_id;
+ GDHandle main_device;
+ GDHandle device_list;
+
+ device_list = GetDeviceList ();
+ main_device = GetMainDevice ();
+
+ /* Quick check to avoid slower method when only one display exists */
+ if ( (**device_list).gdNextGD == NULL ) {
+ *device = main_device;
+ return 0;
+ }
+
+ SDL_memset (&attrib, 0, sizeof (DSpContextAttributes));
+
+ /* These attributes are hopefully supported on all devices...*/
+ attrib.displayWidth = 640;
+ attrib.displayHeight = 480;
+ attrib.displayBestDepth = 8;
+ attrib.backBufferBestDepth = 8;
+ attrib.displayDepthMask = kDSpDepthMask_All;
+ attrib.backBufferDepthMask = kDSpDepthMask_All;
+ attrib.colorNeeds = kDSpColorNeeds_Require;
+ attrib.pageCount = 1;
+
+ if (noErr != DMGetDisplayIDByGDevice (main_device, &display_id, SDL_FALSE)) {
+ SDL_SetError ("Display Manager couldn't associate GDevice with a Display ID");
+ return (-1);
+ }
+
+ /* Put up dialog on main display to select which display to use */
+ if (noErr != DSpUserSelectContext (&attrib, display_id, NULL, &context)) {
+ SDL_SetError ("DrawSprocket couldn't create a context");
+ return (-1);
+ }
+
+ if (noErr != DSpContext_GetDisplayID (context, &display_id)) {
+ SDL_SetError ("DrawSprocket couldn't get display ID");
+ return (-1);
+ }
+
+ if (noErr != DMGetGDeviceByDisplayID (display_id, &main_device, SDL_FALSE)) {
+ SDL_SetError ("Display Manager couldn't associate Display ID with GDevice");
+ return (-1);
+ }
+
+ *device = main_device;
+ return (0);
+#endif
+}
+
+static int DSp_VideoInit(_THIS, SDL_PixelFormat *vformat)
+{
+ NumVersion dsp_version = { 0x01, 0x00, 0x00, 0x00 };
+
+#if UNIVERSAL_INTERFACES_VERSION > 0x0320
+ dsp_version = DSpGetVersion ();
+#endif
+
+ if ( (dsp_version.majorRev == 1 && dsp_version.minorAndBugRev < 0x73) ||
+ (dsp_version.majorRev < 1) ) {
+
+ /* StandardAlert (kAlertStopAlert, "\pError!",
+ "\pI need DrawSprocket 1.7.3 or later!\n"
+ "You can find a newer version at http://www.apple.com/swupdates.",
+ NULL, NULL);
+ */
+ SDL_SetError ("DrawSprocket version is too old. Need 1.7.3 or later.");
+ return (-1);
+ }
+
+ if ( DSpStartup () != noErr ) {
+ SDL_SetError ("DrawSprocket couldn't startup");
+ return(-1);
+ }
+
+ /* Start DSpintosh events */
+ Mac_InitEvents(this);
+
+ /* Get a handle to the main monitor, or choose one on multiple monitor setups */
+ if ( DSp_GetMainDevice(this, &SDL_Display) < 0)
+ return (-1);
+
+ /* Determine pixel format */
+ vformat->BitsPerPixel = GetPixDepth ( (**SDL_Display).gdPMap );
+ dsp_old_depth = vformat->BitsPerPixel;
+
+ switch (vformat->BitsPerPixel) {
+ case 16:
+ vformat->Rmask = 0x00007c00;
+ vformat->Gmask = 0x000003e0;
+ vformat->Bmask = 0x0000001f;
+ break;
+ default:
+ break;
+ }
+
+ if ( DSp_CreatePalette (this) < 0 ) {
+ SDL_SetError ("Could not create palette");
+ return (-1);
+ }
+
+ /* Get a list of available fullscreen modes */
+ SDL_modelist = DSp_BuildModeList (SDL_Display,
+ &this->info.current_w, &this->info.current_h);
+ if (SDL_modelist == NULL) {
+ SDL_SetError ("DrawSprocket could not build a mode list");
+ return (-1);
+ }
+
+ /* Check for VRAM and AGP GWorlds for HW Blitting */
+ DSp_IsHWAvailable (this, vformat);
+
+ this->info.wm_available = 0;
+
+ if (dsp_vram_available || dsp_agp_available) {
+
+ this->info.hw_available = SDL_TRUE;
+
+ this->CheckHWBlit = DSp_CheckHWBlit;
+ this->info.blit_hw = SDL_TRUE;
+
+ this->FillHWRect = DSp_FillHWRect;
+ this->info.blit_fill = SDL_TRUE;
+
+ #ifdef DSP_TRY_CC_AND_AA
+ this->SetHWColorKey = DSp_SetHWColorKey;
+ this->info.blit_hw_CC = SDL_TRUE;
+
+ this->SetHWAlpha = DSp_SetHWAlpha;
+ this->info.blit_hw_A = SDL_TRUE;
+ #endif
+
+ }
+
+ return(0);
+}
+
+static SDL_Rect **DSp_ListModes(_THIS, SDL_PixelFormat *format, Uint32 flags)
+{
+ static SDL_Rect *dsp_modes[16];
+ int i = 0, j = 0;
+
+ if ( format->BitsPerPixel == 0 )
+ return ( (SDL_Rect**) NULL );
+
+ while (SDL_modelist[i] != NULL) {
+
+ if (SDL_modelist[i]->x & format->BitsPerPixel) {
+ dsp_modes[j] = SDL_modelist[i];
+ j++;
+ }
+ i++;
+ }
+
+ dsp_modes[j] = NULL;
+
+ return dsp_modes;
+}
+
+/* Various screen update functions available */
+static void DSp_DirectUpdate(_THIS, int numrects, SDL_Rect *rects);
+
+#if ! TARGET_API_MAC_OSX
+
+static volatile unsigned int retrace_count = 0; /* -dw- need volatile because it updates asychronously */
+
+Boolean DSp_VBLProc ( DSpContextReference context, void *ref_con )
+{
+ retrace_count++;
+
+ return 1; /* Darrell, is this right? */
+}
+
+static void DSp_SetHWError (OSStatus err, int is_agp)
+{
+ char message[1024];
+ const char *fmt, *mem;
+
+ if ( is_agp ) {
+ mem = "AGP Memory";
+ } else {
+ mem = "VRAM";
+ }
+ switch(err) {
+ case memFullErr:
+ fmt = "Hardware surface possible but not enough %s available";
+ break;
+ case cDepthErr:
+ fmt = "Hardware surface possible but invalid color depth";
+ break;
+ default:
+ fmt = "Hardware surface could not be allocated in %s - unknown error";
+ break;
+ }
+ SDL_snprintf(message, SDL_arraysize(message), fmt, mem);
+ SDL_SetError(message);
+}
+#endif // TARGET_API_MAC_OSX
+
+/* put up a dialog to verify display change */
+static int DSp_ConfirmSwitch () {
+
+ /* resource id's for dialog */
+ const int rDialog = 1002;
+ const int bCancel = 1;
+ const int bOK = 2;
+
+ DialogPtr dialog;
+ OSStatus err;
+ SInt32 response;
+ DialogItemIndex item = 0;
+ GrafPtr savePort;
+
+ GetPort (&savePort);
+
+ dialog = GetNewDialog (rDialog, NULL, (WindowPtr) -1);
+ if (dialog == NULL)
+ return (0);
+
+#if TARGET_API_MAC_CARBON
+ SetPort (GetDialogPort(dialog));
+#else
+ SetPort ((WindowPtr) dialog);
+#endif
+
+ SetDialogDefaultItem (dialog, bCancel);
+ SetDialogCancelItem (dialog, bCancel);
+
+ SetEventMask (everyEvent);
+ FlushEvents (everyEvent, 0);
+
+ /* On MacOS 8.5 or later, we can make the dialog go away after 15 seconds */
+ /* This is good since it's possible user can't even see the dialog! */
+ /* Requires linking to DialogsLib */
+ err = Gestalt(gestaltSystemVersion,&response);
+ if (err == noErr && response >= 0x00000850) {
+ SetDialogTimeout(dialog, bCancel, 15);
+ }
+
+ do {
+
+ ModalDialog ( NULL, &item );
+
+ } while ( item != bCancel && item != bOK && err != noErr);
+
+
+ DisposeDialog (dialog);
+ SetPort (savePort);
+
+ SetEventMask(everyEvent - autoKeyMask);
+ FlushEvents(everyEvent, 0);
+
+ return (item - 1);
+}
+
+static void DSp_UnsetVideoMode(_THIS, SDL_Surface *current)
+{
+
+
+ if ( current->flags & SDL_OPENGL ) {
+ Mac_GL_Quit (this);
+ }
+
+ if (dsp_context != NULL) {
+
+ GWorldPtr front;
+ DSpContext_GetFrontBuffer (dsp_context, &front);
+
+ if (front != dsp_back_buffer)
+ DisposeGWorld (dsp_back_buffer);
+
+ if (current->hwdata)
+ SDL_free(current->hwdata);
+
+ DSpContext_SetState (dsp_context, kDSpContextState_Inactive );
+ DSpContext_Release (dsp_context);
+
+ dsp_context = NULL;
+ }
+
+ if (SDL_Window != NULL) {
+ DisposeWindow (SDL_Window);
+ SDL_Window = NULL;
+ }
+
+ current->pixels = NULL;
+ current->flags = 0;
+}
+
+static SDL_Surface *DSp_SetVideoMode(_THIS,
+ SDL_Surface *current, int width, int height, int bpp, Uint32 flags)
+{
+
+#if !TARGET_API_MAC_OSX
+ DisplayIDType display_id;
+ Fixed freq;
+#endif
+ DSpContextAttributes attrib;
+ OSStatus err;
+ UInt32 rmask = 0, gmask = 0, bmask = 0;
+
+ int page_count;
+ int double_buf;
+ int hw_surface;
+ int use_dsp_back_buffer;
+
+ DSp_UnsetVideoMode (this, current);
+
+ if (bpp != dsp_old_depth)
+ DSp_DestroyPalette (this);
+
+ double_buf = (flags & SDL_DOUBLEBUF) != 0;
+ hw_surface = (flags & SDL_HWSURFACE) != 0;
+ use_dsp_back_buffer = !dsp_vram_available || !hw_surface ;
+
+ current->flags |= SDL_FULLSCREEN;
+
+rebuild:
+
+ if ( double_buf && use_dsp_back_buffer ) {
+ page_count = 2;
+ } else {
+ page_count = 1;
+ }
+
+ SDL_memset (&attrib, 0, sizeof (DSpContextAttributes));
+ attrib.displayWidth = width;
+ attrib.displayHeight = height;
+ attrib.displayBestDepth = bpp;
+ attrib.backBufferBestDepth = bpp;
+ attrib.displayDepthMask = kDSpDepthMask_All;
+ attrib.backBufferDepthMask = kDSpDepthMask_All;
+ attrib.colorNeeds = kDSpColorNeeds_Require;
+ attrib.colorTable = 0;
+ attrib.pageCount = page_count;
+ #if TARGET_API_MAC_OSX || UNIVERSAL_INTERFACES_VERSION == 0x0320
+
+ if ( DSpFindBestContext (&attrib, &dsp_context) != noErr ) {
+ SDL_SetError ("DrawSprocket couldn't find a context");
+ return NULL;
+ }
+
+ #else
+ if ( noErr != DMGetDisplayIDByGDevice (SDL_Display, &display_id, SDL_FALSE) ) {
+ SDL_SetError ("Display Manager couldn't associate GDevice with display_id");
+ return NULL;
+ }
+ if ( DSpFindBestContextOnDisplayID(&attrib, &dsp_context, display_id) != noErr ) {
+ SDL_SetError ("DrawSprocket couldn't find a suitable context on given display");
+ return NULL;
+ }
+
+ #endif
+ if ( DSpContext_Reserve (dsp_context, &attrib) != noErr ) {
+ SDL_SetError ("DrawSprocket couldn't get the needed resources to build the display");
+ return NULL;
+ }
+
+ if ( (err = DSpContext_SetState (dsp_context, kDSpContextState_Active)) != noErr ) {
+
+ if (err == kDSpConfirmSwitchWarning) {
+
+ if ( ! DSp_ConfirmSwitch () ) {
+
+ DSpContext_Release (dsp_context);
+ dsp_context = NULL;
+ SDL_SetError ("User cancelled display switch");
+ return NULL;
+ }
+ else
+ /* Have to reactivate context. Why? */
+ DSpContext_SetState (dsp_context, kDSpContextState_Active);
+
+ }
+ else {
+ SDL_SetError ("DrawSprocket couldn't activate the context");
+ return NULL;
+ }
+ }
+
+
+ if (bpp != dsp_old_depth) {
+
+ DSp_CreatePalette (this);
+
+ /* update format if display depth changed */
+ if (bpp == 16) {
+
+ rmask = 0x00007c00;
+ gmask = 0x000003e0;
+ bmask = 0x0000001f;
+ }
+ if ( ! SDL_ReallocFormat (current, bpp, rmask, gmask, bmask, 0 ) ) {
+
+ SDL_SetError ("Could not reallocate video format.");
+ return(NULL);
+ }
+ }
+
+ if (!double_buf) {
+
+ /* single-buffer context */
+ DSpContext_GetFrontBuffer (dsp_context, &dsp_back_buffer);
+
+ current->hwdata = (private_hwdata*) SDL_malloc (sizeof (private_hwdata));
+ if (current ->hwdata == NULL) {
+ SDL_OutOfMemory ();
+ return NULL;
+ }
+ current->hwdata->offscreen = dsp_back_buffer;
+ current->flags |= SDL_HWSURFACE;
+ this->UpdateRects = DSp_DirectUpdate;
+ }
+ else if ( use_dsp_back_buffer ) {
+
+ DSpContext_GetBackBuffer (dsp_context, kDSpBufferKind_Normal, &dsp_back_buffer);
+
+ current->flags |= SDL_DOUBLEBUF | SDL_SWSURFACE; /* only front buffer is in VRAM */
+ this->UpdateRects = DSp_DSpUpdate;
+ }
+ else if ( DSp_NewHWSurface(this, &dsp_back_buffer, bpp, width-1, height-1) == 0 ) {
+
+ current->hwdata = (private_hwdata*) SDL_malloc (sizeof (private_hwdata));
+ if (current ->hwdata == NULL) {
+ SDL_OutOfMemory ();
+ return NULL;
+ }
+
+ SDL_memset (current->hwdata, 0, sizeof (private_hwdata));
+ current->hwdata->offscreen = dsp_back_buffer;
+ current->flags |= SDL_DOUBLEBUF | SDL_HWSURFACE;
+ this->UpdateRects = DSp_DirectUpdate; /* hardware doesn't do update rects, must be page-flipped */
+ }
+ else {
+
+ DSpContext_Release (dsp_context);
+ use_dsp_back_buffer = SDL_TRUE;
+ goto rebuild;
+ }
+
+ current->pitch = GetPortPixRowBytes(dsp_back_buffer) & 0x3FFF;
+ current->pixels = GetPixBaseAddr(GetPortPixMap(dsp_back_buffer));
+
+ current->w = width;
+ current->h = height;
+
+ #if ! TARGET_API_MAC_OSX
+
+ if (use_dsp_back_buffer) {
+
+ DSpContext_GetMonitorFrequency (dsp_context, &freq);
+ DSpContext_SetMaxFrameRate (dsp_context, freq >> 16);
+ }
+
+
+ if ( (current->flags & SDL_HWSURFACE) || (current->flags & SDL_OPENGL) )
+ DSpContext_SetVBLProc (dsp_context, DSp_VBLProc, NULL);
+ #endif
+
+ if (bpp == 8)
+ current->flags |= SDL_HWPALETTE;
+
+ if (flags & SDL_OPENGL) {
+
+ Rect rect;
+ RGBColor rgb = { 0.0, 0.0, 0.0 };
+ GrafPtr save_port;
+
+ SetRect (&rect, 0, 0, width, height);
+ SDL_Window = NewCWindow(nil, &( (**SDL_Display).gdRect), "\p", SDL_TRUE, plainDBox, (WindowPtr)-1, SDL_FALSE, 0);
+
+ if (SDL_Window == NULL) {
+
+ SDL_SetError ("DSp_SetVideoMode : OpenGL window could not be created.");
+ return NULL;
+ }
+
+ /* Set window color to black to avoid white flash*/
+ GetPort (&save_port);
+#if TARGET_API_MAC_CARBON
+ SetPort (GetWindowPort(SDL_Window));
+#else
+ SetPort (SDL_Window);
+#endif
+ RGBForeColor (&rgb);
+ PaintRect (&rect);
+ SetPort (save_port);
+
+ SetPortWindowPort (SDL_Window);
+ SelectWindow (SDL_Window);
+
+ if ( Mac_GL_Init (this) < 0 ) {
+
+ SDL_SetError ("DSp_SetVideoMode : could not create OpenGL context.");
+ return NULL;
+ }
+
+ current->flags |= SDL_OPENGL;
+ }
+
+ return current;
+}
+
+#ifdef DSP_TRY_CC_AND_AA
+
+static int DSp_MakeHWMask (_THIS, SDL_Surface *surface)
+{
+ GDHandle save_device;
+ CGrafPtr save_port;
+ GWorldPtr temp;
+ RGBColor black = { 0, 0, 0 };
+ RGBColor white = { 0xFFFF, 0xFFFF, 0xFFFF };
+ Rect rect;
+
+ Uint32 depth = GetPixDepth ( GetGDevPixMap (SDL_Display) );
+
+ SetRect (&rect, 0, 0, surface->w, surface->h);
+
+ if ( noErr != NewGWorld (&(surface->hwdata->mask), depth, &rect, 0, SDL_Display, 0 ) < 0 ) {
+
+ SDL_OutOfMemory ();
+ return (-1);
+ }
+
+ if ( noErr != NewGWorld (&temp, depth, &rect, 0 , SDL_Display, 0 ) ) {
+
+ SDL_OutOfMemory ();
+ return (-1);
+ }
+
+
+ GetGWorld (&save_port, &save_device);
+ SetGWorld (surface->hwdata->mask, SDL_Display);
+
+ RGBForeColor (&white);
+ PaintRect (&rect);
+
+ RGBBackColor (&(surface->hwdata->trans));
+
+ CopyBits ( GetPortBitMapForCopyBits(surface->hwdata->offscreen),
+ GetPortBitMapForCopyBits(surface->hwdata->mask),
+ &rect, &rect, transparent, NULL );
+
+ SetGWorld (surface->hwdata->mask, SDL_Display);
+ SetGWorld (save_port, save_device);
+ return (0);
+}
+
+static int DSp_SetHWAlpha(_THIS, SDL_Surface *surface, UInt8 alpha)
+{
+ surface->hwdata->alpha.red = (alpha / 255.0) * 65535;
+ surface->hwdata->alpha.blue = (alpha / 255.0) * 65535;
+ surface->hwdata->alpha.green = (alpha / 255.0) * 65535;
+
+ surface->flags |= SDL_SRCALPHA;
+
+ if (surface->flags & SDL_SRCCOLORKEY) {
+ return(DSp_MakeHWMask (this, surface));
+ }
+ return(0);
+}
+
+static int DSp_SetHWColorKey(_THIS, SDL_Surface *surface, Uint32 key)
+{
+ CGrafPtr save_port;
+ GDHandle save_device;
+
+ GetGWorld (&save_port, &save_device);
+ SetGWorld (surface->hwdata->offscreen, NULL);
+
+ Index2Color (key, &(surface->hwdata->trans));
+ surface->flags |= SDL_SRCCOLORKEY;
+
+ SetGWorld (save_port, save_device);
+
+ if ( surface->flags & SDL_SRCALPHA ) {
+ return(DSp_MakeHWMask (this, surface));
+ }
+ return(0);
+}
+
+#endif /* DSP_TRY_CC_AND_AA */
+
+static int DSp_NewHWSurface(_THIS, CGrafPtr *port, int depth, int width, int height) {
+
+ OSStatus err;
+ Rect bounds;
+
+ SetRect (&bounds, 0, 0, width, height);
+
+ #if useDistantHdwrMem && useLocalHdwrMem
+ if (dsp_vram_available) {
+ /* try VRAM */
+ err = NewGWorld (port, depth, &bounds, 0 , SDL_Display, useDistantHdwrMem | noNewDevice );
+ if (err != noErr)
+ DSp_SetHWError (err, SDL_FALSE);
+ else
+ return (0);
+ }
+
+ if (dsp_agp_available) {
+ /* try AGP */
+ err = NewGWorld (port, depth, &bounds, 0 , SDL_Display, useLocalHdwrMem | noNewDevice );
+
+ if (err != noErr)
+ DSp_SetHWError (err, SDL_TRUE);
+ else
+ return (0);
+ }
+#endif
+
+ return (-1);
+}
+
+static int DSp_AllocHWSurface(_THIS, SDL_Surface *surface)
+{
+ GWorldPtr temp;
+
+ if ( DSp_NewHWSurface (this, &temp, surface->format->BitsPerPixel, surface->w, surface->h) < 0 )
+ return (-1);
+
+ surface->hwdata = (private_hwdata*) SDL_malloc (sizeof (private_hwdata));
+ if (surface->hwdata == NULL) {
+ SDL_OutOfMemory ();
+ return -1;
+ }
+
+ SDL_memset (surface->hwdata, 0, sizeof(private_hwdata));
+ surface->hwdata->offscreen = temp;
+ surface->pitch = GetPixRowBytes (GetPortPixMap (temp)) & 0x3FFF;
+ surface->pixels = GetPixBaseAddr (GetPortPixMap (temp));
+ surface->flags |= SDL_HWSURFACE;
+#ifdef DSP_TRY_CC_AND_AA
+ surface->flags |= SDL_HWACCEL;
+#endif
+ return 0;
+}
+
+static void DSp_FreeHWSurface(_THIS, SDL_Surface *surface)
+{
+ if (surface->hwdata->offscreen != NULL)
+ DisposeGWorld (surface->hwdata->offscreen);
+ SDL_free(surface->hwdata);
+
+ surface->pixels = NULL;
+}
+
+static int DSp_CheckHWBlit(_THIS, SDL_Surface *src, SDL_Surface *dest)
+{
+ int accelerated;
+
+ /* Set initial acceleration on */
+ src->flags |= SDL_HWACCEL;
+
+ /* Set the surface attributes */
+ if ( (src->flags & SDL_SRCALPHA) == SDL_SRCALPHA ) {
+ if ( ! this->info.blit_hw_A ) {
+ src->flags &= ~SDL_HWACCEL;
+ }
+ }
+ if ( (src->flags & SDL_SRCCOLORKEY) == SDL_SRCCOLORKEY ) {
+ if ( ! this->info.blit_hw_CC ) {
+ src->flags &= ~SDL_HWACCEL;
+ }
+ }
+
+ /* Check to see if final surface blit is accelerated */
+ accelerated = !!(src->flags & SDL_HWACCEL);
+ if ( accelerated ) {
+ src->map->hw_blit = DSp_HWAccelBlit;
+ }
+ return(accelerated);
+}
+
+static int DSp_HWAccelBlit(SDL_Surface *src, SDL_Rect *srcrect,
+ SDL_Surface *dst, SDL_Rect *dstrect)
+{
+ CGrafPtr save_port;
+ GDHandle save_device;
+ Rect src_rect, dst_rect;
+ RGBColor black = { 0, 0, 0 };
+ RGBColor white = { 0xFFFF, 0xFFFF, 0xFFFF };
+
+#ifdef DSP_TRY_CC_AND_AA
+ UInt32 mode;
+#endif
+
+ SetRect (&src_rect, srcrect->x, srcrect->y, srcrect->x + srcrect->w, srcrect->y + srcrect->h);
+ SetRect (&dst_rect, dstrect->x, dstrect->y, dstrect->x + dstrect->w, dstrect->y + dstrect->h);
+
+ GetGWorld (&save_port, &save_device);
+ SetGWorld (dst->hwdata->offscreen, NULL);
+
+ RGBForeColor (&black);
+ RGBBackColor (&white);
+
+#ifdef DSP_TRY_CC_AND_AA
+
+ if ( (src->flags & SDL_SRCCOLORKEY) &&
+ (src->flags & SDL_SRCALPHA) ) {
+
+ OpColor (&(src->hwdata->alpha));
+
+ CopyDeepMask ( GetPortBitMapForCopyBits(src->hwdata->offscreen),
+ GetPortBitMapForCopyBits(src->hwdata->mask),
+ GetPortBitMapForCopyBits(dst->hwdata->offscreen),
+ &src_rect, &src_rect, &dst_rect,
+ blend,
+ NULL );
+ }
+ else {
+
+ if ( src->flags & SDL_SRCCOLORKEY) {
+ RGBBackColor (&(src->hwdata->trans) );
+ mode = transparent;
+ }
+ else if (src->flags & SDL_SRCALPHA) {
+
+ OpColor (&(src->hwdata->alpha));
+ mode = blend;
+ }
+ else {
+
+ mode = srcCopy;
+ }
+
+ CopyBits ( GetPortBitMapForCopyBits(src->hwdata->offscreen),
+ GetPortBitMapForCopyBits(dst->hwdata->offscreen),
+ &src_rect, &dst_rect, mode, NULL );
+ }
+#else
+
+ CopyBits ( &(((GrafPtr)(src->hwdata->offscreen))->portBits),
+ &(((GrafPtr)(dst->hwdata->offscreen))->portBits),
+ &src_rect, &dst_rect, srcCopy, NULL );
+
+#endif /* DSP_TRY_CC_AND_AA */
+
+ SetGWorld (save_port, save_device);
+
+ return(0);
+}
+
+static int DSp_FillHWRect(_THIS, SDL_Surface *dst, SDL_Rect *rect, Uint32 color)
+{
+ CGrafPtr save_port;
+ GDHandle save_device;
+ Rect fill_rect;
+ RGBColor rgb;
+
+ SetRect (&fill_rect, rect->x, rect->y, rect->x + rect->w, rect->y + rect->h);
+
+ GetGWorld (&save_port, &save_device);
+ SetGWorld (dst->hwdata->offscreen, NULL);
+
+ Index2Color (color, &rgb);
+
+ RGBForeColor (&rgb);
+ PaintRect (&fill_rect);
+
+ SetGWorld (save_port, save_device);
+
+ return(0);
+}
+
+static int DSp_FlipHWSurface(_THIS, SDL_Surface *surface)
+{
+ if ( (surface->flags & SDL_HWSURFACE) ) {
+ CGrafPtr dsp_front_buffer, save_port;
+ Rect rect;
+
+ #if ! TARGET_API_MAC_OSX
+ unsigned int old_count;
+ #endif
+
+ /* pseudo page flipping for VRAM back buffer*/
+ DSpContext_GetFrontBuffer (dsp_context, &dsp_front_buffer);
+ SetRect (&rect, 0, 0, surface->w-1, surface->h-1);
+
+ GetPort ((GrafPtr *)&save_port);
+ SetPort ((GrafPtr)dsp_front_buffer);
+
+ /* wait for retrace */
+ /* I have tried doing the swap in interrupt routine (VBL Proc) to do */
+ /* it asynchronously, but apparently CopyBits isn't interrupt safe */
+
+ #if ! TARGET_API_MAC_OSX
+ #ifndef DSP_NO_SYNC_VBL
+ old_count = retrace_count;
+ while (old_count == retrace_count)
+ ;
+ #endif
+ #endif
+
+ CopyBits ( GetPortBitMapForCopyBits(dsp_back_buffer),
+ GetPortBitMapForCopyBits(dsp_front_buffer),
+ &rect, &rect, srcCopy, NULL );
+
+ SetPort ((GrafPtr)save_port);
+
+ } else {
+ /* not really page flipping at all: DSp just blits the dirty rectangles from DSp_UpdateRects */
+ Boolean busy_flag;
+ DSpContext_SwapBuffers (dsp_context, NULL, &busy_flag); /* this waits for VBL */
+ DSpContext_GetBackBuffer (dsp_context, kDSpBufferKind_Normal, &dsp_back_buffer);
+ surface->pixels = GetPixBaseAddr( GetPortPixMap(dsp_back_buffer) );
+ }
+ return(0);
+}
+
+static int DSp_LockHWSurface(_THIS, SDL_Surface *surface)
+{
+ if ( LockPixels (GetGWorldPixMap (surface->hwdata->offscreen)) )
+ return 0;
+ else
+ return -1;
+}
+
+static void DSp_UnlockHWSurface(_THIS, SDL_Surface *surface)
+{
+ UnlockPixels (GetGWorldPixMap (surface->hwdata->offscreen));
+}
+
+static void DSp_DirectUpdate(_THIS, int numrects, SDL_Rect *sdl_rects)
+{
+ return;
+}
+
+static void DSp_DSpUpdate(_THIS, int numrects, SDL_Rect *sdl_rects)
+{
+#if ! TARGET_API_MAC_OSX /* Unsupported DSp in here */
+ int i;
+ Rect rect;
+
+ for (i = 0; i < numrects; i++) {
+
+ rect.top = sdl_rects[i].y;
+ rect.left = sdl_rects[i].x;
+ rect.bottom = sdl_rects[i].h + sdl_rects[i].y;
+ rect.right = sdl_rects[i].w + sdl_rects[i].x;
+
+ DSpContext_InvalBackBufferRect (dsp_context, &rect);
+ }
+#endif
+}
+
+static int DSp_CreatePalette(_THIS) {
+
+
+ /* Create our palette */
+ SDL_CTab = (CTabHandle)NewHandle(sizeof(ColorSpec)*256 + 8);
+ if ( SDL_CTab == nil ) {
+ SDL_OutOfMemory();
+ return(-1);
+ }
+ (**SDL_CTab).ctSeed = GetCTSeed();
+ (**SDL_CTab).ctFlags = 0;
+ (**SDL_CTab).ctSize = 255;
+ CTabChanged(SDL_CTab);
+ SDL_CPal = NewPalette(256, SDL_CTab, pmExplicit+pmTolerant, 0);
+
+ return 0;
+}
+
+static int DSp_DestroyPalette(_THIS) {
+
+ /* Free palette and restore original one */
+ if ( SDL_CTab != nil ) {
+ DisposeHandle((Handle)SDL_CTab);
+ SDL_CTab = nil;
+ }
+ if ( SDL_CPal != nil ) {
+ DisposePalette(SDL_CPal);
+ SDL_CPal = nil;
+ }
+ RestoreDeviceClut(SDL_Display);
+
+ return (0);
+}
+
+static int DSp_SetColors(_THIS, int firstcolor, int ncolors, SDL_Color *colors)
+{
+ CTabHandle cTab;
+
+ int i;
+
+ cTab = SDL_CTab;
+
+ /* Verify the range of colors */
+ if ( (firstcolor+ncolors) > ((**cTab).ctSize+1) ) {
+ return(0);
+ }
+
+ /* Set the screen palette and update the display */
+ for(i = 0; i < ncolors; i++) {
+ int j = firstcolor + i;
+ (**cTab).ctTable[j].value = j;
+ (**cTab).ctTable[j].rgb.red = colors[i].r << 8 | colors[i].r;
+ (**cTab).ctTable[j].rgb.green = colors[i].g << 8 | colors[i].g;
+ (**cTab).ctTable[j].rgb.blue = colors[i].b << 8 | colors[i].b;
+ }
+
+ SetGDevice(SDL_Display);
+ SetEntries(0, (**cTab).ctSize, (ColorSpec *)&(**cTab).ctTable);
+
+ return(1);
+}
+
+void DSp_VideoQuit(_THIS)
+{
+ int i;
+
+ /* Free current video mode */
+ DSp_UnsetVideoMode(this, this->screen);
+
+ /* Free Palette and restore original */
+ DSp_DestroyPalette (this);
+
+#if SDL_MACCLASSIC_GAMMA_SUPPORT
+ Mac_QuitGamma(this);
+#endif
+
+ /* Free list of video modes */
+ if ( SDL_modelist != NULL ) {
+ for ( i=0; SDL_modelist[i]; i++ ) {
+ SDL_free(SDL_modelist[i]);
+ }
+ SDL_free(SDL_modelist);
+ SDL_modelist = NULL;
+ }
+
+ /* Unload DrawSprocket */
+ DSpShutdown ();
+}
+
+#if SDL_VIDEO_OPENGL
+
+/* swap buffers with v-sync */
+static void DSp_GL_SwapBuffers (_THIS) {
+
+ #ifndef DSP_NO_SYNC_OPENGL
+
+ unsigned int old_count;
+
+ old_count = retrace_count;
+ while (old_count == retrace_count)
+ ;
+ #endif
+
+ aglSwapBuffers (glContext);
+}
+
+#endif