Initial commit

engines/scumm/players/player_mac_loom_monkey.cpp

@@ -0,0 +1,903 @@
+/* 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 "scumm/players/player_mac_new.h"
+#include "scumm/players/player_mac_intern.h"
+#include "scumm/resource.h"
+
+#include "audio/audiostream.h"
+#include "audio/mixer.h"
+#include "common/endian.h"
+#include "common/punycode.h"
+#include "common/macresman.h"
+#include "common/memstream.h"
+
+namespace Scumm {
+
+#define ASC_DEVICE_RATE		0x56EE8BA3
+#define PCM_BUFFER_SIZE		1024
+
+class MacSndLoader {
+protected:
+	MacSndLoader(bool useInstrTag);
+public:
+	virtual ~MacSndLoader() {}
+
+	virtual bool init() = 0;
+	virtual bool checkResource(const byte *data, uint32 dataSize) const = 0;
+	virtual bool blocked(const byte *data, uint32 dataSize) const = 0;
+	virtual bool loadSound(const byte *data, uint32 dataSize) = 0;
+	virtual void unblock() = 0;
+	void setSynthType(byte type) { _synth = type; }
+
+	const MacLowLevelPCMDriver::PCMSound *getInstrData(uint16 chan);
+	virtual bool isInstrUsable(uint16 chan) const = 0;
+	virtual bool parseNextEvent(uint16 chan, uint16 &duration, uint8 &note, bool &skip, bool &updateInstr) = 0;
+	virtual uint16 getChanSetup() const = 0;
+	uint16 getTimbre() const { return _timbre; }
+	virtual bool isMusic() const = 0;
+	bool isLooping() const { return _loop; }
+	virtual bool restartSoundAfterLoad() const = 0;
+
+	virtual bool ignoreMachineRating() const = 0;
+
+protected:
+	bool loadInstruments(const char *const *tryFileNames, uint16 numTryFileNames, uint16 numInstruments);
+
+	Common::Array<Common::SharedPtr<MacSndResource> > _instruments;
+
+	byte _sndRes6;
+	byte _isMusic;
+	byte _sndRes9;
+	byte _sndRes10;
+	uint16 _chanSetup;
+	uint16 _timbre;
+	bool _loop;
+	byte _synth;
+	const byte *_chanSndData[5];
+	uint32 _chanNumEvents[5];
+	uint32 _chanCurEvent[5];
+	const Common::SharedPtr<MacSndResource> *_chanInstr[5];
+	const Common::SharedPtr<MacSndResource> *_chanInstr2[5];
+
+	const bool _useInstrTag;
+};
+
+class LoomMacSndLoader final : public MacSndLoader {
+public:
+	LoomMacSndLoader() : MacSndLoader(false) {}
+	~LoomMacSndLoader() override {}
+
+	bool init() override;
+	bool checkResource(const byte *data, uint32 dataSize) const override;
+	bool blocked(const byte *data, uint32 dataSize) const override { return false; }
+	bool loadSound(const byte *data, uint32 dataSize) override;
+	void unblock() override {}
+
+	bool isInstrUsable(uint16 chan) const override;
+	bool parseNextEvent(uint16 chan, uint16 &duration, uint8 &note, bool &skip, bool &updateInstr) override;
+	uint16 getChanSetup() const override { return _chanSetup; }
+	bool isMusic() const override { return (_chanSetup == 0); }
+	bool restartSoundAfterLoad() const override { return isMusic(); }
+	bool ignoreMachineRating() const override { return false; }
+private:
+	const Common::SharedPtr<MacSndResource> *fetchInstrument(uint16 id) const;
+};
+
+class MonkeyMacSndLoader final : public MacSndLoader {
+public:
+	MonkeyMacSndLoader() : MacSndLoader(true), _numInstrumentsMax(17), _blockSfx(false), _transpose(0) {}
+	~MonkeyMacSndLoader() override {}
+
+	bool init() override;
+	bool checkResource(const byte *data, uint32 dataSize) const override;
+	bool blocked(const byte *data, uint32 dataSize) const override;
+	bool loadSound(const byte *data, uint32 dataSize) override;
+	void unblock() override { _blockSfx = false; }
+
+	bool isInstrUsable(uint16 chan) const override;
+	bool parseNextEvent(uint16 chan, uint16 &duration, uint8 &note, bool &skip, bool &updateInstr) override;
+	uint16 getChanSetup() const override { return _isMusic ? _chanSetup : 7; }
+	bool isMusic() const override { return _isMusic; }
+	bool restartSoundAfterLoad() const override { return _isMusic && _loop; }
+	bool ignoreMachineRating() const override { return true; }
+private:
+	const Common::SharedPtr<MacSndResource> *fetchInstrument(const byte *data, uint32 dataSize, uint32 tagOrOffset);
+	bool _blockSfx;
+	byte _transpose;
+	const byte _numInstrumentsMax;
+};
+
+MacSndLoader::MacSndLoader(bool useInstrTag) : _sndRes6(0), _isMusic(0), _sndRes9(0), _sndRes10(0), _chanSetup(0),
+	_timbre(0), _useInstrTag(useInstrTag), _synth(0), _loop(false) {
+	memset(_chanInstr, 0, sizeof(_chanInstr));
+	memset(_chanInstr2, 0, sizeof(_chanInstr2));
+	memset(_chanSndData, 0, sizeof(_chanSndData));
+	memset(_chanNumEvents, 0, sizeof(_chanNumEvents));
+	memset(_chanCurEvent, 0, sizeof(_chanCurEvent));
+}
+
+const MacLowLevelPCMDriver::PCMSound *MacSndLoader::getInstrData(uint16 chan) {
+	return (chan < ARRAYSIZE(_chanInstr) && _chanInstr[chan]) ? _chanInstr[chan]->get()->data() : nullptr;
+}
+
+bool MacSndLoader::loadInstruments(const char *const *tryFileNames, uint16 numTryFileNames, uint16 numInstruments) {
+	assert(tryFileNames && numTryFileNames && numInstruments);
+	uint32 tag = 0;
+	const Common::CodePage tryCodePages[] = {
+		Common::kMacRoman,
+		Common::kISO8859_1
+	};
+
+	Common::MacResManager resMan;
+	Common::Path resFile;
+	for (int i = 0; resFile.empty() && i < numTryFileNames; ++i) {
+		for (int ii = 0; resFile.empty() && ii < ARRAYSIZE(tryCodePages); ++ii) {
+			Common::U32String fn(tryFileNames[i], tryCodePages[ii]);
+			resFile = Common::Path(fn.encode(Common::kUtf8));
+			if (!resMan.exists(resFile) || !resMan.open(resFile) || !resMan.hasResFork()) {
+				resMan.close();
+				resFile = Common::Path(Common::punycode_encodefilename(fn));
+				if (!resMan.exists(resFile) || !resMan.open(resFile) || !resMan.hasResFork()) {
+					resMan.close();
+					resFile.clear();
+				}
+			}
+		}
+	}
+
+	if (resFile.empty()) {
+		warning("MacSndLoader::loadInstruments(): Resource fork not found");
+		return false;
+	}
+
+	Common::MacResIDArray ids = resMan.getResIDArray(MKTAG('s', 'n', 'd', ' '));
+	for (uint i = 0; i < ids.size(); ++i) {
+		Common::SeekableReadStream *str = resMan.getResource(MKTAG('s', 'n', 'd', ' '), ids[i]);
+		if (!str || str->readUint16BE() != 1) {
+			static const char *const errStr[2] = {"Failed to load", "Invalid sound resource format for"};
+			warning("MacSndLoader::loadInstruments(): %s instrument with id 0x%04x", errStr[str ? 1 : 0], ids[i]);
+			delete str;
+			return false;
+		}
+		Common::String nm(resMan.getResName(MKTAG('s', 'n', 'd', ' '), ids[i]));
+		memcpy(&tag, nm.c_str(), MIN<uint>(nm.size(), sizeof(tag)));
+		uint32 id = _useInstrTag ? FROM_BE_32(tag) : ids[i];
+		_instruments.push_back(Common::SharedPtr<MacSndResource>(new MacSndResource(id, str, Common::move(nm))));
+		delete str;
+	}
+
+	if (_instruments.size() != numInstruments)
+		warning("MacSndLoader::loadInstruments(): Unexpected number of instruments found (expected: %d, found: %d)", numInstruments, _instruments.size());
+
+	return true;
+}
+
+bool LoomMacSndLoader::init() {
+	static const char *const execNames[] = {
+		"Loom",
+		"Loom\xaa",
+		"Loom PPC",
+		"Loom\xaa PPC"
+	};
+
+	return loadInstruments(execNames, ARRAYSIZE(execNames), 10);
+}
+
+bool LoomMacSndLoader::checkResource(const byte *data, uint32 dataSize) const {
+	return (dataSize >= 14 && READ_BE_UINT16(data + 4) == MKTAG16('s','o') && !READ_BE_UINT32(data + 10));
+}
+
+bool LoomMacSndLoader::loadSound(const byte *data, uint32 dataSize) {
+	if (dataSize < 40)
+		return false;
+
+	_sndRes6 = READ_BE_UINT16(data + 6) & 0xff;
+	_isMusic = READ_BE_UINT16(data + 8) >> 8;
+	_sndRes10 = READ_BE_UINT16(data + 10) >> 8;
+	_chanSetup = READ_BE_UINT16(data + 16);
+	_timbre = READ_BE_UINT16(data + 18);
+	for (int i = 0; i < 5; ++i) {
+		_chanInstr[i] = fetchInstrument(READ_BE_UINT16(data + 20 + 2 * i));
+		_chanSndData[i] = data + READ_BE_UINT16(data + 30 + 2 * i) + 6;
+		_chanNumEvents[i] = READ_BE_UINT16(_chanSndData[i] - 2);
+		_chanCurEvent[i] = 0;
+	}
+
+	return true;
+}
+
+bool LoomMacSndLoader::isInstrUsable(uint16 chan) const {
+	return (chan < ARRAYSIZE(_chanInstr) && _chanInstr[chan] && _chanInstr[chan]->get()->id() != 0x2D1C);
+}
+
+bool LoomMacSndLoader::parseNextEvent(uint16 chan, uint16 &duration, uint8 &note, bool &skip, bool &updateInstr) {
+	if (chan >= ARRAYSIZE(_chanSndData) || !_chanSndData[chan] || _chanCurEvent[chan] >= _chanNumEvents[chan])
+		return false;
+
+	const byte *s = _chanSndData[chan] + (_chanCurEvent[chan]++) * 3;
+	duration = READ_BE_UINT16(s);
+	note = s[2] & 0x7f;
+	skip = false;
+	updateInstr = false;
+
+	if (_synth == 4 && chan != 0 && note == 0)
+		note = 1;
+
+	return true;
+}
+
+const Common::SharedPtr<MacSndResource> *LoomMacSndLoader::fetchInstrument(uint16 id) const {
+	Common::Array<Common::SharedPtr<MacSndResource> >::const_iterator instr = _instruments.end();
+	for (Common::Array<Common::SharedPtr<MacSndResource> >::const_iterator i = _instruments.begin(); i != _instruments.end(); ++i) {
+		if ((*i)->id() == id)
+			return i;
+		else if ((*i)->id() == 0x2D1C)
+			instr = i;
+	}
+	return (instr != _instruments.end()) ? instr : nullptr;
+}
+
+bool MonkeyMacSndLoader::init() {
+	static const char *const execNames[] = {
+		"Monkey Island"
+	};
+
+	return loadInstruments(execNames, ARRAYSIZE(execNames), _numInstrumentsMax - 1);
+}
+
+bool MonkeyMacSndLoader::checkResource(const byte *data, uint32 dataSize) const {
+	return (dataSize >= 14 && (READ_BE_UINT32(data) == MKTAG('M', 'a', 'c', '0') || READ_BE_UINT32(data) == MKTAG('M', 'a', 'c', '1')));
+}
+
+bool MonkeyMacSndLoader::blocked(const byte *data, uint32 dataSize) const {
+	return (dataSize < 14 || (_blockSfx && !data[13]));
+}
+
+bool MonkeyMacSndLoader::loadSound(const byte *data, uint32 dataSize) {
+	if (dataSize < 32)
+		return false;
+
+	_sndRes9 = data[9];
+	_isMusic = data[13];
+	_sndRes10 = data[10];
+	_chanSetup = data[11];
+	_timbre = data[12];
+
+	for (int i = 0; i < 4; ++i) {
+		uint32 offs = READ_BE_UINT32(data + 16 + 4 * i);
+		_chanCurEvent[i] = 0;
+		if (offs) {
+			if (dataSize < offs + 12)
+				return false;
+			_chanInstr[i] = fetchInstrument(data, dataSize, READ_BE_UINT32(data + offs + 8));
+			_chanInstr2[i] = nullptr;
+			_chanSndData[i] = &data[offs + 12];
+			_chanNumEvents[i] = 0;
+
+			for (const byte *s = _chanSndData[i]; s < &data[dataSize - 4]; s += 4) {
+				uint32 in = READ_BE_UINT32(s);
+				if (in == MKTAG('L', 'o', 'o', 'p') || in == MKTAG('D', 'o', 'n', 'e')) {
+					if (i == 1)
+						_loop = (in == MKTAG('L', 'o', 'o', 'p'));
+					break;
+				}
+				_chanNumEvents[i]++;
+			}
+		} else {
+			_chanInstr[i] = nullptr;
+			_chanSndData[i] = nullptr;
+		}
+	}
+
+	_blockSfx = _isMusic;
+
+	return true;
+}
+
+bool MonkeyMacSndLoader::isInstrUsable(uint16 chan) const {
+	return (chan < ARRAYSIZE(_chanInstr) && _chanInstr[chan] && _chanInstr[chan]->get()->id() != MKTAG('s', 'i', 'l', 'e'));
+}
+
+bool MonkeyMacSndLoader::parseNextEvent(uint16 chan, uint16 &duration, uint8 &note, bool &skip, bool &updateInstr) {
+	if (chan >= ARRAYSIZE(_chanSndData) || !_chanSndData[chan] || _chanCurEvent[chan] >= _chanNumEvents[chan])
+		return false;
+
+	const byte *s = _chanSndData[chan] + (_chanCurEvent[chan]++) * 4;
+	duration = READ_BE_UINT16(s);
+	note = s[2];
+	skip = false;
+	updateInstr = true;
+
+	if (duration == 0 && _chanCurEvent[chan] == _chanNumEvents[chan])
+		skip = true;
+
+	if (_synth == 4) {
+		if (!skip && note == 0) {
+			note = 60;
+			_chanInstr2[chan] = _chanInstr[chan];
+			_chanInstr[chan] = fetchInstrument(nullptr, 0, MKTAG('s', 'i', 'l', 'e'));
+		} else if (_chanInstr2[chan]) {
+			_chanInstr[chan] = _chanInstr2[chan];
+			_chanInstr2[chan] = nullptr;
+		} else {
+			updateInstr = false;
+		}
+		if (note == 1)
+			skip = true;
+		else if (s[6] == 1)
+			duration += READ_BE_UINT16(s + 4);
+	} else {
+		updateInstr = false;
+		if (note == 1)
+			note = 0;
+		else if (note != 0)
+			note += _transpose;
+	}
+
+	return true;
+}
+
+const Common::SharedPtr<MacSndResource> *MonkeyMacSndLoader::fetchInstrument(const byte *data, uint32 dataSize, uint32 tagOrOffset) {
+	Common::Array<Common::SharedPtr<MacSndResource> >::const_iterator instr = _instruments.end();
+	if (tagOrOffset & ~0x7fffff) {
+		for (Common::Array<Common::SharedPtr<MacSndResource> >::const_iterator i = _instruments.begin(); i != _instruments.end(); ++i) {
+			if ((*i)->id() == tagOrOffset)
+				return i;
+			else if ((*i)->id() == MKTAG('s', 'i', 'l', 'e'))
+				instr = i;
+		}
+	} else if (dataSize >= tagOrOffset + 8) {
+		Common::SeekableReadStream *str = new Common::MemoryReadStream(&data[tagOrOffset + 8], READ_BE_UINT32(data + tagOrOffset + 4), DisposeAfterUse::NO);
+		if (_instruments.size() == _numInstrumentsMax)
+			_instruments.pop_back();
+		_instruments.push_back(Common::SharedPtr<MacSndResource>(new MacSndResource(READ_BE_UINT32(&data[tagOrOffset]), str, Common::String())));
+		delete str;
+		instr = _instruments.end() - 1;
+	}
+	return (instr != _instruments.end()) ? instr : nullptr;
+}
+
+Common::WeakPtr<LoomMonkeyMacSnd> *LoomMonkeyMacSnd::_inst = nullptr;
+
+LoomMonkeyMacSnd::LoomMonkeyMacSnd(ScummEngine *vm, Audio::Mixer *mixer) : VblTaskClientDriver(), _vm(vm), _mixer(mixer), _curSound(0), _loader(nullptr),
+	_macstr(nullptr), _sdrv(nullptr), _vblTskProc(this, &VblTaskClientDriver::vblCallback), _songTimer(0), _songTimerInternal(0), _disableFlags(0),
+	_machineRating(0), _selectedQuality(2), _effectiveChanConfig(0), _16bit(false), _idRangeMax(200), _sndChannel(0), _chanUse(0), _defaultChanConfig(0),
+	_chanConfigTable(nullptr), _chanPlaying(0), _curChanConfig(0), _curSynthType(0), _curSndType(Audio::Mixer::kPlainSoundType), _mixerThread(false),
+	_restartSound(0), _lastSndType(Audio::Mixer::kPlainSoundType), _chanCbProc(this, &MacLowLevelPCMDriver::CallbackClient::sndChannelCallback),
+	_curSoundSaveVar(0), _saveVersionChange(vm->_game.id == GID_MONKEY ? 115 : 114), _legacySaveUnits(vm->_game.id == GID_MONKEY ? 3 : 5),
+	_checkSound(vm->_game.id == GID_MONKEY ? _curSound : _curSoundSaveVar) {
+	assert(_vm);
+	assert(_mixer);
+
+	static const byte cfgtable[] = { 0, 0, 0, 1, 4, 5, 1, 5, 6, 6, 8, 9 };
+	_chanConfigTable = new byte[sizeof(cfgtable)]();
+	memcpy(_chanConfigTable, cfgtable, sizeof(cfgtable));
+
+	if (vm->_game.id == GID_MONKEY)
+		_chanConfigTable[10] = 7;
+
+	memset(_musChannels, 0, sizeof(_musChannels));
+}
+
+LoomMonkeyMacSnd::~LoomMonkeyMacSnd() {
+	_mixer->stopHandle(_soundHandle);
+	delete _macstr;
+	delete[] _chanConfigTable;
+
+	disposeAllChannels();
+	delete _sdrv;
+	delete _loader;
+
+	delete _inst;
+	_inst = nullptr;
+}
+
+Common::SharedPtr<LoomMonkeyMacSnd> LoomMonkeyMacSnd::open(ScummEngine *vm, Audio::Mixer *mixer) {
+	Common::SharedPtr<LoomMonkeyMacSnd> scp = nullptr;
+
+	if (_inst == nullptr) {
+		scp = Common::SharedPtr<LoomMonkeyMacSnd>(new LoomMonkeyMacSnd(vm, mixer));
+		_inst = new Common::WeakPtr<LoomMonkeyMacSnd>(scp);
+		// We can start this with the ScummVM mixer output rate instead of the ASC rate. The Mac sample rate converter can handle it (at
+		// least for up to 48 KHz, I haven't tried higher settings) and we don't have to do another rate conversion in the ScummVM mixer.
+		if ((_inst == nullptr) || (mixer == nullptr) || !(scp->startDevice(mixer->getOutputRate(), mixer->getOutputRate() << 16/*ASC_DEVICE_RATE*/, PCM_BUFFER_SIZE, true, false, true)))
+			error("LoomMonkeyMacSnd::open(): Failed to start player");
+	}
+
+	return _inst->lock();
+}
+
+bool LoomMonkeyMacSnd::startDevice(uint32 outputRate, uint32 pcmDeviceRate, uint32 feedBufferSize, bool enableInterpolation, bool stereo, bool internal16Bit) {
+	_macstr = new MacPlayerAudioStream(this, outputRate, stereo, enableInterpolation, internal16Bit);
+	if (!_macstr || !_mixer)
+		return false;
+
+	if (_vm->_game.id == GID_LOOM)
+		_loader = new LoomMacSndLoader();
+	else if(_vm->_game.id == GID_MONKEY)
+		_loader = new MonkeyMacSndLoader();
+
+	if (!_loader || !_loader->init())
+		return false;
+
+	_sdrv = new MacLowLevelPCMDriver(_mixer->mutex(), pcmDeviceRate, internal16Bit);
+	if (!_sdrv)
+		return false;
+
+	_effectiveChanConfig = 9;
+	_16bit = internal16Bit;
+
+	_macstr->initBuffers(feedBufferSize);
+	_macstr->addVolumeGroup(Audio::Mixer::kMusicSoundType);
+	_macstr->addVolumeGroup(Audio::Mixer::kSFXSoundType);
+	_macstr->setVblCallback(&_vblTskProc);
+
+	_mixer->playStream(Audio::Mixer::kPlainSoundType, &_soundHandle, _macstr, -1, Audio::Mixer::kMaxChannelVolume, 0, DisposeAfterUse::NO, true);
+
+	return true;
+}
+
+void LoomMonkeyMacSnd::setMusicVolume(int vol) {
+	Common::StackLock lock(_mixer->mutex());
+	if (_macstr)
+		_macstr->setMasterVolume(Audio::Mixer::kMusicSoundType, vol);
+}
+
+void LoomMonkeyMacSnd::setSfxVolume(int vol) {
+	Common::StackLock lock(_mixer->mutex());
+	if (_macstr)
+		_macstr->setMasterVolume(Audio::Mixer::kSFXSoundType, vol);
+}
+
+void LoomMonkeyMacSnd::startSound(int id, int jumpToTick) {
+	if (_sdrv == nullptr || id < 1 || id >= _idRangeMax) {
+		warning("LoomMonkeyMacSnd::startSound(): sound id '%d' out of range (1 - %d)", id, _idRangeMax - 1);
+		return;
+	}
+
+	Common::StackLock lock(_mixer->mutex());
+
+	uint32 size = _vm->getResourceSize(rtSound, id);
+	const byte *ptr = _vm->getResourceAddress(rtSound, id);
+	assert(ptr);
+
+	if (!_loader->checkResource(ptr, size)) {
+		warning("LoomMonkeyMacSnd::startSound(): Sound resource '%d' cannot be played", id);
+		return;
+	}
+
+	if (_loader->blocked(ptr, size))
+		return;
+
+	if (_curSound)
+		stopActiveSound();
+	if (_chanUse <= 1)
+		disposeAllChannels();
+
+	if (!_defaultChanConfig)
+		detectQuality();
+
+	if (!_loader->loadSound(ptr, size)) {
+		warning("LoomMonkeyMacSnd::startSound(): Sound resource '%d' cannot be played", id);
+		return;
+	}
+
+	if (_disableFlags) {
+		if (_loader->restartSoundAfterLoad()) {
+			_curSoundSaveVar = id;
+			_loader->unblock();
+		}
+		if (_loader->isMusic() || (_disableFlags & 2))
+			return;
+	}
+
+	_effectiveChanConfig = _loader->getChanSetup() ? _loader->getChanSetup() : _defaultChanConfig;
+	_curSndType = _loader->isMusic() ? Audio::Mixer::kMusicSoundType : Audio::Mixer::kSFXSoundType;
+
+	if (_lastSndType != _curSndType)
+		_curChanConfig = 0;
+
+	_curSound = id;
+	_curSoundSaveVar = _loader->restartSoundAfterLoad() ? _curSound : 0;
+
+	setupChannels();
+	sendSoundCommands(jumpToTick);
+
+	if (!jumpToTick) {
+		_songTimer = 0;
+		_songTimerInternal = 0;
+	}
+}
+
+void LoomMonkeyMacSnd::stopSound(int id) {
+	if (id < 1 || id >= _idRangeMax) {
+		warning("LoomMonkeyMacSnd::stopSound(): sound id '%d' out of range (1 - %d)", id, _idRangeMax - 1);
+		return;
+	}
+
+	Common::StackLock lock(_mixer->mutex());
+
+	if (id == _curSoundSaveVar)
+		_curSoundSaveVar = 0;
+
+	if (id == _curSound)
+		stopActiveSound();
+}
+
+void LoomMonkeyMacSnd::stopAllSounds() {
+	Common::StackLock lock(_mixer->mutex());
+	stopActiveSound();
+}
+
+int LoomMonkeyMacSnd::getMusicTimer() {
+	Common::StackLock lock(_mixer->mutex());
+	return _songTimer;
+}
+
+int LoomMonkeyMacSnd::getSoundStatus(int id) const {
+	if (id < 1 || id >= _idRangeMax) {
+		warning("LoomMonkeyMacSnd::getSoundStatus(): sound id '%d' out of range (1 - %d)", id, _idRangeMax - 1);
+		return 0;
+	}
+	Common::StackLock lock(_mixer->mutex());
+	return (_checkSound == id) ? 1 : 0;
+}
+
+void LoomMonkeyMacSnd::setQuality(int qual) {
+	assert(qual >= MacSound::kQualityAuto && qual <= MacSound::kQualityHighest);
+	Common::StackLock lock(_mixer->mutex());
+
+	if (qual > MacSound::kQualityAuto) {
+		qual--;
+		if (!_loader->ignoreMachineRating())
+			_machineRating = (qual / 3) + 1;
+		_selectedQuality = qual % 3;
+		qual = _chanConfigTable[_machineRating * 3 + _selectedQuality];
+		if (qual && qual == _defaultChanConfig)
+			return;
+	}
+
+	int csnd = _curSound;
+	int32 timeStamp = csnd ? _songTimer * 1000 + ((_songTimerInternal * 1000) / 30) : 0;
+	stopActiveSound();
+
+	detectQuality();
+	if (csnd)
+		startSound(csnd, timeStamp);
+}
+
+void LoomMonkeyMacSnd::saveLoadWithSerializer(Common::Serializer &ser) {
+	if (ser.isLoading() && ser.getVersion() < VER(94)) {
+		_curSound = _curSoundSaveVar = 0;
+		return;
+	}
+
+	if (ser.isLoading()) {
+		if (ser.getVersion() < VER(_saveVersionChange)) {
+			// Skip over old driver savedata, since it is not needed here.
+			ser.skip(4);
+			// We need only this
+			ser.syncAsSint16LE(_curSound);
+			_curSoundSaveVar = CLIP<int>(_curSound, 0, _idRangeMax - 1);
+			// Skip the rest
+			ser.skip(_legacySaveUnits * (ser.getVersion() >= VER(94) && ser.getVersion() <= VER(103) ? 24 : 20));
+		} else if (ser.getVersion() <= VER(114)) {
+			_curSoundSaveVar = 0;
+			byte tmp = 0;
+			for (int i = 0; !_curSoundSaveVar && i < 200; ++i) {
+				ser.syncAsByte(tmp);
+				if (tmp)
+					_curSoundSaveVar = i;
+			}
+		}
+	}
+	ser.syncAsSint16LE(_curSoundSaveVar, VER(115));
+}
+
+void LoomMonkeyMacSnd::restoreAfterLoad() {
+	int sound = _curSoundSaveVar;
+	stopActiveSound();
+	if (sound)
+		startSound(sound);
+}
+
+void LoomMonkeyMacSnd::toggleMusic(bool enable) {
+	if ((_disableFlags & 1) == (enable ? 0 : 1))
+		return;
+	_disableFlags ^= 1;
+	updateDisabledState();
+}
+
+void LoomMonkeyMacSnd::toggleSoundEffects(bool enable) {
+	if ((_disableFlags & 2) == (enable ? 0 : 2))
+		return;
+	_disableFlags ^= 2;
+	updateDisabledState();
+}
+
+void LoomMonkeyMacSnd::vblCallback() {
+	if (_songTimerInternal++ == 29) {
+		_songTimerInternal = 0;
+		++_songTimer;
+	}
+
+	if (_restartSound) {
+		startSound(_restartSound);
+		_restartSound = 0;
+	}
+}
+
+void LoomMonkeyMacSnd::generateData(int8 *dst, uint32 len, Audio::Mixer::SoundType type, bool expectStereo) const {
+	assert(dst);
+	memset(dst, 0, len);
+	_sdrv->feed(dst, len, type, expectStereo);
+}
+
+const MacSoundDriver::Status &LoomMonkeyMacSnd::getDriverStatus(Audio::Mixer::SoundType sndType) const {
+	return _sdrv->getStatus(sndType);
+}
+
+void LoomMonkeyMacSnd::sndChannelCallback(uint16 arg1, const void*) {
+	// The original Loom player stops the track immediately when the first channel invoked its end-of-track
+	// callback. This cuts of the playback early, in an unpleasant way. The Monkey Island player stops the
+	// playback not before all channels have finished. We do the same here for both games.
+	_chanPlaying &= ~arg1;
+	if (_chanPlaying)
+		return;
+
+	if (_loader->isLooping())
+		_restartSound = _curSound;
+
+	stopActiveSound();
+}
+
+void LoomMonkeyMacSnd::sendSoundCommands(int timeStamp) {
+	if (!_defaultChanConfig || !_curSound)
+		return;
+
+	uint16 duration = 0;
+	byte note = 0;
+	bool skip = false;
+	bool updateInstr = false;
+	_chanPlaying = 0;
+
+	if (_chanUse == 1 && _sndChannel) {
+		while (_loader->parseNextEvent(0, duration, note, skip, updateInstr)) {
+			if (timeStamp > 0 && !skip) {
+				timeStamp -= duration;
+				if (timeStamp >= 0)
+					skip = true;
+				else if (timeStamp < 0)
+					duration = -timeStamp;
+			}
+
+			if (updateInstr)
+				_sdrv->loadInstrument(_sndChannel, MacLowLevelPCMDriver::kEnqueue, _loader->getInstrData(0));
+
+			if (!skip) {
+				_sdrv->playNote(_sndChannel, MacLowLevelPCMDriver::kEnqueue, note, duration);
+				if (note == 0) // Workaround for tempo glitch in original driver
+					_sdrv->wait(_sndChannel, MacLowLevelPCMDriver::kEnqueue, duration);
+			}
+		}
+		_sdrv->quiet(_sndChannel, MacLowLevelPCMDriver::kEnqueue);
+		_sdrv->callback(_sndChannel, MacLowLevelPCMDriver::kEnqueue, 1, nullptr);
+		_chanPlaying |= 1;
+
+	} else if (_chanUse == 4) {
+		int tmstmp[4];
+		uint8 busy = 0;
+
+		for (int i = 0; i < 4; ++i) {
+			tmstmp[i] = timeStamp;
+			if (_musChannels[i])
+				busy |= (1 << i);
+		}
+
+		while (busy) {
+			for (int i = 0; i < 4; ++i) {
+				if (!(busy & (1 << i)) || !_loader->parseNextEvent(i + 1, duration, note, skip, updateInstr)) {
+					busy &= ~(1 << i);
+					continue;
+				}
+				if (tmstmp[i] > 0 && !skip) {
+					tmstmp[i] -= duration;
+					if (tmstmp[i] >= 0)
+						skip = true;
+					else if (tmstmp[i] < 0)
+						duration = -tmstmp[i];
+				}
+
+				if (updateInstr)
+					_sdrv->loadInstrument(_musChannels[i], MacLowLevelPCMDriver::kEnqueue, _loader->getInstrData(i + 1));
+
+				if (!skip) {
+					_sdrv->playNote(_musChannels[i], MacLowLevelPCMDriver::kEnqueue, note, duration);
+					// Workaround for tempo glitch in original driver. For the sampled synth in 4 channel mode, there is
+					// some sort of fix in the original (see parseNextEvent()), but that really does not work well for the other cases.
+					if (note == 0 && _curSynthType != 4)
+						_sdrv->wait(_musChannels[i], MacLowLevelPCMDriver::kEnqueue, duration);
+				}
+				_chanPlaying |= (1 << i);
+			}
+		}
+
+
+		for (int i = 0; i < 4; ++i) {
+			if (_chanPlaying & (1 << i)) {
+				_sdrv->quiet(_musChannels[i], MacLowLevelPCMDriver::kEnqueue);
+				_sdrv->callback(_musChannels[i], MacLowLevelPCMDriver::kEnqueue, 1 << i, nullptr);
+			}
+		}
+	}
+}
+
+void LoomMonkeyMacSnd::stopActiveSound() {
+	if (_sndChannel) {
+		_sdrv->quiet(_sndChannel, MacLowLevelPCMDriver::kImmediate);
+		_sdrv->flush(_sndChannel, MacLowLevelPCMDriver::kImmediate);
+	}
+
+	for (int i = 0; i < ARRAYSIZE(_musChannels); ++i) {
+		if (_musChannels[i]) {
+			_sdrv->quiet(_musChannels[i], MacLowLevelPCMDriver::kImmediate);
+			_sdrv->flush(_musChannels[i], MacLowLevelPCMDriver::kImmediate);
+		}
+	}
+
+	_chanPlaying = 0;
+	_curSound = 0;
+	_curSoundSaveVar = 0;
+	_loader->unblock();
+}
+
+void LoomMonkeyMacSnd::setupChannels() {
+	static const byte synthType[] =	{ 0x00,	0x01, 0x02, 0x04, 0x04, 0x04, 0x02, 0x04, 0x04, 0x04 };
+	static const byte numChan[] =	{ 0x00,	0x01, 0x01, 0x01, 0x01, 0x01, 0x04, 0x04, 0x04, 0x04 };
+	static const byte attrib[] =	{ 0x00, 0x00, 0x04, 0xAC, 0xA4, 0xA0, 0x04, 0xAC, 0xA4, 0xA0 };
+
+	if (!_defaultChanConfig)
+		return;
+
+	if (_curChanConfig != _effectiveChanConfig) {
+		disposeAllChannels();
+		_curChanConfig = _effectiveChanConfig;
+		_curSynthType = synthType[_curChanConfig];
+		_chanUse = numChan[_curChanConfig];
+		_lastSndType = _curSndType;
+		_loader->setSynthType(_curSynthType);
+
+		switch (_curSynthType) {
+		case 1:
+			if (_chanUse == 1 && !_sndChannel) {
+				_sndChannel = _sdrv->createChannel(_curSndType, MacLowLevelPCMDriver::kSquareWaveSynth, attrib[_curChanConfig], &_chanCbProc);
+			}
+			break;
+		case 2:
+			if (_chanUse == 1 && !_sndChannel) {
+				_sndChannel = _sdrv->createChannel(_curSndType, MacLowLevelPCMDriver::kWaveTableSynth, attrib[_curChanConfig], &_chanCbProc);
+			} else if (_chanUse == 4) {
+				for (int i = 0; i < ARRAYSIZE(_musChannels); ++i) {
+					if (!_musChannels[i] && _loader->isInstrUsable(i + 1))
+						_musChannels[i] = _sdrv->createChannel(_curSndType, MacLowLevelPCMDriver::kWaveTableSynth, attrib[_curChanConfig] + i, &_chanCbProc);
+				}
+			}
+			break;
+		case 4:
+			if (_chanUse == 1 && !_sndChannel) {
+				_sndChannel = _sdrv->createChannel(_curSndType, MacLowLevelPCMDriver::kSampledSynth, attrib[_curChanConfig], &_chanCbProc);
+			} else if (_chanUse == 4) {
+				for (int i = 0; i < ARRAYSIZE(_musChannels); ++i) {
+					if (!_musChannels[i] && _loader->isInstrUsable(i + 1))
+						_musChannels[i] = _sdrv->createChannel(_curSndType, MacLowLevelPCMDriver::kSampledSynth, attrib[_curChanConfig], &_chanCbProc);
+				}
+			}
+			break;
+		default:
+			break;
+		}
+	}
+
+	switch (_curSynthType) {
+	case 1:
+		if (_sndChannel)
+			_sdrv->setTimbre(_sndChannel, MacLowLevelPCMDriver::kImmediate, _loader->getTimbre());
+		break;
+	case 2:
+		if (_chanUse == 1) {
+			if (_sndChannel)
+				_sdrv->loadWaveTable(_sndChannel, MacLowLevelPCMDriver::kImmediate, _fourToneSynthWaveForm, _fourToneSynthWaveFormSize);
+		} else {
+			for (int i = 0; i < ARRAYSIZE(_musChannels); ++i) {
+				if (_musChannels[i])
+					_sdrv->loadWaveTable(_musChannels[i], MacLowLevelPCMDriver::kImmediate, _fourToneSynthWaveForm, _fourToneSynthWaveFormSize);
+			}
+		}
+		break;
+	case 4:
+		if (_chanUse == 1) {
+			if (_sndChannel && _loader->getInstrData(0))
+				_sdrv->loadInstrument(_sndChannel, MacLowLevelPCMDriver::kImmediate, _loader->getInstrData(0));
+		} else {
+			for (int i = 0; i < ARRAYSIZE(_musChannels); ++i) {
+				if (_musChannels[i] && _loader->getInstrData(i + 1))
+					_sdrv->loadInstrument(_musChannels[i], MacLowLevelPCMDriver::kImmediate, _loader->getInstrData(i + 1));
+			}
+		}
+		break;
+	default:
+		break;
+	}
+}
+
+void LoomMonkeyMacSnd::disposeAllChannels() {
+	if (_sndChannel)
+		_sdrv->disposeChannel(_sndChannel);
+	_sndChannel = 0;
+
+	for (int i = 0; i < ARRAYSIZE(_musChannels); ++i) {
+		if (_musChannels[i])
+			_sdrv->disposeChannel(_musChannels[i]);
+		_musChannels[i] = 0;
+	}
+
+	_curChanConfig = 0;
+}
+
+void LoomMonkeyMacSnd::updateDisabledState() {
+	if (_disableFlags == 0) {
+		if (_curSoundSaveVar)
+			startSound(_curSoundSaveVar);
+	} else {
+		int sound = _curSoundSaveVar;
+		stopActiveSound();
+		_curSoundSaveVar = sound;
+	}
+}
+
+void LoomMonkeyMacSnd::detectQuality() {
+	if (_machineRating == 0) {
+		if (!_loader->ignoreMachineRating()) {
+			if (isSoundCardType10())
+				_machineRating = 2;
+			/*else if (0)
+				_machineRating = 1;*/
+		}
+		_machineRating ^= 3;
+	}
+
+	_defaultChanConfig = _effectiveChanConfig = _chanConfigTable[_machineRating * 3 + _selectedQuality];
+	_curChanConfig = 0;
+	disposeAllChannels();
+	setupChannels();
+	_chanConfigTable[_machineRating * 3 + _selectedQuality] = _defaultChanConfig;
+}
+
+bool LoomMonkeyMacSnd::isSoundCardType10() const {
+	return _mixerThread ? (_machineRating == 1) : (_vm->VAR_SOUNDCARD != 0xff && _vm->VAR(_vm->VAR_SOUNDCARD) == 10);
+}
+
+#undef ASC_DEVICE_RATE
+#undef PCM_BUFFER_SIZE
+
+} // End of namespace Scumm