Merge pull request #607 from tintinhamans/arctic/go/stack/04-audio-fixes

bugfix(audio): Cherry-pick upstream Miles audio fixes (b2)

Author: x64-dev

Core/GameEngine/Include/Common/AudioEventRTS.h

@@ -199,14 +199,27 @@ class AudioEventRTS
 	PortionToPlay m_portionToPlayNext;	///< Which portion (attack, sound, decay) should be played next?
 };
 
-class DynamicAudioEventRTS : public MemoryPoolObject
+class DynamicAudioEventRTS : public MemoryPoolObject, public RefCountClass, public AudioEventRTS
 {
 	MEMORY_POOL_GLUE_WITH_USERLOOKUP_CREATE(DynamicAudioEventRTS, "DynamicAudioEventRTS" )
 public:
 
-	DynamicAudioEventRTS() { }
-	DynamicAudioEventRTS(const AudioEventRTS& a) : m_event(a) { }
+	DynamicAudioEventRTS() {}
+	DynamicAudioEventRTS( const AsciiString& eventName ) : AudioEventRTS(eventName) {}
+	DynamicAudioEventRTS( const AsciiString& eventName, ObjectID ownerID ) : AudioEventRTS(eventName, ownerID) {}
+	DynamicAudioEventRTS( const AsciiString& eventName, DrawableID drawableID ) : AudioEventRTS(eventName, drawableID) {}
+	DynamicAudioEventRTS( const AsciiString& eventName, const Coord3D *positionOfAudio ) : AudioEventRTS(eventName, positionOfAudio) {}
 
-	AudioEventRTS	m_event;
+	DynamicAudioEventRTS(const AudioEventRTS& a) : AudioEventRTS(a) {}
+	DynamicAudioEventRTS& operator=( const AudioEventRTS& right )
+	{
+		*static_cast<AudioEventRTS*>(this) = right;
+		return *this;
+	}
+
+	void Delete_This() override
+	{
+		deleteInstance(this);
+	}
 };
 EMPTY_DTOR(DynamicAudioEventRTS)

Core/GameEngine/Include/Common/AudioRequest.h

@@ -30,8 +30,9 @@
 
 #include "Common/GameAudio.h"
 #include "Common/GameMemory.h"
+#include "Common/AudioHandleSpecialValues.h"
 
-class AudioEventRTS;
+class DynamicAudioEventRTS;
 
 enum RequestType CPP_11(: Int)
 {
@@ -45,14 +46,18 @@ struct AudioRequest : public MemoryPoolObject
 	MEMORY_POOL_GLUE_WITH_USERLOOKUP_CREATE( AudioRequest, "AudioRequest" )
 
 public:
-	AudioEventRTS* releasePendingEvent();
+
+	AudioRequest()
+		: m_request(AR_Play)
+		, m_pendingEvent(nullptr)
+		, m_handleToInteractOn(AHSV_Error)
+		, m_requiresCheckForSample(false)
+		, m_requestStop(false)
+	{}
 
 	RequestType m_request;
-	union
-	{
-		AudioEventRTS *m_pendingEvent;
-		AudioHandle m_handleToInteractOn;
-	};
-	Bool m_usePendingEvent;
+	RefCountPtr<DynamicAudioEventRTS> m_pendingEvent;
+	AudioHandle m_handleToInteractOn;
 	Bool m_requiresCheckForSample;
+	Bool m_requestStop; // Let the audio play and finish but stop looping if it is looping
 };

Core/GameEngine/Include/Common/GameAudio.h

@@ -244,8 +244,6 @@ class AudioManager : public SubsystemInterface
 		// on zoom.
 		virtual void set3DVolumeAdjustment( Real volumeAdjustment );
 
-    virtual Bool has3DSensitiveStreamsPlaying() const = 0;
-
  		virtual void *getHandleForBink() = 0;
  		virtual void releaseHandleForBink() = 0;
 
@@ -257,9 +255,9 @@ class AudioManager : public SubsystemInterface
 		virtual void setListenerPosition( const Coord3D *newListenerPos, const Coord3D *newListenerOrientation );
 		virtual const Coord3D *getListenerPosition() const;
 
