From 09bf4c589b28aa1e86e72ce7d0af95e2613363b7 Mon Sep 17 00:00:00 2001
From: mrshigure <mrshigure64@gmail.com>
Date: Mon, 13 Jan 2025 20:00:03 -0800
Subject: [PATCH] Matched most of msmsys (5 functions left)

---
 include/game/msm.h      |   4 +-
 include/msm/msmstream.h |   2 +-
 include/msm/msmsys.h    | 141 +++++++----
 src/msm/msmsys.c        | 512 +++++++++++++++++++++++++++++++---------
 4 files changed, 491 insertions(+), 168 deletions(-)

diff --git a/include/game/msm.h b/include/game/msm.h
index 5d7dfa11..c99b7eb4 100644
--- a/include/game/msm.h
+++ b/include/game/msm.h
@@ -40,7 +40,9 @@
 #define MSM_ERR_OUTOFMEM -10
 #define MSM_ERR_OUTOFAMEM -20
 #define MSM_ERR_INITFAIL -20
+#define MSM_ERR_1E -30
 #define MSM_ERR_INVALID_AUXPARAM -31
+#define MSM_ERR_20 -32
 #define MSM_ERR_PLAYFAIL -33
 #define MSM_ERR_22 -34
 #define MSM_ERR_STREAMALLOC_FAIL -35
@@ -166,7 +168,7 @@ typedef struct msmStreamParam_s {
 } MSM_STREAMPARAM;
 
 s32 msmSysInit(MSM_INIT *init, MSM_ARAM *aram);
-void msmSysSetOutputMode(SND_OUTPUTMODE mode);
+s32 msmSysSetOutputMode(SND_OUTPUTMODE mode);
 s32 msmSysDelGroupAll(void);
 s32 msmSysLoadGroup(s32 grp, void *buf, BOOL flag);
 s32 msmSysGetSampSize(BOOL baseGrp);
diff --git a/include/msm/msmstream.h b/include/msm/msmstream.h
index c21347b0..d1818803 100644
--- a/include/msm/msmstream.h
+++ b/include/msm/msmstream.h
@@ -4,7 +4,7 @@
 #include "dolphin/types.h"
 
 void msmStreamPeriodicProc(void);
-void msmStreamSetOutputMode(s8);
+void msmStreamSetOutputMode(s32);
 void msmStreamAmemFree(void);
 s32 msmStreamAmemAlloc(void);
 s32 msmStreamInit(char *);
diff --git a/include/msm/msmsys.h b/include/msm/msmsys.h
index fbd36f7e..af06396f 100755
--- a/include/msm/msmsys.h
+++ b/include/msm/msmsys.h
@@ -1,47 +1,47 @@
 #ifndef MSMSYS_H
 #define MSMSYS_H
 
+#include "musyx/musyx.h"
+
 #include "dolphin.h"
 
+typedef struct {
+    u32 tempDisableFX;
+    f32 coloration;
+    f32 mix;
+    f32 time;
+    f32 damping;
+    f32 preDelay;
+    f32 crosstalk;
+} SubStructRev;
+
+typedef struct {
+    u32 baseDelay;
+    u32 variation;
+    u32 period;
+} SubStructCh;
+
+typedef struct {
+    u32 delay[3];
+    u32 feedback[3];
+    u32 output[3];
+} SubDelay;
+
 typedef struct _unkSubStruct {
     s8 unk0;
     union {
-        f32 unk4f[9];
-        s32 unk4s[9];
+        SubStructRev rev;
+        SubStructCh ch;
+        SubDelay delay;
     };
 } unkSubStruct;
 
