This repository has been archived by the owner on Feb 11, 2021. It is now read-only.
/
SDL_syscdrom.c
509 lines (442 loc) · 13.5 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_QNX
26
27
28
29
30
31
32
33
34
35
36
/* Functions for system-level CD-ROM audio control */
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/ioctl.h>
#include <fcntl.h>
#include <errno.h>
#include <unistd.h>
#include <sys/cdrom.h>
#include <sys/dcmd_cam.h>
37
#include "SDL_timer.h"
38
#include "SDL_cdrom.h"
39
#include "../SDL_syscdrom.h"
40
41
/* The maximum number of CD-ROM drives we'll detect */
42
43
44
#define MAX_DRIVES 16
#define QNX_CD_OPENMODE O_RDONLY | O_EXCL
45
46
47
48
/* A list of available CD-ROM drives */
static char *SDL_cdlist[MAX_DRIVES];
static dev_t SDL_cdmode[MAX_DRIVES];
49
static int SDL_cdopen[MAX_DRIVES];
50
51
52
53
/* The system-dependent CD control functions */
static const char *SDL_SYS_CDName(int drive);
static int SDL_SYS_CDOpen(int drive);
54
55
56
57
58
59
60
61
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);
62
63
/* Check a drive to see if it is a CD-ROM */
64
65
static int
CheckDrive(char *drive, struct stat *stbuf)
66
{
67
68
int is_cd, cdfd;
cam_devinfo_t dinfo;
69
int devctlret = 0;
70
71
72
73
74
75
int atapi;
int removable;
int cdb10;
/* If it doesn't exist, return -1 */
76
77
if (stat(drive, stbuf) < 0) {
return (-1);
78
79
80
81
82
}
/* If it does exist, verify that it's an available CD-ROM */
is_cd = 0;
83
if (S_ISCHR(stbuf->st_mode) || S_ISBLK(stbuf->st_mode)) {
84
cdfd = open(drive, QNX_CD_OPENMODE);
85
86
87
88
89
90
91
92
93
94
95
96
97
98
if (cdfd >= 0) {
devctlret =
devctl(cdfd, DCMD_CAM_DEVINFO, &dinfo,
sizeof(cam_devinfo_t), NULL);
if (devctlret == EOK) {
atapi = dinfo.flags & DEV_ATAPI;
removable = dinfo.flags & DEV_REMOVABLE;
cdb10 = dinfo.flags & DEV_CDB_10; /* I'm not sure about that flag */
/* in the near future need to add more checks for splitting cdroms from other devices */
if ((atapi) && (removable)) {
is_cd = 1;
}
99
100
101
102
103
}
close(cdfd);
}
}
104
return (is_cd);
105
106
107
}
/* Add a CD-ROM drive to our list of valid drives */
108
109
static void
AddDrive(char *drive, struct stat *stbuf)
110
{
111
112
int i;
113
if (SDL_numcds < MAX_DRIVES) {
114
/* Check to make sure it's not already in our list.
115
This can happen when we see a drive via symbolic link. */
116
117
118
for (i = 0; i < SDL_numcds; ++i) {
if (stbuf->st_rdev == SDL_cdmode[i]) {
119
120
121
122
123
124
125
return;
}
}
/* Add this drive to our list */
i = SDL_numcds;
126
SDL_cdlist[i] = SDL_strdup(drive);
127
if (SDL_cdlist[i] == NULL) {
128
129
130
131
132
133
SDL_OutOfMemory();
return;
}
SDL_cdmode[i] = stbuf->st_rdev;
++SDL_numcds;
}
134
135
}
136
137
int
SDL_SYS_CDInit(void)
138
{
139
/* checklist: /dev/cdrom, /dev/cd?, /dev/scd? */
140
141
static char *checklist[] =
{ "cdrom", "?0 cd?", "?1 cd?", "?0 scd?", NULL };
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
char *SDLcdrom;
int i, j, exists;
char drive[32];
struct stat stbuf;
/* 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;
/* clearing device open status */
161
162
for (i = 0; i < MAX_DRIVES; i++) {
SDL_cdopen[i] = 0;
163
164
165
}
/* Look in the environment for our CD-ROM drive list */
166
167
SDLcdrom = SDL_getenv("SDL_CDROM"); /* ':' separated list of devices */
if (SDLcdrom != NULL) {
168
char *cdpath, *delim;
169
size_t len = SDL_strlen(SDLcdrom) + 1;
170
cdpath = SDL_stack_alloc(char, len);
171
if (cdpath != NULL) {
172
SDL_strlcpy(cdpath, SDLcdrom, len);
173
174
SDLcdrom = cdpath;
do {
175
delim = SDL_strchr(SDLcdrom, ':');
176
if (delim) {
177
178
*delim++ = '\0';
}
179
if (CheckDrive(SDLcdrom, &stbuf) > 0) {
180
181
AddDrive(SDLcdrom, &stbuf);
}
182
if (delim) {
183
SDLcdrom = delim;
184
} else {
185
186
SDLcdrom = NULL;
}
187
188
}
while (SDLcdrom);
189
SDL_stack_free(cdpath);
190
191
192
}
/* If we found our drives, there's nothing left to do */
193
194
if (SDL_numcds > 0) {
return (0);
195
196
197
198
}
}
/* Scan the system for CD-ROM drives */
199
200
201
for (i = 0; checklist[i]; ++i) {
if (checklist[i][0] == '?') {
char *insert;
202
203
exists = 1;
204
205
206
for (j = checklist[i][1]; exists; ++j) {
SDL_snprintf(drive, SDL_arraysize(drive), "/dev/%s",
&checklist[i][3]);
207
insert = SDL_strchr(drive, '?');
208
if (insert != NULL) {
209
210
*insert = j;
}
211
switch (CheckDrive(drive, &stbuf)) {
212
/* Drive exists and is a CD-ROM */
213
214
215
case 1:
AddDrive(drive, &stbuf);
break;
216
/* Drive exists, but isn't a CD-ROM */
217
218
case 0:
break;
219
/* Drive doesn't exist */
220
221
222
case -1:
exists = 0;
break;
223
224
}
}
225
226
227
228
} else {
SDL_snprintf(drive, SDL_arraysize(drive), "/dev/%s",
checklist[i]);
if (CheckDrive(drive, &stbuf) > 0) {
229
230
231
232
AddDrive(drive, &stbuf);
}
}
}
233
return (0);
234
235
}
236
237
static const char *
SDL_SYS_CDName(int drive)
238
{
239
return (SDL_cdlist[drive]);
240
241
}
242
243
static int
SDL_SYS_CDOpen(int drive)
244
{
245
246
int handle;
247
handle = open(SDL_cdlist[drive], QNX_CD_OPENMODE);
248
249
250
if (handle > 0) {
SDL_cdopen[drive] = handle;
251
252
253
}
return (handle);
254
255
}
256
257
static int
SDL_SYS_CDGetTOC(SDL_CD * cdrom)
258
{
259
260
261
262
cdrom_read_toc_t toc;
int i, okay;
okay = 0;
263
264
if (devctl(cdrom->id, DCMD_CAM_CDROMREADTOC, &toc, sizeof(toc), NULL) ==
0) {
265
cdrom->numtracks = toc.last_track - toc.first_track + 1;
266
if (cdrom->numtracks > SDL_MAX_TRACKS) {
267
268
269
cdrom->numtracks = SDL_MAX_TRACKS;
}
/* Read all the track TOC entries */
270
271
for (i = 0; i <= cdrom->numtracks; ++i) {
if (i == cdrom->numtracks) {
272
cdrom->track[i].id = CDROM_LEADOUT;
273
274
} else {
cdrom->track[i].id = toc.first_track + i;
275
276
277
278
279
280
}
cdrom->track[i].type = toc.toc_entry[i].control_adr & 0x0F;
cdrom->track[i].offset = toc.toc_entry[i].addr.lba;
cdrom->track[i].length = 0;
281
282
283
if (i > 0) {
cdrom->track[i - 1].length =
cdrom->track[i].offset - cdrom->track[i - 1].offset;
284
285
}
}
286
if (i == (cdrom->numtracks + 1)) {
287
288
289
290
okay = 1;
}
}
return (okay ? 0 : -1);
291
292
293
}
/* Get CD-ROM status */
294
295
static CDstatus
SDL_SYS_CDStatus(SDL_CD * cdrom, int *position)
296
{
297
298
299
300
301
302
CDstatus status;
cdrom_read_toc_t toc;
cdrom_subch_data_t info;
cam_devinfo_t dinfo;
303
304
int devctlret = 0;
int drive = -1;
305
int i;
306
int eagaincnt = 0;
307
308
309
/* check media presence before read subchannel call, some cdroms can lockups */
/* if no media, while calling read subchannel functions. */
310
311
312
devctlret =
devctl(cdrom->id, DCMD_CAM_DEVINFO, &dinfo, sizeof(cam_devinfo_t),
NULL);
313
314
315
if (devctlret == EOK) {
if ((dinfo.flags & DEV_NO_MEDIA) != 0) {
316
status = CD_TRAYEMPTY;
317
if (position) {
318
319
320
321
322
323
324
325
*position = 0;
}
return (status);
}
}
/* if media exists, then do other stuff */
326
SDL_memset(&info, 0x00, sizeof(info));
327
328
329
info.subch_command.data_format = CDROM_SUBCH_CURRENT_POSITION;
do {
330
331
332
333
devctlret =
devctl(cdrom->id, DCMD_CAM_CDROMSUBCHNL, &info, sizeof(info),
NULL);
if (devctlret == EIO) {
334
335
336
/* big workaround for media change, handle is unusable after that,
that bug was found in QNX 6.2, 6.2.1 is not released yet. */
337
338
339
for (i = 0; i < MAX_DRIVES; i++) {
if (SDL_cdopen[i] == cdrom->id) {
drive = i;
340
341
342
break;
}
}
343
344
345
if (drive == -1) {
/* that cannot happen, but ... */
break;
346
347
}
close(cdrom->id);
348
349
cdrom->id = open(SDL_cdlist[drive], QNX_CD_OPENMODE);
devctlret = EAGAIN;
350
}
351
if (devctlret == EAGAIN) {
352
353
eagaincnt++;
}
354
if (eagaincnt == 2) {
355
356
/* workaround for broken cdroms, which can return always EAGAIN when its not ready, */
/* that mean errornous media or just no media avail */
357
devctlret = ENXIO;
358
359
break;
}
360
361
}
while ((devctlret == EAGAIN) || (devctlret == ESTALE));
362
363
364
if (devctlret != 0) {
if (devctlret == ENXIO) {
365
status = CD_TRAYEMPTY;
366
} else {
367
368
status = CD_ERROR;
}
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
} else {
switch (info.current_position.header.audio_status) {
case CDROM_AUDIO_INVALID:
case CDROM_AUDIO_NO_STATUS:
/* Try to determine if there's a CD available */
if (devctl
(cdrom->id, DCMD_CAM_CDROMREADTOC, &toc, sizeof(toc),
NULL) == 0)
status = CD_STOPPED;
else
status = CD_TRAYEMPTY;
break;
case CDROM_AUDIO_COMPLETED:
status = CD_STOPPED;
break;
case CDROM_AUDIO_PLAY:
status = CD_PLAYING;
break;
case CDROM_AUDIO_PAUSED:
/* Workaround buggy CD-ROM drive */
if (info.current_position.data_format == CDROM_LEADOUT) {
status = CD_STOPPED;
} else {
status = CD_PAUSED;
}
break;
default:
status = CD_ERROR;
break;
398
399
400
}
}
401
402
403
404
405
406
407
408
409
if (position) {
if (status == CD_PLAYING || (status == CD_PAUSED)) {
*position =
MSF_TO_FRAMES(info.current_position.addr.msf.minute,
info.current_position.addr.msf.second,
info.current_position.addr.msf.frame);
} else {
*position = 0;
}
410
411
412
}
return (status);
413
414
415
}
/* Start play */
416
417
static int
SDL_SYS_CDPlay(SDL_CD * cdrom, int start, int length)
418
{
419
420
cdrom_playmsf_t playtime;
421
422
423
424
425
426
427
428
429
430
431
FRAMES_TO_MSF(start, &playtime.start_minute, &playtime.start_second,
&playtime.start_frame);
FRAMES_TO_MSF(start + length, &playtime.end_minute, &playtime.end_second,
&playtime.end_frame);
if (devctl
(cdrom->id, DCMD_CAM_CDROMPLAYMSF, &playtime, sizeof(playtime),
NULL) != 0) {
return -1;
} else {
return 0;
432
}
433
434
435
}
/* Pause play */
436
437
static int
SDL_SYS_CDPause(SDL_CD * cdrom)
438
{
439
440
441
442
if (devctl(cdrom->id, DCMD_CAM_CDROMPAUSE, NULL, 0, NULL) != 0) {
return -1;
} else {
return 0;
443
}
444
445
446
}
/* Resume play */
447
448
static int
SDL_SYS_CDResume(SDL_CD * cdrom)
449
{
450
451
452
453
if (devctl(cdrom->id, DCMD_CAM_CDROMRESUME, NULL, 0, NULL) != 0) {
return -1;
} else {
return 0;
454
}
455
456
457
}
/* Stop play */
458
459
static int
SDL_SYS_CDStop(SDL_CD * cdrom)
460
{
461
462
463
464
if (devctl(cdrom->id, DCMD_CAM_CDROMSTOP, NULL, 0, NULL) != 0) {
return -1;
} else {
return 0;
465
}
466
467
468
}
/* Eject the CD-ROM */
469
470
static int
SDL_SYS_CDEject(SDL_CD * cdrom)
471
{
472
473
474
475
if (devctl(cdrom->id, DCMD_CAM_EJECT_MEDIA, NULL, 0, NULL) != 0) {
return -1;
} else {
return 0;
476
}
477
478
479
}
/* Close the CD-ROM handle */
480
481
static void
SDL_SYS_CDClose(SDL_CD * cdrom)
482
{
483
484
int i;
485
486
487
488
489
for (i = 0; i < MAX_DRIVES; i++) {
if (SDL_cdopen[i] == cdrom->id) {
SDL_cdopen[i] = 0;
break;
}
490
491
492
}
close(cdrom->id);
493
494
}
495
496
void
SDL_SYS_CDQuit(void)
497
{
498
499
int i;
500
501
if (SDL_numcds > 0) {
for (i = 0; i < SDL_numcds; ++i) {
502
SDL_free(SDL_cdlist[i]);
503
504
505
}
SDL_numcds = 0;
}
506
}
507
508
#endif /* SDL_CDROM_QNX */
509
/* vi: set ts=4 sw=4 expandtab: */