cAudioManager.cpp

// Copyright (c) 2008-2011 Raynaldo (Wildicv) Rivera, Joshua (Dark_Kilauea) Jones, Murat (wolfmanfx) Sari
// This file is part of the "cAudio Engine"
// For conditions of distribution and use, see copyright notice in cAudio.h
 
#include "cAudioManager.h"
#include "cAudio.h"
#include "cAudioSource.h"
#include "cAudioStaticSource.h"
#include "cAudioPlatform.h"
#include "cAudioSleep.h"
#include "cUtils.h"
#include "cThread.h"
#include "cLogger.h"
#include "cPluginManager.h"
#include "cThread.h"
#include "cMemorySource.h"
#include "cRawAudioDecoderFactory.h"
#include <string.h>
#include <algorithm>
#include "cOpenALDeviceContext.h"
 
namespace cAudio
{
        cAudioManager::~cAudioManager() 
        {                       
        cAudioManager::shutDown();
        }
 
    bool cAudioManager::initialize(const char* deviceName, int outputFrequency, int eaxEffectSlots)
    {
                cAudioMutexBasicLock lock(Mutex);
 
                if(Initialized)
                        return false;
 
                AudioContext = CAUDIO_NEW cOpenALDeviceContext(this);
 
                if(!AudioContext->initialize(deviceName, outputFrequency, eaxEffectSlots))
                        return false;
 
#ifdef CAUDIO_USE_INTERNAL_THREAD
                if (!AudioThread)
                {
                        AudioThread = new cAudioThread(this);
                }
                AudioThread->start();
#endif
                Initialized = true;
                return true;
    }
 
        void cAudioManager::shutDown()
        {
                if(Initialized)
                {
                        if (AudioThread) // First wait for our update thread to finish up
                        {
                                AudioThread->join();
                                delete AudioThread;
                                AudioThread = NULL;
                        } 
 
                        cAudioMutexBasicLock lock(Mutex);
            
            unRegisterAllAudioDecoders();
                        unRegisterAllDataSources();
                        unRegisterAllEventHandlers();
 
                        releaseAllSources();
                        
                        if (AudioContext)
                        {
                                AudioContext->shutDown();
                                CAUDIO_DELETE AudioContext;
                                AudioContext = NULL;
                        }
 
                        Initialized = false;
 
                        getLogger()->logInfo("AudioManager", "Manager successfully shutdown.");
                }
        }
 
        void cAudioManager::update()
        {
        updateSources.clear();
 
        {
            cAudioMutexBasicLock lock(Mutex);
            size_t count = audioSources.size();
            for(size_t i=0; i<count; i++)
            {
                IAudioSource* source = audioSources[i];
                if (source->isValid())
                {
                    source->grab();
                    updateSources.push_back(source);
                }
            }
        }
 
        // not holding the mutex because this might take a while!
        for (int i=0; i != updateSources.size(); i++)
        {
            IAudioSource *src = updateSources[i];
            src->update();
            src->drop();
        }
 
        cAudioMutexBasicLock lock(Mutex);
        
                if (!managedAudioSources.empty())
                {
                        size_t count = managedAudioSources.size();
                        for(size_t i=0; i<count; i++)
                        {
                                IAudioSource* source = managedAudioSources[i];
                                if (source->isValid())
                                {
                                        source->update();
                                        if (source->isStopped())
                                        {
                                                managedAudioSourcesDelBuffer.push_back(source);
                                        }
                                }
                        }
 
                        count = managedAudioSourcesDelBuffer.size();
                        for(size_t i=0; i<count; i++)
                        {
                                IAudioSource* source = managedAudioSourcesDelBuffer[i];
                                cAudioVector<IAudioSource*>::Type::iterator it = std::find(managedAudioSources.begin(), managedAudioSources.end(), source);
                                if (it != managedAudioSources.end())
                                {
                                        managedAudioSources.erase(it);
                                        CAUDIO_DELETE source;
                                }
                        }
                        managedAudioSourcesDelBuffer.clear();
                }               
        }
 