-		virtual AudioRequest *allocateAudioRequest( Bool useAudioEvent );
+		virtual AudioRequest *allocateAudioRequest();
 		virtual void releaseAudioRequest( AudioRequest *requestToRelease );
-		virtual void appendAudioRequest( AudioRequest *m_request );
+		virtual void appendAudioRequest( AudioRequest *request );
 		virtual void processRequestList();
 
 		virtual AudioEventInfo *newAudioEventInfo( AsciiString newEventName );
@@ -269,9 +267,6 @@ class AudioManager : public SubsystemInterface
 		const AudioSettings *getAudioSettings() const;
 		const MiscAudio *getMiscAudio() const;
 
-		// This function should only be called by AudioManager, MusicManager and SoundManager
-		virtual void releaseAudioEventRTS( AudioEventRTS *&eventToRelease );
-
 		// For INI
 		AudioSettings *friend_getAudioSettings();
 		MiscAudio *friend_getMiscAudio();

Core/GameEngine/Include/Common/GameMusic.h

@@ -102,10 +102,10 @@ class MusicManager
 		MusicManager();
 		virtual ~MusicManager();
 
-		void playTrack( AudioEventRTS *eventToUse );
+		void playTrack( DynamicAudioEventRTS *eventToUse );
 		void stopTrack( AudioHandle eventToRemove );
 
-		virtual void addAudioEvent(AudioEventRTS *eventToAdd);	// pre-copied
+		virtual void addAudioEvent( DynamicAudioEventRTS *eventToAdd );	// pre-copied
 		virtual void removeAudioEvent( AudioHandle eventToRemove );
 
 		void setVolume( Real m_volume );

Core/GameEngine/Include/Common/GameSounds.h

@@ -45,8 +45,8 @@
 #include "Common/GameAudio.h"
 #include "Common/GameType.h"
 
-// Forward declarations
 class AudioEventRTS;
+class DynamicAudioEventRTS;
 
 class SoundManager : public SubsystemInterface
 {
@@ -67,7 +67,7 @@ class SoundManager : public SubsystemInterface
 		virtual void setCameraAudibleDistance( Real audibleDistance );
 		virtual Real getCameraAudibleDistance();
 
-		virtual void addAudioEvent(AudioEventRTS *&eventToAdd);	// pre-copied
+		virtual Bool addAudioEvent(DynamicAudioEventRTS *eventToAdd);	// pre-copied
 
 		// empty string means that this sound wasn't found or some error occurred. CHECK FOR EMPTY STRING.
 		virtual AsciiString getFilenameForPlayFromAudioEvent( const AudioEventRTS *eventToGetFrom );

Core/GameEngine/Include/GameClient/VideoPlayer.h

@@ -245,6 +245,8 @@ class VideoPlayerInterface : public SubsystemInterface
 		virtual const FieldParse *getFieldParse() const = 0;		///< Return the field parse info
 
 		virtual void notifyVideoPlayerOfNewProvider( Bool nowHasValid ) = 0;		///< Notify the video player that they can now ask for an audio handle, or they need to give theirs up.
+
+		virtual void setVolume( Real volume ) = 0;		///< Push a new speech volume to the video player's audio output
 };
 
 
@@ -299,6 +301,13 @@ class VideoPlayer : public VideoPlayerInterface
 
 };
 
+class NullVideoPlayer : public VideoPlayer
+{
+	public:
+
+		virtual void setVolume( Real ) override { }
+};
+
 extern VideoPlayerInterface *TheVideoPlayer;
 
 //----------------------------------------------------------------------------

Core/GameEngine/Source/Common/Audio/AudioRequest.cpp

@@ -30,20 +30,4 @@
 
 AudioRequest::~AudioRequest()
 {
-	if (m_usePendingEvent)
-	{
-		delete m_pendingEvent;
-	}
-}
-
-AudioEventRTS* AudioRequest::releasePendingEvent()
-{
-	if (m_usePendingEvent)
-	{
-		m_usePendingEvent = false;
-		AudioEventRTS* event = m_pendingEvent;
-		m_pendingEvent = nullptr;
-		return event;
-	}
-	return nullptr;
 }

