[sdl_omap.git] / src / cdrom / macosx / AudioFilePlayer.c

/*
    SDL - Simple DirectMedia Layer
    Copyright (C) 1997-2009 Sam Lantinga

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.

    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
    Library General Public License for more details.

    You should have received a copy of the GNU Library General Public
    License along with this library; if not, write to the Free
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

    Sam Lantinga
    slouken@libsdl.org

    This file based on Apple sample code. We haven't changed the file name, 
    so if you want to see the original search for it on apple.com/developer
*/
#include "SDL_config.h"
#include "SDL_endian.h"

/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    AudioFilePlayer.cpp
*/
#include "AudioFilePlayer.h"

/*
void ThrowResult (OSStatus result, const char* str)
{
    SDL_SetError ("Error: %s %d", str, result);
    throw result;
}
*/

#if DEBUG
static void PrintStreamDesc (AudioStreamBasicDescription *inDesc)
{
    if (!inDesc) {
        printf ("Can't print a NULL desc!\n");
        return;
    }
    
    printf ("- - - - - - - - - - - - - - - - - - - -\n");
    printf ("  Sample Rate:%f\n", inDesc->mSampleRate);
    printf ("  Format ID:%s\n", (char*)&inDesc->mFormatID);
    printf ("  Format Flags:%lX\n", inDesc->mFormatFlags);
    printf ("  Bytes per Packet:%ld\n", inDesc->mBytesPerPacket);
    printf ("  Frames per Packet:%ld\n", inDesc->mFramesPerPacket);
    printf ("  Bytes per Frame:%ld\n", inDesc->mBytesPerFrame);
    printf ("  Channels per Frame:%ld\n", inDesc->mChannelsPerFrame);
    printf ("  Bits per Channel:%ld\n", inDesc->mBitsPerChannel);
    printf ("- - - - - - - - - - - - - - - - - - - -\n");
}
#endif


static int AudioFilePlayer_SetDestination (AudioFilePlayer *afp, AudioUnit  *inDestUnit)
{
    /*if (afp->mConnected) throw static_cast<OSStatus>(-1);*/ /* can't set dest if already engaged */
    if (afp->mConnected)
        return 0 ;

    SDL_memcpy(&afp->mPlayUnit, inDestUnit, sizeof (afp->mPlayUnit));

    OSStatus result = noErr;
    

        /* we can "down" cast a component instance to a component */
    ComponentDescription desc;
    result = GetComponentInfo ((Component)*inDestUnit, &desc, 0, 0, 0);
    if (result) return 0; /*THROW_RESULT("GetComponentInfo")*/
        
        /* we're going to use this to know which convert routine to call
           a v1 audio unit will have a type of 'aunt'
           a v2 audio unit will have one of several different types. */
    if (desc.componentType != kAudioUnitType_Output) {
        result = badComponentInstance;
        /*THROW_RESULT("BAD COMPONENT")*/
        if (result) return 0;
    }

    /* Set the input format of the audio unit. */
    result = AudioUnitSetProperty (*inDestUnit,
                               kAudioUnitProperty_StreamFormat,
                               kAudioUnitScope_Input,
                               0,
                               &afp->mFileDescription,
                               sizeof (afp->mFileDescription));
        /*THROW_RESULT("AudioUnitSetProperty")*/
    if (result) return 0;
    return 1;
}

static void AudioFilePlayer_SetNotifier(AudioFilePlayer *afp, AudioFilePlayNotifier inNotifier, void *inRefCon)
{
    afp->mNotifier = inNotifier;
    afp->mRefCon = inRefCon;
}

static int AudioFilePlayer_IsConnected(AudioFilePlayer *afp)
{
    return afp->mConnected;
}

static AudioUnit AudioFilePlayer_GetDestUnit(AudioFilePlayer *afp)
{
   return afp->mPlayUnit;
}

static void AudioFilePlayer_Print(AudioFilePlayer *afp)
{
#if DEBUG    
    printf ("Is Connected:%s\n", (IsConnected() ? "true" : "false"));
    printf ("- - - - - - - - - - - - - - \n");
#endif
}

static void    AudioFilePlayer_SetStartFrame (AudioFilePlayer *afp, int frame)
{
    SInt64 position = frame * 2352;

    afp->mStartFrame = frame;
    afp->mAudioFileManager->SetPosition (afp->mAudioFileManager, position);
}

    
static int    AudioFilePlayer_GetCurrentFrame (AudioFilePlayer *afp)
{
    return afp->mStartFrame + (afp->mAudioFileManager->GetByteCounter(afp->mAudioFileManager) / 2352);
}
    
static void    AudioFilePlayer_SetStopFrame (AudioFilePlayer *afp, int frame)
{
    SInt64 position  = frame * 2352;
    
    afp->mAudioFileManager->SetEndOfFile (afp->mAudioFileManager, position);
}
    
