LCOV - code coverage report
Current view: top level - source/soundmanager - SoundManager.cpp (source / functions) Hit Total Coverage
Test: 0 A.D. test coverage report Lines: 0 457 0.0 %
Date: 2022-06-14 00:41:00 Functions: 0 54 0.0 %

          Line data    Source code
       1             : /* Copyright (C) 2021 Wildfire Games.
       2             :  * This file is part of 0 A.D.
       3             :  *
       4             :  * 0 A.D. is free software: you can redistribute it and/or modify
       5             :  * it under the terms of the GNU General Public License as published by
       6             :  * the Free Software Foundation, either version 2 of the License, or
       7             :  * (at your option) any later version.
       8             :  *
       9             :  * 0 A.D. is distributed in the hope that it will be useful,
      10             :  * but WITHOUT ANY WARRANTY; without even the implied warranty of
      11             :  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      12             :  * GNU General Public License for more details.
      13             :  *
      14             :  * You should have received a copy of the GNU General Public License
      15             :  * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
      16             :  */
      17             : 
      18             : #include "precompiled.h"
      19             : 
      20             : #include "ISoundManager.h"
      21             : #include "SoundManager.h"
      22             : #include "data/SoundData.h"
      23             : #include "items/CBufferItem.h"
      24             : #include "items/CSoundItem.h"
      25             : #include "items/CStreamItem.h"
      26             : 
      27             : #include "lib/external_libraries/libsdl.h"
      28             : #include "ps/CLogger.h"
      29             : #include "ps/CStr.h"
      30             : #include "ps/ConfigDB.h"
      31             : #include "ps/Filesystem.h"
      32             : #include "ps/Profiler2.h"
      33             : #include "ps/Threading.h"
      34             : #include "ps/XML/Xeromyces.h"
      35             : 
      36             : #include <thread>
      37             : 
      38             : ISoundManager* g_SoundManager = NULL;
      39             : 
      40             : #define SOURCE_NUM 64
      41             : 
      42             : #if CONFIG2_AUDIO
      43             : 
      44             : class CSoundManagerWorker
      45             : {
      46             :     NONCOPYABLE(CSoundManagerWorker);
      47             : 
      48             : public:
      49           0 :     CSoundManagerWorker()
      50           0 :     {
      51           0 :         m_Items = new ItemsList;
      52           0 :         m_DeadItems = new ItemsList;
      53           0 :         m_Shutdown = false;
      54             : 
      55           0 :         m_WorkerThread = std::thread(Threading::HandleExceptions<RunThread>::Wrapper, this);
      56           0 :     }
      57             : 
      58           0 :     ~CSoundManagerWorker()
      59           0 :     {
      60           0 :         delete m_Items;
      61           0 :         CleanupItems();
      62           0 :         delete m_DeadItems;
      63           0 :     }
      64             : 
      65           0 :     bool Shutdown()
      66             :     {
      67           0 :         {
      68           0 :             std::lock_guard<std::mutex> lock(m_WorkerMutex);
      69             : 
      70           0 :             m_Shutdown = true;
      71             : 
      72           0 :             ItemsList::iterator lstr = m_Items->begin();
      73           0 :             while (lstr != m_Items->end())
      74             :             {
      75           0 :                 delete *lstr;
      76           0 :                 ++lstr;
      77             :             }
      78             : 
      79             :         }
      80             : 
      81           0 :         m_WorkerThread.join();
      82             : 
      83           0 :         return true;
      84             :     }
      85             : 
      86           0 :     void addItem(ISoundItem* anItem)
      87             :     {
      88           0 :         std::lock_guard<std::mutex> lock(m_WorkerMutex);
      89           0 :         m_Items->push_back(anItem);
      90           0 :     }
      91             : 
      92           0 :     void CleanupItems()
      93             :     {
      94           0 :         std::lock_guard<std::mutex> lock(m_DeadItemsMutex);
      95           0 :         AL_CHECK;
      96           0 :         ItemsList::iterator deadItems = m_DeadItems->begin();
      97           0 :         while (deadItems != m_DeadItems->end())
      98             :         {
      99           0 :             delete *deadItems;
     100           0 :             ++deadItems;
     101             : 
     102           0 :             AL_CHECK;
     103             :         }
     104           0 :         m_DeadItems->clear();
     105           0 :     }
     106             : 
     107             : private:
     108           0 :     static void RunThread(CSoundManagerWorker* data)
     109             :     {
     110           0 :         debug_SetThreadName("CSoundManagerWorker");
     111           0 :         g_Profiler2.RegisterCurrentThread("soundmanager");
     112             : 
     113           0 :         data->Run();
     114           0 :     }
     115             : 
     116           0 :     void Run()
     117             :     {
     118           0 :         while (true)
     119             :         {
     120             :             // Handle shutdown requests as soon as possible
     121           0 :             if (GetShutdown())
     122           0 :                 return;
     123             : 
     124           0 :             int pauseTime = 500;
     125           0 :             if (g_SoundManager->InDistress())
     126           0 :                 pauseTime = 50;
     127             : 
     128           0 :             {
     129           0 :                 std::lock_guard<std::mutex> workerLock(m_WorkerMutex);
     130             : 
     131           0 :                 ItemsList::iterator lstr = m_Items->begin();
     132           0 :                 ItemsList* nextItemList = new ItemsList;
     133             : 
     134           0 :                 while (lstr != m_Items->end())
     135             :                 {
     136           0 :                     AL_CHECK;
     137           0 :                     if ((*lstr)->IdleTask())
     138             :                     {
     139           0 :                         if ((pauseTime == 500) && (*lstr)->IsFading())
     140             :                             pauseTime = 100;
     141             : 
     142           0 :                         nextItemList->push_back(*lstr);
     143             :                     }
     144             :                     else
     145             :                     {
     146           0 :                         std::lock_guard<std::mutex> deadItemsLock(m_DeadItemsMutex);
     147           0 :                         m_DeadItems->push_back(*lstr);
     148             :                     }
     149           0 :                     ++lstr;
     150             : 
     151           0 :                     AL_CHECK;
     152             :                 }
     153             : 
     154           0 :                 delete m_Items;
     155           0 :                 m_Items = nextItemList;
     156             : 
     157           0 :                 AL_CHECK;
     158             :             }
     159           0 :             SDL_Delay(pauseTime);
     160           0 :         }
     161             :     }
     162             : 
     163             :     bool GetShutdown()
     164             :     {
     165           0 :         std::lock_guard<std::mutex> lock(m_WorkerMutex);
     166           0 :         return m_Shutdown;
     167             :     }
     168             : 
     169             : private:
     170             :     // Thread-related members:
     171             :     std::thread m_WorkerThread;
     172             :     std::mutex m_WorkerMutex;
     173             :     std::mutex m_DeadItemsMutex;
     174             : 
     175             :     // Shared by main thread and worker thread:
     176             :     // These variables are all protected by a mutexes
     177             :     ItemsList* m_Items;
     178             :     ItemsList* m_DeadItems;
     179             : 
     180             :     bool m_Shutdown;
     181             : 
     182             :     CSoundManagerWorker(ISoundManager* UNUSED(other)){};
     183             : };
     184             : 
     185           0 : void ISoundManager::CreateSoundManager()
     186             : {
     187           0 :     if (g_SoundManager)
     188             :         return;
     189             : 
     190           0 :     ALCdevice* device = alcOpenDevice(nullptr);
     191           0 :     if (!device)
     192             :     {
     193           0 :         LOGWARNING("No audio device was found.");
     194           0 :         return;
     195             :     }
     196             : 
     197           0 :     g_SoundManager = new CSoundManager(device);
     198           0 :     g_SoundManager->StartWorker();
     199             : }
     200             : 
     201           0 : void ISoundManager::SetEnabled(bool doEnable)
     202             : {
     203           0 :     if (g_SoundManager && !doEnable)
     204           0 :         SAFE_DELETE(g_SoundManager);
     205           0 :     else if (!g_SoundManager && doEnable)
     206           0 :         ISoundManager::CreateSoundManager();
     207           0 : }
     208           0 : void ISoundManager::CloseGame()
     209             : {
     210           0 :     if (CSoundManager* aSndMgr = (CSoundManager*)g_SoundManager)
     211           0 :         aSndMgr->SetAmbientItem(NULL);
     212           0 : }
     213             : 
     214           0 : void CSoundManager::al_ReportError(ALenum err, const char* caller, int line)
     215             : {
     216           0 :     LOGERROR("OpenAL error: %s; called from %s (line %d)\n", alGetString(err), caller, line);
     217           0 : }
     218             : 
     219           0 : void CSoundManager::al_check(const char* caller, int line)
     220             : {
     221           0 :     ALenum err = alGetError();
     222           0 :     if (err != AL_NO_ERROR)
     223           0 :         al_ReportError(err, caller, line);
     224           0 : }
     225             : 
     226           0 : Status CSoundManager::ReloadChangedFiles(const VfsPath& UNUSED(path))
     227             : {
     228             :     // TODO implement sound file hotloading
     229           0 :     return INFO::OK;
     230             : }
     231             : 
     232           0 : /*static*/ Status CSoundManager::ReloadChangedFileCB(void* param, const VfsPath& path)
     233             : {
     234           0 :     return static_cast<CSoundManager*>(param)->ReloadChangedFiles(path);
     235             : }
     236             : 
     237           0 : CSoundManager::CSoundManager(ALCdevice* device)
     238             :     : m_Context(nullptr), m_Device(device), m_ALSourceBuffer(nullptr),
     239             :     m_CurrentTune(nullptr), m_CurrentEnvirons(nullptr),
     240             :     m_Worker(nullptr), m_DistressMutex(), m_PlayListItems(nullptr), m_SoundGroups(),
     241             :     m_Gain(.5f), m_MusicGain(.5f), m_AmbientGain(.5f), m_ActionGain(.5f), m_UIGain(.5f),
     242             :     m_Enabled(false), m_BufferSize(98304), m_BufferCount(50),
     243             :     m_SoundEnabled(true), m_MusicEnabled(true), m_MusicPaused(false),
     244             :     m_AmbientPaused(false), m_ActionPaused(false),
     245             :     m_RunningPlaylist(false), m_PlayingPlaylist(false), m_LoopingPlaylist(false),
     246           0 :     m_PlaylistGap(0), m_DistressErrCount(0), m_DistressTime(0)
     247             : {
     248           0 :     CFG_GET_VAL("sound.mastergain", m_Gain);
     249           0 :     CFG_GET_VAL("sound.musicgain", m_MusicGain);
     250           0 :     CFG_GET_VAL("sound.ambientgain", m_AmbientGain);
     251           0 :     CFG_GET_VAL("sound.actiongain", m_ActionGain);
     252           0 :     CFG_GET_VAL("sound.uigain", m_UIGain);
     253             : 
     254           0 :     AlcInit();
     255             : 
     256           0 :     if (m_Enabled)
     257             :     {
     258           0 :         SetMasterGain(m_Gain);
     259           0 :         InitListener();
     260             : 
     261           0 :         m_PlayListItems = new PlayList;
     262             :     }
     263             : 
     264           0 :     if (!CXeromyces::AddValidator(g_VFS, "sound_group", "audio/sound_group.rng"))
     265           0 :         LOGERROR("CSoundManager: failed to load grammar file 'audio/sound_group.rng'");
     266             : 
     267           0 :     RegisterFileReloadFunc(ReloadChangedFileCB, this);
     268             : 
     269           0 :     RunHardwareDetection();
     270           0 : }
     271             : 
     272           0 : CSoundManager::~CSoundManager()
     273             : {
     274           0 :     UnregisterFileReloadFunc(ReloadChangedFileCB, this);
     275             : 
     276           0 :     if (m_Worker)
     277             :     {
     278           0 :         AL_CHECK;
     279           0 :         m_Worker->Shutdown();
     280           0 :         AL_CHECK;
     281           0 :         m_Worker->CleanupItems();
     282           0 :         AL_CHECK;
     283             : 
     284           0 :         delete m_Worker;
     285             :     }
     286           0 :     AL_CHECK;
     287             : 
     288           0 :     for (const std::pair<const std::wstring, CSoundGroup*>& p : m_SoundGroups)
     289           0 :         delete p.second;
     290           0 :     m_SoundGroups.clear();
     291             : 
     292           0 :     if (m_PlayListItems)
     293           0 :         delete m_PlayListItems;
     294             : 
     295           0 :     if (m_ALSourceBuffer != NULL)
     296           0 :         delete[] m_ALSourceBuffer;
     297             : 
     298           0 :     if (m_Context)
     299           0 :         alcDestroyContext(m_Context);
     300             : 
     301           0 :     if (m_Device)
     302           0 :         alcCloseDevice(m_Device);
     303           0 : }
     304           0 : 
     305             : void CSoundManager::StartWorker()
     306             : {
     307             :     if (m_Enabled)
     308             :         m_Worker = new CSoundManagerWorker();
     309             : }
     310             : 
     311             : Status CSoundManager::AlcInit()
     312             : {
     313             :     Status ret = INFO::OK;
     314             : 
     315             :     if(!m_Device)
     316             :         m_Device = alcOpenDevice(nullptr);
     317             : 
     318             :     if (m_Device)
     319             :     {
     320             :         ALCint attribs[] = {ALC_STEREO_SOURCES, 16, 0};
     321             :         m_Context = alcCreateContext(m_Device, &attribs[0]);
     322             : 
     323             :         if (m_Context)
     324             :         {
     325             :             alcMakeContextCurrent(m_Context);
     326             :             m_ALSourceBuffer = new ALSourceHolder[SOURCE_NUM];
     327             :             ALuint* sourceList = new ALuint[SOURCE_NUM];
     328             : 
     329             :             alGenSources(SOURCE_NUM, sourceList);
     330             :             ALCenum err = alcGetError(m_Device);
     331             : 
     332             :             if (err == ALC_NO_ERROR)
     333             :             {
     334             :                 for (int x = 0; x < SOURCE_NUM; x++)
     335           0 :                 {
     336           0 :                     m_ALSourceBuffer[x].ALSource = sourceList[x];
     337             :                     m_ALSourceBuffer[x].SourceItem = NULL;
     338           0 :                 }
     339             :                 m_Enabled = true;
     340           0 :             }
     341             :             else
     342           0 :             {
     343           0 :                 LOGERROR("error in gensource = %d", err);
     344           0 :             }
     345           0 :             delete[] sourceList;
     346           0 :         }
     347             :     }
     348           0 : 
     349             :     // check if init succeeded.
     350           0 :     // some OpenAL implementations don't indicate failure here correctly;
     351             :     // we need to check if the device and context pointers are actually valid.
     352           0 :     ALCenum err = alcGetError(m_Device);
     353           0 :     const char* dev_name = (const char*)alcGetString(m_Device, ALC_DEVICE_SPECIFIER);
     354           0 : 
     355             :     if (err == ALC_NO_ERROR && m_Device && m_Context)
     356           0 :         debug_printf("Sound: AlcInit success, using %s\n", dev_name);
     357           0 :     else
     358             :     {
     359           0 :         LOGERROR("Sound: AlcInit failed, m_Device=%p m_Context=%p dev_name=%s err=%x\n", (void *)m_Device, (void *)m_Context, dev_name, err);
     360           0 : 
     361             : // FIXME Hack to get around exclusive access to the sound device
     362           0 : #if OS_UNIX
     363           0 :         ret = INFO::OK;
     364             : #else
     365           0 :         ret = ERR::FAIL;
     366           0 : #endif // !OS_UNIX
     367           0 :     }
     368             : 
     369           0 :     return ret;
     370             : }
     371           0 : 
     372           0 : bool CSoundManager::InDistress()
     373           0 : {
     374             :     std::lock_guard<std::mutex> lock(m_DistressMutex);
     375           0 : 
     376             :     if (m_DistressTime == 0)
     377           0 :         return false;
     378             :     else if ((timer_Time() - m_DistressTime) > 10)
     379           0 :     {
     380           0 :         m_DistressTime = 0;
     381             : // Coming out of distress mode
     382           0 :         m_DistressErrCount = 0;
     383             :         return false;
     384           0 :     }
     385           0 : 
     386             :     return true;
     387           0 : }
     388             : 
     389           0 : void CSoundManager::SetDistressThroughShortage()
     390           0 : {
     391           0 :     std::lock_guard<std::mutex> lock(m_DistressMutex);
     392             : 
     393           0 : // Going into distress for normal reasons
     394           0 : 
     395             :     m_DistressTime = timer_Time();
     396           0 : }
     397             : 
     398           0 : void CSoundManager::SetDistressThroughError()
     399             : {
     400           0 :     std::lock_guard<std::mutex> lock(m_DistressMutex);
     401           0 : 
     402             : // Going into distress due to unknown error
     403           0 : 
     404             :     m_DistressTime = timer_Time();
     405             :     m_DistressErrCount++;
     406             : }
     407           0 : 
     408             : 
     409           0 : 
     410             : ALuint CSoundManager::GetALSource(ISoundItem* anItem)
     411             : {
     412             :     for (int x = 0; x < SOURCE_NUM; x++)
     413             :     {
     414             :         if (!m_ALSourceBuffer[x].SourceItem)
     415             :         {
     416           0 :             m_ALSourceBuffer[x].SourceItem = anItem;
     417           0 :             return m_ALSourceBuffer[x].ALSource;
     418             :         }
     419           0 :     }
     420           0 :     SetDistressThroughShortage();
     421             :     return 0;
     422             : }
     423           0 : 
     424             : void CSoundManager::ReleaseALSource(ALuint theSource)
     425             : {
     426             :     for (int x = 0; x < SOURCE_NUM; x++)
     427           0 :     {
     428             :         if (m_ALSourceBuffer[x].ALSource == theSource)
     429             :         {
     430             :             m_ALSourceBuffer[x].SourceItem = NULL;
     431             :             return;
     432             :         }
     433           0 :     }
     434             : }
     435             : 
     436           0 : long CSoundManager::GetBufferCount()
     437             : {
     438           0 :     return m_BufferCount;
     439             : }
     440           0 : long CSoundManager::GetBufferSize()
     441             : {
     442           0 :     return m_BufferSize;
     443             : }
     444           0 : 
     445             : void CSoundManager::AddPlayListItem(const VfsPath& itemPath)
     446           0 : {
     447           0 :     if (m_Enabled)
     448             :         m_PlayListItems->push_back(itemPath);
     449             : }
     450             : 
     451             : void CSoundManager::ClearPlayListItems()
     452             : {
     453           0 :     if (m_Enabled)
     454             :     {
     455           0 :         if (m_PlayingPlaylist)
     456             :             SetMusicItem(NULL);
     457             : 
     458             :         m_PlayingPlaylist = false;
     459           0 :         m_LoopingPlaylist = false;
     460           0 :         m_RunningPlaylist = false;
     461             : 
     462           0 :         m_PlayListItems->clear();
     463             :     }
     464           0 : }
     465             : 
     466             : void CSoundManager::StartPlayList(bool doLoop)
     467             : {
     468           0 :     if (m_Enabled && m_MusicEnabled)
     469           0 :     {
     470           0 :         if (m_PlayListItems->size() > 0)
     471             :         {
     472             :             m_PlayingPlaylist = true;
     473             :             m_LoopingPlaylist = doLoop;
     474           0 :             m_RunningPlaylist = false;
     475             : 
     476           0 :             ISoundItem* aSnd = LoadItem((m_PlayListItems->at(0)));
     477             :             if (aSnd)
     478           0 :                 SetMusicItem(aSnd);
     479             :             else
     480           0 :                 SetMusicItem(NULL);
     481           0 :         }
     482             :     }
     483             : }
     484           0 : 
     485           0 : void CSoundManager::SetMasterGain(float gain)
     486             : {
     487             :     if (m_Enabled)
     488           0 :     {
     489             :         m_Gain = gain;
     490           0 :         alListenerf(AL_GAIN, m_Gain);
     491             :         AL_CHECK;
     492           0 :     }
     493             : }
     494           0 : 
     495           0 : void CSoundManager::SetMusicGain(float gain)
     496             : {
     497             :     m_MusicGain = gain;
     498             : 
     499             :     if (m_CurrentTune)
     500           0 :         m_CurrentTune->SetGain(m_MusicGain);
     501             : }
     502           0 : void CSoundManager::SetAmbientGain(float gain)
     503             : {
     504           0 :     m_AmbientGain = gain;
     505             : }
     506           0 : void CSoundManager::SetActionGain(float gain)
     507             : {
     508             :     m_ActionGain = gain;
     509           0 : }
     510             : void CSoundManager::SetUIGain(float gain)
     511           0 : {
     512           0 :     m_UIGain = gain;
     513           0 : }
     514             : 
     515           0 : 
     516             : ISoundItem* CSoundManager::LoadItem(const VfsPath& itemPath)
     517           0 : {
     518             :     AL_CHECK;
     519           0 : 
     520           0 :     if (m_Enabled)
     521             :     {
     522           0 :         CSoundData* itemData = CSoundData::SoundDataFromFile(itemPath);
     523           0 : 
     524           0 :         AL_CHECK;
     525             :         if (itemData)
     526           0 :             return CSoundManager::ItemForData(itemData);
     527             :     }
     528           0 : 
     529             :     return NULL;
     530           0 : }
     531             : 
     532           0 : ISoundItem* CSoundManager::ItemForData(CSoundData* itemData)
     533             : {
     534           0 :     AL_CHECK;
     535             :     ISoundItem* answer = NULL;
     536           0 : 
     537           0 :     AL_CHECK;
     538           0 : 
     539             :     if (m_Enabled && (itemData != NULL))
     540           0 :     {
     541           0 :         if (itemData->IsOneShot())
     542           0 :         {
     543             :             if (itemData->GetBufferCount() == 1)
     544           0 :                 answer = new CSoundItem(itemData);
     545             :             else
     546             :                 answer = new CBufferItem(itemData);
     547           0 :         }
     548             :         else
     549           0 :         {
     550             :             answer = new CStreamItem(itemData);
     551           0 :         }
     552             : 
     553           0 :         if (answer && m_Worker)
     554           0 :             m_Worker->addItem(answer);
     555           0 :     }
     556             : 
     557           0 :     return answer;
     558             : }
     559           0 : 
     560             : void CSoundManager::IdleTask()
     561           0 : {
     562             :     if (m_Enabled)
     563           0 :     {
     564           0 :         if (m_CurrentTune)
     565           0 :         {
     566           0 :             m_CurrentTune->EnsurePlay();
     567             :             if (m_PlayingPlaylist && m_RunningPlaylist)
     568           0 :             {
     569           0 :                 if (m_CurrentTune->Finished())
     570           0 :                 {
     571             :                     if (m_PlaylistGap == 0)
     572           0 :                     {
     573           0 :                         m_PlaylistGap = timer_Time() + 15;
     574           0 :                     }
     575             :                     else if (m_PlaylistGap < timer_Time())
     576           0 :                     {
     577           0 :                         m_PlaylistGap = 0;
     578             :                         PlayList::iterator it = find(m_PlayListItems->begin(), m_PlayListItems->end(), m_CurrentTune->GetName());
     579             :                         if (it != m_PlayListItems->end())
     580           0 :                         {
     581             :                             ++it;
     582           0 : 
     583             :                             Path nextPath;
     584           0 :                             if (it == m_PlayListItems->end())
     585             :                                 nextPath = m_PlayListItems->at(0);
     586           0 :                             else
     587             :                                 nextPath = *it;
     588           0 : 
     589           0 :                             ISoundItem* aSnd = LoadItem(nextPath);
     590           0 :                             if (aSnd)
     591             :                                 SetMusicItem(aSnd);
     592             :                         }
     593             :                     }
     594             :                 }
     595             :             }
     596           0 :         }
     597             : 
     598           0 :         if (m_CurrentEnvirons)
     599           0 :             m_CurrentEnvirons->EnsurePlay();
     600             : 
     601           0 :         if (m_Worker)
     602             :             m_Worker->CleanupItems();
     603           0 :     }
     604             : }
     605           0 : 
     606             : ISoundItem* CSoundManager::ItemForEntity(entity_id_t UNUSED(source), CSoundData* sndData)
     607           0 : {
     608           0 :     ISoundItem* currentItem = NULL;
     609             : 
     610           0 :     if (m_Enabled)
     611             :         currentItem = ItemForData(sndData);
     612             : 
     613             :     return currentItem;
     614           0 : }
     615             : 
     616             : 
     617           0 : void CSoundManager::InitListener()
     618           0 : {
     619             :     ALfloat listenerPos[] = {0.0, 0.0, 0.0};
     620             :     ALfloat listenerVel[] = {0.0, 0.0, 0.0};
     621           0 :     ALfloat listenerOri[] = {0.0, 0.0, -1.0, 0.0, 1.0, 0.0};
     622             : 
     623             :     alListenerfv(AL_POSITION, listenerPos);
     624           0 :     alListenerfv(AL_VELOCITY, listenerVel);
     625             :     alListenerfv(AL_ORIENTATION, listenerOri);
     626           0 : 
     627             :     alDistanceModel(AL_LINEAR_DISTANCE);
     628           0 : }
     629             : 
     630           0 : void CSoundManager::PlayGroupItem(ISoundItem* anItem, ALfloat groupGain)
     631           0 : {
     632             :     if (anItem)
     633           0 :     {
     634             :         if (m_Enabled && (m_ActionGain > 0))
     635           0 :         {
     636             :             anItem->SetGain(m_ActionGain * groupGain);
     637           0 :             anItem->PlayAndDelete();
     638             :             AL_CHECK;
     639           0 :         }
     640             :     }
     641           0 : }
     642           0 : 
     643           0 : void CSoundManager::SetMusicEnabled(bool isEnabled)
     644             : {
     645           0 :     if (m_CurrentTune && !isEnabled)
     646             :     {
     647           0 :         m_CurrentTune->FadeAndDelete(1.00);
     648           0 :         m_CurrentTune = NULL;
     649           0 :     }
     650             :     m_MusicEnabled = isEnabled;
     651           0 : }
     652             : 
     653           0 : void CSoundManager::PlayAsGroup(const VfsPath& groupPath, const CVector3D& sourcePos, entity_id_t source, bool ownedSound)
     654           0 : {
     655           0 :     // Make sure the sound group is loaded
     656             :     CSoundGroup* group;
     657             :     if (m_SoundGroups.find(groupPath.string()) == m_SoundGroups.end())
     658             :     {
     659             :         group = new CSoundGroup();
     660             :         if (!group->LoadSoundGroup(L"audio/" + groupPath.string()))
     661             :         {
     662           0 :             LOGERROR("Failed to load sound group '%s'", groupPath.string8());
     663           0 :             delete group;
     664             :             group = NULL;
     665           0 :         }
     666           0 :         // Cache the sound group (or the null, if it failed)
     667             :         m_SoundGroups[groupPath.string()] = group;
     668           0 :     }
     669             :     else
     670           0 :     {
     671             :         group = m_SoundGroups[groupPath.string()];
     672           0 :     }
     673             : 
     674           0 :     // Failed to load group -> do nothing
     675           0 :     if (group && (ownedSound || !group->TestFlag(eOwnerOnly)))
     676             :         group->PlayNext(sourcePos, source);
     677           0 : }
     678             : 
     679             : void CSoundManager::PlayAsMusic(const VfsPath& itemPath, bool looping)
     680             : {
     681           0 :     if (m_Enabled)
     682             :     {
     683           0 :         UNUSED2(looping);
     684           0 : 
     685           0 :         ISoundItem* aSnd = LoadItem(itemPath);
     686             :         if (aSnd != NULL)
     687           0 :             SetMusicItem(aSnd);
     688           0 :     }
     689           0 : }
     690             : 
     691           0 : void CSoundManager::PlayAsAmbient(const VfsPath& itemPath, bool looping)
     692           0 : {
     693             :     if (m_Enabled)
     694           0 :     {
     695             :         UNUSED2(looping);
     696           0 :         ISoundItem* aSnd = LoadItem(itemPath);
     697             :         if (aSnd != NULL)
     698           0 :             SetAmbientItem(aSnd);
     699             :     }
     700           0 : }
     701           0 : 
     702           0 : 
     703             : void CSoundManager::PlayAsUI(const VfsPath& itemPath, bool looping)
     704             : {
     705           0 :     if (m_Enabled)
     706             :     {
     707           0 :         IdleTask();
     708             : 
     709           0 :         if (ISoundItem* anItem = LoadItem(itemPath))
     710             :         {
     711           0 :             if (m_UIGain > 0)
     712           0 :             {
     713             :                 anItem->SetGain(m_UIGain);
     714           0 :                 anItem->SetLooping(looping);
     715           0 :                 anItem->PlayAndDelete();
     716             :             }
     717           0 :         }
     718             :         AL_CHECK;
     719             :     }
     720           0 : }
     721           0 : 
     722             : void CSoundManager::Pause(bool pauseIt)
     723           0 : {
     724           0 :     PauseMusic(pauseIt);
     725             :     PauseAmbient(pauseIt);
     726           0 :     PauseAction(pauseIt);
     727           0 : }
     728           0 : 
     729             : void CSoundManager::PauseMusic(bool pauseIt)
     730             : {
     731           0 :     if (m_CurrentTune && pauseIt && !m_MusicPaused)
     732             :     {
     733             :         m_CurrentTune->FadeAndPause(1.0);
     734             :     }
     735           0 :     else if (m_CurrentTune && m_MusicPaused && !pauseIt && m_MusicEnabled)
     736             :     {
     737             :         m_CurrentTune->SetGain(0);
     738             :         m_CurrentTune->Resume();
     739           0 :         m_CurrentTune->FadeToIn(m_MusicGain, 1.0);
     740           0 :     }
     741           0 :     m_MusicPaused = pauseIt;
     742             : }
     743           0 : 
     744             : void CSoundManager::PauseAmbient(bool pauseIt)
     745           0 : {
     746             :     if (m_CurrentEnvirons && pauseIt)
     747           0 :         m_CurrentEnvirons->Pause();
     748             :     else if (m_CurrentEnvirons)
     749           0 :         m_CurrentEnvirons->Resume();
     750           0 : 
     751           0 :     m_AmbientPaused = pauseIt;
     752             : }
     753           0 : 
     754             : void CSoundManager::PauseAction(bool pauseIt)
     755           0 : {
     756             :     m_ActionPaused = pauseIt;
     757           0 : }
     758             : 
     759           0 : void CSoundManager::SetMusicItem(ISoundItem* anItem)
     760           0 : {
     761           0 :     if (m_Enabled)
     762           0 :     {
     763             :         AL_CHECK;
     764           0 :         if (m_CurrentTune)
     765             :         {
     766             :             m_CurrentTune->FadeAndDelete(2.00);
     767           0 :             m_CurrentTune = NULL;
     768             :         }
     769           0 : 
     770             :         IdleTask();
     771           0 : 
     772             :         if (anItem)
     773           0 :         {
     774             :             if (m_MusicEnabled)
     775           0 :             {
     776             :                 m_CurrentTune = anItem;
     777           0 :                 m_CurrentTune->SetGain(0);
     778           0 : 
     779           0 :                 if (m_PlayingPlaylist)
     780             :                 {
     781             :                     m_RunningPlaylist = true;
     782           0 :                     m_CurrentTune->Play();
     783             :                 }
     784           0 :                 else
     785             :                     m_CurrentTune->PlayLoop();
     786           0 : 
     787             :                 m_MusicPaused = false;
     788           0 :                 m_CurrentTune->FadeToIn(m_MusicGain, 1.00);
     789           0 :             }
     790           0 :             else
     791           0 :             {
     792             :                 anItem->StopAndDelete();
     793           0 :             }
     794             :         }
     795           0 :         AL_CHECK;
     796             :     }
     797           0 : }
     798             : 
     799           0 : void CSoundManager::SetAmbientItem(ISoundItem* anItem)
     800             : {
     801           0 :     if (m_Enabled)
     802           0 :     {
     803           0 :         if (m_CurrentEnvirons)
     804             :         {
     805           0 :             m_CurrentEnvirons->FadeAndDelete(3.00);
     806           0 :             m_CurrentEnvirons = NULL;
     807             :         }
     808           0 :         IdleTask();
     809             : 
     810           0 :         if (anItem)
     811           0 :         {
     812           0 :             if (m_AmbientGain > 0)
     813           0 :             {
     814             :                 m_CurrentEnvirons = anItem;
     815           0 :                 m_CurrentEnvirons->SetGain(0);
     816           0 :                 m_CurrentEnvirons->PlayLoop();
     817             :                 m_CurrentEnvirons->FadeToIn(m_AmbientGain, 2.00);
     818           0 :             }
     819             :         }
     820           0 :         AL_CHECK;
     821           0 :     }
     822             : }
     823           0 : 
     824             : void CSoundManager::RunHardwareDetection()
     825           0 : {
     826             :     // OpenAL alGetString might not return anything interesting on certain platforms
     827           0 :     // (see https://stackoverflow.com/questions/28960638 for an example).
     828           0 :     // However our previous code supported only Windows, and alGetString does work on
     829             :     // Windows, so this is an improvement.
     830           0 : 
     831           0 :     // Sound cards
     832             : 
     833             :     const ALCchar* devices = nullptr;
     834           0 :     if (alcIsExtensionPresent(nullptr, "ALC_enumeration_EXT") == AL_TRUE)
     835             :     {
     836           0 :         if (alcIsExtensionPresent(nullptr, "ALC_enumerate_all_EXT") == AL_TRUE)
     837             :             devices = alcGetString(nullptr, ALC_ALL_DEVICES_SPECIFIER);
     838           0 :         else
     839             :             devices = alcGetString(nullptr, ALC_DEVICE_SPECIFIER);
     840           0 :     }
     841           0 :     WARN_IF_FALSE(devices);
     842             : 
     843           0 :     m_SoundCardNames.clear();
     844             :     do
     845           0 :     {
     846           0 :         m_SoundCardNames += devices;
     847             :         devices += strlen(devices) + 1;
     848             :         m_SoundCardNames += "; ";
     849           0 :     } while (*devices);
     850             : 
     851           0 :     // Driver version
     852           0 :     const ALCchar* al_version = alGetString(AL_VERSION);
     853             :     if (al_version)
     854             :         m_OpenALVersion = al_version;
     855             : }
     856           0 : 
     857             : CStr8 CSoundManager::GetOpenALVersion() const
     858             : {
     859           0 :     return m_OpenALVersion;
     860             : }
     861           0 : 
     862             : CStr8 CSoundManager::GetSoundCardNames() const
     863           0 : {
     864             :     return m_SoundCardNames;
     865           0 : }
     866             : 
     867           0 : #else // CONFIG2_AUDIO
     868             : 
     869           0 : void ISoundManager::CreateSoundManager(){}
     870           0 : void ISoundManager::SetEnabled(bool UNUSED(doEnable)){}
     871             : void ISoundManager::CloseGame(){}
     872           0 : void ISoundManager::RunHardwareDetection() {}
     873             : CStr8 ISoundManager::GetSoundCardNames() const { return CStr8(); };
     874           0 : CStr8 ISoundManager::GetOpenALVersion() const { return CStr8(); };
     875             : #endif // CONFIG2_AUDIO
     876           0 : 

Generated by: LCOV version 1.13