/*

SDL - Simple DirectMedia Layer

Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002 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

*/

/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

AudioFileManager.cpp

*/

#include "SDLOSXCAGuard.h"

#include <pthread.h>

typedef struct S_FileData

{

AudioFileManager *obj;

struct S_FileData *next;

} FileData;

typedef struct S_FileReaderThread

{

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;

SDLOSXCAGuard *mGuard;

UInt32 mThreadPriority;

int mNumReaders;

FileData *mFileData;

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 SDLOSXCAGuard *

FileReaderThread_GetGuard (FileReaderThread * frt)

{

return frt->mGuard;

}

static int

FileReaderThread_TryNextRead (FileReaderThread * frt,

AudioFileManager * inItem)

{

int didLock = 0;

int succeeded = 0;

if (frt->mGuard->Try (frt->mGuard, &didLock)) {

/*frt->mFileData.push_back (inItem); */

FileData *i = frt->mFileData;

FileData *prev = NULL;

newfd->obj = inItem;

newfd->next = NULL;

while (i != NULL) {

prev = i;

i = i->next;

}

if (prev == NULL)

frt->mFileData = newfd;

else

prev->next = newfd;

succeeded = 1;

if (didLock)

return succeeded;

}

static void

FileReaderThread_AddReader (FileReaderThread * frt)

frt->mThreadShouldDie = 0;

frt->StartFixedPriorityThread (frt);

}

frt->mNumReaders++;

}

static void

FileReaderThread_RemoveReader (FileReaderThread * frt,

AudioFileManager * inItem)

if (frt->mNumReaders > 0) {

int bNeedsRelease = frt->mGuard->Lock (frt->mGuard);

/*frt->mFileData.remove (inItem); */

FileData *i = frt->mFileData;

FileData *prev = NULL;

FileData *next = i->next;

if (i->obj != inItem)

prev = i;

if (prev == NULL)

frt->mFileData = next;

else

prev->next = next;

}

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);

}

}

static int

FileReaderThread_StartFixedPriorityThread (FileReaderThread * frt)

pthread_attr_t theThreadAttrs;

pthread_t pThread;

OSStatus result = pthread_attr_init (&theThreadAttrs);

if (result)

return 0; /*THROW_RESULT("pthread_attr_init - Thread attributes could not be created.") */

result =

pthread_attr_setdetachstate (&theThreadAttrs,

PTHREAD_CREATE_DETACHED);

if (result)

return 0; /*THROW_RESULT("pthread_attr_setdetachstate - Thread attributes could not be detached.") */

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);

/* we've now created the thread and started it

we'll now set the priority of the thread to the nominated priority

and we'll also make the thread fixed */

thread_extended_policy_data_t theFixedPolicy;

thread_precedence_policy_data_t thePrecedencePolicy;

SInt32 relativePriority;

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);

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 =

frt->mThreadPriority - frt->GetThreadBasePriority (pthread_self ());

result =

thread_policy_set (pthread_mach_thread_np (pThread),

THREAD_PRECEDENCE_POLICY,

(thread_policy_t) & thePrecedencePolicy,

THREAD_PRECEDENCE_POLICY_COUNT);

if (result)

return 0; /*THROW_RESULT("thread_policy - Couldn't set thread priority.") */

return 1;

}

static UInt32

FileReaderThread_GetThreadBasePriority (pthread_t inThread)

thread_basic_info_data_t threadInfo;

policy_info_data_t thePolicyInfo;

unsigned int count;

thread_info (pthread_mach_thread_np (inThread), THREAD_BASIC_INFO,

(integer_t *) & threadInfo, &count);

case POLICY_TIMESHARE:

count = POLICY_TIMESHARE_INFO_COUNT;

thread_info (pthread_mach_thread_np (inThread),

THREAD_SCHED_TIMESHARE_INFO,

(integer_t *) & (thePolicyInfo.ts), &count);

return thePolicyInfo.ts.base_priority;

break;

case POLICY_FIFO:

