diff options
Diffstat (limited to 'Runtime/Audio/AudioManager.cpp')
| -rw-r--r-- | Runtime/Audio/AudioManager.cpp | 1773 |
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 |