/*

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

*/

#include "SDL_config.h"

#include "CDPlayer.h"

#include "AudioFilePlayer.h"

#include "SDLOSXCAGuard.h"

/* we're exporting these functions into C land for SDL_syscdrom.c */

/*extern "C" {*/

/*///////////////////////////////////////////////////////////////////////////

Constants

//////////////////////////////////////////////////////////////////////////*/

#define kAudioCDFilesystemID (UInt16)(('J' << 8) | 'H') /* 'JH'; this avoids compiler warning */

/* XML PList keys */

#define kRawTOCDataString "Format 0x02 TOC Data"

#define kSessionsString "Sessions"

#define kSessionTypeString "Session Type"

#define kTrackArrayString "Track Array"

#define kFirstTrackInSessionString "First Track"

#define kLastTrackInSessionString "Last Track"

#define kLeadoutBlockString "Leadout Block"

#define kDataKeyString "Data"

#define kPointKeyString "Point"

#define kSessionNumberKeyString "Session Number"

#define kStartBlockKeyString "Start Block"

/*///////////////////////////////////////////////////////////////////////////

Globals

//////////////////////////////////////////////////////////////////////////*/

#pragma mark -- Globals --

static int playBackWasInit = 0;

static AudioUnit theUnit;

static AudioFilePlayer* thePlayer = NULL;

static CDPlayerCompletionProc completionProc = NULL;

static SDL_mutex *apiMutex = NULL;

static SDL_sem *callbackSem;

static SDL_CD* theCDROM;

/*///////////////////////////////////////////////////////////////////////////

Prototypes

//////////////////////////////////////////////////////////////////////////*/

#pragma mark -- Prototypes --

static OSStatus CheckInit ();

static void FilePlayNotificationHandler (void* inRefCon, OSStatus inStatus);

static int RunCallBackThread (void* inRefCon);

#pragma mark -- Public Functions --

void Lock ()

{

if (!apiMutex) {

apiMutex = SDL_CreateMutex();

}

SDL_mutexP(apiMutex);

}

void Unlock ()

{

SDL_mutexV(apiMutex);

}

int DetectAudioCDVolumes(FSVolumeRefNum *volumes, int numVolumes)

{

int volumeIndex;

int cdVolumeCount = 0;

OSStatus result = noErr;

for (volumeIndex = 1; result == noErr || result != nsvErr; volumeIndex++)

{

FSVolumeRefNum actualVolume;

FSVolumeInfo volumeInfo;

memset (&volumeInfo, 0, sizeof(volumeInfo));

result = FSGetVolumeInfo (kFSInvalidVolumeRefNum,

volumeIndex,

&actualVolume,

kFSVolInfoFSInfo,

&volumeInfo,

NULL,

NULL);

if (result == noErr)

{

if (volumeInfo.filesystemID == kAudioCDFilesystemID) /* It's an audio CD */

{

if (volumes != NULL && cdVolumeCount < numVolumes)

volumes[cdVolumeCount] = actualVolume;

cdVolumeCount++;

}

}

else

{

/* I'm commenting this out because it seems to be harmless */

/*SDL_SetError ("DetectAudioCDVolumes: FSGetVolumeInfo returned %d", result);*/

}

}

return cdVolumeCount;

}

int ReadTOCData (FSVolumeRefNum theVolume, SDL_CD *theCD)

