638 lines
20 KiB
C
Executable file
638 lines
20 KiB
C
Executable file
#include "msm/msmse.h"
|
|
#include "msm/msmfio.h"
|
|
#include "msm/msmmem.h"
|
|
|
|
#define SE_PLAYER_EMIT (1 << 0)
|
|
|
|
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;
|
|
|
|
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(SE_PLAYER *player) {
|
|
u8 vol;
|
|
|
|
if (player->status == MSM_SE_PAUSEOUT) {
|
|
return;
|
|
}
|
|
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 {
|
|
player->status = 1;
|
|
if ((player->flag & SE_PLAYER_EMIT) && player->emitterF == TRUE) {
|
|
sndRemoveEmitter(&player->emitter);
|
|
} else {
|
|
sndFXKeyOff(player->vid);
|
|
}
|
|
}
|
|
} else {
|
|
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(player->vid, vol);
|
|
}
|
|
}
|
|
} else if (player->fadeMaxTime < 0) {
|
|
if (++player->fadeTime >= -player->fadeMaxTime) {
|
|
player->fadeMaxTime = 0;
|
|
player->fadeVol = 127;
|
|
} else {
|
|
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 == 1) {
|
|
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);
|
|
}
|
|
}
|
|
}
|
|
|
|
static void msmSePauseSub(SE_PLAYER* player, BOOL pause, s32 speed) {
|
|
s32 time;
|
|
|
|
time = speed / 15;
|
|
if (pause) {
|
|
if (player->status == MSM_SE_PAUSEIN) {
|
|
if (time != 0) {
|
|
player->pauseMaxTime = player->pauseTime = time;
|
|
player->pauseVol = 127;
|
|
} else {
|
|
player->pauseVol = 0;
|
|
sndFXVolume(player->vid, player->vol * player->baseVol * player->fadeVol * player->pauseVol / (127*127*127));
|
|
}
|
|
player->status = MSM_SE_PAUSEOUT;
|
|
}
|
|
} else {
|
|
if (player->status == MSM_SE_PAUSEOUT) {
|
|
if (time != 0) {
|
|
if (player->pauseMaxTime != 0) {
|
|
player->pauseMaxTime = -time;
|
|
} else {
|
|
player->pauseMaxTime = -time;
|
|
player->pauseTime = 0;
|
|
player->pauseVol = 0;
|
|
}
|
|
} else {
|
|
player->pauseVol = 127;
|
|
sndFXVolume(player->vid, player->vol * player->baseVol * player->fadeVol * player->pauseVol / (127*127*127));
|
|
}
|
|
player->status = MSM_SE_PAUSEIN;
|
|
}
|
|
}
|
|
}
|
|
|
|
static SE_PLAYER* msmSeSearchEntry(s32 seNo) {
|
|
SE_PLAYER *player;
|
|
s32 i;
|
|
|
|
for (i = 0; i < se.sfx; i++) {
|
|
player = &se.player[i];
|
|
if (player->status != MSM_SE_DONE && player->no == seNo) {
|
|
return player;
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
void msmSePeriodicProc(void) {
|
|
s32 i;
|
|
SE_PLAYER* player;
|
|
u8 vol;
|
|
|
|
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);
|
|
}
|
|
}
|
|
|
|
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) {
|
|
SE_PLAYER* player;
|
|
int pan;
|
|
s32 pitch;
|
|
|
|
player = msmSeSearchEntry(seNo);
|
|
if (player == NULL) {
|
|
return MSM_ERR_INVALIDSE;
|
|
}
|
|
if (param->flag & MSM_SEPARAM_VOL) {
|
|
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));
|
|
}
|
|
player->busyF = FALSE;
|
|
}
|
|
if (!(player->flag & SE_PLAYER_EMIT)) {
|
|
if (param->flag & MSM_SEPARAM_PAN) {
|
|
player->pan = param->pan;
|
|
pan = player->pan + player->basePan - 64;
|
|
if (pan < 0) {
|
|
pan = 0;
|
|
}
|
|
if (pan > 127) {
|
|
pan = 127;
|
|
}
|
|
sndFXPanning(player->vid, pan);
|
|
}
|
|
if (param->flag & MSM_SEPARAM_PITCH) {
|
|
player->pitch = param->pitch;
|
|
pitch = player->pitch + player->basePitch + 8192;
|
|
if (pitch < 0) {
|
|
pitch = 0;
|
|
}
|
|
if (pitch > 16383) {
|
|
pitch = 16383;
|
|
}
|
|
sndFXPitchBend(player->vid, pitch);
|
|
}
|
|
if (param->flag & MSM_SEPARAM_SPAN) {
|
|
player->span = param->span;
|
|
sndFXSurroundPanning(player->vid, player->span);
|
|
}
|
|
} else if (player->emitterF == TRUE) {
|
|
player->vid = sndEmitterVoiceID(&player->emitter);
|
|
if (param->flag & MSM_SEPARAM_POS) {
|
|
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) {
|
|
player->auxAVol = param->auxAVol;
|
|
sndFXReverb(player->vid, player->auxAVol);
|
|
}
|
|
if (param->flag & MSM_SEPARAM_AUXVOLB) {
|
|
player->auxBVol = param->auxBVol;
|
|
sndFXChorus(player->vid, player->auxBVol);
|
|
}
|
|
if (param->flag & MSM_SEPARAM_PAD) {
|
|
sndSendMessage(player->vid, param->pad);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
void msmSePauseAll(BOOL pause, s32 speed) {
|
|
s32 i;
|
|
SE_PLAYER* player;
|
|
|
|
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) {
|
|
SE_PLAYER* player;
|
|
s32 i;
|
|
|
|
for (i = 0; i < se.sfx; i++) {
|
|
player = &se.player[i];
|
|
if (player->status == MSM_MUS_DONE) {
|
|
continue;
|
|
}
|
|
player->busyF = TRUE;
|
|
switch (checkGrp) {
|
|
case FALSE:
|
|
player->fadeMaxTime = speed / 15;
|
|
if (player->fadeMaxTime != 0) {
|
|
player->fadeTime = player->fadeMaxTime;
|
|
player->fadeVol = 127;
|
|
} else {
|
|
player->status = 1;
|
|
if ((player->flag & SE_PLAYER_EMIT) && player->emitterF == TRUE) {
|
|
sndRemoveEmitter(&player->emitter);
|
|
} else {
|
|
sndFXKeyOff(player->vid);
|
|
}
|
|
}
|
|
break;
|
|
default:
|
|
if (msmSysCheckBaseGroup(se.seData[player->seId].gid) == 0) {
|
|
player->fadeMaxTime = speed / 15;
|
|
if (player->fadeMaxTime != 0) {
|
|
player->fadeTime = player->fadeMaxTime;
|
|
player->fadeVol = 127;
|
|
} else {
|
|
player->status = 1;
|
|
if ((player->flag & SE_PLAYER_EMIT) && player->emitterF == TRUE) {
|
|
sndRemoveEmitter(&player->emitter);
|
|
} else {
|
|
sndFXKeyOff(player->vid);
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
player->busyF = FALSE;
|
|
}
|
|
}
|
|
|
|
s32 msmSeStop(int seNo, s32 speed) {
|
|
SE_PLAYER* player;
|
|
|
|
player = msmSeSearchEntry(seNo);
|
|
if (player == NULL) {
|
|
return MSM_ERR_INVALIDSE;
|
|
}
|
|
player->busyF = TRUE;
|
|
player->fadeMaxTime = speed / 15;
|
|
if (player->fadeMaxTime != 0) {
|
|
player->fadeTime = player->fadeMaxTime;
|
|
player->fadeVol = 127;
|
|
} else {
|
|
player->status = MSM_MUS_STOP;
|
|
if ((player->flag & SE_PLAYER_EMIT) && player->emitterF == TRUE) {
|
|
sndRemoveEmitter(&player->emitter);
|
|
} else {
|
|
sndFXKeyOff(player->vid);
|
|
}
|
|
}
|
|
player->busyF = FALSE;
|
|
return 0;
|
|
}
|
|
|
|
static inline BOOL msmSeUpdateBaseParam(SE_PLAYER* player, MSM_SEPARAM* param) {
|
|
BOOL listenerF = FALSE;
|
|
|
|
if (param != NULL) {
|
|
if (param->flag & MSM_SEPARAM_VOL) {
|
|
player->vol = param->vol;
|
|
}
|
|
if (param->flag & MSM_SEPARAM_PAN) {
|
|
player->pan = param->pan;
|
|
}
|
|
if (param->flag & MSM_SEPARAM_PITCH) {
|
|
player->pitch = param->pitch;
|
|
}
|
|
if (param->flag & MSM_SEPARAM_SPAN) {
|
|
player->span = param->span;
|
|
}
|
|
if (param->flag & MSM_SEPARAM_AUXVOLA) {
|
|
player->auxAVol = param->auxAVol;
|
|
}
|
|
if (param->flag & MSM_SEPARAM_AUXVOLB) {
|
|
player->auxBVol = param->auxBVol;
|
|
}
|
|
if ((param->flag & MSM_SEPARAM_POS) && se.listenerF != 0) {
|
|
listenerF = TRUE;
|
|
}
|
|
}
|
|
player->paramInfo.paraArray = player->param;
|
|
return listenerF;
|
|
}
|
|
|
|
int msmSePlay(int seId, MSM_SEPARAM* param) {
|
|
SE_PLAYER* player;
|
|
SND_EMITTER* emitter;
|
|
MSM_SE* seData;
|
|
int pitch;
|
|
s32 pan;
|
|
s32 i;
|
|
s32 emiFlag;
|
|
|
|
if (seId < 0 || seId >= se.seMax) {
|
|
return MSM_ERR_INVALIDID;
|
|
}
|
|
seData = &se.seData[seId];
|
|
if (seData->gid == 0xFFFF) {
|
|
return MSM_ERR_REMOVEDID;
|
|
}
|
|
for (i = 0; i < se.sfx; i++) {
|
|
player = &se.player[i];
|
|
if (player->status == 0) {
|
|
break;
|
|
}
|
|
}
|
|
if (i == se.sfx) {
|
|
return MSM_ERR_CHANLIMIT;
|
|
}
|
|
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 {
|
|
emitter = NULL;
|
|
emiFlag = SND_EMITTER_DOPPLERFX;
|
|
}
|
|
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 (player->vid == -1) {
|
|
return MSM_ERR_PLAYFAIL;
|
|
}
|
|
}
|
|
player->flag |= 1;
|
|
} else {
|
|
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 (pan > 127) {
|
|
pan = 127;
|
|
}
|
|
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;
|
|
}
|
|
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(player->vid, player->span);
|
|
player->flag &= ~1;
|
|
}
|
|
player->busyF = 1;
|
|
player->seId = seId;
|
|
player->no = se.no++;
|
|
player->status = 2;
|
|
player->busyF = 0;
|
|
return player->no;
|
|
}
|
|
|
|
s32 msmSeInit(MSM_SYS* arg0, DVDFileInfo* arg1) {
|
|
s32 playerSize;
|
|
|
|
se.sfx = 0;
|
|
se.seMax = 0;
|
|
se.baseGrpNumPlay = 0;
|
|
se.numPlay = 0;
|
|
se.listenerF = 0;
|
|
if (arg0->info->seMax == 0) {
|
|
return 0;
|
|
}
|
|
if ((se.seData = msmMemAlloc(arg0->header->seSize)) == NULL) {
|
|
return MSM_ERR_OUTOFMEM;
|
|
}
|
|
if (msmFioRead(arg1, se.seData, arg0->header->seSize, arg0->header->seOfs) < 0) {
|
|
return MSM_ERR_READFAIL;
|
|
}
|
|
playerSize = arg0->info->sfx * sizeof(SE_PLAYER);
|
|
if ((se.player = msmMemAlloc(playerSize)) == NULL) {
|
|
return MSM_ERR_OUTOFMEM;
|
|
}
|
|
memset(se.player, 0, playerSize);
|
|
se.seMax = arg0->info->seMax;
|
|
se.sfx = arg0->info->sfx;
|
|
se.no = 1;
|
|
return 0;
|
|
}
|