fix alpha for 32bpp screen
[sdl_omap.git] / src / cdrom / macosx / AudioFilePlayer.c
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