This repository has been archived by the owner on Feb 11, 2021. It is now read-only.
/
SDL_syscdrom.cc
428 lines (375 loc) · 10.7 KB
1
2
/*
SDL - Simple DirectMedia Layer
3
Copyright (C) 1997-2006 Sam Lantinga
4
5
This library is free software; you can redistribute it and/or
6
modify it under the terms of the GNU Lesser General Public
7
License as published by the Free Software Foundation; either
8
version 2.1 of the License, or (at your option) any later version.
9
10
11
12
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
13
Lesser General Public License for more details.
14
15
16
17
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
18
19
Sam Lantinga
20
slouken@libsdl.org
21
*/
22
#include "SDL_config.h"
23
24
25
#ifdef SDL_CDROM_BEOS
26
27
28
29
30
31
32
33
34
/* 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>
35
36
37
#include <Directory.h>
#include <Entry.h>
#include <Path.h>
38
39
#include "SDL_cdrom.h"
40
41
extern "C"
{
42
#include "../SDL_syscdrom.h"
43
}
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
/* 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 */
63
#define MAX_DRIVES 16
64
65
66
67
68
/* A list of available CD-ROM drives */
static char *SDL_cdlist[MAX_DRIVES];
/* The system-dependent CD control functions */
69
70
71
72
73
74
75
76
77
78
79
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);
80
81
82
/* Check a drive to see if it is a CD-ROM */
83
static int
84
CheckDrive(char *drive)
85
{
86
87
88
89
90
struct stat stbuf;
int is_cd, cdfd;
device_geometry info;
/* If it doesn't exist, return -1 */
91
if (stat(drive, &stbuf) < 0) {
92
93
94
95
96
return (-1);
}
/* If it does exist, verify that it's an available CD-ROM */
is_cd = 0;
97
cdfd = open(drive, 0);
98
if (cdfd >= 0) {
99
if (ioctl(cdfd, B_GET_GEOMETRY, &info) == B_NO_ERROR) {
100
101
102
103
if (info.device_type == B_CD) {
is_cd = 1;
}
}
104
close(cdfd);
105
106
107
108
109
} else {
/* This can happen when the drive is open .. (?) */ ;
is_cd = 1;
}
return (is_cd);
110
111
112
}
/* Add a CD-ROM drive to our list of valid drives */
113
static void
114
AddDrive(char *drive)
115
{
116
117
118
119
120
121
int i;
size_t len;
if (SDL_numcds < MAX_DRIVES) {
/* Add this drive to our list */
i = SDL_numcds;
122
123
len = SDL_strlen(drive) + 1;
SDL_cdlist[i] = (char *) SDL_malloc(len);
124
if (SDL_cdlist[i] == NULL) {
125
SDL_OutOfMemory();
126
127
return;
}
128
SDL_strlcpy(SDL_cdlist[i], drive, len);
129
++SDL_numcds;
130
#ifdef CDROM_DEBUG
131
fprintf(stderr, "Added CD-ROM drive: %s\n", drive);
132
#endif
133
}
134
135
136
}
/* IDE bus scanning magic */
137
138
139
enum
{
IDE_GET_DEVICES_INFO = B_DEVICE_OP_CODES_END + 50,
140
};
141
142
143
144
145
146
147
148
149
150
151
152
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;
153
154
};
155
int
156
SDL_SYS_CDInit(void)
157
{
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
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 */
175
SDLcdrom = SDL_getenv("SDL_CDROM"); /* ':' separated list of devices */
176
177
if (SDLcdrom != NULL) {
char *cdpath, *delim;
178
179
size_t len = SDL_strlen(SDLcdrom) + 1;
cdpath = SDL_stack_alloc(char, len);
180
if (cdpath != NULL) {
181
SDL_strlcpy(cdpath, SDLcdrom, len);
182
183
SDLcdrom = cdpath;
do {
184
delim = SDL_strchr(SDLcdrom, ':');
185
186
187
if (delim) {
*delim++ = '\0';
}
188
189
if (CheckDrive(SDLcdrom) > 0) {
AddDrive(SDLcdrom);
190
191
192
193
194
195
196
197
}
if (delim) {
SDLcdrom = delim;
} else {
SDLcdrom = NULL;
}
}
while (SDLcdrom);
198
SDL_stack_free(cdpath);
199
200
201
202
203
204
205
206
207
}
/* If we found our drives, there's nothing left to do */
if (SDL_numcds > 0) {
return (0);
}
}
/* Scan the system for CD-ROM drives */
208
try_dir("/dev/disk");
209
return 0;
210
211
212
}
213
int
214
try_dir(const char *directory)
215
216
{
BDirectory dir;
217
218
dir.SetTo(directory);
if (dir.InitCheck() != B_NO_ERROR) {
219
220
return false;
}
221
dir.Rewind();
222
BEntry entry;
223
while (dir.GetNextEntry(&entry) >= 0) {
224
225
226
227
BPath path;
const char *name;
entry_ref e;
228
if (entry.GetPath(&path) != B_NO_ERROR)
229
continue;
230
name = path.Path();
231
232
if (entry.GetRef(&e) != B_NO_ERROR)
233
234
continue;
235
236
if (entry.IsDirectory()) {
if (SDL_strcmp(e.name, "floppy") == 0)
237
continue; /* ignore floppy (it is not silent) */
238
int devfd = try_dir(name);
239
240
241
242
243
244
if (devfd >= 0)
return devfd;
} else {
int devfd;
device_geometry g;
245
if (SDL_strcmp(e.name, "raw") != 0)
246
247
continue; /* ignore partitions */
248
devfd = open(name, O_RDONLY);
249
250
251
if (devfd < 0)
continue;
252
if (ioctl(devfd, B_GET_GEOMETRY, &g, sizeof(g)) >= 0) {
253
if (g.device_type == B_CD) {
254
AddDrive(strdup(name));
255
256
}
}
257
close(devfd);
258
259
260
}
}
return B_ERROR;
261
262
}
263
264
/* General ioctl() CD-ROM command function */
265
static int
266
SDL_SYS_CDioctl(int index, int command, void *arg)
267
{
268
269
270
271
int okay;
int fd;
okay = 0;
272
fd = open(SDL_cdlist[index], 0);
273
if (fd >= 0) {
274
if (ioctl(fd, command, arg) == B_NO_ERROR) {
275
276
okay = 1;
}
277
close(fd);
278
279
}
return (okay ? 0 : -1);
280
281
}
282
static const char *
283
SDL_SYS_CDName(int drive)
284
{
285
286
return (SDL_cdlist[drive]);
}
287
288
static int
289
SDL_SYS_CDOpen(int drive)
290
{
291
return (drive);
292
293
}
294
static int
295
SDL_SYS_CDGetTOC(SDL_CD * cdrom)
296
{
297
298
299
int i;
scsi_toc toc;
300
301
if (SDL_SYS_CDioctl(cdrom->id, B_SCSI_GET_TOC, &toc) == 0) {
cdrom->numtracks = CD_NUMTRACKS(toc);
302
303
304
305
if (cdrom->numtracks > SDL_MAX_TRACKS) {
cdrom->numtracks = SDL_MAX_TRACKS;
}
for (i = 0; i <= cdrom->numtracks; ++i) {
306
cdrom->track[i].id = CD_TRACK_N(toc, i);
307
308
/* FIXME: How do we tell on BeOS? */
cdrom->track[i].type = SDL_AUDIO_TRACK;
309
310
311
cdrom->track[i].offset = MSF_TO_FRAMES(CD_TRACK_M(toc, i),
CD_TRACK_S(toc, i),
CD_TRACK_F(toc, i));
312
313
314
315
316
317
318
319
320
321
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);
}
322
323
324
}
/* Get CD-ROM status */
325
static CDstatus
326
SDL_SYS_CDStatus(SDL_CD * cdrom, int *position)
327
{
328
329
330
331
332
CDstatus status;
int fd;
int cur_frame;
scsi_position pos;
333
fd = open(SDL_cdlist[cdrom->id], 0);
334
335
cur_frame = 0;
if (fd >= 0) {
336
if (ioctl(fd, B_SCSI_GET_POSITION, &pos) == B_NO_ERROR) {
337
cur_frame =
338
MSF_TO_FRAMES(POS_ABS_M(pos), POS_ABS_S(pos), POS_ABS_F(pos));
339
340
341
342
343
344
345
346
347
}
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;
}
348
close(fd);
349
350
351
352
353
354
355
} else {
status = CD_TRAYEMPTY;
}
if (position) {
*position = cur_frame;
}
return (status);
356
357
358
}
/* Start play */
359
static int
360
SDL_SYS_CDPlay(SDL_CD * cdrom, int start, int length)
361
{
362
363
364
365
366
int okay;
int fd;
scsi_play_position pos;
okay = 0;
367
fd = open(SDL_cdlist[cdrom->id], 0);
368
if (fd >= 0) {
369
370
371
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) {
372
373
okay = 1;
}
374
close(fd);
375
376
}
return (okay ? 0 : -1);
377
378
379
}
/* Pause play */
380
static int
381
SDL_SYS_CDPause(SDL_CD * cdrom)
382
{
383
return (SDL_SYS_CDioctl(cdrom->id, B_SCSI_PAUSE_AUDIO, 0));
384
385
386
}
/* Resume play */
387
static int
388
SDL_SYS_CDResume(SDL_CD * cdrom)
389
{
390
return (SDL_SYS_CDioctl(cdrom->id, B_SCSI_RESUME_AUDIO, 0));
391
392
393
}
/* Stop play */
394
static int
395
SDL_SYS_CDStop(SDL_CD * cdrom)
396
{
397
return (SDL_SYS_CDioctl(cdrom->id, B_SCSI_STOP_AUDIO, 0));
398
399
400
}
/* Eject the CD-ROM */
401
static int
402
SDL_SYS_CDEject(SDL_CD * cdrom)
403
{
404
return (SDL_SYS_CDioctl(cdrom->id, B_SCSI_EJECT, 0));
405
406
407
}
/* Close the CD-ROM handle */
408
static void
409
SDL_SYS_CDClose(SDL_CD * cdrom)
410
{
411
close(cdrom->id);
412
413
}
414
void
415
SDL_SYS_CDQuit(void)
416
{
417
418
419
420
int i;
if (SDL_numcds > 0) {
for (i = 0; i < SDL_numcds; ++i) {
421
SDL_free(SDL_cdlist[i]);
422
423
424
}
SDL_numcds = 0;
}
425
426
}
427
#endif /* SDL_CDROM_BEOS */
428
/* vi: set ts=4 sw=4 expandtab: */