aboutsummaryrefslogtreecommitdiff
path: root/sound
diff options
context:
space:
mode:
Diffstat (limited to 'sound')
-rw-r--r--sound/mods/maxtrax.cpp1038
-rw-r--r--sound/mods/maxtrax.h225
-rw-r--r--sound/mods/paula.cpp65
-rw-r--r--sound/mods/paula.h77
-rw-r--r--sound/mods/soundfx.cpp11
-rw-r--r--sound/mods/tfmx.cpp1189
-rw-r--r--sound/mods/tfmx.h284
-rw-r--r--sound/module.mk2
8 files changed, 2853 insertions, 38 deletions
diff --git a/sound/mods/maxtrax.cpp b/sound/mods/maxtrax.cpp
new file mode 100644
index 0000000000..90ac3d55ca
--- /dev/null
+++ b/sound/mods/maxtrax.cpp
@@ -0,0 +1,1038 @@
+/* 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$
+ *
+ */
+
+#include "common/scummsys.h"
+#include "common/endian.h"
+#include "common/stream.h"
+#include "common/util.h"
+#include "common/debug.h"
+
+#include "sound/mods/maxtrax.h"
+
+// test for engines using this class.
+#if defined(SOUND_MODS_MAXTRAX_H)
+
+namespace {
+
+enum { K_VALUE = 0x9fd77, PREF_PERIOD = 0x8fd77, PERIOD_LIMIT = 0x6f73d };
+enum { NO_BEND = 64 << 7, MAX_BEND_RANGE = 24 };
+
+int32 precalcNote(byte baseNote, int16 tune, byte octave) {
+ return K_VALUE + 0x3C000 - ((baseNote << 14) + (tune << 11) / 3) / 3 - (octave << 16);
+}
+
+int32 calcVolumeDelta(int32 delta, uint16 time, uint16 vBlankFreq) {
+ const int32 div = time * vBlankFreq;
+ // div <= 1000 means time to small (or even 0)
+ return (div <= 1000) ? delta : (1000 * delta) / div;
+}
+
+int32 calcTempo(const uint16 tempo, uint16 vBlankFreq) {
+ return (int32)(((uint32)(tempo & 0xFFF0) << 8) / (uint16)(5 * vBlankFreq));
+}
+
+void nullFunc(int) {}
+
+// Function to calculate 2^x, where x is a fixedpoint number with 16 fraction bits
+// using exp would be more accurate and needs less space if mathlibrary is already linked
+// but this function should be faster and doesnt use floats
+#if 1
+inline uint32 pow2Fixed(int32 val) {
+ static const uint16 tablePow2[] = {
+ 0, 178, 356, 535, 714, 893, 1073, 1254, 1435, 1617, 1799, 1981, 2164, 2348, 2532, 2716,
+ 2902, 3087, 3273, 3460, 3647, 3834, 4022, 4211, 4400, 4590, 4780, 4971, 5162, 5353, 5546, 5738,
+ 5932, 6125, 6320, 6514, 6710, 6906, 7102, 7299, 7496, 7694, 7893, 8092, 8292, 8492, 8693, 8894,
+ 9096, 9298, 9501, 9704, 9908, 10113, 10318, 10524, 10730, 10937, 11144, 11352, 11560, 11769, 11979, 12189,
+ 12400, 12611, 12823, 13036, 13249, 13462, 13676, 13891, 14106, 14322, 14539, 14756, 14974, 15192, 15411, 15630,
+ 15850, 16071, 16292, 16514, 16737, 16960, 17183, 17408, 17633, 17858, 18084, 18311, 18538, 18766, 18995, 19224,
+ 19454, 19684, 19915, 20147, 20379, 20612, 20846, 21080, 21315, 21550, 21786, 22023, 22260, 22498, 22737, 22977,
+ 23216, 23457, 23698, 23940, 24183, 24426, 24670, 24915, 25160, 25406, 25652, 25900, 26148, 26396, 26645, 26895,
+ 27146, 27397, 27649, 27902, 28155, 28409, 28664, 28919, 29175, 29432, 29690, 29948, 30207, 30466, 30727, 30988,
+ 31249, 31512, 31775, 32039, 32303, 32568, 32834, 33101, 33369, 33637, 33906, 34175, 34446, 34717, 34988, 35261,
+ 35534, 35808, 36083, 36359, 36635, 36912, 37190, 37468, 37747, 38028, 38308, 38590, 38872, 39155, 39439, 39724,
+ 40009, 40295, 40582, 40870, 41158, 41448, 41738, 42029, 42320, 42613, 42906, 43200, 43495, 43790, 44087, 44384,
+ 44682, 44981, 45280, 45581, 45882, 46184, 46487, 46791, 47095, 47401, 47707, 48014, 48322, 48631, 48940, 49251,
+ 49562, 49874, 50187, 50500, 50815, 51131, 51447, 51764, 52082, 52401, 52721, 53041, 53363, 53685, 54008, 54333,
+ 54658, 54983, 55310, 55638, 55966, 56296, 56626, 56957, 57289, 57622, 57956, 58291, 58627, 58964, 59301, 59640,
+ 59979, 60319, 60661, 61003, 61346, 61690, 62035, 62381, 62727, 63075, 63424, 63774, 64124, 64476, 64828, 65182,
+ 0
+ };
+ const uint16 whole = val >> 16;
+ const uint8 index = (uint8)(val >> 8);
+ // calculate fractional part.
+ const uint16 base = tablePow2[index];
+ // linear interpolation and add 1.0
+ uint32 exponent = ((uint32)(uint16)(tablePow2[index + 1] - base) * (uint8)val) + ((uint32)base << 8) + (1 << 24);
+
+ if (whole < 24) {
+ // shift away all but the last fractional bit which is used for rounding,
+ // then round to nearest integer
+ exponent = ((exponent >> (23 - whole)) + 1) >> 1;
+ } else if (whole < 32) {
+ // no need to round here
+ exponent <<= whole - 24;
+ } else if (val > 0) {
+ // overflow
+ exponent = 0xFFFFFFFF;
+ } else {
+ // negative integer, test if >= -0.5
+ exponent = (val >= -0x8000) ? 1 : 0;
+ }
+ return exponent;
+}
+#else
+inline uint32 pow2Fixed(int32 val) {
+ return (uint32)(expf((float)val * (float)(0.69314718055994530942 / (1 << 16))) + 0.5f);
+}
+#endif
+
+} // End of namespace
+
+namespace Audio {
+
+MaxTrax::MaxTrax(int rate, bool stereo, uint16 vBlankFreq, uint16 maxScores)
+ : Paula(stereo, rate, rate / vBlankFreq),
+ _patch(),
+ _scores(),
+ _numScores() {
+ _playerCtx.maxScoreNum = maxScores;
+ _playerCtx.vBlankFreq = vBlankFreq;
+ _playerCtx.frameUnit = (uint16)((1000 << 8) / vBlankFreq);
+ _playerCtx.scoreIndex = -1;
+ _playerCtx.volume = 0x40;
+
+ _playerCtx.tempo = 120;
+ _playerCtx.tempoTime = 0;
+ _playerCtx.filterOn = true;
+ _playerCtx.syncCallBack = &nullFunc;
+
+ resetPlayer();
+ for (int i = 0; i < ARRAYSIZE(_channelCtx); ++i)
+ _channelCtx[i].regParamNumber = 0;
+}
+
+MaxTrax::~MaxTrax() {
+ stopMusic();
+ freePatches();
+ freeScores();
+}
+
+void MaxTrax::interrupt() {
+ // a5 - maxtraxm a4 . globaldata
+
+ // TODO
+ // test for changes in shared struct and make changes
+ // specifically all used channels get marked altered
+
+ _playerCtx.ticks += _playerCtx.tickUnit;
+ const int32 millis = _playerCtx.ticks >> 8; // d4
+
+ for (int i = 0; i < ARRAYSIZE(_voiceCtx); ++i) {
+ VoiceContext &voice = _voiceCtx[i];
+ if (voice.stopEventTime >= 0) {
+ assert(voice.channel);
+ voice.stopEventTime -= (voice.channel < &_channelCtx[kNumChannels]) ? _playerCtx.tickUnit : _playerCtx.frameUnit;
+ if (voice.stopEventTime <= 0 && voice.status > VoiceContext::kStatusRelease) {
+ if ((voice.channel->flags & ChannelContext::kFlagDamper) != 0)
+ voice.hasDamper = true;
+ else
+ voice.status = VoiceContext::kStatusRelease;
+ }
+ }
+ }
+
+ if (_playerCtx.scoreIndex >= 0) {
+ const Event *curEvent = _playerCtx.nextEvent;
+ int32 eventDelta = _playerCtx.nextEventTime - millis;
+ for (; eventDelta <= 0; eventDelta += (++curEvent)->startTime) {
+ const byte cmd = curEvent->command;
+ ChannelContext &channel = _channelCtx[curEvent->parameter & 0x0F];
+
+ // outPutEvent(*curEvent);
+ // debug("CurTime, EventDelta, NextDelta: %d, %d, %d", millis, eventDelta, eventDelta + curEvent[1].startTime );
+
+ if (cmd < 0x80) { // Note
+ const int8 voiceIndex = noteOn(channel, cmd, (curEvent->parameter & 0xF0) >> 1, kPriorityScore);
+ if (voiceIndex >= 0)
+ _voiceCtx[voiceIndex].stopEventTime = MAX(0, (eventDelta + curEvent->stopTime) << 8);
+
+ } else {
+ switch (cmd) {
+
+ case 0x80: // TEMPO
+ if ((_playerCtx.tickUnit >> 8) > curEvent->stopTime) {
+ _playerCtx.tickUnit = calcTempo(curEvent->parameter << 4, _playerCtx.vBlankFreq);
+ _playerCtx.tempoTime = 0;
+ } else {
+ _playerCtx.tempoStart = _playerCtx.tempo;
+ _playerCtx.tempoDelta = (curEvent->parameter << 4) - _playerCtx.tempoStart;
+ _playerCtx.tempoTime = (curEvent->stopTime << 8);
+ _playerCtx.tempoTicks = 0;
+ }
+ break;
+
+ case 0xC0: // PROGRAM
+ channel.patch = &_patch[curEvent->stopTime & (kNumPatches - 1)];
+ break;
+
+ case 0xE0: // BEND
+ channel.pitchBend = ((curEvent->stopTime & 0x7F00) >> 1) | (curEvent->stopTime & 0x7f);
+ channel.pitchReal = (((int32)channel.pitchBendRange * channel.pitchBend) >> 5) - (channel.pitchBendRange << 8);
+ channel.isAltered = true;
+ break;
+
+ case 0xFF: // END
+ if (_playerCtx.musicLoop) {
+ curEvent = _scores[_playerCtx.scoreIndex].events;
+ eventDelta = curEvent->startTime - millis;
+ _playerCtx.ticks = 0;
+ } else
+ _playerCtx.scoreIndex = -1;
+ // stop processing for this tick
+ goto endOfEventLoop;
+
+ case 0xA0: // SPECIAL
+ switch (curEvent->stopTime >> 8){
+ case 0x01: // SPECIAL_SYNC
+ _playerCtx.syncCallBack(curEvent->stopTime & 0xFF);
+ break;
+ case 0x02: // SPECIAL_BEGINREP
+ // we allow a depth of 4 loops
+ for (int i = 0; i < ARRAYSIZE(_playerCtx.repeatPoint); ++i) {
+ if (!_playerCtx.repeatPoint[i]) {
+ _playerCtx.repeatPoint[i] = curEvent;
+ _playerCtx.repeatCount[i] = curEvent->stopTime & 0xFF;
+ break;
+ }
+ }
+ break;
+ case 0x03: // SPECIAL_ENDREP
+ for (int i = ARRAYSIZE(_playerCtx.repeatPoint) - 1; i >= 0; --i) {
+ if (_playerCtx.repeatPoint[i]) {
+ if (_playerCtx.repeatCount[i]--)
+ curEvent = _playerCtx.repeatPoint[i]; // gets incremented by 1 at end of loop
+ else
+ _playerCtx.repeatPoint[i] = 0;
+ break;
+ }
+ }
+ break;
+ }
+ break;
+
+ case 0xB0: // CONTROL
+ controlCh(channel, (byte)(curEvent->stopTime >> 8), (byte)curEvent->stopTime);
+ break;
+
+ default:
+ debug("Unhandled Command");
+ outPutEvent(*curEvent);
+ }
+ }
+ }
+endOfEventLoop:
+ _playerCtx.nextEvent = curEvent;
+ _playerCtx.nextEventTime = eventDelta + millis;
+
+ // tempoEffect
+ if (_playerCtx.tempoTime) {
+ _playerCtx.tempoTicks += _playerCtx.tickUnit;
+ uint16 newTempo = _playerCtx.tempoStart;
+ if (_playerCtx.tempoTicks < _playerCtx.tempoTime) {
+ newTempo += (uint16)((_playerCtx.tempoTicks * _playerCtx.tempoDelta) / _playerCtx.tempoTime);
+ } else {
+ _playerCtx.tempoTime = 0;
+ newTempo += _playerCtx.tempoDelta;
+ }
+ _playerCtx.tickUnit = calcTempo(newTempo, _playerCtx.vBlankFreq);
+ }
+ }
+
+ // Handling of Envelopes and Portamento
+ for (int i = 0; i < ARRAYSIZE(_voiceCtx); ++i) {
+ VoiceContext &voice = _voiceCtx[i];
+ if (!voice.channel)
+ continue;
+ const ChannelContext &channel = *voice.channel;
+ const Patch &patch = *voice.patch;
+
+ switch (voice.status) {
+ case VoiceContext::kStatusSustain:
+ // we need to check if some voices have no sustainSample.
+ // in that case they are finished after the attackSample is done
+ if (voice.dmaOff && Paula::getChannelDmaCount((byte)i) >= voice.dmaOff ) {
+ voice.dmaOff = 0;
+ voice.isBlocked = 0;
+ voice.priority = 0;
+ // disable it in next tick
+ voice.stopEventTime = 0;
+ }
+ if (!channel.isAltered && !voice.hasPortamento && !channel.modulation)
+ continue;
+ // Update Volume and Period
+ break;
+
+ case VoiceContext::kStatusHalt:
+ killVoice((byte)i);
+ continue;
+
+ case VoiceContext::kStatusStart:
+ if (patch.attackLen) {
+ voice.envelope = patch.attackPtr;
+ const uint16 duration = voice.envelope->duration;
+ voice.envelopeLeft = patch.attackLen;
+ voice.ticksLeft = duration << 8;
+ voice.status = VoiceContext::kStatusAttack;
+ voice.incrVolume = calcVolumeDelta((int32)voice.envelope->volume, duration, _playerCtx.vBlankFreq);
+ // Process Envelope
+ } else {
+ voice.status = VoiceContext::kStatusSustain;
+ voice.baseVolume = patch.volume;
+ // Update Volume and Period
+ }
+ break;
+
+ case VoiceContext::kStatusRelease:
+ if (patch.releaseLen) {
+ voice.envelope = patch.attackPtr + patch.attackLen;
+ const uint16 duration = voice.envelope->duration;
+ voice.envelopeLeft = patch.releaseLen;
+ voice.ticksLeft = duration << 8;
+ voice.status = VoiceContext::kStatusDecay;
+ voice.incrVolume = calcVolumeDelta((int32)voice.envelope->volume - voice.baseVolume, duration, _playerCtx.vBlankFreq);
+ // Process Envelope
+ } else {
+ voice.status = VoiceContext::kStatusHalt;
+ voice.lastVolume = 0;
+ // Send Audio Packet
+ }
+ voice.stopEventTime = -1;
+ break;
+ }
+
+ // Process Envelope
+ const uint16 envUnit = _playerCtx.frameUnit;
+ if (voice.envelope) {
+ if (voice.ticksLeft > envUnit) { // envelope still active
+ voice.baseVolume = (uint16)MIN(MAX(0, voice.baseVolume + voice.incrVolume), 0x8000);
+ voice.ticksLeft -= envUnit;
+ // Update Volume and Period
+
+ } else { // next or last Envelope
+ voice.baseVolume = voice.envelope->volume;
+ assert(voice.envelopeLeft > 0);
+ if (--voice.envelopeLeft) {
+ ++voice.envelope;
+ const uint16 duration = voice.envelope->duration;
+ voice.ticksLeft = duration << 8;
+ voice.incrVolume = calcVolumeDelta((int32)voice.envelope->volume - voice.baseVolume, duration, _playerCtx.vBlankFreq);
+ // Update Volume and Period
+ } else if (voice.status == VoiceContext::kStatusDecay) {
+ voice.status = VoiceContext::kStatusHalt;
+ voice.envelope = 0;
+ voice.lastVolume = 0;
+ // Send Audio Packet
+ } else {
+ assert(voice.status == VoiceContext::kStatusAttack);
+ voice.status = VoiceContext::kStatusSustain;
+ voice.envelope = 0;
+ // Update Volume and Period
+ }
+ }
+ }
+
+ // Update Volume and Period
+ if (voice.status >= VoiceContext::kStatusDecay) {
+ // Calc volume
+ uint16 vol = (voice.noteVolume < (1 << 7)) ? (voice.noteVolume * _playerCtx.volume) >> 7 : _playerCtx.volume;
+ if (voice.baseVolume < (1 << 15))
+ vol = (uint16)(((uint32)vol * voice.baseVolume) >> 15);
+ if (voice.channel->volume < (1 << 7))
+ vol = (vol * voice.channel->volume) >> 7;
+ voice.lastVolume = (byte)MIN(vol, (uint16)0x64);
+
+ // Calc Period
+ if (voice.hasPortamento) {
+ voice.portaTicks += envUnit;
+ if ((uint16)(voice.portaTicks >> 8) >= channel.portamentoTime) {
+ voice.hasPortamento = false;
+ voice.baseNote = voice.endNote;
+ voice.preCalcNote = precalcNote(voice.baseNote, patch.tune, voice.octave);
+ }
+ voice.lastPeriod = calcNote(voice);
+ } else if (channel.isAltered || channel.modulation)
+ voice.lastPeriod = calcNote(voice);
+ }
+
+ // Send Audio Packet
+ Paula::setChannelPeriod((byte)i, (voice.lastPeriod) ? voice.lastPeriod : 1000);
+ Paula::setChannelVolume((byte)i, (voice.lastPeriod) ? voice.lastVolume : 0);
+ }
+ for (ChannelContext *c = _channelCtx; c != &_channelCtx[ARRAYSIZE(_channelCtx)]; ++c)
+ c->isAltered = false;
+
+#ifdef MAXTRAX_HAS_MODULATION
+ // original player had _playerCtx.sineValue = _playerCtx.frameUnit >> 2
+ // this should fit the comments that modtime=1000 is one second ?
+ _playerCtx.sineValue += _playerCtx.frameUnit;
+#endif
+}
+
+void MaxTrax::controlCh(ChannelContext &channel, const byte command, const byte data) {
+ switch (command) {
+ case 0x01: // modulation level MSB
+ channel.modulation = data << 8;
+ break;
+ case 0x21: // modulation level LSB
+ channel.modulation = (channel.modulation & 0xFF00) || ((data * 2) & 0xFF);
+ break;
+ case 0x05: // portamento time MSB
+ channel.portamentoTime = data << 7;
+ break;
+ case 0x25: // portamento time LSB
+ channel.portamentoTime = (channel.portamentoTime & 0x3f80) || data;
+ break;
+ case 0x06: // data entry MSB
+ if (channel.regParamNumber == 0) {
+ channel.pitchBendRange = (int8)MIN((uint8)MAX_BEND_RANGE, (uint8)data);
+ channel.pitchReal = (((int32)channel.pitchBendRange * channel.pitchBend) >> 5) - (channel.pitchBendRange << 8);
+ channel.isAltered = true;
+ }
+ break;
+ case 0x07: // Main Volume MSB
+ channel.volume = (data == 0) ? 0 : data + 1;
+ channel.isAltered = true;
+ break;
+ case 0x0A: // Pan
+ if (data > 0x40 || (data == 0x40 && ((&channel - _channelCtx) & 1) != 0))
+ channel.flags |= ChannelContext::kFlagRightChannel;
+ else
+ channel.flags &= ~ChannelContext::kFlagRightChannel;
+ break;
+ case 0x10: // GPC as Modulation Time MSB
+ channel.modulationTime = data << 7;
+ break;
+ case 0x30: // GPC as Modulation Time LSB
+ channel.modulationTime = (channel.modulationTime & 0x3f80) || data;
+ break;
+ case 0x11: // GPC as Microtonal Set MSB
+ channel.microtonal = data << 8;
+ break;
+ case 0x31: // GPC as Microtonal Set LSB
+ channel.microtonal = (channel.microtonal & 0xFF00) || ((data * 2) & 0xFF);
+ break;
+ case 0x40: // Damper Pedal
+ if ((data & 0x40) != 0)
+ channel.flags |= ChannelContext::kFlagDamper;
+ else {
+ channel.flags &= ~ChannelContext::kFlagDamper;
+ // release all dampered voices on this channel
+ for (int i = 0; i < ARRAYSIZE(_voiceCtx); ++i) {
+ if (_voiceCtx[i].channel == &channel && _voiceCtx[i].hasDamper) {
+ _voiceCtx[i].hasDamper = false;
+ _voiceCtx[i].status = VoiceContext::kStatusRelease;
+ }
+ }
+ }
+ break;
+ case 0x41: // Portamento off/on
+ if ((data & 0x40) != 0)
+ channel.flags |= ChannelContext::kFlagPortamento;
+ else
+ channel.flags &= ~ChannelContext::kFlagPortamento;
+ break;
+ case 0x50: // Microtonal off/on
+ if ((data & 0x40) != 0)
+ channel.flags |= ChannelContext::kFlagMicrotonal;
+ else
+ channel.flags &= ~ChannelContext::kFlagMicrotonal;
+ break;
+ case 0x51: // Audio Filter off/on
+ Paula::setAudioFilter(data > 0x40 || (data == 0x40 && _playerCtx.filterOn));
+ break;
+ case 0x65: // RPN MSB
+ channel.regParamNumber = (data << 8) || (channel.regParamNumber & 0xFF);
+ break;
+ case 0x64: // RPN LSB
+ channel.regParamNumber = (channel.regParamNumber & 0xFF00) || data;
+ break;
+ case 0x79: // Reset All Controllers
+ resetChannel(channel, ((&channel - _channelCtx) & 1) != 0);
+ break;
+ case 0x7E: // MONO mode
+ channel.flags |= ChannelContext::kFlagMono;
+ goto allNotesOff;
+ case 0x7F: // POLY mode
+ channel.flags &= ~ChannelContext::kFlagMono;
+ // Fallthrough
+ case 0x7B: // All Notes Off
+allNotesOff:
+ for (int i = 0; i < ARRAYSIZE(_voiceCtx); ++i) {
+ if (_voiceCtx[i].channel == &channel) {
+ if ((channel.flags & ChannelContext::kFlagDamper) != 0)
+ _voiceCtx[i].hasDamper = true;
+ else
+ _voiceCtx[i].status = VoiceContext::kStatusRelease;
+ }
+ }
+ break;
+ case 0x78: // All Sounds Off
+ for (int i = 0; i < ARRAYSIZE(_voiceCtx); ++i) {
+ if (_voiceCtx[i].channel == &channel)
+ killVoice((byte)i);
+ }
+ break;
+ }
+}
+
+void MaxTrax::setTempo(const uint16 tempo) {
+ Common::StackLock lock(_mutex);
+ _playerCtx.tickUnit = calcTempo(tempo, _playerCtx.vBlankFreq);
+}
+
+void MaxTrax::resetPlayer() {
+ for (int i = 0; i < ARRAYSIZE(_voiceCtx); ++i)
+ killVoice((byte)i);
+
+ for (int i = 0; i < ARRAYSIZE(_channelCtx); ++i) {
+ _channelCtx[i].flags = 0;
+ _channelCtx[i].lastNote = (uint8)-1;
+ resetChannel(_channelCtx[i], (i & 1) != 0);
+ _channelCtx[i].patch = (i < kNumChannels) ? &_patch[i] : 0;
+ }
+
+#ifdef MAXTRAX_HAS_MICROTONAL
+ for (int i = 0; i < ARRAYSIZE(_microtonal); ++i)
+ _microtonal[i] = (int16)(i << 8);
+#endif
+}
+
+void MaxTrax::stopMusic() {
+ Common::StackLock lock(_mutex);
+ _playerCtx.scoreIndex = -1;
+ for (int i = 0; i < ARRAYSIZE(_voiceCtx); ++i) {
+ if (_voiceCtx[i].channel < &_channelCtx[kNumChannels])
+ killVoice((byte)i);
+ }
+}
+
+bool MaxTrax::playSong(int songIndex, bool loop) {
+ if (songIndex < 0 || songIndex >= _numScores)
+ return false;
+ Common::StackLock lock(_mutex);
+ _playerCtx.scoreIndex = -1;
+ resetPlayer();
+ for (int i = 0; i < ARRAYSIZE(_playerCtx.repeatPoint); ++i)
+ _playerCtx.repeatPoint[i] = 0;
+
+ setTempo(_playerCtx.tempoInitial << 4);
+ Paula::setAudioFilter(_playerCtx.filterOn);
+ _playerCtx.musicLoop = loop;
+ _playerCtx.tempoTime = 0;
+ _playerCtx.scoreIndex = songIndex;
+ _playerCtx.ticks = 0;
+
+ _playerCtx.nextEvent = _scores[songIndex].events;;
+ _playerCtx.nextEventTime = _playerCtx.nextEvent->startTime;
+
+ Paula::startPaula();
+ return true;
+}
+
+void MaxTrax::advanceSong(int advance) {
+ Common::StackLock lock(_mutex);
+ if (_playerCtx.scoreIndex >= 0) {
+ const Event *cev = _playerCtx.nextEvent;
+ if (cev) {
+ for (; advance > 0; --advance) {
+ // TODO - check for boundaries
+ for (; cev->command != 0xFF && (cev->command != 0xA0 || (cev->stopTime >> 8) != 0x00); ++cev)
+ ; // no end_command or special_command + end
+ }
+ _playerCtx.nextEvent = cev;
+ }
+ }
+}
+
+void MaxTrax::killVoice(byte num) {
+ VoiceContext &voice = _voiceCtx[num];
+ voice.channel = 0;
+ voice.envelope = 0;
+ voice.status = VoiceContext::kStatusFree;
+ voice.isBlocked = 0;
+ voice.hasDamper = false;
+ voice.hasPortamento = false;
+ voice.priority = 0;
+ voice.stopEventTime = -1;
+ voice.dmaOff = 0;
+ voice.lastVolume = 0;
+ voice.tieBreak = 0;
+ //voice.uinqueId = 0;
+
+ // "stop" voice, set period to 1, vol to 0
+ Paula::disableChannel(num);
+ Paula::setChannelPeriod(num, 1);
+ Paula::setChannelVolume(num, 0);
+}
+
+int8 MaxTrax::pickvoice(uint pick, int16 pri) {
+ enum { kPrioFlagFixedSide = 1 << 3 };
+ pick &= 3;
+ if ((pri & (kPrioFlagFixedSide)) == 0) {
+ const bool leftSide = (uint)(pick - 1) > 1;
+ const int leftBest = MIN(_voiceCtx[0].status, _voiceCtx[3].status);
+ const int rightBest = MIN(_voiceCtx[1].status, _voiceCtx[2].status);
+ const int sameSide = (leftSide) ? leftBest : rightBest;
+ const int otherSide = leftBest + rightBest - sameSide;
+
+ if (sameSide > VoiceContext::kStatusRelease && otherSide <= VoiceContext::kStatusRelease)
+ pick ^= 1; // switches sides
+ }
+ pri &= ~kPrioFlagFixedSide;
+
+ for (int i = 2; i > 0; --i) {
+ VoiceContext *voice = &_voiceCtx[pick];
+ VoiceContext *alternate = &_voiceCtx[pick ^ 3];
+
+ const uint16 voiceVal = voice->status << 8 | voice->lastVolume;
+ const uint16 altVal = alternate->status << 8 | alternate->lastVolume;
+
+ if (voiceVal + voice->tieBreak > altVal
+ || voice->isBlocked > alternate->isBlocked) {
+
+ // this is somewhat different to the original player,
+ // but has a similar result
+ voice->tieBreak = 0;
+ alternate->tieBreak = 1;
+
+ pick ^= 3; // switch channels
+ VoiceContext *tmp = voice;
+ voice = alternate;
+ alternate = tmp;
+ }
+
+ if (voice->isBlocked || voice->priority > pri) {
+ // if not already done, switch sides and try again
+ pick ^= 1;
+ continue;
+ }
+ // succeded
+ return (int8)pick;
+ }
+ // failed
+ debug(5, "MaxTrax: could not find channel for note");
+ return -1;
+}
+
+uint16 MaxTrax::calcNote(const VoiceContext &voice) {
+ const ChannelContext &channel = *voice.channel;
+ int16 bend = channel.pitchReal;
+
+#ifdef MAXTRAX_HAS_MICROTONAL
+ if (voice.hasPortamento) {
+ if ((channel.flags & ChannelContext::kFlagMicrotonal) != 0)
+ bend += (int16)(((_microtonal[voice.endNote] - _microtonal[voice.baseNote]) * voice.portaTicks) >> 8) / channel.portamentoTime;
+ else
+ bend += (int16)(((int8)(voice.endNote - voice.baseNote)) * voice.portaTicks) / channel.portamentoTime;
+ }
+
+ if ((channel.flags & ChannelContext::kFlagMicrotonal) != 0)
+ bend += _microtonal[voice.baseNote];
+#else
+ if (voice.hasPortamento)
+ bend += (int16)(((int8)(voice.endNote - voice.baseNote)) * voice.portaTicks) / channel.portamentoTime;
+#endif
+
+#ifdef MAXTRAX_HAS_MODULATION
+ static const uint8 tableSine[] = {
+ 0, 5, 12, 18, 24, 30, 37, 43, 49, 55, 61, 67, 73, 79, 85, 91,
+ 97, 103, 108, 114, 120, 125, 131, 136, 141, 146, 151, 156, 161, 166, 171, 176,
+ 180, 184, 189, 193, 197, 201, 205, 208, 212, 215, 219, 222, 225, 228, 230, 233,
+ 236, 238, 240, 242, 244, 246, 247, 249, 250, 251, 252, 253, 254, 254, 255, 255,
+ 255, 255, 255, 254, 254, 253, 252, 251, 250, 249, 247, 246, 244, 242, 240, 238,
+ 236, 233, 230, 228, 225, 222, 219, 215, 212, 208, 205, 201, 197, 193, 189, 184,
+ 180, 176, 171, 166, 161, 156, 151, 146, 141, 136, 131, 125, 120, 114, 108, 103,
+ 97, 91, 85, 79, 73, 67, 61, 55, 49, 43, 37, 30, 24, 18, 12, 5
+ };
+ if (channel.modulation) {
+ if ((channel.flags & ChannelContext::kFlagModVolume) == 0) {
+ const uint8 sineByte = _playerCtx.sineValue / channel.modulationTime;
+ const uint8 sineIndex = sineByte & 0x7F;
+ const int16 modVal = ((uint32)(uint16)(tableSine[sineIndex] + (sineIndex ? 1 : 0)) * channel.modulation) >> 8;
+ bend = (sineByte < 0x80) ? bend + modVal : bend - modVal;
+ }
+ }
+#endif
+
+ // tone = voice.baseNote << 8 + microtonal
+ // bend = channelPitch + porta + modulation
+
+ const int32 tone = voice.preCalcNote + (bend << 6) / 3;
+
+ return (tone >= PERIOD_LIMIT) ? (uint16)pow2Fixed(tone) : 0;
+}
+
+int8 MaxTrax::noteOn(ChannelContext &channel, const byte note, uint16 volume, uint16 pri) {
+#ifdef MAXTRAX_HAS_MICROTONAL
+ if (channel.microtonal >= 0)
+ _microtonal[note % 127] = channel.microtonal;
+#endif
+
+ if (!volume)
+ return -1;
+
+ const Patch &patch = *channel.patch;
+ if (!patch.samplePtr || patch.sampleTotalLen == 0)
+ return -1;
+ int8 voiceNum = -1;
+ if ((channel.flags & ChannelContext::kFlagMono) == 0) {
+ voiceNum = pickvoice((channel.flags & ChannelContext::kFlagRightChannel) != 0 ? 1 : 0, pri);
+ } else {
+ VoiceContext *voice = _voiceCtx + ARRAYSIZE(_voiceCtx) - 1;
+ for (voiceNum = ARRAYSIZE(_voiceCtx) - 1; voiceNum >= 0 && voice->channel != &channel; --voiceNum, --voice)
+ ;
+ if (voiceNum < 0)
+ voiceNum = pickvoice((channel.flags & ChannelContext::kFlagRightChannel) != 0 ? 1 : 0, pri);
+ else if (voice->status >= VoiceContext::kStatusSustain && (channel.flags & ChannelContext::kFlagPortamento) != 0) {
+ // reset previous porta
+ if (voice->hasPortamento)
+ voice->baseNote = voice->endNote;
+ voice->preCalcNote = precalcNote(voice->baseNote, patch.tune, voice->octave);
+ voice->noteVolume = (_playerCtx.handleVolume) ? volume + 1 : 128;
+ voice->portaTicks = 0;
+ voice->hasPortamento = true;
+ voice->endNote = channel.lastNote = note;
+ return voiceNum;
+ }
+ }
+
+ if (voiceNum >= 0) {
+ VoiceContext &voice = _voiceCtx[voiceNum];
+ voice.hasDamper = false;
+ voice.isBlocked = 0;
+ voice.hasPortamento = false;
+ if (voice.channel)
+ killVoice(voiceNum);
+ voice.channel = &channel;
+ voice.patch = &patch;
+ voice.baseNote = note;
+
+ // always base octave on the note in the command, regardless of porta
+ const int32 plainNote = precalcNote(note, patch.tune, 0);
+ // calculate which sample to use
+ const int useOctave = (plainNote <= PREF_PERIOD) ? 0 : MIN<int32>((plainNote + 0xFFFF - PREF_PERIOD) >> 16, patch.sampleOctaves - 1);
+ voice.octave = (byte)useOctave;
+ // adjust precalculated value
+ voice.preCalcNote = plainNote - (useOctave << 16);
+
+ // next calculate the actual period which depends on wether porta is enabled
+ if (&channel < &_channelCtx[kNumChannels] && (channel.flags & ChannelContext::kFlagPortamento) != 0) {
+ if ((channel.flags & ChannelContext::kFlagMono) != 0 && channel.lastNote < 0x80 && channel.lastNote != note) {
+ voice.portaTicks = 0;
+ voice.baseNote = channel.lastNote;
+ voice.endNote = note;
+ voice.hasPortamento = true;
+ voice.preCalcNote = precalcNote(voice.baseNote, patch.tune, voice.octave);
+ }
+ channel.lastNote = note;
+ }
+
+ voice.lastPeriod = calcNote(voice);
+
+ voice.priority = (byte)pri;
+ voice.status = VoiceContext::kStatusStart;
+
+ voice.noteVolume = (_playerCtx.handleVolume) ? volume + 1 : 128;
+ voice.baseVolume = 0;
+
+ // TODO: since the original player is using the OS-functions, more than 1 sample could be queued up already
+ // get samplestart for the given octave
+ const int8 *samplePtr = patch.samplePtr + (patch.sampleTotalLen << useOctave) - patch.sampleTotalLen;
+ if (patch.sampleAttackLen) {
+ Paula::setChannelSampleStart(voiceNum, samplePtr);
+ Paula::setChannelSampleLen(voiceNum, (patch.sampleAttackLen << useOctave) / 2);
+
+ Paula::enableChannel(voiceNum);
+ // wait for dma-clear
+ }
+
+ if (patch.sampleTotalLen > patch.sampleAttackLen) {
+ Paula::setChannelSampleStart(voiceNum, samplePtr + (patch.sampleAttackLen << useOctave));
+ Paula::setChannelSampleLen(voiceNum, ((patch.sampleTotalLen - patch.sampleAttackLen) << useOctave) / 2);
+ if (!patch.sampleAttackLen)
+ Paula::enableChannel(voiceNum); // need to enable channel
+ // another pointless wait for DMA-Clear???
+
+ } else { // no sustain sample
+ // this means we must stop playback after the attacksample finished
+ // so we queue up an "empty" sample and note that we need to kill the sample after dma finished
+ Paula::setChannelSampleStart(voiceNum, 0);
+ Paula::setChannelSampleLen(voiceNum, 0);
+ Paula::setChannelDmaCount(voiceNum);
+ voice.dmaOff = 1;
+ }
+
+ Paula::setChannelPeriod(voiceNum, (voice.lastPeriod) ? voice.lastPeriod : 1000);
+ Paula::setChannelVolume(voiceNum, 0);
+ }
+ return voiceNum;
+}
+
+void MaxTrax::resetChannel(ChannelContext &chan, bool rightChannel) {
+ chan.modulation = 0;
+ chan.modulationTime = 1000;
+ chan.microtonal = -1;
+ chan.portamentoTime = 500;
+ chan.pitchBend = NO_BEND;
+ chan.pitchReal = 0;
+ chan.pitchBendRange = MAX_BEND_RANGE;
+ chan.volume = 128;
+ chan.flags &= ~(ChannelContext::kFlagPortamento | ChannelContext::kFlagMicrotonal | ChannelContext::kFlagRightChannel);
+ chan.isAltered = true;
+ if (rightChannel)
+ chan.flags |= ChannelContext::kFlagRightChannel;
+}
+
+void MaxTrax::freeScores() {
+ if (_scores) {
+ for (int i = 0; i < _numScores; ++i)
+ delete[] _scores[i].events;
+ delete[] _scores;
+ _scores = 0;
+ }
+ _numScores = 0;
+ _playerCtx.tempo = 120;
+ _playerCtx.filterOn = true;
+}
+
+void MaxTrax::freePatches() {
+ for (int i = 0; i < ARRAYSIZE(_patch); ++i) {
+ delete[] _patch[i].samplePtr;
+ delete[] _patch[i].attackPtr;
+ }
+ memset(_patch, 0, sizeof(_patch));
+}
+
+void MaxTrax::setSignalCallback(void (*callback) (int)) {
+ Common::StackLock lock(_mutex);
+ _playerCtx.syncCallBack = (callback == 0) ? nullFunc : callback;
+}
+
+int MaxTrax::playNote(byte note, byte patch, uint16 duration, uint16 volume, bool rightSide) {
+ Common::StackLock lock(_mutex);
+ assert(patch < ARRAYSIZE(_patch));
+
+ ChannelContext &channel = _channelCtx[kNumChannels];
+ channel.flags = (rightSide) ? ChannelContext::kFlagRightChannel : 0;
+ channel.isAltered = false;
+ channel.patch = &_patch[patch];
+ const int8 voiceIndex = noteOn(channel, note, (byte)volume, kPriorityNote);
+ if (voiceIndex >= 0)
+ _voiceCtx[voiceIndex].stopEventTime = duration << 8;
+ return voiceIndex;
+}
+
+bool MaxTrax::load(Common::SeekableReadStream &musicData, bool loadScores, bool loadSamples) {
+ Common::StackLock lock(_mutex);
+ stopMusic();
+ if (loadSamples)
+ freePatches();
+ if (loadScores)
+ freeScores();
+ const char *errorMsg = 0;
+ // 0x0000: 4 Bytes Header "MXTX"
+ // 0x0004: uint16 tempo
+ // 0x0006: uint16 flags. bit0 = lowpassfilter, bit1 = attackvolume, bit15 = microtonal
+ if (musicData.size() < 10 || musicData.readUint32BE() != 0x4D585458) {
+ warning("Maxtrax: File is not a Maxtrax Module");
+ return false;
+ }
+ const uint16 songTempo = musicData.readUint16BE();
+ const uint16 flags = musicData.readUint16BE();
+ if (loadScores) {
+ _playerCtx.tempoInitial = songTempo;
+ _playerCtx.filterOn = (flags & 1) != 0;
+ _playerCtx.handleVolume = (flags & 2) != 0;
+ }
+
+ if (flags & (1 << 15)) {
+ debug(5, "Maxtrax: Song has microtonal");
+#ifdef MAXTRAX_HAS_MICROTONAL
+ if (loadScores) {
+ for (int i = 0; i < ARRAYSIZE(_microtonal); ++i)
+ _microtonal[i] = musicData.readUint16BE();
+ } else
+ musicData.skip(128 * 2);
+#else
+ musicData.skip(128 * 2);
+#endif
+ }
+
+ int scoresLoaded = 0;
+ // uint16 number of Scores
+ const uint16 scoresInFile = musicData.readUint16BE();
+
+ if (musicData.err() || musicData.eos())
+ goto ioError;
+
+ if (loadScores) {
+ const uint16 tempScores = MIN(scoresInFile, _playerCtx.maxScoreNum);
+ Score *curScore = new Score[tempScores];
+ if (!curScore)
+ goto allocError;
+ _scores = curScore;
+
+ for (scoresLoaded = 0; scoresLoaded < tempScores; ++scoresLoaded, ++curScore) {
+ const uint32 numEvents = musicData.readUint32BE();
+ Event *curEvent = new Event[numEvents];
+ if (!curEvent)
+ goto allocError;
+ curScore->events = curEvent;
+ for (int j = numEvents; j > 0; --j, ++curEvent) {
+ curEvent->command = musicData.readByte();
+ curEvent->parameter = musicData.readByte();
+ curEvent->startTime = musicData.readUint16BE();
+ curEvent->stopTime = musicData.readUint16BE();
+ }
+ curScore->numEvents = numEvents;
+ }
+ _numScores = scoresLoaded;
+ }
+
+ if (loadSamples) {
+ // skip over remaining scores in file
+ for (int i = scoresInFile - scoresLoaded; i > 0; --i)
+ musicData.skip(musicData.readUint32BE() * 6);
+
+ // uint16 number of Samples
+ const uint16 wavesInFile = musicData.readUint16BE();
+ for (int i = wavesInFile; i > 0; --i) {
+ // load disksample structure
+ const uint16 number = musicData.readUint16BE();
+ assert(number < ARRAYSIZE(_patch));
+
+ Patch &curPatch = _patch[number];
+ if (curPatch.attackPtr || curPatch.samplePtr) {
+ delete curPatch.attackPtr;
+ curPatch.attackPtr = 0;
+ delete curPatch.samplePtr;
+ curPatch.samplePtr = 0;
+ }
+ curPatch.tune = musicData.readSint16BE();
+ curPatch.volume = musicData.readUint16BE();
+ curPatch.sampleOctaves = musicData.readUint16BE();
+ curPatch.sampleAttackLen = musicData.readUint32BE();
+ const uint32 sustainLen = musicData.readUint32BE();
+ curPatch.sampleTotalLen = curPatch.sampleAttackLen + sustainLen;
+ // each octave the number of samples doubles.
+ const uint32 totalSamples = curPatch.sampleTotalLen * ((1 << curPatch.sampleOctaves) - 1);
+ curPatch.attackLen = musicData.readUint16BE();
+ curPatch.releaseLen = musicData.readUint16BE();
+ const uint32 totalEnvs = curPatch.attackLen + curPatch.releaseLen;
+
+ // Allocate space for both attack and release Segment.
+ Envelope *envPtr = new Envelope[totalEnvs];
+ if (!envPtr)
+ goto allocError;
+ // Attack Segment
+ curPatch.attackPtr = envPtr;
+ // Release Segment
+ // curPatch.releasePtr = envPtr + curPatch.attackLen;
+
+ // Read Attack and Release Segments
+ for (int j = totalEnvs; j > 0; --j, ++envPtr) {
+ envPtr->duration = musicData.readUint16BE();
+ envPtr->volume = musicData.readUint16BE();
+ }
+
+ // read Samples
+ int8 *allocSamples = new int8[totalSamples];
+ if (!allocSamples)
+ goto allocError;
+ curPatch.samplePtr = allocSamples;
+ musicData.read(allocSamples, totalSamples);
+ }
+ }
+ if (!musicData.err() && !musicData.eos())
+ return true;
+ioError:
+ errorMsg = "Maxtrax: Encountered IO-Error";
+allocError:
+ if (!errorMsg)
+ errorMsg = "Maxtrax: Could not allocate Memory";
+
+ warning("%s", errorMsg);
+ if (loadSamples)
+ freePatches();
+ if (loadScores)
+ freeScores();
+ return false;
+}
+
+#if !defined(NDEBUG) && 0
+void MaxTrax::outPutEvent(const Event &ev, int num) {
+ struct {
+ byte cmd;
+ const char *name;
+ const char *param;
+ } COMMANDS[] = {
+ {0x80, "TEMPO ", "TEMPO, N/A "},
+ {0xa0, "SPECIAL ", "CHAN, SPEC # | VAL"},
+ {0xb0, "CONTROL ", "CHAN, CTRL # | VAL"},
+ {0xc0, "PROGRAM ", "CHANNEL, PROG # "},
+ {0xe0, "BEND ", "CHANNEL, BEND VALUE"},
+ {0xf0, "SYSEX ", "TYPE, SIZE "},
+ {0xf8, "REALTIME", "REALTIME, N/A "},
+ {0xff, "END ", "N/A, N/A "},
+ {0xff, "NOTE ", "VOL | CHAN, STOP"},
+ };
+
+ int i = 0;
+ for (; i < ARRAYSIZE(COMMANDS) - 1 && ev.command != COMMANDS[i].cmd; ++i)
+ ;
+
+ if (num == -1)
+ debug("Event : %02X %s %s %02X %04X %04X", ev.command, COMMANDS[i].name, COMMANDS[i].param, ev.parameter, ev.startTime, ev.stopTime);
+ else
+ debug("Event %3d: %02X %s %s %02X %04X %04X", num, ev.command, COMMANDS[i].name, COMMANDS[i].param, ev.parameter, ev.startTime, ev.stopTime);
+}
+
+void MaxTrax::outPutScore(const Score &sc, int num) {
+ if (num == -1)
+ debug("score : %i Events", sc.numEvents);
+ else
+ debug("score %2d: %i Events", num, sc.numEvents);
+ for (uint i = 0; i < sc.numEvents; ++i)
+ outPutEvent(sc.events[i], i);
+ debug("");
+}
+#else
+void MaxTrax::outPutEvent(const Event &ev, int num) {}
+void MaxTrax::outPutScore(const Score &sc, int num) {}
+#endif // #ifndef NDEBUG
+
+} // End of namespace Audio
+
+#endif // #if defined(SOUND_MODS_MAXTRAX_H)
diff --git a/sound/mods/maxtrax.h b/sound/mods/maxtrax.h
new file mode 100644
index 0000000000..3cd5ebc94b
--- /dev/null
+++ b/sound/mods/maxtrax.h
@@ -0,0 +1,225 @@
+/* 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$
+ *
+ */
+
+// see if all engines using this class are DISABLED
+#if !defined(ENABLE_KYRA)
+
+// normal Header Guard
+#elif !defined SOUND_MODS_MAXTRAX_H
+#define SOUND_MODS_MAXTRAX_H
+
+// #define MAXTRAX_HAS_MODULATION
+// #define MAXTRAX_HAS_MICROTONAL
+
+#include "sound/mods/paula.h"
+
+namespace Audio {
+
+class MaxTrax : public Paula {
+public:
+ MaxTrax(int rate, bool stereo, uint16 vBlankFreq = 50, uint16 maxScores = 128);
+ virtual ~MaxTrax();
+
+ bool load(Common::SeekableReadStream &musicData, bool loadScores = true, bool loadSamples = true);
+ bool playSong(int songIndex, bool loop = false);
+ void advanceSong(int advance = 1);
+ int playNote(byte note, byte patch, uint16 duration, uint16 volume, bool rightSide);
+ void setVolume(const byte volume) { Common::StackLock lock(_mutex); _playerCtx.volume = volume; }
+ void setTempo(const uint16 tempo);
+ void stopMusic();
+ /**
+ * Set a callback function for sync-events.
+ * @param callback Callback function, will be called synchronously, so DONT modify the player
+ * directly in response
+ */
+ void setSignalCallback(void (*callback) (int));
+
+protected:
+ void interrupt();
+
+private:
+ enum { kNumPatches = 64, kNumVoices = 4, kNumChannels = 16, kNumExtraChannels = 1 };
+ enum { kPriorityScore, kPriorityNote, kPrioritySound };
+
+#ifdef MAXTRAX_HAS_MICROTONAL
+ int16 _microtonal[128];
+#endif
+
+ struct Event {
+ uint16 startTime;
+ uint16 stopTime;
+ byte command;
+ byte parameter;
+ };
+
+ const struct Score {
+ const Event *events;
+ uint32 numEvents;
+ } *_scores;
+
+ int _numScores;
+
+ struct {
+ uint32 sineValue;
+ uint16 vBlankFreq;
+ int32 ticks;
+ int32 tickUnit;
+ uint16 frameUnit;
+
+ uint16 maxScoreNum;
+ uint16 tempo;
+ uint16 tempoInitial;
+ uint16 tempoStart;
+ int16 tempoDelta;
+ int32 tempoTime;
+ int32 tempoTicks;
+
+ byte volume;
+
+ bool filterOn;
+ bool handleVolume;
+ bool musicLoop;
+
+ int scoreIndex;
+ const Event *nextEvent;
+ int32 nextEventTime;
+
+ void (*syncCallBack) (int);
+ const Event *repeatPoint[4];
+ byte repeatCount[4];
+ } _playerCtx;
+
+ struct Envelope {
+ uint16 duration;
+ uint16 volume;
+ };
+
+ struct Patch {
+ const Envelope *attackPtr;
+ //Envelope *releasePtr;
+ uint16 attackLen;
+ uint16 releaseLen;
+
+ int16 tune;
+ uint16 volume;
+
+ // this was the SampleData struct in the assembler source
+ const int8 *samplePtr;
+ uint32 sampleTotalLen;
+ uint32 sampleAttackLen;
+ uint16 sampleOctaves;
+ } _patch[kNumPatches];
+
+ struct ChannelContext {
+ const Patch *patch;
+ uint16 regParamNumber;
+
+ uint16 modulation;
+ uint16 modulationTime;
+
+ int16 microtonal;
+
+ uint16 portamentoTime;
+
+ int16 pitchBend;
+ int16 pitchReal;
+ int8 pitchBendRange;
+
+ uint8 volume;
+// uint8 voicesActive;
+
+ enum {
+ kFlagRightChannel = 1 << 0,
+ kFlagPortamento = 1 << 1,
+ kFlagDamper = 1 << 2,
+ kFlagMono = 1 << 3,
+ kFlagMicrotonal = 1 << 4,
+ kFlagModVolume = 1 << 5
+ };
+ byte flags;
+ bool isAltered;
+
+ uint8 lastNote;
+// uint8 program;
+
+ } _channelCtx[kNumChannels + kNumExtraChannels];
+
+ struct VoiceContext {
+ ChannelContext *channel;
+ const Patch *patch;
+ const Envelope *envelope;
+// uint32 uinqueId;
+ int32 preCalcNote;
+ uint32 ticksLeft;
+ int32 portaTicks;
+ int32 incrVolume;
+// int32 periodOffset;
+ uint16 envelopeLeft;
+ uint16 noteVolume;
+ uint16 baseVolume;
+ uint16 lastPeriod;
+ byte baseNote;
+ byte endNote;
+ byte octave;
+// byte number;
+// byte link;
+ enum {
+ kStatusFree,
+ kStatusHalt,
+ kStatusDecay,
+ kStatusRelease,
+ kStatusSustain,
+ kStatusAttack,
+ kStatusStart
+ };
+ uint8 isBlocked;
+ uint8 priority;
+ byte status;
+ byte lastVolume;
+ byte tieBreak;
+ bool hasDamper;
+ bool hasPortamento;
+ byte dmaOff;
+
+ int32 stopEventTime;
+ } _voiceCtx[kNumVoices];
+
+ void controlCh(ChannelContext &channel, byte command, byte data);
+ void freePatches();
+ void freeScores();
+ void resetChannel(ChannelContext &chan, bool rightChannel);
+ void resetPlayer();
+
+ int8 pickvoice(uint pick, int16 pri);
+ uint16 calcNote(const VoiceContext &voice);
+ int8 noteOn(ChannelContext &channel, byte note, uint16 volume, uint16 pri);
+ void killVoice(byte num);
+
+ static void outPutEvent(const Event &ev, int num = -1);
+ static void outPutScore(const Score &sc, int num = -1);
+};
+} // End of namespace Audio
+
+#endif // !defined SOUND_MODS_MAXTRAX_H
diff --git a/sound/mods/paula.cpp b/sound/mods/paula.cpp
index 545390ff93..1f557e0ece 100644
--- a/sound/mods/paula.cpp
+++ b/sound/mods/paula.cpp
@@ -27,19 +27,20 @@
namespace Audio {
-Paula::Paula(bool stereo, int rate, int interruptFreq) :
- _stereo(stereo), _rate(rate), _intFreq(interruptFreq) {
+Paula::Paula(bool stereo, int rate, uint interruptFreq) :
+ _stereo(stereo), _rate(rate), _periodScale((double)kPalPaulaClock / rate), _intFreq(interruptFreq) {
clearVoices();
- _voice[0].panning = 63;
- _voice[1].panning = 191;
- _voice[2].panning = 191;
- _voice[3].panning = 63;
+ _voice[0].panning = 191;
+ _voice[1].panning = 63;
+ _voice[2].panning = 63;
+ _voice[3].panning = 191;
- if (_intFreq <= 0)
+ if (_intFreq == 0)
_intFreq = _rate;
- _curInt = _intFreq;
+ _curInt = 0;
+ _timerBase = 1;
_playing = false;
_end = true;
}
@@ -57,6 +58,7 @@ void Paula::clearVoice(byte voice) {
_voice[voice].period = 0;
_voice[voice].volume = 0;
_voice[voice].offset = 0;
+ _voice[voice].dmaCount = 0;
}
int Paula::readBuffer(int16 *buffer, const int numSamples) {
@@ -95,18 +97,17 @@ int Paula::readBufferIntern(int16 *buffer, const int numSamples) {
// Handle 'interrupts'. This gives subclasses the chance to adjust the channel data
// (e.g. insert new samples, do pitch bending, whatever).
- if (_curInt == _intFreq) {
+ if (_curInt == 0) {
+ _curInt = _intFreq;
interrupt();
- _curInt = 0;
}
// Compute how many samples to generate: at most the requested number of samples,
// of course, but we may stop earlier when an 'interrupt' is expected.
- const int nSamples = MIN(samples, _intFreq - _curInt);
+ const uint nSamples = MIN((uint)samples, _curInt);
// Loop over the four channels of the emulated Paula chip
for (int voice = 0; voice < NUM_VOICES; voice++) {
-
// No data, or paused -> skip channel
if (!_voice[voice].data || (_voice[voice].period <= 0))
continue;
@@ -115,8 +116,7 @@ int Paula::readBufferIntern(int16 *buffer, const int numSamples) {
// the requested output sampling rate (typicall 44.1 kHz or 22.05 kHz)
// as well as the "period" of the channel we are processing right now,
// to compute the correct output 'rate'.
- const double frequency = (7093789.2 / 2.0) / _voice[voice].period;
- frac_t rate = doubleToFrac(frequency / _rate);
+ frac_t rate = doubleToFrac(_periodScale / _voice[voice].period);
// Cap the volume
_voice[voice].volume = MIN((byte) 0x40, _voice[voice].volume);
@@ -126,50 +126,67 @@ int Paula::readBufferIntern(int16 *buffer, const int numSamples) {
frac_t offset = _voice[voice].offset;
frac_t sLen = intToFrac(_voice[voice].length);
const int8 *data = _voice[voice].data;
+ int dmaCount = _voice[voice].dmaCount;
int16 *p = buffer;
int end = 0;
int neededSamples = nSamples;
+ assert(offset < sLen);
// Compute the number of samples to generate; that is, either generate
// just as many as were requested, or until the buffer is used up.
// Note that dividing two frac_t yields an integer (as the denominators
// cancel out each other).
// Note that 'end' could be 0 here. No harm in that :-).
- end = MIN(neededSamples, (int)((sLen - offset + rate - 1) / rate));
+ const int leftSamples = (int)((sLen - offset + rate - 1) / rate);
+ end = MIN(neededSamples, leftSamples);
mixBuffer<stereo>(p, data, offset, rate, end, _voice[voice].volume, _voice[voice].panning);
neededSamples -= end;
- // If we have not yet generated enough samples, and looping is active: loop!
- if (neededSamples > 0 && _voice[voice].lengthRepeat > 2) {
-
- // At this point we know that we have used up all samples in the buffer, so reset it.
- _voice[voice].data = data = _voice[voice].dataRepeat;
+ if (leftSamples > 0 && end == leftSamples) {
+ dmaCount++;
+ data = _voice[voice].data = _voice[voice].dataRepeat;
_voice[voice].length = _voice[voice].lengthRepeat;
+ // TODO: offset -= sLen; but make sure there is no way offset >= 2*sLen
+ offset &= FRAC_LO_MASK;
+ }
+
+ // If we have not yet generated enough samples, and looping is active: loop!
+ if (neededSamples > 0 && _voice[voice].length > 2) {
sLen = intToFrac(_voice[voice].length);
// If the "rate" exceeds the sample rate, we would have to perform constant
// wrap arounds. So, apply the first step of the euclidean algorithm to
// achieve the same more efficiently: Take rate modulo sLen
+ // TODO: This messes up dmaCount and shouldnt happen?
if (sLen < rate)
- rate %= sLen;
+ warning("Paula: length %d is lesser than rate", _voice[voice].length);
+// rate %= sLen;
// Repeat as long as necessary.
while (neededSamples > 0) {
- offset = 0;
-
+ // TODO: offset -= sLen; but make sure there is no way offset >= 2*sLen
+ offset &= FRAC_LO_MASK;
+ dmaCount++;
// Compute the number of samples to generate (see above) and mix 'em.
end = MIN(neededSamples, (int)((sLen - offset + rate - 1) / rate));
mixBuffer<stereo>(p, data, offset, rate, end, _voice[voice].volume, _voice[voice].panning);
neededSamples -= end;
}
+
+ if (offset < sLen)
+ dmaCount--;
+ else
+ offset &= FRAC_LO_MASK;
+
}
// Write back the cached data
_voice[voice].offset = offset;
+ _voice[voice].dmaCount = dmaCount;
}
buffer += _stereo ? nSamples * 2 : nSamples;
- _curInt += nSamples;
+ _curInt -= nSamples;
samples -= nSamples;
}
return numSamples;
diff --git a/sound/mods/paula.h b/sound/mods/paula.h
index e3c6002451..647dc5fe56 100644
--- a/sound/mods/paula.h
+++ b/sound/mods/paula.h
@@ -40,12 +40,29 @@ namespace Audio {
class Paula : public AudioStream {
public:
static const int NUM_VOICES = 4;
+ enum {
+ kPalSystemClock = 7093790,
+ kNtscSystemClock = 7159090,
+ kPalCiaClock = kPalSystemClock / 10,
+ kNtscCiaClock = kNtscSystemClock / 10,
+ kPalPaulaClock = kPalSystemClock / 2,
+ kNtscPauleClock = kNtscSystemClock / 2
+ };
- Paula(bool stereo = false, int rate = 44100, int interruptFreq = 0);
+ Paula(bool stereo = false, int rate = 44100, uint interruptFreq = 0);
~Paula();
bool playing() const { return _playing; }
- void setInterruptFreq(int freq) { _curInt = _intFreq = freq; }
+ void setTimerBaseValue( uint32 ticksPerSecond ) { _timerBase = ticksPerSecond; }
+ uint32 getTimerBaseValue() { return _timerBase; }
+ void setSingleInterrupt(uint sampleDelay) { assert(sampleDelay < _intFreq); _curInt = sampleDelay; }
+ void setSingleInterruptUnscaled(uint timerDelay) {
+ setSingleInterrupt((uint)(((double)timerDelay * getRate()) / _timerBase));
+ }
+ void setInterruptFreq(uint sampleDelay) { _intFreq = sampleDelay; _curInt = 0; }
+ void setInterruptFreqUnscaled(uint timerDelay) {
+ setInterruptFreq((uint)(((double)timerDelay * getRate()) / _timerBase));
+ }
void clearVoice(byte voice);
void clearVoices() { for (int i = 0; i < NUM_VOICES; ++i) clearVoice(i); }
void startPlay(void) { _playing = true; }
@@ -68,6 +85,7 @@ protected:
byte volume;
frac_t offset;
byte panning; // For stereo mixing: 0 = far left, 255 = far right
+ int dmaCount;
};
bool _end;
@@ -90,6 +108,21 @@ protected:
_voice[channel].panning = panning;
}
+ void disableChannel(byte channel) {
+ assert(channel < NUM_VOICES);
+ _voice[channel].data = 0;
+ }
+
+ void enableChannel(byte channel) {
+ assert(channel < NUM_VOICES);
+ Channel &ch = _voice[channel];
+ ch.data = ch.dataRepeat;
+ ch.length = ch.lengthRepeat;
+ // actually first 2 bytes are dropped?
+ ch.offset = intToFrac(0);
+ // ch.period = ch.periodRepeat;
+ }
+
void setChannelPeriod(byte channel, int16 period) {
assert(channel < NUM_VOICES);
_voice[channel].period = period;
@@ -100,6 +133,17 @@ protected:
_voice[channel].volume = volume;
}
+ void setChannelSampleStart(byte channel, const int8 *data) {
+ assert(channel < NUM_VOICES);
+ _voice[channel].dataRepeat = data;
+ }
+
+ void setChannelSampleLen(byte channel, uint32 length) {
+ assert(channel < NUM_VOICES);
+ assert(length < 32768/2);
+ _voice[channel].lengthRepeat = 2 * length;
+ }
+
void setChannelData(uint8 channel, const int8 *data, const int8 *dataRepeat, uint32 length, uint32 lengthRepeat, int32 offset = 0) {
assert(channel < NUM_VOICES);
@@ -110,11 +154,14 @@ protected:
assert(lengthRepeat < 32768);
Channel &ch = _voice[channel];
- ch.data = data;
+
+ ch.dataRepeat = data;
+ ch.lengthRepeat = length;
+ enableChannel(channel);
+ ch.offset = intToFrac(offset);
+
ch.dataRepeat = dataRepeat;
- ch.length = length;
ch.lengthRepeat = lengthRepeat;
- ch.offset = intToFrac(offset);
}
void setChannelOffset(byte channel, frac_t offset) {
@@ -128,13 +175,29 @@ protected:
return _voice[channel].offset;
}
+ int getChannelDmaCount(byte channel) {
+ assert(channel < NUM_VOICES);
+ return _voice[channel].dmaCount;
+ }
+
+ void setChannelDmaCount(byte channel, int dmaVal = 0) {
+ assert(channel < NUM_VOICES);
+ _voice[channel].dmaCount = dmaVal;
+ }
+
+ void setAudioFilter(bool enable) {
+ // TODO: implement
+ }
+
private:
Channel _voice[NUM_VOICES];
const bool _stereo;
const int _rate;
- int _intFreq;
- int _curInt;
+ const double _periodScale;
+ uint _intFreq;
+ uint _curInt;
+ uint32 _timerBase;
bool _playing;
template<bool stereo>
diff --git a/sound/mods/soundfx.cpp b/sound/mods/soundfx.cpp
index 101d8a077d..3af8ca19c6 100644
--- a/sound/mods/soundfx.cpp
+++ b/sound/mods/soundfx.cpp
@@ -46,8 +46,7 @@ public:
enum {
NUM_CHANNELS = 4,
- NUM_INSTRUMENTS = 15,
- CIA_FREQ = 715909
+ NUM_INSTRUMENTS = 15
};
SoundFx(int rate, bool stereo);
@@ -75,12 +74,12 @@ protected:
uint16 _curPos;
uint8 _ordersTable[128];
uint8 *_patternData;
- int _eventsFreq;
uint16 _effects[NUM_CHANNELS];
};
SoundFx::SoundFx(int rate, bool stereo)
: Paula(stereo, rate) {
+ setTimerBaseValue(kPalCiaClock);
_ticks = 0;
_delay = 0;
memset(_instruments, 0, sizeof(_instruments));
@@ -89,7 +88,6 @@ SoundFx::SoundFx(int rate, bool stereo)
_curPos = 0;
memset(_ordersTable, 0, sizeof(_ordersTable));
_patternData = 0;
- _eventsFreq = 0;
memset(_effects, 0, sizeof(_effects));
}
@@ -167,8 +165,7 @@ void SoundFx::play() {
_curPos = 0;
_curOrder = 0;
_ticks = 0;
- _eventsFreq = CIA_FREQ / _delay;
- setInterruptFreq(getRate() / _eventsFreq);
+ setInterruptFreqUnscaled(_delay);
startPaula();
}
@@ -252,7 +249,7 @@ void SoundFx::handleTick() {
}
void SoundFx::disablePaulaChannel(uint8 channel) {
- setChannelPeriod(channel, 0);
+ disableChannel(channel);
}
void SoundFx::setupPaulaChannel(uint8 channel, const int8 *data, uint16 len, uint16 repeatPos, uint16 repeatLen) {
diff --git a/sound/mods/tfmx.cpp b/sound/mods/tfmx.cpp
new file mode 100644
index 0000000000..2ef7d79b7a
--- /dev/null
+++ b/sound/mods/tfmx.cpp
@@ -0,0 +1,1189 @@
+/* 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$
+ *
+ */
+
+#include "common/scummsys.h"
+#include "common/endian.h"
+#include "common/stream.h"
+#include "common/util.h"
+#include "common/debug.h"
+
+#include "sound/mods/tfmx.h"
+
+// test for engines using this class.
+#if defined(SOUND_MODS_TFMX_H)
+
+// couple debug-functions
+namespace {
+ void displayPatternstep(const void *const vptr);
+ void displayMacroStep(const void *const vptr);
+
+ const uint16 noteIntervalls[64] = {
+ 1710, 1614, 1524, 1438, 1357, 1281, 1209, 1141, 1077, 1017, 960, 908,
+ 856, 810, 764, 720, 680, 642, 606, 571, 539, 509, 480, 454,
+ 428, 404, 381, 360, 340, 320, 303, 286, 270, 254, 240, 227,
+ 214, 202, 191, 180, 170, 160, 151, 143, 135, 127, 120, 113,
+ 214, 202, 191, 180, 170, 160, 151, 143, 135, 127, 120, 113,
+ 214, 202, 191, 180 };
+}
+
+namespace Audio {
+
+Tfmx::Tfmx(int rate, bool stereo)
+ : Paula(stereo, rate),
+ _resource(),
+ _resourceSample(),
+ _playerCtx(),
+ _deleteResource(false) {
+
+ _playerCtx.stopWithLastPattern = false;
+
+ for (int i = 0; i < kNumVoices; ++i)
+ _channelCtx[i].paulaChannel = (byte)i;
+
+ _playerCtx.volume = 0x40;
+ _playerCtx.patternSkip = 6;
+ stopSongImpl();
+
+ setTimerBaseValue(kPalCiaClock);
+ setInterruptFreqUnscaled(kPalDefaultCiaVal);
+}
+
+Tfmx::~Tfmx() {
+ freeResourceDataImpl();
+}
+
+void Tfmx::interrupt() {
+ assert(!_end);
+ ++_playerCtx.tickCount;
+
+ for (int i = 0; i < kNumVoices; ++i) {
+ if (_channelCtx[i].dmaIntCount) {
+ // wait for DMA Interupts to happen
+ int doneDma = getChannelDmaCount(i);
+ if (doneDma >= _channelCtx[i].dmaIntCount) {
+ _channelCtx[i].dmaIntCount = 0;
+ _channelCtx[i].macroRun = true;
+ }
+ }
+ }
+
+ for (int i = 0; i < kNumVoices; ++i) {
+ ChannelContext &channel = _channelCtx[i];
+
+ if (channel.sfxLockTime >= 0)
+ --channel.sfxLockTime;
+ else {
+ channel.sfxLocked = false;
+ channel.customMacroPrio = 0;
+ }
+
+ // externally queued macros
+ if (channel.customMacro) {
+ const byte *const noteCmd = (const byte *)&channel.customMacro;
+ channel.sfxLocked = false;
+ noteCommand(noteCmd[0], noteCmd[1], (noteCmd[2] & 0xF0) | (uint8)i, noteCmd[3]);
+ channel.customMacro = 0;
+ channel.sfxLocked = (channel.customMacroPrio != 0);
+ }
+
+ // apply timebased effects on Parameters
+ if (channel.macroSfxRun > 0)
+ effects(channel);
+
+ // see if we have to run the macro-program
+ if (channel.macroRun) {
+ if (!channel.macroWait)
+ macroRun(channel);
+ else
+ --channel.macroWait;
+ }
+
+ Paula::setChannelPeriod(i, channel.period);
+ if (channel.macroSfxRun >= 0)
+ channel.macroSfxRun = 1;
+
+ // TODO: handling pending DMAOff?
+ }
+
+ // Patterns are only processed each _playerCtx.timerCount + 1 tick
+ if (_playerCtx.song >= 0 && !_playerCtx.patternCount--) {
+ _playerCtx.patternCount = _playerCtx.patternSkip;
+ advancePatterns();
+ }
+}
+
+void Tfmx::effects(ChannelContext &channel) {
+ // addBegin
+ if (channel.addBeginLength) {
+ channel.sampleStart += channel.addBeginDelta;
+ Paula::setChannelSampleStart(channel.paulaChannel, getSamplePtr(channel.sampleStart));
+ if (!(--channel.addBeginCount)) {
+ channel.addBeginCount = channel.addBeginLength;
+ channel.addBeginDelta = -channel.addBeginDelta;
+ }
+ }
+
+ // vibrato
+ if (channel.vibLength) {
+ channel.vibValue += channel.vibDelta;
+ if (--channel.vibCount == 0) {
+ channel.vibCount = channel.vibLength;
+ channel.vibDelta = -channel.vibDelta;
+ }
+ if (!channel.portaDelta) {
+ // 16x16 bit multiplication, casts needed for the right results
+ channel.period = (uint16)(((uint32)channel.refPeriod * (uint16)((1 << 11) + channel.vibValue)) >> 11);
+ }
+ }
+
+ // portamento
+ if (channel.portaDelta && !(--channel.portaCount)) {
+ channel.portaCount = channel.portaSkip;
+
+ bool resetPorta = true;
+ const uint16 period = channel.refPeriod;
+ uint16 portaVal = channel.portaValue;
+
+ if (period > portaVal) {
+ portaVal = ((uint32)portaVal * (uint16)((1 << 8) + channel.portaDelta)) >> 8;
+ resetPorta = (period <= portaVal);
+
+ } else if (period < portaVal) {
+ portaVal = ((uint32)portaVal * (uint16)((1 << 8) - channel.portaDelta)) >> 8;
+ resetPorta = (period >= portaVal);
+ }
+
+ if (resetPorta) {
+ channel.portaDelta = 0;
+ channel.portaValue = period & 0x7FF;
+ } else
+ channel.period = channel.portaValue = portaVal & 0x7FF;
+ }
+
+ // envelope
+ if (channel.envSkip && !channel.envCount--) {
+ channel.envCount = channel.envSkip;
+
+ const int8 endVol = channel.envEndVolume;
+ int8 volume = channel.volume;
+ bool resetEnv = true;
+
+ if (endVol > volume) {
+ volume += channel.envDelta;
+ resetEnv = endVol <= volume;
+ } else {
+ volume -= channel.envDelta;
+ resetEnv = volume <= 0 || endVol >= volume;
+ }
+
+ if (resetEnv) {
+ channel.envSkip = 0;
+ volume = endVol;
+ }
+ channel.volume = volume;
+ }
+
+ // Fade
+ if (_playerCtx.fadeDelta && !(--_playerCtx.fadeCount)) {
+ _playerCtx.fadeCount = _playerCtx.fadeSkip;
+
+ _playerCtx.volume += _playerCtx.fadeDelta;
+ if (_playerCtx.volume == _playerCtx.fadeEndVolume)
+ _playerCtx.fadeDelta = 0;
+ }
+
+ // Volume
+ const uint8 finVol = _playerCtx.volume * channel.volume >> 6;
+ Paula::setChannelVolume(channel.paulaChannel, finVol);
+}
+
+void Tfmx::macroRun(ChannelContext &channel) {
+ bool deferWait = channel.deferWait;
+ for (;;) {
+ const byte *const macroPtr = (const byte *)(getMacroPtr(channel.macroOffset) + channel.macroStep);
+ ++channel.macroStep;
+
+ switch (macroPtr[0]) {
+ case 0x00: // Reset + DMA Off. Parameters: deferWait, addset, vol
+ clearEffects(channel);
+ // FT
+ case 0x13: // DMA Off. Parameters: deferWait, addset, vol
+ // TODO: implement PArameters
+ Paula::disableChannel(channel.paulaChannel);
+ channel.deferWait = deferWait = (macroPtr[1] != 0);
+ if (deferWait) {
+ // if set, then we expect a DMA On in the same tick.
+ channel.period = 4;
+ //Paula::setChannelPeriod(channel.paulaChannel, channel.period);
+ Paula::setChannelSampleLen(channel.paulaChannel, 1);
+ // in this state we then need to allow some commands that normally
+ // would halt the macroprogamm to continue instead.
+ // those commands are: Wait, WaitDMA, AddPrevNote, AddNote, SetNote, <unknown Cmd>
+ // DMA On is affected aswell
+ // TODO remember time disabled, remember pending dmaoff?.
+ }
+
+ if (macroPtr[2] || macroPtr[3]) {
+ channel.volume = (macroPtr[2] ? 0 : channel.relVol * 3) + macroPtr[3];
+ Paula::setChannelVolume(channel.paulaChannel, channel.volume);
+ }
+ continue;
+
+ case 0x01: // DMA On
+ // TODO: Parameter macroPtr[1] - en-/disable effects
+ channel.dmaIntCount = 0;
+ if (deferWait) {
+ // TODO
+ // there is actually a small delay in the player, but I think that
+ // only allows to clear DMA-State on real Hardware
+ }
+ Paula::setChannelPeriod(channel.paulaChannel, channel.period);
+ Paula::enableChannel(channel.paulaChannel);
+ channel.deferWait = deferWait = false;
+ continue;
+
+ case 0x02: // Set Beginn. Parameters: SampleOffset(L)
+ channel.addBeginLength = 0;
+ channel.sampleStart = READ_BE_UINT32(macroPtr) & 0xFFFFFF;
+ Paula::setChannelSampleStart(channel.paulaChannel, getSamplePtr(channel.sampleStart));
+ continue;
+
+ case 0x03: // SetLength. Parameters: SampleLength(W)
+ channel.sampleLen = READ_BE_UINT16(&macroPtr[2]);
+ Paula::setChannelSampleLen(channel.paulaChannel, channel.sampleLen);
+ continue;
+
+ case 0x04: // Wait. Parameters: Ticks to wait(W).
+ // TODO: some unkown Parameter? (macroPtr[1] & 1)
+ channel.macroWait = READ_BE_UINT16(&macroPtr[2]);
+ break;
+
+ case 0x10: // Loop Key Up. Parameters: Loopcount, MacroStep(W)
+ if (channel.keyUp)
+ continue;
+ // FT
+ case 0x05: // Loop. Parameters: Loopcount, MacroStep(W)
+ if (channel.macroLoopCount != 0) {
+ if (channel.macroLoopCount == 0xFF)
+ channel.macroLoopCount = macroPtr[1];
+ channel.macroStep = READ_BE_UINT16(&macroPtr[2]);
+ }
+ --channel.macroLoopCount;
+ continue;
+
+ case 0x06: // Jump. Parameters: MacroIndex, MacroStep(W)
+ // channel.macroIndex = macroPtr[1] & (kMaxMacroOffsets - 1);
+ channel.macroOffset = _resource->macroOffset[macroPtr[1] & (kMaxMacroOffsets - 1)];
+ channel.macroStep = READ_BE_UINT16(&macroPtr[2]);
+ channel.macroLoopCount = 0xFF;
+ continue;
+
+ case 0x07: // Stop Macro
+ channel.macroRun = false;
+ --channel.macroStep;
+ return;
+
+ case 0x08: // AddNote. Parameters: Note, Finetune(W)
+ setNoteMacro(channel, channel.note + macroPtr[1], READ_BE_UINT16(&macroPtr[2]));
+ break;
+
+ case 0x09: // SetNote. Parameters: Note, Finetune(W)
+ setNoteMacro(channel, macroPtr[1], READ_BE_UINT16(&macroPtr[2]));
+ break;
+
+ case 0x0A: // Clear Effects
+ clearEffects(channel);
+ continue;
+
+ case 0x0B: // Portamento. Parameters: count, speed
+ channel.portaSkip = macroPtr[1];
+ channel.portaCount = 1;
+ // if porta is already running, then keep using old value
+ if (!channel.portaDelta)
+ channel.portaValue = channel.refPeriod;
+ channel.portaDelta = READ_BE_UINT16(&macroPtr[2]);
+ continue;
+
+ case 0x0C: // Vibrato. Parameters: Speed, intensity
+ channel.vibLength = macroPtr[1];
+ channel.vibCount = macroPtr[1] / 2;
+ channel.vibDelta = macroPtr[3];
+ // TODO: Perhaps a bug, vibValue could be left uninitialised
+ if (!channel.portaDelta) {
+ channel.period = channel.refPeriod;
+ channel.vibValue = 0;
+ }
+ continue;
+
+ case 0x0D: // Add Volume. Parameters: note, addNoteFlag, volume
+ if (macroPtr[2] == 0xFE)
+ setNoteMacro(channel, channel.note + macroPtr[1], 0);
+ channel.volume = channel.relVol * 3 + macroPtr[3];
+ continue;
+
+ case 0x0E: // Set Volume. Parameters: note, addNoteFlag, volume
+ if (macroPtr[2] == 0xFE)
+ setNoteMacro(channel, channel.note + macroPtr[1], 0);
+ channel.volume = macroPtr[3];
+ continue;
+
+ case 0x0F: // Envelope. Parameters: speed, count, endvol
+ channel.envDelta = macroPtr[1];
+ channel.envCount = channel.envSkip = macroPtr[2];
+ channel.envEndVolume = macroPtr[3];
+ continue;
+
+ case 0x11: // Add Beginn. Parameters: times, Offset(W)
+ channel.addBeginLength = channel.addBeginCount = macroPtr[1];
+ channel.addBeginDelta = (int16)READ_BE_UINT16(&macroPtr[2]);
+ channel.sampleStart += channel.addBeginDelta;
+ Paula::setChannelSampleStart(channel.paulaChannel, getSamplePtr(channel.sampleStart));
+ continue;
+
+ case 0x12: // Add Length. Parameters: added Length(W)
+ channel.sampleLen += (int16)READ_BE_UINT16(&macroPtr[2]);
+ Paula::setChannelSampleLen(channel.paulaChannel, channel.sampleLen);
+ continue;
+
+ case 0x14: // Wait key up. Parameters: wait cycles
+ if (channel.keyUp || channel.macroLoopCount == 0) {
+ channel.macroLoopCount = 0xFF;
+ continue;
+ } else if (channel.macroLoopCount == 0xFF)
+ channel.macroLoopCount = macroPtr[3];
+ --channel.macroLoopCount;
+ --channel.macroStep;
+ return;
+
+ case 0x15: // Subroutine. Parameters: MacroIndex, Macrostep(W)
+ channel.macroReturnOffset = channel.macroOffset;
+ channel.macroReturnStep = channel.macroStep;
+
+ channel.macroOffset = _resource->macroOffset[macroPtr[1] & (kMaxMacroOffsets - 1)];
+ channel.macroStep = READ_BE_UINT16(&macroPtr[2]);
+ // TODO: MI does some weird stuff there. Figure out which varioables need to be set
+ continue;
+
+ case 0x16: // Return from Sub.
+ channel.macroOffset = channel.macroReturnOffset;
+ channel.macroStep = channel.macroReturnStep;
+ continue;
+
+ case 0x17: // Set Period. Parameters: Period(W)
+ channel.refPeriod = READ_BE_UINT16(&macroPtr[2]);
+ if (!channel.portaDelta) {
+ channel.period = channel.refPeriod;
+ //Paula::setChannelPeriod(channel.paulaChannel, channel.period);
+ }
+ continue;
+
+ case 0x18: { // Sampleloop. Parameters: Offset from Samplestart(W)
+ // TODO: MI loads 24 bit, but thats useless?
+ const uint16 temp = /* ((int8)macroPtr[1] << 16) | */ READ_BE_UINT16(&macroPtr[2]);
+ if (macroPtr[1] || (temp & 1))
+ warning("Tfmx: Problematic value for sampleloop: %06X", (macroPtr[1] << 16) | temp);
+ channel.sampleStart += temp & 0xFFFE;
+ channel.sampleLen -= (temp / 2) /* & 0x7FFF */;
+ Paula::setChannelSampleStart(channel.paulaChannel, getSamplePtr(channel.sampleStart));
+ Paula::setChannelSampleLen(channel.paulaChannel, channel.sampleLen);
+ continue;
+ }
+ case 0x19: // Set One-Shot Sample
+ channel.addBeginLength = 0;
+ channel.sampleStart = 0;
+ channel.sampleLen = 1;
+ Paula::setChannelSampleStart(channel.paulaChannel, getSamplePtr(0));
+ Paula::setChannelSampleLen(channel.paulaChannel, 1);
+ continue;
+
+ case 0x1A: // Wait on DMA. Parameters: Cycles-1(W) to wait
+ channel.dmaIntCount = READ_BE_UINT16(&macroPtr[2]) + 1;
+ channel.macroRun = false;
+ Paula::setChannelDmaCount(channel.paulaChannel);
+ break;
+
+/* case 0x1B: // Random play. Parameters: macro/speed/mode
+ warnMacroUnimplemented(macroPtr, 0);
+ continue;*/
+
+ case 0x1C: // Branch on Note. Parameters: note/macrostep(W)
+ if (channel.note > macroPtr[1])
+ channel.macroStep = READ_BE_UINT16(&macroPtr[2]);
+ continue;
+
+ case 0x1D: // Branch on Volume. Parameters: volume/macrostep(W)
+ if (channel.volume > macroPtr[1])
+ channel.macroStep = READ_BE_UINT16(&macroPtr[2]);
+ continue;
+
+/* case 0x1E: // Addvol+note. Parameters: note/CONST./volume
+ warnMacroUnimplemented(macroPtr, 0);
+ continue;*/
+
+ case 0x1F: // AddPrevNote. Parameters: Note, Finetune(W)
+ setNoteMacro(channel, channel.prevNote + macroPtr[1], READ_BE_UINT16(&macroPtr[2]));
+ break;
+
+ case 0x20: // Signal. Parameters: signalnumber, value(W)
+ if (_playerCtx.numSignals > macroPtr[1])
+ _playerCtx.signal[macroPtr[1]] = READ_BE_UINT16(&macroPtr[2]);
+ continue;
+
+ case 0x21: // Play macro. Parameters: macro, chan, detune
+ noteCommand(channel.note, macroPtr[1], (channel.relVol << 4) | macroPtr[2], macroPtr[3]);
+ continue;
+
+ // 0x22 - 0x29 are used by Gem`X
+ // 0x30 - 0x34 are used by Carribean Disaster
+
+ default:
+ debug(3, "Tfmx: Macro %02X not supported", macroPtr[0]);
+ }
+ if (!deferWait)
+ return;
+ }
+}
+
+void Tfmx::advancePatterns() {
+startPatterns:
+ int runningPatterns = 0;
+
+ for (int i = 0; i < kNumChannels; ++i) {
+ PatternContext &pattern = _patternCtx[i];
+ const uint8 pattCmd = pattern.command;
+ if (pattCmd < 0x90) { // execute Patternstep
+ ++runningPatterns;
+ if (!pattern.wait) {
+ // issue all Steps for this tick
+ if (patternRun(pattern)) {
+ // we load the next Trackstep Command and then process all Channels again
+ if (trackRun(true))
+ goto startPatterns;
+ else
+ break;
+ }
+
+ } else
+ --pattern.wait;
+
+ } else if (pattCmd == 0xFE) { // Stop voice in pattern.expose
+ pattern.command = 0xFF;
+ ChannelContext &channel = _channelCtx[pattern.expose & (kNumVoices - 1)];
+ if (!channel.sfxLocked) {
+ haltMacroProgramm(channel);
+ Paula::disableChannel(channel.paulaChannel);
+ }
+ } // else this pattern-Channel is stopped
+ }
+ if (_playerCtx.stopWithLastPattern && !runningPatterns) {
+ stopPaula();
+ }
+}
+
+bool Tfmx::patternRun(PatternContext &pattern) {
+ for (;;) {
+ const byte *const patternPtr = (const byte *)(getPatternPtr(pattern.offset) + pattern.step);
+ ++pattern.step;
+ const byte pattCmd = patternPtr[0];
+
+ if (pattCmd < 0xF0) { // Playnote
+ bool doWait = false;
+ byte noteCmd = pattCmd + pattern.expose;
+ byte param3 = patternPtr[3];
+ if (pattCmd < 0xC0) { // Note
+ if (pattCmd >= 0x80) { // Wait
+ pattern.wait = param3;
+ param3 = 0;
+ doWait = true;
+ }
+ noteCmd &= 0x3F;
+ } // else Portamento
+ noteCommand(noteCmd, patternPtr[1], patternPtr[2], param3);
+ if (doWait)
+ return false;
+
+ } else { // Patterncommand
+ switch (pattCmd & 0xF) {
+ case 0: // End Pattern + Next Trackstep
+ pattern.command = 0xFF;
+ --pattern.step;
+ return true;
+
+ case 1: // Loop Pattern. Parameters: Loopcount, PatternStep(W)
+ if (pattern.loopCount != 0) {
+ if (pattern.loopCount == 0xFF)
+ pattern.loopCount = patternPtr[1];
+ pattern.step = READ_BE_UINT16(&patternPtr[2]);
+ }
+ --pattern.loopCount;
+ continue;
+
+ case 2: // Jump. Parameters: PatternIndex, PatternStep(W)
+ pattern.offset = _resource->patternOffset[patternPtr[1] & (kMaxPatternOffsets - 1)];
+ pattern.step = READ_BE_UINT16(&patternPtr[2]);
+ continue;
+
+ case 3: // Wait. Paramters: ticks to wait
+ pattern.wait = patternPtr[1];
+ return false;
+
+ case 14: // Stop custompattern
+ // TODO apparently toggles on/off pattern channel 7
+ debug(3, "Tfmx: Encountered 'Stop custompattern' command");
+ // FT
+ case 4: // Stop this pattern
+ pattern.command = 0xFF;
+ --pattern.step;
+ // TODO: try figuring out if this was the last Channel?
+ return false;
+
+ case 5: // Key Up Signal. Paramters: channel
+ if (!_channelCtx[patternPtr[2] & (kNumVoices - 1)].sfxLocked)
+ _channelCtx[patternPtr[2] & (kNumVoices - 1)].keyUp = true;
+ continue;
+
+ case 6: // Vibrato. Parameters: length, channel, rate
+ case 7: // Envelope. Parameters: rate, tempo | channel, endVol
+ noteCommand(pattCmd, patternPtr[1], patternPtr[2], patternPtr[3]);
+ continue;
+
+ case 8: // Subroutine. Parameters: pattern, patternstep(W)
+ pattern.savedOffset = pattern.offset;
+ pattern.savedStep = pattern.step;
+
+ pattern.offset = _resource->patternOffset[patternPtr[1] & (kMaxPatternOffsets - 1)];
+ pattern.step = READ_BE_UINT16(&patternPtr[2]);
+ continue;
+
+ case 9: // Return from Subroutine
+ pattern.offset = pattern.savedOffset;
+ pattern.step = pattern.savedStep;
+ continue;
+
+ case 10: // fade. Parameters: tempo, endVol
+ initFadeCommand((uint8)patternPtr[1], (int8)patternPtr[3]);
+ continue;
+
+ case 11: // play pattern. Parameters: patternCmd, channel, expose
+ initPattern(_patternCtx[patternPtr[2] & (kNumChannels - 1)], patternPtr[1], patternPtr[3], _resource->patternOffset[patternPtr[1] & (kMaxPatternOffsets - 1)]);
+ continue;
+
+ case 12: // Lock. Parameters: lockFlag, channel, lockTime
+ _channelCtx[patternPtr[2] & (kNumVoices - 1)].sfxLocked = (patternPtr[1] != 0);
+ _channelCtx[patternPtr[2] & (kNumVoices - 1)].sfxLockTime = patternPtr[3];
+ continue;
+
+ case 13: // Cue. Parameters: signalnumber, value(W)
+ if (_playerCtx.numSignals > patternPtr[1])
+ _playerCtx.signal[patternPtr[1]] = READ_BE_UINT16(&patternPtr[2]);
+ continue;
+
+ case 15: // NOP
+ continue;
+ }
+ }
+ }
+}
+
+bool Tfmx::trackRun(const bool incStep) {
+ assert(_playerCtx.song >= 0);
+ if (incStep) {
+ // TODO Optionally disable looping
+ if (_trackCtx.posInd == _trackCtx.stopInd)
+ _trackCtx.posInd = _trackCtx.startInd;
+ else
+ ++_trackCtx.posInd;
+ }
+ for (;;) {
+ const uint16 *const trackData = getTrackPtr(_trackCtx.posInd);
+
+ if (trackData[0] != FROM_BE_16(0xEFFE)) {
+ // 8 commands for Patterns
+ for (int i = 0; i < 8; ++i) {
+ const uint8 *patCmd = (const uint8 *)&trackData[i];
+ // First byte is pattern number
+ const uint8 patNum = patCmd[0];
+ // if highest bit is set then keep previous pattern
+ if (patNum < 0x80) {
+ initPattern(_patternCtx[i], patNum, patCmd[1], _resource->patternOffset[patNum]);
+ } else {
+ _patternCtx[i].command = patNum;
+ _patternCtx[i].expose = (int8)patCmd[1];
+ }
+ }
+ return true;
+
+ } else {
+ // 16 byte Trackstep Command
+ switch (READ_BE_UINT16(&trackData[1])) {
+ case 0: // Stop Player. No Parameters
+ stopPaula();
+ return false;
+
+ case 1: // Branch/Loop section of tracksteps. Parameters: branch target, loopcount
+ if (_trackCtx.loopCount != 0) {
+ if (_trackCtx.loopCount < 0)
+ _trackCtx.loopCount = READ_BE_UINT16(&trackData[3]);
+ _trackCtx.posInd = READ_BE_UINT16(&trackData[2]);
+ continue;
+ }
+ --_trackCtx.loopCount;
+ break;
+
+ case 2: { // Set Tempo. Parameters: tempo, divisor
+ _playerCtx.patternCount = _playerCtx.patternSkip = READ_BE_UINT16(&trackData[2]); // tempo
+ const uint16 temp = READ_BE_UINT16(&trackData[3]); // divisor
+
+ if (!(temp & 0x8000) && (temp & 0x1FF))
+ setInterruptFreqUnscaled(temp & 0x1FF);
+ break;
+ }
+ case 4: // Fade. Parameters: tempo, endVol
+ // load the LSB of the 16bit words
+ initFadeCommand(((const uint8 *)&trackData[2])[1], ((const int8 *)&trackData[3])[1]);
+ break;
+
+ case 3: // Unknown, stops player aswell
+ default:
+ debug(3, "Tfmx: Unknown Trackstep Command: %02X", READ_BE_UINT16(&trackData[1]));
+ // MI-Player handles this by stopping the player, we just continue
+ }
+ }
+
+ if (_trackCtx.posInd == _trackCtx.stopInd) {
+ warning("Tfmx: Reached invalid Song-Position");
+ return false;
+ }
+ ++_trackCtx.posInd;
+ }
+}
+
+void Tfmx::noteCommand(const uint8 note, const uint8 param1, const uint8 param2, const uint8 param3) {
+ ChannelContext &channel = _channelCtx[param2 & (kNumVoices - 1)];
+
+ if (note == 0xFC) { // Lock command
+ channel.sfxLocked = (param1 != 0);
+ channel.sfxLockTime = param3; // only 1 byte read!
+
+ } else if (channel.sfxLocked) { // Channel still locked, do nothing
+
+ } else if (note < 0xC0) { // Play Note - Parameters: note, macro, relVol | channel, finetune
+
+ channel.prevNote = channel.note;
+ channel.note = note;
+ // channel.macroIndex = param1 & (kMaxMacroOffsets - 1);
+ channel.macroOffset = _resource->macroOffset[param1 & (kMaxMacroOffsets - 1)];
+ channel.relVol = param2 >> 4;
+ channel.fineTune = (int8)param3;
+
+ // TODO: the point where the channel gets initialised varies with the games, needs more research.
+ initMacroProgramm(channel);
+ channel.keyUp = false; // key down = playing a Note
+
+ } else if (note < 0xF0) { // Portamento - Parameters: note, tempo, channel, rate
+ channel.portaSkip = param1;
+ channel.portaCount = 1;
+ if (!channel.portaDelta)
+ channel.portaValue = channel.refPeriod;
+ channel.portaDelta = param3;
+
+ channel.note = note & 0x3F;
+ channel.refPeriod = noteIntervalls[channel.note];
+
+ } else switch (note) { // Command
+
+ case 0xF5: // Key Up Signal
+ channel.keyUp = true;
+ break;
+
+ case 0xF6: // Vibratio - Parameters: length, channel, rate
+ channel.vibLength = param1 & 0xFE;
+ channel.vibCount = param1 / 2;
+ channel.vibDelta = param3;
+ channel.vibValue = 0;
+ break;
+
+ case 0xF7: // Envelope - Parameters: rate, tempo | channel, endVol
+ channel.envDelta = param1;
+ channel.envCount = channel.envSkip = (param2 >> 4) + 1;
+ channel.envEndVolume = param3;
+ break;
+ }
+}
+
+void Tfmx::initMacroProgramm(ChannelContext &channel) {
+ channel.macroStep = 0;
+ channel.macroWait = 0;
+ channel.macroRun = true;
+ channel.macroSfxRun = 0;
+ channel.macroLoopCount = 0xFF;
+ channel.dmaIntCount = 0;
+ channel.deferWait = false;
+
+ channel.macroReturnOffset = 0;
+ channel.macroReturnStep = 0;
+}
+
+void Tfmx::clearEffects(ChannelContext &channel) {
+ channel.addBeginLength = 0;
+ channel.envSkip = 0;
+ channel.vibLength = 0;
+ channel.portaDelta = 0;
+}
+
+void Tfmx::haltMacroProgramm(ChannelContext &channel) {
+ channel.macroRun = false;
+ channel.dmaIntCount = 0;
+}
+
+void Tfmx::unlockMacroChannel(ChannelContext &channel) {
+ channel.customMacro = 0;
+ channel.customMacroIndex = 0;
+ channel.customMacroPrio = 0;
+ channel.sfxLocked = false;
+ channel.sfxLockTime = -1;
+}
+
+void Tfmx::initPattern(PatternContext &pattern, uint8 cmd, int8 expose, uint32 offset) {
+ pattern.command = cmd;
+ pattern.offset = offset;
+ pattern.expose = expose;
+ pattern.step = 0;
+ pattern.wait = 0;
+ pattern.loopCount = 0xFF;
+
+ pattern.savedOffset = 0;
+ pattern.savedStep = 0;
+}
+
+void Tfmx::stopSongImpl(bool stopAudio) {
+ _playerCtx.song = -1;
+ for (int i = 0; i < kNumChannels; ++i) {
+ _patternCtx[i].command = 0xFF;
+ _patternCtx[i].expose = 0;
+ }
+ if (stopAudio) {
+ stopPaula();
+ for (int i = 0; i < kNumVoices; ++i) {
+ clearEffects(_channelCtx[i]);
+ unlockMacroChannel(_channelCtx[i]);
+ haltMacroProgramm(_channelCtx[i]);
+ _channelCtx[i].note = 0;
+ _channelCtx[i].volume = 0;
+ _channelCtx[i].macroSfxRun = -1;
+ _channelCtx[i].vibValue = 0;
+
+ _channelCtx[i].sampleStart = 0;
+ _channelCtx[i].sampleLen = 2;
+ _channelCtx[i].refPeriod = 4;
+ _channelCtx[i].period = 4;
+ Paula::disableChannel(i);
+ }
+ }
+}
+
+void Tfmx::setNoteMacro(ChannelContext &channel, uint note, int fineTune) {
+ const uint16 noteInt = noteIntervalls[note & 0x3F];
+ const uint16 finetune = (uint16)(fineTune + channel.fineTune + (1 << 8));
+ channel.refPeriod = ((uint32)noteInt * finetune >> 8);
+ if (!channel.portaDelta)
+ channel.period = channel.refPeriod;
+}
+
+void Tfmx::initFadeCommand(const uint8 fadeTempo, const int8 endVol) {
+ _playerCtx.fadeCount = _playerCtx.fadeSkip = fadeTempo;
+ _playerCtx.fadeEndVolume = endVol;
+
+ if (fadeTempo) {
+ const int diff = _playerCtx.fadeEndVolume - _playerCtx.volume;
+ _playerCtx.fadeDelta = (diff != 0) ? ((diff > 0) ? 1 : -1) : 0;
+ } else {
+ _playerCtx.volume = endVol;
+ _playerCtx.fadeDelta = 0;
+ }
+}
+
+void Tfmx::setModuleData(Tfmx &otherPlayer) {
+ setModuleData(otherPlayer._resource, otherPlayer._resourceSample.sampleData, otherPlayer._resourceSample.sampleLen, false);
+}
+
+bool Tfmx::load(Common::SeekableReadStream &musicData, Common::SeekableReadStream &sampleData, bool autoDelete) {
+ const MdatResource *mdat = loadMdatFile(musicData);
+ if (mdat) {
+ uint32 sampleLen = 0;
+ const int8 *sampleDat = loadSampleFile(sampleLen, sampleData);
+ if (sampleDat) {
+ setModuleData(mdat, sampleDat, sampleLen, autoDelete);
+ return true;
+ }
+ delete[] mdat->mdatAlloc;
+ delete mdat;
+ }
+ return false;
+}
+
+void Tfmx::freeResourceDataImpl() {
+ if (_deleteResource) {
+ if (_resource) {
+ delete[] _resource->mdatAlloc;
+ delete _resource;
+ }
+ delete[] _resourceSample.sampleData;
+ }
+ _resource = 0;
+ _resourceSample.sampleData = 0;
+ _resourceSample.sampleLen = 0;
+ _deleteResource = false;
+}
+
+void Tfmx::setModuleData(const MdatResource *resource, const int8 *sampleData, uint32 sampleLen, bool autoDelete) {
+ Common::StackLock lock(_mutex);
+ stopSongImpl(true);
+ freeResourceDataImpl();
+ _resource = resource;
+ _resourceSample.sampleData = sampleData;
+ _resourceSample.sampleLen = sampleData ? sampleLen : 0;
+ _deleteResource = autoDelete;
+}
+
+const int8 *Tfmx::loadSampleFile(uint32 &sampleLen, Common::SeekableReadStream &sampleStream) {
+ sampleLen = 0;
+
+ const int32 sampleSize = sampleStream.size();
+ if (sampleSize < 4) {
+ warning("Tfmx: Cant load Samplefile");
+ return false;
+ }
+
+ int8 *sampleAlloc = new int8[sampleSize];
+ if (!sampleAlloc) {
+ warning("Tfmx: Could not allocate Memory: %dKB", sampleSize / 1024);
+ return 0;
+ }
+
+ if (sampleStream.read(sampleAlloc, sampleSize) == (uint32)sampleSize) {
+ sampleAlloc[0] = sampleAlloc[1] = sampleAlloc[2] = sampleAlloc[3] = 0;
+ sampleLen = sampleSize;
+ } else {
+ delete sampleAlloc;
+ warning("Tfmx: Encountered IO-Error");
+ return 0;
+ }
+ return sampleAlloc;
+}
+
+const Tfmx::MdatResource *Tfmx::loadMdatFile(Common::SeekableReadStream &musicData) {
+ bool hasHeader = false;
+ const int32 mdatSize = musicData.size();
+ if (mdatSize >= 0x200) {
+ byte buf[16] = { 0 };
+ // 0x0000: 10 Bytes Header "TFMX-SONG "
+ musicData.read(buf, 10);
+ hasHeader = memcmp(buf, "TFMX-SONG ", 10) == 0;
+ }
+
+ if (!hasHeader) {
+ warning("Tfmx: File is not a Tfmx Module");
+ return 0;
+ }
+
+ MdatResource *resource = new MdatResource;
+
+ resource->mdatAlloc = 0;
+ resource->mdatData = 0;
+ resource->mdatLen = 0;
+
+ // 0x000A: int16 flags
+ resource->headerFlags = musicData.readUint16BE();
+ // 0x000C: int32 ?
+ // 0x0010: 6*40 Textfield
+ musicData.skip(4 + 6 * 40);
+
+ /* 0x0100: Songstart x 32*/
+ for (int i = 0; i < kNumSubsongs; ++i)
+ resource->subsong[i].songstart = musicData.readUint16BE();
+ /* 0x0140: Songend x 32*/
+ for (int i = 0; i < kNumSubsongs; ++i)
+ resource->subsong[i].songend = musicData.readUint16BE();
+ /* 0x0180: Tempo x 32*/
+ for (int i = 0; i < kNumSubsongs; ++i)
+ resource->subsong[i].tempo = musicData.readUint16BE();
+
+ /* 0x01c0: unused ? */
+ musicData.skip(16);
+
+ /* 0x01d0: trackstep, pattern data p, macro data p */
+ const uint32 offTrackstep = musicData.readUint32BE();
+ uint32 offPatternP, offMacroP;
+
+ // This is how MI`s TFMX-Player tests for unpacked Modules.
+ if (offTrackstep == 0) { // unpacked File
+ resource->trackstepOffset = 0x600 + 0x200;
+ offPatternP = 0x200 + 0x200;
+ offMacroP = 0x400 + 0x200;
+ } else { // packed File
+ resource->trackstepOffset = offTrackstep;
+ offPatternP = musicData.readUint32BE();
+ offMacroP = musicData.readUint32BE();
+ }
+
+ // End of basic header, check if everything worked ok
+ if (musicData.err()) {
+ warning("Tfmx: Encountered IO-Error");
+ delete resource;
+ return 0;
+ }
+
+ // TODO: if a File is packed it could have for Ex only 2 Patterns/Macros
+ // the following loops could then read beyond EOF.
+ // To correctly handle this it would be necessary to sort the pointers and
+ // figure out the number of Macros/Patterns
+ // We could also analyze pointers if they are correct offsets,
+ // so that accesses can be unchecked later
+
+ // Read in pattern starting offsets
+ musicData.seek(offPatternP);
+ for (int i = 0; i < kMaxPatternOffsets; ++i)
+ resource->patternOffset[i] = musicData.readUint32BE();
+
+ // use last PatternOffset (stored at 0x5FC in mdat) if unpacked File
+ // or fixed offset 0x200 if packed
+ resource->sfxTableOffset = offTrackstep ? 0x200 : resource->patternOffset[127];
+
+ // Read in macro starting offsets
+ musicData.seek(offMacroP);
+ for (int i = 0; i < kMaxMacroOffsets; ++i)
+ resource->macroOffset[i] = musicData.readUint32BE();
+
+ // Read in mdat-file
+ // TODO: we can skip everything thats already stored in the resource-structure.
+ const int32 mdatOffset = offTrackstep ? 0x200 : 0x600; // 0x200 is very conservative
+ const uint32 allocSize = (uint32)mdatSize - mdatOffset;
+
+ byte *mdatAlloc = new byte[allocSize];
+ if (!mdatAlloc) {
+ warning("Tfmx: Could not allocate Memory: %dKB", allocSize / 1024);
+ delete resource;
+ return 0;
+ }
+ musicData.seek(mdatOffset);
+ if (musicData.read(mdatAlloc, allocSize) == allocSize) {
+ resource->mdatAlloc = mdatAlloc;
+ resource->mdatData = mdatAlloc - mdatOffset;
+ resource->mdatLen = mdatSize;
+ } else {
+ delete mdatAlloc;
+ warning("Tfmx: Encountered IO-Error");
+ delete resource;
+ return 0;
+ }
+
+ return resource;
+}
+
+void Tfmx::doMacro(int note, int macro, int relVol, int finetune, int channelNo) {
+ assert(0 <= macro && macro < kMaxMacroOffsets);
+ assert(0 <= note && note < 0xC0);
+ Common::StackLock lock(_mutex);
+
+ if (!hasResources())
+ return;
+ channelNo &= (kNumVoices - 1);
+ ChannelContext &channel = _channelCtx[channelNo];
+ unlockMacroChannel(channel);
+
+ noteCommand((uint8)note, (uint8)macro, (uint8)((relVol << 4) | channelNo), (uint8)finetune);
+ startPaula();
+}
+
+void Tfmx::stopMacroEffect(int channel) {
+ assert(0 <= channel && channel < kNumVoices);
+ Common::StackLock lock(_mutex);
+ unlockMacroChannel(_channelCtx[channel]);
+ haltMacroProgramm(_channelCtx[channel]);
+ Paula::disableChannel(_channelCtx[channel].paulaChannel);
+}
+
+void Tfmx::doSong(int songPos, bool stopAudio) {
+ assert(0 <= songPos && songPos < kNumSubsongs);
+ Common::StackLock lock(_mutex);
+
+ stopSongImpl(stopAudio);
+
+ if (!hasResources())
+ return;
+
+ _trackCtx.loopCount = -1;
+ _trackCtx.startInd = _trackCtx.posInd = _resource->subsong[songPos].songstart;
+ _trackCtx.stopInd = _resource->subsong[songPos].songend;
+ _playerCtx.song = (int8)songPos;
+
+ const bool palFlag = (_resource->headerFlags & 2) != 0;
+ const uint16 tempo = _resource->subsong[songPos].tempo;
+ uint16 ciaIntervall;
+ if (tempo >= 0x10) {
+ ciaIntervall = (uint16)(kCiaBaseInterval / tempo);
+ _playerCtx.patternSkip = 0;
+ } else {
+ ciaIntervall = palFlag ? (uint16)kPalDefaultCiaVal : (uint16)kNtscDefaultCiaVal;
+ _playerCtx.patternSkip = tempo;
+ }
+ setInterruptFreqUnscaled(ciaIntervall);
+ Paula::setAudioFilter(true);
+
+ _playerCtx.patternCount = 0;
+ if (trackRun())
+ startPaula();
+}
+
+int Tfmx::doSfx(uint16 sfxIndex, bool unlockChannel) {
+ assert(sfxIndex < 128);
+ Common::StackLock lock(_mutex);
+
+ if (!hasResources())
+ return -1;
+ const byte *sfxEntry = getSfxPtr(sfxIndex);
+ if (sfxEntry[0] == 0xFB) {
+ warning("Tfmx: custom patterns are not supported");
+ // custompattern
+ /* const uint8 patCmd = sfxEntry[2];
+ const int8 patExp = (int8)sfxEntry[3]; */
+ } else {
+ // custommacro
+ const byte channelNo = ((_playerCtx.song >= 0) ? sfxEntry[2] : sfxEntry[4]) & (kNumVoices - 1);
+ const byte priority = sfxEntry[5] & 0x7F;
+
+ ChannelContext &channel = _channelCtx[channelNo];
+ if (unlockChannel)
+ unlockMacroChannel(channel);
+
+ const int16 sfxLocktime = channel.sfxLockTime;
+ if (priority >= channel.customMacroPrio || sfxLocktime < 0) {
+ if (sfxIndex != channel.customMacroIndex || sfxLocktime < 0 || (sfxEntry[5] < 0x80)) {
+ channel.customMacro = READ_UINT32(sfxEntry); // intentionally not "endian-correct"
+ channel.customMacroPrio = priority;
+ channel.customMacroIndex = (uint8)sfxIndex;
+ debug(3, "Tfmx: running Macro %08X on channel %i - priority: %02X", TO_BE_32(channel.customMacro), channelNo, priority);
+ return channelNo;
+ }
+ }
+ }
+ return -1;
+}
+
+} // End of namespace Audio
+
+// some debugging functions
+namespace {
+#if !defined(NDEBUG) && 0
+void displayMacroStep(const void *const vptr) {
+ const char *tableMacros[] = {
+ "DMAoff+Resetxx/xx/xx flag/addset/vol ",
+ "DMAon (start sample at selected begin) ",
+ "SetBegin xxxxxx sample-startadress",
+ "SetLen ..xxxx sample-length ",
+ "Wait ..xxxx count (VBI''s) ",
+ "Loop xx/xxxx count/step ",
+ "Cont xx/xxxx macro-number/step ",
+ "-------------STOP----------------------",
+ "AddNote xx/xxxx note/detune ",
+ "SetNote xx/xxxx note/detune ",
+ "Reset Vibrato-Portamento-Envelope ",
+ "Portamento xx/../xx count/speed ",
+ "Vibrato xx/../xx speed/intensity ",
+ "AddVolume ....xx volume 00-3F ",
+ "SetVolume ....xx volume 00-3F ",
+ "Envelope xx/xx/xx speed/count/endvol",
+ "Loop key up xx/xxxx count/step ",
+ "AddBegin xx/xxxx count/add to start",
+ "AddLen ..xxxx add to sample-len ",
+ "DMAoff stop sample but no clear ",
+ "Wait key up ....xx count (VBI''s) ",
+ "Go submacro xx/xxxx macro-number/step ",
+ "--------Return to old macro------------",
+ "Setperiod ..xxxx DMA period ",
+ "Sampleloop ..xxxx relative adress ",
+ "-------Set one shot sample-------------",
+ "Wait on DMA ..xxxx count (Wavecycles)",
+ "Random play xx/xx/xx macro/speed/mode ",
+ "Splitkey xx/xxxx key/macrostep ",
+ "Splitvolume xx/xxxx volume/macrostep ",
+ "Addvol+note xx/fe/xx note/CONST./volume",
+ "SetPrevNote xx/xxxx note/detune ",
+ "Signal xx/xxxx signalnumber/value",
+ "Play macro xx/.x/xx macro/chan/detune ",
+ "SID setbeg xxxxxx sample-startadress",
+ "SID setlen xx/xxxx buflen/sourcelen ",
+ "SID op3 ofs xxxxxx offset ",
+ "SID op3 frq xx/xxxx speed/amplitude ",
+ "SID op2 ofs xxxxxx offset ",
+ "SID op2 frq xx/xxxx speed/amplitude ",
+ "SID op1 xx/xx/xx speed/amplitude/TC",
+ "SID stop xx.... flag (1=clear all)"
+ };
+
+ const byte *const macroData = (const byte *const)vptr;
+ if (macroData[0] < ARRAYSIZE(tableMacros))
+ debug("%s %02X%02X%02X", tableMacros[macroData[0]], macroData[1], macroData[2], macroData[3]);
+ else
+ debug("Unkown Macro #%02X %02X%02X%02X", macroData[0], macroData[1], macroData[2], macroData[3]);
+}
+
+void displayPatternstep(const void *const vptr) {
+ const char *tablePatterns[] = {
+ "End --Next track step--",
+ "Loop[count / step.w]",
+ "Cont[patternno./ step.w]",
+ "Wait[count 00-FF--------",
+ "Stop--Stop this pattern-",
+ "Kup^-Set key up/channel]",
+ "Vibr[speed / rate.b]",
+ "Enve[speed /endvolume.b]",
+ "GsPt[patternno./ step.w]",
+ "RoPt-Return old pattern-",
+ "Fade[speed /endvolume.b]",
+ "PPat[patt./track+transp]",
+ "Lock---------ch./time.b]",
+ "Cue [number.b/ value.w]",
+ "Stop-Stop custompattern-",
+ "NOP!-no operation-------"
+ };
+
+ const byte *const patData = (const byte *const)vptr;
+ const byte command = patData[0];
+ if (command < 0xF0) { // Playnote
+ const byte flags = command >> 6; // 0-1 means note+detune, 2 means wait, 3 means portamento?
+ const char *flagsSt[] = { "Note ", "Note ", "Wait ", "Porta" };
+ debug("%s %02X%02X%02X%02X", flagsSt[flags], patData[0], patData[1], patData[2], patData[3]);
+ } else
+ debug("%s %02X%02X%02X",tablePatterns[command & 0xF], patData[1], patData[2], patData[3]);
+}
+#else
+void displayMacroStep(const void *const vptr, int chan, int index) {}
+void displayPatternstep(const void *const vptr) {}
+#endif
+} // End of namespace
+
+#endif // #if defined(SOUND_MODS_TFMX_H)
diff --git a/sound/mods/tfmx.h b/sound/mods/tfmx.h
new file mode 100644
index 0000000000..26018d9466
--- /dev/null
+++ b/sound/mods/tfmx.h
@@ -0,0 +1,284 @@
+/* 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$
+ *
+ */
+
+// see if all engines using this class are DISABLED
+#if !defined(ENABLE_SCUMM)
+
+// normal Header Guard
+#elif !defined(SOUND_MODS_TFMX_H)
+#define SOUND_MODS_TFMX_H
+
+#include "sound/mods/paula.h"
+
+namespace Audio {
+
+class Tfmx : public Paula {
+public:
+ Tfmx(int rate, bool stereo);
+ virtual ~Tfmx();
+
+ /**
+ * Stops a playing Song (but leaves macros running) and optionally also stops the player
+ *
+ * @param stopAudio stops player and audio output
+ * @param dataSize number of bytes to be written
+ * @return the number of bytes which were actually written.
+ */
+ void stopSong(bool stopAudio = true) { Common::StackLock lock(_mutex); stopSongImpl(stopAudio); }
+ /**
+ * Stops currently playing Song (if any) and cues up a new one.
+ * if stopAudio is specified, the player gets reset before starting the new song
+ *
+ * @param songPos index of Song to play
+ * @param stopAudio stops player and audio output
+ * @param dataSize number of bytes to be written
+ * @return the number of bytes which were actually written.
+ */
+ void doSong(int songPos, bool stopAudio = false);
+ /**
+ * plays an effect from the sfx-table, does not start audio-playback.
+ *
+ * @param sfxIndex index of effect to play
+ * @param unlockChannel overwrite higher priority effects
+ * @return index of the channel which now queued up the effect.
+ * -1 in case the effect couldnt be queued up
+ */
+ int doSfx(uint16 sfxIndex, bool unlockChannel = false);
+ /**
+ * stop a running macro channel
+ *
+ * @param channel index of effect to stop
+ */
+ void stopMacroEffect(int channel);
+
+ void doMacro(int note, int macro, int relVol = 0, int finetune = 0, int channelNo = 0);
+ int getTicks() const { return _playerCtx.tickCount; }
+ int getSongIndex() const { return _playerCtx.song; }
+ void setSignalPtr(uint16 *ptr, uint16 numSignals) { _playerCtx.signal = ptr; _playerCtx.numSignals = numSignals; }
+ void freeResources() { _deleteResource = true; freeResourceDataImpl(); }
+ bool load(Common::SeekableReadStream &musicData, Common::SeekableReadStream &sampleData, bool autoDelete = true);
+ void setModuleData(Tfmx &otherPlayer);
+
+protected:
+ void interrupt();
+
+private:
+ enum { kPalDefaultCiaVal = 11822, kNtscDefaultCiaVal = 14320, kCiaBaseInterval = 0x1B51F8 };
+ enum { kNumVoices = 4, kNumChannels = 8, kNumSubsongs = 32, kMaxPatternOffsets = 128, kMaxMacroOffsets = 128 };
+
+ struct MdatResource {
+ const byte *mdatAlloc; //!< allocated Block of Memory
+ const byte *mdatData; //!< Start of mdat-File, might point before mdatAlloc to correct Offset
+ uint32 mdatLen;
+
+ uint16 headerFlags;
+// uint32 headerUnknown;
+// char textField[6 * 40];
+
+ struct Subsong {
+ uint16 songstart; //!< Index in Trackstep-Table
+ uint16 songend; //!< Last index in Trackstep-Table
+ uint16 tempo;
+ } subsong[kNumSubsongs];
+
+ uint32 trackstepOffset; //!< Offset in mdat
+ uint32 sfxTableOffset;
+
+ uint32 patternOffset[kMaxPatternOffsets]; //!< Offset in mdat
+ uint32 macroOffset[kMaxMacroOffsets]; //!< Offset in mdat
+
+ void boundaryCheck(const void *address, size_t accessLen = 1) const {
+ assert(mdatAlloc <= address && (const byte *)address + accessLen <= (const byte *)mdatData + mdatLen);
+ }
+ } const *_resource;
+
+ struct SampleResource {
+ const int8 *sampleData; //!< The whole sample-File
+ uint32 sampleLen;
+
+ void boundaryCheck(const void *address, size_t accessLen = 2) const {
+ assert(sampleData <= address && (const byte *)address + accessLen <= (const byte *)sampleData + sampleLen);
+ }
+ } _resourceSample;
+
+ bool _deleteResource;
+
+ bool hasResources() {
+ return _resource && _resource->mdatLen && _resourceSample.sampleLen;
+ }
+
+ struct ChannelContext {
+ byte paulaChannel;
+
+// byte macroIndex;
+ uint16 macroWait;
+ uint32 macroOffset;
+ uint32 macroReturnOffset;
+ uint16 macroStep;
+ uint16 macroReturnStep;
+ uint8 macroLoopCount;
+ bool macroRun;
+ int8 macroSfxRun; //!< values are the folowing: -1 macro disabled, 0 macro init, 1 macro running
+
+ uint32 customMacro;
+ uint8 customMacroIndex;
+ uint8 customMacroPrio;
+
+ bool sfxLocked;
+ int16 sfxLockTime;
+ bool keyUp;
+
+ bool deferWait;
+ uint16 dmaIntCount;
+
+ uint32 sampleStart;
+ uint16 sampleLen;
+ uint16 refPeriod;
+ uint16 period;
+
+ int8 volume;
+ uint8 relVol;
+ uint8 note;
+ uint8 prevNote;
+ int16 fineTune; // always a signextended byte
+
+ uint8 portaSkip;
+ uint8 portaCount;
+ uint16 portaDelta;
+ uint16 portaValue;
+
+ uint8 envSkip;
+ uint8 envCount;
+ uint8 envDelta;
+ int8 envEndVolume;
+
+ uint8 vibLength;
+ uint8 vibCount;
+ int16 vibValue;
+ int8 vibDelta;
+
+ uint8 addBeginLength;
+ uint8 addBeginCount;
+ int32 addBeginDelta;
+ } _channelCtx[kNumVoices];
+
+ struct PatternContext {
+ uint32 offset; // patternStart, Offset from mdat
+ uint32 savedOffset; // for subroutine calls
+ uint16 step; // distance from patternStart
+ uint16 savedStep;
+
+ uint8 command;
+ int8 expose;
+ uint8 loopCount;
+ uint8 wait; //!< how many ticks to wait before next Command
+ } _patternCtx[kNumChannels];
+
+ struct TrackStepContext {
+ uint16 startInd;
+ uint16 stopInd;
+ uint16 posInd;
+ int16 loopCount;
+ } _trackCtx;
+
+ struct PlayerContext {
+ int8 song; //!< >= 0 if Song is running (means process Patterns)
+
+ uint16 patternCount;
+ uint16 patternSkip; //!< skip that amount of CIA-Interrupts
+
+ int8 volume; //!< Master Volume
+
+ uint8 fadeSkip;
+ uint8 fadeCount;
+ int8 fadeEndVolume;
+ int8 fadeDelta;
+
+ int tickCount;
+
+ uint16 *signal;
+ uint16 numSignals;
+
+ bool stopWithLastPattern; //!< hack to automatically stop the whole player if no Pattern is running
+ } _playerCtx;
+
+ const byte *getSfxPtr(uint16 index = 0) const {
+ const byte *sfxPtr = (const byte *)(_resource->mdatData + _resource->sfxTableOffset + index * 8);
+
+ _resource->boundaryCheck(sfxPtr, 8);
+ return sfxPtr;
+ }
+
+ const uint16 *getTrackPtr(uint16 trackstep = 0) const {
+ const uint16 *trackData = (const uint16 *)(_resource->mdatData + _resource->trackstepOffset + 16 * trackstep);
+
+ _resource->boundaryCheck(trackData, 16);
+ return trackData;
+ }
+
+ const uint32 *getPatternPtr(uint32 offset) const {
+ const uint32 *pattData = (const uint32 *)(_resource->mdatData + offset);
+
+ _resource->boundaryCheck(pattData, 4);
+ return pattData;
+ }
+
+ const uint32 *getMacroPtr(uint32 offset) const {
+ const uint32 *macroData = (const uint32 *)(_resource->mdatData + offset);
+
+ _resource->boundaryCheck(macroData, 4);
+ return macroData;
+ }
+
+ const int8 *getSamplePtr(const uint32 offset) const {
+ const int8 *sample = _resourceSample.sampleData + offset;
+
+ _resourceSample.boundaryCheck(sample, 2);
+ return sample;
+ }
+
+ static inline void initMacroProgramm(ChannelContext &channel);
+ static inline void clearEffects(ChannelContext &channel);
+ static inline void haltMacroProgramm(ChannelContext &channel);
+ static inline void unlockMacroChannel(ChannelContext &channel);
+ static inline void initPattern(PatternContext &pattern, uint8 cmd, int8 expose, uint32 offset);
+ void stopSongImpl(bool stopAudio = true);
+ static void inline setNoteMacro(ChannelContext &channel, uint note, int fineTune);
+ void initFadeCommand(const uint8 fadeTempo, const int8 endVol);
+ void setModuleData(const MdatResource *resource, const int8 *sampleData, uint32 sampleLen, bool autoDelete = true);
+ static const MdatResource *loadMdatFile(Common::SeekableReadStream &musicData);
+ static const int8 *loadSampleFile(uint32 &sampleLen, Common::SeekableReadStream &sampleStream);
+ void freeResourceDataImpl();
+ void effects(ChannelContext &channel);
+ void macroRun(ChannelContext &channel);
+ void advancePatterns();
+ bool patternRun(PatternContext &pattern);
+ bool trackRun(bool incStep = false);
+ void noteCommand(uint8 note, uint8 param1, uint8 param2, uint8 param3);
+};
+
+} // End of namespace Audio
+
+#endif // !defined(SOUND_MODS_TFMX_H)
diff --git a/sound/module.mk b/sound/module.mk
index 3bcdd47c56..aabe7fe729 100644
--- a/sound/module.mk
+++ b/sound/module.mk
@@ -24,11 +24,13 @@ MODULE_OBJS := \
vorbis.o \
wave.o \
mods/infogrames.o \
+ mods/maxtrax.o \
mods/module.o \
mods/protracker.o \
mods/paula.o \
mods/rjp1.o \
mods/soundfx.o \
+ mods/tfmx.o \
softsynth/adlib.o \
softsynth/opl/dosbox.o \
softsynth/opl/mame.o \
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-26 23:51:10 +0000