This repository has been archived by the owner on Feb 11, 2021. It is now read-only.
/
SDL_syscdrom.c
464 lines (413 loc) · 13 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
/*
Tru64 audio module for SDL (Simple DirectMedia Layer)
Copyright (C) 2003
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License as published by the Free Software Foundation; either
version 2 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
Library General Public License for more details.
You should have received a copy of the GNU Library General Public
License along with this library; if not, write to the Free
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
21
#include "SDL_config.h"
22
23
24
#ifdef SDL_CDROM_OSF
25
26
/* Functions for system-level CD-ROM audio control */
27
/* #define DEBUG_CDROM 1 */
28
29
#include <sys/types.h>
30
#include <dirent.h>
31
32
33
34
35
36
37
#include <sys/stat.h>
#include <fcntl.h>
#include <io/cam/cdrom.h>
#include <io/cam/rzdisk.h>
#include <io/common/devgetinfo.h>
#include "SDL_cdrom.h"
38
#include "../SDL_syscdrom.h"
39
40
41
42
43
44
45
46
47
48
/* 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];
static dev_t SDL_cdmode[MAX_DRIVES];
/* The system-dependent CD control functions */
static const char *SDL_SYS_CDName(int drive);
49
50
51
52
53
54
55
56
57
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);
58
59
/* Check a drive to see if it is a CD-ROM */
60
61
62
/* Caution!! Not tested. */
static int
CheckDrive(char *drive, struct stat *stbuf)
63
{
64
65
66
67
68
int cdfd, is_cd = 0;
struct mode_sel_sns_params msp;
struct inquiry_info inq;
#ifdef DEBUG_CDROM
69
70
71
char *devtype[] = { "Disk", "Tape", "Printer", "Processor", "WORM",
"CD-ROM", "Scanner", "Optical", "Changer", "Comm", "Unknown"
};
72
73
74
75
#endif
bzero(&msp, sizeof(msp));
bzero(&inq, sizeof(inq));
76
77
/* If it doesn't exist, return -1 */
78
79
if (stat(drive, stbuf) < 0) {
return (-1);
80
81
}
82
83
84
85
86
87
if ((cdfd = open(drive, (O_RDWR | O_NDELAY), 0)) >= 0) {
msp.msp_addr = (caddr_t) & inq;
msp.msp_pgcode = 0;
msp.msp_pgctrl = 0;
msp.msp_length = sizeof(inq);
msp.msp_setps = 0;
88
89
90
if (ioctl(cdfd, SCSI_GET_INQUIRY_DATA, &msp))
return (0);
91
92
#ifdef DEBUG_CDROM
93
94
95
96
fprintf(stderr, "Device Type: %s\n", devtype[inq.perfdt]);
fprintf(stderr, "Vendor: %.8s\n", inq.vndrid);
fprintf(stderr, "Product: %.8s\n", inq.prodid);
fprintf(stderr, "Revision: %.8s\n", inq.revlvl);
97
#endif
98
99
if (inq.perfdt == DTYPE_RODIRECT)
is_cd = 1;
100
101
}
102
return (is_cd);
103
104
105
}
/* Add a CD-ROM drive to our list of valid drives */
106
107
static void
AddDrive(char *drive, struct stat *stbuf)
108
109
110
{
int i;
111
112
113
114
115
116
117
if (SDL_numcds < MAX_DRIVES) {
/* Check to make sure it's not already in our list.
* This can happen when we see a drive via symbolic link.
*
*/
for (i = 0; i < SDL_numcds; ++i) {
if (stbuf->st_rdev == SDL_cdmode[i]) {
118
#ifdef DEBUG_CDROM
119
120
fprintf(stderr, "Duplicate drive detected: %s == %s\n",
drive, SDL_cdlist[i]);
121
#endif
122
123
124
125
126
127
128
129
130
131
132
133
134
return;
}
}
/* Add this drive to our list */
i = SDL_numcds;
SDL_cdlist[i] = SDL_strdup(drive);
if (SDL_cdlist[i] == NULL) {
SDL_OutOfMemory();
return;
}
SDL_cdmode[i] = stbuf->st_rdev;
++SDL_numcds;
135
#ifdef DEBUG_CDROM
136
fprintf(stderr, "Added CD-ROM drive: %s\n", drive);
137
138
139
140
#endif
}
}
141
142
int
SDL_SYS_CDInit(void)
143
{
144
145
146
147
148
149
150
/* checklist:
*
* Tru64 5.X (/dev/rdisk/cdrom?c)
* dir: /dev/rdisk, name: cdrom
*
* Digital UNIX 4.0X (/dev/rrz?c)
* dir: /dev, name: rrz
151
152
*
*/
153
154
155
156
struct
{
char *dir;
char *name;
157
} checklist[] = {
158
159
160
161
{
"/dev/rdisk", "cdrom"}, {
"/dev", "rrz"}, {
NULL, NULL}};
162
163
164
165
166
167
char drive[32];
char *SDLcdrom;
int i, j, exists;
struct stat stbuf;
/* Fill in our driver capabilities */
168
169
SDL_CDcaps.Name = SDL_SYS_CDName;
SDL_CDcaps.Open = SDL_SYS_CDOpen;
170
171
SDL_CDcaps.GetTOC = SDL_SYS_CDGetTOC;
SDL_CDcaps.Status = SDL_SYS_CDStatus;
172
173
SDL_CDcaps.Play = SDL_SYS_CDPlay;
SDL_CDcaps.Pause = SDL_SYS_CDPause;
174
SDL_CDcaps.Resume = SDL_SYS_CDResume;
175
176
177
SDL_CDcaps.Stop = SDL_SYS_CDStop;
SDL_CDcaps.Eject = SDL_SYS_CDEject;
SDL_CDcaps.Close = SDL_SYS_CDClose;
178
179
180
/* Look in the environment for our CD-ROM drive list */
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
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, &stbuf) > 0) {
AddDrive(SDLcdrom, &stbuf);
}
if (delim) {
SDLcdrom = delim;
} else {
SDLcdrom = NULL;
}
202
} while (SDLcdrom);
203
204
205
206
207
208
209
SDL_stack_free(cdpath);
}
/* If we found our drives, there's nothing left to do */
if (SDL_numcds > 0) {
return (0);
}
210
211
}
/* Scan the system for CD-ROM drives */
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
for (i = 0; checklist[i].dir; ++i) {
DIR *devdir;
struct dirent *devent;
int name_len;
devdir = opendir(checklist[i].dir);
if (devdir) {
name_len = SDL_strlen(checklist[i].name);
while (devent = readdir(devdir))
if (SDL_memcmp
(checklist[i].name, devent->d_name, name_len) == 0)
if (devent->d_name[devent->d_namlen - 1] == 'c') {
SDL_snprintf(drive, SDL_arraysize(drive),
"%s/%s", checklist[i].dir,
devent->d_name);
227
#ifdef DEBUG_CDROM
228
fprintf(stderr, "Try to add drive: %s\n", drive);
229
#endif
230
231
232
233
234
if (CheckDrive(drive, &stbuf) > 0)
AddDrive(drive, &stbuf);
}
closedir(devdir);
} else {
235
#ifdef DEBUG_CDROM
236
fprintf(stderr, "cannot open dir: %s\n", checklist[i].dir);
237
#endif
238
}
239
240
241
242
}
return (0);
}
243
244
static const char *
SDL_SYS_CDName(int drive)
245
{
246
return (SDL_cdlist[drive]);
247
248
}
249
250
static int
SDL_SYS_CDOpen(int drive)
251
252
{
/* O_RDWR: To use ioctl(fd, SCSI_STOP_UNIT) */
253
return (open(SDL_cdlist[drive], (O_RDWR | O_NDELAY), 0));
254
255
}
256
257
static int
SDL_SYS_CDGetTOC(SDL_CD * cdrom)
258
{
259
260
261
struct cd_toc toc;
struct cd_toc_header hdr;
struct cd_toc_entry *cdte;
262
263
int i;
int okay = 0;
264
265
266
if (ioctl(cdrom->id, CDROM_TOC_HEADER, &hdr)) {
fprintf(stderr, "ioctl error CDROM_TOC_HEADER\n");
return -1;
267
268
}
cdrom->numtracks = hdr.th_ending_track - hdr.th_starting_track + 1;
269
270
if (cdrom->numtracks > SDL_MAX_TRACKS) {
cdrom->numtracks = SDL_MAX_TRACKS;
271
272
}
#ifdef DEBUG_CDROM
273
274
275
276
277
fprintf(stderr, "hdr.th_data_len1 = %d\n", hdr.th_data_len1);
fprintf(stderr, "hdr.th_data_len0 = %d\n", hdr.th_data_len0);
fprintf(stderr, "hdr.th_starting_track = %d\n", hdr.th_starting_track);
fprintf(stderr, "hdr.th_ending_track = %d\n", hdr.th_ending_track);
fprintf(stderr, "cdrom->numtracks = %d\n", cdrom->numtracks);
278
279
280
281
#endif
toc.toc_address_format = CDROM_LBA_FORMAT;
toc.toc_starting_track = 0;
toc.toc_alloc_length = (hdr.th_data_len1 << 8) +
282
283
284
285
hdr.th_data_len0 + sizeof(hdr);
if ((toc.toc_buffer = alloca(toc.toc_alloc_length)) == NULL) {
fprintf(stderr, "cannot allocate toc.toc_buffer\n");
return -1;
286
287
}
288
bzero(toc.toc_buffer, toc.toc_alloc_length);
289
if (ioctl(cdrom->id, CDROM_TOC_ENTRYS, &toc)) {
290
291
fprintf(stderr, "ioctl error CDROM_TOC_ENTRYS\n");
return -1;
292
293
}
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
cdte = (struct cd_toc_entry *) ((char *) toc.toc_buffer + sizeof(hdr));
for (i = 0; i <= cdrom->numtracks; ++i) {
if (i == cdrom->numtracks) {
cdrom->track[i].id = 0xAA;;
} else {
cdrom->track[i].id = hdr.th_starting_track + i;
}
cdrom->track[i].type = cdte[i].te_control & CDROM_DATA_TRACK;
cdrom->track[i].offset =
cdte[i].te_absaddr.lba.addr3 << 24 |
cdte[i].te_absaddr.lba.addr2 << 16 |
cdte[i].te_absaddr.lba.addr1 << 8 | cdte[i].te_absaddr.lba.addr0;
cdrom->track[i].length = 0;
if (i > 0) {
cdrom->track[i - 1].length =
cdrom->track[i].offset - cdrom->track[i - 1].offset;
}
312
}
313
#ifdef DEBUG_CDROM
314
315
316
317
318
319
320
321
322
323
324
for (i = 0; i <= cdrom->numtracks; i++) {
fprintf(stderr, "toc_entry[%d].te_track_number = %d\n",
i, cdte[i].te_track_number);
fprintf(stderr, "cdrom->track[%d].id = %d\n", i, cdrom->track[i].id);
fprintf(stderr, "cdrom->track[%d].type = %x\n", i,
cdrom->track[i].type);
fprintf(stderr, "cdrom->track[%d].offset = %d\n", i,
cdrom->track[i].offset);
fprintf(stderr, "cdrom->track[%d].length = %d\n", i,
cdrom->track[i].length);
}
325
#endif
326
327
if (i == (cdrom->numtracks + 1)) {
okay = 1;
328
329
}
330
return (okay ? 0 : -1);
331
332
333
}
/* Get CD-ROM status */
334
335
static CDstatus
SDL_SYS_CDStatus(SDL_CD * cdrom, int *position)
336
{
337
338
339
CDstatus status;
struct cd_sub_channel sc;
struct cd_subc_channel_data scd;
340
341
sc.sch_address_format = CDROM_LBA_FORMAT;
342
343
344
345
346
347
348
sc.sch_data_format = CDROM_CURRENT_POSITION;
sc.sch_track_number = 0;
sc.sch_alloc_length = sizeof(scd);
sc.sch_buffer = (caddr_t) & scd;
if (ioctl(cdrom->id, CDROM_READ_SUBCHANNEL, &sc)) {
status = CD_ERROR;
fprintf(stderr, "ioctl error CDROM_READ_SUBCHANNEL \n");
349
} else {
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
switch (scd.scd_header.sh_audio_status) {
case AS_AUDIO_INVALID:
status = CD_STOPPED;
break;
case AS_PLAY_IN_PROGRESS:
status = CD_PLAYING;
break;
case AS_PLAY_PAUSED:
status = CD_PAUSED;
break;
case AS_PLAY_COMPLETED:
status = CD_STOPPED;
break;
case AS_PLAY_ERROR:
status = CD_ERROR;
break;
case AS_NO_STATUS:
status = CD_STOPPED;
break;
default:
status = CD_ERROR;
break;
}
373
#ifdef DEBUG_CDROM
374
375
fprintf(stderr, "scd.scd_header.sh_audio_status = %x\n",
scd.scd_header.sh_audio_status);
376
377
378
#endif
}
if (position) {
379
380
381
382
383
384
385
386
387
if (status == CD_PLAYING || (status == CD_PAUSED)) {
*position =
scd.scd_position_data.scp_absaddr.lba.addr3 << 24 |
scd.scd_position_data.scp_absaddr.lba.addr2 << 16 |
scd.scd_position_data.scp_absaddr.lba.addr1 << 8 |
scd.scd_position_data.scp_absaddr.lba.addr0;
} else {
*position = 0;
}
388
389
390
391
392
393
}
return status;
}
/* Start play */
394
395
static int
SDL_SYS_CDPlay(SDL_CD * cdrom, int start, int length)
396
{
397
398
/*
* Play MSF
399
400
401
402
403
*/
struct cd_play_audio_msf msf;
int end;
bzero(&msf, sizeof(msf));
404
405
406
407
408
409
410
411
412
end = start + length;
FRAMES_TO_MSF(start + 150, /* LBA = 4500*M + 75*S + F - 150 */
&msf.msf_starting_M_unit,
&msf.msf_starting_S_unit, &msf.msf_starting_F_unit);
FRAMES_TO_MSF(end + 150, /* LBA = 4500*M + 75*S + F - 150 */
&msf.msf_ending_M_unit,
&msf.msf_ending_S_unit, &msf.msf_ending_F_unit);
return (ioctl(cdrom->id, CDROM_PLAY_AUDIO_MSF, &msf));
413
414
415
}
/* Pause play */
416
417
static int
SDL_SYS_CDPause(SDL_CD * cdrom)
418
{
419
return (ioctl(cdrom->id, CDROM_PAUSE_PLAY));
420
421
422
}
/* Resume play */
423
424
static int
SDL_SYS_CDResume(SDL_CD * cdrom)
425
{
426
return (ioctl(cdrom->id, CDROM_RESUME_PLAY));
427
428
429
}
/* Stop play */
430
431
static int
SDL_SYS_CDStop(SDL_CD * cdrom)
432
{
433
return (ioctl(cdrom->id, SCSI_STOP_UNIT));
434
435
436
}
/* Eject the CD-ROM */
437
438
static int
SDL_SYS_CDEject(SDL_CD * cdrom)
439
{
440
return (ioctl(cdrom->id, CDROM_EJECT_CADDY));
441
442
443
}
/* Close the CD-ROM handle */
444
445
static void
SDL_SYS_CDClose(SDL_CD * cdrom)
446
447
448
449
{
close(cdrom->id);
}
450
451
void
SDL_SYS_CDQuit(void)
452
453
454
{
int i;
455
456
457
458
459
if (SDL_numcds > 0) {
for (i = 0; i < SDL_numcds; ++i) {
SDL_free(SDL_cdlist[i]);
}
SDL_numcds = 0;
460
461
462
}
}
463
#endif /* SDL_CDROM_OSF */
464
/* vi: set ts=4 sw=4 expandtab: */