cAudioSource.h

// 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
 
#pragma once
 
#include <list>
#include <string>
#include <vector>
 
#include "cOpenALUtil.h"
#include "cMutex.h"
#include "cEFXFunctions.h"
#include "cMemoryOverride.h"
#include "IAudioSource.h"
#include "cVector3.h"
#include "ILogger.h"
#include "cSTLAllocator.h"
#include "IAudioDeviceContext.h"
 
namespace cAudio
{
    
    class cAudioSourceBase : public IAudioSource, public cMemoryOverride
    {
    public:
 
                enum Events{
                        ON_UPDATE,
                        ON_RELEASE,
                        ON_PLAY,
                        ON_PAUSE,
                        ON_STOP,
                };
 
        cAudioSourceBase(IAudioDeviceContext* context);
        virtual ~cAudioSourceBase();
 
                virtual bool isPlaying() const;
                virtual bool isPaused() const;
                virtual bool isStopped() const;
 
                virtual void setPosition(const cVector3& position);
                virtual void setVelocity(const cVector3& velocity);
                virtual void setDirection(const cVector3& direction);
 
                virtual void setRolloffFactor(const float& rolloff);
                virtual void setStrength(const float& soundstrength);
                virtual void setMinDistance(const float& minDistance);
                virtual void setMaxAttenuationDistance(const float& maxDistance);
 
                virtual void setPitch(const float& pitch);
                virtual void setVolume(const float& volume);
                virtual void setMinVolume(const float& minVolume);
                virtual void setMaxVolume(const float& maxVolume);
 
                virtual void setInnerConeAngle(const float& innerAngle);
                virtual void setOuterConeAngle(const float& outerAngle);
                virtual void setOuterConeVolume(const float& outerVolume);
 
                virtual void setDopplerStrength(const float& dstrength); 
                virtual void setDopplerVelocity(const cVector3& dvelocity);
 
                virtual void move(const cVector3& position);
 
                virtual cVector3 getPosition() const;
                virtual cVector3 getVelocity() const;
                virtual cVector3 getDirection() const;
 
                virtual float getRolloffFactor() const;
                virtual float getStrength() const;
                virtual float getMinDistance() const;
                virtual float getMaxDistance() const;
 
        virtual bool isRelative() const;
        virtual float calculateGain() const;
 
                virtual float getPitch() const;
                virtual float getVolume() const;
                virtual float getMinVolume() const;
                virtual float getMaxVolume() const;
 
                virtual float getInnerConeAngle() const;
                virtual float getOuterConeAngle() const;
                virtual float getOuterConeVolume() const;
 
                virtual float getDopplerStrength() const;
                virtual cVector3 getDopplerVelocity() const;
 
                virtual void registerEventHandler(ISourceEventHandler* handler);
                virtual void unRegisterEventHandler(ISourceEventHandler* handler);
                virtual void unRegisterAllEventHandlers();
 
    protected:
                cAudioMutex Mutex;
 
                void signalEvent(Events sevent);
 
                IAudioDeviceContext* Context;
                
                float Volume;
 
                ALuint Source; 
 
                ALenum oldState;
 
                cAudioVector<ISourceEventHandler*>::Type eventHandlerList;
    };
 
    class cAudioSource : public cAudioSourceBase {
    public:
#if CAUDIO_EFX_ENABLED == 1
                cAudioSource(IAudioDecoder* decoder, IAudioDeviceContext* context, cEFXFunctions* oALFunctions);
#else
                cAudioSource(IAudioDecoder* decoder, IAudioDeviceContext* context);
#endif
                ~cAudioSource();
 
                virtual bool play();
                virtual bool play2d(const bool& toLoop = false);
                virtual bool play3d(const cVector3& position, const float& soundstr = 1.0 , const bool& toLoop = false);
                
                virtual void pause();    
                virtual void stop();
                virtual void loop(const bool& toLoop);
                virtual bool seek(const float& seconds, bool relative = false);
 
        virtual bool setBuffer(IAudioBuffer* buffer) { return false; }
        virtual IAudioBuffer *getBuffer() { return NULL; }
 
                virtual float getTotalAudioTime();
                virtual int getTotalAudioSize();
                virtual int getCompressedAudioSize();
 
                virtual float getCurrentAudioTime();
                virtual int getCurrentAudioPosition();
                virtual int getCurrentCompressedAudioPosition();
 
                virtual bool update();
 
                virtual bool isValid() const;
                virtual bool isLooping() const;
 
                virtual bool drop(); 
 
#if CAUDIO_EFX_ENABLED == 1
                virtual unsigned int getNumEffectSlotsAvailable() const;
                virtual bool attachEffect(unsigned int slot, IEffect* effect);
                virtual void removeEffect(unsigned int slot);
 
                virtual bool attachFilter(IFilter* filter);
                virtual void removeFilter();
#endif
 
        private:
                void empty();
                bool stream(ALuint buffer);
 
                ALuint Buffers[CAUDIO_SOURCE_NUM_BUFFERS]; 
 
                IAudioDecoder* Decoder;
 
                bool Loop;
                bool Valid;
 
        float BufferTime;
        int BufferPosition;
 
#if CAUDIO_EFX_ENABLED == 1
                cEFXFunctions* EFX;
                void updateFilter(bool remove = false);
                void updateEffect(unsigned int slot, bool remove = false);
 
                IEffect* Effects[CAUDIO_SOURCE_MAX_EFFECT_SLOTS];
                unsigned int LastEffectTimeStamp[CAUDIO_SOURCE_MAX_EFFECT_SLOTS];
 
                IFilter* Filter;
                unsigned int LastFilterTimeStamp;
 
                unsigned int EffectSlotsAvailable;
#endif
    };
};