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

Merge pull request #436 from gamemasterplc/main

Browse source 
Improve audio types
This commit is contained in:
Liam Coleman 2024-11-04 22:19:53 -06:00 • committed by GitHub
commit dc125f3067
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
11 changed files with 430 additions and 298 deletions
Download patch file Download diff file Expand all files Collapse all files

2
config/GMPE01_00/symbols.txt
View file

@ -3558,7 +3558,7 @@ msmSePlay = .text:0x80119A94; // type:function size:0x480
msmSeInit = .text:0x80119F14; // type:function size:0x130
msmStreamGetStatus = .text:0x8011A044; // type:function size:0xC8
msmStreamSetMasterVolume = .text:0x8011A10C; // type:function size:0x118
msmStreamPauseAll = .text:0x8011A224; // type:function size:0xE0
msmStreamStopAll = .text:0x8011A224; // type:function size:0xE0
msmStreamStop = .text:0x8011A304; // type:function size:0x204
msmStreamPlay = .text:0x8011A508; // type:function size:0x88
msmStreamPeriodicProc = .text:0x8011A590; // type:function size:0x8C

51
include/game/audio.h
View file

@ -3,40 +3,41 @@
#include "dolphin.h"
typedef struct hu_snd_grp_data {
/* 0x00 */ s16 ovl;
/* 0x02 */ s16 grpset;
/* 0x04 */ s32 auxANo;
/* 0x08 */ s32 auxBNo;
/* 0x0C */ s8 auxAVol;
/* 0x0D */ s8 auxBVol;
} HuSndGrpData;
typedef struct sndGrpTbl_s {
s16 ovl;
s16 grpSet;
s32 auxANo;
s32 auxBNo;
s8 auxAVol;
s8 auxBVol;
} SNDGRPTBL;
void HuAudInit(void);
s32 HuAudStreamPlay(char *name, s32 arg1);
s32 HuAudStreamPlay(char *name, BOOL flag);
void HuAudStreamVolSet(s16 vol);
void HuAudStreamPauseOn(void);
void HuAudStreamPauseOff(void);
void HuAudStreamFadeOut(s32 arg0);
void HuAudStreamFadeOut(s32 streamNo);
void HuAudAllStop(void);
void HuAudFadeOut(s32 arg0);
s32 HuAudFXPlay(s32 arg0);
s32 HuAudFXPlayVol(s32 arg0, s16 arg1);
s32 HuAudFXPlayVolPan(s32 arg0, s16 arg1, s16 arg2);
void HuAudFXStop(s32 arg0);
void HuAudFadeOut(s32 speed);
int HuAudFXPlay(int seId);
int HuAudFXPlayVol(int seId, s16 vol);
int HuAudFXPlayVolPan(int seId, s16 vol, s16 pan);
void HuAudFXStop(int seNo);
void HuAudFXAllStop(void);
void HuAudFXFadeOut(s32 arg0, s32 arg1);
void HuAudFXPanning(s32 arg0, s16 arg1);
void HuAudFXListnerSet(Vec* arg0, Vec* arg1, float arg2, float arg3);
void HuAudFXListnerSetEX(Vec* arg0, Vec* arg1, float sndDist, float sndSpeed, float arg4, float arg5, float arg6);
void HuAudFXFadeOut(int seNo, s32 speed);
void HuAudFXPanning(int seNo, s16 pan);
void HuAudFXListnerSet(Vec *pos, Vec *heading, float sndDist, float sndSpeed);
void HuAudFXListnerSetEX(Vec *pos, Vec *heading, float sndDist, float sndSpeed, float startDis, float frontSurDis, float backSurDis);
void HuAudFXListnerUpdate(Vec *arg0, Vec *arg1);
s32 HuAudFXEmiterPlay(s32 arg0, Vec *arg1);
void HuAudFXEmiterUpDate(s32 arg0, Vec *arg1);
int HuAudFXEmiterPlay(int seId, Vec *pos);
void HuAudFXEmiterUpDate(int seNo, Vec *pos);
void HuAudFXListnerKill(void);
void HuAudFXPauseAll(s32 arg0);
s32 HuAudFXStatusGet(s32 arg0);
s32 HuAudFXPitchSet(s32 arg0, s16 arg1);
s32 HuAudFXVolSet(s32 arg0, s16 arg1);
s32 HuAudFXStatusGet(int seNo);
s32 HuAudFXPitchSet(int seNo, s16 pitch);
s32 HuAudFXVolSet(int seNo, s16 vol);
s32 HuAudSeqPlay(s16 arg0);
void HuAudSeqStop(s32 arg0);
void HuAudSeqFadeOut(s32 arg0, s32 arg1);
@ -73,6 +74,6 @@ extern float Snd3DDistOffset;
extern s32 musicOffF;
extern u8 fadeStat;
extern HuSndGrpData HuSndGrpTbl[];
extern SNDGRPTBL sndGrpTable[];
#endif

270
include/game/msm.h
View file

