| /* |
| SDL - Simple DirectMedia Layer |
| Copyright (C) 1997-2006 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 */ |
