From 168fdcc05e210c6a70e3e9a066f78a5865d8cd32 Mon Sep 17 00:00:00 2001 From: Jcw87 Date: Fri, 3 Nov 2023 15:36:27 -0700 Subject: [PATCH] JASTrack, JASNoteMgr, JASOuterParam, JASSeqParser --- configure.py | 4 +- include/JSystem/JAudio/JASChannel.h | 2 +- include/JSystem/JAudio/JASSeqCtrl.h | 2 +- include/JSystem/JAudio/JASSeqParser.h | 75 ++++ include/JSystem/JAudio/JASTrack.h | 211 ++++++++++ src/JSystem/JAudio/JASChannel.cpp | 2 +- src/JSystem/JAudio/JASNoteMgr.cpp | 54 ++- src/JSystem/JAudio/JASOuterParam.cpp | 80 +++- src/JSystem/JAudio/JASSeqCtrl.cpp | 4 +- src/JSystem/JAudio/JASSeqParser.cpp | 370 +++++++++++++----- src/JSystem/JAudio/JASTrack.cpp | 534 ++++++++++++++++++++++---- 11 files changed, 1138 insertions(+), 200 deletions(-) create mode 100644 include/JSystem/JAudio/JASSeqParser.h create mode 100644 include/JSystem/JAudio/JASTrack.h diff --git a/configure.py b/configure.py index e7f98f017..c970eaadb 100644 --- a/configure.py +++ b/configure.py @@ -662,8 +662,8 @@ config.libs = [ Object(Matching, "JSystem/JAudio/JASKernelDebug.cpp"), Object(Matching, "JSystem/JAudio/JASCmdStack.cpp"), Object(Matching, "JSystem/JAudio/JASSystemHeap.cpp"), - Object(NonMatching, "JSystem/JAudio/JASNoteMgr.cpp"), - Object(NonMatching, "JSystem/JAudio/JASOuterParam.cpp"), + Object(Matching, "JSystem/JAudio/JASNoteMgr.cpp"), + Object(Matching, "JSystem/JAudio/JASOuterParam.cpp"), Object(Matching, "JSystem/JAudio/JASPlayer_impl.cpp"), Object(Matching, "JSystem/JAudio/JASRegisterParam.cpp"), Object(NonMatching, "JSystem/JAudio/JASSeqCtrl.cpp"), diff --git a/include/JSystem/JAudio/JASChannel.h b/include/JSystem/JAudio/JASChannel.h index 3f9363658..c5025e716 100644 --- a/include/JSystem/JAudio/JASChannel.h +++ b/include/JSystem/JAudio/JASChannel.h @@ -29,7 +29,7 @@ namespace JASystem { f32 bankOscToOfs(u32); void effectOsc(u32, f32); int getOscState(u32) const; - bool isOsc(u32); + BOOL isOsc(u32); void copyOsc(u32, TOscillator::Osc_*); void overwriteOsc(u32, TOscillator::Osc_*); void setKeySweepTarget(u8, u32); diff --git a/include/JSystem/JAudio/JASSeqCtrl.h b/include/JSystem/JAudio/JASSeqCtrl.h index df3fda2d2..15a49b1d7 100644 --- a/include/JSystem/JAudio/JASSeqCtrl.h +++ b/include/JSystem/JAudio/JASSeqCtrl.h @@ -14,7 +14,7 @@ namespace JASystem { bool waitCountDown(); bool callIntr(void*); bool retIntr(); - u32 get16(u32) const; + u16 get16(u32) const; u32 get24(u32) const; u32 get32(u32) const; u32 read16(); diff --git a/include/JSystem/JAudio/JASSeqParser.h b/include/JSystem/JAudio/JASSeqParser.h new file mode 100644 index 000000000..8f8aeb2fa --- /dev/null +++ b/include/JSystem/JAudio/JASSeqParser.h @@ -0,0 +1,75 @@ +#ifndef JASSEQPARSER_H +#define JASSEQPARSER_H + +#include "dolphin/types.h" + +namespace JASystem { + class TTrack; + class TSeqParser { + public: + int cmdOpenTrack(TTrack*, u32*); + int cmdOpenTrackBros(TTrack*, u32*); + int cmdCall(TTrack*, u32*); + int cmdRet(TTrack*, u32*); + int cmdJmp(TTrack*, u32*); + int cmdLoopS(TTrack*, u32*); + int cmdLoopE(TTrack*, u32*); + int cmdReadPort(TTrack*, u32*); + int cmdWritePort(TTrack*, u32*); + int cmdParentWritePort(TTrack*, u32*); + int cmdChildWritePort(TTrack*, u32*); + int cmdCheckPortImport(TTrack*, u32*); + int cmdCheckPortExport(TTrack*, u32*); + int cmdWait(TTrack*, u32*); + int cmdSetLastNote(TTrack*, u32*); + int cmdTimeRelate(TTrack*, u32*); + int cmdSimpleOsc(TTrack*, u32*); + int cmdSimpleEnv(TTrack*, u32*); + int cmdSimpleADSR(TTrack*, u32*); + int cmdTranspose(TTrack*, u32*); + int cmdCloseTrack(TTrack*, u32*); + int cmdOutSwitch(TTrack*, u32*); + int cmdUpdateSync(TTrack*, u32*); + int cmdBusConnect(TTrack*, u32*); + int cmdPauseStatus(TTrack*, u32*); + int cmdVolumeMode(TTrack*, u32*); + int cmdSetInterrupt(TTrack*, u32*); + int cmdDisInterrupt(TTrack*, u32*); + int cmdClrI(TTrack*, u32*); + int cmdSetI(TTrack*, u32*); + int cmdRetI(TTrack*, u32*); + int cmdIntTimer(TTrack*, u32*); + int cmdSyncCPU(TTrack*, u32*); + int cmdFlushAll(TTrack*, u32*); + int cmdFlushRelease(TTrack*, u32*); + int cmdTimeBase(TTrack*, u32*); + int cmdTempo(TTrack*, u32*); + int cmdFinish(TTrack*, u32*); + int cmdNop(TTrack*, u32*); + int cmdPanPowSet(TTrack*, u32*); + int cmdFIRSet(TTrack*, u32*); + int cmdEXTSet(TTrack*, u32*); + int cmdPanSwSet(TTrack*, u32*); + int cmdOscRoute(TTrack*, u32*); + int cmdVibDepth(TTrack*, u32*); + int cmdVibDepthMidi(TTrack*, u32*); + int cmdVibPitch(TTrack*, u32*); + int cmdIIRSet(TTrack*, u32*); + int cmdIIRCutOff(TTrack*, u32*); + int cmdOscFull(TTrack*, u32*); + int cmdCheckWave(TTrack*, u32*); + int cmdPrintf(TTrack*, u32*); + void Cmd_Process(TTrack*, u8, u16); + void RegCmd_Process(TTrack*, int, int); + int cmdSetParam(TTrack*, u8); + int cmdWait(TTrack*, u8); + int cmdNoteOff(TTrack*, u8); + int cmdNoteOn(TTrack*, u8); + bool conditionCheck(TTrack*, u8); + void parseSeq(TTrack*); + + static int (TSeqParser::*sCmdPList[])(TTrack*, u32*); + }; +} + +#endif /* JASSEQPARSER_H */ diff --git a/include/JSystem/JAudio/JASTrack.h b/include/JSystem/JAudio/JASTrack.h new file mode 100644 index 000000000..b4fda2884 --- /dev/null +++ b/include/JSystem/JAudio/JASTrack.h @@ -0,0 +1,211 @@ +#ifndef JASTRACK_H +#define JASTRACK_H + +#include "JSystem/JAudio/JASChannelMgr.h" +#include "JSystem/JAudio/JASOscillator.h" +#include "JSystem/JAudio/JASRegisterParam.h" +#include "JSystem/JAudio/JASSeqCtrl.h" +#include "JSystem/JAudio/JASSeqParser.h" +#include "JSystem/JAudio/JASTrackInterrupt.h" +#include "JSystem/JAudio/JASTrackPort.h" +#include "JSystem/JUtility/JUTAssert.h" + +namespace JASystem { + class TChannel; + + class TVibrate { + public: + TVibrate(); + void init(); + void incCounter(); + f32 getValue() const; + + /* 0x00 */ f32 field_0x0; + /* 0x04 */ f32 field_0x4; + /* 0x08 */ f32 field_0x8; + }; + + class TTrack { + public: + class TOuterParam { + public: + TOuterParam(); + void initExtBuffer(); + void setOuterSwitch(u16); + bool checkOuterSwitch(u16); + void setOuterUpdate(u16); + u16 getOuterUpdate(); + s16 getIntFirFilter(u8); + void setParam(u8, f32); + void onSwitch(u16); + void setFirFilter(s16*); + + /* 0x00 */ u16 field_0x0; + /* 0x02 */ u16 field_0x2; + /* 0x04 */ f32 field_0x4; + /* 0x08 */ f32 field_0x8; + /* 0x0C */ f32 field_0xc; + /* 0x10 */ f32 field_0x10; + /* 0x14 */ f32 field_0x14; + /* 0x18 */ f32 field_0x18; + /* 0x1C */ s16 field_0x1c[8]; + }; + + class MoveParam_ { + public: + MoveParam_(); + + /* 0x00 */ f32 field_0x0; + /* 0x04 */ f32 field_0x4; + /* 0x08 */ f32 field_0x8; + /* 0x0C */ f32 field_0xc; + }; + + class AInnerParam_ { + public: + AInnerParam_(); + + /* 0x000 */ f32 field_0x0[48]; + /* 0x0C0 */ MoveParam_ field_0xc0[4]; + /* 0x100 */ f32 field_0x100[8]; + }; + + class TimedParam_ { + public: + TimedParam_(); + + union { + AInnerParam_ inner; + MoveParam_ move[18]; + }; + }; + + class TNoteMgr { + public: + void init(); + void endProcess(); + void setChannel(int, TChannel*); + void releaseChannel(int); + TChannel* getChannel(int); + + TChannel* field_0x0[8]; + u16 field_0x20[8]; + int field_0x30; + u8 field_0x34; + u8 field_0x35; + u8 field_0x36; + }; + + static const int MAX_CHILDREN = 16; + + TTrack(); + void init(); + void inherit(); + s8 mainProc(); + void setInterrupt(u16); + bool tryInterrupt(); + void assignExtBuffer(TOuterParam*); + void releaseChannelAll(); + void flushAll(); + static int moveFreeChannel(TChannelMgr*, TChannelMgr*, int); + void initTimed(); + void connectBus(int, int); + int noteOn(u8, s32, s32, s32, u32); + void overwriteOsc(TChannel*); + bool noteOff(u8, u16); + int gateOn(u8, s32, s32, s32); + int checkNoteStop(s32); + void oscSetupFull(u8, u32, u32); + void oscSetupSimpleEnv(u8, u32); + void updateOscParam(int, f32); + void oscSetupSimple(u8); + void updateTimedParam(); + void updateTrackAll(); + void updateTrack(u32); + void updateTempo(); + void updateSeq(u32, bool); + int seqTimeToDspTime(s32, u8); + void setParam(int, f32, int); + bool setSeqData(u8*, s32, int); + bool startSeq(); + bool stopSeq(); + void stopSeqMain(); + void noteOffAll(); + int close(); + void muteTrack(bool); + bool start(void*, u32); + TTrack* openChild(u8, u8); + int loadTbl(u32, u32, u32); + int exchangeRegisterValue(u8); + void readReg32(u8); + void readReg16(u8); + void writeRegDirect(u8, u16); + void writeRegParam(u8); + u16 readSelfPort(int); + void writeSelfPort(int, u16); + int writePortAppDirect(u32, u16); + int readPortAppDirect(u32, u16*); + void routeTrack(u32); + int writePortApp(u32, u16); + int readPortApp(u32, u16*); + void pause(bool, bool); + int getTranspose() const; + void setTempo(u16); + void setTimebase(u16); + f32 panCalc(f32, f32, f32, u8); + static int rootCallback(void*); + static void registerSeqCallback(u16 (*)(TTrack*, u16)); + static void newMemPool(int); + + TTrack* getParent() { return mParent; } + TTrack* getChild(int index) { + JUT_ASSERT(242, index >= 0); + JUT_ASSERT(243, index < MAX_CHILDREN); + return mChildren[index]; + } + + /* 0x000 */ union { + TSeqCtrl field_0x0; + TTrack* next; + }; + /* 0x048 */ TTrackPort field_0x48; + /* 0x088 */ TIntrMgr field_0x88; + /* 0x0B4 */ TNoteMgr field_0xb4; + /* 0x0EC */ TVibrate field_0xec; + /* 0x0F8 */ TChannelMgr field_0xf8; + /* 0x16C */ TimedParam_ field_0x16c; + /* 0x28C */ TRegisterParam field_0x28c; + /* 0x2BC */ u8 field_0x2bc[0x2cc - 0x2bc]; + /* 0x2CC */ TOscillator::Osc_ field_0x2cc[2]; + /* 0x2FC */ u32 field_0x2fc[2]; + /* 0x304 */ short field_0x304[12]; + /* 0x31C */ TTrack* mParent; + /* 0x320 */ TTrack* mChildren[MAX_CHILDREN]; + /* 0x360 */ TOuterParam* field_0x360; + /* 0x364 */ f32 field_0x364; + /* 0x368 */ f32 field_0x368; + /* 0x36C */ int field_0x36c; + /* 0x370 */ int field_0x370; + /* 0x374 */ u16 field_0x374; + /* 0x376 */ u16 field_0x376; + /* 0x378 */ u16 field_0x378; + /* 0x37a */ u8 field_0x37a; + /* 0x37b */ u8 field_0x37b; + /* 0x37c */ u8 field_0x37c; + /* 0x37d */ u8 field_0x37d; + /* 0x37e */ u8 field_0x37e; + /* 0x37f */ u8 field_0x37f[3]; + /* 0x382 */ u8 field_0x382[3]; + /* 0x385 */ u8 field_0x385; + /* 0x386 */ u8 field_0x386; + /* 0x387 */ bool field_0x387; + /* 0x388 */ u8 field_0x388; + /* 0x389 */ u8 field_0x389; + + static u16 (*sCallBackFunc)(TTrack*, u16); + static TSeqParser sParser; + static TTrack* sFreeList; + }; +} + +#endif /* JASTRACK_H */ diff --git a/src/JSystem/JAudio/JASChannel.cpp b/src/JSystem/JAudio/JASChannel.cpp index 8f9b5c0d1..bedbefae6 100644 --- a/src/JSystem/JAudio/JASChannel.cpp +++ b/src/JSystem/JAudio/JASChannel.cpp @@ -112,7 +112,7 @@ int JASystem::TChannel::getOscState(u32 oscnum) const { } /* 8028BB14-8028BB98 .text isOsc__Q28JASystem8TChannelFUl */ -bool JASystem::TChannel::isOsc(u32 oscnum) { +BOOL JASystem::TChannel::isOsc(u32 oscnum) { /* Nonmatching */ JUT_ASSERT(284, oscnum < (4)); return osc[oscnum]->field_0x0 != 0; diff --git a/src/JSystem/JAudio/JASNoteMgr.cpp b/src/JSystem/JAudio/JASNoteMgr.cpp index 6f606a719..dcee9e266 100644 --- a/src/JSystem/JAudio/JASNoteMgr.cpp +++ b/src/JSystem/JAudio/JASNoteMgr.cpp @@ -3,31 +3,63 @@ // Translation Unit: JASNoteMgr.cpp // -#include "JASNoteMgr.h" -#include "dolphin/types.h" +#include "JSystem/JAudio/JASTrack.h" +#include "JSystem/JAudio/JASChannel.h" +#include "JSystem/JUtility/JUTAssert.h" + +static const int MULTI_MAX = 8; /* 8027DD54-8027DD94 .text init__Q38JASystem6TTrack8TNoteMgrFv */ void JASystem::TTrack::TNoteMgr::init() { - /* Nonmatching */ + field_0x30 = 0; + field_0x34 = 0; + field_0x35 = 0; + field_0x36 = 0; + for (int i = 0; i < MULTI_MAX; i++) { + field_0x0[i] = NULL; + field_0x20[i] = 0; + } } /* 8027DD94-8027DDBC .text endProcess__Q38JASystem6TTrack8TNoteMgrFv */ void JASystem::TTrack::TNoteMgr::endProcess() { - /* Nonmatching */ + if (field_0x30 == 0xffffffff) { + return; + } + if (field_0x34 != 0) { + return; + } + field_0x0[0] = NULL; } /* 8027DDBC-8027DE78 .text setChannel__Q38JASystem6TTrack8TNoteMgrFiPQ28JASystem8TChannel */ -void JASystem::TTrack::TNoteMgr::setChannel(int, JASystem::TChannel*) { - /* Nonmatching */ +void JASystem::TTrack::TNoteMgr::setChannel(int index, JASystem::TChannel* channel) { + JUT_ASSERT(44, index >= 0); + JUT_ASSERT(45, index < MULTI_MAX); + field_0x0[index] = channel; + field_0x20[index] = channel->field_0xc8; } /* 8027DE78-8027DF24 .text releaseChannel__Q38JASystem6TTrack8TNoteMgrFi */ -void JASystem::TTrack::TNoteMgr::releaseChannel(int) { - /* Nonmatching */ +void JASystem::TTrack::TNoteMgr::releaseChannel(int index) { + JUT_ASSERT(53, index >= 0); + JUT_ASSERT(54, index < MULTI_MAX); + field_0x0[index] = NULL; } /* 8027DF24-8027DFD8 .text getChannel__Q38JASystem6TTrack8TNoteMgrFi */ -void JASystem::TTrack::TNoteMgr::getChannel(int) { - /* Nonmatching */ +JASystem::TChannel* JASystem::TTrack::TNoteMgr::getChannel(int index) { + JUT_ASSERT(61, index >= 0); + if (index >= MULTI_MAX) { + return NULL; + } + TChannel* channel = field_0x0[index]; + if (!channel) { + return NULL; + } + if (field_0x20[index] != channel->field_0xc8) { + field_0x0[index] = NULL; + return NULL; + } + return channel; } - diff --git a/src/JSystem/JAudio/JASOuterParam.cpp b/src/JSystem/JAudio/JASOuterParam.cpp index 75c9155d3..d03f452b4 100644 --- a/src/JSystem/JAudio/JASOuterParam.cpp +++ b/src/JSystem/JAudio/JASOuterParam.cpp @@ -3,56 +3,94 @@ // Translation Unit: JASOuterParam.cpp // -#include "JASOuterParam.h" -#include "dolphin/types.h" +#include "JSystem/JAudio/JASTrack.h" /* 8027DFD8-8027E020 .text __ct__Q38JASystem6TTrack11TOuterParamFv */ JASystem::TTrack::TOuterParam::TOuterParam() { - /* Nonmatching */ + field_0x0 = 0; + field_0x2 = 0; + field_0x4 = 0.0f; + field_0x8 = 0.0f; + field_0xc = 0.0f; + field_0x10 = 0.0f; + field_0x14 = 0.0f; + field_0x18 = 0.0f; + for (int i = 0; i < 8; i++) { + field_0x1c[i] = 0; + } } /* 8027E020-8027E030 .text initExtBuffer__Q38JASystem6TTrack11TOuterParamFv */ void JASystem::TTrack::TOuterParam::initExtBuffer() { - /* Nonmatching */ + field_0x0 = 0; + field_0x2 = 0; } /* 8027E030-8027E038 .text setOuterSwitch__Q38JASystem6TTrack11TOuterParamFUs */ -void JASystem::TTrack::TOuterParam::setOuterSwitch(unsigned short) { - /* Nonmatching */ +void JASystem::TTrack::TOuterParam::setOuterSwitch(u16 param_1) { + field_0x0 = param_1; } /* 8027E038-8027E054 .text checkOuterSwitch__Q38JASystem6TTrack11TOuterParamFUs */ -void JASystem::TTrack::TOuterParam::checkOuterSwitch(unsigned short) { - /* Nonmatching */ +bool JASystem::TTrack::TOuterParam::checkOuterSwitch(u16 param_1) { + return field_0x0 & param_1; } /* 8027E054-8027E05C .text setOuterUpdate__Q38JASystem6TTrack11TOuterParamFUs */ -void JASystem::TTrack::TOuterParam::setOuterUpdate(unsigned short) { - /* Nonmatching */ +void JASystem::TTrack::TOuterParam::setOuterUpdate(u16 param_1) { + field_0x2 = param_1; } /* 8027E05C-8027E064 .text getOuterUpdate__Q38JASystem6TTrack11TOuterParamFv */ -void JASystem::TTrack::TOuterParam::getOuterUpdate() { - /* Nonmatching */ +u16 JASystem::TTrack::TOuterParam::getOuterUpdate() { + return field_0x2; } /* 8027E064-8027E074 .text getIntFirFilter__Q38JASystem6TTrack11TOuterParamFUc */ -void JASystem::TTrack::TOuterParam::getIntFirFilter(unsigned char) { - /* Nonmatching */ +s16 JASystem::TTrack::TOuterParam::getIntFirFilter(u8 param_1) { + return field_0x1c[param_1]; } /* 8027E074-8027E110 .text setParam__Q38JASystem6TTrack11TOuterParamFUcf */ -void JASystem::TTrack::TOuterParam::setParam(unsigned char, float) { - /* Nonmatching */ +void JASystem::TTrack::TOuterParam::setParam(u8 param_1, f32 param_2) { + f32* var1; + switch (param_1) { + case 1: + var1 = &field_0x4; + break; + case 2: + var1 = &field_0x8; + break; + case 4: + var1 = &field_0xc; + break; + case 16: + var1 = &field_0x10; + break; + case 8: + var1 = &field_0x14; + break; + case 64: + var1 = &field_0x18; + break; + default: + return; + } + *var1 = param_2; + field_0x2 |= param_1; } /* 8027E110-8027E12C .text onSwitch__Q38JASystem6TTrack11TOuterParamFUs */ -void JASystem::TTrack::TOuterParam::onSwitch(unsigned short) { - /* Nonmatching */ +void JASystem::TTrack::TOuterParam::onSwitch(u16 param_1) { + field_0x0 |= param_1; + field_0x2 |= param_1; } /* 8027E12C-8027E170 .text setFirFilter__Q38JASystem6TTrack11TOuterParamFPs */ -void JASystem::TTrack::TOuterParam::setFirFilter(short*) { - /* Nonmatching */ +void JASystem::TTrack::TOuterParam::setFirFilter(s16* param_1) { + field_0x2 |= 0x80; + field_0x0 |= 0x80; + for (u8 i = 0; i < 8; i++) { + field_0x1c[i] = param_1[i]; + } } - diff --git a/src/JSystem/JAudio/JASSeqCtrl.cpp b/src/JSystem/JAudio/JASSeqCtrl.cpp index 864aee9ee..23799cfdb 100644 --- a/src/JSystem/JAudio/JASSeqCtrl.cpp +++ b/src/JSystem/JAudio/JASSeqCtrl.cpp @@ -82,8 +82,8 @@ bool JASystem::TSeqCtrl::retIntr() { } /* 8027E59C-8027E5B4 .text get16__Q28JASystem8TSeqCtrlCFUl */ -u32 JASystem::TSeqCtrl::get16(u32 param_1) const { - u32 result = field_0x0[param_1++] << 8; +u16 JASystem::TSeqCtrl::get16(u32 param_1) const { + u16 result = field_0x0[param_1++] << 8; result |= field_0x0[param_1++]; return result; } diff --git a/src/JSystem/JAudio/JASSeqParser.cpp b/src/JSystem/JAudio/JASSeqParser.cpp index d5490f3c5..02f293126 100644 --- a/src/JSystem/JAudio/JASSeqParser.cpp +++ b/src/JSystem/JAudio/JASSeqParser.cpp @@ -3,306 +3,494 @@ // Translation Unit: JASSeqParser.cpp // -#include "JASSeqParser.h" -#include "dolphin/types.h" +#include "JSystem/JAudio/JASSeqParser.h" +#include "JSystem/JAudio/JASPlayer.h" +#include "JSystem/JAudio/JASTrack.h" +#include "JSystem/JSupport/JSupport.h" +#include "JSystem/JUtility/JUTAssert.h" /* 8027E680-8027E728 .text cmdOpenTrack__Q28JASystem10TSeqParserFPQ28JASystem6TTrackPUl */ -void JASystem::TSeqParser::cmdOpenTrack(JASystem::TTrack*, unsigned long*) { +int JASystem::TSeqParser::cmdOpenTrack(TTrack* track, u32* params) { /* Nonmatching */ + u32 param1 = params[0]; + u32 param2 = params[1]; + u8 b1 = param1 & 0xF; + u8 b2 = (param1 >> 6) & 3; + if (param1 & 0x20) { + b2 = 4; + } + TTrack* child = track->openChild(b1, b2); + JUT_ASSERT(255, child); + child->start(track->field_0x0.field_0x0, param2); + return 0; } /* 8027E728-8027E800 .text cmdOpenTrackBros__Q28JASystem10TSeqParserFPQ28JASystem6TTrackPUl */ -void JASystem::TSeqParser::cmdOpenTrackBros(JASystem::TTrack*, unsigned long*) { +int JASystem::TSeqParser::cmdOpenTrackBros(TTrack* track, u32* params) { /* Nonmatching */ + if (!track->getParent()) { + JUT_WARN(268, "%s", "cannot opentrackB in ROOT Track"); + return 0; + } + u32 param1 = params[0]; + u32 param2 = params[1]; + u8 b1 = param1 & 0xF; + u8 b2 = (param1 >> 6) & 3; + if (param1 & 0x20) { + b2 = 4; + } + TTrack* bros = track->getParent()->openChild(b1, b2); + JUT_ASSERT(282, bros); + bros->start(track->field_0x0.field_0x0, param2); + return 0; } /* 8027E800-8027E90C .text cmdCall__Q28JASystem10TSeqParserFPQ28JASystem6TTrackPUl */ -void JASystem::TSeqParser::cmdCall(JASystem::TTrack*, unsigned long*) { +int JASystem::TSeqParser::cmdCall(TTrack* track, u32* params) { /* Nonmatching */ } /* 8027E90C-8027E9AC .text cmdRet__Q28JASystem10TSeqParserFPQ28JASystem6TTrackPUl */ -void JASystem::TSeqParser::cmdRet(JASystem::TTrack*, unsigned long*) { - /* Nonmatching */ +int JASystem::TSeqParser::cmdRet(TTrack* track, u32* params) { + if (conditionCheck(track, params[0])) { + u32 var1 = track->field_0x0.field_0xc; + bool tmp; + if (var1 == 0) { + tmp = false; + } else { + u32 var2 = var1 - 1; + track->field_0x0.field_0xc = var2; + track->field_0x0.field_0x4 = track->field_0x0.field_0x10[var2]; + tmp = true; + } + if (!tmp) { + JUT_WARN(335, "%s", "cannot ret for call-stack is NULL"); + return 3; + } + } + return 0; } /* 8027E9AC-8027EAF4 .text cmdJmp__Q28JASystem10TSeqParserFPQ28JASystem6TTrackPUl */ -void JASystem::TSeqParser::cmdJmp(JASystem::TTrack*, unsigned long*) { +int JASystem::TSeqParser::cmdJmp(TTrack* track, u32* params) { /* Nonmatching */ } /* 8027EAF4-8027EB2C .text cmdLoopS__Q28JASystem10TSeqParserFPQ28JASystem6TTrackPUl */ -void JASystem::TSeqParser::cmdLoopS(JASystem::TTrack*, unsigned long*) { +int JASystem::TSeqParser::cmdLoopS(TTrack* track, u32* params) { /* Nonmatching */ + u32 param1 = params[0]; + track->field_0x0.field_0x10[track->field_0x0.field_0xc] = track->field_0x0.field_0x4; + track->field_0x0.field_0x30[track->field_0x0.field_0xc++] = param1; + return 0; } /* 8027EB2C-8027EB54 .text cmdLoopE__Q28JASystem10TSeqParserFPQ28JASystem6TTrackPUl */ -void JASystem::TSeqParser::cmdLoopE(JASystem::TTrack*, unsigned long*) { - /* Nonmatching */ +int JASystem::TSeqParser::cmdLoopE(TTrack* track, u32* params) { + track->field_0x0.loopEnd(); + return 0; } /* 8027EB54-8027EBAC .text cmdReadPort__Q28JASystem10TSeqParserFPQ28JASystem6TTrackPUl */ -void JASystem::TSeqParser::cmdReadPort(JASystem::TTrack*, unsigned long*) { - /* Nonmatching */ +int JASystem::TSeqParser::cmdReadPort(TTrack* track, u32* params) { + track->writeRegDirect(params[1], track->readSelfPort(params[0])); + return 0; } /* 8027EBAC-8027EBE0 .text cmdWritePort__Q28JASystem10TSeqParserFPQ28JASystem6TTrackPUl */ -void JASystem::TSeqParser::cmdWritePort(JASystem::TTrack*, unsigned long*) { - /* Nonmatching */ +int JASystem::TSeqParser::cmdWritePort(TTrack* track, u32* params) { + track->writeSelfPort(params[0], params[1]); + return 0; } /* 8027EBE0-8027EC68 .text cmdParentWritePort__Q28JASystem10TSeqParserFPQ28JASystem6TTrackPUl */ -void JASystem::TSeqParser::cmdParentWritePort(JASystem::TTrack*, unsigned long*) { +int JASystem::TSeqParser::cmdParentWritePort(TTrack* track, u32* params) { /* Nonmatching */ + TTrack* parent = track->getParent(); + JUT_ASSERT(452, parent != 0); + parent->writePortAppDirect(params[0] & 0xf, params[1]); + return 0; } /* 8027EC68-8027ED80 .text cmdChildWritePort__Q28JASystem10TSeqParserFPQ28JASystem6TTrackPUl */ -void JASystem::TSeqParser::cmdChildWritePort(JASystem::TTrack*, unsigned long*) { +int JASystem::TSeqParser::cmdChildWritePort(TTrack* track, u32* params) { /* Nonmatching */ + u8 param1 = JSULoByte(params[0]); + u8 b1 = JSUHiNibble(param1); + TTrack* child = track->getChild(b1); + JUT_ASSERT(462, child != 0); + child->writePortAppDirect(JSULoNibble(param1), params[1]); + return 0; } /* 8027ED80-8027ED98 .text cmdCheckPortImport__Q28JASystem10TSeqParserFPQ28JASystem6TTrackPUl */ -void JASystem::TSeqParser::cmdCheckPortImport(JASystem::TTrack*, unsigned long*) { - /* Nonmatching */ +int JASystem::TSeqParser::cmdCheckPortImport(TTrack* track, u32* params) { + track->field_0x28c.field_0x6 = track->field_0x48.field_0x0[params[0]]; + return 0; } /* 8027ED98-8027EDB0 .text cmdCheckPortExport__Q28JASystem10TSeqParserFPQ28JASystem6TTrackPUl */ -void JASystem::TSeqParser::cmdCheckPortExport(JASystem::TTrack*, unsigned long*) { - /* Nonmatching */ +int JASystem::TSeqParser::cmdCheckPortExport(TTrack* track, u32* params) { + track->field_0x28c.field_0x6 = track->field_0x48.field_0x10[params[0]]; + return 0; } /* 8027EDB0-8027EDC4 .text cmdWait__Q28JASystem10TSeqParserFPQ28JASystem6TTrackPUl */ -void JASystem::TSeqParser::cmdWait(JASystem::TTrack*, unsigned long*) { - /* Nonmatching */ +int JASystem::TSeqParser::cmdWait(TTrack* track, u32* params) { + u32 param1 = params[0]; + track->field_0x0.field_0x8 = param1; + return param1 != 0 ? 1 : 0; } /* 8027EDC4-8027EE44 .text cmdSetLastNote__Q28JASystem10TSeqParserFPQ28JASystem6TTrackPUl */ -void JASystem::TSeqParser::cmdSetLastNote(JASystem::TTrack*, unsigned long*) { - /* Nonmatching */ +int JASystem::TSeqParser::cmdSetLastNote(TTrack* track, u32* params) { + u32 key = params[0]; + key += track->getTranspose(); + JUT_ASSERT(506, key < 256); + track->field_0xb4.field_0x35 = key; + return 0; } /* 8027EE44-8027EE5C .text cmdTimeRelate__Q28JASystem10TSeqParserFPQ28JASystem6TTrackPUl */ -void JASystem::TSeqParser::cmdTimeRelate(JASystem::TTrack*, unsigned long*) { - /* Nonmatching */ +int JASystem::TSeqParser::cmdTimeRelate(TTrack* track, u32* params) { + track->field_0x387 = params[0]; + return 0; } /* 8027EE5C-8027EE8C .text cmdSimpleOsc__Q28JASystem10TSeqParserFPQ28JASystem6TTrackPUl */ -void JASystem::TSeqParser::cmdSimpleOsc(JASystem::TTrack*, unsigned long*) { - /* Nonmatching */ +int JASystem::TSeqParser::cmdSimpleOsc(TTrack* track, u32* params) { + track->oscSetupSimple(params[0]); + return 0; } /* 8027EE8C-8027EEC0 .text cmdSimpleEnv__Q28JASystem10TSeqParserFPQ28JASystem6TTrackPUl */ -void JASystem::TSeqParser::cmdSimpleEnv(JASystem::TTrack*, unsigned long*) { - /* Nonmatching */ +int JASystem::TSeqParser::cmdSimpleEnv(TTrack* track, u32* params) { + track->oscSetupSimpleEnv(params[0], params[1]); + return 0; } /* 8027EEC0-8027EF2C .text cmdSimpleADSR__Q28JASystem10TSeqParserFPQ28JASystem6TTrackPUl */ -void JASystem::TSeqParser::cmdSimpleADSR(JASystem::TTrack*, unsigned long*) { - /* Nonmatching */ +int JASystem::TSeqParser::cmdSimpleADSR(TTrack* track, u32* params) { + track->field_0x2cc[0] = Player::sAdsrDef; + track->field_0x2cc[0].table = track->field_0x304; + track->field_0x304[1] = params[0]; + track->field_0x304[4] = params[1]; + track->field_0x304[7] = params[2]; + track->field_0x304[8] = params[3]; + track->field_0x374 = params[4]; + return 0; + } /* 8027EF2C-8027EF3C .text cmdTranspose__Q28JASystem10TSeqParserFPQ28JASystem6TTrackPUl */ -void JASystem::TSeqParser::cmdTranspose(JASystem::TTrack*, unsigned long*) { - /* Nonmatching */ +int JASystem::TSeqParser::cmdTranspose(TTrack* track, u32* params) { + track->field_0x37a = params[0]; + return 0; } /* 8027EF3C-8027EFD8 .text cmdCloseTrack__Q28JASystem10TSeqParserFPQ28JASystem6TTrackPUl */ -void JASystem::TSeqParser::cmdCloseTrack(JASystem::TTrack*, unsigned long*) { - /* Nonmatching */ +int JASystem::TSeqParser::cmdCloseTrack(TTrack* track, u32* params) { + u8 track_no = params[0]; + JUT_ASSERT(565, track_no < TTrack::MAX_CHILDREN); + if (!track->mChildren[track_no]) { + return 0; + } + track->mChildren[track_no]->close(); + track->mChildren[track_no] = NULL; + return 0; } /* 8027EFD8-8027F02C .text cmdOutSwitch__Q28JASystem10TSeqParserFPQ28JASystem6TTrackPUl */ -void JASystem::TSeqParser::cmdOutSwitch(JASystem::TTrack*, unsigned long*) { - /* Nonmatching */ +int JASystem::TSeqParser::cmdOutSwitch(TTrack* track, u32* params) { + TTrack::TOuterParam* outer = track->field_0x360; + if (outer) { + outer->setOuterSwitch(params[0]); + outer->setOuterUpdate(0xffff); + } + return 0; } /* 8027F02C-8027F058 .text cmdUpdateSync__Q28JASystem10TSeqParserFPQ28JASystem6TTrackPUl */ -void JASystem::TSeqParser::cmdUpdateSync(JASystem::TTrack*, unsigned long*) { - /* Nonmatching */ +int JASystem::TSeqParser::cmdUpdateSync(TTrack* track, u32* params) { + track->updateTrack(params[0]); + return 0; } /* 8027F058-8027F088 .text cmdBusConnect__Q28JASystem10TSeqParserFPQ28JASystem6TTrackPUl */ -void JASystem::TSeqParser::cmdBusConnect(JASystem::TTrack*, unsigned long*) { - /* Nonmatching */ +int JASystem::TSeqParser::cmdBusConnect(TTrack* track, u32* params) { + track->connectBus(params[0], params[1]); + return 0; } /* 8027F088-8027F098 .text cmdPauseStatus__Q28JASystem10TSeqParserFPQ28JASystem6TTrackPUl */ -void JASystem::TSeqParser::cmdPauseStatus(JASystem::TTrack*, unsigned long*) { +int JASystem::TSeqParser::cmdPauseStatus(TTrack* track, u32* params) { /* Nonmatching */ + track->field_0x37c = params[0]; + return 0; } /* 8027F098-8027F0A8 .text cmdVolumeMode__Q28JASystem10TSeqParserFPQ28JASystem6TTrackPUl */ -void JASystem::TSeqParser::cmdVolumeMode(JASystem::TTrack*, unsigned long*) { +int JASystem::TSeqParser::cmdVolumeMode(TTrack* track, u32* params) { /* Nonmatching */ + track->field_0x37d = params[0]; + return 0; } /* 8027F0A8-8027F0E0 .text cmdSetInterrupt__Q28JASystem10TSeqParserFPQ28JASystem6TTrackPUl */ -void JASystem::TSeqParser::cmdSetInterrupt(JASystem::TTrack*, unsigned long*) { +int JASystem::TSeqParser::cmdSetInterrupt(TTrack* track, u32* params) { /* Nonmatching */ + track->field_0x88.setIntr(params[0], track->field_0x0.field_0x0 + params[1]); + return 0; } /* 8027F0E0-8027F10C .text cmdDisInterrupt__Q28JASystem10TSeqParserFPQ28JASystem6TTrackPUl */ -void JASystem::TSeqParser::cmdDisInterrupt(JASystem::TTrack*, unsigned long*) { - /* Nonmatching */ +int JASystem::TSeqParser::cmdDisInterrupt(TTrack* track, u32* params) { + track->field_0x88.resetInter(params[0]); + return 0; } /* 8027F10C-8027F124 .text cmdClrI__Q28JASystem10TSeqParserFPQ28JASystem6TTrackPUl */ -void JASystem::TSeqParser::cmdClrI(JASystem::TTrack*, unsigned long*) { - /* Nonmatching */ +int JASystem::TSeqParser::cmdClrI(TTrack* track, u32* params) { + track->field_0x88.field_0x0 = 1; + track->field_0x0.field_0x44 = 0; + return 0; } /* 8027F124-8027F134 .text cmdSetI__Q28JASystem10TSeqParserFPQ28JASystem6TTrackPUl */ -void JASystem::TSeqParser::cmdSetI(JASystem::TTrack*, unsigned long*) { - /* Nonmatching */ +int JASystem::TSeqParser::cmdSetI(TTrack* track, u32* params) { + track->field_0x88.field_0x0 = 0; + return 0; } /* 8027F134-8027F178 .text cmdRetI__Q28JASystem10TSeqParserFPQ28JASystem6TTrackPUl */ -void JASystem::TSeqParser::cmdRetI(JASystem::TTrack*, unsigned long*) { - /* Nonmatching */ +int JASystem::TSeqParser::cmdRetI(TTrack* track, u32* params) { + track->field_0x88.field_0x0 = 1; + track->field_0x0.retIntr(); + track->tryInterrupt(); + return 0; } /* 8027F178-8027F194 .text cmdIntTimer__Q28JASystem10TSeqParserFPQ28JASystem6TTrackPUl */ -void JASystem::TSeqParser::cmdIntTimer(JASystem::TTrack*, unsigned long*) { - /* Nonmatching */ +int JASystem::TSeqParser::cmdIntTimer(TTrack* track, u32* params) { + u32 param2 = params[1]; + track->field_0x88.field_0x3 = params[0]; + track->field_0x88.field_0x4 = param2; + track->field_0x88.field_0x8 = param2; + return 0; } /* 8027F194-8027F1EC .text cmdSyncCPU__Q28JASystem10TSeqParserFPQ28JASystem6TTrackPUl */ -void JASystem::TSeqParser::cmdSyncCPU(JASystem::TTrack*, unsigned long*) { - /* Nonmatching */ +int JASystem::TSeqParser::cmdSyncCPU(TTrack* track, u32* params) { + u16 var1 = 0xffff; + if (TTrack::sCallBackFunc) { + var1 = TTrack::sCallBackFunc(track, params[0]); + } + track->field_0x28c.field_0x6 = var1; + return 0; } /* 8027F1EC-8027F214 .text cmdFlushAll__Q28JASystem10TSeqParserFPQ28JASystem6TTrackPUl */ -void JASystem::TSeqParser::cmdFlushAll(JASystem::TTrack*, unsigned long*) { - /* Nonmatching */ +int JASystem::TSeqParser::cmdFlushAll(TTrack* track, u32* params) { + track->flushAll(); + return 0; } /* 8027F214-8027F23C .text cmdFlushRelease__Q28JASystem10TSeqParserFPQ28JASystem6TTrackPUl */ -void JASystem::TSeqParser::cmdFlushRelease(JASystem::TTrack*, unsigned long*) { - /* Nonmatching */ +int JASystem::TSeqParser::cmdFlushRelease(TTrack* track, u32* params) { + track->field_0xf8.stopAllRelease(); + return 0; } /* 8027F23C-8027F26C .text cmdTimeBase__Q28JASystem10TSeqParserFPQ28JASystem6TTrackPUl */ -void JASystem::TSeqParser::cmdTimeBase(JASystem::TTrack*, unsigned long*) { - /* Nonmatching */ +int JASystem::TSeqParser::cmdTimeBase(TTrack* track, u32* params) { + track->setTimebase(params[0]); + return 0; } /* 8027F26C-8027F29C .text cmdTempo__Q28JASystem10TSeqParserFPQ28JASystem6TTrackPUl */ -void JASystem::TSeqParser::cmdTempo(JASystem::TTrack*, unsigned long*) { - /* Nonmatching */ +int JASystem::TSeqParser::cmdTempo(TTrack* track, u32* params) { + track->setTempo(params[0]); + return 0; } /* 8027F29C-8027F2A4 .text cmdFinish__Q28JASystem10TSeqParserFPQ28JASystem6TTrackPUl */ -void JASystem::TSeqParser::cmdFinish(JASystem::TTrack*, unsigned long*) { - /* Nonmatching */ +int JASystem::TSeqParser::cmdFinish(TTrack* track, u32* params) { + return 3; } /* 8027F2A4-8027F2AC .text cmdNop__Q28JASystem10TSeqParserFPQ28JASystem6TTrackPUl */ -void JASystem::TSeqParser::cmdNop(JASystem::TTrack*, unsigned long*) { - /* Nonmatching */ +int JASystem::TSeqParser::cmdNop(TTrack* track, u32* params) { + return 0; } /* 8027F2AC-8027F330 .text cmdPanPowSet__Q28JASystem10TSeqParserFPQ28JASystem6TTrackPUl */ -void JASystem::TSeqParser::cmdPanPowSet(JASystem::TTrack*, unsigned long*) { +int JASystem::TSeqParser::cmdPanPowSet(TTrack* track, u32* params) { /* Nonmatching */ } /* 8027F330-8027F368 .text cmdFIRSet__Q28JASystem10TSeqParserFPQ28JASystem6TTrackPUl */ -void JASystem::TSeqParser::cmdFIRSet(JASystem::TTrack*, unsigned long*) { +int JASystem::TSeqParser::cmdFIRSet(TTrack* track, u32* params) { /* Nonmatching */ } /* 8027F368-8027F3BC .text cmdEXTSet__Q28JASystem10TSeqParserFPQ28JASystem6TTrackPUl */ -void JASystem::TSeqParser::cmdEXTSet(JASystem::TTrack*, unsigned long*) { +int JASystem::TSeqParser::cmdEXTSet(TTrack* track, u32* params) { /* Nonmatching */ } /* 8027F3BC-8027F460 .text cmdPanSwSet__Q28JASystem10TSeqParserFPQ28JASystem6TTrackPUl */ -void JASystem::TSeqParser::cmdPanSwSet(JASystem::TTrack*, unsigned long*) { +int JASystem::TSeqParser::cmdPanSwSet(TTrack* track, u32* params) { /* Nonmatching */ } /* 8027F460-8027F47C .text cmdOscRoute__Q28JASystem10TSeqParserFPQ28JASystem6TTrackPUl */ -void JASystem::TSeqParser::cmdOscRoute(JASystem::TTrack*, unsigned long*) { +int JASystem::TSeqParser::cmdOscRoute(TTrack* track, u32* params) { /* Nonmatching */ } /* 8027F47C-8027F4C4 .text cmdVibDepth__Q28JASystem10TSeqParserFPQ28JASystem6TTrackPUl */ -void JASystem::TSeqParser::cmdVibDepth(JASystem::TTrack*, unsigned long*) { +int JASystem::TSeqParser::cmdVibDepth(TTrack* track, u32* params) { /* Nonmatching */ } /* 8027F4C4-8027F4FC .text cmdVibDepthMidi__Q28JASystem10TSeqParserFPQ28JASystem6TTrackPUl */ -void JASystem::TSeqParser::cmdVibDepthMidi(JASystem::TTrack*, unsigned long*) { +int JASystem::TSeqParser::cmdVibDepthMidi(TTrack* track, u32* params) { /* Nonmatching */ } /* 8027F4FC-8027F544 .text cmdVibPitch__Q28JASystem10TSeqParserFPQ28JASystem6TTrackPUl */ -void JASystem::TSeqParser::cmdVibPitch(JASystem::TTrack*, unsigned long*) { +int JASystem::TSeqParser::cmdVibPitch(TTrack* track, u32* params) { /* Nonmatching */ } /* 8027F544-8027F5C8 .text cmdIIRSet__Q28JASystem10TSeqParserFPQ28JASystem6TTrackPUl */ -void JASystem::TSeqParser::cmdIIRSet(JASystem::TTrack*, unsigned long*) { +int JASystem::TSeqParser::cmdIIRSet(TTrack* track, u32* params) { /* Nonmatching */ } /* 8027F5C8-8027F65C .text cmdIIRCutOff__Q28JASystem10TSeqParserFPQ28JASystem6TTrackPUl */ -void JASystem::TSeqParser::cmdIIRCutOff(JASystem::TTrack*, unsigned long*) { +int JASystem::TSeqParser::cmdIIRCutOff(TTrack* track, u32* params) { /* Nonmatching */ } /* 8027F65C-8027F698 .text cmdOscFull__Q28JASystem10TSeqParserFPQ28JASystem6TTrackPUl */ -void JASystem::TSeqParser::cmdOscFull(JASystem::TTrack*, unsigned long*) { +int JASystem::TSeqParser::cmdOscFull(TTrack* track, u32* params) { /* Nonmatching */ } /* 8027F698-8027F6A8 .text cmdCheckWave__Q28JASystem10TSeqParserFPQ28JASystem6TTrackPUl */ -void JASystem::TSeqParser::cmdCheckWave(JASystem::TTrack*, unsigned long*) { +int JASystem::TSeqParser::cmdCheckWave(TTrack* track, u32* params) { /* Nonmatching */ } /* 8027F6A8-8027F8F4 .text cmdPrintf__Q28JASystem10TSeqParserFPQ28JASystem6TTrackPUl */ -void JASystem::TSeqParser::cmdPrintf(JASystem::TTrack*, unsigned long*) { +int JASystem::TSeqParser::cmdPrintf(TTrack* track, u32* params) { /* Nonmatching */ } /* 8027F8F4-8027FA48 .text Cmd_Process__Q28JASystem10TSeqParserFPQ28JASystem6TTrackUcUs */ -void JASystem::TSeqParser::Cmd_Process(JASystem::TTrack*, unsigned char, unsigned short) { +void JASystem::TSeqParser::Cmd_Process(TTrack* track, u8, u16) { /* Nonmatching */ } /* 8027FA48-8027FB08 .text RegCmd_Process__Q28JASystem10TSeqParserFPQ28JASystem6TTrackii */ -void JASystem::TSeqParser::RegCmd_Process(JASystem::TTrack*, int, int) { +void JASystem::TSeqParser::RegCmd_Process(TTrack* track, int, int) { /* Nonmatching */ } /* 8027FB08-8027FC98 .text cmdSetParam__Q28JASystem10TSeqParserFPQ28JASystem6TTrackUc */ -void JASystem::TSeqParser::cmdSetParam(JASystem::TTrack*, unsigned char) { +int JASystem::TSeqParser::cmdSetParam(TTrack* track, u8) { /* Nonmatching */ } /* 8027FC98-8027FCE4 .text cmdWait__Q28JASystem10TSeqParserFPQ28JASystem6TTrackUc */ -void JASystem::TSeqParser::cmdWait(JASystem::TTrack*, unsigned char) { +int JASystem::TSeqParser::cmdWait(TTrack* track, u8) { /* Nonmatching */ } /* 8027FCE4-8027FE08 .text cmdNoteOff__Q28JASystem10TSeqParserFPQ28JASystem6TTrackUc */ -void JASystem::TSeqParser::cmdNoteOff(JASystem::TTrack*, unsigned char) { +int JASystem::TSeqParser::cmdNoteOff(TTrack* track, u8) { /* Nonmatching */ } /* 8027FE08-80280148 .text cmdNoteOn__Q28JASystem10TSeqParserFPQ28JASystem6TTrackUc */ -void JASystem::TSeqParser::cmdNoteOn(JASystem::TTrack*, unsigned char) { +int JASystem::TSeqParser::cmdNoteOn(TTrack* track, u8) { /* Nonmatching */ } /* 80280148-8028024C .text conditionCheck__Q28JASystem10TSeqParserFPQ28JASystem6TTrackUc */ -void JASystem::TSeqParser::conditionCheck(JASystem::TTrack*, unsigned char) { +bool JASystem::TSeqParser::conditionCheck(TTrack* track, u8) { /* Nonmatching */ } /* 8028024C-802803B0 .text parseSeq__Q28JASystem10TSeqParserFPQ28JASystem6TTrack */ -void JASystem::TSeqParser::parseSeq(JASystem::TTrack*) { +void JASystem::TSeqParser::parseSeq(TTrack* track) { /* Nonmatching */ } +int (JASystem::TSeqParser::*JASystem::TSeqParser::sCmdPList[64])(JASystem::TTrack*, u32*) = { + NULL, + JASystem::TSeqParser::cmdOpenTrack, + JASystem::TSeqParser::cmdOpenTrackBros, + NULL, + JASystem::TSeqParser::cmdCall, + NULL, + JASystem::TSeqParser::cmdRet, + NULL, + JASystem::TSeqParser::cmdJmp, + JASystem::TSeqParser::cmdLoopS, + JASystem::TSeqParser::cmdLoopE, + JASystem::TSeqParser::cmdReadPort, + JASystem::TSeqParser::cmdWritePort, + JASystem::TSeqParser::cmdCheckPortImport, + JASystem::TSeqParser::cmdCheckPortExport, + JASystem::TSeqParser::cmdWait, + NULL, + JASystem::TSeqParser::cmdParentWritePort, + JASystem::TSeqParser::cmdChildWritePort, + NULL, + JASystem::TSeqParser::cmdSetLastNote, + JASystem::TSeqParser::cmdTimeRelate, + JASystem::TSeqParser::cmdSimpleOsc, + JASystem::TSeqParser::cmdSimpleEnv, + JASystem::TSeqParser::cmdSimpleADSR, + JASystem::TSeqParser::cmdTranspose, + JASystem::TSeqParser::cmdCloseTrack, + JASystem::TSeqParser::cmdOutSwitch, + JASystem::TSeqParser::cmdUpdateSync, + JASystem::TSeqParser::cmdBusConnect, + JASystem::TSeqParser::cmdPauseStatus, + JASystem::TSeqParser::cmdSetInterrupt, + JASystem::TSeqParser::cmdDisInterrupt, + JASystem::TSeqParser::cmdClrI, + JASystem::TSeqParser::cmdSetI, + JASystem::TSeqParser::cmdRetI, + JASystem::TSeqParser::cmdIntTimer, + JASystem::TSeqParser::cmdVibDepth, + JASystem::TSeqParser::cmdVibDepthMidi, + JASystem::TSeqParser::cmdSyncCPU, + JASystem::TSeqParser::cmdFlushAll, + JASystem::TSeqParser::cmdFlushRelease, + JASystem::TSeqParser::cmdWait, + JASystem::TSeqParser::cmdPanPowSet, + JASystem::TSeqParser::cmdIIRSet, + JASystem::TSeqParser::cmdFIRSet, + JASystem::TSeqParser::cmdEXTSet, + JASystem::TSeqParser::cmdPanSwSet, + JASystem::TSeqParser::cmdOscRoute, + JASystem::TSeqParser::cmdIIRCutOff, + JASystem::TSeqParser::cmdOscFull, + JASystem::TSeqParser::cmdVolumeMode, + JASystem::TSeqParser::cmdVibPitch, + NULL, + NULL, + NULL, + NULL, + NULL, + JASystem::TSeqParser::cmdCheckWave, + JASystem::TSeqParser::cmdPrintf, + JASystem::TSeqParser::cmdNop, + JASystem::TSeqParser::cmdTempo, + JASystem::TSeqParser::cmdTimeBase, + JASystem::TSeqParser::cmdFinish, +}; diff --git a/src/JSystem/JAudio/JASTrack.cpp b/src/JSystem/JAudio/JASTrack.cpp index d7b97170a..3dd868a5d 100644 --- a/src/JSystem/JAudio/JASTrack.cpp +++ b/src/JSystem/JAudio/JASTrack.cpp @@ -3,117 +3,456 @@ // Translation Unit: JASTrack.cpp // -#include "JASTrack.h" -#include "dolphin/types.h" +#include "JSystem/JAudio/JASTrack.h" +#include "JSystem/JAudio/JASBankMgr.h" +#include "JSystem/JAudio/JASCalc.h" +#include "JSystem/JAudio/JASChannel.h" +#include "JSystem/JAudio/JASChGlobal.h" +#include "JSystem/JAudio/JASPlayer.h" +#include "JSystem/JAudio/JASSystemHeap.h" +#include "JSystem/JKernel/JKRSolidHeap.h" +#include "JSystem/JUtility/JUTAssert.h" /* 80280960-80280A34 .text __ct__Q28JASystem6TTrackFv */ JASystem::TTrack::TTrack() { - /* Nonmatching */ + mParent = NULL; + field_0x364 = 0.0f; + field_0x368 = 0.0f; + field_0x36c = 0; + field_0x370 = 0; + field_0x374 = 0; + field_0x376 = 0x78; + field_0x378 = 0x78; + field_0x37a = 0; + field_0x37b = 0; + field_0x37c = 0; + field_0x37d = 0; + field_0x37e = 0; + field_0x385 = 0; + field_0x386 = 0; + field_0x387 = 0; + field_0x388 = 0; + field_0x389 = 0; + field_0xf8.init(); + for (int i = 0; i < 12; i++) { + field_0x304[i] = Player::sAdsTable[i]; + } + Calc::bzero(&field_0x16c, sizeof(TimedParam_)); } /* 80280A34-80280A80 .text __ct__Q38JASystem6TTrack11TimedParam_Fv */ -JASystem::TTrack::TimedParam_::TimedParam_() { - /* Nonmatching */ -} +JASystem::TTrack::TimedParam_::TimedParam_() {} /* 80280A80-80280C10 .text init__Q28JASystem6TTrackFv */ void JASystem::TTrack::init() { - /* Nonmatching */ + field_0x0.init(); + field_0x48.init(); + field_0x88.init(); + field_0xb4.init(); + field_0xf8.initAllocChannel(0); + initTimed(); + field_0x28c.init(); + field_0x2fc[0] = 0x0f; + field_0x2cc[0] = Player::sEnvelopeDef; + field_0x2fc[1] = 0x0f; + field_0x2cc[1] = Player::sEnvelopeDef; + mParent = NULL; + for (int i = 0; i < 16; i++) { + mChildren[i] = NULL; + } + if (field_0x360) { + field_0x360->initExtBuffer(); + } + field_0x364 = 0.0f; + field_0x368 = 1.0f; + field_0x36c = 0; + field_0xec.init(); + field_0x370 = 0; + field_0x374 = 0; + field_0x376 = 0x78; + field_0x378 = 0x30; + updateTempo(); + field_0x37a = 0; + field_0x37b = 0; + field_0x37c = 10; + field_0x37d = 0; + field_0x37e = 0; + for (int i = 0; i < 3; i++) { + field_0x37f[i] = 0; + field_0x382[i] = 0; + field_0xf8.field_0x62[i] = 0x0d; + } + field_0x385 = 0; + field_0x386 = 0; + field_0x387 = 1; + field_0x388 = 0; } /* 80280C10-80280D0C .text inherit__Q28JASystem6TTrackFv */ void JASystem::TTrack::inherit() { - /* Nonmatching */ + if (!mParent) { + return; + } + field_0x376 = mParent->field_0x376; + field_0x388 = 0; + field_0x368 = mParent->field_0x368; + field_0x378 = mParent->field_0x378; + field_0x387 = mParent->field_0x387; + field_0x385 = mParent->field_0x385; + field_0x37c = mParent->field_0x37c; + field_0x37d = mParent->field_0x37d; + field_0x386 = mParent->field_0x386; + if (field_0x37b & 2) { + return; + } + field_0x28c.inherit(mParent->field_0x28c); + for (int i = 0; i < 3; i++) { + field_0x37f[i] = mParent->field_0x37f[i]; + field_0x382[i] = mParent->field_0x382[i]; + field_0xf8.field_0x62[i] = mParent->field_0xf8.field_0x62[i]; + } } +u16 (*JASystem::TTrack::sCallBackFunc)(JASystem::TTrack*, u16); +JASystem::TSeqParser JASystem::TTrack::sParser; + /* 80280D0C-80280F80 .text mainProc__Q28JASystem6TTrackFv */ -void JASystem::TTrack::mainProc() { +s8 JASystem::TTrack::mainProc() { /* Nonmatching */ + int r31 = 0; + if (field_0x388 && mParent) { + f32 tmp = f32(field_0x376) / f32(mParent->field_0x376); + if (tmp > 1.0f) { + tmp = 1.0f; + } + field_0x364 += tmp; + if (field_0x364 < 1.0f) { + return 0; + } + field_0x364 -= 1.0f; + } + if (mParent && field_0xf8.field_0x0) { + TChannel* channel = field_0xf8.getListHead(0); + if (channel) { + mParent->field_0xf8.addListHead(channel, 0); + channel->field_0x4 = &mParent->field_0xf8; + field_0xf8.field_0x0--; + mParent->field_0xf8.field_0x0++; + } + } + field_0x88.request(7); + field_0x88.timerProcess(); + tryInterrupt(); + if (field_0x385 == 0 && (field_0x37c & 2) == 0) { + // TODO: + } + updateSeq(0, false); + if (r31 < 0) { + return -1; + } + for (int i = 0; i < 16; i++) { + TTrack* child = mChildren[i]; + if (child && child->field_0x37e) { + JUT_ASSERT(276, this == child->mParent); + if (child->mainProc() == -1) { + child->close(); + mChildren[i] = NULL; + } + } + } + return 0; } /* 80280F80-80280FA8 .text setInterrupt__Q28JASystem6TTrackFUs */ -void JASystem::TTrack::setInterrupt(unsigned short) { - /* Nonmatching */ +void JASystem::TTrack::setInterrupt(u16 param_1) { + field_0x88.request(param_1); } /* 80280FA8-80281004 .text tryInterrupt__Q28JASystem6TTrackFv */ -void JASystem::TTrack::tryInterrupt() { - /* Nonmatching */ +bool JASystem::TTrack::tryInterrupt() { + if (field_0x0.field_0x44) { + return false; + } + void* var1 = field_0x88.checkIntr(); + if (var1 == NULL) { + return false; + } + return field_0x0.callIntr(var1); } /* 80281004-8028100C .text assignExtBuffer__Q28JASystem6TTrackFPQ38JASystem6TTrack11TOuterParam */ -void JASystem::TTrack::assignExtBuffer(JASystem::TTrack::TOuterParam*) { - /* Nonmatching */ +void JASystem::TTrack::assignExtBuffer(TOuterParam* param_1) { + field_0x360 = param_1; } /* 8028100C-80281050 .text releaseChannelAll__Q28JASystem6TTrackFv */ void JASystem::TTrack::releaseChannelAll() { - /* Nonmatching */ + if (mParent) { + mParent->field_0xf8.receiveAllChannels(&field_0xf8); + } else { + TGlobalChannel::releaseAll(&field_0xf8); + } } /* 80281050-80281088 .text flushAll__Q28JASystem6TTrackFv */ void JASystem::TTrack::flushAll() { - /* Nonmatching */ + field_0xf8.stopAll(); + field_0xf8.stopAllRelease(); } /* 80281088-80281138 .text moveFreeChannel__Q28JASystem6TTrackFPQ28JASystem11TChannelMgrPQ28JASystem11TChannelMgri */ -void JASystem::TTrack::moveFreeChannel(JASystem::TChannelMgr*, JASystem::TChannelMgr*, int) { - /* Nonmatching */ +int JASystem::TTrack::moveFreeChannel(TChannelMgr* param_1, TChannelMgr* param_2, int param_3) { + if (param_3 < 0) { + u32 r31 = param_1->field_0x0; + param_2->receiveAllChannels(param_1); + return r31; + } + for (int i = 0; i < param_3; i++) { + if (!param_1->field_0x0) { + break; + } + TChannel* channel = param_1->getListHead(0); + if (!channel) { + break; + } + param_1->field_0x0--; + param_2->addListHead(channel, 0); + param_2->field_0x0++; + } + return 0; } /* 80281138-802811DC .text initTimed__Q28JASystem6TTrackFv */ void JASystem::TTrack::initTimed() { - /* Nonmatching */ + for (u8 i = 0; i < 18; i++) { + field_0x16c.move[i].field_0x8 = 0.0f; + field_0x16c.move[i].field_0x0 = 1.0f; + field_0x16c.move[i].field_0x4 = 1.0f; + } + field_0x16c.move[1].field_0x0 = 0.0f; + field_0x16c.move[1].field_0x4 = 0.0f; + field_0x16c.move[3].field_0x0 = 0.5f; + field_0x16c.move[3].field_0x4 = 0.5f; + field_0x16c.move[16].field_0x0 = 0.5f; + field_0x16c.move[16].field_0x4 = 0.5f; + field_0x16c.move[17].field_0x0 = 0.0f; + field_0x16c.move[17].field_0x4 = 0.0f; + field_0x16c.move[2].field_0x0 = 0.0f; + field_0x16c.move[2].field_0x4 = 0.0f; + field_0x16c.move[4].field_0x0 = 0.0f; + field_0x16c.move[4].field_0x4 = 0.0f; + for (u8 i = 1; i < 4; i++) { + field_0x16c.move[i + 12].field_0x0 = 0.0f; + field_0x16c.move[i + 12].field_0x4 = 0.0f; + } + field_0x16c.move[5].field_0x0 = 0.0f; + field_0x16c.move[5].field_0x4 = 0.0f; +} + +static void dummy() { + OSReport("i >= 0"); + OSReport("i < 3"); } /* 802811DC-80281258 .text connectBus__Q28JASystem6TTrackFii */ -void JASystem::TTrack::connectBus(int, int) { - /* Nonmatching */ +void JASystem::TTrack::connectBus(int line, int param_2) { + JUT_ASSERT(486, line < (6)); + field_0xf8.field_0x4e[line] = param_2; } /* 80281258-802814AC .text noteOn__Q28JASystem6TTrackFUclllUl */ -void JASystem::TTrack::noteOn(unsigned char, long, long, long, unsigned long) { - /* Nonmatching */ +int JASystem::TTrack::noteOn(u8 param_1, s32 param_2, s32 param_3, s32 param_4, u32 param_5) { + if (field_0x386 && (field_0x37c & 0x40)) { + return -1; + } + noteOff(param_1, 0); + TChannelMgr* r31 = &field_0xf8; + TTrack* parent = mParent; + while (r31->field_0x0 == 0 || r31->field_0x8 == 0) { + if (!parent) { + r31 = &field_0xf8; + break; + } + r31 = &parent->field_0xf8; + parent = parent->mParent; + } + if (field_0x37b == 4) { + JUT_ASSERT(527, mParent != 0); + if (r31 != &mParent->field_0xf8) { + if (moveFreeChannel(r31, &mParent->field_0xf8, 1) != 1) { + OSReport("in Player (NOTE-MODE) ... ボイス借用に失敗しました！！ (%d)\n", r31->field_0x0); + } + r31 = &mParent->field_0xf8; + } + } else if (r31 != &field_0xf8) { + if (moveFreeChannel(r31, &field_0xf8, 1) != 1) { + OSReport("in Player ボイス借用に失敗しました！！ (%d)\n", r31->field_0x0); + } + r31 = &field_0xf8; + } + u8 bankNum = field_0x28c.getBankNumber(); + u8 physNum = BankMgr::getPhysicalNumber(bankNum); + u8 progNum = field_0x28c.getProgramNumber(); + TChannel* channel = BankMgr::noteOn(r31, physNum, progNum, param_2, param_3, param_4); + if (!channel) { + return -1; + } + field_0xb4.setChannel(param_1, channel); + channel->field_0xe8 = param_5; + channel->setPanPower(field_0x28c.field_0x10[0], field_0x28c.field_0x10[1], field_0x28c.field_0x10[2], 0.0f); + overwriteOsc(channel); + if (field_0x374) { + channel->directReleaseOsc(0, field_0x374); + } + return 0; } /* 802814AC-802815DC .text overwriteOsc__Q28JASystem6TTrackFPQ28JASystem8TChannel */ -void JASystem::TTrack::overwriteOsc(JASystem::TChannel*) { +void JASystem::TTrack::overwriteOsc(TChannel* param_1) { /* Nonmatching */ + u32 r28; + for (int i = 0; i < 2; i++) { + u32 var1 = field_0x2fc[i]; + if (var1 == 0x0f) { + continue; + } + r28 = var1 & 3; + if (var1 & 8) { + if (!param_1->isOsc(r28)) { + JUT_WARN(593, "%s", "cannot copy osc"); + continue; + } + param_1->copyOsc(r28, &field_0x2cc[i]); + } else if (var1 & 4) { + void* var4 = field_0x2cc[i].rel_table; + if (!param_1->isOsc(r28)) { + JUT_WARN(603, "%s", "cannot copy osc"); + continue; + } + param_1->copyOsc(r28, &field_0x2cc[i]); + field_0x2cc[i].rel_table = var4; + } + param_1->overwriteOsc(r28, &field_0x2cc[i]); + } } /* 802815DC-8028165C .text noteOff__Q28JASystem6TTrackFUcUs */ -void JASystem::TTrack::noteOff(unsigned char, unsigned short) { - /* Nonmatching */ +bool JASystem::TTrack::noteOff(u8 param_1, u16 param_2) { + TChannel* channel = field_0xb4.getChannel(param_1); + if (!channel) { + return false; + } + if (param_2 == 0) { + channel->stop(0); + } else { + channel->stop(param_2); + } + field_0xb4.releaseChannel(param_1); + return true; } /* 8028165C-802816C4 .text gateOn__Q28JASystem6TTrackFUclll */ -void JASystem::TTrack::gateOn(unsigned char, long, long, long) { - /* Nonmatching */ +int JASystem::TTrack::gateOn(u8 param_1, s32 param_2, s32 param_3, s32 param_4) { + TChannel* channel = field_0xb4.getChannel(param_1); + if (!channel) { + return -1; + } + BankMgr::gateOn(channel, param_2, param_3, param_4); + return 0; } /* 802816C4-80281708 .text checkNoteStop__Q28JASystem6TTrackFl */ -void JASystem::TTrack::checkNoteStop(long) { - /* Nonmatching */ +int JASystem::TTrack::checkNoteStop(s32 param_1) { + TChannel* channel = field_0xb4.getChannel(param_1); + if (channel == NULL) { + return true; + } + return channel->field_0x1 == 0xff; } /* 80281708-802817E4 .text oscSetupFull__Q28JASystem6TTrackFUcUlUl */ -void JASystem::TTrack::oscSetupFull(unsigned char, unsigned long, unsigned long) { +void JASystem::TTrack::oscSetupFull(u8 param_1, u32 param_2, u32 param_3) { /* Nonmatching */ + u32 var1 = (param_1 & 0x10) >> 4; + int var2 = param_1 & 0x0f; + bool var3 = (param_1 & 0x80) >> 7; + bool var4 = param_1 & 0x40; + bool var5 = param_1 & 0x20; + if (var3) { + field_0x2cc[var1] = Player::sEnvelopeDef; + field_0x2cc[var1].field_0x0 = var2; + if (var2 == 1) { + field_0x2cc[var1].field_0x14 = 1.0f; + } + } + if (var4) { + if (param_2 == 0) { + field_0x2cc[var1].table = NULL; + } + field_0x2cc[var1].table = field_0x0.field_0x0 + param_2; + } + if (!var5) { + return; + } + if (param_3 == 0) { + field_0x2cc[var1].rel_table = Player::sRelTable; + } + field_0x2cc[var1].rel_table = field_0x0.field_0x0 + param_2; } /* 802817E4-80281850 .text oscSetupSimpleEnv__Q28JASystem6TTrackFUcUl */ -void JASystem::TTrack::oscSetupSimpleEnv(unsigned char, unsigned long) { - /* Nonmatching */ +void JASystem::TTrack::oscSetupSimpleEnv(u8 param_1, u32 param_2) { + switch (param_1) { + case 0: + field_0x2cc[0] = Player::sEnvelopeDef; + field_0x2cc[0].table = field_0x0.field_0x0 + param_2; + break; + case 1: + field_0x2cc[0].rel_table = field_0x0.field_0x0 + param_2; + break; + } } /* 80281850-80281900 .text updateOscParam__Q28JASystem6TTrackFif */ -void JASystem::TTrack::updateOscParam(int, float) { - /* Nonmatching */ +void JASystem::TTrack::updateOscParam(int param_1, f32 param_2) { + switch (param_1) { + case 6: + field_0x2cc[0].field_0x10 = param_2; + break; + case 7: + field_0x2cc[0].field_0x4 = param_2; + break; + case 8: + field_0x2cc[0].field_0x14 = param_2; + break; + case 9: + field_0x2cc[1].field_0x10 = param_2; + break; + case 10: + field_0x2cc[1].field_0x4 = param_2; + break; + case 11: + field_0x2cc[1].field_0x14 = param_2; + break; + default: + JUT_ASSERT(753, false); + break; + } } /* 80281900-802819D0 .text oscSetupSimple__Q28JASystem6TTrackFUc */ -void JASystem::TTrack::oscSetupSimple(unsigned char) { - /* Nonmatching */ +void JASystem::TTrack::oscSetupSimple(u8 param_1) { + switch (param_1) { + case 0: + field_0x2cc[1] = Player::sVibratoDef; + break; + case 1: + field_0x2cc[0] = Player::sTremoroDef; + break; + case 2: + field_0x2cc[1] = Player::sTremoroDef; + break; + } } /* 802819D0-80281AA4 .text updateTimedParam__Q28JASystem6TTrackFv */ @@ -127,7 +466,7 @@ void JASystem::TTrack::updateTrackAll() { } /* 80281E90-80282364 .text updateTrack__Q28JASystem6TTrackFUl */ -void JASystem::TTrack::updateTrack(unsigned long) { +void JASystem::TTrack::updateTrack(u32) { /* Nonmatching */ } @@ -137,32 +476,38 @@ void JASystem::TTrack::updateTempo() { } /* 802824C0-802825A0 .text updateSeq__Q28JASystem6TTrackFUlb */ -void JASystem::TTrack::updateSeq(unsigned long, bool) { +void JASystem::TTrack::updateSeq(u32, bool) { /* Nonmatching */ } /* 802825A0-8028265C .text seqTimeToDspTime__Q28JASystem6TTrackFlUc */ -void JASystem::TTrack::seqTimeToDspTime(long, unsigned char) { +int JASystem::TTrack::seqTimeToDspTime(s32, u8) { /* Nonmatching */ } /* 8028265C-8028278C .text setParam__Q28JASystem6TTrackFifi */ -void JASystem::TTrack::setParam(int, float, int) { +void JASystem::TTrack::setParam(int, f32, int) { /* Nonmatching */ } /* 8028278C-802827F0 .text setSeqData__Q28JASystem6TTrackFPUcli */ -void JASystem::TTrack::setSeqData(unsigned char*, long, int) { +bool JASystem::TTrack::setSeqData(u8* param_1, s32, int) { /* Nonmatching */ + init(); + field_0x37b = 3; + field_0x0.start(param_1, 0); + updateTrackAll(); + field_0x37e = 2; + return true; } /* 802827F0-802828A8 .text startSeq__Q28JASystem6TTrackFv */ -void JASystem::TTrack::startSeq() { +bool JASystem::TTrack::startSeq() { /* Nonmatching */ } /* 802828A8-80282908 .text stopSeq__Q28JASystem6TTrackFv */ -void JASystem::TTrack::stopSeq() { +bool JASystem::TTrack::stopSeq() { /* Nonmatching */ } @@ -177,7 +522,7 @@ void JASystem::TTrack::noteOffAll() { } /* 802829DC-80282A90 .text close__Q28JASystem6TTrackFv */ -void JASystem::TTrack::close() { +int JASystem::TTrack::close() { /* Nonmatching */ } @@ -187,77 +532,95 @@ void JASystem::TTrack::muteTrack(bool) { } /* 80282B44-80282B84 .text start__Q28JASystem6TTrackFPvUl */ -void JASystem::TTrack::start(void*, unsigned long) { +bool JASystem::TTrack::start(void* param_1, u32 param_2) { /* Nonmatching */ + field_0x0.start(param_1, param_2); + field_0x37e = 1; + updateTrackAll(); + return false; } /* 80282B84-80282CE8 .text openChild__Q28JASystem6TTrackFUcUc */ -void JASystem::TTrack::openChild(unsigned char, unsigned char) { +JASystem::TTrack* JASystem::TTrack::openChild(u8, u8) { /* Nonmatching */ } /* 80282CE8-80282D80 .text loadTbl__Q28JASystem6TTrackFUlUlUl */ -void JASystem::TTrack::loadTbl(unsigned long, unsigned long, unsigned long) { +int JASystem::TTrack::loadTbl(u32 param_1, u32 param_2, u32 param_3) { /* Nonmatching */ + switch (param_3) { + case 4: + return field_0x0.field_0x0[param_1 + param_2]; + case 5: + return field_0x0.get16(param_1 + param_2 * 2); + case 6: + return field_0x0.get24(param_1 + param_2 * 3); + case 7: + return field_0x0.get32(param_1 + param_2 * 4); + case 8: + return field_0x0.get32(param_1 + param_2); + } } /* 80282D80-80282DC0 .text exchangeRegisterValue__Q28JASystem6TTrackFUc */ -void JASystem::TTrack::exchangeRegisterValue(unsigned char) { +int JASystem::TTrack::exchangeRegisterValue(u8) { /* Nonmatching */ } /* 80282DC0-80282ED4 .text readReg32__Q28JASystem6TTrackFUc */ -void JASystem::TTrack::readReg32(unsigned char) { +void JASystem::TTrack::readReg32(u8) { /* Nonmatching */ } /* 80282ED4-802830AC .text readReg16__Q28JASystem6TTrackFUc */ -void JASystem::TTrack::readReg16(unsigned char) { +void JASystem::TTrack::readReg16(u8) { /* Nonmatching */ } /* 802830AC-80283164 .text writeRegDirect__Q28JASystem6TTrackFUcUs */ -void JASystem::TTrack::writeRegDirect(unsigned char, unsigned short) { +void JASystem::TTrack::writeRegDirect(u8, u16) { /* Nonmatching */ } /* 80283164-802836FC .text writeRegParam__Q28JASystem6TTrackFUc */ -void JASystem::TTrack::writeRegParam(unsigned char) { +void JASystem::TTrack::writeRegParam(u8) { /* Nonmatching */ } /* 802836FC-80283720 .text readSelfPort__Q28JASystem6TTrackFi */ -void JASystem::TTrack::readSelfPort(int) { +u16 JASystem::TTrack::readSelfPort(int param_1) { /* Nonmatching */ + return field_0x48.readImport(param_1); } /* 80283720-80283744 .text writeSelfPort__Q28JASystem6TTrackFiUs */ -void JASystem::TTrack::writeSelfPort(int, unsigned short) { +void JASystem::TTrack::writeSelfPort(int param_1, u16 param_2) { /* Nonmatching */ + field_0x48.writeExport(param_1, param_2); } /* 80283744-802837AC .text writePortAppDirect__Q28JASystem6TTrackFUlUs */ -void JASystem::TTrack::writePortAppDirect(unsigned long, unsigned short) { +int JASystem::TTrack::writePortAppDirect(u32, u16) { /* Nonmatching */ } /* 802837AC-802837E4 .text readPortAppDirect__Q28JASystem6TTrackFUlPUs */ -void JASystem::TTrack::readPortAppDirect(unsigned long, unsigned short*) { +int JASystem::TTrack::readPortAppDirect(u32, u16*) { /* Nonmatching */ } /* 802837E4-8028381C .text routeTrack__Q28JASystem6TTrackFUl */ -void JASystem::TTrack::routeTrack(unsigned long) { +void JASystem::TTrack::routeTrack(u32) { /* Nonmatching */ } /* 8028381C-80283870 .text writePortApp__Q28JASystem6TTrackFUlUs */ -void JASystem::TTrack::writePortApp(unsigned long, unsigned short) { +int JASystem::TTrack::writePortApp(u32, u16) { /* Nonmatching */ } /* 80283870-802838C4 .text readPortApp__Q28JASystem6TTrackFUlPUs */ -void JASystem::TTrack::readPortApp(unsigned long, unsigned short*) { +int JASystem::TTrack::readPortApp(u32, u16*) { /* Nonmatching */ } @@ -267,67 +630,98 @@ void JASystem::TTrack::pause(bool, bool) { } /* 80283A64-80283AB4 .text getTranspose__Q28JASystem6TTrackCFv */ -void JASystem::TTrack::getTranspose() const { +int JASystem::TTrack::getTranspose() const { /* Nonmatching */ } /* 80283AB4-80283AF0 .text setTempo__Q28JASystem6TTrackFUs */ -void JASystem::TTrack::setTempo(unsigned short) { +void JASystem::TTrack::setTempo(u16) { /* Nonmatching */ } /* 80283AF0-80283B20 .text setTimebase__Q28JASystem6TTrackFUs */ -void JASystem::TTrack::setTimebase(unsigned short) { +void JASystem::TTrack::setTimebase(u16) { /* Nonmatching */ } /* 80283B20-80283BBC .text panCalc__Q28JASystem6TTrackFfffUc */ -void JASystem::TTrack::panCalc(float, float, float, unsigned char) { +f32 JASystem::TTrack::panCalc(f32, f32, f32, u8) { /* Nonmatching */ } /* 80283BBC-80283C9C .text rootCallback__Q28JASystem6TTrackFPv */ -void JASystem::TTrack::rootCallback(void*) { +int JASystem::TTrack::rootCallback(void*) { /* Nonmatching */ } /* 80283C9C-80283CE8 .text registerSeqCallback__Q28JASystem6TTrackFPFPQ28JASystem6TTrackUs_Us */ -void JASystem::TTrack::registerSeqCallback(unsigned short (*)(JASystem::TTrack*, unsigned short)) { +void JASystem::TTrack::registerSeqCallback(u16 (*param_1)(TTrack*, u16)) { /* Nonmatching */ + if (sCallBackFunc) { + OSReport("in Player ... overwrite callback\n"); + } + sCallBackFunc = param_1; } /* 80283CE8-80283E9C .text newMemPool__Q28JASystem6TTrackFi */ -void JASystem::TTrack::newMemPool(int) { +void JASystem::TTrack::newMemPool(int param_1) { /* Nonmatching */ + TTrack* runner = (TTrack*)new (JASDram, 0) u8[sizeof(TTrack)]; + JUT_ASSERT(2218, runner); + TOuterParam* outer = new (JASDram, 0) TOuterParam(); + JUT_ASSERT(2220, outer); + runner->assignExtBuffer(outer); + sFreeList = runner; + for (int i = 1; i < param_1; i++) { + runner->next = (TTrack*)new (JASDram, 0) u8[sizeof(TTrack)]; + JUT_ASSERT(2228, runner->next); + TOuterParam* outer = new (JASDram, 0) TOuterParam(); + JUT_ASSERT(2230, outer); + runner->next->assignExtBuffer(outer); + runner = runner->next; + } + runner->next = NULL; } /* 80283E9C-80283ECC .text __ct__Q28JASystem8TVibrateFv */ JASystem::TVibrate::TVibrate() { /* Nonmatching */ + init(); } /* 80283ECC-80283EE4 .text init__Q28JASystem8TVibrateFv */ void JASystem::TVibrate::init() { /* Nonmatching */ + field_0x8 = 1.0f / 18.0f; + field_0x4 = 0.0f; + field_0x0 = 0.0f; } /* 80283EE4-80283F18 .text incCounter__Q28JASystem8TVibrateFv */ void JASystem::TVibrate::incCounter() { /* Nonmatching */ + field_0x0 += field_0x8; + if (!(field_0x0 >= 4.0)) { + return; + } + field_0x0 -= 4.0f; } /* 80283F18-80283FD0 .text getValue__Q28JASystem8TVibrateCFv */ -void JASystem::TVibrate::getValue() const { +f32 JASystem::TVibrate::getValue() const { /* Nonmatching */ } /* 80283FD0-80283FE8 .text __ct__Q38JASystem6TTrack10MoveParam_Fv */ JASystem::TTrack::MoveParam_::MoveParam_() { /* Nonmatching */ + field_0x0 = 0.0f; + field_0x4 = 0.0f; + field_0x8 = 0.0f; + field_0xc = 0.0f; } /* 80283FE8-80284118 .text __ct__Q38JASystem6TTrack12AInnerParam_Fv */ JASystem::TTrack::AInnerParam_::AInnerParam_() { /* Nonmatching */ } -