AudioEngine.h

//---------------------------------------
// File: AudioEngine.h
// Author: WangTian
//
// Desc: ParaEngine Audio Engine
// Email: mitnick_wang@hotmail.com
//          wangtian@cad.zju.edu.cn
// Date: 2006.8
//---------------------------------------

#pragma once
#include <xact.h>
#include <xact3d.h>
#include <map>
#include <vector>
#include <list>

#include "util/mutex.h"

using namespace std;

namespace ParaEngine
{
    struct ParaAudio_3DCUE
    {
        bool bActive;
        IXACTCue* pCue;
        Vector3 vEmitterPosition;
        string strKeyName;
    };

    class CAudioEngine
    {
    public:
        typedef map<string, ParaAudio_3DCUE>    POOL_3DCUE_TYPE;

        CAudioEngine(void);
        ~CAudioEngine(void);
        static CAudioEngine * GetInstance();

        HRESULT InitAudioEngine();
        void CleanupAudioEngine();

        //
        // Only for documentation
        // void WINAPI AudioEngineNotificationCallback(const XACT_NOTIFICATION* pNotification)

        bool IsValid();

        inline bool IsValidAndEnabled(){return IsValid() && IsAudioEngineEnabled();};

        void DoWork();

    //
    // recording functions
    //
    public:
        const char* GetRecordingDeviceEnum();

        const char* GetRecordingFormatEnum();

        bool SetRecordingOutput(const char* sOutputFile, int nDeviceIndex, int nWaveFormatIndex);

        bool BeginRecording();

        bool IsRecording();

        bool IsRecordingPaused();

        const char* GetLastRecordedData(int nTimeLength);

        bool PauseOrResumeRecording(int nState);

        bool StopRecording();

        void SetVolume(float fVolume);

        float GetVolume();
    private:
        HRESULT InitSoundCapture();

        HRESULT ReleaseSoundCapture();

        HRESULT ScanAvailableInputFormats();

        void GetWaveFormatFromIndex( INT nIndex, WAVEFORMATEX* pwfx );

        void ConvertWaveFormatToString( WAVEFORMATEX* pwfx, TCHAR* strFormatName, int cchFormatName );

        HRESULT InitNotifications();

        HRESULT DestoryNotifications();

        const static int NUM_REC_NOTIFICATIONS = 10;
        
        LPDIRECTSOUNDCAPTURE       m_pDSCapture;
        LPDIRECTSOUNDCAPTUREBUFFER m_pDSBCapture;
        LPDIRECTSOUNDNOTIFY        m_pDSNotify;
        GUID                       m_guidCaptureDevice;
        BOOL                       m_bRecording;
        WAVEFORMATEX               m_wfxInput;
        DSBPOSITIONNOTIFY          m_aPosNotify[ NUM_REC_NOTIFICATIONS + 1 ];  
        BOOL                       m_abInputFormatSupported[20];
        DWORD                      m_dwCaptureBufferSize;
        DWORD                      m_dwNextCaptureOffset;
        DWORD                      m_dwNotifySize;
        CWaveFile*                 m_pWaveFile;
        bool m_bCaptureDeviceAvailable;
        int m_nCaptureDeviceIndex;
        int m_nWaveFormatIndex;
        string m_sCapureFileName;

        string m_strCaptureFormats;
        
        HRESULT RecordCapturedData();

        static unsigned int __stdcall RecordSoundLoop(void* parameter);
        
        HANDLE m_hRecordingThread;
    //
    // playing functions
    //
    public:
        // ---------------- Audio Engine Functions ----------------
        bool IsAudioEngineEnabled();
        HRESULT EnableAudioEngine( );
        HRESULT DisableAudioEngine( );
        HRESULT PauseCategory(const char * strCategoryName);
        HRESULT ResumeCategory(const char * strCategoryName);
        HRESULT StopCategory(const char * strCategoryName);
        HRESULT EnableAudioBank(const char * strBankName);
        HRESULT DisableAudioBank(const char * strBankName);
        string GetCurrentAudioBankName();
        HRESULT SetAudioStereo();
        HRESULT SetAudio5Point1();
        int GetAudioFormat();

        // ---------------- Background Functions ----------------
        HRESULT PlayBGMusic( const char * strBGMusicName );
        HRESULT PauseBGMusic( );
        HRESULT ResumeBGMusic( );
        HRESULT StopBGMusic( );
        bool IsBGMusicEnabled();
        HRESULT EnableBGMusic( );
        HRESULT DisableBGMusic( );
        float GetBGMusicVolume( );
        HRESULT SetBGMusicVolume( const float fVolume );

        // ---------------- Dialog Functions ----------------
        HRESULT PlayDialog( const char * strDialogName , const char * strScript);
        HRESULT SkipDialog( );
        HRESULT PauseDialog( );
        HRESULT ResumeDialog( );
        HRESULT StopDialog( );
        bool IsDialogEnabled();
        HRESULT EnableDialog( );
        HRESULT DisableDialog( );
        float GetDialogVolume( );
        HRESULT SetDialogVolume( const float fVolume );

        // ---------------- Ambient Sound Functions ----------------
        HRESULT PlayAmbientSound( const char * strAmbientSoundName );
        HRESULT PauseAmbientSound( const char * strAmbientSoundName );
        HRESULT ResumeAmbientSound( const char * strAmbientSoundName );
        HRESULT StopAmbientSound( const char * strAmbientSoundName );
        bool IsAmbientSoundEnabled();
        HRESULT EnableAmbientSound( );
        HRESULT DisableAmbientSound( );
        float GetAmbientSoundVolume( );
        HRESULT SetAmbientSoundVolume( const float fVolume );