        void cAudioManager::run()
        {
                if(!audioSources.empty()) 
                        update();
                
                cAudioSleep(1);
        }
 
        bool cAudioManager::isUpdateThreadRunning() 
        {
                return (AudioThread != NULL && AudioThread->isRunning());
        }
 
#if CAUDIO_EFX_ENABLED == 1
        IAudioEffects* cAudioManager::getEffects()
        {
                if (AudioContext)
                {
                        return AudioContext->getEffects();
                }
                return NULL;
        }
#endif
 
        IAudioSource* cAudioManager::play2D(const char* filename, bool playLooped, bool startPaused)
        {
                cAudioMutexBasicLock lock(Mutex);
                IAudioSource* pAudioSrc = create("", filename, true);
        
        if (!pAudioSrc)
            return NULL;
 
                if (!playLooped && !startPaused)
                {
                        cAudioVector<IAudioSource*>::Type::iterator it = std::find(audioSources.begin(), audioSources.end(), pAudioSrc);
                        if (it != audioSources.end())
                        {
                                audioSources.erase(it);
                        }
                        managedAudioSources.push_back(pAudioSrc);
 
                        pAudioSrc->play2d();
                        return NULL;                     
                }
 
                if (playLooped && !startPaused)
                {
                        pAudioSrc->play2d(true);
                }
 
                return pAudioSrc;
        }
 
        IAudioSource* cAudioManager::play3D(const char* filename, cVector3 position, bool playLooped, bool startPaused)
        {
                cAudioMutexBasicLock lock(Mutex);
                IAudioSource* pAudioSrc = create("", filename, true);
 
                if (!playLooped && !startPaused)
                {
                        cAudioVector<IAudioSource*>::Type::iterator it = std::find(audioSources.begin(), audioSources.end(), pAudioSrc);
                        if (it != audioSources.end())
                        {
                                audioSources.erase(it);
                        }
                        managedAudioSources.push_back(pAudioSrc);
 
                        pAudioSrc->play3d(position);
                        return NULL;                     
                }
 
                if (playLooped && !startPaused)
                {
                        pAudioSrc->play3d(position, 1.0, true);
                }
 
                return pAudioSrc;
        }
 
        void cAudioManager::setMasterVolume(float vol)
        {
                cAudioMutexBasicLock lock(Mutex);
                MasterVolume = vol;
                size_t count = audioSources.size();
                for(size_t i=0; i<count; i++)
                {
                        audioSources[i]->setVolume(audioSources[i]->getVolume());
                }
        }
 
        float cAudioManager::getMasterVolume() const
        {
                return MasterVolume;
        }
 
    void cAudioManager::setSpeedOfSound(float speed)
    {
        alSpeedOfSound(speed);
        checkALError();
    }
    
    float cAudioManager::getSpeedOfSound() const
    {
        return alGetFloat(AL_SPEED_OF_SOUND);
    }
 
    void cAudioManager::setDopplerFactor(float factor) const
    {
        alDopplerFactor(factor);
        checkALError();
    }
 
    float cAudioManager::getDopplerFactor() const
    {
        return alGetFloat(AL_DOPPLER_FACTOR);
    }
 
        void cAudioManager::stopAllSounds() 
        {
                cAudioMutexBasicLock lock(Mutex);
                size_t count = audioSources.size();
                for(size_t i=0; i<count; i++)
                {
                        if(audioSources[i]->isPlaying())
                                audioSources[i]->stop();
                }
        }
 
