[GEN][ZH] Unify code of GameAudio and MilesAudioManager (#782)

Author: Mauller

Generals/Code/GameEngine/Include/Common/AudioEventInfo.h

@@ -82,6 +82,8 @@ enum AudioControl CPP_11(: Int)
 	AC_INTERRUPT						= 0x0010,
 };
 
+class DynamicAudioEventInfo;
+
 struct AudioEventInfo : public MemoryPoolObject
 {
 	MEMORY_POOL_GLUE_WITH_USERLOOKUP_CREATE( AudioEventInfo, "AudioEventInfo" )
@@ -118,6 +120,16 @@ struct AudioEventInfo : public MemoryPoolObject
 
 	AudioType m_soundType;	// This should be either Music, Streaming or SoundEffect
 
+  
+  // DynamicAudioEventInfo interfacing functions
+  virtual Bool isLevelSpecific() const { return false; } ///< If true, this sound is only defined on the current level and can be deleted when that level ends
+  virtual DynamicAudioEventInfo * getDynamicAudioEventInfo() { return NULL; }  ///< If this object is REALLY a DynamicAudioEventInfo, return a pointer to the derived class
+  virtual const DynamicAudioEventInfo * getDynamicAudioEventInfo() const { return NULL; } ///< If this object is REALLY a DynamicAudioEventInfo, return a pointer to the derived class
+
+  /// Is this a permenant sound? That is, if I start this sound up, will it ever end
+  /// "on its own" or only if I explicitly kill it?
+  Bool isPermanentSound() const { return BitIsSet( m_control, AC_LOOP ) && (m_loopCount == 0 );  }
+  
 	static const FieldParse m_audioEventInfo[];		///< the parse table for INI definition
 	const FieldParse *getFieldParse( void ) const { return m_audioEventInfo; }
 };

Generals/Code/GameEngine/Include/Common/GameAudio.h

@@ -236,6 +236,8 @@ class AudioManager : public SubsystemInterface
 		// on zoom.
 		virtual void set3DVolumeAdjustment( Real volumeAdjustment );
 
+    virtual Bool has3DSensitiveStreamsPlaying( void ) const = 0;
+
  		virtual void *getHandleForBink( void ) = 0;
  		virtual void releaseHandleForBink( void ) = 0;
 
@@ -253,6 +255,7 @@ class AudioManager : public SubsystemInterface
 		virtual void processRequestList( void );
 
 		virtual AudioEventInfo *newAudioEventInfo( AsciiString newEventName );
+    virtual void addAudioEventInfo( AudioEventInfo * newEventInfo );
 		virtual AudioEventInfo *findAudioEventInfo( AsciiString eventName ) const;
 
 		const AudioSettings *getAudioSettings( void ) const;
@@ -294,6 +297,7 @@ class AudioManager : public SubsystemInterface
 
 		// For Worldbuilder, to build lists from which to select
 		virtual void findAllAudioEventsOfType( AudioType audioType, std::vector<AudioEventInfo*>& allEvents );
+    virtual const AudioEventInfoHash & getAllAudioEvents() const { return m_allAudioEventInfo; }
 
 		Real getZoomVolume() const { return m_zoomVolume; }
 	protected:
@@ -313,6 +317,11 @@ class AudioManager : public SubsystemInterface
 		// For tracking purposes
 		virtual AudioHandle allocateNewHandle( void );	
 
+    // Remove all AudioEventInfo's with the m_isLevelSpecific flag
+    virtual void removeLevelSpecificAudioEventInfos( void );
+    
+    void removeAllAudioRequests( void );
+    
 	protected:
 		AudioSettings *m_audioSettings;
 		MiscAudio *m_miscAudio;

Generals/Code/GameEngine/Source/Common/Audio/GameAudio.cpp

@@ -390,6 +390,7 @@ void AudioManager::update()
 			m_zoomVolume = 1.0f - scalar * maxBoostScalar;
 		}
 	}
+
 	set3DVolumeAdjustment( m_zoomVolume );
 
 }
@@ -780,8 +781,8 @@ void AudioManager::set3DVolumeAdjustment( Real volumeAdjustment )
 	if (m_sound3DVolume > 1.0f) 
 		m_sound3DVolume = 1.0f;
 
