Skip to content

MilesAudio: Protect access to playing audio lists with a mutex #111

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Open
seer-by-sentry wants to merge 1 commit into
base: main
Choose a base branch
from
+63 −13
Open

MilesAudio: Protect access to playing audio lists with a mutex #111

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
4 changes: 4 additions & 0 deletions Core/GameEngineDevice/Include/MilesAudioDevice/MilesAudioManager.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -321,6 +321,10 @@ class MilesAudioManager : public AudioManager
UnsignedInt m_num3DSamples;
UnsignedInt m_numStreams;

// Mutex to protect access to m_playingSounds, m_playing3DSounds, m_playingStreams from
// concurrent access by the Miles Audio callback thread and the main game thread
HANDLE m_playingAudioMutex;

#if defined(RTS_DEBUG)
typedef std::set<AsciiString> SetAsciiString;
typedef SetAsciiString::iterator SetAsciiStringIt;
Expand Down
72 changes: 59 additions & 13 deletions Core/GameEngineDevice/Source/MilesAudioDevice/MilesAudioManager.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -92,9 +92,11 @@ MilesAudioManager::MilesAudioManager() :
m_delayFilter(NULL),
m_binkHandle(NULL),
m_pref3DProvider(AsciiString::TheEmptyString),
m_prefSpeaker(AsciiString::TheEmptyString)
m_prefSpeaker(AsciiString::TheEmptyString),
m_playingAudioMutex(NULL)
{
m_audioCache = NEW AudioFileCache;
m_playingAudioMutex = CreateMutex(NULL, FALSE, NULL);
}

//-------------------------------------------------------------------------------------------------
Expand All @@ -105,6 +107,11 @@ MilesAudioManager::~MilesAudioManager()
closeDevice();
delete m_audioCache;

if (m_playingAudioMutex) {
CloseHandle(m_playingAudioMutex);
m_playingAudioMutex = NULL;
}

DEBUG_ASSERTCRASH(this == TheAudio, ("Umm..."));
TheAudio = NULL;
}
Expand Down Expand Up @@ -496,6 +503,7 @@ void MilesAudioManager::stopAudio( AudioAffect which )
// 3) Set the status to stopped, so that when we next process the playing list, we will
// correctly clean up the sample.

ScopedMutex lock(m_playingAudioMutex);

std::list<PlayingAudio *>::iterator it;

