This repository has been archived by the owner on Feb 11, 2021. It is now read-only.
/
SDL_romaudio.c
317 lines (270 loc) · 9.02 KB
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
11
12
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
13
Lesser General Public License for more details.
14
15
16
17
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
18
19
Sam Lantinga
20
slouken@libsdl.org
21
*/
22
#include "SDL_config.h"
23
24
25
/* This should work on PowerPC and Intel Mac OS X, and Carbonized Mac OS 9. */
26
#if defined(__APPLE__) && defined(__MACH__)
27
# define SDL_MACOS_NAME "Mac OS X"
28
29
# include <Carbon/Carbon.h>
#elif TARGET_API_MAC_CARBON && (UNIVERSAL_INTERFACES_VERSION > 0x0335)
30
# define SDL_MACOS_NAME "Mac OS 9"
31
32
# include <Carbon.h>
#else
33
# define SDL_MACOS_NAME "Mac OS 9"
34
# include <Sound.h> /* SoundManager interface */
35
# include <Gestalt.h>
36
# include <DriverServices.h>
37
38
#endif
39
#if !defined(NewSndCallBackUPP) && (UNIVERSAL_INTERFACES_VERSION < 0x0335)
40
#if !defined(NewSndCallBackProc) /* avoid circular redefinition... */
41
42
#define NewSndCallBackUPP NewSndCallBackProc
#endif
43
44
45
#if !defined(NewSndCallBackUPP)
#define NewSndCallBackUPP NewSndCallBackProc
#endif
46
47
#endif
48
#include "SDL_audio.h"
49
50
#include "../SDL_audio_c.h"
#include "../SDL_sysaudio.h"
51
52
#include "SDL_romaudio.h"
53
54
55
56
#pragma options align=power
static volatile SInt32 audio_is_locked = 0;
static volatile SInt32 need_to_mix = 0;
57
58
static UInt8 *buffer[2];
59
60
static volatile UInt32 running = 0;
static CmpSoundHeader header;
61
62
static volatile Uint32 fill_me = 0;
63
64
65
static void
mix_buffer(SDL_AudioDevice * audio, UInt8 * buffer)
66
{
67
if (!audio->paused) {
68
#ifdef __MACOSX__
69
70
SDL_mutexP(audio->mixer_lock);
#endif
71
if (audio->convert.needed) {
72
audio->spec.callback(audio->spec.userdata,
73
74
(Uint8 *) audio->convert.buf,
audio->convert.len);
75
SDL_ConvertAudio(&audio->convert);
76
77
if (audio->convert.len_cvt != audio->spec.size) {
/* Uh oh... probably crashes here */ ;
78
}
79
SDL_memcpy(buffer, audio->convert.buf, audio->convert.len_cvt);
80
} else {
81
82
audio->spec.callback(audio->spec.userdata, buffer,
audio->spec.size);
83
}
84
#ifdef __MACOSX__
85
86
SDL_mutexV(audio->mixer_lock);
#endif
87
88
}
89
DecrementAtomic((SInt32 *) & need_to_mix);
90
91
}
92
static void
93
SNDMGR_LockDevice(_THIS)
94
{
95
IncrementAtomic((SInt32 *) & audio_is_locked);
96
97
}
98
static void
99
SNDMGR_UnlockDevice(_THIS)
100
101
{
SInt32 oldval;
102
103
104
oldval = DecrementAtomic((SInt32 *) & audio_is_locked);
if (oldval != 1) /* != 1 means audio is still locked. */
105
106
107
return;
/* Did we miss the chance to mix in an interrupt? Do it now. */
108
if (BitAndAtomic(0xFFFFFFFF, (UInt32 *) & need_to_mix)) {
109
110
111
112
113
/*
* Note that this could be a problem if you missed an interrupt
* while the audio was locked, and get preempted by a second
* interrupt here, but that means you locked for way too long anyhow.
*/
114
mix_buffer(this, buffer[fill_me]);
115
116
}
}
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
static void
callBackProc(SndChannel * chan, SndCommand * cmd_passed)
{
UInt32 play_me;
SndCommand cmd;
SDL_AudioDevice *audio = (SDL_AudioDevice *) chan->userInfo;
IncrementAtomic((SInt32 *) & need_to_mix);
fill_me = cmd_passed->param2; /* buffer that has just finished playing, so fill it */
play_me = !fill_me; /* filled buffer to play _now_ */
if (!audio->enabled) {
return;
}
/* queue previously mixed buffer for playback. */
header.samplePtr = (Ptr) buffer[play_me];
cmd.cmd = bufferCmd;
cmd.param1 = 0;
cmd.param2 = (long) &header;
SndDoCommand(chan, &cmd, 0);
141
SDL_memset(buffer[fill_me], 0, audio->spec.size);
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
/*
* if audio device isn't locked, mix the next buffer to be queued in
* the memory block that just finished playing.
*/
if (!BitAndAtomic(0xFFFFFFFF, (UInt32 *) & audio_is_locked)) {
mix_buffer(audio, buffer[fill_me]);
}
/* set this callback to run again when current buffer drains. */
if (running) {
cmd.cmd = callBackCmd;
cmd.param1 = 0;
cmd.param2 = play_me;
SndDoCommand(chan, &cmd, 0);
}
159
160
}
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
static void
SNDMGR_CloseDevice(_THIS)
{
running = 0;
if (this->hidden != NULL) {
if (this->hidden->channel) {
SndDisposeChannel(this->hidden->channel, true);
this->hidden->channel = NULL;
}
SDL_free(buffer[0]);
SDL_free(buffer[1]);
buffer[0] = buffer[1] = NULL;
SDL_free(this->hidden);
this->hidden = NULL;
}
}
181
static int
182
SNDMGR_OpenDevice(_THIS, const char *devname, int iscapture)
183
{
184
185
SDL_AudioSpec *spec = &this->spec;
SndChannelPtr channel = NULL;
186
187
188
189
SndCallBackUPP callback;
int sample_bits;
int i;
long initOptions;
190
191
192
/* Initialize all variables that we clean on shutdown */
this->hidden = (struct SDL_PrivateAudioData *)
193
SDL_malloc((sizeof *this->hidden));
194
195
196
197
198
199
200
if (this->hidden == NULL) {
SDL_OutOfMemory();
return 0;
}
SDL_memset(this->hidden, 0, (sizeof *this->hidden));
/* !!! FIXME: iterate through format matrix... */
201
/* Very few conversions are required, but... */
202
switch (spec->format) {
203
case AUDIO_S8:
204
205
spec->format = AUDIO_U8;
break;
206
case AUDIO_U16LSB:
207
208
spec->format = AUDIO_S16LSB;
break;
209
case AUDIO_U16MSB:
210
211
spec->format = AUDIO_S16MSB;
break;
212
213
214
case AUDIO_F32LSB:
spec->format = AUDIO_F32MSB;
break;
215
}
216
SDL_CalculateAudioSpec(&this->spec);
217
218
/* initialize bufferCmd header */
219
SDL_memset(&header, 0, sizeof(header));
220
callback = (SndCallBackUPP) NewSndCallBackUPP(callBackProc);
221
222
223
224
sample_bits = spec->size / spec->samples / spec->channels * 8;
#ifdef DEBUG_AUDIO
fprintf(stderr,
225
226
"Audio format 0x%x, channels = %d, sample_bits = %d, frequency = %d\n",
spec->format, spec->channels, sample_bits, spec->freq);
227
#endif /* DEBUG_AUDIO */
228
229
header.numChannels = spec->channels;
230
231
232
233
234
header.sampleSize = sample_bits;
header.sampleRate = spec->freq << 16;
header.numFrames = spec->samples;
header.encode = cmpSH;
235
/* Note that we install the 16bitLittleEndian Converter if needed. */
236
if (spec->format == AUDIO_S16LSB) {
237
238
header.compressionID = fixedCompression;
header.format = k16BitLittleEndianFormat;
239
240
241
242
243
244
245
246
247
} else if (spec->format == AUDIO_S32MSB) {
header.compressionID = fixedCompression;
header.format = k32BitFormat;
} else if (spec->format == AUDIO_S32LSB) {
header.compressionID = fixedCompression;
header.format = k32BitLittleEndianFormat;
} else if (spec->format == AUDIO_F32MSB) {
header.compressionID = fixedCompression;
header.format = kFloat32Format;
248
}
249
250
/* allocate 2 buffers */
251
for (i = 0; i < 2; i++) {
252
buffer[i] = (UInt8 *) SDL_malloc(sizeof(UInt8) * spec->size);
253
if (buffer[i] == NULL) {
254
SNDMGR_CloseDevice(this);
255
SDL_OutOfMemory();
256
return 0;
257
}
258
SDL_memset(buffer[i], 0, spec->size);
259
260
261
262
263
}
/* Create the sound manager channel */
channel = (SndChannelPtr) SDL_malloc(sizeof(*channel));
if (channel == NULL) {
264
SNDMGR_CloseDevice(this);
265
SDL_OutOfMemory();
266
return 0;
267
}
268
this->hidden->channel = channel;
269
if (spec->channels >= 2) {
270
271
272
273
initOptions = initStereo;
} else {
initOptions = initMono;
}
274
channel->userInfo = (long) this;
275
channel->qLength = 128;
276
if (SndNewChannel(&channel, sampledSynth, initOptions, callback) != noErr) {
277
SNDMGR_CloseDevice(this);
278
SDL_SetError("Unable to create audio channel");
279
return 0;
280
}
281
282
283
284
285
286
287
288
289
290
291
/* start playback */
{
SndCommand cmd;
cmd.cmd = callBackCmd;
cmd.param2 = 0;
running = 1;
SndDoCommand(channel, &cmd, 0);
}
return 1;
292
293
}
294
static int
295
SNDMGR_Init(SDL_AudioDriverImpl * impl)
296
{
297
298
299
300
301
302
303
304
305
306
307
308
/* Set the function pointers */
impl->OpenDevice = SNDMGR_OpenDevice;
impl->CloseDevice = SNDMGR_CloseDevice;
impl->ProvidesOwnCallbackThread = 1;
impl->OnlyHasDefaultOutputDevice = 1;
/* Mac OS X uses threaded audio, so normal thread code is okay */
#ifndef __MACOSX__
impl->LockDevice = SNDMGR_LockDevice;
impl->UnlockDevice = SNDMGR_UnlockDevice;
impl->SkipMixerLock = 1;
#endif
309
310
311
312
return 1;
}
313
314
315
316
AudioBootStrap SNDMGR_bootstrap = {
"sndmgr", SDL_MACOS_NAME " SoundManager", SNDMGR_Init, 0
};
317
/* vi: set ts=4 sw=4 expandtab: */