void GameAudio::processPunchSound()
{
if (soundEffectRegistrationMap[ENUM_SOUND_EFFECT_PUNCH] == true)
{
Game *game = Game::getSingleton();
GameStateManager *gsm = game->getGSM();
SpriteManager *spriteMgr = gsm->getSpriteManager();
PlayerSprite *player = spriteMgr->getPlayer();
wstring playerState = player->getCurrentState();
if (playerState.compare(L"PUNCH_LEFT") == 0 || playerState.compare(L"PUNCH_RIGHT") == 0
|| playerState.compare(L"PUNCH_BACK") == 0 || playerState.compare(L"PUNCH_FRONT") == 0)
{
IXAudio2SourceVoice *punchSound = soundEffectMap[ENUM_SOUND_EFFECT_PUNCH];
XAUDIO2_VOICE_STATE voiceState;
punchSound->GetState(&voiceState);
//// [voiceState.BuffersQueued <= 0] means there are nothing in the buffer
//// so let's make a new buffer to queue the sound
if (voiceState.BuffersQueued <= 0)
{
XAUDIO2_BUFFER *proto = audioBufferPrototypeMap[ENUM_SOUND_EFFECT_PUNCH];
bool ssbSuccess = SUCCEEDED(punchSound->SubmitSourceBuffer(proto));
punchSound->Start();
}
//// if there is something in the buffer
else
{
/// do nothing
}
}
}
}
void GameAudio::processHealSound()
{
if (soundEffectRegistrationMap[ENUM_SOUND_EFFECT_HEAL] == true)
{
Game *game = Game::getSingleton();
GameStateManager *gsm = game->getGSM();
SpriteManager *spriteMgr = gsm->getSpriteManager();
PlayerSprite *player = spriteMgr->getPlayer();
bool isHealing = player->getIshealing();
if (isHealing == true)
{
IXAudio2SourceVoice *healSound = soundEffectMap[ENUM_SOUND_EFFECT_HEAL];
XAUDIO2_VOICE_STATE voiceState;
healSound->GetState(&voiceState);
//// [voiceState.BuffersQueued <= 0] means there are nothing in the buffer
//// so let's make a new buffer to queue the sound
if (voiceState.BuffersQueued <= 0)
{
XAUDIO2_BUFFER *proto = audioBufferPrototypeMap[ENUM_SOUND_EFFECT_HEAL];
bool ssbSuccess = SUCCEEDED(healSound->SubmitSourceBuffer(proto));
healSound->Start();
//// After all, there will be only one buffer node in the queue always ...
}
//// if there is something in the buffer
else
{
/// do nothing
}
}
}
}
virtual const char* write_frame( void * buffer, unsigned num_samples, bool wait )
{
if ( paused )
{
if ( wait ) Sleep( MulDiv( num_samples / nch, 1000, sample_rate ) );
return 0;
}
if ( reopen_count )
{
if ( ! --reopen_count )
{
const char * err = open( hwnd, sample_rate, nch, max_samples_per_frame, num_frames );
if ( err )
{
reopen_count = 60 * 5;
return err;
}
}
else
{
if ( wait ) Sleep( MulDiv( num_samples / nch, 1000, sample_rate ) );
return 0;
}
}
for (;;) {
sVoice->GetState( &vState );
assert( vState.BuffersQueued <= num_frames );
if( vState.BuffersQueued < num_frames ) {
if( vState.BuffersQueued == 0 ) {
// buffers ran dry
}
// there is at least one free buffer
break;
} else {
// wait for one buffer to finish playing
ResetEvent( notify.hBufferEndEvent );
WaitForSingleObject( notify.hBufferEndEvent, INFINITE );
}
}
samples_in_buffer[ buffer_write_cursor ] = num_samples / nch;
XAUDIO2_BUFFER buf = {0};
unsigned num_bytes = num_samples * 2;
buf.AudioBytes = num_bytes;
buf.pAudioData = ( const BYTE * )( sample_buffer + max_samples_per_frame * buffer_write_cursor );
buf.pContext = this;
buffer_write_cursor = ( buffer_write_cursor + 1 ) % num_frames;
memcpy( ( void * ) buf.pAudioData, buffer, num_bytes );
if( sVoice->SubmitSourceBuffer( &buf ) == S_OK )
{
InterlockedIncrement( &buffered_count );
return 0;
}
close();
reopen_count = 60 * 5;
return 0;
}
static void
XAUDIO2_CloseDevice(_THIS)
{
if (_this->hidden != NULL) {
IXAudio2 *ixa2 = _this->hidden->ixa2;
IXAudio2SourceVoice *source = _this->hidden->source;
IXAudio2MasteringVoice *mastering = _this->hidden->mastering;
if (source != NULL) {
source->Stop();
source->FlushSourceBuffers();
source->DestroyVoice();
}
if (ixa2 != NULL) {
ixa2->StopEngine();
}
if (mastering != NULL) {
mastering->DestroyVoice();
}
if (ixa2 != NULL) {
ixa2->Release();
}
SDL_free(_this->hidden->mixbuf);
if (_this->hidden->semaphore != NULL) {
CloseHandle(_this->hidden->semaphore);
}
SDL_free(_this->hidden);
_this->hidden = NULL;
}
}
void XAudio2_Output::close()
{
initialized = false;
if( sVoice ) {
if( playing ) {
HRESULT hr = sVoice->Stop( 0 );
ASSERT( hr == S_OK );
}
sVoice->DestroyVoice();
sVoice = NULL;
}
if( buffers ) {
free( buffers );
buffers = NULL;
}
if( mVoice ) {
mVoice->DestroyVoice();
mVoice = NULL;
}
if( xaud ) {
xaud->Release();
xaud = NULL;
}
}
virtual const char* pause( bool pausing )
{
if ( pausing )
{
if ( ! paused )
{
paused = true;
HRESULT hr = sVoice->Stop( 0 );
if ( FAILED(hr) )
{
close();
reopen_count = 60 * 5;
}
}
}
else
{
if ( paused )
{
paused = false;
HRESULT hr = sVoice->Start( 0 );
if ( FAILED(hr) )
{
close();
reopen_count = 60 * 5;
}
}
}
return 0;
}
void GameAudio::stopMusic(MusicTypes musicType)
{
if (musicRegistrationMap[musicType] == true)
{
IXAudio2SourceVoice *sourceVoice = musicMap[musicType];
sourceVoice->Stop();
sourceVoice->FlushSourceBuffers();
}
}
bool Audio::AddAudioFile(const char* i_AudioPath, bool bLoop, float i_InitialVolume)
{
WAVEFORMATEXTENSIBLE wfx = { 0 };
XAUDIO2_BUFFER buffer = { 0 };
// Open the file
HANDLE hFile = CreateFile(
i_AudioPath,
GENERIC_READ,
FILE_SHARE_READ,
NULL,
OPEN_EXISTING,
0,
NULL);
SetFilePointer(hFile, 0, NULL, FILE_BEGIN);
DWORD dwChunkSize;
DWORD dwChunkPosition;
//check the file type, should be fourccWAVE or 'XWMA'
FindChunk(hFile, fourccRIFF, dwChunkSize, dwChunkPosition);
DWORD filetype;
ReadChunkData(hFile, &filetype, sizeof(DWORD), dwChunkPosition);
if (filetype != fourccWAVE)
return false;
FindChunk(hFile, fourccFMT, dwChunkSize, dwChunkPosition);
ReadChunkData(hFile, &wfx, dwChunkSize, dwChunkPosition);
//fill out the audio data buffer with the contents of the fourccDATA chunk
FindChunk(hFile, fourccDATA, dwChunkSize, dwChunkPosition);
BYTE * pDataBuffer = new BYTE[dwChunkSize];
ReadChunkData(hFile, pDataBuffer, dwChunkSize, dwChunkPosition);
buffer.AudioBytes = dwChunkSize; //buffer containing audio data
buffer.pAudioData = pDataBuffer; //size of the audio buffer in bytes
buffer.Flags = XAUDIO2_END_OF_STREAM; // tell the source voice not to expect any data after this buffer
if (bLoop)
{
buffer.LoopLength = 0;
buffer.LoopCount = XAUDIO2_LOOP_INFINITE;
}
HRESULT hr;
IXAudio2SourceVoice* pSourceVoice;
if (FAILED(hr = s_pXAudio2->CreateSourceVoice(&pSourceVoice, (WAVEFORMATEX*)&wfx)))
return false;
if (FAILED(hr = pSourceVoice->SubmitSourceBuffer(&buffer)))
return false;
pSourceVoice->SetVolume(i_InitialVolume);
s_SourceVoices.push_back(pSourceVoice);
s_AudioBuffers.push_back(buffer);
}
virtual const char* open( void * hwnd, unsigned sample_rate, unsigned nch, unsigned max_samples_per_frame, unsigned num_frames )
{
this->hwnd = hwnd;
this->sample_rate = sample_rate;
this->nch = nch;
this->max_samples_per_frame = max_samples_per_frame;
this->num_frames = num_frames;
#ifdef HAVE_KS_HEADERS
WAVEFORMATEXTENSIBLE wfx;
wfx.Format.wFormatTag = WAVE_FORMAT_EXTENSIBLE;
wfx.Format.nChannels = nch; //1;
wfx.Format.nSamplesPerSec = sample_rate;
wfx.Format.nBlockAlign = 2 * nch; //2;
wfx.Format.nAvgBytesPerSec = wfx.Format.nSamplesPerSec * wfx.Format.nBlockAlign;
wfx.Format.wBitsPerSample = 16;
wfx.Format.cbSize = sizeof(WAVEFORMATEXTENSIBLE)-sizeof(WAVEFORMATEX);
wfx.Samples.wValidBitsPerSample = 16;
wfx.SubFormat = KSDATAFORMAT_SUBTYPE_PCM;
wfx.dwChannelMask = nch == 2 ? KSAUDIO_SPEAKER_STEREO : KSAUDIO_SPEAKER_MONO;
#else
WAVEFORMATEX wfx;
wfx.wFormatTag = WAVE_FORMAT_PCM;
wfx.nChannels = nch; //1;
wfx.nSamplesPerSec = sample_rate;
wfx.nBlockAlign = 2 * nch; //2;
wfx.nAvgBytesPerSec = wfx.nSamplesPerSec * wfx.nBlockAlign;
wfx.wBitsPerSample = 16;
wfx.cbSize = 0;
#endif
HRESULT hr = XAudio2Create( &xaud, 0 );
if (FAILED(hr)) return "Creating XAudio2 interface";
hr = xaud->CreateMasteringVoice(
&mVoice,
nch,
sample_rate,
0,
NULL,
NULL );
if (FAILED(hr)) return "Creating XAudio2 mastering voice";
hr = xaud->CreateSourceVoice( &sVoice, &wfx, 0, 4.0f, ¬ify );
if (FAILED(hr)) return "Creating XAudio2 source voice";
hr = sVoice->Start( 0 );
if (FAILED(hr)) return "Starting XAudio2 voice";
hr = sVoice->SetFrequencyRatio((float)1.0f);
if (FAILED(hr)) return "Setting XAudio2 voice frequency ratio";
buffered_count = 0;
buffer_read_cursor = 0;
buffer_write_cursor = 0;
samples_played = 0;
sample_buffer = new int16_t[ max_samples_per_frame * num_frames ];
samples_in_buffer = new UINT64[ num_frames ];
memset( samples_in_buffer, 0, sizeof( UINT64 ) * num_frames );
return NULL;
}
static void
XAUDIO2_WaitDone(_THIS)
{
IXAudio2SourceVoice *source = _this->hidden->source;
XAUDIO2_VOICE_STATE state;
SDL_assert(!_this->enabled); /* flag that stops playing. */
source->Discontinuity();
source->GetState(&state);
while (state.BuffersQueued > 0) {
WaitForSingleObjectEx(_this->hidden->semaphore, INFINITE, 0);
source->GetState(&state);
}
}
void XAudio2_Output::reset()
{
if( !initialized || failed ) return;
if( playing ) {
HRESULT hr = sVoice->Stop( 0 );
ASSERT( hr == S_OK );
}
sVoice->FlushSourceBuffers();
sVoice->Start( 0 );
playing = true;
}
void XAudio2_Output::write(u16 * finalWave, int length)
{
if( !initialized || failed ) return;
while( true ) {
if ( device_changed ) {
close();
if (!init(freq)) return;
}
sVoice->GetState( &vState );
ASSERT( vState.BuffersQueued <= bufferCount );
if( vState.BuffersQueued < bufferCount ) {
if( vState.BuffersQueued == 0 ) {
// buffers ran dry
if( systemVerbose & VERBOSE_SOUNDOUTPUT ) {
static unsigned int i = 0;
log( "XAudio2: Buffers were not refilled fast enough (i=%i)\n", i++ );
}
}
// there is at least one free buffer
break;
} else {
// the maximum number of buffers is currently queued
if( synchronize && !speedup && !theApp.throttle ) {
// wait for one buffer to finish playing
if (WaitForSingleObject( notify.hBufferEndEvent, 10000 ) == WAIT_TIMEOUT) {
device_changed = true;
}
} else {
// drop current audio frame
return;
}
}
}
// copy & protect the audio data in own memory area while playing it
CopyMemory( &buffers[ currentBuffer * soundBufferLen ], finalWave, soundBufferLen );
buf.AudioBytes = soundBufferLen;
buf.pAudioData = &buffers[ currentBuffer * soundBufferLen ];
currentBuffer++;
currentBuffer %= ( bufferCount + 1 ); // + 1 because we need one temporary buffer
HRESULT hr = sVoice->SubmitSourceBuffer( &buf ); // send buffer to queue
ASSERT( hr == S_OK );
}
void SoundManager::update(Camera* p_gameCamera)
{
m_masterVoice->SetVolume(m_masterVolume,0);
updateListener(p_gameCamera);
X3DAudioCalculate(m_X3DAudioInstance, &m_listener, &m_music->getEmitter(),
X3DAUDIO_CALCULATE_MATRIX, &m_music->getDSPSettings());
IXAudio2SourceVoice* voice = m_music->getSource();
m_left = m_matrixCoefficients[0];
m_right = m_matrixCoefficients[1];
voice->SetOutputMatrix( m_masterVoice, 1, m_destChannels, m_matrixCoefficients);
if(!m_music->isPlaying())
m_music->play();
}
void XAudio2_Output::setThrottle( unsigned short throttle )
{
if( !initialized || failed ) return;
if( throttle == 0 ) throttle = 100;
HRESULT hr = sVoice->SetFrequencyRatio( (float)throttle / 100.0f );
ASSERT( hr == S_OK );
}
void GameAudio::playMusicRepeat(MusicTypes musicType)
{
if (musicRegistrationMap[musicType] == true)
{
IXAudio2SourceVoice *sourceVoice = musicMap[musicType];
XAUDIO2_VOICE_STATE voiceState;
sourceVoice->GetState(&voiceState);
if (voiceState.BuffersQueued <= 0)
{
XAUDIO2_BUFFER *proto = musicBufferPrototypeMap[musicType];
bool ssbSuccess = SUCCEEDED(sourceVoice->SubmitSourceBuffer(proto));
sourceVoice->Start();
}
}
}
virtual double buffered()
{
sVoice->GetState( &vState );
double buffered_count = vState.BuffersQueued;
INT64 samples_played = vState.SamplesPlayed - this->samples_played;
buffered_count -= double( samples_played ) / double( max_samples_per_frame / nch );
return buffered_count;
}
void StreamingVoiceContext2_7::SubmitBuffer(PBYTE buf_data)
{
XAUDIO2_BUFFER buf = {};
buf.AudioBytes = BUFFER_SIZE_BYTES;
buf.pContext = buf_data;
buf.pAudioData = buf_data;
m_source_voice->SubmitSourceBuffer(&buf);
}
void XAudio2_Output::pause()
{
if( !initialized || failed ) return;
if( playing ) {
HRESULT hr = sVoice->Stop( 0 );
ASSERT( hr == S_OK );
playing = false;
}
}
void XAudio2_Output::resume()
{
if( !initialized || failed ) return;
if( !playing ) {
HRESULT hr = sVoice->Start( 0 );
ASSERT( hr == S_OK );
playing = true;
}
}
void GameAudio::processMoneySound()
{
if (soundEffectRegistrationMap[ENUM_SOUND_EFFECT_MONEY] == true)
{
if (moneySoundSignal == true)
{
IXAudio2SourceVoice *moneySound = soundEffectMap[ENUM_SOUND_EFFECT_MONEY];
XAUDIO2_VOICE_STATE voiceState;
moneySound->GetState(&voiceState);
XAUDIO2_BUFFER *proto = audioBufferPrototypeMap[ENUM_SOUND_EFFECT_MONEY];
bool ssbSuccess = SUCCEEDED(moneySound->SubmitSourceBuffer(proto));
moneySound->Start();
moneySoundSignal = false;
}
}
}
void GameAudio::playMusicOnce(MusicTypes musicType)
{
if (musicRegistrationMap[musicType] == true)
{
IXAudio2SourceVoice *sourceVoice = musicMap[musicType];
XAUDIO2_VOICE_STATE voiceState;
sourceVoice->GetState(&voiceState);
if (musicType == ENUM_MUSIC_LEVEL_COMPLETE)
{
if (levelCompleteMusicBuffered == false)
{
XAUDIO2_BUFFER *proto = musicBufferPrototypeMap[musicType];
bool ssbSuccess = SUCCEEDED(sourceVoice->SubmitSourceBuffer(proto));
sourceVoice->Start();
levelCompleteMusicBuffered = true;
}
}
/// here put the game over music
else if (musicType == ENUM_MUSIC_GAMEOVER)
{
if (gameOverMusicBuffered == false)
{
XAUDIO2_BUFFER *proto = musicBufferPrototypeMap[musicType];
bool ssbSuccess = SUCCEEDED(sourceVoice->SubmitSourceBuffer(proto));
sourceVoice->Start();
gameOverMusicBuffered = true;
}
}
}
}
static void
XAUDIO2_PlayDevice(_THIS)
{
XAUDIO2_BUFFER buffer;
Uint8 *mixbuf = _this->hidden->mixbuf;
Uint8 *nextbuf = _this->hidden->nextbuf;
const int mixlen = _this->hidden->mixlen;
IXAudio2SourceVoice *source = _this->hidden->source;
HRESULT result = S_OK;
if (!_this->enabled) { /* shutting down? */
return;
}
/* Submit the next filled buffer */
SDL_zero(buffer);
buffer.AudioBytes = mixlen;
buffer.pAudioData = nextbuf;
buffer.pContext = _this;
buffer.LoopCount = 1;
if (nextbuf == mixbuf) {
nextbuf += mixlen;
} else {
nextbuf = mixbuf;
}
_this->hidden->nextbuf = nextbuf;
result = source->SubmitSourceBuffer(&buffer);
if (result == XAUDIO2_E_DEVICE_INVALIDATED) {
/* !!! FIXME: possibly disconnected or temporary lost. Recover? */
}
if (result != S_OK) { /* uhoh, panic! */
source->FlushSourceBuffers();
_this->enabled = 0;
}
}
void XAudio2Streamer::Stream( void const *pSamples )
{
// Verify buffer availability
XAUDIO2_VOICE_STATE xa2vs;
m_pXAudio2SourceVoice->GetState( &xa2vs );
if( xa2vs.BuffersQueued == m_count )
return;
// Copy samples to buffer
Sample *pBuffer( &m_samples[ m_index * m_size ] );
using std::memcpy;
memcpy( pBuffer, pSamples, m_size );
// Submit buffer to voice
XAUDIO2_BUFFER xa2b = {};
xa2b.AudioBytes = UINT32( m_size );
xa2b.pAudioData = pBuffer;
if( FAILED( m_pXAudio2SourceVoice->SubmitSourceBuffer( &xa2b ) ) )
return;
// Select next buffer
m_index = ( m_index + 1 ) % m_count;
}
void close()
{
if( sVoice ) {
if( !paused ) {
sVoice->Stop( 0 );
}
sVoice->DestroyVoice();
}
if( mVoice ) {
mVoice->DestroyVoice();
}
if( xaud ) {
xaud->Release();
xaud = NULL;
}
delete [] sample_buffer;
sample_buffer = NULL;
delete [] samples_in_buffer;
samples_in_buffer = NULL;
}
void WMA::Play()
{
HRESULT hr;
//uint32_t decodedDataSize = GetSize();
/*uint32_t decodedDataSize = m_WaveFormatEx.nSamplesPerSec * m_WaveFormatEx.wBitsPerSample / 8 * m_WaveFormatEx.nChannels * 6;
uint32_t readSize = 0;
BYTE * data1 = new BYTE[decodedDataSize];
SingleRead( data1, decodedDataSize, &readSize );
XAUDIO2_BUFFER buffer1 = {0};
buffer1.AudioBytes = readSize;
buffer1.Flags = XAUDIO2_END_OF_STREAM;
buffer1.pAudioData = data1;*/
mMaxBufferSize = 0;
hr = m_pReaderAdvanced->GetMaxOutputSampleSize( 0, &mMaxBufferSize );
//mMaxBufferSize = m_WaveFormatEx.nSamplesPerSec * m_WaveFormatEx.wBitsPerSample / 8 * m_WaveFormatEx.nChannels * 2;
if( FAILED( hr = gXAudio->CreateSourceVoice( &mSourceVoice, &m_WaveFormatEx, 0, XAUDIO2_DEFAULT_FREQ_RATIO, &mVoiceCallback, NULL, NULL ) ))
{
std::cout << "Error creating source buffer:" << hr << std::endl;
return;
}
if( FAILED( hr = mSourceVoice->Start( 0, XAUDIO2_COMMIT_NOW ) ) ) {
std::cout << "Error starting buffer" << std::endl;
return;
}
//mDecodedBuffers = new uint8_t[MAX_BUFFER_COUNT * (mMaxBufferSize + DECODING_BUFFER_ERROR)];
mDecodedBuffers = new uint8_t[MAX_BUFFER_COUNT * mMaxBufferSize];
mCurrentBuffer = 0;
mCurrentTime = 0;
hr = m_pReader->Start(0, 0, 1.0f, this);
if( FAILED(hr) ) {
std::cout << "Error starting decoder" << std::endl;
return;
}
/*if( FAILED( hr = mSourceVoice->SubmitSourceBuffer( &buffer1 ) ) ) {
std::cout << "Error submitting source buffer:" << hr << std::endl;
return;
}*/
}
HRESULT SubmitBuffer()
{
// Ensure we do have a valid voice
if (this->SourceVoice == nullptr)
{
return E_FAIL;
}
MxMixSamples(this->buffer, this->bufferLength / 4);
XAUDIO2_BUFFER buf = { 0 };
buf.AudioBytes = this->bufferLength;
buf.pAudioData = (const BYTE *) this->buffer;
return SourceVoice->SubmitSourceBuffer(&buf);
}
/* Loads a sound with the specified id and path
*/
void XAudioSoundSystem::OnLoadSound(uint32 soundID, const char* szSoundPath)
{
if(mSounds[soundID] != NULL)
return;
HRESULT hr = S_OK;
char szFullPath[1024];
sprintf_s(szFullPath, 1024, "Data/Win32/%s", szSoundPath);
size_t convertedChars = 0;
wchar_t wpath[1024];
mbstowcs_s(&convertedChars, wpath, strlen(szFullPath) + 1, szFullPath, _TRUNCATE);
//
// Read in the wave file
//
CWaveFile wav;
if( FAILED( hr = wav.Open( wpath, NULL, WAVEFILE_READ ) ) )
{
wprintf( L"Failed reading WAV file: %#X (%s)\n", hr, wpath );
return;
}
// Get format of wave file
WAVEFORMATEX* pwfx = wav.GetFormat();
// Calculate how many bytes and samples are in the wave
DWORD cbWaveSize = wav.GetSize();
// Read the sample data into memory
BYTE* pbWaveData = new BYTE[ cbWaveSize ];
if( FAILED( hr = wav.Read( pbWaveData, cbWaveSize, &cbWaveSize ) ) )
{
wprintf( L"Failed to read WAV data: %#X\n", hr );
SAFE_DELETE_ARRAY( pbWaveData );
return;
}
//
// Play the wave using a XAudio2SourceVoice
//
// Create the source voice
IXAudio2SourceVoice* pSourceVoice;
if( FAILED( hr = mXAudio2->CreateSourceVoice( &pSourceVoice, pwfx ) ) )
{
wprintf( L"Error %#X creating source voice\n", hr );
SAFE_DELETE_ARRAY( pbWaveData );
return;
}
// Submit the wave sample data using an XAUDIO2_BUFFER structure
XAUDIO2_BUFFER buffer = {0};
buffer.pAudioData = pbWaveData;
buffer.Flags = XAUDIO2_END_OF_STREAM; // tell the source voice not to expect any data after this buffer
buffer.AudioBytes = cbWaveSize;
if( FAILED( hr = pSourceVoice->SubmitSourceBuffer( &buffer ) ) )
{
wprintf( L"Error %#X submitting source buffer\n", hr );
pSourceVoice->DestroyVoice();
SAFE_DELETE_ARRAY( pbWaveData );
return;
}
Sound* pSound = new Sound();
pSound->mVoice = pSourceVoice;
pSound->mAudioBuffer = buffer;
pSound->mData = pbWaveData;
pSound->mStarted = false;
mSounds[soundID] = pSound;
}
void WaveBank::Impl::Play( int index )
{
if ( mStreaming )
{
DebugTrace( "ERROR: One-shots can only be created from an in-memory wave bank\n");
throw std::exception( "WaveBank::Play" );
}
if ( index < 0 || uint32_t(index) >= mReader.Count() )
{
DebugTrace( "WARNING: Index %d not found in wave bank with only %u entries, one-shot not triggered\n", index, mReader.Count() );
return;
}
if ( !mPrepared )
{
mReader.WaitOnPrepare();
mPrepared = true;
}
char wfxbuff[64];
auto wfx = reinterpret_cast<WAVEFORMATEX*>( wfxbuff );
HRESULT hr = mReader.GetFormat( index, wfx, 64 );
ThrowIfFailed( hr );
IXAudio2SourceVoice* voice = nullptr;
mEngine->AllocateVoice( wfx, SoundEffectInstance_Default, true, &voice );
if ( !voice )
return;
hr = voice->Start( 0 );
ThrowIfFailed( hr );
XAUDIO2_BUFFER buffer;
memset( &buffer, 0, sizeof(buffer) );
hr = mReader.GetWaveData( index, &buffer.pAudioData, buffer.AudioBytes );
ThrowIfFailed( hr );
WaveBankReader::Metadata metadata;
hr = mReader.GetMetadata( index, metadata );
ThrowIfFailed( hr );
buffer.Flags = XAUDIO2_END_OF_STREAM;
buffer.pContext = this;
#if defined(_XBOX_ONE) || (_WIN32_WINNT < _WIN32_WINNT_WIN8)
XAUDIO2_BUFFER_WMA wmaBuffer;
memset( &wmaBuffer, 0, sizeof(wmaBuffer) );
uint32_t tag;
hr = mReader.GetSeekTable( index, &wmaBuffer.pDecodedPacketCumulativeBytes, wmaBuffer.PacketCount, tag );
ThrowIfFailed( hr );
if ( tag == WAVE_FORMAT_WMAUDIO2 || tag == WAVE_FORMAT_WMAUDIO3 )
{
hr = voice->SubmitSourceBuffer( &buffer, &wmaBuffer );
}
else
#endif
{
hr = voice->SubmitSourceBuffer( &buffer, nullptr );
}
if ( FAILED(hr) )
{
DebugTrace( "ERROR: WaveBank failed (%08X) when submitting buffer:\n", hr );
DebugTrace( "\tFormat Tag %u, %u channels, %u-bit, %u Hz, %u bytes\n", wfx->wFormatTag,
wfx->nChannels, wfx->wBitsPerSample, wfx->nSamplesPerSec, metadata.lengthBytes );
throw std::exception( "SubmitSourceBuffer" );
}
InterlockedIncrement( &mOneShots );
}
void GameAudio::shutDown()
{
//// ---- destroy sound effects
if (soundEffectRegistrationMap[ENUM_SOUND_EFFECT_SHOOT] == true)
{
IXAudio2SourceVoice* shootSound = soundEffectMap[ENUM_SOUND_EFFECT_SHOOT];
shootSound->DestroyVoice();
XAUDIO2_BUFFER *buffer = audioBufferPrototypeMap[ENUM_SOUND_EFFECT_SHOOT];
delete[] buffer->pAudioData;
delete buffer;
}
if (soundEffectRegistrationMap[ENUM_SOUND_EFFECT_MONEY] == true)
{
IXAudio2SourceVoice* moneySound = soundEffectMap[ENUM_SOUND_EFFECT_MONEY];
moneySound->DestroyVoice();
XAUDIO2_BUFFER *buffer = audioBufferPrototypeMap[ENUM_SOUND_EFFECT_MONEY];
delete[] buffer->pAudioData;
delete buffer;
}
if (soundEffectRegistrationMap[ENUM_SOUND_EFFECT_PUNCH] == true)
{
IXAudio2SourceVoice* punchSound = soundEffectMap[ENUM_SOUND_EFFECT_PUNCH];
punchSound->DestroyVoice();
XAUDIO2_BUFFER *buffer = audioBufferPrototypeMap[ENUM_SOUND_EFFECT_PUNCH];
delete[] buffer->pAudioData;
delete buffer;
}
if (soundEffectRegistrationMap[ENUM_SOUND_EFFECT_HEAL] == true)
{
IXAudio2SourceVoice* healSound = soundEffectMap[ENUM_SOUND_EFFECT_HEAL];
healSound->DestroyVoice();
XAUDIO2_BUFFER *buffer = audioBufferPrototypeMap[ENUM_SOUND_EFFECT_HEAL];
delete[] buffer->pAudioData;
delete buffer;
}
if (soundEffectRegistrationMap[ENUM_SOUND_EFFECT_DAMAGE] == true)
{
IXAudio2SourceVoice* damageSound = soundEffectMap[ENUM_SOUND_EFFECT_DAMAGE];
damageSound->DestroyVoice();
XAUDIO2_BUFFER *buffer = audioBufferPrototypeMap[ENUM_SOUND_EFFECT_DAMAGE];
delete[] buffer->pAudioData;
delete buffer;
}
//// --- destory sound effects complete
//// --- destroy musics
if (musicRegistrationMap[ENUM_MUSIC_MAIN_THEME] == true)
{
IXAudio2SourceVoice* mainTheme = musicMap[ENUM_MUSIC_MAIN_THEME];
mainTheme->DestroyVoice();
XAUDIO2_BUFFER *buffer = musicBufferPrototypeMap[ENUM_MUSIC_MAIN_THEME];
delete[] buffer->pAudioData;
delete buffer;
}
if (musicRegistrationMap[ENUM_MUSIC_LEVEL_COMPLETE] == true)
{
IXAudio2SourceVoice* completeMusic = musicMap[ENUM_MUSIC_LEVEL_COMPLETE];
completeMusic->DestroyVoice();
XAUDIO2_BUFFER *buffer = musicBufferPrototypeMap[ENUM_MUSIC_LEVEL_COMPLETE];
delete[] buffer->pAudioData;
delete buffer;
}
if (musicRegistrationMap[ENUM_MUSIC_INGAME] == true)
{
IXAudio2SourceVoice* ingameMusic = musicMap[ENUM_MUSIC_INGAME];
ingameMusic->DestroyVoice();
XAUDIO2_BUFFER *buffer = musicBufferPrototypeMap[ENUM_MUSIC_INGAME];
delete[] buffer->pAudioData;
delete buffer;
}
if (musicRegistrationMap[ENUM_MUSIC_GAMEOVER] == true)
{
IXAudio2SourceVoice* gameoverMusic = musicMap[ENUM_MUSIC_GAMEOVER];
gameoverMusic->DestroyVoice();
XAUDIO2_BUFFER *buffer = musicBufferPrototypeMap[ENUM_MUSIC_GAMEOVER];
delete[] buffer->pAudioData;
delete buffer;
}
//// --- destroy musics complete
//// --- put other effects' destructors here ------
masterVoice->DestroyVoice();
xAudio2Engine->Release();
CoUninitialize();
}
void GameAudio::processShootSound()
{
if (soundEffectRegistrationMap[ENUM_SOUND_EFFECT_SHOOT] == true)
{
Game *game = Game::getSingleton();
GameStateManager *gsm = game->getGSM();
SpriteManager *spriteMgr = gsm->getSpriteManager();
/*if (moneySoundSignal == true)
{
IXAudio2SourceVoice *moneySound = soundEffectMap[ENUM_SOUND_EFFECT_MONEY];
XAUDIO2_VOICE_STATE voiceState;
moneySound->GetState(&voiceState);
XAUDIO2_BUFFER *proto = audioBufferPrototypeMap[ENUM_SOUND_EFFECT_MONEY];
bool ssbSuccess = SUCCEEDED(moneySound->SubmitSourceBuffer(proto));
moneySound->Start();
moneySoundSignal = false;
}
*/
if (shootSoundSignal == true)
{
IXAudio2SourceVoice *shootSound = soundEffectMap[ENUM_SOUND_EFFECT_SHOOT];
XAUDIO2_VOICE_STATE voiceState;
shootSound->GetState(&voiceState);
XAUDIO2_BUFFER *proto = audioBufferPrototypeMap[ENUM_SOUND_EFFECT_SHOOT];
bool ssbSuccess = SUCCEEDED(shootSound->SubmitSourceBuffer(proto));
shootSound->Start();
shootSoundSignal = false;
}
/*
list<Bot*>::iterator botIt = spriteMgr->getBotsIterator();
list<Bot*>::iterator endBotIt = spriteMgr->getEndOfBotsIterator();
while (botIt != endBotIt)
{
Bot *bot = (*botIt);
wstring botCurState = bot->getCurrentState();
if (botCurState.compare(L"SHOOT_LEFT") == 0 || botCurState.compare(L"SHOOT_RIGHT") == 0
|| botCurState.compare(L"SHOOT_BACK") == 0 || botCurState.compare(L"SHOOT_FRONT") == 0)
{
IXAudio2SourceVoice *shootSound = soundEffectMap[ENUM_SOUND_EFFECT_SHOOT];
XAUDIO2_VOICE_STATE voiceState;
shootSound->GetState(&voiceState);
if (voiceState.BuffersQueued <= 0)
{
XAUDIO2_BUFFER *proto = audioBufferPrototypeMap[ENUM_SOUND_EFFECT_SHOOT];
bool ssbSuccess = SUCCEEDED(shootSound->SubmitSourceBuffer(proto));
shootSound->Start();
}
}
botIt++;
}
PlayerSprite *player = spriteMgr->getPlayer();
wstring playerState = player->getCurrentState();
if (playerState.compare(L"SHOOT_LEFT") == 0 || playerState.compare(L"SHOOT_RIGHT") == 0
|| playerState.compare(L"SHOOT_BACK") == 0 || playerState.compare(L"SHOOT_FRONT") == 0)
{
IXAudio2SourceVoice *shootSound = soundEffectMap[ENUM_SOUND_EFFECT_SHOOT];
XAUDIO2_VOICE_STATE voiceState;
shootSound->GetState(&voiceState);
//// [voiceState.BuffersQueued <= 0] means there are nothing in the buffer
//// so let's make a new buffer to queue the sound
if (voiceState.BuffersQueued <= 0)
{
XAUDIO2_BUFFER *proto = audioBufferPrototypeMap[ENUM_SOUND_EFFECT_SHOOT];
bool ssbSuccess = SUCCEEDED(shootSound->SubmitSourceBuffer(proto));
shootSound->Start();
}
//// if there is something in the buffer
else
{
/// do nothing
}
}
*/
}
}
