/*

SDL - Simple DirectMedia Layer

Copyright (C) 1997-2009 Sam Lantinga

This library is free software; you can redistribute it and/or

modify it under the terms of the GNU Lesser General Public

License as published by the Free Software Foundation; either

version 2.1 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

Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public

License along with this library; if not, write to the Free Software

Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA

Sam Lantinga

slouken@libsdl.org

*/

#include "SDL_config.h"

#ifdef SDL_CDROM_MACOS

/* MacOS functions for system-level CD-ROM audio control */

#include <Devices.h>

#include <Files.h>

#include <LowMem.h> /* Use entry table macros, not functions in InterfaceLib */

#include "SDL_cdrom.h"

#include "../SDL_syscdrom.h"

#include "SDL_syscdrom_c.h"

/* Added by Matt Slot */

#if !defined(LMGetUnitTableEntryCount)

#define LMGetUnitTableEntryCount() *(short *)0x01D2

#endif

/* The maximum number of CD-ROM drives we'll detect */

#define MAX_DRIVES 26

/* A list of available CD-ROM drives */

static long SDL_cdversion = 0;

static struct {

short dRefNum;

short driveNum;

long frames;

char name[256];

Boolean hasAudio;

} SDL_cdlist[MAX_DRIVES];

static StringPtr gDriverName = "\p.AppleCD";

/* The system-dependent CD control functions */

static const char *SDL_SYS_CDName(int drive);

static int SDL_SYS_CDOpen(int drive);

static int SDL_SYS_CDGetTOC(SDL_CD *cdrom);

static CDstatus SDL_SYS_CDStatus(SDL_CD *cdrom, int *position);

static int SDL_SYS_CDPlay(SDL_CD *cdrom, int start, int length);

static int SDL_SYS_CDPause(SDL_CD *cdrom);

static int SDL_SYS_CDResume(SDL_CD *cdrom);

static int SDL_SYS_CDStop(SDL_CD *cdrom);

static int SDL_SYS_CDEject(SDL_CD *cdrom);

static void SDL_SYS_CDClose(SDL_CD *cdrom);

static short SDL_SYS_ShortToBCD(short value)

{

return((value % 10) + (value / 10) * 0x10); /* Convert value to BCD */

}

static short SDL_SYS_BCDToShort(short value)

{

return((value % 0x10) + (value / 0x10) * 10); /* Convert value from BCD */

}

int SDL_SYS_CDInit(void)

{

SInt16 dRefNum = 0;

SInt16 first, last;

SDL_numcds = 0;

/* Check that the software is available */

if (Gestalt(kGestaltAudioCDSelector, &SDL_cdversion) ||

!SDL_cdversion) return(0);

/* Fill in our driver capabilities */

SDL_CDcaps.Name = SDL_SYS_CDName;

SDL_CDcaps.Open = SDL_SYS_CDOpen;

SDL_CDcaps.GetTOC = SDL_SYS_CDGetTOC;

SDL_CDcaps.Status = SDL_SYS_CDStatus;

SDL_CDcaps.Play = SDL_SYS_CDPlay;

SDL_CDcaps.Pause = SDL_SYS_CDPause;

SDL_CDcaps.Resume = SDL_SYS_CDResume;

SDL_CDcaps.Stop = SDL_SYS_CDStop;

SDL_CDcaps.Eject = SDL_SYS_CDEject;

SDL_CDcaps.Close = SDL_SYS_CDClose;

/* Walk the list, count each AudioCD driver, and save the refnums */

first = -1;

last = 0 - LMGetUnitTableEntryCount();

for(dRefNum = first; dRefNum >= last; dRefNum--) {

Str255 driverName;

StringPtr namePtr;

DCtlHandle deviceEntry;

deviceEntry = GetDCtlEntry(dRefNum);

if (! deviceEntry) continue;

/* Is this an .AppleCD ? */

namePtr = (*deviceEntry)->dCtlFlags & (1L << dRAMBased) ?

((StringPtr) ((DCtlPtr) deviceEntry)->dCtlDriver + 18) :

((StringPtr) (*deviceEntry)->dCtlDriver + 18);

BlockMoveData(namePtr, driverName, namePtr[0]+1);

if (driverName[0] > gDriverName[0]) driverName[0] = gDriverName[0];

if (! EqualString(driverName, gDriverName, false, false)) continue;

/* Record the basic info for each drive */

SDL_cdlist[SDL_numcds].dRefNum = dRefNum;

BlockMoveData(namePtr + 1, SDL_cdlist[SDL_numcds].name, namePtr[0]);

SDL_cdlist[SDL_numcds].name[namePtr[0]] = 0;

SDL_cdlist[SDL_numcds].hasAudio = false;

SDL_numcds++;

}

return(0);

}

