From 7204b0849838c0fa63b30591f9063a76c54307a7 Mon Sep 17 00:00:00 2001 From: engineer124 <47598039+engineer124@users.noreply.github.com> Date: Thu, 13 Oct 2022 16:17:27 -0400 Subject: [PATCH] Rename audio context (#1114) --- include/variables.h | 4 +- include/z64audio.h | 2 +- src/code/audio/audio_effects.c | 2 +- src/code/audio/audio_heap.c | 564 ++++++++++++++--------------- src/code/audio/audio_init_params.c | 2 +- src/code/audio/audio_load.c | 558 ++++++++++++++-------------- src/code/audio/audio_playback.c | 118 +++--- src/code/audio/audio_seqplayer.c | 117 +++--- src/code/audio/audio_synthesis.c | 115 +++--- src/code/audio/code_8019AF00.c | 42 +-- src/code/audio/code_801A5BD0.c | 6 +- tools/disasm/variables.txt | 4 +- 12 files changed, 756 insertions(+), 778 deletions(-) diff --git a/include/variables.h b/include/variables.h index 1719d4c6fb..5b40e11614 100644 --- a/include/variables.h +++ b/include/variables.h @@ -1186,7 +1186,7 @@ extern f32 gDefaultPanVolume[]; // extern UNK_TYPE1 D_801D5FD4; extern UNK_PTR D_801D5FE0; // extern UNK_TYPE1 D_801D5FE4; -extern s32 gAudioContextInitalized; +extern s32 gAudioCtxInitalized; // extern UNK_TYPE4 D_801D5FEC; // extern UNK_TYPE4 D_801D5FF0; // extern UNK_TYPE4 D_801D5FF4; @@ -3081,7 +3081,7 @@ extern ActiveSequence gActiveSeqs[]; // extern UNK_TYPE1 D_80200BCC; // extern UNK_TYPE1 D_80200BCE; // extern UNK_TYPE1 D_80200BD0; -extern AudioContext gAudioContext; // at 0x80200C70 +extern AudioContext gAudioCtx; // at 0x80200C70 extern void (*gCustomAudioUpdateFunction)(void); extern u32 (*gCustomAudioSeqFunction)(s8 value, SequenceChannel* channel); extern s32 (*gCustomAudioReverbFunction)(Sample*, s32, s8, s32); diff --git a/include/z64audio.h b/include/z64audio.h index 264e8d9e3b..17f0e84f9d 100644 --- a/include/z64audio.h +++ b/include/z64audio.h @@ -7,7 +7,7 @@ #define TATUMS_PER_BEAT 48 -#define IS_SEQUENCE_CHANNEL_VALID(ptr) ((uintptr_t)(ptr) != (uintptr_t)&gAudioContext.sequenceChannelNone) +#define IS_SEQUENCE_CHANNEL_VALID(ptr) ((uintptr_t)(ptr) != (uintptr_t)&gAudioCtx.sequenceChannelNone) #define SEQ_NUM_CHANNELS 16 #define SEQ_IO_VAL_NONE -1 diff --git a/src/code/audio/audio_effects.c b/src/code/audio/audio_effects.c index bc27a6e227..3f50f003c1 100644 --- a/src/code/audio/audio_effects.c +++ b/src/code/audio/audio_effects.c @@ -268,7 +268,7 @@ f32 AudioEffects_AdsrUpdate(AdsrState* adsr) { break; default: - adsr->delay *= gAudioContext.audioBufferParameters.updatesPerFrameScaled; + adsr->delay *= gAudioCtx.audioBufferParameters.updatesPerFrameScaled; if (adsr->delay == 0) { adsr->delay = 1; } diff --git a/src/code/audio/audio_heap.c b/src/code/audio/audio_heap.c index 8412220a34..1c05e94412 100644 --- a/src/code/audio/audio_heap.c +++ b/src/code/audio/audio_heap.c @@ -20,7 +20,7 @@ void AudioHeap_InitReverb(s32 reverbIndex, ReverbSettings* settings, s32 isFirst * i.e. (256.0f * `updatesPerFrameInvScaled`) is just `updatesPerFrameInv` */ f32 AudioHeap_CalculateAdsrDecay(f32 scaleInv) { - return 256.0f * gAudioContext.audioBufferParameters.updatesPerFrameInvScaled / scaleInv; + return 256.0f * gAudioCtx.audioBufferParameters.updatesPerFrameInvScaled / scaleInv; } /** @@ -29,45 +29,45 @@ f32 AudioHeap_CalculateAdsrDecay(f32 scaleInv) { void AudioHeap_InitAdsrDecayTable(void) { s32 i; - gAudioContext.adsrDecayTable[255] = AudioHeap_CalculateAdsrDecay(0.25f); - gAudioContext.adsrDecayTable[254] = AudioHeap_CalculateAdsrDecay(0.33f); - gAudioContext.adsrDecayTable[253] = AudioHeap_CalculateAdsrDecay(0.5f); - gAudioContext.adsrDecayTable[252] = AudioHeap_CalculateAdsrDecay(0.66f); - gAudioContext.adsrDecayTable[251] = AudioHeap_CalculateAdsrDecay(0.75f); + gAudioCtx.adsrDecayTable[255] = AudioHeap_CalculateAdsrDecay(0.25f); + gAudioCtx.adsrDecayTable[254] = AudioHeap_CalculateAdsrDecay(0.33f); + gAudioCtx.adsrDecayTable[253] = AudioHeap_CalculateAdsrDecay(0.5f); + gAudioCtx.adsrDecayTable[252] = AudioHeap_CalculateAdsrDecay(0.66f); + gAudioCtx.adsrDecayTable[251] = AudioHeap_CalculateAdsrDecay(0.75f); for (i = 128; i < 251; i++) { - gAudioContext.adsrDecayTable[i] = AudioHeap_CalculateAdsrDecay(251 - i); + gAudioCtx.adsrDecayTable[i] = AudioHeap_CalculateAdsrDecay(251 - i); } for (i = 16; i < 128; i++) { - gAudioContext.adsrDecayTable[i] = AudioHeap_CalculateAdsrDecay(4 * (143 - i)); + gAudioCtx.adsrDecayTable[i] = AudioHeap_CalculateAdsrDecay(4 * (143 - i)); } for (i = 1; i < 16; i++) { - gAudioContext.adsrDecayTable[i] = AudioHeap_CalculateAdsrDecay(60 * (23 - i)); + gAudioCtx.adsrDecayTable[i] = AudioHeap_CalculateAdsrDecay(60 * (23 - i)); } - gAudioContext.adsrDecayTable[0] = 0.0f; + gAudioCtx.adsrDecayTable[0] = 0.0f; } void AudioHeap_ResetLoadStatus(void) { s32 i; - for (i = 0; i < ARRAY_COUNT(gAudioContext.fontLoadStatus); i++) { - if (gAudioContext.fontLoadStatus[i] != LOAD_STATUS_PERMANENT) { - gAudioContext.fontLoadStatus[i] = LOAD_STATUS_NOT_LOADED; + for (i = 0; i < ARRAY_COUNT(gAudioCtx.fontLoadStatus); i++) { + if (gAudioCtx.fontLoadStatus[i] != LOAD_STATUS_PERMANENT) { + gAudioCtx.fontLoadStatus[i] = LOAD_STATUS_NOT_LOADED; } } - for (i = 0; i < ARRAY_COUNT(gAudioContext.sampleFontLoadStatus); i++) { - if (gAudioContext.sampleFontLoadStatus[i] != LOAD_STATUS_PERMANENT) { - gAudioContext.sampleFontLoadStatus[i] = LOAD_STATUS_NOT_LOADED; + for (i = 0; i < ARRAY_COUNT(gAudioCtx.sampleFontLoadStatus); i++) { + if (gAudioCtx.sampleFontLoadStatus[i] != LOAD_STATUS_PERMANENT) { + gAudioCtx.sampleFontLoadStatus[i] = LOAD_STATUS_NOT_LOADED; } } - for (i = 0; i < ARRAY_COUNT(gAudioContext.seqLoadStatus); i++) { - if (gAudioContext.seqLoadStatus[i] != LOAD_STATUS_PERMANENT) { - gAudioContext.seqLoadStatus[i] = LOAD_STATUS_NOT_LOADED; + for (i = 0; i < ARRAY_COUNT(gAudioCtx.seqLoadStatus); i++) { + if (gAudioCtx.seqLoadStatus[i] != LOAD_STATUS_PERMANENT) { + gAudioCtx.seqLoadStatus[i] = LOAD_STATUS_NOT_LOADED; } } } @@ -75,8 +75,8 @@ void AudioHeap_ResetLoadStatus(void) { void AudioHeap_DiscardFont(s32 fontId) { s32 i; - for (i = 0; i < gAudioContext.numNotes; i++) { - Note* note = &gAudioContext.notes[i]; + for (i = 0; i < gAudioCtx.numNotes; i++) { + Note* note = &gAudioCtx.notes[i]; if (note->playbackState.fontId == fontId) { if ((note->playbackState.status == PLAYBACK_STATUS_0) && (note->playbackState.priority != 0)) { @@ -86,7 +86,7 @@ void AudioHeap_DiscardFont(s32 fontId) { AudioPlayback_NoteDisable(note); AudioPlayback_AudioListRemove(¬e->listItem); - AudioSeq_AudioListPushBack(&gAudioContext.noteFreeLists.disabled, ¬e->listItem); + AudioSeq_AudioListPushBack(&gAudioCtx.noteFreeLists.disabled, ¬e->listItem); } } } @@ -94,14 +94,14 @@ void AudioHeap_DiscardFont(s32 fontId) { void AudioHeap_ReleaseNotesForFont(s32 fontId) { s32 i; - for (i = 0; i < gAudioContext.numNotes; i++) { - Note* note = &gAudioContext.notes[i]; + for (i = 0; i < gAudioCtx.numNotes; i++) { + Note* note = &gAudioCtx.notes[i]; NotePlaybackState* playbackState = ¬e->playbackState; if (playbackState->fontId == fontId) { if (playbackState->priority != 0) { playbackState->priority = 1; - playbackState->adsr.fadeOutVel = gAudioContext.audioBufferParameters.updatesPerFrameInv; + playbackState->adsr.fadeOutVel = gAudioCtx.audioBufferParameters.updatesPerFrameInv; playbackState->adsr.action.s.release = true; } } @@ -111,9 +111,9 @@ void AudioHeap_ReleaseNotesForFont(s32 fontId) { 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) { - AudioSeq_SequencePlayerDisable(&gAudioContext.seqPlayers[i]); + for (i = 0; i < gAudioCtx.audioBufferParameters.numSequencePlayers; i++) { + if (gAudioCtx.seqPlayers[i].enabled && gAudioCtx.seqPlayers[i].seqId == seqId) { + AudioSeq_SequencePlayerDisable(&gAudioCtx.seqPlayers[i]); } } } @@ -137,8 +137,8 @@ void* AudioHeap_WritebackDCache(void* addr, size_t size) { void* AudioHeap_AllocZeroedAttemptExternal(AudioAllocPool* pool, size_t size) { void* addr = NULL; - if (gAudioContext.externalPool.startAddr != NULL) { - addr = AudioHeap_AllocZeroed(&gAudioContext.externalPool, size); + if (gAudioCtx.externalPool.startAddr != NULL) { + addr = AudioHeap_AllocZeroed(&gAudioCtx.externalPool, size); } if (addr == NULL) { @@ -155,8 +155,8 @@ void* AudioHeap_AllocZeroedAttemptExternal(AudioAllocPool* pool, size_t size) { void* AudioHeap_AllocAttemptExternal(AudioAllocPool* pool, size_t size) { void* addr = NULL; - if (gAudioContext.externalPool.startAddr != NULL) { - addr = AudioHeap_Alloc(&gAudioContext.externalPool, size); + if (gAudioCtx.externalPool.startAddr != NULL) { + addr = AudioHeap_Alloc(&gAudioCtx.externalPool, size); } if (addr == NULL) { @@ -277,18 +277,18 @@ void AudioHeap_PopPersistentCache(s32 tableType) { switch (tableType) { case SEQUENCE_TABLE: - loadedCache = &gAudioContext.seqCache; - loadStatus = gAudioContext.seqLoadStatus; + loadedCache = &gAudioCtx.seqCache; + loadStatus = gAudioCtx.seqLoadStatus; break; case FONT_TABLE: - loadedCache = &gAudioContext.fontCache; - loadStatus = gAudioContext.fontLoadStatus; + loadedCache = &gAudioCtx.fontCache; + loadStatus = gAudioCtx.fontLoadStatus; break; case SAMPLE_TABLE: - loadedCache = &gAudioContext.sampleBankCache; - loadStatus = gAudioContext.sampleFontLoadStatus; + loadedCache = &gAudioCtx.sampleBankCache; + loadStatus = gAudioCtx.sampleFontLoadStatus; break; } @@ -315,64 +315,63 @@ void AudioHeap_PopPersistentCache(s32 tableType) { } void AudioHeap_InitMainPool(size_t initPoolSize) { - AudioHeap_InitPool(&gAudioContext.initPool, gAudioContext.audioHeap, initPoolSize); - AudioHeap_InitPool(&gAudioContext.sessionPool, gAudioContext.audioHeap + initPoolSize, - gAudioContext.audioHeapSize - initPoolSize); + AudioHeap_InitPool(&gAudioCtx.initPool, gAudioCtx.audioHeap, initPoolSize); + AudioHeap_InitPool(&gAudioCtx.sessionPool, gAudioCtx.audioHeap + initPoolSize, + gAudioCtx.audioHeapSize - initPoolSize); - gAudioContext.externalPool.startAddr = NULL; + gAudioCtx.externalPool.startAddr = NULL; } void AudioHeap_InitSessionPool(AudioSessionPoolSplit* split) { - gAudioContext.sessionPool.curAddr = gAudioContext.sessionPool.startAddr; + gAudioCtx.sessionPool.curAddr = gAudioCtx.sessionPool.startAddr; - AudioHeap_InitPool(&gAudioContext.miscPool, AudioHeap_Alloc(&gAudioContext.sessionPool, split->miscPoolSize), + AudioHeap_InitPool(&gAudioCtx.miscPool, AudioHeap_Alloc(&gAudioCtx.sessionPool, split->miscPoolSize), split->miscPoolSize); - AudioHeap_InitPool(&gAudioContext.cachePool, AudioHeap_Alloc(&gAudioContext.sessionPool, split->cachePoolSize), + AudioHeap_InitPool(&gAudioCtx.cachePool, AudioHeap_Alloc(&gAudioCtx.sessionPool, split->cachePoolSize), split->cachePoolSize); } void AudioHeap_InitCachePool(AudioCachePoolSplit* split) { - gAudioContext.cachePool.curAddr = gAudioContext.cachePool.startAddr; + gAudioCtx.cachePool.curAddr = gAudioCtx.cachePool.startAddr; - AudioHeap_InitPool(&gAudioContext.persistentCommonPool, - AudioHeap_Alloc(&gAudioContext.cachePool, split->persistentCommonPoolSize), + AudioHeap_InitPool(&gAudioCtx.persistentCommonPool, + AudioHeap_Alloc(&gAudioCtx.cachePool, split->persistentCommonPoolSize), split->persistentCommonPoolSize); - AudioHeap_InitPool(&gAudioContext.temporaryCommonPool, - AudioHeap_Alloc(&gAudioContext.cachePool, split->temporaryCommonPoolSize), + AudioHeap_InitPool(&gAudioCtx.temporaryCommonPool, + AudioHeap_Alloc(&gAudioCtx.cachePool, split->temporaryCommonPoolSize), split->temporaryCommonPoolSize); } void AudioHeap_InitPersistentPoolsAndCaches(AudioCommonPoolSplit* split) { - gAudioContext.persistentCommonPool.curAddr = gAudioContext.persistentCommonPool.startAddr; + gAudioCtx.persistentCommonPool.curAddr = gAudioCtx.persistentCommonPool.startAddr; - AudioHeap_InitPool(&gAudioContext.seqCache.persistent.pool, - AudioHeap_Alloc(&gAudioContext.persistentCommonPool, split->seqCacheSize), split->seqCacheSize); - AudioHeap_InitPool(&gAudioContext.fontCache.persistent.pool, - AudioHeap_Alloc(&gAudioContext.persistentCommonPool, split->fontCacheSize), - split->fontCacheSize); - AudioHeap_InitPool(&gAudioContext.sampleBankCache.persistent.pool, - AudioHeap_Alloc(&gAudioContext.persistentCommonPool, split->sampleBankCacheSize), + AudioHeap_InitPool(&gAudioCtx.seqCache.persistent.pool, + AudioHeap_Alloc(&gAudioCtx.persistentCommonPool, split->seqCacheSize), split->seqCacheSize); + AudioHeap_InitPool(&gAudioCtx.fontCache.persistent.pool, + AudioHeap_Alloc(&gAudioCtx.persistentCommonPool, split->fontCacheSize), split->fontCacheSize); + AudioHeap_InitPool(&gAudioCtx.sampleBankCache.persistent.pool, + AudioHeap_Alloc(&gAudioCtx.persistentCommonPool, split->sampleBankCacheSize), split->sampleBankCacheSize); - AudioHeap_InitPersistentCache(&gAudioContext.seqCache.persistent); - AudioHeap_InitPersistentCache(&gAudioContext.fontCache.persistent); - AudioHeap_InitPersistentCache(&gAudioContext.sampleBankCache.persistent); + AudioHeap_InitPersistentCache(&gAudioCtx.seqCache.persistent); + AudioHeap_InitPersistentCache(&gAudioCtx.fontCache.persistent); + AudioHeap_InitPersistentCache(&gAudioCtx.sampleBankCache.persistent); } void AudioHeap_InitTemporaryPoolsAndCaches(AudioCommonPoolSplit* split) { - gAudioContext.temporaryCommonPool.curAddr = gAudioContext.temporaryCommonPool.startAddr; + gAudioCtx.temporaryCommonPool.curAddr = gAudioCtx.temporaryCommonPool.startAddr; - AudioHeap_InitPool(&gAudioContext.seqCache.temporary.pool, - AudioHeap_Alloc(&gAudioContext.temporaryCommonPool, split->seqCacheSize), split->seqCacheSize); - AudioHeap_InitPool(&gAudioContext.fontCache.temporary.pool, - AudioHeap_Alloc(&gAudioContext.temporaryCommonPool, split->fontCacheSize), split->fontCacheSize); - AudioHeap_InitPool(&gAudioContext.sampleBankCache.temporary.pool, - AudioHeap_Alloc(&gAudioContext.temporaryCommonPool, split->sampleBankCacheSize), + AudioHeap_InitPool(&gAudioCtx.seqCache.temporary.pool, + AudioHeap_Alloc(&gAudioCtx.temporaryCommonPool, split->seqCacheSize), split->seqCacheSize); + AudioHeap_InitPool(&gAudioCtx.fontCache.temporary.pool, + AudioHeap_Alloc(&gAudioCtx.temporaryCommonPool, split->fontCacheSize), split->fontCacheSize); + AudioHeap_InitPool(&gAudioCtx.sampleBankCache.temporary.pool, + AudioHeap_Alloc(&gAudioCtx.temporaryCommonPool, split->sampleBankCacheSize), split->sampleBankCacheSize); - AudioHeap_InitTemporaryCache(&gAudioContext.seqCache.temporary); - AudioHeap_InitTemporaryCache(&gAudioContext.fontCache.temporary); - AudioHeap_InitTemporaryCache(&gAudioContext.sampleBankCache.temporary); + AudioHeap_InitTemporaryCache(&gAudioCtx.seqCache.temporary); + AudioHeap_InitTemporaryCache(&gAudioCtx.fontCache.temporary); + AudioHeap_InitTemporaryCache(&gAudioCtx.sampleBankCache.temporary); } void* AudioHeap_AllocCached(s32 tableType, size_t size, s32 cache, s32 id) { @@ -389,18 +388,18 @@ void* AudioHeap_AllocCached(s32 tableType, size_t size, s32 cache, s32 id) { switch (tableType) { case SEQUENCE_TABLE: - loadedCache = &gAudioContext.seqCache; - loadStatus = gAudioContext.seqLoadStatus; + loadedCache = &gAudioCtx.seqCache; + loadStatus = gAudioCtx.seqLoadStatus; break; case FONT_TABLE: - loadedCache = &gAudioContext.fontCache; - loadStatus = gAudioContext.fontLoadStatus; + loadedCache = &gAudioCtx.fontCache; + loadStatus = gAudioCtx.fontLoadStatus; break; case SAMPLE_TABLE: - loadedCache = &gAudioContext.sampleBankCache; - loadStatus = gAudioContext.sampleFontLoadStatus; + loadedCache = &gAudioCtx.sampleBankCache; + loadStatus = gAudioCtx.sampleFontLoadStatus; break; } @@ -419,28 +418,28 @@ void* AudioHeap_AllocCached(s32 tableType, size_t size, s32 cache, s32 id) { if (tableType == FONT_TABLE) { if (loadStatusEntry0 == LOAD_STATUS_MAYBE_DISCARDABLE) { - for (i = 0; i < gAudioContext.numNotes; i++) { - if ((gAudioContext.notes[i].playbackState.fontId == temporaryCache->entries[0].id) && - gAudioContext.notes[i].sampleState.bitField0.enabled) { + for (i = 0; i < gAudioCtx.numNotes; i++) { + if ((gAudioCtx.notes[i].playbackState.fontId == temporaryCache->entries[0].id) && + gAudioCtx.notes[i].sampleState.bitField0.enabled) { break; } } - if (i == gAudioContext.numNotes) { + if (i == gAudioCtx.numNotes) { AudioLoad_SetFontLoadStatus(temporaryCache->entries[0].id, LOAD_STATUS_DISCARDABLE); loadStatusEntry0 = LOAD_STATUS_DISCARDABLE; } } if (loadStatusEntry1 == LOAD_STATUS_MAYBE_DISCARDABLE) { - for (i = 0; i < gAudioContext.numNotes; i++) { - if ((gAudioContext.notes[i].playbackState.fontId == temporaryCache->entries[1].id) && - gAudioContext.notes[i].sampleState.bitField0.enabled) { + for (i = 0; i < gAudioCtx.numNotes; i++) { + if ((gAudioCtx.notes[i].playbackState.fontId == temporaryCache->entries[1].id) && + gAudioCtx.notes[i].sampleState.bitField0.enabled) { break; } } - if (i == gAudioContext.numNotes) { + if (i == gAudioCtx.numNotes) { AudioLoad_SetFontLoadStatus(temporaryCache->entries[1].id, LOAD_STATUS_DISCARDABLE); loadStatusEntry1 = LOAD_STATUS_DISCARDABLE; } @@ -461,54 +460,54 @@ void* AudioHeap_AllocCached(s32 tableType, size_t size, s32 cache, s32 id) { // Check if there is a side which isn't in active use, if so, evict that one. if (tableType == SEQUENCE_TABLE) { if (loadStatusEntry0 == LOAD_STATUS_COMPLETE) { - for (i = 0; i < gAudioContext.audioBufferParameters.numSequencePlayers; i++) { - if (gAudioContext.seqPlayers[i].enabled && - gAudioContext.seqPlayers[i].seqId == temporaryCache->entries[0].id) { + for (i = 0; i < gAudioCtx.audioBufferParameters.numSequencePlayers; i++) { + if (gAudioCtx.seqPlayers[i].enabled && + gAudioCtx.seqPlayers[i].seqId == temporaryCache->entries[0].id) { break; } } - if (i == gAudioContext.audioBufferParameters.numSequencePlayers) { + if (i == gAudioCtx.audioBufferParameters.numSequencePlayers) { temporaryCache->nextSide = 0; goto done; } } if (loadStatusEntry1 == LOAD_STATUS_COMPLETE) { - for (i = 0; i < gAudioContext.audioBufferParameters.numSequencePlayers; i++) { - if (gAudioContext.seqPlayers[i].enabled && - gAudioContext.seqPlayers[i].seqId == temporaryCache->entries[1].id) { + for (i = 0; i < gAudioCtx.audioBufferParameters.numSequencePlayers; i++) { + if (gAudioCtx.seqPlayers[i].enabled && + gAudioCtx.seqPlayers[i].seqId == temporaryCache->entries[1].id) { break; } } - if (i == gAudioContext.audioBufferParameters.numSequencePlayers) { + if (i == gAudioCtx.audioBufferParameters.numSequencePlayers) { temporaryCache->nextSide = 1; goto done; } } } else if (tableType == FONT_TABLE) { if (loadStatusEntry0 == LOAD_STATUS_COMPLETE) { - for (i = 0; i < gAudioContext.numNotes; i++) { - if ((gAudioContext.notes[i].playbackState.fontId == temporaryCache->entries[0].id) && - gAudioContext.notes[i].sampleState.bitField0.enabled) { + for (i = 0; i < gAudioCtx.numNotes; i++) { + if ((gAudioCtx.notes[i].playbackState.fontId == temporaryCache->entries[0].id) && + gAudioCtx.notes[i].sampleState.bitField0.enabled) { break; } } - if (i == gAudioContext.numNotes) { + if (i == gAudioCtx.numNotes) { temporaryCache->nextSide = 0; goto done; } } if (loadStatusEntry1 == LOAD_STATUS_COMPLETE) { - for (i = 0; i < gAudioContext.numNotes; i++) { - if ((gAudioContext.notes[i].playbackState.fontId == temporaryCache->entries[1].id) && - gAudioContext.notes[i].sampleState.bitField0.enabled) { + for (i = 0; i < gAudioCtx.numNotes; i++) { + if ((gAudioCtx.notes[i].playbackState.fontId == temporaryCache->entries[1].id) && + gAudioCtx.notes[i].sampleState.bitField0.enabled) { break; } } - if (i == gAudioContext.numNotes) { + if (i == gAudioCtx.numNotes) { temporaryCache->nextSide = 1; goto done; } @@ -667,15 +666,15 @@ void* AudioHeap_SearchRegularCaches(s32 tableType, s32 cache, s32 id) { switch (tableType) { case SEQUENCE_TABLE: - loadedCache = &gAudioContext.seqCache; + loadedCache = &gAudioCtx.seqCache; break; case FONT_TABLE: - loadedCache = &gAudioContext.fontCache; + loadedCache = &gAudioCtx.fontCache; break; case SAMPLE_TABLE: - loadedCache = &gAudioContext.sampleBankCache; + loadedCache = &gAudioCtx.sampleBankCache; break; } @@ -817,15 +816,15 @@ void AudioHeap_UpdateReverbs(void) { s32 reverbIndex; s32 j; - if (gAudioContext.audioBufferParameters.specUnk4 == 2) { + if (gAudioCtx.audioBufferParameters.specUnk4 == 2) { count = 2; } else { count = 1; } - for (reverbIndex = 0; reverbIndex < gAudioContext.numSynthesisReverbs; reverbIndex++) { + for (reverbIndex = 0; reverbIndex < gAudioCtx.numSynthesisReverbs; reverbIndex++) { for (j = 0; j < count; j++) { - AudioHeap_UpdateReverb(&gAudioContext.synthesisReverbs[reverbIndex]); + AudioHeap_UpdateReverb(&gAudioCtx.synthesisReverbs[reverbIndex]); } } } @@ -834,13 +833,13 @@ void AudioHeap_UpdateReverbs(void) { * Clear the Audio Interface Buffers */ void AudioHeap_ClearAiBuffers(void) { - s32 curAiBufferIndex = gAudioContext.curAiBufferIndex; + s32 curAiBufferIndex = gAudioCtx.curAiBufferIndex; s32 i; - gAudioContext.aiBufNumSamples[curAiBufferIndex] = gAudioContext.audioBufferParameters.numSamplesPerFrameMin; + gAudioCtx.aiBufNumSamples[curAiBufferIndex] = gAudioCtx.audioBufferParameters.numSamplesPerFrameMin; for (i = 0; i < AIBUF_LEN; i++) { - gAudioContext.aiBuffers[curAiBufferIndex][i] = 0; + gAudioCtx.aiBuffers[curAiBufferIndex][i] = 0; } } @@ -849,55 +848,55 @@ s32 AudioHeap_ResetStep(void) { s32 j; s32 count; - if (gAudioContext.audioBufferParameters.specUnk4 == 2) { + if (gAudioCtx.audioBufferParameters.specUnk4 == 2) { count = 2; } else { count = 1; } - switch (gAudioContext.resetStatus) { + switch (gAudioCtx.resetStatus) { case 5: - for (i = 0; i < gAudioContext.audioBufferParameters.numSequencePlayers; i++) { - AudioSeq_SequencePlayerDisableAsFinished(&gAudioContext.seqPlayers[i]); + for (i = 0; i < gAudioCtx.audioBufferParameters.numSequencePlayers; i++) { + AudioSeq_SequencePlayerDisableAsFinished(&gAudioCtx.seqPlayers[i]); } - gAudioContext.audioResetFadeOutFramesLeft = 2 / count; - gAudioContext.resetStatus--; + gAudioCtx.audioResetFadeOutFramesLeft = 2 / count; + gAudioCtx.resetStatus--; break; case 4: - if (gAudioContext.audioResetFadeOutFramesLeft != 0) { - gAudioContext.audioResetFadeOutFramesLeft--; + if (gAudioCtx.audioResetFadeOutFramesLeft != 0) { + gAudioCtx.audioResetFadeOutFramesLeft--; AudioHeap_UpdateReverbs(); } else { - for (i = 0; i < gAudioContext.numNotes; i++) { - if (gAudioContext.notes[i].sampleState.bitField0.enabled && - gAudioContext.notes[i].playbackState.adsr.action.s.state != ADSR_STATE_DISABLED) { - gAudioContext.notes[i].playbackState.adsr.fadeOutVel = - gAudioContext.audioBufferParameters.updatesPerFrameInv; - gAudioContext.notes[i].playbackState.adsr.action.s.release = true; + for (i = 0; i < gAudioCtx.numNotes; i++) { + if (gAudioCtx.notes[i].sampleState.bitField0.enabled && + gAudioCtx.notes[i].playbackState.adsr.action.s.state != ADSR_STATE_DISABLED) { + gAudioCtx.notes[i].playbackState.adsr.fadeOutVel = + gAudioCtx.audioBufferParameters.updatesPerFrameInv; + gAudioCtx.notes[i].playbackState.adsr.action.s.release = true; } } - gAudioContext.audioResetFadeOutFramesLeft = 8 / count; - gAudioContext.resetStatus--; + gAudioCtx.audioResetFadeOutFramesLeft = 8 / count; + gAudioCtx.resetStatus--; } break; case 3: - if (gAudioContext.audioResetFadeOutFramesLeft != 0) { - gAudioContext.audioResetFadeOutFramesLeft--; + if (gAudioCtx.audioResetFadeOutFramesLeft != 0) { + gAudioCtx.audioResetFadeOutFramesLeft--; AudioHeap_UpdateReverbs(); } else { - gAudioContext.audioResetFadeOutFramesLeft = 2 / count; - gAudioContext.resetStatus--; + gAudioCtx.audioResetFadeOutFramesLeft = 2 / count; + gAudioCtx.resetStatus--; } break; case 2: AudioHeap_ClearAiBuffers(); - if (gAudioContext.audioResetFadeOutFramesLeft != 0) { - gAudioContext.audioResetFadeOutFramesLeft--; + if (gAudioCtx.audioResetFadeOutFramesLeft != 0) { + gAudioCtx.audioResetFadeOutFramesLeft--; } else { - gAudioContext.resetStatus--; + gAudioCtx.resetStatus--; AudioHeap_DiscardSampleCaches(); AudioHeap_DiscardSampleBanks(); } @@ -905,17 +904,17 @@ s32 AudioHeap_ResetStep(void) { case 1: AudioHeap_Init(); - gAudioContext.resetStatus = 0; - for (i = 0; i < ARRAY_COUNT(gAudioContext.aiBufNumSamples); i++) { - gAudioContext.aiBufNumSamples[i] = gAudioContext.audioBufferParameters.numSamplesPerFrameMax; + gAudioCtx.resetStatus = 0; + for (i = 0; i < ARRAY_COUNT(gAudioCtx.aiBufNumSamples); i++) { + gAudioCtx.aiBufNumSamples[i] = gAudioCtx.audioBufferParameters.numSamplesPerFrameMax; for (j = 0; j < AIBUF_LEN; j++) { - gAudioContext.aiBuffers[i][j] = 0; + gAudioCtx.aiBuffers[i][j] = 0; } } break; } - if (gAudioContext.resetStatus < 3) { + if (gAudioCtx.resetStatus < 3) { return false; } @@ -933,72 +932,67 @@ void AudioHeap_Init(void) { s32 reverbIndex; s32 i; s32 pad2; - AudioSpec* spec = &gAudioSpecs[gAudioContext.audioResetSpecIdToLoad]; // Audio Specifications + AudioSpec* spec = &gAudioSpecs[gAudioCtx.audioResetSpecIdToLoad]; // Audio Specifications - gAudioContext.sampleDmaCount = 0; + gAudioCtx.sampleDmaCount = 0; // audio buffer parameters - gAudioContext.audioBufferParameters.samplingFreq = spec->samplingFreq; - gAudioContext.audioBufferParameters.aiSamplingFreq = - osAiSetFrequency(gAudioContext.audioBufferParameters.samplingFreq); + gAudioCtx.audioBufferParameters.samplingFreq = spec->samplingFreq; + gAudioCtx.audioBufferParameters.aiSamplingFreq = osAiSetFrequency(gAudioCtx.audioBufferParameters.samplingFreq); - gAudioContext.audioBufferParameters.numSamplesPerFrameTarget = - ALIGN16(gAudioContext.audioBufferParameters.samplingFreq / gAudioContext.refreshRate); - gAudioContext.audioBufferParameters.numSamplesPerFrameMin = - gAudioContext.audioBufferParameters.numSamplesPerFrameTarget - 0x10; - gAudioContext.audioBufferParameters.numSamplesPerFrameMax = - gAudioContext.audioBufferParameters.numSamplesPerFrameTarget + 0x10; - gAudioContext.audioBufferParameters.updatesPerFrame = - ((gAudioContext.audioBufferParameters.numSamplesPerFrameTarget + 0x10) / 0xD0) + 1; - gAudioContext.audioBufferParameters.numSamplesPerUpdate = - (gAudioContext.audioBufferParameters.numSamplesPerFrameTarget / - gAudioContext.audioBufferParameters.updatesPerFrame) & + gAudioCtx.audioBufferParameters.numSamplesPerFrameTarget = + ALIGN16(gAudioCtx.audioBufferParameters.samplingFreq / gAudioCtx.refreshRate); + gAudioCtx.audioBufferParameters.numSamplesPerFrameMin = + gAudioCtx.audioBufferParameters.numSamplesPerFrameTarget - 0x10; + gAudioCtx.audioBufferParameters.numSamplesPerFrameMax = + gAudioCtx.audioBufferParameters.numSamplesPerFrameTarget + 0x10; + gAudioCtx.audioBufferParameters.updatesPerFrame = + ((gAudioCtx.audioBufferParameters.numSamplesPerFrameTarget + 0x10) / 0xD0) + 1; + gAudioCtx.audioBufferParameters.numSamplesPerUpdate = + (gAudioCtx.audioBufferParameters.numSamplesPerFrameTarget / gAudioCtx.audioBufferParameters.updatesPerFrame) & ~7; - gAudioContext.audioBufferParameters.numSamplesPerUpdateMax = - gAudioContext.audioBufferParameters.numSamplesPerUpdate + 8; - gAudioContext.audioBufferParameters.numSamplesPerUpdateMin = - gAudioContext.audioBufferParameters.numSamplesPerUpdate - 8; - gAudioContext.audioBufferParameters.resampleRate = 32000.0f / (s32)gAudioContext.audioBufferParameters.samplingFreq; - gAudioContext.audioBufferParameters.updatesPerFrameInvScaled = - (1.0f / 256.0f) / gAudioContext.audioBufferParameters.updatesPerFrame; - gAudioContext.audioBufferParameters.updatesPerFrameScaled = - gAudioContext.audioBufferParameters.updatesPerFrame / 4.0f; - gAudioContext.audioBufferParameters.updatesPerFrameInv = 1.0f / gAudioContext.audioBufferParameters.updatesPerFrame; + gAudioCtx.audioBufferParameters.numSamplesPerUpdateMax = gAudioCtx.audioBufferParameters.numSamplesPerUpdate + 8; + gAudioCtx.audioBufferParameters.numSamplesPerUpdateMin = gAudioCtx.audioBufferParameters.numSamplesPerUpdate - 8; + gAudioCtx.audioBufferParameters.resampleRate = 32000.0f / (s32)gAudioCtx.audioBufferParameters.samplingFreq; + gAudioCtx.audioBufferParameters.updatesPerFrameInvScaled = + (1.0f / 256.0f) / gAudioCtx.audioBufferParameters.updatesPerFrame; + gAudioCtx.audioBufferParameters.updatesPerFrameScaled = gAudioCtx.audioBufferParameters.updatesPerFrame / 4.0f; + gAudioCtx.audioBufferParameters.updatesPerFrameInv = 1.0f / gAudioCtx.audioBufferParameters.updatesPerFrame; // sample dma size - gAudioContext.sampleDmaBufSize1 = spec->sampleDmaBufSize1; - gAudioContext.sampleDmaBufSize2 = spec->sampleDmaBufSize2; + gAudioCtx.sampleDmaBufSize1 = spec->sampleDmaBufSize1; + gAudioCtx.sampleDmaBufSize2 = spec->sampleDmaBufSize2; - gAudioContext.numNotes = spec->numNotes; - gAudioContext.audioBufferParameters.numSequencePlayers = spec->numSequencePlayers; + gAudioCtx.numNotes = spec->numNotes; + gAudioCtx.audioBufferParameters.numSequencePlayers = spec->numSequencePlayers; - if (gAudioContext.audioBufferParameters.numSequencePlayers > 5) { - gAudioContext.audioBufferParameters.numSequencePlayers = 5; + if (gAudioCtx.audioBufferParameters.numSequencePlayers > 5) { + gAudioCtx.audioBufferParameters.numSequencePlayers = 5; } - gAudioContext.unk_29BC = 8; - gAudioContext.unk_2 = spec->unk_14; - gAudioContext.tempoInternalToExternal = (u32)(gAudioContext.audioBufferParameters.updatesPerFrame * 2880000.0f / - gTatumsPerBeat / gAudioContext.unk_2960); + gAudioCtx.unk_29BC = 8; + gAudioCtx.unk_2 = spec->unk_14; + gAudioCtx.tempoInternalToExternal = + (u32)(gAudioCtx.audioBufferParameters.updatesPerFrame * 2880000.0f / gTatumsPerBeat / gAudioCtx.unk_2960); - gAudioContext.unk_2870 = gAudioContext.refreshRate; - gAudioContext.unk_2870 *= gAudioContext.audioBufferParameters.updatesPerFrame; - gAudioContext.unk_2870 /= gAudioContext.audioBufferParameters.aiSamplingFreq; - gAudioContext.unk_2870 /= gAudioContext.tempoInternalToExternal; + gAudioCtx.unk_2870 = gAudioCtx.refreshRate; + gAudioCtx.unk_2870 *= gAudioCtx.audioBufferParameters.updatesPerFrame; + gAudioCtx.unk_2870 /= gAudioCtx.audioBufferParameters.aiSamplingFreq; + gAudioCtx.unk_2870 /= gAudioCtx.tempoInternalToExternal; - gAudioContext.audioBufferParameters.specUnk4 = spec->unk_04; - gAudioContext.audioBufferParameters.numSamplesPerFrameTarget *= gAudioContext.audioBufferParameters.specUnk4; - gAudioContext.audioBufferParameters.numSamplesPerFrameMax *= gAudioContext.audioBufferParameters.specUnk4; - gAudioContext.audioBufferParameters.numSamplesPerFrameMin *= gAudioContext.audioBufferParameters.specUnk4; - gAudioContext.audioBufferParameters.updatesPerFrame *= gAudioContext.audioBufferParameters.specUnk4; + gAudioCtx.audioBufferParameters.specUnk4 = spec->unk_04; + gAudioCtx.audioBufferParameters.numSamplesPerFrameTarget *= gAudioCtx.audioBufferParameters.specUnk4; + gAudioCtx.audioBufferParameters.numSamplesPerFrameMax *= gAudioCtx.audioBufferParameters.specUnk4; + gAudioCtx.audioBufferParameters.numSamplesPerFrameMin *= gAudioCtx.audioBufferParameters.specUnk4; + gAudioCtx.audioBufferParameters.updatesPerFrame *= gAudioCtx.audioBufferParameters.specUnk4; - if (gAudioContext.audioBufferParameters.specUnk4 >= 2) { - gAudioContext.audioBufferParameters.numSamplesPerFrameMax -= 0x10; + if (gAudioCtx.audioBufferParameters.specUnk4 >= 2) { + gAudioCtx.audioBufferParameters.numSamplesPerFrameMax -= 0x10; } // Determine the maximum allowable number of audio command list entries for the rsp microcode - gAudioContext.maxAudioCmds = - gAudioContext.numNotes * 20 * gAudioContext.audioBufferParameters.updatesPerFrame + spec->numReverbs * 30 + 800; + gAudioCtx.maxAudioCmds = + gAudioCtx.numNotes * 20 * gAudioCtx.audioBufferParameters.updatesPerFrame + spec->numReverbs * 30 + 800; // Calculate sizes for various caches on the audio heap persistentSize = @@ -1006,81 +1000,81 @@ void AudioHeap_Init(void) { temporarySize = spec->temporarySeqCacheSize + spec->temporaryFontCacheSize + spec->temporarySampleBankCacheSize + 0x10; cachePoolSize = persistentSize + temporarySize; - miscPoolSize = gAudioContext.sessionPool.size - cachePoolSize - 0x100; + miscPoolSize = gAudioCtx.sessionPool.size - cachePoolSize - 0x100; - if (gAudioContext.externalPool.startAddr != NULL) { - gAudioContext.externalPool.curAddr = gAudioContext.externalPool.startAddr; + if (gAudioCtx.externalPool.startAddr != NULL) { + gAudioCtx.externalPool.curAddr = gAudioCtx.externalPool.startAddr; } // Session Pool Split (split into Cache and Misc heaps) - gAudioContext.sessionPoolSplit.miscPoolSize = miscPoolSize; - gAudioContext.sessionPoolSplit.cachePoolSize = cachePoolSize; - AudioHeap_InitSessionPool(&gAudioContext.sessionPoolSplit); + gAudioCtx.sessionPoolSplit.miscPoolSize = miscPoolSize; + gAudioCtx.sessionPoolSplit.cachePoolSize = cachePoolSize; + AudioHeap_InitSessionPool(&gAudioCtx.sessionPoolSplit); // Cache Pool Split (Split into Persistent and Temporary heaps) - gAudioContext.cachePoolSplit.persistentCommonPoolSize = persistentSize; - gAudioContext.cachePoolSplit.temporaryCommonPoolSize = temporarySize; - AudioHeap_InitCachePool(&gAudioContext.cachePoolSplit); + gAudioCtx.cachePoolSplit.persistentCommonPoolSize = persistentSize; + gAudioCtx.cachePoolSplit.temporaryCommonPoolSize = temporarySize; + AudioHeap_InitCachePool(&gAudioCtx.cachePoolSplit); // Persistent Pool Split (Split into Sequences, SoundFonts, Samples) - gAudioContext.persistentCommonPoolSplit.seqCacheSize = spec->persistentSeqCacheSize; - gAudioContext.persistentCommonPoolSplit.fontCacheSize = spec->persistentFontCacheSize; - gAudioContext.persistentCommonPoolSplit.sampleBankCacheSize = spec->persistentSampleBankCacheSize; - AudioHeap_InitPersistentPoolsAndCaches(&gAudioContext.persistentCommonPoolSplit); + gAudioCtx.persistentCommonPoolSplit.seqCacheSize = spec->persistentSeqCacheSize; + gAudioCtx.persistentCommonPoolSplit.fontCacheSize = spec->persistentFontCacheSize; + gAudioCtx.persistentCommonPoolSplit.sampleBankCacheSize = spec->persistentSampleBankCacheSize; + AudioHeap_InitPersistentPoolsAndCaches(&gAudioCtx.persistentCommonPoolSplit); // Temporary Pool Split (Split into Sequences, SoundFonts, Samples) - gAudioContext.temporaryCommonPoolSplit.seqCacheSize = spec->temporarySeqCacheSize; - gAudioContext.temporaryCommonPoolSplit.fontCacheSize = spec->temporaryFontCacheSize; - gAudioContext.temporaryCommonPoolSplit.sampleBankCacheSize = spec->temporarySampleBankCacheSize; - AudioHeap_InitTemporaryPoolsAndCaches(&gAudioContext.temporaryCommonPoolSplit); + gAudioCtx.temporaryCommonPoolSplit.seqCacheSize = spec->temporarySeqCacheSize; + gAudioCtx.temporaryCommonPoolSplit.fontCacheSize = spec->temporaryFontCacheSize; + gAudioCtx.temporaryCommonPoolSplit.sampleBankCacheSize = spec->temporarySampleBankCacheSize; + AudioHeap_InitTemporaryPoolsAndCaches(&gAudioCtx.temporaryCommonPoolSplit); AudioHeap_ResetLoadStatus(); // Initialize notes - gAudioContext.notes = AudioHeap_AllocZeroed(&gAudioContext.miscPool, gAudioContext.numNotes * sizeof(Note)); + gAudioCtx.notes = AudioHeap_AllocZeroed(&gAudioCtx.miscPool, gAudioCtx.numNotes * sizeof(Note)); AudioPlayback_NoteInitAll(); AudioPlayback_InitNoteFreeList(); - gAudioContext.sampleStateList = - AudioHeap_AllocZeroed(&gAudioContext.miscPool, gAudioContext.audioBufferParameters.updatesPerFrame * - gAudioContext.numNotes * sizeof(NoteSampleState)); + gAudioCtx.sampleStateList = + AudioHeap_AllocZeroed(&gAudioCtx.miscPool, gAudioCtx.audioBufferParameters.updatesPerFrame * + gAudioCtx.numNotes * sizeof(NoteSampleState)); // Initialize audio binary interface command list buffer - for (i = 0; i < ARRAY_COUNT(gAudioContext.abiCmdBufs); i++) { - gAudioContext.abiCmdBufs[i] = - AudioHeap_AllocDmaMemoryZeroed(&gAudioContext.miscPool, gAudioContext.maxAudioCmds * sizeof(Acmd)); + for (i = 0; i < ARRAY_COUNT(gAudioCtx.abiCmdBufs); i++) { + gAudioCtx.abiCmdBufs[i] = + AudioHeap_AllocDmaMemoryZeroed(&gAudioCtx.miscPool, gAudioCtx.maxAudioCmds * sizeof(Acmd)); } // Initialize the decay rate table for ADSR - gAudioContext.adsrDecayTable = AudioHeap_Alloc(&gAudioContext.miscPool, 0x100 * sizeof(f32)); + gAudioCtx.adsrDecayTable = AudioHeap_Alloc(&gAudioCtx.miscPool, 0x100 * sizeof(f32)); AudioHeap_InitAdsrDecayTable(); // Initialize reverbs - for (reverbIndex = 0; reverbIndex < ARRAY_COUNT(gAudioContext.synthesisReverbs); reverbIndex++) { - gAudioContext.synthesisReverbs[reverbIndex].useReverb = 0; + for (reverbIndex = 0; reverbIndex < ARRAY_COUNT(gAudioCtx.synthesisReverbs); reverbIndex++) { + gAudioCtx.synthesisReverbs[reverbIndex].useReverb = 0; } - gAudioContext.numSynthesisReverbs = spec->numReverbs; - for (reverbIndex = 0; reverbIndex < gAudioContext.numSynthesisReverbs; reverbIndex++) { + gAudioCtx.numSynthesisReverbs = spec->numReverbs; + for (reverbIndex = 0; reverbIndex < gAudioCtx.numSynthesisReverbs; reverbIndex++) { AudioHeap_InitReverb(reverbIndex, &spec->reverbSettings[reverbIndex], true); } // Initialize sequence players AudioSeq_InitSequencePlayers(); - for (i = 0; i < gAudioContext.audioBufferParameters.numSequencePlayers; i++) { + for (i = 0; i < gAudioCtx.audioBufferParameters.numSequencePlayers; i++) { AudioSeq_InitSequencePlayerChannels(i); - AudioSeq_ResetSequencePlayer(&gAudioContext.seqPlayers[i]); + AudioSeq_ResetSequencePlayer(&gAudioCtx.seqPlayers[i]); } // Initialize two additional caches on the audio heap to store individual audio samples AudioHeap_InitSampleCaches(spec->persistentSampleCacheSize, spec->temporarySampleCacheSize); - AudioLoad_InitSampleDmaBuffers(gAudioContext.numNotes); + AudioLoad_InitSampleDmaBuffers(gAudioCtx.numNotes); // Initalize Loads - gAudioContext.preloadSampleStackTop = 0; + gAudioCtx.preloadSampleStackTop = 0; AudioLoad_InitSlowLoads(); AudioLoad_InitScriptLoads(); AudioLoad_InitAsyncLoads(); - gAudioContext.unk_4 = 0x1000; + gAudioCtx.unk_4 = 0x1000; AudioLoad_LoadPermanentSamples(); intMask = osSetIntMask(1); @@ -1091,9 +1085,9 @@ void AudioHeap_Init(void) { void* AudioHeap_SearchPermanentCache(s32 tableType, s32 id) { s32 i; - for (i = 0; i < gAudioContext.permanentPool.count; i++) { - if (gAudioContext.permanentEntries[i].tableType == tableType && gAudioContext.permanentEntries[i].id == id) { - return gAudioContext.permanentEntries[i].addr; + for (i = 0; i < gAudioCtx.permanentPool.count; i++) { + if (gAudioCtx.permanentEntries[i].tableType == tableType && gAudioCtx.permanentEntries[i].id == id) { + return gAudioCtx.permanentEntries[i].addr; } } return NULL; @@ -1101,18 +1095,18 @@ void* AudioHeap_SearchPermanentCache(s32 tableType, s32 id) { void* AudioHeap_AllocPermanent(s32 tableType, s32 id, size_t size) { void* addr; - s32 index = gAudioContext.permanentPool.count; + s32 index = gAudioCtx.permanentPool.count; - addr = AudioHeap_Alloc(&gAudioContext.permanentPool, size); - gAudioContext.permanentEntries[index].addr = addr; + addr = AudioHeap_Alloc(&gAudioCtx.permanentPool, size); + gAudioCtx.permanentEntries[index].addr = addr; if (addr == NULL) { return NULL; } - gAudioContext.permanentEntries[index].tableType = tableType; - gAudioContext.permanentEntries[index].id = id; - gAudioContext.permanentEntries[index].size = size; + gAudioCtx.permanentEntries[index].tableType = tableType; + gAudioCtx.permanentEntries[index].id = id; + gAudioCtx.permanentEntries[index].size = size; //! @bug UB: missing return. "addr" is in v0 at this point, but doing an // explicit return uses an additional register. // return addr; @@ -1143,22 +1137,22 @@ void* AudioHeap_AllocSampleCache(size_t size, s32 sampleBankId, void* sampleAddr void AudioHeap_InitSampleCaches(size_t persistentSampleCacheSize, size_t temporarySampleCacheSize) { void* addr; - addr = AudioHeap_AllocAttemptExternal(&gAudioContext.miscPool, persistentSampleCacheSize); + addr = AudioHeap_AllocAttemptExternal(&gAudioCtx.miscPool, persistentSampleCacheSize); if (addr == NULL) { - gAudioContext.persistentSampleCache.pool.size = 0; + gAudioCtx.persistentSampleCache.pool.size = 0; } else { - AudioHeap_InitPool(&gAudioContext.persistentSampleCache.pool, addr, persistentSampleCacheSize); + AudioHeap_InitPool(&gAudioCtx.persistentSampleCache.pool, addr, persistentSampleCacheSize); } - addr = AudioHeap_AllocAttemptExternal(&gAudioContext.miscPool, temporarySampleCacheSize); + addr = AudioHeap_AllocAttemptExternal(&gAudioCtx.miscPool, temporarySampleCacheSize); if (addr == NULL) { - gAudioContext.temporarySampleCache.pool.size = 0; + gAudioCtx.temporarySampleCache.pool.size = 0; } else { - AudioHeap_InitPool(&gAudioContext.temporarySampleCache.pool, addr, temporarySampleCacheSize); + AudioHeap_InitPool(&gAudioCtx.temporarySampleCache.pool, addr, temporarySampleCacheSize); } - gAudioContext.persistentSampleCache.numEntries = 0; - gAudioContext.temporarySampleCache.numEntries = 0; + gAudioCtx.persistentSampleCache.numEntries = 0; + gAudioCtx.temporarySampleCache.numEntries = 0; } SampleCacheEntry* AudioHeap_AllocTemporarySampleCacheEntry(size_t size) { @@ -1176,7 +1170,7 @@ SampleCacheEntry* AudioHeap_AllocTemporarySampleCacheEntry(size_t size) { u8* startAddr; u8* endAddr; - cache = &gAudioContext.temporarySampleCache; + cache = &gAudioCtx.temporarySampleCache; allocBefore = cache->pool.curAddr; addr = AudioHeap_Alloc(&cache->pool, size); if (addr == NULL) { @@ -1197,8 +1191,8 @@ SampleCacheEntry* AudioHeap_AllocTemporarySampleCacheEntry(size_t size) { allocAfter = cache->pool.curAddr; index = -1; - for (i = 0; i < gAudioContext.preloadSampleStackTop; i++) { - preload = &gAudioContext.preloadSampleStack[i]; + for (i = 0; i < gAudioCtx.preloadSampleStackTop; i++) { + preload = &gAudioCtx.preloadSampleStack[i]; if (preload->isFree == false) { startAddr = preload->ramAddr; endAddr = preload->ramAddr + preload->sample->size - 1; @@ -1270,7 +1264,7 @@ void AudioHeap_UnapplySampleCacheForFont(SampleCacheEntry* entry, s32 fontId) { s32 drumId; s32 sfxId; - for (instId = 0; instId < gAudioContext.soundFontList[fontId].numInstruments; instId++) { + for (instId = 0; instId < gAudioCtx.soundFontList[fontId].numInstruments; instId++) { inst = AudioPlayback_GetInstrumentInner(fontId, instId); if (inst != NULL) { if (inst->normalRangeLo != 0) { @@ -1283,14 +1277,14 @@ void AudioHeap_UnapplySampleCacheForFont(SampleCacheEntry* entry, s32 fontId) { } } - for (drumId = 0; drumId < gAudioContext.soundFontList[fontId].numDrums; drumId++) { + for (drumId = 0; drumId < gAudioCtx.soundFontList[fontId].numDrums; drumId++) { drum = AudioPlayback_GetDrum(fontId, drumId); if (drum != NULL) { AudioHeap_UnapplySampleCache(entry, drum->tunedSample.sample); } } - for (sfxId = 0; sfxId < gAudioContext.soundFontList[fontId].numSfx; sfxId++) { + for (sfxId = 0; sfxId < gAudioCtx.soundFontList[fontId].numSfx; sfxId++) { soundEffect = AudioPlayback_GetSoundEffect(fontId, sfxId); if (soundEffect != NULL) { AudioHeap_UnapplySampleCache(entry, soundEffect->tunedSample.sample); @@ -1304,10 +1298,10 @@ void AudioHeap_DiscardSampleCacheEntry(SampleCacheEntry* entry) { s32 sampleBankId2; s32 fontId; - numFonts = gAudioContext.soundFontTable->numEntries; + numFonts = gAudioCtx.soundFontTable->numEntries; for (fontId = 0; fontId < numFonts; fontId++) { - sampleBankId1 = gAudioContext.soundFontList[fontId].sampleBankId1; - sampleBankId2 = gAudioContext.soundFontList[fontId].sampleBankId2; + sampleBankId1 = gAudioCtx.soundFontList[fontId].sampleBankId1; + sampleBankId2 = gAudioCtx.soundFontList[fontId].sampleBankId2; if (((sampleBankId1 != 0xFF) && (entry->sampleBankId == sampleBankId1)) || ((sampleBankId2 != 0xFF) && (entry->sampleBankId == sampleBankId2)) || entry->sampleBankId == 0 || entry->sampleBankId == 0xFE) { @@ -1335,7 +1329,7 @@ SampleCacheEntry* AudioHeap_AllocPersistentSampleCacheEntry(size_t size) { SampleCacheEntry* entry; void* addr; - cache = &gAudioContext.persistentSampleCache; + cache = &gAudioCtx.persistentSampleCache; addr = AudioHeap_Alloc(&cache->pool, size); if (addr == NULL) { return NULL; @@ -1368,10 +1362,10 @@ void AudioHeap_DiscardSampleCaches(void) { s32 fontId; s32 j; - numFonts = gAudioContext.soundFontTable->numEntries; + numFonts = gAudioCtx.soundFontTable->numEntries; for (fontId = 0; fontId < numFonts; fontId++) { - sampleBankId1 = gAudioContext.soundFontList[fontId].sampleBankId1; - sampleBankId2 = gAudioContext.soundFontList[fontId].sampleBankId2; + sampleBankId1 = gAudioCtx.soundFontList[fontId].sampleBankId1; + sampleBankId2 = gAudioCtx.soundFontList[fontId].sampleBankId2; if ((sampleBankId1 == 0xFF) && (sampleBankId2 == 0xFF)) { continue; } @@ -1380,12 +1374,12 @@ void AudioHeap_DiscardSampleCaches(void) { continue; } - for (j = 0; j < gAudioContext.persistentSampleCache.numEntries; j++) { - AudioHeap_DiscardSampleCacheForFont(&gAudioContext.persistentSampleCache.entries[j], sampleBankId1, + for (j = 0; j < gAudioCtx.persistentSampleCache.numEntries; j++) { + AudioHeap_DiscardSampleCacheForFont(&gAudioCtx.persistentSampleCache.entries[j], sampleBankId1, sampleBankId2, fontId); } - for (j = 0; j < gAudioContext.temporarySampleCache.numEntries; j++) { - AudioHeap_DiscardSampleCacheForFont(&gAudioContext.temporarySampleCache.entries[j], sampleBankId1, + for (j = 0; j < gAudioCtx.temporarySampleCache.numEntries; j++) { + AudioHeap_DiscardSampleCacheForFont(&gAudioCtx.temporarySampleCache.entries[j], sampleBankId1, sampleBankId2, fontId); } } @@ -1442,8 +1436,8 @@ void AudioHeap_ApplySampleBankCacheInternal(s32 apply, s32 sampleBankId) { uintptr_t* newAddr; s32 pad[4]; - sampleBankTable = gAudioContext.sampleBankTable; - numFonts = gAudioContext.soundFontTable->numEntries; + sampleBankTable = gAudioCtx.sampleBankTable; + numFonts = gAudioCtx.soundFontTable->numEntries; change.oldAddr = AudioHeap_SearchCaches(SAMPLE_TABLE, CACHE_EITHER, sampleBankId); if (change.oldAddr == 0) { return; @@ -1465,8 +1459,8 @@ void AudioHeap_ApplySampleBankCacheInternal(s32 apply, s32 sampleBankId) { } for (fontId = 0; fontId < numFonts; fontId++) { - sampleBankId1 = gAudioContext.soundFontList[fontId].sampleBankId1; - sampleBankId2 = gAudioContext.soundFontList[fontId].sampleBankId2; + sampleBankId1 = gAudioCtx.soundFontList[fontId].sampleBankId1; + sampleBankId2 = gAudioCtx.soundFontList[fontId].sampleBankId2; if ((sampleBankId1 != 0xFF) || (sampleBankId2 != 0xFF)) { if (!AudioLoad_IsFontLoadComplete(fontId) || AudioHeap_SearchCaches(FONT_TABLE, CACHE_EITHER, fontId) == NULL) { @@ -1479,7 +1473,7 @@ void AudioHeap_ApplySampleBankCacheInternal(s32 apply, s32 sampleBankId) { continue; } - for (instId = 0; instId < gAudioContext.soundFontList[fontId].numInstruments; instId++) { + for (instId = 0; instId < gAudioCtx.soundFontList[fontId].numInstruments; instId++) { inst = AudioPlayback_GetInstrumentInner(fontId, instId); if (inst != NULL) { if (inst->normalRangeLo != 0) { @@ -1492,14 +1486,14 @@ void AudioHeap_ApplySampleBankCacheInternal(s32 apply, s32 sampleBankId) { } } - for (drumId = 0; drumId < gAudioContext.soundFontList[fontId].numDrums; drumId++) { + for (drumId = 0; drumId < gAudioCtx.soundFontList[fontId].numDrums; drumId++) { drum = AudioPlayback_GetDrum(fontId, drumId); if (drum != NULL) { AudioHeap_ChangeStorage(&change, drum->tunedSample.sample); } } - for (sfxId = 0; sfxId < gAudioContext.soundFontList[fontId].numSfx; sfxId++) { + for (sfxId = 0; sfxId < gAudioCtx.soundFontList[fontId].numSfx; sfxId++) { soundEffect = AudioPlayback_GetSoundEffect(fontId, sfxId); if (soundEffect != NULL) { AudioHeap_ChangeStorage(&change, soundEffect->tunedSample.sample); @@ -1515,7 +1509,7 @@ void AudioHeap_DiscardSampleBanks(void) { AudioTemporaryCache* temporary; u32 i; - cache = &gAudioContext.sampleBankCache; + cache = &gAudioCtx.sampleBankCache; temporary = &cache->temporary; if (temporary->entries[0].id != -1) { @@ -1534,7 +1528,7 @@ void AudioHeap_DiscardSampleBanks(void) { void AudioHeap_SetReverbData(s32 reverbIndex, u32 dataType, s32 data, s32 isFirstInit) { s32 delayNumSamples; - SynthesisReverb* reverb = &gAudioContext.synthesisReverbs[reverbIndex]; + SynthesisReverb* reverb = &gAudioCtx.synthesisReverbs[reverbIndex]; switch (dataType) { case REVERB_DATA_TYPE_SETTINGS: @@ -1568,14 +1562,10 @@ void AudioHeap_SetReverbData(s32 reverbIndex, u32 dataType, s32 data, s32 isFirs if ((reverb->downsampleRate != 1) || reverb->resampleEffectOn) { reverb->downsamplePitch = 0x8000 / reverb->downsampleRate; if (reverb->leftLoadResampleBuf == NULL) { - reverb->leftLoadResampleBuf = - AudioHeap_AllocZeroed(&gAudioContext.miscPool, sizeof(RESAMPLE_STATE)); - reverb->rightLoadResampleBuf = - AudioHeap_AllocZeroed(&gAudioContext.miscPool, sizeof(RESAMPLE_STATE)); - reverb->leftSaveResampleBuf = - AudioHeap_AllocZeroed(&gAudioContext.miscPool, sizeof(RESAMPLE_STATE)); - reverb->rightSaveResampleBuf = - AudioHeap_AllocZeroed(&gAudioContext.miscPool, sizeof(RESAMPLE_STATE)); + reverb->leftLoadResampleBuf = AudioHeap_AllocZeroed(&gAudioCtx.miscPool, sizeof(RESAMPLE_STATE)); + reverb->rightLoadResampleBuf = AudioHeap_AllocZeroed(&gAudioCtx.miscPool, sizeof(RESAMPLE_STATE)); + reverb->leftSaveResampleBuf = AudioHeap_AllocZeroed(&gAudioCtx.miscPool, sizeof(RESAMPLE_STATE)); + reverb->rightSaveResampleBuf = AudioHeap_AllocZeroed(&gAudioCtx.miscPool, sizeof(RESAMPLE_STATE)); if (reverb->rightSaveResampleBuf == NULL) { reverb->downsampleRate = 1; } @@ -1584,31 +1574,31 @@ void AudioHeap_SetReverbData(s32 reverbIndex, u32 dataType, s32 data, s32 isFirs break; case REVERB_DATA_TYPE_DECAY: - gAudioContext.synthesisReverbs[reverbIndex].decayRatio = data; + gAudioCtx.synthesisReverbs[reverbIndex].decayRatio = data; break; case REVERB_DATA_TYPE_SUB_VOLUME: - gAudioContext.synthesisReverbs[reverbIndex].subVolume = data; + gAudioCtx.synthesisReverbs[reverbIndex].subVolume = data; break; case REVERB_DATA_TYPE_VOLUME: - gAudioContext.synthesisReverbs[reverbIndex].volume = data; + gAudioCtx.synthesisReverbs[reverbIndex].volume = data; break; case REVERB_DATA_TYPE_LEAK_RIGHT: - gAudioContext.synthesisReverbs[reverbIndex].leakRtl = data; + gAudioCtx.synthesisReverbs[reverbIndex].leakRtl = data; break; case REVERB_DATA_TYPE_LEAK_LEFT: - gAudioContext.synthesisReverbs[reverbIndex].leakLtr = data; + gAudioCtx.synthesisReverbs[reverbIndex].leakLtr = data; break; case REVERB_DATA_TYPE_FILTER_LEFT: if (data != 0) { if (isFirstInit || (reverb->filterLeftInit == NULL)) { - reverb->filterLeftState = AudioHeap_AllocDmaMemoryZeroed(&gAudioContext.miscPool, - 2 * (FILTER_BUF_PART1 + FILTER_BUF_PART2)); - reverb->filterLeftInit = AudioHeap_AllocDmaMemory(&gAudioContext.miscPool, FILTER_SIZE); + reverb->filterLeftState = + AudioHeap_AllocDmaMemoryZeroed(&gAudioCtx.miscPool, 2 * (FILTER_BUF_PART1 + FILTER_BUF_PART2)); + reverb->filterLeftInit = AudioHeap_AllocDmaMemory(&gAudioCtx.miscPool, FILTER_SIZE); } reverb->filterLeft = reverb->filterLeftInit; @@ -1627,9 +1617,9 @@ void AudioHeap_SetReverbData(s32 reverbIndex, u32 dataType, s32 data, s32 isFirs case REVERB_DATA_TYPE_FILTER_RIGHT: if (data != 0) { if (isFirstInit || (reverb->filterRightInit == NULL)) { - reverb->filterRightState = AudioHeap_AllocDmaMemoryZeroed( - &gAudioContext.miscPool, 2 * (FILTER_BUF_PART1 + FILTER_BUF_PART2)); - reverb->filterRightInit = AudioHeap_AllocDmaMemory(&gAudioContext.miscPool, FILTER_SIZE); + reverb->filterRightState = + AudioHeap_AllocDmaMemoryZeroed(&gAudioCtx.miscPool, 2 * (FILTER_BUF_PART1 + FILTER_BUF_PART2)); + reverb->filterRightInit = AudioHeap_AllocDmaMemory(&gAudioCtx.miscPool, FILTER_SIZE); } reverb->filterRight = reverb->filterRightInit; if (reverb->filterRight != NULL) { @@ -1658,7 +1648,7 @@ void AudioHeap_SetReverbData(s32 reverbIndex, u32 dataType, s32 data, s32 isFirs } void AudioHeap_InitReverb(s32 reverbIndex, ReverbSettings* settings, s32 isFirstInit) { - SynthesisReverb* reverb = &gAudioContext.synthesisReverbs[reverbIndex]; + SynthesisReverb* reverb = &gAudioCtx.synthesisReverbs[reverbIndex]; if (isFirstInit) { reverb->delayNumSamplesAfterDownsampling = settings->delayNumSamples / settings->downsampleRate; @@ -1684,10 +1674,8 @@ void AudioHeap_InitReverb(s32 reverbIndex, ReverbSettings* settings, s32 isFirst reverb->useReverb = 8; // used as a boolean if (isFirstInit) { - reverb->leftReverbBuf = - AudioHeap_AllocZeroedAttemptExternal(&gAudioContext.miscPool, reverb->delayNumSamples * 2); - reverb->rightReverbBuf = - AudioHeap_AllocZeroedAttemptExternal(&gAudioContext.miscPool, reverb->delayNumSamples * 2); + reverb->leftReverbBuf = AudioHeap_AllocZeroedAttemptExternal(&gAudioCtx.miscPool, reverb->delayNumSamples * 2); + reverb->rightReverbBuf = AudioHeap_AllocZeroedAttemptExternal(&gAudioCtx.miscPool, reverb->delayNumSamples * 2); reverb->resampleFlags = 1; reverb->nextReverbBufPos = 0; reverb->delayNumSamplesUnk = 0; diff --git a/src/code/audio/audio_init_params.c b/src/code/audio/audio_init_params.c index 59c6658ac3..6bba865e9c 100644 --- a/src/code/audio/audio_init_params.c +++ b/src/code/audio/audio_init_params.c @@ -14,7 +14,7 @@ const s16 gAudioTatumInit[] = { #define SOUNDFONT_2_SIZE 0xCE0 // Sizes of everything on the init pool -#define AI_BUFFERS_SIZE (AIBUF_SIZE * ARRAY_COUNT(gAudioContext.aiBuffers)) +#define AI_BUFFERS_SIZE (AIBUF_SIZE * ARRAY_COUNT(gAudioCtx.aiBuffers)) #define SOUNDFONT_LIST_SIZE (NUM_SOUNDFONTS * sizeof(SoundFont)) // 0x19BD0 diff --git a/src/code/audio/audio_load.c b/src/code/audio/audio_load.c index c9b5ad30bf..d101b53f54 100644 --- a/src/code/audio/audio_load.c +++ b/src/code/audio/audio_load.c @@ -92,38 +92,38 @@ s32 D_801FD1E0; DmaHandler sDmaHandler = osEPiStartDma; void* sUnusedHandler = NULL; -s32 gAudioContextInitalized = false; +s32 gAudioCtxInitalized = false; void AudioLoad_DecreaseSampleDmaTtls(void) { u32 i; - for (i = 0; i < gAudioContext.sampleDmaListSize1; i++) { - SampleDma* dma = &gAudioContext.sampleDmas[i]; + for (i = 0; i < gAudioCtx.sampleDmaListSize1; i++) { + SampleDma* dma = &gAudioCtx.sampleDmas[i]; if (dma->ttl != 0) { dma->ttl--; if (dma->ttl == 0) { - dma->reuseIndex = gAudioContext.sampleDmaReuseQueue1WrPos; - gAudioContext.sampleDmaReuseQueue1[gAudioContext.sampleDmaReuseQueue1WrPos] = i; - gAudioContext.sampleDmaReuseQueue1WrPos++; + dma->reuseIndex = gAudioCtx.sampleDmaReuseQueue1WrPos; + gAudioCtx.sampleDmaReuseQueue1[gAudioCtx.sampleDmaReuseQueue1WrPos] = i; + gAudioCtx.sampleDmaReuseQueue1WrPos++; } } } - for (i = gAudioContext.sampleDmaListSize1; i < gAudioContext.sampleDmaCount; i++) { - SampleDma* dma = &gAudioContext.sampleDmas[i]; + for (i = gAudioCtx.sampleDmaListSize1; i < gAudioCtx.sampleDmaCount; i++) { + SampleDma* dma = &gAudioCtx.sampleDmas[i]; if (dma->ttl != 0) { dma->ttl--; if (dma->ttl == 0) { - dma->reuseIndex = gAudioContext.sampleDmaReuseQueue2WrPos; - gAudioContext.sampleDmaReuseQueue2[gAudioContext.sampleDmaReuseQueue2WrPos] = i; - gAudioContext.sampleDmaReuseQueue2WrPos++; + dma->reuseIndex = gAudioCtx.sampleDmaReuseQueue2WrPos; + gAudioCtx.sampleDmaReuseQueue2[gAudioCtx.sampleDmaReuseQueue2WrPos] = i; + gAudioCtx.sampleDmaReuseQueue2WrPos++; } } } - gAudioContext.unused2648 = 0; + gAudioCtx.unused2648 = 0; } void* AudioLoad_DmaSampleData(uintptr_t devAddr, size_t size, s32 arg2, u8* dmaIndexRef, s32 medium) { @@ -137,24 +137,22 @@ void* AudioLoad_DmaSampleData(uintptr_t devAddr, size_t size, s32 arg2, u8* dmaI s32 bufferPos; u32 i; - if (arg2 != 0 || *dmaIndexRef >= gAudioContext.sampleDmaListSize1) { - for (i = gAudioContext.sampleDmaListSize1; i < gAudioContext.sampleDmaCount; i++) { - dma = &gAudioContext.sampleDmas[i]; + if (arg2 != 0 || *dmaIndexRef >= gAudioCtx.sampleDmaListSize1) { + for (i = gAudioCtx.sampleDmaListSize1; i < gAudioCtx.sampleDmaCount; i++) { + dma = &gAudioCtx.sampleDmas[i]; bufferPos = devAddr - dma->devAddr; if (0 <= bufferPos && ((u32)bufferPos <= dma->size - size)) { // We already have a DMA request for this memory range. - if (dma->ttl == 0 && - gAudioContext.sampleDmaReuseQueue2RdPos != gAudioContext.sampleDmaReuseQueue2WrPos) { + if (dma->ttl == 0 && gAudioCtx.sampleDmaReuseQueue2RdPos != gAudioCtx.sampleDmaReuseQueue2WrPos) { // Move the DMA out of the reuse queue, by swapping it with the // read pos, and then incrementing the read pos. - if (dma->reuseIndex != gAudioContext.sampleDmaReuseQueue2RdPos) { - gAudioContext.sampleDmaReuseQueue2[dma->reuseIndex] = - gAudioContext.sampleDmaReuseQueue2[gAudioContext.sampleDmaReuseQueue2RdPos]; - gAudioContext - .sampleDmas[gAudioContext.sampleDmaReuseQueue2[gAudioContext.sampleDmaReuseQueue2RdPos]] + if (dma->reuseIndex != gAudioCtx.sampleDmaReuseQueue2RdPos) { + gAudioCtx.sampleDmaReuseQueue2[dma->reuseIndex] = + gAudioCtx.sampleDmaReuseQueue2[gAudioCtx.sampleDmaReuseQueue2RdPos]; + gAudioCtx.sampleDmas[gAudioCtx.sampleDmaReuseQueue2[gAudioCtx.sampleDmaReuseQueue2RdPos]] .reuseIndex = dma->reuseIndex; } - gAudioContext.sampleDmaReuseQueue2RdPos++; + gAudioCtx.sampleDmaReuseQueue2RdPos++; } dma->ttl = 32; *dmaIndexRef = (u8)i; @@ -166,16 +164,16 @@ void* AudioLoad_DmaSampleData(uintptr_t devAddr, size_t size, s32 arg2, u8* dmaI goto search_short_lived; } - if (gAudioContext.sampleDmaReuseQueue2RdPos != gAudioContext.sampleDmaReuseQueue2WrPos && arg2 != 0) { + if (gAudioCtx.sampleDmaReuseQueue2RdPos != gAudioCtx.sampleDmaReuseQueue2WrPos && arg2 != 0) { // Allocate a DMA from reuse queue 2, unless full. - dmaIndex = gAudioContext.sampleDmaReuseQueue2[gAudioContext.sampleDmaReuseQueue2RdPos]; - gAudioContext.sampleDmaReuseQueue2RdPos++; - dma = gAudioContext.sampleDmas + dmaIndex; + dmaIndex = gAudioCtx.sampleDmaReuseQueue2[gAudioCtx.sampleDmaReuseQueue2RdPos]; + gAudioCtx.sampleDmaReuseQueue2RdPos++; + dma = gAudioCtx.sampleDmas + dmaIndex; hasDma = true; } } else { search_short_lived: - dma = gAudioContext.sampleDmas + *dmaIndexRef; + dma = gAudioCtx.sampleDmas + *dmaIndexRef; i = 0; again: bufferPos = devAddr - dma->devAddr; @@ -184,31 +182,30 @@ void* AudioLoad_DmaSampleData(uintptr_t devAddr, size_t size, s32 arg2, u8* dmaI if (dma->ttl == 0) { // Move the DMA out of the reuse queue, by swapping it with the // read pos, and then incrementing the read pos. - if (dma->reuseIndex != gAudioContext.sampleDmaReuseQueue1RdPos) { - gAudioContext.sampleDmaReuseQueue1[dma->reuseIndex] = - gAudioContext.sampleDmaReuseQueue1[gAudioContext.sampleDmaReuseQueue1RdPos]; - gAudioContext - .sampleDmas[gAudioContext.sampleDmaReuseQueue1[gAudioContext.sampleDmaReuseQueue1RdPos]] + if (dma->reuseIndex != gAudioCtx.sampleDmaReuseQueue1RdPos) { + gAudioCtx.sampleDmaReuseQueue1[dma->reuseIndex] = + gAudioCtx.sampleDmaReuseQueue1[gAudioCtx.sampleDmaReuseQueue1RdPos]; + gAudioCtx.sampleDmas[gAudioCtx.sampleDmaReuseQueue1[gAudioCtx.sampleDmaReuseQueue1RdPos]] .reuseIndex = dma->reuseIndex; } - gAudioContext.sampleDmaReuseQueue1RdPos++; + gAudioCtx.sampleDmaReuseQueue1RdPos++; } dma->ttl = 2; return dma->ramAddr + (devAddr - dma->devAddr); } - dma = gAudioContext.sampleDmas + i++; - if (i <= gAudioContext.sampleDmaListSize1) { + dma = gAudioCtx.sampleDmas + i++; + if (i <= gAudioCtx.sampleDmaListSize1) { goto again; } } if (!hasDma) { - if (gAudioContext.sampleDmaReuseQueue1RdPos == gAudioContext.sampleDmaReuseQueue1WrPos) { + if (gAudioCtx.sampleDmaReuseQueue1RdPos == gAudioCtx.sampleDmaReuseQueue1WrPos) { return NULL; } // Allocate a DMA from reuse queue 1. - dmaIndex = gAudioContext.sampleDmaReuseQueue1[gAudioContext.sampleDmaReuseQueue1RdPos++]; - dma = gAudioContext.sampleDmas + dmaIndex; + dmaIndex = gAudioCtx.sampleDmaReuseQueue1[gAudioCtx.sampleDmaReuseQueue1RdPos++]; + dma = gAudioCtx.sampleDmas + dmaIndex; hasDma = true; } @@ -217,9 +214,8 @@ void* AudioLoad_DmaSampleData(uintptr_t devAddr, size_t size, s32 arg2, u8* dmaI dma->ttl = 3; dma->devAddr = dmaDevAddr; dma->sizeUnused = transfer; - AudioLoad_Dma(&gAudioContext.currAudioFrameDmaIoMesgBuf[gAudioContext.curAudioFrameDmaCount++], OS_MESG_PRI_NORMAL, - OS_READ, dmaDevAddr, dma->ramAddr, transfer, &gAudioContext.curAudioFrameDmaQueue, medium, - "SUPERDMA"); + AudioLoad_Dma(&gAudioCtx.currAudioFrameDmaIoMesgBuf[gAudioCtx.curAudioFrameDmaCount++], OS_MESG_PRI_NORMAL, OS_READ, + dmaDevAddr, dma->ramAddr, transfer, &gAudioCtx.curAudioFrameDmaQueue, medium, "SUPERDMA"); *dmaIndexRef = dmaIndex; return (devAddr - dmaDevAddr) + dma->ramAddr; } @@ -233,78 +229,77 @@ void AudioLoad_InitSampleDmaBuffers(s32 numNotes) { s32 t2; s32 j; - gAudioContext.sampleDmaBufSize = gAudioContext.sampleDmaBufSize1; - gAudioContext.sampleDmas = - AudioHeap_Alloc(&gAudioContext.miscPool, - 4 * gAudioContext.numNotes * sizeof(SampleDma) * gAudioContext.audioBufferParameters.specUnk4); - t2 = 3 * gAudioContext.numNotes * gAudioContext.audioBufferParameters.specUnk4; + gAudioCtx.sampleDmaBufSize = gAudioCtx.sampleDmaBufSize1; + gAudioCtx.sampleDmas = AudioHeap_Alloc(&gAudioCtx.miscPool, 4 * gAudioCtx.numNotes * sizeof(SampleDma) * + gAudioCtx.audioBufferParameters.specUnk4); + t2 = 3 * gAudioCtx.numNotes * gAudioCtx.audioBufferParameters.specUnk4; // First 3/4 sampleDmas for (i = 0; i < t2; i++) { - dma = &gAudioContext.sampleDmas[gAudioContext.sampleDmaCount]; - dma->ramAddr = AudioHeap_AllocAttemptExternal(&gAudioContext.miscPool, gAudioContext.sampleDmaBufSize); + dma = &gAudioCtx.sampleDmas[gAudioCtx.sampleDmaCount]; + dma->ramAddr = AudioHeap_AllocAttemptExternal(&gAudioCtx.miscPool, gAudioCtx.sampleDmaBufSize); if (dma->ramAddr == NULL) { break; } else { - AudioHeap_WritebackDCache(dma->ramAddr, gAudioContext.sampleDmaBufSize); - dma->size = gAudioContext.sampleDmaBufSize; + AudioHeap_WritebackDCache(dma->ramAddr, gAudioCtx.sampleDmaBufSize); + dma->size = gAudioCtx.sampleDmaBufSize; dma->devAddr = 0; dma->sizeUnused = 0; dma->unused = 0; dma->ttl = 0; - gAudioContext.sampleDmaCount++; + gAudioCtx.sampleDmaCount++; } } - for (i = 0; (u32)i < gAudioContext.sampleDmaCount; i++) { - gAudioContext.sampleDmaReuseQueue1[i] = i; - gAudioContext.sampleDmas[i].reuseIndex = i; + for (i = 0; (u32)i < gAudioCtx.sampleDmaCount; i++) { + gAudioCtx.sampleDmaReuseQueue1[i] = i; + gAudioCtx.sampleDmas[i].reuseIndex = i; } - for (i = gAudioContext.sampleDmaCount; i < 0x100; i++) { - gAudioContext.sampleDmaReuseQueue1[i] = 0; + for (i = gAudioCtx.sampleDmaCount; i < 0x100; i++) { + gAudioCtx.sampleDmaReuseQueue1[i] = 0; } - gAudioContext.sampleDmaReuseQueue1RdPos = 0; - gAudioContext.sampleDmaReuseQueue1WrPos = gAudioContext.sampleDmaCount; - gAudioContext.sampleDmaListSize1 = gAudioContext.sampleDmaCount; - gAudioContext.sampleDmaBufSize = gAudioContext.sampleDmaBufSize2; + gAudioCtx.sampleDmaReuseQueue1RdPos = 0; + gAudioCtx.sampleDmaReuseQueue1WrPos = gAudioCtx.sampleDmaCount; + gAudioCtx.sampleDmaListSize1 = gAudioCtx.sampleDmaCount; + gAudioCtx.sampleDmaBufSize = gAudioCtx.sampleDmaBufSize2; - for (j = 0; j < gAudioContext.numNotes; j++) { - dma = &gAudioContext.sampleDmas[gAudioContext.sampleDmaCount]; - dma->ramAddr = AudioHeap_AllocAttemptExternal(&gAudioContext.miscPool, gAudioContext.sampleDmaBufSize); + for (j = 0; j < gAudioCtx.numNotes; j++) { + dma = &gAudioCtx.sampleDmas[gAudioCtx.sampleDmaCount]; + dma->ramAddr = AudioHeap_AllocAttemptExternal(&gAudioCtx.miscPool, gAudioCtx.sampleDmaBufSize); if (dma->ramAddr == NULL) { break; } else { - AudioHeap_WritebackDCache(dma->ramAddr, gAudioContext.sampleDmaBufSize); - dma->size = gAudioContext.sampleDmaBufSize; + AudioHeap_WritebackDCache(dma->ramAddr, gAudioCtx.sampleDmaBufSize); + dma->size = gAudioCtx.sampleDmaBufSize; dma->devAddr = 0; dma->sizeUnused = 0; dma->unused = 0; dma->ttl = 0; - gAudioContext.sampleDmaCount++; + gAudioCtx.sampleDmaCount++; } } - for (i = gAudioContext.sampleDmaListSize1; (u32)i < gAudioContext.sampleDmaCount; i++) { - gAudioContext.sampleDmaReuseQueue2[i - gAudioContext.sampleDmaListSize1] = i; - gAudioContext.sampleDmas[i].reuseIndex = i - gAudioContext.sampleDmaListSize1; + for (i = gAudioCtx.sampleDmaListSize1; (u32)i < gAudioCtx.sampleDmaCount; i++) { + gAudioCtx.sampleDmaReuseQueue2[i - gAudioCtx.sampleDmaListSize1] = i; + gAudioCtx.sampleDmas[i].reuseIndex = i - gAudioCtx.sampleDmaListSize1; } - for (i = gAudioContext.sampleDmaCount; i < 0x100; i++) { - gAudioContext.sampleDmaReuseQueue2[i] = gAudioContext.sampleDmaListSize1; + for (i = gAudioCtx.sampleDmaCount; i < 0x100; i++) { + gAudioCtx.sampleDmaReuseQueue2[i] = gAudioCtx.sampleDmaListSize1; } - gAudioContext.sampleDmaReuseQueue2RdPos = 0; - gAudioContext.sampleDmaReuseQueue2WrPos = gAudioContext.sampleDmaCount - gAudioContext.sampleDmaListSize1; + gAudioCtx.sampleDmaReuseQueue2RdPos = 0; + gAudioCtx.sampleDmaReuseQueue2WrPos = gAudioCtx.sampleDmaCount - gAudioCtx.sampleDmaListSize1; } s32 AudioLoad_IsFontLoadComplete(s32 fontId) { if (fontId == 0xFF) { return true; - } else if (gAudioContext.fontLoadStatus[fontId] >= LOAD_STATUS_COMPLETE) { + } else if (gAudioCtx.fontLoadStatus[fontId] >= LOAD_STATUS_COMPLETE) { return true; - } else if (gAudioContext.fontLoadStatus[AudioLoad_GetRealTableIndex(FONT_TABLE, fontId)] >= LOAD_STATUS_COMPLETE) { + } else if (gAudioCtx.fontLoadStatus[AudioLoad_GetRealTableIndex(FONT_TABLE, fontId)] >= LOAD_STATUS_COMPLETE) { return true; } else { return false; @@ -314,10 +309,9 @@ s32 AudioLoad_IsFontLoadComplete(s32 fontId) { s32 AudioLoad_IsSeqLoadComplete(s32 seqId) { if (seqId == 0xFF) { return true; - } else if (gAudioContext.seqLoadStatus[seqId] >= LOAD_STATUS_COMPLETE) { + } else if (gAudioCtx.seqLoadStatus[seqId] >= LOAD_STATUS_COMPLETE) { return true; - } else if (gAudioContext.seqLoadStatus[AudioLoad_GetRealTableIndex(SEQUENCE_TABLE, seqId)] >= - LOAD_STATUS_COMPLETE) { + } else if (gAudioCtx.seqLoadStatus[AudioLoad_GetRealTableIndex(SEQUENCE_TABLE, seqId)] >= LOAD_STATUS_COMPLETE) { return true; } else { return false; @@ -327,9 +321,9 @@ s32 AudioLoad_IsSeqLoadComplete(s32 seqId) { s32 AudioLoad_IsSampleLoadComplete(s32 sampleBankId) { if (sampleBankId == 0xFF) { return true; - } else if (gAudioContext.sampleFontLoadStatus[sampleBankId] >= LOAD_STATUS_COMPLETE) { + } else if (gAudioCtx.sampleFontLoadStatus[sampleBankId] >= LOAD_STATUS_COMPLETE) { return true; - } else if (gAudioContext.sampleFontLoadStatus[AudioLoad_GetRealTableIndex(SAMPLE_TABLE, sampleBankId)] >= + } else if (gAudioCtx.sampleFontLoadStatus[AudioLoad_GetRealTableIndex(SAMPLE_TABLE, sampleBankId)] >= LOAD_STATUS_COMPLETE) { return true; } else { @@ -338,33 +332,33 @@ s32 AudioLoad_IsSampleLoadComplete(s32 sampleBankId) { } void AudioLoad_SetFontLoadStatus(s32 fontId, s32 loadStatus) { - if ((fontId != 0xFF) && (gAudioContext.fontLoadStatus[fontId] != LOAD_STATUS_PERMANENT)) { - gAudioContext.fontLoadStatus[fontId] = loadStatus; + if ((fontId != 0xFF) && (gAudioCtx.fontLoadStatus[fontId] != LOAD_STATUS_PERMANENT)) { + gAudioCtx.fontLoadStatus[fontId] = loadStatus; } } void AudioLoad_SetSeqLoadStatus(s32 seqId, s32 loadStatus) { - if ((seqId != 0xFF) && (gAudioContext.seqLoadStatus[seqId] != LOAD_STATUS_PERMANENT)) { - gAudioContext.seqLoadStatus[seqId] = loadStatus; + if ((seqId != 0xFF) && (gAudioCtx.seqLoadStatus[seqId] != LOAD_STATUS_PERMANENT)) { + gAudioCtx.seqLoadStatus[seqId] = loadStatus; } } void AudioLoad_SetSampleFontLoadStatusAndApplyCaches(s32 sampleBankId, s32 loadStatus) { if (sampleBankId != 0xFF) { - if (gAudioContext.sampleFontLoadStatus[sampleBankId] != LOAD_STATUS_PERMANENT) { - gAudioContext.sampleFontLoadStatus[sampleBankId] = loadStatus; + if (gAudioCtx.sampleFontLoadStatus[sampleBankId] != LOAD_STATUS_PERMANENT) { + gAudioCtx.sampleFontLoadStatus[sampleBankId] = loadStatus; } - if ((gAudioContext.sampleFontLoadStatus[sampleBankId] == LOAD_STATUS_PERMANENT) || - (gAudioContext.sampleFontLoadStatus[sampleBankId] == LOAD_STATUS_COMPLETE)) { + if ((gAudioCtx.sampleFontLoadStatus[sampleBankId] == LOAD_STATUS_PERMANENT) || + (gAudioCtx.sampleFontLoadStatus[sampleBankId] == LOAD_STATUS_COMPLETE)) { AudioHeap_ApplySampleBankCache(sampleBankId); } } } void AudioLoad_SetSampleFontLoadStatus(s32 sampleBankId, s32 loadStatus) { - if ((sampleBankId != 0xFF) && (gAudioContext.sampleFontLoadStatus[sampleBankId] != LOAD_STATUS_PERMANENT)) { - gAudioContext.sampleFontLoadStatus[sampleBankId] = loadStatus; + if ((sampleBankId != 0xFF) && (gAudioCtx.sampleFontLoadStatus[sampleBankId] != LOAD_STATUS_PERMANENT)) { + gAudioCtx.sampleFontLoadStatus[sampleBankId] = loadStatus; } } @@ -389,16 +383,16 @@ SoundFontData* AudioLoad_SyncLoadSeqFonts(s32 seqId, u32* outDefaultFontId) { s32 fontId; s32 i; - if (seqId >= gAudioContext.numSequences) { + if (seqId >= gAudioCtx.numSequences) { return NULL; } fontId = 0xFF; - index = ((u16*)gAudioContext.sequenceFontTable)[seqId]; - numFonts = gAudioContext.sequenceFontTable[index++]; + index = ((u16*)gAudioCtx.sequenceFontTable)[seqId]; + numFonts = gAudioCtx.sequenceFontTable[index++]; while (numFonts > 0) { - fontId = gAudioContext.sequenceFontTable[index++]; + fontId = gAudioCtx.sequenceFontTable[index++]; fontData = AudioLoad_SyncLoadFont(fontId); numFonts--; } @@ -411,7 +405,7 @@ void AudioLoad_SyncLoadSeqParts(s32 seqId, s32 arg1, s32 arg2, OSMesgQueue* arg3 s32 pad; u32 defaultFontId; - if (seqId < gAudioContext.numSequences) { + if (seqId < gAudioCtx.numSequences) { if (arg1 & 2) { AudioLoad_SyncLoadSeqFonts(seqId, &defaultFontId); } @@ -437,7 +431,7 @@ s32 AudioLoad_SyncLoadSample(Sample* sample, s32 fontId) { if (sample->medium == MEDIUM_UNK) { AudioLoad_SyncDmaUnkMedium(sample->sampleAddr, sampleAddr, sample->size, - gAudioContext.sampleBankTable->unkMediumParam); + gAudioCtx.sampleBankTable->unkMediumParam); } else { AudioLoad_SyncDma(sample->sampleAddr, sampleAddr, sample->size, sample->medium); } @@ -493,23 +487,23 @@ void AudioLoad_AsyncLoadFont(s32 fontId, s32 arg1, s32 retData, OSMesgQueue* ret } u8* AudioLoad_GetFontsForSequence(s32 seqId, u32* outNumFonts) { - s32 index = ((u16*)gAudioContext.sequenceFontTable)[seqId]; + s32 index = ((u16*)gAudioCtx.sequenceFontTable)[seqId]; - *outNumFonts = gAudioContext.sequenceFontTable[index++]; + *outNumFonts = gAudioCtx.sequenceFontTable[index++]; if (*outNumFonts == 0) { return NULL; } - return &gAudioContext.sequenceFontTable[index]; + return &gAudioCtx.sequenceFontTable[index]; } void AudioLoad_DiscardSeqFonts(s32 seqId) { s32 fontId; - s32 index = ((u16*)gAudioContext.sequenceFontTable)[seqId]; - s32 numFonts = gAudioContext.sequenceFontTable[index++]; + s32 index = ((u16*)gAudioCtx.sequenceFontTable)[seqId]; + s32 numFonts = gAudioCtx.sequenceFontTable[index++]; while (numFonts > 0) { numFonts--; - fontId = AudioLoad_GetRealTableIndex(FONT_TABLE, gAudioContext.sequenceFontTable[index++]); + fontId = AudioLoad_GetRealTableIndex(FONT_TABLE, gAudioCtx.sequenceFontTable[index++]); if (AudioHeap_SearchPermanentCache(FONT_TABLE, fontId) == NULL) { AudioLoad_DiscardFont(fontId); AudioLoad_SetFontLoadStatus(fontId, LOAD_STATUS_NOT_LOADED); @@ -519,7 +513,7 @@ void AudioLoad_DiscardSeqFonts(s32 seqId) { void AudioLoad_DiscardFont(s32 fontId) { u32 i; - AudioCache* pool = &gAudioContext.fontCache; + AudioCache* pool = &gAudioCtx.fontCache; AudioPersistentCache* persistent; if (fontId == pool->temporary.entries[0].id) { @@ -556,11 +550,11 @@ void func_8018FA60(u32 tableType, u32 id, s32 type, s32 data) { } s32 AudioLoad_SyncInitSeqPlayer(s32 playerIndex, s32 seqId, s32 arg2) { - if (gAudioContext.resetTimer != 0) { + if (gAudioCtx.resetTimer != 0) { return 0; } - gAudioContext.seqPlayers[playerIndex].skipTicks = 0; + gAudioCtx.seqPlayers[playerIndex].skipTicks = 0; AudioLoad_SyncInitSeqPlayerInternal(playerIndex, 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 @@ -569,23 +563,23 @@ s32 AudioLoad_SyncInitSeqPlayer(s32 playerIndex, s32 seqId, s32 arg2) { } s32 AudioLoad_SyncInitSeqPlayerSkipTicks(s32 playerIndex, s32 seqId, s32 skipTicks) { - if (gAudioContext.resetTimer != 0) { + if (gAudioCtx.resetTimer != 0) { return 0; } - gAudioContext.seqPlayers[playerIndex].skipTicks = skipTicks; + gAudioCtx.seqPlayers[playerIndex].skipTicks = skipTicks; AudioLoad_SyncInitSeqPlayerInternal(playerIndex, seqId, 0); // Missing return, see above. } s32 AudioLoad_SyncInitSeqPlayerInternal(s32 playerIndex, s32 seqId, s32 arg2) { - SequencePlayer* seqPlayer = &gAudioContext.seqPlayers[playerIndex]; + SequencePlayer* seqPlayer = &gAudioCtx.seqPlayers[playerIndex]; u8* seqData; s32 index; s32 numFonts; s32 fontId; - if (seqId >= gAudioContext.numSequences) { + if (seqId >= gAudioCtx.numSequences) { return 0; } @@ -593,11 +587,11 @@ s32 AudioLoad_SyncInitSeqPlayerInternal(s32 playerIndex, s32 seqId, s32 arg2) { if (1) {} fontId = 0xFF; - index = ((u16*)gAudioContext.sequenceFontTable)[seqId]; - numFonts = gAudioContext.sequenceFontTable[index++]; + index = ((u16*)gAudioCtx.sequenceFontTable)[seqId]; + numFonts = gAudioCtx.sequenceFontTable[index++]; while (numFonts > 0) { - fontId = gAudioContext.sequenceFontTable[index++]; + fontId = gAudioCtx.sequenceFontTable[index++]; AudioLoad_SyncLoadFont(fontId); numFonts--; } @@ -630,7 +624,7 @@ u8* AudioLoad_SyncLoadSeq(s32 seqId) { s32 pad; s32 didAllocate; - if (gAudioContext.seqLoadStatus[AudioLoad_GetRealTableIndex(SEQUENCE_TABLE, seqId)] == LOAD_STATUS_IN_PROGRESS) { + if (gAudioCtx.seqLoadStatus[AudioLoad_GetRealTableIndex(SEQUENCE_TABLE, seqId)] == LOAD_STATUS_IN_PROGRESS) { return NULL; } @@ -651,7 +645,7 @@ u32 AudioLoad_TrySyncLoadSampleBank(u32 sampleBankId, u32* outMedium, s32 noLoad addr = AudioLoad_SearchCaches(SAMPLE_TABLE, realTableId); if (addr != NULL) { - if (gAudioContext.sampleFontLoadStatus[realTableId] != LOAD_STATUS_IN_PROGRESS) { + if (gAudioCtx.sampleFontLoadStatus[realTableId] != LOAD_STATUS_IN_PROGRESS) { AudioLoad_SetSampleFontLoadStatus(realTableId, LOAD_STATUS_COMPLETE); } @@ -684,12 +678,12 @@ SoundFontData* AudioLoad_SyncLoadFont(u32 fontId) { SampleBankRelocInfo sampleBankReloc; s32 realFontId = AudioLoad_GetRealTableIndex(FONT_TABLE, fontId); - if (gAudioContext.fontLoadStatus[realFontId] == LOAD_STATUS_IN_PROGRESS) { + if (gAudioCtx.fontLoadStatus[realFontId] == LOAD_STATUS_IN_PROGRESS) { return NULL; } - sampleBankId1 = gAudioContext.soundFontList[realFontId].sampleBankId1; - sampleBankId2 = gAudioContext.soundFontList[realFontId].sampleBankId2; + sampleBankId1 = gAudioCtx.soundFontList[realFontId].sampleBankId1; + sampleBankId2 = gAudioCtx.soundFontList[realFontId].sampleBankId2; sampleBankReloc.sampleBankId1 = sampleBankId1; sampleBankReloc.sampleBankId2 = sampleBankId2; @@ -780,7 +774,7 @@ void* AudioLoad_SyncLoad(s32 tableType, u32 id, s32* didAllocate) { } if (tableType == FONT_TABLE) { - SoundFont* soundFont = &gAudioContext.soundFontList[realId]; + SoundFont* soundFont = &gAudioCtx.soundFontList[realId]; soundFont->numInstruments = ((UnloadedFonts*)romAddr)->numInstruments; soundFont->numDrums = ((UnloadedFonts*)romAddr)->numDrums; @@ -847,16 +841,16 @@ AudioTable* AudioLoad_GetLoadTable(s32 tableType) { switch (tableType) { case SEQUENCE_TABLE: - table = gAudioContext.sequenceTable; + table = gAudioCtx.sequenceTable; break; case FONT_TABLE: - table = gAudioContext.soundFontTable; + table = gAudioCtx.soundFontTable; break; default: table = NULL; break; case SAMPLE_TABLE: - table = gAudioContext.sampleBankTable; + table = gAudioCtx.sampleBankTable; break; } return table; @@ -877,9 +871,9 @@ void AudioLoad_RelocateFont(s32 fontId, SoundFontData* fontDataStartAddr, Sample Drum* drum; SoundEffect* soundEffect; s32 i; - s32 numDrums = gAudioContext.soundFontList[fontId].numDrums; - s32 numInstruments = gAudioContext.soundFontList[fontId].numInstruments; - s32 numSfx = gAudioContext.soundFontList[fontId].numSfx; + s32 numDrums = gAudioCtx.soundFontList[fontId].numDrums; + s32 numInstruments = gAudioCtx.soundFontList[fontId].numInstruments; + s32 numSfx = gAudioCtx.soundFontList[fontId].numSfx; u32* fontData = (u32*)fontDataStartAddr; // Relocate an offset (relative to the start of the font data) to a pointer (a ram address) @@ -985,14 +979,14 @@ void AudioLoad_RelocateFont(s32 fontId, SoundFontData* fontDataStartAddr, Sample #undef RELOC_TO_RAM // Store the relocated pointers - gAudioContext.soundFontList[fontId].drums = (Drum**)fontData[0]; - gAudioContext.soundFontList[fontId].soundEffects = (SoundEffect*)fontData[1]; - gAudioContext.soundFontList[fontId].instruments = (Instrument**)(&fontData[2]); + gAudioCtx.soundFontList[fontId].drums = (Drum**)fontData[0]; + gAudioCtx.soundFontList[fontId].soundEffects = (SoundEffect*)fontData[1]; + gAudioCtx.soundFontList[fontId].instruments = (Instrument**)(&fontData[2]); } void AudioLoad_SyncDma(uintptr_t devAddr, u8* ramAddr, size_t size, s32 medium) { - OSMesgQueue* msgQueue = &gAudioContext.syncDmaQueue; - OSIoMesg* ioMesg = &gAudioContext.syncDmaIoMesg; + OSMesgQueue* msgQueue = &gAudioCtx.syncDmaQueue; + OSIoMesg* ioMesg = &gAudioCtx.syncDmaIoMesg; size = ALIGN16(size); Audio_InvalDCache(ramAddr, size); @@ -1021,19 +1015,19 @@ s32 AudioLoad_Dma(OSIoMesg* mesg, u32 priority, s32 direction, uintptr_t devAddr OSMesgQueue* reqQueue, s32 medium, const char* dmaFuncType) { OSPiHandle* handle; - if (gAudioContext.resetTimer > 16) { + if (gAudioCtx.resetTimer > 16) { return -1; } switch (medium) { case MEDIUM_CART: - handle = gAudioContext.cartHandle; + handle = gAudioCtx.cartHandle; break; case MEDIUM_DISK_DRIVE: // driveHandle is uninitialized and corresponds to stubbed-out disk drive support. // SM64 Shindou called osDriveRomInit here. - handle = gAudioContext.driveHandle; + handle = gAudioCtx.driveHandle; break; default: @@ -1077,19 +1071,19 @@ void* AudioLoad_AsyncLoadInner(s32 tableType, s32 id, s32 nChunks, s32 retData, switch (tableType) { case SEQUENCE_TABLE: - if (gAudioContext.seqLoadStatus[realId] == LOAD_STATUS_IN_PROGRESS) { + if (gAudioCtx.seqLoadStatus[realId] == LOAD_STATUS_IN_PROGRESS) { return NULL; } break; case FONT_TABLE: - if (gAudioContext.fontLoadStatus[realId] == LOAD_STATUS_IN_PROGRESS) { + if (gAudioCtx.fontLoadStatus[realId] == LOAD_STATUS_IN_PROGRESS) { return NULL; } break; case SAMPLE_TABLE: - if (gAudioContext.sampleFontLoadStatus[realId] == LOAD_STATUS_IN_PROGRESS) { + if (gAudioCtx.sampleFontLoadStatus[realId] == LOAD_STATUS_IN_PROGRESS) { return NULL; } break; @@ -1146,7 +1140,7 @@ void* AudioLoad_AsyncLoadInner(s32 tableType, s32 id, s32 nChunks, s32 retData, } if (tableType == FONT_TABLE) { - soundFont = &gAudioContext.soundFontList[realId]; + soundFont = &gAudioCtx.soundFontList[realId]; soundFont->numInstruments = ((UnloadedFonts*)romAddr)->numInstruments; soundFont->numDrums = ((UnloadedFonts*)romAddr)->numDrums; @@ -1199,8 +1193,8 @@ void AudioLoad_SetUnusedHandler(void* callback) { } void AudioLoad_InitSoundFont(s32 fontId) { - SoundFont* font = &gAudioContext.soundFontList[fontId]; - AudioTableEntry* entry = &gAudioContext.soundFontTable->entries[fontId]; + SoundFont* font = &gAudioCtx.soundFontList[fontId]; + AudioTableEntry* entry = &gAudioCtx.soundFontTable->entries[fontId]; font->sampleBankId1 = (entry->shortData1 >> 8) & 0xFF; font->sampleBankId2 = (entry->shortData1) & 0xFF; @@ -1213,7 +1207,7 @@ void AudioLoad_Init(void* heap, size_t heapSize) { s32 pad1[9]; s32 numFonts; s32 pad2[2]; - u8* audioContextPtr; + u8* audioCtxPtr; void* addr; s32 i; s32 j; @@ -1222,120 +1216,120 @@ void AudioLoad_Init(void* heap, size_t heapSize) { gCustomAudioReverbFunction = NULL; gCustomAudioSynthFunction = NULL; - for (i = 0; i < ARRAY_COUNT(gAudioContext.unk_29A8); i++) { - gAudioContext.unk_29A8[i] = NULL; + for (i = 0; i < ARRAY_COUNT(gAudioCtx.unk_29A8); i++) { + gAudioCtx.unk_29A8[i] = NULL; } - gAudioContext.resetTimer = 0; - gAudioContext.unk_29B8 = false; + gAudioCtx.resetTimer = 0; + gAudioCtx.unk_29B8 = false; - // Set all of gAudioContext to 0 - audioContextPtr = (u8*)&gAudioContext; - for (j = sizeof(gAudioContext); j >= 0; j--) { - *audioContextPtr++ = 0; + // Set all of gAudioCtx to 0 + audioCtxPtr = (u8*)&gAudioCtx; + for (j = sizeof(gAudioCtx); j >= 0; j--) { + *audioCtxPtr++ = 0; } switch (osTvType) { case OS_TV_PAL: - gAudioContext.unk_2960 = 20.03042f; - gAudioContext.refreshRate = 50; + gAudioCtx.unk_2960 = 20.03042f; + gAudioCtx.refreshRate = 50; break; case OS_TV_MPAL: - gAudioContext.unk_2960 = 16.546f; - gAudioContext.refreshRate = 60; + gAudioCtx.unk_2960 = 16.546f; + gAudioCtx.refreshRate = 60; break; case OS_TV_NTSC: default: - gAudioContext.unk_2960 = 16.713f; - gAudioContext.refreshRate = 60; + gAudioCtx.unk_2960 = 16.713f; + gAudioCtx.refreshRate = 60; } AudioThread_InitMesgQueues(); - for (i = 0; i < ARRAY_COUNT(gAudioContext.aiBufNumSamples); i++) { - gAudioContext.aiBufNumSamples[i] = 0xA0; + for (i = 0; i < ARRAY_COUNT(gAudioCtx.aiBufNumSamples); i++) { + gAudioCtx.aiBufNumSamples[i] = 0xA0; } - gAudioContext.totalTaskCount = 0; - gAudioContext.rspTaskIndex = 0; - gAudioContext.curAiBufferIndex = 0; - gAudioContext.soundMode = SOUNDMODE_STEREO; - gAudioContext.curTask = NULL; - gAudioContext.rspTask[0].task.t.dataSize = 0; - gAudioContext.rspTask[1].task.t.dataSize = 0; + gAudioCtx.totalTaskCount = 0; + gAudioCtx.rspTaskIndex = 0; + gAudioCtx.curAiBufferIndex = 0; + gAudioCtx.soundMode = SOUNDMODE_STEREO; + gAudioCtx.curTask = NULL; + gAudioCtx.rspTask[0].task.t.dataSize = 0; + gAudioCtx.rspTask[1].task.t.dataSize = 0; - osCreateMesgQueue(&gAudioContext.syncDmaQueue, &gAudioContext.syncDmaMesg, 1); - osCreateMesgQueue(&gAudioContext.curAudioFrameDmaQueue, gAudioContext.currAudioFrameDmaMesgBuf, - ARRAY_COUNT(gAudioContext.currAudioFrameDmaMesgBuf)); - osCreateMesgQueue(&gAudioContext.externalLoadQueue, gAudioContext.externalLoadMesgBuf, - ARRAY_COUNT(gAudioContext.externalLoadMesgBuf)); - osCreateMesgQueue(&gAudioContext.preloadSampleQueue, gAudioContext.preloadSampleMesgBuf, - ARRAY_COUNT(gAudioContext.preloadSampleMesgBuf)); - gAudioContext.curAudioFrameDmaCount = 0; - gAudioContext.sampleDmaCount = 0; - gAudioContext.cartHandle = osCartRomInit(); + osCreateMesgQueue(&gAudioCtx.syncDmaQueue, &gAudioCtx.syncDmaMesg, 1); + osCreateMesgQueue(&gAudioCtx.curAudioFrameDmaQueue, gAudioCtx.currAudioFrameDmaMesgBuf, + ARRAY_COUNT(gAudioCtx.currAudioFrameDmaMesgBuf)); + osCreateMesgQueue(&gAudioCtx.externalLoadQueue, gAudioCtx.externalLoadMesgBuf, + ARRAY_COUNT(gAudioCtx.externalLoadMesgBuf)); + osCreateMesgQueue(&gAudioCtx.preloadSampleQueue, gAudioCtx.preloadSampleMesgBuf, + ARRAY_COUNT(gAudioCtx.preloadSampleMesgBuf)); + gAudioCtx.curAudioFrameDmaCount = 0; + gAudioCtx.sampleDmaCount = 0; + gAudioCtx.cartHandle = osCartRomInit(); if (heap == NULL) { - gAudioContext.audioHeap = gAudioHeap; - gAudioContext.audioHeapSize = gAudioHeapInitSizes.heapSize; + gAudioCtx.audioHeap = gAudioHeap; + gAudioCtx.audioHeapSize = gAudioHeapInitSizes.heapSize; } else { void** hp = &heap; - gAudioContext.audioHeap = *hp; - gAudioContext.audioHeapSize = heapSize; + gAudioCtx.audioHeap = *hp; + gAudioCtx.audioHeapSize = heapSize; } - for (i = 0; i < ((s32)gAudioContext.audioHeapSize / (s32)sizeof(u64)); i++) { - ((u64*)gAudioContext.audioHeap)[i] = 0; + for (i = 0; i < ((s32)gAudioCtx.audioHeapSize / (s32)sizeof(u64)); i++) { + ((u64*)gAudioCtx.audioHeap)[i] = 0; } // Main Pool Split (split entirety of audio heap into initPool and sessionPool) AudioHeap_InitMainPool(gAudioHeapInitSizes.initPoolSize); // Initialize the audio interface buffers - for (i = 0; i < ARRAY_COUNT(gAudioContext.aiBuffers); i++) { - gAudioContext.aiBuffers[i] = AudioHeap_AllocZeroed(&gAudioContext.initPool, AIBUF_LEN * sizeof(s16)); + for (i = 0; i < ARRAY_COUNT(gAudioCtx.aiBuffers); i++) { + gAudioCtx.aiBuffers[i] = AudioHeap_AllocZeroed(&gAudioCtx.initPool, AIBUF_LEN * sizeof(s16)); } // Connect audio tables to their tables in memory - gAudioContext.sequenceTable = (AudioTable*)gSequenceTable; - gAudioContext.soundFontTable = (AudioTable*)gSoundFontTable; - gAudioContext.sampleBankTable = (AudioTable*)gSampleBankTable; - gAudioContext.sequenceFontTable = gSequenceFontTable; + gAudioCtx.sequenceTable = (AudioTable*)gSequenceTable; + gAudioCtx.soundFontTable = (AudioTable*)gSoundFontTable; + gAudioCtx.sampleBankTable = (AudioTable*)gSampleBankTable; + gAudioCtx.sequenceFontTable = gSequenceFontTable; - gAudioContext.numSequences = gAudioContext.sequenceTable->numEntries; + gAudioCtx.numSequences = gAudioCtx.sequenceTable->numEntries; - gAudioContext.audioResetSpecIdToLoad = 0; - gAudioContext.resetStatus = 1; // Set reset to immediately initialize the audio heap + gAudioCtx.audioResetSpecIdToLoad = 0; + gAudioCtx.resetStatus = 1; // Set reset to immediately initialize the audio heap AudioHeap_ResetStep(); // Initialize audio tables - AudioLoad_InitTable(gAudioContext.sequenceTable, SEGMENT_ROM_START(Audioseq), 0); - AudioLoad_InitTable(gAudioContext.soundFontTable, SEGMENT_ROM_START(Audiobank), 0); - AudioLoad_InitTable(gAudioContext.sampleBankTable, SEGMENT_ROM_START(Audiotable), 0); + AudioLoad_InitTable(gAudioCtx.sequenceTable, SEGMENT_ROM_START(Audioseq), 0); + AudioLoad_InitTable(gAudioCtx.soundFontTable, SEGMENT_ROM_START(Audiobank), 0); + AudioLoad_InitTable(gAudioCtx.sampleBankTable, SEGMENT_ROM_START(Audiotable), 0); - numFonts = gAudioContext.soundFontTable->numEntries; - gAudioContext.soundFontList = AudioHeap_Alloc(&gAudioContext.initPool, numFonts * sizeof(SoundFont)); + numFonts = gAudioCtx.soundFontTable->numEntries; + gAudioCtx.soundFontList = AudioHeap_Alloc(&gAudioCtx.initPool, numFonts * sizeof(SoundFont)); for (i = 0; i < numFonts; i++) { AudioLoad_InitSoundFont(i); } - if (addr = AudioHeap_Alloc(&gAudioContext.initPool, gAudioHeapInitSizes.permanentPoolSize), addr == NULL) { + if (addr = AudioHeap_Alloc(&gAudioCtx.initPool, gAudioHeapInitSizes.permanentPoolSize), addr == NULL) { // cast away const from gAudioHeapInitSizes *((u32*)&gAudioHeapInitSizes.permanentPoolSize) = 0; } - AudioHeap_InitPool(&gAudioContext.permanentPool, addr, gAudioHeapInitSizes.permanentPoolSize); - gAudioContextInitalized = true; - osSendMesg(gAudioContext.taskStartQueueP, (void*)gAudioContext.totalTaskCount, OS_MESG_NOBLOCK); + AudioHeap_InitPool(&gAudioCtx.permanentPool, addr, gAudioHeapInitSizes.permanentPoolSize); + gAudioCtxInitalized = true; + osSendMesg(gAudioCtx.taskStartQueueP, (void*)gAudioCtx.totalTaskCount, OS_MESG_NOBLOCK); } void AudioLoad_InitSlowLoads(void) { - gAudioContext.slowLoads[0].status = 0; - gAudioContext.slowLoads[1].status = 0; + gAudioCtx.slowLoads[0].status = 0; + gAudioCtx.slowLoads[1].status = 0; } s32 AudioLoad_SlowLoadSample(s32 fontId, s32 instId, s8* isDone) { @@ -1353,7 +1347,7 @@ s32 AudioLoad_SlowLoadSample(s32 fontId, s32 instId, s8* isDone) { return 0; } - slowLoad = &gAudioContext.slowLoads[gAudioContext.slowLoadPos]; + slowLoad = &gAudioCtx.slowLoads[gAudioCtx.slowLoadPos]; if (slowLoad->status == LOAD_STATUS_DONE) { slowLoad->status = LOAD_STATUS_WAITING; } @@ -1382,10 +1376,10 @@ s32 AudioLoad_SlowLoadSample(s32 fontId, s32 instId, s8* isDone) { slowLoad->instId = instId; if (slowLoad->medium == MEDIUM_UNK) { - slowLoad->unkMediumParam = gAudioContext.sampleBankTable->unkMediumParam; + slowLoad->unkMediumParam = gAudioCtx.sampleBankTable->unkMediumParam; } - gAudioContext.slowLoadPos ^= 1; + gAudioCtx.slowLoadPos ^= 1; return 0; } @@ -1442,9 +1436,9 @@ void AudioLoad_ProcessSlowLoads(s32 resetStatus) { AudioSlowLoad* slowLoad; s32 i; - for (i = 0; i < ARRAY_COUNT(gAudioContext.slowLoads); i++) { - slowLoad = &gAudioContext.slowLoads[i]; - switch (gAudioContext.slowLoads[i].status) { + for (i = 0; i < ARRAY_COUNT(gAudioCtx.slowLoads); i++) { + slowLoad = &gAudioCtx.slowLoads[i]; + switch (gAudioCtx.slowLoads[i].status) { case LOAD_STATUS_LOADING: if (slowLoad->medium != MEDIUM_UNK) { osRecvMesg(&slowLoad->msgqueue, NULL, OS_MESG_BLOCK); @@ -1501,14 +1495,14 @@ s32 AudioLoad_SlowLoadSeq(s32 seqId, u8* ramAddr, s8* isDone) { AudioTable* seqTable; size_t size; - if (seqId >= gAudioContext.numSequences) { + if (seqId >= gAudioCtx.numSequences) { *isDone = 0; return -1; } seqId = AudioLoad_GetRealTableIndex(SEQUENCE_TABLE, seqId); seqTable = AudioLoad_GetLoadTable(SEQUENCE_TABLE); - slowLoad = &gAudioContext.slowLoads[gAudioContext.slowLoadPos]; + slowLoad = &gAudioCtx.slowLoads[gAudioCtx.slowLoadPos]; if (slowLoad->status == LOAD_STATUS_DONE) { slowLoad->status = LOAD_STATUS_WAITING; } @@ -1529,15 +1523,15 @@ s32 AudioLoad_SlowLoadSeq(s32 seqId, u8* ramAddr, s8* isDone) { slowLoad->unkMediumParam = seqTable->unkMediumParam; } - gAudioContext.slowLoadPos ^= 1; + gAudioCtx.slowLoadPos ^= 1; return 0; } void AudioLoad_InitAsyncLoads(void) { s32 i; - for (i = 0; i < ARRAY_COUNT(gAudioContext.asyncLoads); i++) { - gAudioContext.asyncLoads[i].status = 0; + for (i = 0; i < ARRAY_COUNT(gAudioCtx.asyncLoads); i++) { + gAudioCtx.asyncLoads[i].status = 0; } } @@ -1550,7 +1544,7 @@ AudioAsyncLoad* AudioLoad_StartAsyncLoadUnkMedium(s32 unkMediumParam, uintptr_t return NULL; } - osSendMesg(&gAudioContext.asyncLoadUnkMediumQueue, asyncLoad, OS_MESG_NOBLOCK); + osSendMesg(&gAudioCtx.asyncLoadUnkMediumQueue, asyncLoad, OS_MESG_NOBLOCK); asyncLoad->unkMediumParam = unkMediumParam; return asyncLoad; } @@ -1560,15 +1554,15 @@ AudioAsyncLoad* AudioLoad_StartAsyncLoad(uintptr_t devAddr, void* ramAddr, size_ AudioAsyncLoad* asyncLoad; s32 i; - for (i = 0; i < ARRAY_COUNT(gAudioContext.asyncLoads); i++) { - if (gAudioContext.asyncLoads[i].status == 0) { - asyncLoad = &gAudioContext.asyncLoads[i]; + for (i = 0; i < ARRAY_COUNT(gAudioCtx.asyncLoads); i++) { + if (gAudioCtx.asyncLoads[i].status == 0) { + asyncLoad = &gAudioCtx.asyncLoads[i]; break; } } // no more available async loads - if (i == ARRAY_COUNT(gAudioContext.asyncLoads)) { + if (i == ARRAY_COUNT(gAudioCtx.asyncLoads)) { return NULL; } @@ -1601,29 +1595,29 @@ void AudioLoad_ProcessAsyncLoads(s32 resetStatus) { AudioAsyncLoad* asyncLoad; s32 i; - if (gAudioContext.resetTimer == 1) { + if (gAudioCtx.resetTimer == 1) { return; } - if (gAudioContext.curUnkMediumLoad == NULL) { + if (gAudioCtx.curUnkMediumLoad == NULL) { if (resetStatus != 0) { // Clear and ignore queue if resetting. do { - } while (osRecvMesg(&gAudioContext.asyncLoadUnkMediumQueue, (OSMesg*)&asyncLoad, OS_MESG_NOBLOCK) != -1); - } else if (osRecvMesg(&gAudioContext.asyncLoadUnkMediumQueue, (OSMesg*)&asyncLoad, OS_MESG_NOBLOCK) == -1) { - gAudioContext.curUnkMediumLoad = NULL; + } while (osRecvMesg(&gAudioCtx.asyncLoadUnkMediumQueue, (OSMesg*)&asyncLoad, OS_MESG_NOBLOCK) != -1); + } else if (osRecvMesg(&gAudioCtx.asyncLoadUnkMediumQueue, (OSMesg*)&asyncLoad, OS_MESG_NOBLOCK) == -1) { + gAudioCtx.curUnkMediumLoad = NULL; } else { - gAudioContext.curUnkMediumLoad = asyncLoad; + gAudioCtx.curUnkMediumLoad = asyncLoad; } } - if (gAudioContext.curUnkMediumLoad != NULL) { - AudioLoad_ProcessAsyncLoadUnkMedium(gAudioContext.curUnkMediumLoad, resetStatus); + if (gAudioCtx.curUnkMediumLoad != NULL) { + AudioLoad_ProcessAsyncLoadUnkMedium(gAudioCtx.curUnkMediumLoad, resetStatus); } - for (i = 0; i < ARRAY_COUNT(gAudioContext.asyncLoads); i++) { - if (gAudioContext.asyncLoads[i].status == 1) { - asyncLoad = &gAudioContext.asyncLoads[i]; + for (i = 0; i < ARRAY_COUNT(gAudioCtx.asyncLoads); i++) { + if (gAudioCtx.asyncLoads[i].status == 1) { + asyncLoad = &gAudioCtx.asyncLoads[i]; if (asyncLoad->medium != MEDIUM_UNK) { AudioLoad_ProcessAsyncLoad(asyncLoad, resetStatus); } @@ -1653,8 +1647,8 @@ void AudioLoad_FinishAsyncLoad(AudioAsyncLoad* asyncLoad) { break; case FONT_TABLE: fontId = ASYNC_ID(retMsg); - sampleBankId1 = gAudioContext.soundFontList[fontId].sampleBankId1; - sampleBankId2 = gAudioContext.soundFontList[fontId].sampleBankId2; + sampleBankId1 = gAudioCtx.soundFontList[fontId].sampleBankId1; + sampleBankId2 = gAudioCtx.soundFontList[fontId].sampleBankId2; sampleBankReloc.sampleBankId1 = sampleBankId1; sampleBankReloc.sampleBankId2 = sampleBankId2; sampleBankReloc.baseAddr1 = @@ -1673,7 +1667,7 @@ void AudioLoad_FinishAsyncLoad(AudioAsyncLoad* asyncLoad) { } void AudioLoad_ProcessAsyncLoad(AudioAsyncLoad* asyncLoad, s32 resetStatus) { - AudioTable* sampleBankTable = gAudioContext.sampleBankTable; + AudioTable* sampleBankTable = gAudioCtx.sampleBankTable; if (asyncLoad->delay >= 2) { asyncLoad->delay--; @@ -1797,7 +1791,7 @@ void AudioLoad_RelocateSample(TunedSample* tunedSample, SoundFontData* fontData, sample->isRelocated = true; if (sample->unk_bit26 && (sample->medium != MEDIUM_RAM)) { - gAudioContext.usedSamples[gAudioContext.numUsedSamples++] = sample; + gAudioCtx.usedSamples[gAudioCtx.numUsedSamples++] = sample; } } } @@ -1823,27 +1817,27 @@ void AudioLoad_RelocateFontAndPreloadSamples(s32 fontId, SoundFontData* fontData s32 i; preloadInProgress = false; - if (gAudioContext.preloadSampleStackTop != 0) { + if (gAudioCtx.preloadSampleStackTop != 0) { preloadInProgress = true; } else { D_801FD1E0 = 0; } - gAudioContext.numUsedSamples = 0; + gAudioCtx.numUsedSamples = 0; AudioLoad_RelocateFont(fontId, fontData, sampleBankReloc); size = 0; - for (i = 0; i < gAudioContext.numUsedSamples; i++) { - size += ALIGN16(gAudioContext.usedSamples[i]->size); + for (i = 0; i < gAudioCtx.numUsedSamples; i++) { + size += ALIGN16(gAudioCtx.usedSamples[i]->size); } if (size && size) {} - for (i = 0; i < gAudioContext.numUsedSamples; i++) { - if (gAudioContext.preloadSampleStackTop == 120) { + for (i = 0; i < gAudioCtx.numUsedSamples; i++) { + if (gAudioCtx.preloadSampleStackTop == 120) { break; } - sample = gAudioContext.usedSamples[i]; + sample = gAudioCtx.usedSamples[i]; sampleRamAddr = NULL; switch (isAsync) { case false: @@ -1883,7 +1877,7 @@ void AudioLoad_RelocateFontAndPreloadSamples(s32 fontId, SoundFontData* fontData case false: if (sample->medium == MEDIUM_UNK) { AudioLoad_SyncDmaUnkMedium((uintptr_t)sample->sampleAddr, sampleRamAddr, sample->size, - gAudioContext.sampleBankTable->unkMediumParam); + gAudioCtx.sampleBankTable->unkMediumParam); sample->sampleAddr = sampleRamAddr; sample->medium = MEDIUM_RAM; } else { @@ -1895,27 +1889,27 @@ void AudioLoad_RelocateFontAndPreloadSamples(s32 fontId, SoundFontData* fontData break; case true: - preload = &gAudioContext.preloadSampleStack[gAudioContext.preloadSampleStackTop]; + preload = &gAudioCtx.preloadSampleStack[gAudioCtx.preloadSampleStackTop]; preload->sample = sample; preload->ramAddr = sampleRamAddr; - preload->encodedInfo = (gAudioContext.preloadSampleStackTop << 24) | 0xFFFFFF; + preload->encodedInfo = (gAudioCtx.preloadSampleStackTop << 24) | 0xFFFFFF; preload->isFree = false; preload->endAndMediumKey = (uintptr_t)sample->sampleAddr + sample->size + sample->medium; - gAudioContext.preloadSampleStackTop++; + gAudioCtx.preloadSampleStackTop++; break; default: break; } } - gAudioContext.numUsedSamples = 0; + gAudioCtx.numUsedSamples = 0; - if (gAudioContext.preloadSampleStackTop != 0 && !preloadInProgress) { - topPreload = &gAudioContext.preloadSampleStack[gAudioContext.preloadSampleStackTop - 1]; + if (gAudioCtx.preloadSampleStackTop != 0 && !preloadInProgress) { + topPreload = &gAudioCtx.preloadSampleStack[gAudioCtx.preloadSampleStackTop - 1]; sample = topPreload->sample; nChunks = (sample->size >> 12) + 1; AudioLoad_StartAsyncLoad((uintptr_t)sample->sampleAddr, topPreload->ramAddr, sample->size, sample->medium, - nChunks, &gAudioContext.preloadSampleQueue, topPreload->encodedInfo); + nChunks, &gAudioCtx.preloadSampleQueue, topPreload->encodedInfo); } } @@ -1927,20 +1921,20 @@ s32 AudioLoad_ProcessSamplePreloads(s32 resetStatus) { u32 nChunks; s32 pad; - if (gAudioContext.preloadSampleStackTop > 0) { + if (gAudioCtx.preloadSampleStackTop > 0) { if (resetStatus != 0) { // Clear result queue and preload stack and return. - osRecvMesg(&gAudioContext.preloadSampleQueue, (OSMesg*)&preloadIndex, OS_MESG_NOBLOCK); - gAudioContext.preloadSampleStackTop = 0; + osRecvMesg(&gAudioCtx.preloadSampleQueue, (OSMesg*)&preloadIndex, OS_MESG_NOBLOCK); + gAudioCtx.preloadSampleStackTop = 0; return false; } - if (osRecvMesg(&gAudioContext.preloadSampleQueue, (OSMesg*)&preloadIndex, OS_MESG_NOBLOCK) == -1) { + if (osRecvMesg(&gAudioCtx.preloadSampleQueue, (OSMesg*)&preloadIndex, OS_MESG_NOBLOCK) == -1) { // Previous preload is not done yet. return false; } preloadIndex >>= 24; - preload = &gAudioContext.preloadSampleStack[preloadIndex]; + preload = &gAudioCtx.preloadSampleStack[preloadIndex]; if (preload->isFree == false) { sample = preload->sample; @@ -1956,12 +1950,12 @@ s32 AudioLoad_ProcessSamplePreloads(s32 resetStatus) { // Pop requests with isFree = true off the stack, as far as possible, // and dispatch the next DMA. for (;;) { - if (gAudioContext.preloadSampleStackTop <= 0) { + if (gAudioCtx.preloadSampleStackTop <= 0) { break; } - preload = &gAudioContext.preloadSampleStack[gAudioContext.preloadSampleStackTop - 1]; + preload = &gAudioCtx.preloadSampleStack[gAudioCtx.preloadSampleStackTop - 1]; if (preload->isFree == true) { - gAudioContext.preloadSampleStackTop--; + gAudioCtx.preloadSampleStackTop--; continue; } @@ -1970,10 +1964,10 @@ s32 AudioLoad_ProcessSamplePreloads(s32 resetStatus) { key = (uintptr_t)sample->sampleAddr + sample->size + sample->medium; if (key != preload->endAndMediumKey) { preload->isFree = true; - gAudioContext.preloadSampleStackTop--; + gAudioCtx.preloadSampleStackTop--; } else { AudioLoad_StartAsyncLoad((uintptr_t)sample->sampleAddr, preload->ramAddr, sample->size, sample->medium, - nChunks, &gAudioContext.preloadSampleQueue, preload->encodedInfo); + nChunks, &gAudioCtx.preloadSampleQueue, preload->encodedInfo); break; } } @@ -2001,8 +1995,8 @@ s32 AudioLoad_AddToSampleSet(Sample* sample, s32 numSamples, Sample** sampleSet) s32 AudioLoad_GetSamplesForFont(s32 fontId, Sample** sampleSet) { s32 i; s32 numSamples = 0; - s32 numDrums = gAudioContext.soundFontList[fontId].numDrums; - s32 numInstruments = gAudioContext.soundFontList[fontId].numInstruments; + s32 numDrums = gAudioCtx.soundFontList[fontId].numDrums; + s32 numInstruments = gAudioCtx.soundFontList[fontId].numInstruments; for (i = 0; i < numDrums; i++) { Drum* drum = AudioPlayback_GetDrum(fontId, i); @@ -2035,7 +2029,7 @@ void AudioLoad_AddUsedSample(TunedSample* tunedSample) { Sample* sample = tunedSample->sample; if ((sample->size != 0) && (sample->unk_bit26) && (sample->medium != MEDIUM_RAM)) { - gAudioContext.usedSamples[gAudioContext.numUsedSamples++] = sample; + gAudioCtx.usedSamples[gAudioCtx.numUsedSamples++] = sample; } } @@ -2056,15 +2050,15 @@ void AudioLoad_PreloadSamplesForFont(s32 fontId, s32 async, SampleBankRelocInfo* s32 nChunks; preloadInProgress = false; - if (gAudioContext.preloadSampleStackTop != 0) { + if (gAudioCtx.preloadSampleStackTop != 0) { preloadInProgress = true; } - gAudioContext.numUsedSamples = 0; + gAudioCtx.numUsedSamples = 0; - numDrums = gAudioContext.soundFontList[fontId].numDrums; - numInstruments = gAudioContext.soundFontList[fontId].numInstruments; - numSfx = gAudioContext.soundFontList[fontId].numSfx; + numDrums = gAudioCtx.soundFontList[fontId].numDrums; + numInstruments = gAudioCtx.soundFontList[fontId].numInstruments; + numSfx = gAudioCtx.soundFontList[fontId].numSfx; for (i = 0; i < numInstruments; i++) { instrument = AudioPlayback_GetInstrumentInner(fontId, i); @@ -2093,22 +2087,22 @@ void AudioLoad_PreloadSamplesForFont(s32 fontId, s32 async, SampleBankRelocInfo* } } - if (gAudioContext.numUsedSamples == 0) { + if (gAudioCtx.numUsedSamples == 0) { return; } size = 0; - for (i = 0; i < gAudioContext.numUsedSamples; i++) { - size += ALIGN16(gAudioContext.usedSamples[i]->size); + for (i = 0; i < gAudioCtx.numUsedSamples; i++) { + size += ALIGN16(gAudioCtx.usedSamples[i]->size); } if (size) {} - for (i = 0; i < gAudioContext.numUsedSamples; i++) { - if (gAudioContext.preloadSampleStackTop == 120) { + for (i = 0; i < gAudioCtx.numUsedSamples; i++) { + if (gAudioCtx.preloadSampleStackTop == 120) { break; } - sample = gAudioContext.usedSamples[i]; + sample = gAudioCtx.usedSamples[i]; if (sample->medium == MEDIUM_RAM) { continue; } @@ -2142,7 +2136,7 @@ void AudioLoad_PreloadSamplesForFont(s32 fontId, s32 async, SampleBankRelocInfo* case false: if (sample->medium == MEDIUM_UNK) { AudioLoad_SyncDmaUnkMedium((uintptr_t)sample->sampleAddr, addr, sample->size, - gAudioContext.sampleBankTable->unkMediumParam); + gAudioCtx.sampleBankTable->unkMediumParam); sample->sampleAddr = addr; sample->medium = MEDIUM_RAM; } else { @@ -2153,24 +2147,24 @@ void AudioLoad_PreloadSamplesForFont(s32 fontId, s32 async, SampleBankRelocInfo* break; case true: - preload = &gAudioContext.preloadSampleStack[gAudioContext.preloadSampleStackTop]; + preload = &gAudioCtx.preloadSampleStack[gAudioCtx.preloadSampleStackTop]; preload->sample = sample; preload->ramAddr = addr; - preload->encodedInfo = (gAudioContext.preloadSampleStackTop << 24) | 0xFFFFFF; + preload->encodedInfo = (gAudioCtx.preloadSampleStackTop << 24) | 0xFFFFFF; preload->isFree = false; preload->endAndMediumKey = (uintptr_t)sample->sampleAddr + sample->size + sample->medium; - gAudioContext.preloadSampleStackTop++; + gAudioCtx.preloadSampleStackTop++; break; } } - gAudioContext.numUsedSamples = 0; + gAudioCtx.numUsedSamples = 0; - if (gAudioContext.preloadSampleStackTop != 0 && !preloadInProgress) { - topPreload = &gAudioContext.preloadSampleStack[gAudioContext.preloadSampleStackTop - 1]; + if (gAudioCtx.preloadSampleStackTop != 0 && !preloadInProgress) { + topPreload = &gAudioCtx.preloadSampleStack[gAudioCtx.preloadSampleStackTop - 1]; sample = topPreload->sample; nChunks = (sample->size >> 12) + 1; AudioLoad_StartAsyncLoad((uintptr_t)sample->sampleAddr, topPreload->ramAddr, sample->size, sample->medium, - nChunks, &gAudioContext.preloadSampleQueue, topPreload->encodedInfo); + nChunks, &gAudioCtx.preloadSampleQueue, topPreload->encodedInfo); } } @@ -2182,13 +2176,13 @@ void AudioLoad_LoadPermanentSamples(void) { s32 i; sampleBankTable = AudioLoad_GetLoadTable(SAMPLE_TABLE); - for (i = 0; i < gAudioContext.permanentPool.count; i++) { + for (i = 0; i < gAudioCtx.permanentPool.count; i++) { SampleBankRelocInfo sampleBankReloc; - if (gAudioContext.permanentEntries[i].tableType == FONT_TABLE) { - fontId = AudioLoad_GetRealTableIndex(FONT_TABLE, gAudioContext.permanentEntries[i].id); - sampleBankReloc.sampleBankId1 = gAudioContext.soundFontList[fontId].sampleBankId1; - sampleBankReloc.sampleBankId2 = gAudioContext.soundFontList[fontId].sampleBankId2; + if (gAudioCtx.permanentEntries[i].tableType == FONT_TABLE) { + fontId = AudioLoad_GetRealTableIndex(FONT_TABLE, gAudioCtx.permanentEntries[i].id); + sampleBankReloc.sampleBankId1 = gAudioCtx.soundFontList[fontId].sampleBankId1; + sampleBankReloc.sampleBankId2 = gAudioCtx.soundFontList[fontId].sampleBankId2; if (sampleBankReloc.sampleBankId1 != 0xFF) { sampleBankReloc.sampleBankId1 = diff --git a/src/code/audio/audio_playback.c b/src/code/audio/audio_playback.c index a7cc9a5880..07315d56e0 100644 --- a/src/code/audio/audio_playback.c +++ b/src/code/audio/audio_playback.c @@ -35,7 +35,7 @@ void AudioPlayback_InitSampleState(Note* note, NoteSampleState* sampleState, Not sampleState->bitField0.strongLeft = false; sampleState->bitField0.strongReverbRight = stereoData.strongReverbRight; sampleState->bitField0.strongReverbLeft = stereoData.strongReverbLeft; - if (stereoHeadsetEffects && (gAudioContext.soundMode == SOUNDMODE_HEADSET)) { + if (stereoHeadsetEffects && (gAudioCtx.soundMode == SOUNDMODE_HEADSET)) { halfPanIndex = pan >> 1; if (halfPanIndex > 0x3F) { halfPanIndex = 0x3F; @@ -47,7 +47,7 @@ void AudioPlayback_InitSampleState(Note* note, NoteSampleState* sampleState, Not volLeft = gHeadsetPanVolume[pan]; volRight = gHeadsetPanVolume[0x7F - pan]; - } else if (stereoHeadsetEffects && (gAudioContext.soundMode == SOUNDMODE_STEREO)) { + } else if (stereoHeadsetEffects && (gAudioCtx.soundMode == SOUNDMODE_STEREO)) { strongLeft = strongRight = false; sampleState->haasEffectLeftDelaySize = 0; sampleState->haasEffectRightDelaySize = 0; @@ -85,7 +85,7 @@ void AudioPlayback_InitSampleState(Note* note, NoteSampleState* sampleState, Not break; } - } else if (gAudioContext.soundMode == SOUNDMODE_MONO) { + } else if (gAudioCtx.soundMode == SOUNDMODE_MONO) { sampleState->bitField0.strongReverbRight = false; sampleState->bitField0.strongReverbLeft = false; volLeft = 0.707f; // approx 1/sqrt(2) @@ -170,9 +170,9 @@ void AudioPlayback_ProcessNotes(void) { f32 scale; s32 i; - for (i = 0; i < gAudioContext.numNotes; i++) { - note = &gAudioContext.notes[i]; - sampleState = &gAudioContext.sampleStateList[gAudioContext.sampleStateOffset + i]; + for (i = 0; i < gAudioCtx.numNotes; i++) { + note = &gAudioCtx.notes[i]; + sampleState = &gAudioCtx.sampleStateList[gAudioCtx.sampleStateOffset + i]; playbackState = ¬e->playbackState; if (playbackState->parentLayer != NO_LAYER) { if ((u32)playbackState->parentLayer < 0x7FFFFFFF) { @@ -181,7 +181,7 @@ void AudioPlayback_ProcessNotes(void) { if ((note != playbackState->parentLayer->note) && (playbackState->status == PLAYBACK_STATUS_0)) { playbackState->adsr.action.s.release = true; - playbackState->adsr.fadeOutVel = gAudioContext.audioBufferParameters.updatesPerFrameInv; + playbackState->adsr.fadeOutVel = gAudioCtx.audioBufferParameters.updatesPerFrameInv; playbackState->priority = 1; playbackState->status = PLAYBACK_STATUS_2; goto out; @@ -316,7 +316,7 @@ void AudioPlayback_ProcessNotes(void) { } subAttrs.frequency *= playbackState->vibratoFreqScale * playbackState->portamentoFreqScale; - subAttrs.frequency *= gAudioContext.audioBufferParameters.resampleRate; + subAttrs.frequency *= gAudioCtx.audioBufferParameters.resampleRate; subAttrs.velocity *= scale; AudioPlayback_InitSampleState(note, sampleState, &subAttrs); noteSampleState->bitField1.bookOffset = bookOffset; @@ -347,18 +347,18 @@ Instrument* AudioPlayback_GetInstrumentInner(s32 fontId, s32 instId) { } if (!AudioLoad_IsFontLoadComplete(fontId)) { - gAudioContext.audioErrorFlags = AUDIO_ERROR(0, fontId, AUDIO_ERROR_FONT_NOT_LOADED); + gAudioCtx.audioErrorFlags = AUDIO_ERROR(0, fontId, AUDIO_ERROR_FONT_NOT_LOADED); return NULL; } - if (instId >= gAudioContext.soundFontList[fontId].numInstruments) { - gAudioContext.audioErrorFlags = AUDIO_ERROR(fontId, instId, AUDIO_ERROR_INVALID_INST_ID); + if (instId >= gAudioCtx.soundFontList[fontId].numInstruments) { + gAudioCtx.audioErrorFlags = AUDIO_ERROR(fontId, instId, AUDIO_ERROR_INVALID_INST_ID); return NULL; } - inst = gAudioContext.soundFontList[fontId].instruments[instId]; + inst = gAudioCtx.soundFontList[fontId].instruments[instId]; if (inst == NULL) { - gAudioContext.audioErrorFlags = AUDIO_ERROR(fontId, instId, AUDIO_ERROR_NO_INST); + gAudioCtx.audioErrorFlags = AUDIO_ERROR(fontId, instId, AUDIO_ERROR_NO_INST); return inst; } @@ -373,21 +373,21 @@ Drum* AudioPlayback_GetDrum(s32 fontId, s32 drumId) { } if (!AudioLoad_IsFontLoadComplete(fontId)) { - gAudioContext.audioErrorFlags = AUDIO_ERROR(0, fontId, AUDIO_ERROR_FONT_NOT_LOADED); + gAudioCtx.audioErrorFlags = AUDIO_ERROR(0, fontId, AUDIO_ERROR_FONT_NOT_LOADED); return NULL; } - if (drumId >= gAudioContext.soundFontList[fontId].numDrums) { - gAudioContext.audioErrorFlags = AUDIO_ERROR(fontId, drumId, AUDIO_ERROR_INVALID_DRUM_SFX_ID); + if (drumId >= gAudioCtx.soundFontList[fontId].numDrums) { + gAudioCtx.audioErrorFlags = AUDIO_ERROR(fontId, drumId, AUDIO_ERROR_INVALID_DRUM_SFX_ID); return NULL; } - if ((u32)gAudioContext.soundFontList[fontId].drums < AUDIO_RELOCATED_ADDRESS_START) { + if ((u32)gAudioCtx.soundFontList[fontId].drums < AUDIO_RELOCATED_ADDRESS_START) { return NULL; } - drum = gAudioContext.soundFontList[fontId].drums[drumId]; + drum = gAudioCtx.soundFontList[fontId].drums[drumId]; if (drum == NULL) { - gAudioContext.audioErrorFlags = AUDIO_ERROR(fontId, drumId, AUDIO_ERROR_NO_DRUM_SFX); + gAudioCtx.audioErrorFlags = AUDIO_ERROR(fontId, drumId, AUDIO_ERROR_NO_DRUM_SFX); } return drum; @@ -401,23 +401,23 @@ SoundEffect* AudioPlayback_GetSoundEffect(s32 fontId, s32 sfxId) { } if (!AudioLoad_IsFontLoadComplete(fontId)) { - gAudioContext.audioErrorFlags = AUDIO_ERROR(0, fontId, AUDIO_ERROR_FONT_NOT_LOADED); + gAudioCtx.audioErrorFlags = AUDIO_ERROR(0, fontId, AUDIO_ERROR_FONT_NOT_LOADED); return NULL; } - if (sfxId >= gAudioContext.soundFontList[fontId].numSfx) { - gAudioContext.audioErrorFlags = AUDIO_ERROR(fontId, sfxId, AUDIO_ERROR_INVALID_DRUM_SFX_ID); + if (sfxId >= gAudioCtx.soundFontList[fontId].numSfx) { + gAudioCtx.audioErrorFlags = AUDIO_ERROR(fontId, sfxId, AUDIO_ERROR_INVALID_DRUM_SFX_ID); return NULL; } - if ((u32)gAudioContext.soundFontList[fontId].soundEffects < AUDIO_RELOCATED_ADDRESS_START) { + if ((u32)gAudioCtx.soundFontList[fontId].soundEffects < AUDIO_RELOCATED_ADDRESS_START) { return NULL; } - soundEffect = &gAudioContext.soundFontList[fontId].soundEffects[sfxId]; + soundEffect = &gAudioCtx.soundFontList[fontId].soundEffects[sfxId]; if (soundEffect == NULL) { - gAudioContext.audioErrorFlags = AUDIO_ERROR(fontId, sfxId, AUDIO_ERROR_NO_DRUM_SFX); + gAudioCtx.audioErrorFlags = AUDIO_ERROR(fontId, sfxId, AUDIO_ERROR_NO_DRUM_SFX); } if (soundEffect->tunedSample.sample == NULL) { @@ -438,24 +438,24 @@ s32 AudioPlayback_SetFontInstrument(s32 instrumentType, s32 fontId, s32 index, v switch (instrumentType) { case 0: - if (index >= gAudioContext.soundFontList[fontId].numDrums) { + if (index >= gAudioCtx.soundFontList[fontId].numDrums) { return -3; } - gAudioContext.soundFontList[fontId].drums[index] = value; + gAudioCtx.soundFontList[fontId].drums[index] = value; break; case 1: - if (index >= gAudioContext.soundFontList[fontId].numSfx) { + if (index >= gAudioCtx.soundFontList[fontId].numSfx) { return -3; } - gAudioContext.soundFontList[fontId].soundEffects[index] = *(SoundEffect*)value; + gAudioCtx.soundFontList[fontId].soundEffects[index] = *(SoundEffect*)value; break; default: - if (index >= gAudioContext.soundFontList[fontId].numInstruments) { + if (index >= gAudioCtx.soundFontList[fontId].numInstruments) { return -3; } - gAudioContext.soundFontList[fontId].instruments[index] = value; + gAudioCtx.soundFontList[fontId].instruments[index] = value; break; } @@ -488,7 +488,7 @@ void AudioPlayback_SeqLayerDecayRelease(SequenceLayer* layer, s32 target) { if (note->playbackState.parentLayer != layer) { if (note->playbackState.parentLayer == NO_LAYER && note->playbackState.wantedParentLayer == NO_LAYER && note->playbackState.prevParentLayer == layer && target != ADSR_STATE_DECAY) { - note->playbackState.adsr.fadeOutVel = gAudioContext.audioBufferParameters.updatesPerFrameInv; + note->playbackState.adsr.fadeOutVel = gAudioCtx.audioBufferParameters.updatesPerFrameInv; note->playbackState.adsr.action.s.release = true; } return; @@ -549,16 +549,16 @@ void AudioPlayback_SeqLayerDecayRelease(SequenceLayer* layer, s32 target) { note->playbackState.prevParentLayer = note->playbackState.parentLayer; note->playbackState.parentLayer = NO_LAYER; if (target == ADSR_STATE_RELEASE) { - note->playbackState.adsr.fadeOutVel = gAudioContext.audioBufferParameters.updatesPerFrameInv; + note->playbackState.adsr.fadeOutVel = gAudioCtx.audioBufferParameters.updatesPerFrameInv; note->playbackState.adsr.action.s.release = true; note->playbackState.status = PLAYBACK_STATUS_2; } else { note->playbackState.status = PLAYBACK_STATUS_1; note->playbackState.adsr.action.s.decay = true; if (layer->adsr.decayIndex == 0) { - note->playbackState.adsr.fadeOutVel = gAudioContext.adsrDecayTable[layer->channel->adsr.decayIndex]; + note->playbackState.adsr.fadeOutVel = gAudioCtx.adsrDecayTable[layer->channel->adsr.decayIndex]; } else { - note->playbackState.adsr.fadeOutVel = gAudioContext.adsrDecayTable[layer->adsr.decayIndex]; + note->playbackState.adsr.fadeOutVel = gAudioCtx.adsrDecayTable[layer->adsr.decayIndex]; } note->playbackState.adsr.sustain = ((f32)(s32)(layer->channel->adsr.sustain) * note->playbackState.adsr.current) / 256.0f; @@ -665,11 +665,11 @@ void AudioPlayback_InitNoteLists(NotePool* pool) { void AudioPlayback_InitNoteFreeList(void) { s32 i; - AudioPlayback_InitNoteLists(&gAudioContext.noteFreeLists); - for (i = 0; i < gAudioContext.numNotes; i++) { - gAudioContext.notes[i].listItem.u.value = &gAudioContext.notes[i]; - gAudioContext.notes[i].listItem.prev = NULL; - AudioSeq_AudioListPushBack(&gAudioContext.noteFreeLists.disabled, &gAudioContext.notes[i].listItem); + AudioPlayback_InitNoteLists(&gAudioCtx.noteFreeLists); + for (i = 0; i < gAudioCtx.numNotes; i++) { + gAudioCtx.notes[i].listItem.u.value = &gAudioCtx.notes[i]; + gAudioCtx.notes[i].listItem.prev = NULL; + AudioSeq_AudioListPushBack(&gAudioCtx.noteFreeLists.disabled, &gAudioCtx.notes[i].listItem); } } @@ -683,22 +683,22 @@ void AudioPlayback_NotePoolClear(NotePool* pool) { switch (i) { case 0: source = &pool->disabled; - dest = &gAudioContext.noteFreeLists.disabled; + dest = &gAudioCtx.noteFreeLists.disabled; break; case 1: source = &pool->decaying; - dest = &gAudioContext.noteFreeLists.decaying; + dest = &gAudioCtx.noteFreeLists.decaying; break; case 2: source = &pool->releasing; - dest = &gAudioContext.noteFreeLists.releasing; + dest = &gAudioCtx.noteFreeLists.releasing; break; case 3: source = &pool->active; - dest = &gAudioContext.noteFreeLists.active; + dest = &gAudioCtx.noteFreeLists.active; break; } @@ -729,22 +729,22 @@ void AudioPlayback_NotePoolFill(NotePool* pool, s32 count) { switch (i) { case 0: - source = &gAudioContext.noteFreeLists.disabled; + source = &gAudioCtx.noteFreeLists.disabled; dest = &pool->disabled; break; case 1: - source = &gAudioContext.noteFreeLists.decaying; + source = &gAudioCtx.noteFreeLists.decaying; dest = &pool->decaying; break; case 2: - source = &gAudioContext.noteFreeLists.releasing; + source = &gAudioCtx.noteFreeLists.releasing; dest = &pool->releasing; break; case 3: - source = &gAudioContext.noteFreeLists.active; + source = &gAudioCtx.noteFreeLists.active; dest = &pool->active; break; } @@ -862,7 +862,7 @@ void AudioPlayback_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.fadeOutVel = gAudioCtx.audioBufferParameters.updatesPerFrameInv; note->playbackState.adsr.action.s.release = true; } @@ -958,9 +958,9 @@ Note* AudioPlayback_AllocNote(SequenceLayer* layer) { } if (policy & 8) { - if (!(note = AudioPlayback_AllocNoteFromDisabled(&gAudioContext.noteFreeLists, layer)) && - !(note = AudioPlayback_AllocNoteFromDecaying(&gAudioContext.noteFreeLists, layer)) && - !(note = AudioPlayback_AllocNoteFromActive(&gAudioContext.noteFreeLists, layer))) { + if (!(note = AudioPlayback_AllocNoteFromDisabled(&gAudioCtx.noteFreeLists, layer)) && + !(note = AudioPlayback_AllocNoteFromDecaying(&gAudioCtx.noteFreeLists, layer)) && + !(note = AudioPlayback_AllocNoteFromActive(&gAudioCtx.noteFreeLists, layer))) { goto null_return; } return note; @@ -968,13 +968,13 @@ Note* AudioPlayback_AllocNote(SequenceLayer* layer) { if (!(note = AudioPlayback_AllocNoteFromDisabled(&layer->channel->notePool, layer)) && !(note = AudioPlayback_AllocNoteFromDisabled(&layer->channel->seqPlayer->notePool, layer)) && - !(note = AudioPlayback_AllocNoteFromDisabled(&gAudioContext.noteFreeLists, layer)) && + !(note = AudioPlayback_AllocNoteFromDisabled(&gAudioCtx.noteFreeLists, layer)) && !(note = AudioPlayback_AllocNoteFromDecaying(&layer->channel->notePool, layer)) && !(note = AudioPlayback_AllocNoteFromDecaying(&layer->channel->seqPlayer->notePool, layer)) && - !(note = AudioPlayback_AllocNoteFromDecaying(&gAudioContext.noteFreeLists, layer)) && + !(note = AudioPlayback_AllocNoteFromDecaying(&gAudioCtx.noteFreeLists, layer)) && !(note = AudioPlayback_AllocNoteFromActive(&layer->channel->notePool, layer)) && !(note = AudioPlayback_AllocNoteFromActive(&layer->channel->seqPlayer->notePool, layer)) && - !(note = AudioPlayback_AllocNoteFromActive(&gAudioContext.noteFreeLists, layer))) { + !(note = AudioPlayback_AllocNoteFromActive(&gAudioCtx.noteFreeLists, layer))) { goto null_return; } return note; @@ -988,8 +988,8 @@ void AudioPlayback_NoteInitAll(void) { Note* note; s32 i; - for (i = 0; i < gAudioContext.numNotes; i++) { - note = &gAudioContext.notes[i]; + for (i = 0; i < gAudioCtx.numNotes; i++) { + note = &gAudioCtx.notes[i]; note->sampleState = gZeroedSampleState; note->playbackState.priority = 0; note->playbackState.status = PLAYBACK_STATUS_0; @@ -1006,7 +1006,7 @@ void AudioPlayback_NoteInitAll(void) { note->playbackState.stereoHeadsetEffects = false; note->playbackState.startSamplePos = 0; note->synthesisState.synthesisBuffers = - AudioHeap_AllocDmaMemory(&gAudioContext.miscPool, sizeof(NoteSynthesisBuffers)); - note->playbackState.attributes.filterBuf = AudioHeap_AllocDmaMemory(&gAudioContext.miscPool, FILTER_SIZE); + AudioHeap_AllocDmaMemory(&gAudioCtx.miscPool, sizeof(NoteSynthesisBuffers)); + note->playbackState.attributes.filterBuf = AudioHeap_AllocDmaMemory(&gAudioCtx.miscPool, FILTER_SIZE); } } diff --git a/src/code/audio/audio_seqplayer.c b/src/code/audio/audio_seqplayer.c index bc5115f8f6..099f646fe5 100644 --- a/src/code/audio/audio_seqplayer.c +++ b/src/code/audio/audio_seqplayer.c @@ -269,7 +269,7 @@ s32 AudioSeq_HandleScriptFlowControl(SequencePlayer* seqPlayer, SeqScriptState* void AudioSeq_InitSequenceChannel(SequenceChannel* channel) { s32 i; - if (channel == &gAudioContext.sequenceChannelNone) { + if (channel == &gAudioCtx.sequenceChannelNone) { return; } @@ -330,7 +330,7 @@ s32 AudioSeq_SeqChannelSetLayer(SequenceChannel* channel, s32 layerIndex) { s32 pad; if (channel->layers[layerIndex] == NULL) { - layer = AudioSeq_AudioListPopBack(&gAudioContext.layerFreeList); + layer = AudioSeq_AudioListPopBack(&gAudioCtx.layerFreeList); channel->layers[layerIndex] = layer; if (layer == NULL) { channel->layers[layerIndex] = NULL; @@ -384,7 +384,7 @@ s32 AudioSeq_SeqChannelSetLayer(SequenceChannel* channel, s32 layerIndex) { void AudioSeq_SeqLayerDisable(SequenceLayer* layer) { if (layer != NULL) { - if ((layer->channel != &gAudioContext.sequenceChannelNone) && (layer->channel->seqPlayer->finished == true)) { + if ((layer->channel != &gAudioCtx.sequenceChannelNone) && (layer->channel->seqPlayer->finished == true)) { AudioPlayback_SeqLayerNoteRelease(layer); } else { AudioPlayback_SeqLayerNoteDecay(layer); @@ -398,7 +398,7 @@ void AudioSeq_SeqLayerFree(SequenceChannel* channel, s32 layerIndex) { SequenceLayer* layer = channel->layers[layerIndex]; if (layer != NULL) { - AudioSeq_AudioListPushBack(&gAudioContext.layerFreeList, &layer->listItem); + AudioSeq_AudioListPushBack(&gAudioCtx.layerFreeList, &layer->listItem); AudioSeq_SeqLayerDisable(layer); channel->layers[layerIndex] = NULL; } @@ -484,10 +484,10 @@ void AudioSeq_SequencePlayerDisable(SequencePlayer* seqPlayer) { AudioLoad_SetFontLoadStatus(seqPlayer->defaultFont, LOAD_STATUS_MAYBE_DISCARDABLE); } - if (seqPlayer->defaultFont == gAudioContext.fontCache.temporary.entries[0].id) { - gAudioContext.fontCache.temporary.nextSide = 1; - } else if (seqPlayer->defaultFont == gAudioContext.fontCache.temporary.entries[1].id) { - gAudioContext.fontCache.temporary.nextSide = 0; + if (seqPlayer->defaultFont == gAudioCtx.fontCache.temporary.entries[0].id) { + gAudioCtx.fontCache.temporary.nextSide = 1; + } else if (seqPlayer->defaultFont == gAudioCtx.fontCache.temporary.entries[1].id) { + gAudioCtx.fontCache.temporary.nextSide = 0; } } @@ -520,15 +520,15 @@ void* AudioSeq_AudioListPopBack(AudioListItem* list) { void AudioSeq_InitLayerFreelist(void) { s32 i; - gAudioContext.layerFreeList.prev = &gAudioContext.layerFreeList; - gAudioContext.layerFreeList.next = &gAudioContext.layerFreeList; - gAudioContext.layerFreeList.u.count = 0; - gAudioContext.layerFreeList.pool = NULL; + gAudioCtx.layerFreeList.prev = &gAudioCtx.layerFreeList; + gAudioCtx.layerFreeList.next = &gAudioCtx.layerFreeList; + gAudioCtx.layerFreeList.u.count = 0; + gAudioCtx.layerFreeList.pool = NULL; - for (i = 0; i < ARRAY_COUNT(gAudioContext.sequenceLayers); i++) { - gAudioContext.sequenceLayers[i].listItem.u.value = &gAudioContext.sequenceLayers[i]; - gAudioContext.sequenceLayers[i].listItem.prev = NULL; - AudioSeq_AudioListPushBack(&gAudioContext.layerFreeList, &gAudioContext.sequenceLayers[i].listItem); + for (i = 0; i < ARRAY_COUNT(gAudioCtx.sequenceLayers); i++) { + gAudioCtx.sequenceLayers[i].listItem.u.value = &gAudioCtx.sequenceLayers[i]; + gAudioCtx.sequenceLayers[i].listItem.prev = NULL; + AudioSeq_AudioListPushBack(&gAudioCtx.layerFreeList, &gAudioCtx.sequenceLayers[i].listItem); } } @@ -918,7 +918,7 @@ s32 AudioSeq_SeqLayerProcessScriptStep4(SequenceLayer* layer, s32 cmd) { layer->tunedSample = NULL; tuning = 1.0f; if (instOrWave >= 0xC0) { - layer->tunedSample = &gAudioContext.synthesisReverbs[instOrWave - 0xC0].tunedSample; + layer->tunedSample = &gAudioCtx.synthesisReverbs[instOrWave - 0xC0].tunedSample; } } @@ -948,12 +948,12 @@ s32 AudioSeq_SeqLayerProcessScriptStep4(SequenceLayer* layer, s32 cmd) { portamento->extent = (freqScale2 / freqScale) - 1.0f; if (PORTAMENTO_IS_SPECIAL(*portamento)) { - speed = seqPlayer->tempo * 0x8000 / gAudioContext.tempoInternalToExternal; + speed = seqPlayer->tempo * 0x8000 / gAudioCtx.tempoInternalToExternal; if (layer->delay != 0) { speed = speed * 0x100 / (layer->delay * layer->portamentoTime); } } else { - speed = 0x20000 / (layer->portamentoTime * gAudioContext.audioBufferParameters.updatesPerFrame); + speed = 0x20000 / (layer->portamentoTime * gAudioCtx.audioBufferParameters.updatesPerFrame); } if (speed >= 0x7FFF) { @@ -980,7 +980,7 @@ s32 AudioSeq_SeqLayerProcessScriptStep4(SequenceLayer* layer, s32 cmd) { layer->tunedSample = NULL; layer->freqScale = gPitchFrequencies[semitone2]; if (instOrWave >= 0xC0) { - layer->tunedSample = &gAudioContext.synthesisReverbs[instOrWave - 0xC0].tunedSample; + layer->tunedSample = &gAudioCtx.synthesisReverbs[instOrWave - 0xC0].tunedSample; } } break; @@ -996,7 +996,7 @@ s32 AudioSeq_SeqLayerProcessScriptStep4(SequenceLayer* layer, s32 cmd) { time = 0.0f; } time *= seqPlayer->tempo; - time *= gAudioContext.unk_2870; + time *= gAudioCtx.unk_2870; time /= layer->freqScale; //! FAKE: if (1) {} @@ -1011,7 +1011,7 @@ s32 AudioSeq_SeqLayerProcessScriptStep4(SequenceLayer* layer, s32 cmd) { // (It's a bit unclear if 'portamento' has actually always been // set when this is reached...) if (PORTAMENTO_IS_SPECIAL(*portamento)) { - speed2 = seqPlayer->tempo * 0x8000 / gAudioContext.tempoInternalToExternal; + speed2 = seqPlayer->tempo * 0x8000 / gAudioCtx.tempoInternalToExternal; speed2 = speed2 * 0x100 / (layer->delay * layer->portamentoTime); if (speed2 >= 0x7FFF) { speed2 = 0x7FFF; @@ -1090,8 +1090,8 @@ s32 AudioSeq_SeqLayerProcessScriptStep3(SequenceLayer* layer, s32 cmd) { } if (channel->velocityRandomVariance != 0) { - floatDelta = layer->velocitySquare * (gAudioContext.audioRandom % channel->velocityRandomVariance) / 100.0f; - if ((gAudioContext.audioRandom & 0x8000) != 0) { + floatDelta = layer->velocitySquare * (gAudioCtx.audioRandom % channel->velocityRandomVariance) / 100.0f; + if ((gAudioCtx.audioRandom & 0x8000) != 0) { floatDelta = -floatDelta; } @@ -1111,8 +1111,8 @@ s32 AudioSeq_SeqLayerProcessScriptStep3(SequenceLayer* layer, s32 cmd) { if (channel->gateTimeRandomVariance != 0) { //! @bug should probably be gateTimeRandomVariance - intDelta = (layer->gateDelay * (gAudioContext.audioRandom % channel->velocityRandomVariance)) / 100; - if ((gAudioContext.audioRandom & 0x4000) != 0) { + intDelta = (layer->gateDelay * (gAudioCtx.audioRandom % channel->velocityRandomVariance)) / 100; + if ((gAudioCtx.audioRandom & 0x4000) != 0) { intDelta = -intDelta; } @@ -1297,9 +1297,9 @@ void AudioSeq_SequenceChannelProcessScript(SequenceChannel* channel) { cmd = (u8)cmdArgs[0]; if (seqPlayer->defaultFont != 0xFF) { - cmdArgU16 = ((u16*)gAudioContext.sequenceFontTable)[seqPlayer->seqId]; - lowBits = gAudioContext.sequenceFontTable[cmdArgU16]; - cmd = gAudioContext.sequenceFontTable[cmdArgU16 + lowBits - cmd]; + cmdArgU16 = ((u16*)gAudioCtx.sequenceFontTable)[seqPlayer->seqId]; + lowBits = gAudioCtx.sequenceFontTable[cmdArgU16]; + cmd = gAudioCtx.sequenceFontTable[cmdArgU16 + lowBits - cmd]; } if (AudioHeap_SearchCaches(FONT_TABLE, CACHE_EITHER, cmd)) { @@ -1426,9 +1426,9 @@ void AudioSeq_SequenceChannelProcessScript(SequenceChannel* channel) { cmd = (u8)cmdArgs[0]; if (seqPlayer->defaultFont != 0xFF) { - cmdArgU16 = ((u16*)gAudioContext.sequenceFontTable)[seqPlayer->seqId]; - lowBits = gAudioContext.sequenceFontTable[cmdArgU16]; - cmd = gAudioContext.sequenceFontTable[cmdArgU16 + lowBits - cmd]; + cmdArgU16 = ((u16*)gAudioCtx.sequenceFontTable)[seqPlayer->seqId]; + lowBits = gAudioCtx.sequenceFontTable[cmdArgU16]; + cmd = gAudioCtx.sequenceFontTable[cmdArgU16 + lowBits - cmd]; } if (AudioHeap_SearchCaches(FONT_TABLE, CACHE_EITHER, cmd)) { @@ -1625,13 +1625,13 @@ void AudioSeq_SequenceChannelProcessScript(SequenceChannel* channel) { break; case 0xB7: // channel: random large - channel->unk_22 = (cmdArgs[0] == 0) ? (gAudioContext.audioRandom & 0xFFFF) - : (gAudioContext.audioRandom % cmdArgs[0]); + channel->unk_22 = + (cmdArgs[0] == 0) ? (gAudioCtx.audioRandom & 0xFFFF) : (gAudioCtx.audioRandom % cmdArgs[0]); break; case 0xB8: // channel: random value - scriptState->value = (cmdArgs[0] == 0) ? (gAudioContext.audioRandom & 0xFFFF) - : (gAudioContext.audioRandom % cmdArgs[0]); + scriptState->value = + (cmdArgs[0] == 0) ? (gAudioCtx.audioRandom & 0xFFFF) : (gAudioCtx.audioRandom % cmdArgs[0]); break; case 0xA8: // channel: random range large (only cmd that differs from OoT) @@ -1667,8 +1667,8 @@ void AudioSeq_SequenceChannelProcessScript(SequenceChannel* channel) { case 0xBE: // channel: if (cmdArgs[0] < 5) { if (1) {} - if (gAudioContext.unk_29A8[cmdArgs[0]] != NULL) { - gCustomAudioSeqFunction = gAudioContext.unk_29A8[cmdArgs[0]]; + if (gAudioCtx.unk_29A8[cmdArgs[0]] != NULL) { + gCustomAudioSeqFunction = gAudioCtx.unk_29A8[cmdArgs[0]]; scriptState->value = gCustomAudioSeqFunction(scriptState->value, channel); } } @@ -1880,17 +1880,17 @@ void AudioSeq_SequencePlayerProcessSequence(SequencePlayer* seqPlayer) { seqPlayer->scriptCounter++; tempoChange = seqPlayer->tempo + seqPlayer->unk_0C; - if (tempoChange > gAudioContext.tempoInternalToExternal) { - tempoChange = gAudioContext.tempoInternalToExternal; + if (tempoChange > gAudioCtx.tempoInternalToExternal) { + tempoChange = gAudioCtx.tempoInternalToExternal; } seqPlayer->tempoAcc += tempoChange; - if (seqPlayer->tempoAcc < gAudioContext.tempoInternalToExternal) { + if (seqPlayer->tempoAcc < gAudioCtx.tempoInternalToExternal) { return; } - seqPlayer->tempoAcc -= (u16)gAudioContext.tempoInternalToExternal; + seqPlayer->tempoAcc -= (u16)gAudioCtx.tempoInternalToExternal; seqPlayer->unk_16++; if (seqPlayer->stopScript == true) { @@ -1943,8 +1943,8 @@ void AudioSeq_SequencePlayerProcessSequence(SequencePlayer* seqPlayer) { case 0xDD: // seqPlayer: set tempo seqPlayer->tempo = AudioSeq_ScriptReadU8(seqScript) * TATUMS_PER_BEAT; - if (seqPlayer->tempo > gAudioContext.tempoInternalToExternal) { - seqPlayer->tempo = gAudioContext.tempoInternalToExternal; + if (seqPlayer->tempo > gAudioCtx.tempoInternalToExternal) { + seqPlayer->tempo = gAudioCtx.tempoInternalToExternal; } if ((s16)seqPlayer->tempo <= 0) { @@ -2041,9 +2041,9 @@ void AudioSeq_SequencePlayerProcessSequence(SequencePlayer* seqPlayer) { case 0xCE: // seqPlayer: random value cmd = AudioSeq_ScriptReadU8(seqScript); if (cmd == 0) { - seqScript->value = (gAudioContext.audioRandom >> 2) & 0xFF; + seqScript->value = (gAudioCtx.audioRandom >> 2) & 0xFF; } else { - seqScript->value = (gAudioContext.audioRandom >> 2) % cmd; + seqScript->value = (gAudioCtx.audioRandom >> 2) % cmd; } break; @@ -2198,11 +2198,10 @@ void AudioSeq_ProcessSequences(s32 arg0) { SequencePlayer* seqPlayer; u32 i; - gAudioContext.sampleStateOffset = - (gAudioContext.audioBufferParameters.updatesPerFrame - arg0 - 1) * gAudioContext.numNotes; + gAudioCtx.sampleStateOffset = (gAudioCtx.audioBufferParameters.updatesPerFrame - arg0 - 1) * gAudioCtx.numNotes; - for (i = 0; i < (u32)gAudioContext.audioBufferParameters.numSequencePlayers; i++) { - seqPlayer = &gAudioContext.seqPlayers[i]; + for (i = 0; i < (u32)gAudioCtx.audioBufferParameters.numSequencePlayers; i++) { + seqPlayer = &gAudioCtx.seqPlayers[i]; if (seqPlayer->enabled == true) { AudioSeq_SequencePlayerProcessSequence(seqPlayer); AudioEffects_SequencePlayerProcessSound(seqPlayer); @@ -2250,14 +2249,14 @@ void AudioSeq_ResetSequencePlayer(SequencePlayer* seqPlayer) { void AudioSeq_InitSequencePlayerChannels(s32 playerIndex) { SequenceChannel* channel; - SequencePlayer* seqPlayer = &gAudioContext.seqPlayers[playerIndex]; + SequencePlayer* seqPlayer = &gAudioCtx.seqPlayers[playerIndex]; s32 i; s32 j; for (i = 0; i < SEQ_NUM_CHANNELS; i++) { - seqPlayer->channels[i] = AudioHeap_AllocZeroed(&gAudioContext.miscPool, sizeof(SequenceChannel)); + seqPlayer->channels[i] = AudioHeap_AllocZeroed(&gAudioCtx.miscPool, sizeof(SequenceChannel)); if (seqPlayer->channels[i] == NULL) { - seqPlayer->channels[i] = &gAudioContext.sequenceChannelNone; + seqPlayer->channels[i] = &gAudioCtx.sequenceChannelNone; } else { channel = seqPlayer->channels[i]; channel->seqPlayer = seqPlayer; @@ -2277,7 +2276,7 @@ void AudioSeq_InitSequencePlayer(SequencePlayer* seqPlayer) { s32 j; for (i = 0; i < SEQ_NUM_CHANNELS; i++) { - seqPlayer->channels[i] = &gAudioContext.sequenceChannelNone; + seqPlayer->channels[i] = &gAudioCtx.sequenceChannelNone; } seqPlayer->enabled = false; @@ -2303,12 +2302,12 @@ void AudioSeq_InitSequencePlayers(void) { AudioSeq_InitLayerFreelist(); - for (i = 0; i < ARRAY_COUNT(gAudioContext.sequenceLayers); i++) { - gAudioContext.sequenceLayers[i].channel = NULL; - gAudioContext.sequenceLayers[i].enabled = false; + for (i = 0; i < ARRAY_COUNT(gAudioCtx.sequenceLayers); i++) { + gAudioCtx.sequenceLayers[i].channel = NULL; + gAudioCtx.sequenceLayers[i].enabled = false; } - for (i = 0; i < ARRAY_COUNT(gAudioContext.seqPlayers); i++) { - AudioSeq_InitSequencePlayer(&gAudioContext.seqPlayers[i]); + for (i = 0; i < ARRAY_COUNT(gAudioCtx.seqPlayers); i++) { + AudioSeq_InitSequencePlayer(&gAudioCtx.seqPlayers[i]); } } diff --git a/src/code/audio/audio_synthesis.c b/src/code/audio/audio_synthesis.c index d3b25f4461..5c72c44528 100644 --- a/src/code/audio/audio_synthesis.c +++ b/src/code/audio/audio_synthesis.c @@ -80,13 +80,13 @@ void AudioSynth_AddReverbBufferEntry(s32 numSamples, s32 updateIndex, s32 reverb s32 count2; s32 nextReverbSubBufPos; - reverb = &gAudioContext.synthesisReverbs[reverbIndex]; + reverb = &gAudioCtx.synthesisReverbs[reverbIndex]; entry = &reverb->bufEntry[reverb->curFrame][updateIndex]; - numSamplesAfterDownsampling = numSamples / gAudioContext.synthesisReverbs[reverbIndex].downsampleRate; + numSamplesAfterDownsampling = numSamples / gAudioCtx.synthesisReverbs[reverbIndex].downsampleRate; // Apply resampling effect - if (gAudioContext.synthesisReverbs[reverbIndex].resampleEffectOn) { + if (gAudioCtx.synthesisReverbs[reverbIndex].resampleEffectOn) { if (reverb->downsampleRate == 1) { count1 = 0; count2 = 0; @@ -199,10 +199,10 @@ void AudioSynth_SyncSampleStates(s32 updateIndex) { s32 sampleStateBaseIndex; s32 i; - sampleStateBaseIndex = gAudioContext.numNotes * updateIndex; - for (i = 0; i < gAudioContext.numNotes; i++) { - noteSampleState = &gAudioContext.notes[i].sampleState; - sampleState = &gAudioContext.sampleStateList[sampleStateBaseIndex + i]; + sampleStateBaseIndex = gAudioCtx.numNotes * updateIndex; + for (i = 0; i < gAudioCtx.numNotes; i++) { + noteSampleState = &gAudioCtx.notes[i].sampleState; + sampleState = &gAudioCtx.sampleStateList[sampleStateBaseIndex + i]; if (noteSampleState->bitField0.enabled) { noteSampleState->bitField0.needsInit = false; } else { @@ -221,51 +221,51 @@ Acmd* AudioSynth_Update(Acmd* abiCmdStart, s32* numAbiCmds, s16* aiBufStart, s32 s32 reverbIndex; SynthesisReverb* reverb; - for (reverseUpdateIndex = gAudioContext.audioBufferParameters.updatesPerFrame; reverseUpdateIndex > 0; + for (reverseUpdateIndex = gAudioCtx.audioBufferParameters.updatesPerFrame; reverseUpdateIndex > 0; reverseUpdateIndex--) { AudioSeq_ProcessSequences(reverseUpdateIndex - 1); - AudioSynth_SyncSampleStates(gAudioContext.audioBufferParameters.updatesPerFrame - reverseUpdateIndex); + AudioSynth_SyncSampleStates(gAudioCtx.audioBufferParameters.updatesPerFrame - reverseUpdateIndex); } curAiBufPos = aiBufStart; - gAudioContext.adpcmCodeBook = NULL; + gAudioCtx.adpcmCodeBook = NULL; // Process/Update all samples multiple times in a single frame - for (reverseUpdateIndex = gAudioContext.audioBufferParameters.updatesPerFrame; reverseUpdateIndex > 0; + for (reverseUpdateIndex = gAudioCtx.audioBufferParameters.updatesPerFrame; reverseUpdateIndex > 0; reverseUpdateIndex--) { if (reverseUpdateIndex == 1) { // Final Update numSamplesPerUpdate = numSamplesPerFrame; } else if ((numSamplesPerFrame / reverseUpdateIndex) >= - gAudioContext.audioBufferParameters.numSamplesPerUpdateMax) { - numSamplesPerUpdate = gAudioContext.audioBufferParameters.numSamplesPerUpdateMax; + gAudioCtx.audioBufferParameters.numSamplesPerUpdateMax) { + numSamplesPerUpdate = gAudioCtx.audioBufferParameters.numSamplesPerUpdateMax; } else if ((numSamplesPerFrame / reverseUpdateIndex) <= - gAudioContext.audioBufferParameters.numSamplesPerUpdateMin) { - numSamplesPerUpdate = gAudioContext.audioBufferParameters.numSamplesPerUpdateMin; + gAudioCtx.audioBufferParameters.numSamplesPerUpdateMin) { + numSamplesPerUpdate = gAudioCtx.audioBufferParameters.numSamplesPerUpdateMin; } else { - numSamplesPerUpdate = gAudioContext.audioBufferParameters.numSamplesPerUpdate; + numSamplesPerUpdate = gAudioCtx.audioBufferParameters.numSamplesPerUpdate; } - for (reverbIndex = 0; reverbIndex < gAudioContext.numSynthesisReverbs; reverbIndex++) { - if (gAudioContext.synthesisReverbs[reverbIndex].useReverb) { - AudioSynth_AddReverbBufferEntry( - numSamplesPerUpdate, gAudioContext.audioBufferParameters.updatesPerFrame - reverseUpdateIndex, - reverbIndex); + for (reverbIndex = 0; reverbIndex < gAudioCtx.numSynthesisReverbs; reverbIndex++) { + if (gAudioCtx.synthesisReverbs[reverbIndex].useReverb) { + AudioSynth_AddReverbBufferEntry(numSamplesPerUpdate, + gAudioCtx.audioBufferParameters.updatesPerFrame - reverseUpdateIndex, + reverbIndex); } } curCmd = AudioSynth_ProcessSamples(curAiBufPos, numSamplesPerUpdate, curCmd, - gAudioContext.audioBufferParameters.updatesPerFrame - reverseUpdateIndex); + gAudioCtx.audioBufferParameters.updatesPerFrame - reverseUpdateIndex); numSamplesPerFrame -= numSamplesPerUpdate; curAiBufPos += numSamplesPerUpdate * SAMPLE_SIZE; } // Update reverb frame info - for (reverbIndex = 0; reverbIndex < gAudioContext.numSynthesisReverbs; reverbIndex++) { - if (gAudioContext.synthesisReverbs[reverbIndex].framesToIgnore != 0) { - gAudioContext.synthesisReverbs[reverbIndex].framesToIgnore--; + for (reverbIndex = 0; reverbIndex < gAudioCtx.numSynthesisReverbs; reverbIndex++) { + if (gAudioCtx.synthesisReverbs[reverbIndex].framesToIgnore != 0) { + gAudioCtx.synthesisReverbs[reverbIndex].framesToIgnore--; } - gAudioContext.synthesisReverbs[reverbIndex].curFrame ^= 1; + gAudioCtx.synthesisReverbs[reverbIndex].curFrame ^= 1; } *numAbiCmds = curCmd - abiCmdStart; @@ -276,8 +276,8 @@ void AudioSynth_DisableSampleStates(s32 updateIndex, s32 noteIndex) { NoteSampleState* sampleState; s32 i; - for (i = updateIndex + 1; i < gAudioContext.audioBufferParameters.updatesPerFrame; i++) { - sampleState = &gAudioContext.sampleStateList[(gAudioContext.numNotes * i) + noteIndex]; + for (i = updateIndex + 1; i < gAudioCtx.audioBufferParameters.updatesPerFrame; i++) { + sampleState = &gAudioCtx.sampleStateList[(gAudioCtx.numNotes * i) + noteIndex]; if (sampleState->bitField0.needsInit) { break; } @@ -572,11 +572,11 @@ Acmd* AudioSynth_FilterReverb(Acmd* cmd, s32 size, SynthesisReverb* reverb) { Acmd* AudioSynth_MixOtherReverbIndex(Acmd* cmd, SynthesisReverb* reverb, s32 updateIndex) { SynthesisReverb* mixReverb; - if (reverb->mixReverbIndex >= gAudioContext.numSynthesisReverbs) { + if (reverb->mixReverbIndex >= gAudioCtx.numSynthesisReverbs) { return cmd; } - mixReverb = &gAudioContext.synthesisReverbs[reverb->mixReverbIndex]; + mixReverb = &gAudioCtx.synthesisReverbs[reverb->mixReverbIndex]; if (mixReverb->downsampleRate == 1) { cmd = AudioSynth_LoadMixedReverbSamples(cmd, mixReverb, updateIndex); aMix(cmd++, DMEM_2CH_SIZE >> 4, reverb->mixReverbStrength, DMEM_WET_LEFT_CH, DMEM_WET_TEMP); @@ -758,31 +758,31 @@ Acmd* AudioSynth_ProcessSamples(s16* aiBuf, s32 numSamplesPerUpdate, Acmd* cmd, s16 reverbIndex; SynthesisReverb* reverb; s32 useReverb; - s32 sampleStateOffset = gAudioContext.numNotes * updateIndex; + s32 sampleStateOffset = gAudioCtx.numNotes * updateIndex; s32 i; - if (gAudioContext.numSynthesisReverbs == 0) { - for (i = 0; i < gAudioContext.numNotes; i++) { - if (gAudioContext.sampleStateList[sampleStateOffset + i].bitField0.enabled) { + if (gAudioCtx.numSynthesisReverbs == 0) { + for (i = 0; i < gAudioCtx.numNotes; i++) { + if (gAudioCtx.sampleStateList[sampleStateOffset + i].bitField0.enabled) { noteIndices[noteCount++] = i; } } } else { NoteSampleState* sampleState; - for (reverbIndex = 0; reverbIndex < gAudioContext.numSynthesisReverbs; reverbIndex++) { - for (i = 0; i < gAudioContext.numNotes; i++) { - sampleState = &gAudioContext.sampleStateList[sampleStateOffset + i]; + for (reverbIndex = 0; reverbIndex < gAudioCtx.numSynthesisReverbs; reverbIndex++) { + for (i = 0; i < gAudioCtx.numNotes; i++) { + sampleState = &gAudioCtx.sampleStateList[sampleStateOffset + i]; if (sampleState->bitField0.enabled && (sampleState->bitField1.reverbIndex == reverbIndex)) { noteIndices[noteCount++] = i; } } } - for (i = 0; i < gAudioContext.numNotes; i++) { - sampleState = &gAudioContext.sampleStateList[sampleStateOffset + i]; + for (i = 0; i < gAudioCtx.numNotes; i++) { + sampleState = &gAudioCtx.sampleStateList[sampleStateOffset + i]; if (sampleState->bitField0.enabled && - (sampleState->bitField1.reverbIndex >= gAudioContext.numSynthesisReverbs)) { + (sampleState->bitField1.reverbIndex >= gAudioCtx.numSynthesisReverbs)) { noteIndices[noteCount++] = i; } } @@ -791,11 +791,11 @@ Acmd* AudioSynth_ProcessSamples(s16* aiBuf, s32 numSamplesPerUpdate, Acmd* cmd, aClearBuffer(cmd++, DMEM_LEFT_CH, DMEM_2CH_SIZE); i = 0; - for (reverbIndex = 0; reverbIndex < gAudioContext.numSynthesisReverbs; reverbIndex++) { + for (reverbIndex = 0; reverbIndex < gAudioCtx.numSynthesisReverbs; reverbIndex++) { s32 subDelay; NoteSampleState* sampleState; - reverb = &gAudioContext.synthesisReverbs[reverbIndex]; + reverb = &gAudioCtx.synthesisReverbs[reverbIndex]; useReverb = reverb->useReverb; if (useReverb) { @@ -815,7 +815,7 @@ Acmd* AudioSynth_ProcessSamples(s16* aiBuf, s32 numSamplesPerUpdate, Acmd* cmd, // Decays reverb over time. The (+ 0x8000) here is -100% aMix(cmd++, DMEM_2CH_SIZE >> 4, reverb->decayRatio + 0x8000, DMEM_WET_LEFT_CH, DMEM_WET_LEFT_CH); - if (((reverb->leakRtl != 0) || (reverb->leakLtr != 0)) && (gAudioContext.soundMode != SOUNDMODE_MONO)) { + if (((reverb->leakRtl != 0) || (reverb->leakLtr != 0)) && (gAudioCtx.soundMode != SOUNDMODE_MONO)) { cmd = AudioSynth_LeakReverb(cmd, reverb); } @@ -830,13 +830,12 @@ Acmd* AudioSynth_ProcessSamples(s16* aiBuf, s32 numSamplesPerUpdate, Acmd* cmd, } while (i < noteCount) { - sampleState = &gAudioContext.sampleStateList[sampleStateOffset + noteIndices[i]]; + sampleState = &gAudioCtx.sampleStateList[sampleStateOffset + noteIndices[i]]; if (sampleState->bitField1.reverbIndex != reverbIndex) { break; } - cmd = AudioSynth_ProcessSample(noteIndices[i], sampleState, - &gAudioContext.notes[noteIndices[i]].synthesisState, aiBuf, - numSamplesPerUpdate, cmd, updateIndex); + cmd = AudioSynth_ProcessSample(noteIndices[i], sampleState, &gAudioCtx.notes[noteIndices[i]].synthesisState, + aiBuf, numSamplesPerUpdate, cmd, updateIndex); i++; } @@ -858,9 +857,9 @@ Acmd* AudioSynth_ProcessSamples(s16* aiBuf, s32 numSamplesPerUpdate, Acmd* cmd, } while (i < noteCount) { - cmd = AudioSynth_ProcessSample( - noteIndices[i], &gAudioContext.sampleStateList[sampleStateOffset + noteIndices[i]], - &gAudioContext.notes[noteIndices[i]].synthesisState, aiBuf, numSamplesPerUpdate, cmd, updateIndex); + cmd = AudioSynth_ProcessSample(noteIndices[i], &gAudioCtx.sampleStateList[sampleStateOffset + noteIndices[i]], + &gAudioCtx.notes[noteIndices[i]].synthesisState, aiBuf, numSamplesPerUpdate, cmd, + updateIndex); i++; } @@ -928,7 +927,7 @@ Acmd* AudioSynth_ProcessSample(s32 noteIndex, NoteSampleState* sampleState, Note s32 sampleDataChunkSize; s16 sampleDataDmemAddr; - note = &gAudioContext.notes[noteIndex]; + note = &gAudioCtx.notes[noteIndex]; flags = A_CONTINUE; // Initialize the synthesis state @@ -1013,23 +1012,23 @@ Acmd* AudioSynth_ProcessSample(s32 noteIndex, NoteSampleState* sampleState, Note // Load the ADPCM codeBook if ((sample->codec == CODEC_ADPCM) || (sample->codec == CODEC_SMALL_ADPCM)) { - if (gAudioContext.adpcmCodeBook != sample->book->codeBook) { + if (gAudioCtx.adpcmCodeBook != sample->book->codeBook) { u32 numEntries; switch (bookOffset) { case 1: - gAudioContext.adpcmCodeBook = &gInvalidAdpcmCodeBook[1]; + gAudioCtx.adpcmCodeBook = &gInvalidAdpcmCodeBook[1]; break; case 2: case 3: default: - gAudioContext.adpcmCodeBook = sample->book->codeBook; + gAudioCtx.adpcmCodeBook = sample->book->codeBook; break; } numEntries = SAMPLES_PER_FRAME * sample->book->order * sample->book->numPredictors; - aLoadADPCM(cmd++, numEntries, gAudioContext.adpcmCodeBook); + aLoadADPCM(cmd++, numEntries, gAudioCtx.adpcmCodeBook); } } @@ -1163,7 +1162,7 @@ Acmd* AudioSynth_ProcessSample(s32 noteIndex, NoteSampleState* sampleState, Note if (sample->medium == MEDIUM_RAM) { // Sample is already loaded into ram samplesToLoadAddr = sampleAddr + (zeroOffset + sampleAddrOffset); - } else if (gAudioContext.unk_29B8) { // always false + } else if (gAudioCtx.unk_29B8) { // always false return cmd; } else if (sample->medium == MEDIUM_UNK) { // This medium is unsupported so terminate processing this note @@ -1405,7 +1404,7 @@ Acmd* AudioSynth_ProcessSample(s32 noteIndex, NoteSampleState* sampleState, Note } // Apply an unknown effect based on the surround sound-mode - if (gAudioContext.soundMode == SOUNDMODE_SURROUND) { + if (gAudioCtx.soundMode == SOUNDMODE_SURROUND) { sampleState->targetVolLeft = sampleState->targetVolLeft >> 1; sampleState->targetVolRight = sampleState->targetVolRight >> 1; if (sampleState->surroundEffectIndex != 0xFF) { @@ -1512,7 +1511,7 @@ Acmd* AudioSynth_ProcessEnvelope(Acmd* cmd, NoteSampleState* sampleState, NoteSy targetVolRight = sampleState->targetVolRight; targetVolRight <<= 4; - if ((gAudioContext.soundMode == SOUNDMODE_SURROUND) && (sampleState->surroundEffectIndex != 0xFF)) { + if ((gAudioCtx.soundMode == SOUNDMODE_SURROUND) && (sampleState->surroundEffectIndex != 0xFF)) { defaultPanVolume = gDefaultPanVolume[sampleState->surroundEffectIndex]; targetVolLeft *= defaultPanVolume; targetVolRight *= defaultPanVolume; diff --git a/src/code/audio/code_8019AF00.c b/src/code/audio/code_8019AF00.c index 9df12e7fe9..5fd58a487b 100644 --- a/src/code/audio/code_8019AF00.c +++ b/src/code/audio/code_8019AF00.c @@ -3311,7 +3311,7 @@ s32 AudioOcarina_MemoryGameNextNote(void) { #undef OCARINA_SONG_MEMORY_GAME void AudioOcarina_Update(void) { - sOcarinaUpdateTaskStart = gAudioContext.totalTaskCount; + sOcarinaUpdateTaskStart = gAudioCtx.totalTaskCount; if (sOcarinaInstrumentId != OCARINA_INSTRUMENT_OFF) { if (sIsOcarinaInputEnabled == true) { AudioOcarina_ReadControllerInput(); @@ -3399,9 +3399,9 @@ u8 sRequestCustomSequence = false; void AudioOcarina_SetCustomSequence(void) { // Never passes true as sRequestCustomSequence is never set true - if (sRequestCustomSequence && gAudioContext.seqPlayers[SEQ_PLAYER_FANFARE].enabled && - ((u8)gAudioContext.seqPlayers[SEQ_PLAYER_FANFARE].soundScriptIO[0] == (u8)SEQ_IO_VAL_NONE)) { - gAudioContext.seqPlayers[SEQ_PLAYER_FANFARE].seqData = sCustomSequenceScript; + if (sRequestCustomSequence && gAudioCtx.seqPlayers[SEQ_PLAYER_FANFARE].enabled && + ((u8)gAudioCtx.seqPlayers[SEQ_PLAYER_FANFARE].soundScriptIO[0] == (u8)SEQ_IO_VAL_NONE)) { + gAudioCtx.seqPlayers[SEQ_PLAYER_FANFARE].seqData = sCustomSequenceScript; sRequestCustomSequence = false; } } @@ -3753,9 +3753,9 @@ s8 AudioSfx_ComputeReverb(u8 bankId, u8 entryIndex, u8 channelIndex) { } } - if (IS_SEQUENCE_CHANNEL_VALID(gAudioContext.seqPlayers[SEQ_PLAYER_SFX].channels[channelIndex])) { - scriptAdd = gAudioContext.seqPlayers[SEQ_PLAYER_SFX].channels[channelIndex]->soundScriptIO[1]; - if (gAudioContext.seqPlayers[SEQ_PLAYER_SFX].channels[channelIndex]->soundScriptIO[1] <= SEQ_IO_VAL_NONE) { + if (IS_SEQUENCE_CHANNEL_VALID(gAudioCtx.seqPlayers[SEQ_PLAYER_SFX].channels[channelIndex])) { + scriptAdd = gAudioCtx.seqPlayers[SEQ_PLAYER_SFX].channels[channelIndex]->soundScriptIO[1]; + if (gAudioCtx.seqPlayers[SEQ_PLAYER_SFX].channels[channelIndex]->soundScriptIO[1] <= SEQ_IO_VAL_NONE) { scriptAdd = 0; } } @@ -3815,7 +3815,7 @@ f32 AudioSfx_ComputeFreqScale(u8 bankId, u8 entryIndex) { f32 freq = 1.0f; if (entry->sfxParams & SFX_PARAM_RAND_FREQ_LOWER) { - freq = 1.0f - ((gAudioContext.audioRandom & 0xF) / 192.0f); + freq = 1.0f - ((gAudioCtx.audioRandom & 0xF) / 192.0f); } switch (bankId) { @@ -3850,7 +3850,7 @@ f32 AudioSfx_ComputeFreqScale(u8 bankId, u8 entryIndex) { } if ((applyRandScaling == true) && !(entry->sfxParams & SFX_PARAM_RAND_FREQ_SCALE)) { - freq *= 1.0293 - ((gAudioContext.audioRandom & 0xF) / 144.0f); + freq *= 1.0293 - ((gAudioCtx.audioRandom & 0xF) / 144.0f); } dist = entry->dist; @@ -4356,18 +4356,16 @@ s32 Audio_SetGanonsTowerBgmVolume(u8 targetVolume) { (u8)(lowPassFilterCutoff)); // Sets the reverb - for (channelIndex = 0; channelIndex < ARRAY_COUNT(gAudioContext.seqPlayers[SEQ_PLAYER_BGM_MAIN].channels); + for (channelIndex = 0; channelIndex < ARRAY_COUNT(gAudioCtx.seqPlayers[SEQ_PLAYER_BGM_MAIN].channels); channelIndex++) { - if (&gAudioContext.sequenceChannelNone != - gAudioContext.seqPlayers[SEQ_PLAYER_BGM_MAIN].channels[channelIndex]) { + if (&gAudioCtx.sequenceChannelNone != gAudioCtx.seqPlayers[SEQ_PLAYER_BGM_MAIN].channels[channelIndex]) { // soundScriptIO[5] was set to 0x40 in channels 0, 1, and 4 (BGM no longer in OoT) - if ((u8)gAudioContext.seqPlayers[SEQ_PLAYER_BGM_MAIN].channels[channelIndex]->soundScriptIO[5] != + if ((u8)gAudioCtx.seqPlayers[SEQ_PLAYER_BGM_MAIN].channels[channelIndex]->soundScriptIO[5] != (u8)SEQ_IO_VAL_NONE) { // Higher volume leads to lower reverb - reverb = - (((u16)gAudioContext.seqPlayers[SEQ_PLAYER_BGM_MAIN].channels[channelIndex]->soundScriptIO[5] - - targetVolume) + - 0x7F); + reverb = (((u16)gAudioCtx.seqPlayers[SEQ_PLAYER_BGM_MAIN].channels[channelIndex]->soundScriptIO[5] - + targetVolume) + + 0x7F); if (reverb > 0x7F) { reverb = 0x7F; @@ -4556,7 +4554,7 @@ void Audio_SplitBgmChannels(s8 volumeSplit) { channelBits = 0; for (channelIndex = 0; channelIndex < SEQ_NUM_CHANNELS; channelIndex++) { - if (gAudioContext.seqPlayers[sBgmPlayers[i]].channels[channelIndex]->notePriority < notePriority) { + if (gAudioCtx.seqPlayers[sBgmPlayers[i]].channels[channelIndex]->notePriority < notePriority) { // If the note currently playing in the channel is a high enough priority, // then keep the channel on by setting a channelBit // If this condition fails, then the channel will be shut off @@ -4723,7 +4721,7 @@ void Audio_UpdateSceneSequenceResumePoint(void) { if ((seqId != NA_BGM_DISABLED) && (sSeqFlags[seqId & 0xFF & 0xFF] & SEQ_FLAG_RESUME)) { if (sSeqResumePoint != SEQ_RESUME_POINT_NONE) { // Get the current point to resume from - sSeqResumePoint = gAudioContext.seqPlayers[SEQ_PLAYER_BGM_MAIN].soundScriptIO[3]; + sSeqResumePoint = gAudioCtx.seqPlayers[SEQ_PLAYER_BGM_MAIN].soundScriptIO[3]; } else { // Initialize the point to resume from to the start of the sequence sSeqResumePoint = 0; @@ -5139,13 +5137,13 @@ void Audio_PlayAmbience(u8 ambienceId) { u32 Audio_SetAmbienceRandomBend(u8 seqScriptValIn, SequenceChannel* channel) { u32 seqScriptValOut = seqScriptValIn; - gAudioContext.seqPlayers[SEQ_PLAYER_AMBIENCE].applyBend = true; + gAudioCtx.seqPlayers[SEQ_PLAYER_AMBIENCE].applyBend = true; if ((seqScriptValIn == 0) || (seqScriptValIn == 0xFF)) { - gAudioContext.seqPlayers[SEQ_PLAYER_AMBIENCE].bend = 1.0f; + gAudioCtx.seqPlayers[SEQ_PLAYER_AMBIENCE].bend = 1.0f; } else { seqScriptValOut = AudioThread_NextRandom(); - gAudioContext.seqPlayers[SEQ_PLAYER_AMBIENCE].bend = 1.0293 - ((gAudioContext.audioRandom & 0xF) / 144.0f); + gAudioCtx.seqPlayers[SEQ_PLAYER_AMBIENCE].bend = 1.0293 - ((gAudioCtx.audioRandom & 0xF) / 144.0f); return seqScriptValOut; } diff --git a/src/code/audio/code_801A5BD0.c b/src/code/audio/code_801A5BD0.c index d769708299..0e509670b8 100644 --- a/src/code/audio/code_801A5BD0.c +++ b/src/code/audio/code_801A5BD0.c @@ -599,7 +599,7 @@ void AudioSfx_PlayActiveSfx(u8 bankId) { // If entry is not empty if (entryIndex != 0xFF) { entry = &gSfxBanks[bankId][entryIndex]; - channel = gAudioContext.seqPlayers[SEQ_PLAYER_SFX].channels[sCurSfxPlayerChannelIndex]; + channel = gAudioCtx.seqPlayers[SEQ_PLAYER_SFX].channels[sCurSfxPlayerChannelIndex]; if (entry->state == SFX_STATE_READY) { // Initialize a sfx (new sfx request) @@ -847,7 +847,7 @@ void AudioSfx_StopById(u32 sfxId) { } void AudioSfx_ProcessRequests(void) { - if (gAudioContext.seqPlayers[SEQ_PLAYER_SFX].enabled) { + if (gAudioCtx.seqPlayers[SEQ_PLAYER_SFX].enabled) { while (sSfxRequestWriteIndex != sSfxRequestReadIndex) { AudioSfx_ProcessRequest(); sSfxRequestReadIndex++; @@ -886,7 +886,7 @@ void AudioSfx_StepBankLerp(u8 bankId) { void AudioSfx_ProcessActiveSfx(void) { u8 bankId; - if (gAudioContext.seqPlayers[SEQ_PLAYER_SFX].enabled) { + if (gAudioCtx.seqPlayers[SEQ_PLAYER_SFX].enabled) { sCurSfxPlayerChannelIndex = 0; for (bankId = 0; bankId < ARRAY_COUNT(gSfxBanks); bankId++) { diff --git a/tools/disasm/variables.txt b/tools/disasm/variables.txt index 4a5017ad5b..0fbd78e381 100644 --- a/tools/disasm/variables.txt +++ b/tools/disasm/variables.txt @@ -2249,7 +2249,7 @@ 0x801D5FD4:("D_801D5FD4","UNK_TYPE1","",0x1), 0x801D5FE0:("D_801D5FE0","UNK_PTR","",0x4), 0x801D5FE4:("D_801D5FE4","UNK_TYPE1","",0x1), - 0x801D5FE8:("gAudioContextInitalized","UNK_TYPE4","",0x4), + 0x801D5FE8:("gAudioCtxInitalized","UNK_TYPE4","",0x4), 0x801D5FEC:("D_801D5FEC","UNK_TYPE4","",0x4), 0x801D5FF0:("D_801D5FF0","UNK_TYPE4","",0x4), 0x801D5FF4:("D_801D5FF4","UNK_TYPE4","",0x4), @@ -4353,7 +4353,7 @@ 0x80200BCC:("D_80200BCC","UNK_TYPE1","",0x1), 0x80200BCE:("D_80200BCE","UNK_TYPE1","",0x1), 0x80200BD0:("D_80200BD0","UNK_TYPE1","",0x1), - 0x80200C70:("gAudioContext","AudioContext","",0x81F8), + 0x80200C70:("gAudioCtx","AudioContext","",0x81F8), 0x80208E68:("gCustomAudioUpdateFunction","UNK_TYPE4","",0x4), 0x80208E6C:("gCustomAudioSeqFunction","UNK_TYPE4","",0x4), 0x80208E70:("gCustomAudioReverbFunction","UNK_TYPE4","",0x4),