void delete_AudioFilePlayer(AudioFilePlayer *afp)
{
    if (afp != NULL)
    {
        afp->Disconnect(afp);
        
        if (afp->mAudioFileManager) {
            delete_AudioFileManager(afp->mAudioFileManager);
            afp->mAudioFileManager = 0;
        }
    
        if (afp->mForkRefNum) {
            FSCloseFork (afp->mForkRefNum);
            afp->mForkRefNum = 0;
        }
        SDL_free(afp);
    }
}

static int    AudioFilePlayer_Connect(AudioFilePlayer *afp)
{
#if DEBUG
    printf ("Connect:%x, engaged=%d\n", (int)afp->mPlayUnit, (afp->mConnected ? 1 : 0));
#endif
    if (!afp->mConnected)
    {           
        if (!afp->mAudioFileManager->DoConnect(afp->mAudioFileManager))
            return 0;

        /* set the render callback for the file data to be supplied to the sound converter AU */
        afp->mInputCallback.inputProc = afp->mAudioFileManager->FileInputProc;
        afp->mInputCallback.inputProcRefCon = afp->mAudioFileManager;

        OSStatus result = AudioUnitSetProperty (afp->mPlayUnit, 
                            kAudioUnitProperty_SetRenderCallback,
                            kAudioUnitScope_Input, 
                            0,
                            &afp->mInputCallback, 
                            sizeof(afp->mInputCallback));
        if (result) return 0;  /*THROW_RESULT("AudioUnitSetProperty")*/
        afp->mConnected = 1;
    }

    return 1;
}

/* warning noted, now please go away ;-) */
/* #warning This should redirect the calling of notification code to some other thread */
static void    AudioFilePlayer_DoNotification (AudioFilePlayer *afp, OSStatus inStatus)
{
    if (afp->mNotifier) {
        (*afp->mNotifier) (afp->mRefCon, inStatus);
    } else {
        SDL_SetError ("Notification posted with no notifier in place");
        
        if (inStatus == kAudioFilePlay_FileIsFinished)
            afp->Disconnect(afp);
        else if (inStatus != kAudioFilePlayErr_FilePlayUnderrun)
            afp->Disconnect(afp);
    }
}

static void    AudioFilePlayer_Disconnect (AudioFilePlayer *afp)
{
#if DEBUG
    printf ("Disconnect:%x,%ld, engaged=%d\n", (int)afp->mPlayUnit, 0, (afp->mConnected ? 1 : 0));
#endif
    if (afp->mConnected)
    {
        afp->mConnected = 0;
            
        afp->mInputCallback.inputProc = 0;
        afp->mInputCallback.inputProcRefCon = 0;
        OSStatus result = AudioUnitSetProperty (afp->mPlayUnit, 
                                        kAudioUnitProperty_SetRenderCallback,
                                        kAudioUnitScope_Input, 
                                        0,
                                        &afp->mInputCallback, 
                                        sizeof(afp->mInputCallback));
        if (result) 
            SDL_SetError ("AudioUnitSetProperty:RemoveInputCallback:%ld", result);

        afp->mAudioFileManager->Disconnect(afp->mAudioFileManager);
    }
}

typedef struct {
    UInt32 offset;
    UInt32 blockSize;
} SSNDData;

