src/cdrom/macos/SDL_syscdrom.c - third_party/sdl - Git at Google

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