/*

SDL - Simple DirectMedia Layer

This library is free software; you can redistribute it and/or

This library is distributed in the hope that it will be useful,

but WITHOUT ANY WARRANTY; without even the implied warranty of

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

You should have received a copy of the GNU Lesser General Public

License along with this library; if not, write to the Free Software

Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA

Sam Lantinga

/*

Written by Darrell Walisser <dwaliss1@purdue.edu>

Implementation notes ----------------------------------------------------------------------

A bit on GWorlds in VRAM from technote 1182:

There are two important things to note about GWorld's allocated in

VRAM. First, the base address retrieved through GetPixBaseAddr or

read directly from the PixMap structure can become invalid anytime

memory is allocated in VRAM. This can occur either by explicit

allocations, such as calls to NewGWorld, or by implicit ones, such as

those associated with the internal texture allocation of OpenGL. The

stored pixel images themselves will still be valid but may have been

moved in VRAM, thus rendering any stored base addresses invalid.

You should never store an image's base address for longer than is

necessary and especially never across calls to NewGWorld or

texture-creation routines.

Secondly, an offscreen pixel image allocated in VRAM can be

purged at system task time by the display driver. This means any

time your application yields time such by calling WaitNextEvent or

SystemTask you can lose your VRAM GWorld contents. While this

happens infrequently, usually associated with display resolution or

pixel depth changes you must code for this eventuality. This purge

can occur whether or not the GWorld is locked or not. A return value

of false from LockPixels, a NULL return value from GetPixBaseAddr

or NULL in the baseAddr field of the PixMap mean that the pixel

image has been purged. To reallocate it you can either call

UpdateGWorld or Dispose your current GWorld through

DisposeGWorld and reallocate it via NewGWorld. Either way you must

then rebuild the pixel image.

------------------------------------------------------------------------------------

Currently, I don't account for (1). In my testing, NewGWorld never invalidated

other existing GWorlds in VRAM. However, I do have protection for (2).

Namely, I am using GetOSEvent() instead of WaitNextEvent() so that there are no

context switches (the app hogs the CPU). Eventually a book-keeping system should

be coded to take care of (1) and (2).

------------------------------------------------------------------------------------

System requirements (* denotes optional):

1. DrawSprocket 1.7.3

3. *May also require certain graphics hardware for (2). I trust that all Apple OEM

hardware will work. Third party accelerators may work if they have QuickDraw

acceleration in the drivers and the drivers have been updated for OS 9. The current

Voodoo 3 drivers (1.0b12) do not work.

Coding suggestions:

1. Use SDL_UpdateRects !

If no QuickDraw acceleration is present, double-buffered surfaces will use a back buffer

in System memory. I recommend you use SDL_UpdateRects with double-buffered surfaces

for best performance on these cards, since the overhead is nearly zero for VRAM back buffer.

2. Load most-resident surfaces first.

If you fill up VRAM or AGP memory, there is no contingency for purging to make room for the next one.

Therefore, you should load the surfaces you plan to use the most frequently first.

Sooner or later, I will code LRU replacement to help this.

TODO:

Some kind of posterized mode for resolutions < 640x480.

Window support / fullscreen toggle.

Figure out how much VRAM is available. Put in video->info->video_mem.

Track VRAM usage.

BUGS:

I can't create a hardware surface the same size as the screen?! How to fix?

COMPILE OPTIONS:

DSP_TRY_CC_AND_AA - Define if you want to try HWA color-key and alpha blitters

HW color-key blitting gives substantial improvements,

but hw alpha is neck-and-neck with SDL's soft bitter.

DSP_NO_SYNC_VBL - Define for HWA double-buffered surfaces: don't sync

pseudo-flip to monitor redraw.

DSP_NO_SYNC_OPENGL - Define for OpenGL surfaces: don't sync buffer swap. Synching buffer

swap may result in reduced performance, but can eliminate some

tearing artifacts.

CHANGELOG:

09/17/00 Lots of little tweaks. Build modelist in reverse order so largest contexts

list first. Compared various methods with ROM methods and fixed rez switch

crashing bug in GL Tron. (Woohoo!)

*/

#define DSP_TRY_CC_AND_AA

/* #define DSP_NO_SYNC_VBL */

#define DSP_NO_SYNC_OPENGL

#if defined(__APPLE__) && defined(__MACH__)

#include <Carbon/Carbon.h>

#include <DrawSprocket/DrawSprocket.h>

#elif TARGET_API_MAC_CARBON && (UNIVERSAL_INTERFACES_VERSION > 0x0335)

#else

#include <LowMem.h>

#include <Gestalt.h>

