/*
    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" */
/* vi: set ts=4 sw=4 expandtab: */