Merge changes I505c4aea,I2ae0529c

* changes:
  Import SDL release-1.2.15
  Handle SDL windows with BGRA color

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