        IAudioSource* cAudioManager::createAudioSource(IAudioDecoder* decoder, const cAudioString& audioName, const cAudioString& dataSource)
        {
        if (!decoder)
            return NULL;
        
                if(decoder->isValid())
                {
#if CAUDIO_EFX_ENABLED == 1
                        IAudioSource* audio = CAUDIO_NEW cAudioSource(decoder, AudioContext, ((cAudioEffects*)getEffects())->getEFXInterface());
#else
                        IAudioSource* audio = CAUDIO_NEW cAudioSource(decoder, AudioContext);
#endif
                        decoder->drop();
 
                        if(audio && audio->isValid())
                        {
                                if(!audioName.empty())
                                        audioIndex[audioName] = audio;
 
                                audioSources.push_back(audio);          
                                getLogger()->logInfo("AudioManager", "Audio Source (%s) created from Data Source %s.", toUTF8(audioName), toUTF8(dataSource));
                                return audio;
                        }
 
                        getLogger()->logError("AudioManager", "Failed to create Audio Source (%s): Error creating audio source.", toUTF8(audioName));
                        audio->drop();
                        return NULL;
                }
                getLogger()->logError("AudioManager", "Failed to create Audio Source (%s): Audio data could not be decoded by (.%s) decoder.",
                              toUTF8(audioName), toUTF8(decoder->getType()));
                decoder->drop();
                return NULL;
        }
 
 
    IAudioSource* cAudioManager::create(const char* name, const char* filename, bool stream)
    {
                if(!Initialized) return NULL;
 
                cAudioMutexBasicLock lock(Mutex);
                cAudioString audioName = fromUTF8(name);
                cAudioString path = fromUTF8(filename);
                cAudioString ext = getExt(path);
                IAudioDecoderFactory* factory = getAudioDecoderFactory(toUTF8(ext));
 
                if(!factory) {
                        getLogger()->logError("AudioManager", "Failed to create Audio Source (%s): No decoder could be found for (.%s).", toUTF8(audioName), toUTF8(ext));
                        return NULL;
                }
 
                for(size_t i=0; i<dataSourcePriorityList.size(); ++i)
                {
                        const cAudioString dataSourceName = dataSourcePriorityList[i].second;
                        IDataSourceFactory* dataFactory = datasourcemap[dataSourceName];
                        if(dataFactory)
                        {
                                IDataSource* source = dataFactory->CreateDataSource(filename, stream);
                                if(source && source->isValid())
                                {
                                        IAudioDecoder* decoder = factory->CreateAudioDecoder(source);
                                        source->drop();
 
                                        IAudioSource* audio = createAudioSource(decoder, audioName, dataSourceName);
                                        if(audio != NULL)
                                                return audio;
 
                                        return NULL;
                                }
                        }
                }               
                return NULL;
    }
 
    IAudioSource* cAudioManager::createFromMemory(const char* name, const char* data, size_t length, const char* extension)
    {
                if(!Initialized) return NULL;
 
                cAudioMutexBasicLock lock(Mutex);
                cAudioString audioName = fromUTF8(name);
                cAudioString ext = fromUTF8(extension);
                IAudioDecoderFactory* factory = getAudioDecoderFactory(toUTF8(ext));
 
                if(!factory) {
                        getLogger()->logError("AudioManager", "Failed to create Audio Source (%s): Codec (.%s) is not supported.", toUTF8(audioName), toUTF8(ext));
                        return NULL;
                }
 
                cMemorySource* source = CAUDIO_NEW cMemorySource(data, length, true);
                if(source && source->isValid())
                {
                        IAudioDecoder* decoder = factory->CreateAudioDecoder(source);
                        source->drop();
 
                        IAudioSource* audio = createAudioSource(decoder, audioName, _CTEXT("cMemorySource"));
                        if(audio != NULL)
                                return audio;
                }
                return NULL;
    }
 
        IAudioSource* cAudioManager::createFromAudioBuffer(const char* name, AudioCaptureBuffer* pBiffer, unsigned int frequency, AudioFormats format)
        {
                return createFromRaw(name, pBiffer->getWriteBuffer(), pBiffer->getLength(), frequency, format);
        }
 