count = POLICY_FIFO_INFO_COUNT;

thread_info (pthread_mach_thread_np (inThread),

THREAD_SCHED_FIFO_INFO,

(integer_t *) & (thePolicyInfo.fifo), &count);

if (thePolicyInfo.fifo.depressed) {

return thePolicyInfo.fifo.depress_priority;

} else {

return thePolicyInfo.fifo.base_priority;

}

break;

case POLICY_RR:

count = POLICY_RR_INFO_COUNT;

thread_info (pthread_mach_thread_np (inThread),

THREAD_SCHED_RR_INFO,

(integer_t *) & (thePolicyInfo.rr), &count);

if (thePolicyInfo.rr.depressed) {

return thePolicyInfo.rr.depress_priority;

} else {

return thePolicyInfo.rr.base_priority;

}

break;

return 0;

}

static void *

FileReaderThread_DiskReaderEntry (void *inRefCon)

FileReaderThread *frt = (FileReaderThread *) inRefCon;

frt->ReadNextChunk (frt);

#if DEBUG

#endif

return 0;

}

static void

FileReaderThread_ReadNextChunk (FileReaderThread * frt)

{

OSStatus result;

UInt32 dataChunkSize;

AudioFileManager *theItem = 0;

for (;;) {

{ /* this is a scoped based lock */

int bNeedsRelease = frt->mGuard->Lock (frt->mGuard);

frt->mGuard->Notify (frt->mGuard);

if (bNeedsRelease)

frt->mGuard->Unlock (frt->mGuard);

return;

}

/*if (frt->mFileData.empty()) */

if (frt->mFileData == NULL) {

frt->mGuard->Wait (frt->mGuard);

frt->mGuard->Notify (frt->mGuard);

if (bNeedsRelease)

frt->mGuard->Unlock (frt->mGuard);

return;

}

/*theItem = frt->mFileData.front(); */

/*frt->mFileData.pop_front(); */

FileData *next = frt->mFileData->next;

theItem = frt->mFileData->obj;

frt->mFileData = next;

}

if (bNeedsRelease)

frt->mGuard->Unlock (frt->mGuard);

if ((theItem->mFileLength - theItem->mReadFilePosition) <

theItem->mChunkSize)

dataChunkSize = theItem->mFileLength - theItem->mReadFilePosition;

else

dataChunkSize = theItem->mChunkSize;

/* this is the exit condition for the thread */

if (dataChunkSize <= 0) {

theItem->mFinishedReadingData = 1;

continue;

}

/* construct pointer */

char *writePtr = (char *) (theItem->GetFileBuffer (theItem) +

(theItem->

mWriteToFirstBuffer ? 0 : theItem->

mChunkSize));

/* read data */

result = theItem->Read (theItem, writePtr, &dataChunkSize);

AudioFilePlayer *afp =

(AudioFilePlayer *) theItem->GetParent (theItem);

afp->DoNotification (afp, result);

continue;

}

if (dataChunkSize != theItem->mChunkSize) {

writePtr += dataChunkSize;

if (result == eofErr)

theItem->mReadFilePosition = theItem->mFileLength;

else

}

}

void

delete_FileReaderThread (FileReaderThread * frt)

if (frt != NULL) {

delete_SDLOSXCAGuard (frt->mGuard);

SDL_free (frt);

}

}

FileReaderThread *

new_FileReaderThread ()

FileReaderThread *frt =

(FileReaderThread *) SDL_malloc (sizeof (FileReaderThread));

if (frt == NULL)

return NULL;

frt->mGuard = new_SDLOSXCAGuard ();

if (frt->mGuard == NULL) {

SDL_free (frt);

return 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;

}

static FileReaderThread *sReaderThread;

static int

AudioFileManager_DoConnect (AudioFileManager * afm)

OSStatus result;

afm->mFinishedReadingData = 0;

afm->mNumTimesAskedSinceFinished = 0;

afm->mLockUnsuccessful = 0;

if ((afm->mFileLength - afm->mReadFilePosition) < afm->mChunkSize)

