From 004d5929c44affdb8aa4d1b4bab21853eeabd808 Mon Sep 17 00:00:00 2001 From: LagoLunatic Date: Wed, 17 Jul 2024 20:25:55 -0400 Subject: [PATCH] JASSeqParser work --- include/JSystem/JAudio/JASChannelMgr.h | 2 +- include/JSystem/JAudio/JASRegisterParam.h | 22 +- include/JSystem/JAudio/JASSeqCtrl.h | 47 +- include/JSystem/JAudio/JASSeqParser.h | 8 +- include/JSystem/JAudio/JASTrack.h | 108 +-- include/JSystem/JAudio/JASTrackPort.h | 12 +- include/JSystem/JSupport/JSupport.h | 2 +- src/JSystem/JAudio/JASChannel.cpp | 2 +- src/JSystem/JAudio/JASChannelMgr.cpp | 6 +- src/JSystem/JAudio/JASRegisterParam.cpp | 58 +- src/JSystem/JAudio/JASSeqCtrl.cpp | 52 +- src/JSystem/JAudio/JASSeqParser.cpp | 758 ++++++++++++++++++---- src/JSystem/JAudio/JASTrack.cpp | 204 +++--- src/JSystem/JAudio/JASTrackPort.cpp | 22 +- 14 files changed, 923 insertions(+), 380 deletions(-) diff --git a/include/JSystem/JAudio/JASChannelMgr.h b/include/JSystem/JAudio/JASChannelMgr.h index cab79bd15..d6978fcad 100644 --- a/include/JSystem/JAudio/JASChannelMgr.h +++ b/include/JSystem/JAudio/JASChannelMgr.h @@ -43,7 +43,7 @@ namespace JASystem { /* 0x5A */ u8 field_0x5a[6]; /* 0x60 */ u8 field_0x60; /* 0x61 */ u8 field_0x61; - /* 0x62 */ u8 field_0x62[3]; + /* 0x62 */ u8 mCalcTypes[3]; /* 0x68 */ int field_0x68; /* 0x6C */ u16 field_0x6c; /* 0x70 */ int field_0x70; diff --git a/include/JSystem/JAudio/JASRegisterParam.h b/include/JSystem/JAudio/JASRegisterParam.h index 5f3b6378d..e49b28abc 100644 --- a/include/JSystem/JAudio/JASRegisterParam.h +++ b/include/JSystem/JAudio/JASRegisterParam.h @@ -12,15 +12,23 @@ namespace JASystem { u8 getBankNumber() const; u8 getProgramNumber() const; - /* 0x00 */ short field_0x0; - /* 0x02 */ short field_0x2; - /* 0x04 */ short field_0x4; - /* 0x06 */ short field_0x6; - /* 0x08 */ short field_0x8; - /* 0x0A */ short field_0xa; + void getAddress(int) const {} + void getBendSense() const {} + void getFlag() const {} + void getPanPowerBank() const {} + void getPanPowerExt() const {} + void getPanPowerOsc() const {} + void getPanPowerParent() const {} + void getPanPowerTrack() const {} + void getPriority() const {} + void setAddress(int, u32) {} + void setFlag(u16) {} + void setPanPower(int i, u16 power) { mPanPower[i] = power; } + + /* 0x00 */ u16 field_0x0[6]; /* 0x0C */ u16 field_0xc; /* 0x0E */ u16 field_0xe; - /* 0x10 */ u16 field_0x10[5]; + /* 0x10 */ u16 mPanPower[5]; /* 0x1A */ u16 field_0x1a; /* 0x1C */ int field_0x1c; /* 0x20 */ int field_0x20; diff --git a/include/JSystem/JAudio/JASSeqCtrl.h b/include/JSystem/JAudio/JASSeqCtrl.h index 8cf93ee96..ba10062ae 100644 --- a/include/JSystem/JAudio/JASSeqCtrl.h +++ b/include/JSystem/JAudio/JASSeqCtrl.h @@ -8,19 +8,32 @@ namespace JASystem { class TSeqCtrl { public: - void call(u32) {} - void clrIntr() {} - void getAddr(u32) {} - void getBase() {} - u8 getByte(u32 offset) const { return field_0x0[offset]; } + void call(u32 offset) { + mLoopStartPositions[mLoopIndex++] = mCurrentFilePtr; + mCurrentFilePtr = mRawFilePtr + offset; + } + void clrIntr() { mPreviousFilePtr = 0; } + u8* getAddr(u32 offset) { return mRawFilePtr + offset; } + u8* getBase() { return mRawFilePtr; } + u8 getByte(u32 offset) const { return mRawFilePtr[offset]; } void getLoopCount() const {} void getWait() const {} void isIntr() const {} - void jump(u32) {} - void loopStart(u32) {} - u8 readByte() { return *field_0x4++; } - void ret() {} - void wait(s32) {} + void jump(u32 offset) { + mCurrentFilePtr = mRawFilePtr + offset; + } + void loopStart(u32 timer) { + mLoopStartPositions[mLoopIndex] = mCurrentFilePtr; + mLoopTimers[mLoopIndex++] = timer; + } + u8 readByte() { return *mCurrentFilePtr++; } + bool ret() { + mCurrentFilePtr = mLoopStartPositions[--mLoopIndex]; + return true; + } + void wait(s32 timer) { + mWaitTimer = timer; + } void init(); void start(void*, u32); @@ -34,14 +47,14 @@ namespace JASystem { u32 read16(); u32 read24(); - /* 0x00 */ u8* field_0x0; - /* 0x04 */ u8* field_0x4; - /* 0x08 */ int field_0x8; - /* 0x0C */ u32 field_0xc; - /* 0x10 */ u8* field_0x10[8]; - /* 0x30 */ u16 field_0x30[8]; + /* 0x00 */ u8* mRawFilePtr; + /* 0x04 */ u8* mCurrentFilePtr; + /* 0x08 */ int mWaitTimer; + /* 0x0C */ u32 mLoopIndex; + /* 0x10 */ u8* mLoopStartPositions[8]; + /* 0x30 */ u16 mLoopTimers[8]; /* 0x40 */ int field_0x40; - /* 0x44 */ u8* field_0x44; + /* 0x44 */ u8* mPreviousFilePtr; }; } diff --git a/include/JSystem/JAudio/JASSeqParser.h b/include/JSystem/JAudio/JASSeqParser.h index 8f8aeb2fa..5a9cb3898 100644 --- a/include/JSystem/JAudio/JASSeqParser.h +++ b/include/JSystem/JAudio/JASSeqParser.h @@ -59,17 +59,19 @@ namespace JASystem { 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 Cmd_Process(TTrack*, u8, u16); + int 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*); + int parseSeq(TTrack*); static int (TSeqParser::*sCmdPList[])(TTrack*, u32*); }; + + extern const u16 Arglist[0x40][2]; } #endif /* JASSEQPARSER_H */ diff --git a/include/JSystem/JAudio/JASTrack.h b/include/JSystem/JAudio/JASTrack.h index 24ac75c2e..08e5daef3 100644 --- a/include/JSystem/JAudio/JASTrack.h +++ b/include/JSystem/JAudio/JASTrack.h @@ -38,13 +38,38 @@ namespace JASystem { void incCounter(); f32 getValue() const; + void setDepth(f32 depth) { mDepth = depth; } + void setPitch(f32 pitch) { mPitch = pitch; } + /* 0x00 */ f32 field_0x0; - /* 0x04 */ f32 field_0x4; - /* 0x08 */ f32 field_0x8; + /* 0x04 */ f32 mDepth; + /* 0x08 */ f32 mPitch; }; class TTrack { public: + enum TimedParamType { + TIMED_Volume = 0, + TIMED_Pitch = 1, + TIMED_Fxmix = 2, + TIMED_Pan = 3, + TIMED_Dolby = 4, + TIMED_Unk5 = 5, + TIMED_Osc0_Width = 6, + TIMED_Osc0_Rate = 7, + TIMED_Osc0_Vertex = 8, + TIMED_Osc1_Width = 9, + TIMED_Osc1_Rate = 10, + TIMED_Osc1_Vertex = 11, + TIMED_IIR_Unk0 = 12, + TIMED_IIR_Unk1 = 13, + TIMED_IIR_Unk2 = 14, + TIMED_IIR_Unk3 = 15, + TIMED_Unk16 = 16, + TIMED_Unk17 = 17, + TIMED_Count, // 18 + }; + class TOuterParam { public: TOuterParam(); @@ -73,17 +98,18 @@ namespace JASystem { public: MoveParam_(); - /* 0x00 */ f32 field_0x0; - /* 0x04 */ f32 field_0x4; - /* 0x08 */ f32 field_0x8; - /* 0x0C */ f32 field_0xc; + /* 0x00 */ f32 mCurrentValue; + /* 0x04 */ f32 mTargetValue; + /* 0x08 */ f32 mMoveTime; + /* 0x0C */ f32 mMoveAmount; }; class AInnerParam_ { public: AInnerParam_(); - /* 0x000 */ f32 field_0x0[48]; + /* 0x000 */ MoveParam_ mIIRs[4]; + /* 0x010 */ f32 field_0x10[32]; /* 0x0C0 */ MoveParam_ field_0xc0[4]; /* 0x100 */ f32 field_0x100[8]; }; @@ -93,8 +119,8 @@ namespace JASystem { TimedParam_(); union { - AInnerParam_ inner; - MoveParam_ move[18]; + AInnerParam_ mInnerParam; + MoveParam_ mMoveParams[TIMED_Count]; }; }; @@ -106,12 +132,12 @@ namespace JASystem { 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; + /* 0x00 */ TChannel* field_0x0[8]; + /* 0x20 */ u16 field_0x20[8]; + /* 0x30 */ int field_0x30; + /* 0x34 */ u8 field_0x34; + /* 0x35 */ u8 field_0x35; + /* 0x36 */ u8 field_0x36; }; static const int MAX_CHILDREN = 16; @@ -155,8 +181,8 @@ namespace JASystem { TTrack* openChild(u8, u8); int loadTbl(u32, u32, u32); int exchangeRegisterValue(u8); - void readReg32(u8); - void readReg16(u8); + u32 readReg32(u8); + u16 readReg16(u8); void writeRegDirect(u8, u16); void writeRegParam(u8); u16 readSelfPort(int); @@ -184,53 +210,53 @@ namespace JASystem { TOuterParam* getOuterParam() { return mOuterParam; } - void checkExport(int) const {} - void checkImport(int) const {} + bool checkImport(int i) const { return mTrackPort.checkImport(i); } + bool checkExport(int i) const { return mTrackPort.checkExport(i); } void getActivity() const {} void getRoute() const {} - void getSeq() {} + TSeqCtrl* getSeq() { return &mSeqCtrl; } // void operator delete(void*, u32) {} // void* operator new(size_t) {} void pauseTrackAll() {} - void setPanPower(int, u16) {} + void setPanPower(int i, u16 power) { mRegisterParam.setPanPower(i, power); } void setPauseStatus(u8) {} - void setTranspose(s32) {} - void setVolumeMode(u8) {} + void setTranspose(s32 transpose) { field_0x37a = transpose; } + void setVolumeMode(u8 mode) { mVolumeMode = mode; } void unPauseTrackAll() {} /* 0x000 */ union { - TSeqCtrl field_0x0; + TSeqCtrl mSeqCtrl; TTrack* next; }; - /* 0x048 */ TTrackPort field_0x48; + /* 0x048 */ TTrackPort mTrackPort; /* 0x088 */ TIntrMgr field_0x88; - /* 0x0B4 */ TNoteMgr field_0xb4; - /* 0x0EC */ TVibrate field_0xec; - /* 0x0F8 */ TChannelMgr field_0xf8; - /* 0x16C */ TimedParam_ field_0x16c; - /* 0x28C */ TRegisterParam field_0x28c; + /* 0x0B4 */ TNoteMgr mNoteMgr; + /* 0x0EC */ TVibrate mVibrate; + /* 0x0F8 */ TChannelMgr mChannelUpdater; + /* 0x16C */ TimedParam_ mTimedParam; + /* 0x28C */ TRegisterParam mRegisterParam; /* 0x2BC */ u8 field_0x2bc[0x2cc - 0x2bc]; /* 0x2CC */ TOscillator::Osc_ field_0x2cc[2]; - /* 0x2FC */ u32 field_0x2fc[2]; - /* 0x304 */ short field_0x304[12]; + /* 0x2FC */ u32 mOscRoute[2]; + /* 0x304 */ s16 field_0x304[12]; /* 0x31C */ TTrack* mParent; /* 0x320 */ TTrack* mChildren[MAX_CHILDREN]; /* 0x360 */ TOuterParam* mOuterParam; /* 0x364 */ f32 field_0x364; /* 0x368 */ f32 field_0x368; /* 0x36C */ int field_0x36c; - /* 0x370 */ int field_0x370; + /* 0x370 */ u32 mUpdateFlags; /* 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; + /* 0x37A */ u8 field_0x37a; + /* 0x37B */ u8 field_0x37b; + /* 0x37C */ u8 mPauseStatus; + /* 0x37D */ u8 mVolumeMode; + /* 0x37E */ u8 field_0x37e; + /* 0x37F */ u8 mCalcTypes[3]; + /* 0x382 */ u8 mParentCalcTypes[3]; + /* 0x385 */ u8 mIsPaused; /* 0x386 */ u8 field_0x386; /* 0x387 */ bool field_0x387; /* 0x388 */ u8 field_0x388; diff --git a/include/JSystem/JAudio/JASTrackPort.h b/include/JSystem/JAudio/JASTrackPort.h index dfb990a14..4fb8856d5 100644 --- a/include/JSystem/JAudio/JASTrackPort.h +++ b/include/JSystem/JAudio/JASTrackPort.h @@ -3,6 +3,8 @@ #include "dolphin/types.h" +#define TRACKPORT_MAX (16) + namespace JASystem { class TTrackPort { public: @@ -12,9 +14,13 @@ namespace JASystem { void writeImport(int, u16); void writeExport(int, u16); - /* 0x00 */ u8 field_0x0[16]; - /* 0x10 */ u8 field_0x10[16]; - /* 0x20 */ u16 field_0x20[16]; + bool checkImport(int i) const { return mImportFlag[i] != 0; } + bool checkExport(int i) const { return mExportFlag[i] != 0; } + u16 get(u32 i) { return mValue[i]; } + + /* 0x00 */ u8 mImportFlag[TRACKPORT_MAX]; + /* 0x10 */ u8 mExportFlag[TRACKPORT_MAX]; + /* 0x20 */ u16 mValue[TRACKPORT_MAX]; }; } diff --git a/include/JSystem/JSupport/JSupport.h b/include/JSystem/JSupport/JSupport.h index fbdde1f91..6d9a0c1df 100644 --- a/include/JSystem/JSupport/JSupport.h +++ b/include/JSystem/JSupport/JSupport.h @@ -20,7 +20,7 @@ T* JSUConvertOffsetToPtr(const void* ptr, const void* offset) { } inline u8 JSULoNibble(u8 param_0) { return param_0 & 0x0f; } -inline u8 JSUHiNibble(u8 param_0) {return param_0 >> 4; } +inline u8 JSUHiNibble(u8 param_0) {return (param_0 & 0xff) >> 4; } inline u8 JSULoByte(u16 in) { return in & 0xff; diff --git a/src/JSystem/JAudio/JASChannel.cpp b/src/JSystem/JAudio/JASChannel.cpp index f22220b96..18a9ae3b9 100644 --- a/src/JSystem/JAudio/JASChannel.cpp +++ b/src/JSystem/JAudio/JASChannel.cpp @@ -42,7 +42,7 @@ void JASystem::TChannel::init() { field_0x48 = field_0x4->field_0x68; field_0x4c = field_0x4->field_0x6c; for (int i = 0; i < 3; i++) { - field_0x60[i] = field_0x4->field_0x62[i]; + field_0x60[i] = field_0x4->mCalcTypes[i]; } } for (u32 i = 0; i < 4; i++) { diff --git a/src/JSystem/JAudio/JASChannelMgr.cpp b/src/JSystem/JAudio/JASChannelMgr.cpp index b55ec9f19..0a0e5dffc 100644 --- a/src/JSystem/JAudio/JASChannelMgr.cpp +++ b/src/JSystem/JAudio/JASChannelMgr.cpp @@ -45,9 +45,9 @@ void JASystem::TChannelMgr::init() { field_0x4e[5] = 0; field_0x68 = 0x20103; field_0x6c = 600; - field_0x62[0] = 13; - field_0x62[1] = 13; - field_0x62[2] = 13; + mCalcTypes[0] = 13; + mCalcTypes[1] = 13; + mCalcTypes[2] = 13; } /* 8028D4D0-8028D514 .text stopAll__Q28JASystem11TChannelMgrFv */ diff --git a/src/JSystem/JAudio/JASRegisterParam.cpp b/src/JSystem/JAudio/JASRegisterParam.cpp index 7bff29b3a..6445c135d 100644 --- a/src/JSystem/JAudio/JASRegisterParam.cpp +++ b/src/JSystem/JAudio/JASRegisterParam.cpp @@ -8,20 +8,20 @@ /* 8027E2C0-8027E310 .text __ct__Q28JASystem14TRegisterParamFv */ JASystem::TRegisterParam::TRegisterParam() { - field_0x0 = 0; - field_0x2 = 0; - field_0x4 = 0; - field_0x6 = 0; - field_0x8 = 0; - field_0xa = 0; + field_0x0[0] = 0; + field_0x0[1] = 0; + field_0x0[2] = 0; + field_0x0[3] = 0; + field_0x0[4] = 0; + field_0x0[5] = 0; field_0xc = 0; field_0xe = 0; field_0x1a = 0; - field_0x10[0] = 0; - field_0x10[1] = 0; - field_0x10[2] = 0; - field_0x10[3] = 0; - field_0x10[4] = 0; + mPanPower[0] = 0; + mPanPower[1] = 0; + mPanPower[2] = 0; + mPanPower[3] = 0; + mPanPower[4] = 0; field_0x20 = 0; field_0x24 = 0; field_0x28 = 0; @@ -30,20 +30,20 @@ JASystem::TRegisterParam::TRegisterParam() { /* 8027E310-8027E378 .text init__Q28JASystem14TRegisterParamFv */ void JASystem::TRegisterParam::init() { - field_0x0 = 0; - field_0x2 = 0; - field_0x4 = 0; - field_0x6 = 0; - field_0x8 = 0; - field_0xa = 0; + field_0x0[0] = 0; + field_0x0[1] = 0; + field_0x0[2] = 0; + field_0x0[3] = 0; + field_0x0[4] = 0; + field_0x0[5] = 0; field_0xc = 0xf0; field_0xe = 0x0c; field_0x1a = 0x40; - field_0x10[0] = 0; - field_0x10[1] = 1; - field_0x10[2] = 1; - field_0x10[3] = 0x7fff; - field_0x10[4] = 0x4000; + mPanPower[0] = 0; + mPanPower[1] = 1; + mPanPower[2] = 1; + mPanPower[3] = 0x7fff; + mPanPower[4] = 0x4000; field_0x20 = 0; field_0x24 = 0; field_0x28 = 0; @@ -52,17 +52,17 @@ void JASystem::TRegisterParam::init() { /* 8027E378-8027E3E0 .text inherit__Q28JASystem14TRegisterParamFRCQ28JASystem14TRegisterParam */ void JASystem::TRegisterParam::inherit(const JASystem::TRegisterParam& param_1) { - field_0x0 = 0; - field_0x2 = 0; - field_0x4 = 0; - field_0x6 = 0; - field_0x8 = 0; - field_0xa = 0; + field_0x0[0] = 0; + field_0x0[1] = 0; + field_0x0[2] = 0; + field_0x0[3] = 0; + field_0x0[4] = 0; + field_0x0[5] = 0; field_0xc = param_1.field_0xc; field_0xe = param_1.field_0xe; field_0x1a = param_1.field_0x1a; for (int i = 0; i < 5; i++) { - field_0x10[i] = param_1.field_0x10[i]; + mPanPower[i] = param_1.mPanPower[i]; } field_0x20 = 0; field_0x24 = 0; diff --git a/src/JSystem/JAudio/JASSeqCtrl.cpp b/src/JSystem/JAudio/JASSeqCtrl.cpp index 2fcf74fb3..4bd977b14 100644 --- a/src/JSystem/JAudio/JASSeqCtrl.cpp +++ b/src/JSystem/JAudio/JASSeqCtrl.cpp @@ -8,49 +8,49 @@ /* 8027E3F8-8027E448 .text init__Q28JASystem8TSeqCtrlFv */ void JASystem::TSeqCtrl::init() { - field_0x0 = NULL; - field_0x4 = NULL; - field_0x8 = 0; - field_0xc = 0; + mRawFilePtr = NULL; + mCurrentFilePtr = NULL; + mWaitTimer = 0; + mLoopIndex = 0; for (int i = 0; i < 8; i++) { - field_0x10[i] = NULL; - field_0x30[i] = 0; + mLoopStartPositions[i] = NULL; + mLoopTimers[i] = 0; } field_0x40 = 0; - field_0x44 = NULL; + mPreviousFilePtr = NULL; } /* 8027E448-8027E45C .text start__Q28JASystem8TSeqCtrlFPvUl */ void JASystem::TSeqCtrl::start(void* param_1, u32 param_2) { - field_0x0 = (u8*)param_1; - field_0x4 = field_0x0 + param_2; + mRawFilePtr = (u8*)param_1; + mCurrentFilePtr = mRawFilePtr + param_2; } /* 8027E45C-8027E500 .text loopEnd__Q28JASystem8TSeqCtrlFv */ int JASystem::TSeqCtrl::loopEnd() { - u32 var1 = field_0xc; + u32 var1 = mLoopIndex; if (var1 == 0) { JUT_WARN(45, "%s", "cannot loopE for call-stack is NULL"); return 0; } - u16 var3 = field_0x30[var1 - 1]; + u16 var3 = mLoopTimers[var1 - 1]; if (var3) { var3--; } if (var3 == 0) { - field_0xc--; + mLoopIndex--; return true; } - field_0x30[var1 - 1] = var3; - field_0x4 = field_0x10[field_0xc - 1]; + mLoopTimers[var1 - 1] = var3; + mCurrentFilePtr = mLoopStartPositions[mLoopIndex - 1]; return true; } /* 8027E500-8027E530 .text waitCountDown__Q28JASystem8TSeqCtrlFv */ bool JASystem::TSeqCtrl::waitCountDown() { - if (field_0x8 > 0) { - field_0x8--; - if (field_0x8) { + if (mWaitTimer > 0) { + mWaitTimer--; + if (mWaitTimer) { return false; } } @@ -59,24 +59,24 @@ bool JASystem::TSeqCtrl::waitCountDown() { /* 8027E530-8027E568 .text callIntr__Q28JASystem8TSeqCtrlFPv */ bool JASystem::TSeqCtrl::callIntr(void* param_1) { - if (field_0x44) { + if (mPreviousFilePtr) { return false; } - field_0x44 = field_0x4; - field_0x4 = (u8*)param_1; - field_0x40 = field_0x8; - field_0x8 = 0; + mPreviousFilePtr = mCurrentFilePtr; + mCurrentFilePtr = (u8*)param_1; + field_0x40 = mWaitTimer; + mWaitTimer = 0; return true; } /* 8027E568-8027E59C .text retIntr__Q28JASystem8TSeqCtrlFv */ bool JASystem::TSeqCtrl::retIntr() { - if (!field_0x44) { + if (!mPreviousFilePtr) { return false; } - field_0x8 = field_0x40; - field_0x4 = field_0x44; - field_0x44 = NULL; + mWaitTimer = field_0x40; + mCurrentFilePtr = mPreviousFilePtr; + mPreviousFilePtr = NULL; return true; } diff --git a/src/JSystem/JAudio/JASSeqParser.cpp b/src/JSystem/JAudio/JASSeqParser.cpp index 39419367d..efd5cda8b 100644 --- a/src/JSystem/JAudio/JASSeqParser.cpp +++ b/src/JSystem/JAudio/JASSeqParser.cpp @@ -6,14 +6,14 @@ #include "JSystem/JAudio/JASSeqParser.h" #include "JSystem/JAudio/JASPlayer.h" #include "JSystem/JAudio/JASTrack.h" +#include "JSystem/JAudio/JASChannel.h" #include "JSystem/JSupport/JSupport.h" #include "JSystem/JUtility/JUTAssert.h" /* 8027E680-8027E728 .text cmdOpenTrack__Q28JASystem10TSeqParserFPQ28JASystem6TTrackPUl */ -int JASystem::TSeqParser::cmdOpenTrack(TTrack* track, u32* params) { - /* Nonmatching */ - u32 param1 = params[0]; - u32 param2 = params[1]; +int JASystem::TSeqParser::cmdOpenTrack(TTrack* track, u32* args) { + u32 param1 = args[0]; + u32 param2 = args[1]; u8 b1 = param1 & 0xF; u8 b2 = (param1 >> 6) & 3; if (param1 & 0x20) { @@ -21,19 +21,18 @@ int JASystem::TSeqParser::cmdOpenTrack(TTrack* track, u32* params) { } TTrack* child = track->openChild(b1, b2); JUT_ASSERT(255, child); - child->start(track->field_0x0.field_0x0, param2); + child->start(track->getSeq()->getBase(), param2); return 0; } /* 8027E728-8027E800 .text cmdOpenTrackBros__Q28JASystem10TSeqParserFPQ28JASystem6TTrackPUl */ -int JASystem::TSeqParser::cmdOpenTrackBros(TTrack* track, u32* params) { - /* Nonmatching */ +int JASystem::TSeqParser::cmdOpenTrackBros(TTrack* track, u32* args) { if (!track->getParent()) { JUT_WARN(268, "%s", "cannot opentrackB in ROOT Track"); return 0; } - u32 param1 = params[0]; - u32 param2 = params[1]; + u32 param1 = args[0]; + u32 param2 = args[1]; u8 b1 = param1 & 0xF; u8 b2 = (param1 >> 6) & 3; if (param1 & 0x20) { @@ -41,27 +40,48 @@ int JASystem::TSeqParser::cmdOpenTrackBros(TTrack* track, u32* params) { } TTrack* bros = track->getParent()->openChild(b1, b2); JUT_ASSERT(282, bros); - bros->start(track->field_0x0.field_0x0, param2); + bros->start(track->getSeq()->getBase(), param2); return 0; } /* 8027E800-8027E90C .text cmdCall__Q28JASystem10TSeqParserFPQ28JASystem6TTrackPUl */ -int JASystem::TSeqParser::cmdCall(TTrack* track, u32* params) { - /* Nonmatching */ +int JASystem::TSeqParser::cmdCall(TTrack* track, u32* args) { + u8 flag = track->getSeq()->readByte(); + + u32 data; + if (flag & 0x80) { + u8 cData = track->getSeq()->readByte(); + data = track->readReg16(cData); + + if (flag & 0x40) { + u32 offs; + if (flag & 0x20) { + cData = track->getSeq()->readByte(); + offs = track->readReg16(cData); + } else { + offs = track->getSeq()->read24(); + } + data = track->getSeq()->get24(offs + data * 3); + } + } else { + data = track->getSeq()->read24(); + } + + if (conditionCheck(track, flag)) { + track->getSeq()->call(data); + } + return 0; } /* 8027E90C-8027E9AC .text cmdRet__Q28JASystem10TSeqParserFPQ28JASystem6TTrackPUl */ -int JASystem::TSeqParser::cmdRet(TTrack* track, u32* params) { - if (conditionCheck(track, params[0])) { - u32 var1 = track->field_0x0.field_0xc; +int JASystem::TSeqParser::cmdRet(TTrack* track, u32* args) { + if (conditionCheck(track, args[0])) { + u32 var1 = track->getSeq()->mLoopIndex; 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; + tmp = track->getSeq()->ret(); } if (!tmp) { JUT_WARN(335, "%s", "cannot ret for call-stack is NULL"); @@ -72,125 +92,159 @@ int JASystem::TSeqParser::cmdRet(TTrack* track, u32* params) { } /* 8027E9AC-8027EAF4 .text cmdJmp__Q28JASystem10TSeqParserFPQ28JASystem6TTrackPUl */ -int JASystem::TSeqParser::cmdJmp(TTrack* track, u32* params) { - /* Nonmatching */ +int JASystem::TSeqParser::cmdJmp(TTrack* track, u32* args) { + u8 flag; + bool usetrackptr = false; + int trackptr = 0; + flag = track->getSeq()->readByte(); + u32 data; + + if (flag & 0x80) { + u8 cData = track->getSeq()->readByte(); + + if (flag & 0x40) { + data = track->readReg16(cData) & 0xffff; + u32 offs; + if (flag & 0x20) { + cData = track->getSeq()->readByte(); + offs = track->readReg16(cData); + } else { + offs = track->getSeq()->read24(); + } + data = track->getSeq()->get24(offs + data * 3); + } else { + if (cData >= 0x28 && 0x2b >= cData) { + trackptr = track->readReg32(cData); + usetrackptr = true; + } else { + data = track->readReg32(cData); + } + } + } else { + data = track->getSeq()->read24(); + } + + if (conditionCheck(track, flag)) { + if (usetrackptr) { + track->getSeq()->start((void*)trackptr, 0); + } else { + track->getSeq()->jump(data); + } + } + return 0; } /* 8027EAF4-8027EB2C .text cmdLoopS__Q28JASystem10TSeqParserFPQ28JASystem6TTrackPUl */ -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; +int JASystem::TSeqParser::cmdLoopS(TTrack* track, u32* args) { + u32 timer = args[0]; + track->getSeq()->loopStart(timer); return 0; } /* 8027EB2C-8027EB54 .text cmdLoopE__Q28JASystem10TSeqParserFPQ28JASystem6TTrackPUl */ -int JASystem::TSeqParser::cmdLoopE(TTrack* track, u32* params) { - track->field_0x0.loopEnd(); +int JASystem::TSeqParser::cmdLoopE(TTrack* track, u32* args) { + track->getSeq()->loopEnd(); return 0; } /* 8027EB54-8027EBAC .text cmdReadPort__Q28JASystem10TSeqParserFPQ28JASystem6TTrackPUl */ -int JASystem::TSeqParser::cmdReadPort(TTrack* track, u32* params) { - track->writeRegDirect(params[1], track->readSelfPort(params[0])); +int JASystem::TSeqParser::cmdReadPort(TTrack* track, u32* args) { + track->writeRegDirect(args[1], track->readSelfPort(args[0])); return 0; } /* 8027EBAC-8027EBE0 .text cmdWritePort__Q28JASystem10TSeqParserFPQ28JASystem6TTrackPUl */ -int JASystem::TSeqParser::cmdWritePort(TTrack* track, u32* params) { - track->writeSelfPort(params[0], params[1]); +int JASystem::TSeqParser::cmdWritePort(TTrack* track, u32* args) { + track->writeSelfPort(args[0], args[1]); return 0; } /* 8027EBE0-8027EC68 .text cmdParentWritePort__Q28JASystem10TSeqParserFPQ28JASystem6TTrackPUl */ -int JASystem::TSeqParser::cmdParentWritePort(TTrack* track, u32* params) { - /* Nonmatching */ +int JASystem::TSeqParser::cmdParentWritePort(TTrack* track, u32* args) { TTrack* parent = track->getParent(); JUT_ASSERT(452, parent != NULL); - parent->writePortAppDirect(params[0] & 0xf, params[1]); + parent->writePortAppDirect(args[0] & 0xf, args[1]); return 0; } /* 8027EC68-8027ED80 .text cmdChildWritePort__Q28JASystem10TSeqParserFPQ28JASystem6TTrackPUl */ -int JASystem::TSeqParser::cmdChildWritePort(TTrack* track, u32* params) { - /* Nonmatching */ - u8 param1 = JSULoByte(params[0]); +int JASystem::TSeqParser::cmdChildWritePort(TTrack* track, u32* args) { + u8 param1 = args[0]; u8 b1 = JSUHiNibble(param1); TTrack* child = track->getChild(b1); JUT_ASSERT(462, child != NULL); - child->writePortAppDirect(JSULoNibble(param1), params[1]); + child->writePortAppDirect(JSULoNibble(param1), args[1]); return 0; } /* 8027ED80-8027ED98 .text cmdCheckPortImport__Q28JASystem10TSeqParserFPQ28JASystem6TTrackPUl */ -int JASystem::TSeqParser::cmdCheckPortImport(TTrack* track, u32* params) { - track->field_0x28c.field_0x6 = track->field_0x48.field_0x0[params[0]]; +int JASystem::TSeqParser::cmdCheckPortImport(TTrack* track, u32* args) { + track->mRegisterParam.field_0x0[3] = track->mTrackPort.mImportFlag[args[0]]; return 0; } /* 8027ED98-8027EDB0 .text cmdCheckPortExport__Q28JASystem10TSeqParserFPQ28JASystem6TTrackPUl */ -int JASystem::TSeqParser::cmdCheckPortExport(TTrack* track, u32* params) { - track->field_0x28c.field_0x6 = track->field_0x48.field_0x10[params[0]]; +int JASystem::TSeqParser::cmdCheckPortExport(TTrack* track, u32* args) { + track->mRegisterParam.field_0x0[3] = track->mTrackPort.mExportFlag[args[0]]; return 0; } /* 8027EDB0-8027EDC4 .text cmdWait__Q28JASystem10TSeqParserFPQ28JASystem6TTrackPUl */ -int JASystem::TSeqParser::cmdWait(TTrack* track, u32* params) { - u32 param1 = params[0]; - track->field_0x0.field_0x8 = param1; +int JASystem::TSeqParser::cmdWait(TTrack* track, u32* args) { + u32 param1 = args[0]; + track->getSeq()->wait(param1); return param1 != 0 ? 1 : 0; } /* 8027EDC4-8027EE44 .text cmdSetLastNote__Q28JASystem10TSeqParserFPQ28JASystem6TTrackPUl */ -int JASystem::TSeqParser::cmdSetLastNote(TTrack* track, u32* params) { - u32 key = params[0]; +int JASystem::TSeqParser::cmdSetLastNote(TTrack* track, u32* args) { + u32 key = args[0]; key += track->getTranspose(); JUT_ASSERT(506, key < 256); - track->field_0xb4.field_0x35 = key; + track->mNoteMgr.field_0x35 = key; return 0; } /* 8027EE44-8027EE5C .text cmdTimeRelate__Q28JASystem10TSeqParserFPQ28JASystem6TTrackPUl */ -int JASystem::TSeqParser::cmdTimeRelate(TTrack* track, u32* params) { - track->field_0x387 = params[0]; +int JASystem::TSeqParser::cmdTimeRelate(TTrack* track, u32* args) { + track->field_0x387 = args[0]; return 0; } /* 8027EE5C-8027EE8C .text cmdSimpleOsc__Q28JASystem10TSeqParserFPQ28JASystem6TTrackPUl */ -int JASystem::TSeqParser::cmdSimpleOsc(TTrack* track, u32* params) { - track->oscSetupSimple(params[0]); +int JASystem::TSeqParser::cmdSimpleOsc(TTrack* track, u32* args) { + track->oscSetupSimple(args[0]); return 0; } /* 8027EE8C-8027EEC0 .text cmdSimpleEnv__Q28JASystem10TSeqParserFPQ28JASystem6TTrackPUl */ -int JASystem::TSeqParser::cmdSimpleEnv(TTrack* track, u32* params) { - track->oscSetupSimpleEnv(params[0], params[1]); +int JASystem::TSeqParser::cmdSimpleEnv(TTrack* track, u32* args) { + track->oscSetupSimpleEnv(args[0], args[1]); return 0; } /* 8027EEC0-8027EF2C .text cmdSimpleADSR__Q28JASystem10TSeqParserFPQ28JASystem6TTrackPUl */ -int JASystem::TSeqParser::cmdSimpleADSR(TTrack* track, u32* params) { +int JASystem::TSeqParser::cmdSimpleADSR(TTrack* track, u32* args) { 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]; + track->field_0x304[1] = args[0]; + track->field_0x304[4] = args[1]; + track->field_0x304[7] = args[2]; + track->field_0x304[8] = args[3]; + track->field_0x374 = args[4]; return 0; } /* 8027EF2C-8027EF3C .text cmdTranspose__Q28JASystem10TSeqParserFPQ28JASystem6TTrackPUl */ -int JASystem::TSeqParser::cmdTranspose(TTrack* track, u32* params) { - track->field_0x37a = params[0]; +int JASystem::TSeqParser::cmdTranspose(TTrack* track, u32* args) { + track->setTranspose(args[0]); return 0; } /* 8027EF3C-8027EFD8 .text cmdCloseTrack__Q28JASystem10TSeqParserFPQ28JASystem6TTrackPUl */ -int JASystem::TSeqParser::cmdCloseTrack(TTrack* track, u32* params) { - u8 track_no = params[0]; +int JASystem::TSeqParser::cmdCloseTrack(TTrack* track, u32* args) { + u8 track_no = args[0]; JUT_ASSERT(565, track_no < TTrack::MAX_CHILDREN); if (!track->mChildren[track_no]) { return 0; @@ -201,231 +255,598 @@ int JASystem::TSeqParser::cmdCloseTrack(TTrack* track, u32* params) { } /* 8027EFD8-8027F02C .text cmdOutSwitch__Q28JASystem10TSeqParserFPQ28JASystem6TTrackPUl */ -int JASystem::TSeqParser::cmdOutSwitch(TTrack* track, u32* params) { +int JASystem::TSeqParser::cmdOutSwitch(TTrack* track, u32* args) { TTrack::TOuterParam* outer = track->getOuterParam(); if (outer) { - outer->setOuterSwitch(params[0]); + outer->setOuterSwitch(args[0]); outer->setOuterUpdate(0xffff); } return 0; } /* 8027F02C-8027F058 .text cmdUpdateSync__Q28JASystem10TSeqParserFPQ28JASystem6TTrackPUl */ -int JASystem::TSeqParser::cmdUpdateSync(TTrack* track, u32* params) { - track->updateTrack(params[0]); +int JASystem::TSeqParser::cmdUpdateSync(TTrack* track, u32* args) { + track->updateTrack(args[0]); return 0; } /* 8027F058-8027F088 .text cmdBusConnect__Q28JASystem10TSeqParserFPQ28JASystem6TTrackPUl */ -int JASystem::TSeqParser::cmdBusConnect(TTrack* track, u32* params) { - track->connectBus(params[0], params[1]); +int JASystem::TSeqParser::cmdBusConnect(TTrack* track, u32* args) { + track->connectBus(args[0], args[1]); return 0; } /* 8027F088-8027F098 .text cmdPauseStatus__Q28JASystem10TSeqParserFPQ28JASystem6TTrackPUl */ -int JASystem::TSeqParser::cmdPauseStatus(TTrack* track, u32* params) { +int JASystem::TSeqParser::cmdPauseStatus(TTrack* track, u32* args) { /* Nonmatching */ - track->field_0x37c = params[0]; + track->mPauseStatus = args[0]; return 0; } /* 8027F098-8027F0A8 .text cmdVolumeMode__Q28JASystem10TSeqParserFPQ28JASystem6TTrackPUl */ -int JASystem::TSeqParser::cmdVolumeMode(TTrack* track, u32* params) { - /* Nonmatching */ - track->field_0x37d = params[0]; +int JASystem::TSeqParser::cmdVolumeMode(TTrack* track, u32* args) { + track->setVolumeMode(args[0]); return 0; } /* 8027F0A8-8027F0E0 .text cmdSetInterrupt__Q28JASystem10TSeqParserFPQ28JASystem6TTrackPUl */ -int JASystem::TSeqParser::cmdSetInterrupt(TTrack* track, u32* params) { - /* Nonmatching */ - track->field_0x88.setIntr(params[0], track->field_0x0.field_0x0 + params[1]); +int JASystem::TSeqParser::cmdSetInterrupt(TTrack* track, u32* args) { + track->field_0x88.setIntr(args[0], track->getSeq()->getBase() + args[1]); return 0; } /* 8027F0E0-8027F10C .text cmdDisInterrupt__Q28JASystem10TSeqParserFPQ28JASystem6TTrackPUl */ -int JASystem::TSeqParser::cmdDisInterrupt(TTrack* track, u32* params) { - track->field_0x88.resetInter(params[0]); +int JASystem::TSeqParser::cmdDisInterrupt(TTrack* track, u32* args) { + track->field_0x88.resetInter(args[0]); return 0; } /* 8027F10C-8027F124 .text cmdClrI__Q28JASystem10TSeqParserFPQ28JASystem6TTrackPUl */ -int JASystem::TSeqParser::cmdClrI(TTrack* track, u32* params) { +int JASystem::TSeqParser::cmdClrI(TTrack* track, u32* args) { track->field_0x88.field_0x0 = 1; - track->field_0x0.field_0x44 = 0; + track->getSeq()->clrIntr(); return 0; } /* 8027F124-8027F134 .text cmdSetI__Q28JASystem10TSeqParserFPQ28JASystem6TTrackPUl */ -int JASystem::TSeqParser::cmdSetI(TTrack* track, u32* params) { +int JASystem::TSeqParser::cmdSetI(TTrack* track, u32* args) { track->field_0x88.field_0x0 = 0; return 0; } /* 8027F134-8027F178 .text cmdRetI__Q28JASystem10TSeqParserFPQ28JASystem6TTrackPUl */ -int JASystem::TSeqParser::cmdRetI(TTrack* track, u32* params) { +int JASystem::TSeqParser::cmdRetI(TTrack* track, u32* args) { track->field_0x88.field_0x0 = 1; - track->field_0x0.retIntr(); + track->getSeq()->retIntr(); track->tryInterrupt(); return 0; } /* 8027F178-8027F194 .text cmdIntTimer__Q28JASystem10TSeqParserFPQ28JASystem6TTrackPUl */ -int JASystem::TSeqParser::cmdIntTimer(TTrack* track, u32* params) { - u32 param2 = params[1]; - track->field_0x88.field_0x3 = params[0]; +int JASystem::TSeqParser::cmdIntTimer(TTrack* track, u32* args) { + u32 param2 = args[1]; + track->field_0x88.field_0x3 = args[0]; track->field_0x88.field_0x4 = param2; track->field_0x88.field_0x8 = param2; return 0; } /* 8027F194-8027F1EC .text cmdSyncCPU__Q28JASystem10TSeqParserFPQ28JASystem6TTrackPUl */ -int JASystem::TSeqParser::cmdSyncCPU(TTrack* track, u32* params) { +int JASystem::TSeqParser::cmdSyncCPU(TTrack* track, u32* args) { u16 var1 = 0xffff; if (TTrack::sCallBackFunc) { - var1 = TTrack::sCallBackFunc(track, params[0]); + var1 = TTrack::sCallBackFunc(track, args[0]); } - track->field_0x28c.field_0x6 = var1; + track->mRegisterParam.field_0x0[3] = var1; return 0; } /* 8027F1EC-8027F214 .text cmdFlushAll__Q28JASystem10TSeqParserFPQ28JASystem6TTrackPUl */ -int JASystem::TSeqParser::cmdFlushAll(TTrack* track, u32* params) { +int JASystem::TSeqParser::cmdFlushAll(TTrack* track, u32* args) { track->flushAll(); return 0; } /* 8027F214-8027F23C .text cmdFlushRelease__Q28JASystem10TSeqParserFPQ28JASystem6TTrackPUl */ -int JASystem::TSeqParser::cmdFlushRelease(TTrack* track, u32* params) { - track->field_0xf8.stopAllRelease(); +int JASystem::TSeqParser::cmdFlushRelease(TTrack* track, u32* args) { + track->mChannelUpdater.stopAllRelease(); return 0; } /* 8027F23C-8027F26C .text cmdTimeBase__Q28JASystem10TSeqParserFPQ28JASystem6TTrackPUl */ -int JASystem::TSeqParser::cmdTimeBase(TTrack* track, u32* params) { - track->setTimebase(params[0]); +int JASystem::TSeqParser::cmdTimeBase(TTrack* track, u32* args) { + track->setTimebase(args[0]); return 0; } /* 8027F26C-8027F29C .text cmdTempo__Q28JASystem10TSeqParserFPQ28JASystem6TTrackPUl */ -int JASystem::TSeqParser::cmdTempo(TTrack* track, u32* params) { - track->setTempo(params[0]); +int JASystem::TSeqParser::cmdTempo(TTrack* track, u32* args) { + track->setTempo(args[0]); return 0; } /* 8027F29C-8027F2A4 .text cmdFinish__Q28JASystem10TSeqParserFPQ28JASystem6TTrackPUl */ -int JASystem::TSeqParser::cmdFinish(TTrack* track, u32* params) { +int JASystem::TSeqParser::cmdFinish(TTrack* track, u32* args) { return 3; } /* 8027F2A4-8027F2AC .text cmdNop__Q28JASystem10TSeqParserFPQ28JASystem6TTrackPUl */ -int JASystem::TSeqParser::cmdNop(TTrack* track, u32* params) { +int JASystem::TSeqParser::cmdNop(TTrack* track, u32* args) { return 0; } /* 8027F2AC-8027F330 .text cmdPanPowSet__Q28JASystem10TSeqParserFPQ28JASystem6TTrackPUl */ -int JASystem::TSeqParser::cmdPanPowSet(TTrack* track, u32* params) { - /* Nonmatching */ +int JASystem::TSeqParser::cmdPanPowSet(TTrack* track, u32* args) { + track->setPanPower(0, args[0]); + track->setPanPower(1, args[1]); + track->setPanPower(2, args[2]); + track->setPanPower(3, args[3] * 327.67f); + track->setPanPower(4, args[4] * 327.67f); + return 0; } /* 8027F330-8027F368 .text cmdFIRSet__Q28JASystem10TSeqParserFPQ28JASystem6TTrackPUl */ -int JASystem::TSeqParser::cmdFIRSet(TTrack* track, u32* params) { - /* Nonmatching */ +int JASystem::TSeqParser::cmdFIRSet(TTrack* track, u32* args) { + track->getOuterParam()->setFirFilter((s16*)track->getSeq()->getAddr(args[0])); + return 0; } /* 8027F368-8027F3BC .text cmdEXTSet__Q28JASystem10TSeqParserFPQ28JASystem6TTrackPUl */ -int JASystem::TSeqParser::cmdEXTSet(TTrack* track, u32* params) { - /* Nonmatching */ +int JASystem::TSeqParser::cmdEXTSet(TTrack* track, u32* args) { + u8* outerParamAddr = track->getSeq()->getAddr(args[0]); + TTrack::TOuterParam* outerParam = (TTrack::TOuterParam*)outerParamAddr; + outerParam->initExtBuffer(); + track->assignExtBuffer((TTrack::TOuterParam*)outerParamAddr); + return 0; } /* 8027F3BC-8027F460 .text cmdPanSwSet__Q28JASystem10TSeqParserFPQ28JASystem6TTrackPUl */ -int JASystem::TSeqParser::cmdPanSwSet(TTrack* track, u32* params) { - /* Nonmatching */ +int JASystem::TSeqParser::cmdPanSwSet(TTrack* track, u32* args) { + u8 calcTypes[] = { 0, 0, 0, 1, 1, 2, 2 }; + u8 parentCalcTypes[] = { 0, 1, 2, 0, 2, 0, 2 }; + + for (u8 i = 0; i < 3; i++) { + track->mCalcTypes[i] = calcTypes[args[i] >> 5]; + track->mParentCalcTypes[i] = parentCalcTypes[args[i] >> 5]; + track->mChannelUpdater.mCalcTypes[i] = args[i] & 0x1F; + track->mUpdateFlags |= (OUTERPARAM_Fxmix | OUTERPARAM_Pan | OUTERPARAM_Dolby); + } + + return 0; } /* 8027F460-8027F47C .text cmdOscRoute__Q28JASystem10TSeqParserFPQ28JASystem6TTrackPUl */ -int JASystem::TSeqParser::cmdOscRoute(TTrack* track, u32* params) { - /* Nonmatching */ +int JASystem::TSeqParser::cmdOscRoute(TTrack* track, u32* args) { + track->mOscRoute[(args[0] / 16) & 0xF] = args[0] & 0xF; + return 0; } /* 8027F47C-8027F4C4 .text cmdVibDepth__Q28JASystem10TSeqParserFPQ28JASystem6TTrackPUl */ -int JASystem::TSeqParser::cmdVibDepth(TTrack* track, u32* params) { - /* Nonmatching */ +int JASystem::TSeqParser::cmdVibDepth(TTrack* track, u32* args) { + f32 depth = ((u8)args[0] << 8 | (u8)args[0] << 1); + depth /= 393204.0f; + track->mVibrate.setDepth(depth); + return 0; } /* 8027F4C4-8027F4FC .text cmdVibDepthMidi__Q28JASystem10TSeqParserFPQ28JASystem6TTrackPUl */ -int JASystem::TSeqParser::cmdVibDepthMidi(TTrack* track, u32* params) { - /* Nonmatching */ +int JASystem::TSeqParser::cmdVibDepthMidi(TTrack* track, u32* args) { + f32 depth = args[0]; + depth /= 393204.0f; + track->mVibrate.setDepth(depth); + return 0; } /* 8027F4FC-8027F544 .text cmdVibPitch__Q28JASystem10TSeqParserFPQ28JASystem6TTrackPUl */ -int JASystem::TSeqParser::cmdVibPitch(TTrack* track, u32* params) { - /* Nonmatching */ +int JASystem::TSeqParser::cmdVibPitch(TTrack* track, u32* args) { + f32 pitch = u16((u8)args[0] << 8 | (u8)args[0] << 1); + pitch /= 294903.0f; + track->mVibrate.mPitch = pitch; + return 0; } /* 8027F544-8027F5C8 .text cmdIIRSet__Q28JASystem10TSeqParserFPQ28JASystem6TTrackPUl */ -int JASystem::TSeqParser::cmdIIRSet(TTrack* track, u32* params) { +int JASystem::TSeqParser::cmdIIRSet(TTrack* track, u32* args) { /* Nonmatching */ + for (int i = 0; i < 4; i++) { + track->mTimedParam.mInnerParam.mIIRs[i].mTargetValue = (s16)args[i] / 32768.0f; + track->mTimedParam.mInnerParam.mIIRs[i].mCurrentValue = track->mTimedParam.mInnerParam.mIIRs[i].mTargetValue; + track->mTimedParam.mInnerParam.mIIRs[i].mMoveAmount = 0.0f; + track->mTimedParam.mInnerParam.mIIRs[i].mMoveTime = 1.0f; + } + return 0; } /* 8027F5C8-8027F65C .text cmdIIRCutOff__Q28JASystem10TSeqParserFPQ28JASystem6TTrackPUl */ -int JASystem::TSeqParser::cmdIIRCutOff(TTrack* track, u32* params) { +int JASystem::TSeqParser::cmdIIRCutOff(TTrack* track, u32* args) { /* Nonmatching */ + s16* table = &JASystem::Player::CUTOFF_TO_IIR_TABLE[u8(args[0]) * 4]; + for (int i = 0; i < 4; i++) { + track->mTimedParam.mInnerParam.mIIRs[i].mTargetValue = table[i] / (32768.0f - 1.0f); + track->mTimedParam.mInnerParam.mIIRs[i].mCurrentValue = track->mTimedParam.mInnerParam.mIIRs[i].mTargetValue; + track->mTimedParam.mInnerParam.mIIRs[i].mMoveAmount = 0.0f; + track->mTimedParam.mInnerParam.mIIRs[i].mMoveTime = 1.0f; + } + return 0; } /* 8027F65C-8027F698 .text cmdOscFull__Q28JASystem10TSeqParserFPQ28JASystem6TTrackPUl */ -int JASystem::TSeqParser::cmdOscFull(TTrack* track, u32* params) { - /* Nonmatching */ +int JASystem::TSeqParser::cmdOscFull(TTrack* track, u32* args) { + track->oscSetupFull(args[0], args[1], args[2]); + return 0; } /* 8027F698-8027F6A8 .text cmdCheckWave__Q28JASystem10TSeqParserFPQ28JASystem6TTrackPUl */ -int JASystem::TSeqParser::cmdCheckWave(TTrack* track, u32* params) { - /* Nonmatching */ +int JASystem::TSeqParser::cmdCheckWave(TTrack* track, u32* args) { + track->mRegisterParam.field_0x0[3] = 0; + return 0; } /* 8027F6A8-8027F8F4 .text cmdPrintf__Q28JASystem10TSeqParserFPQ28JASystem6TTrackPUl */ -int JASystem::TSeqParser::cmdPrintf(TTrack* track, u32* params) { +int JASystem::TSeqParser::cmdPrintf(TTrack* track, u32* args) { /* Nonmatching */ + char buf[128]; + u8 byteArray[4]; + int registers[4]; + u32 count = 0; + + for (u32 i = 0; i < 128; i++) { + buf[i] = track->getSeq()->readByte(); + if (!buf[i]) { + break; + } + if (buf[i] == '\\') { + buf[i] = track->getSeq()->readByte(); + if (!buf[i]) { + break; + } + + if (buf[i] != 'n') { + continue; + } else { + buf[i] = '\r'; + continue; + } + } + + if (buf[i] != '%') { + continue; + } + + buf[++i] = track->getSeq()->readByte(); + if (!buf[i]) { + break; + } + + switch (buf[i]) { + case 'd': + byteArray[count] = 0; + break; + case 'x': + byteArray[count] = 1; + break; + case 's': + byteArray[count] = 2; + break; + case 'r': + byteArray[count] = 3; + buf[i] = 'd'; + break; + case 'R': + byteArray[count] = 4; + buf[i] = 'x'; + break; + case 't': + byteArray[count] = 5; + buf[i] = 'x'; + break; + } + count++; + } + + for (u32 i = 0; i < count; i++) { + registers[i] = track->getSeq()->readByte(); + if (byteArray[i] == 2) { + registers[i] = (int)track->getSeq()->getAddr(registers[i]); + } else if (byteArray[i] == 5) { + registers[i] = track->field_0x36c; + } else if (byteArray[i] >= 3) { + registers[i] = track->exchangeRegisterValue(registers[i]); + } + } + + OSReport(buf, registers[0], registers[1], registers[2], registers[3]); + + return 0; } /* 8027F8F4-8027FA48 .text Cmd_Process__Q28JASystem10TSeqParserFPQ28JASystem6TTrackUcUs */ -void JASystem::TSeqParser::Cmd_Process(TTrack* track, u8, u16) { +int JASystem::TSeqParser::Cmd_Process(TTrack* track, u8, u16) { /* Nonmatching */ } /* 8027FA48-8027FB08 .text RegCmd_Process__Q28JASystem10TSeqParserFPQ28JASystem6TTrackii */ -void JASystem::TSeqParser::RegCmd_Process(TTrack* track, int, int) { - /* Nonmatching */ +int JASystem::TSeqParser::RegCmd_Process(TTrack* track, int r30, int r31) { + u8 r5 = track->getSeq()->readByte(); + if (r30 != 0) { + r5 = track->exchangeRegisterValue(r5); + } + u16 r6 = 0; + if (r30 == 0 || r31 != 0) { + u8 r3 = track->getSeq()->readByte(); + u16 r4 = 3; + for (int i = 0; i < (u32)r31+1; i++) { + if (r3 & 0x80) { + r6 |= r4; + } + r3 <<= 1; + r4 <<= 2; + } + } + Cmd_Process(track, r5, r6); } /* 8027FB08-8027FC98 .text cmdSetParam__Q28JASystem10TSeqParserFPQ28JASystem6TTrackUc */ -int JASystem::TSeqParser::cmdSetParam(TTrack* track, u8) { +int JASystem::TSeqParser::cmdSetParam(TTrack* track, u8 param_2) { /* Nonmatching */ + u8 flag = track->getSeq()->readByte(); + + s16 data; + switch (param_2 & 0xC) { + case 0: + data = track->readReg16(track->getSeq()->readByte()); + break; + case 4: + data = track->getSeq()->readByte(); + break; + case 8: + u8 byte = track->getSeq()->readByte(); + if (byte & 0x80) { + data = byte << 8; + } else { + data = byte << 8 | byte << 1; + } + break; + case 12: + data = track->getSeq()->read16(); + break; + } + + int val = 0; + switch (param_2 & 0x3) { + case 0: + val = -1; + break; + case 1: + val = track->readReg16(track->getSeq()->readByte()); + break; + case 2: + val = track->getSeq()->readByte(); + break; + case 3: + val = track->getSeq()->read16() & 0xFFFF; + break; + } + + track->setParam(flag, (int)data / 32767.0f, val); + return 0; } /* 8027FC98-8027FCE4 .text cmdWait__Q28JASystem10TSeqParserFPQ28JASystem6TTrackUc */ -int JASystem::TSeqParser::cmdWait(TTrack* track, u8) { - /* Nonmatching */ +int JASystem::TSeqParser::cmdWait(TTrack* track, u8 flag) { + int end = flag == 0x80 ? 1 : 2; + int val = 0; + for (int i = 0; i < end; i++) { + val <<= 8; + val |= track->getSeq()->readByte(); + } + track->getSeq()->mWaitTimer = val; + if (val != 0) { + return 1; + } else { + return 0; + } } /* 8027FCE4-8027FE08 .text cmdNoteOff__Q28JASystem10TSeqParserFPQ28JASystem6TTrackUc */ -int JASystem::TSeqParser::cmdNoteOff(TTrack* track, u8) { +int JASystem::TSeqParser::cmdNoteOff(TTrack* track, u8 flag) { /* Nonmatching */ + if (flag == 0xF9) { + u32 r30 = track->getSeq()->readByte(); + u32 rdata2 = (track->exchangeRegisterValue(r30 & 0x7) & 0xFF); + JUT_ASSERT(0x496, rdata2 >= 1); + JUT_ASSERT(0x497, rdata2 <= 7); + + // flag = rdata2 + 0x80; + // if (r30 & 0x80) { + // flag |= 0x08; + // } + + flag = r30 & 0x80 ? (rdata2 + 0x80) | 0x08 : (rdata2 + 0x80); + } + + int r6 = 0; + if ((s32)flag & 0x08) { + r6 = track->getSeq()->readByte(); + if (r6 > 100) { + r6 = (r6 - 98) * 20; + } + } + track->noteOff(flag & 0x7, r6); + return 0; } /* 8027FE08-80280148 .text cmdNoteOn__Q28JASystem10TSeqParserFPQ28JASystem6TTrackUc */ -int JASystem::TSeqParser::cmdNoteOn(TTrack* track, u8) { +int JASystem::TSeqParser::cmdNoteOn(TTrack* track, u8 note) { /* Nonmatching */ + s32 flag = *track->mSeqCtrl.mCurrentFilePtr++; + if (flag & 0x80) { + note = track->exchangeRegisterValue(note); + } + + note += track->getTranspose(); + + int val28 = (flag >> 5) & 0x3; + u8 val27; + if ((flag >> 5) & 0x2) { + val27 = note; + note = track->mNoteMgr.field_0x35; + } + + u8 val26 = *track->mSeqCtrl.mCurrentFilePtr++; + if (val26 & 0x80) { + val26 = track->exchangeRegisterValue(val26 & 0x7F); + } + u8 val25; + u8 noteid = flag & 0x7; + int val23 = 0; + if (!noteid) { + val25 = *track->mSeqCtrl.mCurrentFilePtr++; + if (val25 & 0x80) { + val25 = track->exchangeRegisterValue(val25 & 0x7F); + } + int count = (flag >> 3) & 0x3; + flag = 0; + for (int i = 0; i < count; i++) { + flag <<= 8; + flag |= *track->mSeqCtrl.mCurrentFilePtr++; + } + + if ((u32)count == 1 && flag & 0x80) { + flag = track->exchangeRegisterValue(flag & 0x7F); + } + } else { + if ((flag >> 3) & 0x3) { + noteid = track->exchangeRegisterValue(noteid - 1); + } + JUT_ASSERT(0x4FE, noteid < 8); + if (val28 & 1) { + val23 = track->exchangeRegisterValue(*track->mSeqCtrl.mCurrentFilePtr++); + val28 = (val28 ^ 1) & 0xFF; + } + + flag = -1; + val25 = 100; + } + + track->mNoteMgr.field_0x34 = val28; + s32 time = flag; + if (track->mNoteMgr.field_0x36) { + if (track->mNoteMgr.field_0x34 & 1) { + time = -1; + } + if (time != -1) { + time = track->seqTimeToDspTime(time, val25); + } + + if (!track->mIsPaused || !(track->mPauseStatus & 0x10)) { + track->gateOn(noteid, note, val26, time); + } + } else { + if (flag != -1) { + time = track->seqTimeToDspTime(flag, val25); + } + if (track->mNoteMgr.field_0x34 & 1) { + time = -1; + } + + if (!track->mIsPaused || !(track->mPauseStatus & 0x10)) { + track->noteOn(noteid, note, val26, time, val23); + } + } + + track->mNoteMgr.field_0x30 = flag; + track->mNoteMgr.field_0x36 = track->mNoteMgr.field_0x34 & 1; + if (track->mNoteMgr.field_0x34 & 0x2) { + s32 val = time; + if (time == -1) { + val = track->seqTimeToDspTime(flag, val25); + } + + JASystem::TChannel* channel = track->mNoteMgr.getChannel(0); + if (channel) { + channel->setKeySweepTarget(val27 + track->getTranspose(), val); + } + + note = val27; + } + + track->mNoteMgr.field_0x35 = note; + if (flag == 0xFFFFFFFF) { + return 0; + } + + track->mSeqCtrl.mWaitTimer = ((u32)flag) ? flag : -1; + + return 1; } /* 80280148-8028024C .text conditionCheck__Q28JASystem10TSeqParserFPQ28JASystem6TTrackUc */ -bool JASystem::TSeqParser::conditionCheck(TTrack* track, u8) { +bool JASystem::TSeqParser::conditionCheck(TTrack* track, u8 param_2) { /* Nonmatching */ + u16 val = (u32)track->mRegisterParam.field_0x0[3]; + switch (param_2 & 0xF) { + case 0: + return true; + case 1: + return val == 0; + case 2: + return val != 0; + case 3: + return val == 1; + case 4: + return val >= 0x8000; + case 5: + return val < 0x8000; + } + + JUT_ASSERT(0x578, false); + + return false; } /* 8028024C-802803B0 .text parseSeq__Q28JASystem10TSeqParserFPQ28JASystem6TTrack */ -void JASystem::TSeqParser::parseSeq(TTrack* track) { - /* Nonmatching */ +int JASystem::TSeqParser::parseSeq(TTrack* track) { + while (true) { + u8 flag = track->getSeq()->readByte(); + u32 r29 = 0; + if (!(flag & 0x80)) { + r29 = cmdNoteOn(track, flag); + } else if (((flag & 0xF0) == 128) && !(flag & 0x07)) { + r29 = cmdWait(track, flag); + } else if (((flag & 0xF0) == 128) || flag == (u32)0xF9) { + r29 = cmdNoteOff(track, flag); + } else { + switch ((s32)flag & 0xF0) { + case 0x90: + r29 = cmdSetParam(track, flag & 0xF); + break; + case 0xA0: + track->writeRegParam(flag & 0xF); + break; + case 0xB0: + r29 = RegCmd_Process(track, (flag >> 3) & 1, flag & 0x07); + break; + default: + r29 = Cmd_Process(track, flag, 0); + break; + } + } + + if (r29 == 0) { + continue; + } + + if (r29 == 1) { + break; + } + + if (r29 == 3) { + return -1; + } + } + + return 0; } int (JASystem::TSeqParser::*JASystem::TSeqParser::sCmdPList[64])(JASystem::TTrack*, u32*) = { @@ -494,3 +915,70 @@ int (JASystem::TSeqParser::*JASystem::TSeqParser::sCmdPList[64])(JASystem::TTrac &JASystem::TSeqParser::cmdTimeBase, &JASystem::TSeqParser::cmdFinish, }; + +const u16 JASystem::Arglist[0x40][2] = { + {0x0000, 0x0000}, + {0x0002, 0x0008}, + {0x0002, 0x0008}, + {0x0001, 0x0002}, + {0x0000, 0x0000}, + {0x0000, 0x0000}, + {0x0001, 0x0000}, + {0x0001, 0x0002}, + {0x0000, 0x0000}, + {0x0001, 0x0001}, + {0x0000, 0x0000}, + {0x0002, 0x0000}, + {0x0002, 0x000C}, + {0x0001, 0x0000}, + {0x0001, 0x0000}, + {0x0001, 0x0003}, + {0x0000, 0x0000}, + {0x0002, 0x000C}, + {0x0002, 0x000C}, + {0x0000, 0x0000}, + {0x0001, 0x0000}, + {0x0001, 0x0000}, + {0x0001, 0x0000}, + {0x0002, 0x0008}, + {0x0005, 0x0155}, + {0x0001, 0x0000}, + {0x0001, 0x0000}, + {0x0001, 0x0000}, + {0x0001, 0x0001}, + {0x0002, 0x0004}, + {0x0001, 0x0000}, + {0x0002, 0x0008}, + {0x0001, 0x0000}, + {0x0000, 0x0000}, + {0x0000, 0x0000}, + {0x0000, 0x0000}, + {0x0002, 0x0004}, + {0x0001, 0x0000}, + {0x0001, 0x0001}, + {0x0001, 0x0001}, + {0x0000, 0x0000}, + {0x0000, 0x0000}, + {0x0001, 0x0002}, + {0x0005, 0x0000}, + {0x0004, 0x0055}, + {0x0001, 0x0002}, + {0x0001, 0x0002}, + {0x0003, 0x0000}, + {0x0001, 0x0000}, + {0x0001, 0x0000}, + {0x0003, 0x0028}, + {0x0001, 0x0000}, + {0x0001, 0x0000}, + {0x0000, 0x0000}, + {0x0000, 0x0000}, + {0x0000, 0x0000}, + {0x0000, 0x0000}, + {0x0000, 0x0000}, + {0x0001, 0x0001}, + {0x0000, 0x0000}, + {0x0000, 0x0000}, + {0x0001, 0x0001}, + {0x0001, 0x0001}, + {0x0000, 0x0000}, +}; diff --git a/src/JSystem/JAudio/JASTrack.cpp b/src/JSystem/JAudio/JASTrack.cpp index 6e264cc8d..69809c617 100644 --- a/src/JSystem/JAudio/JASTrack.cpp +++ b/src/JSystem/JAudio/JASTrack.cpp @@ -20,25 +20,25 @@ JASystem::TTrack::TTrack() { field_0x364 = 0.0f; field_0x368 = 0.0f; field_0x36c = 0; - field_0x370 = 0; + mUpdateFlags = 0; field_0x374 = 0; field_0x376 = 0x78; field_0x378 = 0x78; field_0x37a = 0; field_0x37b = 0; - field_0x37c = 0; - field_0x37d = 0; + mPauseStatus = 0; + mVolumeMode = 0; field_0x37e = 0; - field_0x385 = 0; + mIsPaused = 0; field_0x386 = 0; field_0x387 = 0; field_0x388 = 0; field_0x389 = 0; - field_0xf8.init(); + mChannelUpdater.init(); for (int i = 0; i < 12; i++) { field_0x304[i] = Player::sAdsTable[i]; } - Calc::bzero(&field_0x16c, sizeof(TimedParam_)); + Calc::bzero(&mTimedParam, sizeof(TimedParam_)); } /* 80280A34-80280A80 .text __ct__Q38JASystem6TTrack11TimedParam_Fv */ @@ -46,16 +46,16 @@ JASystem::TTrack::TimedParam_::TimedParam_() {} /* 80280A80-80280C10 .text init__Q28JASystem6TTrackFv */ void JASystem::TTrack::init() { - field_0x0.init(); - field_0x48.init(); + mSeqCtrl.init(); + mTrackPort.init(); field_0x88.init(); - field_0xb4.init(); - field_0xf8.initAllocChannel(0); + mNoteMgr.init(); + mChannelUpdater.initAllocChannel(0); initTimed(); - field_0x28c.init(); - field_0x2fc[0] = 0x0f; + mRegisterParam.init(); + mOscRoute[0] = 0x0f; field_0x2cc[0] = Player::sEnvelopeDef; - field_0x2fc[1] = 0x0f; + mOscRoute[1] = 0x0f; field_0x2cc[1] = Player::sEnvelopeDef; mParent = NULL; for (int i = 0; i < 16; i++) { @@ -67,23 +67,23 @@ void JASystem::TTrack::init() { field_0x364 = 0.0f; field_0x368 = 1.0f; field_0x36c = 0; - field_0xec.init(); - field_0x370 = 0; + mVibrate.init(); + mUpdateFlags = 0; field_0x374 = 0; field_0x376 = 0x78; field_0x378 = 0x30; updateTempo(); field_0x37a = 0; field_0x37b = 0; - field_0x37c = 10; - field_0x37d = 0; + mPauseStatus = 10; + mVolumeMode = 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; + mCalcTypes[i] = 0; + mParentCalcTypes[i] = 0; + mChannelUpdater.mCalcTypes[i] = 0x0d; } - field_0x385 = 0; + mIsPaused = 0; field_0x386 = 0; field_0x387 = 1; field_0x388 = 0; @@ -99,18 +99,18 @@ void JASystem::TTrack::inherit() { 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; + mIsPaused = mParent->mIsPaused; + mPauseStatus = mParent->mPauseStatus; + mVolumeMode = mParent->mVolumeMode; field_0x386 = mParent->field_0x386; if (field_0x37b & 2) { return; } - field_0x28c.inherit(mParent->field_0x28c); + mRegisterParam.inherit(mParent->mRegisterParam); 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]; + mCalcTypes[i] = mParent->mCalcTypes[i]; + mParentCalcTypes[i] = mParent->mParentCalcTypes[i]; + mChannelUpdater.mCalcTypes[i] = mParent->mChannelUpdater.mCalcTypes[i]; } } @@ -132,19 +132,19 @@ s8 JASystem::TTrack::mainProc() { } field_0x364 -= 1.0f; } - if (mParent && field_0xf8.field_0x0) { - TChannel* channel = field_0xf8.getListHead(0); + if (mParent && mChannelUpdater.field_0x0) { + TChannel* channel = mChannelUpdater.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++; + mParent->mChannelUpdater.addListHead(channel, 0); + channel->field_0x4 = &mParent->mChannelUpdater; + mChannelUpdater.field_0x0--; + mParent->mChannelUpdater.field_0x0++; } } field_0x88.request(7); field_0x88.timerProcess(); tryInterrupt(); - if (field_0x385 == 0 && (field_0x37c & 2) == 0) { + if (mIsPaused == 0 && (mPauseStatus & 2) == 0) { // TODO: } updateSeq(0, false); @@ -171,14 +171,14 @@ void JASystem::TTrack::setInterrupt(u16 param_1) { /* 80280FA8-80281004 .text tryInterrupt__Q28JASystem6TTrackFv */ bool JASystem::TTrack::tryInterrupt() { - if (field_0x0.field_0x44) { + if (mSeqCtrl.mPreviousFilePtr) { return false; } void* var1 = field_0x88.checkIntr(); if (var1 == NULL) { return false; } - return field_0x0.callIntr(var1); + return mSeqCtrl.callIntr(var1); } /* 80281004-8028100C .text assignExtBuffer__Q28JASystem6TTrackFPQ38JASystem6TTrack11TOuterParam */ @@ -189,16 +189,16 @@ void JASystem::TTrack::assignExtBuffer(TOuterParam* param_1) { /* 8028100C-80281050 .text releaseChannelAll__Q28JASystem6TTrackFv */ void JASystem::TTrack::releaseChannelAll() { if (mParent) { - mParent->field_0xf8.receiveAllChannels(&field_0xf8); + mParent->mChannelUpdater.receiveAllChannels(&mChannelUpdater); } else { - TGlobalChannel::releaseAll(&field_0xf8); + TGlobalChannel::releaseAll(&mChannelUpdater); } } /* 80281050-80281088 .text flushAll__Q28JASystem6TTrackFv */ void JASystem::TTrack::flushAll() { - field_0xf8.stopAll(); - field_0xf8.stopAllRelease(); + mChannelUpdater.stopAll(); + mChannelUpdater.stopAllRelease(); } /* 80281088-80281138 .text moveFreeChannel__Q28JASystem6TTrackFPQ28JASystem11TChannelMgrPQ28JASystem11TChannelMgri */ @@ -226,28 +226,28 @@ int JASystem::TTrack::moveFreeChannel(TChannelMgr* param_1, TChannelMgr* param_2 /* 80281138-802811DC .text initTimed__Q28JASystem6TTrackFv */ void JASystem::TTrack::initTimed() { 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; + mTimedParam.mMoveParams[i].mMoveTime = 0.0f; + mTimedParam.mMoveParams[i].mCurrentValue = 1.0f; + mTimedParam.mMoveParams[i].mTargetValue = 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; + mTimedParam.mMoveParams[1].mCurrentValue = 0.0f; + mTimedParam.mMoveParams[1].mTargetValue = 0.0f; + mTimedParam.mMoveParams[3].mCurrentValue = 0.5f; + mTimedParam.mMoveParams[3].mTargetValue = 0.5f; + mTimedParam.mMoveParams[16].mCurrentValue = 0.5f; + mTimedParam.mMoveParams[16].mTargetValue = 0.5f; + mTimedParam.mMoveParams[17].mCurrentValue = 0.0f; + mTimedParam.mMoveParams[17].mTargetValue = 0.0f; + mTimedParam.mMoveParams[2].mCurrentValue = 0.0f; + mTimedParam.mMoveParams[2].mTargetValue = 0.0f; + mTimedParam.mMoveParams[4].mCurrentValue = 0.0f; + mTimedParam.mMoveParams[4].mTargetValue = 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; + mTimedParam.mMoveParams[i + 12].mCurrentValue = 0.0f; + mTimedParam.mMoveParams[i + 12].mTargetValue = 0.0f; } - field_0x16c.move[5].field_0x0 = 0.0f; - field_0x16c.move[5].field_0x4 = 0.0f; + mTimedParam.mMoveParams[5].mCurrentValue = 0.0f; + mTimedParam.mMoveParams[5].mTargetValue = 0.0f; } static void dummy() { @@ -258,49 +258,49 @@ static void dummy() { /* 802811DC-80281258 .text connectBus__Q28JASystem6TTrackFii */ void JASystem::TTrack::connectBus(int line, int param_2) { JUT_ASSERT(486, line < (6)); - field_0xf8.field_0x4e[line] = param_2; + mChannelUpdater.field_0x4e[line] = param_2; } /* 80281258-802814AC .text noteOn__Q28JASystem6TTrackFUclllUl */ 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)) { + if (field_0x386 && (mPauseStatus & 0x40)) { return -1; } noteOff(param_1, 0); - TChannelMgr* r31 = &field_0xf8; + TChannelMgr* r31 = &mChannelUpdater; TTrack* parent = mParent; while (r31->field_0x0 == 0 || r31->field_0x8 == 0) { if (!parent) { - r31 = &field_0xf8; + r31 = &mChannelUpdater; break; } - r31 = &parent->field_0xf8; + r31 = &parent->mChannelUpdater; parent = parent->mParent; } if (field_0x37b == 4) { JUT_ASSERT(527, mParent != NULL); - if (r31 != &mParent->field_0xf8) { - if (moveFreeChannel(r31, &mParent->field_0xf8, 1) != 1) { + if (r31 != &mParent->mChannelUpdater) { + if (moveFreeChannel(r31, &mParent->mChannelUpdater, 1) != 1) { OSReport("in Player (NOTE-MODE) ... ボイス借用に失敗しました！！ (%d)\n", r31->field_0x0); } - r31 = &mParent->field_0xf8; + r31 = &mParent->mChannelUpdater; } - } else if (r31 != &field_0xf8) { - if (moveFreeChannel(r31, &field_0xf8, 1) != 1) { + } else if (r31 != &mChannelUpdater) { + if (moveFreeChannel(r31, &mChannelUpdater, 1) != 1) { OSReport("in Player ボイス借用に失敗しました！！ (%d)\n", r31->field_0x0); } - r31 = &field_0xf8; + r31 = &mChannelUpdater; } - u8 bankNum = field_0x28c.getBankNumber(); + u8 bankNum = mRegisterParam.getBankNumber(); u8 physNum = BankMgr::getPhysicalNumber(bankNum); - u8 progNum = field_0x28c.getProgramNumber(); + u8 progNum = mRegisterParam.getProgramNumber(); TChannel* channel = BankMgr::noteOn(r31, physNum, progNum, param_2, param_3, param_4); if (!channel) { return -1; } - field_0xb4.setChannel(param_1, channel); + mNoteMgr.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); + channel->setPanPower(mRegisterParam.mPanPower[0], mRegisterParam.mPanPower[1], mRegisterParam.mPanPower[2], 0.0f); overwriteOsc(channel); if (field_0x374) { channel->directReleaseOsc(0, field_0x374); @@ -313,7 +313,7 @@ void JASystem::TTrack::overwriteOsc(TChannel* param_1) { /* Nonmatching */ u32 r28; for (int i = 0; i < 2; i++) { - u32 var1 = field_0x2fc[i]; + u32 var1 = mOscRoute[i]; if (var1 == 0x0f) { continue; } @@ -339,7 +339,7 @@ void JASystem::TTrack::overwriteOsc(TChannel* param_1) { /* 802815DC-8028165C .text noteOff__Q28JASystem6TTrackFUcUs */ bool JASystem::TTrack::noteOff(u8 param_1, u16 param_2) { - TChannel* channel = field_0xb4.getChannel(param_1); + TChannel* channel = mNoteMgr.getChannel(param_1); if (!channel) { return false; } @@ -348,13 +348,13 @@ bool JASystem::TTrack::noteOff(u8 param_1, u16 param_2) { } else { channel->stop(param_2); } - field_0xb4.releaseChannel(param_1); + mNoteMgr.releaseChannel(param_1); return true; } /* 8028165C-802816C4 .text gateOn__Q28JASystem6TTrackFUclll */ int JASystem::TTrack::gateOn(u8 param_1, s32 param_2, s32 param_3, s32 param_4) { - TChannel* channel = field_0xb4.getChannel(param_1); + TChannel* channel = mNoteMgr.getChannel(param_1); if (!channel) { return -1; } @@ -364,7 +364,7 @@ int JASystem::TTrack::gateOn(u8 param_1, s32 param_2, s32 param_3, s32 param_4) /* 802816C4-80281708 .text checkNoteStop__Q28JASystem6TTrackFl */ int JASystem::TTrack::checkNoteStop(s32 param_1) { - TChannel* channel = field_0xb4.getChannel(param_1); + TChannel* channel = mNoteMgr.getChannel(param_1); if (channel == NULL) { return true; } @@ -390,7 +390,7 @@ void JASystem::TTrack::oscSetupFull(u8 param_1, u32 param_2, u32 param_3) { if (param_2 == 0) { field_0x2cc[var1].table = NULL; } - field_0x2cc[var1].table = field_0x0.field_0x0 + param_2; + field_0x2cc[var1].table = mSeqCtrl.mRawFilePtr + param_2; } if (!var5) { return; @@ -398,7 +398,7 @@ void JASystem::TTrack::oscSetupFull(u8 param_1, u32 param_2, u32 param_3) { if (param_3 == 0) { field_0x2cc[var1].rel_table = Player::sRelTable; } - field_0x2cc[var1].rel_table = field_0x0.field_0x0 + param_2; + field_0x2cc[var1].rel_table = mSeqCtrl.mRawFilePtr + param_2; } /* 802817E4-80281850 .text oscSetupSimpleEnv__Q28JASystem6TTrackFUcUl */ @@ -406,10 +406,10 @@ 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; + field_0x2cc[0].table = mSeqCtrl.mRawFilePtr + param_2; break; case 1: - field_0x2cc[0].rel_table = field_0x0.field_0x0 + param_2; + field_0x2cc[0].rel_table = mSeqCtrl.mRawFilePtr + param_2; break; } } @@ -506,7 +506,7 @@ bool JASystem::TTrack::setSeqData(u8* param_1, s32, int) { /* Nonmatching */ init(); field_0x37b = 3; - field_0x0.start(param_1, 0); + mSeqCtrl.start(param_1, 0); updateTrackAll(); field_0x37e = 2; return true; @@ -546,7 +546,7 @@ void JASystem::TTrack::muteTrack(bool) { /* 80282B44-80282B84 .text start__Q28JASystem6TTrackFPvUl */ bool JASystem::TTrack::start(void* param_1, u32 param_2) { /* Nonmatching */ - field_0x0.start(param_1, param_2); + mSeqCtrl.start(param_1, param_2); field_0x37e = 1; updateTrackAll(); return false; @@ -562,15 +562,15 @@ 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]; + return mSeqCtrl.mRawFilePtr[param_1 + param_2]; case 5: - return field_0x0.get16(param_1 + param_2 * 2); + return mSeqCtrl.get16(param_1 + param_2 * 2); case 6: - return field_0x0.get24(param_1 + param_2 * 3); + return mSeqCtrl.get24(param_1 + param_2 * 3); case 7: - return field_0x0.get32(param_1 + param_2 * 4); + return mSeqCtrl.get32(param_1 + param_2 * 4); case 8: - return field_0x0.get32(param_1 + param_2); + return mSeqCtrl.get32(param_1 + param_2); } } @@ -580,12 +580,12 @@ int JASystem::TTrack::exchangeRegisterValue(u8) { } /* 80282DC0-80282ED4 .text readReg32__Q28JASystem6TTrackFUc */ -void JASystem::TTrack::readReg32(u8) { +u32 JASystem::TTrack::readReg32(u8) { /* Nonmatching */ } /* 80282ED4-802830AC .text readReg16__Q28JASystem6TTrackFUc */ -void JASystem::TTrack::readReg16(u8) { +u16 JASystem::TTrack::readReg16(u8) { /* Nonmatching */ } @@ -602,13 +602,13 @@ void JASystem::TTrack::writeRegParam(u8) { /* 802836FC-80283720 .text readSelfPort__Q28JASystem6TTrackFi */ u16 JASystem::TTrack::readSelfPort(int param_1) { /* Nonmatching */ - return field_0x48.readImport(param_1); + return mTrackPort.readImport(param_1); } /* 80283720-80283744 .text writeSelfPort__Q28JASystem6TTrackFiUs */ void JASystem::TTrack::writeSelfPort(int param_1, u16 param_2) { /* Nonmatching */ - field_0x48.writeExport(param_1, param_2); + mTrackPort.writeExport(param_1, param_2); } /* 80283744-802837AC .text writePortAppDirect__Q28JASystem6TTrackFUlUs */ @@ -704,15 +704,15 @@ JASystem::TVibrate::TVibrate() { /* 80283ECC-80283EE4 .text init__Q28JASystem8TVibrateFv */ void JASystem::TVibrate::init() { /* Nonmatching */ - field_0x8 = 1.0f / 18.0f; - field_0x4 = 0.0f; + mPitch = 1.0f / 18.0f; + mDepth = 0.0f; field_0x0 = 0.0f; } /* 80283EE4-80283F18 .text incCounter__Q28JASystem8TVibrateFv */ void JASystem::TVibrate::incCounter() { /* Nonmatching */ - field_0x0 += field_0x8; + field_0x0 += mPitch; if (!(field_0x0 >= 4.0)) { return; } @@ -727,10 +727,10 @@ f32 JASystem::TVibrate::getValue() const { /* 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; + mCurrentValue = 0.0f; + mTargetValue = 0.0f; + mMoveTime = 0.0f; + mMoveAmount = 0.0f; } /* 80283FE8-80284118 .text __ct__Q38JASystem6TTrack12AInnerParam_Fv */ diff --git a/src/JSystem/JAudio/JASTrackPort.cpp b/src/JSystem/JAudio/JASTrackPort.cpp index b55e5341f..9a7eb6f42 100644 --- a/src/JSystem/JAudio/JASTrackPort.cpp +++ b/src/JSystem/JAudio/JASTrackPort.cpp @@ -12,36 +12,36 @@ const u32 MAX_PORTS = 16; void JASystem::TTrackPort::init() { /* Nonmatching */ for (int i = 0; i < 16; i++) { - field_0x0[i] = 0; - field_0x10[i] = 0; - field_0x20[i] = 0; + mImportFlag[i] = 0; + mExportFlag[i] = 0; + mValue[i] = 0; } } /* 802842E8-8028437C .text readImport__Q28JASystem10TTrackPortFi */ u16 JASystem::TTrackPort::readImport(int port_num) { JUT_ASSERT(31, port_num >= 0 && port_num < MAX_PORTS); - field_0x0[port_num] = 0; - return field_0x20[port_num]; + mImportFlag[port_num] = 0; + return mValue[port_num]; } /* 8028437C-80284414 .text readExport__Q28JASystem10TTrackPortFi */ u16 JASystem::TTrackPort::readExport(int port_num) { JUT_ASSERT(38, port_num >= 0 && port_num < MAX_PORTS); - field_0x10[port_num] = 0; - return field_0x20[port_num]; + mExportFlag[port_num] = 0; + return mValue[port_num]; } /* 80284414-802844AC .text writeImport__Q28JASystem10TTrackPortFiUs */ void JASystem::TTrackPort::writeImport(int port_num, u16 value) { JUT_ASSERT(45, port_num >= 0 && port_num < MAX_PORTS); - field_0x0[port_num] = 1; - field_0x20[port_num] = value; + mImportFlag[port_num] = 1; + mValue[port_num] = value; } /* 802844AC-80284548 .text writeExport__Q28JASystem10TTrackPortFiUs */ void JASystem::TTrackPort::writeExport(int port_num, u16 value) { JUT_ASSERT(51, port_num >= 0 && port_num < MAX_PORTS); - field_0x10[port_num] = 1; - field_0x20[port_num] = value; + mExportFlag[port_num] = 1; + mValue[port_num] = value; }