Audio decompiled and WIP custom sample support

6 files changed, 345 insertions, 115 deletions

diff --git a/soh/src/code/audio_heap.c b/soh/src/code/audio_heap.c
index 765fd8b09..84e91d439 100644
--- a/soh/src/code/audio_heap.c
+++ b/soh/src/code/audio_heap.c
@@ -10,6 +10,8 @@ void AudioHeap_DiscardSampleCaches(void);
 void AudioHeap_DiscardSampleBank(s32 sampleBankId);
 void AudioHeap_DiscardSampleBanks(void);
 
+extern bool gUseLegacySD;
+
 f32 func_800DDE20(f32 arg0) {
     return 256.0f * gAudioContext.audioBufferParameters.unkUpdatesPerFrameScaled / arg0;
 }
@@ -1201,7 +1203,11 @@ void AudioHeap_DiscardSampleCacheEntry(SampleCacheEntry* entry) {
     }
 }
 
-void AudioHeap_UnapplySampleCache(SampleCacheEntry* entry, SoundFontSample* sample) {
+void AudioHeap_UnapplySampleCache(SampleCacheEntry* entry, SoundFontSample* sample) 
+{
+    if (!gUseLegacySD)
+        return;
+
     if (sample != NULL) {
         if (sample->sampleAddr == entry->allocatedAddr) {
             sample->sampleAddr = entry->sampleAddr;
diff --git a/soh/src/code/audio_load.c b/soh/src/code/audio_load.c
index 7af9037a6..ecb6eab2d 100644
--- a/soh/src/code/audio_load.c
+++ b/soh/src/code/audio_load.c
@@ -4,6 +4,7 @@
 
 #include "ultra64.h"
 #include "global.h"
+#include "soh/OTRGlobals.h"
 
 #define MK_ASYNC_MSG(retData, tableType, id, status) (((retData) << 24) | ((tableType) << 16) | ((id) << 8) | (status))
 #define ASYNC_TBLTYPE(v) ((u8)(v >> 16))
@@ -37,7 +38,7 @@ void AudioLoad_ProcessAsyncLoads(s32 resetStatus);
 void AudioLoad_ProcessAsyncLoadUnkMedium(AudioAsyncLoad* asyncLoad, s32 resetStatus);
 void AudioLoad_ProcessAsyncLoad(AudioAsyncLoad* asyncLoad, s32 resetStatus);
 void AudioLoad_RelocateFontAndPreloadSamples(s32 fontId, SoundFontData* mem, RelocInfo* relocInfo, s32 temporary);
-void AudioLoad_RelocateSample(SoundFontSound* sound, SoundFontData* mem, RelocInfo* relocInfo);
+void AudioLoad_RelocateSample(SoundFontSound* sound, SoundFontData* mem, RelocInfo* relocInfo, int fontId);
 void AudioLoad_DiscardFont(s32 fontId);
 u32 AudioLoad_TrySyncLoadSampleBank(u32 sampleBankId, u32* outMedium, s32 noLoad);
 void* AudioLoad_SyncLoad(u32 tableType, u32 tableId, s32* didAllocate);
@@ -74,6 +75,11 @@ void* sUnusedHandler = NULL;
 
 s32 gAudioContextInitalized = false;
 
+uintptr_t fontStart;
+uint32_t fontOffsets[8192];
+
+bool gUseLegacySD = false;
+
 void AudioLoad_DecreaseSampleDmaTtls(void) {
     u32 i;
 
@@ -278,8 +284,11 @@ void AudioLoad_InitSampleDmaBuffers(s32 arg0) {
 }
 
 s32 AudioLoad_IsFontLoadComplete(s32 fontId) {
+    return true;
+    
     if (fontId == 0xFF) {
         return true;
+
     } else if (gAudioContext.fontLoadStatus[fontId] >= 2) {
         return true;
     } else if (gAudioContext.fontLoadStatus[AudioLoad_GetRealTableIndex(FONT_TABLE, fontId)] >= 2) {
@@ -352,6 +361,9 @@ void AudioLoad_InitTable(AudioTable* table, uintptr_t romAddr, u16 unkMediumPara
 
     for (i = 0; i < table->numEntries; i++) {
         if ((table->entries[i].size != 0) && (table->entries[i].medium == MEDIUM_CART)) {
+            if (romAddr == fontStart)
+                fontOffsets[i] = table->entries[i].romAddr;
+
             table->entries[i].romAddr += romAddr;
         }
     }
@@ -400,7 +412,8 @@ void AudioLoad_SyncLoadSeqParts(s32 seqId, s32 arg1) {
 s32 AudioLoad_SyncLoadSample(SoundFontSample* sample, s32 fontId) {
     void* sampleAddr;
 
-    if (sample->unk_bit25 == 1) {
+    if (sample->unk_bit25 == 1) 
+    {
         if (sample->medium != MEDIUM_RAM) {
             sampleAddr = AudioHeap_AllocSampleCache(sample->size, fontId, (void*)sample->sampleAddr, sample->medium,
                                                     CACHE_PERSISTENT);
@@ -544,7 +557,7 @@ s32 AudioLoad_SyncInitSeqPlayerInternal(s32 playerIdx, s32 seqId, s32 arg2) {
     s32 numFonts;
     s32 fontId;
 
-    if (seqId >= gAudioContext.numSequences) {
+    if (gUseLegacySD && seqId >= gAudioContext.numSequences) {
         return 0;
     }
 
@@ -556,18 +569,27 @@ s32 AudioLoad_SyncInitSeqPlayerInternal(s32 playerIdx, s32 seqId, s32 arg2) {
 
     while (numFonts > 0) {
         fontId = gAudioContext.sequenceFontTable[index++];
-        AudioLoad_SyncLoadFont(fontId);
+        
+        //if (gUseLegacySD)
+            AudioLoad_SyncLoadFont(fontId);
+        
         numFonts--;
     }
 
     seqData = AudioLoad_SyncLoadSeq(seqId);
+    
     if (seqData == NULL) {
         return 0;
     }
 
     AudioSeq_ResetSequencePlayer(seqPlayer);
     seqPlayer->seqId = seqId;
-    seqPlayer->defaultFont = AudioLoad_GetRealTableIndex(FONT_TABLE, fontId);
+    
+    if (gUseLegacySD)
+        seqPlayer->defaultFont = AudioLoad_GetRealTableIndex(FONT_TABLE, fontId);
+    else
+        seqPlayer->defaultFont = fontId;
+
     seqPlayer->seqData = seqData;
     seqPlayer->enabled = 1;
     seqPlayer->scriptState.pc = seqData;
@@ -633,12 +655,22 @@ SoundFontData* AudioLoad_SyncLoadFont(u32 fontId) {
     s32 didAllocate;
     RelocInfo relocInfo;
     s32 realFontId = AudioLoad_GetRealTableIndex(FONT_TABLE, fontId);
+    //s32 realFontId = fontId;
 
     if (gAudioContext.fontLoadStatus[realFontId] == 1) {
         return NULL;
     }
-    sampleBankId1 = gAudioContext.soundFonts[realFontId].sampleBankId1;
-    sampleBankId2 = gAudioContext.soundFonts[realFontId].sampleBankId2;
+
+    if (!gUseLegacySD) {
+        SoundFont* sf = ResourceMgr_LoadAudioSoundFont(fontId);
+
+        sampleBankId1 = sf->sampleBankId1;
+        sampleBankId2 = sf->sampleBankId2;
+    } else {
+
+        sampleBankId1 = gAudioContext.soundFonts[realFontId].sampleBankId1;
+        sampleBankId2 = gAudioContext.soundFonts[realFontId].sampleBankId2;
+    }
 
     relocInfo.sampleBankId1 = sampleBankId1;
     relocInfo.sampleBankId2 = sampleBankId2;
@@ -681,13 +713,39 @@ void* AudioLoad_SyncLoad(u32 tableType, u32 id, s32* didAllocate) {
     if (ret != NULL) {
         *didAllocate = false;
         status = 2;
-    } else {
-        table = AudioLoad_GetLoadTable(tableType);
-        size = table->entries[realId].size;
-        size = ALIGN16(size);
-        medium = table->entries[id].medium;
-        cachePolicy = table->entries[id].cachePolicy;
-        romAddr = table->entries[realId].romAddr;
+    } else 
+    {
+        char* seqData = 0;
+        SoundFont* fnt;
+
+        if (!gUseLegacySD && tableType == SEQUENCE_TABLE)
+        {
+            seqData = ResourceMgr_LoadSeqByID(id);
+            size = ResourceMgr_GetSeqSizeByID(id);
+            size -= 2;
+            medium = seqData[0];
+            cachePolicy = seqData[1];
+            romAddr = 0;
+            seqData += 2;
+        } 
+        else if (!gUseLegacySD && tableType == FONT_TABLE) 
+        {
+            fnt = ResourceMgr_LoadAudioSoundFont(id);
+            size = sizeof(SoundFont);
+            medium = 2;
+            cachePolicy = 0;
+            romAddr = 0;
+        }
+        else 
+        {
+            table = AudioLoad_GetLoadTable(tableType);
+            size = table->entries[realId].size;
+            size = ALIGN16(size);
+            medium = table->entries[id].medium;
+            cachePolicy = table->entries[id].cachePolicy;
+            romAddr = table->entries[realId].romAddr;
+        }
+
         switch (cachePolicy) {
             case 0:
                 ret = AudioHeap_AllocPermanent(tableType, realId, size);
@@ -720,7 +778,14 @@ void* AudioLoad_SyncLoad(u32 tableType, u32 id, s32* didAllocate) {
         if (medium == MEDIUM_UNK) {
             AudioLoad_SyncDmaUnkMedium(romAddr, ret, size, (s16)table->unkMediumParam);
         } else {
-            AudioLoad_SyncDma(romAddr, ret, size, medium);
+            if (!gUseLegacySD && tableType == SEQUENCE_TABLE && seqData != NULL) {
+                AudioLoad_SyncDma(seqData, ret, size, medium);
+            } else if (!gUseLegacySD && tableType == FONT_TABLE) {
+                AudioLoad_SyncDma(fnt, ret, size, medium);
+            }
+            else {
+                AudioLoad_SyncDma(romAddr, ret, size, medium);
+            }
         }
 
         status = cachePolicy == 0 ? 5 : 2;
@@ -743,9 +808,16 @@ void* AudioLoad_SyncLoad(u32 tableType, u32 id, s32* didAllocate) {
     return ret;
 }
 
-u32 AudioLoad_GetRealTableIndex(s32 tableType, u32 id) {
+u32 AudioLoad_GetRealTableIndex(s32 tableType, u32 id) 
+{
+    if ((tableType == SEQUENCE_TABLE || tableType == FONT_TABLE) && !gUseLegacySD) {
+        return id;
+    }
+
     AudioTable* table = AudioLoad_GetLoadTable(tableType);
 
+    // If the size is 0, then this entry actually redirects to another entry. 
+    // The rom address is actually an index into the same table where the "real" data is.
     if (table->entries[id].size == 0) {
         id = table->entries[id].romAddr;
     }
@@ -796,29 +868,63 @@ void AudioLoad_RelocateFont(s32 fontId, SoundFontData* mem, RelocInfo* relocInfo
     Drum* drum;
     SoundFontSound* sfx;
     s32 i;
-    s32 numDrums = gAudioContext.soundFonts[fontId].numDrums;
-    s32 numInstruments = gAudioContext.soundFonts[fontId].numInstruments;
-    s32 numSfx = gAudioContext.soundFonts[fontId].numSfx;
+    SoundFont* sf = ResourceMgr_LoadAudioSoundFont(fontId);
+
+    s32 numDrums = 0;
+    s32 numInstruments = 0;
+    s32 numSfx = 0;
+
+    if (gUseLegacySD) {
+        numDrums = gAudioContext.soundFonts[fontId].numDrums;
+        numInstruments = gAudioContext.soundFonts[fontId].numInstruments;
+        numSfx = gAudioContext.soundFonts[fontId].numSfx;
+    } else {
+        numDrums = sf->numDrums;
+        numInstruments = sf->numInstruments;
+        numSfx = sf->numSfx;
+    }    
+
     void** ptrs = (void**)mem;
 
+
 #define BASE_OFFSET(x) (void*)((u32)(x) + (u32)(mem))
 
     reloc2 = ptrs[0];
     if (1) {}
-    if ((reloc2 != 0) && (numDrums != 0)) {
+    if ((reloc2 != 0 || !gUseLegacySD) && (numDrums != 0)) 
+    {
         ptrs[0] = BASE_OFFSET(reloc2);
-        for (i = 0; i < numDrums; i++) {
-            reloc = ((Drum**)ptrs[0])[i];
-
-            if (reloc != 0) {
-                reloc = BASE_OFFSET(reloc);
-
-                ((Drum**)ptrs[0])[i] = drum = reloc;
-                if (!drum->loaded) {
-                    AudioLoad_RelocateSample(&drum->sound, mem, relocInfo);
-                    reloc = drum->envelope;
-                    drum->envelope = BASE_OFFSET(reloc);
-                    drum->loaded = 1;
+        for (i = 0; i < numDrums; i++) 
+        {
+            if (gUseLegacySD)
+                reloc = ((Drum**)ptrs[0])[i];
+
+            if (reloc != 0 || !gUseLegacySD) 
+            {
+                if (gUseLegacySD) 
+                {
+                    reloc = BASE_OFFSET(reloc);
+                    ((Drum**)ptrs[0])[i] = drum = reloc;
+                }
+
+                if (!gUseLegacySD)
+                    drum = sf->drums[i];
+
+                if (!drum->loaded) 
+                {
+                    if (!gUseLegacySD) 
+                    {
+                        AudioLoad_RelocateSample(&sf->drums[i]->sound, mem, relocInfo, fontOffsets[fontId]);
+                        //reloc = drum->envelope;
+                        drum->loaded = 1;
+                    } 
+                    else 
+                    {
+                        AudioLoad_RelocateSample(&drum->sound, mem, relocInfo, fontOffsets[fontId]);
+                        reloc = drum->envelope;
+                        drum->envelope = BASE_OFFSET(reloc);
+                        drum->loaded = 1;
+                    }
                 }
             }
         }
@@ -826,39 +932,56 @@ void AudioLoad_RelocateFont(s32 fontId, SoundFontData* mem, RelocInfo* relocInfo
 
     reloc2 = ptrs[1];
     if (1) {}
-    if ((reloc2 != 0) && (numSfx != 0)) {
+    if ((reloc2 != 0 || !gUseLegacySD) && (numSfx != 0)) {
         ptrs[1] = BASE_OFFSET(reloc2);
         for (i = 0; i < numSfx; i++) {
             reloc = (SoundFontSound*)ptrs[1] + i;
-            if (reloc != 0) {
-                sfx = reloc;
-                if (sfx->sample != NULL) {
-                    AudioLoad_RelocateSample(sfx, mem, relocInfo);
+            if (reloc != 0 || !gUseLegacySD) 
+            {
+                if (!gUseLegacySD) {
+                    AudioLoad_RelocateSample(&sf->soundEffects[i].sample, mem, relocInfo, fontOffsets[fontId]);
+                } else {
+                    sfx = reloc;
+                    if (sfx->sample != NULL) {
+                        AudioLoad_RelocateSample(sfx, mem, relocInfo, fontOffsets[fontId]);
+                    }
                 }
             }
         }
     }
-
+    
     if (numInstruments > 0x7E) {
         numInstruments = 0x7E;
     }
 
-    for (i = 2; i <= 2 + numInstruments - 1; i++) {
-        if (ptrs[i] != NULL) {
+    int startI = gUseLegacySD ? 2 : 0;
+    int startEC = gUseLegacySD ? 2 + numInstruments - 1 : numInstruments - 1;
+    //for (i = 2; i <= 2 + numInstruments - 1; i++) {
+    for (i = startI; i <= startEC; i++) {
+        if (!gUseLegacySD || ptrs[i] != NULL) 
+        {
             ptrs[i] = BASE_OFFSET(ptrs[i]);
 
-            inst = ptrs[i];
-            if (!inst->loaded) {
-                if (inst->normalRangeLo != 0) {
-                    AudioLoad_RelocateSample(&inst->lowNotesSound, mem, relocInfo);
+            if (gUseLegacySD)
+                inst = ptrs[i];
+            else
+                inst = sf->instruments[i];
+            
+            if (inst != NULL && !inst->loaded) {
+                if (inst->normalRangeLo != 0) 
+                {
+                    AudioLoad_RelocateSample(&inst->lowNotesSound, mem, relocInfo, fontOffsets[fontId]);
                 }
-                AudioLoad_RelocateSample(&inst->normalNotesSound, mem, relocInfo);
+                AudioLoad_RelocateSample(&inst->normalNotesSound, mem, relocInfo, fontOffsets[fontId]);
                 if (inst->normalRangeHi != 0x7F) {
-                    AudioLoad_RelocateSample(&inst->highNotesSound, mem, relocInfo);
+                    AudioLoad_RelocateSample(&inst->highNotesSound, mem, relocInfo, fontOffsets[fontId]);
                 }
 
                 reloc = inst->envelope;
-                inst->envelope = BASE_OFFSET(reloc);
+                
+                if (gUseLegacySD)
+                    inst->envelope = BASE_OFFSET(reloc);
+                
                 inst->loaded = 1;
             }
         }
@@ -866,9 +989,11 @@ void AudioLoad_RelocateFont(s32 fontId, SoundFontData* mem, RelocInfo* relocInfo
 
 #undef BASE_OFFSET
 
-    gAudioContext.soundFonts[fontId].drums = ptrs[0];
-    gAudioContext.soundFonts[fontId].soundEffects = ptrs[1];
-    gAudioContext.soundFonts[fontId].instruments = (Instrument**)(ptrs + 2);
+    if (gUseLegacySD) {
+        gAudioContext.soundFonts[fontId].drums = ptrs[0];
+        gAudioContext.soundFonts[fontId].soundEffects = ptrs[1];
+        gAudioContext.soundFonts[fontId].instruments = (Instrument**)(ptrs + 2);
+    }
 }
 
 void AudioLoad_SyncDma(u32 devAddr, u8* addr, size_t size, s32 medium) {
@@ -1270,17 +1395,21 @@ void AudioLoad_Init(void* heap, u32 heapSize) {
     uintptr_t bankStart = ResourceMgr_LoadFileRaw(_AudiobankSegmentRomStart);
     uintptr_t tableStart = ResourceMgr_LoadFileRaw(_AudiotableSegmentRomStart);
 
+    fontStart = bankStart;
+
     AudioLoad_InitTable(gAudioContext.sequenceTable, seqStart, 0);
     AudioLoad_InitTable(gAudioContext.soundFontTable, bankStart, 0);
     AudioLoad_InitTable(gAudioContext.sampleBankTable, tableStart, 0);
     numFonts = gAudioContext.soundFontTable->numEntries;
     gAudioContext.soundFonts = AudioHeap_Alloc(&gAudioContext.audioInitPool, numFonts * sizeof(SoundFont));
 
-    for (i = 0; i < numFonts; i++) {
-        AudioLoad_InitSoundFontMeta(i);
-    }
+    if (gUseLegacySD) {
+        for (i = 0; i < numFonts; i++) {
+            AudioLoad_InitSoundFontMeta(i);
+        }
 
-    AudioLoad_InitSwapFont();
+        AudioLoad_InitSwapFont();
+    }
 
     if (temp_v0_3 = AudioHeap_Alloc(&gAudioContext.audioInitPool, D_8014A6C4.permanentPoolSize), temp_v0_3 == NULL) {
         // cast away const from D_8014A6C4
@@ -1454,28 +1583,40 @@ s32 AudioLoad_SlowLoadSeq(s32 seqId, u8* ramAddr, s8* isDone) {
     AudioTable* seqTable;
     size_t size;
 
-    if (seqId >= gAudioContext.numSequences) {
+    if (gUseLegacySD && seqId >= gAudioContext.numSequences) {
         *isDone = 0;
         return -1;
     }
 
     seqId = AudioLoad_GetRealTableIndex(SEQUENCE_TABLE, seqId);
+    
     seqTable = AudioLoad_GetLoadTable(SEQUENCE_TABLE);
+    
     slowLoad = &gAudioContext.slowLoads[gAudioContext.slowLoadPos];
     if (slowLoad->status == LOAD_STATUS_DONE) {
         slowLoad->status = LOAD_STATUS_WAITING;
     }
 
+
     slowLoad->sample.sampleAddr = NULL;
     slowLoad->isDone = isDone;
-    size = seqTable->entries[seqId].size;
-    size = ALIGN16(size);
+
+    if (!gUseLegacySD) {
+        char* seqData = ResourceMgr_LoadSeqByID(seqId);
+        size = ResourceMgr_GetSeqSizeByID(seqId) - 2;
+        slowLoad->curDevAddr = seqData + 2;
+        slowLoad->medium = seqData[0];
+    } else {
+        size = seqTable->entries[seqId].size;
+        size = ALIGN16(size);
+        slowLoad->curDevAddr = seqTable->entries[seqId].romAddr;
+        slowLoad->medium = seqTable->entries[seqId].medium;
+    }
+
     slowLoad->curRamAddr = ramAddr;
     slowLoad->status = LOAD_STATUS_START;
     slowLoad->bytesRemaining = size;
     slowLoad->ramAddr = ramAddr;
-    slowLoad->curDevAddr = seqTable->entries[seqId].romAddr;
-    slowLoad->medium = seqTable->entries[seqId].medium;
     slowLoad->seqOrFontId = seqId;
 
     if (slowLoad->medium == MEDIUM_UNK) {
@@ -1687,7 +1828,7 @@ void AudioLoad_AsyncDmaUnkMedium(u32 devAddr, void* ramAddr, size_t size, s16 ar
 
 #define RELOC(v, base) (reloc = (void*)((u32)(v) + (u32)(base)))
 
-void AudioLoad_RelocateSample(SoundFontSound* sound, SoundFontData* mem, RelocInfo* relocInfo) {
+void AudioLoad_RelocateSample(SoundFontSound* sound, SoundFontData* mem, RelocInfo* relocInfo, int fontId) {
     // OTRTODO: This is hack to detect whether or not the sample has been relocated.
     size_t maxSoundBankSize = 0x3EB2A0; // sample bank 0 is largest size at 0x3EB2A0
     if ((uintptr_t)mem <= maxSoundBankSize) {
@@ -1699,32 +1840,58 @@ void AudioLoad_RelocateSample(SoundFontSound* sound, SoundFontData* mem, RelocIn
     void* reloc;
 
     // OTRTODO: Seems precarious to assume the RAM is never <= 0x3EB2A0, but it largely works.
-    if ((uintptr_t)sound->sample < maxSoundBankSize) {
-        sample = sound->sample = RELOC(sound->sample, mem);
-        if (sample->size != 0 && sample->unk_bit25 != 1) {
-            sample->loop = RELOC(sample->loop, mem);
-            sample->book = RELOC(sample->book, mem);
-
-            // Resolve the sample medium 2-bit bitfield into a real value based on relocInfo.
-            switch (sample->medium) {
-                case 0:
-                    sample->sampleAddr = RELOC(sample->sampleAddr, relocInfo->baseAddr1);
-                    sample->medium = relocInfo->medium1;
-                    break;
-                case 1:
-                    sample->sampleAddr = RELOC(sample->sampleAddr, relocInfo->baseAddr2);
-                    sample->medium = relocInfo->medium2;
-                    break;
-                case 2:
-                case 3:
-                    // Invalid? This leaves sample->medium as MEDIUM_CART and MEDIUM_DISK_DRIVE
-                    // respectively, and the sampleAddr unrelocated.
-                    break;
+    if ((uintptr_t)sound->sample < maxSoundBankSize || !gUseLegacySD) 
+    {
+        if (!gUseLegacySD) {
+            SoundFontSample* sample2 = sound;
+
+            if (sample2->unk_bit25 != 1) 
+            {
+                //if (sample2->size == 0x5CC8) 
+                //{
+                //   switch (sample2->medium) {
+                //        case 0:
+                //            sample2->medium = relocInfo->medium1;
+                //            break;
+                //        case 1:
+                //            sample2->medium = relocInfo->medium2;
+                //            break;
+                //    }
+
+                //    sample2->unk_bit25 = 1;
+                //    if (sample2->unk_bit26 && (sample2->medium != MEDIUM_RAM)) {
+                //        // gAudioContext.usedSamples[gAudioContext.numUsedSamples++] = sample2;
+                //    }
+                //}
             }
+        } else {
+            sample = sound->sample = RELOC(sound->sample, mem);
+
+            if (sample->size != 0 && sample->unk_bit25 != 1) {
+                sample->loop = RELOC(sample->loop, mem);
+                sample->book = RELOC(sample->book, mem);
+
+                // Resolve the sample medium 2-bit bitfield into a real value based on relocInfo.
+                switch (sample->medium) {
+                    case 0:
+                        sample->sampleAddr = RELOC(sample->sampleAddr, relocInfo->baseAddr1);
+                        sample->medium = relocInfo->medium1;
+                        break;
+                    case 1:
+                        sample->sampleAddr = RELOC(sample->sampleAddr, relocInfo->baseAddr2);
+                        sample->medium = relocInfo->medium2;
+                        break;
+                    case 2:
+                    case 3:
+                        // Invalid? This leaves sample->medium as MEDIUM_CART and MEDIUM_DISK_DRIVE
+                        // respectively, and the sampleAddr unrelocated.
+                        break;
+                }
 
-            sample->unk_bit25 = 1;
-            if (sample->unk_bit26 && (sample->medium != MEDIUM_RAM)) {
-                gAudioContext.usedSamples[gAudioContext.numUsedSamples++] = sample;
+                sample->unk_bit25 = 1;
+                if (sample->unk_bit26 && (sample->medium != MEDIUM_RAM)) {
+                    gAudioContext.usedSamples[gAudioContext.numUsedSamples++] = sample;
+                }
             }
         }
     }
@@ -1977,9 +2144,17 @@ void AudioLoad_PreloadSamplesForFont(s32 fontId, s32 async, RelocInfo* relocInfo
 
     gAudioContext.numUsedSamples = 0;
 
-    numDrums = gAudioContext.soundFonts[fontId].numDrums;
-    numInstruments = gAudioContext.soundFonts[fontId].numInstruments;
-    numSfx = gAudioContext.soundFonts[fontId].numSfx;
+    if (!gUseLegacySD) {
+        SoundFont* sf = ResourceMgr_LoadAudioSoundFont(fontId);
+
+        numDrums = sf->numDrums;
+        numInstruments = sf->numInstruments;
+        numSfx = sf->numSfx;
+    } else {
+        numDrums = gAudioContext.soundFonts[fontId].numDrums;
+        numInstruments = gAudioContext.soundFonts[fontId].numInstruments;
+        numSfx = gAudioContext.soundFonts[fontId].numSfx;
+    }
 
     for (i = 0; i < numInstruments; i++) {
         instrument = Audio_GetInstrumentInner(fontId, i);
@@ -2024,6 +2199,7 @@ void AudioLoad_PreloadSamplesForFont(s32 fontId, s32 async, RelocInfo* relocInfo
         }
 
         sample = gAudioContext.usedSamples[i];
+
         if (sample->medium == MEDIUM_RAM) {
             continue;
         }
@@ -2100,10 +2276,19 @@ void AudioLoad_LoadPermanentSamples(void) {
     for (i = 0; i < gAudioContext.permanentPool.count; i++) {
         RelocInfo relocInfo;
 
-        if (gAudioContext.permanentCache[i].tableType == FONT_TABLE) {
+        if (gAudioContext.permanentCache[i].tableType == FONT_TABLE) 
+        {
             fontId = AudioLoad_GetRealTableIndex(FONT_TABLE, gAudioContext.permanentCache[i].id);
-            relocInfo.sampleBankId1 = gAudioContext.soundFonts[fontId].sampleBankId1;
-            relocInfo.sampleBankId2 = gAudioContext.soundFonts[fontId].sampleBankId2;
+            //fontId = gAudioContext.permanentCache[i].id;
+            
+            if (!gUseLegacySD) {
+                SoundFont* sf = ResourceMgr_LoadAudioSoundFont(fontId);
+                relocInfo.sampleBankId1 = sf->sampleBankId1;
+                relocInfo.sampleBankId2 = sf->sampleBankId2;
+            } else {
+                relocInfo.sampleBankId1 = gAudioContext.soundFonts[fontId].sampleBankId1;
+                relocInfo.sampleBankId2 = gAudioContext.soundFonts[fontId].sampleBankId2;
+            }
 
             if (relocInfo.sampleBankId1 != 0xFF) {
                 relocInfo.sampleBankId1 = AudioLoad_GetRealTableIndex(SAMPLE_TABLE, relocInfo.sampleBankId1);
diff --git a/soh/src/code/audio_playback.c b/soh/src/code/audio_playback.c
index c116b4ddb..5d43118b8 100644
--- a/soh/src/code/audio_playback.c
+++ b/soh/src/code/audio_playback.c
@@ -1,6 +1,8 @@
 #include "global.h"
 #include "Cvar.h"
 
+extern bool gUseLegacySD;
+
 void Audio_InitNoteSub(Note* note, NoteSubEu* sub, NoteSubAttributes* attrs) {
     f32 volRight, volLeft;
     s32 smallPanIndex;
@@ -307,7 +309,7 @@ SoundFontSound* Audio_InstrumentGetSound(Instrument* instrument, s32 semitone) {
 
 Instrument* Audio_GetInstrumentInner(s32 fontId, s32 instId) {
     Instrument* inst;
-
+    
     if (fontId == 0xFF) {
         return NULL;
     }
@@ -317,16 +319,31 @@ Instrument* Audio_GetInstrumentInner(s32 fontId, s32 instId) {
         return NULL;
     }
 
-    if (instId >= gAudioContext.soundFonts[fontId].numInstruments) {
-        gAudioContext.audioErrorFlags = ((fontId << 8) + instId) + 0x3000000;
-        return NULL;
+    int instCnt = 0;
+
+    if (gUseLegacySD) {
+        instCnt = gAudioContext.soundFonts[fontId].numInstruments;
+        inst = gAudioContext.soundFonts[fontId].instruments[instId];
+
+        if (instId >= gAudioContext.soundFonts[fontId].numInstruments)
+            if (instId >= instCnt) {
+                gAudioContext.audioErrorFlags = ((fontId << 8) + instId) + 0x3000000;
+                return NULL;
+            }
+    } else {
+        SoundFont* sf = ResourceMgr_LoadAudioSoundFont(fontId);
+
+        if (instId >= sf->numInstruments)
+            return NULL;
+
+        inst = sf->instruments[instId];
     }
 
-    inst = gAudioContext.soundFonts[fontId].instruments[instId];
     if (inst == NULL) {
         gAudioContext.audioErrorFlags = ((fontId << 8) + instId) + 0x1000000;
         return inst;
     }
+    
 
     return inst;
 }
@@ -343,12 +360,17 @@ Drum* Audio_GetDrum(s32 fontId, s32 drumId) {
         return NULL;
     }
 
-    if (drumId >= gAudioContext.soundFonts[fontId].numDrums) {
-        gAudioContext.audioErrorFlags = ((fontId << 8) + drumId) + 0x4000000;
-        return NULL;
-    }
+    if (gUseLegacySD) {
+         if (drumId >= gAudioContext.soundFonts[fontId].numDrums) {
+         gAudioContext.audioErrorFlags = ((fontId << 8) + drumId) + 0x4000000;
+         return NULL;
+        }
 
-    drum = gAudioContext.soundFonts[fontId].drums[drumId];
+         drum = gAudioContext.soundFonts[fontId].drums[drumId];
+    } else {
+        SoundFont* sf = ResourceMgr_LoadAudioSoundFont(fontId);
+        drum = sf->drums[drumId];
+    }
 
     if (drum == NULL) {
         gAudioContext.audioErrorFlags = ((fontId << 8) + drumId) + 0x5000000;
@@ -369,12 +391,17 @@ SoundFontSound* Audio_GetSfx(s32 fontId, s32 sfxId) {
         return NULL;
     }
 
-    if (sfxId >= gAudioContext.soundFonts[fontId].numSfx) {
-        gAudioContext.audioErrorFlags = ((fontId << 8) + sfxId) + 0x4000000;
-        return NULL;
-    }
+    if (gUseLegacySD) {
+         if (sfxId >= gAudioContext.soundFonts[fontId].numSfx) {
+         gAudioContext.audioErrorFlags = ((fontId << 8) + sfxId) + 0x4000000;
+         return NULL;
+        }
 
-    sfx = &gAudioContext.soundFonts[fontId].soundEffects[sfxId];
+         sfx = &gAudioContext.soundFonts[fontId].soundEffects[sfxId];
+    } else {
+        SoundFont* sf = ResourceMgr_LoadAudioSoundFont(fontId);
+        sfx = &sf->soundEffects[sfxId];
+    }
 
     if (sfx == NULL) {
         gAudioContext.audioErrorFlags = ((fontId << 8) + sfxId) + 0x5000000;
diff --git a/soh/src/code/audio_seqplayer.c b/soh/src/code/audio_seqplayer.c
index 3dd7b811e..52d14a9a1 100644
--- a/soh/src/code/audio_seqplayer.c
+++ b/soh/src/code/audio_seqplayer.c
@@ -938,8 +938,16 @@ u8 AudioSeq_GetInstrument(SequenceChannel* channel, u8 instId, Instrument** inst
         *instOut = NULL;
         return 0;
     }
-    adsr->envelope = inst->envelope;
-    adsr->releaseRate = inst->releaseRate;
+
+    if (inst->envelope != NULL) 
+    {
+        adsr->envelope = inst->envelope;
+        adsr->releaseRate = (inst->releaseRate);
+    }
+    else {
+        adsr->envelope = gDefaultEnvelope;
+    }
+
     *instOut = inst;
     instId += 2;
     return instId;
diff --git a/soh/src/code/audio_synthesis.c b/soh/src/code/audio_synthesis.c
index 037bd2ec3..b567dd0ef 100644
--- a/soh/src/code/audio_synthesis.c
+++ b/soh/src/code/audio_synthesis.c
@@ -749,8 +749,10 @@ Acmd* AudioSynth_ProcessNote(s32 noteIndex, NoteSubEu* noteSubEu, NoteSynthesisS
         cmd = AudioSynth_LoadWaveSamples(cmd, noteSubEu, synthState, nSamplesToLoad);
         noteSamplesDmemAddrBeforeResampling = DMEM_UNCOMPRESSED_NOTE + (synthState->samplePosInt * 2);
         synthState->samplePosInt += nSamplesToLoad;
-    } else {
+    } else 
+    {
         audioFontSample = noteSubEu->sound.soundFontSound->sample;
+        
         loopInfo = audioFontSample->loop;
         loopEndPos = loopInfo->end;
         sampleAddr = audioFontSample->sampleAddr;
@@ -822,6 +824,7 @@ Acmd* AudioSynth_ProcessNote(s32 noteIndex, NoteSubEu* noteSubEu, NoteSynthesisS
                         noteFinished = true;
                     }
                 }
+               
 
                 switch (audioFontSample->codec) {
                     case CODEC_ADPCM:
@@ -848,6 +851,9 @@ Acmd* AudioSynth_ProcessNote(s32 noteIndex, NoteSubEu* noteSubEu, NoteSynthesisS
                         goto skip;
                     case CODEC_S16:
                         AudioSynth_ClearBuffer(cmd++, DMEM_UNCOMPRESSED_NOTE, (samplesLenAdjusted * 2) + 0x20);
+                        AudioSynth_LoadBuffer(cmd++, DMEM_UNCOMPRESSED_NOTE, ALIGN16(nSamplesToLoad * 2),
+                                              audioFontSample->sampleAddr + (synthState->samplePosInt * 2));
+                        
                         flags = A_CONTINUE;
                         skipBytes = 0;
                         nSamplesProcessed = samplesLenAdjusted;
@@ -860,7 +866,8 @@ Acmd* AudioSynth_ProcessNote(s32 noteIndex, NoteSubEu* noteSubEu, NoteSynthesisS
                 if (nFramesToDecode != 0) {
                     frameIndex = (synthState->samplePosInt + skipInitialSamples - nFirstFrameSamplesToIgnore) / 16;
                     sampleDataOffset = frameIndex * frameSize;
-                    if (audioFontSample->medium == MEDIUM_RAM) {
+                    if (audioFontSample->medium == MEDIUM_RAM) 
+                    {
                         sampleData = (u8*)(sampleDataStart + sampleDataOffset + sampleAddr);
                     } else if (audioFontSample->medium == MEDIUM_UNK) {
                         return cmd;
@@ -1024,7 +1031,8 @@ Acmd* AudioSynth_ProcessNote(s32 noteIndex, NoteSubEu* noteSubEu, NoteSynthesisS
     unk7 = noteSubEu->unk_07;
     unkE = noteSubEu->unk_0E;
     buf = &synthState->synthesisBuffers->panSamplesBuffer[0x18];
-    if (unk7 != 0 && noteSubEu->unk_0E != 0) {
+    if (unk7 != 0 && noteSubEu->unk_0E != 0) 
+    {
         AudioSynth_DMemMove(cmd++, DMEM_TEMP, DMEM_SCRATCH2, aiBufLen * 2);
         thing = DMEM_SCRATCH2 - unk7;
         if (synthState->unk_1A != 0) {
diff --git a/soh/src/code/code_800E4FE0.c b/soh/src/code/code_800E4FE0.c
index c46ae7a07..d88e731f4 100644
--- a/soh/src/code/code_800E4FE0.c
+++ b/soh/src/code/code_800E4FE0.c
@@ -213,11 +213,7 @@ AudioTask* func_800E5000(void) {
     task = &gAudioContext.currTask->task.t;
     task->type = M_AUDTASK;
     task->flags = 0;
-    //task->ucode_boot = D_801120C0;
     task->ucode_boot_size = 0x1000;
-    //task->ucode_data_size = ((rspAspMainDataEnd - rspAspMainDataStart) * sizeof(u64)) - 1;
-    //task->ucode = D_801120C0;
-    //task->ucode_data = rspAspMainDataStart;
     task->ucode_size = 0x1000;
     task->dram_stack = NULL;
     task->dram_stack_size = 0;