dataChunkSize = afm->mFileLength - afm->mReadFilePosition;

else

dataChunkSize = afm->mChunkSize;

result = afm->Read (afm, afm->mFileBuffer, &dataChunkSize);

if (result)

return 0; /*THROW_RESULT("AudioFileManager::DoConnect(): Read") */

afm->mReadFilePosition += dataChunkSize;

afm->mWriteToFirstBuffer = 0;

afm->mReadFromFirstBuffer = 1;

sReaderThread->AddReader (sReaderThread);

afm->mIsEngaged = 1;

}

else

throw static_cast<OSStatus>(-1); *//* thread has already been started */

return 1;

}

static void

AudioFileManager_Disconnect (AudioFileManager * afm)

sReaderThread->RemoveReader (sReaderThread, afm);

afm->mIsEngaged = 0;

}

}

static OSStatus

AudioFileManager_Read (AudioFileManager * afm, char *buffer, UInt32 * len)

{

return FSReadFork (afm->mForkRefNum,

fsFromStart,

afm->mReadFilePosition + afm->mAudioDataOffset,

}

static OSStatus

AudioFileManager_GetFileData (AudioFileManager * afm, void **inOutData,

UInt32 * inOutDataSize)

++afm->mNumTimesAskedSinceFinished;

*inOutDataSize = 0;

*inOutData = 0;

return noErr;

}

#endif

afm->mParent->DoNotification (afm->mParent,

kAudioFilePlayErr_FilePlayUnderrun);

*inOutDataSize = 0;

*inOutData = 0;

} else {

*inOutDataSize = afm->mChunkSize;

*inOutData =

afm->mReadFromFirstBuffer ? afm->mFileBuffer : (afm->

mFileBuffer +

afm->mChunkSize);

}

afm->mLockUnsuccessful = !sReaderThread->TryNextRead (sReaderThread, afm);

afm->mReadFromFirstBuffer = !afm->mReadFromFirstBuffer;

return noErr;

}

static void

AudioFileManager_AfterRender (AudioFileManager * afm)

SDLOSXCAGuard *guard = sReaderThread->GetGuard (sReaderThread);

if (guard->Try (guard, &didLock)) {

afm->mParent->DoNotification (afm->mParent,

kAudioFilePlay_FileIsFinished);

}

}

if (afm->mLockUnsuccessful)

afm->mLockUnsuccessful =

!sReaderThread->TryNextRead (sReaderThread, afm);

}

static void

AudioFileManager_SetPosition (AudioFileManager * afm, SInt64 pos)

{

if (pos < 0 || pos >= afm->mFileLength) {

SDL_SetError

("AudioFileManager::SetPosition - position invalid: %d filelen=%d\n",

(unsigned int) pos, (unsigned int) afm->mFileLength);

pos = 0;

}

afm->mReadFilePosition = pos;

}

static void

AudioFileManager_SetEndOfFile (AudioFileManager * afm, SInt64 pos)

{

if (pos <= 0 || pos > afm->mFileLength) {

SDL_SetError

("AudioFileManager::SetEndOfFile - position beyond actual eof\n");

pos = afm->mFileLength;

}

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;

}

ioData->mDataByteSize = afm->mBufferSize - afm->mBufferOffset;

ioData->mData = (char *) afm->mTmpBuffer + afm->mBufferOffset;

afm->mByteCounter += ioData->mDataByteSize;

afm->AfterRender (afm);

return result;

}

void

delete_AudioFileManager (AudioFileManager * afm)

{

if (afm != NULL) {

if (afm->mFileBuffer) {

}

}

}

AudioFileManager *

new_AudioFileManager (AudioFilePlayer * inParent,

SInt16 inForkRefNum,

SInt64 inFileLength, UInt32 inChunkSize)

{

AudioFileManager *afm;

if (sReaderThread == NULL) {

sReaderThread = new_FileReaderThread ();

if (sReaderThread == NULL)

return NULL;

}