Skip to content

L
libSDL
Commit 7be238c6 authored by Ryan C. Gordon's avatar Ryan C. Gordon
Browse files
Options

Replaced Mac OS X's C++ cdrom code with almost-direct translation to C. Sam 

 requested this effort on the mailing list, apparently because of binary
 compatibility issues between 10.4 and earlier systems (or gcc4 and earlier
 compilers?).

Works fine with SDL12/test/testcdrom.c, with this command line:

./testcdrom -status -list -play -sleep 5000 -pause -sleep 3000 -resume \
            -sleep 5000 -stop -sleep 3000 -play -sleep 3000 -stop \
            -sleep 3000 -eject

Unix Makefiles work, XCode project still need updating for new filenames.

--HG--
extra : convert_revision : svn%3Ac70aab31-4412-0410-b14c-859654838e24/trunk%401146
parent cddfe242
Show whitespace changes
Inline Side-by-side
Showing with 1162 additions and 237 deletions
src/cdrom/macosx/AudioFilePlayer.cpp → src/cdrom/macosx/AudioFilePlayer.c
View file @ 7be238c6
......@@ -28,14 +28,16 @@
//
#include "AudioFilePlayer.h"
/*
void ThrowResult (OSStatus result, const char* str)
{
SDL_SetError ("Error: %s %d", str, result);
throw result;
}
*/
#if DEBUG
void PrintStreamDesc (AudioStreamBasicDescription *inDesc)
static void PrintStreamDesc (AudioStreamBasicDescription *inDesc)
{
if (!inDesc) {
printf ("Can't print a NULL desc!\n");
......@@ -55,214 +57,181 @@ void PrintStreamDesc (AudioStreamBasicDescription *inDesc)
}
#endif
OSStatus AudioFileManager::FileInputProc (void *inRefCon,
AudioUnitRenderActionFlags inActionFlags,
const AudioTimeStamp *inTimeStamp,
UInt32 inBusNumber,
AudioBuffer *ioData)
{
AudioFileManager* THIS = (AudioFileManager*)inRefCon;
return THIS->Render(*ioData);
}
OSStatus AudioFileManager::Render (AudioBuffer &ioData)
{
OSStatus result = noErr;
if (mBufferOffset >= mBufferSize) {
result = GetFileData(&mTmpBuffer, &mBufferSize);
if (result) {
SDL_SetError ("AudioConverterFillBuffer:%ld\n", result);
mParent.DoNotification (result);
return result;
}
mBufferOffset = 0;
}
if (ioData.mDataByteSize > mBufferSize - mBufferOffset)
ioData.mDataByteSize = mBufferSize - mBufferOffset;
ioData.mData = (char *)mTmpBuffer + mBufferOffset;
mBufferOffset += ioData.mDataByteSize;
mByteCounter += ioData.mDataByteSize;
AfterRender();
return result;
}
AudioFileManager::~AudioFileManager ()
{
if (mFileBuffer) {
free (mFileBuffer);
mFileBuffer = 0;
}
}
AudioFilePlayer::AudioFilePlayer (const FSRef *inFileRef)
: mConnected (false),
mAudioFileManager (0),
mNotifier (0),
mStartFrame (0)
{
SInt64 fileDataSize = 0;
OpenFile (inFileRef, fileDataSize);
// we want about 4 seconds worth of data for the buffer
int bytesPerSecond = UInt32 (4 * mFileDescription.mSampleRate * mFileDescription.mBytesPerFrame);
#if DEBUG
printf("File format:\n");
PrintStreamDesc (&mFileDescription);
#endif
mAudioFileManager = new AudioFileManager (*this,
mForkRefNum,
fileDataSize,
bytesPerSecond);
}
void AudioFilePlayer::SetDestination (AudioUnit &inDestUnit)
static int AudioFilePlayer_SetDestination (AudioFilePlayer *afp, AudioUnit *inDestUnit)
{
if (mConnected) throw static_cast<OSStatus>(-1); //can't set dest if already engaged
//if (afp->mConnected) throw static_cast<OSStatus>(-1); //can't set dest if already engaged
if (afp->mConnected)
return 0 ;
mPlayUnit = inDestUnit;
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);
THROW_RESULT("GetComponentInfo")
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 != kAudioUnitComponentType) {
result = badComponentInstance;
THROW_RESULT("BAD COMPONENT")
//THROW_RESULT("BAD COMPONENT")
if (result) return 0;
}
/* Set the input format of the audio unit. */
result = AudioUnitSetProperty (inDestUnit,
result = AudioUnitSetProperty (*inDestUnit,
kAudioUnitProperty_StreamFormat,
kAudioUnitScope_Input,
0,
&mFileDescription,
sizeof (mFileDescription));
THROW_RESULT("AudioUnitSetProperty")
&afp->mFileDescription,
sizeof (afp->mFileDescription));
//THROW_RESULT("AudioUnitSetProperty")
if (result) return 0;
return 1;
}
void AudioFilePlayer::SetStartFrame (int frame)
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;
mStartFrame = frame;
mAudioFileManager->SetPosition (position);
afp->mStartFrame = frame;
afp->mAudioFileManager->SetPosition (afp->mAudioFileManager, position);
}
int AudioFilePlayer::GetCurrentFrame ()
static int AudioFilePlayer_GetCurrentFrame (AudioFilePlayer *afp)
{
return mStartFrame + (mAudioFileManager->GetByteCounter() / 2352);
return afp->mStartFrame + (afp->mAudioFileManager->GetByteCounter(afp->mAudioFileManager) / 2352);
}
void AudioFilePlayer::SetStopFrame (int frame)
static void AudioFilePlayer_SetStopFrame (AudioFilePlayer *afp, int frame)
{
SInt64 position = frame * 2352;
mAudioFileManager->SetEndOfFile (position);
afp->mAudioFileManager->SetEndOfFile (afp->mAudioFileManager, position);
}
AudioFilePlayer::~AudioFilePlayer()
void delete_AudioFilePlayer(AudioFilePlayer *afp)
{
Disconnect();
if (afp != NULL)
{
afp->Disconnect(afp);
if (mAudioFileManager) {
delete mAudioFileManager;
mAudioFileManager = 0;
if (afp->mAudioFileManager) {
delete_AudioFileManager(afp->mAudioFileManager);
afp->mAudioFileManager = 0;
}
if (mForkRefNum) {
FSClose (mForkRefNum);
mForkRefNum = 0;
if (afp->mForkRefNum) {
FSClose (afp->mForkRefNum);
afp->mForkRefNum = 0;
}
free(afp);
}
}
void AudioFilePlayer::Connect()
static int AudioFilePlayer_Connect(AudioFilePlayer *afp)
{
#if DEBUG
printf ("Connect:%x, engaged=%d\n", (int)mPlayUnit, (mConnected ? 1 : 0));
printf ("Connect:%x, engaged=%d\n", (int)afp->mPlayUnit, (afp->mConnected ? 1 : 0));
#endif
if (!mConnected)
if (!afp->mConnected)
{
mAudioFileManager->DoConnect();
if (!afp->mAudioFileManager->DoConnect(afp->mAudioFileManager))
return 0;
// set the render callback for the file data to be supplied to the sound converter AU
mInputCallback.inputProc = AudioFileManager::FileInputProc;
mInputCallback.inputProcRefCon = mAudioFileManager;
afp->mInputCallback.inputProc = afp->mAudioFileManager->FileInputProc;
afp->mInputCallback.inputProcRefCon = afp->mAudioFileManager;
OSStatus result = AudioUnitSetProperty (mPlayUnit,
OSStatus result = AudioUnitSetProperty (afp->mPlayUnit,
kAudioUnitProperty_SetInputCallback,
kAudioUnitScope_Input,
0,
&mInputCallback,
sizeof(mInputCallback));
THROW_RESULT("AudioUnitSetProperty")
mConnected = true;
&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
void AudioFilePlayer::DoNotification (OSStatus inStatus) const
static void AudioFilePlayer_DoNotification (AudioFilePlayer *afp, OSStatus inStatus)
{
AudioFilePlayer* THIS = const_cast<AudioFilePlayer*>(this);
if (mNotifier) {
(*mNotifier) (mRefCon, inStatus);
if (afp->mNotifier) {
(*afp->mNotifier) (afp->mRefCon, inStatus);
} else {
SDL_SetError ("Notification posted with no notifier in place");
if (inStatus == kAudioFilePlay_FileIsFinished)
THIS->Disconnect();
afp->Disconnect(afp);
else if (inStatus != kAudioFilePlayErr_FilePlayUnderrun)
THIS->Disconnect();
afp->Disconnect(afp);
}
}
void AudioFilePlayer::Disconnect ()
static void AudioFilePlayer_Disconnect (AudioFilePlayer *afp)
{
#if DEBUG
printf ("Disconnect:%x,%ld, engaged=%d\n", (int)mPlayUnit, 0, (mConnected ? 1 : 0));
printf ("Disconnect:%x,%ld, engaged=%d\n", (int)afp->mPlayUnit, 0, (afp->mConnected ? 1 : 0));
#endif
if (mConnected)
if (afp->mConnected)
{
mConnected = false;
afp->mConnected = 0;
mInputCallback.inputProc = 0;
mInputCallback.inputProcRefCon = 0;
OSStatus result = AudioUnitSetProperty (mPlayUnit,
afp->mInputCallback.inputProc = 0;
afp->mInputCallback.inputProcRefCon = 0;
OSStatus result = AudioUnitSetProperty (afp->mPlayUnit,
kAudioUnitProperty_SetInputCallback,
kAudioUnitScope_Input,
0,
&mInputCallback,
sizeof(mInputCallback));
&afp->mInputCallback,
sizeof(afp->mInputCallback));
if (result)
SDL_SetError ("AudioUnitSetProperty:RemoveInputCallback:%ld", result);
mAudioFileManager->Disconnect();
afp->mAudioFileManager->Disconnect(afp->mAudioFileManager);
}
}
struct SSNDData {
typedef struct {
UInt32 offset;
UInt32 blockSize;
};
} SSNDData;
void AudioFilePlayer::OpenFile (const FSRef *inRef, SInt64& outFileDataSize)
static int AudioFilePlayer_OpenFile (AudioFilePlayer *afp, const FSRef *inRef, SInt64 *outFileDataSize)
{
ContainerChunk chunkHeader;
ChunkHeader chunk;
......@@ -275,23 +244,23 @@ void AudioFilePlayer::OpenFile (const FSRef *inRef, SInt64& outFileDataSize)
// Open the data fork of the input file
result = FSGetDataForkName(&dfName);
THROW_RESULT("AudioFilePlayer::OpenFile(): FSGetDataForkName")
if (result) return 0; //THROW_RESULT("AudioFilePlayer::OpenFile(): FSGetDataForkName")
result = FSOpenFork(inRef, dfName.length, dfName.unicode, fsRdPerm, &mForkRefNum);
THROW_RESULT("AudioFilePlayer::OpenFile(): FSOpenFork")
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(mForkRefNum, fsAtMark, 0, sizeof(chunkHeader), &chunkHeader, &actual);
THROW_RESULT("AudioFilePlayer::OpenFile(): FSReadFork")
result = FSReadFork(afp->mForkRefNum, fsAtMark, 0, sizeof(chunkHeader), &chunkHeader, &actual);
if (result) return 0; //THROW_RESULT("AudioFilePlayer::OpenFile(): FSReadFork")
if (chunkHeader.ckID != 'FORM') {
result = -1;
THROW_RESULT("AudioFilePlayer::OpenFile(): chunk id is not 'FORM'");
if (result) return 0; //THROW_RESULT("AudioFilePlayer::OpenFile(): chunk id is not 'FORM'");
}
if (chunkHeader.formType != 'AIFC') {
result = -1;
THROW_RESULT("AudioFilePlayer::OpenFile(): file format is not 'AIFC'");
if (result) return 0; //THROW_RESULT("AudioFilePlayer::OpenFile(): file format is not 'AIFC'");
}
// Search for the SSND chunk. We ignore all compression etc. information
......@@ -300,8 +269,8 @@ void AudioFilePlayer::OpenFile (const FSRef *inRef, SInt64& outFileDataSize)
// TODO: Parse the COMM chunk we currently skip to fill in mFileDescription.
offset = 0;
do {
result = FSReadFork(mForkRefNum, fsFromMark, offset, sizeof(chunk), &chunk, &actual);
THROW_RESULT("AudioFilePlayer::OpenFile(): FSReadFork")
result = FSReadFork(afp->mForkRefNum, fsFromMark, offset, sizeof(chunk), &chunk, &actual);
if (result) return 0; //THROW_RESULT("AudioFilePlayer::OpenFile(): FSReadFork")
// Skip the chunk data
offset = chunk.ckSize;
......@@ -309,22 +278,75 @@ void AudioFilePlayer::OpenFile (const FSRef *inRef, SInt64& outFileDataSize)
// Read the header of the SSND chunk. After this, we are positioned right
// at the start of the audio data.
result = FSReadFork(mForkRefNum, fsAtMark, 0, sizeof(ssndData), &ssndData, &actual);
THROW_RESULT("AudioFilePlayer::OpenFile(): FSReadFork")
result = FSReadFork(afp->mForkRefNum, fsAtMark, 0, sizeof(ssndData), &ssndData, &actual);
if (result) return 0; //THROW_RESULT("AudioFilePlayer::OpenFile(): FSReadFork")
result = FSSetForkPosition(mForkRefNum, fsFromMark, ssndData.offset);
THROW_RESULT("AudioFilePlayer::OpenFile(): FSSetForkPosition")
result = FSSetForkPosition(afp->mForkRefNum, fsFromMark, ssndData.offset);
if (result) return 0; //THROW_RESULT("AudioFilePlayer::OpenFile(): FSSetForkPosition")
// Data size
outFileDataSize = chunk.ckSize - ssndData.offset - 8;
*outFileDataSize = chunk.ckSize - ssndData.offset - 8;
// File format
mFileDescription.mSampleRate = 44100;
mFileDescription.mFormatID = kAudioFormatLinearPCM;
mFileDescription.mFormatFlags = kLinearPCMFormatFlagIsPacked | kLinearPCMFormatFlagIsSignedInteger;
mFileDescription.mBytesPerPacket = 4;
mFileDescription.mFramesPerPacket = 1;
mFileDescription.mBytesPerFrame = 4;
mFileDescription.mChannelsPerFrame = 2;
mFileDescription.mBitsPerChannel = 16;
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 *) malloc(sizeof (AudioFilePlayer));
if (afp == NULL)
return NULL;
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))
{
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;
}
src/cdrom/macosx/AudioFilePlayer.h
View file @ 7be238c6
......@@ -37,12 +37,14 @@
const char* AudioFilePlayerErrorStr (OSStatus error);
/*
void ThrowResult (OSStatus result, const char *str);
#define THROW_RESULT(str) \
if (result) { \
ThrowResult (result, str); \
}
*/
typedef void (*AudioFilePlayNotifier)(void *inRefCon,
OSStatus inStatus);
......@@ -54,49 +56,25 @@ enum {
};
class AudioFileManager;
struct S_AudioFileManager;
#pragma mark __________ AudioFilePlayer
class AudioFilePlayer
typedef struct S_AudioFilePlayer
{
public:
AudioFilePlayer (const FSRef *inFileRef);
~AudioFilePlayer();
void SetDestination (AudioUnit &inDestUnit);
void SetNotifier (AudioFilePlayNotifier inNotifier, void *inRefCon)
{
mNotifier = inNotifier;
mRefCon = inRefCon;
}
void SetStartFrame (int frame); // seek in the file
int GetCurrentFrame (); // get the current frame position
void SetStopFrame (int frame); // set limit in the file
void Connect();
void Disconnect();
void DoNotification (OSStatus inError) const;
bool IsConnected () const { return mConnected; }
AudioUnit GetDestUnit () const { return mPlayUnit; }
#if DEBUG
void Print() const
{
printf ("Is Connected:%s\n", (IsConnected() ? "true" : "false"));
printf ("- - - - - - - - - - - - - - \n");
}
#endif
private:
//public:
int (*SetDestination)(struct S_AudioFilePlayer *afp, AudioUnit *inDestUnit);
void (*SetNotifier)(struct S_AudioFilePlayer *afp, AudioFilePlayNotifier inNotifier, void *inRefCon);
void (*SetStartFrame)(struct S_AudioFilePlayer *afp, int frame); // seek in the file
int (*GetCurrentFrame)(struct S_AudioFilePlayer *afp); // get the current frame position
void (*SetStopFrame)(struct S_AudioFilePlayer *afp, int frame); // set limit in the file
int (*Connect)(struct S_AudioFilePlayer *afp);
void (*Disconnect)(struct S_AudioFilePlayer *afp);
void (*DoNotification)(struct S_AudioFilePlayer *afp, OSStatus inError);
int (*IsConnected)(struct S_AudioFilePlayer *afp);
AudioUnit (*GetDestUnit)(struct S_AudioFilePlayer *afp);
void (*Print)(struct S_AudioFilePlayer *afp);
//private:
AudioUnit mPlayUnit;
SInt16 mForkRefNum;
......@@ -104,9 +82,9 @@ private:
AudioStreamBasicDescription mFileDescription;
bool mConnected;
int mConnected;
AudioFileManager* mAudioFileManager;
struct S_AudioFileManager* mAudioFileManager;
AudioFilePlayNotifier mNotifier;
void* mRefCon;
......@@ -115,41 +93,32 @@ private:
#pragma mark __________ Private_Methods
void OpenFile (const FSRef *inRef, SInt64& outFileSize);
};
int (*OpenFile)(struct S_AudioFilePlayer *afp, const FSRef *inRef, SInt64 *outFileSize);
} AudioFilePlayer;
#pragma mark __________ AudioFileManager
class AudioFileManager
{
public:
AudioFileManager (AudioFilePlayer &inParent,
SInt16 inForkRefNum,
SInt64 inFileLength,
UInt32 inChunkSize);
~AudioFileManager();
AudioFilePlayer *new_AudioFilePlayer(const FSRef *inFileRef);
void delete_AudioFilePlayer(AudioFilePlayer *afp);
#pragma mark __________ AudioFileManager
typedef struct S_AudioFileManager
{
//public:
// this method should NOT be called by an object of this class
// as it is called by the parent's Disconnect() method
void Disconnect ();
void DoConnect ();
OSStatus Read(char *buffer, UInt32 *len);
const char* GetFileBuffer () { return mFileBuffer; }
const AudioFilePlayer& GetParent () const { return mParent; }
void SetPosition (SInt64 pos); // seek/rewind in the file
int GetByteCounter () { return mByteCounter; } // return actual bytes streamed to audio hardware
void SetEndOfFile (SInt64 pos); // set the "EOF" (will behave just like it reached eof)
protected:
AudioFilePlayer& mParent;
void (*Disconnect)(struct S_AudioFileManager *afm);
int (*DoConnect)(struct S_AudioFileManager *afm);
OSStatus (*Read)(struct S_AudioFileManager *afm, char *buffer, UInt32 *len);
const char* (*GetFileBuffer)(struct S_AudioFileManager *afm);
const AudioFilePlayer *(*GetParent)(struct S_AudioFileManager *afm);
void (*SetPosition)(struct S_AudioFileManager *afm, SInt64 pos); // seek/rewind in the file
int (*GetByteCounter)(struct S_AudioFileManager *afm); // return actual bytes streamed to audio hardware
void (*SetEndOfFile)(struct S_AudioFileManager *afm, SInt64 pos); // set the "EOF" (will behave just like it reached eof)
//protected:
AudioFilePlayer* mParent;
SInt16 mForkRefNum;
SInt64 mAudioDataOffset;
......@@ -157,9 +126,9 @@ protected:
int mByteCounter;
bool mReadFromFirstBuffer;
bool mLockUnsuccessful;
bool mIsEngaged;
int mReadFromFirstBuffer;
int mLockUnsuccessful;
int mIsEngaged;
int mNumTimesAskedSinceFinished;
......@@ -167,27 +136,34 @@ protected:
void* mTmpBuffer;
UInt32 mBufferSize;
UInt32 mBufferOffset;
public:
const UInt32 mChunkSize;
//public:
UInt32 mChunkSize;
SInt64 mFileLength;
SInt64 mReadFilePosition;
bool mWriteToFirstBuffer;
bool mFinishedReadingData;
protected:
OSStatus Render (AudioBuffer &ioData);
int mWriteToFirstBuffer;
int mFinishedReadingData;
OSStatus GetFileData (void** inOutData, UInt32 *inOutDataSize);
//protected:
OSStatus (*Render)(struct S_AudioFileManager *afm, AudioBuffer *ioData);
OSStatus (*GetFileData)(struct S_AudioFileManager *afm, void** inOutData, UInt32 *inOutDataSize);
void (*AfterRender)(struct S_AudioFileManager *afm);
void AfterRender ();
public:
static OSStatus FileInputProc (void *inRefCon,
//public:
//static
OSStatus (*FileInputProc)(void *inRefCon,
AudioUnitRenderActionFlags inActionFlags,
const AudioTimeStamp *inTimeStamp,
UInt32 inBusNumber,
AudioBuffer *ioData);
};
} AudioFileManager;
AudioFileManager *new_AudioFileManager (AudioFilePlayer *inParent,
SInt16 inForkRefNum,
SInt64 inFileLength,
UInt32 inChunkSize);
void delete_AudioFileManager(AudioFileManager *afm);
#endif
src/cdrom/macosx/AudioFileReaderThread.cpp → src/cdrom/macosx/AudioFileReaderThread.c
View file @ 7be238c6
......@@ -28,105 +28,142 @@
//
#include "AudioFilePlayer.h"
#include <mach/mach.h> //used for setting policy of thread
#include "CAGuard.h"
#include "SDLOSXCAGuard.h"
#include <pthread.h>
#include <list>
//#include <list>
class FileReaderThread {
public:
FileReaderThread ();
CAGuard& GetGuard() { return mGuard; }
void AddReader();
void RemoveReader (AudioFileManager* inItem);
// returns true if succeeded
bool TryNextRead (AudioFileManager* inItem)
{
bool didLock = false;
bool succeeded = false;
if (mGuard.Try (didLock))
{
mFileData.push_back (inItem);
mGuard.Notify();
succeeded = true;
//typedef void *FileData;
typedef struct S_FileData
{
AudioFileManager *obj;
struct S_FileData *next;
} FileData;
if (didLock)
mGuard.Unlock();
}
return succeeded;
}
typedef struct S_FileReaderThread {
//public:
SDLOSXCAGuard* (*GetGuard)(struct S_FileReaderThread *frt);
void (*AddReader)(struct S_FileReaderThread *frt);
void (*RemoveReader)(struct S_FileReaderThread *frt, AudioFileManager* inItem);
int (*TryNextRead)(struct S_FileReaderThread *frt, AudioFileManager* inItem);
int mThreadShouldDie;
private:
typedef std::list<AudioFileManager*> FileData;
//private:
//typedef std::list<AudioFileManager*> FileData;
CAGuard mGuard;
SDLOSXCAGuard *mGuard;
UInt32 mThreadPriority;
int mNumReaders;
FileData mFileData;
FileData *mFileData;
void ReadNextChunk ();
void StartFixedPriorityThread ();
static UInt32 GetThreadBasePriority (pthread_t inThread);
void (*ReadNextChunk)(struct S_FileReaderThread *frt);
int (*StartFixedPriorityThread)(struct S_FileReaderThread *frt);
//static
UInt32 (*GetThreadBasePriority)(pthread_t inThread);
//static
void* (*DiskReaderEntry)(void *inRefCon);
} FileReaderThread;
static void* DiskReaderEntry (void *inRefCon);
};
FileReaderThread::FileReaderThread ()
: mThreadPriority (62),
mNumReaders (0)
static SDLOSXCAGuard* FileReaderThread_GetGuard(FileReaderThread *frt)
{
return frt->mGuard;
}
void FileReaderThread::AddReader()
// returns 1 if succeeded
static int FileReaderThread_TryNextRead (FileReaderThread *frt, AudioFileManager* inItem)
{
if (mNumReaders == 0)
int didLock = 0;
int succeeded = 0;
if (frt->mGuard->Try(frt->mGuard, &didLock))
{
mThreadShouldDie = false;
//frt->mFileData.push_back (inItem);
// !!! FIXME: this could be faster with a "tail" member. --ryan.
FileData *i = frt->mFileData;
FileData *prev = NULL;
FileData *newfd = (FileData *) malloc(sizeof (FileData));
newfd->obj = inItem;
newfd->next = NULL;
while (i != NULL) { prev = i; i = i->next; }
if (prev == NULL)
frt->mFileData = newfd;
else
prev->next = newfd;
frt->mGuard->Notify(frt->mGuard);
succeeded = 1;
StartFixedPriorityThread ();
if (didLock)
frt->mGuard->Unlock(frt->mGuard);
}
mNumReaders++;
return succeeded;
}
void FileReaderThread::RemoveReader (AudioFileManager* inItem)
static void FileReaderThread_AddReader(FileReaderThread *frt)
{
if (mNumReaders > 0)
if (frt->mNumReaders == 0)
{
CAGuard::Locker fileReadLock (mGuard);
frt->mThreadShouldDie = 0;
frt->StartFixedPriorityThread (frt);
}
frt->mNumReaders++;
}
mFileData.remove (inItem);
static void FileReaderThread_RemoveReader (FileReaderThread *frt, AudioFileManager* inItem)
{
if (frt->mNumReaders > 0)
{
int bNeedsRelease = frt->mGuard->Lock(frt->mGuard);
if (--mNumReaders == 0) {
mThreadShouldDie = true;
mGuard.Notify(); // wake up thread so it will quit
mGuard.Wait(); // wait for thread to die
//frt->mFileData.remove (inItem);
FileData *i = frt->mFileData;
FileData *prev = NULL;
while (i != NULL)
{
FileData *next = i->next;
if (i->obj != inItem)
prev = i;
else
{
if (prev == NULL)
frt->mFileData = next;
else
prev->next = next;
free(i);
}
i = next;
}
if (--frt->mNumReaders == 0) {
frt->mThreadShouldDie = 1;
frt->mGuard->Notify(frt->mGuard); // wake up thread so it will quit
frt->mGuard->Wait(frt->mGuard); // wait for thread to die
}
if (bNeedsRelease) frt->mGuard->Unlock(frt->mGuard);
}
}
void FileReaderThread::StartFixedPriorityThread ()
static int FileReaderThread_StartFixedPriorityThread (FileReaderThread *frt)
{
pthread_attr_t theThreadAttrs;
pthread_t pThread;
OSStatus result = pthread_attr_init(&theThreadAttrs);
THROW_RESULT("pthread_attr_init - Thread attributes could not be created.")
if (result) return 0; //THROW_RESULT("pthread_attr_init - Thread attributes could not be created.")
result = pthread_attr_setdetachstate(&theThreadAttrs, PTHREAD_CREATE_DETACHED);
THROW_RESULT("pthread_attr_setdetachstate - Thread attributes could not be detached.")
if (result) return 0; //THROW_RESULT("pthread_attr_setdetachstate - Thread attributes could not be detached.")
result = pthread_create (&pThread, &theThreadAttrs, DiskReaderEntry, this);
THROW_RESULT("pthread_create - Create and start the thread.")
result = pthread_create (&pThread, &theThreadAttrs, frt->DiskReaderEntry, frt);
if (result) return 0; //THROW_RESULT("pthread_create - Create and start the thread.")
pthread_attr_destroy(&theThreadAttrs);
......@@ -138,19 +175,21 @@ void FileReaderThread::StartFixedPriorityThread ()
SInt32 relativePriority;
// make thread fixed
theFixedPolicy.timeshare = false; // set to true for a non-fixed thread
theFixedPolicy.timeshare = 0; // set to 1 for a non-fixed thread
result = thread_policy_set (pthread_mach_thread_np(pThread), THREAD_EXTENDED_POLICY, (thread_policy_t)&theFixedPolicy, THREAD_EXTENDED_POLICY_COUNT);
THROW_RESULT("thread_policy - Couldn't set thread as fixed priority.")
if (result) return 0; //THROW_RESULT("thread_policy - Couldn't set thread as fixed priority.")
// set priority
// precedency policy's "importance" value is relative to spawning thread's priority
relativePriority = mThreadPriority - FileReaderThread::GetThreadBasePriority (pthread_self());
relativePriority = frt->mThreadPriority - frt->GetThreadBasePriority(pthread_self());
thePrecedencePolicy.importance = relativePriority;
result = thread_policy_set (pthread_mach_thread_np(pThread), THREAD_PRECEDENCE_POLICY, (thread_policy_t)&thePrecedencePolicy, THREAD_PRECEDENCE_POLICY_COUNT);
THROW_RESULT("thread_policy - Couldn't set thread priority.")
if (result) return 0; //THROW_RESULT("thread_policy - Couldn't set thread priority.")
return 1;
}
UInt32 FileReaderThread::GetThreadBasePriority (pthread_t inThread)
static UInt32 FileReaderThread_GetThreadBasePriority (pthread_t inThread)
{
thread_basic_info_data_t threadInfo;
policy_info_data_t thePolicyInfo;
......@@ -191,10 +230,10 @@ UInt32 FileReaderThread::GetThreadBasePriority (pthread_t inThread)
return 0;
}
void *FileReaderThread::DiskReaderEntry (void *inRefCon)
static void *FileReaderThread_DiskReaderEntry (void *inRefCon)
{
FileReaderThread *This = (FileReaderThread *)inRefCon;
This->ReadNextChunk();
FileReaderThread *frt = (FileReaderThread *)inRefCon;
frt->ReadNextChunk(frt);
#if DEBUG
printf ("finished with reading file\n");
#endif
......@@ -202,7 +241,7 @@ void *FileReaderThread::DiskReaderEntry (void *inRefCon)
return 0;
}
void FileReaderThread::ReadNextChunk ()
static void FileReaderThread_ReadNextChunk (FileReaderThread *frt)
{
OSStatus result;
UInt32 dataChunkSize;
......@@ -211,28 +250,40 @@ void FileReaderThread::ReadNextChunk ()
for (;;)
{
{ // this is a scoped based lock
CAGuard::Locker fileReadLock (mGuard);
if (this->mThreadShouldDie) {
int bNeedsRelease = frt->mGuard->Lock(frt->mGuard);
mGuard.Notify();
if (frt->mThreadShouldDie) {
frt->mGuard->Notify(frt->mGuard);
if (bNeedsRelease) frt->mGuard->Unlock(frt->mGuard);
return;
}
if (mFileData.empty())
//if (frt->mFileData.empty())
if (frt->mFileData == NULL)
{
mGuard.Wait();
frt->mGuard->Wait(frt->mGuard);
}
// kill thread
if (this->mThreadShouldDie) {
if (frt->mThreadShouldDie) {
mGuard.Notify();
frt->mGuard->Notify(frt->mGuard);
if (bNeedsRelease) frt->mGuard->Unlock(frt->mGuard);
return;
}
theItem = mFileData.front();
mFileData.pop_front();
//theItem = frt->mFileData.front();
//frt->mFileData.pop_front();
theItem = NULL;
if (frt->mFileData != NULL)
{
FileData *next = frt->mFileData->next;
theItem = frt->mFileData->obj;
free(frt->mFileData);
frt->mFileData = next;
}
if (bNeedsRelease) frt->mGuard->Unlock(frt->mGuard);
}
if ((theItem->mFileLength - theItem->mReadFilePosition) < theItem->mChunkSize)
......@@ -242,17 +293,18 @@ void FileReaderThread::ReadNextChunk ()
// this is the exit condition for the thread
if (dataChunkSize <= 0) {
theItem->mFinishedReadingData = true;
theItem->mFinishedReadingData = 1;
continue;
}
// construct pointer
char* writePtr = const_cast<char*>(theItem->GetFileBuffer() +
char* writePtr = (char *) (theItem->GetFileBuffer(theItem) +
(theItem->mWriteToFirstBuffer ? 0 : theItem->mChunkSize));
// read data
result = theItem->Read(writePtr, &dataChunkSize);
result = theItem->Read(theItem, writePtr, &dataChunkSize);
if (result != noErr && result != eofErr) {
theItem->GetParent().DoNotification(result);
AudioFilePlayer *afp = (AudioFilePlayer *) theItem->GetParent(theItem);
afp->DoNotification(afp, result);
continue;
}
......@@ -273,150 +325,278 @@ void FileReaderThread::ReadNextChunk ()
}
}
void delete_FileReaderThread(FileReaderThread *frt)
{
if (frt != NULL)
{
delete_SDLOSXCAGuard(frt->mGuard);
free(frt);
}
}
static FileReaderThread sReaderThread;
FileReaderThread *new_FileReaderThread ()
{
FileReaderThread *frt = (FileReaderThread *) malloc(sizeof (FileReaderThread));
if (frt == NULL)
return NULL;
memset(frt, '\0', sizeof (*frt));
AudioFileManager::AudioFileManager (AudioFilePlayer &inParent,
SInt16 inForkRefNum,
SInt64 inFileLength,
UInt32 inChunkSize)
: mParent (inParent),
mForkRefNum (inForkRefNum),
mFileBuffer (0),
mByteCounter (0),
mLockUnsuccessful (false),
mIsEngaged (false),
mBufferSize (inChunkSize),
mBufferOffset (inChunkSize),
mChunkSize (inChunkSize),
mFileLength (inFileLength),
mReadFilePosition (0),
mWriteToFirstBuffer (false),
mFinishedReadingData (false)
frt->mGuard = new_SDLOSXCAGuard();
if (frt->mGuard == NULL)
{
free(frt);
return NULL;
}
{
mFileBuffer = (char*) malloc (mChunkSize * 2);
FSGetForkPosition(mForkRefNum, &mAudioDataOffset);
assert (mFileBuffer != NULL);
#define SET_FILEREADERTHREAD_METHOD(m) frt->m = FileReaderThread_##m
SET_FILEREADERTHREAD_METHOD(GetGuard);
SET_FILEREADERTHREAD_METHOD(AddReader);
SET_FILEREADERTHREAD_METHOD(RemoveReader);
SET_FILEREADERTHREAD_METHOD(TryNextRead);
SET_FILEREADERTHREAD_METHOD(ReadNextChunk);
SET_FILEREADERTHREAD_METHOD(StartFixedPriorityThread);
SET_FILEREADERTHREAD_METHOD(GetThreadBasePriority);
SET_FILEREADERTHREAD_METHOD(DiskReaderEntry);
#undef SET_FILEREADERTHREAD_METHOD
frt->mThreadPriority = 62;
return frt;
}
void AudioFileManager::DoConnect ()
static FileReaderThread *sReaderThread;
static int AudioFileManager_DoConnect (AudioFileManager *afm)
{
if (!mIsEngaged)
if (!afm->mIsEngaged)
{
//mReadFilePosition = 0;
mFinishedReadingData = false;
//afm->mReadFilePosition = 0;
afm->mFinishedReadingData = 0;
mNumTimesAskedSinceFinished = 0;
mLockUnsuccessful = false;
afm->mNumTimesAskedSinceFinished = 0;
afm->mLockUnsuccessful = 0;
OSStatus result;
UInt32 dataChunkSize;
if ((mFileLength - mReadFilePosition) < mChunkSize)
dataChunkSize = mFileLength - mReadFilePosition;
if ((afm->mFileLength - afm->mReadFilePosition) < afm->mChunkSize)
dataChunkSize = afm->mFileLength - afm->mReadFilePosition;
else
dataChunkSize = mChunkSize;
dataChunkSize = afm->mChunkSize;
result = Read(mFileBuffer, &dataChunkSize);
THROW_RESULT("AudioFileManager::DoConnect(): Read")
result = afm->Read(afm, afm->mFileBuffer, &dataChunkSize);
if (result) return 0; //THROW_RESULT("AudioFileManager::DoConnect(): Read")
mReadFilePosition += dataChunkSize;
afm->mReadFilePosition += dataChunkSize;
mWriteToFirstBuffer = false;
mReadFromFirstBuffer = true;
afm->mWriteToFirstBuffer = 0;
afm->mReadFromFirstBuffer = 1;
sReaderThread.AddReader();
sReaderThread->AddReader(sReaderThread);
mIsEngaged = true;
afm->mIsEngaged = 1;
}
else
throw static_cast<OSStatus>(-1); //thread has already been started
//else
// throw static_cast<OSStatus>(-1); //thread has already been started
return 1;
}
void AudioFileManager::Disconnect ()
static void AudioFileManager_Disconnect (AudioFileManager *afm)
{
if (mIsEngaged)
if (afm->mIsEngaged)
{
sReaderThread.RemoveReader (this);
mIsEngaged = false;
sReaderThread->RemoveReader (sReaderThread, afm);
afm->mIsEngaged = 0;
}
}
OSStatus AudioFileManager::Read(char *buffer, UInt32 *len)
static OSStatus AudioFileManager_Read(AudioFileManager *afm, char *buffer, UInt32 *len)
{
return FSReadFork (mForkRefNum,
return FSReadFork (afm->mForkRefNum,
fsFromStart,
mReadFilePosition + mAudioDataOffset,
afm->mReadFilePosition + afm->mAudioDataOffset,
*len,
buffer,
len);
}
OSStatus AudioFileManager::GetFileData (void** inOutData, UInt32 *inOutDataSize)
static OSStatus AudioFileManager_GetFileData (AudioFileManager *afm, void** inOutData, UInt32 *inOutDataSize)
{
if (mFinishedReadingData)
if (afm->mFinishedReadingData)
{
++mNumTimesAskedSinceFinished;
++afm->mNumTimesAskedSinceFinished;
*inOutDataSize = 0;
*inOutData = 0;
return noErr;
}
if (mReadFromFirstBuffer == mWriteToFirstBuffer) {
if (afm->mReadFromFirstBuffer == afm->mWriteToFirstBuffer) {
#if DEBUG
printf ("* * * * * * * Can't keep up with reading file\n");
#endif
mParent.DoNotification (kAudioFilePlayErr_FilePlayUnderrun);
afm->mParent->DoNotification (afm->mParent, kAudioFilePlayErr_FilePlayUnderrun);
*inOutDataSize = 0;
*inOutData = 0;
} else {
*inOutDataSize = mChunkSize;
*inOutData = mReadFromFirstBuffer ? mFileBuffer : (mFileBuffer + mChunkSize);
*inOutDataSize = afm->mChunkSize;
*inOutData = afm->mReadFromFirstBuffer ? afm->mFileBuffer : (afm->mFileBuffer + afm->mChunkSize);
}
mLockUnsuccessful = !sReaderThread.TryNextRead (this);
afm->mLockUnsuccessful = !sReaderThread->TryNextRead (sReaderThread, afm);
mReadFromFirstBuffer = !mReadFromFirstBuffer;
afm->mReadFromFirstBuffer = !afm->mReadFromFirstBuffer;
return noErr;
}
void AudioFileManager::AfterRender ()
static void AudioFileManager_AfterRender (AudioFileManager *afm)
{
if (mNumTimesAskedSinceFinished > 0)
if (afm->mNumTimesAskedSinceFinished > 0)
{
bool didLock = false;
if (sReaderThread.GetGuard().Try (didLock)) {
mParent.DoNotification (kAudioFilePlay_FileIsFinished);
int didLock = 0;
SDLOSXCAGuard *guard = sReaderThread->GetGuard(sReaderThread);
if (guard->Try(guard, &didLock)) {
afm->mParent->DoNotification (afm->mParent, kAudioFilePlay_FileIsFinished);
if (didLock)
sReaderThread.GetGuard().Unlock();
guard->Unlock(guard);
}
}
if (mLockUnsuccessful)
mLockUnsuccessful = !sReaderThread.TryNextRead (this);
if (afm->mLockUnsuccessful)
afm->mLockUnsuccessful = !sReaderThread->TryNextRead (sReaderThread, afm);
}
void AudioFileManager::SetPosition (SInt64 pos)
static void AudioFileManager_SetPosition (AudioFileManager *afm, SInt64 pos)
{
if (pos < 0 || pos >= mFileLength) {
if (pos < 0 || pos >= afm->mFileLength) {
SDL_SetError ("AudioFileManager::SetPosition - position invalid: %d filelen=%d\n",
(unsigned int)pos, (unsigned int)mFileLength);
(unsigned int)pos, (unsigned int)afm->mFileLength);
pos = 0;
}
mReadFilePosition = pos;
afm->mReadFilePosition = pos;
}
void AudioFileManager::SetEndOfFile (SInt64 pos)
static void AudioFileManager_SetEndOfFile (AudioFileManager *afm, SInt64 pos)
{
if (pos <= 0 || pos > mFileLength) {
if (pos <= 0 || pos > afm->mFileLength) {
SDL_SetError ("AudioFileManager::SetEndOfFile - position beyond actual eof\n");
pos = mFileLength;
pos = afm->mFileLength;
}
mFileLength = pos;
afm->mFileLength = pos;
}
static const char *AudioFileManager_GetFileBuffer(AudioFileManager *afm)
{
return afm->mFileBuffer;
}
const AudioFilePlayer *AudioFileManager_GetParent(AudioFileManager *afm)
{
return afm->mParent;
}
static int AudioFileManager_GetByteCounter(AudioFileManager *afm)
{
return afm->mByteCounter;
}
static OSStatus AudioFileManager_FileInputProc (void *inRefCon,
AudioUnitRenderActionFlags inActionFlags,
const AudioTimeStamp *inTimeStamp,
UInt32 inBusNumber,
AudioBuffer *ioData)
{
AudioFileManager* afm = (AudioFileManager*)inRefCon;
return afm->Render(afm, ioData);
}
static OSStatus AudioFileManager_Render (AudioFileManager *afm, AudioBuffer *ioData)
{
OSStatus result = noErr;
if (afm->mBufferOffset >= afm->mBufferSize) {
result = afm->GetFileData(afm, &afm->mTmpBuffer, &afm->mBufferSize);
if (result) {
SDL_SetError ("AudioConverterFillBuffer:%ld\n", result);
afm->mParent->DoNotification(afm->mParent, result);
return result;
}
afm->mBufferOffset = 0;
}
if (ioData->mDataByteSize > afm->mBufferSize - afm->mBufferOffset)
ioData->mDataByteSize = afm->mBufferSize - afm->mBufferOffset;
ioData->mData = (char *)afm->mTmpBuffer + afm->mBufferOffset;
afm->mBufferOffset += ioData->mDataByteSize;
afm->mByteCounter += ioData->mDataByteSize;
afm->AfterRender(afm);
return result;
}
void delete_AudioFileManager (AudioFileManager *afm)
{
if (afm != NULL) {
if (afm->mFileBuffer) {
free (afm->mFileBuffer);
}
free(afm);
}
}
AudioFileManager *new_AudioFileManager(AudioFilePlayer *inParent,
SInt16 inForkRefNum,
SInt64 inFileLength,
UInt32 inChunkSize)
{
AudioFileManager *afm;
if (sReaderThread == NULL)
{
sReaderThread = new_FileReaderThread();
if (sReaderThread == NULL)
return NULL;
}
afm = (AudioFileManager *) malloc(sizeof (AudioFileManager));
if (afm == NULL)
return NULL;
memset(afm, '\0', sizeof (*afm));
#define SET_AUDIOFILEMANAGER_METHOD(m) afm->m = AudioFileManager_##m
SET_AUDIOFILEMANAGER_METHOD(Disconnect);
SET_AUDIOFILEMANAGER_METHOD(DoConnect);
SET_AUDIOFILEMANAGER_METHOD(Read);
SET_AUDIOFILEMANAGER_METHOD(GetFileBuffer);
SET_AUDIOFILEMANAGER_METHOD(GetParent);
SET_AUDIOFILEMANAGER_METHOD(SetPosition);
SET_AUDIOFILEMANAGER_METHOD(GetByteCounter);
SET_AUDIOFILEMANAGER_METHOD(SetEndOfFile);
SET_AUDIOFILEMANAGER_METHOD(Render);
SET_AUDIOFILEMANAGER_METHOD(GetFileData);
SET_AUDIOFILEMANAGER_METHOD(AfterRender);
SET_AUDIOFILEMANAGER_METHOD(FileInputProc);
#undef SET_AUDIOFILEMANAGER_METHOD
afm->mParent = inParent;
afm->mForkRefNum = inForkRefNum;
afm->mBufferSize = inChunkSize;
afm->mBufferOffset = inChunkSize;
afm->mChunkSize = inChunkSize;
afm->mFileLength = inFileLength;
afm->mFileBuffer = (char*) malloc (afm->mChunkSize * 2);
FSGetForkPosition(afm->mForkRefNum, &afm->mAudioDataOffset);
assert (afm->mFileBuffer != NULL);
return afm;
}
src/cdrom/macosx/CDPlayer.cpp → src/cdrom/macosx/CDPlayer.c
View file @ 7be238c6
......@@ -22,10 +22,10 @@
#include "CDPlayer.h"
#include "AudioFilePlayer.h"
#include "CAGuard.h"
#include "SDLOSXCAGuard.h"
// we're exporting these functions into C land for SDL_syscdrom.c
extern "C" {
//extern "C" {
//
// Constants
......@@ -52,7 +52,7 @@ extern "C" {
#pragma mark -- Globals --
static bool playBackWasInit = false;
static int playBackWasInit = 0;
static AudioUnit theUnit;
static AudioFilePlayer* thePlayer = NULL;
static CDPlayerCompletionProc completionProc = NULL;
......@@ -411,38 +411,40 @@ int LoadFile (const FSRef *ref, int startFrame, int stopFrame)
printf ("LoadFile: %d %d\n", startFrame, stopFrame);
#endif
try {
//try {
// create a new player, and attach to the audio unit
thePlayer = new AudioFilePlayer(ref);
thePlayer = new_AudioFilePlayer(ref);
if (thePlayer == NULL) {
SDL_SetError ("LoadFile: Could not create player");
throw (-3);
return -3; //throw (-3);
}
thePlayer->SetDestination(theUnit);
if (!thePlayer->SetDestination(thePlayer, &theUnit))
goto bail;
if (startFrame >= 0)
thePlayer->SetStartFrame (startFrame);
thePlayer->SetStartFrame (thePlayer, startFrame);
if (stopFrame >= 0 && stopFrame > startFrame)
thePlayer->SetStopFrame (stopFrame);
thePlayer->SetStopFrame (thePlayer, stopFrame);
// we set the notifier later
//thePlayer->SetNotifier(FilePlayNotificationHandler, NULL);
//thePlayer->SetNotifier(thePlayer, FilePlayNotificationHandler, NULL);
thePlayer->Connect();
if (!thePlayer->Connect(thePlayer))
goto bail;
#if DEBUG_CDROM
thePlayer->Print();
thePlayer->Print(thePlayer);
fflush (stdout);
#endif
}
catch (...)
{
goto bail;
}
//}
//catch (...)
//{
// goto bail;
//}
error = 0;
......@@ -458,24 +460,25 @@ int ReleaseFile ()
{
int error = -1;
try {
// (Don't see any way that the original C++ code could throw here.) --ryan.
//try {
if (thePlayer != NULL) {
thePlayer->Disconnect();
thePlayer->Disconnect(thePlayer);
delete thePlayer;
delete_AudioFilePlayer(thePlayer);
thePlayer = NULL;
}
}
catch (...)
{
goto bail;
}
//}
//catch (...)
//{
// goto bail;
//}
error = 0;
bail:
// bail:
return error;
}
......@@ -490,17 +493,17 @@ int PlayFile ()
if (CheckInit () < 0)
goto bail;
try {
// try {
// start processing of the audio unit
result = AudioOutputUnitStart (theUnit);
THROW_RESULT("PlayFile: AudioOutputUnitStart")
if (result) goto bail; //THROW_RESULT("PlayFile: AudioOutputUnitStart")
}
catch (...)
{
goto bail;
}
// }
// catch (...)
// {
// goto bail;
// }
result = 0;
......@@ -519,16 +522,16 @@ int PauseFile ()
if (CheckInit () < 0)
goto bail;
try {
//try {
// stop processing the audio unit
result = AudioOutputUnitStop (theUnit);
THROW_RESULT("PauseFile: AudioOutputUnitStop")
}
catch (...)
{
goto bail;
}
if (result) goto bail; //THROW_RESULT("PauseFile: AudioOutputUnitStop")
//}
//catch (...)
//{
// goto bail;
//}
result = 0;
bail:
......@@ -545,7 +548,7 @@ void SetCompletionProc (CDPlayerCompletionProc proc, SDL_CD *cdrom)
theCDROM = cdrom;
completionProc = proc;
thePlayer->SetNotifier (FilePlayNotificationHandler, cdrom);
thePlayer->SetNotifier (thePlayer, FilePlayNotificationHandler, cdrom);
}
//
......@@ -559,7 +562,7 @@ int GetCurrentFrame ()
if (thePlayer == NULL)
frame = 0;
else
frame = thePlayer->GetCurrentFrame ();
frame = thePlayer->GetCurrentFrame (thePlayer);
return frame;
}
......@@ -580,7 +583,7 @@ static OSStatus CheckInit ()
// Start callback thread
SDL_CreateThread(RunCallBackThread, NULL);
try {
{ //try {
ComponentDescription desc;
desc.componentType = kAudioUnitComponentType;
......@@ -592,23 +595,23 @@ static OSStatus CheckInit ()
Component comp = FindNextComponent (NULL, &desc);
if (comp == NULL) {
SDL_SetError ("CheckInit: FindNextComponent returned NULL");
throw(internalComponentErr);
if (result) return -1; //throw(internalComponentErr);
}
result = OpenAComponent (comp, &theUnit);
THROW_RESULT("CheckInit: OpenAComponent")
if (result) return -1; //THROW_RESULT("CheckInit: OpenAComponent")
// you need to initialize the output unit before you set it as a destination
result = AudioUnitInitialize (theUnit);
THROW_RESULT("CheckInit: AudioUnitInitialize")
if (result) return -1; //THROW_RESULT("CheckInit: AudioUnitInitialize")
playBackWasInit = true;
}
catch (...)
{
return -1;
}
//catch (...)
//{
// return -1;
//}
return 0;
}
......@@ -657,4 +660,4 @@ static int RunCallBackThread (void *param)
return 0;
}
}; // extern "C"
//}; // extern "C"
src/cdrom/macosx/Makefile.am
View file @ 7be238c6
......@@ -9,9 +9,8 @@ SRCS = \
SDL_syscdrom_c.h \
SDL_syscdrom.c \
AudioFilePlayer.h \
AudioFilePlayer.cpp \
AudioFileReaderThread.cpp \
CAGuard.h \
CAGuard.cpp \
AudioFilePlayer.c \
AudioFileReaderThread.c \
SDLOSXCAGuard.c \
CDPlayer.h \
CDPlayer.cpp
CDPlayer.c
src/cdrom/macosx/CAGuard.cpp → src/cdrom/macosx/SDLOSXCAGuard.c
View file @ 7be238c6
......@@ -69,92 +69,114 @@
//=============================================================================
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
//#define NDEBUG 1
#include <assert.h>
#include "CAGuard.h"
#include "SDLOSXCAGuard.h"
//#warning Need a try-based Locker too
//=============================================================================
// CAGuard
// SDLOSXCAGuard
//=============================================================================
CAGuard::CAGuard()
static int SDLOSXCAGuard_Lock(SDLOSXCAGuard *cag)
{
OSStatus theError = pthread_mutex_init(&mMutex, NULL);
assert(theError == 0);
theError = pthread_cond_init(&mCondVar, NULL);
assert(theError == 0);
mOwner = 0;
}
CAGuard::~CAGuard()
{
pthread_mutex_destroy(&mMutex);
pthread_cond_destroy(&mCondVar);
}
bool CAGuard::Lock()
{
bool theAnswer = false;
int theAnswer = 0;
if(pthread_self() != mOwner)
if(pthread_self() != cag->mOwner)
{
OSStatus theError = pthread_mutex_lock(&mMutex);
OSStatus theError = pthread_mutex_lock(&cag->mMutex);
assert(theError == 0);
mOwner = pthread_self();
theAnswer = true;
cag->mOwner = pthread_self();
theAnswer = 1;
}
return theAnswer;
}
void CAGuard::Unlock()
static void SDLOSXCAGuard_Unlock(SDLOSXCAGuard *cag)
{
assert(pthread_self() == mOwner);
assert(pthread_self() == cag->mOwner);
mOwner = 0;
OSStatus theError = pthread_mutex_unlock(&mMutex);
cag->mOwner = 0;
OSStatus theError = pthread_mutex_unlock(&cag->mMutex);
assert(theError == 0);
}
bool CAGuard::Try (bool& outWasLocked)
static int SDLOSXCAGuard_Try (SDLOSXCAGuard *cag, int *outWasLocked)
{
bool theAnswer = false;
outWasLocked = false;
int theAnswer = 0;
*outWasLocked = 0;
if (pthread_self() == mOwner) {
theAnswer = true;
outWasLocked = false;
if (pthread_self() == cag->mOwner) {
theAnswer = 1;
*outWasLocked = 0;
} else {
OSStatus theError = pthread_mutex_trylock(&mMutex);
OSStatus theError = pthread_mutex_trylock(&cag->mMutex);
if (theError == 0) {
mOwner = pthread_self();
theAnswer = true;
outWasLocked = true;
cag->mOwner = pthread_self();
theAnswer = 1;
*outWasLocked = 1;
}
}
return theAnswer;
}
void CAGuard::Wait()
static void SDLOSXCAGuard_Wait(SDLOSXCAGuard *cag)
{
assert(pthread_self() == mOwner);
assert(pthread_self() == cag->mOwner);
cag->mOwner = 0;
mOwner = 0;
OSStatus theError = pthread_cond_wait(&cag->mCondVar, &cag->mMutex);
assert(theError == 0);
cag->mOwner = pthread_self();
}
OSStatus theError = pthread_cond_wait(&mCondVar, &mMutex);
static void SDLOSXCAGuard_Notify(SDLOSXCAGuard *cag)
{
OSStatus theError = pthread_cond_signal(&cag->mCondVar);
assert(theError == 0);
mOwner = pthread_self();
}
void CAGuard::Notify()
SDLOSXCAGuard *new_SDLOSXCAGuard(void)
{
OSStatus theError = pthread_cond_signal(&mCondVar);
SDLOSXCAGuard *cag = (SDLOSXCAGuard *) malloc(sizeof (SDLOSXCAGuard));
if (cag == NULL)
return NULL;
memset(cag, '\0', sizeof (*cag));
#define SET_SDLOSXCAGUARD_METHOD(m) cag->m = SDLOSXCAGuard_##m
SET_SDLOSXCAGUARD_METHOD(Lock);
SET_SDLOSXCAGUARD_METHOD(Unlock);
SET_SDLOSXCAGUARD_METHOD(Try);
SET_SDLOSXCAGUARD_METHOD(Wait);
SET_SDLOSXCAGUARD_METHOD(Notify);
#undef SET_SDLOSXCAGUARD_METHOD
OSStatus theError = pthread_mutex_init(&cag->mMutex, NULL);
assert(theError == 0);
theError = pthread_cond_init(&cag->mCondVar, NULL);
assert(theError == 0);
cag->mOwner = 0;
return cag;
}
void delete_SDLOSXCAGuard(SDLOSXCAGuard *cag)
{
if (cag != NULL)
{
pthread_mutex_destroy(&cag->mMutex);
pthread_cond_destroy(&cag->mCondVar);
free(cag);
}
}
src/cdrom/macosx/CAGuard.h → src/cdrom/macosx/SDLOSXCAGuard.h
View file @ 7be238c6
......@@ -87,57 +87,28 @@
// return false if they receive notification any other way.
//=============================================================================
class CAGuard
typedef struct S_SDLOSXCAGuard
{
// Construction/Destruction
public:
CAGuard();
virtual ~CAGuard();
//public:
// Actions
public:
virtual bool Lock();
virtual void Unlock();
virtual bool Try(bool& outWasLocked); // returns true if lock is free, false if not
virtual void Wait();
virtual void Notify();
//public:
int (*Lock)(struct S_SDLOSXCAGuard *cag);
void (*Unlock)(struct S_SDLOSXCAGuard *cag);
int (*Try)(struct S_SDLOSXCAGuard *cag, int *outWasLocked); // returns true if lock is free, false if not
void (*Wait)(struct S_SDLOSXCAGuard *cag);
void (*Notify)(struct S_SDLOSXCAGuard *cag);
// Implementation
protected:
//protected:
pthread_mutex_t mMutex;
pthread_cond_t mCondVar;
pthread_t mOwner;
} SDLOSXCAGuard;
// Helper class to manage taking and releasing recursively
public:
class Locker
{
// Construction/Destruction
public:
Locker(CAGuard& inGuard) : mGuard(inGuard), mNeedsRelease(false) { mNeedsRelease = mGuard.Lock(); }
~Locker() { if(mNeedsRelease) { mGuard.Unlock(); } }
private:
Locker(const Locker&);
Locker& operator=(const Locker&);
// Actions
public:
void Wait() { mGuard.Wait(); }
void Notify() { mGuard.Notify(); }
// Implementation
private:
CAGuard& mGuard;
bool mNeedsRelease;
};
};
SDLOSXCAGuard *new_SDLOSXCAGuard(void);
void delete_SDLOSXCAGuard(SDLOSXCAGuard *cag);
#endif
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment