---

IAudio.h

Go to the documentation of this file.

/***********************************************************\
Copyright (C) James Boer, 2002. 
All rights reserved worldwide.

This software is provided "as is" without express or implied
warranties. You may freely copy and compile this source into
applications you distribute provided that the copyright text
below is included in the resulting source code, for example:
"Portions Copyright (C) James Boer, 2002"
\***********************************************************/
#ifndef __IAUDIO_H__
#define __IAUDIO_H__

#ifndef DOXYGEN_SHOULD_SKIP_THIS
namespace Audio
{
#endif /* DOXYGEN_SHOULD_SKIP_THIS */
 

static const float VOLUME_MIN                   = 0.0f;
static const float VOLUME_MAX                   = 1.0f;
static const float PAN_LEFT                             = -1.0f;
static const float PAN_CENTER                   = 0.0f;
static const float PAN_RIGHT                    = 1.0f;
static const float PITCH_ORIGINAL               = 1.0f;
static const uint32 MODE_NORMAL                 = 0x00000000;
static const uint32 MODE_HEADRELATIVE   = 0x00000001;
static const uint32 MODE_DISABLE                = 0x00000002;



class IAudioBase 
{
public:
        virtual void Destroy() = 0;

        virtual bool IsInitialized() const = 0;

        virtual bool Load() = 0;
        virtual bool Unload() = 0;
        virtual bool IsLoaded() const = 0;

#ifndef DOXYGEN_SHOULD_SKIP_THIS
protected:
        virtual ~IAudioBase() {};
#endif /* DOXYGEN_SHOULD_SKIP_THIS */

};



class IPlayable : public IAudioBase
{
public:

        virtual bool Play() = 0;
        virtual bool Pause() = 0;
        virtual bool Stop() = 0;

        virtual bool IsPlaying() const = 0;
        virtual bool IsPaused() const = 0;
        virtual bool IsLooping() const = 0;
};


struct SoundProp
{
        SoundProp()     { Clear(); }
        void Clear()
        {
                m_fVolume = VOLUME_MAX;
                m_fPan = PAN_CENTER;
                m_fPitch = PITCH_ORIGINAL;
                m_nReadCursor = 0;
        }
        float   m_fVolume;
        float   m_fPan;
        float   m_fPitch;
        uint32  m_nReadCursor;

};


struct SoundInit
{
        SoundInit()     { Clear(); }
        void Clear()
        {
                m_sFileName.erase();
                m_bStreaming = false;
                m_bLooping = false;
                m_bMusic = false;
                m_nPriority = 0;
                m_Prop.Clear();
        }
        std::string m_sFileName;
        bool            m_bStreaming;
        bool            m_bLooping;
        bool            m_bMusic;

        uint32          m_nPriority;

        SoundProp       m_Prop;
};



class ISound : public IPlayable
{
public:
        virtual bool Init(const SoundInit& init) = 0;

        virtual bool SetProperties(const SoundProp& prop) = 0;
        virtual bool GetProperties(SoundProp& prop) const = 0;

        virtual bool SetVolume(float fVolume) = 0;
        virtual bool GetVolume(float& fVolume) const = 0;

        virtual bool SetPan(float fPan) = 0;
        virtual bool GetPan(float& fPan) const = 0;

        virtual bool SetPitch(float fPitch) = 0;
        virtual bool GetPitch(float& fPitch) const = 0;

        virtual bool SetReadCursor(uint32 nBytes) = 0;
        virtual bool GetReadCursor(uint32& nBytes) const = 0;

        virtual bool GetSourceSize(uint32& nBytes) const = 0;
};



struct Sound3DProp
{
        Sound3DProp()   { Clear(); }
        void Clear()
        {
                m_vPosition.x = 0;  m_vPosition.y = 0;  m_vPosition.z = 0;
                m_vVelocity.x = 0;  m_vVelocity.y = 0;  m_vVelocity.z = 0;
                m_vConeOrientation.x = 0;  m_vConeOrientation.y = 0;  m_vConeOrientation.z = 1.0f;
                m_nInsideConeAngle = 360;
                m_nOutsideConeAngle = 360;
                m_fConeOutsideVolume = VOLUME_MAX;
                m_fMinDistance = 1.0f;
                m_fMaxDistance = 1000.0f;
                m_nMode = MODE_NORMAL;
                m_fVolume = VOLUME_MAX;
                m_fPitch = PITCH_ORIGINAL;
                m_nReadCursor = 0;
        }
        AUDIOVECTOR     m_vPosition;
        AUDIOVECTOR     m_vVelocity;
        AUDIOVECTOR     m_vConeOrientation;