@ -1,87 +1,203 @@
#ifndef _GAME_MSM_H
#define _GAME_MSM_H
#ifndef MSM_H
#define MSM_H
#include "dolphin.h"
#include "musyx/musyx.h"
typedef struct {
s32 unk00;
s32 unk04;
char unk08[4];
char *unk0C;
char *unk10;
s32 unk14;
s32 unk18;
s32 unk1C;
void *unk20;
s32 unk24;
} UnkMsmStruct_00; // Size 0x28
#define MSM_SEPARAM_NONE 0
#define MSM_SEPARAM_VOL (1 << 0)
#define MSM_SEPARAM_PAN (1 << 1)
#define MSM_SEPARAM_PITCH (1 << 2)
#define MSM_SEPARAM_SPAN (1 << 3)
#define MSM_SEPARAM_AUXVOLA (1 << 4)
#define MSM_SEPARAM_AUXVOLB (1 << 5)
#define MSM_SEPARAM_POS (1 << 6)
typedef struct {
/* 0x00 */ s32 unk00;
/* 0x04 */ s8 unk04;
/* 0x05 */ s8 unk05;
/* 0x06 */ s16 unk06;
/* 0x08 */ char unk08[1];
/* 0x09 */ s8 unk09;
/* 0x0A */ s8 unk0A;
/* 0x0B */ char unk0B[5];
/* 0x10 */ Vec unk10;
} UnkMsmStruct_01; // Size 0x1C
#define MSM_LISTENER_NONE 0
#define MSM_LISTENER_STARTDIS (1 << 0)
#define MSM_LISTENER_FRONTSURDIS (1 << 1)
#define MSM_LISTENER_BACKSURDIS (1 << 2)
typedef struct {
/* 0x00 */ s32 unk00;
/* 0x04 */ float startDis;
/* 0x08 */ float frontSurDis;
/* 0x0C */ float backSurDis;
} UnkMsmStruct_02; // Size (min: 0x10, max: 0x1C)
#define MSM_MUSPARAM_NONE 0
#define MSM_MUSPARAM_CHAN (1 << 0)
#define MSM_MUSPARAM_VOL (1 << 1)
#define MSM_MUSPARAM_PAUSE (1 << 2)
#define MSM_MUSPARAM_FADESPEED (1 << 3)
#define MSM_MUSPARAM_SPEED (1 << 4)
typedef struct {
/* 0x00 */ s32 unk00;
/* 0x04 */ s8 unk04;
/* 0x05 */ s8 unk05;
/* 0x06 */ u16 unk06;
} UnkMsmStruct_03; // Size unknown (min: 8, max: 0x10)
#define MSM_STREAMPARAM_NONE 0
#define MSM_STREAMPARAM_VOL (1 << 0)
#define MSM_STREAMPARAM_PAN (1 << 1)
#define MSM_STREAMPARAM_SPAN (1 << 2)
#define MSM_STREAMPARAM_AUXA (1 << 4)
#define MSM_STREAMPARAM_AUXB (1 << 5)
#define MSM_STREAMPARAM_FADESPEED (1 << 8)
#define MSM_STREAMPARAM_CHAN (1 << 9)
#define MSM_STREAMPARAM_PAUSE (1 << 10)
typedef struct {
/* 0x00 */ s32 unk00;
/* 0x04 */ char unk04[1];
/* 0x05 */ s8 unk05;
/* 0x06 */ u16 unk06;
/* 0x08 */ char unk08[1];
} UnkMsmStruct_04; // Size unknown (min: 9, max: 0x18)
#define MSM_ERR_OPENFAIL -1
#define MSM_ERR_READFAIL -2
#define MSM_ERR_OUTOFMEM -10
#define MSM_ERR_OUTOFAMEM -20
#define MSM_ERR_INITFAIL -20
#define MSM_ERR_INVALID_AUXPARAM -31
#define MSM_ERR_PLAYFAIL -33
#define MSM_ERR_STREAMALLOC_FAIL -35
#define MSM_ERR_INSTALLED -36
#define MSM_ERR_GRP_NOTLOADED -103
#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
void msmSysRegularProc(void);
void msmSysSetOutputMode(s32 arg0);
void msmSysSetAux(s32 arg0, s32 arg1);
s32 msmSysGetSampSize(s32 arg0);
#define MSM_VOL_MAX 127
#define MSM_PAN_LEFT 32
#define MSM_PAN_CENTER 64
#define MSM_PAN_RIGHT 96
#define MSM_SE_DONE 0
#define MSM_SE_PLAY 1
#define MSM_SE_PAUSEIN 2
#define MSM_SE_PAUSEOUT 3
#define MSM_MUS_DONE 0
#define MSM_MUS_STOP 1
#define MSM_MUS_PLAY 2
#define MSM_MUS_PAUSE 3
#define MSM_STREAM_DONE 0
#define MSM_STREAM_STOP 1
#define MSM_STREAM_PLAY 2
#define MSM_STREAM_PAUSEIN 3
#define MSM_STREAM_PAUSEOUT 4
#define MSM_STREAM_DVDERROR 5
#define MSM_MUS_MAX 4
#define MSM_STREAM_NONE -1
#define MSM_AUXA_DEFAULT 0
#define MSM_AUXB_DEFAULT 1
#define MSM_AUX_NONE -1
#define MSM_ENTRY_SENO_MAX 32
typedef BOOL (*MSM_OPEN)(s32 entrynum, DVDFileInfo *fileInfo);
typedef BOOL (*MSM_READ)(DVDFileInfo *fileInfo, void *addr, s32 length, s32 offset, s32 prio);
typedef BOOL (*MSM_CLOSE)(DVDFileInfo *fileInfo);
typedef struct msmAram_s {
BOOL skipARInit;
union {
struct {
u32 aramEnd;
};
struct {
u32 numEntries;
u32 *stackIndex;
};
};
} MSM_ARAM;
typedef struct msmInit_s {
char *msmPath;
char *pdtPath;
MSM_OPEN open;
MSM_READ read;
MSM_CLOSE close;
void *heap;
u32 heapSize;
} MSM_INIT;
typedef struct msmSeParam_s {
s32 flag;
s8 vol;
s8 pan;
s16 pitch;
u8 span;
s8 auxAVol;
s8 auxBVol;
s32 pad;
Vec pos;
} MSM_SEPARAM;
typedef struct msmSe_s {
u16 groupId;
u16 fxId;
s8 vol;
s8 pan;
s16 pitchBend;
u8 span;
u8 reverb;
u8 chorus;
u8 doppler;
s8 comp;
u8 pad[3];
} MSMSE;
typedef struct msmSeListener_s {
s32 flag;
float startDis;
float frontSurDis;
float backSurDis;
} MSM_SELISTENER;
typedef struct msmMusParam_s {
s32 flag;
s8 chan;
s8 vol;
u16 fadeSpeed;
u16 speed;
} MSM_MUSPARAM;
typedef struct msmStreamParam_s {
s32 flag;
s8 vol;
s8 pan;
s8 span;
s8 auxA;
s8 auxB;
s8 chan;
u16 fadeSpeed;
} MSM_STREAMPARAM;
s32 msmSysInit(MSM_INIT *init, MSM_ARAM *aram);
void msmSysSetOutputMode(SND_OUTPUTMODE mode);
s32 msmSysDelGroupAll(void);
s32 msmSysDelGroupBase(s32 arg0);
void msmSysLoadGroupBase(s32 arg0, void *arg1);
s32 msmSysLoadGroupSet(s32 arg0, void *arg1);
s32 msmSysInit(char **arg0, UnkMsmStruct_00 *arg1);
s32 msmMusGetMidiCtrl(s32 arg0, s32 arg1, s32 arg2);
s32 msmMusGetNumPlay(s32 arg0);
s32 msmMusGetStatus(s32 arg0);
void msmMusPauseAll(s32 arg0, s32 arg1);
void msmMusPause(s32 arg0, s32 arg1, s32 arg2);
void msmMusSetParam(s16 arg0, UnkMsmStruct_04 *arg1);
void msmMusStopAll(s32 arg0, s32 arg1);
void msmMusStop(s32 arg0, s32 arg1);
s32 msmMusPlay(s32 arg0, UnkMsmStruct_03 *arg1);
void msmSeDelListener(void);
void msmSeUpdataListener(Vec *arg0, Vec *arg1);
void msmSeSetListener(Vec* arg0, Vec* arg1, float arg2, float arg3, UnkMsmStruct_02 *arg4);
s32 msmSeGetEntryID(s32 arg0, void *arg1);
s32 msmSeGetNumPlay(s32 arg0);
s32 msmSeGetStatus(s32 arg0);
s32 msmSeSetParam(s32 arg0, UnkMsmStruct_01 *arg1);
void msmSePauseAll(s32 arg0, s32 arg1);
void msmSeStopAll(s32 arg0, s32 arg1);
void msmSeStop(s32 arg0, s32 arg1);
s32 msmSePlay(s32 arg0, UnkMsmStruct_01 *arg1);
s32 msmStreamGetStatus(s32 arg0);
void msmStreamPauseAll(s32 arg0);
void msmStreamStop(s32 arg0, s32 arg1);
s32 msmStreamPlay(s16 arg0, s32 *arg1);
s32 msmSysLoadGroup(s32 grp, void *buf, BOOL flag);
s32 msmSysGetSampSize(BOOL baseGrp);
s32 msmSysDelGroupBase(s32 grpNum);
#endif
s32 msmSeSetParam(int seNo, MSM_SEPARAM *param);
int msmSePlay(int seId, MSM_SEPARAM *param);
s32 msmSeStop(int seNo, s32 speed);
s32 msmSePauseAll(BOOL pause, s32 speed);
s32 msmSePause(int seNo, BOOL pause, s32 speed);
void msmSeStopAll(BOOL checkGrp, s32 speed);
s32 msmSeSetListener(Vec *pos, Vec *heading, float sndDist, float sndSpeed, MSM_SELISTENER *listener);
s32 msmSeUpdataListener(Vec *pos, Vec *heading);
void msmSeDelListener(void);
s32 msmSeGetStatus(int seNo);
s32 msmSeGetNumPlay(BOOL baseGrp);
s32 msmSeGetEntryID(s16 seId, int *seNo);
int msmMusPlay(int musId, MSM_MUSPARAM *musParam);
s32 msmMusStop(int musNo, s32 speed);
s32 msmMusPauseAll(BOOL pause, s32 speed);
s32 msmMusPause(int musNo, BOOL pause, s32 speed);
s32 msmMusGetMidiCtrl(int musNo, s32 channel, s32 ctrl);
void msmMusStopAll(BOOL checkGrp, s32 speed);
s32 msmMusGetStatus(int musNo);
s32 msmMusGetNumPlay(BOOL baseGrp);
int msmStreamPlay(int streamId, MSM_STREAMPARAM *streamParam);
s32 msmStreamStop(int streamNo, s32 speed);
s32 msmStreamPauseAll(BOOL pause, s32 speed);
s32 msmStreamPause(int streamNo, BOOL pause, s32 speed);
void msmStreamStopAll(s32 speed);
s32 msmStreamGetStatus(int streamNo);
#endif

