diff --git a/include/Z2AudioLib/Z2DebugSys.h b/include/Z2AudioLib/Z2DebugSys.h
index 1acd8f97b9..11851a1977 100644
--- a/include/Z2AudioLib/Z2DebugSys.h
+++ b/include/Z2AudioLib/Z2DebugSys.h
@@ -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);
diff --git a/libs/JSystem/include/JSystem/JAudio2/JAISeqDataMgr.h b/libs/JSystem/include/JSystem/JAudio2/JAISeqDataMgr.h
index 510f1f4905..a517a58c16 100644
--- a/libs/JSystem/include/JSystem/JAudio2/JAISeqDataMgr.h
+++ b/libs/JSystem/include/JSystem/JAudio2/JAISeqDataMgr.h
@@ -10,17 +10,17 @@
  */
 struct JAISeqData {
     JAISeqData(const void* param_0, u32 param_1) {
-        field_0x0 = (void*)param_0;
-        field_0x4 = param_1;
+        mBase = (void*)param_0;
+        mOffset = param_1;
     }
 
     void set(const void* param_0, u32 param_1) {
-        field_0x0 = (void*)param_0;
-        field_0x4 = param_1;
+        mBase = (void*)param_0;
+        mOffset = param_1;
     }
 
-    /* 0x00 */ void* field_0x0;
-    /* 0x04 */ u32 field_0x4;
+    /* 0x00 */ void* mBase;
+    /* 0x04 */ u32 mOffset;
 };
 
 /**
@@ -29,10 +29,10 @@ struct JAISeqData {
  */
 struct JAISeqDataRegion {
     bool intersects(const JAISeqData& seqData) const {
-        if ((uintptr_t)addr + size < (uintptr_t)seqData.field_0x0) {
+        if ((uintptr_t)addr + size < (uintptr_t)seqData.mBase) {
             return false;
         }
-        if ((uintptr_t)seqData.field_0x0 + seqData.field_0x4 < (uintptr_t)addr) {
+        if ((uintptr_t)seqData.mBase + seqData.mOffset < (uintptr_t)addr) {
             return false;
         }
         return true;
diff --git a/libs/JSystem/include/JSystem/JAudio2/JASAramStream.h b/libs/JSystem/include/JSystem/JAudio2/JASAramStream.h
index 17d4c6f521..df1f3bff86 100644
--- a/libs/JSystem/include/JSystem/JAudio2/JASAramStream.h
+++ b/libs/JSystem/include/JSystem/JAudio2/JASAramStream.h
@@ -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;
diff --git a/libs/JSystem/include/JSystem/JAudio2/JASBNKParser.h b/libs/JSystem/include/JSystem/JAudio2/JASBNKParser.h
index df742ed681..ac3c740cd9 100644
--- a/libs/JSystem/include/JSystem/JAudio2/JASBNKParser.h
+++ b/libs/JSystem/include/JSystem/JAudio2/JASBNKParser.h
@@ -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];
diff --git a/libs/JSystem/include/JSystem/JAudio2/JASChannel.h b/libs/JSystem/include/JSystem/JAudio2/JASChannel.h
index e9e57785b2..ff1e4c85a2 100644
--- a/libs/JSystem/include/JSystem/JAudio2/JASChannel.h
+++ b/libs/JSystem/include/JSystem/JAudio2/JASChannel.h
@@ -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];
diff --git a/libs/JSystem/include/JSystem/JAudio2/JASDSPChannel.h b/libs/JSystem/include/JSystem/JAudio2/JASDSPChannel.h
index f843562f37..8204ab0838 100644
--- a/libs/JSystem/include/JSystem/JAudio2/JASDSPChannel.h
+++ b/libs/JSystem/include/JSystem/JAudio2/JASDSPChannel.h
@@ -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;
diff --git a/libs/JSystem/include/JSystem/JAudio2/JASDSPInterface.h b/libs/JSystem/include/JSystem/JAudio2/JASDSPInterface.h
index 44f2805bfe..4cdbf22b63 100644
--- a/libs/JSystem/include/JSystem/JAudio2/JASDSPInterface.h
+++ b/libs/JSystem/include/JSystem/JAudio2/JASDSPInterface.h
@@ -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*));
diff --git a/libs/JSystem/include/JSystem/JAudio2/JASDriverIF.h b/libs/JSystem/include/JSystem/JAudio2/JASDriverIF.h
index 319c826345..5cddc38596 100644
--- a/libs/JSystem/include/JSystem/JAudio2/JASDriverIF.h
+++ b/libs/JSystem/include/JSystem/JAudio2/JASDriverIF.h
@@ -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 {
diff --git a/libs/JSystem/include/JSystem/JAudio2/JASOscillator.h b/libs/JSystem/include/JSystem/JAudio2/JASOscillator.h
index 4dc7b171b6..4db9a69e58 100644
--- a/libs/JSystem/include/JSystem/JAudio2/JASOscillator.h
+++ b/libs/JSystem/include/JSystem/JAudio2/JASOscillator.h
@@ -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;
 
diff --git a/libs/JSystem/include/JSystem/JAudio2/JASSeqParser.h b/libs/JSystem/include/JSystem/JAudio2/JASSeqParser.h
index 096cbadd98..51db04ba26 100644
--- a/libs/JSystem/include/JSystem/JAudio2/JASSeqParser.h
+++ b/libs/JSystem/include/JSystem/JAudio2/JASSeqParser.h
@@ -14,9 +14,9 @@ public:
     enum BranchCondition {};
 
     struct CmdInfo {
-        s32 (JASSeqParser::*field_0x0)(JASTrack*, u32*);
-        u16 field_0xc;
-        u16 field_0xe;
+        s32 (JASSeqParser::*mHandler)(JASTrack*, u32*);
+        u16 mParameterCount;
+        u16 mParameterTypes;
     };
 
     virtual ~JASSeqParser() {}
diff --git a/libs/JSystem/include/JSystem/JAudio2/JASSeqReader.h b/libs/JSystem/include/JSystem/JAudio2/JASSeqReader.h
index 9dce7f56f7..73908eae6f 100644
--- a/libs/JSystem/include/JSystem/JAudio2/JASSeqReader.h
+++ b/libs/JSystem/include/JSystem/JAudio2/JASSeqReader.h
@@ -3,6 +3,8 @@
 
 #include <types.h>
 
+#define JAS_SEQ_STACK_SIZE 8
+
 /**
  * @ingroup jsystem-jaudio
  * 
@@ -19,55 +21,55 @@ public:
     int readMidiValue();
 
     void jump(u32 param_1) {
-        field_0x04 = field_0x00 + param_1;
+        mCurPos = mBase + param_1;
     }
 
     void jump(void* param_1) {
-        field_0x04 = (u8*)param_1;
+        mCurPos = (u8*)param_1;
     }
 
     u32 get24(u32 param_0) const {
-        return (*(u32*)(field_0x00 + param_0 - 1)) & 0xffffff;
+        return (*(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 */
diff --git a/libs/JSystem/include/JSystem/JAudio2/JASTrackPort.h b/libs/JSystem/include/JSystem/JAudio2/JASTrackPort.h
index 393a701c27..781da78049 100644
--- a/libs/JSystem/include/JSystem/JAudio2/JASTrackPort.h
+++ b/libs/JSystem/include/JSystem/JAudio2/JASTrackPort.h
@@ -19,12 +19,12 @@ public:
     u32 checkImport(u32) const;
     u32 checkExport(u32) const;
 
-    u16 get(u32 param_0) const { return field_0x4[param_0]; }
-    void set(u32 param_0, u16 param_1) { field_0x4[param_0] = param_1; }
+    u16 get(u32 param_0) const { return mPortValues[param_0]; }
+    void set(u32 param_0, u16 param_1) { mPortValues[param_0] = param_1; }
 
     u16 field_0x0;
     u16 field_0x2;
-    u16 field_0x4[MAX_PORTS];
+    u16 mPortValues[MAX_PORTS];
 };
 
 #endif /* JASTRACKPORT_H */