Core/GameEngine/Source/Common/Audio/GameAudio.cpp

@@ -439,7 +439,8 @@ AudioHandle AudioManager::addAudioEvent(const AudioEventRTS *eventToAdd)
 		return AHSV_NotForLocal;
 	}
 
-	AudioEventRTS *audioEvent = MSGNEW("AudioEventRTS") AudioEventRTS(*eventToAdd);		// poolify
+	RefCountPtr<DynamicAudioEventRTS> audioEvent;
+	audioEvent.Assign_No_Add_Ref(newInstance(DynamicAudioEventRTS)(*eventToAdd));
 	audioEvent->setPlayingHandle( allocateNewHandle() );
 	audioEvent->generateFilename();	// which file are we actually going to play?
 	eventToAdd->setPlayingAudioIndex( audioEvent->getPlayingAudioIndex() );
@@ -456,7 +457,6 @@ AudioHandle AudioManager::addAudioEvent(const AudioEventRTS *eventToAdd)
 #if RETAIL_COMPATIBLE_CRC
 	if (notForLocal)
 	{
-		releaseAudioEventRTS(audioEvent);
 		return AHSV_NotForLocal;
 	}
 #endif
@@ -466,21 +466,22 @@ AudioHandle AudioManager::addAudioEvent(const AudioEventRTS *eventToAdd)
 #ifdef INTENSIVE_AUDIO_DEBUG
 		DEBUG_LOG((" - culled due to muting (%d).", audioEvent->getVolume()));
 #endif
-		releaseAudioEventRTS(audioEvent);
 		return AHSV_Muted;
 	}
 
 	if (soundType == AT_Music)
 	{
-		m_music->addAudioEvent(audioEvent);
+		m_music->addAudioEvent(audioEvent.Peek());
 	}
 	else
 	{
-		//Possible to nuke audioEvent inside.
-		m_sound->addAudioEvent(audioEvent);
+		if (!m_sound->addAudioEvent(audioEvent.Peek()))
+		{
+			audioEvent.Clear();
+		}
 	}
 
-	if( audioEvent )
+	if( audioEvent != nullptr )
 	{
 		return audioEvent->getPlayingHandle();
 	}
@@ -578,7 +579,7 @@ void AudioManager::removeAudioEvent(AudioHandle audioEvent)
 		return;
 	}
 
-	AudioRequest *req = allocateAudioRequest( false );
+	AudioRequest *req = allocateAudioRequest();
 	req->m_handleToInteractOn = audioEvent;
 	req->m_request = AR_Stop;
 	appendAudioRequest( req );
@@ -709,7 +710,12 @@ void AudioManager::setVolume( Real volume, AudioAffect whichToAffect )
 			m_scriptMusicVolume = volume;
 		}
 
-		m_musicVolume = m_scriptMusicVolume * m_systemMusicVolume;
+		const Real newVolume = m_scriptMusicVolume * m_systemMusicVolume;
+		if (m_musicVolume != newVolume)
+		{
+			m_musicVolume = newVolume;
+			m_volumeHasChanged = true;
+		}
 	}
 
 	if (whichToAffect & AudioAffect_Sound) {
@@ -719,7 +725,12 @@ void AudioManager::setVolume( Real volume, AudioAffect whichToAffect )
 			m_scriptSoundVolume = volume;
 		}
 
-		m_soundVolume = m_scriptSoundVolume * m_systemSoundVolume;
+		const Real newVolume = m_scriptSoundVolume * m_systemSoundVolume;
+		if (m_soundVolume != newVolume)
+		{
+			m_soundVolume = newVolume;
+			m_volumeHasChanged = true;
+		}
 	}
 
 	if (whichToAffect & AudioAffect_Sound3D) {
@@ -728,7 +739,13 @@ void AudioManager::setVolume( Real volume, AudioAffect whichToAffect )
 		} else {
 			m_scriptSound3DVolume = volume;
 		}