        // ---------------- UserInterface Sound Functions ----------------
        HRESULT PlayUISound( const char * strUISoundName );
        float GetUISoundVolume( );
        HRESULT SetUISoundVolume( const float fVolume );

        // ---------------- 3D Sound Functions ----------------

        HRESULT PlayStatic3DSound( const char * str3DSoundName, const char * assetName, float x, float y, float z);
        HRESULT PauseStatic3DSound( const char * assetName );
        HRESULT ResumeStatic3DSound( const char * assetName );
        HRESULT StopStatic3DSound( const char * assetName );
        //          this is the name of the base class BaseObject
        HRESULT PlayDynamic3DSound( const char * str3DSoundName, const char * objectName );
        float Get3DSoundVolume( );
        HRESULT Set3DSoundVolume( const float fVolume );

        // ---------------- Interactive Sound Functions ----------------
        HRESULT PlayInteractiveSound( const char * strInteractiveSoundName );
        float GetInteractiveSoundVolume( );
        HRESULT SetInteractiveSoundVolume( const float fVolume );


        // ---------------- Loading Functions ----------------
        HRESULT LoadSoundBank(const char* filename);
        HRESULT UnLoadSoundBank(const char* filename=NULL);

        HRESULT LoadInMemoryWaveBank(const char* filename);
        HRESULT UnLoadInMemoryWaveBank(const char* filename=NULL);

        HRESULT LoadStreamWaveBank(const char* filename);
        HRESULT UnLoadStreamWaveBank(const char* filename=NULL);
        
    private:
        HRESULT FindMediaFileCch(CHAR* strDestPath, int cchDest, LPCSTR strFilename);
        HRESULT PlayAmbientWater();

        void UpdateAudio();
    private:

        IXACTEngine* m_pEngine;

        HANDLE m_hStreamingWaveBankFile;
        VOID* m_pbWaveBankInMemory; // Handle to in memory wave bank data.  Its memory mapped so call UnmapViewOfFile() upon cleanup to release file
        VOID* m_pbSoundBank; // Pointer to sound bank data.  Call delete on it when the sound bank is destroyed

        bool m_bEnableAudioEngine;
        bool m_bEnableBGMusic;
        bool m_bEnableDialogMusic;
        bool m_bEnableAmbientSound;
        bool m_bEnableUISound;
        bool m_bEnable3DSound;
        bool m_bEnableInteractiveSound;

        float m_fBGMusicVolume;
        float m_fDialogMusicVolume;
        float m_fAmbientSoundVolume;
        float m_fUISoundVolume;
        float m_f3DSoundVolume;
        float m_fInteractiveSoundVolume;

        string m_strCurrentAudioBankName;
        bool m_bInitializeBanks;

        typedef pair <XACTINDEX, IXACTCue*> CuePointerPair;
        map<XACTINDEX, IXACTCue*> m_mapAmbientCuePointer;

        X3DAUDIO_HANDLE m_x3DInstance;
        int m_nFrameToApply3DAudio;
        X3DAUDIO_DSP_SETTINGS m_dspSettings;
        X3DAUDIO_LISTENER m_listener;
        X3DAUDIO_EMITTER m_emitter;
        FLOAT32 m_DelayTimes[2];
        FLOAT32 m_MatrixCoefficients[2 * 2];

        POOL_3DCUE_TYPE m_pool_3D_Static_Cues;
        POOL_3DCUE_TYPE m_pool_3D_Dynamic_Cues;

        ParaEngine::mutex  m_mutex;

        bool m_bHandleStreamingWaveBankPrepared;
        bool m_bHandleDialogCuePrepared;
        bool m_bHandleDialogCueStop;
        bool m_bHandleBGCuePrepared;
        bool m_bHandleBGCueStop;

        IXACTSoundBank* m_pSoundBank;
        IXACTWaveBank* m_pWaveBankInMemory;
        IXACTWaveBank* m_pWaveBankStream;

        bool m_bStreamingWaveBankPrepared;

        XACTINDEX m_iCurrentBGMusic;
        IXACTCue* m_pCurrentBGMusic;

        XACTINDEX m_iCurrentDialog;
        IXACTCue* m_pCurrentDialog;

        map<string, IXACTWave*> m_codeDrivenFiles;
        
    public:
        IXACTWaveBank* GetWaveBankStream();
        IXACTCue* GetCurrentDialog();
        IXACTCue* GetCurrentBGMusic();
        void SetHandleStreamingWaveBankPrepared( bool bHandle );
        void SetHandleDialogCuePrepared( bool bHandle );
        void SetHandleDialogCueStop( bool bHandle );
        void SetHandleBGCuePrepared( bool bHandle );
        void SetHandleBGCueStop( bool bHandle );

        HRESULT PlayWaveFile(PCSTR szWavePath,XACTLOOPCOUNT nLoopCount, WORD wStreamingPacketSize=0,DWORD dwPlayOffset=0, DWORD dwAlignment=2048);
        HRESULT StopWaveFile(PCSTR szWavePath, DWORD dwFlags);

        HRESULT ReleaseWaveFile(PCSTR szWavePath);


        bool IsWaveFileInQueue(const string& filename);
    };
}


// Old Audio Engine Interface

//HRESULT PlayBGMusic(const char * name);
//HRESULT EnableBGMusic( );
//HRESULT DisableBGMusic( );

//HRESULT PlayUISound(const char * name);

// --------- Audio Engine ---------
// void EnableAudioEngine(bool enable);
// bool IsAudioEngineEnabled();

//HRESULT PlayAudioCue( XACTINDEX iCueIndex );
//HRESULT StopAudioCue( XACTINDEX iCueIndex );

//XACTINDEX GetCueIndexByName(const char * strName);