kobayashi90/marioparty4
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Matched most of msmsys (5 functions left) (#528)

Browse source
This commit is contained in:
mrshigure 2025-01-13 20:07:10 -08:00 • committed by GitHub
parent f812abd06f
commit 6284cb6116
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
4 changed files with 491 additions and 168 deletions
Download patch file Download diff file Expand all files Collapse all files

4
include/game/msm.h
View file

@ -40,7 +40,9 @@
#define MSM_ERR_OUTOFMEM -10 #define MSM_ERR_OUTOFMEM -10
#define MSM_ERR_OUTOFAMEM -20 #define MSM_ERR_OUTOFAMEM -20
#define MSM_ERR_INITFAIL -20 #define MSM_ERR_INITFAIL -20
#define MSM_ERR_1E -30
#define MSM_ERR_INVALID_AUXPARAM -31 #define MSM_ERR_INVALID_AUXPARAM -31
#define MSM_ERR_20 -32
#define MSM_ERR_PLAYFAIL -33 #define MSM_ERR_PLAYFAIL -33
#define MSM_ERR_22 -34 #define MSM_ERR_22 -34
#define MSM_ERR_STREAMALLOC_FAIL -35 #define MSM_ERR_STREAMALLOC_FAIL -35
@ -166,7 +168,7 @@ typedef struct msmStreamParam_s {
} MSM_STREAMPARAM; } MSM_STREAMPARAM;
s32 msmSysInit(MSM_INIT *init, MSM_ARAM *aram); s32 msmSysInit(MSM_INIT *init, MSM_ARAM *aram);
void msmSysSetOutputMode(SND_OUTPUTMODE mode); s32 msmSysSetOutputMode(SND_OUTPUTMODE mode);
s32 msmSysDelGroupAll(void); s32 msmSysDelGroupAll(void);
s32 msmSysLoadGroup(s32 grp, void *buf, BOOL flag); s32 msmSysLoadGroup(s32 grp, void *buf, BOOL flag);
s32 msmSysGetSampSize(BOOL baseGrp); s32 msmSysGetSampSize(BOOL baseGrp);

2
include/msm/msmstream.h
View file

@ -4,7 +4,7 @@
#include "dolphin/types.h" #include "dolphin/types.h"
void msmStreamPeriodicProc(void); void msmStreamPeriodicProc(void);
void msmStreamSetOutputMode(s8); void msmStreamSetOutputMode(s32);
void msmStreamAmemFree(void); void msmStreamAmemFree(void);
s32 msmStreamAmemAlloc(void); s32 msmStreamAmemAlloc(void);
s32 msmStreamInit(char *); s32 msmStreamInit(char *);

141
include/msm/msmsys.h
View file