        uint32          m_nInsideConeAngle;

        uint32          m_nOutsideConeAngle;
        float           m_fConeOutsideVolume;
        float           m_fMinDistance;
        float           m_fMaxDistance;

        uint32          m_nMode;
        float   m_fVolume;
        float   m_fPitch;
        uint32  m_nReadCursor;
};



struct Sound3DInit
{
        Sound3DInit()   { Clear(); }
        void Clear()
        {
                m_sFileName.erase();
                m_bStreaming = false;
                m_bLooping = false;
                m_bMusic = false;
                m_nPriority = 0;
                m_Prop.Clear();
        }
        std::string m_sFileName;
        bool            m_bStreaming;
        bool            m_bLooping;
        bool            m_bMusic;

        uint32          m_nPriority;

        Sound3DProp     m_Prop;
};



class ISound3D : public IPlayable
{
public:
        virtual bool Init(const Sound3DInit& init) = 0;
        
        virtual bool SetProperties(const Sound3DProp& prop) = 0;
        virtual bool GetProperties(Sound3DProp& prop) const = 0;

        virtual bool SetPosition(const AUDIOVECTOR& vPosition) = 0;
        virtual bool GetPosition(AUDIOVECTOR& vPosition) const = 0;

        virtual bool SetVelocity(const AUDIOVECTOR& vVelocity) = 0;
        virtual bool GetVelocity(AUDIOVECTOR& vVelocity) const = 0;

        virtual bool SetMaxDistance(float fMaxDist) = 0;
        virtual bool GetMaxDistance(float& fMaxDist) const = 0;

        virtual bool SetMinDistance(float fMinDist) = 0;
        virtual bool GetMinDistance(float& fMinDist) const = 0;

        virtual bool SetConeAngles(uint32 nInside, uint32 nOutside) = 0;
        virtual bool GetConeAngles(uint32& nInside, uint32& nOutside) const = 0;

        virtual bool SetConeOrientation(const AUDIOVECTOR& vOrientation) = 0;
        virtual bool GetConeOrientation(AUDIOVECTOR& vOrientation) const = 0;

        virtual bool SetConeOutsideVolume(float fVolume) = 0;
        virtual bool GetConeOutsideVolume(float& fVolume) const = 0;

        virtual bool SetMode(uint32 nMode) = 0;
        virtual bool GetMode(uint32& nMode) const = 0;

        virtual bool SetVolume(float fVolume) = 0;
        virtual bool GetVolume(float& fVolume) const = 0;

        virtual bool SetPitch(float fPitch) = 0;
        virtual bool GetPitch(float& fPitch) const = 0;

        virtual bool SetReadCursor(uint32 nBytes) = 0;
        virtual bool GetReadCursor(uint32& nBytes) const = 0;

        virtual bool GetSourceSize(uint32& nBytes) const = 0;

        virtual IEAXBuffer* EAX() = 0;

        virtual IZoomFX* ZoomFX() = 0;


        virtual bool QuerySupport(const GUID& guid, uint32 nID, uint32* pTypeSupport) = 0;
        virtual bool Get(const GUID& guidProperty, uint32 nID, void* pInstanceData,
                uint32 nInstanceLength, void* pPropData, uint32 nPropLength, 
                uint32* pBytesReturned) = 0;
        virtual bool Set(const GUID& guidProperty, uint32 nID, void* pInstanceData,
                uint32 nInstanceLength, void* pPropData, uint32 nPropLength,
                bool bStoreProperty) = 0;
};



struct DLSInit
{
        DLSInit()       {  Clear();  }
        void Clear()
        {
                m_sFileName.erase();
        }

        std::string             m_sFileName;
};


class IDLS : public IAudioBase
{
public:

        virtual bool Init(const DLSInit& init) = 0;
        virtual bool Lock() = 0;
        virtual bool Unlock() = 0;

};



struct SegmentInit
{
        SegmentInit()   { Clear(); }
        void Clear()
        {
                m_sFileName.erase();
                m_bMusic = true;
                m_bLooping = false;
                m_pDLS = 0;
        }