-
-	m_volumeHasChanged = TRUE;
+  if ( ! has3DSensitiveStreamsPlaying() )
+  	m_volumeHasChanged = TRUE;
 }
 
 //-------------------------------------------------------------------------------------------------
@@ -820,6 +821,18 @@ void AudioManager::appendAudioRequest( AudioRequest *m_request )
 	m_audioRequests.push_back(m_request);
 }
 
+//-------------------------------------------------------------------------------------------------
+// Remove all pending audio requests
+void AudioManager::removeAllAudioRequests( void )
+{
+  std::list<AudioRequest*>::iterator it;
+  for ( it = m_audioRequests.begin(); it != m_audioRequests.end(); it++ ) {
+    releaseAudioRequest( *it );
+  }
+
+  m_audioRequests.clear();
+}
+
 //-------------------------------------------------------------------------------------------------
 void AudioManager::processRequestList( void )
 {
@@ -839,6 +852,23 @@ AudioEventInfo *AudioManager::newAudioEventInfo( AsciiString audioName )
 	return m_allAudioEventInfo[audioName];
 }
 
+//-------------------------------------------------------------------------------------------------
+// Add an AudioEventInfo structure allocated elsewhere to the audio event list
+void AudioManager::addAudioEventInfo( AudioEventInfo * newEvent )
+{
+  // Warning: Don't try to copy the structure. It may be a derived class
+  AudioEventInfo *eventInfo = findAudioEventInfo( newEvent->m_audioName );
+  if (eventInfo) 
+  {
+    DEBUG_CRASH(("Requested add of '%s' multiple times. Is this intentional? - jkmcd\n", newEvent->m_audioName.str()));
+    *eventInfo = *newEvent;
+  }
+  else
+  {
+    m_allAudioEventInfo[newEvent->m_audioName] = newEvent;
+  }
+}
+
 //-------------------------------------------------------------------------------------------------
 AudioEventInfo *AudioManager::findAudioEventInfo( AsciiString eventName ) const
 {
@@ -851,6 +881,28 @@ AudioEventInfo *AudioManager::findAudioEventInfo( AsciiString eventName ) const
 	return (*it).second;
 }
 
+//-------------------------------------------------------------------------------------------------
+// Remove all AudioEventInfo's with the m_isLevelSpecific flag
+void AudioManager::removeLevelSpecificAudioEventInfos(void)
+{
+  AudioEventInfoHash::iterator it = m_allAudioEventInfo.begin();
+
+  while ( it != m_allAudioEventInfo.end() )
+  {
+    AudioEventInfoHash::iterator next = it; // Make sure erase doesn't cause problems
+    next++;
+
+    if ( it->second->isLevelSpecific() )
+    {
+      it->second->deleteInstance();
+      m_allAudioEventInfo.erase( it );
+    }
+
+    it = next;
+  }
+
+}
+
 //-------------------------------------------------------------------------------------------------
 const AudioSettings *AudioManager::getAudioSettings( void ) const
 {

Generals/Code/GameEngineDevice/Include/MilesAudioDevice/MilesAudioManager.h

@@ -73,6 +73,7 @@ struct PlayingAudio
 		m_audioEventRTS(NULL), 
 		m_requestStop(false), 
 		m_cleanupAudioEventRTS(true),
+		m_sample(NULL), 
 		m_framesFaded(0)
 	{ }
 };
@@ -223,6 +224,10 @@ class MilesAudioManager : public AudioManager
 
 		virtual void closeAnySamplesUsingFile( const void *fileToClose );
 
+    
+    virtual Bool has3DSensitiveStreamsPlaying( void ) const; 
+
+
 	protected:	
 		// 3-D functions
 		virtual void setDeviceListenerPosition( void );

Generals/Code/GameEngineDevice/Source/MilesAudioDevice/MilesAudioManager.cpp

@@ -474,6 +474,10 @@ void MilesAudioManager::reset()
 
 	AudioManager::reset();
 	stopAllAudioImmediately();
+  removeAllAudioRequests();
+  // This must come after stopAllAudioImmediately() and removeAllAudioRequests(), to ensure that
+  // sounds pointing to the temporary AudioEventInfo handles are deleted before their info is deleted
+  removeLevelSpecificAudioEventInfos();
 }
 
 //-------------------------------------------------------------------------------------------------
