/*
SDL - Simple DirectMedia Layer
Copyright (C) 1997-2006 Sam Lantinga
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Sam Lantinga
slouken@libsdl.org
*/
#include "SDL_config.h"
#if defined(__APPLE__) && defined(__MACH__)
#include <Carbon/Carbon.h>
#elif TARGET_API_MAC_CARBON && (UNIVERSAL_INTERFACES_VERSION > 0x0335)
#include <Carbon.h>
#else
#include <Windows.h>
#include <Strings.h>
#endif
#if SDL_MACCLASSIC_GAMMA_SUPPORT
#include <Devices.h>
#include <Files.h>
#include <MacTypes.h>
#include <QDOffscreen.h>
#include <Quickdraw.h>
#include <Video.h>
#endif
#include "SDL_stdinc.h"
#include "SDL_macwm_c.h"
void Mac_SetCaption(_THIS, const char *title, const char *icon)
{
/* Don't convert C to P string in place, because it may be read-only */
Str255 ptitle; /* MJS */
ptitle[0] = strlen (title);
SDL_memcpy(ptitle+1, title, ptitle[0]); /* MJS */
if (SDL_Window)
SetWTitle(SDL_Window, ptitle); /* MJS */
}
#if SDL_MACCLASSIC_GAMMA_SUPPORT
/*
* ADC Gamma Ramp support...
*
* Mac Gamma Ramp code was originally from sample code provided by
* Apple Developer Connection, and not written specifically for SDL:
* "Contains: Functions to enable Mac OS device gamma adjustments using 3 channel 256 element 8 bit gamma ramps
* Written by: Geoff Stahl (ggs)
* Copyright: Copyright (c) 1999 Apple Computer, Inc., All Rights Reserved
* Disclaimer: You may incorporate this sample code into your applications without
* restriction, though the sample code has been provided "AS IS" and the
* responsibility for its operation is 100% yours. However, what you are
* not permitted to do is to redistribute the source as "DSC Sample Code"
* after having made changes. If you're going to re-distribute the source,
* we require that you make it clear in the source that the code was
* descended from Apple Sample Code, but that you've made changes."
* (The sample code has been integrated into this file, and thus is modified from the original Apple sources.)
*/
typedef struct recDeviceGamma /* storage for device handle and gamma table */
{
GDHandle hGD; /* handle to device */
GammaTblPtr pDeviceGamma; /* pointer to device gamma table */
} recDeviceGamma;
typedef recDeviceGamma * precDeviceGamma;
typedef struct recSystemGamma /* storage for system devices and gamma tables */
{
short numDevices; /* number of devices */
precDeviceGamma * devGamma; /* array of pointers to device gamma records */
} recSystemGamma;
typedef recSystemGamma * precSystemGamma;
static Ptr CopyGammaTable (GammaTblPtr pTableGammaIn)
{
GammaTblPtr pTableGammaOut = NULL;
short tableSize, dataWidth;
if (pTableGammaIn) /* if there is a table to copy */
{
dataWidth = (pTableGammaIn->gDataWidth + 7) / 8; /* number of bytes per entry */
tableSize = sizeof (GammaTbl) + pTableGammaIn->gFormulaSize +
(pTableGammaIn->gChanCnt * pTableGammaIn->gDataCnt * dataWidth);
pTableGammaOut = (GammaTblPtr) NewPtr (tableSize); /* allocate new table */
if (pTableGammaOut)
BlockMove( (Ptr)pTableGammaIn, (Ptr)pTableGammaOut, tableSize); /* move everything */
}
return (Ptr)pTableGammaOut; /* return whatever we allocated, could be NULL */
}
static OSErr GetGammaTable (GDHandle hGD, GammaTblPtr * ppTableGammaOut)
{
VDGammaRecord DeviceGammaRec;
CntrlParam cParam;
OSErr err;
cParam.ioCompletion = NULL; /* set up control params */
cParam.ioNamePtr = NULL;
cParam.ioVRefNum = 0;
cParam.ioCRefNum = (**hGD).gdRefNum;
cParam.csCode = cscGetGamma; /* Get Gamma commnd to device */
*(Ptr *)cParam.csParam = (Ptr) &DeviceGammaRec; /* record for gamma */
err = PBStatusSync( (ParmBlkPtr)&cParam ); /* get gamma */
*ppTableGammaOut = (GammaTblPtr)(DeviceGammaRec.csGTable); /* pull table out of record */
return err;
}
static Ptr GetDeviceGamma (GDHandle hGD)
{
GammaTblPtr pTableGammaDevice = NULL;
GammaTblPtr pTableGammaReturn = NULL;
OSErr err;
err = GetGammaTable (hGD, &pTableGammaDevice); /* get a pointer to the devices table */
if ((noErr == err) && pTableGammaDevice) /* if succesful */
pTableGammaReturn = (GammaTblPtr) CopyGammaTable (pTableGammaDevice); /* copy to global */
return (Ptr) pTableGammaReturn;
}
static void DisposeGammaTable (Ptr pGamma)
{
if (pGamma)
DisposePtr((Ptr) pGamma); /* get rid of it */
}
static void DisposeSystemGammas (Ptr* ppSystemGammas)
{
precSystemGamma pSysGammaIn;
if (ppSystemGammas)
{
pSysGammaIn = (precSystemGamma) *ppSystemGammas;
if (pSysGammaIn)
{
short i;
for (i = 0; i < pSysGammaIn->numDevices; i++) /* for all devices */
if (pSysGammaIn->devGamma [i]) /* if pointer is valid */
{
DisposeGammaTable ((Ptr) pSysGammaIn->devGamma [i]->pDeviceGamma); /* dump gamma table */
DisposePtr ((Ptr) pSysGammaIn->devGamma [i]); /* dump device info */
}
DisposePtr ((Ptr) pSysGammaIn->devGamma); /* dump device pointer array */
DisposePtr ((Ptr) pSysGammaIn); /* dump system structure */
*ppSystemGammas = NULL;
}
}
}
static Boolean GetDeviceGammaRampGD (GDHandle hGD, Ptr pRamp)
{
GammaTblPtr pTableGammaTemp = NULL;
long indexChan, indexEntry;
OSErr err;
if (pRamp) /* ensure pRamp is allocated */
{
err = GetGammaTable (hGD, &pTableGammaTemp); /* get a pointer to the current gamma */
if ((noErr == err) && pTableGammaTemp) /* if successful */
{
/* fill ramp */
unsigned char * pEntry = (unsigned char *) &pTableGammaTemp->gFormulaData + pTableGammaTemp->gFormulaSize; /* base of table */
short bytesPerEntry = (pTableGammaTemp->gDataWidth + 7) / 8; /* size, in bytes, of the device table entries */
short shiftRightValue = pTableGammaTemp->gDataWidth - 8; /* number of right shifts device -> ramp */
short channels = pTableGammaTemp->gChanCnt;
short entries = pTableGammaTemp->gDataCnt;
if (3 == channels) /* RGB format */
{ /* note, this will create runs of entries if dest. is bigger (not linear interpolate) */
for (indexChan = 0; indexChan < channels; indexChan++)
for (indexEntry = 0; indexEntry < 256; indexEntry++)
*((unsigned char *) pRamp + (indexChan * 256) + indexEntry) =
*(pEntry + indexChan * entries * bytesPerEntry + indexEntry * entries * bytesPerEntry / 256) >> shiftRightValue;
}
else /* single channel format */
{
for (indexChan = 0; indexChan < 768; indexChan += 256) /* repeat for all 3 channels (step by ramp size) */
for (indexEntry = 0; indexEntry < 256; indexEntry++) /* for all entries set vramp value */
*((unsigned char *) pRamp + indexChan + indexEntry) =
*(pEntry + indexEntry * entries * bytesPerEntry / 256) >> shiftRightValue;
}
return true;
}
}
return false;
}
static Ptr GetSystemGammas (void)
{
precSystemGamma pSysGammaOut; /* return pointer to system device gamma info */
short devCount = 0; /* number of devices attached */
Boolean fail = false;
GDHandle hGDevice;
pSysGammaOut = (precSystemGamma) NewPtr (sizeof (recSystemGamma)); /* allocate for structure */
hGDevice = GetDeviceList (); /* top of device list */
do /* iterate */
{
devCount++; /* count devices */
hGDevice = GetNextDevice (hGDevice); /* next device */
} while (hGDevice);
pSysGammaOut->devGamma = (precDeviceGamma *) NewPtr (sizeof (precDeviceGamma) * devCount); /* allocate for array of pointers to device records */
if (pSysGammaOut)
{
pSysGammaOut->numDevices = devCount; /* stuff count */
devCount = 0; /* reset iteration */
hGDevice = GetDeviceList ();
do
{
pSysGammaOut->devGamma [devCount] = (precDeviceGamma) NewPtr (sizeof (recDeviceGamma)); /* new device record */
if (pSysGammaOut->devGamma [devCount]) /* if we actually allocated memory */
{
pSysGammaOut->devGamma [devCount]->hGD = hGDevice; /* stuff handle */
pSysGammaOut->devGamma [devCount]->pDeviceGamma = (GammaTblPtr)GetDeviceGamma (hGDevice); /* copy gamma table */
}
else /* otherwise dump record on exit */
fail = true;
devCount++; /* next device */
hGDevice = GetNextDevice (hGDevice);
} while (hGDevice);
}
if (!fail) /* if we did not fail */
return (Ptr) pSysGammaOut; /* return pointer to structure */
else
{
DisposeSystemGammas ((Ptr *) &pSysGammaOut); /* otherwise dump the current structures (dispose does error checking) */
return NULL; /* could not complete */
}
}
static void RestoreDeviceGamma (GDHandle hGD, Ptr pGammaTable)
{
VDSetEntryRecord setEntriesRec;
VDGammaRecord gameRecRestore;
CTabHandle hCTabDeviceColors;
Ptr csPtr;
OSErr err = noErr;
if (pGammaTable) /* if we have a table to restore */
{
gameRecRestore.csGTable = pGammaTable; /* setup restore record */
csPtr = (Ptr) &gameRecRestore;
err = Control((**hGD).gdRefNum, cscSetGamma, (Ptr) &csPtr); /* restore gamma */
if ((noErr == err) && (8 == (**(**hGD).gdPMap).pixelSize)) /* if successful and on an 8 bit device */
{
hCTabDeviceColors = (**(**hGD).gdPMap).pmTable; /* do SetEntries to force CLUT update */
setEntriesRec.csTable = (ColorSpec *) &(**hCTabDeviceColors).ctTable;
setEntriesRec.csStart = 0;
setEntriesRec.csCount = (**hCTabDeviceColors).ctSize;
csPtr = (Ptr) &setEntriesRec;
err = Control((**hGD).gdRefNum, cscSetEntries, (Ptr) &csPtr); /* SetEntries in CLUT */
}
}
}
static void RestoreSystemGammas (Ptr pSystemGammas)
{
short i;
precSystemGamma pSysGammaIn = (precSystemGamma) pSystemGammas;
if (pSysGammaIn)
for (i = 0; i < pSysGammaIn->numDevices; i++) /* for all devices */
RestoreDeviceGamma (pSysGammaIn->devGamma [i]->hGD, (Ptr) pSysGammaIn->devGamma [i]->pDeviceGamma); /* restore gamma */
}
static Ptr CreateEmptyGammaTable (short channels, short entries, short bits)
{
GammaTblPtr pTableGammaOut = NULL;
short tableSize, dataWidth;
dataWidth = (bits + 7) / 8; /* number of bytes per entry */
tableSize = sizeof (GammaTbl) + (channels * entries * dataWidth);
pTableGammaOut = (GammaTblPtr) NewPtrClear (tableSize); /* allocate new tabel */
if (pTableGammaOut) /* if we successfully allocated */
{
pTableGammaOut->gVersion = 0; /* set parameters based on input */
pTableGammaOut->gType = 0;
pTableGammaOut->gFormulaSize = 0;
pTableGammaOut->gChanCnt = channels;
pTableGammaOut->gDataCnt = entries;
pTableGammaOut->gDataWidth = bits;
}
return (Ptr)pTableGammaOut; /* return whatever we allocated */
}
static Boolean SetDeviceGammaRampGD (GDHandle hGD, Ptr pRamp)
{
VDSetEntryRecord setEntriesRec;
VDGammaRecord gameRecRestore;
GammaTblPtr pTableGammaNew;
GammaTblPtr pTableGammaCurrent = NULL;
CTabHandle hCTabDeviceColors;
Ptr csPtr;
OSErr err;
short dataBits, entries, channels = 3; /* force three channels in the gamma table */
if (pRamp) /* ensure pRamp is allocated */
{
err= GetGammaTable (hGD, &pTableGammaCurrent); /* get pointer to current table */
if ((noErr == err) && pTableGammaCurrent)
{
dataBits = pTableGammaCurrent->gDataWidth; /* table must have same data width */
entries = pTableGammaCurrent->gDataCnt; /* table must be same size */
pTableGammaNew = (GammaTblPtr) CreateEmptyGammaTable (channels, entries, dataBits); /* our new table */
if (pTableGammaNew) /* if successful fill table */
{
unsigned char * pGammaBase = (unsigned char *) &pTableGammaNew->gFormulaData + pTableGammaNew->gFormulaSize; /* base of table */
if ((256 == entries) && (8 == dataBits)) /* simple case: direct mapping */
BlockMove ((Ptr)pRamp, (Ptr)pGammaBase, channels * entries); /* move everything */
else /* tough case handle entry, channel and data size disparities */
{
short indexChan, indexEntry;
short bytesPerEntry = (dataBits + 7) / 8; /* size, in bytes, of the device table entries */
short shiftRightValue = 8 - dataBits; /* number of right shifts ramp -> device */
shiftRightValue += ((bytesPerEntry - 1) * 8); /* multibyte entries and the need to map a byte at a time most sig. to least sig. */
for (indexChan = 0; indexChan < channels; indexChan++) /* for all the channels */
for (indexEntry = 0; indexEntry < entries; indexEntry++) /* for all the entries */
{
short currentShift = shiftRightValue; /* reset current bit shift */
long temp = *((unsigned char *)pRamp + (indexChan << 8) + (indexEntry << 8) / entries); /* get data from ramp */
short indexByte;
for (indexByte = 0; indexByte < bytesPerEntry; indexByte++) /* for all bytes */
{
if (currentShift < 0) /* shift data correctly for current byte */
*(pGammaBase++) = temp << -currentShift;
else
*(pGammaBase++) = temp >> currentShift;
currentShift -= 8; /* increment shift to align to next less sig. byte */
}
}
}
/* set gamma */
gameRecRestore.csGTable = (Ptr) pTableGammaNew; /* setup restore record */
csPtr = (Ptr) &gameRecRestore;
err = Control((**hGD).gdRefNum, cscSetGamma, (Ptr) &csPtr); /* restore gamma (note, display drivers may delay returning from this until VBL) */
if ((8 == (**(**hGD).gdPMap).pixelSize) && (noErr == err)) /* if successful and on an 8 bit device */
{
hCTabDeviceColors = (**(**hGD).gdPMap).pmTable; /* do SetEntries to force CLUT update */
setEntriesRec.csTable = (ColorSpec *) &(**hCTabDeviceColors).ctTable;
setEntriesRec.csStart = 0;
setEntriesRec.csCount = (**hCTabDeviceColors).ctSize;
csPtr = (Ptr) &setEntriesRec;
err = Control((**hGD).gdRefNum, cscSetEntries, (Ptr) &csPtr); /* SetEntries in CLUT */
}
DisposeGammaTable ((Ptr) pTableGammaNew); /* dump table */
if (noErr == err)
return true;
}
}
}
else /* set NULL gamma -> results in linear map */
{
gameRecRestore.csGTable = (Ptr) NULL; /* setup restore record */
csPtr = (Ptr) &gameRecRestore;
err = Control((**hGD).gdRefNum, cscSetGamma, (Ptr) &csPtr); /* restore gamma */
if ((8 == (**(**hGD).gdPMap).pixelSize) && (noErr == err)) /* if successful and on an 8 bit device */
{
hCTabDeviceColors = (**(**hGD).gdPMap).pmTable; /* do SetEntries to force CLUT update */
setEntriesRec.csTable = (ColorSpec *) &(**hCTabDeviceColors).ctTable;
setEntriesRec.csStart = 0;
setEntriesRec.csCount = (**hCTabDeviceColors).ctSize;
csPtr = (Ptr) &setEntriesRec;
err = Control((**hGD).gdRefNum, cscSetEntries, (Ptr) &csPtr); /* SetEntries in CLUT */
}
if (noErr == err)
return true;
}
return false; /* memory allocation or device control failed if we get here */
}
/* end of ADC Gamma Ramp support code... */
static Ptr systemGammaPtr;
void Mac_QuitGamma(_THIS)
{
if (systemGammaPtr)
{
RestoreSystemGammas(systemGammaPtr);
DisposeSystemGammas(&systemGammaPtr);
}
}
static unsigned char shiftedRamp[3 * 256];
int Mac_SetGammaRamp(_THIS, Uint16 *ramp)
{
int i;
if (!systemGammaPtr)
systemGammaPtr = GetSystemGammas();
for (i = 0; i < 3 * 256; i++)
{
shiftedRamp[i] = ramp[i] >> 8;
}
if (SetDeviceGammaRampGD(GetMainDevice(), (Ptr) shiftedRamp))
return 0;
else
return -1;
}
int Mac_GetGammaRamp(_THIS, Uint16 *ramp)
{
if (GetDeviceGammaRampGD(GetMainDevice(), (Ptr) shiftedRamp))
{
int i;
for (i = 0; i < 3 * 256; i++)
{
ramp[i] = shiftedRamp[i] << 8;
}
return 0;
}
else
return -1;
}
#endif /* SDL_MACCLASSIC_GAMMA_SUPPORT */