Merge branch 'master' into otr

1 files changed, 336 insertions, 247 deletions

diff --git a/src/audio/audio_load.c b/src/audio/audio_load.c
index e74e9ab3..bd979269 100644
--- a/src/audio/audio_load.c
+++ b/src/audio/audio_load.c
@@ -2,37 +2,13 @@
 #include "sf64dma.h"
 #include "sf64audio_provisional.h"
 
-static char devstr00[] = "CAUTION:WAVE CACHE FULL %d";
-static char D_800C4F6C[] = "SUPERDMA";
-static char devstr02[] = "Bank Change... top %d lba %d\n";
-static char devstr03[] = "BankCount %d\n";
-static char devstr04[] = "BANK LOAD MISS! FOR %d\n";
-static char devstr05[] = "BankCount %d\n";
-static char devstr06[] = "Flush Start\n";
-static char devstr07[] = "%d ->%d\n";
-static char devstr08[] = "useflag %d\n";
-static char devstr09[] = "BankCount %d\n";
-static char devstr10[] = "%2x ";
-static char devstr11[] = "StartSeq (Group %d,Seq %d) Process finish\n";
-static char devstr12[] = "LoadCtrl, Ptr %x and Media is %d\n";
-static char devstr13[] = "Load Bank, Type %d , ID %d\n";
-static char devstr14[] = "get auto\n";
-static char devstr15[] = "get s-auto %x\n";
-static char devstr16[] = "Seq %d Write ID OK %d!\n";
-static char devstr17[] = "Banknumber %d\n";
-static char devstr18[] = "Bank Offset %x %d %d\n";
-static char devstr19[] = "PEP Touch %x \n";
-static char D_800C50E8[] = "FastCopy";
-
 s32 D_80146D80;
 s32 PAD_80146D88[2];
 AudioSlowLoadBuffer gSlowLoads;
 
 s32 AudioLoad_DiscardFont(s32 fontId);
-
 void AudioLoad_SyncInitSeqPlayerInternal(s32 playerIdx, s32 seqId, s32 arg2);
 void* AudioLoad_SyncLoadSeq(s32 seqId);
-void* AudioLoad_SyncLoadSampleBank(u32 sampleBankId, s32* outMedium);
 void* AudioLoad_SyncLoadFont(s32 fontId);
 void* AudioLoad_SyncLoad(u32 tableType, u32 id, s32* didAllocate);
 s32 AudioLoad_GetLoadTableIndex(s32 tableType, u32 entryId);
@@ -44,9 +20,7 @@ s32 AudioLoad_Dma(OSIoMesg* mesg, u32 priority, s32 direction, u32 devAddr, void
                   OSMesgQueue* retQueue, s32 medium, const char* dmaType);
 s32 func_8000FC7C(u32 unkMediumParam, u32* addrPtr);
 void func_8000FC8C(s32 unkParam2, u32 addr, u8* ramAddr, u32 size);
-void AudioLoad_SyncLoadSimple(u32 tableType, u32 id);
 void* AudioLoad_AsyncLoadInner(s32 tableType, s32 id, s32 nChunks, s32 retData, OSMesgQueue* retQueue);
-
 Sample* AudioLoad_GetFontSample(s32 fontId, s32 instId);
 void AudioLoad_ProcessSlowLoads(s32 resetStatus);
 void AudioLoad_DmaSlowCopy(AudioSlowLoad* slowLoad, s32 size);
@@ -60,7 +34,6 @@ void AudioLoad_AsyncDmaUnkMedium(u32 devAddr, u8* ramAddr, u32 size, s32 unkMedi
 void AudioLoad_RelocateSample(TunedSample* tSample, u32 fontDataAddr, SampleBankRelocInfo* relocInfo);
 s32 AudioLoad_RelocateFontAndPreloadSamples(s32 fontId, u32 fontDataAddr, SampleBankRelocInfo* relocData, s32 isAsync);
 s32 AudioLoad_ProcessSamplePreloads(s32 resetStatus);
-s32 AudioLoad_GetSamplesForFont(s32 fontId, Sample** sampleSet);
 
 void AudioLoad_DecreaseSampleDmaTtls(void) {
     SampleDma* dma;
@@ -77,6 +50,7 @@ void AudioLoad_DecreaseSampleDmaTtls(void) {
             }
         }
     }
