aboutsummaryrefslogtreecommitdiff
path: root/sound/mods/maxtrax.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'sound/mods/maxtrax.cpp')
-rw-r--r--sound/mods/maxtrax.cpp282
1 files changed, 275 insertions, 7 deletions
diff --git a/sound/mods/maxtrax.cpp b/sound/mods/maxtrax.cpp
index 13c7148fe4..f945a5544b 100644
--- a/sound/mods/maxtrax.cpp
+++ b/sound/mods/maxtrax.cpp
@@ -34,7 +34,23 @@
namespace Audio {
MaxTrax::MaxTrax(int rate, bool stereo)
- : Paula(stereo, rate, rate/50), _patch(), _scores(), _numScores(), _microtonal() {
+ : Paula(stereo, rate, rate/50), _playerCtx(), _voiceCtx(), _patch(), _channelCtx(), _scores(), _numScores(), _microtonal() {
+ _playerCtx.maxScoreNum = 128;
+ _playerCtx.vBlankFreq = 50;
+ _playerCtx.frameUnit = (uint16)((1000 * (1<<8)) / _playerCtx.vBlankFreq);
+ _playerCtx.scoreIndex = -1;
+ // glob_CurrentScore = _scoreptr;
+ _playerCtx.volume = 0x64;
+
+ _playerCtx.tempoTime = 0;
+
+ uint32 uinqueId = 0;
+ byte flags = 0;
+
+ uint32 colorClock = kPalSystemClock / 2;
+
+ // init extraChannel
+ // extraChannel. chan_Number = 16, chan_Flags = chan_VoicesActive = 0
}
MaxTrax::~MaxTrax() {
@@ -44,11 +60,263 @@ MaxTrax::~MaxTrax() {
}
void MaxTrax::interrupt() {
+ // a5 - maxtraxm a4 . globaldata
+
+ // 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]; // a3
+ if (!voice.channel || voice.stopEventCommand >= 0x80)
+ continue;
+ const int channelNo = voice.stopEventParameter;
+ voice.stopEventTime -= (channelNo < kNumChannels) ? _playerCtx.tickUnit : _playerCtx.frameUnit;
+ if (voice.stopEventTime <= 0) {
+ noteOff(_channelCtx[channelNo], voice.stopEventCommand);
+ voice.stopEventCommand = 0xFF;
+ }
+ }
+
+ if (_playerCtx.musicPlaying) {
+ Event *curEvent = _playerCtx.nextEvent;
+ int32 eventTime = _playerCtx.nextEventTime;
+ for (; eventTime <= millis; eventTime += (++curEvent)->startTime) {
+ const byte cmd = curEvent->command;
+ const byte data = curEvent->parameter;
+ const uint16 stopTime = curEvent->stopTime;
+ ChannelContext &channel = _channelCtx[data & 0x0F];
+
+ outPutEvent(*curEvent);
+
+ if (cmd < 0x80) {
+ _playerCtx.addedNote = false;
+ const uint16 vol = (data & 0xF0) >> 1;
+
+ const int8 voiceIndex = noteOn(channel, cmd, vol, kPriorityScore);
+ if (voiceIndex >= 0) {
+ VoiceContext &voice = _voiceCtx[voiceIndex];
+ voice.stopEventCommand = cmd;
+ voice.stopEventParameter = data & 0x0F;
+ voice.stopEventTime = (eventTime + stopTime - millis) << 8;
+ }
+ } else {
+ switch (cmd) {
+ case 0x80: // TEMPO
+ if ((_playerCtx.tickUnit >> 8) > stopTime) {
+ setTempo(data << 4);
+ _playerCtx.tempoTime = 0;
+ } else {
+ _playerCtx.tempoStart = _playerCtx.tempo;
+ _playerCtx.tempoDelta = (data << 4) - _playerCtx.tempoStart;
+ _playerCtx.tempoTime = (stopTime << 8);
+ _playerCtx.tempoTicks = 0;
+ }
+ break;
+/* case 0xA0: // SPECIAL
+ break;
+ case 0xB0: // CONTROL
+ // TODO: controlChange((byte)stopTime, (byte)(stopTime >> 8))
+ break;
+*/ case 0xC0: // PROGRAM
+ channel.patch = &_patch[stopTime & (kNumPatches - 1)];
+ break;
+ case 0xE0: // BEND
+ channel.pitchBend = ((stopTime & 0x7F00) >> 1) | (stopTime & 0x7f);
+ channel.pitchReal = ((int32)(channel.pitchBendRange << 8) * (channel.pitchBend - (64 << 7))) / (64 << 7);
+ channel.flags |= ChannelContext::kFlagAltered;
+ break;
+ case 0xFF: // END
+ if (_playerCtx.musicLoop) {
+ // event -1 as it gets increased at the end of the loop
+ curEvent = _scores[_playerCtx.scoreIndex].events - 1;
+ _playerCtx.ticks = 0;
+ eventTime = 0;
+ } else
+ _playerCtx.musicPlaying = false;
+ break;
+ default:
+ debug("Unhandled Command");
+ outPutEvent(*curEvent);
+ }
+ }
+ }
+ _playerCtx.nextEvent = curEvent;
+ _playerCtx.nextEventTime = eventTime;
+
+ // tempoEffect
+ if (_playerCtx.tempoTime) {
+ _playerCtx.tempoTicks += _playerCtx.tickUnit;
+ uint16 newTempo;
+ if (_playerCtx.tempoTicks < _playerCtx.tempoTime) {
+ const uint16 delta = (_playerCtx.tempoTicks * _playerCtx.tempoDelta) / _playerCtx.tempoTime;
+ newTempo = delta;
+ } else {
+ _playerCtx.tempoTime = 0;
+ newTempo = _playerCtx.tempoDelta;
+ }
+ setTempo(_playerCtx.tempoStart + newTempo);
+ }
+
+ // envelopes
+
+ }
+
}
void MaxTrax::stopMusic() {
}
+bool MaxTrax::doSong(int songIndex, int advance) {
+ if (songIndex < 0 || songIndex >= _numScores)
+ return false;
+ Paula::pausePlay(true);
+ _playerCtx.musicPlaying = false;
+ _playerCtx.musicLoop = false;
+
+ setTempo(_playerCtx.tempoInitial);
+ _playerCtx.nextEvent = _scores[songIndex].events;
+ _playerCtx.scoreIndex = songIndex;
+
+ _playerCtx.musicPlaying = true;
+ Paula::startPaula();
+}
+
+void MaxTrax::killVoice(byte num) {
+ VoiceContext &voice = _voiceCtx[num];
+ --(voice.channel->voicesActive);
+ voice.channel = 0;
+ voice.status = VoiceContext::kStatusFree;
+ voice.flags = 0;
+ voice.priority = 0;
+ voice.uinqueId = 0;
+
+ // "stop" voice, set period to 1, vol to 0
+ Paula::disableChannel(0);
+ Paula::setChannelPeriod(num, 1);
+ Paula::setChannelVolume(num, 0);
+}
+
+int8 MaxTrax::noteOn(ChannelContext &channel, const byte note, uint16 volume, uint16 pri) {
+ if (channel.microtonal >= 0)
+ _microtonal[note % 127] = channel.microtonal;
+ if (!volume)
+ return -1;
+
+ Patch &patch = *channel.patch;
+ if (!patch.samplePtr)
+ return -1;
+ int8 voiceNum = -1;
+ if ((channel.flags & ChannelContext::kFlagMono) != 0 && channel.voicesActive) {
+ for (voiceNum = ARRAYSIZE(_voiceCtx) - 1; voiceNum >= 0 && _voiceCtx[voiceNum].channel != &channel; --voiceNum)
+ ;
+ if (voiceNum < 0)
+ return -1;
+
+ VoiceContext &voice = _voiceCtx[voiceNum];
+ if (voice.status >= VoiceContext::kStatusSustain && (channel.flags & ChannelContext::kFlagPortamento) != 0) {
+ // reset previous porta
+ if ((voice.flags & VoiceContext::kFlagPortamento) != 0)
+ voice.baseNote = voice.endNote;
+ voice.portaTicks = 0;
+ voice.flags |= VoiceContext::kFlagPortamento;
+ voice.endNote = channel.lastNote = note;
+ voice.noteVolume = (_playerCtx.handleVolume) ? volume + 1 : 128;
+ goto endFunction;
+ }
+ } else {
+ // TODO:
+ // pickvoice based on channel.isRightChannel
+ // return if no channel found
+ voiceNum = (channel.flags & ChannelContext::kFlagRightChannel) != 0 ? 0 : 1;
+ }
+ assert(voiceNum >= 0 && voiceNum < ARRAYSIZE(_voiceCtx));
+
+ VoiceContext &voice = _voiceCtx[voiceNum];
+ voice.flags = 0;
+ if (voice.channel) {
+ killVoice(voiceNum);
+ voice.flags |= VoiceContext::kFlagStolen;
+ }
+ voice.channel = &channel;
+ voice.patch = &patch;
+ voice.baseNote = note;
+
+ // calc note period
+ voice.priority = (byte)pri;
+ voice.status = VoiceContext::kStatusStart;
+
+ voice.noteVolume = (_playerCtx.handleVolume) ? volume + 1 : 128;
+
+ // ifeq HAS_FULLCHANVOL macro
+ if (channel.volume < 128)
+ voice.noteVolume = (voice.noteVolume * channel.volume) >> 7;
+
+ voice.baseVolume = 0;
+ voice.lastTicks = 0;
+
+ uint16 period = voice.lastPeriod;
+ if (!period)
+ period = 1000;
+
+ int useOctave = 0;
+ // 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);
+ Paula::setChannelPeriod(voiceNum, period);
+ Paula::setChannelVolume(voiceNum, 0);
+
+ Paula::enableChannel(voiceNum);
+ // wait for dma-clear
+ }
+
+ if (patch.sampleTotalLen > patch.sampleAttackLen) {
+ Paula::setChannelSampleStart(voiceNum, samplePtr + patch.sampleAttackLen);
+ Paula::setChannelSampleLen(voiceNum, (patch.sampleTotalLen - patch.sampleAttackLen) << useOctave);
+ if (!patch.sampleAttackLen) {
+ // need to enable channel
+ Paula::setChannelPeriod(voiceNum, period);
+ Paula::setChannelVolume(voiceNum, 0);
+
+ Paula::enableChannel(voiceNum);
+ }
+ // another pointless wait for DMA-Clear???
+ }
+
+ channel.voicesActive++;
+ if (&channel < &_channelCtx[kNumChannels]) {
+ const byte flagsSet = ChannelContext::kFlagMono | ChannelContext::kFlagPortamento;
+ if ((channel.flags & flagsSet) == flagsSet && channel.lastNote < 0x80 && channel.lastNote != voice.baseNote) {
+ voice.portaTicks = 0;
+ voice.endNote = voice.baseNote;
+ voice.baseNote = channel.lastNote;
+ voice.flags |= VoiceContext::kFlagPortamento;
+ }
+ if ((channel.flags & ChannelContext::kFlagPortamento) != 0)
+ channel.lastNote = note;
+ }
+endFunction:
+ _playerCtx.addedNote = true;
+ _playerCtx.lastVoice = voiceNum;
+ return voiceNum;
+}
+
+void MaxTrax::noteOff(ChannelContext &channel, const byte note) {
+ VoiceContext &voice = _voiceCtx[_playerCtx.lastVoice];
+ if (channel.voicesActive && voice.channel == &channel && voice.status != VoiceContext::kStatusRelease) {
+ const byte refNote = ((voice.flags & VoiceContext::kFlagPortamento) != 0) ? voice.endNote : voice.baseNote;
+ if (refNote == note) {
+ if ((channel.flags & ChannelContext::kFlagDamper) != 0)
+ voice.flags |= VoiceContext::kFlagDamper;
+ else
+ voice.status = VoiceContext::kStatusRelease;
+ }
+ }
+}
+
void MaxTrax::freeScores() {
if (_scores) {
for (int i = 0; i < _numScores; ++i)
@@ -82,7 +350,7 @@ bool MaxTrax::load(Common::SeekableReadStream &musicData, bool loadScores, bool
warning("Maxtrax: File is not a Maxtrax Module");
return false;
}
- _playerCtx.tempo = musicData.readUint16BE();
+ _playerCtx.tempoInitial = musicData.readUint16BE();
const uint16 flags = musicData.readUint16BE();
_playerCtx.filterOn = (flags & 1) != 0;
_playerCtx.handleVolume = (flags & 2) != 0;
@@ -99,8 +367,7 @@ bool MaxTrax::load(Common::SeekableReadStream &musicData, bool loadScores, bool
const uint16 scoresInFile = musicData.readUint16BE();
if (loadScores) {
- const uint16 scoremax = 128; // some variable which is set upon initialisation of player
- const uint16 tempScores = MIN(scoresInFile, scoremax);
+ const uint16 tempScores = MIN(scoresInFile, _playerCtx.maxScoreNum);
debug("#Scores: %d, loading # of scores: %d", scoresInFile, tempScores);
Score *curScore =_scores = new Score[tempScores];
@@ -142,10 +409,11 @@ bool MaxTrax::load(Common::SeekableReadStream &musicData, bool loadScores, bool
curPatch.tune = musicData.readUint16BE();
curPatch.volume = musicData.readUint16BE();
curPatch.sampleOctaves = musicData.readUint16BE();
- curPatch.sampleAttack = musicData.readUint32BE();
- curPatch.sampleSustain = musicData.readUint32BE();
+ 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.sampleAttack + curPatch.sampleSustain) * ((1 << curPatch.sampleOctaves) - 1);
+ const uint32 totalSamples = curPatch.sampleTotalLen * ((1 << curPatch.sampleOctaves) - 1);
curPatch.attackLen = musicData.readUint16BE();
curPatch.releaseLen = musicData.readUint16BE();
const uint32 totalEnvs = curPatch.attackLen + curPatch.releaseLen;
generated by cgit v1.2.3 (git 2.25.1) at 2024-10-21 11:30:27 +0000