TONY: Rename sound functions and class names

7 files changed, 239 insertions, 232 deletions

diff --git a/engines/tony/custom.cpp b/engines/tony/custom.cpp
index 9acdc84932..ef4f889a12 100644
--- a/engines/tony/custom.cpp
+++ b/engines/tony/custom.cpp
@@ -253,7 +253,7 @@ DECLARE_CUSTOM_FUNCTION(SendTonyMessage)(CORO_PARAM, uint32 dwMessage, uint32 nX
 	int i;
 	int curOffset;
 	VoiceHeader *curVoc;
-	FPSFX *voice;
+	FPSfx *voice;
 	RMTextDialog text;
 	CORO_END_CONTEXT(_ctx);
 
@@ -276,12 +276,12 @@ DECLARE_CUSTOM_FUNCTION(SendTonyMessage)(CORO_PARAM, uint32 dwMessage, uint32 nX
 
 		// First time allocation
 		_vm->_vdbFP.seek(_ctx->curOffset);
-		_vm->_theSound.CreateSfx(&_ctx->voice);
+		_vm->_theSound.createSfx(&_ctx->voice);
 
-		_ctx->voice->LoadVoiceFromVDB(_vm->_vdbFP);
+		_ctx->voice->loadVoiceFromVDB(_vm->_vdbFP);
 		_ctx->curOffset = _vm->_vdbFP.pos();
 
-		_ctx->voice->SetLoop(false);
+		_ctx->voice->setLoop(false);
 	}
 
 	if (GLOBALS._nTonyNextTalkType != GLOBALS._tony->TALK_NORMAL) {
@@ -330,16 +330,16 @@ DECLARE_CUSTOM_FUNCTION(SendTonyMessage)(CORO_PARAM, uint32 dwMessage, uint32 nX
 
 		if (_ctx->curVoc) {
 			if (_ctx->i == 0) {
-				_ctx->voice->Play();
+				_ctx->voice->play();
 				_ctx->text.setCustomSkipHandle2(_ctx->voice->hEndOfBuffer);
 			} else {
 				_vm->_vdbFP.seek(_ctx->curOffset);
-				_vm->_theSound.CreateSfx(&_ctx->voice);
-				_ctx->voice->LoadVoiceFromVDB(_vm->_vdbFP);
+				_vm->_theSound.createSfx(&_ctx->voice);
+				_ctx->voice->loadVoiceFromVDB(_vm->_vdbFP);
 
 				_ctx->curOffset = _vm->_vdbFP.pos();
-				_ctx->voice->SetLoop(false);
-				_ctx->voice->Play();
+				_ctx->voice->setLoop(false);
+				_ctx->voice->play();
 				_ctx->text.setCustomSkipHandle2(_ctx->voice->hEndOfBuffer);
 			}
 		}
@@ -349,8 +349,8 @@ DECLARE_CUSTOM_FUNCTION(SendTonyMessage)(CORO_PARAM, uint32 dwMessage, uint32 nX
 		CORO_INVOKE_0(_ctx->text.waitForEndDisplay);
 
 		if (_ctx->curVoc) {
-			_ctx->voice->Stop();
-			_ctx->voice->Release();
+			_ctx->voice->stop();
+			_ctx->voice->release();
 			_ctx->voice = NULL;
 		}
 	}
@@ -1458,7 +1458,7 @@ DECLARE_CUSTOM_FUNCTION(CharSendMessage)(CORO_PARAM, uint32 nChar, uint32 dwMess
 	RMTextDialog *text;
 	int curOffset;
 	VoiceHeader *curVoc;
-	FPSFX *voice;
+	FPSfx *voice;
 	CORO_END_CONTEXT(_ctx);
 
 	CORO_BEGIN_CODE(_ctx);
@@ -1524,12 +1524,12 @@ DECLARE_CUSTOM_FUNCTION(CharSendMessage)(CORO_PARAM, uint32 nChar, uint32 dwMess
 		GLOBALS.LinkGraphicTask(_ctx->text);
 
 		if (_ctx->curVoc) {
-			_vm->_theSound.CreateSfx(&_ctx->voice);
+			_vm->_theSound.createSfx(&_ctx->voice);
 			_vm->_vdbFP.seek(_ctx->curOffset);
-			_ctx->voice->LoadVoiceFromVDB(_vm->_vdbFP);
-			_ctx->voice->SetLoop(false);
-			if (bIsBack) _ctx->voice->SetVolume(55);
-			_ctx->voice->Play();
+			_ctx->voice->loadVoiceFromVDB(_vm->_vdbFP);
+			_ctx->voice->setLoop(false);
+			if (bIsBack) _ctx->voice->setVolume(55);
+			_ctx->voice->play();
 			_ctx->text->setCustomSkipHandle2(_ctx->voice->hEndOfBuffer);
 			_ctx->curOffset = _vm->_vdbFP.pos();
 		}
@@ -1539,8 +1539,8 @@ DECLARE_CUSTOM_FUNCTION(CharSendMessage)(CORO_PARAM, uint32 nChar, uint32 dwMess
 		CORO_INVOKE_0(_ctx->text->waitForEndDisplay);
 
 		if (_ctx->curVoc) {
-			_ctx->voice->Stop();
-			_ctx->voice->Release();
+			_ctx->voice->stop();
+			_ctx->voice->release();
 			_ctx->voice = NULL;
 		}
 
@@ -1662,7 +1662,7 @@ DECLARE_CUSTOM_FUNCTION(MCharSendMessage)(CORO_PARAM, uint32 nChar, uint32 dwMes
 	RMTextDialog *text;
 	int curOffset;
 	VoiceHeader *curVoc;
-	FPSFX *voice;
+	FPSfx *voice;
 	CORO_END_CONTEXT(_ctx);
 
 	CORO_BEGIN_CODE(_ctx);
@@ -1737,12 +1737,13 @@ DECLARE_CUSTOM_FUNCTION(MCharSendMessage)(CORO_PARAM, uint32 nChar, uint32 dwMes
 		GLOBALS.LinkGraphicTask(_ctx->text);
 
 		if (_ctx->curVoc) {
-			_vm->_theSound.CreateSfx(&_ctx->voice);
+			_vm->_theSound.createSfx(&_ctx->voice);
 			_vm->_vdbFP.seek(_ctx->curOffset);
-			_ctx->voice->LoadVoiceFromVDB(_vm->_vdbFP);
-			_ctx->voice->SetLoop(false);
-			if (bIsBack) _ctx->voice->SetVolume(55);
-			_ctx->voice->Play();
+			_ctx->voice->loadVoiceFromVDB(_vm->_vdbFP);
+			_ctx->voice->setLoop(false);
+			if (bIsBack)
+				_ctx->voice->setVolume(55);
+			_ctx->voice->play();
 			_ctx->text->setCustomSkipHandle2(_ctx->voice->hEndOfBuffer);
 			_ctx->curOffset = _vm->_vdbFP.pos();
 		}
@@ -1752,8 +1753,8 @@ DECLARE_CUSTOM_FUNCTION(MCharSendMessage)(CORO_PARAM, uint32 nChar, uint32 dwMes
 		CORO_INVOKE_0(_ctx->text->waitForEndDisplay);
 
 		if (_ctx->curVoc) {
-			_ctx->voice->Stop();
-			_ctx->voice->Release();
+			_ctx->voice->stop();
+			_ctx->voice->release();
 			_ctx->voice = NULL;
 		}
 
@@ -1787,7 +1788,7 @@ DECLARE_CUSTOM_FUNCTION(SendDialogMessage)(CORO_PARAM, uint32 nPers, uint32 nMsg
 	uint32 h;
 	bool bIsBack;
 	VoiceHeader *curVoc;
-	FPSFX *voice;
+	FPSfx *voice;
 	RMPoint pt;
 	CORO_END_CONTEXT(_ctx);
 
@@ -1805,10 +1806,11 @@ DECLARE_CUSTOM_FUNCTION(SendDialogMessage)(CORO_PARAM, uint32 nPers, uint32 nMsg
 	if (_ctx->curVoc) {
 		// Position within the database of entries, beginning at the first
 		_vm->_vdbFP.seek(_ctx->curVoc->_offset);
-		_vm->_theSound.CreateSfx(&_ctx->voice);
-		_ctx->voice->LoadVoiceFromVDB(_vm->_vdbFP);
-		_ctx->voice->SetLoop(false);
-		if (_ctx->bIsBack) _ctx->voice->SetVolume(55);
+		_vm->_theSound.createSfx(&_ctx->voice);
+		_ctx->voice->loadVoiceFromVDB(_vm->_vdbFP);
+		_ctx->voice->setLoop(false);
+		if (_ctx->bIsBack)
+			_ctx->voice->setVolume(55);
 	}
 
 	_ctx->string = mpalQueryDialogPeriod(nMsg);
@@ -1904,7 +1906,7 @@ DECLARE_CUSTOM_FUNCTION(SendDialogMessage)(CORO_PARAM, uint32 nPers, uint32 nMsg
 		GLOBALS.LinkGraphicTask(_ctx->text);
 
 		if (_ctx->curVoc) {
-			_ctx->voice->Play();
+			_ctx->voice->play();
 			_ctx->text->setCustomSkipHandle2(_ctx->voice->hEndOfBuffer);
 		}
 
@@ -1914,8 +1916,8 @@ DECLARE_CUSTOM_FUNCTION(SendDialogMessage)(CORO_PARAM, uint32 nPers, uint32 nMsg
 	}
 
 	if (_ctx->curVoc) {
-		_ctx->voice->Stop();
-		_ctx->voice->Release();
+		_ctx->voice->stop();
+		_ctx->voice->release();
 		_ctx->voice = NULL;
 	}
 
diff --git a/engines/tony/loc.cpp b/engines/tony/loc.cpp
index 42c96076f9..d36c004baf 100644
--- a/engines/tony/loc.cpp
+++ b/engines/tony/loc.cpp
@@ -409,7 +409,7 @@ void RMSfx::readFromStream(RMDataStream &ds, bool bLOX) {
 
 	// Create the sound effect
 	_fx = _vm->createSFX(stream);
-	_fx->SetLoop(false);
+	_fx->setLoop(false);
 }
 
 RMSfx::RMSfx() {
@@ -419,15 +419,15 @@ RMSfx::RMSfx() {
 
 RMSfx::~RMSfx() {
 	if (_fx) {
-		_fx->Release();
+		_fx->release();
 		_fx = NULL;
 	}
 }
 
 void RMSfx::play(bool bLoop) {
 	if (_fx && !_bPlayingLoop) {
-		_fx->SetLoop(bLoop);
-		_fx->Play();
+		_fx->setLoop(bLoop);
+		_fx->play();
 
 		if (bLoop)
 			_bPlayingLoop = true;
@@ -436,19 +436,19 @@ void RMSfx::play(bool bLoop) {
 
 void RMSfx::setVolume(int vol) {
 	if (_fx) {
-		_fx->SetVolume(vol);
+		_fx->setVolume(vol);
 	}
 }
 
 void RMSfx::pause(bool bPause) {
 	if (_fx) {
-		_fx->Pause(bPause);
+		_fx->pause(bPause);
 	}
 }
 
 void RMSfx::stop(void) {
 	if (_fx) {
-		_fx->Stop();
+		_fx->stop();
 		_bPlayingLoop = false;
 	}
 }
diff --git a/engines/tony/loc.h b/engines/tony/loc.h
index 00fcb579c8..ac0bb1d69a 100644
--- a/engines/tony/loc.h
+++ b/engines/tony/loc.h
@@ -72,7 +72,7 @@ public:
 class RMSfx {
 public:
 	RMString _name;
-	FPSFX *_fx;
+	FPSfx *_fx;
 	bool _bPlayingLoop;
 
 public:
diff --git a/engines/tony/sound.cpp b/engines/tony/sound.cpp
index b3bdd1be9a..35db3ced38 100644
--- a/engines/tony/sound.cpp
+++ b/engines/tony/sound.cpp
@@ -41,28 +41,28 @@ namespace Tony {
 *       Defines
 \****************************************************************************/
 
-#define RELEASE(x)             {if ((x) != NULL) { (x)->Release(); x = NULL; }}
+#define RELEASE(x)             {if ((x) != NULL) { (x)->release(); x = NULL; }}
 
 /****************************************************************************\
-*       Metodi per FPSOUND
+*       Metodi per FPSound
 \****************************************************************************/
 
 /****************************************************************************\
 *
-* Function:     FPSOUND::FPSOUND();
+* Function:     FPSound::FPSound();
 *
 * Description:  Costruttore di default. Inizializza gli attributi.
 *
 \****************************************************************************/
 
-FPSOUND::FPSOUND() {
+FPSound::FPSound() {
 	bSoundSupported = false;
 }
 
 
 /****************************************************************************\
 *
-* Function:     bool FPSOUND::Init();
+* Function:     bool FPSound::Init();
 *
 * Description:  Inizializza l'oggetto, e prepara tutto il necessario per
 *               creare stream e effetti sonori.
@@ -71,7 +71,7 @@ FPSOUND::FPSOUND() {
 *
 \****************************************************************************/
 
-bool FPSOUND::Init() {
+bool FPSound::init() {
 	bSoundSupported = g_system->getMixer()->isReady();
 	return bSoundSupported;
 }
@@ -79,40 +79,40 @@ bool FPSOUND::Init() {
 
 /****************************************************************************\
 *
-* Function:     FPSOUND::~FPSOUND();
+* Function:     FPSound::~FPSound();
 *
 * Description:  Deinizializza l'oggetto, disallocando la memoria.
 *
 \****************************************************************************/
 
-FPSOUND::~FPSOUND() {
+FPSound::~FPSound() {
 }
 
 
 /****************************************************************************\
 *
-* Function:     bool CreateStream(FPSTREAM** lplpStream);
+* Function:     bool CreateStream(FPStream** lplpStream);
 *
-* Description:  Alloca un oggetti di tipo FPSTREAM, e ritorna il suo
+* Description:  Alloca un oggetti di tipo FPStream, e ritorna il suo
 *               puntatore dopo averlo inizializzato.
 *
-* Input:        FPSTREAM** lplpStream   Conterra' il pointer all'oggetto
+* Input:        FPStream** lplpStream   Conterra' il pointer all'oggetto
 *                                       appena creato.
 *
 * Return:       true se tutto OK, false in caso di errore
 *
 * Note:         L'utilizzo di funzioni del tipo CreateStream(), CreateSfx(),
-*               sono dovute al fatto che i costruttori delle classi FPSTREAM
-*               e FPSFX richiedono che DirectSound sia gia' stato
+*               sono dovute al fatto che i costruttori delle classi FPStream
+*               e FPSfx richiedono che DirectSound sia gia' stato
 *               inzializzato. In questo modo quindi si evitano dei bugs
 *               che si verrebbero a creare se venisse dichiarata un oggetto
-*               di tipo FPSTREAM o FPSFX globale (o cmq prima della
+*               di tipo FPStream o FPSfx globale (o cmq prima della
 *               inizializzazione di DirectSound).
 *
 \****************************************************************************/
 
-bool FPSOUND::CreateStream(FPSTREAM **lplpStream) {
-	(*lplpStream) = new FPSTREAM(bSoundSupported);
+bool FPSound::createStream(FPStream **lplpStream) {
+	(*lplpStream) = new FPStream(bSoundSupported);
 
 	return (*lplpStream != NULL);
 }
@@ -121,12 +121,12 @@ bool FPSOUND::CreateStream(FPSTREAM **lplpStream) {
 
 /****************************************************************************\
 *
-* Function:     bool CreateSfx(FPSFX** lplpSfx);
+* Function:     bool CreateSfx(FPSfx** lplpSfx);
 *
-* Description:  Alloca un oggetti di tipo FPSFX e ritorna il suo
+* Description:  Alloca un oggetti di tipo FPSfx e ritorna il suo
 *               puntatore dopo averlo inizializzato.
 *
-* Input:        FPSFX** lplpSfx         Conterra' il pointer all'oggetto
+* Input:        FPSfx** lplpSfx         Conterra' il pointer all'oggetto
 *                                       appena creato.
 *
 * Return:       true se tutto OK, false in caso di errore
@@ -135,8 +135,8 @@ bool FPSOUND::CreateStream(FPSTREAM **lplpStream) {
 *
 \****************************************************************************/
 
-bool FPSOUND::CreateSfx(FPSFX **lplpSfx) {
-	(*lplpSfx) = new FPSFX(bSoundSupported);
+bool FPSound::createSfx(FPSfx **lplpSfx) {
+	(*lplpSfx) = new FPSfx(bSoundSupported);
 
 	return (*lplpSfx != NULL);
 }
@@ -153,7 +153,7 @@ bool FPSOUND::CreateSfx(FPSFX **lplpSfx) {
 *
 \****************************************************************************/
 
-void FPSOUND::SetMasterVolume(int dwVolume) {
+void FPSound::setMasterVolume(int dwVolume) {
 	if (!bSoundSupported)
 		return;
 
@@ -171,7 +171,7 @@ void FPSOUND::SetMasterVolume(int dwVolume) {
 *
 \****************************************************************************/
 
-void FPSOUND::GetMasterVolume(int *lpdwVolume) {
+void FPSound::getMasterVolume(int *lpdwVolume) {
 	if (!bSoundSupported)
 		return;
 
@@ -180,19 +180,19 @@ void FPSOUND::GetMasterVolume(int *lpdwVolume) {
 
 
 /****************************************************************************\
-*       Metodi di FPSFX
+*       Metodi di FPSfx
 \****************************************************************************/
 
 /****************************************************************************\
 *
-* Function:     FPSFX(bool bSoundOn);
+* Function:     FPSfx(bool bSoundOn);
 *
 * Description:  Costruttore di default. *NON* bisogna dichiarare direttamente
-*               un oggetto, ma crearlo piuttosto tramite FPSOUND::CreateSfx()
+*               un oggetto, ma crearlo piuttosto tramite FPSound::CreateSfx()
 *
 \****************************************************************************/
 
-FPSFX::FPSFX(bool bSoundOn) {
+FPSfx::FPSfx(bool bSoundOn) {
 	bSoundSupported = bSoundOn;
 	bFileLoaded = false;
 	lastVolume = 63;
@@ -208,7 +208,7 @@ FPSFX::FPSFX(bool bSoundOn) {
 
 /****************************************************************************\
 *
-* Function:     ~FPSFX();
+* Function:     ~FPSfx();
 *
 * Description:  Distruttore di default. Si preoccupa anche di fermare il sound
 *                               effect eventualmente in esecuzione, e disallocare la memoria
@@ -216,7 +216,7 @@ FPSFX::FPSFX(bool bSoundOn) {
 *
 \****************************************************************************/
 
-FPSFX::~FPSFX() {
+FPSfx::~FPSfx() {
 	if (!bSoundSupported)
 		return;
 
@@ -240,14 +240,14 @@ FPSFX::~FPSFX() {
 *
 * Description:  Rilascia la memoria dell'oggetto. Deve essere richiamata quando
 *               l'oggetto non serve piu' e **SOLO SE** l'oggetto e' stato
-*               creato con la FPSOUND::CreateStream().
+*               creato con la FPSound::CreateStream().
 *
 * Note:         Eventuali puntatori all'oggetto non sono piu' validi dopo
 *               questa chiamata.
 *
 \****************************************************************************/
 
-void FPSFX::Release() {
+void FPSfx::release() {
 	delete this;
 }
 
@@ -267,7 +267,7 @@ void FPSFX::Release() {
 *
 \****************************************************************************/
 
-bool FPSFX::loadWave(Common::SeekableReadStream *stream) {
+bool FPSfx::loadWave(Common::SeekableReadStream *stream) {
 	if (!stream)
 		return false;
 
@@ -277,7 +277,7 @@ bool FPSFX::loadWave(Common::SeekableReadStream *stream) {
 		return false;
 
 	bFileLoaded = true;
-	SetVolume(lastVolume);
+	setVolume(lastVolume);
 	return true;
 }
 
@@ -296,7 +296,7 @@ bool FPSFX::loadWave(Common::SeekableReadStream *stream) {
 *
 \****************************************************************************/
 
-bool FPSFX::LoadVoiceFromVDB(Common::File &vdbFP) {
+bool FPSfx::loadVoiceFromVDB(Common::File &vdbFP) {
 	if (!bSoundSupported)
 		return true;
 
@@ -307,23 +307,23 @@ bool FPSFX::LoadVoiceFromVDB(Common::File &vdbFP) {
 	_rewindableStream = Audio::makeADPCMStream(vdbFP.readStream(size), DisposeAfterUse::YES, 0, Audio::kADPCMDVI, rate, 1);
 
 	bFileLoaded = true;
-	SetVolume(62);
+	setVolume(62);
 	return true;
 }
 
 
-bool FPSFX::LoadFile(const char *lpszFileName, uint32 dwCodec) {
+bool FPSfx::loadFile(const char *lpszFileName, uint32 dwCodec) {
 	if (!bSoundSupported)
 		return true;
 
 	Common::File file;
 	if (!file.open(lpszFileName)) {
-		warning("FPSFX::LoadFile(): Cannot open sfx file!");
+		warning("FPSfx::LoadFile(): Cannot open sfx file!");
 		return false;
 	}
 
 	if (file.readUint32BE() != MKTAG('A', 'D', 'P', 0x10)) {
-		warning("FPSFX::LoadFile(): Invalid ADP header!");
+		warning("FPSfx::LoadFile(): Invalid ADP header!");
 		return false;
 	}
 
@@ -358,8 +358,8 @@ bool FPSFX::LoadFile(const char *lpszFileName, uint32 dwCodec) {
 *
 \****************************************************************************/
 
-bool FPSFX::Play() {
-	Stop(); // sanity check
+bool FPSfx::play() {
+	stop(); // sanity check
 
 	if (bFileLoaded) {
 		// FIXME
@@ -380,7 +380,7 @@ bool FPSFX::Play() {
 		g_system->getMixer()->playStream(Audio::Mixer::kPlainSoundType, &_handle, stream, -1,
 				Audio::Mixer::kMaxChannelVolume, 0, DisposeAfterUse::NO);
 
-		SetVolume(lastVolume);
+		setVolume(lastVolume);
 
 		if (bPaused)
 			g_system->getMixer()->pauseHandle(_handle, true);
@@ -400,7 +400,7 @@ bool FPSFX::Play() {
 *
 \****************************************************************************/
 
-bool FPSFX::Stop() {
+bool FPSfx::stop() {
 	if (bFileLoaded) {
 		g_system->getMixer()->stopHandle(_handle);
 		bPaused = false;
@@ -427,11 +427,11 @@ bool FPSFX::Stop() {
 *
 \****************************************************************************/
 
-void FPSFX::SetLoop(bool bLop) {
+void FPSfx::setLoop(bool bLop) {
 	bLoop = bLop;
 }
 
-void FPSFX::Pause(bool bPause) {
+void FPSfx::pause(bool bPause) {
 	if (bFileLoaded) {
 		if (g_system->getMixer()->isSoundHandleActive(_handle) && (bPause ^ bPaused))
 			g_system->getMixer()->pauseHandle(_handle, bPause);
@@ -451,23 +451,28 @@ void FPSFX::Pause(bool bPause) {
 *
 \****************************************************************************/
 
-void FPSFX::SetVolume(int dwVolume) {
-	if (dwVolume > 63) dwVolume = 63;
-	if (dwVolume < 0) dwVolume = 0;
+void FPSfx::setVolume(int dwVolume) {
+	if (dwVolume > 63)
+		dwVolume = 63;
+	if (dwVolume < 0)
+		dwVolume = 0;
 
 	lastVolume = dwVolume;
 
 	if (bIsVoice) {
-		if (!GLOBALS._bCfgDubbing) dwVolume = 0;
+		if (!GLOBALS._bCfgDubbing)
+			dwVolume = 0;
 		else {
 			dwVolume -= (10 - GLOBALS._nCfgDubbingVolume) * 2;
 			if (dwVolume < 0) dwVolume = 0;
 		}
 	} else {
-		if (!GLOBALS._bCfgSFX) dwVolume = 0;
+		if (!GLOBALS._bCfgSFX)
+			dwVolume = 0;
 		else {
 			dwVolume -= (10 - GLOBALS._nCfgSFXVolume) * 2;
-			if (dwVolume < 0) dwVolume = 0;
+			if (dwVolume < 0)
+				dwVolume = 0;
 		}
 	}
 
@@ -488,7 +493,7 @@ void FPSFX::SetVolume(int dwVolume) {
 *
 \****************************************************************************/
 
-void FPSFX::GetVolume(int *lpdwVolume) {
+void FPSfx::getVolume(int *lpdwVolume) {
 	if (g_system->getMixer()->isSoundHandleActive(_handle))
 		*lpdwVolume = g_system->getMixer()->getChannelVolume(_handle) * 63 / Audio::Mixer::kMaxChannelVolume;
 	else
@@ -498,7 +503,7 @@ void FPSFX::GetVolume(int *lpdwVolume) {
 /**
  * Returns true if the underlying sound has ended
  */
-bool FPSFX::endOfBuffer() const {
+bool FPSfx::endOfBuffer() const {
 	return !g_system->getMixer()->isSoundHandleActive(_handle) && (!_rewindableStream || _rewindableStream->endOfData());
 }
 
@@ -506,9 +511,9 @@ bool FPSFX::endOfBuffer() const {
  * Continually checks to see if active sounds have finished playing
  * Sets the event signalling the sound has ended
  */
-void FPSFX::soundCheckProcess(CORO_PARAM, const void *param) {
+void FPSfx::soundCheckProcess(CORO_PARAM, const void *param) {
 	CORO_BEGIN_CONTEXT;
-		Common::List<FPSFX *>::iterator i;
+		Common::List<FPSfx *>::iterator i;
 	CORO_END_CONTEXT(_ctx);
 
 	CORO_BEGIN_CODE(_ctx);
@@ -516,7 +521,7 @@ void FPSFX::soundCheckProcess(CORO_PARAM, const void *param) {
 	for (;;) {
 		// Check each active sound
 		for (_ctx->i = _vm->_activeSfx.begin(); _ctx->i != _vm->_activeSfx.end(); ++_ctx->i) {
-			FPSFX *sfx = *_ctx->i;
+			FPSfx *sfx = *_ctx->i;
 			if (sfx->endOfBuffer())
 				CoroScheduler.setEvent(sfx->hEndOfBuffer);
 		}
@@ -529,19 +534,19 @@ void FPSFX::soundCheckProcess(CORO_PARAM, const void *param) {
 }
 
 /****************************************************************************\
-*       Metodi di FPSTREAM
+*       Metodi di FPStream
 \****************************************************************************/
 
 /****************************************************************************\
 *
-* Function:     FPSTREAM(LPDIRECTSOUND lpDS, bool bSoundOn);
+* Function:     FPStream(LPDIRECTSOUND lpDS, bool bSoundOn);
 *
 * Description:  Costruttore di default. *NON* bisogna dichiarare direttamente
-*               un oggetto, ma crearlo piuttosto tramite FPSOUND::CreateStream()
+*               un oggetto, ma crearlo piuttosto tramite FPSound::CreateStream()
 *
 \****************************************************************************/
 
-FPSTREAM::FPSTREAM(bool bSoundOn) {
+FPStream::FPStream(bool bSoundOn) {
 #ifdef REFACTOR_ME
 	//hwnd=hWnd;
 	lpDS = LPDS;
@@ -556,7 +561,7 @@ FPSTREAM::FPSTREAM(bool bSoundOn) {
 #endif
 }
 
-bool FPSTREAM::CreateBuffer(int nBufSize) {
+bool FPStream::createBuffer(int nBufSize) {
 #ifdef REFACTOR_ME
 	static PCMWAVEFORMAT pcmwf;
 	static DSBUFFERDESC dsbdesc;
@@ -585,7 +590,7 @@ bool FPSTREAM::CreateBuffer(int nBufSize) {
 
 	if ((err = lpDS->CreateSoundBuffer(&dsbdesc, &lpDSBuffer, NULL)) != DS_OK) {
 		wsprintf(errbuf, "Error creating the secondary buffer (%lx)", err);
-		MessageBox(hwnd, errbuf, "FPSTREAM::FPSTREAM()", MB_OK);
+		MessageBox(hwnd, errbuf, "FPStream::FPStream()", MB_OK);
 		bSoundSupported = false;
 		return false;
 	}
@@ -599,7 +604,7 @@ bool FPSTREAM::CreateBuffer(int nBufSize) {
 
 	if (FAILED(err)) {
 		wsprintf(errbuf, "Error creating notify object! (%lx)", err);
-		MessageBox(hwnd, errbuf, "FPSTREAM::FPSTREAM()", MB_OK);
+		MessageBox(hwnd, errbuf, "FPStream::FPStream()", MB_OK);
 		bSoundSupported = false;
 		return false;
 	}
@@ -626,14 +631,14 @@ bool FPSTREAM::CreateBuffer(int nBufSize) {
 
 /****************************************************************************\
 *
-* Function:     ~FPSTREAM();
+* Function:     ~FPStream();
 *
 * Description:  Distruttore di default. Richiama anche la CloseFile() se ce
 *               ne e' bisogno.
 *
 \****************************************************************************/
 
-FPSTREAM::~FPSTREAM() {
+FPStream::~FPStream() {
 #ifdef REFACTOR_ME
 
 	if (!bSoundSupported)
@@ -680,14 +685,14 @@ FPSTREAM::~FPSTREAM() {
 *
 * Description:  Rilascia la memoria dell'oggetto. Deve essere richiamata quando
 *               l'oggetto non serve piu' e **SOLO SE** l'oggetto e' stato
-*               creato con la FPSOUND::CreateStream().
+*               creato con la FPSound::CreateStream().
 *
 * Note:         Eventuali puntatori all'oggetto non sono piu' validi dopo
 *               questa chiamata.
 *
 \****************************************************************************/
 
-void FPSTREAM::Release() {
+void FPStream::release() {
 	delete this;
 //	return NULL;
 }
@@ -707,7 +712,7 @@ void FPSTREAM::Release() {
 *
 \****************************************************************************/
 
-bool FPSTREAM::LoadFile(const char *lpszFileName, uint32 dwCodType, int nBufSize) {
+bool FPStream::loadFile(const char *lpszFileName, uint32 dwCodType, int nBufSize) {
 #ifdef REFACTOR_ME
 	HRESULT err;
 	void *lpBuf;
@@ -725,7 +730,7 @@ bool FPSTREAM::LoadFile(const char *lpszFileName, uint32 dwCodType, int nBufSize
 
 	/* Apre il file di stream in lettura */
 	if (!_file.open(lpszFileName))
-		//MessageBox(hwnd,"Cannot open stream file!","FPSTREAM::LoadFile()", MB_OK);
+		//MessageBox(hwnd,"Cannot open stream file!","FPStream::LoadFile()", MB_OK);
 		return false;
 }
 
@@ -755,7 +760,7 @@ return true;
 *
 \****************************************************************************/
 
-bool FPSTREAM::UnloadFile() {
+bool FPStream::unloadFile() {
 #ifdef REFACTOR_ME
 
 	if (!bSoundSupported || !bFileLoaded)
@@ -783,7 +788,7 @@ bool FPSTREAM::UnloadFile() {
 *
 \****************************************************************************/
 
-void FPSTREAM::Prefetch(void) {
+void FPStream::prefetch(void) {
 #ifdef REFACTOR_ME
 	uint32 dwId;
 	void *lpBuf;
@@ -850,7 +855,7 @@ void FPSTREAM::Prefetch(void) {
 #endif
 }
 
-void FPSTREAM::PlayFast(void) {
+void FPStream::playFast(void) {
 #ifdef REFACTOR_ME
 	dspnHot[0].dwOffset = 32;
 	dspnHot[0].hEventNotify = hHot1;
@@ -873,7 +878,7 @@ void FPSTREAM::PlayFast(void) {
 #endif
 }
 
-bool FPSTREAM::Play() {
+bool FPStream::play() {
 #ifdef REFACTOR_ME
 	uint32 dwId;
 	void *lpBuf;
@@ -961,7 +966,7 @@ bool FPSTREAM::Play() {
 *
 \****************************************************************************/
 
-bool FPSTREAM::Stop(bool bSync) {
+bool FPStream::stop(bool bSync) {
 #ifdef REFACTOR_ME
 
 	if (!bSoundSupported)
@@ -1001,7 +1006,7 @@ bool FPSTREAM::Stop(bool bSync) {
 	return true;
 }
 
-void FPSTREAM::WaitForSync(FPSTREAM *toplay) {
+void FPStream::waitForSync(FPStream *toplay) {
 #ifdef REFACTOR_ME
 	if (!bSoundSupported)
 		return;
@@ -1035,13 +1040,13 @@ void FPSTREAM::WaitForSync(FPSTREAM *toplay) {
 
 /****************************************************************************\
 *
-* Function:     void FPSTREAM::PlayThread();
+* Function:     void FPStream::PlayThread();
 *
 * Description:  Thread che si occupa del play dello stream
 *
 \****************************************************************************/
 
-void FPSTREAM::PlayThread(FPSTREAM *This) {
+void FPStream::playThread(FPStream *This) {
 #ifdef REFACTOR_ME
 	byte *lpLockBuf;
 	uint32 dwResult;
@@ -1172,12 +1177,12 @@ void FPSTREAM::PlayThread(FPSTREAM *This) {
 *
 \****************************************************************************/
 
-void FPSTREAM::SetLoop(bool loop) {
+void FPStream::setLoop(bool loop) {
 	bLoop = loop;
 }
 
 
-void FPSTREAM::Pause(bool bPause) {
+void FPStream::pause(bool bPause) {
 #ifdef REFACTOR_ME
 
 	if (bFileLoaded) {
@@ -1222,7 +1227,7 @@ void FPSTREAM::Pause(bool bPause) {
 *
 \****************************************************************************/
 
-void FPSTREAM::SetVolume(int dwVolume) {
+void FPStream::setVolume(int dwVolume) {
 #ifdef REFACTOR_ME
 	if (dwVolume > 63) dwVolume = 63;
 	if (dwVolume < 0) dwVolume = 0;
@@ -1253,7 +1258,7 @@ void FPSTREAM::SetVolume(int dwVolume) {
 *
 \****************************************************************************/
 
-void FPSTREAM::GetVolume(int *lpdwVolume) {
+void FPStream::getVolume(int *lpdwVolume) {
 #ifdef REFACTOR_ME
 	if (lpDSBuffer)
 		lpDSBuffer->GetVolume((uint32 *)lpdwVolume);
diff --git a/engines/tony/sound.h b/engines/tony/sound.h
index abd7e06cae..f47393b86d 100644
--- a/engines/tony/sound.h
+++ b/engines/tony/sound.h
@@ -41,8 +41,8 @@ class RewindableAudioStream;
 
 namespace Tony {
 
-class FPSTREAM;
-class FPSFX;
+class FPStream;
+class FPSfx;
 
 enum SoundCodecs {
 	FPCODEC_RAW,
@@ -58,7 +58,7 @@ enum SoundCodecs {
 *****************************************************************************
 \****************************************************************************/
 
-class FPSOUND {
+class FPSound {
 
 private:
 
@@ -72,27 +72,27 @@ public:
 
 	/****************************************************************************\
 	*
-	* Function:     FPSOUND::FPSOUND();
+	* Function:     FPSound::FPSound();
 	*
 	* Description:  Default constructor. Initializes the attributes
 	*
 	\****************************************************************************/
 
-	FPSOUND();
+	FPSound();
 
 	/****************************************************************************\
 	*
-	* Function:     FPSOUND::~FPSOUND();
+	* Function:     FPSound::~FPSound();
 	*
 	* Description:  Deinitialize the object, free memory
 	*
 	\****************************************************************************/
 
-	~FPSOUND();
+	~FPSound();
 
 	/****************************************************************************\
 	*
-	* Function:     bool FPSOUND::Init();
+	* Function:     bool FPSound::Init();
 	*
 	* Description:  Initializes the objects, and prepare everything required to 
 	*               create streams and sound effects.
@@ -101,38 +101,38 @@ public:
 	*
 	\****************************************************************************/
 
-	bool Init();
+	bool init();
 
 	/****************************************************************************\
 	*
-	* Function:     bool CreateStream(FPSTREAM** lplpStream);
+	* Function:     bool CreateStream(FPStream** lplpStream);
 	*
-	* Description:  Allocates an object of type FPSTREAM, and return its 
+	* Description:  Allocates an object of type FPStream, and return its 
 	*               pointer after it has been initialized.
 	*
-	* Input:        FPSTREAM** lplpStream   Will contain the pointer of the 
+	* Input:        FPStream** lplpStream   Will contain the pointer of the 
 	*                                       object
 	*
 	* Return:       True is everything i OK, False otherwise
 	*
 	* Note:         The use of functions like CreateStream () and CreateSfx () 
 	*               are due to the fact that the class constructors and 
-	*               FPSTREAM FPSFX require that DirectSound is already initialized. 
+	*               FPStream FPSfx require that DirectSound is already initialized. 
 	*               In this way, you avoid the bugs that would be created if an 
-	*               object type is declared FPSTREAM FPSFX or global 
+	*               object type is declared FPStream FPSfx or global 
 	*               (or anyway before initializing DirectSound).
 	\****************************************************************************/
 
-	bool CreateStream(FPSTREAM **lplpStream);
+	bool createStream(FPStream **lplpStream);
 
 	/****************************************************************************\
 	*
-	* Function:     bool CreateSfx(FPSFX** lplpSfx);
+	* Function:     bool CreateSfx(FPSfx** lplpSfx);
 	*
-	* Description:  Allocates an object of type FPSFX and returns a pointer 
+	* Description:  Allocates an object of type FPSfx and returns a pointer 
 	*               pointing to it
 	*
-	* Input:        FPSFX** lplpSfx         Will contain the pointer of the 
+	* Input:        FPSfx** lplpSfx         Will contain the pointer of the 
 	*                                       object
 	*
 	* Return:       True is everything i OK, False otherwise
@@ -141,7 +141,7 @@ public:
 	*
 	\****************************************************************************/
 
-	bool CreateSfx(FPSFX **lplpSfx);
+	bool createSfx(FPSfx **lplpSfx);
 
 	/****************************************************************************\
 	*
@@ -153,7 +153,7 @@ public:
 	*
 	\****************************************************************************/
 
-	void SetMasterVolume(int dwVolume);
+	void setMasterVolume(int dwVolume);
 
 	/****************************************************************************\
 	*
@@ -166,10 +166,10 @@ public:
 	*
 	\****************************************************************************/
 
-	void GetMasterVolume(int *lpdwVolume);
+	void getMasterVolume(int *lpdwVolume);
 };
 
-class FPSFX {
+class FPSfx {
 
 	/****************************************************************************\
 	*       Attributes
@@ -206,43 +206,43 @@ public:
 
 	/****************************************************************************\
 	*
-	* Function:     FPSFX(bool bSoundOn);
+	* Function:     FPSfx(bool bSoundOn);
 	*
 	* Description:  Default constructor. *DO NOT* declare the object directly,
-	*               create it though FPSOUND::CreateSfx() instead
+	*               create it though FPSound::CreateSfx() instead
 	*
 	\****************************************************************************/
 
-	FPSFX(bool bSoundOn);
+	FPSfx(bool bSoundOn);
 
 	/****************************************************************************\
 	*
-	* Function:     ~FPSFX();
+	* Function:     ~FPSfx();
 	*
 	* Description:  Default destructor. It also stops the sound effect that 
 	*               may be running, and free the memory used.
 	*
 	\****************************************************************************/
 
-	~FPSFX();
+	~FPSfx();
 
 	/****************************************************************************\
 	*
-	* Function:     Release();
+	* Function:     release();
 	*
 	* Description:  Releases the memory object. Must be called when the object 
 	*               is no longer useful and **ONLY** when the object was created 
-	*               with the FPSOUND :: CreateStream ().
+	*               with the FPSound :: CreateStream ().
 	*
 	* Note:         Any object pointers are no longer valid after this call.
 	*
 	\****************************************************************************/
 
-	void Release();
+	void release();
 
 	/****************************************************************************\
 	*
-	* Function:     bool LoadFile(char *lpszFileName, uint32 dwCodec=FPCODEC_RAW);
+	* Function:     bool loadFile(char *lpszFileName, uint32 dwCodec=FPCODEC_RAW);
 	*
 	* Description:  Opens a file and load sound effect
 	*
@@ -254,13 +254,13 @@ public:
 	*
 	\****************************************************************************/
 
-	bool LoadFile(const char *lpszFileName, uint32 dwCodec = FPCODEC_RAW);
+	bool loadFile(const char *lpszFileName, uint32 dwCodec = FPCODEC_RAW);
 	bool loadWave(Common::SeekableReadStream *stream);
-	bool LoadVoiceFromVDB(Common::File &vdbFP);
+	bool loadVoiceFromVDB(Common::File &vdbFP);
 
 	/****************************************************************************\
 	*
-	* Function:     bool Play();
+	* Function:     bool play();
 	*
 	* Description:  Play the loaded FX.
 	*
@@ -268,11 +268,11 @@ public:
 	*
 	\****************************************************************************/
 
-	bool Play();
+	bool play();
 
 	/****************************************************************************\
 	*
-	* Function:     bool Stop();
+	* Function:     bool stop();
 	*
 	* Description:  Stop a FX
 	*
@@ -280,21 +280,21 @@ public:
 	*
 	\****************************************************************************/
 
-	bool Stop();
+	bool stop();
 
 	/****************************************************************************\
 	*
-	* Function:     void Pause(bool bPause);
+	* Function:     void pause(bool bPause);
 	*
 	* Description:  Pause a FX
 	*
 	\****************************************************************************/
 
-	void Pause(bool bPause);
+	void pause(bool bPause);
 
 	/****************************************************************************\
 	*
-	* Function:     bool SetLoop(bool bLoop);
+	* Function:     bool setLoop(bool bLoop);
 	*
 	* Description:  Enables or disables SFX loop
 	*
@@ -306,11 +306,11 @@ public:
 	*
 	\****************************************************************************/
 
-	void SetLoop(bool bLoop);
+	void setLoop(bool bLoop);
 
 	/****************************************************************************\
 	*
-	* Function:     void SetVolume(int dwVolume);
+	* Function:     void setVolume(int dwVolume);
 	*
 	* Description:  Set SFX Volume
 	*
@@ -318,11 +318,11 @@ public:
 	*
 	\****************************************************************************/
 
-	void SetVolume(int dwVolume);
+	void setVolume(int dwVolume);
 
 	/****************************************************************************\
 	*
-	* Function:     void GetVolume(int * lpdwVolume);
+	* Function:     void getVolume(int * lpdwVolume);
 	*
 	* Description:  Get SFX volume
 	*
@@ -330,7 +330,7 @@ public:
 	*
 	\****************************************************************************/
 
-	void GetVolume(int *lpdwVolume);
+	void getVolume(int *lpdwVolume);
 
 	/**
 	 * Returns true if the sound has finished playing
@@ -338,7 +338,7 @@ public:
 	bool endOfBuffer() const;
 };
 
-class FPSTREAM {
+class FPStream {
 
 	/****************************************************************************\
 	*       Attributes
@@ -372,17 +372,17 @@ private:
 	bool bSyncExit;
 	bool bPaused;
 	int lastVolume;
-	FPSTREAM *SyncToPlay;
+	FPStream *SyncToPlay;
 //	DSBPOSITIONNOTIFY dspnHot[3];
 
-	bool CreateBuffer(int nBufSize);
+	bool createBuffer(int nBufSize);
 
 public:
 	bool bIsPlaying;                      // True if the stream is playing
 
 private:
 
-	static void PlayThread(FPSTREAM *This);
+	static void playThread(FPStream *This);
 
 	/****************************************************************************\
 	*       Methods
@@ -392,43 +392,43 @@ public:
 
 	/****************************************************************************\
 	*
-	* Function:     FPSTREAM(bool bSoundOn);
+	* Function:     FPStream(bool bSoundOn);
 	*
 	* Description:  Default contractor. *DO NOT* declare the object directly: use
-	*                                   FPSOUND::CreateStream() indtead
+	*                                   FPSound::CreateStream() indtead
 	*
 	\****************************************************************************/
 
-	FPSTREAM(bool bSoundOn);
+	FPStream(bool bSoundOn);
 
 	/****************************************************************************\
 	*
-	* Function:     ~FPSTREAM();
+	* Function:     ~FPStream();
 	*
 	* Description:  Destructor by default. Stops the playing stream (if any) and
 	*                                      frees the memory used by them
 	*
 	\****************************************************************************/
 
-	~FPSTREAM();
+	~FPStream();
 
 	/****************************************************************************\
 	*
-	* Function:     Release();
+	* Function:     release();
 	*
 	* Description:  Releases memory used by object. Must be used when the object 
 	*               is no longer used. *ONLY*¨for objects created by 
-	*               FPSOUND::CreateStream().
+	*               FPSound::CreateStream().
 	*
 	* Note:         Object pointers are no longer valid after this call.
 	*
 	\****************************************************************************/
 
-	void Release();
+	void release();
 
 	/****************************************************************************\
 	*
-	* Function:     bool LoadFile(char *lpszFileName, uint32 dwCodec=FPCODEC_RAW);
+	* Function:     bool loadFile(char *lpszFileName, uint32 dwCodec=FPCODEC_RAW);
 	*
 	* Description:  Open a file for a stream.
 	*
@@ -440,11 +440,11 @@ public:
 	*
 	\****************************************************************************/
 
-	bool LoadFile(const char *lpszFileName, uint32 dwCodec = FPCODEC_RAW, int nSync = 2000);
+	bool loadFile(const char *lpszFileName, uint32 dwCodec = FPCODEC_RAW, int nSync = 2000);
 
 	/****************************************************************************\
 	*
-	* Function:     UnloadFile();
+	* Function:     unloadFile();
 	*
 	* Description:  Close a file stream (if opened). This function must be
 	*               called to free the memory used by the stream
@@ -454,11 +454,11 @@ public:
 	*
 	\****************************************************************************/
 
-	bool UnloadFile();
+	bool unloadFile();
 
 	/****************************************************************************\
 	*
-	* Function:     bool Play();
+	* Function:     bool play();
 	*
 	* Description:  Play the loaded stream.
 	*
@@ -466,13 +466,13 @@ public:
 	*
 	\****************************************************************************/
 
-	bool Play();
-	void PlayFast(void);
-	void Prefetch(void);
+	bool play();
+	void playFast(void);
+	void prefetch(void);
 
 	/****************************************************************************\
 	*
-	* Function:     bool Stop();
+	* Function:     bool stop();
 	*
 	* Description:  Stops the play of the stream.
 	*
@@ -480,22 +480,22 @@ public:
 	*
 	\****************************************************************************/
 
-	bool Stop(bool bSync = false);
-	void WaitForSync(FPSTREAM *toplay);
+	bool stop(bool bSync = false);
+	void waitForSync(FPStream *toplay);
 
 	/****************************************************************************\
 	*
-	* Function:     void Pause(bool bPause);
+	* Function:     void pause(bool bPause);
 	*
 	* Description:  Pause sound effect
 	*
 	\****************************************************************************/
 
-	void Pause(bool bPause);
+	void pause(bool bPause);
 
 	/****************************************************************************\
 	*
-	* Function:     bool SetLoop(bool bLoop);
+	* Function:     bool setLoop(bool bLoop);
 	*
 	* Description:  Enable of disable stream loop
 	*
@@ -507,11 +507,11 @@ public:
 	*
 	\****************************************************************************/
 
-	void SetLoop(bool bLoop);
+	void setLoop(bool bLoop);
 
 	/****************************************************************************\
 	*
-	* Function:     void SetVolume(int dwVolume);
+	* Function:     void setVolume(int dwVolume);
 	*
 	* Description:  Change stream colume
 	*
@@ -519,13 +519,13 @@ public:
 	*
 	\****************************************************************************/
 
-	void SetVolume(int dwVolume);
+	void setVolume(int dwVolume);
 
 
 
 	/****************************************************************************\
 	*
-	* Function:     void GetVolume(LPINT lpdwVolume);
+	* Function:     void getVolume(LPINT lpdwVolume);
 	*
 	* Description:  Get stream volume
 	*
@@ -533,7 +533,7 @@ public:
 	*
 	\****************************************************************************/
 
-	void GetVolume(int *lpdwVolume);
+	void getVolume(int *lpdwVolume);
 };
 
 
diff --git a/engines/tony/tony.cpp b/engines/tony/tony.cpp
index 012dc854b9..094e1bd038 100644
--- a/engines/tony/tony.cpp
+++ b/engines/tony/tony.cpp
@@ -213,8 +213,8 @@ void TonyEngine::playMusic(int nChannel, const char *fn, int nFX, bool bLoop, in
 	case 0:
 	case 1:
 	case 2:
-		_stream[nChannel]->Stop();
-		_stream[nChannel]->UnloadFile();
+		_stream[nChannel]->stop();
+		_stream[nChannel]->unloadFile();
 		break;
 
 	case 22:
@@ -287,30 +287,30 @@ void TonyEngine::playSFX(int nChannel, int nFX) {
 
 	switch (nFX) {
 	case 0:
-		_sfx[nChannel]->SetLoop(false);
+		_sfx[nChannel]->setLoop(false);
 		break;
 
 	case 1:
-		_sfx[nChannel]->SetLoop(true);
+		_sfx[nChannel]->setLoop(true);
 		break;
 	}
 
-	_sfx[nChannel]->Play();
+	_sfx[nChannel]->play();
 }
 
 void TonyEngine::stopMusic(int nChannel) {
 //	g_system->lockMutex(csMusic);
 
 	if (nChannel < 4)
-		_stream[nChannel + GLOBALS._flipflop]->Stop();
+		_stream[nChannel + GLOBALS._flipflop]->stop();
 	else
-		_stream[nChannel]->Stop();
+		_stream[nChannel]->stop();
 
 //	g_system->unlockMutex(csMusic);
 }
 
 void TonyEngine::stopSFX(int nChannel) {
-	_sfx[nChannel]->Stop();
+	_sfx[nChannel]->stop();
 }
 
 void TonyEngine::playUtilSFX(int nChannel, int nFX) {
@@ -319,38 +319,38 @@ void TonyEngine::playUtilSFX(int nChannel, int nFX) {
 
 	switch (nFX) {
 	case 0:
-		_utilSfx[nChannel]->SetLoop(false);
+		_utilSfx[nChannel]->setLoop(false);
 		break;
 
 	case 1:
-		_utilSfx[nChannel]->SetLoop(true);
+		_utilSfx[nChannel]->setLoop(true);
 		break;
 	}
 
-	_utilSfx[nChannel]->SetVolume(52);
-	_utilSfx[nChannel]->Play();
+	_utilSfx[nChannel]->setVolume(52);
+	_utilSfx[nChannel]->play();
 }
 
 void TonyEngine::stopUtilSFX(int nChannel) {
-	_utilSfx[nChannel]->Stop();
+	_utilSfx[nChannel]->stop();
 }
 
 void TonyEngine::preloadSFX(int nChannel, const char *fn) {
 	if (_sfx[nChannel] != NULL) {
-		_sfx[nChannel]->Stop();
-		_sfx[nChannel]->Release();
+		_sfx[nChannel]->stop();
+		_sfx[nChannel]->release();
 		_sfx[nChannel] = NULL;
 	}
 
-	_theSound.CreateSfx(&_sfx[nChannel]);
+	_theSound.createSfx(&_sfx[nChannel]);
 
-	_sfx[nChannel]->LoadFile(fn, FPCODEC_ADPCM);
+	_sfx[nChannel]->loadFile(fn, FPCODEC_ADPCM);
 }
 
-FPSFX *TonyEngine::createSFX(Common::SeekableReadStream *stream) {
-	FPSFX *sfx;
+FPSfx *TonyEngine::createSFX(Common::SeekableReadStream *stream) {
+	FPSfx *sfx;
 
-	_theSound.CreateSfx(&sfx);
+	_theSound.createSfx(&sfx);
 	sfx->loadWave(stream);
 	return sfx;
 }
@@ -370,11 +370,11 @@ void TonyEngine::unloadAllUtilSFX(void) {
 void TonyEngine::initMusic() {
 	int i;
 
-	_theSound.Init(/*_window*/);
-	_theSound.SetMasterVolume(63);
+	_theSound.init(/*_window*/);
+	_theSound.setMasterVolume(63);
 
 	for (i = 0; i < 6; i++)
-		_theSound.CreateStream(&_stream[i]);
+		_theSound.createStream(&_stream[i]);
 
 	for (i = 0; i < MAX_SFX_CHANNELS; i++) {
 		_sfx[i] = _utilSfx[i] = NULL;
@@ -388,14 +388,14 @@ void TonyEngine::initMusic() {
 	preloadUtilSFX(1, "U02.ADP");
 
 	// Start check processes for sound
-	CoroScheduler.createProcess(FPSFX::soundCheckProcess, NULL);
+	CoroScheduler.createProcess(FPSfx::soundCheckProcess, NULL);
 }
 
 void TonyEngine::closeMusic() {
 	for (int i = 0; i < 6; i++) {
-		_stream[i]->Stop();
-		_stream[i]->UnloadFile();
-		_stream[i]->Release();
+		_stream[i]->stop();
+		_stream[i]->unloadFile();
+		_stream[i]->release();
 	}
 
 //	g_system->deleteMutex(csMusic);
diff --git a/engines/tony/tony.h b/engines/tony/tony.h
index 8df2da697c..93232b950d 100644
--- a/engines/tony/tony.h
+++ b/engines/tony/tony.h
@@ -99,8 +99,8 @@ public:
 	uint32 _hEndOfFrame;
 	Common::File _vdbFP;
 	Common::Array<VoiceHeader> _voices;
-	FPSOUND _theSound;
-	Common::List<FPSFX *> _activeSfx;
+	FPSound _theSound;
+	Common::List<FPSfx *> _activeSfx;
 	Globals _globals;
 	Debugger *_debugger;
 
@@ -115,9 +115,9 @@ public:
 		DD_BASE2
 	};
 
-	FPSTREAM *_stream[6];
-	FPSFX *_sfx[MAX_SFX_CHANNELS];
-	FPSFX *_utilSfx[MAX_SFX_CHANNELS];
+	FPStream *_stream[6];
+	FPSfx *_sfx[MAX_SFX_CHANNELS];
+	FPSfx *_utilSfx[MAX_SFX_CHANNELS];
 //	RMFont *_fonts[2];
 	bool _bPaused;
 	bool _bDrawLocation;
@@ -189,7 +189,7 @@ public:
 	void playUtilSFX(int nSfx, int nFX = 0);
 	void stopUtilSFX(int nSfx);
 
-	FPSFX *createSFX(Common::SeekableReadStream *stream);
+	FPSfx *createSFX(Common::SeekableReadStream *stream);
 
 	void preloadSFX(int nSfx, const char *fn);
 	void unloadAllSFX(void);