/*

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

}

//ΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡ

//  DetectAudioCDVolumes

//ΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡ

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;

}

//ΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡ

//  ReadTOCData

//ΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡ

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;

}

//ΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡ

//  ListTrackFiles

//ΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡ

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;

}

//ΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡ

//  LoadFile

//ΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡ

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;

}

//ΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡ

//  ReleaseFile

//ΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡ

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;

}

//ΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡ

//  PlayFile

//ΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡ

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;

}

//ΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡ

//  PauseFile

//ΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡ

int PauseFile ()

{

    OSStatus result = -1;

    if (CheckInit () < 0)

        goto bail;

    //try {

        // stop processing the audio unit