{

HFSUniStr255 dataForkName;

OSStatus theErr;

SInt16 forkRefNum;

SInt64 forkSize;

Ptr forkData = 0;

ByteCount actualRead;

CFDataRef dataRef = 0;

CFPropertyListRef propertyListRef = 0;

FSRefParam fsRefPB;

FSRef tocPlistFSRef;

const char* error = "Unspecified Error";

/* get stuff from .TOC.plist */

fsRefPB.ioCompletion = NULL;

fsRefPB.ioNamePtr = "\p.TOC.plist";

fsRefPB.ioVRefNum = theVolume;

fsRefPB.ioDirID = 0;

fsRefPB.newRef = &tocPlistFSRef;

theErr = PBMakeFSRefSync (&fsRefPB);

if(theErr != noErr) {

error = "PBMakeFSRefSync";

goto bail;

}

/* Load and parse the TOC XML data */

theErr = FSGetDataForkName (&dataForkName);

if (theErr != noErr) {

error = "FSGetDataForkName";

goto bail;

}

theErr = FSOpenFork (&tocPlistFSRef, dataForkName.length, dataForkName.unicode, fsRdPerm, &forkRefNum);

if (theErr != noErr) {

error = "FSOpenFork";

goto bail;

}

theErr = FSGetForkSize (forkRefNum, &forkSize);

if (theErr != noErr) {

error = "FSGetForkSize";

goto bail;

}

/* Allocate some memory for the XML data */

forkData = NewPtr (forkSize);

if(forkData == NULL) {

error = "NewPtr";

goto bail;

}

theErr = FSReadFork (forkRefNum, fsFromStart, 0 /* offset location */, forkSize, forkData, &actualRead);

if(theErr != noErr) {

error = "FSReadFork";

goto bail;

}

dataRef = CFDataCreate (kCFAllocatorDefault, (UInt8 *)forkData, forkSize);

if(dataRef == 0) {

error = "CFDataCreate";

goto bail;

}

propertyListRef = CFPropertyListCreateFromXMLData (kCFAllocatorDefault,

dataRef,

kCFPropertyListImmutable,

NULL);

if (propertyListRef == NULL) {

error = "CFPropertyListCreateFromXMLData";

goto bail;

}

/* Now we got the Property List in memory. Parse it. */

/* First, make sure the root item is a CFDictionary. If not, release and bail. */

if(CFGetTypeID(propertyListRef)== CFDictionaryGetTypeID())

{

CFDictionaryRef dictRef = (CFDictionaryRef)propertyListRef;

CFDataRef theRawTOCDataRef;

CFArrayRef theSessionArrayRef;

CFIndex numSessions;

CFIndex index;

/* This is how we get the Raw TOC Data */

theRawTOCDataRef = (CFDataRef)CFDictionaryGetValue (dictRef, CFSTR(kRawTOCDataString));

/* Get the session array info. */

theSessionArrayRef = (CFArrayRef)CFDictionaryGetValue (dictRef, CFSTR(kSessionsString));

/* Find out how many sessions there are. */

numSessions = CFArrayGetCount (theSessionArrayRef);

/* Initialize the total number of tracks to 0 */

theCD->numtracks = 0;

/* Iterate over all sessions, collecting the track data */

for(index = 0; index < numSessions; index++)

{

CFDictionaryRef theSessionDict;

CFNumberRef leadoutBlock;

CFArrayRef trackArray;

CFIndex numTracks;

CFIndex trackIndex;

UInt32 value = 0;

theSessionDict = (CFDictionaryRef) CFArrayGetValueAtIndex (theSessionArrayRef, index);

leadoutBlock = (CFNumberRef) CFDictionaryGetValue (theSessionDict, CFSTR(kLeadoutBlockString));

trackArray = (CFArrayRef)CFDictionaryGetValue (theSessionDict, CFSTR(kTrackArrayString));

numTracks = CFArrayGetCount (trackArray);

for(trackIndex = 0; trackIndex < numTracks; trackIndex++) {

CFDictionaryRef theTrackDict;

CFNumberRef trackNumber;

CFNumberRef sessionNumber;

CFNumberRef startBlock;

CFBooleanRef isDataTrack;

UInt32 value;

theTrackDict = (CFDictionaryRef) CFArrayGetValueAtIndex (trackArray, trackIndex);

trackNumber = (CFNumberRef) CFDictionaryGetValue (theTrackDict, CFSTR(kPointKeyString));

sessionNumber = (CFNumberRef) CFDictionaryGetValue (theTrackDict, CFSTR(kSessionNumberKeyString));

startBlock = (CFNumberRef) CFDictionaryGetValue (theTrackDict, CFSTR(kStartBlockKeyString));

isDataTrack = (CFBooleanRef) CFDictionaryGetValue (theTrackDict, CFSTR(kDataKeyString));

/* Fill in the SDL_CD struct */

int idx = theCD->numtracks++;

CFNumberGetValue (trackNumber, kCFNumberSInt32Type, &value);

theCD->track[idx].id = value;

CFNumberGetValue (startBlock, kCFNumberSInt32Type, &value);

theCD->track[idx].offset = value;

theCD->track[idx].type = (isDataTrack == kCFBooleanTrue) ? SDL_DATA_TRACK : SDL_AUDIO_TRACK;

/* Since the track lengths are not stored in .TOC.plist we compute them. */

if (trackIndex > 0) {

theCD->track[idx-1].length = theCD->track[idx].offset - theCD->track[idx-1].offset;

}

}

/* Compute the length of the last track */

CFNumberGetValue (leadoutBlock, kCFNumberSInt32Type, &value);

theCD->track[theCD->numtracks-1].length =

value - theCD->track[theCD->numtracks-1].offset;

/* Set offset to leadout track */

theCD->track[theCD->numtracks].offset = value;

}

}

theErr = 0;

goto cleanup;

bail:

SDL_SetError ("ReadTOCData: %s returned %d", error, theErr);

theErr = -1;

cleanup:

if (propertyListRef != NULL)

CFRelease(propertyListRef);

if (dataRef != NULL)

CFRelease(dataRef);

if (forkData != NULL)

DisposePtr(forkData);

FSCloseFork (forkRefNum);

return theErr;

}

