This repository has been archived by the owner on Feb 11, 2021. It is now read-only.
/
SDL_coreaudio.c
307 lines (261 loc) · 9.2 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.
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)
48
49
static void
Audio_DeleteDevice(SDL_AudioDevice * device)
51
52
SDL_free(device->hidden);
SDL_free(device);
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));
67
if ((this == NULL) || (this->hidden == NULL)) {
68
SDL_OutOfMemory();
70
SDL_free(this);
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)
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;
}
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.
*/
114
115
assert(!this->convert.needed);
assert(this->spec.channels == ioData->mNumberChannels);
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;
}
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;
}
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)
158
return (NULL);
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;
}
193
SDL_free(buffer);
194
195
196
197
}
#define CHECK_RESULT(msg) \
if (result != noErr) { \
198
SDL_SetError("CoreAudio error (%s): %d", msg, (int) result); \
199
200
201
202
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
AudioStreamBasicDescription strdesc;
211
212
SDL_AudioFormat test_format = SDL_FirstAudioFormat(spec->format);
int valid_datatype = 0;
213
214
/* Setup a AudioStreamBasicDescription with the requested format */
215
memset(&strdesc, '\0', sizeof(AudioStreamBasicDescription));
216
217
218
219
220
strdesc.mFormatID = kAudioFormatLinearPCM;
strdesc.mFormatFlags = kLinearPCMFormatFlagIsPacked;
strdesc.mChannelsPerFrame = spec->channels;
strdesc.mSampleRate = spec->freq;
strdesc.mFramesPerPacket = 1;
221
222
223
224
225
while ((!valid_datatype) && (test_format)) {
spec->format = test_format;
/* Just a list of valid SDL formats, so people don't pass junk here. */
switch (test_format) {
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
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;
strdesc.mBitsPerChannel = SDL_AUDIO_BITSIZE(spec->format);
if (SDL_AUDIO_ISBIGENDIAN(spec->format))
strdesc.mFormatFlags |= kLinearPCMFormatFlagIsBigEndian;
if (SDL_AUDIO_ISFLOAT(spec->format))
strdesc.mFormatFlags |= kLinearPCMFormatFlagIsFloat;
else if (SDL_AUDIO_ISSIGNED(spec->format))
strdesc.mFormatFlags |= kLinearPCMFormatFlagIsSignedInteger;
break;
249
if (!valid_datatype) { /* shouldn't happen, but just in case... */
250
251
252
SDL_SetError("Unsupported audio format");
return (-1);
}
254
255
256
257
strdesc.mBytesPerFrame =
strdesc.mBitsPerChannel * strdesc.mChannelsPerFrame / 8;
strdesc.mBytesPerPacket =
strdesc.mBytesPerFrame * strdesc.mFramesPerPacket;
258
259
/* Locate the default output audio unit */
260
memset(&desc, '\0', sizeof(ComponentDescription));
261
262
263
264
265
desc.componentType = kAudioUnitComponentType;
desc.componentSubType = kAudioUnitSubType_Output;
desc.componentManufacturer = kAudioUnitID_DefaultOutput;
desc.componentFlags = 0;
desc.componentFlagsMask = 0;
266
267
comp = FindNextComponent(NULL, &desc);
268
if (comp == NULL) {
269
270
SDL_SetError
("Failed to start CoreAudio: FindNextComponent returned NULL");
271
272
return -1;
}
274
/* Open & initialize the default output audio unit */
275
result = OpenAComponent(comp, &outputAudioUnit);
276
CHECK_RESULT("OpenAComponent")
277
result = AudioUnitInitialize(outputAudioUnit);
278
CHECK_RESULT("AudioUnitInitialize")
279
280
281
282
/* Set the input format of the audio unit. */
result = AudioUnitSetProperty(outputAudioUnit,
kAudioUnitProperty_StreamFormat,
kAudioUnitScope_Input,
283
0, &strdesc, sizeof(strdesc));
284
CHECK_RESULT("AudioUnitSetProperty (kAudioUnitProperty_StreamFormat)")
285
286
/* Set the audio callback */
callback.inputProc = audioCallback;
287
callback.inputProcRefCon = this;
288
289
290
291
result = AudioUnitSetProperty(outputAudioUnit,
kAudioUnitProperty_SetInputCallback,
kAudioUnitScope_Input,
0, &callback, sizeof(callback));
292
CHECK_RESULT("AudioUnitSetProperty (kAudioUnitProperty_SetInputCallback)")
293
294
/* Calculate the final parameters for this audio specification */
SDL_CalculateAudioSpec(spec);
295
296
297
/* Allocate a sample buffer */
bufferOffset = bufferSize = this->spec.size;
298
buffer = SDL_malloc(bufferSize);
300
/* Finally, start processing of the audio unit */
301
302
303
304
result = AudioOutputUnitStart(outputAudioUnit);
CHECK_RESULT("AudioOutputUnitStart")
/* We're running! */
return (1);
306
307
/* vi: set ts=4 sw=4 expandtab: */