Initial commit

engines/scumm/players/player_apple2.cpp

@@ -0,0 +1,503 @@
+/* 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 "engines/engine.h"
+#include "scumm/players/player_apple2.h"
+#include "scumm/scumm.h"
+
+namespace Scumm {
+
+/************************************
+ * Apple-II sound-resource parsers
+ ************************************/
+
+/*
+ * SoundFunction1: frequency up/down
+ */
+class AppleII_SoundFunction1_FreqUpDown : public AppleII_SoundFunction {
+public:
+	void init(Player_AppleII *player, const byte *params) override {
+		_player = player;
+		_delta = params[0];
+		_count = params[1];
+		_interval = params[2];
+		_limit = params[3];
+		_decInterval = (params[4] >= 0x40);
+	}
+
+	bool update() override { // D085
+		if (_decInterval) {
+			do {
+				_update(_interval, _count);
+				_interval -= _delta;
+			} while (_interval >= _limit);
+		} else {
+			do {
+				_update(_interval, _count);
+				_interval += _delta;
+			} while (_interval < _limit);
+		}
+		return true;
+	}
+
+private:
+	void _update(int interval /*a*/, int count /*y*/) { // D076
+		assert(interval > 0); // 0 == 256?
+		assert(count > 0); // 0 == 256?
+
+		for (; count >= 0; --count) {
+			_player->speakerToggle();
+			_player->generateSamples(17 + 5 * interval);
+		}
+	}
+
+protected:
+	int _delta = 0;
+	int _count = 0;
+	byte _interval = 0; // must be unsigned byte ("interval < delta" possible)
+	int _limit = 0;
+	bool _decInterval = false;
+};
+
+/*
+ * SoundFunction2: symmetric wave (~)
+ */
+class AppleII_SoundFunction2_SymmetricWave : public AppleII_SoundFunction {
+public:
+	void init(Player_AppleII *player, const byte *params) override {
+		_player = player;
+		_params = params;
+		_pos = 1;
+	}
+
+	bool update() override { // D0D6
+		// while (pos = 1; pos < 256; ++pos)
+		if (_pos < 256) {
+			byte interval = _params[_pos];
+			if (interval == 0xFF)
+				return true;
+			_update(interval, _params[0] /*, LD12F=interval*/);
+
+			++_pos;
+			return false;
+		}
+		return true;
+	}
+
+private:
+	void _update(int interval /*a*/, int count) { // D0EF
+		if (interval == 0xFE) {
+			_player->wait(interval, 10);
+		} else {
+			assert(count > 0); // 0 == 256?
+			assert(interval > 0); // 0 == 256?
+
+			int a = (interval >> 3) + count;
+			for (int y = a; y > 0; --y) {
+				_player->generateSamples(1292 - 5*interval);
+				_player->speakerToggle();
+
+				_player->generateSamples(1287 - 5*interval);
+				_player->speakerToggle();
+			}
+		}
+	}
+
+protected:
+	const byte *_params = 0;
+	int _pos = 0;
+};
+
+/*
+ * SoundFunction3: asymmetric wave (__-)
+ */
+class AppleII_SoundFunction3_AsymmetricWave : public AppleII_SoundFunction {
+public:
+	void init(Player_AppleII *player, const byte *params) override {
+		_player = player;
+		_params = params;
+		_pos = 1;
+	}
+
+	bool update() override { // D132
+		// while (pos = 1; pos < 256; ++pos)
+		if (_pos < 256) {
+			byte interval = _params[_pos];
+			if (interval == 0xFF)
+				return true;
+			_update(interval, _params[0]);
+
+			++_pos;
+			return false;
+		}
+		return true;
+	}
+
+private:
+	void _update(int interval /*a*/, int count /*LD12D*/) { // D14B
+		if (interval == 0xFE) {
+			_player->wait(interval, 70);
+		} else {
+			assert(interval > 0); // 0 == 256?
+			assert(count > 0); // 0 == 256?
+
+			for (int y = count; y > 0; --y) {
+				_player->generateSamples(1289 - 5*interval);
+				_player->speakerToggle();
+			}
+		}
+	}
+
+protected:
+	const byte *_params = nullptr;
+	int _pos = 0;
+};
+
+/*
+ * SoundFunction4: polyphone (2 voices)
+ */
+class AppleII_SoundFunction4_Polyphone : public AppleII_SoundFunction {
+public:
+	void init(Player_AppleII *player, const byte *params) override {
+		_player = player;
+		_params = params;
+		_updateRemain1 = 80;
+		_updateRemain2 = 10;
+		_count = 0;
+	}
+
+	bool update() override { // D170
+		// while (_params[0] != 0x01)
+		if (_params[0] != 0x01) {
+			if (_count == 0) // prepare next loop
+				nextLoop(_params[0], _params[1], _params[2]);
+			if (loopIteration()) // loop finished -> fetch next parameter set
+				_params += 3;
+			return false;
+		}
+		return true;
+	}
+
+private:
+	/*
+	 * prepare for next parameter set loop
+	 */
+	void nextLoop(byte param0, byte param1, byte param2) { // LD182
+		_count = (-param2 << 8) | 0x3;
+
+		_bitmask1 = 0x3;
+		_bitmask2 = 0x3;
+
+		_updateInterval2 = param0;
+		if (_updateInterval2 == 0)
+			_bitmask2 = 0x0;
+
+		_updateInterval1 = param1;
+		if (_updateInterval1 == 0) {
+			_bitmask1 = 0x0;
+			if (_bitmask2 != 0) {
+				_bitmask1 = _bitmask2;
+				_bitmask2 = 0;
+				_updateInterval1 = _updateInterval2;
+			}
+		}
+
+		_speakerShiftReg = 0;
+	}
+
+	/*
+	 * perform one loop iteration
+	 * Returns true if loop finished
+	 */
+	bool loopIteration() { // D1A2
+		--_updateRemain1;
+		--_updateRemain2;
+
+		if (_updateRemain2 == 0) {
+			_updateRemain2 = _updateInterval2;
+			// use only first voice's data (bitmask1) if both voices are triggered
+			if (_updateRemain1 != 0) {
+				_speakerShiftReg ^= _bitmask2;
+			}
+		}
+
+		if (_updateRemain1 == 0) {
+			_updateRemain1 = _updateInterval1;
+			_speakerShiftReg ^= _bitmask1;
+		}
+
+		if (_count < 0xff80) { // add a note separation towards the end of the note, otherwise, play the note
+			if (_speakerShiftReg & 0x1)
+				_player->speakerToggle();
+		}
+		_speakerShiftReg >>= 1;
+		_player->generateSamples(42); /* actually 42.5 */
+
+		++_count;
+		return (_count == 0);
+	}
+
+protected:
+	const byte *_params = nullptr;
+
+	byte _updateRemain1 = 0;
+	byte _updateRemain2 = 0;
+
+	uint16 _count = 0;
+	byte _bitmask1 = 0;
+	byte _bitmask2 = 0;
+	byte _updateInterval1 = 0;
+	byte _updateInterval2 = 0;
+	byte _speakerShiftReg = 0;
+};
+
+/*
+ * SoundFunction5: periodic noise
+ */
+class AppleII_SoundFunction5_Noise : public AppleII_SoundFunction {
+public:
+	void init(Player_AppleII *player, const byte *params) override {
+		_player = player;
+		_index = 0;
+		_param0 = params[0];
+		assert(_param0 > 0);
+	}
+
+	bool update() override { // D222
+		const byte noiseMask[] = {
+			0x3F, 0x3F, 0x7F, 0x7F, 0x7F, 0x7F, 0xFF, 0xFF, 0xFF, 0x0F, 0x0F
+		};
+
+		// while (i = 0; i < 10; ++i)
+		if (_index < 10) {
+			int count = _param0;
+			do {
+				_update(noise() & noiseMask[_index], 1);
+				--count;
+			} while (count > 0);
+
+			++_index;
+			return false;
+		}
+
+		return true;
+	}
+
+private:
+	void _update(int interval /*a*/, int count) { // D270
+		assert(count > 0); // 0 == 256?
+		if (interval == 0)
+			interval = 256;
+
+		for (int i = count; i > 0; --i) {
+			_player->generateSamples(10 + 5*interval);
+			_player->speakerToggle();
+
+			_player->generateSamples(5 + 5*interval);
+			_player->speakerToggle();
+		}
+	}
+
+	byte /*a*/ noise() { // D261
+		static int pos = 0; // initial value?
+		byte result = _noiseTable[pos];
+		pos = (pos + 1) % 256;
+		return result;
+	}
+
+protected:
+	int _index = 0;
+	int _param0 = 0;
+
+private:
+	static const byte _noiseTable[256];
+};
+
+// LD000[loc] ^ LD00A[loc]
+const byte AppleII_SoundFunction5_Noise::_noiseTable[256] = {
+	0x65, 0x1b, 0xda, 0x11, 0x61, 0xe5, 0x77, 0x57, 0x92, 0xc8, 0x51, 0x1c, 0xd4, 0x91, 0x62, 0x63,
+	0x00, 0x38, 0x57, 0xd5, 0x18, 0xd8, 0xdc, 0x40, 0x03, 0x86, 0xd3, 0x2f, 0x10, 0x11, 0xd8, 0x3c,
+	0xbe, 0x00, 0x19, 0xc5, 0xd2, 0xc3, 0xca, 0x34, 0x00, 0x28, 0xbf, 0xb9, 0x18, 0x20, 0x01, 0xcc,
+	0xda, 0x08, 0xbc, 0x75, 0x7c, 0xb0, 0x8d, 0xe0, 0x09, 0x18, 0xbf, 0x5d, 0xe9, 0x8c, 0x75, 0x64,
+	0xe5, 0xb5, 0x5d, 0xe0, 0xb7, 0x7d, 0xe9, 0x8c, 0x55, 0x65, 0xc5, 0xb5, 0x5d, 0xd8, 0x09, 0x0d,
+	0x64, 0xf0, 0xf0, 0x08, 0x63, 0x03, 0x00, 0x55, 0x35, 0xc0, 0x00, 0x20, 0x74, 0xa5, 0x1e, 0xe3,
+	0x00, 0x06, 0x3c, 0x52, 0xd1, 0x70, 0xd0, 0x57, 0x02, 0xf0, 0x00, 0xb6, 0xfc, 0x02, 0x11, 0x9a,
+	0x3b, 0xc8, 0x38, 0xdf, 0x1a, 0xb0, 0xd1, 0xb8, 0xd0, 0x18, 0x8a, 0x4a, 0xea, 0x1b, 0x12, 0x5d,
+	0x29, 0x58, 0xd8, 0x43, 0xb8, 0x2d, 0xd2, 0x61, 0x10, 0x3c, 0x0c, 0x5d, 0x1b, 0x61, 0x10, 0x3c,
+	0x0a, 0x5d, 0x1d, 0x61, 0x10, 0x3c, 0x0b, 0x19, 0x88, 0x21, 0xc0, 0x21, 0x07, 0x00, 0x65, 0x62,
+	0x08, 0xe9, 0x36, 0x40, 0x20, 0x41, 0x06, 0x00, 0x20, 0x00, 0x00, 0xed, 0xa3, 0x00, 0x88, 0x06,
+	0x98, 0x01, 0x5d, 0x7f, 0x02, 0x1d, 0x78, 0x03, 0x60, 0xcb, 0x3a, 0x01, 0xbd, 0x78, 0x02, 0x5d,
+	0x7e, 0x03, 0x1d, 0xf5, 0xa6, 0x40, 0x81, 0xb4, 0xd0, 0x8d, 0xd3, 0xd0, 0x6d, 0xd5, 0x61, 0x48,
+	0x61, 0x4d, 0xd1, 0xc8, 0xb1, 0xd8, 0x69, 0xff, 0x61, 0xd9, 0xed, 0xa0, 0xfe, 0x19, 0x91, 0x37,
+	0x19, 0x37, 0x00, 0xf1, 0x00, 0x01, 0x1f, 0x00, 0xad, 0xc1, 0x01, 0x01, 0x2e, 0x00, 0x40, 0xc6,
+	0x7a, 0x9b, 0x95, 0x43, 0xfc, 0x18, 0xd2, 0x9e, 0x2a, 0x5a, 0x4b, 0x2a, 0xb6, 0x87, 0x30, 0x6c
+};
+
+/************************************
+ * Apple-II player
+ ************************************/
+
+Player_AppleII::Player_AppleII(ScummEngine *scumm, Audio::Mixer *mixer)
+	: _mixer(mixer), _vm(scumm), _soundFunc(nullptr) {
+	resetState();
+	setSampleRate(_mixer->getOutputRate());
+	_mixer->playStream(Audio::Mixer::kPlainSoundType, &_soundHandle, this, -1, Audio::Mixer::kMaxChannelVolume, 0, DisposeAfterUse::NO, true);
+}
+
+Player_AppleII::~Player_AppleII() {
+	_mixer->stopHandle(_soundHandle);
+	delete _soundFunc;
+}
+
+void Player_AppleII::resetState() {
+	_soundNr = 0;
+	_type = 0;
+	_loop = 0;
+	_params = nullptr;
+	_speakerState = 0;
+	delete _soundFunc;
+	_soundFunc = nullptr;
+	_sampleConverter.reset();
+}
+
+void Player_AppleII::startSound(int nr) {
+	Common::StackLock lock(_mutex);
+
+	byte *data = _vm->getResourceAddress(rtSound, nr);
+	assert(data);
+	byte *ptr1 = data + 4;
+
+	resetState();
+	_soundNr = nr;
+	_type = ptr1[0];
+	_loop = ptr1[1];
+	_params = &ptr1[2];
+
+	switch (_type) {
+	case 0: // empty (nothing to play)
+		resetState();
+		return;
+	case 1:
+		_soundFunc = new AppleII_SoundFunction1_FreqUpDown();
+		break;
+	case 2:
+		_soundFunc = new AppleII_SoundFunction2_SymmetricWave();
+		break;
+	case 3:
+		_soundFunc = new AppleII_SoundFunction3_AsymmetricWave();
+		break;
+	case 4:
+		_soundFunc = new AppleII_SoundFunction4_Polyphone();
+		break;
+	case 5:
+		_soundFunc = new AppleII_SoundFunction5_Noise();
+		break;
+	default:
+		break;
+	}
+	_soundFunc->init(this, _params);
+
+	assert(_loop > 0);
+
+	debug(4, "startSound %d: type %d, loop %d",
+		  nr, _type, _loop);
+}
+
+bool Player_AppleII::updateSound() {
+	if (!_soundFunc)
+		return false;
+
+	if (_soundFunc->update()) {
+		--_loop;
+		if (_loop <= 0) {
+			delete _soundFunc;
+			_soundFunc = nullptr;
+		} else {
+			// reset function state on each loop
+			_soundFunc->init(this, _params);
+		}
+	}
+
+	return true;
+}
+
+void Player_AppleII::stopAllSounds() {
+	Common::StackLock lock(_mutex);
+	resetState();
+}
+
+void Player_AppleII::stopSound(int nr) {
+	Common::StackLock lock(_mutex);
+	if (_soundNr == nr) {
+		resetState();
+	}
+}
+
+int Player_AppleII::getSoundStatus(int nr) const {
+	Common::StackLock lock(_mutex);
+	return (_soundNr == nr);
+}
+
+int Player_AppleII::getMusicTimer() {
+	/* Apple-II sounds are synchronous -> no music timer */
+	return 0;
+}
+
+int Player_AppleII::readBuffer(int16 *buffer, const int numSamples) {
+	Common::StackLock lock(_mutex);
+
+	if (!_soundNr)
+		return 0;
+
+	int samplesLeft = numSamples;
+	do {
+		int nSamplesRead = _sampleConverter.readSamples(buffer, samplesLeft);
+		samplesLeft -= nSamplesRead;
+		buffer += nSamplesRead;
+	} while ((samplesLeft > 0) && updateSound());
+
+	// reset state if sound is played completely
+	if (!_soundFunc && (_sampleConverter.availableSize() == 0))
+		resetState();
+
+	return numSamples - samplesLeft;
+}
+
+/************************************
+ * Apple-II sound-resource helpers
+ ************************************/
+
+// toggle speaker on/off
+void Player_AppleII::speakerToggle() {
+	_speakerState ^= 0x1;
+}
+
+void Player_AppleII::generateSamples(int cycles) {
+	_sampleConverter.addCycles(_speakerState, cycles);
+}
+
+void Player_AppleII::wait(int interval, int count /*y*/) {
+	assert(count > 0); // 0 == 256?
+	assert(interval > 0); // 0 == 256?
+	generateSamples(11 + count*(8 + 5 * interval));
+}
+
+} // End of namespace Scumm