+Unity Runtime codeHEADmaster

1 files changed, 1773 insertions, 0 deletions

diff --git a/Runtime/Audio/AudioManager.cpp b/Runtime/Audio/AudioManager.cpp
new file mode 100644
index 0000000..0f89245
--- /dev/null
+++ b/Runtime/Audio/AudioManager.cpp
@@ -0,0 +1,1773 @@
+#include "UnityPrefix.h"
+#include "Runtime/Misc/ReproductionLog.h"
+#if ENABLE_AUDIO
+#include "AudioManager.h"
+#include "AudioListener.h"
+#include "AudioSource.h"
+#include "AudioReverbZone.h"
+#include "Runtime/BaseClasses/ManagerContext.h"
+#include "Runtime/Serialize/TransferFunctions/SerializeTransfer.h"
+#include "Runtime/Dynamics/RigidBody.h"
+#include "Runtime/Graphics/Transform.h"
+#include "Runtime/Profiler/Profiler.h"
+#include "Runtime/BaseClasses/GameObject.h"
+#include "Runtime/Audio/correct_fmod_includer.h"
+#include "Runtime/Video/MoviePlayback.h"
+#include "Runtime/Utilities/PathNameUtility.h"
+#include "WavReader.h"
+#include "Runtime/Profiler/ProfilerStats.h"
+#include "Runtime/Utilities/UserAuthorizationManager.h"
+#include "Runtime/Misc/UTF8.h"
+#include "Runtime/Misc/BuildSettings.h"
+#include "Runtime/Utilities/Argv.h"
+#include "Runtime/Core/Callbacks/GlobalCallbacks.h"
+
+#if UNITY_IPHONE
+#include "External/Audio/FMOD/builds/iphone/include/fmodiphone.h"
+#include <AudioToolbox/AudioFile.h>
+#include <AudioToolbox/AudioQueue.h>
+#include <AudioToolbox/AudioServices.h>
+#include "Runtime/Misc/PlayerSettings.h"
+#endif
+
+#if UNITY_EDITOR
+#include "Runtime/BaseClasses/IsPlaying.h"
+#if UNITY_WIN
+#include "PlatformDependent/Win/WinUnicode.h"
+#endif
+#endif
+
+#if UNITY_PS3
+#include "External/Audio/FMOD/builds/ps3/include/fmodps3.h"
+struct CellSpurs2;
+extern CellSpurs2* g_pSpursInstance;
+extern uint8_t g_aFmodPriorities[8];
+#endif
+
+#if UNITY_ANDROID
+#include "PlatformDependent/AndroidPlayer/FMOD_FileIO.h"
+#endif
+
+#if UNITY_XENON
+#include "fmodxbox360.h"
+#include "PlatformDependent/Xbox360/Source/Services/Audio.h"
+#endif
+
+#if UNITY_METRO
+#include "PlatformDependent/MetroPlayer/AppCallbacks.h"
+#include "PlatformDependent/MetroPlayer/MetroCapabilities.h"
+#endif
+
+#if UNITY_WP8
+#include "PlatformDependent/WP8Player/WP8Capabilities.h"
+#endif
+
+void*  F_CALLBACK FMODMemoryAlloc (unsigned int size, FMOD_MEMORY_TYPE type, const char *sourcestr)
+{
+#if UNITY_XENON
+	if(type & FMOD_MEMORY_XBOX360_PHYSICAL)
+    {
+        return XPhysicalAlloc(size, MAXULONG_PTR, 0, PAGE_READWRITE);
+    }
+	else
+#endif
+	{
+		SET_ALLOC_OWNER(GetAudioManagerPtr());
+		return UNITY_MALLOC_ALIGNED(kMemFMOD, size, 16);
+    }
+}
+
+void F_CALLBACK FMODMemoryFree(void *ptr, FMOD_MEMORY_TYPE type, const char *sourcestr);
+
+void*  F_CALLBACK FMODMemoryRealloc (void *ptr, unsigned int size, FMOD_MEMORY_TYPE type, const char *sourcestr)
+{
+#if UNITY_XENON
+    if (type & FMOD_MEMORY_XBOX360_PHYSICAL)
+    {
+        char *newdata = (char *)FMODMemoryAlloc(size, type, sourcestr);
+        if (newdata && ptr)
+        {
+            int copylen;
+            int curlen = XPhysicalSize(ptr);
+            copylen = (size > curlen) ? curlen : size;
+            memcpy(newdata, ptr, copylen);
+        }
+        if (ptr)
+        {
+            FMODMemoryFree(ptr, type, sourcestr);
+        }
+        return newdata;   
+    }
+    else
+#endif
+	{
+        return UNITY_REALLOC_ALIGNED(kMemFMOD, ptr, size, 16);
+    }
+}
+
+void  F_CALLBACK FMODMemoryFree (void *ptr, FMOD_MEMORY_TYPE type, const char *sourcestr)
+{
+#if UNITY_XENON
+    if (type & FMOD_MEMORY_XBOX360_PHYSICAL)
+    {
+		XPhysicalFree(ptr);
+    }
+	else
+#endif
+	{
+		UNITY_FREE (kMemFMOD, ptr);
+	}
+}
+
+
+using namespace std;
+
+extern double GetTimeSinceStartup();
+
+// ---------------------------------------------------------------------------
+
+static void _InitScriptBufferManager()
+{
+#if ENABLE_AUDIO_FMOD
+    if (GetAudioManagerPtr())
+        GetAudioManager().InitScriptBufferManager();
+#endif
+}
+
+void AudioManager::InitializeClass ()
+{
+#if UNITY_EDITOR
+	RegisterAllowNameConversion (AudioManager::GetClassStringStatic(), "iOS DSP Buffer Size", "m_DSPBufferSize");
+#endif
+
+	
+	//@TODO: Refactor this. Its ugly...
+	GlobalCallbacks::Get().managersWillBeReloadedHack.Register(_InitScriptBufferManager);
+}
+
+void AudioManager::CleanupClass ()
+{
+	
+}
+
+AudioManager::AudioManager (MemLabelId label, ObjectCreationMode mode)
+	: Super(label, mode)
+	  ,m_DefaultVolume(1.0f)
+	  ,m_Volume(1.0f)
+	  ,m_IsPaused(false)
+	  ,m_Rolloffscale(1.0f)
+	  ,m_DisableAudio(false)
+#if ENABLE_AUDIO_FMOD
+	  ,m_SpeedOfSound(347.0f)
+	  ,m_DopplerFactor(1.0f)
+	  ,m_speakerMode(FMOD_SPEAKERMODE_STEREO)
+	  ,m_activeSpeakerMode(FMOD_SPEAKERMODE_STEREO)
+	  ,m_speakerModeCaps(FMOD_SPEAKERMODE_STEREO)
+	  ,m_driverCaps(0)
+	  ,m_FMODSystem(NULL)
+	  ,m_ChannelGroup_FMODMaster(NULL)
+	  ,m_ChannelGroup_FX_IgnoreVolume(NULL)
+	  ,m_ChannelGroup_FX_UseVolume(NULL)
+	  ,m_ChannelGroup_NoFX_IgnoreVolume(NULL)
+	  ,m_ChannelGroup_NoFX_UseVolume(NULL)
+	  ,m_DSPBufferSize(0)
+	  ,m_ScriptBufferManager(NULL)
+	  ,m_accPausedTicks(0)
+	  ,m_pauseStartTicks(0)
+#endif
+{}
+
+AudioManager::~AudioManager ()
+{	
+#if ENABLE_AUDIO_FMOD
+	CloseFMOD();
+	m_FMODSystem->release();
+#endif
+}
+
+#if ENABLE_AUDIO_FMOD
+// ----------------------------------------------------------------------
+//  FMOD
+
+bool AudioManager::ValidateFMODResult(FMOD_RESULT result, const char* errmsg)
+{
+	if (result != FMOD_OK)
+	{
+		m_LastErrorString = FMOD_ErrorString(result);
+		m_LastFMODErrorResult = result;
+		ErrorString(std::string(errmsg) + m_LastErrorString);
+		return false;
+	}
+	return true;
+}
+
+
+#if UNITY_METRO
+namespace FMOD {
+
+extern Windows::UI::Core::CoreDispatcher^ (*GetAppcallbackCoreDispatcher)(); // Defined in fmod_output_wasapi.cpp
+
+} // namespace FMOD
+#endif // UNITY_METRO
+
+bool AudioManager::InitFMOD()
+{
+	FMOD_RESULT result;
+
+	string fmoddebuglevel = GetFirstValueForARGV("fmoddebuglevel");
+	if(!fmoddebuglevel.empty())
+	{
+		int level = atoi(fmoddebuglevel.c_str());
+		FMOD::Debug_SetLevel(level);
+	}
+	else
+	{
+#if DEBUGMODE && !UNITY_WINRT
+	// FMOD in verbose mode .. remember to link w. L versions of FMOD
+	FMOD::Debug_SetLevel( FMOD_DEBUG_ALL );
+#else
+	FMOD::Debug_SetLevel(FMOD_DEBUG_LEVEL_NONE);
+#endif	
+	}
+
+	if (!m_FMODSystem) // not loaded yet
+	{		
+		#if UNITY_METRO
+			// This serves as a getter for the dispatcher from AppCallbacks.cpp
+			FMOD::GetAppcallbackCoreDispatcher = &UnityPlayer::AppCallbacks::GetCoreDispatcher;
+		#endif
+
+		FMOD::Memory_Initialize(NULL, 0, FMODMemoryAlloc, FMODMemoryRealloc, FMODMemoryFree);
+		result = FMOD::System_Create(&m_FMODSystem);          // Create the main system object. 
+		if(!ValidateFMODResult(result, "FMOD failed to initialize ... ")) return false;
+	#if UNITY_ANDROID
+		m_FMODSystem->setFileSystem(FMOD_FileOpen, FMOD_FileClose, FMOD_FileRead, FMOD_FileSeek, 0,0,-1);
+	#elif UNITY_WII
+	#	if WIIWARE
+		m_FMODSystem->setFileSystem(wii::FMOD_FileOpen, wii::FMOD_FileClose, wii::FMOD_FileRead, wii::FMOD_FileSeek, NULL, NULL, -1);
+	#	endif
+	#endif
+	}
+	
+#if DEBUGMODE
+	if (m_FMODSystem)
+	{
+		FMOD_ADVANCEDSETTINGS settings;
+		memset(&settings, 0, sizeof(settings));
+		settings.profileport = 9264;
+	}
+#endif
+
+#if SUPPORT_REPRODUCE_LOG
+	if (RunningReproduction())
+	{
+		if (!InitReproduction())
+			return false;
+	}
+	else
+	{
+		if (!InitNormal())
+			return false;
+	}
+#else
+	if (!InitNormal())
+		return false;
+#endif // SUPPORT_REPRODUCE_LOG
+
+
+	// 64k for streaming buffer sizes - we're streaming from memory so this should be sufficient
+	// when we're streaming from a www/movie class, buffer sizes are set independently
+	result = m_FMODSystem->setStreamBufferSize(64000, FMOD_TIMEUNIT_RAWBYTES);
+	if(!ValidateFMODResult(result, "FMOD failed to initialize ... ")) return false;
+
+	// Setup system callbacks
+	result = m_FMODSystem->setCallback(AudioManager::systemCallback);
+	if(!ValidateFMODResult(result, "FMOD failed to setup system callbacks ... ")) return false;
+
+	#if UNITY_EDITOR
+	m_EditorChannel = NULL;
+	#endif
+	
+	// Setup channel callbacks
+	result = m_FMODSystem->set3DRolloffCallback(AudioSource::rolloffCallback);
+	if(!ValidateFMODResult(result, "FMOD failed to setup channel callbacks ... ")) return false;
+		
+	// setup channel groups
+
+	Assert(m_ChannelGroup_FMODMaster == NULL);
+	result = m_FMODSystem->getMasterChannelGroup(&m_ChannelGroup_FMODMaster);
+	if(!ValidateFMODResult(result, "FMOD failed to setup channel groups ... ")) return false;
+
+	Assert(m_ChannelGroup_FX_IgnoreVolume == NULL);
+	result = m_FMODSystem->createChannelGroup("FX_IgnoreVol", &m_ChannelGroup_FX_IgnoreVolume);
+	if(!ValidateFMODResult(result, "FMOD failed to setup channel groups ... ")) return false;
+
+	Assert(m_ChannelGroup_FX_UseVolume == NULL);
+	result = m_FMODSystem->createChannelGroup("FX_UseVol", &m_ChannelGroup_FX_UseVolume);
+	if(!ValidateFMODResult(result, "FMOD failed to setup channel groups ... ")) return false;
+
+	Assert(m_ChannelGroup_NoFX_IgnoreVolume == NULL);
+    result = m_FMODSystem->createChannelGroup("NoFX_IgnoreVol", &m_ChannelGroup_NoFX_IgnoreVolume);
+	if(!ValidateFMODResult(result, "FMOD failed to setup channel groups ... ")) return false;
+        
+	Assert(m_ChannelGroup_NoFX_UseVolume == NULL);
+	result = m_FMODSystem->createChannelGroup("NoFX_UseVol", &m_ChannelGroup_NoFX_UseVolume);
+	if(!ValidateFMODResult(result, "FMOD failed to setup channel groups ... ")) return false;
+	
+	result = m_ChannelGroup_FMODMaster->addGroup(m_ChannelGroup_FX_IgnoreVolume);
+	if(!ValidateFMODResult(result, "FMOD failed to setup channel groups ... ")) return false;
+	
+	result = m_ChannelGroup_FX_IgnoreVolume->addGroup(m_ChannelGroup_FX_UseVolume);
+	if(!ValidateFMODResult(result, "FMOD failed to setup channel groups ... ")) return false;
+
+	result = m_ChannelGroup_FMODMaster->addGroup(m_ChannelGroup_NoFX_IgnoreVolume);
+	if(!ValidateFMODResult(result, "FMOD failed to setup channel groups ... ")) return false;
+
+	result = m_ChannelGroup_NoFX_IgnoreVolume->addGroup(m_ChannelGroup_NoFX_UseVolume);
+	if(!ValidateFMODResult(result, "FMOD failed to setup channel groups ... ")) return false;
+	
+	m_activeSpeakerMode = m_speakerMode;
+	
+	return true;
+}
+void AudioManager::InitScriptBufferManager()
+{
+	if (m_ScriptBufferManager == 0)
+	{
+		unsigned DSPBufferSize;
+		int maxOutputChannels;
+		int maxInputChannels;
+		m_FMODSystem->getDSPBufferSize(&DSPBufferSize, NULL);
+		m_FMODSystem->getSoftwareFormat(NULL, 
+															 NULL, 
+															 &maxOutputChannels, 
+															 &maxInputChannels, 
+															 NULL, 
+															 NULL);
+		m_ScriptBufferManager = new AudioScriptBufferManager(16384 / 4, DSPBufferSize * std::max(maxOutputChannels, maxInputChannels)); 
+	}
+}
+void AudioManager::ReloadFMODSounds()
+{
+	CloseFMOD();
+	InitFMOD();
+	InitScriptBufferManager();
+
+	// reload any loaded audio clips
+	std::vector<AudioClip*> audioClips;
+	Object::FindObjectsOfType(&audioClips);
+	for(std::vector<AudioClip*>::iterator it = audioClips.begin(); it != audioClips.end(); ++it)
+		(*it)->Reload();
+	
+	#if ENABLE_SCRIPTING
+	// Recreate Filters on Monobehaviours
+	std::vector<MonoBehaviour*> monoBehaviours;
+	Object::FindObjectsOfType(&monoBehaviours);
+	for(std::vector<MonoBehaviour*>::iterator it = monoBehaviours.begin(); it != monoBehaviours.end(); ++it)
+	{
+		MonoBehaviour* behaviour = *it;
+		FMOD::DSP* dsp = behaviour->GetOrCreateDSP();
+		if (dsp)
+			dsp->setBypass(!behaviour->GetEnabled());
+	}
+	#endif
+
+	// Awake sources
+	std::vector<AudioSource*> audioSources;
+	Object::FindObjectsOfType(&audioSources);
+	for(std::vector<AudioSource*>::iterator it = audioSources.begin(); it != audioSources.end(); ++it)
+		(*it)->AwakeFromLoad(kDefaultAwakeFromLoad);
+	
+	// reload listener filters (if any)
+	TAudioListenersIterator i = m_Listeners.begin();
+	for (;i!=m_Listeners.end();++i)
+	{
+		AudioListener& curListener = **i;
+		curListener.ApplyFilters();
+	}	
+	
+	// reload reverb zones (if any)
+	TAudioReverbZonesIterator j = m_ReverbZones.begin();
+	for(;j!=m_ReverbZones.end();++j)
+	{
+		AudioReverbZone& curReverbZone = **j;
+		curReverbZone.Init();
+	}		
+}
+
+
+void AudioManager::SetSpeakerMode(FMOD_SPEAKERMODE speakerMode)
+{
+	m_speakerMode = speakerMode;
+	if (m_activeSpeakerMode != m_speakerMode)
+		ReloadFMODSounds();
+} 
+#endif  //ENABLE_AUDIO_FMOD
+
+double AudioManager::GetDSPTime() const
+{
+#if ENABLE_AUDIO_FMOD
+	int sampleRate;
+	m_FMODSystem->getSoftwareFormat(&sampleRate, NULL, NULL, NULL, NULL, NULL);
+	if(m_IsPaused)
+		return (double)(m_pauseStartTicks - m_accPausedTicks) / (double)sampleRate;
+	unsigned clockLo, clockHi;
+	m_FMODSystem->getDSPClock(&clockHi, &clockLo);
+	return (double)(((UInt64)clockHi << 32) + clockLo - m_accPausedTicks) / (double)sampleRate;
+#else
+	return GetTimeSinceStartup();
+#endif
+}
+
+#if SUPPORT_REPRODUCE_LOG && ENABLE_AUDIO_FMOD
+bool AudioManager::InitReproduction( )
+{
+	// set a non-realtime wav writer up as output
+	FMOD_RESULT result = m_FMODSystem->setOutput(FMOD_OUTPUTTYPE_WAVWRITER_NRT);
+	if(!ValidateFMODResult(result, "[Reproduction]FMOD failed to initialize WAV writer output... ")) return false;
+	
+	// set lowest possible mixing quality (stereo,11025hz, 8bit)
+	result = m_FMODSystem->setSpeakerMode(FMOD_SPEAKERMODE_STEREO);
+	if(!ValidateFMODResult(result, "[Reproduction]FMOD failed to set speaker mode... ")) return false;
+	
+	result = m_FMODSystem->setSoftwareFormat(22050, FMOD_SOUND_FORMAT_PCM8, 0, 6, FMOD_DSP_RESAMPLER_LINEAR);
+	if(!ValidateFMODResult(result, "[Reproduction]FMOD failed to set software format... ")) return false;
+
+	// init (with filename)
+	string reproductionPathTemp = AppendPathName( GetReproductionDirectory(), "/Audio/" );
+	string out = AppendPathName(reproductionPathTemp, "audio_output.wav");
+	result = m_FMODSystem->init(100, FMOD_INIT_STREAM_FROM_UPDATE | FMOD_INIT_SYNCMIXERWITHUPDATE, (void*)out.c_str());        // Initialize FMOD. 	
+	if(!ValidateFMODResult(result, "[Reproduction]FMOD failed to initialize ... ")) return false;
+
+	return true;
+}
+#endif //SUPPORT_REPRODUCE_LOG && ENABLE_AUDIO_FMODD
+
+#if UNITY_LINUX
+static void LogDriverDetails (FMOD::System *system, int driverID)
+{
+	char driverName[BUFSIZ];
+	FMOD_GUID guid;
+	FMOD_OUTPUTTYPE output;
+	char *outputName;
+
+	system->getOutput (&output);
+	system->getDriverInfo (driverID, driverName, BUFSIZ, &guid);
+
+	switch (output) {
+	case FMOD_OUTPUTTYPE_PULSEAUDIO:
+		outputName = "PulseAudio";
+		break;
+	case FMOD_OUTPUTTYPE_ALSA:
+		outputName = "ALSA";
+		break;
+	case FMOD_OUTPUTTYPE_OSS:
+		outputName = "OSS";
+		break;
+	case FMOD_OUTPUTTYPE_ESD:
+		outputName = "ESD";
+		break;
+	default:
+		outputName = "Unknown";
+		break;
+	}
+	printf_console ("AudioManager: Using %s: %s\n", outputName, driverName);
+}
+#endif
+
+
+#if ENABLE_AUDIO_FMOD
+bool AudioManager::InitNormal( )
+{
+	// Get available sound cards
+	// If no device is found fall back on the NOSOUND driver
+	// @TODO Enable user to choose driver
+	int numDrivers;
+	FMOD_RESULT result = m_FMODSystem->getNumDrivers(&numDrivers);
+	if(!ValidateFMODResult(result, "FMOD failed to get number of drivers ... ")) return false;
+
+	if (numDrivers == 0
+#if !UNITY_EDITOR
+		|| m_DisableAudio
+#endif
+	) // no suitable audio devices/drivers
+	{
+		result = m_FMODSystem->setOutput(FMOD_OUTPUTTYPE_NOSOUND);
+		if(!ValidateFMODResult(result, "FMOD failed to initialize nosound device ... ")) return false;
+	}
+	
+	// get driver id
+	int driverID;
+	m_FMODSystem->getDriver(&driverID);
+	
+	// setup speakermode
+	// check if current hw is capable of the current speakerMode
+	result = m_FMODSystem->getDriverCaps(driverID,&m_driverCaps,0,&m_speakerModeCaps);
+	if(!ValidateFMODResult(result, "FMOD failed to get driver capabilities ... ")) return false;
+	
+	m_activeSpeakerMode = m_speakerMode;
+
+	if (m_speakerModeCaps < m_activeSpeakerMode)
+	{
+		if (m_activeSpeakerMode != FMOD_SPEAKERMODE_SRS5_1_MATRIX)
+			// hardware is not capable of the current speakerMode
+			m_activeSpeakerMode = m_speakerModeCaps;
+	}
+		
+#if UNITY_EDITOR
+
+	int samplerate;
+	FMOD_SOUND_FORMAT format;
+	FMOD_DSP_RESAMPLER resampler;
+
+	result = m_FMODSystem->getSoftwareFormat(&samplerate, &format, NULL, NULL, &resampler, NULL);
+	if(!ValidateFMODResult(result, "FMOD failed to get driver capabilities ... ")) return false;
+
+	result = m_FMODSystem->setSoftwareFormat(samplerate, format, 0, 8, resampler);
+	if(!ValidateFMODResult(result, "FMOD failed to get driver capabilities ... ")) return false;
+
+#endif
+
+	result = m_FMODSystem->setSpeakerMode((FMOD_SPEAKERMODE)m_activeSpeakerMode);
+	if(result != FMOD_OK)
+	{
+		ErrorStringMsg("FMOD could not set speaker mode to the one specified in the project settings. Falling back to stereo.");
+		result = m_FMODSystem->setSpeakerMode(FMOD_SPEAKERMODE_STEREO);
+	}
+	if(!ValidateFMODResult(result, "FMOD failed to set speaker mode ... ")) return false;
+	
+	FMOD_INITFLAGS initFlags = FMOD_INIT_NORMAL;
+
+	if(HasARGV("fmodprofiler"))
+		initFlags |= FMOD_INIT_ENABLE_PROFILE;
+	
+	// Initialize FMOD.
+#if UNITY_IPHONE	
+	FMOD_IPHONE_EXTRADRIVERDATA extradriverdata;
+	memset(&extradriverdata, 0, sizeof(FMOD_IPHONE_EXTRADRIVERDATA));
+
+	if (GetPlayerSettings().prepareIOSForRecording)
+		extradriverdata.sessionCategory = FMOD_IPHONE_SESSIONCATEGORY_PLAYANDRECORD;
+	else if (GetPlayerSettings().overrideIPodMusic)
+		extradriverdata.sessionCategory = FMOD_IPHONE_SESSIONCATEGORY_SOLOAMBIENTSOUND;
+	else
+		extradriverdata.sessionCategory = FMOD_IPHONE_SESSIONCATEGORY_AMBIENTSOUND;
+	
+	extradriverdata.forceMixWithOthers = !GetPlayerSettings().overrideIPodMusic;
+	
+	if (m_DSPBufferSize != 0)
+	{
+		result = m_FMODSystem->setDSPBufferSize(m_DSPBufferSize, 4);		
+		if(!ValidateFMODResult(result, "FMOD failed to set DSP Buffer size ... ")) return false;
+	}
+	
+	result = m_FMODSystem->init(100, initFlags, &extradriverdata); 
+#elif UNITY_PS3
+	if (!IS_CONTENT_NEWER_OR_SAME (kUnityVersion4_0_a1) && m_activeSpeakerMode == FMOD_SPEAKERMODE_STEREO)
+		initFlags |= FMOD_INIT_PS3_FORCE2CHLPCM;
+	
+	FMOD_PS3_EXTRADRIVERDATA extradriverdata;
+	memset(&extradriverdata, 0, sizeof(FMOD_PS3_EXTRADRIVERDATA));
+	extradriverdata.spurs = g_pSpursInstance;
+	extradriverdata.spursmode = FMOD_PS3_SPURSMODE_CREATECONTEXT;
+	extradriverdata.spurs_taskset_priorities = &g_aFmodPriorities[0];
+	result = m_FMODSystem->setSoftwareChannels(64);
+	result = m_FMODSystem->setOutput((!UNITY_EDITOR && m_DisableAudio) ? FMOD_OUTPUTTYPE_NOSOUND : FMOD_OUTPUTTYPE_PS3);
+	result = m_FMODSystem->setSpeakerMode(FMOD_SPEAKERMODE_7POINT1);
+	result = m_FMODSystem->init(100, initFlags | FMOD_INIT_VOL0_BECOMES_VIRTUAL, &extradriverdata); 
+
+#elif UNITY_XENON
+    FMOD_360_EXTRADRIVERDATA extraDriverData;
+    ZeroMemory(&extraDriverData, sizeof(extraDriverData));
+    extraDriverData.xaudio2instance = xenon::Audio::GetXAudio();
+    result = m_FMODSystem->init(100, initFlags, &extraDriverData);
+#elif UNITY_ANDROID
+	result = m_FMODSystem->setOutput((!UNITY_EDITOR && m_DisableAudio) ? FMOD_OUTPUTTYPE_NOSOUND : FMOD_OUTPUTTYPE_AUDIOTRACK);
+	if(!ValidateFMODResult(result, "FMOD failed to force Java Audio Track output ... ")) return false;
+	if (m_DSPBufferSize != 0)
+	{
+		result = m_FMODSystem->setDSPBufferSize(m_DSPBufferSize, 4);		
+		if(!ValidateFMODResult(result, "FMOD failed to set DSP Buffer size ... ")) return false;
+	}
+	result = m_FMODSystem->setSpeakerMode(FMOD_SPEAKERMODE_STEREO);
+	result = m_FMODSystem->init(100, initFlags, NULL); 
+#else
+	result = m_FMODSystem->init(100, initFlags, NULL); 
+#endif
+	if(!ValidateFMODResult(result, "FMOD failed to initialize ... ")) return false;
+
+#if UNITY_LINUX
+	LogDriverDetails (m_FMODSystem, driverID);
+#endif
+
+	return true;
+}
+
+void AudioManager::CloseFMOD()
+{
+	if (m_FMODSystem)
+	{
+		// Cleanup sources
+		std::vector<AudioSource*> audioSources;
+		Object::FindObjectsOfType(&audioSources);
+		for(std::vector<AudioSource*>::iterator it = audioSources.begin(); it != audioSources.end(); ++it)
+			(*it)->Cleanup();		
+		
+		// Cleanup listener(s)
+		std::vector<AudioListener*> audioListeners;
+		Object::FindObjectsOfType(&audioListeners);
+		for(std::vector<AudioListener*>::iterator it = audioListeners.begin(); it != audioListeners.end(); ++it)
+			(*it)->Cleanup();
+		
+		// Cleanup reverb zone(s)
+		std::vector<AudioReverbZone*> audioReverbZones;
+		Object::FindObjectsOfType(&audioReverbZones);
+		for(std::vector<AudioReverbZone*>::iterator it = audioReverbZones.begin(); it != audioReverbZones.end(); ++it)
+			(*it)->Cleanup();
+        
+		if (m_ChannelGroup_FX_IgnoreVolume)
+		{		
+			m_ChannelGroup_FX_IgnoreVolume->release();
+			m_ChannelGroup_FX_IgnoreVolume = NULL;
+		}
+
+		if (m_ChannelGroup_NoFX_IgnoreVolume)
+		{		
+			m_ChannelGroup_NoFX_IgnoreVolume->release();
+			m_ChannelGroup_NoFX_IgnoreVolume = NULL;
+		}
+	
+		if (m_ChannelGroup_FX_UseVolume)
+		{		
+			m_ChannelGroup_FX_UseVolume->release();
+			m_ChannelGroup_FX_UseVolume = NULL;
+		}
+
+		if (m_ChannelGroup_NoFX_UseVolume)
+		{
+			m_ChannelGroup_NoFX_UseVolume->release();
+			m_ChannelGroup_NoFX_UseVolume = NULL;
+		}
+
+		// m_ChannelGroup_FMODMaster  is the FMOD master group so we should not call release on it
+		m_ChannelGroup_FMODMaster = NULL;
+
+		// cleanup any loaded audio clips
+		std::vector<AudioClip*> audioClips;
+		Object::FindObjectsOfType(&audioClips);
+		for(std::vector<AudioClip*>::iterator it = audioClips.begin(); it != audioClips.end(); ++it)
+			(*it)->Cleanup();
+		
+		m_FMODSystem->close();
+	}
+	
+	delete m_ScriptBufferManager;
+	m_ScriptBufferManager = NULL;
+}
+
+
+
+int AudioManager::GetMemoryAllocated() const
+{
+	int a = 0;
+	FMOD::Memory_GetStats(&a, NULL);
+	return a;
+}
+
+float AudioManager::GetCPUUsage() const
+{
+	float c = 0.0f;
+	if (m_FMODSystem)
+		m_FMODSystem->getCPUUsage(NULL, NULL, NULL,NULL, &c);
+	return c;
+}
+
+#if ENABLE_PROFILER
+void AudioManager::GetProfilerData( AudioStats& audioStats )
+{
+	if (m_FMODSystem)
+	{
+		FMOD::Memory_GetStats(&audioStats.audioMemUsage, &audioStats.audioMaxMemUsage);
+		float cpuUsage;
+		m_FMODSystem->getCPUUsage(NULL, NULL, NULL, NULL, &cpuUsage);
+		audioStats.audioCPUusage = RoundfToInt(cpuUsage * 10.0F);
+		m_FMODSystem->getChannelsPlaying(&audioStats.audioVoices);
+		audioStats.pausedSources = m_PausedSources.size_slow();
+		audioStats.playingSources = m_Sources.size_slow();
+		audioStats.audioClipCount = AudioClip::s_AudioClipCount;
+		audioStats.audioSourceCount = AudioSource::s_AudioSourceCount;
+		FMOD_MEMORY_USAGE_DETAILS details;
+		m_FMODSystem->getMemoryInfo(FMOD_EVENT_MEMBITS_ALL, 0, &audioStats.audioMemDetailsUsage, &details);
+		audioStats.audioMemDetails.other = details.other;                          /* [out] Memory not accounted for by other types */
+		audioStats.audioMemDetails.string = details.string;                         /* [out] String data */
+		audioStats.audioMemDetails.system = details.system;                         /* [out] System object and various internals */
+		audioStats.audioMemDetails.plugins = details.plugins;                        /* [out] Plugin objects and internals */
+		audioStats.audioMemDetails.output = details.output;                         /* [out] Output module object and internals */
+		audioStats.audioMemDetails.channel = details.channel;                        /* [out] Channel related memory */
+		audioStats.audioMemDetails.channelgroup = details.channelgroup;                   /* [out] ChannelGroup objects and internals */
+		audioStats.audioMemDetails.codec = details.codec;                          /* [out] Codecs allocated for streaming */
+		audioStats.audioMemDetails.file = details.file;                           /* [out] File buffers and structures */
+		audioStats.audioMemDetails.sound = details.sound;                          /* [out] Sound objects and internals */
+		audioStats.audioMemDetails.secondaryram = details.secondaryram;                   /* [out] Sound data stored in secondary RAM */
+		audioStats.audioMemDetails.soundgroup = details.soundgroup;                     /* [out] SoundGroup objects and internals */
+		audioStats.audioMemDetails.streambuffer = details.streambuffer;                   /* [out] Stream buffer memory */
+		audioStats.audioMemDetails.dspconnection = details.dspconnection;                  /* [out] DSPConnection objects and internals */
+		audioStats.audioMemDetails.dsp = details.dsp;                            /* [out] DSP implementation objects */
+		audioStats.audioMemDetails.dspcodec = details.dspcodec;                       /* [out] Realtime file format decoding DSP objects */
+		audioStats.audioMemDetails.profile = details.profile;                        /* [out] Profiler memory footprint. */
+		audioStats.audioMemDetails.recordbuffer = details.recordbuffer;                   /* [out] Buffer used to store recorded data from microphone */
+		audioStats.audioMemDetails.reverb = details.reverb;                         /* [out] Reverb implementation objects */
+		audioStats.audioMemDetails.reverbchannelprops = details.reverbchannelprops;             /* [out] Reverb channel properties structs */
+		audioStats.audioMemDetails.geometry = details.geometry;                       /* [out] Geometry objects and internals */
+		audioStats.audioMemDetails.syncpoint = details.syncpoint;                      /* [out] Sync point memory. */
+		audioStats.audioMemDetails.eventsystem = details.eventsystem;                    /* [out] EventSystem and various internals */
+		audioStats.audioMemDetails.musicsystem = details.musicsystem;                    /* [out] MusicSystem and various internals */
+		audioStats.audioMemDetails.fev = details.fev;                            /* [out] Definition of objects contained in all loaded projects e.g. events, groups, categories */
+		audioStats.audioMemDetails.memoryfsb = details.memoryfsb;                      /* [out] Data loaded with preloadFSB */
+		audioStats.audioMemDetails.eventproject = details.eventproject;                   /* [out] EventProject objects and internals */
+		audioStats.audioMemDetails.eventgroupi = details.eventgroupi;                    /* [out] EventGroup objects and internals */
+		audioStats.audioMemDetails.soundbankclass = details.soundbankclass;                 /* [out] Objects used to manage wave banks */
+		audioStats.audioMemDetails.soundbanklist = details.soundbanklist;                  /* [out] Data used to manage lists of wave bank usage */
+		audioStats.audioMemDetails.streaminstance = details.streaminstance;                 /* [out] Stream objects and internals */
+		audioStats.audioMemDetails.sounddefclass = details.sounddefclass;                  /* [out] Sound definition objects */
+		audioStats.audioMemDetails.sounddefdefclass = details.sounddefdefclass;               /* [out] Sound definition static data objects */
+		audioStats.audioMemDetails.sounddefpool = details.sounddefpool;                   /* [out] Sound definition pool data */
+		audioStats.audioMemDetails.reverbdef = details.reverbdef;                      /* [out] Reverb definition objects */
+		audioStats.audioMemDetails.eventreverb = details.eventreverb;                    /* [out] Reverb objects */
+		audioStats.audioMemDetails.userproperty = details.userproperty;                   /* [out] User property objects */
+		audioStats.audioMemDetails.eventinstance = details.eventinstance;                  /* [out] Event instance base objects */
+		audioStats.audioMemDetails.eventinstance_complex = details.eventinstance_complex;          /* [out] Complex event instance objects */
+		audioStats.audioMemDetails.eventinstance_simple = details.eventinstance_simple;           /* [out] Simple event instance objects */
+		audioStats.audioMemDetails.eventinstance_layer = details.eventinstance_layer;            /* [out] Event layer instance objects */
+		audioStats.audioMemDetails.eventinstance_sound = details.eventinstance_sound;            /* [out] Event sound instance objects */
+		audioStats.audioMemDetails.eventenvelope = details.eventenvelope;                  /* [out] Event envelope objects */
+		audioStats.audioMemDetails.eventenvelopedef = details.eventenvelopedef;               /* [out] Event envelope definition objects */
+		audioStats.audioMemDetails.eventparameter = details.eventparameter;                 /* [out] Event parameter objects */
+		audioStats.audioMemDetails.eventcategory = details.eventcategory;                  /* [out] Event category objects */
+		audioStats.audioMemDetails.eventenvelopepoint = details.eventenvelopepoint;             /* [out] Event envelope point objects */
+		audioStats.audioMemDetails.eventinstancepool = details.eventinstancepool;              /* [out] Event instance pool memory */
+	}
+}
+#endif
+#endif // ENABLE_AUDIO_FMOD
+
+#if ENABLE_WWW && ENABLE_AUDIO_FMOD
+FMOD::Sound* AudioManager::CreateFMODSoundFromWWW(WWW* webStream,
+									 bool threeD,
+									 FMOD_SOUND_TYPE suggestedtype,
+									 FMOD_SOUND_FORMAT format,
+									 unsigned freq,
+									 unsigned channels,
+									 bool stream)
+{
+	if (!m_FMODSystem)
+		return NULL;
+
+	FMOD::Sound* sound = NULL;
+	FMOD_CREATESOUNDEXINFO exInfo;
+	memset(&exInfo, 0, sizeof(FMOD_CREATESOUNDEXINFO));
+	exInfo.cbsize = sizeof(FMOD_CREATESOUNDEXINFO);
+	exInfo.decodebuffersize = 16384;
+	exInfo.suggestedsoundtype = suggestedtype; 
+	exInfo.format = format;
+	exInfo.defaultfrequency = freq;
+	exInfo.numchannels = channels;
+	exInfo.useropen = AudioClip::WWWOpen;
+	exInfo.userclose = AudioClip::WWWClose;
+	exInfo.userread = AudioClip::WWWRead;
+	exInfo.userseek = AudioClip::WWWSeek;
+	exInfo.userdata = (void*)webStream;
+	
+	
+    FMOD_MODE mode = FMOD_SOFTWARE | (threeD?FMOD_3D:FMOD_2D) | (stream?FMOD_CREATESTREAM:FMOD_CREATESAMPLE) | (suggestedtype==FMOD_SOUND_TYPE_MPEG?FMOD_MPEGSEARCH:FMOD_IGNORETAGS) | FMOD_LOOP_NORMAL | FMOD_3D_CUSTOMROLLOFF ;
+	
+	if (suggestedtype==FMOD_SOUND_TYPE_RAW)
+		mode |= FMOD_OPENRAW;
+	
+	FMOD_RESULT err = m_FMODSystem->createSound(
+												(const char*)webStream,
+												mode,
+												&exInfo,
+												&sound );
+	
+	if (err != FMOD_OK)
+	{
+		m_LastErrorString = FMOD_ErrorString(err);
+		m_LastFMODErrorResult = err;
+		return NULL;
+	}
+	else
+	{
+		// FMOD_LOOP_NORMAL is set on createSound() - this prepares the sound for looping
+		// now turn it off (and let the user set it later)
+		sound->setMode( FMOD_LOOP_OFF );
+		return sound;	
+	}
+	
+}
+#endif // ENABLE_WWW && ENABLE_AUDIO_FMOD
+
+#if ENABLE_AUDIO_FMOD
+FMOD::Sound* AudioManager::CreateFMODSoundFromMovie(AudioClip* clip, bool threeD)
+{
+	if (!m_FMODSystem)
+		return NULL;
+
+	Assert ( clip->GetMovie() );
+	
+	FMOD::Sound* sound = NULL;
+	FMOD_CREATESOUNDEXINFO exInfo;
+	memset(&exInfo, 0, sizeof(FMOD_CREATESOUNDEXINFO));
+	exInfo.cbsize = sizeof(FMOD_CREATESOUNDEXINFO);	
+	// @FIX FMODs position is increased even though the pcm reader thread is starving (FMOD just repeats the last buffer).
+	// @FIX This can lead to out-of-synch problems and that the audio is stopped before the movie is done.
+	// @FIX fix: double the length of the clip as a headroom (and stop the audio when video frames are done)
+	// @FIX duration: Theora format is really stupid for streams, so if we´re not lucky that the duration is in the meta-tags we set it to infinity
+	if (clip->GetMovie()->GetMovieTotalDuration() < 0)
+		exInfo.length = 0xffffffff;
+	else		
+		exInfo.length = (unsigned int)(clip->GetMovie()->GetMovieTotalDuration() * clip->GetFrequency() * clip->GetChannelCount() * ( clip->GetBitsPerSample() / 8 ) * 2);
+	exInfo.decodebuffersize = 4096;
+	exInfo.format = FMOD_SOUND_FORMAT_PCM16;
+	exInfo.defaultfrequency = clip->GetFrequency();
+	exInfo.numchannels = clip->GetChannelCount();	
+	exInfo.pcmreadcallback = AudioClip::pcmread;
+	exInfo.userdata = (void*)clip;
+	
+	
+    FMOD_MODE mode = FMOD_SOFTWARE | (threeD?FMOD_3D:FMOD_2D) | FMOD_CREATESTREAM | FMOD_OPENUSER | FMOD_IGNORETAGS | FMOD_LOOP_NORMAL | FMOD_3D_CUSTOMROLLOFF ;
+		
+	FMOD_RESULT err = m_FMODSystem->createSound(
+												0,
+												mode,
+												&exInfo,
+												&sound );
+	
+	if (err != FMOD_OK)
+	{
+		m_LastErrorString = FMOD_ErrorString(err);
+		m_LastFMODErrorResult = err;
+		return NULL;
+	}
+	else
+	{
+		// FMOD_LOOP_NORMAL is set on createSound() - this prepares the sound for looping
+		// now turn it off (and let the user set it later)
+		sound->setMode( FMOD_LOOP_OFF );
+		return sound;	
+	}	
+}
+
+
+FMOD::Sound* AudioManager::CreateFMODSound(const void* buffer, FMOD_CREATESOUNDEXINFO exInfo, FMOD_MODE mode, bool useHardwareDecoder)
+{
+	Assert(exInfo.cbsize == sizeof(FMOD_CREATESOUNDEXINFO));
+
+#if !(UNITY_ANDROID || UNITY_XENON || UNITY_LINUX || UNITY_BB10 || UNITY_TIZEN)
+	// On Android the file paths have been converted to ascii and fmod doesn't seem to accept unicode strings
+	dynamic_array<UnicodeChar> unicodeBuf (kMemTempAlloc);
+	if((mode & (FMOD_OPENMEMORY | FMOD_OPENMEMORY_POINT | FMOD_OPENUSER)) == 0 && (mode & FMOD_UNICODE) == 0)
+	{
+		ConvertUTF8toUTF16((const char*)buffer, unicodeBuf);
+		unicodeBuf.push_back(0);
+		unicodeBuf.push_back(0); // FMOD reads unicode strings as shorts, so it expects 2 bytes
+		buffer = (const char*)&unicodeBuf[0];
+		mode |= FMOD_UNICODE;
+	}
+#endif
+	
+#if UNITY_IPHONE	
+	if (mode & FMOD_CREATESTREAM)
+	{
+		exInfo.suggestedsoundtype = exInfo.suggestedsoundtype==FMOD_SOUND_TYPE_MPEG?FMOD_SOUND_TYPE_AUDIOQUEUE:exInfo.suggestedsoundtype;
+		FMOD_AUDIOQUEUE_CODECPOLICY policy = FMOD_AUDIOQUEUE_CODECPOLICY_SOFTWAREONLY;
+		if (useHardwareDecoder)
+			policy = FMOD_AUDIOQUEUE_CODECPOLICY_DEFAULT; // try hardware, if it fails then try software
+		exInfo.audioqueuepolicy = policy;
+	}
+#endif	
+	FMOD::Sound* sound = NULL;	
+	FMOD_RESULT result = m_FMODSystem->createSound(
+												(const char*)buffer,
+												mode,
+												&exInfo,
+												&sound );	
+#if UNITY_IPHONE
+	// if the Apple's AudioQueue codec(sf/hw) fails completely (this can happen with some obscure mp3s that FMOD software MP3 codec can read/import, but Apple's decoder can't)
+	// then use FMOD's SOFTWARE codec instead
+	// @TODO Wait for FMOD to handle this internally
+	if (FMOD_ERR_FORMAT == result)
+	{
+		exInfo.suggestedsoundtype = FMOD_SOUND_TYPE_MPEG;
+		result = m_FMODSystem->createSound(
+										(const char*)buffer,
+										mode,
+										&exInfo,
+										&sound );		
+	}
+#endif	
+
+	if (result != FMOD_OK)
+	{
+		m_LastErrorString = FMOD_ErrorString(result);
+		m_LastFMODErrorResult = result;
+#if UNITY_WII
+		ErrorStringMsg ("ERROR: %s\n", m_LastErrorString.c_str());
+#endif
+		return NULL;
+	}
+	else
+	{
+		// FMOD_LOOP_NORMAL is set on createSound() - this prepares the sound for looping
+		// now turn it off (and let the user set it later)
+		sound->setMode( FMOD_LOOP_OFF );
+		return sound;	
+	}
+}
+#endif //ENABLE_AUDIO_FMOD					
+									
+#if UNITY_EDITOR && ENABLE_AUDIO_FMOD					
+FMOD::Sound* AudioManager::CreateFMODSound(const std::string& path, bool threeD, bool hardware, bool openOnly /* = false */)
+{
+	FMOD::Sound* sound = NULL;
+	
+	if (!m_FMODSystem)
+		return NULL;
+
+	Assert( m_FMODSystem );
+	
+	const char* strPtr = path.c_str();
+	FMOD_MODE mode = (openOnly?FMOD_OPENONLY:0x0) | FMOD_SOFTWARE | (threeD?FMOD_3D:FMOD_2D) | FMOD_LOOP_OFF | FMOD_MPEGSEARCH;
+#if !UNITY_ANDROID
+	// On Android the file paths have been converted to ascii and fmod doesn't seem to accept unicode strings
+	dynamic_array<UnicodeChar> unicodeBuf (kMemTempAlloc);
+	if((mode & (FMOD_OPENMEMORY | FMOD_OPENMEMORY_POINT | FMOD_OPENUSER)) == 0 && (mode & FMOD_UNICODE) == 0)
+	{
+		ConvertUTF8toUTF16(strPtr, unicodeBuf);
+		unicodeBuf.push_back(0);
+		unicodeBuf.push_back(0); // FMOD reads unicode strings as shorts, so it expects 2 bytes
+		strPtr = (const char*)&unicodeBuf[0];
+		mode |= FMOD_UNICODE;
+	}
+#endif
+	
+	FMOD_RESULT err = m_FMODSystem->createSound(strPtr, mode, 0, &sound);
+	if (err != FMOD_OK)
+	{
+		m_LastErrorString = FMOD_ErrorString(err);
+		m_LastFMODErrorResult = err;
+		return NULL;
+	}
+	else
+		return sound;	
+}
+
+#endif // UNITY_EDITOR && ENABLE_AUDIO_FMOD					
+
+
+#if ENABLE_AUDIO_FMOD
+FMOD::Channel* AudioManager::GetFreeFMODChannel(FMOD::Sound* sound, bool paused /*=true*/)
+{
+	if (!m_FMODSystem)
+		return NULL;
+	
+	FMOD::Channel* channel;
+	FMOD_RESULT err = m_FMODSystem->playSound(FMOD_CHANNEL_FREE, sound, paused || (IS_CONTENT_NEWER_OR_SAME(kUnityVersion4_1_a3) && m_IsPaused), &channel);
+	if (err != FMOD_OK)
+	{
+		m_LastErrorString = FMOD_ErrorString(err);
+		m_LastFMODErrorResult = err;
+		return NULL;
+	}
+	else
+		return channel;
+	
+}
+#endif //ENABLE_AUDIO_FMOD
+
+
+void AudioManager::UpdateListener (
+								  const Vector3f& position, 
+								  const Vector3f& velocity, 
+								  const Vector3f& up,
+								  const Vector3f& forward)
+{
+#if ENABLE_AUDIO_FMOD
+	if (!m_FMODSystem)
+		return;
+	
+	m_FMODSystem->set3DListenerAttributes(
+								   0, 
+								   reinterpret_cast<const FMOD_VECTOR*>( &position ), 
+								   reinterpret_cast<const FMOD_VECTOR*>( &velocity ),								   
+								   reinterpret_cast<const FMOD_VECTOR*>( &forward ),
+								   reinterpret_cast<const FMOD_VECTOR*>( &up )  
+								   );	
+#endif //ENABLE_AUDIO_FMOD
+	
+}
+
+int AudioManager::GetAutomaticUpdateMode(GameObject *go)
+{
+	Rigidbody* body = go->QueryComponent (Rigidbody);
+	if (body)
+		return kVelocityUpdateModeFixed;
+
+	Transform* parent = go->GetComponent (Transform).GetParent ();
+	while (parent)
+	{
+		go = parent->GetGameObjectPtr ();
+		if (go)
+			body = go->QueryComponent (Rigidbody);
+		else
+			body = NULL;
+		if (body)
+			return kVelocityUpdateModeFixed;
+		
+		parent = parent->GetParent ();
+	}
+	return kVelocityUpdateModeDynamic;
+}
+
+void AudioManager::SetPause (bool pause)
+{
+	if(m_IsPaused == pause)
+		return;
+	m_IsPaused = pause;
+#if ENABLE_AUDIO_FMOD
+	unsigned clockLo, clockHi;
+	m_FMODSystem->getDSPClock(&clockHi, &clockLo);
+	UInt64 dspTicks = ((UInt64)clockHi << 32) + clockLo;
+#else
+	UInt64 dspTicks = 0;
+#endif
+	if (m_IsPaused)
+	{
+		m_pauseStartTicks = dspTicks;
+		// Pause all audio sources and put them in the m_PausedSources, when resuming we start playing them again
+		for (TAudioSourcesIterator i=m_Sources.begin();i != m_Sources.end();)
+		{			
+			AudioSource& source = **(i);
+			i++;
+			
+			if (source.IsPlaying())
+			{
+				source.Pause();
+				m_PausedSources.push_back(source.m_Node);
+			}
+			source.PauseOneShots();
+		}		
+	}
+	else
+	{
+		UInt64 pauseDuration = dspTicks - m_pauseStartTicks;
+		m_accPausedTicks += pauseDuration;
+		// Resume all paused audio sources
+		for (TAudioSourcesIterator i=m_PausedSources.begin();i != m_PausedSources.end();)
+		{
+			AudioSource& source = **(i);
+			++i;
+			
+			// Play is pushing the source to the m_Sources list
+			// don't play if editor is pause
+			source.Play();
+			if(source.HasScheduledTime())
+				source.CorrectScheduledTimeAfterUnpause(pauseDuration);
+		}
+
+		for (TAudioSourcesIterator i=m_Sources.begin();i != m_Sources.end();)
+		{
+			AudioSource& source = **(i);
+			++i;
+			source.ResumeOneShots();
+		}
+		Assert( m_PausedSources.empty() );
+	}
+}
+
+void AudioManager::SetVolume (float volume)
+{
+#if ENABLE_AUDIO_FMOD
+	if (!m_FMODSystem)
+		return;
+	m_ChannelGroup_FX_UseVolume->setVolume(volume);
+	m_ChannelGroup_NoFX_UseVolume->setVolume(volume);
+#endif
+#if UNITY_FLASH
+	__asm __volatile__("SoundMixer.soundTransform = new SoundTransform(Math.min(Math.max(0.0, %0), 1.0));"::"f"(volume));
+#endif
+	m_Volume = volume;
+}
+
+float AudioManager::GetVolume () const
+{
+	return m_Volume;
+}
+
+
+template<class TransferFunction>
+void AudioManager::Transfer (TransferFunction& transfer)
+{
+	Super::Transfer (transfer);
+	
+	transfer.Transfer (m_DefaultVolume, "m_Volume", kSimpleEditorMask);
+	transfer.Transfer (m_Rolloffscale, "Rolloff Scale");
+	
+#if ENABLE_AUDIO_FMOD
+	if (!(transfer.IsWritingGameReleaseData () && transfer.GetBuildingTarget().platform==kBuildFlash || transfer.GetBuildingTarget().platform==kBuildWebGL)){
+		transfer.Transfer (m_SpeedOfSound, "m_SpeedOfSound");
+		transfer.Transfer (m_DopplerFactor, "Doppler Factor");
+		
+		transfer.Transfer ((SInt32&)m_speakerMode, "Default Speaker Mode"); // Remember to specify the TransferName in the doxygen comment in the .h file
+
+		TRANSFER (m_DSPBufferSize);
+	}
+#endif	
+
+	TRANSFER (m_DisableAudio);
+}
+
+
+void AudioManager::AwakeFromLoad (AwakeFromLoadMode awakeMode)
+{
+	Super::AwakeFromLoad (awakeMode);
+#if ENABLE_AUDIO_FMOD	
+	if (!m_FMODSystem)
+	{
+		InitFMOD();
+		m_IsPaused = false;
+	}
+	
+	if (!m_FMODSystem)
+		return;
+	
+	// has the speakermode changed?
+	if (m_activeSpeakerMode != m_speakerMode)
+	{
+		// bootstrap FMOD
+		ReloadFMODSounds();
+		if (!m_FMODSystem)
+			return;
+	}
+	m_Volume = m_DefaultVolume;	
+	m_ChannelGroup_FX_UseVolume->setVolume(m_Volume);
+	m_ChannelGroup_NoFX_UseVolume->setVolume(m_Volume);
+	m_FMODSystem->set3DSettings(m_DopplerFactor, 1, m_Rolloffscale);
+#endif
+}
+
+PROFILER_INFORMATION(gAudioUpdateProfile, "AudioManager.Update", kProfilerAudio);
+PROFILER_INFORMATION(gAudioFixedUpdateProfile, "AudioManager.FixedUpdate", kProfilerAudio);
+
+#if UNITY_EDITOR
+void AudioManager::ListenerCheck()
+{
+	if (!IsWorldPlaying())
+		return;
+	
+	int listenerCount = m_Listeners.size_slow();
+	// @TODO enable multiple listeners
+	if (listenerCount == 0 && !m_Sources.empty())
+	{
+		LogString("There are no audio listeners in the scene. Please ensure there is always one audio listener in the scene");		
+		m_ChannelGroup_FX_UseVolume->setVolume(0.0f);
+		m_ChannelGroup_NoFX_UseVolume->setVolume(0.0f);
+	}
+	else
+	{
+		if (listenerCount > 1)
+			LogString(Format("There are %d audio listeners in the scene. Please ensure there is always exactly one audio listener in the scene.", listenerCount));
+		m_ChannelGroup_FX_UseVolume->setVolume(m_Volume);
+		m_ChannelGroup_NoFX_UseVolume->setVolume(m_Volume);
+	}	
+}
+#endif
+
+
+#define Unity_HiWord(x) ((UInt32)((UInt64)(x) >> 32))
+#define Unity_LoWord(x) ((UInt32)(x))
+#if UNITY_WII
+void AudioManager::UpdateOnDiskEject()
+{
+	for (TAudioSourcesIterator i = m_Sources.begin(); i != m_Sources.end(); i++)
+	{
+		AudioSource& curSource = **i;
+		curSource.Update();
+	}	
+	m_FMODSystem->update();
+}
+#endif
+void AudioManager::ProcessScheduledSources()
+{
+#if ENABLE_AUDIO_FMOD
+	// start scheduled sources
+	// Get mixer clock
+	unsigned hiclock, loclock;
+	m_FMODSystem->getDSPClock(&hiclock, &loclock);
+#endif	
+	for (TScheduledSourcesIterator s = m_ScheduledSources.begin(); s != m_ScheduledSources.end(); s++)
+	{
+		const AudioScheduledSource& p = *s;
+		AudioSource* curSource = p.source;
+		
+		Assert(curSource != NULL);
+		Assert(curSource->m_Channel != NULL);
+		
+
+#if ENABLE_AUDIO_FMOD
+		if (p.time != 0.0)
+		{
+			int sampleRate;
+			m_FMODSystem->getSoftwareFormat(&sampleRate, NULL, NULL, NULL, NULL, NULL);
+			if(p.time > 0.0)
+			{
+				// exact scheduled
+				UInt64 sample = (UInt64)(p.time * sampleRate) + m_accPausedTicks;
+				curSource->m_Channel->setDelay(FMOD_DELAYTYPE_DSPCLOCK_START, Unity_HiWord(sample), Unity_LoWord(sample)); 
+			}
+			else
+			{
+				UInt64 sample = ((UInt64)hiclock << 32) + loclock + (UInt64)(-p.time * sampleRate);
+				curSource->m_Channel->setDelay(FMOD_DELAYTYPE_DSPCLOCK_START, Unity_HiWord(sample), Unity_LoWord(sample)); 
+			}
+			curSource->m_HasScheduledStartDelay = true;
+		}
+#endif
+		// play (TODO: if paused in the same frame - pause here)
+		bool paused = curSource->m_pause || (IS_CONTENT_NEWER_OR_SAME(kUnityVersion4_1_a3) && m_IsPaused && !curSource->m_AudioParameters.ignoreListenerPause);
+		curSource->m_Channel->setPaused(paused);
+		AddAudioSource(curSource, paused); // to make sure source is put into active or paused sources lists
+	}
+	// clean queue
+	m_ScheduledSources.clear();
+}
+
+void AudioManager::Update()
+{
+	PROFILER_AUTO (gAudioUpdateProfile, NULL);
+	
+#if ENABLE_AUDIO_FMOD
+	if (!m_FMODSystem)
+		return;	
+#endif
+	
+	ProcessScheduledSources();
+	
+#if UNITY_EDITOR
+	ListenerCheck();			
+#endif
+		
+	for (TAudioListenersIterator l = m_Listeners.begin(); l != m_Listeners.end(); l++)
+	{
+		AudioListener& curListener = **l;
+		curListener.Update();
+	}	
+	
+	for (TAudioSourcesIterator i = m_Sources.begin(); i != m_Sources.end(); i++)
+	{
+		AudioSource& curSource = **i;
+#if UNITY_EDITOR
+		if (!IsWorldPlaying() && curSource.m_Channel)
+		{
+			if (curSource.GetGameObject().IsMarkedVisible())
+				curSource.m_Channel->setMute(curSource.GetMute());
+			else
+				curSource.m_Channel->setMute(true);
+		}
+#endif
+		curSource.Update();
+	}
+#if ENABLE_AUDIO_FMOD	
+	// update reverb zones position
+	for (TAudioReverbZonesIterator r = m_ReverbZones.begin(); r != m_ReverbZones.end(); ++r)
+	{
+		AudioReverbZone& curReverbZone = **r;
+		curReverbZone.Update();
+	}
+			 
+	m_FMODSystem->update();
+#endif
+}
+
+
+void AudioManager::FixedUpdate()
+{
+#if ENABLE_AUDIO_FMOD
+	if (!m_FMODSystem)
+		return;
+#endif
+	PROFILER_AUTO (gAudioFixedUpdateProfile, NULL);
+
+	#if UNITY_EDITOR
+	ListenerCheck();	
+	#endif
+	
+	for (TAudioListenersIterator l = m_Listeners.begin(); l != m_Listeners.end(); l++)
+	{
+		AudioListener& curListener = **l;
+		curListener.FixedUpdate();
+	}	
+	
+	TAudioSourcesIterator i;	
+	for (i = m_Sources.begin(); i != m_Sources.end(); i++)
+	{
+		AudioSource& curSource = **i;
+		curSource.FixedUpdate();
+	}	
+}
+
+void AudioManager::AddAudioSource( AudioSource* s, bool paused )
+{
+	Assert(s);
+	if(paused)
+		m_PausedSources.push_back(s->m_Node);
+	else
+		m_Sources.push_back(s->m_Node);
+}	
+
+void AudioManager::RemoveAudioSource( AudioSource* s )
+{
+	Assert(s);
+	UnScheduleSource(s);
+	s->m_Node.RemoveFromList(); // note: removes either from m_Sources or m_PausedSources
+}
+
+void AudioManager::StopSources()
+{ 
+	TAudioSourcesIterator i = m_Sources.begin();
+	while (!m_Sources.empty())
+	{
+		AudioSource& curSource = **i;
+		++i;
+		curSource.Stop(true);
+	}
+	i = m_PausedSources.begin();
+	while (!m_PausedSources.empty())
+	{
+		AudioSource& curSource = **i;
+		++i;
+		curSource.Stop(true);
+	}
+}
+
+void AudioManager::AddAudioListener (AudioListener* s)
+{
+	Assert(s);
+	m_Listeners.push_back( s->GetNode() );
+}
+
+void AudioManager::RemoveAudioListener (AudioListener* s)
+{
+	Assert(s);
+	s->GetNode().RemoveFromList();
+}
+
+AudioListener* AudioManager::GetAudioListener() const
+{
+	if (!m_Listeners.empty())
+		return m_Listeners.back().GetData();
+	else
+		return NULL;
+}
+
+/// Schedule source to be played in sync. In this frame if time==0, delayed by -time if time<0 or scheduled at time
+void AudioManager::ScheduleSource(AudioSource* s, double time)
+{
+	s->m_ScheduledSource.RemoveFromList();
+	s->m_ScheduledSource.time = time;
+	m_ScheduledSources.push_back(s->m_ScheduledSource);
+}
+
+void AudioManager::UnScheduleSource(AudioSource* s)
+{
+	s->m_ScheduledSource.RemoveFromList();
+}
+
+#if ENABLE_AUDIO_FMOD
+void AudioManager::AddAudioReverbZone(AudioReverbZone* zone)
+{
+	Assert(zone);
+	m_ReverbZones.push_back(zone->m_Node);	
+}
+
+void AudioManager::RemoveAudioReverbZone(AudioReverbZone* zone)
+{
+	Assert(zone);
+	zone->m_Node.RemoveFromList();	
+}
+
+
+
+#endif
+
+#if ENABLE_MICROPHONE
+// Microphone(s)
+bool HasMicrophoneAuthorization ()
+{
+	#if UNITY_WINRT
+		#if UNITY_METRO
+		namespace Capabilities = metro::Capabilities;
+		#elif UNITY_WP8
+		namespace Capabilities = WP8::Capabilities;
+		#else
+		#error Unknown WinRT flavour (did you implement capability detection for the OS?)
+		#endif
+
+		Capabilities::IsSupported(Capabilities::kMicrophone, "because you're using Microphone functionality");
+	#endif // UNITY_WINRT
+
+	return GetUserAuthorizationManager().HasUserAuthorization(UserAuthorizationManager::kMicrophone);
+}
+
+const std::vector<std::string> AudioManager::GetRecordDevices() const
+{
+	std::vector<std::string> devices;
+	m_MicrophoneNameToIDMap.clear();
+	
+	if (!m_FMODSystem)
+		return devices;	
+	
+	if (!HasMicrophoneAuthorization())
+		return devices;
+	
+	int numDevices;
+	FMOD_RESULT result = m_FMODSystem->getRecordNumDrivers(&numDevices);
+	
+	if (result != FMOD_OK)
+		return devices;
+	
+	if (numDevices > 0)
+	{
+		for (int i=0; i < numDevices; ++i)
+		{
+			char name[255];
+			
+			m_FMODSystem->getRecordDriverInfo(i, name, 255, NULL);
+			
+			std::string strName = (char*)name;
+			// update map with a unique name
+			std::string origName = strName;
+			int no = 0;
+			while (m_MicrophoneNameToIDMap.find(strName) != m_MicrophoneNameToIDMap.end())
+			{
+				char post[3];
+				sprintf(post, " %i", ++no);
+				strName = origName + post;
+			}
+			devices.push_back(strName);
+			m_MicrophoneNameToIDMap[strName] = i;						
+		}
+	}
+	
+	return devices;
+}
+
+int AudioManager::GetMicrophoneDeviceIDFromName(const std::string& name) const
+{
+	if ( m_MicrophoneNameToIDMap.empty() )
+		GetRecordDevices();
+
+	// Double lookup on return is totally unnecessary, because we can cache the iterator
+	std::map<std::string, int>::const_iterator devit = m_MicrophoneNameToIDMap.find( name );
+	if ( devit != m_MicrophoneNameToIDMap.end() )
+		return devit->second;
+	else
+		return 0; // the default device is always 0.
+}
+
+
+void ReportError (char const* msg, FMOD_RESULT result)
+{
+	ErrorString (Format ("%s. result=%d (%s)", msg, result, FMOD_ErrorString (result)));
+}
+
+void CapsToSoundFormat (FMOD_CAPS caps, FMOD_SOUND_FORMAT *soundFormat, int *sampleSizeInBytes)
+{
+	*soundFormat = FMOD_SOUND_FORMAT_PCM16;
+	*sampleSizeInBytes = 2;
+	
+	if ((caps & FMOD_CAPS_OUTPUT_FORMAT_PCM16) == FMOD_CAPS_OUTPUT_FORMAT_PCM16)
+	{
+		*soundFormat = FMOD_SOUND_FORMAT_PCM16;
+		*sampleSizeInBytes = 2;
+	}
+	else
+	if ((caps & FMOD_CAPS_OUTPUT_FORMAT_PCM8) == FMOD_CAPS_OUTPUT_FORMAT_PCM8)
+	{
+		*soundFormat = FMOD_SOUND_FORMAT_PCM8;
+		*sampleSizeInBytes = 1;
+	}
+	else 
+	if ((caps & FMOD_CAPS_OUTPUT_FORMAT_PCM24) == FMOD_CAPS_OUTPUT_FORMAT_PCM24)
+	{
+		*soundFormat = FMOD_SOUND_FORMAT_PCM24;
+		*sampleSizeInBytes = 3;
+	}
+	else if ((caps & FMOD_CAPS_OUTPUT_FORMAT_PCM32) == FMOD_CAPS_OUTPUT_FORMAT_PCM32)
+	{
+		*soundFormat = FMOD_SOUND_FORMAT_PCM32;
+		*sampleSizeInBytes = 4;
+	}
+	else if ((caps & FMOD_CAPS_OUTPUT_FORMAT_PCMFLOAT) == FMOD_CAPS_OUTPUT_FORMAT_PCMFLOAT)
+	{
+		*soundFormat = FMOD_SOUND_FORMAT_PCMFLOAT;
+		*sampleSizeInBytes = sizeof (float);
+	}
+}
+
+void AudioManager::GetDeviceCaps(int deviceID, int *minFreq, int *maxFreq) const
+{
+	FMOD_CAPS caps = 0;
+	FMOD_RESULT result = m_FMODSystem->getRecordDriverCaps (deviceID, &caps, minFreq, maxFreq);
+	
+	if (result != FMOD_OK)
+	{
+		ReportError ("Failed to get record driver caps", result);
+	}
+}
+
+FMOD::Sound* AudioManager::CreateSound (int deviceID, int lengthSec, int frequency)
+{
+	FMOD::Sound* sound;
+	FMOD_CAPS caps = 0;
+	FMOD_RESULT result = m_FMODSystem->getRecordDriverCaps (deviceID, &caps, NULL, NULL);
+
+	if (result != FMOD_OK)
+	{
+		ReportError ("Failed to get record driver caps", result);
+		return NULL;
+	}
+
+	FMOD_SOUND_FORMAT soundFormat = FMOD_SOUND_FORMAT_NONE;
+	int sampleSizeInBytes = 1;
+	CapsToSoundFormat (caps, &soundFormat, &sampleSizeInBytes);
+
+	FMOD_CREATESOUNDEXINFO exinfo;
+	memset(&exinfo, 0, sizeof(FMOD_CREATESOUNDEXINFO));
+
+	exinfo.cbsize           = sizeof(FMOD_CREATESOUNDEXINFO);
+	exinfo.numchannels      = 1;
+	exinfo.format           = soundFormat;
+	exinfo.defaultfrequency = frequency;
+	exinfo.length = exinfo.defaultfrequency * sampleSizeInBytes * exinfo.numchannels * lengthSec;
+
+	FMOD_MODE mode = FMOD_2D | FMOD_SOFTWARE | FMOD_OPENUSER;
+	result = m_FMODSystem->createSound (0, mode, &exinfo, &sound);
+
+	if (result != FMOD_OK)
+	{
+		ReportError ("Failed to create sound clip for recording", result);
+		return NULL;
+	}
+
+	return sound;
+}
+
+PPtr<AudioClip> AudioManager::StartRecord(int deviceID, bool loop, int lengthSec, int frequency)
+{
+	if (!m_FMODSystem)
+		return NULL;
+
+	if (!HasMicrophoneAuthorization())
+		return NULL;
+	
+	if (lengthSec <= 0)
+	{
+		ErrorString("Length of the recording must be greater than zero (0)");
+		return NULL;
+	}
+	
+	if (frequency <= 0)
+	{
+		ErrorString("Frequency must be greater than zero (0)");
+		return NULL;	
+	}
+
+	FMOD::Sound* sound = CreateSound (deviceID, lengthSec, frequency);
+
+	if (sound == NULL)
+		return NULL;
+
+	FMOD_RESULT result = m_FMODSystem->recordStart (deviceID, sound, loop);
+
+	if (result == FMOD_OK)
+	{
+		PPtr<AudioClip> audioClip = NEW_OBJECT(AudioClip);
+		audioClip->Reset();
+		audioClip->HackSetAwakeWasCalled();
+
+		audioClip->InitWSound(sound);
+		audioClip->SetName("Microphone");
+
+		return audioClip;
+	}
+	else
+	{
+		ReportError ("Starting Microphone failed", result);
+		return NULL;
+	}
+}
+
+bool AudioManager::EndRecord(int deviceID)
+{
+	if (!m_FMODSystem)
+		return false;
+	
+	m_FMODSystem->recordStop(deviceID);
+	
+	return true;
+}
+
+bool AudioManager::IsRecording(int deviceID) const
+{
+	if (!m_FMODSystem)
+		return false;
+	
+	bool isRecording;
+	m_FMODSystem->isRecording(deviceID, &isRecording);
+	return isRecording;
+}
+
+unsigned AudioManager::GetRecordPosition(int deviceID) const
+{
+	if (!m_FMODSystem)
+		return 0;
+	
+	unsigned pos;
+	m_FMODSystem->getRecordPosition(deviceID, &pos);
+	return pos;
+}
+
+#endif // ENABLE_MICROPHONE
+
+#if ENABLE_AUDIO_FMOD
+AudioScriptBufferManager& AudioManager::GetScriptBufferManager()
+{
+	return *GetScriptBufferManagerPtr();
+}
+
+AudioScriptBufferManager* AudioManager::GetScriptBufferManagerPtr()
+{
+	if (m_ScriptBufferManager == 0)
+	{
+		InitScriptBufferManager ();
+	}
+
+	return m_ScriptBufferManager;
+}
+#endif
+
+#if UNITY_EDITOR
+void AudioManager::PlayClip(AudioClip& clip, int startSample, bool loop, bool twoD)
+{
+	if (!m_FMODSystem)
+		return;
+
+	// update FMOD to get any device changes
+	m_FMODSystem->update();
+	
+	if (m_EditorChannel)
+		m_EditorChannel->stop();
+
+	m_EditorChannel = clip.CreateChannel();
+	
+	if(m_EditorChannel != NULL)
+	{
+		if (twoD && clip.Is3D())
+		{
+			m_EditorChannel->setMode(FMOD_2D);
+		}
+
+		m_EditorChannel->setChannelGroup(m_ChannelGroup_NoFX_IgnoreVolume);
+
+		FMOD_REVERB_CHANNELPROPERTIES rev;
+		memset(&rev, 0, sizeof(rev));
+		rev.Room = -10000;
+		m_EditorChannel->setReverbProperties(&rev);
+
+		if (loop)
+			m_EditorChannel->setMode(FMOD_LOOP_NORMAL);
+
+		// movie audio
+		if (clip.GetMovie())
+			clip.GetMovie()->SetAudioChannel(m_EditorChannel);
+
+		m_EditorChannel->setPaused(false);
+	}
+}
+
+
+void AudioManager::LoopClip(const AudioClip& clip, bool loop)
+{
+	if (m_EditorChannel)
+		m_EditorChannel->setMode(loop?FMOD_LOOP_NORMAL:FMOD_LOOP_OFF);
+}
+
+
+void AudioManager::StopClip(const AudioClip& clip)
+{
+	if (m_EditorChannel)
+		m_EditorChannel->stop();
+
+	if (clip.GetMovie())
+		clip.GetMovie()->SetAudioChannel(NULL);
+}
+
+void AudioManager::StopAllClips()
+{
+	if (m_EditorChannel)
+		m_EditorChannel->stop();	
+}
+void AudioManager::PauseClip(const AudioClip& clip)
+{
+	if (m_EditorChannel)
+		m_EditorChannel->setPaused(true);
+
+	if (clip.GetMovie())
+		clip.GetMovie()->SetAudioChannel(NULL);
+}
+void AudioManager::ResumeClip(const AudioClip& clip)
+{
+	if (m_EditorChannel)
+		m_EditorChannel->setPaused(false);}
+
+bool AudioManager::IsClipPlaying(const AudioClip& clip)
+{
+	bool isPlaying = false;
+	if (m_EditorChannel)
+		 m_EditorChannel->isPlaying(&isPlaying);
+	return isPlaying;
+}
+
+float AudioManager::GetClipPosition(const AudioClip& clip)
+{
+	unsigned int pos = 0;
+	if (m_EditorChannel)
+		m_EditorChannel->getPosition(&pos, FMOD_TIMEUNIT_MS);
+	return (float)pos / 1000.f;
+}
+
+unsigned int AudioManager::GetClipSamplePosition(const AudioClip& clip)
+{
+	unsigned int pos = 0;
+	if (m_EditorChannel)
+		m_EditorChannel->getPosition(&pos, FMOD_TIMEUNIT_PCM);
+	return pos;
+}
+
+void AudioManager::SetClipSamplePosition(const AudioClip& clip, unsigned int iSamplePosition)
+{
+	if (m_EditorChannel)
+		m_EditorChannel->setPosition(iSamplePosition, FMOD_TIMEUNIT_PCM);
+}
+
+#endif // UNITY_EDITOR
+
+
+
+IMPLEMENT_CLASS_HAS_INIT (AudioManager)
+IMPLEMENT_OBJECT_SERIALIZE (AudioManager)
+GET_MANAGER (AudioManager)
+GET_MANAGER_PTR (AudioManager)
+
+#endif //ENABLE_AUDIO