diff --git a/config/GMPE01_00/symbols.txt b/config/GMPE01_00/symbols.txt index 3e84f320..1417c27e 100644 --- a/config/GMPE01_00/symbols.txt +++ b/config/GMPE01_00/symbols.txt @@ -3568,15 +3568,15 @@ msmStreamSetOutputMode = .text:0x8011A61C; // type:function size:0x114 msmStreamAmemFree = .text:0x8011A730; // type:function size:0x68 msmStreamAmemAlloc = .text:0x8011A798; // type:function size:0x10C msmStreamInit = .text:0x8011A8A4; // type:function size:0x2A8 -msmStreamPauseOff = .text:0x8011AB4C; // type:function size:0x2B8 -msmStreamPauseOn = .text:0x8011AE04; // type:function size:0x1AC +msmStreamPauseOff = .text:0x8011AB4C; // type:function size:0x2B8 scope:local +msmStreamPauseOn = .text:0x8011AE04; // type:function size:0x1AC scope:local msmStreamPauseFade = .text:0x8011AFB0; // type:function size:0x2E8 scope:local msmStreamFade = .text:0x8011B298; // type:function size:0x33C scope:local msmStreamStopSub = .text:0x8011B5D4; // type:function size:0x13C scope:local msmStreamSetParamSub = .text:0x8011B710; // type:function size:0xE0 scope:local -msmStreamPackStartStereo = .text:0x8011B7F0; // type:function size:0x448 -msmStreamPackStartMono = .text:0x8011BC38; // type:function size:0x2DC -msmStreamSlotOff = .text:0x8011BF14; // type:function size:0xD0 +msmStreamPackStartStereo = .text:0x8011B7F0; // type:function size:0x448 scope:local +msmStreamPackStartMono = .text:0x8011BC38; // type:function size:0x2DC scope:local +msmStreamSlotOff = .text:0x8011BF14; // type:function size:0xD0 scope:local msmStreamData = .text:0x8011BFE4; // type:function size:0x320 scope:local msmStreamDvdCallback = .text:0x8011C304; // type:function size:0x4A8 scope:local msmStreamDvdCallback2 = .text:0x8011C7AC; // type:function size:0x188 scope:local diff --git a/config/GMPE01_01/symbols.txt b/config/GMPE01_01/symbols.txt index ef9eff80..5bed188a 100644 --- a/config/GMPE01_01/symbols.txt +++ b/config/GMPE01_01/symbols.txt @@ -3568,15 +3568,15 @@ msmStreamSetOutputMode = .text:0x8011A61C; // type:function size:0x114 msmStreamAmemFree = .text:0x8011A730; // type:function size:0x68 msmStreamAmemAlloc = .text:0x8011A798; // type:function size:0x10C msmStreamInit = .text:0x8011A8A4; // type:function size:0x2A8 -msmStreamPauseOff = .text:0x8011AB4C; // type:function size:0x2B8 -msmStreamPauseOn = .text:0x8011AE04; // type:function size:0x1AC -msmStreamPauseFade = .text:0x8011AFB0; // type:function size:0x2E8 -msmStreamFade = .text:0x8011B298; // type:function size:0x33C +msmStreamPauseOff = .text:0x8011AB4C; // type:function size:0x2B8 scope:local +msmStreamPauseOn = .text:0x8011AE04; // type:function size:0x1AC scope:local +msmStreamPauseFade = .text:0x8011AFB0; // type:function size:0x2E8 scope:local +msmStreamFade = .text:0x8011B298; // type:function size:0x33C scope:local msmStreamStopSub = .text:0x8011B5D4; // type:function size:0x13C scope:local msmStreamSetParamSub = .text:0x8011B710; // type:function size:0xE0 scope:local -msmStreamPackStartStereo = .text:0x8011B7F0; // type:function size:0x448 -msmStreamPackStartMono = .text:0x8011BC38; // type:function size:0x2DC -msmStreamSlotOff = .text:0x8011BF14; // type:function size:0xD0 +msmStreamPackStartStereo = .text:0x8011B7F0; // type:function size:0x448 scope:local +msmStreamPackStartMono = .text:0x8011BC38; // type:function size:0x2DC scope:local +msmStreamSlotOff = .text:0x8011BF14; // type:function size:0xD0 scope:local msmStreamData = .text:0x8011BFE4; // type:function size:0x320 scope:local msmStreamDvdCallback = .text:0x8011C304; // type:function size:0x4A8 scope:local msmStreamDvdCallback2 = .text:0x8011C7AC; // type:function size:0x188 scope:local diff --git a/include/game/msm.h b/include/game/msm.h index e7ae2ae2..e5106677 100644 --- a/include/game/msm.h +++ b/include/game/msm.h @@ -3,6 +3,7 @@ #include "dolphin.h" #include "musyx/musyx.h" +#include "game/msm_data.h" #define MSM_SEPARAM_NONE 0 #define MSM_SEPARAM_VOL (1 << 0) @@ -40,25 +41,24 @@ #define MSM_ERR_READFAIL -2 #define MSM_ERR_OUTOFMEM -10 #define MSM_ERR_OUTOFAMEM -20 -#define MSM_ERR_INITFAIL -20 -#define MSM_ERR_1E -30 +#define MSM_ERR_INITFAIL -30 #define MSM_ERR_INVALID_AUXPARAM -31 -#define MSM_ERR_20 -32 +#define MSM_ERR_GRP_FAILPUSH -32 #define MSM_ERR_PLAYFAIL -33 -#define MSM_ERR_22 -34 +#define MSM_LISTENER_NO_UPDATA -34 #define MSM_ERR_STREAMALLOC_FAIL -35 #define MSM_ERR_INSTALLED -36 #define MSM_ERR_64 -100 -#define MSM_ERR_65 -101 +#define MSM_ERR_STACK_OVERFLOW -101 #define MSM_ERR_GRP_NOTLOADED -103 -#define MSM_ERR_6E -110 -#define MSM_ERR_6F -111 +#define MSM_ERR_CHANLIMIT -110 +#define MSM_ERR_INVALIDSE -111 #define MSM_ERR_INVALIDID -120 #define MSM_ERR_INVALIDFILE -121 #define MSM_ERR_REMOVEDID -122 #define MSM_ERR_MUSGRP_NOTLOADED -123 #define MSM_ERR_OUTOFMUS -130 -#define MSM_ERR_8C -140 +#define MSM_ERR_RANGE_STREAM -140 #define MSM_VOL_MAX 127 #define MSM_PAN_LEFT 32 @@ -132,19 +132,6 @@ typedef struct msmSeParam_s { Vec pos; } MSM_SEPARAM; -typedef struct msmSe_s { - u16 groupId; - u16 fxId; - s8 vol; - s8 pan; - s16 pitchBend; - u8 span; - u8 reverb; - u8 chorus; - s8 doppler; - s8 comp; - u8 pad[3]; -} MSMSE; typedef struct msmSeListener_s { s32 flag; @@ -173,10 +160,11 @@ typedef struct msmStreamParam_s { } MSM_STREAMPARAM; s32 msmSysInit(MSM_INIT *init, MSM_ARAM *aram); -s32 msmSysSetOutputMode(SND_OUTPUTMODE mode); +BOOL msmSysSetOutputMode(SND_OUTPUTMODE mode); s32 msmSysDelGroupAll(void); s32 msmSysGetSampSize(BOOL baseGrp); s32 msmSysDelGroupBase(s32 grpNum); +s32 msmSysSetAux(s32 auxA, s32 auxB); s32 msmSeSetParam(int seNo, MSM_SEPARAM *param); int msmSePlay(int seId, MSM_SEPARAM *param); @@ -190,6 +178,8 @@ void msmSeDelListener(void); s32 msmSeGetStatus(int seNo); s32 msmSeGetNumPlay(BOOL baseGrp); s32 msmSeGetEntryID(s32 seId, int *seNo); +void msmSeSetMasterVolume(s32 vol); +MSM_SE* msmSeGetIndexPtr(s32 seId); int msmMusPlay(int musId, MSM_MUSPARAM *musParam); s32 msmMusStop(int musNo, s32 speed); @@ -199,6 +189,8 @@ s32 msmMusGetMidiCtrl(int musNo, s32 channel, s32 ctrl); void msmMusStopAll(BOOL checkGrp, s32 speed); s32 msmMusGetStatus(int musNo); s32 msmMusGetNumPlay(BOOL baseGrp); +s32 msmMusSetParam(s32 musNo, MSM_MUSPARAM *param); +void msmMusSetMasterVolume(s32 vol); int msmStreamPlay(int streamId, MSM_STREAMPARAM *streamParam); s32 msmStreamStop(int streamNo, s32 speed); @@ -207,5 +199,7 @@ s32 msmStreamPause(int streamNo, BOOL pause, s32 speed); void msmStreamStopAll(s32 speed); s32 msmStreamGetStatus(int streamNo); +void msmStreamSetMasterVolume(s32 arg0); +void msmStreamSetOutputMode(s32 outputMode); #endif diff --git a/include/game/msm_data.h b/include/game/msm_data.h new file mode 100644 index 00000000..0c282ffb --- /dev/null +++ b/include/game/msm_data.h @@ -0,0 +1,185 @@ +#ifndef _MSM_DATA_H +#define _MSM_DATA_H + +#include "dolphin.h" +#include "musyx/musyx.h" + +#define MSM_STREAM_FLAG_STEREO 0x1 +#define MSM_STREAM_FLAG_LOOP 0x2 + +#define MSM_FILE_VERSION 2 +#define MSM_PDT_FILE_VERSION 1 + +typedef struct MSMHeader_s { + s32 magic; + s32 version; + s32 endOfs; + s32 endSize; + s32 infoOfs; + u32 infoSize; + s32 auxParamOfs; + u32 auxParamSize; + s32 grpInfoOfs; + s32 grpInfoSize; + s32 musOfs; + s32 musSize; + s32 seOfs; + s32 seSize; + s32 grpDataOfs; + s32 grpDataSize; + s32 sampOfs; + s32 sampSize; + s32 dummyMusOfs; + s32 dummyMusSize; + s32 grpSetOfs; + s32 grpSetSize; + s32 pad[2]; +} MSM_HEADER; // sizeof 0x60 + +typedef struct MSMInfo_s { + s8 voices; + s8 music; + s8 sfx; + s8 grpMax; + s16 musMax; + s16 seMax; + s8 musChanMax; + s8 stackDepthA; + s8 stackDepthB; + s8 surroundF; + s8 unkC[2]; + s8 auxParamA; + s8 auxParamB; + s32 minMem; + s32 aramSize; + s32 grpBufSizeA; + s32 grpBufSizeB; + s32 dummyMusSize; + s32 unk24; + s8 baseGrpNum; + s8 baseGrp[23]; +} MSM_INFO; + +typedef struct { + u32 tempDisableFX; + f32 coloration; + f32 mix; + f32 time; + f32 damping; + f32 preDelay; + f32 crosstalk; +} MSM_AUXPARAM_REVERBHI; + +typedef struct { + u32 tempDisableFX; + f32 coloration; + f32 mix; + f32 time; + f32 damping; + f32 preDelay; + f32 crosstalk; +} MSM_AUXPARAM_REVERBSTD; + +typedef struct { + u32 baseDelay; + u32 variation; + u32 period; +} MSM_AUXPARAM_CHORUS; + +typedef struct { + u32 delay[3]; + u32 feedback[3]; + u32 output[3]; +} MSM_AUXPARAM_DELAY; + +typedef struct MSMAuxParam_s { + s8 type; + u8 pad[3]; + union { + MSM_AUXPARAM_REVERBHI revHi; + MSM_AUXPARAM_REVERBSTD revStd; + MSM_AUXPARAM_CHORUS chorus; + MSM_AUXPARAM_DELAY delay; + }; +} MSM_AUXPARAM; + +typedef struct MSMSe_s { + SND_GROUPID gid; + SND_FXID fxId; + s8 vol; + s8 pan; + s16 pitchBend; + u8 span; + u8 reverb; + u8 chorus; + s8 emitterF; + s8 emiComp; + u8 pad[3]; +} MSM_SE; + +typedef struct MSMMus_s { + SND_GROUPID sgid; + SND_SONGID sid; + s32 songOfs; + s32 songSize; + s8 songGrp; + s8 vol; + u8 pad[2]; +} MSM_MUS; // Size 0x10 + +typedef struct MSMGrpHead_s { + s32 poolOfs; + s32 projOfs; + s32 sdirOfs; + s32 sngOfs; +} MSM_GRP_HEAD; + +typedef struct MSMGrpInfo_s { + SND_GROUPID gid; + s8 stackNo; + s8 subGrpId; + s32 dataOfs; + s32 dataSize; + s32 sampOfs; + s32 sampSize; + u8 pad[12]; +} MSM_GRP_INFO; + +typedef struct MSMGrpSet_s { + s8 numGrpSet; + s8 grpSetW; + s8 data[1]; +} MSM_GRP_SET; + +typedef struct MSMStreamHeader_s { + s16 version; + s16 streamMax; + s32 chanMax; + s32 sampleFrq; + s32 maxBufs; + u32 streamPackListOfs; + u32 adpcmParamOfs; + u32 streamPackOfs; + u32 sampleOfs; +} MSM_STREAM_HEADER; + +typedef struct MSMStream_s { + s32 sampleOfs; + s16 adpcmParamIdx; + u16 pad; +} MSM_STREAM; + +typedef struct MSMStreamPack_s { + s8 flag; + s8 vol; + s8 pan; + s8 span; + s8 auxA; + s8 auxB; + u16 frq; + u32 loopOfsEnd; + u32 loopOfsStart; + MSM_STREAM stream[2]; +} MSM_STREAM_PACK; // Size unknown + +#endif diff --git a/include/msm/msmmem.h b/include/msm/msmmem.h index 1acc500a..30d73f75 100644 --- a/include/msm/msmmem.h +++ b/include/msm/msmmem.h @@ -3,8 +3,8 @@ #include "dolphin/types.h" -void msmMemFree(void *); -void *msmMemAlloc(u32); -void msmMemInit(void *, u32); +void msmMemFree(void *ptr); +void *msmMemAlloc(u32 sze); +void msmMemInit(void *ptr, u32 size); #endif diff --git a/include/msm/msmmus.h b/include/msm/msmmus.h index 6428b067..586af22c 100644 --- a/include/msm/msmmus.h +++ b/include/msm/msmmus.h @@ -16,6 +16,6 @@ s32 msmMusPause(int musNo, BOOL pause, s32 speed); void msmMusStopAll(BOOL checkGrp, s32 speed); s32 msmMusStop(int musNo, s32 speed); int msmMusPlay(int musId, MSM_MUSPARAM* musParam); -s32 msmMusInit(sysData* arg0, DVDFileInfo* arg1); +s32 msmMusInit(MSM_SYS* arg0, DVDFileInfo* arg1); #endif diff --git a/include/msm/msmse.h b/include/msm/msmse.h index feb1e462..b765a771 100644 --- a/include/msm/msmse.h +++ b/include/msm/msmse.h @@ -5,7 +5,7 @@ #include "msm/msmsys.h" void msmSePeriodicProc(void); -MSMSE* msmSeGetIndexPtr(s32 arg0); +MSM_SE* msmSeGetIndexPtr(s32 arg0); void msmSeDelListener(void); s32 msmSeUpdataListener(Vec* pos, Vec* heading); s32 msmSeSetListener(Vec* pos, Vec* heading, float sndDist, float sndSpeed, MSM_SELISTENER* listener); @@ -18,6 +18,6 @@ void msmSePauseAll(BOOL pause, s32 speed); void msmSeStopAll(BOOL checkGrp, s32 speed); s32 msmSeStop(int seNo, s32 speed); int msmSePlay(int seId, MSM_SEPARAM* param); -s32 msmSeInit(sysData* arg0, DVDFileInfo* arg1); +s32 msmSeInit(MSM_SYS* arg0, DVDFileInfo* arg1); #endif diff --git a/include/msm/msmstream.h b/include/msm/msmstream.h index fb1bd9cd..b86fcaad 100644 --- a/include/msm/msmstream.h +++ b/include/msm/msmstream.h @@ -13,10 +13,6 @@ void msmStreamSetOutputMode(s32 arg0); void msmStreamAmemFree(void); s32 msmStreamAmemAlloc(void); s32 msmStreamInit(char* arg0); -void msmStreamPauseOff(s32 arg0); -void msmStreamPauseOn(s32 streamNo, s32 arg1); -s32 msmStreamPackStartStereo(s32 arg0, MSM_STREAMPARAM* arg1, s32 arg2); -s32 msmStreamPackStartMono(s32 arg0, MSM_STREAMPARAM* arg1, s32 arg2); -void msmStreamSlotOff(s32 streamNo); + #endif diff --git a/include/msm/msmsys.h b/include/msm/msmsys.h index 3ed5e134..6a55a4c6 100755 --- a/include/msm/msmsys.h +++ b/include/msm/msmsys.h @@ -5,167 +5,63 @@ #include "dolphin.h" -typedef struct { - u32 tempDisableFX; - f32 coloration; - f32 mix; - f32 time; - f32 damping; - f32 preDelay; - f32 crosstalk; -} SubStructRev; +#define MSM_AUX_REVERBHI 0 +#define MSM_AUX_REVERBSTD 1 +#define MSM_AUX_CHORUS 2 +#define MSM_AUX_DELAY 3 -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 { - SubStructRev rev; - SubStructCh ch; - SubDelay delay; - }; -} unkSubStruct; +#define MSM_AUXNO_NULL -2 +#define MSM_AUXNO_UNSET -1 typedef union { SND_AUX_REVERBHI revHi; SND_AUX_REVERBSTD revStd; - SND_AUX_CHORUS ch; + SND_AUX_CHORUS chorus; SND_AUX_DELAY delay; -} UnkSndAuxUnion; // Size 0x1E0 +} MSM_AUX; // Size 0x1E0 -typedef struct _unkSubStruct3 { - char unk[0x4]; - s32 unk4; - char unk8[0x8]; - s32 unk10; // offset - u32 unk14; // length - s32 unk18; // offset - u32 unk1C; // length - s32 unk20; - s32 unk24; - s32 unk28; - s32 unk2C; - s32 unk30; - s32 unk34; - s32 unk38; - char unk3C[4]; - s32 unk40; - char unk44[4]; - s32 unk48; - char unk4C[4]; - s32 unk50; - s32 unk54; - char unk58[8]; -} unkSubStruct3; // sizeof 0x60 +typedef struct MSMGrpWork_s { + s8 grpId; + s8 baseGrpF; + u32 num; + void *buf; +} MSM_GRP_STACK; -typedef struct _unkStruct3 { - s32 unk0; - s32 unk4; - s32 unk8; -} unkStruct3; - -typedef struct _sndInitData { - s8 unk0; - s8 unk1; - s8 unk2; - s8 unk3; - s16 unk4; - s16 unk6; - s8 unk8; - s8 unk9; - s8 unkA; - s8 unkB; - char unkC[2]; - s8 unkE; - s8 unkF; - u32 unk10; - s32 unk14; - s32 unk18; - s32 unk1C; - s32 unk20; - 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; - s8 unk3; - s32 unk4; - s32 unk8; - s32 unkC; - s32 unk10; - char unk14[0xC]; -} unkStruct4; // Size 0x20 - -typedef struct { - /* 0x00 */ s8 unk00; - /* 0x01 */ s8 unk01; - /* 0x02 */ s8 unk02[1]; // unknown array length -} UnkSys3F0Struct; // Size unknown - -typedef struct _sysData { - s32 unk0; - s8 unk4; +typedef struct MSMSys_s { + s32 msmEntryNum; + s8 outputMode; s8 unk5; s8 unk6; - s8 unk7; - s32 unk8; - unkSubStruct3 *unkC; - sndInitData *unk10; - unkSubStruct *unk14; - s8 unk18[2]; - s8 unk1A; - s8 unk1B; - UnkSndAuxUnion unk1C[2]; // 0: userA, 1: userB - s8 unk3DC; - char unk3DD[3]; - s32 unk3E0; - u32 unk3E4; - u32 unk3E8; - unkStruct4 *unk3EC; - UnkSys3F0Struct *unk3F0; - s8 unk3F4; - unkStruct3 *unk3F8[1]; // unknown array length - char unk3FC[0x38]; - s8 unk434; - u8 unk435; - s8 unk436; - char unk437[1]; - void *unk438; - UnkStructSys43C unk43C[1]; // unknown array length - char unk448[0x24]; - s8 unk46C; - u8 unk46D; - s8 unk46E; - char unk46F[1]; - void *unk470; - UnkStructSys43C unk474[1]; // unknown array length - char unk480[0x6C]; - s32 unk4EC; - BOOL unk4F0; - AIDCallback unk4F4; - s32 unk4F8; -} sysData; + s8 arInitF; + s32 aramP; + MSM_HEADER *header; + MSM_INFO *info; + MSM_AUXPARAM *auxParam; + s8 auxParamNo[2]; + MSM_AUX aux[2]; // 0: userA, 1: userB + s8 grpMax; + s32 grpNum; + u32 sampSize; + u32 sampSizeBase; + MSM_GRP_INFO *grpInfo; + MSM_GRP_SET *grpSet; + s8 baseGrpNum; + MSM_GRP_HEAD *grpData[15]; + s8 grpStackAMax; + u8 grpStackADepth; + s8 grpStackAOfs; + void *grpBufA; + MSM_GRP_STACK grpStackA[4]; + s8 grpStackBMax; + u8 grpStackBDepth; + s8 grpStackBOfs; + void *grpBufB; + MSM_GRP_STACK grpStackB[10]; + s32 irqDepth; + BOOL irqState; + AIDCallback oldAIDCallback; + s32 timer; +} MSM_SYS; s32 msmSysSearchGroupStack(s32 arg0, s32 arg1); s32 msmSysGroupInit(DVDFileInfo *arg0); @@ -176,8 +72,7 @@ void *msmSysGetGroupDataPtr(s32 arg0); BOOL msmSysCheckLoadGroupID(s32 arg0); void msmSysRegularProc(void); s32 msmSysGetOutputMode(void); -s32 msmSysSetOutputMode(SND_OUTPUTMODE mode); -s32 msmSysSetAux(s32 arg0, s32 arg1); +BOOL msmSysSetOutputMode(SND_OUTPUTMODE mode); s32 msmSysGetSampSize(BOOL baseGrp); s32 msmSysDelGroupAll(void); s32 msmSysDelGroupBase(s32 grpNum); diff --git a/src/msm/msmmem.c b/src/msm/msmmem.c index cbe6e2be..1a587589 100644 --- a/src/msm/msmmem.c +++ b/src/msm/msmmem.c @@ -1,133 +1,132 @@ #include "msm/msmmem.h" -typedef struct _unkStruct { - struct _unkStruct* prev; - struct _unkStruct* next; - u32 unk8; - u32 unkC; - void* unk10; - void* unk14; - char unk18[0x8]; -} unkStruct; +typedef struct MSMBlock_s { + struct MSMBlock_s* prev; + struct MSMBlock_s* next; + u32 freeSize; + u32 size; + void* ptr; + char pad[12]; +} MSMBLOCK; -typedef struct _unkMemStruct { - unkStruct* unk0; - u32 unk4; - unkStruct* unk8; - unkStruct unkC; -} unkMemStruct; +typedef struct MSMMem_s { + void *ptr; + u32 size; + MSMBLOCK *head; + MSMBLOCK first; +} MSM_MEM; -static unkMemStruct mem; +static MSM_MEM mem; -void msmMemFree(void* arg0) { - unkStruct* temp_r6; - unkStruct* temp_r7; - unkStruct* temp_r8; - unkStruct* temp_r5; - unkStruct* temp; +void msmMemFree(void* ptr) { + MSMBLOCK* block; + MSMBLOCK* blockPrev; + MSMBLOCK* blockNext; + MSMBLOCK* blockHead; + MSMBLOCK* base; - temp = arg0; + base = ptr; - temp_r6 = &temp[-1]; - temp_r7 = temp_r6->prev; - temp_r8 = temp_r6->next; - if (mem.unk0 > temp_r6 || ((u32)mem.unk0 + (u32)mem.unk4) <= (u32)temp_r6) { + block = &base[-1]; + blockPrev = block->prev; + blockNext = block->next; + if (mem.ptr > block || ((u32)mem.ptr + (u32)mem.size) <= (u32)block) { return; } - if ((temp_r7->next != temp_r6) || (temp_r6->unk10 != arg0) || (temp_r8 && (temp_r8->prev != temp_r6))) { + if ((blockPrev->next != block) || (block->ptr != ptr) || (blockNext && (blockNext->prev != block))) { return; } - temp_r7->unkC += temp_r6->unk8 + temp_r6->unkC; - temp_r7->next = temp_r8; - temp_r5 = mem.unk8; - if ((temp_r5 == temp_r6) || (temp_r5->unkC < temp_r7->unkC)) { - mem.unk8 = temp_r7; + blockPrev->size += block->freeSize + block->size; + blockPrev->next = blockNext; + blockHead = mem.head; + if ((blockHead == block) || (blockHead->size < blockPrev->size)) { + mem.head = blockPrev; } - if (temp_r8) { - temp_r8->prev = temp_r7; - if (mem.unk8->unkC < temp_r8->unkC) { - mem.unk8 = temp_r8; + if (blockNext) { + blockNext->prev = blockPrev; + if (mem.head->size < blockNext->size) { + mem.head = blockNext; } } } -void* msmMemAlloc(u32 arg0) { - s32 temp_r0; - u32 var_r5; - u32 var_r7; - unkStruct* temp_r5; - unkStruct* var_r8; - unkStruct* temp_r9; +void* msmMemAlloc(u32 size) { + s32 alignOfs; + u32 freeSize; + u32 allocSize; + MSMBLOCK* block; + MSMBLOCK* blockPrev; + MSMBLOCK* blockNext; - var_r7 = arg0 + 0x20; - temp_r0 = var_r7 & 0x1F; - if (temp_r0 != 0) { - var_r7 += 0x20 - temp_r0; + allocSize = size + 0x20; + alignOfs = allocSize & 0x1F; + if (alignOfs) { + allocSize += 0x20 - alignOfs; } - if (mem.unk8->unkC >= var_r7) { - var_r8 = mem.unk8; + if (mem.head->size >= allocSize) { + blockPrev = mem.head; } else { - var_r8 = &mem.unkC; + blockPrev = &mem.first; do { - if (var_r8->unkC >= var_r7) break; - var_r8 = var_r8->next; - } while (var_r8); - if (!var_r8) { + if (blockPrev->size >= allocSize) break; + blockPrev = blockPrev->next; + } while (blockPrev); + if (!blockPrev) { return NULL; } } - var_r5 = var_r8->unk8; - if (var_r5 != 0) { - var_r5 -= 0x20; + freeSize = blockPrev->freeSize; + if (freeSize != 0) { + freeSize -= 0x20; } - temp_r5 = (void*)((u32)var_r8->unk10 + (var_r5)); - temp_r9 = var_r8->next; - if ((mem.unk0 > temp_r5) || ((void*)((u32)mem.unk0 + (u32)mem.unk4) <= temp_r5)) { + block = (void*)((u32)blockPrev->ptr + (freeSize)); + blockNext = blockPrev->next; + if ((mem.ptr > block) || ((void*)((u32)mem.ptr + (u32)mem.size) <= block)) { return NULL; } - temp_r5->unk8 = var_r7; - temp_r5->unkC = var_r8->unkC - var_r7; - temp_r5->unk10 = (temp_r5 + 1); - temp_r5->prev = var_r8; - temp_r5->next = temp_r9; - mem.unk8 = temp_r5; - var_r8->unkC = 0; - var_r8->next = temp_r5; - if (temp_r9) { - temp_r9->prev = temp_r5; - if (mem.unk8->unkC < temp_r9->unkC) { - mem.unk8 = temp_r9; + block->freeSize = allocSize; + block->size = blockPrev->size - allocSize; + block->ptr = (block + 1); + block->prev = blockPrev; + block->next = blockNext; + mem.head = block; + blockPrev->size = 0; + blockPrev->next = block; + if (blockNext) { + blockNext->prev = block; + if (mem.head->size < blockNext->size) { + mem.head = blockNext; } } - return temp_r5->unk10; + return block->ptr; } -void msmMemInit(void* arg0, u32 arg1) { - unkStruct* temp_r7; - s32 temp; +void msmMemInit(void* ptr, u32 size) { + MSMBLOCK* block; + s32 ofs; - temp = (s32)arg0 & 0x1F; - switch (temp) { + ofs = (s32)ptr & 0x1F; + switch (ofs) { default: - temp = 0x20 - temp; + ofs = 0x20 - ofs; break; case 0: - temp = 0; + ofs = 0; break; } - mem.unk0 = (void*)((s32)arg0 + temp); - temp = (s32)arg0 + arg1; - mem.unk4 = ((temp - (s32)mem.unk0) & ~0x1F); - temp_r7 = &mem.unkC; - temp_r7->unk8 = 0; - temp_r7->unkC = mem.unk4; - temp_r7->unk10 = mem.unk0; - temp_r7->prev = NULL; - temp_r7->next = NULL; - mem.unk8 = &mem.unkC; + mem.ptr = (void*)((s32)ptr + ofs); + ofs = (s32)ptr + size; + mem.size = ((ofs - (s32)mem.ptr) & ~0x1F); + block = &mem.first; + block->freeSize = 0; + block->size = mem.size; + block->ptr = mem.ptr; + block->prev = NULL; + block->next = NULL; + mem.head = &mem.first; } diff --git a/src/msm/msmmus.c b/src/msm/msmmus.c index 3b70662d..061da27a 100755 --- a/src/msm/msmmus.c +++ b/src/msm/msmmus.c @@ -1,150 +1,127 @@ #include "msm/msmmus.h" #include "msm/msmmem.h" -typedef struct { - /* 0x00 */ s16 unk00; - /* 0x02 */ s8 unk02; - /* 0x03 */ s8 unk03; - /* 0x04 */ s8 unk04; - /* 0x05 */ s8 unk05; - /* 0x06 */ char unk06[2]; - /* 0x08 */ SND_SEQID unk08; - /* 0x0C */ void* unk0C; - /* 0x10 */ void* unk10; - /* 0x14 */ volatile s32 unk14; - /* 0x18 */ s32 unk18; - /* 0x1C */ s8 unk1C; - /* 0x1D */ char unk1D[3]; - /* 0x20 */ volatile s32 unk20; - /* 0x24 */ s32 unk24; - /* 0x28 */ s8 unk28; - /* 0x29 */ char unk29[3]; - /* 0x2C */ volatile s32 unk2C; - /* 0x30 */ s32 unk30; - /* 0x34 */ char unk34[1]; - /* 0x35 */ volatile s8 unk35; - /* 0x36 */ s8 unk36; - /* 0x37 */ char unk37[1]; - /* 0x38 */ SND_PLAYPARA unk38; -} msmMusStruct00; // Size 0x58 +typedef struct MusPlayer_s { + /* 0x00 */ s16 musId; + /* 0x02 */ s8 baseVol; + /* 0x03 */ s8 vol; + /* 0x04 */ s8 status; + /* 0x05 */ s8 busyF; + /* 0x08 */ SND_SEQID seqId; + /* 0x0C */ void* songBuf; + /* 0x10 */ void* arrfile; + /* 0x14 */ volatile s32 fadeMaxTime; + /* 0x18 */ s32 fadeTime; + /* 0x1C */ s8 fadeVol; + /* 0x20 */ volatile s32 pauseOnMaxTime; + /* 0x24 */ s32 pauseOnTime; + /* 0x28 */ s8 pauseOnVol; + /* 0x2C */ volatile s32 pauseOffMaxTime; + /* 0x30 */ s32 pauseOffTime; + /* 0x28 */ s8 pauseOffVol; + /* 0x35 */ volatile s8 startVol; + /* 0x36 */ s8 targetVol; + /* 0x38 */ SND_PLAYPARA playPara; +} MUS_PLAYER; // Size 0x58 -typedef struct { - /* 0x00 */ u16 unk00; - /* 0x02 */ s16 unk02; - /* 0x04 */ s32 unk04; - /* 0x08 */ s32 unk08; - /* 0x0C */ s8 unk0C; - /* 0x0D */ s8 unk0D; - /* 0x0E */ char unk0E[2]; -} msmMusStruct01; // Size 0x10 +static struct { + /* 0x000 */ s16 musMax; + /* 0x002 */ s8 musChanMax; + /* 0x003 */ s8 baseGrpNumPlay; + /* 0x004 */ s8 numPlay; + /* 0x008 */ s32 msmEntryNum; + /* 0x00C */ MSM_MUS *musData; + /* 0x010 */ s32 dummyMusOfs; + /* 0x014 */ void* musBuf; + /* 0x018 */ MUS_PLAYER player[4]; +} mus; -typedef struct { - /* 0x000 */ s16 unk00; - /* 0x002 */ s8 unk02; - /* 0x003 */ s8 unk03; - /* 0x004 */ s8 unk04; - /* 0x005 */ char unk05[3]; - /* 0x008 */ s32 unk08; - /* 0x00C */ msmMusStruct01* unk0C; - /* 0x010 */ s32 unk10; - /* 0x014 */ void* unk14; - /* 0x018 */ msmMusStruct00 unk18[1]; // unknown length - /* 0x01C */ char unk70[0x108]; -} msmMusStruct02; // Size 0x178 +static void msmMusPauseSub(MUS_PLAYER* player, BOOL pause, s32 speed) { + s32 time; -typedef struct { - /* 0x00 */ char unk00[0xC]; - /* 0x0C */ s32 unk0C; -} UnkGroupDataPtr; // Size unknown - -static msmMusStruct02 mus; - -static void msmMusPauseSub(msmMusStruct00* arg0, BOOL pause, s32 speed) { - s32 temp_r30; - - temp_r30 = speed / 15; + time = speed / 15; if (pause) { - if (arg0->unk04 == 2) { - if (temp_r30 != 0) { - arg0->unk24 = temp_r30; - arg0->unk20 = temp_r30; - arg0->unk28 = 0x7F; + if (player->status == MSM_MUS_PLAY) { + if (time != 0) { + player->pauseOnTime = time; + player->pauseOnMaxTime = time; + player->pauseOnVol = 127; } else { - sndSeqPause(arg0->unk08); - arg0->unk28 = 0; + sndSeqPause(player->seqId); + player->pauseOnVol = 0; } - arg0->unk04 = 3; + player->status = MSM_MUS_PAUSE; } } else { - if (arg0->unk04 == 3) { - if (temp_r30 != 0) { - if (arg0->unk20 != 0) { - arg0->unk20 = -temp_r30; + if (player->status == MSM_MUS_PAUSE) { + if (time != 0) { + if (player->pauseOnMaxTime != 0) { + player->pauseOnMaxTime = -time; } else { - sndSeqContinue(arg0->unk08); - arg0->unk20 = -temp_r30; - arg0->unk24 = 0; - arg0->unk28 = 0; + sndSeqContinue(player->seqId); + player->pauseOnMaxTime = -time; + player->pauseOnTime = 0; + player->pauseOnVol = 0; } } else { - sndSeqContinue(arg0->unk08); - arg0->unk28 = 0x7F; - sndSeqVolume(arg0->unk02 * arg0->unk03 * arg0->unk1C * arg0->unk28 / 2048383, 0, arg0->unk08, 0); + sndSeqContinue(player->seqId); + player->pauseOnVol = 127; + sndSeqVolume(player->baseVol * player->vol * player->fadeVol * player->pauseOnVol / (127*127*127), 0, player->seqId, 0); } - arg0->unk04 = 2; + player->status = MSM_MUS_PLAY; } } } -static void msmMusPauseFade(msmMusStruct00* arg0) { - if (arg0->unk20 > 0) { - if (--arg0->unk24 == 0) { - arg0->unk20 = 0; - arg0->unk28 = 0; - sndSeqPause(arg0->unk08); +static void msmMusPauseFade(MUS_PLAYER *player) { + if (player->pauseOnMaxTime > 0) { + if (--player->pauseOnTime == 0) { + player->pauseOnMaxTime = 0; + player->pauseOnVol = 0; + sndSeqPause(player->seqId); } else { - arg0->unk28 = arg0->unk24 * 0x7F / arg0->unk20; - sndSeqVolume(arg0->unk02 * arg0->unk03 * arg0->unk1C * arg0->unk28 / 2048383, 0, arg0->unk08, 0); + player->pauseOnVol = player->pauseOnTime * 127 / player->pauseOnMaxTime; + sndSeqVolume(player->baseVol * player->vol * player->fadeVol * player->pauseOnVol / (127*127*127), 0, player->seqId, 0); } - } else if (arg0->unk20 < 0) { - if (++arg0->unk24 >= -arg0->unk20) { - arg0->unk20 = 0; - arg0->unk28 = 0x7F; + } else if (player->pauseOnMaxTime < 0) { + if (++player->pauseOnTime >= -player->pauseOnMaxTime) { + player->pauseOnMaxTime = 0; + player->pauseOnVol = 127; } else { - arg0->unk28 = arg0->unk24 * 0x7F / -arg0->unk20; + player->pauseOnVol = player->pauseOnTime * 127 / -player->pauseOnMaxTime; } - sndSeqVolume(arg0->unk02 * arg0->unk03 * arg0->unk1C * arg0->unk28 / 2048383, 0, arg0->unk08, 0); + sndSeqVolume(player->baseVol * player->vol * player->fadeVol * player->pauseOnVol / (127*127*127), 0, player->seqId, 0); } } -static void msmMusFade(msmMusStruct00* arg0) { - if (arg0->unk04 != 2) { +static void msmMusFade(MUS_PLAYER *player) { + if (player->status != MSM_MUS_PLAY) { return; } - if (arg0->unk14 > 0) { - if (--arg0->unk18 == 0) { - if (arg0->unk04 != 0) { - arg0->unk14 = 0; - if (arg0->unk14 != 0) { - arg0->unk18 = arg0->unk14; - arg0->unk1C = 0x7F; + if (player->fadeMaxTime > 0) { + if (--player->fadeTime == 0) { + if (player->status != 0) { + player->fadeMaxTime = 0; + if (player->fadeMaxTime != 0) { + player->fadeTime = player->fadeMaxTime; + player->fadeVol = 127; } else { - sndSeqStop(arg0->unk08); - arg0->unk04 = 1; + sndSeqStop(player->seqId); + player->status = 1; } } } else { - arg0->unk1C = arg0->unk18 * 0x7F / arg0->unk14; - sndSeqVolume(arg0->unk02 * arg0->unk03 * arg0->unk1C * arg0->unk28 / 2048383, 0, arg0->unk08, 0); + player->fadeVol = player->fadeTime * 127 / player->fadeMaxTime; + sndSeqVolume(player->baseVol * player->vol * player->fadeVol * player->pauseOnVol / (127*127*127), 0, player->seqId, 0); } - } else if (arg0->unk14 < 0) { - if (++arg0->unk18 >= -arg0->unk14) { - arg0->unk14 = 0; - arg0->unk1C = 0x7F; + } else if (player->fadeMaxTime < 0) { + if (++player->fadeTime >= -player->fadeMaxTime) { + player->fadeMaxTime = 0; + player->fadeVol = 127; } else { - arg0->unk1C = arg0->unk18 * 0x7F / -arg0->unk14; + player->fadeVol = player->fadeTime * 127 / -player->fadeMaxTime; } - sndSeqVolume(arg0->unk02 * arg0->unk03 * arg0->unk1C * arg0->unk28 / 2048383, 0, arg0->unk08, 0); + sndSeqVolume(player->baseVol * player->vol * player->fadeVol * player->pauseOnVol / (127*127*127), 0, player->seqId, 0); } } @@ -152,54 +129,54 @@ void msmMusFdoutEnd(void) { } void msmMusPeriodicProc(void) { - s32 var_r26; - msmMusStruct00* temp_r25; + s32 i; + MUS_PLAYER* player; - mus.unk04 = mus.unk03 = 0; - for (var_r26 = 0; var_r26 < mus.unk02; var_r26++) { - temp_r25 = &mus.unk18[var_r26]; - if (temp_r25->unk05 != 0) { + mus.numPlay = mus.baseGrpNumPlay = 0; + for (i = 0; i < mus.musChanMax; i++) { + player = &mus.player[i]; + if (player->busyF != FALSE) { continue; } - switch (temp_r25->unk04) { - case 1: - case 2: - if (sndSeqGetValid(temp_r25->unk08) == FALSE) { - temp_r25->unk04 = 0; + switch (player->status) { + case MSM_MUS_STOP: + case MSM_MUS_PLAY: + if (sndSeqGetValid(player->seqId) == FALSE) { + player->status = 0; } break; } - if (temp_r25->unk04 == 0) { + if (player->status == MSM_MUS_DONE) { continue; } - if (msmSysCheckBaseGroup(mus.unk0C[temp_r25->unk00].unk00) != 0) { - mus.unk04++; + if (msmSysCheckBaseGroup(mus.musData[player->musId].sgid) != 0) { + mus.numPlay++; } else { - mus.unk03++; + mus.baseGrpNumPlay++; } - msmMusPauseFade(temp_r25); - if (temp_r25->unk04 == 2 && temp_r25->unk2C != 0) { - if (++temp_r25->unk30 >= temp_r25->unk2C) { - temp_r25->unk2C = 0; - temp_r25->unk02 = temp_r25->unk36; + msmMusPauseFade(player); + if (player->status == MSM_MUS_PLAY && player->pauseOffMaxTime != 0) { + if (++player->pauseOffTime >= player->pauseOffMaxTime) { + player->pauseOffMaxTime = 0; + player->baseVol = player->targetVol; } else { - temp_r25->unk02 = temp_r25->unk35 + temp_r25->unk30 * (temp_r25->unk36 - temp_r25->unk35) / temp_r25->unk2C; + player->baseVol = player->startVol + player->pauseOffTime * (player->targetVol - player->startVol) / player->pauseOffMaxTime; } - sndSeqVolume(temp_r25->unk02 * temp_r25->unk03 * temp_r25->unk1C * temp_r25->unk28 / 2048383, 0, temp_r25->unk08, 0); + sndSeqVolume(player->baseVol * player->vol * player->fadeVol * player->pauseOnVol / (127*127*127), 0, player->seqId, 0); } - msmMusFade(temp_r25); + msmMusFade(player); } } s32 msmMusGetMidiCtrl(int musNo, s32 channel, s32 ctrl) { - msmMusStruct00* temp_ptr; + MUS_PLAYER *player; - if (musNo < 0 || musNo >= mus.unk02) { + if (musNo < 0 || musNo >= mus.musChanMax) { return MSM_ERR_OUTOFMUS; } - temp_ptr = &mus.unk18[musNo]; - if (sndSeqGetValid(temp_ptr->unk08) == TRUE) { - return sndSeqGetMidiCtrl(temp_ptr->unk08, channel & 0xF, ctrl); + player = &mus.player[musNo]; + if (sndSeqGetValid(player->seqId) == TRUE) { + return sndSeqGetMidiCtrl(player->seqId, channel & 0xF, ctrl); } return 0; } @@ -207,135 +184,135 @@ s32 msmMusGetMidiCtrl(int musNo, s32 channel, s32 ctrl) { s32 msmMusGetNumPlay(BOOL baseGrp) { switch (baseGrp) { case FALSE: - return mus.unk03 + mus.unk04; + return mus.baseGrpNumPlay + mus.numPlay; default: - return mus.unk03; + return mus.baseGrpNumPlay; } } s32 msmMusGetStatus(int musNo) { - if (musNo < 0 || musNo >= mus.unk02) { + if (musNo < 0 || musNo >= mus.musChanMax) { return MSM_ERR_OUTOFMUS; } - return mus.unk18[musNo].unk04; + return mus.player[musNo].status; } -void msmMusSetMasterVolume(s32 arg0) { - sndMasterVolume(arg0 & 0x7F, 0, 1, 0); +void msmMusSetMasterVolume(s32 vol) { + sndMasterVolume(vol & 127, 0, 1, 0); } -s32 msmMusSetParam(s32 arg0, MSM_MUSPARAM* arg1) { - msmMusStruct00* temp_r31; +s32 msmMusSetParam(s32 musNo, MSM_MUSPARAM *param) { + MUS_PLAYER* player; - if (arg0 < 0 || arg0 >= mus.unk02) { + if (musNo < 0 || musNo >= mus.musChanMax) { return MSM_ERR_OUTOFMUS; } - temp_r31 = &mus.unk18[arg0]; - if (arg1->flag & MSM_MUSPARAM_VOL) { - temp_r31->unk2C = arg1->fadeSpeed / 15; - if (temp_r31->unk2C != 0) { - temp_r31->unk05 = 1; - temp_r31->unk30 = 0; - temp_r31->unk35 = temp_r31->unk02; - temp_r31->unk36 = arg1->vol & 0x7F; - temp_r31->unk05 = 0; + player = &mus.player[musNo]; + if (param->flag & MSM_MUSPARAM_VOL) { + player->pauseOffMaxTime = param->fadeSpeed / 15; + if (player->pauseOffMaxTime != 0) { + player->busyF = 1; + player->pauseOffTime = 0; + player->startVol = player->baseVol; + player->targetVol = param->vol & 127; + player->busyF = 0; } else { - temp_r31->unk02 = arg1->vol & 0x7F; - sndSeqVolume(temp_r31->unk02 * temp_r31->unk03 * temp_r31->unk1C * temp_r31->unk28 / 2048383, 0, temp_r31->unk08, 0); + player->baseVol = param->vol & 127; + sndSeqVolume(player->baseVol * player->vol * player->fadeVol * player->pauseOnVol / (127*127*127), 0, player->seqId, 0); } } - if (arg1->flag & MSM_MUSPARAM_SPEED) { - sndSeqSpeed(temp_r31->unk08, (arg1->speed << 8) / 100); + if (param->flag & MSM_MUSPARAM_SPEED) { + sndSeqSpeed(player->seqId, (param->speed << 8) / 100); } return 0; } void msmMusPauseAll(BOOL pause, s32 speed) { s32 var_r27; - msmMusStruct00* temp_r26; + MUS_PLAYER* player; - for (var_r27 = 0; var_r27 < mus.unk02; var_r27++) { - temp_r26 = &mus.unk18[var_r27]; - if (temp_r26->unk04 != 0) { - temp_r26->unk05 = 1; - msmMusPauseSub(temp_r26, pause, speed); - temp_r26->unk05 = 0; + for (var_r27 = 0; var_r27 < mus.musChanMax; var_r27++) { + player = &mus.player[var_r27]; + if (player->status != MSM_MUS_DONE) { + player->busyF = TRUE; + msmMusPauseSub(player, pause, speed); + player->busyF = FALSE; } } } s32 msmMusPause(int musNo, BOOL pause, s32 speed) { - msmMusStruct00* temp_r31; + MUS_PLAYER *player; - if (musNo < 0 || musNo >= mus.unk02) { + if (musNo < 0 || musNo >= mus.musChanMax) { return MSM_ERR_OUTOFMUS; } - temp_r31 = &mus.unk18[musNo]; - temp_r31->unk05 = 1; - msmMusPauseSub(temp_r31, pause, speed); - temp_r31->unk05 = 0; + player = &mus.player[musNo]; + player->busyF = TRUE; + msmMusPauseSub(player, pause, speed); + player->busyF = FALSE; return 0; } void msmMusStopAll(BOOL checkGrp, s32 speed) { - s32 var_r28; - msmMusStruct00* temp_r27; + s32 i; + MUS_PLAYER *player; - for (var_r28 = 0; var_r28 < mus.unk02; var_r28++) { - temp_r27 = &mus.unk18[var_r28]; - if (temp_r27->unk04 == 0) { + for (i = 0; i < mus.musChanMax; i++) { + player = &mus.player[i]; + if (player->status == 0) { continue; } - temp_r27->unk05 = 1; + player->busyF = TRUE; switch (checkGrp) { case FALSE: - if (temp_r27->unk04 != 0) { - temp_r27->unk14 = speed / 15; - if (temp_r27->unk14 != 0) { - temp_r27->unk18 = temp_r27->unk14; - temp_r27->unk1C = 0x7F; + if (player->status != 0) { + player->fadeMaxTime = speed / 15; + if (player->fadeMaxTime != 0) { + player->fadeTime = player->fadeMaxTime; + player->fadeVol = 127; } else { - sndSeqStop(temp_r27->unk08); - temp_r27->unk04 = 1; + sndSeqStop(player->seqId); + player->status = 1; } } break; default: - if (msmSysCheckBaseGroup(mus.unk0C[temp_r27->unk00].unk00) == 0 && temp_r27->unk04 != 0) { - temp_r27->unk14 = speed / 15; - if (temp_r27->unk14 != 0) { - temp_r27->unk18 = temp_r27->unk14; - temp_r27->unk1C = 0x7F; + if (msmSysCheckBaseGroup(mus.musData[player->musId].sgid) == 0 && player->status != 0) { + player->fadeMaxTime = speed / 15; + if (player->fadeMaxTime != 0) { + player->fadeTime = player->fadeMaxTime; + player->fadeVol = 127; } else { - sndSeqStop(temp_r27->unk08); - temp_r27->unk04 = 1; + sndSeqStop(player->seqId); + player->status = 1; } } break; } - temp_r27->unk05 = 0; + player->busyF = FALSE; } } s32 msmMusStop(int musNo, s32 speed) { - msmMusStruct00* temp_r30; + MUS_PLAYER* player; - if (musNo < 0 || musNo >= mus.unk02) { + if (musNo < 0 || musNo >= mus.musChanMax) { return MSM_ERR_OUTOFMUS; } - temp_r30 = &mus.unk18[musNo]; - temp_r30->unk05 = 1; - if (temp_r30->unk04 != 0) { - temp_r30->unk14 = speed / 15; - if (temp_r30->unk14 != 0) { - temp_r30->unk18 = temp_r30->unk14; - temp_r30->unk1C = 0x7F; + player = &mus.player[musNo]; + player->busyF = TRUE; + if (player->status != 0) { + player->fadeMaxTime = speed / 15; + if (player->fadeMaxTime != 0) { + player->fadeTime = player->fadeMaxTime; + player->fadeVol = 127; } else { - sndSeqStop(temp_r30->unk08); - temp_r30->unk04 = 1; + sndSeqStop(player->seqId); + player->status = MSM_MUS_STOP; } } - temp_r30->unk05 = 0; + player->busyF = FALSE; return 0; } @@ -343,124 +320,124 @@ int msmMusPlay(int musId, MSM_MUSPARAM* musParam) { s32 var_r30; int var_r29; s32 temp_r3_3; - UnkGroupDataPtr* temp_r3_2; - msmMusStruct01* temp_r28; - msmMusStruct00* temp_r27; + MSM_GRP_HEAD* temp_r3_2; + MSM_MUS* temp_r28; + MUS_PLAYER* temp_r27; DVDFileInfo sp10; - if (musId < 0 || musId >= mus.unk00) { + if (musId < 0 || musId >= mus.musMax) { return MSM_ERR_INVALIDID; } - temp_r28 = &mus.unk0C[musId]; - if (temp_r28->unk00 == 0xFFFF) { + temp_r28 = &mus.musData[musId]; + if (temp_r28->sgid == 0xFFFF) { return MSM_ERR_REMOVEDID; } - if (msmSysCheckLoadGroupID(temp_r28->unk00) == 0) { + if (msmSysCheckLoadGroupID(temp_r28->sgid) == 0) { return MSM_ERR_GRP_NOTLOADED; } var_r30 = (musParam != NULL) ? musParam->flag : 0; var_r29 = (var_r30 & MSM_MUSPARAM_CHAN) ? musParam->chan : 0; - if (var_r29 < 0 || var_r29 >= mus.unk02) { + if (var_r29 < 0 || var_r29 >= mus.musChanMax) { return MSM_ERR_OUTOFMUS; } - temp_r27 = &mus.unk18[var_r29]; - if (temp_r27->unk04 != 0) { - sndSeqStop(temp_r27->unk08); + temp_r27 = &mus.player[var_r29]; + if (temp_r27->status != 0) { + sndSeqStop(temp_r27->seqId); } - if (temp_r28->unk0C < 0) { - if (temp_r27->unk00 != musId) { - if (msmFioOpen(mus.unk08, &sp10) != 1) { + if (temp_r28->songGrp < 0) { + if (temp_r27->musId != musId) { + if (msmFioOpen(mus.msmEntryNum, &sp10) != 1) { return MSM_ERR_OPENFAIL; } - if (msmFioRead(&sp10, temp_r27->unk0C, temp_r28->unk08, temp_r28->unk04 + mus.unk10) < 0) { + if (msmFioRead(&sp10, temp_r27->songBuf, temp_r28->songSize, temp_r28->songOfs + mus.dummyMusOfs) < 0) { msmFioClose(&sp10); return MSM_ERR_READFAIL; } msmFioClose(&sp10); - temp_r27->unk10 = temp_r27->unk0C; + temp_r27->arrfile = temp_r27->songBuf; } } else { - temp_r3_2 = msmSysGetGroupDataPtr(temp_r28->unk0C); + temp_r3_2 = msmSysGetGroupDataPtr(temp_r28->songGrp); if (temp_r3_2 == NULL) { return MSM_ERR_MUSGRP_NOTLOADED; } - temp_r27->unk10 = (void*) ((u32) temp_r3_2 + temp_r3_2->unk0C + temp_r28->unk04); + temp_r27->arrfile = (void*) ((u32) temp_r3_2 + temp_r3_2->sngOfs + temp_r28->songOfs); } - temp_r27->unk05 = 1; - temp_r27->unk03 = temp_r28->unk0D; - temp_r27->unk2C = 0; - temp_r27->unk20 = 0; - temp_r27->unk14 = 0; - temp_r27->unk28 = 0x7F; - temp_r27->unk1C = 0x7F; - temp_r27->unk38.flags = 4; - temp_r27->unk38.volume.time = 0; - temp_r27->unk02 = (var_r30 & MSM_MUSPARAM_VOL) ? musParam->vol : 0x7F; - temp_r27->unk38.volume.target = temp_r27->unk03 * temp_r27->unk1C * temp_r27->unk02 / 16129; + temp_r27->busyF = 1; + temp_r27->vol = temp_r28->vol; + temp_r27->pauseOffMaxTime = 0; + temp_r27->pauseOnMaxTime = 0; + temp_r27->fadeMaxTime = 0; + temp_r27->pauseOnVol = 127; + temp_r27->fadeVol = 127; + temp_r27->playPara.flags = 4; + temp_r27->playPara.volume.time = 0; + temp_r27->baseVol = (var_r30 & MSM_MUSPARAM_VOL) ? musParam->vol : 127; + temp_r27->playPara.volume.target = temp_r27->vol * temp_r27->fadeVol * temp_r27->baseVol / 16129; if (var_r30 & MSM_MUSPARAM_PAUSE) { - temp_r27->unk38.flags |= 0x10; + temp_r27->playPara.flags |= 0x10; } if (var_r30 & MSM_MUSPARAM_SPEED) { - temp_r27->unk38.flags |= 2; - temp_r27->unk38.speed = musParam->speed * 256 / 100; + temp_r27->playPara.flags |= 2; + temp_r27->playPara.speed = musParam->speed * 256 / 100; } if (var_r30 & MSM_MUSPARAM_FADESPEED) { - temp_r27->unk14 = -(musParam->fadeSpeed / 15); - if (temp_r27->unk14 != 0) { - temp_r27->unk18 = 0; - temp_r27->unk1C = 0; - temp_r27->unk38.volume.target = 0; + temp_r27->fadeMaxTime = -(musParam->fadeSpeed / 15); + if (temp_r27->fadeMaxTime != 0) { + temp_r27->fadeTime = 0; + temp_r27->fadeVol = 0; + temp_r27->playPara.volume.target = 0; } } - temp_r3_3 = sndSeqPlayEx(temp_r28->unk00, temp_r28->unk02, temp_r27->unk10, &temp_r27->unk38, 0); + temp_r3_3 = sndSeqPlay(temp_r28->sgid, temp_r28->sid, temp_r27->arrfile, &temp_r27->playPara); if (temp_r3_3 == SND_ID_ERROR) { - temp_r27->unk05 = 0; + temp_r27->busyF = 0; return MSM_ERR_PLAYFAIL; } - temp_r27->unk08 = temp_r3_3; - temp_r27->unk00 = musId; - temp_r27->unk04 = (temp_r27->unk38.flags & 0x10) ? 3 : 2; - temp_r27->unk05 = 0; + temp_r27->seqId = temp_r3_3; + temp_r27->musId = musId; + temp_r27->status = (temp_r27->playPara.flags & 0x10) ? 3 : 2; + temp_r27->busyF = 0; return var_r29; } -s32 msmMusInit(sysData* arg0, DVDFileInfo* arg1) { +s32 msmMusInit(MSM_SYS* arg0, DVDFileInfo* arg1) { s32 temp_r4; s32 var_r8; - mus.unk00 = 0; - mus.unk02 = 0; - mus.unk04 = 0; - mus.unk03 = 0; - if (arg0->unk10->unk4 == 0) { + mus.musMax = 0; + mus.musChanMax = 0; + mus.numPlay = 0; + mus.baseGrpNumPlay = 0; + if (arg0->info->musMax == 0) { return 0; } - temp_r4 = arg0->unkC->unk2C; + temp_r4 = arg0->header->musSize; if (temp_r4 == 0) { return 0; } - if ((mus.unk0C = msmMemAlloc(temp_r4)) == NULL) { + if ((mus.musData = msmMemAlloc(temp_r4)) == NULL) { return MSM_ERR_OUTOFMEM; } - if (msmFioRead(arg1, mus.unk0C, arg0->unkC->unk2C, arg0->unkC->unk28) < 0) { + if (msmFioRead(arg1, mus.musData, arg0->header->musSize, arg0->header->musOfs) < 0) { return MSM_ERR_READFAIL; } - temp_r4 = arg0->unk10->unk20; + temp_r4 = arg0->info->dummyMusSize; if (temp_r4 != 0) { - if ((mus.unk14 = msmMemAlloc(temp_r4 * arg0->unk10->unk8)) == NULL) { + if ((mus.musBuf = msmMemAlloc(temp_r4 * arg0->info->musChanMax)) == NULL) { return MSM_ERR_OUTOFMEM; } } else { - mus.unk14 = NULL; + mus.musBuf = NULL; } - mus.unk00 = arg0->unk10->unk4; - mus.unk02 = arg0->unk10->unk8; - mus.unk10 = arg0->unkC->unk48; - mus.unk08 = arg0->unk0; - for (var_r8 = 0; var_r8 < mus.unk02; var_r8++) { - mus.unk18[var_r8].unk0C = (void*) ((u32) mus.unk14 + arg0->unk10->unk20 * var_r8); - mus.unk18[var_r8].unk00 = -1; - mus.unk18[var_r8].unk05 = 0; + mus.musMax = arg0->info->musMax; + mus.musChanMax = arg0->info->musChanMax; + mus.dummyMusOfs = arg0->header->dummyMusOfs; + mus.msmEntryNum = arg0->msmEntryNum; + for (var_r8 = 0; var_r8 < mus.musChanMax; var_r8++) { + mus.player[var_r8].songBuf = (void*) ((u32) mus.musBuf + arg0->info->dummyMusSize * var_r8); + mus.player[var_r8].musId = -1; + mus.player[var_r8].busyF = 0; } return 0; } diff --git a/src/msm/msmse.c b/src/msm/msmse.c index 1d6481ce..cbacf34c 100755 --- a/src/msm/msmse.c +++ b/src/msm/msmse.c @@ -2,641 +2,637 @@ #include "msm/msmfio.h" #include "msm/msmmem.h" -typedef struct { - /* 0x00 */ SND_VOICEID unk00; - /* 0x04 */ s32 unk04; - /* 0x08 */ s16 unk08; - /* 0x0A */ s8 unk0A; - /* 0x0B */ s8 unk0B; - /* 0x0C */ s8 unk0C; - /* 0x0D */ s8 unk0D; - /* 0x0E */ s16 unk0E; - /* 0x10 */ s8 unk10; - /* 0x11 */ s8 unk11; - /* 0x12 */ s8 unk12; - /* 0x13 */ u8 unk13; - /* 0x14 */ SND_PARAMETER_INFO unk14; - /* 0x1C */ SND_PARAMETER unk1C[5]; - /* 0x30 */ s8 unk30; - /* 0x31 */ s8 unk31; - /* 0x32 */ s16 unk32; - /* 0x34 */ volatile s32 unk34; - /* 0x38 */ s32 unk38; - /* 0x3C */ s8 unk3C; - /* 0x3D */ char unk3D[3]; - /* 0x40 */ volatile s32 unk40; - /* 0x44 */ s32 unk44; - /* 0x48 */ s8 unk48; - /* 0x49 */ char unk49[3]; - /* 0x4C */ SND_EMITTER unk4C; - /* 0x9C */ SND_FVECTOR unk9C; - /* 0xA8 */ SND_FVECTOR unkA8; - /* 0xB4 */ s8 unkB4; - /* 0xB5 */ char unkB5[3]; -} msmSeStruct00; // Size 0xB8 +#define SE_PLAYER_EMIT (1 << 0) -typedef struct { - /* 0x00 */ s32 unk00; - /* 0x04 */ s8 unk04; - /* 0x05 */ s8 unk05; - /* 0x06 */ s8 unk06; - /* 0x07 */ char unk07[1]; - /* 0x08 */ s32 unk08; - /* 0x0C */ MSMSE* unk0C; - /* 0x10 */ msmSeStruct00* unk10; - /* 0x14 */ SND_LISTENER unk14; - /* 0xA4 */ SND_FVECTOR unkA4; - /* 0xB0 */ SND_FVECTOR unkB0; - /* 0xBC */ SND_FVECTOR unkBC; - /* 0xC8 */ SND_FVECTOR unkC8; - /* 0xD4 */ float unkD4; - /* 0xD8 */ u16 unkD8; - /* 0xDA */ u16 unkDA; -} msmSeStruct02; // Size 0xDC +typedef struct SePlayer_s { + SND_VOICEID vid; + s32 no; + s16 seId; + s8 status; + s8 busyF; + s8 vol; + s8 pan; + s16 pitch; + s8 span; + s8 auxAVol; + s8 auxBVol; + u8 flag; + SND_PARAMETER_INFO paramInfo; + SND_PARAMETER param[5]; + s8 baseVol; + s8 basePan; + s16 basePitch; + volatile s32 fadeMaxTime; + s32 fadeTime; + s8 fadeVol; + volatile s32 pauseMaxTime; + s32 pauseTime; + s8 pauseVol; + SND_EMITTER emitter; + SND_FVECTOR emiPos; + SND_FVECTOR emiDir; + s8 emitterF; +} SE_PLAYER; -msmSeStruct02 se; +static struct { + s32 seMax; + s8 sfx; + s8 baseGrpNumPlay; + s8 numPlay; + s32 no; + MSM_SE *seData; + SE_PLAYER *player; + SND_LISTENER listener; + SND_FVECTOR listenerPos; + SND_FVECTOR listenerDir; + SND_FVECTOR listenerHeading; + SND_FVECTOR listenerUp; + float sndDist; + u16 groupId; + u16 listenerF; +} se; -static void msmSeFade(msmSeStruct00* arg0) { - u8 temp_r3; +static void msmSeFade(SE_PLAYER *player) { + u8 vol; - if (arg0->unk0A == 3) { + if (player->status == MSM_SE_PAUSEOUT) { return; } - if (arg0->unk34 > 0) { - if (--arg0->unk38 == 0) { - arg0->unk34 = 0; - arg0->unk34 = 0; - if (arg0->unk34 != 0) { - arg0->unk38 = arg0->unk34; - arg0->unk3C = 0x7F; + if (player->fadeMaxTime > 0) { + if (--player->fadeTime == 0) { + player->fadeMaxTime = 0; + player->fadeMaxTime = 0; + if (player->fadeMaxTime != 0) { + player->fadeTime = player->fadeMaxTime; + player->fadeVol = 127; } else { - arg0->unk0A = 1; - if ((arg0->unk13 & 1) && arg0->unkB4 == 1) { - sndRemoveEmitter(&arg0->unk4C); + player->status = 1; + if ((player->flag & SE_PLAYER_EMIT) && player->emitterF == TRUE) { + sndRemoveEmitter(&player->emitter); } else { - sndFXKeyOff(arg0->unk00); + sndFXKeyOff(player->vid); } } } else { - arg0->unk3C = arg0->unk38 * 0x7F / arg0->unk34; - temp_r3 = arg0->unk0C * arg0->unk30 * arg0->unk3C * arg0->unk48 / 2048383; - if ((arg0->unk13 & 1) && arg0->unkB4 == 1) { - arg0->unkA8.x = arg0->unkA8.y = arg0->unkA8.z = 0.0f; - sndUpdateEmitter(&arg0->unk4C, &arg0->unk9C, &arg0->unkA8, temp_r3, NULL); + player->fadeVol = player->fadeTime * 127 / player->fadeMaxTime; + vol = player->vol * player->baseVol * player->fadeVol * player->pauseVol / (127*127*127); + if ((player->flag & SE_PLAYER_EMIT) && player->emitterF == TRUE) { + player->emiDir.x = player->emiDir.y = player->emiDir.z = 0.0f; + sndUpdateEmitter(&player->emitter, &player->emiPos, &player->emiDir, vol, NULL); } else { - sndFXVolume(arg0->unk00, temp_r3); + sndFXVolume(player->vid, vol); } } - } else if (arg0->unk34 < 0) { - if (++arg0->unk38 >= -arg0->unk34) { - arg0->unk34 = 0; - arg0->unk3C = 0x7F; + } else if (player->fadeMaxTime < 0) { + if (++player->fadeTime >= -player->fadeMaxTime) { + player->fadeMaxTime = 0; + player->fadeVol = 127; } else { - arg0->unk3C = arg0->unk38 * 0x7F / -arg0->unk34; + player->fadeVol = player->fadeTime * 127 / -player->fadeMaxTime; } - temp_r3 = arg0->unk0C * arg0->unk30 * arg0->unk3C * arg0->unk48 / 2048383; - if ((arg0->unk13 & 1) && arg0->unkB4 == 1) { - arg0->unkA8.x = arg0->unkA8.y = arg0->unkA8.z = 0.0f; - sndUpdateEmitter(&arg0->unk4C, &arg0->unk9C, &arg0->unkA8, temp_r3, NULL); + vol = player->vol * player->baseVol * player->fadeVol * player->pauseVol / (127*127*127); + if ((player->flag & SE_PLAYER_EMIT) && player->emitterF == 1) { + player->emiDir.x = player->emiDir.y = player->emiDir.z = 0.0f; + sndUpdateEmitter(&player->emitter, &player->emiPos, &player->emiDir, vol, NULL); } else { - sndFXVolume(arg0->unk00, temp_r3); + sndFXVolume(player->vid, vol); } } } -static void msmSePauseSub(msmSeStruct00* arg0, BOOL pause, s32 speed) { - s32 temp_r3; +static void msmSePauseSub(SE_PLAYER* player, BOOL pause, s32 speed) { + s32 time; - temp_r3 = speed / 15; + time = speed / 15; if (pause) { - if (arg0->unk0A == 2) { - if (temp_r3 != 0) { - arg0->unk40 = arg0->unk44 = temp_r3; - arg0->unk48 = 0x7F; + if (player->status == MSM_SE_PAUSEIN) { + if (time != 0) { + player->pauseMaxTime = player->pauseTime = time; + player->pauseVol = 127; } else { - arg0->unk48 = 0; - sndFXVolume(arg0->unk00, arg0->unk0C * arg0->unk30 * arg0->unk3C * arg0->unk48 / 2048383); + player->pauseVol = 0; + sndFXVolume(player->vid, player->vol * player->baseVol * player->fadeVol * player->pauseVol / (127*127*127)); } - arg0->unk0A = 3; + player->status = MSM_SE_PAUSEOUT; } } else { - if (arg0->unk0A == 3) { - if (temp_r3 != 0) { - if (arg0->unk40 != 0) { - arg0->unk40 = -temp_r3; + if (player->status == MSM_SE_PAUSEOUT) { + if (time != 0) { + if (player->pauseMaxTime != 0) { + player->pauseMaxTime = -time; } else { - arg0->unk40 = -temp_r3; - arg0->unk44 = 0; - arg0->unk48 = 0; + player->pauseMaxTime = -time; + player->pauseTime = 0; + player->pauseVol = 0; } } else { - arg0->unk48 = 0x7F; - sndFXVolume(arg0->unk00, arg0->unk0C * arg0->unk30 * arg0->unk3C * arg0->unk48 / 2048383); + player->pauseVol = 127; + sndFXVolume(player->vid, player->vol * player->baseVol * player->fadeVol * player->pauseVol / (127*127*127)); } - arg0->unk0A = 2; + player->status = MSM_SE_PAUSEIN; } } } -void msmSePeriodicProc(void) { - s32 var_r26; - msmSeStruct00* temp_r3; - u8 temp_r3_3; +static SE_PLAYER* msmSeSearchEntry(s32 seNo) { + SE_PLAYER *player; + s32 i; - se.unk05 = se.unk06 = 0; - for (var_r26 = 0; var_r26 < se.unk04; var_r26++) { - temp_r3 = &se.unk10[var_r26]; - if (temp_r3->unk0B != 0) { - continue; - } - switch (temp_r3->unk0A) { - case 1: - case 2: - if ((temp_r3->unk13 & 1) && temp_r3->unkB4 == 1) { - if (!sndCheckEmitter(&temp_r3->unk4C)) { - temp_r3->unk0A = 0; - } - } else { - if (sndFXCheck(temp_r3->unk00) == SND_ID_ERROR) { - temp_r3->unk0A = 0; - } - } - break; - } - if (temp_r3->unk0A == 0) { - continue; - } - if (msmSysCheckBaseGroup(se.unk0C[temp_r3->unk08].groupId) != 0) { - se.unk05++; - } else { - se.unk06++; - } - if (temp_r3->unk40 > 0) { - if (--temp_r3->unk44 == 0) { - temp_r3->unk40 = 0; - temp_r3->unk48 = 0; - } else { - temp_r3->unk48 = temp_r3->unk44 * 0x7F / temp_r3->unk40; - } - } else if (temp_r3->unk40 < 0) { - if (++temp_r3->unk44 >= -temp_r3->unk40) { - temp_r3->unk40 = 0; - temp_r3->unk48 = 0x7F; - } else { - temp_r3->unk48 = temp_r3->unk44 * 0x7F / -temp_r3->unk40; - } - } - temp_r3_3 = temp_r3->unk0C * temp_r3->unk30 * temp_r3->unk3C * temp_r3->unk48 / 2048383; - if ((temp_r3->unk13 & 1) && temp_r3->unkB4 == 1) { - temp_r3->unkA8.x = temp_r3->unkA8.y = temp_r3->unkA8.z = 0.0f; - sndUpdateEmitter(&temp_r3->unk4C, &temp_r3->unk9C, &temp_r3->unkA8, temp_r3_3, NULL); - } else { - sndFXVolume(temp_r3->unk00, temp_r3_3); - } - msmSeFade(temp_r3); - } -} - -MSMSE* msmSeGetIndexPtr(s32 arg0) { - if (arg0 < 0 || arg0 >= se.unk00) { - return NULL; - } - return &se.unk0C[arg0]; -} - -void msmSeDelListener(void) { - if (se.unkDA != 0) { - sndRemoveListener(&se.unk14); - se.unkDA = 0; - } -} - -s32 msmSeUpdataListener(Vec* pos, Vec* heading) { - if (se.unkDA == 0) { - return MSM_ERR_22; - } - se.unkB0.x = pos->x - se.unkA4.x; - se.unkB0.y = pos->y - se.unkA4.y; - se.unkB0.z = pos->z - se.unkA4.z; - se.unkA4.x = pos->x; - se.unkA4.y = pos->y; - se.unkA4.z = pos->z; - se.unkBC.x = heading->x; - se.unkBC.y = heading->y; - se.unkBC.z = heading->z; - if (!sndUpdateListener(&se.unk14, &se.unkA4, &se.unkB0, &se.unkBC, &se.unkC8, 0x7F, NULL)) { - return MSM_ERR_22; - } - return 0; -} - -s32 msmSeSetListener(Vec* pos, Vec* heading, float sndDist, float sndSpeed, MSM_SELISTENER* listener) { - SND_FVECTOR* temp_b0; - SND_FVECTOR* temp_a4; - SND_FVECTOR* temp_c8; - SND_FVECTOR* temp_bc; - s32 var_r3; - float var_f4; - float var_f0; - float var_f0_2; - - temp_a4 = &se.unkA4; - temp_c8 = &se.unkC8; - temp_bc = &se.unkBC; - temp_b0 = &se.unkB0; - temp_a4->x = pos->x; - temp_a4->y = pos->y; - temp_a4->z = pos->z; - temp_c8->x = temp_c8->z = 0.0f; - temp_c8->y = 1.0f; - temp_bc->x = heading->x; - temp_bc->y = heading->y; - temp_bc->z = heading->z; - temp_b0->x = temp_b0->y = temp_b0->z = 0.0f; - se.unkD4 = sndDist; - var_r3 = (listener != NULL) ? listener->flag : 0; - var_f4 = (var_r3 & 1) ? listener->startDis : 0.0f; - var_f0 = (var_r3 & 2) ? listener->frontSurDis : (var_f4 + sndDist * 0.25f); - var_f0_2 = (var_r3 & 4) ? listener->backSurDis : (var_f4 + sndDist * 0.25f); - if ((s32) sndAddListenerEx(&se.unk14, temp_a4, temp_b0, temp_bc, temp_c8, - var_f0, var_f0_2, sndSpeed, -var_f4, 1, 0x7F, NULL) == FALSE) - { - se.unkDA = 0; - return MSM_ERR_22; - } - se.unkDA = 1; - return 0; -} - -s32 msmSeGetEntryID(s32 seId, int* seNo) { - msmSeStruct00* temp_r8; - s32 var_r9; - s32 var_r10; - - for (var_r9 = var_r10 = 0; var_r9 < se.unk04; var_r9++) { - temp_r8 = &se.unk10[var_r9]; - if (temp_r8->unk0A != 0 && temp_r8->unk08 == seId) { - if (seNo != NULL) { - seNo[var_r10] = temp_r8->unk04; - } - var_r10++; - } - } - return var_r10; -} - -s32 msmSeGetNumPlay(BOOL baseGrp) { - switch (baseGrp) { - case FALSE: - return se.unk06 + se.unk05; - default: - return se.unk06; - } -} - -static inline msmSeStruct00* msmSeGetStatus_inline(s32 seNo) { - msmSeStruct00* var_r4; - s32 var_ctr; - - for (var_ctr = 0; var_ctr < se.unk04; var_ctr++) { - var_r4 = &se.unk10[var_ctr]; - if (var_r4->unk0A != 0 && var_r4->unk04 == seNo) { - return var_r4; + for (i = 0; i < se.sfx; i++) { + player = &se.player[i]; + if (player->status != MSM_SE_DONE && player->no == seNo) { + return player; } } return NULL; } -s32 msmSeGetStatus(int seNo) { - msmSeStruct00* var_r4; +void msmSePeriodicProc(void) { + s32 i; + SE_PLAYER* player; + u8 vol; - var_r4 = msmSeGetStatus_inline(seNo); - if (var_r4 == NULL) { - return 0; + se.baseGrpNumPlay = se.numPlay = 0; + for (i = 0; i < se.sfx; i++) { + player = &se.player[i]; + if (player->busyF != 0) { + continue; + } + switch (player->status) { + case MSM_SE_PLAY: + case MSM_SE_PAUSEIN: + if ((player->flag & SE_PLAYER_EMIT) && player->emitterF == TRUE) { + if (!sndCheckEmitter(&player->emitter)) { + player->status = 0; + } + } else { + if (sndFXCheck(player->vid) == SND_ID_ERROR) { + player->status = 0; + } + } + break; + } + if (player->status == 0) { + continue; + } + if (msmSysCheckBaseGroup(se.seData[player->seId].gid) != 0) { + se.baseGrpNumPlay++; + } else { + se.numPlay++; + } + if (player->pauseMaxTime > 0) { + if (--player->pauseTime == 0) { + player->pauseMaxTime = 0; + player->pauseVol = 0; + } else { + player->pauseVol = player->pauseTime * 127 / player->pauseMaxTime; + } + } else if (player->pauseMaxTime < 0) { + if (++player->pauseTime >= -player->pauseMaxTime) { + player->pauseMaxTime = 0; + player->pauseVol = 127; + } else { + player->pauseVol = player->pauseTime * 127 / -player->pauseMaxTime; + } + } + vol = player->vol * player->baseVol * player->fadeVol * player->pauseVol / (127*127*127); + if ((player->flag & SE_PLAYER_EMIT) && player->emitterF == TRUE) { + player->emiDir.x = player->emiDir.y = player->emiDir.z = 0.0f; + sndUpdateEmitter(&player->emitter, &player->emiPos, &player->emiDir, vol, NULL); + } else { + sndFXVolume(player->vid, vol); + } + msmSeFade(player); } - return var_r4->unk0A; } -void msmSeSetMasterVolume(s32 arg0) { - sndMasterVolume(arg0 & 0x7F, 0, 0, 1); +MSM_SE* msmSeGetIndexPtr(s32 seId) { + if (seId < 0 || seId >= se.seMax) { + return NULL; + } + return &se.seData[seId]; +} + +void msmSeDelListener(void) { + if (se.listenerF != 0) { + sndRemoveListener(&se.listener); + se.listenerF = 0; + } +} + +s32 msmSeUpdataListener(Vec* pos, Vec* heading) { + if (se.listenerF == 0) { + return MSM_LISTENER_NO_UPDATA; + } + se.listenerDir.x = pos->x - se.listenerPos.x; + se.listenerDir.y = pos->y - se.listenerPos.y; + se.listenerDir.z = pos->z - se.listenerPos.z; + se.listenerPos.x = pos->x; + se.listenerPos.y = pos->y; + se.listenerPos.z = pos->z; + se.listenerHeading.x = heading->x; + se.listenerHeading.y = heading->y; + se.listenerHeading.z = heading->z; + if (!sndUpdateListener(&se.listener, &se.listenerPos, &se.listenerDir, &se.listenerHeading, &se.listenerUp, 127, NULL)) { + return MSM_LISTENER_NO_UPDATA; + } + return 0; +} + +s32 msmSeSetListener(Vec* pos, Vec* heading, float sndDist, float sndSpeed, MSM_SELISTENER* listener) { + SND_FVECTOR* listenerDir; + SND_FVECTOR* listenerPos; + SND_FVECTOR* listenerUp; + SND_FVECTOR* listenerHeading; + s32 flag; + float startDis; + float frontSurDis; + float backSurDis; + + listenerPos = &se.listenerPos; + listenerUp = &se.listenerUp; + listenerHeading = &se.listenerHeading; + listenerDir = &se.listenerDir; + listenerPos->x = pos->x; + listenerPos->y = pos->y; + listenerPos->z = pos->z; + listenerUp->x = listenerUp->z = 0.0f; + listenerUp->y = 1.0f; + listenerHeading->x = heading->x; + listenerHeading->y = heading->y; + listenerHeading->z = heading->z; + listenerDir->x = listenerDir->y = listenerDir->z = 0.0f; + se.sndDist = sndDist; + flag = (listener != NULL) ? listener->flag : MSM_LISTENER_NONE; + startDis = (flag & MSM_LISTENER_STARTDIS) ? listener->startDis : 0.0f; + frontSurDis = (flag & MSM_LISTENER_FRONTSURDIS) ? listener->frontSurDis : (startDis + sndDist * 0.25f); + backSurDis = (flag & MSM_LISTENER_BACKSURDIS) ? listener->backSurDis : (startDis + sndDist * 0.25f); + if ((s32) sndAddListenerEx(&se.listener, listenerPos, listenerDir, listenerHeading, listenerUp, + frontSurDis, backSurDis, sndSpeed, -startDis, SND_EMITTER_CONTINOUS, 127, NULL) == FALSE) + { + se.listenerF = FALSE; + return MSM_LISTENER_NO_UPDATA; + } + se.listenerF = TRUE; + return 0; +} + +s32 msmSeGetEntryID(s32 seId, int* seNo) { + SE_PLAYER* player; + s32 i; + s32 num; + + for (i = num = 0; i < se.sfx; i++) { + player = &se.player[i]; + if (player->status != 0 && player->seId == seId) { + if (seNo != NULL) { + seNo[num] = player->no; + } + num++; + } + } + return num; +} + +s32 msmSeGetNumPlay(BOOL baseGrp) { + switch (baseGrp) { + case FALSE: + return se.numPlay + se.baseGrpNumPlay; + default: + return se.numPlay; + } +} + +s32 msmSeGetStatus(int seNo) { + SE_PLAYER* pan; + + pan = msmSeSearchEntry(seNo); + if (pan == NULL) { + return 0; + } + return pan->status; +} + +void msmSeSetMasterVolume(s32 vol) { + sndMasterVolume(vol & 127, 0, 0, 1); } s32 msmSeSetParam(int seNo, MSM_SEPARAM* param) { - msmSeStruct00* var_r31; - int temp_r3; - s32 var_r4; + SE_PLAYER* player; + int pan; + s32 pitch; - var_r31 = msmSeGetStatus_inline(seNo); - if (var_r31 == NULL) { - return MSM_ERR_6F; + player = msmSeSearchEntry(seNo); + if (player == NULL) { + return MSM_ERR_INVALIDSE; } if (param->flag & MSM_SEPARAM_VOL) { - var_r31->unk0B = 1; - var_r31->unk0C = param->vol; - if (!(var_r31->unk13 & 1) || var_r31->unkB4 != 1) { - sndFXVolume(var_r31->unk00, var_r31->unk0C * var_r31->unk30 * var_r31->unk3C * var_r31->unk48 / 2048383); + player->busyF = TRUE; + player->vol = param->vol; + if (!(player->flag & SE_PLAYER_EMIT) || player->emitterF != TRUE) { + sndFXVolume(player->vid, player->vol * player->baseVol * player->fadeVol * player->pauseVol / (127*127*127)); } - var_r31->unk0B = 0; + player->busyF = FALSE; } - if (!(var_r31->unk13 & 1)) { + if (!(player->flag & SE_PLAYER_EMIT)) { if (param->flag & MSM_SEPARAM_PAN) { - var_r31->unk0D = param->pan; - temp_r3 = var_r31->unk0D + var_r31->unk31 - 0x40; - if (temp_r3 < 0) { - temp_r3 = 0; + player->pan = param->pan; + pan = player->pan + player->basePan - 64; + if (pan < 0) { + pan = 0; } - if (temp_r3 > 0x7F) { - temp_r3 = 0x7F; + if (pan > 127) { + pan = 127; } - sndFXPanning(var_r31->unk00, temp_r3); + sndFXPanning(player->vid, pan); } if (param->flag & MSM_SEPARAM_PITCH) { - var_r31->unk0E = param->pitch; - var_r4 = var_r31->unk0E + var_r31->unk32 + 0x2000; - if (var_r4 < 0) { - var_r4 = 0; + player->pitch = param->pitch; + pitch = player->pitch + player->basePitch + 8192; + if (pitch < 0) { + pitch = 0; } - if (var_r4 > 0x3FFF) { - var_r4 = 0x3FFF; + if (pitch > 16383) { + pitch = 16383; } - sndFXPitchBend(var_r31->unk00, var_r4); + sndFXPitchBend(player->vid, pitch); } if (param->flag & MSM_SEPARAM_SPAN) { - var_r31->unk10 = param->span; - sndFXSurroundPanning(var_r31->unk00, var_r31->unk10); + player->span = param->span; + sndFXSurroundPanning(player->vid, player->span); } - } else if (var_r31->unkB4 == 1) { - var_r31->unk00 = sndEmitterVoiceID(&var_r31->unk4C); + } else if (player->emitterF == TRUE) { + player->vid = sndEmitterVoiceID(&player->emitter); if (param->flag & MSM_SEPARAM_POS) { - var_r31->unk0B = 1; - var_r31->unkA8.x = param->pos.x - var_r31->unk9C.x; - var_r31->unkA8.y = param->pos.y - var_r31->unk9C.y; - var_r31->unkA8.z = param->pos.z - var_r31->unk9C.z; - var_r31->unk9C.x = param->pos.x; - var_r31->unk9C.y = param->pos.y; - var_r31->unk9C.z = param->pos.z; - sndUpdateEmitter(&var_r31->unk4C, &var_r31->unk9C, &var_r31->unkA8, var_r31->unk0C * var_r31->unk30 * var_r31->unk3C * var_r31->unk48 / 2048383, NULL); - var_r31->unk0B = 0; + player->busyF = TRUE; + player->emiDir.x = param->pos.x - player->emiPos.x; + player->emiDir.y = param->pos.y - player->emiPos.y; + player->emiDir.z = param->pos.z - player->emiPos.z; + player->emiPos.x = param->pos.x; + player->emiPos.y = param->pos.y; + player->emiPos.z = param->pos.z; + sndUpdateEmitter(&player->emitter, &player->emiPos, &player->emiDir, player->vol * player->baseVol * player->fadeVol * player->pauseVol / (127*127*127), NULL); + player->busyF = FALSE; } } if (param->flag & MSM_SEPARAM_AUXVOLA) { - var_r31->unk11 = param->auxAVol; - sndFXReverb(var_r31->unk00, var_r31->unk11); + player->auxAVol = param->auxAVol; + sndFXReverb(player->vid, player->auxAVol); } if (param->flag & MSM_SEPARAM_AUXVOLB) { - var_r31->unk12 = param->auxBVol; - sndFXChorus(var_r31->unk00, var_r31->unk12); + player->auxBVol = param->auxBVol; + sndFXChorus(player->vid, player->auxBVol); } if (param->flag & MSM_SEPARAM_PAD) { - sndSendMessage(var_r31->unk00, param->pad); + sndSendMessage(player->vid, param->pad); } return 0; } void msmSePauseAll(BOOL pause, s32 speed) { - s32 var_r27; - msmSeStruct00* temp_r26; + s32 i; + SE_PLAYER* player; - for (var_r27 = 0; var_r27 < se.unk04; var_r27++) { - temp_r26 = &se.unk10[var_r27]; - temp_r26->unk0B = 1; - msmSePauseSub(temp_r26, pause, speed); - temp_r26->unk0B = 0; + for (i = 0; i < se.sfx; i++) { + player = &se.player[i]; + player->busyF = TRUE; + msmSePauseSub(player, pause, speed); + player->busyF = FALSE; } } void msmSeStopAll(BOOL checkGrp, s32 speed) { - msmSeStruct00* temp_r28; - s32 var_r27; + SE_PLAYER* player; + s32 i; - for (var_r27 = 0; var_r27 < se.unk04; var_r27++) { - temp_r28 = &se.unk10[var_r27]; - if (temp_r28->unk0A == 0) { + for (i = 0; i < se.sfx; i++) { + player = &se.player[i]; + if (player->status == MSM_MUS_DONE) { continue; } - temp_r28->unk0B = 1; + player->busyF = TRUE; switch (checkGrp) { case FALSE: - temp_r28->unk34 = speed / 15; - if (temp_r28->unk34 != 0) { - temp_r28->unk38 = temp_r28->unk34; - temp_r28->unk3C = 0x7F; + player->fadeMaxTime = speed / 15; + if (player->fadeMaxTime != 0) { + player->fadeTime = player->fadeMaxTime; + player->fadeVol = 127; } else { - temp_r28->unk0A = 1; - if ((temp_r28->unk13 & 1) && temp_r28->unkB4 == 1) { - sndRemoveEmitter(&temp_r28->unk4C); + player->status = 1; + if ((player->flag & SE_PLAYER_EMIT) && player->emitterF == TRUE) { + sndRemoveEmitter(&player->emitter); } else { - sndFXKeyOff(temp_r28->unk00); + sndFXKeyOff(player->vid); } } break; default: - if (msmSysCheckBaseGroup(se.unk0C[temp_r28->unk08].groupId) == 0) { - temp_r28->unk34 = speed / 15; - if (temp_r28->unk34 != 0) { - temp_r28->unk38 = temp_r28->unk34; - temp_r28->unk3C = 0x7F; + if (msmSysCheckBaseGroup(se.seData[player->seId].gid) == 0) { + player->fadeMaxTime = speed / 15; + if (player->fadeMaxTime != 0) { + player->fadeTime = player->fadeMaxTime; + player->fadeVol = 127; } else { - temp_r28->unk0A = 1; - if ((temp_r28->unk13 & 1) && temp_r28->unkB4 == 1) { - sndRemoveEmitter(&temp_r28->unk4C); + player->status = 1; + if ((player->flag & SE_PLAYER_EMIT) && player->emitterF == TRUE) { + sndRemoveEmitter(&player->emitter); } else { - sndFXKeyOff(temp_r28->unk00); + sndFXKeyOff(player->vid); } } } break; } - temp_r28->unk0B = 0; + player->busyF = FALSE; } } s32 msmSeStop(int seNo, s32 speed) { - msmSeStruct00* var_r31; + SE_PLAYER* player; - var_r31 = msmSeGetStatus_inline(seNo); - if (var_r31 == NULL) { - return MSM_ERR_6F; + player = msmSeSearchEntry(seNo); + if (player == NULL) { + return MSM_ERR_INVALIDSE; } - var_r31->unk0B = 1; - var_r31->unk34 = speed / 15; - if (var_r31->unk34 != 0) { - var_r31->unk38 = var_r31->unk34; - var_r31->unk3C = 0x7F; + player->busyF = TRUE; + player->fadeMaxTime = speed / 15; + if (player->fadeMaxTime != 0) { + player->fadeTime = player->fadeMaxTime; + player->fadeVol = 127; } else { - var_r31->unk0A = 1; - if ((var_r31->unk13 & 1) && var_r31->unkB4 == 1) { - sndRemoveEmitter(&var_r31->unk4C); + player->status = MSM_MUS_STOP; + if ((player->flag & SE_PLAYER_EMIT) && player->emitterF == TRUE) { + sndRemoveEmitter(&player->emitter); } else { - sndFXKeyOff(var_r31->unk00); + sndFXKeyOff(player->vid); } } - var_r31->unk0B = 0; + player->busyF = FALSE; return 0; } -static inline BOOL msmSeInline00(msmSeStruct00* arg0, MSM_SEPARAM* param) { - BOOL var_r0 = FALSE; +static inline BOOL msmSeUpdateBaseParam(SE_PLAYER* player, MSM_SEPARAM* param) { + BOOL listenerF = FALSE; if (param != NULL) { if (param->flag & MSM_SEPARAM_VOL) { - arg0->unk0C = param->vol; + player->vol = param->vol; } if (param->flag & MSM_SEPARAM_PAN) { - arg0->unk0D = param->pan; + player->pan = param->pan; } if (param->flag & MSM_SEPARAM_PITCH) { - arg0->unk0E = param->pitch; + player->pitch = param->pitch; } if (param->flag & MSM_SEPARAM_SPAN) { - arg0->unk10 = param->span; + player->span = param->span; } if (param->flag & MSM_SEPARAM_AUXVOLA) { - arg0->unk11 = param->auxAVol; + player->auxAVol = param->auxAVol; } if (param->flag & MSM_SEPARAM_AUXVOLB) { - arg0->unk12 = param->auxBVol; + player->auxBVol = param->auxBVol; } - if ((param->flag & MSM_SEPARAM_POS) && se.unkDA != 0) { - var_r0 = TRUE; + if ((param->flag & MSM_SEPARAM_POS) && se.listenerF != 0) { + listenerF = TRUE; } } - arg0->unk14.paraArray = arg0->unk1C; - return var_r0; + player->paramInfo.paraArray = player->param; + return listenerF; } int msmSePlay(int seId, MSM_SEPARAM* param) { - msmSeStruct00* var_r30; - SND_EMITTER* var_r29; - MSMSE* temp_r9; - int var_r3_2; - s32 var_r4; - s32 var_r6; - s32 var_r6_2; + SE_PLAYER* player; + SND_EMITTER* emitter; + MSM_SE* seData; + int pitch; + s32 pan; + s32 i; + s32 emiFlag; - if (seId < 0 || seId >= se.unk00) { + if (seId < 0 || seId >= se.seMax) { return MSM_ERR_INVALIDID; } - temp_r9 = &se.unk0C[seId]; - if (temp_r9->groupId == 0xFFFF) { + seData = &se.seData[seId]; + if (seData->gid == 0xFFFF) { return MSM_ERR_REMOVEDID; } - for (var_r6 = 0; var_r6 < se.unk04; var_r6++) { - var_r30 = &se.unk10[var_r6]; - if (var_r30->unk0A == 0) { + for (i = 0; i < se.sfx; i++) { + player = &se.player[i]; + if (player->status == 0) { break; } } - if (var_r6 == se.unk04) { - return MSM_ERR_6E; + if (i == se.sfx) { + return MSM_ERR_CHANLIMIT; } - var_r30->unk30 = temp_r9->vol; - var_r30->unk31 = temp_r9->pan; - var_r30->unk32 = temp_r9->pitchBend; - var_r30->unk0C = 0x7F; - var_r30->unk0D = 0x40; - var_r30->unk10 = temp_r9->span; - var_r30->unk0E = 0; - var_r30->unk11 = temp_r9->reverb; - var_r30->unk12 = temp_r9->chorus; - var_r30->unk40 = 0; - var_r30->unk34 = 0; - var_r30->unk48 = 0x7F; - var_r30->unk3C = 0x7F; - var_r30->unkB4 = 0; - if (msmSeInline00(var_r30, param)) { - var_r30->unk9C.x = param->pos.x; - var_r30->unk9C.y = param->pos.y; - var_r30->unk9C.z = param->pos.z; - var_r30->unk1C[0].ctrl = SND_MIDICTRL_REVERB; - var_r30->unk1C[0].paraData.value7 = var_r30->unk11; - var_r30->unk1C[1].ctrl = SND_MIDICTRL_CHORUS; - var_r30->unk1C[1].paraData.value7 = var_r30->unk12; - var_r30->unk14.numPara = 2; - var_r30->unkA8.x = var_r30->unkA8.y = var_r30->unkA8.z = 0.0f; - if (temp_r9->doppler == 1) { - var_r29 = &var_r30->unk4C; - var_r6_2 = 9; + player->baseVol = seData->vol; + player->basePan = seData->pan; + player->basePitch = seData->pitchBend; + player->vol = 127; + player->pan = 64; + player->span = seData->span; + player->pitch = 0; + player->auxAVol = seData->reverb; + player->auxBVol = seData->chorus; + player->pauseMaxTime = 0; + player->fadeMaxTime = 0; + player->pauseVol = 127; + player->fadeVol = 127; + player->emitterF = 0; + if (msmSeUpdateBaseParam(player, param)) { + player->emiPos.x = param->pos.x; + player->emiPos.y = param->pos.y; + player->emiPos.z = param->pos.z; + player->param[0].ctrl = SND_MIDICTRL_REVERB; + player->param[0].paraData.value7 = player->auxAVol; + player->param[1].ctrl = SND_MIDICTRL_CHORUS; + player->param[1].paraData.value7 = player->auxBVol; + player->paramInfo.numPara = 2; + player->emiDir.x = player->emiDir.y = player->emiDir.z = 0.0f; + if (seData->emitterF == TRUE) { + emitter = &player->emitter; + emiFlag = SND_EMITTER_DOPPLERFX|SND_EMITTER_CONTINOUS; } else { - var_r29 = NULL; - var_r6_2 = 8; + emitter = NULL; + emiFlag = SND_EMITTER_DOPPLERFX; } - var_r30->unkB4 = temp_r9->doppler; - var_r30->unk00 = sndAddEmitterParaEx(var_r29, &var_r30->unk9C, &var_r30->unkA8, se.unkD4, temp_r9->comp / 127.0f, var_r6_2, temp_r9->fxId, se.unkD8++, var_r30->unk0C * var_r30->unk30 / 127, 0, NULL, &var_r30->unk14); - if (var_r29 != NULL) { - if (!sndCheckEmitter(var_r29)) { + player->emitterF = seData->emitterF; + player->vid = sndAddEmitterParaEx(emitter, &player->emiPos, &player->emiDir, se.sndDist, seData->emiComp / 127.0f, emiFlag, seData->fxId, se.groupId++, player->vol * player->baseVol / 127, 0, NULL, &player->paramInfo); + if (emitter != NULL) { + if (!sndCheckEmitter(emitter)) { return MSM_ERR_PLAYFAIL; } } else { - if (var_r30->unk00 == -1) { + if (player->vid == -1) { return MSM_ERR_PLAYFAIL; } } - var_r30->unk13 |= 1; + player->flag |= 1; } else { - var_r30->unk1C[0].ctrl = SND_MIDICTRL_VOLUME; - var_r30->unk1C[0].paraData.value14 = (var_r30->unk0C * var_r30->unk30 / 127) * 0x81; - var_r4 = var_r30->unk0D + var_r30->unk31 - 0x40; - if (var_r4 < 0) { - var_r4 = 0; + player->param[0].ctrl = SND_MIDICTRL_VOLUME; + player->param[0].paraData.value14 = (player->vol * player->baseVol / 127) * 129; + pan = player->pan + player->basePan - 64; + if (pan < 0) { + pan = 0; } - if (var_r4 > 0x7F) { - var_r4 = 0x7F; + if (pan > 127) { + pan = 127; } - var_r30->unk1C[1].ctrl = SND_MIDICTRL_PANNING; - var_r30->unk1C[1].paraData.value14 = var_r4 * 0x81; - var_r30->unk1C[2].ctrl = SND_MIDICTRL_REVERB; - var_r30->unk1C[2].paraData.value7 = var_r30->unk11; - var_r30->unk1C[3].ctrl = SND_MIDICTRL_CHORUS; - var_r30->unk1C[3].paraData.value7 = var_r30->unk12; - var_r3_2 = var_r30->unk0E + var_r30->unk32 + 0x2000; - if (var_r3_2 > 0x3FFF) { - var_r3_2 = 0x3FFF; - } else if (var_r3_2 < 0) { - var_r3_2 = 0; + player->param[1].ctrl = SND_MIDICTRL_PANNING; + player->param[1].paraData.value14 = pan * 129; + player->param[2].ctrl = SND_MIDICTRL_REVERB; + player->param[2].paraData.value7 = player->auxAVol; + player->param[3].ctrl = SND_MIDICTRL_CHORUS; + player->param[3].paraData.value7 = player->auxBVol; + pitch = player->pitch + player->basePitch + 8192; + if (pitch > 16383) { + pitch = 16383; + } else if (pitch < 0) { + pitch = 0; } - var_r30->unk1C[4].ctrl = SND_MIDICTRL_PITCHBEND; - var_r30->unk1C[4].paraData.value14 = var_r3_2; - var_r30->unk14.numPara = 5; - var_r30->unk00 = sndFXStartParaInfo(temp_r9->fxId, 0xFF, 0xFF, 0, &var_r30->unk14); - if (var_r30->unk00 == -1) { + player->param[4].ctrl = SND_MIDICTRL_PITCHBEND; + player->param[4].paraData.value14 = pitch; + player->paramInfo.numPara = 5; + player->vid = sndFXStartParaInfo(seData->fxId, 0xFF, 0xFF, 0, &player->paramInfo); + if (player->vid == -1) { return MSM_ERR_PLAYFAIL; } - sndFXSurroundPanning(var_r30->unk00, var_r30->unk10); - var_r30->unk13 &= ~1; + sndFXSurroundPanning(player->vid, player->span); + player->flag &= ~1; } - var_r30->unk0B = 1; - var_r30->unk08 = seId; - var_r30->unk04 = se.unk08++; - var_r30->unk0A = 2; - var_r30->unk0B = 0; - return var_r30->unk04; + player->busyF = 1; + player->seId = seId; + player->no = se.no++; + player->status = 2; + player->busyF = 0; + return player->no; } -s32 msmSeInit(sysData* arg0, DVDFileInfo* arg1) { - s32 temp_r29; +s32 msmSeInit(MSM_SYS* arg0, DVDFileInfo* arg1) { + s32 playerSize; - se.unk04 = 0; - se.unk00 = 0; - se.unk05 = 0; - se.unk06 = 0; - se.unkDA = 0; - if (arg0->unk10->unk6 == 0) { + se.sfx = 0; + se.seMax = 0; + se.baseGrpNumPlay = 0; + se.numPlay = 0; + se.listenerF = 0; + if (arg0->info->seMax == 0) { return 0; } - if ((se.unk0C = msmMemAlloc(arg0->unkC->unk34)) == NULL) { + if ((se.seData = msmMemAlloc(arg0->header->seSize)) == NULL) { return MSM_ERR_OUTOFMEM; } - if (msmFioRead(arg1, se.unk0C, arg0->unkC->unk34, arg0->unkC->unk30) < 0) { + if (msmFioRead(arg1, se.seData, arg0->header->seSize, arg0->header->seOfs) < 0) { return MSM_ERR_READFAIL; } - temp_r29 = arg0->unk10->unk2 * sizeof(*se.unk10); - if ((se.unk10 = msmMemAlloc(temp_r29)) == NULL) { + playerSize = arg0->info->sfx * sizeof(SE_PLAYER); + if ((se.player = msmMemAlloc(playerSize)) == NULL) { return MSM_ERR_OUTOFMEM; } - memset(se.unk10, 0, temp_r29); - se.unk00 = arg0->unk10->unk6; - se.unk04 = arg0->unk10->unk2; - se.unk08 = 1; + memset(se.player, 0, playerSize); + se.seMax = arg0->info->seMax; + se.sfx = arg0->info->sfx; + se.no = 1; return 0; } diff --git a/src/msm/msmstream.c b/src/msm/msmstream.c index 058835ab..2afade01 100755 --- a/src/msm/msmstream.c +++ b/src/msm/msmstream.c @@ -3,215 +3,187 @@ #include "msm/msmsys.h" typedef struct { - /* 0x00 */ SND_STREAMID unk00; - /* 0x04 */ s16 unk04; - /* 0x06 */ u8 unk06; - /* 0x07 */ u8 unk07; - /* 0x08 */ u8 unk08; - /* 0x09 */ u8 unk09; - /* 0x0A */ u8 unk0A; - /* 0x0B */ u8 unk0B; - /* 0x0C */ u8 unk0C; - /* 0x0D */ u8 unk0D; - /* 0x0E */ s8 unk0E; - /* 0x0F */ s8 unk0F; - /* 0x10 */ u32 unk10; - /* 0x14 */ volatile s32 unk14; - /* 0x18 */ volatile s32 unk18; - /* 0x1C */ s32 unk1C; - /* 0x20 */ char unk20[4]; - /* 0x24 */ volatile s32 unk24; - /* 0x28 */ s32 unk28; - /* 0x2C */ s8 unk2C; - /* 0x2D */ s8 unk2D; - /* 0x2E */ s8 unk2E; - /* 0x2F */ char unk2F[1]; - /* 0x30 */ void* unk30; - /* 0x34 */ u32 unk34; - /* 0x38 */ u32 unk38; + /* 0x00 */ SND_STREAMID stid; + /* 0x04 */ s16 streamId; + /* 0x06 */ u8 status; + /* 0x07 */ u8 stereoF; + /* 0x08 */ u8 volBase; + /* 0x09 */ u8 vol; + /* 0x0A */ u8 volFade; + /* 0x0B */ u8 pauseVol; + /* 0x0C */ u8 panBase; + /* 0x0D */ u8 pan; + /* 0x0E */ s8 slotL; + /* 0x0F */ s8 slotR; + /* 0x10 */ u32 pauseLen; + /* 0x14 */ volatile s32 pauseTime; + /* 0x18 */ volatile s32 pauseTimeMax; + /* 0x1C */ s32 fadeVol; + /* 0x20 */ s32 unk20; + /* 0x24 */ volatile s32 fadeMaxTime; + /* 0x28 */ s32 fadeTime; + /* 0x2C */ s8 span; + /* 0x2D */ s8 auxA; + /* 0x2E */ s8 auxB; + /* 0x30 */ void* streamBuf; + /* 0x34 */ u32 streamBufSize; + /* 0x38 */ u32 streamFrq; /* 0x3C */ struct { - volatile u8 unk3C_0 : 1; - volatile u8 unk3C_1 : 1; - u8 unk3C_2 : 1; - u8 unk3C_3 : 1; - volatile u8 unk3C_4 : 1; - volatile u8 unk3C_5 : 1; - volatile u8 unk3C_6 : 1; + volatile u8 bufNo : 1; + volatile u8 firstF : 1; + u8 streamOffF : 1; + u8 readBusyF : 1; + volatile u8 shutdownF : 1; + volatile u8 pauseF : 1; + volatile u8 updateAramF : 1; }; - /* 0x3D */ char unk3D[3]; - /* 0x40 */ s32 unk40; - /* 0x44 */ SND_ADPCMSTREAM_INFO* unk44; - /* 0x48 */ s32 unk48; - /* 0x4C */ u32 unk4C; - /* 0x50 */ u32 unk50; - /* 0X54 */ s32 unk54; - /* 0x58 */ u32 unk58; - /* 0x5C */ void* unk5C; - /* 0X60 */ s32 unk60; + s32 frq; + /* 0x44 */ SND_ADPCMSTREAM_INFO* adpcmInfo; + /* 0x48 */ s32 streamBaseOfs; + /* 0x4C */ u32 streamPos; + /* 0x50 */ u32 loopLen; + /* 0X54 */ s32 loopEndOfs; + /* 0x58 */ u32 streamReadSize; + /* 0x5C */ void* streamReadBuf; + /* 0X60 */ s32 streamPosStart; /* 0x64 */ u32 unk64; /* 0x68 */ s32 unk68; /* 0x6C */ s32 unk6C; - /* 0x70 */ DVDFileInfo unk70; -} msmStreamUnk20Struct; // Size 0xAC + /* 0x70 */ DVDFileInfo file; +} MSM_STREAM_SLOT; // Size 0xAC + +static struct { + /* 0x00 */ s32 sampleFrq; + /* 0x04 */ u32 bufSize; + /* 0x08 */ s32 frq; + /* 0x0C */ s32 pdtEntryNum; + /* 0x10 */ s8 time; + /* 0x11 */ u8 masterVol; + /* 0x12 */ u8 outputMode; + /* 0x14 */ u32* streamPackList; + /* 0x18 */ s8* streamPackFlag; + /* 0x1C */ SND_ADPCMSTREAM_INFO* adpcmParam; + /* 0x20 */ MSM_STREAM_SLOT* slot; + MSM_STREAM_HEADER header ATTRIBUTE_ALIGN(32); +} StreamInfo; // Size 0x60 typedef struct { - /* 0x00 */ s32 unk00; - /* 0x04 */ u32 unk04; - /* 0x08 */ s32 unk08; - /* 0x0C */ s32 unk0C; - /* 0x10 */ s8 unk10; - /* 0x11 */ u8 unk11; - /* 0x12 */ u8 unk12; - /* 0x13 */ char unk13[1]; - /* 0x14 */ u32* unk14; - /* 0x18 */ s8* unk18; - /* 0x1C */ SND_ADPCMSTREAM_INFO* unk1C; - /* 0x20 */ msmStreamUnk20Struct* unk20; - /* 0x24 */ char unk24[0x1C]; - /* 0x40 */ s16 unk40; - /* 0x42 */ s16 unk42; - /* 0x44 */ s32 unk44; - /* 0x48 */ s32 unk48; - /* 0x4C */ s32 unk4C; - /* 0x50 */ s32 unk50; - /* 0x54 */ s32 unk54; - /* 0x58 */ s32 unk58; - /* 0x5C */ s32 unk5C; -} msmStreamStruct; // Size 0x60 + /* 0x00 */ u8 vol; + /* 0x01 */ u8 pan; + /* 0x02 */ u8 span; + /* 0x03 */ u8 auxA; + /* 0x04 */ u8 auxB; + /* 0x08 */ s32 sampleOfs; +} STREAM_PARAM; -typedef struct { - /* 0x00 */ s32 unk00; - /* 0x04 */ s16 unk04; - /* 0x06 */ char unk06[2]; -} StructSlotInitInnerArg1; // Size 8 - -typedef struct { - /* 0x00 */ s8 unk00; - /* 0x01 */ s8 unk01; - /* 0x02 */ s8 unk02; - /* 0x03 */ s8 unk03; - /* 0x04 */ s8 unk04; - /* 0x05 */ s8 unk05; - /* 0x06 */ u16 unk06; - /* 0x08 */ u32 unk08; - /* 0x0C */ u32 unk0C; - /* 0x10 */ StructSlotInitInnerArg1 unk10[2]; -} StructSlotInitArg1; // Size unknown - -typedef struct { - /* 0x00 */ u8 unk00; - /* 0x01 */ u8 unk01; - /* 0x02 */ u8 unk02; - /* 0x03 */ u8 unk03; - /* 0x04 */ u8 unk04; - /* 0x05 */ char unk05[3]; - /* 0x08 */ s32 unk08; -} StructSlotInitArg2; // Size unknown - -static void msmStreamPauseFade(s32 arg0); -static void msmStreamFade(s32 arg0); +static void msmStreamPauseFade(s32 streamNo); +static void msmStreamFade(s32 streamNo); static void msmStreamDvdCallback(s32 result, DVDFileInfo* fileInfo); static void msmStreamStopSub(s32 streamNo, s32 speed); -static void msmStreamDvdCallback2(s32 arg0, DVDFileInfo* arg1); +static void msmStreamDvdCallback2(s32 result, DVDFileInfo* fileInfo); static u32 msmStreamUpdateFunc(void* buffer1, u32 len1, void* buffer2, u32 len2, u32 user); -static s32 msmStreamSlotInit(msmStreamUnk20Struct* arg0, StructSlotInitArg1* arg1, StructSlotInitArg2* arg2, s32 arg3); +static s32 msmStreamSlotInit(MSM_STREAM_SLOT* arg0, MSM_STREAM_PACK* arg1, STREAM_PARAM* arg2, s32 arg3); +static void msmStreamPauseOff(s32 streamNo); +static void msmStreamPauseOn(s32 streamNo, s32 arg1); +static s32 msmStreamPackStartStereo(s32 streamId, MSM_STREAMPARAM *param, s32 sampleOfs); +static s32 msmStreamPackStartMono(s32 streamId, MSM_STREAMPARAM *param, s32 sampleOfs); +static void msmStreamSlotOff(s32 streamNo); -static msmStreamStruct StreamInfo ATTRIBUTE_ALIGN(32); +static inline void msmStreamClose(s32 streamNo) { + MSM_STREAM_SLOT* slot; -static inline void msmStreamInline00(s32 streamNo) { - msmStreamUnk20Struct* temp_ptr; - - temp_ptr = &StreamInfo.unk20[streamNo]; - DVDClose(&temp_ptr->unk70); - temp_ptr->unk06 = 0; + slot = &StreamInfo.slot[streamNo]; + DVDClose(&slot->file); + slot->status = 0; } s32 msmStreamGetStatus(int streamNo) { - msmStreamUnk20Struct* temp_r3; - s32 var_r4; + MSM_STREAM_SLOT* slot; + s32 status; - if (streamNo < 0 || streamNo >= StreamInfo.unk44) { + if (streamNo < 0 || streamNo >= StreamInfo.header.chanMax) { return 0; } - temp_r3 = &StreamInfo.unk20[streamNo]; - switch (temp_r3->unk06) { + slot = &StreamInfo.slot[streamNo]; + switch (slot->status) { case 4: - var_r4 = 2; + status = MSM_STREAM_PLAY; break; case 2: case 3: - var_r4 = 4; + status = MSM_STREAM_PAUSEOUT; break; case 5: - var_r4 = 1; + status = MSM_STREAM_STOP; break; default: - var_r4 = 0; + status = MSM_STREAM_DONE; break; } - if (temp_r3->unk3C_5 == 1) { - var_r4 = 3; + if (slot->pauseF == TRUE) { + status = MSM_STREAM_PAUSEIN; } - if (var_r4 == 0 && temp_r3->unk0E != -1) { - var_r4 = msmStreamGetStatus(temp_r3->unk0E); + if (status == MSM_STREAM_DONE && slot->slotL != -1) { + status = msmStreamGetStatus(slot->slotL); } - return var_r4; + return status; } -static inline void msmStreamInline04(msmStreamUnk20Struct* arg0) { - s32 var_r10; - s32 temp_var; +static void msmStreamUpdateBaseParam(MSM_STREAM_SLOT* slot) { + s32 pan; + s32 vol; - if (StreamInfo.unk12 != 0) { - var_r10 = arg0->unk0C + arg0->unk0D - 0x40; - if (var_r10 < 0) { - var_r10 = 0; + if (StreamInfo.outputMode != 0) { + pan = slot->panBase + slot->pan - 64; + if (pan < 0) { + pan = 0; } - if (var_r10 > 0x7F) { - var_r10 = 0x7F; + if (pan > 127) { + pan = 127; } } else { - var_r10 = 0x40; + pan = 64; } - temp_var = arg0->unk08 * arg0->unk09 * arg0->unk0A * arg0->unk0B / 2048383; - sndStreamMixParameterEx(arg0->unk00, temp_var * StreamInfo.unk11 / 127, var_r10, arg0->unk2C, arg0->unk2D, arg0->unk2E); + vol = slot->volBase * slot->vol * slot->volFade * slot->pauseVol / (127*127*127); + sndStreamMixParameterEx(slot->stid, vol * StreamInfo.masterVol / 127, pan, slot->span, slot->auxA, slot->auxB); } -void msmStreamSetMasterVolume(s32 arg0) { - s32 var_r27; +void msmStreamSetMasterVolume(s32 vol) { + s32 i; - StreamInfo.unk11 = arg0 & 0x7F; - for (var_r27 = 0; var_r27 < StreamInfo.unk44; var_r27++) { - if (StreamInfo.unk20[var_r27].unk06 != 0) { - msmStreamInline04(&StreamInfo.unk20[var_r27]); + StreamInfo.masterVol = vol & 127; + for (i = 0; i < StreamInfo.header.chanMax; i++) { + if (StreamInfo.slot[i].status != 0) { + msmStreamUpdateBaseParam(&StreamInfo.slot[i]); } } } -static inline BOOL msmStreamInline01(msmStreamUnk20Struct* arg0) { - if (arg0->unk06 != 0 || arg0->unk3C_5 != 0) { +static inline BOOL msmStreamIsPlay(MSM_STREAM_SLOT* slot) { + if (slot->status != 0 || slot->pauseF != 0) { return TRUE; } else { return FALSE; } } -void msmStreamStopAll(s32 speed) { - msmStreamUnk20Struct* temp_r29; - s32 var_r28; +void msmStreamStopAll(s32 speed) +{ + MSM_STREAM_SLOT* slot; + s32 i; msmSysIrqDisable(); - for (var_r28 = 0; var_r28 < StreamInfo.unk44; var_r28++) { - if (var_r28 >= 0 && var_r28 < StreamInfo.unk44) { - temp_r29 = &StreamInfo.unk20[var_r28]; - if (msmStreamInline01(temp_r29)) { + for (i = 0; i < StreamInfo.header.chanMax; i++) { + if (i >= 0 && i < StreamInfo.header.chanMax) { + slot = &StreamInfo.slot[i]; + if (msmStreamIsPlay(slot)) { msmSysIrqDisable(); - msmStreamStopSub(var_r28, speed); - if (temp_r29->unk0E != -1) { - msmStreamStopSub(temp_r29->unk0E, speed); + msmStreamStopSub(i, speed); + if (slot->slotL != -1) { + msmStreamStopSub(slot->slotL, speed); } - if (temp_r29->unk0F != -1) { - msmStreamStopSub(temp_r29->unk0F, speed); + if (slot->slotR != -1) { + msmStreamStopSub(slot->slotR, speed); } msmSysIrqEnable(); } @@ -220,38 +192,38 @@ void msmStreamStopAll(s32 speed) { msmSysIrqEnable(); } -static inline void msmStreamInline03(int streamNo, s32 speed) { - msmStreamUnk20Struct* temp_ptr = &StreamInfo.unk20[streamNo]; +static inline void msmStreamSetFade(int streamNo, s32 speed) { + MSM_STREAM_SLOT* slot = &StreamInfo.slot[streamNo]; - if (temp_ptr->unk3C_5 != 0) { - temp_ptr->unk3C_5 = 0; + if (slot->pauseF != 0) { + slot->pauseF = 0; speed = 0; } - temp_ptr->unk24 = speed / 15; - if (temp_ptr->unk24 != 0) { - temp_ptr->unk28 = temp_ptr->unk24; - temp_ptr->unk0A = 0x7F; + slot->fadeMaxTime = speed / 15; + if (slot->fadeMaxTime != 0) { + slot->fadeTime = slot->fadeMaxTime; + slot->volFade = 127; } else { msmStreamSlotOff(streamNo); } } s32 msmStreamStop(int streamNo, s32 speed) { - msmStreamUnk20Struct* temp_r31; + MSM_STREAM_SLOT* slot; s32 unused; - if (streamNo < 0 || streamNo >= StreamInfo.unk44) { - return MSM_ERR_8C; + if (streamNo < 0 || streamNo >= StreamInfo.header.chanMax) { + return MSM_ERR_RANGE_STREAM; } - temp_r31 = &StreamInfo.unk20[streamNo]; - if (msmStreamInline01(temp_r31)) { + slot = &StreamInfo.slot[streamNo]; + if (msmStreamIsPlay(slot)) { msmSysIrqDisable(); - msmStreamInline03(streamNo, speed); - if (temp_r31->unk0E != -1) { - msmStreamInline03(temp_r31->unk0E, speed); + msmStreamSetFade(streamNo, speed); + if (slot->slotL != -1) { + msmStreamSetFade(slot->slotL, speed); } - if (temp_r31->unk0F != -1) { - msmStreamInline03(temp_r31->unk0F, speed); + if (slot->slotR != -1) { + msmStreamSetFade(slot->slotR, speed); } msmSysIrqEnable(); } @@ -259,13 +231,13 @@ s32 msmStreamStop(int streamNo, s32 speed) { } int msmStreamPlay(int streamId, MSM_STREAMPARAM* streamParam) { - if (streamId < 0 || streamId >= StreamInfo.unk42) { + if (streamId < 0 || streamId >= StreamInfo.header.streamMax) { return MSM_ERR_INVALIDID; } - if (StreamInfo.unk14[streamId] == 0) { + if (StreamInfo.streamPackList[streamId] == 0) { return MSM_ERR_REMOVEDID; } - if (StreamInfo.unk18[StreamInfo.unk14[streamId] - StreamInfo.unk58] & 1) { + if (StreamInfo.streamPackFlag[StreamInfo.streamPackList[streamId] - StreamInfo.header.streamPackOfs] & MSM_STREAM_FLAG_STEREO) { return msmStreamPackStartStereo(streamId, streamParam, 0); } else { return msmStreamPackStartMono(streamId, streamParam, 0); @@ -273,785 +245,785 @@ int msmStreamPlay(int streamId, MSM_STREAMPARAM* streamParam) { } void msmStreamPeriodicProc(void) { - msmStreamUnk20Struct* temp_r28; - s32 var_r27; + MSM_STREAM_SLOT* slot; + s32 i; - StreamInfo.unk10 = 0; - for (var_r27 = 0; var_r27 < StreamInfo.unk44; var_r27++) { - temp_r28 = &StreamInfo.unk20[var_r27]; - msmStreamFade(var_r27); - msmStreamPauseOff(var_r27); - msmStreamPauseFade(var_r27); - if (temp_r28->unk06 != 0) { - StreamInfo.unk10++; + StreamInfo.time = 0; + for (i = 0; i < StreamInfo.header.chanMax; i++) { + slot = &StreamInfo.slot[i]; + msmStreamFade(i); + msmStreamPauseOff(i); + msmStreamPauseFade(i); + if (slot->status != 0) { + StreamInfo.time++; } } } -void msmStreamSetOutputMode(s32 arg0) { - s32 var_r27; +void msmStreamSetOutputMode(s32 outputMode) { + s32 i; - StreamInfo.unk12 = arg0; - for (var_r27 = 0; var_r27 < StreamInfo.unk44; var_r27++) { - if (StreamInfo.unk20[var_r27].unk06 != 0) { - msmStreamInline04(&StreamInfo.unk20[var_r27]); + StreamInfo.outputMode = outputMode; + for (i = 0; i < StreamInfo.header.chanMax; i++) { + if (StreamInfo.slot[i].status != 0) { + msmStreamUpdateBaseParam(&StreamInfo.slot[i]); } } } void msmStreamAmemFree(void) { - u32 var_r29; + u32 i; - for (var_r29 = 0; var_r29 < StreamInfo.unk44; var_r29++) { - sndStreamFree(StreamInfo.unk20[var_r29].unk00); + for (i = 0; i < StreamInfo.header.chanMax; i++) { + sndStreamFree(StreamInfo.slot[i].stid); } } s32 msmStreamAmemAlloc(void) { - u32 var_r25; - msmStreamUnk20Struct* temp_r24; + u32 i; + MSM_STREAM_SLOT* slot; - for (var_r25 = 0; var_r25 < StreamInfo.unk44; var_r25++) { - temp_r24 = &StreamInfo.unk20[var_r25]; - temp_r24->unk06 = 0; - temp_r24->unk0F = -1; - temp_r24->unk0E = -1; - temp_r24->unk30 = msmMemAlloc(StreamInfo.unk04); - if (temp_r24->unk30 == NULL) { + for (i = 0; i < StreamInfo.header.chanMax; i++) { + slot = &StreamInfo.slot[i]; + slot->status = 0; + slot->slotR = -1; + slot->slotL = -1; + slot->streamBuf = msmMemAlloc(StreamInfo.bufSize); + if (slot->streamBuf == NULL) { return MSM_ERR_OUTOFMEM; } - temp_r24->unk34 = StreamInfo.unk04; - temp_r24->unk38 = StreamInfo.unk08; - temp_r24->unk00 = sndStreamAllocEx(0xFF, temp_r24->unk30, temp_r24->unk38, StreamInfo.unk48, 0, 0x40, 0, 0, 0, 0, 0x30001, msmStreamUpdateFunc, var_r25, NULL); - if (temp_r24->unk00 == -1) { + slot->streamBufSize = StreamInfo.bufSize; + slot->streamFrq = StreamInfo.frq; + slot->stid = sndStreamAllocEx(0xFF, slot->streamBuf, slot->streamFrq, StreamInfo.header.sampleFrq, 0, 64, 0, 0, 0, 0, 0x30001, msmStreamUpdateFunc, i, NULL); + if (slot->stid == -1) { return MSM_ERR_STREAMALLOC_FAIL; } } - return StreamInfo.unk04 * StreamInfo.unk44; + return StreamInfo.bufSize * StreamInfo.header.chanMax; } -s32 msmStreamInit(char* arg0) { - DVDFileInfo spC; - s32 temp_r27; +s32 msmStreamInit(char *pdtPath) { + DVDFileInfo file; + s32 size; - StreamInfo.unk42 = 0; - StreamInfo.unk44 = 0; - StreamInfo.unk11 = 0x7F; - StreamInfo.unk10 = 0; - if (arg0 == NULL) { + StreamInfo.header.streamMax = 0; + StreamInfo.header.chanMax = 0; + StreamInfo.masterVol = 127; + StreamInfo.time = 0; + if (pdtPath == NULL) { return 0; } - StreamInfo.unk0C = DVDConvertPathToEntrynum(arg0); - if (StreamInfo.unk0C == -1) { + StreamInfo.pdtEntryNum = DVDConvertPathToEntrynum(pdtPath); + if (StreamInfo.pdtEntryNum == -1) { return MSM_ERR_OPENFAIL; } - if (!msmFioOpen(StreamInfo.unk0C, &spC)) { + if (!msmFioOpen(StreamInfo.pdtEntryNum, &file)) { return MSM_ERR_OPENFAIL; } - if (msmFioRead(&spC, &StreamInfo.unk40, 0x20, 0) < 0) { - msmFioClose(&spC); + if (msmFioRead(&file, &StreamInfo.header, 0x20, 0) < 0) { + msmFioClose(&file); return MSM_ERR_READFAIL; } - if (StreamInfo.unk40 != 1) { - msmFioClose(&spC); + if (StreamInfo.header.version != MSM_PDT_FILE_VERSION) { + msmFioClose(&file); return MSM_ERR_INVALIDFILE; } - if (StreamInfo.unk42 != 0) { - temp_r27 = (StreamInfo.unk54 - StreamInfo.unk50 + 0x1F) & ~0x1F; - StreamInfo.unk14 = msmMemAlloc(temp_r27); - if (StreamInfo.unk14 == NULL) { - msmFioClose(&spC); + if (StreamInfo.header.streamMax != 0) { + size = (StreamInfo.header.adpcmParamOfs - StreamInfo.header.streamPackListOfs + 0x1F) & ~0x1F; + StreamInfo.streamPackList = msmMemAlloc(size); + if (StreamInfo.streamPackList == NULL) { + msmFioClose(&file); return MSM_ERR_OUTOFMEM; } - if (msmFioRead(&spC, StreamInfo.unk14, temp_r27, StreamInfo.unk50) < 0) { - msmFioClose(&spC); + if (msmFioRead(&file, StreamInfo.streamPackList, size, StreamInfo.header.streamPackListOfs) < 0) { + msmFioClose(&file); return MSM_ERR_READFAIL; } - temp_r27 = (StreamInfo.unk5C - StreamInfo.unk58 + 0x1F) & ~0x1F; - StreamInfo.unk18 = msmMemAlloc(temp_r27); - if (StreamInfo.unk18 == NULL) { - msmFioClose(&spC); + size = (StreamInfo.header.sampleOfs - StreamInfo.header.streamPackOfs + 0x1F) & ~0x1F; + StreamInfo.streamPackFlag = msmMemAlloc(size); + if (StreamInfo.streamPackFlag == NULL) { + msmFioClose(&file); return MSM_ERR_OUTOFMEM; } - if (msmFioRead(&spC, StreamInfo.unk18, temp_r27, StreamInfo.unk58) < 0) { - msmFioClose(&spC); + if (msmFioRead(&file, StreamInfo.streamPackFlag, size, StreamInfo.header.streamPackOfs) < 0) { + msmFioClose(&file); return MSM_ERR_READFAIL; } - temp_r27 = StreamInfo.unk58 - StreamInfo.unk54; - StreamInfo.unk1C = msmMemAlloc(temp_r27); - if (StreamInfo.unk1C == NULL) { - msmFioClose(&spC); + size = StreamInfo.header.streamPackOfs - StreamInfo.header.adpcmParamOfs; + StreamInfo.adpcmParam = msmMemAlloc(size); + if (StreamInfo.adpcmParam == NULL) { + msmFioClose(&file); return MSM_ERR_OUTOFMEM; } - if (msmFioRead(&spC, StreamInfo.unk1C, temp_r27, StreamInfo.unk54) < 0) { - msmFioClose(&spC); + if (msmFioRead(&file, StreamInfo.adpcmParam, size, StreamInfo.header.adpcmParamOfs) < 0) { + msmFioClose(&file); return MSM_ERR_READFAIL; } } - msmFioClose(&spC); - StreamInfo.unk00 = (StreamInfo.unk48 + 13) / 14; - StreamInfo.unk04 = (8 * StreamInfo.unk00 * StreamInfo.unk4C + 0x3F) & ~0x3F; - StreamInfo.unk08 = (StreamInfo.unk04 / 8) * 14; - StreamInfo.unk20 = msmMemAlloc(StreamInfo.unk44 * sizeof(*StreamInfo.unk20)); - memset(StreamInfo.unk20, 0, StreamInfo.unk44 * sizeof(*StreamInfo.unk20)); + msmFioClose(&file); + StreamInfo.sampleFrq = (StreamInfo.header.sampleFrq + (SND_STREAM_ADPCM_BLKSIZE-1)) / SND_STREAM_ADPCM_BLKSIZE ; + StreamInfo.bufSize = (8 * StreamInfo.sampleFrq * StreamInfo.header.maxBufs + 0x3F) & ~0x3F; + StreamInfo.frq = (StreamInfo.bufSize / SND_STREAM_ADPCM_BLKBYTES ) * SND_STREAM_ADPCM_BLKSIZE; + StreamInfo.slot = msmMemAlloc(StreamInfo.header.chanMax * sizeof(*StreamInfo.slot)); + memset(StreamInfo.slot, 0, StreamInfo.header.chanMax * sizeof(*StreamInfo.slot)); return 0; } -void msmStreamPauseOff(s32 arg0) { - msmStreamUnk20Struct* temp_r31; - u32 temp_r3; - u32 var_r30; +static void msmStreamPauseOff(s32 streamNo) { + MSM_STREAM_SLOT* slot; + u32 ofs; + u32 readSize; - temp_r31 = &StreamInfo.unk20[arg0]; - if (temp_r31->unk14 == 0) { + slot = &StreamInfo.slot[streamNo]; + if (slot->pauseTime == 0) { return; } - if (temp_r31->unk3C_5 == 0) { - temp_r31->unk14 = 0; + if (slot->pauseF == 0) { + slot->pauseTime = 0; return; } - if (temp_r31->unk18 != 0) { - temp_r31->unk18 = -(temp_r31->unk14 + 1); - if (temp_r31->unk18 == 0) { - temp_r31->unk0B = 0x7F; - msmStreamInline04(temp_r31); + if (slot->pauseTimeMax != 0) { + slot->pauseTimeMax = -(slot->pauseTime + 1); + if (slot->pauseTimeMax == 0) { + slot->pauseVol = 127; + msmStreamUpdateBaseParam(slot); } - temp_r31->unk14 = 0; - temp_r31->unk3C_5 = 0; - } else if (temp_r31->unk06 == 0 && DVDFastOpen(StreamInfo.unk0C, &temp_r31->unk70) == TRUE) { - if (--temp_r31->unk14 != 0) { - temp_r31->unk18 = -temp_r31->unk14; - temp_r31->unk1C = 0; - temp_r31->unk0B = 0; + slot->pauseTime = 0; + slot->pauseF = 0; + } else if (slot->status == 0 && DVDFastOpen(StreamInfo.pdtEntryNum, &slot->file) == TRUE) { + if (--slot->pauseTime != 0) { + slot->pauseTimeMax = -slot->pauseTime; + slot->fadeVol = 0; + slot->pauseVol = 0; } else { - temp_r31->unk0B = 0x7F; + slot->pauseVol = 127; } - temp_r31->unk14 = 0; - temp_r31->unk3C_1 = 1; - temp_r31->unk3C_2 = 0; - temp_r31->unk3C_4 = 0; - temp_r31->unk3C_5 = 0; - temp_r31->unk3C_6 = 0; - temp_r31->unk3C_0 = 1; - temp_r31->unk64 = temp_r31->unk68 = (temp_r31->unk10 / 8) * 14; - temp_r31->unk6C = 0; - temp_r31->unk4C = temp_r31->unk10; - var_r30 = temp_r31->unk34 / 2; - if ((temp_r3 = temp_r31->unk50 - temp_r31->unk4C) < temp_r31->unk34 / 2) { - var_r30 = temp_r3; - temp_r31->unk58 = temp_r31->unk34 / 2 - temp_r3; - temp_r31->unk5C = (void*) ((u32) temp_r31->unk30 + temp_r3); - memset(temp_r31->unk5C, 0, temp_r31->unk58); + slot->pauseTime = 0; + slot->firstF = TRUE; + slot->streamOffF = 0; + slot->shutdownF = 0; + slot->pauseF = 0; + slot->updateAramF = 0; + slot->bufNo = 1; + slot->unk64 = slot->unk68 = (slot->pauseLen / SND_STREAM_ADPCM_BLKBYTES) * SND_STREAM_ADPCM_BLKSIZE; + slot->unk6C = 0; + slot->streamPos = slot->pauseLen; + readSize = slot->streamBufSize / 2; + if ((ofs = slot->loopLen - slot->streamPos) < slot->streamBufSize / 2) { + readSize = ofs; + slot->streamReadSize = slot->streamBufSize / 2 - ofs; + slot->streamReadBuf = (void*) ((u32) slot->streamBuf + ofs); + memset(slot->streamReadBuf, 0, slot->streamReadSize); } - temp_r31->unk06 = 2; - temp_r31->unk4C += var_r30; - temp_r31->unk3C_3 = 1; - DVDReadAsync(&temp_r31->unk70, temp_r31->unk30, var_r30, temp_r31->unk48 + (temp_r31->unk4C - var_r30), msmStreamDvdCallback); + slot->status = 2; + slot->streamPos += readSize; + slot->readBusyF = TRUE; + DVDReadAsync(&slot->file, slot->streamBuf, readSize, slot->streamBaseOfs + (slot->streamPos - readSize), msmStreamDvdCallback); } } -static inline void msmStreamInline05(s32 streamNo) { - msmStreamUnk20Struct* temp_r31; +static inline void msmStreamOff(s32 streamNo) { + MSM_STREAM_SLOT* slot; - temp_r31 = &StreamInfo.unk20[streamNo]; - switch (temp_r31->unk06) { + slot = &StreamInfo.slot[streamNo]; + switch (slot->status) { case 2: - temp_r31->unk3C_4 = 1; - temp_r31->unk06 = 5; + slot->shutdownF = TRUE; + slot->status = 5; break; case 3: - msmStreamInline00(streamNo); + msmStreamClose(streamNo); break; case 4: - if (temp_r31->unk3C_2 == 0) { - sndStreamMixParameterEx(temp_r31->unk00, 0, 0x40, 0, 0, 0); - temp_r31->unk3C_2 = 1; - temp_r31->unk06 = 5; + if (slot->streamOffF == FALSE) { + sndStreamMixParameterEx(slot->stid, 0, 64, 0, 0, 0); + slot->streamOffF = TRUE; + slot->status = 5; } break; } } -void msmStreamPauseOn(s32 streamNo, s32 arg1) { - msmStreamUnk20Struct* temp_r31; +static void msmStreamPauseOn(s32 streamNo, s32 speed) { + MSM_STREAM_SLOT* slot; - temp_r31 = &StreamInfo.unk20[streamNo]; - temp_r31->unk14 = 0; - if (temp_r31->unk3C_5 != 0) { + slot = &StreamInfo.slot[streamNo]; + slot->pauseTime = 0; + if (slot->pauseF != 0) { return; } - temp_r31->unk3C_5 = 1; - temp_r31->unk18 = arg1 / 15; - if (temp_r31->unk18 != 0) { - temp_r31->unk1C = temp_r31->unk18; - temp_r31->unk0B = 0x7F; + slot->pauseF = TRUE; + slot->pauseTimeMax = speed / 15; + if (slot->pauseTimeMax != 0) { + slot->fadeVol = slot->pauseTimeMax; + slot->pauseVol = 127; return; } - temp_r31->unk10 = ((temp_r31->unk64 / 7) * 4) & ~7; - if (temp_r31->unk07 != 0) { - if (temp_r31->unk10 >= temp_r31->unk50 - temp_r31->unk34 / 4) { - temp_r31->unk10 = 0; + slot->pauseLen = ((slot->unk64 / 7) * 4) & ~7; + if (slot->stereoF != 0) { + if (slot->pauseLen >= slot->loopLen - slot->streamBufSize / 4) { + slot->pauseLen = 0; } - } else if (temp_r31->unk10 >= temp_r31->unk50) { - temp_r31->unk3C_5 = 0; + } else if (slot->pauseLen >= slot->loopLen) { + slot->pauseF = 0; } - msmStreamInline05(streamNo); + msmStreamOff(streamNo); } -static void msmStreamPauseFade(s32 arg0) { - msmStreamUnk20Struct* temp_r5; +static void msmStreamPauseFade(s32 streamNo) { + MSM_STREAM_SLOT* slot; - temp_r5 = &StreamInfo.unk20[arg0]; - if (temp_r5->unk06 != 4) { + slot = &StreamInfo.slot[streamNo]; + if (slot->status != 4) { return; } - if (temp_r5->unk18 > 0) { - if (--temp_r5->unk1C == 0) { - temp_r5->unk18 = 0; - temp_r5->unk3C_5 = 0; - msmStreamPauseOn(arg0, 0); + if (slot->pauseTimeMax > 0) { + if (--slot->fadeVol == 0) { + slot->pauseTimeMax = 0; + slot->pauseF = 0; + msmStreamPauseOn(streamNo, 0); } else { - temp_r5->unk0B = temp_r5->unk1C * 0x7F / temp_r5->unk18; - msmStreamInline04(temp_r5); + slot->pauseVol = slot->fadeVol * 127 / slot->pauseTimeMax; + msmStreamUpdateBaseParam(slot); } - } else if (temp_r5->unk18 < 0) { - if (++temp_r5->unk1C >= -temp_r5->unk18) { - temp_r5->unk18 = 0; - temp_r5->unk0B = 0x7F; - msmStreamInline04(temp_r5); + } else if (slot->pauseTimeMax < 0) { + if (++slot->fadeVol >= -slot->pauseTimeMax) { + slot->pauseTimeMax = 0; + slot->pauseVol = 127; + msmStreamUpdateBaseParam(slot); } else { - temp_r5->unk0B = temp_r5->unk1C * 0x7F / -temp_r5->unk18; - msmStreamInline04(temp_r5); + slot->pauseVol = slot->fadeVol * 127 / -slot->pauseTimeMax; + msmStreamUpdateBaseParam(slot); } } } -static void msmStreamFade(s32 arg0) { - msmStreamUnk20Struct* temp_r5; +static void msmStreamFade(s32 streamNo) { + MSM_STREAM_SLOT* slot; - temp_r5 = &StreamInfo.unk20[arg0]; - if (temp_r5->unk06 != 4) { + slot = &StreamInfo.slot[streamNo]; + if (slot->status != 4) { return; } - if (temp_r5->unk24 > 0) { - if (--temp_r5->unk28 == 0) { - temp_r5->unk24 = 0; - msmStreamInline03(arg0, 0); + if (slot->fadeMaxTime > 0) { + if (--slot->fadeTime == 0) { + slot->fadeMaxTime = 0; + msmStreamSetFade(streamNo, 0); } else { - temp_r5->unk0A = temp_r5->unk28 * 0x7F / temp_r5->unk24; - msmStreamInline04(temp_r5); + slot->volFade = slot->fadeTime * 127 / slot->fadeMaxTime; + msmStreamUpdateBaseParam(slot); } - } else if (temp_r5->unk24 < 0) { - if (++temp_r5->unk28 >= -temp_r5->unk24) { - temp_r5->unk24 = 0; - temp_r5->unk0A = 0x7F; - msmStreamInline04(temp_r5); + } else if (slot->fadeMaxTime < 0) { + if (++slot->fadeTime >= -slot->fadeMaxTime) { + slot->fadeMaxTime = 0; + slot->volFade = 127; + msmStreamUpdateBaseParam(slot); } else { - temp_r5->unk0A = temp_r5->unk28 * 0x7F / -temp_r5->unk24; - msmStreamInline04(temp_r5); + slot->volFade = slot->fadeTime * 127 / -slot->fadeMaxTime; + msmStreamUpdateBaseParam(slot); } } } static void msmStreamStopSub(s32 streamNo, s32 speed) { - msmStreamUnk20Struct* temp_r31; - s32 var_r4; + MSM_STREAM_SLOT* slot; + s32 time; - var_r4 = speed; - temp_r31 = &StreamInfo.unk20[streamNo]; - if (temp_r31->unk3C_5 != 0) { - temp_r31->unk3C_5 = 0; - var_r4 = 0; + time = speed; + slot = &StreamInfo.slot[streamNo]; + if (slot->pauseF != 0) { + slot->pauseF = 0; + time = 0; } - temp_r31->unk24 = var_r4 / 15; - if (temp_r31->unk24 != 0) { - temp_r31->unk28 = temp_r31->unk24; - temp_r31->unk0A = 0x7F; + slot->fadeMaxTime = time / 15; + if (slot->fadeMaxTime != 0) { + slot->fadeTime = slot->fadeMaxTime; + slot->volFade = 127; return; } - msmStreamInline05(streamNo); + msmStreamOff(streamNo); } -static void msmStreamSetParamSub(msmStreamUnk20Struct* arg0) { - int var_r10; - s32 temp_var; +static void msmStreamSetParamSub(MSM_STREAM_SLOT* slot) { + int pan; + s32 vol; - if (StreamInfo.unk12 != 0) { - var_r10 = arg0->unk0C + arg0->unk0D - 0x40; - if (var_r10 < 0) { - var_r10 = 0; + if (StreamInfo.outputMode != 0) { + pan = slot->panBase + slot->pan - 64; + if (pan < 0) { + pan = 0; } - if (var_r10 > 0x7F) { - var_r10 = 0x7F; + if (pan > 127) { + pan = 127; } } else { - var_r10 = 0x40; + pan = 64; } - temp_var = arg0->unk08 * arg0->unk09 * arg0->unk0A * arg0->unk0B / 2048383; - sndStreamMixParameterEx(arg0->unk00, temp_var * StreamInfo.unk11 / 127, var_r10, arg0->unk2C, arg0->unk2D, arg0->unk2E); + vol = slot->volBase * slot->vol * slot->volFade * slot->pauseVol / (127*127*127); + sndStreamMixParameterEx(slot->stid, vol * StreamInfo.masterVol / 127, pan, slot->span, slot->auxA, slot->auxB); } -s32 msmStreamPackStartStereo(s32 arg0, MSM_STREAMPARAM* arg1, s32 arg2) { - s32 var_r29; - s32 var_r28; - s32 var_r27; - u32 temp_r3_3; - u32 temp_r3_4; - StructSlotInitArg2 sp1C; - msmStreamUnk20Struct* temp_r25; - msmStreamUnk20Struct* temp_r24; - StructSlotInitArg1* temp_r23; +static s32 msmStreamPackStartStereo(s32 streamId, MSM_STREAMPARAM *param, s32 sampleOfs) { + s32 flag; + s32 chanL; + s32 chanR; + u32 sizeL; + u32 sizeR; + STREAM_PARAM streamParam; + MSM_STREAM_SLOT* slotL; + MSM_STREAM_SLOT* slotR; + MSM_STREAM_PACK* pack; - var_r29 = (arg1 != NULL) ? arg1->flag : 0; - if (var_r29 & MSM_STREAMPARAM_CHAN) { - var_r28 = arg1->chan; - var_r27 = arg1->chan + 1; - if (var_r28 < 0 || var_r28 >= StreamInfo.unk44) { - return MSM_ERR_6E; + flag = (param != NULL) ? param->flag : 0; + if (flag & MSM_STREAMPARAM_CHAN) { + chanL = param->chan; + chanR = param->chan + 1; + if (chanL < 0 || chanL >= StreamInfo.header.chanMax) { + return MSM_ERR_CHANLIMIT; } - if (var_r27 < 0 || var_r27 >= StreamInfo.unk44) { - return MSM_ERR_6E; + if (chanR < 0 || chanR >= StreamInfo.header.chanMax) { + return MSM_ERR_CHANLIMIT; } - if (msmStreamInline01(&StreamInfo.unk20[var_r28])) { - return MSM_ERR_6E; + if (msmStreamIsPlay(&StreamInfo.slot[chanL])) { + return MSM_ERR_CHANLIMIT; } - if (msmStreamInline01(&StreamInfo.unk20[var_r27])) { - return MSM_ERR_6E; + if (msmStreamIsPlay(&StreamInfo.slot[chanR])) { + return MSM_ERR_CHANLIMIT; } } else { - for (var_r28 = 0; var_r28 < StreamInfo.unk44; var_r28++) { - if (!msmStreamInline01(&StreamInfo.unk20[var_r28])) { + for (chanL = 0; chanL < StreamInfo.header.chanMax; chanL++) { + if (!msmStreamIsPlay(&StreamInfo.slot[chanL])) { break; } } - for (var_r27 = var_r28 + 1; var_r27 < StreamInfo.unk44; var_r27++) { - if (!msmStreamInline01(&StreamInfo.unk20[var_r27])) { + for (chanR = chanL + 1; chanR < StreamInfo.header.chanMax; chanR++) { + if (!msmStreamIsPlay(&StreamInfo.slot[chanR])) { break; } } - if (var_r28 == StreamInfo.unk44 || var_r27 == StreamInfo.unk44) { - return MSM_ERR_6E; + if (chanL == StreamInfo.header.chanMax || chanR == StreamInfo.header.chanMax) { + return MSM_ERR_CHANLIMIT; } } - temp_r25 = &StreamInfo.unk20[var_r28]; - temp_r24 = &StreamInfo.unk20[var_r27]; - temp_r23 = (StructSlotInitArg1*) ((u32) StreamInfo.unk18 + (StreamInfo.unk14[arg0] - StreamInfo.unk58)); - sp1C.unk00 = (var_r29 & MSM_STREAMPARAM_VOL) ? arg1->vol : 0x7F; - sp1C.unk02 = (var_r29 & MSM_STREAMPARAM_SPAN) ? arg1->span : (s32) temp_r23->unk03; - sp1C.unk03 = (var_r29 & MSM_STREAMPARAM_AUXA) ? arg1->auxA : (s32) temp_r23->unk04; - sp1C.unk04 = (var_r29 & MSM_STREAMPARAM_AUXB) ? arg1->auxB : (s32) temp_r23->unk05; - sp1C.unk08 = arg2; + slotL = &StreamInfo.slot[chanL]; + slotR = &StreamInfo.slot[chanR]; + pack = (MSM_STREAM_PACK*) ((u32) StreamInfo.streamPackFlag + (StreamInfo.streamPackList[streamId] - StreamInfo.header.streamPackOfs)); + streamParam.vol = (flag & MSM_STREAMPARAM_VOL) ? param->vol : 127; + streamParam.span = (flag & MSM_STREAMPARAM_SPAN) ? param->span : (s32) pack->span; + streamParam.auxA = (flag & MSM_STREAMPARAM_AUXA) ? param->auxA : (s32) pack->auxA; + streamParam.auxB = (flag & MSM_STREAMPARAM_AUXB) ? param->auxB : (s32) pack->auxB; + streamParam.sampleOfs = sampleOfs; msmSysIrqDisable(); - sp1C.unk01 = 0; - temp_r3_3 = msmStreamSlotInit(temp_r25, temp_r23, &sp1C, 0); - sp1C.unk01 = 0x7F; - temp_r3_4 = msmStreamSlotInit(temp_r24, temp_r23, &sp1C, 1); - temp_r25->unk04 = arg0; - temp_r24->unk04 = -1; - temp_r25->unk0E = var_r27; - temp_r24->unk0F = var_r28; - if ((var_r29 & MSM_STREAMPARAM_FADESPEED) && arg1->fadeSpeed != 0) { - temp_r25->unk24 = temp_r24->unk24 = -arg1->fadeSpeed / 15; - temp_r25->unk28 = temp_r24->unk28 = 0; - temp_r25->unk0A = temp_r24->unk0A = 0; + streamParam.pan = 0; + sizeL = msmStreamSlotInit(slotL, pack, &streamParam, 0); + streamParam.pan = 127; + sizeR = msmStreamSlotInit(slotR, pack, &streamParam, 1); + slotL->streamId = streamId; + slotR->streamId = -1; + slotL->slotL = chanR; + slotR->slotR = chanL; + if ((flag & MSM_STREAMPARAM_FADESPEED) && param->fadeSpeed != 0) { + slotL->fadeMaxTime = slotR->fadeMaxTime = -param->fadeSpeed / 15; + slotL->fadeTime = slotR->fadeTime = 0; + slotL->volFade = slotR->volFade = 0; } msmSysIrqEnable(); - if (temp_r3_3 == 0) { + if (sizeL == 0) { return 0; } - if (var_r29 & MSM_STREAMPARAM_PAUSE) { - temp_r25->unk3C_5 = temp_r24->unk3C_5 = 1; - temp_r25->unk06 = temp_r24->unk06 = 0; - return var_r28; + if (flag & MSM_STREAMPARAM_PAUSE) { + slotL->pauseF = slotR->pauseF = 1; + slotL->status = slotR->status = 0; + return chanL; } - if (DVDFastOpen(StreamInfo.unk0C, &temp_r25->unk70) != 1) { + if (DVDFastOpen(StreamInfo.pdtEntryNum, &slotL->file) != 1) { return MSM_ERR_OPENFAIL; } - if (DVDFastOpen(StreamInfo.unk0C, &temp_r24->unk70) != 1) { - DVDClose(&temp_r25->unk70); + if (DVDFastOpen(StreamInfo.pdtEntryNum, &slotR->file) != 1) { + DVDClose(&slotL->file); return MSM_ERR_OPENFAIL; } - temp_r25->unk4C += temp_r3_3; - temp_r24->unk4C += temp_r3_4; - temp_r25->unk3C_3 = 1; - DVDReadAsync(&temp_r25->unk70, temp_r25->unk30, temp_r3_3, temp_r25->unk48 + (temp_r25->unk4C - temp_r3_3), msmStreamDvdCallback); - temp_r24->unk3C_3 = 1; - DVDReadAsync(&temp_r24->unk70, temp_r24->unk30, temp_r3_4, temp_r24->unk48 + (temp_r24->unk4C - temp_r3_4), msmStreamDvdCallback); - return var_r28; + slotL->streamPos += sizeL; + slotR->streamPos += sizeR; + slotL->readBusyF = 1; + DVDReadAsync(&slotL->file, slotL->streamBuf, sizeL, slotL->streamBaseOfs + (slotL->streamPos - sizeL), msmStreamDvdCallback); + slotR->readBusyF = 1; + DVDReadAsync(&slotR->file, slotR->streamBuf, sizeR, slotR->streamBaseOfs + (slotR->streamPos - sizeR), msmStreamDvdCallback); + return chanL; } -s32 msmStreamPackStartMono(s32 arg0, MSM_STREAMPARAM* arg1, s32 arg2) { - s32 var_r30; - s32 var_r29; - u32 temp_r3_2; - StructSlotInitArg2 sp18; - msmStreamUnk20Struct* temp_r27; - StructSlotInitArg1* temp_r25; +static s32 msmStreamPackStartMono(s32 streamId, MSM_STREAMPARAM *param, s32 sampleOfs) { + s32 flag; + s32 chan; + u32 size; + STREAM_PARAM streamParam; + MSM_STREAM_SLOT* slot; + MSM_STREAM_PACK* pack; - var_r30 = (arg1 != NULL) ? arg1->flag : 0; - if (var_r30 & MSM_STREAMPARAM_CHAN) { - var_r29 = arg1->chan; - if (var_r29 < 0 || var_r29 >= StreamInfo.unk44) { - return MSM_ERR_6E; + flag = (param != NULL) ? param->flag : 0; + if (flag & MSM_STREAMPARAM_CHAN) { + chan = param->chan; + if (chan < 0 || chan >= StreamInfo.header.chanMax) { + return MSM_ERR_CHANLIMIT; } - if (msmStreamInline01(&StreamInfo.unk20[var_r29])) { - return MSM_ERR_6E; + if (msmStreamIsPlay(&StreamInfo.slot[chan])) { + return MSM_ERR_CHANLIMIT; } } else { - for (var_r29 = 0; var_r29 < StreamInfo.unk44; var_r29++) { - if (!msmStreamInline01(&StreamInfo.unk20[var_r29])) { + for (chan = 0; chan < StreamInfo.header.chanMax; chan++) { + if (!msmStreamIsPlay(&StreamInfo.slot[chan])) { break; } } - if (var_r29 == StreamInfo.unk44) { - return MSM_ERR_6E; + if (chan == StreamInfo.header.chanMax) { + return MSM_ERR_CHANLIMIT; } } - temp_r27 = &StreamInfo.unk20[var_r29]; - temp_r25 = (StructSlotInitArg1*) ((u32) StreamInfo.unk18 + (StreamInfo.unk14[arg0] - StreamInfo.unk58)); - sp18.unk00 = (var_r30 & MSM_STREAMPARAM_VOL) ? arg1->vol : 0x7F; - sp18.unk01 = (var_r30 & MSM_STREAMPARAM_PAN) ? arg1->pan : 0x40; - sp18.unk02 = (var_r30 & MSM_STREAMPARAM_SPAN) ? arg1->span : (s32) temp_r25->unk03; - sp18.unk03 = (var_r30 & MSM_STREAMPARAM_AUXA) ? arg1->auxA : (s32) temp_r25->unk04; - sp18.unk04 = (var_r30 & MSM_STREAMPARAM_AUXB) ? arg1->auxB : (s32) temp_r25->unk05; - sp18.unk08 = arg2; + slot = &StreamInfo.slot[chan]; + pack = (MSM_STREAM_PACK*) ((u32) StreamInfo.streamPackFlag + (StreamInfo.streamPackList[streamId] - StreamInfo.header.streamPackOfs)); + streamParam.vol = (flag & MSM_STREAMPARAM_VOL) ? param->vol : 127; + streamParam.pan = (flag & MSM_STREAMPARAM_PAN) ? param->pan : 64; + streamParam.span = (flag & MSM_STREAMPARAM_SPAN) ? param->span : (s32) pack->span; + streamParam.auxA = (flag & MSM_STREAMPARAM_AUXA) ? param->auxA : (s32) pack->auxA; + streamParam.auxB = (flag & MSM_STREAMPARAM_AUXB) ? param->auxB : (s32) pack->auxB; + streamParam.sampleOfs = sampleOfs; msmSysIrqDisable(); - temp_r3_2 = msmStreamSlotInit(temp_r27, temp_r25, &sp18, 0); - temp_r27->unk04 = arg0; - if ((var_r30 & MSM_STREAMPARAM_FADESPEED) && arg1->fadeSpeed != 0) { - temp_r27->unk24 = -arg1->fadeSpeed / 15; - temp_r27->unk28 = 0; - temp_r27->unk0A = 0; + size = msmStreamSlotInit(slot, pack, &streamParam, 0); + slot->streamId = streamId; + if ((flag & MSM_STREAMPARAM_FADESPEED) && param->fadeSpeed != 0) { + slot->fadeMaxTime = -param->fadeSpeed / 15; + slot->fadeTime = 0; + slot->volFade = 0; } msmSysIrqEnable(); - if (temp_r3_2 == 0) { + if (size == 0) { return 0; } - if (var_r30 & MSM_STREAMPARAM_PAUSE) { - temp_r27->unk3C_5 = 1; - temp_r27->unk06 = 0; - return var_r29; + if (flag & MSM_STREAMPARAM_PAUSE) { + slot->pauseF = TRUE; + slot->status = 0; + return chan; } - if (DVDFastOpen(StreamInfo.unk0C, &temp_r27->unk70) != 1) { + if (DVDFastOpen(StreamInfo.pdtEntryNum, &slot->file) != 1) { return MSM_ERR_OPENFAIL; } - temp_r27->unk4C += temp_r3_2; - temp_r27->unk3C_3 = 1; - DVDReadAsync(&temp_r27->unk70, temp_r27->unk30, temp_r3_2, temp_r27->unk48 + (temp_r27->unk4C - temp_r3_2), msmStreamDvdCallback); - return var_r29; + slot->streamPos += size; + slot->readBusyF = TRUE; + DVDReadAsync(&slot->file, slot->streamBuf, size, slot->streamBaseOfs + (slot->streamPos - size), msmStreamDvdCallback); + return chan; } -// Note: identical to msmStreamInline05. -void msmStreamSlotOff(s32 streamNo) { - msmStreamUnk20Struct* temp_r31; +// Note: identical to msmStreamOff. +static void msmStreamSlotOff(s32 streamNo) { + MSM_STREAM_SLOT* slot; - temp_r31 = &StreamInfo.unk20[streamNo]; - switch (temp_r31->unk06) { + slot = &StreamInfo.slot[streamNo]; + switch (slot->status) { case 2: - temp_r31->unk3C_4 = 1; - temp_r31->unk06 = 5; + slot->shutdownF = 1; + slot->status = 5; break; case 3: - msmStreamInline00(streamNo); + msmStreamClose(streamNo); break; case 4: - if (temp_r31->unk3C_2 == 0) { - sndStreamMixParameterEx(temp_r31->unk00, 0, 0x40, 0, 0, 0); - temp_r31->unk3C_2 = 1; - temp_r31->unk06 = 5; + if (slot->streamOffF == 0) { + sndStreamMixParameterEx(slot->stid, 0, 64, 0, 0, 0); + slot->streamOffF = TRUE; + slot->status = 5; } break; } } -static inline void msmStreamInline06(s32 streamNo) { - msmStreamUnk20Struct* temp_r25; +static void msmStreamShutdown(s32 streamNo) { + MSM_STREAM_SLOT* slot; - temp_r25 = &StreamInfo.unk20[streamNo]; + slot = &StreamInfo.slot[streamNo]; msmStreamSlotOff(streamNo); - sndStreamDeactivate(temp_r25->unk00); - if (temp_r25->unk3C_3 == 0) { - msmStreamInline00(streamNo); + sndStreamDeactivate(slot->stid); + if (slot->readBusyF == 0) { + msmStreamClose(streamNo); } else { - temp_r25->unk3C_4 = 1; + slot->shutdownF = 1; } } -static void msmStreamData(s32 arg0) { - s32 temp_r5; - u32 var_r28; - void* var_r27; - msmStreamUnk20Struct* temp_r26; - s32 var_r24; +static void msmStreamData(s32 streamNo) { + s32 dataSize; + u32 readSize; + void* dataPtr; + MSM_STREAM_SLOT* slot; + s32 off1; - temp_r26 = &StreamInfo.unk20[arg0]; - var_r28 = temp_r5 = temp_r26->unk34 / 2; - var_r27 = (temp_r26->unk3C_0 != 0) - ? (void*) ((u32) temp_r26->unk30 + temp_r5) - : temp_r26->unk30; - temp_r26->unk58 = var_r24 = 0; - if (temp_r26->unk4C + var_r28 > temp_r26->unk50) { - if (temp_r26->unk50 > temp_r26->unk4C) { - var_r28 = temp_r26->unk50 - temp_r26->unk4C; - temp_r26->unk58 = temp_r5 - var_r28; - temp_r26->unk5C = (void*) ((u32) var_r27 + var_r28); - } else if (temp_r26->unk07 != 0) { - temp_r26->unk4C = temp_r26->unk60; + slot = &StreamInfo.slot[streamNo]; + readSize = dataSize = slot->streamBufSize / 2; + dataPtr = (slot->bufNo != 0) + ? (void*) ((u32) slot->streamBuf + dataSize) + : slot->streamBuf; + slot->streamReadSize = off1 = 0; + if (slot->streamPos + readSize > slot->loopLen) { + if (slot->loopLen > slot->streamPos) { + readSize = slot->loopLen - slot->streamPos; + slot->streamReadSize = dataSize - readSize; + slot->streamReadBuf = (void*) ((u32) dataPtr + readSize); + } else if (slot->stereoF != 0) { + slot->streamPos = slot->streamPosStart; } else { - memset(var_r27, 0, temp_r5); - if (temp_r26->unk3C_0 != 0) { - var_r24 = temp_r26->unk38 / 2; + memset(dataPtr, 0, dataSize); + if (slot->bufNo != 0) { + off1 = slot->streamFrq / 2; } - sndStreamARAMUpdate(temp_r26->unk00, var_r24, temp_r26->unk38 / 2, 0, 0); - var_r28 = 0; + sndStreamARAMUpdate(slot->stid, off1, slot->streamFrq / 2, 0, 0); + readSize = 0; } } - if (var_r28 != 0) { - if (DVDGetCommandBlockStatus(&temp_r26->unk70.cb) != 0) { - if (temp_r26->unk3C_6 != 1) { - temp_r26->unk3C_6 = 1; - sndStreamMixParameterEx(temp_r26->unk00, 0, 0x40, 0x40, 0, 0); - memset(temp_r26->unk30, 0, temp_r26->unk34); - sndStreamARAMUpdate(temp_r26->unk00, 0, temp_r26->unk38, 0, 0); + if (readSize != 0) { + if (DVDGetCommandBlockStatus(&slot->file.cb) != 0) { + if (slot->updateAramF != TRUE) { + slot->updateAramF = TRUE; + sndStreamMixParameterEx(slot->stid, 0, 64, 64, 0, 0); + memset(slot->streamBuf, 0, slot->streamBufSize); + sndStreamARAMUpdate(slot->stid, 0, slot->streamFrq, 0, 0); } } else { - if (temp_r26->unk3C_6 == 1) { - temp_r26->unk3C_6 = 0; - msmStreamInline04(temp_r26); + if (slot->updateAramF == TRUE) { + slot->updateAramF = FALSE; + msmStreamUpdateBaseParam(slot); } - temp_r26->unk4C += var_r28; - temp_r26->unk3C_3 = 1; - DVDReadAsync(&temp_r26->unk70, var_r27, var_r28, temp_r26->unk48 + (temp_r26->unk4C - var_r28), msmStreamDvdCallback); + slot->streamPos += readSize; + slot->readBusyF = 1; + DVDReadAsync(&slot->file, dataPtr, readSize, slot->streamBaseOfs + (slot->streamPos - readSize), msmStreamDvdCallback); } - } else if (temp_r26->unk3C_1 != 0) { - temp_r26->unk3C_1= 0; + } else if (slot->firstF != 0) { + slot->firstF= 0; } else { - msmStreamInline06(arg0); + msmStreamShutdown(streamNo); } - temp_r26->unk3C_0 ^= 1; + slot->bufNo ^= 1; } -static inline BOOL msmStreamInline02(s32 streamNo) { - msmStreamUnk20Struct* temp_ptr; +static BOOL msmStreamActivateStream(s32 streamNo) { + MSM_STREAM_SLOT* slot; - temp_ptr = &StreamInfo.unk20[streamNo]; - msmStreamSetParamSub(temp_ptr); - sndStreamFrq(temp_ptr->unk00, temp_ptr->unk40); - sndStreamADPCMParameter(temp_ptr->unk00, temp_ptr->unk44); - sndStreamARAMUpdate(temp_ptr->unk00, 0, temp_ptr->unk38 / 2, 0, 0); - if (sndStreamActivate(temp_ptr->unk00)) { - temp_ptr->unk06 = 4; + slot = &StreamInfo.slot[streamNo]; + msmStreamSetParamSub(slot); + sndStreamFrq(slot->stid, slot->frq); + sndStreamADPCMParameter(slot->stid, slot->adpcmInfo); + sndStreamARAMUpdate(slot->stid, 0, slot->streamFrq / 2, 0, 0); + if (sndStreamActivate(slot->stid)) { + slot->status = 4; msmStreamData(streamNo); return TRUE; } else { - msmStreamInline00(streamNo); + msmStreamClose(streamNo); return FALSE; } } -static void msmStreamDvdCallback(s32 arg0, DVDFileInfo* arg1) { - s32 var_r28; - msmStreamUnk20Struct* temp_r27; +static void msmStreamDvdCallback(s32 result, DVDFileInfo* fileInfo) { + s32 readSize; + MSM_STREAM_SLOT* slot; - for (var_r28 = 0; var_r28 < StreamInfo.unk44; var_r28++) { - if (&StreamInfo.unk20[var_r28].unk70 == arg1) { + for (readSize = 0; readSize < StreamInfo.header.chanMax; readSize++) { + if (&StreamInfo.slot[readSize].file == fileInfo) { break; } } - if (var_r28 == StreamInfo.unk44) { + if (readSize == StreamInfo.header.chanMax) { return; } - temp_r27 = &StreamInfo.unk20[var_r28]; - temp_r27->unk3C_3 = 0; - if (temp_r27->unk3C_4 != 0) { - temp_r27->unk3C_4 = 0; - msmStreamInline00(var_r28); + slot = &StreamInfo.slot[readSize]; + slot->readBusyF = 0; + if (slot->shutdownF != 0) { + slot->shutdownF = 0; + msmStreamClose(readSize); return; } - if (DVDGetCommandBlockStatus(&arg1->cb) == 0) { - switch (temp_r27->unk06) { + if (DVDGetCommandBlockStatus(&fileInfo->cb) == 0) { + switch (slot->status) { case 2: - if (temp_r27->unk0E != -1) { - if (StreamInfo.unk20[temp_r27->unk0E].unk06 != 3) { - temp_r27->unk06 = 3; + if (slot->slotL != -1) { + if (StreamInfo.slot[slot->slotL].status != 3) { + slot->status = 3; break; } - if (!msmStreamInline02(temp_r27->unk0E)) { - temp_r27->unk0E = -1; + if (!msmStreamActivateStream(slot->slotL)) { + slot->slotL = -1; } } - if (temp_r27->unk0F != -1) { - if (StreamInfo.unk20[temp_r27->unk0F].unk06 != 3) { - temp_r27->unk06 = 3; + if (slot->slotR != -1) { + if (StreamInfo.slot[slot->slotR].status != 3) { + slot->status = 3; break; } - if (!msmStreamInline02(temp_r27->unk0F)) { - temp_r27->unk0F = -1; + if (!msmStreamActivateStream(slot->slotR)) { + slot->slotR = -1; } } - if (!msmStreamInline02(var_r28)) { - if (temp_r27->unk0E != -1) { - StreamInfo.unk20[temp_r27->unk0E].unk0F = -1; + if (!msmStreamActivateStream(readSize)) { + if (slot->slotL != -1) { + StreamInfo.slot[slot->slotL].slotR = -1; } - if (temp_r27->unk0F != -1) { - StreamInfo.unk20[temp_r27->unk0F].unk0E = -1; + if (slot->slotR != -1) { + StreamInfo.slot[slot->slotR].slotL = -1; } } break; case 4: - if (temp_r27->unk4C >= temp_r27->unk50) { - if (temp_r27->unk07 != 0) { - temp_r27->unk4C = temp_r27->unk60; - if (temp_r27->unk58 != 0) { - temp_r27->unk3C_3 = 1; - DVDReadAsync(arg1, temp_r27->unk5C, temp_r27->unk58, temp_r27->unk48 + temp_r27->unk4C, msmStreamDvdCallback2); - temp_r27->unk4C += temp_r27->unk58; + if (slot->streamPos >= slot->loopLen) { + if (slot->stereoF != 0) { + slot->streamPos = slot->streamPosStart; + if (slot->streamReadSize != 0) { + slot->readBusyF = 1; + DVDReadAsync(fileInfo, slot->streamReadBuf, slot->streamReadSize, slot->streamBaseOfs + slot->streamPos, msmStreamDvdCallback2); + slot->streamPos += slot->streamReadSize; break; } - } else if (temp_r27->unk58 != 0) { - memset(temp_r27->unk5C, 0, temp_r27->unk58); + } else if (slot->streamReadSize != 0) { + memset(slot->streamReadBuf, 0, slot->streamReadSize); } } - sndStreamARAMUpdate(temp_r27->unk00, (temp_r27->unk3C_0 != 0) ? 0 : temp_r27->unk38 / 2, temp_r27->unk38 / 2, 0, 0); + sndStreamARAMUpdate(slot->stid, (slot->bufNo != 0) ? 0 : slot->streamFrq / 2, slot->streamFrq / 2, 0, 0); break; case 5: - temp_r27->unk3C_4 = 0; - msmStreamInline00(var_r28); + slot->shutdownF = 0; + msmStreamClose(readSize); break; } } else { - if (temp_r27->unk06 == 4) { - sndStreamDeactivate(temp_r27->unk00); + if (slot->status == 4) { + sndStreamDeactivate(slot->stid); } - msmStreamInline00(var_r28); - if (temp_r27->unk0E != -1) { - StreamInfo.unk20[temp_r27->unk0E].unk0F = -1; + msmStreamClose(readSize); + if (slot->slotL != -1) { + StreamInfo.slot[slot->slotL].slotR = -1; } - if (temp_r27->unk0F != -1) { - StreamInfo.unk20[temp_r27->unk0F].unk0E = -1; + if (slot->slotR != -1) { + StreamInfo.slot[slot->slotR].slotL = -1; } } } -static void msmStreamDvdCallback2(s32 arg0, DVDFileInfo* arg1) { - msmStreamUnk20Struct* var_r30; - s32 var_r28; +static void msmStreamDvdCallback2(s32 result, DVDFileInfo* fileInfo) { + MSM_STREAM_SLOT* slot; + s32 readSize; - for (var_r28 = 0; var_r28 < StreamInfo.unk44; var_r28++) { - var_r30 = &StreamInfo.unk20[var_r28]; - if (&var_r30->unk70 == arg1) { + for (readSize = 0; readSize < StreamInfo.header.chanMax; readSize++) { + slot = &StreamInfo.slot[readSize]; + if (&slot->file == fileInfo) { break; } } - if (var_r28 == StreamInfo.unk44) { + if (readSize == StreamInfo.header.chanMax) { return; } - var_r30->unk3C_3 = 0; - if (var_r30->unk3C_4 != 0) { - var_r30->unk3C_4 = 0; - msmStreamInline00(var_r28); - } else if (DVDGetCommandBlockStatus(&arg1->cb) == 0) { - sndStreamARAMUpdate(var_r30->unk00, (var_r30->unk3C_0 != 0) ? 0 : var_r30->unk38 / 2, var_r30->unk38 / 2, 0, 0); + slot->readBusyF = FALSE; + if (slot->shutdownF != 0) { + slot->shutdownF = FALSE; + msmStreamClose(readSize); + } else if (DVDGetCommandBlockStatus(&fileInfo->cb) == 0) { + sndStreamARAMUpdate(slot->stid, (slot->bufNo != 0) ? 0 : slot->streamFrq / 2, slot->streamFrq / 2, 0, 0); } else { - if (var_r30->unk06 == 4) { - sndStreamDeactivate(var_r30->unk00); + if (slot->status == 4) { + sndStreamDeactivate(slot->stid); } - msmStreamInline00(var_r28); - if (var_r30->unk0E != -1) { - StreamInfo.unk20[var_r30->unk0E].unk0F = -1; + msmStreamClose(readSize); + if (slot->slotL != -1) { + StreamInfo.slot[slot->slotL].slotR = -1; } - if (var_r30->unk0F != -1) { - StreamInfo.unk20[var_r30->unk0F].unk0E = -1; + if (slot->slotR != -1) { + StreamInfo.slot[slot->slotR].slotL = -1; } } } static u32 msmStreamUpdateFunc(void* buffer1, u32 len1, void* buffer2, u32 len2, u32 user) { - msmStreamUnk20Struct* temp_r31; - s32 temp_r4; - s32 temp_r0; - s32 var_r3; + MSM_STREAM_SLOT* slot; + s32 len3; + s32 updateLen; + s32 len; - temp_r31 = &StreamInfo.unk20[user]; - if (temp_r31->unk3C_2 != 0) { - msmStreamInline06(user); + slot = &StreamInfo.slot[user]; + if (slot->streamOffF != 0) { + msmStreamShutdown(user); return 0; } - temp_r0 = temp_r31->unk38 / 2; - if (len1 < temp_r0) { - var_r3 = 0; - temp_r31->unk64 = temp_r31->unk68 + (len1 - temp_r31->unk6C); + updateLen = slot->streamFrq / 2; + if (len1 < updateLen) { + len = 0; + slot->unk64 = slot->unk68 + (len1 - slot->unk6C); } else { msmStreamData(user); - var_r3 = temp_r0; - temp_r4 = temp_r31->unk68 + (temp_r0 - temp_r31->unk6C); - temp_r31->unk68 = temp_r4; - temp_r31->unk64 = temp_r4; - temp_r31->unk6C = 0; + len = updateLen; + len3 = slot->unk68 + (updateLen - slot->unk6C); + slot->unk68 = len3; + slot->unk64 = len3; + slot->unk6C = 0; } - if (temp_r31->unk64 >= temp_r31->unk54) { - if (temp_r31->unk07 != 0) { - temp_r31->unk68 = 0; - temp_r31->unk64 -= temp_r31->unk54; - if (len1 < temp_r0) { - temp_r31->unk6C = len1 - temp_r31->unk64; + if (slot->unk64 >= slot->loopEndOfs) { + if (slot->stereoF != 0) { + slot->unk68 = 0; + slot->unk64 -= slot->loopEndOfs; + if (len1 < updateLen) { + slot->unk6C = len1 - slot->unk64; } } else { - temp_r31->unk3C_2 = 1; - temp_r31->unk3C_5 = 0; + slot->streamOffF = 1; + slot->pauseF = 0; } } - return var_r3; + return len; } -static s32 msmStreamSlotInit(msmStreamUnk20Struct* arg0, StructSlotInitArg1* arg1, StructSlotInitArg2* arg2, s32 arg3) { - StructSlotInitInnerArg1* temp_r10; +static s32 msmStreamSlotInit(MSM_STREAM_SLOT *slot, MSM_STREAM_PACK* pack, STREAM_PARAM* param, s32 no) { + MSM_STREAM *stream; s32 temp_r3; - s32 var_r30; + s32 ret; - temp_r10 = &arg1->unk10[arg3]; - arg0->unk08 = arg1->unk01; - arg0->unk09 = arg2->unk00; - arg0->unk0A = arg0->unk0B = 0x7F; - arg0->unk0C = arg1->unk02; - arg0->unk0D = arg2->unk01; - arg0->unk2C = arg2->unk02; - arg0->unk2D = arg2->unk03; - arg0->unk2E = arg2->unk04; - arg0->unk07 = (arg1->unk00 >> 1) & 1; - arg0->unk48 = temp_r10->unk00; - arg0->unk60 = (arg1->unk0C >> 1) & ~7; - arg0->unk40 = arg1->unk06; - arg0->unk44 = &StreamInfo.unk1C[temp_r10->unk04]; - arg0->unk24 = 0; - arg0->unk18 = 0; - arg0->unk14 = 0; - arg0->unk10 = 0; - arg0->unk3C_1 = 1; - arg0->unk3C_2 = 0; - arg0->unk3C_4 = 0; - arg0->unk3C_5 = 0; - arg0->unk3C_6 = 0; - arg0->unk3C_0 = 1; - arg0->unk34 = (StreamInfo.unk48 * StreamInfo.unk4C * 8 / 14 + 0x3F) & ~0x3F; - if (arg0->unk34 > StreamInfo.unk04) { - arg0->unk34 = StreamInfo.unk04; + stream = &pack->stream[no]; + slot->volBase = pack->vol; + slot->vol = param->vol; + slot->volFade = slot->pauseVol = 127; + slot->panBase = pack->pan; + slot->pan = param->pan; + slot->span = param->span; + slot->auxA = param->auxA; + slot->auxB = param->auxB; + slot->stereoF = (pack->flag >> 1) & 1; + slot->streamBaseOfs = stream->sampleOfs; + slot->streamPosStart = (pack->loopOfsStart >> 1) & ~7; + slot->frq = pack->frq; + slot->adpcmInfo = &StreamInfo.adpcmParam[stream->adpcmParamIdx]; + slot->fadeMaxTime = 0; + slot->pauseTimeMax = 0; + slot->pauseTime = 0; + slot->pauseLen = 0; + slot->firstF = 1; + slot->streamOffF = 0; + slot->shutdownF = 0; + slot->pauseF = 0; + slot->updateAramF = 0; + slot->bufNo = 1; + slot->streamBufSize = (StreamInfo.header.sampleFrq * StreamInfo.header.maxBufs * SND_STREAM_ADPCM_BLKBYTES / SND_STREAM_ADPCM_BLKSIZE + 0x3F) & ~0x3F; + if (slot->streamBufSize > StreamInfo.bufSize) { + slot->streamBufSize = StreamInfo.bufSize; } - arg0->unk38 = (arg0->unk34 / 8) * 14; - arg0->unk50 = (arg1->unk08 >> 1) & ~0x1F; - arg0->unk54 = (arg0->unk50 / 8) * 14; - arg0->unk64 = arg0->unk68 = 0; - arg0->unk6C = 0; - arg0->unk0E = -1; - arg0->unk0F = -1; - arg0->unk4C = arg2->unk08; - var_r30 = arg0->unk34 / 2; - if ((temp_r3 = arg0->unk50 - arg0->unk4C) < arg0->unk34 / 2) { - var_r30 = temp_r3; - arg0->unk58 = arg0->unk34 / 2 - temp_r3; - arg0->unk5C = (void*) ((u32) arg0->unk30 + temp_r3); - memset(arg0->unk5C, 0, arg0->unk58); + slot->streamFrq = (slot->streamBufSize / SND_STREAM_ADPCM_BLKBYTES) * SND_STREAM_ADPCM_BLKSIZE; + slot->loopLen = (pack->loopOfsEnd >> 1) & ~0x1F; + slot->loopEndOfs = (slot->loopLen / SND_STREAM_ADPCM_BLKBYTES) * SND_STREAM_ADPCM_BLKSIZE; + slot->unk64 = slot->unk68 = 0; + slot->unk6C = 0; + slot->slotL = -1; + slot->slotR = -1; + slot->streamPos = param->sampleOfs; + ret = slot->streamBufSize / 2; + if ((temp_r3 = slot->loopLen - slot->streamPos) < slot->streamBufSize / 2) { + ret = temp_r3; + slot->streamReadSize = slot->streamBufSize / 2 - temp_r3; + slot->streamReadBuf = (void*) ((u32) slot->streamBuf + temp_r3); + memset(slot->streamReadBuf, 0, slot->streamReadSize); } - arg0->unk06 = 2; - return var_r30; + slot->status = 2; + return ret; } diff --git a/src/msm/msmsys.c b/src/msm/msmsys.c index 6dcd4ac9..916e03b0 100644 --- a/src/msm/msmsys.c +++ b/src/msm/msmsys.c @@ -5,233 +5,236 @@ #include "msm/msmse.h" #include "msm/msmstream.h" -static sysData sys; +static MSM_SYS sys; static void msmSysServer(void) { if (sndIsInstalled() == 1) { - if (--sys.unk4F8 == 0) { - sys.unk4F8 = 3; + if (--sys.timer == 0) { + sys.timer = 3; msmMusPeriodicProc(); msmSePeriodicProc(); msmStreamPeriodicProc(); } } - sys.unk4F4(); + sys.oldAIDCallback(); } -static s32 msmSysSetAuxParam(s32 arg0, s32 arg1) +static s32 msmSysSetAuxParam(s32 auxA, s32 auxB) { s32 unused_1[2]; - SND_AUX_CALLBACK sp20[2]; + SND_AUX_CALLBACK auxcb[2]; s32 unused_2[2]; - unkSubStruct *temp_r4_2; - UnkSndAuxUnion *temp_r3; - u32 var_r0; - s32 var_r23; + MSM_AUXPARAM *auxParam; + MSM_AUX *aux; + u32 result; + s32 i; - if (sys.unk18[0] != -2 && arg0 >= 0) { - sys.unk18[0] = arg0; + if (sys.auxParamNo[0] != MSM_AUXNO_NULL && auxA >= 0) { + sys.auxParamNo[0] = auxA; } - if (sys.unk18[1] != -2 && arg1 >= 0) { - sys.unk18[1] = arg1; + if (sys.auxParamNo[1] != MSM_AUXNO_NULL && auxB >= 0) { + sys.auxParamNo[1] = auxB; } - if (sys.unk18[0] < 0 && sys.unk18[1] < 0) { + if (sys.auxParamNo[0] < 0 && sys.auxParamNo[1] < 0) { return 0; } - for (var_r23 = 0; var_r23 < 2; var_r23++) { - if (sys.unk18[var_r23] < 0) { - sp20[var_r23] = NULL; + for (i = 0; i < 2; i++) { + if (sys.auxParamNo[i] < 0) { + auxcb[i] = NULL; continue; } - temp_r4_2 = &sys.unk14[sys.unk18[var_r23]]; - temp_r3 = &sys.unk1C[var_r23]; - switch (temp_r4_2->unk0) { - case 0: - 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); + auxParam = &sys.auxParam[sys.auxParamNo[i]]; + aux = &sys.aux[i]; + switch (auxParam->type) { + case MSM_AUX_REVERBHI: + auxcb[i] = sndAuxCallbackReverbHI; + aux->revHi.tempDisableFX = auxParam->revHi.tempDisableFX; + aux->revHi.coloration = auxParam->revHi.coloration; + aux->revHi.mix = auxParam->revHi.mix; + aux->revHi.time = auxParam->revHi.time; + aux->revHi.damping = auxParam->revHi.damping; + aux->revHi.preDelay = auxParam->revHi.preDelay; + aux->revHi.crosstalk = auxParam->revHi.crosstalk; + result = sndAuxCallbackPrepareReverbHI(&aux->revHi); break; - case 1: - 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); + + case MSM_AUX_REVERBSTD: + auxcb[i] = sndAuxCallbackReverbSTD; + aux->revStd.tempDisableFX = auxParam->revStd.tempDisableFX; + aux->revStd.coloration = auxParam->revStd.coloration; + aux->revStd.mix = auxParam->revStd.mix; + aux->revStd.time = auxParam->revStd.time; + aux->revStd.damping = auxParam->revStd.damping; + aux->revStd.preDelay = auxParam->revStd.preDelay; + result = sndAuxCallbackPrepareReverbSTD(&aux->revStd); break; - case 2: - 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); + + case MSM_AUX_CHORUS: + auxcb[i] = sndAuxCallbackChorus; + aux->chorus.baseDelay = auxParam->chorus.baseDelay; + aux->chorus.variation = auxParam->chorus.variation; + aux->chorus.period = auxParam->chorus.period; + result = sndAuxCallbackPrepareChorus(&aux->chorus); break; - case 3: - 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); + + case MSM_AUX_DELAY: + auxcb[i] = sndAuxCallbackDelay; + aux->delay.delay[0] = auxParam->delay.delay[0]; + aux->delay.feedback[0] = auxParam->delay.feedback[0]; + aux->delay.output[0] = auxParam->delay.output[0]; + aux->delay.delay[1] = auxParam->delay.delay[1]; + aux->delay.feedback[1] = auxParam->delay.feedback[1]; + aux->delay.output[1] = auxParam->delay.output[1]; + aux->delay.delay[2] = auxParam->delay.delay[2]; + aux->delay.feedback[2] = auxParam->delay.feedback[2]; + aux->delay.output[2] = auxParam->delay.output[2]; + result = sndAuxCallbackPrepareDelay(&aux->delay); break; } - if (var_r0 == 0) { - return 1; + if (result == FALSE) { + return TRUE; } } - sndSetAuxProcessingCallbacks(0, sp20[0], &sys.unk1C[0], 0xFF, 0, sp20[1], &sys.unk1C[1], 0xFF, 0); - return 0; + sndSetAuxProcessingCallbacks(0, auxcb[0], &sys.aux[0], 0xFF, 0, auxcb[1], &sys.aux[1], 0xFF, 0); + return FALSE; } static s32 msmSysLoadBaseGroup(void *buf) { - DVDFileInfo spC; - s32 var_r28; - unkStruct3 *temp_r27; - unkStruct4 *temp_r25; + DVDFileInfo file; + s32 i; + MSM_GRP_HEAD *grpData; + MSM_GRP_INFO *grpInfo; - if (msmFioOpen(sys.unk0, &spC) != 1) { + if (msmFioOpen(sys.msmEntryNum, &file) != TRUE) { return MSM_ERR_OPENFAIL; } - 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); + for(i = 0; i < sys.baseGrpNum; i++) { + grpData = sys.grpData[i]; + grpInfo = &sys.grpInfo[sys.info->baseGrp[i]]; + if (msmFioRead(&file, grpData, grpInfo->dataSize, grpInfo->dataOfs + sys.header->grpDataOfs) < 0) { + msmFioClose(&file); return MSM_ERR_READFAIL; } - if (msmFioRead(&spC, buf, temp_r25->unk10, temp_r25->unkC + sys.unkC->unk40) < 0) { - msmFioClose(&spC); + if (msmFioRead(&file, buf, grpInfo->sampSize, grpInfo->sampOfs + sys.header->sampOfs) < 0) { + msmFioClose(&file); return MSM_ERR_READFAIL; } - if (!sndPushGroup((void*) (temp_r27->unk4 + (u32) temp_r27), temp_r25->unk0, buf, - (void*) (temp_r27->unk8 + (u32) temp_r27), (void*) (temp_r27->unk0 + (u32) temp_r27))) + if (!sndPushGroup((void*) (grpData->projOfs + (u32) grpData), grpInfo->gid, buf, + (void*) (grpData->sdirOfs + (u32) grpData), (void*) (grpData->poolOfs + (u32) grpData))) { - msmFioClose(&spC); - return MSM_ERR_20; + msmFioClose(&file); + return MSM_ERR_GRP_FAILPUSH; } - sys.unk8 += temp_r25->unk10; + sys.aramP += grpInfo->sampSize; } - msmFioClose(&spC); + msmFioClose(&file); return 0; } -s32 msmSysSearchGroupStack(s32 arg0, s32 arg1) +s32 msmSysSearchGroupStack(s32 grpId, s32 no) { - UnkStructSys43C *var_r3; - u32 var_r5; - s32 var_r6; - s32 var_r7; - s32 var_r8; - s32 var_r9; - s32 var_r0; + MSM_GRP_STACK *stack; + u32 stackNo; + s32 i; + s32 stackNoB; + s32 stackNoA; + s32 maxNo; + s32 stackMax; - var_r8 = -1; - var_r9 = 0; - if (sys.unk3EC[arg0].unk2 == 0) { - var_r3 = sys.unk43C; - var_r0 = sys.unk434; + stackNoA = -1; + maxNo = 0; + if (sys.grpInfo[grpId].stackNo == 0) { + stack = sys.grpStackA; + stackMax = sys.grpStackAMax; } else { - var_r3 = sys.unk474; - var_r0 = sys.unk46C; + stack = sys.grpStackB; + stackMax = sys.grpStackBMax; } - for (var_r6 = 0; var_r6 < var_r0; var_r3++, var_r6++) { - if (var_r6 == arg1) { + for (i = 0; i < stackMax; stack++, i++) { + if (i == no) { continue; } - if ((var_r5 = var_r3->unk04) != 0) { - if (var_r3->unk01 == 0 && var_r5 > var_r9) { - var_r9 = var_r5; - var_r7 = -(var_r6 + 1); + if ((stackNo = stack->num) != 0) { + if (stack->baseGrpF == 0 && stackNo > maxNo) { + maxNo = stackNo; + stackNoB = -(i + 1); } } else { - var_r8 = var_r6; + stackNoA = i; } } - return (var_r8 < 0) ? var_r7 : var_r8; + return (stackNoA < 0) ? stackNoB : stackNoA; } -s32 msmSysGroupInit(DVDFileInfo *arg0) +s32 msmSysGroupInit(DVDFileInfo *file) { - s32 var_r7; - UnkStructSys43C *temp_43C; - unkStruct4 *temp_r20; + s32 i; + MSM_GRP_STACK *stack; + MSM_GRP_INFO *grpInfo; - 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) { + sys.grpMax = sys.info->grpMax; + sys.grpNum = 1; + sys.baseGrpNum = sys.info->baseGrpNum; + sys.grpStackAMax = sys.info->stackDepthA; + sys.grpStackADepth = 0; + sys.grpStackAOfs = 0; + sys.grpStackBMax = sys.info->stackDepthB; + sys.grpStackBDepth = 0; + sys.grpStackBOfs = 0; + if ((sys.grpInfo = msmMemAlloc(sys.header->grpInfoSize)) == NULL) { return MSM_ERR_OUTOFMEM; } - if (msmFioRead(arg0, sys.unk3EC, sys.unkC->unk24, sys.unkC->unk20) < 0) { + if (msmFioRead(file, sys.grpInfo, sys.header->grpInfoSize, sys.header->grpInfoOfs) < 0) { return MSM_ERR_READFAIL; } - if ((sys.unk438 = msmMemAlloc(sys.unk10->unk18 * sys.unk434)) == NULL) { + if ((sys.grpBufA = msmMemAlloc(sys.info->grpBufSizeA * sys.grpStackAMax)) == NULL) { return MSM_ERR_OUTOFMEM; } - if ((sys.unk470 = msmMemAlloc(sys.unk10->unk1C * sys.unk46C)) == NULL) { + if ((sys.grpBufB = msmMemAlloc(sys.info->grpBufSizeB * sys.grpStackBMax)) == NULL) { return MSM_ERR_OUTOFMEM; } - if (sys.unkC->unk54) { - if ((sys.unk3F0 = msmMemAlloc(sys.unkC->unk54)) == NULL) { + if (sys.header->grpSetSize) { + if ((sys.grpSet = msmMemAlloc(sys.header->grpSetSize)) == NULL) { return MSM_ERR_OUTOFMEM; } - if (msmFioRead(arg0, sys.unk3F0, sys.unkC->unk54, sys.unkC->unk50) < 0) { + if (msmFioRead(file, sys.grpSet, sys.header->grpSetSize, sys.header->grpSetOfs) < 0) { return MSM_ERR_READFAIL; } } else { - sys.unk3F0 = NULL; + sys.grpSet = 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 (i = 0; i < sys.grpStackAMax; i++) { + stack = &sys.grpStackA[i]; + stack->grpId = stack->baseGrpF = 0; + stack->num = 0; + stack->buf = (void*) ((u32) sys.grpBufA + sys.info->grpBufSizeA * i); } - 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); + for (i = 0; i < sys.grpStackBMax; i++) { + stack = &sys.grpStackB[i]; + stack->grpId = stack->baseGrpF = 0; + stack->num = 0; + stack->buf = (void*) ((u32) sys.grpBufB + sys.info->grpBufSizeB * i); } - 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) { + sys.sampSize = 0; + for (i = 0; i < sys.baseGrpNum; i++) { + grpInfo = &sys.grpInfo[sys.info->baseGrp[i]]; + if ((sys.grpData[i] = msmMemAlloc(grpInfo->dataSize)) == NULL) { return MSM_ERR_OUTOFMEM; } - if (sys.unk3E4 < temp_r20->unk10) { - sys.unk3E4 = temp_r20->unk10; + if (sys.sampSize < grpInfo->sampSize) { + sys.sampSize = grpInfo->sampSize; } - temp_r20->unk10 *= -1; + grpInfo->sampSize *= -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; + sys.sampSizeBase = 0; + for (i = 1; i < sys.grpMax; i++) { + grpInfo = &sys.grpInfo[i]; + if (grpInfo->sampSize < 0) { + grpInfo->sampSize *= -1; + } else if (sys.sampSizeBase < grpInfo->sampSize) { + sys.sampSizeBase = grpInfo->sampSize; } } return 0; @@ -239,88 +242,88 @@ s32 msmSysGroupInit(DVDFileInfo *arg0) void msmSysIrqDisable(void) { - if (sys.unk4EC++ == 0) { - sys.unk4F0 = OSDisableInterrupts(); + if (sys.irqDepth++ == 0) { + sys.irqState = OSDisableInterrupts(); } } void msmSysIrqEnable(void) { - if (sys.unk4EC != 0) { - if (--sys.unk4EC == 0) { - OSRestoreInterrupts(sys.unk4F0); + if (sys.irqDepth != 0) { + if (--sys.irqDepth == 0) { + OSRestoreInterrupts(sys.irqState); } } } -static inline BOOL msmSysInline00(s32 arg0) +static BOOL msmSysCheckBaseGroupNo(s32 grpId) { - s32 var_r6; + s32 i; - for (var_r6 = 0; var_r6 < sys.unk3F4 + sys.unk436 + sys.unk46E; var_r6++) { - if (sys.unk10->unk29[var_r6] == arg0) { + for (i = 0; i < sys.baseGrpNum + sys.grpStackAOfs + sys.grpStackBOfs; i++) { + if (sys.info->baseGrp[i] == grpId) { return TRUE; } } return FALSE; } -BOOL msmSysCheckBaseGroup(s32 arg0) +BOOL msmSysCheckBaseGroup(s32 grpId) { - s32 var_r6; + s32 i; - for (var_r6 = 0; var_r6 < sys.unk3F4 + sys.unk436 + sys.unk46E; var_r6++) { - if (sys.unk3EC[sys.unk10->unk29[var_r6]].unk0 == arg0) { + for (i = 0; i < sys.baseGrpNum + sys.grpStackAOfs + sys.grpStackBOfs; i++) { + if (sys.grpInfo[sys.info->baseGrp[i]].gid == grpId) { return TRUE; } } return FALSE; } -void *msmSysGetGroupDataPtr(s32 arg0) +void *msmSysGetGroupDataPtr(s32 grpId) { - UnkStructSys43C *temp_43C; - s32 var_r6; + MSM_GRP_STACK *grp; + s32 i; - for (var_r6 = 0; var_r6 < sys.unk3F4; var_r6++) { - if (sys.unk10->unk29[var_r6] == arg0) { - return sys.unk3F8[var_r6]; + for (i = 0; i < sys.baseGrpNum; i++) { + if (sys.info->baseGrp[i] == grpId) { + return sys.grpData[i]; } } - 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 (i = 0; i < sys.grpStackAMax; i++) { + grp = &sys.grpStackA[i]; + if (grp->num != 0 && grp->grpId == grpId) { + return grp->buf; } } - 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; + for (i = 0; i < sys.grpStackBMax; i++) { + grp = &sys.grpStackB[i]; + if (grp->num != 0 && grp->grpId == grpId) { + return grp->buf; } } return NULL; } -BOOL msmSysCheckLoadGroupID(s32 arg0) +BOOL msmSysCheckLoadGroupID(s32 grpId) { - UnkStructSys43C *temp_43C; - s32 var_r6; + MSM_GRP_STACK *grp; + s32 i; - for (var_r6 = 0; var_r6 < sys.unk3F4 + sys.unk436 + sys.unk46E; var_r6++) { - if (sys.unk3EC[sys.unk10->unk29[var_r6]].unk0 == arg0) { + for (i = 0; i < sys.baseGrpNum + sys.grpStackAOfs + sys.grpStackBOfs; i++) { + if (sys.grpInfo[sys.info->baseGrp[i]].gid == grpId) { 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) { + for (i = 0; i < sys.grpStackAMax; i++) { + grp = &sys.grpStackA[i]; + if (grp->num != 0 && sys.grpInfo[grp->grpId].gid == grpId) { 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) { + for (i = 0; i < sys.grpStackBMax; i++) { + grp = &sys.grpStackB[i]; + if (grp->num != 0 && sys.grpInfo[grp->grpId].gid == grpId) { return TRUE; } } @@ -333,27 +336,27 @@ void msmSysRegularProc(void) s32 msmSysGetOutputMode(void) { - return sys.unk4; + return sys.outputMode; } -s32 msmSysSetOutputMode(SND_OUTPUTMODE mode) +BOOL msmSysSetOutputMode(SND_OUTPUTMODE mode) { SND_OUTPUTMODE var_r3; - s32 var_r30; + BOOL failF; - var_r30 = 0; - sys.unk4 = mode; + failF = 0; + sys.outputMode = mode; switch (mode) { case SND_OUTPUTMODE_MONO: var_r3 = SND_OUTPUTMODE_MONO; break; case SND_OUTPUTMODE_SURROUND: - if (sys.unk10->unkB != 0) { + if (sys.info->surroundF != 0) { var_r3 = SND_OUTPUTMODE_SURROUND; } else { - sys.unk4 = SND_OUTPUTMODE_STEREO; + sys.outputMode = SND_OUTPUTMODE_STEREO; var_r3 = SND_OUTPUTMODE_STEREO; - var_r30 = 1; + failF = 1; } break; case SND_OUTPUTMODE_STEREO: @@ -362,36 +365,36 @@ s32 msmSysSetOutputMode(SND_OUTPUTMODE mode) break; } sndOutputMode(var_r3); - msmStreamSetOutputMode(sys.unk4); + msmStreamSetOutputMode(sys.outputMode); OSSetSoundMode((mode != SND_OUTPUTMODE_MONO) ? 1 : 0); - return var_r30; + return failF; } -s32 msmSysSetAux(s32 arg0, s32 arg1) +s32 msmSysSetAux(s32 auxA, s32 auxB) { - s32 var_r28; + s32 i; 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) { + for (i = 1; i >= 0; i--) { + if (sys.auxParamNo[i] < 0) { continue; } - switch (sys.unk14[sys.unk18[var_r28]].unk0) { + switch (sys.auxParam[sys.auxParamNo[i]].type) { case 0: - sndAuxCallbackShutdownReverbHI(&sys.unk1C[var_r28].revHi); + sndAuxCallbackShutdownReverbHI(&sys.aux[i].revHi); break; case 1: - sndAuxCallbackShutdownReverbSTD(&sys.unk1C[var_r28].revStd); + sndAuxCallbackShutdownReverbSTD(&sys.aux[i].revStd); break; case 2: - sndAuxCallbackShutdownChorus(&sys.unk1C[var_r28].ch); + sndAuxCallbackShutdownChorus(&sys.aux[i].chorus); break; case 3: - sndAuxCallbackShutdownDelay(&sys.unk1C[var_r28].delay); + sndAuxCallbackShutdownDelay(&sys.aux[i].delay); break; } } - if (msmSysSetAuxParam(arg0, arg1) != 0) { + if (msmSysSetAuxParam(auxA, auxB) != 0) { return MSM_ERR_INVALID_AUXPARAM; } return 0; @@ -400,32 +403,32 @@ s32 msmSysSetAux(s32 arg0, s32 arg1) s32 msmSysGetSampSize(BOOL baseGrp) { if (baseGrp != 0) { - return sys.unk3E8; + return sys.sampSizeBase; } - return sys.unk3E4; + return sys.sampSize; } s32 msmSysDelGroupAll(void) { - UnkStructSys43C *temp_r28; - s32 var_r29; + MSM_GRP_STACK *grp; + s32 i; - 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; + for (i = 0; i < sys.grpStackBMax; i++) { + grp = &sys.grpStackB[i]; + if (grp->num != 0 && grp->baseGrpF == 0) { + grp->num = 0; sndPopGroup(); - sys.unk8 -= sys.unk3EC[temp_r28->unk00].unk10; - sys.unk46D--; + sys.aramP -= sys.grpInfo[grp->grpId].sampSize; + sys.grpStackBDepth--; } } - 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; + for (i = 0; i < sys.grpStackAMax; i++) { + grp = &sys.grpStackA[i]; + if (grp->num != 0 && grp->baseGrpF == 0) { + grp->num = 0; sndPopGroup(); - sys.unk8 -= sys.unk3EC[temp_r28->unk00].unk10; - sys.unk435--; + sys.aramP -= sys.grpInfo[grp->grpId].sampSize; + sys.grpStackADepth--; } } return 0; @@ -433,338 +436,338 @@ s32 msmSysDelGroupAll(void) s32 msmSysDelGroupBase(s32 grpNum) { - s32 var_r4; - UnkStructSys43C *temp_r26; - s32 var_r27; - s8 var_r31; - s8 var_r25; - s32 var_r6; + s32 j; + MSM_GRP_STACK *grp; + s32 i; + s8 level; + s8 stackBF; + s32 grpMaxNum; - if (sys.unk436 + sys.unk46E == 0) { + if (sys.grpStackAOfs + sys.grpStackBOfs == 0) { return 0; } - if (grpNum >= sys.unk436 + sys.unk46E) { + if (grpNum >= sys.grpStackAOfs + sys.grpStackBOfs) { 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 (i = 0; i < grpNum; i++) { + grpMaxNum = 0; + for (j = 0; j < sys.grpStackAMax; j++) { + grp = &sys.grpStackA[j]; + if (grp->num > grpMaxNum) { + grpMaxNum = grp->num; + level = j; + stackBF = FALSE; } } - 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; + for (j = 0; j < sys.grpStackBMax; j++) { + grp = &sys.grpStackB[j]; + if (grp->num > grpMaxNum) { + grpMaxNum = grp->num; + level = j; + stackBF = TRUE; } } - if (var_r25 == 0) { - temp_r26 = &sys.unk43C[var_r31]; - sys.unk435--; - sys.unk436--; + if (stackBF == FALSE) { + grp = &sys.grpStackA[level]; + sys.grpStackADepth--; + sys.grpStackAOfs--; } else { - temp_r26 = &sys.unk474[var_r31]; - sys.unk46D--; - sys.unk46E--; + grp = &sys.grpStackB[level]; + sys.grpStackBDepth--; + sys.grpStackBOfs--; } sndPopGroup(); - sys.unk8 -= sys.unk3EC[temp_r26->unk00].unk10; - temp_r26->unk01 = 0; - temp_r26->unk04 = 0; + sys.aramP -= sys.grpInfo[grp->grpId].sampSize; + grp->baseGrpF = 0; + grp->num = 0; } } else { - for (var_r27 = 0; var_r27 < sys.unk434; var_r27++) { - temp_r26 = &sys.unk43C[var_r27]; - if (temp_r26->unk04 != 0) { + for (i = 0; i < sys.grpStackAMax; i++) { + grp = &sys.grpStackA[i]; + if (grp->num != 0) { sndPopGroup(); - sys.unk8 -= sys.unk3EC[temp_r26->unk00].unk10; - temp_r26->unk01 = 0; - temp_r26->unk04 = 0; + sys.aramP -= sys.grpInfo[grp->grpId].sampSize; + grp->baseGrpF = 0; + grp->num = 0; } } - for (var_r27 = 0; var_r27 < sys.unk46C; var_r27++) { - temp_r26 = &sys.unk474[var_r27]; - if (temp_r26->unk04 != 0) { + for (i = 0; i < sys.grpStackBMax; i++) { + grp = &sys.grpStackB[i]; + if (grp->num != 0) { sndPopGroup(); - sys.unk8 -= sys.unk3EC[temp_r26->unk00].unk10; - temp_r26->unk01 = 0; - temp_r26->unk04 = 0; + sys.aramP -= sys.grpInfo[grp->grpId].sampSize; + grp->baseGrpF = 0; + grp->num = 0; } } - sys.unk46E = 0; - sys.unk46D = 0; - sys.unk436 = 0; - sys.unk435 = 0; + sys.grpStackBOfs = 0; + sys.grpStackBDepth = 0; + sys.grpStackAOfs = 0; + sys.grpStackADepth = 0; } return 0; } -static inline s32 msmSysPushGroup(DVDFileInfo *arg0, void *buf, UnkStructSys43C *arg2, s32 arg3) +static s32 msmSysPushGroup(DVDFileInfo *file, void *buf, MSM_GRP_STACK *grp, s32 grpId) { - unkStruct4 *temp_r30; - unkStruct3 *temp_r7; + MSM_GRP_INFO *grpInfo; + MSM_GRP_HEAD *grpBuf; - temp_r30 = &sys.unk3EC[arg3]; - if (msmFioRead(arg0, arg2->unk08, temp_r30->unk8, temp_r30->unk4 + sys.unkC->unk38) < 0) { + grpInfo = &sys.grpInfo[grpId]; + if (msmFioRead(file, grp->buf, grpInfo->dataSize, grpInfo->dataOfs + sys.header->grpDataOfs) < 0) { return MSM_ERR_READFAIL; } - if (msmFioRead(arg0, buf, temp_r30->unk10, temp_r30->unkC + sys.unkC->unk40) < 0) { + if (msmFioRead(file, buf, grpInfo->sampSize, grpInfo->sampOfs + sys.header->sampOfs) < 0) { return MSM_ERR_READFAIL; } - temp_r7 = arg2->unk08; - if (!sndPushGroup((void*) (temp_r7->unk4 + (u32) temp_r7), temp_r30->unk0, buf, - (void*) (temp_r7->unk8 + (u32) temp_r7), (void*) (temp_r7->unk0 + (u32) temp_r7))) + grpBuf = grp->buf; + if (!sndPushGroup((void*) (grpBuf->projOfs + (u32) grpBuf), grpInfo->gid, buf, + (void*) (grpBuf->sdirOfs + (u32) grpBuf), (void*) (grpBuf->poolOfs + (u32) grpBuf))) { - return MSM_ERR_20; + return MSM_ERR_GRP_FAILPUSH; } - sys.unk8 += temp_r30->unk10; - arg2->unk00 = arg3; - arg2->unk04 = sys.unk3E0++; + sys.aramP += grpInfo->sampSize; + grp->grpId = grpId; + grp->num = sys.grpNum++; return 0; } -s32 msmSysLoadGroupBase(s32 arg0, void *arg1) +s32 msmSysLoadGroupBase(s32 grpId, void *buf) { s32 temp_r29; s32 temp_r28; s32 var_r23; s32 temp_r3_2; - UnkStructSys43C *var_r24; + MSM_GRP_STACK *var_r24; DVDFileInfo sp10; - if (arg0 < 1 || arg0 >= sys.unk3DC) { + if (grpId < 1 || grpId >= sys.grpMax) { return MSM_ERR_64; } var_r23 = msmSysDelGroupAll(); if (var_r23 != 0) { return var_r23; } - temp_r29 = sys.unk3F4 + sys.unk436 + sys.unk46E; - if (msmSysInline00(arg0)) { + temp_r29 = sys.baseGrpNum + sys.grpStackAOfs + sys.grpStackBOfs; + if (msmSysCheckBaseGroupNo(grpId)) { return 0; } if (temp_r29 >= 0xF) { - return MSM_ERR_65; + return MSM_ERR_STACK_OVERFLOW; } - temp_r3_2 = msmSysSearchGroupStack(arg0, -1); + temp_r3_2 = msmSysSearchGroupStack(grpId, -1); if (temp_r3_2 < 0) { - return MSM_ERR_65; + return MSM_ERR_STACK_OVERFLOW; } - temp_r28 = sys.unk3EC[arg0].unk2; + temp_r28 = sys.grpInfo[grpId].stackNo; if (!temp_r28) { - var_r24 = &sys.unk43C[temp_r3_2]; + var_r24 = &sys.grpStackA[temp_r3_2]; } else { - var_r24 = &sys.unk474[temp_r3_2]; + var_r24 = &sys.grpStackB[temp_r3_2]; } - if (msmFioOpen(sys.unk0, &sp10) != 1) { + if (msmFioOpen(sys.msmEntryNum, &sp10) != 1) { return MSM_ERR_OPENFAIL; } - var_r23 = msmSysPushGroup(&sp10, arg1, var_r24, arg0); + var_r23 = msmSysPushGroup(&sp10, buf, var_r24, grpId); if (var_r23 != 0) { msmFioClose(&sp10); return var_r23; } msmFioClose(&sp10); - sys.unk10->unk29[temp_r29] = arg0; - var_r24->unk01 = 1; + sys.info->baseGrp[temp_r29] = grpId; + var_r24->baseGrpF = 1; if (temp_r28 == 0) { - sys.unk436++; - sys.unk435++; + sys.grpStackAOfs++; + sys.grpStackADepth++; } else { - sys.unk46E++; - sys.unk46D++; + sys.grpStackBOfs++; + sys.grpStackBDepth++; } return 0; } -static inline s32 msmSysInline01(void) +static s32 msmSysGetNumGroupSet(void) { - if (sys.unk3F0 != NULL) { - return sys.unk3F0->unk00; + if (sys.grpSet != NULL) { + return sys.grpSet->numGrpSet; } return 0; } s32 msmSysLoadGroupSet(s32 arg0, void *arg1) { - s8 sp4C[12]; // unknown length (5..12 works) - DVDFileInfo sp10; - s32 temp_r3; - s32 temp_r3_2; - s32 var_r19; - s32 var_r24; - s32 var_r31; - s8 *var_r19_2; + s8 grpId[10]; + DVDFileInfo file; + s32 result; + s32 stackLevel; + s32 pushResult; + s32 i; + s32 grpSetNum; + s8 *grpSet; - if (msmSysInline01() == 0) { + if (msmSysGetNumGroupSet() == 0) { return 0; } - temp_r3 = msmSysDelGroupAll(); - if (temp_r3 != 0) { - return temp_r3; + result = msmSysDelGroupAll(); + if (result != 0) { + return result; } - var_r19_2 = &sys.unk3F0->unk02[sys.unk3F0->unk01 * arg0]; - if (msmFioOpen(sys.unk0, &sp10) != TRUE) { + grpSet = &sys.grpSet->data[sys.grpSet->grpSetW * arg0]; + if (msmFioOpen(sys.msmEntryNum, &file) != TRUE) { return MSM_ERR_OPENFAIL; } - sys.unk435 = sys.unk436; - var_r31 = 0; - for (; *var_r19_2 != 0; var_r19_2++) { - if (msmSysInline00(*var_r19_2)) { + sys.grpStackADepth = sys.grpStackAOfs; + grpSetNum = 0; + for (; *grpSet != 0; grpSet++) { + if (msmSysCheckBaseGroupNo(*grpSet)) { continue; } - if (sys.unk3EC[(s8) *var_r19_2].unk2 == 1) { - sp4C[var_r31++] = *var_r19_2; + if (sys.grpInfo[(s8) *grpSet].stackNo == 1) { + grpId[grpSetNum++] = *grpSet; } else { - temp_r3_2 = msmSysSearchGroupStack(*var_r19_2, -1); - if (temp_r3_2 < 0) { - msmFioClose(&sp10); - return MSM_ERR_65; + stackLevel = msmSysSearchGroupStack(*grpSet, -1); + if (stackLevel < 0) { + msmFioClose(&file); + return MSM_ERR_STACK_OVERFLOW; } - var_r19 = msmSysPushGroup(&sp10, arg1, &sys.unk43C[temp_r3_2], *var_r19_2); - if (var_r19 != 0) { - msmFioClose(&sp10); - return var_r19; + pushResult = msmSysPushGroup(&file, arg1, &sys.grpStackA[stackLevel], *grpSet); + if (pushResult != 0) { + msmFioClose(&file); + return pushResult; } - sys.unk435++; + sys.grpStackADepth++; } } - sys.unk46D = sys.unk46E; - for (var_r24 = 0; var_r24 < var_r31; var_r24++) { - temp_r3_2 = msmSysSearchGroupStack(sp4C[var_r24], -1); - if (temp_r3_2 < 0) { - msmFioClose(&sp10); - return MSM_ERR_65; + sys.grpStackBDepth = sys.grpStackBOfs; + for (i = 0; i < grpSetNum; i++) { + stackLevel = msmSysSearchGroupStack(grpId[i], -1); + if (stackLevel < 0) { + msmFioClose(&file); + return MSM_ERR_STACK_OVERFLOW; } - var_r19 = msmSysPushGroup(&sp10, arg1, &sys.unk474[temp_r3_2], sp4C[var_r24]); - if (var_r19 != 0) { - msmFioClose(&sp10); - return var_r19; + pushResult = msmSysPushGroup(&file, arg1, &sys.grpStackB[stackLevel], grpId[i]); + if (pushResult != 0) { + msmFioClose(&file); + return pushResult; } - sys.unk46D++; + sys.grpStackBDepth++; } - msmFioClose(&sp10); + msmFioClose(&file); return 0; } -static s32 msmSysLoadGroupSub(DVDFileInfo *arg0, s32 arg1, void *arg2) +static s32 msmSysLoadGroupSub(DVDFileInfo *file, s32 grpId, void *buf) { - s32 var_r30; - s32 var_r18; - s32 var_r19; - s32 var_r3; - u8 *var_r29; - UnkStructSys43C *var_r28; - unkStruct4 *temp_r23; + s32 grpIdResult; + s32 i; + s32 stackLevel; + s32 result; + u8 *stackDepth; + MSM_GRP_STACK *grpStack; + MSM_GRP_INFO *temp_r23; - var_r30 = 0; - temp_r23 = &sys.unk3EC[arg1]; - if (temp_r23->unk2 == 0) { - var_r28 = sys.unk43C; - var_r29 = &sys.unk435; + grpIdResult = 0; + temp_r23 = &sys.grpInfo[grpId]; + if (temp_r23->stackNo == 0) { + grpStack = sys.grpStackA; + stackDepth = &sys.grpStackADepth; } else { - var_r28 = sys.unk474; - var_r29 = &sys.unk46D; + grpStack = sys.grpStackB; + stackDepth = &sys.grpStackBDepth; } - if (temp_r23->unk3 != 0) { - if (!msmSysCheckBaseGroup(sys.unk3EC[temp_r23->unk3].unk0)) { - var_r19 = -1; - for (var_r18 = 0; var_r18 < 2; var_r18++) { - var_r19 = msmSysSearchGroupStack(temp_r23->unk3, var_r19); - if (var_r19 < 0) { - var_r19 = -(var_r19 + 1); - (*var_r29)--; + if (temp_r23->subGrpId != 0) { + if (!msmSysCheckBaseGroup(sys.grpInfo[temp_r23->subGrpId].gid)) { + stackLevel = -1; + for (i = 0; i < 2; i++) { + stackLevel = msmSysSearchGroupStack(temp_r23->subGrpId, stackLevel); + if (stackLevel < 0) { + stackLevel = -(stackLevel + 1); + (*stackDepth)--; sndPopGroup(); - sys.unk8 -= sys.unk3EC[var_r28[var_r19].unk00].unk10; - var_r30 = var_r28[var_r19].unk00; - var_r28[var_r19].unk04 = 0; + sys.aramP -= sys.grpInfo[grpStack[stackLevel].grpId].sampSize; + grpIdResult = grpStack[stackLevel].grpId; + grpStack[stackLevel].num = 0; } } - var_r3 = msmSysPushGroup(arg0, arg2, &var_r28[var_r19], temp_r23->unk3); - if (var_r3 != 0) { - return var_r3; + result = msmSysPushGroup(file, buf, &grpStack[stackLevel], temp_r23->subGrpId); + if (result != 0) { + return result; } - (*var_r29)++; + (*stackDepth)++; } } - var_r19 = msmSysSearchGroupStack(arg1, -1); - if (var_r19 < 0) { - var_r19 = -(var_r19 + 1); - (*var_r29)--; + stackLevel = msmSysSearchGroupStack(grpId, -1); + if (stackLevel < 0) { + stackLevel = -(stackLevel + 1); + (*stackDepth)--; sndPopGroup(); - sys.unk8 -= sys.unk3EC[var_r28[var_r19].unk00].unk10; - var_r30 = var_r28[var_r19].unk00; + sys.aramP -= sys.grpInfo[grpStack[stackLevel].grpId].sampSize; + grpIdResult = grpStack[stackLevel].grpId; } - var_r3 = msmSysPushGroup(arg0, arg2, &var_r28[var_r19], arg1); - if (var_r3 == 0) { - var_r3 = var_r30; + result = msmSysPushGroup(file, buf, &grpStack[stackLevel], grpId); + if (result == 0) { + result = grpIdResult; } - (*var_r29)++; - return var_r3; + (*stackDepth)++; + return result; } -static inline void msmSysPopGroup(s32 arg0) +static void msmSysPopGroup(s32 no) { - UnkStructSys43C *temp_r23; + MSM_GRP_STACK *grp; - temp_r23 = &sys.unk474[arg0]; - if (temp_r23->unk04 != 0 && temp_r23->unk01 == 0) { + grp = &sys.grpStackB[no]; + if (grp->num != 0 && grp->baseGrpF == 0) { sndPopGroup(); - sys.unk8 -= sys.unk3EC[temp_r23->unk00].unk10; + sys.aramP -= sys.grpInfo[grp->grpId].sampSize; } } -s32 msmSysLoadGroup(s32 grp, void *buf) +s32 msmSysLoadGroup(s32 grpId, void *buf) { - UnkStructSys43C *temp_r23; - unkStruct4 *temp_r22; - s32 var_r31; - s32 var_r22; - s32 var_r21; - DVDFileInfo sp14; + MSM_GRP_STACK *grpStack; + MSM_GRP_INFO *grpInfo; + s32 pushResult; + s32 i; + s32 result; + DVDFileInfo file; s32 unused; if (buf == NULL) { return 0; } - if (grp == 0) { + if (grpId == 0) { return msmSysLoadBaseGroup(buf); } - temp_r22 = &sys.unk3EC[grp]; - if (msmSysCheckLoadGroupID(temp_r22->unk0)) { + grpInfo = &sys.grpInfo[grpId]; + if (msmSysCheckLoadGroupID(grpInfo->gid)) { return 0; } - if (msmFioOpen(sys.unk0, &sp14) != 1) { + if (msmFioOpen(sys.msmEntryNum, &file) != TRUE) { return MSM_ERR_OPENFAIL; } - if (temp_r22->unk2 == 0) { - for (var_r22 = 0; var_r22 < sys.unk46C; var_r22++) { - msmSysPopGroup(var_r22); + if (grpInfo->stackNo == 0) { + for (i = 0; i < sys.grpStackBMax; i++) { + msmSysPopGroup(i); } - var_r21 = msmSysLoadGroupSub(&sp14, grp, buf); - for (var_r22 = 0; var_r22 < sys.unk46C; var_r22++) { - temp_r23 = &sys.unk474[var_r22]; - if (temp_r23->unk04 != 0 && temp_r23->unk01 == 0) { - var_r31 = msmSysPushGroup(&sp14, buf, temp_r23, temp_r23->unk00); - if (var_r31 != 0) { - msmFioClose(&sp14); - return var_r31; + result = msmSysLoadGroupSub(&file, grpId, buf); + for (i = 0; i < sys.grpStackBMax; i++) { + grpStack = &sys.grpStackB[i]; + if (grpStack->num != 0 && grpStack->baseGrpF == 0) { + pushResult = msmSysPushGroup(&file, buf, grpStack, grpStack->grpId); + if (pushResult != 0) { + msmFioClose(&file); + return pushResult; } } } } else { - var_r21 = msmSysLoadGroupSub(&sp14, grp, buf); + result = msmSysLoadGroupSub(&file, grpId, buf); } - msmFioClose(&sp14); - return var_r21; + msmFioClose(&file); + return result; } void msmSysCheckInit(void) @@ -774,42 +777,42 @@ void msmSysCheckInit(void) s32 msmSysInit(MSM_INIT *init, MSM_ARAM *aram) { - s32 var_r26; - void *temp_r3_8; + s32 result; + void *temp; - SND_HOOKS sp4C = { msmMemAlloc, msmMemFree }; + SND_HOOKS sndHooks = { msmMemAlloc, msmMemFree }; DVDFileInfo sp10; if (sndIsInstalled() == 1) { return MSM_ERR_INSTALLED; } - var_r26 = 0; // retErr - sys.unk4EC = 0; + result = 0; // retErr + sys.irqDepth = 0; msmMemInit(init->heap, init->heapSize); msmFioInit(init->open, init->read, init->close); - sys.unk0 = DVDConvertPathToEntrynum(init->msmPath); - if (sys.unk0 < 0) { + sys.msmEntryNum = DVDConvertPathToEntrynum(init->msmPath); + if (sys.msmEntryNum < 0) { return MSM_ERR_OPENFAIL; } - if (msmFioOpen(sys.unk0, &sp10) != 1) { + if (msmFioOpen(sys.msmEntryNum, &sp10) != 1) { return MSM_ERR_OPENFAIL; } - if ((sys.unkC = msmMemAlloc(0x60)) == NULL) { + if ((sys.header = msmMemAlloc(0x60)) == NULL) { msmFioClose(&sp10); return MSM_ERR_OUTOFMEM; } - if (msmFioRead(&sp10, sys.unkC, 0x60, 0) < 0) { + if (msmFioRead(&sp10, sys.header, 0x60, 0) < 0) { msmFioClose(&sp10); return MSM_ERR_READFAIL; } - if (sys.unkC->unk4 != 2) { + if (sys.header->version != MSM_FILE_VERSION) { msmFioClose(&sp10); return MSM_ERR_INVALIDFILE; } - if ((sys.unk10 = msmMemAlloc(sys.unkC->unk14)) == NULL) { + if ((sys.info = msmMemAlloc(sys.header->infoSize)) == NULL) { msmFioClose(&sp10); return MSM_ERR_OUTOFMEM; } - if (msmFioRead(&sp10, sys.unk10, sys.unkC->unk14, sys.unkC->unk10) < 0) { + if (msmFioRead(&sp10, sys.info, sys.header->infoSize, sys.header->infoOfs) < 0) { msmFioClose(&sp10); return MSM_ERR_READFAIL; } @@ -817,88 +820,88 @@ s32 msmSysInit(MSM_INIT *init, MSM_ARAM *aram) if (aram->skipARInit == 0) { ARInit(aram->stackIndex, aram->aramEnd); ARQInit(); - aram = (MSM_ARAM *)ARAlloc(sys.unk10->unk14); + aram = (MSM_ARAM *)ARAlloc(sys.info->aramSize); if ((u32)aram != ARGetBaseAddress()) { msmFioClose(&sp10); return MSM_ERR_OUTOFAMEM; } - sys.unk7 = 0; + sys.arInitF = FALSE; } else { - if ((sys.unk10->unk14 + ARGetBaseAddress()) > aram->aramEnd) { + if ((sys.info->aramSize + ARGetBaseAddress()) > aram->aramEnd) { msmFioClose(&sp10); return MSM_ERR_OUTOFAMEM; } ARInit(NULL, 0); ARQInit(); - sys.unk7 = 1; + sys.arInitF = TRUE; } } - var_r26 = msmSysGroupInit(&sp10); - if (var_r26 != 0) { + result = msmSysGroupInit(&sp10); + if (result != 0) { msmFioClose(&sp10); - return var_r26; + return result; } - var_r26 = msmMusInit(&sys, &sp10); - if (var_r26 != 0) { + result = msmMusInit(&sys, &sp10); + if (result != 0) { msmFioClose(&sp10); - return var_r26; + return result; } - var_r26 = msmSeInit(&sys, &sp10); - if (var_r26 != 0) { + result = msmSeInit(&sys, &sp10); + if (result != 0) { msmFioClose(&sp10); - return var_r26; + return result; } - 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; + sys.auxParamNo[0] = sys.info->auxParamA == MSM_AUXNO_NULL ? MSM_AUXNO_NULL : MSM_AUXNO_UNSET; + sys.auxParamNo[1] = sys.info->auxParamB == MSM_AUXNO_NULL ? MSM_AUXNO_NULL : MSM_AUXNO_UNSET; + if ((s32)sys.header->auxParamSize == 0) { + result = 0; } else { - if ((sys.unk14 = msmMemAlloc(sys.unkC->unk1C)) == NULL) { - var_r26 = MSM_ERR_OUTOFMEM; + if ((sys.auxParam = msmMemAlloc(sys.header->auxParamSize)) == NULL) { + result = MSM_ERR_OUTOFMEM; } else { - if (msmFioRead(&sp10, sys.unk14, sys.unkC->unk1C, sys.unkC->unk18) < 0) { - var_r26 = MSM_ERR_READFAIL; + if (msmFioRead(&sp10, sys.auxParam, sys.header->auxParamSize, sys.header->auxParamOfs) < 0) { + result = MSM_ERR_READFAIL; } else { - var_r26 = 0; + result = 0; } } } - if (var_r26 != 0) { + if (result != 0) { msmFioClose(&sp10); - return var_r26; + return result; } msmFioClose(&sp10); - var_r26 = msmStreamInit(init->pdtPath); - if (var_r26 < 0) { - return var_r26; + result = msmStreamInit(init->pdtPath); + if (result < 0) { + return result; } AIInit(NULL); - sndSetHooks(&sp4C); - if (sndInit(sys.unk10->unk0, sys.unk10->unk1, sys.unk10->unk2, 1, 0, sys.unk10->unk14) != 0) { - return MSM_ERR_1E; + sndSetHooks(&sndHooks); + if (sndInit(sys.info->voices, sys.info->music, sys.info->sfx, 1, 0, sys.info->aramSize) != 0) { + return MSM_ERR_INITFAIL; } - sys.unk4F4 = AIRegisterDMACallback(msmSysServer); - sys.unk4F8 = 1; - var_r26 = msmStreamAmemAlloc(); - if (var_r26 < 0) { + sys.oldAIDCallback = AIRegisterDMACallback(msmSysServer); + sys.timer = 1; + result = msmStreamAmemAlloc(); + if (result < 0) { sndQuit(); - return var_r26; + return result; } - sys.unk8 = var_r26 + 0x500; - if ((s32)sys.unk10->unk10 != 0) { - temp_r3_8 = msmMemAlloc(sys.unk10->unk10 + 0x100); - if (temp_r3_8 == NULL) { + sys.aramP = result + 0x500; + if ((int)sys.info->minMem != 0) { + temp = msmMemAlloc(sys.info->minMem + 0x100); + if (temp == NULL) { msmStreamAmemFree(); sndQuit(); return MSM_ERR_OUTOFMEM; } - msmMemFree(temp_r3_8); + msmMemFree(temp); } - if (msmSysSetAuxParam(sys.unk10->unkE, sys.unk10->unkF) != 0) { + if (msmSysSetAuxParam(sys.info->auxParamA, sys.info->auxParamB) != 0) { msmStreamAmemFree(); sndQuit(); return MSM_ERR_INVALID_AUXPARAM;