static int    AudioFilePlayer_OpenFile (AudioFilePlayer *afp, const FSRef *inRef, SInt64 *outFileDataSize)
{
    ContainerChunk chunkHeader;
    ChunkHeader chunk;
    SSNDData ssndData;

    OSErr result;
    HFSUniStr255 dfName;
    ByteCount actual;
    SInt64 offset;

    /* Open the data fork of the input file */
    result = FSGetDataForkName(&dfName);
       if (result) return 0; /*THROW_RESULT("AudioFilePlayer::OpenFile(): FSGetDataForkName")*/

    result = FSOpenFork(inRef, dfName.length, dfName.unicode, fsRdPerm, &afp->mForkRefNum);
       if (result) return 0; /*THROW_RESULT("AudioFilePlayer::OpenFile(): FSOpenFork")*/
 
    /* Read the file header, and check if it's indeed an AIFC file */
    result = FSReadFork(afp->mForkRefNum, fsAtMark, 0, sizeof(chunkHeader), &chunkHeader, &actual);
       if (result) return 0; /*THROW_RESULT("AudioFilePlayer::OpenFile(): FSReadFork")*/

    if (SDL_SwapBE32(chunkHeader.ckID) != 'FORM') {
        result = -1;
        if (result) return 0; /*THROW_RESULT("AudioFilePlayer::OpenFile(): chunk id is not 'FORM'");*/
    }

    if (SDL_SwapBE32(chunkHeader.formType) != 'AIFC') {
        result = -1;
        if (result) return 0; /*THROW_RESULT("AudioFilePlayer::OpenFile(): file format is not 'AIFC'");*/
    }

    /* Search for the SSND chunk. We ignore all compression etc. information
       in other chunks. Of course that is kind of evil, but for now we are lazy
       and rely on the cdfs to always give us the same fixed format.
       TODO: Parse the COMM chunk we currently skip to fill in mFileDescription.
    */
    offset = 0;
    do {
        result = FSReadFork(afp->mForkRefNum, fsFromMark, offset, sizeof(chunk), &chunk, &actual);
        if (result) return 0; /*THROW_RESULT("AudioFilePlayer::OpenFile(): FSReadFork")*/

        chunk.ckID = SDL_SwapBE32(chunk.ckID);
        chunk.ckSize = SDL_SwapBE32(chunk.ckSize);

        /* Skip the chunk data */
        offset = chunk.ckSize;
    } while (chunk.ckID != 'SSND');

    /* Read the header of the SSND chunk. After this, we are positioned right
       at the start of the audio data. */
    result = FSReadFork(afp->mForkRefNum, fsAtMark, 0, sizeof(ssndData), &ssndData, &actual);
    if (result) return 0; /*THROW_RESULT("AudioFilePlayer::OpenFile(): FSReadFork")*/

    ssndData.offset = SDL_SwapBE32(ssndData.offset);

    result = FSSetForkPosition(afp->mForkRefNum, fsFromMark, ssndData.offset);
    if (result) return 0; /*THROW_RESULT("AudioFilePlayer::OpenFile(): FSSetForkPosition")*/

    /* Data size */
    *outFileDataSize = chunk.ckSize - ssndData.offset - 8;

    /* File format */
    afp->mFileDescription.mSampleRate = 44100;
    afp->mFileDescription.mFormatID = kAudioFormatLinearPCM;
    afp->mFileDescription.mFormatFlags = kLinearPCMFormatFlagIsPacked | kLinearPCMFormatFlagIsSignedInteger;
    afp->mFileDescription.mBytesPerPacket = 4;
    afp->mFileDescription.mFramesPerPacket = 1;
    afp->mFileDescription.mBytesPerFrame = 4;
    afp->mFileDescription.mChannelsPerFrame = 2;
    afp->mFileDescription.mBitsPerChannel = 16;

    return 1;
}

AudioFilePlayer *new_AudioFilePlayer (const FSRef *inFileRef)
{
    SInt64 fileDataSize  = 0;

    AudioFilePlayer *afp = (AudioFilePlayer *) SDL_malloc(sizeof (AudioFilePlayer));
    if (afp == NULL)
        return NULL;
    SDL_memset(afp, '\0', sizeof (*afp));

    #define SET_AUDIOFILEPLAYER_METHOD(m) afp->m = AudioFilePlayer_##m
    SET_AUDIOFILEPLAYER_METHOD(SetDestination);
    SET_AUDIOFILEPLAYER_METHOD(SetNotifier);
    SET_AUDIOFILEPLAYER_METHOD(SetStartFrame);
    SET_AUDIOFILEPLAYER_METHOD(GetCurrentFrame);
    SET_AUDIOFILEPLAYER_METHOD(SetStopFrame);
    SET_AUDIOFILEPLAYER_METHOD(Connect);
    SET_AUDIOFILEPLAYER_METHOD(Disconnect);
    SET_AUDIOFILEPLAYER_METHOD(DoNotification);
    SET_AUDIOFILEPLAYER_METHOD(IsConnected);
    SET_AUDIOFILEPLAYER_METHOD(GetDestUnit);
    SET_AUDIOFILEPLAYER_METHOD(Print);
    SET_AUDIOFILEPLAYER_METHOD(OpenFile);
    #undef SET_AUDIOFILEPLAYER_METHOD

    if (!afp->OpenFile (afp, inFileRef, &fileDataSize))
    {
        SDL_free(afp);
        return NULL;
    }
        
    /* we want about 4 seconds worth of data for the buffer */
    int bytesPerSecond = (UInt32) (4 * afp->mFileDescription.mSampleRate * afp->mFileDescription.mBytesPerFrame);
    
#if DEBUG
    printf("File format:\n");
    PrintStreamDesc (&afp->mFileDescription);
#endif
    
    afp->mAudioFileManager = new_AudioFileManager(afp, afp->mForkRefNum,
                                                  fileDataSize,
                                                  bytesPerSecond);
    if (afp->mAudioFileManager == NULL)
    {
        delete_AudioFilePlayer(afp);
        return NULL;
    }

    return afp;
}
Commit	Line	Data
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