#include <Devices.h>

#include <DiskInit.h>

#include <QDOffscreen.h>

#endif

#include "SDL_video.h"

#include "SDL_syswm.h"

#include "../SDL_sysvideo.h"

#include "../SDL_blit.h"

#include "../SDL_pixels_c.h"

#include "../maccommon/SDL_macgl_c.h"

#include "../maccommon/SDL_macwm_c.h"

#include "../maccommon/SDL_macmouse_c.h"

#include "../maccommon/SDL_macevents_c.h"

/* Initialization/Query functions */

static int DSp_VideoInit(_THIS, SDL_PixelFormat * vformat);

static SDL_Rect **DSp_ListModes(_THIS, SDL_PixelFormat * format,

Uint32 flags);

static SDL_Surface *DSp_SetVideoMode(_THIS, SDL_Surface * current, int width,

int height, int bpp, Uint32 flags);

static int DSp_SetColors(_THIS, int firstcolor, int ncolors,

SDL_Color * colors);

static int DSp_CreatePalette(_THIS);

static int DSp_DestroyPalette(_THIS);

static void DSp_VideoQuit(_THIS);

static int DSp_GetMainDevice(_THIS, GDHandle * device);

static void DSp_IsHWAvailable(_THIS, SDL_PixelFormat * vformat);

static void DSp_DSpUpdate(_THIS, int numrects, SDL_Rect * sdl_rects);

static void DSp_DirectUpdate(_THIS, int numrects, SDL_Rect * sdl_rects);

/* Hardware surface functions */

static int DSp_SetHWAlpha(_THIS, SDL_Surface * surface, UInt8 alpha);

static int DSp_SetHWColorKey(_THIS, SDL_Surface * surface, Uint32 key);

static int DSp_NewHWSurface(_THIS, CGrafPtr * port, int depth, int width,

int height);

static int DSp_AllocHWSurface(_THIS, SDL_Surface * surface);

static int DSp_LockHWSurface(_THIS, SDL_Surface * surface);

static void DSp_UnlockHWSurface(_THIS, SDL_Surface * surface);

static void DSp_FreeHWSurface(_THIS, SDL_Surface * surface);

static int DSp_FlipHWSurface(_THIS, SDL_Surface * surface);

static int DSp_CheckHWBlit(_THIS, SDL_Surface * src, SDL_Surface * dest);

static int DSp_HWAccelBlit(SDL_Surface * src, SDL_Rect * srcrect,

SDL_Surface * dst, SDL_Rect * dstrect);

static int DSp_FillHWRect(_THIS, SDL_Surface * dst, SDL_Rect * rect,

Uint32 color);

#endif

#if ! TARGET_API_MAC_CARBON

#define GetPortPixRowBytes(x) ( (*(x->portPixMap))->rowBytes )

#define GetGDevPixMap(x) ((**(x)).gdPMap)

#define GetPortPixMap(x) ((*(x)).portPixMap)

#define GetPixDepth(y) ((**(y)).pixelSize)

//#define GetPixRowBytes(y) ((**(y)).rowBytes)

//#define GetPixBaseAddr(y) ((**(y)).baseAddr)

#define GetPixCTab(y) ((**(y)).pmTable)

#define GetPortBitMapForCopyBits(x) (&(((GrafPtr)(x))->portBits))

#define GetPortPixRowBytes(x) (GetPixRowBytes(GetPortPixMap(x)) )

#define GetGDevPixMap(x) ((**(x)).gdPMap)

#endif

typedef struct private_hwdata

{

GWorldPtr offscreen; // offscreen gworld in VRAM or AGP

#ifdef DSP_TRY_CC_AND_AA

GWorldPtr mask; // transparent mask

RGBColor alpha; // alpha color

RGBColor trans; // transparent color

#endif

} private_hwdata;

/* Macintosh toolbox driver bootstrap functions */

/* This check is only meaningful if you weak-link DrawSprocketLib */

return ((Ptr) DSpStartup != (Ptr) kUnresolvedCFragSymbolAddress);

}

/* -dw- taking no chances with null pointers */

if (device) {

if (device->hidden) {

if (device->hidden->dspinfo)

}

SDL_VideoDevice *device;

/* Initialize all variables that we clean on shutdown */

}

if ((device == NULL) || (device->hidden == NULL)) {

if (device) {

if (device->hidden)

}

return (NULL);

}

/* Allocate DrawSprocket information */

device->hidden->dspinfo = (struct DSpInfo *) SDL_malloc((sizeof *device->

hidden->

dspinfo));

SDL_OutOfMemory();

SDL_free(device->hidden);