diff --git a/libs/JSystem/include/JSystem/JAudio2/JASWSParser.h b/libs/JSystem/include/JSystem/JAudio2/JASWSParser.h
index 1dc68674cf..6844d7cb8b 100644
--- a/libs/JSystem/include/JSystem/JAudio2/JASWSParser.h
+++ b/libs/JSystem/include/JSystem/JAudio2/JASWSParser.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;
diff --git a/libs/JSystem/include/JSystem/JAudio2/JASWaveInfo.h b/libs/JSystem/include/JSystem/JAudio2/JASWaveInfo.h
index 33571fef13..158aa642ab 100644
--- a/libs/JSystem/include/JSystem/JAudio2/JASWaveInfo.h
+++ b/libs/JSystem/include/JSystem/JAudio2/JASWaveInfo.h
@@ -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;
diff --git a/libs/JSystem/include/JSystem/JAudio2/JAUInitializer.h b/libs/JSystem/include/JSystem/JAudio2/JAUInitializer.h
index 8b5090c580..9f9e5bc6fd 100644
--- a/libs/JSystem/include/JSystem/JAudio2/JAUInitializer.h
+++ b/libs/JSystem/include/JSystem/JAudio2/JAUInitializer.h
@@ -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 */
diff --git a/libs/JSystem/include/JSystem/JAudio2/JAUSeqCollection.h b/libs/JSystem/include/JSystem/JAudio2/JAUSeqCollection.h
index 37c5afc6d3..78d2a344de 100644
--- a/libs/JSystem/include/JSystem/JAudio2/JAUSeqCollection.h
+++ b/libs/JSystem/include/JSystem/JAudio2/JAUSeqCollection.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_;
diff --git a/libs/JSystem/include/JSystem/JAudio2/JAUStreamAramMgr.h b/libs/JSystem/include/JSystem/JAudio2/JAUStreamAramMgr.h
index bf861b495d..f1cfe8f7f6 100644
--- a/libs/JSystem/include/JSystem/JAudio2/JAUStreamAramMgr.h
+++ b/libs/JSystem/include/JSystem/JAudio2/JAUStreamAramMgr.h
@@ -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;
diff --git a/libs/JSystem/include/JSystem/JAudio2/dspproc.h b/libs/JSystem/include/JSystem/JAudio2/dspproc.h
index 868080031a..c49c143fe4 100644
--- a/libs/JSystem/include/JSystem/JAudio2/dspproc.h
+++ b/libs/JSystem/include/JSystem/JAudio2/dspproc.h
@@ -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);
diff --git a/libs/JSystem/include/JSystem/JAudio2/dsptask.h b/libs/JSystem/include/JSystem/JAudio2/dsptask.h
index 8042d1884b..7dbcff2dec 100644
--- a/libs/JSystem/include/JSystem/JAudio2/dsptask.h
+++ b/libs/JSystem/include/JSystem/JAudio2/dsptask.h
@@ -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));
 