static const char *SDL_SYS_CDName(int drive)

{

return(SDL_cdlist[drive].name);

}

static int get_drivenum(int drive)

{

QHdr *driveQ = GetDrvQHdr();

DrvQEl *driveElem;

/* Update the drive number */

SDL_cdlist[drive].driveNum = 0;

if ( driveQ->qTail ) {

driveQ->qTail->qLink = 0;

}

for ( driveElem=(DrvQEl *)driveQ->qHead; driveElem;

driveElem = (DrvQEl *)driveElem->qLink ) {

if ( driveElem->dQRefNum == SDL_cdlist[drive].dRefNum ) {

SDL_cdlist[drive].driveNum = driveElem->dQDrive;

break;

}

}

return(SDL_cdlist[drive].driveNum);

}

static int SDL_SYS_CDOpen(int drive)

{

return(drive);

}

static int SDL_SYS_CDGetTOC(SDL_CD *cdrom)

{

CDCntrlParam cdpb;

CDTrackData tracks[SDL_MAX_TRACKS];

long i, leadout;

/* Get the number of tracks on the CD by examining the TOC */

SDL_memset(&cdpb, 0, sizeof(cdpb));

cdpb.ioVRefNum = SDL_cdlist[cdrom->id].driveNum;

cdpb.ioCRefNum = SDL_cdlist[cdrom->id].dRefNum;

cdpb.csCode = kReadTOC;

cdpb.csParam.words[0] = kGetTrackRange;

if ( PBControlSync((ParmBlkPtr)&cdpb) != noErr ) {

SDL_SetError("PBControlSync() failed");

return(-1);

}

cdrom->numtracks =

SDL_SYS_BCDToShort(cdpb.csParam.bytes[1]) -

SDL_SYS_BCDToShort(cdpb.csParam.bytes[0]) + 1;

if ( cdrom->numtracks > SDL_MAX_TRACKS )

cdrom->numtracks = SDL_MAX_TRACKS;

cdrom->status = CD_STOPPED;

cdrom->cur_track = 0; /* Apparently these are set elsewhere */

cdrom->cur_frame = 0; /* Apparently these are set elsewhere */

/* Get the lead out area of the CD by examining the TOC */

SDL_memset(&cdpb, 0, sizeof(cdpb));

cdpb.ioVRefNum = SDL_cdlist[cdrom->id].driveNum;

cdpb.ioCRefNum = SDL_cdlist[cdrom->id].dRefNum;

cdpb.csCode = kReadTOC;

cdpb.csParam.words[0] = kGetLeadOutArea;

if ( PBControlSync((ParmBlkPtr)&cdpb) != noErr ) {

SDL_SetError("PBControlSync() failed");

return(-1);

}

leadout = MSF_TO_FRAMES(

SDL_SYS_BCDToShort(cdpb.csParam.bytes[0]),

SDL_SYS_BCDToShort(cdpb.csParam.bytes[1]),

SDL_SYS_BCDToShort(cdpb.csParam.bytes[2]));

/* Get an array of track locations by examining the TOC */

SDL_memset(tracks, 0, sizeof(tracks));

SDL_memset(&cdpb, 0, sizeof(cdpb));

cdpb.ioVRefNum = SDL_cdlist[cdrom->id].driveNum;

cdpb.ioCRefNum = SDL_cdlist[cdrom->id].dRefNum;

cdpb.csCode = kReadTOC;

cdpb.csParam.words[0] = kGetTrackEntries; /* Type of Query */

* ((long *) (cdpb.csParam.words+1)) = (long) tracks;

cdpb.csParam.words[3] = cdrom->numtracks * sizeof(tracks[0]);

* ((char *) (cdpb.csParam.words+4)) = 1; /* First track */

if ( PBControlSync((ParmBlkPtr)&cdpb) != noErr ) {

SDL_SetError("PBControlSync() failed");

return(-1);

}

/* Read all the track TOC entries */

SDL_cdlist[cdrom->id].hasAudio = false;

for ( i=0; i<cdrom->numtracks; ++i )

{

cdrom->track[i].id = i+1;

if (tracks[i].entry.control & kDataTrackMask)

cdrom->track[i].type = SDL_DATA_TRACK;

else

{

cdrom->track[i].type = SDL_AUDIO_TRACK;

SDL_cdlist[SDL_numcds].hasAudio = true;

}

cdrom->track[i].offset = MSF_TO_FRAMES(

SDL_SYS_BCDToShort(tracks[i].entry.min),

SDL_SYS_BCDToShort(tracks[i].entry.min),

SDL_SYS_BCDToShort(tracks[i].entry.frame));

cdrom->track[i].length = MSF_TO_FRAMES(

SDL_SYS_BCDToShort(tracks[i+1].entry.min),

SDL_SYS_BCDToShort(tracks[i+1].entry.min),

SDL_SYS_BCDToShort(tracks[i+1].entry.frame)) -

cdrom->track[i].offset;

}

/* Apparently SDL wants a fake last entry */

cdrom->track[i].offset = leadout;

cdrom->track[i].length = 0;

return(0);

}

