diff options
author | Franklin Wei <git@fwei.tk> | 2018-02-07 20:04:46 -0500 |
---|---|---|
committer | Franklin Wei <git@fwei.tk> | 2018-03-12 20:52:01 -0400 |
commit | 6039eb05ba6d82ef56f2868c96654c552d117bf9 (patch) | |
tree | 9db7016bcbf66cfdf7b9bc998d84c6eaff9c8378 /apps/plugins/sdl/src/audio/macrom | |
parent | ef373c03b96b0be08babca581d9f10bccfd4931f (diff) | |
download | rockbox-6039eb05ba6d82ef56f2868c96654c552d117bf9.tar.gz rockbox-6039eb05ba6d82ef56f2868c96654c552d117bf9.zip |
sdl: remove non-rockbox drivers
We never use any of these other drivers, so having them around just takes
up space.
Change-Id: Iced812162df1fef3fd55522b7e700acb6c3bcd41
Diffstat (limited to 'apps/plugins/sdl/src/audio/macrom')
-rw-r--r-- | apps/plugins/sdl/src/audio/macrom/SDL_romaudio.c | 496 | ||||
-rw-r--r-- | apps/plugins/sdl/src/audio/macrom/SDL_romaudio.h | 50 |
2 files changed, 0 insertions, 546 deletions
diff --git a/apps/plugins/sdl/src/audio/macrom/SDL_romaudio.c b/apps/plugins/sdl/src/audio/macrom/SDL_romaudio.c deleted file mode 100644 index 1b3d49e198..0000000000 --- a/apps/plugins/sdl/src/audio/macrom/SDL_romaudio.c +++ /dev/null | |||
@@ -1,496 +0,0 @@ | |||
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 <Sound.h> /* SoundManager interface */ | ||
30 | # include <Gestalt.h> | ||
31 | # include <DriverServices.h> | ||
32 | #endif | ||
33 | |||
34 | #if !defined(NewSndCallBackUPP) && (UNIVERSAL_INTERFACES_VERSION < 0x0335) | ||
35 | #if !defined(NewSndCallBackProc) /* avoid circular redefinition... */ | ||
36 | #define NewSndCallBackUPP NewSndCallBackProc | ||
37 | #endif | ||
38 | #if !defined(NewSndCallBackUPP) | ||
39 | #define NewSndCallBackUPP NewSndCallBackProc | ||
40 | #endif | ||
41 | #endif | ||
42 | |||
43 | #include "SDL_audio.h" | ||
44 | #include "../SDL_audio_c.h" | ||
45 | #include "../SDL_sysaudio.h" | ||
46 | #include "SDL_romaudio.h" | ||
47 | |||
48 | /* Audio driver functions */ | ||
49 | |||
50 | static void Mac_CloseAudio(_THIS); | ||
51 | static int Mac_OpenAudio(_THIS, SDL_AudioSpec *spec); | ||
52 | static void Mac_LockAudio(_THIS); | ||
53 | static void Mac_UnlockAudio(_THIS); | ||
54 | |||
55 | /* Audio driver bootstrap functions */ | ||
56 | |||
57 | |||
58 | static int Audio_Available(void) | ||
59 | { | ||
60 | return(1); | ||
61 | } | ||
62 | |||
63 | static void Audio_DeleteDevice(SDL_AudioDevice *device) | ||
64 | { | ||
65 | SDL_free(device->hidden); | ||
66 | SDL_free(device); | ||
67 | } | ||
68 | |||
69 | static SDL_AudioDevice *Audio_CreateDevice(int devindex) | ||
70 | { | ||
71 | SDL_AudioDevice *this; | ||
72 | |||
73 | /* Initialize all variables that we clean on shutdown */ | ||
74 | this = (SDL_AudioDevice *)SDL_malloc(sizeof(SDL_AudioDevice)); | ||
75 | if ( this ) { | ||
76 | SDL_memset(this, 0, (sizeof *this)); | ||
77 | this->hidden = (struct SDL_PrivateAudioData *) | ||
78 | SDL_malloc((sizeof *this->hidden)); | ||
79 | } | ||
80 | if ( (this == NULL) || (this->hidden == NULL) ) { | ||
81 | SDL_OutOfMemory(); | ||
82 | if ( this ) { | ||
83 | SDL_free(this); | ||
84 | } | ||
85 | return(0); | ||
86 | } | ||
87 | SDL_memset(this->hidden, 0, (sizeof *this->hidden)); | ||
88 | |||
89 | /* Set the function pointers */ | ||
90 | this->OpenAudio = Mac_OpenAudio; | ||
91 | this->CloseAudio = Mac_CloseAudio; | ||
92 | this->LockAudio = Mac_LockAudio; | ||
93 | this->UnlockAudio = Mac_UnlockAudio; | ||
94 | this->free = Audio_DeleteDevice; | ||
95 | |||
96 | #ifdef __MACOSX__ /* Mac OS X uses threaded audio, so normal thread code is okay */ | ||
97 | this->LockAudio = NULL; | ||
98 | this->UnlockAudio = NULL; | ||
99 | #endif | ||
100 | return this; | ||
101 | } | ||
102 | |||
103 | AudioBootStrap SNDMGR_bootstrap = { | ||
104 | "sndmgr", "MacOS SoundManager 3.0", | ||
105 | Audio_Available, Audio_CreateDevice | ||
106 | }; | ||
107 | |||
108 | #if defined(TARGET_API_MAC_CARBON) || defined(USE_RYANS_SOUNDCODE) | ||
109 | /* This works correctly on Mac OS X */ | ||
110 | |||
111 | #pragma options align=power | ||
112 | |||
113 | static volatile SInt32 audio_is_locked = 0; | ||
114 | static volatile SInt32 need_to_mix = 0; | ||
115 | |||
116 | static UInt8 *buffer[2]; | ||
117 | static volatile UInt32 running = 0; | ||
118 | static CmpSoundHeader header; | ||
119 | static volatile Uint32 fill_me = 0; | ||
120 | |||
121 | static void mix_buffer(SDL_AudioDevice *audio, UInt8 *buffer) | ||
122 | { | ||
123 | if ( ! audio->paused ) { | ||
124 | #ifdef __MACOSX__ | ||
125 | SDL_mutexP(audio->mixer_lock); | ||
126 | #endif | ||
127 | if ( audio->convert.needed ) { | ||
128 | audio->spec.callback(audio->spec.userdata, | ||
129 | (Uint8 *)audio->convert.buf,audio->convert.len); | ||
130 | SDL_ConvertAudio(&audio->convert); | ||
131 | if ( audio->convert.len_cvt != audio->spec.size ) { | ||
132 | /* Uh oh... probably crashes here */; | ||
133 | } | ||
134 | SDL_memcpy(buffer, audio->convert.buf, audio->convert.len_cvt); | ||
135 | } else { | ||
136 | audio->spec.callback(audio->spec.userdata, buffer, audio->spec.size); | ||
137 | } | ||
138 | #ifdef __MACOSX__ | ||
139 | SDL_mutexV(audio->mixer_lock); | ||
140 | #endif | ||
141 | } | ||
142 | |||
143 | DecrementAtomic((SInt32 *) &need_to_mix); | ||
144 | } | ||
145 | |||
146 | static void Mac_LockAudio(_THIS) | ||
147 | { | ||
148 | IncrementAtomic((SInt32 *) &audio_is_locked); | ||
149 | } | ||
150 | |||
151 | static void Mac_UnlockAudio(_THIS) | ||
152 | { | ||
153 | SInt32 oldval; | ||
154 | |||
155 | oldval = DecrementAtomic((SInt32 *) &audio_is_locked); | ||
156 | if ( oldval != 1 ) /* != 1 means audio is still locked. */ | ||
157 | return; | ||
158 | |||
159 | /* Did we miss the chance to mix in an interrupt? Do it now. */ | ||
160 | if ( BitAndAtomic (0xFFFFFFFF, (UInt32 *) &need_to_mix) ) { | ||
161 | /* | ||
162 | * Note that this could be a problem if you missed an interrupt | ||
163 | * while the audio was locked, and get preempted by a second | ||
164 | * interrupt here, but that means you locked for way too long anyhow. | ||
165 | */ | ||
166 | mix_buffer (this, buffer[fill_me]); | ||
167 | } | ||
168 | } | ||
169 | |||
170 | static void callBackProc (SndChannel *chan, SndCommand *cmd_passed ) { | ||
171 | UInt32 play_me; | ||
172 | SndCommand cmd; | ||
173 | SDL_AudioDevice *audio = (SDL_AudioDevice *)chan->userInfo; | ||
174 | |||
175 | IncrementAtomic((SInt32 *) &need_to_mix); | ||
176 | |||
177 | fill_me = cmd_passed->param2; /* buffer that has just finished playing, so fill it */ | ||
178 | play_me = ! fill_me; /* filled buffer to play _now_ */ | ||
179 | |||
180 | if ( ! audio->enabled ) { | ||
181 | return; | ||
182 | } | ||
183 | |||
184 | /* queue previously mixed buffer for playback. */ | ||
185 | header.samplePtr = (Ptr)buffer[play_me]; | ||
186 | cmd.cmd = bufferCmd; | ||
187 | cmd.param1 = 0; | ||
188 | cmd.param2 = (long)&header; | ||
189 | SndDoCommand (chan, &cmd, 0); | ||
190 | |||
191 | memset (buffer[fill_me], 0, audio->spec.size); | ||
192 | |||
193 | /* | ||
194 | * if audio device isn't locked, mix the next buffer to be queued in | ||
195 | * the memory block that just finished playing. | ||
196 | */ | ||
197 | if ( ! BitAndAtomic(0xFFFFFFFF, (UInt32 *) &audio_is_locked) ) { | ||
198 | mix_buffer (audio, buffer[fill_me]); | ||
199 | } | ||
200 | |||
201 | /* set this callback to run again when current buffer drains. */ | ||
202 | if ( running ) { | ||
203 | cmd.cmd = callBackCmd; | ||
204 | cmd.param1 = 0; | ||
205 | cmd.param2 = play_me; | ||
206 | |||
207 | SndDoCommand (chan, &cmd, 0); | ||
208 | } | ||
209 | } | ||
210 | |||
211 | static int Mac_OpenAudio(_THIS, SDL_AudioSpec *spec) { | ||
212 | |||
213 | SndCallBackUPP callback; | ||
214 | int sample_bits; | ||
215 | int i; | ||
216 | long initOptions; | ||
217 | |||
218 | /* Very few conversions are required, but... */ | ||
219 | switch (spec->format) { | ||
220 | case AUDIO_S8: | ||
221 | spec->format = AUDIO_U8; | ||
222 | break; | ||
223 | case AUDIO_U16LSB: | ||
224 | spec->format = AUDIO_S16LSB; | ||
225 | break; | ||
226 | case AUDIO_U16MSB: | ||
227 | spec->format = AUDIO_S16MSB; | ||
228 | break; | ||
229 | } | ||
230 | SDL_CalculateAudioSpec(spec); | ||
231 | |||
232 | /* initialize bufferCmd header */ | ||
233 | memset (&header, 0, sizeof(header)); | ||
234 | callback = (SndCallBackUPP) NewSndCallBackUPP (callBackProc); | ||
235 | sample_bits = spec->size / spec->samples / spec->channels * 8; | ||
236 | |||
237 | #ifdef DEBUG_AUDIO | ||
238 | fprintf(stderr, | ||
239 | "Audio format 0x%x, channels = %d, sample_bits = %d, frequency = %d\n", | ||
240 | spec->format, spec->channels, sample_bits, spec->freq); | ||
241 | #endif /* DEBUG_AUDIO */ | ||
242 | |||
243 | header.numChannels = spec->channels; | ||
244 | header.sampleSize = sample_bits; | ||
245 | header.sampleRate = spec->freq << 16; | ||
246 | header.numFrames = spec->samples; | ||
247 | header.encode = cmpSH; | ||
248 | |||
249 | /* Note that we install the 16bitLittleEndian Converter if needed. */ | ||
250 | if ( spec->format == 0x8010 ) { | ||
251 | header.compressionID = fixedCompression; | ||
252 | header.format = k16BitLittleEndianFormat; | ||
253 | } | ||
254 | |||
255 | /* allocate 2 buffers */ | ||
256 | for (i=0; i<2; i++) { | ||
257 | buffer[i] = (UInt8*)malloc (sizeof(UInt8) * spec->size); | ||
258 | if (buffer[i] == NULL) { | ||
259 | SDL_OutOfMemory(); | ||
260 | return (-1); | ||
261 | } | ||
262 | memset (buffer[i], 0, spec->size); | ||
263 | } | ||
264 | |||
265 | /* Create the sound manager channel */ | ||
266 | channel = (SndChannelPtr)SDL_malloc(sizeof(*channel)); | ||
267 | if ( channel == NULL ) { | ||
268 | SDL_OutOfMemory(); | ||
269 | return(-1); | ||
270 | } | ||
271 | if ( spec->channels >= 2 ) { | ||
272 | initOptions = initStereo; | ||
273 | } else { | ||
274 | initOptions = initMono; | ||
275 | } | ||
276 | channel->userInfo = (long)this; | ||
277 | channel->qLength = 128; | ||
278 | if ( SndNewChannel(&channel, sampledSynth, initOptions, callback) != noErr ) { | ||
279 | SDL_SetError("Unable to create audio channel"); | ||
280 | SDL_free(channel); | ||
281 | channel = NULL; | ||
282 | return(-1); | ||
283 | } | ||
284 | |||
285 | /* start playback */ | ||
286 | { | ||
287 | SndCommand cmd; | ||
288 | cmd.cmd = callBackCmd; | ||
289 | cmd.param2 = 0; | ||
290 | running = 1; | ||
291 | SndDoCommand (channel, &cmd, 0); | ||
292 | } | ||
293 | |||
294 | return 1; | ||
295 | } | ||
296 | |||
297 | static void Mac_CloseAudio(_THIS) { | ||
298 | |||
299 | int i; | ||
300 | |||
301 | running = 0; | ||
302 | |||
303 | if (channel) { | ||
304 | SndDisposeChannel (channel, true); | ||
305 | channel = NULL; | ||
306 | } | ||
307 | |||
308 | for ( i=0; i<2; ++i ) { | ||
309 | if ( buffer[i] ) { | ||
310 | SDL_free(buffer[i]); | ||
311 | buffer[i] = NULL; | ||
312 | } | ||
313 | } | ||
314 | } | ||
315 | |||
316 | #else /* !TARGET_API_MAC_CARBON && !USE_RYANS_SOUNDCODE */ | ||
317 | |||
318 | static void Mac_LockAudio(_THIS) | ||
319 | { | ||
320 | /* no-op. */ | ||
321 | } | ||
322 | |||
323 | static void Mac_UnlockAudio(_THIS) | ||
324 | { | ||
325 | /* no-op. */ | ||
326 | } | ||
327 | |||
328 | |||
329 | /* This function is called by Sound Manager when it has exhausted one of | ||
330 | the buffers, so we'll zero it to silence and fill it with audio if | ||
331 | we're not paused. | ||
332 | */ | ||
333 | static pascal | ||
334 | void sndDoubleBackProc (SndChannelPtr chan, SndDoubleBufferPtr newbuf) | ||
335 | { | ||
336 | SDL_AudioDevice *audio = (SDL_AudioDevice *)newbuf->dbUserInfo[0]; | ||
337 | |||
338 | /* If audio is quitting, don't do anything */ | ||
339 | if ( ! audio->enabled ) { | ||
340 | return; | ||
341 | } | ||
342 | memset (newbuf->dbSoundData, 0, audio->spec.size); | ||
343 | newbuf->dbNumFrames = audio->spec.samples; | ||
344 | if ( ! audio->paused ) { | ||
345 | if ( audio->convert.needed ) { | ||
346 | audio->spec.callback(audio->spec.userdata, | ||
347 | (Uint8 *)audio->convert.buf,audio->convert.len); | ||
348 | SDL_ConvertAudio(&audio->convert); | ||
349 | #if 0 | ||
350 | if ( audio->convert.len_cvt != audio->spec.size ) { | ||
351 | /* Uh oh... probably crashes here */; | ||
352 | } | ||
353 | #endif | ||
354 | SDL_memcpy(newbuf->dbSoundData, audio->convert.buf, | ||
355 | audio->convert.len_cvt); | ||
356 | } else { | ||
357 | audio->spec.callback(audio->spec.userdata, | ||
358 | (Uint8 *)newbuf->dbSoundData, audio->spec.size); | ||
359 | } | ||
360 | } | ||
361 | newbuf->dbFlags |= dbBufferReady; | ||
362 | } | ||
363 | |||
364 | static int DoubleBufferAudio_Available(void) | ||
365 | { | ||
366 | int available; | ||
367 | NumVersion sndversion; | ||
368 | long response; | ||
369 | |||
370 | available = 0; | ||
371 | sndversion = SndSoundManagerVersion(); | ||
372 | if ( sndversion.majorRev >= 3 ) { | ||
373 | if ( Gestalt(gestaltSoundAttr, &response) == noErr ) { | ||
374 | if ( (response & (1 << gestaltSndPlayDoubleBuffer)) ) { | ||
375 | available = 1; | ||
376 | } | ||
377 | } | ||
378 | } else { | ||
379 | if ( Gestalt(gestaltSoundAttr, &response) == noErr ) { | ||
380 | if ( (response & (1 << gestaltHasASC)) ) { | ||
381 | available = 1; | ||
382 | } | ||
383 | } | ||
384 | } | ||
385 | return(available); | ||
386 | } | ||
387 | |||
388 | static void Mac_CloseAudio(_THIS) | ||
389 | { | ||
390 | int i; | ||
391 | |||
392 | if ( channel != NULL ) { | ||
393 | /* Clean up the audio channel */ | ||
394 | SndDisposeChannel(channel, true); | ||
395 | channel = NULL; | ||
396 | } | ||
397 | for ( i=0; i<2; ++i ) { | ||
398 | if ( audio_buf[i] ) { | ||
399 | SDL_free(audio_buf[i]); | ||
400 | audio_buf[i] = NULL; | ||
401 | } | ||
402 | } | ||
403 | } | ||
404 | |||
405 | static int Mac_OpenAudio(_THIS, SDL_AudioSpec *spec) | ||
406 | { | ||
407 | SndDoubleBufferHeader2 audio_dbh; | ||
408 | int i; | ||
409 | long initOptions; | ||
410 | int sample_bits; | ||
411 | SndDoubleBackUPP doubleBackProc; | ||
412 | |||
413 | /* Check to make sure double-buffered audio is available */ | ||
414 | if ( ! DoubleBufferAudio_Available() ) { | ||
415 | SDL_SetError("Sound manager doesn't support double-buffering"); | ||
416 | return(-1); | ||
417 | } | ||
418 | |||
419 | /* Very few conversions are required, but... */ | ||
420 | switch (spec->format) { | ||
421 | case AUDIO_S8: | ||
422 | spec->format = AUDIO_U8; | ||
423 | break; | ||
424 | case AUDIO_U16LSB: | ||
425 | spec->format = AUDIO_S16LSB; | ||
426 | break; | ||
427 | case AUDIO_U16MSB: | ||
428 | spec->format = AUDIO_S16MSB; | ||
429 | break; | ||
430 | } | ||
431 | SDL_CalculateAudioSpec(spec); | ||
432 | |||
433 | /* initialize the double-back header */ | ||
434 | SDL_memset(&audio_dbh, 0, sizeof(audio_dbh)); | ||
435 | doubleBackProc = NewSndDoubleBackProc (sndDoubleBackProc); | ||
436 | sample_bits = spec->size / spec->samples / spec->channels * 8; | ||
437 | |||
438 | audio_dbh.dbhNumChannels = spec->channels; | ||
439 | audio_dbh.dbhSampleSize = sample_bits; | ||
440 | audio_dbh.dbhCompressionID = 0; | ||
441 | audio_dbh.dbhPacketSize = 0; | ||
442 | audio_dbh.dbhSampleRate = spec->freq << 16; | ||
443 | audio_dbh.dbhDoubleBack = doubleBackProc; | ||
444 | audio_dbh.dbhFormat = 0; | ||
445 | |||
446 | /* Note that we install the 16bitLittleEndian Converter if needed. */ | ||
447 | if ( spec->format == 0x8010 ) { | ||
448 | audio_dbh.dbhCompressionID = fixedCompression; | ||
449 | audio_dbh.dbhFormat = k16BitLittleEndianFormat; | ||
450 | } | ||
451 | |||
452 | /* allocate the 2 double-back buffers */ | ||
453 | for ( i=0; i<2; ++i ) { | ||
454 | audio_buf[i] = SDL_calloc(1, sizeof(SndDoubleBuffer)+spec->size); | ||
455 | if ( audio_buf[i] == NULL ) { | ||
456 | SDL_OutOfMemory(); | ||
457 | return(-1); | ||
458 | } | ||
459 | audio_buf[i]->dbNumFrames = spec->samples; | ||
460 | audio_buf[i]->dbFlags = dbBufferReady; | ||
461 | audio_buf[i]->dbUserInfo[0] = (long)this; | ||
462 | audio_dbh.dbhBufferPtr[i] = audio_buf[i]; | ||
463 | } | ||
464 | |||
465 | /* Create the sound manager channel */ | ||
466 | channel = (SndChannelPtr)SDL_malloc(sizeof(*channel)); | ||
467 | if ( channel == NULL ) { | ||
468 | SDL_OutOfMemory(); | ||
469 | return(-1); | ||
470 | } | ||
471 | if ( spec->channels >= 2 ) { | ||
472 | initOptions = initStereo; | ||
473 | } else { | ||
474 | initOptions = initMono; | ||
475 | } | ||
476 | channel->userInfo = 0; | ||
477 | channel->qLength = 128; | ||
478 | if ( SndNewChannel(&channel, sampledSynth, initOptions, 0L) != noErr ) { | ||
479 | SDL_SetError("Unable to create audio channel"); | ||
480 | SDL_free(channel); | ||
481 | channel = NULL; | ||
482 | return(-1); | ||
483 | } | ||
484 | |||
485 | /* Start playback */ | ||
486 | if ( SndPlayDoubleBuffer(channel, (SndDoubleBufferHeaderPtr)&audio_dbh) | ||
487 | != noErr ) { | ||
488 | SDL_SetError("Unable to play double buffered audio"); | ||
489 | return(-1); | ||
490 | } | ||
491 | |||
492 | return 1; | ||
493 | } | ||
494 | |||
495 | #endif /* TARGET_API_MAC_CARBON || USE_RYANS_SOUNDCODE */ | ||
496 | |||
diff --git a/apps/plugins/sdl/src/audio/macrom/SDL_romaudio.h b/apps/plugins/sdl/src/audio/macrom/SDL_romaudio.h deleted file mode 100644 index 90e19c0695..0000000000 --- a/apps/plugins/sdl/src/audio/macrom/SDL_romaudio.h +++ /dev/null | |||
@@ -1,50 +0,0 @@ | |||
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 | #ifndef _SDL_romaudio_h | ||
25 | #define _SDL_romaudio_h | ||
26 | |||
27 | #include "../SDL_sysaudio.h" | ||
28 | |||
29 | /* This is Ryan's improved MacOS sound code, with locking support */ | ||
30 | #define USE_RYANS_SOUNDCODE | ||
31 | |||
32 | /* Hidden "this" pointer for the video functions */ | ||
33 | #define _THIS SDL_AudioDevice *this | ||
34 | |||
35 | struct SDL_PrivateAudioData { | ||
36 | /* Sound manager audio channel */ | ||
37 | SndChannelPtr channel; | ||
38 | #if defined(TARGET_API_MAC_CARBON) || defined(USE_RYANS_SOUNDCODE) | ||
39 | /* FIXME: Add Ryan's static data here */ | ||
40 | #else | ||
41 | /* Double buffering variables */ | ||
42 | SndDoubleBufferPtr audio_buf[2]; | ||
43 | #endif | ||
44 | }; | ||
45 | |||
46 | /* Old variable names */ | ||
47 | #define channel (this->hidden->channel) | ||
48 | #define audio_buf (this->hidden->audio_buf) | ||
49 | |||
50 | #endif /* _SDL_romaudio_h */ | ||