int ListTrackFiles (FSVolumeRefNum theVolume, FSRef *trackFiles, int numTracks)

{

OSStatus result = -1;

FSIterator iterator;

ItemCount actualObjects;

FSRef rootDirectory;

FSRef ref;

HFSUniStr255 nameStr;

result = FSGetVolumeInfo (theVolume,

0,

NULL,

kFSVolInfoFSInfo,

NULL,

NULL,

&rootDirectory);

if (result != noErr) {

SDL_SetError ("ListTrackFiles: FSGetVolumeInfo returned %d", result);

return result;

}

result = FSOpenIterator (&rootDirectory, kFSIterateFlat, &iterator);

if (result == noErr) {

do

{

result = FSGetCatalogInfoBulk (iterator, 1, &actualObjects,

NULL, kFSCatInfoNone, NULL, &ref, NULL, &nameStr);

if (result == noErr) {

CFStringRef name;

name = CFStringCreateWithCharacters (NULL, nameStr.unicode, nameStr.length);

/* Look for .aiff extension */

if (CFStringHasSuffix (name, CFSTR(".aiff")) ||

CFStringHasSuffix (name, CFSTR(".cdda"))) {

/* Extract the track id from the filename */

int trackID = 0, i = 0;

while (i < nameStr.length && !isdigit(nameStr.unicode[i])) {

++i;

}

while (i < nameStr.length && isdigit(nameStr.unicode[i])) {

trackID = 10 * trackID +(nameStr.unicode[i] - '0');

++i;

}

#if DEBUG_CDROM

printf("Found AIFF for track %d: '%s'\n", trackID,

CFStringGetCStringPtr (name, CFStringGetSystemEncoding()));

#endif

/* Track ID's start at 1, but we want to start at 0 */

trackID--;

assert(0 <= trackID && trackID <= SDL_MAX_TRACKS);

if (trackID < numTracks)

memcpy (&trackFiles[trackID], &ref, sizeof(FSRef));

}

CFRelease (name);

}

} while(noErr == result);

FSCloseIterator (iterator);

}

return 0;

}

int LoadFile (const FSRef *ref, int startFrame, int stopFrame)

{

int error = -1;

if (CheckInit () < 0)

goto bail;

/* release any currently playing file */

if (ReleaseFile () < 0)

goto bail;

#if DEBUG_CDROM

printf ("LoadFile: %d %d\n", startFrame, stopFrame);

#endif

/*try {*/

/* create a new player, and attach to the audio unit */

thePlayer = new_AudioFilePlayer(ref);

if (thePlayer == NULL) {

SDL_SetError ("LoadFile: Could not create player");

return -3; /*throw (-3);*/

}

if (!thePlayer->SetDestination(thePlayer, &theUnit))

goto bail;

if (startFrame >= 0)

thePlayer->SetStartFrame (thePlayer, startFrame);

if (stopFrame >= 0 && stopFrame > startFrame)

thePlayer->SetStopFrame (thePlayer, stopFrame);

/* we set the notifier later */

/*thePlayer->SetNotifier(thePlayer, FilePlayNotificationHandler, NULL);*/

if (!thePlayer->Connect(thePlayer))

goto bail;

#if DEBUG_CDROM

thePlayer->Print(thePlayer);

fflush (stdout);

#endif

/*}

catch (...)

{

goto bail;

}*/

error = 0;

bail:

return error;

}

