SWORD25: Got rid of FMODExSound class

svn-id: r53364

11 files changed, 137 insertions, 1712 deletions

diff --git a/engines/sword25/kernel/service_ids.h b/engines/sword25/kernel/service_ids.h
index 7c41fe459e..5ffd83d743 100644
--- a/engines/sword25/kernel/service_ids.h
+++ b/engines/sword25/kernel/service_ids.h
@@ -52,7 +52,7 @@ namespace Sword25 {
 Service *GraphicEngine_CreateObject(Kernel *pKernel);
 Service *PackageManager_CreateObject(Kernel *pKernel);
 Service *InputEngine_CreateObject(Kernel *pKernel);
-Service *FMODExSound_CreateObject(Kernel *pKernel);
+Service *SoundEngine_CreateObject(Kernel *pKernel);
 Service *LuaScriptEngine_CreateObject(Kernel *pKernel);
 Service *Geometry_CreateObject(Kernel *pKernel);
 Service *OggTheora_CreateObject(Kernel *pKernel);
@@ -67,7 +67,7 @@ const BS_ServiceInfo BS_SERVICE_TABLE[] = {
 	BS_ServiceInfo("gfx", "opengl", GraphicEngine_CreateObject),
 	BS_ServiceInfo("package", "archiveFS", PackageManager_CreateObject),
 	BS_ServiceInfo("input", "winapi", InputEngine_CreateObject),
-	BS_ServiceInfo("sfx", "fmodex", FMODExSound_CreateObject),
+	BS_ServiceInfo("sfx", "fmodex", SoundEngine_CreateObject),
 	BS_ServiceInfo("script", "lua", LuaScriptEngine_CreateObject),
 	BS_ServiceInfo("geometry", "std", Geometry_CreateObject),
 	BS_ServiceInfo("fmv", "oggtheora", OggTheora_CreateObject),
diff --git a/engines/sword25/module.mk b/engines/sword25/module.mk
index fc4c6ebf8a..4d3a617cf7 100644
--- a/engines/sword25/module.mk
+++ b/engines/sword25/module.mk
@@ -68,7 +68,6 @@ MODULE_OBJS := \
 	script/luacallback.o \
 	script/luascript.o \
 	script/lua_extensions.o \
-	sfx/fmodexsound.o \
 	sfx/soundengine.o \
 	sfx/soundengine_script.o \
 	util/lua/lapi.o \
diff --git a/engines/sword25/sfx/fmodexchannel.cpp b/engines/sword25/sfx/fmodexchannel.cpp
deleted file mode 100644
index 5214dd7b51..0000000000
--- a/engines/sword25/sfx/fmodexchannel.cpp
+++ /dev/null
@@ -1,279 +0,0 @@
-/* ScummVM - Graphic Adventure Engine
- *
- * ScummVM is the legal property of its developers, whose names
- * are too numerous to list here. Please refer to the COPYRIGHT
- * file distributed with this source distribution.
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version 2
- * of the License, or (at your option) any later version.
-
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
-
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
- *
- * $URL$
- * $Id$
- *
- */
-
-/*
- * This code is based on Broken Sword 2.5 engine
- *
- * Copyright (c) Malte Thiesen, Daniel Queteschiner and Michael Elsdoerfer
- *
- * Licensed under GNU GPL v2
- *
- */
-
-// -----------------------------------------------------------------------------
-// Logging
-// -----------------------------------------------------------------------------
-
-#define BS_LOG_PREFIX "FMODEXCHANNEL"
-
-// -----------------------------------------------------------------------------
-// Includes
-// -----------------------------------------------------------------------------
-
-#include "sword25/sfx/fmodexexception.h"
-#include "sword25/sfx/fmodexchannel.h"
-
-// -----------------------------------------------------------------------------
-// Konstruktion / Destruktion
-// -----------------------------------------------------------------------------
-
-BS_FMODExChannel::BS_FMODExChannel(FMOD_CHANNEL *ChannelPtr, FMOD_SOUND *SoundPtr) :
-	m_ChannelPtr(ChannelPtr),
-	m_SoundPtr(SoundPtr) {
-}
-
-// -----------------------------------------------------------------------------
-
-BS_FMODExChannel::~BS_FMODExChannel() {
-	if (m_ChannelPtr) FMOD_Channel_Stop(m_ChannelPtr);
-	if (m_SoundPtr) FMOD_Sound_Release(m_SoundPtr);
-}
-
-// -----------------------------------------------------------------------------
-// FMOD Ex macht alle Kanäle ungültig, sobald sie nicht mehr abgespielt werden,
-// oder wenn der Kanal in der zwischenzeit neu vergeben wurde.
-// Dann führen alle Aufrufe von Funktionen dieser Kanäle zu dem Fehlern
-// FMOD_ERR_INVALID_HANDLE oder FMOD_ERR_CHANNEL_STOLEN
-// Dieses Soundsystem entfernt aber nur jeden Frame alle toten Kanäle. Daher
-// kann es vorkommen, dass an einem bereits toten Kanal Aufrufe getätigt werden.
-// Diese Fehler werden daher von den folgenden Methoden ignoriert.
-// -----------------------------------------------------------------------------
-
-namespace {
-bool IsImportantError(FMOD_RESULT Result) {
-	return Result != FMOD_OK && Result != FMOD_ERR_INVALID_HANDLE && Result != FMOD_ERR_CHANNEL_STOLEN;
-}
-}
-
-// -----------------------------------------------------------------------------
-// Setter
-// -----------------------------------------------------------------------------
-
-bool BS_FMODExChannel::SetPaused(bool Paused) {
-	BS_ASSERT(m_ChannelPtr);
-
-	FMOD_RESULT Result = FMOD_Channel_SetPaused(m_ChannelPtr, Paused ? 1 : 0);
-	if (IsImportantError(Result)) {
-		BS_FMODExException("FMOD_Channel_SetPaused()", Result).Log();
-		return false;
-	} else
-		return true;
-}
-
-// -----------------------------------------------------------------------------
-
-bool BS_FMODExChannel::SetVolume(float Volume) {
-	BS_ASSERT(m_ChannelPtr);
-
-	FMOD_RESULT Result = FMOD_Channel_SetVolume(m_ChannelPtr, Volume);
-	if (IsImportantError(Result)) {
-		BS_FMODExException("FMOD_Channel_SetVolume()", Result).Log();
-		return false;
-	} else
-		return true;
-}
-
-// -----------------------------------------------------------------------------
-
-bool BS_FMODExChannel::SetPanning(float Panning) {
-	BS_ASSERT(m_ChannelPtr);
-
-	FMOD_RESULT Result = FMOD_Channel_SetPan(m_ChannelPtr, Panning);
-	if (IsImportantError(Result)) {
-		BS_FMODExException("FMOD_Channel_SetPan()", Result).Log();
-		return false;
-	} else
-		return true;
-}
-
-// -----------------------------------------------------------------------------
-
-bool BS_FMODExChannel::SetLoop(bool Loop) {
-	BS_ASSERT(m_ChannelPtr);
-
-	FMOD_RESULT Result = FMOD_Channel_SetLoopCount(m_ChannelPtr, Loop ? -1 : 0);
-	if (IsImportantError(Result)) {
-		BS_FMODExException("FMOD_Channel_SetLoopCount()", Result).Log();
-		return false;
-	} else
-		return true;
-}
-
-// -----------------------------------------------------------------------------
-
-bool BS_FMODExChannel::SetLoopPoints(uint LoopStart, uint LoopEnd) {
-	BS_ASSERT(m_ChannelPtr);
-
-	FMOD_RESULT Result = FMOD_Channel_SetLoopPoints(m_ChannelPtr, LoopStart, FMOD_TIMEUNIT_PCM, LoopEnd, FMOD_TIMEUNIT_PCM);
-	if (IsImportantError(Result)) {
-		BS_FMODExException("FMOD_Channel_SetLoopPoints()", Result).Log();
-		return false;
-	} else
-		return true;
-}
-
-// -----------------------------------------------------------------------------
-
-bool BS_FMODExChannel::SetPosition(uint Position) {
-	BS_ASSERT(m_ChannelPtr);
-
-	FMOD_RESULT Result = FMOD_Channel_SetPosition(m_ChannelPtr, Position, FMOD_TIMEUNIT_PCM);
-	if (IsImportantError(Result)) {
-		BS_FMODExException("FMOD_Channel_SetPosition()", Result).Log();
-		return false;
-	} else
-		return true;
-}
-
-// -----------------------------------------------------------------------------
-
-bool BS_FMODExChannel::Stop() {
-	BS_ASSERT(m_ChannelPtr);
-
-	FMOD_RESULT Result = FMOD_Channel_Stop(m_ChannelPtr);
-	if (IsImportantError(Result)) {
-		BS_FMODExException("FMOD_Channel_Stop()", Result).Log();
-		return false;
-	} else
-		return true;
-}
-
-// -----------------------------------------------------------------------------
-// Getter
-// -----------------------------------------------------------------------------
-
-float BS_FMODExChannel::GetVolume() {
-	BS_ASSERT(m_ChannelPtr);
-
-	float Volume = 0;
-	FMOD_RESULT Result = FMOD_Channel_GetVolume(m_ChannelPtr, &Volume);
-	if (IsImportantError(Result)) BS_FMODExException("FMOD_Channel_GetVolume()", Result).Log();
-
-	return Volume;
-}
-
-// -----------------------------------------------------------------------------
-
-float BS_FMODExChannel::GetPanning() {
-	BS_ASSERT(m_ChannelPtr);
-
-	float Panning = 0;
-	FMOD_RESULT Result = FMOD_Channel_GetPan(m_ChannelPtr, &Panning);
-	if (IsImportantError(Result)) BS_FMODExException("FMOD_Channel_GetPan()", Result).Log();
-
-	return Panning;
-}
-
-// -----------------------------------------------------------------------------
-
-uint BS_FMODExChannel::GetPosition() {
-	BS_ASSERT(m_ChannelPtr);
-
-	uint Position = 0;
-	FMOD_RESULT Result = FMOD_Channel_GetPosition(m_ChannelPtr, &Position, FMOD_TIMEUNIT_PCM);
-	if (IsImportantError(Result)) BS_FMODExException("FMOD_Channel_GetPosition()", Result).Log();
-
-	return Position;
-}
-
-// -----------------------------------------------------------------------------
-
-uint BS_FMODExChannel::GetTime() {
-	BS_ASSERT(m_ChannelPtr);
-
-	uint Time = 0;
-	FMOD_RESULT Result = FMOD_Channel_GetPosition(m_ChannelPtr, &Time, FMOD_TIMEUNIT_MS);
-	if (IsImportantError(Result)) BS_FMODExException("FMOD_Channel_GetPosition()", Result).Log();
-
-	return Time;
-}
-
-// -----------------------------------------------------------------------------
-
-uint BS_FMODExChannel::GetLoopStart() {
-	BS_ASSERT(m_ChannelPtr);
-	uint LoopStart = 0;
-	FMOD_RESULT Result = FMOD_Channel_GetLoopPoints(m_ChannelPtr, &LoopStart, FMOD_TIMEUNIT_PCM, 0, FMOD_TIMEUNIT_PCM);
-	if (IsImportantError(Result)) BS_FMODExException("FMOD_Channel_GetLoopPoints()", Result).Log();
-
-	return LoopStart;
-}
-
-// -----------------------------------------------------------------------------
-
-uint BS_FMODExChannel::GetLoopEnd() {
-	BS_ASSERT(m_ChannelPtr);
-	uint LoopEnd = 0;
-	FMOD_RESULT Result = FMOD_Channel_GetLoopPoints(m_ChannelPtr, 0, FMOD_TIMEUNIT_PCM, &LoopEnd, FMOD_TIMEUNIT_PCM);
-	if (IsImportantError(Result)) BS_FMODExException("FMOD_Channel_GetLoopPoints()", Result).Log();
-
-	return LoopEnd;
-}
-
-// -----------------------------------------------------------------------------
-
-bool BS_FMODExChannel::IsLooping() {
-	BS_ASSERT(m_ChannelPtr);
-
-	int LoopCount = 0;
-	FMOD_RESULT Result = FMOD_Channel_GetLoopCount(m_ChannelPtr, &LoopCount);
-	if (IsImportantError(Result)) BS_FMODExException("FMOD_Channel_GetLoopCount()", Result).Log();
-
-	return LoopCount == -1;
-}
-
-// -----------------------------------------------------------------------------
-
-bool BS_FMODExChannel::IsPaused() {
-	BS_ASSERT(m_ChannelPtr);
-
-	FMOD_BOOL Paused = 0;
-	FMOD_RESULT Result = FMOD_Channel_GetPaused(m_ChannelPtr, &Paused);
-	if (IsImportantError(Result)) BS_FMODExException("FMOD_Channel_GetPaused()", Result).Log();
-
-	return Paused != 0;
-}
-
-// -----------------------------------------------------------------------------
-
-bool BS_FMODExChannel::IsPlaying() {
-	BS_ASSERT(m_ChannelPtr);
-
-	FMOD_BOOL Playing = 0;
-	FMOD_RESULT Result = FMOD_Channel_IsPlaying(m_ChannelPtr, &Playing);
-	if (IsImportantError(Result))   BS_FMODExException("FMOD_Channel_IsPlaying()", Result).Log();
-
-	return Playing != 0;
-}
diff --git a/engines/sword25/sfx/fmodexchannel.h b/engines/sword25/sfx/fmodexchannel.h
deleted file mode 100644
index bada197eb0..0000000000
--- a/engines/sword25/sfx/fmodexchannel.h
+++ /dev/null
@@ -1,83 +0,0 @@
-/* ScummVM - Graphic Adventure Engine
- *
- * ScummVM is the legal property of its developers, whose names
- * are too numerous to list here. Please refer to the COPYRIGHT
- * file distributed with this source distribution.
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version 2
- * of the License, or (at your option) any later version.
-
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
-
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
- *
- * $URL$
- * $Id$
- *
- */
-
-/*
- * This code is based on Broken Sword 2.5 engine
- *
- * Copyright (c) Malte Thiesen, Daniel Queteschiner and Michael Elsdoerfer
- *
- * Licensed under GNU GPL v2
- *
- */
-
-#ifndef SWORD25_FMODEXCHANNEL_H
-#define SWORD25_FMODEXCHANNEL_H
-
-// -----------------------------------------------------------------------------
-// Includes
-// -----------------------------------------------------------------------------
-
-#include "sword25/kernel/common.h"
-
-// -----------------------------------------------------------------------------
-// Forward Declarations
-// -----------------------------------------------------------------------------
-
-struct FMOD_CHANNEL;
-struct FMOD_SOUND;
-
-// -----------------------------------------------------------------------------
-// Klassendefinition
-// -----------------------------------------------------------------------------
-
-class BS_FMODExChannel {
-public:
-	BS_FMODExChannel(FMOD_CHANNEL *ChannelPtr, FMOD_SOUND *SoundPtr);
-	virtual ~BS_FMODExChannel();
-
-	bool SetPaused(bool Paused);
-	bool SetVolume(float Volume);
-	bool SetPanning(float Panning);
-	bool SetLoop(bool Loop);
-	bool SetLoopPoints(uint LoopStart, uint LoopEnd);
-	bool SetPosition(uint Position);
-	bool Stop();
-
-	float           GetVolume();
-	float           GetPanning();
-	uint    GetPosition();
-	uint    GetTime();
-	uint    GetLoopStart();
-	uint    GetLoopEnd();
-	bool            IsLooping();
-	bool            IsPaused();
-	bool            IsPlaying();
-
-private:
-	FMOD_CHANNEL   *m_ChannelPtr;
-	FMOD_SOUND     *m_SoundPtr;
-};
-
-#endif
diff --git a/engines/sword25/sfx/fmodexexception.h b/engines/sword25/sfx/fmodexexception.h
deleted file mode 100644
index 05e6d82310..0000000000
--- a/engines/sword25/sfx/fmodexexception.h
+++ /dev/null
@@ -1,63 +0,0 @@
-/* ScummVM - Graphic Adventure Engine
- *
- * ScummVM is the legal property of its developers, whose names
- * are too numerous to list here. Please refer to the COPYRIGHT
- * file distributed with this source distribution.
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version 2
- * of the License, or (at your option) any later version.
-
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
-
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
- *
- * $URL$
- * $Id$
- *
- */
-
-/*
- * This code is based on Broken Sword 2.5 engine
- *
- * Copyright (c) Malte Thiesen, Daniel Queteschiner and Michael Elsdoerfer
- *
- * Licensed under GNU GPL v2
- *
- */
-
-#ifndef SWORD25_FMODEXEXCEPTION_H
-#define SWROD25_FMODEXEXCEPTION_H
-
-// -----------------------------------------------------------------------------
-// Includes
-// -----------------------------------------------------------------------------
-
-#include "sword25/kernel/common.h"
-
-// -----------------------------------------------------------------------------
-// Klassendefinition
-// -----------------------------------------------------------------------------
-
-class BS_FMODExException {
-public:
-	BS_FMODExException(const char *Function_, FMOD_RESULT Result_) :
-		Function(Function_),
-		Result(Result_) {}
-
-	const char   *Function;
-	FMOD_RESULT   Result;
-
-	void Log() {
-		BS_LOG_ERROR("Call to %s failed.", Function);
-		BS_LOGLN(" FMOD error: %s(%d)", FMOD_ErrorString(Result), Result);
-	}
-};
-
-#endif
diff --git a/engines/sword25/sfx/fmodexresource.cpp b/engines/sword25/sfx/fmodexresource.cpp
deleted file mode 100644
index d4bdbb2887..0000000000
--- a/engines/sword25/sfx/fmodexresource.cpp
+++ /dev/null
@@ -1,170 +0,0 @@
-/* ScummVM - Graphic Adventure Engine
- *
- * ScummVM is the legal property of its developers, whose names
- * are too numerous to list here. Please refer to the COPYRIGHT
- * file distributed with this source distribution.
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version 2
- * of the License, or (at your option) any later version.
-
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
-
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
- *
- * $URL$
- * $Id$
- *
- */
-
-/*
- * This code is based on Broken Sword 2.5 engine
- *
- * Copyright (c) Malte Thiesen, Daniel Queteschiner and Michael Elsdoerfer
- *
- * Licensed under GNU GPL v2
- *
- */
-
-// -----------------------------------------------------------------------------
-// Logging
-// -----------------------------------------------------------------------------
-
-#define BS_LOG_PREFIX "FMODEXRESOURCE"
-
-// -----------------------------------------------------------------------------
-// Includes
-// -----------------------------------------------------------------------------
-
-#include <memory>
-#include "sword25/sfx/fmodexexception.h"
-#include "sword25/sfx/fmodexchannel.h"
-#include "sword25/package/packagemanager.h"
-#include "sword25/sfx/fmodexresource.h"
-
-// -----------------------------------------------------------------------------
-// Konstanten
-// -----------------------------------------------------------------------------
-
-namespace {
-const uint MAX_SAMPLE_SIZE = 100 * 1024; // Die Dateigröße in Byte ab der ein Sound als Stream abgespielt wird
-}
-
-// -----------------------------------------------------------------------------
-// Konstruktion / Destruktion
-// -----------------------------------------------------------------------------
-
-
-BS_FMODExResource::BS_FMODExResource(const std::string &FileName, FMOD_SYSTEM *FMOD, bool &Success) :
-	m_SoundPtr(0),
-	m_SoundDataPtr(0),
-	BS_Resource(FileName, BS_Resource::TYPE_SOUND) {
-	BS_ASSERT(FMOD);
-
-	// Von Misserfolg ausgehen
-	Success = false;
-
-	// Pointer auf den Package-Manager bekommen
-	BS_PackageManager *PackagePtr = BS_Kernel::GetInstance()->GetPackage();
-	if (!PackagePtr) {
-		BS_LOG_ERRORLN("Package manager not found.");
-		return;
-	}
-
-	// Datei laden
-	uint FileSize;
-	char *FileDataPtr = (char *) PackagePtr->GetFile(GetFileName(), &FileSize);
-	if (!FileDataPtr) {
-		BS_LOG_ERRORLN("File \"%s\" could not be loaded.", GetFileName().c_str());
-		return;
-	}
-
-	// Ob die Sounddatei als Sample oder als Stream behandelt wird, ist abhängig von der Dateigröße.
-	// Samples werden sofort intialisiert.
-	// Für Streams wird hingegen bei jedem Abspielen ein neuer Sound erstellt. Dieses Vorgehen ist notwendig, da FMOD Ex Samples beliebig oft
-	// gleichzeitig abspielen kann, Streams jedoch nur ein mal.
-	if (FileSize <= MAX_SAMPLE_SIZE) {
-		FMOD_CREATESOUNDEXINFO ExInfo;
-		memset(&ExInfo, 0, sizeof(ExInfo));
-		ExInfo.cbsize = sizeof(ExInfo);
-		ExInfo.length = FileSize;
-
-		FMOD_RESULT Result = FMOD_System_CreateSound(FMOD, FileDataPtr,
-		                     FMOD_CREATESAMPLE | FMOD_OPENMEMORY | FMOD_SOFTWARE | FMOD_2D | FMOD_LOOP_NORMAL,
-		                     &ExInfo,
-		                     &m_SoundPtr);
-		if (Result != FMOD_OK) BS_FMODExException("FMOD_System_CreateSound()", Result).Log();
-
-		Success = Result == FMOD_OK;
-
-		delete FileDataPtr;
-	} else {
-		m_SoundDataPtr = FileDataPtr;
-		m_SoundDataSize = FileSize;
-
-		Success = true;
-	}
-}
-
-// -----------------------------------------------------------------------------
-
-BS_FMODExResource::~BS_FMODExResource() {
-	// Sound freigeben, solange des Soundsystem noch läuft.
-	// Sollte das Soundsystem beendet worden sein müssen und können Sounds nicht mehr freigegeben werden.
-	if (m_SoundPtr && BS_Kernel::GetInstance()->GetService("sfx")) FMOD_Sound_Release(m_SoundPtr);
-	if (m_SoundDataPtr) delete [] m_SoundDataPtr;
-}
-
-// -----------------------------------------------------------------------------
-// Abspielen
-// -----------------------------------------------------------------------------
-
-BS_FMODExChannel *BS_FMODExResource::StartSound(FMOD_SYSTEM *FMOD) {
-	BS_ASSERT(FMOD);
-
-	FMOD_CHANNEL *NewChannelPtr;
-	FMOD_SOUND    *NewSoundPtr = 0;
-
-	// Sample können sofort abgespielt werden.
-	if (m_SoundPtr) {
-		FMOD_RESULT Result = FMOD_System_PlaySound(FMOD, FMOD_CHANNEL_FREE, m_SoundPtr, 1, &NewChannelPtr);
-		if (Result != FMOD_OK) {
-			BS_FMODExException("FMOD_System_PlaySound()", Result).Log();
-			return 0;
-		}
-	}
-	// Für Streams muss ein neuer Sound erstellt werden.
-	else {
-		FMOD_CREATESOUNDEXINFO ExInfo;
-		memset(&ExInfo, 0, sizeof(ExInfo));
-		ExInfo.cbsize = sizeof(ExInfo);
-		ExInfo.length = m_SoundDataSize;
-
-		FMOD_RESULT Result;
-		Result = FMOD_System_CreateSound(FMOD,
-		                                 m_SoundDataPtr,
-		                                 FMOD_CREATESTREAM | FMOD_OPENMEMORY_POINT | FMOD_SOFTWARE | FMOD_2D | FMOD_LOOP_NORMAL,
-		                                 &ExInfo,
-		                                 &NewSoundPtr);
-		if (Result != FMOD_OK) {
-			BS_FMODExException("FMOD_System_CreateSound()", Result).Log();
-			return 0;
-		}
-
-		Result = FMOD_System_PlaySound(FMOD, FMOD_CHANNEL_FREE, NewSoundPtr, 1, &NewChannelPtr);
-		if (Result != FMOD_OK) {
-			BS_FMODExException("FMOD_System_PlaySound()", Result).Log();
-			return 0;
-		}
-	}
-
-	// Der Channel und der Sound (bei Streams) werden an ein BS_FMODExChannel-Objekt übergeben.
-	// Dieses Sorgt auch dafür, dass Channel und Sound korrekt zerstört werden.
-	return new BS_FMODExChannel(NewChannelPtr, NewSoundPtr);
-}
diff --git a/engines/sword25/sfx/fmodexresource.h b/engines/sword25/sfx/fmodexresource.h
deleted file mode 100644
index f74fef5365..0000000000
--- a/engines/sword25/sfx/fmodexresource.h
+++ /dev/null
@@ -1,70 +0,0 @@
-/* ScummVM - Graphic Adventure Engine
- *
- * ScummVM is the legal property of its developers, whose names
- * are too numerous to list here. Please refer to the COPYRIGHT
- * file distributed with this source distribution.
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version 2
- * of the License, or (at your option) any later version.
-
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
-
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
- *
- * $URL$
- * $Id$
- *
- */
-
-/*
- * This code is based on Broken Sword 2.5 engine
- *
- * Copyright (c) Malte Thiesen, Daniel Queteschiner and Michael Elsdoerfer
- *
- * Licensed under GNU GPL v2
- *
- */
-
-#ifndef SWORD25_FMODRESOURCE_H
-#define SWORD25_FMODRESOURCE_H
-
-// -----------------------------------------------------------------------------
-// Includes
-// -----------------------------------------------------------------------------
-
-#include "sword25/kernel/common.h"
-#include "sword25/kernel/resource.h"
-
-// -----------------------------------------------------------------------------
-// Forward Declarations
-// -----------------------------------------------------------------------------
-
-class BS_FMODExChannel;
-struct FMOD_SOUND;
-struct FMOD_SYSTEM;
-
-// -----------------------------------------------------------------------------
-// Klassendefinition
-// -----------------------------------------------------------------------------
-
-class BS_FMODExResource : public BS_Resource {
-public:
-	BS_FMODExResource(const std::string &FileName, FMOD_SYSTEM *FMOD, bool &Success);
-	virtual ~BS_FMODExResource();
-
-	BS_FMODExChannel   *StartSound(FMOD_SYSTEM *FMOD);
-
-private:
-	FMOD_SOUND     *m_SoundPtr;
-	char           *m_SoundDataPtr;
-	uint    m_SoundDataSize;
-};
-
-#endif
diff --git a/engines/sword25/sfx/fmodexsound.cpp b/engines/sword25/sfx/fmodexsound.cpp
deleted file mode 100644
index c67db28401..0000000000
--- a/engines/sword25/sfx/fmodexsound.cpp
+++ /dev/null
@@ -1,886 +0,0 @@
-/* ScummVM - Graphic Adventure Engine
- *
- * ScummVM is the legal property of its developers, whose names
- * are too numerous to list here. Please refer to the COPYRIGHT
- * file distributed with this source distribution.
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version 2
- * of the License, or (at your option) any later version.
-
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
-
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
- *
- * $URL$
- * $Id$
- *
- */
-
-/*
- * This code is based on Broken Sword 2.5 engine
- *
- * Copyright (c) Malte Thiesen, Daniel Queteschiner and Michael Elsdoerfer
- *
- * Licensed under GNU GPL v2
- *
- */
-
-// Die von der Engine ausgegebenen Soundhandles werden intern auf FMOD Ex Handles gemapped.
-// Diese Handles sind nur solange gültig, wie der Sound spielt. Falls danach versucht wird manipulierend auf den Sound zuzugreifen,
-// schlägt dieses ohne Fehlermeldung fehl.
-
-// -----------------------------------------------------------------------------
-// Logging
-// -----------------------------------------------------------------------------
-
-#define BS_LOG_PREFIX "FMODEXSOUND"
-
-// -----------------------------------------------------------------------------
-// Includes
-// -----------------------------------------------------------------------------
-
-#include "sword25/kernel/inputpersistenceblock.h"
-#include "sword25/kernel/outputpersistenceblock.h"
-#include "sword25/package/packagemanager.h"
-#include "sword25/sfx/fmodexsound.h"
-
-// -----------------------------------------------------------------------------
-// Konstanten und lokale Funktionen
-// -----------------------------------------------------------------------------
-
-namespace Sword25 {
-const float         DEFAULT_MUSIC_VOLUME = 1.0f;
-const float         DEFAULT_SPEECH_VOLUME = 1.0f;
-const float         DEFAULT_SFX_VOLUME = 1.0f;
-const uint  SOUNDTYPE_COUNT = 3;
-const uint  INVALID_SOUND_HANDLE = 0xffffffff;
-
-// -------------------------------------------------------------------------
-
-#if 0
-inline float NormalizePanning(float Panning) {
-	bool Corrected = false;
-	float Result = Panning;
-	if (Result > 1.0f) {
-		Result = 1.0f;
-		Corrected = true;
-	}
-	if (Result < -1.0f) {
-		Result = -1.0f;
-		Corrected = true;
-	}
-
-	if (Corrected) BS_LOG_WARNINGLN("Tried to set an invalid panning value of %.2f. It was corrected to %.2f", Panning, Result);
-
-	return Result;
-}
-
-// -------------------------------------------------------------------------
-
-inline float NormalizeVolume(float Volume) {
-	bool Corrected = false;
-	float Result = Volume;
-	if (Result > 1.0f) {
-		Result = 1.0f;
-		Corrected = true;
-	}
-	if (Result < 0.0f) {
-		Result = 0.0f;
-		Corrected = true;
-	}
-
-	if (Corrected) BS_LOG_WARNINGLN("Tried to set an invalid volume value of %.2f. It was corrected to %.2f", Volume, Result);
-
-	return Result;
-}
-
-// -------------------------------------------------------------------------
-
-inline FMOD_SOUND_FORMAT BitsPerSampleToFMODExSoundFormat(uint BitsPerSample) {
-	switch (BitsPerSample) {
-	case 8:
-		return FMOD_SOUND_FORMAT_PCM8;
-	case 16:
-		return FMOD_SOUND_FORMAT_PCM16;
-	case 24:
-		return FMOD_SOUND_FORMAT_PCM24;
-	case 32:
-		return FMOD_SOUND_FORMAT_PCM32;
-	default:
-		return FMOD_SOUND_FORMAT_NONE;
-	}
-}
-
-#endif
-
-FMODExSound::FMODExSound(Kernel *pKernel) :
-	SoundEngine(pKernel)
-	/*	m_FMOD(0), 
-		m_NextHandle(1) */ {
-	// Lautstärkeneinstellungen auf die Standardwerte setzen
-#if 0
-	m_Volumes[MUSIC] = DEFAULT_MUSIC_VOLUME;
-	m_Volumes[SPEECH] = DEFAULT_SPEECH_VOLUME;
-	m_Volumes[SFX] = DEFAULT_SFX_VOLUME;
-#endif
-}
-
-// -----------------------------------------------------------------------------
-
-FMODExSound::~FMODExSound() {
-#if 0
-	// Alle noch spielenden Sounds stoppen und die Ressourcen freigeben
-	for (PSM_ITER it = m_PlayingSoundsMap.begin(); it != m_PlayingSoundsMap.end(); ++it) {
-		if (it->second.ChannelPtr) delete it->second.ChannelPtr;
-		if (it->second.ResourcePtr) it->second.ResourcePtr->Release();
-	}
-
-	// FMOD Ex deinitialisieren
-	if (m_FMOD) FMOD_System_Release(m_FMOD);
-#endif
-}
-
-// -----------------------------------------------------------------------------
-
-Service *FMODExSound_CreateObject(Kernel *pKernel) {
-	return new FMODExSound(pKernel);
-}
-
-// -----------------------------------------------------------------------------
-
-bool FMODExSound::Init(uint SampleRate, uint Channels) {
-#if 0
-	// Eine Warnung ausgeben, wenn dieser Service schon initialisiert wurde.
-	// Allerdings wird trotzdem true zurückgegeben, weil kein Fehler aufgetreten ist, der Service ist noch benutzbar.
-	if (m_FMOD) {
-		BS_LOG_WARNINGLN("Tried to initialize again. Call ignored.");
-		return true;
-	} else {
-		try {
-			// Die FMOD Ex mit den übergebenen Werte initialisieren
-			FMOD_RESULT Result = FMOD_System_Create(&m_FMOD);
-			if (Result != FMOD_OK) throw(BS_FMODExException("FMOD_System_Create()", Result));
-
-			Result = FMOD_System_SetSoftwareFormat(m_FMOD, SampleRate, FMOD_SOUND_FORMAT_PCM16, 0, 0, FMOD_DSP_RESAMPLER_LINEAR);
-			if (Result != FMOD_OK) throw(BS_FMODExException("FMOD_System_SetSoftwareFormat()", Result));
-
-			Result = FMOD_System_Init(m_FMOD, Channels, FMOD_INIT_NORMAL, 0);
-			if (Result != FMOD_OK) throw(BS_FMODExException("FMOD_System_Init()", Result));
-		}
-
-		catch (BS_FMODExException Ex) {
-			Ex.Log();
-			BS_LOG_ERRORLN("FMOD Ex could not be initialized.");
-
-			if (m_FMOD) {
-				FMOD_System_Release(m_FMOD);
-				m_FMOD = 0;
-			}
-
-			return false;
-		}
-
-		BS_LOGLN("FMOD Ex initialized. Sample rate: %d / Channels: %d", SampleRate, Channels);
-		return true;
-	}
-#else
-	return true;
-#endif
-}
-
-// -----------------------------------------------------------------------------
-
-void FMODExSound::Update() {
-#if 0
-	BS_ASSERT(m_FMOD);
-
-	FMOD_RESULT Result = FMOD_System_Update(m_FMOD);
-	if (Result != FMOD_OK) BS_FMODExException("FMOD_System_Update()", Result).Log();
-
-	RemoveInactiveSounds();
-#endif
-}
-
-// -----------------------------------------------------------------------------
-// Sounds abspielen
-// -----------------------------------------------------------------------------
-
-bool FMODExSound::PlaySound(const Common::String &FileName,
-                               SOUND_TYPES Type,
-                               float Volume,
-                               float Pan,
-                               bool Loop,
-                               int LoopStart, int LoopEnd,
-                               uint Layer) {
-#if 0
-	return PlaySoundInternal(FileName, Type, Volume, Pan, Loop, LoopStart, LoopEnd, Layer, 0, 0) != 0;
-#else
-	return true;
-#endif
-}
-
-// -----------------------------------------------------------------------------
-
-uint FMODExSound::PlaySoundEx(const Common::String &FileName,
-        SOUND_TYPES Type,
-        float Volume,
-        float Pan,
-        bool Loop,
-        int LoopStart, int LoopEnd,
-        uint Layer) {
-#if 0
-	return PlaySoundInternal(FileName, Type, Volume, Pan, Loop, LoopStart, LoopEnd, Layer, 0, 0);
-#else
-	return true;
-#endif
-}
-
-// -------------------------------------------------------------------------
-
-#if 0
-FMOD_RESULT F_CALLBACK BS_FMODExSound::FMODExDynamicSoundSetPosCallback(FMOD_SOUND *sound, int subsound, uint position, FMOD_TIMEUNIT postype) {
-	// In dynamischen Sounds wird nicht gesprungen, daher tut dieses Funktion nichts.
-	return FMOD_OK;
-}
-
-// -------------------------------------------------------------------------
-
-FMOD_RESULT F_CALLBACK BS_FMODExSound::FMODExDynamicSoundReadCallback(FMOD_SOUND *sound, void *data, uint datalen) {
-	// Handle auf das aktuelle Soundsystem holen, dies ist wohl dieses hier.
-	BS_FMODExSound *t = reinterpret_cast<BS_FMODExSound *>(BS_Kernel::GetInstance()->GetSfx());
-
-	// Handle auf den richtigen Sound holen, wurde als FMOD Ex Benutzerdaten gesetzt.
-	uint Handle;
-	FMOD_RESULT Result = FMOD_Sound_GetUserData(sound, reinterpret_cast<void **>(&Handle));
-	if (Result != FMOD_OK) {
-		BS_FMODExException("FMOD_Sound_GetUserData()", Result).Log();
-		return FMOD_OK;
-	}
-
-	// Sounddaten holen und Callbackfunktion aufrufen.
-	PlayingSoundData *PSD = t->GetPlayingSoundDataByHandle(Handle);
-	if (PSD) PSD->ReadCallback(PSD->UserData, data, datalen);
-
-	return FMOD_OK;
-}
-#endif
-// -----------------------------------------------------------------------------
-
-uint FMODExSound::PlayDynamicSoundEx(DynamicSoundReadCallback ReadCallback,
-        void *UserData,
-        SOUND_TYPES Type,
-        uint SampleRate,
-        uint BitsPerSample,
-        uint Channels,
-        float Volume,
-        float Pan,
-        uint Layer) {
-#if 0
-	// Parameter überprüfen
-	if (BitsPerSampleToFMODExSoundFormat(BitsPerSample) == FMOD_SOUND_FORMAT_NONE) {
-		BS_LOG_ERRORLN("Cannot create a dynamic sound with %d bits per sample.", BitsPerSample);
-		return 0;
-	}
-	if (Channels == 0 || Channels > 2) {
-		BS_LOG_ERRORLN("Cannot create a dynamic sound with %d channels.", Channels);
-		return 0;
-	}
-
-	// Zu vergebendes Handle bestimmen
-	uint Handle = m_NextHandle++;
-
-	// Sound in die Sound-Map eintragen mit all den Informationen, die wir bisher haben.
-	// Dies muss für dynamische Sounds so früh geschehen, da sofort nach dem Aufruf von FMOD_System_CreateSound der Callback aufgerufen wird um
-	// den Decode-Buffer zu füllen. Unser Callback liest den BS-Callback aus der Sound-Map. Wenn wir den Sound später hinzufügen würden, würde der
-	// BS-Callback zu diesem Sound nicht in der Map stehen und nicht aufgerufen werden können.
-	// Den fehlenden ChannelPtr tragen wir später in dieser Funktion ein.
-	m_PlayingSoundsMap[Handle] = PlayingSoundData(0, 0, Type, Layer, Volume, ReadCallback, UserData);
-
-	// Dynamischen FMOD Ex Sound erstellen
-	FMOD_CREATESOUNDEXINFO CreateSoundExInfo;
-	memset(&CreateSoundExInfo, 0, sizeof(FMOD_CREATESOUNDEXINFO));
-	CreateSoundExInfo.cbsize            = sizeof(FMOD_CREATESOUNDEXINFO);
-	CreateSoundExInfo.length            = 0xffffffff;
-	CreateSoundExInfo.numchannels       = Channels;
-	CreateSoundExInfo.defaultfrequency  = SampleRate;
-	CreateSoundExInfo.format            = BitsPerSampleToFMODExSoundFormat(BitsPerSample);
-	CreateSoundExInfo.pcmreadcallback   = FMODExDynamicSoundReadCallback;
-	CreateSoundExInfo.pcmsetposcallback = FMODExDynamicSoundSetPosCallback;
-	CreateSoundExInfo.userdata          = reinterpret_cast<void *>(Handle);
-
-	FMOD_SOUND *FMODExSoundPtr;
-	FMOD_RESULT Result = FMOD_System_CreateSound(m_FMOD,
-	                     0,
-	                     FMOD_2D | FMOD_OPENUSER | FMOD_LOOP_NORMAL | FMOD_HARDWARE | FMOD_CREATESTREAM,
-	                     &CreateSoundExInfo,
-	                     &FMODExSoundPtr);
-	if (Result != FMOD_OK) {
-		BS_FMODExException("FMOD_System_CreateSound() from PlayDynamicSoundEx()", Result).Log();
-		return 0;
-	}
-
-	// Neu erstellten Sound einem Kanal zuweisen
-	FMOD_CHANNEL *FMODExChannelPtr;
-	Result = FMOD_System_PlaySound(m_FMOD, FMOD_CHANNEL_FREE, FMODExSoundPtr, 1, &FMODExChannelPtr);
-	if (Result != FMOD_OK) {
-		BS_FMODExException("FMOD_System_PlaySound() from PlayDynamicSoundEx()", Result).Log();
-		return 0;
-	}
-
-	// FMOD Ex Kanal an einen BS_FMODExChannel binden und abspielen
-	BS_FMODExChannel *ChannelPtr = new BS_FMODExChannel(FMODExChannelPtr, FMODExSoundPtr);
-	ChannelPtr->SetPaused(false);
-
-	// ChannelPtr in die PlayingSoundData-Struktur eintragen
-	PlayingSoundData *PSD = GetPlayingSoundDataByHandle(Handle);
-	if (PSD) PSD->ChannelPtr = ChannelPtr;
-
-	return Handle;
-#else
-	return 0;
-#endif
-}
-
-// -----------------------------------------------------------------------------
-
-#if 0
-uint BS_FMODExSound::PlaySoundInternal(const Common::String &FileName,
-        SOUND_TYPES Type,
-        float Volume,
-        float Pan,
-        bool Loop,
-        int LoopStart, int LoopEnd,
-        uint Layer,
-        uint Position,
-        uint Handle) {
-	BS_ASSERT(m_FMOD);
-	BS_ASSERT(Type < SOUNDTYPE_COUNT);
-
-	// Resource anfordern
-	BS_Resource *ResourcePtr = BS_Kernel::GetInstance()->GetResourceManager()->RequestResource(FileName);
-	if (!ResourcePtr) {
-		BS_LOG_ERRORLN("Could not request resource \"%s\".", FileName.c_str());
-		return 0;
-	}
-	if (ResourcePtr->GetType() != BS_Resource::TYPE_SOUND) {
-		BS_LOG_ERRORLN("Requested resource \"%s\" is not a sound.", FileName.c_str());
-		return 0;
-	}
-	BS_FMODExResource *SoundResourcePtr = static_cast<BS_FMODExResource *>(ResourcePtr);
-
-	// Sound im Pause-Modus starten
-	BS_FMODExChannel *ChannelPtr = SoundResourcePtr->StartSound(m_FMOD);
-
-	if (ChannelPtr) {
-		try {
-			// Falls der Sound gelooped wird, Loop-Points setzen
-			if (Loop) {
-				// Bestimmen, welche Loop-Points benutzt werden. Falls ein Loop-Point als Parameter nicht spezifiziert wurde (Wert -1),
-				// wird der Loop-Point von FMOD Ex benutzt.
-				uint RealLoopStart = (LoopStart > 0) ? LoopStart : ChannelPtr->GetLoopStart();
-				uint RealLoopEnd = (LoopEnd > 0) ? LoopEnd : ChannelPtr->GetLoopEnd();
-
-				// Loop-Points auf Gültigkeit überprüfen
-				if (RealLoopStart > RealLoopEnd) {
-					BS_LOG_ERRORLN("Loop start (%d) was placed after loop end (%d) for sound \"%s\".",
-					               RealLoopStart, RealLoopEnd,
-					               SoundResourcePtr->GetFileName().c_str());
-					throw(0);
-				}
-				if (RealLoopStart > ChannelPtr->GetLoopEnd()) {
-					BS_LOG_ERRORLN("Loop start (%d) was placed after end (%d) of sound \"%s\".",
-					               RealLoopStart,
-					               ChannelPtr->GetLoopEnd(),
-					               SoundResourcePtr->GetFileName().c_str());
-					throw(0);
-				}
-				if (RealLoopEnd > ChannelPtr->GetLoopEnd()) {
-					BS_LOG_ERRORLN("Loop end (%d) was placed after end (%d) of sound \"%s\".",
-					               RealLoopEnd,
-					               ChannelPtr->GetLoopEnd(),
-					               SoundResourcePtr->GetFileName().c_str());
-					throw(0);
-				}
-
-				// Loop-Points setzen
-				if (!ChannelPtr->SetLoopPoints(RealLoopStart, RealLoopEnd)) throw(0);
-			}
-
-			// Sound-Parameter gemäß der Übergabeparameter setzen
-			if (!ChannelPtr->SetVolume(NormalizeVolume(Volume) * m_Volumes[Type])) throw(0);
-			if (!ChannelPtr->SetPanning(NormalizePanning(Pan))) throw(0);
-			if (!ChannelPtr->SetLoop(Loop)) throw(0);
-			if (!ChannelPtr->SetPosition(Position)) throw(0);
-		} catch (...) {
-			delete ChannelPtr;
-			SoundResourcePtr->Release();
-			return 0;
-		}
-
-		uint MyLoopStart = ChannelPtr->GetLoopStart();
-		uint MyLoopEnd = ChannelPtr->GetLoopEnd();
-		ChannelPtr->SetLoopPoints(MyLoopStart, MyLoopEnd);
-
-		// Sound abspielen
-		ChannelPtr->SetPaused(false);
-
-		// Sound in die Sound-Map eintragen
-		uint NewHandle = (Handle != 0) ? Handle : m_NextHandle++;
-		m_PlayingSoundsMap[NewHandle] = PlayingSoundData(SoundResourcePtr, ChannelPtr, Type, Layer, Volume);
-
-		return NewHandle;
-	} else {
-		SoundResourcePtr->Release();
-		return 0;
-	}
-}
-#endif
-// -----------------------------------------------------------------------------
-// Sonstige Methoden
-// -----------------------------------------------------------------------------
-
-void FMODExSound::SetVolume(float Volume, SOUND_TYPES Type) {
-#if 0
-	BS_ASSERT(m_FMOD);
-	BS_ASSERT(Type < SOUNDTYPE_COUNT);
-	m_Volumes[Type] = NormalizeVolume(Volume);
-
-	// Alle Volumen der Sounds der Kategorie aktualisieren
-	PSM_CONST_ITER it = m_PlayingSoundsMap.begin();
-	while (it != m_PlayingSoundsMap.end()) {
-		const PlayingSoundData &PSD = it->second;
-		if (PSD.ChannelPtr && PSD.Type == Type) PSD.ChannelPtr->SetVolume(Volume * PSD.Volume);
-
-		++it;
-	}
-#endif
-}
-
-// -----------------------------------------------------------------------------
-
-float FMODExSound::GetVolume(SOUND_TYPES Type) {
-#if 0
-	BS_ASSERT(m_FMOD);
-	BS_ASSERT(Type < SOUNDTYPE_COUNT);
-	return m_Volumes[Type];
-#else
-	return 0;
-#endif
-}
-
-// -----------------------------------------------------------------------------
-
-void FMODExSound::PauseAll() {
-#if 0
-	BS_ASSERT(m_FMOD);
-
-	// Alle Sounds durchgehen und alle pausieren.
-	// Diese werden dann markiert, damit ResumeAll() feststellen kann, welche Sounds mit PauseAll() pausiert wurden.
-	// ResumeAll() setzt dann nur diejenigen fort, die nur über PauseAll() pausiert wurden.
-	PSM_ITER it = m_PlayingSoundsMap.begin();
-	while (it != m_PlayingSoundsMap.end()) {
-		PlayingSoundData &PSD = it->second;
-
-		if (PSD.ChannelPtr) PSD.ChannelPtr->SetPaused(true);
-		PSD.PausedGlobal = true;
-
-		++it;
-	}
-#endif
-}
-
-// -----------------------------------------------------------------------------
-
-void FMODExSound::ResumeAll() {
-#if 0
-	BS_ASSERT(m_FMOD);
-
-	// Alle Sounds durchgehen, die gloable Pause aufheben und diejenigen fortsetzen,
-	// die keine Pause mehr haben (weder explizit, über den Layer oder global).
-	PSM_ITER it = m_PlayingSoundsMap.begin();
-	while (it != m_PlayingSoundsMap.end()) {
-		PlayingSoundData &PSD = it->second;
-
-		if (PSD.PausedGlobal) {
-			PSD.PausedGlobal = false;
-			if (PSD.ChannelPtr && !PSD.PausedLayer && !PSD.Paused) PSD.ChannelPtr->SetPaused(false);
-		}
-
-		++it;
-	}
-#endif
-}
-
-// -----------------------------------------------------------------------------
-
-void FMODExSound::PauseLayer(uint Layer) {
-#if 0
-	BS_ASSERT(m_FMOD);
-
-	// Alle Sounds durchgehen und alle pausieren, die sich auf den angegebenen Layer befinden.
-	// Diese werden dann markiert, damit ResumeLayer() feststellen kann, welche Sounds mit PauseLayer() pausiert wurden.
-	// ResumeLayer() setzt dann nur diejenigen fort, die nur über PauseLayer() mit der entsprechenden Layer-Nummer pausiert wurden.
-	PSM_ITER it = m_PlayingSoundsMap.begin();
-	while (it != m_PlayingSoundsMap.end()) {
-		PlayingSoundData &PSD = it->second;
-
-		if (PSD.Layer == Layer) {
-			if (PSD.ChannelPtr) PSD.ChannelPtr->SetPaused(true);
-			PSD.PausedLayer = true;
-		}
-
-		++it;
-	}
-#endif
-}
-
-// -----------------------------------------------------------------------------
-
-void FMODExSound::ResumeLayer(uint Layer) {
-#if 0
-	BS_ASSERT(m_FMOD);
-
-	// Alle Sounds durchgehen, die Layer-Pause aufheben und diejenigen fortsetzen,
-	// die keine Pause mehr haben (weder explizit, über den Layer oder global).
-	PSM_ITER it = m_PlayingSoundsMap.begin();
-	while (it != m_PlayingSoundsMap.end()) {
-		PlayingSoundData &PSD = it->second;
-
-		if (PSD.PausedLayer && PSD.Layer == Layer) {
-			PSD.PausedLayer = false;
-			if (PSD.ChannelPtr && !PSD.PausedGlobal && !PSD.Paused) PSD.ChannelPtr->SetPaused(false);
-		}
-
-		++it;
-	}
-#endif
-}
-
-// -----------------------------------------------------------------------------
-// Sound Setter
-// -----------------------------------------------------------------------------
-
-void FMODExSound::SetSoundVolume(uint Handle, float Volume) {
-#if 0
-	BS_ASSERT(m_FMOD);
-	PlayingSoundData *PSDPtr = GetPlayingSoundDataByHandle(Handle);
-	if (PSDPtr) if (PSDPtr->ChannelPtr && PSDPtr->ChannelPtr->SetVolume(NormalizeVolume(Volume) * m_Volumes[PSDPtr->Type])) PSDPtr->Volume = Volume;
-#endif
-}
-
-// -----------------------------------------------------------------------------
-
-void FMODExSound::SetSoundPanning(uint Handle, float Pan) {
-#if 0
-	BS_ASSERT(m_FMOD);
-	PlayingSoundData *PSDPtr = GetPlayingSoundDataByHandle(Handle);
-	if (PSDPtr && PSDPtr->ChannelPtr) PSDPtr->ChannelPtr->SetPanning(NormalizePanning(Pan));
-#endif
-}
-
-// -----------------------------------------------------------------------------
-
-void FMODExSound::PauseSound(uint Handle) {
-#if 0
-	BS_ASSERT(m_FMOD);
-	PlayingSoundData *PSDPtr = GetPlayingSoundDataByHandle(Handle);
-	if (PSDPtr) {
-		PSDPtr->Paused = true;
-		if (PSDPtr->ChannelPtr) PSDPtr->ChannelPtr->SetPaused(true);
-	}
-#endif
-}
-
-// -----------------------------------------------------------------------------
-
-void FMODExSound::ResumeSound(uint Handle) {
-#if 0
-	BS_ASSERT(m_FMOD);
-	PlayingSoundData *PSDPtr = GetPlayingSoundDataByHandle(Handle);
-	if (PSDPtr) {
-		PSDPtr->Paused = false;
-		if (PSDPtr->ChannelPtr && !PSDPtr->PausedGlobal && !PSDPtr->PausedLayer) PSDPtr->ChannelPtr->SetPaused(false);
-	}
-#endif
-}
-
-// -----------------------------------------------------------------------------
-
-void FMODExSound::StopSound(uint Handle) {
-#if 0
-	BS_ASSERT(m_FMOD);
-	PlayingSoundData *PSDPtr = GetPlayingSoundDataByHandle(Handle);
-	if (PSDPtr && PSDPtr->ChannelPtr) PSDPtr->ChannelPtr->Stop();
-#endif
-}
-
-// -----------------------------------------------------------------------------
-// Sound Getter
-// -----------------------------------------------------------------------------
-
-bool FMODExSound::IsSoundPaused(uint Handle) {
-#if 0
-	BS_ASSERT(m_FMOD);
-	PlayingSoundData *PSDPtr = GetPlayingSoundDataByHandle(Handle);
-	if (PSDPtr && PSDPtr->ChannelPtr) return PSDPtr->ChannelPtr->IsPaused();
-#endif
-	return false;
-}
-
-// -----------------------------------------------------------------------------
-
-bool FMODExSound::IsSoundPlaying(uint Handle) {
-#if 0
-	BS_ASSERT(m_FMOD);
-	PlayingSoundData *PSDPtr = GetPlayingSoundDataByHandle(Handle);
-	if (PSDPtr && PSDPtr->ChannelPtr) return PSDPtr->ChannelPtr->IsPlaying();
-#endif
-	return false;
-}
-
-// -----------------------------------------------------------------------------
-
-float FMODExSound::GetSoundVolume(uint Handle) {
-#if 0
-	BS_ASSERT(m_FMOD);
-	PlayingSoundData *PSDPtr = GetPlayingSoundDataByHandle(Handle);
-	if (PSDPtr) return PSDPtr->Volume;
-#endif
-	return 0;
-}
-
-// -----------------------------------------------------------------------------
-
-float FMODExSound::GetSoundPanning(uint Handle) {
-#if 0
-	BS_ASSERT(m_FMOD);
-	PlayingSoundData *PSDPtr = GetPlayingSoundDataByHandle(Handle);
-	if (PSDPtr && PSDPtr->ChannelPtr) return PSDPtr->ChannelPtr->GetPanning();
-#endif
-	return 0;
-}
-
-// -----------------------------------------------------------------------------
-
-float FMODExSound::GetSoundTime(uint Handle) {
-#if 0
-	BS_ASSERT(m_FMOD);
-	PlayingSoundData *PSDPtr = GetPlayingSoundDataByHandle(Handle);
-	if (PSDPtr && PSDPtr->ChannelPtr) return static_cast<float>(PSDPtr->ChannelPtr->GetTime()) / 1000.0f;
-#endif
-	return 0;
-}
-
-#if 0
-void BS_FMODExSound::RemoveInactiveSounds() {
-	PSM_ITER it = m_PlayingSoundsMap.begin();
-	while (it != m_PlayingSoundsMap.end()) {
-		if (!it->second.ChannelPtr || !it->second.ChannelPtr->IsPlaying()) {
-			PlayingSoundData &PSD = it->second;
-
-			delete PSD.ChannelPtr;
-			if (PSD.ResourcePtr) PSD.ResourcePtr->Release();
-
-			it = m_PlayingSoundsMap.erase(it);
-		} else
-			++it;
-	}
-
-	/*
-	static size_t lastActiveChannels = 0;
-	if (m_PlayingSoundsMap.size() != lastActiveChannels)
-	{
-	    BS_LOGLN("Aktive Kanaele: %d", m_PlayingSoundsMap.size());
-	    lastActiveChannels = m_PlayingSoundsMap.size();
-	}
-	*/
-}
-
-// -----------------------------------------------------------------------------
-
-BS_FMODExSound::PlayingSoundData *BS_FMODExSound::GetPlayingSoundDataByHandle(uint Handle) {
-	// Zum Soundhandle gehörige Daten in der Hash-Map finden
-	PSM_ITER it = m_PlayingSoundsMap.find(Handle);
-	// Falls die Daten nicht gefunden werden konnten, Fehler zurückgebene, ansonsten ein Pointer auf die Daten.
-	if (it == m_PlayingSoundsMap.end()) return 0;
-	return &((*it).second);
-}
-
-// -----------------------------------------------------------------------------
-
-uint BS_FMODExSound::CountPlayingDynamicSounds() {
-	uint Result = 0;
-	for (PSM_CONST_ITER it = m_PlayingSoundsMap.begin(); it != m_PlayingSoundsMap.end(); ++it) if (!it->second.ResourcePtr) ++Result;
-
-	return Result;
-}
-#endif
-
-// -----------------------------------------------------------------------------
-// Ressourcen-Verwaltung
-// -----------------------------------------------------------------------------
-
-Resource *FMODExSound::LoadResource(const Common::String &FileName) {
-#if 0
-	BS_ASSERT(m_FMOD);
-	BS_ASSERT(CanLoadResource(FileName));
-
-	bool Success;
-	BS_FMODExResource *ResourcePtr = new BS_FMODExResource(FileName, m_FMOD, Success);
-	if (Success)
-		return ResourcePtr;
-	else {
-		delete ResourcePtr;
-		return 0;
-	}
-#else
-	return 0;
-#endif
-}
-bool FMODExSound::CanLoadResource(const Common::String &FileName) {
-#if 0
-	if (FileName.size() >= 4) {
-		Common::String Extension(FileName.end() - 4, FileName.end());
-		BS_String::ToLower(Extension);
-
-		return  Extension == ".wav" ||
-		        Extension == ".ogg" ||
-		        Extension == ".mp3";
-	} else
-		return false;
-#else
-	return true;
-#endif
-}
-
-// -----------------------------------------------------------------------------
-// Persistenz
-// -----------------------------------------------------------------------------
-
-bool FMODExSound::persist(OutputPersistenceBlock &writer) {
-#if 0
-	BS_ASSERT(m_FMOD);
-
-	// Alle inaktiven Sounds entfernen, damit kein unnötiger Ballast gespeichert wird
-	RemoveInactiveSounds();
-
-	// Warnung ausgeben, wenn dynamische Sounds abgespielt werden
-	uint PlayingDynamicSounds = CountPlayingDynamicSounds();
-	if (PlayingDynamicSounds) BS_LOG_WARNINGLN("There are currently dynamic sounds playing. These will not be persisted.");
-
-	// Nächstes Handle speichern
-	Writer.Write(m_NextHandle);
-
-	// Anzahl spielender (nicht dynamischer) Sounds speichern
-	Writer.Write(m_PlayingSoundsMap.size() - PlayingDynamicSounds);
-
-	// Informationen für jeden spielenden (nicht dynamischen) Sound speichern
-	PSM_CONST_ITER it = m_PlayingSoundsMap.begin();
-	while (it != m_PlayingSoundsMap.end()) {
-		const PlayingSoundData &PSD = it->second;
-
-		if (PSD.ResourcePtr) {
-			// Handle speichern
-			Writer.Write(it->first);
-
-			// Soundeigenschaften speichern
-			Writer.Write(PSD.ResourcePtr->GetFileName());
-			Writer.Write(static_cast<uint>(PSD.Type));
-			Writer.Write(PSD.Layer);
-
-			Writer.Write(PSD.Volume);
-			Writer.Write(PSD.ChannelPtr->GetPanning());
-			Writer.Write(PSD.ChannelPtr->IsLooping());
-			Writer.Write(PSD.ChannelPtr->GetLoopStart());
-			Writer.Write(PSD.ChannelPtr->GetLoopEnd());
-			Writer.Write(PSD.ChannelPtr->GetPosition());
-			Writer.Write(PSD.Paused);
-			Writer.Write(PSD.PausedLayer);
-			Writer.Write(PSD.PausedGlobal);
-		}
-
-		++it;
-	}
-
-#endif
-	return true;
-}
-
-// -----------------------------------------------------------------------------
-
-bool FMODExSound::unpersist(InputPersistenceBlock &reader) {
-#if 0
-	BS_ASSERT(m_FMOD);
-
-	// Alle Sounds stoppen
-	PSM_ITER it = m_PlayingSoundsMap.begin();
-	while (it != m_PlayingSoundsMap.end()) {
-		const PlayingSoundData &PSD = it->second;
-		if (PSD.ChannelPtr) delete PSD.ChannelPtr;
-		if (PSD.ResourcePtr) PSD.ResourcePtr->Release();
-		++it;
-	}
-
-	// Sound-Map leeren
-	m_PlayingSoundsMap.clear();
-
-	// Nächstes Handle laden
-	Reader.Read(m_NextHandle);
-
-	// Soundanzahl einlesen
-	uint SoundCount = 0;
-	Reader.Read(SoundCount);
-
-	// Informationen über jeden spielenden Sound einlesen und ihn mit den Parametern abspielen
-	for (uint i = 0; i < SoundCount; ++i) {
-		uint    Handle;
-		Common::String     FileName;
-		uint    Type;
-		uint    Layer;
-
-		float           Volume;
-		float           Pan;
-		bool            Loop;
-		uint    LoopStart;
-		uint    LoopEnd;
-		uint    Position;
-		bool            Paused;
-		bool            PausedLayer;
-		bool            PausedGlobal;
-
-		Reader.Read(Handle);
-		Reader.Read(FileName);
-		Reader.Read(Type);
-		Reader.Read(Layer);
-
-		Reader.Read(Volume);
-		Reader.Read(Pan);
-		Reader.Read(Loop);
-		Reader.Read(LoopStart);
-		Reader.Read(LoopEnd);
-		Reader.Read(Position);
-		Reader.Read(Paused);
-		Reader.Read(PausedLayer);
-		Reader.Read(PausedGlobal);
-
-		if (Reader.IsGood()) {
-			PlaySoundInternal(FileName, (SOUND_TYPES) Type, Volume, Pan, Loop, LoopStart, LoopEnd, Layer, Position, Handle);
-		} else {
-			return false;
-		}
-	}
-
-	return Reader.IsGood();
-#else
-	return true;
-#endif
-}
-
-} // End of namespace Sword25
diff --git a/engines/sword25/sfx/fmodexsound.h b/engines/sword25/sfx/fmodexsound.h
deleted file mode 100644
index b599334d1c..0000000000
--- a/engines/sword25/sfx/fmodexsound.h
+++ /dev/null
@@ -1,136 +0,0 @@
-/* ScummVM - Graphic Adventure Engine
- *
- * ScummVM is the legal property of its developers, whose names
- * are too numerous to list here. Please refer to the COPYRIGHT
- * file distributed with this source distribution.
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version 2
- * of the License, or (at your option) any later version.
-
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
-
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
- *
- * $URL$
- * $Id$
- *
- */
-
-/*
- * This code is based on Broken Sword 2.5 engine
- *
- * Copyright (c) Malte Thiesen, Daniel Queteschiner and Michael Elsdoerfer
- *
- * Licensed under GNU GPL v2
- *
- */
-
-#ifndef SWORD25_FMODEXSOUND_H
-#define SWORD25_FMODEXSOUND_H
-
-#include "sword25/sfx/soundengine.h"
-
-namespace Sword25 {
-
-class FMODExSound : public SoundEngine {
-public:
-	// -----------------------------------------------------------------------------
-	// Konstruktion / Destruktion
-	// -----------------------------------------------------------------------------
-
-	FMODExSound(Kernel *pKernel);
-	virtual ~FMODExSound();
-
-	bool            Init(uint SampleRate, uint Channels = 32);
-	void            Update();
-	void            SetVolume(float Volume, SOUND_TYPES Type);
-	float           GetVolume(SOUND_TYPES Type);
-	void            PauseAll();
-	void            ResumeAll();
-	void            PauseLayer(uint Layer);
-	void            ResumeLayer(uint Layer);
-	bool            PlaySound(const Common::String &FileName, SOUND_TYPES Type, float Volume, float Pan, bool Loop, int LoopStart, int LoopEnd, uint Layer);
-	uint    PlaySoundEx(const Common::String &FileName, SOUND_TYPES Type, float Volume, float Pan, bool Loop, int LoopStart, int LoopEnd, uint Layer);
-	uint    PlayDynamicSoundEx(DynamicSoundReadCallback ReadCallback, void *UserData, SOUND_TYPES Type, uint SampleRate, uint BitsPerSample, uint Channels, float Volume = 1.0f, float Pan = 0.0f, uint Layer = 0);
-
-	void    SetSoundVolume(uint Handle, float Volume);
-	void    SetSoundPanning(uint Handle, float Pan);
-	void    PauseSound(uint Handle);
-	void    ResumeSound(uint Handle);
-	void    StopSound(uint Handle);
-	bool    IsSoundPaused(uint Handle);
-	bool    IsSoundPlaying(uint Handle);
-	float   GetSoundVolume(uint Handle);
-	float   GetSoundPanning(uint Handle);
-	float   GetSoundTime(uint Handle);
-
-	Resource    *LoadResource(const Common::String &FileName);
-	bool            CanLoadResource(const Common::String &FileName);
-
-	// -----------------------------------------------------------------------------
-	// Persistenz
-	// -----------------------------------------------------------------------------
-
-	bool persist(OutputPersistenceBlock &writer);
-	bool unpersist(InputPersistenceBlock &reader);
-
-#if 0
-private:
-	struct PlayingSoundData {
-		PlayingSoundData() {};
-		PlayingSoundData(BS_Resource *ResourcePtr_, BS_FMODExChannel *ChannelPtr_, SOUND_TYPES Type_, uint Layer_, float Volume_, DynamicSoundReadCallback ReadCallback_ = 0, void *UserData_ = 0) :
-			ResourcePtr(ResourcePtr_),
-			ChannelPtr(ChannelPtr_),
-			Type(Type_),
-			Layer(Layer_),
-			Volume(Volume_),
-			ReadCallback(ReadCallback_),
-			UserData(UserData_),
-			Paused(false),
-			PausedLayer(false),
-			PausedGlobal(false)
-		{}
-
-		BS_Resource                *ResourcePtr;
-		BS_FMODExChannel           *ChannelPtr;
-		SOUND_TYPES                 Type;
-		uint                Layer;
-		DynamicSoundReadCallback    ReadCallback;
-		void                       *UserData;
-
-		float   Volume;
-		bool    Paused;
-		bool    PausedLayer;
-		bool    PausedGlobal;
-	};
-
-	typedef BS_Hashmap<uint, PlayingSoundData>                  PSM;
-	typedef BS_Hashmap<uint, PlayingSoundData>::iterator        PSM_ITER;
-	typedef BS_Hashmap<uint, PlayingSoundData>::const_iterator  PSM_CONST_ITER;
-	PSM m_PlayingSoundsMap;
-
-	FMOD_SYSTEM    *m_FMOD;
-	float           m_Volumes[3];
-	uint    m_NextHandle;
-
-	void                RemoveInactiveSounds();
-	PlayingSoundData   *GetPlayingSoundDataByHandle(uint Handle);
-	uint        PlaySoundInternal(const Common::String &FileName, SOUND_TYPES Type, float Volume, float Pan, bool Loop, int LoopStart, int LoopEnd, uint Layer, uint Handle, uint Position);
-	uint        CountPlayingDynamicSounds();
-
-	static FMOD_RESULT F_CALLBACK FMODExDynamicSoundSetPosCallback(FMOD_SOUND *sound, int subsound, uint position, FMOD_TIMEUNIT postype);
-	static FMOD_RESULT F_CALLBACK FMODExDynamicSoundReadCallback(FMOD_SOUND *sound, void *data, uint datalen);
-	static FMOD_RESULT F_CALLBACK DSPReadCallback(FMOD_DSP_STATE *dsp_state, float *inbuffer, float *outbuffer, uint length, int inchannels, int outchannels);
-#endif
-};
-
-} // End of namespace Sword25
-
-#endif
diff --git a/engines/sword25/sfx/soundengine.cpp b/engines/sword25/sfx/soundengine.cpp
index 022d58b4b4..cd83085e44 100644
--- a/engines/sword25/sfx/soundengine.cpp
+++ b/engines/sword25/sfx/soundengine.cpp
@@ -43,6 +43,107 @@ SoundEngine::SoundEngine(Kernel *pKernel) : ResourceService(pKernel) {
 		BS_LOG_ERRORLN("Script bindings could not be registered.");
 	else
 		BS_LOGLN("Script bindings registered.");
+
+	_mixer = g_system->getMixer();
+}
+
+Service *SoundEngine_CreateObject(Kernel *pKernel) {
+	return new SoundEngine(pKernel);
+}
+
+bool SoundEngine::Init(uint SampleRate, uint Channels) {
+	return true;
+}
+
+void SoundEngine::Update() {
+}
+
+void SoundEngine::SetVolume(float Volume, SOUND_TYPES Type) {
+}
+
+float SoundEngine::GetVolume(SOUND_TYPES Type) {
+	return 0;
+}
+
+void SoundEngine::PauseAll() {
+}
+
+void SoundEngine::ResumeAll() {
+}
+
+void SoundEngine::PauseLayer(uint Layer) {
+}
+
+void SoundEngine::ResumeLayer(uint Layer) {
+}
+
+bool SoundEngine::PlaySound(const Common::String &FileName, SOUND_TYPES Type, float Volume, float Pan, bool Loop, int LoopStart, int LoopEnd, uint Layer) {
+	return true;
+}
+
+uint SoundEngine::PlaySoundEx(const Common::String &FileName, SOUND_TYPES Type, float Volume, float Pan, bool Loop, int LoopStart, int LoopEnd, uint Layer) {
+	return 0;
+}
+
+void SoundEngine::SetSoundVolume(uint Handle, float Volume) {
+}
+
+void SoundEngine::SetSoundPanning(uint Handle, float Pan) {
+}
+
+void SoundEngine::PauseSound(uint Handle) {
 }
 
+void SoundEngine::ResumeSound(uint Handle) {
+}
+
+void SoundEngine::StopSound(uint Handle) {
+}
+
+bool SoundEngine::IsSoundPaused(uint Handle) {
+	return false;
+}
+
+bool SoundEngine::IsSoundPlaying(uint Handle) {
+	return false;
+}
+
+float SoundEngine::GetSoundVolume(uint Handle) {
+	return 0;
+}
+
+float SoundEngine::GetSoundPanning(uint Handle) {
+	return 0;
+}
+
+float SoundEngine::GetSoundTime(uint Handle) {
+	return 0;
+}
+
+Resource *SoundEngine::LoadResource(const Common::String &FileName) {
+	return 0;
+}
+
+bool SoundEngine::CanLoadResource(const Common::String &fileName) {
+	Common::String fname = fileName;
+
+	fname.toLowercase();
+
+	return fname.hasSuffix(".ogg");
+}
+
+
+bool SoundEngine::persist(OutputPersistenceBlock &writer) {
+	warning("STUB: SoundEngine::persist()");
+
+	return true;
+}
+
+bool SoundEngine::unpersist(InputPersistenceBlock &reader) {
+	warning("STUB: SoundEngine::unpersist()");
+
+	return true;
+}
+
+
 } // End of namespace Sword25
diff --git a/engines/sword25/sfx/soundengine.h b/engines/sword25/sfx/soundengine.h
index 6c67c9c531..2bc29cdd1e 100644
--- a/engines/sword25/sfx/soundengine.h
+++ b/engines/sword25/sfx/soundengine.h
@@ -56,6 +56,9 @@
 #include "sword25/kernel/resservice.h"
 #include "sword25/kernel/persistable.h"
 
+#include "sound/audiostream.h"
+#include "sound/mixer.h"
+
 namespace Sword25 {
 
 // -----------------------------------------------------------------------------
@@ -87,7 +90,7 @@ public:
 	// -----------------------------------------------------------------------------
 
 	SoundEngine(Kernel *pKernel);
-	virtual ~SoundEngine() {};
+	~SoundEngine() {};
 
 	// --------------------------------------------------------------
 	// THIS METHOD MUST BE IMPLEMENTED BY THE SOUND ENGINE
@@ -101,7 +104,7 @@ public:
 	 * @remark              Calls to other methods may take place only if this
 	 * method was called successfully.
 	 */
-	virtual bool Init(uint SampleRate, uint Channels = 32) = 0;
+	bool Init(uint SampleRate, uint Channels = 32);
 
 	/**
 	 * Performs a "tick" of the sound engine
@@ -110,14 +113,14 @@ public:
 	 * of the sound engine that are not running in their own thread, or to perform
 	 * additional administrative tasks that are needed.
 	 */
-	virtual void Update() = 0;
+	void Update();
 
 	/**
 	 * Sets the default volume for the different sound types
 	 * @param Volume        The default volume level (0 = off, 1 = full volume)
 	 * @param Type          The SoundType whose volume is to be changed
 	 */
-	virtual void SetVolume(float Volume, SOUND_TYPES Type) = 0;
+	void SetVolume(float Volume, SOUND_TYPES Type);
 
 	/**
 	 * Specifies the default volume of different sound types
@@ -125,29 +128,29 @@ public:
 	 * @return              Returns the standard sound volume for the given type
 	 * (0 = off, 1 = full volume).
 	*/
-	virtual float GetVolume(SOUND_TYPES Type) = 0;
+	float GetVolume(SOUND_TYPES Type);
 
 	/**
 	 * Pauses all the sounds that are playing.
 	 */
-	virtual void PauseAll() = 0;
+	void PauseAll();
 
 	/**
 	 * Resumes all currently stopped sounds
 	 */
-	virtual void ResumeAll() = 0;
+	void ResumeAll();
 
 	/**
 	 * Pauses all sounds of a given layer.
 	 * @param Layer         The Sound Layer
 	*/
-	virtual void PauseLayer(uint Layer) = 0;
+	void PauseLayer(uint Layer);
 
 	/**
 	 * Resumes all the sounds in a layer that was previously stopped with PauseLayer()
 	 * @param Layer         The Sound Layer
 	*/
-	virtual void ResumeLayer(uint Layer) = 0;
+	void ResumeLayer(uint Layer);
 
 
 	/**
@@ -166,7 +169,7 @@ public:
 	 * @remark              If more control is needed over the playing, eg. changing the sound parameters
 	 * for Volume and Panning, then PlaySoundEx should be used.
 	*/
-	virtual bool PlaySound(const Common::String &FileName, SOUND_TYPES Type, float Volume = 1.0f, float Pan = 0.0f, bool Loop = false, int LoopStart = -1, int LoopEnd = -1, uint Layer = 0) = 0;
+	bool PlaySound(const Common::String &FileName, SOUND_TYPES Type, float Volume = 1.0f, float Pan = 0.0f, bool Loop = false, int LoopStart = -1, int LoopEnd = -1, uint Layer = 0);
 
 	/**
 	 * Plays a sound
@@ -183,7 +186,7 @@ public:
 	 * @remark              If more control is needed over the playing, eg. changing the sound parameters
 	 * for Volume and Panning, then PlaySoundEx should be used.
 	 */
-	virtual uint PlaySoundEx(const Common::String &FileName, SOUND_TYPES Type, float Volume = 1.0f, float Pan = 0.0f, bool Loop = false, int LoopStart = -1, int LoopEnd = -1, uint Layer = 0) = 0;
+	uint PlaySoundEx(const Common::String &FileName, SOUND_TYPES Type, float Volume = 1.0f, float Pan = 0.0f, bool Loop = false, int LoopStart = -1, int LoopEnd = -1, uint Layer = 0);
 
 	/**
 	 * Plays a sound generated at runtime
@@ -202,72 +205,81 @@ public:
 	 * @return              Returns a handle to the sound. With this handle, the sound can be manipulated during playback.
 	 * @remark              Dynamic sounds cannot be persisted.
 	 */
-	virtual uint PlayDynamicSoundEx(DynamicSoundReadCallback ReadCallback, void *UserData, SOUND_TYPES Type, uint SampleRate, uint BitsPerSample, uint Channels, float Volume = 1.0f, float Pan = 0.0f, uint Layer = 0) = 0;
+	uint PlayDynamicSoundEx(DynamicSoundReadCallback ReadCallback, void *UserData, SOUND_TYPES Type, uint SampleRate, uint BitsPerSample, uint Channels, float Volume = 1.0f, float Pan = 0.0f, uint Layer = 0);
 
 	/**
 	 * Sets the volume of a playing sound
 	 * @param Handle        The sound handle
 	 * @param Volume        The volume of the sound (0 = off, 1 = full volume)
 	 */
-	virtual void SetSoundVolume(uint Handle, float Volume) = 0;
+	void SetSoundVolume(uint Handle, float Volume);
 
 	/**
 	 * Sets the panning of a playing sound
 	 * @param Handle        The sound handle
 	 * @param Pan           Panning (-1 = full left, 1 = right)
 	 */
-	virtual void SetSoundPanning(uint Handle, float Pan) = 0;
+	void SetSoundPanning(uint Handle, float Pan);
 
 	/**
 	 * Pauses a playing sound
 	 * @param Handle        The sound handle
 	 */
-	virtual void PauseSound(uint Handle) = 0;
+	void PauseSound(uint Handle);
 
 	/**
 	 * Resumes a paused sound
 	 * @param Handle        The sound handle
 	 */
-	virtual void ResumeSound(uint Handle) = 0;
+	void ResumeSound(uint Handle);
 
 	/**
 	 * Stops a playing sound
 	 * @param Handle        The sound handle
 	 * @remark              Calling this method invalidates the passed handle; it can no longer be used.
 	 */
-	virtual void StopSound(uint Handle) = 0;
+	void StopSound(uint Handle);
 
 	/**
 	 * Returns whether a sound is paused
 	 * @param Handle        The sound handle
 	 * @return              Returns true if the sound is paused, false otherwise.
 	 */
-	virtual bool IsSoundPaused(uint Handle) = 0;
+	bool IsSoundPaused(uint Handle);
 
 	/**
 	 * Returns whether a sound is still playing.
 	 * @param Handle        The sound handle
 	 * @return              Returns true if the sound is playing, false otherwise.
 	*/
-	virtual bool IsSoundPlaying(uint Handle) = 0;
+	bool IsSoundPlaying(uint Handle);
 
 	/**
 	 * Returns the volume of a playing sound (0 = off, 1 = full volume)
 	 */
-	virtual float GetSoundVolume(uint Handle) = 0;
+	float GetSoundVolume(uint Handle);
 
 	/**
 	 * Returns the panning of a playing sound (-1 = full left, 1 = right)
 	 */
-	virtual float GetSoundPanning(uint Handle) = 0;
+	float GetSoundPanning(uint Handle);
 
 	/**
 	 * Returns the position within a playing sound in seconds
 	 */
-	virtual float GetSoundTime(uint Handle) = 0;
+	float GetSoundTime(uint Handle);
+
+	Resource    *LoadResource(const Common::String &FileName);
+	bool            CanLoadResource(const Common::String &FileName);
+
+	bool persist(OutputPersistenceBlock &writer);
+	bool unpersist(InputPersistenceBlock &reader);
 
 private:
 	bool _RegisterScriptBindings();
+
+private:
+	Audio::Mixer *_mixer;
 };
 
 } // End of namespace Sword25