        std::string                     m_sFileName;
        bool                            m_bLooping;
        bool                            m_bMusic;

        IDLS*                           m_pDLS;

};



class ISegment : public IPlayable
{
public:
        virtual bool Init(const SegmentInit& init) = 0;

};


struct AudioScriptInit
{
        AudioScriptInit()       { Clear(); }
        void Clear()
        {
                m_sFileName.erase();
                m_bMusic = true;
        }
        std::string                     m_sFileName;
        bool                            m_bMusic;

};


class IAudioScript : public IAudioBase
{
public:
        virtual bool Init(const AudioScriptInit& init) = 0;

        virtual bool SetVariable(std::string sVarName, int32 iVal) = 0;
        virtual bool GetVariable(std::string sVarName, int32& iVal) = 0;

        virtual bool CallRoutine(std::string sRoutineName) = 0;
#ifndef DOXYGEN_SHOULD_SKIP_THIS
protected:
        virtual ~IAudioScript() {};
#endif /* DOXYGEN_SHOULD_SKIP_THIS */
};


struct ListenerProp
{
        ListenerProp()  {  Clear();  }
        void Clear()
        {
                m_vPosition.x = 0.0f; m_vPosition.y = 0.0f; m_vPosition.z = 0.0f;
                m_vVelocity.x = 0.0f; m_vVelocity.y = 0.0f; m_vVelocity.z = 0.0f;
                m_vOrientFront.x = 0.0f; m_vOrientFront.y = 0.0f; m_vOrientFront.z = 1.0f;
                m_vOrientTop.x = 0.0f; m_vOrientTop.y = 1.0f; m_vOrientTop.z = 0.0f;
                m_fDistanceFactor = 1.0f;
                m_fRolloffFactor = 1.0f;
                m_fDopplerFactor = 1.0f;
        }
        AUDIOVECTOR     m_vPosition;
        AUDIOVECTOR     m_vVelocity;
        AUDIOVECTOR     m_vOrientFront;
        AUDIOVECTOR     m_vOrientTop;
        float           m_fDistanceFactor;

        float           m_fRolloffFactor;

        float           m_fDopplerFactor;
};

struct ListenerInit
{
        ListenerInit()  {  Clear();  }
        void Clear()
        {
                m_Prop.Clear();
        }
        ListenerProp    m_Prop;
};



class IListener
{
public:
        
        virtual bool Init(const ListenerInit& init) = 0;
        virtual void Term() = 0;

        virtual bool SetProperties(const ListenerProp& prop) = 0;
        virtual void GetProperties(ListenerProp& prop) const = 0;

        virtual bool SetPosition(const AUDIOVECTOR& vPos) = 0;
        virtual void GetPosition(AUDIOVECTOR& vPos) const = 0;

        virtual bool SetVelocity(const AUDIOVECTOR& vVel) = 0;
        virtual void GetVelocity(AUDIOVECTOR& vVel) const = 0;

        virtual bool SetOrientation(const AUDIOVECTOR& vFront, const AUDIOVECTOR& vTop) = 0;
        virtual void GetOrientation(AUDIOVECTOR& vFront, AUDIOVECTOR& vTop) const = 0;

        virtual bool SetDistanceFactor(float fDistanceFactor) = 0;
        virtual void GetDistanceFactor(float& fDistanceFactor) const = 0;

        virtual bool SetDopplerFactor(float fDopplerFactor) = 0;
        virtual void GetDopplerFactor(float& fDopplerFactor) const = 0;

        virtual bool SetRolloffFactor(float fRolloffFactor) = 0;
        virtual void GetRolloffFactor(float& fRolloffFactor) const = 0;

        virtual bool QuerySupport(const GUID& guid, uint32 nID, uint32* pTypeSupport) = 0;
        virtual bool Get(const GUID& guidProperty, uint32 nID, void* pInstanceData,
                uint32 nInstanceLength, void* pPropData, uint32 nPropLength, 
                uint32* pBytesReturned) = 0;
        virtual bool Set(const GUID& guidProperty, uint32 nID, void* pInstanceData,
                uint32 nInstanceLength, void* pPropData, uint32 nPropLength,
                bool bStoreProperty) = 0;

