summaryrefslogtreecommitdiff
path: root/src/code
diff options
context:
space:
mode:
authorengineer124 <47598039+engineer124@users.noreply.github.com>2022-10-13 16:17:27 -0400
committerGitHub <noreply@github.com>2022-10-13 17:17:27 -0300
commit7204b0849838c0fa63b30591f9063a76c54307a7 (patch)
treea98668167da28e86c8f9a07bd6f5b6478f7495f9 /src/code
parentf3db0299367c4dd7cf44ab9e12cf6c8b56d598ab (diff)
Rename audio context (#1114)
Diffstat (limited to 'src/code')
-rw-r--r--src/code/audio/audio_effects.c2
-rw-r--r--src/code/audio/audio_heap.c570
-rw-r--r--src/code/audio/audio_init_params.c2
-rw-r--r--src/code/audio/audio_load.c564
-rw-r--r--src/code/audio/audio_playback.c118
-rw-r--r--src/code/audio/audio_seqplayer.c117
-rw-r--r--src/code/audio/audio_synthesis.c115
-rw-r--r--src/code/audio/code_8019AF00.c42
-rw-r--r--src/code/audio/code_801A5BD0.c6
9 files changed, 757 insertions, 779 deletions
diff --git a/src/code/audio/audio_effects.c b/src/code/audio/audio_effects.c
index bc27a6e22..3f50f003c 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 8412220a3..1c05e9441 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(&note->listItem);
- AudioSeq_AudioListPushBack(&gAudioContext.noteFreeLists.disabled, &note->listItem);
+ AudioSeq_AudioListPushBack(&gAudioCtx.noteFreeLists.disabled, &note->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 = &note->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;
-
- 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),
+ gAudioCtx.persistentCommonPool.curAddr = gAudioCtx.persistentCommonPool.startAddr;
+
+ 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;
-
- 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),
+ gAudioCtx.temporaryCommonPool.curAddr = gAudioCtx.temporaryCommonPool.startAddr;
+
+ 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);
-
- 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.samplingFreq = spec->samplingFreq;
+ gAudioCtx.audioBufferParameters.aiSamplingFreq = osAiSetFrequency(gAudioCtx.audioBufferParameters.samplingFreq);
+
+ 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 59c6658ac..6bba865e9 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 c9b5ad30b..d101b53f5 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;
- }
-
- 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;
-
- 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();
+ for (i = 0; i < ARRAY_COUNT(gAudioCtx.aiBufNumSamples); i++) {
+ gAudioCtx.aiBufNumSamples[i] = 0xA0;
+ }
+
+ 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(&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 a7cc9a588..07315d56e 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 = &note->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 bc5115f8f..099f646fe 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 d3b25f446..5c72c4452 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 9df12e7fe..5fd58a487 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 d76970829..0e509670b 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++) {
generated by cgit v1.2.3 (git 2.25.1) at 2026-08-04 18:03:24 +0000