SDL_free(device);

return (0);

}

/* Set the function pointers */

device->VideoInit = DSp_VideoInit;

device->ListModes = DSp_ListModes;

device->SetVideoMode = DSp_SetVideoMode;

device->SetColors = DSp_SetColors;

device->UpdateRects = NULL;

device->VideoQuit = DSp_VideoQuit;

device->AllocHWSurface = DSp_AllocHWSurface;

device->CheckHWBlit = NULL;

device->FillHWRect = NULL;

device->SetHWColorKey = NULL;

device->SetHWAlpha = NULL;

device->LockHWSurface = DSp_LockHWSurface;

device->UnlockHWSurface = DSp_UnlockHWSurface;

device->FlipHWSurface = DSp_FlipHWSurface;

device->FreeHWSurface = DSp_FreeHWSurface;

device->GL_MakeCurrent = Mac_GL_MakeCurrent;

device->GL_SwapBuffers = DSp_GL_SwapBuffers;

device->GL_LoadLibrary = Mac_GL_LoadLibrary;

device->GL_GetProcAddress = Mac_GL_GetProcAddress;

device->SetCaption = NULL;

device->SetIcon = NULL;

device->IconifyWindow = NULL;

device->GrabInput = NULL;

device->GetWMInfo = NULL;

device->FreeWMCursor = Mac_FreeWMCursor;

device->CreateWMCursor = Mac_CreateWMCursor;

device->ShowWMCursor = Mac_ShowWMCursor;

device->WarpWMCursor = Mac_WarpWMCursor;

device->InitOSKeymap = Mac_InitOSKeymap;

device->PumpEvents = Mac_PumpEvents;

device->GrabInput = NULL;

device->CheckMouseMode = NULL;

device->free = DSp_DeleteDevice;

return device;

}

VideoBootStrap DSp_bootstrap = {

"DSp", "MacOS DrawSprocket",

DSp_Available, DSp_CreateDevice

};

/* Use DSp/Display Manager to build mode list for given screen */

DSp_BuildModeList(const GDHandle gDevice, int *displayWidth,

int *displayHeight)

DSpContextAttributes attributes;

DSpContextReference context;

DisplayIDType displayID;

SDL_Rect temp_list[16];

SDL_Rect **mode_list;

int width, height, i, j;

#if TARGET_API_MAC_OSX

displayID = 0;

#else

/* Ask Display Manager for integer id of screen device */

return NULL;

}

#endif

/* Get the first possible DSp context on this device */

return NULL;

}

return NULL;

*displayWidth = attributes.displayWidth;

*displayHeight = attributes.displayHeight;

width = attributes.displayWidth;

height = attributes.displayHeight;

temp_list[i].x = 0 | attributes.displayBestDepth;

temp_list[i].y = 0;

temp_list[i].w = width;

temp_list[i].h = height;

/* DSp will report many different contexts with the same width and height. */

/* They will differ in bit depth and refresh rate. */

/* We will ignore them until we reach one with a different width/height */

/* When there are no more contexts to look at, we will quit building the list */

while (width == attributes.displayWidth

&& height == attributes.displayHeight) {

if (err != noErr)

if (err == kDSpContextNotFoundErr)

goto done;

else

return NULL;

return NULL;

temp_list[i].x |= attributes.displayBestDepth;

}

}

done:

i++; /* i was not incremented before kicking out of the loop */

if (mode_list) {

/* -dw- new stuff: build in reverse order so largest sizes list first */

for (j = i - 1; j >= 0; j--) {

return NULL;

}

}

mode_list[i] = NULL; /* append null to the end */

} else {

return NULL;

}

return mode_list;

}

/*

VRAM GWorlds are only available on OS 9 or later.

Even with OS 9, some display drivers won't support it,

so we create a test GWorld and check for errors.

*/

long versionSystem;

dsp_vram_available = SDL_FALSE;

dsp_agp_available = SDL_FALSE;

if (0x00000860 < (versionSystem & 0x0000FFFF)) {

GWorldPtr offscreen;

OSStatus err;

Rect bounds;

NewGWorld(&offscreen, vformat->BitsPerPixel, &bounds, NULL,

SDL_Display, useDistantHdwrMem | noNewDevice);

if (err == noErr) {

dsp_vram_available = SDL_TRUE;

}

err =

NewGWorld(&offscreen, vformat->BitsPerPixel, &bounds, NULL,

SDL_Display, useLocalHdwrMem | noNewDevice);

dsp_agp_available = SDL_TRUE;

}

}

#else

DSpContextAttributes attrib;

DSpContextReference context;

DisplayIDType display_id;