-typedef struct _unkSubStruct2 {
-    char unk[0x3C];
-    s32 unk3C;
-    s32 unk40;
-    s32 unk44;
-    s32 unk48;
-    s32 unk4C;
-    s32 unk50;
-    s32 unk54;
-    s32 unk58;
-    s32 unk5C;
-    char unk60[0x30];
-    s32 unk90;
-    s32 unk94;
-    s32 unk98;
-    char unk9C[0xA0];
-    u8 unk13C;
-    f32 unk140;
-    f32 unk144;
-    f32 unk148;
-    f32 unk14C;
-    f32 unk150;
-    char unk154[0x70];
-    u8 unk1C4;
-    f32 unk1C8;
-    f32 unk1CC;
-    f32 unk1D0;
-    f32 unk1D4;
-    f32 unk1D8;
-    f32 unk1DC;
-} unkSubStruct2; // sizeof unk1E0
+typedef union {
+    SND_AUX_REVERBHI revHi;
+    SND_AUX_REVERBSTD revStd;
+    SND_AUX_CHORUS ch;
+    SND_AUX_DELAY delay;
+} UnkSndAuxUnion; // Size 0x1E0
 
 typedef struct _unkSubStruct3 {
     char unk[0x4];
@@ -51,7 +51,8 @@ typedef struct _unkSubStruct3 {
     u32 unk14; // length
     s32 unk18; // offset
     u32 unk1C; // length
-    char unk20[8];
+    s32 unk20;
+    s32 unk24;
     s32 unk28;
     s32 unk2C;
     s32 unk30;
@@ -61,7 +62,10 @@ typedef struct _unkSubStruct3 {
     s32 unk40;
     char unk44[4];
     s32 unk48;
-    char unk4C[0x14];
+    char unk4C[4];
+    s32 unk50;
+    s32 unk54;
+    char unk58[8];
 } unkSubStruct3; // sizeof 0x60
 
 typedef struct _unkStruct3 {
@@ -74,21 +78,44 @@ typedef struct _sndInitData {
     s8 unk0;
     s8 unk1;
     s8 unk2;
-    char unk3[1];
+    s8 unk3;
     s16 unk4;
     s16 unk6;
     s8 unk8;
-    char unk9[5];
+    s8 unk9;
+    s8 unkA;
+    s8 unkB;
+    char unkC[2];
     s8 unkE;
     s8 unkF;
     u32 unk10;
     s32 unk14;
-    char unk18[8];
+    s32 unk18;
+    s32 unk1C;
     s32 unk20;
-    char unk24[5];
+    char unk24[4];
+    s8 unk28;
     s8 unk29[10]; // size unknown
 } sndInitData;
 
+typedef struct {
+    /* 0x00 */ s8 unk00;
+    /* 0x01 */ s8 unk01;
+    /* 0x02 */ char unk02[2];
+    /* 0x04 */ u32 unk04;
+    /* 0x08 */ void *unk08;
+} UnkStructSys43C; // Size 0xC
+
+typedef struct _unkStruct4 {
+    SND_GROUPID unk0;
+    s8 unk2;
+    s32 unk4;
+    s32 unk8;
+    s32 unkC;
+    s32 unk10;
+    char unk14[0xC];
+} unkStruct4; // Size 0x20
+
 typedef struct _sysData {
     s32 unk0;
     s8 unk4;
@@ -99,20 +126,34 @@ typedef struct _sysData {
     unkSubStruct3 *unkC;
     sndInitData *unk10;
     unkSubStruct *unk14;
-    s8 unk18;
-    s8 unk19;
+    s8 unk18[2];
     s8 unk1A;
     s8 unk1B;
-    unkSubStruct2 unk1C; // userA
-    unkSubStruct2 unk1FC; // userB
-    char unk3DC[0x8];
-    s32 unk3E4;
-    s32 unk3E8;
-    s32 unk3EC;
-    s32 unk3F0;
+    UnkSndAuxUnion unk1C[2]; // 0: userA, 1: userB
+    s8 unk3DC;
+    char unk3DD[3];
+    s32 unk3E0;
+    u32 unk3E4;
+    u32 unk3E8;
+    unkStruct4 *unk3EC;
+    void *unk3F0;
     s8 unk3F4;
-    unkStruct3 *unk3F8;
-    char unk3FC[0xF0];
+    unkStruct3 *unk3F8[1]; // unknown array length
+    char unk3FC[0x38];
+    s8 unk434;
+    s8 unk435;
+    s8 unk436;
+    char unk437[1];
+    void *unk438;
+    UnkStructSys43C unk43C[1]; // unknown array length
+    char unk448[0x24];
+    s8 unk46C;
+    s8 unk46D;
+    s8 unk46E;
+    char unk46F[1];
+    void *unk470;
+    UnkStructSys43C unk474[1]; // unknown array length
+    char unk480[0x6C];
     s32 unk4EC;
     BOOL unk4F0;
     AIDCallback unk4F4;
diff --git a/src/msm/msmsys.c b/src/msm/msmsys.c
index b3165461..2df1b11b 100644
--- a/src/msm/msmsys.c
+++ b/src/msm/msmsys.c
@@ -4,31 +4,12 @@
 #include "msm/msmmus.h"
 #include "msm/msmse.h"
 #include "msm/msmstream.h"
-#include "musyx/musyx.h"
 
 #include "game/msm.h" // TODO remove, only for decomp
 
-typedef struct _unkStruct2 {
-    char *unk0;
-    s32 unk4;
-    void *unk8;
-    void *unkC;
-    void *unk10;
-    u32 unk14;
-    void *unk18;
-} unkStruct2;
-
-typedef struct _unkStruct4 {
-    SND_GROUPID unk0;
-    s32 unk4;
-    s32 unk8;
-    s32 unkC;
-    s32 unk10;
-} unkStruct4;
-
 static sysData sys;
 
-void msmSysServer(void)
+static void msmSysServer(void)
 {
     if (sndIsInstalled() == 1) {
         if (--sys.unk4F8 == 0) {
@@ -41,127 +22,190 @@ void msmSysServer(void)
     sys.unk4F4();
 }
 
-s32 msmSysSetAuxParam(s32 arg0, s32 arg1)
+static s32 msmSysSetAuxParam(s32 arg0, s32 arg1)
 {
-    SND_AUX_CALLBACK sp24;
-    SND_AUX_CALLBACK sp20;
-    void **var_r26;
-    s32 var_r23;
-    unkSubStruct2 *temp_r3;
-    sysData *var_r25;
-    sysData *var_r27;
-    unkSubStruct *temp_r5;
-    u32 var_r0;
-    u8 temp_r5_2;
+    s32 unused_1[2];
+    SND_AUX_CALLBACK sp20[2];
+    s32 unused_2[2];
     unkSubStruct *temp_r4_2;
+    UnkSndAuxUnion *temp_r3;
+    u32 var_r0;
+    s32 var_r23;
 
-    if ((sys.unk18 != -2) && (arg0 >= 0)) {
-        sys.unk18 = arg0;
+    if (sys.unk18[0] != -2 && arg0 >= 0) {
+        sys.unk18[0] = arg0;
     }
-    if ((sys.unk19 != -2) && (arg1 >= 0)) {
-        temp_r5->unk0 = arg1;
+    if (sys.unk18[1] != -2 && arg1 >= 0) {
+        sys.unk18[1] = arg1;
     }
-    if ((sys.unk18 < 0) && (temp_r5->unk0 < 0)) {
+    if (sys.unk18[0] < 0 && sys.unk18[1] < 0) {
         return 0;
     }
-    var_r27 = &sys;
-    var_r25 = &sys;
-    var_r26 = &sp20;
-
-    // the for loop first sets sp20 and then sp24
-    for (var_r23 = 0; var_r23 < 2; var_r23++, var_r27++, var_r26++, var_r25++) {
-        if (var_r27->unk18 < 0) {
-            *var_r26 = NULL;
+    for (var_r23 = 0; var_r23 < 2; var_r23++) {
+        if (sys.unk18[var_r23] < 0) {
+            sp20[var_r23] = NULL;
             continue;
         }
-        temp_r4_2 = &sys.unk14[var_r27->unk18];
-        temp_r3 = &var_r25->unk1C;
+        temp_r4_2 = &sys.unk14[sys.unk18[var_r23]];
+        temp_r3 = &sys.unk1C[var_r23];
         switch (temp_r4_2->unk0) {
             case 0:
-                *var_r26 = &sndAuxCallbackReverbHI;
-                temp_r3->unk1C4 = temp_r4_2->unk4s[0];
-                temp_r3->unk1C8 = temp_r4_2->unk4f[1];
-                temp_r3->unk1CC = temp_r4_2->unk4f[2];
-                temp_r3->unk1D0 = temp_r4_2->unk4f[3];
-                temp_r3->unk1D4 = temp_r4_2->unk4f[4];
-                temp_r3->unk1D8 = temp_r4_2->unk4f[5];
-                temp_r3->unk1DC = temp_r4_2->unk4f[6];
-                // var_r0 = sndAuxCallbackPrepareReverbHI();
+                sp20[var_r23] = sndAuxCallbackReverbHI;
+                temp_r3->revHi.tempDisableFX = temp_r4_2->rev.tempDisableFX;
+                temp_r3->revHi.coloration = temp_r4_2->rev.coloration;
+                temp_r3->revHi.mix = temp_r4_2->rev.mix;
+                temp_r3->revHi.time = temp_r4_2->rev.time;
+                temp_r3->revHi.damping = temp_r4_2->rev.damping;
+                temp_r3->revHi.preDelay = temp_r4_2->rev.preDelay;
+                temp_r3->revHi.crosstalk = temp_r4_2->rev.crosstalk;
+                var_r0 = sndAuxCallbackPrepareReverbHI(&temp_r3->revHi);
                 break;
             case 1:
-                *var_r26 = &sndAuxCallbackReverbSTD;
-                temp_r3->unk13C = temp_r4_2->unk4s[0];
-                temp_r3->unk140 = temp_r4_2->unk4f[1];
-                temp_r3->unk144 = temp_r4_2->unk4f[2];
-                temp_r3->unk148 = temp_r4_2->unk4f[3];
-                temp_r3->unk14C = temp_r4_2->unk4f[4];
-                temp_r3->unk150 = temp_r4_2->unk4f[5];
-                // var_r0 = sndAuxCallbackPrepareReverbSTD();
+                sp20[var_r23] = sndAuxCallbackReverbSTD;
+                temp_r3->revStd.tempDisableFX = temp_r4_2->rev.tempDisableFX;
+                temp_r3->revStd.coloration = temp_r4_2->rev.coloration;
+                temp_r3->revStd.mix = temp_r4_2->rev.mix;
+                temp_r3->revStd.time = temp_r4_2->rev.time;
+                temp_r3->revStd.damping = temp_r4_2->rev.damping;
+                temp_r3->revStd.preDelay = temp_r4_2->rev.preDelay;
+                var_r0 = sndAuxCallbackPrepareReverbSTD(&temp_r3->revStd);
                 break;
             case 2:
-                *var_r26 = &sndAuxCallbackChorus;
-                temp_r3->unk90 = temp_r4_2->unk4s[0];
-                temp_r3->unk94 = temp_r4_2->unk4s[1];
-                temp_r3->unk98 = temp_r4_2->unk4s[2];
-                // var_r0 = sndAuxCallbackPrepareChorus();
+                sp20[var_r23] = sndAuxCallbackChorus;
+                temp_r3->ch.baseDelay = temp_r4_2->ch.baseDelay;
+                temp_r3->ch.variation = temp_r4_2->ch.variation;
+                temp_r3->ch.period = temp_r4_2->ch.period;
+                var_r0 = sndAuxCallbackPrepareChorus(&temp_r3->ch);
                 break;
             case 3:
-                *var_r26 = &sndAuxCallbackDelay;
-                temp_r3->unk3C = temp_r4_2->unk4s[0];
-                temp_r3->unk48 = temp_r4_2->unk4s[3];
-                temp_r3->unk54 = temp_r4_2->unk4s[6];
-                temp_r3->unk40 = temp_r4_2->unk4s[1];
-                temp_r3->unk4C = temp_r4_2->unk4s[4];
-                temp_r3->unk58 = temp_r4_2->unk4s[7];
-                temp_r3->unk44 = temp_r4_2->unk4s[2];
-                temp_r3->unk50 = temp_r4_2->unk4s[5];
-                temp_r3->unk5C = temp_r4_2->unk4s[8];
-                // var_r0 = sndAuxCallbackPrepareDelay();
+                sp20[var_r23] = sndAuxCallbackDelay;
+                temp_r3->delay.delay[0] = temp_r4_2->delay.delay[0];
+                temp_r3->delay.feedback[0] = temp_r4_2->delay.feedback[0];
+                temp_r3->delay.output[0] = temp_r4_2->delay.output[0];
+                temp_r3->delay.delay[1] = temp_r4_2->delay.delay[1];
+                temp_r3->delay.feedback[1] = temp_r4_2->delay.feedback[1];
+                temp_r3->delay.output[1] = temp_r4_2->delay.output[1];
+                temp_r3->delay.delay[2] = temp_r4_2->delay.delay[2];
+                temp_r3->delay.feedback[2] = temp_r4_2->delay.feedback[2];
+                temp_r3->delay.output[2] = temp_r4_2->delay.output[2];
+                var_r0 = sndAuxCallbackPrepareDelay(&temp_r3->delay);
                 break;
         }
         if (var_r0 == 0) {
             return 1;
         }
     }
-    sndSetAuxProcessingCallbacks(0, sp20, &sys.unk1C, 0xFF, 0, sp24, &sys.unk1FC, 0xFF, 0);
+    sndSetAuxProcessingCallbacks(0, sp20[0], &sys.unk1C[0], 0xFF, 0, sp20[1], &sys.unk1C[1], 0xFF, 0);
     return 0;
 }
 
-s8 msmSysLoadBaseGroup(void *arg0)
+static s8 msmSysLoadBaseGroup(void *arg0)
 {
     DVDFileInfo spC;
-    sysData *var_r30;
     s32 var_r28;
     unkStruct3 *temp_r27;
     unkStruct4 *temp_r25;
 
     if (msmFioOpen(sys.unk0, &spC) != 1) {
-        return -1;
+        return MSM_ERR_OPENFAIL;
     }
-    var_r30 = &sys;
-    for (var_r28 = 0; var_r28 < sys.unk3F4; var_r30 = (sysData *)((s32)var_r30 + 4), var_r28++, sys.unk8 += temp_r25->unk10) {
-        temp_r27 = var_r30->unk3F8;
-        temp_r25 = (unkStruct4 *)(sys.unk3EC + (sys.unk10->unk29[var_r28] << 5));
+    for (var_r28 = 0; var_r28 < sys.unk3F4; var_r28++) {
+        temp_r27 = sys.unk3F8[var_r28];
+        temp_r25 = &sys.unk3EC[sys.unk10->unk29[var_r28]];
         if (msmFioRead(&spC, temp_r27, temp_r25->unk8, temp_r25->unk4 + sys.unkC->unk38) < 0) {
             msmFioClose(&spC);
-            return -2;
+            return MSM_ERR_READFAIL;
         }
         if (msmFioRead(&spC, arg0, temp_r25->unk10, temp_r25->unkC + sys.unkC->unk40) < 0) {
             msmFioClose(&spC);
-            return -2;
+            return MSM_ERR_READFAIL;
         }
-        if (sndPushGroup((void *)(temp_r27->unk4 + (s32)temp_r27), temp_r25->unk0, arg0, (void *)(temp_r27->unk8 + (s32)temp_r27),
-                (void *)(temp_r27->unk0 + (s32)temp_r27))
-            == 0U) {
+        if (!sndPushGroup((void*) (temp_r27->unk4 + (u32) temp_r27), temp_r25->unk0, arg0,
+            (void*) (temp_r27->unk8 + (u32) temp_r27), (void*) (temp_r27->unk0 + (u32) temp_r27)))
+        {
             msmFioClose(&spC);
-            return -0x20;
+            return MSM_ERR_20;
         }
+        sys.unk8 += temp_r25->unk10;
     }
     msmFioClose(&spC);
     return 0;
 }
 
-s32 msmSysGroupInit(DVDFileInfo *arg0);
+// TODO: https://decomp.me/scratch/NWiuL
+// msmSysSearchGroupStack
+
+s32 msmSysGroupInit(DVDFileInfo *arg0)
+{
+    s32 var_r7;
+    UnkStructSys43C *temp_43C;
+    unkStruct4 *temp_r20;
+
+    sys.unk3DC = sys.unk10->unk3;
+    sys.unk3E0 = 1;
+    sys.unk3F4 = sys.unk10->unk28;
+    sys.unk434 = sys.unk10->unk9;
+    sys.unk435 = 0;
+    sys.unk436 = 0;
+    sys.unk46C = sys.unk10->unkA;
+    sys.unk46D = 0;
+    sys.unk46E = 0;
+    if ((sys.unk3EC = msmMemAlloc(sys.unkC->unk24)) == NULL) {
+        return MSM_ERR_OUTOFMEM;
+    }
+    if (msmFioRead(arg0, sys.unk3EC, sys.unkC->unk24, sys.unkC->unk20) < 0) {
+        return MSM_ERR_READFAIL;
+    }
+    if ((sys.unk438 = msmMemAlloc(sys.unk10->unk18 * sys.unk434)) == NULL) {
+        return MSM_ERR_OUTOFMEM;
+    }
+    if ((sys.unk470 = msmMemAlloc(sys.unk10->unk1C * sys.unk46C)) == NULL) {
+        return MSM_ERR_OUTOFMEM;
+    }
+    if (sys.unkC->unk54) {
+        if ((sys.unk3F0 = msmMemAlloc(sys.unkC->unk54)) == NULL) {
+            return MSM_ERR_OUTOFMEM;
+        }
+        if (msmFioRead(arg0, sys.unk3F0, sys.unkC->unk54, sys.unkC->unk50) < 0) {
+            return MSM_ERR_READFAIL;
+        }
+    } else {
+        sys.unk3F0 = NULL;
+    }
+    for (var_r7 = 0; var_r7 < sys.unk434; var_r7++) {
+        temp_43C = &sys.unk43C[var_r7];
+        temp_43C->unk00 = temp_43C->unk01 = 0;
+        temp_43C->unk04 = 0;
+        temp_43C->unk08 = (void*) ((u32) sys.unk438 + sys.unk10->unk18 * var_r7);
+    }
+    for (var_r7 = 0; var_r7 < sys.unk46C; var_r7++) {
+        temp_43C = &sys.unk474[var_r7];
+        temp_43C->unk00 = temp_43C->unk01 = 0;
+        temp_43C->unk04 = 0;
+        temp_43C->unk08 = (void*) ((u32) sys.unk470 + sys.unk10->unk1C * var_r7);
+    }
+    sys.unk3E4 = 0;
+    for (var_r7 = 0; var_r7 < sys.unk3F4; var_r7++) {
+        temp_r20 = &sys.unk3EC[sys.unk10->unk29[var_r7]];
+        if ((sys.unk3F8[var_r7] = msmMemAlloc(temp_r20->unk8)) == NULL) {
+            return MSM_ERR_OUTOFMEM;
+        }
+        if (sys.unk3E4 < temp_r20->unk10) {
+            sys.unk3E4 = temp_r20->unk10;
+        }
+        temp_r20->unk10 *= -1;
+    }
+    sys.unk3E8 = 0;
+    for (var_r7 = 1; var_r7 < sys.unk3DC; var_r7++) {
+        temp_r20 = &sys.unk3EC[var_r7];
+        if (temp_r20->unk10 < 0) {
+            temp_r20->unk10 *= -1;
+        } else if (sys.unk3E8 < temp_r20->unk10) {
+            sys.unk3E8 = temp_r20->unk10;
+        }
+    }
+    return 0;
+}
 
 void msmSysIrqDisable(void)
 {
@@ -179,13 +223,138 @@ void msmSysIrqEnable(void)
     }
 }
 
-void msmSysRegularProc(void);
+BOOL msmSysCheckBaseGroup(s32 arg0)
+{
+    s32 var_r6;
+
+    for (var_r6 = 0; var_r6 < sys.unk3F4 + sys.unk436 + sys.unk46E; var_r6++) {
+        if (sys.unk3EC[sys.unk10->unk29[var_r6]].unk0 == arg0) {
+            return TRUE;
+        }
+    }
+    return FALSE;
+}
+
+void *msmSysGetGroupDataPtr(s32 arg0)
+{
+    UnkStructSys43C *temp_43C;
+    s32 var_r6;
+
+    for (var_r6 = 0; var_r6 < sys.unk3F4; var_r6++) {
+        if (sys.unk10->unk29[var_r6] == arg0) {
+            return sys.unk3F8[var_r6];
+        }
+    }
+    for (var_r6 = 0; var_r6 < sys.unk434; var_r6++) {
+        temp_43C = &sys.unk43C[var_r6];
+        if (temp_43C->unk04 != 0 && temp_43C->unk00 == arg0) {
+            return temp_43C->unk08;
+        }
+    }
+    for (var_r6 = 0; var_r6 < sys.unk46C; var_r6++) {
+        temp_43C = &sys.unk474[var_r6];
+        if (temp_43C->unk04 != 0 && temp_43C->unk00 == arg0) {
+            return temp_43C->unk08;
+        }
+    }
+    return NULL;
+}
+
+BOOL msmSysCheckLoadGroupID(s32 arg0)
+{
+    UnkStructSys43C *temp_43C;
+    s32 var_r6;
+
+    for (var_r6 = 0; var_r6 < sys.unk3F4 + sys.unk436 + sys.unk46E; var_r6++) {
+        if (sys.unk3EC[sys.unk10->unk29[var_r6]].unk0 == arg0) {
+            return TRUE;
+        }
+    }
+    for (var_r6 = 0; var_r6 < sys.unk434; var_r6++) {
+        temp_43C = &sys.unk43C[var_r6];
+        if (temp_43C->unk04 != 0 && sys.unk3EC[temp_43C->unk00].unk0 == arg0) {
+            return TRUE;
+        }
+    }
+    for (var_r6 = 0; var_r6 < sys.unk46C; var_r6++) {
+        temp_43C = &sys.unk474[var_r6];
+        if (temp_43C->unk04 != 0 && sys.unk3EC[temp_43C->unk00].unk0 == arg0) {
+            return TRUE;
+        }
+    }
+    return FALSE;
+}
+
+void msmSysRegularProc(void)
+{
+}
 
 s32 msmSysGetOutputMode(void)
 {
     return sys.unk4;
 }
 
+s32 msmSysSetOutputMode(SND_OUTPUTMODE mode)
+{
+    SND_OUTPUTMODE var_r3;
+    s32 var_r30;
+
+    var_r30 = 0;
+    sys.unk4 = mode;
+    switch (mode) {
+        case SND_OUTPUTMODE_MONO:
+            var_r3 = SND_OUTPUTMODE_MONO;
+            break;
+        case SND_OUTPUTMODE_SURROUND:
+            if (sys.unk10->unkB != 0) {
+                var_r3 = SND_OUTPUTMODE_SURROUND;
+            } else {
+                sys.unk4 = SND_OUTPUTMODE_STEREO;
+                var_r3 = SND_OUTPUTMODE_STEREO;
+                var_r30 = 1;
+            }
+            break;
+        case SND_OUTPUTMODE_STEREO:
+        default:
+            var_r3 = SND_OUTPUTMODE_STEREO;
+            break;
+    }
+    sndOutputMode(var_r3);
+    msmStreamSetOutputMode(sys.unk4);
+    OSSetSoundMode((mode != SND_OUTPUTMODE_MONO) ? 1 : 0);
+    return var_r30;
+}
+
+s32 msmSysSetAux(s32 arg0, s32 arg1)
+{
+    s32 var_r28;
+
+    sndSetAuxProcessingCallbacks(0, NULL, NULL, 0, 0, NULL, NULL, 0, 0);
+    for (var_r28 = 1; var_r28 >= 0; var_r28--) {
+        if (sys.unk18[var_r28] < 0) {
+            continue;
+        }
+        switch (sys.unk14[sys.unk18[var_r28]].unk0) {
+            case 0:
+                sndAuxCallbackShutdownReverbHI(&sys.unk1C[var_r28].revHi);
+                break;
+            case 1:
+                sndAuxCallbackShutdownReverbSTD(&sys.unk1C[var_r28].revStd);
+                break;
+            case 2:
+                sndAuxCallbackShutdownChorus(&sys.unk1C[var_r28].ch);
+                break;
+            case 3:
+                sndAuxCallbackShutdownDelay(&sys.unk1C[var_r28].delay);
+                break;
+            }
+    }
+    if (msmSysSetAuxParam(arg0, arg1) != 0) {
+        return MSM_ERR_INVALID_AUXPARAM;
+    }
+    return 0;
+}
+
 s32 msmSysGetSampSize(BOOL baseGrp)
 {
     if (baseGrp != 0) {
@@ -194,6 +363,118 @@ s32 msmSysGetSampSize(BOOL baseGrp)
     return sys.unk3E4;
 }
 
+s32 msmSysDelGroupAll(void)
+{
+    UnkStructSys43C *temp_r28;
+    s32 var_r29;
+
+    for (var_r29 = 0; var_r29 < sys.unk46C; var_r29++) {
+        temp_r28 = &sys.unk474[var_r29];
+        if (temp_r28->unk04 != 0 && temp_r28->unk01 == 0) {
+            temp_r28->unk04 = 0;
+            sndPopGroup();
+            sys.unk8 -= sys.unk3EC[temp_r28->unk00].unk10;
+            sys.unk46D--;
+        }
+    }
+    for (var_r29 = 0; var_r29 < sys.unk434; var_r29++) {
+        temp_r28 = &sys.unk43C[var_r29];
+        if (temp_r28->unk04 != 0 && temp_r28->unk01 == 0) {
+            temp_r28->unk04 = 0;
+            sndPopGroup();
+            sys.unk8 -= sys.unk3EC[temp_r28->unk00].unk10;
+            sys.unk435--;
+        }
+    }
+    return 0;
+}
+
+s32 msmSysDelGroupBase(s32 grpNum)
+{
+    s32 var_r4;
+    UnkStructSys43C *temp_r26;
+    s32 var_r27;
+    s8 var_r31;
+    s8 var_r25;
+    s32 var_r6;
+
+    if (sys.unk436 + sys.unk46E == 0) {
+        return 0;
+    }
+    if (grpNum >= sys.unk436 + sys.unk46E) {
+        grpNum = 0;
+    }
+    if (grpNum != 0) {
+        msmSysDelGroupAll();
+        for (var_r27 = 0; var_r27 < grpNum; var_r27++) {
+            var_r6 = 0;
+            for (var_r4 = 0; var_r4 < sys.unk434; var_r4++) {
+                temp_r26 = &sys.unk43C[var_r4];
+                if (temp_r26->unk04 > var_r6) {
+                    var_r6 = temp_r26->unk04;
+                    var_r31 = var_r4;
+                    var_r25 = 0;
+                }
+            }
+            for (var_r4 = 0; var_r4 < sys.unk46C; var_r4++) {
+                temp_r26 = &sys.unk474[var_r4];
+                if (temp_r26->unk04 > var_r6) {
+                    var_r6 = temp_r26->unk04;
+                    var_r31 = var_r4;
+                    var_r25 = 1;
+                }
+            }
+            if (var_r25 == 0) {
+                temp_r26 = &sys.unk43C[var_r31];
+                sys.unk435--;
+                sys.unk436--;
+            } else {
+                temp_r26 = &sys.unk474[var_r31];
+                sys.unk46D--;
+                sys.unk46E--;
+            }
+            sndPopGroup();
+            sys.unk8 -= sys.unk3EC[temp_r26->unk00].unk10;
+            temp_r26->unk01 = 0;
+            temp_r26->unk04 = 0;
+        }
+    } else {
+        for (var_r27 = 0; var_r27 < sys.unk434; var_r27++) {
+            temp_r26 = &sys.unk43C[var_r27];
+            if (temp_r26->unk04 != 0) {
+                sndPopGroup();
+                sys.unk8 -= sys.unk3EC[temp_r26->unk00].unk10;
+                temp_r26->unk01 = 0;
+                temp_r26->unk04 = 0;
+            }
+        }
+        for (var_r27 = 0; var_r27 < sys.unk46C; var_r27++) {
+            temp_r26 = &sys.unk474[var_r27];
+            if (temp_r26->unk04 != 0) {
+                sndPopGroup();
+                sys.unk8 -= sys.unk3EC[temp_r26->unk00].unk10;
+                temp_r26->unk01 = 0;
+                temp_r26->unk04 = 0;
+            }
+        }
+        sys.unk46E = 0;
+        sys.unk46D = 0;
+        sys.unk436 = 0;
+        sys.unk435 = 0;
+    }
+    return 0;
+}
+
+// TODO: https://decomp.me/scratch/zexTY
+// msmSysLoadGroupBase
+
+// msmSysLoadGroupSet
+
+// msmSysLoadGroupSub
+
+// TODO: https://decomp.me/scratch/AhvXa
+// msmSysLoadGroup
+
 void msmSysCheckInit(void)
 {
     sndIsInstalled();
@@ -202,13 +483,12 @@ void msmSysCheckInit(void)
 s32 msmSysInit(MSM_INIT *init, MSM_ARAM *aram)
 {
     s32 var_r26;
-    s32 temp_r3;
     void *temp_r3_8;
 
     SND_HOOKS sp4C = { msmMemAlloc, msmMemFree };
     DVDFileInfo sp10;
     if (sndIsInstalled() == 1) {
-        return -0x24;
+        return MSM_ERR_INSTALLED;
     }
     var_r26 = 0; // retErr
     sys.unk4EC = 0;
@@ -216,30 +496,30 @@ s32 msmSysInit(MSM_INIT *init, MSM_ARAM *aram)
     msmFioInit(init->open, init->read, init->close);
     sys.unk0 = DVDConvertPathToEntrynum(init->msmPath);
     if (sys.unk0 < 0) {
-        return -1;
+        return MSM_ERR_OPENFAIL;
     }
     if (msmFioOpen(sys.unk0, &sp10) != 1) {
-        return -1;
+        return MSM_ERR_OPENFAIL;
     }
     if ((sys.unkC = msmMemAlloc(0x60)) == NULL) {
         msmFioClose(&sp10);
-        return -0xA;
+        return MSM_ERR_OUTOFMEM;
     }
     if (msmFioRead(&sp10, sys.unkC, 0x60, 0) < 0) {
         msmFioClose(&sp10);
-        return -2;
+        return MSM_ERR_READFAIL;
     }
     if (sys.unkC->unk4 != 2) {
         msmFioClose(&sp10);
-        return -0x79;
+        return MSM_ERR_INVALIDFILE;
     }
     if ((sys.unk10 = msmMemAlloc(sys.unkC->unk14)) == NULL) {
         msmFioClose(&sp10);
-        return -0xA;
+        return MSM_ERR_OUTOFMEM;
     }
     if (msmFioRead(&sp10, sys.unk10, sys.unkC->unk14, sys.unkC->unk10) < 0) {
         msmFioClose(&sp10);
-        return -2;
+        return MSM_ERR_READFAIL;
     }
     if (aram != NULL) {
         if (aram->skipARInit == 0) {
@@ -248,14 +528,14 @@ s32 msmSysInit(MSM_INIT *init, MSM_ARAM *aram)
             aram = (MSM_ARAM *)ARAlloc(sys.unk10->unk14);
             if ((u32)aram != ARGetBaseAddress()) {
                 msmFioClose(&sp10);
-                return -0x14;
+                return MSM_ERR_OUTOFAMEM;
             }
             sys.unk7 = 0;
         }
         else {
             if ((sys.unk10->unk14 + ARGetBaseAddress()) > aram->aramEnd) {
                 msmFioClose(&sp10);
-                return -0x14;
+                return MSM_ERR_OUTOFAMEM;
             }
             ARInit(NULL, 0);
             ARQInit();
@@ -277,18 +557,18 @@ s32 msmSysInit(MSM_INIT *init, MSM_ARAM *aram)
         msmFioClose(&sp10);
         return var_r26;
     }
-    sys.unk18 = sys.unk10->unkE == -2 ? -2 : -1;
-    sys.unk19 = sys.unk10->unkF == -2 ? -2 : -1;
+    sys.unk18[0] = sys.unk10->unkE == -2 ? -2 : -1;
+    sys.unk18[1] = sys.unk10->unkF == -2 ? -2 : -1;
     if ((s32)sys.unkC->unk1C == 0) {
         var_r26 = 0;
     }
     else {
         if ((sys.unk14 = msmMemAlloc(sys.unkC->unk1C)) == NULL) {
-            var_r26 = -0xA;
+            var_r26 = MSM_ERR_OUTOFMEM;
         }
         else {
             if (msmFioRead(&sp10, sys.unk14, sys.unkC->unk1C, sys.unkC->unk18) < 0) {
-                var_r26 = -2;
+                var_r26 = MSM_ERR_READFAIL;
             }
             else {
                 var_r26 = 0;
@@ -300,14 +580,14 @@ s32 msmSysInit(MSM_INIT *init, MSM_ARAM *aram)
         return var_r26;
     }
     msmFioClose(&sp10);
-    temp_r3 = msmStreamInit(init->pdtPath);
-    if (temp_r3 < 0) {
-        return temp_r3;
+    var_r26 = msmStreamInit(init->pdtPath);
+    if (var_r26 < 0) {
+        return var_r26;
     }
     AIInit(NULL);
     sndSetHooks(&sp4C);
     if (sndInit(sys.unk10->unk0, sys.unk10->unk1, sys.unk10->unk2, 1, 0, sys.unk10->unk14) != 0) {
-        return -0x1E;
+        return MSM_ERR_1E;
     }
     sys.unk4F4 = AIRegisterDMACallback(msmSysServer);
     sys.unk4F8 = 1;
@@ -322,14 +602,14 @@ s32 msmSysInit(MSM_INIT *init, MSM_ARAM *aram)
         if (temp_r3_8 == NULL) {
             msmStreamAmemFree();
             sndQuit();
-            return -0xA;
+            return MSM_ERR_OUTOFMEM;
         }
         msmMemFree(temp_r3_8);
     }
     if (msmSysSetAuxParam(sys.unk10->unkE, sys.unk10->unkF) != 0) {
         msmStreamAmemFree();
         sndQuit();
-        return -0x1F;
+        return MSM_ERR_INVALID_AUXPARAM;
     }
     msmSysSetOutputMode(OSGetSoundMode() == 0 ? SND_OUTPUTMODE_MONO : SND_OUTPUTMODE_STEREO);
     sndVolume(0x7F, 0, 0xFF);