Mercurial > sdl-ios-xcode

comparison src/cdrom/macosx/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 4d66375c2012
children 99210400e8b9
comparison
equal deleted inserted replaced
1894:c69cee13dd76 1895:c121d94672cb
25 25
26 #include "SDL_syscdrom_c.h" 26 #include "SDL_syscdrom_c.h"
27 27
28 #pragma mark -- Globals -- 28 #pragma mark -- Globals --
29 29
30 static FSRef** tracks; 30 static FSRef **tracks;
31 static FSVolumeRefNum* volumes; 31 static FSVolumeRefNum *volumes;
32 static CDstatus status; 32 static CDstatus status;
33 static int nextTrackFrame; 33 static int nextTrackFrame;
34 static int nextTrackFramesRemaining; 34 static int nextTrackFramesRemaining;
35 static int fakeCD; 35 static int fakeCD;
36 static int currentTrack; 36 static int currentTrack;
37 static int didReadTOC; 37 static int didReadTOC;
38 static int cacheTOCNumTracks; 38 static int cacheTOCNumTracks;
39 static int currentDrive; /* Only allow 1 drive in use at a time */ 39 static int currentDrive; /* Only allow 1 drive in use at a time */
40 40
41 #pragma mark -- Prototypes -- 41 #pragma mark -- Prototypes --
42 42
43 static const char *SDL_SYS_CDName (int drive); 43 static const char *SDL_SYS_CDName(int drive);
44 static int SDL_SYS_CDOpen (int drive); 44 static int SDL_SYS_CDOpen(int drive);
45 static int SDL_SYS_CDGetTOC (SDL_CD *cdrom); 45 static int SDL_SYS_CDGetTOC(SDL_CD * cdrom);
46 static CDstatus SDL_SYS_CDStatus (SDL_CD *cdrom, int *position); 46 static CDstatus SDL_SYS_CDStatus(SDL_CD * cdrom, int *position);
47 static int SDL_SYS_CDPlay (SDL_CD *cdrom, int start, int length); 47 static int SDL_SYS_CDPlay(SDL_CD * cdrom, int start, int length);
48 static int SDL_SYS_CDPause (SDL_CD *cdrom); 48 static int SDL_SYS_CDPause(SDL_CD * cdrom);
49 static int SDL_SYS_CDResume (SDL_CD *cdrom); 49 static int SDL_SYS_CDResume(SDL_CD * cdrom);
50 static int SDL_SYS_CDStop (SDL_CD *cdrom); 50 static int SDL_SYS_CDStop(SDL_CD * cdrom);
51 static int SDL_SYS_CDEject (SDL_CD *cdrom); 51 static int SDL_SYS_CDEject(SDL_CD * cdrom);
52 static void SDL_SYS_CDClose (SDL_CD *cdrom); 52 static void SDL_SYS_CDClose(SDL_CD * cdrom);
53 53
54 #pragma mark -- Helper Functions -- 54 #pragma mark -- Helper Functions --
55 55
56 /* Read a list of tracks from the volume */ 56 /* Read a list of tracks from the volume */
57 static int LoadTracks (SDL_CD *cdrom) 57 static int
58 LoadTracks(SDL_CD * cdrom)
58 { 59 {
59 /* Check if tracks are already loaded */ 60 /* Check if tracks are already loaded */
60 if ( tracks[cdrom->id] != NULL ) 61 if (tracks[cdrom->id] != NULL)
61 return 0; 62 return 0;
62 63
63 /* Allocate memory for tracks */ 64 /* Allocate memory for tracks */
64 tracks[cdrom->id] = (FSRef*) SDL_calloc (1, sizeof(**tracks) * cdrom->numtracks); 65 tracks[cdrom->id] =
66 (FSRef *) SDL_calloc(1, sizeof(**tracks) * cdrom->numtracks);
65 if (tracks[cdrom->id] == NULL) { 67 if (tracks[cdrom->id] == NULL) {
66 SDL_OutOfMemory (); 68 SDL_OutOfMemory();
67 return -1; 69 return -1;
68 } 70 }
69 71
70 /* Load tracks */ 72 /* Load tracks */
71 if (ListTrackFiles (volumes[cdrom->id], tracks[cdrom->id], cdrom->numtracks) < 0) 73 if (ListTrackFiles
74 (volumes[cdrom->id], tracks[cdrom->id], cdrom->numtracks) < 0)
72 return -1; 75 return -1;
73 76
74 return 0; 77 return 0;
75 } 78 }
76 79
77 /* Find a file for a given start frame and length */ 80 /* Find a file for a given start frame and length */
78 static FSRef* GetFileForOffset (SDL_CD *cdrom, int start, int length, int *outStartFrame, int *outStopFrame) 81 static FSRef *
82 GetFileForOffset(SDL_CD * cdrom, int start, int length, int *outStartFrame,
83 int *outStopFrame)
79 { 84 {
80 int i; 85 int i;
81 86
82 for (i = 0; i < cdrom->numtracks; i++) { 87 for (i = 0; i < cdrom->numtracks; i++) {
83 88
84 if (cdrom->track[i].offset <= start && 89 if (cdrom->track[i].offset <= start &&
85 start < (cdrom->track[i].offset + cdrom->track[i].length)) 90 start < (cdrom->track[i].offset + cdrom->track[i].length))
86 break; 91 break;
87 } 92 }
88 93
89 if (i == cdrom->numtracks) 94 if (i == cdrom->numtracks)
90 return NULL; 95 return NULL;
91 96
92 currentTrack = i; 97 currentTrack = i;
93 98
94 *outStartFrame = start - cdrom->track[i].offset; 99 *outStartFrame = start - cdrom->track[i].offset;
95 100
96 if ((*outStartFrame + length) < cdrom->track[i].length) { 101 if ((*outStartFrame + length) < cdrom->track[i].length) {
97 *outStopFrame = *outStartFrame + length; 102 *outStopFrame = *outStartFrame + length;
98 length = 0; 103 length = 0;
99 nextTrackFrame = -1; 104 nextTrackFrame = -1;
100 nextTrackFramesRemaining = -1; 105 nextTrackFramesRemaining = -1;
101 } 106 } else {
102 else {
103 *outStopFrame = -1; 107 *outStopFrame = -1;
104 length -= cdrom->track[i].length - *outStartFrame; 108 length -= cdrom->track[i].length - *outStartFrame;
105 nextTrackFrame = cdrom->track[i+1].offset; 109 nextTrackFrame = cdrom->track[i + 1].offset;
106 nextTrackFramesRemaining = length; 110 nextTrackFramesRemaining = length;
107 } 111 }
108 112
109 return &tracks[cdrom->id][i]; 113 return &tracks[cdrom->id][i];
110 } 114 }
111 115
112 /* Setup another file for playback, or stop playback (called from another thread) */ 116 /* Setup another file for playback, or stop playback (called from another thread) */
113 static void CompletionProc (SDL_CD *cdrom) 117 static void
114 { 118 CompletionProc(SDL_CD * cdrom)
115 119 {
116 Lock (); 120
117 121 Lock();
122
118 if (nextTrackFrame > 0 && nextTrackFramesRemaining > 0) { 123 if (nextTrackFrame > 0 && nextTrackFramesRemaining > 0) {
119 124
120 /* Load the next file to play */ 125 /* Load the next file to play */
121 int startFrame, stopFrame; 126 int startFrame, stopFrame;
122 FSRef *file; 127 FSRef *file;
123 128
124 PauseFile (); 129 PauseFile();
125 ReleaseFile (); 130 ReleaseFile();
126 131
127 file = GetFileForOffset (cdrom, nextTrackFrame, 132 file = GetFileForOffset(cdrom, nextTrackFrame,
128 nextTrackFramesRemaining, &startFrame, &stopFrame); 133 nextTrackFramesRemaining, &startFrame,
129 134 &stopFrame);
135
130 if (file == NULL) { 136 if (file == NULL) {
131 status = CD_STOPPED; 137 status = CD_STOPPED;
132 Unlock (); 138 Unlock();
133 return; 139 return;
134 } 140 }
135 141
136 LoadFile (file, startFrame, stopFrame); 142 LoadFile(file, startFrame, stopFrame);
137 143
138 SetCompletionProc (CompletionProc, cdrom); 144 SetCompletionProc(CompletionProc, cdrom);
139 145
140 PlayFile (); 146 PlayFile();
141 } 147 } else {
142 else { 148
143
144 /* Release the current file */ 149 /* Release the current file */
145 PauseFile (); 150 PauseFile();
146 ReleaseFile (); 151 ReleaseFile();
147 status = CD_STOPPED; 152 status = CD_STOPPED;
148 } 153 }
149 154
150 Unlock (); 155 Unlock();
151 } 156 }
152 157
153 158
154 #pragma mark -- Driver Functions -- 159 #pragma mark -- Driver Functions --
155 160
156 /* Initialize */ 161 /* Initialize */
157 int SDL_SYS_CDInit (void) 162 int
163 SDL_SYS_CDInit(void)
158 { 164 {
159 /* Initialize globals */ 165 /* Initialize globals */
160 volumes = NULL; 166 volumes = NULL;
161 tracks = NULL; 167 tracks = NULL;
162 status = CD_STOPPED; 168 status = CD_STOPPED;
163 nextTrackFrame = -1; 169 nextTrackFrame = -1;
164 nextTrackFramesRemaining = -1; 170 nextTrackFramesRemaining = -1;
165 fakeCD = SDL_FALSE; 171 fakeCD = SDL_FALSE;
166 currentTrack = -1; 172 currentTrack = -1;
167 didReadTOC = SDL_FALSE; 173 didReadTOC = SDL_FALSE;
168 cacheTOCNumTracks = -1; 174 cacheTOCNumTracks = -1;
169 currentDrive = -1; 175 currentDrive = -1;
170 176
171 /* Fill in function pointers */ 177 /* Fill in function pointers */
172 SDL_CDcaps.Name = SDL_SYS_CDName; 178 SDL_CDcaps.Name = SDL_SYS_CDName;
173 SDL_CDcaps.Open = SDL_SYS_CDOpen; 179 SDL_CDcaps.Open = SDL_SYS_CDOpen;
174 SDL_CDcaps.GetTOC = SDL_SYS_CDGetTOC; 180 SDL_CDcaps.GetTOC = SDL_SYS_CDGetTOC;
175 SDL_CDcaps.Status = SDL_SYS_CDStatus; 181 SDL_CDcaps.Status = SDL_SYS_CDStatus;
176 SDL_CDcaps.Play = SDL_SYS_CDPlay; 182 SDL_CDcaps.Play = SDL_SYS_CDPlay;
177 SDL_CDcaps.Pause = SDL_SYS_CDPause; 183 SDL_CDcaps.Pause = SDL_SYS_CDPause;
178 SDL_CDcaps.Resume = SDL_SYS_CDResume; 184 SDL_CDcaps.Resume = SDL_SYS_CDResume;
179 SDL_CDcaps.Stop = SDL_SYS_CDStop; 185 SDL_CDcaps.Stop = SDL_SYS_CDStop;
180 SDL_CDcaps.Eject = SDL_SYS_CDEject; 186 SDL_CDcaps.Eject = SDL_SYS_CDEject;
181 SDL_CDcaps.Close = SDL_SYS_CDClose; 187 SDL_CDcaps.Close = SDL_SYS_CDClose;
182 188
183 /* 189 /*
184 Read the list of "drives" 190 Read the list of "drives"
185 191
186 This is currently a hack that infers drives from 192 This is currently a hack that infers drives from
187 mounted audio CD volumes, rather than 193 mounted audio CD volumes, rather than
188 actual CD-ROM devices - which means it may not 194 actual CD-ROM devices - which means it may not
189 act as expected sometimes. 195 act as expected sometimes.
190 */ 196 */
191 197
192 /* Find out how many cd volumes are mounted */ 198 /* Find out how many cd volumes are mounted */
193 SDL_numcds = DetectAudioCDVolumes (NULL, 0); 199 SDL_numcds = DetectAudioCDVolumes(NULL, 0);
194 200
195 /* 201 /*
196 If there are no volumes, fake a cd device 202 If there are no volumes, fake a cd device
197 so tray empty can be reported. 203 so tray empty can be reported.
198 */ 204 */
199 if (SDL_numcds == 0) { 205 if (SDL_numcds == 0) {
200 206
201 fakeCD = SDL_TRUE; 207 fakeCD = SDL_TRUE;
202 SDL_numcds = 1; 208 SDL_numcds = 1;
203 status = CD_TRAYEMPTY; 209 status = CD_TRAYEMPTY;
204 210
205 return 0; 211 return 0;
206 } 212 }
207 213
208 /* Allocate space for volumes */ 214 /* Allocate space for volumes */
209 volumes = (FSVolumeRefNum*) SDL_calloc (1, sizeof(*volumes) * SDL_numcds); 215 volumes = (FSVolumeRefNum *) SDL_calloc(1, sizeof(*volumes) * SDL_numcds);
210 if (volumes == NULL) { 216 if (volumes == NULL) {
211 SDL_OutOfMemory (); 217 SDL_OutOfMemory();
212 return -1; 218 return -1;
213 } 219 }
214 220
215 /* Allocate space for tracks */ 221 /* Allocate space for tracks */
216 tracks = (FSRef**) SDL_calloc (1, sizeof(*tracks) * (SDL_numcds + 1)); 222 tracks = (FSRef **) SDL_calloc(1, sizeof(*tracks) * (SDL_numcds + 1));
217 if (tracks == NULL) { 223 if (tracks == NULL) {
218 SDL_OutOfMemory (); 224 SDL_OutOfMemory();
219 return -1; 225 return -1;
220 } 226 }
221 227
222 /* Mark the end of the tracks array */ 228 /* Mark the end of the tracks array */
223 tracks[ SDL_numcds ] = (FSRef*)-1; 229 tracks[SDL_numcds] = (FSRef *) - 1;
224 230
225 /* 231 /*
226 Redetect, now save all volumes for later 232 Redetect, now save all volumes for later
227 Update SDL_numcds just in case it changed 233 Update SDL_numcds just in case it changed
228 */ 234 */
229 { 235 {
230 int numVolumes = SDL_numcds; 236 int numVolumes = SDL_numcds;
231 237
232 SDL_numcds = DetectAudioCDVolumes (volumes, numVolumes); 238 SDL_numcds = DetectAudioCDVolumes(volumes, numVolumes);
233 239
234 /* If more cds suddenly show up, ignore them */ 240 /* If more cds suddenly show up, ignore them */
235 if (SDL_numcds > numVolumes) { 241 if (SDL_numcds > numVolumes) {
236 SDL_SetError ("Some CD's were added but they will be ignored"); 242 SDL_SetError("Some CD's were added but they will be ignored");
237 SDL_numcds = numVolumes; 243 SDL_numcds = numVolumes;
238 } 244 }
239 } 245 }
240 246
241 return 0; 247 return 0;
242 } 248 }
243 249
244 /* Shutdown and cleanup */ 250 /* Shutdown and cleanup */
245 void SDL_SYS_CDQuit(void) 251 void
252 SDL_SYS_CDQuit(void)
246 { 253 {
247 ReleaseFile(); 254 ReleaseFile();
248 255
249 if (volumes != NULL) 256 if (volumes != NULL)
250 free (volumes); 257 free(volumes);
251 258
252 if (tracks != NULL) { 259 if (tracks != NULL) {
253 260
254 FSRef **ptr; 261 FSRef **ptr;
255 for (ptr = tracks; *ptr != (FSRef*)-1; ptr++) 262 for (ptr = tracks; *ptr != (FSRef *) - 1; ptr++)
256 if (*ptr != NULL) 263 if (*ptr != NULL)
257 free (*ptr); 264 free(*ptr);
258 265
259 free (tracks); 266 free(tracks);
260 } 267 }
261 } 268 }
262 269
263 /* Get the Unix disk name of the volume */ 270 /* Get the Unix disk name of the volume */
264 static const char *SDL_SYS_CDName (int drive) 271 static const char *
265 { 272 SDL_SYS_CDName(int drive)
266 OSStatus err = noErr; 273 {
267 HParamBlockRec pb; 274 OSStatus err = noErr;
268 GetVolParmsInfoBuffer volParmsInfo; 275 HParamBlockRec pb;
269 276 GetVolParmsInfoBuffer volParmsInfo;
277
270 if (fakeCD) 278 if (fakeCD)
271 return "Fake CD-ROM Device"; 279 return "Fake CD-ROM Device";
272 280
273 pb.ioParam.ioNamePtr = NULL; 281 pb.ioParam.ioNamePtr = NULL;
274 pb.ioParam.ioVRefNum = volumes[drive]; 282 pb.ioParam.ioVRefNum = volumes[drive];
275 pb.ioParam.ioBuffer = (Ptr)&volParmsInfo; 283 pb.ioParam.ioBuffer = (Ptr) & volParmsInfo;
276 pb.ioParam.ioReqCount = (SInt32)sizeof(volParmsInfo); 284 pb.ioParam.ioReqCount = (SInt32) sizeof(volParmsInfo);
277 err = PBHGetVolParmsSync(&pb); 285 err = PBHGetVolParmsSync(&pb);
278 286
279 if (err != noErr) { 287 if (err != noErr) {
280 SDL_SetError ("PBHGetVolParmsSync returned %d", err); 288 SDL_SetError("PBHGetVolParmsSync returned %d", err);
281 return NULL; 289 return NULL;
282 } 290 }
283 291
284 return volParmsInfo.vMDeviceID; 292 return volParmsInfo.vMDeviceID;
285 } 293 }
286 294
287 /* Open the "device" */ 295 /* Open the "device" */
288 static int SDL_SYS_CDOpen (int drive) 296 static int
297 SDL_SYS_CDOpen(int drive)
289 { 298 {
290 /* Only allow 1 device to be open */ 299 /* Only allow 1 device to be open */
291 if (currentDrive >= 0) { 300 if (currentDrive >= 0) {
292 SDL_SetError ("Only one cdrom is supported"); 301 SDL_SetError("Only one cdrom is supported");
293 return -1; 302 return -1;
294 } 303 } else
295 else
296 currentDrive = drive; 304 currentDrive = drive;
297 305
298 return drive; 306 return drive;
299 } 307 }
300 308
301 /* Get the table of contents */ 309 /* Get the table of contents */
302 static int SDL_SYS_CDGetTOC (SDL_CD *cdrom) 310 static int
311 SDL_SYS_CDGetTOC(SDL_CD * cdrom)
303 { 312 {
304 if (fakeCD) { 313 if (fakeCD) {
305 SDL_SetError (kErrorFakeDevice); 314 SDL_SetError(kErrorFakeDevice);
306 return -1; 315 return -1;
307 } 316 }
308 317
309 if (didReadTOC) { 318 if (didReadTOC) {
310 cdrom->numtracks = cacheTOCNumTracks; 319 cdrom->numtracks = cacheTOCNumTracks;
311 return 0; 320 return 0;
312 } 321 }
313 322
314 323
315 ReadTOCData (volumes[cdrom->id], cdrom); 324 ReadTOCData(volumes[cdrom->id], cdrom);
316 didReadTOC = SDL_TRUE; 325 didReadTOC = SDL_TRUE;
317 cacheTOCNumTracks = cdrom->numtracks; 326 cacheTOCNumTracks = cdrom->numtracks;
318 327
319 return 0; 328 return 0;
320 } 329 }
321 330
322 /* Get CD-ROM status */ 331 /* Get CD-ROM status */
323 static CDstatus SDL_SYS_CDStatus (SDL_CD *cdrom, int *position) 332 static CDstatus
333 SDL_SYS_CDStatus(SDL_CD * cdrom, int *position)
324 { 334 {
325 if (position) { 335 if (position) {
326 int trackFrame; 336 int trackFrame;
327 337
328 Lock (); 338 Lock();
329 trackFrame = GetCurrentFrame (); 339 trackFrame = GetCurrentFrame();
330 Unlock (); 340 Unlock();
331 341
332 *position = cdrom->track[currentTrack].offset + trackFrame; 342 *position = cdrom->track[currentTrack].offset + trackFrame;
333 } 343 }
334 344
335 return status; 345 return status;
336 } 346 }
337 347
338 /* Start playback */ 348 /* Start playback */
339 static int SDL_SYS_CDPlay(SDL_CD *cdrom, int start, int length) 349 static int
350 SDL_SYS_CDPlay(SDL_CD * cdrom, int start, int length)
340 { 351 {
341 int startFrame, stopFrame; 352 int startFrame, stopFrame;
342 FSRef *ref; 353 FSRef *ref;
343 354
344 if (fakeCD) { 355 if (fakeCD) {
345 SDL_SetError (kErrorFakeDevice); 356 SDL_SetError(kErrorFakeDevice);
346 return -1; 357 return -1;
347 } 358 }
348 359
349 Lock(); 360 Lock();
350 361
351 if (LoadTracks (cdrom) < 0) 362 if (LoadTracks(cdrom) < 0)
352 return -2; 363 return -2;
353 364
354 if (PauseFile () < 0) 365 if (PauseFile() < 0)
355 return -3; 366 return -3;
356 367
357 if (ReleaseFile () < 0) 368 if (ReleaseFile() < 0)
358 return -4; 369 return -4;
359 370
360 ref = GetFileForOffset (cdrom, start, length, &startFrame, &stopFrame); 371 ref = GetFileForOffset(cdrom, start, length, &startFrame, &stopFrame);
361 if (ref == NULL) { 372 if (ref == NULL) {
362 SDL_SetError ("SDL_SYS_CDPlay: No file for start=%d, length=%d", start, length); 373 SDL_SetError("SDL_SYS_CDPlay: No file for start=%d, length=%d",
374 start, length);
363 return -5; 375 return -5;
364 } 376 }
365 377
366 if (LoadFile (ref, startFrame, stopFrame) < 0) 378 if (LoadFile(ref, startFrame, stopFrame) < 0)
367 return -6; 379 return -6;
368 380
369 SetCompletionProc (CompletionProc, cdrom); 381 SetCompletionProc(CompletionProc, cdrom);
370 382
371 if (PlayFile () < 0) 383 if (PlayFile() < 0)
372 return -7; 384 return -7;
373 385
374 status = CD_PLAYING; 386 status = CD_PLAYING;
375 387
376 Unlock(); 388 Unlock();
377 389
378 return 0; 390 return 0;
379 } 391 }
380 392
381 /* Pause playback */ 393 /* Pause playback */
382 static int SDL_SYS_CDPause(SDL_CD *cdrom) 394 static int
395 SDL_SYS_CDPause(SDL_CD * cdrom)
383 { 396 {
384 if (fakeCD) { 397 if (fakeCD) {
385 SDL_SetError (kErrorFakeDevice); 398 SDL_SetError(kErrorFakeDevice);
386 return -1; 399 return -1;
387 } 400 }
388 401
389 Lock (); 402 Lock();
390 403
391 if (PauseFile () < 0) { 404 if (PauseFile() < 0) {
392 Unlock (); 405 Unlock();
393 return -2; 406 return -2;
394 } 407 }
395 408
396 status = CD_PAUSED; 409 status = CD_PAUSED;
397 410
398 Unlock (); 411 Unlock();
399 412
400 return 0; 413 return 0;
401 } 414 }
402 415
403 /* Resume playback */ 416 /* Resume playback */
404 static int SDL_SYS_CDResume(SDL_CD *cdrom) 417 static int
418 SDL_SYS_CDResume(SDL_CD * cdrom)
405 { 419 {
406 if (fakeCD) { 420 if (fakeCD) {
407 SDL_SetError (kErrorFakeDevice); 421 SDL_SetError(kErrorFakeDevice);
408 return -1; 422 return -1;
409 } 423 }
410 424
411 Lock (); 425 Lock();
412 426
413 if (PlayFile () < 0) { 427 if (PlayFile() < 0) {
414 Unlock (); 428 Unlock();
415 return -2; 429 return -2;
416 } 430 }
417 431
418 status = CD_PLAYING; 432 status = CD_PLAYING;
419 433
420 Unlock (); 434 Unlock();
421 435
422 return 0; 436 return 0;
423 } 437 }
424 438
425 /* Stop playback */ 439 /* Stop playback */
426 static int SDL_SYS_CDStop(SDL_CD *cdrom) 440 static int
441 SDL_SYS_CDStop(SDL_CD * cdrom)
427 { 442 {
428 if (fakeCD) { 443 if (fakeCD) {
429 SDL_SetError (kErrorFakeDevice); 444 SDL_SetError(kErrorFakeDevice);
430 return -1; 445 return -1;
431 } 446 }
432 447
433 Lock (); 448 Lock();
434 449
435 if (PauseFile () < 0) { 450 if (PauseFile() < 0) {
436 Unlock (); 451 Unlock();
437 return -2; 452 return -2;
438 } 453 }
439 454
440 if (ReleaseFile () < 0) { 455 if (ReleaseFile() < 0) {
441 Unlock (); 456 Unlock();
442 return -3; 457 return -3;
443 } 458 }
444 459
445 status = CD_STOPPED; 460 status = CD_STOPPED;
446 461
447 Unlock (); 462 Unlock();
448 463
449 return 0; 464 return 0;
450 } 465 }
451 466
452 /* Eject the CD-ROM (Unmount the volume) */ 467 /* Eject the CD-ROM (Unmount the volume) */
453 static int SDL_SYS_CDEject(SDL_CD *cdrom) 468 static int
469 SDL_SYS_CDEject(SDL_CD * cdrom)
454 { 470 {
455 OSStatus err; 471 OSStatus err;
456 pid_t dissenter; 472 pid_t dissenter;
457 473
458 if (fakeCD) { 474 if (fakeCD) {
459 SDL_SetError (kErrorFakeDevice); 475 SDL_SetError(kErrorFakeDevice);
460 return -1; 476 return -1;
461 } 477 }
462 478
463 Lock (); 479 Lock();
464 480
465 if (PauseFile () < 0) { 481 if (PauseFile() < 0) {
466 Unlock (); 482 Unlock();
467 return -2; 483 return -2;
468 } 484 }
469 485
470 if (ReleaseFile () < 0) { 486 if (ReleaseFile() < 0) {
471 Unlock (); 487 Unlock();
472 return -3; 488 return -3;
473 } 489 }
474 490
475 status = CD_STOPPED; 491 status = CD_STOPPED;
476 492
477 /* Eject the volume */ 493 /* Eject the volume */
478 err = FSEjectVolumeSync(volumes[cdrom->id], kNilOptions, &dissenter); 494 err = FSEjectVolumeSync(volumes[cdrom->id], kNilOptions, &dissenter);
479 495
480 if (err != noErr) { 496 if (err != noErr) {
481 Unlock (); 497 Unlock();
482 SDL_SetError ("PBUnmountVol returned %d", err); 498 SDL_SetError("PBUnmountVol returned %d", err);
483 return -4; 499 return -4;
484 } 500 }
485 501
486 status = CD_TRAYEMPTY; 502 status = CD_TRAYEMPTY;
487 503
488 /* Invalidate volume and track info */ 504 /* Invalidate volume and track info */
489 volumes[cdrom->id] = 0; 505 volumes[cdrom->id] = 0;
490 free (tracks[cdrom->id]); 506 free(tracks[cdrom->id]);
491 tracks[cdrom->id] = NULL; 507 tracks[cdrom->id] = NULL;
492 508
493 Unlock (); 509 Unlock();
494 510
495 return 0; 511 return 0;
496 } 512 }
497 513
498 /* Close the CD-ROM */ 514 /* Close the CD-ROM */
499 static void SDL_SYS_CDClose(SDL_CD *cdrom) 515 static void
516 SDL_SYS_CDClose(SDL_CD * cdrom)
500 { 517 {
501 currentDrive = -1; 518 currentDrive = -1;
502 return; 519 return;
503 } 520 }
504 521
505 #endif /* SDL_CDROM_MACOSX */ 522 #endif /* SDL_CDROM_MACOSX */
523 /* vi: set ts=4 sw=4 expandtab: */