int ReleaseFile ()

{

int error = -1;

/* (Don't see any way that the original C++ code could throw here.) --ryan. */

/*try {*/

if (thePlayer != NULL) {

thePlayer->Disconnect(thePlayer);

delete_AudioFilePlayer(thePlayer);

thePlayer = NULL;

}

/*}

catch (...)

{

goto bail;

}*/

error = 0;

/* bail: */

return error;

}

int PlayFile ()

{

OSStatus result = -1;

if (CheckInit () < 0)

goto bail;

/*try {*/

// start processing of the audio unit

result = AudioOutputUnitStart (theUnit);

if (result) goto bail; //THROW_RESULT("PlayFile: AudioOutputUnitStart")

/*}

catch (...)

{

goto bail;

}*/

result = 0;

bail:

return result;

}

int PauseFile ()

{

OSStatus result = -1;

if (CheckInit () < 0)

goto bail;

/*try {*/

/* stop processing the audio unit */

result = AudioOutputUnitStop (theUnit);

if (result) goto bail; /*THROW_RESULT("PauseFile: AudioOutputUnitStop")*/

/*}

catch (...)

{

goto bail;

}*/

result = 0;

bail:

return result;

}

void SetCompletionProc (CDPlayerCompletionProc proc, SDL_CD *cdrom)

{

assert(thePlayer != NULL);

theCDROM = cdrom;

completionProc = proc;

thePlayer->SetNotifier (thePlayer, FilePlayNotificationHandler, cdrom);

}

int GetCurrentFrame ()

{

int frame;

if (thePlayer == NULL)

frame = 0;

else

frame = thePlayer->GetCurrentFrame (thePlayer);

return frame;

}

#pragma mark -- Private Functions --

static OSStatus CheckInit ()

{

if (playBackWasInit)

return 0;

OSStatus result = noErr;

/* Create the callback semaphore */

callbackSem = SDL_CreateSemaphore(0);

/* Start callback thread */

SDL_CreateThread(RunCallBackThread, NULL);

{ /*try {*/

ComponentDescription desc;

desc.componentType = kAudioUnitComponentType;

desc.componentSubType = kAudioUnitSubType_Output;

desc.componentManufacturer = kAudioUnitID_DefaultOutput;

desc.componentFlags = 0;

desc.componentFlagsMask = 0;

Component comp = FindNextComponent (NULL, &desc);

if (comp == NULL) {

SDL_SetError ("CheckInit: FindNextComponent returned NULL");

if (result) return -1; //throw(internalComponentErr);

}

result = OpenAComponent (comp, &theUnit);

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

if (result) return -1; //THROW_RESULT("CheckInit: AudioUnitInitialize")

playBackWasInit = true;

}

/*catch (...)

{

return -1;

}*/

return 0;

}

static void FilePlayNotificationHandler(void * inRefCon, OSStatus inStatus)

{

if (inStatus == kAudioFilePlay_FileIsFinished) {

/* notify non-CA thread to perform the callback */

SDL_SemPost(callbackSem);

} else if (inStatus == kAudioFilePlayErr_FilePlayUnderrun) {

SDL_SetError ("CDPlayer Notification: buffer underrun");

} else if (inStatus == kAudioFilePlay_PlayerIsUninitialized) {

SDL_SetError ("CDPlayer Notification: player is uninitialized");

} else {

SDL_SetError ("CDPlayer Notification: unknown error %ld", inStatus);

}

}

static int RunCallBackThread (void *param)

{

for (;;) {

SDL_SemWait(callbackSem);

if (completionProc && theCDROM) {

#if DEBUG_CDROM

printf ("callback!\n");

#endif

(*completionProc)(theCDROM);

} else {

#if DEBUG_CDROM

printf ("callback?\n");

#endif

}

}

#if DEBUG_CDROM

printf ("thread dying now...\n");

#endif

return 0;

}

/*}; // extern "C" */