@ -1,47 +1,47 @@
#ifndef MSMSYS_H #ifndef MSMSYS_H
#define MSMSYS_H #define MSMSYS_H
#include "musyx/musyx.h"
#include "dolphin.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 { typedef struct _unkSubStruct {
s8 unk0; s8 unk0;
union { union {
f32 unk4f[9]; SubStructRev rev;
s32 unk4s[9]; SubStructCh ch;
SubDelay delay;
}; };
} unkSubStruct; } unkSubStruct;
typedef struct _unkSubStruct2 { typedef union {
char unk[0x3C]; SND_AUX_REVERBHI revHi;
s32 unk3C; SND_AUX_REVERBSTD revStd;
s32 unk40; SND_AUX_CHORUS ch;
s32 unk44; SND_AUX_DELAY delay;
s32 unk48; } UnkSndAuxUnion; // Size 0x1E0
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 struct _unkSubStruct3 { typedef struct _unkSubStruct3 {
char unk[0x4]; char unk[0x4];
@ -51,7 +51,8 @@ typedef struct _unkSubStruct3 {
u32 unk14; // length u32 unk14; // length
s32 unk18; // offset s32 unk18; // offset
u32 unk1C; // length u32 unk1C; // length
char unk20[8]; s32 unk20;
s32 unk24;
s32 unk28; s32 unk28;
s32 unk2C; s32 unk2C;
s32 unk30; s32 unk30;
@ -61,7 +62,10 @@ typedef struct _unkSubStruct3 {
s32 unk40; s32 unk40;
char unk44[4]; char unk44[4];
s32 unk48; s32 unk48;
char unk4C[0x14]; char unk4C[4];
s32 unk50;
s32 unk54;
char unk58[8];
} unkSubStruct3; // sizeof 0x60 } unkSubStruct3; // sizeof 0x60
typedef struct _unkStruct3 { typedef struct _unkStruct3 {
@ -74,21 +78,44 @@ typedef struct _sndInitData {
s8 unk0; s8 unk0;
s8 unk1; s8 unk1;
s8 unk2; s8 unk2;
char unk3[1]; s8 unk3;
s16 unk4; s16 unk4;
s16 unk6; s16 unk6;
s8 unk8; s8 unk8;
char unk9[5]; s8 unk9;
s8 unkA;
s8 unkB;
char unkC[2];
s8 unkE; s8 unkE;
s8 unkF; s8 unkF;
u32 unk10; u32 unk10;
s32 unk14; s32 unk14;
char unk18[8]; s32 unk18;
s32 unk1C;
s32 unk20; s32 unk20;
char unk24[5]; char unk24[4];
s8 unk28;
s8 unk29[10]; // size unknown s8 unk29[10]; // size unknown
} sndInitData; } 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 { typedef struct _sysData {
s32 unk0; s32 unk0;
s8 unk4; s8 unk4;
@ -99,20 +126,34 @@ typedef struct _sysData {
unkSubStruct3 *unkC; unkSubStruct3 *unkC;
sndInitData *unk10; sndInitData *unk10;
unkSubStruct *unk14; unkSubStruct *unk14;
s8 unk18; s8 unk18[2];
s8 unk19;
s8 unk1A; s8 unk1A;
s8 unk1B; s8 unk1B;
unkSubStruct2 unk1C; // userA UnkSndAuxUnion unk1C[2]; // 0: userA, 1: userB
unkSubStruct2 unk1FC; // userB s8 unk3DC;
char unk3DC[0x8]; char unk3DD[3];
s32 unk3E4; s32 unk3E0;
s32 unk3E8; u32 unk3E4;
s32 unk3EC; u32 unk3E8;
s32 unk3F0; unkStruct4 *unk3EC;
void *unk3F0;
s8 unk3F4; s8 unk3F4;
unkStruct3 *unk3F8; unkStruct3 *unk3F8[1]; // unknown array length
char unk3FC[0xF0]; 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; s32 unk4EC;
BOOL unk4F0; BOOL unk4F0;
AIDCallback unk4F4; AIDCallback unk4F4;

512
src/msm/msmsys.c
View file

@ -4,31 +4,12 @@
#include "msm/msmmus.h" #include "msm/msmmus.h"
#include "msm/msmse.h" #include "msm/msmse.h"
#include "msm/msmstream.h" #include "msm/msmstream.h"
#include "musyx/musyx.h"
#include "game/msm.h" // TODO remove, only for decomp #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; static sysData sys;
void msmSysServer(void) static void msmSysServer(void)
{ {
if (sndIsInstalled() == 1) { if (sndIsInstalled() == 1) {
if (--sys.unk4F8 == 0) { if (--sys.unk4F8 == 0) {
@ -41,127 +22,190 @@ void msmSysServer(void)
sys.unk4F4(); sys.unk4F4();
} }
s32 msmSysSetAuxParam(s32 arg0, s32 arg1) static s32 msmSysSetAuxParam(s32 arg0, s32 arg1)
{ {
SND_AUX_CALLBACK sp24; s32 unused_1[2];
SND_AUX_CALLBACK sp20; SND_AUX_CALLBACK sp20[2];
void **var_r26; s32 unused_2[2];
s32 var_r23;
unkSubStruct2 *temp_r3;
sysData *var_r25;
sysData *var_r27;
unkSubStruct *temp_r5;
u32 var_r0;
u8 temp_r5_2;
unkSubStruct *temp_r4_2; unkSubStruct *temp_r4_2;
UnkSndAuxUnion *temp_r3;
u32 var_r0;
s32 var_r23;
if ((sys.unk18 != -2) && (arg0 >= 0)) { if (sys.unk18[0] != -2 && arg0 >= 0) {
sys.unk18 = arg0; sys.unk18[0] = arg0;
} }
if ((sys.unk19 != -2) && (arg1 >= 0)) { if (sys.unk18[1] != -2 && arg1 >= 0) {
temp_r5->unk0 = arg1; sys.unk18[1] = arg1;
} }
if ((sys.unk18 < 0) && (temp_r5->unk0 < 0)) { if (sys.unk18[0] < 0 && sys.unk18[1] < 0) {
return 0; return 0;
} }
var_r27 = &sys; for (var_r23 = 0; var_r23 < 2; var_r23++) {
var_r25 = &sys; if (sys.unk18[var_r23] < 0) {
var_r26 = &sp20; sp20[var_r23] = NULL;
// 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;
continue; continue;
} }
temp_r4_2 = &sys.unk14[var_r27->unk18]; temp_r4_2 = &sys.unk14[sys.unk18[var_r23]];
temp_r3 = &var_r25->unk1C; temp_r3 = &sys.unk1C[var_r23];
switch (temp_r4_2->unk0) { switch (temp_r4_2->unk0) {
case 0: case 0:
*var_r26 = &sndAuxCallbackReverbHI; sp20[var_r23] = sndAuxCallbackReverbHI;
temp_r3->unk1C4 = temp_r4_2->unk4s[0]; temp_r3->revHi.tempDisableFX = temp_r4_2->rev.tempDisableFX;
temp_r3->unk1C8 = temp_r4_2->unk4f[1]; temp_r3->revHi.coloration = temp_r4_2->rev.coloration;
temp_r3->unk1CC = temp_r4_2->unk4f[2]; temp_r3->revHi.mix = temp_r4_2->rev.mix;
temp_r3->unk1D0 = temp_r4_2->unk4f[3]; temp_r3->revHi.time = temp_r4_2->rev.time;
temp_r3->unk1D4 = temp_r4_2->unk4f[4]; temp_r3->revHi.damping = temp_r4_2->rev.damping;
temp_r3->unk1D8 = temp_r4_2->unk4f[5]; temp_r3->revHi.preDelay = temp_r4_2->rev.preDelay;
temp_r3->unk1DC = temp_r4_2->unk4f[6]; temp_r3->revHi.crosstalk = temp_r4_2->rev.crosstalk;
// var_r0 = sndAuxCallbackPrepareReverbHI(); var_r0 = sndAuxCallbackPrepareReverbHI(&temp_r3->revHi);
break; break;
case 1: case 1:
*var_r26 = &sndAuxCallbackReverbSTD; sp20[var_r23] = sndAuxCallbackReverbSTD;
temp_r3->unk13C = temp_r4_2->unk4s[0]; temp_r3->revStd.tempDisableFX = temp_r4_2->rev.tempDisableFX;
temp_r3->unk140 = temp_r4_2->unk4f[1]; temp_r3->revStd.coloration = temp_r4_2->rev.coloration;
temp_r3->unk144 = temp_r4_2->unk4f[2]; temp_r3->revStd.mix = temp_r4_2->rev.mix;
temp_r3->unk148 = temp_r4_2->unk4f[3]; temp_r3->revStd.time = temp_r4_2->rev.time;
temp_r3->unk14C = temp_r4_2->unk4f[4]; temp_r3->revStd.damping = temp_r4_2->rev.damping;
temp_r3->unk150 = temp_r4_2->unk4f[5]; temp_r3->revStd.preDelay = temp_r4_2->rev.preDelay;
// var_r0 = sndAuxCallbackPrepareReverbSTD(); var_r0 = sndAuxCallbackPrepareReverbSTD(&temp_r3->revStd);
break; break;
case 2: case 2:
*var_r26 = &sndAuxCallbackChorus; sp20[var_r23] = sndAuxCallbackChorus;
temp_r3->unk90 = temp_r4_2->unk4s[0]; temp_r3->ch.baseDelay = temp_r4_2->ch.baseDelay;
temp_r3->unk94 = temp_r4_2->unk4s[1]; temp_r3->ch.variation = temp_r4_2->ch.variation;
temp_r3->unk98 = temp_r4_2->unk4s[2]; temp_r3->ch.period = temp_r4_2->ch.period;
// var_r0 = sndAuxCallbackPrepareChorus(); var_r0 = sndAuxCallbackPrepareChorus(&temp_r3->ch);
break; break;
case 3: case 3:
*var_r26 = &sndAuxCallbackDelay; sp20[var_r23] = sndAuxCallbackDelay;
temp_r3->unk3C = temp_r4_2->unk4s[0]; temp_r3->delay.delay[0] = temp_r4_2->delay.delay[0];
temp_r3->unk48 = temp_r4_2->unk4s[3]; temp_r3->delay.feedback[0] = temp_r4_2->delay.feedback[0];
temp_r3->unk54 = temp_r4_2->unk4s[6]; temp_r3->delay.output[0] = temp_r4_2->delay.output[0];
temp_r3->unk40 = temp_r4_2->unk4s[1]; temp_r3->delay.delay[1] = temp_r4_2->delay.delay[1];
temp_r3->unk4C = temp_r4_2->unk4s[4]; temp_r3->delay.feedback[1] = temp_r4_2->delay.feedback[1];
temp_r3->unk58 = temp_r4_2->unk4s[7]; temp_r3->delay.output[1] = temp_r4_2->delay.output[1];
temp_r3->unk44 = temp_r4_2->unk4s[2]; temp_r3->delay.delay[2] = temp_r4_2->delay.delay[2];
temp_r3->unk50 = temp_r4_2->unk4s[5]; temp_r3->delay.feedback[2] = temp_r4_2->delay.feedback[2];
temp_r3->unk5C = temp_r4_2->unk4s[8]; temp_r3->delay.output[2] = temp_r4_2->delay.output[2];
// var_r0 = sndAuxCallbackPrepareDelay(); var_r0 = sndAuxCallbackPrepareDelay(&temp_r3->delay);
break; break;
} }
if (var_r0 == 0) { if (var_r0 == 0) {
return 1; 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; return 0;
} }
s8 msmSysLoadBaseGroup(void *arg0) static s8 msmSysLoadBaseGroup(void *arg0)
{ {
DVDFileInfo spC; DVDFileInfo spC;
sysData *var_r30;
s32 var_r28; s32 var_r28;
unkStruct3 *temp_r27; unkStruct3 *temp_r27;
unkStruct4 *temp_r25; unkStruct4 *temp_r25;
if (msmFioOpen(sys.unk0, &spC) != 1) { if (msmFioOpen(sys.unk0, &spC) != 1) {
return -1; return MSM_ERR_OPENFAIL;
} }
var_r30 = &sys; for (var_r28 = 0; var_r28 < sys.unk3F4; var_r28++) {
for (var_r28 = 0; var_r28 < sys.unk3F4; var_r30 = (sysData *)((s32)var_r30 + 4), var_r28++, sys.unk8 += temp_r25->unk10) { temp_r27 = sys.unk3F8[var_r28];
temp_r27 = var_r30->unk3F8; temp_r25 = &sys.unk3EC[sys.unk10->unk29[var_r28]];
temp_r25 = (unkStruct4 *)(sys.unk3EC + (sys.unk10->unk29[var_r28] << 5));
if (msmFioRead(&spC, temp_r27, temp_r25->unk8, temp_r25->unk4 + sys.unkC->unk38) < 0) { if (msmFioRead(&spC, temp_r27, temp_r25->unk8, temp_r25->unk4 + sys.unkC->unk38) < 0) {
msmFioClose(&spC); msmFioClose(&spC);
return -2; return MSM_ERR_READFAIL;
} }
if (msmFioRead(&spC, arg0, temp_r25->unk10, temp_r25->unkC + sys.unkC->unk40) < 0) { if (msmFioRead(&spC, arg0, temp_r25->unk10, temp_r25->unkC + sys.unkC->unk40) < 0) {
msmFioClose(&spC); 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), if (!sndPushGroup((void*) (temp_r27->unk4 + (u32) temp_r27), temp_r25->unk0, arg0,
(void *)(temp_r27->unk0 + (s32)temp_r27)) (void*) (temp_r27->unk8 + (u32) temp_r27), (void*) (temp_r27->unk0 + (u32) temp_r27)))
== 0U) { {
msmFioClose(&spC); msmFioClose(&spC);
return -0x20; return MSM_ERR_20;
} }
sys.unk8 += temp_r25->unk10;
} }
msmFioClose(&spC); msmFioClose(&spC);
return 0; 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) 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) s32 msmSysGetOutputMode(void)
{ {
return sys.unk4; 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) s32 msmSysGetSampSize(BOOL baseGrp)
{ {
if (baseGrp != 0) { if (baseGrp != 0) {
@ -194,6 +363,118 @@ s32 msmSysGetSampSize(BOOL baseGrp)
return sys.unk3E4; 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) void msmSysCheckInit(void)
{ {
sndIsInstalled(); sndIsInstalled();
@ -202,13 +483,12 @@ void msmSysCheckInit(void)
s32 msmSysInit(MSM_INIT *init, MSM_ARAM *aram) s32 msmSysInit(MSM_INIT *init, MSM_ARAM *aram)
{ {
s32 var_r26; s32 var_r26;
s32 temp_r3;
void *temp_r3_8; void *temp_r3_8;
SND_HOOKS sp4C = { msmMemAlloc, msmMemFree }; SND_HOOKS sp4C = { msmMemAlloc, msmMemFree };
DVDFileInfo sp10; DVDFileInfo sp10;
if (sndIsInstalled() == 1) { if (sndIsInstalled() == 1) {
return -0x24; return MSM_ERR_INSTALLED;
} }
var_r26 = 0; // retErr var_r26 = 0; // retErr
sys.unk4EC = 0; sys.unk4EC = 0;
@ -216,30 +496,30 @@ s32 msmSysInit(MSM_INIT *init, MSM_ARAM *aram)
msmFioInit(init->open, init->read, init->close); msmFioInit(init->open, init->read, init->close);
sys.unk0 = DVDConvertPathToEntrynum(init->msmPath); sys.unk0 = DVDConvertPathToEntrynum(init->msmPath);
if (sys.unk0 < 0) { if (sys.unk0 < 0) {
return -1; return MSM_ERR_OPENFAIL;
} }
if (msmFioOpen(sys.unk0, &sp10) != 1) { if (msmFioOpen(sys.unk0, &sp10) != 1) {
return -1; return MSM_ERR_OPENFAIL;
} }
if ((sys.unkC = msmMemAlloc(0x60)) == NULL) { if ((sys.unkC = msmMemAlloc(0x60)) == NULL) {
msmFioClose(&sp10); msmFioClose(&sp10);
return -0xA; return MSM_ERR_OUTOFMEM;
} }
if (msmFioRead(&sp10, sys.unkC, 0x60, 0) < 0) { if (msmFioRead(&sp10, sys.unkC, 0x60, 0) < 0) {
msmFioClose(&sp10); msmFioClose(&sp10);
return -2; return MSM_ERR_READFAIL;
} }
if (sys.unkC->unk4 != 2) { if (sys.unkC->unk4 != 2) {
msmFioClose(&sp10); msmFioClose(&sp10);
return -0x79; return MSM_ERR_INVALIDFILE;
} }
if ((sys.unk10 = msmMemAlloc(sys.unkC->unk14)) == NULL) { if ((sys.unk10 = msmMemAlloc(sys.unkC->unk14)) == NULL) {
msmFioClose(&sp10); msmFioClose(&sp10);
return -0xA; return MSM_ERR_OUTOFMEM;
} }
if (msmFioRead(&sp10, sys.unk10, sys.unkC->unk14, sys.unkC->unk10) < 0) { if (msmFioRead(&sp10, sys.unk10, sys.unkC->unk14, sys.unkC->unk10) < 0) {
msmFioClose(&sp10); msmFioClose(&sp10);
return -2; return MSM_ERR_READFAIL;
} }
if (aram != NULL) { if (aram != NULL) {
if (aram->skipARInit == 0) { if (aram->skipARInit == 0) {
@ -248,14 +528,14 @@ s32 msmSysInit(MSM_INIT *init, MSM_ARAM *aram)
aram = (MSM_ARAM *)ARAlloc(sys.unk10->unk14); aram = (MSM_ARAM *)ARAlloc(sys.unk10->unk14);
if ((u32)aram != ARGetBaseAddress()) { if ((u32)aram != ARGetBaseAddress()) {
msmFioClose(&sp10); msmFioClose(&sp10);
return -0x14; return MSM_ERR_OUTOFAMEM;
} }
sys.unk7 = 0; sys.unk7 = 0;
} }
else { else {
if ((sys.unk10->unk14 + ARGetBaseAddress()) > aram->aramEnd) { if ((sys.unk10->unk14 + ARGetBaseAddress()) > aram->aramEnd) {
msmFioClose(&sp10); msmFioClose(&sp10);
return -0x14; return MSM_ERR_OUTOFAMEM;
} }
ARInit(NULL, 0); ARInit(NULL, 0);
ARQInit(); ARQInit();
@ -277,18 +557,18 @@ s32 msmSysInit(MSM_INIT *init, MSM_ARAM *aram)
msmFioClose(&sp10); msmFioClose(&sp10);
return var_r26; return var_r26;
} }
sys.unk18 = sys.unk10->unkE == -2 ? -2 : -1; sys.unk18[0] = sys.unk10->unkE == -2 ? -2 : -1;
sys.unk19 = sys.unk10->unkF == -2 ? -2 : -1; sys.unk18[1] = sys.unk10->unkF == -2 ? -2 : -1;
if ((s32)sys.unkC->unk1C == 0) { if ((s32)sys.unkC->unk1C == 0) {
var_r26 = 0; var_r26 = 0;
} }
else { else {
if ((sys.unk14 = msmMemAlloc(sys.unkC->unk1C)) == NULL) { if ((sys.unk14 = msmMemAlloc(sys.unkC->unk1C)) == NULL) {
var_r26 = -0xA; var_r26 = MSM_ERR_OUTOFMEM;
} }
else { else {
if (msmFioRead(&sp10, sys.unk14, sys.unkC->unk1C, sys.unkC->unk18) < 0) { if (msmFioRead(&sp10, sys.unk14, sys.unkC->unk1C, sys.unkC->unk18) < 0) {
var_r26 = -2; var_r26 = MSM_ERR_READFAIL;
} }
else { else {
var_r26 = 0; var_r26 = 0;
@ -300,14 +580,14 @@ s32 msmSysInit(MSM_INIT *init, MSM_ARAM *aram)
return var_r26; return var_r26;
} }
msmFioClose(&sp10); msmFioClose(&sp10);
temp_r3 = msmStreamInit(init->pdtPath); var_r26 = msmStreamInit(init->pdtPath);
if (temp_r3 < 0) { if (var_r26 < 0) {
return temp_r3; return var_r26;
} }
AIInit(NULL); AIInit(NULL);
sndSetHooks(&sp4C); sndSetHooks(&sp4C);
if (sndInit(sys.unk10->unk0, sys.unk10->unk1, sys.unk10->unk2, 1, 0, sys.unk10->unk14) != 0) { 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.unk4F4 = AIRegisterDMACallback(msmSysServer);
sys.unk4F8 = 1; sys.unk4F8 = 1;
@ -322,14 +602,14 @@ s32 msmSysInit(MSM_INIT *init, MSM_ARAM *aram)
if (temp_r3_8 == NULL) { if (temp_r3_8 == NULL) {
msmStreamAmemFree(); msmStreamAmemFree();
sndQuit(); sndQuit();
return -0xA; return MSM_ERR_OUTOFMEM;
} }
msmMemFree(temp_r3_8); msmMemFree(temp_r3_8);
} }
if (msmSysSetAuxParam(sys.unk10->unkE, sys.unk10->unkF) != 0) { if (msmSysSetAuxParam(sys.unk10->unkE, sys.unk10->unkF) != 0) {
msmStreamAmemFree(); msmStreamAmemFree();
sndQuit(); sndQuit();
return -0x1F; return MSM_ERR_INVALID_AUXPARAM;
} }
msmSysSetOutputMode(OSGetSoundMode() == 0 ? SND_OUTPUTMODE_MONO : SND_OUTPUTMODE_STEREO); msmSysSetOutputMode(OSGetSoundMode() == 0 ? SND_OUTPUTMODE_MONO : SND_OUTPUTMODE_STEREO);
sndVolume(0x7F, 0, 0xFF); sndVolume(0x7F, 0, 0xFF);