//========= Copyright Valve Corporation, All rights reserved. ============// // // Purpose: // //=============================================================================// #include "cbase.h" #define WIN32_LEAN_AND_MEAN #include #include #include #include #include "snd_audio_source.h" #include "AudioWaveOutput.h" #include "ISceneManagerSound.h" #include "utlvector.h" #include "filesystem.h" #include "sentence.h" typedef struct channel_s { int leftvol; int rightvol; int rleftvol; int rrightvol; float pitch; } channel_t; #define INPUT_BUFFER_COUNT 32 class CAudioWaveInput : public CAudioInput { public: CAudioWaveInput( void ); ~CAudioWaveInput( void ); // Returns the current count of available samples int SampleCount( void ); // returns the size of each sample in bytes int SampleSize( void ) { return m_sampleSize; } // returns the sampling rate of the data int SampleRate( void ) { return m_sampleRate; } // returns a pointer to the actual data void *SampleData( void ); // release the available data (mark as done) void SampleRelease( void ); // returns the mono/stereo status of this device (true if stereo) bool IsStereo( void ) { return m_isStereo; } // begin sampling void Start( void ); // stop sampling void Stop( void ); void WaveMessage( HWAVEIN hdevice, UINT uMsg, DWORD dwParam1, DWORD dwParam2 ); private: void OpenDevice( void ); bool ValidDevice( void ) { return m_deviceId >= 0; } void ClearDevice( void ) { m_deviceId = (UINT)-1; } // returns true if the new format is better bool BetterFormat( DWORD dwNewFormat, DWORD dwOldFormat ); void InitReadyList( void ); void AddToReadyList( WAVEHDR *pBuffer ); void PopReadyList( void ); WAVEHDR *m_pReadyList; int m_sampleSize; int m_sampleRate; bool m_isStereo; UINT m_deviceId; HWAVEIN m_deviceHandle; WAVEHDR *m_buffers[ INPUT_BUFFER_COUNT ]; }; extern "C" void CALLBACK WaveData( HWAVEIN hwi, UINT uMsg, CAudioWaveInput *pAudio, DWORD dwParam1, DWORD dwParam2 ); CAudioWaveInput::CAudioWaveInput( void ) { memset( m_buffers, 0, sizeof( m_buffers ) ); int deviceCount = (int)waveInGetNumDevs(); UINT deviceId = (UINT)-1; DWORD deviceFormat = 0; int i; for ( i = 0; i < deviceCount; i++ ) { WAVEINCAPS waveCaps; MMRESULT errorCode = waveInGetDevCaps( (UINT)i, &waveCaps, sizeof(waveCaps) ); if ( errorCode == MMSYSERR_NOERROR ) { // valid device if ( BetterFormat( waveCaps.dwFormats, deviceFormat ) ) { deviceId = i; deviceFormat = waveCaps.dwFormats; } } } if ( !deviceFormat ) { m_deviceId = (UINT)-1; m_sampleSize = 0; m_sampleRate = 0; m_isStereo = false; } else { m_deviceId = deviceId; m_sampleRate = 44100; m_isStereo = false; if ( deviceFormat & WAVE_FORMAT_4M16 ) { m_sampleSize = 2; } else if ( deviceFormat & WAVE_FORMAT_4M08 ) { m_sampleSize = 1; } else { // ERROR! } OpenDevice(); } InitReadyList(); } CAudioWaveInput::~CAudioWaveInput( void ) { if ( ValidDevice() ) { Stop(); waveInReset( m_deviceHandle ); waveInClose( m_deviceHandle ); for ( int i = 0; i < INPUT_BUFFER_COUNT; i++ ) { if ( m_buffers[i] ) { waveInUnprepareHeader( m_deviceHandle, m_buffers[i], sizeof( *m_buffers[i] ) ); delete[] m_buffers[i]->lpData; delete m_buffers[i]; } m_buffers[i] = NULL; } ClearDevice(); } } void CALLBACK WaveData( HWAVEIN hwi, UINT uMsg, CAudioWaveInput *pAudio, DWORD dwParam1, DWORD dwParam2 ) { if ( pAudio ) { pAudio->WaveMessage( hwi, uMsg, dwParam1, dwParam2 ); } } void CAudioWaveInput::WaveMessage( HWAVEIN hdevice, UINT uMsg, DWORD dwParam1, DWORD dwParam2 ) { if ( hdevice != m_deviceHandle ) return; switch( uMsg ) { case WIM_DATA: WAVEHDR *pHeader = (WAVEHDR *)dwParam1; AddToReadyList( pHeader ); break; } } void CAudioWaveInput::OpenDevice( void ) { if ( !ValidDevice() ) return; WAVEFORMATEX format; memset( &format, 0, sizeof(format) ); format.nAvgBytesPerSec = m_sampleRate * m_sampleSize; format.nChannels = 1; format.wBitsPerSample = m_sampleSize * 8; format.nSamplesPerSec = m_sampleRate; format.wFormatTag = WAVE_FORMAT_PCM; format.nBlockAlign = m_sampleSize; MMRESULT errorCode = waveInOpen( &m_deviceHandle, m_deviceId, &format, (DWORD)WaveData, (DWORD)this, CALLBACK_FUNCTION ); if ( errorCode == MMSYSERR_NOERROR ) { // valid device opened int bufferSize = m_sampleSize * m_sampleRate / INPUT_BUFFER_COUNT; // total of one second of data // allocate buffers for ( int i = 0; i < INPUT_BUFFER_COUNT; i++ ) { m_buffers[i] = new WAVEHDR; m_buffers[i]->lpData = new char[ bufferSize ]; m_buffers[i]->dwBufferLength = bufferSize; m_buffers[i]->dwUser = 0; m_buffers[i]->dwFlags = 0; waveInPrepareHeader( m_deviceHandle, m_buffers[i], sizeof( *m_buffers[i] ) ); waveInAddBuffer( m_deviceHandle, m_buffers[i], sizeof( *m_buffers[i] ) ); } } else { ClearDevice(); } } void CAudioWaveInput::Start( void ) { if ( !ValidDevice() ) return; waveInStart( m_deviceHandle ); } void CAudioWaveInput::Stop( void ) { if ( !ValidDevice() ) return; waveInStop( m_deviceHandle ); } void CAudioWaveInput::InitReadyList( void ) { m_pReadyList = NULL; } void CAudioWaveInput::AddToReadyList( WAVEHDR *pBuffer ) { WAVEHDR **pList = &m_pReadyList; waveInUnprepareHeader( m_deviceHandle, pBuffer, sizeof(*pBuffer) ); // insert at the tail of the list while ( *pList ) { pList = reinterpret_cast(&((*pList)->dwUser)); } pBuffer->dwUser = NULL; *pList = pBuffer; } void CAudioWaveInput::PopReadyList( void ) { if ( m_pReadyList ) { WAVEHDR *pBuffer = m_pReadyList; m_pReadyList = reinterpret_cast(m_pReadyList->dwUser); waveInPrepareHeader( m_deviceHandle, pBuffer, sizeof(*pBuffer) ); waveInAddBuffer( m_deviceHandle, pBuffer, sizeof(*pBuffer) ); } } #define WAVE_FORMAT_STEREO (WAVE_FORMAT_1S08|WAVE_FORMAT_1S16|WAVE_FORMAT_2S08|WAVE_FORMAT_2S16|WAVE_FORMAT_4S08|WAVE_FORMAT_4S16) #define WAVE_FORMATS_UNDERSTOOD (0xFFF) #define WAVE_FORMAT_11K (WAVE_FORMAT_1M08|WAVE_FORMAT_1M16) #define WAVE_FORMAT_22K (WAVE_FORMAT_2M08|WAVE_FORMAT_2M16) #define WAVE_FORMAT_44K (WAVE_FORMAT_4M08|WAVE_FORMAT_4M16) static int HighestBit( DWORD dwFlags ) { int i = 31; while ( i ) { if ( dwFlags & (1<= HighestBit(dwNewFormat) ) return false; return true; } int CAudioWaveInput::SampleCount( void ) { if ( !ValidDevice() ) return 0; if ( m_pReadyList ) { switch( SampleSize() ) { case 2: return m_pReadyList->dwBytesRecorded >> 1; case 1: return m_pReadyList->dwBytesRecorded; default: break; } } return 0; } void *CAudioWaveInput::SampleData( void ) { if ( !ValidDevice() ) return NULL; if ( m_pReadyList ) { return m_pReadyList->lpData; } return NULL; } // release the available data (mark as done) void CAudioWaveInput::SampleRelease( void ) { PopReadyList(); } // factory to create a suitable audio input for this system CAudioInput *CAudioInput::Create( void ) { // sound source is a singleton for now static CAudioInput *pSource = NULL; if ( !pSource ) { pSource = new CAudioWaveInput; } return pSource; } void CAudioDeviceSWMix::Mix8Mono( channel_t *pChannel, char *pData, int outputOffset, int inputOffset, int rateScaleFix, int outCount, int timecompress, bool forward ) { int sampleIndex = 0; fixedint sampleFrac = inputOffset; int fixup = 0; int fixupstep = 1; if ( !forward ) { fixup = outCount - 1; fixupstep = -1; } for ( int i = 0; i < outCount; i++, fixup += fixupstep ) { int dest = max( outputOffset + fixup, 0 ); m_paintbuffer[ dest ].left += pChannel->leftvol * pData[sampleIndex]; m_paintbuffer[ dest ].right += pChannel->rightvol * pData[sampleIndex]; sampleFrac += rateScaleFix; sampleIndex += FIX_INTPART(sampleFrac); sampleFrac = FIX_FRACPART(sampleFrac); } } void CAudioDeviceSWMix::Mix8Stereo( channel_t *pChannel, char *pData, int outputOffset, int inputOffset, int rateScaleFix, int outCount, int timecompress, bool forward ) { int sampleIndex = 0; fixedint sampleFrac = inputOffset; int fixup = 0; int fixupstep = 1; if ( !forward ) { fixup = outCount - 1; fixupstep = -1; } for ( int i = 0; i < outCount; i++, fixup += fixupstep ) { int dest = max( outputOffset + fixup, 0 ); m_paintbuffer[ dest ].left += pChannel->leftvol * pData[sampleIndex]; m_paintbuffer[ dest ].right += pChannel->rightvol * pData[sampleIndex+1]; sampleFrac += rateScaleFix; sampleIndex += FIX_INTPART(sampleFrac)<<1; sampleFrac = FIX_FRACPART(sampleFrac); } } void CAudioDeviceSWMix::Mix16Mono( channel_t *pChannel, short *pData, int outputOffset, int inputOffset, int rateScaleFix, int outCount, int timecompress, bool forward ) { int sampleIndex = 0; fixedint sampleFrac = inputOffset; int fixup = 0; int fixupstep = 1; if ( !forward ) { fixup = outCount - 1; fixupstep = -1; } for ( int i = 0; i < outCount; i++, fixup += fixupstep ) { int dest = max( outputOffset + fixup, 0 ); m_paintbuffer[ dest ].left += (pChannel->leftvol * pData[sampleIndex])>>8; m_paintbuffer[ dest ].right += (pChannel->rightvol * pData[sampleIndex])>>8; sampleFrac += rateScaleFix; sampleIndex += FIX_INTPART(sampleFrac); sampleFrac = FIX_FRACPART(sampleFrac); } } void CAudioDeviceSWMix::Mix16Stereo( channel_t *pChannel, short *pData, int outputOffset, int inputOffset, int rateScaleFix, int outCount, int timecompress, bool forward ) { int sampleIndex = 0; fixedint sampleFrac = inputOffset; int fixup = 0; int fixupstep = 1; if ( !forward ) { fixup = outCount - 1; fixupstep = -1; } for ( int i = 0; i < outCount; i++, fixup += fixupstep ) { int dest = max( outputOffset + fixup, 0 ); m_paintbuffer[ dest ].left += (pChannel->leftvol * pData[sampleIndex])>>8; m_paintbuffer[ dest ].right += (pChannel->rightvol * pData[sampleIndex+1])>>8; sampleFrac += rateScaleFix; sampleIndex += FIX_INTPART(sampleFrac)<<1; sampleFrac = FIX_FRACPART(sampleFrac); } } int CAudioDeviceSWMix::MaxSampleCount( void ) { return PAINTBUFFER_SIZE; } void CAudioDeviceSWMix::MixBegin( void ) { memset( m_paintbuffer, 0, sizeof(m_paintbuffer) ); } void CAudioDeviceSWMix::TransferBufferStereo16( short *pOutput, int sampleCount ) { for ( int i = 0; i < sampleCount; i++ ) { if ( m_paintbuffer[i].left > 32767 ) m_paintbuffer[i].left = 32767; else if ( m_paintbuffer[i].left < -32768 ) m_paintbuffer[i].left = -32768; if ( m_paintbuffer[i].right > 32767 ) m_paintbuffer[i].right = 32767; else if ( m_paintbuffer[i].right < -32768 ) m_paintbuffer[i].right = -32768; *pOutput++ = (short)m_paintbuffer[i].left; *pOutput++ = (short)m_paintbuffer[i].right; } } CAudioWaveOutput::CAudioWaveOutput( void ) { for ( int i = 0; i < OUTPUT_BUFFER_COUNT; i++ ) { CAudioBuffer *buffer = &m_buffers[ i ]; Assert( buffer ); buffer->hdr = NULL; buffer->submitted = false; buffer->submit_sample_count = false; } ClearDevice(); OpenDevice(); m_mixTime = -1; m_sampleIndex = 0; memset( m_sourceList, 0, sizeof(m_sourceList) ); m_nEstimatedSamplesAhead = (int)( ( float ) OUTPUT_SAMPLE_RATE / 10.0f ); } void CAudioWaveOutput::RemoveMixerChannelReferences( CAudioMixer *mixer ) { for ( int i = 0; i < OUTPUT_BUFFER_COUNT; i++ ) { RemoveFromReferencedList( mixer, &m_buffers[ i ] ); } } void CAudioWaveOutput::AddToReferencedList( CAudioMixer *mixer, CAudioBuffer *buffer ) { // Already in list for ( int i = 0; i < buffer->m_Referenced.Size(); i++ ) { if ( buffer->m_Referenced[ i ].mixer == mixer ) { return; } } // Just remove it int idx = buffer->m_Referenced.AddToTail(); CAudioMixerState *state = &buffer->m_Referenced[ idx ]; state->mixer = mixer; state->submit_mixer_sample = mixer->GetSamplePosition(); } void CAudioWaveOutput::RemoveFromReferencedList( CAudioMixer *mixer, CAudioBuffer *buffer ) { for ( int i = 0; i < buffer->m_Referenced.Size(); i++ ) { if ( buffer->m_Referenced[ i ].mixer == mixer ) { buffer->m_Referenced.Remove( i ); break; } } } bool CAudioWaveOutput::IsSoundInReferencedList( CAudioMixer *mixer, CAudioBuffer *buffer ) { for ( int i = 0; i < buffer->m_Referenced.Size(); i++ ) { if ( buffer->m_Referenced[ i ].mixer == mixer ) { return true; } } return false; } bool CAudioWaveOutput::IsSourceReferencedByActiveBuffer( CAudioMixer *mixer ) { if ( !ValidDevice() ) return false; CAudioBuffer *buffer; for ( int i = 0; i < OUTPUT_BUFFER_COUNT; i++ ) { buffer = &m_buffers[ i ]; if ( !buffer->submitted ) continue; if ( buffer->hdr->dwFlags & WHDR_DONE ) continue; // See if it's referenced if ( IsSoundInReferencedList( mixer, buffer ) ) return true; } return false; } CAudioWaveOutput::~CAudioWaveOutput( void ) { if ( ValidDevice() ) { waveOutReset( m_deviceHandle ); for ( int i = 0; i < OUTPUT_BUFFER_COUNT; i++ ) { if ( m_buffers[i].hdr ) { waveOutUnprepareHeader( m_deviceHandle, m_buffers[i].hdr, sizeof(*m_buffers[i].hdr) ); delete[] m_buffers[i].hdr->lpData; delete m_buffers[i].hdr; } m_buffers[i].hdr = NULL; m_buffers[i].submitted = false; m_buffers[i].submit_sample_count = 0; m_buffers[i].m_Referenced.Purge(); } waveOutClose( m_deviceHandle ); ClearDevice(); } } CAudioBuffer *CAudioWaveOutput::GetEmptyBuffer( void ) { CAudioBuffer *pOutput = NULL; if ( ValidDevice() ) { for ( int i = 0; i < OUTPUT_BUFFER_COUNT; i++ ) { if ( !(m_buffers[ i ].submitted ) || m_buffers[i].hdr->dwFlags & WHDR_DONE ) { pOutput = &m_buffers[i]; pOutput->submitted = true; pOutput->m_Referenced.Purge(); break; } } } return pOutput; } void CAudioWaveOutput::SilenceBuffer( short *pSamples, int sampleCount ) { int i; for ( i = 0; i < sampleCount; i++ ) { // left *pSamples++ = 0; // right *pSamples++ = 0; } } void CAudioWaveOutput::Flush( void ) { waveOutReset( m_deviceHandle ); } // mix a buffer up to time (time is absolute) void CAudioWaveOutput::Update( float time ) { channel_t channel; channel.leftvol = 200; channel.rightvol = 200; channel.pitch = 1.0; if ( !ValidDevice() ) return; // reset the system if ( m_mixTime < 0 || time < m_baseTime ) { m_baseTime = time; m_mixTime = 0; } // put time in our coordinate frame time -= m_baseTime; if ( time > m_mixTime ) { CAudioBuffer *pBuffer = GetEmptyBuffer(); // no free buffers, mixing is ahead of the playback! if ( !pBuffer || !pBuffer->hdr ) { //Con_Printf( "out of buffers\n" ); return; } // UNDONE: These numbers are constants // calc number of samples (2 channels * 2 bytes per sample) int sampleCount = pBuffer->hdr->dwBufferLength >> 2; //float oldTime = m_mixTime; m_mixTime += sampleCount * (1.0f / OUTPUT_SAMPLE_RATE); short *pSamples = reinterpret_cast(pBuffer->hdr->lpData); SilenceBuffer( pSamples, sampleCount ); int tempCount = sampleCount; while ( tempCount > 0 ) { if ( tempCount > m_audioDevice.MaxSampleCount() ) sampleCount = m_audioDevice.MaxSampleCount(); else sampleCount = tempCount; m_audioDevice.MixBegin(); for ( int i = 0; i < MAX_CHANNELS; i++ ) { CAudioMixer *pSource = m_sourceList[i]; if ( !pSource ) continue; int currentsample = pSource->GetSamplePosition(); bool forward = pSource->GetDirection(); if ( pSource->GetActive() ) { if ( !pSource->MixDataToDevice( &m_audioDevice, &channel, currentsample, sampleCount, SampleRate(), forward ) ) { // Source becomes inactive when last submitted sample is finally // submitted. But it lingers until it's no longer referenced pSource->SetActive( false ); } else { AddToReferencedList( pSource, pBuffer ); } } else { if ( !IsSourceReferencedByActiveBuffer( pSource ) ) { if ( !pSource->GetAutoDelete() ) { FreeChannel( i ); } } else { pSource->IncrementSamples( &channel, currentsample, sampleCount, SampleRate(), forward ); } } } m_audioDevice.TransferBufferStereo16( pSamples, sampleCount ); m_sampleIndex += sampleCount; tempCount -= sampleCount; pSamples += sampleCount * 2; } // if the buffers aren't aligned on sample boundaries, this will hard-lock the machine! pBuffer->submit_sample_count = GetOutputPosition(); waveOutWrite( m_deviceHandle, pBuffer->hdr, sizeof(*(pBuffer->hdr)) ); } } int CAudioWaveOutput::GetNumberofSamplesAhead( void ) { ComputeSampleAheadAmount(); return m_nEstimatedSamplesAhead; } float CAudioWaveOutput::GetAmountofTimeAhead( void ) { ComputeSampleAheadAmount(); return ( (float)m_nEstimatedSamplesAhead / (float)OUTPUT_SAMPLE_RATE ); } // Find the most recent submitted sample that isn't flagged as whdr_done void CAudioWaveOutput::ComputeSampleAheadAmount( void ) { m_nEstimatedSamplesAhead = 0; int newest_sample_index = -1; int newest_sample_count = 0; CAudioBuffer *buffer; if ( ValidDevice() ) { for ( int i = 0; i < OUTPUT_BUFFER_COUNT; i++ ) { buffer = &m_buffers[ i ]; if ( !buffer->submitted ) continue; if ( buffer->hdr->dwFlags & WHDR_DONE ) continue; if ( buffer->submit_sample_count > newest_sample_count ) { newest_sample_index = i; newest_sample_count = buffer->submit_sample_count; } } } if ( newest_sample_index == -1 ) return; buffer = &m_buffers[ newest_sample_index ]; int currentPos = GetOutputPosition() ; m_nEstimatedSamplesAhead = currentPos - buffer->submit_sample_count; } int CAudioWaveOutput::FindSourceIndex( CAudioMixer *pSource ) { for ( int i = 0; i < MAX_CHANNELS; i++ ) { if ( pSource == m_sourceList[i] ) { return i; } } return -1; } CAudioMixer *CAudioWaveOutput::GetMixerForSource( CAudioSource *source ) { for ( int i = 0; i < MAX_CHANNELS; i++ ) { if ( !m_sourceList[i] ) continue; if ( source == m_sourceList[i]->GetSource() ) { return m_sourceList[i]; } } return NULL; } void CAudioWaveOutput::AddSource( CAudioMixer *pSource ) { int slot = 0; for ( int i = 0; i < MAX_CHANNELS; i++ ) { if ( !m_sourceList[i] ) { slot = i; break; } } if ( m_sourceList[slot] ) { FreeChannel( slot ); } SetChannel( slot, pSource ); pSource->SetActive( true ); } void CAudioWaveOutput::StopSounds( void ) { for ( int i = 0; i < MAX_CHANNELS; i++ ) { if ( m_sourceList[i] ) { FreeChannel( i ); } } } void CAudioWaveOutput::SetChannel( int channelIndex, CAudioMixer *pSource ) { if ( channelIndex < 0 || channelIndex >= MAX_CHANNELS ) return; m_sourceList[channelIndex] = pSource; } void CAudioWaveOutput::FreeChannel( int channelIndex ) { if ( channelIndex < 0 || channelIndex >= MAX_CHANNELS ) return; if ( m_sourceList[channelIndex] ) { RemoveMixerChannelReferences( m_sourceList[channelIndex] ); delete m_sourceList[channelIndex]; m_sourceList[channelIndex] = NULL; } } int CAudioWaveOutput::GetOutputPosition( void ) { if ( !m_deviceHandle ) return 0; MMTIME mmtime; mmtime.wType = TIME_SAMPLES; waveOutGetPosition( m_deviceHandle, &mmtime, sizeof( MMTIME ) ); // Convert time to sample count return ( mmtime.u.sample ); } void CAudioWaveOutput::OpenDevice( void ) { WAVEFORMATEX waveFormat; memset( &waveFormat, 0, sizeof(waveFormat) ); // Select a PCM, 16-bit stereo playback device waveFormat.cbSize = sizeof(waveFormat); waveFormat.nAvgBytesPerSec = OUTPUT_SAMPLE_RATE * 2 * 2; waveFormat.nBlockAlign = 2 * 2; // channels * sample size waveFormat.nChannels = 2; // stereo waveFormat.nSamplesPerSec = OUTPUT_SAMPLE_RATE; waveFormat.wBitsPerSample = 16; waveFormat.wFormatTag = WAVE_FORMAT_PCM; MMRESULT errorCode = waveOutOpen( &m_deviceHandle, WAVE_MAPPER, &waveFormat, 0, 0, CALLBACK_NULL ); if ( errorCode == MMSYSERR_NOERROR ) { int bufferSize = 4 * ( OUTPUT_SAMPLE_RATE / OUTPUT_BUFFER_COUNT ); // total of 1 second of data // Got one! for ( int i = 0; i < OUTPUT_BUFFER_COUNT; i++ ) { m_buffers[i].hdr = new WAVEHDR; m_buffers[i].hdr->lpData = new char[ bufferSize ]; long align = (long)m_buffers[i].hdr->lpData; if ( align & 3 ) { m_buffers[i].hdr->lpData = (char *) ( (align+3) &~3 ); } m_buffers[i].hdr->dwBufferLength = bufferSize - (align&3); m_buffers[i].hdr->dwFlags = 0; if ( waveOutPrepareHeader( m_deviceHandle, m_buffers[i].hdr, sizeof(*m_buffers[i].hdr) ) != MMSYSERR_NOERROR ) { ClearDevice(); return; } } } else { ClearDevice(); } } // factory to create a suitable audio output for this system CAudioOutput *CAudioOutput::Create( void ) { // sound device is a singleton for now static CAudioOutput *pWaveOut = NULL; if ( !pWaveOut ) { pWaveOut = new CAudioWaveOutput; } return pWaveOut; } struct CSoundFile { char filename[ 512 ]; CAudioSource *source; long filetime; }; //----------------------------------------------------------------------------- // Purpose: //----------------------------------------------------------------------------- class CSceneManagerSound : public ISceneManagerSound { public: ~CSceneManagerSound( void ); void Init( void ); void Shutdown( void ); void Update( float dt ); void Flush( void ); CAudioSource *LoadSound( const char *wavfile ); void PlaySound( const char *wavfile, CAudioMixer **ppMixer ); void PlaySound( CAudioSource *source, CAudioMixer **ppMixer ); bool IsSoundPlaying( CAudioMixer *pMixer ); CAudioMixer *FindMixer( CAudioSource *source ); void StopAll( void ); void StopSound( CAudioMixer *mixer ); CAudioOuput *GetAudioOutput( void ); virtual CAudioSource *FindOrAddSound( const char *filename ); private: CAudioOutput *m_pAudio; float m_flElapsedTime; CUtlVector < CSoundFile > m_ActiveSounds; }; static CSceneManagerSound g_FacePoserSound; ISceneManagerSound *sound = ( ISceneManagerSound * )&g_FacePoserSound; CSceneManagerSound::~CSceneManagerSound( void ) { OutputDebugString( va( "Removing %i sounds\n", m_ActiveSounds.Size() ) ); for ( int i = 0 ; i < m_ActiveSounds.Size(); i++ ) { CSoundFile *p = &m_ActiveSounds[ i ]; OutputDebugString( va( "Removing sound: %s\n", p->filename ) ); delete p->source; } m_ActiveSounds.RemoveAll(); } //----------------------------------------------------------------------------- // Purpose: //----------------------------------------------------------------------------- CAudioOuput *CSceneManagerSound::GetAudioOutput( void ) { return (CAudioOuput *)m_pAudio; } CAudioSource *CSceneManagerSound::FindOrAddSound( const char *filename ) { CSoundFile *s; int i; for ( i = 0; i < m_ActiveSounds.Size(); i++ ) { s = &m_ActiveSounds[ i ]; Assert( s ); if ( !stricmp( s->filename, filename ) ) { long filetime = filesystem->GetFileTime( filename ); if ( filetime != s->filetime ) { Con_Printf( "Reloading sound %s\n", filename ); delete s->source; s->source = LoadSound( filename ); s->filetime = filetime; } return s->source; } } i = m_ActiveSounds.AddToTail(); s = &m_ActiveSounds[ i ]; strcpy( s->filename, filename ); s->source = LoadSound( filename ); s->filetime = filesystem->GetFileTime( filename ); return s->source; } void CSceneManagerSound::Init( void ) { m_flElapsedTime = 0.0f; m_pAudio = CAudioOutput::Create(); } void CSceneManagerSound::Shutdown( void ) { } CAudioSource *CSceneManagerSound::LoadSound( const char *wavfile ) { if ( !m_pAudio ) return NULL; CAudioSource *wave = AudioSource_Create( wavfile ); return wave; } void CSceneManagerSound::PlaySound( const char *wavfile, CAudioMixer **ppMixer ) { if ( m_pAudio ) { CAudioSource *wave = FindOrAddSound( wavfile ); if ( !wave ) return; CAudioMixer *pMixer = wave->CreateMixer(); if ( ppMixer ) { *ppMixer = pMixer; } m_pAudio->AddSource( pMixer ); } } void CSceneManagerSound::PlaySound( CAudioSource *source, CAudioMixer **ppMixer ) { if ( ppMixer ) { *ppMixer = NULL; } if ( m_pAudio ) { CAudioMixer *mixer = source->CreateMixer(); if ( ppMixer ) { *ppMixer = mixer; } m_pAudio->AddSource( mixer ); } } void CSceneManagerSound::Update( float dt ) { if ( m_pAudio ) { m_pAudio->Update( m_flElapsedTime ); } m_flElapsedTime += dt; } void CSceneManagerSound::Flush( void ) { if ( m_pAudio ) { m_pAudio->Flush(); } } void CSceneManagerSound::StopAll( void ) { if ( m_pAudio ) { m_pAudio->StopSounds(); } } void CSceneManagerSound::StopSound( CAudioMixer *mixer ) { int idx = m_pAudio->FindSourceIndex( mixer ); if ( idx != -1 ) { m_pAudio->FreeChannel( idx ); } } bool CSceneManagerSound::IsSoundPlaying( CAudioMixer *pMixer ) { if ( !m_pAudio || !pMixer ) { return false; } // int index = m_pAudio->FindSourceIndex( pMixer ); if ( index != -1 ) return true; return false; } CAudioMixer *CSceneManagerSound::FindMixer( CAudioSource *source ) { if ( !m_pAudio ) return NULL; return m_pAudio->GetMixerForSource( source ); }