Names mixed in with some BE fixes

include/Z2AudioLib/Z2DebugSys.h

@@ -27,7 +27,7 @@ public:
     virtual ~Z2HioSeSeqDataMgr() {}
     virtual SeqDataReturnValue getSeqData(JAISoundID param_1, JAISeqData* param_2) {
         if (field_0x18->getSeqList()->getSeqData(param_1, param_2)) {
-            param_2->field_0x4 = 4;
+            param_2->mOffset = 4;
             return SeqDataReturnValue_2;
         } else {
             return JAUSeqDataMgr_SeqCollection::getSeqData(param_1, param_2);

libs/JSystem/include/JSystem/JAudio2/JAISeqDataMgr.h

@@ -10,17 +10,17 @@
  */
 struct JAISeqData {
     JAISeqData(const void* param_0, u32 param_1) {
-        field_0x0 = (void*)param_0;
-        field_0x4 = param_1;
+        mBase = (void*)param_0;
+        mOffset = param_1;
     }
 
     void set(const void* param_0, u32 param_1) {
-        field_0x0 = (void*)param_0;
-        field_0x4 = param_1;
+        mBase = (void*)param_0;
+        mOffset = param_1;
     }
 
-    /* 0x00 */ void* field_0x0;
-    /* 0x04 */ u32 field_0x4;
+    /* 0x00 */ void* mBase;
+    /* 0x04 */ u32 mOffset;
 };
 
 /**
@@ -29,10 +29,10 @@ struct JAISeqData {
  */
 struct JAISeqDataRegion {
     bool intersects(const JAISeqData& seqData) const {
-        if ((uintptr_t)addr + size < (uintptr_t)seqData.field_0x0) {
+        if ((uintptr_t)addr + size < (uintptr_t)seqData.mBase) {
             return false;
         }
-        if ((uintptr_t)seqData.field_0x0 + seqData.field_0x4 < (uintptr_t)addr) {
+        if ((uintptr_t)seqData.mBase + seqData.mOffset < (uintptr_t)addr) {
             return false;
         }
         return true;

libs/JSystem/include/JSystem/JAudio2/JASSeqParser.h

@@ -14,9 +14,9 @@ public:
     enum BranchCondition {};
 
     struct CmdInfo {
-        s32 (JASSeqParser::*field_0x0)(JASTrack*, u32*);
-        u16 field_0xc;
-        u16 field_0xe;
+        s32 (JASSeqParser::*mHandler)(JASTrack*, u32*);
+        u16 mParameterCount;
+        u16 mParameterTypes;
     };
 
     virtual ~JASSeqParser() {}

libs/JSystem/include/JSystem/JAudio2/JASSeqReader.h

@@ -3,6 +3,8 @@
 
 #include <types.h>
 
+#define JAS_SEQ_STACK_SIZE 8
+
 /**
  * @ingroup jsystem-jaudio
  * 
@@ -19,55 +21,55 @@ public:
     int readMidiValue();
 
     void jump(u32 param_1) {
-        field_0x04 = field_0x00 + param_1;
+        mCurPos = mBase + param_1;
     }
 
     void jump(void* param_1) {
-        field_0x04 = (u8*)param_1;
+        mCurPos = (u8*)param_1;
     }
 
     u32 get24(u32 param_0) const {
-        return (*(u32*)(field_0x00 + param_0 - 1)) & 0xffffff;
+        return (*(BE(u32)*)(mBase + param_0 - 1)) & 0xffffff;
     }
 
-    u32* getBase() { return (u32*)field_0x00; }
-    void* getAddr(u32 param_0) { return field_0x00 + param_0; }
-    u8 getByte(u32 param_0) const { return *(field_0x00 + param_0); }
-    u16 get16(u32 param_0) const { return *(u16*)(field_0x00 + param_0); }
-    u32 get32(u32 param_0) const { return *(u32*)(field_0x00 + param_0); }
-    u8* getCur() { return field_0x04; }
-    u32 readByte() { return *field_0x04++; }
+    u32* getBase() { return (u32*)mBase; }
+    void* getAddr(u32 param_0) { return mBase + param_0; }
+    u8 getByte(u32 param_0) const { return *(mBase + param_0); }
+    u16 get16(u32 param_0) const { return *(BE(u16)*)(mBase + param_0); }
+    u32 get32(u32 param_0) const { return *(BE(u32)*)(mBase + param_0); }
+    u8* getCur() { return mCurPos; }
+    u32 readByte() { return *mCurPos++; }
     u32 read16() {
 #ifdef __MWERKS__
-        return *((u16*)field_0x04)++;
+        return *((u16*)mCurPos)++;
 #else
-        BE(u16)* value = (BE(u16)*)field_0x04;
-        field_0x04 += 2;
+        BE(u16)* value = (BE(u16)*)mCurPos;
+        mCurPos += 2;
         return *value;
 #endif
     }
     u32 read24() {
-        field_0x04--;
+        mCurPos--;
 #ifdef __MWERKS__
-        return (*((u32*)field_0x04)++) & 0x00ffffff;
+        return (*((u32*)mCurPos)++) & 0x00ffffff;
 #else
-        BE(u32)* value = (BE(u32)*)field_0x04;
-        field_0x04 += 4;
+        BE(u32)* value = (BE(u32)*)mCurPos;
+        mCurPos += 4;
         return (*value) & 0x00ffffff;
 #endif
     }
     u16 getLoopCount() const { 
-        if (field_0x08 == 0) {
+        if (mCurStackDepth == 0) {
             return 0;
          } 
-         return field_0x2c[field_0x08 - 1]; 
+         return mLoopCount[mCurStackDepth - 1];
     }
 
-    /* 0x00 */ u8* field_0x00;
-    /* 0x04 */ u8* field_0x04;
-    /* 0x08 */ u32 field_0x08;
-    /* 0x0C */ u16* field_0x0c[8];
-    /* 0x2C */ u16 field_0x2c[8];
+    /* 0x00 */ u8* mBase;
+    /* 0x04 */ u8* mCurPos;
+    /* 0x08 */ u32 mCurStackDepth;
+    /* 0x0C */ u16* mReturnAddr[JAS_SEQ_STACK_SIZE];
+    /* 0x2C */ u16 mLoopCount[JAS_SEQ_STACK_SIZE];
 };
 
 #endif /* JASSEQREADER_H */

libs/JSystem/include/JSystem/JAudio2/JASTrackPort.h

@@ -19,12 +19,12 @@ public:
     u32 checkImport(u32) const;
     u32 checkExport(u32) const;
 
-    u16 get(u32 param_0) const { return field_0x4[param_0]; }
-    void set(u32 param_0, u16 param_1) { field_0x4[param_0] = param_1; }
+    u16 get(u32 param_0) const { return mPortValues[param_0]; }
+    void set(u32 param_0, u16 param_1) { mPortValues[param_0] = param_1; }
 
     u16 field_0x0;
     u16 field_0x2;
-    u16 field_0x4[MAX_PORTS];
+    u16 mPortValues[MAX_PORTS];
 };
 
 #endif /* JASTRACKPORT_H */

libs/JSystem/include/JSystem/JAudio2/JAUAudibleParam.h

@@ -2,6 +2,7 @@
 #define JAUAUDIBLEPARAM_H
 
 #include <types.h>
+#include "dusk/endian.h"
 
 /**
  * @ingroup jsystem-jaudio
@@ -14,8 +15,8 @@ struct JAUAudibleParam {
 
     union {
         struct {
-            u16 f0;
-            u16 f1;
+            BE(u16) f0;
+            BE(u16) f1;
         } half;
         struct {
             u8 b0_0 : 4;
@@ -29,7 +30,7 @@ struct JAUAudibleParam {
             u8 b2;
             u8 b3;
         } bytes;
-        u32 raw;
+        BE(u32) raw;
     } field_0x0;
 };
 

libs/JSystem/include/JSystem/JAudio2/JAUSeqCollection.h

@@ -11,11 +11,11 @@ struct JAISeqDataRegion;
  * 
  */
 struct JAUSeqCollectionData {
-    s8 field_0x0;
-    s8 field_0x1;
-    BE(u16) field_0x2;
-    BE(u32) field_0x4;
-    BE(u32) field_0x8;
+    s8 mMagic1; // 'S'
+    s8 mMagic2; // 'C'
+    BE(u16) mNumSoundCategories;
+    BE(u32) mSectionSize;
+    BE(u32) mTableOffsets[0]; // VLA
 };
 
 /**
@@ -29,12 +29,12 @@ public:
     bool getSeqData(int, int, JAISeqData*);
     bool getSeqDataRegion(JAISeqDataRegion*);
 
-    bool isValid() const { return field_0x8; }
+    bool isValid() const { return mHeader; }
 
-    /* 0x00 */ u16 field_0x0;
-    /* 0x04 */ const BE(u32)* field_0x4;
-    /* 0x08 */ const JAUSeqCollectionData* field_0x8;
-    /* 0x0C */ int field_0xc;
+    /* 0x00 */ u16 mNumSoundCategories;
+    /* 0x04 */ const BE(u32)* mTableOffsets;
+    /* 0x08 */ const JAUSeqCollectionData* mHeader;
+    /* 0x0C */ u32 mSectionSize;
 };
 
 /**
@@ -49,7 +49,7 @@ public:
     SeqDataReturnValue getSeqData(JAISoundID, JAISeqData*);
     ~JAUSeqDataMgr_SeqCollection();
 
-    const void* getResource() const { return field_0x4; }
+    const void* getResource() const { return mTableOffsets; }
     void init(const void* param_1) { JAUSeqCollection::init(param_1); }
 
     /* 0x14 */ JAISeqDataUser* user_;

libs/JSystem/src/JAudio2/JAISe.cpp

@@ -57,7 +57,7 @@ void JAISe::startTrack_(const JASSoundParams& params) {
     }
 
     inner_.field_0x26c = 1;
-    inner_.track.setSeqData(inner_.mSeqData.field_0x0, inner_.mSeqData.field_0x4);
+    inner_.track.setSeqData(inner_.mSeqData.mBase, inner_.mSeqData.mOffset);
     inner_.track.startSeq();
 }
 

libs/JSystem/src/JAudio2/JAISeq.cpp

@@ -40,7 +40,7 @@ void JAISeq::JAISeqMgr_startID_(JAISoundID id, const JGeometry::TVec3<f32>* posP
 void JAISeq::playSeqData_(const JASSoundParams& params, JAISoundActivity activity) {
     JUT_ASSERT(72, JASTrack_isFreeOrStopped( & inner_.outputTrack ));
 
-    inner_.outputTrack.setSeqData(inner_.mSeqData.field_0x0, inner_.mSeqData.field_0x4);
+    inner_.outputTrack.setSeqData(inner_.mSeqData.mBase, inner_.mSeqData.mOffset);
     if (audible_) {
         initTrack_JAISound_(&inner_.outputTrack);
     } else {

libs/JSystem/src/JAudio2/JASSeqCtrl.cpp

@@ -34,9 +34,9 @@ void JASSeqCtrl::init() {
     field_0x51 = 0;
 }
 
-void JASSeqCtrl::start(void* param_0, u32 param_1) {
-    mReader.init(param_0);
-    mReader.jump(param_1);
+void JASSeqCtrl::start(void* base, u32 offset) {
+    mReader.init(base);
+    mReader.jump(offset);
 }
 
 int JASSeqCtrl::tickProc(JASTrack* param_0) {

libs/JSystem/src/JAudio2/JASSeqParser.cpp

@@ -959,10 +959,10 @@ s32 JASSeqParser::parseCommand(JASTrack* param_0, u8 cmd, u16 param_2) {
     } else {
         cmdInfo = &sExtCmdInfo[seqCtrl->readByte() & 0xff];
     }
-    u16 r28 = (u16)cmdInfo->field_0xe;
+    u16 r28 = (u16)cmdInfo->mParameterTypes;
     r28 |= param_2;
     u32 stack_28[8];
-    for (int i = 0; i < cmdInfo->field_0xc; i++, r28 >>= 2) {
+    for (int i = 0; i < cmdInfo->mParameterCount; i++, r28 >>= 2) {
         int r27 = 0;
         switch (r28 & 3) {
         case 0:
@@ -980,11 +980,11 @@ s32 JASSeqParser::parseCommand(JASTrack* param_0, u8 cmd, u16 param_2) {
         }
         stack_28[i] = r27;
     }
-    s32 (JASSeqParser::*ptr)(JASTrack*, u32*) = cmdInfo->field_0x0;
+    s32 (JASSeqParser::*ptr)(JASTrack*, u32*) = cmdInfo->mHandler;
     if (!ptr) {
         return 0;
     }
-    return execCommand(param_0, ptr, cmdInfo->field_0xc, stack_28);
+    return execCommand(param_0, ptr, cmdInfo->mParameterCount, stack_28);
 }
 
 s32 JASSeqParser::parseRegCommand(JASTrack* param_0, int param_1) {

libs/JSystem/src/JAudio2/JASSeqReader.cpp

@@ -8,81 +8,81 @@
 #include "JSystem/JAudio2/JASSeqReader.h"
 
 void JASSeqReader::init() {
-    field_0x00 = 0;
-    field_0x04 = 0;
-    field_0x08 = 0;
+    mBase = 0;
+    mCurPos = 0;
+    mCurStackDepth = 0;
 
-    for (int i = 0; i < 8; i++) {
-        field_0x0c[i] = NULL;
-        field_0x2c[i] = 0;
+    for (int i = 0; i < JAS_SEQ_STACK_SIZE; i++) {
+        mReturnAddr[i] = NULL;
+        mLoopCount[i] = 0;
     }
 }
 
-void JASSeqReader::init(void* param_0) {
-    field_0x00 = (u8*)param_0;
-    field_0x04 = field_0x00;
-    field_0x08 = 0;
+void JASSeqReader::init(void* base) {
+    mBase = (u8*)base;
+    mCurPos = mBase;
+    mCurStackDepth = 0;
 
-    for (int i = 0; i < 8; i++) {
-        field_0x0c[i] = NULL;
-        field_0x2c[i] = 0;
+    for (int i = 0; i < JAS_SEQ_STACK_SIZE; i++) {
+        mReturnAddr[i] = NULL;
+        mLoopCount[i] = 0;
     }
     
 }
 
 bool JASSeqReader::call(u32 param_0) {
-    if (field_0x08 >= 8) {
+    if (mCurStackDepth >= JAS_SEQ_STACK_SIZE) {
         JUT_WARN(42, "%s", "Cannot exec call command");
         return false;
     }
 
-    field_0x0c[field_0x08++] = (u16*)field_0x04;
-    field_0x04 = field_0x00 + param_0;
+    mReturnAddr[mCurStackDepth++] = (u16*)mCurPos;
+    mCurPos = mBase + param_0;
 
     return true;
 }
 
 bool JASSeqReader::loopStart(u32 param_0) {
-    if (8 <= field_0x08) {
+    if (JAS_SEQ_STACK_SIZE <= mCurStackDepth) {
         JUT_WARN(53, "%s", "Cannot exec loopStart command");
         return false;
     }
 
-    field_0x0c[field_0x08] = (u16*)field_0x04;
-    field_0x2c[field_0x08++] = param_0;
+    mReturnAddr[mCurStackDepth] = (u16*)mCurPos;
+    mLoopCount[mCurStackDepth++] = param_0;
 
     return true;
 }
 
 
 bool JASSeqReader::loopEnd() {
-    if (field_0x08 == 0) {
+    if (mCurStackDepth == 0) {
         JUT_WARN(65, "%s", "cannot loopE for call-stack is NULL");
         return false;
     }
 
-    u16 tmp = field_0x2c[field_0x08 - 1];
+    u16 tmp = mLoopCount[mCurStackDepth - 1];
 
     if (tmp != 0) {
         tmp--;
     }
 
     if (!tmp) {
-        field_0x08--;
+        mCurStackDepth--;
         return true;
     }
 
-    field_0x2c[field_0x08 - 1] = tmp;
-    field_0x04 = (u8*)field_0x0c[field_0x08 - 1];
+    mLoopCount[mCurStackDepth - 1] = tmp;
+    mCurPos = (u8*)mReturnAddr[mCurStackDepth - 1];
     return true;
 }
 
 bool JASSeqReader::ret() {
-    if (field_0x08 == 0) {
+    if (mCurStackDepth == 0) {
         return false;
     }
 
-    field_0x04 = (u8*)field_0x0c[--field_0x08];
+    mCurPos = (u8*)mReturnAddr[--mCurStackDepth];
 
     return true;
 }

libs/JSystem/src/JAudio2/JASTrack.cpp

@@ -171,9 +171,9 @@ void JASTrack::assignExtBuffer(u32 index, JASSoundParams* i_soundParams) {
     mChannelMgrs[index]->mSoundParams = i_soundParams;
 }
 
-void JASTrack::setSeqData(void* param_0, u32 param_1) {
+void JASTrack::setSeqData(void* base, u32 offset) {
     JUT_ASSERT(257, mStatus == STATUS_FREE);
-    mSeqCtrl.start(param_0, param_1);
+    mSeqCtrl.start(base, offset);
 }
 
 void JASTrack::startSeq() {

libs/JSystem/src/JAudio2/JASTrackPort.cpp

@@ -3,8 +3,8 @@
 #include "JSystem/JAudio2/JASTrackPort.h"
 
 void JASTrackPort::init() {
-    for (int i = 0; i < 16; i++) {
-        field_0x4[i] = 0;
+    for (int i = 0; i < MAX_PORTS; i++) {
+        mPortValues[i] = 0;
     }
     field_0x0 = 0;
     field_0x2 = 0;
@@ -13,25 +13,25 @@ void JASTrackPort::init() {
 u16 JASTrackPort::readImport(u32 port_num) {
     JUT_ASSERT(27, port_num < MAX_PORTS);
     field_0x0 = field_0x0 & ~(1 << port_num);
-    return field_0x4[port_num];
+    return mPortValues[port_num];
 }
 
 u16 JASTrackPort::readExport(u32 port_num) {
     JUT_ASSERT(34, port_num < MAX_PORTS);
     field_0x2 = field_0x2 & ~(1 << port_num);
-    return field_0x4[port_num];
+    return mPortValues[port_num];
 }
 
 void JASTrackPort::writeImport(u32 port_num, u16 param_1) {
     JUT_ASSERT(41, port_num < MAX_PORTS);
     field_0x0 = field_0x0 | (1 << port_num);
-    field_0x4[port_num] = param_1;
+    mPortValues[port_num] = param_1;
 }
 
 void JASTrackPort::writeExport(u32 port_num, u16 param_1) {
     JUT_ASSERT(47, port_num < MAX_PORTS);
     field_0x2 = field_0x2 | (1 << port_num);
-    field_0x4[port_num] = param_1;
+    mPortValues[port_num] = param_1;
 }
 
 u32 JASTrackPort::checkImport(u32 param_0) const {

libs/JSystem/src/JAudio2/JAUSeqCollection.cpp

@@ -4,39 +4,39 @@
 #include "JSystem/JUtility/JUTAssert.h"
 
 JAUSeqCollection::JAUSeqCollection() {
-    field_0x8 = NULL;
+    mHeader = NULL;
 }
 
 void JAUSeqCollection::init(void const* param_0) {
-    field_0x8 = (const JAUSeqCollectionData*)param_0;
-    if (field_0x8->field_0x0 != 0x53 || field_0x8->field_0x1 != 0x43) {
-        field_0x8 = NULL;
+    mHeader = (const JAUSeqCollectionData*)param_0;
+    if (mHeader->mMagic1 != 0x53 || mHeader->mMagic2 != 0x43) {
+        mHeader = NULL;
         return;
     }
 
-    field_0x0 = field_0x8->field_0x2;
-    field_0xc = field_0x8->field_0x4;
-    field_0x4 = &field_0x8->field_0x8;
+    mNumSoundCategories = mHeader->mNumSoundCategories;
+    mSectionSize = mHeader->mSectionSize;
+    mTableOffsets = mHeader->mTableOffsets;
 
 }
 
 bool JAUSeqCollection::getSeqData(int param_0, int param_1, JAISeqData* param_2) {
-    if (param_0 >= field_0x0) {
+    if (param_0 >= mNumSoundCategories) {
         return false;
     }
-    u32 r29 = field_0x4[param_0];
-    BE(u32)* puVar2 = (BE(u32)*)((u8*)field_0x8 + r29);
+    u32 r29 = mTableOffsets[param_0];
+    BE(u32)* puVar2 = (BE(u32)*)((u8*)mHeader + r29);
     if (param_1 >= puVar2[0]) {
         return false;
     }
-    param_2->set((void*)field_0x8, puVar2[param_1 + 1]);
+    param_2->set((void*)mHeader, puVar2[param_1 + 1]);
     return true;
 }
 
 bool JAUSeqCollection::getSeqDataRegion(JAISeqDataRegion* param_0) {
     if (isValid()) {
-        param_0->addr = (u8*)field_0x8;
-        param_0->size = field_0xc;
+        param_0->addr = (u8*)mHeader;
+        param_0->size = mSectionSize;
         return true;
     }
     return false;

libs/JSystem/src/JAudio2/JAUSeqDataBlockMgr.cpp

@@ -87,8 +87,8 @@ s32 JAUDynamicSeqDataBlocks::getSeqData(JAISoundID param_0, JAISeqDataUser* para
 
     u8* seqData = mLoadedBlocks.getSeqData(param_0);
     if (seqData != NULL) {
-        param_2->field_0x0 = seqData;
-        param_2->field_0x4 = 0;
+        param_2->mBase = seqData;
+        param_2->mOffset = 0;
         return 2;
     }