        virtual IEAXListener* EAX() = 0;
};


class IMusicCallback
{
public:
        virtual void OnSegmentStart()   {};
};



struct AudioMgrInit
{
        AudioMgrInit()  { Clear(); }
        void Clear()
        {
                m_hWnd = (HWND)0;
                m_bLoadAsyncronously = true;
                m_bForceSoftware = false;
                m_bUseMusicReverb = true;
                m_bUseEAX = true;
                m_bUseZoomFX = true;
                m_bAutoStream = false;
                m_bCacheBuffers = false;
                m_n2DHardwareBufferMin = 8;
                m_n3DHardwareBufferMin = 8;
                m_n2DHardwareBufferMax = 256;
                m_n3DHardwareBufferMax = 256;
                m_n2DSoftwareBufferMax = 256;
                m_n3DSoftwareBufferMax = 256;
                m_nSegmentMax = 256;
                m_nOptimalSampleBits = 16;
                m_nOptimalSampleRate = 44100;
                m_sWorkingPath.erase();
                m_pAudioStreamFactory = 0;
                m_pMusicCallback = 0;
        }
        HWND                                    m_hWnd;
        bool                                    m_bLoadAsyncronously;
        bool                                    m_bForceSoftware;
        bool                                    m_bUseMusicReverb;
        bool                                    m_bUseEAX;
        bool                                    m_bUseZoomFX;
        bool                                    m_bAutoStream;
        bool                                    m_bCacheBuffers;
        uint32                                  m_n2DHardwareBufferMin;
        uint32                                  m_n3DHardwareBufferMin;
        uint32                                  m_n2DHardwareBufferMax;
        uint32                                  m_n3DHardwareBufferMax;
        uint32                                  m_n2DSoftwareBufferMax;
        uint32                                  m_n3DSoftwareBufferMax;
        uint32                                  m_nSegmentMax;
        uint32                                  m_nOptimalSampleBits;
        uint32                                  m_nOptimalSampleRate;

        std::string                             m_sWorkingPath;
        IAudioStreamFactory*    m_pAudioStreamFactory;
        IMusicCallback*                 m_pMusicCallback;
        
};


struct AudioMgrStats
{
        AudioMgrStats() { Clear(); }
        void Clear()
        {
                m_bForce2DSoftware = false;
                m_bForce3DSoftware = false;
                m_n2DSoundsLoaded = 0;
                m_n3DSoundsLoaded = 0;
                m_nSegmentsLoaded = 0;
        }
        bool    m_bForce2DSoftware;
        bool    m_bForce3DSoftware;
        uint32  m_n2DSoundsLoaded;
        uint32  m_n3DSoundsLoaded;
        uint32  m_nSegmentsLoaded;
};



class IAudioManager
{
public:

        virtual bool Init(const AudioMgrInit& init) = 0;
        virtual void Term() = 0;

        virtual bool IsInitialized() const = 0;

        virtual bool GetStats(AudioMgrStats& stats) const = 0;

        virtual bool CreateSound(ISound*& pSound) = 0;
        virtual bool CreateSound3D(ISound3D*& pSound3D) = 0;
        virtual bool CreateSegment(ISegment*& pSegment) = 0;
        virtual bool CreateDLS(IDLS*& pDLS) = 0;

        virtual bool CreateAudioScript(IAudioScript*& pScript) = 0;

        virtual bool GetListener(IListener*& pListener) = 0;
        
        virtual bool SetSoundVolume(float fVolume) = 0;
        virtual bool GetSoundVolume(float& fVolume) const = 0;

        virtual bool SetMusicVolume(float fVolume) = 0;
        virtual bool GetMusicVolume(float& fVolume) const = 0;

        virtual bool StopAll() = 0;
        virtual bool PauseAll() = 0;
        virtual bool ResumeAll() = 0;

        virtual bool GetCurrentSegment(ISegment*& pSegment) const = 0;
        virtual bool GetNextSegment(ISegment*& pSegment) const = 0;

        virtual bool CreateAudioStream(IAudioStream*& pStream) = 0;
};

inline IAudioManager* AudioMgr()
{  return AudioLibFactory::GetAudioMgr();  }

#ifndef DOXYGEN_SHOULD_SKIP_THIS
}; // namespace Audio
#endif /* DOXYGEN_SHOULD_SKIP_THIS */

#endif // __IAUDIO_H__

---