diff --git a/libs/JSystem/src/JAudio2/JAISe.cpp b/libs/JSystem/src/JAudio2/JAISe.cpp
index fd75e9b7b7..9857160762 100644
--- a/libs/JSystem/src/JAudio2/JAISe.cpp
+++ b/libs/JSystem/src/JAudio2/JAISe.cpp
@@ -57,7 +57,7 @@ void JAISe::startTrack_(const JASSoundParams& params) {
     }
 
     inner_.field_0x26c = 1;
-    inner_.track.setSeqData(inner_.mSeqData.field_0x0, inner_.mSeqData.field_0x4);
+    inner_.track.setSeqData(inner_.mSeqData.mBase, inner_.mSeqData.mOffset);
     inner_.track.startSeq();
 }
 
diff --git a/libs/JSystem/src/JAudio2/JAISeq.cpp b/libs/JSystem/src/JAudio2/JAISeq.cpp
index 7f9f9132d1..79e889db1a 100644
--- a/libs/JSystem/src/JAudio2/JAISeq.cpp
+++ b/libs/JSystem/src/JAudio2/JAISeq.cpp
@@ -40,7 +40,7 @@ void JAISeq::JAISeqMgr_startID_(JAISoundID id, const JGeometry::TVec3<f32>* posP
 void JAISeq::playSeqData_(const JASSoundParams& params, JAISoundActivity activity) {
     JUT_ASSERT(72, JASTrack_isFreeOrStopped( & inner_.outputTrack ));
 
-    inner_.outputTrack.setSeqData(inner_.mSeqData.field_0x0, inner_.mSeqData.field_0x4);
+    inner_.outputTrack.setSeqData(inner_.mSeqData.mBase, inner_.mSeqData.mOffset);
     if (audible_) {
         initTrack_JAISound_(&inner_.outputTrack);
     } else {
diff --git a/libs/JSystem/src/JAudio2/JAIStream.cpp b/libs/JSystem/src/JAudio2/JAIStream.cpp
index f228347d26..7641fc3682 100644
--- a/libs/JSystem/src/JAudio2/JAIStream.cpp
+++ b/libs/JSystem/src/JAudio2/JAIStream.cpp
@@ -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 {
diff --git a/libs/JSystem/src/JAudio2/JASAramStream.cpp b/libs/JSystem/src/JAudio2/JASAramStream.cpp
index 68a1b7988c..ec4a8e2e73 100644
--- a/libs/JSystem/src/JAudio2/JASAramStream.cpp
+++ b/libs/JSystem/src/JAudio2/JASAramStream.cpp
@@ -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;
 }
 
 
diff --git a/libs/JSystem/src/JAudio2/JASAudioReseter.cpp b/libs/JSystem/src/JAudio2/JASAudioReseter.cpp
index 4d4f3517c1..46853d03e7 100644
--- a/libs/JSystem/src/JAudio2/JASAudioReseter.cpp
+++ b/libs/JSystem/src/JAudio2/JASAudioReseter.cpp
@@ -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();
diff --git a/libs/JSystem/src/JAudio2/JASBNKParser.cpp b/libs/JSystem/src/JAudio2/JASBNKParser.cpp
index c19daf5fe1..e0414fb2ac 100644
--- a/libs/JSystem/src/JAudio2/JASBNKParser.cpp
+++ b/libs/JSystem/src/JAudio2/JASBNKParser.cpp
@@ -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;
diff --git a/libs/JSystem/src/JAudio2/JASBank.cpp b/libs/JSystem/src/JAudio2/JASBank.cpp
index b307619694..c23b6cc99b 100644
--- a/libs/JSystem/src/JAudio2/JASBank.cpp
+++ b/libs/JSystem/src/JAudio2/JASBank.cpp
@@ -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()) {
diff --git a/libs/JSystem/src/JAudio2/JASBasicWaveBank.cpp b/libs/JSystem/src/JAudio2/JASBasicWaveBank.cpp
index a6134046be..225e17002e 100644
--- a/libs/JSystem/src/JAudio2/JASBasicWaveBank.cpp
+++ b/libs/JSystem/src/JAudio2/JASBasicWaveBank.cpp
@@ -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;
 }
diff --git a/libs/JSystem/src/JAudio2/JASChannel.cpp b/libs/JSystem/src/JAudio2/JASChannel.cpp
index 0979b38b8d..7db36702f5 100644
--- a/libs/JSystem/src/JAudio2/JASChannel.cpp
+++ b/libs/JSystem/src/JAudio2/JASChannel.cpp
@@ -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);
diff --git a/libs/JSystem/src/JAudio2/JASDSPChannel.cpp b/libs/JSystem/src/JAudio2/JASDSPChannel.cpp
index 268c80a779..f6588a928c 100644
--- a/libs/JSystem/src/JAudio2/JASDSPChannel.cpp
+++ b/libs/JSystem/src/JAudio2/JASDSPChannel.cpp
@@ -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++;
         }
     }