@@ -603,6 +607,7 @@ void MilesAudioManager::pauseAudio( AudioAffect which )
 	}
 }
 
+
 //-------------------------------------------------------------------------------------------------
 void MilesAudioManager::resumeAudio( AudioAffect which )
 {
@@ -1161,6 +1166,16 @@ void MilesAudioManager::stopAllAudioImmediately( void )
 		it = m_playingStreams.erase(it);
 	}
 
+  for (it = m_fadingAudio.begin(); it != m_fadingAudio.end(); ) {
+    playing = (*it);
+    if (!playing) {
+      continue;
+    }
+    
+    releasePlayingAudio(playing);
+    it = m_fadingAudio.erase(it);
+  }
+  
 	std::list<HAUDIO>::iterator hit;
 	for (hit = m_audioForcePlayed.begin(); hit != m_audioForcePlayed.end(); ++hit) {
 		if (*hit) {
@@ -2377,6 +2392,44 @@ void MilesAudioManager::processPlayingList( void )
 	}
 }
 
+//Patch for a rare bug (only on about 5% of in-studio machines suffer, and not all the time) .
+//The actual mechanics of this problem are still elusive as of the date of this comment. 8/21/03
+//but the cause is clear. Some cinematics do a radical change in the microphone position, which
+//calls for a radical 3DSoundVolume adjustment. If this happens while a stereo stream is *ENDING*,
+//low-level code gets caught in a tight loop. (Hangs) on some machines.
+//To prevent this condition, we just suppress the updating of 3DSoundVolume while one of these
+//is on the list. Since the music tracks play continuously, they never *END* during these cinematics.
+//so we filter them out as, *NOT SENSITIVE*... we do want to update 3DSoundVolume during music, 
+//which is almost all of the time.
+
+Bool MilesAudioManager::has3DSensitiveStreamsPlaying( void ) const
+{
+  if ( m_playingStreams.empty() )
+    return FALSE;
+
+	for ( std::list< PlayingAudio* >::const_iterator it = m_playingStreams.begin(); it != m_playingStreams.end(); ++it ) 
+  {
+		const PlayingAudio *playing = (*it);
+
+    if ( ! playing )
+      continue;
+
+    if ( playing->m_audioEventRTS->getAudioEventInfo()->m_soundType != AT_Music )
+    {
+      return TRUE;
+    }
+
+    if ( playing->m_audioEventRTS->getEventName().startsWith("Game_") == FALSE ) 
+    {
+      return TRUE;
+    }
+  }	
+  
+  return FALSE; 
+
+}
+
+
 //-------------------------------------------------------------------------------------------------
 void MilesAudioManager::processFadingList( void )
 {
@@ -2476,7 +2529,14 @@ Bool MilesAudioManager::checkForSample( AudioRequest *req )
 		return true;
 	}
 
-	if (req->m_pendingEvent->getAudioEventInfo()->m_type != AT_SoundEffect) {
+  if ( req->m_pendingEvent->getAudioEventInfo() == NULL )
+  {
+    // Fill in event info
+    getInfoForAudioEvent( req->m_pendingEvent );
+  }
+  
+	if (req->m_pendingEvent->getAudioEventInfo()->m_type != AT_SoundEffect) 
+  {
 		return true;
 	}
 

GeneralsMD/Code/GameEngineDevice/Include/MilesAudioDevice/MilesAudioManager.h

@@ -53,12 +53,12 @@ enum PlayingWhich CPP_11(: Int)
 
 struct PlayingAudio
 {
-//	union
-//	{
+	union
+	{
 		HSAMPLE m_sample;
 		H3DSAMPLE m_3DSample;
 		HSTREAM m_stream;
-//	};
+	};
 
 	PlayingAudioType m_type;
 	volatile PlayingStatus m_status;	// This member is adjusted by another running thread.
@@ -73,9 +73,7 @@ struct PlayingAudio
 		m_audioEventRTS(NULL), 
 		m_requestStop(false), 
 		m_cleanupAudioEventRTS(true),
-		m_sample(0), 
-		m_3DSample(0),
-		m_stream(0),
+		m_sample(NULL), 
 		m_framesFaded(0)
 	{ }
 };