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