This repository has been archived by the owner on Feb 11, 2021. It is now read-only.
/
SDL_coreaudio.c
279 lines (234 loc) · 8.25 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
35
36
37
38
static int Core_OpenAudio(_THIS, SDL_AudioSpec * spec);
static void Core_WaitAudio(_THIS);
static void Core_PlayAudio(_THIS);
static Uint8 *Core_GetAudioBuf(_THIS);
static void Core_CloseAudio(_THIS);
39
40
41
/* Audio driver bootstrap functions */
42
static int
43
Audio_Available(void)
44
{
45
return (1);
46
47
}
48
static void
49
Audio_DeleteDevice(SDL_AudioDevice * device)
50
{
51
52
SDL_free(device->hidden);
SDL_free(device);
53
54
}
55
static SDL_AudioDevice *
56
Audio_CreateDevice(int devindex)
57
58
59
60
{
SDL_AudioDevice *this;
/* Initialize all variables that we clean on shutdown */
61
this = (SDL_AudioDevice *) SDL_malloc(sizeof(SDL_AudioDevice));
62
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
static OSStatus
95
96
97
98
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
124
SDL_memset(buffer, this->spec.silence, bufferSize);
SDL_mutexP(this->mixer_lock);
125
(*this->spec.callback) (this->spec.userdata, buffer, bufferSize);
126
SDL_mutexV(this->mixer_lock);
127
128
bufferOffset = 0;
}
129
130
131
132
len = bufferSize - bufferOffset;
if (len > remaining)
len = remaining;
133
SDL_memcpy(ptr, (char *) buffer + bufferOffset, len);
134
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
void
144
Core_WaitAudio(_THIS)
145
146
147
148
{
return;
}
149
void
150
Core_PlayAudio(_THIS)
151
152
153
154
{
return;
}
155
Uint8 *
156
Core_GetAudioBuf(_THIS)
157
{
158
return (NULL);
159
160
}
161
void
162
Core_CloseAudio(_THIS)
163
164
{
OSStatus result;
165
struct AudioUnitInputCallback callback;
166
167
/* stop processing the audio unit */
168
result = AudioOutputUnitStop(outputAudioUnit);
169
if (result != noErr) {
170
SDL_SetError("Core_CloseAudio: AudioOutputUnitStop");
171
172
173
174
175
176
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
return;
}
187
result = CloseComponent(outputAudioUnit);
188
if (result != noErr) {
189
SDL_SetError("Core_CloseAudio: CloseComponent");
190
191
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
int
204
Core_OpenAudio(_THIS, SDL_AudioSpec * spec)
205
206
207
208
{
OSStatus result = noErr;
Component comp;
ComponentDescription desc;
209
struct AudioUnitInputCallback callback;
210
211
212
213
214
215
216
AudioStreamBasicDescription requestedDesc;
/* Setup a AudioStreamBasicDescription with the requested format */
requestedDesc.mFormatID = kAudioFormatLinearPCM;
requestedDesc.mFormatFlags = kLinearPCMFormatFlagIsPacked;
requestedDesc.mChannelsPerFrame = spec->channels;
requestedDesc.mSampleRate = spec->freq;
217
218
219
220
221
222
223
224
requestedDesc.mBitsPerChannel = spec->format & 0xFF;
if (spec->format & 0x8000)
requestedDesc.mFormatFlags |= kLinearPCMFormatFlagIsSignedInteger;
if (spec->format & 0x1000)
requestedDesc.mFormatFlags |= kLinearPCMFormatFlagIsBigEndian;
requestedDesc.mFramesPerPacket = 1;
225
226
227
228
requestedDesc.mBytesPerFrame =
requestedDesc.mBitsPerChannel * requestedDesc.mChannelsPerFrame / 8;
requestedDesc.mBytesPerPacket =
requestedDesc.mBytesPerFrame * requestedDesc.mFramesPerPacket;
229
230
231
232
233
234
235
236
/* Locate the default output audio unit */
desc.componentType = kAudioUnitComponentType;
desc.componentSubType = kAudioUnitSubType_Output;
desc.componentManufacturer = kAudioUnitID_DefaultOutput;
desc.componentFlags = 0;
desc.componentFlagsMask = 0;
237
238
comp = FindNextComponent(NULL, &desc);
239
if (comp == NULL) {
240
241
SDL_SetError
("Failed to start CoreAudio: FindNextComponent returned NULL");
242
243
return -1;
}
244
245
/* Open & initialize the default output audio unit */
246
247
248
249
result = OpenAComponent(comp, &outputAudioUnit);
CHECK_RESULT("OpenAComponent")
result = AudioUnitInitialize(outputAudioUnit);
CHECK_RESULT("AudioUnitInitialize")
250
/* Set the input format of the audio unit. */
251
252
253
254
255
256
result = AudioUnitSetProperty(outputAudioUnit,
kAudioUnitProperty_StreamFormat,
kAudioUnitScope_Input,
0,
&requestedDesc, sizeof(requestedDesc));
CHECK_RESULT("AudioUnitSetProperty (kAudioUnitProperty_StreamFormat)")
257
258
/* Set the audio callback */
callback.inputProc = audioCallback;
259
callback.inputProcRefCon = this;
260
261
262
263
264
result = AudioUnitSetProperty(outputAudioUnit,
kAudioUnitProperty_SetInputCallback,
kAudioUnitScope_Input,
0, &callback, sizeof(callback));
CHECK_RESULT("AudioUnitSetProperty (kAudioUnitProperty_SetInputCallback)")
265
/* Calculate the final parameters for this audio specification */
266
SDL_CalculateAudioSpec(spec);
267
268
269
/* Allocate a sample buffer */
bufferOffset = bufferSize = this->spec.size;
270
buffer = SDL_malloc(bufferSize);
271
272
/* Finally, start processing of the audio unit */
273
274
result = AudioOutputUnitStart(outputAudioUnit);
CHECK_RESULT("AudioOutputUnitStart")
275
276
/* We're running! */
return (1);
277
}
278
279
/* vi: set ts=4 sw=4 expandtab: */