/* Copyright (c) 2010 Steve Oldmeadow Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. $Id$ */ #import "CocosDenshion.h" ALvoid alBufferDataStaticProc(const ALint bid, ALenum format, ALvoid* data, ALsizei size, ALsizei freq); ALvoid alcMacOSXMixerOutputRateProc(const ALdouble value); typedef ALvoid AL_APIENTRY (*alBufferDataStaticProcPtr) (const ALint bid, ALenum format, ALvoid* data, ALsizei size, ALsizei freq); ALvoid alBufferDataStaticProc(const ALint bid, ALenum format, ALvoid* data, ALsizei size, ALsizei freq) { static alBufferDataStaticProcPtr proc = NULL; if (proc == NULL) { proc = (alBufferDataStaticProcPtr) alcGetProcAddress(NULL, (const ALCchar*) "alBufferDataStatic"); } if (proc) proc(bid, format, data, size, freq); return; } typedef ALvoid AL_APIENTRY (*alcMacOSXMixerOutputRateProcPtr) (const ALdouble value); ALvoid alcMacOSXMixerOutputRateProc(const ALdouble value) { static alcMacOSXMixerOutputRateProcPtr proc = NULL; if (proc == NULL) { proc = (alcMacOSXMixerOutputRateProcPtr) alcGetProcAddress(NULL, (const ALCchar*) "alcMacOSXMixerOutputRate"); } if (proc) proc(value); return; } NSString * const kCDN_BadAlContext = @"kCDN_BadAlContext"; NSString * const kCDN_AsynchLoadComplete = @"kCDN_AsynchLoadComplete"; float const kCD_PitchDefault = 1.0f; float const kCD_PitchLowerOneOctave = 0.5f; float const kCD_PitchHigherOneOctave = 2.0f; float const kCD_PanDefault = 0.0f; float const kCD_PanFullLeft = -1.0f; float const kCD_PanFullRight = 1.0f; float const kCD_GainDefault = 1.0f; @interface CDSoundEngine (PrivateMethods) -(BOOL) _initOpenAL; -(void) _testGetGain; -(void) _dumpSourceGroupsInfo; -(void) _getSourceIndexForSourceGroup; -(void) _freeSourceGroups; -(BOOL) _setUpSourceGroups:(int[]) definitions total:(NSUInteger) total; @end #pragma mark - #pragma mark CDUtilities @implementation CDUtilities +(NSString*) fullPathFromRelativePath:(NSString*) relPath { // do not convert an absolute path (starting with '/') if(([relPath length] > 0) && ([relPath characterAtIndex:0] == '/')) { return relPath; } NSMutableArray *imagePathComponents = [NSMutableArray arrayWithArray:[relPath pathComponents]]; NSString *file = [imagePathComponents lastObject]; [imagePathComponents removeLastObject]; NSString *imageDirectory = [NSString pathWithComponents:imagePathComponents]; NSString *fullpath = [[NSBundle mainBundle] pathForResource:file ofType:nil inDirectory:imageDirectory]; if (fullpath == nil) fullpath = relPath; return fullpath; } @end #pragma mark - #pragma mark CDSoundEngine @implementation CDSoundEngine static Float32 _mixerSampleRate; static BOOL _mixerRateSet = NO; @synthesize lastErrorCode = lastErrorCode_; @synthesize functioning = functioning_; @synthesize asynchLoadProgress = asynchLoadProgress_; @synthesize getGainWorks = getGainWorks_; @synthesize sourceTotal = sourceTotal_; + (void) setMixerSampleRate:(Float32) sampleRate { _mixerRateSet = YES; _mixerSampleRate = sampleRate; } - (void) _testGetGain { float testValue = 0.7f; ALuint testSourceId = _sources[0].sourceId; alSourcef(testSourceId, AL_GAIN, 0.0f);//Start from know value alSourcef(testSourceId, AL_GAIN, testValue); ALfloat gainVal; alGetSourcef(testSourceId, AL_GAIN, &gainVal); getGainWorks_ = (gainVal == testValue); } //Generate sources one at a time until we fail -(void) _generateSources { _sources = (sourceInfo*)malloc( sizeof(_sources[0]) * CD_SOURCE_LIMIT); BOOL hasFailed = NO; sourceTotal_ = 0; alGetError();//Clear error while (!hasFailed && sourceTotal_ < CD_SOURCE_LIMIT) { alGenSources(1, &(_sources[sourceTotal_].sourceId)); if (alGetError() == AL_NO_ERROR) { //Now try attaching source to null buffer alSourcei(_sources[sourceTotal_].sourceId, AL_BUFFER, 0); if (alGetError() == AL_NO_ERROR) { _sources[sourceTotal_].usable = true; sourceTotal_++; } else { hasFailed = YES; } } else { _sources[sourceTotal_].usable = false; hasFailed = YES; } } //Mark the rest of the sources as not usable for (int i=sourceTotal_; i < CD_SOURCE_LIMIT; i++) { _sources[i].usable = false; } } -(void) _generateBuffers:(int) startIndex endIndex:(int) endIndex { if (_buffers) { alGetError(); for (int i=startIndex; i <= endIndex; i++) { alGenBuffers(1, &_buffers[i].bufferId); _buffers[i].bufferData = NULL; if (alGetError() == AL_NO_ERROR) { _buffers[i].bufferState = CD_BS_EMPTY; } else { _buffers[i].bufferState = CD_BS_FAILED; CDLOG(@"Denshion::CDSoundEngine - buffer creation failed %i",i); } } } } /** * Internal method called during init */ - (BOOL) _initOpenAL { //ALenum error; context = NULL; ALCdevice *newDevice = NULL; //Set the mixer rate for the audio mixer if (!_mixerRateSet) { _mixerSampleRate = CD_SAMPLE_RATE_DEFAULT; } alcMacOSXMixerOutputRateProc(_mixerSampleRate); CDLOGINFO(@"Denshion::CDSoundEngine - mixer output rate set to %0.2f",_mixerSampleRate); // Create a new OpenAL Device // Pass NULL to specify the system's default output device newDevice = alcOpenDevice(NULL); if (newDevice != NULL) { // Create a new OpenAL Context // The new context will render to the OpenAL Device just created context = alcCreateContext(newDevice, 0); if (context != NULL) { // Make the new context the Current OpenAL Context alcMakeContextCurrent(context); // Create some OpenAL Buffer Objects [self _generateBuffers:0 endIndex:bufferTotal-1]; // Create some OpenAL Source Objects [self _generateSources]; } } else { return FALSE;//No device } alGetError();//Clear error return TRUE; } - (void) dealloc { ALCcontext *currentContext = NULL; ALCdevice *device = NULL; [self stopAllSounds]; CDLOGINFO(@"Denshion::CDSoundEngine - Deallocing sound engine."); [self _freeSourceGroups]; // Delete the Sources CDLOGINFO(@"Denshion::CDSoundEngine - deleting sources."); for (int i=0; i < sourceTotal_; i++) { alSourcei(_sources[i].sourceId, AL_BUFFER, 0);//Detach from current buffer alDeleteSources(1, &(_sources[i].sourceId)); if((lastErrorCode_ = alGetError()) != AL_NO_ERROR) { CDLOG(@"Denshion::CDSoundEngine - Error deleting source! %x\n", lastErrorCode_); } } // Delete the Buffers CDLOGINFO(@"Denshion::CDSoundEngine - deleting buffers."); for (int i=0; i < bufferTotal; i++) { alDeleteBuffers(1, &_buffers[i].bufferId); #ifdef CD_USE_STATIC_BUFFERS if (_buffers[i].bufferData) { free(_buffers[i].bufferData); } #endif } CDLOGINFO(@"Denshion::CDSoundEngine - free buffers."); free(_buffers); currentContext = alcGetCurrentContext(); //Get device for active context device = alcGetContextsDevice(currentContext); //Release context CDLOGINFO(@"Denshion::CDSoundEngine - destroy context."); alcDestroyContext(currentContext); //Close device CDLOGINFO(@"Denshion::CDSoundEngine - close device."); alcCloseDevice(device); CDLOGINFO(@"Denshion::CDSoundEngine - free sources."); free(_sources); //Release mutexes [_mutexBufferLoad release]; [super dealloc]; } -(NSUInteger) sourceGroupTotal { return _sourceGroupTotal; } -(void) _freeSourceGroups { CDLOGINFO(@"Denshion::CDSoundEngine freeing source groups"); if(_sourceGroups) { for (int i=0; i < _sourceGroupTotal; i++) { if (_sourceGroups[i].sourceStatuses) { free(_sourceGroups[i].sourceStatuses); CDLOGINFO(@"Denshion::CDSoundEngine freed source statuses %i",i); } } free(_sourceGroups); } } -(BOOL) _redefineSourceGroups:(int[]) definitions total:(NSUInteger) total { if (_sourceGroups) { //Stop all sounds [self stopAllSounds]; //Need to free source groups [self _freeSourceGroups]; } return [self _setUpSourceGroups:definitions total:total]; } -(BOOL) _setUpSourceGroups:(int[]) definitions total:(NSUInteger) total { _sourceGroups = (sourceGroup *)malloc( sizeof(_sourceGroups[0]) * total); if(!_sourceGroups) { CDLOG(@"Denshion::CDSoundEngine - source groups memory allocation failed"); return NO; } _sourceGroupTotal = total; int sourceCount = 0; for (int i=0; i < _sourceGroupTotal; i++) { _sourceGroups[i].startIndex = 0; _sourceGroups[i].currentIndex = _sourceGroups[i].startIndex; _sourceGroups[i].enabled = false; _sourceGroups[i].nonInterruptible = false; _sourceGroups[i].totalSources = definitions[i]; _sourceGroups[i].sourceStatuses = malloc(sizeof(_sourceGroups[i].sourceStatuses[0]) * _sourceGroups[i].totalSources); if (_sourceGroups[i].sourceStatuses) { for (int j=0; j < _sourceGroups[i].totalSources; j++) { //First bit is used to indicate whether source is locked, index is shifted back 1 bit _sourceGroups[i].sourceStatuses[j] = (sourceCount + j) << 1; } } sourceCount += definitions[i]; } return YES; } -(void) defineSourceGroups:(int[]) sourceGroupDefinitions total:(NSUInteger) total { [self _redefineSourceGroups:sourceGroupDefinitions total:total]; } -(void) defineSourceGroups:(NSArray*) sourceGroupDefinitions { CDLOGINFO(@"Denshion::CDSoundEngine - source groups defined by NSArray."); NSUInteger totalDefs = [sourceGroupDefinitions count]; int* defs = (int *)malloc( sizeof(int) * totalDefs); int currentIndex = 0; for (id currentDef in sourceGroupDefinitions) { if ([currentDef isKindOfClass:[NSNumber class]]) { defs[currentIndex] = (int)[(NSNumber*)currentDef integerValue]; CDLOGINFO(@"Denshion::CDSoundEngine - found definition %i.",defs[currentIndex]); } else { CDLOG(@"Denshion::CDSoundEngine - warning, did not understand source definition."); defs[currentIndex] = 0; } currentIndex++; } [self _redefineSourceGroups:defs total:totalDefs]; free(defs); } - (id)init { if ((self = [super init])) { //Create mutexes _mutexBufferLoad = [[NSObject alloc] init]; asynchLoadProgress_ = 0.0f; bufferTotal = CD_BUFFERS_START; _buffers = (bufferInfo *)malloc( sizeof(_buffers[0]) * bufferTotal); // Initialize our OpenAL environment if ([self _initOpenAL]) { //Set up the default source group - a single group that contains all the sources int sourceDefs[1]; sourceDefs[0] = self.sourceTotal; [self _setUpSourceGroups:sourceDefs total:1]; functioning_ = YES; //Synchronize premute gain _preMuteGain = self.masterGain; mute_ = NO; enabled_ = YES; //Test whether get gain works for sources [self _testGetGain]; } else { //Something went wrong with OpenAL functioning_ = NO; } } return self; } /** * Delete the buffer identified by soundId * @return true if buffer deleted successfully, otherwise false */ - (BOOL) unloadBuffer:(int) soundId { //Ensure soundId is within array bounds otherwise memory corruption will occur if (soundId < 0 || soundId >= bufferTotal) { CDLOG(@"Denshion::CDSoundEngine - soundId is outside array bounds, maybe you need to increase CD_MAX_BUFFERS"); return FALSE; } //Before a buffer can be deleted any sources that are attached to it must be stopped for (int i=0; i < sourceTotal_; i++) { //Note: tried getting the AL_BUFFER attribute of the source instead but doesn't //appear to work on a device - just returned zero. if (_buffers[soundId].bufferId == _sources[i].attachedBufferId) { CDLOG(@"Denshion::CDSoundEngine - Found attached source %i %i %i",i,_buffers[soundId].bufferId,_sources[i].sourceId); #ifdef CD_USE_STATIC_BUFFERS //When using static buffers a crash may occur if a source is playing with a buffer that is about //to be deleted even though we stop the source and successfully delete the buffer. Crash is confirmed //on 2.2.1 and 3.1.2, however, it will only occur if a source is used rapidly after having its prior //data deleted. To avoid any possibility of the crash we wait for the source to finish playing. ALint state; alGetSourcei(_sources[i].sourceId, AL_SOURCE_STATE, &state); if (state == AL_PLAYING) { CDLOG(@"Denshion::CDSoundEngine - waiting for source to complete playing before removing buffer data"); alSourcei(_sources[i].sourceId, AL_LOOPING, FALSE);//Turn off looping otherwise loops will never end while (state == AL_PLAYING) { alGetSourcei(_sources[i].sourceId, AL_SOURCE_STATE, &state); usleep(10000); } } #endif //Stop source and detach alSourceStop(_sources[i].sourceId); if((lastErrorCode_ = alGetError()) != AL_NO_ERROR) { CDLOG(@"Denshion::CDSoundEngine - error stopping source: %x\n", lastErrorCode_); } alSourcei(_sources[i].sourceId, AL_BUFFER, 0);//Attach to "NULL" buffer to detach if((lastErrorCode_ = alGetError()) != AL_NO_ERROR) { CDLOG(@"Denshion::CDSoundEngine - error detaching buffer: %x\n", lastErrorCode_); } else { //Record that source is now attached to nothing _sources[i].attachedBufferId = 0; } } } alDeleteBuffers(1, &_buffers[soundId].bufferId); if((lastErrorCode_ = alGetError()) != AL_NO_ERROR) { CDLOG(@"Denshion::CDSoundEngine - error deleting buffer: %x\n", lastErrorCode_); _buffers[soundId].bufferState = CD_BS_FAILED; return FALSE; } else { #ifdef CD_USE_STATIC_BUFFERS //Free previous data, if alDeleteBuffer has returned without error then no if (_buffers[soundId].bufferData) { CDLOGINFO(@"Denshion::CDSoundEngine - freeing static data for soundId %i @ %i",soundId,_buffers[soundId].bufferData); free(_buffers[soundId].bufferData);//Free the old data _buffers[soundId].bufferData = NULL; } #endif } alGenBuffers(1, &_buffers[soundId].bufferId); if((lastErrorCode_ = alGetError()) != AL_NO_ERROR) { CDLOG(@"Denshion::CDSoundEngine - error regenerating buffer: %x\n", lastErrorCode_); _buffers[soundId].bufferState = CD_BS_FAILED; return FALSE; } else { //We now have an empty buffer _buffers[soundId].bufferState = CD_BS_EMPTY; CDLOGINFO(@"Denshion::CDSoundEngine - buffer %i successfully unloaded\n",soundId); return TRUE; } } /** * Load buffers asynchronously * Check asynchLoadProgress for progress. asynchLoadProgress represents fraction of completion. When it equals 1.0 loading * is complete. NB: asynchLoadProgress is simply based on the number of load requests, it does not take into account * file sizes. * @param An array of CDBufferLoadRequest objects */ - (void) loadBuffersAsynchronously:(NSArray *) loadRequests { @synchronized(self) { asynchLoadProgress_ = 0.0f; CDAsynchBufferLoader *loaderOp = [[[CDAsynchBufferLoader alloc] init:loadRequests soundEngine:self] autorelease]; NSOperationQueue *opQ = [[[NSOperationQueue alloc] init] autorelease]; [opQ addOperation:loaderOp]; } } -(BOOL) _resizeBuffers:(int) increment { void * tmpBufferInfos = realloc( _buffers, sizeof(_buffers[0]) * (bufferTotal + increment) ); if(!tmpBufferInfos) { free(tmpBufferInfos); return NO; } else { _buffers = tmpBufferInfos; int oldBufferTotal = bufferTotal; bufferTotal = bufferTotal + increment; [self _generateBuffers:oldBufferTotal endIndex:bufferTotal-1]; return YES; } } -(BOOL) loadBufferFromData:(int) soundId soundData:(ALvoid*) soundData format:(ALenum) format size:(ALsizei) size freq:(ALsizei) freq { @synchronized(_mutexBufferLoad) { if (!functioning_) { //OpenAL initialisation has previously failed CDLOG(@"Denshion::CDSoundEngine - Loading buffer failed because sound engine state != functioning"); return FALSE; } //Ensure soundId is within array bounds otherwise memory corruption will occur if (soundId < 0) { CDLOG(@"Denshion::CDSoundEngine - soundId is negative"); return FALSE; } if (soundId >= bufferTotal) { //Need to resize the buffers int requiredIncrement = CD_BUFFERS_INCREMENT; while (bufferTotal + requiredIncrement < soundId) { requiredIncrement += CD_BUFFERS_INCREMENT; } CDLOGINFO(@"Denshion::CDSoundEngine - attempting to resize buffers by %i for sound %i",requiredIncrement,soundId); if (![self _resizeBuffers:requiredIncrement]) { CDLOG(@"Denshion::CDSoundEngine - buffer resize failed"); return FALSE; } } if (soundData) { if (_buffers[soundId].bufferState != CD_BS_EMPTY) { CDLOGINFO(@"Denshion::CDSoundEngine - non empty buffer, regenerating"); if (![self unloadBuffer:soundId]) { //Deletion of buffer failed, delete buffer routine has set buffer state and lastErrorCode return NO; } } #ifdef CD_DEBUG //Check that sample rate matches mixer rate and warn if they do not if (freq != (int)_mixerSampleRate) { CDLOGINFO(@"Denshion::CDSoundEngine - WARNING sample rate does not match mixer sample rate performance may not be optimal."); } #endif #ifdef CD_USE_STATIC_BUFFERS alBufferDataStaticProc(_buffers[soundId].bufferId, format, soundData, size, freq); _buffers[soundId].bufferData = data;//Save the pointer to the new data #else alBufferData(_buffers[soundId].bufferId, format, soundData, size, freq); #endif if((lastErrorCode_ = alGetError()) != AL_NO_ERROR) { CDLOG(@"Denshion::CDSoundEngine - error attaching audio to buffer: %x", lastErrorCode_); _buffers[soundId].bufferState = CD_BS_FAILED; return FALSE; } } else { CDLOG(@"Denshion::CDSoundEngine Buffer data is null!"); _buffers[soundId].bufferState = CD_BS_FAILED; return FALSE; } _buffers[soundId].format = format; _buffers[soundId].sizeInBytes = size; _buffers[soundId].frequencyInHertz = freq; _buffers[soundId].bufferState = CD_BS_LOADED; CDLOGINFO(@"Denshion::CDSoundEngine Buffer %i loaded format:%i freq:%i size:%i",soundId,format,freq,size); return TRUE; }//end mutex } /** * Load sound data for later play back. * @return TRUE if buffer loaded okay for play back otherwise false */ - (BOOL) loadBuffer:(int) soundId filePath:(NSString*) filePath { ALvoid* data; ALenum format; ALsizei size; ALsizei freq; CDLOGINFO(@"Denshion::CDSoundEngine - Loading openAL buffer %i %@", soundId, filePath); CFURLRef fileURL = nil; NSString *path = [CDUtilities fullPathFromRelativePath:filePath]; if (path) { fileURL = (CFURLRef)[[NSURL fileURLWithPath:path] retain]; } if (fileURL) { data = CDGetOpenALAudioData(fileURL, &size, &format, &freq); CFRelease(fileURL); BOOL result = [self loadBufferFromData:soundId soundData:data format:format size:size freq:freq]; #ifndef CD_USE_STATIC_BUFFERS free(data);//Data can be freed here because alBufferData performs a memcpy #endif return result; } else { CDLOG(@"Denshion::CDSoundEngine Could not find file!\n"); //Don't change buffer state here as it will be the same as before method was called return FALSE; } } -(BOOL) validateBufferId:(int) soundId { if (soundId < 0 || soundId >= bufferTotal) { CDLOGINFO(@"Denshion::CDSoundEngine - validateBufferId buffer outside range %i",soundId); return NO; } else if (_buffers[soundId].bufferState != CD_BS_LOADED) { CDLOGINFO(@"Denshion::CDSoundEngine - validateBufferId invalide buffer state %i",soundId); return NO; } else { return YES; } } -(float) bufferDurationInSeconds:(int) soundId { if ([self validateBufferId:soundId]) { float factor = 0.0f; switch (_buffers[soundId].format) { case AL_FORMAT_MONO8: factor = 1.0f; break; case AL_FORMAT_MONO16: factor = 0.5f; break; case AL_FORMAT_STEREO8: factor = 0.5f; break; case AL_FORMAT_STEREO16: factor = 0.25f; break; } return (float)_buffers[soundId].sizeInBytes/(float)_buffers[soundId].frequencyInHertz * factor; } else { return -1.0f; } } -(ALsizei) bufferSizeInBytes:(int) soundId { if ([self validateBufferId:soundId]) { return _buffers[soundId].sizeInBytes; } else { return -1.0f; } } -(ALsizei) bufferFrequencyInHertz:(int) soundId { if ([self validateBufferId:soundId]) { return _buffers[soundId].frequencyInHertz; } else { return -1.0f; } } - (ALfloat) masterGain { if (mute_) { //When mute the real gain will always be 0 therefore return the preMuteGain value return _preMuteGain; } else { ALfloat gain; alGetListenerf(AL_GAIN, &gain); return gain; } } /** * Overall gain setting multiplier. e.g 0.5 is half the gain. */ - (void) setMasterGain:(ALfloat) newGainValue { if (mute_) { _preMuteGain = newGainValue; } else { alListenerf(AL_GAIN, newGainValue); } } #pragma mark CDSoundEngine AudioInterrupt protocol - (BOOL) mute { return mute_; } /** * Setting mute silences all sounds but playing sounds continue to advance playback */ - (void) setMute:(BOOL) newMuteValue { if (newMuteValue == mute_) { return; } mute_ = newMuteValue; if (mute_) { //Remember what the gain was _preMuteGain = self.masterGain; //Set gain to 0 - do not use the property as this will adjust preMuteGain when muted alListenerf(AL_GAIN, 0.0f); } else { //Restore gain to what it was before being muted self.masterGain = _preMuteGain; } } - (BOOL) enabled { return enabled_; } - (void) setEnabled:(BOOL)enabledValue { if (enabled_ == enabledValue) { return; } enabled_ = enabledValue; if (enabled_ == NO) { [self stopAllSounds]; } } -(void) _lockSource:(int) sourceIndex lock:(BOOL) lock { BOOL found = NO; for (int i=0; i < _sourceGroupTotal && !found; i++) { if (_sourceGroups[i].sourceStatuses) { for (int j=0; j < _sourceGroups[i].totalSources && !found; j++) { //First bit is used to indicate whether source is locked, index is shifted back 1 bit if((_sourceGroups[i].sourceStatuses[j] >> 1)==sourceIndex) { if (lock) { //Set first bit to lock this source _sourceGroups[i].sourceStatuses[j] |= 1; } else { //Unset first bit to unlock this source _sourceGroups[i].sourceStatuses[j] &= ~1; } found = YES; } } } } } -(int) _getSourceIndexForSourceGroup:(int)sourceGroupId { //Ensure source group id is valid to prevent memory corruption if (sourceGroupId < 0 || sourceGroupId >= _sourceGroupTotal) { CDLOG(@"Denshion::CDSoundEngine invalid source group id %i",sourceGroupId); return CD_NO_SOURCE; } int sourceIndex = -1;//Using -1 to indicate no source found BOOL complete = NO; ALint sourceState = 0; sourceGroup *thisSourceGroup = &_sourceGroups[sourceGroupId]; thisSourceGroup->currentIndex = thisSourceGroup->startIndex; while (!complete) { //Iterate over sources looking for one that is not locked, first bit indicates if source is locked if ((thisSourceGroup->sourceStatuses[thisSourceGroup->currentIndex] & 1) == 0) { //This source is not locked sourceIndex = thisSourceGroup->sourceStatuses[thisSourceGroup->currentIndex] >> 1;//shift back to get the index if (thisSourceGroup->nonInterruptible) { //Check if this source is playing, if so it can't be interrupted alGetSourcei(_sources[sourceIndex].sourceId, AL_SOURCE_STATE, &sourceState); if (sourceState != AL_PLAYING) { //complete = YES; //Set start index so next search starts at the next position thisSourceGroup->startIndex = thisSourceGroup->currentIndex + 1; break; } else { sourceIndex = -1;//The source index was no good because the source was playing } } else { //complete = YES; //Set start index so next search starts at the next position thisSourceGroup->startIndex = thisSourceGroup->currentIndex + 1; break; } } thisSourceGroup->currentIndex++; if (thisSourceGroup->currentIndex >= thisSourceGroup->totalSources) { //Reset to the beginning thisSourceGroup->currentIndex = 0; } if (thisSourceGroup->currentIndex == thisSourceGroup->startIndex) { //We have looped around and got back to the start complete = YES; } } //Reset start index to beginning if beyond bounds if (thisSourceGroup->startIndex >= thisSourceGroup->totalSources) { thisSourceGroup->startIndex = 0; } if (sourceIndex >= 0) { return sourceIndex; } else { return CD_NO_SOURCE; } } /** * Play a sound. * @param soundId the id of the sound to play (buffer id). * @param SourceGroupId the source group that will be used to play the sound. * @param pitch pitch multiplier. e.g 1.0 is unaltered, 0.5 is 1 octave lower. * @param pan stereo position. -1 is fully left, 0 is centre and 1 is fully right. * @param gain gain multiplier. e.g. 1.0 is unaltered, 0.5 is half the gain * @param loop should the sound be looped or one shot. * @return the id of the source being used to play the sound or CD_MUTE if the sound engine is muted or non functioning * or CD_NO_SOURCE if a problem occurs setting up the source * */ - (ALuint)playSound:(int) soundId sourceGroupId:(int)sourceGroupId pitch:(float) pitch pan:(float) pan gain:(float) gain loop:(BOOL) loop { #ifdef CD_DEBUG //Sanity check parameters - only in DEBUG NSAssert(soundId >= 0, @"soundId can not be negative"); NSAssert(soundId < bufferTotal, @"soundId exceeds limit"); NSAssert(sourceGroupId >= 0, @"sourceGroupId can not be negative"); NSAssert(sourceGroupId < _sourceGroupTotal, @"sourceGroupId exceeds limit"); NSAssert(pitch > 0, @"pitch must be greater than zero"); NSAssert(pan >= -1 && pan <= 1, @"pan must be between -1 and 1"); NSAssert(gain >= 0, @"gain can not be negative"); #endif //If mute or initialisation has failed or buffer is not loaded then do nothing if (!enabled_ || !functioning_ || _buffers[soundId].bufferState != CD_BS_LOADED || _sourceGroups[sourceGroupId].enabled) { #ifdef CD_DEBUG if (!functioning_) { CDLOGINFO(@"Denshion::CDSoundEngine - sound playback aborted because sound engine is not functioning"); } else if (_buffers[soundId].bufferState != CD_BS_LOADED) { CDLOGINFO(@"Denshion::CDSoundEngine - sound playback aborted because buffer %i is not loaded", soundId); } #endif return CD_MUTE; } int sourceIndex = [self _getSourceIndexForSourceGroup:sourceGroupId];//This method ensures sourceIndex is valid if (sourceIndex != CD_NO_SOURCE) { ALint state; ALuint source = _sources[sourceIndex].sourceId; ALuint buffer = _buffers[soundId].bufferId; alGetError();//Clear the error code alGetSourcei(source, AL_SOURCE_STATE, &state); if (state == AL_PLAYING) { alSourceStop(source); } alSourcei(source, AL_BUFFER, buffer);//Attach to sound alSourcef(source, AL_PITCH, pitch);//Set pitch alSourcei(source, AL_LOOPING, loop);//Set looping alSourcef(source, AL_GAIN, gain);//Set gain/volume float sourcePosAL[] = {pan, 0.0f, 0.0f};//Set position - just using left and right panning alSourcefv(source, AL_POSITION, sourcePosAL); alGetError();//Clear the error code alSourcePlay(source); if((lastErrorCode_ = alGetError()) == AL_NO_ERROR) { //Everything was okay _sources[sourceIndex].attachedBufferId = buffer; return source; } else { if (alcGetCurrentContext() == NULL) { CDLOGINFO(@"Denshion::CDSoundEngine - posting bad OpenAL context message"); [[NSNotificationCenter defaultCenter] postNotificationName:kCDN_BadAlContext object:nil]; } return CD_NO_SOURCE; } } else { return CD_NO_SOURCE; } } -(BOOL) _soundSourceAttachToBuffer:(CDSoundSource*) soundSource soundId:(int) soundId { //Attach the source to the buffer ALint state; ALuint source = soundSource->_sourceId; ALuint buffer = _buffers[soundId].bufferId; alGetSourcei(source, AL_SOURCE_STATE, &state); if (state == AL_PLAYING) { alSourceStop(source); } alGetError();//Clear the error code alSourcei(source, AL_BUFFER, buffer);//Attach to sound data if((lastErrorCode_ = alGetError()) == AL_NO_ERROR) { _sources[soundSource->_sourceIndex].attachedBufferId = buffer; //_sourceBufferAttachments[soundSource->_sourceIndex] = buffer;//Keep track of which soundSource->_soundId = soundId; return YES; } else { return NO; } } /** * Get a sound source for the specified sound in the specified source group */ -(CDSoundSource *) soundSourceForSound:(int) soundId sourceGroupId:(int) sourceGroupId { if (!functioning_) { return nil; } //Check if a source is available int sourceIndex = [self _getSourceIndexForSourceGroup:sourceGroupId]; if (sourceIndex != CD_NO_SOURCE) { CDSoundSource *result = [[CDSoundSource alloc] init:_sources[sourceIndex].sourceId sourceIndex:sourceIndex soundEngine:self]; [self _lockSource:sourceIndex lock:YES]; //Try to attach to the buffer if ([self _soundSourceAttachToBuffer:result soundId:soundId]) { //Set to a known state result.pitch = 1.0f; result.pan = 0.0f; result.gain = 1.0f; result.looping = NO; return [result autorelease]; } else { //Release the sound source we just created, this will also unlock the source [result release]; return nil; } } else { //No available source within that source group return nil; } } -(void) _soundSourcePreRelease:(CDSoundSource *) soundSource { CDLOGINFO(@"Denshion::CDSoundEngine _soundSourcePreRelease %i",soundSource->_sourceIndex); //Unlock the sound source's source [self _lockSource:soundSource->_sourceIndex lock:NO]; } /** * Stop all sounds playing within a source group */ - (void) stopSourceGroup:(int) sourceGroupId { if (!functioning_ || sourceGroupId >= _sourceGroupTotal || sourceGroupId < 0) { return; } int sourceCount = _sourceGroups[sourceGroupId].totalSources; for (int i=0; i < sourceCount; i++) { int sourceIndex = _sourceGroups[sourceGroupId].sourceStatuses[i] >> 1; alSourceStop(_sources[sourceIndex].sourceId); } alGetError();//Clear error in case we stopped any sounds that couldn't be stopped } /** * Stop a sound playing. * @param sourceId an OpenAL source identifier i.e. the return value of playSound */ - (void)stopSound:(ALuint) sourceId { if (!functioning_) { return; } alSourceStop(sourceId); alGetError();//Clear error in case we stopped any sounds that couldn't be stopped } - (void) stopAllSounds { for (int i=0; i < sourceTotal_; i++) { alSourceStop(_sources[i].sourceId); } alGetError();//Clear error in case we stopped any sounds that couldn't be stopped } - (void) pauseSound:(ALuint) sourceId { if (!functioning_) { return; } alSourcePause(sourceId); alGetError();//Clear error in case we pause any sounds that couldn't be paused } - (void) pauseAllSounds { for (int i = 0; i < sourceTotal_; i++) { [self pauseSound:_sources[i].sourceId]; } alGetError();//Clear error in case we stopped any sounds that couldn't be paused } - (void) resumeSound:(ALuint) soundId { if (!functioning_) { return; } // only resume a sound id that is paused ALint state; alGetSourcei(soundId, AL_SOURCE_STATE, &state); if (state != AL_PAUSED) { return; } alSourcePlay(soundId); alGetError();//Clear error in case we stopped any sounds that couldn't be resumed } - (void) resumeAllSounds { for (int i = 0; i < sourceTotal_; i++) { [self resumeSound:_sources[i].sourceId]; } alGetError();//Clear error in case we stopped any sounds that couldn't be resumed } /** * Set a source group as non interruptible. Default is that source groups are interruptible. * Non interruptible means that if a request to play a sound is made for a source group and there are * no free sources available then the play request will be ignored and CD_NO_SOURCE will be returned. */ - (void) setSourceGroupNonInterruptible:(int) sourceGroupId isNonInterruptible:(BOOL) isNonInterruptible { //Ensure source group id is valid to prevent memory corruption if (sourceGroupId < 0 || sourceGroupId >= _sourceGroupTotal) { CDLOG(@"Denshion::CDSoundEngine setSourceGroupNonInterruptible invalid source group id %i",sourceGroupId); return; } if (isNonInterruptible) { _sourceGroups[sourceGroupId].nonInterruptible = true; } else { _sourceGroups[sourceGroupId].nonInterruptible = false; } } /** * Set the mute property for a source group. If mute is turned on any sounds in that source group * will be stopped and further sounds in that source group will play. However, turning mute off * will not restart any sounds that were playing when mute was turned on. Also the mute setting * for the sound engine must be taken into account. If the sound engine is mute no sounds will play * no matter what the source group mute setting is. */ - (void) setSourceGroupEnabled:(int) sourceGroupId enabled:(BOOL) enabled { //Ensure source group id is valid to prevent memory corruption if (sourceGroupId < 0 || sourceGroupId >= _sourceGroupTotal) { CDLOG(@"Denshion::CDSoundEngine setSourceGroupEnabled invalid source group id %i",sourceGroupId); return; } if (enabled) { _sourceGroups[sourceGroupId].enabled = true; [self stopSourceGroup:sourceGroupId]; } else { _sourceGroups[sourceGroupId].enabled = false; } } /** * Return the mute property for the source group identified by sourceGroupId */ - (BOOL) sourceGroupEnabled:(int) sourceGroupId { return _sourceGroups[sourceGroupId].enabled; } -(ALCcontext *) openALContext { return context; } - (void) _dumpSourceGroupsInfo { #ifdef CD_DEBUG CDLOGINFO(@"-------------- source Group Info --------------"); for (int i=0; i < _sourceGroupTotal; i++) { CDLOGINFO(@"Group: %i start:%i total:%i",i,_sourceGroups[i].startIndex, _sourceGroups[i].totalSources); CDLOGINFO(@"----- mute:%i nonInterruptible:%i",_sourceGroups[i].enabled, _sourceGroups[i].nonInterruptible); CDLOGINFO(@"----- Source statuses ----"); for (int j=0; j < _sourceGroups[i].totalSources; j++) { CDLOGINFO(@"Source status:%i index=%i locked=%i",j,_sourceGroups[i].sourceStatuses[j] >> 1, _sourceGroups[i].sourceStatuses[j] & 1); } } #endif } @end /////////////////////////////////////////////////////////////////////////////////////// @implementation CDSoundSource @synthesize lastError; //Macro for handling the al error code #define CDSOUNDSOURCE_UPDATE_LAST_ERROR (lastError = alGetError()) #define CDSOUNDSOURCE_ERROR_HANDLER ( CDSOUNDSOURCE_UPDATE_LAST_ERROR == AL_NO_ERROR) -(id)init:(ALuint) theSourceId sourceIndex:(int) index soundEngine:(CDSoundEngine*) engine { if ((self = [super init])) { _sourceId = theSourceId; _engine = engine; _sourceIndex = index; enabled_ = YES; mute_ = NO; _preMuteGain = self.gain; } return self; } -(void) dealloc { CDLOGINFO(@"Denshion::CDSoundSource deallocated %i",self->_sourceIndex); //Notify sound engine we are about to release [_engine _soundSourcePreRelease:self]; [super dealloc]; } - (void) setPitch:(float) newPitchValue { alSourcef(_sourceId, AL_PITCH, newPitchValue); CDSOUNDSOURCE_UPDATE_LAST_ERROR; } - (void) setGain:(float) newGainValue { if (!mute_) { alSourcef(_sourceId, AL_GAIN, newGainValue); } else { _preMuteGain = newGainValue; } CDSOUNDSOURCE_UPDATE_LAST_ERROR; } - (void) setPan:(float) newPanValue { float sourcePosAL[] = {newPanValue, 0.0f, 0.0f};//Set position - just using left and right panning alSourcefv(_sourceId, AL_POSITION, sourcePosAL); CDSOUNDSOURCE_UPDATE_LAST_ERROR; } - (void) setLooping:(BOOL) newLoopingValue { alSourcei(_sourceId, AL_LOOPING, newLoopingValue); CDSOUNDSOURCE_UPDATE_LAST_ERROR; } - (BOOL) isPlaying { ALint state; alGetSourcei(_sourceId, AL_SOURCE_STATE, &state); CDSOUNDSOURCE_UPDATE_LAST_ERROR; return (state == AL_PLAYING); } - (float) pitch { ALfloat pitchVal; alGetSourcef(_sourceId, AL_PITCH, &pitchVal); CDSOUNDSOURCE_UPDATE_LAST_ERROR; return pitchVal; } - (float) pan { ALfloat sourcePosAL[] = {0.0f,0.0f,0.0f}; alGetSourcefv(_sourceId, AL_POSITION, sourcePosAL); CDSOUNDSOURCE_UPDATE_LAST_ERROR; return sourcePosAL[0]; } - (float) gain { if (!mute_) { ALfloat val; alGetSourcef(_sourceId, AL_GAIN, &val); CDSOUNDSOURCE_UPDATE_LAST_ERROR; return val; } else { return _preMuteGain; } } - (BOOL) looping { ALfloat val; alGetSourcef(_sourceId, AL_LOOPING, &val); CDSOUNDSOURCE_UPDATE_LAST_ERROR; return val; } -(BOOL) stop { alSourceStop(_sourceId); return CDSOUNDSOURCE_ERROR_HANDLER; } -(BOOL) play { if (enabled_) { alSourcePlay(_sourceId); CDSOUNDSOURCE_UPDATE_LAST_ERROR; if (lastError != AL_NO_ERROR) { if (alcGetCurrentContext() == NULL) { CDLOGINFO(@"Denshion::CDSoundSource - posting bad OpenAL context message"); [[NSNotificationCenter defaultCenter] postNotificationName:kCDN_BadAlContext object:nil]; } return NO; } else { return YES; } } else { return NO; } } -(BOOL) pause { alSourcePause(_sourceId); return CDSOUNDSOURCE_ERROR_HANDLER; } -(BOOL) rewind { alSourceRewind(_sourceId); return CDSOUNDSOURCE_ERROR_HANDLER; } -(void) setSoundId:(int) soundId { [_engine _soundSourceAttachToBuffer:self soundId:soundId]; } -(int) soundId { return _soundId; } -(float) durationInSeconds { return [_engine bufferDurationInSeconds:_soundId]; } #pragma mark CDSoundSource AudioInterrupt protocol - (BOOL) mute { return mute_; } /** * Setting mute silences all sounds but playing sounds continue to advance playback */ - (void) setMute:(BOOL) newMuteValue { if (newMuteValue == mute_) { return; } if (newMuteValue) { //Remember what the gain was _preMuteGain = self.gain; self.gain = 0.0f; mute_ = newMuteValue;//Make sure this is done after setting the gain property as the setter behaves differently depending on mute value } else { //Restore gain to what it was before being muted mute_ = newMuteValue; self.gain = _preMuteGain; } } - (BOOL) enabled { return enabled_; } - (void) setEnabled:(BOOL)enabledValue { if (enabled_ == enabledValue) { return; } enabled_ = enabledValue; if (enabled_ == NO) { [self stop]; } } @end //////////////////////////////////////////////////////////////////////////// #pragma mark - #pragma mark CDAudioInterruptTargetGroup @implementation CDAudioInterruptTargetGroup -(id) init { if ((self = [super init])) { children_ = [[NSMutableArray alloc] initWithCapacity:32]; enabled_ = YES; mute_ = NO; } return self; } -(void) addAudioInterruptTarget:(NSObject*) interruptibleTarget { //Synchronize child with group settings; [interruptibleTarget setMute:mute_]; [interruptibleTarget setEnabled:enabled_]; [children_ addObject:interruptibleTarget]; } -(void) removeAudioInterruptTarget:(NSObject*) interruptibleTarget { [children_ removeObjectIdenticalTo:interruptibleTarget]; } - (BOOL) mute { return mute_; } /** * Setting mute silences all sounds but playing sounds continue to advance playback */ - (void) setMute:(BOOL) newMuteValue { if (newMuteValue == mute_) { return; } for (NSObject* target in children_) { [target setMute:newMuteValue]; } } - (BOOL) enabled { return enabled_; } - (void) setEnabled:(BOOL)enabledValue { if (enabledValue == enabled_) { return; } for (NSObject* target in children_) { [target setEnabled:enabledValue]; } } @end //////////////////////////////////////////////////////////////////////////// #pragma mark - #pragma mark CDAsynchBufferLoader @implementation CDAsynchBufferLoader -(id) init:(NSArray *)loadRequests soundEngine:(CDSoundEngine *) theSoundEngine { if ((self = [super init])) { _loadRequests = loadRequests; [_loadRequests retain]; _soundEngine = theSoundEngine; [_soundEngine retain]; } return self; } -(void) main { CDLOGINFO(@"Denshion::CDAsynchBufferLoader - loading buffers"); [super main]; _soundEngine.asynchLoadProgress = 0.0f; if ([_loadRequests count] > 0) { float increment = 1.0f / [_loadRequests count]; //Iterate over load request and load for (CDBufferLoadRequest *loadRequest in _loadRequests) { [_soundEngine loadBuffer:loadRequest.soundId filePath:loadRequest.filePath]; _soundEngine.asynchLoadProgress += increment; } } //Completed _soundEngine.asynchLoadProgress = 1.0f; [[NSNotificationCenter defaultCenter] postNotificationName:kCDN_AsynchLoadComplete object:nil]; } -(void) dealloc { [_loadRequests release]; [_soundEngine release]; [super dealloc]; } @end /////////////////////////////////////////////////////////////////////////////////////// #pragma mark - #pragma mark CDBufferLoadRequest @implementation CDBufferLoadRequest @synthesize filePath, soundId; -(id) init:(int) theSoundId filePath:(const NSString *) theFilePath { if ((self = [super init])) { soundId = theSoundId; filePath = [theFilePath copy]; } return self; } -(void) dealloc { [filePath release]; [super dealloc]; } @end /////////////////////////////////////////////////////////////////////////////////////// #pragma mark - #pragma mark CDFloatInterpolator @implementation CDFloatInterpolator @synthesize start,end,interpolationType; -(float) interpolate:(float) t { if (t < 1.0f) { switch (interpolationType) { case kIT_Linear: //Linear interpolation return ((end - start) * t) + start; case kIT_SCurve: //Cubic s curve t^2 * (3 - 2t) return ((float)(t * t * (3.0 - (2.0 * t))) * (end - start)) + start; case kIT_Exponential: //Formulas taken from EaseAction if (end > start) { //Fade in float logDelta = (t==0) ? 0 : powf(2, 10 * (t/1 - 1)) - 1 * 0.001f; return ((end - start) * logDelta) + start; } else { //Fade Out float logDelta = (-powf(2, -10 * t/1) + 1); return ((end - start) * logDelta) + start; } default: return 0.0f; } } else { return end; } } -(id) init:(tCDInterpolationType) type startVal:(float) startVal endVal:(float) endVal { if ((self = [super init])) { start = startVal; end = endVal; interpolationType = type; } return self; } @end /////////////////////////////////////////////////////////////////////////////////////// #pragma mark - #pragma mark CDPropertyModifier @implementation CDPropertyModifier @synthesize stopTargetWhenComplete; -(id) init:(id) theTarget interpolationType:(tCDInterpolationType) type startVal:(float) startVal endVal:(float) endVal { if ((self = [super init])) { if (target) { //Release the previous target if there is one [target release]; } target = theTarget; #if CD_DEBUG //Check target is of the required type if (![theTarget isMemberOfClass:[self _allowableType]] ) { CDLOG(@"Denshion::CDPropertyModifier target is not of type %@",[self _allowableType]); NSAssert([theTarget isKindOfClass:[CDSoundEngine class]], @"CDPropertyModifier target not of required type"); } #endif [target retain]; startValue = startVal; endValue = endVal; if (interpolator) { //Release previous interpolator if there is one [interpolator release]; } interpolator = [[CDFloatInterpolator alloc] init:type startVal:startVal endVal:endVal]; stopTargetWhenComplete = NO; } return self; } -(void) dealloc { CDLOGINFO(@"Denshion::CDPropertyModifier deallocated %@",self); [target release]; [interpolator release]; [super dealloc]; } -(void) modify:(float) t { if (t < 1.0) { [self _setTargetProperty:[interpolator interpolate:t]]; } else { //At the end [self _setTargetProperty:endValue]; if (stopTargetWhenComplete) { [self _stopTarget]; } } } -(float) startValue { return startValue; } -(void) setStartValue:(float) startVal { startValue = startVal; interpolator.start = startVal; } -(float) endValue { return startValue; } -(void) setEndValue:(float) endVal { endValue = endVal; interpolator.end = endVal; } -(tCDInterpolationType) interpolationType { return interpolator.interpolationType; } -(void) setInterpolationType:(tCDInterpolationType) interpolationType { interpolator.interpolationType = interpolationType; } -(void) _setTargetProperty:(float) newVal { } -(float) _getTargetProperty { return 0.0f; } -(void) _stopTarget { } -(Class) _allowableType { return [NSObject class]; } @end /////////////////////////////////////////////////////////////////////////////////////// #pragma mark - #pragma mark CDSoundSourceFader @implementation CDSoundSourceFader -(void) _setTargetProperty:(float) newVal { ((CDSoundSource*)target).gain = newVal; } -(float) _getTargetProperty { return ((CDSoundSource*)target).gain; } -(void) _stopTarget { [((CDSoundSource*)target) stop]; } -(Class) _allowableType { return [CDSoundSource class]; } @end /////////////////////////////////////////////////////////////////////////////////////// #pragma mark - #pragma mark CDSoundSourcePanner @implementation CDSoundSourcePanner -(void) _setTargetProperty:(float) newVal { ((CDSoundSource*)target).pan = newVal; } -(float) _getTargetProperty { return ((CDSoundSource*)target).pan; } -(void) _stopTarget { [((CDSoundSource*)target) stop]; } -(Class) _allowableType { return [CDSoundSource class]; } @end /////////////////////////////////////////////////////////////////////////////////////// #pragma mark - #pragma mark CDSoundSourcePitchBender @implementation CDSoundSourcePitchBender -(void) _setTargetProperty:(float) newVal { ((CDSoundSource*)target).pitch = newVal; } -(float) _getTargetProperty { return ((CDSoundSource*)target).pitch; } -(void) _stopTarget { [((CDSoundSource*)target) stop]; } -(Class) _allowableType { return [CDSoundSource class]; } @end /////////////////////////////////////////////////////////////////////////////////////// #pragma mark - #pragma mark CDSoundEngineFader @implementation CDSoundEngineFader -(void) _setTargetProperty:(float) newVal { ((CDSoundEngine*)target).masterGain = newVal; } -(float) _getTargetProperty { return ((CDSoundEngine*)target).masterGain; } -(void) _stopTarget { [((CDSoundEngine*)target) stopAllSounds]; } -(Class) _allowableType { return [CDSoundEngine class]; } @end