WINTERMUTE: Rename FuncName->funcName in the sound-classes.

15 files changed, 178 insertions, 178 deletions

diff --git a/engines/wintermute/Ad/AdActor.cpp b/engines/wintermute/Ad/AdActor.cpp
index bfd344531c..b2686245a6 100644
--- a/engines/wintermute/Ad/AdActor.cpp
+++ b/engines/wintermute/Ad/AdActor.cpp
@@ -684,7 +684,7 @@ HRESULT CAdActor::update() {
 		_sentence->update(_dir);

 		if (_sentence->_currentSprite) _tempSprite2 = _sentence->_currentSprite;

 

-		bool TimeIsUp = (_sentence->_sound && _sentence->_soundStarted && (!_sentence->_sound->IsPlaying() && !_sentence->_sound->IsPaused())) || (!_sentence->_sound && _sentence->_duration <= Game->_timer - _sentence->_startTime);

+		bool TimeIsUp = (_sentence->_sound && _sentence->_soundStarted && (!_sentence->_sound->isPlaying() && !_sentence->_sound->isPaused())) || (!_sentence->_sound && _sentence->_duration <= Game->_timer - _sentence->_startTime);

 		if (_tempSprite2 == NULL || _tempSprite2->_finished || (/*_tempSprite2->_looping &&*/ TimeIsUp)) {

 			if (TimeIsUp) {

 				_sentence->Finish();

diff --git a/engines/wintermute/Ad/AdEntity.cpp b/engines/wintermute/Ad/AdEntity.cpp
index 9e7fb28f2a..64a9531678 100644
--- a/engines/wintermute/Ad/AdEntity.cpp
+++ b/engines/wintermute/Ad/AdEntity.cpp
@@ -565,7 +565,7 @@ HRESULT CAdEntity::update() {
 		_sentence->update();

 		if (_sentence->_currentSprite) _tempSprite2 = _sentence->_currentSprite;

 

-		bool TimeIsUp = (_sentence->_sound && _sentence->_soundStarted && (!_sentence->_sound->IsPlaying() && !_sentence->_sound->IsPaused())) || (!_sentence->_sound && _sentence->_duration <= Game->_timer - _sentence->_startTime);

+		bool TimeIsUp = (_sentence->_sound && _sentence->_soundStarted && (!_sentence->_sound->isPlaying() && !_sentence->_sound->isPaused())) || (!_sentence->_sound && _sentence->_duration <= Game->_timer - _sentence->_startTime);

 		if (_tempSprite2 == NULL || _tempSprite2->_finished || (/*_tempSprite2->_looping &&*/ TimeIsUp)) {

 			if (TimeIsUp) {

 				_sentence->Finish();

diff --git a/engines/wintermute/Ad/AdGame.cpp b/engines/wintermute/Ad/AdGame.cpp
index c16c1dac28..2d1a24c600 100644
--- a/engines/wintermute/Ad/AdGame.cpp
+++ b/engines/wintermute/Ad/AdGame.cpp
@@ -307,7 +307,7 @@ void CAdGame::FinishSentences() {
 	for (int i = 0; i < _sentences.GetSize(); i++) {

 		if (_sentences[i]->CanSkip()) {

 			_sentences[i]->_duration = 0;

-			if (_sentences[i]->_sound) _sentences[i]->_sound->Stop();

+			if (_sentences[i]->_sound) _sentences[i]->_sound->stop();

 		}

 	}

 }

diff --git a/engines/wintermute/Ad/AdItem.cpp b/engines/wintermute/Ad/AdItem.cpp
index ca001b3eb7..2885623454 100644
--- a/engines/wintermute/Ad/AdItem.cpp
+++ b/engines/wintermute/Ad/AdItem.cpp
@@ -357,7 +357,7 @@ HRESULT CAdItem::update() {
 		_sentence->update();

 		if (_sentence->_currentSprite) _tempSprite2 = _sentence->_currentSprite;

 

-		bool TimeIsUp = (_sentence->_sound && _sentence->_soundStarted && (!_sentence->_sound->IsPlaying() && !_sentence->_sound->IsPaused())) || (!_sentence->_sound && _sentence->_duration <= Game->_timer - _sentence->_startTime);

+		bool TimeIsUp = (_sentence->_sound && _sentence->_soundStarted && (!_sentence->_sound->isPlaying() && !_sentence->_sound->isPaused())) || (!_sentence->_sound && _sentence->_duration <= Game->_timer - _sentence->_startTime);

 		if (_tempSprite2 == NULL || _tempSprite2->_finished || (/*_tempSprite2->_looping &&*/ TimeIsUp)) {

 			if (TimeIsUp) {

 				_sentence->Finish();

diff --git a/engines/wintermute/Ad/AdObject.cpp b/engines/wintermute/Ad/AdObject.cpp
index ca6880557e..6cd37ee040 100644
--- a/engines/wintermute/Ad/AdObject.cpp
+++ b/engines/wintermute/Ad/AdObject.cpp
@@ -862,10 +862,10 @@ void CAdObject::Talk(const char *Text, const char *Sound, uint32 Duration, const
 	// load sound and set duration appropriately

 	if (Sound) {

 		CBSound *snd = new CBSound(Game);

-		if (snd && SUCCEEDED(snd->SetSound(Sound, SOUND_SPEECH, true))) {

+		if (snd && SUCCEEDED(snd->setSound(Sound, SOUND_SPEECH, true))) {

 			_sentence->SetSound(snd);

 			if (_sentence->_duration <= 0) {

-				uint32 Length = snd->GetLength();

+				uint32 Length = snd->getLength();

 				if (Length != 0) _sentence->_duration = Length;

 			}

 		} else delete snd;

@@ -1009,7 +1009,7 @@ HRESULT CAdObject::updateSounds() {
 //////////////////////////////////////////////////////////////////////////

 HRESULT CAdObject::resetSoundPan() {

 	if (_sentence && _sentence->_sound) {

-		_sentence->_sound->SetPan(0.0f);

+		_sentence->_sound->setPan(0.0f);

 	}

 	return CBObject::resetSoundPan();

 }

diff --git a/engines/wintermute/Ad/AdSentence.cpp b/engines/wintermute/Ad/AdSentence.cpp
index a753f13a67..feaeec714d 100644
--- a/engines/wintermute/Ad/AdSentence.cpp
+++ b/engines/wintermute/Ad/AdSentence.cpp
@@ -169,7 +169,7 @@ HRESULT CAdSentence::display() {
 	if (!_font || !_text) return E_FAIL;

 

 	if (_sound && !_soundStarted) {

-		_sound->Play();

+		_sound->play();

 		_soundStarted = true;

 	}

 

@@ -205,7 +205,7 @@ void CAdSentence::SetSound(CBSound *Sound) {
 

 //////////////////////////////////////////////////////////////////////////

 HRESULT CAdSentence::Finish() {

-	if (_sound) _sound->Stop();

+	if (_sound) _sound->stop();

 	return S_OK;

 }

 

diff --git a/engines/wintermute/Base/BFrame.cpp b/engines/wintermute/Base/BFrame.cpp
index 7acc45e3ba..95b81feb51 100644
--- a/engines/wintermute/Base/BFrame.cpp
+++ b/engines/wintermute/Base/BFrame.cpp
@@ -91,7 +91,7 @@ HRESULT CBFrame::Draw(int X, int Y, CBObject *Register, float ZoomX, float ZoomY
 HRESULT CBFrame::OneTimeDisplay(CBObject *Owner, bool Muted) {

 	if (_sound && !Muted) {

 		if (Owner) Owner->updateOneSound(_sound);

-		_sound->Play();

+		_sound->play();

 		/*

 		if (Game->_state == GAME_FROZEN) {

 		    _sound->Pause(true);

@@ -252,7 +252,7 @@ HRESULT CBFrame::LoadBuffer(byte  *Buffer, int LifeTime, bool KeepLoaded) {
 				_sound = NULL;

 			}

 			_sound = new CBSound(Game);

-			if (!_sound || FAILED(_sound->SetSound(params, SOUND_SFX, false))) {

+			if (!_sound || FAILED(_sound->setSound(params, SOUND_SFX, false))) {

 				if (Game->_soundMgr->_soundAvailable) Game->LOG(0, "Error loading sound '%s'.", params);

 				delete _sound;

 				_sound = NULL;

@@ -425,7 +425,7 @@ HRESULT CBFrame::scCallMethod(CScScript *Script, CScStack *Stack, CScStack *This
 

 		if (!Val->IsNULL()) {

 			_sound = new CBSound(Game);

-			if (!_sound || FAILED(_sound->SetSound(Val->GetString(), SOUND_SFX, false))) {

+			if (!_sound || FAILED(_sound->setSound(Val->GetString(), SOUND_SFX, false))) {

 				Stack->PushBool(false);

 				delete _sound;

 				_sound = NULL;

diff --git a/engines/wintermute/Base/BGame.cpp b/engines/wintermute/Base/BGame.cpp
index 62197ec430..08f0ddecfa 100644
--- a/engines/wintermute/Base/BGame.cpp
+++ b/engines/wintermute/Base/BGame.cpp
@@ -1235,7 +1235,7 @@ HRESULT CBGame::scCallMethod(CScScript *Script, CScStack *Stack, CScStack *ThisS
 		}

 

 		if (Channel < 0 || Channel >= NUM_MUSIC_CHANNELS || !_music[Channel]) Stack->PushInt(0);

-		else Stack->PushInt(_music[Channel]->GetPositionTime());

+		else Stack->PushInt(_music[Channel]->getPositionTime());

 		return S_OK;

 	}

 

@@ -1251,7 +1251,7 @@ HRESULT CBGame::scCallMethod(CScScript *Script, CScStack *Stack, CScStack *ThisS
 		}

 

 		if (Channel < 0 || Channel >= NUM_MUSIC_CHANNELS || !_music[Channel]) Stack->PushBool(false);

-		else Stack->PushBool(_music[Channel]->IsPlaying());

+		else Stack->PushBool(_music[Channel]->isPlaying());

 		return S_OK;

 	}

 

@@ -1269,7 +1269,7 @@ HRESULT CBGame::scCallMethod(CScScript *Script, CScStack *Stack, CScStack *ThisS
 		int Volume = Stack->Pop()->GetInt();

 		if (Channel < 0 || Channel >= NUM_MUSIC_CHANNELS || !_music[Channel]) Stack->PushBool(false);

 		else {

-			if (FAILED(_music[Channel]->SetVolume(Volume))) Stack->PushBool(false);

+			if (FAILED(_music[Channel]->setVolume(Volume))) Stack->PushBool(false);

 			else Stack->PushBool(true);

 		}

 		return S_OK;

@@ -1287,7 +1287,7 @@ HRESULT CBGame::scCallMethod(CScScript *Script, CScStack *Stack, CScStack *ThisS
 		}

 

 		if (Channel < 0 || Channel >= NUM_MUSIC_CHANNELS || !_music[Channel]) Stack->PushInt(0);

-		else Stack->PushInt(_music[Channel]->GetVolume());

+		else Stack->PushInt(_music[Channel]->getVolume());

 

 		return S_OK;

 	}

@@ -1330,8 +1330,8 @@ HRESULT CBGame::scCallMethod(CScScript *Script, CScStack *Stack, CScStack *ThisS
 		const char *Filename = Stack->Pop()->GetString();

 

 		CBSound *Sound = new CBSound(Game);

-		if (Sound && SUCCEEDED(Sound->SetSound(Filename, SOUND_MUSIC, true))) {

-			Length = Sound->GetLength();

+		if (Sound && SUCCEEDED(Sound->setSound(Filename, SOUND_MUSIC, true))) {

+			Length = Sound->getLength();

 			delete Sound;

 			Sound = NULL;

 		}

@@ -3369,7 +3369,7 @@ void CBGame::AfterLoadSubFrame(void *Subframe, void *Data) {
 

 //////////////////////////////////////////////////////////////////////////

 void CBGame::AfterLoadSound(void *Sound, void *Data) {

-	((CBSound *)Sound)->SetSoundSimple();

+	((CBSound *)Sound)->setSoundSimple();

 }

 

 //////////////////////////////////////////////////////////////////////////

@@ -3424,13 +3424,13 @@ HRESULT CBGame::PlayMusic(int Channel, const char *Filename, bool Looping, uint3
 	_music[Channel] = NULL;

 

 	_music[Channel] = new CBSound(Game);

-	if (_music[Channel] && SUCCEEDED(_music[Channel]->SetSound(Filename, SOUND_MUSIC, true))) {

+	if (_music[Channel] && SUCCEEDED(_music[Channel]->setSound(Filename, SOUND_MUSIC, true))) {

 		if (_musicStartTime[Channel]) {

-			_music[Channel]->SetPositionTime(_musicStartTime[Channel]);

+			_music[Channel]->setPositionTime(_musicStartTime[Channel]);

 			_musicStartTime[Channel] = 0;

 		}

-		if (LoopStart) _music[Channel]->SetLoopStart(LoopStart);

-		return _music[Channel]->Play(Looping);

+		if (LoopStart) _music[Channel]->setLoopStart(LoopStart);

+		return _music[Channel]->play(Looping);

 	} else {

 		delete _music[Channel];

 		_music[Channel] = NULL;

@@ -3447,7 +3447,7 @@ HRESULT CBGame::StopMusic(int Channel) {
 	}

 

 	if (_music[Channel]) {

-		_music[Channel]->Stop();

+		_music[Channel]->stop();

 		delete _music[Channel];

 		_music[Channel] = NULL;

 		return S_OK;

@@ -3462,7 +3462,7 @@ HRESULT CBGame::PauseMusic(int Channel) {
 		return E_FAIL;

 	}

 

-	if (_music[Channel]) return _music[Channel]->Pause();

+	if (_music[Channel]) return _music[Channel]->pause();

 	else return E_FAIL;

 }

 

@@ -3474,7 +3474,7 @@ HRESULT CBGame::ResumeMusic(int Channel) {
 		return E_FAIL;

 	}

 

-	if (_music[Channel]) return _music[Channel]->Resume();

+	if (_music[Channel]) return _music[Channel]->resume();

 	else return E_FAIL;

 }

 

@@ -3488,7 +3488,7 @@ HRESULT CBGame::SetMusicStartTime(int Channel, uint32 Time) {
 	}

 

 	_musicStartTime[Channel] = Time;

-	if (_music[Channel] && _music[Channel]->IsPlaying()) return _music[Channel]->SetPositionTime(Time);

+	if (_music[Channel] && _music[Channel]->isPlaying()) return _music[Channel]->setPositionTime(Time);

 	else return S_OK;

 }

 

@@ -4123,19 +4123,19 @@ HRESULT CBGame::UpdateMusicCrossfade() {
 		return S_OK;

 	}

 

-	if (!_music[_musicCrossfadeChannel1]->IsPlaying()) _music[_musicCrossfadeChannel1]->Play();

-	if (!_music[_musicCrossfadeChannel2]->IsPlaying()) _music[_musicCrossfadeChannel2]->Play();

+	if (!_music[_musicCrossfadeChannel1]->isPlaying()) _music[_musicCrossfadeChannel1]->play();

+	if (!_music[_musicCrossfadeChannel2]->isPlaying()) _music[_musicCrossfadeChannel2]->play();

 

 	uint32 CurrentTime = Game->_liveTimer - _musicCrossfadeStartTime;

 

 	if (CurrentTime >= _musicCrossfadeLength) {

 		_musicCrossfadeRunning = false;

-		//_music[_musicCrossfadeChannel2]->SetVolume(GlobMusicVol);

-		_music[_musicCrossfadeChannel2]->SetVolume(100);

+		//_music[_musicCrossfadeChannel2]->setVolume(GlobMusicVol);

+		_music[_musicCrossfadeChannel2]->setVolume(100);

 

-		_music[_musicCrossfadeChannel1]->Stop();

-		//_music[_musicCrossfadeChannel1]->SetVolume(GlobMusicVol);

-		_music[_musicCrossfadeChannel1]->SetVolume(100);

+		_music[_musicCrossfadeChannel1]->stop();

+		//_music[_musicCrossfadeChannel1]->setVolume(GlobMusicVol);

+		_music[_musicCrossfadeChannel1]->setVolume(100);

 

 

 		if (_musicCrossfadeSwap) {

@@ -4150,10 +4150,10 @@ HRESULT CBGame::UpdateMusicCrossfade() {
 			_musicStartTime[_musicCrossfadeChannel2] = DummyInt;

 		}

 	} else {

-		//_music[_musicCrossfadeChannel1]->SetVolume(GlobMusicVol - (float)CurrentTime / (float)_musicCrossfadeLength * GlobMusicVol);

-		//_music[_musicCrossfadeChannel2]->SetVolume((float)CurrentTime / (float)_musicCrossfadeLength * GlobMusicVol);

-		_music[_musicCrossfadeChannel1]->SetVolume(100 - (float)CurrentTime / (float)_musicCrossfadeLength * 100);

-		_music[_musicCrossfadeChannel2]->SetVolume((float)CurrentTime / (float)_musicCrossfadeLength * 100);

+		//_music[_musicCrossfadeChannel1]->setVolume(GlobMusicVol - (float)CurrentTime / (float)_musicCrossfadeLength * GlobMusicVol);

+		//_music[_musicCrossfadeChannel2]->setVolume((float)CurrentTime / (float)_musicCrossfadeLength * GlobMusicVol);

+		_music[_musicCrossfadeChannel1]->setVolume(100 - (float)CurrentTime / (float)_musicCrossfadeLength * 100);

+		_music[_musicCrossfadeChannel2]->setVolume((float)CurrentTime / (float)_musicCrossfadeLength * 100);

 

 		//Game->QuickMessageForm("%d %d", _music[_musicCrossfadeChannel1]->GetVolume(), _music[_musicCrossfadeChannel2]->GetVolume());

 	}

diff --git a/engines/wintermute/Base/BObject.cpp b/engines/wintermute/Base/BObject.cpp
index 156575b2b5..d117fe3455 100644
--- a/engines/wintermute/Base/BObject.cpp
+++ b/engines/wintermute/Base/BObject.cpp
@@ -371,7 +371,7 @@ HRESULT CBObject::scCallMethod(CScScript *Script, CScStack *Stack, CScStack *Thi
 	else if (strcmp(Name, "IsSoundPlaying") == 0) {

 		Stack->CorrectParams(0);

 

-		if (_sFX && _sFX->IsPlaying()) Stack->PushBool(true);

+		if (_sFX && _sFX->isPlaying()) Stack->PushBool(true);

 		else Stack->PushBool(false);

 		return S_OK;

 	}

@@ -395,7 +395,7 @@ HRESULT CBObject::scCallMethod(CScScript *Script, CScStack *Stack, CScStack *Thi
 		Stack->CorrectParams(0);

 

 		if (!_sFX) Stack->PushInt(0);

-		else Stack->PushInt(_sFX->GetPositionTime());

+		else Stack->PushInt(_sFX->getPositionTime());

 		return S_OK;

 	}

 

@@ -418,7 +418,7 @@ HRESULT CBObject::scCallMethod(CScScript *Script, CScStack *Stack, CScStack *Thi
 		Stack->CorrectParams(0);

 

 		if (!_sFX) Stack->PushInt(_sFXVolume);

-		else Stack->PushInt(_sFX->GetVolume());

+		else Stack->PushInt(_sFX->getVolume());

 		return S_OK;

 	}

 

@@ -976,14 +976,14 @@ HRESULT CBObject::playSFX(const char *filename, bool looping, bool playNow, cons
 	// just play loaded sound

 	if (filename == NULL && _sFX) {

 		if (Game->_editorMode || _sFXStart) {

-			_sFX->SetVolume(_sFXVolume);

-			_sFX->SetPositionTime(_sFXStart);

+			_sFX->setVolume(_sFXVolume);

+			_sFX->setPositionTime(_sFXStart);

 			if (!Game->_editorMode) _sFXStart = 0;

 		}

 		if (playNow) {

 			setSoundEvent(eventName);

-			if (loopStart) _sFX->SetLoopStart(loopStart);

-			return _sFX->Play(looping);

+			if (loopStart) _sFX->setLoopStart(loopStart);

+			return _sFX->play(looping);

 		} else return S_OK;

 	}

 

@@ -993,17 +993,17 @@ HRESULT CBObject::playSFX(const char *filename, bool looping, bool playNow, cons
 	delete _sFX;

 

 	_sFX = new CBSound(Game);

-	if (_sFX && SUCCEEDED(_sFX->SetSound(filename, SOUND_SFX, true))) {

-		_sFX->SetVolume(_sFXVolume);

+	if (_sFX && SUCCEEDED(_sFX->setSound(filename, SOUND_SFX, true))) {

+		_sFX->setVolume(_sFXVolume);

 		if (_sFXStart) {

-			_sFX->SetPositionTime(_sFXStart);

+			_sFX->setPositionTime(_sFXStart);

 			_sFXStart = 0;

 		}

 		_sFX->ApplyFX(_sFXType, _sFXParam1, _sFXParam2, _sFXParam3, _sFXParam4);

 		if (playNow) {

 			setSoundEvent(eventName);

-			if (loopStart) _sFX->SetLoopStart(loopStart);

-			return _sFX->Play(looping);

+			if (loopStart) _sFX->setLoopStart(loopStart);

+			return _sFX->play(looping);

 		} else return S_OK;

 	} else {

 		delete _sFX;

@@ -1016,7 +1016,7 @@ HRESULT CBObject::playSFX(const char *filename, bool looping, bool playNow, cons
 //////////////////////////////////////////////////////////////////////////

 HRESULT CBObject::stopSFX(bool deleteSound) {

 	if (_sFX) {

-		_sFX->Stop();

+		_sFX->stop();

 		if (deleteSound) {

 			delete _sFX;

 			_sFX = NULL;

@@ -1028,14 +1028,14 @@ HRESULT CBObject::stopSFX(bool deleteSound) {
 

 //////////////////////////////////////////////////////////////////////////

 HRESULT CBObject::pauseSFX() {

-	if (_sFX) return _sFX->Pause();

+	if (_sFX) return _sFX->pause();

 	else return E_FAIL;

 }

 

 

 //////////////////////////////////////////////////////////////////////////

 HRESULT CBObject::resumeSFX() {

-	if (_sFX) return _sFX->Resume();

+	if (_sFX) return _sFX->resume();

 	else return E_FAIL;

 }

 

@@ -1043,7 +1043,7 @@ HRESULT CBObject::resumeSFX() {
 //////////////////////////////////////////////////////////////////////////

 HRESULT CBObject::setSFXTime(uint32 time) {

 	_sFXStart = time;

-	if (_sFX && _sFX->IsPlaying()) return _sFX->SetPositionTime(time);

+	if (_sFX && _sFX->isPlaying()) return _sFX->setPositionTime(time);

 	else return S_OK;

 }

 

@@ -1051,7 +1051,7 @@ HRESULT CBObject::setSFXTime(uint32 time) {
 //////////////////////////////////////////////////////////////////////////

 HRESULT CBObject::setSFXVolume(int Volume) {

 	_sFXVolume = Volume;

-	if (_sFX) return _sFX->SetVolume(Volume);

+	if (_sFX) return _sFX->setVolume(Volume);

 	else return S_OK;

 }

 

@@ -1059,7 +1059,7 @@ HRESULT CBObject::setSFXVolume(int Volume) {
 //////////////////////////////////////////////////////////////////////////

 HRESULT CBObject::updateSounds() {

 	if (_soundEvent) {

-		if (_sFX && !_sFX->IsPlaying()) {

+		if (_sFX && !_sFX->isPlaying()) {

 			applyEvent(_soundEvent);

 			setSoundEvent(NULL);

 		}

@@ -1076,7 +1076,7 @@ HRESULT CBObject::updateOneSound(CBSound *sound) {
 

 	if (sound) {

 		if (_autoSoundPanning)

-			Ret = sound->SetPan(Game->_soundMgr->posToPan(_posX  - Game->_offsetX, _posY - Game->_offsetY));

+			Ret = sound->setPan(Game->_soundMgr->posToPan(_posX  - Game->_offsetX, _posY - Game->_offsetY));

 

 		Ret = sound->ApplyFX(_sFXType, _sFXParam1, _sFXParam2, _sFXParam3, _sFXParam4);

 	}

@@ -1087,7 +1087,7 @@ HRESULT CBObject::updateOneSound(CBSound *sound) {
 HRESULT CBObject::resetSoundPan() {

 	if (!_sFX) return S_OK;

 	else {

-		return _sFX->SetPan(0.0f);

+		return _sFX->setPan(0.0f);

 	}

 }

 

diff --git a/engines/wintermute/Base/BSound.cpp b/engines/wintermute/Base/BSound.cpp
index 477c44dba3..e6ba15ee3a 100644
--- a/engines/wintermute/Base/BSound.cpp
+++ b/engines/wintermute/Base/BSound.cpp
@@ -65,7 +65,7 @@ CBSound::~CBSound() {
 

 

 //////////////////////////////////////////////////////////////////////////

-HRESULT CBSound::SetSound(const char *Filename, TSoundType Type, bool Streamed) {

+HRESULT CBSound::setSound(const char *filename, TSoundType type, bool streamed) {

 	if (_sound) {

 		Game->_soundMgr->removeSound(_sound);

 		_sound = NULL;

@@ -73,13 +73,13 @@ HRESULT CBSound::SetSound(const char *Filename, TSoundType Type, bool Streamed)
 	delete[] _soundFilename;

 	_soundFilename = NULL;

 

-	_sound = Game->_soundMgr->addSound(Filename, Type, Streamed);

+	_sound = Game->_soundMgr->addSound(filename, type, streamed);

 	if (_sound) {

-		_soundFilename = new char[strlen(Filename) + 1];

-		strcpy(_soundFilename, Filename);

+		_soundFilename = new char[strlen(filename) + 1];

+		strcpy(_soundFilename, filename);

 

-		_soundType = Type;

-		_soundStreamed = Streamed;

+		_soundType = type;

+		_soundStreamed = streamed;

 

 		return S_OK;

 	} else return E_FAIL;

@@ -87,15 +87,15 @@ HRESULT CBSound::SetSound(const char *Filename, TSoundType Type, bool Streamed)
 

 

 //////////////////////////////////////////////////////////////////////////

-HRESULT CBSound::SetSoundSimple() {

+HRESULT CBSound::setSoundSimple() {

 	_sound = Game->_soundMgr->addSound(_soundFilename, _soundType, _soundStreamed);

 	if (_sound) {

-		if (_soundPosition) _sound->SetPosition(_soundPosition);

-		_sound->SetLooping(_soundLooping);

-		_sound->SetPrivateVolume(_soundPrivateVolume);

-		_sound->SetLoopStart(_soundLoopStart);

+		if (_soundPosition) _sound->setPosition(_soundPosition);

+		_sound->setLooping(_soundLooping);

+		_sound->setPrivateVolume(_soundPrivateVolume);

+		_sound->setLoopStart(_soundLoopStart);

 		_sound->_freezePaused = _soundFreezePaused;

-		if (_soundPlaying) return _sound->Resume();

+		if (_soundPlaying) return _sound->resume();

 		else return S_OK;

 	} else return E_FAIL;

 }

@@ -103,45 +103,45 @@ HRESULT CBSound::SetSoundSimple() {
 

 

 //////////////////////////////////////////////////////////////////////////

-uint32 CBSound::GetLength() {

-	if (_sound) return _sound->GetLength();

+uint32 CBSound::getLength() {

+	if (_sound) return _sound->getLength();

 	else return 0;

 }

 

 

 //////////////////////////////////////////////////////////////////////////

-HRESULT CBSound::Play(bool Looping) {

+HRESULT CBSound::play(bool looping) {

 	if (_sound) {

 		_soundPaused = false;

-		return _sound->Play(Looping, _soundPosition);

+		return _sound->play(looping, _soundPosition);

 	} else return E_FAIL;

 }

 

 

 //////////////////////////////////////////////////////////////////////////

-HRESULT CBSound::Stop() {

+HRESULT CBSound::stop() {

 	if (_sound) {

 		_soundPaused = false;

-		return _sound->Stop();

+		return _sound->stop();

 	} else return E_FAIL;

 }

 

 

 //////////////////////////////////////////////////////////////////////////

-HRESULT CBSound::Pause(bool FreezePaused) {

+HRESULT CBSound::pause(bool freezePaused) {

 	if (_sound) {

 		_soundPaused = true;

-		if (FreezePaused) _sound->_freezePaused = true;

-		return _sound->Pause();

+		if (freezePaused) _sound->_freezePaused = true;

+		return _sound->pause();

 	} else return E_FAIL;

 }

 

 

 //////////////////////////////////////////////////////////////////////////

-HRESULT CBSound::Resume() {

+HRESULT CBSound::resume() {

 	if (_sound && _soundPaused) {

 		_soundPaused = false;

-		return _sound->Resume();

+		return _sound->resume();

 	} else return E_FAIL;

 }

 

@@ -149,10 +149,10 @@ HRESULT CBSound::Resume() {
 //////////////////////////////////////////////////////////////////////////

 HRESULT CBSound::persist(CBPersistMgr *persistMgr) {

 	if (persistMgr->_saving && _sound) {

-		_soundPlaying = _sound->IsPlaying();

+		_soundPlaying = _sound->isPlaying();

 		_soundLooping = _sound->_looping;

 		_soundPrivateVolume = _sound->_privateVolume;

-		if (_soundPlaying) _soundPosition = _sound->GetPosition();

+		if (_soundPlaying) _soundPosition = _sound->getPosition();

 		_soundLoopStart = _sound->_loopStart;

 		_soundFreezePaused = _sound->_freezePaused;

 	}

@@ -180,83 +180,83 @@ HRESULT CBSound::persist(CBPersistMgr *persistMgr) {
 

 

 //////////////////////////////////////////////////////////////////////////

-bool CBSound::IsPlaying() {

-	return _sound && _sound->IsPlaying();

+bool CBSound::isPlaying() {

+	return _sound && _sound->isPlaying();

 }

 

 

 //////////////////////////////////////////////////////////////////////////

-bool CBSound::IsPaused() {

+bool CBSound::isPaused() {

 	return _sound && _soundPaused;

 }

 

 

 //////////////////////////////////////////////////////////////////////////

-HRESULT CBSound::SetPositionTime(uint32 Time) {

+HRESULT CBSound::setPositionTime(uint32 time) {

 	if (!_sound) return E_FAIL;

-	_soundPosition = Time;

-	HRESULT ret = _sound->SetPosition(_soundPosition);

-	if (_sound->IsPlaying()) _soundPosition = 0;

+	_soundPosition = time;

+	HRESULT ret = _sound->setPosition(_soundPosition);

+	if (_sound->isPlaying()) _soundPosition = 0;

 	return ret;

 }

 

 

 //////////////////////////////////////////////////////////////////////////

-uint32 CBSound::GetPositionTime() {

+uint32 CBSound::getPositionTime() {

 	if (!_sound) return 0;

 

-	if (!_sound->IsPlaying()) return 0;

-	else return _sound->GetPosition();

+	if (!_sound->isPlaying()) return 0;

+	else return _sound->getPosition();

 }

 

 

 //////////////////////////////////////////////////////////////////////////

-HRESULT CBSound::SetVolume(int Volume) {

+HRESULT CBSound::setVolume(int volume) {

 	if (!_sound) return E_FAIL;

-	else return _sound->SetPrivateVolume(Volume);

+	else return _sound->setPrivateVolume(volume);

 }

 

 //////////////////////////////////////////////////////////////////////////

-HRESULT CBSound::SetPrivateVolume(int Volume) {

+HRESULT CBSound::setPrivateVolume(int volume) {

 	if (!_sound) return E_FAIL;

-	else return _sound->_privateVolume = Volume;

+	else return _sound->_privateVolume = volume;

 }

 

 

 //////////////////////////////////////////////////////////////////////////

-int CBSound::GetVolume() {

+int CBSound::getVolume() {

 	if (!_sound) return 0;

 	else return _sound->_privateVolume;

 }

 

 //////////////////////////////////////////////////////////////////////////

-HRESULT CBSound::SetLoopStart(uint32 Pos) {

+HRESULT CBSound::setLoopStart(uint32 pos) {

 	if (!_sound) return E_FAIL;

 	else {

-		_sound->SetLoopStart(Pos);

+		_sound->setLoopStart(pos);

 		return S_OK;

 	}

 }

 

 //////////////////////////////////////////////////////////////////////////

-HRESULT CBSound::SetPan(float Pan) {

-	if (_sound) return _sound->SetPan(Pan);

+HRESULT CBSound::setPan(float pan) {

+	if (_sound) return _sound->setPan(pan);

 	else return E_FAIL;

 }

 

 

 //////////////////////////////////////////////////////////////////////////

-HRESULT CBSound::ApplyFX(TSFXType Type, float Param1, float Param2, float Param3, float Param4) {

+HRESULT CBSound::ApplyFX(TSFXType type, float param1, float param2, float param3, float param4) {

 	if (!_sound) return S_OK;

 

-	if (Type != _sFXType || Param1 != _sFXParam1 || Param2 != _sFXParam2 || Param3 != _sFXParam3 || Param4 != _sFXParam4) {

-		HRESULT Ret = _sound->ApplyFX(Type, Param1, Param2, Param3, Param4);

+	if (type != _sFXType || param1 != _sFXParam1 || param2 != _sFXParam2 || param3 != _sFXParam3 || param4 != _sFXParam4) {

+		HRESULT Ret = _sound->applyFX(type, param1, param2, param3, param4);

 

-		_sFXType = Type;

-		_sFXParam1 = Param1;

-		_sFXParam2 = Param2;

-		_sFXParam3 = Param3;

-		_sFXParam4 = Param4;

+		_sFXType = type;

+		_sFXParam1 = param1;

+		_sFXParam2 = param2;

+		_sFXParam3 = param3;

+		_sFXParam4 = param4;

 

 		return Ret;

 	}

diff --git a/engines/wintermute/Base/BSound.h b/engines/wintermute/Base/BSound.h
index a9d1a0b5af..4bc3f25c19 100644
--- a/engines/wintermute/Base/BSound.h
+++ b/engines/wintermute/Base/BSound.h
@@ -38,37 +38,37 @@ namespace WinterMute {
 

 class CBSound : public CBBase {

 public:

-	HRESULT SetPan(float Pan);

+	HRESULT setPan(float pan);

 	int _soundPrivateVolume;

-	int GetVolume();

-	HRESULT SetVolume(int Volume);

-	HRESULT SetPrivateVolume(int Volume);

-	HRESULT SetLoopStart(uint32 Pos);

-	uint32 GetPositionTime();

-	HRESULT SetPositionTime(uint32 Time);

+	int getVolume();

+	HRESULT setVolume(int volume);

+	HRESULT setPrivateVolume(int volume);

+	HRESULT setLoopStart(uint32 pos);

+	uint32 getPositionTime();

+	HRESULT setPositionTime(uint32 time);

 	bool _soundPaused;

 	bool _soundFreezePaused;

-	bool IsPlaying();

-	bool IsPaused();

+	bool isPlaying();

+	bool isPaused();

 	bool _soundPlaying;

 	bool _soundLooping;

 	uint32 _soundLoopStart;

 	uint32 _soundPosition;

 	DECLARE_PERSISTENT(CBSound, CBBase)

-	HRESULT Resume();

-	HRESULT Pause(bool FreezePaused = false);

-	HRESULT Stop();

-	HRESULT Play(bool Looping = false);

-	uint32 GetLength();

+	HRESULT resume();

+	HRESULT pause(bool freezePaused = false);

+	HRESULT stop();

+	HRESULT play(bool looping = false);

+	uint32 getLength();

 	bool _soundStreamed;

 	TSoundType _soundType;

 	char *_soundFilename;

-	HRESULT SetSoundSimple();

-	HRESULT SetSound(const char *Filename, TSoundType Type = SOUND_SFX, bool Streamed = false);

+	HRESULT setSoundSimple();

+	HRESULT setSound(const char *filename, TSoundType type = SOUND_SFX, bool streamed = false);

 	CBSound(CBGame *inGame);

 	virtual ~CBSound();

 

-	HRESULT ApplyFX(TSFXType Type = SFX_NONE, float Param1 = 0, float Param2 = 0, float Param3 = 0, float Param4 = 0);

+	HRESULT ApplyFX(TSFXType type = SFX_NONE, float param1 = 0, float param2 = 0, float param3 = 0, float param4 = 0);

 

 private:

 	TSFXType _sFXType;

diff --git a/engines/wintermute/Base/BSoundBuffer.cpp b/engines/wintermute/Base/BSoundBuffer.cpp
index 35471bd4d9..b24bdcfb19 100644
--- a/engines/wintermute/Base/BSoundBuffer.cpp
+++ b/engines/wintermute/Base/BSoundBuffer.cpp
@@ -69,7 +69,7 @@ CBSoundBuffer::CBSoundBuffer(CBGame *inGame): CBBase(inGame) {
 

 //////////////////////////////////////////////////////////////////////////

 CBSoundBuffer::~CBSoundBuffer() {

-	Stop();

+	stop();

 

 	if (_handle) {

 		delete _handle;

@@ -87,13 +87,13 @@ CBSoundBuffer::~CBSoundBuffer() {
 

 

 //////////////////////////////////////////////////////////////////////////

-void CBSoundBuffer::SetStreaming(bool Streamed, uint32 NumBlocks, uint32 BlockSize) {

+void CBSoundBuffer::setStreaming(bool Streamed, uint32 NumBlocks, uint32 BlockSize) {

 	_streamed = Streamed;

 }

 

 

 //////////////////////////////////////////////////////////////////////////

-HRESULT CBSoundBuffer::LoadFromFile(const char *Filename, bool ForceReload) {

+HRESULT CBSoundBuffer::loadFromFile(const char *Filename, bool ForceReload) {

 	warning("BSoundBuffer::LoadFromFile(%s,%d)", Filename, ForceReload);

 #if 0

 	if (_stream) {

@@ -187,7 +187,7 @@ HRESULT CBSoundBuffer::LoadFromFile(const char *Filename, bool ForceReload) {
 

 

 //////////////////////////////////////////////////////////////////////////

-HRESULT CBSoundBuffer::Play(bool looping, uint32 startSample) {

+HRESULT CBSoundBuffer::play(bool looping, uint32 startSample) {

 	if (startSample != 0) {

 		warning("BSoundBuffer::Play - Should start playback at %d, but currently we don't", startSample);

 	}

@@ -203,7 +203,7 @@ HRESULT CBSoundBuffer::Play(bool looping, uint32 startSample) {
 }

 

 //////////////////////////////////////////////////////////////////////////

-void CBSoundBuffer::SetLooping(bool looping) {

+void CBSoundBuffer::setLooping(bool looping) {

 	warning("BSoundBuffer::SetLooping(%d) - not implemented yet", looping);

 #if 0

 	_looping = looping;

@@ -215,7 +215,7 @@ void CBSoundBuffer::SetLooping(bool looping) {
 }

 

 //////////////////////////////////////////////////////////////////////////

-HRESULT CBSoundBuffer::Resume() {

+HRESULT CBSoundBuffer::resume() {

 	if (_stream && _handle) {

 		g_system->getMixer()->pauseHandle(*_handle, false);

 	}

@@ -224,7 +224,7 @@ HRESULT CBSoundBuffer::Resume() {
 

 

 //////////////////////////////////////////////////////////////////////////

-HRESULT CBSoundBuffer::Stop() {

+HRESULT CBSoundBuffer::stop() {

 	if (_stream && _handle) {

 		g_system->getMixer()->stopHandle(*_handle);

 	}

@@ -233,7 +233,7 @@ HRESULT CBSoundBuffer::Stop() {
 

 

 //////////////////////////////////////////////////////////////////////////

-HRESULT CBSoundBuffer::Pause() {

+HRESULT CBSoundBuffer::pause() {

 	if (_stream && _handle) {

 		g_system->getMixer()->pauseHandle(*_handle, true);

 	}

@@ -242,7 +242,7 @@ HRESULT CBSoundBuffer::Pause() {
 }

 

 //////////////////////////////////////////////////////////////////////////

-uint32 CBSoundBuffer::GetLength() {

+uint32 CBSoundBuffer::getLength() {

 	if (_stream) {

 		uint32 len = _stream->getLength().msecs();

 		return len * 1000;

@@ -252,13 +252,13 @@ uint32 CBSoundBuffer::GetLength() {
 

 

 //////////////////////////////////////////////////////////////////////////

-void CBSoundBuffer::SetType(TSoundType Type) {

+void CBSoundBuffer::setType(TSoundType Type) {

 	_type = Type;

 }

 

 

 //////////////////////////////////////////////////////////////////////////

-HRESULT CBSoundBuffer::SetVolume(int Volume) {

+HRESULT CBSoundBuffer::setVolume(int Volume) {

 	if (_stream && _handle) {

 		byte vol = (byte)(Volume / 100.f * Audio::Mixer::kMaxChannelVolume);

 		g_system->getMixer()->setChannelVolume(*_handle, vol);

@@ -268,7 +268,7 @@ HRESULT CBSoundBuffer::SetVolume(int Volume) {
 

 

 //////////////////////////////////////////////////////////////////////////

-HRESULT CBSoundBuffer::SetPrivateVolume(int Volume) {

+HRESULT CBSoundBuffer::setPrivateVolume(int Volume) {

 #if 0

 	_privateVolume = Volume;

 

@@ -284,12 +284,12 @@ HRESULT CBSoundBuffer::SetPrivateVolume(int Volume) {
 		break;

 	}

 #endif

-	return SetVolume(Volume);

+	return setVolume(Volume);

 }

 

 

 //////////////////////////////////////////////////////////////////////////

-bool CBSoundBuffer::IsPlaying() {

+bool CBSoundBuffer::isPlaying() {

 	if (_stream && _handle) {

 		return _freezePaused || g_system->getMixer()->isSoundHandleActive(*_handle);

 	} else {

@@ -299,7 +299,7 @@ bool CBSoundBuffer::IsPlaying() {
 

 

 //////////////////////////////////////////////////////////////////////////

-uint32 CBSoundBuffer::GetPosition() {

+uint32 CBSoundBuffer::getPosition() {

 	if (_stream && _handle) {

 		uint32 pos = g_system->getMixer()->getSoundElapsedTime(*_handle);

 		return pos;

@@ -309,7 +309,7 @@ uint32 CBSoundBuffer::GetPosition() {
 

 

 //////////////////////////////////////////////////////////////////////////

-HRESULT CBSoundBuffer::SetPosition(uint32 Pos) {

+HRESULT CBSoundBuffer::setPosition(uint32 Pos) {

 	warning("CBSoundBuffer::SetPosition - not implemented yet");

 #if 0

 	if (_stream) {

@@ -321,7 +321,7 @@ HRESULT CBSoundBuffer::SetPosition(uint32 Pos) {
 }

 

 //////////////////////////////////////////////////////////////////////////

-HRESULT CBSoundBuffer::SetLoopStart(uint32 Pos) {

+HRESULT CBSoundBuffer::setLoopStart(uint32 Pos) {

 	_loopStart = Pos;

 #if 0

 	if (_stream) {

@@ -348,7 +348,7 @@ void CBSoundBuffer::LoopSyncProc(HSYNC handle, uint32 channel, uint32 data, void
 }

 #endif

 //////////////////////////////////////////////////////////////////////////

-HRESULT CBSoundBuffer::SetPan(float pan) {

+HRESULT CBSoundBuffer::setPan(float pan) {

 	if (_stream) {

 		g_system->getMixer()->setChannelBalance(*_handle, pan * 127);

 	}

@@ -356,7 +356,7 @@ HRESULT CBSoundBuffer::SetPan(float pan) {
 }

 

 //////////////////////////////////////////////////////////////////////////

-HRESULT CBSoundBuffer::ApplyFX(TSFXType Type, float Param1, float Param2, float Param3, float Param4) {

+HRESULT CBSoundBuffer::applyFX(TSFXType Type, float Param1, float Param2, float Param3, float Param4) {

 	warning("CBSoundBuffer::ApplyFX - not implemented yet");

 #if 0

 	switch (Type) {

diff --git a/engines/wintermute/Base/BSoundBuffer.h b/engines/wintermute/Base/BSoundBuffer.h
index 9fa9dec1cf..1e59ef0971 100644
--- a/engines/wintermute/Base/BSoundBuffer.h
+++ b/engines/wintermute/Base/BSoundBuffer.h
@@ -48,32 +48,32 @@ public:
 	virtual ~CBSoundBuffer();

 

 

-	HRESULT Pause();

-	HRESULT Play(bool Looping = false, uint32 StartSample = 0);

-	HRESULT Resume();

-	HRESULT Stop();

-	bool IsPlaying();

+	HRESULT pause();

+	HRESULT play(bool Looping = false, uint32 StartSample = 0);

+	HRESULT resume();

+	HRESULT stop();

+	bool isPlaying();

 

-	void SetLooping(bool looping);

+	void setLooping(bool looping);

 

-	uint32 GetPosition();

-	HRESULT SetPosition(uint32 Pos);

-	uint32 GetLength();

+	uint32 getPosition();

+	HRESULT setPosition(uint32 Pos);

+	uint32 getLength();

 

-	HRESULT SetLoopStart(uint32 Pos);

-	uint32 GetLoopStart() const {

+	HRESULT setLoopStart(uint32 Pos);

+	uint32 getLoopStart() const {

 		return _loopStart;

 	}

 

-	HRESULT SetPan(float Pan);

-	HRESULT SetPrivateVolume(int Volume);

-	HRESULT SetVolume(int Volume);

+	HRESULT setPan(float Pan);

+	HRESULT setPrivateVolume(int Volume);

+	HRESULT setVolume(int Volume);

 

-	void SetType(TSoundType Type);

+	void setType(TSoundType Type);

 

-	HRESULT LoadFromFile(const char *Filename, bool ForceReload = false);

-	void SetStreaming(bool Streamed, uint32 NumBlocks = 0, uint32 BlockSize = 0);

-	HRESULT ApplyFX(TSFXType Type, float Param1, float Param2, float Param3, float Param4);

+	HRESULT loadFromFile(const char *Filename, bool ForceReload = false);

+	void setStreaming(bool Streamed, uint32 NumBlocks = 0, uint32 BlockSize = 0);

+	HRESULT applyFX(TSFXType Type, float Param1, float Param2, float Param3, float Param4);

 

 	//HSTREAM _stream;

 	//HSYNC _sync;

diff --git a/engines/wintermute/Base/BSoundMgr.cpp b/engines/wintermute/Base/BSoundMgr.cpp
index dc9f3e9011..e931d95f2d 100644
--- a/engines/wintermute/Base/BSoundMgr.cpp
+++ b/engines/wintermute/Base/BSoundMgr.cpp
@@ -148,11 +148,11 @@ CBSoundBuffer *CBSoundMgr::addSound(const char *Filename, TSoundType Type, bool
 	sound = new CBSoundBuffer(Game);

 	if (!sound) return NULL;

 

-	sound->SetStreaming(Streamed);

-	sound->SetType(Type);

+	sound->setStreaming(Streamed);

+	sound->setType(Type);

 

 

-	HRESULT res = sound->LoadFromFile(Filename);

+	HRESULT res = sound->loadFromFile(Filename);

 	if (FAILED(res)) {

 		Game->LOG(res, "Error loading sound '%s'", Filename);

 		delete sound;

@@ -162,13 +162,13 @@ CBSoundBuffer *CBSoundMgr::addSound(const char *Filename, TSoundType Type, bool
 	// set volume appropriately

 	switch (Type) {

 	case SOUND_SFX:

-		sound->SetVolume(_volumeSFX);

+		sound->setVolume(_volumeSFX);

 		break;

 	case SOUND_SPEECH:

-		sound->SetVolume(_volumeSpeech);

+		sound->setVolume(_volumeSpeech);

 		break;

 	case SOUND_MUSIC:

-		sound->SetVolume(_volumeMusic);

+		sound->setVolume(_volumeMusic);

 		break;

 	}

 

@@ -187,13 +187,13 @@ HRESULT CBSoundMgr::addSound(CBSoundBuffer *Sound, TSoundType Type) {
 	// set volume appropriately

 	switch (Type) {

 	case SOUND_SFX:

-		Sound->SetVolume(_volumeSFX);

+		Sound->setVolume(_volumeSFX);

 		break;

 	case SOUND_SPEECH:

-		Sound->SetVolume(_volumeSpeech);

+		Sound->setVolume(_volumeSpeech);

 		break;

 	case SOUND_MUSIC:

-		Sound->SetVolume(_volumeMusic);

+		Sound->setVolume(_volumeMusic);

 		break;

 	}

 

@@ -235,7 +235,7 @@ HRESULT CBSoundMgr::setVolume(TSoundType Type, int Volume) {
 	}

 

 	for (int i = 0; i < _sounds.GetSize(); i++) {

-		if (_sounds[i]->_type == Type) _sounds[i]->SetVolume(Volume);

+		if (_sounds[i]->_type == Type) _sounds[i]->setVolume(Volume);

 	}

 

 	return S_OK;

@@ -291,8 +291,8 @@ byte CBSoundMgr::getMasterVolumePercent() {
 HRESULT CBSoundMgr::pauseAll(bool IncludingMusic) {

 

 	for (int i = 0; i < _sounds.GetSize(); i++) {

-		if (_sounds[i]->IsPlaying() && (_sounds[i]->_type != SOUND_MUSIC || IncludingMusic)) {

-			_sounds[i]->Pause();

+		if (_sounds[i]->isPlaying() && (_sounds[i]->_type != SOUND_MUSIC || IncludingMusic)) {

+			_sounds[i]->pause();

 			_sounds[i]->_freezePaused = true;

 		}

 	}

@@ -306,7 +306,7 @@ HRESULT CBSoundMgr::resumeAll() {
 

 	for (int i = 0; i < _sounds.GetSize(); i++) {

 		if (_sounds[i]->_freezePaused) {

-			_sounds[i]->Resume();

+			_sounds[i]->resume();

 			_sounds[i]->_freezePaused = false;

 		}

 	}

diff --git a/engines/wintermute/Base/BSprite.cpp b/engines/wintermute/Base/BSprite.cpp
index e7f9df194d..5b22c36db2 100644
--- a/engines/wintermute/Base/BSprite.cpp
+++ b/engines/wintermute/Base/BSprite.cpp
@@ -746,7 +746,7 @@ const char *CBSprite::scToString() {
 //////////////////////////////////////////////////////////////////////////

 HRESULT CBSprite::KillAllSounds() {

 	for (int i = 0; i < _frames.GetSize(); i++) {

-		if (_frames[i]->_sound) _frames[i]->_sound->Stop();

+		if (_frames[i]->_sound) _frames[i]->_sound->stop();

 	}

 	return S_OK;

 }