Mercurial > sdl-ios-xcode

comparison src/cdrom/aix/SDL_syscdrom.c @ 1895:c121d94672cb

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