mirror/dusklight
1
0
Fork 0
mirror of https://github.com/TwilitRealm/dusklight synced 2026-05-31 08:51:29 -04:00
Code Issues Packages Projects Releases Wiki Activity
Files
8b63858d9dfc381d23ccbb98937b7eb00d88b067
dusklight/libs/JSystem/src/JAudio2/JASSeqParser.cpp
T
PJB3005 8b63858d9d Oops
2026-03-15 18:41:48 +01:00

1028 lines
28 KiB
C++
Raw Blame History

#include "JSystem/JSystem.h" // IWYU pragma: keep
#include "JSystem/JAudio2/JASSeqParser.h"
#include "JSystem/JAudio2/JASCalc.h"
#include "JSystem/JAudio2/JASReport.h"
#include "JSystem/JAudio2/JASTrack.h"
#include "JSystem/JMath/random.h"
#include "JSystem/JSupport/JSupport.h"
#include "JSystem/JUtility/JUTAssert.h"
JASSeqParser::CmdInfo JASSeqParser::sCmdInfo[96] = {
NULL, 0x0000, 0x0000,
NULL, 0x0000, 0x0000,
NULL, 0x0000, 0x0000,
NULL, 0x0000, 0x0000,
NULL, 0x0000, 0x0000,
NULL, 0x0000, 0x0000,
NULL, 0x0000, 0x0000,
NULL, 0x0000, 0x0000,
NULL, 0x0000, 0x0000,
NULL, 0x0000, 0x0000,
NULL, 0x0000, 0x0000,
NULL, 0x0000, 0x0000,
NULL, 0x0000, 0x0000,
NULL, 0x0000, 0x0000,
NULL, 0x0000, 0x0000,
NULL, 0x0000, 0x0000,
NULL, 0x0000, 0x0000,
&JASSeqParser::cmdNoteOn, 0x0003, 0x0000,
&JASSeqParser::cmdNoteOff, 0x0001, 0x0000,
&JASSeqParser::cmdNote, 0x0004, 0x0040,
&JASSeqParser::cmdSetLastNote, 0x0001, 0x0000,
NULL, 0x0000, 0x0000,
NULL, 0x0000, 0x0000,
NULL, 0x0000, 0x0000,
&JASSeqParser::cmdParamE, 0x0002, 0x0000,
&JASSeqParser::cmdParamI, 0x0002, 0x0004,
&JASSeqParser::cmdParamEI, 0x0003, 0x0010,
&JASSeqParser::cmdParamII, 0x0003, 0x0014,
NULL, 0x0000, 0x0000,
NULL, 0x0000, 0x0000,
NULL, 0x0000, 0x0000,
NULL, 0x0000, 0x0000,
NULL, 0x0000, 0x0000,
&JASSeqParser::cmdOpenTrack, 0x0002, 0x0008,
&JASSeqParser::cmdCloseTrack, 0x0001, 0x0000,
&JASSeqParser::cmdCall, 0x0001, 0x0002,
&JASSeqParser::cmdCallF, 0x0002, 0x0008,
&JASSeqParser::cmdRet, 0x0000, 0x0000,
&JASSeqParser::cmdRetF, 0x0001, 0x0000,
&JASSeqParser::cmdJmp, 0x0001, 0x0002,
&JASSeqParser::cmdJmpF, 0x0002, 0x0008,
&JASSeqParser::cmdJmpTable, 0x0002, 0x000B,
&JASSeqParser::cmdCallTable, 0x0002, 0x000B,
&JASSeqParser::cmdLoopS, 0x0001, 0x0001,
&JASSeqParser::cmdLoopE, 0x0000, 0x0000,
NULL, 0x0000, 0x0000,
NULL, 0x0000, 0x0000,
NULL, 0x0000, 0x0000,
&JASSeqParser::cmdReadPort, 0x0002, 0x0000,
&JASSeqParser::cmdWritePort, 0x0002, 0x000C,
&JASSeqParser::cmdCheckPortImport, 0x0001, 0x0000,
&JASSeqParser::cmdCheckPortExport, 0x0001, 0x0000,
&JASSeqParser::cmdParentWritePort, 0x0002, 0x000C,
&JASSeqParser::cmdChildWritePort, 0x0002, 0x000C,
&JASSeqParser::cmdParentReadPort, 0x0002, 0x0000,
&JASSeqParser::cmdChildReadPort, 0x0002, 0x0000,
&JASSeqParser::cmdRegLoad, 0x0002, 0x0004,
&JASSeqParser::cmdReg, 0x0003, 0x0030,
&JASSeqParser::cmdReg, 0x0003, 0x0010,
&JASSeqParser::cmdRegUni, 0x0002, 0x0000,
&JASSeqParser::cmdRegTblLoad, 0x0004, 0x00E0,
NULL, 0x0000, 0x0000,
NULL, 0x0000, 0x0000,
NULL, 0x0000, 0x0000,
&JASSeqParser::cmdTempo, 0x0001, 0x0001,
&JASSeqParser::cmdBankPrg, 0x0001, 0x0001,
&JASSeqParser::cmdBank, 0x0001, 0x0000,
&JASSeqParser::cmdPrg, 0x0001, 0x0000,
NULL, 0x0000, 0x0000,
NULL, 0x0000, 0x0000,
NULL, 0x0000, 0x0000,
&JASSeqParser::cmdEnvScaleSet, 0x0002, 0x0004,
&JASSeqParser::cmdEnvSet, 0x0002, 0x0008,
&JASSeqParser::cmdSimpleADSR, 0x0005, 0x0155,
&JASSeqParser::cmdBusConnect, 0x0002, 0x0004,
&JASSeqParser::cmdIIRCutOff, 0x0001, 0x0000,
&JASSeqParser::cmdIIRSet, 0x0004, 0x0055,
&JASSeqParser::cmdFIRSet, 0x0001, 0x0002,
NULL, 0x0000, 0x0000,
NULL, 0x0000, 0x0000,
&JASSeqParser::cmdWait, 0x0000, 0x0000,
&JASSeqParser::cmdWaitByte, 0x0001, 0x0000,
NULL, 0x0000, 0x0000,
&JASSeqParser::cmdSetIntTable, 0x0001, 0x0002,
&JASSeqParser::cmdSetInterrupt, 0x0001, 0x0001,
&JASSeqParser::cmdDisInterrupt, 0x0001, 0x0001,
&JASSeqParser::cmdRetI, 0x0000, 0x0000,
&JASSeqParser::cmdClrI, 0x0000, 0x0000,
&JASSeqParser::cmdIntTimer, 0x0002, 0x0004,
&JASSeqParser::cmdSyncCPU, 0x0001, 0x0001,
NULL, 0x0000, 0x0000,
NULL, 0x0000, 0x0000,
NULL, 0x0000, 0x0000,
&JASSeqParser::cmdPrintf, 0x0000, 0x0000,
&JASSeqParser::cmdNop, 0x0000, 0x0000,
&JASSeqParser::cmdFinish, 0x0000, 0x0000,
};
JASSeqParser::CmdInfo JASSeqParser::sExtCmdInfo[255] = {
NULL, 0x0000, 0x0000,
&JASSeqParser::cmdDump, 0x0000, 0x0000,
NULL, 0x0000, 0x0000,
NULL, 0x0000, 0x0000,
NULL, 0x0000, 0x0000,
NULL, 0x0000, 0x0000,
NULL, 0x0000, 0x0000,
};
bool JASSeqParser::conditionCheck(JASTrack* param_0, JASSeqParser::BranchCondition param_1) {
u16 reg = readReg(param_0, 3);
switch (param_1) {
case 0:
return 1;
case 1:
return reg == 0;
case 2:
return reg != 0;
case 3:
return reg == 1;
case 4:
return 0x8000 <= reg;
case 5:
return 0x8000 > reg;
default:
JUT_WARN(463, "%s", "Unexpected condition flag");
return 0;
}
}
void JASSeqParser::writeReg(JASTrack* param_0, u32 param_1, u32 param_2) {
param_0->writeReg(JASRegisterParam::REG3, param_2);
if (param_1 < 0x40) {
param_0->writeReg(JASRegisterParam::RegID(param_1), param_2);
return;
}
switch (param_1) {
case 0x40:
case 0x41:
case 0x42:
case 0x43:
case 0x44:
case 0x45:
case 0x46:
case 0x47:
case 0x48:
case 0x49:
case 0x4a:
case 0x4b:
case 0x4c:
case 0x4d:
case 0x4e:
case 0x4f:
param_0->setPort(param_1 - 0x40, param_2);
break;
case 0x60:
case 0x61:
JUT_WARN(502, "%s", "writeReg for Read-Only Register");
break;
case 0x62:
param_0->setTimebase(param_2);
break;
case 0x63:
param_0->setTranspose(param_2);
break;
case 0x64:
param_0->setBendSense(param_2);
break;
case 0x65:
param_0->setGateRate(param_2);
break;
case 0x66:
param_0->setSkipSample(param_2);
break;
case 0x67:
param_0->setBankNumber(u8(param_2));
break;
case 0x68:
param_0->setProgNumber(u8(param_2));
break;
case 0x69:
param_0->setPanPower(param_2 / 32767.0f);
break;
case 0x6a:
param_0->setReleasePrio(JSUHiByte(param_2));
param_0->setNoteOnPrio(JSULoByte(param_2));
break;
case 0x6b:
param_0->setNoteOnPrio(param_2);
break;
case 0x6c:
param_0->setReleasePrio(param_2);
break;
case 0x6d:
param_0->setDirectRelease(param_2);
break;
case 0x6e:
param_0->setVibDepth(param_2 / 1524.0f);
break;
case 0x6f:
param_0->setVibDepth(param_2 / 12192.0f);
break;
case 0x70:
param_0->setTremDepth(param_2 / 256.0f);
break;
case 0x71:
param_0->setVibPitch(param_2 / 64.0f);
break;
case 0x72:
param_0->setTremPitch(param_2 / 64.0f);
break;
case 0x73:
param_0->setVibDelay(param_2);
break;
case 0x74:
param_0->setTremDelay(param_2);
break;
default:
break;
}
}
u32 JASSeqParser::readReg(JASTrack* param_0, u32 param_1) const {
if (param_1 < 0x40) {
return param_0->readReg(JASRegisterParam::RegID(param_1));
}
u32 result = 0;
u16 r27;
switch (param_1) {
case 0x40:
case 0x41:
case 0x42:
case 0x43:
case 0x44:
case 0x45:
case 0x46:
case 0x47:
case 0x48:
case 0x49:
case 0x4a:
case 0x4b:
case 0x4c:
case 0x4d:
case 0x4e:
case 0x4f:
result = param_0->getPort(param_1 - 0x40);
break;
case 0x60:
r27 = 1;
for (u32 i = 0; i < 16; i++, r27 <<= 1) {
JASTrack* child = param_0->getChild(i);
if (child && child->getStatus() == 1) {
result |= r27;
}
}
break;
case 0x61:
result = param_0->getSeqCtrl()->getSeqReader()->getLoopCount();
break;
case 0x62:
result = param_0->getTimebase();
break;
case 0x63:
result = param_0->getTranspose();
break;
case 0x64:
result = param_0->getBendSense();
break;
case 0x65:
result = param_0->getGateRate();
break;
case 0x66:
result = param_0->getSkipSample();
break;
case 0x67:
result = param_0->getBankNumber();
break;
case 0x68:
result = param_0->getProgNumber();
break;
case 0x69:
result = param_0->getPanPower() * 32767.0f;
break;
case 0x6a:
result = param_0->getReleasePrio();
// @bug this should have been <<=
result << 8;
result |= param_0->getNoteOnPrio();
break;
case 0x6b:
result = param_0->getNoteOnPrio();
break;
case 0x6c:
result = param_0->getReleasePrio();
break;
case 0x6d:
result = param_0->getDirectRelease();
break;
case 0x6e:
result = param_0->getVibDepth() * 1524.0f;
break;
case 0x6f:
result = param_0->getVibDepth() * 12192.0f;
break;
case 0x70:
result = param_0->getTremDepth() * 256.0f;
break;
case 0x71:
result = param_0->getVibPitch() * 64.0f;
break;
case 0x72:
result = param_0->getTremPitch() * 64.0f;
break;
case 0x73:
result = param_0->getVibDelay();
break;
case 0x74:
result = param_0->getTremDelay();
break;
default:
break;
}
return result;
}
s32 JASSeqParser::cmdOpenTrack(JASTrack* param_0, u32* param_1) {
u32 r29 = param_1[0];
u32 r28 = param_1[1];
JASTrack* child = param_0->openChild(r29);
if (!child) {
JUT_WARN(679, "%s", "Cannot open child track");
return 0;
}
child->setSeqData(param_0->getSeqCtrl()->getBase(), r28);
child->start();
return 0;
}
s32 JASSeqParser::cmdCloseTrack(JASTrack* param_0, u32* param_1) {
param_0->closeChild(*param_1);
return 0;
}
s32 JASSeqParser::cmdCall(JASTrack* param_0, u32* param_1) {
param_0->getSeqCtrl()->call(*param_1);
return 0;
}
s32 JASSeqParser::cmdCallF(JASTrack* param_0, u32* param_1) {
if (conditionCheck(param_0, BranchCondition(param_1[0]))) {
param_0->getSeqCtrl()->call(param_1[1]);
}
return 0;
}
s32 JASSeqParser::cmdRet(JASTrack* param_0, u32* param_1) {
if (!param_0->getSeqCtrl()->ret()) {
JUT_WARN(718, "%s", "cannot ret for call-stack is NULL");
return 0;
}
return 0;
}
s32 JASSeqParser::cmdRetF(JASTrack* param_0, u32* param_1) {
if (conditionCheck(param_0, BranchCondition(param_1[0]))) {
if (!param_0->getSeqCtrl()->ret()) {
JUT_WARN(729, "%s", "cannot ret for call-stack is NULL");
return 0;
}
}
return 0;
}
s32 JASSeqParser::cmdJmp(JASTrack* param_0, u32* param_1) {
param_0->getSeqCtrl()->jump(param_1[0]);
return 0;
}
s32 JASSeqParser::cmdJmpF(JASTrack* param_0, u32* param_1) {
if (conditionCheck(param_0, BranchCondition(param_1[0]))) {
param_0->getSeqCtrl()->jump(param_1[1]);
}
return 0;
}
s32 JASSeqParser::cmdJmpTable(JASTrack* param_0, u32* param_1) {
JASSeqCtrl* seqCtrl = param_0->getSeqCtrl();
u32 uVar1 = param_1[0];
uVar1 += uVar1 * 2;
seqCtrl->jump(seqCtrl->get24(param_1[1] + uVar1));
return 0;
}
s32 JASSeqParser::cmdCallTable(JASTrack* param_0, u32* param_1) {
JASSeqCtrl* seqCtrl = param_0->getSeqCtrl();
u32 uVar1 = param_1[0];
uVar1 += uVar1 * 2;
seqCtrl->call(seqCtrl->get24(param_1[1] + uVar1));
return 0;
}
s32 JASSeqParser::cmdLoopS(JASTrack* param_0, u32* param_1) {
param_0->getSeqCtrl()->loopStart(param_1[0]);
return 0;
}
s32 JASSeqParser::cmdLoopE(JASTrack* param_0, u32* param_1) {
param_0->getSeqCtrl()->loopEnd();
return 0;
}
s32 JASSeqParser::cmdNote(JASTrack* param_0, u32* param_1) {
execNoteOnGate(param_0, param_1[1], param_1[2], param_1[3], param_1[0]);
return 0;
}
s32 JASSeqParser::cmdNoteOn(JASTrack* param_0, u32* param_1) {
execNoteOnMidi(param_0, param_1[1], param_1[0], param_1[2]);
return 0;
}
s32 JASSeqParser::cmdNoteOff(JASTrack* param_0, u32* param_1) {
execNoteOff(param_0, param_1[0]);
return 0;
}
s32 JASSeqParser::cmdReadPort(JASTrack* param_0, u32* param_1) {
u16 tmp = param_0->readPortSelf(param_1[0]);
writeReg(param_0, param_1[1], tmp);
return 0;
}
s32 JASSeqParser::cmdWritePort(JASTrack* param_0, u32* param_1) {
param_0->writePortSelf(param_1[0], param_1[1]);
return 0;
}
s32 JASSeqParser::cmdParentWritePort(JASTrack* param_0, u32* param_1) {
{
u32* p1 = param_1;
u32* p2 = param_1 + 1;
JASTrack* parent = param_0->getParent();
if (parent) {
parent->writePort(*p1, *p2);
} else {
JUT_WARN(835, "%s", "parent == NULL");
}
}
return 0;
}
s32 JASSeqParser::cmdChildWritePort(JASTrack* param_0, u32* param_1) {
{
u8 val = param_1[0];
JASTrack* child = param_0->getChild(JSUHiNibble(val));
if (child) {
child->writePort(JSULoNibble(val), param_1[1]);
} else {
JUT_WARN(848, "%s", "child == NULL");
}
}
return 0;
}
s32 JASSeqParser::cmdParentReadPort(JASTrack* param_0, u32* param_1) {
u32* p1 = param_1;
u32* p2 = param_1 + 1;
JASTrack* parent = param_0->getParent();
if (parent) {
u16 tmp = parent->readPort(*p1);
writeReg(param_0, *p2, tmp);
} else {
JUT_WARN(864, "%s", "parent == NULL");
}
return 0;
}
s32 JASSeqParser::cmdChildReadPort(JASTrack* param_0, u32* param_1) {
u8 val = param_1[0];
u32* p2 = param_1 + 1;
JASTrack* child = param_0->getChild(JSUHiNibble(val));
if (child) {
u16 tmp = child->readPort(JSULoNibble(val));
writeReg(param_0, *p2, tmp);
} else {
JUT_WARN(880, "%s", "child == NULL");
}
return 0;
}
s32 JASSeqParser::cmdCheckPortImport(JASTrack* param_0, u32* param_1) {
u8 tmp = param_0->checkPortIn(param_1[0]);
param_0->writeReg(JASRegisterParam::REG3, tmp);
return 0;
}
s32 JASSeqParser::cmdCheckPortExport(JASTrack* param_0, u32* param_1) {
u8 tmp = param_0->checkPort(param_1[0]);
param_0->writeReg(JASRegisterParam::REG3, tmp);
return 0;
}
s32 JASSeqParser::cmdWait(JASTrack* param_0, u32* param_1) {
JASSeqCtrl* seqCtrl = param_0->getSeqCtrl();
int midiValue = seqCtrl->readMidiValue();
seqCtrl->wait(midiValue);
return 0;
}
s32 JASSeqParser::cmdWaitByte(JASTrack* param_0, u32* param_1) {
u32 val = param_1[0];
param_0->getSeqCtrl()->wait(val);
return 0;
}
s32 JASSeqParser::cmdSetLastNote(JASTrack* param_0, u32* param_1) {
u32 r31 = param_1[0];
if (r31 < 256) {
param_0->setLatestKey(r31);
} else {
JUT_WARN(928, "%s", "Too large latest key");
}
return 0;
}
s32 JASSeqParser::cmdEnvScaleSet(JASTrack* param_0, u32* param_1) {
param_0->setOscScale(param_1[0], param_1[1] / 16383.0f);
return 0;
}
s32 JASSeqParser::cmdEnvSet(JASTrack* param_0, u32* param_1) {
param_0->setOscTable(param_1[0], (JASOscillator::Point*)param_0->getSeqCtrl()->getAddr(param_1[1]));
return 0;
}
s32 JASSeqParser::cmdSimpleADSR(JASTrack* param_0, u32* param_1) {
param_0->setOscAdsr(param_1[0], param_1[1], param_1[2], param_1[3], param_1[4]);
return 0;
}
s32 JASSeqParser::cmdBusConnect(JASTrack* param_0, u32* param_1) {
param_0->connectBus(param_1[0], param_1[1]);
return 0;
}
s32 JASSeqParser::cmdSetIntTable(JASTrack* param_0, u32* param_1) {
param_0->getSeqCtrl()->setIntrTable(param_1[0]);
return 0;
}
s32 JASSeqParser::cmdSetInterrupt(JASTrack* param_0, u32* param_1) {
param_0->getSeqCtrl()->setIntrMask(param_1[0]);
return 0;
}
s32 JASSeqParser::cmdDisInterrupt(JASTrack* param_0, u32* param_1) {
param_0->getSeqCtrl()->clrIntrMask(param_1[0]);
return 0;
}
s32 JASSeqParser::cmdClrI(JASTrack* param_0, u32* param_1) {
JASSeqCtrl* seqCtrl = param_0->getSeqCtrl();
seqCtrl->clrIntr();
seqCtrl->checkIntr();
return 0;
}
s32 JASSeqParser::cmdRetI(JASTrack* param_0, u32* param_1) {
JASSeqCtrl* seqCtrl = param_0->getSeqCtrl();
seqCtrl->retIntr();
seqCtrl->checkIntr();
return 0;
}
s32 JASSeqParser::cmdIntTimer(JASTrack* param_0, u32* param_1) {
param_0->getSeqCtrl()->setIntrTimer(param_1[0], param_1[1]);
return 0;
}
u16 (*JASSeqParser::sCallBackFunc)(JASTrack*, u16);
s32 JASSeqParser::cmdSyncCPU(JASTrack* param_0, u32* param_1) {
u16 r31 = 0xffff;
if (sCallBackFunc) {
r31 = sCallBackFunc(param_0, param_1[0]);
}
param_0->writeReg(JASRegisterParam::REG3, r31);
return 0;
}
s32 JASSeqParser::cmdTempo(JASTrack* param_0, u32* param_1) {
param_0->setTempo(param_1[0]);
return 0;
}
s32 JASSeqParser::cmdFinish(JASTrack* param_0, u32* param_1) {
return -1;
}
s32 JASSeqParser::cmdNop(JASTrack* param_0, u32* param_1) {
return 0;
}
s32 JASSeqParser::cmdFIRSet(JASTrack* param_0, u32* param_1) {
s16* addr = (s16*)param_0->getSeqCtrl()->getAddr(param_1[0]);
param_0->setFIR(addr);
return 0;
}
s32 JASSeqParser::cmdIIRSet(JASTrack* param_0, u32* param_1) {
s16 stack_10[4];
for (int i = 0; i < 4; i++) {
stack_10[i] = param_1[i];
}
param_0->setIIR(stack_10);
return 0;
}
s32 JASSeqParser::cmdIIRCutOff(JASTrack* param_0, u32* param_1) {
u32 r31 = param_1[0];
if (r31 < 128) {
param_0->setIIR(JASCalc::CUTOFF_TO_IIR_TABLE[r31]);
} else {
JUT_WARN(1077, "%s", "Too large cutoff");
}
return 0;
}
s32 JASSeqParser::cmdBankPrg(JASTrack* param_0, u32* param_1) {
u16 r31 = JSULoHalf(param_1[0]);
param_0->setBankNumber(JSUHiByte(r31));
param_0->setProgNumber(JSULoByte(r31));
return 0;
}
s32 JASSeqParser::cmdBank(JASTrack* param_0, u32* param_1) {
param_0->setBankNumber(param_1[0] & 0xff);
return 0;
}
s32 JASSeqParser::cmdPrg(JASTrack* param_0, u32* param_1) {
param_0->setProgNumber(param_1[0] & 0xff);
return 0;
}
s32 JASSeqParser::cmdParamI(JASTrack* param_0, u32* param_1) {
s16 val = param_1[1];
param_0->setParam(param_1[0], val / 32767.0f, 0);
return 0;
}
s32 JASSeqParser::cmdParamII(JASTrack* param_0, u32* param_1) {
s16 val = param_1[1];
param_0->setParam(param_1[0], val / 32767.0f, param_1[2]);
return 0;
}
s32 JASSeqParser::cmdParamE(JASTrack* param_0, u32* param_1) {
s32* r31 = (s32*)param_1 + 1;
s16 r30 = *r31 << 8;
if ((*r31 & 0x80) == 0) {
r30 |= s16(*r31 << 1);
}
param_0->setParam(param_1[0], r30 / 32767.0f, 0);
return 0;
}
s32 JASSeqParser::cmdParamEI(JASTrack* param_0, u32* param_1) {
s32* r31 = (s32*)param_1 + 1;
s16 r30 = *r31 << 8;
if ((*r31 & 0x80) == 0) {
r30 |= s16(*r31 << 1);
}
param_0->setParam(param_1[0], r30 / 32767.0f, param_1[2]);
return 0;
}
s32 JASSeqParser::cmdReg(JASTrack* param_0, u32* param_1) {
u32 val = param_1[0];
u32 r29 = param_1[1];
u32 r30 = param_1[2];
u32 tmp;
switch (val) {
case 0:
break;
case 1:
r30 += readReg(param_0, r29);
break;
case 2:
r30 = readReg(param_0, r29) - r30;
break;
case 3:
r30 = readReg(param_0, r29) - r30;
r29 = 3;
break;
case 4:
r30 *= readReg(param_0, r29);
r29 = 0x21;
break;
case 5:
r30 &= readReg(param_0, r29);
break;
case 6:
r30 |= readReg(param_0, r29);
break;
case 7:
r30 ^= readReg(param_0, r29);
break;
case 8: {
static JMath::TRandom_<JMath::TRandom_fast_> oRandom(0);
r30 = (oRandom.get_bit32() >> 9) % r30;
} break;
case 9:
r30 = readReg(param_0, r29) << r30;
break;
case 10:
r30 = readReg(param_0, r29) >> r30;
break;
default:
JUT_WARN(1191, "%s", "cmdReg Not Supported RegCmdType");
return 0;
}
writeReg(param_0, r29, r30);
return 0;
}
s32 JASSeqParser::cmdRegLoad(JASTrack* param_0, u32* param_1) {
u32 val1 = param_1[0];
u32 val2 = param_1[1];
writeReg(param_0, val1, val2);
return 0;
}
s32 JASSeqParser::cmdRegUni(JASTrack* param_0, u32* param_1) {
u32 val1 = param_1[0];
u32 r31 = param_1[1];
s32 r30 = 0;
switch (val1) {
case 11:
r30 = -readReg(param_0, r31);
break;
default:
JUT_WARN(1217, "%s", "cmdRegUni Not Supported RegCmdType");
return 0;
}
writeReg(param_0, r31, r30);
return 0;
}
s32 JASSeqParser::cmdRegTblLoad(JASTrack* param_0, u32* param_1) {
JASSeqCtrl* seqCtrl = param_0->getSeqCtrl();
u32 p0 = param_1[0];
u32 p1 = param_1[1];
u32 p2 = param_1[2];
u32 p3 = param_1[3];
u32 r27;
switch (p0) {
case 12:
r27 = seqCtrl->getByte(p2 + p3);
break;
case 13:
p3 *= 2;
r27 = seqCtrl->get16(p2 + p3);
break;
case 14:
p3 += p3 * 2;
r27 = seqCtrl->get24(p2 + p3);
break;
case 15:
p3 *= 4;
r27 = seqCtrl->get32(p2 + p3);
break;
case 16:
r27 = seqCtrl->get32(p2 + p3);
break;
default:
JUT_WARN(1255, "%s", "cmdRegTblLoad Not Supported RegCmdType");
return 0;
}
writeReg(param_0, p1, r27);
return 0;
}
s32 JASSeqParser::cmdDump(JASTrack* param_0, u32* param_1) {
JASSeqCtrl* seqCtrl = param_0->getSeqCtrl();
JASReport("--------------- JASTrack (%8x) dump ----------------", param_0);
JASReport(" Base: 0x%08x Cur: 0x%08x(0x%06x)", seqCtrl->getBase(), seqCtrl->getCur(), (u8*)seqCtrl->getCur() - (u8*)seqCtrl->getBase());
JASReport("");
JASReport(" REG_A: 0x%04x REG_B: 0x%04x REG_S: 0x%04x", readReg(param_0, 0), readReg(param_0, 1), readReg(param_0, 2));
JASReport(" REG_X: 0x%04x REG_Y: 0x%04x REG_F: 0x%04x", readReg(param_0, 4), readReg(param_0, 5), readReg(param_0, 3));
JASReport("");
JASReport(" PORT 0-3: 0x%04x 0x%04x 0x%04x 0x%04x", param_0->getPort(0x0), param_0->getPort(0x1), param_0->getPort(0x2), param_0->getPort(0x3));
JASReport(" PORT 4-7: 0x%04x 0x%04x 0x%04x 0x%04x", param_0->getPort(0x4), param_0->getPort(0x5), param_0->getPort(0x6), param_0->getPort(0x7));
JASReport(" PORT 8-B: 0x%04x 0x%04x 0x%04x 0x%04x", param_0->getPort(0x8), param_0->getPort(0x9), param_0->getPort(0xa), param_0->getPort(0xb));
JASReport(" PORT C-F: 0x%04x 0x%04x 0x%04x 0x%04x", param_0->getPort(0xc), param_0->getPort(0xd), param_0->getPort(0xe), param_0->getPort(0xf));
JASReport("");
return 0;
}
s32 JASSeqParser::cmdPrintf(JASTrack* param_0, u32* param_1) {
u8 stack_c[4];
u32 stack_10[4];
char buffer[128];
JASSeqCtrl* seqCtrl = param_0->getSeqCtrl();
u32 r30 = 0;
u32 i = 0;
for (; i < 128; i++) {
buffer[i] = seqCtrl->readByte();
if (buffer[i] == 0) {
break;
}
if (buffer[i] == '\\') {
buffer[i] = seqCtrl->readByte();
if (buffer[i] == 0) {
break;
}
switch (buffer[i]) {
case 'n':
buffer[i] = '\r';
break;
}
} else if (buffer[i] == '%') {
i++;
buffer[i] = seqCtrl->readByte();
if (buffer[i] == 0) {
break;
}
switch (buffer[i]) {
case 'd':
stack_c[r30] = 0;
break;
case 'x':
stack_c[r30] = 1;
break;
case 's':
stack_c[r30] = 2;
break;
case 'r':
stack_c[r30] = 3;
buffer[i] = 'd';
break;
case 'R':
stack_c[r30] = 4;
buffer[i] = 'x';
break;
}
r30++;
}
}
for (i = 0; i < r30; i++) {
stack_10[i] = (u8)seqCtrl->readByte();
switch (stack_c[i]) {
case 2:
stack_10[i] = (uintptr_t)seqCtrl->getAddr(stack_10[i]);
break;
case 3:
case 4:
stack_10[i] = readReg(param_0, stack_10[i] & 0xff);
break;
}
}
JASReport(buffer, stack_10[0], stack_10[1], stack_10[2], stack_10[3]);
return 0;
}
s32 JASSeqParser::execNoteOnGate(JASTrack* param_0, u32 param_1, u32 param_2, u32 param_3,
u32 param_4) {
JASSeqCtrl* seqCtrl = param_0->getSeqCtrl();
// likely fake match, this may use some actual union defined somewhere else
union {
u8 val;
struct {
u8 bit0 : 1;
u8 bit1 : 1;
} bits;
} tmp;
tmp.val = param_4;
int r31 = 0;
if (tmp.bits.bit1) {
r31 |= 2;
}
if (tmp.bits.bit0) {
r31 |= 1;
}
if (param_3 == 0) {
r31 |= 4;
}
int result = param_0->gateOn(param_1, param_2, param_3, r31);
if (param_3) {
seqCtrl->wait(param_3);
} else {
seqCtrl->waitNoteFinish();
}
return result;
}
s32 JASSeqParser::execNoteOnMidi(JASTrack* param_0, u32 param_1, u32 param_2, u32 param_3) {
return param_0->noteOn(param_1, param_2, param_3);
}
s32 JASSeqParser::execNoteOff(JASTrack* param_0, u32 param_1) {
return param_0->noteOff(param_1, 0);
}
s32 JASSeqParser::execCommand(JASTrack* param_0, s32 (JASSeqParser::*param_1)(JASTrack*, u32*),
u32 param_2, u32* param_3) {
return (this->*param_1)(param_0, param_3);
}
s32 JASSeqParser::parseNoteOff(JASTrack* param_0, u8 param_1) {
u8 note_id = param_1 & 7;
if (note_id) {
execNoteOff(param_0, note_id);
} else {
JUT_WARN(1433, "%s", "noteoff for note_id == 0");
}
return 0;
}
s32 JASSeqParser::parseNoteOn(JASTrack* param_0, u8 param_1) {
JASSeqCtrl* seqCtrl = param_0->getSeqCtrl();
u32 r28 = seqCtrl->readByte();
u32 r30 = r28;
r30 &= 7;
u32 r27 = seqCtrl->readByte();
if ((u8)r30 == 0) {
u32 midiVal = seqCtrl->readMidiValue();
execNoteOnGate(param_0, (u8)param_1, (u8)r27, midiVal, (u8)r28);
} else {
execNoteOnMidi(param_0, (u8)r30, (u8)param_1, (u8)r27);
}
return 0;
}
s32 JASSeqParser::parseCommand(JASTrack* param_0, u8 cmd, u16 parameterTypesOverride) {
JASSeqCtrl* seqCtrl = param_0->getSeqCtrl();
CmdInfo* cmdInfo = NULL;
if (cmd != 0xb0) {
JUT_ASSERT(1477, cmd >= 0xa0);
cmdInfo = &sCmdInfo[cmd - 0xa0];
} else {
cmdInfo = &sExtCmdInfo[seqCtrl->readByte() & 0xff];
}
u16 parameterTypes = (u16)cmdInfo->mParameterTypes;
parameterTypes |= parameterTypesOverride;
u32 args[8];
for (int i = 0; i < cmdInfo->mParameterCount; i++, parameterTypes >>= 2) {
int value = 0;
switch (parameterTypes & 3) {
case 0:
value = (u8)seqCtrl->readByte();
break;
case 1:
value = (u16)seqCtrl->read16();
break;
case 2:
value = seqCtrl->read24();
break;
case 3:
value = readReg(param_0, (u8)seqCtrl->readByte());
break;
}
args[i] = value;
}
s32 (JASSeqParser::*ptr)(JASTrack*, u32*) = cmdInfo->mHandler;
if (!ptr) {
return 0;
}
return execCommand(param_0, ptr, cmdInfo->mParameterCount, args);
}
s32 JASSeqParser::parseRegCommand(JASTrack* param_0, int param_1) {
JASSeqCtrl* seqCtrl = param_0->getSeqCtrl();
u8 r30 = seqCtrl->readByte();
u16 r29 = 0;
u16 r28 = 3;
for (int i = 0; i < param_1; i++) {
if (r30 & 0x80) {
r29 |= r28;
}
r30 <<= 1;
r28 <<= 2;
}
u8 r25 = seqCtrl->readByte();
return parseCommand(param_0, r25, r29);
}
s32 JASSeqParser::parse(JASTrack* param_0) {
JASSeqCtrl* ctrl = param_0->getSeqCtrl();
u32 base = ctrl->mReader.mCurPos - ctrl->mReader.mBase;
u32 r31 = ctrl->readByte();
s32 r30 = 0;
if ((r31 & 0x80) == 0) {
r30 = parseNoteOn(param_0, r31);
} else {
switch (r31 & 0xf0) {
case 0x80:
r30 = parseNoteOff(param_0, r31 & 0xf);
break;
case 0x90:
r30 = parseRegCommand(param_0, (r31 & 7) + 1);
break;
default:
r30 = parseCommand(param_0, r31, 0);
break;
}
}
return r30;
}
Reference in New Issue View Git Blame Copy Permalink