GDHandle main_device;

GDHandle device_list;

device_list = GetDeviceList();

main_device = GetMainDevice();

/* Quick check to avoid slower method when only one display exists */

if ((**device_list).gdNextGD == NULL) {

*device = main_device;

return 0;

}

/* These attributes are hopefully supported on all devices... */

attrib.displayWidth = 640;

attrib.displayHeight = 480;

attrib.displayBestDepth = 8;

attrib.backBufferBestDepth = 8;

attrib.displayDepthMask = kDSpDepthMask_All;

attrib.backBufferDepthMask = kDSpDepthMask_All;

attrib.colorNeeds = kDSpColorNeeds_Require;

attrib.pageCount = 1;

SDL_SetError

("Display Manager couldn't associate GDevice with a Display ID");

return (-1);

}

/* Put up dialog on main display to select which display to use */

if (noErr != DSpUserSelectContext(&attrib, display_id, NULL, &context)) {

SDL_SetError("DrawSprocket couldn't create a context");

return (-1);

}

if (noErr != DSpContext_GetDisplayID(context, &display_id)) {

SDL_SetError("DrawSprocket couldn't get display ID");

return (-1);

}

SDL_SetError

("Display Manager couldn't associate Display ID with GDevice");

return (-1);

}

*device = main_device;

return (0);

#endif

}

NumVersion dsp_version = { 0x01, 0x00, 0x00, 0x00 };

if ((dsp_version.majorRev == 1 && dsp_version.minorAndBugRev < 0x73) ||

(dsp_version.majorRev < 1)) {

/* StandardAlert (kAlertStopAlert, "\pError!",

"\pI need DrawSprocket 1.7.3 or later!\n"

"You can find a newer version at http://www.apple.com/swupdates.",

NULL, NULL);

*/

return (-1);

}

if (DSpStartup() != noErr) {

SDL_SetError("DrawSprocket couldn't startup");

return (-1);

}

/* Start DSpintosh events */

/* Get a handle to the main monitor, or choose one on multiple monitor setups */

return (-1);

/* Determine pixel format */

dsp_old_depth = vformat->BitsPerPixel;

switch (vformat->BitsPerPixel) {

case 16:

vformat->Rmask = 0x00007c00;

vformat->Gmask = 0x000003e0;

vformat->Bmask = 0x0000001f;

break;

default:

break;

}

if (DSp_CreatePalette(this) < 0) {

SDL_SetError("Could not create palette");

return (-1);

}

/* Get a list of available fullscreen modes */

SDL_modelist = DSp_BuildModeList(SDL_Display,

&this->info.current_w,

&this->info.current_h);

return (-1);

}

/* Check for VRAM and AGP GWorlds for HW Blitting */

this->info.wm_available = 0;

if (dsp_vram_available || dsp_agp_available) {

this->info.hw_available = SDL_TRUE;

this->CheckHWBlit = DSp_CheckHWBlit;

this->info.blit_hw = SDL_TRUE;

this->FillHWRect = DSp_FillHWRect;

this->info.blit_fill = SDL_TRUE;

#ifdef DSP_TRY_CC_AND_AA

this->SetHWColorKey = DSp_SetHWColorKey;

this->info.blit_hw_CC = SDL_TRUE;

this->SetHWAlpha = DSp_SetHWAlpha;

this->info.blit_hw_A = SDL_TRUE;

#endif

}

return (0);

}

static SDL_Rect *dsp_modes[16];

int i = 0, j = 0;

if (format->BitsPerPixel == 0)

return ((SDL_Rect **) NULL);

while (SDL_modelist[i] != NULL) {

if (SDL_modelist[i]->x & format->BitsPerPixel) {

dsp_modes[j] = SDL_modelist[i];

j++;

}

i++;

}

dsp_modes[j] = NULL;

return dsp_modes;

}

/* Various screen update functions available */

#if ! TARGET_API_MAC_OSX

static volatile unsigned int retrace_count = 0; /* -dw- need volatile because it updates asychronously */

retrace_count++;

return 1; /* Darrell, is this right? */

}

char message[1024];

const char *fmt, *mem;

if (is_agp) {

mem = "AGP Memory";

} else {

mem = "VRAM";

}

switch (err) {

case memFullErr:

fmt = "Hardware surface possible but not enough %s available";

break;

case cDepthErr:

fmt = "Hardware surface possible but invalid color depth";

break;

default:

fmt = "Hardware surface could not be allocated in %s - unknown error";

break;

}

SDL_snprintf(message, SDL_arraysize(message), fmt, mem);

SDL_SetError(message);

/* put up a dialog to verify display change */