JAudio naming pass (#3139)

* struct JASWaveArc forward declare fix * JASAramStream::THeader improvement * sizeof/offsetof unhardcodings * JAudio field name/comment pass HUGE thanks to XAYRGA for their work documenting JAudio file formats * Some more names * More names * More minor names * Attempt to fix regressions
2026-06-25 18:04:43 -04:00 · 2026-06-20 02:44:05 +02:00
parent 3f24f432fe
commit 853a6addb4
54 changed files with 767 additions and 574 deletions
@@ -26,7 +26,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);
@@ -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;
@@ -17,6 +17,8 @@ namespace JASDsp {
 */
 class JASAramStream {
 public:
+    static const int CHANNEL_MAX = 6;
+
    typedef void (*StreamCallback)(u32, JASAramStream*, void*);

    enum CallbackType {
@@ -32,29 +34,30 @@ public:
    };

    struct Header {
-        /* 0x00 */ u32 tag;
-        /* 0x04 */ u8 field_0x4[5];
+        /* 0x00 */ u32 tag; // 'STRM'
+        /* 0x04 */ u32 soundBlockSize;
+        /* 0x08 */ u8 field_0x08;
        /* 0x09 */ u8 format;
-        /* 0x0A */ u8 bits;
+        /* 0x0A */ u16 bits;
        /* 0x0C */ u16 channels;
        /* 0x0E */ u16 loop;
-        /* 0x10 */ int field_0x10;
-        /* 0x14 */ u8 field_0x14[4];
+        /* 0x10 */ int mSampleRate;
+        /* 0x14 */ u32 mSampleCount; // unused
        /* 0x18 */ int loop_start;
        /* 0x1C */ int loop_end;
        /* 0x20 */ u32 block_size;
-        /* 0x24 */ u8 field_0x24[4];
-        /* 0x28 */ u8 field_0x28;
-        /* 0x29 */ u8 field_0x29[0x17];
+        /* 0x24 */ u8 _unused2[4];
+        /* 0x28 */ u8 mVolume;
+        /* 0x29 */ u8 _unused3[0x17];
    };  // Size: 0x40

    struct BlockHeader {
-        /* 0x00 */ u32 tag;
-        /* 0x04 */ u32 field_0x4;
+        /* 0x00 */ u32 tag; // 'BLCK'
+        /* 0x04 */ u32 mSize;
        /* 0x08 */ struct {
-            s16 field_0x0;
-            s16 field_0x2;
-        } field_0x8[6];
+            s16 mpLast;
+            s16 mpPenult;
+        } mAdpcmContinuationData[CHANNEL_MAX];
    };  // Size: 0x20

    static void initSystem(u32, u32);
@@ -128,14 +131,12 @@ public:

    static u32 getBlockSize() { return sBlockSize; }

-    static const int CHANNEL_MAX = 6;
-
    /* 0x000 */ OSMessageQueue field_0x000;
    /* 0x020 */ OSMessageQueue field_0x020;
    /* 0x040 */ void* field_0x040[16];
    /* 0x080 */ void* field_0x080[4];
    /* 0x090 */ JASChannel* mChannels[CHANNEL_MAX];
-    /* 0x0A8 */ JASChannel* field_0x0a8;
+    /* 0x0A8 */ JASChannel* mInitialChannel;
    /* 0x0AC */ bool field_0x0ac;
    /* 0x0AD */ bool field_0x0ad;
    /* 0x0AE */ u8 field_0x0ae;
@@ -157,17 +158,17 @@ public:
    /* 0x124 */ int field_0x124;
    /* 0x128 */ u16 field_0x128;
    /* 0x12C */ int field_0x12c;
-    /* 0x130 */ s16 field_0x130[CHANNEL_MAX];
-    /* 0x13C */ s16 field_0x13c[CHANNEL_MAX];
-    /* 0x148 */ int field_0x148;
-    /* 0x14C */ u32 field_0x14c;
+    /* 0x130 */ s16 mpLasts[CHANNEL_MAX];
+    /* 0x13C */ s16 mpPenults[CHANNEL_MAX];
+    /* 0x148 */ int mAramAddress;
+    /* 0x14C */ u32 mAramSize;
    /* 0x150 */ StreamCallback mCallback;
    /* 0x154 */ void* mCallbackData;
-    /* 0x158 */ u16 field_0x158;
+    /* 0x158 */ u16 mFormat;
    /* 0x15A */ u16 mChannelNum;
    /* 0x15C */ u32 mBufCount;
-    /* 0x160 */ u32 field_0x160;
-    /* 0x164 */ u32 field_0x164;
+    /* 0x160 */ u32 mAramBlocksPerChannel;
+    /* 0x164 */ u32 mSampleRate;
    /* 0x168 */ bool mLoop;
    /* 0x16C */ u32 mLoopStart;
    /* 0x170 */ u32 mLoopEnd;
@@ -177,7 +178,7 @@ public:
    /* 0x194 */ f32 mChannelPan[CHANNEL_MAX];
    /* 0x1AC */ f32 mChannelFxMix[CHANNEL_MAX];
    /* 0x1C4 */ f32 mChannelDolby[CHANNEL_MAX];
-    /* 0x1DC */ u16 field_0x1dc[CHANNEL_MAX];
+    /* 0x1DC */ u16 mMixConfig[CHANNEL_MAX];

    static JASTaskThread* sLoadThread;
    static u8* sReadBuffer;
@@ -12,19 +12,19 @@ namespace JASBNKParser {
    struct TFileHeader {
        /* 0x0 */ int id;
        /* 0x4 */ u32 mSize;
-        /* 0x8 */ u8 _08[4];
+        /* 0x8 */ u32 mGlobalId;
        /* 0xC */ u32 mVersion;
    };

    namespace Ver1 {
        struct TOsc {
-            /* 0x00 */ u32 id;
+            /* 0x00 */ u32 id; // "Osci"
            /* 0x04 */ u8 mTarget;
-            /* 0x08 */ f32 _08;
-            /* 0x0C */ u32 mTableOffset;
-            /* 0x10 */ u32 _10;
-            /* 0x14 */ f32 mScale;
-            /* 0x18 */ f32 _18;
+            /* 0x08 */ f32 mRate;
+            /* 0x0C */ u32 mAttackEnvelopeOffset;
+            /* 0x10 */ u32 mReleaseEnvelopeOffset;
+            /* 0x14 */ f32 mScale; // width
+            /* 0x18 */ f32 mVertex;
        };

        struct TPercData {
@@ -36,7 +36,7 @@ namespace JASBNKParser {
        };

        struct TChunk {
-            /* 0x0 */ u32 mID;
+            /* 0x0 */ u32 mID; // Magic
            /* 0x4 */ u32 mSize;
        };

@@ -113,7 +113,7 @@ namespace JASBNKParser {
        };

        struct TOffsetData {
-            /* 0x000 */ u8 field_0x20[4];
+            /* 0x000 */ u32 mMagic; // 'BANK'
            /* 0x004 */ TOffset<TInst> mInstOffset[0x80];
            /* 0x204 */ u8 field_0x204[0x190];
            /* 0x394 */ TOffset<TPerc> mPercOffset[12];
@@ -1,6 +1,7 @@
 #ifndef JASCHANNEL_H
 #define JASCHANNEL_H

+#include "JSystem/JAudio2/JASDspInterface.h"
 #include "JSystem/JAudio2/JASHeapCtrl.h"
 #include "JSystem/JAudio2/JASLfo.h"
 #include "JSystem/JAudio2/JASOscillator.h"
@@ -45,6 +46,9 @@ public:
    /* 0x14 */ f32 mDolby;
 };

+#define CHANNEL_WAVE       0
+#define CHANNEL_OSCILLATOR 2
+
 /**
 * @ingroup jsystem-jaudio
 * 
@@ -52,7 +56,7 @@ public:
 class JASChannel : public JASPoolAllocObject_MultiThreaded<JASChannel> {
 public:
    typedef void (*Callback)(u32, JASChannel*, JASDsp::TChannel*, void*);
-    static const int BUSOUT_CPUCH = 6;
+    static const int BUSOUT_CPUCH = DSP_OUTPUT_CHANNELS;
    static const int OSC_NUM = 2;

    enum CallbackType {
@@ -153,10 +157,14 @@ public:
    /* 0xD4 */ u32 mKeySweepCount;
    /* 0xD8 */ u32 mSkipSamples;
    struct {
-        u32 field_0x0;
-        JASWaveInfo field_0x4;
+        u32 mChannelType; // CHANNEL_WAVE or CHANNEL_OSCILLATOR
+        JASWaveInfo mWaveInfo;
    } field_0xdc;
-    int field_0x104;
+    union {
+        u32 mWaveAramAddress;
+        u32 mOscillatorSomething;
+        u32 field_0x104;
+    };

    static OSMessageQueue sBankDisposeMsgQ;
    static OSMessage sBankDisposeMsg[16];
@@ -5,9 +5,14 @@

 /**
 * @ingroup jsystem-jaudio
- * 
+ * Responsible for allocating and prioritizing the available hardware DSP channels.
 */
 struct JASDSPChannel {
+    /**
+     * Callback used to update DSP channel information on a regular basis.
+     * Parameters are a CallbackType, hardware channel, and specified user data.
+     * Return -1 to immediately abort playback.
+     */
    typedef s32 (*Callback)(u32, JASDsp::TChannel*, void*);

    enum Status {
@@ -17,9 +22,24 @@ struct JASDSPChannel {
    };

    enum CallbackType {
+        /**
+         * Fired on a regular basis during play to update parameters.
+         */
        /* 0 */ CB_PLAY,
+
+        /**
+         * Fired once, when the channel starts playing.
+         */
        /* 1 */ CB_START,
+
+        /**
+         * Fired once, when the channel naturally finishes playing.
+         */
        /* 2 */ CB_STOP,
+
+        /**
+         * Fired once, if the channel is abruptly stopped due to an error or prioritization.
+         */
        /* 3 */ CB_DROP,
    };

@@ -46,9 +66,13 @@ struct JASDSPChannel {
    static JASDSPChannel* sDspChannels;

    /* 0x00 */ s32 mStatus;
+
+    /**
+     * Priority of this DSP channel. Used to
+     */
    /* 0x04 */ s16 mPriority;
    /* 0x08 */ u32 mFlags;
-    /* 0x0C */ u32 field_0xc;
+    /* 0x0C */ u32 mUpdateCounter;
    /* 0x10 */ Callback mCallback;
    /* 0x14 */ void* mCallbackData;
    /* 0x18 */ JASDsp::TChannel* mChannel;
@@ -4,6 +4,16 @@
 #include <cstdint>
 #include <types.h>

+/**
+ * Amount of separate audio channels (i.e. individual playbacks, voices) the DSP can mix at once.
+ */
+#define DSP_CHANNELS        64
+
+/**
+ * Amount of audio channels the DSP can calculate outputs for.
+ */
+#define DSP_OUTPUT_CHANNELS 6 // Presumed 5.1 surround
+
 struct JASWaveInfo;

 namespace JASDsp {
@@ -30,6 +40,24 @@ namespace JASDsp {
        u16 field_0x10[8];
    } FxBuf;

+    struct OutputChannelConfig {
+        u16 mBusConnect;
+        u16 mTargetVolume;
+        u16 mCurrentVolume;
+
+        /**
+         * Gets upper 8 bits cleared when audio volume is changed mid-playback.
+         * Presumed to be some kind of progress used by the DSP to calculate position between
+         * mTargetVolume and mCurrentVolume.
+         */
+        u16 mVolumeProgress;
+    };
+
+    /**
+     * DSP memory for each playback channel ("voice").
+     * The DSP can read and write this memory. It is used as configuration, feedback,
+     * and working memory.
+     */
    struct TChannel {
        void init();
        void playStart();
@@ -37,67 +65,83 @@ namespace JASDsp {
        void replyFinishRequest();
        void forceStop();
        bool isActive() const;
+
+        /**
+         * Check whether the DSP has finished playing this channel.
+         */
        bool isFinish() const;
        void setWaveInfo(JASWaveInfo const&, u32, u32);
        void setOscInfo(u32);
        void initAutoMixer();
        void setAutoMixer(u16, u8, u8, u8, u8);
        void setPitch(u16);
-        void setMixerInitVolume(u8, s16);
-        void setMixerVolume(u8, s16);
+        void setMixerInitVolume(u8 outputChannel, s16 volume);
+        void setMixerVolume(u8 outputChannel, s16 volume);
        void setPauseFlag(u8);
+
+        /**
+         * Flushes backing memory of channel out of the data cache.
+         */
        void flush();
        void initFilter();
        void setFilterMode(u16);
        void setIIRFilterParam(s16*);
        void setFIR8FilterParam(s16*);
        void setDistFilter(s16);
-        void setBusConnect(u8, u8);
+        void setBusConnect(u8 outputChannel, u8 param_1);

        /* 0x000 */ u16 mIsActive;
        /* 0x002 */ u16 mIsFinished;
        /* 0x004 */ u16 mPitch;
-        /* 0x006 */ short field_0x006;
+        /* 0x006 */ short _unused1;
        /* 0x008 */ u16 field_0x008;
-        /* 0x00A */ u8 field_0x00A[0x00C - 0x00A];
+        /* 0x00A */ u8 _unused2[0x00C - 0x00A];
        /* 0x00C */ s16 mPauseFlag;
-        /* 0x00E */ short field_0x00E;
-        /* 0x010 */ u16 field_0x010[1][4]; // array size unknown
-        /* 0x018 */ u8 field_0x018[0x050 - 0x018];
-        /* 0x050 */ u16 field_0x050;
-        /* 0x052 */ u16 field_0x052;
-        /* 0x054 */ u16 field_0x054;
-        /* 0x056 */ u16 field_0x056;
-        /* 0x058 */ u16 field_0x058;
-        /* 0x05A */ u8 field_0x05A[0x060 - 0x05A];
-        /* 0x060 */ short field_0x060;
-        /* 0x062 */ u8 field_0x062[0x064 - 0x062];
-        /* 0x064 */ u16 field_0x064;
-        /* 0x066 */ short field_0x066;
-        /* 0x068 */ int field_0x068;
-        /* 0x06C */ u8 field_0x06C[0x070 - 0x06C];
-        /* 0x070 */ int field_0x070;
+        /* 0x00E */ short _unused3;
+        /* 0x010 */ OutputChannelConfig mOutputChannels[DSP_OUTPUT_CHANNELS];
+        /* 0x040 */ u8 _unused4[0x050 - 0x040];
+        /* 0x050 */ u16 mAutoMixerPanDolby; // pan is upper 8 bits, dolby lower 8.
+        /* 0x052 */ u16 mAutoMixerFxMix;
+        /* 0x054 */ u16 mAutoMixerInitVolume;
+        /* 0x056 */ u16 mAutoMixerVolume;
+        /* 0x058 */ u16 mAutoMixerBeenSet;
+        /* 0x05A */ u8 _unused5[0x060 - 0x05A];
+        /* 0x060 */ short field_0x060; // Only cleared to zero, presumed used by DSP.
+        /* 0x062 */ u8 _unused6[0x064 - 0x062];
+        /* 0x064 */ u16 mSamplesPerBlock;
+        /* 0x066 */ short field_0x066; // Only cleared to zero, presumed used by DSP.
+        /* 0x068 */ int mSamplePosition; // Only ever initialized by code, name is guess.
+        /* 0x06C */ u8 _unused7[0x070 - 0x06C];
+        /* 0x070 */ int mAramStreamPosition; // Seems written by DSP, used for audio streaming.
        /* 0x074 */ int field_0x074;
-        /* 0x078 */ short field_0x078[4];
-        /* 0x080 */ short field_0x080[20];
-        /* 0x0A8 */ short field_0x0a8[4];
-        /* 0x0B0 */ u16 field_0x0b0[16];
-        /* 0x0D0 */ u8 field_0x0D0[0x100 - 0x0D0];
-        /* 0x100 */ u16 field_0x100;
+        /* 0x078 */ short field_0x078[4];  // Only cleared to zero, presumed used by DSP.
+        /* 0x080 */ short field_0x080[20]; // Only cleared to zero, presumed used by DSP.
+        /* 0x0A8 */ short field_0x0a8[4];  // Only cleared to zero, presumed used by DSP.
+        /* 0x0B0 */ u16 field_0x0b0[16];   // Only cleared to zero, presumed used by DSP.
+        /* 0x0D0 */ u8 _unused8[0x100 - 0x0D0];
+        /* 0x100 */ u16 mBytesPerBlock;
        /* 0x102 */ u16 field_0x102;
-        /* 0x104 */ s16 field_0x104;
-        /* 0x106 */ s16 field_0x106;
+
+        /**
+         * Used for decoding ADPCM data around loop edges.
+         */
+        /* 0x104 */ s16 mpLast;
+
+        /**
+         * Used for decoding ADPCM data around loop edges.
+         */
+        /* 0x106 */ s16 mpPenult;
        /* 0x108 */ u16 mFilterMode;
        /* 0x10A */ u16 mForcedStop;
        /* 0x10C */ int field_0x10c;
-        /* 0x110 */ u32 field_0x110;
-        /* 0x114 */ u32 field_0x114;
-        /* 0x118 */ u32 field_0x118;
-        /* 0x11C */ int field_0x11c;
+        /* 0x110 */ u32 mLoopStartSample;
+        /* 0x114 */ u32 mEndSample;
+        /* 0x118 */ u32 mWaveAramAddress;
+        /* 0x11C */ int mSampleCount;
        /* 0x120 */ s16 fir_filter_params[8];
-        /* 0x130 */ u8 field_0x130[0x148 - 0x130];
+        /* 0x130 */ u8 _unused9[0x148 - 0x130];
        /* 0x148 */ s16 iir_filter_params[8];
-        /* 0x158 */ u8 field_0x158[0x180 - 0x158];
+        /* 0x158 */ u8 _unused10[0x180 - 0x158];
    };

    void boot(void (*)(void*));
@@ -3,6 +3,10 @@

 #include "JSystem/JAudio2/JASCallback.h"

+#define JAS_OUTPUT_MONO     OS_SOUND_MODE_MONO
+#define JAS_OUTPUT_STEREO   OS_SOUND_MODE_STEREO
+#define JAS_OUTPUT_SURROUND 2
+
 typedef s32 (*DriverCallback)(void*);

 namespace JASDriver {
@@ -8,10 +8,21 @@
 * 
 */
 struct JASOscillator {
+    enum EnvelopeMode {
+        /* 0x0 */ ENVELOPE_LINEAR,
+        /* 0x1 */ ENVELOPE_SQUARE,
+        /* 0x2 */ ENVELOPE_SQUARE_ROOT,
+        /* 0x3 */ ENVELOPE_SAMPLE_CELL,
+
+        ENVELOPE_LOOP = 0xD,
+        ENVELOPE_HOLD = 0xE,
+        ENVELOPE_STOP = 0xF,
+    };
+
 	struct Point {
-		/* 0x0 */ s16 _0;
-		/* 0x2 */ s16 _2;
-		/* 0x4 */ s16 _4;
+		/* 0x0 */ s16 mEnvelopeMode; // EnvelopeMode
+		/* 0x2 */ s16 mTime;
+		/* 0x4 */ s16 mValue;
 	};

    struct EffectParams {
@@ -36,11 +47,11 @@ struct JASOscillator {

 	struct Data {
 		/* 0x00 */ u32 mTarget;
-		/* 0x04 */ f32 _04;
+		/* 0x04 */ f32 mRate;
 		/* 0x08 */ const Point* mTable;
 		/* 0x0C */ const Point* rel_table;
-		/* 0x10 */ f32 mScale;
-		/* 0x14 */ f32 _14;
+		/* 0x10 */ f32 mScale; // aka width
+		/* 0x14 */ f32 mVertex;
 	};

 	enum Target {
@@ -74,9 +85,9 @@ struct JASOscillator {
 	/* 0x08 */ f32 _08;
 	/* 0x0C */ f32 _0C;
 	/* 0x10 */ f32 _10;
-	/* 0x14 */ u16 _14;
+	/* 0x14 */ u16 mCurPoint;
 	/* 0x16 */ u16 mDirectRelease;
-	/* 0x18 */ u8 _18;
+	/* 0x18 */ u8 mEnvelopeMode; // EnvelopeMode
 	/* 0x1A */ u16 _1A;
 	/* 0x1C */ int _1C;

@@ -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() {}
@@ -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 (*(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 *(u16*)(mBase + param_0); }
+    u32 get32(u32 param_0) const { return *(u32*)(mBase + param_0); }
+    u8* getCur() { return mCurPos; }
+    u32 readByte() { return *mCurPos++; }
    u32 read16() {
 #ifdef __MWERKS__
-        return *((u16*)field_0x04)++;
+        return *((u16*)mCurPos)++;
 #else
-        u16* value = (u16*)field_0x04;
-        field_0x04 += 2;
+        u16* value = (u16*)mCurPos;
+        mCurPos += 2;
        return *value;
 #endif
    }
    u32 read24() {
-        field_0x04--;
+        mCurPos--;
 #ifdef __MWERKS__
-        return (*((u32*)field_0x04)++) & 0x00ffffff;
+        return (*((u32*)mCurPos)++) & 0x00ffffff;
 #else
-        u32* value = (u32*)field_0x04;
-        field_0x04 += 4;
+        u32* value = (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 */
@@ -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 */
@@ -31,26 +31,28 @@ public:

    struct TWave {
        /* 0x00 */ u8 _00;
-        /* 0x01 */ u8 _01;
-        /* 0x02 */ u8 _02;
-        /* 0x04 */ f32 _04;
-        /* 0x08 */ u32 mOffset;
-        /* 0x0C */ u32 _0C;
-        /* 0x10 */ u32 _10;
-        /* 0x14 */ u32 _14;
-        /* 0x18 */ u32 _18;
-        /* 0x1C */ u32 _1C;
-        /* 0x20 */ s16 _20;
-        /* 0x22 */ s16 _22;
+        /* 0x01 */ u8 mWaveFormat;
+        /* 0x02 */ u8 mBaseKey;
+        /* 0x04 */ f32 mSampleRate;
+        /* 0x08 */ u32 mAWOffsetStart;
+        /* 0x0C */ u32 mAWOffsetEnd;
+        /* 0x10 */ u32 mLoopFlags;
+        /* 0x14 */ u32 mLoopStartSample;
+        /* 0x18 */ u32 mLoopEndSample;
+        /* 0x1C */ u32 mSampleCount;
+        /* 0x20 */ s16 mpLast;
+        /* 0x22 */ s16 mpPenult;
    };

    struct TWaveArchive {
-        /* 0x00 */ char mFileName[0x74];  // unknown length
+        /* 0x00 */ char mFileName[0x70];
+        /* 0x70 */ u32 mWaveCount;
        /* 0x74 */ TOffset<TWave> mWaveOffsets[0];
    };

    struct TWaveArchiveBank {
-        /* 0x0 */ u8 _00[8];
+        /* 0x0 */ u32 mMagic; // 'WINF'
+        /* 0x0 */ u32 mArchiveCounts;
        /* 0x8 */ TOffset<TWaveArchive> mArchiveOffsets[0];
    };

@@ -66,14 +68,17 @@ public:
    };

    struct TCtrlGroup {
-        /* 0x0 */ u8 _00[8];
+        /* 0x0 */ u32 mMagic; // 'WBCT'
+        /* 0x4 */ u32 mUnknown;
        /* 0x8 */ u32 mGroupCount;
        /* 0xC */ TOffset<TCtrlScene> mCtrlSceneOffsets[0];
    };

    /** @fabricated */
    struct THeader {
-        /* 0x00 */ u8 _00[0xC];
+        /* 0x00 */ u32 mMagic; // 'WSYS'
+        /* 0x04 */ u32 mSize;
+        /* 0x08 */ u32 mId;
        /* 0x0C */ u32 mWaveTableSize;
        /* 0x10 */ TOffset<TWaveArchiveBank> mArchiveBankOffset;
        /* 0x14 */ TOffset<TCtrlGroup> mCtrlGroupOffset;
@@ -3,7 +3,12 @@

 #include <types.h>

-class JASWaveArc;
+struct JASWaveArc;
+
+#define WAVE_FORMAT_ADPCM4 0
+#define WAVE_FORMAT_ADPCM2 1
+#define WAVE_FORMAT_PCM8   2
+#define WAVE_FORMAT_PCM16  3

 /**
 * @ingroup jsystem-jaudio
@@ -11,21 +16,21 @@ class JASWaveArc;
 */
 struct JASWaveInfo {
    JASWaveInfo() {
-        field_0x01 = 0x3c;
+        mBaseKey = 0x3c;
        field_0x20 = &one;
    }

-    /* 0x00 */ u8 field_0x00;
-    /* 0x01 */ u8 field_0x01;
-    /* 0x02 */ u8 field_0x02;
-    /* 0x04 */ f32 field_0x04;
-    /* 0x08 */ int field_0x08;
-    /* 0x0C */ int field_0x0c;
-    /* 0x10 */ u32 field_0x10;
-    /* 0x14 */ int field_0x14;
-    /* 0x18 */ int field_0x18;
-    /* 0x1C */ s16 field_0x1c;
-    /* 0x1E */ s16 field_0x1e;
+    /* 0x00 */ u8 mWaveFormat;
+    /* 0x01 */ u8 mBaseKey;
+    /* 0x02 */ u8 mLoopFlag;
+    /* 0x04 */ f32 mSampleRate;
+    /* 0x08 */ int mOffsetStart;
+    /* 0x0C */ int mOffsetLength;
+    /* 0x10 */ u32 mLoopStartSample;
+    /* 0x14 */ int mLoopEndSample;
+    /* 0x18 */ int mSampleCount;
+    /* 0x1C */ s16 mpLast;
+    /* 0x1E */ s16 mpPenult;
    /* 0x20 */ const u32* field_0x20;

    static u32 one;
@@ -21,7 +21,7 @@ public:
    /* 0x10 */ int audioThreadPriority_;
    /* 0x14 */ int dvdThreadId_;
    /* 0x18 */ int audioThreadId_;
-    /* 0x1C */ int field_0x1c;
+    /* 0x1C */ int mJasTrackPoolSize;
    /* 0x20 */ int field_0x20;
    /* 0x24 */ int aramBlockSize_;
    /* 0x28 */ int aramChannelNum_;
@@ -38,10 +38,10 @@ public:
    JAU_JAIInitializer();
    void initJAInterface();

-    int field_0x0;
-    int field_0x4;
-    int field_0x8;
-    int field_0xc;
+    int mJaiSePoolSize;
+    int mJaiSeqPoolSize;
+    int mJaiStreamPoolSize;
+    int mJaiSoundChildPoolSize;
 };

 #endif /* JAUINITIALIZER_H */
@@ -11,11 +11,11 @@ struct JAISeqDataRegion;
 * 
 */
 struct JAUSeqCollectionData {
-    s8 field_0x0;
-    s8 field_0x1;
-    u16 field_0x2;
-    u32 field_0x4;
-    u32 field_0x8;
+    s8 mMagic1; // 'S'
+    s8 mMagic2; // 'C'
+    u16 mNumSoundCategories;
+    u32 mSectionSize;
+    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 u32* field_0x4;
-    /* 0x08 */ const JAUSeqCollectionData* field_0x8;
-    /* 0x0C */ int field_0xc;
+    /* 0x00 */ u16 mNumSoundCategories;
+    /* 0x04 */ const 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_;
@@ -48,13 +48,13 @@ template <size_t MAX_CHUNKS_>
 class JAUStreamStaticAramMgr_ : public JAUStreamAramMgrBase_<MAX_CHUNKS_> {
 public:
    JAUStreamStaticAramMgr_() { field_0x4c = 0; }
-    virtual void* newStreamAram(u32* param_0) {
+    virtual void* newStreamAram(u32* size) {
        for (u32 i = 0; i < field_0x4c; i++) {
            if (this->field_0x4.test(i)) {
                continue;
            }
            this->field_0x4.set(i, true);
-            *param_0 = this->mHeaps[i].getSize();
+            *size = this->mHeaps[i].getSize();
            return this->mHeaps[i].getBase();
        }
        return NULL;
@@ -4,7 +4,7 @@
 #include <types.h>

 void DSPReleaseHalt2(u32 msg);
-void DsetupTable(u32 param_0, u32 param_1, u32 param_2, u32 param_3, u32 param_4);
+void DsetupTable(u32 channelCount, u32 channelBufferAddress, u32 param_2, u32 param_3, u32 param_4);
 void DsetMixerLevel(f32 level);
 void DsyncFrame2ch(u32 param_0, u32 param_1, u32 param_2);
 void DsyncFrame4ch(u32 param_0, u32 param_1, u32 param_2, u32 param_3, u32 param_4);
@@ -3,7 +3,7 @@

 #include <types.h>

-void DspBoot(void (*)(void*));
+void DspBoot(void (*requestCallback)(void*));
 void DspFinishWork(u16 param_0);
 int DSPSendCommands2(u32* msgs, u32 param_1, void (*param_2)(u16));

@@ -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();
 }

@@ -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 {
@@ -48,7 +48,7 @@ void JAIStream::JAIStreamMgr_startID_(JAISoundID id, s32 streamFileEntry,
 }

 bool JAIStream::prepare_prepareStream_() {
-    u32 local_28;
+    u32 size;
    JAIStreamAramMgr* streamAramMgr;

    switch (field_0x290) {
@@ -56,9 +56,9 @@ bool JAIStream::prepare_prepareStream_() {
        streamAramMgr = streamMgr_->getStreamAramMgr();
        JUT_ASSERT(100, streamAramMgr);

-        streamAramAddr_ = streamAramMgr->newStreamAram(&local_28);
+        streamAramAddr_ = streamAramMgr->newStreamAram(&size);
        if (streamAramAddr_ != NULL) {
-            inner_.aramStream_.init((u32)streamAramAddr_, local_28, &JAIStream_JASAramStreamCallback_, this);
+            inner_.aramStream_.init((u32)streamAramAddr_, size, &JAIStream_JASAramStreamCallback_, this);
            field_0x290 = 1;
            prepareCount_ = 0;
        } else {
@@ -19,8 +19,8 @@ u32 JASAramStream::sBlockSize;

 u32 JASAramStream::sChannelMax;

-bool struct_80451260;
-bool struct_80451261;
+bool dvdHasErrored;
+bool hasErrored;

 void JASAramStream::initSystem(u32 block_size, u32 channel_max) {
    JUT_ASSERT(66, block_size % 32 == 0);
@@ -37,13 +37,13 @@ void JASAramStream::initSystem(u32 block_size, u32 channel_max) {
        JUT_ASSERT(79, sReadBuffer);
        sBlockSize = block_size;
        sChannelMax = channel_max;
-        struct_80451260 = false;
-        struct_80451261 = false;
+        dvdHasErrored = false;
+        hasErrored = false;
    }
 }

 JASAramStream::JASAramStream() {
-    field_0x0a8 = NULL;
+    mInitialChannel = NULL;
    field_0x0ac = false;
    field_0x0ad = false;
    field_0x0ae = 0;
@@ -60,15 +60,15 @@ JASAramStream::JASAramStream() {
    field_0x114 = 0;
    field_0x118 = 0;
    field_0x12c = 0;
-    field_0x148 = 0;
-    field_0x14c = 0;
+    mAramAddress = 0;
+    mAramSize = 0;
    mCallback = NULL;
    mCallbackData = NULL;
-    field_0x158 = 0;
+    mFormat = 0;
    mChannelNum = 0;
    mBufCount = 0;
-    field_0x160 = 0;
-    field_0x164 = 0;
+    mAramBlocksPerChannel = 0;
+    mSampleRate = 0;
    mLoop = false;
    mLoopStart = 0;
    mLoopEnd = 0;
@@ -76,22 +76,22 @@ JASAramStream::JASAramStream() {
    mPitch = 1.0f;
    for (int i = 0; i < 6; i++) {
        mChannels[i] = NULL;
-        field_0x130[i] = 0;
-        field_0x13c[i] = 0;
+        mpLasts[i] = 0;
+        mpPenults[i] = 0;
        mChannelVolume[i] = 1.0f;
        mChannelPan[i] = 0.5f;
        mChannelFxMix[i] = 0.0f;
        mChannelDolby[i] = 0.0f;
    }
    for (int i = 0; i < 6; i++) {
-        field_0x1dc[i] = 0;
+        mMixConfig[i] = 0;
    }
 }

-void JASAramStream::init(u32 param_0, u32 param_1, StreamCallback i_callback, void* i_callbackData) {
+void JASAramStream::init(u32 aramAddress, u32 aramSize, StreamCallback i_callback, void* i_callbackData) {
    JUT_ASSERT(153, sReadBuffer != NULL);
-    field_0x148 = param_0;
-    field_0x14c = param_1;
+    mAramAddress = aramAddress;
+    mAramSize = aramSize;
    field_0x0c8 = 0.0f;
    field_0x0ae = 0;
    field_0x0ac = false;
@@ -106,7 +106,7 @@ void JASAramStream::init(u32 param_0, u32 param_1, StreamCallback i_callback, vo
    }
    mVolume = 1.0f;
    mPitch = 1.0f;
-    field_0x1dc[0] = 0xffff;
+    mMixConfig[0] = 0xffff;
    mCallback = i_callback;
    mCallbackData = i_callbackData;
    OSInitMessageQueue(&field_0x000, field_0x040, 0x10);
@@ -124,9 +124,9 @@ bool JASAramStream::prepare(s32 param_0, int param_1) {
    }
    TaskData data;
    data.stream = this;
-    data.field_0x4 = field_0x14c;
+    data.field_0x4 = mAramSize;
    data.field_0x8 = param_1;
-    if (!sLoadThread->sendCmdMsg(headerLoadTask, &data, 0xc)) {
+    if (!sLoadThread->sendCmdMsg(headerLoadTask, &data, sizeof(data))) {
        JUT_WARN(254, "%s", "sendCmdMsg headerLoadTask Failed");
        JASDriver::rejectCallback(channelProcCallback, this);
        return false;
@@ -169,7 +169,7 @@ bool JASAramStream::cancel() {
 }

 u32 JASAramStream::getBlockSamples() const {
-    return field_0x158 == 0 ? (sBlockSize << 4) / 9 : sBlockSize >> 1;
+    return mFormat == 0 ? (sBlockSize << 4) / 9 : sBlockSize >> 1;
 }

 void JASAramStream::headerLoadTask(void* i_data) {
@@ -188,15 +188,15 @@ void JASAramStream::firstLoadTask(void* i_data) {
        if (data->field_0x8 == 0) {
            if (!sLoadThread->sendCmdMsg(prepareFinishTask, _this)) {
                JUT_WARN(364, "%s", "sendCmdMsg prepareFinishTask Failed");
-                struct_80451261 = true;
+                hasErrored = true;
            }
        }
    }
    if (data->field_0x4 != 0) {
        data->field_0x4--;
-        if (!sLoadThread->sendCmdMsg(firstLoadTask, data, 0xc)) {
+        if (!sLoadThread->sendCmdMsg(firstLoadTask, data, sizeof(*data))) {
            JUT_WARN(372, "%s", "sendCmdMsg firstLoadTask Failed");
-            struct_80451261 = true;
+            hasErrored = true;
        }
        JASCriticalSection cs;
        _this->field_0x118++;
@@ -227,8 +227,8 @@ void JASAramStream::prepareFinishTask(void* i_this) {
    }
 }

-bool JASAramStream::headerLoad(u32 param_0, int param_1) {
-    if (struct_80451261) {
+bool JASAramStream::headerLoad(u32 aramSize, int param_1) {
+    if (hasErrored) {
        return false;
    }
    if (field_0x114 != 0) {
@@ -236,7 +236,7 @@ bool JASAramStream::headerLoad(u32 param_0, int param_1) {
    }
    if (DVDReadPrio(&mDvdFileInfo, sReadBuffer, sizeof(Header), 0, 1) < 0) {
        JUT_WARN(420, "%s", "DVDReadPrio Failed");
-        struct_80451261 = true;
+        hasErrored = true;
        return false;
    }
    Header* header = (Header*)sReadBuffer;
@@ -245,18 +245,18 @@ bool JASAramStream::headerLoad(u32 param_0, int param_1) {
    JUT_ASSERT(428, header->bits == 16);
    JUT_ASSERT(429, header->channels <= sChannelMax);
    JUT_ASSERT(430, header->block_size == sBlockSize);
-    field_0x158 = header->format;
+    mFormat = header->format;
    mChannelNum = header->channels;
-    field_0x164 = header->field_0x10;
+    mSampleRate = header->mSampleRate;
    mLoop = header->loop != 0;
    mLoopStart = header->loop_start;
    mLoopEnd = header->loop_end;
-    mVolume = header->field_0x28 / 127.0f;
+    mVolume = header->mVolume / 127.0f;
    field_0x118 = 0;
    mBlock = 0;
    field_0x10c = 0;
-    field_0x160 = (param_0 / sBlockSize) / header->channels;
-    mBufCount = field_0x160;
+    mAramBlocksPerChannel = (aramSize / sBlockSize) / header->channels;
+    mBufCount = mAramBlocksPerChannel;
    JUT_ASSERT(445, mBufCount > 0);
    mBufCount--;
    if (mBufCount < 3) {
@@ -277,9 +277,9 @@ bool JASAramStream::headerLoad(u32 param_0, int param_1) {
    data.stream = this;
    data.field_0x4 = field_0x108 - 1;
    data.field_0x8 = param_1;
-    if (!sLoadThread->sendCmdMsg(firstLoadTask, &data, 0xc)) {
+    if (!sLoadThread->sendCmdMsg(firstLoadTask, &data, sizeof(data))) {
        JUT_WARN(472, "%s", "sendCmdMsg firstLoadTask Failed");
-        struct_80451261 = true;
+        hasErrored = true;
        return false;
    }
    JASCriticalSection cs;
@@ -293,7 +293,7 @@ bool JASAramStream::load() {
        JASCriticalSection cs;
        field_0x118--;
    }
-    if (struct_80451261) {
+    if (hasErrored) {
        return false;
    }
    if (field_0x114 != 0) {
@@ -311,7 +311,7 @@ bool JASAramStream::load() {
    }
    if (DVDReadPrio(&mDvdFileInfo, sReadBuffer, size, offset, 1) < 0) {
        JUT_WARN(507, "%s", "DVDReadPrio Failed");
-        struct_80451261 = true;
+        hasErrored = true;
        return false;
    }
    BlockHeader* bhead = (BlockHeader*)sReadBuffer;
@@ -319,16 +319,16 @@ bool JASAramStream::load() {
    if (field_0x114 != 0) {
        return false;
    }
-    u32 sp08 = field_0x148 + field_0x10c * sBlockSize;
+    u32 sp08 = mAramAddress + field_0x10c * sBlockSize;
    for (int i = 0; i < mChannelNum; i++) {
        (void)i;
        // Fakematch? It seems the only way to get the bhead->field_0x4 load in the right order is
        // with a pointer cast on its address in one of the two places it is read, but not both.
-        if (!JKRMainRamToAram(sReadBuffer + *(u32*)&bhead->field_0x4 * i + sizeof(BlockHeader),
-                              sp08 + sBlockSize * field_0x160 * i,
-                              bhead->field_0x4, EXPAND_SWITCH_UNKNOWN0, 0, NULL, -1, NULL)) {
+        if (!JKRMainRamToAram(sReadBuffer + *(u32*)&bhead->mSize * i + sizeof(BlockHeader),
+                              sp08 + sBlockSize * mAramBlocksPerChannel * i,
+                              bhead->mSize, EXPAND_SWITCH_UNKNOWN0, 0, NULL, -1, NULL)) {
            JUT_WARN(522, "%s", "JKRMainRamToAram Failed");
-            struct_80451261 = 1;
+            hasErrored = 1;
            return false;
        }
    }
@@ -344,14 +344,14 @@ bool JASAramStream::load() {
            }
        }
        if (r28 == loop_end_block || r28 + 2 == loop_end_block) {
-            field_0x108 = field_0x160;
+            field_0x108 = mAramBlocksPerChannel;
            OSSendMessage(&field_0x020, (OSMessage)5, OS_MESSAGE_BLOCK);
        } else {
-            field_0x108 = field_0x160 - 1;
+            field_0x108 = mAramBlocksPerChannel - 1;
        }
        for (int i = 0; i < mChannelNum; i++) {
-            field_0x130[i] = (s16)bhead->field_0x8[i].field_0x0;
-            field_0x13c[i] = (s16)bhead->field_0x8[i].field_0x2;
+            mpLasts[i] = (s16)bhead->mAdpcmContinuationData[i].mpLast;
+            mpPenults[i] = (s16)bhead->mAdpcmContinuationData[i].mpPenult;
        }
        field_0x10c = 0;
    }
@@ -371,7 +371,7 @@ s32 JASAramStream::dvdErrorCheck(void* param_0) {
    s32 status = DVDGetDriveStatus();
    switch (status) {
    case DVD_STATE_END:
-        struct_80451260 = false;
+        dvdHasErrored = false;
        break;
    case DVD_STATE_BUSY:
        break;
@@ -385,7 +385,7 @@ s32 JASAramStream::dvdErrorCheck(void* param_0) {
    case DVD_STATE_RETRY:
    case DVD_STATE_FATAL_ERROR:
    default:
-        struct_80451260 = true;
+        dvdHasErrored = true;
        break;
    }
    return 0;
@@ -402,8 +402,8 @@ void JASAramStream::updateChannel(u32 i_callbackType, JASChannel* i_channel,
    u32 block_samples = getBlockSamples();
    switch (i_callbackType) {
    case JASChannel::CB_START:
-        if (field_0x0a8 == NULL) {
-            field_0x0a8 = i_channel;
+        if (mInitialChannel == NULL) {
+            mInitialChannel = i_channel;
            field_0x0b4 = block_samples * mBufCount;
            field_0x0b8 = 0;
            field_0x0b0 = 0;
@@ -415,9 +415,9 @@ void JASAramStream::updateChannel(u32 i_callbackType, JASChannel* i_channel,
        break;
    case JASChannel::CB_PLAY:
        if (i_dspChannel->field_0x008 == 0) {
-            if (i_channel == field_0x0a8) {
+            if (i_channel == mInitialChannel) {
                field_0x12c = 0;
-                u32 sp28 = i_dspChannel->field_0x074 + i_dspChannel->field_0x064;
+                u32 sp28 = i_dspChannel->field_0x074 + i_dspChannel->mSamplesPerBlock;
                if (sp28 <= field_0x0b4) {
                    field_0x0b8 += field_0x0b4 - sp28;
                } else {
@@ -427,10 +427,10 @@ void JASAramStream::updateChannel(u32 i_callbackType, JASChannel* i_channel,
                    } else {
                        field_0x0b8 += field_0x0b4;
                        field_0x0b8 += block_samples * mBufCount - sp28
-                                       - i_dspChannel->field_0x110;
+                                       - i_dspChannel->mLoopStartSample;
                        field_0x0b8 -= mLoopEnd;
                        field_0x0b8 += mLoopStart;
-                        i_dspChannel->field_0x110 = 0;
+                        i_dspChannel->mLoopStartSample = 0;
                        field_0x120 = 0;
                        field_0x12c |= 2;
                        if (field_0x0c4 < 0xffffffff) {
@@ -441,14 +441,14 @@ void JASAramStream::updateChannel(u32 i_callbackType, JASChannel* i_channel,
                }
                if (field_0x0b8 > mLoopEnd) {
                    JUT_WARN(686, "%s", "mReadSample > mLoopEnd");
-                    struct_80451261 = true;
+                    hasErrored = true;
                }
                f32 fvar1 = field_0x0c4;
                fvar1 *= mLoopEnd - mLoopStart;
                if (field_0x0c4 < 0xffffffff) {
                    fvar1 += field_0x0b8;
                }
-                fvar1 /= field_0x164;
+                fvar1 /= mSampleRate;
                field_0x0c8 = fvar1;
                if (field_0x0b8 + 400 >= mLoopEnd && !field_0x0c0) {
                    if (mLoop) {
@@ -456,9 +456,9 @@ void JASAramStream::updateChannel(u32 i_callbackType, JASChannel* i_channel,
                        if (uvar5 >= mBufCount) {
                            uvar5 = 0;
                        }
-                        i_dspChannel->field_0x110 = mLoopStart % block_samples
+                        i_dspChannel->mLoopStartSample = mLoopStart % block_samples
                                                    + uvar5 * block_samples;
-                        field_0x120 = i_dspChannel->field_0x110;
+                        field_0x120 = i_dspChannel->mLoopStartSample;
                        field_0x12c |= 2;
                    } else {
                        i_dspChannel->field_0x102 = 0;
@@ -472,18 +472,18 @@ void JASAramStream::updateChannel(u32 i_callbackType, JASChannel* i_channel,
                    field_0x0bc += (mLoopEnd - 1) / block_samples - mLoopStart / block_samples + 1;
                    field_0x0c0 = true;
                }
-                u32 uvar4 = i_dspChannel->field_0x070 - i_channel->field_0x104;
+                u32 uvar4 = i_dspChannel->mAramStreamPosition - i_channel->mWaveAramAddress;
                if (uvar4 != 0) {
                    uvar4--;
                }
-                u32 sp18 = uvar4 / sBlockSize;
+                u32 blockCount = uvar4 / sBlockSize;
                u32 sp14 = (mLoopEnd - 1) / getBlockSamples();
-                if (sp18 != field_0x0b0) {
-                    bool cmp = sp18 < field_0x0b0;
-                    while (sp18 != field_0x0b0) {
+                if (blockCount != field_0x0b0) {
+                    bool cmp = blockCount < field_0x0b0;
+                    while (blockCount != field_0x0b0) {
                        if (!sLoadThread->sendCmdMsg(loadToAramTask, this)) {
-                            JUT_WARN(741, "sendCmdMsg Failed %d %d (%d %d)", i_dspChannel->field_0x070, i_channel->field_0x104, sp18, field_0x0b0);
-                            struct_80451261 = true;
+                            JUT_WARN(741, "sendCmdMsg Failed %d %d (%d %d)", i_dspChannel->mAramStreamPosition, i_channel->mWaveAramAddress, blockCount, field_0x0b0);
+                            hasErrored = true;
                            break;
                        }
                        {
@@ -503,16 +503,16 @@ void JASAramStream::updateChannel(u32 i_callbackType, JASChannel* i_channel,
                                field_0x11c = i_dspChannel->field_0x074;
                                field_0x12c |= 1;
                            }
-                            i_dspChannel->field_0x114 += block_samples;
-                            field_0x124 = i_dspChannel->field_0x114;
+                            i_dspChannel->mEndSample += block_samples;
+                            field_0x124 = i_dspChannel->mEndSample;
                            field_0x12c |= 4;
-                            mBufCount = field_0x160;
+                            mBufCount = mAramBlocksPerChannel;
                            field_0x0ad = false;
                        } else {
-                            if (mBufCount != field_0x160 - 1) {
-                                mBufCount = field_0x160 - 1;
-                                i_dspChannel->field_0x114 -= block_samples;
-                                field_0x124 = i_dspChannel->field_0x114;
+                            if (mBufCount != mAramBlocksPerChannel - 1) {
+                                mBufCount = mAramBlocksPerChannel - 1;
+                                i_dspChannel->mEndSample -= block_samples;
+                                field_0x124 = i_dspChannel->mEndSample;
                                field_0x12c |= 4;
                                if (!field_0x0c0) {
                                    i_dspChannel->field_0x074 -= block_samples;
@@ -523,13 +523,13 @@ void JASAramStream::updateChannel(u32 i_callbackType, JASChannel* i_channel,
                        }
                    }
                } else {
-                    if (field_0x118 == 0 && !struct_80451260) {
+                    if (field_0x118 == 0 && !dvdHasErrored) {
                        field_0x0ae &= ~2;
                        field_0x0ae &= ~4;
                    }
                }
-                field_0x0b4 = i_dspChannel->field_0x074 + i_dspChannel->field_0x064;
-                if (field_0x118 >= field_0x160 - 2) {
+                field_0x0b4 = i_dspChannel->field_0x074 + i_dspChannel->mSamplesPerBlock;
+                if (field_0x118 >= mAramBlocksPerChannel - 2) {
                    JUT_WARN_DEVICE(810, 1, "%s", "buffer under error");
                    field_0x0ae |= (u8)4;
                }
@@ -538,10 +538,10 @@ void JASAramStream::updateChannel(u32 i_callbackType, JASChannel* i_channel,
                    i_dspChannel->field_0x074 = field_0x11c;
                }
                if (field_0x12c & 2) {
-                    i_dspChannel->field_0x110 = field_0x120;
+                    i_dspChannel->mLoopStartSample = field_0x120;
                }
                if (field_0x12c & 4) {
-                    i_dspChannel->field_0x114 = field_0x124;
+                    i_dspChannel->mEndSample = field_0x124;
                }
                if (field_0x12c & 8) {
                    i_dspChannel->field_0x102 = field_0x128;
@@ -554,8 +554,8 @@ void JASAramStream::updateChannel(u32 i_callbackType, JASChannel* i_channel,
                }
            }
            JUT_ASSERT(834, ch < CHANNEL_MAX);
-            i_dspChannel->field_0x104 = (s16)field_0x130[ch];
-            i_dspChannel->field_0x106 = (s16)field_0x13c[ch];
+            i_dspChannel->mpLast = (s16)mpLasts[ch];
+            i_dspChannel->mpPenult = (s16)mpPenults[ch];
        }
        break;
    case JASChannel::CB_STOP:
@@ -571,7 +571,7 @@ void JASAramStream::updateChannel(u32 i_callbackType, JASChannel* i_channel,
            field_0x114 = 1;
            if (!sLoadThread->sendCmdMsg(finishTask, this)) {
                JUT_WARN(854, "%s", "sendCmdMsg finishTask Failed");
-                struct_80451261 = true;
+                hasErrored = true;
                return;
            }
        }
@@ -614,10 +614,10 @@ s32 JASAramStream::channelProc() {
        }
    }

-    if (struct_80451261) {
+    if (hasErrored) {
        field_0x0ae |= 8;
    }
-    if (struct_80451260) {
+    if (dvdHasErrored) {
        field_0x0ae |= 2;
    }

@@ -646,44 +646,44 @@ static JASOscillator::Point const OSC_RELEASE_TABLE[2] = {
 static JASOscillator::Data const OSC_ENV = {0, 1.0f, NULL, OSC_RELEASE_TABLE, 1.0f, 0.0f};

 void JASAramStream::channelStart() {
-    u8 r31;
-    switch (field_0x158) {
+    u8 format;
+    switch (mFormat) {
    case 0:
-        r31 = 0;
+        format = WAVE_FORMAT_ADPCM4;
        break;
    case 1:
-        r31 = 3;
+        format = WAVE_FORMAT_PCM16;
        break;
    }
    for (int i = 0; i < mChannelNum; i++) {
        JASWaveInfo wave_info;
-        wave_info.field_0x00 = r31;
-        wave_info.field_0x02 = 0xff;
-        wave_info.field_0x10 = 0;
-        wave_info.field_0x14 = mBufCount * getBlockSamples();
-        wave_info.field_0x18 = wave_info.field_0x14;
-        wave_info.field_0x1c = 0;
-        wave_info.field_0x1e = 0;
+        wave_info.mWaveFormat = format;
+        wave_info.mLoopFlag = 0xff;
+        wave_info.mLoopStartSample = 0;
+        wave_info.mLoopEndSample = mBufCount * getBlockSamples();
+        wave_info.mSampleCount = wave_info.mLoopEndSample;
+        wave_info.mpLast = 0;
+        wave_info.mpPenult = 0;
        // probably a fake match, this should be set in the JASWaveInfo constructor
        static u32 const one = 1;
        wave_info.field_0x20 = &one;
        JASChannel* jc = new JASChannel(channelCallback, this);
        JUT_ASSERT(963, jc);
        jc->setPriority(0x7f7f);
-        for (u32 j = 0; j < 6; j++) {
-            jc->setMixConfig(j, field_0x1dc[j]);
+        for (u32 j = 0; j < DSP_OUTPUT_CHANNELS; j++) {
+            jc->setMixConfig(j, mMixConfig[j]);
        }
-        jc->setInitPitch(field_0x164 / JASDriver::getDacRate());
+        jc->setInitPitch(mSampleRate / JASDriver::getDacRate());
        jc->setOscInit(0, &OSC_ENV);
-        jc->field_0xdc.field_0x4 = wave_info;
-        jc->field_0x104 = field_0x148 + sBlockSize * field_0x160 * i;
-        jc->field_0xdc.field_0x0 = 0;
+        jc->field_0xdc.mWaveInfo = wave_info;
+        jc->mWaveAramAddress = mAramAddress + sBlockSize * mAramBlocksPerChannel * i;
+        jc->field_0xdc.mChannelType = 0;
        int ret = jc->playForce();
        JUT_ASSERT(977, ret);
        JUT_ASSERT_MSG(979, mChannels[i] == NULL, "channelStart for already playing channel");
        mChannels[i] = jc;
    }
-    field_0x0a8 = NULL;
+    mInitialChannel = NULL;
 }


@@ -47,7 +47,7 @@ s32 JASAudioReseter::checkDone() const {

 s32 JASAudioReseter::calc() {
    if (field_0x0==0) {
-        for (size_t i = 0; i<64; i++) {
+        for (size_t i = 0; i<DSP_CHANNELS; i++) {
            JASDSPChannel* handle = JASDSPChannel::getHandle(i);
            if (handle->getStatus() == 0) {
                handle->drop();
@@ -79,11 +79,11 @@ JASBasicBank* JASBNKParser::Ver1::createBasicBank(void const* stream, JKRHeap* h
        JUT_ASSERT(155, op->id == 'Osci');
        JASOscillator::Data* data = &osc_data[i];
        data->mTarget = op->mTarget;
-        data->_04 = op->_08;
+        data->mRate = op->mRate;
        data->mScale = op->mScale;
-        data->_14 = op->_18;
-        data->mTable = (JASOscillator::Point*)(envt + op->mTableOffset);
-        data->rel_table = (JASOscillator::Point*)(envt + op->_10);
+        data->mVertex = op->mVertex;
+        data->mTable = (JASOscillator::Point*)(envt + op->mAttackEnvelopeOffset);
+        data->rel_table = (JASOscillator::Point*)(envt + op->mReleaseEnvelopeOffset);
    }
    TListChunk* list = list_chunk;
    JUT_ASSERT(172, list->count <= JASBank::PRG_OSC);
@@ -203,7 +203,7 @@ JASBasicBank* JASBNKParser::Ver0::createBasicBank(void const* stream, JKRHeap* h
                        osc = new (heap, 0) JASOscillator::Data();
                        JUT_ASSERT(386, osc != NULL);
                        osc->mTarget = tosc->mTarget;
-                        osc->_04 = tosc->field_0x4;
+                        osc->mRate = tosc->field_0x4;

                        JASOscillator::Point* points = tosc->mPointOffset.ptr(header);
                        if (points != NULL) {
@@ -230,7 +230,7 @@ JASBasicBank* JASBNKParser::Ver0::createBasicBank(void const* stream, JKRHeap* h
                        }

                        osc->mScale = tosc->mScale;
-                        osc->_14 = tosc->field_0x14;
+                        osc->mVertex = tosc->field_0x14;
                        instp->setOsc(osc_idx, osc);
                    }

@@ -312,7 +312,7 @@ JASOscillator::Data* JASBNKParser::Ver0::findOscPtr(JASBasicBank* bank, THeader
 JASOscillator::Point const* JASBNKParser::Ver0::getOscTableEndPtr(JASOscillator::Point const* points) {
    const JASOscillator::Point* ptr = points;
    while(true) {
-        s16 tmp = ptr->_0;
+        s16 tmp = ptr->mEnvelopeMode;
        ptr++;
        if (tmp > 10) {
            break;
@@ -42,13 +42,13 @@ JASChannel* JASBank::noteOn(JASBank const* param_0, int param_1, u8 param_2, u8
        return NULL;
    }
    channel->setPriority(param_4);
-    channel->field_0xdc.field_0x4 = *waveInfo;
-    channel->field_0x104 = wavePtr;
-    channel->field_0xdc.field_0x0 = stack_60.field_0x1c;
+    channel->field_0xdc.mWaveInfo = *waveInfo;
+    channel->mWaveAramAddress = wavePtr;
+    channel->field_0xdc.mChannelType = stack_60.field_0x1c;
    channel->setBankDisposeID(param_0);
-    channel->setInitPitch(stack_60.mPitch * (waveInfo->field_0x04 / JASDriver::getDacRate()));
+    channel->setInitPitch(stack_60.mPitch * (waveInfo->mSampleRate / JASDriver::getDacRate()));
    if (stack_60.field_0x1e == 0) {
-        channel->setKey(param_2 - waveInfo->field_0x01);
+        channel->setKey(param_2 - waveInfo->mBaseKey);
    }
    channel->setInitVolume(stack_60.mVolume);
    channel->setVelocity(param_3);
@@ -79,10 +79,10 @@ JASChannel* JASBank::noteOnOsc(int param_0, u8 param_1, u8 param_2, u16 param_3,
        return NULL;
    }
    channel->setPriority(param_3);
-    channel->field_0x104 = param_0;
-    channel->field_0xdc.field_0x0 = 2;
+    channel->mOscillatorSomething = param_0;
+    channel->field_0xdc.mChannelType = 2;
    channel->setInitPitch(16736.016f / JASDriver::getDacRate());
-    channel->setKey(param_1 - channel->field_0xdc.field_0x4.field_0x01);
+    channel->setKey(param_1 - channel->field_0xdc.mWaveInfo.mBaseKey);
    channel->setVelocity(param_2);
    channel->setOscInit(0, &OSC_ENV);
    if (!channel->play()) {
@@ -50,7 +50,7 @@ void JASBasicWaveBank::incWaveTable(JASBasicWaveBank::TWaveGroup const* param_0)
        if (!handle->mHeap) {
            handle->mHeap = &param_0->mHeap;
            handle->field_0x4.field_0x20 = &param_0->_48;
-            handle->field_0x4.field_0x08 = param_0->mCtrlWaveArray[i].field_0x4;
+            handle->field_0x4.mOffsetStart = param_0->mCtrlWaveArray[i].field_0x4;
        }
    }
 }
@@ -64,7 +64,7 @@ void JASBasicWaveBank::decWaveTable(JASBasicWaveBank::TWaveGroup const* param_0)
        if (handle->mHeap == &param_0->mHeap) {
            handle->mHeap = NULL;
            handle->field_0x4.field_0x20 = &mNoLoad;
-            handle->field_0x4.field_0x08 = -1;
+            handle->field_0x4.mOffsetStart = -1;
        }
    }
 }
@@ -86,9 +86,9 @@ void JASBasicWaveBank::setWaveInfo(JASBasicWaveBank::TWaveGroup* wgrp, int index
    JUT_ASSERT(206, index >= 0);
    mWaveTable[param_2].field_0x4 = param_3;
    mWaveTable[param_2].field_0x4.field_0x20 = &mNoLoad;
-    mWaveTable[param_2].field_0x4.field_0x08 = -1;
+    mWaveTable[param_2].field_0x4.mOffsetStart = -1;
    wgrp->mCtrlWaveArray[index].field_0x0 = param_2;
-    wgrp->mCtrlWaveArray[index].field_0x4 = param_3.field_0x08;
+    wgrp->mCtrlWaveArray[index].field_0x4 = param_3.mOffsetStart;
 }

 JASBasicWaveBank::TWaveGroup::TWaveGroup() {
@@ -131,5 +131,5 @@ int JASBasicWaveBank::TWaveHandle::getWavePtr() const {
    if (base == 0) {
        return 0;
    }
-    return (intptr_t)base + field_0x4.field_0x08;
+    return (intptr_t)base + field_0x4.mOffsetStart;
 }
@@ -31,7 +31,7 @@ JASChannel::JASChannel(Callback i_callback, void* i_callbackData) :
    mKeySweepCount(0),
    mSkipSamples(0)
 {
-    field_0xdc.field_0x0 = 0;
+    field_0xdc.mChannelType = 0;
    field_0x104 = 0;
    mMixConfig[0].whole = 0x150;
    mMixConfig[1].whole = 0x210;
@@ -171,12 +171,12 @@ void JASChannel::updateEffectorParam(JASDsp::TChannel* i_channel, u16* i_mixerVo
    f32 pan = 0.5f;
    f32 dolby = 0.0f;
    switch (JASDriver::getOutputMode()) {
-    case 0:
+    case JAS_OUTPUT_MONO:
        break;
-    case 1:
+    case JAS_OUTPUT_STEREO:
        pan = calcPan(&pan_vector);
        break;
-    case 2:
+    case JAS_OUTPUT_SURROUND:
        pan = calcPan(&pan_vector);
        dolby = calcEffect(&dolby_vector);
        break;
@@ -229,7 +229,7 @@ s32 JASChannel::initialUpdateDSPChannel(JASDsp::TChannel* i_channel) {
        mCallback(CB_START, this, i_channel, mCallbackData);
    }

-    if (field_0xdc.field_0x4.field_0x20[0] == 0) {
+    if (field_0xdc.mWaveInfo.field_0x20[0] == 0) {
        JUT_WARN_DEVICE(346, 2, "%s", "Lost wave data while playing");
        mDspCh->free();
        mDspCh = NULL;
@@ -245,19 +245,19 @@ s32 JASChannel::initialUpdateDSPChannel(JASDsp::TChannel* i_channel) {
        return -1;
    }

-    switch (field_0xdc.field_0x0) {
+    switch (field_0xdc.mChannelType) {
    case 0:
-        i_channel->setWaveInfo(field_0xdc.field_0x4, field_0x104, mSkipSamples);
+        i_channel->setWaveInfo(field_0xdc.mWaveInfo, mWaveAramAddress, mSkipSamples);
        break;
    case 2:
-        i_channel->setOscInfo(field_0x104);
+        i_channel->setOscInfo(mOscillatorSomething);
        break;
    }

-    for (u8 i = 0; i < 6; i++) {
+    for (u8 i = 0; i < DSP_OUTPUT_CHANNELS; i++) {
        MixConfig mix_config = mMixConfig[i];
        u32 output_mode = JASDriver::getOutputMode();
-        if (output_mode == 0) {
+        if (output_mode == JAS_OUTPUT_MONO) {
            switch (mix_config.parts.upper) {
            case 8:
                mix_config.parts.upper = 11;
@@ -266,7 +266,7 @@ s32 JASChannel::initialUpdateDSPChannel(JASDsp::TChannel* i_channel) {
                mix_config.parts.upper = 2;
                break;
            }
-        } else if (output_mode == 1 && mix_config.parts.upper == 8) {
+        } else if (output_mode == JAS_OUTPUT_STEREO && mix_config.parts.upper == 8) {
            mix_config.parts.upper = 11;
        }
        i_channel->setBusConnect(i, mix_config.parts.upper);
@@ -281,9 +281,9 @@ s32 JASChannel::initialUpdateDSPChannel(JASDsp::TChannel* i_channel) {
    }
    mVibrate.resetCounter();
    mTremolo.resetCounter();
-    u16 mixer_volume[6];
+    u16 mixer_volume[DSP_OUTPUT_CHANNELS];
    updateEffectorParam(i_channel, mixer_volume, effect_params);
-    for (u8 i = 0; i < 6; i++) {
+    for (u8 i = 0; i < DSP_OUTPUT_CHANNELS; i++) {
        i_channel->setMixerInitVolume(i, mixer_volume[i]);
    }

@@ -307,7 +307,7 @@ s32 JASChannel::updateDSPChannel(JASDsp::TChannel* i_channel) {
        mCallback(CB_PLAY, this, i_channel, mCallbackData);
    }

-    if (field_0xdc.field_0x4.field_0x20[0] == 0) {
+    if (field_0xdc.mWaveInfo.field_0x20[0] == 0) {
        JUT_WARN_DEVICE(456, 2, "%s","Lost wave data while playing");
        mDspCh->free();
        mDspCh = NULL;
@@ -378,18 +378,18 @@ s32 JASChannel::updateDSPChannel(JASDsp::TChannel* i_channel) {
    return 0;
 }

-void JASChannel::updateAutoMixer(JASDsp::TChannel* i_channel, f32 param_1, f32 param_2,
-                                 f32 param_3, f32 param_4) {
-    if (JASDriver::getOutputMode() == 0) {
-        param_1 *= 0.707f;
+void JASChannel::updateAutoMixer(JASDsp::TChannel* i_channel, f32 volume, f32 pan,
+                                 f32 fxmix, f32 dolby) {
+    if (JASDriver::getOutputMode() == JAS_OUTPUT_MONO) {
+        volume *= 0.707f;
    }
-    param_1 = JASCalc::clamp01(param_1);
+    volume = JASCalc::clamp01(volume);

-    u16 r31 = param_1 * JASDriver::getChannelLevel_dsp();
-    u8 r30 = param_2 * 127.5f;
-    u8 r29 = param_4 * 127.5f;
-    u8 r28 = param_3 * 127.5f;
-    i_channel->setAutoMixer(r31, r30, r29, r28, 0);
+    u16 dspVolume = volume * JASDriver::getChannelLevel_dsp();
+    u8 dspPan = pan * 127.5f;
+    u8 dspDolby = dolby * 127.5f;
+    u8 dspFxMix = fxmix * 127.5f;
+    i_channel->setAutoMixer(dspVolume, dspPan, dspDolby, dspFxMix, 0);
 }

 void JASChannel::updateMixer(f32 i_volume, f32 i_pan, f32 i_fxmix, f32 i_dolby, u16* i_volumeOut) {
@@ -429,7 +429,7 @@ void JASChannel::updateMixer(f32 i_volume, f32 i_pan, f32 i_fxmix, f32 i_dolby,
                    volume *= scale;
                    break;
                default:
-                    if (JASDriver::getOutputMode() == 0) {
+                    if (JASDriver::getOutputMode() == JAS_OUTPUT_MONO) {
                        volume *= scale;
                    } else {
                        volume *= JMASinRadian(scale * JGeometry::TUtil<f32>::PI() * 0.5f);
@@ -471,7 +471,7 @@ void JASChannel::updateMixer(f32 i_volume, f32 i_pan, f32 i_fxmix, f32 i_dolby,
                    volume *= scale;
                    break;
                default:
-                    if (JASDriver::getOutputMode() == 0) {
+                    if (JASDriver::getOutputMode() == JAS_OUTPUT_MONO) {
                        volume *= scale;
                    } else {
                        volume *= JMASinRadian(scale * JGeometry::TUtil<f32>::PI() * 0.5f);
@@ -10,7 +10,7 @@ JASDSPChannel::JASDSPChannel() :
    mStatus(STATUS_INACTIVE),
    mPriority(-1),
    mFlags(0),
-    field_0xc(0),
+    mUpdateCounter(0),
    mCallback(NULL),
    mCallbackData(NULL),
    mChannel(NULL)
@@ -42,9 +42,9 @@ void JASDSPChannel::drop() {
 }

 void JASDSPChannel::initAll() {
-    sDspChannels = new (JASDram, 0x20) JASDSPChannel[0x40];
+    sDspChannels = new (JASDram, 0x20) JASDSPChannel[DSP_CHANNELS];
    JUT_ASSERT(102, sDspChannels);
-    for (int i = 0; i < 0x40; i++) {
+    for (int i = 0; i < DSP_CHANNELS; i++) {
        sDspChannels[i].mChannel = JASDsp::getDSPHandle(i);
    }
 }
@@ -56,7 +56,7 @@ JASDSPChannel* JASDSPChannel::alloc(u8 i_priority, Callback i_callback, void* i_
    }
    channel->drop();
    channel->mPriority = i_priority;
-    channel->field_0xc = 0;
+    channel->mUpdateCounter = 0;
    channel->mCallback = i_callback;
    channel->mCallbackData = i_callbackData;
    return channel;
@@ -70,7 +70,7 @@ JASDSPChannel* JASDSPChannel::allocForce(u8 i_priority, Callback i_callback, voi
    channel->mStatus = STATUS_INACTIVE;
    channel->drop();
    channel->mPriority = i_priority;
-    channel->field_0xc = 0;
+    channel->mUpdateCounter = 0;
    channel->mCallback = i_callback;
    channel->mCallbackData = i_callbackData;
    return channel;
@@ -83,16 +83,16 @@ void JASDSPChannel::setPriority(u8 i_priority) {
 JASDSPChannel* JASDSPChannel::getLowestChannel(int i_priority) {
    s16 best_priority = 0xff;
    int best_index = -1;
-    int best_unknown = 0;
-    for (int i = 0; i < 0x40; i++) {
+    int best_updateCounter = 0;
+    for (int i = 0; i < DSP_CHANNELS; i++) {
        JASDSPChannel* channel = &sDspChannels[i];
        s16 priority = channel->mPriority;
        if (priority < 0) {
            return &sDspChannels[i];
        }
        if (priority <= i_priority && priority <= best_priority) {
-            if (priority != best_priority || channel->field_0xc > best_unknown) {
-                best_unknown = channel->field_0xc;
+            if (priority != best_priority || channel->mUpdateCounter > best_updateCounter) {
+                best_updateCounter = channel->mUpdateCounter;
                best_index = i;
                best_priority = priority;
            }
@@ -107,14 +107,14 @@ JASDSPChannel* JASDSPChannel::getLowestChannel(int i_priority) {
 JASDSPChannel* JASDSPChannel::getLowestActiveChannel() {
    s16 best_priority = 0xff;
    int best_index = -1;
-    int best_unknown = 0;
-    for (int i = 0; i < 0x40; i++) {
+    int best_updateCounter = 0;
+    for (int i = 0; i < DSP_CHANNELS; i++) {
        JASDSPChannel* channel = &sDspChannels[i];
        if (channel->mStatus == STATUS_ACTIVE) {
            s16 priority = channel->mPriority;
            if (priority < 0x7f && priority <= best_priority) {
-                if (priority != best_priority || channel->field_0xc > best_unknown) {
-                    best_unknown = channel->field_0xc;
+                if (priority != best_priority || channel->mUpdateCounter > best_updateCounter) {
+                    best_updateCounter = channel->mUpdateCounter;
                    best_index = i;
                    best_priority = priority;
                }
@@ -195,7 +195,7 @@ void JASDSPChannel::updateProc() {
                mChannel->playStop();
                mChannel->flush();
            } else {
-                field_0xc++;
+                mUpdateCounter++;
                if (flush) {
                    mChannel->flush();
                }
@@ -205,7 +205,7 @@ void JASDSPChannel::updateProc() {
 }

 void JASDSPChannel::updateAll() {
-    for (u32 i = 0; i < 0x40; i++) {
+    for (u32 i = 0; i < DSP_CHANNELS; i++) {
        if ((i & 0xf) == 0 && i != 0) {
            JASDsp::releaseHalt((i - 1) >> 4);
        }
@@ -230,8 +230,8 @@ JASDSPChannel* JASDSPChannel::getHandle(u32 i_index) {

 u32 JASDSPChannel::getNumUse() {
    u32 count = 0;
-    for (int i = 0; i < 0x40; i++) {
-        if (sDspChannels[i].mStatus == 0) {
+    for (int i = 0; i < DSP_CHANNELS; i++) {
+        if (sDspChannels[i].mStatus == STATUS_ACTIVE) {
            count++;
        }
    }
@@ -240,8 +240,8 @@ u32 JASDSPChannel::getNumUse() {

 u32 JASDSPChannel::getNumFree() {
    u32 count = 0;
-    for (int i = 0; i < 0x40; i++) {
-        if (sDspChannels[i].mStatus == 1) {
+    for (int i = 0; i < DSP_CHANNELS; i++) {
+        if (sDspChannels[i].mStatus == STATUS_INACTIVE) {
            count++;
        }
    }
@@ -250,8 +250,8 @@ u32 JASDSPChannel::getNumFree() {

 u32 JASDSPChannel::getNumBreak() {
        u32 count = 0;
-    for (int i = 0; i < 0x40; i++) {
-        if (sDspChannels[i].mStatus == 2) {
+    for (int i = 0; i < DSP_CHANNELS; i++) {
+        if (sDspChannels[i].mStatus == STATUS_DROP) {
            count++;
        }
    }
@@ -72,8 +72,8 @@ f32 JASDsp::getDSPMixerLevel() {
    return sDSPVolume;
 }

-JASDsp::TChannel* JASDsp::getDSPHandle(int param_0) {
-    return CH_BUF + param_0;
+JASDsp::TChannel* JASDsp::getDSPHandle(int index) {
+    return CH_BUF + index;
 }

 JASDsp::TChannel* JASDsp::getDSPHandleNc(int param_0) {
@@ -87,12 +87,12 @@ void JASDsp::setFilterTable(s16* param_0, s16* param_1, u32 param_2) {
 }

 void JASDsp::flushBuffer() {
-    DCFlushRange(CH_BUF, sizeof(TChannel) * 64);
+    DCFlushRange(CH_BUF, sizeof(TChannel) * DSP_CHANNELS);
    DCFlushRange(FX_BUF, sizeof(FxBuf) * 4);
 }

 void JASDsp::invalChannelAll() {
-    DCInvalidateRange(CH_BUF, sizeof(TChannel) * 64);
+    DCInvalidateRange(CH_BUF, sizeof(TChannel) * DSP_CHANNELS);
 }

 u8 const ATTRIBUTE_ALIGN(32) JASDsp::DSPADPCM_FILTER[64] = {
@@ -426,16 +426,16 @@ u32 const ATTRIBUTE_ALIGN(32) JASDsp::DSPRES_FILTER[320] = {
 };

 void JASDsp::initBuffer() {
-    CH_BUF = new(JASDram, 0x20) TChannel[64];
+    CH_BUF = new(JASDram, 0x20) TChannel[DSP_CHANNELS];
    JUT_ASSERT(354, CH_BUF);
    FX_BUF = new(JASDram, 0x20) FxBuf[4];
    JUT_ASSERT(356, FX_BUF);
-    JASCalc::bzero(CH_BUF, 0x6000);
+    JASCalc::bzero(CH_BUF, sizeof(TChannel) * DSP_CHANNELS);
    JASCalc::bzero(FX_BUF, sizeof(FxBuf) * 4);
    for (u8 i = 0; i < 4; i++) {
        setFXLine(i, NULL, NULL);
    }
-    DsetupTable(0x40, u32(CH_BUF), u32(&DSPRES_FILTER), u32(&DSPADPCM_FILTER), u32(FX_BUF));
+    DsetupTable(DSP_CHANNELS, u32(CH_BUF), u32(&DSPRES_FILTER), u32(&DSPADPCM_FILTER), u32(FX_BUF));
    flushBuffer();
 }

@@ -500,8 +500,8 @@ void JASDsp::TChannel::init() {
    mIsFinished = 0;
    mForcedStop = 0;
    mIsActive = 0;
-    field_0x058 = 0;
-    field_0x068 = 0;
+    mAutoMixerBeenSet = 0;
+    mSamplePosition = 0;
    initFilter();
 }

@@ -548,41 +548,41 @@ bool JASDsp::TChannel::isFinish() const {
    return mIsFinished != 0;
 }

-void JASDsp::TChannel::setWaveInfo(JASWaveInfo const& param_0, u32 param_1, u32 param_2) {
+void JASDsp::TChannel::setWaveInfo(JASWaveInfo const& waveInfo, u32 aramAddress, u32 skipSamples) {
    int i;
    JUT_ASSERT(610, dspMutex);
-    field_0x118 = param_1;
+    mWaveAramAddress = aramAddress;
    static const u8 COMP_BLOCKSAMPLES[8] = {0x10, 0x10, 0x01, 0x01, 0x01, 0x10, 0x10, 0x01};
-    field_0x064 = COMP_BLOCKSAMPLES[param_0.field_0x00];
+    mSamplesPerBlock = COMP_BLOCKSAMPLES[waveInfo.mWaveFormat];
    static const u8 COMP_BLOCKBYTES[8] = {0x09, 0x05, 0x08, 0x10, 0x01, 0x01, 0x01, 0x01};
-    field_0x100 = COMP_BLOCKBYTES[param_0.field_0x00];
-    field_0x068 = 0;
-    if (field_0x100 >= 4) {
-        field_0x11c = param_0.field_0x18;
-        field_0x102 = param_0.field_0x02;
+    mBytesPerBlock = COMP_BLOCKBYTES[waveInfo.mWaveFormat];
+    mSamplePosition = 0;
+    if (mBytesPerBlock >= 4) {
+        mSampleCount = waveInfo.mSampleCount;
+        field_0x102 = waveInfo.mLoopFlag;
        if (field_0x102) {
-            if (param_2 == 1) {
-                param_2 = param_0.field_0x10;
+            if (skipSamples == 1) {
+                skipSamples = waveInfo.mLoopStartSample;
            }
-            field_0x110 = param_0.field_0x10;
-            field_0x114 = param_0.field_0x14;
-            field_0x104 = param_0.field_0x1c;
-            field_0x106 = param_0.field_0x1e;
+            mLoopStartSample = waveInfo.mLoopStartSample;
+            mEndSample = waveInfo.mLoopEndSample;
+            mpLast = waveInfo.mpLast;
+            mpPenult = waveInfo.mpPenult;
        } else {
-            field_0x114 = field_0x11c;
+            mEndSample = mSampleCount;
        }
-        if (param_2 && field_0x114 > param_2) {
-            switch (param_0.field_0x00) {
-            case 0:
-            case 1:
-                field_0x068 = param_2;
-                field_0x118 += param_2 * field_0x100 >> 4;
-                field_0x110 -= param_2;
-                field_0x114 -= param_2;
+        if (skipSamples && mEndSample > skipSamples) {
+            switch (waveInfo.mWaveFormat) {
+            case WAVE_FORMAT_ADPCM4:
+            case WAVE_FORMAT_ADPCM2:
+                mSamplePosition = skipSamples;
+                mWaveAramAddress += skipSamples * mBytesPerBlock >> 4;
+                mLoopStartSample -= skipSamples;
+                mEndSample -= skipSamples;
                break;
-            case 2:
-            case 3:
-                field_0x068 = param_2;
+            case WAVE_FORMAT_PCM8:
+            case WAVE_FORMAT_PCM16:
+                mSamplePosition = skipSamples;
                break;
            }
        }
@@ -594,28 +594,27 @@ void JASDsp::TChannel::setWaveInfo(JASWaveInfo const& param_0, u32 param_1, u32

 void JASDsp::TChannel::setOscInfo(u32 param_0) {
    JUT_ASSERT(671, dspMutex);
-    field_0x118 = 0;
-    field_0x064 = 16;
-    field_0x100 = param_0;
+    mWaveAramAddress = 0;
+    mSamplesPerBlock = 16;
+    mBytesPerBlock = param_0;
 }

 void JASDsp::TChannel::initAutoMixer() {
    JUT_ASSERT(688, dspMutex);
-    if (field_0x058) {
-        field_0x054 = field_0x056;
+    if (mAutoMixerBeenSet) {
+        mAutoMixerInitVolume = mAutoMixerVolume;
    } else {
-        field_0x054 = 0;
-        field_0x058 = 1;
+        mAutoMixerInitVolume = 0;
+        mAutoMixerBeenSet = 1;
    }
 }

-void JASDsp::TChannel::setAutoMixer(u16 param_0, u8 param_1, u8 param_2, u8 param_3,
-                                        u8 param_4) {
+void JASDsp::TChannel::setAutoMixer(u16 volume, u8 pan, u8 dolby, u8 fxMix, u8) {
    JUT_ASSERT(709, dspMutex);
-    field_0x050 = (param_1 << 8) | param_2;
-    field_0x052 = param_3 << 8 | param_3 << 1;
-    field_0x056 = param_0;
-    field_0x058 = 1;
+    mAutoMixerPanDolby = (pan << 8) | dolby;
+    mAutoMixerFxMix = fxMix << 8 | fxMix << 1;
+    mAutoMixerVolume = volume;
+    mAutoMixerBeenSet = 1;
 }

 void JASDsp::TChannel::setPitch(u16 param_0) {
@@ -626,21 +625,21 @@ void JASDsp::TChannel::setPitch(u16 param_0) {
    mPitch = param_0;
 }

-void JASDsp::TChannel::setMixerInitVolume(u8 param_0, s16 param_1) {
+void JASDsp::TChannel::setMixerInitVolume(u8 outputChannel, s16 volume) {
    JUT_ASSERT(798, dspMutex);
-    u16* tmp = field_0x010[param_0];
-    tmp[2] = param_1;
-    tmp[1] = param_1;
-    tmp[3] = 0;
+    OutputChannelConfig& cfg = mOutputChannels[outputChannel];
+    cfg.mCurrentVolume = volume;
+    cfg.mTargetVolume = volume;
+    cfg.mVolumeProgress = 0;
 }

-void JASDsp::TChannel::setMixerVolume(u8 param_0, s16 param_1) {
-    u16* tmp;
+void JASDsp::TChannel::setMixerVolume(u8 outputChannel, s16 volume) {
+    OutputChannelConfig* cfg;
    JUT_ASSERT(841, dspMutex);
    if (mForcedStop == 0) {
-        tmp = field_0x010[param_0];
-        tmp[1] = param_1;
-        tmp[3] &= 0xff;
+        cfg = &mOutputChannels[outputChannel];
+        cfg->mTargetVolume = volume;
+        cfg->mVolumeProgress &= 0xff;
    }
 }

@@ -698,16 +697,16 @@ void JASDsp::TChannel::setDistFilter(s16 param_0) {
    iir_filter_params[4] = param_0;
 }

-void JASDsp::TChannel::setBusConnect(u8 param_0, u8 param_1) {
+void JASDsp::TChannel::setBusConnect(u8 outputChannel, u8 param_1) {
    JUT_ASSERT(973, dspMutex);
-    u16* tmp = field_0x010[param_0];
+    OutputChannelConfig& tmp = mOutputChannels[outputChannel];
    static u16 const connect_table[12] = {
        0x0000, 0x0D00, 0x0D60, 0x0DC0, 0x0E20, 0x0E80,
        0x0EE0, 0x0CA0, 0x0F40, 0x0FA0, 0x0B00, 0x09A0,
    };
    u16 r30 = 0;
    r30 = connect_table[param_1];
-    tmp[0] = r30;
+    tmp.mBusConnect = r30;
 }

 u16 DSP_CreateMap2(u32 param_0) {
@@ -23,10 +23,10 @@ f32 JASDriver::getDSPLevel() {
    return JASDsp::getDSPMixerLevel();
 }

-u32 JASDriver::JAS_SYSTEM_OUTPUT_MODE = 0x00000001;
+u32 JASDriver::JAS_SYSTEM_OUTPUT_MODE = JAS_OUTPUT_STEREO;

-void JASDriver::setOutputMode(u32 param_0) {
-    JAS_SYSTEM_OUTPUT_MODE = param_0;
+void JASDriver::setOutputMode(u32 mode) {
+    JAS_SYSTEM_OUTPUT_MODE = mode;
 }

 u32 JASDriver::getOutputMode() {
@@ -49,11 +49,11 @@ bool JASDrumSet::getParam(int key, int param_1, JASInstParam* param_2) const {
    static JASOscillator::Data osc;

    osc.mTarget = 0;
-    osc._04 = 1.0f;
+    osc.mRate = 1.0f;
    osc.mTable = NULL;
    osc.rel_table = NULL;
    osc.mScale = 1.0f;
-    osc._14 = 0.0f;
+    osc.mVertex = 0.0f;

    static JASOscillator::Data* oscp = &osc;

@@ -4,9 +4,9 @@

 JASOscillator::JASOscillator() {
    mData = NULL;
-    _14 = 0;
+    mCurPoint = 0;
    mDirectRelease = 0;
-    _18 = 0;
+    mEnvelopeMode = 0;
    _1C = 0;
    _04 = _08 = _10 = _0C = 0.0f;
 }
@@ -17,7 +17,7 @@ void JASOscillator::initStart(JASOscillator::Data const* data) {
    _04 = 0.0f;
    _08 = 0.0f;
    _0C = 0.0f;
-    _14 = 0;
+    mCurPoint = 0;
    mDirectRelease = 0;
    if (!data) {
 		_1C = 0;
@@ -30,8 +30,8 @@ void JASOscillator::initStart(JASOscillator::Data const* data) {
        return;
    }

-    _10 = mData->mTable[0]._4 / 32768.0f;
-    _18 = mData->mTable[0]._0;
+    _10 = mData->mTable[0].mValue / 32768.0f;
+    mEnvelopeMode = mData->mTable[0].mEnvelopeMode;
    _1C = 1;
 }

@@ -44,13 +44,13 @@ void JASOscillator::incCounter(f32 param_0) {
 	case 1:
 		break;
 	}
-	_04 += param_0 * mData->_04;
+	_04 += param_0 * mData->mRate;
    update();
 }

 f32 JASOscillator::getValue() const {
    JUT_ASSERT(120, mData);
-	return _08 * mData->mScale + mData->_14;
+	return _08 * mData->mScale + mData->mVertex;
 }

 void JASOscillator::release() {
@@ -63,8 +63,8 @@ void JASOscillator::release() {
 		_04 = 0.0f;
        _0C = _08;
        _10 = 0.0f;
-        _14 = 0;
-        _18 = (mDirectRelease >> 14) & 3;
+        mCurPoint = 0;
+        mEnvelopeMode = (mDirectRelease >> 14) & 3;
        _1C = 4;
        update();
        return;
@@ -74,9 +74,9 @@ void JASOscillator::release() {
        JUT_ASSERT(157, mData->rel_table != NULL);
        _04 = 0.0f;
        _0C = _08;
-        _10 = mData->rel_table[0]._4 / 32768.0f;
-        _14 = 0;
-        _18 = mData->rel_table[0]._0;
+        _10 = mData->rel_table[0].mValue / 32768.0f;
+        mCurPoint = 0;
+        mEnvelopeMode = mData->rel_table[0].mEnvelopeMode;
    }

    _1C = 3;
@@ -104,31 +104,31 @@ void JASOscillator::update() {
        return;
    }

-    while (_04 >= psVar1[_14]._2) {
-        _04 -= psVar1[_14]._2;
+    while (_04 >= psVar1[mCurPoint].mTime) {
+        _04 -= psVar1[mCurPoint].mTime;
        _08 = _10;
-        _14++;
+        mCurPoint++;
        _0C = _08;
-        const s16* ps = &psVar1[_14]._0;
-        s16 r26 = ps[0];
-        switch(r26) {
-        case 0xf:
+        const Point* ps = &psVar1[mCurPoint];
+        s16 mode = ps->mEnvelopeMode;
+        switch(mode) {
+        case ENVELOPE_STOP:
            _1C = 0;
            return;
-        case 0xe:
+        case ENVELOPE_HOLD:
            _1C = 2;
            return;
-        case 0xd:
-            _14 = ps[2];
+        case ENVELOPE_LOOP:
+            mCurPoint = ps->mValue;
            break;
        default:
-            _18 = r26;
-            _10 = ps[2] / 32768.0f;
+            mEnvelopeMode = mode;
+            _10 = ps->mValue / 32768.0f;
            break;
        }
    }

-    updateCurrentValue(psVar1[_14]._2);
+    updateCurrentValue(psVar1[mCurPoint].mTime);
 }

 f32 const JASOscillator::sCurveTableLinear[17] = {
@@ -163,7 +163,7 @@ static f32* table_list[4] = {
 };

 void JASOscillator::updateCurrentValue(f32 param_0) {
-    f32* table = table_list[_18];
+    f32* table = table_list[mEnvelopeMode];
    f32 fVar1 = 16.0f * (_04 / param_0);
    u32 index = (u32) fVar1;
    f32 fVar3 = (fVar1 - index);
@@ -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) {
@@ -950,7 +950,7 @@ s32 JASSeqParser::parseNoteOn(JASTrack* param_0, u8 param_1) {
    return 0;
 }

-s32 JASSeqParser::parseCommand(JASTrack* param_0, u8 cmd, u16 param_2) {
+s32 JASSeqParser::parseCommand(JASTrack* param_0, u8 cmd, u16 parameterTypesOverride) {
    JASSeqCtrl* seqCtrl = param_0->getSeqCtrl();
    CmdInfo* cmdInfo = NULL;
    if (cmd != 0xb0) {
@@ -959,32 +959,32 @@ s32 JASSeqParser::parseCommand(JASTrack* param_0, u8 cmd, u16 param_2) {
    } else {
        cmdInfo = &sExtCmdInfo[seqCtrl->readByte() & 0xff];
    }
-    u16 r28 = (u16)cmdInfo->field_0xe;
-    r28 |= param_2;
-    u32 stack_28[8];
-    for (int i = 0; i < cmdInfo->field_0xc; i++, r28 >>= 2) {
-        int r27 = 0;
-        switch (r28 & 3) {
+    u16 parameterTypes = (u16)cmdInfo->mParameterTypes;
+    parameterTypes |= parameterTypesOverride;
+    u32 args[8];
+    for (int i = 0; i < cmdInfo->mParameterCount; i++, parameterTypes >>= 2) {
+        int value = 0;
+        switch (parameterTypes & 3) {
        case 0:
-            r27 = (u8)seqCtrl->readByte();
+            value = (u8)seqCtrl->readByte();
            break;
        case 1:
-            r27 = (u16)seqCtrl->read16();
+            value = (u16)seqCtrl->read16();
            break;
        case 2:
-            r27 = seqCtrl->read24();
+            value = seqCtrl->read24();
            break;
        case 3:
-            r27 = readReg(param_0, (u8)seqCtrl->readByte());
+            value = readReg(param_0, (u8)seqCtrl->readByte());
            break;
        }
-        stack_28[i] = r27;
+        args[i] = value;
    }
-    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, args);
 }

 s32 JASSeqParser::parseRegCommand(JASTrack* param_0, int param_1) {
@@ -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;
 }
@@ -44,7 +44,7 @@ int JASSimpleWaveBank::TWaveHandle::getWavePtr() const {
    if (base == NULL) {
        return 0;
    }
-    return (intptr_t)base + mWaveInfo.field_0x08;
+    return (intptr_t)base + mWaveInfo.mOffsetStart;
 }

 JASSimpleWaveBank::TWaveHandle::TWaveHandle() {
@@ -26,7 +26,7 @@ JASTaskThread::~JASTaskThread() {

 void* JASTaskThread::allocCallStack(JASThreadCallback callback, const void* msg, u32 msgSize) {
    ThreadMemPool* heap;
-    u32 size = msgSize + 8;
+    u32 size = msgSize + offsetof(JASThreadCallStack, msg);
    JASThreadCallStack *callStack = (JASThreadCallStack*) JASKernel::getCommandHeap()->alloc(size);
    if (callStack == NULL) {
        return NULL;
@@ -40,7 +40,7 @@ void* JASTaskThread::allocCallStack(JASThreadCallback callback, const void* msg,

 void* JASTaskThread::allocCallStack(JASThreadCallback callback, void* msg) {
    JASThreadCallStack *callStack;
-    callStack = (JASThreadCallStack*)JASKernel::getCommandHeap()->alloc(12);
+    callStack = (JASThreadCallStack*)JASKernel::getCommandHeap()->alloc(offsetof(JASThreadCallStack, msg) + sizeof(void*));
    if (callStack == NULL) {
        return NULL;
    }
@@ -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() {
@@ -356,7 +356,7 @@ int JASTrack::gateOn(u32 param_0, u32 i_velocity, f32 i_time, u32 i_flags) {
            } else {
                JASChannel* channel = channel_mgr->mChannels[0];
                if (channel != NULL) {
-                    channel->setKey(uvar7 - channel->field_0xdc.field_0x4.field_0x01);
+                    channel->setKey(uvar7 - channel->field_0xdc.mWaveInfo.mBaseKey);
                    channel->setVelocity(i_velocity);
                    channel->setUpdateTimer(update_timer);
                }
@@ -545,10 +545,10 @@ void JASTrack::setOscTable(u32 osc_no, JASOscillator::Point const* i_table) {
 void JASTrack::setOscAdsr(s16 param_0, s16 param_1, s16 param_2, s16 param_3, u16 i_directRelease) {
    mOscParam[0] = sEnvOsc;
    mOscParam[0].mTable = mOscPoint;
-    mOscPoint[0]._2 = param_0;
-    mOscPoint[1]._2 = param_1;
-    mOscPoint[2]._2 = param_2;
-    mOscPoint[2]._4 = param_3;
+    mOscPoint[0].mTime = param_0;
+    mOscPoint[1].mTime = param_1;
+    mOscPoint[2].mTime = param_2;
+    mOscPoint[2].mValue = param_3;
    mDirectRelease = i_directRelease;
 }

@@ -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 {
@@ -48,17 +48,17 @@ JASBasicWaveBank* JASWSParser::createBasicWaveBank(void const* stream, JKRHeap*
        for (int j = 0; j < ctrl->mWaveCount; j++) {
            TWave* wave = archive->mWaveOffsets[j].ptr(header);
            JASWaveInfo wave_info;
-            wave_info.field_0x00 = wave->_01;
-            wave_info.field_0x01 = wave->_02;
-            wave_info.field_0x04 = wave->_04;
-            wave_info.field_0x08 = wave->mOffset;
-            wave_info.field_0x0c = wave->_0C;
-            wave_info.field_0x02 = wave->_10 == 0 ? 0 : 0xff;
-            wave_info.field_0x10 = wave->_14;
-            wave_info.field_0x14 = wave->_18;
-            wave_info.field_0x18 = wave->_1C;
-            wave_info.field_0x1c = wave->_20;
-            wave_info.field_0x1e = wave->_22;
+            wave_info.mWaveFormat = wave->mWaveFormat;
+            wave_info.mBaseKey = wave->mBaseKey;
+            wave_info.mSampleRate = wave->mSampleRate;
+            wave_info.mOffsetStart = wave->mAWOffsetStart;
+            wave_info.mOffsetLength = wave->mAWOffsetEnd;
+            wave_info.mLoopFlag = wave->mLoopFlags == 0 ? 0 : 0xff;
+            wave_info.mLoopStartSample = wave->mLoopStartSample;
+            wave_info.mLoopEndSample = wave->mLoopEndSample;
+            wave_info.mSampleCount = wave->mSampleCount;
+            wave_info.mpLast = wave->mpLast;
+            wave_info.mpPenult = wave->mpPenult;
            TCtrlWave* ctrl_wave = ctrl->mCtrlWaveOffsets[j].ptr(header);
            u16 local_74 = JSULoHalf(ctrl_wave->_00);
            wave_bank->setWaveInfo(wave_group, j, local_74, wave_info);
@@ -104,17 +104,17 @@ JASSimpleWaveBank* JASWSParser::createSimpleWaveBank(void const* stream, JKRHeap
    for (int i = 0; i < ctrl->mWaveCount; i++) {
        TWave* wave = archive->mWaveOffsets[i].ptr(header);
        JASWaveInfo wave_info;
-        wave_info.field_0x00 = wave->_01;
-        wave_info.field_0x01 = wave->_02;
-        wave_info.field_0x04 = wave->_04;
-        wave_info.field_0x08 = wave->mOffset;
-        wave_info.field_0x0c = wave->_0C;
-        wave_info.field_0x02 = wave->_10 == 0 ? 0 : 0xff;
-        wave_info.field_0x10 = wave->_14;
-        wave_info.field_0x14 = wave->_18;
-        wave_info.field_0x18 = wave->_1C;
-        wave_info.field_0x1c = wave->_20;
-        wave_info.field_0x1e = wave->_22;
+        wave_info.mWaveFormat = wave->mWaveFormat;
+        wave_info.mBaseKey = wave->mBaseKey;
+        wave_info.mSampleRate = wave->mSampleRate;
+        wave_info.mOffsetStart = wave->mAWOffsetStart;
+        wave_info.mOffsetLength = wave->mAWOffsetEnd;
+        wave_info.mLoopFlag = wave->mLoopFlags == 0 ? 0 : 0xff;
+        wave_info.mLoopStartSample = wave->mLoopStartSample;
+        wave_info.mLoopEndSample = wave->mLoopEndSample;
+        wave_info.mSampleCount = wave->mSampleCount;
+        wave_info.mpLast = wave->mpLast;
+        wave_info.mpPenult = wave->mpPenult;
        TCtrlWave* ctrl_wave = ctrl->mCtrlWaveOffsets[i].ptr(header);
        u32 tmp = JSULoHalf(ctrl_wave->_00);
        wave_bank->setWaveInfo(tmp, wave_info);
@@ -99,7 +99,7 @@ bool JASWaveArc::sendLoadCmd() {

    _5a++;

-    if (JASDvd::getThreadPointer()->sendCmdMsg(loadToAramCallback, &commandInfo, 0x10) == 0) {
+    if (JASDvd::getThreadPointer()->sendCmdMsg(loadToAramCallback, &commandInfo, sizeof(commandInfo)) == 0) {
        JUT_WARN(193, "%s", "sendCmdMsg loadToAramCallback Failed");
        mHeap.free();
        return false;
@@ -23,7 +23,7 @@ JAU_JASInitializer::JAU_JASInitializer() {
    heapSize_ = 0x1000;
    dvdThreadPriority_ = 3;
    audioThreadPriority_ = 2;
-    field_0x1c = 0x80;
+    mJasTrackPoolSize = 0x80;
    dspLevel_ = 1.0f;
    aramBlockSize_ = 0x2760;
    aramChannelNum_ = 2;
@@ -50,7 +50,7 @@ void JAU_JASInitializer::initJASystem(JKRSolidHeap* heap) {

        JASKernel::setupAramHeap(audioMemory_, audioMemSize_);

-        JASTrack::newMemPool(field_0x1c);
+        JASTrack::newMemPool(mJasTrackPoolSize);
        if (field_0x20 > 0) {
            JASTrack::TChannelMgr::newMemPool(field_0x20);
        }
@@ -76,33 +76,33 @@ void JAU_JASInitializer::initJASystem(JKRSolidHeap* heap) {
    }

    #if PLATFORM_SHIELD
-    JASDriver::setOutputMode(1);
+    JASDriver::setOutputMode(JAS_OUTPUT_STEREO);
    #else
    switch (OSGetSoundMode()) {
-    case 0:
-        JASDriver::setOutputMode(0);
+    case OS_SOUND_MODE_MONO:
+        JASDriver::setOutputMode(JAS_OUTPUT_MONO);
        break;
-    case 1:
-        JASDriver::setOutputMode(1);
+    case OS_SOUND_MODE_STEREO:
+        JASDriver::setOutputMode(JAS_OUTPUT_STEREO);
        break;
    }
    #endif
 }

 JAU_JAIInitializer::JAU_JAIInitializer() {
-    field_0x0 = 100;
-    field_0x4 = 4;
-    field_0x8 = 2;
-    field_0xc = 16;
+    mJaiSePoolSize = 100;
+    mJaiSeqPoolSize = 4;
+    mJaiStreamPoolSize = 2;
+    mJaiSoundChildPoolSize = 16;
 }

 // NONMATCHING JASPoolAllocObject<_> locations
 void JAU_JAIInitializer::initJAInterface() {
    s32 r30 = JASDram->getFreeSize();
-    JAIStream::newMemPool(field_0x8);
-    JAISeq::newMemPool(field_0x4);
-    JAISe::newMemPool(field_0x0);
-    JAISoundChild::newMemPool(field_0xc);
+    JAIStream::newMemPool(mJaiStreamPoolSize);
+    JAISeq::newMemPool(mJaiSeqPoolSize);
+    JAISe::newMemPool(mJaiSePoolSize);
+    JAISoundChild::newMemPool(mJaiSoundChildPoolSize);
    s32 r29 = JASDram->getFreeSize();
    OS_REPORT("JAU_JAIInitializer uses %d bytes\n", r30 - r29);
 }
@@ -245,11 +245,11 @@ u8* JAUSection::newStaticSeqDataBlock_(JAISoundID param_0, u32 size) {
    return NULL;
 }

-bool JAUSection::newStaticSeqData(JAISoundID param_0, void const* param_1, u32 param_2) {
+bool JAUSection::newStaticSeqData(JAISoundID param_0, void const* param_1, u32 size) {
    {
-        u8* r30 = newStaticSeqDataBlock_(param_0, param_2);
+        u8* r30 = newStaticSeqDataBlock_(param_0, size);
        if (r30) {
-            memcpy(r30, param_1, param_2);
+            memcpy(r30, param_1, size);
            return true;
        }
    }
@@ -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];
-    u32* puVar2 = (u32*)((u8*)field_0x8 + r29);
+    u32 r29 = mTableOffsets[param_0];
+    u32* puVar2 = (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;
@@ -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;
    }

@@ -19,10 +19,10 @@ static void setup_callback(u16 param_0) {
    flag = FALSE;
 }

-void DsetupTable(u32 param_0, u32 param_1, u32 param_2, u32 param_3, u32 param_4) {
+void DsetupTable(u32 channelCount, u32 channelBufferAddress, u32 param_2, u32 param_3, u32 param_4) {
    u32 table[5];
-    table[0] = (param_0 & 0xFFFF) | 0x81000000;
-    table[1] = param_1;
+    table[0] = (channelCount & 0xFFFF) | 0x81000000;
+    table[1] = channelBufferAddress;
    table[2] = param_2;
    table[3] = param_3;
    table[4] = param_4;
@@ -526,7 +526,7 @@ static DSPTaskInfo audio_task ATTRIBUTE_ALIGN(32);

 static u8 AUDIO_YIELD_BUFFER[8192] ATTRIBUTE_ALIGN(32);

-void DspBoot(void (*param_0)(void*)) {
+void DspBoot(void (*requestCallback)(void*)) {
    DspInitWork();
    OS_REPORT("Dsp をブートします\n");
    audio_task.priority = 0xf0;
@@ -541,7 +541,7 @@ void DspBoot(void (*param_0)(void*)) {
    audio_task.init_cb = DspHandShake;
    audio_task.res_cb = NULL;
    audio_task.done_cb = NULL;
-    audio_task.req_cb = param_0;
+    audio_task.req_cb = requestCallback;
    DSPInit();
    DSPAddPriorTask(&audio_task);
    OS_REPORT("Dspブートしました\n");
@@ -12,7 +12,7 @@ extern "C" void __DSP_remove_task(DSPTaskInfo* task);

 static void Dsp_Update_Request();

-static vu8 struct_80451308;
+static vu8 DspRunningStatus;
 static u8 struct_80451309;

 DSPTaskInfo* DSP_prior_task;
@@ -23,7 +23,7 @@ extern "C" void __DSPHandler(__OSInterrupt interrupt, OSContext* context) {
    OSClearContext(&funcContext);
    OSSetCurrentContext(&funcContext);

-    if (struct_80451308 == 1 || struct_80451308 == 0) {
+    if (DspRunningStatus == 1 || DspRunningStatus == 0) {
        __DSP_curr_task = DSP_prior_task;
    }

@@ -38,7 +38,7 @@ extern "C" void __DSPHandler(__OSInterrupt interrupt, OSContext* context) {
    case 0xDCD10000:
        __DSP_curr_task->state = 1;
        if (__DSP_curr_task == DSP_prior_task) {
-            struct_80451308 = 1;
+            DspRunningStatus = 1;
        }
        if (__DSP_curr_task->init_cb != NULL) {
            __DSP_curr_task->init_cb(__DSP_curr_task);
@@ -47,7 +47,7 @@ extern "C" void __DSPHandler(__OSInterrupt interrupt, OSContext* context) {
    case 0xDCD10001:
        __DSP_curr_task->state = 1;
        if (__DSP_curr_task == DSP_prior_task) {
-            struct_80451308 = 1;
+            DspRunningStatus = 1;
            Dsp_Update_Request();
        }
        if (__DSP_curr_task->res_cb != NULL) {
@@ -97,7 +97,7 @@ extern "C" void __DSPHandler(__OSInterrupt interrupt, OSContext* context) {
            __DSP_curr_task = DSP_prior_task;
            Dsp_Update_Request();
        } else {
-            struct_80451308 = 3;
+            DspRunningStatus = 3;
            DSPSendMailToDSP(0xCDD10001);
            while (DSPCheckMailToDSP() != 0);
            __DSP_exec_task(DSP_prior_task, __DSP_first_task);
@@ -113,7 +113,7 @@ extern "C" void __DSPHandler(__OSInterrupt interrupt, OSContext* context) {
 static u32 sync_stack[5];

 void DsyncFrame2(u32 param_0, u32 param_1, u32 param_2) {
-    if (struct_80451308 != 1) {
+    if (DspRunningStatus != 1) {
        sync_stack[0] = param_0;
        struct_80451309 = 1;
        sync_stack[1] = param_1;
@@ -125,7 +125,7 @@ void DsyncFrame2(u32 param_0, u32 param_1, u32 param_2) {
 }

 static void DsyncFrame3(u32 param_0, u32 param_1, u32 param_2, u32 param_3, u32 param_4) {
-    if (struct_80451308 != 1) {
+    if (DspRunningStatus != 1) {
        sync_stack[0] = param_0;
        struct_80451309 = 2;
        sync_stack[1] = param_1;
@@ -152,9 +152,9 @@ static void Dsp_Update_Request() {
 }

 int Dsp_Running_Check() {
-    return struct_80451308 == 1 ? TRUE : FALSE;
+    return DspRunningStatus == 1 ? TRUE : FALSE;
 }

 void Dsp_Running_Start() {
-    struct_80451308 = 1;
+    DspRunningStatus = 1;
 }
@@ -30,15 +30,15 @@ Z2AudioMgr::Z2AudioMgr() : mSoundStarter(true) {
 void Z2AudioMgr::init(JKRSolidHeap* heap, u32 memSize, void* baaData, JKRArchive* seqArc) {
    JAU_JASInitializer JASInitializer;
    JASInitializer.audioMemSize_ = memSize;
-    JASInitializer.field_0x1c = 140;
+    JASInitializer.mJasTrackPoolSize = 140;
    JASInitializer.dspLevel_ = 1.3f;
    JASInitializer.waveArcDir_ = "Audiores/Waves/";
    JASInitializer.initJASystem(heap);

    JAU_JAIInitializer JAIInitializer;
-    JAIInitializer.field_0x0 = 78;
-    JAIInitializer.field_0x4 = 4;
-    JAIInitializer.field_0xc = 48;
+    JAIInitializer.mJaiSePoolSize = 78;
+    JAIInitializer.mJaiSeqPoolSize = 4;
+    JAIInitializer.mJaiSoundChildPoolSize = 48;
    JAIInitializer.initJAInterface();
    
    JAISeMgr* seMgr = mSoundMgr.getSeMgr();
@@ -144,7 +144,7 @@ void Z2AudioMgr::init(JKRSolidHeap* heap, u32 memSize, void* baaData, JKRArchive
 }

 void Z2AudioMgr::setOutputMode(u32 mode) {
-    if (mode <= 2) {
+    if (mode <= JAS_OUTPUT_SURROUND) {
        JAISetOutputMode(mode);
    }
 }
@@ -3266,7 +3266,7 @@ static void daMP_MixAudio(s16* destination, s16*, u32 sample) {
 				if (r_mix > 32767)
 					r_mix = 32767;

-                if (JASDriver::getOutputMode() == 0) {
+                if (JASDriver::getOutputMode() == JAS_OUTPUT_MONO) {
                    l_mix = r_mix = ((r_mix >> 1) + (l_mix >> 1));
                    r_mix = (s16)r_mix;
                    l_mix = (s16)l_mix;
@@ -24,6 +24,8 @@
 #include "m_Do/m_Do_graphic.h"
 #include <cstring>

+#include "JSystem/JAudio2/JASDriverIF.h"
+
 typedef void (dMenu_Option_c::*initFunc)();
 static initFunc init[] = {
    &dMenu_Option_c::atten_init,
@@ -89,7 +91,7 @@ dMenu_Option_c::dMenu_Option_c(JKRArchive* i_archive, STControl* i_stick) {

 dMenu_Option_c::~dMenu_Option_c() {}

-static const u32 dMo_soundMode[3] = {0, 1, 2};
+static const u32 dMo_soundMode[3] = {JAS_OUTPUT_MONO, JAS_OUTPUT_STEREO, JAS_OUTPUT_SURROUND};

 void dMenu_Option_c::_create() {
    static const u64 text_a_tag[5] = {MULTI_CHAR('atext1_1'), MULTI_CHAR('atext1_2'), MULTI_CHAR('atext1_3'), MULTI_CHAR('atext1_4'), MULTI_CHAR('atext1_5')};
@@ -1755,13 +1757,13 @@ void dMenu_Option_c::screenSet() {
    }
 }

-void dMenu_Option_c::setSoundMode(u32 param_0) {
-    switch (param_0) {
-    case 0:
+void dMenu_Option_c::setSoundMode(u32 soundMode) {
+    switch (soundMode) {
+    case JAS_OUTPUT_MONO:
        OSSetSoundMode(OS_SOUND_MODE_MONO);
        break;
-    case 1:
-    case 2:
+    case JAS_OUTPUT_STEREO:
+    case JAS_OUTPUT_SURROUND: // Via dolby pro logic 2, so it's over 2 output channels.
        OSSetSoundMode(OS_SOUND_MODE_STEREO);
        break;
    }
@@ -158,7 +158,7 @@ void mDoDvdThd_param_c::mainLoop() {
        while ((command = this->getFirstCommand())) {
            this->cut(command);
            if (mDoDvdThd::SyncWidthSound) {
-                JASDvd::getThreadPointer()->sendCmdMsg(cb, &command, 4);
+                JASDvd::getThreadPointer()->sendCmdMsg(cb, &command, sizeof(void*));
            } else {
                cb(&command);
            }
@@ -0,0 +1,88 @@
+#!/usr/bin/env python3
+
+import argparse
+import os
+from pathlib import Path
+
+if os.name == "nt":
+  DEFAULT_DOLPHIN_CONFIG_PATH = Path(os.getenv('APPDATA')) / "Dolphin Emulator"
+else:
+  DEFAULT_DOLPHIN_CONFIG_PATH = Path("~/.var/app/org.DolphinEmu.dolphin-emu/data/dolphin-emu").expanduser()
+
+def expanded_path(path_str: str):
+  path = Path(path_str)
+  path = path.expanduser()
+  return path
+
+parser = argparse.ArgumentParser()
+parser.add_argument(
+  "vanilla_iso_path",
+  type=expanded_path,
+  help="Path to a vanilla Wind Waker ISO to use as a base.",
+)
+parser.add_argument(
+  "output_iso_path",
+  type=expanded_path,
+  help="Path to put the modified ISO.",
+)
+parser.add_argument(
+  "decomp_repo_path",
+  type=expanded_path,
+  help="Path to the root of the git repository containing the tww decompilation.",
+)
+parser.add_argument(
+  "--map",
+  type=expanded_path,
+  default=DEFAULT_DOLPHIN_CONFIG_PATH / "Maps",
+  help="Folder to place the symbol map for the modified ISO (defaults to Dolphin's maps directory).",
+)
+
+args = parser.parse_args()
+
+decomp_build_path = args.decomp_repo_path / "build/GZ2E01"
+
+import sys
+import os.path
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), "gclib"))
+
+from gclib.gcm import GCM
+from gclib.rarc import RARC
+from gclib.yaz0_yay0 import Yaz0
+from io import BytesIO
+import shutil
+
+gcm = GCM(args.vanilla_iso_path)
+gcm.read_entire_disc()
+
+rels_arc = RARC(gcm.read_file_data("files/RELS.arc"))
+rels_arc.read()
+
+for rel_name in os.listdir(decomp_build_path):
+  if os.path.isfile(decomp_build_path / rel_name):
+    continue
+  if not os.path.isfile(decomp_build_path / rel_name / (rel_name + ".rel")):
+    continue
+  decomp_rel_path = decomp_build_path / rel_name / (rel_name + ".rel")
+  with open(decomp_rel_path, "rb") as f:
+    decomp_rel_data = BytesIO(f.read())
+    rel_file_entry = rels_arc.get_file_entry(rel_name.lower() + ".rel")
+    if rel_file_entry:
+      rel_file_entry.data = Yaz0.compress(decomp_rel_data)
+    else:
+      gcm_rel_file_path = f"files/rel/Final/Release/{rel_name}.rel"
+      assert gcm_rel_file_path in gcm.files_by_path, f"Invalid REL path: {gcm_rel_file_path}"
+      gcm.changed_files[gcm_rel_file_path] = decomp_rel_data
+
+rels_arc.save_changes()
+gcm.changed_files["files/RELS.arc"] = rels_arc.data
+
+with open(decomp_build_path / "framework.dol", "rb") as f:
+  gcm.changed_files["sys/main.dol"] = BytesIO(f.read())
+
+with open(decomp_build_path / "framework.elf.MAP", "rb") as f:
+  gcm.changed_files["files/map/Final/Release/frameworkF.map"] = BytesIO(f.read())
+shutil.copy(decomp_build_path / "framework.elf.MAP", args.map / "GZ2E01.map")
+
+for _ in gcm.export_disc_to_iso_with_changed_files(args.output_iso_path): pass
+
+print("Done")