/* Get CD-ROM status */

static CDstatus SDL_SYS_CDStatus(SDL_CD *cdrom, int *position)

{

CDCntrlParam cdpb;

CDstatus status = CD_ERROR;

Boolean spinning = false;

if (position) *position = 0;

/* Get the number of tracks on the CD by examining the TOC */

if ( ! get_drivenum(cdrom->id) ) {

return(CD_TRAYEMPTY);

}

SDL_memset(&cdpb, 0, sizeof(cdpb));

cdpb.ioVRefNum = SDL_cdlist[cdrom->id].driveNum;

cdpb.ioCRefNum = SDL_cdlist[cdrom->id].dRefNum;

cdpb.csCode = kReadTOC;

cdpb.csParam.words[0] = kGetTrackRange;

if ( PBControlSync((ParmBlkPtr)&cdpb) != noErr ) {

SDL_SetError("PBControlSync() failed");

return(CD_ERROR);

}

cdrom->numtracks =

SDL_SYS_BCDToShort(cdpb.csParam.bytes[1]) -

SDL_SYS_BCDToShort(cdpb.csParam.bytes[0]) + 1;

if ( cdrom->numtracks > SDL_MAX_TRACKS )

cdrom->numtracks = SDL_MAX_TRACKS;

cdrom->cur_track = 0; /* Apparently these are set elsewhere */

cdrom->cur_frame = 0; /* Apparently these are set elsewhere */

if (1 || SDL_cdlist[cdrom->id].hasAudio) {

/* Get the current playback status */

SDL_memset(&cdpb, 0, sizeof(cdpb));

cdpb.ioVRefNum = SDL_cdlist[cdrom->id].driveNum;

cdpb.ioCRefNum = SDL_cdlist[cdrom->id].dRefNum;

cdpb.csCode = kAudioStatus;

if ( PBControlSync((ParmBlkPtr)&cdpb) != noErr ) {

SDL_SetError("PBControlSync() failed");

return(-1);

}

switch(cdpb.csParam.cd.status) {

case kStatusPlaying:

status = CD_PLAYING;

spinning = true;

break;

case kStatusPaused:

status = CD_PAUSED;

spinning = true;

break;

case kStatusMuted:

status = CD_PLAYING; /* What should I do here? */

spinning = true;

break;

case kStatusDone:

status = CD_STOPPED;

spinning = true;

break;

case kStatusStopped:

status = CD_STOPPED;

spinning = false;

break;

case kStatusError:

default:

status = CD_ERROR;

spinning = false;

break;

}

if (spinning && position) *position = MSF_TO_FRAMES(

SDL_SYS_BCDToShort(cdpb.csParam.cd.minute),

SDL_SYS_BCDToShort(cdpb.csParam.cd.second),

SDL_SYS_BCDToShort(cdpb.csParam.cd.frame));

}

else

status = CD_ERROR; /* What should I do here? */

return(status);

}

/* Start play */

static int SDL_SYS_CDPlay(SDL_CD *cdrom, int start, int length)

