diff options
Diffstat (limited to 'apps/plugins/sdl/src/video/maccommon/SDL_macwm.c')
-rw-r--r-- | apps/plugins/sdl/src/video/maccommon/SDL_macwm.c | 442 |
1 files changed, 442 insertions, 0 deletions
diff --git a/apps/plugins/sdl/src/video/maccommon/SDL_macwm.c b/apps/plugins/sdl/src/video/maccommon/SDL_macwm.c new file mode 100644 index 0000000000..6f485a3fa9 --- /dev/null +++ b/apps/plugins/sdl/src/video/maccommon/SDL_macwm.c | |||
@@ -0,0 +1,442 @@ | |||
1 | /* | ||
2 | SDL - Simple DirectMedia Layer | ||
3 | Copyright (C) 1997-2012 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 | #if defined(__APPLE__) && defined(__MACH__) | ||
25 | #include <Carbon/Carbon.h> | ||
26 | #elif TARGET_API_MAC_CARBON && (UNIVERSAL_INTERFACES_VERSION > 0x0335) | ||
27 | #include <Carbon.h> | ||
28 | #else | ||
29 | #include <Windows.h> | ||
30 | #include <Strings.h> | ||
31 | #endif | ||
32 | |||
33 | #if SDL_MACCLASSIC_GAMMA_SUPPORT | ||
34 | #include <Devices.h> | ||
35 | #include <Files.h> | ||
36 | #include <MacTypes.h> | ||
37 | #include <QDOffscreen.h> | ||
38 | #include <Quickdraw.h> | ||
39 | #include <Video.h> | ||
40 | #endif | ||
41 | |||
42 | #include "SDL_stdinc.h" | ||
43 | #include "SDL_macwm_c.h" | ||
44 | |||
45 | void Mac_SetCaption(_THIS, const char *title, const char *icon) | ||
46 | { | ||
47 | /* Don't convert C to P string in place, because it may be read-only */ | ||
48 | Str255 ptitle; /* MJS */ | ||
49 | ptitle[0] = strlen (title); | ||
50 | SDL_memcpy(ptitle+1, title, ptitle[0]); /* MJS */ | ||
51 | if (SDL_Window) | ||
52 | SetWTitle(SDL_Window, ptitle); /* MJS */ | ||
53 | } | ||
54 | |||
55 | #if SDL_MACCLASSIC_GAMMA_SUPPORT | ||
56 | /* | ||
57 | * ADC Gamma Ramp support... | ||
58 | * | ||
59 | * Mac Gamma Ramp code was originally from sample code provided by | ||
60 | * Apple Developer Connection, and not written specifically for SDL: | ||
61 | * "Contains: Functions to enable Mac OS device gamma adjustments using 3 channel 256 element 8 bit gamma ramps | ||
62 | * Written by: Geoff Stahl (ggs) | ||
63 | * Copyright: Copyright (c) 1999 Apple Computer, Inc., All Rights Reserved | ||
64 | * Disclaimer: You may incorporate this sample code into your applications without | ||
65 | * restriction, though the sample code has been provided "AS IS" and the | ||
66 | * responsibility for its operation is 100% yours. However, what you are | ||
67 | * not permitted to do is to redistribute the source as "DSC Sample Code" | ||
68 | * after having made changes. If you're going to re-distribute the source, | ||
69 | * we require that you make it clear in the source that the code was | ||
70 | * descended from Apple Sample Code, but that you've made changes." | ||
71 | * (The sample code has been integrated into this file, and thus is modified from the original Apple sources.) | ||
72 | */ | ||
73 | |||
74 | typedef struct recDeviceGamma /* storage for device handle and gamma table */ | ||
75 | { | ||
76 | GDHandle hGD; /* handle to device */ | ||
77 | GammaTblPtr pDeviceGamma; /* pointer to device gamma table */ | ||
78 | } recDeviceGamma; | ||
79 | typedef recDeviceGamma * precDeviceGamma; | ||
80 | |||
81 | typedef struct recSystemGamma /* storage for system devices and gamma tables */ | ||
82 | { | ||
83 | short numDevices; /* number of devices */ | ||
84 | precDeviceGamma * devGamma; /* array of pointers to device gamma records */ | ||
85 | } recSystemGamma; | ||
86 | typedef recSystemGamma * precSystemGamma; | ||
87 | |||
88 | static Ptr CopyGammaTable (GammaTblPtr pTableGammaIn) | ||
89 | { | ||
90 | GammaTblPtr pTableGammaOut = NULL; | ||
91 | short tableSize, dataWidth; | ||
92 | |||
93 | if (pTableGammaIn) /* if there is a table to copy */ | ||
94 | { | ||
95 | dataWidth = (pTableGammaIn->gDataWidth + 7) / 8; /* number of bytes per entry */ | ||
96 | tableSize = sizeof (GammaTbl) + pTableGammaIn->gFormulaSize + | ||
97 | (pTableGammaIn->gChanCnt * pTableGammaIn->gDataCnt * dataWidth); | ||
98 | pTableGammaOut = (GammaTblPtr) NewPtr (tableSize); /* allocate new table */ | ||
99 | if (pTableGammaOut) | ||
100 | BlockMove( (Ptr)pTableGammaIn, (Ptr)pTableGammaOut, tableSize); /* move everything */ | ||
101 | } | ||
102 | return (Ptr)pTableGammaOut; /* return whatever we allocated, could be NULL */ | ||
103 | } | ||
104 | |||
105 | static OSErr GetGammaTable (GDHandle hGD, GammaTblPtr * ppTableGammaOut) | ||
106 | { | ||
107 | VDGammaRecord DeviceGammaRec; | ||
108 | CntrlParam cParam; | ||
109 | OSErr err; | ||
110 | |||
111 | cParam.ioCompletion = NULL; /* set up control params */ | ||
112 | cParam.ioNamePtr = NULL; | ||
113 | cParam.ioVRefNum = 0; | ||
114 | cParam.ioCRefNum = (**hGD).gdRefNum; | ||
115 | cParam.csCode = cscGetGamma; /* Get Gamma commnd to device */ | ||
116 | *(Ptr *)cParam.csParam = (Ptr) &DeviceGammaRec; /* record for gamma */ | ||
117 | |||
118 | err = PBStatusSync( (ParmBlkPtr)&cParam ); /* get gamma */ | ||
119 | |||
120 | *ppTableGammaOut = (GammaTblPtr)(DeviceGammaRec.csGTable); /* pull table out of record */ | ||
121 | |||
122 | return err; | ||
123 | } | ||
124 | |||
125 | static Ptr GetDeviceGamma (GDHandle hGD) | ||
126 | { | ||
127 | GammaTblPtr pTableGammaDevice = NULL; | ||
128 | GammaTblPtr pTableGammaReturn = NULL; | ||
129 | OSErr err; | ||
130 | |||
131 | err = GetGammaTable (hGD, &pTableGammaDevice); /* get a pointer to the devices table */ | ||
132 | if ((noErr == err) && pTableGammaDevice) /* if succesful */ | ||
133 | pTableGammaReturn = (GammaTblPtr) CopyGammaTable (pTableGammaDevice); /* copy to global */ | ||
134 | |||
135 | return (Ptr) pTableGammaReturn; | ||
136 | } | ||
137 | |||
138 | static void DisposeGammaTable (Ptr pGamma) | ||
139 | { | ||
140 | if (pGamma) | ||
141 | DisposePtr((Ptr) pGamma); /* get rid of it */ | ||
142 | } | ||
143 | |||
144 | static void DisposeSystemGammas (Ptr* ppSystemGammas) | ||
145 | { | ||
146 | precSystemGamma pSysGammaIn; | ||
147 | if (ppSystemGammas) | ||
148 | { | ||
149 | pSysGammaIn = (precSystemGamma) *ppSystemGammas; | ||
150 | if (pSysGammaIn) | ||
151 | { | ||
152 | short i; | ||
153 | for (i = 0; i < pSysGammaIn->numDevices; i++) /* for all devices */ | ||
154 | if (pSysGammaIn->devGamma [i]) /* if pointer is valid */ | ||
155 | { | ||
156 | DisposeGammaTable ((Ptr) pSysGammaIn->devGamma [i]->pDeviceGamma); /* dump gamma table */ | ||
157 | DisposePtr ((Ptr) pSysGammaIn->devGamma [i]); /* dump device info */ | ||
158 | } | ||
159 | DisposePtr ((Ptr) pSysGammaIn->devGamma); /* dump device pointer array */ | ||
160 | DisposePtr ((Ptr) pSysGammaIn); /* dump system structure */ | ||
161 | *ppSystemGammas = NULL; | ||
162 | } | ||
163 | } | ||
164 | } | ||
165 | |||
166 | static Boolean GetDeviceGammaRampGD (GDHandle hGD, Ptr pRamp) | ||
167 | { | ||
168 | GammaTblPtr pTableGammaTemp = NULL; | ||
169 | long indexChan, indexEntry; | ||
170 | OSErr err; | ||
171 | |||
172 | if (pRamp) /* ensure pRamp is allocated */ | ||
173 | { | ||
174 | err = GetGammaTable (hGD, &pTableGammaTemp); /* get a pointer to the current gamma */ | ||
175 | if ((noErr == err) && pTableGammaTemp) /* if successful */ | ||
176 | { | ||
177 | /* fill ramp */ | ||
178 | unsigned char * pEntry = (unsigned char *) &pTableGammaTemp->gFormulaData + pTableGammaTemp->gFormulaSize; /* base of table */ | ||
179 | short bytesPerEntry = (pTableGammaTemp->gDataWidth + 7) / 8; /* size, in bytes, of the device table entries */ | ||
180 | short shiftRightValue = pTableGammaTemp->gDataWidth - 8; /* number of right shifts device -> ramp */ | ||
181 | short channels = pTableGammaTemp->gChanCnt; | ||
182 | short entries = pTableGammaTemp->gDataCnt; | ||
183 | if (3 == channels) /* RGB format */ | ||
184 | { /* note, this will create runs of entries if dest. is bigger (not linear interpolate) */ | ||
185 | for (indexChan = 0; indexChan < channels; indexChan++) | ||
186 | for (indexEntry = 0; indexEntry < 256; indexEntry++) | ||
187 | *((unsigned char *) pRamp + (indexChan * 256) + indexEntry) = | ||
188 | *(pEntry + indexChan * entries * bytesPerEntry + indexEntry * entries * bytesPerEntry / 256) >> shiftRightValue; | ||
189 | } | ||
190 | else /* single channel format */ | ||
191 | { | ||
192 | for (indexChan = 0; indexChan < 768; indexChan += 256) /* repeat for all 3 channels (step by ramp size) */ | ||
193 | for (indexEntry = 0; indexEntry < 256; indexEntry++) /* for all entries set vramp value */ | ||
194 | *((unsigned char *) pRamp + indexChan + indexEntry) = | ||
195 | *(pEntry + indexEntry * entries * bytesPerEntry / 256) >> shiftRightValue; | ||
196 | } | ||
197 | return true; | ||
198 | } | ||
199 | } | ||
200 | return false; | ||
201 | } | ||
202 | |||
203 | static Ptr GetSystemGammas (void) | ||
204 | { | ||
205 | precSystemGamma pSysGammaOut; /* return pointer to system device gamma info */ | ||
206 | short devCount = 0; /* number of devices attached */ | ||
207 | Boolean fail = false; | ||
208 | GDHandle hGDevice; | ||
209 | |||
210 | pSysGammaOut = (precSystemGamma) NewPtr (sizeof (recSystemGamma)); /* allocate for structure */ | ||
211 | |||
212 | hGDevice = GetDeviceList (); /* top of device list */ | ||
213 | do /* iterate */ | ||
214 | { | ||
215 | devCount++; /* count devices */ | ||
216 | hGDevice = GetNextDevice (hGDevice); /* next device */ | ||
217 | } while (hGDevice); | ||
218 | |||
219 | pSysGammaOut->devGamma = (precDeviceGamma *) NewPtr (sizeof (precDeviceGamma) * devCount); /* allocate for array of pointers to device records */ | ||
220 | if (pSysGammaOut) | ||
221 | { | ||
222 | pSysGammaOut->numDevices = devCount; /* stuff count */ | ||
223 | |||
224 | devCount = 0; /* reset iteration */ | ||
225 | hGDevice = GetDeviceList (); | ||
226 | do | ||
227 | { | ||
228 | pSysGammaOut->devGamma [devCount] = (precDeviceGamma) NewPtr (sizeof (recDeviceGamma)); /* new device record */ | ||
229 | if (pSysGammaOut->devGamma [devCount]) /* if we actually allocated memory */ | ||
230 | { | ||
231 | pSysGammaOut->devGamma [devCount]->hGD = hGDevice; /* stuff handle */ | ||
232 | pSysGammaOut->devGamma [devCount]->pDeviceGamma = (GammaTblPtr)GetDeviceGamma (hGDevice); /* copy gamma table */ | ||
233 | } | ||
234 | else /* otherwise dump record on exit */ | ||
235 | fail = true; | ||
236 | devCount++; /* next device */ | ||
237 | hGDevice = GetNextDevice (hGDevice); | ||
238 | } while (hGDevice); | ||
239 | } | ||
240 | if (!fail) /* if we did not fail */ | ||
241 | return (Ptr) pSysGammaOut; /* return pointer to structure */ | ||
242 | else | ||
243 | { | ||
244 | DisposeSystemGammas ((Ptr *) &pSysGammaOut); /* otherwise dump the current structures (dispose does error checking) */ | ||
245 | return NULL; /* could not complete */ | ||
246 | } | ||
247 | } | ||
248 | |||
249 | static void RestoreDeviceGamma (GDHandle hGD, Ptr pGammaTable) | ||
250 | { | ||
251 | VDSetEntryRecord setEntriesRec; | ||
252 | VDGammaRecord gameRecRestore; | ||
253 | CTabHandle hCTabDeviceColors; | ||
254 | Ptr csPtr; | ||
255 | OSErr err = noErr; | ||
256 | |||
257 | if (pGammaTable) /* if we have a table to restore */ | ||
258 | { | ||
259 | gameRecRestore.csGTable = pGammaTable; /* setup restore record */ | ||
260 | csPtr = (Ptr) &gameRecRestore; | ||
261 | err = Control((**hGD).gdRefNum, cscSetGamma, (Ptr) &csPtr); /* restore gamma */ | ||
262 | |||
263 | if ((noErr == err) && (8 == (**(**hGD).gdPMap).pixelSize)) /* if successful and on an 8 bit device */ | ||
264 | { | ||
265 | hCTabDeviceColors = (**(**hGD).gdPMap).pmTable; /* do SetEntries to force CLUT update */ | ||
266 | setEntriesRec.csTable = (ColorSpec *) &(**hCTabDeviceColors).ctTable; | ||
267 | setEntriesRec.csStart = 0; | ||
268 | setEntriesRec.csCount = (**hCTabDeviceColors).ctSize; | ||
269 | csPtr = (Ptr) &setEntriesRec; | ||
270 | |||
271 | err = Control((**hGD).gdRefNum, cscSetEntries, (Ptr) &csPtr); /* SetEntries in CLUT */ | ||
272 | } | ||
273 | } | ||
274 | } | ||
275 | |||
276 | static void RestoreSystemGammas (Ptr pSystemGammas) | ||
277 | { | ||
278 | short i; | ||
279 | precSystemGamma pSysGammaIn = (precSystemGamma) pSystemGammas; | ||
280 | if (pSysGammaIn) | ||
281 | for (i = 0; i < pSysGammaIn->numDevices; i++) /* for all devices */ | ||
282 | RestoreDeviceGamma (pSysGammaIn->devGamma [i]->hGD, (Ptr) pSysGammaIn->devGamma [i]->pDeviceGamma); /* restore gamma */ | ||
283 | } | ||
284 | |||
285 | static Ptr CreateEmptyGammaTable (short channels, short entries, short bits) | ||
286 | { | ||
287 | GammaTblPtr pTableGammaOut = NULL; | ||
288 | short tableSize, dataWidth; | ||
289 | |||
290 | dataWidth = (bits + 7) / 8; /* number of bytes per entry */ | ||
291 | tableSize = sizeof (GammaTbl) + (channels * entries * dataWidth); | ||
292 | pTableGammaOut = (GammaTblPtr) NewPtrClear (tableSize); /* allocate new tabel */ | ||
293 | |||
294 | if (pTableGammaOut) /* if we successfully allocated */ | ||
295 | { | ||
296 | pTableGammaOut->gVersion = 0; /* set parameters based on input */ | ||
297 | pTableGammaOut->gType = 0; | ||
298 | pTableGammaOut->gFormulaSize = 0; | ||
299 | pTableGammaOut->gChanCnt = channels; | ||
300 | pTableGammaOut->gDataCnt = entries; | ||
301 | pTableGammaOut->gDataWidth = bits; | ||
302 | } | ||
303 | return (Ptr)pTableGammaOut; /* return whatever we allocated */ | ||
304 | } | ||
305 | |||
306 | static Boolean SetDeviceGammaRampGD (GDHandle hGD, Ptr pRamp) | ||
307 | { | ||
308 | VDSetEntryRecord setEntriesRec; | ||
309 | VDGammaRecord gameRecRestore; | ||
310 | GammaTblPtr pTableGammaNew; | ||
311 | GammaTblPtr pTableGammaCurrent = NULL; | ||
312 | CTabHandle hCTabDeviceColors; | ||
313 | Ptr csPtr; | ||
314 | OSErr err; | ||
315 | short dataBits, entries, channels = 3; /* force three channels in the gamma table */ | ||
316 | |||
317 | if (pRamp) /* ensure pRamp is allocated */ | ||
318 | { | ||
319 | err= GetGammaTable (hGD, &pTableGammaCurrent); /* get pointer to current table */ | ||
320 | if ((noErr == err) && pTableGammaCurrent) | ||
321 | { | ||
322 | dataBits = pTableGammaCurrent->gDataWidth; /* table must have same data width */ | ||
323 | entries = pTableGammaCurrent->gDataCnt; /* table must be same size */ | ||
324 | pTableGammaNew = (GammaTblPtr) CreateEmptyGammaTable (channels, entries, dataBits); /* our new table */ | ||
325 | if (pTableGammaNew) /* if successful fill table */ | ||
326 | { | ||
327 | unsigned char * pGammaBase = (unsigned char *) &pTableGammaNew->gFormulaData + pTableGammaNew->gFormulaSize; /* base of table */ | ||
328 | if ((256 == entries) && (8 == dataBits)) /* simple case: direct mapping */ | ||
329 | BlockMove ((Ptr)pRamp, (Ptr)pGammaBase, channels * entries); /* move everything */ | ||
330 | else /* tough case handle entry, channel and data size disparities */ | ||
331 | { | ||
332 | short indexChan, indexEntry; | ||
333 | short bytesPerEntry = (dataBits + 7) / 8; /* size, in bytes, of the device table entries */ | ||
334 | short shiftRightValue = 8 - dataBits; /* number of right shifts ramp -> device */ | ||
335 | shiftRightValue += ((bytesPerEntry - 1) * 8); /* multibyte entries and the need to map a byte at a time most sig. to least sig. */ | ||
336 | for (indexChan = 0; indexChan < channels; indexChan++) /* for all the channels */ | ||
337 | for (indexEntry = 0; indexEntry < entries; indexEntry++) /* for all the entries */ | ||
338 | { | ||
339 | short currentShift = shiftRightValue; /* reset current bit shift */ | ||
340 | long temp = *((unsigned char *)pRamp + (indexChan << 8) + (indexEntry << 8) / entries); /* get data from ramp */ | ||
341 | short indexByte; | ||
342 | for (indexByte = 0; indexByte < bytesPerEntry; indexByte++) /* for all bytes */ | ||
343 | { | ||
344 | if (currentShift < 0) /* shift data correctly for current byte */ | ||
345 | *(pGammaBase++) = temp << -currentShift; | ||
346 | else | ||
347 | *(pGammaBase++) = temp >> currentShift; | ||
348 | currentShift -= 8; /* increment shift to align to next less sig. byte */ | ||
349 | } | ||
350 | } | ||
351 | } | ||
352 | |||
353 | /* set gamma */ | ||
354 | gameRecRestore.csGTable = (Ptr) pTableGammaNew; /* setup restore record */ | ||
355 | csPtr = (Ptr) &gameRecRestore; | ||
356 | err = Control((**hGD).gdRefNum, cscSetGamma, (Ptr) &csPtr); /* restore gamma (note, display drivers may delay returning from this until VBL) */ | ||
357 | |||
358 | if ((8 == (**(**hGD).gdPMap).pixelSize) && (noErr == err)) /* if successful and on an 8 bit device */ | ||
359 | { | ||
360 | hCTabDeviceColors = (**(**hGD).gdPMap).pmTable; /* do SetEntries to force CLUT update */ | ||
361 | setEntriesRec.csTable = (ColorSpec *) &(**hCTabDeviceColors).ctTable; | ||
362 | setEntriesRec.csStart = 0; | ||
363 | setEntriesRec.csCount = (**hCTabDeviceColors).ctSize; | ||
364 | csPtr = (Ptr) &setEntriesRec; | ||
365 | err = Control((**hGD).gdRefNum, cscSetEntries, (Ptr) &csPtr); /* SetEntries in CLUT */ | ||
366 | } | ||
367 | DisposeGammaTable ((Ptr) pTableGammaNew); /* dump table */ | ||
368 | if (noErr == err) | ||
369 | return true; | ||
370 | } | ||
371 | } | ||
372 | } | ||
373 | else /* set NULL gamma -> results in linear map */ | ||
374 | { | ||
375 | gameRecRestore.csGTable = (Ptr) NULL; /* setup restore record */ | ||
376 | csPtr = (Ptr) &gameRecRestore; | ||
377 | err = Control((**hGD).gdRefNum, cscSetGamma, (Ptr) &csPtr); /* restore gamma */ | ||
378 | |||
379 | if ((8 == (**(**hGD).gdPMap).pixelSize) && (noErr == err)) /* if successful and on an 8 bit device */ | ||
380 | { | ||
381 | hCTabDeviceColors = (**(**hGD).gdPMap).pmTable; /* do SetEntries to force CLUT update */ | ||
382 | setEntriesRec.csTable = (ColorSpec *) &(**hCTabDeviceColors).ctTable; | ||
383 | setEntriesRec.csStart = 0; | ||
384 | setEntriesRec.csCount = (**hCTabDeviceColors).ctSize; | ||
385 | csPtr = (Ptr) &setEntriesRec; | ||
386 | err = Control((**hGD).gdRefNum, cscSetEntries, (Ptr) &csPtr); /* SetEntries in CLUT */ | ||
387 | } | ||
388 | if (noErr == err) | ||
389 | return true; | ||
390 | } | ||
391 | return false; /* memory allocation or device control failed if we get here */ | ||
392 | } | ||
393 | |||
394 | /* end of ADC Gamma Ramp support code... */ | ||
395 | |||
396 | static Ptr systemGammaPtr; | ||
397 | |||
398 | void Mac_QuitGamma(_THIS) | ||
399 | { | ||
400 | if (systemGammaPtr) | ||
401 | { | ||
402 | RestoreSystemGammas(systemGammaPtr); | ||
403 | DisposeSystemGammas(&systemGammaPtr); | ||
404 | } | ||
405 | } | ||
406 | |||
407 | static unsigned char shiftedRamp[3 * 256]; | ||
408 | |||
409 | int Mac_SetGammaRamp(_THIS, Uint16 *ramp) | ||
410 | { | ||
411 | int i; | ||
412 | if (!systemGammaPtr) | ||
413 | systemGammaPtr = GetSystemGammas(); | ||
414 | for (i = 0; i < 3 * 256; i++) | ||
415 | { | ||
416 | shiftedRamp[i] = ramp[i] >> 8; | ||
417 | } | ||
418 | |||
419 | if (SetDeviceGammaRampGD(GetMainDevice(), (Ptr) shiftedRamp)) | ||
420 | return 0; | ||
421 | else | ||
422 | return -1; | ||
423 | } | ||
424 | |||
425 | int Mac_GetGammaRamp(_THIS, Uint16 *ramp) | ||
426 | { | ||
427 | if (GetDeviceGammaRampGD(GetMainDevice(), (Ptr) shiftedRamp)) | ||
428 | { | ||
429 | int i; | ||
430 | for (i = 0; i < 3 * 256; i++) | ||
431 | { | ||
432 | ramp[i] = shiftedRamp[i] << 8; | ||
433 | } | ||
434 | return 0; | ||
435 | } | ||
436 | else | ||
437 | return -1; | ||
438 | } | ||
439 | |||
440 | #endif /* SDL_MACCLASSIC_GAMMA_SUPPORT */ | ||
441 | |||
442 | |||