Expand Down Expand Up @@ -546,6 +554,8 @@ void MilesAudioManager::stopAudio( AudioAffect which )
//-------------------------------------------------------------------------------------------------
void MilesAudioManager::pauseAudio( AudioAffect which )
{
ScopedMutex lock(m_playingAudioMutex);

std::list<PlayingAudio *>::iterator it;

PlayingAudio *playing = NULL;
Expand Down Expand Up @@ -607,6 +617,8 @@ void MilesAudioManager::pauseAudio( AudioAffect which )
//-------------------------------------------------------------------------------------------------
void MilesAudioManager::resumeAudio( AudioAffect which )
{
ScopedMutex lock(m_playingAudioMutex);

std::list<PlayingAudio *>::iterator it;

PlayingAudio *playing = NULL;
Expand Down Expand Up @@ -901,6 +913,8 @@ void MilesAudioManager::stopAudioEvent( AudioHandle handle )
DEBUG_LOG(("MILES (%d) - Processing stop request: %d", TheGameLogic->getFrame(), handle));
#endif

ScopedMutex lock(m_playingAudioMutex);

std::list<PlayingAudio *>::iterator it;
if ( handle == AHSV_StopTheMusic || handle == AHSV_StopTheMusicFade ) {
// for music, just find the currently playing music stream and kill it.
Expand Down Expand Up @@ -985,6 +999,8 @@ void MilesAudioManager::killAudioEventImmediately( AudioHandle audioEvent )
}
}

ScopedMutex lock(m_playingAudioMutex);

//Look for matching 3D sound to kill
std::list<PlayingAudio *>::iterator it;
for( it = m_playing3DSounds.begin(); it != m_playing3DSounds.end(); it++ )
Expand Down Expand Up @@ -1129,6 +1145,8 @@ void MilesAudioManager::releasePlayingAudio( PlayingAudio *release )
//-------------------------------------------------------------------------------------------------
void MilesAudioManager::stopAllAudioImmediately( void )
{
ScopedMutex lock(m_playingAudioMutex);

std::list<PlayingAudio *>::iterator it;
PlayingAudio *playing;

Expand Down Expand Up @@ -1333,12 +1351,15 @@ void MilesAudioManager::initFilters3D( H3DSAMPLE sample, const AudioEventRTS *ev
void MilesAudioManager::nextMusicTrack( void )
{
AsciiString trackName;
std::list<PlayingAudio *>::iterator it;
PlayingAudio *playing;
for (it = m_playingStreams.begin(); it != m_playingStreams.end(); ++it) {
playing = *it;
if (playing && playing->m_audioEventRTS->getAudioEventInfo()->m_soundType == AT_Music) {
trackName = playing->m_audioEventRTS->getEventName();
{
ScopedMutex lock(m_playingAudioMutex);
std::list<PlayingAudio *>::iterator it;
PlayingAudio *playing;
for (it = m_playingStreams.begin(); it != m_playingStreams.end(); ++it) {
playing = *it;
if (playing && playing->m_audioEventRTS->getAudioEventInfo()->m_soundType == AT_Music) {
trackName = playing->m_audioEventRTS->getEventName();
}
}
}

Expand All @@ -1354,12 +1375,15 @@ void MilesAudioManager::nextMusicTrack( void )
void MilesAudioManager::prevMusicTrack( void )
{
AsciiString trackName;
std::list<PlayingAudio *>::iterator it;
PlayingAudio *playing;
for (it = m_playingStreams.begin(); it != m_playingStreams.end(); ++it) {
playing = *it;
if (playing && playing->m_audioEventRTS->getAudioEventInfo()->m_soundType == AT_Music) {
trackName = playing->m_audioEventRTS->getEventName();
{
ScopedMutex lock(m_playingAudioMutex);
std::list<PlayingAudio *>::iterator it;
PlayingAudio *playing;
for (it = m_playingStreams.begin(); it != m_playingStreams.end(); ++it) {
playing = *it;
if (playing && playing->m_audioEventRTS->getAudioEventInfo()->m_soundType == AT_Music) {
trackName = playing->m_audioEventRTS->getEventName();
}
}
}

Expand All @@ -1374,6 +1398,8 @@ void MilesAudioManager::prevMusicTrack( void )
//-------------------------------------------------------------------------------------------------
Bool MilesAudioManager::isMusicPlaying( void ) const
{
ScopedMutex lock(m_playingAudioMutex);

std::list<PlayingAudio *>::const_iterator it;
PlayingAudio *playing;
for (it = m_playingStreams.begin(); it != m_playingStreams.end(); ++it) {
Expand All @@ -1389,6 +1415,8 @@ Bool MilesAudioManager::isMusicPlaying( void ) const
//-------------------------------------------------------------------------------------------------
Bool MilesAudioManager::hasMusicTrackCompleted( const AsciiString& trackName, Int numberOfTimes ) const
{
ScopedMutex lock(m_playingAudioMutex);

std::list<PlayingAudio *>::const_iterator it;
PlayingAudio *playing;
for (it = m_playingStreams.begin(); it != m_playingStreams.end(); ++it) {
Expand Down Expand Up @@ -1424,6 +1452,8 @@ AsciiString MilesAudioManager::getMusicTrackName( void ) const
}
}

ScopedMutex lock(m_playingAudioMutex);

std::list<PlayingAudio *>::const_iterator it;
PlayingAudio *playing;
for (it = m_playingStreams.begin(); it != m_playingStreams.end(); ++it) {
Expand Down Expand Up @@ -1486,6 +1516,8 @@ void MilesAudioManager::closeDevice( void )
//-------------------------------------------------------------------------------------------------
Bool MilesAudioManager::isCurrentlyPlaying( AudioHandle handle )
{
ScopedMutex lock(m_playingAudioMutex);

std::list<PlayingAudio *>::iterator it;
PlayingAudio *playing;

Expand Down Expand Up @@ -1526,6 +1558,9 @@ Bool MilesAudioManager::isCurrentlyPlaying( AudioHandle handle )
//-------------------------------------------------------------------------------------------------
void MilesAudioManager::notifyOfAudioCompletion( UnsignedInt audioCompleted, UnsignedInt flags )
{
// Protect access to playing audio lists from concurrent modification by main thread
ScopedMutex lock(m_playingAudioMutex);

PlayingAudio *playing = findPlayingAudioFrom(audioCompleted, flags);
if (!playing) {
DEBUG_CRASH(("Audio has completed playing, but we can't seem to find it. - jkmcd"));
Expand Down Expand Up @@ -2098,6 +2133,8 @@ Bool MilesAudioManager::killLowestPrioritySoundImmediately( AudioEventRTS *event
//-------------------------------------------------------------------------------------------------
void MilesAudioManager::adjustVolumeOfPlayingAudio(AsciiString eventName, Real newVolume)
{
ScopedMutex lock(m_playingAudioMutex);

Real pan;
std::list<PlayingAudio *>::iterator it;

Expand Down Expand Up @@ -2139,6 +2176,8 @@ void MilesAudioManager::adjustVolumeOfPlayingAudio(AsciiString eventName, Real n
//-------------------------------------------------------------------------------------------------
void MilesAudioManager::removePlayingAudio( AsciiString eventName )
{
ScopedMutex lock(m_playingAudioMutex);

std::list<PlayingAudio *>::iterator it;

PlayingAudio *playing = NULL;
Expand Down Expand Up @@ -2188,6 +2227,8 @@ void MilesAudioManager::removePlayingAudio( AsciiString eventName )
//-------------------------------------------------------------------------------------------------
void MilesAudioManager::removeAllDisabledAudio()
{
ScopedMutex lock(m_playingAudioMutex);

std::list<PlayingAudio *>::iterator it;

PlayingAudio *playing = NULL;
Expand Down Expand Up @@ -2261,6 +2302,9 @@ void MilesAudioManager::processRequestList( void )
//-------------------------------------------------------------------------------------------------
void MilesAudioManager::processPlayingList( void )
{
// Protect access to playing audio lists from concurrent modification by callback thread
ScopedMutex lock(m_playingAudioMutex);

// There are two types of processing we have to do here.
// 1. Move the item to the stopped list if it has become stopped.
// 2. Update the position of the audio if it is positional
Expand Down Expand Up @@ -2400,6 +2444,8 @@ void MilesAudioManager::processPlayingList( void )

Bool MilesAudioManager::has3DSensitiveStreamsPlaying( void ) const
{
ScopedMutex lock(m_playingAudioMutex);

if ( m_playingStreams.empty() )
return FALSE;

Expand Down
Loading