4
src/REL/bootDll/main.c
View file

@ -502,13 +502,13 @@ static BOOL TitleProc(void)
{
float scale;
float scale_time;
s32 y_offset[32];
int seNo[32];
s16 i;
Hu3DModelAttrReset(titleModel[0], HU3D_ATTR_DISPOFF);
Hu3DModelAttrReset(titleModel[1], HU3D_ATTR_DISPOFF);
HuSprAttrReset(titleGroup, 0, HUSPR_ATTR_DISPOFF);
HuSprAttrReset(titleGroup, 1, HUSPR_ATTR_DISPOFF);
OSReport(">>>>>>>>MSM_SE_SEL_01 %d\n", msmSeGetEntryID(2092, y_offset));
OSReport(">>>>>>>>MSM_SE_SEL_01 %d\n", msmSeGetEntryID(2092, seNo));
OSReport(">>>>>>>>SE Num %d\n", msmSeGetNumPlay(0));
HuAudSStreamPlay(20);
WipeCreate(WIPE_MODE_IN, WIPE_TYPE_NORMAL, 30);

8
src/REL/instDll/main.c
View file

@ -65,13 +65,13 @@ void ObjectSetup(void)
lbl_1_bss_10 = 0;
lbl_1_bss_4 = 0;
_ClearFlag(0x1000C);
for (i = 0; HuSndGrpTbl[i].ovl != OVL_INVALID; i++) {
if (HuSndGrpTbl[i].ovl == mgInfoTbl[lbl_1_bss_14].ovl) {
for (i = 0; sndGrpTable[i].ovl != OVL_INVALID; i++) {
if (sndGrpTable[i].ovl == mgInfoTbl[lbl_1_bss_14].ovl) {
break;
}
}
if (HuSndGrpTbl[i].ovl != OVL_INVALID) {
HuAudSndGrpSetSet(HuSndGrpTbl[i].grpset);
if (sndGrpTable[i].ovl != OVL_INVALID) {
HuAudSndGrpSetSet(sndGrpTable[i].grpSet);
}
if (mgInfoTbl[lbl_1_bss_14].ovl == OVL_M411) {
if (GWMGTypeGet() == -1) {

10
src/REL/m404Dll/main.c
View file

@ -972,13 +972,13 @@ void fn_1_3F30(omObjData *object)
}
}
void fn_1_445C(s32 arg0, s16 arg1)
void fn_1_445C(int seId, s16 vol)
{
UnkMsmStruct_01 sp8;
MSM_SEPARAM param;
sp8.unk00 = 1;
sp8.unk04 = arg1;
msmSeSetParam(arg0, &sp8);
param.flag = MSM_SEPARAM_VOL;
param.vol = vol;
msmSeSetParam(seId, &param);
}
void fn_1_44A0(omObjData *object)

10
src/REL/m431Dll/main.c
View file

@ -2196,10 +2196,10 @@ void fn_1_79FC(Mtx arg0, Mtx arg1)
arg1[2][3] = 0;
}
s32 fn_1_7A78(s32 arg0, s16 arg1)
s32 fn_1_7A78(s32 arg0, s16 vol)
{
UnkMsmStruct_01 sp10;
sp10.unk00 = 1;
sp10.unk04 = arg1;
return msmSeSetParam(arg0, &sp10);
MSM_SEPARAM seParam;
seParam.flag = MSM_SEPARAM_VOL;
seParam.vol = vol;
return msmSeSetParam(arg0, &seParam);
}

12
src/REL/w04Dll/mg_coin.c
View file

@ -235,7 +235,7 @@ static void fn_1_D0DC(void) {
}
static void fn_1_D174(omObjData *arg0) {
UnkMsmStruct_03 sp8;
MSM_MUSPARAM musParam;
if (arg0->work[0] == 0) {
arg0->work[0] = MGSeqCreate(3, 0);
@ -243,11 +243,11 @@ static void fn_1_D174(omObjData *arg0) {
return;
}
if (MGSeqStatGet(arg0->work[0]) == 0) {
sp8.unk00 = 1;
sp8.unk06 = 0;
sp8.unk05 = 0x7F;
sp8.unk04 = 1;
lbl_1_data_588 = msmMusPlay(0x1D, &sp8);
musParam.flag = MSM_MUSPARAM_CHAN;
musParam.fadeSpeed = 0;
musParam.vol = 0x7F;
musParam.chan = 1;
lbl_1_data_588 = msmMusPlay(0x1D, &musParam);
arg0->func = fn_1_D230;
}
}

317
src/game/audio.c
View file

@ -5,7 +5,7 @@
#include "game/wipe.h"
#include "game/gamework_data.h"
static s32 HuSePlay(s32 arg0, UnkMsmStruct_01 *arg1);
static int HuSePlay(int seId, MSM_SEPARAM *param);
extern s16 omSysExitReq;
@ -32,29 +32,34 @@ static char *lbl_8012E9AC[] = {
""
};
void HuAudInit(void) {
UnkMsmStruct_00 sp8;
s32 temp_r3;
void HuAudInit(void)
{
MSM_INIT msmInit;
MSM_ARAM msmAram;
s32 result;
s16 i;
sp8.unk20 = HuMemDirectMalloc(HEAP_MUSIC, 0x13FC00);
sp8.unk24 = 0x13FC00;
sp8.unk0C = "/sound/mpgcsnd.msm";
sp8.unk10 = "/sound/mpgcstr.pdt";
sp8.unk14 = 0;
sp8.unk18 = 0;
sp8.unk1C = 0;
sp8.unk00 = 1;
sp8.unk04 = 0x808000;
temp_r3 = msmSysInit(&sp8.unk0C, &sp8);
if (temp_r3 < 0) {
OSReport("MSM(Sound Manager) Error:Error Code %d\n", temp_r3);
msmInit.heap = HuMemDirectMalloc(HEAP_MUSIC, 0x13FC00);
msmInit.heapSize = 0x13FC00;
msmInit.msmPath = "/sound/mpgcsnd.msm";
msmInit.pdtPath = "/sound/mpgcstr.pdt";
msmInit.open = NULL;
msmInit.read = NULL;
msmInit.close = NULL;
msmAram.skipARInit = TRUE;
msmAram.aramEnd = 0x808000;
result = msmSysInit(&msmInit, &msmAram);
if (result < 0) {
OSReport("MSM(Sound Manager) Error:Error Code %d\n", result);
while (1);
}
if (OSGetSoundMode() == 0) {
msmSysSetOutputMode(0);
if (OSGetSoundMode() == OS_SOUND_MODE_MONO) {
msmSysSetOutputMode(SND_OUTPUTMODE_MONO);
} else {
msmSysSetOutputMode(2);
msmSysSetOutputMode(SND_OUTPUTMODE_SURROUND);
}
for (i = 0; i < 64; i++) {
sndFXBuf[i][0] = -1;
@ -68,7 +73,7 @@ void HuAudInit(void) {
musicOffF = 0;
}
s32 HuAudStreamPlay(char *name, s32 arg1) {
s32 HuAudStreamPlay(char *name, BOOL flag) {
return 0;
}
@ -101,115 +106,122 @@ void HuAudFadeOut(s32 arg0) {
HuAudSStreamAllFadeOut(arg0);
}
s32 HuAudFXPlay(s32 arg0) {
int HuAudFXPlay(int seId)
{
WipeState *wipe = &wipeData;
if (omSysExitReq != 0 || (wipeData.mode == WIPE_MODE_OUT && wipe->time / wipe->duration > 0.5)) {
return 0;
}
return HuAudFXPlayVolPan(arg0, 0x7F, 0x40);
return HuAudFXPlayVolPan(seId, MSM_VOL_MAX, MSM_PAN_CENTER);
}
s32 HuAudFXPlayVol(s32 arg0, s16 arg1) {
int HuAudFXPlayVol(int seId, s16 vol) {
if (omSysExitReq != 0) {
return 0;
}
return HuAudFXPlayVolPan(arg0, arg1, 0x40);
return HuAudFXPlayVolPan(seId, vol, MSM_PAN_CENTER);
}
s32 HuAudFXPlayVolPan(s32 arg0, s16 arg1, s16 arg2) {
UnkMsmStruct_01 sp10;
int HuAudFXPlayVolPan(int seId, s16 vol, s16 pan)
{
MSM_SEPARAM seParam;
if (omSysExitReq != 0) {
return 0;
}
sp10.unk00 = 3;
sp10.unk04 = arg1;
sp10.unk05 = arg2;
return HuSePlay(arg0, &sp10);
seParam.flag = MSM_SEPARAM_VOL|MSM_SEPARAM_PAN;
seParam.vol = vol;
seParam.pan = pan;
return HuSePlay(seId, &seParam);
}
void HuAudFXStop(s32 arg0) {
msmSeStop(arg0, 0);
void HuAudFXStop(int seNo) {
msmSeStop(seNo, 0);
}
void HuAudFXAllStop(void) {
msmSeStopAll(0, 0);
}
void HuAudFXFadeOut(s32 arg0, s32 arg1) {
msmSeStop(arg0, arg1);
void HuAudFXFadeOut(int seNo, s32 speed) {
msmSeStop(seNo, speed);
}
void HuAudFXPanning(s32 arg0, s16 arg1) {
UnkMsmStruct_01 sp10;
void HuAudFXPanning(int seNo, s16 pan) {
MSM_SEPARAM seParam;
if (omSysExitReq == 0) {
sp10.unk00 = 2;
sp10.unk05 = arg1;
msmSeSetParam(arg0, &sp10);
seParam.flag = MSM_SEPARAM_PAN;
seParam.pan = pan;
msmSeSetParam(seNo, &seParam);
}
}
void HuAudFXListnerSet(Vec* arg0, Vec* arg1, float arg2, float arg3) {
void HuAudFXListnerSet(Vec *pos, Vec *heading, float sndDist, float sndSpeed)
{
if(omSysExitReq) {
return;
}
HuAudFXListnerSetEX(pos, heading,
sndDist + Snd3DDistOffset,
sndSpeed + Snd3DSpeedOffset,
Snd3DStartDisOffset,
Snd3DFrontSurDisOffset + (0.25 * sndDist + Snd3DStartDisOffset),
Snd3DBackSurDisOffset + (0.25 * sndDist + Snd3DStartDisOffset));
}
void HuAudFXListnerSetEX(Vec *pos, Vec *heading, float sndDist, float sndSpeed, float startDis, float frontSurDis, float backSurDis)
{
MSM_SELISTENER listener;
if(omSysExitReq) {
return;
}
listener.flag = MSM_LISTENER_STARTDIS|MSM_LISTENER_FRONTSURDIS|MSM_LISTENER_BACKSURDIS;
listener.startDis = startDis + Snd3DStartDisOffset;
listener.frontSurDis = frontSurDis + Snd3DFrontSurDisOffset;
listener.backSurDis = backSurDis + Snd3DBackSurDisOffset;
msmSeSetListener(pos, heading, sndDist + Snd3DDistOffset, sndSpeed + Snd3DSpeedOffset, &listener);
OSReport("//////////////////////////////////\n");
OSReport("sndDist %f\n", sndDist);
OSReport("sndSpeed %f\n", sndSpeed);
OSReport("startDis %f\n", listener.startDis);
OSReport("frontSurDis %f\n", listener.frontSurDis);
OSReport("backSurDis %f\n", listener.backSurDis);
OSReport("//////////////////////////////////\n");
}
void HuAudFXListnerUpdate(Vec *pos, Vec *heading)
{
if (omSysExitReq == 0) {
HuAudFXListnerSetEX(arg0, arg1,
arg2 + Snd3DDistOffset,
arg3 + Snd3DSpeedOffset,
Snd3DStartDisOffset,
Snd3DFrontSurDisOffset + (0.25 * arg2 + Snd3DStartDisOffset),
Snd3DBackSurDisOffset + (0.25 * arg2 + Snd3DStartDisOffset));
msmSeUpdataListener(pos, heading);
}
}
void HuAudFXListnerSetEX(Vec* arg0, Vec* arg1, float sndDist, float sndSpeed, float arg4, float arg5, float arg6) {
UnkMsmStruct_02 sp1C;
if (omSysExitReq == 0) {
sp1C.unk00 = 7;
sp1C.startDis = arg4 + Snd3DStartDisOffset;
sp1C.frontSurDis = arg5 + Snd3DFrontSurDisOffset;
sp1C.backSurDis = arg6 + Snd3DBackSurDisOffset;
msmSeSetListener(arg0, arg1, sndDist + Snd3DDistOffset, sndSpeed + Snd3DSpeedOffset, &sp1C);
OSReport("//////////////////////////////////\n");
OSReport("sndDist %f\n", sndDist);
OSReport("sndSpeed %f\n", sndSpeed);
OSReport("startDis %f\n", sp1C.startDis);
OSReport("frontSurDis %f\n", sp1C.frontSurDis);
OSReport("backSurDis %f\n", sp1C.backSurDis);
OSReport("//////////////////////////////////\n");
int HuAudFXEmiterPlay(int seId, Vec *pos)
{
MSM_SEPARAM seParam;
if(omSysExitReq) {
return 0;
}
seParam.flag = MSM_SEPARAM_POS;
seParam.pos.x = pos->x;
seParam.pos.y = pos->y;
seParam.pos.z = pos->z;
return HuSePlay(seId, &seParam);
}
void HuAudFXListnerUpdate(Vec *arg0, Vec *arg1) {
if (omSysExitReq == 0) {
msmSeUpdataListener(arg0, arg1);
}
}
s32 HuAudFXEmiterPlay(s32 arg0, Vec *arg1) {
UnkMsmStruct_01 spC;
if (omSysExitReq != 0) {
return 0;
}
spC.unk00 = 0x40;
spC.unk10.x = arg1->x;
spC.unk10.y = arg1->y;
spC.unk10.z = arg1->z;
return HuSePlay(arg0, &spC);
}
void HuAudFXEmiterUpDate(s32 arg0, Vec *arg1) {
UnkMsmStruct_01 spC;
if (omSysExitReq == 0) {
spC.unk00 = 0x40;
spC.unk10.x = arg1->x;
spC.unk10.y = arg1->y;
spC.unk10.z = arg1->z;
msmSeSetParam(arg0, &spC);
void HuAudFXEmiterUpDate(int seNo, Vec *pos)
{
MSM_SEPARAM param;
if(omSysExitReq) {
return;
}
param.flag = MSM_SEPARAM_POS;
param.pos.x = pos->x;
param.pos.y = pos->y;
param.pos.z = pos->z;
msmSeSetParam(seNo, &param);
}
void HuAudFXListnerKill(void) {
@ -220,30 +232,31 @@ void HuAudFXPauseAll(s32 arg0) {
msmSePauseAll(arg0, 0x64);
}
s32 HuAudFXStatusGet(s32 arg0) {
return msmSeGetStatus(arg0);
s32 HuAudFXStatusGet(int seNo) {
return msmSeGetStatus(seNo);
}
s32 HuAudFXPitchSet(s32 arg0, s16 arg1) {
UnkMsmStruct_01 sp10;
if (omSysExitReq != 0) {
s32 HuAudFXPitchSet(int seNo, s16 pitch)
{
MSM_SEPARAM param;
if(omSysExitReq) {
return 0;
}
sp10.unk00 = 4;
sp10.unk06 = arg1;
return msmSeSetParam(arg0, &sp10);
param.flag = MSM_SEPARAM_PITCH;
param.pitch = pitch;
return msmSeSetParam(seNo, &param);
}
s32 HuAudFXVolSet(s32 arg0, s16 arg1) {
UnkMsmStruct_01 sp10;
s32 HuAudFXVolSet(int seNo, s16 vol)
{
MSM_SEPARAM param;
if (omSysExitReq != 0) {
if(omSysExitReq) {
return 0;
}
sp10.unk00 = 1;
sp10.unk04 = arg1;
return msmSeSetParam(arg0, &sp10);
param.flag = MSM_SEPARAM_VOL;
param.vol = vol;
return msmSeSetParam(seNo, &param);
}
s32 HuAudSeqPlay(s16 arg0) {
@ -301,16 +314,16 @@ s32 HuAudSeqMidiCtrlGet(s32 arg0, s8 arg1, s8 arg2) {
return msmMusGetMidiCtrl(arg0, arg1, arg2);
}
s32 HuAudSStreamPlay(s16 arg0) {
s32 spC;
s32 temp_r31;
s32 HuAudSStreamPlay(s16 streamId) {
MSM_STREAMPARAM param;
s32 result;
if (musicOffF != 0 || omSysExitReq != 0) {
return 0;
}
spC = 0;
temp_r31 = msmStreamPlay(arg0, &spC);
return temp_r31;
param.flag = MSM_STREAMPARAM_NONE ;
result = msmStreamPlay(streamId, &param);
return result;
}
void HuAudSStreamStop(s32 arg0) {
@ -326,18 +339,18 @@ void HuAudSStreamFadeOut(s32 arg0, s32 arg1) {
}
void HuAudSStreamAllFadeOut(s32 arg0) {
msmStreamPauseAll(arg0);
msmStreamStopAll(arg0);
}
void HuAudSStreamAllStop(void) {
msmStreamPauseAll(0);
msmStreamStopAll(0);
}
s32 HuAudSStreamStatGet(s32 arg0) {
return msmStreamGetStatus(arg0);
}
HuSndGrpData HuSndGrpTbl[] = {
SNDGRPTBL sndGrpTable[] = {
{ OVL_BOOT, -1, 0, 1, -1, -1 },
{ OVL_INST, -1, 0, 1, -1, -1 },
{ OVL_M401, 18, 0, 2, 64, 64 },
@ -432,13 +445,13 @@ HuSndGrpData HuSndGrpTbl[] = {
};
void HuAudDllSndGrpSet(u16 ovl) {
HuSndGrpData *var_r31;
SNDGRPTBL *var_r31;
s16 var_r29;
var_r31 = HuSndGrpTbl;
var_r31 = sndGrpTable;
while (1) {
if (var_r31->ovl == ovl) {
var_r29 = var_r31->grpset;
var_r29 = var_r31->grpSet;
break;
}
if (var_r31->ovl == OVL_INVALID) {
@ -540,7 +553,7 @@ void HuAudAUXVolSet(s8 arg0, s8 arg1) {
}
void HuAudVoiceInit(s16 ovl) {
HuSndGrpData *var_r29;
SNDGRPTBL *var_r29;
OSTick temp_r23;
s16 temp_r26;
s16 temp_r25;
@ -550,9 +563,9 @@ void HuAudVoiceInit(s16 ovl) {
s16 i;
if (ovl != OVL_INVALID) {
var_r29 = HuSndGrpTbl;
var_r29 = sndGrpTable;
while (1) {
if (var_r29->ovl == ovl && var_r29->grpset == -1) {
if (var_r29->ovl == ovl && var_r29->grpSet == -1) {
return;
}
if (var_r29->ovl == OVL_INVALID) {
@ -615,65 +628,67 @@ void HuAudPlayerVoicePlayEntry(s16 arg0, s16 arg1) {
HuAudCharVoicePlayEntry(temp_r31, arg1);
}
s32 HuAudCharVoicePlay(s16 arg0, s16 arg1) {
UnkMsmStruct_01 spC;
s32 HuAudCharVoicePlay(s16 charNo, s16 seId)
{
MSM_SEPARAM param;
if (omSysExitReq != 0) {
return 0;
}
arg1 += (arg0 << 6);
spC.unk00 = 0;
seId += (charNo << 6);
param.flag = MSM_SEPARAM_NONE;
if (HuAuxAVol != -1) {
spC.unk00 |= 0x10;
param.flag |= MSM_SEPARAM_AUXVOLA;
}
if (HuAuxBVol != -1) {
spC.unk00 |= 0x20;
param.flag |= MSM_SEPARAM_AUXVOLB;
}
spC.unk09 = HuAuxAVol;
spC.unk0A = HuAuxBVol;
return HuSePlay(arg1, &spC);
param.auxAVol = HuAuxAVol;
param.auxBVol = HuAuxBVol;
return HuSePlay(seId, &param);
}
s32 HuAudCharVoicePlayPos(s16 arg0, s16 arg1, Vec *arg2) {
UnkMsmStruct_01 spC;
s32 HuAudCharVoicePlayPos(s16 charNo, s16 seId, Vec *pos) {
MSM_SEPARAM param;
if (omSysExitReq != 0) {
return 0;
}
arg1 += (arg0 << 6);
spC.unk00 = 0x40;
seId += (charNo << 6);
param.flag = MSM_SEPARAM_POS;
if (HuAuxAVol != -1) {
spC.unk00 |= 0x10;
param.flag |= MSM_SEPARAM_AUXVOLA;
}
if (HuAuxBVol != -1) {
spC.unk00 |= 0x20;
param.flag |= MSM_SEPARAM_AUXVOLB;
}
spC.unk09 = HuAuxAVol;
spC.unk0A = HuAuxBVol;
spC.unk10.x = arg2->x;
spC.unk10.y = arg2->y;
spC.unk10.z = arg2->z;
return HuSePlay(arg1, &spC);
param.auxAVol = HuAuxAVol;
param.auxBVol = HuAuxBVol;
param.pos.x = pos->x;
param.pos.y = pos->y;
param.pos.z = pos->z;
return HuSePlay(seId, &param);
}
void HuAudCharVoicePlayEntry(s16 arg0, s16 arg1) {
s32 spC[30]; // size unknown (min: 30, max: 33)
void HuAudCharVoicePlayEntry(s16 charNo, s16 seId) {
int spC[MSM_ENTRY_SENO_MAX]; // size unknown (min: 30, max: 33)
u16 temp_r29;
u16 i;
arg1 += (arg0 << 6);
temp_r29 = msmSeGetEntryID(arg1, spC);
seId += (charNo << 6);
temp_r29 = msmSeGetEntryID(seId, spC);
for (i = 0; i < temp_r29; i++) {
msmSeStop(spC[i], 0);
}
}
static s32 HuSePlay(s32 arg0, UnkMsmStruct_01 *arg1) {
s32 temp_r3;
static int HuSePlay(int seId, MSM_SEPARAM *param)
{
s32 result;
temp_r3 = msmSePlay(arg0, arg1);
if (temp_r3 < 0) {
OSReport("#########SE Entry Error<SE %d:ErrorNo %d>\n", arg0, temp_r3);
result = msmSePlay(seId, param);
if (result < 0) {
OSReport("#########SE Entry Error<SE %d:ErrorNo %d>\n", seId, result);
}
return temp_r3;
return result;
}

34
src/game/board/audio.c
View file

@ -23,7 +23,7 @@ void BoardMusStartBoard(void) {
void BoardMusStart(s32 arg0, s32 arg1, s8 arg2, u16 arg3) {
s16 *temp_r31 = boardSeq[arg0];
UnkMsmStruct_03 sp8;
MSM_MUSPARAM param;
if (arg1 == temp_r31[1]) {
return;
@ -31,18 +31,18 @@ void BoardMusStart(s32 arg0, s32 arg1, s8 arg2, u16 arg3) {
if (temp_r31[0] != -1) {
BoardAudSeqFadeOutFast(temp_r31[0]);
}
sp8.unk00 = 1;
param.flag = MSM_MUSPARAM_CHAN;
if (arg3 != 0) {
sp8.unk00 |= 8;
param.flag |= MSM_MUSPARAM_FADESPEED;
}
if (arg2 < 0) {
sp8.unk00 |= 2;
param.flag |= MSM_MUSPARAM_VOL;
arg2 = 0x7F;
}
sp8.unk06 = arg3;
sp8.unk05 = arg2;
sp8.unk04 = arg0;
temp_r31[0] = msmMusPlay(arg1, &sp8);
param.fadeSpeed = arg3;
param.vol = arg2;
param.chan = arg0;
temp_r31[0] = msmMusPlay(arg1, &param);
temp_r31[1] = arg1;
}
@ -68,21 +68,21 @@ void BoardMusLoudSet(s32 arg0, s32 arg1) {
}
}
void BoardMusVolPanSet(s32 arg0, s8 arg1, u16 arg2) {
void BoardMusVolPanSet(s32 arg0, s8 vol, u16 fadeSpeed) {
s16 *temp_r31 = boardSeq[arg0];
UnkMsmStruct_04 sp10;
MSM_MUSPARAM param;
if (temp_r31[0] == -1) {
return;
}
sp10.unk00 = 1;
sp10.unk00 |= 2;
if (arg1 < 0) {
arg1 = 0x7F;
param.flag = MSM_MUSPARAM_CHAN;
param.flag |= MSM_MUSPARAM_VOL;
if (vol < 0) {
vol = 0x7F;
}
sp10.unk06 = arg2;
sp10.unk05 = arg1;
msmMusSetParam(temp_r31[0], &sp10);
param.fadeSpeed = fadeSpeed;
param.vol = vol;
msmMusSetParam(temp_r31[0], &param);
}
void BoardAudSeqPause(s32 arg0, s32 arg1, u16 arg2) {

10
src/game/board/main.c
View file

@ -2169,14 +2169,14 @@ static void TauntUpdate(omObjData *object)
port = GWPlayer[i].port & 0x3;
character = GWPlayer[i].character & 0x7;
if(tauntActiveFXTbl[port] >= 0) {
UnkMsmStruct_01 param;
MSM_SEPARAM param;
float vol, pan;
vol = (64.0f*(HuPadSubStkX[port]/59.0f))+64.0f;
pan = 8191.0f*(HuPadSubStkY[port]/59.0f);
memset(&param, 0, sizeof(UnkMsmStruct_01));
param.unk00 = 6;
OSf32tos8(&vol, &param.unk05);
OSf32tos16(&pan, &param.unk06);
memset(&param, 0, sizeof(MSM_SEPARAM));
param.flag = MSM_SEPARAM_PITCH|MSM_SEPARAM_PAN;
OSf32tos8(&vol, &param.pan);
OSf32tos16(&pan, &param.pitch);
msmSeSetParam(tauntActiveFXTbl[port], &param);
} else {
if(HuPadBtnDown[port] & PAD_TRIGGER_L) {