        IAudioSource* cAudioManager::createFromRaw(const char* name, const char* data, size_t length, unsigned int frequency, AudioFormats format)
        {
                if(!Initialized) return NULL;
 
                cAudioMutexBasicLock lock(Mutex);
                cAudioString audioName = fromUTF8(name);
                IAudioDecoderFactory* factory = getAudioDecoderFactory("raw");
 
                if(!factory) {
                        getLogger()->logError("AudioManager", "Failed to create Audio Source (%s): Codec (.raw) is not supported.", toUTF8(audioName));
                        return NULL;
                }
 
                cMemorySource* source = CAUDIO_NEW cMemorySource(data, length, true);
                if(source && source->isValid())
                {
                        IAudioDecoder* decoder = ((cRawAudioDecoderFactory*)factory)->CreateAudioDecoder(source, frequency, format);
                        source->drop();
 
                        IAudioSource* audio = createAudioSource(decoder, audioName, _CTEXT("cMemorySource"));
                        if(audio != NULL)
                                return audio;
                }
                return NULL;
        }
 
    IAudioBuffer* cAudioManager::createBuffer(const char* filename)
    {
                if(!Initialized) return NULL;
 
                cAudioMutexBasicLock lock(Mutex);
                cAudioString path = fromUTF8(filename);
                cAudioString ext = getExt(path);
                IAudioDecoderFactory* factory = getAudioDecoderFactory(toUTF8(ext));
 
                if(!factory) {
                        getLogger()->logError("AudioManager", "Failed to create Audio Buffer: No decoder could be found for (.%s).", toUTF8(ext));
                        return NULL;
                }
 
                for(size_t i=0; i<dataSourcePriorityList.size(); ++i)
                {
                        const cAudioString dataSourceName = dataSourcePriorityList[i].second;
                        IDataSourceFactory* dataFactory = datasourcemap[dataSourceName];
                        if(dataFactory)
                        {
                                IDataSource* source = dataFactory->CreateDataSource(filename, false);
                                if(source && source->isValid())
                                {
                                        IAudioDecoder* decoder = factory->CreateAudioDecoder(source);
                                        source->drop();
 
                    IAudioBuffer* buffer = CAUDIO_NEW cAudioBuffer(decoder);
 
                                        if(buffer != NULL)
                                                return buffer;
 
                                        return NULL;
                                }
                        }
                }
                return NULL;
    }
 
    IAudioSource* cAudioManager::createStatic(IAudioBuffer* buffer)
    {
        if(!Initialized) return NULL;
 
        // FIXME save a reference?
        IAudioSource *audio = CAUDIO_NEW cAudioStaticSource(buffer, AudioContext);
        return audio;
    }
 
    bool cAudioManager::registerAudioDecoder(IAudioDecoderFactory* factory, const char* extension)
    {
                cAudioMutexBasicLock lock(Mutex);
                cAudioString ext = fromUTF8(extension);
        decodermap[ext] = factory;
                getLogger()->logInfo("AudioManager", "Audio Decoder for extension .%s registered.", toUTF8(ext));
                return true;
    }
 
        void cAudioManager::unRegisterAudioDecoder(const char* extension)
        {
                cAudioMutexBasicLock lock(Mutex);
                cAudioString ext = fromUTF8(extension);
                decodermapIterator it = decodermap.find(ext);
                if(it != decodermap.end())
                {
                        decodermap.erase(it);
                        getLogger()->logInfo("AudioManager", "Audio Decoder for extension .%s unregistered.", toUTF8(ext));
                }
        }
 
        bool cAudioManager::isAudioDecoderRegistered(const char* extension)
        {
                cAudioMutexBasicLock lock(Mutex);
                cAudioString ext = fromUTF8(extension);
                decodermapIterator it = decodermap.find(ext);
                return (it != decodermap.end());
        }
 
