fix alpha for 32bpp screen
[sdl_omap.git] / src / cdrom / macosx / CDPlayer.c
1 /*
2     SDL - Simple DirectMedia Layer
3     Copyright (C) 1997-2009 Sam Lantinga
4
5     This library is free software; you can redistribute it and/or
6     modify it under the terms of the GNU Library General Public
7     License as published by the Free Software Foundation; either
8     version 2 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     Library General Public License for more details.
14
15     You should have received a copy of the GNU Library General Public
16     License along with this library; if not, write to the Free
17     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
18
19     Sam Lantinga
20     slouken@libsdl.org
21 */
22 #include "SDL_config.h"
23
24 #include "CDPlayer.h"
25 #include "AudioFilePlayer.h"
26 #include "SDLOSXCAGuard.h"
27
28 /* we're exporting these functions into C land for SDL_syscdrom.c */
29 /*extern "C" {*/
30
31 /*///////////////////////////////////////////////////////////////////////////
32     Constants
33   //////////////////////////////////////////////////////////////////////////*/
34
35 #define kAudioCDFilesystemID   (UInt16)(('J' << 8) | 'H') /* 'JH'; this avoids compiler warning */
36
37 /* XML PList keys */
38 #define kRawTOCDataString           "Format 0x02 TOC Data"
39 #define kSessionsString             "Sessions"
40 #define kSessionTypeString          "Session Type"
41 #define kTrackArrayString           "Track Array"
42 #define kFirstTrackInSessionString      "First Track"
43 #define kLastTrackInSessionString       "Last Track"
44 #define kLeadoutBlockString         "Leadout Block"
45 #define kDataKeyString              "Data"
46 #define kPointKeyString             "Point"
47 #define kSessionNumberKeyString         "Session Number"
48 #define kStartBlockKeyString            "Start Block"   
49     
50 /*///////////////////////////////////////////////////////////////////////////
51     Globals
52   //////////////////////////////////////////////////////////////////////////*/
53
54 #pragma mark -- Globals --
55
56 static int             playBackWasInit = 0;
57 static AudioUnit        theUnit;
58 static AudioFilePlayer* thePlayer = NULL;
59 static CDPlayerCompletionProc   completionProc = NULL;
60 static SDL_mutex       *apiMutex = NULL;
61 static SDL_sem         *callbackSem;
62 static SDL_CD*          theCDROM;
63
64 /*///////////////////////////////////////////////////////////////////////////
65     Prototypes
66   //////////////////////////////////////////////////////////////////////////*/
67
68 #pragma mark -- Prototypes --
69
70 static OSStatus CheckInit ();
71
72 static void     FilePlayNotificationHandler (void* inRefCon, OSStatus inStatus);
73
74 static int      RunCallBackThread (void* inRefCon);
75
76
77 #pragma mark -- Public Functions --
78
79 void     Lock ()
80 {
81     if (!apiMutex) {
82         apiMutex = SDL_CreateMutex();
83     }
84     SDL_mutexP(apiMutex);
85 }
86
87 void     Unlock ()
88 {
89     SDL_mutexV(apiMutex);
90 }
91
92 int DetectAudioCDVolumes(FSVolumeRefNum *volumes, int numVolumes)
93 {
94     int volumeIndex;
95     int cdVolumeCount = 0;
96     OSStatus result = noErr;
97     
98     for (volumeIndex = 1; result == noErr || result != nsvErr; volumeIndex++)
99     {
100         FSVolumeRefNum  actualVolume;
101         FSVolumeInfo    volumeInfo;
102         
103         memset (&volumeInfo, 0, sizeof(volumeInfo));
104         
105         result = FSGetVolumeInfo (kFSInvalidVolumeRefNum,
106                                   volumeIndex,
107                                   &actualVolume,
108                                   kFSVolInfoFSInfo,
109                                   &volumeInfo,
110                                   NULL,
111                                   NULL); 
112          
113         if (result == noErr)
114         {
115             if (volumeInfo.filesystemID == kAudioCDFilesystemID) /* It's an audio CD */
116             {
117                 if (volumes != NULL && cdVolumeCount < numVolumes)
118                     volumes[cdVolumeCount] = actualVolume;
119             
120                 cdVolumeCount++;
121             }
122         }
123         else 
124         {
125             /* I'm commenting this out because it seems to be harmless */
126             /*SDL_SetError ("DetectAudioCDVolumes: FSGetVolumeInfo returned %d", result);*/
127         }
128     }
129         
130     return cdVolumeCount;
131 }
132
133 int ReadTOCData (FSVolumeRefNum theVolume, SDL_CD *theCD)
134 {
135     HFSUniStr255      dataForkName;
136     OSStatus          theErr;
137     FSIORefNum        forkRefNum;
138     SInt64            forkSize;
139     Ptr               forkData = 0;
140     ByteCount         actualRead;
141     CFDataRef         dataRef = 0;
142     CFPropertyListRef propertyListRef = 0;
143     int               i;
144     FSRefParam      fsRefPB;
145     FSRef           tocPlistFSRef;
146     FSRef           rootRef;
147     const char* error = "Unspecified Error";
148     const UniChar uniName[] = { '.','T','O','C','.','p','l','i','s','t' };
149
150     theErr = FSGetVolumeInfo(theVolume, 0, 0, kFSVolInfoNone, 0, 0, &rootRef);
151     if(theErr != noErr) {
152         error = "FSGetVolumeInfo";
153         goto bail;
154     }
155
156     SDL_memset(&fsRefPB, '\0', sizeof (fsRefPB));
157
158     /* get stuff from .TOC.plist */
159     fsRefPB.ref = &rootRef;
160     fsRefPB.newRef = &tocPlistFSRef;
161     fsRefPB.nameLength = sizeof (uniName) / sizeof (uniName[0]);
162     fsRefPB.name = uniName;
163     fsRefPB.textEncodingHint = kTextEncodingUnknown;
164
165     theErr = PBMakeFSRefUnicodeSync (&fsRefPB);
166     if(theErr != noErr) {
167         error = "PBMakeFSRefUnicodeSync";
168         goto bail;
169     }
170     
171     /* Load and parse the TOC XML data */
172
173     theErr = FSGetDataForkName (&dataForkName);
174     if (theErr != noErr) {
175         error = "FSGetDataForkName";
176         goto bail;
177     }
178     
179     theErr = FSOpenFork (&tocPlistFSRef, dataForkName.length, dataForkName.unicode, fsRdPerm, &forkRefNum);
180     if (theErr != noErr) {
181         error = "FSOpenFork";
182         goto bail;
183     }
184     
185     theErr = FSGetForkSize (forkRefNum, &forkSize);
186     if (theErr != noErr) {
187         error = "FSGetForkSize";
188         goto bail;
189     }
190     
191     /* Allocate some memory for the XML data */
192     forkData = NewPtr (forkSize);
193     if(forkData == NULL) {
194         error = "NewPtr";
195         goto bail;
196     }
197     
198     theErr = FSReadFork (forkRefNum, fsFromStart, 0 /* offset location */, forkSize, forkData, &actualRead);
199     if(theErr != noErr) {
200         error = "FSReadFork";
201         goto bail;
202     }
203     
204     dataRef = CFDataCreate (kCFAllocatorDefault, (UInt8 *)forkData, forkSize);
205     if(dataRef == 0) {
206         error = "CFDataCreate";
207         goto bail;
208     }
209
210     propertyListRef = CFPropertyListCreateFromXMLData (kCFAllocatorDefault,
211                                                        dataRef,
212                                                        kCFPropertyListImmutable,
213                                                        NULL);
214     if (propertyListRef == NULL) {
215         error = "CFPropertyListCreateFromXMLData";
216         goto bail;
217     }
218
219     /* Now we got the Property List in memory. Parse it. */
220     
221     /* First, make sure the root item is a CFDictionary. If not, release and bail. */
222     if(CFGetTypeID(propertyListRef)== CFDictionaryGetTypeID())
223     {
224         CFDictionaryRef dictRef = (CFDictionaryRef)propertyListRef;
225         
226         CFDataRef   theRawTOCDataRef;
227         CFArrayRef  theSessionArrayRef;
228         CFIndex     numSessions;
229         CFIndex     index;
230         
231         /* This is how we get the Raw TOC Data */
232         theRawTOCDataRef = (CFDataRef)CFDictionaryGetValue (dictRef, CFSTR(kRawTOCDataString));
233         
234         /* Get the session array info. */
235         theSessionArrayRef = (CFArrayRef)CFDictionaryGetValue (dictRef, CFSTR(kSessionsString));
236         
237         /* Find out how many sessions there are. */
238         numSessions = CFArrayGetCount (theSessionArrayRef);
239         
240         /* Initialize the total number of tracks to 0 */
241         theCD->numtracks = 0;
242         
243         /* Iterate over all sessions, collecting the track data */
244         for(index = 0; index < numSessions; index++)
245         {
246             CFDictionaryRef theSessionDict;
247             CFNumberRef     leadoutBlock;
248             CFArrayRef      trackArray;
249             CFIndex         numTracks;
250             CFIndex         trackIndex;
251             UInt32          value = 0;
252             
253             theSessionDict      = (CFDictionaryRef) CFArrayGetValueAtIndex (theSessionArrayRef, index);
254             leadoutBlock        = (CFNumberRef) CFDictionaryGetValue (theSessionDict, CFSTR(kLeadoutBlockString));
255             
256             trackArray = (CFArrayRef)CFDictionaryGetValue (theSessionDict, CFSTR(kTrackArrayString));
257             
258             numTracks = CFArrayGetCount (trackArray);
259
260             for(trackIndex = 0; trackIndex < numTracks; trackIndex++) {
261                     
262                 CFDictionaryRef theTrackDict;
263                 CFNumberRef     trackNumber;
264                 CFNumberRef     sessionNumber;
265                 CFNumberRef     startBlock;
266                 CFBooleanRef    isDataTrack;
267                 UInt32          value;
268                 
269                 theTrackDict  = (CFDictionaryRef) CFArrayGetValueAtIndex (trackArray, trackIndex);
270                 
271                 trackNumber   = (CFNumberRef)  CFDictionaryGetValue (theTrackDict, CFSTR(kPointKeyString));
272                 sessionNumber = (CFNumberRef)  CFDictionaryGetValue (theTrackDict, CFSTR(kSessionNumberKeyString));
273                 startBlock    = (CFNumberRef)  CFDictionaryGetValue (theTrackDict, CFSTR(kStartBlockKeyString));
274                 isDataTrack   = (CFBooleanRef) CFDictionaryGetValue (theTrackDict, CFSTR(kDataKeyString));
275                                                         
276                 /* Fill in the SDL_CD struct */
277                 int idx = theCD->numtracks++;
278
279                 CFNumberGetValue (trackNumber, kCFNumberSInt32Type, &value);
280                 theCD->track[idx].id = value;
281                 
282                 CFNumberGetValue (startBlock, kCFNumberSInt32Type, &value);
283                 theCD->track[idx].offset = value;
284
285                 theCD->track[idx].type = (isDataTrack == kCFBooleanTrue) ? SDL_DATA_TRACK : SDL_AUDIO_TRACK;
286
287                 /* Since the track lengths are not stored in .TOC.plist we compute them. */
288                 if (trackIndex > 0) {
289                     theCD->track[idx-1].length = theCD->track[idx].offset - theCD->track[idx-1].offset;
290                 }
291             }
292             
293             /* Compute the length of the last track */
294             CFNumberGetValue (leadoutBlock, kCFNumberSInt32Type, &value);
295             
296             theCD->track[theCD->numtracks-1].length = 
297                 value - theCD->track[theCD->numtracks-1].offset;
298
299             /* Set offset to leadout track */
300             theCD->track[theCD->numtracks].offset = value;
301         }
302     
303     }
304
305     theErr = 0;
306     goto cleanup;
307 bail:
308     SDL_SetError ("ReadTOCData: %s returned %d", error, theErr);
309     theErr = -1;
310 cleanup:
311
312     if (propertyListRef != NULL)
313         CFRelease(propertyListRef);
314     if (dataRef != NULL)
315         CFRelease(dataRef);
316     if (forkData != NULL)
317         DisposePtr(forkData);
318         
319     FSCloseFork (forkRefNum);
320
321     return theErr;
322 }
323
324 int ListTrackFiles (FSVolumeRefNum theVolume, FSRef *trackFiles, int numTracks)
325 {
326     OSStatus        result = -1;
327     FSIterator      iterator;
328     ItemCount       actualObjects;
329     FSRef           rootDirectory;
330     FSRef           ref;
331     HFSUniStr255    nameStr;
332     
333     result = FSGetVolumeInfo (theVolume,
334                               0,
335                               NULL,
336                               kFSVolInfoFSInfo,
337                               NULL,
338                               NULL,
339                               &rootDirectory); 
340                                  
341     if (result != noErr) {
342         SDL_SetError ("ListTrackFiles: FSGetVolumeInfo returned %d", result);
343         return result;
344     }
345
346     result = FSOpenIterator (&rootDirectory, kFSIterateFlat, &iterator);
347     if (result == noErr) {
348         do
349         {
350             result = FSGetCatalogInfoBulk (iterator, 1, &actualObjects,
351                                            NULL, kFSCatInfoNone, NULL, &ref, NULL, &nameStr);
352             if (result == noErr) {
353                 
354                 CFStringRef  name;
355                 name = CFStringCreateWithCharacters (NULL, nameStr.unicode, nameStr.length);
356                 
357                 /* Look for .aiff extension */
358                 if (CFStringHasSuffix (name, CFSTR(".aiff")) ||
359                     CFStringHasSuffix (name, CFSTR(".cdda"))) {
360                     
361                     /* Extract the track id from the filename */
362                     int trackID = 0, i = 0;
363                     while (i < nameStr.length && !isdigit(nameStr.unicode[i])) {
364                         ++i;
365                     }
366                     while (i < nameStr.length && isdigit(nameStr.unicode[i])) {
367                         trackID = 10 * trackID +(nameStr.unicode[i] - '0');
368                         ++i;
369                     }
370
371                     #if DEBUG_CDROM
372                     printf("Found AIFF for track %d: '%s'\n", trackID, 
373                     CFStringGetCStringPtr (name, CFStringGetSystemEncoding()));
374                     #endif
375                     
376                     /* Track ID's start at 1, but we want to start at 0 */
377                     trackID--;
378                     
379                     assert(0 <= trackID && trackID <= SDL_MAX_TRACKS);
380                     
381                     if (trackID < numTracks)
382                         memcpy (&trackFiles[trackID], &ref, sizeof(FSRef));
383                 }
384                 CFRelease (name);
385             }
386         } while(noErr == result);
387         FSCloseIterator (iterator);
388     }
389     
390     return 0;
391 }
392
393 int LoadFile (const FSRef *ref, int startFrame, int stopFrame)
394 {
395     int error = -1;
396     
397     if (CheckInit () < 0)
398         goto bail;
399     
400     /* release any currently playing file */
401     if (ReleaseFile () < 0)
402         goto bail;
403     
404     #if DEBUG_CDROM
405     printf ("LoadFile: %d %d\n", startFrame, stopFrame);
406     #endif
407     
408     /*try {*/
409     
410         /* create a new player, and attach to the audio unit */
411         
412         thePlayer = new_AudioFilePlayer(ref);
413         if (thePlayer == NULL) {
414             SDL_SetError ("LoadFile: Could not create player");
415             return -3; /*throw (-3);*/
416         }
417             
418         if (!thePlayer->SetDestination(thePlayer, &theUnit))
419             goto bail;
420         
421         if (startFrame >= 0)
422             thePlayer->SetStartFrame (thePlayer, startFrame);
423         
424         if (stopFrame >= 0 && stopFrame > startFrame)
425             thePlayer->SetStopFrame (thePlayer, stopFrame);
426         
427         /* we set the notifier later */
428         /*thePlayer->SetNotifier(thePlayer, FilePlayNotificationHandler, NULL);*/
429             
430         if (!thePlayer->Connect(thePlayer))
431             goto bail;
432     
433         #if DEBUG_CDROM
434         thePlayer->Print(thePlayer);
435         fflush (stdout);
436         #endif
437     /*}
438       catch (...)
439       {
440           goto bail;
441       }*/
442         
443     error = 0;
444
445     bail:
446     return error;
447 }
448
449 int ReleaseFile ()
450 {
451     int error = -1;
452         
453     /* (Don't see any way that the original C++ code could throw here.) --ryan. */
454     /*try {*/
455         if (thePlayer != NULL) {
456             
457             thePlayer->Disconnect(thePlayer);
458             
459             delete_AudioFilePlayer(thePlayer);
460             
461             thePlayer = NULL;
462         }
463     /*}
464       catch (...)
465       {
466           goto bail;
467       }*/
468     
469     error = 0;
470     
471 /*  bail: */
472     return error;
473 }
474
475 int PlayFile ()
476 {
477     OSStatus result = -1;
478     
479     if (CheckInit () < 0)
480         goto bail;
481         
482     /*try {*/
483     
484         // start processing of the audio unit
485         result = AudioOutputUnitStart (theUnit);
486             if (result) goto bail; //THROW_RESULT("PlayFile: AudioOutputUnitStart")
487         
488     /*}
489     catch (...)
490     {
491         goto bail;
492     }*/
493     
494     result = 0;
495     
496 bail:
497     return result;
498 }
499
500 int PauseFile ()
501 {
502     OSStatus result = -1;
503     
504     if (CheckInit () < 0)
505         goto bail;
506             
507     /*try {*/
508     
509         /* stop processing the audio unit */
510         result = AudioOutputUnitStop (theUnit);
511             if (result) goto bail;  /*THROW_RESULT("PauseFile: AudioOutputUnitStop")*/
512     /*}
513       catch (...)
514       {
515           goto bail;
516       }*/
517     
518     result = 0;
519 bail:
520     return result;
521 }
522
523 void SetCompletionProc (CDPlayerCompletionProc proc, SDL_CD *cdrom)
524 {
525     assert(thePlayer != NULL);
526
527     theCDROM = cdrom;
528     completionProc = proc;
529     thePlayer->SetNotifier (thePlayer, FilePlayNotificationHandler, cdrom);
530 }
531
532 int GetCurrentFrame ()
533 {    
534     int frame;
535     
536     if (thePlayer == NULL)
537         frame = 0;
538     else
539         frame = thePlayer->GetCurrentFrame (thePlayer);
540         
541     return frame; 
542 }
543
544
545 #pragma mark -- Private Functions --
546
547 static OSStatus CheckInit ()
548 {    
549     if (playBackWasInit)
550         return 0;
551     
552     OSStatus result = noErr;
553     
554     /* Create the callback semaphore */
555     callbackSem = SDL_CreateSemaphore(0);
556
557     /* Start callback thread */
558     SDL_CreateThread(RunCallBackThread, NULL);
559
560     { /*try {*/
561         ComponentDescription desc;
562     
563         desc.componentType = kAudioUnitType_Output;
564         desc.componentSubType = kAudioUnitSubType_DefaultOutput;
565         desc.componentManufacturer = kAudioUnitManufacturer_Apple;
566         desc.componentFlags = 0;
567         desc.componentFlagsMask = 0;
568         
569         Component comp = FindNextComponent (NULL, &desc);
570         if (comp == NULL) {
571             SDL_SetError ("CheckInit: FindNextComponent returned NULL");
572             if (result) return -1; //throw(internalComponentErr);
573         }
574         
575         result = OpenAComponent (comp, &theUnit);
576             if (result) return -1; //THROW_RESULT("CheckInit: OpenAComponent")
577                     
578         // you need to initialize the output unit before you set it as a destination
579         result = AudioUnitInitialize (theUnit);
580             if (result) return -1; //THROW_RESULT("CheckInit: AudioUnitInitialize")
581         
582                     
583         playBackWasInit = true;
584     }
585     /*catch (...)
586       {
587           return -1;
588       }*/
589     
590     return 0;
591 }
592
593 static void FilePlayNotificationHandler(void * inRefCon, OSStatus inStatus)
594 {
595     if (inStatus == kAudioFilePlay_FileIsFinished) {
596     
597         /* notify non-CA thread to perform the callback */
598         SDL_SemPost(callbackSem);
599         
600     } else if (inStatus == kAudioFilePlayErr_FilePlayUnderrun) {
601     
602         SDL_SetError ("CDPlayer Notification: buffer underrun");
603     } else if (inStatus == kAudioFilePlay_PlayerIsUninitialized) {
604     
605         SDL_SetError ("CDPlayer Notification: player is uninitialized");
606     } else {
607         
608         SDL_SetError ("CDPlayer Notification: unknown error %ld", inStatus);
609     }
610 }
611
612 static int RunCallBackThread (void *param)
613 {
614     for (;;) {
615     
616         SDL_SemWait(callbackSem);
617
618         if (completionProc && theCDROM) {
619             #if DEBUG_CDROM
620             printf ("callback!\n");
621             #endif
622             (*completionProc)(theCDROM);
623         } else {
624             #if DEBUG_CDROM
625             printf ("callback?\n");
626             #endif
627         }
628     }
629     
630     #if DEBUG_CDROM
631     printf ("thread dying now...\n");
632     #endif
633     
634     return 0;
635 }
636
637 /*}; // extern "C" */