This repository has been archived by the owner on Feb 11, 2021. It is now read-only.
/
SDL_coreaudio.c
281 lines (236 loc) · 8.36 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
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
63
this = (SDL_AudioDevice *) SDL_malloc (sizeof (SDL_AudioDevice));
if (this) {
SDL_memset (this, 0, (sizeof *this));
64
this->hidden = (struct SDL_PrivateAudioData *)
65
SDL_malloc ((sizeof *this->hidden));
66
}
67
68
69
70
if ((this == NULL) || (this->hidden == NULL)) {
SDL_OutOfMemory ();
if (this) {
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
106
if (!this->enabled || this->paused) {
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
125
126
SDL_memset (buffer, this->spec.silence, bufferSize);
SDL_mutexP (this->mixer_lock);
(*this->spec.callback) (this->spec.userdata, buffer, bufferSize);
SDL_mutexV (this->mixer_lock);
127
128
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
168
169
/* stop processing the audio unit */
result = AudioOutputUnitStop (outputAudioUnit);
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
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
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
239
comp = FindNextComponent (NULL, &desc);
if (comp == NULL) {
240
241
SDL_SetError
("Failed to start CoreAudio: FindNextComponent returned NULL");
242
243
return -1;
}
244
245
246
/* Open & initialize the default output audio unit */
result = OpenAComponent (comp, &outputAudioUnit);
247
248
249
250
251
252
253
254
255
256
257
258
259
CHECK_RESULT ("OpenAComponent")
result = AudioUnitInitialize (outputAudioUnit);
CHECK_RESULT ("AudioUnitInitialize")
/* Set the input format of the audio unit. */
result = AudioUnitSetProperty (outputAudioUnit,
kAudioUnitProperty_StreamFormat,
kAudioUnitScope_Input,
0,
&requestedDesc,
sizeof (requestedDesc));
CHECK_RESULT ("AudioUnitSetProperty (kAudioUnitProperty_StreamFormat)")
/* Set the audio callback */
callback.inputProc = audioCallback;
260
callback.inputProcRefCon = this;
261
262
263
264
265
266
267
268
269
result = AudioUnitSetProperty (outputAudioUnit,
kAudioUnitProperty_SetInputCallback,
kAudioUnitScope_Input,
0, &callback, sizeof (callback));
CHECK_RESULT
("AudioUnitSetProperty (kAudioUnitProperty_SetInputCallback)")
/* Calculate the final parameters for this audio specification */
SDL_CalculateAudioSpec (spec);
270
271
/* Allocate a sample buffer */
bufferOffset = bufferSize = this->spec.size;
272
buffer = SDL_malloc (bufferSize);
273
274
275
/* Finally, start processing of the audio unit */
result = AudioOutputUnitStart (outputAudioUnit);
276
277
278
CHECK_RESULT ("AudioOutputUnitStart")
/* We're running! */
return (1);
279
}
280
281
/* vi: set ts=4 sw=4 expandtab: */