        IAudioDecoderFactory* cAudioManager::getAudioDecoderFactory(const char* extension)
        {
                cAudioMutexBasicLock lock(Mutex);
                cAudioString ext = fromUTF8(extension);
                decodermapIterator it = decodermap.find(ext);
                if(it != decodermap.end())
                {
                        return it->second;
                }
                return NULL;
        }
 
        void cAudioManager::unRegisterAllAudioDecoders()
        {
                cAudioMutexBasicLock lock(Mutex);
                decodermap.clear();
        }
 
        bool compareDataSourcePriorities(std::pair<int, cAudioString> left, std::pair<int, cAudioString> right)
        {
                return (left.first > right.first);
        }
 
        bool cAudioManager::registerDataSource(IDataSourceFactory* factory, const char* name, int priority)
        {
                cAudioMutexBasicLock lock(Mutex);
                cAudioString safeName = fromUTF8(name);
        datasourcemap[safeName] = factory;
                dataSourcePriorityList.push_back(std::pair<int, cAudioString>(priority, safeName));
                std::sort(dataSourcePriorityList.begin(), dataSourcePriorityList.end(), compareDataSourcePriorities);
 
                getLogger()->logInfo("AudioManager", "Data Source named %s registered (Priority %i).", toUTF8(safeName), priority);
                return true;
        }
 
        void cAudioManager::unRegisterDataSource(const char* name)
        {
                cAudioMutexBasicLock lock(Mutex);
                cAudioString safeName = fromUTF8(name);
                datasourcemapIterator it = datasourcemap.find(safeName);
                if(it != datasourcemap.end())
                {
                        datasourcemap.erase(it);
                        getLogger()->logInfo("AudioManager", "Data Source named %s unregistered.", toUTF8(safeName));
                }
 
                for(size_t i=0; i<dataSourcePriorityList.size(); ++i)
                {
                        if(dataSourcePriorityList[i].second == safeName)
                        {
                                dataSourcePriorityList.erase(dataSourcePriorityList.begin()+i);
                                break;
                        }
                }
 
                std::sort(dataSourcePriorityList.begin(), dataSourcePriorityList.end(), compareDataSourcePriorities);
        }
 
        bool cAudioManager::isDataSourceRegistered(const char* name)
        {
                cAudioMutexBasicLock lock(Mutex);
                cAudioString safeName = fromUTF8(name);
                datasourcemapIterator it = datasourcemap.find(safeName);
                return (it != datasourcemap.end());
        }
 
        IDataSourceFactory* cAudioManager::getDataSourceFactory(const char* name)
        {
                cAudioMutexBasicLock lock(Mutex);
                cAudioString safeName = fromUTF8(name);
                datasourcemapIterator it = datasourcemap.find(safeName);
                if(it != datasourcemap.end())
                {
                        return it->second;
                }
                return NULL;
        }
 
        void cAudioManager::unRegisterAllDataSources()
        {
                cAudioMutexBasicLock lock(Mutex);
                datasourcemap.clear();
                dataSourcePriorityList.clear();
        }
 
        void cAudioManager::registerEventHandler(IManagerEventHandler* handler)
        {
                if(handler)
                {
                        eventHandlerList.push_back(handler);
                }
        }
 
        void cAudioManager::unRegisterEventHandler(IManagerEventHandler* handler)
        {
                if(handler)
                {
                        eventHandlerList.remove(handler);
                }
        }
 
        void cAudioManager::unRegisterAllEventHandlers()
        {
                eventHandlerList.clear();
        }
 
