--HG-- extra : convert_revision : svn%3Ac70aab31-4412-0410-b14c-859654838e24/trunk%401576
409 lines
9.3 KiB
C++
409 lines
9.3 KiB
C++
/*
|
|
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"
|
|
|
|
/* Functions for system-level CD-ROM audio control on BeOS
|
|
(not completely implemented yet)
|
|
*/
|
|
|
|
#include <sys/types.h>
|
|
#include <sys/stat.h>
|
|
#include <unistd.h>
|
|
|
|
#include <scsi.h>
|
|
#include <Directory.h>
|
|
#include <Entry.h>
|
|
#include <Path.h>
|
|
|
|
#include "SDL_cdrom.h"
|
|
extern "C" {
|
|
#include "../SDL_syscdrom.h"
|
|
}
|
|
|
|
/* Constants to help us get at the SCSI table-of-contents info */
|
|
#define CD_NUMTRACKS(toc) toc.toc_data[3]
|
|
#define CD_TRACK(toc, track) (&toc.toc_data[6+(track)*8])
|
|
#define CD_TRACK_N(toc, track) CD_TRACK(toc, track)[0]
|
|
#define CD_TRACK_M(toc, track) CD_TRACK(toc, track)[3]
|
|
#define CD_TRACK_S(toc, track) CD_TRACK(toc, track)[4]
|
|
#define CD_TRACK_F(toc, track) CD_TRACK(toc, track)[5]
|
|
|
|
/* Constants to help us get at the SCSI position info */
|
|
#define POS_TRACK(pos) pos.position[6]
|
|
#define POS_ABS_M(pos) pos.position[9]
|
|
#define POS_ABS_S(pos) pos.position[10]
|
|
#define POS_ABS_F(pos) pos.position[11]
|
|
#define POS_REL_M(pos) pos.position[13]
|
|
#define POS_REL_S(pos) pos.position[14]
|
|
#define POS_REL_F(pos) pos.position[15]
|
|
|
|
/* The maximum number of CD-ROM drives we'll detect */
|
|
#define MAX_DRIVES 16
|
|
|
|
/* A list of available CD-ROM drives */
|
|
static char *SDL_cdlist[MAX_DRIVES];
|
|
|
|
/* 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);
|
|
int try_dir(const char *directory);
|
|
|
|
|
|
/* Check a drive to see if it is a CD-ROM */
|
|
static int CheckDrive(char *drive)
|
|
{
|
|
struct stat stbuf;
|
|
int is_cd, cdfd;
|
|
device_geometry info;
|
|
|
|
/* If it doesn't exist, return -1 */
|
|
if ( stat(drive, &stbuf) < 0 ) {
|
|
return(-1);
|
|
}
|
|
|
|
/* If it does exist, verify that it's an available CD-ROM */
|
|
is_cd = 0;
|
|
cdfd = open(drive, 0);
|
|
if ( cdfd >= 0 ) {
|
|
if ( ioctl(cdfd, B_GET_GEOMETRY, &info) == B_NO_ERROR ) {
|
|
if ( info.device_type == B_CD ) {
|
|
is_cd = 1;
|
|
}
|
|
}
|
|
close(cdfd);
|
|
} else {
|
|
/* This can happen when the drive is open .. (?) */;
|
|
is_cd = 1;
|
|
}
|
|
return(is_cd);
|
|
}
|
|
|
|
/* Add a CD-ROM drive to our list of valid drives */
|
|
static void AddDrive(char *drive)
|
|
{
|
|
int i;
|
|
size_t len;
|
|
|
|
if ( SDL_numcds < MAX_DRIVES ) {
|
|
/* Add this drive to our list */
|
|
i = SDL_numcds;
|
|
len = SDL_strlen(drive)+1;
|
|
SDL_cdlist[i] = (char *)SDL_malloc(len);
|
|
if ( SDL_cdlist[i] == NULL ) {
|
|
SDL_OutOfMemory();
|
|
return;
|
|
}
|
|
SDL_strlcpy(SDL_cdlist[i], drive, len);
|
|
++SDL_numcds;
|
|
#ifdef CDROM_DEBUG
|
|
fprintf(stderr, "Added CD-ROM drive: %s\n", drive);
|
|
#endif
|
|
}
|
|
}
|
|
|
|
/* IDE bus scanning magic */
|
|
enum {
|
|
IDE_GET_DEVICES_INFO = B_DEVICE_OP_CODES_END + 50,
|
|
};
|
|
struct ide_ctrl_info {
|
|
bool ide_0_present;
|
|
bool ide_0_master_present;
|
|
bool ide_0_slave_present;
|
|
int ide_0_master_type;
|
|
int ide_0_slave_type;
|
|
bool ide_1_present;
|
|
bool ide_1_master_present;
|
|
bool ide_1_slave_present;
|
|
int ide_1_master_type;
|
|
int ide_1_slave_type;
|
|
};
|
|
|
|
int SDL_SYS_CDInit(void)
|
|
{
|
|
char *SDLcdrom;
|
|
int raw_fd;
|
|
struct ide_ctrl_info info;
|
|
|
|
/* 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;
|
|
|
|
/* Look in the environment for our CD-ROM drive list */
|
|
SDLcdrom = SDL_getenv("SDL_CDROM"); /* ':' separated list of devices */
|
|
if ( SDLcdrom != NULL ) {
|
|
char *cdpath, *delim;
|
|
size_t len = SDL_strlen(SDLcdrom)+1;
|
|
cdpath = SDL_stack_alloc(char, len);
|
|
if ( cdpath != NULL ) {
|
|
SDL_strlcpy(cdpath, SDLcdrom, len);
|
|
SDLcdrom = cdpath;
|
|
do {
|
|
delim = SDL_strchr(SDLcdrom, ':');
|
|
if ( delim ) {
|
|
*delim++ = '\0';
|
|
}
|
|
if ( CheckDrive(SDLcdrom) > 0 ) {
|
|
AddDrive(SDLcdrom);
|
|
}
|
|
if ( delim ) {
|
|
SDLcdrom = delim;
|
|
} else {
|
|
SDLcdrom = NULL;
|
|
}
|
|
} while ( SDLcdrom );
|
|
SDL_stack_free(cdpath);
|
|
}
|
|
|
|
/* If we found our drives, there's nothing left to do */
|
|
if ( SDL_numcds > 0 ) {
|
|
return(0);
|
|
}
|
|
}
|
|
|
|
/* Scan the system for CD-ROM drives */
|
|
try_dir("/dev/disk");
|
|
return 0;
|
|
}
|
|
|
|
|
|
int try_dir(const char *directory)
|
|
{
|
|
BDirectory dir;
|
|
dir.SetTo(directory);
|
|
if(dir.InitCheck() != B_NO_ERROR) {
|
|
return false;
|
|
}
|
|
dir.Rewind();
|
|
BEntry entry;
|
|
while(dir.GetNextEntry(&entry) >= 0) {
|
|
BPath path;
|
|
const char *name;
|
|
entry_ref e;
|
|
|
|
if(entry.GetPath(&path) != B_NO_ERROR)
|
|
continue;
|
|
name = path.Path();
|
|
|
|
if(entry.GetRef(&e) != B_NO_ERROR)
|
|
continue;
|
|
|
|
if(entry.IsDirectory()) {
|
|
if(SDL_strcmp(e.name, "floppy") == 0)
|
|
continue; /* ignore floppy (it is not silent) */
|
|
int devfd = try_dir(name);
|
|
if(devfd >= 0)
|
|
return devfd;
|
|
}
|
|
else {
|
|
int devfd;
|
|
device_geometry g;
|
|
|
|
if(SDL_strcmp(e.name, "raw") != 0)
|
|
continue; /* ignore partitions */
|
|
|
|
devfd = open(name, O_RDONLY);
|
|
if(devfd < 0)
|
|
continue;
|
|
|
|
if(ioctl(devfd, B_GET_GEOMETRY, &g, sizeof(g)) >= 0) {
|
|
if(g.device_type == B_CD)
|
|
{
|
|
AddDrive(strdup(name));
|
|
}
|
|
}
|
|
close(devfd);
|
|
}
|
|
}
|
|
return B_ERROR;
|
|
}
|
|
|
|
|
|
/* General ioctl() CD-ROM command function */
|
|
static int SDL_SYS_CDioctl(int index, int command, void *arg)
|
|
{
|
|
int okay;
|
|
int fd;
|
|
|
|
okay = 0;
|
|
fd = open(SDL_cdlist[index], 0);
|
|
if ( fd >= 0 ) {
|
|
if ( ioctl(fd, command, arg) == B_NO_ERROR ) {
|
|
okay = 1;
|
|
}
|
|
close(fd);
|
|
}
|
|
return(okay ? 0 : -1);
|
|
}
|
|
|
|
static const char *SDL_SYS_CDName(int drive)
|
|
{
|
|
return(SDL_cdlist[drive]);
|
|
}
|
|
|
|
static int SDL_SYS_CDOpen(int drive)
|
|
{
|
|
return(drive);
|
|
}
|
|
|
|
static int SDL_SYS_CDGetTOC(SDL_CD *cdrom)
|
|
{
|
|
int i;
|
|
scsi_toc toc;
|
|
|
|
if ( SDL_SYS_CDioctl(cdrom->id, B_SCSI_GET_TOC, &toc) == 0 ) {
|
|
cdrom->numtracks = CD_NUMTRACKS(toc);
|
|
if ( cdrom->numtracks > SDL_MAX_TRACKS ) {
|
|
cdrom->numtracks = SDL_MAX_TRACKS;
|
|
}
|
|
for ( i=0; i<=cdrom->numtracks; ++i ) {
|
|
cdrom->track[i].id = CD_TRACK_N(toc, i);
|
|
/* FIXME: How do we tell on BeOS? */
|
|
cdrom->track[i].type = SDL_AUDIO_TRACK;
|
|
cdrom->track[i].offset = MSF_TO_FRAMES(
|
|
CD_TRACK_M(toc, i),
|
|
CD_TRACK_S(toc, i),
|
|
CD_TRACK_F(toc, i));
|
|
cdrom->track[i].length = 0;
|
|
if ( i > 0 ) {
|
|
cdrom->track[i-1].length =
|
|
cdrom->track[i].offset-
|
|
cdrom->track[i-1].offset;
|
|
}
|
|
}
|
|
return(0);
|
|
} else {
|
|
return(-1);
|
|
}
|
|
}
|
|
|
|
/* Get CD-ROM status */
|
|
static CDstatus SDL_SYS_CDStatus(SDL_CD *cdrom, int *position)
|
|
{
|
|
CDstatus status;
|
|
int fd;
|
|
int cur_frame;
|
|
scsi_position pos;
|
|
|
|
fd = open(SDL_cdlist[cdrom->id], 0);
|
|
cur_frame = 0;
|
|
if ( fd >= 0 ) {
|
|
if ( ioctl(fd, B_SCSI_GET_POSITION, &pos) == B_NO_ERROR ) {
|
|
cur_frame = MSF_TO_FRAMES(
|
|
POS_ABS_M(pos), POS_ABS_S(pos), POS_ABS_F(pos));
|
|
}
|
|
if ( ! pos.position[1] || (pos.position[1] >= 0x13) ||
|
|
((pos.position[1] == 0x12) && (!pos.position[6])) ) {
|
|
status = CD_STOPPED;
|
|
} else
|
|
if ( pos.position[1] == 0x11 ) {
|
|
status = CD_PLAYING;
|
|
} else {
|
|
status = CD_PAUSED;
|
|
}
|
|
close(fd);
|
|
} else {
|
|
status = CD_TRAYEMPTY;
|
|
}
|
|
if ( position ) {
|
|
*position = cur_frame;
|
|
}
|
|
return(status);
|
|
}
|
|
|
|
/* Start play */
|
|
static int SDL_SYS_CDPlay(SDL_CD *cdrom, int start, int length)
|
|
{
|
|
int okay;
|
|
int fd;
|
|
scsi_play_position pos;
|
|
|
|
okay = 0;
|
|
fd = open(SDL_cdlist[cdrom->id], 0);
|
|
if ( fd >= 0 ) {
|
|
FRAMES_TO_MSF(start, &pos.start_m, &pos.start_s, &pos.start_f);
|
|
FRAMES_TO_MSF(start+length, &pos.end_m, &pos.end_s, &pos.end_f);
|
|
if ( ioctl(fd, B_SCSI_PLAY_POSITION, &pos) == B_NO_ERROR ) {
|
|
okay = 1;
|
|
}
|
|
close(fd);
|
|
}
|
|
return(okay ? 0 : -1);
|
|
}
|
|
|
|
/* Pause play */
|
|
static int SDL_SYS_CDPause(SDL_CD *cdrom)
|
|
{
|
|
return(SDL_SYS_CDioctl(cdrom->id, B_SCSI_PAUSE_AUDIO, 0));
|
|
}
|
|
|
|
/* Resume play */
|
|
static int SDL_SYS_CDResume(SDL_CD *cdrom)
|
|
{
|
|
return(SDL_SYS_CDioctl(cdrom->id, B_SCSI_RESUME_AUDIO, 0));
|
|
}
|
|
|
|
/* Stop play */
|
|
static int SDL_SYS_CDStop(SDL_CD *cdrom)
|
|
{
|
|
return(SDL_SYS_CDioctl(cdrom->id, B_SCSI_STOP_AUDIO, 0));
|
|
}
|
|
|
|
/* Eject the CD-ROM */
|
|
static int SDL_SYS_CDEject(SDL_CD *cdrom)
|
|
{
|
|
return(SDL_SYS_CDioctl(cdrom->id, B_SCSI_EJECT, 0));
|
|
}
|
|
|
|
/* Close the CD-ROM handle */
|
|
static void SDL_SYS_CDClose(SDL_CD *cdrom)
|
|
{
|
|
close(cdrom->id);
|
|
}
|
|
|
|
void SDL_SYS_CDQuit(void)
|
|
{
|
|
int i;
|
|
|
|
if ( SDL_numcds > 0 ) {
|
|
for ( i=0; i<SDL_numcds; ++i ) {
|
|
SDL_free(SDL_cdlist[i]);
|
|
}
|
|
SDL_numcds = 0;
|
|
}
|
|
}
|
|
|