{

CDCntrlParam cdpb;

/* Pause the current audio playback to avoid audible artifacts */

if ( SDL_SYS_CDPause(cdrom) < 0 ) {

return(-1);

}

/* Specify the AudioCD playback mode */

SDL_memset(&cdpb, 0, sizeof(cdpb));

cdpb.ioVRefNum = SDL_cdlist[cdrom->id].driveNum;

cdpb.ioCRefNum = SDL_cdlist[cdrom->id].dRefNum;

cdpb.csCode = kSetPlayMode;

cdpb.csParam.bytes[0] = false; /* Repeat? */

cdpb.csParam.bytes[1] = kPlayModeSequential; /* Play mode */

/* ¥¥¥ÊTreat as soft error, NEC Drive doesnt support this call ¥¥¥ */

PBControlSync((ParmBlkPtr) &cdpb);

#if 1

/* Specify the end of audio playback */

SDL_memset(&cdpb, 0, sizeof(cdpb));

cdpb.ioVRefNum = SDL_cdlist[cdrom->id].driveNum;

cdpb.ioCRefNum = SDL_cdlist[cdrom->id].dRefNum;

cdpb.csCode = kAudioStop;

cdpb.csParam.words[0] = kBlockPosition; /* Position Mode */

*(long *) (cdpb.csParam.words + 1) = start+length-1; /* Search Address */

if ( PBControlSync((ParmBlkPtr)&cdpb) != noErr ) {

SDL_SetError("PBControlSync() failed");

return(-1);

}

/* Specify the start of audio playback, and start it */

SDL_memset(&cdpb, 0, sizeof(cdpb));

cdpb.ioVRefNum = SDL_cdlist[cdrom->id].driveNum;

cdpb.ioCRefNum = SDL_cdlist[cdrom->id].dRefNum;

cdpb.csCode = kAudioPlay;

cdpb.csParam.words[0] = kBlockPosition; /* Position Mode */

*(long *) (cdpb.csParam.words + 1) = start+1; /* Search Address */

cdpb.csParam.words[3] = false; /* Stop address? */

cdpb.csParam.words[4] = kStereoPlayMode; /* Audio Play Mode */

if ( PBControlSync((ParmBlkPtr)&cdpb) != noErr ) {

SDL_SetError("PBControlSync() failed");

return(-1);

}

#else

/* Specify the end of audio playback */

FRAMES_TO_MSF(start+length, &m, &s, &f);

SDL_memset(&cdpb, 0, sizeof(cdpb));

cdpb.ioVRefNum = SDL_cdlist[cdrom->id].driveNum;

cdpb.ioCRefNum = SDL_cdlist[cdrom->id].dRefNum;

cdpb.csCode = kAudioStop;

cdpb.csParam.words[0] = kTrackPosition; /* Position Mode */

cdpb.csParam.words[1] = 0; /* Search Address (hiword)*/

cdpb.csParam.words[2] = /* Search Address (loword)*/

SDL_SYS_ShortToBCD(cdrom->numtracks);

if ( PBControlSync((ParmBlkPtr)&cdpb) != noErr ) {

SDL_SetError("PBControlSync() failed");

return(-1);

}

/* Specify the start of audio playback, and start it */

FRAMES_TO_MSF(start, &m, &s, &f);

SDL_memset(&cdpb, 0, sizeof(cdpb));

cdpb.ioVRefNum = SDL_cdlist[cdrom->id].driveNum;

cdpb.ioCRefNum = SDL_cdlist[cdrom->id].dRefNum;

cdpb.csCode = kAudioPlay;

cdpb.csParam.words[0] = kTrackPosition; /* Position Mode */

cdpb.csParam.words[1] = 0; /* Search Address (hiword)*/

cdpb.csParam.words[2] = SDL_SYS_ShortToBCD(1); /* Search Address (loword)*/

cdpb.csParam.words[3] = false; /* Stop address? */

cdpb.csParam.words[4] = kStereoPlayMode; /* Audio Play Mode */

if ( PBControlSync((ParmBlkPtr)&cdpb) != noErr ) {

SDL_SetError("PBControlSync() failed");

return(-1);

}

#endif

return(0);

}

/* Pause play */

static int SDL_SYS_CDPause(SDL_CD *cdrom)

