src/video/macdsp/SDL_dspvideo.c

   1 /*
   2     SDL - Simple DirectMedia Layer
   3     Copyright (C) 1997-2009 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