+
     for (i = gSampleDmaListSize1; i < gSampleDmaCount; i++) {
         dma = &gSampleDmas[i];
         if (dma->ttl != 0) {
@@ -91,6 +65,8 @@ void AudioLoad_DecreaseSampleDmaTtls(void) {
     D_80155A50 = 0;
 }
 
+static const char devstr00[] = "CAUTION:WAVE CACHE FULL %d";
+
 void* AudioLoad_DmaSampleData(u32 devAddr, u32 size, u32 arg2, u8* dmaIndexRef, s32 medium) {
     u32 i;
     SampleDma* dma;
@@ -116,6 +92,7 @@ void* AudioLoad_DmaSampleData(u32 devAddr, u32 size, u32 arg2, u8* dmaIndexRef,
                 return &dma->ramAddr[devAddr - dma->devAddr];
             }
         }
+
         if ((gSampleDmaReuseQueue2RdPos != gSampleDmaReuseQueue2WrPos) && (arg2 != 0)) {
             sp38 = gSampleDmaReuseQueue2[gSampleDmaReuseQueue2RdPos];
             gSampleDmaReuseQueue2RdPos++;
@@ -152,17 +129,37 @@ void* AudioLoad_DmaSampleData(u32 devAddr, u32 size, u32 arg2, u8* dmaIndexRef,
     dma->devAddr = dmaDevAddr;
     dma->sizeUnused = dma->size;
     AudioLoad_Dma(&gCurAudioFrameDmaIoMsgBuf[gCurAudioFrameDmaCount++], 0, 0, dmaDevAddr, dma->ramAddr, dma->size,
-                  &gCurAudioFrameDmaQueue, medium, D_800C4F6C);
+                  &gCurAudioFrameDmaQueue, medium, "SUPERDMA");
     *dmaIndexRef = sp38;
     return devAddr - dmaDevAddr + dma->ramAddr;
 }
 
+static const char devstr02[] = "Bank Change... top %d lba %d\n";
+static const char devstr03[] = "BankCount %d\n";
+static const char devstr04[] = "BANK LOAD MISS! FOR %d\n";
+static const char devstr05[] = "BankCount %d\n";
+static const char devstr06[] = "Flush Start\n";
+static const char devstr07[] = "%d ->%d\n";
+static const char devstr08[] = "useflag %d\n";
+static const char devstr09[] = "BankCount %d\n";
+static const char devstr10[] = "%2x ";
+static const char devstr11[] = "StartSeq (Group %d,Seq %d) Process finish\n";
+static const char devstr12[] = "LoadCtrl, Ptr %x and Media is %d\n";
+static const char devstr13[] = "Load Bank, Type %d , ID %d\n";
+static const char devstr14[] = "get auto\n";
+static const char devstr15[] = "get s-auto %x\n";
+static const char devstr16[] = "Seq %d Write ID OK %d!\n";
+static const char devstr17[] = "Banknumber %d\n";
+static const char devstr18[] = "Bank Offset %x %d %d\n";
+static const char devstr19[] = "PEP Touch %x \n";
+
 void AudioLoad_InitSampleDmaBuffers(s32 numNotes) {
     s32 i;
     u8* dma;
 
     gSampleDmaBuffSize = 0x2D0;
-    for (i = 0; i < (3 * gNumNotes * gAudioBufferParams.specUnk4); i++) {
+
+    for (i = 0; i < (3 * gNumNotes * gAudioBufferParams.count); i++) {
         dma = AudioHeap_Alloc(&gMiscPool, gSampleDmaBuffSize);
         gSampleDmas[gSampleDmaCount].ramAddr = dma;
         if (dma == NULL) {
@@ -175,17 +172,21 @@ void AudioLoad_InitSampleDmaBuffers(s32 numNotes) {
         gSampleDmas[gSampleDmaCount].size = gSampleDmaBuffSize;
         gSampleDmaCount++;
     }
+
     for (i = 0; i < gSampleDmaCount; i++) {
         gSampleDmaReuseQueue1[i] = i;
         gSampleDmas[i].reuseIndex = i;
     }
+
     for (i = gSampleDmaCount; i < 0x100; i++) {
         gSampleDmaReuseQueue1[i] = 0;
     }
+
     gSampleDmaReuseQueue1RdPos = 0;
     gSampleDmaReuseQueue1WrPos = gSampleDmaCount;
     gSampleDmaListSize1 = gSampleDmaCount;
     gSampleDmaBuffSize = 0x200;
+
     for (i = 0; i < gNumNotes; i++) {
         dma = AudioHeap_Alloc(&gMiscPool, gSampleDmaBuffSize);
         gSampleDmas[gSampleDmaCount].ramAddr = dma;
@@ -199,32 +200,36 @@ void AudioLoad_InitSampleDmaBuffers(s32 numNotes) {
         gSampleDmas[gSampleDmaCount].size = gSampleDmaBuffSize;
         gSampleDmaCount++;
     }
+
     for (i = gSampleDmaListSize1; i < gSampleDmaCount; i++) {
         gSampleDmaReuseQueue2[i - gSampleDmaListSize1] = i;
         gSampleDmas[i].reuseIndex = i - gSampleDmaListSize1;
     }
+
     for (i = gSampleDmaCount; i < 0x100; i++) {
         gSampleDmaReuseQueue2[i] = gSampleDmaListSize1;
     }
+
     gSampleDmaReuseQueue2RdPos = 0;
     gSampleDmaReuseQueue2WrPos = gSampleDmaCount - gSampleDmaListSize1;
 }
 
+// Updates the audiotable entries with their absolute ROM addresses
 void AudioLoad_InitTable(AudioTable* table, u8* romAddr, u16 unkMediumParam) {
     s32 i;
 
-    table->unkMediumParam = unkMediumParam;
-    table->romAddr = romAddr;
+    table->base.unkMediumParam = unkMediumParam;
+    table->base.romAddr = (uintptr_t) romAddr;
 
-    for (i = 0; i < table->numEntries; i++) {
+    for (i = 0; i < table->base.numEntries; i++) {
         if ((table->entries[i].size != 0) && (table->entries[i].medium == MEDIUM_CART)) {
-            table->entries[i].romAddr += (u32) romAddr;
+            table->entries[i].romAddr += (uintptr_t) romAddr;
         }
     }
 }
 
 void* AudioLoad_SyncLoadSeqFonts(s32 seqId, u32* outFontId) {
-    s32 index = ((u16*) gSeqFontTable)[AudioLoad_GetLoadTableIndex(0, seqId)];
+    s32 index = ((u16*) gSeqFontTable)[AudioLoad_GetLoadTableIndex(SEQUENCE_TABLE, seqId)];
     s32 fontId = 0xFF;
     s32 numFonts = gSeqFontTable[index++];
     void* soundFontData;
@@ -233,7 +238,9 @@ void* AudioLoad_SyncLoadSeqFonts(s32 seqId, u32* outFontId) {
         fontId = gSeqFontTable[index++];
         soundFontData = AudioLoad_SyncLoadFont(fontId);
     }
+
     *outFontId = fontId;
+
     return soundFontData;
 }
 
@@ -241,7 +248,7 @@ void AudioLoad_SyncLoadSeqParts(s32 seqId, s32 flags) {
     s32 pad;
     u32 fontId;
 
-    seqId = AudioLoad_GetLoadTableIndex(0, seqId);
+    seqId = AudioLoad_GetLoadTableIndex(SEQUENCE_TABLE, seqId);
     if (flags & 2) {
         AudioLoad_SyncLoadSeqFonts(seqId, &fontId);
     }
@@ -253,13 +260,14 @@ void AudioLoad_SyncLoadSeqParts(s32 seqId, s32 flags) {
 s32 AudioLoad_SyncLoadSample(Sample* sample, s32 fontId) {
     u8* sampleAddr;
 
-    if ((sample->isRelocated == 1) && (sample->medium != 0)) {
+    if ((sample->isRelocated == true) && (sample->medium != MEDIUM_RAM)) {
         sampleAddr = AudioHeap_AllocPersistentSampleCache(sample->size, fontId, sample->sampleAddr, sample->medium);
         if (sampleAddr == NULL) {
             return -1;
         }
         if (sample->medium == MEDIUM_UNK) {
-            AudioLoad_SyncDmaUnkMedium(sample->sampleAddr, sampleAddr, sample->size, gSampleBankTable->unkMediumParam);
+            AudioLoad_SyncDmaUnkMedium(sample->sampleAddr, sampleAddr, sample->size,
+                                       gSampleBankTable->base.unkMediumParam);
         } else {
             AudioLoad_SyncDma(sample->sampleAddr, sampleAddr, sample->size, sample->medium);
         }
@@ -295,43 +303,46 @@ s32 AudioLoad_SyncLoadInstrument(s32 fontId, s32 instId, s32 drumId) {
 }
 
 void AudioLoad_AsyncLoadSampleBank(s32 sampleBankId, s32 nChunks, s32 retData, OSMesgQueue* retQueue) {
-    if (AudioLoad_AsyncLoadInner(2, AudioLoad_GetLoadTableIndex(2, sampleBankId), nChunks, retData, retQueue) == NULL) {
-        osSendMesg(retQueue, OS_MESG_PTR(NULL), 0);
+    if (AudioLoad_AsyncLoadInner(SAMPLE_TABLE, AudioLoad_GetLoadTableIndex(SAMPLE_TABLE, sampleBankId), nChunks,
+                                 retData, retQueue) == NULL) {
+        osSendMesg(retQueue, OS_MESG_PTR(NULL), OS_MESG_NOBLOCK);
     }
 }
 
 void AudioLoad_AsyncLoadSeq(s32 seqId, s32 nChunks, s32 retData, OSMesgQueue* retQueue) {
-    s32 index = ((u16*) gSeqFontTable)[AudioLoad_GetLoadTableIndex(0, seqId)];
+    s32 index = *((u16*) gSeqFontTable + AudioLoad_GetLoadTableIndex(SEQUENCE_TABLE, seqId));
     s32 fontsLeft = gSeqFontTable[index++];
 
     for (fontsLeft; fontsLeft > 0; fontsLeft--) {
-        AudioLoad_AsyncLoadInner(1, AudioLoad_GetLoadTableIndex(1, gSeqFontTable[index++]), nChunks, retData, retQueue);
+        AudioLoad_AsyncLoadInner(FONT_TABLE, AudioLoad_GetLoadTableIndex(FONT_TABLE, gSeqFontTable[index++]), nChunks,
+                                 retData, retQueue);
     }
 }
 
 u8* AudioLoad_GetFontsForSequence(s32 seqId, u32* outNumFonts) {
-    s32 index = ((u16*) gSeqFontTable)[AudioLoad_GetLoadTableIndex(0, seqId)];
+    s32 index = *((u16*) gSeqFontTable + AudioLoad_GetLoadTableIndex(SEQUENCE_TABLE, seqId));
 
     *outNumFonts = gSeqFontTable[index++];
     if (*outNumFonts == 0) {
         return NULL;
+    } else {
+        return &gSeqFontTable[index];
     }
-    return &gSeqFontTable[index];
 }
 
 void AudioLoad_DiscardSeqFonts(s32 seqId) {
-    s32 index = ((u16*) gSeqFontTable)[AudioLoad_GetLoadTableIndex(0, seqId)];
+    s32 index = *((u16*) gSeqFontTable + AudioLoad_GetLoadTableIndex(SEQUENCE_TABLE, seqId));
     s32 numFonts = gSeqFontTable[index++];
     u32 fontId;
 
     while (numFonts > 0) {
         numFonts--;
-        fontId = AudioLoad_GetLoadTableIndex(1, gSeqFontTable[index++]);
+        fontId = AudioLoad_GetLoadTableIndex(FONT_TABLE, gSeqFontTable[index++]);
         if (AudioHeap_SearchPermanentCache(1, fontId) == NULL) {
             AudioLoad_DiscardFont(fontId);
             if (gFontLoadStatus[fontId] != 5) {
-                if (1) {}
                 gFontLoadStatus[fontId] = 0;
+                if (1) {}
             }
         }
     }
@@ -349,6 +360,7 @@ s32 AudioLoad_DiscardFont(s32 fontId) {
     } else if (tcache->entries[1].id == fontId) {
         tcache->entries[1].id = -1;
     }
+
     pcache = &cache->persistent;
     for (i = 0; i < pcache->numEntries; i++) {
         if (pcache->entries[i].id == fontId) {
@@ -369,17 +381,23 @@ void AudioLoad_SyncInitSeqPlayerInternal(s32 playerIdx, s32 seqId, s32 arg2) {
     s32 fontId;
     s32 i;
 
-    seqId = AudioLoad_GetLoadTableIndex(0, seqId);
+    seqId = AudioLoad_GetLoadTableIndex(SEQUENCE_TABLE, seqId);
+
     func_800144E4(&gSeqPlayers[playerIdx]);
-    index = ((u16*) gSeqFontTable)[seqId];
+
+    index = *((u16*) gSeqFontTable + seqId);
     numFonts = gSeqFontTable[index++];
     fontId = 0xFF;
+
     for (numFonts; numFonts > 0; numFonts--) {
         fontId = gSeqFontTable[index++];
         AudioLoad_SyncLoadFont(fontId);
     }
+
     seqData = AudioLoad_SyncLoadSeq(seqId);
+
     func_80016804(playerIdx);
+
     gSeqPlayers[playerIdx].seqId = seqId;
     gSeqPlayers[playerIdx].defaultFont = fontId;
     gSeqPlayers[playerIdx].enabled = true;
@@ -388,13 +406,14 @@ void AudioLoad_SyncInitSeqPlayerInternal(s32 playerIdx, s32 seqId, s32 arg2) {
     gSeqPlayers[playerIdx].scriptState.depth = 0;
     gSeqPlayers[playerIdx].delay = 0;
     gSeqPlayers[playerIdx].finished = false;
+
     for (i = 0; i < 16; i++) {
         ;
     }
 }
 
 void* AudioLoad_SyncLoadSeq(s32 seqId) {
-    s32 seqIdx = AudioLoad_GetLoadTableIndex(0, seqId);
+    s32 seqIdx = AudioLoad_GetLoadTableIndex(SEQUENCE_TABLE, seqId);
     s32 didAllocate;
 
     return AudioLoad_SyncLoad(0, seqIdx, &didAllocate);
@@ -406,7 +425,7 @@ void* AudioLoad_SyncLoadSampleBank(u32 sampleBankId, s32* outMedium) {
     s32 cachePolicy;
     s32 noLoad;
 
-    sampleBankId = AudioLoad_GetLoadTableIndex(2, sampleBankId);
+    sampleBankId = AudioLoad_GetLoadTableIndex(SAMPLE_TABLE, sampleBankId);
     ramAddr = AudioLoad_SearchCaches(2, sampleBankId);
     if (ramAddr != NULL) {
         if (gSampleFontLoadStatus[sampleBankId] != 5) {
@@ -415,17 +434,21 @@ void* AudioLoad_SyncLoadSampleBank(u32 sampleBankId, s32* outMedium) {
         *outMedium = MEDIUM_RAM;
         return ramAddr;
     }
+
     cachePolicy = sampleBankTable->entries[sampleBankId].cachePolicy;
-    if (cachePolicy == 4) {
+    if (cachePolicy == CACHEPOLICY_4) {
         *outMedium = sampleBankTable->entries[sampleBankId].medium;
         return sampleBankTable->entries[sampleBankId].romAddr;
     }
+
     ramAddr = AudioLoad_SyncLoad(2, sampleBankId, &noLoad);
     if (ramAddr != NULL) {
         *outMedium = MEDIUM_RAM;
         return ramAddr;
     }
+
     *outMedium = sampleBankTable->entries[sampleBankId].medium;
+
     return sampleBankTable->entries[sampleBankId].romAddr;
 }
 
@@ -436,29 +459,35 @@ void* AudioLoad_SyncLoadFont(s32 fontId) {
     s32 didAllocate;
     SampleBankRelocInfo relocInfo;
 
-    fontId = AudioLoad_GetLoadTableIndex(1, fontId);
+    fontId = AudioLoad_GetLoadTableIndex(FONT_TABLE, fontId);
+
     sampleBankId1 = gSoundFontList[fontId].sampleBankId1;
     sampleBankId2 = gSoundFontList[fontId].sampleBankId2;
 
     relocInfo.sampleBankId1 = sampleBankId1;
     relocInfo.sampleBankId2 = sampleBankId2;
-    if (sampleBankId1 != 0xFF) {
+
+    if (sampleBankId1 != SAMPLES_NONE) {
         relocInfo.baseAddr1 = AudioLoad_SyncLoadSampleBank(sampleBankId1, &relocInfo.medium1);
     } else {
         relocInfo.baseAddr1 = NULL;
     }
-    if (sampleBankId2 != 0xFF) {
+
+    if (sampleBankId2 != SAMPLES_NONE) {
         relocInfo.baseAddr2 = AudioLoad_SyncLoadSampleBank(sampleBankId2, &relocInfo.medium2);
     } else {
         relocInfo.baseAddr2 = NULL;
     }
+
     fontData = AudioLoad_SyncLoad(1, fontId, &didAllocate);
     if (fontData == NULL) {
         return NULL;
     }
+
     if (didAllocate == 1) {
-        AudioLoad_RelocateFontAndPreloadSamples(fontId, fontData, &relocInfo, 0);
+        AudioLoad_RelocateFontAndPreloadSamples(fontId, fontData, &relocInfo, AUDIOLOAD_SYNC);
     }
+
     return fontData;
 }
 
@@ -483,28 +512,32 @@ void* AudioLoad_SyncLoad(u32 tableType, u32 id, s32* didAllocate) {
         medium = table->entries[id].medium;
         cachePolicy = table->entries[id].cachePolicy;
         romAddr = table->entries[id].romAddr;
+
         switch (cachePolicy) {
-            case 0:
+            case CACHEPOLICY_0:
                 ramAddr = AudioHeap_AllocPermanent(tableType, id, size);
                 if (ramAddr == NULL) {
                     return ramAddr;
                 }
                 break;
-            case 1:
-                ramAddr = AudioHeap_AllocCached(tableType, size, 1, id);
+
+            case CACHEPOLICY_1:
+                ramAddr = AudioHeap_AllocCached(tableType, size, CACHE_PERSISTENT, id);
                 if (ramAddr == NULL) {
                     return ramAddr;
                 }
                 break;
-            case 2:
-                ramAddr = AudioHeap_AllocCached(tableType, size, 0, id);
+
+            case CACHEPOLICY_2:
+                ramAddr = AudioHeap_AllocCached(tableType, size, CACHE_TEMPORARY, id);
                 if (ramAddr == NULL) {
                     return ramAddr;
                 }
                 break;
-            case 3:
-            case 4:
-                ramAddr = AudioHeap_AllocCached(tableType, size, 2, id);
+
+            case CACHEPOLICY_3:
+            case CACHEPOLICY_4:
+                ramAddr = AudioHeap_AllocCached(tableType, size, CACHE_EITHER, id);
                 if (ramAddr == NULL) {
                     return ramAddr;
                 }
@@ -512,24 +545,28 @@ void* AudioLoad_SyncLoad(u32 tableType, u32 id, s32* didAllocate) {
         }
 
         *didAllocate = true;
+
         if (medium == MEDIUM_UNK) {
-            AudioLoad_SyncDmaUnkMedium(romAddr, ramAddr, size, table->unkMediumParam);
+            AudioLoad_SyncDmaUnkMedium(romAddr, ramAddr, size, table->base.unkMediumParam);
         } else {
             AudioLoad_SyncDma(romAddr, ramAddr, size, medium);
         }
-        loadStatus = (cachePolicy == 0) ? 5 : 2;
+        loadStatus = (cachePolicy == CACHEPOLICY_0) ? 5 : 2;
     }
+
     switch (tableType) {
         case SEQUENCE_TABLE:
             if (gSeqLoadStatus[id] != 5) {
                 gSeqLoadStatus[id] = loadStatus;
             }
             break;
+
         case FONT_TABLE:
             if (gFontLoadStatus[id] != 5) {
                 gFontLoadStatus[id] = loadStatus;
             }
             break;
+
         case SAMPLE_TABLE:
             if (gSampleFontLoadStatus[id] != 5) {
                 gSampleFontLoadStatus[id] = loadStatus;
@@ -555,7 +592,8 @@ void* AudioLoad_SearchCaches(s32 tableType, s32 id) {
     if (ramAddr != NULL) {
         return ramAddr;
     }
-    ramAddr = AudioHeap_SearchCaches(tableType, 2, id);
+
+    ramAddr = AudioHeap_SearchCaches(tableType, CACHE_EITHER, id);
     if (ramAddr != NULL) {
         return ramAddr;
     }
@@ -599,11 +637,11 @@ void AudioLoad_RelocateFont(s32 fontId, u32 fontBaseAddr, void* relocData) {
         fontDataPtrs[0] += fontBaseAddr;
 
         for (i = 0; i < numDrums; i++) {
-            offset = (*drumDataPtrs)[i];
+            offset = *(*drumDataPtrs + i);
             if (offset != 0) {
                 drum = offset += fontBaseAddr;
-                (*drumDataPtrs)[i] = drum;
-                //  temp2;
+                *(*drumDataPtrs + i) = drum;
+
                 if (!drum->isRelocated) {
                     AudioLoad_RelocateSample(&drum->tunedSample, fontBaseAddr, relocData);
                     offset = (u32) drum->envelope;
@@ -613,13 +651,14 @@ void AudioLoad_RelocateFont(s32 fontId, u32 fontBaseAddr, void* relocData) {
             }
         }
     }
+
     for (i = 1; i <= numInstruments; i++) {
         if (fontDataPtrs[i] != 0) {
 
             fontDataPtrs[i] += fontBaseAddr;
 
             instrument = fontDataPtrs[i];
-            if (instrument->isRelocated == 0) {
+            if (!instrument->isRelocated) {
                 if (instrument->normalRangeLo != 0) {
                     AudioLoad_RelocateSample(&instrument->lowPitchTunedSample, fontBaseAddr, relocData);
                 }
@@ -633,28 +672,30 @@ void AudioLoad_RelocateFont(s32 fontId, u32 fontBaseAddr, void* relocData) {
             }
         }
     }
+
     gSoundFontList[fontId].drums = fontDataPtrs[0];
     gSoundFontList[fontId].instruments = (u32) &fontDataPtrs[1];
 }
 
-static char D_800C50F4[] = "FastCopy";
-
 void AudioLoad_SyncDma(u32 devAddr, u8* ramAddr, u32 size, s32 medium) {
     size = ALIGN16(size);
+
     osInvalDCache(ramAddr, size);
+
     while (true) {
         if (size < 0x400) {
             break;
         }
-        AudioLoad_Dma(&gSyncDmaIoMsg, 1, 0, devAddr, ramAddr, 0x400, &gSyncDmaQueue, medium, D_800C50E8);
-        osRecvMesg(&gSyncDmaQueue, NULL, 1);
+        AudioLoad_Dma(&gSyncDmaIoMsg, 1, 0, devAddr, ramAddr, 0x400, &gSyncDmaQueue, medium, "FastCopy");
+        MQ_WAIT_FOR_MESG(&gSyncDmaQueue, NULL);
         size -= 0x400;
         devAddr += 0x400;
         ramAddr += 0x400;
     }
+
     if (size != 0) {
-        AudioLoad_Dma(&gSyncDmaIoMsg, 1, 0, devAddr, ramAddr, size, &gSyncDmaQueue, medium, D_800C50F4);
-        osRecvMesg(&gSyncDmaQueue, NULL, 1);
+        AudioLoad_Dma(&gSyncDmaIoMsg, 1, 0, devAddr, ramAddr, size, &gSyncDmaQueue, medium, "FastCopy");
+        MQ_WAIT_FOR_MESG(&gSyncDmaQueue, NULL);
     }
 }
 
@@ -665,11 +706,11 @@ void AudioLoad_SyncDmaUnkMedium(u32 devAddr, u8* ramAddr, u32 size, s32 unkMediu
     func_8000FC8C(func_8000FC7C(unkMediumParam, &addr), addr, ramAddr, size);
 }
 
-static char devstr22[] = "Error: Cannot DMA Media [%d]\n";
-static char devstr23[] = "Warning: size not align 16 %x  (%s)\n";
-static char devstr24[] = "Load Bank BG, Type %d , ID %d\n";
-static char devstr25[] = "get auto\n";
-static char devstr26[] = "get s-auto %x\n";
+static const char devstr22[] = "Error: Cannot DMA Media [%d]\n";
+static const char devstr23[] = "Warning: size not align 16 %x  (%s)\n";
+static const char devstr24[] = "Load Bank BG, Type %d , ID %d\n";
+static const char devstr25[] = "get auto\n";
+static const char devstr26[] = "get s-auto %x\n";
 
 s32 AudioLoad_Dma(OSIoMesg* mesg, u32 priority, s32 direction, u32 devAddr, void* ramAddr, u32 size,
                   OSMesgQueue* retQueue, s32 medium, const char* dmaType) {
@@ -680,20 +721,22 @@ s32 AudioLoad_Dma(OSIoMesg* mesg, u32 priority, s32 direction, u32 devAddr, void
             handle = osCartRomInit();
             break;
         case MEDIUM_DISK_DRIVE:
-            handle = func_8001EE60();
+            handle = osDriveRomInit();
             break;
         default:
             return 0;
     }
 
-    if (size & 0xF) {
+    if (size % 16) {
         size = ALIGN16(size);
     }
+
     mesg->hdr.pri = priority;
     mesg->hdr.retQueue = retQueue;
     mesg->dramAddr = ramAddr;
     mesg->devAddr = devAddr;
     mesg->size = size;
+
     handle->transferInfo.cmdType = 2;
     osEPiStartDma(handle, mesg, direction);
 
@@ -723,26 +766,29 @@ void* AudioLoad_AsyncLoadInner(s32 tableType, s32 id, s32 nChunks, s32 retData,
     s32 loadStatus;
 
     switch (tableType) {
-        case 0:
-            if (gSeqLoadStatus[id] == 1) {
+        case SEQUENCE_TABLE:
+            if (gSeqLoadStatus[id] == LOAD_STATUS_IN_PROGRESS) {
                 return NULL;
             }
             break;
-        case 1:
-            if (gFontLoadStatus[id] == 1) {
+
+        case FONT_TABLE:
+            if (gFontLoadStatus[id] == LOAD_STATUS_IN_PROGRESS) {
                 return NULL;
             }
             break;
-        case 2:
-            if (gSampleFontLoadStatus[id] == 1) {
+
+        case SAMPLE_TABLE:
+            if (gSampleFontLoadStatus[id] == LOAD_STATUS_IN_PROGRESS) {
                 return NULL;
             }
             break;
     }
+
     ramAddr = AudioLoad_SearchCaches(tableType, id);
     if (ramAddr != NULL) {
-        loadStatus = 2;
-        osSendMesg(retQueue, OS_MESG_32(retData << 0x18), 0);
+        loadStatus = LOAD_STATUS_COMPLETE;
+        osSendMesg(retQueue, OS_MESG_32(retData << 0x18), OS_MESG_NOBLOCK);
     } else {
         table = AudioLoad_GetLoadTable(tableType);
         size = table->entries[id].size;
@@ -750,30 +796,34 @@ void* AudioLoad_AsyncLoadInner(s32 tableType, s32 id, s32 nChunks, s32 retData,
         medium = table->entries[id].medium;
         cachePolicy = table->entries[id].cachePolicy;
         romAddr = table->entries[id].romAddr;
-        loadStatus = 2;
+        loadStatus = LOAD_STATUS_COMPLETE;
+
         switch (cachePolicy) {
-            case 0:
+            case CACHEPOLICY_0:
                 ramAddr = AudioHeap_AllocPermanent(tableType, id, size);
                 if (ramAddr == NULL) {
                     return ramAddr;
                 }
-                loadStatus = 5;
+                loadStatus = LOAD_STATUS_PERMANENTLY_LOADED;
                 break;
-            case 1:
-                ramAddr = AudioHeap_AllocCached(tableType, size, 1, id);
+
+            case CACHEPOLICY_1:
+                ramAddr = AudioHeap_AllocCached(tableType, size, CACHE_PERSISTENT, id);
                 if (ramAddr == NULL) {
                     return ramAddr;
                 }
                 break;
-            case 2:
-                ramAddr = AudioHeap_AllocCached(tableType, size, 0, id);
+
+            case CACHEPOLICY_2:
+                ramAddr = AudioHeap_AllocCached(tableType, size, CACHE_TEMPORARY, id);
                 if (ramAddr == NULL) {
                     return ramAddr;
                 }
                 break;
-            case 3:
-            case 4:
-                ramAddr = AudioHeap_AllocCached(tableType, size, 2, id);
+
+            case CACHEPOLICY_3:
+            case CACHEPOLICY_4:
+                ramAddr = AudioHeap_AllocCached(tableType, size, CACHE_EITHER, id);
                 if (ramAddr == NULL) {
                     return ramAddr;
                 }
@@ -781,20 +831,23 @@ void* AudioLoad_AsyncLoadInner(s32 tableType, s32 id, s32 nChunks, s32 retData,
         }
         AudioLoad_StartAsyncLoad(romAddr, ramAddr, size, medium, nChunks, retQueue,
                                  (retData << 0x18) | (tableType << 0x10) | (id << 8) | loadStatus);
-        loadStatus = 1;
+        loadStatus = LOAD_STATUS_IN_PROGRESS;
     }
+
     switch (tableType) {
-        case 0:
+        case SEQUENCE_TABLE:
             if (gSeqLoadStatus[id] != 5) {
                 gSeqLoadStatus[id] = loadStatus;
             }
             break;
-        case 1:
+
+        case FONT_TABLE:
             if (gFontLoadStatus[id] != 5) {
                 gFontLoadStatus[id] = loadStatus;
             }
             break;
-        case 2:
+
+        case SAMPLE_TABLE:
             if (gSampleFontLoadStatus[id] != 5) {
                 gSampleFontLoadStatus[id] = loadStatus;
             }
@@ -810,17 +863,17 @@ void AudioLoad_ProcessLoads(s32 resetStatus) {
     AudioLoad_ProcessAsyncLoads(resetStatus);
 }
 
-static char devstr27[] = "Clear Workarea %x -%x size %x \n";
-static char devstr28[] = "AudioHeap is %x\n";
-static char devstr29[] = "Heap reset.Synth Change %x \n";
-static char devstr30[] = "Heap %x %x %x\n";
-static char devstr31[] = "Main Heap Initialize.\n";
-static char devstr32[] = "%d :WaveA %d WaveB %d Inst %d,Perc %d\n";
-static char devstr33[] = "---------- Init Completed. ------------\n";
-static char devstr34[] = " Syndrv    :[%6d]\n";
-static char devstr35[] = " Seqdrv    :[%6d]\n";
-static char devstr36[] = " audiodata :[%6d]\n";
-static char devstr37[] = "---------------------------------------\n";
+static const char devstr27[] = "Clear Workarea %x -%x size %x \n";
+static const char devstr28[] = "AudioHeap is %x\n";
+static const char devstr29[] = "Heap reset.Synth Change %x \n";
+static const char devstr30[] = "Heap %x %x %x\n";
+static const char devstr31[] = "Main Heap Initialize.\n";
+static const char devstr32[] = "%d :WaveA %d WaveB %d Inst %d,Perc %d\n";
+static const char devstr33[] = "---------- Init Completed. ------------\n";
+static const char devstr34[] = " Syndrv    :[%6d]\n";
+static const char devstr35[] = " Seqdrv    :[%6d]\n";
+static const char devstr36[] = " audiodata :[%6d]\n";
+static const char devstr37[] = "---------------------------------------\n";
 
 void AudioLoad_Init(void) {
     s32 pad[14];
@@ -831,10 +884,10 @@ void AudioLoad_Init(void) {
     u64* clearContext;
     void* ramAddr;
 
-    gResetTimer = 0;
+    gAudioResetTimer = 0;
 
     for (i = 0; i < gAudioHeapSize / 8; i++) {
-        ((u64*) gAudioHeap)[i] = 0;
+        *((u64*) gAudioHeap + i) = 0;
     }
 
     clearContext = gAudioContextStart;
@@ -846,9 +899,11 @@ void AudioLoad_Init(void) {
     gMaxTempoTvTypeFactors = 16.713f;
     gRefreshRate = 60;
     AudioThread_Init();
+
     for (i = 0; i < 3; i++) {
         gAiBuffLengths[i] = 0xA0;
     }
+
     gAudioTaskCountQ = 0;
     gAudioTaskIndexQ = 0;
     gCurAiBuffIndex = 0;
@@ -856,80 +911,98 @@ void AudioLoad_Init(void) {
     gAudioCurTask = NULL;
     gAudioRspTasks[0].task.t.data_size = 0;
     gAudioRspTasks[1].task.t.data_size = 0;
+
     osCreateMesgQueue(&gSyncDmaQueue, gSyncDmaMsg, 1);
     osCreateMesgQueue(&gCurAudioFrameDmaQueue, gCurAudioFrameDmaMsg, 64);
     osCreateMesgQueue(&gExternalLoadQueue, gExternalLoadMsg, 16);
     osCreateMesgQueue(&gPreloadSampleQueue, gPreloadSampleMsg, 16);
+
     gCurAudioFrameDmaCount = 0;
     gSampleDmaCount = 0;
+
     AudioHeap_InitMainPools(gInitPoolSize);
+
     for (i = 0; i < 3; i++) {
         gAiBuffers[i] = AudioHeap_Alloc(&gInitPool, AIBUF_SIZE);
         for (j = 0; j < AIBUF_LEN; j++) {
             gAiBuffers[i][j] = 0;
         }
     }
-    gAudioSpecId = 0;
-    gResetStatus = 1;
+
+    gAudioSpecId = AUDIOSPEC_CO;
+    gAudioResetStep = 1;
     AudioHeap_ResetStep();
+
     gSequenceTable = &gSeqTableInit;
     gSoundFontTable = &gSoundFontTableInit;
     gSampleBankTable = &gSampleBankTableInit;
     gSeqFontTable = gSeqFontTableInit;
-    gNumSequences = gSequenceTable->numEntries;
+    gNumSequences = gSequenceTable->base.numEntries;
+
     AudioLoad_InitTable(gSequenceTable, SEGMENT_ROM_START(audio_seq), gSequenceMedium);
     AudioLoad_InitTable(gSoundFontTable, SEGMENT_ROM_START(audio_bank), gSoundFontMedium);
     AudioLoad_InitTable(gSampleBankTable, SEGMENT_ROM_START(audio_table), gSampleBankMedium);
-    numFonts = gSoundFontTable->numEntries;
+
+    numFonts = gSoundFontTable->base.numEntries;
+
     gSoundFontList = AudioHeap_Alloc(&gInitPool, numFonts * sizeof(SoundFont));
+
     for (i = 0; i < numFonts; i++) {
         gSoundFontList[i].sampleBankId1 = (gSoundFontTable->entries[i].shortData1 >> 8) & 0xFF;
         gSoundFontList[i].sampleBankId2 = gSoundFontTable->entries[i].shortData1 & 0xFF;
         gSoundFontList[i].numInstruments = (gSoundFontTable->entries[i].shortData2 >> 8) & 0xFF;
         gSoundFontList[i].numDrums = gSoundFontTable->entries[i].shortData2 & 0xFF;
     }
+
     ramAddr = AudioHeap_Alloc(&gInitPool, gPermanentPoolSize);
     if (ramAddr == NULL) {
         gPermanentPoolSize = 0;
     }
+
     AudioHeap_InitPool(&gPermanentPool.pool, ramAddr, gPermanentPoolSize);
     func_800168BC();
 }
 
-static char devstr38[] = "Entry--- %d %d\n";
-static char devstr39[] = "---Block LPS here\n";
-static char devstr40[] = "===Block LPS end\n";
+static const char devstr38[] = "Entry--- %d %d\n";
+static const char devstr39[] = "---Block LPS here\n";
+static const char devstr40[] = "===Block LPS end\n";
+
 s32 AudioLoad_SlowLoadSample(s32 fontId, u8 instId, s8* status) {
     Sample* sample;
     AudioSlowLoad* slowLoad;
 
     sample = AudioLoad_GetFontSample(fontId, instId);
     if (sample == NULL) {
-        *status = 0;
+        *status = SLOW_LOAD_STATUS_0;
         return -1;
     }
     if (sample->medium == MEDIUM_RAM) {
-        *status = 2;
+        *status = SLOW_LOAD_STATUS_2;
         return 0;
     }
+
     slowLoad = &gSlowLoads.slowLoad[gSlowLoads.unk_00];
-    if (slowLoad->state == 3) {
-        slowLoad->state = 0;
+    if (slowLoad->state == SLOW_LOAD_DONE) {
+        slowLoad->state = SLOW_LOAD_WAITING;
     }
+
     slowLoad->sample = *sample;
     slowLoad->status = status;
+
     slowLoad->curRamAddr =
         AudioHeap_AllocTemporarySampleCache(sample->size, fontId, sample->sampleAddr, sample->medium);
+
     if (slowLoad->curRamAddr == NULL) {
         if ((sample->medium == MEDIUM_UNK) || (sample->codec == 2)) {
-            *status = 0;
+            *status = SLOW_LOAD_STATUS_0;
             return -1;
         } else {
-            *status = 3;
+            *status = SLOW_LOAD_STATUS_3;
             return -1;
         }
     }
-    slowLoad->state = 1;
+
+    slowLoad->state = SLOW_LOAD_START;
     slowLoad->bytesRemaining = ALIGN16(sample->size);
     slowLoad->ramAddr = slowLoad->curRamAddr;
     slowLoad->curDevAddr = sample->sampleAddr;
@@ -937,6 +1010,7 @@ s32 AudioLoad_SlowLoadSample(s32 fontId, u8 instId, s8* status) {
     slowLoad->seqOrFontId = fontId;
     slowLoad->instId = instId;
     gSlowLoads.unk_00 ^= 1;
+
     return 0;
 }
 
@@ -982,22 +1056,22 @@ void AudioLoad_ProcessSlowLoads(s32 resetStatus) {
     for (i = 0; i < 2; i++) {
         slowLoad = &gSlowLoads.slowLoad[i];
         switch (slowLoad->state) {
-            case 2:
-                osRecvMesg(&slowLoad->msgQueue, NULL, 1);
+            case SLOW_LOAD_LOADING:
+                MQ_WAIT_FOR_MESG(&slowLoad->mesgQueue, NULL);
                 if (resetStatus != 0) {
-                    slowLoad->state = 3;
+                    slowLoad->state = SLOW_LOAD_DONE;
                     break;
                 }
-            case 1:
-                slowLoad->state = 2;
+            case SLOW_LOAD_START:
+                slowLoad->state = SLOW_LOAD_LOADING;
                 if (slowLoad->bytesRemaining == 0) {
                     AudioLoad_FinishSlowLoad(&gSlowLoads.slowLoad[i]);
-                    slowLoad->state = 3;
-                    *slowLoad->status = 1;
+                    slowLoad->state = SLOW_LOAD_DONE;
+                    *slowLoad->status = SLOW_LOAD_STATUS_1;
                 } else if (slowLoad->bytesRemaining < 0x1000) {
                     if (slowLoad->medium == MEDIUM_UNK) {
                         AudioLoad_DmaSlowCopyUnkMedium(slowLoad->curDevAddr, slowLoad->curRamAddr,
-                                                       slowLoad->bytesRemaining, sampleBankTable->unkMediumParam);
+                                                       slowLoad->bytesRemaining, sampleBankTable->base.unkMediumParam);
                     } else {
                         AudioLoad_DmaSlowCopy(&gSlowLoads.slowLoad[i], slowLoad->bytesRemaining);
                     }
@@ -1005,7 +1079,7 @@ void AudioLoad_ProcessSlowLoads(s32 resetStatus) {
                 } else {
                     if (slowLoad->medium == MEDIUM_UNK) {
                         AudioLoad_DmaSlowCopyUnkMedium(slowLoad->curDevAddr, slowLoad->curRamAddr, 0x1000,
-                                                       sampleBankTable->unkMediumParam);
+                                                       sampleBankTable->base.unkMediumParam);
                     } else {
                         AudioLoad_DmaSlowCopy(&gSlowLoads.slowLoad[i], 0x1000);
                     }
@@ -1018,21 +1092,20 @@ void AudioLoad_ProcessSlowLoads(s32 resetStatus) {
     }
 }
 
-static char D_800C52F4[] = "SLOWCOPY";
-static char devstr42[] = "Req: Src %x Dest %x Len %x,media %d,retcode %d\n";
-static char devstr43[] = "Remain Size %d\n";
-static char devstr44[] = "---Block BG here\n";
-static char devstr45[] = "===Block BG end\n";
-static char devstr46[] = "Retcode %x\n";
-static char devstr47[] = "Other Type: Not Write ID.\n";
-
 void AudioLoad_DmaSlowCopy(AudioSlowLoad* slowLoad, s32 size) {
     osInvalDCache(slowLoad->curRamAddr, size);
-    osCreateMesgQueue(&slowLoad->msgQueue, &slowLoad->msg, 1);
-    AudioLoad_Dma(&slowLoad->ioMesg, 0, 0, slowLoad->curDevAddr, slowLoad->curRamAddr, size, &slowLoad->msgQueue,
-                  slowLoad->medium, D_800C52F4);
+    osCreateMesgQueue(&slowLoad->mesgQueue, &slowLoad->msg, 1);
+    AudioLoad_Dma(&slowLoad->ioMesg, 0, 0, slowLoad->curDevAddr, slowLoad->curRamAddr, size, &slowLoad->mesgQueue,
+                  slowLoad->medium, "SLOWCOPY");
 }
 
+static const char devstr42[] = "Req: Src %x Dest %x Len %x,media %d,retcode %d\n";
+static const char devstr43[] = "Remain Size %d\n";
+static const char devstr44[] = "---Block BG here\n";
+static const char devstr45[] = "===Block BG end\n";
+static const char devstr46[] = "Retcode %x\n";
+static const char devstr47[] = "Other Type: Not Write ID.\n";
+
 void AudioLoad_DmaSlowCopyUnkMedium(u32 devAddr, u8* ramAddr, u32 size, s32 unkMediumParam) {
     s32 addr = devAddr;
 
@@ -1054,6 +1127,7 @@ AudioAsyncLoad* AudioLoad_StartAsyncLoad(u32 devAddr, u8* ramAddr, u32 size, s32
     if (i == 16) {
         return NULL;
     }
+
     asyncLoad->status = 1;
     asyncLoad->curDevAddr = devAddr;
     asyncLoad->ramAddr = ramAddr;
@@ -1068,13 +1142,13 @@ AudioAsyncLoad* AudioLoad_StartAsyncLoad(u32 devAddr, u8* ramAddr, u32 size, s32
             asyncLoad->chunkSize = 0x100;
         }
     }
-    asyncLoad->retQueue = retQueue;
 
+    asyncLoad->retQueue = retQueue;
     asyncLoad->delay = 3;
     asyncLoad->medium = medium;
     asyncLoad->retMsg = OS_MESG_32(retMesg);
 
-    osCreateMesgQueue(&asyncLoad->msgQueue, &asyncLoad->msg, 1);
+    osCreateMesgQueue(&asyncLoad->mesgQueue, &asyncLoad->msg, 1);
     return asyncLoad;
 }
 
@@ -1089,16 +1163,15 @@ void AudioLoad_ProcessAsyncLoads(s32 resetStatus) {
 }
 
 void AudioLoad_ProcessAsyncLoad(AudioAsyncLoad* asyncLoad, s32 resetStatus) {
-    AudioTable* sp5C;
-    s32 pad1;
-    s32 pad2;
-    u32 temp;
-    s32 sp24;
-    s32 sp48;
-    s32 sp44;
-    SampleBankRelocInfo sp2C;
-
-    sp5C = gSampleBankTable;
+    AudioTable* sampleTable = gSampleBankTable;
+    s32 tableType;
+    s32 loadStatus;
+    u32 msg;
+    s32 tableIndex;
+    s32 sampleBankId1;
+    s32 sampleBankId2;
+    SampleBankRelocInfo relocInfo;
+
     if (asyncLoad->delay > 1) {
         asyncLoad->delay--;
         return;
@@ -1107,86 +1180,90 @@ void AudioLoad_ProcessAsyncLoad(AudioAsyncLoad* asyncLoad, s32 resetStatus) {
         asyncLoad->delay = 0;
     } else {
         if (resetStatus != 0) {
-            osRecvMesg(&asyncLoad->msgQueue, NULL, 1);
+            MQ_WAIT_FOR_MESG(&asyncLoad->mesgQueue, NULL);
             asyncLoad->status = 0;
             return;
         }
-        if (osRecvMesg(&asyncLoad->msgQueue, NULL, 0) == -1) {
+        if (!MQ_GET_MESG(&asyncLoad->mesgQueue, NULL)) {
             return;
         }
     }
+
     if (asyncLoad->bytesRemaining == 0) {
-        temp = asyncLoad->retMsg.data32;
-        pad1 = (temp >> 0x10) & 0xFF;
-        sp24 = (temp >> 8) & 0xFF;
-        pad2 = temp & 0xFF;
-        switch (pad1) {
-            case 0:
-                if (gSeqLoadStatus[sp24] != 5) {
-                    gSeqLoadStatus[sp24] = pad2;
+        msg = asyncLoad->retMsg;
+        tableType = (msg >> 0x10) & 0xFF;
+        tableIndex = (msg >> 8) & 0xFF;
+        loadStatus = msg & 0xFF;
+
+        switch (tableType) {
+            case SEQUENCE_TABLE:
+                if (gSeqLoadStatus[tableIndex] != 5) {
+                    gSeqLoadStatus[tableIndex] = loadStatus;
                 }
                 break;
-            case 2:
-                if (gSampleFontLoadStatus[sp24] != 5) {
-                    gSampleFontLoadStatus[sp24] = pad2;
+
+            case SAMPLE_TABLE:
+                if (gSampleFontLoadStatus[tableIndex] != 5) {
+                    gSampleFontLoadStatus[tableIndex] = loadStatus;
                 }
                 break;
-            case 1:
-                if (gFontLoadStatus[sp24] != 5) {
-                    gFontLoadStatus[sp24] = pad2;
+
+            case FONT_TABLE:
+                if (gFontLoadStatus[tableIndex] != 5) {
+                    gFontLoadStatus[tableIndex] = loadStatus;
                 }
-                sp48 = gSoundFontList[sp24].sampleBankId1;
-                sp44 = gSoundFontList[sp24].sampleBankId2;
-                sp2C.sampleBankId1 = sp48;
-                sp2C.sampleBankId2 = sp44;
-                if (sp48 != 0xFF) {
-                    sp2C.baseAddr1 = AudioLoad_SyncLoadSampleBank(sp48, &sp2C.medium1);
+
+                sampleBankId1 = gSoundFontList[tableIndex].sampleBankId1;
+                sampleBankId2 = gSoundFontList[tableIndex].sampleBankId2;
+                relocInfo.sampleBankId1 = sampleBankId1;
+                relocInfo.sampleBankId2 = sampleBankId2;
+
+                if (sampleBankId1 != SAMPLES_NONE) {
+                    relocInfo.baseAddr1 = AudioLoad_SyncLoadSampleBank(sampleBankId1, &relocInfo.medium1);
                 } else {
-                    sp2C.baseAddr1 = NULL;
+                    relocInfo.baseAddr1 = NULL;
                 }
-                if (sp44 != 0xFF) {
-                    sp2C.baseAddr2 = AudioLoad_SyncLoadSampleBank(sp44, &sp2C.medium2);
+
+                if (sampleBankId2 != SAMPLES_NONE) {
+                    relocInfo.baseAddr2 = AudioLoad_SyncLoadSampleBank(sampleBankId2, &relocInfo.medium2);
                 } else {
-                    sp2C.baseAddr2 = NULL;
+                    relocInfo.baseAddr2 = NULL;
                 }
-                AudioLoad_RelocateFontAndPreloadSamples(sp24, asyncLoad->ramAddr, &sp2C, 1);
+                AudioLoad_RelocateFontAndPreloadSamples(tableIndex, asyncLoad->ramAddr, &relocInfo, AUDIOLOAD_ASYNC);
                 break;
         }
         asyncLoad->status = 0;
-        osSendMesg(asyncLoad->retQueue, asyncLoad->retMsg, 0);
+        osSendMesg(asyncLoad->retQueue, asyncLoad->retMsg, OS_MESG_NOBLOCK);
+    } else if (asyncLoad->bytesRemaining < asyncLoad->chunkSize) {
+        if (asyncLoad->medium == MEDIUM_UNK) {
+            AudioLoad_AsyncDmaUnkMedium(asyncLoad->curDevAddr, asyncLoad->curRamAddr, asyncLoad->bytesRemaining,
+                                        sampleTable->base.unkMediumParam);
+        } else {
+            AudioLoad_AsyncDma(asyncLoad, asyncLoad->bytesRemaining);
+        }
+        asyncLoad->bytesRemaining = 0;
     } else {
-        if (asyncLoad->bytesRemaining < asyncLoad->chunkSize) {
-            if (asyncLoad->medium == MEDIUM_UNK) {
-                AudioLoad_AsyncDmaUnkMedium(asyncLoad->curDevAddr, asyncLoad->curRamAddr, asyncLoad->bytesRemaining,
-                                            sp5C->unkMediumParam);
-            } else {
-                AudioLoad_AsyncDma(asyncLoad, asyncLoad->bytesRemaining);
-            }
-            asyncLoad->bytesRemaining = 0;
+        if (asyncLoad->medium == MEDIUM_UNK) {
+            AudioLoad_AsyncDmaUnkMedium(asyncLoad->curDevAddr, asyncLoad->curRamAddr, asyncLoad->chunkSize,
+                                        sampleTable->base.unkMediumParam);
         } else {
-            if (asyncLoad->medium == MEDIUM_UNK) {
-                AudioLoad_AsyncDmaUnkMedium(asyncLoad->curDevAddr, asyncLoad->curRamAddr, asyncLoad->chunkSize,
-                                            sp5C->unkMediumParam);
-            } else {
-                AudioLoad_AsyncDma(asyncLoad, asyncLoad->chunkSize);
-            }
-            asyncLoad->bytesRemaining -= asyncLoad->chunkSize;
-            asyncLoad->curDevAddr += asyncLoad->chunkSize;
-            asyncLoad->curRamAddr += asyncLoad->chunkSize;
+            AudioLoad_AsyncDma(asyncLoad, asyncLoad->chunkSize);
         }
+        asyncLoad->bytesRemaining -= asyncLoad->chunkSize;
+        asyncLoad->curDevAddr += asyncLoad->chunkSize;
+        asyncLoad->curRamAddr += asyncLoad->chunkSize;
     }
 }
 
-static char devstr48[] = "BGLOAD:Error: dma length 0\n";
-static char D_800C53AC[] = "BGCOPY";
+static const char devstr48[] = "BGLOAD:Error: dma length 0\n";
 
 void AudioLoad_AsyncDma(AudioAsyncLoad* asyncLoad, u32 size) {
     size = ALIGN16(size);
     osInvalDCache(asyncLoad->curRamAddr, size);
-    osCreateMesgQueue(&asyncLoad->msgQueue, &asyncLoad->msg, 1);
+    osCreateMesgQueue(&asyncLoad->mesgQueue, &asyncLoad->msg, 1);
     if (size) {}
-    AudioLoad_Dma(&asyncLoad->ioMesg, 0, 0, asyncLoad->curDevAddr, asyncLoad->curRamAddr, size, &asyncLoad->msgQueue,
-                  asyncLoad->medium, D_800C53AC);
+    AudioLoad_Dma(&asyncLoad->ioMesg, 0, 0, asyncLoad->curDevAddr, asyncLoad->curRamAddr, size, &asyncLoad->mesgQueue,
+                  asyncLoad->medium, "BGCOPY");
 }
 
 void AudioLoad_AsyncDmaUnkMedium(u32 devAddr, u8* ramAddr, u32 size, s32 unkMediumParam) {
@@ -1196,8 +1273,8 @@ void AudioLoad_AsyncDmaUnkMedium(u32 devAddr, u8* ramAddr, u32 size, s32 unkMedi
     func_8000FC8C(func_8000FC7C(unkMediumParam, &addr), addr, ramAddr, size);
 }
 
-static char devstr50[] = "Error: Already wavetable is touched %x.\n";
-static char devstr51[] = "Touch Warning: Length zero %x\n";
+static const char devstr50[] = "Error: Already wavetable is touched %x.\n";
+static const char devstr51[] = "Touch Warning: Length zero %x\n";
 
 void AudioLoad_RelocateSample(TunedSample* tSample, u32 fontDataAddr, SampleBankRelocInfo* relocInfo) {
     void* reloc;
@@ -1210,7 +1287,7 @@ void AudioLoad_RelocateSample(TunedSample* tSample, u32 fontDataAddr, SampleBank
         if ((sample->size != 0) && (sample->isRelocated != 1)) {
             sample->loop = reloc = (u32) sample->loop + fontDataAddr;
             sample->book = reloc = (u32) sample->book + fontDataAddr;
-            switch (sample->medium) { /* irregular */
+            switch (sample->medium) {
                 case MEDIUM_RAM:
                     sample->sampleAddr = reloc = sample->sampleAddr + relocInfo->baseAddr1;
                     sample->medium = relocInfo->medium1;
@@ -1223,6 +1300,7 @@ void AudioLoad_RelocateSample(TunedSample* tSample, u32 fontDataAddr, SampleBank
                 case MEDIUM_DISK_DRIVE:
                     break;
             }
+
             sample->isRelocated = true;
             if (sample->unk_bit26 && (sample->medium != 0)) {
                 gUsedSamples[gNumUsedSamples++] = sample;
@@ -1231,11 +1309,11 @@ void AudioLoad_RelocateSample(TunedSample* tSample, u32 fontDataAddr, SampleBank
     }
 }
 
-static char devstr52[] = "It's busy now!!!!! %d\n";
-static char devstr53[] = "BG LOAD BUFFER is OVER.\n";
-static char devstr54[] = "Warning: Length zero %x\n";
-static char devstr55[] = "Wave Load %d \n";
-static char devstr56[] = "Total Bg Wave Load %d \n";
+static const char devstr52[] = "It's busy now!!!!! %d\n";
+static const char devstr53[] = "BG LOAD BUFFER is OVER.\n";
+static const char devstr54[] = "Warning: Length zero %x\n";
+static const char devstr55[] = "Wave Load %d \n";
+static const char devstr56[] = "Total Bg Wave Load %d \n";
 
 s32 AudioLoad_RelocateFontAndPreloadSamples(s32 fontId, u32 fontDataAddr, SampleBankRelocInfo* relocData, s32 isAsync) {
     s32 i;
@@ -1252,9 +1330,11 @@ s32 AudioLoad_RelocateFontAndPreloadSamples(s32 fontId, u32 fontDataAddr, Sample
     } else {
         D_80146D80 = 0;
     }
+
     gNumUsedSamples = 0;
     AudioLoad_RelocateFont(fontId, fontDataAddr, relocData);
     size = 0;
+
     for (i = 0; i < gNumUsedSamples; i++) {
         size += ALIGN16(gUsedSamples[i]->size);
     }
@@ -1264,9 +1344,12 @@ s32 AudioLoad_RelocateFontAndPreloadSamples(s32 fontId, u32 fontDataAddr, Sample
             break;
         }
         sample = gUsedSamples[i];
-        //! Bug: Those are assignments, not equality checks.
+#ifdef AVOID_UB
+        sampleRamAddr = NULL;
+#endif
+        //! @bug Those are assignments, not equality checks.
         switch (isAsync) {
-            case 0:
+            case AUDIOLOAD_SYNC:
                 if (sample->medium = relocData->medium1) {
                     sampleRamAddr = AudioHeap_AllocPersistentSampleCache(sample->size, relocData->sampleBankId1,
                                                                          sample->sampleAddr, sample->medium);
@@ -1275,7 +1358,8 @@ s32 AudioLoad_RelocateFontAndPreloadSamples(s32 fontId, u32 fontDataAddr, Sample
                                                                          sample->sampleAddr, sample->medium);
                 }
                 break;
-            case 1:
+
+            case AUDIOLOAD_ASYNC:
                 if (sample->medium = relocData->medium1) {
                     sampleRamAddr = AudioHeap_AllocTemporarySampleCache(sample->size, relocData->sampleBankId1,
                                                                         sample->sampleAddr, sample->medium);
@@ -1285,14 +1369,16 @@ s32 AudioLoad_RelocateFontAndPreloadSamples(s32 fontId, u32 fontDataAddr, Sample
                 }
                 break;
         }
+
         if (sampleRamAddr == NULL) {
             continue;
         }
+
         switch (isAsync) {
-            case 0:
+            case AUDIOLOAD_SYNC:
                 if (sample->medium == MEDIUM_UNK) {
                     AudioLoad_SyncDmaUnkMedium(sample->sampleAddr, sampleRamAddr, sample->size,
-                                               gSampleBankTable->unkMediumParam);
+                                               gSampleBankTable->base.unkMediumParam);
                     sample->sampleAddr = sampleRamAddr;
                     sample->medium = MEDIUM_RAM;
                 } else {
@@ -1301,7 +1387,8 @@ s32 AudioLoad_RelocateFontAndPreloadSamples(s32 fontId, u32 fontDataAddr, Sample
                     sample->medium = MEDIUM_RAM;
                 }
                 break;
-            case 1:
+
+            case AUDIOLOAD_ASYNC:
                 size = gPreloadSampleStackTop;
                 gPreloadSampleStack[size].sample = sample;
                 gPreloadSampleStack[size].ramAddr = sampleRamAddr;
@@ -1313,7 +1400,9 @@ s32 AudioLoad_RelocateFontAndPreloadSamples(s32 fontId, u32 fontDataAddr, Sample
                 break;
         }
     }
+
     gNumUsedSamples = 0;
+
     if ((gPreloadSampleStackTop != 0) && !inProgress) {
         sample = gPreloadSampleStack[gPreloadSampleStackTop - 1].sample;
         nChunks = (sample->size / 0x1000) + 1;
@@ -1323,15 +1412,15 @@ s32 AudioLoad_RelocateFontAndPreloadSamples(s32 fontId, u32 fontDataAddr, Sample
     }
 }
 
-// static char devstr55[] = "Wave Load %d \n";
-// static char devstr56[] = "Total Bg Wave Load %d \n";
-// static char devstr57[] = "Receive %d\n";
+// static const char devstr55[] = "Wave Load %d \n";
+// static const char devstr56[] = "Total Bg Wave Load %d \n";
+// static const char devstr57[] = "Receive %d\n";
 
-static char devstr57[] = "Receive %d\n";
-static char devstr58[] = "============Error: Magic is Broken after loading.\n";
-static char devstr59[] = "Remain DMA: %d\n";
-static char devstr60[] = "N start %d\n";
-static char devstr61[] = "============Error: Magic is Broken: %x\n";
+static const char devstr57[] = "Receive %d\n";
+static const char devstr58[] = "============Error: Magic is Broken after loading.\n";
+static const char devstr59[] = "Remain DMA: %d\n";
+static const char devstr60[] = "N start %d\n";
+static const char devstr61[] = "============Error: Magic is Broken: %x\n";
 
 s32 AudioLoad_ProcessSamplePreloads(s32 resetStatus) {
     Sample* sample;
@@ -1344,11 +1433,11 @@ s32 AudioLoad_ProcessSamplePreloads(s32 resetStatus) {
 
     if (gPreloadSampleStackTop > 0) {
         if (resetStatus != 0) {
-            if (osRecvMesg(&gPreloadSampleQueue, &mesg, 0)) {}
+            if (!MQ_GET_MESG(&gPreloadSampleQueue, &preloadIndex)) {}
             gPreloadSampleStackTop = 0;
             return false;
         }
-        if (osRecvMesg(&gPreloadSampleQueue, &mesg, 0) == -1) {
+        if (!MQ_GET_MESG(&gPreloadSampleQueue, &preloadIndex)) {
             return false;
         }
         preloadIndex = mesg.data32;
@@ -1364,6 +1453,7 @@ s32 AudioLoad_ProcessSamplePreloads(s32 resetStatus) {
             //  "============Error: Magic is Broken after loading.\n"
             gPreloadSampleStack[preloadIndex].isFree = 1;
         }
+
         while (true) {
             if (gPreloadSampleStackTop <= 0) {
                 break;
@@ -1377,6 +1467,7 @@ s32 AudioLoad_ProcessSamplePreloads(s32 resetStatus) {
             sampleAddr = sample->sampleAddr;
             size = sample->size;
             nChunks = (size >> 0xC) + 1;
+
             key = sampleAddr + size + sample->medium;
             if (key != gPreloadSampleStack[gPreloadSampleStackTop - 1].endAndMediumKey) {
                 // "============Error: Magic is Broken: %x\n";
@@ -1408,20 +1499,16 @@ s32 AudioLoad_AddToSampleSet(Sample* sample, s32 numSamples, Sample** sampleSet)
     return numSamples;
 }
 
-static char devstr62[] = "Error: No Handle.\n";
-static char devstr63[] = "Success: %x\n";
+static const char devstr62[] = "Error: No Handle.\n";
+static const char devstr63[] = "Success: %x\n";
 
 s32 AudioLoad_GetSamplesForFont(s32 fontId, Sample** sampleSet) {
     s32 i;
     Drum* drum;
     Instrument* inst;
-    s32 numLoaded;
-    s32 numDrums;
-    s32 numInstruments;
-
-    numLoaded = 0;
-    numDrums = gSoundFontList[fontId].numDrums;
-    numInstruments = gSoundFontList[fontId].numInstruments;
+    s32 numLoaded = 0;
+    s32 numDrums = gSoundFontList[fontId].numDrums;
+    s32 numInstruments = gSoundFontList[fontId].numInstruments;
 
     for (i = 0; i < numDrums; i++) {
         drum = Audio_GetDrum(fontId, i);
@@ -1430,6 +1517,7 @@ s32 AudioLoad_GetSamplesForFont(s32 fontId, Sample** sampleSet) {
         }
         numLoaded = AudioLoad_AddToSampleSet(drum->tunedSample.sample, numLoaded, sampleSet);
     }
+
     for (i = 0; i < numInstruments; i++) {
         inst = Audio_GetInstrument(fontId, i);
         if (inst == NULL) {
@@ -1443,5 +1531,6 @@ s32 AudioLoad_GetSamplesForFont(s32 fontId, Sample** sampleSet) {
         }
         numLoaded = AudioLoad_AddToSampleSet(inst->normalPitchTunedSample.sample, numLoaded, sampleSet);
     }
+
     return numLoaded;
 }