e14743d1 |
1 | /* |
2 | SDL - Simple DirectMedia Layer |
3 | Copyright (C) 1997-2009 Sam Lantinga |
4 | |
5 | This library is free software; you can redistribute it and/or |
6 | modify it under the terms of the GNU Library General Public |
7 | License as published by the Free Software Foundation; either |
8 | version 2 of the License, or (at your option) any later version. |
9 | |
10 | This library is distributed in the hope that it will be useful, |
11 | but WITHOUT ANY WARRANTY; without even the implied warranty of |
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
13 | Library General Public License for more details. |
14 | |
15 | You should have received a copy of the GNU Library General Public |
16 | License along with this library; if not, write to the Free |
17 | Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
18 | |
19 | Sam Lantinga |
20 | slouken@libsdl.org |
21 | |
22 | This file based on Apple sample code. We haven't changed the file name, |
23 | so if you want to see the original search for it on apple.com/developer |
24 | */ |
25 | #include "SDL_config.h" |
26 | #include "SDL_endian.h" |
27 | |
28 | /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |
29 | AudioFilePlayer.cpp |
30 | */ |
31 | #include "AudioFilePlayer.h" |
32 | |
33 | /* |
34 | void ThrowResult (OSStatus result, const char* str) |
35 | { |
36 | SDL_SetError ("Error: %s %d", str, result); |
37 | throw result; |
38 | } |
39 | */ |
40 | |
41 | #if DEBUG |
42 | static void PrintStreamDesc (AudioStreamBasicDescription *inDesc) |
43 | { |
44 | if (!inDesc) { |
45 | printf ("Can't print a NULL desc!\n"); |
46 | return; |
47 | } |
48 | |
49 | printf ("- - - - - - - - - - - - - - - - - - - -\n"); |
50 | printf (" Sample Rate:%f\n", inDesc->mSampleRate); |
51 | printf (" Format ID:%s\n", (char*)&inDesc->mFormatID); |
52 | printf (" Format Flags:%lX\n", inDesc->mFormatFlags); |
53 | printf (" Bytes per Packet:%ld\n", inDesc->mBytesPerPacket); |
54 | printf (" Frames per Packet:%ld\n", inDesc->mFramesPerPacket); |
55 | printf (" Bytes per Frame:%ld\n", inDesc->mBytesPerFrame); |
56 | printf (" Channels per Frame:%ld\n", inDesc->mChannelsPerFrame); |
57 | printf (" Bits per Channel:%ld\n", inDesc->mBitsPerChannel); |
58 | printf ("- - - - - - - - - - - - - - - - - - - -\n"); |
59 | } |
60 | #endif |
61 | |
62 | |
63 | static int AudioFilePlayer_SetDestination (AudioFilePlayer *afp, AudioUnit *inDestUnit) |
64 | { |
65 | /*if (afp->mConnected) throw static_cast<OSStatus>(-1);*/ /* can't set dest if already engaged */ |
66 | if (afp->mConnected) |
67 | return 0 ; |
68 | |
69 | SDL_memcpy(&afp->mPlayUnit, inDestUnit, sizeof (afp->mPlayUnit)); |
70 | |
71 | OSStatus result = noErr; |
72 | |
73 | |
74 | /* we can "down" cast a component instance to a component */ |
75 | ComponentDescription desc; |
76 | result = GetComponentInfo ((Component)*inDestUnit, &desc, 0, 0, 0); |
77 | if (result) return 0; /*THROW_RESULT("GetComponentInfo")*/ |
78 | |
79 | /* we're going to use this to know which convert routine to call |
80 | a v1 audio unit will have a type of 'aunt' |
81 | a v2 audio unit will have one of several different types. */ |
82 | if (desc.componentType != kAudioUnitType_Output) { |
83 | result = badComponentInstance; |
84 | /*THROW_RESULT("BAD COMPONENT")*/ |
85 | if (result) return 0; |
86 | } |
87 | |
88 | /* Set the input format of the audio unit. */ |
89 | result = AudioUnitSetProperty (*inDestUnit, |
90 | kAudioUnitProperty_StreamFormat, |
91 | kAudioUnitScope_Input, |
92 | 0, |
93 | &afp->mFileDescription, |
94 | sizeof (afp->mFileDescription)); |
95 | /*THROW_RESULT("AudioUnitSetProperty")*/ |
96 | if (result) return 0; |
97 | return 1; |
98 | } |
99 | |
100 | static void AudioFilePlayer_SetNotifier(AudioFilePlayer *afp, AudioFilePlayNotifier inNotifier, void *inRefCon) |
101 | { |
102 | afp->mNotifier = inNotifier; |
103 | afp->mRefCon = inRefCon; |
104 | } |
105 | |
106 | static int AudioFilePlayer_IsConnected(AudioFilePlayer *afp) |
107 | { |
108 | return afp->mConnected; |
109 | } |
110 | |
111 | static AudioUnit AudioFilePlayer_GetDestUnit(AudioFilePlayer *afp) |
112 | { |
113 | return afp->mPlayUnit; |
114 | } |
115 | |
116 | static void AudioFilePlayer_Print(AudioFilePlayer *afp) |
117 | { |
118 | #if DEBUG |
119 | printf ("Is Connected:%s\n", (IsConnected() ? "true" : "false")); |
120 | printf ("- - - - - - - - - - - - - - \n"); |
121 | #endif |
122 | } |
123 | |
124 | static void AudioFilePlayer_SetStartFrame (AudioFilePlayer *afp, int frame) |
125 | { |
126 | SInt64 position = frame * 2352; |
127 | |
128 | afp->mStartFrame = frame; |
129 | afp->mAudioFileManager->SetPosition (afp->mAudioFileManager, position); |
130 | } |
131 | |
132 | |
133 | static int AudioFilePlayer_GetCurrentFrame (AudioFilePlayer *afp) |
134 | { |
135 | return afp->mStartFrame + (afp->mAudioFileManager->GetByteCounter(afp->mAudioFileManager) / 2352); |
136 | } |
137 | |
138 | static void AudioFilePlayer_SetStopFrame (AudioFilePlayer *afp, int frame) |
139 | { |
140 | SInt64 position = frame * 2352; |
141 | |
142 | afp->mAudioFileManager->SetEndOfFile (afp->mAudioFileManager, position); |
143 | } |
144 | |
145 | void delete_AudioFilePlayer(AudioFilePlayer *afp) |
146 | { |
147 | if (afp != NULL) |
148 | { |
149 | afp->Disconnect(afp); |
150 | |
151 | if (afp->mAudioFileManager) { |
152 | delete_AudioFileManager(afp->mAudioFileManager); |
153 | afp->mAudioFileManager = 0; |
154 | } |
155 | |
156 | if (afp->mForkRefNum) { |
157 | FSCloseFork (afp->mForkRefNum); |
158 | afp->mForkRefNum = 0; |
159 | } |
160 | SDL_free(afp); |
161 | } |
162 | } |
163 | |
164 | static int AudioFilePlayer_Connect(AudioFilePlayer *afp) |
165 | { |
166 | #if DEBUG |
167 | printf ("Connect:%x, engaged=%d\n", (int)afp->mPlayUnit, (afp->mConnected ? 1 : 0)); |
168 | #endif |
169 | if (!afp->mConnected) |
170 | { |
171 | if (!afp->mAudioFileManager->DoConnect(afp->mAudioFileManager)) |
172 | return 0; |
173 | |
174 | /* set the render callback for the file data to be supplied to the sound converter AU */ |
175 | afp->mInputCallback.inputProc = afp->mAudioFileManager->FileInputProc; |
176 | afp->mInputCallback.inputProcRefCon = afp->mAudioFileManager; |
177 | |
178 | OSStatus result = AudioUnitSetProperty (afp->mPlayUnit, |
179 | kAudioUnitProperty_SetRenderCallback, |
180 | kAudioUnitScope_Input, |
181 | 0, |
182 | &afp->mInputCallback, |
183 | sizeof(afp->mInputCallback)); |
184 | if (result) return 0; /*THROW_RESULT("AudioUnitSetProperty")*/ |
185 | afp->mConnected = 1; |
186 | } |
187 | |
188 | return 1; |
189 | } |
190 | |
191 | /* warning noted, now please go away ;-) */ |
192 | /* #warning This should redirect the calling of notification code to some other thread */ |
193 | static void AudioFilePlayer_DoNotification (AudioFilePlayer *afp, OSStatus inStatus) |
194 | { |
195 | if (afp->mNotifier) { |
196 | (*afp->mNotifier) (afp->mRefCon, inStatus); |
197 | } else { |
198 | SDL_SetError ("Notification posted with no notifier in place"); |
199 | |
200 | if (inStatus == kAudioFilePlay_FileIsFinished) |
201 | afp->Disconnect(afp); |
202 | else if (inStatus != kAudioFilePlayErr_FilePlayUnderrun) |
203 | afp->Disconnect(afp); |
204 | } |
205 | } |
206 | |
207 | static void AudioFilePlayer_Disconnect (AudioFilePlayer *afp) |
208 | { |
209 | #if DEBUG |
210 | printf ("Disconnect:%x,%ld, engaged=%d\n", (int)afp->mPlayUnit, 0, (afp->mConnected ? 1 : 0)); |
211 | #endif |
212 | if (afp->mConnected) |
213 | { |
214 | afp->mConnected = 0; |
215 | |
216 | afp->mInputCallback.inputProc = 0; |
217 | afp->mInputCallback.inputProcRefCon = 0; |
218 | OSStatus result = AudioUnitSetProperty (afp->mPlayUnit, |
219 | kAudioUnitProperty_SetRenderCallback, |
220 | kAudioUnitScope_Input, |
221 | 0, |
222 | &afp->mInputCallback, |
223 | sizeof(afp->mInputCallback)); |
224 | if (result) |
225 | SDL_SetError ("AudioUnitSetProperty:RemoveInputCallback:%ld", result); |
226 | |
227 | afp->mAudioFileManager->Disconnect(afp->mAudioFileManager); |
228 | } |
229 | } |
230 | |
231 | typedef struct { |
232 | UInt32 offset; |
233 | UInt32 blockSize; |
234 | } SSNDData; |
235 | |
236 | static int AudioFilePlayer_OpenFile (AudioFilePlayer *afp, const FSRef *inRef, SInt64 *outFileDataSize) |
237 | { |
238 | ContainerChunk chunkHeader; |
239 | ChunkHeader chunk; |
240 | SSNDData ssndData; |
241 | |
242 | OSErr result; |
243 | HFSUniStr255 dfName; |
244 | ByteCount actual; |
245 | SInt64 offset; |
246 | |
247 | /* Open the data fork of the input file */ |
248 | result = FSGetDataForkName(&dfName); |
249 | if (result) return 0; /*THROW_RESULT("AudioFilePlayer::OpenFile(): FSGetDataForkName")*/ |
250 | |
251 | result = FSOpenFork(inRef, dfName.length, dfName.unicode, fsRdPerm, &afp->mForkRefNum); |
252 | if (result) return 0; /*THROW_RESULT("AudioFilePlayer::OpenFile(): FSOpenFork")*/ |
253 | |
254 | /* Read the file header, and check if it's indeed an AIFC file */ |
255 | result = FSReadFork(afp->mForkRefNum, fsAtMark, 0, sizeof(chunkHeader), &chunkHeader, &actual); |
256 | if (result) return 0; /*THROW_RESULT("AudioFilePlayer::OpenFile(): FSReadFork")*/ |
257 | |
258 | if (SDL_SwapBE32(chunkHeader.ckID) != 'FORM') { |
259 | result = -1; |
260 | if (result) return 0; /*THROW_RESULT("AudioFilePlayer::OpenFile(): chunk id is not 'FORM'");*/ |
261 | } |
262 | |
263 | if (SDL_SwapBE32(chunkHeader.formType) != 'AIFC') { |
264 | result = -1; |
265 | if (result) return 0; /*THROW_RESULT("AudioFilePlayer::OpenFile(): file format is not 'AIFC'");*/ |
266 | } |
267 | |
268 | /* Search for the SSND chunk. We ignore all compression etc. information |
269 | in other chunks. Of course that is kind of evil, but for now we are lazy |
270 | and rely on the cdfs to always give us the same fixed format. |
271 | TODO: Parse the COMM chunk we currently skip to fill in mFileDescription. |
272 | */ |
273 | offset = 0; |
274 | do { |
275 | result = FSReadFork(afp->mForkRefNum, fsFromMark, offset, sizeof(chunk), &chunk, &actual); |
276 | if (result) return 0; /*THROW_RESULT("AudioFilePlayer::OpenFile(): FSReadFork")*/ |
277 | |
278 | chunk.ckID = SDL_SwapBE32(chunk.ckID); |
279 | chunk.ckSize = SDL_SwapBE32(chunk.ckSize); |
280 | |
281 | /* Skip the chunk data */ |
282 | offset = chunk.ckSize; |
283 | } while (chunk.ckID != 'SSND'); |
284 | |
285 | /* Read the header of the SSND chunk. After this, we are positioned right |
286 | at the start of the audio data. */ |
287 | result = FSReadFork(afp->mForkRefNum, fsAtMark, 0, sizeof(ssndData), &ssndData, &actual); |
288 | if (result) return 0; /*THROW_RESULT("AudioFilePlayer::OpenFile(): FSReadFork")*/ |
289 | |
290 | ssndData.offset = SDL_SwapBE32(ssndData.offset); |
291 | |
292 | result = FSSetForkPosition(afp->mForkRefNum, fsFromMark, ssndData.offset); |
293 | if (result) return 0; /*THROW_RESULT("AudioFilePlayer::OpenFile(): FSSetForkPosition")*/ |
294 | |
295 | /* Data size */ |
296 | *outFileDataSize = chunk.ckSize - ssndData.offset - 8; |
297 | |
298 | /* File format */ |
299 | afp->mFileDescription.mSampleRate = 44100; |
300 | afp->mFileDescription.mFormatID = kAudioFormatLinearPCM; |
301 | afp->mFileDescription.mFormatFlags = kLinearPCMFormatFlagIsPacked | kLinearPCMFormatFlagIsSignedInteger; |
302 | afp->mFileDescription.mBytesPerPacket = 4; |
303 | afp->mFileDescription.mFramesPerPacket = 1; |
304 | afp->mFileDescription.mBytesPerFrame = 4; |
305 | afp->mFileDescription.mChannelsPerFrame = 2; |
306 | afp->mFileDescription.mBitsPerChannel = 16; |
307 | |
308 | return 1; |
309 | } |
310 | |
311 | AudioFilePlayer *new_AudioFilePlayer (const FSRef *inFileRef) |
312 | { |
313 | SInt64 fileDataSize = 0; |
314 | |
315 | AudioFilePlayer *afp = (AudioFilePlayer *) SDL_malloc(sizeof (AudioFilePlayer)); |
316 | if (afp == NULL) |
317 | return NULL; |
318 | SDL_memset(afp, '\0', sizeof (*afp)); |
319 | |
320 | #define SET_AUDIOFILEPLAYER_METHOD(m) afp->m = AudioFilePlayer_##m |
321 | SET_AUDIOFILEPLAYER_METHOD(SetDestination); |
322 | SET_AUDIOFILEPLAYER_METHOD(SetNotifier); |
323 | SET_AUDIOFILEPLAYER_METHOD(SetStartFrame); |
324 | SET_AUDIOFILEPLAYER_METHOD(GetCurrentFrame); |
325 | SET_AUDIOFILEPLAYER_METHOD(SetStopFrame); |
326 | SET_AUDIOFILEPLAYER_METHOD(Connect); |
327 | SET_AUDIOFILEPLAYER_METHOD(Disconnect); |
328 | SET_AUDIOFILEPLAYER_METHOD(DoNotification); |
329 | SET_AUDIOFILEPLAYER_METHOD(IsConnected); |
330 | SET_AUDIOFILEPLAYER_METHOD(GetDestUnit); |
331 | SET_AUDIOFILEPLAYER_METHOD(Print); |
332 | SET_AUDIOFILEPLAYER_METHOD(OpenFile); |
333 | #undef SET_AUDIOFILEPLAYER_METHOD |
334 | |
335 | if (!afp->OpenFile (afp, inFileRef, &fileDataSize)) |
336 | { |
337 | SDL_free(afp); |
338 | return NULL; |
339 | } |
340 | |
341 | /* we want about 4 seconds worth of data for the buffer */ |
342 | int bytesPerSecond = (UInt32) (4 * afp->mFileDescription.mSampleRate * afp->mFileDescription.mBytesPerFrame); |
343 | |
344 | #if DEBUG |
345 | printf("File format:\n"); |
346 | PrintStreamDesc (&afp->mFileDescription); |
347 | #endif |
348 | |
349 | afp->mAudioFileManager = new_AudioFileManager(afp, afp->mForkRefNum, |
350 | fileDataSize, |
351 | bytesPerSecond); |
352 | if (afp->mAudioFileManager == NULL) |
353 | { |
354 | delete_AudioFilePlayer(afp); |
355 | return NULL; |
356 | } |
357 | |
358 | return afp; |
359 | } |
360 | |