This repository has been archived by the owner on Feb 11, 2021. It is now read-only.
/
SDL_syscdrom.c
670 lines (611 loc) · 18.4 KB
1
/*
2
3
SDL - Simple DirectMedia Layer
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
20
21
22
23
Carsten Griwodz
griff@kom.tu-darmstadt.de
based on linux/SDL_syscdrom.c by Sam Lantinga
*/
24
#include "SDL_config.h"
25
26
27
#ifdef SDL_CDROM_AIX
28
29
/* Functions for system-level CD-ROM audio control */
30
/*#define DEBUG_CDROM 1*/
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>
#include <unistd.h>
#include <sys/ioctl.h>
#include <sys/devinfo.h>
#include <sys/mntctl.h>
#include <sys/statfs.h>
#include <sys/vmount.h>
#include <fstab.h>
#include <sys/scdisk.h>
#include "SDL_cdrom.h"
47
#include "../SDL_syscdrom.h"
48
49
/* The maximum number of CD-ROM drives we'll detect */
50
#define MAX_DRIVES 16
51
52
53
54
55
56
/* 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 */
57
58
59
60
61
62
63
64
65
66
67
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 int SDL_SYS_CDioctl(int id, int command, void *arg);
68
69
/* Check a drive to see if it is a CD-ROM */
70
static int
71
CheckDrive(char *drive, struct stat *stbuf)
72
73
74
75
76
77
78
{
int is_cd;
int cdfd;
int ret;
struct devinfo info;
/* If it doesn't exist, return -1 */
79
if (stat(drive, stbuf) < 0) {
80
81
82
83
84
return -1;
}
/* If it does exist, verify that it's an available CD-ROM */
is_cd = 0;
85
86
if (S_ISCHR(stbuf->st_mode) || S_ISBLK(stbuf->st_mode)) {
cdfd = open(drive, (O_RDONLY | O_EXCL | O_NONBLOCK), 0);
87
if (cdfd >= 0) {
88
ret = SDL_SYS_CDioctl(cdfd, IOCINFO, &info);
89
90
91
92
93
94
95
96
97
98
if (ret < 0) {
/* Some kind of error */
is_cd = 0;
} else {
if (info.devtype == DD_CDROM) {
is_cd = 1;
} else {
is_cd = 0;
}
}
99
close(cdfd);
100
}
101
#ifdef DEBUG_CDROM
102
else {
103
104
fprintf(stderr, "Could not open drive %s (%s)\n", drive,
strerror(errno));
105
}
106
107
108
109
110
111
#endif
}
return is_cd;
}
/* Add a CD-ROM drive to our list of valid drives */
112
static void
113
AddDrive(char *drive, struct stat *stbuf)
114
{
115
116
117
118
119
120
121
122
int i;
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]) {
123
#ifdef DEBUG_CDROM
124
125
fprintf(stderr, "Duplicate drive detected: %s == %s\n",
drive, SDL_cdlist[i]);
126
#endif
127
128
129
130
131
132
return;
}
}
/* Add this drive to our list */
i = SDL_numcds;
133
SDL_cdlist[i] = SDL_strdup(drive);
134
if (SDL_cdlist[i] == NULL) {
135
SDL_OutOfMemory();
136
137
138
139
return;
}
SDL_cdmode[i] = stbuf->st_rdev;
++SDL_numcds;
140
#ifdef DEBUG_CDROM
141
fprintf(stderr, "Added CD-ROM drive: %s\n", drive);
142
#endif
143
}
144
145
}
146
static void
147
CheckMounts()
148
{
149
150
151
152
153
char *buffer;
int bufsz;
struct vmount *ptr;
int ret;
154
buffer = (char *) SDL_malloc(10);
155
156
bufsz = 10;
if (buffer == NULL) {
157
158
159
fprintf(stderr,
"Could not allocate 10 bytes in aix/SDL_syscdrom.c:CheckMounts\n");
exit(-10);
160
161
}
162
163
do {
/* mntctrl() returns an array of all mounted filesystems */
164
ret = mntctl(MCTL_QUERY, bufsz, buffer);
165
166
167
168
169
if (ret == 0) {
/* Buffer was too small, realloc. */
bufsz = *(int *) buffer; /* Required size is in first word. */
/* (whatever a word is in AIX 4.3.3) */
/* int seems to be OK in 32bit mode. */
170
171
SDL_free(buffer);
buffer = (char *) SDL_malloc(bufsz);
172
if (buffer == NULL) {
173
174
175
176
fprintf(stderr,
"Could not allocate %d bytes in aix/SDL_syscdrom.c:CheckMounts\n",
bufsz);
exit(-10);
177
}
178
} else if (ret < 0) {
179
#ifdef DEBUG_CDROM
180
fprintf(stderr, "Error reading vmount structures\n");
181
#endif
182
183
return;
}
184
}
185
while (ret == 0);
186
187
#ifdef DEBUG_CDROM
188
fprintf(stderr, "Read %d vmount structures\n", ret);
189
#endif
190
191
192
193
ptr = (struct vmount *) buffer;
do {
switch (ptr->vmt_gfstype) {
case MNT_CDROM:
194
{
195
196
struct stat stbuf;
char *text;
197
198
text = (char *) ptr + ptr->vmt_data[VMT_OBJECT].vmt_off;
199
#ifdef DEBUG_CDROM
200
201
202
fprintf(stderr,
"Checking mount path: %s mounted on %s\n", text,
(char *) ptr + ptr->vmt_data[VMT_STUB].vmt_off);
203
#endif
204
205
if (CheckDrive(text, &stbuf) > 0) {
AddDrive(text, &stbuf);
206
207
}
}
208
209
210
211
212
213
break;
default:
break;
}
ptr = (struct vmount *) ((char *) ptr + ptr->vmt_length);
ret--;
214
}
215
while (ret > 0);
216
217
free(buffer);
218
219
}
220
static int
221
CheckNonmounts()
222
223
{
#ifdef _THREAD_SAFE
224
225
226
AFILE_t fsFile = NULL;
int passNo = 0;
int ret;
227
struct fstab entry;
228
229
struct stat stbuf;
230
ret = setfsent_r(&fsFile, &passNo);
231
232
233
if (ret != 0)
return -1;
do {
234
ret = getfsent_r(&entry, &fsFile, &passNo);
235
if (ret == 0) {
236
char *l = SDL_strrchr(entry.fs_spec, '/');
237
if (l != NULL) {
238
if (!SDL_strncmp("cd", ++l, 2)) {
239
#ifdef DEBUG_CDROM
240
241
242
fprintf(stderr,
"Found unmounted CD ROM drive with device name %s\n",
entry.fs_spec);
243
#endif
244
245
if (CheckDrive(entry.fs_spec, &stbuf) > 0) {
AddDrive(entry.fs_spec, &stbuf);
246
}
247
248
249
250
}
}
}
}
251
while (ret == 0);
252
ret = endfsent_r(&fsFile);
253
254
if (ret != 0)
return -1;
255
256
return 0;
#else
257
258
259
struct fstab *entry;
struct stat stbuf;
260
setfsent();
261
do {
262
entry = getfsent();
263
if (entry != NULL) {
264
char *l = SDL_strrchr(entry->fs_spec, '/');
265
if (l != NULL) {
266
if (!SDL_strncmp("cd", ++l, 2)) {
267
#ifdef DEBUG_CDROM
268
269
270
fprintf(stderr,
"Found unmounted CD ROM drive with device name %s",
entry->fs_spec);
271
#endif
272
273
if (CheckDrive(entry->fs_spec, &stbuf) > 0) {
AddDrive(entry->fs_spec, &stbuf);
274
}
275
276
277
278
}
}
}
}
279
while (entry != NULL);
280
endfsent();
281
282
283
#endif
}
284
int
285
SDL_SYS_CDInit(void)
286
{
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
char *SDLcdrom;
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;
/* Look in the environment for our CD-ROM drive list */
303
SDLcdrom = SDL_getenv("SDL_CDROM"); /* ':' separated list of devices */
304
305
if (SDLcdrom != NULL) {
char *cdpath, *delim;
306
307
size_t len = SDL_strlen(SDLcdrom) + 1;
cdpath = SDL_stack_alloc(char, len);
308
if (cdpath != NULL) {
309
SDL_strlcpy(cdpath, SDLcdrom, len);
310
311
SDLcdrom = cdpath;
do {
312
delim = SDL_strchr(SDLcdrom, ':');
313
314
315
if (delim) {
*delim++ = '\0';
}
316
#ifdef DEBUG_CDROM
317
318
319
fprintf(stderr,
"Checking CD-ROM drive from SDL_CDROM: %s\n",
SDLcdrom);
320
#endif
321
322
if (CheckDrive(SDLcdrom, &stbuf) > 0) {
AddDrive(SDLcdrom, &stbuf);
323
324
325
326
327
328
329
330
}
if (delim) {
SDLcdrom = delim;
} else {
SDLcdrom = NULL;
}
}
while (SDLcdrom);
331
SDL_stack_free(cdpath);
332
333
334
335
336
337
338
339
}
/* If we found our drives, there's nothing left to do */
if (SDL_numcds > 0) {
return (0);
}
}
340
341
CheckMounts();
CheckNonmounts();
342
343
return 0;
344
345
346
}
/* General ioctl() CD-ROM command function */
347
static int
348
SDL_SYS_CDioctl(int id, int command, void *arg)
349
350
351
{
int retval;
352
retval = ioctl(id, command, arg);
353
if (retval < 0) {
354
SDL_SetError("ioctl() error: %s", strerror(errno));
355
356
357
358
}
return retval;
}
359
static const char *
360
SDL_SYS_CDName(int drive)
361
{
362
return (SDL_cdlist[drive]);
363
364
}
365
static int
366
SDL_SYS_CDOpen(int drive)
367
{
368
369
370
int fd;
char *lastsl;
char *cdromname;
371
size_t len;
372
373
374
375
376
/*
* We found /dev/cd? drives and that is in our list. But we can
* open only the /dev/rcd? versions of those devices for Audio CD.
*/
377
378
379
380
len = SDL_strlen(SDL_cdlist[drive]) + 2;
cdromname = (char *) SDL_malloc(len);
SDL_strlcpy(cdromname, SDL_cdlist[drive], len);
lastsl = SDL_strrchr(cdromname, '/');
381
if (lastsl) {
382
*lastsl = 0;
383
384
SDL_strlcat(cdromname, "/r", len);
lastsl = SDL_strrchr(SDL_cdlist[drive], '/');
385
386
if (lastsl) {
lastsl++;
387
SDL_strlcat(cdromname, lastsl, len);
388
}
389
390
}
#ifdef DEBUG_CDROM
391
392
fprintf(stderr, "Should open drive %s, opening %s\n", SDL_cdlist[drive],
cdromname);
393
394
395
396
397
398
399
#endif
/*
* Use exclusive access. Don't use SC_DIAGNOSTICS as xmcd does because they
* require root priviledges, and we don't want that. SC_SINGLE provides
* exclusive access with less trouble.
*/
400
fd = openx(cdromname, O_RDONLY, NULL, SC_SINGLE);
401
if (fd < 0) {
402
#ifdef DEBUG_CDROM
403
404
fprintf(stderr, "Could not open drive %s (%s)\n", cdromname,
strerror(errno));
405
#endif
406
407
408
} else {
struct mode_form_op cdMode;
int ret;
409
#ifdef DEBUG_CDROM
410
cdMode.action = CD_GET_MODE;
411
ret = SDL_SYS_CDioctl(fd, DK_CD_MODE, &cdMode);
412
if (ret < 0) {
413
414
415
fprintf(stderr,
"Could not get drive mode for %s (%s)\n",
cdromname, strerror(errno));
416
417
418
} else {
switch (cdMode.cd_mode_form) {
case CD_MODE1:
419
420
421
fprintf(stderr,
"Drive mode for %s is %s\n",
cdromname, "CD-ROM Data Mode 1");
422
423
break;
case CD_MODE2_FORM1:
424
425
426
fprintf(stderr,
"Drive mode for %s is %s\n",
cdromname, "CD-ROM XA Data Mode 2 Form 1");
427
428
break;
case CD_MODE2_FORM2:
429
430
431
fprintf(stderr,
"Drive mode for %s is %s\n",
cdromname, "CD-ROM XA Data Mode 2 Form 2");
432
433
break;
case CD_DA:
434
435
fprintf(stderr,
"Drive mode for %s is %s\n", cdromname, "CD-DA");
436
437
break;
default:
438
439
fprintf(stderr,
"Drive mode for %s is %s\n", cdromname, "unknown");
440
441
442
break;
}
}
443
444
#endif
445
446
cdMode.action = CD_CHG_MODE;
cdMode.cd_mode_form = CD_DA;
447
ret = SDL_SYS_CDioctl(fd, DK_CD_MODE, &cdMode);
448
if (ret < 0) {
449
#ifdef DEBUG_CDROM
450
451
452
fprintf(stderr,
"Could not set drive mode for %s (%s)\n",
cdromname, strerror(errno));
453
#endif
454
455
SDL_SetError
("ioctl() error: Could not set CD drive mode, %s",
456
strerror(errno));
457
} else {
458
#ifdef DEBUG_CDROM
459
fprintf(stderr, "Drive mode for %s set to CD_DA\n", cdromname);
460
#endif
461
}
462
}
463
SDL_free(cdromname);
464
465
466
return fd;
}
467
static int
468
SDL_SYS_CDGetTOC(SDL_CD * cdrom)
469
470
471
{
struct cd_audio_cmd cmd;
struct cd_audio_cmd entry;
472
473
int i;
int okay;
474
475
cmd.audio_cmds = CD_TRK_INFO_AUDIO;
476
cmd.msf_flag = FALSE;
477
if (SDL_SYS_CDioctl(cdrom->id, DKAUDIO, &cmd) < 0) {
478
return -1;
479
480
481
482
}
okay = 0;
cdrom->numtracks = cmd.indexing.track_index.last_track
483
484
- cmd.indexing.track_index.first_track + 1;
if (cdrom->numtracks > SDL_MAX_TRACKS) {
485
486
487
488
cdrom->numtracks = SDL_MAX_TRACKS;
}
/* Read all the track TOC entries */
489
490
for (i = 0; i <= cdrom->numtracks; ++i) {
if (i == cdrom->numtracks) {
491
492
cdrom->track[i].id = 0xAA;;
} else {
493
cdrom->track[i].id = cmd.indexing.track_index.first_track + i;
494
}
495
496
entry.audio_cmds = CD_GET_TRK_MSF;
entry.indexing.track_msf.track = cdrom->track[i].id;
497
if (SDL_SYS_CDioctl(cdrom->id, DKAUDIO, &entry) < 0) {
498
499
break;
} else {
500
501
cdrom->track[i].type = 0; /* don't know how to detect 0x04 data track */
cdrom->track[i].offset =
502
503
504
MSF_TO_FRAMES(entry.indexing.track_msf.mins,
entry.indexing.track_msf.secs,
entry.indexing.track_msf.frames);
505
cdrom->track[i].length = 0;
506
507
508
if (i > 0) {
cdrom->track[i - 1].length = cdrom->track[i].offset
- cdrom->track[i - 1].offset;
509
510
511
}
}
}
512
if (i == (cdrom->numtracks + 1)) {
513
514
okay = 1;
}
515
return (okay ? 0 : -1);
516
517
518
}
/* Get CD-ROM status */
519
static CDstatus
520
SDL_SYS_CDStatus(SDL_CD * cdrom, int *position)
521
{
522
CDstatus status;
523
524
525
struct cd_audio_cmd cmd;
cmd.audio_cmds = CD_INFO_AUDIO;
526
if (SDL_SYS_CDioctl(cdrom->id, DKAUDIO, &cmd) < 0) {
527
#ifdef DEBUG_CDROM
528
529
fprintf(stderr, "ioctl failed in SDL_SYS_CDStatus (%s)\n",
SDL_GetError());
530
531
532
533
#endif
status = CD_ERROR;
} else {
switch (cmd.status) {
534
535
536
537
538
539
540
541
542
543
544
case CD_NO_AUDIO:
case CD_COMPLETED:
status = CD_STOPPED;
break;
case CD_PLAY_AUDIO:
status = CD_PLAYING;
break;
case CD_PAUSE_AUDIO:
status = CD_PAUSED;
break;
case CD_NOT_VALID:
545
#ifdef DEBUG_CDROM
546
fprintf(stderr, "cdStatus failed with CD_NOT_VALID\n");
547
#endif
548
549
550
status = CD_ERROR;
break;
case CD_STATUS_ERROR:
551
#ifdef DEBUG_CDROM
552
fprintf(stderr, "cdStatus failed with CD_STATUS_ERROR\n");
553
#endif
554
555
556
status = CD_ERROR;
break;
default:
557
#ifdef DEBUG_CDROM
558
fprintf(stderr, "cdStatus failed with unknown error\n");
559
#endif
560
561
status = CD_ERROR;
break;
562
563
}
}
564
565
566
if (position) {
if (status == CD_PLAYING || (status == CD_PAUSED)) {
*position =
567
568
569
MSF_TO_FRAMES(cmd.indexing.info_audio.current_mins,
cmd.indexing.info_audio.current_secs,
cmd.indexing.info_audio.current_frames);
570
571
572
573
574
575
576
577
} else {
*position = 0;
}
}
return status;
}
/* Start play */
578
static int
579
SDL_SYS_CDPlay(SDL_CD * cdrom, int start, int length)
580
581
582
583
584
585
586
587
588
{
struct cd_audio_cmd cmd;
/*
* My CD Rom is muted by default. I think I read that this is new with
* AIX 4.3. SDL does not change the volume, so I need a kludge. Maybe
* its better to do this elsewhere?
*/
cmd.audio_cmds = CD_PLAY_AUDIO | CD_SET_VOLUME;
589
cmd.msf_flag = TRUE;
590
591
592
593
594
595
596
FRAMES_TO_MSF(start,
&cmd.indexing.msf.first_mins,
&cmd.indexing.msf.first_secs,
&cmd.indexing.msf.first_frames);
FRAMES_TO_MSF(start + length,
&cmd.indexing.msf.last_mins,
&cmd.indexing.msf.last_secs, &cmd.indexing.msf.last_frames);
597
598
599
600
601
602
cmd.volume_type = CD_VOLUME_ALL;
cmd.all_channel_vol = 255; /* This is a uchar. What is a good value? No docu! */
cmd.out_port_0_sel = CD_AUDIO_CHNL_0;
cmd.out_port_1_sel = CD_AUDIO_CHNL_1;
cmd.out_port_2_sel = CD_AUDIO_CHNL_2;
cmd.out_port_3_sel = CD_AUDIO_CHNL_3;
603
604
#ifdef DEBUG_CDROM
605
606
607
608
609
610
fprintf(stderr, "Trying to play from %d:%d:%d to %d:%d:%d\n",
cmd.indexing.msf.first_mins,
cmd.indexing.msf.first_secs,
cmd.indexing.msf.first_frames,
cmd.indexing.msf.last_mins,
cmd.indexing.msf.last_secs, cmd.indexing.msf.last_frames);
611
#endif
612
return (SDL_SYS_CDioctl(cdrom->id, DKAUDIO, &cmd));
613
614
615
}
/* Pause play */
616
static int
617
SDL_SYS_CDPause(SDL_CD * cdrom)
618
619
620
{
struct cd_audio_cmd cmd;
cmd.audio_cmds = CD_PAUSE_AUDIO;
621
return (SDL_SYS_CDioctl(cdrom->id, DKAUDIO, &cmd));
622
623
624
}
/* Resume play */
625
static int
626
SDL_SYS_CDResume(SDL_CD * cdrom)
627
628
629
{
struct cd_audio_cmd cmd;
cmd.audio_cmds = CD_RESUME_AUDIO;
630
return (SDL_SYS_CDioctl(cdrom->id, DKAUDIO, &cmd));
631
632
633
}
/* Stop play */
634
static int
635
SDL_SYS_CDStop(SDL_CD * cdrom)
636
637
638
{
struct cd_audio_cmd cmd;
cmd.audio_cmds = CD_STOP_AUDIO;
639
return (SDL_SYS_CDioctl(cdrom->id, DKAUDIO, &cmd));
640
641
642
}
/* Eject the CD-ROM */
643
static int
644
SDL_SYS_CDEject(SDL_CD * cdrom)
645
{
646
return (SDL_SYS_CDioctl(cdrom->id, DKEJECT, 0));
647
648
649
}
/* Close the CD-ROM handle */
650
static void
651
SDL_SYS_CDClose(SDL_CD * cdrom)
652
{
653
close(cdrom->id);
654
655
}
656
void
657
SDL_SYS_CDQuit(void)
658
{
659
660
661
662
int i;
if (SDL_numcds > 0) {
for (i = 0; i < SDL_numcds; ++i) {
663
SDL_free(SDL_cdlist[i]);
664
665
666
}
SDL_numcds = 0;
}
667
668
}
669
#endif /* SDL_CDROM_AIX */
670
/* vi: set ts=4 sw=4 expandtab: */