diff --git a/libs/JSystem/src/JAudio2/JASDSPInterface.cpp b/libs/JSystem/src/JAudio2/JASDSPInterface.cpp
index e9dfd0d45d..d5da103a2f 100644
--- a/libs/JSystem/src/JAudio2/JASDSPInterface.cpp
+++ b/libs/JSystem/src/JAudio2/JASDSPInterface.cpp
@@ -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) {
diff --git a/libs/JSystem/src/JAudio2/JASDriverIF.cpp b/libs/JSystem/src/JAudio2/JASDriverIF.cpp
index 2c9f305b61..7d602a8856 100644
--- a/libs/JSystem/src/JAudio2/JASDriverIF.cpp
+++ b/libs/JSystem/src/JAudio2/JASDriverIF.cpp
@@ -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() {
diff --git a/libs/JSystem/src/JAudio2/JASDrumSet.cpp b/libs/JSystem/src/JAudio2/JASDrumSet.cpp
index 0262e63c36..4e944c4fe2 100644
--- a/libs/JSystem/src/JAudio2/JASDrumSet.cpp
+++ b/libs/JSystem/src/JAudio2/JASDrumSet.cpp
@@ -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;
 
diff --git a/libs/JSystem/src/JAudio2/JASOscillator.cpp b/libs/JSystem/src/JAudio2/JASOscillator.cpp
index e67f997619..f4bf2ade6f 100644
--- a/libs/JSystem/src/JAudio2/JASOscillator.cpp
+++ b/libs/JSystem/src/JAudio2/JASOscillator.cpp
@@ -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);
diff --git a/libs/JSystem/src/JAudio2/JASSeqCtrl.cpp b/libs/JSystem/src/JAudio2/JASSeqCtrl.cpp
index 044f3873f2..a4e4a4b441 100644
--- a/libs/JSystem/src/JAudio2/JASSeqCtrl.cpp
+++ b/libs/JSystem/src/JAudio2/JASSeqCtrl.cpp
@@ -34,9 +34,9 @@ void JASSeqCtrl::init() {
     field_0x51 = 0;
 }
 
-void JASSeqCtrl::start(void* param_0, u32 param_1) {
-    mReader.init(param_0);
-    mReader.jump(param_1);
+void JASSeqCtrl::start(void* base, u32 offset) {
+    mReader.init(base);
+    mReader.jump(offset);
 }
 
 int JASSeqCtrl::tickProc(JASTrack* param_0) {
diff --git a/libs/JSystem/src/JAudio2/JASSeqParser.cpp b/libs/JSystem/src/JAudio2/JASSeqParser.cpp
index fa3060952a..78f7dfad14 100644
--- a/libs/JSystem/src/JAudio2/JASSeqParser.cpp
+++ b/libs/JSystem/src/JAudio2/JASSeqParser.cpp
@@ -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) {
diff --git a/libs/JSystem/src/JAudio2/JASSeqReader.cpp b/libs/JSystem/src/JAudio2/JASSeqReader.cpp
index c259c57d40..459c2edeee 100644
--- a/libs/JSystem/src/JAudio2/JASSeqReader.cpp
+++ b/libs/JSystem/src/JAudio2/JASSeqReader.cpp
@@ -8,81 +8,81 @@
 #include "JSystem/JAudio2/JASSeqReader.h"
 
 void JASSeqReader::init() {
-    field_0x00 = 0;
-    field_0x04 = 0;
-    field_0x08 = 0;
+    mBase = 0;
+    mCurPos = 0;
+    mCurStackDepth = 0;
 
-    for (int i = 0; i < 8; i++) {
-        field_0x0c[i] = NULL;
-        field_0x2c[i] = 0;
+    for (int i = 0; i < JAS_SEQ_STACK_SIZE; i++) {
+        mReturnAddr[i] = NULL;
+        mLoopCount[i] = 0;
     }
 }
 
-void JASSeqReader::init(void* param_0) {
-    field_0x00 = (u8*)param_0;
-    field_0x04 = field_0x00;
-    field_0x08 = 0;
+void JASSeqReader::init(void* base) {
+    mBase = (u8*)base;
+    mCurPos = mBase;
+    mCurStackDepth = 0;
 
-    for (int i = 0; i < 8; i++) {
-        field_0x0c[i] = NULL;
-        field_0x2c[i] = 0;
+    for (int i = 0; i < JAS_SEQ_STACK_SIZE; i++) {
+        mReturnAddr[i] = NULL;
+        mLoopCount[i] = 0;
     }
     
 }
 
 bool JASSeqReader::call(u32 param_0) {
-    if (field_0x08 >= 8) {
+    if (mCurStackDepth >= JAS_SEQ_STACK_SIZE) {
         JUT_WARN(42, "%s", "Cannot exec call command");
         return false;
     }
 
-    field_0x0c[field_0x08++] = (u16*)field_0x04;
-    field_0x04 = field_0x00 + param_0;
+    mReturnAddr[mCurStackDepth++] = (u16*)mCurPos;
+    mCurPos = mBase + param_0;
 
     return true;
 }
 
 bool JASSeqReader::loopStart(u32 param_0) {
-    if (8 <= field_0x08) {
+    if (JAS_SEQ_STACK_SIZE <= mCurStackDepth) {
         JUT_WARN(53, "%s", "Cannot exec loopStart command");
         return false;
     }
 
-    field_0x0c[field_0x08] = (u16*)field_0x04;
-    field_0x2c[field_0x08++] = param_0;
+    mReturnAddr[mCurStackDepth] = (u16*)mCurPos;
+    mLoopCount[mCurStackDepth++] = param_0;
 
     return true;
 }
 
 
 bool JASSeqReader::loopEnd() {
-    if (field_0x08 == 0) {
+    if (mCurStackDepth == 0) {
         JUT_WARN(65, "%s", "cannot loopE for call-stack is NULL");
         return false;
     }
 
-    u16 tmp = field_0x2c[field_0x08 - 1];
+    u16 tmp = mLoopCount[mCurStackDepth - 1];
 
     if (tmp != 0) {
         tmp--;
     }
 
     if (!tmp) {
-        field_0x08--;
+        mCurStackDepth--;
         return true;
     }
 
-    field_0x2c[field_0x08 - 1] = tmp;
-    field_0x04 = (u8*)field_0x0c[field_0x08 - 1];
+    mLoopCount[mCurStackDepth - 1] = tmp;
+    mCurPos = (u8*)mReturnAddr[mCurStackDepth - 1];
     return true;
 }
 
 bool JASSeqReader::ret() {
-    if (field_0x08 == 0) {
+    if (mCurStackDepth == 0) {
         return false;
     }
 
-    field_0x04 = (u8*)field_0x0c[--field_0x08];
+    mCurPos = (u8*)mReturnAddr[--mCurStackDepth];
 
     return true;
 }
diff --git a/libs/JSystem/src/JAudio2/JASSimpleWaveBank.cpp b/libs/JSystem/src/JAudio2/JASSimpleWaveBank.cpp
index c599a0e857..22ee0b1205 100644
--- a/libs/JSystem/src/JAudio2/JASSimpleWaveBank.cpp
+++ b/libs/JSystem/src/JAudio2/JASSimpleWaveBank.cpp
@@ -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() {
diff --git a/libs/JSystem/src/JAudio2/JASTaskThread.cpp b/libs/JSystem/src/JAudio2/JASTaskThread.cpp
index 30a6d07a98..365424deb4 100644
--- a/libs/JSystem/src/JAudio2/JASTaskThread.cpp
+++ b/libs/JSystem/src/JAudio2/JASTaskThread.cpp
@@ -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;
     }
diff --git a/libs/JSystem/src/JAudio2/JASTrack.cpp b/libs/JSystem/src/JAudio2/JASTrack.cpp
index eec0ebd644..cd2023d065 100644
--- a/libs/JSystem/src/JAudio2/JASTrack.cpp
+++ b/libs/JSystem/src/JAudio2/JASTrack.cpp
@@ -171,9 +171,9 @@ void JASTrack::assignExtBuffer(u32 index, JASSoundParams* i_soundParams) {
     mChannelMgrs[index]->mSoundParams = i_soundParams;
 }
 
-void JASTrack::setSeqData(void* param_0, u32 param_1) {
+void JASTrack::setSeqData(void* base, u32 offset) {
     JUT_ASSERT(257, mStatus == STATUS_FREE);
-    mSeqCtrl.start(param_0, param_1);
+    mSeqCtrl.start(base, offset);
 }
 
 void JASTrack::startSeq() {
@@ -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;
 }
 
diff --git a/libs/JSystem/src/JAudio2/JASTrackPort.cpp b/libs/JSystem/src/JAudio2/JASTrackPort.cpp
index e822212ec9..bde86b37f9 100644
--- a/libs/JSystem/src/JAudio2/JASTrackPort.cpp
+++ b/libs/JSystem/src/JAudio2/JASTrackPort.cpp
@@ -3,8 +3,8 @@
 #include "JSystem/JAudio2/JASTrackPort.h"
 
 void JASTrackPort::init() {
-    for (int i = 0; i < 16; i++) {
-        field_0x4[i] = 0;
+    for (int i = 0; i < MAX_PORTS; i++) {
+        mPortValues[i] = 0;
     }
     field_0x0 = 0;
     field_0x2 = 0;
@@ -13,25 +13,25 @@ void JASTrackPort::init() {
 u16 JASTrackPort::readImport(u32 port_num) {
     JUT_ASSERT(27, port_num < MAX_PORTS);
     field_0x0 = field_0x0 & ~(1 << port_num);
-    return field_0x4[port_num];
+    return mPortValues[port_num];
 }
 
 u16 JASTrackPort::readExport(u32 port_num) {
     JUT_ASSERT(34, port_num < MAX_PORTS);
     field_0x2 = field_0x2 & ~(1 << port_num);
-    return field_0x4[port_num];
+    return mPortValues[port_num];
 }
 
 void JASTrackPort::writeImport(u32 port_num, u16 param_1) {
     JUT_ASSERT(41, port_num < MAX_PORTS);
     field_0x0 = field_0x0 | (1 << port_num);
-    field_0x4[port_num] = param_1;
+    mPortValues[port_num] = param_1;
 }
 
 void JASTrackPort::writeExport(u32 port_num, u16 param_1) {
     JUT_ASSERT(47, port_num < MAX_PORTS);
     field_0x2 = field_0x2 | (1 << port_num);
-    field_0x4[port_num] = param_1;
+    mPortValues[port_num] = param_1;
 }
 
 u32 JASTrackPort::checkImport(u32 param_0) const {
diff --git a/libs/JSystem/src/JAudio2/JASWSParser.cpp b/libs/JSystem/src/JAudio2/JASWSParser.cpp
index a03f73f35e..7454b04e51 100644
--- a/libs/JSystem/src/JAudio2/JASWSParser.cpp
+++ b/libs/JSystem/src/JAudio2/JASWSParser.cpp
@@ -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);
diff --git a/libs/JSystem/src/JAudio2/JASWaveArcLoader.cpp b/libs/JSystem/src/JAudio2/JASWaveArcLoader.cpp
index ad1a1e2a76..7db157862f 100644
--- a/libs/JSystem/src/JAudio2/JASWaveArcLoader.cpp
+++ b/libs/JSystem/src/JAudio2/JASWaveArcLoader.cpp
@@ -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;
diff --git a/libs/JSystem/src/JAudio2/JAUInitializer.cpp b/libs/JSystem/src/JAudio2/JAUInitializer.cpp
index cbcd7ba62b..f95db82359 100644
--- a/libs/JSystem/src/JAudio2/JAUInitializer.cpp
+++ b/libs/JSystem/src/JAudio2/JAUInitializer.cpp
@@ -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);
 }
diff --git a/libs/JSystem/src/JAudio2/JAUSectionHeap.cpp b/libs/JSystem/src/JAudio2/JAUSectionHeap.cpp
index 9bf781b56a..02acb153f2 100644
--- a/libs/JSystem/src/JAudio2/JAUSectionHeap.cpp
+++ b/libs/JSystem/src/JAudio2/JAUSectionHeap.cpp
@@ -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;
         }
     }
diff --git a/libs/JSystem/src/JAudio2/JAUSeqCollection.cpp b/libs/JSystem/src/JAudio2/JAUSeqCollection.cpp
index 074862e521..bf975e56b4 100644
--- a/libs/JSystem/src/JAudio2/JAUSeqCollection.cpp
+++ b/libs/JSystem/src/JAudio2/JAUSeqCollection.cpp
@@ -4,39 +4,39 @@
 #include "JSystem/JUtility/JUTAssert.h"
 
 JAUSeqCollection::JAUSeqCollection() {
-    field_0x8 = NULL;
+    mHeader = NULL;
 }
 
 void JAUSeqCollection::init(void const* param_0) {
-    field_0x8 = (const JAUSeqCollectionData*)param_0;
-    if (field_0x8->field_0x0 != 0x53 || field_0x8->field_0x1 != 0x43) {
-        field_0x8 = NULL;
+    mHeader = (const JAUSeqCollectionData*)param_0;
+    if (mHeader->mMagic1 != 0x53 || mHeader->mMagic2 != 0x43) {
+        mHeader = NULL;
         return;
     }
 
-    field_0x0 = field_0x8->field_0x2;
-    field_0xc = field_0x8->field_0x4;
-    field_0x4 = &field_0x8->field_0x8;
+    mNumSoundCategories = mHeader->mNumSoundCategories;
+    mSectionSize = mHeader->mSectionSize;
+    mTableOffsets = mHeader->mTableOffsets;
 
 }
 
 bool JAUSeqCollection::getSeqData(int param_0, int param_1, JAISeqData* param_2) {
-    if (param_0 >= field_0x0) {
+    if (param_0 >= mNumSoundCategories) {
         return false;
     }
-    u32 r29 = field_0x4[param_0];
-    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;
diff --git a/libs/JSystem/src/JAudio2/JAUSeqDataBlockMgr.cpp b/libs/JSystem/src/JAudio2/JAUSeqDataBlockMgr.cpp
index c90c36e3b8..4459c35046 100644
--- a/libs/JSystem/src/JAudio2/JAUSeqDataBlockMgr.cpp
+++ b/libs/JSystem/src/JAudio2/JAUSeqDataBlockMgr.cpp
@@ -87,8 +87,8 @@ s32 JAUDynamicSeqDataBlocks::getSeqData(JAISoundID param_0, JAISeqDataUser* para
 
     u8* seqData = mLoadedBlocks.getSeqData(param_0);
     if (seqData != NULL) {
-        param_2->field_0x0 = seqData;
-        param_2->field_0x4 = 0;
+        param_2->mBase = seqData;
+        param_2->mOffset = 0;
         return 2;
     }
 
diff --git a/libs/JSystem/src/JAudio2/dspproc.cpp b/libs/JSystem/src/JAudio2/dspproc.cpp
index 8d4dd26dfe..c301d8fd76 100644
--- a/libs/JSystem/src/JAudio2/dspproc.cpp
+++ b/libs/JSystem/src/JAudio2/dspproc.cpp
@@ -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;
diff --git a/libs/JSystem/src/JAudio2/dsptask.cpp b/libs/JSystem/src/JAudio2/dsptask.cpp
index bbdf47d64a..9aa6e4bc62 100644
--- a/libs/JSystem/src/JAudio2/dsptask.cpp
+++ b/libs/JSystem/src/JAudio2/dsptask.cpp
@@ -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");
diff --git a/libs/JSystem/src/JAudio2/osdsp_task.cpp b/libs/JSystem/src/JAudio2/osdsp_task.cpp
index d9f4973880..7ec8f3f855 100644
--- a/libs/JSystem/src/JAudio2/osdsp_task.cpp
+++ b/libs/JSystem/src/JAudio2/osdsp_task.cpp
@@ -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;
 }
diff --git a/src/Z2AudioLib/Z2AudioMgr.cpp b/src/Z2AudioLib/Z2AudioMgr.cpp
index 1465515cb6..b47d0283ea 100644
--- a/src/Z2AudioLib/Z2AudioMgr.cpp
+++ b/src/Z2AudioLib/Z2AudioMgr.cpp
@@ -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);
     }
 }
diff --git a/src/d/actor/d_a_movie_player.cpp b/src/d/actor/d_a_movie_player.cpp
index ab32fd4564..0b70fe75fe 100644
--- a/src/d/actor/d_a_movie_player.cpp
+++ b/src/d/actor/d_a_movie_player.cpp
@@ -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;
diff --git a/src/d/d_menu_option.cpp b/src/d/d_menu_option.cpp
index 32762905d9..d2c32b5ed5 100644
--- a/src/d/d_menu_option.cpp
+++ b/src/d/d_menu_option.cpp
@@ -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;
     }
diff --git a/src/m_Do/m_Do_dvd_thread.cpp b/src/m_Do/m_Do_dvd_thread.cpp
index 550cb9b587..19030cb6f2 100644
--- a/src/m_Do/m_Do_dvd_thread.cpp
+++ b/src/m_Do/m_Do_dvd_thread.cpp
@@ -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);
             }
diff --git a/tools/rebuild-decomp-tp.py b/tools/rebuild-decomp-tp.py
new file mode 100644
index 0000000000..e69f1bd33e
--- /dev/null
+++ b/tools/rebuild-decomp-tp.py
@@ -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")