home *** CD-ROM | disk | FTP | other *** search
/ Game Audio Programming / GameAudioProgramming.iso / Game_Audio / audio_sdk / src / AudioLib / AudioMgr.h < prev    next >
C/C++ Source or Header  |  2002-07-11  |  8KB  |  283 lines
  1. /***********************************************************\
  2. Copyright (C) James Boer, 2002. 
  3. All rights reserved worldwide.
  4.  
  5. This software is provided "as is" without express or implied
  6. warranties. You may freely copy and compile this source into
  7. applications you distribute provided that the copyright text
  8. below is included in the resulting source code, for example:
  9. "Portions Copyright (C) James Boer, 2002"
  10. \***********************************************************/
  11. #ifndef __AUDIOMGR_H
  12. #define __AUDIOMGR_H
  13.  
  14. #include "Audio.h"
  15.  
  16. #include "BufferCache.h"
  17.  
  18. struct IDirectMusicLoader8;
  19. struct IDirectMusicPerformance8;
  20. struct IDirectSound8;
  21. struct IDirectSoundBuffer;
  22. struct IDirectMusicAudioPath;
  23.  
  24. namespace Audio
  25. {
  26.  
  27. class Sound;
  28. class Sound3D;
  29. class Segment;
  30. class AudioScript;
  31. class Listener;
  32.  
  33. /*
  34. Thanks to:
  35. StΘphane PETIT (S.Petit@cryo-interactive.com)
  36. Technical Direction - Programming Department Manager
  37. Cryo Interactive Entertainment - 24, rue Marc Seguin - 75018 Paris - France
  38. */
  39. static int LinearToLogVol(double fLevel)
  40. {
  41.     // Clamp the value
  42.     if(fLevel <= 0.0f)
  43.         return DSBVOLUME_MIN;
  44.     else if(fLevel >= 1.0f)
  45.         return 0;
  46.     return (long) (-2000.0 * log10(1.0f / fLevel));
  47. }
  48.  
  49. static float LogToLinearVol(int iLevel)
  50. {
  51.     // Clamp the value
  52.     if(iLevel <= -9600)
  53.         return 0.0f;
  54.     else if(iLevel >= 0)
  55.         return 1.0f;
  56.     return pow(10, double(iLevel + 2000) / 2000.0f) / 10.0f;
  57. }
  58.  
  59. // Unknown contributor (thanks):
  60. // use a linear scale from 0.0 (silence) to 1.0 (full volume)
  61. static int VolumeToDecibels(float vol) 
  62. {
  63.     if (vol>=1.0F) 
  64.         return 0;
  65.     if (vol<=0.0F) 
  66.         return DSBVOLUME_MIN;
  67.     static const float adj=3321.928094887F;  // 1000/log10(2)
  68.     return int(float(log10(vol)) * adj);
  69. }
  70.  
  71.  
  72. typedef std::vector<Sound*> SoundVector;
  73. typedef std::vector<Sound3D*> Sound3DVector;
  74. typedef std::vector<Segment*> SegmentVector;
  75.  
  76. typedef std::queue<Sound*> SoundQueue;
  77. typedef std::queue<Sound3D*> Sound3DQueue;
  78. typedef std::queue<Segment*> SegmentQueue;
  79.  
  80. typedef std::list<Sound*> SoundList;
  81. typedef std::list<Sound3D*> Sound3DList;
  82. typedef std::list<Segment*> SegmentList;
  83.  
  84.  
  85. class AudioManager : public IAudioManager
  86. {
  87. // Interface functions
  88. public:
  89.     bool Init(const AudioMgrInit& init);
  90.     void Term();
  91.  
  92.     bool IsInitialized() const;
  93.     bool GetStats(AudioMgrStats& stats) const;
  94.  
  95.     // Object create and destroy functions
  96.     bool CreateSound(ISound*& pSound);
  97.     bool CreateSound3D(ISound3D*& pSound3D);
  98.     bool CreateSegment(ISegment*& pSegment);
  99.     bool CreateDLS(IDLS*& pDLS);
  100.     bool CreateAudioScript(IAudioScript*& pScript);
  101.  
  102.     // This interface is unique in that it will return a single object created internally
  103.     bool GetListener(IListener*& pListener);
  104.  
  105.     bool SetSoundVolume(float fVolume);
  106.     bool GetSoundVolume(float& fVolume) const;
  107.  
  108.     bool SetMusicVolume(float fVolume);
  109.     bool GetMusicVolume(float& fVolume) const;
  110.  
  111.     bool StopAll();
  112.     bool PauseAll();
  113.     bool ResumeAll();
  114.  
  115.     bool GetCurrentSegment(ISegment*& pSegment) const;
  116.     bool GetNextSegment(ISegment*& pSegment) const;
  117.  
  118.     bool CreateAudioStream(IAudioStream*& pStream);
  119.  
  120. // Concrete functions
  121. public:
  122.     AudioManager();
  123.     virtual ~AudioManager();
  124.  
  125.     void Clear();
  126.  
  127.     // DX object accessors
  128.     IDirectMusicLoader8*        Loader()        {  return m_pLoader;  }
  129.     IDirectSound8*                DirectSound()    {  return m_pDirectSound;  }
  130.     IDirectSoundBuffer*            PrimaryBuffer() {  return m_pPrimaryBuffer;  }
  131.     IDirectMusicPerformance8*    Performance(bool bMusic)    
  132.     {  return (bMusic) ? m_pMusicPerformance : m_pSoundPerformance;  }
  133.     DSCAPS&                        GetCaps()        {  return m_DSCaps;  }        
  134.  
  135.     // Hardware management functions
  136.     bool ForceSoftware(bool b3D) const            {  return (b3D) ? m_Stats.m_bForce3DSoftware : m_Stats.m_bForce2DSoftware;  }
  137.     uint32 GetNumBuffers(bool b3D) const        {  return (b3D) ? m_Stats.m_n3DSoundsLoaded : m_Stats.m_n2DSoundsLoaded;  }
  138.     const AudioMgrInit* GetInit() const            {  return &m_Init;  }
  139.  
  140.     bool CanAddSound() const;
  141.     bool CanAddSound3D() const;
  142.     bool CanAddSegment() const;
  143.     bool RemoveSound(Sound* pSound);
  144.     bool RemoveSound3D(Sound3D* pSound3D);
  145.     bool RemoveSegment(Segment* pSegment);
  146.     void ResetSoundLimit();
  147.     void ResetSound3DLimit();
  148.  
  149.     // Stream insertion and removal
  150.     void InsertStream(Sound* pStream);
  151.     void RemoveStream(Sound* pStream);
  152.  
  153.     // Segment access functions
  154.     ISegment*    GetCurrentSegment()    const            {  return m_pCurrentSegment;  }
  155.     void        SetCurrentSegment(ISegment* pSeg)    {  m_pCurrentSegment = pSeg;  }
  156.     ISegment*    GetNextSegment() const                {  return m_pNextSegment;  }
  157.     void        SetNextSegment(ISegment* pSeg)        {  m_pNextSegment = pSeg;  }
  158.  
  159.     // Loaded list functions
  160.     void OnLoadSound(Sound* pSound);
  161.     void OnUnloadSound(Sound* pSound);
  162.     void OnLoadSound3D(Sound3D* pSound3D);
  163.     void OnUnloadSound3D(Sound3D* pSound3D);
  164.     void OnLoadSegment(Segment* pSegment);
  165.     void OnUnloadSegment(Segment* pSegment);
  166.  
  167.     // Insert the audio element into the pending load lists
  168.     void ScheduleLoad(Sound* pSound);
  169.     void ScheduleLoad(Sound3D* pSound3D);
  170.     void ScheduleLoad(Segment* pSegment);
  171.  
  172.     // Are we loading asynchronously?
  173.     bool LoadAsync()                                {  return m_Init.m_bLoadAsyncronously;  }
  174.  
  175.     void AdjustVolume(Sound* pSound);
  176.     void AdjustVolume(Segment* pSound);
  177.  
  178.     uint32 GetOptimalSampleBits()                    {  return m_Init.m_nOptimalSampleBits;  }
  179.     uint32 GetOptimalSampleRate()                    {  return m_Init.m_nOptimalSampleRate;  }
  180.  
  181.     char*    GetAudioSystemPath()                    {  return m_pszAudioSystemPath;  }
  182.     char*    GetCurrentWorkingPath()                    {  return m_pszCurrentWorkingPath;  }
  183.  
  184.     CRITICAL_SECTION& GetUpdateCS()                    {  return m_csAudioUpdate;  }
  185.  
  186.     BufferCache* GetBufferCache()                    {  return &m_BufferCache;  }
  187.  
  188. private:
  189.  
  190.  
  191.     // Separate thread for timed events
  192.     static void TimeEvent(LPVOID lpv);
  193.     // Service all currently playing streaming buffers
  194.     void ServiceStreamingBuffers();
  195.  
  196.     // Separate thread used to update the music system
  197.     static void MusicEventThread(LPVOID lpv);
  198.     void UpdateMusic();
  199.  
  200.     // Thread used for loading audio elements asyncronously
  201.     static void LoadingThread(LPVOID lpv);
  202.     void ServiceLoading();
  203.  
  204.  
  205.     // DirectMusic interfaces
  206.     IDirectMusicLoader8*        m_pLoader;
  207.     IDirectMusicPerformance8*    m_pSoundPerformance;
  208.     IDirectMusicPerformance8*    m_pMusicPerformance;
  209.  
  210.     // DirectSound interfaces and structures
  211.     IDirectSound8*                m_pDirectSound;
  212.     IDirectSoundBuffer*            m_pPrimaryBuffer;
  213.     DSCAPS                        m_DSCaps;
  214.  
  215.     // Verification that the system has been initialized;
  216.     bool                        m_bInitialized;
  217.  
  218.     // Stored path information for the audio system
  219.     char                        m_pszAudioSystemPath[MAX_PATH];
  220.     char                        m_pszCurrentWorkingPath[MAX_PATH];
  221.  
  222.     // Initialization structure
  223.     AudioMgrInit                m_Init;
  224.  
  225.     // Buffer and segment usage members
  226.     AudioMgrStats                m_Stats;
  227.  
  228.     // Ordered sets of all currently loaded objects by type
  229.     SoundVector                    m_LoadedSound;
  230.     Sound3DVector                m_LoadedSound3D;
  231.     SegmentVector                m_LoadedSegment;
  232.  
  233.     // Caching system for equal sized buffers
  234.     BufferCache                    m_BufferCache;
  235.  
  236.     // Asynchronous load pending lists for sounds and segments
  237.     SoundQueue                    m_SoundLoadPending;
  238.     SoundQueue                    m_SoundLoadTemp;
  239.     Sound3DQueue                m_Sound3DLoadPending;
  240.     Sound3DQueue                m_Sound3DLoadTemp;
  241.     SegmentQueue                m_SegmentLoadPending;
  242.     SegmentQueue                m_SegmentLoadTemp;
  243.     HANDLE                        m_hLoadNotify;
  244.  
  245.     // Sound and music volume level variable and structures
  246.     float                        m_fSoundVolume;
  247.     float                        m_fMusicVolume;
  248.  
  249.     // Streaming members
  250.     SoundList                    m_SoundStreamProcess;
  251.     SoundList                    m_SoundStreamRemoval;
  252.  
  253.     // The listener object - used for 3d audio positioning
  254.     Listener*                    m_pListener;
  255.  
  256.     // Current and next music segments
  257.     ISegment*                    m_pCurrentSegment;
  258.     ISegment*                    m_pNextSegment;
  259.  
  260.     // Music update thread handle
  261.     HANDLE                        m_hMusicNotify;
  262.  
  263.     // Used to properly synchronize and shut down the manager's multiple threads
  264.     HANDLE                        m_hTerm[2];
  265.  
  266.     // Critical sections ensuring threads are properly syncronized with
  267.     // other thread's functions
  268.     CRITICAL_SECTION            m_csAudioUpdate;
  269.     CRITICAL_SECTION            m_csLoading;
  270.     CRITICAL_SECTION            m_csLoadScheduling;
  271.  
  272.     // Audio file factory information
  273.     IAudioStreamFactory*        m_pStreamFactory;
  274. };
  275.  
  276.  
  277. static AudioManager* DXAudioMgr()
  278. {  return static_cast<AudioManager*>(AudioMgr());  }
  279.  
  280.  
  281. }; // namespace Audio
  282.  
  283. #endif // __AUDIOMGR_H