Initial commit

engines/sword2/music.cpp

@@ -0,0 +1,849 @@
+/* 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.
+ *
+ * Additional copyright for this file:
+ * Copyright (C) 1994-1998 Revolution Software Ltd.
+ *
+ * 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/>.
+ */
+
+// One feature still missing is the original's DipMusic() function which, as
+// far as I can understand, softened the music volume when someone was
+// speaking, but only (?) if the music was playing loudly at the time.
+//
+// All things considered, I think this is more bother than it's worth.
+
+
+#include "common/file.h"
+#include "common/memstream.h"
+#include "common/substream.h"
+#include "common/system.h"
+#include "common/textconsole.h"
+
+#include "audio/audiostream.h"
+#include "audio/mixer.h"
+#include "audio/decoders/mp3.h"
+#include "audio/decoders/vorbis.h"
+#include "audio/decoders/flac.h"
+#include "audio/decoders/xa.h"
+#include "audio/rate.h"
+
+#include "sword2/sword2.h"
+#include "sword2/defs.h"
+#include "sword2/header.h"
+#include "sword2/resman.h"
+#include "sword2/sound.h"
+
+namespace Sword2 {
+
+static Audio::AudioStream *makeCLUStream(Common::File *fp, int size);
+static Audio::AudioStream *makePSXCLUStream(Common::File *fp, int size);
+
+static Audio::AudioStream *getAudioStream(SoundFileHandle *fh, const char *base, int cd, uint32 id, uint32 *numSamples) {
+	bool alreadyOpen;
+
+	if (!fh->file.isOpen()) {
+		alreadyOpen = false;
+
+		struct {
+			const char *ext;
+			int mode;
+		} file_types[] = {
+#ifdef USE_FLAC
+			{ "clf", kFLACMode },
+#endif
+#ifdef USE_VORBIS
+			{ "clg", kVorbisMode },
+#endif
+#ifdef USE_MAD
+			{ "cl3", kMP3Mode },
+#endif
+			{ "clu", kCLUMode }
+		};
+
+		int soundMode = 0;
+		char filename[20];
+
+		for (int i = 0; i < ARRAYSIZE(file_types); i++) {
+			Common::sprintf_s(filename, "%s%d.%s", base, cd, file_types[i].ext);
+			if (Common::File::exists(filename)) {
+				soundMode = file_types[i].mode;
+				break;
+			}
+
+			Common::sprintf_s(filename, "%s.%s", base, file_types[i].ext);
+			if (Common::File::exists(filename)) {
+				soundMode = file_types[i].mode;
+				break;
+			}
+		}
+
+		if (soundMode == 0)
+			return nullptr;
+
+		fh->file.open(filename);
+		fh->fileType = soundMode;
+		if (!fh->file.isOpen()) {
+			warning("BS2 getAudioStream: Failed opening file '%s'", filename);
+			return nullptr;
+		}
+		if (fh->fileSize != fh->file.size()) {
+			free(fh->idxTab);
+			fh->idxTab = nullptr;
+		}
+	} else
+		alreadyOpen = true;
+
+	uint32 entrySize = (fh->fileType == kCLUMode) ? 2 : 3;
+
+	if (!fh->idxTab) {
+		fh->file.seek(0);
+		fh->idxLen = fh->file.readUint32LE();
+		fh->file.seek(entrySize * 4);
+
+		fh->idxTab = (uint32 *)malloc(fh->idxLen * 3 * sizeof(uint32));
+		for (uint32 cnt = 0; cnt < fh->idxLen; cnt++) {
+			fh->idxTab[cnt * 3 + 0] = fh->file.readUint32LE();
+			fh->idxTab[cnt * 3 + 1] = fh->file.readUint32LE();
+			if (fh->fileType == kCLUMode) {
+				fh->idxTab[cnt * 3 + 2] = fh->idxTab[cnt * 3 + 1];
+				fh->idxTab[cnt * 3 + 1]--;
+			} else
+				fh->idxTab[cnt * 3 + 2] = fh->file.readUint32LE();
+		}
+	}
+
+	// FIXME: In the forest maze on Zombie Island, the scripts will often
+	// try to play song 451, which doesn't exist. We could easily substitute
+	// another for it here, but which one? There are roughly 250 musical
+	// cues to choose from.
+
+	uint32 pos = fh->idxTab[id * 3 + 0];
+	uint32 len = fh->idxTab[id * 3 + 1];
+	uint32 enc_len = fh->idxTab[id * 3 + 2];
+
+	if (numSamples)
+		*numSamples = len;
+
+	if (!pos || !len) {
+		// We couldn't find the sound. Possibly as a result of a bad
+		// installation (e.g. using the music file from CD 2 as the
+		// first music file). Don't close the file if it was already
+		// open though, because something is playing from it.
+		warning("getAudioStream: Could not find %s ID %d! Possibly the wrong file", base, id);
+		if (!alreadyOpen)
+			fh->file.close();
+		return nullptr;
+	}
+
+	fh->file.seek(pos, SEEK_SET);
+
+	switch (fh->fileType) {
+	case kCLUMode:
+		if (Sword2Engine::isPsx())
+			return makePSXCLUStream(&fh->file, enc_len);
+		else
+			return makeCLUStream(&fh->file, enc_len);
+#ifdef USE_MAD
+	case kMP3Mode: {
+		Common::SafeSeekableSubReadStream *tmp = new Common::SafeSeekableSubReadStream(&fh->file, pos, pos + enc_len);
+		return Audio::makeMP3Stream(tmp, DisposeAfterUse::YES);
+		}
+#endif
+#ifdef USE_VORBIS
+	case kVorbisMode: {
+		Common::SafeSeekableSubReadStream *tmp = new Common::SafeSeekableSubReadStream(&fh->file, pos, pos + enc_len);
+		return Audio::makeVorbisStream(tmp, DisposeAfterUse::YES);
+		}
+#endif
+#ifdef USE_FLAC
+	case kFLACMode: {
+		Common::SafeSeekableSubReadStream *tmp = new Common::SafeSeekableSubReadStream(&fh->file, pos, pos + enc_len);
+		return Audio::makeFLACStream(tmp, DisposeAfterUse::YES);
+		}
+#endif
+	default:
+		return nullptr;
+	}
+}
+
+// ----------------------------------------------------------------------------
+// Custom AudioStream class to handle Broken Sword 2's audio compression.
+// ----------------------------------------------------------------------------
+
+#define GetCompressedShift(n)      (((n) >> 4) & 0x0F)
+#define GetCompressedSign(n)       ((n) & 0x08)
+#define GetCompressedAmplitude(n)  ((n) & 0x07)
+
+CLUInputStream::CLUInputStream(Common::File *file, int size)
+	: _file(file), _firstTime(true), _bufferEnd(_outbuf + BUFFER_SIZE) {
+
+	// Determine the end position.
+	_file_pos = _file->pos();
+	_end_pos = _file_pos + size;
+
+	// Read in initial data
+	refill();
+}
+
+CLUInputStream::~CLUInputStream() {
+}
+
+int CLUInputStream::readBuffer(int16 *buffer, const int numSamples) {
+	int samples = 0;
+	while (samples < numSamples && !eosIntern()) {
+		const int len = MIN(numSamples - samples, (int)(_bufferEnd - _pos));
+		memcpy(buffer, _pos, len * 2);
+		buffer += len;
+		_pos += len;
+		samples += len;
+		if (_pos >= _bufferEnd) {
+			refill();
+		}
+	}
+	return samples;
+}
+
+void CLUInputStream::refill() {
+	byte *in = _inbuf;
+	int16 *out = _outbuf;
+
+	_file->seek(_file_pos, SEEK_SET);
+
+	uint len_left = _file->read(in, MIN((uint32)BUFFER_SIZE, _end_pos - (uint32)_file->pos()));
+
+	_file_pos = _file->pos();
+
+	while (len_left > 0) {
+		uint16 sample;
+
+		if (_firstTime) {
+			_firstTime = false;
+			_prev = READ_LE_UINT16(in);
+			sample = _prev;
+			len_left -= 2;
+			in += 2;
+		} else {
+			uint16 delta = GetCompressedAmplitude(*in) << GetCompressedShift(*in);
+			if (GetCompressedSign(*in))
+				sample = _prev - delta;
+			else
+				sample = _prev + delta;
+
+			_prev = sample;
+			len_left--;
+			in++;
+		}
+
+		*out++ = (int16)sample;
+	}
+
+	_pos = _outbuf;
+	_bufferEnd = out;
+}
+
+Audio::AudioStream *makeCLUStream(Common::File *file, int size) {
+	return new CLUInputStream(file, size);
+}
+
+Audio::AudioStream *makePSXCLUStream(Common::File *file, int size) {
+
+	// Buffer audio file data, and ask MemoryReadStream to dispose of it
+	// when not needed anymore.
+
+	byte *buffer = (byte *)malloc(size);
+	file->read(buffer, size);
+	return Audio::makeXAStream(new Common::MemoryReadStream(buffer, size, DisposeAfterUse::YES), 11025);
+}
+
+// ----------------------------------------------------------------------------
+// Another custom AudioStream class, to wrap around the various AudioStream
+// classes used for music decompression, and to add looping, fading, etc.
+// ----------------------------------------------------------------------------
+
+// The length of a fade-in/out, in milliseconds.
+#define FADE_LENGTH 3000
+
+MusicInputStream::MusicInputStream(int cd, SoundFileHandle *fh, uint32 musicId, bool looping) {
+	_cd = cd;
+	_fh = fh;
+	_musicId = musicId;
+	_looping = looping;
+
+	_bufferEnd = _buffer + BUFFER_SIZE;
+	_remove = false;
+	_fading = 0;
+
+	_decoder = getAudioStream(_fh, "music", _cd, _musicId, &_numSamples);
+	if (_decoder) {
+		_samplesLeft = _numSamples;
+		_fadeSamples = (getRate() * FADE_LENGTH) / 1000;
+		fadeUp();
+
+		// Read in initial data
+		refill();
+	}
+}
+
+MusicInputStream::~MusicInputStream() {
+	delete _decoder;
+	_decoder = nullptr;
+}
+
+int MusicInputStream::readBuffer(int16 *buffer, const int numSamples) {
+	if (!_decoder)
+		return 0;
+
+	int samples = 0;
+	while (samples < numSamples && !eosIntern()) {
+		const int len = MIN(numSamples - samples, (int)(_bufferEnd - _pos));
+		memcpy(buffer, _pos, len * 2);
+		buffer += len;
+		_pos += len;
+		samples += len;
+		if (_pos >= _bufferEnd) {
+			refill();
+		}
+	}
+	return samples;
+}
+
+void MusicInputStream::refill() {
+	int16 *buf = _buffer;
+	uint32 numSamples = 0;
+	uint32 len_left;
+	bool endFade = false;
+
+	len_left = BUFFER_SIZE;
+
+	if (_fading > 0 && (uint32)_fading < len_left)
+		len_left = _fading;
+
+	if (_samplesLeft < len_left)
+		len_left = _samplesLeft;
+
+	if (!_looping) {
+		// Non-looping music is faded out at the end. If this fade
+		// out would have started somewhere within the len_left samples
+		// to read, we only read up to that point. This way, we can
+		// treat this fade as any other.
+
+		if (!_fading) {
+			uint32 currentlyAt = _numSamples - _samplesLeft;
+			uint32 fadeOutAt = _numSamples - _fadeSamples;
+			uint32 readTo = currentlyAt + len_left;
+
+			if (fadeOutAt == currentlyAt)
+				fadeDown();
+			else if (fadeOutAt > currentlyAt && fadeOutAt <= readTo) {
+				len_left = fadeOutAt - currentlyAt;
+				endFade = true;
+			}
+		}
+	}
+
+	int desired = len_left - numSamples;
+	int len = _decoder->readBuffer(buf, desired);
+
+	// Shouldn't happen, but if it does it could cause an infinite loop.
+	// Of course there were bugs that caused it to happen several times
+	// during development. :-)
+
+	if (len < desired) {
+		warning("Expected %d samples, but got %d", desired, len);
+		_samplesLeft = len;
+	}
+
+	buf += len;
+	numSamples += len;
+	len_left -= len;
+	_samplesLeft -= len;
+
+	int16 *ptr;
+
+	if (_fading > 0) {
+		// Fade down
+		for (ptr = _buffer; ptr < buf; ptr++) {
+			if (_fading > 0) {
+				_fading--;
+				*ptr = (*ptr * _fading) / _fadeSamples;
+			}
+			if (_fading == 0) {
+				_looping = false;
+				_remove = true;
+				*ptr = 0;
+			}
+		}
+	} else if (_fading < 0) {
+		// Fade up
+		for (ptr = _buffer; ptr < buf; ptr++) {
+			_fading--;
+			*ptr = -(*ptr * _fading) / _fadeSamples;
+			if (_fading <= -_fadeSamples) {
+				_fading = 0;
+				break;
+			}
+		}
+	}
+
+	if (endFade)
+		fadeDown();
+
+	if (!_samplesLeft) {
+		if (_looping) {
+			delete _decoder;
+			_decoder = getAudioStream(_fh, "music", _cd, _musicId, &_numSamples);
+			_samplesLeft = _numSamples;
+		} else
+			_remove = true;
+	}
+
+	_pos = _buffer;
+	_bufferEnd = buf;
+}
+
+void MusicInputStream::fadeUp() {
+	if (_fading > 0)
+		_fading = -_fading;
+	else if (_fading == 0)
+		_fading = -1;
+}
+
+void MusicInputStream::fadeDown() {
+	if (_fading < 0)
+		_fading = -_fading;
+	else if (_fading == 0)
+		_fading = _fadeSamples;
+}
+
+bool MusicInputStream::readyToRemove() {
+	return _remove;
+}
+
+int32 MusicInputStream::getTimeRemaining() {
+	// This is far from exact, but it doesn't have to be.
+	return (_samplesLeft + BUFFER_SIZE) / getRate();
+}
+
+// ----------------------------------------------------------------------------
+// Main sound class
+// ----------------------------------------------------------------------------
+
+// AudioStream API
+
+int Sound::readBuffer(int16 *buffer, const int numSamples) {
+	Common::StackLock lock(_mutex);
+	int i;
+
+	if (_musicPaused)
+		return 0;
+
+	for (i = 0; i < MAXMUS; i++) {
+		if (_music[i] && _music[i]->readyToRemove()) {
+			delete _music[i];
+			_music[i] = nullptr;
+		}
+	}
+
+	memset(buffer, 0, 2 * numSamples);
+
+	if (!_mixBuffer || numSamples > _mixBufferLen) {
+		if (_mixBuffer) {
+			int16 *newBuffer = (int16 *)realloc(_mixBuffer, 2 * numSamples);
+			if (newBuffer) {
+				_mixBuffer = newBuffer;
+			} else {
+				// We can't use the old buffer any more. It's too small.
+				free(_mixBuffer);
+				_mixBuffer = 0;
+			}
+		} else
+			_mixBuffer = (int16 *)malloc(2 * numSamples);
+
+		_mixBufferLen = numSamples;
+	}
+
+	if (!_mixBuffer)
+		return 0;
+
+	for (i = 0; i < MAXMUS; i++) {
+		if (!_music[i])
+			continue;
+
+		int len = _music[i]->readBuffer(_mixBuffer, numSamples);
+
+		if (!_musicMuted) {
+			for (int j = 0; j < len; j++) {
+				Audio::clampedAdd(buffer[j], _mixBuffer[j]);
+			}
+		}
+	}
+
+	bool inUse[MAXMUS];
+
+	for (i = 0; i < MAXMUS; i++)
+		inUse[i] = false;
+
+	for (i = 0; i < MAXMUS; i++) {
+		if (_music[i]) {
+			if (_music[i]->getCD() == 1)
+				inUse[0] = true;
+			else
+				inUse[1] = true;
+		}
+	}
+
+	for (i = 0; i < MAXMUS; i++) {
+		if (!inUse[i] && !_musicFile[i].inUse && _musicFile[i].file.isOpen())
+			_musicFile[i].file.close();
+	}
+
+	return numSamples;
+}
+
+bool Sound::endOfData() const {
+	// The music never stops. It just goes quiet.
+	return false;
+}
+
+// ----------------------------------------------------------------------------
+// MUSIC
+// ----------------------------------------------------------------------------
+
+/**
+ * Stops the music dead in its tracks. Any music that is currently being
+ * streamed is paused.
+ */
+
+void Sound::pauseMusic() {
+	Common::StackLock lock(_mutex);
+
+	_musicPaused = true;
+}
+
+/**
+ * Restarts the music from where it was stopped.
+ */
+
+void Sound::unpauseMusic() {
+	Common::StackLock lock(_mutex);
+
+	_musicPaused = false;
+}
+
+/**
+ * Fades out and stops the music.
+ */
+
+void Sound::stopMusic(bool immediately) {
+	Common::StackLock lock(_mutex);
+
+	_loopingMusicId = 0;
+
+	for (int i = 0; i < MAXMUS; i++) {
+		if (_music[i]) {
+			if (immediately) {
+				delete _music[i];
+				_music[i] = nullptr;
+			} else
+				_music[i]->fadeDown();
+		}
+	}
+}
+
+/**
+ * Streams music from a cluster file.
+ * @param musicId the id of the music to stream
+ * @param loop true if the music is to loop back to the start
+ * @return RD_OK or an error code
+ */
+int32 Sound::streamCompMusic(uint32 musicId, bool loop) {
+	Common::StackLock lock(_mutex);
+
+	int cd = _vm->_resman->getCD();
+
+	if (loop)
+		_loopingMusicId = musicId;
+	else
+		_loopingMusicId = 0;
+
+	int primary = -1;
+	int secondary = -1;
+
+	// If both music streams are active, one of them will have to go.
+
+	if (_music[0] && _music[1]) {
+		int32 fade0 = _music[0]->isFading();
+		int32 fade1 = _music[1]->isFading();
+
+		if (!fade0 && !fade1) {
+			// Neither is fading. This shouldn't happen, so just
+			// pick one and be done with it.
+			primary = 0;
+		} else if (fade0 && !fade1) {
+			// Stream 0 is fading, so pick that one.
+			primary = 0;
+		} else if (!fade0 && fade1) {
+			// Stream 1 is fading, so pick that one.
+			primary = 1;
+		} else {
+			// Both streams are fading. Pick the one that is
+			// closest to silent.
+			if (ABS(fade0) < ABS(fade1))
+				primary = 0;
+			else
+				primary = 1;
+		}
+
+		delete _music[primary];
+		_music[primary] = nullptr;
+	}
+
+	// Pick the available music stream. If no music is playing it doesn't
+	// matter which we use.
+
+	if (_music[0] || _music[1]) {
+		if (_music[0]) {
+			primary = 1;
+			secondary = 0;
+		} else {
+			primary = 0;
+			secondary = 1;
+		}
+	} else
+		primary = 0;
+
+	// Don't start streaming if the volume is off.
+	if (isMusicMute()) {
+		return RD_OK;
+	}
+
+	if (secondary != -1)
+		_music[secondary]->fadeDown();
+	SoundFileHandle *fh = (cd == 1) ? &_musicFile[0] : &_musicFile[1];
+	fh->inUse = true;
+
+	MusicInputStream *tmp = new MusicInputStream(cd, fh, musicId, loop);
+
+	if (tmp->isReady()) {
+		_music[primary] = tmp;
+		fh->inUse = false;
+		return RD_OK;
+	} else {
+		fh->inUse = false;
+		delete tmp;
+		return RDERR_INVALIDFILENAME;
+	}
+}
+
+/**
+ * @return the time left for the current music, in seconds.
+ */
+
+int32 Sound::musicTimeRemaining() {
+	Common::StackLock lock(_mutex);
+
+	for (int i = 0; i < MAXMUS; i++) {
+		if (_music[i] && _music[i]->isFading() <= 0)
+			return _music[i]->getTimeRemaining();
+	}
+
+	return 0;
+}
+
+// ----------------------------------------------------------------------------
+// SPEECH
+// ----------------------------------------------------------------------------
+
+/**
+ * Mutes/Unmutes the speech.
+ * @param mute If mute is false, restore the volume to the last set master
+ * level. Otherwise the speech is muted (volume 0).
+ */
+
+void Sound::muteSpeech(bool mute) {
+	_speechMuted = mute;
+
+	if (_vm->_mixer->isSoundHandleActive(_soundHandleSpeech)) {
+		uint volume = mute ? 0 : Audio::Mixer::kMaxChannelVolume;
+
+		_vm->_mixer->setChannelVolume(_soundHandleSpeech, volume);
+	}
+}
+
+/**
+ * Stops the speech dead in its tracks.
+ */
+
+void Sound::pauseSpeech() {
+	if (!_speechPaused) {
+		_speechPaused = true;
+		_vm->_mixer->pauseHandle(_soundHandleSpeech, true);
+	}
+}
+
+/**
+ * Restarts the speech from where it was stopped.
+ */
+
+void Sound::unpauseSpeech() {
+	if (_speechPaused) {
+		_speechPaused = false;
+		_vm->_mixer->pauseHandle(_soundHandleSpeech, false);
+	}
+}
+
+/**
+ * Stops the speech from playing.
+ */
+
+int32 Sound::stopSpeech() {
+	if (_vm->_mixer->isSoundHandleActive(_soundHandleSpeech)) {
+		_vm->_mixer->stopHandle(_soundHandleSpeech);
+		return RD_OK;
+	}
+
+	return RDERR_SPEECHNOTPLAYING;
+}
+
+/**
+ * @return Either RDSE_SAMPLEPLAYING or RDSE_SAMPLEFINISHED
+ */
+
+int32 Sound::getSpeechStatus() {
+	return _vm->_mixer->isSoundHandleActive(_soundHandleSpeech) ? RDSE_SAMPLEPLAYING : RDSE_SAMPLEFINISHED;
+}
+
+/**
+ * Returns either RDSE_QUIET or RDSE_SPEAKING
+ */
+
+int32 Sound::amISpeaking() {
+	if (!_speechMuted && !_speechPaused && _vm->_mixer->isSoundHandleActive(_soundHandleSpeech))
+		return RDSE_SPEAKING;
+
+	return RDSE_QUIET;
+}
+
+/**
+ * This function loads, decompresses and plays a line of speech. An error
+ * occurs if speech is already playing.
+ * @param speechId the text line id used to reference the speech
+ * @param vol volume, 0 (minimum) to 16 (maximum)
+ * @param pan panning, -16 (full left) to 16 (full right)
+ */
+
+int32 Sound::playCompSpeech(uint32 speechId, uint8 vol, int8 pan) {
+	if (_speechMuted)
+		return RD_OK;
+
+	if (getSpeechStatus() == RDERR_SPEECHPLAYING)
+		return RDERR_SPEECHPLAYING;
+
+	int cd = _vm->_resman->getCD();
+	SoundFileHandle *fh = (cd == 1) ? &_speechFile[0] : &_speechFile[1];
+
+	Audio::AudioStream *input = getAudioStream(fh, "speech", cd, speechId, nullptr);
+
+	if (!input)
+		return RDERR_INVALIDID;
+
+	// Modify the volume according to the master volume
+
+	byte volume = _speechMuted ? 0 : vol * Audio::Mixer::kMaxChannelVolume / 16;
+	int8 p = (pan * 127) / 16;
+
+	if (isReverseStereo())
+		p = -p;
+
+	// Start the speech playing
+	_vm->_mixer->playStream(Audio::Mixer::kSpeechSoundType, &_soundHandleSpeech, input, -1, volume, p);
+	return RD_OK;
+}
+
+// ----------------------------------------------------------------------------
+// SOUND EFFECTS
+// ----------------------------------------------------------------------------
+
+/**
+ * Mutes/Unmutes the sound effects.
+ * @param mute If mute is false, restore the volume to the last set master
+ * level. Otherwise the sound effects are muted (volume 0).
+ */
+
+void Sound::muteFx(bool mute) {
+	_fxMuted = mute;
+
+	// Now update the volume of any fxs playing
+	for (int i = 0; i < FXQ_LENGTH; i++) {
+		if (_fxQueue[i].resource) {
+			_vm->_mixer->setChannelVolume(_fxQueue[i].handle, mute ? 0 : _fxQueue[i].volume);
+		}
+	}
+}
+
+/**
+ * Sets the volume and pan of the sample which is currently playing
+ * @param id the id of the sample
+ * @param vol volume
+ * @param pan panning
+ */
+
+int32 Sound::setFxIdVolumePan(int32 id, int vol, int pan) {
+	if (!_fxQueue[id].resource)
+		return RDERR_FXNOTOPEN;
+
+	if (vol > 16)
+		vol = 16;
+
+	_fxQueue[id].volume = (vol * Audio::Mixer::kMaxChannelVolume) / 16;
+
+	if (pan != 255) {
+		if (isReverseStereo())
+			pan = -pan;
+		_fxQueue[id].pan = (pan * 127) / 16;
+	}
+
+	if (!_fxMuted && _vm->_mixer->isSoundHandleActive(_fxQueue[id].handle)) {
+		_vm->_mixer->setChannelVolume(_fxQueue[id].handle, _fxQueue[id].volume);
+		if (pan != -1)
+			_vm->_mixer->setChannelBalance(_fxQueue[id].handle, _fxQueue[id].pan);
+	}
+
+	return RD_OK;
+}
+
+void Sound::pauseFx() {
+	if (!_fxPaused) {
+		for (int i = 0; i < FXQ_LENGTH; i++) {
+			if (_fxQueue[i].resource)
+				_vm->_mixer->pauseHandle(_fxQueue[i].handle, true);
+		}
+		_fxPaused = true;
+	}
+}
+
+void Sound::unpauseFx() {
+	if (_fxPaused) {
+		for (int i = 0; i < FXQ_LENGTH; i++)
+			if (_fxQueue[i].resource)
+				_vm->_mixer->pauseHandle(_fxQueue[i].handle, false);
+		_fxPaused = false;
+	}
+}
+
+} // End of namespace Sword2