Initial commit

engines/lastexpress/sound/slot.cpp

@@ -0,0 +1,912 @@
+/* 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 3 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, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "lastexpress/sound/slot.h"
+#include "lastexpress/sound/sound.h"
+#include "lastexpress/sound/subtitle.h"
+#include "lastexpress/data/archive.h"
+
+#include "lastexpress/helpers.h"
+#include "lastexpress/lastexpress.h"
+
+namespace LastExpress {
+
+Slot::Slot(SoundManager *soundMan, const char *filename, int typeFlags, int priority) {
+	_soundMan = soundMan;
+	_engine = _soundMan->_engine;
+
+	_engine->_soundMutex->lock();
+
+	memset(_name1, 0, sizeof(_name1));
+	memset(_name2, 0, sizeof(_name2));
+
+	_priority = priority;
+	setTag(typeFlags);
+	setType(typeFlags);
+	_soundMan->addSlot(this);
+
+	_engine->_soundMutex->unlock();
+
+	// From this point onwards there could be deadlocks between the main
+	// thread and the sound thread because of busy waits in getBuffer(),
+	// so we leave the mutex unlocked and let the insides of the function
+	// do their job...
+	getBuffer();
+
+	// This function will reacquire the mutex...
+	load(filename);
+}
+
+Slot::Slot(SoundManager *soundMan, int typeFlags, int priority) {
+	_soundMan = soundMan;
+	_engine = _soundMan->_engine;
+
+	_engine->_soundMutex->lock();
+
+	memset(_name1, 0, sizeof(_name1));
+	memset(_name2, 0, sizeof(_name2));
+
+	_priority = priority;
+	Common::strcpy_s(_name2, "NISSND?");
+	assignDirectVolume(kVolumeFull);
+	setTag(typeFlags);
+	setType(typeFlags);
+	_soundMan->addSlot(this);
+
+	_engine->_soundMutex->unlock();
+
+	// From this point onwards there could be deadlocks between the main
+	// thread and the sound thread because of busy waits in getBuffer(),
+	// so we leave the mutex unlocked and let the insides of the function
+	// do their job...
+	getBuffer();
+}
+
+Slot::Slot(SoundManager *soundMan, SaveSlot *soundEntry) {
+	_soundMan = soundMan;
+	_engine = _soundMan->_engine;
+
+	_engine->_soundMutex->lock();
+
+	memset(_name1, 0, sizeof(_name1));
+	memset(_name2, 0, sizeof(_name2));
+
+	setBlockCount(soundEntry->blockCount);
+	addStatusFlag(soundEntry->status);
+	setTag(_statusFlags);
+
+	strncpy(_name1, soundEntry->name1, 15);
+	strncpy(_name2, soundEntry->name2, 15);
+
+	Common::String subName = _name2;
+	subName.replace('.', '\0');
+
+	setSub(subName.c_str());
+
+	_time = soundEntry->time;
+	_fadeDelayCounter = soundEntry->fadeDelayCounter;
+	_unusedVar = soundEntry->unusedVar;
+	_character = soundEntry->character;
+	_delayedStartTime = _soundMan->getSoundDriver30HzCounter() + soundEntry->delayTicks;
+	_priority = soundEntry->priority;
+
+	_engine->_soundMutex->unlock();
+
+	// From this point onwards there could be deadlocks between the main
+	// thread and the sound thread because of busy waits in devirtualize(),
+	// so we must activate the mutex selectively when fetching or updating
+	// the class members...
+	if ((getStatusFlags() & kSoundFlagPlaying) != 0 &&
+		(getStatusFlags() & kSoundFlagMuteProcessed) == 0 &&
+		(getStatusFlags() & kSoundVolumeMask) != 0) {
+		removeStatusFlag(kSoundFlagPlaying);
+		addStatusFlag(kSoundFlagMute);
+		devirtualize();
+	}
+
+	_soundMan->addSlot(this);
+}
+
+Slot::~Slot() {
+	addStatusFlag(kSoundFlagCloseRequested);
+
+	while (true) {
+		bool mustWait = (getStatusFlags() & kSoundFlagClosed) == 0 &&
+			(_soundMan->getSoundDriverFlags() & kSoundDriverClearBufferProcessed) == 0 &&
+			(_soundMan->getSoundDriverFlags() & kSoundDriverInitState) != 0;
+
+		if (!mustWait)
+			break;
+
+		_engine->handleEvents(); // For good measure...
+	}
+
+	_soundMan->removeSlot(this);
+
+	_engine->_soundMutex->lock();
+
+	if (_archive)
+		_engine->getArchiveManager()->closeHPF(_archive);
+
+	_engine->_soundMutex->unlock();
+
+	if (getSoundBuffer())
+		releaseBuffer();
+
+	if (getSubtitle()) {
+		_engine->_soundMutex->lock();
+
+		delete _subtitle;
+		_subtitle = nullptr;
+
+		_engine->_soundMutex->unlock();
+	}
+
+	if (getAssociatedCharacter()) {
+		if (getAssociatedCharacter() == kCharacterSteam) {
+			_soundMan->ambientAI(kAmbientSoundSteam);
+		} else if (getAssociatedCharacter() != kCharacterClerk) {
+			_engine->getLogicManager()->send(kCharacterCath, getAssociatedCharacter(), 2, 0);
+		}
+	}
+}
+
+void Slot::play() {
+	if ((_soundMan->getSoundDriverFlags() & kSoundDriverNISHasRequestedFade) != 0) {
+		if (getTag() != kSoundTagNIS && getTag() != kSoundTagLink && getTag() != kSoundTagConcert) {
+			int volume = getStatusFlags() & kSoundVolumeMask;
+			removeStatusFlag(kSoundVolumeMask);
+			assignDirectVolume(volume);
+			addStatusFlag((volume >> 1) + 1);
+		}
+	}
+
+	addStatusFlag(kSoundFlagPlayRequested);
+}
+
+void Slot::setFade(int volume) {
+	Common::StackLock lock(*_engine->_soundMutex);
+	if ((_statusFlags & kSoundFlagFading) == 0) {
+		int32 targetVolume = volume;
+		_statusFlags |= kSoundFlagVolumeChanging;
+
+		if (volume) {
+			if ((_soundMan->_soundDriverFlags & kSoundDriverNISHasRequestedFade) != 0) {
+				_volume = volume;
+				targetVolume = (volume >> 1) + 1;
+			}
+
+			_fadeTargetVolume = targetVolume;
+		} else {
+			_fadeTargetVolume = 0;
+			_statusFlags |= kSoundFlagFading;
+		}
+	}
+}
+
+void Slot::setVol(int volume) {
+	if (volume) {
+		if ((_soundMan->getSoundDriverFlags() & kSoundDriverNISHasRequestedFade) == 0 || getTag() == kSoundTagNIS || getTag() == kSoundTagLink) {
+			setStatusFlags(volume + (getStatusFlags() & ~kSoundVolumeMask));
+		} else {
+			setFade(volume);
+		}
+	} else {
+		assignDirectVolume(0);
+		addStatusFlag(kSoundFlagMuteRequested);
+		removeStatusFlag(kSoundVolumeMask);
+		removeStatusFlag(kSoundFlagVolumeChanging);
+	}
+}
+
+void Slot::setTag(int typeFlags) {
+	Slot *cacheSlot;
+
+	switch (typeFlags & kSoundTypeMask) {
+	case kSoundTypeNormal:
+		assignDirectTag(_soundMan->_curSoundSlotTag++);
+		break;
+
+	case kSoundTypeAmbient:
+		cacheSlot = _soundMan->_soundCache;
+		if (cacheSlot) {
+			do {
+				if (cacheSlot->getTag() == kSoundTagOldAmbient)
+					break;
+
+				cacheSlot = cacheSlot->getNext();
+			} while (cacheSlot);
+
+			if (cacheSlot)
+				cacheSlot->setFade(0);
+		}
+
+		cacheSlot = _soundMan->_soundCache;
+		if (cacheSlot) {
+			do {
+				if (cacheSlot->getTag() == kSoundTagAmbient)
+					break;
+
+				cacheSlot = cacheSlot->getNext();
+			} while (cacheSlot);
+
+			if (cacheSlot) {
+				cacheSlot->assignDirectTag(kSoundTagOldAmbient);
+				cacheSlot->setFade(0);
+			}
+		}
+
+		assignDirectTag(kSoundTagAmbient);
+		break;
+
+	case kSoundTypeMenu:
+		cacheSlot = _soundMan->_soundCache;
+		if (cacheSlot) {
+			do {
+				if (cacheSlot->getTag() == kSoundTagMenu)
+					break;
+
+				cacheSlot = cacheSlot->getNext();
+			} while (cacheSlot);
+
+			if (cacheSlot)
+				cacheSlot->assignDirectTag(kSoundTagOldMenu);
+		}
+
+		assignDirectTag(kSoundTagMenu);
+		break;
+
+	case kSoundTypeLink:
+		cacheSlot = _soundMan->_soundCache;
+		if (cacheSlot) {
+			do {
+				if (cacheSlot->getTag() == kSoundTagLink)
+					break;
+
+				cacheSlot = cacheSlot->getNext();
+			} while (cacheSlot);
+
+			if (cacheSlot)
+				cacheSlot->assignDirectTag(kSoundTagOldLink);
+		}
+
+		assignDirectTag(kSoundTagLink);
+		break;
+
+	case kSoundTypeIntro:
+		cacheSlot = _soundMan->_soundCache;
+		if (cacheSlot) {
+			do {
+				if (cacheSlot->getTag() == kSoundTagIntro)
+					break;
+
+				cacheSlot = cacheSlot->getNext();
+			} while (cacheSlot);
+
+			if (cacheSlot)
+				cacheSlot->assignDirectTag(kSoundTagOldMenu);
+		}
+
+		assignDirectTag(kSoundTagIntro);
+		break;
+
+	case kSoundTypeWalla:
+		cacheSlot = _soundMan->_soundCache;
+		if (cacheSlot) {
+			do {
+				if (cacheSlot->getTag() == kSoundTagWalla)
+					break;
+
+				cacheSlot = cacheSlot->getNext();
+			} while (cacheSlot);
+
+			if (cacheSlot) {
+				cacheSlot->assignDirectTag(kSoundTagOldWalla);
+				cacheSlot->setFade(0);
+			}
+		}
+
+		assignDirectTag(kSoundTagWalla);
+		break;
+
+	case kSoundTypeNIS:
+		cacheSlot = _soundMan->_soundCache;
+		if (cacheSlot) {
+			do {
+				if (cacheSlot->getTag() == kSoundTagNIS)
+					break;
+
+				cacheSlot = cacheSlot->getNext();
+			} while (cacheSlot);
+
+			if (cacheSlot)
+				cacheSlot->assignDirectTag(kSoundTagOldNIS);
+		}
+
+		assignDirectTag(kSoundTagNIS);
+		break;
+
+	default:
+		break;
+	}
+}
+
+void Slot::setType(int typeFlags) {
+	int effFlags = typeFlags;
+
+	if ((typeFlags & kSoundVolumeMask) == 0)
+		effFlags |= kSoundFlagMuteRequested;
+
+	if ((effFlags & kSoundFlagLooped) == 0)
+		effFlags |= kSoundFlagCloseOnDataEnd;
+
+	addStatusFlag(effFlags);
+}
+
+void Slot::setSub(const char *filename) {
+	Common::StackLock lock(*_engine->_soundMutex);
+	_subtitle = new Subtitle(_engine, filename, this);
+
+	if ((_subtitle->_status & kSubFlagStatusKilled) != 0) {
+		delete _subtitle;
+		_subtitle = nullptr;
+	} else {
+		_statusFlags |= kSoundFlagHasSubtitles;
+	}
+}
+
+bool Slot::getBuffer() {
+	int effPrio = 1000;
+	int count = 0;
+	Slot *cacheSlots;
+	Slot *chosenSlot;
+	
+	if (getSoundBuffer()) {
+		return true;
+	}
+
+	if (_soundMan->_numActiveChannels >= 6) {
+		cacheSlots = _soundMan->_soundCache;
+
+		for (chosenSlot = nullptr; cacheSlots; cacheSlots = cacheSlots->getNext()) {
+			if ((cacheSlots->getStatusFlags() & kSoundFlagMute) == 0) {
+				if (cacheSlots->getPriority() + (int)(getStatusFlags() & kSoundVolumeMask) < effPrio) {
+					chosenSlot = cacheSlots;
+					effPrio = cacheSlots->getPriority() + (getStatusFlags() & kSoundVolumeMask);
+				}
+			}
+		}
+
+		if (getPriority() <= effPrio) {
+			return false;
+		} else {
+			if (chosenSlot)
+				chosenSlot->virtualize();
+
+			if (chosenSlot) {
+				while ((chosenSlot->getStatusFlags() & kSoundFlagMuteProcessed) == 0) {
+					_engine->handleEvents();
+				}
+			}
+
+			if (chosenSlot && chosenSlot->getSoundBuffer())
+				chosenSlot->releaseBuffer();
+
+			for (count = 0; _soundMan->_soundSlotChannels[count]; count++) {
+				if (count >= ARRAYSIZE(_soundMan->_soundSlotChannels) - 1) {
+					return false;
+				}
+			}
+
+			_soundMan->_soundSlotChannels[count] = this;
+			_soundMan->_numActiveChannels++;
+			setSoundBuffer(_engine->_soundMemoryPool + 0x16800 * count);
+
+			return true;
+		}
+	} else {
+		for (count = 0; _soundMan->_soundSlotChannels[count]; count++) {
+			if (count >= ARRAYSIZE(_soundMan->_soundSlotChannels) - 1) {
+				return false;
+			}
+		}
+
+		_soundMan->_soundSlotChannels[count] = this;
+		_soundMan->_numActiveChannels++;
+		setSoundBuffer(_engine->_soundMemoryPool + 0x16800 * count);
+
+		return true;
+	}
+}
+
+void Slot::releaseBuffer() {
+	Common::StackLock lock(*_engine->_soundMutex);
+	int count = 0;
+	int32 size = 0;
+
+	if (getSoundBuffer()) {
+		while ((size + _engine->_soundMemoryPool) != getSoundBuffer()) {
+			count++;
+
+			size += 0x16800;
+			if (size >= 0x87000)
+				return;
+		}
+
+		if (_soundMan->_soundSlotChannels[count]) {
+			_soundMan->_soundSlotChannels[count] = nullptr;
+			_soundMan->_numActiveChannels--;
+			setSoundBuffer(nullptr);
+		}
+	}
+}
+
+void Slot::virtualize() {
+	addStatusFlag(kSoundFlagMuteRequested);
+}
+
+void Slot::devirtualize() {
+	Slot *i;
+	int32 chunkSize;
+	int32 diff;
+	int32 pagesToRead;
+
+	_engine->_soundMutex->lock();
+
+	if ((_statusFlags & kSoundFlagMuteProcessed) != 0 && getBuffer()) {
+		if ((_statusFlags & kSoundFlagLooped) != 0) {
+			load(_name2);
+			_statusFlags &= ~kSoundFlagMute;
+		} else {
+			_archive = _engine->getArchiveManager()->openHPF(_name2);
+			if (_archive) {
+				_statusFlags |= kSoundFlagUnmuteRequested;
+
+				if ((_statusFlags & kSoundFlagPlaying) != 0) {
+					_statusFlags |= kSoundFlagPauseRequested;
+				} else {
+					_statusFlags |= kSoundFlagPaused;
+				}
+
+				if ((_statusFlags & kSoundFlagHeaderProcessed) == 0) {
+					_statusFlags |= kSoundFlagHeaderProcessed;
+					_engine->getArchiveManager()->readHPF(_archive, _soundBuffer, 1);
+
+					_engine->_soundMutex->unlock();
+
+					while ((getStatusFlags() & kSoundFlagPaused) == 0) {
+						_engine->handleEvents();
+					}
+
+					_engine->_soundMutex->lock();
+
+					_size = READ_LE_UINT32(&_soundBuffer[0]);
+					_blockCount = READ_LE_UINT32(&_soundBuffer[4]) - 1;
+					_blockCount -= _time;
+				}
+
+				_engine->_soundMutex->unlock();
+
+				while ((getStatusFlags() & kSoundFlagPaused) == 0) {
+					_engine->handleEvents();
+				}
+
+				_engine->_soundMutex->lock();
+
+				chunkSize = 739 * _time + 6;
+	
+				_dataStart = _soundBuffer;
+				_dataEnd = (_dataStart + 0x16000);
+				_size = 0x16000;
+				_currentDataPtr = &_dataStart[chunkSize & 0x7FF];
+				_loadedBytes = chunkSize & 0xFFFF800;
+				diff = (_archive->size * MEM_PAGE_SIZE) - (chunkSize & 0xFFFF800);
+
+				if (diff <= 0x15800) {
+					pagesToRead = (diff + 2047) / MEM_PAGE_SIZE;
+				} else {
+					pagesToRead = 43;
+					_statusFlags |= (kSoundFlagCyclicBuffer | kSoundFlagHasUnreadData);
+				}
+
+				_engine->getArchiveManager()->seekHPF(_archive, chunkSize / MEM_PAGE_SIZE);
+				_engine->getArchiveManager()->readHPF(_archive, _soundBuffer, pagesToRead);
+				if (_archive->size <= _archive->currentPos) {
+					_engine->getArchiveManager()->closeHPF(_archive);
+					_statusFlags &= ~kSoundFlagHasUnreadData;
+					_archive = 0;
+					_loadedBytes = 4;
+				}
+
+				_loadedBytes += pagesToRead * MEM_PAGE_SIZE;
+				_currentBufferPtr = &_soundBuffer[pagesToRead * MEM_PAGE_SIZE];
+				_statusFlags &= ~(kSoundFlagMute | kSoundFlagPaused | kSoundFlagPauseRequested);
+			} else {
+				for (i = _soundMan->_soundCache; i; i = i->_next) {
+					if (i->_tag == kSoundTagNIS)
+						break;
+				}
+
+				if (i != this)
+					_statusFlags |= kSoundFlagCloseRequested;
+			}
+		}
+	}
+
+	_engine->_soundMutex->unlock();
+}
+
+bool Slot::load(const char *filename) {
+	Common::StackLock lock(*_engine->_soundMutex);
+	_archive = _engine->getArchiveManager()->openHPF(filename);
+	Common::strcpy_s(_name2, filename);
+
+	if (!_archive)
+		_archive = _engine->getArchiveManager()->openHPF("DEFAULT.SND");
+
+	if (_archive) {
+		if (_archive->size > 44 && (_statusFlags & kSoundFlagLooped) != 0) {
+			_engine->getArchiveManager()->closeHPF(_archive);
+			_archive = nullptr;
+			_statusFlags = kSoundFlagCloseRequested;
+			_loadedBytes = 5;
+		} else {
+			if (_soundBuffer) {
+				_dataStart = _soundBuffer;
+				_currentDataPtr = _soundBuffer + 6;
+
+				if (_archive->size > 44) {
+					_engine->getArchiveManager()->readHPF(_archive, _soundBuffer, 44);
+					_loadedBytes = 0x16000;
+					_size = 0x16000;
+					_statusFlags |= (kSoundFlagCloseOnDataEnd | kSoundFlagCyclicBuffer | kSoundFlagHasUnreadData);
+					_blockCount = (int32)READ_LE_UINT16(_soundBuffer + 4) - 1;
+					_dataEnd = _dataStart + 0x16000;
+				} else {
+					_engine->getArchiveManager()->readHPF(_archive, _soundBuffer, _archive->size);
+					_loadedBytes = _archive->size * MEM_PAGE_SIZE;
+					_engine->getArchiveManager()->closeHPF(_archive);
+					_archive = nullptr;
+					_loadedBytes = 6;
+					_blockCount = (int32)READ_LE_UINT16(_soundBuffer + 4);
+					_size = 739 * _blockCount;
+					_dataEnd = &_dataStart[_size + 6];
+				}
+				
+				_currentBufferPtr = _dataStart;
+				_statusFlags |= kSoundFlagHeaderProcessed;
+
+				memset(_dataEnd, 0, 739);
+
+				return true;
+			} else {
+				_size = _archive->size * MEM_PAGE_SIZE;
+				if (_size > 0x16000)
+					_statusFlags |= (kSoundFlagCyclicBuffer | kSoundFlagHasUnreadData);
+
+				_blockCount = (_size + 1018) / 739;
+				_statusFlags |= kSoundFlagMute;
+				_engine->getArchiveManager()->closeHPF(_archive);
+				_archive = nullptr;
+				_loadedBytes = 6;
+
+				return true;
+			}
+		}
+	} else {
+		_statusFlags = kSoundFlagCloseRequested;
+	}
+
+	return false;
+}
+
+void Slot::stream() {
+	Common::StackLock lock(*_engine->_soundMutex);
+
+	int32 numPages;
+	int32 numBytes;
+
+	if ((_statusFlags & kSoundFlagHasUnreadData) != 0) {
+		if (_soundBuffer) {
+			if ((_statusFlags & kSoundFlagMute) == 0) {
+				if (_archive) {	
+					numPages = 739 * _time - _loadedBytes + _size - 2054;
+					if (numPages > _size)
+						numPages = 0;
+
+					numBytes = numPages / MEM_PAGE_SIZE;
+
+					if (numBytes > 16) {
+						if (_archive->size - _archive->currentPos <= numBytes) {
+							_statusFlags &= ~kSoundFlagHasUnreadData;
+							numBytes = _archive->size - _archive->currentPos;
+						}
+
+						while (numBytes > 0) {
+							_engine->getArchiveManager()->readHPF(_archive, _currentBufferPtr, 1);
+
+							_loadedBytes += 0x800;
+
+							if (_dataStart == _currentBufferPtr)
+								memcpy(_dataEnd, _currentBufferPtr, 0x800);
+
+							_currentBufferPtr += 0x800;
+
+							if (_currentBufferPtr > _dataEnd)
+								_currentBufferPtr = _dataStart;
+
+							if (_currentBufferPtr == _dataEnd)
+								_currentBufferPtr = _dataStart;
+
+							numBytes--;
+						}
+
+						if ((_statusFlags & kSoundFlagHasUnreadData) == 0) {
+							_engine->getArchiveManager()->closeHPF(_archive);
+							_archive = nullptr;
+							_loadedBytes |= 1;
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+bool Slot::update() {
+	Common::StackLock lock(*_engine->_soundMutex);
+
+	if ((_statusFlags & kSoundFlagClosed) != 0)
+		return false;
+
+	if ((_statusFlags & kSoundFlagDelayedActivate) != 0) {
+		if (_delayedStartTime <= _soundMan->_sound30HzCounter) {
+			_statusFlags |= kSoundFlagPlayRequested;
+			_statusFlags &= ~kSoundFlagDelayedActivate;
+
+			Common::String subName = _name2;
+			subName.replace('.', '\0');
+			setSub(subName.c_str());
+		}
+	} else {
+		if ((_soundMan->_soundDriverFlags & kSoundDriverNISHasRequestedFade) == 0 && (_statusFlags & kSoundFlagFixedVolume) == 0) {
+			if (_character > 0 && _character < 128) {
+				setVol(_engine->getLogicManager()->getVolume(_character));
+			}
+		}
+
+		if ((_statusFlags & kSoundFlagHasUnreadData) != 0 && (_statusFlags & kSoundFlagMute) == 0 && _soundBuffer)
+			stream();
+	}
+
+	return true;
+}
+
+int32 Slot::getStatusFlags() {
+	Common::StackLock lock(*_engine->_soundMutex);
+	return _statusFlags;
+}
+
+void Slot::setStatusFlags(int32 flags) {
+	Common::StackLock lock(*_engine->_soundMutex);
+	_statusFlags = flags;
+}
+
+void Slot::addStatusFlag(int32 flag) {
+	Common::StackLock lock(*_engine->_soundMutex);
+	_statusFlags |= flag;
+}
+
+void Slot::removeStatusFlag(int32 flag) {
+	Common::StackLock lock(*_engine->_soundMutex);
+	_statusFlags &= ~flag;
+}
+
+int32 Slot::getTag() {
+	Common::StackLock lock(*_engine->_soundMutex);
+	return _tag;
+}
+
+bool Slot::hasTag(int32 tag) {
+	Common::StackLock lock(*_engine->_soundMutex);
+	return _tag == tag;
+}
+
+void Slot::assignDirectTag(int32 tag) {
+	Common::StackLock lock(*_engine->_soundMutex);
+	_tag = tag;
+}
+
+int Slot::getAssociatedCharacter() {
+	Common::StackLock lock(*_engine->_soundMutex);
+	return _character;
+}
+
+void Slot::setAssociatedCharacter(int character) {
+	Common::StackLock lock(*_engine->_soundMutex);
+	_character = character;
+}
+
+int32 Slot::getTime() {
+	Common::StackLock lock(*_engine->_soundMutex);
+	return _time;
+}
+
+Slot *Slot::getNext() {
+	Common::StackLock lock(*_engine->_soundMutex);
+	return _next;
+}
+
+void Slot::setNext(Slot *next) {
+	Common::StackLock lock(*_engine->_soundMutex);
+	_next = next;
+}
+
+int Slot::getPriority() {
+	Common::StackLock lock(*_engine->_soundMutex);
+	return _priority;
+}
+
+bool Slot::closeArchive() {
+	Common::StackLock lock(*_engine->_soundMutex);
+	bool hadArchive = false;
+
+	if (_archive) {
+		_engine->getArchiveManager()->closeHPF(_archive);
+		hadArchive = true;
+	}
+
+	_archive = nullptr;
+
+	return hadArchive;
+}
+
+void Slot::assignDirectVolume(int volume) {
+	Common::StackLock lock(*_engine->_soundMutex);
+	_volume = volume;
+}
+
+int Slot::getVolume() {
+	Common::StackLock lock(*_engine->_soundMutex);
+	return _volume;
+}
+
+void Slot::setChainedSound(Slot *chainedSound) {
+	Common::StackLock lock(*_engine->_soundMutex);
+	_chainedSound = chainedSound;
+}
+
+Subtitle *Slot::getSubtitle() {
+	Common::StackLock lock(*_engine->_soundMutex);
+	return _subtitle;
+}
+
+int32 Slot::getSize() {
+	Common::StackLock lock(*_engine->_soundMutex);
+	return _size;
+}
+
+void Slot::setSize(int32 size) {
+	Common::StackLock lock(*_engine->_soundMutex);
+	_size = size;
+}
+
+int32 Slot::getNumLoadedBytes() {
+	Common::StackLock lock(*_engine->_soundMutex);
+	return _loadedBytes;
+}
+
+void Slot::setNumLoadedBytes(int32 bytes) {
+	Common::StackLock lock(*_engine->_soundMutex);
+	_loadedBytes = bytes;
+}
+
+void Slot::advanceLoadedBytesBy(int32 loadedBytes) {
+	Common::StackLock lock(*_engine->_soundMutex);
+	_loadedBytes += loadedBytes;
+}
+
+byte *Slot::getDataStart() {
+	Common::StackLock lock(*_engine->_soundMutex);
+	return _dataStart;
+}
+
+void Slot::setDataStart(byte *dataStart) {
+	Common::StackLock lock(*_engine->_soundMutex);
+	_dataStart = dataStart;
+}
+
+byte *Slot::getDataEnd() {
+	Common::StackLock lock(*_engine->_soundMutex);
+	return _dataEnd;
+}
+
+void Slot::setDataEnd(byte *dataEnd) {
+	Common::StackLock lock(*_engine->_soundMutex);
+	_dataEnd = dataEnd;
+}
+
+void Slot::setDataEndByte(int32 pos, byte value) {
+	Common::StackLock lock(*_engine->_soundMutex);
+	_dataEnd[pos] = value;
+}
+
+void Slot::advanceDataEndBy(int32 size) {
+	Common::StackLock lock(*_engine->_soundMutex);
+	_dataEnd += size;
+}
+
+byte *Slot::getSoundBuffer() {
+	Common::StackLock lock(*_engine->_soundMutex);
+	return _soundBuffer;
+}
+
+void Slot::setSoundBuffer(byte *bufferPtr) {
+	Common::StackLock lock(*_engine->_soundMutex);
+	_soundBuffer = bufferPtr;
+}
+
+byte *Slot::getCurrentBufferPtr() {
+	Common::StackLock lock(*_engine->_soundMutex);
+	return _currentBufferPtr;
+}
+
+void Slot::advanceCurrentBufferPtrBy(int32 size) {
+	Common::StackLock lock(*_engine->_soundMutex);
+	_currentBufferPtr += size;
+}
+
+void Slot::setCurrentBufferPtr(byte *bufferPtr) {
+	Common::StackLock lock(*_engine->_soundMutex);
+	_currentBufferPtr = bufferPtr;
+}
+
+byte *Slot::getCurrentDataPtr() {
+	Common::StackLock lock(*_engine->_soundMutex);
+	return _currentDataPtr;
+}
+
+void Slot::setCurrentDataPtr(byte *dataPtr) {
+	Common::StackLock lock(*_engine->_soundMutex);
+	_currentDataPtr = dataPtr;
+}
+
+int32 Slot::getBlockCount() {
+	Common::StackLock lock(*_engine->_soundMutex);
+	return _blockCount;
+}
+
+void Slot::setBlockCount(int32 blockCount) {
+	Common::StackLock lock(*_engine->_soundMutex);
+	_blockCount = blockCount;
+}
+
+void Slot::setDelayedStartTime(int32 time) {
+	Common::StackLock lock(*_engine->_soundMutex);
+	_delayedStartTime = time;
+}
+
+char *Slot::getName2() {
+	Common::StackLock lock(*_engine->_soundMutex);
+	return _name2;
+}
+
+} // End of namespace LastExpress