335 lines
11 KiB
C++

/*
** Command & Conquer Generals Zero Hour(tm)
** Copyright 2025 Electronic Arts Inc.
**
** This program is free software: you can redistribute it and/or modify
** it under the terms of the GNU General Public License as published by
** the Free Software Foundation, either version 3 of the License, or
** (at your option) any later version.
**
** This program is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
** GNU General Public License for more details.
**
** You should have received a copy of the GNU General Public License
** along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
// FILE: MilesAudioManager.h //////////////////////////////////////////////////////////////////////////
// MilesAudioManager implementation
// Author: John K. McDonald, July 2002
#include "Common/AsciiString.h"
#include "Common/GameAudio.h"
#include "MSS/MSS.h"
class AudioEventRTS;
enum { MAXPROVIDERS = 64 };
enum PlayingAudioType
{
PAT_Sample,
PAT_3DSample,
PAT_Stream,
PAT_INVALID
};
enum PlayingStatus
{
PS_Playing,
PS_Stopped,
PS_Paused
};
enum PlayingWhich
{
PW_Attack,
PW_Sound,
PW_Decay,
PW_INVALID
};
struct PlayingAudio
{
// 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.
AudioEventRTS *m_audioEventRTS;
void *m_file; // The file that was opened to play this
Bool m_requestStop;
Bool m_cleanupAudioEventRTS;
Int m_framesFaded;
PlayingAudio() :
m_type(PAT_INVALID),
m_audioEventRTS(NULL),
m_requestStop(false),
m_cleanupAudioEventRTS(true),
m_sample(0),
m_3DSample(0),
m_stream(0),
m_framesFaded(0)
{ }
};
struct ProviderInfo
{
AsciiString name;
HPROVIDER id;
Bool m_isValid;
};
struct OpenAudioFile
{
AILSOUNDINFO m_soundInfo;
void *m_file;
UnsignedInt m_openCount;
UnsignedInt m_fileSize;
Bool m_compressed; // if the file was compressed, then we need to free it with a miles function.
// Note: OpenAudioFile does not own this m_eventInfo, and should not delete it.
const AudioEventInfo *m_eventInfo; // Not mutable, unlike the one on AudioEventRTS.
};
typedef std::hash_map< AsciiString, OpenAudioFile, rts::hash<AsciiString>, rts::equal_to<AsciiString> > OpenFilesHash;
typedef OpenFilesHash::iterator OpenFilesHashIt;
class AudioFileCache
{
public:
AudioFileCache();
// Protected by mutex
virtual ~AudioFileCache();
void *openFile( AudioEventRTS *eventToOpenFrom );
void closeFile( void *fileToClose );
void setMaxSize( UnsignedInt size );
// End Protected by mutex
// Note: These functions should be used for informational purposes only. For speed reasons,
// they are not protected by the mutex, so they are not guarenteed to be valid if called from
// outside the audio cache. They should be used as a rough estimate only.
UnsignedInt getCurrentlyUsedSize() const { return m_currentlyUsedSize; }
UnsignedInt getMaxSize() const { return m_maxSize; }
protected:
void releaseOpenAudioFile( OpenAudioFile *fileToRelease );
// This function will return TRUE if it was able to free enough space, and FALSE otherwise.
Bool freeEnoughSpaceForSample(const OpenAudioFile& sampleThatNeedsSpace);
OpenFilesHash m_openFiles;
UnsignedInt m_currentlyUsedSize;
UnsignedInt m_maxSize;
HANDLE m_mutex;
const char *m_mutexName;
};
class MilesAudioManager : public AudioManager
{
public:
#if defined(_DEBUG) || defined(_INTERNAL)
virtual void audioDebugDisplay(DebugDisplayInterface *dd, void *, FILE *fp = NULL );
virtual AudioHandle addAudioEvent( const AudioEventRTS *eventToAdd ); ///< Add an audio event (event must be declared in an INI file)
#endif
// from AudioDevice
virtual void init();
virtual void postProcessLoad();
virtual void reset();
virtual void update();
MilesAudioManager();
virtual ~MilesAudioManager();
virtual void nextMusicTrack( void );
virtual void prevMusicTrack( void );
virtual Bool isMusicPlaying( void ) const;
virtual Bool hasMusicTrackCompleted( const AsciiString& trackName, Int numberOfTimes ) const;
virtual AsciiString getMusicTrackName( void ) const;
virtual void openDevice( void );
virtual void closeDevice( void );
virtual void *getDevice( void ) { return m_digitalHandle; }
virtual void stopAudio( AudioAffect which );
virtual void pauseAudio( AudioAffect which );
virtual void resumeAudio( AudioAffect which );
virtual void pauseAmbient( Bool shouldPause );
virtual void killAudioEventImmediately( AudioHandle audioEvent );
///< Return whether the current audio is playing or not.
///< NOTE NOTE NOTE !!DO NOT USE THIS IN FOR GAMELOGIC PURPOSES!! NOTE NOTE NOTE
virtual Bool isCurrentlyPlaying( AudioHandle handle );
virtual void notifyOfAudioCompletion( UnsignedInt audioCompleted, UnsignedInt flags );
virtual PlayingAudio *findPlayingAudioFrom( UnsignedInt audioCompleted, UnsignedInt flags );
virtual UnsignedInt getProviderCount( void ) const;
virtual AsciiString getProviderName( UnsignedInt providerNum ) const;
virtual UnsignedInt getProviderIndex( AsciiString providerName ) const;
virtual void selectProvider( UnsignedInt providerNdx );
virtual void unselectProvider( void );
virtual UnsignedInt getSelectedProvider( void ) const;
virtual void setSpeakerType( UnsignedInt speakerType );
virtual UnsignedInt getSpeakerType( void );
virtual void *getHandleForBink( void );
virtual void releaseHandleForBink( void );
virtual void friend_forcePlayAudioEventRTS(const AudioEventRTS* eventToPlay);
virtual UnsignedInt getNum2DSamples( void ) const;
virtual UnsignedInt getNum3DSamples( void ) const;
virtual UnsignedInt getNumStreams( void ) const;
virtual Bool doesViolateLimit( AudioEventRTS *event ) const;
virtual Bool isPlayingLowerPriority( AudioEventRTS *event ) const;
virtual Bool isPlayingAlready( AudioEventRTS *event ) const;
virtual Bool isObjectPlayingVoice( UnsignedInt objID ) const;
Bool killLowestPrioritySoundImmediately( AudioEventRTS *event );
AudioEventRTS* findLowestPrioritySound( AudioEventRTS *event );
virtual void adjustVolumeOfPlayingAudio(AsciiString eventName, Real newVolume);
virtual void removePlayingAudio( AsciiString eventName );
virtual void removeAllDisabledAudio();
virtual void processRequestList( void );
virtual void processPlayingList( void );
virtual void processFadingList( void );
virtual void processStoppedList( void );
Bool shouldProcessRequestThisFrame( AudioRequest *req ) const;
void adjustRequest( AudioRequest *req );
Bool checkForSample( AudioRequest *req );
virtual void setHardwareAccelerated(Bool accel);
virtual void setSpeakerSurround(Bool surround);
virtual void setPreferredProvider(AsciiString provider) { m_pref3DProvider = provider; }
virtual void setPreferredSpeaker(AsciiString speakerType) { m_prefSpeaker = speakerType; }
virtual Real getFileLengthMS( AsciiString strToLoad ) const;
virtual void closeAnySamplesUsingFile( const void *fileToClose );
virtual Bool has3DSensitiveStreamsPlaying( void ) const;
protected:
// 3-D functions
virtual void setDeviceListenerPosition( void );
const Coord3D *getCurrentPositionFromEvent( AudioEventRTS *event );
Bool isOnScreen( const Coord3D *pos ) const;
Real getEffectiveVolume(AudioEventRTS *event) const;
// Looping functions
Bool startNextLoop( PlayingAudio *looping );
void playStream( AudioEventRTS *event, HSTREAM stream );
// Returns the file handle for attachment to the PlayingAudio structure
void *playSample( AudioEventRTS *event, HSAMPLE sample );
void *playSample3D( AudioEventRTS *event, H3DSAMPLE sample3D );
protected:
void buildProviderList( void );
void createListener( void );
void initDelayFilter( void );
Bool isValidProvider( void );
void initSamplePools( void );
void processRequest( AudioRequest *req );
void playAudioEvent( AudioEventRTS *event );
void stopAudioEvent( AudioHandle handle );
void pauseAudioEvent( AudioHandle handle );
void *loadFileForRead( AudioEventRTS *eventToLoadFrom );
void closeFile( void *fileRead );
PlayingAudio *allocatePlayingAudio( void );
void releaseMilesHandles( PlayingAudio *release );
void releasePlayingAudio( PlayingAudio *release );
void stopAllAudioImmediately( void );
void freeAllMilesHandles( void );
HSAMPLE getFirst2DSample( AudioEventRTS *event );
H3DSAMPLE getFirst3DSample( AudioEventRTS *event );
void adjustPlayingVolume( PlayingAudio *audio );
void stopAllSpeech( void );
protected:
void initFilters( HSAMPLE sample, const AudioEventRTS *eventInfo );
void initFilters3D( H3DSAMPLE sample, const AudioEventRTS *eventInfo, const Coord3D *pos );
protected:
ProviderInfo m_provider3D[MAXPROVIDERS];
UnsignedInt m_providerCount;
UnsignedInt m_selectedProvider;
UnsignedInt m_lastProvider;
UnsignedInt m_selectedSpeakerType;
AsciiString m_pref3DProvider;
AsciiString m_prefSpeaker;
HDIGDRIVER m_digitalHandle;
H3DPOBJECT m_listener;
HPROVIDER m_delayFilter;
// This is a list of all handles that are forcibly played. They always play as UI sounds.
std::list<HAUDIO> m_audioForcePlayed;
// Available handles for play. Note that there aren't handles open in advance for
// streaming things, only 2-D and 3-D sounds.
std::list<HSAMPLE> m_availableSamples;
std::list<H3DSAMPLE> m_available3DSamples;
// Currently Playing stuff. Useful if we have to preempt it.
// This should rarely if ever happen, as we mirror this in Sounds, and attempt to
// keep preemption from taking place here.
std::list<PlayingAudio *> m_playingSounds;
std::list<PlayingAudio *> m_playing3DSounds;
std::list<PlayingAudio *> m_playingStreams;
// Currently fading stuff. At this point, we just want to let it finish fading, when it is
// done it should be added to the completed list, then "freed" and the counts should be updated
// on the next update
std::list<PlayingAudio *> m_fadingAudio;
// Stuff that is done playing (either because it has finished or because it was killed)
// This stuff should be cleaned up during the next update cycle. This includes updating counts
// in the sound engine
std::list<PlayingAudio *> m_stoppedAudio;
AudioFileCache *m_audioCache;
PlayingAudio *m_binkHandle;
UnsignedInt m_num2DSamples;
UnsignedInt m_num3DSamples;
UnsignedInt m_numStreams;
#if defined(_DEBUG) || defined(_INTERNAL)
typedef std::set<AsciiString> SetAsciiString;
typedef SetAsciiString::iterator SetAsciiStringIt;
SetAsciiString m_allEventsLoaded;
void dumpAllAssetsUsed();
#endif
};