This repository has been archived by the owner on Feb 11, 2021. It is now read-only.
/
SDL_coreaudio.c
310 lines (262 loc) · 9.22 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
20
21
Sam Lantinga
slouken@libsdl.org
*/
22
#include "SDL_config.h"
23
24
25
26
#include <AudioUnit/AudioUnit.h>
#include "SDL_audio.h"
27
28
#include "../SDL_audio_c.h"
#include "../SDL_sysaudio.h"
29
30
31
32
33
#include "SDL_coreaudio.h"
/* Audio driver functions */
34
static int Core_OpenAudio(_THIS, SDL_AudioSpec * spec);
35
36
37
38
39
40
41
static void Core_WaitAudio(_THIS);
static void Core_PlayAudio(_THIS);
static Uint8 *Core_GetAudioBuf(_THIS);
static void Core_CloseAudio(_THIS);
/* Audio driver bootstrap functions */
42
43
static int
Audio_Available(void)
44
{
45
return (1);
46
47
}
48
49
static void
Audio_DeleteDevice(SDL_AudioDevice * device)
50
{
51
52
SDL_free(device->hidden);
SDL_free(device);
53
54
}
55
56
static SDL_AudioDevice *
Audio_CreateDevice(int devindex)
57
58
59
60
{
SDL_AudioDevice *this;
/* Initialize all variables that we clean on shutdown */
61
62
this = (SDL_AudioDevice *) SDL_malloc(sizeof(SDL_AudioDevice));
if (this) {
63
SDL_memset(this, 0, (sizeof *this));
64
this->hidden = (struct SDL_PrivateAudioData *)
65
SDL_malloc((sizeof *this->hidden));
66
}
67
if ((this == NULL) || (this->hidden == NULL)) {
68
SDL_OutOfMemory();
69
if (this) {
70
SDL_free(this);
71
}
72
return (0);
73
}
74
SDL_memset(this->hidden, 0, (sizeof *this->hidden));
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
/* Set the function pointers */
this->OpenAudio = Core_OpenAudio;
this->WaitAudio = Core_WaitAudio;
this->PlayAudio = Core_PlayAudio;
this->GetAudioBuf = Core_GetAudioBuf;
this->CloseAudio = Core_CloseAudio;
this->free = Audio_DeleteDevice;
return this;
}
AudioBootStrap COREAUDIO_bootstrap = {
"coreaudio", "Mac OS X CoreAudio",
Audio_Available, Audio_CreateDevice
};
/* The CoreAudio callback */
94
95
96
97
98
static OSStatus
audioCallback(void *inRefCon,
AudioUnitRenderActionFlags inActionFlags,
const AudioTimeStamp * inTimeStamp,
UInt32 inBusNumber, AudioBuffer * ioData)
99
{
100
SDL_AudioDevice *this = (SDL_AudioDevice *) inRefCon;
101
102
103
104
UInt32 remaining, len;
void *ptr;
/* Only do anything if audio is enabled and not paused */
105
if (!this->enabled || this->paused) {
106
SDL_memset(ioData->mData, this->spec.silence, ioData->mDataByteSize);
107
108
return 0;
}
109
110
111
112
/* No SDL conversion should be needed here, ever, since we accept
any input format in OpenAudio, and leave the conversion to CoreAudio.
*/
113
/*
114
115
assert(!this->convert.needed);
assert(this->spec.channels == ioData->mNumberChannels);
116
*/
117
118
119
120
121
122
remaining = ioData->mDataByteSize;
ptr = ioData->mData;
while (remaining > 0) {
if (bufferOffset >= bufferSize) {
/* Generate the data */
123
SDL_memset(buffer, this->spec.silence, bufferSize);
124
SDL_mutexP(this->mixer_lock);
125
(*this->spec.callback) (this->spec.userdata, buffer, bufferSize);
126
127
128
SDL_mutexV(this->mixer_lock);
bufferOffset = 0;
}
129
130
131
132
len = bufferSize - bufferOffset;
if (len > remaining)
len = remaining;
133
134
SDL_memcpy(ptr, (char *) buffer + bufferOffset, len);
ptr = (char *) ptr + len;
135
136
137
remaining -= len;
bufferOffset += len;
}
138
139
140
141
142
return 0;
}
/* Dummy functions -- we don't use thread-based audio */
143
144
void
Core_WaitAudio(_THIS)
145
146
147
148
{
return;
}
149
150
void
Core_PlayAudio(_THIS)
151
152
153
154
{
return;
}
155
156
Uint8 *
Core_GetAudioBuf(_THIS)
157
{
158
return (NULL);
159
160
}
161
162
void
Core_CloseAudio(_THIS)
163
164
{
OSStatus result;
165
struct AudioUnitInputCallback callback;
166
167
/* stop processing the audio unit */
168
result = AudioOutputUnitStop(outputAudioUnit);
169
170
171
172
173
174
175
176
if (result != noErr) {
SDL_SetError("Core_CloseAudio: AudioOutputUnitStop");
return;
}
/* Remove the input callback */
callback.inputProc = 0;
callback.inputProcRefCon = 0;
177
178
179
180
result = AudioUnitSetProperty(outputAudioUnit,
kAudioUnitProperty_SetInputCallback,
kAudioUnitScope_Input,
0, &callback, sizeof(callback));
181
if (result != noErr) {
182
183
SDL_SetError
("Core_CloseAudio: AudioUnitSetProperty (kAudioUnitProperty_SetInputCallback)");
184
185
186
187
188
189
190
191
return;
}
result = CloseComponent(outputAudioUnit);
if (result != noErr) {
SDL_SetError("Core_CloseAudio: CloseComponent");
return;
}
192
193
SDL_free(buffer);
194
195
196
197
198
199
200
201
202
}
#define CHECK_RESULT(msg) \
if (result != noErr) { \
SDL_SetError("Failed to start CoreAudio: " msg); \
return -1; \
}
203
204
int
Core_OpenAudio(_THIS, SDL_AudioSpec * spec)
205
206
207
208
{
OSStatus result = noErr;
Component comp;
ComponentDescription desc;
209
struct AudioUnitInputCallback callback;
210
211
212
AudioStreamBasicDescription desc;
SDL_AudioFormat test_format = SDL_FirstAudioFormat(spec->format);
int valid_datatype = 0;
213
214
/* Setup a AudioStreamBasicDescription with the requested format */
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
memset(&desc, '\0', sizeof (AudioStreamBasicDescription));
desc.mFormatID = kAudioFormatLinearPCM;
desc.mFormatFlags = kLinearPCMFormatFlagIsPacked;
desc.mChannelsPerFrame = spec->channels;
desc.mSampleRate = spec->freq;
desc.mFramesPerPacket = 1;
while ((!valid_datatype) && (test_format)) {
spec->format = test_format;
desc.mFormatFlags = 0;
/* Just a list of valid SDL formats, so people don't pass junk here. */
switch (test_format) {
case AUDIO_U8:
case AUDIO_S8:
case AUDIO_U16LSB:
case AUDIO_S16LSB:
case AUDIO_U16MSB:
case AUDIO_S16MSB:
case AUDIO_S32LSB:
case AUDIO_S32MSB:
case AUDIO_F32LSB:
case AUDIO_F32MSB:
valid_datatype = 1;
desc.mBitsPerChannel = SDL_AUDIO_BITSIZE(spec->format);
if (SDL_AUDIO_ISFLOAT(spec->format))
desc.mFormatFlags |= kLinearPCMFormatFlagIsFloat;
else if (SDL_AUDIO_ISSIGNED(spec->format))
desc.mFormatFlags |= kLinearPCMFormatFlagIsSignedInteger;
if (SDL_AUDIO_ISBIGENDIAN(spec->format))
desc.mFormatFlags |= kLinearPCMFormatFlagIsBigEndian;
break;
}
}
250
251
252
253
254
if (!valid_datatype) { /* shouldn't happen, but just in case... */
SDL_SetError("Unsupported audio format");
return (-1);
}
255
256
257
258
259
desc.mBytesPerFrame =
desc.mBitsPerChannel * desc.mChannelsPerFrame / 8;
desc.mBytesPerPacket =
desc.mBytesPerFrame * desc.mFramesPerPacket;
260
261
262
263
264
265
266
267
/* Locate the default output audio unit */
desc.componentType = kAudioUnitComponentType;
desc.componentSubType = kAudioUnitSubType_Output;
desc.componentManufacturer = kAudioUnitID_DefaultOutput;
desc.componentFlags = 0;
desc.componentFlagsMask = 0;
268
269
comp = FindNextComponent(NULL, &desc);
270
if (comp == NULL) {
271
272
SDL_SetError
("Failed to start CoreAudio: FindNextComponent returned NULL");
273
274
return -1;
}
275
276
/* Open & initialize the default output audio unit */
277
result = OpenAComponent(comp, &outputAudioUnit);
278
CHECK_RESULT("OpenAComponent")
279
result = AudioUnitInitialize(outputAudioUnit);
280
CHECK_RESULT("AudioUnitInitialize")
281
282
283
284
285
/* Set the input format of the audio unit. */
result = AudioUnitSetProperty(outputAudioUnit,
kAudioUnitProperty_StreamFormat,
kAudioUnitScope_Input,
0,
286
&desc, sizeof (desc));
287
CHECK_RESULT("AudioUnitSetProperty (kAudioUnitProperty_StreamFormat)")
288
289
/* Set the audio callback */
callback.inputProc = audioCallback;
290
callback.inputProcRefCon = this;
291
292
293
294
result = AudioUnitSetProperty(outputAudioUnit,
kAudioUnitProperty_SetInputCallback,
kAudioUnitScope_Input,
0, &callback, sizeof(callback));
295
CHECK_RESULT("AudioUnitSetProperty (kAudioUnitProperty_SetInputCallback)")
296
297
/* Calculate the final parameters for this audio specification */
SDL_CalculateAudioSpec(spec);
298
299
300
/* Allocate a sample buffer */
bufferOffset = bufferSize = this->spec.size;
301
buffer = SDL_malloc(bufferSize);
302
303
/* Finally, start processing of the audio unit */
304
305
306
307
result = AudioOutputUnitStart(outputAudioUnit);
CHECK_RESULT("AudioOutputUnitStart")
/* We're running! */
return (1);
308
}
309
310
/* vi: set ts=4 sw=4 expandtab: */