1 /*

     2     SDL - Simple DirectMedia Layer

     3     Copyright (C) 1997-2006 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