cAudioManager.h

// Copyright (c) 2008-2010 Raynaldo (Wildicv) Rivera, Joshua (Dark_Kilauea) Jones
// This file is part of the "cAudio Engine"
// For conditions of distribution and use, see copyright notice in cAudio.h

#ifndef CAUDIOMANAGER_H_INCLUDED
#define CAUDIOMANAGER_H_INCLUDED

#include <map>
#include <string>
#include <vector>

#include "cAudioSource.h"
#include "../include/IAudioDecoderFactory.h"
#include "cListener.h"
#include "../include/IAudioManager.h"
#include "../Headers/cMutex.h"
#include "../Headers/cAudioEffects.h"

#include <AL/al.h>
#include <AL/alc.h>

#ifdef CAUDIO_PLATFORM_LINUX
#include <AL/alext.h>
#endif

namespace cAudio
{
        class IAudioSource;

    class cAudioManager : public IAudioManager
    {
    public:
                enum Events{
                        ON_INIT,
                        ON_UPDATE,
                        ON_RELEASE,
                        ON_SOURCECREATE,
                        ON_DECODERREGISTER,
                        ON_DATASOURCEREGISTER,
                };

                cAudioManager() : Device(NULL), Context(NULL), EFXSupported(false), Initialized(false) { }
                virtual ~cAudioManager() { }

                virtual bool initialize(const char* deviceName = 0x0, int outputFrequency = -1, int eaxEffectSlots = 4);      
                virtual void shutDown();     
                virtual void update();
                virtual IAudioSource* getSoundByName(const char* name);       
                virtual void releaseAllSources();
                virtual void release(IAudioSource* source);

                virtual const char* getAvailableDeviceName(unsigned int index);
                virtual unsigned int getAvailableDeviceCount();
                virtual const char* getDefaultDeviceName();

                virtual IAudioSource* create(const char* name, const char* filename, bool stream = false);
                virtual IAudioSource* createFromMemory(const char* name, const char* data, size_t length, const char* extension);
                virtual IAudioSource* createFromRaw(const char* name, const char* data, size_t length, unsigned int frequency, AudioFormats format);
      
                virtual bool registerAudioDecoder(IAudioDecoderFactory* factory, const char* extension);
                virtual void unRegisterAudioDecoder(const char* extension);
                virtual bool isAudioDecoderRegistered(const char* extension);
                virtual IAudioDecoderFactory* getAudioDecoderFactory(const char* extension);
                virtual void unRegisterAllAudioDecoders();

                virtual bool registerDataSource(IDataSourceFactory* factory, const char* name, int priority);
                virtual void unRegisterDataSource(const char* name);
                virtual bool isDataSourceRegistered(const char* name);
                virtual IDataSourceFactory* getDataSourceFactory(const char* name);
                virtual void unRegisterAllDataSources();

                virtual void registerEventHandler(IManagerEventHandler* handler);
                virtual void unRegisterEventHandler(IManagerEventHandler* handler) ;
                virtual void unRegisterAllEventHandlers();

                void getAvailableDevices();

                virtual IListener* getListener() { return &initlistener; }

#ifdef CAUDIO_EFX_ENABLED
                virtual IAudioEffects* getEffects() { return &initEffects; }
#endif

        private:
                cAudioMutex Mutex;

                ALCcontext* Context;
                ALCdevice* Device;

                bool EFXSupported;

                bool Initialized;

                std::map<std::string, IAudioSource*> audioIndex;
                std::vector<IAudioSource*> audioSources;
                std::map<std::string, IAudioDecoderFactory*> decodermap; 
                std::map<std::string, IDataSourceFactory*> datasourcemap;
                std::vector< std::pair<int, std::string> > dataSourcePriorityList;

                cListener initlistener;
#ifdef CAUDIO_EFX_ENABLED
                cAudioEffects initEffects;
#endif
                bool checkError();

                std::vector<std::string> AvailableDevices;
                std::string DefaultDevice;

                void signalEvent(Events sevent);
                
                std::list<IManagerEventHandler*> eventHandlerList;
    };
}

#endif