axmol/CocosDenshion/iphone/CocosDenshion.m

/*
 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 stopped 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;
  }
  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<CDAudioInterruptProtocol>*) interruptibleTarget {
	//Synchronize child with group settings;
	[interruptibleTarget setMute:mute_];
	[interruptibleTarget setEnabled:enabled_];
	[children_ addObject:interruptibleTarget];
}	

-(void) removeAudioInterruptTarget:(NSObject<CDAudioInterruptProtocol>*) 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<CDAudioInterruptProtocol>* target in children_) {
		[target setMute:newMuteValue];
	}	
}

- (BOOL) enabled {
	return enabled_;
}

- (void) setEnabled:(BOOL)enabledValue
{
	if (enabledValue == enabled_) {
		return;
	}
	
	for (NSObject<CDAudioInterruptProtocol>* 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];//TODO: is retain necessary or does copy set retain count
		[filePath retain];
	} 
	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