{

CDCntrlParam cdpb;

SDL_memset(&cdpb, 0, sizeof(cdpb));

cdpb.ioVRefNum = SDL_cdlist[cdrom->id].driveNum;

cdpb.ioCRefNum = SDL_cdlist[cdrom->id].dRefNum;

cdpb.csCode = kAudioPause;

cdpb.csParam.words[0] = 0; /* Pause/Continue Flag (hiword) */

cdpb.csParam.words[1] = 1; /* Pause/Continue Flag (loword) */

if ( PBControlSync((ParmBlkPtr)&cdpb) != noErr ) {

SDL_SetError("PBControlSync() failed");

return(-1);

}

return(0);

}

/* Resume play */

static int SDL_SYS_CDResume(SDL_CD *cdrom)

{

CDCntrlParam cdpb;

SDL_memset(&cdpb, 0, sizeof(cdpb));

cdpb.ioVRefNum = SDL_cdlist[cdrom->id].driveNum;

cdpb.ioCRefNum = SDL_cdlist[cdrom->id].dRefNum;

cdpb.csCode = kAudioPause;

cdpb.csParam.words[0] = 0; /* Pause/Continue Flag (hiword) */

cdpb.csParam.words[1] = 0; /* Pause/Continue Flag (loword) */

if ( PBControlSync((ParmBlkPtr)&cdpb) != noErr ) {

SDL_SetError("PBControlSync() failed");

return(-1);

}

return(0);

}

/* Stop play */

static int SDL_SYS_CDStop(SDL_CD *cdrom)

{

CDCntrlParam cdpb;

SDL_memset(&cdpb, 0, sizeof(cdpb));

cdpb.ioVRefNum = SDL_cdlist[cdrom->id].driveNum;

cdpb.ioCRefNum = SDL_cdlist[cdrom->id].dRefNum;

cdpb.csCode = kAudioStop;

cdpb.csParam.words[0] = 0; /* Position Mode */

cdpb.csParam.words[1] = 0; /* Search Address (hiword) */

cdpb.csParam.words[2] = 0; /* Search Address (loword) */

if ( PBControlSync((ParmBlkPtr)&cdpb) != noErr ) {

SDL_SetError("PBControlSync() failed");

return(-1);

}

return(0);

}

/* Eject the CD-ROM */

static int SDL_SYS_CDEject(SDL_CD *cdrom)

{

Boolean disk = false;

QHdr *driveQ = GetDrvQHdr();

DrvQEl *driveElem;

HParamBlockRec hpb;

ParamBlockRec cpb;

for ( driveElem = (DrvQEl *) driveQ->qHead; driveElem; driveElem =

(driveElem) ? ((DrvQEl *) driveElem->qLink) :

((DrvQEl *) driveQ->qHead) ) {

if ( driveQ->qTail ) {

driveQ->qTail->qLink = 0;

}

if ( driveElem->dQRefNum != SDL_cdlist[cdrom->id].dRefNum ) {

continue;

}

/* Does drive contain mounted volume? If not, skip */

SDL_memset(&hpb, 0, sizeof(hpb));

hpb.volumeParam.ioVRefNum = driveElem->dQDrive;

if ( PBHGetVInfoSync(&hpb) != noErr ) {

continue;

}

if ( (UnmountVol(0, driveElem->dQDrive) == noErr) &&

(Eject(0, driveElem->dQDrive) == noErr) ) {

driveElem = 0; /* Clear pointer to reset our loop */

disk = true;

}

}

/* If no disk is present, just eject the tray */

if (! disk) {

SDL_memset(&cpb, 0, sizeof(cpb));

cpb.cntrlParam.ioVRefNum = 0; /* No Drive */

cpb.cntrlParam.ioCRefNum = SDL_cdlist[cdrom->id].dRefNum;

cpb.cntrlParam.csCode = kEjectTheDisc;

if ( PBControlSync((ParmBlkPtr)&cpb) != noErr ) {

SDL_SetError("PBControlSync() failed");

return(-1);

}

}

return(0);

}

/* Close the CD-ROM handle */

static void SDL_SYS_CDClose(SDL_CD *cdrom)

{

return;

}

void SDL_SYS_CDQuit(void)

{

while(SDL_numcds--)

SDL_memset(SDL_cdlist + SDL_numcds, 0, sizeof(SDL_cdlist[0]));

}

#endif /* SDL_CDROM_MACOS */