-		m_sound3DVolume = m_scriptSound3DVolume * m_systemSound3DVolume;
+
+		const Real newVolume = m_scriptSound3DVolume * m_systemSound3DVolume;
+		if (m_sound3DVolume != newVolume)
+		{
+			m_sound3DVolume = newVolume;
+			m_volumeHasChanged = true;
+		}
 	}
 
 	if (whichToAffect & AudioAffect_Speech) {
@@ -737,10 +754,14 @@ void AudioManager::setVolume( Real volume, AudioAffect whichToAffect )
 		} else {
 			m_scriptSpeechVolume = volume;
 		}
-		m_speechVolume = m_scriptSpeechVolume * m_systemSpeechVolume;
-	}
 
+		const Real newVolume = m_scriptSpeechVolume * m_systemSpeechVolume;
+		if (m_speechVolume != newVolume)
+		{
+			m_speechVolume = newVolume;
 	m_volumeHasChanged = true;
+		}
+	}
 }
 
 //-------------------------------------------------------------------------------------------------
@@ -761,17 +782,13 @@ Real AudioManager::getVolume( AudioAffect whichToGet )
 //-------------------------------------------------------------------------------------------------
 void AudioManager::set3DVolumeAdjustment( Real volumeAdjustment )
 {
-	m_sound3DVolume = volumeAdjustment * m_scriptSound3DVolume * m_systemSound3DVolume;
-
-	// clamp
-	if (m_sound3DVolume < 0.0f)
-		m_sound3DVolume = 0.0f;
+	const Real newVolume = clamp(0.0f, volumeAdjustment * m_scriptSound3DVolume * m_systemSound3DVolume, 1.0f);
 
-	if (m_sound3DVolume > 1.0f)
-		m_sound3DVolume = 1.0f;
-
-  if ( ! has3DSensitiveStreamsPlaying() )
-  	m_volumeHasChanged = TRUE;
+	if (m_sound3DVolume != newVolume)
+	{
+		m_sound3DVolume = newVolume;
+		m_volumeHasChanged = true;
+	}
 }
 
 //-------------------------------------------------------------------------------------------------
@@ -788,10 +805,9 @@ const Coord3D *AudioManager::getListenerPosition() const
 }
 
 //-------------------------------------------------------------------------------------------------
-AudioRequest *AudioManager::allocateAudioRequest( Bool useAudioEvent )
+AudioRequest *AudioManager::allocateAudioRequest()
 {
 	AudioRequest *audioReq = newInstance(AudioRequest);
-	audioReq->m_usePendingEvent = useAudioEvent;
 	audioReq->m_requiresCheckForSample = false;
 	return audioReq;
 }
@@ -805,20 +821,19 @@ void AudioManager::releaseAudioRequest( AudioRequest *requestToRelease )
 }
 
 //-------------------------------------------------------------------------------------------------
-void AudioManager::appendAudioRequest( AudioRequest *m_request )
+void AudioManager::appendAudioRequest( AudioRequest *request )
 {
-	m_audioRequests.push_back(m_request);
+	m_audioRequests.push_back(request);
 }
 
 //-------------------------------------------------------------------------------------------------
 // Remove all pending audio requests
 void AudioManager::removeAllAudioRequests()
 {
   std::list<AudioRequest*>::iterator it;
-  for ( it = m_audioRequests.begin(); it != m_audioRequests.end(); it++ ) {
+	for ( it = m_audioRequests.begin(); it != m_audioRequests.end(); ++it ) {
     releaseAudioRequest( *it );
   }
-
   m_audioRequests.clear();
 }
 
@@ -1047,17 +1062,10 @@ Bool AudioManager::shouldPlayLocally(const AudioEventRTS *audioEvent)
 //-------------------------------------------------------------------------------------------------
 AudioHandle AudioManager::allocateNewHandle()
 {
-	// note, intenionally a post increment rather than a pre increment.
+	// note, intentionally a post increment rather than a pre increment.
 	return theAudioHandlePool++;
 }
 
-//-------------------------------------------------------------------------------------------------
-void AudioManager::releaseAudioEventRTS( AudioEventRTS *&eventToRelease )
-{
-	delete eventToRelease;
-	eventToRelease = nullptr;
-}
-
 //-------------------------------------------------------------------------------------------------
 void AudioManager::muteAudio( MuteAudioReason reason )
 {