        void cAudioManager::signalEvent(Events sevent)
        {
                cAudioMutexBasicLock lock(Mutex);
                cAudioList<IManagerEventHandler*>::Type::iterator it = eventHandlerList.begin();
 
                if(it != eventHandlerList.end())
                {
                        switch(sevent)
                        {
                                case ON_INIT: 
                                        
                                        for(; it != eventHandlerList.end(); it++)
                                        {
                                                (*it)->onInit();
                                        }
 
                                        break;
                                
                                case ON_UPDATE:
 
                                        for(; it != eventHandlerList.end(); it++)
                                        {
                                                (*it)->onUpdate();
                                        }
 
                                        break;
 
                                case ON_RELEASE:
 
                                        for(; it != eventHandlerList.end(); it++)
                                        {
                                                (*it)->onRelease();
                                        }
 
                                        break;
 
                                case ON_SOURCECREATE:
 
                                        for(; it != eventHandlerList.end(); it++)
                                        {
                                                (*it)->onSourceCreate();
                                        }
 
                                        break;
 
                                case ON_DECODERREGISTER:
 
                                        for(; it != eventHandlerList.end(); it++)
                                        {
                                                (*it)->onDecoderRegister();
                                        }
 
                                        break;
 
                                case ON_DATASOURCEREGISTER:
 
                                        for(; it != eventHandlerList.end(); it++)
                                        {
                                                (*it)->onDataSourceRegister();
                                        }
 
                                        break;
                        }
                }
        }
 
    IAudioSource* cAudioManager::getSoundByName(const char* name)
    {
                cAudioMutexBasicLock lock(Mutex);
                cAudioString audioName = fromUTF8(name);
        audioIndexIterator i = audioIndex.find(audioName);
        if (i == audioIndex.end())
                {
                        return NULL;
                }
        return i->second;
    }
 
    void cAudioManager::releaseAllSources()
    {
                cAudioMutexBasicLock lock(Mutex);
                cAudioVector<IAudioSource*>::Type::iterator audioSourcesIter;
 
                cAudioVector<IAudioSource*>::Type deleteSources;
                for(audioSourcesIter = audioSources.begin(); audioSourcesIter != audioSources.end(); ++audioSourcesIter)
                {
                        if((*audioSourcesIter))
                                deleteSources.push_back(*audioSourcesIter);
                }
                for(audioSourcesIter = deleteSources.begin(); audioSourcesIter != deleteSources.end(); ++audioSourcesIter)
                        (*audioSourcesIter)->drop();
 
                deleteSources.clear();
                audioSources.clear();
                audioIndex.clear();
 
                cAudioVector<IAudioSource*>::Type::iterator managedAudioIter;
                for(managedAudioIter = managedAudioSources.begin(); managedAudioIter != managedAudioSources.end(); managedAudioIter++)
                {
                        if ((*managedAudioIter))
                        {
                                CAUDIO_DELETE (*managedAudioIter);
                        }
                }
                managedAudioSources.clear();
 
                cAudioVector<IAudioSource*>::Type::iterator managedAudioSourcesDelIter;
                for(managedAudioSourcesDelIter = managedAudioSourcesDelBuffer.begin(); managedAudioSourcesDelIter != managedAudioSourcesDelBuffer.end(); managedAudioSourcesDelIter++)
                {
                        if ((*managedAudioSourcesDelIter))
                        {
                                CAUDIO_DELETE (*managedAudioSourcesDelIter);
                        }
                }
                managedAudioSourcesDelBuffer.clear();
    }
 
        void cAudioManager::release(IAudioSource* source)
        {
                if(source)
                {               
                        cAudioMutexBasicLock lock(Mutex);
                        audioIndexIterator it = audioIndex.begin();
                        for ( it=audioIndex.begin(); it != audioIndex.end(); it++ )
                        {
                                if( it->second == source )
                                {
                                        audioIndex.erase(it);
                                        break;
                                }
                        }
                        for(unsigned int i=0; i<audioSources.size(); ++i)
                        {
                                if(source == audioSources[i])
                                {                                       
                                        audioSources.erase(audioSources.begin()+i);             
 
                                        if (source->getReferenceCount() <= 1)
                                                CAUDIO_DELETE source;
                                        else
                                                source->drop();
 
                                        break;
                                }
                        }
                }
        }
};