summaryrefslogtreecommitdiff
path: root/src/code
diff options
context:
space:
mode:
Diffstat (limited to 'src/code')
-rw-r--r--src/code/audioMgr.c6
-rw-r--r--src/code/audio_effects.c68
-rw-r--r--src/code/audio_heap.c948
-rw-r--r--src/code/audio_init_params.c (renamed from src/code/audio_rodata.c)4
-rw-r--r--src/code/audio_load.c1814
-rw-r--r--src/code/audio_playback.c393
-rw-r--r--src/code/audio_seqplayer.c802
-rw-r--r--src/code/audio_synthesis.c286
-rw-r--r--src/code/code_8006BA00.c4
-rw-r--r--src/code/code_800C3C20.c2
-rw-r--r--src/code/code_800E4FE0.c84
-rw-r--r--src/code/code_800EC960.c765
-rw-r--r--src/code/code_800F7260.c553
-rw-r--r--src/code/code_800F9280.c217
-rw-r--r--src/code/fault.c6
-rw-r--r--src/code/sched.c2
-rw-r--r--src/code/z_actor.c2
-rw-r--r--src/code/z_camera.c4
-rw-r--r--src/code/z_effect_soft_sprite.c4
-rw-r--r--src/code/z_play.c4
20 files changed, 3053 insertions, 2915 deletions
diff --git a/src/code/audioMgr.c b/src/code/audioMgr.c
index 202e9c57f..a4775861e 100644
--- a/src/code/audioMgr.c
+++ b/src/code/audioMgr.c
@@ -55,9 +55,9 @@ void AudioMgr_ThreadEntry(void* arg0) {
s16* msg = NULL;
osSyncPrintf("オーディオマネージャスレッド実行開始\n"); // "Start running audio manager thread"
- func_800F70F8();
- func_800E301C(DmaMgr_DmaCallback0);
- func_800F711C();
+ Audio_Init();
+ AudioLoad_SetDmaHandler(DmaMgr_DmaHandler);
+ Audio_InitSound();
osSendMesg(&audioMgr->unk_C8, NULL, OS_MESG_BLOCK);
IrqMgr_AddClient(audioMgr->irqMgr, &irqClient, &audioMgr->unk_74);
diff --git a/src/code/audio_effects.c b/src/code/audio_effects.c
index afe2bee38..091a37780 100644
--- a/src/code/audio_effects.c
+++ b/src/code/audio_effects.c
@@ -1,51 +1,51 @@
#include "ultra64.h"
#include "global.h"
-void Audio_SequenceChannelProcessSound(SequenceChannel* seqChannel, s32 recalculateVolume, s32 b) {
+void Audio_SequenceChannelProcessSound(SequenceChannel* channel, s32 recalculateVolume, s32 b) {
f32 channelVolume;
f32 chanFreqScale;
s32 i;
- if (seqChannel->changes.s.volume || recalculateVolume) {
- channelVolume = seqChannel->volume * seqChannel->volumeScale * seqChannel->seqPlayer->appliedFadeVolume;
- if (seqChannel->seqPlayer->muted && (seqChannel->muteBehavior & 0x20)) {
- channelVolume = seqChannel->seqPlayer->muteVolumeScale * channelVolume;
+ if (channel->changes.s.volume || recalculateVolume) {
+ channelVolume = channel->volume * channel->volumeScale * channel->seqPlayer->appliedFadeVolume;
+ if (channel->seqPlayer->muted && (channel->muteBehavior & 0x20)) {
+ channelVolume = channel->seqPlayer->muteVolumeScale * channelVolume;
}
- seqChannel->appliedVolume = channelVolume * channelVolume;
+ channel->appliedVolume = channelVolume * channelVolume;
}
- if (seqChannel->changes.s.pan) {
- seqChannel->pan = seqChannel->newPan * seqChannel->panChannelWeight;
+ if (channel->changes.s.pan) {
+ channel->pan = channel->newPan * channel->panChannelWeight;
}
- chanFreqScale = seqChannel->freqScale;
+ chanFreqScale = channel->freqScale;
if (b != 0) {
- chanFreqScale *= seqChannel->seqPlayer->unk_34;
- seqChannel->changes.s.freqScale = true;
+ chanFreqScale *= channel->seqPlayer->unk_34;
+ channel->changes.s.freqScale = true;
}
for (i = 0; i < 4; i++) {
- SequenceChannelLayer* layer = seqChannel->layers[i];
+ SequenceLayer* layer = channel->layers[i];
if (layer != NULL && layer->enabled && layer->note != NULL) {
if (layer->notePropertiesNeedInit) {
layer->noteFreqScale = layer->freqScale * chanFreqScale;
- layer->noteVelocity = layer->velocitySquare2 * seqChannel->appliedVolume;
- layer->notePan = (seqChannel->pan + layer->pan * (0x80 - seqChannel->panChannelWeight)) >> 7;
+ layer->noteVelocity = layer->velocitySquare2 * channel->appliedVolume;
+ layer->notePan = (channel->pan + layer->pan * (0x80 - channel->panChannelWeight)) >> 7;
layer->notePropertiesNeedInit = false;
} else {
- if (seqChannel->changes.s.freqScale) {
+ if (channel->changes.s.freqScale) {
layer->noteFreqScale = layer->freqScale * chanFreqScale;
}
- if (seqChannel->changes.s.volume || recalculateVolume) {
- layer->noteVelocity = layer->velocitySquare2 * seqChannel->appliedVolume;
+ if (channel->changes.s.volume || recalculateVolume) {
+ layer->noteVelocity = layer->velocitySquare2 * channel->appliedVolume;
}
- if (seqChannel->changes.s.pan) {
- layer->notePan = (seqChannel->pan + layer->pan * (0x80 - seqChannel->panChannelWeight)) >> 7;
+ if (channel->changes.s.pan) {
+ layer->notePan = (channel->pan + layer->pan * (0x80 - channel->panChannelWeight)) >> 7;
}
}
}
}
- seqChannel->changes.asByte = 0;
+ channel->changes.asByte = 0;
}
void Audio_SequencePlayerProcessSound(SequencePlayer* seqPlayer) {
@@ -63,7 +63,7 @@ void Audio_SequencePlayerProcessSound(SequencePlayer* seqPlayer) {
}
if (--seqPlayer->fadeTimer == 0 && seqPlayer->state == 2) {
- Audio_SequencePlayerDisable(seqPlayer);
+ AudioSeq_SequencePlayerDisable(seqPlayer);
return;
}
}
@@ -112,14 +112,16 @@ f32 Audio_GetVibratoFreqScale(VibratoState* vib) {
f32 temp;
f32 twoToThe16th = 65536.0f;
s32 one = 1;
- SequenceChannel* channel = vib->seqChannel;
+ SequenceChannel* channel = vib->channel;
if (vib->delay != 0) {
vib->delay--;
return 1;
}
- if (channel != NO_CHANNEL) {
+ //! @bug this probably meant to compare with gAudioContext.sequenceChannelNone.
+ //! -1 isn't used as a channel pointer anywhere else.
+ if (channel != ((SequenceChannel*)(-1))) {
if (vib->extentChangeTimer) {
if (vib->extentChangeTimer == 1) {
vib->extent = (s32)channel->vibratoExtentTarget;
@@ -179,7 +181,7 @@ void Audio_NoteVibratoUpdate(Note* note) {
void Audio_NoteVibratoInit(Note* note) {
VibratoState* vib;
- SequenceChannel* seqChannel;
+ SequenceChannel* channel;
note->playbackState.vibratoFreqScale = 1.0f;
@@ -189,20 +191,20 @@ void Audio_NoteVibratoInit(Note* note) {
vib->time = 0;
vib->curve = gWaveSamples[2];
- vib->seqChannel = note->playbackState.parentLayer->seqChannel;
- seqChannel = vib->seqChannel;
- if ((vib->extentChangeTimer = seqChannel->vibratoExtentChangeDelay) == 0) {
- vib->extent = (s32)seqChannel->vibratoExtentTarget;
+ vib->channel = note->playbackState.parentLayer->channel;
+ channel = vib->channel;
+ if ((vib->extentChangeTimer = channel->vibratoExtentChangeDelay) == 0) {
+ vib->extent = (s32)channel->vibratoExtentTarget;
} else {
- vib->extent = (s32)seqChannel->vibratoExtentStart;
+ vib->extent = (s32)channel->vibratoExtentStart;
}
- if ((vib->rateChangeTimer = seqChannel->vibratoRateChangeDelay) == 0) {
- vib->rate = (s32)seqChannel->vibratoRateTarget;
+ if ((vib->rateChangeTimer = channel->vibratoRateChangeDelay) == 0) {
+ vib->rate = (s32)channel->vibratoRateTarget;
} else {
- vib->rate = (s32)seqChannel->vibratoRateStart;
+ vib->rate = (s32)channel->vibratoRateStart;
}
- vib->delay = seqChannel->vibratoDelay;
+ vib->delay = channel->vibratoDelay;
}
void Audio_NotePortamentoInit(Note* note) {
diff --git a/src/code/audio_heap.c b/src/code/audio_heap.c
index 1d264a1e7..1ed73c81b 100644
--- a/src/code/audio_heap.c
+++ b/src/code/audio_heap.c
@@ -1,6 +1,15 @@
#include "ultra64.h"
#include "global.h"
+void AudioHeap_InitSampleCaches(u32 persistentSize, u32 temporarySize);
+SampleCacheEntry* AudioHeap_AllocTemporarySampleCacheEntry(u32 size);
+SampleCacheEntry* AudioHeap_AllocPersistentSampleCacheEntry(u32 size);
+void AudioHeap_DiscardSampleCacheEntry(SampleCacheEntry* entry);
+void AudioHeap_UnapplySampleCache(SampleCacheEntry* entry, SoundFontSample* sample);
+void AudioHeap_DiscardSampleCaches(void);
+void AudioHeap_DiscardSampleBank(s32 sampleBankId);
+void AudioHeap_DiscardSampleBanks(void);
+
f32 func_800DDE20(f32 arg0) {
return 256.0f * gAudioContext.audioBufferParameters.unkUpdatesPerFrameScaled / arg0;
}
@@ -29,18 +38,18 @@ void func_800DDE3C(void) {
gAudioContext.unk_3520[0] = 0.0f;
}
-void Audio_ResetLoadStatus(void) {
+void AudioHeap_ResetLoadStatus(void) {
s32 i;
for (i = 0; i < 0x30; i++) {
- if (gAudioContext.bankLoadStatus[i] != 5) {
- gAudioContext.bankLoadStatus[i] = 0;
+ if (gAudioContext.fontLoadStatus[i] != 5) {
+ gAudioContext.fontLoadStatus[i] = 0;
}
}
for (i = 0; i < 0x30; i++) {
- if (gAudioContext.audioTableLoadStatus[i] != 5) {
- gAudioContext.audioTableLoadStatus[i] = 0;
+ if (gAudioContext.sampleFontLoadStatus[i] != 5) {
+ gAudioContext.sampleFontLoadStatus[i] = 0;
}
}
@@ -51,32 +60,32 @@ void Audio_ResetLoadStatus(void) {
}
}
-void Audio_DiscardBank(s32 bankId) {
+void AudioHeap_DiscardFont(s32 fontId) {
s32 i;
- for (i = 0; i < gAudioContext.maxSimultaneousNotes; i++) {
+ for (i = 0; i < gAudioContext.numNotes; i++) {
Note* note = &gAudioContext.notes[i];
- if (note->playbackState.bankId == bankId) {
+ if (note->playbackState.fontId == fontId) {
if (note->playbackState.unk_04 == 0 && note->playbackState.priority != 0) {
note->playbackState.parentLayer->enabled = false;
note->playbackState.parentLayer->finished = true;
}
Audio_NoteDisable(note);
Audio_AudioListRemove(&note->listItem);
- Audio_AudioListPushBack(&gAudioContext.noteFreeLists.disabled, &note->listItem);
+ AudioSeq_AudioListPushBack(&gAudioContext.noteFreeLists.disabled, &note->listItem);
}
}
}
-void func_800DE12C(s32 bankId) {
+void AudioHeap_ReleaseNotesForFont(s32 fontId) {
s32 i;
- for (i = 0; i < gAudioContext.maxSimultaneousNotes; i++) {
+ for (i = 0; i < gAudioContext.numNotes; i++) {
Note* note = &gAudioContext.notes[i];
NotePlaybackState* state = &note->playbackState;
- if (state->bankId == bankId) {
+ if (state->fontId == fontId) {
if (state->priority != 0 && state->adsr.action.s.state == ADSR_STATE_DECAY) {
state->priority = 1;
state->adsr.fadeOutVel = gAudioContext.audioBufferParameters.updatesPerFrameInv;
@@ -86,66 +95,66 @@ void func_800DE12C(s32 bankId) {
}
}
-void Audio_DiscardSequence(s32 seqId) {
+void AudioHeap_DiscardSequence(s32 seqId) {
s32 i;
for (i = 0; i < gAudioContext.audioBufferParameters.numSequencePlayers; i++) {
if (gAudioContext.seqPlayers[i].enabled && gAudioContext.seqPlayers[i].seqId == seqId) {
- Audio_SequencePlayerDisable(&gAudioContext.seqPlayers[i]);
+ AudioSeq_SequencePlayerDisable(&gAudioContext.seqPlayers[i]);
}
}
}
-void func_800DE238(void* mem, u32 size) {
+void AudioHeap_WritebackDCache(void* mem, u32 size) {
Audio_osWritebackDCache(mem, size);
}
-void* func_800DE258(SoundAllocPool* pool, u32 size) {
+void* AudioHeap_AllocZeroedAttemptExternal(AudioAllocPool* pool, u32 size) {
void* ret = NULL;
- if (gAudioContext.unkPool.start != 0) {
- ret = Audio_AllocZeroed(&gAudioContext.unkPool, size);
+ if (gAudioContext.externalPool.start != 0) {
+ ret = AudioHeap_AllocZeroed(&gAudioContext.externalPool, size);
}
if (ret == NULL) {
- ret = Audio_AllocZeroed(pool, size);
+ ret = AudioHeap_AllocZeroed(pool, size);
}
return ret;
}
-void* func_800DE2B0(SoundAllocPool* pool, u32 size) {
+void* AudioHeap_AllocAttemptExternal(AudioAllocPool* pool, u32 size) {
void* ret = NULL;
- if (gAudioContext.unkPool.start != NULL) {
- ret = Audio_Alloc(&gAudioContext.unkPool, size);
+ if (gAudioContext.externalPool.start != NULL) {
+ ret = AudioHeap_Alloc(&gAudioContext.externalPool, size);
}
if (ret == NULL) {
- ret = Audio_Alloc(pool, size);
+ ret = AudioHeap_Alloc(pool, size);
}
return ret;
}
-void* Audio_AllocDmaMemory(SoundAllocPool* pool, u32 size) {
+void* AudioHeap_AllocDmaMemory(AudioAllocPool* pool, u32 size) {
void* ret;
- ret = Audio_Alloc(pool, size);
+ ret = AudioHeap_Alloc(pool, size);
if (ret != NULL) {
- func_800DE238(ret, size);
+ AudioHeap_WritebackDCache(ret, size);
}
return ret;
}
-void* Audio_AllocDmaMemoryZeroed(SoundAllocPool* pool, u32 size) {
+void* AudioHeap_AllocDmaMemoryZeroed(AudioAllocPool* pool, u32 size) {
void* ret;
- ret = Audio_AllocZeroed(pool, size);
+ ret = AudioHeap_AllocZeroed(pool, size);
if (ret != NULL) {
- func_800DE238(ret, size);
+ AudioHeap_WritebackDCache(ret, size);
}
return ret;
}
-void* Audio_AllocZeroed(SoundAllocPool* pool, u32 size) {
- u8* ret = Audio_Alloc(pool, size);
+void* AudioHeap_AllocZeroed(AudioAllocPool* pool, u32 size) {
+ u8* ret = AudioHeap_Alloc(pool, size);
u8* ptr;
if (ret != NULL) {
@@ -157,7 +166,7 @@ void* Audio_AllocZeroed(SoundAllocPool* pool, u32 size) {
return ret;
}
-void* Audio_Alloc(SoundAllocPool* pool, u32 size) {
+void* AudioHeap_Alloc(AudioAllocPool* pool, u32 size) {
u32 aligned = ALIGN16(size);
u8* ret = pool->cur;
@@ -166,24 +175,24 @@ void* Audio_Alloc(SoundAllocPool* pool, u32 size) {
} else {
return NULL;
}
- pool->unused++;
+ pool->count++;
return ret;
}
-void Audio_SoundAllocPoolInit(SoundAllocPool* pool, void* memAddr, u32 size) {
- pool->cur = pool->start = (u8*)ALIGN16((u32)memAddr);
- pool->size = size - ((u32)memAddr & 0xF);
- pool->unused = 0;
+void AudioHeap_AllocPoolInit(AudioAllocPool* pool, void* mem, u32 size) {
+ pool->cur = pool->start = (u8*)ALIGN16((u32)mem);
+ pool->size = size - ((u32)mem & 0xF);
+ pool->count = 0;
}
-void Audio_PersistentPoolClear(PersistentPool* persistent) {
- persistent->pool.unused = 0;
+void AudioHeap_PersistentCacheClear(AudioPersistentCache* persistent) {
+ persistent->pool.count = 0;
persistent->numEntries = 0;
persistent->pool.cur = persistent->pool.start;
}
-void Audio_TemporaryPoolClear(TemporaryPool* temporary) {
- temporary->pool.unused = 0;
+void AudioHeap_TemporaryCacheClear(AudioTemporaryCache* temporary) {
+ temporary->pool.count = 0;
temporary->pool.cur = temporary->pool.start;
temporary->nextSide = 0;
temporary->entries[0].ptr = temporary->pool.start;
@@ -192,30 +201,30 @@ void Audio_TemporaryPoolClear(TemporaryPool* temporary) {
temporary->entries[1].id = -1;
}
-void func_800DE4A0(SoundAllocPool* pool) {
- pool->unused = 0;
+void AudioHeap_ResetPool(AudioAllocPool* pool) {
+ pool->count = 0;
pool->cur = pool->start;
}
-void func_800DE4B0(s32 poolIdx) {
- SoundMultiPool* loadedPool;
- SoundAllocPool* persistentPool;
- PersistentPool* persistent;
+void AudioHeap_PopCache(s32 tableType) {
+ AudioCache* loadedPool;
+ AudioAllocPool* persistentPool;
+ AudioPersistentCache* persistent;
void* entryPtr;
u8* table;
- switch (poolIdx) {
- case 0:
- loadedPool = &gAudioContext.seqLoadedPool;
+ switch (tableType) {
+ case SEQUENCE_TABLE:
+ loadedPool = &gAudioContext.seqCache;
table = gAudioContext.seqLoadStatus;
break;
- case 1:
- loadedPool = &gAudioContext.bankLoadedPool;
- table = gAudioContext.bankLoadStatus;
+ case FONT_TABLE:
+ loadedPool = &gAudioContext.fontCache;
+ table = gAudioContext.fontLoadStatus;
break;
- case 2:
- loadedPool = &gAudioContext.unusedLoadedPool;
- table = gAudioContext.audioTableLoadStatus;
+ case SAMPLE_TABLE:
+ loadedPool = &gAudioContext.sampleBankCache;
+ table = gAudioContext.sampleFontLoadStatus;
break;
}
@@ -228,71 +237,71 @@ void func_800DE4B0(s32 poolIdx) {
entryPtr = persistent->entries[persistent->numEntries - 1].ptr;
persistentPool->cur = entryPtr;
- persistentPool->unused--;
+ persistentPool->count--;
- if (poolIdx == 2) {
- func_800E0E6C(persistent->entries[persistent->numEntries - 1].id);
+ if (tableType == SAMPLE_TABLE) {
+ AudioHeap_DiscardSampleBank(persistent->entries[persistent->numEntries - 1].id);
}
- if (poolIdx == 1) {
- Audio_DiscardBank(persistent->entries[persistent->numEntries - 1].id);
+ if (tableType == FONT_TABLE) {
+ AudioHeap_DiscardFont(persistent->entries[persistent->numEntries - 1].id);
}
table[persistent->entries[persistent->numEntries - 1].id] = 0;
persistent->numEntries--;
}
-void Audio_InitMainPools(s32 sizeForAudioInitPool) {
- Audio_SoundAllocPoolInit(&gAudioContext.audioInitPool, gAudioContext.audioHeap, sizeForAudioInitPool);
- Audio_SoundAllocPoolInit(&gAudioContext.audioSessionPool, gAudioContext.audioHeap + sizeForAudioInitPool,
- gAudioContext.audioHeapSize - sizeForAudioInitPool);
- gAudioContext.unkPool.start = NULL;
+void AudioHeap_InitMainPools(s32 initPoolSize) {
+ AudioHeap_AllocPoolInit(&gAudioContext.audioInitPool, gAudioContext.audioHeap, initPoolSize);
+ AudioHeap_AllocPoolInit(&gAudioContext.audioSessionPool, gAudioContext.audioHeap + initPoolSize,
+ gAudioContext.audioHeapSize - initPoolSize);
+ gAudioContext.externalPool.start = NULL;
}
-void Audio_SessionPoolsInit(AudioPoolSplit4* split) {
+void AudioHeap_SessionPoolsInit(AudioPoolSplit4* split) {
gAudioContext.audioSessionPool.cur = gAudioContext.audioSessionPool.start;
- Audio_SoundAllocPoolInit(&gAudioContext.notesAndBuffersPool,
- Audio_Alloc(&gAudioContext.audioSessionPool, split->wantSeq), split->wantSeq);
- Audio_SoundAllocPoolInit(&gAudioContext.seqAndBankPool,
- Audio_Alloc(&gAudioContext.audioSessionPool, split->wantCustom), split->wantCustom);
+ AudioHeap_AllocPoolInit(&gAudioContext.notesAndBuffersPool,
+ AudioHeap_Alloc(&gAudioContext.audioSessionPool, split->wantSeq), split->wantSeq);
+ AudioHeap_AllocPoolInit(&gAudioContext.cachePool,
+ AudioHeap_Alloc(&gAudioContext.audioSessionPool, split->wantCustom), split->wantCustom);
}
-void Audio_SeqAndBankPoolInit(AudioPoolSplit2* split) {
- gAudioContext.seqAndBankPool.cur = gAudioContext.seqAndBankPool.start;
- Audio_SoundAllocPoolInit(&gAudioContext.persistentCommonPool,
- Audio_Alloc(&gAudioContext.seqAndBankPool, split->wantPersistent), split->wantPersistent);
- Audio_SoundAllocPoolInit(&gAudioContext.temporaryCommonPool,
- Audio_Alloc(&gAudioContext.seqAndBankPool, split->wantTemporary), split->wantTemporary);
+void AudioHeap_CachePoolInit(AudioPoolSplit2* split) {
+ gAudioContext.cachePool.cur = gAudioContext.cachePool.start;
+ AudioHeap_AllocPoolInit(&gAudioContext.persistentCommonPool,
+ AudioHeap_Alloc(&gAudioContext.cachePool, split->wantPersistent), split->wantPersistent);
+ AudioHeap_AllocPoolInit(&gAudioContext.temporaryCommonPool,
+ AudioHeap_Alloc(&gAudioContext.cachePool, split->wantTemporary), split->wantTemporary);
}
-void Audio_PersistentPoolsInit(AudioPoolSplit3* split) {
+void AudioHeap_PersistentCachesInit(AudioPoolSplit3* split) {
gAudioContext.persistentCommonPool.cur = gAudioContext.persistentCommonPool.start;
- Audio_SoundAllocPoolInit(&gAudioContext.seqLoadedPool.persistent.pool,
- Audio_Alloc(&gAudioContext.persistentCommonPool, split->wantSeq), split->wantSeq);
- Audio_SoundAllocPoolInit(&gAudioContext.bankLoadedPool.persistent.pool,
- Audio_Alloc(&gAudioContext.persistentCommonPool, split->wantBank), split->wantBank);
- Audio_SoundAllocPoolInit(&gAudioContext.unusedLoadedPool.persistent.pool,
- Audio_Alloc(&gAudioContext.persistentCommonPool, split->wantUnused), split->wantUnused);
- Audio_PersistentPoolClear(&gAudioContext.seqLoadedPool.persistent);
- Audio_PersistentPoolClear(&gAudioContext.bankLoadedPool.persistent);
- Audio_PersistentPoolClear(&gAudioContext.unusedLoadedPool.persistent);
+ AudioHeap_AllocPoolInit(&gAudioContext.seqCache.persistent.pool,
+ AudioHeap_Alloc(&gAudioContext.persistentCommonPool, split->wantSeq), split->wantSeq);
+ AudioHeap_AllocPoolInit(&gAudioContext.fontCache.persistent.pool,
+ AudioHeap_Alloc(&gAudioContext.persistentCommonPool, split->wantFont), split->wantFont);
+ AudioHeap_AllocPoolInit(&gAudioContext.sampleBankCache.persistent.pool,
+ AudioHeap_Alloc(&gAudioContext.persistentCommonPool, split->wantSample), split->wantSample);
+ AudioHeap_PersistentCacheClear(&gAudioContext.seqCache.persistent);
+ AudioHeap_PersistentCacheClear(&gAudioContext.fontCache.persistent);
+ AudioHeap_PersistentCacheClear(&gAudioContext.sampleBankCache.persistent);
}
-void Audio_TemporaryPoolsInit(AudioPoolSplit3* split) {
+void AudioHeap_TemporaryCachesInit(AudioPoolSplit3* split) {
gAudioContext.temporaryCommonPool.cur = gAudioContext.temporaryCommonPool.start;
- Audio_SoundAllocPoolInit(&gAudioContext.seqLoadedPool.temporary.pool,
- Audio_Alloc(&gAudioContext.temporaryCommonPool, split->wantSeq), split->wantSeq);
- Audio_SoundAllocPoolInit(&gAudioContext.bankLoadedPool.temporary.pool,
- Audio_Alloc(&gAudioContext.temporaryCommonPool, split->wantBank), split->wantBank);
- Audio_SoundAllocPoolInit(&gAudioContext.unusedLoadedPool.temporary.pool,
- Audio_Alloc(&gAudioContext.temporaryCommonPool, split->wantUnused), split->wantUnused);
- Audio_TemporaryPoolClear(&gAudioContext.seqLoadedPool.temporary);
- Audio_TemporaryPoolClear(&gAudioContext.bankLoadedPool.temporary);
- Audio_TemporaryPoolClear(&gAudioContext.unusedLoadedPool.temporary);
+ AudioHeap_AllocPoolInit(&gAudioContext.seqCache.temporary.pool,
+ AudioHeap_Alloc(&gAudioContext.temporaryCommonPool, split->wantSeq), split->wantSeq);
+ AudioHeap_AllocPoolInit(&gAudioContext.fontCache.temporary.pool,
+ AudioHeap_Alloc(&gAudioContext.temporaryCommonPool, split->wantFont), split->wantFont);
+ AudioHeap_AllocPoolInit(&gAudioContext.sampleBankCache.temporary.pool,
+ AudioHeap_Alloc(&gAudioContext.temporaryCommonPool, split->wantSample), split->wantSample);
+ AudioHeap_TemporaryCacheClear(&gAudioContext.seqCache.temporary);
+ AudioHeap_TemporaryCacheClear(&gAudioContext.fontCache.temporary);
+ AudioHeap_TemporaryCacheClear(&gAudioContext.sampleBankCache.temporary);
}
-void* Audio_AllocBankOrSeq(s32 poolIdx, s32 size, s32 arg2, s32 id) {
- SoundMultiPool* loadedPool;
- TemporaryPool* tp;
- SoundAllocPool* pool;
+void* AudioHeap_AllocCached(s32 tableType, s32 size, s32 cache, s32 id) {
+ AudioCache* loadedPool;
+ AudioTemporaryCache* tp;
+ AudioAllocPool* pool;
void* mem;
void* ret;
u8 firstVal;
@@ -301,22 +310,22 @@ void* Audio_AllocBankOrSeq(s32 poolIdx, s32 size, s32 arg2, s32 id) {
u8* table;
s32 side;
- switch (poolIdx) {
- case 0:
- loadedPool = &gAudioContext.seqLoadedPool;
+ switch (tableType) {
+ case SEQUENCE_TABLE:
+ loadedPool = &gAudioContext.seqCache;
table = gAudioContext.seqLoadStatus;
break;
- case 1:
- loadedPool = &gAudioContext.bankLoadedPool;
- table = gAudioContext.bankLoadStatus;
+ case FONT_TABLE:
+ loadedPool = &gAudioContext.fontCache;
+ table = gAudioContext.fontLoadStatus;
break;
- case 2:
- loadedPool = &gAudioContext.unusedLoadedPool;
- table = gAudioContext.audioTableLoadStatus;
+ case SAMPLE_TABLE:
+ loadedPool = &gAudioContext.sampleBankCache;
+ table = gAudioContext.sampleFontLoadStatus;
break;
}
- if (arg2 == 0) {
+ if (cache == CACHE_TEMPORARY) {
tp = &loadedPool->temporary;
pool = &tp->pool;
@@ -327,31 +336,31 @@ void* Audio_AllocBankOrSeq(s32 poolIdx, s32 size, s32 arg2, s32 id) {
firstVal = (tp->entries[0].id == -1) ? 0 : table[tp->entries[0].id];
secondVal = (tp->entries[1].id == -1) ? 0 : table[tp->entries[1].id];
- if (poolIdx == 1) {
+ if (tableType == FONT_TABLE) {
if (firstVal == 4) {
- for (i = 0; i < gAudioContext.maxSimultaneousNotes; i++) {
- if (gAudioContext.notes[i].playbackState.bankId == tp->entries[0].id &&
- gAudioContext.notes[i].noteSubEu.bitField0.s.enabled != 0) {
+ for (i = 0; i < gAudioContext.numNotes; i++) {
+ if (gAudioContext.notes[i].playbackState.fontId == tp->entries[0].id &&
+ gAudioContext.notes[i].noteSubEu.bitField0.enabled != 0) {
break;
}
}
- if (i == gAudioContext.maxSimultaneousNotes) {
- Audio_SetBankLoadStatus(tp->entries[0].id, 3);
+ if (i == gAudioContext.numNotes) {
+ AudioLoad_SetFontLoadStatus(tp->entries[0].id, 3);
firstVal = 3;
}
}
if (secondVal == 4) {
- for (i = 0; i < gAudioContext.maxSimultaneousNotes; i++) {
- if (gAudioContext.notes[i].playbackState.bankId == tp->entries[1].id &&
- gAudioContext.notes[i].noteSubEu.bitField0.s.enabled != 0) {
+ for (i = 0; i < gAudioContext.numNotes; i++) {
+ if (gAudioContext.notes[i].playbackState.fontId == tp->entries[1].id &&
+ gAudioContext.notes[i].noteSubEu.bitField0.enabled != 0) {
break;
}
}
- if (i == gAudioContext.maxSimultaneousNotes) {
- Audio_SetBankLoadStatus(tp->entries[1].id, 3);
+ if (i == gAudioContext.numNotes) {
+ AudioLoad_SetFontLoadStatus(tp->entries[1].id, 3);
secondVal = 3;
}
}
@@ -369,7 +378,7 @@ void* Audio_AllocBankOrSeq(s32 poolIdx, s32 size, s32 arg2, s32 id) {
tp->nextSide = 1;
} else {
// Check if there is a side which isn't in active use, if so, evict that one.
- if (poolIdx == 0) {
+ if (tableType == SEQUENCE_TABLE) {
if (firstVal == 2) {
for (i = 0; i < gAudioContext.audioBufferParameters.numSequencePlayers; i++) {
if (gAudioContext.seqPlayers[i].enabled != 0 &&
@@ -397,28 +406,28 @@ void* Audio_AllocBankOrSeq(s32 poolIdx, s32 size, s32 arg2, s32 id) {
goto done;
}
}
- } else if (poolIdx == 1) {
+ } else if (tableType == FONT_TABLE) {
if (firstVal == 2) {
- for (i = 0; i < gAudioContext.maxSimultaneousNotes; i++) {
- if (gAudioContext.notes[i].playbackState.bankId == tp->entries[0].id &&
- gAudioContext.notes[i].noteSubEu.bitField0.s.enabled != 0) {
+ for (i = 0; i < gAudioContext.numNotes; i++) {
+ if (gAudioContext.notes[i].playbackState.fontId == tp->entries[0].id &&
+ gAudioContext.notes[i].noteSubEu.bitField0.enabled != 0) {
break;
}
}
- if (i == gAudioContext.maxSimultaneousNotes) {
+ if (i == gAudioContext.numNotes) {
tp->nextSide = 0;
goto done;
}
}
if (secondVal == 2) {
- for (i = 0; i < gAudioContext.maxSimultaneousNotes; i++) {
- if (gAudioContext.notes[i].playbackState.bankId == tp->entries[1].id &&
- gAudioContext.notes[i].noteSubEu.bitField0.s.enabled != 0) {
+ for (i = 0; i < gAudioContext.numNotes; i++) {
+ if (gAudioContext.notes[i].playbackState.fontId == tp->entries[1].id &&
+ gAudioContext.notes[i].noteSubEu.bitField0.enabled != 0) {
break;
}
}
- if (i == gAudioContext.maxSimultaneousNotes) {
+ if (i == gAudioContext.numNotes) {
tp->nextSide = 1;
goto done;
}
@@ -454,12 +463,12 @@ void* Audio_AllocBankOrSeq(s32 poolIdx, s32 size, s32 arg2, s32 id) {
side = tp->nextSide;
if (tp->entries[side].id != -1) {
- if (poolIdx == 2) {
- func_800E0E6C(tp->entries[side].id);
+ if (tableType == SAMPLE_TABLE) {
+ AudioHeap_DiscardSampleBank(tp->entries[side].id);
}
table[tp->entries[side].id] = 0;
- if (poolIdx == 1) {
- Audio_DiscardBank(tp->entries[side].id);
+ if (tableType == FONT_TABLE) {
+ AudioHeap_DiscardFont(tp->entries[side].id);
}
}
@@ -471,17 +480,17 @@ void* Audio_AllocBankOrSeq(s32 poolIdx, s32 size, s32 arg2, s32 id) {
pool->cur = pool->start + size;
if (tp->entries[1].id != -1 && tp->entries[1].ptr < pool->cur) {
- if (poolIdx == 2) {
- func_800E0E6C(tp->entries[1].id);
+ if (tableType == SAMPLE_TABLE) {
+ AudioHeap_DiscardSampleBank(tp->entries[1].id);
}
table[tp->entries[1].id] = 0;
- switch (poolIdx) {
- case 0:
- Audio_DiscardSequence((s32)tp->entries[1].id);
+ switch (tableType) {
+ case SEQUENCE_TABLE:
+ AudioHeap_DiscardSequence((s32)tp->entries[1].id);
break;
- case 1:
- Audio_DiscardBank((s32)tp->entries[1].id);
+ case FONT_TABLE:
+ AudioHeap_DiscardFont((s32)tp->entries[1].id);
break;
}
@@ -497,17 +506,17 @@ void* Audio_AllocBankOrSeq(s32 poolIdx, s32 size, s32 arg2, s32 id) {
tp->entries[1].id = id;
tp->entries[1].size = size;
if (tp->entries[0].id != -1 && tp->entries[1].ptr < pool->cur) {
- if (poolIdx == 2) {
- func_800E0E6C(tp->entries[0].id);
+ if (tableType == SAMPLE_TABLE) {
+ AudioHeap_DiscardSampleBank(tp->entries[0].id);
}
table[tp->entries[0].id] = 0;
- switch (poolIdx) {
- case 0:
- Audio_DiscardSequence(tp->entries[0].id);
+ switch (tableType) {
+ case SEQUENCE_TABLE:
+ AudioHeap_DiscardSequence(tp->entries[0].id);
break;
- case 1:
- Audio_DiscardBank(tp->entries[0].id);
+ case FONT_TABLE:
+ AudioHeap_DiscardFont(tp->entries[0].id);
break;
}
@@ -525,16 +534,16 @@ void* Audio_AllocBankOrSeq(s32 poolIdx, s32 size, s32 arg2, s32 id) {
return ret;
}
- mem = Audio_Alloc(&loadedPool->persistent.pool, size);
+ mem = AudioHeap_Alloc(&loadedPool->persistent.pool, size);
loadedPool->persistent.entries[loadedPool->persistent.numEntries].ptr = mem;
if (mem == NULL) {
- switch (arg2) {
- case 2:
- return Audio_AllocBankOrSeq(poolIdx, size, 0, id);
+ switch (cache) {
+ case CACHE_EITHER:
+ return AudioHeap_AllocCached(tableType, size, CACHE_TEMPORARY, id);
- case 0:
- case 1:
+ case CACHE_TEMPORARY:
+ case CACHE_PERSISTENT:
return NULL;
}
}
@@ -544,43 +553,44 @@ void* Audio_AllocBankOrSeq(s32 poolIdx, s32 size, s32 arg2, s32 id) {
return loadedPool->persistent.entries[loadedPool->persistent.numEntries++].ptr;
}
-void* func_800DF074(s32 poolIdx, s32 arg1, s32 id) {
+void* AudioHeap_SearchCaches(s32 tableType, s32 cache, s32 id) {
void* ret;
- ret = func_800E04E8(poolIdx, id);
+ // Always search the permanent cache in addition to the regular ones.
+ ret = AudioHeap_SearchPermanentCache(tableType, id);
if (ret != NULL) {
return ret;
}
- if (arg1 == 3) {
+ if (cache == CACHE_PERMANENT) {
return NULL;
}
- return func_800DF0CC(poolIdx, arg1, id);
+ return AudioHeap_SearchRegularCaches(tableType, cache, id);
}
-void* func_800DF0CC(s32 poolIdx, s32 arg1, s32 bankId) {
+void* AudioHeap_SearchRegularCaches(s32 tableType, s32 cache, s32 id) {
u32 i;
- SoundMultiPool* loadedPool;
- TemporaryPool* temporary;
- PersistentPool* persistent;
+ AudioCache* loadedPool;
+ AudioTemporaryCache* temporary;
+ AudioPersistentCache* persistent;
- switch (poolIdx) {
- case 0:
- loadedPool = &gAudioContext.seqLoadedPool;
+ switch (tableType) {
+ case SEQUENCE_TABLE:
+ loadedPool = &gAudioContext.seqCache;
break;
- case 1:
- loadedPool = &gAudioContext.bankLoadedPool;
+ case FONT_TABLE:
+ loadedPool = &gAudioContext.fontCache;
break;
- case 2:
- loadedPool = &gAudioContext.unusedLoadedPool;
+ case SAMPLE_TABLE:
+ loadedPool = &gAudioContext.sampleBankCache;
break;
}
temporary = &loadedPool->temporary;
- if (arg1 == 0) {
- if (temporary->entries[0].id == bankId) {
+ if (cache == CACHE_TEMPORARY) {
+ if (temporary->entries[0].id == id) {
temporary->nextSide = 1;
return temporary->entries[0].ptr;
- } else if (temporary->entries[1].id == bankId) {
+ } else if (temporary->entries[1].id == id) {
temporary->nextSide = 0;
return temporary->entries[1].ptr;
} else {
@@ -590,38 +600,46 @@ void* func_800DF0CC(s32 poolIdx, s32 arg1, s32 bankId) {
persistent = &loadedPool->persistent;
for (i = 0; i < persistent->numEntries; i++) {
- if (persistent->entries[i].id == bankId) {
+ if (persistent->entries[i].id == id) {
return persistent->entries[i].ptr;
}
}
- if (arg1 == 2) {
- return func_800DF074(poolIdx, 0, bankId);
+ if (cache == CACHE_EITHER) {
+ return AudioHeap_SearchCaches(tableType, CACHE_TEMPORARY, id);
}
return NULL;
}
-void func_800DF1D8(f32 arg0, f32 arg1, u16* arg2) {
+void func_800DF1D8(f32 p, f32 q, u16* out) {
+ // With the bug below fixed, this mysterious unused function computes two recurrences
+ // out[0..7] = a_i, out[8..15] = b_i, where
+ // a_{-2} = b_{-1} = 262159 = 2^18 + 15
+ // a_{-1} = b_{-2} = 0
+ // a_i = q * a_{i-1} + p * a_{i-2}
+ // b_i = q * b_{i-1} + p * b_{i-2}
+ // These grow exponentially if p < -1 or p + |q| > 1.
s32 i;
f32 tmp[16];
- tmp[0] = (f32)(arg1 * 262159.0f);
- tmp[8] = (f32)(arg0 * 262159.0f);
- tmp[1] = (f32)((arg1 * arg0) * 262159.0f);
- tmp[9] = (f32)(((arg0 * arg0) + arg1) * 262159.0f);
+ tmp[0] = (f32)(q * 262159.0f);
+ tmp[8] = (f32)(p * 262159.0f);
+ tmp[1] = (f32)((q * p) * 262159.0f);
+ tmp[9] = (f32)(((p * p) + q) * 262159.0f);
for (i = 2; i < 8; i++) {
- //! @bug value was probably meant to be stored to tmp[i] and tmp[8 + i]
- arg2[i] = arg1 * tmp[i - 2] + arg0 * tmp[i - 1];
- arg2[8 + i] = arg1 * tmp[6 + i] + arg0 * tmp[7 + i];
+ //! @bug value should be stored to tmp[i] and tmp[8 + i], otherwise we read
+ //! garbage in later loop iterations.
+ out[i] = q * tmp[i - 2] + p * tmp[i - 1];
+ out[8 + i] = q * tmp[6 + i] + p * tmp[7 + i];
}
for (i = 0; i < 16; i++) {
- arg2[i] = tmp[i];
+ out[i] = tmp[i];
}
}
-void func_800DF5AC(s16* filter) {
+void AudioHeap_ClearFilter(s16* filter) {
s32 i;
for (i = 0; i < 8; i++) {
@@ -629,46 +647,47 @@ void func_800DF5AC(s16* filter) {
}
}
-void func_800DF5DC(s16* filter, s32 arg1) {
+void AudioHeap_LoadLowPassFilter(s16* filter, s32 cutoff) {
s32 i;
- s16* ptr = &D_80130228[8 * arg1];
+ s16* ptr = &sLowPassFilterData[8 * cutoff];
for (i = 0; i < 8; i++) {
filter[i] = ptr[i];
}
}
-void func_800DF630(s16* filter, s32 arg1) {
+void AudioHeap_LoadHighPassFilter(s16* filter, s32 cutoff) {
s32 i;
- s16* ptr = &D_80130328[8 * (arg1 - 1)];
+ s16* ptr = &sHighPassFilterData[8 * (cutoff - 1)];
for (i = 0; i < 8; i++) {
filter[i] = ptr[i];
}
}
-void func_800DF688(s16* filter, s32 arg1, s32 arg2) {
+void AudioHeap_LoadFilter(s16* filter, s32 lowPassCutoff, s32 highPassCutoff) {
s32 i;
- if (arg1 == 0 && arg2 == 0) {
- func_800DF5DC(filter, 0);
- } else if (arg2 == 0) {
- func_800DF5DC(filter, arg1);
- } else if (arg1 == 0) {
- func_800DF630(filter, arg2);
+ if (lowPassCutoff == 0 && highPassCutoff == 0) {
+ // Identity filter
+ AudioHeap_LoadLowPassFilter(filter, 0);
+ } else if (highPassCutoff == 0) {
+ AudioHeap_LoadLowPassFilter(filter, lowPassCutoff);
+ } else if (lowPassCutoff == 0) {
+ AudioHeap_LoadHighPassFilter(filter, highPassCutoff);
} else {
- s16* ptr1 = &D_80130228[8 * arg1];
- s16* ptr2 = &D_80130328[8 * (arg2 - 1)];
+ s16* ptr1 = &sLowPassFilterData[8 * lowPassCutoff];
+ s16* ptr2 = &sHighPassFilterData[8 * (highPassCutoff - 1)];
for (i = 0; i < 8; i++) {
filter[i] = (ptr1[i] + ptr2[i]) / 2;
}
}
}
-void func_800DF7BC(SynthesisReverb* reverb) {
+void AudioHeap_UpdateReverb(SynthesisReverb* reverb) {
}
-void func_800DF7C4(void) {
+void AudioHeap_UpdateReverbs(void) {
s32 count;
s32 i;
s32 j;
@@ -681,24 +700,24 @@ void func_800DF7C4(void) {
for (i = 0; i < gAudioContext.numSynthesisReverbs; i++) {
for (j = 0; j < count; j++) {
- func_800DF7BC(&gAudioContext.synthesisReverbs[i]);
+ AudioHeap_UpdateReverb(&gAudioContext.synthesisReverbs[i]);
}
}
}
-void func_800DF888(void) {
+void AudioHeap_ClearAiBuffers(void) {
s32 ind;
s32 i;
ind = gAudioContext.curAIBufIdx;
gAudioContext.aiBufLengths[ind] = gAudioContext.audioBufferParameters.minAiBufferLength;
- for (i = 0; i < 0x580; i++) {
+ for (i = 0; i < AIBUF_LEN; i++) {
gAudioContext.aiBuffers[ind][i] = 0;
}
}
-s32 Audio_ResetStep(void) {
+s32 AudioHeap_ResetStep(void) {
s32 i;
s32 j;
s32 sp24;
@@ -712,7 +731,7 @@ s32 Audio_ResetStep(void) {
switch (gAudioContext.resetStatus) {
case 5:
for (i = 0; i < gAudioContext.audioBufferParameters.numSequencePlayers; i++) {
- Audio_SequencePlayerDisableAsFinished(&gAudioContext.seqPlayers[i]);
+ AudioSeq_SequencePlayerDisableAsFinished(&gAudioContext.seqPlayers[i]);
}
gAudioContext.audioResetFadeOutFramesLeft = 2 / sp24;
gAudioContext.resetStatus--;
@@ -721,10 +740,10 @@ s32 Audio_ResetStep(void) {
case 4:
if (gAudioContext.audioResetFadeOutFramesLeft != 0) {
gAudioContext.audioResetFadeOutFramesLeft--;
- func_800DF7C4();
+ AudioHeap_UpdateReverbs();
} else {
- for (i = 0; i < gAudioContext.maxSimultaneousNotes; i++) {
- if (gAudioContext.notes[i].noteSubEu.bitField0.s.enabled &&
+ for (i = 0; i < gAudioContext.numNotes; i++) {
+ if (gAudioContext.notes[i].noteSubEu.bitField0.enabled &&
gAudioContext.notes[i].playbackState.adsr.action.s.state != ADSR_STATE_DISABLED) {
gAudioContext.notes[i].playbackState.adsr.fadeOutVel =
gAudioContext.audioBufferParameters.updatesPerFrameInv;
@@ -739,7 +758,7 @@ s32 Audio_ResetStep(void) {
case 3:
if (gAudioContext.audioResetFadeOutFramesLeft != 0) {
gAudioContext.audioResetFadeOutFramesLeft--;
- func_800DF7C4();
+ AudioHeap_UpdateReverbs();
} else {
gAudioContext.audioResetFadeOutFramesLeft = 2 / sp24;
gAudioContext.resetStatus--;
@@ -747,22 +766,22 @@ s32 Audio_ResetStep(void) {
break;
case 2:
- func_800DF888();
+ AudioHeap_ClearAiBuffers();
if (gAudioContext.audioResetFadeOutFramesLeft != 0) {
gAudioContext.audioResetFadeOutFramesLeft--;
} else {
gAudioContext.resetStatus--;
- func_800E0CBC();
- func_800E1148();
+ AudioHeap_DiscardSampleCaches();
+ AudioHeap_DiscardSampleBanks();
}
break;
case 1:
- Audio_InitHeap();
+ AudioHeap_Init();
gAudioContext.resetStatus = 0;
for (i = 0; i < 3; i++) {
gAudioContext.aiBufLengths[i] = gAudioContext.audioBufferParameters.maxAiBufferLength;
- for (j = 0; j < 0x580; j++) {
+ for (j = 0; j < AIBUF_LEN; j++) {
gAudioContext.aiBuffers[i][j] = 0;
}
}
@@ -776,7 +795,7 @@ s32 Audio_ResetStep(void) {
return 1;
}
-void Audio_InitHeap(void) {
+void AudioHeap_Init(void) {
s32 pad1[4];
s16* mem;
s32 persistentMem;
@@ -790,7 +809,7 @@ void Audio_InitHeap(void) {
AudioSpec* spec;
spec = &gAudioSpecs[gAudioContext.audioResetSpecIdToLoad];
- gAudioContext.sampleDmaReqCnt = 0;
+ gAudioContext.sampleDmaCount = 0;
gAudioContext.audioBufferParameters.frequency = spec->frequency;
gAudioContext.audioBufferParameters.aiFrequency = osAiSetFrequency(gAudioContext.audioBufferParameters.frequency);
gAudioContext.audioBufferParameters.samplesPerFrameTarget =
@@ -811,10 +830,10 @@ void Audio_InitHeap(void) {
(1.0f / 256.0f) / gAudioContext.audioBufferParameters.updatesPerFrame;
gAudioContext.audioBufferParameters.unk_24 = gAudioContext.audioBufferParameters.updatesPerFrame * 0.25f;
gAudioContext.audioBufferParameters.updatesPerFrameInv = 1.0f / gAudioContext.audioBufferParameters.updatesPerFrame;
- gAudioContext.unk_2874 = spec->unk_10;
- gAudioContext.unk_2878 = spec->unk_12;
+ gAudioContext.sampleDmaBufSize1 = spec->sampleDmaBufSize1;
+ gAudioContext.sampleDmaBufSize2 = spec->sampleDmaBufSize2;
- gAudioContext.maxSimultaneousNotes = spec->maxSimultaneousNotes;
+ gAudioContext.numNotes = spec->numNotes;
gAudioContext.audioBufferParameters.numSequencePlayers = spec->numSequencePlayers;
if (gAudioContext.audioBufferParameters.numSequencePlayers > 4) {
gAudioContext.audioBufferParameters.numSequencePlayers = 4;
@@ -838,49 +857,48 @@ void Audio_InitHeap(void) {
gAudioContext.audioBufferParameters.maxAiBufferLength -= 0x10;
}
- gAudioContext.maxAudioCmds =
- gAudioContext.maxSimultaneousNotes * 0x10 * gAudioContext.audioBufferParameters.updatesPerFrame +
- spec->numReverbs * 0x18 + 0x140;
+ gAudioContext.maxAudioCmds = gAudioContext.numNotes * 0x10 * gAudioContext.audioBufferParameters.updatesPerFrame +
+ spec->numReverbs * 0x18 + 0x140;
- persistentMem = spec->persistentSeqMem + spec->persistentBankMem + spec->persistentUnusedMem + 0x10;
- temporaryMem = spec->temporarySeqMem + spec->temporaryBankMem + spec->temporaryUnusedMem + 0x10;
+ persistentMem = spec->persistentSeqMem + spec->persistentFontMem + spec->persistentSampleMem + 0x10;
+ temporaryMem = spec->temporarySeqMem + spec->temporaryFontMem + spec->temporarySampleMem + 0x10;
totalMem = persistentMem + temporaryMem;
wantMisc = gAudioContext.audioSessionPool.size - totalMem - 0x100;
- if (gAudioContext.unkPool.start != NULL) {
- gAudioContext.unkPool.cur = gAudioContext.unkPool.start;
+ if (gAudioContext.externalPool.start != NULL) {
+ gAudioContext.externalPool.cur = gAudioContext.externalPool.start;
}
gAudioContext.sessionPoolSplit.wantSeq = wantMisc;
gAudioContext.sessionPoolSplit.wantCustom = totalMem;
- Audio_SessionPoolsInit(&gAudioContext.sessionPoolSplit);
- gAudioContext.seqAndBankPoolSplit.wantPersistent = persistentMem;
- gAudioContext.seqAndBankPoolSplit.wantTemporary = temporaryMem;
- Audio_SeqAndBankPoolInit(&gAudioContext.seqAndBankPoolSplit);
+ AudioHeap_SessionPoolsInit(&gAudioContext.sessionPoolSplit);
+ gAudioContext.cachePoolSplit.wantPersistent = persistentMem;
+ gAudioContext.cachePoolSplit.wantTemporary = temporaryMem;
+ AudioHeap_CachePoolInit(&gAudioContext.cachePoolSplit);
gAudioContext.persistentCommonPoolSplit.wantSeq = spec->persistentSeqMem;
- gAudioContext.persistentCommonPoolSplit.wantBank = spec->persistentBankMem;
- gAudioContext.persistentCommonPoolSplit.wantUnused = spec->persistentUnusedMem;
- Audio_PersistentPoolsInit(&gAudioContext.persistentCommonPoolSplit);
+ gAudioContext.persistentCommonPoolSplit.wantFont = spec->persistentFontMem;
+ gAudioContext.persistentCommonPoolSplit.wantSample = spec->persistentSampleMem;
+ AudioHeap_PersistentCachesInit(&gAudioContext.persistentCommonPoolSplit);
gAudioContext.temporaryCommonPoolSplit.wantSeq = spec->temporarySeqMem;
- gAudioContext.temporaryCommonPoolSplit.wantBank = spec->temporaryBankMem;
- gAudioContext.temporaryCommonPoolSplit.wantUnused = spec->temporaryUnusedMem;
- Audio_TemporaryPoolsInit(&gAudioContext.temporaryCommonPoolSplit);
+ gAudioContext.temporaryCommonPoolSplit.wantFont = spec->temporaryFontMem;
+ gAudioContext.temporaryCommonPoolSplit.wantSample = spec->temporarySampleMem;
+ AudioHeap_TemporaryCachesInit(&gAudioContext.temporaryCommonPoolSplit);
- Audio_ResetLoadStatus();
+ AudioHeap_ResetLoadStatus();
gAudioContext.notes =
- Audio_AllocZeroed(&gAudioContext.notesAndBuffersPool, gAudioContext.maxSimultaneousNotes * sizeof(Note));
+ AudioHeap_AllocZeroed(&gAudioContext.notesAndBuffersPool, gAudioContext.numNotes * sizeof(Note));
Audio_NoteInitAll();
Audio_InitNoteFreeList();
- gAudioContext.noteSubsEu = Audio_AllocZeroed(&gAudioContext.notesAndBuffersPool,
- gAudioContext.audioBufferParameters.updatesPerFrame *
- gAudioContext.maxSimultaneousNotes * sizeof(NoteSubEu));
+ gAudioContext.noteSubsEu =
+ AudioHeap_AllocZeroed(&gAudioContext.notesAndBuffersPool, gAudioContext.audioBufferParameters.updatesPerFrame *
+ gAudioContext.numNotes * sizeof(NoteSubEu));
for (i = 0; i != 2; i++) {
- gAudioContext.abiCmdBufs[i] =
- Audio_AllocDmaMemoryZeroed(&gAudioContext.notesAndBuffersPool, gAudioContext.maxAudioCmds * sizeof(u64));
+ gAudioContext.abiCmdBufs[i] = AudioHeap_AllocDmaMemoryZeroed(&gAudioContext.notesAndBuffersPool,
+ gAudioContext.maxAudioCmds * sizeof(u64));
}
- gAudioContext.unk_3520 = Audio_Alloc(&gAudioContext.notesAndBuffersPool, 0x100 * sizeof(f32));
+ gAudioContext.unk_3520 = AudioHeap_Alloc(&gAudioContext.notesAndBuffersPool, 0x100 * sizeof(f32));
func_800DDE3C();
for (i = 0; i < 4; i++) {
gAudioContext.synthesisReverbs[i].useReverb = 0;
@@ -903,8 +921,10 @@ void Audio_InitHeap(void) {
reverb->unk_05 = settings->unk_10;
reverb->unk_08 = settings->unk_12;
reverb->useReverb = 8;
- reverb->leftRingBuf = func_800DE258(&gAudioContext.notesAndBuffersPool, reverb->windowSize * sizeof(s16));
- reverb->rightRingBuf = func_800DE258(&gAudioContext.notesAndBuffersPool, reverb->windowSize * sizeof(s16));
+ reverb->leftRingBuf =
+ AudioHeap_AllocZeroedAttemptExternal(&gAudioContext.notesAndBuffersPool, reverb->windowSize * sizeof(s16));
+ reverb->rightRingBuf =
+ AudioHeap_AllocZeroedAttemptExternal(&gAudioContext.notesAndBuffersPool, reverb->windowSize * sizeof(s16));
reverb->nextRingBufPos = 0;
reverb->unk_20 = 0;
reverb->curFrame = 0;
@@ -914,8 +934,8 @@ void Audio_InitHeap(void) {
reverb->sound.sample = &reverb->sample;
reverb->sample.loop = &reverb->loop;
reverb->sound.tuning = 1.0f;
- reverb->sample.codec = 4;
- reverb->sample.medium = 0;
+ reverb->sample.codec = CODEC_REVERB;
+ reverb->sample.medium = MEDIUM_RAM;
reverb->sample.size = reverb->windowSize * 2;
reverb->sample.sampleAddr = (u8*)reverb->leftRingBuf;
reverb->loop.start = 0;
@@ -924,156 +944,160 @@ void Audio_InitHeap(void) {
if (reverb->downsampleRate != 1) {
reverb->unk_0E = 0x8000 / reverb->downsampleRate;
- reverb->unk_30 = Audio_AllocZeroed(&gAudioContext.notesAndBuffersPool, 0x20);
- reverb->unk_34 = Audio_AllocZeroed(&gAudioContext.notesAndBuffersPool, 0x20);
- reverb->unk_38 = Audio_AllocZeroed(&gAudioContext.notesAndBuffersPool, 0x20);
- reverb->unk_3C = Audio_AllocZeroed(&gAudioContext.notesAndBuffersPool, 0x20);
+ reverb->unk_30 = AudioHeap_AllocZeroed(&gAudioContext.notesAndBuffersPool, 0x20);
+ reverb->unk_34 = AudioHeap_AllocZeroed(&gAudioContext.notesAndBuffersPool, 0x20);
+ reverb->unk_38 = AudioHeap_AllocZeroed(&gAudioContext.notesAndBuffersPool, 0x20);
+ reverb->unk_3C = AudioHeap_AllocZeroed(&gAudioContext.notesAndBuffersPool, 0x20);
for (j = 0; j < gAudioContext.audioBufferParameters.updatesPerFrame; j++) {
- mem = func_800DE258(&gAudioContext.notesAndBuffersPool, 0x340);
+ mem = AudioHeap_AllocZeroedAttemptExternal(&gAudioContext.notesAndBuffersPool, 0x340);
reverb->items[0][j].toDownsampleLeft = mem;
reverb->items[0][j].toDownsampleRight = mem + 0x1A0 / sizeof(s16);
- mem = func_800DE258(&gAudioContext.notesAndBuffersPool, 0x340);
+ mem = AudioHeap_AllocZeroedAttemptExternal(&gAudioContext.notesAndBuffersPool, 0x340);
reverb->items[1][j].toDownsampleLeft = mem;
reverb->items[1][j].toDownsampleRight = mem + 0x1A0 / sizeof(s16);
}
}
- if (settings->unk_14 != 0) {
- reverb->filterLeftState = Audio_AllocDmaMemoryZeroed(&gAudioContext.notesAndBuffersPool, 0x40);
- reverb->filterLeft = Audio_AllocDmaMemory(&gAudioContext.notesAndBuffersPool, 8 * sizeof(s16));
- func_800DF5DC(reverb->filterLeft, settings->unk_14);
+ if (settings->lowPassFilterCutoffLeft != 0) {
+ reverb->filterLeftState = AudioHeap_AllocDmaMemoryZeroed(&gAudioContext.notesAndBuffersPool, 0x40);
+ reverb->filterLeft = AudioHeap_AllocDmaMemory(&gAudioContext.notesAndBuffersPool, 8 * sizeof(s16));
+ AudioHeap_LoadLowPassFilter(reverb->filterLeft, settings->lowPassFilterCutoffLeft);
} else {
reverb->filterLeft = NULL;
}
- if (settings->unk_16 != 0) {
- reverb->filterRightState = Audio_AllocDmaMemoryZeroed(&gAudioContext.notesAndBuffersPool, 0x40);
- reverb->filterRight = Audio_AllocDmaMemory(&gAudioContext.notesAndBuffersPool, 8 * sizeof(s16));
- func_800DF5DC(reverb->filterRight, settings->unk_16);
+ if (settings->lowPassFilterCutoffRight != 0) {
+ reverb->filterRightState = AudioHeap_AllocDmaMemoryZeroed(&gAudioContext.notesAndBuffersPool, 0x40);
+ reverb->filterRight = AudioHeap_AllocDmaMemory(&gAudioContext.notesAndBuffersPool, 8 * sizeof(s16));
+ AudioHeap_LoadLowPassFilter(reverb->filterRight, settings->lowPassFilterCutoffRight);
} else {
reverb->filterRight = NULL;
}
}
- Audio_InitSequencePlayers();
+ AudioSeq_InitSequencePlayers();
for (j = 0; j < gAudioContext.audioBufferParameters.numSequencePlayers; j++) {
- func_800EC734(j);
- Audio_ResetSequencePlayer(&gAudioContext.seqPlayers[j]);
+ AudioSeq_InitSequencePlayerChannels(j);
+ AudioSeq_ResetSequencePlayer(&gAudioContext.seqPlayers[j]);
}
- func_800E0634(spec->unk_30, spec->unk_34);
- func_800E1618(gAudioContext.maxSimultaneousNotes);
- gAudioContext.unk_176C = 0;
- Audio_SyncLoadsInit();
- func_800E4FB0();
- Audio_AsyncLoadReqInit();
+ AudioHeap_InitSampleCaches(spec->persistentSampleCacheMem, spec->temporarySampleCacheMem);
+ AudioLoad_InitSampleDmaBuffers(gAudioContext.numNotes);
+ gAudioContext.preloadSampleStackTop = 0;
+ AudioLoad_InitSlowLoads();
+ AudioLoad_InitScriptLoads();
+ AudioLoad_InitAsyncLoads();
gAudioContext.unk_4 = 0x1000;
- func_800E4D94();
+ AudioLoad_LoadPermanentSamples();
intMask = osSetIntMask(1);
osWritebackDCacheAll();
osSetIntMask(intMask);
}
-void* func_800E04E8(s32 poolIdx, s32 id) {
+void* AudioHeap_SearchPermanentCache(s32 tableType, s32 id) {
s32 i;
- for (i = 0; i < gAudioContext.unk_2D50.unused; i++) {
- if (gAudioContext.unk_2D60[i].poolIndex == poolIdx && gAudioContext.unk_2D60[i].id == id) {
- return gAudioContext.unk_2D60[i].ptr;
+ for (i = 0; i < gAudioContext.permanentPool.count; i++) {
+ if (gAudioContext.permanentCache[i].tableType == tableType && gAudioContext.permanentCache[i].id == id) {
+ return gAudioContext.permanentCache[i].ptr;
}
}
return NULL;
}
-void* func_800E0540(s32 poolIdx, s32 id, u32 size) {
+void* AudioHeap_AllocPermanent(s32 tableType, s32 id, u32 size) {
void* ret;
- s32 sp18;
+ s32 index;
- sp18 = gAudioContext.unk_2D50.unused;
+ index = gAudioContext.permanentPool.count;
- ret = Audio_Alloc(&gAudioContext.unk_2D50, size);
- gAudioContext.unk_2D60[sp18].ptr = ret;
+ ret = AudioHeap_Alloc(&gAudioContext.permanentPool, size);
+ gAudioContext.permanentCache[index].ptr = ret;
if (ret == NULL) {
return NULL;
}
- gAudioContext.unk_2D60[sp18].poolIndex = poolIdx;
- gAudioContext.unk_2D60[sp18].id = id;
- gAudioContext.unk_2D60[sp18].size = size;
+ gAudioContext.permanentCache[index].tableType = tableType;
+ gAudioContext.permanentCache[index].id = id;
+ gAudioContext.permanentCache[index].size = size;
//! @bug UB: missing return. "ret" is in v0 at this point, but doing an
// explicit return uses an additional register.
// return ret;
}
-void* func_800E05C4(u32 size, s32 arg1, void* arg2, s8 arg3, s32 arg4) {
- UnkHeapEntry* entry;
+void* AudioHeap_AllocSampleCache(u32 size, s32 fontId, void* sampleAddr, s8 medium, s32 cache) {
+ SampleCacheEntry* entry;
- if (arg4 == 0) {
- entry = func_800E06CC(size);
+ if (cache == CACHE_TEMPORARY) {
+ entry = AudioHeap_AllocTemporarySampleCacheEntry(size);
} else {
- entry = func_800E0BF8(size);
+ entry = AudioHeap_AllocPersistentSampleCacheEntry(size);
}
if (entry != NULL) {
- entry->unk_02 = arg1;
- entry->unk_0C = arg2;
- entry->unk_01 = arg3;
- return entry->unk_08;
+ //! @bug Should use sampleBankId, not fontId
+ entry->sampleBankId = fontId;
+ entry->sampleAddr = sampleAddr;
+ entry->origMedium = medium;
+ return entry->allocatedAddr;
}
return NULL;
}
-void func_800E0634(u32 arg0, u32 arg1) {
+void AudioHeap_InitSampleCaches(u32 persistentSize, u32 temporarySize) {
void* mem;
- mem = func_800DE2B0(&gAudioContext.notesAndBuffersPool, arg0);
+ mem = AudioHeap_AllocAttemptExternal(&gAudioContext.notesAndBuffersPool, persistentSize);
if (mem == NULL) {
- gAudioContext.unk_2EE0.pool.size = 0;
+ gAudioContext.persistentSampleCache.pool.size = 0;
} else {
- Audio_SoundAllocPoolInit(&gAudioContext.unk_2EE0.pool, mem, arg0);
+ AudioHeap_AllocPoolInit(&gAudioContext.persistentSampleCache.pool, mem, persistentSize);
}
- mem = func_800DE2B0(&gAudioContext.notesAndBuffersPool, arg1);
+ mem = AudioHeap_AllocAttemptExternal(&gAudioContext.notesAndBuffersPool, temporarySize);
if (mem == NULL) {
- gAudioContext.unk_3174.pool.size = 0;
+ gAudioContext.temporarySampleCache.pool.size = 0;
} else {
- Audio_SoundAllocPoolInit(&gAudioContext.unk_3174.pool, mem, arg1);
+ AudioHeap_AllocPoolInit(&gAudioContext.temporarySampleCache.pool, mem, temporarySize);
}
- gAudioContext.unk_2EE0.size = 0;
- gAudioContext.unk_3174.size = 0;
+ gAudioContext.persistentSampleCache.size = 0;
+ gAudioContext.temporarySampleCache.size = 0;
}
-UnkHeapEntry* func_800E06CC(u32 size) {
+SampleCacheEntry* AudioHeap_AllocTemporarySampleCacheEntry(u32 size) {
u8* allocAfter;
u8* allocBefore;
void* mem;
s32 index;
s32 i;
- UnkHeapEntry* ret;
- AudioStruct0D68* item;
- UnkPool* unkPool;
+ SampleCacheEntry* ret;
+ AudioPreloadReq* preload;
+ AudioSampleCache* pool;
u8* start;
u8* end;
- unkPool = &gAudioContext.unk_3174;
- allocBefore = unkPool->pool.cur;
- mem = Audio_Alloc(&unkPool->pool, size);
+ pool = &gAudioContext.temporarySampleCache;
+ allocBefore = pool->pool.cur;
+ mem = AudioHeap_Alloc(&pool->pool, size);
if (mem == NULL) {
- u8* old = unkPool->pool.cur;
- unkPool->pool.cur = unkPool->pool.start;
- mem = Audio_Alloc(&unkPool->pool, size);
+ // Reset the pool and try again. We still keep pointers to within the
+ // pool, so we have to be careful to discard existing overlapping
+ // allocations further down.
+ u8* old = pool->pool.cur;
+ pool->pool.cur = pool->pool.start;
+ mem = AudioHeap_Alloc(&pool->pool, size);
if (mem == NULL) {
- unkPool->pool.cur = old;
+ pool->pool.cur = old;
return NULL;
}
- allocBefore = unkPool->pool.start;
+ allocBefore = pool->pool.start;
}
- allocAfter = unkPool->pool.cur;
+ allocAfter = pool->pool.cur;
index = -1;
- for (i = 0; i < gAudioContext.unk_176C; i++) {
- item = &gAudioContext.unk_0D68[i];
- if (item->isFree == false) {
- start = item->ramAddr;
- end = item->ramAddr + item->sample->size - 1;
+ for (i = 0; i < gAudioContext.preloadSampleStackTop; i++) {
+ preload = &gAudioContext.preloadSampleStack[i];
+ if (preload->isFree == false) {
+ start = preload->ramAddr;
+ end = preload->ramAddr + preload->sample->size - 1;
if (end < allocBefore && start < allocBefore) {
continue;
@@ -1082,18 +1106,18 @@ UnkHeapEntry* func_800E06CC(u32 size) {
continue;
}
- // Overlap
- item->isFree = true;
+ // Overlap, skip this preload.
+ preload->isFree = true;
}
}
- for (i = 0; i < unkPool->size; i++) {
- if (unkPool->entries[i].unk_00 == 0) {
+ for (i = 0; i < pool->size; i++) {
+ if (pool->entries[i].inUse == false) {
continue;
}
- start = unkPool->entries[i].unk_08;
- end = start + unkPool->entries[i].size - 1;
+ start = pool->entries[i].allocatedAddr;
+ end = start + pool->entries[i].size - 1;
if (end < allocBefore && start < allocBefore) {
continue;
@@ -1102,273 +1126,279 @@ UnkHeapEntry* func_800E06CC(u32 size) {
continue;
}
- // Overlap. Discard existing entry?
- func_800E0AD8(&unkPool->entries[i]);
+ // Overlap, discard existing entry.
+ AudioHeap_DiscardSampleCacheEntry(&pool->entries[i]);
if (index == -1) {
index = i;
}
}
if (index == -1) {
- index = unkPool->size++;
+ index = pool->size++;
}
- ret = &unkPool->entries[index];
- ret->unk_00 = 1;
- ret->unk_08 = mem;
+ ret = &pool->entries[index];
+ ret->inUse = true;
+ ret->allocatedAddr = mem;
ret->size = size;
return ret;
}
-void func_800E0964(UnkHeapEntry* entry, s32 bankId) {
+void AudioHeap_UnapplySampleCacheForFont(SampleCacheEntry* entry, s32 fontId) {
Drum* drum;
Instrument* inst;
- AudioBankSound* sfx;
+ SoundFontSound* sfx;
s32 instId;
s32 drumId;
s32 sfxId;
- for (instId = 0; instId < gAudioContext.ctlEntries[bankId].numInstruments; instId++) {
- inst = Audio_GetInstrumentInner(bankId, instId);
+ for (instId = 0; instId < gAudioContext.soundFonts[fontId].numInstruments; instId++) {
+ inst = Audio_GetInstrumentInner(fontId, instId);
if (inst != NULL) {
if (inst->normalRangeLo != 0) {
- func_800E0BB4(entry, inst->lowNotesSound.sample);
+ AudioHeap_UnapplySampleCache(entry, inst->lowNotesSound.sample);
}
if (inst->normalRangeHi != 0x7F) {
- func_800E0BB4(entry, inst->highNotesSound.sample);
+ AudioHeap_UnapplySampleCache(entry, inst->highNotesSound.sample);
}
- func_800E0BB4(entry, inst->normalNotesSound.sample);
+ AudioHeap_UnapplySampleCache(entry, inst->normalNotesSound.sample);
}
}
- for (drumId = 0; drumId < gAudioContext.ctlEntries[bankId].numDrums; drumId++) {
- drum = Audio_GetDrum(bankId, drumId);
+ for (drumId = 0; drumId < gAudioContext.soundFonts[fontId].numDrums; drumId++) {
+ drum = Audio_GetDrum(fontId, drumId);
if (drum != NULL) {
- func_800E0BB4(entry, drum->sound.sample);
+ AudioHeap_UnapplySampleCache(entry, drum->sound.sample);
}
}
- for (sfxId = 0; sfxId < gAudioContext.ctlEntries[bankId].numSfx; sfxId++) {
- sfx = Audio_GetSfx(bankId, sfxId);
+ for (sfxId = 0; sfxId < gAudioContext.soundFonts[fontId].numSfx; sfxId++) {
+ sfx = Audio_GetSfx(fontId, sfxId);
if (sfx != NULL) {
- func_800E0BB4(entry, sfx->sample);
+ AudioHeap_UnapplySampleCache(entry, sfx->sample);
}
}
}
-void func_800E0AD8(UnkHeapEntry* entry) {
- s32 numBanks;
- s32 unk2;
- s32 unk3;
- s32 bankId;
-
- numBanks = gAudioContext.audioBankTable->header.entryCnt;
- for (bankId = 0; bankId < numBanks; bankId++) {
- unk2 = gAudioContext.ctlEntries[bankId].unk_02;
- unk3 = gAudioContext.ctlEntries[bankId].unk_03;
- if (((unk2 != 0xFF) && (entry->unk_02 == unk2)) || ((unk3 != 0xFF) && (entry->unk_02 == unk3)) ||
- entry->unk_02 == 0) {
- if (func_800DF074(1, 2, bankId) != NULL) {
- if (Audio_IsBankLoadComplete(bankId) != 0) {
- func_800E0964(entry, bankId);
+void AudioHeap_DiscardSampleCacheEntry(SampleCacheEntry* entry) {
+ s32 numFonts;
+ s32 sampleBankId1;
+ s32 sampleBankId2;
+ s32 fontId;
+
+ numFonts = gAudioContext.soundFontTable->numEntries;
+ for (fontId = 0; fontId < numFonts; fontId++) {
+ sampleBankId1 = gAudioContext.soundFonts[fontId].sampleBankId1;
+ sampleBankId2 = gAudioContext.soundFonts[fontId].sampleBankId2;
+ if (((sampleBankId1 != 0xFF) && (entry->sampleBankId == sampleBankId1)) ||
+ ((sampleBankId2 != 0xFF) && (entry->sampleBankId == sampleBankId2)) || entry->sampleBankId == 0) {
+ if (AudioHeap_SearchCaches(FONT_TABLE, CACHE_EITHER, fontId) != NULL) {
+ if (AudioLoad_IsFontLoadComplete(fontId) != 0) {
+ AudioHeap_UnapplySampleCacheForFont(entry, fontId);
}
}
}
}
}
-void func_800E0BB4(UnkHeapEntry* entry, AudioBankSample* sample) {
+void AudioHeap_UnapplySampleCache(SampleCacheEntry* entry, SoundFontSample* sample) {
if (sample != NULL) {
- if (sample->sampleAddr == entry->unk_08) {
- sample->sampleAddr = entry->unk_0C;
- sample->medium = entry->unk_01;
+ if (sample->sampleAddr == entry->allocatedAddr) {
+ sample->sampleAddr = entry->sampleAddr;
+ sample->medium = entry->origMedium;
}
}
}
-UnkHeapEntry* func_800E0BF8(u32 size) {
- UnkPool* pool;
- UnkHeapEntry* entry;
+SampleCacheEntry* AudioHeap_AllocPersistentSampleCacheEntry(u32 size) {
+ AudioSampleCache* pool;
+ SampleCacheEntry* entry;
void* mem;
- pool = &gAudioContext.unk_2EE0;
- mem = Audio_Alloc(&pool->pool, size);
+ pool = &gAudioContext.persistentSampleCache;
+ mem = AudioHeap_Alloc(&pool->pool, size);
if (mem == NULL) {
return NULL;
}
entry = &pool->entries[pool->size];
- entry->unk_00 = 1;
- entry->unk_08 = mem;
+ entry->inUse = true;
+ entry->allocatedAddr = mem;
entry->size = size;
pool->size++;
return entry;
}
-void func_800E0C80(UnkHeapEntry* entry, s32 arg1, s32 arg2, s32 bankId) {
- if ((entry->unk_02 == arg1) || (entry->unk_02 == arg2) || (entry->unk_02 == 0)) {
- func_800E0964(entry, bankId);
+void AudioHeap_DiscardSampleCacheForFont(SampleCacheEntry* entry, s32 sampleBankId1, s32 sampleBankId2, s32 fontId) {
+ if ((entry->sampleBankId == sampleBankId1) || (entry->sampleBankId == sampleBankId2) ||
+ (entry->sampleBankId == 0)) {
+ AudioHeap_UnapplySampleCacheForFont(entry, fontId);
}
}
-void func_800E0CBC(void) {
- s32 numBanks;
- s32 unk2;
- s32 unk3;
- s32 bankId;
+void AudioHeap_DiscardSampleCaches(void) {
+ s32 numFonts;
+ s32 sampleBankId1;
+ s32 sampleBankId2;
+ s32 fontId;
s32 j;
- numBanks = gAudioContext.audioBankTable->header.entryCnt;
- for (bankId = 0; bankId < numBanks; bankId++) {
- unk2 = gAudioContext.ctlEntries[bankId].unk_02;
- unk3 = gAudioContext.ctlEntries[bankId].unk_03;
- if ((unk2 == 0xFF) && (unk3 == 0xFF)) {
+ numFonts = gAudioContext.soundFontTable->numEntries;
+ for (fontId = 0; fontId < numFonts; fontId++) {
+ sampleBankId1 = gAudioContext.soundFonts[fontId].sampleBankId1;
+ sampleBankId2 = gAudioContext.soundFonts[fontId].sampleBankId2;
+ if ((sampleBankId1 == 0xFF) && (sampleBankId2 == 0xFF)) {
continue;
}
- if (func_800DF074(1, 3, bankId) == NULL || !Audio_IsBankLoadComplete(bankId)) {
+ if (AudioHeap_SearchCaches(FONT_TABLE, CACHE_PERMANENT, fontId) == NULL ||
+ !AudioLoad_IsFontLoadComplete(fontId)) {
continue;
}
- for (j = 0; j < gAudioContext.unk_2EE0.size; j++) {
- func_800E0C80(&gAudioContext.unk_2EE0.entries[j], unk2, unk3, bankId);
+ for (j = 0; j < gAudioContext.persistentSampleCache.size; j++) {
+ AudioHeap_DiscardSampleCacheForFont(&gAudioContext.persistentSampleCache.entries[j], sampleBankId1,
+ sampleBankId2, fontId);
}
- for (j = 0; j < gAudioContext.unk_3174.size; j++) {
- func_800E0C80(&gAudioContext.unk_3174.entries[j], unk2, unk3, bankId);
+ for (j = 0; j < gAudioContext.temporarySampleCache.size; j++) {
+ AudioHeap_DiscardSampleCacheForFont(&gAudioContext.temporarySampleCache.entries[j], sampleBankId1,
+ sampleBankId2, fontId);
}
}
}
typedef struct {
- u8* unk_0;
- u8* unk_4;
- u32 unk_8;
- u8 unk_C;
-} Struct_800E0E0C;
+ u32 oldAddr;
+ u32 newAddr;
+ u32 size;
+ u8 newMedium;
+} StorageChange;
-void func_800E0E0C(Struct_800E0E0C* arg0, AudioBankSample* sample) {
+void AudioHeap_ChangeStorage(StorageChange* change, SoundFontSample* sample) {
if (sample != NULL) {
- u8* start = arg0->unk_0;
- u8* end = arg0->unk_0 + arg0->unk_8;
- u8* sampleAddr = sample->sampleAddr;
- if (start <= sampleAddr && sampleAddr < end) {
- sample->sampleAddr = sampleAddr - start + arg0->unk_4;
- sample->medium = arg0->unk_C & 0xFF;
+ u32 start = change->oldAddr;
+ u32 end = change->oldAddr + change->size;
+ if (start <= (u32)sample->sampleAddr && (u32)sample->sampleAddr < end) {
+ sample->sampleAddr = sample->sampleAddr - start + change->newAddr;
+ sample->medium = change->newMedium;
}
}
}
-void func_800E0E6C(s32 id) {
- func_800E0EB4(0, id);
+void AudioHeap_ApplySampleBankCacheInternal(s32 apply, s32 id);
+
+void AudioHeap_DiscardSampleBank(s32 sampleBankId) {
+ AudioHeap_ApplySampleBankCacheInternal(false, sampleBankId);
}
-void func_800E0E90(s32 id) {
- func_800E0EB4(1, id);
+void AudioHeap_ApplySampleBankCache(s32 sampleBankId) {
+ AudioHeap_ApplySampleBankCacheInternal(true, sampleBankId);
}
-void func_800E0EB4(s32 arg0, s32 id) {
- AudioTable* audioTable;
- AudioTableEntry* thing;
- s32 numBanks;
+void AudioHeap_ApplySampleBankCacheInternal(s32 apply, s32 sampleBankId) {
+ AudioTable* sampleBankTable;
+ AudioTableEntry* entry;
+ s32 numFonts;
s32 instId;
s32 drumId;
s32 sfxId;
- Struct_800E0E0C sp78;
- s32 unk2;
- s32 unk3;
- s32 bankId;
+ StorageChange change;
+ s32 sampleBankId1;
+ s32 sampleBankId2;
+ s32 fontId;
Drum* drum;
Instrument* inst;
- AudioBankSound* sfx;
- u8** fakematch;
+ SoundFontSound* sfx;
+ u32* fakematch;
s32 pad[4];
- audioTable = gAudioContext.audioTable;
- numBanks = gAudioContext.audioBankTable->header.entryCnt;
- sp78.unk_0 = func_800DF074(2, 2, id);
- if (sp78.unk_0 == NULL) {
+ sampleBankTable = gAudioContext.sampleBankTable;
+ numFonts = gAudioContext.soundFontTable->numEntries;
+ change.oldAddr = AudioHeap_SearchCaches(SAMPLE_TABLE, CACHE_EITHER, sampleBankId);
+ if (change.oldAddr == 0) {
return;
}
- thing = &audioTable->entries[id];
- sp78.unk_8 = thing->size;
- sp78.unk_C = thing->unk_08;
+ entry = &sampleBankTable->entries[sampleBankId];
+ change.size = entry->size;
+ change.newMedium = entry->medium;
- if ((sp78.unk_C == 2) || (sp78.unk_C == 3)) {
- sp78.unk_4 = thing->romAddr;
+ if ((change.newMedium == MEDIUM_CART) || (change.newMedium == MEDIUM_DISK_DRIVE)) {
+ change.newAddr = entry->romAddr;
} else {
- sp78.unk_4 = NULL;
+ change.newAddr = 0;
}
- fakematch = &sp78.unk_0;
- if ((arg0 != 0) && (arg0 == 1)) {
- u8* temp = sp78.unk_4;
- sp78.unk_4 = *fakematch;
- sp78.unk_0 = temp;
- sp78.unk_C = 0;
+ fakematch = &change.oldAddr;
+ if ((apply != false) && (apply == true)) {
+ u32 temp = change.newAddr;
+ change.newAddr = *fakematch; // = change.oldAddr
+ change.oldAddr = temp;
+ change.newMedium = MEDIUM_RAM;
}
- for (bankId = 0; bankId < numBanks; bankId++) {
- unk2 = gAudioContext.ctlEntries[bankId].unk_02;
- unk3 = gAudioContext.ctlEntries[bankId].unk_03;
- if ((unk2 != 0xFF) || (unk3 != 0xFF)) {
- if (!Audio_IsBankLoadComplete(bankId) || func_800DF074(1, 2, bankId) == NULL) {
+ for (fontId = 0; fontId < numFonts; fontId++) {
+ sampleBankId1 = gAudioContext.soundFonts[fontId].sampleBankId1;
+ sampleBankId2 = gAudioContext.soundFonts[fontId].sampleBankId2;
+ if ((sampleBankId1 != 0xFF) || (sampleBankId2 != 0xFF)) {
+ if (!AudioLoad_IsFontLoadComplete(fontId) ||
+ AudioHeap_SearchCaches(FONT_TABLE, CACHE_EITHER, fontId) == NULL) {
continue;
}
- if (unk2 == id) {
- } else if (unk3 == id) {
+ if (sampleBankId1 == sampleBankId) {
+ } else if (sampleBankId2 == sampleBankId) {
} else {
continue;
}
- for (instId = 0; instId < gAudioContext.ctlEntries[bankId].numInstruments; instId++) {
- inst = Audio_GetInstrumentInner(bankId, instId);
+ for (instId = 0; instId < gAudioContext.soundFonts[fontId].numInstruments; instId++) {
+ inst = Audio_GetInstrumentInner(fontId, instId);
if (inst != NULL) {
if (inst->normalRangeLo != 0) {
- func_800E0E0C(&sp78, inst->lowNotesSound.sample);
+ AudioHeap_ChangeStorage(&change, inst->lowNotesSound.sample);
}
if (inst->normalRangeHi != 0x7F) {
- func_800E0E0C(&sp78, inst->highNotesSound.sample);
+ AudioHeap_ChangeStorage(&change, inst->highNotesSound.sample);
}
- func_800E0E0C(&sp78, inst->normalNotesSound.sample);
+ AudioHeap_ChangeStorage(&change, inst->normalNotesSound.sample);
}
}
- for (drumId = 0; drumId < gAudioContext.ctlEntries[bankId].numDrums; drumId++) {
- drum = Audio_GetDrum(bankId, drumId);
+ for (drumId = 0; drumId < gAudioContext.soundFonts[fontId].numDrums; drumId++) {
+ drum = Audio_GetDrum(fontId, drumId);
if (drum != NULL) {
- func_800E0E0C(&sp78, drum->sound.sample);
+ AudioHeap_ChangeStorage(&change, drum->sound.sample);
}
}
- for (sfxId = 0; sfxId < gAudioContext.ctlEntries[bankId].numSfx; sfxId++) {
- sfx = Audio_GetSfx(bankId, sfxId);
+ for (sfxId = 0; sfxId < gAudioContext.soundFonts[fontId].numSfx; sfxId++) {
+ sfx = Audio_GetSfx(fontId, sfxId);
if (sfx != NULL) {
- func_800E0E0C(&sp78, sfx->sample);
+ AudioHeap_ChangeStorage(&change, sfx->sample);
}
}
}
}
}
-void func_800E1148(void) {
- SoundMultiPool* pool;
- PersistentPool* persistent;
- TemporaryPool* temporary;
+void AudioHeap_DiscardSampleBanks(void) {
+ AudioCache* pool;
+ AudioPersistentCache* persistent;
+ AudioTemporaryCache* temporary;
u32 i;
- pool = &gAudioContext.unusedLoadedPool;
+ pool = &gAudioContext.sampleBankCache;
temporary = &pool->temporary;
if (temporary->entries[0].id != -1) {
- func_800E0E6C(temporary->entries[0].id);
+ AudioHeap_DiscardSampleBank(temporary->entries[0].id);
}
if (temporary->entries[1].id != -1) {
- func_800E0E6C(temporary->entries[1].id);
+ AudioHeap_DiscardSampleBank(temporary->entries[1].id);
}
persistent = &pool->persistent;
for (i = 0; i < persistent->numEntries; i++) {
- func_800E0E6C(persistent->entries[i].id);
+ AudioHeap_DiscardSampleBank(persistent->entries[i].id);
}
}
diff --git a/src/code/audio_rodata.c b/src/code/audio_init_params.c
index 469c5fc35..f7528deed 100644
--- a/src/code/audio_rodata.c
+++ b/src/code/audio_init_params.c
@@ -1,7 +1,7 @@
#include "global.h"
const s16 D_8014A6C0[] = {
- 0x1C00,
- 0x0030,
+ 0x1C00, // unused
+ 0x0030, // gTatumsPerBeat
};
const AudioContextInitSizes D_8014A6C4 = { 0x37F00, 0xE0E0, 0xBCE0 };
diff --git a/src/code/audio_load.c b/src/code/audio_load.c
index 1146c3a1c..291ee5670 100644
--- a/src/code/audio_load.c
+++ b/src/code/audio_load.c
@@ -1,95 +1,121 @@
#include "ultra64.h"
#include "global.h"
-typedef enum { LOAD_STATUS_WAITING, LOAD_STATUS_START, LOAD_STATUS_LOADING, LOAD_STATUS_DONE } SyncLoadStatus;
-
-// opaque type for unpatched audio bank data (should maybe get rid of this?)
-typedef void AudioBankData;
+#define MK_ASYNC_MSG(retData, tableType, id, status) (((retData) << 24) | ((tableType) << 16) | ((id) << 8) | (status))
+#define ASYNC_TBLTYPE(v) ((u8)(v >> 16))
+#define ASYNC_ID(v) ((u8)(v >> 8))
+#define ASYNC_STATUS(v) ((u8)(v >> 0))
+
+typedef enum {
+ /* 0 */ LOAD_STATUS_WAITING,
+ /* 1 */ LOAD_STATUS_START,
+ /* 2 */ LOAD_STATUS_LOADING,
+ /* 3 */ LOAD_STATUS_DONE
+} SlowLoadStatus;
+
+typedef struct {
+ /* 0x00 */ s32 sampleBankId1;
+ /* 0x04 */ s32 sampleBankId2;
+ /* 0x08 */ s32 baseAddr1;
+ /* 0x0C */ s32 baseAddr2;
+ /* 0x10 */ u32 medium1;
+ /* 0x14 */ u32 medium2;
+} RelocInfo; // size = 0x18
+
+// opaque type for unpatched sound font data (should maybe get rid of this?)
+typedef void SoundFontData;
/* forward declarations */
-s32 func_800E217C(s32 playerIndex, s32, s32);
-AudioBankData* func_800E2454(u32 bankId);
-AudioBankSample* Audio_GetBankSample(s32 bankId, s32 sfxId);
-void Audio_ProcessAsyncLoads(s32 arg0);
-void Audio_HandleAsyncMsg(AsyncLoadReq* arg0, s32 arg1);
-void Audio_UpdateAsyncReq(AsyncLoadReq* arg0, s32 arg1);
-void func_800E4198(s32, AudioBankData*, RelocInfo*, s32);
-void Audio_SampleReloc(AudioBankSound* sound, u32, RelocInfo*);
-void func_800E202C(s32 arg0);
-u32 func_800E2338(u32 arg0, u32* arg1, s32 arg2);
-void* func_800E2558(u32 tableType, u32 tableIdx, s32* didAllocate);
-u32 Audio_GetTableIndex(s32 tableType, u32 tableIdx);
-void* func_800E27A4(s32 tableType, s32 id);
-void* Audio_GetLoadTable(s32 tableType);
-void Audio_DMAFastCopy(u32 devAddr, u8* addr, u32 size, s32 handleType);
-void Audio_NoopCopy(u32 devAddr, u8* addr, u32 size, s32 handleType);
-s32 Audio_DMA(OSIoMesg* mesg, u32 priority, s32 direction, u32 devAddr, void* ramAddr, u32 size, OSMesgQueue* reqQueue,
- s32 handleType, const char* dmaFuncType);
-void* Audio_AsyncLoadInner(s32 tableType, s32 arg1, s32 arg2, s32 arg3, OSMesgQueue* retQueue);
-AsyncLoadReq* func_800E3A44(s32 arg0, u32 devAddr, void* ramAddr, s32 size, s32 arg4, s32 nChunks,
- OSMesgQueue* retQueue, s32 retMsg);
-AsyncLoadReq* Audio_InitAsyncReq(u32 devAddr, void* ramAddr, u32 size, s32 arg3, s32 nChunks, OSMesgQueue* retQueue,
- s32 retMsg);
-void func_800E3FB4(AsyncLoadReq* req, u32 size);
-void func_800E4044(u32 devAddr, void* ramAddr, u32 size, s16 arg3);
-u8* func_800E22C4(s32 seqId);
-s32 func_800E4590(s32 resetStatus);
-void func_800E3874(AudioSyncLoad* arg0, s32 size);
-void Audio_ProcessSyncLoads(s32 resetStatus);
-void func_800E38F8(s32 arg0, s32 arg1, s32 arg2, s32 arg3);
-
-OSMesgQueue D_8016B6E0;
-OSMesg D_8016B6F8[0x10];
-s8* D_8016B738[0x12];
+s32 AudioLoad_SyncInitSeqPlayerInternal(s32 playerIdx, s32 seqId, s32 skipTicks);
+SoundFontData* AudioLoad_SyncLoadFont(u32 fontId);
+SoundFontSample* AudioLoad_GetFontSample(s32 fontId, s32 instId);
+void AudioLoad_ProcessAsyncLoads(s32 resetStatus);
+void AudioLoad_ProcessAsyncLoadUnkMedium(AudioAsyncLoad* asyncLoad, s32 resetStatus);
+void AudioLoad_ProcessAsyncLoad(AudioAsyncLoad* asyncLoad, s32 resetStatus);
+void AudioLoad_RelocateFontAndPreloadSamples(s32 fontId, SoundFontData* mem, RelocInfo* relocInfo, s32 temporary);
+void AudioLoad_RelocateSample(SoundFontSound* sound, SoundFontData* mem, RelocInfo* relocInfo);
+void AudioLoad_DiscardFont(s32 fontId);
+u32 AudioLoad_TrySyncLoadSampleBank(u32 sampleBankId, u32* outMedium, s32 noLoad);
+void* AudioLoad_SyncLoad(u32 tableType, u32 tableId, s32* didAllocate);
+u32 AudioLoad_GetRealTableIndex(s32 tableType, u32 tableId);
+void* AudioLoad_SearchCaches(s32 tableType, s32 id);
+AudioTable* AudioLoad_GetLoadTable(s32 tableType);
+void AudioLoad_SyncDma(u32 devAddr, u8* addr, u32 size, s32 medium);
+void AudioLoad_SyncDmaUnkMedium(u32 devAddr, u8* addr, u32 size, s32 unkMediumParam);
+s32 AudioLoad_Dma(OSIoMesg* mesg, u32 priority, s32 direction, u32 devAddr, void* ramAddr, u32 size,
+ OSMesgQueue* reqQueue, s32 medium, const char* dmaFuncType);
+void* AudioLoad_AsyncLoadInner(s32 tableType, s32 id, s32 nChunks, s32 retData, OSMesgQueue* retQueue);
+AudioAsyncLoad* AudioLoad_StartAsyncLoadUnkMedium(s32 unkMediumParam, u32 devAddr, void* ramAddr, s32 size, s32 medium,
+ s32 nChunks, OSMesgQueue* retQueue, s32 retMsg);
+AudioAsyncLoad* AudioLoad_StartAsyncLoad(u32 devAddr, void* ramAddr, u32 size, s32 medium, s32 nChunks,
+ OSMesgQueue* retQueue, s32 retMsg);
+void AudioLoad_AsyncDma(AudioAsyncLoad* asyncLoad, u32 size);
+void AudioLoad_AsyncDmaUnkMedium(u32 devAddr, void* ramAddr, u32 size, s16 arg3);
+u8* AudioLoad_SyncLoadSeq(s32 seqId);
+s32 AudioLoad_ProcessSamplePreloads(s32 resetStatus);
+void AudioLoad_DmaSlowCopy(AudioSlowLoad* slowLoad, s32 size);
+void AudioLoad_ProcessSlowLoads(s32 resetStatus);
+void AudioLoad_DmaSlowCopyUnkMedium(s32 devAddr, u8* ramAddr, s32 size, s32 arg3);
+
+OSMesgQueue sScriptLoadQueue;
+OSMesg sScriptLoadMesgBuf[0x10];
+s8* sScriptLoadDonePointers[0x10];
+s32 sAudioLoadPad1[2]; // file padding
+
s32 D_8016B780;
-s32 sAudioLoadPad[4];
+s32 sAudioLoadPad2[4]; // double file padding?
+
+DmaHandler sDmaHandler = osEPiStartDma;
+void* sUnusedHandler = NULL;
-void func_800E11F0(void) {
+s32 gAudioContextInitalized = false;
+
+void AudioLoad_DecreaseSampleDmaTtls(void) {
u32 i;
for (i = 0; i < gAudioContext.sampleDmaListSize1; i++) {
- SampleDmaReq* req = &gAudioContext.sampleDmaReqs[i];
+ SampleDma* dma = &gAudioContext.sampleDmas[i];
- if (req->ttl != 0) {
- req->ttl--;
- if (req->ttl == 0) {
- req->reuseIndex = gAudioContext.sampleDmaReuseQueue1WrPos;
+ if (dma->ttl != 0) {
+ dma->ttl--;
+ if (dma->ttl == 0) {
+ dma->reuseIndex = gAudioContext.sampleDmaReuseQueue1WrPos;
gAudioContext.sampleDmaReuseQueue1[gAudioContext.sampleDmaReuseQueue1WrPos] = i;
gAudioContext.sampleDmaReuseQueue1WrPos++;
}
}
}
- for (i = gAudioContext.sampleDmaListSize1; i < gAudioContext.sampleDmaReqCnt; i++) {
- SampleDmaReq* req = &gAudioContext.sampleDmaReqs[i];
+ for (i = gAudioContext.sampleDmaListSize1; i < gAudioContext.sampleDmaCount; i++) {
+ SampleDma* dma = &gAudioContext.sampleDmas[i];
- if (req->ttl != 0) {
- req->ttl--;
- if (req->ttl == 0) {
- req->reuseIndex = gAudioContext.sampleDmaReuseQueue2WrPos;
+ if (dma->ttl != 0) {
+ dma->ttl--;
+ if (dma->ttl == 0) {
+ dma->reuseIndex = gAudioContext.sampleDmaReuseQueue2WrPos;
gAudioContext.sampleDmaReuseQueue2[gAudioContext.sampleDmaReuseQueue2WrPos] = i;
gAudioContext.sampleDmaReuseQueue2WrPos++;
}
}
}
- gAudioContext.unk_2628 = 0;
+ gAudioContext.unused2628 = 0;
}
-void* Audio_DmaSampleData(u32 devAddr, u32 size, s32 arg2, u8* dmaIndexRef, s32 medium) {
- s32 sp60;
- SampleDmaReq* dma;
+void* AudioLoad_DmaSampleData(u32 devAddr, u32 size, s32 arg2, u8* dmaIndexRef, s32 medium) {
+ s32 pad1;
+ SampleDma* dma;
s32 hasDma = false;
u32 dmaDevAddr;
- u32 pad;
+ u32 pad2;
u32 dmaIndex;
u32 transfer;
s32 bufferPos;
u32 i;
if (arg2 != 0 || *dmaIndexRef >= gAudioContext.sampleDmaListSize1) {
- for (i = gAudioContext.sampleDmaListSize1; i < gAudioContext.sampleDmaReqCnt; i++) {
- dma = &gAudioContext.sampleDmaReqs[i];
+ for (i = gAudioContext.sampleDmaListSize1; i < gAudioContext.sampleDmaCount; i++) {
+ dma = &gAudioContext.sampleDmas[i];
bufferPos = devAddr - dma->devAddr;
if (0 <= bufferPos && (u32)bufferPos <= dma->size - size) {
// We already have a DMA request for this memory range.
@@ -101,7 +127,7 @@ void* Audio_DmaSampleData(u32 devAddr, u32 size, s32 arg2, u8* dmaIndexRef, s32
gAudioContext.sampleDmaReuseQueue2[dma->reuseIndex] =
gAudioContext.sampleDmaReuseQueue2[gAudioContext.sampleDmaReuseQueue2RdPos];
gAudioContext
- .sampleDmaReqs[gAudioContext.sampleDmaReuseQueue2[gAudioContext.sampleDmaReuseQueue2RdPos]]
+ .sampleDmas[gAudioContext.sampleDmaReuseQueue2[gAudioContext.sampleDmaReuseQueue2RdPos]]
.reuseIndex = dma->reuseIndex;
}
gAudioContext.sampleDmaReuseQueue2RdPos++;
@@ -120,12 +146,12 @@ void* Audio_DmaSampleData(u32 devAddr, u32 size, s32 arg2, u8* dmaIndexRef, s32
// Allocate a DMA from reuse queue 2, unless full.
dmaIndex = gAudioContext.sampleDmaReuseQueue2[gAudioContext.sampleDmaReuseQueue2RdPos];
gAudioContext.sampleDmaReuseQueue2RdPos++;
- dma = gAudioContext.sampleDmaReqs + dmaIndex;
+ dma = gAudioContext.sampleDmas + dmaIndex;
hasDma = true;
}
} else {
search_short_lived:
- dma = gAudioContext.sampleDmaReqs + *dmaIndexRef;
+ dma = gAudioContext.sampleDmas + *dmaIndexRef;
i = 0;
again:
bufferPos = devAddr - dma->devAddr;
@@ -138,7 +164,7 @@ void* Audio_DmaSampleData(u32 devAddr, u32 size, s32 arg2, u8* dmaIndexRef, s32
gAudioContext.sampleDmaReuseQueue1[dma->reuseIndex] =
gAudioContext.sampleDmaReuseQueue1[gAudioContext.sampleDmaReuseQueue1RdPos];
gAudioContext
- .sampleDmaReqs[gAudioContext.sampleDmaReuseQueue1[gAudioContext.sampleDmaReuseQueue1RdPos]]
+ .sampleDmas[gAudioContext.sampleDmaReuseQueue1[gAudioContext.sampleDmaReuseQueue1RdPos]]
.reuseIndex = dma->reuseIndex;
}
gAudioContext.sampleDmaReuseQueue1RdPos++;
@@ -146,7 +172,7 @@ void* Audio_DmaSampleData(u32 devAddr, u32 size, s32 arg2, u8* dmaIndexRef, s32
dma->ttl = 2;
return dma->ramAddr + (devAddr - dma->devAddr);
}
- dma = gAudioContext.sampleDmaReqs + i++;
+ dma = gAudioContext.sampleDmas + i++;
if (i <= gAudioContext.sampleDmaListSize1) {
goto again;
}
@@ -158,7 +184,7 @@ void* Audio_DmaSampleData(u32 devAddr, u32 size, s32 arg2, u8* dmaIndexRef, s32
}
// Allocate a DMA from reuse queue 1.
dmaIndex = gAudioContext.sampleDmaReuseQueue1[gAudioContext.sampleDmaReuseQueue1RdPos++];
- dma = gAudioContext.sampleDmaReqs + dmaIndex;
+ dma = gAudioContext.sampleDmas + dmaIndex;
hasDma = true;
}
@@ -167,504 +193,516 @@ void* Audio_DmaSampleData(u32 devAddr, u32 size, s32 arg2, u8* dmaIndexRef, s32
dma->ttl = 3;
dma->devAddr = dmaDevAddr;
dma->sizeUnused = transfer;
- Audio_DMA(&gAudioContext.currAudioFrameDmaIoMesgBufs[gAudioContext.curAudioFrameDmaCount++], OS_MESG_PRI_NORMAL,
- OS_READ, dmaDevAddr, dma->ramAddr, transfer, &gAudioContext.currAudioFrameDmaQueue, medium, "SUPERDMA");
+ AudioLoad_Dma(&gAudioContext.currAudioFrameDmaIoMesgBuf[gAudioContext.curAudioFrameDmaCount++], OS_MESG_PRI_NORMAL,
+ OS_READ, dmaDevAddr, dma->ramAddr, transfer, &gAudioContext.currAudioFrameDmaQueue, medium,
+ "SUPERDMA");
*dmaIndexRef = dmaIndex;
return (devAddr - dmaDevAddr) + dma->ramAddr;
}
-void func_800E1618(s32 arg0) {
- SampleDmaReq* temp_s0;
+void AudioLoad_InitSampleDmaBuffers(s32 arg0) {
+ SampleDma* dma;
s32 i;
s32 t2;
s32 j;
- gAudioContext.unk_288C = gAudioContext.unk_2874;
- gAudioContext.sampleDmaReqs =
- Audio_Alloc(&gAudioContext.notesAndBuffersPool, 4 * gAudioContext.maxSimultaneousNotes * sizeof(SampleDmaReq) *
- gAudioContext.audioBufferParameters.specUnk4);
- t2 = 3 * gAudioContext.maxSimultaneousNotes * gAudioContext.audioBufferParameters.specUnk4;
+ gAudioContext.sampleDmaBufSize = gAudioContext.sampleDmaBufSize1;
+ gAudioContext.sampleDmas =
+ AudioHeap_Alloc(&gAudioContext.notesAndBuffersPool,
+ 4 * gAudioContext.numNotes * sizeof(SampleDma) * gAudioContext.audioBufferParameters.specUnk4);
+ t2 = 3 * gAudioContext.numNotes * gAudioContext.audioBufferParameters.specUnk4;
for (i = 0; i < t2; i++) {
- temp_s0 = &gAudioContext.sampleDmaReqs[gAudioContext.sampleDmaReqCnt];
- temp_s0->ramAddr = func_800DE2B0(&gAudioContext.notesAndBuffersPool, gAudioContext.unk_288C);
- if (temp_s0->ramAddr == NULL) {
+ dma = &gAudioContext.sampleDmas[gAudioContext.sampleDmaCount];
+ dma->ramAddr = AudioHeap_AllocAttemptExternal(&gAudioContext.notesAndBuffersPool, gAudioContext.sampleDmaBufSize);
+ if (dma->ramAddr == NULL) {
break;
} else {
- func_800DE238(temp_s0->ramAddr, gAudioContext.unk_288C);
- temp_s0->size = gAudioContext.unk_288C;
- temp_s0->devAddr = 0;
- temp_s0->sizeUnused = 0;
- temp_s0->unused = 0;
- temp_s0->ttl = 0;
- gAudioContext.sampleDmaReqCnt++;
+ AudioHeap_WritebackDCache(dma->ramAddr, gAudioContext.sampleDmaBufSize);
+ dma->size = gAudioContext.sampleDmaBufSize;
+ dma->devAddr = 0;
+ dma->sizeUnused = 0;
+ dma->unused = 0;
+ dma->ttl = 0;
+ gAudioContext.sampleDmaCount++;
}
}
- for (i = 0; (u32)i < gAudioContext.sampleDmaReqCnt; i++) {
+ for (i = 0; (u32)i < gAudioContext.sampleDmaCount; i++) {
gAudioContext.sampleDmaReuseQueue1[i] = i;
- gAudioContext.sampleDmaReqs[i].reuseIndex = i;
+ gAudioContext.sampleDmas[i].reuseIndex = i;
}
- for (i = gAudioContext.sampleDmaReqCnt; i < 0x100; i++) {
+ for (i = gAudioContext.sampleDmaCount; i < 0x100; i++) {
gAudioContext.sampleDmaReuseQueue1[i] = 0;
}
gAudioContext.sampleDmaReuseQueue1RdPos = 0;
- gAudioContext.sampleDmaReuseQueue1WrPos = gAudioContext.sampleDmaReqCnt;
- gAudioContext.sampleDmaListSize1 = gAudioContext.sampleDmaReqCnt;
- gAudioContext.unk_288C = gAudioContext.unk_2878;
-
- for (j = 0; j < gAudioContext.maxSimultaneousNotes; j++) {
- temp_s0 = &gAudioContext.sampleDmaReqs[gAudioContext.sampleDmaReqCnt];
- temp_s0->ramAddr = func_800DE2B0(&gAudioContext.notesAndBuffersPool, gAudioContext.unk_288C);
- if (temp_s0->ramAddr == NULL) {
+ gAudioContext.sampleDmaReuseQueue1WrPos = gAudioContext.sampleDmaCount;
+ gAudioContext.sampleDmaListSize1 = gAudioContext.sampleDmaCount;
+ gAudioContext.sampleDmaBufSize = gAudioContext.sampleDmaBufSize2;
+
+ for (j = 0; j < gAudioContext.numNotes; j++) {
+ dma = &gAudioContext.sampleDmas[gAudioContext.sampleDmaCount];
+ dma->ramAddr = AudioHeap_AllocAttemptExternal(&gAudioContext.notesAndBuffersPool, gAudioContext.sampleDmaBufSize);
+ if (dma->ramAddr == NULL) {
break;
} else {
- func_800DE238(temp_s0->ramAddr, gAudioContext.unk_288C);
- temp_s0->size = gAudioContext.unk_288C;
- temp_s0->devAddr = 0U;
- temp_s0->sizeUnused = 0;
- temp_s0->unused = 0;
- temp_s0->ttl = 0;
- gAudioContext.sampleDmaReqCnt++;
+ AudioHeap_WritebackDCache(dma->ramAddr, gAudioContext.sampleDmaBufSize);
+ dma->size = gAudioContext.sampleDmaBufSize;
+ dma->devAddr = 0U;
+ dma->sizeUnused = 0;
+ dma->unused = 0;
+ dma->ttl = 0;
+ gAudioContext.sampleDmaCount++;
}
}
- for (i = gAudioContext.sampleDmaListSize1; (u32)i < gAudioContext.sampleDmaReqCnt; i++) {
+ for (i = gAudioContext.sampleDmaListSize1; (u32)i < gAudioContext.sampleDmaCount; i++) {
gAudioContext.sampleDmaReuseQueue2[i - gAudioContext.sampleDmaListSize1] = i;
- gAudioContext.sampleDmaReqs[i].reuseIndex = i - gAudioContext.sampleDmaListSize1;
+ gAudioContext.sampleDmas[i].reuseIndex = i - gAudioContext.sampleDmaListSize1;
}
- for (i = gAudioContext.sampleDmaReqCnt; i < 0x100; i++) {
+ for (i = gAudioContext.sampleDmaCount; i < 0x100; i++) {
gAudioContext.sampleDmaReuseQueue2[i] = gAudioContext.sampleDmaListSize1;
}
gAudioContext.sampleDmaReuseQueue2RdPos = 0;
- gAudioContext.sampleDmaReuseQueue2WrPos = gAudioContext.sampleDmaReqCnt - gAudioContext.sampleDmaListSize1;
+ gAudioContext.sampleDmaReuseQueue2WrPos = gAudioContext.sampleDmaCount - gAudioContext.sampleDmaListSize1;
}
-s32 Audio_IsBankLoadComplete(s32 bankId) {
- if (bankId == 0xFF) {
+s32 AudioLoad_IsFontLoadComplete(s32 fontId) {
+ if (fontId == 0xFF) {
return true;
- } else if (gAudioContext.bankLoadStatus[bankId] >= 2) {
+ } else if (gAudioContext.fontLoadStatus[fontId] >= 2) {
return true;
- } else if (gAudioContext.bankLoadStatus[Audio_GetTableIndex(BANK_TABLE, bankId)] >= 2) {
+ } else if (gAudioContext.fontLoadStatus[AudioLoad_GetRealTableIndex(FONT_TABLE, fontId)] >= 2) {
return true;
} else {
return false;
}
}
-s32 Audio_IsSeqLoadComplete(s32 seqId) {
+s32 AudioLoad_IsSeqLoadComplete(s32 seqId) {
if (seqId == 0xFF) {
return true;
} else if (gAudioContext.seqLoadStatus[seqId] >= 2) {
return true;
- } else if (gAudioContext.seqLoadStatus[Audio_GetTableIndex(SEQUENCE_TABLE, seqId)] >= 2) {
+ } else if (gAudioContext.seqLoadStatus[AudioLoad_GetRealTableIndex(SEQUENCE_TABLE, seqId)] >= 2) {
return true;
} else {
return false;
}
}
-s32 Audio_IsAudTabLoadComplete(s32 tabId) {
- if (tabId == 0xFF) {
+s32 AudioLoad_IsSampleLoadComplete(s32 sampleBankId) {
+ if (sampleBankId == 0xFF) {
return true;
- } else if (gAudioContext.audioTableLoadStatus[tabId] >= 2) {
+ } else if (gAudioContext.sampleFontLoadStatus[sampleBankId] >= 2) {
return true;
- } else if (gAudioContext.audioTableLoadStatus[Audio_GetTableIndex(AUDIO_TABLE, tabId)] >= 2) {
+ } else if (gAudioContext.sampleFontLoadStatus[AudioLoad_GetRealTableIndex(SAMPLE_TABLE, sampleBankId)] >= 2) {
return true;
} else {
return false;
}
}
-void Audio_SetBankLoadStatus(s32 bankId, s32 status) {
- if ((bankId != 0xFF) && (gAudioContext.bankLoadStatus[bankId] != 5)) {
- gAudioContext.bankLoadStatus[bankId] = status;
+void AudioLoad_SetFontLoadStatus(s32 fontId, s32 status) {
+ if ((fontId != 0xFF) && (gAudioContext.fontLoadStatus[fontId] != 5)) {
+ gAudioContext.fontLoadStatus[fontId] = status;
}
}
-void Audio_SetSeqLoadStatus(s32 seqId, s32 status) {
+void AudioLoad_SetSeqLoadStatus(s32 seqId, s32 status) {
if ((seqId != 0xFF) && (gAudioContext.seqLoadStatus[seqId] != 5)) {
gAudioContext.seqLoadStatus[seqId] = status;
}
}
-void func_800E1A78(s32 arg0, s32 arg1) {
- if (arg0 != 0xFF) {
- if (gAudioContext.audioTableLoadStatus[arg0] != 5) {
- gAudioContext.audioTableLoadStatus[arg0] = arg1;
+void AudioLoad_SetSampleFontLoadStatusAndApplyCaches(s32 sampleBankId, s32 status) {
+ if (sampleBankId != 0xFF) {
+ if (gAudioContext.sampleFontLoadStatus[sampleBankId] != 5) {
+ gAudioContext.sampleFontLoadStatus[sampleBankId] = status;
}
- if ((gAudioContext.audioTableLoadStatus[arg0] == 5) || (gAudioContext.audioTableLoadStatus[arg0] == 2)) {
- func_800E0E90(arg0);
+ if ((gAudioContext.sampleFontLoadStatus[sampleBankId] == 5) ||
+ (gAudioContext.sampleFontLoadStatus[sampleBankId] == 2)) {
+ AudioHeap_ApplySampleBankCache(sampleBankId);
}
}
}
-void Audio_SetAudtabLoadStatus(s32 tabId, s32 status) {
- if ((tabId != 0xFF) && (gAudioContext.audioTableLoadStatus[tabId] != 5)) {
- gAudioContext.audioTableLoadStatus[tabId] = status;
+void AudioLoad_SetSampleFontLoadStatus(s32 sampleBankId, s32 status) {
+ if ((sampleBankId != 0xFF) && (gAudioContext.sampleFontLoadStatus[sampleBankId] != 5)) {
+ gAudioContext.sampleFontLoadStatus[sampleBankId] = status;
}
}
-void Audio_InitAudioTable(AudioTable* table, u32 romAddr, u16 arg2) {
+void AudioLoad_InitTable(AudioTable* table, u32 romAddr, u16 unkMediumParam) {
s32 i;
- table->header.unk_02 = arg2;
- table->header.romAddr = romAddr;
+ table->unkMediumParam = unkMediumParam;
+ table->romAddr = romAddr;
- for (i = 0; i < table->header.entryCnt; i++) {
- if ((table->entries[i].size != 0) && (table->entries[i].unk_08 == 2)) {
+ for (i = 0; i < table->numEntries; i++) {
+ if ((table->entries[i].size != 0) && (table->entries[i].medium == MEDIUM_CART)) {
table->entries[i].romAddr += romAddr;
}
}
}
-AudioBankData* func_800E1B68(s32 arg0, u32* arg1) {
+SoundFontData* AudioLoad_SyncLoadSeqFonts(s32 seqId, u32* outDefaultFontId) {
char pad[0x8];
- s32 phi_s0;
- AudioBankData* sp28;
- s32 phi_s1;
- s32 phi_s2;
+ s32 index;
+ SoundFontData* font;
+ s32 numFonts;
+ s32 fontId;
s32 i;
- if (arg0 >= gAudioContext.seqTabEntCnt) {
- return 0;
+ if (seqId >= gAudioContext.numSequences) {
+ return NULL;
}
- phi_s2 = 0xFF;
- phi_s0 = gAudioContext.unk_283C[arg0]; // ofset into unk_283C for cnt?
- phi_s1 = *(phi_s0 + gAudioContext.unk_283Cb);
- phi_s0++;
+ fontId = 0xFF;
+ index = ((u16*)gAudioContext.sequenceFontTable)[seqId];
+ numFonts = gAudioContext.sequenceFontTable[index++];
- while (phi_s1 > 0) {
- phi_s2 = gAudioContext.unk_283Cb[phi_s0++];
- sp28 = func_800E2454(phi_s2);
- phi_s1--;
+ while (numFonts > 0) {
+ fontId = gAudioContext.sequenceFontTable[index++];
+ font = AudioLoad_SyncLoadFont(fontId);
+ numFonts--;
}
- *arg1 = phi_s2;
- return sp28;
+ *outDefaultFontId = fontId;
+ return font;
}
-void func_800E1C18(s32 channelIdx, s32 arg1) {
+void AudioLoad_SyncLoadSeqParts(s32 seqId, s32 arg1) {
s32 pad;
- u32 sp18;
+ u32 defaultFontId;
- if (channelIdx < gAudioContext.seqTabEntCnt) {
+ if (seqId < gAudioContext.numSequences) {
if (arg1 & 2) {
- func_800E1B68(channelIdx, &sp18);
+ AudioLoad_SyncLoadSeqFonts(seqId, &defaultFontId);
}
if (arg1 & 1) {
- func_800E22C4(channelIdx);
+ AudioLoad_SyncLoadSeq(seqId);
}
}
}
-s32 func_800E1C78(AudioBankSample* sample, s32 arg1) {
+s32 AudioLoad_SyncLoadSample(SoundFontSample* sample, s32 fontId) {
void* sampleAddr;
- if (sample->unk_bits25 == 1) {
- if (sample->medium != 0) {
- sampleAddr = func_800E05C4(sample->size, arg1, (void*)sample->sampleAddr, sample->medium, 1);
+ if (sample->unk_bit25 == 1) {
+ if (sample->medium != MEDIUM_RAM) {
+ sampleAddr = AudioHeap_AllocSampleCache(sample->size, fontId, (void*)sample->sampleAddr, sample->medium,
+ CACHE_PERSISTENT);
if (sampleAddr == NULL) {
return -1;
}
- if (sample->medium == 1) {
- Audio_NoopCopy(sample->sampleAddr, sampleAddr, sample->size, gAudioContext.audioTable->header.unk_02);
+ if (sample->medium == MEDIUM_UNK) {
+ AudioLoad_SyncDmaUnkMedium(sample->sampleAddr, sampleAddr, sample->size,
+ gAudioContext.sampleBankTable->unkMediumParam);
} else {
- Audio_DMAFastCopy(sample->sampleAddr, sampleAddr, sample->size, sample->medium);
+ AudioLoad_SyncDma(sample->sampleAddr, sampleAddr, sample->size, sample->medium);
}
- sample->medium = 0;
+ sample->medium = MEDIUM_RAM;
sample->sampleAddr = sampleAddr;
}
}
}
-s32 func_800E1D64(s32 arg0, s32 arg1, s32 arg2) {
- if (arg1 < 0x7F) {
- Instrument* instrument = Audio_GetInstrumentInner(arg0, arg1);
+s32 AudioLoad_SyncLoadInstrument(s32 fontId, s32 instId, s32 drumId) {
+ if (instId < 0x7F) {
+ Instrument* instrument = Audio_GetInstrumentInner(fontId, instId);
if (instrument == NULL) {
return -1;
}
if (instrument->normalRangeLo != 0) {
- func_800E1C78(instrument->lowNotesSound.sample, arg0);
+ AudioLoad_SyncLoadSample(instrument->lowNotesSound.sample, fontId);
}
- func_800E1C78(instrument->normalNotesSound.sample, arg0);
+ AudioLoad_SyncLoadSample(instrument->normalNotesSound.sample, fontId);
if (instrument->normalRangeHi != 0x7F) {
- return func_800E1C78(instrument->highNotesSound.sample, arg0);
+ return AudioLoad_SyncLoadSample(instrument->highNotesSound.sample, fontId);
}
- } else if (arg1 == 0x7F) {
- Drum* drum = Audio_GetDrum(arg0, arg2);
+ } else if (instId == 0x7F) {
+ Drum* drum = Audio_GetDrum(fontId, drumId);
if (drum == NULL) {
return -1;
}
- func_800E1C78(drum->sound.sample, arg0);
+ AudioLoad_SyncLoadSample(drum->sound.sample, fontId);
return 0;
}
}
-void Audio_AsyncLoad(s32 tableType, s32 arg1, s32 arg2, s32 arg3, OSMesgQueue* queue) {
- if (Audio_AsyncLoadInner(tableType, arg1, arg2, arg3, queue) == NULL) {
- osSendMesg(queue, -1, OS_MESG_NOBLOCK);
+void AudioLoad_AsyncLoad(s32 tableType, s32 id, s32 nChunks, s32 retData, OSMesgQueue* retQueue) {
+ if (AudioLoad_AsyncLoadInner(tableType, id, nChunks, retData, retQueue) == NULL) {
+ osSendMesg(retQueue, 0xFFFFFFFF, OS_MESG_NOBLOCK);
}
}
-void Audio_AudioSeqAsyncLoad(s32 arg0, s32 arg1, s32 arg2, OSMesgQueue* queue) {
- Audio_AsyncLoad(SEQUENCE_TABLE, arg0, 0, arg2, queue);
+void AudioLoad_AsyncLoadSeq(s32 seqId, s32 arg1, s32 retData, OSMesgQueue* retQueue) {
+ AudioLoad_AsyncLoad(SEQUENCE_TABLE, seqId, 0, retData, retQueue);
}
-void Audio_AudioTableAsyncLoad(s32 arg0, s32 arg1, s32 arg2, OSMesgQueue* queue) {
- Audio_AsyncLoad(AUDIO_TABLE, arg0, 0, arg2, queue);
+void AudioLoad_AsyncLoadSampleBank(s32 sampleBankId, s32 arg1, s32 retData, OSMesgQueue* retQueue) {
+ AudioLoad_AsyncLoad(SAMPLE_TABLE, sampleBankId, 0, retData, retQueue);
}
-void Audio_AudioBankAsyncLoad(s32 arg0, s32 arg1, s32 arg2, OSMesgQueue* queue) {
- Audio_AsyncLoad(BANK_TABLE, arg0, 0, arg2, queue);
+void AudioLoad_AsyncLoadFont(s32 fontId, s32 arg1, s32 retData, OSMesgQueue* retQueue) {
+ AudioLoad_AsyncLoad(FONT_TABLE, fontId, 0, retData, retQueue);
}
-u8* func_800E1F38(s32 arg0, u32* arg1) {
- s32 temp_v1;
+u8* AudioLoad_GetFontsForSequence(s32 seqId, u32* outNumFonts) {
+ s32 index;
- temp_v1 = gAudioContext.unk_283C[arg0];
+ index = ((u16*)gAudioContext.sequenceFontTable)[seqId];
- *arg1 = *(temp_v1 + gAudioContext.unk_283Cb);
- temp_v1++;
- if (*arg1 == 0) {
+ *outNumFonts = gAudioContext.sequenceFontTable[index++];
+ if (*outNumFonts == 0) {
return NULL;
}
- return &gAudioContext.unk_283Cb[temp_v1];
+ return &gAudioContext.sequenceFontTable[index];
}
-void func_800E1F7C(s32 arg0) {
- s32 temp_s0;
- s32 phi_s1;
- s32 phi_s2;
+void AudioLoad_DiscardSeqFonts(s32 seqId) {
+ s32 fontId;
+ s32 index;
+ s32 numFonts;
- phi_s1 = gAudioContext.unk_283C[arg0];
- phi_s2 = *(phi_s1 + gAudioContext.unk_283Cb);
- phi_s1++;
+ index = ((u16*)gAudioContext.sequenceFontTable)[seqId];
+ numFonts = gAudioContext.sequenceFontTable[index++];
- while (phi_s2 > 0) {
- phi_s2--;
- temp_s0 = Audio_GetTableIndex(BANK_TABLE, gAudioContext.unk_283Cb[phi_s1++]);
- if (func_800E04E8(BANK_TABLE, temp_s0) == NULL) {
- func_800E202C(temp_s0);
- Audio_SetBankLoadStatus(temp_s0, 0);
+ while (numFonts > 0) {
+ numFonts--;
+ fontId = AudioLoad_GetRealTableIndex(FONT_TABLE, gAudioContext.sequenceFontTable[index++]);
+ if (AudioHeap_SearchPermanentCache(FONT_TABLE, fontId) == NULL) {
+ AudioLoad_DiscardFont(fontId);
+ AudioLoad_SetFontLoadStatus(fontId, 0);
}
}
}
-void func_800E202C(s32 arg0) {
+void AudioLoad_DiscardFont(s32 fontId) {
u32 i;
- SoundMultiPool* pool = &gAudioContext.bankLoadedPool;
- PersistentPool* persistent;
+ AudioCache* pool = &gAudioContext.fontCache;
+ AudioPersistentCache* persistent;
- if (arg0 == pool->temporary.entries[0].id) {
+ if (fontId == pool->temporary.entries[0].id) {
pool->temporary.entries[0].id = -1;
- } else if (arg0 == pool->temporary.entries[1].id) {
+ } else if (fontId == pool->temporary.entries[1].id) {
pool->temporary.entries[1].id = -1;
}
persistent = &pool->persistent;
for (i = 0; i < persistent->numEntries; i++) {
- if (arg0 == persistent->entries[i].id) {
+ if (fontId == persistent->entries[i].id) {
persistent->entries[i].id = -1;
}
}
- Audio_DiscardBank(arg0);
+ AudioHeap_DiscardFont(fontId);
}
-s32 func_800E20D4(s32 playerIndex, s32 seqId, s32 arg2) {
+s32 AudioLoad_SyncInitSeqPlayer(s32 playerIdx, s32 seqId, s32 arg2) {
if (gAudioContext.resetTimer != 0) {
return 0;
- } else {
- gAudioContext.seqPlayers[playerIndex].unk_DC = 0;
- return func_800E217C(playerIndex, seqId, arg2);
}
+
+ gAudioContext.seqPlayers[playerIdx].skipTicks = 0;
+ AudioLoad_SyncInitSeqPlayerInternal(playerIdx, seqId, arg2);
+ // Intentionally missing return. Returning the result of the above function
+ // call matches but is UB because it too is missing a return, and using the
+ // result of a non-void function that has failed to return a value is UB.
+ // The callers of this function do not use the return value, so it's fine.
}
-s32 func_800E2124(s32 playerIndex, s32 seqId, s32 arg2) {
+s32 AudioLoad_SyncInitSeqPlayerSkipTicks(s32 playerIdx, s32 seqId, s32 skipTicks) {
if (gAudioContext.resetTimer != 0) {
return 0;
}
- gAudioContext.seqPlayers[playerIndex].unk_DC = arg2;
- return func_800E217C(playerIndex, seqId, 0);
+ gAudioContext.seqPlayers[playerIdx].skipTicks = skipTicks;
+ AudioLoad_SyncInitSeqPlayerInternal(playerIdx, seqId, 0);
+ // Missing return, see above.
}
-// InitSeqPlayer
-s32 func_800E217C(s32 playerIndex, s32 seqId, s32 arg2) {
- SequencePlayer* seqPlayer = &gAudioContext.seqPlayers[playerIndex];
+s32 AudioLoad_SyncInitSeqPlayerInternal(s32 playerIdx, s32 seqId, s32 arg2) {
+ SequencePlayer* seqPlayer = &gAudioContext.seqPlayers[playerIdx];
u8* seqData;
- s32 phi_s0;
- s32 phi_s1;
- s32 phi_s2;
+ s32 index;
+ s32 numFonts;
+ s32 fontId;
- if (seqId >= gAudioContext.seqTabEntCnt) {
+ if (seqId >= gAudioContext.numSequences) {
return 0;
}
- Audio_SequencePlayerDisable(seqPlayer);
+ AudioSeq_SequencePlayerDisable(seqPlayer);
- phi_s2 = 0xFF;
- phi_s0 = gAudioContext.unk_283C[seqId];
- phi_s1 = gAudioContext.unk_283Cb[phi_s0++];
+ fontId = 0xFF;
+ index = ((u16*)gAudioContext.sequenceFontTable)[seqId];
+ numFonts = gAudioContext.sequenceFontTable[index++];
- while (phi_s1 > 0) {
- phi_s2 = gAudioContext.unk_283Cb[phi_s0++];
- func_800E2454(phi_s2);
- phi_s1--;
+ while (numFonts > 0) {
+ fontId = gAudioContext.sequenceFontTable[index++];
+ AudioLoad_SyncLoadFont(fontId);
+ numFonts--;
}
- seqData = func_800E22C4(seqId);
+ seqData = AudioLoad_SyncLoadSeq(seqId);
if (seqData == NULL) {
return 0;
}
- Audio_ResetSequencePlayer(seqPlayer);
+ AudioSeq_ResetSequencePlayer(seqPlayer);
seqPlayer->seqId = seqId;
- seqPlayer->defaultBank = Audio_GetTableIndex(BANK_TABLE, phi_s2);
+ seqPlayer->defaultFont = AudioLoad_GetRealTableIndex(FONT_TABLE, fontId);
seqPlayer->seqData = seqData;
seqPlayer->enabled = 1;
seqPlayer->scriptState.pc = seqData;
seqPlayer->scriptState.depth = 0;
seqPlayer->delay = 0;
seqPlayer->finished = 0;
- seqPlayer->playerIndex = playerIndex;
- Audio_ProcessSequence(seqPlayer);
+ seqPlayer->playerIdx = playerIdx;
+ AudioSeq_SkipForwardSequence(seqPlayer);
+ //! @bug missing return (but the return value is not used so it's not UB)
}
-// LoadSequence
-u8* func_800E22C4(s32 seqId) {
+u8* AudioLoad_SyncLoadSeq(s32 seqId) {
s32 pad;
- s32 sp20;
+ s32 didAllocate;
- if (gAudioContext.seqLoadStatus[Audio_GetTableIndex(SEQUENCE_TABLE, seqId)] == 1) {
+ if (gAudioContext.seqLoadStatus[AudioLoad_GetRealTableIndex(SEQUENCE_TABLE, seqId)] == 1) {
return NULL;
}
- return func_800E2558(SEQUENCE_TABLE, seqId, &sp20);
+ return AudioLoad_SyncLoad(SEQUENCE_TABLE, seqId, &didAllocate);
}
-u32 func_800E2318(u32 arg0, u32* arg1) {
- return func_800E2338(arg0, arg1, 1);
+u32 AudioLoad_GetSampleBank(u32 sampleBankId, u32* outMedium) {
+ return AudioLoad_TrySyncLoadSampleBank(sampleBankId, outMedium, true);
}
-u32 func_800E2338(u32 arg0, u32* arg1, s32 arg2) {
- void* temp_v0;
- AudioTable* audioTable;
- u32 temp_s0 = Audio_GetTableIndex(AUDIO_TABLE, arg0);
- s8 tmp;
+u32 AudioLoad_TrySyncLoadSampleBank(u32 sampleBankId, u32* outMedium, s32 noLoad) {
+ void* ret;
+ AudioTable* sampleBankTable;
+ u32 realTableId = AudioLoad_GetRealTableIndex(SAMPLE_TABLE, sampleBankId);
+ s8 cachePolicy;
- audioTable = Audio_GetLoadTable(AUDIO_TABLE);
- if (temp_v0 = func_800E27A4(AUDIO_TABLE, temp_s0), temp_v0 != NULL) {
- if (gAudioContext.audioTableLoadStatus[temp_s0] != 1) {
- Audio_SetAudtabLoadStatus(temp_s0, 2);
+ sampleBankTable = AudioLoad_GetLoadTable(SAMPLE_TABLE);
+ ret = AudioLoad_SearchCaches(SAMPLE_TABLE, realTableId);
+ if (ret != NULL) {
+ if (gAudioContext.sampleFontLoadStatus[realTableId] != 1) {
+ AudioLoad_SetSampleFontLoadStatus(realTableId, 2);
}
- *arg1 = 0;
- return temp_v0;
- } else if (tmp = audioTable->entries[arg0].unk_09, tmp == 4 || arg2 == 1) {
- *arg1 = audioTable->entries[arg0].unk_08;
- return audioTable->entries[temp_s0].romAddr;
- } else if (temp_v0 = func_800E2558(AUDIO_TABLE, arg0, &arg2), temp_v0 != NULL) {
- *arg1 = 0;
- return temp_v0;
- } else {
- *arg1 = audioTable->entries[arg0].unk_08;
- return audioTable->entries[temp_s0].romAddr;
+ *outMedium = MEDIUM_RAM;
+ return ret;
+ }
+
+ cachePolicy = sampleBankTable->entries[sampleBankId].cachePolicy;
+ if (cachePolicy == 4 || noLoad == true) {
+ *outMedium = sampleBankTable->entries[sampleBankId].medium;
+ return sampleBankTable->entries[realTableId].romAddr;
}
+
+ ret = AudioLoad_SyncLoad(SAMPLE_TABLE, sampleBankId, &noLoad);
+ if (ret != NULL) {
+ *outMedium = MEDIUM_RAM;
+ return ret;
+ }
+
+ *outMedium = sampleBankTable->entries[sampleBankId].medium;
+ return sampleBankTable->entries[realTableId].romAddr;
}
-AudioBankData* func_800E2454(u32 bankId) {
- AudioBankData* temp_ret;
- s32 unk02;
- s32 unk03;
- s32 sp38;
+SoundFontData* AudioLoad_SyncLoadFont(u32 fontId) {
+ SoundFontData* ret;
+ s32 sampleBankId1;
+ s32 sampleBankId2;
+ s32 didAllocate;
RelocInfo relocInfo;
- s32 idx = Audio_GetTableIndex(BANK_TABLE, bankId);
+ s32 realFontId = AudioLoad_GetRealTableIndex(FONT_TABLE, fontId);
- if (gAudioContext.bankLoadStatus[idx] == 1) {
+ if (gAudioContext.fontLoadStatus[realFontId] == 1) {
return NULL;
}
- unk02 = gAudioContext.ctlEntries[idx].unk_02;
- unk03 = gAudioContext.ctlEntries[idx].unk_03;
+ sampleBankId1 = gAudioContext.soundFonts[realFontId].sampleBankId1;
+ sampleBankId2 = gAudioContext.soundFonts[realFontId].sampleBankId2;
- relocInfo.index1 = unk02;
- relocInfo.index2 = unk03;
- if (relocInfo.index1 != 0xFF) {
- relocInfo.baseAddr1 = func_800E2338(relocInfo.index1, &relocInfo.medium1, 0);
+ relocInfo.sampleBankId1 = sampleBankId1;
+ relocInfo.sampleBankId2 = sampleBankId2;
+ if (sampleBankId1 != 0xFF) {
+ relocInfo.baseAddr1 = AudioLoad_TrySyncLoadSampleBank(sampleBankId1, &relocInfo.medium1, false);
} else {
relocInfo.baseAddr1 = 0;
}
- if (unk03 != 0xFF) {
- relocInfo.baseAddr2 = func_800E2338(unk03, &relocInfo.medium2, 0);
+ if (sampleBankId2 != 0xFF) {
+ relocInfo.baseAddr2 = AudioLoad_TrySyncLoadSampleBank(sampleBankId2, &relocInfo.medium2, false);
} else {
relocInfo.baseAddr2 = 0;
}
- temp_ret = func_800E2558(BANK_TABLE, bankId, &sp38);
- if (temp_ret == NULL) {
+ ret = AudioLoad_SyncLoad(FONT_TABLE, fontId, &didAllocate);
+ if (ret == NULL) {
return NULL;
}
- if (sp38 == 1) {
- func_800E4198(idx, temp_ret, &relocInfo, 0);
+ if (didAllocate == true) {
+ AudioLoad_RelocateFontAndPreloadSamples(realFontId, ret, &relocInfo, false);
}
- return temp_ret;
+ return ret;
}
-void* func_800E2558(u32 tableType, u32 tableIdx, s32* didAllocate) {
+void* AudioLoad_SyncLoad(u32 tableType, u32 id, s32* didAllocate) {
u32 size;
AudioTable* table;
s32 pad;
- u32 sp40;
+ u32 medium;
s32 status;
u32 romAddr;
- s32 sp24;
+ s32 cachePolicy;
void* ret;
- u32 id;
+ u32 realId;
- id = Audio_GetTableIndex(tableType, tableIdx);
- ret = func_800E27A4(tableType, id);
+ realId = AudioLoad_GetRealTableIndex(tableType, id);
+ ret = AudioLoad_SearchCaches(tableType, realId);
if (ret != NULL) {
*didAllocate = false;
status = 2;
} else {
- table = Audio_GetLoadTable(tableType);
- size = table->entries[id].size;
+ table = AudioLoad_GetLoadTable(tableType);
+ size = table->entries[realId].size;
size = ALIGN16(size);
- sp40 = table->entries[tableIdx].unk_08;
- sp24 = table->entries[tableIdx].unk_09;
- romAddr = table->entries[id].romAddr;
- switch (sp24) {
+ medium = table->entries[id].medium;
+ cachePolicy = table->entries[id].cachePolicy;
+ romAddr = table->entries[realId].romAddr;
+ switch (cachePolicy) {
case 0:
- ret = func_800E0540(tableType, id, size);
+ ret = AudioHeap_AllocPermanent(tableType, realId, size);
if (ret == NULL) {
return ret;
}
break;
case 1:
- ret = Audio_AllocBankOrSeq(tableType, size, 1, id);
+ ret = AudioHeap_AllocCached(tableType, size, CACHE_PERSISTENT, realId);
if (ret == NULL) {
return ret;
}
break;
case 2:
- ret = Audio_AllocBankOrSeq(tableType, size, 0, id);
+ ret = AudioHeap_AllocCached(tableType, size, CACHE_TEMPORARY, realId);
if (ret == NULL) {
return ret;
}
break;
case 3:
case 4:
- ret = Audio_AllocBankOrSeq(tableType, size, 2, id);
+ ret = AudioHeap_AllocCached(tableType, size, CACHE_EITHER, realId);
if (ret == NULL) {
return ret;
}
@@ -672,24 +710,24 @@ void* func_800E2558(u32 tableType, u32 tableIdx, s32* didAllocate) {
}
*didAllocate = true;
- if (sp40 == 1) {
- Audio_NoopCopy(romAddr, ret, size, (s16)table->header.unk_02);
+ if (medium == MEDIUM_UNK) {
+ AudioLoad_SyncDmaUnkMedium(romAddr, ret, size, (s16)table->unkMediumParam);
} else {
- Audio_DMAFastCopy(romAddr, ret, size, sp40);
+ AudioLoad_SyncDma(romAddr, ret, size, medium);
}
- status = sp24 == 0 ? 5 : 2;
+ status = cachePolicy == 0 ? 5 : 2;
}
switch (tableType) {
case SEQUENCE_TABLE:
- Audio_SetSeqLoadStatus(id, status);
+ AudioLoad_SetSeqLoadStatus(realId, status);
break;
- case BANK_TABLE:
- Audio_SetBankLoadStatus(id, status);
+ case FONT_TABLE:
+ AudioLoad_SetFontLoadStatus(realId, status);
break;
- case AUDIO_TABLE:
- func_800E1A78(id, status);
+ case SAMPLE_TABLE:
+ AudioLoad_SetSampleFontLoadStatusAndApplyCaches(realId, status);
break;
default:
break;
@@ -698,25 +736,25 @@ void* func_800E2558(u32 tableType, u32 tableIdx, s32* didAllocate) {
return ret;
}
-u32 Audio_GetTableIndex(s32 tableType, u32 tableIdx) {
- AudioTable* table = Audio_GetLoadTable(tableType);
+u32 AudioLoad_GetRealTableIndex(s32 tableType, u32 id) {
+ AudioTable* table = AudioLoad_GetLoadTable(tableType);
- if (table->entries[tableIdx].size == 0) {
- tableIdx = table->entries[tableIdx].romAddr;
+ if (table->entries[id].size == 0) {
+ id = table->entries[id].romAddr;
}
- return tableIdx;
+ return id;
}
-void* func_800E27A4(s32 tableType, s32 id) {
+void* AudioLoad_SearchCaches(s32 tableType, s32 id) {
void* ret;
- ret = func_800E04E8(tableType, id);
+ ret = AudioHeap_SearchPermanentCache(tableType, id);
if (ret != NULL) {
return ret;
}
- ret = func_800DF074(tableType, 2, id);
+ ret = AudioHeap_SearchCaches(tableType, CACHE_EITHER, id);
if (ret != NULL) {
return ret;
}
@@ -724,53 +762,53 @@ void* func_800E27A4(s32 tableType, s32 id) {
return NULL;
}
-void* Audio_GetLoadTable(s32 tableType) {
- void* ret;
+AudioTable* AudioLoad_GetLoadTable(s32 tableType) {
+ AudioTable* ret;
switch (tableType) {
case SEQUENCE_TABLE:
ret = gAudioContext.sequenceTable;
break;
- case BANK_TABLE:
- ret = gAudioContext.audioBankTable;
+ case FONT_TABLE:
+ ret = gAudioContext.soundFontTable;
break;
default:
ret = NULL;
break;
- case AUDIO_TABLE:
- ret = gAudioContext.audioTable;
+ case SAMPLE_TABLE:
+ ret = gAudioContext.sampleBankTable;
break;
}
return ret;
}
-#define BASE_OFFSET(x, off) (void*)((u32)(x) + (u32)(off))
-
-void func_800E283C(s32 bankId, AudioBankData* mem, RelocInfo* relocInfo) {
+void AudioLoad_RelocateFont(s32 fontId, SoundFontData* mem, RelocInfo* relocInfo) {
u32 reloc;
u32 reloc2;
Instrument* inst;
Drum* drum;
- AudioBankSound* sfx;
+ SoundFontSound* sfx;
s32 i;
- s32 numDrums = gAudioContext.ctlEntries[bankId].numDrums;
- s32 numInstruments = gAudioContext.ctlEntries[bankId].numInstruments;
- s32 numSfx = gAudioContext.ctlEntries[bankId].numSfx;
+ s32 numDrums = gAudioContext.soundFonts[fontId].numDrums;
+ s32 numInstruments = gAudioContext.soundFonts[fontId].numInstruments;
+ s32 numSfx = gAudioContext.soundFonts[fontId].numSfx;
void** ptrs = (void**)mem;
+#define BASE_OFFSET(x) (void*)((u32)(x) + (u32)(mem))
+
reloc2 = ptrs[0];
if (1) {}
if ((reloc2 != 0) && (numDrums != 0)) {
- ptrs[0] = BASE_OFFSET(reloc2, mem);
+ ptrs[0] = BASE_OFFSET(reloc2);
for (i = 0; i < numDrums; i++) {
reloc = ((Drum**)ptrs[0])[i];
if (reloc != 0) {
- reloc = BASE_OFFSET(reloc, mem);
+ reloc = BASE_OFFSET(reloc);
((Drum**)ptrs[0])[i] = drum = reloc;
if (!drum->loaded) {
- Audio_SampleReloc(&drum->sound, mem, relocInfo);
+ AudioLoad_RelocateSample(&drum->sound, mem, relocInfo);
reloc = drum->envelope;
- drum->envelope = BASE_OFFSET(reloc, mem);
+ drum->envelope = BASE_OFFSET(reloc);
drum->loaded = 1;
}
}
@@ -780,13 +818,13 @@ void func_800E283C(s32 bankId, AudioBankData* mem, RelocInfo* relocInfo) {
reloc2 = ptrs[1];
if (1) {}
if ((reloc2 != 0) && (numSfx != 0)) {
- ptrs[1] = BASE_OFFSET(reloc2, mem);
+ ptrs[1] = BASE_OFFSET(reloc2);
for (i = 0; i < numSfx; i++) {
- reloc = (AudioBankSound*)ptrs[1] + i;
+ reloc = (SoundFontSound*)ptrs[1] + i;
if (reloc != 0) {
sfx = reloc;
if (sfx->sample != NULL) {
- Audio_SampleReloc(sfx, mem, relocInfo);
+ AudioLoad_RelocateSample(sfx, mem, relocInfo);
}
}
}
@@ -798,34 +836,34 @@ void func_800E283C(s32 bankId, AudioBankData* mem, RelocInfo* relocInfo) {
for (i = 2; i <= 2 + numInstruments - 1; i++) {
if (ptrs[i] != NULL) {
- ptrs[i] = BASE_OFFSET(ptrs[i], mem);
+ ptrs[i] = BASE_OFFSET(ptrs[i]);
inst = ptrs[i];
if (!inst->loaded) {
if (inst->normalRangeLo != 0) {
- Audio_SampleReloc(&inst->lowNotesSound, mem, relocInfo);
+ AudioLoad_RelocateSample(&inst->lowNotesSound, mem, relocInfo);
}
- Audio_SampleReloc(&inst->normalNotesSound, mem, relocInfo);
+ AudioLoad_RelocateSample(&inst->normalNotesSound, mem, relocInfo);
if (inst->normalRangeHi != 0x7F) {
- Audio_SampleReloc(&inst->highNotesSound, mem, relocInfo);
+ AudioLoad_RelocateSample(&inst->highNotesSound, mem, relocInfo);
}
reloc = inst->envelope;
- inst->envelope = BASE_OFFSET(reloc, mem);
+ inst->envelope = BASE_OFFSET(reloc);
inst->loaded = 1;
}
}
}
- gAudioContext.ctlEntries[bankId].drums = ptrs[0];
- gAudioContext.ctlEntries[bankId].soundEffects = ptrs[1];
- gAudioContext.ctlEntries[bankId].instruments = (Instrument**)(ptrs + 2);
-}
-
#undef BASE_OFFSET
-void Audio_DMAFastCopy(u32 devAddr, u8* addr, u32 size, s32 handleType) {
- OSMesgQueue* msgQueue = &gAudioContext.unk_25E8;
- OSIoMesg* ioMesg = &gAudioContext.unk_2604;
+ gAudioContext.soundFonts[fontId].drums = ptrs[0];
+ gAudioContext.soundFonts[fontId].soundEffects = ptrs[1];
+ gAudioContext.soundFonts[fontId].instruments = (Instrument**)(ptrs + 2);
+}
+
+void AudioLoad_SyncDma(u32 devAddr, u8* addr, u32 size, s32 medium) {
+ OSMesgQueue* msgQueue = &gAudioContext.syncDmaQueue;
+ OSIoMesg* ioMesg = &gAudioContext.syncDmaIoMesg;
size = ALIGN16(size);
Audio_osInvalDCache(addr, size);
@@ -834,7 +872,7 @@ void Audio_DMAFastCopy(u32 devAddr, u8* addr, u32 size, s32 handleType) {
if (size < 0x400) {
break;
}
- Audio_DMA(ioMesg, OS_MESG_PRI_HIGH, OS_READ, devAddr, addr, 0x400, msgQueue, handleType, "FastCopy");
+ AudioLoad_Dma(ioMesg, OS_MESG_PRI_HIGH, OS_READ, devAddr, addr, 0x400, msgQueue, medium, "FastCopy");
osRecvMesg(msgQueue, NULL, OS_MESG_BLOCK);
size -= 0x400;
devAddr += 0x400;
@@ -842,30 +880,30 @@ void Audio_DMAFastCopy(u32 devAddr, u8* addr, u32 size, s32 handleType) {
}
if (size != 0) {
- Audio_DMA(ioMesg, OS_MESG_PRI_HIGH, OS_READ, devAddr, addr, size, msgQueue, handleType, "FastCopy");
+ AudioLoad_Dma(ioMesg, OS_MESG_PRI_HIGH, OS_READ, devAddr, addr, size, msgQueue, medium, "FastCopy");
osRecvMesg(msgQueue, NULL, OS_MESG_BLOCK);
}
}
-void Audio_NoopCopy(u32 devAddr, u8* addr, u32 size, s32 handleType) {
+void AudioLoad_SyncDmaUnkMedium(u32 devAddr, u8* addr, u32 size, s32 unkMediumParam) {
}
-s32 (*sDmaHandler)(OSPiHandle* handle, OSIoMesg* mb, s32 direction) = osEPiStartDma;
-
-s32 Audio_DMA(OSIoMesg* mesg, u32 priority, s32 direction, u32 devAddr, void* ramAddr, u32 size, OSMesgQueue* reqQueue,
- s32 handleType, const char* dmaFuncType) {
+s32 AudioLoad_Dma(OSIoMesg* mesg, u32 priority, s32 direction, u32 devAddr, void* ramAddr, u32 size,
+ OSMesgQueue* reqQueue, s32 medium, const char* dmaFuncType) {
OSPiHandle* handle;
if (gAudioContext.resetTimer > 0x10) {
return -1;
}
- switch (handleType) {
- case 2:
+ switch (medium) {
+ case MEDIUM_CART:
handle = gAudioContext.cartHandle;
break;
- case 3:
- handle = gAudioContext.unk_1E1C;
+ case MEDIUM_DISK_DRIVE:
+ // driveHandle is uninitialized and corresponds to stubbed-out disk drive support.
+ // SM64 Shindou called osDriveRomInit here.
+ handle = gAudioContext.driveHandle;
break;
default:
return 0;
@@ -885,145 +923,141 @@ s32 Audio_DMA(OSIoMesg* mesg, u32 priority, s32 direction, u32 devAddr, void* ra
return 0;
}
-void func_800E2CB8(void) {
+void AudioLoad_Unused1(void) {
}
-void func_800E2CC0(u32 tableType, u32 bankId) {
- s32 sp1C;
+void AudioLoad_SyncLoadSimple(u32 tableType, u32 fontId) {
+ s32 didAllocate;
- func_800E2558(tableType, bankId, &sp1C);
+ AudioLoad_SyncLoad(tableType, fontId, &didAllocate);
}
-void* Audio_AsyncLoadInner(s32 tableType, s32 arg1, s32 arg2, s32 arg3, OSMesgQueue* retQueue) {
+void* AudioLoad_AsyncLoadInner(s32 tableType, s32 id, s32 nChunks, s32 retData, OSMesgQueue* retQueue) {
u32 size;
AudioTable* sp50;
- void* sp4C;
- s32 sp48;
- s8 temp_a1;
+ void* ret;
+ s32 medium;
+ s8 cachePolicy;
u32 devAddr;
- s32 sp3C;
+ s32 status;
u32 temp_v0;
- u32 sp34;
+ u32 realId;
- sp34 = Audio_GetTableIndex(tableType, arg1);
+ realId = AudioLoad_GetRealTableIndex(tableType, id);
switch (tableType) {
case SEQUENCE_TABLE:
- if (gAudioContext.seqLoadStatus[sp34] == 1) {
+ if (gAudioContext.seqLoadStatus[realId] == 1) {
return NULL;
}
break;
- case BANK_TABLE:
- if (gAudioContext.bankLoadStatus[sp34] == 1) {
+ case FONT_TABLE:
+ if (gAudioContext.fontLoadStatus[realId] == 1) {
return NULL;
}
break;
- case AUDIO_TABLE:
- if (gAudioContext.audioTableLoadStatus[sp34] == 1) {
+ case SAMPLE_TABLE:
+ if (gAudioContext.sampleFontLoadStatus[realId] == 1) {
return NULL;
}
break;
}
- sp4C = func_800E27A4(tableType, sp34);
- if (sp4C != NULL) {
- sp3C = 2;
- osSendMesg(retQueue, arg3 << 0x18, 0);
+ ret = AudioLoad_SearchCaches(tableType, realId);
+ if (ret != NULL) {
+ status = 2;
+ osSendMesg(retQueue, MK_ASYNC_MSG(retData, 0, 0, 0), OS_MESG_NOBLOCK);
} else {
- sp50 = Audio_GetLoadTable(tableType);
- size = sp50->entries[sp34].size;
+ sp50 = AudioLoad_GetLoadTable(tableType);
+ size = sp50->entries[realId].size;
size = ALIGN16(size);
- sp48 = sp50->entries[arg1].unk_08;
- temp_a1 = sp50->entries[arg1].unk_09;
- devAddr = sp50->entries[sp34].romAddr;
- sp3C = 2;
- switch (temp_a1) {
+ medium = sp50->entries[id].medium;
+ cachePolicy = sp50->entries[id].cachePolicy;
+ devAddr = sp50->entries[realId].romAddr;
+ status = 2;
+ switch (cachePolicy) {
case 0:
- sp4C = func_800E0540(tableType, sp34, size);
- if (sp4C == NULL) {
- return sp4C;
+ ret = AudioHeap_AllocPermanent(tableType, realId, size);
+ if (ret == NULL) {
+ return ret;
}
- sp3C = 5;
+ status = 5;
break;
case 1:
- sp4C = Audio_AllocBankOrSeq(tableType, size, 1, sp34);
- if (sp4C == NULL) {
- return sp4C;
+ ret = AudioHeap_AllocCached(tableType, size, CACHE_PERSISTENT, realId);
+ if (ret == NULL) {
+ return ret;
}
break;
case 2:
- sp4C = Audio_AllocBankOrSeq(tableType, size, 0, sp34);
- if (sp4C == NULL) {
- return sp4C;
+ ret = AudioHeap_AllocCached(tableType, size, CACHE_TEMPORARY, realId);
+ if (ret == NULL) {
+ return ret;
}
break;
case 3:
case 4:
- sp4C = Audio_AllocBankOrSeq(tableType, size, 2, sp34);
- if (sp4C == NULL) {
- return sp4C;
+ ret = AudioHeap_AllocCached(tableType, size, CACHE_EITHER, realId);
+ if (ret == NULL) {
+ return ret;
}
break;
}
- if (sp48 == 1) {
- func_800E3A44((s16)sp50->header.unk_02, devAddr, sp4C, size, sp48, arg2, retQueue,
- (arg3 << 0x18) | (tableType << 0x10) | (arg1 << 8) | sp3C);
+ if (medium == MEDIUM_UNK) {
+ AudioLoad_StartAsyncLoadUnkMedium((s16)sp50->unkMediumParam, devAddr, ret, size, medium, nChunks, retQueue,
+ MK_ASYNC_MSG(retData, tableType, id, status));
} else {
- Audio_InitAsyncReq(devAddr, sp4C, size, sp48, arg2, retQueue, MK_ASYNC_MSG(arg3, tableType, sp34, sp3C));
+ AudioLoad_StartAsyncLoad(devAddr, ret, size, medium, nChunks, retQueue,
+ MK_ASYNC_MSG(retData, tableType, realId, status));
}
- sp3C = 1;
+ status = 1;
}
switch (tableType) {
- case 0:
- Audio_SetSeqLoadStatus(sp34, sp3C);
+ case SEQUENCE_TABLE:
+ AudioLoad_SetSeqLoadStatus(realId, status);
break;
- case 1:
- Audio_SetBankLoadStatus(sp34, sp3C);
+ case FONT_TABLE:
+ AudioLoad_SetFontLoadStatus(realId, status);
break;
- case 2:
- func_800E1A78(sp34, sp3C);
+ case SAMPLE_TABLE:
+ AudioLoad_SetSampleFontLoadStatusAndApplyCaches(realId, status);
break;
default:
break;
}
- return sp4C;
+ return ret;
}
-void Audio_ProcessLoads(s32 resetStatus) {
- Audio_ProcessSyncLoads(resetStatus);
- func_800E4590(resetStatus);
- Audio_ProcessAsyncLoads(resetStatus);
+void AudioLoad_ProcessLoads(s32 resetStatus) {
+ AudioLoad_ProcessSlowLoads(resetStatus);
+ AudioLoad_ProcessSamplePreloads(resetStatus);
+ AudioLoad_ProcessAsyncLoads(resetStatus);
}
-// SetDmaCallback
-void func_800E301C(void* callback) {
+void AudioLoad_SetDmaHandler(DmaHandler callback) {
sDmaHandler = callback;
}
-u32 D_801304D4 = 0;
-void func_800E3028(u32 arg0) {
- D_801304D4 = arg0;
+void AudioLoad_SetUnusedHandler(void* callback) {
+ sUnusedHandler = callback;
}
-// InitCtlTable
-void func_800E3034(s32 arg0) {
- CtlEntry* ctlEnt = &gAudioContext.ctlEntries[arg0];
- AudioBankTableEntry* tableEnt = &gAudioContext.audioBankTable->entries[arg0];
+void AudioLoad_InitSoundFontMeta(s32 fontId) {
+ SoundFont* font = &gAudioContext.soundFonts[fontId];
+ AudioTableEntry* entry = &gAudioContext.soundFontTable->entries[fontId];
- ctlEnt->unk_02 = (tableEnt->unk_0A >> 8) & 0xFF;
- ctlEnt->unk_03 = (tableEnt->unk_0A) & 0xFF;
- ctlEnt->numInstruments = (tableEnt->unk_0C >> 8) & 0xFF;
- ctlEnt->numDrums = tableEnt->unk_0C & 0xFF;
- ctlEnt->numSfx = tableEnt->unk_0E;
+ font->sampleBankId1 = (entry->shortData1 >> 8) & 0xFF;
+ font->sampleBankId2 = (entry->shortData1) & 0xFF;
+ font->numInstruments = (entry->shortData2 >> 8) & 0xFF;
+ font->numDrums = entry->shortData2 & 0xFF;
+ font->numSfx = entry->shortData3;
}
-s32 gAudioContextInitalized = 0;
-
-void Audio_ContextInit(void* heap, u32 heapSize) {
+void AudioLoad_Init(void* heap, u32 heapSize) {
char pad[0x48];
- s32 sp24;
+ s32 numFonts;
void* temp_v0_3;
s32 i;
u64* heapP;
@@ -1069,17 +1103,19 @@ void Audio_ContextInit(void* heap, u32 heapSize) {
gAudioContext.currTask = NULL;
gAudioContext.rspTask[0].task.t.data_size = 0;
gAudioContext.rspTask[1].task.t.data_size = 0;
- osCreateMesgQueue(&gAudioContext.unk_25E8, &gAudioContext.unk_2600, 1);
- osCreateMesgQueue(&gAudioContext.currAudioFrameDmaQueue, gAudioContext.currAudioFrameDmaMesgBufs, 0x40);
- osCreateMesgQueue(&gAudioContext.unk_1E20, gAudioContext.unk_1E38, 0x10);
- osCreateMesgQueue(&gAudioContext.unk_1E78, gAudioContext.unk_1E90, 0x10);
+ osCreateMesgQueue(&gAudioContext.syncDmaQueue, &gAudioContext.syncDmaMesg, 1);
+ osCreateMesgQueue(&gAudioContext.currAudioFrameDmaQueue, gAudioContext.currAudioFrameDmaMesgBuf, 0x40);
+ osCreateMesgQueue(&gAudioContext.externalLoadQueue, gAudioContext.externalLoadMesgBuf,
+ ARRAY_COUNT(gAudioContext.externalLoadMesgBuf));
+ osCreateMesgQueue(&gAudioContext.preloadSampleQueue, gAudioContext.preloadSampleMesgBuf,
+ ARRAY_COUNT(gAudioContext.externalLoadMesgBuf));
gAudioContext.curAudioFrameDmaCount = 0;
- gAudioContext.sampleDmaReqCnt = 0;
+ gAudioContext.sampleDmaCount = 0;
gAudioContext.cartHandle = osCartRomInit();
if (heap == NULL) {
gAudioContext.audioHeap = gAudioHeap;
- gAudioContext.audioHeapSize = D_8014A6C4.heap;
+ gAudioContext.audioHeapSize = D_8014A6C4.heapSize;
} else {
void** hp = &heap;
gAudioContext.audioHeap = *hp;
@@ -1090,73 +1126,74 @@ void Audio_ContextInit(void* heap, u32 heapSize) {
((u64*)gAudioContext.audioHeap)[i] = 0;
}
- Audio_InitMainPools(D_8014A6C4.mainPool);
+ AudioHeap_InitMainPools(D_8014A6C4.initPoolSize);
for (i = 0; i < 3; i++) {
- gAudioContext.aiBuffers[i] = Audio_AllocZeroed(&gAudioContext.audioInitPool, AIBUF_LEN);
+ gAudioContext.aiBuffers[i] = AudioHeap_AllocZeroed(&gAudioContext.audioInitPool, AIBUF_LEN * sizeof(s16));
}
- gAudioContext.sequenceTable = &gSequenceTable;
- gAudioContext.audioBankTable = &gAudioBankTable;
- gAudioContext.audioTable = &gAudioTable;
- gAudioContext.unk_283C = &D_80155340;
- gAudioContext.seqTabEntCnt = gAudioContext.sequenceTable->header.entryCnt;
+ gAudioContext.sequenceTable = (AudioTable*)gSequenceTable;
+ gAudioContext.soundFontTable = (AudioTable*)gSoundFontTable;
+ gAudioContext.sampleBankTable = (AudioTable*)gSampleBankTable;
+ gAudioContext.sequenceFontTable = gSequenceFontTable;
+ gAudioContext.numSequences = gAudioContext.sequenceTable->numEntries;
gAudioContext.audioResetSpecIdToLoad = 0;
gAudioContext.resetStatus = 1;
- Audio_ResetStep();
- Audio_InitAudioTable(gAudioContext.sequenceTable, _AudioseqSegmentRomStart, 0);
- Audio_InitAudioTable(gAudioContext.audioBankTable, _AudiobankSegmentRomStart, 0);
- Audio_InitAudioTable(gAudioContext.audioTable, _AudiotableSegmentRomStart, 0);
- sp24 = gAudioContext.audioBankTable->header.entryCnt;
- gAudioContext.ctlEntries = Audio_Alloc(&gAudioContext.audioInitPool, sp24 * sizeof(CtlEntry));
+ AudioHeap_ResetStep();
+ AudioLoad_InitTable(gAudioContext.sequenceTable, _AudioseqSegmentRomStart, 0);
+ AudioLoad_InitTable(gAudioContext.soundFontTable, _AudiobankSegmentRomStart, 0);
+ AudioLoad_InitTable(gAudioContext.sampleBankTable, _AudiotableSegmentRomStart, 0);
+ numFonts = gAudioContext.soundFontTable->numEntries;
+ gAudioContext.soundFonts = AudioHeap_Alloc(&gAudioContext.audioInitPool, numFonts * sizeof(SoundFont));
- for (i = 0; i < sp24; i++) {
- func_800E3034(i);
+ for (i = 0; i < numFonts; i++) {
+ AudioLoad_InitSoundFontMeta(i);
}
- if (temp_v0_3 = Audio_Alloc(&gAudioContext.audioInitPool, D_8014A6C4.initPool), temp_v0_3 == NULL) {
-
- *((u32*)&D_8014A6C4.initPool) = 0;
+ if (temp_v0_3 = AudioHeap_Alloc(&gAudioContext.audioInitPool, D_8014A6C4.permanentPoolSize), temp_v0_3 == NULL) {
+ // cast away const from D_8014A6C4
+ *((u32*)&D_8014A6C4.permanentPoolSize) = 0;
}
- Audio_SoundAllocPoolInit(&gAudioContext.unk_2D50, temp_v0_3, D_8014A6C4.initPool);
- gAudioContextInitalized = 1;
- osSendMesg(gAudioContext.taskStartQueueP, (void*)gAudioContext.totalTaskCnt, 0);
+ AudioHeap_AllocPoolInit(&gAudioContext.permanentPool, temp_v0_3, D_8014A6C4.permanentPoolSize);
+ gAudioContextInitalized = true;
+ osSendMesg(gAudioContext.taskStartQueueP, (void*)gAudioContext.totalTaskCnt, OS_MESG_NOBLOCK);
}
-void Audio_SyncLoadsInit(void) {
- gAudioContext.syncLoads[0].status = 0;
- gAudioContext.syncLoads[1].status = 0;
+void AudioLoad_InitSlowLoads(void) {
+ gAudioContext.slowLoads[0].status = 0;
+ gAudioContext.slowLoads[1].status = 0;
}
-s32 Audio_SyncLoadSample(s32 arg0, s32 arg1, s8* isDone) {
- AudioBankSample* sample;
- AudioSyncLoad* syncLoad;
+s32 AudioLoad_SlowLoadSample(s32 fontId, s32 instId, s8* isDone) {
+ SoundFontSample* sample;
+ AudioSlowLoad* slowLoad;
- sample = Audio_GetBankSample(arg0, arg1);
+ sample = AudioLoad_GetFontSample(fontId, instId);
if (sample == NULL) {
*isDone = 0;
return -1;
}
- if (sample->medium == 0) {
+ if (sample->medium == MEDIUM_RAM) {
*isDone = 2;
return 0;
}
- syncLoad = &gAudioContext.syncLoads[gAudioContext.syncLoadPos];
- if (syncLoad->status == LOAD_STATUS_DONE) {
- syncLoad->status = LOAD_STATUS_WAITING;
+ slowLoad = &gAudioContext.slowLoads[gAudioContext.slowLoadPos];
+ if (slowLoad->status == LOAD_STATUS_DONE) {
+ slowLoad->status = LOAD_STATUS_WAITING;
}
- syncLoad->sample = *sample;
- syncLoad->isDone = isDone;
- syncLoad->ramAddr = func_800E05C4(sample->size, arg0, sample->sampleAddr, sample->medium, 0);
+ slowLoad->sample = *sample;
+ slowLoad->isDone = isDone;
+ slowLoad->curRamAddr =
+ AudioHeap_AllocSampleCache(sample->size, fontId, sample->sampleAddr, sample->medium, CACHE_TEMPORARY);
- if (syncLoad->ramAddr == NULL) {
- if (sample->medium == 1 || sample->codec == 2) {
+ if (slowLoad->curRamAddr == NULL) {
+ if (sample->medium == MEDIUM_UNK || sample->codec == CODEC_S16_INMEMORY) {
*isDone = 0;
return -1;
} else {
@@ -1165,376 +1202,391 @@ s32 Audio_SyncLoadSample(s32 arg0, s32 arg1, s8* isDone) {
}
}
- syncLoad->status = LOAD_STATUS_START;
- syncLoad->size = ALIGN16(sample->size);
- syncLoad->unk_10 = syncLoad->ramAddr;
- syncLoad->devAddr = sample->sampleAddr;
- syncLoad->unk_00 = sample->medium;
- syncLoad->unk_01 = arg0;
- syncLoad->unk_02 = arg1;
- if (syncLoad->unk_00 == 1) {
- syncLoad->unk_04 = gAudioContext.audioTable->header.unk_02;
+ slowLoad->status = LOAD_STATUS_START;
+ slowLoad->bytesRemaining = ALIGN16(sample->size);
+ slowLoad->ramAddr = slowLoad->curRamAddr;
+ slowLoad->curDevAddr = sample->sampleAddr;
+ slowLoad->medium = sample->medium;
+ slowLoad->seqOrFontId = fontId;
+ slowLoad->instId = instId;
+ if (slowLoad->medium == MEDIUM_UNK) {
+ slowLoad->unkMediumParam = gAudioContext.sampleBankTable->unkMediumParam;
}
- gAudioContext.syncLoadPos ^= 1;
+ gAudioContext.slowLoadPos ^= 1;
return 0;
}
-AudioBankSample* Audio_GetBankSample(s32 bankId, s32 sfxId) {
- AudioBankSample* ret;
+SoundFontSample* AudioLoad_GetFontSample(s32 fontId, s32 instId) {
+ SoundFontSample* ret;
- if (sfxId < 0x80) {
- Instrument* instrument = Audio_GetInstrumentInner(bankId, sfxId);
+ if (instId < 0x80) {
+ Instrument* instrument = Audio_GetInstrumentInner(fontId, instId);
if (instrument == NULL) {
return NULL;
}
ret = instrument->normalNotesSound.sample;
- } else if (sfxId < 0x100) {
- Drum* drum = Audio_GetDrum(bankId, sfxId - 0x80);
+ } else if (instId < 0x100) {
+ Drum* drum = Audio_GetDrum(fontId, instId - 0x80);
if (drum == NULL) {
return NULL;
}
ret = drum->sound.sample;
} else {
- AudioBankSound* bankSound = Audio_GetSfx(bankId, sfxId - 0x100);
- if (bankSound == NULL) {
+ SoundFontSound* sound = Audio_GetSfx(fontId, instId - 0x100);
+ if (sound == NULL) {
return NULL;
}
- ret = bankSound->sample;
+ ret = sound->sample;
}
return ret;
}
-void func_800E3670(void) {
+void AudioLoad_Unused2(void) {
}
-void func_800E3678(AudioSyncLoad* syncLoad) {
- AudioBankSample* sample;
+void AudioLoad_FinishSlowLoad(AudioSlowLoad* slowLoad) {
+ SoundFontSample* sample;
- if (syncLoad->sample.sampleAddr == NULL) {
+ if (slowLoad->sample.sampleAddr == NULL) {
return;
}
- sample = Audio_GetBankSample(syncLoad->unk_01, syncLoad->unk_02);
+ sample = AudioLoad_GetFontSample(slowLoad->seqOrFontId, slowLoad->instId);
if (sample == NULL) {
return;
}
- syncLoad->sample = *sample;
- sample->sampleAddr = syncLoad->unk_10;
- sample->medium = 0;
+ slowLoad->sample = *sample;
+ sample->sampleAddr = slowLoad->ramAddr;
+ sample->medium = MEDIUM_RAM;
}
-void Audio_ProcessSyncLoads(s32 resetStatus) {
- AudioSyncLoad* syncLoad;
+void AudioLoad_ProcessSlowLoads(s32 resetStatus) {
+ AudioSlowLoad* slowLoad;
s32 i;
- for (i = 0; i < ARRAY_COUNT(gAudioContext.syncLoads); i++) {
- syncLoad = &gAudioContext.syncLoads[i];
- switch (gAudioContext.syncLoads[i].status) {
+ for (i = 0; i < ARRAY_COUNT(gAudioContext.slowLoads); i++) {
+ slowLoad = &gAudioContext.slowLoads[i];
+ switch (gAudioContext.slowLoads[i].status) {
case LOAD_STATUS_LOADING:
- if (syncLoad->unk_00 != 1) {
- osRecvMesg(&syncLoad->msgqueue, NULL, OS_MESG_BLOCK);
+ if (slowLoad->medium != MEDIUM_UNK) {
+ osRecvMesg(&slowLoad->msgqueue, NULL, OS_MESG_BLOCK);
}
if (resetStatus != 0) {
- syncLoad->status = LOAD_STATUS_DONE;
+ slowLoad->status = LOAD_STATUS_DONE;
continue;
}
case LOAD_STATUS_START:
- syncLoad->status = LOAD_STATUS_LOADING;
- if (syncLoad->size == 0) {
- func_800E3678(syncLoad);
- syncLoad->status = LOAD_STATUS_DONE;
- *syncLoad->isDone = 1;
- } else if (syncLoad->size < 0x400) {
- if (syncLoad->unk_00 == 1) {
- u32 size = syncLoad->size;
- func_800E38F8(syncLoad->devAddr, syncLoad->ramAddr, size, syncLoad->unk_04);
+ slowLoad->status = LOAD_STATUS_LOADING;
+ if (slowLoad->bytesRemaining == 0) {
+ AudioLoad_FinishSlowLoad(slowLoad);
+ slowLoad->status = LOAD_STATUS_DONE;
+ *slowLoad->isDone = 1;
+ } else if (slowLoad->bytesRemaining < 0x400) {
+ if (slowLoad->medium == MEDIUM_UNK) {
+ u32 size = slowLoad->bytesRemaining;
+ AudioLoad_DmaSlowCopyUnkMedium(slowLoad->curDevAddr, slowLoad->curRamAddr, size,
+ slowLoad->unkMediumParam);
} else {
- func_800E3874(syncLoad, syncLoad->size);
+ AudioLoad_DmaSlowCopy(slowLoad, slowLoad->bytesRemaining);
}
- syncLoad->size = 0;
+ slowLoad->bytesRemaining = 0;
} else {
- if (syncLoad->unk_00 == 1) {
- func_800E38F8(syncLoad->devAddr, syncLoad->ramAddr, 0x400, syncLoad->unk_04);
+ if (slowLoad->medium == MEDIUM_UNK) {
+ AudioLoad_DmaSlowCopyUnkMedium(slowLoad->curDevAddr, slowLoad->curRamAddr, 0x400,
+ slowLoad->unkMediumParam);
} else {
- func_800E3874(syncLoad, 0x400);
+ AudioLoad_DmaSlowCopy(slowLoad, 0x400);
}
- syncLoad->size -= 0x400;
- syncLoad->ramAddr += 0x400;
- syncLoad->devAddr += 0x400;
+ slowLoad->bytesRemaining -= 0x400;
+ slowLoad->curRamAddr += 0x400;
+ slowLoad->curDevAddr += 0x400;
}
break;
}
}
}
-void func_800E3874(AudioSyncLoad* arg0, s32 size) {
- Audio_osInvalDCache(arg0->ramAddr, size);
- osCreateMesgQueue(&arg0->msgqueue, &arg0->msg, 1);
- Audio_DMA(&arg0->ioMesg, 0U, 0, arg0->devAddr, arg0->ramAddr, size, &arg0->msgqueue, arg0->unk_00, "SLOWCOPY");
+void AudioLoad_DmaSlowCopy(AudioSlowLoad* slowLoad, s32 size) {
+ Audio_osInvalDCache(slowLoad->curRamAddr, size);
+ osCreateMesgQueue(&slowLoad->msgqueue, &slowLoad->msg, 1);
+ AudioLoad_Dma(&slowLoad->ioMesg, 0U, 0, slowLoad->curDevAddr, slowLoad->curRamAddr, size, &slowLoad->msgqueue,
+ slowLoad->medium, "SLOWCOPY");
}
-void func_800E38F8(s32 arg0, s32 arg1, s32 arg2, s32 arg3) {
+void AudioLoad_DmaSlowCopyUnkMedium(s32 devAddr, u8* ramAddr, s32 size, s32 arg3) {
}
-s32 Audio_SyncLoadSeq(s32 seqIdx, u8* ramAddr, s8* isDone) {
- AudioSyncLoad* syncLoad;
- SequenceTable* seqTable;
+s32 AudioLoad_SlowLoadSeq(s32 seqId, u8* ramAddr, s8* isDone) {
+ AudioSlowLoad* slowLoad;
+ AudioTable* seqTable;
u32 size;
- if (seqIdx >= gAudioContext.seqTabEntCnt) {
+ if (seqId >= gAudioContext.numSequences) {
*isDone = 0;
return -1;
}
- seqIdx = Audio_GetTableIndex(SEQUENCE_TABLE, seqIdx);
- seqTable = Audio_GetLoadTable(SEQUENCE_TABLE);
- syncLoad = &gAudioContext.syncLoads[gAudioContext.syncLoadPos];
- if (syncLoad->status == LOAD_STATUS_DONE) {
- syncLoad->status = LOAD_STATUS_WAITING;
+ seqId = AudioLoad_GetRealTableIndex(SEQUENCE_TABLE, seqId);
+ seqTable = AudioLoad_GetLoadTable(SEQUENCE_TABLE);
+ slowLoad = &gAudioContext.slowLoads[gAudioContext.slowLoadPos];
+ if (slowLoad->status == LOAD_STATUS_DONE) {
+ slowLoad->status = LOAD_STATUS_WAITING;
}
- syncLoad->sample.sampleAddr = NULL;
- syncLoad->isDone = isDone;
- size = seqTable->entries[seqIdx].size;
+ slowLoad->sample.sampleAddr = NULL;
+ slowLoad->isDone = isDone;
+ size = seqTable->entries[seqId].size;
size = ALIGN16(size);
- syncLoad->ramAddr = ramAddr;
- syncLoad->status = LOAD_STATUS_START;
- syncLoad->size = size;
- syncLoad->unk_10 = ramAddr;
- syncLoad->devAddr = seqTable->entries[seqIdx].romAddr;
- syncLoad->unk_00 = seqTable->entries[seqIdx].unk_08;
- syncLoad->unk_01 = seqIdx;
+ slowLoad->curRamAddr = ramAddr;
+ slowLoad->status = LOAD_STATUS_START;
+ slowLoad->bytesRemaining = size;
+ slowLoad->ramAddr = ramAddr;
+ slowLoad->curDevAddr = seqTable->entries[seqId].romAddr;
+ slowLoad->medium = seqTable->entries[seqId].medium;
+ slowLoad->seqOrFontId = seqId;
- if (syncLoad->unk_00 == 1) {
- syncLoad->unk_04 = seqTable->header.unk_02;
+ if (slowLoad->medium == MEDIUM_UNK) {
+ slowLoad->unkMediumParam = seqTable->unkMediumParam;
}
- gAudioContext.syncLoadPos ^= 1;
+ gAudioContext.slowLoadPos ^= 1;
return 0;
}
-void Audio_AsyncLoadReqInit(void) {
+void AudioLoad_InitAsyncLoads(void) {
s32 i;
- for (i = 0; i < ARRAY_COUNT(gAudioContext.asyncReqs); i++) {
- gAudioContext.asyncReqs[i].status = 0;
+ for (i = 0; i < ARRAY_COUNT(gAudioContext.asyncLoads); i++) {
+ gAudioContext.asyncLoads[i].status = 0;
}
}
-AsyncLoadReq* func_800E3A44(s32 arg0, u32 devAddr, void* ramAddr, s32 size, s32 arg4, s32 nChunks,
- OSMesgQueue* retQueue, s32 retMsg) {
- AsyncLoadReq* loadReq;
+AudioAsyncLoad* AudioLoad_StartAsyncLoadUnkMedium(s32 unkMediumParam, u32 devAddr, void* ramAddr, s32 size, s32 medium,
+ s32 nChunks, OSMesgQueue* retQueue, s32 retMsg) {
+ AudioAsyncLoad* asyncLoad;
- loadReq = Audio_InitAsyncReq(devAddr, ramAddr, size, arg4, nChunks, retQueue, retMsg);
+ asyncLoad = AudioLoad_StartAsyncLoad(devAddr, ramAddr, size, medium, nChunks, retQueue, retMsg);
- if (loadReq == NULL) {
+ if (asyncLoad == NULL) {
return NULL;
}
- osSendMesg(&gAudioContext.asyncLoadQueue, loadReq, 0);
- loadReq->unk_18 = arg0;
- return loadReq;
+ osSendMesg(&gAudioContext.asyncLoadUnkMediumQueue, asyncLoad, OS_MESG_NOBLOCK);
+ asyncLoad->unkMediumParam = unkMediumParam;
+ return asyncLoad;
}
-AsyncLoadReq* Audio_InitAsyncReq(u32 devAddr, void* ramAddr, u32 size, s32 arg3, s32 nChunks, OSMesgQueue* retQueue,
- s32 retMsg) {
- AsyncLoadReq* loadReq;
+AudioAsyncLoad* AudioLoad_StartAsyncLoad(u32 devAddr, void* ramAddr, u32 size, s32 medium, s32 nChunks,
+ OSMesgQueue* retQueue, s32 retMsg) {
+ AudioAsyncLoad* asyncLoad;
s32 i;
- for (i = 0; i < ARRAY_COUNT(gAudioContext.asyncReqs); i++) {
- if (gAudioContext.asyncReqs[i].status == 0) {
- loadReq = &gAudioContext.asyncReqs[i];
+ for (i = 0; i < ARRAY_COUNT(gAudioContext.asyncLoads); i++) {
+ if (gAudioContext.asyncLoads[i].status == 0) {
+ asyncLoad = &gAudioContext.asyncLoads[i];
break;
}
}
- // no more available async reqs
- if (i == ARRAY_COUNT(gAudioContext.asyncReqs)) {
+ // no more available async loads
+ if (i == ARRAY_COUNT(gAudioContext.asyncLoads)) {
return NULL;
}
- loadReq->status = LOAD_STATUS_START;
- loadReq->devAddr = devAddr;
- loadReq->unk_04 = ramAddr;
- loadReq->ramAddr = ramAddr;
- loadReq->bytesRemaining = size;
+ asyncLoad->status = LOAD_STATUS_START;
+ asyncLoad->curDevAddr = devAddr;
+ asyncLoad->ramAddr = ramAddr;
+ asyncLoad->curRamAddr = ramAddr;
+ asyncLoad->bytesRemaining = size;
if (nChunks == 0) {
- loadReq->chunkSize = 0x1000;
+ asyncLoad->chunkSize = 0x1000;
} else if (nChunks == 1) {
- loadReq->chunkSize = size;
+ asyncLoad->chunkSize = size;
} else {
- loadReq->chunkSize = (((s32)size / nChunks) + 0xFF) & ~0xFF;
- if (loadReq->chunkSize < 0x100) {
- loadReq->chunkSize = 0x100;
+ asyncLoad->chunkSize = (((s32)size / nChunks) + 0xFF) & ~0xFF;
+ if (asyncLoad->chunkSize < 0x100) {
+ asyncLoad->chunkSize = 0x100;
}
}
- loadReq->retQueue = retQueue;
- loadReq->unk_01 = 3;
- loadReq->unk_02 = arg3;
- loadReq->retMsg = retMsg;
- osCreateMesgQueue(&loadReq->msgQueue, &loadReq->msg, 1);
- return loadReq;
+ asyncLoad->retQueue = retQueue;
+ asyncLoad->delay = 3;
+ asyncLoad->medium = medium;
+ asyncLoad->retMsg = retMsg;
+ osCreateMesgQueue(&asyncLoad->msgQueue, &asyncLoad->msg, 1);
+ return asyncLoad;
}
-void Audio_ProcessAsyncLoads(s32 resetStatus) {
- AsyncLoadReq* loadReq;
+void AudioLoad_ProcessAsyncLoads(s32 resetStatus) {
+ AudioAsyncLoad* asyncLoad;
s32 i;
if (gAudioContext.resetTimer == 1) {
return;
}
- if (gAudioContext.curAsyncReq == NULL) {
+ if (gAudioContext.curUnkMediumLoad == NULL) {
if (resetStatus != 0) {
+ // Clear and ignore queue if resetting.
do {
- } while (osRecvMesg(&gAudioContext.asyncLoadQueue, (OSMesg*)&loadReq, OS_MESG_NOBLOCK) != -1);
- } else if (osRecvMesg(&gAudioContext.asyncLoadQueue, (OSMesg*)&loadReq, OS_MESG_NOBLOCK) == -1) {
- gAudioContext.curAsyncReq = NULL;
+ } while (osRecvMesg(&gAudioContext.asyncLoadUnkMediumQueue, (OSMesg*)&asyncLoad, OS_MESG_NOBLOCK) != -1);
+ } else if (osRecvMesg(&gAudioContext.asyncLoadUnkMediumQueue, (OSMesg*)&asyncLoad, OS_MESG_NOBLOCK) == -1) {
+ gAudioContext.curUnkMediumLoad = NULL;
} else {
- gAudioContext.curAsyncReq = loadReq;
+ gAudioContext.curUnkMediumLoad = asyncLoad;
}
}
- if (gAudioContext.curAsyncReq != NULL) {
- Audio_HandleAsyncMsg(gAudioContext.curAsyncReq, resetStatus);
+ if (gAudioContext.curUnkMediumLoad != NULL) {
+ AudioLoad_ProcessAsyncLoadUnkMedium(gAudioContext.curUnkMediumLoad, resetStatus);
}
- for (i = 0; i < ARRAY_COUNT(gAudioContext.asyncReqs); i++) {
- if (gAudioContext.asyncReqs[i].status == 1) {
- loadReq = &gAudioContext.asyncReqs[i];
- if (loadReq->unk_02 != 1) {
- Audio_UpdateAsyncReq(loadReq, resetStatus);
+ for (i = 0; i < ARRAY_COUNT(gAudioContext.asyncLoads); i++) {
+ if (gAudioContext.asyncLoads[i].status == 1) {
+ asyncLoad = &gAudioContext.asyncLoads[i];
+ if (asyncLoad->medium != MEDIUM_UNK) {
+ AudioLoad_ProcessAsyncLoad(asyncLoad, resetStatus);
}
}
}
}
-void Audio_HandleAsyncMsg(AsyncLoadReq* arg0, s32 arg1) {
+void AudioLoad_ProcessAsyncLoadUnkMedium(AudioAsyncLoad* asyncLoad, s32 resetStatus) {
}
-void Audio_AsyncReqDone(AsyncLoadReq* loadReq) {
- u32 retMsg = loadReq->retMsg;
- u32 b2;
+void AudioLoad_FinishAsyncLoad(AudioAsyncLoad* asyncLoad) {
+ u32 retMsg = asyncLoad->retMsg;
+ u32 fontId;
u32 pad;
- u32 t1;
OSMesg doneMsg;
- u32 t2;
- RelocInfo sp30;
+ u32 sampleBankId1;
+ u32 sampleBankId2;
+ RelocInfo relocInfo;
if (1) {}
switch (ASYNC_TBLTYPE(retMsg)) {
case SEQUENCE_TABLE:
- Audio_SetSeqLoadStatus(ASYNC_B2(retMsg), ASYNC_B3(retMsg));
+ AudioLoad_SetSeqLoadStatus(ASYNC_ID(retMsg), ASYNC_STATUS(retMsg));
break;
- case AUDIO_TABLE:
- func_800E1A78(ASYNC_B2(retMsg), ASYNC_B3(retMsg));
+ case SAMPLE_TABLE:
+ AudioLoad_SetSampleFontLoadStatusAndApplyCaches(ASYNC_ID(retMsg), ASYNC_STATUS(retMsg));
break;
- case BANK_TABLE:
- b2 = ASYNC_B2(retMsg);
- t1 = gAudioContext.ctlEntries[b2].unk_02;
- t2 = gAudioContext.ctlEntries[b2].unk_03;
- sp30.index1 = t1;
- sp30.index2 = t2;
- sp30.baseAddr1 = t1 != 0xFF ? func_800E2318(t1, &sp30.medium1) : 0;
- sp30.baseAddr2 = t2 != 0xFF ? func_800E2318(t2, &sp30.medium2) : 0;
- Audio_SetBankLoadStatus(b2, ASYNC_B3(retMsg));
- func_800E4198(b2, loadReq->unk_04, &sp30, 1);
+ case FONT_TABLE:
+ fontId = ASYNC_ID(retMsg);
+ sampleBankId1 = gAudioContext.soundFonts[fontId].sampleBankId1;
+ sampleBankId2 = gAudioContext.soundFonts[fontId].sampleBankId2;
+ relocInfo.sampleBankId1 = sampleBankId1;
+ relocInfo.sampleBankId2 = sampleBankId2;
+ relocInfo.baseAddr1 =
+ sampleBankId1 != 0xFF ? AudioLoad_GetSampleBank(sampleBankId1, &relocInfo.medium1) : 0;
+ relocInfo.baseAddr2 =
+ sampleBankId2 != 0xFF ? AudioLoad_GetSampleBank(sampleBankId2, &relocInfo.medium2) : 0;
+ AudioLoad_SetFontLoadStatus(fontId, ASYNC_STATUS(retMsg));
+ AudioLoad_RelocateFontAndPreloadSamples(fontId, asyncLoad->ramAddr, &relocInfo, true);
break;
}
- doneMsg = loadReq->retMsg;
+ doneMsg = asyncLoad->retMsg;
if (1) {}
- loadReq->status = LOAD_STATUS_WAITING;
- osSendMesg(loadReq->retQueue, doneMsg, OS_MESG_NOBLOCK);
+ asyncLoad->status = LOAD_STATUS_WAITING;
+ osSendMesg(asyncLoad->retQueue, doneMsg, OS_MESG_NOBLOCK);
}
-void Audio_UpdateAsyncReq(AsyncLoadReq* req, s32 resetStatus) {
- AudioTable* audioTable = gAudioContext.audioTable;
+void AudioLoad_ProcessAsyncLoad(AudioAsyncLoad* asyncLoad, s32 resetStatus) {
+ AudioTable* sampleBankTable = gAudioContext.sampleBankTable;
- if (req->unk_01 >= 2) {
- req->unk_01--;
+ if (asyncLoad->delay >= 2) {
+ asyncLoad->delay--;
return;
}
- if (req->unk_01 == 1) {
- req->unk_01 = 0;
+ if (asyncLoad->delay == 1) {
+ asyncLoad->delay = 0;
} else if (resetStatus != 0) {
- osRecvMesg(&req->msgQueue, NULL, OS_MESG_BLOCK);
- req->status = LOAD_STATUS_WAITING;
+ // Await the previous DMA response synchronously, then return.
+ osRecvMesg(&asyncLoad->msgQueue, NULL, OS_MESG_BLOCK);
+ asyncLoad->status = LOAD_STATUS_WAITING;
return;
- } else if (osRecvMesg(&req->msgQueue, NULL, OS_MESG_NOBLOCK) == -1) {
+ } else if (osRecvMesg(&asyncLoad->msgQueue, NULL, OS_MESG_NOBLOCK) == -1) {
+ // If the previous DMA step isn't done, return.
return;
}
- if (req->bytesRemaining == 0) {
- Audio_AsyncReqDone(req);
+ if (asyncLoad->bytesRemaining == 0) {
+ AudioLoad_FinishAsyncLoad(asyncLoad);
return;
}
- if (req->bytesRemaining < req->chunkSize) {
- if (req->unk_02 == 1) {
- func_800E4044(req->devAddr, req->ramAddr, req->bytesRemaining, audioTable->header.unk_02);
+ if (asyncLoad->bytesRemaining < asyncLoad->chunkSize) {
+ if (asyncLoad->medium == MEDIUM_UNK) {
+ AudioLoad_AsyncDmaUnkMedium(asyncLoad->curDevAddr, asyncLoad->curRamAddr, asyncLoad->bytesRemaining,
+ sampleBankTable->unkMediumParam);
} else {
- func_800E3FB4(req, req->bytesRemaining);
+ AudioLoad_AsyncDma(asyncLoad, asyncLoad->bytesRemaining);
}
- req->bytesRemaining = 0;
+ asyncLoad->bytesRemaining = 0;
return;
}
- if (req->unk_02 == 1) {
- func_800E4044(req->devAddr, req->ramAddr, req->chunkSize, audioTable->header.unk_02);
+ if (asyncLoad->medium == MEDIUM_UNK) {
+ AudioLoad_AsyncDmaUnkMedium(asyncLoad->curDevAddr, asyncLoad->curRamAddr, asyncLoad->chunkSize,
+ sampleBankTable->unkMediumParam);
} else {
- func_800E3FB4(req, req->chunkSize);
+ AudioLoad_AsyncDma(asyncLoad, asyncLoad->chunkSize);
}
- req->bytesRemaining -= req->chunkSize;
- req->devAddr += req->chunkSize;
- req->ramAddr = req->ramAddr + req->chunkSize;
+ asyncLoad->bytesRemaining -= asyncLoad->chunkSize;
+ asyncLoad->curDevAddr += asyncLoad->chunkSize;
+ asyncLoad->curRamAddr += asyncLoad->chunkSize;
}
-void func_800E3FB4(AsyncLoadReq* req, u32 size) {
+void AudioLoad_AsyncDma(AudioAsyncLoad* asyncLoad, u32 size) {
size = ALIGN16(size);
- Audio_osInvalDCache(req->ramAddr, size);
- osCreateMesgQueue(&req->msgQueue, &req->msg, 1);
- Audio_DMA(&req->ioMesg, 0, 0, req->devAddr, req->ramAddr, size, &req->msgQueue, req->unk_02, "BGCOPY");
+ Audio_osInvalDCache(asyncLoad->curRamAddr, size);
+ osCreateMesgQueue(&asyncLoad->msgQueue, &asyncLoad->msg, 1);
+ AudioLoad_Dma(&asyncLoad->ioMesg, 0, 0, asyncLoad->curDevAddr, asyncLoad->curRamAddr, size, &asyncLoad->msgQueue,
+ asyncLoad->medium, "BGCOPY");
}
-void func_800E4044(u32 devAddr, void* ramAddr, u32 size, s16 arg3) {
+void AudioLoad_AsyncDmaUnkMedium(u32 devAddr, void* ramAddr, u32 size, s16 arg3) {
}
#define RELOC(v, base) (reloc = (void*)((u32)(v) + (u32)(base)))
-void Audio_SampleReloc(AudioBankSound* sound, u32 arg1, RelocInfo* arg2) {
- AudioBankSample* sample;
+void AudioLoad_RelocateSample(SoundFontSound* sound, SoundFontData* mem, RelocInfo* relocInfo) {
+ SoundFontSample* sample;
void* reloc;
if ((u32)sound->sample <= 0x80000000) {
- sample = sound->sample = RELOC(sound->sample, arg1);
- if (sample->size != 0 && sample->unk_bits25 != 1) {
- sample->loop = RELOC(sample->loop, arg1);
- sample->book = RELOC(sample->book, arg1);
+ sample = sound->sample = RELOC(sound->sample, mem);
+ if (sample->size != 0 && sample->unk_bit25 != 1) {
+ sample->loop = RELOC(sample->loop, mem);
+ sample->book = RELOC(sample->book, mem);
+
+ // Resolve the sample medium 2-bit bitfield into a real value based on relocInfo.
switch (sample->medium) {
case 0:
- sample->sampleAddr = RELOC(sample->sampleAddr, arg2->baseAddr1);
- sample->medium = arg2->medium1;
+ sample->sampleAddr = RELOC(sample->sampleAddr, relocInfo->baseAddr1);
+ sample->medium = relocInfo->medium1;
break;
case 1:
- sample->sampleAddr = RELOC(sample->sampleAddr, arg2->baseAddr2);
- sample->medium = arg2->medium2;
+ sample->sampleAddr = RELOC(sample->sampleAddr, relocInfo->baseAddr2);
+ sample->medium = relocInfo->medium2;
break;
case 2:
case 3:
+ // Invalid? This leaves sample->medium as MEDIUM_CART and MEDIUM_DISK_DRIVE
+ // respectively, and the sampleAddr unrelocated.
break;
}
- sample->unk_bits25 = 1;
- if (sample->unk_bits26 && (sample->medium != 0)) {
- gAudioContext.unk_0B68[gAudioContext.unk_1768++] = sample;
+ sample->unk_bit25 = 1;
+ if (sample->unk_bit26 && (sample->medium != MEDIUM_RAM)) {
+ gAudioContext.usedSamples[gAudioContext.numUsedSamples++] = sample;
}
}
}
@@ -1542,56 +1594,63 @@ void Audio_SampleReloc(AudioBankSound* sound, u32 arg1, RelocInfo* arg2) {
#undef RELOC
-void func_800E4198(s32 bankId, AudioBankData* mem, RelocInfo* relocInfo, s32 arg3) {
- AudioStruct0D68* item;
- AudioStruct0D68* item2;
- AudioBankSample* sample;
- s32 count;
+void AudioLoad_RelocateFontAndPreloadSamples(s32 fontId, SoundFontData* mem, RelocInfo* relocInfo, s32 async) {
+ AudioPreloadReq* preload;
+ AudioPreloadReq* topPreload;
+ SoundFontSample* sample;
+ s32 size;
s32 nChunks;
u8* addr;
- s32 sp4C;
+ s32 preloadInProgress;
s32 i;
- sp4C = false;
- if (gAudioContext.unk_176C != 0) {
- sp4C = true;
+ preloadInProgress = false;
+ if (gAudioContext.preloadSampleStackTop != 0) {
+ preloadInProgress = true;
} else {
D_8016B780 = 0;
}
- gAudioContext.unk_1768 = 0;
- func_800E283C(bankId, mem, relocInfo);
- count = 0;
- for (i = 0; i < gAudioContext.unk_1768; i++) {
- count += ALIGN16(gAudioContext.unk_0B68[i]->size);
+ gAudioContext.numUsedSamples = 0;
+ AudioLoad_RelocateFont(fontId, mem, relocInfo);
+
+ size = 0;
+ for (i = 0; i < gAudioContext.numUsedSamples; i++) {
+ size += ALIGN16(gAudioContext.usedSamples[i]->size);
}
- if (count && count) {}
+ if (size && size) {}
- for (i = 0; i < gAudioContext.unk_1768; i++) {
- if (gAudioContext.unk_176C == 120) {
+ for (i = 0; i < gAudioContext.numUsedSamples; i++) {
+ if (gAudioContext.preloadSampleStackTop == 120) {
break;
}
- sample = gAudioContext.unk_0B68[i];
+ sample = gAudioContext.usedSamples[i];
addr = NULL;
- switch (arg3) {
- case 0:
+ switch (async) {
+ case false:
if (sample->medium == relocInfo->medium1) {
- addr = func_800E05C4(sample->size, relocInfo->index1, sample->sampleAddr, sample->medium, 1);
+ addr = AudioHeap_AllocSampleCache(sample->size, relocInfo->sampleBankId1, sample->sampleAddr,
+ sample->medium, CACHE_PERSISTENT);
} else if (sample->medium == relocInfo->medium2) {
- addr = func_800E05C4(sample->size, relocInfo->index2, sample->sampleAddr, sample->medium, 1);
- } else if (sample->medium == 3) {
- addr = func_800E05C4(sample->size, 0xFE, sample->sampleAddr, sample->medium, 1);
+ addr = AudioHeap_AllocSampleCache(sample->size, relocInfo->sampleBankId2, sample->sampleAddr,
+ sample->medium, CACHE_PERSISTENT);
+ } else if (sample->medium == MEDIUM_DISK_DRIVE) {
+ addr = AudioHeap_AllocSampleCache(sample->size, 0xFE, sample->sampleAddr, sample->medium,
+ CACHE_PERSISTENT);
}
break;
- case 1:
+ case true:
if (sample->medium == relocInfo->medium1) {
- addr = func_800E05C4(sample->size, relocInfo->index1, sample->sampleAddr, sample->medium, 0);
+ addr = AudioHeap_AllocSampleCache(sample->size, relocInfo->sampleBankId1, sample->sampleAddr,
+ sample->medium, CACHE_TEMPORARY);
} else if (sample->medium == relocInfo->medium2) {
- addr = func_800E05C4(sample->size, relocInfo->index2, sample->sampleAddr, sample->medium, 0);
- } else if (sample->medium == 3) {
- addr = func_800E05C4(sample->size, 0xFE, sample->sampleAddr, sample->medium, 0);
+ addr = AudioHeap_AllocSampleCache(sample->size, relocInfo->sampleBankId2, sample->sampleAddr,
+ sample->medium, CACHE_TEMPORARY);
+ } else if (sample->medium == MEDIUM_DISK_DRIVE) {
+ addr = AudioHeap_AllocSampleCache(sample->size, 0xFE, sample->sampleAddr, sample->medium,
+ CACHE_TEMPORARY);
}
break;
}
@@ -1599,93 +1658,98 @@ void func_800E4198(s32 bankId, AudioBankData* mem, RelocInfo* relocInfo, s32 arg
continue;
}
- switch (arg3) {
- case 0:
- if (sample->medium == 1) {
- Audio_NoopCopy((u32)sample->sampleAddr, addr, sample->size,
- gAudioContext.audioTable->header.unk_02);
+ switch (async) {
+ case false:
+ if (sample->medium == MEDIUM_UNK) {
+ AudioLoad_SyncDmaUnkMedium((u32)sample->sampleAddr, addr, sample->size,
+ gAudioContext.sampleBankTable->unkMediumParam);
sample->sampleAddr = addr;
- sample->medium = 0;
+ sample->medium = MEDIUM_RAM;
} else {
- Audio_DMAFastCopy((u32)sample->sampleAddr, addr, sample->size, sample->medium);
+ AudioLoad_SyncDma((u32)sample->sampleAddr, addr, sample->size, sample->medium);
sample->sampleAddr = addr;
- sample->medium = 0;
+ sample->medium = MEDIUM_RAM;
}
- if (sample->medium == 3) {}
+ if (sample->medium == MEDIUM_DISK_DRIVE) {}
break;
- case 1:
- item = &gAudioContext.unk_0D68[gAudioContext.unk_176C];
- item->sample = sample;
- item->ramAddr = addr;
- item->encodedInfo = (gAudioContext.unk_176C << 24) | 0xFFFFFF;
- item->isFree = false;
- item->endAndMediumKey = (u32)sample->sampleAddr + sample->size + sample->medium;
- gAudioContext.unk_176C++;
+ case true:
+ preload = &gAudioContext.preloadSampleStack[gAudioContext.preloadSampleStackTop];
+ preload->sample = sample;
+ preload->ramAddr = addr;
+ preload->encodedInfo = (gAudioContext.preloadSampleStackTop << 24) | 0xFFFFFF;
+ preload->isFree = false;
+ preload->endAndMediumKey = (u32)sample->sampleAddr + sample->size + sample->medium;
+ gAudioContext.preloadSampleStackTop++;
break;
}
}
+ gAudioContext.numUsedSamples = 0;
- gAudioContext.unk_1768 = 0;
- if (gAudioContext.unk_176C != 0 && !sp4C) {
- item2 = &gAudioContext.unk_0D68[gAudioContext.unk_176C - 1];
- sample = item2->sample;
+ if (gAudioContext.preloadSampleStackTop != 0 && !preloadInProgress) {
+ topPreload = &gAudioContext.preloadSampleStack[gAudioContext.preloadSampleStackTop - 1];
+ sample = topPreload->sample;
nChunks = (sample->size >> 12) + 1;
- Audio_InitAsyncReq((u32)sample->sampleAddr, item2->ramAddr, sample->size, sample->medium, nChunks,
- &gAudioContext.unk_1E78, item2->encodedInfo);
+ AudioLoad_StartAsyncLoad((u32)sample->sampleAddr, topPreload->ramAddr, sample->size, sample->medium, nChunks,
+ &gAudioContext.preloadSampleQueue, topPreload->encodedInfo);
}
}
-s32 func_800E4590(s32 resetStatus) {
- AudioBankSample* sample;
- AudioStruct0D68* item;
- u32 sp4C;
+s32 AudioLoad_ProcessSamplePreloads(s32 resetStatus) {
+ SoundFontSample* sample;
+ AudioPreloadReq* preload;
+ u32 preloadIndex;
u32 key;
- u32 unk;
+ u32 nChunks;
s32 pad;
- if (gAudioContext.unk_176C > 0) {
+ if (gAudioContext.preloadSampleStackTop > 0) {
if (resetStatus != 0) {
- osRecvMesg(&gAudioContext.unk_1E78, (OSMesg*)&sp4C, OS_MESG_NOBLOCK);
- gAudioContext.unk_176C = 0;
+ // Clear result queue and preload stack and return.
+ osRecvMesg(&gAudioContext.preloadSampleQueue, (OSMesg*)&preloadIndex, OS_MESG_NOBLOCK);
+ gAudioContext.preloadSampleStackTop = 0;
return 0;
}
- if (osRecvMesg(&gAudioContext.unk_1E78, (OSMesg*)&sp4C, OS_MESG_NOBLOCK) == -1) {
+ if (osRecvMesg(&gAudioContext.preloadSampleQueue, (OSMesg*)&preloadIndex, OS_MESG_NOBLOCK) == -1) {
+ // Previous preload is not done yet.
return 0;
}
- sp4C >>= 24;
- item = &gAudioContext.unk_0D68[sp4C];
+ preloadIndex >>= 24;
+ preload = &gAudioContext.preloadSampleStack[preloadIndex];
- if (item->isFree == false) {
- sample = item->sample;
+ if (preload->isFree == false) {
+ sample = preload->sample;
key = (u32)sample->sampleAddr + sample->size + sample->medium;
- if (key == item->endAndMediumKey) {
- sample->sampleAddr = item->ramAddr;
- sample->medium = 0;
+ if (key == preload->endAndMediumKey) {
+ // Change storage for sample to the preloaded version.
+ sample->sampleAddr = preload->ramAddr;
+ sample->medium = MEDIUM_RAM;
}
- item->isFree = true;
+ preload->isFree = true;
}
+ // Pop requests with isFree = true off the stack, as far as possible,
+ // and dispatch the next DMA.
for (;;) {
- if (gAudioContext.unk_176C <= 0) {
+ if (gAudioContext.preloadSampleStackTop <= 0) {
break;
}
- item = &gAudioContext.unk_0D68[gAudioContext.unk_176C - 1];
- if (item->isFree == true) {
- gAudioContext.unk_176C--;
+ preload = &gAudioContext.preloadSampleStack[gAudioContext.preloadSampleStackTop - 1];
+ if (preload->isFree == true) {
+ gAudioContext.preloadSampleStackTop--;
continue;
}
- sample = item->sample;
- unk = (sample->size >> 12) + 1;
+ sample = preload->sample;
+ nChunks = (sample->size >> 12) + 1;
key = (u32)sample->sampleAddr + sample->size + sample->medium;
- if (key != item->endAndMediumKey) {
- item->isFree = true;
- gAudioContext.unk_176C--;
+ if (key != preload->endAndMediumKey) {
+ preload->isFree = true;
+ gAudioContext.preloadSampleStackTop--;
} else {
- Audio_InitAsyncReq((u32)sample->sampleAddr, item->ramAddr, sample->size, sample->medium, unk,
- &gAudioContext.unk_1E78, item->encodedInfo);
+ AudioLoad_StartAsyncLoad((u32)sample->sampleAddr, preload->ramAddr, sample->size, sample->medium,
+ nChunks, &gAudioContext.preloadSampleQueue, preload->encodedInfo);
break;
}
}
@@ -1693,150 +1757,157 @@ s32 func_800E4590(s32 resetStatus) {
return 1;
}
-s32 func_800E4744(AudioBankSample* sample, s32 sampleCnt, AudioBankSample** sampleList) {
+s32 AudioLoad_AddToSampleSet(SoundFontSample* sample, s32 numSamples, SoundFontSample** sampleSet) {
s32 i;
- for (i = 0; i < sampleCnt; i++) {
- if (sample->sampleAddr == sampleList[i]->sampleAddr) {
+ for (i = 0; i < numSamples; i++) {
+ if (sample->sampleAddr == sampleSet[i]->sampleAddr) {
break;
}
}
- if (i == sampleCnt) {
- sampleList[sampleCnt] = sample;
- sampleCnt++;
+ if (i == numSamples) {
+ sampleSet[numSamples] = sample;
+ numSamples++;
}
- return sampleCnt;
+ return numSamples;
}
-s32 func_800E478C(s32 bankId, AudioBankSample** sampleList) {
+s32 AudioLoad_GetSamplesForFont(s32 fontId, SoundFontSample** sampleSet) {
s32 i;
- s32 drumCnt;
- s32 instrumentCnt;
- s32 sampleCnt = 0;
+ s32 numDrums;
+ s32 numInstruments;
+ s32 numSamples = 0;
- drumCnt = gAudioContext.ctlEntries[bankId].numDrums;
- instrumentCnt = gAudioContext.ctlEntries[bankId].numInstruments;
+ numDrums = gAudioContext.soundFonts[fontId].numDrums;
+ numInstruments = gAudioContext.soundFonts[fontId].numInstruments;
- for (i = 0; i < drumCnt; i++) {
- Drum* drum = Audio_GetDrum(bankId, i);
+ for (i = 0; i < numDrums; i++) {
+ Drum* drum = Audio_GetDrum(fontId, i);
if (1) {}
if (drum != NULL) {
- sampleCnt = func_800E4744(drum->sound.sample, sampleCnt, sampleList);
+ numSamples = AudioLoad_AddToSampleSet(drum->sound.sample, numSamples, sampleSet);
}
}
- for (i = 0; i < instrumentCnt; i++) {
- Instrument* instrument = Audio_GetInstrumentInner(bankId, i);
+ for (i = 0; i < numInstruments; i++) {
+ Instrument* instrument = Audio_GetInstrumentInner(fontId, i);
if (instrument != NULL) {
if (instrument->normalRangeLo != 0) {
- sampleCnt = func_800E4744(instrument->lowNotesSound.sample, sampleCnt, sampleList);
+ numSamples = AudioLoad_AddToSampleSet(instrument->lowNotesSound.sample, numSamples, sampleSet);
}
if (instrument->normalRangeHi != 0x7F) {
- sampleCnt = func_800E4744(instrument->highNotesSound.sample, sampleCnt, sampleList);
+ numSamples = AudioLoad_AddToSampleSet(instrument->highNotesSound.sample, numSamples, sampleSet);
}
- sampleCnt = func_800E4744(instrument->normalNotesSound.sample, sampleCnt, sampleList);
+ numSamples = AudioLoad_AddToSampleSet(instrument->normalNotesSound.sample, numSamples, sampleSet);
}
}
- return sampleCnt;
+
+ // Should really also process sfx, but this method is never called, so whatever.
+ return numSamples;
}
-void func_800E48C0(AudioBankSound* sound) {
- AudioBankSample* sample = sound->sample;
+void AudioLoad_AddUsedSample(SoundFontSound* sound) {
+ SoundFontSample* sample = sound->sample;
- if ((sample->size != 0) && (sample->unk_bits26) && (sample->medium)) {
- gAudioContext.unk_0B68[gAudioContext.unk_1768++] = sample;
+ if ((sample->size != 0) && (sample->unk_bit26) && (sample->medium != MEDIUM_RAM)) {
+ gAudioContext.usedSamples[gAudioContext.numUsedSamples++] = sample;
}
}
-void func_800E4918(s32 bankId, s32 arg1, RelocInfo* relocInfo) {
+void AudioLoad_PreloadSamplesForFont(s32 fontId, s32 async, RelocInfo* relocInfo) {
s32 numDrums;
s32 numInstruments;
s32 numSfx;
Drum* drum;
Instrument* instrument;
- AudioBankSound* sound;
- AudioStruct0D68* item;
- AudioStruct0D68* item2;
+ SoundFontSound* sound;
+ AudioPreloadReq* preload;
+ AudioPreloadReq* topPreload;
u8* addr;
- s32 count;
+ s32 size;
s32 i;
- AudioBankSample* sample;
- s32 sp44;
+ SoundFontSample* sample;
+ s32 preloadInProgress;
s32 nChunks;
- sp44 = false;
- if (gAudioContext.unk_176C != 0) {
- sp44 = true;
+ preloadInProgress = false;
+ if (gAudioContext.preloadSampleStackTop != 0) {
+ preloadInProgress = true;
}
- gAudioContext.unk_1768 = 0;
- numDrums = gAudioContext.ctlEntries[bankId].numDrums;
- numInstruments = gAudioContext.ctlEntries[bankId].numInstruments;
- numSfx = gAudioContext.ctlEntries[bankId].numSfx;
+ gAudioContext.numUsedSamples = 0;
+
+ numDrums = gAudioContext.soundFonts[fontId].numDrums;
+ numInstruments = gAudioContext.soundFonts[fontId].numInstruments;
+ numSfx = gAudioContext.soundFonts[fontId].numSfx;
for (i = 0; i < numInstruments; i++) {
- instrument = Audio_GetInstrumentInner(bankId, i);
+ instrument = Audio_GetInstrumentInner(fontId, i);
if (instrument != NULL) {
if (instrument->normalRangeLo != 0) {
- func_800E48C0(&instrument->lowNotesSound);
+ AudioLoad_AddUsedSample(&instrument->lowNotesSound);
}
if (instrument->normalRangeHi != 0x7F) {
- func_800E48C0(&instrument->highNotesSound);
+ AudioLoad_AddUsedSample(&instrument->highNotesSound);
}
- func_800E48C0(&instrument->normalNotesSound);
+ AudioLoad_AddUsedSample(&instrument->normalNotesSound);
}
}
for (i = 0; i < numDrums; i++) {
- drum = Audio_GetDrum(bankId, i);
+ drum = Audio_GetDrum(fontId, i);
if (drum != NULL) {
- func_800E48C0(&drum->sound);
+ AudioLoad_AddUsedSample(&drum->sound);
}
}
for (i = 0; i < numSfx; i++) {
- sound = Audio_GetSfx(bankId, i);
+ sound = Audio_GetSfx(fontId, i);
if (sound != NULL) {
- func_800E48C0(sound);
+ AudioLoad_AddUsedSample(sound);
}
}
- if (gAudioContext.unk_1768 == 0) {
+ if (gAudioContext.numUsedSamples == 0) {
return;
}
- count = 0;
- for (i = 0; i < gAudioContext.unk_1768; i++) {
- count += ALIGN16(gAudioContext.unk_0B68[i]->size);
+ size = 0;
+ for (i = 0; i < gAudioContext.numUsedSamples; i++) {
+ size += ALIGN16(gAudioContext.usedSamples[i]->size);
}
- if (count) {}
+ if (size) {}
- for (i = 0; i < gAudioContext.unk_1768; i++) {
- if (gAudioContext.unk_176C == 120) {
+ for (i = 0; i < gAudioContext.numUsedSamples; i++) {
+ if (gAudioContext.preloadSampleStackTop == 120) {
break;
}
- sample = gAudioContext.unk_0B68[i];
- if (sample->medium == 0) {
+ sample = gAudioContext.usedSamples[i];
+ if (sample->medium == MEDIUM_RAM) {
continue;
}
- switch (arg1) {
- case 0:
+ switch (async) {
+ case false:
if (sample->medium == relocInfo->medium1) {
- addr = func_800E05C4(sample->size, relocInfo->index1, sample->sampleAddr, sample->medium, 1);
+ addr = AudioHeap_AllocSampleCache(sample->size, relocInfo->sampleBankId1, sample->sampleAddr,
+ sample->medium, CACHE_PERSISTENT);
} else if (sample->medium == relocInfo->medium2) {
- addr = func_800E05C4(sample->size, relocInfo->index2, sample->sampleAddr, sample->medium, 1);
+ addr = AudioHeap_AllocSampleCache(sample->size, relocInfo->sampleBankId2, sample->sampleAddr,
+ sample->medium, CACHE_PERSISTENT);
}
break;
- case 1:
+ case true:
if (sample->medium == relocInfo->medium1) {
- addr = func_800E05C4(sample->size, relocInfo->index1, sample->sampleAddr, sample->medium, 0);
+ addr = AudioHeap_AllocSampleCache(sample->size, relocInfo->sampleBankId1, sample->sampleAddr,
+ sample->medium, CACHE_TEMPORARY);
} else if (sample->medium == relocInfo->medium2) {
- addr = func_800E05C4(sample->size, relocInfo->index2, sample->sampleAddr, sample->medium, 0);
+ addr = AudioHeap_AllocSampleCache(sample->size, relocInfo->sampleBankId2, sample->sampleAddr,
+ sample->medium, CACHE_TEMPORARY);
}
break;
}
@@ -1844,104 +1915,105 @@ void func_800E4918(s32 bankId, s32 arg1, RelocInfo* relocInfo) {
continue;
}
- switch (arg1) {
- case 0:
- if (sample->medium == 1) {
- Audio_NoopCopy((u32)sample->sampleAddr, addr, sample->size,
- gAudioContext.audioTable->header.unk_02);
+ switch (async) {
+ case false:
+ if (sample->medium == MEDIUM_UNK) {
+ AudioLoad_SyncDmaUnkMedium((u32)sample->sampleAddr, addr, sample->size,
+ gAudioContext.sampleBankTable->unkMediumParam);
sample->sampleAddr = addr;
- sample->medium = 0;
+ sample->medium = MEDIUM_RAM;
} else {
- Audio_DMAFastCopy((u32)sample->sampleAddr, addr, sample->size, sample->medium);
+ AudioLoad_SyncDma((u32)sample->sampleAddr, addr, sample->size, sample->medium);
sample->sampleAddr = addr;
- sample->medium = 0;
+ sample->medium = MEDIUM_RAM;
}
break;
- case 1:
- item = &gAudioContext.unk_0D68[gAudioContext.unk_176C];
- item->sample = sample;
- item->ramAddr = addr;
- item->encodedInfo = (gAudioContext.unk_176C << 24) | 0xFFFFFF;
- item->isFree = false;
- item->endAndMediumKey = (u32)sample->sampleAddr + sample->size + sample->medium;
- gAudioContext.unk_176C++;
+ case true:
+ preload = &gAudioContext.preloadSampleStack[gAudioContext.preloadSampleStackTop];
+ preload->sample = sample;
+ preload->ramAddr = addr;
+ preload->encodedInfo = (gAudioContext.preloadSampleStackTop << 24) | 0xFFFFFF;
+ preload->isFree = false;
+ preload->endAndMediumKey = (u32)sample->sampleAddr + sample->size + sample->medium;
+ gAudioContext.preloadSampleStackTop++;
break;
}
}
+ gAudioContext.numUsedSamples = 0;
- gAudioContext.unk_1768 = 0;
- if (gAudioContext.unk_176C != 0 && !sp44) {
- item2 = &gAudioContext.unk_0D68[gAudioContext.unk_176C - 1];
- sample = item2->sample;
+ if (gAudioContext.preloadSampleStackTop != 0 && !preloadInProgress) {
+ topPreload = &gAudioContext.preloadSampleStack[gAudioContext.preloadSampleStackTop - 1];
+ sample = topPreload->sample;
nChunks = (sample->size >> 12) + 1;
- Audio_InitAsyncReq((u32)sample->sampleAddr, item2->ramAddr, sample->size, sample->medium, nChunks,
- &gAudioContext.unk_1E78, item2->encodedInfo);
+ AudioLoad_StartAsyncLoad((u32)sample->sampleAddr, topPreload->ramAddr, sample->size, sample->medium, nChunks,
+ &gAudioContext.preloadSampleQueue, topPreload->encodedInfo);
}
}
-void func_800E4D94(void) {
+void AudioLoad_LoadPermanentSamples(void) {
s32 pad;
- u32 temp_s2;
- AudioTable* audioTable;
+ u32 fontId;
+ AudioTable* sampleBankTable;
s32 pad2;
s32 i;
- audioTable = Audio_GetLoadTable(AUDIO_TABLE);
- for (i = 0; i < gAudioContext.unk_2D50.unused; i++) {
- RelocInfo sp4C;
- if (gAudioContext.unk_2D60[i].poolIndex == 1) {
- temp_s2 = Audio_GetTableIndex(BANK_TABLE, gAudioContext.unk_2D60[i].id);
- sp4C.index1 = gAudioContext.ctlEntries[temp_s2].unk_02;
- sp4C.index2 = gAudioContext.ctlEntries[temp_s2].unk_03;
-
- if (sp4C.index1 != 0xFF) {
- sp4C.index1 = Audio_GetTableIndex(AUDIO_TABLE, sp4C.index1);
- sp4C.medium1 = audioTable->entries[sp4C.index1].unk_08;
+ sampleBankTable = AudioLoad_GetLoadTable(SAMPLE_TABLE);
+ for (i = 0; i < gAudioContext.permanentPool.count; i++) {
+ RelocInfo relocInfo;
+
+ if (gAudioContext.permanentCache[i].tableType == FONT_TABLE) {
+ fontId = AudioLoad_GetRealTableIndex(FONT_TABLE, gAudioContext.permanentCache[i].id);
+ relocInfo.sampleBankId1 = gAudioContext.soundFonts[fontId].sampleBankId1;
+ relocInfo.sampleBankId2 = gAudioContext.soundFonts[fontId].sampleBankId2;
+
+ if (relocInfo.sampleBankId1 != 0xFF) {
+ relocInfo.sampleBankId1 = AudioLoad_GetRealTableIndex(SAMPLE_TABLE, relocInfo.sampleBankId1);
+ relocInfo.medium1 = sampleBankTable->entries[relocInfo.sampleBankId1].medium;
}
- if (sp4C.index2 != 0xFF) {
- sp4C.index2 = Audio_GetTableIndex(AUDIO_TABLE, sp4C.index2);
- sp4C.medium2 = audioTable->entries[sp4C.index2].unk_08;
+ if (relocInfo.sampleBankId2 != 0xFF) {
+ relocInfo.sampleBankId2 = AudioLoad_GetRealTableIndex(SAMPLE_TABLE, relocInfo.sampleBankId2);
+ relocInfo.medium2 = sampleBankTable->entries[relocInfo.sampleBankId2].medium;
}
- func_800E4918(temp_s2, 0, &sp4C);
+ AudioLoad_PreloadSamplesForFont(fontId, false, &relocInfo);
}
}
}
-void func_800E4ED4(void) {
+void AudioLoad_Unused3(void) {
}
-void func_800E4EDC(void) {
+void AudioLoad_Unused4(void) {
}
-void func_800E4EE4(void) {
+void AudioLoad_Unused5(void) {
}
-void func_800E4EEC(s32 tableType, s32 arg1, s8* arg2) {
- static u32 D_801304DC = 0;
- D_8016B738[D_801304DC] = arg2;
- Audio_AsyncLoad(tableType, arg1, 0, D_801304DC, &D_8016B6E0);
- D_801304DC++;
- if (D_801304DC == 0x10) {
- D_801304DC = 0;
+void AudioLoad_ScriptLoad(s32 tableType, s32 id, s8* isDone) {
+ static u32 sLoadIndex = 0;
+ sScriptLoadDonePointers[sLoadIndex] = isDone;
+ AudioLoad_AsyncLoad(tableType, id, 0, sLoadIndex, &sScriptLoadQueue);
+ sLoadIndex++;
+ if (sLoadIndex == 0x10) {
+ sLoadIndex = 0;
}
}
-void func_800E4F58(void) {
- u32 pad;
+void AudioLoad_ProcessScriptLoads(void) {
+ u32 temp;
u32 sp20;
- s8* temp_v0;
+ s8* isDone;
- if (osRecvMesg(&D_8016B6E0, (OSMesg*)&sp20, OS_MESG_NOBLOCK) != -1) {
- pad = sp20 >> 24;
- temp_v0 = D_8016B738[pad];
- if (temp_v0 != NULL) {
- *temp_v0 = 0;
+ if (osRecvMesg(&sScriptLoadQueue, (OSMesg*)&sp20, OS_MESG_NOBLOCK) != -1) {
+ temp = sp20 >> 24;
+ isDone = sScriptLoadDonePointers[temp];
+ if (isDone != NULL) {
+ *isDone = 0;
}
}
}
-void func_800E4FB0(void) {
- osCreateMesgQueue(&D_8016B6E0, D_8016B6F8, 0x10);
+void AudioLoad_InitScriptLoads(void) {
+ osCreateMesgQueue(&sScriptLoadQueue, sScriptLoadMesgBuf, ARRAY_COUNT(sScriptLoadMesgBuf));
}
diff --git a/src/code/audio_playback.c b/src/code/audio_playback.c
index 573c0d810..4edc18db3 100644
--- a/src/code/audio_playback.c
+++ b/src/code/audio_playback.c
@@ -17,8 +17,8 @@ void Audio_InitNoteSub(Note* note, NoteSubEu* sub, NoteSubAttributes* attrs) {
reverbVol = attrs->reverbVol;
sp24 = attrs->stereo.s;
- sub->bitField0.s = note->noteSubEu.bitField0.s;
- sub->bitField1.s = note->noteSubEu.bitField1.s;
+ sub->bitField0 = note->noteSubEu.bitField0;
+ sub->bitField1 = note->noteSubEu.bitField1;
sub->sound.samples = note->noteSubEu.sound.samples;
sub->unk_06 = note->noteSubEu.unk_06;
@@ -26,10 +26,10 @@ void Audio_InitNoteSub(Note* note, NoteSubEu* sub, NoteSubAttributes* attrs) {
pan &= 0x7F;
- sub->bitField0.s.stereoStrongRight = false;
- sub->bitField0.s.stereoStrongLeft = false;
- sub->bitField0.s.stereoHeadsetEffects = sp24.stereoHeadsetEffects;
- sub->bitField0.s.usesHeadsetPanEffects = sp24.usesHeadsetPanEffects;
+ sub->bitField0.stereoStrongRight = false;
+ sub->bitField0.stereoStrongLeft = false;
+ sub->bitField0.stereoHeadsetEffects = sp24.stereoHeadsetEffects;
+ sub->bitField0.usesHeadsetPanEffects = sp24.usesHeadsetPanEffects;
if (stereoHeadsetEffects && gAudioContext.soundMode == 1) {
smallPanIndex = pan >> 1;
if (smallPanIndex > 0x3F) {
@@ -38,7 +38,7 @@ void Audio_InitNoteSub(Note* note, NoteSubEu* sub, NoteSubAttributes* attrs) {
sub->headsetPanLeft = gHeadsetPanQuantization[smallPanIndex];
sub->headsetPanRight = gHeadsetPanQuantization[0x3F - smallPanIndex];
- sub->bitField1.s.usesHeadsetPanEffects2 = true;
+ sub->bitField1.usesHeadsetPanEffects2 = true;
volLeft = gHeadsetPanVolume[pan];
volRight = gHeadsetPanVolume[0x7F - pan];
@@ -46,7 +46,7 @@ void Audio_InitNoteSub(Note* note, NoteSubEu* sub, NoteSubAttributes* attrs) {
strongLeft = strongRight = 0;
sub->headsetPanRight = 0;
sub->headsetPanLeft = 0;
- sub->bitField1.s.usesHeadsetPanEffects2 = false;
+ sub->bitField1.usesHeadsetPanEffects2 = false;
volLeft = gStereoPanVolume[pan];
volRight = gStereoPanVolume[0x7F - pan];
@@ -56,34 +56,34 @@ void Audio_InitNoteSub(Note* note, NoteSubEu* sub, NoteSubAttributes* attrs) {
strongRight = 1;
}
- sub->bitField0.s.stereoStrongRight = strongRight;
- sub->bitField0.s.stereoStrongLeft = strongLeft;
+ sub->bitField0.stereoStrongRight = strongRight;
+ sub->bitField0.stereoStrongLeft = strongLeft;
switch (sp24.bit2) {
case 0:
break;
case 1:
- sub->bitField0.s.stereoStrongRight = sp24.strongRight;
- sub->bitField0.s.stereoStrongLeft = sp24.strongLeft;
+ sub->bitField0.stereoStrongRight = sp24.strongRight;
+ sub->bitField0.stereoStrongLeft = sp24.strongLeft;
break;
case 2:
- sub->bitField0.s.stereoStrongRight = sp24.strongRight | strongRight;
- sub->bitField0.s.stereoStrongLeft = sp24.strongLeft | strongLeft;
+ sub->bitField0.stereoStrongRight = sp24.strongRight | strongRight;
+ sub->bitField0.stereoStrongLeft = sp24.strongLeft | strongLeft;
break;
case 3:
- sub->bitField0.s.stereoStrongRight = sp24.strongRight ^ strongRight;
- sub->bitField0.s.stereoStrongLeft = sp24.strongLeft ^ strongLeft;
+ sub->bitField0.stereoStrongRight = sp24.strongRight ^ strongRight;
+ sub->bitField0.stereoStrongLeft = sp24.strongLeft ^ strongLeft;
break;
}
} else if (gAudioContext.soundMode == 3) {
- sub->bitField0.s.stereoHeadsetEffects = false;
- sub->bitField0.s.usesHeadsetPanEffects = false;
+ sub->bitField0.stereoHeadsetEffects = false;
+ sub->bitField0.usesHeadsetPanEffects = false;
volLeft = 0.707f; // approx 1/sqrt(2)
volRight = 0.707f;
} else {
- sub->bitField0.s.stereoStrongRight = sp24.strongRight;
- sub->bitField0.s.stereoStrongLeft = sp24.strongLeft;
+ sub->bitField0.stereoStrongRight = sp24.strongRight;
+ sub->bitField0.stereoStrongLeft = sp24.strongLeft;
volLeft = gDefaultPanVolume[pan];
volRight = gDefaultPanVolume[0x7F - pan];
}
@@ -105,7 +105,7 @@ void Audio_NoteSetResamplingRate(NoteSubEu* noteSubEu, f32 resamplingRateInput)
f32 resamplingRate = 0.0f;
if (resamplingRateInput < 2.0f) {
- noteSubEu->bitField1.s.hasTwoAdpcmParts = false;
+ noteSubEu->bitField1.hasTwoParts = false;
if (1.99998f < resamplingRateInput) {
resamplingRate = 1.99998f;
@@ -114,7 +114,7 @@ void Audio_NoteSetResamplingRate(NoteSubEu* noteSubEu, f32 resamplingRateInput)
}
} else {
- noteSubEu->bitField1.s.hasTwoAdpcmParts = true;
+ noteSubEu->bitField1.hasTwoParts = true;
if (3.99996f < resamplingRateInput) {
resamplingRate = 1.99998f;
} else {
@@ -126,11 +126,11 @@ void Audio_NoteSetResamplingRate(NoteSubEu* noteSubEu, f32 resamplingRateInput)
void Audio_NoteInit(Note* note) {
if (note->playbackState.parentLayer->adsr.releaseRate == 0) {
- Audio_AdsrInit(&note->playbackState.adsr, note->playbackState.parentLayer->seqChannel->adsr.envelope,
- &note->playbackState.adsrVolScale);
+ Audio_AdsrInit(&note->playbackState.adsr, note->playbackState.parentLayer->channel->adsr.envelope,
+ &note->playbackState.adsrVolScaleUnused);
} else {
Audio_AdsrInit(&note->playbackState.adsr, note->playbackState.parentLayer->adsr.envelope,
- &note->playbackState.adsrVolScale);
+ &note->playbackState.adsrVolScaleUnused);
}
note->playbackState.unk_04 = 0;
@@ -139,13 +139,13 @@ void Audio_NoteInit(Note* note) {
}
void Audio_NoteDisable(Note* note) {
- if (note->noteSubEu.bitField0.s.needsInit == true) {
- note->noteSubEu.bitField0.s.needsInit = false;
+ if (note->noteSubEu.bitField0.needsInit == true) {
+ note->noteSubEu.bitField0.needsInit = false;
}
note->playbackState.priority = 0;
- note->noteSubEu.bitField0.s.enabled = false;
+ note->noteSubEu.bitField0.enabled = false;
note->playbackState.unk_04 = 0;
- note->noteSubEu.bitField0.s.finished = false;
+ note->noteSubEu.bitField0.finished = false;
note->playbackState.parentLayer = NO_LAYER;
note->playbackState.prevParentLayer = NO_LAYER;
note->playbackState.adsr.action.s.state = ADSR_STATE_DISABLED;
@@ -164,7 +164,7 @@ void Audio_ProcessNotes(void) {
f32 scale;
s32 i;
- for (i = 0; i < gAudioContext.maxSimultaneousNotes; i++) {
+ for (i = 0; i < gAudioContext.numNotes; i++) {
note = &gAudioContext.notes[i];
noteSubEu2 = &gAudioContext.noteSubsEu[gAudioContext.noteSubEuOffset + i];
playbackState = &note->playbackState;
@@ -182,19 +182,19 @@ void Audio_ProcessNotes(void) {
} else if (!playbackState->parentLayer->enabled && playbackState->unk_04 == 0 &&
playbackState->priority >= 1) {
// do nothing
- } else if (playbackState->parentLayer->seqChannel->seqPlayer == NULL) {
- Audio_SequenceChannelDisable(playbackState->parentLayer->seqChannel);
+ } else if (playbackState->parentLayer->channel->seqPlayer == NULL) {
+ AudioSeq_SequenceChannelDisable(playbackState->parentLayer->channel);
playbackState->priority = 1;
playbackState->unk_04 = 1;
continue;
- } else if (playbackState->parentLayer->seqChannel->seqPlayer->muted &&
- (playbackState->parentLayer->seqChannel->muteBehavior & 0x40)) {
+ } else if (playbackState->parentLayer->channel->seqPlayer->muted &&
+ (playbackState->parentLayer->channel->muteBehavior & 0x40)) {
// do nothing
} else {
goto out;
}
- Audio_SeqChanLayerNoteRelease(playbackState->parentLayer);
+ Audio_SeqLayerNoteRelease(playbackState->parentLayer);
Audio_AudioListRemove(&note->listItem);
Audio_AudioListPushFront(&note->listItem.pool->decaying, &note->listItem);
playbackState->priority = 1;
@@ -207,22 +207,22 @@ void Audio_ProcessNotes(void) {
if (playbackState->priority != 0) {
if (1) {}
noteSubEu = &note->noteSubEu;
- if (playbackState->unk_04 >= 1 || noteSubEu->bitField0.s.finished) {
- if (playbackState->adsr.action.s.state == ADSR_STATE_DISABLED || noteSubEu->bitField0.s.finished) {
+ if (playbackState->unk_04 >= 1 || noteSubEu->bitField0.finished) {
+ if (playbackState->adsr.action.s.state == ADSR_STATE_DISABLED || noteSubEu->bitField0.finished) {
if (playbackState->wantedParentLayer != NO_LAYER) {
Audio_NoteDisable(note);
- if (playbackState->wantedParentLayer->seqChannel != NULL) {
+ if (playbackState->wantedParentLayer->channel != NULL) {
Audio_NoteInitForLayer(note, playbackState->wantedParentLayer);
Audio_NoteVibratoInit(note);
Audio_NotePortamentoInit(note);
Audio_AudioListRemove(&note->listItem);
- Audio_AudioListPushBack(&note->listItem.pool->active, &note->listItem);
+ AudioSeq_AudioListPushBack(&note->listItem.pool->active, &note->listItem);
playbackState->wantedParentLayer = NO_LAYER;
// don't skip
} else {
Audio_NoteDisable(note);
Audio_AudioListRemove(&note->listItem);
- Audio_AudioListPushBack(&note->listItem.pool->disabled, &note->listItem);
+ AudioSeq_AudioListPushBack(&note->listItem.pool->disabled, &note->listItem);
playbackState->wantedParentLayer = NO_LAYER;
goto skip;
}
@@ -232,7 +232,7 @@ void Audio_ProcessNotes(void) {
}
Audio_NoteDisable(note);
Audio_AudioListRemove(&note->listItem);
- Audio_AudioListPushBack(&note->listItem.pool->disabled, &note->listItem);
+ AudioSeq_AudioListPushBack(&note->listItem.pool->disabled, &note->listItem);
continue;
}
}
@@ -242,7 +242,7 @@ void Audio_ProcessNotes(void) {
}
Audio_NoteDisable(note);
Audio_AudioListRemove(&note->listItem);
- Audio_AudioListPushBack(&note->listItem.pool->disabled, &note->listItem);
+ AudioSeq_AudioListPushBack(&note->listItem.pool->disabled, &note->listItem);
continue;
}
@@ -259,10 +259,10 @@ void Audio_ProcessNotes(void) {
subAttrs.filter = attrs->filter;
subAttrs.unk_14 = attrs->unk_4;
subAttrs.unk_16 = attrs->unk_6;
- bookOffset = noteSubEu->bitField1.s.bookOffset;
+ bookOffset = noteSubEu->bitField1.bookOffset;
} else {
- SequenceChannelLayer* layer = playbackState->parentLayer;
- SequenceChannel* channel = layer->seqChannel;
+ SequenceLayer* layer = playbackState->parentLayer;
+ SequenceChannel* channel = layer->channel;
subAttrs.frequency = layer->noteFreqScale;
subAttrs.velocity = layer->noteVelocity;
@@ -289,14 +289,14 @@ void Audio_ProcessNotes(void) {
subAttrs.frequency *= gAudioContext.audioBufferParameters.resampleRate;
subAttrs.velocity *= scale;
Audio_InitNoteSub(note, noteSubEu2, &subAttrs);
- noteSubEu->bitField1.s.bookOffset = bookOffset;
+ noteSubEu->bitField1.bookOffset = bookOffset;
skip:;
}
}
}
-AudioBankSound* Audio_InstrumentGetAudioBankSound(Instrument* instrument, s32 semitone) {
- AudioBankSound* sound;
+SoundFontSound* Audio_InstrumentGetSound(Instrument* instrument, s32 semitone) {
+ SoundFontSound* sound;
if (semitone < instrument->normalRangeLo) {
sound = &instrument->lowNotesSound;
} else if (semitone <= instrument->normalRangeHi) {
@@ -307,85 +307,85 @@ AudioBankSound* Audio_InstrumentGetAudioBankSound(Instrument* instrument, s32 se
return sound;
}
-Instrument* Audio_GetInstrumentInner(s32 bankId, s32 instId) {
+Instrument* Audio_GetInstrumentInner(s32 fontId, s32 instId) {
Instrument* inst;
- if (bankId == 0xFF) {
+ if (fontId == 0xFF) {
return NULL;
}
- if (!Audio_IsBankLoadComplete(bankId)) {
- gAudioContext.audioErrorFlags = bankId + 0x10000000;
+ if (!AudioLoad_IsFontLoadComplete(fontId)) {
+ gAudioContext.audioErrorFlags = fontId + 0x10000000;
return NULL;
}
- if (instId >= gAudioContext.ctlEntries[bankId].numInstruments) {
- gAudioContext.audioErrorFlags = ((bankId << 8) + instId) + 0x3000000;
+ if (instId >= gAudioContext.soundFonts[fontId].numInstruments) {
+ gAudioContext.audioErrorFlags = ((fontId << 8) + instId) + 0x3000000;
return NULL;
}
- inst = gAudioContext.ctlEntries[bankId].instruments[instId];
+ inst = gAudioContext.soundFonts[fontId].instruments[instId];
if (inst == NULL) {
- gAudioContext.audioErrorFlags = ((bankId << 8) + instId) + 0x1000000;
+ gAudioContext.audioErrorFlags = ((fontId << 8) + instId) + 0x1000000;
return inst;
}
return inst;
}
-Drum* Audio_GetDrum(s32 bankId, s32 drumId) {
+Drum* Audio_GetDrum(s32 fontId, s32 drumId) {
Drum* drum;
- if (bankId == 0xFF) {
+ if (fontId == 0xFF) {
return NULL;
}
- if (!Audio_IsBankLoadComplete(bankId)) {
- gAudioContext.audioErrorFlags = bankId + 0x10000000;
+ if (!AudioLoad_IsFontLoadComplete(fontId)) {
+ gAudioContext.audioErrorFlags = fontId + 0x10000000;
return NULL;
}
- if (drumId >= gAudioContext.ctlEntries[bankId].numDrums) {
- gAudioContext.audioErrorFlags = ((bankId << 8) + drumId) + 0x4000000;
+ if (drumId >= gAudioContext.soundFonts[fontId].numDrums) {
+ gAudioContext.audioErrorFlags = ((fontId << 8) + drumId) + 0x4000000;
return NULL;
}
- if ((u32)gAudioContext.ctlEntries[bankId].drums < 0x80000000) {
+ if ((u32)gAudioContext.soundFonts[fontId].drums < 0x80000000) {
return NULL;
}
- drum = gAudioContext.ctlEntries[bankId].drums[drumId];
+ drum = gAudioContext.soundFonts[fontId].drums[drumId];
if (drum == NULL) {
- gAudioContext.audioErrorFlags = ((bankId << 8) + drumId) + 0x5000000;
+ gAudioContext.audioErrorFlags = ((fontId << 8) + drumId) + 0x5000000;
}
return drum;
}
-AudioBankSound* Audio_GetSfx(s32 bankId, s32 sfxId) {
- AudioBankSound* sfx;
+SoundFontSound* Audio_GetSfx(s32 fontId, s32 sfxId) {
+ SoundFontSound* sfx;
- if (bankId == 0xFF) {
+ if (fontId == 0xFF) {
return NULL;
}
- if (!Audio_IsBankLoadComplete(bankId)) {
- gAudioContext.audioErrorFlags = bankId + 0x10000000;
+ if (!AudioLoad_IsFontLoadComplete(fontId)) {
+ gAudioContext.audioErrorFlags = fontId + 0x10000000;
return NULL;
}
- if (sfxId >= gAudioContext.ctlEntries[bankId].numSfx) {
- gAudioContext.audioErrorFlags = ((bankId << 8) + sfxId) + 0x4000000;
+ if (sfxId >= gAudioContext.soundFonts[fontId].numSfx) {
+ gAudioContext.audioErrorFlags = ((fontId << 8) + sfxId) + 0x4000000;
return NULL;
}
- if ((u32)gAudioContext.ctlEntries[bankId].soundEffects < 0x80000000) {
+ if ((u32)gAudioContext.soundFonts[fontId].soundEffects < 0x80000000) {
return NULL;
}
- sfx = &gAudioContext.ctlEntries[bankId].soundEffects[sfxId];
+ sfx = &gAudioContext.soundFonts[fontId].soundEffects[sfxId];
if (sfx == NULL) {
- gAudioContext.audioErrorFlags = ((bankId << 8) + sfxId) + 0x5000000;
+ gAudioContext.audioErrorFlags = ((fontId << 8) + sfxId) + 0x5000000;
}
if (sfx->sample == NULL) {
@@ -395,67 +395,67 @@ AudioBankSound* Audio_GetSfx(s32 bankId, s32 sfxId) {
return sfx;
}
-s32 func_800E7744(s32 instrument, s32 bankId, s32 instId, void* arg3) {
- if (bankId == 0xFF) {
+s32 Audio_SetFontInstrument(s32 instrumentType, s32 fontId, s32 index, void* value) {
+ if (fontId == 0xFF) {
return -1;
}
- if (!Audio_IsBankLoadComplete(bankId)) {
+ if (!AudioLoad_IsFontLoadComplete(fontId)) {
return -2;
}
- switch (instrument) {
+ switch (instrumentType) {
case 0:
- if (instId >= gAudioContext.ctlEntries[bankId].numDrums) {
+ if (index >= gAudioContext.soundFonts[fontId].numDrums) {
return -3;
}
- gAudioContext.ctlEntries[bankId].drums[instId] = arg3;
+ gAudioContext.soundFonts[fontId].drums[index] = value;
break;
case 1:
- if (instId >= gAudioContext.ctlEntries[bankId].numSfx) {
+ if (index >= gAudioContext.soundFonts[fontId].numSfx) {
return -3;
}
- gAudioContext.ctlEntries[bankId].soundEffects[instId] = *(AudioBankSound*)arg3;
+ gAudioContext.soundFonts[fontId].soundEffects[index] = *(SoundFontSound*)value;
break;
default:
- if (instId >= gAudioContext.ctlEntries[bankId].numInstruments) {
+ if (index >= gAudioContext.soundFonts[fontId].numInstruments) {
return -3;
}
- gAudioContext.ctlEntries[bankId].instruments[instId] = arg3;
+ gAudioContext.soundFonts[fontId].instruments[index] = value;
break;
}
return 0;
}
-void Audio_SeqChanLayerDecayRelease(SequenceChannelLayer* seqLayer, s32 target) {
+void Audio_SeqLayerDecayRelease(SequenceLayer* layer, s32 target) {
Note* note;
NoteAttributes* attrs;
SequenceChannel* chan;
s32 i;
- if (seqLayer == NO_LAYER) {
+ if (layer == NO_LAYER) {
return;
}
- seqLayer->bit3 = false;
+ layer->bit3 = false;
- if (seqLayer->note == NULL) {
+ if (layer->note == NULL) {
return;
}
- note = seqLayer->note;
+ note = layer->note;
attrs = &note->playbackState.attributes;
- if (note->playbackState.wantedParentLayer == seqLayer) {
+ if (note->playbackState.wantedParentLayer == layer) {
note->playbackState.wantedParentLayer = NO_LAYER;
}
- if (note->playbackState.parentLayer != seqLayer) {
+ if (note->playbackState.parentLayer != layer) {
if (note->playbackState.parentLayer == NO_LAYER && note->playbackState.wantedParentLayer == NO_LAYER &&
- note->playbackState.prevParentLayer == seqLayer && target != ADSR_STATE_DECAY) {
+ note->playbackState.prevParentLayer == layer && target != ADSR_STATE_DECAY) {
note->playbackState.adsr.fadeOutVel = gAudioContext.audioBufferParameters.updatesPerFrameInv;
note->playbackState.adsr.action.s.release = true;
}
@@ -463,12 +463,12 @@ void Audio_SeqChanLayerDecayRelease(SequenceChannelLayer* seqLayer, s32 target)
}
if (note->playbackState.adsr.action.s.state != ADSR_STATE_DECAY) {
- attrs->freqScale = seqLayer->noteFreqScale;
- attrs->velocity = seqLayer->noteVelocity;
- attrs->pan = seqLayer->notePan;
+ attrs->freqScale = layer->noteFreqScale;
+ attrs->velocity = layer->noteVelocity;
+ attrs->pan = layer->notePan;
- if (seqLayer->seqChannel != NULL) {
- chan = seqLayer->seqChannel;
+ if (layer->channel != NULL) {
+ chan = layer->channel;
attrs->reverb = chan->reverb;
attrs->unk_1 = chan->unk_0C;
attrs->filter = chan->filter;
@@ -483,17 +483,17 @@ void Audio_SeqChanLayerDecayRelease(SequenceChannelLayer* seqLayer, s32 target)
attrs->unk_6 = chan->unk_20;
attrs->unk_4 = chan->unk_0F;
if (chan->seqPlayer->muted && (chan->muteBehavior & 8)) {
- note->noteSubEu.bitField0.s.finished = true;
+ note->noteSubEu.bitField0.finished = true;
}
- if (seqLayer->stereo.asByte == 0) {
+ if (layer->stereo.asByte == 0) {
attrs->stereo = chan->stereo;
} else {
- attrs->stereo = seqLayer->stereo;
+ attrs->stereo = layer->stereo;
}
note->playbackState.priority = chan->someOtherPriority;
} else {
- attrs->stereo = seqLayer->stereo;
+ attrs->stereo = layer->stereo;
note->playbackState.priority = 1;
}
@@ -506,13 +506,13 @@ void Audio_SeqChanLayerDecayRelease(SequenceChannelLayer* seqLayer, s32 target)
} else {
note->playbackState.unk_04 = 1;
note->playbackState.adsr.action.s.decay = true;
- if (seqLayer->adsr.releaseRate == 0) {
- note->playbackState.adsr.fadeOutVel = gAudioContext.unk_3520[seqLayer->seqChannel->adsr.releaseRate];
+ if (layer->adsr.releaseRate == 0) {
+ note->playbackState.adsr.fadeOutVel = gAudioContext.unk_3520[layer->channel->adsr.releaseRate];
} else {
- note->playbackState.adsr.fadeOutVel = gAudioContext.unk_3520[seqLayer->adsr.releaseRate];
+ note->playbackState.adsr.fadeOutVel = gAudioContext.unk_3520[layer->adsr.releaseRate];
}
note->playbackState.adsr.sustain =
- ((f32)(s32)(seqLayer->seqChannel->adsr.sustain) * note->playbackState.adsr.current) / 256.0f;
+ ((f32)(s32)(layer->channel->adsr.sustain) * note->playbackState.adsr.current) / 256.0f;
}
}
@@ -522,15 +522,15 @@ void Audio_SeqChanLayerDecayRelease(SequenceChannelLayer* seqLayer, s32 target)
}
}
-void Audio_SeqChanLayerNoteDecay(SequenceChannelLayer* seqLayer) {
- Audio_SeqChanLayerDecayRelease(seqLayer, ADSR_STATE_DECAY);
+void Audio_SeqLayerNoteDecay(SequenceLayer* layer) {
+ Audio_SeqLayerDecayRelease(layer, ADSR_STATE_DECAY);
}
-void Audio_SeqChanLayerNoteRelease(SequenceChannelLayer* seqLayer) {
- Audio_SeqChanLayerDecayRelease(seqLayer, ADSR_STATE_RELEASE);
+void Audio_SeqLayerNoteRelease(SequenceLayer* layer) {
+ Audio_SeqLayerDecayRelease(layer, ADSR_STATE_RELEASE);
}
-s32 Audio_BuildSyntheticWave(Note* note, SequenceChannelLayer* seqLayer, s32 waveId) {
+s32 Audio_BuildSyntheticWave(Note* note, SequenceLayer* layer, s32 waveId) {
f32 freqScale;
f32 ratio;
u8 sampleCountIndex;
@@ -539,9 +539,9 @@ s32 Audio_BuildSyntheticWave(Note* note, SequenceChannelLayer* seqLayer, s32 wav
waveId = 128;
}
- freqScale = seqLayer->freqScale;
- if (seqLayer->portamento.mode != 0 && 0.0f < seqLayer->portamento.extent) {
- freqScale *= (seqLayer->portamento.extent + 1.0f);
+ freqScale = layer->freqScale;
+ if (layer->portamento.mode != 0 && 0.0f < layer->portamento.extent) {
+ freqScale *= (layer->portamento.extent + 1.0f);
}
if (freqScale < 0.99999f) {
sampleCountIndex = 0;
@@ -556,7 +556,7 @@ s32 Audio_BuildSyntheticWave(Note* note, SequenceChannelLayer* seqLayer, s32 wav
sampleCountIndex = 3;
ratio = 0.13081f;
}
- seqLayer->freqScale *= ratio;
+ layer->freqScale *= ratio;
note->playbackState.waveId = waveId;
note->playbackState.sampleCountIndex = sampleCountIndex;
@@ -565,17 +565,17 @@ s32 Audio_BuildSyntheticWave(Note* note, SequenceChannelLayer* seqLayer, s32 wav
return sampleCountIndex;
}
-void Audio_InitSyntheticWave(Note* note, SequenceChannelLayer* seqLayer) {
+void Audio_InitSyntheticWave(Note* note, SequenceLayer* layer) {
s32 sampleCountIndex;
s32 waveSampleCountIndex;
- s32 waveId = seqLayer->instOrWave;
+ s32 waveId = layer->instOrWave;
if (waveId == 0xFF) {
- waveId = seqLayer->seqChannel->instOrWave;
+ waveId = layer->channel->instOrWave;
}
sampleCountIndex = note->playbackState.sampleCountIndex;
- waveSampleCountIndex = Audio_BuildSyntheticWave(note, seqLayer, waveId);
+ waveSampleCountIndex = Audio_BuildSyntheticWave(note, layer, waveId);
if (waveSampleCountIndex != sampleCountIndex) {
note->noteSubEu.unk_06 = waveSampleCountIndex * 4 + sampleCountIndex;
@@ -603,10 +603,10 @@ void Audio_InitNoteFreeList(void) {
s32 i;
Audio_InitNoteLists(&gAudioContext.noteFreeLists);
- for (i = 0; i < gAudioContext.maxSimultaneousNotes; i++) {
+ for (i = 0; i < gAudioContext.numNotes; i++) {
gAudioContext.notes[i].listItem.u.value = &gAudioContext.notes[i];
gAudioContext.notes[i].listItem.prev = NULL;
- Audio_AudioListPushBack(&gAudioContext.noteFreeLists.disabled, &gAudioContext.notes[i].listItem);
+ AudioSeq_AudioListPushBack(&gAudioContext.noteFreeLists.disabled, &gAudioContext.notes[i].listItem);
}
}
@@ -645,7 +645,7 @@ void Audio_NotePoolClear(NotePool* pool) {
break;
}
Audio_AudioListRemove(cur);
- Audio_AudioListPushBack(dest, cur);
+ AudioSeq_AudioListPushBack(dest, cur);
}
}
}
@@ -687,11 +687,11 @@ void Audio_NotePoolFill(NotePool* pool, s32 count) {
}
while (j < count) {
- note = Audio_AudioListPopBack(source);
+ note = AudioSeq_AudioListPopBack(source);
if (note == NULL) {
break;
}
- Audio_AudioListPushBack(dest, &note->listItem);
+ AudioSeq_AudioListPushBack(dest, &note->listItem);
j++;
}
}
@@ -718,7 +718,7 @@ void Audio_AudioListRemove(AudioListItem* item) {
}
}
-Note* Audio_PopNodeWithValueLessEqual(AudioListItem* list, s32 limit) {
+Note* Audio_FindNodeWithPrioLessThan(AudioListItem* list, s32 limit) {
AudioListItem* cur = list->next;
AudioListItem* best;
@@ -743,89 +743,90 @@ Note* Audio_PopNodeWithValueLessEqual(AudioListItem* list, s32 limit) {
return best->u.value;
}
-void Audio_NoteInitForLayer(Note* note, SequenceChannelLayer* seqLayer) {
+void Audio_NoteInitForLayer(Note* note, SequenceLayer* layer) {
s32 pad[3];
s16 instId;
NotePlaybackState* playback = &note->playbackState;
NoteSubEu* sub = &note->noteSubEu;
note->playbackState.prevParentLayer = NO_LAYER;
- note->playbackState.parentLayer = seqLayer;
- playback->priority = seqLayer->seqChannel->notePriority;
- seqLayer->notePropertiesNeedInit = true;
- seqLayer->bit3 = true;
- seqLayer->note = note;
- seqLayer->seqChannel->noteUnused = note;
- seqLayer->seqChannel->layerUnused = seqLayer;
- seqLayer->noteVelocity = 0.0f;
+ note->playbackState.parentLayer = layer;
+ playback->priority = layer->channel->notePriority;
+ layer->notePropertiesNeedInit = true;
+ layer->bit3 = true;
+ layer->note = note;
+ layer->channel->noteUnused = note;
+ layer->channel->layerUnused = layer;
+ layer->noteVelocity = 0.0f;
Audio_NoteInit(note);
- instId = seqLayer->instOrWave;
+ instId = layer->instOrWave;
if (instId == 0xFF) {
- instId = seqLayer->seqChannel->instOrWave;
+ instId = layer->channel->instOrWave;
}
- sub->sound.audioBankSound = seqLayer->sound;
+ sub->sound.soundFontSound = layer->sound;
if (instId >= 0x80 && instId < 0xC0) {
- sub->bitField1.s.isSyntheticWave = true;
+ sub->bitField1.isSyntheticWave = true;
} else {
- sub->bitField1.s.isSyntheticWave = false;
+ sub->bitField1.isSyntheticWave = false;
}
- if (sub->bitField1.s.isSyntheticWave) {
- Audio_BuildSyntheticWave(note, seqLayer, instId);
+ if (sub->bitField1.isSyntheticWave) {
+ Audio_BuildSyntheticWave(note, layer, instId);
}
- playback->bankId = seqLayer->seqChannel->bankId;
- playback->stereoHeadsetEffects = seqLayer->seqChannel->stereoHeadsetEffects;
- sub->bitField1.s.reverbIndex = seqLayer->seqChannel->reverbIndex & 3;
+ playback->fontId = layer->channel->fontId;
+ playback->stereoHeadsetEffects = layer->channel->stereoHeadsetEffects;
+ sub->bitField1.reverbIndex = layer->channel->reverbIndex & 3;
}
-void func_800E82C0(Note* note, SequenceChannelLayer* seqLayer) {
- Audio_SeqChanLayerNoteRelease(note->playbackState.parentLayer);
- note->playbackState.wantedParentLayer = seqLayer;
+void func_800E82C0(Note* note, SequenceLayer* layer) {
+ // similar to Audio_NoteReleaseAndTakeOwnership, hard to say what the difference is
+ Audio_SeqLayerNoteRelease(note->playbackState.parentLayer);
+ note->playbackState.wantedParentLayer = layer;
}
-void Audio_NoteReleaseAndTakeOwnership(Note* note, SequenceChannelLayer* seqLayer) {
- note->playbackState.wantedParentLayer = seqLayer;
- note->playbackState.priority = seqLayer->seqChannel->notePriority;
+void Audio_NoteReleaseAndTakeOwnership(Note* note, SequenceLayer* layer) {
+ note->playbackState.wantedParentLayer = layer;
+ note->playbackState.priority = layer->channel->notePriority;
note->playbackState.adsr.fadeOutVel = gAudioContext.audioBufferParameters.updatesPerFrameInv;
note->playbackState.adsr.action.s.release = true;
}
-Note* Audio_AllocNoteFromDisabled(NotePool* pool, SequenceChannelLayer* seqLayer) {
- Note* note = Audio_AudioListPopBack(&pool->disabled);
+Note* Audio_AllocNoteFromDisabled(NotePool* pool, SequenceLayer* layer) {
+ Note* note = AudioSeq_AudioListPopBack(&pool->disabled);
if (note != NULL) {
- Audio_NoteInitForLayer(note, seqLayer);
+ Audio_NoteInitForLayer(note, layer);
Audio_AudioListPushFront(&pool->active, &note->listItem);
}
return note;
}
-Note* Audio_AllocNoteFromDecaying(NotePool* pool, SequenceChannelLayer* seqLayer) {
- Note* note = Audio_AudioListPopBack(&pool->decaying);
+Note* Audio_AllocNoteFromDecaying(NotePool* pool, SequenceLayer* layer) {
+ Note* note = AudioSeq_AudioListPopBack(&pool->decaying);
if (note != NULL) {
- Audio_NoteReleaseAndTakeOwnership(note, seqLayer);
- Audio_AudioListPushBack(&pool->releasing, &note->listItem);
+ Audio_NoteReleaseAndTakeOwnership(note, layer);
+ AudioSeq_AudioListPushBack(&pool->releasing, &note->listItem);
}
return note;
}
-Note* Audio_AllocNoteFromActive(NotePool* pool, SequenceChannelLayer* seqLayer) {
+Note* Audio_AllocNoteFromActive(NotePool* pool, SequenceLayer* layer) {
Note* rNote;
Note* aNote;
s32 rPriority;
s32 aPriority;
rPriority = aPriority = 0x10;
- rNote = Audio_PopNodeWithValueLessEqual(&pool->releasing, seqLayer->seqChannel->notePriority);
+ rNote = Audio_FindNodeWithPrioLessThan(&pool->releasing, layer->channel->notePriority);
if (rNote != NULL) {
rPriority = rNote->playbackState.priority;
}
- aNote = Audio_PopNodeWithValueLessEqual(&pool->active, seqLayer->seqChannel->notePriority);
+ aNote = Audio_FindNodeWithPrioLessThan(&pool->active, layer->channel->notePriority);
if (aNote != NULL) {
aPriority = aNote->playbackState.priority;
@@ -837,76 +838,76 @@ Note* Audio_AllocNoteFromActive(NotePool* pool, SequenceChannelLayer* seqLayer)
if (aPriority < rPriority) {
Audio_AudioListRemove(&aNote->listItem);
- func_800E82C0(aNote, seqLayer);
- Audio_AudioListPushBack(&pool->releasing, &aNote->listItem);
- aNote->playbackState.priority = seqLayer->seqChannel->notePriority;
+ func_800E82C0(aNote, layer);
+ AudioSeq_AudioListPushBack(&pool->releasing, &aNote->listItem);
+ aNote->playbackState.priority = layer->channel->notePriority;
return aNote;
}
- rNote->playbackState.wantedParentLayer = seqLayer;
- rNote->playbackState.priority = seqLayer->seqChannel->notePriority;
+ rNote->playbackState.wantedParentLayer = layer;
+ rNote->playbackState.priority = layer->channel->notePriority;
return rNote;
}
-Note* Audio_AllocNote(SequenceChannelLayer* seqLayer) {
+Note* Audio_AllocNote(SequenceLayer* layer) {
Note* ret;
- u32 policy = seqLayer->seqChannel->noteAllocPolicy;
+ u32 policy = layer->channel->noteAllocPolicy;
if (policy & 1) {
- ret = seqLayer->note;
- if (ret != NULL && ret->playbackState.prevParentLayer == seqLayer &&
+ ret = layer->note;
+ if (ret != NULL && ret->playbackState.prevParentLayer == layer &&
ret->playbackState.wantedParentLayer == NO_LAYER) {
- Audio_NoteReleaseAndTakeOwnership(ret, seqLayer);
+ Audio_NoteReleaseAndTakeOwnership(ret, layer);
Audio_AudioListRemove(&ret->listItem);
- Audio_AudioListPushBack(&ret->listItem.pool->releasing, &ret->listItem);
+ AudioSeq_AudioListPushBack(&ret->listItem.pool->releasing, &ret->listItem);
return ret;
}
}
if (policy & 2) {
- if (!(ret = Audio_AllocNoteFromDisabled(&seqLayer->seqChannel->notePool, seqLayer)) &&
- !(ret = Audio_AllocNoteFromDecaying(&seqLayer->seqChannel->notePool, seqLayer)) &&
- !(ret = Audio_AllocNoteFromActive(&seqLayer->seqChannel->notePool, seqLayer))) {
+ if (!(ret = Audio_AllocNoteFromDisabled(&layer->channel->notePool, layer)) &&
+ !(ret = Audio_AllocNoteFromDecaying(&layer->channel->notePool, layer)) &&
+ !(ret = Audio_AllocNoteFromActive(&layer->channel->notePool, layer))) {
goto null_return;
}
return ret;
}
if (policy & 4) {
- if (!(ret = Audio_AllocNoteFromDisabled(&seqLayer->seqChannel->notePool, seqLayer)) &&
- !(ret = Audio_AllocNoteFromDisabled(&seqLayer->seqChannel->seqPlayer->notePool, seqLayer)) &&
- !(ret = Audio_AllocNoteFromDecaying(&seqLayer->seqChannel->notePool, seqLayer)) &&
- !(ret = Audio_AllocNoteFromDecaying(&seqLayer->seqChannel->seqPlayer->notePool, seqLayer)) &&
- !(ret = Audio_AllocNoteFromActive(&seqLayer->seqChannel->notePool, seqLayer)) &&
- !(ret = Audio_AllocNoteFromActive(&seqLayer->seqChannel->seqPlayer->notePool, seqLayer))) {
+ if (!(ret = Audio_AllocNoteFromDisabled(&layer->channel->notePool, layer)) &&
+ !(ret = Audio_AllocNoteFromDisabled(&layer->channel->seqPlayer->notePool, layer)) &&
+ !(ret = Audio_AllocNoteFromDecaying(&layer->channel->notePool, layer)) &&
+ !(ret = Audio_AllocNoteFromDecaying(&layer->channel->seqPlayer->notePool, layer)) &&
+ !(ret = Audio_AllocNoteFromActive(&layer->channel->notePool, layer)) &&
+ !(ret = Audio_AllocNoteFromActive(&layer->channel->seqPlayer->notePool, layer))) {
goto null_return;
}
return ret;
}
if (policy & 8) {
- if (!(ret = Audio_AllocNoteFromDisabled(&gAudioContext.noteFreeLists, seqLayer)) &&
- !(ret = Audio_AllocNoteFromDecaying(&gAudioContext.noteFreeLists, seqLayer)) &&
- !(ret = Audio_AllocNoteFromActive(&gAudioContext.noteFreeLists, seqLayer))) {
+ if (!(ret = Audio_AllocNoteFromDisabled(&gAudioContext.noteFreeLists, layer)) &&
+ !(ret = Audio_AllocNoteFromDecaying(&gAudioContext.noteFreeLists, layer)) &&
+ !(ret = Audio_AllocNoteFromActive(&gAudioContext.noteFreeLists, layer))) {
goto null_return;
}
return ret;
}
- if (!(ret = Audio_AllocNoteFromDisabled(&seqLayer->seqChannel->notePool, seqLayer)) &&
- !(ret = Audio_AllocNoteFromDisabled(&seqLayer->seqChannel->seqPlayer->notePool, seqLayer)) &&
- !(ret = Audio_AllocNoteFromDisabled(&gAudioContext.noteFreeLists, seqLayer)) &&
- !(ret = Audio_AllocNoteFromDecaying(&seqLayer->seqChannel->notePool, seqLayer)) &&
- !(ret = Audio_AllocNoteFromDecaying(&seqLayer->seqChannel->seqPlayer->notePool, seqLayer)) &&
- !(ret = Audio_AllocNoteFromDecaying(&gAudioContext.noteFreeLists, seqLayer)) &&
- !(ret = Audio_AllocNoteFromActive(&seqLayer->seqChannel->notePool, seqLayer)) &&
- !(ret = Audio_AllocNoteFromActive(&seqLayer->seqChannel->seqPlayer->notePool, seqLayer)) &&
- !(ret = Audio_AllocNoteFromActive(&gAudioContext.noteFreeLists, seqLayer))) {
+ if (!(ret = Audio_AllocNoteFromDisabled(&layer->channel->notePool, layer)) &&
+ !(ret = Audio_AllocNoteFromDisabled(&layer->channel->seqPlayer->notePool, layer)) &&
+ !(ret = Audio_AllocNoteFromDisabled(&gAudioContext.noteFreeLists, layer)) &&
+ !(ret = Audio_AllocNoteFromDecaying(&layer->channel->notePool, layer)) &&
+ !(ret = Audio_AllocNoteFromDecaying(&layer->channel->seqPlayer->notePool, layer)) &&
+ !(ret = Audio_AllocNoteFromDecaying(&gAudioContext.noteFreeLists, layer)) &&
+ !(ret = Audio_AllocNoteFromActive(&layer->channel->notePool, layer)) &&
+ !(ret = Audio_AllocNoteFromActive(&layer->channel->seqPlayer->notePool, layer)) &&
+ !(ret = Audio_AllocNoteFromActive(&gAudioContext.noteFreeLists, layer))) {
goto null_return;
}
return ret;
null_return:
- seqLayer->bit3 = true;
+ layer->bit3 = true;
return NULL;
}
@@ -914,7 +915,7 @@ void Audio_NoteInitAll(void) {
Note* note;
s32 i;
- for (i = 0; i < gAudioContext.maxSimultaneousNotes; i++) {
+ for (i = 0; i < gAudioContext.numNotes; i++) {
note = &gAudioContext.notes[i];
note->noteSubEu = gZeroNoteSub;
note->playbackState.priority = 0;
@@ -924,13 +925,13 @@ void Audio_NoteInitAll(void) {
note->playbackState.prevParentLayer = NO_LAYER;
note->playbackState.waveId = 0;
note->playbackState.attributes.velocity = 0.0f;
- note->playbackState.adsrVolScale = 0;
+ note->playbackState.adsrVolScaleUnused = 0;
note->playbackState.adsr.action.asByte = 0;
note->vibratoState.active = 0;
note->portamento.cur = 0;
note->portamento.speed = 0;
note->playbackState.stereoHeadsetEffects = false;
note->unk_BC = 0;
- note->synthesisState.synthesisBuffers = Audio_AllocDmaMemory(&gAudioContext.notesAndBuffersPool, 0x1E0);
+ note->synthesisState.synthesisBuffers = AudioHeap_AllocDmaMemory(&gAudioContext.notesAndBuffersPool, 0x1E0);
}
}
diff --git a/src/code/audio_seqplayer.c b/src/code/audio_seqplayer.c
index 64b8b9531..cce9333bc 100644
--- a/src/code/audio_seqplayer.c
+++ b/src/code/audio_seqplayer.c
@@ -11,30 +11,28 @@
extern u8 D_80130470[];
-u8 Audio_M64ReadU8(M64ScriptState* state);
+u8 AudioSeq_ScriptReadU8(SeqScriptState* state);
+s16 AudioSeq_ScriptReadS16(SeqScriptState* state);
+u16 AudioSeq_ScriptReadCompressedU16(SeqScriptState* state);
-s16 Audio_M64ReadS16(M64ScriptState* state);
+u8 AudioSeq_GetInstrument(SequenceChannel* channel, u8 instId, Instrument** instOut, AdsrSettings* adsr);
-u16 Audio_M64ReadCompressedU16(M64ScriptState* state);
-
-u8 Audio_GetInstrument(SequenceChannel* seqChannel, u8 instId, Instrument** instOut, AdsrSettings* adsr);
-
-u16 Audio_GetScriptControlFlowArgument(M64ScriptState* state, u8 arg1) {
+u16 AudioSeq_GetScriptControlFlowArgument(SeqScriptState* state, u8 arg1) {
u8 temp_v0 = D_80130470[arg1];
u8 loBits = temp_v0 & 3;
u16 ret = 0;
if (loBits == 1) {
if ((temp_v0 & 0x80) == 0) {
- ret = Audio_M64ReadU8(state);
+ ret = AudioSeq_ScriptReadU8(state);
} else {
- ret = Audio_M64ReadS16(state);
+ ret = AudioSeq_ScriptReadS16(state);
}
}
return ret;
}
-s32 Audio_HandleScriptFlowControl(SequencePlayer* seqPlayer, M64ScriptState* state, s32 cmd, s32 arg) {
+s32 AudioSeq_HandleScriptFlowControl(SequencePlayer* seqPlayer, SeqScriptState* state, s32 cmd, s32 arg) {
switch (cmd) {
case 0xFF:
if (state->depth == 0) {
@@ -44,7 +42,7 @@ s32 Audio_HandleScriptFlowControl(SequencePlayer* seqPlayer, M64ScriptState* sta
break;
case 0xFD:
- return Audio_M64ReadCompressedU16(state);
+ return AudioSeq_ScriptReadCompressedU16(state);
case 0xFE:
return 1;
@@ -104,79 +102,79 @@ s32 Audio_HandleScriptFlowControl(SequencePlayer* seqPlayer, M64ScriptState* sta
return 0;
}
-void Audio_SequenceChannelInit(SequenceChannel* seqChannel) {
+void AudioSeq_InitSequenceChannel(SequenceChannel* channel) {
s32 i;
- if (seqChannel == &gAudioContext.sequenceChannelNone) {
+ if (channel == &gAudioContext.sequenceChannelNone) {
return;
}
- seqChannel->enabled = false;
- seqChannel->finished = false;
- seqChannel->stopScript = false;
- seqChannel->stopSomething2 = false;
- seqChannel->hasInstrument = false;
- seqChannel->stereoHeadsetEffects = false;
- seqChannel->transposition = 0;
- seqChannel->largeNotes = false;
- seqChannel->bookOffset = 0;
- seqChannel->stereo.asByte = 0;
- seqChannel->changes.asByte = 0xFF;
- seqChannel->scriptState.depth = 0;
- seqChannel->newPan = 0x40;
- seqChannel->panChannelWeight = 0x80;
- seqChannel->velocityRandomVariance = 0;
- seqChannel->durationRandomVariance = 0;
- seqChannel->noteUnused = NULL;
- seqChannel->reverbIndex = 0;
- seqChannel->reverb = 0;
- seqChannel->unk_0C = 0;
- seqChannel->notePriority = 3;
- seqChannel->someOtherPriority = 1;
- seqChannel->delay = 0;
- seqChannel->adsr.envelope = gDefaultEnvelope;
- seqChannel->adsr.releaseRate = 0xF0;
- seqChannel->adsr.sustain = 0;
- seqChannel->vibratoRateTarget = 0x800;
- seqChannel->vibratoRateStart = 0x800;
- seqChannel->vibratoExtentTarget = 0;
- seqChannel->vibratoExtentStart = 0;
- seqChannel->vibratoRateChangeDelay = 0;
- seqChannel->vibratoExtentChangeDelay = 0;
- seqChannel->vibratoDelay = 0;
- seqChannel->filter = NULL;
- seqChannel->unk_20 = 0;
- seqChannel->unk_0F = 0;
- seqChannel->volume = 1.0f;
- seqChannel->volumeScale = 1.0f;
- seqChannel->freqScale = 1.0f;
+ channel->enabled = false;
+ channel->finished = false;
+ channel->stopScript = false;
+ channel->stopSomething2 = false;
+ channel->hasInstrument = false;
+ channel->stereoHeadsetEffects = false;
+ channel->transposition = 0;
+ channel->largeNotes = false;
+ channel->bookOffset = 0;
+ channel->stereo.asByte = 0;
+ channel->changes.asByte = 0xFF;
+ channel->scriptState.depth = 0;
+ channel->newPan = 0x40;
+ channel->panChannelWeight = 0x80;
+ channel->velocityRandomVariance = 0;
+ channel->gateTimeRandomVariance = 0;
+ channel->noteUnused = NULL;
+ channel->reverbIndex = 0;
+ channel->reverb = 0;
+ channel->unk_0C = 0;
+ channel->notePriority = 3;
+ channel->someOtherPriority = 1;
+ channel->delay = 0;
+ channel->adsr.envelope = gDefaultEnvelope;
+ channel->adsr.releaseRate = 0xF0;
+ channel->adsr.sustain = 0;
+ channel->vibratoRateTarget = 0x800;
+ channel->vibratoRateStart = 0x800;
+ channel->vibratoExtentTarget = 0;
+ channel->vibratoExtentStart = 0;
+ channel->vibratoRateChangeDelay = 0;
+ channel->vibratoExtentChangeDelay = 0;
+ channel->vibratoDelay = 0;
+ channel->filter = NULL;
+ channel->unk_20 = 0;
+ channel->unk_0F = 0;
+ channel->volume = 1.0f;
+ channel->volumeScale = 1.0f;
+ channel->freqScale = 1.0f;
for (i = 0; i < 8; i++) {
- seqChannel->soundScriptIO[i] = -1;
+ channel->soundScriptIO[i] = -1;
}
- seqChannel->unused = false;
- Audio_InitNoteLists(&seqChannel->notePool);
+ channel->unused = false;
+ Audio_InitNoteLists(&channel->notePool);
}
-s32 Audio_SeqChannelSetLayer(SequenceChannel* seqChannel, s32 layerIdx) {
- SequenceChannelLayer* layer;
+s32 AudioSeq_SeqChannelSetLayer(SequenceChannel* channel, s32 layerIdx) {
+ SequenceLayer* layer;
- if (seqChannel->layers[layerIdx] == NULL) {
- SequenceChannelLayer* layer;
- layer = Audio_AudioListPopBack(&gAudioContext.layerFreeList);
- seqChannel->layers[layerIdx] = layer;
+ if (channel->layers[layerIdx] == NULL) {
+ SequenceLayer* layer;
+ layer = AudioSeq_AudioListPopBack(&gAudioContext.layerFreeList);
+ channel->layers[layerIdx] = layer;
if (layer == NULL) {
- seqChannel->layers[layerIdx] = NULL;
+ channel->layers[layerIdx] = NULL;
return -1;
}
} else {
- Audio_SeqChanLayerNoteDecay(seqChannel->layers[layerIdx]);
+ Audio_SeqLayerNoteDecay(channel->layers[layerIdx]);
}
- layer = seqChannel->layers[layerIdx];
- layer->seqChannel = seqChannel;
- layer->adsr = seqChannel->adsr;
+ layer = channel->layers[layerIdx];
+ layer->channel = channel;
+ layer->adsr = channel->adsr;
layer->adsr.releaseRate = 0;
layer->enabled = true;
layer->finished = false;
@@ -189,11 +187,11 @@ s32 Audio_SeqChannelSetLayer(SequenceChannel* seqChannel, s32 layerIdx) {
layer->stereo.asByte = 0;
layer->portamento.mode = 0;
layer->scriptState.depth = 0;
- layer->noteDuration = 0x80;
+ layer->gateTime = 0x80;
layer->pan = 0x40;
layer->transposition = 0;
layer->delay = 0;
- layer->duration = 0;
+ layer->gateDelay = 0;
layer->delay2 = 0;
layer->note = NULL;
layer->instrument = NULL;
@@ -204,90 +202,90 @@ s32 Audio_SeqChannelSetLayer(SequenceChannel* seqChannel, s32 layerIdx) {
return 0;
}
-void Audio_SeqChannelLayerDisable(SequenceChannelLayer* layer) {
+void AudioSeq_SeqLayerDisable(SequenceLayer* layer) {
if (layer != NULL) {
- if (layer->seqChannel != &gAudioContext.sequenceChannelNone && layer->seqChannel->seqPlayer->finished == 1) {
- Audio_SeqChanLayerNoteRelease(layer);
+ if (layer->channel != &gAudioContext.sequenceChannelNone && layer->channel->seqPlayer->finished == 1) {
+ Audio_SeqLayerNoteRelease(layer);
} else {
- Audio_SeqChanLayerNoteDecay(layer);
+ Audio_SeqLayerNoteDecay(layer);
}
layer->enabled = false;
layer->finished = true;
}
}
-void Audio_SeqChannelLayerFree(SequenceChannel* seqChannel, s32 layerIdx) {
- SequenceChannelLayer* layer = seqChannel->layers[layerIdx];
+void AudioSeq_SeqLayerFree(SequenceChannel* channel, s32 layerIdx) {
+ SequenceLayer* layer = channel->layers[layerIdx];
if (layer != NULL) {
- Audio_AudioListPushBack(&gAudioContext.layerFreeList, &layer->listItem);
- Audio_SeqChannelLayerDisable(layer);
- seqChannel->layers[layerIdx] = NULL;
+ AudioSeq_AudioListPushBack(&gAudioContext.layerFreeList, &layer->listItem);
+ AudioSeq_SeqLayerDisable(layer);
+ channel->layers[layerIdx] = NULL;
}
}
-void Audio_SequenceChannelDisable(SequenceChannel* seqChannel) {
+void AudioSeq_SequenceChannelDisable(SequenceChannel* channel) {
s32 i;
for (i = 0; i < 4; i++) {
- Audio_SeqChannelLayerFree(seqChannel, i);
+ AudioSeq_SeqLayerFree(channel, i);
}
- Audio_NotePoolClear(&seqChannel->notePool);
- seqChannel->enabled = false;
- seqChannel->finished = true;
+ Audio_NotePoolClear(&channel->notePool);
+ channel->enabled = false;
+ channel->finished = true;
}
-void Audio_SequencePlayerInitChannels(SequencePlayer* seqPlayer, u16 channelBits) {
- SequenceChannel* seqChannel;
+void AudioSeq_SequencePlayerSetupChannels(SequencePlayer* seqPlayer, u16 channelBits) {
+ SequenceChannel* channel;
s32 i;
for (i = 0; i < 0x10; i++) {
if (channelBits & 1) {
- seqChannel = seqPlayer->channels[i];
- seqChannel->bankId = seqPlayer->defaultBank;
- seqChannel->muteBehavior = seqPlayer->muteBehavior;
- seqChannel->noteAllocPolicy = seqPlayer->noteAllocPolicy;
+ channel = seqPlayer->channels[i];
+ channel->fontId = seqPlayer->defaultFont;
+ channel->muteBehavior = seqPlayer->muteBehavior;
+ channel->noteAllocPolicy = seqPlayer->noteAllocPolicy;
}
channelBits = channelBits >> 1;
}
}
-void Audio_SequencePlayerDisableChannels(SequencePlayer* seqPlayer, u16 channelBitsUnused) {
- SequenceChannel* seqChannel;
+void AudioSeq_SequencePlayerDisableChannels(SequencePlayer* seqPlayer, u16 channelBitsUnused) {
+ SequenceChannel* channel;
s32 i;
for (i = 0; i < 0x10; i++) {
- seqChannel = seqPlayer->channels[i];
- if (IS_SEQUENCE_CHANNEL_VALID(seqChannel) == 1) {
- Audio_SequenceChannelDisable(seqChannel);
+ channel = seqPlayer->channels[i];
+ if (IS_SEQUENCE_CHANNEL_VALID(channel) == 1) {
+ AudioSeq_SequenceChannelDisable(channel);
}
}
}
-void Audio_SequenceChannelEnable(SequencePlayer* seqPlayer, u8 channelIdx, void* script) {
- SequenceChannel* seqChannel = seqPlayer->channels[channelIdx];
+void AudioSeq_SequenceChannelEnable(SequencePlayer* seqPlayer, u8 channelIdx, void* script) {
+ SequenceChannel* channel = seqPlayer->channels[channelIdx];
s32 i;
- seqChannel->enabled = true;
- seqChannel->finished = false;
- seqChannel->scriptState.depth = 0;
- seqChannel->scriptState.pc = script;
- seqChannel->delay = 0;
+ channel->enabled = true;
+ channel->finished = false;
+ channel->scriptState.depth = 0;
+ channel->scriptState.pc = script;
+ channel->delay = 0;
for (i = 0; i < 4; i++) {
- if (seqChannel->layers[i] != NULL) {
- Audio_SeqChannelLayerFree(seqChannel, i);
+ if (channel->layers[i] != NULL) {
+ AudioSeq_SeqLayerFree(channel, i);
}
}
}
-void Audio_SequencePlayerDisableAsFinished(SequencePlayer* seqPlayer) {
+void AudioSeq_SequencePlayerDisableAsFinished(SequencePlayer* seqPlayer) {
seqPlayer->finished = true;
- Audio_SequencePlayerDisable(seqPlayer);
+ AudioSeq_SequencePlayerDisable(seqPlayer);
}
-void Audio_SequencePlayerDisable(SequencePlayer* seqPlayer) {
- Audio_SequencePlayerDisableChannels(seqPlayer, 0xFFFF);
+void AudioSeq_SequencePlayerDisable(SequencePlayer* seqPlayer) {
+ AudioSeq_SequencePlayerDisableChannels(seqPlayer, 0xFFFF);
Audio_NotePoolClear(&seqPlayer->notePool);
if (!seqPlayer->enabled) {
return;
@@ -296,21 +294,21 @@ void Audio_SequencePlayerDisable(SequencePlayer* seqPlayer) {
seqPlayer->enabled = false;
seqPlayer->finished = true;
- if (Audio_IsSeqLoadComplete(seqPlayer->seqId)) {
- Audio_SetSeqLoadStatus(seqPlayer->seqId, 3);
+ if (AudioLoad_IsSeqLoadComplete(seqPlayer->seqId)) {
+ AudioLoad_SetSeqLoadStatus(seqPlayer->seqId, 3);
}
- if (Audio_IsBankLoadComplete(seqPlayer->defaultBank)) {
- Audio_SetBankLoadStatus(seqPlayer->defaultBank, 4);
+ if (AudioLoad_IsFontLoadComplete(seqPlayer->defaultFont)) {
+ AudioLoad_SetFontLoadStatus(seqPlayer->defaultFont, 4);
}
- if (seqPlayer->defaultBank == gAudioContext.bankLoadedPool.temporary.entries[0].id) {
- gAudioContext.bankLoadedPool.temporary.nextSide = 0;
- } else if (seqPlayer->defaultBank == gAudioContext.bankLoadedPool.temporary.entries[1].id) {
- gAudioContext.bankLoadedPool.temporary.nextSide = 1;
+ if (seqPlayer->defaultFont == gAudioContext.fontCache.temporary.entries[0].id) {
+ gAudioContext.fontCache.temporary.nextSide = 0;
+ } else if (seqPlayer->defaultFont == gAudioContext.fontCache.temporary.entries[1].id) {
+ gAudioContext.fontCache.temporary.nextSide = 1;
}
}
-void Audio_AudioListPushBack(AudioListItem* list, AudioListItem* item) {
+void AudioSeq_AudioListPushBack(AudioListItem* list, AudioListItem* item) {
if (item->prev == NULL) {
list->prev->next = item;
item->prev = list->prev;
@@ -321,7 +319,7 @@ void Audio_AudioListPushBack(AudioListItem* list, AudioListItem* item) {
}
}
-void* Audio_AudioListPopBack(AudioListItem* list) {
+void* AudioSeq_AudioListPopBack(AudioListItem* list) {
AudioListItem* item = list->prev;
if (item == list) {
@@ -335,7 +333,7 @@ void* Audio_AudioListPopBack(AudioListItem* list) {
return item->u.value;
}
-void Audio_InitLayerFreelist(void) {
+void AudioSeq_InitLayerFreelist(void) {
s32 i;
gAudioContext.layerFreeList.prev = &gAudioContext.layerFreeList;
@@ -346,21 +344,21 @@ void Audio_InitLayerFreelist(void) {
for (i = 0; i < ARRAY_COUNT(gAudioContext.sequenceLayers); i++) {
gAudioContext.sequenceLayers[i].listItem.u.value = &gAudioContext.sequenceLayers[i];
gAudioContext.sequenceLayers[i].listItem.prev = NULL;
- Audio_AudioListPushBack(&gAudioContext.layerFreeList, &gAudioContext.sequenceLayers[i].listItem);
+ AudioSeq_AudioListPushBack(&gAudioContext.layerFreeList, &gAudioContext.sequenceLayers[i].listItem);
}
}
-u8 Audio_M64ReadU8(M64ScriptState* state) {
+u8 AudioSeq_ScriptReadU8(SeqScriptState* state) {
return *(state->pc++);
}
-s16 Audio_M64ReadS16(M64ScriptState* state) {
+s16 AudioSeq_ScriptReadS16(SeqScriptState* state) {
s16 ret = *(state->pc++) << 8;
ret = *(state->pc++) | ret;
return ret;
}
-u16 Audio_M64ReadCompressedU16(M64ScriptState* state) {
+u16 AudioSeq_ScriptReadCompressedU16(SeqScriptState* state) {
u16 ret = *(state->pc++);
if (ret & 0x80) {
ret = (ret << 8) & 0x7F00;
@@ -369,54 +367,54 @@ u16 Audio_M64ReadCompressedU16(M64ScriptState* state) {
return ret;
}
-void func_800E9ED8(SequenceChannelLayer* layer);
-s32 func_800E9F64(SequenceChannelLayer* layer, s32 arg1);
-s32 func_800EA0C0(SequenceChannelLayer* layer);
-s32 func_800EA440(SequenceChannelLayer* layer, s32 arg1);
-s32 func_800EAAE0(SequenceChannelLayer* layer, s32 arg1);
+void AudioSeq_SeqLayerProcessScriptStep1(SequenceLayer* layer);
+s32 AudioSeq_SeqLayerProcessScriptStep2(SequenceLayer* layer);
+s32 AudioSeq_SeqLayerProcessScriptStep3(SequenceLayer* layer, s32 cmd);
+s32 AudioSeq_SeqLayerProcessScriptStep4(SequenceLayer* layer, s32 cmd);
+s32 AudioSeq_SeqLayerProcessScriptStep5(SequenceLayer* layer, s32 sameSound);
-void Audio_SeqChannelLayerProcessScript(SequenceChannelLayer* layer) {
+void AudioSeq_SeqLayerProcessScript(SequenceLayer* layer) {
s32 val;
- if (layer->enabled == 0) {
+ if (!layer->enabled) {
return;
}
if (layer->delay > 1) {
layer->delay--;
- if (!layer->stopSomething && layer->delay <= layer->duration) {
- Audio_SeqChanLayerNoteDecay(layer);
+ if (!layer->stopSomething && layer->delay <= layer->gateDelay) {
+ Audio_SeqLayerNoteDecay(layer);
layer->stopSomething = true;
}
return;
}
- func_800E9ED8(layer);
- val = func_800EA0C0(layer);
+ AudioSeq_SeqLayerProcessScriptStep1(layer);
+ val = AudioSeq_SeqLayerProcessScriptStep2(layer);
if (val == -1) {
return;
}
- val = func_800EAAE0(layer, val);
+ val = AudioSeq_SeqLayerProcessScriptStep3(layer, val);
if (val != -1) {
- val = func_800EA440(layer, val);
+ val = AudioSeq_SeqLayerProcessScriptStep4(layer, val);
}
if (val != -1) {
- func_800E9F64(layer, val);
+ AudioSeq_SeqLayerProcessScriptStep5(layer, val);
}
- if (layer->stopSomething == 1) {
+ if (layer->stopSomething == true) {
if ((layer->note != NULL) || layer->continuousNotes) {
- Audio_SeqChanLayerNoteDecay(layer);
+ Audio_SeqLayerNoteDecay(layer);
}
}
}
-void func_800E9ED8(SequenceChannelLayer* layer) {
+void AudioSeq_SeqLayerProcessScriptStep1(SequenceLayer* layer) {
if (!layer->continuousNotes) {
- Audio_SeqChanLayerNoteDecay(layer);
+ Audio_SeqLayerNoteDecay(layer);
} else if (layer->note != NULL && layer->note->playbackState.wantedParentLayer == layer) {
- Audio_SeqChanLayerNoteDecay(layer);
+ Audio_SeqLayerNoteDecay(layer);
}
if (PORTAMENTO_MODE(layer->portamento) == PORTAMENTO_MODE_1 ||
@@ -426,25 +424,25 @@ void func_800E9ED8(SequenceChannelLayer* layer) {
layer->notePropertiesNeedInit = true;
}
-s32 func_800E9F64(SequenceChannelLayer* layer, s32 arg1) {
- if (!layer->stopSomething && layer->sound != NULL && layer->sound->sample->codec == 2 &&
- layer->sound->sample->medium != 0) {
+s32 AudioSeq_SeqLayerProcessScriptStep5(SequenceLayer* layer, s32 sameSound) {
+ if (!layer->stopSomething && layer->sound != NULL && layer->sound->sample->codec == CODEC_S16_INMEMORY &&
+ layer->sound->sample->medium != MEDIUM_RAM) {
layer->stopSomething = true;
return -1;
}
- if (layer->continuousNotes == 1 && layer->bit1 == 1) {
+ if (layer->continuousNotes == true && layer->bit1 == 1) {
return 0;
}
- if (layer->continuousNotes == 1 && layer->note != NULL && layer->bit3 && arg1 == 1 &&
+ if (layer->continuousNotes == true && layer->note != NULL && layer->bit3 && sameSound == true &&
layer->note->playbackState.parentLayer == layer) {
if (layer->sound == NULL) {
Audio_InitSyntheticWave(layer->note, layer);
}
} else {
- if (arg1 == 0) {
- Audio_SeqChanLayerNoteDecay(layer);
+ if (sameSound == false) {
+ Audio_SeqLayerNoteDecay(layer);
}
layer->note = Audio_AllocNote(layer);
if (layer->note != NULL && layer->note->playbackState.parentLayer == layer) {
@@ -459,24 +457,24 @@ s32 func_800E9F64(SequenceChannelLayer* layer, s32 arg1) {
return 0;
}
-s32 func_800EA0C0(SequenceChannelLayer* layer) {
- SequenceChannel* seqChannel = layer->seqChannel;
- M64ScriptState* state = &layer->scriptState;
- SequencePlayer* seqPlayer = seqChannel->seqPlayer;
+s32 AudioSeq_SeqLayerProcessScriptStep2(SequenceLayer* layer) {
+ SequenceChannel* channel = layer->channel;
+ SeqScriptState* state = &layer->scriptState;
+ SequencePlayer* seqPlayer = channel->seqPlayer;
u16 sp3A;
u8 cmd;
for (;;) {
- cmd = Audio_M64ReadU8(state);
+ cmd = AudioSeq_ScriptReadU8(state);
if (cmd < 0xC1) {
return cmd;
}
if (cmd >= 0xF2) {
- u16 arg = Audio_GetScriptControlFlowArgument(state, cmd);
- if (Audio_HandleScriptFlowControl(seqPlayer, state, cmd, arg) == 0) {
+ u16 arg = AudioSeq_GetScriptControlFlowArgument(state, cmd);
+ if (AudioSeq_HandleScriptFlowControl(seqPlayer, state, cmd, arg) == 0) {
continue;
}
- Audio_SeqChannelLayerDisable(layer);
+ AudioSeq_SeqLayerDisable(layer);
return -1;
}
@@ -493,12 +491,12 @@ s32 func_800EA0C0(SequenceChannelLayer* layer) {
break;
}
- case 0xC9: // layer_setshortnoteduration
+ case 0xC9: // layer_setshortnotegatetime
case 0xC2: // layer_transpose; set transposition in semitones
{
u8 tempByte = *(state->pc++);
if (cmd == 0xC9) {
- layer->noteDuration = tempByte;
+ layer->gateTime = tempByte;
} else {
layer->transposition = tempByte;
}
@@ -513,16 +511,16 @@ s32 func_800EA0C0(SequenceChannelLayer* layer) {
layer->continuousNotes = false;
}
layer->bit1 = false;
- Audio_SeqChanLayerNoteDecay(layer);
+ Audio_SeqLayerNoteDecay(layer);
break;
- case 0xC3: // layer_setshortnotedefaultplaypercentage
- sp3A = Audio_M64ReadCompressedU16(state);
- layer->shortNoteDefaultPlayPercentage = sp3A;
+ case 0xC3: // layer_setshortnotedefaultdelay
+ sp3A = AudioSeq_ScriptReadCompressedU16(state);
+ layer->shortNoteDefaultDelay = sp3A;
break;
case 0xC6: // layer_setinstr
- cmd = Audio_M64ReadU8(state);
+ cmd = AudioSeq_ScriptReadU8(state);
if (cmd >= 0x7E) {
if (cmd == 0x7E) {
layer->instOrWave = 1;
@@ -540,16 +538,16 @@ s32 func_800EA0C0(SequenceChannelLayer* layer) {
break;
}
- if ((layer->instOrWave = Audio_GetInstrument(seqChannel, cmd, &layer->instrument, &layer->adsr)) == 0) {
+ if ((layer->instOrWave = AudioSeq_GetInstrument(channel, cmd, &layer->instrument, &layer->adsr)) == 0) {
layer->instOrWave = 0xFF;
}
break;
case 0xC7: // layer_portamento
- layer->portamento.mode = Audio_M64ReadU8(state);
+ layer->portamento.mode = AudioSeq_ScriptReadU8(state);
- cmd = Audio_M64ReadU8(state);
- cmd += seqChannel->transposition;
+ cmd = AudioSeq_ScriptReadU8(state);
+ cmd += channel->transposition;
cmd += layer->transposition;
cmd += seqPlayer->transposition;
@@ -565,7 +563,7 @@ s32 func_800EA0C0(SequenceChannelLayer* layer) {
break;
}
- sp3A = Audio_M64ReadCompressedU16(state);
+ sp3A = AudioSeq_ScriptReadCompressedU16(state);
layer->portamentoTime = sp3A;
break;
@@ -574,12 +572,12 @@ s32 func_800EA0C0(SequenceChannelLayer* layer) {
break;
case 0xCB:
- sp3A = Audio_M64ReadS16(state);
+ sp3A = AudioSeq_ScriptReadS16(state);
layer->adsr.envelope = (AdsrEnvelope*)(seqPlayer->seqData + sp3A);
// fallthrough
case 0xCF:
- layer->adsr.releaseRate = Audio_M64ReadU8(state);
+ layer->adsr.releaseRate = AudioSeq_ScriptReadU8(state);
break;
case 0xCC:
@@ -587,11 +585,11 @@ s32 func_800EA0C0(SequenceChannelLayer* layer) {
break;
case 0xCD:
- layer->stereo.asByte = Audio_M64ReadU8(state);
+ layer->stereo.asByte = AudioSeq_ScriptReadU8(state);
break;
case 0xCE: {
- u8 tempByte = Audio_M64ReadU8(state);
+ u8 tempByte = AudioSeq_ScriptReadU8(state);
layer->unk_34 = D_8012F4B4[(tempByte + 0x80) & 0xFF];
break;
}
@@ -602,16 +600,16 @@ s32 func_800EA0C0(SequenceChannelLayer* layer) {
sp3A = seqPlayer->shortNoteVelocityTable[cmd & 0xF];
layer->velocitySquare = (f32)(sp3A * sp3A) / 16129.0f;
break;
- case 0xE0: // layer_setshortnotedurationfromtable
- layer->noteDuration = (u8)seqPlayer->shortNoteDurationTable[cmd & 0xF];
+ case 0xE0: // layer_setshortnotegatetimefromtable
+ layer->gateTime = (u8)seqPlayer->shortNoteGateTimeTable[cmd & 0xF];
break;
}
}
}
}
-s32 func_800EA440(SequenceChannelLayer* layer, s32 arg1) {
- s32 sameSound = 1;
+s32 AudioSeq_SeqLayerProcessScriptStep4(SequenceLayer* layer, s32 cmd) {
+ s32 sameSound = true;
s32 instOrWave;
s32 speed;
f32 temp_f14;
@@ -619,35 +617,35 @@ s32 func_800EA440(SequenceChannelLayer* layer, s32 arg1) {
Portamento* portamento;
f32 freqScale;
f32 freqScale2;
- AudioBankSound* sound;
+ SoundFontSound* sound;
Instrument* instrument;
Drum* drum;
s32 pad;
- SequenceChannel* seqChannel;
+ SequenceChannel* channel;
SequencePlayer* seqPlayer;
- u8 cmd = arg1;
+ u8 semitone = cmd;
u16 sfxId;
- s32 cmd2;
+ s32 semitone2;
s32 vel;
f32 time;
f32 tuning;
instOrWave = layer->instOrWave;
- seqChannel = layer->seqChannel;
- seqPlayer = seqChannel->seqPlayer;
+ channel = layer->channel;
+ seqPlayer = channel->seqPlayer;
if (instOrWave == 0xFF) {
- if (!seqChannel->hasInstrument) {
+ if (!channel->hasInstrument) {
return -1;
}
- instOrWave = seqChannel->instOrWave;
+ instOrWave = channel->instOrWave;
}
switch (instOrWave) {
case 0:
- cmd += seqChannel->transposition + layer->transposition;
- layer->semitone = cmd;
- drum = Audio_GetDrum(seqChannel->bankId, cmd);
+ semitone += channel->transposition + layer->transposition;
+ layer->semitone = semitone;
+ drum = Audio_GetDrum(channel->fontId, semitone);
if (drum == NULL) {
layer->stopSomething = true;
layer->delay2 = layer->delay;
@@ -664,9 +662,9 @@ s32 func_800EA440(SequenceChannelLayer* layer, s32 arg1) {
break;
case 1:
- layer->semitone = cmd;
- sfxId = (layer->transposition << 6) + cmd;
- sound = Audio_GetSfx(seqChannel->bankId, sfxId);
+ layer->semitone = semitone;
+ sfxId = (layer->transposition << 6) + semitone;
+ sound = Audio_GetSfx(channel->fontId, sfxId);
if (sound == NULL) {
layer->stopSomething = true;
layer->delay2 = layer->delay + 1;
@@ -677,25 +675,25 @@ s32 func_800EA440(SequenceChannelLayer* layer, s32 arg1) {
break;
default:
- cmd += seqPlayer->transposition + seqChannel->transposition + layer->transposition;
- cmd2 = cmd;
- layer->semitone = cmd;
- if (cmd >= 0x80) {
+ semitone += seqPlayer->transposition + channel->transposition + layer->transposition;
+ semitone2 = semitone;
+ layer->semitone = semitone;
+ if (semitone >= 0x80) {
layer->stopSomething = true;
return -1;
}
if (layer->instOrWave == 0xFF) {
- instrument = seqChannel->instrument;
+ instrument = channel->instrument;
} else {
instrument = layer->instrument;
}
if (layer->portamento.mode != 0) {
portamento = &layer->portamento;
- vel = (cmd > layer->portamentoTargetNote) ? cmd : layer->portamentoTargetNote;
+ vel = (semitone > layer->portamentoTargetNote) ? semitone : layer->portamentoTargetNote;
if (instrument != NULL) {
- sound = Audio_InstrumentGetAudioBankSound(instrument, vel);
+ sound = Audio_InstrumentGetSound(instrument, vel);
sameSound = (layer->sound == sound);
layer->sound = sound;
tuning = sound->tuning;
@@ -707,7 +705,7 @@ s32 func_800EA440(SequenceChannelLayer* layer, s32 arg1) {
}
}
- temp_f2 = gNoteFrequencies[cmd2] * tuning;
+ temp_f2 = gNoteFrequencies[semitone2] * tuning;
temp_f14 = gNoteFrequencies[layer->portamentoTargetNote] * tuning;
switch (PORTAMENTO_MODE(*portamento)) {
@@ -749,19 +747,19 @@ s32 func_800EA440(SequenceChannelLayer* layer, s32 arg1) {
portamento->cur = 0;
layer->freqScale = freqScale;
if (PORTAMENTO_MODE(*portamento) == PORTAMENTO_MODE_5) {
- layer->portamentoTargetNote = cmd;
+ layer->portamentoTargetNote = semitone;
}
break;
}
if (instrument != NULL) {
- sound = Audio_InstrumentGetAudioBankSound(instrument, cmd);
+ sound = Audio_InstrumentGetSound(instrument, semitone);
sameSound = (sound == layer->sound);
layer->sound = sound;
- layer->freqScale = gNoteFrequencies[cmd2] * sound->tuning;
+ layer->freqScale = gNoteFrequencies[semitone2] * sound->tuning;
} else {
layer->sound = NULL;
- layer->freqScale = gNoteFrequencies[cmd2];
+ layer->freqScale = gNoteFrequencies[semitone2];
if (instOrWave >= 0xC0) {
layer->sound = &gAudioContext.synthesisReverbs[instOrWave - 0xC0].sound;
}
@@ -783,7 +781,7 @@ s32 func_800EA440(SequenceChannelLayer* layer, s32 arg1) {
if (time > 32766.0f) {
time = 32766.0f;
}
- layer->duration = 0;
+ layer->gateDelay = 0;
layer->delay = (u16)(s32)time + 1;
if (layer->portamento.mode != 0) {
// (It's a bit unclear if 'portamento' has actually always been
@@ -804,43 +802,43 @@ s32 func_800EA440(SequenceChannelLayer* layer, s32 arg1) {
return sameSound;
}
-s32 func_800EAAE0(SequenceChannelLayer* layer, s32 arg1) {
- M64ScriptState* state = &layer->scriptState;
- u16 playPercentage;
+s32 AudioSeq_SeqLayerProcessScriptStep3(SequenceLayer* layer, s32 cmd) {
+ SeqScriptState* state = &layer->scriptState;
+ u16 delay;
s32 velocity;
- SequenceChannel* seqChannel = layer->seqChannel;
- SequencePlayer* seqPlayer = seqChannel->seqPlayer;
+ SequenceChannel* channel = layer->channel;
+ SequencePlayer* seqPlayer = channel->seqPlayer;
s32 intDelta;
f32 floatDelta;
- if (arg1 == 0xC0) {
- layer->delay = Audio_M64ReadCompressedU16(state);
+ if (cmd == 0xC0) {
+ layer->delay = AudioSeq_ScriptReadCompressedU16(state);
layer->stopSomething = true;
layer->bit1 = false;
return -1;
}
layer->stopSomething = false;
- if (seqChannel->largeNotes == 1) {
- switch (arg1 & 0xC0) {
- case 0:
- playPercentage = Audio_M64ReadCompressedU16(state);
+ if (channel->largeNotes == 1) {
+ switch (cmd & 0xC0) {
+ case 0x00:
+ delay = AudioSeq_ScriptReadCompressedU16(state);
velocity = *(state->pc++);
- layer->noteDuration = *(state->pc++);
- layer->playPercentage = playPercentage;
+ layer->gateTime = *(state->pc++);
+ layer->lastDelay = delay;
break;
case 0x40:
- playPercentage = Audio_M64ReadCompressedU16(state);
+ delay = AudioSeq_ScriptReadCompressedU16(state);
velocity = *(state->pc++);
- layer->noteDuration = 0;
- layer->playPercentage = playPercentage;
+ layer->gateTime = 0;
+ layer->lastDelay = delay;
break;
case 0x80:
- playPercentage = layer->playPercentage;
+ delay = layer->lastDelay;
velocity = *(state->pc++);
- layer->noteDuration = *(state->pc++);
+ layer->gateTime = *(state->pc++);
break;
}
@@ -848,28 +846,28 @@ s32 func_800EAAE0(SequenceChannelLayer* layer, s32 arg1) {
velocity = 0x7F;
}
layer->velocitySquare = (f32)velocity * (f32)velocity / 16129.0f;
- arg1 -= (arg1 & 0xC0);
+ cmd -= (cmd & 0xC0);
} else {
- switch (arg1 & 0xC0) {
- case 0:
- playPercentage = Audio_M64ReadCompressedU16(state);
- layer->playPercentage = playPercentage;
+ switch (cmd & 0xC0) {
+ case 0x00:
+ delay = AudioSeq_ScriptReadCompressedU16(state);
+ layer->lastDelay = delay;
break;
case 0x40:
- playPercentage = layer->shortNoteDefaultPlayPercentage;
+ delay = layer->shortNoteDefaultDelay;
break;
case 0x80:
- playPercentage = layer->playPercentage;
+ delay = layer->lastDelay;
break;
}
- arg1 -= (arg1 & 0xC0);
+ cmd -= (cmd & 0xC0);
}
- if (seqChannel->velocityRandomVariance != 0) {
+ if (channel->velocityRandomVariance != 0) {
floatDelta =
- layer->velocitySquare * (f32)(gAudioContext.audioRandom % seqChannel->velocityRandomVariance) / 100.0f;
+ layer->velocitySquare * (f32)(gAudioContext.audioRandom % channel->velocityRandomVariance) / 100.0f;
if ((gAudioContext.audioRandom & 0x8000) != 0) {
floatDelta = -floatDelta;
}
@@ -883,45 +881,45 @@ s32 func_800EAAE0(SequenceChannelLayer* layer, s32 arg1) {
layer->velocitySquare2 = layer->velocitySquare;
}
- layer->delay = playPercentage;
- layer->duration = (layer->noteDuration * playPercentage) >> 8;
- if (seqChannel->durationRandomVariance != 0) {
- //! @bug should probably be durationRandomVariance
- intDelta = (layer->duration * (gAudioContext.audioRandom % seqChannel->velocityRandomVariance)) / 100;
+ layer->delay = delay;
+ layer->gateDelay = (layer->gateTime * delay) >> 8;
+ if (channel->gateTimeRandomVariance != 0) {
+ //! @bug should probably be gateTimeRandomVariance
+ intDelta = (layer->gateDelay * (gAudioContext.audioRandom % channel->velocityRandomVariance)) / 100;
if ((gAudioContext.audioRandom & 0x4000) != 0) {
intDelta = -intDelta;
}
- layer->duration += intDelta;
- if (layer->duration < 0) {
- layer->duration = 0;
- } else if (layer->duration > layer->delay) {
- layer->duration = layer->delay;
+ layer->gateDelay += intDelta;
+ if (layer->gateDelay < 0) {
+ layer->gateDelay = 0;
+ } else if (layer->gateDelay > layer->delay) {
+ layer->gateDelay = layer->delay;
}
}
- if ((seqPlayer->muted && (seqChannel->muteBehavior & (0x40 | 0x10)) != 0) || seqChannel->stopSomething2) {
+ if ((seqPlayer->muted && (channel->muteBehavior & (0x40 | 0x10)) != 0) || channel->stopSomething2) {
layer->stopSomething = true;
return -1;
}
- if (seqPlayer->unk_DC != 0) {
+ if (seqPlayer->skipTicks != 0) {
layer->stopSomething = true;
return -1;
}
- return arg1;
+ return cmd;
}
-void func_800EAEF4(SequenceChannel* seqChannel, u8 arg1) {
+void AudioSeq_SetChannelPriorities(SequenceChannel* channel, u8 arg1) {
if ((arg1 & 0xF) != 0) {
- seqChannel->notePriority = arg1 & 0xF;
+ channel->notePriority = arg1 & 0xF;
}
arg1 = arg1 >> 4;
if (arg1 != 0) {
- seqChannel->someOtherPriority = arg1;
+ channel->someOtherPriority = arg1;
}
}
-u8 Audio_GetInstrument(SequenceChannel* seqChannel, u8 instId, Instrument** instOut, AdsrSettings* adsr) {
- Instrument* inst = Audio_GetInstrumentInner(seqChannel->bankId, instId);
+u8 AudioSeq_GetInstrument(SequenceChannel* channel, u8 instId, Instrument** instOut, AdsrSettings* adsr) {
+ Instrument* inst = Audio_GetInstrumentInner(channel->fontId, instId);
if (inst == NULL) {
*instOut = NULL;
@@ -934,29 +932,29 @@ u8 Audio_GetInstrument(SequenceChannel* seqChannel, u8 instId, Instrument** inst
return instId;
}
-void Audio_SetInstrument(SequenceChannel* seqChannel, u8 instId) {
+void AudioSeq_SetInstrument(SequenceChannel* channel, u8 instId) {
if (instId >= 0x80) {
- seqChannel->instOrWave = instId;
- seqChannel->instrument = NULL;
+ channel->instOrWave = instId;
+ channel->instrument = NULL;
} else if (instId == 0x7F) {
- seqChannel->instOrWave = 0;
- seqChannel->instrument = (Instrument*)1;
+ channel->instOrWave = 0;
+ channel->instrument = (Instrument*)1;
} else if (instId == 0x7E) {
- seqChannel->instOrWave = 1;
- seqChannel->instrument = (Instrument*)2;
- } else if ((seqChannel->instOrWave =
- Audio_GetInstrument(seqChannel, instId, &seqChannel->instrument, &seqChannel->adsr)) == 0) {
- seqChannel->hasInstrument = false;
+ channel->instOrWave = 1;
+ channel->instrument = (Instrument*)2;
+ } else if ((channel->instOrWave = AudioSeq_GetInstrument(channel, instId, &channel->instrument, &channel->adsr)) ==
+ 0) {
+ channel->hasInstrument = false;
return;
}
- seqChannel->hasInstrument = true;
+ channel->hasInstrument = true;
}
-void Audio_SequenceChannelSetVolume(SequenceChannel* seqChannel, u8 volume) {
- seqChannel->volume = (f32)(s32)volume / 127.0f;
+void AudioSeq_SequenceChannelSetVolume(SequenceChannel* channel, u8 volume) {
+ channel->volume = (f32)(s32)volume / 127.0f;
}
-void Audio_SequenceChannelProcessScript(SequenceChannel* channel) {
+void AudioSeq_SequenceChannelProcessScript(SequenceChannel* channel) {
s32 i;
u8* data;
u8* test;
@@ -976,13 +974,13 @@ void Audio_SequenceChannelProcessScript(SequenceChannel* channel) {
}
while (true) {
- M64ScriptState* scriptState = &channel->scriptState;
+ SeqScriptState* scriptState = &channel->scriptState;
s32 param;
s16 pad1;
u16 offset;
u32 parameters[3];
s8 signedParam;
- u8 command = Audio_M64ReadU8(scriptState);
+ u8 command = AudioSeq_ScriptReadU8(scriptState);
u8 lowBits;
u8 highBits;
s32 result;
@@ -994,17 +992,17 @@ void Audio_SequenceChannelProcessScript(SequenceChannel* channel) {
for (i = 0; i < lowBits; i++, highBits <<= 1) {
if (!(highBits & 0x80)) {
- parameters[i] = Audio_M64ReadU8(scriptState);
+ parameters[i] = AudioSeq_ScriptReadU8(scriptState);
} else {
- parameters[i] = Audio_M64ReadS16(scriptState);
+ parameters[i] = AudioSeq_ScriptReadS16(scriptState);
}
}
if (command >= 0xF2) {
- result = Audio_HandleScriptFlowControl(seqPlayer, scriptState, command, parameters[0]);
+ result = AudioSeq_HandleScriptFlowControl(seqPlayer, scriptState, command, parameters[0]);
if (result != 0) {
if (result == -1) {
- Audio_SequenceChannelDisable(channel);
+ AudioSeq_SequenceChannelDisable(channel);
} else {
channel->delay = result;
}
@@ -1040,21 +1038,21 @@ void Audio_SequenceChannelProcessScript(SequenceChannel* channel) {
result = (u8)parameters[0];
command = (u8)parameters[0];
- if (seqPlayer->defaultBank != 0xFF) {
- offset = ((u16*)gAudioContext.unk_283C)[seqPlayer->seqId];
- lowBits = gAudioContext.unk_283Cb[offset];
- command = gAudioContext.unk_283Cb[offset + lowBits - result];
+ if (seqPlayer->defaultFont != 0xFF) {
+ offset = ((u16*)gAudioContext.sequenceFontTable)[seqPlayer->seqId];
+ lowBits = gAudioContext.sequenceFontTable[offset];
+ command = gAudioContext.sequenceFontTable[offset + lowBits - result];
}
- if (func_800DF074(1, 2, command)) {
- channel->bankId = command;
+ if (AudioHeap_SearchCaches(FONT_TABLE, CACHE_EITHER, command)) {
+ channel->fontId = command;
}
parameters[0] = parameters[1];
// NOTE: Intentional fallthrough
case 0xC1:
command = (u8)parameters[0];
- Audio_SetInstrument(channel, command);
+ AudioSeq_SetInstrument(channel, command);
break;
case 0xC3:
channel->largeNotes = false;
@@ -1064,7 +1062,7 @@ void Audio_SequenceChannelProcessScript(SequenceChannel* channel) {
break;
case 0xDF:
command = (u8)parameters[0];
- Audio_SequenceChannelSetVolume(channel, command);
+ AudioSeq_SequenceChannelSetVolume(channel, command);
channel->changes.s.volume = true;
break;
case 0xE0:
@@ -1151,14 +1149,14 @@ void Audio_SequenceChannelProcessScript(SequenceChannel* channel) {
result = (u8)parameters[0];
command = (u8)parameters[0];
- if (seqPlayer->defaultBank != 0xFF) {
- offset = ((u16*)gAudioContext.unk_283C)[seqPlayer->seqId];
- lowBits = gAudioContext.unk_283Cb[offset];
- command = gAudioContext.unk_283Cb[offset + lowBits - result];
+ if (seqPlayer->defaultFont != 0xFF) {
+ offset = ((u16*)gAudioContext.sequenceFontTable)[seqPlayer->seqId];
+ lowBits = gAudioContext.sequenceFontTable[offset];
+ command = gAudioContext.sequenceFontTable[offset + lowBits - result];
}
- if (func_800DF074(1, 2, command)) {
- channel->bankId = command;
+ if (AudioHeap_SearchCaches(FONT_TABLE, CACHE_EITHER, command)) {
+ channel->fontId = command;
}
break;
@@ -1183,7 +1181,7 @@ void Audio_SequenceChannelProcessScript(SequenceChannel* channel) {
break;
case 0xCD:
command = (u8)parameters[0];
- Audio_SequenceChannelDisable(seqPlayer->channels[command]);
+ AudioSeq_SequenceChannelDisable(seqPlayer->channels[command]);
break;
case 0xCA:
command = (u8)parameters[0];
@@ -1245,7 +1243,7 @@ void Audio_SequenceChannelProcessScript(SequenceChannel* channel) {
channel->muteBehavior = data[0];
data += 3;
channel->noteAllocPolicy = data[-2];
- func_800EAEF4(channel, data[-1]);
+ AudioSeq_SetChannelPriorities(channel, data[-1]);
channel->transposition = (s8)data[0];
data += 4;
channel->newPan = data[-3];
@@ -1259,12 +1257,12 @@ void Audio_SequenceChannelProcessScript(SequenceChannel* channel) {
channel->muteBehavior = parameters[0];
channel->noteAllocPolicy = parameters[1];
command = (u8)parameters[2];
- func_800EAEF4(channel, command);
- channel->transposition = (s8)Audio_M64ReadU8(scriptState);
- channel->newPan = Audio_M64ReadU8(scriptState);
- channel->panChannelWeight = Audio_M64ReadU8(scriptState);
- channel->reverb = Audio_M64ReadU8(scriptState);
- channel->reverbIndex = Audio_M64ReadU8(scriptState);
+ AudioSeq_SetChannelPriorities(channel, command);
+ channel->transposition = (s8)AudioSeq_ScriptReadU8(scriptState);
+ channel->newPan = AudioSeq_ScriptReadU8(scriptState);
+ channel->panChannelWeight = AudioSeq_ScriptReadU8(scriptState);
+ channel->reverb = AudioSeq_ScriptReadU8(scriptState);
+ channel->reverbIndex = AudioSeq_ScriptReadU8(scriptState);
//! @bug: Not marking reverb state as changed
channel->changes.s.pan = true;
break;
@@ -1279,14 +1277,14 @@ void Audio_SequenceChannelProcessScript(SequenceChannel* channel) {
channel->unk_0C = 0;
channel->adsr.sustain = 0;
channel->velocityRandomVariance = 0;
- channel->durationRandomVariance = 0;
+ channel->gateTimeRandomVariance = 0;
channel->unk_0F = 0;
channel->unk_20 = 0;
channel->bookOffset = 0;
channel->freqScale = 1.0f;
break;
case 0xE9:
- func_800EAEF4(channel, (u8)parameters[0]);
+ AudioSeq_SetChannelPriorities(channel, (u8)parameters[0]);
break;
case 0xED:
command = (u8)parameters[0];
@@ -1306,7 +1304,7 @@ void Audio_SequenceChannelProcessScript(SequenceChannel* channel) {
if (channel->filter != NULL) {
lowBits = (command >> 4) & 0xF;
command &= 0xF;
- func_800DF688(channel->filter, lowBits, command);
+ AudioHeap_LoadFilter(channel->filter, lowBits, command);
}
break;
case 0xB2:
@@ -1342,7 +1340,7 @@ void Audio_SequenceChannelProcessScript(SequenceChannel* channel) {
channel->velocityRandomVariance = parameters[0];
break;
case 0xBA:
- channel->durationRandomVariance = parameters[0];
+ channel->gateTimeRandomVariance = parameters[0];
break;
case 0xBB:
channel->unk_0F = parameters[0];
@@ -1369,16 +1367,16 @@ void Audio_SequenceChannelProcessScript(SequenceChannel* channel) {
}
break;
case 0x88:
- offset = Audio_M64ReadS16(scriptState);
- if (!Audio_SeqChannelSetLayer(channel, lowBits)) {
+ offset = AudioSeq_ScriptReadS16(scriptState);
+ if (!AudioSeq_SeqChannelSetLayer(channel, lowBits)) {
channel->layers[lowBits]->scriptState.pc = &seqPlayer->seqData[offset];
}
break;
case 0x90:
- Audio_SeqChannelLayerFree(channel, lowBits);
+ AudioSeq_SeqLayerFree(channel, lowBits);
break;
case 0x98:
- if (scriptState->value == -1 || Audio_SeqChannelSetLayer(channel, lowBits) == -1) {
+ if (scriptState->value == -1 || AudioSeq_SeqChannelSetLayer(channel, lowBits) == -1) {
break;
}
@@ -1390,8 +1388,8 @@ void Audio_SequenceChannelProcessScript(SequenceChannel* channel) {
channel->soundScriptIO[lowBits] = scriptState->value;
break;
case 0x78:
- pad1 = Audio_M64ReadS16(scriptState);
- if (!Audio_SeqChannelSetLayer(channel, lowBits)) {
+ pad1 = AudioSeq_ScriptReadS16(scriptState);
+ if (!AudioSeq_SeqChannelSetLayer(channel, lowBits)) {
channel->layers[lowBits]->scriptState.pc = &scriptState->pc[pad1];
}
break;
@@ -1400,22 +1398,22 @@ void Audio_SequenceChannelProcessScript(SequenceChannel* channel) {
lowBits = command & 0xF;
switch (command & 0xF0) {
- case 0: {
+ case 0x00: {
channel->delay = lowBits;
goto exit_loop;
}
case 0x10:
if (lowBits < 8) {
channel->soundScriptIO[lowBits] = -1;
- if (Audio_SyncLoadSample(channel->bankId, scriptState->value,
- &channel->soundScriptIO[lowBits]) == -1) {
+ if (AudioLoad_SlowLoadSample(channel->fontId, scriptState->value,
+ &channel->soundScriptIO[lowBits]) == -1) {
break;
}
} else {
lowBits -= 8;
channel->soundScriptIO[lowBits] = -1;
- if (Audio_SyncLoadSample(channel->bankId, channel->unk_22 + 0x100,
- &channel->soundScriptIO[lowBits]) == -1) {
+ if (AudioLoad_SlowLoadSample(channel->fontId, channel->unk_22 + 0x100,
+ &channel->soundScriptIO[lowBits]) == -1) {
break;
}
}
@@ -1430,15 +1428,15 @@ void Audio_SequenceChannelProcessScript(SequenceChannel* channel) {
scriptState->value -= channel->soundScriptIO[lowBits];
break;
case 0x20:
- offset = Audio_M64ReadS16(scriptState);
- Audio_SequenceChannelEnable(seqPlayer, lowBits, &seqPlayer->seqData[offset]);
+ offset = AudioSeq_ScriptReadS16(scriptState);
+ AudioSeq_SequenceChannelEnable(seqPlayer, lowBits, &seqPlayer->seqData[offset]);
break;
case 0x30:
- command = Audio_M64ReadU8(scriptState);
+ command = AudioSeq_ScriptReadU8(scriptState);
seqPlayer->channels[lowBits]->soundScriptIO[command] = scriptState->value;
break;
case 0x40:
- command = Audio_M64ReadU8(scriptState);
+ command = AudioSeq_ScriptReadU8(scriptState);
scriptState->value = seqPlayer->channels[lowBits]->soundScriptIO[command];
break;
}
@@ -1448,15 +1446,15 @@ exit_loop:
for (i = 0; i < ARRAY_COUNT(channel->layers); i++) {
if (channel->layers[i] != NULL) {
- Audio_SeqChannelLayerProcessScript(channel->layers[i]);
+ AudioSeq_SeqLayerProcessScript(channel->layers[i]);
}
}
}
-void Audio_SequencePlayerProcessSequence(SequencePlayer* seqPlayer) {
+void AudioSeq_SequencePlayerProcessSequence(SequencePlayer* seqPlayer) {
u8 command;
u8 commandLow;
- M64ScriptState* seqScript = &seqPlayer->scriptState;
+ SeqScriptState* seqScript = &seqPlayer->scriptState;
s16 tempS;
u16 temp;
s32 i;
@@ -1471,19 +1469,19 @@ void Audio_SequencePlayerProcessSequence(SequencePlayer* seqPlayer) {
return;
}
- if (!Audio_IsSeqLoadComplete(seqPlayer->seqId) || !Audio_IsBankLoadComplete(seqPlayer->defaultBank)) {
- Audio_SequencePlayerDisable(seqPlayer);
+ if (!AudioLoad_IsSeqLoadComplete(seqPlayer->seqId) || !AudioLoad_IsFontLoadComplete(seqPlayer->defaultFont)) {
+ AudioSeq_SequencePlayerDisable(seqPlayer);
return;
}
- Audio_SetSeqLoadStatus(seqPlayer->seqId, 2);
- Audio_SetBankLoadStatus(seqPlayer->defaultBank, 2);
+ AudioLoad_SetSeqLoadStatus(seqPlayer->seqId, 2);
+ AudioLoad_SetFontLoadStatus(seqPlayer->defaultFont, 2);
if (seqPlayer->muted && (seqPlayer->muteBehavior & 0x80)) {
return;
}
- seqPlayer->unk_E0++;
+ seqPlayer->scriptCounter++;
seqPlayer->tempoAcc += seqPlayer->tempo;
seqPlayer->tempoAcc += (s16)seqPlayer->unk_0C;
@@ -1493,7 +1491,7 @@ void Audio_SequencePlayerProcessSequence(SequencePlayer* seqPlayer) {
seqPlayer->tempoAcc -= (u16)gAudioContext.tempoInternalToExternal;
- if (seqPlayer->unk_0b2 == true) {
+ if (seqPlayer->stopScript == true) {
return;
}
@@ -1503,17 +1501,17 @@ void Audio_SequencePlayerProcessSequence(SequencePlayer* seqPlayer) {
seqPlayer->recalculateVolume = true;
while (true) {
- command = Audio_M64ReadU8(seqScript);
+ command = AudioSeq_ScriptReadU8(seqScript);
// 0xF2 and above are "flow control" commands, including termination.
if (command >= 0xF2) {
- s32 scriptHandled =
- Audio_HandleScriptFlowControl(seqPlayer, seqScript, command,
- Audio_GetScriptControlFlowArgument(&seqPlayer->scriptState, command));
+ s32 scriptHandled = AudioSeq_HandleScriptFlowControl(
+ seqPlayer, seqScript, command,
+ AudioSeq_GetScriptControlFlowArgument(&seqPlayer->scriptState, command));
if (scriptHandled != 0) {
if (scriptHandled == -1) {
- Audio_SequencePlayerDisable(seqPlayer);
+ AudioSeq_SequencePlayerDisable(seqPlayer);
} else {
seqPlayer->delay = (u16)scriptHandled;
}
@@ -1523,7 +1521,7 @@ void Audio_SequencePlayerProcessSequence(SequencePlayer* seqPlayer) {
switch (command) {
case 0xF1:
Audio_NotePoolClear(&seqPlayer->notePool);
- command = Audio_M64ReadU8(seqScript);
+ command = AudioSeq_ScriptReadU8(seqScript);
Audio_NotePoolFill(&seqPlayer->notePool, command);
// Fake-match: the asm has two breaks in a row here,
// which the compiler normally optimizes out.
@@ -1543,10 +1541,10 @@ void Audio_SequencePlayerProcessSequence(SequencePlayer* seqPlayer) {
seqPlayer->transposition = 0;
// Note: intentional fallthrough, also executes below command
case 0xDE:
- seqPlayer->transposition += (s8)Audio_M64ReadU8(seqScript);
+ seqPlayer->transposition += (s8)AudioSeq_ScriptReadU8(seqScript);
break;
case 0xDD:
- seqPlayer->tempo = Audio_M64ReadU8(seqScript) * 48;
+ seqPlayer->tempo = AudioSeq_ScriptReadU8(seqScript) * 48;
if (seqPlayer->tempo > gAudioContext.tempoInternalToExternal) {
seqPlayer->tempo = (u16)gAudioContext.tempoInternalToExternal;
}
@@ -1555,11 +1553,11 @@ void Audio_SequencePlayerProcessSequence(SequencePlayer* seqPlayer) {
}
break;
case 0xDC:
- seqPlayer->unk_0C = (s8)Audio_M64ReadU8(seqScript) * 48;
+ seqPlayer->unk_0C = (s8)AudioSeq_ScriptReadU8(seqScript) * 48;
break;
case 0xDA:
- command = Audio_M64ReadU8(seqScript);
- temp = Audio_M64ReadS16(seqScript);
+ command = AudioSeq_ScriptReadU8(seqScript);
+ temp = AudioSeq_ScriptReadS16(seqScript);
switch (command) {
case 0:
case 1:
@@ -1576,7 +1574,7 @@ void Audio_SequencePlayerProcessSequence(SequencePlayer* seqPlayer) {
}
break;
case 0xDB:
- value = Audio_M64ReadU8(seqScript);
+ value = AudioSeq_ScriptReadU8(seqScript);
switch (seqPlayer->state) {
case 1:
seqPlayer->state = 0;
@@ -1596,39 +1594,39 @@ void Audio_SequencePlayerProcessSequence(SequencePlayer* seqPlayer) {
}
break;
case 0xD9:
- seqPlayer->fadeVolumeScale = (s8)Audio_M64ReadU8(seqScript) / 127.0f;
+ seqPlayer->fadeVolumeScale = (s8)AudioSeq_ScriptReadU8(seqScript) / 127.0f;
break;
case 0xD7:
- temp = Audio_M64ReadS16(seqScript);
- Audio_SequencePlayerInitChannels(seqPlayer, temp);
+ temp = AudioSeq_ScriptReadS16(seqScript);
+ AudioSeq_SequencePlayerSetupChannels(seqPlayer, temp);
break;
case 0xD6:
- Audio_M64ReadS16(seqScript);
+ AudioSeq_ScriptReadS16(seqScript);
break;
case 0xD5:
- seqPlayer->muteVolumeScale = (s8)Audio_M64ReadU8(seqScript) / 127.0f;
+ seqPlayer->muteVolumeScale = (s8)AudioSeq_ScriptReadU8(seqScript) / 127.0f;
break;
case 0xD4:
seqPlayer->muted = true;
break;
case 0xD3:
- seqPlayer->muteBehavior = Audio_M64ReadU8(seqScript);
+ seqPlayer->muteBehavior = AudioSeq_ScriptReadU8(seqScript);
break;
case 0xD1:
case 0xD2:
- temp = Audio_M64ReadS16(seqScript);
+ temp = AudioSeq_ScriptReadS16(seqScript);
data3 = &seqPlayer->seqData[temp];
if (command == 0xD2) {
seqPlayer->shortNoteVelocityTable = data3;
} else {
- seqPlayer->shortNoteDurationTable = data3;
+ seqPlayer->shortNoteGateTimeTable = data3;
}
break;
case 0xD0:
- seqPlayer->noteAllocPolicy = Audio_M64ReadU8(seqScript);
+ seqPlayer->noteAllocPolicy = AudioSeq_ScriptReadU8(seqScript);
break;
case 0xCE:
- command = Audio_M64ReadU8(seqScript);
+ command = AudioSeq_ScriptReadU8(seqScript);
if (command == 0) {
seqScript->value = (gAudioContext.audioRandom >> 2) & 0xFF;
} else {
@@ -1636,7 +1634,7 @@ void Audio_SequencePlayerProcessSequence(SequencePlayer* seqPlayer) {
}
break;
case 0xCD: {
- temp = Audio_M64ReadS16(seqScript);
+ temp = AudioSeq_ScriptReadS16(seqScript);
if ((seqScript->value != -1) && (seqScript->depth != 3)) {
data = seqPlayer->seqData + (u32)(temp + (seqScript->value << 1));
@@ -1649,38 +1647,38 @@ void Audio_SequencePlayerProcessSequence(SequencePlayer* seqPlayer) {
break;
}
case 0xCC:
- seqScript->value = Audio_M64ReadU8(seqScript);
+ seqScript->value = AudioSeq_ScriptReadU8(seqScript);
break;
case 0xC9:
- seqScript->value &= Audio_M64ReadU8(seqScript);
+ seqScript->value &= AudioSeq_ScriptReadU8(seqScript);
break;
case 0xC8:
- seqScript->value -= Audio_M64ReadU8(seqScript);
+ seqScript->value -= AudioSeq_ScriptReadU8(seqScript);
break;
case 0xC7:
- command = Audio_M64ReadU8(seqScript);
- temp = Audio_M64ReadS16(seqScript);
+ command = AudioSeq_ScriptReadU8(seqScript);
+ temp = AudioSeq_ScriptReadS16(seqScript);
data2 = &seqPlayer->seqData[temp];
*data2 = (u8)seqScript->value + command;
break;
case 0xC6:
- seqPlayer->unk_0b2 = true;
+ seqPlayer->stopScript = true;
return;
case 0xC5:
- seqPlayer->unk_E0 = (u16)Audio_M64ReadS16(seqScript);
+ seqPlayer->scriptCounter = (u16)AudioSeq_ScriptReadS16(seqScript);
break;
case 0xEF:
- Audio_M64ReadS16(seqScript);
- Audio_M64ReadU8(seqScript);
+ AudioSeq_ScriptReadS16(seqScript);
+ AudioSeq_ScriptReadU8(seqScript);
break;
case 0xC4:
- command = Audio_M64ReadU8(seqScript);
+ command = AudioSeq_ScriptReadU8(seqScript);
if (command == 0xFF) {
- command = seqPlayer->playerIndex;
+ command = seqPlayer->playerIdx;
}
- commandLow = Audio_M64ReadU8(seqScript);
- func_800E20D4(command, commandLow, 0);
- if (command == (u8)seqPlayer->playerIndex) {
+ commandLow = AudioSeq_ScriptReadU8(seqScript);
+ AudioLoad_SyncInitSeqPlayer(command, commandLow, 0);
+ if (command == (u8)seqPlayer->playerIdx) {
return;
}
break;
@@ -1689,44 +1687,44 @@ void Audio_SequencePlayerProcessSequence(SequencePlayer* seqPlayer) {
commandLow = command & 0x0F;
switch (command & 0xF0) {
- case 0:
+ case 0x00:
seqScript->value = seqPlayer->channels[commandLow]->enabled ^ 1;
break;
case 0x50:
- seqScript->value -= seqPlayer->unk_158[commandLow];
+ seqScript->value -= seqPlayer->soundScriptIO[commandLow];
break;
case 0x70:
- seqPlayer->unk_158[commandLow] = seqScript->value;
+ seqPlayer->soundScriptIO[commandLow] = seqScript->value;
break;
case 0x80:
- seqScript->value = seqPlayer->unk_158[commandLow];
+ seqScript->value = seqPlayer->soundScriptIO[commandLow];
if (commandLow < 2) {
- seqPlayer->unk_158[commandLow] = -1;
+ seqPlayer->soundScriptIO[commandLow] = -1;
}
break;
case 0x40:
- Audio_SequenceChannelDisable(seqPlayer->channels[commandLow]);
+ AudioSeq_SequenceChannelDisable(seqPlayer->channels[commandLow]);
break;
case 0x90:
- temp = Audio_M64ReadS16(seqScript);
- Audio_SequenceChannelEnable(seqPlayer, commandLow, (void*)&seqPlayer->seqData[temp]);
+ temp = AudioSeq_ScriptReadS16(seqScript);
+ AudioSeq_SequenceChannelEnable(seqPlayer, commandLow, (void*)&seqPlayer->seqData[temp]);
break;
case 0xA0:
- tempS = Audio_M64ReadS16(seqScript);
- Audio_SequenceChannelEnable(seqPlayer, commandLow, (void*)&seqScript->pc[tempS]);
+ tempS = AudioSeq_ScriptReadS16(seqScript);
+ AudioSeq_SequenceChannelEnable(seqPlayer, commandLow, (void*)&seqScript->pc[tempS]);
break;
case 0xB0:
- command = Audio_M64ReadU8(seqScript);
- temp = Audio_M64ReadS16(seqScript);
+ command = AudioSeq_ScriptReadU8(seqScript);
+ temp = AudioSeq_ScriptReadS16(seqScript);
data2 = &seqPlayer->seqData[temp];
- Audio_SyncLoadSeq(command, data2, &seqPlayer->unk_158[commandLow]);
+ AudioLoad_SlowLoadSeq(command, data2, &seqPlayer->soundScriptIO[commandLow]);
break;
case 0x60: {
- command = Audio_M64ReadU8(seqScript);
+ command = AudioSeq_ScriptReadU8(seqScript);
value = command;
- temp = Audio_M64ReadU8(seqScript);
+ temp = AudioSeq_ScriptReadU8(seqScript);
- func_800E4EEC(value, temp, &seqPlayer->unk_158[commandLow]);
+ AudioLoad_ScriptLoad(value, temp, &seqPlayer->soundScriptIO[commandLow]);
break;
}
}
@@ -1736,40 +1734,40 @@ void Audio_SequencePlayerProcessSequence(SequencePlayer* seqPlayer) {
for (i = 0; i < ARRAY_COUNT(seqPlayer->channels); i++) {
if (seqPlayer->channels[i]->enabled) {
- Audio_SequenceChannelProcessScript(seqPlayer->channels[i]);
+ AudioSeq_SequenceChannelProcessScript(seqPlayer->channels[i]);
}
}
}
-void Audio_ProcessSequences(s32 arg0) {
+void AudioSeq_ProcessSequences(s32 arg0) {
SequencePlayer* seqPlayer;
u32 i;
gAudioContext.noteSubEuOffset =
- (gAudioContext.audioBufferParameters.updatesPerFrame - arg0 - 1) * gAudioContext.maxSimultaneousNotes;
+ (gAudioContext.audioBufferParameters.updatesPerFrame - arg0 - 1) * gAudioContext.numNotes;
for (i = 0; i < (u32)gAudioContext.audioBufferParameters.numSequencePlayers; i++) {
seqPlayer = &gAudioContext.seqPlayers[i];
if (seqPlayer->enabled == 1) {
- Audio_SequencePlayerProcessSequence(seqPlayer);
+ AudioSeq_SequencePlayerProcessSequence(seqPlayer);
Audio_SequencePlayerProcessSound(seqPlayer);
}
}
Audio_ProcessNotes();
}
-void Audio_ProcessSequence(SequencePlayer* seqPlayer) {
- while (seqPlayer->unk_DC > 0) {
- Audio_SequencePlayerProcessSequence(seqPlayer);
+void AudioSeq_SkipForwardSequence(SequencePlayer* seqPlayer) {
+ while (seqPlayer->skipTicks > 0) {
+ AudioSeq_SequencePlayerProcessSequence(seqPlayer);
Audio_SequencePlayerProcessSound(seqPlayer);
- seqPlayer->unk_DC--;
+ seqPlayer->skipTicks--;
}
}
-void Audio_ResetSequencePlayer(SequencePlayer* seqPlayer) {
+void AudioSeq_ResetSequencePlayer(SequencePlayer* seqPlayer) {
s32 i;
- Audio_SequencePlayerDisable(seqPlayer);
- seqPlayer->unk_0b2 = false;
+ AudioSeq_SequencePlayerDisable(seqPlayer);
+ seqPlayer->stopScript = false;
seqPlayer->delay = 0;
seqPlayer->state = 1;
seqPlayer->fadeTimer = 0;
@@ -1780,40 +1778,40 @@ void Audio_ResetSequencePlayer(SequencePlayer* seqPlayer) {
seqPlayer->transposition = 0;
seqPlayer->noteAllocPolicy = 0;
seqPlayer->shortNoteVelocityTable = gDefaultShortNoteVelocityTable;
- seqPlayer->shortNoteDurationTable = gDefaultShortNoteDurationTable;
- seqPlayer->unk_E0 = 0;
+ seqPlayer->shortNoteGateTimeTable = gDefaultShortNoteGateTimeTable;
+ seqPlayer->scriptCounter = 0;
seqPlayer->fadeVolume = 1.0f;
seqPlayer->fadeVelocity = 0.0f;
seqPlayer->volume = 0.0f;
seqPlayer->muteVolumeScale = 0.5f;
for (i = 0; i < 0x10; i++) {
- Audio_SequenceChannelInit(seqPlayer->channels[i]);
+ AudioSeq_InitSequenceChannel(seqPlayer->channels[i]);
}
}
-void func_800EC734(s32 seqPlayerIdx) {
- SequenceChannel* seqChannel;
- SequencePlayer* seqPlayer = &gAudioContext.seqPlayers[seqPlayerIdx];
+void AudioSeq_InitSequencePlayerChannels(s32 playerIdx) {
+ SequenceChannel* channel;
+ SequencePlayer* seqPlayer = &gAudioContext.seqPlayers[playerIdx];
s32 i, j;
for (i = 0; i < 0x10; i++) {
- seqPlayer->channels[i] = Audio_AllocZeroed(&gAudioContext.notesAndBuffersPool, sizeof(SequenceChannel));
+ seqPlayer->channels[i] = AudioHeap_AllocZeroed(&gAudioContext.notesAndBuffersPool, sizeof(SequenceChannel));
if (seqPlayer->channels[i] == NULL) {
seqPlayer->channels[i] = &gAudioContext.sequenceChannelNone;
} else {
- seqChannel = seqPlayer->channels[i];
- seqChannel->seqPlayer = seqPlayer;
- seqChannel->enabled = false;
+ channel = seqPlayer->channels[i];
+ channel->seqPlayer = seqPlayer;
+ channel->enabled = false;
for (j = 0; j < 4; j++) {
- seqChannel->layers[j] = NULL;
+ channel->layers[j] = NULL;
}
}
- Audio_SequenceChannelInit(seqPlayer->channels[i]);
+ AudioSeq_InitSequenceChannel(seqPlayer->channels[i]);
}
}
-void Audio_InitSequencePlayer(SequencePlayer* seqPlayer) {
+void AudioSeq_InitSequencePlayer(SequencePlayer* seqPlayer) {
s32 i, j;
for (i = 0; i < 0x10; i++) {
@@ -1822,30 +1820,30 @@ void Audio_InitSequencePlayer(SequencePlayer* seqPlayer) {
seqPlayer->enabled = false;
seqPlayer->muted = false;
- seqPlayer->bankDmaInProgress = false;
+ seqPlayer->fontDmaInProgress = false;
seqPlayer->seqDmaInProgress = false;
seqPlayer->unk_0b1 = false;
for (j = 0; j < 8; j++) {
- seqPlayer->unk_158[j] = -1;
+ seqPlayer->soundScriptIO[j] = -1;
}
seqPlayer->muteBehavior = 0x40 | 0x20;
seqPlayer->fadeVolumeScale = 1.0f;
seqPlayer->unk_34 = 1.0f;
Audio_InitNoteLists(&seqPlayer->notePool);
- Audio_ResetSequencePlayer(seqPlayer);
+ AudioSeq_ResetSequencePlayer(seqPlayer);
}
-void Audio_InitSequencePlayers(void) {
+void AudioSeq_InitSequencePlayers(void) {
s32 i;
- Audio_InitLayerFreelist();
+ AudioSeq_InitLayerFreelist();
for (i = 0; i < 64; i++) {
- gAudioContext.sequenceLayers[i].seqChannel = NULL;
+ gAudioContext.sequenceLayers[i].channel = NULL;
gAudioContext.sequenceLayers[i].enabled = false;
}
for (i = 0; i < 4; i++) {
- Audio_InitSequencePlayer(&gAudioContext.seqPlayers[i]);
+ AudioSeq_InitSequencePlayer(&gAudioContext.seqPlayers[i]);
}
}
diff --git a/src/code/audio_synthesis.c b/src/code/audio_synthesis.c
index cd686bf0b..68c5d0cb6 100644
--- a/src/code/audio_synthesis.c
+++ b/src/code/audio_synthesis.c
@@ -112,14 +112,14 @@ void func_800DB03C(s32 arg0) {
s32 baseIndex;
s32 i;
- baseIndex = gAudioContext.maxSimultaneousNotes * arg0;
- for (i = 0; i < gAudioContext.maxSimultaneousNotes; i++) {
+ baseIndex = gAudioContext.numNotes * arg0;
+ for (i = 0; i < gAudioContext.numNotes; i++) {
subEu = &gAudioContext.notes[i].noteSubEu;
subEu2 = &gAudioContext.noteSubsEu[baseIndex + i];
- if (subEu->bitField0.s.enabled) {
- subEu->bitField0.s.needsInit = false;
+ if (subEu->bitField0.enabled) {
+ subEu->bitField0.needsInit = false;
} else {
- subEu2->bitField0.s.enabled = false;
+ subEu2->bitField0.enabled = false;
}
subEu->unk_06 = 0;
@@ -136,7 +136,7 @@ Acmd* AudioSynth_Update(Acmd* cmdStart, s32* cmdCnt, s16* aiStart, s32 aiBufLen)
cmdP = cmdStart;
for (i = gAudioContext.audioBufferParameters.updatesPerFrame; i > 0; i--) {
- Audio_ProcessSequences(i - 1);
+ AudioSeq_ProcessSequences(i - 1);
func_800DB03C(gAudioContext.audioBufferParameters.updatesPerFrame - i);
}
@@ -181,9 +181,9 @@ void func_800DB2C0(s32 updateIndexStart, s32 noteIndex) {
s32 i;
for (i = updateIndexStart + 1; i < gAudioContext.audioBufferParameters.updatesPerFrame; i++) {
- temp_v1 = &gAudioContext.noteSubsEu[(gAudioContext.maxSimultaneousNotes * i) + noteIndex];
- if (!temp_v1->bitField0.s.needsInit) {
- temp_v1->bitField0.s.enabled = 0;
+ temp_v1 = &gAudioContext.noteSubsEu[(gAudioContext.numNotes * i) + noteIndex];
+ if (!temp_v1->bitField0.needsInit) {
+ temp_v1->bitField0.enabled = 0;
} else {
break;
}
@@ -442,11 +442,11 @@ void func_800DBE64(void) {
void func_800DBE6C(void) {
}
-void AudioSynth_SetFilter(Acmd* cmd, s32 flags, s32 countOrBuf, s32 addr) {
+void AudioSynth_LoadFilter(Acmd* cmd, s32 flags, s32 countOrBuf, s32 addr) {
aFilter(cmd, flags, countOrBuf, addr);
}
-void AudioSynth_SetFilterCount(Acmd* cmd, s32 count, s32 addr) {
+void AudioSynth_LoadFilterCount(Acmd* cmd, s32 count, s32 addr) {
aFilter(cmd, 2, count, addr);
}
@@ -563,28 +563,27 @@ Acmd* AudioSynth_DoOneAudioUpdate(s16* aiBuf, s32 aiBufLen, Acmd* cmd, s32 updat
NoteSubEu* noteSubEu2;
s32 unk14;
- t = gAudioContext.maxSimultaneousNotes * updateIndex;
+ t = gAudioContext.numNotes * updateIndex;
count = 0;
if (gAudioContext.numSynthesisReverbs == 0) {
- for (i = 0; i < gAudioContext.maxSimultaneousNotes; i++) {
- if (gAudioContext.noteSubsEu[t + i].bitField0.s.enabled) {
+ for (i = 0; i < gAudioContext.numNotes; i++) {
+ if (gAudioContext.noteSubsEu[t + i].bitField0.enabled) {
noteIndices[count++] = i;
}
}
} else {
for (reverbIndex = 0; reverbIndex < gAudioContext.numSynthesisReverbs; reverbIndex++) {
- for (i = 0; i < gAudioContext.maxSimultaneousNotes; i++) {
+ for (i = 0; i < gAudioContext.numNotes; i++) {
noteSubEu = &gAudioContext.noteSubsEu[t + i];
- if (noteSubEu->bitField0.s.enabled && noteSubEu->bitField1.s.reverbIndex == reverbIndex) {
+ if (noteSubEu->bitField0.enabled && noteSubEu->bitField1.reverbIndex == reverbIndex) {
noteIndices[count++] = i;
}
}
}
- for (i = 0; i < gAudioContext.maxSimultaneousNotes; i++) {
+ for (i = 0; i < gAudioContext.numNotes; i++) {
noteSubEu = &gAudioContext.noteSubsEu[t + i];
- if (noteSubEu->bitField0.s.enabled &&
- noteSubEu->bitField1.s.reverbIndex >= gAudioContext.numSynthesisReverbs) {
+ if (noteSubEu->bitField0.enabled && noteSubEu->bitField1.reverbIndex >= gAudioContext.numSynthesisReverbs) {
noteIndices[count++] = i;
}
}
@@ -620,7 +619,7 @@ Acmd* AudioSynth_DoOneAudioUpdate(s16* aiBuf, s32 aiBufLen, Acmd* cmd, s32 updat
while (i < count) {
noteSubEu2 = &gAudioContext.noteSubsEu[noteIndices[i] + t];
- if (noteSubEu2->bitField1.s.reverbIndex == reverbIndex) {
+ if (noteSubEu2->bitField1.reverbIndex == reverbIndex) {
cmd = AudioSynth_ProcessNote(noteIndices[i], noteSubEu2,
&gAudioContext.notes[noteIndices[i]].synthesisState, aiBuf, aiBufLen, cmd,
updateIndex);
@@ -662,43 +661,43 @@ Acmd* AudioSynth_DoOneAudioUpdate(s16* aiBuf, s32 aiBufLen, Acmd* cmd, s32 updat
Acmd* AudioSynth_ProcessNote(s32 noteIndex, NoteSubEu* noteSubEu, NoteSynthesisState* synthState, s16* aiBuf,
s32 aiBufLen, Acmd* cmd, s32 updateIndex) {
s32 pad1[3];
- AudioBankSample* audioBankSample;
+ SoundFontSample* audioFontSample;
AdpcmLoop* loopInfo;
- s32 samplesRemaining;
+ s32 nSamplesUntilLoopEnd;
s32 nSamplesInThisIteration;
s32 noteFinished;
s32 restart;
s32 flags;
u16 resamplingRateFixedPoint;
- s32 phi_s6;
- s32 phi_s7;
+ s32 nSamplesInFirstFrame;
+ s32 nTrailingSamplesToIgnore;
s32 phi_a1_2;
- s32 temp_v1_5;
- s32 sp120;
+ s32 frameIndex;
+ s32 skipBytes;
s32 temp_v1_6;
void* buf;
- s32 phi_s0;
- s32 sampleAddr;
+ s32 nSamplesToDecode;
+ u32 sampleAddr;
u32 samplesLenFixedPoint;
s32 samplesLenAdjusted;
- s32 nAdpcmSamplesProcessed;
- s32 endPos;
+ s32 nSamplesProcessed;
+ s32 loopEndPos;
s32 nSamplesToProcess;
s32 phi_s4;
- s32 phi_s3;
+ s32 nFirstFrameSamplesToIgnore;
s32 pad2[7];
- s32 spD4;
- s32 phi_s1;
- s32 spCC;
- s32 spC8;
- u8* phi_a1;
+ s32 frameSize;
+ s32 nFramesToDecode;
+ s32 skipInitialSamples;
+ s32 sampleDataStart;
+ u8* sampleData;
s32 nParts;
s32 curPart;
- s32 phi_t0;
+ s32 sampleDataStartPad;
s32 side;
s32 resampledTempLen;
u16 noteSamplesDmemAddrBeforeResampling;
- s32 temp_mult;
+ s32 sampleDataOffset;
s32 thing;
s32 s5;
Note* note;
@@ -712,12 +711,12 @@ Acmd* AudioSynth_ProcessNote(s32 noteIndex, NoteSubEu* noteSubEu, NoteSynthesisS
s16 addr;
u16 unused;
- bookOffset = noteSubEu->bitField1.s.bookOffset;
- finished = noteSubEu->bitField0.s.finished;
+ bookOffset = noteSubEu->bitField1.bookOffset;
+ finished = noteSubEu->bitField0.finished;
note = &gAudioContext.notes[noteIndex];
flags = A_CONTINUE;
- if (noteSubEu->bitField0.s.needsInit == true) {
+ if (noteSubEu->bitField0.needsInit == true) {
flags = A_INIT;
synthState->restart = 0;
synthState->samplePosInt = note->unk_BC;
@@ -727,42 +726,40 @@ Acmd* AudioSynth_ProcessNote(s32 noteIndex, NoteSubEu* noteSubEu, NoteSynthesisS
synthState->prevHeadsetPanRight = 0;
synthState->prevHeadsetPanLeft = 0;
synthState->reverbVol = noteSubEu->reverbVol;
- synthState->numAdpcmParts = 0;
+ synthState->numParts = 0;
synthState->unk_1A = 1;
- note->noteSubEu.bitField0.s.finished = false;
+ note->noteSubEu.bitField0.finished = false;
finished = false;
}
resamplingRateFixedPoint = noteSubEu->resamplingRateFixedPoint;
- nParts = noteSubEu->bitField1.s.hasTwoAdpcmParts + 1;
+ nParts = noteSubEu->bitField1.hasTwoParts + 1;
samplesLenFixedPoint = (resamplingRateFixedPoint * aiBufLen * 2) + synthState->samplePosFrac;
nSamplesToLoad = samplesLenFixedPoint >> 16;
synthState->samplePosFrac = samplesLenFixedPoint & 0xFFFF;
// Partially-optimized out no-op ifs required for matching. SM64 decomp
// makes it clear that this is how it should look.
- if (synthState->numAdpcmParts == 1 && nParts == 2) {
- } else if (synthState->numAdpcmParts == 2 && nParts == 1) {
+ if (synthState->numParts == 1 && nParts == 2) {
+ } else if (synthState->numParts == 2 && nParts == 1) {
} else {
}
- synthState->numAdpcmParts = nParts;
+ synthState->numParts = nParts;
- if (noteSubEu->bitField1.s.isSyntheticWave) {
+ if (noteSubEu->bitField1.isSyntheticWave) {
cmd = AudioSynth_LoadWaveSamples(cmd, noteSubEu, synthState, nSamplesToLoad);
noteSamplesDmemAddrBeforeResampling = DMEM_UNCOMPRESSED_NOTE + (synthState->samplePosInt * 2);
synthState->samplePosInt += nSamplesToLoad;
} else {
- // ADPCM note
- audioBankSample = noteSubEu->sound.audioBankSound->sample;
- loopInfo = audioBankSample->loop;
- endPos = loopInfo->end;
- sampleAddr = audioBankSample->sampleAddr;
+ audioFontSample = noteSubEu->sound.soundFontSound->sample;
+ loopInfo = audioFontSample->loop;
+ loopEndPos = loopInfo->end;
+ sampleAddr = audioFontSample->sampleAddr;
resampledTempLen = 0;
for (curPart = 0; curPart < nParts; curPart++) {
- // reordering in the loop prelude
- nAdpcmSamplesProcessed = 0;
+ nSamplesProcessed = 0;
s5 = 0;
if (nParts == 1) {
@@ -773,8 +770,8 @@ Acmd* AudioSynth_ProcessNote(s32 noteIndex, NoteSubEu* noteSubEu, NoteSynthesisS
samplesLenAdjusted = nSamplesToLoad;
}
- if (audioBankSample->codec == 0 || audioBankSample->codec == 3) {
- if (gAudioContext.curLoadedBook != (*audioBankSample->book).book) {
+ if (audioFontSample->codec == CODEC_ADPCM || audioFontSample->codec == CODEC_SMALL_ADPCM) {
+ if (gAudioContext.curLoadedBook != audioFontSample->book->book) {
u32 nEntries;
switch (bookOffset) {
case 1:
@@ -783,43 +780,43 @@ Acmd* AudioSynth_ProcessNote(s32 noteIndex, NoteSubEu* noteSubEu, NoteSynthesisS
case 2:
case 3:
default:
- gAudioContext.curLoadedBook = (*audioBankSample->book).book;
+ gAudioContext.curLoadedBook = audioFontSample->book->book;
break;
}
if (1) {}
if (1) {}
if (1) {}
- nEntries = 16 * audioBankSample->book->order * audioBankSample->book->npredictors;
+ nEntries = 16 * audioFontSample->book->order * audioFontSample->book->npredictors;
aLoadADPCM(cmd++, nEntries, gAudioContext.curLoadedBook);
}
}
- while (nAdpcmSamplesProcessed != samplesLenAdjusted) {
+ while (nSamplesProcessed != samplesLenAdjusted) {
noteFinished = false;
restart = false;
phi_s4 = 0;
- phi_s3 = synthState->samplePosInt & 0xF;
- samplesRemaining = endPos - synthState->samplePosInt;
- nSamplesToProcess = samplesLenAdjusted - nAdpcmSamplesProcessed;
+ nFirstFrameSamplesToIgnore = synthState->samplePosInt & 0xF;
+ nSamplesUntilLoopEnd = loopEndPos - synthState->samplePosInt;
+ nSamplesToProcess = samplesLenAdjusted - nSamplesProcessed;
- if (phi_s3 == 0 && synthState->restart == false) {
- phi_s3 = 16;
+ if (nFirstFrameSamplesToIgnore == 0 && !synthState->restart) {
+ nFirstFrameSamplesToIgnore = 16;
}
- phi_s6 = 16 - phi_s3;
+ nSamplesInFirstFrame = 16 - nFirstFrameSamplesToIgnore;
- if (nSamplesToProcess < samplesRemaining) {
- phi_s1 = (s32)(nSamplesToProcess - phi_s6 + 15) / 16;
- phi_s0 = phi_s1 * 16;
- phi_s7 = phi_s6 + phi_s0 - nSamplesToProcess;
+ if (nSamplesToProcess < nSamplesUntilLoopEnd) {
+ nFramesToDecode = (s32)(nSamplesToProcess - nSamplesInFirstFrame + 15) / 16;
+ nSamplesToDecode = nFramesToDecode * 16;
+ nTrailingSamplesToIgnore = nSamplesInFirstFrame + nSamplesToDecode - nSamplesToProcess;
} else {
- phi_s0 = samplesRemaining - phi_s6;
- phi_s7 = 0;
- if (phi_s0 <= 0) {
- phi_s0 = 0;
- phi_s6 = samplesRemaining;
+ nSamplesToDecode = nSamplesUntilLoopEnd - nSamplesInFirstFrame;
+ nTrailingSamplesToIgnore = 0;
+ if (nSamplesToDecode <= 0) {
+ nSamplesToDecode = 0;
+ nSamplesInFirstFrame = nSamplesUntilLoopEnd;
}
- phi_s1 = (phi_s0 + 15) / 16;
+ nFramesToDecode = (nSamplesToDecode + 15) / 16;
if (loopInfo->count != 0) {
// Loop around and restart
restart = true;
@@ -828,111 +825,114 @@ Acmd* AudioSynth_ProcessNote(s32 noteIndex, NoteSubEu* noteSubEu, NoteSynthesisS
}
}
- switch (audioBankSample->codec) {
+ switch (audioFontSample->codec) {
case CODEC_ADPCM:
- spD4 = 9;
- spCC = 0x10;
- spC8 = 0;
+ frameSize = 9;
+ skipInitialSamples = 16;
+ sampleDataStart = 0;
break;
- case 3:
- spD4 = 5;
- spCC = 0x10;
- spC8 = 0;
+ case CODEC_SMALL_ADPCM:
+ frameSize = 5;
+ skipInitialSamples = 16;
+ sampleDataStart = 0;
break;
case CODEC_S8:
- spD4 = 0x10;
- spCC = 0x10;
- spC8 = 0;
+ frameSize = 16;
+ skipInitialSamples = 16;
+ sampleDataStart = 0;
break;
- case 2:
+ case CODEC_S16_INMEMORY:
AudioSynth_ClearBuffer(cmd++, DMEM_UNCOMPRESSED_NOTE, (samplesLenAdjusted * 2) + 0x20);
flags = A_CONTINUE;
- sp120 = 0;
- nAdpcmSamplesProcessed = samplesLenAdjusted;
+ skipBytes = 0;
+ nSamplesProcessed = samplesLenAdjusted;
s5 = samplesLenAdjusted;
goto skip;
- case 5:
+ case CODEC_S16:
AudioSynth_ClearBuffer(cmd++, DMEM_UNCOMPRESSED_NOTE, (samplesLenAdjusted * 2) + 0x20);
flags = A_CONTINUE;
- sp120 = 0;
- nAdpcmSamplesProcessed = samplesLenAdjusted;
+ skipBytes = 0;
+ nSamplesProcessed = samplesLenAdjusted;
s5 = samplesLenAdjusted;
goto skip;
- case 4:
+ case CODEC_REVERB:
break;
}
- if (phi_s1 != 0) {
- temp_v1_5 = (synthState->samplePosInt + spCC - phi_s3) / 16;
- temp_mult = (temp_v1_5 * spD4);
- if (audioBankSample->medium == 0) {
- phi_a1 = spC8 + temp_mult + sampleAddr;
- } else if (audioBankSample->medium == 1) {
+ if (nFramesToDecode != 0) {
+ frameIndex = (synthState->samplePosInt + skipInitialSamples - nFirstFrameSamplesToIgnore) / 16;
+ sampleDataOffset = frameIndex * frameSize;
+ if (audioFontSample->medium == MEDIUM_RAM) {
+ sampleData = (u8*)(sampleDataStart + sampleDataOffset + sampleAddr);
+ } else if (audioFontSample->medium == MEDIUM_UNK) {
return cmd;
} else {
- phi_a1 =
- Audio_DmaSampleData((u32)(spC8 + temp_mult + sampleAddr), ALIGN16((phi_s1 * spD4) + 0x10),
- flags, &synthState->sampleDmaIndex, audioBankSample->medium);
+ sampleData = AudioLoad_DmaSampleData(sampleDataStart + sampleDataOffset + sampleAddr,
+ ALIGN16((nFramesToDecode * frameSize) + 0x10), flags,
+ &synthState->sampleDmaIndex, audioFontSample->medium);
}
- if (phi_a1 == NULL) {
+ if (sampleData == NULL) {
return cmd;
}
- phi_t0 = (u32)phi_a1 & 0xF;
- aligned = ALIGN16((phi_s1 * spD4) + 16);
+ sampleDataStartPad = (u32)sampleData & 0xF;
+ aligned = ALIGN16((nFramesToDecode * frameSize) + 16);
addr = DMEM_COMPRESSED_ADPCM_DATA - aligned;
- aLoadBuffer(cmd++, phi_a1 - phi_t0, addr, aligned);
+ aLoadBuffer(cmd++, sampleData - sampleDataStartPad, addr, aligned);
} else {
- phi_s0 = 0;
- phi_t0 = 0;
+ nSamplesToDecode = 0;
+ sampleDataStartPad = 0;
}
if (synthState->restart) {
- aSetLoop(cmd++, audioBankSample->loop->state);
+ aSetLoop(cmd++, audioFontSample->loop->state);
flags = A_LOOP;
synthState->restart = false;
}
- nSamplesInThisIteration = phi_s0 + phi_s6 - phi_s7;
- if (nAdpcmSamplesProcessed == 0) {
+ nSamplesInThisIteration = nSamplesToDecode + nSamplesInFirstFrame - nTrailingSamplesToIgnore;
+ if (nSamplesProcessed == 0) {
if (1) {}
- sp120 = phi_s3 * 2;
+ skipBytes = nFirstFrameSamplesToIgnore * 2;
} else {
phi_s4 = ALIGN16(s5 + 16);
}
- switch (audioBankSample->codec) {
+ switch (audioFontSample->codec) {
case CODEC_ADPCM:
- aligned = ALIGN16((phi_s1 * spD4) + 0x10);
+ aligned = ALIGN16((nFramesToDecode * frameSize) + 0x10);
addr = DMEM_COMPRESSED_ADPCM_DATA - aligned;
- aSetBuffer(cmd++, 0, addr + phi_t0, DMEM_UNCOMPRESSED_NOTE + phi_s4, phi_s0 * 2);
+ aSetBuffer(cmd++, 0, addr + sampleDataStartPad, DMEM_UNCOMPRESSED_NOTE + phi_s4,
+ nSamplesToDecode * 2);
aADPCMdec(cmd++, flags, synthState->synthesisBuffers->adpcmdecState);
break;
- case 3:
- aligned = ALIGN16((phi_s1 * spD4) + 0x10);
+ case CODEC_SMALL_ADPCM:
+ aligned = ALIGN16((nFramesToDecode * frameSize) + 0x10);
addr = DMEM_COMPRESSED_ADPCM_DATA - aligned;
- aSetBuffer(cmd++, 0, addr + phi_t0, DMEM_UNCOMPRESSED_NOTE + phi_s4, phi_s0 * 2);
+ aSetBuffer(cmd++, 0, addr + sampleDataStartPad, DMEM_UNCOMPRESSED_NOTE + phi_s4,
+ nSamplesToDecode * 2);
aADPCMdec(cmd++, flags | 4, synthState->synthesisBuffers->adpcmdecState);
break;
case CODEC_S8:
- aligned = ALIGN16((phi_s1 * spD4) + 0x10);
+ aligned = ALIGN16((nFramesToDecode * frameSize) + 0x10);
addr = DMEM_COMPRESSED_ADPCM_DATA - aligned;
- AudioSynth_SetBuffer(cmd++, 0, addr + phi_t0, DMEM_UNCOMPRESSED_NOTE + phi_s4, phi_s0 * 2);
+ AudioSynth_SetBuffer(cmd++, 0, addr + sampleDataStartPad, DMEM_UNCOMPRESSED_NOTE + phi_s4,
+ nSamplesToDecode * 2);
AudioSynth_S8Dec(cmd++, flags, synthState->synthesisBuffers->adpcmdecState);
break;
}
- if (nAdpcmSamplesProcessed != 0) {
- aDMEMMove(cmd++, DMEM_UNCOMPRESSED_NOTE + phi_s4 + (phi_s3 * 2), DMEM_UNCOMPRESSED_NOTE + s5,
- nSamplesInThisIteration * 2);
+ if (nSamplesProcessed != 0) {
+ aDMEMMove(cmd++, DMEM_UNCOMPRESSED_NOTE + phi_s4 + (nFirstFrameSamplesToIgnore * 2),
+ DMEM_UNCOMPRESSED_NOTE + s5, nSamplesInThisIteration * 2);
}
- nAdpcmSamplesProcessed += nSamplesInThisIteration;
+ nSamplesProcessed += nSamplesInThisIteration;
switch (flags) {
case A_INIT:
- sp120 = 0x20;
- s5 = (phi_s0 + 0x10) * 2;
+ skipBytes = 0x20;
+ s5 = (nSamplesToDecode + 0x10) * 2;
break;
case A_LOOP:
s5 = nSamplesInThisIteration * 2 + s5;
@@ -941,7 +941,7 @@ Acmd* AudioSynth_ProcessNote(s32 noteIndex, NoteSubEu* noteSubEu, NoteSynthesisS
if (s5 != 0) {
s5 = nSamplesInThisIteration * 2 + s5;
} else {
- s5 = (phi_s3 + nSamplesInThisIteration) * 2;
+ s5 = (nFirstFrameSamplesToIgnore + nSamplesInThisIteration) * 2;
}
break;
}
@@ -951,9 +951,9 @@ Acmd* AudioSynth_ProcessNote(s32 noteIndex, NoteSubEu* noteSubEu, NoteSynthesisS
skip:
if (noteFinished) {
AudioSynth_ClearBuffer(cmd++, DMEM_UNCOMPRESSED_NOTE + s5,
- (samplesLenAdjusted - nAdpcmSamplesProcessed) * 2);
+ (samplesLenAdjusted - nSamplesProcessed) * 2);
finished = true;
- note->noteSubEu.bitField0.s.finished = true;
+ note->noteSubEu.bitField0.finished = true;
func_800DB2C0(updateIndex, noteIndex);
break;
} else {
@@ -968,12 +968,12 @@ Acmd* AudioSynth_ProcessNote(s32 noteIndex, NoteSubEu* noteSubEu, NoteSynthesisS
switch (nParts) {
case 1:
- noteSamplesDmemAddrBeforeResampling = DMEM_UNCOMPRESSED_NOTE + sp120;
+ noteSamplesDmemAddrBeforeResampling = DMEM_UNCOMPRESSED_NOTE + skipBytes;
break;
case 2:
switch (curPart) {
case 0:
- AudioSynth_InterL(cmd++, DMEM_UNCOMPRESSED_NOTE + sp120, DMEM_TEMP + 0x20,
+ AudioSynth_InterL(cmd++, DMEM_UNCOMPRESSED_NOTE + skipBytes, DMEM_TEMP + 0x20,
((samplesLenAdjusted / 2) + 7) & ~7);
resampledTempLen = samplesLenAdjusted;
noteSamplesDmemAddrBeforeResampling = DMEM_TEMP + 0x20;
@@ -983,7 +983,7 @@ Acmd* AudioSynth_ProcessNote(s32 noteIndex, NoteSubEu* noteSubEu, NoteSynthesisS
}
break;
case 1:
- AudioSynth_InterL(cmd++, DMEM_UNCOMPRESSED_NOTE + sp120,
+ AudioSynth_InterL(cmd++, DMEM_UNCOMPRESSED_NOTE + skipBytes,
DMEM_TEMP + 0x20 + resampledTempLen, ((samplesLenAdjusted / 2) + 7) & ~7);
break;
}
@@ -995,8 +995,8 @@ Acmd* AudioSynth_ProcessNote(s32 noteIndex, NoteSubEu* noteSubEu, NoteSynthesisS
}
flags = A_CONTINUE;
- if (noteSubEu->bitField0.s.needsInit == true) {
- noteSubEu->bitField0.s.needsInit = false;
+ if (noteSubEu->bitField0.needsInit == true) {
+ noteSubEu->bitField0.needsInit = false;
flags = A_INIT;
}
@@ -1020,8 +1020,8 @@ Acmd* AudioSynth_ProcessNote(s32 noteIndex, NoteSubEu* noteSubEu, NoteSynthesisS
filter = noteSubEu->filter;
if (filter != 0) {
- AudioSynth_SetFilterCount(cmd++, aiBufLen * 2, filter);
- AudioSynth_SetFilter(cmd++, flags, DMEM_TEMP, synthState->synthesisBuffers->mixEnvelopeState);
+ AudioSynth_LoadFilterCount(cmd++, aiBufLen * 2, filter);
+ AudioSynth_LoadFilter(cmd++, flags, DMEM_TEMP, synthState->synthesisBuffers->mixEnvelopeState);
}
unk7 = noteSubEu->unk_07;
@@ -1051,7 +1051,7 @@ Acmd* AudioSynth_ProcessNote(s32 noteIndex, NoteSubEu* noteSubEu, NoteSynthesisS
side = 0;
}
cmd = AudioSynth_ProcessEnvelope(cmd, noteSubEu, synthState, aiBufLen, DMEM_TEMP, side, flags);
- if (noteSubEu->bitField1.s.usesHeadsetPanEffects2) {
+ if (noteSubEu->bitField1.usesHeadsetPanEffects2) {
if (!(flags & A_INIT)) {
flags = A_CONTINUE;
}
@@ -1118,7 +1118,7 @@ Acmd* AudioSynth_ProcessEnvelope(Acmd* cmd, NoteSubEu* noteSubEu, NoteSynthesisS
synthState->curVolLeft = curVolLeft + (rampLeft * (aiBufLen >> 3));
synthState->curVolRight = curVolRight + (rampRight * (aiBufLen >> 3));
- if (noteSubEu->bitField1.s.usesHeadsetPanEffects2) {
+ if (noteSubEu->bitField1.usesHeadsetPanEffects2) {
AudioSynth_ClearBuffer(cmd++, DMEM_NOTE_PAN_TEMP, DEFAULT_LEN_1CH);
AudioSynth_EnvSetup1(cmd++, phi_t1 * 2, rampReverb, rampLeft, rampRight);
AudioSynth_EnvSetup2(cmd++, curVolLeft, curVolRight);
@@ -1139,9 +1139,9 @@ Acmd* AudioSynth_ProcessEnvelope(Acmd* cmd, NoteSubEu* noteSubEu, NoteSynthesisS
phi_a1 = D_801304AC;
}
- aEnvMixer(cmd++, inBuf, aiBufLen, (sourceReverbVol & 0x80) >> 7, noteSubEu->bitField0.s.stereoHeadsetEffects,
- noteSubEu->bitField0.s.usesHeadsetPanEffects, noteSubEu->bitField0.s.stereoStrongRight,
- noteSubEu->bitField0.s.stereoStrongLeft, phi_a1, D_801304A0);
+ aEnvMixer(cmd++, inBuf, aiBufLen, (sourceReverbVol & 0x80) >> 7, noteSubEu->bitField0.stereoHeadsetEffects,
+ noteSubEu->bitField0.usesHeadsetPanEffects, noteSubEu->bitField0.stereoStrongRight,
+ noteSubEu->bitField0.stereoStrongLeft, phi_a1, D_801304A0);
return cmd;
}
@@ -1151,7 +1151,7 @@ Acmd* AudioSynth_LoadWaveSamples(Acmd* cmd, NoteSubEu* noteSubEu, NoteSynthesisS
s32 samplePosInt = synthState->samplePosInt;
s32 repeats;
- if (noteSubEu->bitField1.s.bookOffset != 0) {
+ if (noteSubEu->bitField1.bookOffset != 0) {
AudioSynth_LoadBuffer(cmd++, DMEM_UNCOMPRESSED_NOTE, ALIGN16(nSamplesToLoad * 2), gWaveSamples[8]);
gWaveSamples[8] += nSamplesToLoad * 2;
return cmd;
diff --git a/src/code/code_8006BA00.c b/src/code/code_8006BA00.c
index e3549db8b..6919827fb 100644
--- a/src/code/code_8006BA00.c
+++ b/src/code/code_8006BA00.c
@@ -16,7 +16,7 @@ void func_8006BA30(GlobalContext* globalCtx) {
for (i = 0; i < ARRAY_COUNT(globalCtx->soundSources); i++) {
if (source->countdown != 0) {
if (DECR(source->countdown) == 0) {
- func_800F89E8(&source->relativePos);
+ Audio_StopSfxByPos(&source->relativePos);
} else {
SkinMatrix_Vec3fMtxFMultXYZ(&globalCtx->mf_11D60, &source->originPos, &source->relativePos);
}
@@ -49,7 +49,7 @@ void Audio_PlaySoundAtPosition(GlobalContext* globalCtx, Vec3f* pos, s32 duratio
if (i >= ARRAY_COUNT(globalCtx->soundSources)) {
source = backupSource;
- func_800F89E8(&source->relativePos);
+ Audio_StopSfxByPos(&source->relativePos);
}
source->originPos = *pos;
diff --git a/src/code/code_800C3C20.c b/src/code/code_800C3C20.c
index 72596fbf2..bd3b37850 100644
--- a/src/code/code_800C3C20.c
+++ b/src/code/code_800C3C20.c
@@ -8,6 +8,6 @@ void func_800C3C20(void) {
s32 i;
for (i = 0; (i < ARRAY_COUNT(D_8012D200)) & 0xFFFFFFFF; i++) {
- func_800F87A0(D_8012D200[i]);
+ Audio_StopSfxByBank(D_8012D200[i]);
}
}
diff --git a/src/code/code_800E4FE0.c b/src/code/code_800E4FE0.c
index 6371bf2bb..102012fa7 100644
--- a/src/code/code_800E4FE0.c
+++ b/src/code/code_800E4FE0.c
@@ -107,12 +107,12 @@ AudioTask* func_800E5000(void) {
}
gAudioContext.curAudioFrameDmaCount = 0;
- func_800E11F0();
- Audio_ProcessLoads(gAudioContext.resetStatus);
- func_800E4F58();
+ AudioLoad_DecreaseSampleDmaTtls();
+ AudioLoad_ProcessLoads(gAudioContext.resetStatus);
+ AudioLoad_ProcessScriptLoads();
if (gAudioContext.resetStatus != 0) {
- if (Audio_ResetStep() == 0) {
+ if (AudioHeap_ResetStep() == 0) {
if (gAudioContext.resetStatus == 0) {
osSendMesg(gAudioContext.audioResetQueueP, gAudioContext.audioResetSpecIdToLoad, OS_MESG_NOBLOCK);
}
@@ -217,19 +217,19 @@ void func_800E5584(AudioCmd* cmd) {
switch (cmd->op) {
case 0x81:
- func_800E1C18(cmd->arg1, cmd->arg2);
+ AudioLoad_SyncLoadSeqParts(cmd->arg1, cmd->arg2);
return;
case 0x82:
- func_800E20D4(cmd->arg0, cmd->arg1, cmd->arg2);
+ AudioLoad_SyncInitSeqPlayer(cmd->arg0, cmd->arg1, cmd->arg2);
func_800E59AC(cmd->arg0, cmd->data);
return;
case 0x85:
- func_800E2124(cmd->arg0, cmd->arg1, cmd->data);
+ AudioLoad_SyncInitSeqPlayerSkipTicks(cmd->arg0, cmd->arg1, cmd->data);
return;
case 0x83:
if (gAudioContext.seqPlayers[cmd->arg0].enabled) {
if (cmd->asInt == 0) {
- Audio_SequencePlayerDisableAsFinished(&gAudioContext.seqPlayers[cmd->arg0]);
+ AudioSeq_SequencePlayerDisableAsFinished(&gAudioContext.seqPlayers[cmd->arg0]);
} else {
func_800E5958(cmd->arg0, cmd->asInt);
}
@@ -247,12 +247,12 @@ void func_800E5584(AudioCmd* cmd) {
return;
case 0xF2:
if (cmd->asUInt == 1) {
- for (i = 0; i < gAudioContext.maxSimultaneousNotes; i++) {
+ for (i = 0; i < gAudioContext.numNotes; i++) {
Note* note = &gAudioContext.notes[i];
NoteSubEu* subEu = &note->noteSubEu;
- if (subEu->bitField0.s.enabled && note->playbackState.unk_04 == 0) {
- if (note->playbackState.parentLayer->seqChannel->muteBehavior & 8) {
- subEu->bitField0.s.finished = 1;
+ if (subEu->bitField0.enabled && note->playbackState.unk_04 == 0) {
+ if (note->playbackState.parentLayer->channel->muteBehavior & 8) {
+ subEu->bitField0.finished = 1;
}
}
}
@@ -266,19 +266,19 @@ void func_800E5584(AudioCmd* cmd) {
return;
case 0xF3:
- func_800E1D64(cmd->arg0, cmd->arg1, cmd->arg2);
+ AudioLoad_SyncLoadInstrument(cmd->arg0, cmd->arg1, cmd->arg2);
return;
case 0xF4:
- Audio_AudioTableAsyncLoad(cmd->arg0, cmd->arg1, cmd->arg2, &gAudioContext.unk_1E20);
+ AudioLoad_AsyncLoadSampleBank(cmd->arg0, cmd->arg1, cmd->arg2, &gAudioContext.externalLoadQueue);
return;
case 0xF5:
- Audio_AudioBankAsyncLoad(cmd->arg0, cmd->arg1, cmd->arg2, &gAudioContext.unk_1E20);
+ AudioLoad_AsyncLoadFont(cmd->arg0, cmd->arg1, cmd->arg2, &gAudioContext.externalLoadQueue);
return;
case 0xFC:
- Audio_AudioSeqAsyncLoad(cmd->arg0, cmd->arg1, cmd->arg2, &gAudioContext.unk_1E20);
+ AudioLoad_AsyncLoadSeq(cmd->arg0, cmd->arg1, cmd->arg2, &gAudioContext.externalLoadQueue);
return;
case 0xF6:
- func_800E1F7C(cmd->arg1);
+ AudioLoad_DiscardSeqFonts(cmd->arg1);
return;
case 0x90:
gAudioContext.unk_5BDC[cmd->arg0] = cmd->asUShort;
@@ -293,7 +293,7 @@ void func_800E5584(AudioCmd* cmd) {
case 0xE0:
case 0xE1:
case 0xE2:
- func_800E7744(cmd->op - 0xE0, cmd->arg0, cmd->arg1, cmd->data);
+ Audio_SetFontInstrument(cmd->op - 0xE0, cmd->arg0, cmd->arg1, cmd->data);
return;
case 0xFE:
temp_t7 = cmd->asUInt;
@@ -301,14 +301,14 @@ void func_800E5584(AudioCmd* cmd) {
for (i = 0; i < gAudioContext.audioBufferParameters.numSequencePlayers; i++) {
SequencePlayer* seqPlayer = &gAudioContext.seqPlayers[i];
if (seqPlayer->enabled) {
- Audio_SequencePlayerDisableAsFinished(seqPlayer);
+ AudioSeq_SequencePlayerDisableAsFinished(seqPlayer);
}
}
}
func_800E66C0(temp_t7);
return;
case 0xE3:
- func_800DE4B0(cmd->asInt);
+ AudioHeap_PopCache(cmd->asInt);
return;
default:
return;
@@ -478,24 +478,24 @@ void Audio_ProcessCmds(u32 msg) {
}
}
-u32 func_800E5E20(u32* arg0) {
+u32 func_800E5E20(u32* out) {
u32 sp1C;
- if (osRecvMesg(&gAudioContext.unk_1E20, (OSMesg*)&sp1C, OS_MESG_NOBLOCK) == -1) {
- *arg0 = 0;
+ if (osRecvMesg(&gAudioContext.externalLoadQueue, (OSMesg*)&sp1C, OS_MESG_NOBLOCK) == -1) {
+ *out = 0;
return 0;
}
- *arg0 = sp1C & 0xFFFFFF;
+ *out = sp1C & 0xFFFFFF;
return sp1C >> 0x18;
}
u8* func_800E5E84(s32 arg0, u32* arg1) {
- return func_800E1F38(arg0, arg1);
+ return AudioLoad_GetFontsForSequence(arg0, arg1);
}
void func_800E5EA4(s32 arg0, u32* arg1, u32* arg2) {
- *arg1 = gAudioContext.ctlEntries[arg0].unk_02;
- *arg2 = gAudioContext.ctlEntries[arg0].unk_03;
+ *arg1 = gAudioContext.soundFonts[arg0].sampleBankId1;
+ *arg2 = gAudioContext.soundFonts[arg0].sampleBankId2;
}
s32 func_800E5EDC(void) {
@@ -563,15 +563,15 @@ s8 func_800E6070(s32 playerIdx, s32 channelIdx, s32 scriptIdx) {
}
s8 func_800E60C4(s32 arg0, s32 arg1) {
- return gAudioContext.seqPlayers[arg0].unk_158[arg1];
+ return gAudioContext.seqPlayers[arg0].soundScriptIO[arg1];
}
-void func_800E60EC(void* memAddr, u32 size) {
- Audio_SoundAllocPoolInit(&gAudioContext.unkPool, memAddr, size);
+void Audio_InitExternalPool(void* mem, u32 size) {
+ AudioHeap_AllocPoolInit(&gAudioContext.externalPool, mem, size);
}
-void func_800E611C(void) {
- gAudioContext.unkPool.start = NULL;
+void Audio_DestroyExternalPool(void) {
+ gAudioContext.externalPool.start = NULL;
}
void func_800E6128(SequencePlayer* seqPlayer, AudioCmd* cmd) {
@@ -596,7 +596,7 @@ void func_800E6128(SequencePlayer* seqPlayer, AudioCmd* cmd) {
seqPlayer->transposition = cmd->asSbyte;
return;
case 0x46:
- seqPlayer->unk_158[cmd->arg2] = cmd->asSbyte;
+ seqPlayer->soundScriptIO[cmd->arg2] = cmd->asSbyte;
return;
case 0x4A:
fadeVolume = (s32)cmd->arg1 / 127.0f;
@@ -725,9 +725,9 @@ void Audio_WaitForAudioTask(void) {
s32 func_800E6590(s32 arg0, s32 arg1, s32 arg2) {
SequencePlayer* seqPlayer;
- SequenceChannelLayer* layer;
+ SequenceLayer* layer;
Note* note;
- AudioBankSound* sound;
+ SoundFontSound* sound;
s32 loopEnd;
s32 samplePos;
@@ -749,7 +749,7 @@ s32 func_800E6590(s32 arg0, s32 arg1, s32 arg2) {
note = layer->note;
if (layer == note->playbackState.parentLayer) {
- sound = note->noteSubEu.sound.audioBankSound;
+ sound = note->noteSubEu.sound.soundFontSound;
if (sound == NULL) {
return 0;
}
@@ -777,21 +777,21 @@ s32 func_800E66C0(s32 arg0) {
NoteSubEu* temp_a3;
s32 i;
Note* note;
- AudioBankSound* sound;
+ SoundFontSound* sound;
phi_v1 = 0;
- for (i = 0; i < gAudioContext.maxSimultaneousNotes; i++) {
+ for (i = 0; i < gAudioContext.numNotes; i++) {
note = &gAudioContext.notes[i];
temp_a2 = &note->playbackState;
- if (note->noteSubEu.bitField0.s.enabled) {
+ if (note->noteSubEu.bitField0.enabled) {
temp_a3 = &note->noteSubEu;
if (temp_a2->adsr.action.s.state != 0) {
if (arg0 >= 2) {
- sound = temp_a3->sound.audioBankSound;
- if (sound == NULL || temp_a3->bitField1.s.isSyntheticWave) {
+ sound = temp_a3->sound.soundFontSound;
+ if (sound == NULL || temp_a3->bitField1.isSyntheticWave) {
continue;
}
- if (sound->sample->medium == 0) {
+ if (sound->sample->medium == MEDIUM_RAM) {
continue;
}
}
diff --git a/src/code/code_800EC960.c b/src/code/code_800EC960.c
index 74d20e6b8..0b5695855 100644
--- a/src/code/code_800EC960.c
+++ b/src/code/code_800EC960.c
@@ -3,34 +3,35 @@
// TODO: can these macros be shared between files? code_800F9280 seems to use
// versions without any casts...
-#define Audio_DisableSeq(seqIdx, fadeOut) Audio_QueueCmdS32(0x83000000 | ((u8)seqIdx << 16), fadeOut)
-#define Audio_StartSeq(seqIdx, fadeTimer, seqId) \
- Audio_QueueSeqCmd(0x00000000 | ((u8)seqIdx << 24) | ((u8)(fadeTimer) << 0x10) | (u16)seqId)
-#define Audio_SeqCmd7(seqIdx, a, b) Audio_QueueSeqCmd(0x70000000 | ((u8)seqIdx << 0x18) | ((u8)a << 0x10) | (u8)(b))
-#define Audio_SeqCmdC(seqIdx, a, b, c) \
- Audio_QueueSeqCmd(0xC0000000 | ((u8)seqIdx << 24) | ((u8)a << 16) | ((u8)b << 8) | ((u8)(c)))
-#define Audio_SeqCmdA(seqIdx, a) Audio_QueueSeqCmd(0xA0000000 | ((u8)seqIdx << 24) | ((u16)(a)))
-#define Audio_SeqCmd1(seqIdx, a) Audio_QueueSeqCmd(0x100000FF | ((u8)seqIdx << 24) | ((u8)(a) << 16))
-#define Audio_SeqCmdB(seqIdx, a, b, c) \
- Audio_QueueSeqCmd(0xB0000000 | ((u8)seqIdx << 24) | ((u8)a << 16) | ((u8)b << 8) | ((u8)c))
-#define Audio_SeqCmdB40(seqIdx, a, b) Audio_QueueSeqCmd(0xB0004000 | ((u8)seqIdx << 24) | ((u8)a << 16) | ((u8)b))
-#define Audio_SeqCmd6(seqIdx, a, b, c) \
- Audio_QueueSeqCmd(0x60000000 | ((u8)seqIdx << 24) | ((u8)(a) << 16) | ((u8)b << 8) | ((u8)c))
-#define Audio_SeqCmdE0(seqIdx, a) Audio_QueueSeqCmd(0xE0000000 | ((u8)seqIdx << 24) | ((u8)a))
-#define Audio_SeqCmdE01(seqIdx, a) Audio_QueueSeqCmd(0xE0000100 | ((u8)seqIdx << 24) | ((u16)a))
-#define Audio_SeqCmd8(seqIdx, a, b, c) \
- Audio_QueueSeqCmd(0x80000000 | ((u8)seqIdx << 24) | ((u8)a << 16) | ((u8)b << 8) | ((u8)c))
-#define Audio_SeqCmdF(seqIdx, a) Audio_QueueSeqCmd(0xF0000000 | ((u8)seqIdx << 24) | ((u8)a))
+#define Audio_DisableSeq(playerIdx, fadeOut) Audio_QueueCmdS32(0x83000000 | ((u8)playerIdx << 16), fadeOut)
+#define Audio_StartSeq(playerIdx, fadeTimer, seqId) \
+ Audio_QueueSeqCmd(0x00000000 | ((u8)playerIdx << 24) | ((u8)(fadeTimer) << 0x10) | (u16)seqId)
+#define Audio_SeqCmd7(playerIdx, a, b) \
+ Audio_QueueSeqCmd(0x70000000 | ((u8)playerIdx << 0x18) | ((u8)a << 0x10) | (u8)(b))
+#define Audio_SeqCmdC(playerIdx, a, b, c) \
+ Audio_QueueSeqCmd(0xC0000000 | ((u8)playerIdx << 24) | ((u8)a << 16) | ((u8)b << 8) | ((u8)(c)))
+#define Audio_SeqCmdA(playerIdx, a) Audio_QueueSeqCmd(0xA0000000 | ((u8)playerIdx << 24) | ((u16)(a)))
+#define Audio_SeqCmd1(playerIdx, a) Audio_QueueSeqCmd(0x100000FF | ((u8)playerIdx << 24) | ((u8)(a) << 16))
+#define Audio_SeqCmdB(playerIdx, a, b, c) \
+ Audio_QueueSeqCmd(0xB0000000 | ((u8)playerIdx << 24) | ((u8)a << 16) | ((u8)b << 8) | ((u8)c))
+#define Audio_SeqCmdB40(playerIdx, a, b) Audio_QueueSeqCmd(0xB0004000 | ((u8)playerIdx << 24) | ((u8)a << 16) | ((u8)b))
+#define Audio_SeqCmd6(playerIdx, a, b, c) \
+ Audio_QueueSeqCmd(0x60000000 | ((u8)playerIdx << 24) | ((u8)(a) << 16) | ((u8)b << 8) | ((u8)c))
+#define Audio_SeqCmdE0(playerIdx, a) Audio_QueueSeqCmd(0xE0000000 | ((u8)playerIdx << 24) | ((u8)a))
+#define Audio_SeqCmdE01(playerIdx, a) Audio_QueueSeqCmd(0xE0000100 | ((u8)playerIdx << 24) | ((u16)a))
+#define Audio_SeqCmd8(playerIdx, a, b, c) \
+ Audio_QueueSeqCmd(0x80000000 | ((u8)playerIdx << 24) | ((u8)a << 16) | ((u8)b << 8) | ((u8)c))
+#define Audio_SeqCmdF(playerIdx, a) Audio_QueueSeqCmd(0xF0000000 | ((u8)playerIdx << 24) | ((u8)a))
typedef struct {
- /* 0x0 */ f32 unk_00;
+ /* 0x0 */ f32 vol;
/* 0x4 */ f32 freqScale;
/* 0x8 */ s8 reverb;
/* 0x9 */ s8 panSigned;
/* 0xA */ s8 stereoBits;
- /* 0xB */ u8 unk_0B;
+ /* 0xB */ u8 filter;
/* 0xC */ u8 unk_0C;
-} unk_s1;
+} SfxPlayerState;
typedef struct {
/* 0x0 */ f32 value;
@@ -54,11 +55,11 @@ typedef enum {
/* 0x5 */ PAGE_SUB_TRACK_INFO,
/* 0x6 */ PAGE_CHANNEL_INFO, // unused
/* 0x7 */ PAGE_INTERFACE_INFO,
- /* 0x8 */ PAGE_SE_FLAG_SWAP,
+ /* 0x8 */ PAGE_SFX_SWAP,
/* 0x9 */ PAGE_BLOCK_CHANGE_BGM,
/* 0xA */ PAGE_NATURAL_SOUND_CONTROL, // unused
/* 0xB */ PAGE_OCARINA_TEST,
- /* 0xC */ PAGE_SE_PARAMETER_CHANGE,
+ /* 0xC */ PAGE_SFX_PARAMETER_CHANGE,
/* 0xD */ PAGE_SCROLL_PRINT,
/* 0xE */ PAGE_FREE_AREA,
/* 0xF */ PAGE_MAX
@@ -81,16 +82,23 @@ typedef enum {
#define SCROLL_PRINT_BUF_SIZE 25
+#define OCA_SONGS_SCARECROW 12
+#define OCA_SONGS_MEMORYGAME 13
+
+#define SFX_PLAYER_CHANNEL_OCARINA 13
+
extern f32 D_8012F6B4[]; // from audio_synthesis
-u8 D_80130570[7] = { 0, 0, 0, 1, 0, 0, 0 };
-u8 D_80130578[4][7] = {
+u8 gIsLargeSoundBank[7] = { 0, 0, 0, 1, 0, 0, 0 };
+
+// Only the first row of these is supported by sequence 0. (gSfxChannelLayout is always 0.)
+u8 gChannelsPerBank[4][7] = {
{ 3, 2, 3, 3, 2, 1, 2 },
{ 3, 2, 2, 2, 2, 2, 2 },
{ 3, 2, 2, 2, 2, 2, 2 },
{ 4, 1, 0, 0, 2, 2, 2 },
};
-u8 D_80130594[4][7] = {
+u8 gUsedChannelsPerBank[4][7] = {
{ 3, 2, 3, 2, 2, 1, 1 },
{ 3, 1, 1, 1, 2, 1, 1 },
{ 3, 1, 1, 1, 2, 1, 1 },
@@ -102,7 +110,7 @@ s8 D_801305B4 = 35;
s8 D_801305B8 = 20;
s8 D_801305BC = 30;
s8 D_801305C0 = 20;
-f32 D_801305C4[2] = { -15.0f, -65.0f };
+f32 sBehindScreenZ[2] = { -15.0f, -65.0f };
u8 sAudioIncreasingTranspose = 0;
u8 gMorphaTransposeTable[16] = { 0, 0, 0, 1, 1, 2, 4, 6, 8, 8, 8, 8, 8, 8, 8, 8 };
u8 sPrevChargeLevel = 0;
@@ -124,10 +132,10 @@ u8 D_8013062C = 0;
u8 D_80130630 = NA_BGM_GENERAL_SFX;
u32 D_80130634 = 0;
u32 D_80130638 = 0;
-u8 D_8013063C = 0;
-u8 D_80130640 = 0;
-u8 D_80130644 = 0;
-u8 D_80130648 = 0;
+u8 sAudioBaseFilter = 0;
+u8 sAudioExtraFilter = 0;
+u8 sAudioBaseFilter2 = 0;
+u8 sAudioExtraFilter2 = 0;
Vec3f* sSariaBgmPtr = NULL;
f32 D_80130650 = 2000.0f;
u8 D_80130654 = 0;
@@ -207,7 +215,7 @@ f32 sNormalizedNotePlaybackTone = 1.0f;
f32 sNormalizedNotePlaybackVolume = 1.0f;
s32 D_80130F68 = 0;
u8 sOcarinaNoteValues[5] = { 2, 5, 9, 11, 14 };
-u8 sOcaMinigameApndPos = 0;
+u8 sOcaMinigameAppendPos = 0;
u8 sOcaMinigameEndPos = 0;
u8 sOcaMinigameNoteCnts[] = { 5, 6, 8 };
@@ -356,7 +364,7 @@ OcarinaNote sOcarinaSongs[14][20] = {
{ 0xFF, 0, 0, 255, 0, 0, 0 },
},
- // OCA_MEMORYGAME_IDX
+ // OCA_SONGS_MEMORYGAME
{
{ 2, 0, 3, 0, 0, 0, 0 },
{ 0xFF, 0, 0, 0, 0, 0, 0 },
@@ -384,8 +392,8 @@ OcarinaNote sPierresSong[108] = {
};
OcarinaNote* gScarecrowCustomSongPtr = sPierresSong;
-u8* gScarecrowSpawnSongPtr = (u8*)&sOcarinaSongs[12];
-OcarinaNote* D_80131BEC = sOcarinaSongs[13];
+u8* gScarecrowSpawnSongPtr = (u8*)&sOcarinaSongs[OCA_SONGS_SCARECROW];
+OcarinaNote* D_80131BEC = sOcarinaSongs[OCA_SONGS_MEMORYGAME];
u8 sNoteValueIndexMap[16] = { 0, 0, 0, 0, 1, 1, 1, 2, 2, 2, 5, 3, 3, 4, 4, 4 };
// clang-format off
@@ -408,7 +416,7 @@ OcarinaSongInfo gOcarinaSongNotes[14] = {
// clang-format on
extern u8 D_801333F0;
-extern u8 gAudioSEFlagSwapOff;
+extern u8 gAudioSfxSwapOff;
extern u8 D_80133408;
extern u8 D_80133418;
@@ -436,7 +444,7 @@ u8 D_8016B8B1;
u8 D_8016B8B2;
u8 D_8016B8B3;
u8 sAudioGanonDistVol;
-unk_s1 D_8016B8B8[0x10];
+SfxPlayerState sSfxChannelState[0x10];
char sBinToStrBuf[0x20];
u8 D_8016B9D8;
@@ -482,9 +490,9 @@ u32 sDebugPadPress;
s32 sAudioUpdateTaskStart;
s32 sAudioUpdateTaskEnd;
-extern u16 gAudioSEFlagSwapSource[];
-extern u16 gAudioSEFlagSwapTarget[];
-extern u8 gAudioSEFlagSwapMode[];
+extern u16 gAudioSfxSwapSource[];
+extern u16 gAudioSfxSwapTarget[];
+extern u8 gAudioSfxSwapMode[];
void PadMgr_RequestPadData(PadMgr* padmgr, Input* inputs, s32 mode);
@@ -577,7 +585,7 @@ void func_800ECB7C(u8 songIdx) {
while (savedSongIdx < 8 && scarecrowSongIdx < 0x10) {
noteIdx = sOcarinaSongs[songIdx][scarecrowSongIdx++].noteIdx;
if (noteIdx != 0xFF) {
- gOcarinaSongNotes[12].notesIdx[savedSongIdx++] = sNoteValueIndexMap[noteIdx];
+ gOcarinaSongNotes[OCA_SONGS_SCARECROW].notesIdx[savedSongIdx++] = sNoteValueIndexMap[noteIdx];
}
}
}
@@ -586,15 +594,15 @@ void func_800ECB7C(u8 songIdx) {
void func_800ECC04(u16 flg) {
u8 i;
- if ((sOcarinaSongs[12][1].volume != 0xFF) && ((flg & 0xFFF) == 0xFFF)) {
+ if ((sOcarinaSongs[OCA_SONGS_SCARECROW][1].volume != 0xFF) && ((flg & 0xFFF) == 0xFFF)) {
flg |= 0x1000;
}
- if ((flg == 0xCFFF) && (sOcarinaSongs[12][1].volume != 0xFF)) {
+ if ((flg == 0xCFFF) && (sOcarinaSongs[OCA_SONGS_SCARECROW][1].volume != 0xFF)) {
flg = 0xDFFF;
}
- if ((flg == 0xFFF) && (sOcarinaSongs[12][1].volume != 0xFF)) {
+ if ((flg == 0xFFF) && (sOcarinaSongs[OCA_SONGS_SCARECROW][1].volume != 0xFF)) {
flg = 0x1FFF;
}
@@ -857,7 +865,7 @@ void func_800ED458(s32 arg0) {
Audio_QueueCmdS8(0x6020D05, sCurOcarinaBtnVal);
Audio_PlaySoundGeneral(NA_SE_OC_OCARINA, &D_801333D4, 4, &D_80130F24, &D_80130F28, &D_801333E8);
} else if ((sPrevOcarinaNoteVal != 0xFF) && (sCurOcarinaBtnVal == 0xFF)) {
- Audio_StopSfx(NA_SE_OC_OCARINA);
+ Audio_StopSfxById(NA_SE_OC_OCARINA);
}
}
}
@@ -871,7 +879,7 @@ void func_800ED858(u8 arg0) {
return;
}
- Audio_SeqCmd8(2, 1, 0xD, arg0);
+ Audio_SeqCmd8(2, 1, SFX_PLAYER_CHANNEL_OCARINA, arg0);
D_80130F10 = arg0;
if (arg0 == 0) {
sCurOcarinaBtnPress = 0;
@@ -879,25 +887,25 @@ void func_800ED858(u8 arg0) {
D_8016BA18 = 0;
D_8016BA10 = 0xFFFF;
func_800ED458(0);
- Audio_StopSfx(NA_SE_OC_OCARINA);
+ Audio_StopSfxById(NA_SE_OC_OCARINA);
Audio_SetSoundBanksMute(0);
sPlaybackState = 0;
sStaffPlaybackPos = 0;
sOcarinaInpEnabled = 0;
D_80130F3C = 0;
- Audio_ClearBGMMute(0xD);
+ Audio_ClearBGMMute(SFX_PLAYER_CHANNEL_OCARINA);
} else {
sCurOcarinaBtnPress = 0;
Audio_GetOcaInput();
D_8016BA10 = sCurOcarinaBtnPress;
- Audio_QueueSeqCmdMute(0xD);
+ Audio_QueueSeqCmdMute(SFX_PLAYER_CHANNEL_OCARINA);
}
}
void func_800ED93C(s8 songIdx, s8 arg1) {
if (songIdx == 0) {
sPlaybackState = 0;
- Audio_StopSfx(NA_SE_OC_OCARINA);
+ Audio_StopSfxById(NA_SE_OC_OCARINA);
return;
}
@@ -950,7 +958,7 @@ void Audio_OcaPlayback(void) {
sStaffPlaybackPos = 0;
sDisplayedNoteValue = 0xFF;
} else {
- Audio_StopSfx(NA_SE_OC_OCARINA);
+ Audio_StopSfxById(NA_SE_OC_OCARINA);
}
return;
} else {
@@ -993,7 +1001,7 @@ void Audio_OcaPlayback(void) {
Audio_PlaySoundGeneral(NA_SE_OC_OCARINA, &D_801333D4, 4, &sNormalizedNotePlaybackTone,
&sNormalizedNotePlaybackVolume, &D_801333E8);
} else {
- Audio_StopSfx(NA_SE_OC_OCARINA);
+ Audio_StopSfxById(NA_SE_OC_OCARINA);
}
}
sPlaybackNotePos++;
@@ -1004,8 +1012,8 @@ void Audio_OcaPlayback(void) {
void func_800EDD68(u8 arg0) {
u16 i;
u16 i2;
- u16 mad2;
- u8 mad;
+ u16 pad;
+ u8 lastNote;
OcarinaNote* note;
u8 j;
u8 k;
@@ -1035,10 +1043,10 @@ void func_800EDD68(u8 arg0) {
}
i = sRecordSongPos;
- mad = 0xFF;
- while (i != 0 && mad == 0xFF) {
+ lastNote = 0xFF;
+ while (i != 0 && lastNote == 0xFF) {
i--;
- mad = song[i].noteIdx;
+ lastNote = song[i].noteIdx;
}
if (1) {}
@@ -1056,19 +1064,20 @@ void func_800EDD68(u8 arg0) {
song[i] = song[i + 1];
}
- func_800ECB7C(0xD);
+ func_800ECB7C(OCA_SONGS_MEMORYGAME);
- for (i = 0; i < 12; i++) {
+ for (i = 0; i < OCA_SONGS_SCARECROW; i++) {
for (j = 0; j < 9 - gOcarinaSongNotes[i].len; j++) {
- for (k = 0; k < gOcarinaSongNotes[i].len && k + j < 8 &&
- gOcarinaSongNotes[i].notesIdx[k] == gOcarinaSongNotes[12].notesIdx[k + j];
+ for (k = 0;
+ k < gOcarinaSongNotes[i].len && k + j < 8 &&
+ gOcarinaSongNotes[i].notesIdx[k] == gOcarinaSongNotes[OCA_SONGS_SCARECROW].notesIdx[k + j];
k++) {
;
}
if (k == gOcarinaSongNotes[i].len) {
D_80131858 = 0xFF;
- sOcarinaSongs[12][1].volume = 0xFF;
+ sOcarinaSongs[OCA_SONGS_SCARECROW][1].volume = 0xFF;
return;
}
}
@@ -1076,7 +1085,8 @@ void func_800EDD68(u8 arg0) {
i = 1;
while (i < 8) {
- if (gOcarinaSongNotes[12].notesIdx[0] != gOcarinaSongNotes[12].notesIdx[i]) {
+ if (gOcarinaSongNotes[OCA_SONGS_SCARECROW].notesIdx[0] !=
+ gOcarinaSongNotes[OCA_SONGS_SCARECROW].notesIdx[i]) {
i = 9;
} else {
i++;
@@ -1085,17 +1095,17 @@ void func_800EDD68(u8 arg0) {
if (i == 8) {
D_80131858 = 0xFF;
- sOcarinaSongs[12][1].volume = 0xFF;
+ sOcarinaSongs[OCA_SONGS_SCARECROW][1].volume = 0xFF;
return;
}
for (i = 0; i < sRecordSongPos; i++) {
- sOcarinaSongs[12][i] = sOcarinaSongs[13][i];
+ sOcarinaSongs[OCA_SONGS_SCARECROW][i] = sOcarinaSongs[OCA_SONGS_MEMORYGAME][i];
}
sOcarinaInpEnabled = 0;
} else {
- sOcarinaSongs[12][1].volume = 0xFF;
+ sOcarinaSongs[OCA_SONGS_SCARECROW][1].volume = 0xFF;
}
}
D_80131858 = 0;
@@ -1232,7 +1242,7 @@ void func_800EE57C(u8 minigameIdx) {
minigameIdx = 2;
}
- sOcaMinigameApndPos = 0;
+ sOcaMinigameAppendPos = 0;
sOcaMinigameEndPos = sOcaMinigameNoteCnts[minigameIdx];
for (i = 0; i < 3; i++) {
@@ -1240,34 +1250,33 @@ void func_800EE57C(u8 minigameIdx) {
}
}
-#define OCA_MEMORYGAME_IDX 0xD
s32 func_800EE5EC(void) {
u32 rnd;
u8 rndNote;
- if (sOcaMinigameApndPos == sOcaMinigameEndPos) {
+ if (sOcaMinigameAppendPos == sOcaMinigameEndPos) {
return 1;
}
rnd = Audio_NextRandom();
rndNote = sOcarinaNoteValues[rnd % 5];
- if (sOcarinaSongs[OCA_MEMORYGAME_IDX][sOcaMinigameApndPos - 1].noteIdx == rndNote) {
+ if (sOcarinaSongs[OCA_SONGS_MEMORYGAME][sOcaMinigameAppendPos - 1].noteIdx == rndNote) {
rndNote = sOcarinaNoteValues[(rnd + 1) % 5];
}
- sOcarinaSongs[OCA_MEMORYGAME_IDX][sOcaMinigameApndPos].noteIdx = rndNote;
- sOcarinaSongs[OCA_MEMORYGAME_IDX][sOcaMinigameApndPos].unk_02 = 0x2D;
- sOcarinaSongs[OCA_MEMORYGAME_IDX][sOcaMinigameApndPos].volume = 0x50;
- sOcarinaSongs[OCA_MEMORYGAME_IDX][sOcaMinigameApndPos].vibrato = 0;
- sOcarinaSongs[OCA_MEMORYGAME_IDX][sOcaMinigameApndPos].tone = 0;
+ sOcarinaSongs[OCA_SONGS_MEMORYGAME][sOcaMinigameAppendPos].noteIdx = rndNote;
+ sOcarinaSongs[OCA_SONGS_MEMORYGAME][sOcaMinigameAppendPos].unk_02 = 0x2D;
+ sOcarinaSongs[OCA_SONGS_MEMORYGAME][sOcaMinigameAppendPos].volume = 0x50;
+ sOcarinaSongs[OCA_SONGS_MEMORYGAME][sOcaMinigameAppendPos].vibrato = 0;
+ sOcarinaSongs[OCA_SONGS_MEMORYGAME][sOcaMinigameAppendPos].tone = 0;
- sOcaMinigameApndPos++;
+ sOcaMinigameAppendPos++;
- sOcarinaSongs[OCA_MEMORYGAME_IDX][sOcaMinigameApndPos].noteIdx = 0xFF;
- sOcarinaSongs[OCA_MEMORYGAME_IDX][sOcaMinigameApndPos].unk_02 = 0;
- sOcarinaSongs[OCA_MEMORYGAME_IDX][sOcaMinigameApndPos + 1].noteIdx = 0xFF;
- sOcarinaSongs[OCA_MEMORYGAME_IDX][sOcaMinigameApndPos + 1].unk_02 = 0;
+ sOcarinaSongs[OCA_SONGS_MEMORYGAME][sOcaMinigameAppendPos].noteIdx = 0xFF;
+ sOcarinaSongs[OCA_SONGS_MEMORYGAME][sOcaMinigameAppendPos].unk_02 = 0;
+ sOcarinaSongs[OCA_SONGS_MEMORYGAME][sOcaMinigameAppendPos + 1].noteIdx = 0xFF;
+ sOcarinaSongs[OCA_SONGS_MEMORYGAME][sOcaMinigameAppendPos + 1].unk_02 = 0;
if (1) {}
return 0;
}
@@ -1363,7 +1372,7 @@ f32 D_80131C8C = 0.0f;
f32 sAudioUpdateDuration = 0.0f;
f32 sAudioUpdateDurationMax = 0.0f;
u8 sAudioDebugEverOpened = 0;
-u8 sAudioSEMuted = 0;
+u8 sAudioSfxMuted = 0;
u8 sAudioDebugPage = 0;
u8 sAudioSndContSel = 0;
u8 sAudioDebugTextColor = 7;
@@ -1400,13 +1409,13 @@ s8 sAudioScrPrtY = 1;
u8 sAudioScrPrtWork[11] = { 1, 19, 6, 0, 0, 0, 0, 0, 0, 0, 1 };
u8 sAudioScrPrtWorkLims[11] = { 2, SCROLL_PRINT_BUF_SIZE, 8, 2, 2, 2, 2, 2, 2, 2, 2 };
u8 sAudioSubTrackInfoSpec = 0;
-u8 sAudioSEFlagSwapIsEditing = 0;
-u8 sAudioSEFlagSwapSel = 0;
-u8 sAudioSEFlagSwapNibbleSel = 0;
-char sAudioSEFlagSwapModeNames[2][5] = { "SWAP", "ADD" };
-u8 sAudioSEParamChgSel = 0;
-u8 sAudioSEParamChgBitSel = 0;
-u16 sAudioSEParamChgWork[4] = { 0 };
+u8 sAudioSfxSwapIsEditing = 0;
+u8 sAudioSfxSwapSel = 0;
+u8 sAudioSfxSwapNibbleSel = 0;
+char sAudioSfxSwapModeNames[2][5] = { "SWAP", "ADD" };
+u8 sAudioSfxParamChgSel = 0;
+u8 sAudioSfxParamChgBitSel = 0;
+u16 sAudioSfxParamChgWork[4] = { 0 };
u8 sAudioSubTrackInfoPlayerSel = 0;
u8 sAudioSubTrackInfoChannelSel = 0;
u8 sSeqPlayerPeakNumLayers[20] = { 0 };
@@ -1469,8 +1478,8 @@ void AudioDebug_Draw(GfxPrint* printer) {
GfxPrint_SetPos(printer, 3, 3);
GfxPrint_Printf(printer, "- %s -", sAudioDebugPageNames[sAudioDebugPage]);
- for (i = 0; i < gAudioSpecs[gAudioSpecId].maxSimultaneousNotes; i++) {
- if (gAudioContext.notes[i].noteSubEu.bitField0.s.enabled == 1) {
+ for (i = 0; i < gAudioSpecs[gAudioSpecId].numNotes; i++) {
+ if (gAudioContext.notes[i].noteSubEu.bitField0.enabled == 1) {
numEnabledNotes++;
}
}
@@ -1520,7 +1529,7 @@ void AudioDebug_Draw(GfxPrint* printer) {
GfxPrint_Printf(printer, "BGM CANCEL:%s", sBoolStrs[sAudioSndContWork[5]]);
GfxPrint_SetPos(printer, 3, 5);
- GfxPrint_Printf(printer, "SE MUTE:%s", sBoolStrs[sAudioSEMuted]);
+ GfxPrint_Printf(printer, "SE MUTE:%s", sBoolStrs[sAudioSfxMuted]);
GfxPrint_SetPos(printer, 18, 4);
SETCOL(255, 255, 255);
@@ -1535,8 +1544,8 @@ void AudioDebug_Draw(GfxPrint* printer) {
while (i != 0xFF) {
GfxPrint_SetPos(printer, 3, 7 + j++);
- GfxPrint_Printf(printer, "%02x %04x %02x %08x", i, gSoundBanks[ind][i].sfxId,
- gSoundBanks[ind][i].unk_2A, gSoundBanks[ind][i].priority);
+ GfxPrint_Printf(printer, "%02x %04x %02x %08x", i, gSoundBanks[ind][i].sfxId, gSoundBanks[ind][i].state,
+ gSoundBanks[ind][i].priority);
i = gSoundBanks[ind][i].next;
}
break;
@@ -1592,13 +1601,14 @@ void AudioDebug_Draw(GfxPrint* printer) {
GfxPrint_SetPos(printer, 2 + sAudioIntInfoX, 4 + ind + sAudioIntInfoY);
GfxPrint_Printf(printer, "%s <%d>", sSoundBankNames[k], sAudioIntInfoBankPage[k]);
- for (k2 = 0; k2 < D_80130578[D_801333CC][k]; k2++) {
-#define entryIndex (D_8016E1B8[k][k2].unk_4)
+ for (k2 = 0; k2 < gChannelsPerBank[gSfxChannelLayout][k]; k2++) {
+#define entryIndex (gActiveSounds[k][k2].entryIndex)
#define entry (&gSoundBanks[k][entryIndex])
-#define chan (gAudioContext.seqPlayers[2].channels[entry->unk_2E])
+#define chan (gAudioContext.seqPlayers[2].channels[entry->channelIdx])
GfxPrint_SetPos(printer, 2 + sAudioIntInfoX, 5 + ind + sAudioIntInfoY);
if (sAudioIntInfoBankPage[k] == 1) {
- if ((entryIndex != 0xFF) && ((entry->unk_2A == 4) || (entry->unk_2A == 5))) {
+ if ((entryIndex != 0xFF) &&
+ ((entry->state == SFX_STATE_PLAYING_1) || (entry->state == SFX_STATE_PLAYING_2))) {
GfxPrint_Printf(printer, "%2X %5d %5d %5d %02X %04X %04X", entryIndex, (s32)*entry->posX,
(s32)*entry->posY, (s32)*entry->posZ, entry->sfxImportance,
entry->sfxParams, entry->sfxId);
@@ -1606,7 +1616,8 @@ void AudioDebug_Draw(GfxPrint* printer) {
GfxPrint_Printf(printer, "FF ----- ----- ----- -- ---- ----");
}
} else if (sAudioIntInfoBankPage[k] == 2) {
- if ((entryIndex != 0xFF) && ((entry->unk_2A == 4) || (entry->unk_2A == 5))) {
+ if ((entryIndex != 0xFF) &&
+ ((entry->state == SFX_STATE_PLAYING_1) || (entry->state == SFX_STATE_PLAYING_2))) {
GfxPrint_Printf(printer, "%2X %5d %5d %5d %3d %3d %04X", entryIndex, (s32)*entry->posX,
(s32)*entry->posY, (s32)*entry->posZ, (s32)(chan->volume * 127.1f),
chan->newPan, entry->sfxId);
@@ -1614,7 +1625,8 @@ void AudioDebug_Draw(GfxPrint* printer) {
GfxPrint_Printf(printer, "FF ----- ----- ----- --- --- ----");
}
} else if (sAudioIntInfoBankPage[k] == 3) {
- if ((entryIndex != 0xFF) && ((entry->unk_2A == 4) || (entry->unk_2A == 5))) {
+ if ((entryIndex != 0xFF) &&
+ ((entry->state == SFX_STATE_PLAYING_1) || (entry->state == SFX_STATE_PLAYING_2))) {
GfxPrint_Printf(printer, "%2X %5d %5d %5d %3d %3d %04X", entryIndex, (s32)*entry->posX,
(s32)*entry->posY, (s32)*entry->posZ, (s32)(chan->freqScale * 100.0f),
chan->reverb, entry->sfxId);
@@ -1622,7 +1634,8 @@ void AudioDebug_Draw(GfxPrint* printer) {
GfxPrint_Printf(printer, "FF ----- ----- ----- --- --- ----");
}
} else if (sAudioIntInfoBankPage[k] == 4) {
- if ((entryIndex != 0xFF) && ((entry->unk_2A == 4) || (entry->unk_2A == 5))) {
+ if ((entryIndex != 0xFF) &&
+ ((entry->state == SFX_STATE_PLAYING_1) || (entry->state == SFX_STATE_PLAYING_2))) {
GfxPrint_Printf(printer, "%2X %04X", entryIndex, entry->sfxId);
} else {
GfxPrint_Printf(printer, "FF ----");
@@ -1680,46 +1693,46 @@ void AudioDebug_Draw(GfxPrint* printer) {
GfxPrint_Printf(printer, "SEQ ENT : %d", sAudioScrPrtWork[10]);
break;
- case PAGE_SE_FLAG_SWAP:
+ case PAGE_SFX_SWAP:
GfxPrint_SetPos(printer, 3, 4);
SETCOL(255, 255, 255);
- if (gAudioSEFlagSwapOff) {
+ if (gAudioSfxSwapOff) {
GfxPrint_Printf(printer, "SWAP OFF");
}
- if (sAudioSEFlagSwapIsEditing == 0) {
+ if (sAudioSfxSwapIsEditing == 0) {
SETCOL(255, 255, 255);
} else {
SETCOL(127, 127, 127);
}
- GfxPrint_SetPos(printer, 2, 6 + sAudioSEFlagSwapSel);
+ GfxPrint_SetPos(printer, 2, 6 + sAudioSfxSwapSel);
GfxPrint_Printf(printer, "*");
- ctr = sAudioSEFlagSwapNibbleSel;
- if (sAudioSEFlagSwapNibbleSel >= 4) {
+ ctr = sAudioSfxSwapNibbleSel;
+ if (sAudioSfxSwapNibbleSel >= 4) {
ctr++;
}
- if (sAudioSEFlagSwapIsEditing == 1) {
+ if (sAudioSfxSwapIsEditing == 1) {
SETCOL(255, 255, 255);
GfxPrint_SetPos(printer, 3 + ctr, 5);
GfxPrint_Printf(printer, "V");
}
for (i = 0; i < 10; i++) {
- if (i == sAudioSEFlagSwapSel) {
- if (sAudioSEFlagSwapIsEditing == 0) {
+ if (i == sAudioSfxSwapSel) {
+ if (sAudioSfxSwapIsEditing == 0) {
SETCOL(192, 192, 192);
} else {
SETCOL(255, 255, 255);
}
- } else if (sAudioSEFlagSwapIsEditing == 0) {
+ } else if (sAudioSfxSwapIsEditing == 0) {
SETCOL(144, 144, 144);
} else {
SETCOL(96, 96, 96);
}
GfxPrint_SetPos(printer, 3, 6 + i);
- GfxPrint_Printf(printer, "%04x %04x %s", gAudioSEFlagSwapSource[i], gAudioSEFlagSwapTarget[i],
- sAudioSEFlagSwapModeNames[gAudioSEFlagSwapMode[i]]);
+ GfxPrint_Printf(printer, "%04x %04x %s", gAudioSfxSwapSource[i], gAudioSfxSwapTarget[i],
+ sAudioSfxSwapModeNames[gAudioSfxSwapMode[i]]);
}
break;
@@ -1849,7 +1862,7 @@ void AudioDebug_Draw(GfxPrint* printer) {
GfxPrint_Printf(printer, "%X",
gAudioContext.seqPlayers[sAudioSubTrackInfoPlayerSel]
.channels[sAudioSubTrackInfoChannelSel]
- ->bankId);
+ ->fontId);
ctr = (u8)(gAudioContext.seqPlayers[sAudioSubTrackInfoPlayerSel]
.channels[sAudioSubTrackInfoChannelSel]
@@ -1916,7 +1929,7 @@ void AudioDebug_Draw(GfxPrint* printer) {
case PAGE_HEAP_INFO:
SETCOL(255, 255, 255);
GfxPrint_SetPos(printer, 3, 4);
- GfxPrint_Printf(printer, "TOTAL %d", D_8014A6C4.heap);
+ GfxPrint_Printf(printer, "TOTAL %d", D_8014A6C4.heapSize);
GfxPrint_SetPos(printer, 3, 5);
GfxPrint_Printf(printer, "DRIVER %05X / %05X",
@@ -1925,44 +1938,40 @@ void AudioDebug_Draw(GfxPrint* printer) {
GfxPrint_SetPos(printer, 3, 6);
GfxPrint_Printf(
- printer, "AT-SEQ %02X-%02X (%05X-%05X / %05X)", (u8)gAudioContext.seqLoadedPool.temporary.entries[0].id,
- (u8)gAudioContext.seqLoadedPool.temporary.entries[1].id,
- gAudioContext.seqLoadedPool.temporary.entries[0].size,
- gAudioContext.seqLoadedPool.temporary.entries[1].size, gAudioContext.seqLoadedPool.temporary.pool.size);
+ printer, "AT-SEQ %02X-%02X (%05X-%05X / %05X)", (u8)gAudioContext.seqCache.temporary.entries[0].id,
+ (u8)gAudioContext.seqCache.temporary.entries[1].id, gAudioContext.seqCache.temporary.entries[0].size,
+ gAudioContext.seqCache.temporary.entries[1].size, gAudioContext.seqCache.temporary.pool.size);
GfxPrint_SetPos(printer, 3, 7);
- GfxPrint_Printf(printer, "AT-BNK %02X-%02X (%05X-%05X / %05X)",
- (u8)gAudioContext.bankLoadedPool.temporary.entries[0].id,
- (u8)gAudioContext.bankLoadedPool.temporary.entries[1].id,
- gAudioContext.bankLoadedPool.temporary.entries[0].size,
- gAudioContext.bankLoadedPool.temporary.entries[1].size,
- gAudioContext.bankLoadedPool.temporary.pool.size);
+ GfxPrint_Printf(
+ printer, "AT-BNK %02X-%02X (%05X-%05X / %05X)", (u8)gAudioContext.fontCache.temporary.entries[0].id,
+ (u8)gAudioContext.fontCache.temporary.entries[1].id, gAudioContext.fontCache.temporary.entries[0].size,
+ gAudioContext.fontCache.temporary.entries[1].size, gAudioContext.fontCache.temporary.pool.size);
GfxPrint_SetPos(printer, 3, 8);
- GfxPrint_Printf(
- printer, "ST-SEQ %02Xseqs (%05X / %06X)", gAudioContext.seqLoadedPool.persistent.numEntries,
- gAudioContext.seqLoadedPool.persistent.pool.cur - gAudioContext.seqLoadedPool.persistent.pool.start,
- gAudioContext.seqLoadedPool.persistent.pool.size);
+ GfxPrint_Printf(printer, "ST-SEQ %02Xseqs (%05X / %06X)", gAudioContext.seqCache.persistent.numEntries,
+ gAudioContext.seqCache.persistent.pool.cur - gAudioContext.seqCache.persistent.pool.start,
+ gAudioContext.seqCache.persistent.pool.size);
- for (k = 0; (u32)k < gAudioContext.seqLoadedPool.persistent.numEntries; k++) {
+ for (k = 0; (u32)k < gAudioContext.seqCache.persistent.numEntries; k++) {
GfxPrint_SetPos(printer, 3 + 3 * k, 9);
- GfxPrint_Printf(printer, "%02x", gAudioContext.seqLoadedPool.persistent.entries[k].id);
+ GfxPrint_Printf(printer, "%02x", gAudioContext.seqCache.persistent.entries[k].id);
}
GfxPrint_SetPos(printer, 3, 10);
- GfxPrint_Printf(
- printer, "ST-BNK %02Xbanks (%05X / %06X)", gAudioContext.bankLoadedPool.persistent.numEntries,
- gAudioContext.bankLoadedPool.persistent.pool.cur - gAudioContext.bankLoadedPool.persistent.pool.start,
- gAudioContext.bankLoadedPool.persistent.pool.size);
+ GfxPrint_Printf(printer, "ST-BNK %02Xbanks (%05X / %06X)", gAudioContext.fontCache.persistent.numEntries,
+ gAudioContext.fontCache.persistent.pool.cur - gAudioContext.fontCache.persistent.pool.start,
+ gAudioContext.fontCache.persistent.pool.size);
- for (k = 0; (u32)k < gAudioContext.bankLoadedPool.persistent.numEntries; k++) {
+ for (k = 0; (u32)k < gAudioContext.fontCache.persistent.numEntries; k++) {
GfxPrint_SetPos(printer, 3 + 3 * k, 11);
- GfxPrint_Printf(printer, "%02x", gAudioContext.bankLoadedPool.persistent.entries[k].id);
+ GfxPrint_Printf(printer, "%02x", gAudioContext.fontCache.persistent.entries[k].id);
}
GfxPrint_SetPos(printer, 3, 12);
- GfxPrint_Printf(printer, "E-MEM %05X / %05X", gAudioContext.unk_2D50.cur - gAudioContext.unk_2D50.start,
- gAudioContext.unk_2D50.size);
+ GfxPrint_Printf(printer, "E-MEM %05X / %05X",
+ gAudioContext.permanentPool.cur - gAudioContext.permanentPool.start,
+ gAudioContext.permanentPool.size);
break;
case PAGE_BLOCK_CHANGE_BGM:
@@ -1980,28 +1989,30 @@ void AudioDebug_Draw(GfxPrint* printer) {
SETCOL(255, 255, 255);
GfxPrint_SetPos(printer, 3, 7);
- GfxPrint_Printf(printer, "NEXT SCENE %02X %s", (u8)gAudioContext.seqPlayers[0].unk_158[2],
- sAudioSceneNames[(u8)gAudioContext.seqPlayers[0].unk_158[2]]);
+ GfxPrint_Printf(printer, "NEXT SCENE %02X %s", (u8)gAudioContext.seqPlayers[0].soundScriptIO[2],
+ sAudioSceneNames[(u8)gAudioContext.seqPlayers[0].soundScriptIO[2]]);
GfxPrint_SetPos(printer, 3, 8);
- GfxPrint_Printf(printer, "NOW SCENE %02X %s", (u8)gAudioContext.seqPlayers[0].unk_158[4],
- sAudioSceneNames[(u8)gAudioContext.seqPlayers[0].unk_158[4]]);
+ GfxPrint_Printf(printer, "NOW SCENE %02X %s", (u8)gAudioContext.seqPlayers[0].soundScriptIO[4],
+ sAudioSceneNames[(u8)gAudioContext.seqPlayers[0].soundScriptIO[4]]);
GfxPrint_SetPos(printer, 3, 9);
- GfxPrint_Printf(printer, "NOW BLOCK %02X", (gAudioContext.seqPlayers[0].unk_158[5] + 1) & 0xFF);
+ GfxPrint_Printf(printer, "NOW BLOCK %02X", (gAudioContext.seqPlayers[0].soundScriptIO[5] + 1) & 0xFF);
GfxPrint_SetPos(printer, 3, 11);
GfxPrint_Printf(printer, "PORT");
GfxPrint_SetPos(printer, 3, 12);
- GfxPrint_Printf(printer, "%02X %02X %02X %02X", (u8)gAudioContext.seqPlayers[0].unk_158[0],
- (u8)gAudioContext.seqPlayers[0].unk_158[1], (u8)gAudioContext.seqPlayers[0].unk_158[2],
- (u8)gAudioContext.seqPlayers[0].unk_158[3]);
+ GfxPrint_Printf(printer, "%02X %02X %02X %02X", (u8)gAudioContext.seqPlayers[0].soundScriptIO[0],
+ (u8)gAudioContext.seqPlayers[0].soundScriptIO[1],
+ (u8)gAudioContext.seqPlayers[0].soundScriptIO[2],
+ (u8)gAudioContext.seqPlayers[0].soundScriptIO[3]);
GfxPrint_SetPos(printer, 3, 13);
- GfxPrint_Printf(printer, "%02X %02X %02X %02X", (u8)gAudioContext.seqPlayers[0].unk_158[4],
- (u8)gAudioContext.seqPlayers[0].unk_158[5], (u8)gAudioContext.seqPlayers[0].unk_158[6],
- (u8)gAudioContext.seqPlayers[0].unk_158[7]);
+ GfxPrint_Printf(printer, "%02X %02X %02X %02X", (u8)gAudioContext.seqPlayers[0].soundScriptIO[4],
+ (u8)gAudioContext.seqPlayers[0].soundScriptIO[5],
+ (u8)gAudioContext.seqPlayers[0].soundScriptIO[6],
+ (u8)gAudioContext.seqPlayers[0].soundScriptIO[7]);
break;
case PAGE_OCARINA_TEST:
@@ -2029,39 +2040,39 @@ void AudioDebug_Draw(GfxPrint* printer) {
D_80131858);
break;
- case PAGE_SE_PARAMETER_CHANGE:
- GfxPrint_SetPos(printer, 2, 4 + sAudioSEParamChgSel);
+ case PAGE_SFX_PARAMETER_CHANGE:
+ GfxPrint_SetPos(printer, 2, 4 + sAudioSfxParamChgSel);
SETCOL(127, 255, 127);
GfxPrint_Printf(printer, "*");
SETCOL(255, 255, 255);
GfxPrint_SetPos(printer, 3, 4);
- GfxPrint_Printf(printer, "SE HD : %02x %s", sAudioSEParamChgWork[0],
- sSoundBankNames[sAudioSEParamChgWork[0]]);
+ GfxPrint_Printf(printer, "SE HD : %02x %s", sAudioSfxParamChgWork[0],
+ sSoundBankNames[sAudioSfxParamChgWork[0]]);
GfxPrint_SetPos(printer, 3, 5);
- GfxPrint_Printf(printer, "SE No. : %02x", sAudioSEParamChgWork[1]);
+ GfxPrint_Printf(printer, "SE No. : %02x", sAudioSfxParamChgWork[1]);
GfxPrint_SetPos(printer, 20, 6);
GfxPrint_Printf(printer, " : %04x",
- gSoundParams[sAudioSEParamChgWork[0]][sAudioSEParamChgWork[1]].params);
+ gSoundParams[sAudioSfxParamChgWork[0]][sAudioSfxParamChgWork[1]].params);
GfxPrint_SetPos(printer, 3, 6);
GfxPrint_Printf(
printer, "SE SW %s",
- AudioDebug_ToStringBinary(gSoundParams[sAudioSEParamChgWork[0]][sAudioSEParamChgWork[1]].params, 16));
+ AudioDebug_ToStringBinary(gSoundParams[sAudioSfxParamChgWork[0]][sAudioSfxParamChgWork[1]].params, 16));
SETCOL(127, 255, 127);
- digitStr[0] = (char)('0' + ((gSoundParams[sAudioSEParamChgWork[0]][sAudioSEParamChgWork[1]].params >>
- (15 - sAudioSEParamChgBitSel)) &
+ digitStr[0] = (char)('0' + ((gSoundParams[sAudioSfxParamChgWork[0]][sAudioSfxParamChgWork[1]].params >>
+ (15 - sAudioSfxParamChgBitSel)) &
1));
- GfxPrint_SetPos(printer, 12 + sAudioSEParamChgBitSel, 6);
+ GfxPrint_SetPos(printer, 12 + sAudioSfxParamChgBitSel, 6);
GfxPrint_Printf(printer, "%s", digitStr);
SETCOL(255, 255, 255);
GfxPrint_SetPos(printer, 3, 7);
GfxPrint_Printf(printer, "SE PR : %02x",
- gSoundParams[sAudioSEParamChgWork[0]][sAudioSEParamChgWork[1]].importance);
+ gSoundParams[sAudioSfxParamChgWork[0]][sAudioSfxParamChgWork[1]].importance);
break;
case PAGE_FREE_AREA:
@@ -2176,17 +2187,17 @@ void AudioDebug_ProcessInput_SndCont(void) {
if (sAudioSndContSel == 8) {
if (sAudioSndContWork[sAudioSndContSel] != 0) {
- func_800F6828(0x20);
+ Audio_SetExtraFilter(0x20);
} else {
- func_800F6828(0);
+ Audio_SetExtraFilter(0);
}
}
if (sAudioSndContSel == 9) {
if (sAudioSndContWork[sAudioSndContSel] != 0) {
- func_800F67A0(0x20);
+ Audio_SetBaseFilter(0x20);
} else {
- func_800F67A0(0);
+ Audio_SetBaseFilter(0);
}
}
@@ -2237,7 +2248,7 @@ void AudioDebug_ProcessInput_SndCont(void) {
break;
case 2:
case 3:
- func_800F87A0(sAudioSndContWork[2]);
+ Audio_StopSfxByBank(sAudioSndContWork[2]);
break;
}
}
@@ -2358,59 +2369,59 @@ void AudioDebug_ProcessInput_ScrPrt(void) {
(sAudioScrPrtWork[6] * 8) + (sAudioScrPrtWork[7] * 0x10) + (sAudioScrPrtWork[8] * 0x20);
}
-void AudioDebug_ProcessInput_SEFlagSwap(void) {
+void AudioDebug_ProcessInput_SfxSwap(void) {
s16 step;
u16 val;
u8 prev;
- if (!sAudioSEFlagSwapIsEditing) {
+ if (!sAudioSfxSwapIsEditing) {
if (CHECK_BTN_ANY(sDebugPadPress, BTN_DUP)) {
- if (sAudioSEFlagSwapSel > 0) {
- sAudioSEFlagSwapSel--;
+ if (sAudioSfxSwapSel > 0) {
+ sAudioSfxSwapSel--;
} else {
- sAudioSEFlagSwapSel = 9;
+ sAudioSfxSwapSel = 9;
}
}
if (CHECK_BTN_ANY(sDebugPadPress, BTN_DDOWN)) {
- if (sAudioSEFlagSwapSel < 9) {
- sAudioSEFlagSwapSel++;
+ if (sAudioSfxSwapSel < 9) {
+ sAudioSfxSwapSel++;
} else {
- sAudioSEFlagSwapSel = 0;
+ sAudioSfxSwapSel = 0;
}
}
if (CHECK_BTN_ANY(sDebugPadPress, BTN_A)) {
- sAudioSEFlagSwapIsEditing = true;
+ sAudioSfxSwapIsEditing = true;
}
if (CHECK_BTN_ANY(sDebugPadPress, BTN_B)) {
- gAudioSEFlagSwapSource[sAudioSEFlagSwapSel] = 0;
- gAudioSEFlagSwapTarget[sAudioSEFlagSwapSel] = 0;
+ gAudioSfxSwapSource[sAudioSfxSwapSel] = 0;
+ gAudioSfxSwapTarget[sAudioSfxSwapSel] = 0;
}
if (CHECK_BTN_ANY(sDebugPadPress, BTN_START)) {
- if (sAudioSEFlagSwapSel != 0) {
- prev = sAudioSEFlagSwapSel - 1;
+ if (sAudioSfxSwapSel != 0) {
+ prev = sAudioSfxSwapSel - 1;
} else {
prev = 9;
}
- gAudioSEFlagSwapSource[sAudioSEFlagSwapSel] = gAudioSEFlagSwapSource[prev];
- gAudioSEFlagSwapTarget[sAudioSEFlagSwapSel] = gAudioSEFlagSwapTarget[prev];
+ gAudioSfxSwapSource[sAudioSfxSwapSel] = gAudioSfxSwapSource[prev];
+ gAudioSfxSwapTarget[sAudioSfxSwapSel] = gAudioSfxSwapTarget[prev];
}
} else {
if (CHECK_BTN_ANY(sDebugPadPress, BTN_DLEFT)) {
- if (sAudioSEFlagSwapNibbleSel > 0) {
- sAudioSEFlagSwapNibbleSel--;
+ if (sAudioSfxSwapNibbleSel > 0) {
+ sAudioSfxSwapNibbleSel--;
} else {
- sAudioSEFlagSwapNibbleSel = 7;
+ sAudioSfxSwapNibbleSel = 7;
}
}
if (CHECK_BTN_ANY(sDebugPadPress, BTN_DRIGHT)) {
- if (sAudioSEFlagSwapNibbleSel < 7) {
- sAudioSEFlagSwapNibbleSel++;
+ if (sAudioSfxSwapNibbleSel < 7) {
+ sAudioSfxSwapNibbleSel++;
} else {
- sAudioSEFlagSwapNibbleSel = 0;
+ sAudioSfxSwapNibbleSel = 0;
}
}
@@ -2423,42 +2434,42 @@ void AudioDebug_ProcessInput_SEFlagSwap(void) {
step = CHECK_BTN_ANY(sDebugPadHold, BTN_CUP) ? -8 : -1;
}
- if (sAudioSEFlagSwapNibbleSel < 4) {
- val = gAudioSEFlagSwapSource[sAudioSEFlagSwapSel] >> ((3 - sAudioSEFlagSwapNibbleSel) * 4);
+ if (sAudioSfxSwapNibbleSel < 4) {
+ val = gAudioSfxSwapSource[sAudioSfxSwapSel] >> ((3 - sAudioSfxSwapNibbleSel) * 4);
val = (val + step) & 0xF;
- gAudioSEFlagSwapSource[sAudioSEFlagSwapSel] =
- (gAudioSEFlagSwapSource[sAudioSEFlagSwapSel] &
- ((0xF << ((3 - sAudioSEFlagSwapNibbleSel) * 4)) ^ 0xFFFF)) +
- (val << ((3 - sAudioSEFlagSwapNibbleSel) * 4));
+ gAudioSfxSwapSource[sAudioSfxSwapSel] =
+ (gAudioSfxSwapSource[sAudioSfxSwapSel] &
+ ((0xF << ((3 - sAudioSfxSwapNibbleSel) * 4)) ^ 0xFFFF)) +
+ (val << ((3 - sAudioSfxSwapNibbleSel) * 4));
} else {
- val = gAudioSEFlagSwapTarget[sAudioSEFlagSwapSel] >> ((7 - sAudioSEFlagSwapNibbleSel) * 4);
+ val = gAudioSfxSwapTarget[sAudioSfxSwapSel] >> ((7 - sAudioSfxSwapNibbleSel) * 4);
val = (val + step) & 0xF;
- gAudioSEFlagSwapTarget[sAudioSEFlagSwapSel] =
- (gAudioSEFlagSwapTarget[sAudioSEFlagSwapSel] &
- ((0xF << ((7 - sAudioSEFlagSwapNibbleSel) * 4)) ^ 0xFFFF)) +
- (val << ((7 - sAudioSEFlagSwapNibbleSel) * 4));
+ gAudioSfxSwapTarget[sAudioSfxSwapSel] =
+ (gAudioSfxSwapTarget[sAudioSfxSwapSel] &
+ ((0xF << ((7 - sAudioSfxSwapNibbleSel) * 4)) ^ 0xFFFF)) +
+ (val << ((7 - sAudioSfxSwapNibbleSel) * 4));
}
}
if (CHECK_BTN_ANY(sDebugPadPress, BTN_A)) {
- sAudioSEFlagSwapIsEditing = false;
+ sAudioSfxSwapIsEditing = false;
}
if (CHECK_BTN_ANY(sDebugPadPress, BTN_B)) {
- if (sAudioSEFlagSwapNibbleSel < 4) {
- gAudioSEFlagSwapSource[sAudioSEFlagSwapSel] = 0;
+ if (sAudioSfxSwapNibbleSel < 4) {
+ gAudioSfxSwapSource[sAudioSfxSwapSel] = 0;
} else {
- gAudioSEFlagSwapTarget[sAudioSEFlagSwapSel] = 0;
+ gAudioSfxSwapTarget[sAudioSfxSwapSel] = 0;
}
}
}
if (CHECK_BTN_ANY(sDebugPadPress, BTN_CLEFT)) {
- gAudioSEFlagSwapOff ^= 1;
+ gAudioSfxSwapOff ^= 1;
}
if (CHECK_BTN_ANY(sDebugPadPress, BTN_CDOWN)) {
- gAudioSEFlagSwapMode[sAudioSEFlagSwapSel] ^= 1;
+ gAudioSfxSwapMode[sAudioSfxSwapSel] ^= 1;
}
}
@@ -2536,7 +2547,7 @@ void AudioDebug_ProcessInput_BlkChgBgm(void) {
void AudioDebug_ProcessInput_OcaTest(void) {
}
-void AudioDebug_ProcessInput_SEParamChg(void) {
+void AudioDebug_ProcessInput_SfxParamChg(void) {
s32 step;
u16 sfx;
@@ -2547,78 +2558,78 @@ void AudioDebug_ProcessInput_SEParamChg(void) {
}
if (CHECK_BTN_ANY(sDebugPadPress, BTN_DUP)) {
- if (sAudioSEParamChgSel > 0) {
- sAudioSEParamChgSel--;
+ if (sAudioSfxParamChgSel > 0) {
+ sAudioSfxParamChgSel--;
} else {
- sAudioSEParamChgSel = 3;
+ sAudioSfxParamChgSel = 3;
}
}
if (CHECK_BTN_ANY(sDebugPadPress, BTN_DDOWN)) {
- if (sAudioSEParamChgSel < 3) {
- sAudioSEParamChgSel++;
+ if (sAudioSfxParamChgSel < 3) {
+ sAudioSfxParamChgSel++;
} else {
- sAudioSEParamChgSel = 0;
+ sAudioSfxParamChgSel = 0;
}
}
if (CHECK_BTN_ANY(sDebugPadPress, BTN_DLEFT)) {
- if (sAudioSEParamChgSel < 2) {
- if (sAudioSEParamChgSel == 0) {
- if (sAudioSEParamChgWork[sAudioSEParamChgSel] > 0) {
- sAudioSEParamChgWork[sAudioSEParamChgSel]--;
+ if (sAudioSfxParamChgSel < 2) {
+ if (sAudioSfxParamChgSel == 0) {
+ if (sAudioSfxParamChgWork[sAudioSfxParamChgSel] > 0) {
+ sAudioSfxParamChgWork[sAudioSfxParamChgSel]--;
} else {
- sAudioSEParamChgWork[sAudioSEParamChgSel] = sAudioSndContWorkLims[2] - 1;
+ sAudioSfxParamChgWork[sAudioSfxParamChgSel] = sAudioSndContWorkLims[2] - 1;
}
} else {
- sAudioSEParamChgWork[sAudioSEParamChgSel] -= step;
- sAudioSEParamChgWork[sAudioSEParamChgSel] &= 0x1FF;
+ sAudioSfxParamChgWork[sAudioSfxParamChgSel] -= step;
+ sAudioSfxParamChgWork[sAudioSfxParamChgSel] &= 0x1FF;
}
- } else if (sAudioSEParamChgSel == 3) {
- gSoundParams[sAudioSEParamChgWork[0]][sAudioSEParamChgWork[1]].importance -= step;
+ } else if (sAudioSfxParamChgSel == 3) {
+ gSoundParams[sAudioSfxParamChgWork[0]][sAudioSfxParamChgWork[1]].importance -= step;
} else {
- sAudioSEParamChgBitSel = (sAudioSEParamChgBitSel - 1) & 0xF;
+ sAudioSfxParamChgBitSel = (sAudioSfxParamChgBitSel - 1) & 0xF;
}
}
if (CHECK_BTN_ANY(sDebugPadPress, BTN_DRIGHT)) {
- if (sAudioSEParamChgSel < 2) {
- if (sAudioSEParamChgSel == 0) {
- if (sAudioSEParamChgWork[sAudioSEParamChgSel] < (sAudioSndContWorkLims[2] - 1)) {
- sAudioSEParamChgWork[sAudioSEParamChgSel]++;
+ if (sAudioSfxParamChgSel < 2) {
+ if (sAudioSfxParamChgSel == 0) {
+ if (sAudioSfxParamChgWork[sAudioSfxParamChgSel] < (sAudioSndContWorkLims[2] - 1)) {
+ sAudioSfxParamChgWork[sAudioSfxParamChgSel]++;
} else {
- sAudioSEParamChgWork[sAudioSEParamChgSel] = 0;
+ sAudioSfxParamChgWork[sAudioSfxParamChgSel] = 0;
}
} else {
- sAudioSEParamChgWork[sAudioSEParamChgSel] += step;
- sAudioSEParamChgWork[sAudioSEParamChgSel] &= 0x1FF;
+ sAudioSfxParamChgWork[sAudioSfxParamChgSel] += step;
+ sAudioSfxParamChgWork[sAudioSfxParamChgSel] &= 0x1FF;
}
- } else if (sAudioSEParamChgSel == 3) {
- gSoundParams[sAudioSEParamChgWork[0]][sAudioSEParamChgWork[1]].importance += step;
+ } else if (sAudioSfxParamChgSel == 3) {
+ gSoundParams[sAudioSfxParamChgWork[0]][sAudioSfxParamChgWork[1]].importance += step;
} else {
- sAudioSEParamChgBitSel = (sAudioSEParamChgBitSel + 1) & 0xF;
+ sAudioSfxParamChgBitSel = (sAudioSfxParamChgBitSel + 1) & 0xF;
}
}
if (CHECK_BTN_ANY(sDebugPadPress, BTN_A)) {
- sfx = (u16)(sAudioSEParamChgWork[0] << 12) + sAudioSEParamChgWork[1] + SFX_FLAG;
+ sfx = (u16)(sAudioSfxParamChgWork[0] << 12) + sAudioSfxParamChgWork[1] + SFX_FLAG;
Audio_PlaySoundGeneral(sfx, &D_801333D4, 4, &D_801333E0, &D_801333E0, &D_801333E8);
}
if (CHECK_BTN_ANY(sDebugPadPress, BTN_B)) {
- func_800F87A0(sAudioSEParamChgWork[0]);
+ Audio_StopSfxByBank(sAudioSfxParamChgWork[0]);
}
if (CHECK_BTN_ANY(sDebugPadPress, BTN_CDOWN)) {
- if (sAudioSEParamChgSel == 2) {
- gSoundParams[sAudioSEParamChgWork[0]][sAudioSEParamChgWork[1]].params ^=
- (1 << (0xF - sAudioSEParamChgBitSel));
+ if (sAudioSfxParamChgSel == 2) {
+ gSoundParams[sAudioSfxParamChgWork[0]][sAudioSfxParamChgWork[1]].params ^=
+ (1 << (0xF - sAudioSfxParamChgBitSel));
}
}
if (CHECK_BTN_ANY(sDebugPadPress, BTN_CUP)) {
- if (sAudioSEParamChgSel < 2) {
- sAudioSEParamChgWork[sAudioSEParamChgSel] = 0;
+ if (sAudioSfxParamChgSel < 2) {
+ sAudioSfxParamChgWork[sAudioSfxParamChgSel] = 0;
}
}
}
@@ -2651,7 +2662,7 @@ void AudioDebug_ProcessInput(void) {
return;
}
- if (sAudioSEMuted) {
+ if (sAudioSfxMuted) {
Audio_SetSoundBanksMute(0x6F);
}
@@ -2689,8 +2700,8 @@ void AudioDebug_ProcessInput(void) {
}
if (CHECK_BTN_ANY(sDebugPadPress, BTN_B)) {
- sAudioSEMuted ^= 1;
- if (!sAudioSEMuted) {
+ sAudioSfxMuted ^= 1;
+ if (!sAudioSfxMuted) {
Audio_SetSoundBanksMute(0);
}
}
@@ -2704,8 +2715,8 @@ void AudioDebug_ProcessInput(void) {
case PAGE_SCROLL_PRINT:
AudioDebug_ProcessInput_ScrPrt();
break;
- case PAGE_SE_FLAG_SWAP:
- AudioDebug_ProcessInput_SEFlagSwap();
+ case PAGE_SFX_SWAP:
+ AudioDebug_ProcessInput_SfxSwap();
break;
case PAGE_SUB_TRACK_INFO:
AudioDebug_ProcessInput_SubTrackInfo();
@@ -2719,8 +2730,8 @@ void AudioDebug_ProcessInput(void) {
case PAGE_OCARINA_TEST:
AudioDebug_ProcessInput_OcaTest();
break;
- case PAGE_SE_PARAMETER_CHANGE:
- AudioDebug_ProcessInput_SEParamChg();
+ case PAGE_SFX_PARAMETER_CHANGE:
+ AudioDebug_ProcessInput_SfxParamChg();
break;
case PAGE_FREE_AREA:
default:
@@ -2768,10 +2779,10 @@ void func_800F314C(s8 arg0) {
Audio_QueueCmdS32(0x82000000 | (((u8)arg0 & 0xFF) << 8), 1);
}
-f32 func_800F3188(u8 bankIdx, u8 entryIdx) {
- SoundBankEntry* bankEntry = &gSoundBanks[bankIdx][entryIdx];
- f32 temp_f14;
- f32 phi_f0;
+f32 Audio_ComputeSoundVolume(u8 bankId, u8 entryIdx) {
+ SoundBankEntry* bankEntry = &gSoundBanks[bankId][entryIdx];
+ f32 minDist;
+ f32 baseDist;
f32 ret;
if (bankEntry->sfxParams & 0x2000) {
@@ -2783,27 +2794,29 @@ f32 func_800F3188(u8 bankIdx, u8 entryIdx) {
} else {
switch (bankEntry->sfxParams & 3) {
case 1:
- phi_f0 = 10000.0f / 15.0f;
+ baseDist = 10000.0f / 15.0f;
break;
case 2:
- phi_f0 = 10000.0f / 10.5f;
+ baseDist = 10000.0f / 10.5f;
break;
case 3:
- phi_f0 = 10000.0f / 2.6f;
+ baseDist = 10000.0f / 2.6f;
break;
default:
- phi_f0 = 10000.0f / 20.0f;
+ baseDist = 10000.0f / 20.0f;
break;
}
- temp_f14 = phi_f0 / 5.0f;
+ minDist = baseDist / 5.0f;
- if (bankEntry->dist < temp_f14) {
+ // Volume grows as inverse square of distance. Linearly approximate
+ // the inverse part, then square.
+ if (bankEntry->dist < minDist) {
ret = 1.0f;
- } else if (bankEntry->dist < phi_f0) {
- ret = ((((phi_f0 - temp_f14) - (bankEntry->dist - temp_f14)) / (phi_f0 - temp_f14)) * 0.19f) + 0.81f;
+ } else if (bankEntry->dist < baseDist) {
+ ret = ((((baseDist - minDist) - (bankEntry->dist - minDist)) / (baseDist - minDist)) * 0.19f) + 0.81f;
} else {
- ret = (1.0f - ((bankEntry->dist - phi_f0) / (10000.0f - phi_f0))) * 0.81f;
+ ret = (1.0f - ((bankEntry->dist - baseDist) / (10000.0f - baseDist))) * 0.81f;
}
ret = SQ(ret);
}
@@ -2811,10 +2824,10 @@ f32 func_800F3188(u8 bankIdx, u8 entryIdx) {
return ret;
}
-s8 Audio_ComputeSoundReverb(u8 bankIdx, u8 entryIdx, u8 channelIdx) {
+s8 Audio_ComputeSoundReverb(u8 bankId, u8 entryIdx, u8 channelIdx) {
s8 distAdd = 0;
s32 scriptAdd = 0;
- SoundBankEntry* entry = &gSoundBanks[bankIdx][entryIdx];
+ SoundBankEntry* entry = &gSoundBanks[bankId][entryIdx];
s32 reverb;
if (!(entry->sfxParams & 0x1000)) {
@@ -2833,7 +2846,7 @@ s8 Audio_ComputeSoundReverb(u8 bankIdx, u8 entryIdx, u8 channelIdx) {
}
reverb = *entry->reverbAdd + distAdd + scriptAdd;
- if ((bankIdx != BANK_OCARINA) || !((entry->sfxId & 0x1FF) < 2)) {
+ if ((bankId != BANK_OCARINA) || !((entry->sfxId & 0x1FF) < 2)) {
reverb += sAudioEnvReverb + sAudioCodeReverb + sSpecReverb;
}
@@ -2844,7 +2857,7 @@ s8 Audio_ComputeSoundReverb(u8 bankIdx, u8 entryIdx, u8 channelIdx) {
return reverb;
}
-s8 Audio_ComputeSoundPanSigned(f32 x, f32 z, u8 arg2) {
+s8 Audio_ComputeSoundPanSigned(f32 x, f32 z, u8 token) {
f32 absX;
f32 absZ;
f32 pan;
@@ -2887,9 +2900,9 @@ s8 Audio_ComputeSoundPanSigned(f32 x, f32 z, u8 arg2) {
return (s8)((pan * 127.0f) + 0.5f);
}
-f32 Audio_ComputeSoundFreqScale(u8 bankIdx, u8 entryIdx) {
+f32 Audio_ComputeSoundFreqScale(u8 bankId, u8 entryIdx) {
s32 phi_v0 = 0;
- SoundBankEntry* entry = &gSoundBanks[bankIdx][entryIdx];
+ SoundBankEntry* entry = &gSoundBanks[bankId][entryIdx];
f32 unk1C;
f32 freq = 1.0f;
@@ -2897,17 +2910,17 @@ f32 Audio_ComputeSoundFreqScale(u8 bankIdx, u8 entryIdx) {
freq = 1.0f - ((gAudioContext.audioRandom & 0xF) / 192.0f);
}
- switch (bankIdx) {
+ switch (bankId) {
case BANK_PLAYER:
case BANK_ITEM:
case BANK_VOICE:
- if (D_80130644 != 0) {
+ if (sAudioBaseFilter2 != 0) {
phi_v0 = 1;
}
break;
case BANK_ENV:
case BANK_ENEMY:
- if (D_80130648 != 0) {
+ if (sAudioExtraFilter2 != 0) {
phi_v0 = 1;
}
break;
@@ -2940,13 +2953,13 @@ f32 Audio_ComputeSoundFreqScale(u8 bankIdx, u8 entryIdx) {
return freq;
}
-u8 func_800F37B8(f32 arg0, SoundBankEntry* arg1, s8 arg2) {
+u8 func_800F37B8(f32 behindScreenZ, SoundBankEntry* arg1, s8 arg2) {
s8 phi_v0;
u8 phi_v1;
f32 phi_f0;
f32 phi_f12;
- if (*arg1->posZ < arg0) {
+ if (*arg1->posZ < behindScreenZ) {
phi_v0 = arg2 < 65 ? arg2 : 0x7F - arg2;
if (phi_v0 < 30) {
@@ -3000,20 +3013,20 @@ s8 func_800F3990(f32 arg0, u16 sfxParams) {
return ret | 1;
}
-void Audio_SetSoundProperties(u8 bankIdx, u8 entryIdx, u8 channelIdx) {
- f32 sp44 = 1.0f;
- s8 phi_a1;
+void Audio_SetSoundProperties(u8 bankId, u8 entryIdx, u8 channelIdx) {
+ f32 vol = 1.0f;
+ s8 volS8;
s8 reverb = 0;
f32 freqScale = 1.0f;
s8 panSigned = 0x40;
u8 stereoBits = 0;
- u8 sp39 = 0;
+ u8 filter = 0;
s8 sp38 = 0;
- f32 sp34;
- u8 sp33 = 0;
- SoundBankEntry* entry = &gSoundBanks[bankIdx][entryIdx];
+ f32 behindScreenZ;
+ u8 baseFilter = 0;
+ SoundBankEntry* entry = &gSoundBanks[bankId][entryIdx];
- switch (bankIdx) {
+ switch (bankId) {
case BANK_PLAYER:
case BANK_ITEM:
case BANK_ENV:
@@ -3025,99 +3038,99 @@ void Audio_SetSoundProperties(u8 bankIdx, u8 entryIdx, u8 channelIdx) {
// fallthrough
case BANK_OCARINA:
entry->dist = sqrtf(entry->dist);
- sp44 = func_800F3188(bankIdx, entryIdx) * *entry->unk_14;
- reverb = Audio_ComputeSoundReverb(bankIdx, entryIdx, channelIdx);
- panSigned = Audio_ComputeSoundPanSigned(*entry->posX, *entry->posZ, entry->unk_C);
- freqScale = Audio_ComputeSoundFreqScale(bankIdx, entryIdx) * *entry->freqScale;
+ vol = Audio_ComputeSoundVolume(bankId, entryIdx) * *entry->vol;
+ reverb = Audio_ComputeSoundReverb(bankId, entryIdx, channelIdx);
+ panSigned = Audio_ComputeSoundPanSigned(*entry->posX, *entry->posZ, entry->token);
+ freqScale = Audio_ComputeSoundFreqScale(bankId, entryIdx) * *entry->freqScale;
if (D_80130604 == 2) {
- sp34 = D_801305C4[(entry->sfxParams & 0x400) >> 10];
+ behindScreenZ = sBehindScreenZ[(entry->sfxParams & 0x400) >> 10];
if (!(entry->sfxParams & 0x800)) {
- if (*entry->posZ < sp34) {
+ if (*entry->posZ < behindScreenZ) {
stereoBits = 0x10;
}
- if ((D_8016B8B8[channelIdx].stereoBits ^ stereoBits) & 0x10) {
+ if ((sSfxChannelState[channelIdx].stereoBits ^ stereoBits) & 0x10) {
if (panSigned < 0x40) {
- stereoBits = D_8016B8B8[channelIdx].stereoBits ^ 0x14;
+ stereoBits = sSfxChannelState[channelIdx].stereoBits ^ 0x14;
} else {
- stereoBits = D_8016B8B8[channelIdx].stereoBits ^ 0x18;
+ stereoBits = sSfxChannelState[channelIdx].stereoBits ^ 0x18;
}
} else {
- stereoBits = D_8016B8B8[channelIdx].stereoBits;
+ stereoBits = sSfxChannelState[channelIdx].stereoBits;
}
}
}
- if (D_8013063C != 0) {
- if ((bankIdx == BANK_ITEM) || (bankIdx == BANK_PLAYER) || (bankIdx == BANK_VOICE)) {
- sp33 = D_8013063C;
+ if (sAudioBaseFilter != 0) {
+ if ((bankId == BANK_ITEM) || (bankId == BANK_PLAYER) || (bankId == BANK_VOICE)) {
+ baseFilter = sAudioBaseFilter;
}
}
- if ((sp33 | D_80130640) != 0) {
- sp39 = (sp33 | D_80130640);
+ if ((baseFilter | sAudioExtraFilter) != 0) {
+ filter = (baseFilter | sAudioExtraFilter);
} else if (D_80130604 == 2 && (entry->sfxParams & 0x2000) == 0) {
- sp39 = func_800F37B8(sp34, entry, panSigned);
+ filter = func_800F37B8(behindScreenZ, entry, panSigned);
}
break;
case BANK_SYSTEM:
break;
}
- if (D_8016B8B8[channelIdx].unk_00 != sp44) {
- phi_a1 = (u8)(sp44 * 127.0f);
- D_8016B8B8[channelIdx].unk_00 = sp44;
+ if (sSfxChannelState[channelIdx].vol != vol) {
+ volS8 = (u8)(vol * 127.0f);
+ sSfxChannelState[channelIdx].vol = vol;
} else {
- phi_a1 = -1;
+ volS8 = -1;
}
- // CHAN_UPD_SCRIPT_IO (slot 2)
- Audio_QueueCmdS8(0x6020000 | (channelIdx << 8) | 2, phi_a1);
- if (reverb != D_8016B8B8[channelIdx].reverb) {
+ // CHAN_UPD_SCRIPT_IO (slot 2, sets volume)
+ Audio_QueueCmdS8(0x6020000 | (channelIdx << 8) | 2, volS8);
+ if (reverb != sSfxChannelState[channelIdx].reverb) {
Audio_QueueCmdS8(0x5020000 | (channelIdx << 8), reverb);
- D_8016B8B8[channelIdx].reverb = reverb;
+ sSfxChannelState[channelIdx].reverb = reverb;
}
- if (freqScale != D_8016B8B8[channelIdx].freqScale) {
+ if (freqScale != sSfxChannelState[channelIdx].freqScale) {
Audio_QueueCmdF32(0x4020000 | (channelIdx << 8), freqScale);
- D_8016B8B8[channelIdx].freqScale = freqScale;
+ sSfxChannelState[channelIdx].freqScale = freqScale;
}
- if (stereoBits != D_8016B8B8[channelIdx].stereoBits) {
+ if (stereoBits != sSfxChannelState[channelIdx].stereoBits) {
Audio_QueueCmdS8(0xE020000 | (channelIdx << 8), stereoBits | 0x10);
- D_8016B8B8[channelIdx].stereoBits = stereoBits;
+ sSfxChannelState[channelIdx].stereoBits = stereoBits;
}
- if (sp39 != D_8016B8B8[channelIdx].unk_0B) {
- // CHAN_UPD_SCRIPT_IO (slot 3)
- Audio_QueueCmdS8(0x6020000 | (channelIdx << 8) | 3, sp39);
- D_8016B8B8[channelIdx].unk_0B = sp39;
+ if (filter != sSfxChannelState[channelIdx].filter) {
+ // CHAN_UPD_SCRIPT_IO (slot 3, sets filter)
+ Audio_QueueCmdS8(0x6020000 | (channelIdx << 8) | 3, filter);
+ sSfxChannelState[channelIdx].filter = filter;
}
- if (sp38 != D_8016B8B8[channelIdx].unk_0C) {
+ if (sp38 != sSfxChannelState[channelIdx].unk_0C) {
// CHAN_UPD_UNK_0F
Audio_QueueCmdS8(0xC020000 | (channelIdx << 8), 0x10);
// CHAN_UPD_UNK_20
Audio_QueueCmdU16(0xD020000 | (channelIdx << 8), ((u16)(sp38) << 8) + 0xFF);
- D_8016B8B8[channelIdx].unk_0C = sp38;
+ sSfxChannelState[channelIdx].unk_0C = sp38;
}
- if (panSigned != D_8016B8B8[channelIdx].panSigned) {
+ if (panSigned != sSfxChannelState[channelIdx].panSigned) {
Audio_QueueCmdS8(0x3020000 | (channelIdx << 8), panSigned);
- D_8016B8B8[channelIdx].panSigned = panSigned;
+ sSfxChannelState[channelIdx].panSigned = panSigned;
}
}
-void func_800F3ED4(void) {
+void Audio_ResetSfxChannelState(void) {
u8 i;
- unk_s1* t;
+ SfxPlayerState* state;
for (i = 0; i < 16; i++) {
- t = &D_8016B8B8[i];
- t->unk_00 = 1.0f;
- t->freqScale = 1.0f;
- t->reverb = 0;
- t->panSigned = 0x40;
- t->stereoBits = 0;
- t->unk_0B = 0xFF;
- t->unk_0C = 0xFF;
+ state = &sSfxChannelState[i];
+ state->vol = 1.0f;
+ state->freqScale = 1.0f;
+ state->reverb = 0;
+ state->panSigned = 0x40;
+ state->stereoBits = 0;
+ state->filter = 0xFF;
+ state->unk_0C = 0xFF;
}
- D_8016B8B8[13].unk_0C = 0;
+ sSfxChannelState[SFX_PLAYER_CHANNEL_OCARINA].unk_0C = 0;
D_8013061C = 0;
sAudioCodeReverb = 0;
}
@@ -3404,15 +3417,16 @@ void Audio_PlaySoundTransposed(Vec3f* pos, u16 sfxId, s8 semitone) {
void func_800F4C58(Vec3f* pos, u16 sfxId, u8 arg2) {
u8 phi_s1 = 0;
u8 i;
- u8 bank;
+ u8 bankId;
- bank = SFX_BANK_SHIFT(sfxId);
- for (i = 0; i < bank; i++) {
- phi_s1 += D_80130578[D_801333CC][i];
+ bankId = SFX_BANK_SHIFT(sfxId);
+ for (i = 0; i < bankId; i++) {
+ phi_s1 += gChannelsPerBank[gSfxChannelLayout][i];
}
- for (i = 0; i < D_80130578[D_801333CC][bank]; i++) {
- if ((D_8016E1B8[bank][i].unk_4 != 0xFF) && (sfxId == gSoundBanks[bank][D_8016E1B8[bank][i].unk_4].sfxId)) {
+ for (i = 0; i < gChannelsPerBank[gSfxChannelLayout][bankId]; i++) {
+ if ((gActiveSounds[bankId][i].entryIndex != 0xFF) &&
+ (sfxId == gSoundBanks[bankId][gActiveSounds[bankId][i].entryIndex].sfxId)) {
Audio_QueueCmdS8(_SHIFTL(6, 24, 8) | _SHIFTL(2, 16, 8) | _SHIFTL(phi_s1, 8, 8) | _SHIFTL(6, 0, 8), arg2);
}
phi_s1++;
@@ -3602,7 +3616,7 @@ void func_800F56A8(void) {
bvar = temp_v0 & 0xFF;
if ((temp_v0 != NA_BGM_DISABLED) && ((D_80130658[bvar] & 0x10) != 0)) {
if (D_8013062C != 0xC0) {
- D_8013062C = gAudioContext.seqPlayers->unk_158[3];
+ D_8013062C = gAudioContext.seqPlayers->soundScriptIO[3];
} else {
D_8013062C = 0;
}
@@ -3672,18 +3686,18 @@ s32 func_800F5A58(u8 arg0) {
}
}
-void func_800F5ACC(u16 arg0) {
+void func_800F5ACC(u16 seqId) {
u16 temp_v0;
temp_v0 = func_800FA0B4(0);
- if ((temp_v0 & 0xFF) != NA_BGM_GANON_TOWER && (temp_v0 & 0xFF) != NA_BGM_ESCAPE && temp_v0 != arg0) {
+ if ((temp_v0 & 0xFF) != NA_BGM_GANON_TOWER && (temp_v0 & 0xFF) != NA_BGM_ESCAPE && temp_v0 != seqId) {
func_800F5E90(3);
if (temp_v0 != NA_BGM_DISABLED) {
D_80130628 = temp_v0;
} else {
osSyncPrintf("Middle Boss BGM Start not stack \n");
}
- Audio_StartSeq(0, 0, arg0);
+ Audio_StartSeq(0, 0, seqId);
}
}
@@ -3742,8 +3756,8 @@ void func_800F5CF8(void) {
if (D_8016B9F4 != 0) {
D_8016B9F4--;
if (D_8016B9F4 == 0) {
- Audio_QueueCmdS32(0xE3000000, 0);
- Audio_QueueCmdS32(0xE3000000, 1);
+ Audio_QueueCmdS32(0xE3000000, SEQUENCE_TABLE);
+ Audio_QueueCmdS32(0xE3000000, FONT_TABLE);
func_800FA0B4(0);
sp26 = func_800FA0B4(1);
sp22 = func_800FA0B4(3);
@@ -3766,9 +3780,9 @@ void func_800F5CF8(void) {
}
}
-void func_800F5E18(u8 seqIdx, u16 seqId, u8 fadeTimer, s8 arg3, s8 arg4) {
- Audio_SeqCmd7(seqIdx, arg3, arg4);
- Audio_StartSeq(seqIdx, fadeTimer, seqId);
+void func_800F5E18(u8 playerIdx, u16 seqId, u8 fadeTimer, s8 arg3, s8 arg4) {
+ Audio_SeqCmd7(playerIdx, arg3, arg4);
+ Audio_StartSeq(playerIdx, fadeTimer, seqId);
}
void func_800F5E90(u8 arg0) {
@@ -3883,6 +3897,7 @@ void func_800F6268(f32 dist, u16 arg1) {
} else {
phi_v1 = (s8)(((dist - 200.0f) * 127.0f) / 1800.0f);
}
+ // Transition volume of channels 0, 1 and 13 on seq player 0 over 3 frames
Audio_SeqCmd6(0, 3, 0, 127 - phi_v1);
Audio_SeqCmd6(0, 3, 1, 127 - phi_v1);
Audio_SeqCmd6(0, 3, 13, phi_v1);
@@ -3905,6 +3920,7 @@ void func_800F6268(f32 dist, u16 arg1) {
} else {
phi_v1 = (s8)(((dist - 200.0f) * 127.0f) / 1800.0f);
}
+ // Transition volume of channels 0 and 1 on seq player 0 over 3 frames
Audio_SeqCmd6(3, 3, 0, 127 - phi_v1);
Audio_SeqCmd6(3, 3, 1, 127 - phi_v1);
}
@@ -3927,34 +3943,34 @@ void func_800F64E0(u8 arg0) {
}
void func_800F6584(u8 arg0) {
- u8 seqIdx;
+ u8 playerIdx;
u16 sp34;
D_8016B9F2 = arg0;
if ((func_800FA0B4(0) & 0xFF) == NA_BGM_LONLON) {
- seqIdx = 0;
+ playerIdx = 0;
sp34 = 0;
} else if ((func_800FA0B4(3) & 0xFF) == NA_BGM_LONLON) {
- seqIdx = 3;
+ playerIdx = 3;
sp34 = 0xFFFC;
} else {
return;
}
if (arg0 != 0) {
- Audio_SeqCmd6(seqIdx, 1, 0, 0);
- Audio_SeqCmd6(seqIdx, 1, 1, 0);
- if (seqIdx == 3) {
- Audio_SeqCmdA(seqIdx, sp34 | 3);
+ Audio_SeqCmd6(playerIdx, 1, 0, 0);
+ Audio_SeqCmd6(playerIdx, 1, 1, 0);
+ if (playerIdx == 3) {
+ Audio_SeqCmdA(playerIdx, sp34 | 3);
}
} else {
- if (seqIdx == 3) {
+ if (playerIdx == 3) {
func_800F5E18(3, NA_BGM_LONLON, 0, 0, 0);
}
- Audio_SeqCmd6(seqIdx, 1, 0, 0x7F);
- Audio_SeqCmd6(seqIdx, 1, 1, 0x7F);
- if (seqIdx == 3) {
- Audio_SeqCmdA(seqIdx, sp34);
+ Audio_SeqCmd6(playerIdx, 1, 0, 0x7F);
+ Audio_SeqCmd6(playerIdx, 1, 1, 0x7F);
+ if (playerIdx == 3) {
+ Audio_SeqCmdA(playerIdx, sp34);
}
}
}
@@ -3994,28 +4010,29 @@ void func_800F6700(s8 arg0) {
Audio_SeqCmdE0(0, sp1F);
}
-void func_800F67A0(u8 arg0) {
- if (D_8013063C != arg0) {
- if (arg0 == 0) {
- Audio_StopSfx(NA_SE_PL_IN_BUBBLE);
- } else if (D_8013063C == 0) {
+void Audio_SetBaseFilter(u8 filter) {
+ if (sAudioBaseFilter != filter) {
+ if (filter == 0) {
+ Audio_StopSfxById(NA_SE_PL_IN_BUBBLE);
+ } else if (sAudioBaseFilter == 0) {
Audio_PlaySoundGeneral(NA_SE_PL_IN_BUBBLE, &D_801333D4, 4, &D_801333E0, &D_801333E0, &D_801333E8);
}
}
- D_8013063C = arg0;
- D_80130644 = arg0;
+ sAudioBaseFilter = filter;
+ sAudioBaseFilter2 = filter;
}
-void func_800F6828(u8 arg0) {
+void Audio_SetExtraFilter(u8 filter) {
u32 t;
u8 i;
- D_80130648 = arg0;
- D_80130640 = arg0;
+ sAudioExtraFilter2 = filter;
+ sAudioExtraFilter = filter;
if (D_8016E750[0].unk_254 == NA_BGM_NATURE_BACKGROUND) {
for (i = 0; i < 16; i++) {
t = i;
- Audio_QueueCmdS8(((t & 0xFF) << 8) | 0x6000000 | 6, arg0);
+ // CHAN_UPD_SCRIPT_IO (seq player 0, all channels, slot 6)
+ Audio_QueueCmdS8(0x6000000 | ((t & 0xFF) << 8) | 6, filter);
}
}
}
@@ -4104,10 +4121,10 @@ void func_800F6C34(void) {
D_8013061C = 0;
D_8016B7A8 = 1.0f;
D_8016B7B0 = 1.0f;
- D_8013063C = 0;
- D_80130640 = 0;
- D_80130644 = 0;
- D_80130648 = 0;
+ sAudioBaseFilter = 0;
+ sAudioExtraFilter = 0;
+ sAudioBaseFilter2 = 0;
+ sAudioExtraFilter2 = 0;
func_800ED858(0);
sRiverFreqScaleLerp.remainingFrames = 0;
sWaterfallFreqScaleLerp.remainingFrames = 0;
@@ -4205,20 +4222,20 @@ void func_800F6FB4(u8 arg0) {
Audio_QueueSeqCmd(0x80000000 | (b1 << 0x10) | (b0 << 8) | b2);
}
- Audio_SeqCmd8(0, 0x07, 0xD, D_80130604);
+ Audio_SeqCmd8(0, 0x07, 13, D_80130604);
}
}
-void func_800F70F8(void) {
- Audio_ContextInit(0, 0);
+void Audio_Init(void) {
+ AudioLoad_Init(NULL, 0);
}
-void func_800F711C(void) {
+void Audio_InitSound(void) {
func_800F6C34();
func_800EE930();
- func_800F3ED4();
+ Audio_ResetSfxChannelState();
func_800FAEB4();
- func_800F905C();
+ Audio_ResetSounds();
func_800F9280(2, 0, 0x70, 10);
}
@@ -4233,15 +4250,15 @@ void func_800F71BC(s32 arg0) {
D_80133418 = 1;
func_800F6C34();
func_800EE930();
- func_800F3ED4();
+ Audio_ResetSfxChannelState();
func_800FADF8();
- func_800F905C();
+ Audio_ResetSounds();
}
void func_800F7208(void) {
func_800FADF8();
Audio_QueueCmdS32(0xF2000000, 1);
func_800F6C34();
- func_800F3ED4();
+ Audio_ResetSfxChannelState();
func_800F9280(2, 0, 0x70, 1);
}
diff --git a/src/code/code_800F7260.c b/src/code/code_800F7260.c
index e663d96be..af14f7014 100644
--- a/src/code/code_800F7260.c
+++ b/src/code/code_800F7260.c
@@ -5,24 +5,24 @@
typedef struct {
/* 0x00 */ u16 sfxId;
/* 0x04 */ Vec3f* pos;
- /* 0x08 */ u8 unk_8;
+ /* 0x08 */ u8 token;
/* 0x0C */ f32* freqScale;
- /* 0x10 */ f32* unk_10;
+ /* 0x10 */ f32* vol;
/* 0x14 */ s8* reverbAdd;
} SoundRequest; // size = 0x18
typedef struct {
- /* 0x00 */ f32 unk_0;
- /* 0x04 */ f32 unk_4;
- /* 0x08 */ f32 unk_8;
- /* 0x0C */ u16 unk_C;
-} Struct_800F8EA0; // size = 0x10
+ /* 0x00 */ f32 value;
+ /* 0x04 */ f32 target;
+ /* 0x08 */ f32 step;
+ /* 0x0C */ u16 remainingFrames;
+} UnusedBankLerp; // size = 0x10
// rodata for Audio_ProcessSoundRequest (this file)
// (probably moved to .data due to -use_readwrite_const)
char D_80133340[] = "SE";
-// rodata for func_800F7CEC (this file)
+// rodata for Audio_ChooseActiveSounds (this file)
char D_80133344[] = VT_COL(RED, WHITE) "<INAGAKI CHECK> dist over! flag:%04X ptr:%08X pos:%f-%f-%f" VT_RST "\n";
// file padding
@@ -32,6 +32,21 @@ s32 D_8013338C = 0;
char D_80133390[] = "SEQ H";
char D_80133398[] = " L";
+// bss
+extern SoundRequest sSoundRequests[0x100];
+extern SoundBankEntry D_8016BAD0[9];
+extern SoundBankEntry D_8016BC80[12];
+extern SoundBankEntry D_8016BEC0[22];
+extern SoundBankEntry D_8016C2E0[20];
+extern SoundBankEntry D_8016C6A0[8];
+extern SoundBankEntry D_8016C820[3];
+extern SoundBankEntry D_8016C8B0[5];
+extern u8 sSoundBankListEnd[7];
+extern u8 sSoundBankFreeListStart[7];
+extern u8 sSoundBankUnused[7];
+extern u8 sCurSfxPlayerChannelIdx;
+extern UnusedBankLerp sUnusedBankLerp[7];
+
// data
// sSoundRequests ring buffer endpoints. read index <= write index, wrapping around mod 256.
@@ -58,7 +73,7 @@ u8 sBankSizes[ARRAY_COUNT(gSoundBanks)] = {
ARRAY_COUNT(D_8016C6A0), ARRAY_COUNT(D_8016C820), ARRAY_COUNT(D_8016C8B0),
};
-u8 D_801333CC = 0;
+u8 gSfxChannelLayout = 0;
u16 D_801333D0 = 0;
@@ -74,13 +89,10 @@ s32 D_801333EC = 0; // unused
u8 D_801333F0 = 0;
-u8 gAudioSEFlagSwapOff = 0;
+u8 gAudioSfxSwapOff = 0;
u8 D_801333F8 = 0;
-extern SoundRequest sSoundRequests[0x100];
-extern Struct_800F8EA0 D_8016E270[7];
-
void Audio_SetSoundBanksMute(u16 muteMask) {
u8 bankId;
@@ -94,38 +106,37 @@ void Audio_SetSoundBanksMute(u16 muteMask) {
}
}
-void Audio_QueueSeqCmdMute(u8 arg0) {
- D_801333D0 |= (1 << arg0);
+void Audio_QueueSeqCmdMute(u8 channelIdx) {
+ D_801333D0 |= (1 << channelIdx);
Audio_SetVolScale(0, 2, 0x40, 0xF);
Audio_SetVolScale(3, 2, 0x40, 0xF);
}
-void Audio_ClearBGMMute(u8 arg0) {
- D_801333D0 &= ((1 << arg0) ^ 0xFFFF);
+void Audio_ClearBGMMute(u8 channelIdx) {
+ D_801333D0 &= ((1 << channelIdx) ^ 0xFFFF);
if (D_801333D0 == 0) {
Audio_SetVolScale(0, 2, 0x7F, 0xF);
Audio_SetVolScale(3, 2, 0x7F, 0xF);
}
}
-// a4 is often the same as freqScale. (u8)(*a4 * 127.0f) is sent to script on IO port 2
-void Audio_PlaySoundGeneral(u16 sfxId, Vec3f* pos, u8 a2, f32* freqScale, f32* a4, s8* reverbAdd) {
+void Audio_PlaySoundGeneral(u16 sfxId, Vec3f* pos, u8 token, f32* freqScale, f32* vol, s8* reverbAdd) {
u8 i;
SoundRequest* req;
if (!gSoundBankMuted[SFX_BANK_SHIFT(sfxId)]) {
req = &sSoundRequests[sSoundRequestWriteIndex];
- if (!gAudioSEFlagSwapOff) {
+ if (!gAudioSfxSwapOff) {
for (i = 0; i < 10; i++) {
- if (sfxId == gAudioSEFlagSwapSource[i]) {
- if (gAudioSEFlagSwapMode[i] == 0) { // "SWAP"
- sfxId = gAudioSEFlagSwapTarget[i];
+ if (sfxId == gAudioSfxSwapSource[i]) {
+ if (gAudioSfxSwapMode[i] == 0) { // "SWAP"
+ sfxId = gAudioSfxSwapTarget[i];
} else { // "ADD"
- req->sfxId = gAudioSEFlagSwapTarget[i];
+ req->sfxId = gAudioSfxSwapTarget[i];
req->pos = pos;
- req->unk_8 = a2;
+ req->token = token;
req->freqScale = freqScale;
- req->unk_10 = a4;
+ req->vol = vol;
req->reverbAdd = reverbAdd;
sSoundRequestWriteIndex++;
req = &sSoundRequests[sSoundRequestWriteIndex];
@@ -136,9 +147,9 @@ void Audio_PlaySoundGeneral(u16 sfxId, Vec3f* pos, u8 a2, f32* freqScale, f32* a
}
req->sfxId = sfxId;
req->pos = pos;
- req->unk_8 = a2;
+ req->token = token;
req->freqScale = freqScale;
- req->unk_10 = a4;
+ req->vol = vol;
req->reverbAdd = reverbAdd;
sSoundRequestWriteIndex++;
}
@@ -174,7 +185,7 @@ void Audio_RemoveMatchingSoundRequests(u8 aspect, SoundBankEntry* cmp) {
}
break;
case 4:
- if (req->unk_8 == cmp->unk_C && req->sfxId == cmp->sfxId) {
+ if (req->token == cmp->token && req->sfxId == cmp->sfxId) {
remove = true;
}
break;
@@ -221,7 +232,7 @@ void Audio_ProcessSoundRequest(void) {
return;
}
if (gSoundBanks[bankId][index].sfxId == req->sfxId) {
- count = D_80130594[D_801333CC][bankId];
+ count = gUsedChannelsPerBank[gSfxChannelLayout][bankId];
} else {
if (count == 0) {
evictIndex = index;
@@ -233,7 +244,7 @@ void Audio_ProcessSoundRequest(void) {
evictImportance = gSoundParams[SFX_BANK_SHIFT(sfxId)][SFX_INDEX(sfxId)].importance;
}
count++;
- if (count == D_80130594[D_801333CC][bankId]) {
+ if (count == gUsedChannelsPerBank[gSfxChannelLayout][bankId]) {
if (gSoundParams[SFX_BANK_SHIFT(req->sfxId)][SFX_INDEX(req->sfxId)].importance >= evictImportance) {
index = evictIndex;
} else {
@@ -241,23 +252,24 @@ void Audio_ProcessSoundRequest(void) {
}
}
}
- if (count == D_80130594[D_801333CC][bankId]) {
+ if (count == gUsedChannelsPerBank[gSfxChannelLayout][bankId]) {
soundParams = &gSoundParams[SFX_BANK_SHIFT(req->sfxId)][SFX_INDEX(req->sfxId)];
if ((req->sfxId & 0xC00) || (soundParams->params & 4) || (index == evictIndex)) {
- if ((gSoundBanks[bankId][index].sfxParams & 8) && gSoundBanks[bankId][index].unk_2A != 1) {
- Audio_ClearBGMMute(gSoundBanks[bankId][index].unk_2E);
+ if ((gSoundBanks[bankId][index].sfxParams & 8) &&
+ gSoundBanks[bankId][index].state != SFX_STATE_QUEUED) {
+ Audio_ClearBGMMute(gSoundBanks[bankId][index].channelIdx);
}
- gSoundBanks[bankId][index].unk_C = req->unk_8;
+ gSoundBanks[bankId][index].token = req->token;
gSoundBanks[bankId][index].sfxId = req->sfxId;
- gSoundBanks[bankId][index].unk_2A = 1;
- gSoundBanks[bankId][index].unk_2B = 2;
+ gSoundBanks[bankId][index].state = SFX_STATE_QUEUED;
+ gSoundBanks[bankId][index].freshness = 2;
gSoundBanks[bankId][index].freqScale = req->freqScale;
- gSoundBanks[bankId][index].unk_14 = req->unk_10;
+ gSoundBanks[bankId][index].vol = req->vol;
gSoundBanks[bankId][index].reverbAdd = req->reverbAdd;
gSoundBanks[bankId][index].sfxParams = soundParams->params;
gSoundBanks[bankId][index].sfxImportance = soundParams->importance;
- } else if (gSoundBanks[bankId][index].unk_2A == 5) {
- gSoundBanks[bankId][index].unk_2A = 4;
+ } else if (gSoundBanks[bankId][index].state == SFX_STATE_PLAYING_2) {
+ gSoundBanks[bankId][index].state = SFX_STATE_PLAYING_1;
}
index = 0;
}
@@ -266,93 +278,95 @@ void Audio_ProcessSoundRequest(void) {
index = gSoundBanks[bankId][index].next;
}
}
- if (gSoundBanks[bankId][D_8016E1A8[bankId]].next != 0xFF && index != 0) {
- index = D_8016E1A8[bankId];
+ if (gSoundBanks[bankId][sSoundBankFreeListStart[bankId]].next != 0xFF && index != 0) {
+ index = sSoundBankFreeListStart[bankId];
entry = &gSoundBanks[bankId][index];
entry->posX = &req->pos->x;
entry->posY = &req->pos->y;
entry->posZ = &req->pos->z;
- entry->unk_C = req->unk_8;
+ entry->token = req->token;
entry->freqScale = req->freqScale;
- entry->unk_14 = req->unk_10;
+ entry->vol = req->vol;
entry->reverbAdd = req->reverbAdd;
soundParams = &gSoundParams[SFX_BANK_SHIFT(req->sfxId)][SFX_INDEX(req->sfxId)];
entry->sfxParams = soundParams->params;
entry->sfxImportance = soundParams->importance;
entry->sfxId = req->sfxId;
- entry->unk_2A = 1;
- entry->unk_2B = 2;
- entry->prev = D_8016E1A0[bankId];
- gSoundBanks[bankId][D_8016E1A0[bankId]].next = D_8016E1A8[bankId];
- D_8016E1A0[bankId] = D_8016E1A8[bankId];
- D_8016E1A8[bankId] = gSoundBanks[bankId][D_8016E1A8[bankId]].next;
- gSoundBanks[bankId][D_8016E1A8[bankId]].prev = 0xFF;
+ entry->state = SFX_STATE_QUEUED;
+ entry->freshness = 2;
+ entry->prev = sSoundBankListEnd[bankId];
+ gSoundBanks[bankId][sSoundBankListEnd[bankId]].next = sSoundBankFreeListStart[bankId];
+ sSoundBankListEnd[bankId] = sSoundBankFreeListStart[bankId];
+ sSoundBankFreeListStart[bankId] = gSoundBanks[bankId][sSoundBankFreeListStart[bankId]].next;
+ gSoundBanks[bankId][sSoundBankFreeListStart[bankId]].prev = 0xFF;
entry->next = 0xFF;
}
}
-void func_800F7B54(u8 bankId, u8 bankIndex) {
- SoundBankEntry* entry = &gSoundBanks[bankId][bankIndex];
+void Audio_RemoveSoundBankEntry(u8 bankId, u8 entryIndex) {
+ SoundBankEntry* entry = &gSoundBanks[bankId][entryIndex];
u8 i;
if (entry->sfxParams & 8) {
- Audio_ClearBGMMute(entry->unk_2E);
+ Audio_ClearBGMMute(entry->channelIdx);
}
- if (bankIndex == D_8016E1A0[bankId]) {
- D_8016E1A0[bankId] = entry->prev;
+ if (entryIndex == sSoundBankListEnd[bankId]) {
+ sSoundBankListEnd[bankId] = entry->prev;
} else {
gSoundBanks[bankId][entry->next].prev = entry->prev;
}
gSoundBanks[bankId][entry->prev].next = entry->next;
- entry->next = D_8016E1A8[bankId];
+ entry->next = sSoundBankFreeListStart[bankId];
entry->prev = 0xFF;
- gSoundBanks[bankId][D_8016E1A8[bankId]].prev = bankIndex;
- D_8016E1A8[bankId] = bankIndex;
- entry->unk_2A = 0;
-
- for (i = 0; i < D_80130578[D_801333CC][bankId]; i++) {
- if (D_8016E1B8[bankId][i].unk_4 == bankIndex) {
- D_8016E1B8[bankId][i].unk_4 = 0xFF;
- i = D_80130578[D_801333CC][bankId];
+ gSoundBanks[bankId][sSoundBankFreeListStart[bankId]].prev = entryIndex;
+ sSoundBankFreeListStart[bankId] = entryIndex;
+ entry->state = SFX_STATE_EMPTY;
+
+ for (i = 0; i < gChannelsPerBank[gSfxChannelLayout][bankId]; i++) {
+ if (gActiveSounds[bankId][i].entryIndex == entryIndex) {
+ gActiveSounds[bankId][i].entryIndex = 0xFF;
+ i = gChannelsPerBank[gSfxChannelLayout][bankId];
}
}
}
-void func_800F7CEC(u8 arg0) {
- u8 phi_s3;
- u8 spAE;
- u8 phi_s4;
+void Audio_ChooseActiveSounds(u8 bankId) {
+ u8 numChosenSounds;
+ u8 numChannels;
+ u8 entryIndex;
u8 i;
u8 j;
- u8 phi_s0;
+ u8 k;
u8 sfxImportance;
- u8 phi_v1_5;
- u8 temp2;
+ u8 needNewSound;
+ u8 chosenEntryIndex;
u16 temp3;
f32 tempf1;
SoundBankEntry* entry;
- Struct_800F7CEC sp84[3];
- Struct_800F7CEC* temp_s4_3;
+ ActiveSound chosenSounds[MAX_CHANNELS_PER_BANK];
+ ActiveSound* activeSound;
s32 pad;
- phi_s3 = 0;
- for (i = 0; i < 3; i++) {
- sp84[i].priority = 0x7FFFFFFF;
- sp84[i].unk_4 = 0xFF;
+ numChosenSounds = 0;
+ for (i = 0; i < MAX_CHANNELS_PER_BANK; i++) {
+ chosenSounds[i].priority = 0x7FFFFFFF;
+ chosenSounds[i].entryIndex = 0xFF;
}
- phi_s4 = gSoundBanks[arg0][0].next;
- phi_s0 = 0;
- while (phi_s4 != 0xFF) {
- if ((1 == gSoundBanks[arg0][phi_s4].unk_2A) && (gSoundBanks[arg0][phi_s4].sfxId & 0xC00)) {
- gSoundBanks[arg0][phi_s4].unk_2B--;
- } else if (!(gSoundBanks[arg0][phi_s4].sfxId & 0xC00) && (gSoundBanks[arg0][phi_s4].unk_2A == 5)) {
- Audio_QueueCmdS8((gSoundBanks[arg0][phi_s4].unk_2E << 8) | 0x6020000, 0);
- func_800F7B54(arg0, phi_s4);
+ entryIndex = gSoundBanks[bankId][0].next;
+ k = 0;
+ while (entryIndex != 0xFF) {
+ if ((gSoundBanks[bankId][entryIndex].state == SFX_STATE_QUEUED) &&
+ (gSoundBanks[bankId][entryIndex].sfxId & 0xC00)) {
+ gSoundBanks[bankId][entryIndex].freshness--;
+ } else if (!(gSoundBanks[bankId][entryIndex].sfxId & 0xC00) &&
+ (gSoundBanks[bankId][entryIndex].state == SFX_STATE_PLAYING_2)) {
+ Audio_QueueCmdS8((gSoundBanks[bankId][entryIndex].channelIdx << 8) | 0x6020000, 0);
+ Audio_RemoveSoundBankEntry(bankId, entryIndex);
}
- if (gSoundBanks[arg0][phi_s4].unk_2B == 0) {
- func_800F7B54(arg0, phi_s4);
- } else if (gSoundBanks[arg0][phi_s4].unk_2A != 0) {
- entry = &gSoundBanks[arg0][phi_s4];
+ if (gSoundBanks[bankId][entryIndex].freshness == 0) {
+ Audio_RemoveSoundBankEntry(bankId, entryIndex);
+ } else if (gSoundBanks[bankId][entryIndex].state != SFX_STATE_EMPTY) {
+ entry = &gSoundBanks[bankId][entryIndex];
if (&D_801333D4.x == entry[0].posX) {
entry->dist = 0.0f;
@@ -369,122 +383,124 @@ void func_800F7CEC(u8 arg0) {
osSyncPrintf(D_80133344, entry->sfxId, entry->posX, entry->posZ, *entry->posX, *entry->posY,
*entry->posZ);
}
- temp3 = entry->sfxId;
+ temp3 = entry->sfxId; // fake
entry->priority = (u32)entry->dist + (SQ(0xFF - sfxImportance) * SQ(76)) + temp3 - temp3;
if (*entry->posZ < 0.0f) {
entry->priority += (s32)(-*entry->posZ * 6.0f);
}
}
if (entry->dist > SQ(1e5f)) {
- if (entry->unk_2A == 4) {
- Audio_QueueCmdS8((entry->unk_2E << 8) | 0x6020000, 0);
+ if (entry->state == SFX_STATE_PLAYING_1) {
+ Audio_QueueCmdS8((entry->channelIdx << 8) | 0x6020000, 0);
if (entry->sfxId & 0xC00) {
- func_800F7B54(arg0, phi_s4);
- phi_s4 = phi_s0;
+ Audio_RemoveSoundBankEntry(bankId, entryIndex);
+ entryIndex = k;
}
}
} else {
- spAE = D_80130578[D_801333CC][arg0];
- for (i = 0; i < spAE; i++) {
- if (sp84[i].priority >= entry->priority) {
- if (phi_s3 < D_80130578[D_801333CC][arg0]) {
- phi_s3++;
+ numChannels = gChannelsPerBank[gSfxChannelLayout][bankId];
+ for (i = 0; i < numChannels; i++) {
+ if (chosenSounds[i].priority >= entry->priority) {
+ if (numChosenSounds < gChannelsPerBank[gSfxChannelLayout][bankId]) {
+ numChosenSounds++;
}
- for (j = spAE - 1; j > i; j--) {
- sp84[j].priority = sp84[j - 1].priority;
- sp84[j].unk_4 = sp84[j - 1].unk_4;
+ for (j = numChannels - 1; j > i; j--) {
+ chosenSounds[j].priority = chosenSounds[j - 1].priority;
+ chosenSounds[j].entryIndex = chosenSounds[j - 1].entryIndex;
}
- sp84[i].priority = entry->priority;
- sp84[i].unk_4 = phi_s4;
- i = spAE; // "break;"
+ chosenSounds[i].priority = entry->priority;
+ chosenSounds[i].entryIndex = entryIndex;
+ i = numChannels; // "break;"
}
}
}
- phi_s0 = phi_s4;
+ k = entryIndex;
}
- phi_s4 = gSoundBanks[arg0][phi_s0].next;
+ entryIndex = gSoundBanks[bankId][k].next;
}
- for (i = 0; i < phi_s3; i++) {
- entry = &gSoundBanks[arg0][sp84[i].unk_4];
- if (entry->unk_2A == 1) {
- entry->unk_2A = 2;
- } else if (entry->unk_2A == 4) {
- entry->unk_2A = 3;
+ for (i = 0; i < numChosenSounds; i++) {
+ entry = &gSoundBanks[bankId][chosenSounds[i].entryIndex];
+ if (entry->state == SFX_STATE_QUEUED) {
+ entry->state = SFX_STATE_READY;
+ } else if (entry->state == SFX_STATE_PLAYING_1) {
+ entry->state = SFX_STATE_PLAYING_REFRESH;
}
}
- spAE = D_80130578[D_801333CC][arg0];
- for (i = 0; i < spAE; i++) {
- phi_v1_5 = 0;
- temp_s4_3 = &D_8016E1B8[arg0][i];
+ // Pick something to play for all channels.
+ numChannels = gChannelsPerBank[gSfxChannelLayout][bankId];
+ for (i = 0; i < numChannels; i++) {
+ needNewSound = false;
+ activeSound = &gActiveSounds[bankId][i];
- if (temp_s4_3->unk_4 == 0xFF) {
- phi_v1_5 = 1;
+ if (activeSound->entryIndex == 0xFF) {
+ needNewSound = true;
} else {
- entry = &gSoundBanks[arg0][temp_s4_3[0].unk_4];
- if (entry->unk_2A == 4) {
+ entry = &gSoundBanks[bankId][activeSound[0].entryIndex];
+ if (entry->state == SFX_STATE_PLAYING_1) {
if (entry->sfxId & 0xC00) {
- func_800F7B54(arg0, temp_s4_3->unk_4);
+ Audio_RemoveSoundBankEntry(bankId, activeSound->entryIndex);
} else {
- entry->unk_2A = 1;
+ entry->state = SFX_STATE_QUEUED;
}
- phi_v1_5 = 1;
- } else if (entry->unk_2A == 0) {
- temp_s4_3->unk_4 = 0xFF;
- phi_v1_5 = 1;
+ needNewSound = true;
+ } else if (entry->state == SFX_STATE_EMPTY) {
+ activeSound->entryIndex = 0xFF;
+ needNewSound = true;
} else {
- for (j = 0; j < spAE; j++) {
- if (temp_s4_3->unk_4 == sp84[j].unk_4) {
- sp84[j].unk_4 = 0xFF;
- j = spAE;
+ // Sound is already playing as it should, nothing to do.
+ for (j = 0; j < numChannels; j++) {
+ if (activeSound->entryIndex == chosenSounds[j].entryIndex) {
+ chosenSounds[j].entryIndex = 0xFF;
+ j = numChannels;
}
}
- phi_s3--;
+ numChosenSounds--;
}
}
- if (phi_v1_5 == 1) {
- for (j = 0; j < spAE; j++) {
- temp2 = sp84[j].unk_4;
- if ((temp2 != 0xFF) && (gSoundBanks[arg0][temp2].unk_2A != 3)) {
- for (phi_s0 = 0; phi_s0 < spAE; phi_s0++) {
- if (temp2 == D_8016E1B8[arg0][phi_s0].unk_4) {
- phi_v1_5 = 0;
- phi_s0 = spAE;
+ if (needNewSound == true) {
+ for (j = 0; j < numChannels; j++) {
+ chosenEntryIndex = chosenSounds[j].entryIndex;
+ if ((chosenEntryIndex != 0xFF) &&
+ (gSoundBanks[bankId][chosenEntryIndex].state != SFX_STATE_PLAYING_REFRESH)) {
+ for (k = 0; k < numChannels; k++) {
+ if (chosenEntryIndex == gActiveSounds[bankId][k].entryIndex) {
+ needNewSound = false;
+ k = numChannels; // "break;"
}
}
- if (phi_v1_5 == 1) {
- temp_s4_3->unk_4 = temp2;
-
- sp84[j].unk_4 = 0xFF;
-
- j = spAE + 1;
- phi_s3--;
+ if (needNewSound == true) {
+ activeSound->entryIndex = chosenEntryIndex;
+ chosenSounds[j].entryIndex = 0xFF;
+ j = numChannels + 1;
+ numChosenSounds--;
}
}
}
- if (j == spAE) {
- temp_s4_3->unk_4 = 0xFF;
+ if (j == numChannels) {
+ // nothing found
+ activeSound->entryIndex = 0xFF;
}
}
}
}
-void func_800F8480(u8 bankId) {
- u8 bankIndex;
- SequenceChannel* seqChannel;
+void Audio_PlayActiveSounds(u8 bankId) {
+ u8 entryIndex;
+ SequenceChannel* channel;
SoundBankEntry* entry;
u8 i;
- for (i = 0; i < D_80130578[D_801333CC][bankId]; i++) {
- bankIndex = D_8016E1B8[bankId][i].unk_4;
- if (bankIndex != 0xFF) {
- entry = &gSoundBanks[bankId][bankIndex];
- seqChannel = gAudioContext.seqPlayers[2].channels[D_8016E260];
- if (entry->unk_2A == 2) {
- entry->unk_2E = D_8016E260;
+ for (i = 0; i < gChannelsPerBank[gSfxChannelLayout][bankId]; i++) {
+ entryIndex = gActiveSounds[bankId][i].entryIndex;
+ if (entryIndex != 0xFF) {
+ entry = &gSoundBanks[bankId][entryIndex];
+ channel = gAudioContext.seqPlayers[2].channels[sCurSfxPlayerChannelIdx];
+ if (entry->state == SFX_STATE_READY) {
+ entry->channelIdx = sCurSfxPlayerChannelIdx;
if (entry->sfxParams & 8) {
- Audio_QueueSeqCmdMute(D_8016E260);
+ Audio_QueueSeqCmdMute(sCurSfxPlayerChannelIdx);
}
if (entry->sfxParams & 0xC0) {
switch (entry->sfxParams & 0xC0) {
@@ -502,47 +518,48 @@ void func_800F8480(u8 bankId) {
break;
}
}
- Audio_SetSoundProperties(bankId, bankIndex, D_8016E260);
- Audio_QueueCmdS8(0x06020000 | ((D_8016E260 & 0xFF) << 8), 1);
- Audio_QueueCmdS8(0x06020000 | ((D_8016E260 & 0xFF) << 8) | 4, entry->sfxId & 0xFF);
- if (D_80130570[bankId] != 0) {
- Audio_QueueCmdS8(0x06020000 | ((D_8016E260 & 0xFF) << 8) | 5, (entry->sfxId & 0x100) >> 8);
+ Audio_SetSoundProperties(bankId, entryIndex, sCurSfxPlayerChannelIdx);
+ Audio_QueueCmdS8(0x06020000 | ((sCurSfxPlayerChannelIdx & 0xFF) << 8), 1);
+ Audio_QueueCmdS8(0x06020000 | ((sCurSfxPlayerChannelIdx & 0xFF) << 8) | 4, entry->sfxId & 0xFF);
+ if (gIsLargeSoundBank[bankId]) {
+ Audio_QueueCmdS8(0x06020000 | ((sCurSfxPlayerChannelIdx & 0xFF) << 8) | 5,
+ (entry->sfxId & 0x100) >> 8);
}
if (entry->sfxId & 0xC00) {
- entry->unk_2A = 4;
+ entry->state = SFX_STATE_PLAYING_1;
} else {
- entry->unk_2A = 5;
+ entry->state = SFX_STATE_PLAYING_2;
}
- } else if ((u8)seqChannel->soundScriptIO[1] == 0xFF) {
- func_800F7B54(bankId, bankIndex);
- } else if (entry->unk_2A == 3) {
- Audio_SetSoundProperties(bankId, bankIndex, D_8016E260);
+ } else if ((u8)channel->soundScriptIO[1] == 0xFF) {
+ Audio_RemoveSoundBankEntry(bankId, entryIndex);
+ } else if (entry->state == SFX_STATE_PLAYING_REFRESH) {
+ Audio_SetSoundProperties(bankId, entryIndex, sCurSfxPlayerChannelIdx);
if (entry->sfxId & 0xC00) {
- entry->unk_2A = 4;
+ entry->state = SFX_STATE_PLAYING_1;
} else {
- entry->unk_2A = 5;
+ entry->state = SFX_STATE_PLAYING_2;
}
}
}
- D_8016E260++;
+ sCurSfxPlayerChannelIdx++;
}
}
-void func_800F87A0(u8 bankId) {
+void Audio_StopSfxByBank(u8 bankId) {
SoundBankEntry* entry;
s32 pad;
SoundBankEntry cmp;
- u8 bankIndex = gSoundBanks[bankId][0].next;
+ u8 entryIndex = gSoundBanks[bankId][0].next;
- while (bankIndex != 0xFF) {
- entry = &gSoundBanks[bankId][bankIndex];
- if (entry->unk_2A >= 3) {
- Audio_QueueCmdS8(0x06020000 | ((entry->unk_2E & 0xFF) << 8), 0);
+ while (entryIndex != 0xFF) {
+ entry = &gSoundBanks[bankId][entryIndex];
+ if (entry->state >= SFX_STATE_PLAYING_REFRESH) {
+ Audio_QueueCmdS8(0x06020000 | ((entry->channelIdx & 0xFF) << 8), 0);
}
- if (entry->unk_2A != 0) {
- func_800F7B54(bankId, bankIndex);
+ if (entry->state != SFX_STATE_EMPTY) {
+ Audio_RemoveSoundBankEntry(bankId, entryIndex);
}
- bankIndex = gSoundBanks[bankId][0].next;
+ entryIndex = gSoundBanks[bankId][0].next;
}
cmp.sfxId = bankId << 12;
Audio_RemoveMatchingSoundRequests(0, &cmp);
@@ -550,26 +567,26 @@ void func_800F87A0(u8 bankId) {
void func_800F8884(u8 bankId, Vec3f* pos) {
SoundBankEntry* entry;
- u8 bankIndex = gSoundBanks[bankId][0].next;
- u8 bankIndex2 = 0;
+ u8 entryIndex = gSoundBanks[bankId][0].next;
+ u8 prevEntryIndex = 0;
- while (bankIndex != 0xFF) {
- entry = &gSoundBanks[bankId][bankIndex];
+ while (entryIndex != 0xFF) {
+ entry = &gSoundBanks[bankId][entryIndex];
if (entry->posX == &pos->x) {
- if (entry->unk_2A >= 3) {
- Audio_QueueCmdS8(0x06020000 | ((entry->unk_2E & 0xFF) << 8), 0);
+ if (entry->state >= SFX_STATE_PLAYING_REFRESH) {
+ Audio_QueueCmdS8(0x06020000 | ((entry->channelIdx & 0xFF) << 8), 0);
}
- if (entry->unk_2A != 0) {
- func_800F7B54(bankId, bankIndex);
+ if (entry->state != SFX_STATE_EMPTY) {
+ Audio_RemoveSoundBankEntry(bankId, entryIndex);
}
} else {
- bankIndex2 = bankIndex;
+ prevEntryIndex = entryIndex;
}
- bankIndex = gSoundBanks[bankId][bankIndex2].next;
+ entryIndex = gSoundBanks[bankId][prevEntryIndex].next;
}
}
-void func_800F89A0(u8 bankId, Vec3f* pos) {
+void Audio_StopSfxByPosAndBank(u8 bankId, Vec3f* pos) {
SoundBankEntry cmp;
func_800F8884(bankId, pos);
@@ -578,7 +595,7 @@ void func_800F89A0(u8 bankId, Vec3f* pos) {
Audio_RemoveMatchingSoundRequests(1, &cmp);
}
-void func_800F89E8(Vec3f* pos) {
+void Audio_StopSfxByPos(Vec3f* pos) {
u8 i;
SoundBankEntry cmp;
@@ -589,27 +606,27 @@ void func_800F89E8(Vec3f* pos) {
Audio_RemoveMatchingSoundRequests(2, &cmp);
}
-void func_800F8A44(Vec3f* pos, u16 sfxId) {
+void Audio_StopSfxByPosAndId(Vec3f* pos, u16 sfxId) {
SoundBankEntry* entry;
- u8 bankIndex = gSoundBanks[SFX_BANK(sfxId)][0].next;
- u8 bankIndex2 = 0;
+ u8 entryIndex = gSoundBanks[SFX_BANK(sfxId)][0].next;
+ u8 prevEntryIndex = 0;
SoundBankEntry cmp;
- while (bankIndex != 0xFF) {
- entry = &gSoundBanks[SFX_BANK(sfxId)][bankIndex];
+ while (entryIndex != 0xFF) {
+ entry = &gSoundBanks[SFX_BANK(sfxId)][entryIndex];
if (entry->posX == &pos->x && entry->sfxId == sfxId) {
- if (entry->unk_2A >= 3) {
- Audio_QueueCmdS8(0x06020000 | ((entry->unk_2E & 0xFF) << 8), 0);
+ if (entry->state >= SFX_STATE_PLAYING_REFRESH) {
+ Audio_QueueCmdS8(0x06020000 | ((entry->channelIdx & 0xFF) << 8), 0);
}
- if (entry->unk_2A != 0) {
- func_800F7B54(SFX_BANK(sfxId), bankIndex);
+ if (entry->state != SFX_STATE_EMPTY) {
+ Audio_RemoveSoundBankEntry(SFX_BANK(sfxId), entryIndex);
}
- bankIndex = 0xFF;
+ entryIndex = 0xFF;
} else {
- bankIndex2 = bankIndex;
+ prevEntryIndex = entryIndex;
}
- if (bankIndex != 0xFF) {
- bankIndex = gSoundBanks[SFX_BANK(sfxId)][bankIndex2].next;
+ if (entryIndex != 0xFF) {
+ entryIndex = gSoundBanks[SFX_BANK(sfxId)][prevEntryIndex].next;
}
}
cmp.posX = &pos->x;
@@ -617,52 +634,52 @@ void func_800F8A44(Vec3f* pos, u16 sfxId) {
Audio_RemoveMatchingSoundRequests(3, &cmp);
}
-void func_800F8BA0(u8 arg0, u16 sfxId) {
+void Audio_StopSfxByTokenAndId(u8 token, u16 sfxId) {
SoundBankEntry* entry;
- u8 bankIndex = gSoundBanks[SFX_BANK(sfxId)][0].next;
- u8 bankIndex2 = 0;
+ u8 entryIndex = gSoundBanks[SFX_BANK(sfxId)][0].next;
+ u8 prevEntryIndex = 0;
SoundBankEntry cmp;
- while (bankIndex != 0xFF) {
- entry = &gSoundBanks[SFX_BANK(sfxId)][bankIndex];
- if (entry->unk_C == arg0 && entry->sfxId == sfxId) {
- if (entry->unk_2A >= 3) {
- Audio_QueueCmdS8(0x06020000 | ((entry->unk_2E & 0xFF) << 8), 0);
+ while (entryIndex != 0xFF) {
+ entry = &gSoundBanks[SFX_BANK(sfxId)][entryIndex];
+ if (entry->token == token && entry->sfxId == sfxId) {
+ if (entry->state >= SFX_STATE_PLAYING_REFRESH) {
+ Audio_QueueCmdS8(0x06020000 | ((entry->channelIdx & 0xFF) << 8), 0);
}
- if (entry->unk_2A != 0) {
- func_800F7B54(SFX_BANK(sfxId), bankIndex);
+ if (entry->state != SFX_STATE_EMPTY) {
+ Audio_RemoveSoundBankEntry(SFX_BANK(sfxId), entryIndex);
}
} else {
- bankIndex2 = bankIndex;
+ prevEntryIndex = entryIndex;
}
- if (bankIndex != 0xFF) {
- bankIndex = gSoundBanks[SFX_BANK(sfxId)][bankIndex2].next;
+ if (entryIndex != 0xFF) {
+ entryIndex = gSoundBanks[SFX_BANK(sfxId)][prevEntryIndex].next;
}
}
- cmp.unk_C = arg0;
+ cmp.token = token;
cmp.sfxId = sfxId;
Audio_RemoveMatchingSoundRequests(4, &cmp);
}
-void Audio_StopSfx(u32 sfxId) {
+void Audio_StopSfxById(u32 sfxId) {
SoundBankEntry* entry;
- u8 bankIndex = gSoundBanks[SFX_BANK(sfxId)][0].next;
- u8 bankIndex2 = 0;
+ u8 entryIndex = gSoundBanks[SFX_BANK(sfxId)][0].next;
+ u8 prevEntryIndex = 0;
SoundBankEntry cmp;
- while (bankIndex != 0xFF) {
- entry = &gSoundBanks[SFX_BANK(sfxId)][bankIndex];
+ while (entryIndex != 0xFF) {
+ entry = &gSoundBanks[SFX_BANK(sfxId)][entryIndex];
if (entry->sfxId == sfxId) {
- if (entry->unk_2A >= 3) {
- Audio_QueueCmdS8(0x06020000 | ((entry->unk_2E & 0xFF) << 8), 0);
+ if (entry->state >= SFX_STATE_PLAYING_REFRESH) {
+ Audio_QueueCmdS8(0x06020000 | ((entry->channelIdx & 0xFF) << 8), 0);
}
- if (entry->unk_2A != 0) {
- func_800F7B54(SFX_BANK(sfxId), bankIndex);
+ if (entry->state != SFX_STATE_EMPTY) {
+ Audio_RemoveSoundBankEntry(SFX_BANK(sfxId), entryIndex);
}
} else {
- bankIndex2 = bankIndex;
+ prevEntryIndex = entryIndex;
}
- bankIndex = gSoundBanks[SFX_BANK(sfxId)][bankIndex2].next;
+ entryIndex = gSoundBanks[SFX_BANK(sfxId)][prevEntryIndex].next;
}
cmp.sfxId = sfxId;
Audio_RemoveMatchingSoundRequests(5, &cmp);
@@ -675,72 +692,72 @@ void Audio_ProcessSoundRequests(void) {
}
}
-void func_800F8EA0(u8 arg0, u8 arg1, u16 arg2) {
- if (arg2 == 0) {
- arg2++;
+void Audio_SetUnusedBankLerp(u8 bankId, u8 target, u16 delay) {
+ if (delay == 0) {
+ delay++;
}
- D_8016E270[arg0].unk_4 = arg1 / 127.0f;
- D_8016E270[arg0].unk_C = arg2;
- D_8016E270[arg0].unk_8 = ((D_8016E270[arg0].unk_0 - D_8016E270[arg0].unk_4) / arg2);
+ sUnusedBankLerp[bankId].target = target / 127.0f;
+ sUnusedBankLerp[bankId].remainingFrames = delay;
+ sUnusedBankLerp[bankId].step = ((sUnusedBankLerp[bankId].value - sUnusedBankLerp[bankId].target) / delay);
}
-void func_800F8F34(u8 arg0) {
- if (D_8016E270[arg0].unk_C != 0) {
- D_8016E270[arg0].unk_C--;
- if (D_8016E270[arg0].unk_C != 0) {
- D_8016E270[arg0].unk_0 -= D_8016E270[arg0].unk_8;
+void Audio_StepUnusedBankLerp(u8 bankId) {
+ if (sUnusedBankLerp[bankId].remainingFrames != 0) {
+ sUnusedBankLerp[bankId].remainingFrames--;
+ if (sUnusedBankLerp[bankId].remainingFrames != 0) {
+ sUnusedBankLerp[bankId].value -= sUnusedBankLerp[bankId].step;
} else {
- D_8016E270[arg0].unk_0 = D_8016E270[arg0].unk_4;
+ sUnusedBankLerp[bankId].value = sUnusedBankLerp[bankId].target;
}
}
}
void func_800F8F88(void) {
- u8 i;
+ u8 bankId;
if (IS_SEQUENCE_CHANNEL_VALID(gAudioContext.seqPlayers[2].channels[0])) {
- D_8016E260 = 0;
- for (i = 0; i < ARRAY_COUNT(gSoundBanks); i++) {
- func_800F7CEC(i);
- func_800F8480(i);
- func_800F8F34(i);
+ sCurSfxPlayerChannelIdx = 0;
+ for (bankId = 0; bankId < ARRAY_COUNT(gSoundBanks); bankId++) {
+ Audio_ChooseActiveSounds(bankId);
+ Audio_PlayActiveSounds(bankId);
+ Audio_StepUnusedBankLerp(bankId);
}
}
}
u8 Audio_IsSfxPlaying(u32 sfxId) {
SoundBankEntry* entry;
- u8 bankIndex = gSoundBanks[SFX_BANK(sfxId)][0].next;
+ u8 entryIndex = gSoundBanks[SFX_BANK(sfxId)][0].next;
- while (bankIndex != 0xFF) {
- entry = &gSoundBanks[SFX_BANK(sfxId)][bankIndex];
+ while (entryIndex != 0xFF) {
+ entry = &gSoundBanks[SFX_BANK(sfxId)][entryIndex];
if (entry->sfxId == sfxId) {
return true;
}
- bankIndex = entry->next;
+ entryIndex = entry->next;
}
return false;
}
-void func_800F905C(void) {
+void Audio_ResetSounds(void) {
u8 bankId;
u8 i;
- u8 bankIndex;
+ u8 entryIndex;
sSoundRequestWriteIndex = 0;
sSoundRequestReadIndex = 0;
D_801333D0 = 0;
for (bankId = 0; bankId < ARRAY_COUNT(gSoundBanks); bankId++) {
- D_8016E1A0[bankId] = 0;
- D_8016E1A8[bankId] = 1;
- D_8016E1B0[bankId] = 0;
+ sSoundBankListEnd[bankId] = 0;
+ sSoundBankFreeListStart[bankId] = 1;
+ sSoundBankUnused[bankId] = 0;
gSoundBankMuted[bankId] = false;
- D_8016E270[bankId].unk_0 = 1.0f;
- D_8016E270[bankId].unk_C = 0;
+ sUnusedBankLerp[bankId].value = 1.0f;
+ sUnusedBankLerp[bankId].remainingFrames = 0;
}
for (bankId = 0; bankId < ARRAY_COUNT(gSoundBanks); bankId++) {
- for (i = 0; i < 3; i++) {
- D_8016E1B8[bankId][i].unk_4 = 0xFF;
+ for (i = 0; i < MAX_CHANNELS_PER_BANK; i++) {
+ gActiveSounds[bankId][i].entryIndex = 0xFF;
}
}
for (bankId = 0; bankId < ARRAY_COUNT(gSoundBanks); bankId++) {
@@ -755,9 +772,9 @@ void func_800F905C(void) {
}
if (D_801333F8 == 0) {
for (bankId = 0; bankId < 10; bankId++) {
- gAudioSEFlagSwapSource[bankId] = 0;
- gAudioSEFlagSwapTarget[bankId] = 0;
- gAudioSEFlagSwapMode[bankId] = 0;
+ gAudioSfxSwapSource[bankId] = 0;
+ gAudioSfxSwapTarget[bankId] = 0;
+ gAudioSfxSwapMode[bankId] = 0;
}
D_801333F8++;
}
diff --git a/src/code/code_800F9280.c b/src/code/code_800F9280.c
index ca3884b53..f6eddd4a6 100644
--- a/src/code/code_800F9280.c
+++ b/src/code/code_800F9280.c
@@ -9,56 +9,55 @@ extern u8 sSeqCmdRdPos;
extern u8 sSeqCmdWrPos;
extern u8 D_80133408;
extern u8 D_80133418;
-extern u8 D_801333CC;
extern u8 D_80133410[];
// TODO: clean up these macros. They are similar to ones in code_800EC960.c but without casts.
-#define Audio_StartSeq(seqIdx, fadeTimer, seqId) \
- Audio_QueueSeqCmd(0x00000000 | ((seqIdx) << 24) | ((fadeTimer) << 16) | (seqId))
-#define Audio_SeqCmdA(seqIdx, a) Audio_QueueSeqCmd(0xA0000000 | ((seqIdx) << 24) | (a))
-#define Audio_SeqCmdB30(seqIdx, a, b) Audio_QueueSeqCmd(0xB0003000 | ((seqIdx) << 24) | ((a) << 16) | (b))
-#define Audio_SeqCmdB40(seqIdx, a, b) Audio_QueueSeqCmd(0xB0004000 | ((seqIdx) << 24) | ((a) << 16) | (b))
-#define Audio_SeqCmd3(seqIdx, a) Audio_QueueSeqCmd(0x30000000 | ((seqIdx) << 24) | (a))
-#define Audio_SeqCmd5(seqIdx, a, b) Audio_QueueSeqCmd(0x50000000 | ((seqIdx) << 24) | ((a) << 16) | (b))
-#define Audio_SeqCmd4(seqIdx, a, b) Audio_QueueSeqCmd(0x40000000 | ((seqIdx) << 24) | ((a) << 16) | (b))
-#define Audio_SetVolScaleNow(seqIdx, volFadeTimer, volScale) \
- Audio_ProcessSeqCmd(0x40000000 | ((u8)seqIdx << 24) | ((u8)volFadeTimer << 16) | ((u8)(volScale * 127.0f)));
-
-void func_800F9280(u8 seqIdx, u8 seqId, u8 arg2, u16 fadeTimer) {
+#define Audio_StartSeq(playerIdx, fadeTimer, seqId) \
+ Audio_QueueSeqCmd(0x00000000 | ((playerIdx) << 24) | ((fadeTimer) << 16) | (seqId))
+#define Audio_SeqCmdA(playerIdx, a) Audio_QueueSeqCmd(0xA0000000 | ((playerIdx) << 24) | (a))
+#define Audio_SeqCmdB30(playerIdx, a, b) Audio_QueueSeqCmd(0xB0003000 | ((playerIdx) << 24) | ((a) << 16) | (b))
+#define Audio_SeqCmdB40(playerIdx, a, b) Audio_QueueSeqCmd(0xB0004000 | ((playerIdx) << 24) | ((a) << 16) | (b))
+#define Audio_SeqCmd3(playerIdx, a) Audio_QueueSeqCmd(0x30000000 | ((playerIdx) << 24) | (a))
+#define Audio_SeqCmd5(playerIdx, a, b) Audio_QueueSeqCmd(0x50000000 | ((playerIdx) << 24) | ((a) << 16) | (b))
+#define Audio_SeqCmd4(playerIdx, a, b) Audio_QueueSeqCmd(0x40000000 | ((playerIdx) << 24) | ((a) << 16) | (b))
+#define Audio_SetVolScaleNow(playerIdx, volFadeTimer, volScale) \
+ Audio_ProcessSeqCmd(0x40000000 | ((u8)playerIdx << 24) | ((u8)volFadeTimer << 16) | ((u8)(volScale * 127.0f)));
+
+void func_800F9280(u8 playerIdx, u8 seqId, u8 arg2, u16 fadeTimer) {
u8 i;
u16 dur;
s32 pad;
- if (D_80133408 == 0 || seqIdx == 2) {
+ if (D_80133408 == 0 || playerIdx == 2) {
arg2 &= 0x7F;
if (arg2 == 0x7F) {
dur = (fadeTimer >> 3) * 60 * gAudioContext.audioBufferParameters.updatesPerFrame;
- Audio_QueueCmdS32(0x85000000 | _SHIFTL(seqIdx, 16, 8) | _SHIFTL(seqId, 8, 8), dur);
+ Audio_QueueCmdS32(0x85000000 | _SHIFTL(playerIdx, 16, 8) | _SHIFTL(seqId, 8, 8), dur);
} else {
- Audio_QueueCmdS32(0x82000000 | _SHIFTL(seqIdx, 16, 8) | _SHIFTL(seqId, 8, 8),
+ Audio_QueueCmdS32(0x82000000 | _SHIFTL(playerIdx, 16, 8) | _SHIFTL(seqId, 8, 8),
(fadeTimer * (u16)gAudioContext.audioBufferParameters.updatesPerFrame) / 4);
}
- D_8016E750[seqIdx].unk_254 = seqId | (arg2 << 8);
- D_8016E750[seqIdx].unk_256 = seqId | (arg2 << 8);
+ D_8016E750[playerIdx].unk_254 = seqId | (arg2 << 8);
+ D_8016E750[playerIdx].unk_256 = seqId | (arg2 << 8);
- if (D_8016E750[seqIdx].volCur != 1.0f) {
- Audio_QueueCmdF32(0x41000000 | _SHIFTL(seqIdx, 16, 8), D_8016E750[seqIdx].volCur);
+ if (D_8016E750[playerIdx].volCur != 1.0f) {
+ Audio_QueueCmdF32(0x41000000 | _SHIFTL(playerIdx, 16, 8), D_8016E750[playerIdx].volCur);
}
- D_8016E750[seqIdx].unk_28 = 0;
- D_8016E750[seqIdx].unk_18 = 0;
- D_8016E750[seqIdx].unk_14 = 0;
+ D_8016E750[playerIdx].unk_28 = 0;
+ D_8016E750[playerIdx].unk_18 = 0;
+ D_8016E750[playerIdx].unk_14 = 0;
for (i = 0; i < 0x10; i++) {
- D_8016E750[seqIdx].unk_50[i].unk_00 = 1.0f;
- D_8016E750[seqIdx].unk_50[i].unk_0C = 0;
- D_8016E750[seqIdx].unk_50[i].unk_10 = 1.0f;
- D_8016E750[seqIdx].unk_50[i].unk_1C = 0;
+ D_8016E750[playerIdx].unk_50[i].unk_00 = 1.0f;
+ D_8016E750[playerIdx].unk_50[i].unk_0C = 0;
+ D_8016E750[playerIdx].unk_50[i].unk_10 = 1.0f;
+ D_8016E750[playerIdx].unk_50[i].unk_1C = 0;
}
- D_8016E750[seqIdx].unk_250 = 0;
- D_8016E750[seqIdx].unk_252 = 0;
+ D_8016E750[playerIdx].unk_250 = 0;
+ D_8016E750[playerIdx].unk_252 = 0;
}
}
@@ -102,7 +101,7 @@ void Audio_ProcessSeqCmd(u32 cmd) {
u8 spec;
u8 op;
u8 subOp;
- u8 seqIdx;
+ u8 playerIdx;
u8 seqId;
u8 seqArgs;
u8 found;
@@ -119,7 +118,7 @@ void Audio_ProcessSeqCmd(u32 cmd) {
}
op = cmd >> 28;
- seqIdx = (cmd & 0xF000000) >> 24;
+ playerIdx = (cmd & 0xF000000) >> 24;
switch (op) {
case 0x0:
@@ -127,15 +126,15 @@ void Audio_ProcessSeqCmd(u32 cmd) {
seqId = cmd & 0xFF;
seqArgs = (cmd & 0xFF00) >> 8;
fadeTimer = (cmd & 0xFF0000) >> 13;
- if ((D_8016E750[seqIdx].unk_260 == 0) && (seqArgs < 0x80)) {
- func_800F9280(seqIdx, seqId, seqArgs, fadeTimer);
+ if ((D_8016E750[playerIdx].unk_260 == 0) && (seqArgs < 0x80)) {
+ func_800F9280(playerIdx, seqId, seqArgs, fadeTimer);
}
break;
case 0x1:
// disable seq player
fadeTimer = (cmd & 0xFF0000) >> 13;
- func_800F9474(seqIdx, fadeTimer);
+ func_800F9474(playerIdx, fadeTimer);
break;
case 0x2:
@@ -144,35 +143,35 @@ void Audio_ProcessSeqCmd(u32 cmd) {
seqArgs = (cmd & 0xFF00) >> 8;
fadeTimer = (cmd & 0xFF0000) >> 13;
new_var = seqArgs;
- for (i = 0; i < D_8016E348[seqIdx]; i++) {
- if (D_8016E320[seqIdx][i].unk_0 == seqId) {
+ for (i = 0; i < D_8016E348[playerIdx]; i++) {
+ if (D_8016E320[playerIdx][i].unk_0 == seqId) {
if (i == 0) {
- func_800F9280(seqIdx, seqId, seqArgs, fadeTimer);
+ func_800F9280(playerIdx, seqId, seqArgs, fadeTimer);
}
return;
}
}
- found = D_8016E348[seqIdx];
- for (i = 0; i < D_8016E348[seqIdx]; i++) {
- if (D_8016E320[seqIdx][i].unk_1 <= new_var) {
+ found = D_8016E348[playerIdx];
+ for (i = 0; i < D_8016E348[playerIdx]; i++) {
+ if (D_8016E320[playerIdx][i].unk_1 <= new_var) {
found = i;
- i = D_8016E348[seqIdx]; // "break;"
+ i = D_8016E348[playerIdx]; // "break;"
}
}
- if (D_8016E348[seqIdx] < 5) {
- D_8016E348[seqIdx]++;
+ if (D_8016E348[playerIdx] < 5) {
+ D_8016E348[playerIdx]++;
}
- for (i = D_8016E348[seqIdx] - 1; i != found; i--) {
- D_8016E320[seqIdx][i].unk_1 = D_8016E320[seqIdx][i - 1].unk_1;
- D_8016E320[seqIdx][i].unk_0 = D_8016E320[seqIdx][i - 1].unk_0;
+ for (i = D_8016E348[playerIdx] - 1; i != found; i--) {
+ D_8016E320[playerIdx][i].unk_1 = D_8016E320[playerIdx][i - 1].unk_1;
+ D_8016E320[playerIdx][i].unk_0 = D_8016E320[playerIdx][i - 1].unk_0;
}
- D_8016E320[seqIdx][found].unk_1 = seqArgs;
- D_8016E320[seqIdx][found].unk_0 = seqId;
+ D_8016E320[playerIdx][found].unk_1 = seqArgs;
+ D_8016E320[playerIdx][found].unk_0 = seqId;
if (found == 0) {
- func_800F9280(seqIdx, seqId, seqArgs, fadeTimer);
+ func_800F9280(playerIdx, seqId, seqArgs, fadeTimer);
}
break;
@@ -181,26 +180,26 @@ void Audio_ProcessSeqCmd(u32 cmd) {
seqId = cmd & 0xFF;
fadeTimer = (cmd & 0xFF0000) >> 13;
- found = D_8016E348[seqIdx];
- for (i = 0; i < D_8016E348[seqIdx]; i++) {
- if (D_8016E320[seqIdx][i].unk_0 == seqId) {
+ found = D_8016E348[playerIdx];
+ for (i = 0; i < D_8016E348[playerIdx]; i++) {
+ if (D_8016E320[playerIdx][i].unk_0 == seqId) {
found = i;
- i = D_8016E348[seqIdx]; // "break;"
+ i = D_8016E348[playerIdx]; // "break;"
}
}
- if (found != D_8016E348[seqIdx]) {
- for (i = found; i < D_8016E348[seqIdx] - 1; i++) {
- D_8016E320[seqIdx][i].unk_1 = D_8016E320[seqIdx][i + 1].unk_1;
- D_8016E320[seqIdx][i].unk_0 = D_8016E320[seqIdx][i + 1].unk_0;
+ if (found != D_8016E348[playerIdx]) {
+ for (i = found; i < D_8016E348[playerIdx] - 1; i++) {
+ D_8016E320[playerIdx][i].unk_1 = D_8016E320[playerIdx][i + 1].unk_1;
+ D_8016E320[playerIdx][i].unk_0 = D_8016E320[playerIdx][i + 1].unk_0;
}
- D_8016E348[seqIdx]--;
+ D_8016E348[playerIdx]--;
}
if (found == 0) {
- func_800F9474(seqIdx, fadeTimer);
- if (D_8016E348[seqIdx] != 0) {
- func_800F9280(seqIdx, D_8016E320[seqIdx][0].unk_0, D_8016E320[seqIdx][0].unk_1, fadeTimer);
+ func_800F9474(playerIdx, fadeTimer);
+ if (D_8016E348[playerIdx] != 0) {
+ func_800F9280(playerIdx, D_8016E320[playerIdx][0].unk_0, D_8016E320[playerIdx][0].unk_1, fadeTimer);
}
}
break;
@@ -212,10 +211,11 @@ void Audio_ProcessSeqCmd(u32 cmd) {
if (duration == 0) {
duration++;
}
- D_8016E750[seqIdx].volTarget = (f32)val / 127.0f;
- if (D_8016E750[seqIdx].volCur != D_8016E750[seqIdx].volTarget) {
- D_8016E750[seqIdx].unk_08 = (D_8016E750[seqIdx].volCur - D_8016E750[seqIdx].volTarget) / (f32)duration;
- D_8016E750[seqIdx].unk_0C = duration;
+ D_8016E750[playerIdx].volTarget = (f32)val / 127.0f;
+ if (D_8016E750[playerIdx].volCur != D_8016E750[playerIdx].volTarget) {
+ D_8016E750[playerIdx].unk_08 =
+ (D_8016E750[playerIdx].volCur - D_8016E750[playerIdx].volTarget) / (f32)duration;
+ D_8016E750[playerIdx].unk_0C = duration;
}
break;
@@ -228,11 +228,12 @@ void Audio_ProcessSeqCmd(u32 cmd) {
}
freqScale = (f32)val / 1000.0f;
for (i = 0; i < 16; i++) {
- D_8016E750[seqIdx].unk_50[i].unk_14 = freqScale;
- D_8016E750[seqIdx].unk_50[i].unk_1C = duration;
- D_8016E750[seqIdx].unk_50[i].unk_18 = (D_8016E750[seqIdx].unk_50[i].unk_10 - freqScale) / (f32)duration;
+ D_8016E750[playerIdx].unk_50[i].unk_14 = freqScale;
+ D_8016E750[playerIdx].unk_50[i].unk_1C = duration;
+ D_8016E750[playerIdx].unk_50[i].unk_18 =
+ (D_8016E750[playerIdx].unk_50[i].unk_10 - freqScale) / (f32)duration;
}
- D_8016E750[seqIdx].unk_250 = 0xFFFF;
+ D_8016E750[playerIdx].unk_250 = 0xFFFF;
break;
case 0xD:
@@ -244,11 +245,11 @@ void Audio_ProcessSeqCmd(u32 cmd) {
duration++;
}
freqScale = (f32)val / 1000.0f;
- D_8016E750[seqIdx].unk_50[chanIdx].unk_14 = freqScale;
- D_8016E750[seqIdx].unk_50[chanIdx].unk_18 =
- (D_8016E750[seqIdx].unk_50[chanIdx].unk_10 - freqScale) / (f32)duration;
- D_8016E750[seqIdx].unk_50[chanIdx].unk_1C = duration;
- D_8016E750[seqIdx].unk_250 |= 1 << chanIdx;
+ D_8016E750[playerIdx].unk_50[chanIdx].unk_14 = freqScale;
+ D_8016E750[playerIdx].unk_50[chanIdx].unk_18 =
+ (D_8016E750[playerIdx].unk_50[chanIdx].unk_10 - freqScale) / (f32)duration;
+ D_8016E750[playerIdx].unk_50[chanIdx].unk_1C = duration;
+ D_8016E750[playerIdx].unk_250 |= 1 << chanIdx;
break;
case 0x6:
@@ -259,13 +260,13 @@ void Audio_ProcessSeqCmd(u32 cmd) {
if (duration == 0) {
duration++;
}
- D_8016E750[seqIdx].unk_50[chanIdx].unk_04 = (f32)val / 127.0f;
- if (D_8016E750[seqIdx].unk_50[chanIdx].unk_00 != D_8016E750[seqIdx].unk_50[chanIdx].unk_04) {
- D_8016E750[seqIdx].unk_50[chanIdx].unk_08 =
- (D_8016E750[seqIdx].unk_50[chanIdx].unk_00 - D_8016E750[seqIdx].unk_50[chanIdx].unk_04) /
+ D_8016E750[playerIdx].unk_50[chanIdx].unk_04 = (f32)val / 127.0f;
+ if (D_8016E750[playerIdx].unk_50[chanIdx].unk_00 != D_8016E750[playerIdx].unk_50[chanIdx].unk_04) {
+ D_8016E750[playerIdx].unk_50[chanIdx].unk_08 =
+ (D_8016E750[playerIdx].unk_50[chanIdx].unk_00 - D_8016E750[playerIdx].unk_50[chanIdx].unk_04) /
(f32)duration;
- D_8016E750[seqIdx].unk_50[chanIdx].unk_0C = duration;
- D_8016E750[seqIdx].unk_252 |= 1 << chanIdx;
+ D_8016E750[playerIdx].unk_50[chanIdx].unk_0C = duration;
+ D_8016E750[playerIdx].unk_252 |= 1 << chanIdx;
}
break;
@@ -273,7 +274,7 @@ void Audio_ProcessSeqCmd(u32 cmd) {
// set global io port
port = (cmd & 0xFF0000) >> 16;
val = cmd & 0xFF;
- Audio_QueueCmdS8(0x46000000 | _SHIFTL(seqIdx, 16, 8) | _SHIFTL(port, 0, 8), val);
+ Audio_QueueCmdS8(0x46000000 | _SHIFTL(playerIdx, 16, 8) | _SHIFTL(port, 0, 8), val);
break;
case 0x8:
@@ -281,15 +282,15 @@ void Audio_ProcessSeqCmd(u32 cmd) {
chanIdx = (cmd & 0xF00) >> 8;
port = (cmd & 0xFF0000) >> 16;
val = cmd & 0xFF;
- if ((D_8016E750[seqIdx].unk_258 & (1 << chanIdx)) == 0) {
- Audio_QueueCmdS8(0x06000000 | _SHIFTL(seqIdx, 16, 8) | _SHIFTL(chanIdx, 8, 8) | _SHIFTL(port, 0, 8),
+ if ((D_8016E750[playerIdx].unk_258 & (1 << chanIdx)) == 0) {
+ Audio_QueueCmdS8(0x06000000 | _SHIFTL(playerIdx, 16, 8) | _SHIFTL(chanIdx, 8, 8) | _SHIFTL(port, 0, 8),
val);
}
break;
case 0x9:
// set channel mask for command 0x8
- D_8016E750[seqIdx].unk_258 = cmd & 0xFFFF;
+ D_8016E750[playerIdx].unk_258 = cmd & 0xFFFF;
break;
case 0xA:
@@ -297,36 +298,36 @@ void Audio_ProcessSeqCmd(u32 cmd) {
channelMask = cmd & 0xFFFF;
if (channelMask != 0) {
// with channel mask channelMask...
- Audio_QueueCmdU16(0x90000000 | _SHIFTL(seqIdx, 16, 8), channelMask);
+ Audio_QueueCmdU16(0x90000000 | _SHIFTL(playerIdx, 16, 8), channelMask);
// stop channels
- Audio_QueueCmdS8(0x08000000 | _SHIFTL(seqIdx, 16, 8) | 0xFF00, 1);
+ Audio_QueueCmdS8(0x08000000 | _SHIFTL(playerIdx, 16, 8) | 0xFF00, 1);
}
if ((channelMask ^ 0xFFFF) != 0) {
// with channel mask ~channelMask...
- Audio_QueueCmdU16(0x90000000 | _SHIFTL(seqIdx, 16, 8), (channelMask ^ 0xFFFF));
+ Audio_QueueCmdU16(0x90000000 | _SHIFTL(playerIdx, 16, 8), (channelMask ^ 0xFFFF));
// unstop channels
- Audio_QueueCmdS8(0x08000000 | _SHIFTL(seqIdx, 16, 8) | 0xFF00, 0);
+ Audio_QueueCmdS8(0x08000000 | _SHIFTL(playerIdx, 16, 8) | 0xFF00, 0);
}
break;
case 0xB:
// update tempo
- D_8016E750[seqIdx].unk_14 = cmd;
+ D_8016E750[playerIdx].unk_14 = cmd;
break;
case 0xC:
// start sequence with setup commands
subOp = (cmd & 0xF00000) >> 20;
if (subOp != 0xF) {
- if (D_8016E750[seqIdx].unk_4D < 7) {
- found = D_8016E750[seqIdx].unk_4D++;
+ if (D_8016E750[playerIdx].unk_4D < 7) {
+ found = D_8016E750[playerIdx].unk_4D++;
if (found < 8) {
- D_8016E750[seqIdx].unk_2C[found] = cmd;
- D_8016E750[seqIdx].unk_4C = 2;
+ D_8016E750[playerIdx].unk_2C[found] = cmd;
+ D_8016E750[playerIdx].unk_4C = 2;
}
}
} else {
- D_8016E750[seqIdx].unk_4D = 0;
+ D_8016E750[playerIdx].unk_4D = 0;
}
break;
@@ -348,7 +349,7 @@ void Audio_ProcessSeqCmd(u32 cmd) {
case 0xF:
// change spec
spec = cmd & 0xFF;
- D_801333CC = (cmd & 0xFF00) >> 8;
+ gSfxChannelLayout = (cmd & 0xFF00) >> 8;
oldSpec = gAudioSpecId;
gAudioSpecId = spec;
func_800E5F88(spec);
@@ -403,21 +404,21 @@ void func_800FA18C(u8 arg0, u8 arg1) {
}
}
-void Audio_SetVolScale(u8 seqIdx, u8 scaleIdx, u8 targetVol, u8 volFadeTimer) {
+void Audio_SetVolScale(u8 playerIdx, u8 scaleIdx, u8 targetVol, u8 volFadeTimer) {
f32 volScale;
u8 i;
- D_8016E750[seqIdx].volScales[scaleIdx] = targetVol & 0x7F;
+ D_8016E750[playerIdx].volScales[scaleIdx] = targetVol & 0x7F;
if (volFadeTimer != 0) {
- D_8016E750[seqIdx].fadeVolUpdate = 1;
- D_8016E750[seqIdx].volFadeTimer = volFadeTimer;
+ D_8016E750[playerIdx].fadeVolUpdate = 1;
+ D_8016E750[playerIdx].volFadeTimer = volFadeTimer;
} else {
for (i = 0, volScale = 1.0f; i < 4; i++) {
- volScale *= D_8016E750[seqIdx].volScales[i] / 127.0f;
+ volScale *= D_8016E750[playerIdx].volScales[i] / 127.0f;
}
- Audio_SetVolScaleNow(seqIdx, volFadeTimer, volScale);
+ Audio_SetVolScaleNow(playerIdx, volFadeTimer, volScale);
}
}
@@ -432,7 +433,7 @@ void func_800FA3DC(void) {
u8 temp_s0_3;
u8 temp_a3_3;
s32 pad[3];
- u32 sp70;
+ u32 dummy;
f32 phi_f0;
u8 phi_t0;
u8 i;
@@ -441,7 +442,7 @@ void func_800FA3DC(void) {
for (i = 0; i < 4; i++) {
if (D_8016E750[i].unk_260 != 0) {
- switch (func_800E5E20(&sp70)) {
+ switch (func_800E5E20(&dummy)) {
case 1:
case 2:
case 3:
@@ -624,13 +625,13 @@ void func_800FA3DC(void) {
break;
case 14:
if (temp_a3_3 & 1) {
- Audio_QueueCmdS32(0xE3000000, 0);
+ Audio_QueueCmdS32(0xE3000000, SEQUENCE_TABLE);
}
if (temp_a3_3 & 2) {
- Audio_QueueCmdS32(0xE3000000, 1);
+ Audio_QueueCmdS32(0xE3000000, FONT_TABLE);
}
if (temp_a3_3 & 4) {
- Audio_QueueCmdS32(0xE3000000, 2);
+ Audio_QueueCmdS32(0xE3000000, SAMPLE_TABLE);
}
break;
case 9:
@@ -653,13 +654,13 @@ u8 func_800FAD34(void) {
if (D_80133418 == 1) {
if (func_800E5EDC() == 1) {
D_80133418 = 0;
- Audio_QueueCmdS8(0x46020000, D_801333CC);
+ Audio_QueueCmdS8(0x46020000, gSfxChannelLayout);
func_800F7170();
}
} else if (D_80133418 == 2) {
while (func_800E5EDC() != 1) {}
D_80133418 = 0;
- Audio_QueueCmdS8(0x46020000, D_801333CC);
+ Audio_QueueCmdS8(0x46020000, gSfxChannelLayout);
func_800F7170();
}
}
diff --git a/src/code/fault.c b/src/code/fault.c
index aaf9237b2..52fe378f2 100644
--- a/src/code/fault.c
+++ b/src/code/fault.c
@@ -51,7 +51,7 @@ void Fault_ClientProcessThread(void* arg) {
}
if (ctx->queue != NULL) {
- osSendMesg(ctx->queue, ctx->msg, 1);
+ osSendMesg(ctx->queue, ctx->msg, OS_MESG_BLOCK);
}
}
@@ -81,7 +81,7 @@ void Fault_ProcessClientContext(FaultClientContext* ctx) {
while (true) {
osSetTimer(&timer, OS_USEC_TO_CYCLES(1000000), 0, &queue, (OSMesg)timerMsgVal);
- osRecvMesg(&queue, &recMsg, 1);
+ osRecvMesg(&queue, &recMsg, OS_MESG_BLOCK);
if (recMsg != (OSMesg)666) {
break;
@@ -957,7 +957,7 @@ void Fault_ThreadEntry(void* arg) {
while (true) {
do {
- osRecvMesg(&sFaultStructPtr->queue, &msg, 1);
+ osRecvMesg(&sFaultStructPtr->queue, &msg, OS_MESG_BLOCK);
if (msg == (OSMesg)1) {
sFaultStructPtr->msgId = 1;
diff --git a/src/code/sched.c b/src/code/sched.c
index ef582449c..f3a14893e 100644
--- a/src/code/sched.c
+++ b/src/code/sched.c
@@ -87,7 +87,7 @@ void Sched_HandleReset(SchedContext* sc) {
if (sc->curRDPTask != NULL) {
LOG_TIME("(((u64)(now - rdp_start_time)*(1000000LL/15625LL))/((62500000LL*3/4)/15625LL))",
OS_CYCLES_TO_USEC(now - sRDPStartTime), "../sched.c", 431);
- osSendMesg(&sc->interruptQ, RDP_DONE_MSG, 0);
+ osSendMesg(&sc->interruptQ, RDP_DONE_MSG, OS_MESG_NOBLOCK);
}
}
}
diff --git a/src/code/z_actor.c b/src/code/z_actor.c
index e3cf90680..fdd8bfd43 100644
--- a/src/code/z_actor.c
+++ b/src/code/z_actor.c
@@ -2837,7 +2837,7 @@ Actor* Actor_Delete(ActorContext* actorCtx, Actor* actor, GlobalContext* globalC
actorCtx->targetCtx.unk_90 = NULL;
}
- func_800F89E8(&actor->projectedPos);
+ Audio_StopSfxByPos(&actor->projectedPos);
Actor_Destroy(actor, globalCtx);
newHead = Actor_RemoveFromCategory(globalCtx, actorCtx, actor);
diff --git a/src/code/z_camera.c b/src/code/z_camera.c
index 7a11ae212..e22724903 100644
--- a/src/code/z_camera.c
+++ b/src/code/z_camera.c
@@ -7129,7 +7129,7 @@ s32 Camera_CheckWater(Camera* camera) {
camera->unk_150 = 0x50;
}
- func_800F6828(0x20);
+ Audio_SetExtraFilter(0x20);
if (PREG(81)) {
Quake_RemoveFromIdx(*quakeId);
@@ -7164,7 +7164,7 @@ s32 Camera_CheckWater(Camera* camera) {
camera->unk_150 = 0;
camera->unk_152 = 0;
}
- func_800F6828(0);
+ Audio_SetExtraFilter(0);
}
//! @bug: doesn't always return a value, but sometimes does.
}
diff --git a/src/code/z_effect_soft_sprite.c b/src/code/z_effect_soft_sprite.c
index decc148f0..274a93e3f 100644
--- a/src/code/z_effect_soft_sprite.c
+++ b/src/code/z_effect_soft_sprite.c
@@ -62,11 +62,11 @@ void EffectSs_ClearAll(GlobalContext* globalCtx) {
void EffectSs_Delete(EffectSs* effectSs) {
if (effectSs->flags & 2) {
- func_800F89E8(&effectSs->pos);
+ Audio_StopSfxByPos(&effectSs->pos);
}
if (effectSs->flags & 4) {
- func_800F89E8(&effectSs->vec);
+ Audio_StopSfxByPos(&effectSs->vec);
}
EffectSs_Reset(effectSs);
diff --git a/src/code/z_play.c b/src/code/z_play.c
index 628dbaf14..0807d91a7 100644
--- a/src/code/z_play.c
+++ b/src/code/z_play.c
@@ -205,7 +205,7 @@ void Gameplay_Init(GameState* thisx) {
GameState_Realloc(&globalCtx->state, 0x1D4790);
KaleidoManager_Init(globalCtx);
View_Init(&globalCtx->view, gfxCtx);
- func_800F6828(0);
+ Audio_SetExtraFilter(0);
Quake_Init();
for (i = 0; i < 4; i++) {
@@ -402,7 +402,7 @@ void Gameplay_Init(GameState* thisx) {
if (dREG(95) != 0) {
D_8012D1F0 = D_801614D0;
osSyncPrintf("\nkawauso_data=[%x]", D_8012D1F0);
- DmaMgr_DMARomToRam(0x03FEB000, (u32)D_8012D1F0, sizeof(D_801614D0));
+ DmaMgr_DmaRomToRam(0x03FEB000, (u32)D_8012D1F0, sizeof(D_801614D0));
}
}
generated by cgit v1.2.3 (git 2.25.1) at 2026-08-03 14:15:02 +0000