JAUSectionHeap, Z2SoundInfo, others (#1925)

* Z2SoundInfo * JAUSectionHeap * Z2EnvSeMgr * Z2AudioMgr * m_Do_audio * d_a_alink
2026-09-05 02:36:01 -04:00 · 2023-09-15 05:20:09 -07:00
parent f834379a8b
commit 287ae62349
159 changed files with 1349 additions and 1511 deletions
@@ -4,69 +4,70 @@
 //

 #include "JSystem/JAudio2/JAUSectionHeap.h"
+#include "JSystem/JAudio2/JAIStreamDataMgr.h"
+#include "JSystem/JAudio2/JASBNKParser.h"
+#include "JSystem/JAudio2/JASBankTable.h"
+#include "JSystem/JAudio2/JASBasicWaveBank.h"
+#include "JSystem/JAudio2/JASCriticalSection.h"
+#include "JSystem/JAudio2/JASHeapCtrl.h"
+#include "JSystem/JAudio2/JASResArcLoader.h"
+#include "JSystem/JAudio2/JASVoiceBank.h"
+#include "JSystem/JAudio2/JAUSeqCollection.h"
+#include "JSystem/JAudio2/JAUSoundInfo.h"
+#include "JSystem/JAudio2/JAUSoundTable.h"
+#include "JSystem/JAudio2/JAUStreamFileTable.h"
+#include "JSystem/JKernel/JKRSolidHeap.h"
 #include "MSL_C/stdlib.h"
 #include "dol2asm.h"
+#include "dolphin/dvd/dvd.h"

 //
 // Types:
 //

-struct JKRHeap {
-    /* 802CE438 */ void becomeCurrentHeap();
-    /* 802CE5F8 */ void freeTail();
-    /* 802CE72C */ void getFreeSize();
-};
-
-struct JKRSolidHeap {
-    /* 802D0A24 */ void create(u32, JKRHeap*, bool);
-};
-
-struct JKRArchive {};
-
-struct JAUStreamFileTable {
-    /* 802A7420 */ JAUStreamFileTable();
-    /* 802A742C */ void init(void const*);
-    /* 802A7478 */ void getNumFiles() const;
-    /* 802A7484 */ void getFilePath(int) const;
-};
-
-struct JAUSoundTable {
-    /* 802A7114 */ void init(void const*);
-};
-
-struct JAUSoundNameTable {
-    /* 802A73D4 */ void init(void const*);
-};
-
-struct JAUSeqDataMgr_SeqCollection {
-    /* 802A677C */ JAUSeqDataMgr_SeqCollection();
-};
-
-struct JAUSeqCollection {
-    /* 802A66AC */ void init(void const*);
-};
-
-struct JASHeap {};
-
-struct JASWaveArc {
-    /* 8029A4C0 */ void load(JASHeap*);
-};
-
 struct JASWSParser {
-    /* 80298FD8 */ void createWaveBank(void const*, JKRHeap*);
+    /* 80298FD8 */ static JASWaveBank* createWaveBank(void const*, JKRHeap*);
 };

-struct JASResArcLoader {
-    /* 80290BD0 */ void getResSize(JKRArchive const*, u16);
-};
+namespace {
+    class TPushCurrentHeap {
+    public:
+        TPushCurrentHeap(JKRHeap* heap) { mHeap = JKRSetCurrentHeap(heap); }
+        ~TPushCurrentHeap() { JKRSetCurrentHeap(mHeap); }

-struct JASBNKParser {
-    /* 80299538 */ void createBank(void const*, JKRHeap*);
-};
+    private:
+        JKRHeap* mHeap;
+    };

-struct JAIStreamDataMgr {
-    /* 802A3AD8 */ ~JAIStreamDataMgr();
-};
+    class TStreamDataMgr : public JAIStreamDataMgr {
+    public:
+        TStreamDataMgr(const void* param_0) {
+            JAUStreamFileTable stack_14;
+            stack_14.init(param_0);
+            if (!stack_14.isValid()) {
+                field_0x4 = 0;
+                field_0x8 = NULL;
+                return;
+            }
+            field_0x4 = stack_14.getNumFiles();
+            field_0x8 = new s32[field_0x4];
+            if (!field_0x8) {
+                field_0x4 = NULL;
+                return;
+            }
+            for (u32 i = 0; i < field_0x4; i++) {
+                field_0x8[i] = DVDConvertPathToEntrynum(stack_14.getFilePath(i));
+            }
+        }
+        virtual s32 getStreamFileEntry(JAISoundID);
+        virtual ~TStreamDataMgr();
+
+        bool isValid() { return field_0x4; }
+
+        s32 field_0x4;
+        s32* field_0x8;
+    };
+}

 //
 // Forward References:
@@ -122,8 +123,6 @@ extern "C" extern char const* const JAUSectionHeap__stringBase0;
 // External References:
 //

-SECTION_INIT void memset();
-SECTION_INIT void memcpy();
 extern "C" void getResSize__15JASResArcLoaderFPC10JKRArchiveUs();
 extern "C" void createWaveBank__11JASWSParserFPCvP7JKRHeap();
 extern "C" void createBank__12JASBNKParserFPCvP7JKRHeap();
@@ -163,9 +162,6 @@ extern "C" void __dt__10JSUPtrLinkFv();
 extern "C" void __dt__10JSUPtrListFv();
 extern "C" void initiate__10JSUPtrListFv();
 extern "C" void append__10JSUPtrListFP10JSUPtrLink();
-extern "C" void OSDisableInterrupts();
-extern "C" void OSRestoreInterrupts();
-extern "C" void DVDConvertPathToEntrynum();
 extern "C" void _savegpr_26();
 extern "C" void _savegpr_27();
 extern "C" void _savegpr_28();
@@ -174,7 +170,6 @@ extern "C" void _restgpr_26();
 extern "C" void _restgpr_27();
 extern "C" void _restgpr_28();
 extern "C" void _restgpr_29();
-extern "C" void fprintf();
 extern "C" extern void* __vt__11JASBankList[3 + 1 /* padding */];
 extern "C" extern void* __vt__7JASBank[5];
 extern "C" extern void* __vt__12JASVoiceBank[5 + 1 /* padding */];
@@ -186,7 +181,6 @@ extern "C" extern u8 data_80450B54[4];
 extern "C" extern u8 data_80450B58[4];
 extern "C" extern u8 data_80450B90[4 + 4 /* padding */];
 extern "C" extern u8 data_80450CC0[4 + 4 /* padding */];
-extern "C" extern u8 JASDram[4];
 extern "C" extern u8 __OSReport_disable;

 //
@@ -194,6 +188,18 @@ extern "C" extern u8 __OSReport_disable;
 //

 /* 802A4EE8-802A4F68 29F828 0080+00 1/1 0/0 0/0 .text __ct__Q210JAUSection12TSectionDataFv */
+// wild destructors appeared!
+#ifdef NONMATCHING
+JAUSection::TSectionData::TSectionData() {
+    resetRegisteredWaveBankTables();
+    resetRegisteredBankTables();
+    field_0x84 = 0;
+    field_0x88 = 0;
+    field_0x80 = 0;
+    field_0xa0 = 0;
+    field_0x9c = 0;
+}
+#else
 #pragma push
 #pragma optimization_level 0
 #pragma optimizewithasm off
@@ -202,6 +208,7 @@ asm JAUSection::TSectionData::TSectionData() {
 #include "asm/JSystem/JAudio2/JAUSectionHeap/__ct__Q210JAUSection12TSectionDataFv.s"
 }
 #pragma pop
+#endif

 /* ############################################################################################## */
 /* 8039B950-8039B950 027FB0 0000+00 0/0 0/0 0/0 .rodata          @stringBase0 */
@@ -212,6 +219,14 @@ SECTION_DEAD static char const* const stringBase_8039B950 = "index out of range

 /* 802A4F68-802A4FE4 29F8A8 007C+00 1/1 0/0 0/0 .text
 * resetRegisteredBankTables__Q210JAUSection12TSectionDataFv    */
+// position of std::__bitset_base<8>::reset
+#ifdef NONMATCHING
+void JAUSection::TSectionData::resetRegisteredBankTables() {
+    for (u32 i = 0; i < 255; i++) {
+        registeredBankTables.reset(i);
+    }
+}
+#else
 #pragma push
 #pragma optimization_level 0
 #pragma optimizewithasm off
@@ -220,9 +235,18 @@ asm void JAUSection::TSectionData::resetRegisteredBankTables() {
 #include "asm/JSystem/JAudio2/JAUSectionHeap/resetRegisteredBankTables__Q210JAUSection12TSectionDataFv.s"
 }
 #pragma pop
+#endif

 /* 802A4FE4-802A5060 29F924 007C+00 1/1 0/0 0/0 .text
 * resetRegisteredWaveBankTables__Q210JAUSection12TSectionDataFv */
+// position of std::__bitset_base<8>::reset
+#ifdef NONMATCHING
+void JAUSection::TSectionData::resetRegisteredWaveBankTables() {
+    for (u32 i = 0; i < 255; i++) {
+        registeredWaveBankTables.reset(i);
+    }
+}
+#else
 #pragma push
 #pragma optimization_level 0
 #pragma optimizewithasm off
@@ -231,6 +255,7 @@ asm void JAUSection::TSectionData::resetRegisteredWaveBankTables() {
 #include "asm/JSystem/JAudio2/JAUSectionHeap/resetRegisteredWaveBankTables__Q210JAUSection12TSectionDataFv.s"
 }
 #pragma pop
+#endif

 /* ############################################################################################## */
 /* 803C9AC0-803C9AF4 026BE0 0034+00 2/2 0/0 0/0 .data            __vt__14JAUSectionHeap */
@@ -286,6 +311,17 @@ SECTION_DATA extern void* __vt__10JAUSection[4 + 1 /* padding */] = {
 };

 /* 802A5060-802A50F8 29F9A0 0098+00 1/1 0/0 0/0 .text __ct__10JAUSectionFP14JAUSectionHeapUll */
+// JAUSection inheritance
+#ifdef NONMATCHING
+JAUSection::JAUSection(JAUSectionHeap* param_0, u32 param_1, s32 param_2) : JSULink<JAUSection>(this), field_0x28(param_1), sectionHeap_(param_0) {
+    buildingBankTable_ = NULL;
+    field_0x2c = 1;
+    data_.field_0x98 = param_2;
+    if (this != sectionHeap_) {
+        data_.field_0x00.setSeqDataArchive(sectionHeap_->sectionHeapData_.field_0x408.getSeqDataArchive());
+    }
+}
+#else
 #pragma push
 #pragma optimization_level 0
 #pragma optimizewithasm off
@@ -294,110 +330,248 @@ asm JAUSection::JAUSection(JAUSectionHeap* param_0, u32 param_1, s32 param_2) {
 #include "asm/JSystem/JAudio2/JAUSectionHeap/__ct__10JAUSectionFP14JAUSectionHeapUll.s"
 }
 #pragma pop
+#endif

 /* 802A50F8-802A5160 29FA38 0068+00 0/0 1/1 0/0 .text            finishBuild__10JAUSectionFv */
-#pragma push
-#pragma optimization_level 0
-#pragma optimizewithasm off
-asm void JAUSection::finishBuild() {
-    nofralloc
-#include "asm/JSystem/JAudio2/JAUSectionHeap/finishBuild__10JAUSectionFv.s"
+void JAUSection::finishBuild() {
+    JUT_ASSERT("JAUSectionHeap.cpp", 0x8f, isOpen());
+    JUT_ASSERT("JAUSectionHeap.cpp", 0x90, isBuilding());
+    {
+        TPushCurrentHeap push(getHeap_());
+    }
+    data_.field_0x98 -= getHeap_()->getFreeSize();
+    getHeap_()->freeTail();
+    field_0x2c = 0;
 }
-#pragma pop

 /* 802A5160-802A51E4 29FAA0 0084+00 2/0 0/0 0/0 .text            dispose__10JAUSectionFv */
-#pragma push
-#pragma optimization_level 0
-#pragma optimizewithasm off
-asm void JAUSection::dispose() {
-    nofralloc
-#include "asm/JSystem/JAudio2/JAUSectionHeap/dispose__10JAUSectionFv.s"
+void JAUSection::dispose() {
+    JUT_ASSERT("JAUSectionHeap.cpp", 0x10b, ! data_.registeredBankTables.any());
+    JUT_ASSERT("JAUSectionHeap.cpp", 0x10c, ! data_.registeredWaveBankTables.any());
+    if (data_.mBstDst) {
+        sectionHeap_->sectionHeapData_.soundTable->~JAUSoundTable();
+        sectionHeap_->sectionHeapData_.soundTable = NULL;
+    }
+    if ((data_.mBstnDst)) {
+        sectionHeap_->sectionHeapData_.soundNameTable->~JAUSoundNameTable();
+        sectionHeap_->sectionHeapData_.soundNameTable = NULL;
+    }
 }
-#pragma pop

 /* 802A51E4-802A52A0 29FB24 00BC+00 0/0 1/1 0/0 .text            newSoundTable__10JAUSectionFPCvUlb
 */
+// regalloc, stackalloc
+#ifdef NONMATCHING
+JAUSoundTable* JAUSection::newSoundTable(void const* bst, u32 param_1, bool param_2) {
+    JUT_ASSERT("JAUSectionHeap.cpp", 0x11d, isOpen());
+    JUT_ASSERT("JAUSectionHeap.cpp", 0x11e, isBuilding());
+    JUT_ASSERT("JAUSectionHeap.cpp", 0x11f, bst);
+    JUT_ASSERT("JAUSectionHeap.cpp", 0x120, asSectionHeap() == this);
+    JUT_ASSERT("JAUSectionHeap.cpp", 0x121, sectionHeap_->sectionHeapData_.soundTable == 0);
+    {
+        TPushCurrentHeap push(getHeap_());
+        void* bstDst;
+        if (param_1) {
+            bstDst = newCopy(bst, param_1, 4);
+            JUT_ASSERT("JAUSectionHeap.cpp", 0x128, bstDst);
+        }
+        JAUSoundTable* soundTable = new JAUSoundTable(param_2);
+        JUT_ASSERT("JAUSectionHeap.cpp", 299, soundTable);
+        soundTable->init(bst);
+        sectionHeap_->sectionHeapData_.soundTable = soundTable;
+        data_.mBstDst = bstDst;
+    }
+    return sectionHeap_->sectionHeapData_.soundTable;
+}
+#else
 #pragma push
 #pragma optimization_level 0
 #pragma optimizewithasm off
-asm void JAUSection::newSoundTable(void const* param_0, u32 param_1, bool param_2) {
+asm JAUSoundTable* JAUSection::newSoundTable(void const* param_0, u32 param_1, bool param_2) {
    nofralloc
 #include "asm/JSystem/JAudio2/JAUSectionHeap/newSoundTable__10JAUSectionFPCvUlb.s"
 }
 #pragma pop
+#endif

 /* 802A52A0-802A535C 29FBE0 00BC+00 0/0 1/1 0/0 .text newSoundNameTable__10JAUSectionFPCvUlb */
+// regalloc, stackalloc
+#ifdef NONMATCHING
+JAUSoundNameTable* JAUSection::newSoundNameTable(void const* bstn, u32 param_1, bool param_2) {
+    JUT_ASSERT("JAUSectionHeap.cpp", 0x13b, isOpen());
+    JUT_ASSERT("JAUSectionHeap.cpp", 0x13c, isBuilding());
+    JUT_ASSERT("JAUSectionHeap.cpp", 0x13d, bstn);
+    JUT_ASSERT("JAUSectionHeap.cpp", 0x13e, asSectionHeap() == this);
+    JUT_ASSERT("JAUSectionHeap.cpp", 0x13f, sectionHeap_->sectionHeapData_.soundNameTable == 0);
+    {
+        TPushCurrentHeap push(getHeap_());
+        void* bstnDst;
+        if (param_1) {
+            bstnDst = newCopy(bstn, param_1, 4);
+            JUT_ASSERT("JAUSectionHeap.cpp", 0x146, bstnDst);
+        }
+        JAUSoundNameTable* soundNameTable = new JAUSoundNameTable(param_2);
+        JUT_ASSERT("JAUSectionHeap.cpp", 0x149, soundNameTable);
+        soundNameTable->init(bstnDst);
+        sectionHeap_->sectionHeapData_.soundNameTable = soundNameTable;
+        data_.mBstnDst = bstnDst;
+    }
+    return sectionHeap_->sectionHeapData_.soundNameTable;
+}
+#else
 #pragma push
 #pragma optimization_level 0
 #pragma optimizewithasm off
-asm void JAUSection::newSoundNameTable(void const* param_0, u32 param_1, bool param_2) {
+asm JAUSoundNameTable* JAUSection::newSoundNameTable(void const* param_0, u32 param_1, bool param_2) {
    nofralloc
 #include "asm/JSystem/JAudio2/JAUSectionHeap/newSoundNameTable__10JAUSectionFPCvUlb.s"
 }
 #pragma pop
+#endif

 /* 802A535C-802A5500 29FC9C 01A4+00 0/0 1/1 0/0 .text newStreamFileTable__10JAUSectionFPCvb */
+// JAUStreamFileTable::isValid() signed
+#ifdef NONMATCHING
+JAIStreamDataMgr* JAUSection::newStreamFileTable(void const* param_0, bool param_1) {
+    JUT_ASSERT("JAUSectionHeap.cpp", 0x159, asSectionHeap() == this);
+    JUT_ASSERT("JAUSectionHeap.cpp", 0x15a, isOpen());
+    JUT_ASSERT("JAUSectionHeap.cpp", 0x15b, isBuilding());
+    JUT_ASSERT("JAUSectionHeap.cpp", 0x15c, sectionHeap_->sectionHeapData_.streamDataMgr_ == 0);
+    {
+        TPushCurrentHeap push(getHeap_());
+        JAIStreamDataMgr* r28 = NULL;
+        if (param_1) {
+            TStreamDataMgr* r26 = new TStreamDataMgr(param_0);
+            if (r26->isValid()) {
+                r28 = r26;
+            }
+        } else {
+            JAUStreamDataMgr_StreamFileTable* r25 = new JAUStreamDataMgr_StreamFileTable();
+            r25->init(param_0);
+            if (r25->isValid()) {
+                r28 = r25;
+            }
+        }
+        sectionHeap_->sectionHeapData_.streamDataMgr_ = r28;
+    }
+    return sectionHeap_->sectionHeapData_.streamDataMgr_;
+}
+#else
 #pragma push
 #pragma optimization_level 0
 #pragma optimizewithasm off
-asm void JAUSection::newStreamFileTable(void const* param_0, bool param_1) {
+asm JAIStreamDataMgr* JAUSection::newStreamFileTable(void const* param_0, bool param_1) {
    nofralloc
 #include "asm/JSystem/JAudio2/JAUSectionHeap/newStreamFileTable__10JAUSectionFPCvb.s"
 }
 #pragma pop
+#endif

 /* 802A5500-802A5598 29FE40 0098+00 0/0 1/1 0/0 .text newSeSeqCollection__10JAUSectionFPCvUl */
-#pragma push
-#pragma optimization_level 0
-#pragma optimizewithasm off
-asm void JAUSection::newSeSeqCollection(void const* param_0, u32 param_1) {
-    nofralloc
-#include "asm/JSystem/JAudio2/JAUSectionHeap/newSeSeqCollection__10JAUSectionFPCvUl.s"
+JAISeqDataMgr* JAUSection::newSeSeqCollection(void const* bsc, u32 param_1) {
+    JUT_ASSERT("JAUSectionHeap.cpp", 0x18e, asSectionHeap() == this);
+    JUT_ASSERT("JAUSectionHeap.cpp", 399, sectionHeap_->sectionHeapData_.seSeqDataMgr_ == 0);
+    if (param_1) {
+        bsc = newCopy(bsc, param_1, 4);
+    }
+    JUT_ASSERT("JAUSectionHeap.cpp", 0x195, "bsc");
+    {
+        TPushCurrentHeap push(getHeap_());
+        JAUSeqDataMgr_SeqCollection* seSeqDataMgr = new JAUSeqDataMgr_SeqCollection();
+        JUT_ASSERT("JAUSectionHeap.cpp", 0x199, seSeqDataMgr);
+        seSeqDataMgr->init(bsc);
+        sectionHeap_->sectionHeapData_.seSeqDataMgr_ = seSeqDataMgr;
+        data_.field_0x80 = seSeqDataMgr;
+    }
+    return sectionHeap_->sectionHeapData_.seSeqDataMgr_;
 }
-#pragma pop

 /* 802A5598-802A56C8 29FED8 0130+00 2/2 0/0 0/0 .text
 * newStaticSeqDataBlock___10JAUSectionF10JAISoundIDUl          */
-#pragma push
-#pragma optimization_level 0
-#pragma optimizewithasm off
-asm void JAUSection::newStaticSeqDataBlock_(JAISoundID param_0, u32 param_1) {
-    nofralloc
-#include "asm/JSystem/JAudio2/JAUSectionHeap/newStaticSeqDataBlock___10JAUSectionF10JAISoundIDUl.s"
+u8* JAUSection::newStaticSeqDataBlock_(JAISoundID param_0, u32 size) {
+    JUT_ASSERT("JAUSectionHeap.cpp", 0x1a3, isOpen());
+    JUT_ASSERT("JAUSectionHeap.cpp", 0x1a4, isBuilding());
+    JUT_ASSERT("JAUSectionHeap.cpp", 0x1a5, size);
+    {
+        TPushCurrentHeap push(getHeap_());
+        JAUSeqDataBlock* seqDataBlock = new JAUSeqDataBlock();
+        if (!seqDataBlock) {
+            return NULL;
+        }
+        JSULink<JAUSeqDataBlock>* link = new JSULink<JAUSeqDataBlock>(seqDataBlock);
+        if (!link) {
+            return NULL;
+        }
+        u8* r28 = new(0x20) u8[size];
+        if (!r28) {
+            return NULL;
+        }
+        seqDataBlock->field_0x14 = r28;
+        seqDataBlock->field_0x18 = size;
+        seqDataBlock->field_0x10 = param_0;
+        JASCriticalSection cs;
+        if(data_.field_0x00.appendDynamicSeqDataBlock(seqDataBlock)) {
+            data_.field_0x28.append(link);
+            return r28;
+        }
+    }
+    return NULL;
 }
-#pragma pop

 /* 802A56C8-802A5730 2A0008 0068+00 0/0 1/1 0/0 .text
 * newStaticSeqData__10JAUSectionF10JAISoundIDPCvUl             */
-#pragma push
-#pragma optimization_level 0
-#pragma optimizewithasm off
-asm void JAUSection::newStaticSeqData(JAISoundID param_0, void const* param_1, u32 param_2) {
-    nofralloc
-#include "asm/JSystem/JAudio2/JAUSectionHeap/newStaticSeqData__10JAUSectionF10JAISoundIDPCvUl.s"
+bool JAUSection::newStaticSeqData(JAISoundID param_0, void const* param_1, u32 param_2) {
+    u8* r30 = newStaticSeqDataBlock_(param_0, param_2);
+    if (r30) {
+        memcpy(r30, param_1, param_2);
+        return true;
+    }
+    return false;
 }
-#pragma pop

 /* 802A5730-802A57F0 2A0070 00C0+00 0/0 1/1 0/0 .text newStaticSeqData__10JAUSectionF10JAISoundID
 */
+// extra instruction JAISoundID
+#ifdef NONMATCHING
+bool JAUSection::newStaticSeqData(JAISoundID param_0) {
+    JKRArchive* seqArchive = data_.field_0x00.getSeqDataArchive();
+    JUT_ASSERT("JAUSectionHeap.cpp", 0x1e1, seqArchive);
+    JAUSoundInfo* soundInfo = JASGlobalInstance<JAUSoundInfo>::getInstance();
+    if (!soundInfo) {
+        return false;
+    }
+    u16 r26 = soundInfo->getBgmSeqResourceID(param_0);
+    u32 r25 = JASResArcLoader::getResSize(seqArchive, r26);
+    JAISoundID stack_2c;
+    stack_2c.setAnonymous();
+    u8* r24 = newStaticSeqDataBlock_(stack_2c, r25);
+    if (r24) {
+        data_.field_0x00.loadDynamicSeq(param_0, true, sectionHeap_->sectionHeapData_.seqDataUser);
+        return true;
+    }
+    return false;
+}
+#else
 #pragma push
 #pragma optimization_level 0
 #pragma optimizewithasm off
-asm void JAUSection::newStaticSeqData(JAISoundID param_0) {
+asm bool JAUSection::newStaticSeqData(JAISoundID param_0) {
    nofralloc
 #include "asm/JSystem/JAudio2/JAUSectionHeap/newStaticSeqData__10JAUSectionF10JAISoundID.s"
 }
 #pragma pop
+#endif

 /* 802A57F0-802A5854 2A0130 0064+00 3/3 0/0 0/0 .text            newCopy__10JAUSectionFPCvUll */
-#pragma push
-#pragma optimization_level 0
-#pragma optimizewithasm off
-asm void JAUSection::newCopy(void const* param_0, u32 param_1, s32 param_2) {
-    nofralloc
-#include "asm/JSystem/JAudio2/JAUSectionHeap/newCopy__10JAUSectionFPCvUll.s"
+void* JAUSection::newCopy(void const* param_0, u32 param_1, s32 param_2) {
+    JUT_ASSERT("JAUSectionHeap.cpp", 0x204, isOpen());
+    JUT_ASSERT("JAUSectionHeap.cpp", 0x205, isBuilding());
+    u8* r31 = new(getHeap_(), param_2) u8[param_1];
+    if (r31) {
+        memcpy(r31, param_0, param_1);
+    }
+    return r31;
 }
-#pragma pop

 /* ############################################################################################## */
 /* 8039B950-8039B950 027FB0 0000+00 0/0 0/0 0/0 .rodata          @stringBase0 */
@@ -410,130 +584,237 @@ SECTION_DEAD static char const* const pad_8039B9B9 = "\0\0\0\0\0\0";
 #pragma pop

 /* 802A5854-802A5948 2A0194 00F4+00 0/0 1/1 0/0 .text            newWaveBank__10JAUSectionFUlPCv */
+// position of std::__bitset_base<8>::set
+#ifdef NONMATCHING
+JASWaveBank* JAUSection::newWaveBank(u32 bank_no, void const* param_1) {
+    JUT_ASSERT("JAUSectionHeap.cpp", 0x210, isOpen());
+    JUT_ASSERT("JAUSectionHeap.cpp", 0x211, isBuilding());
+    TPushCurrentHeap push(getHeap_());
+    s32 r27 = getHeap_()->getFreeSize();
+    JASWaveBank* waveBank = JASWSParser::createWaveBank(param_1, getHeap_());
+    if (waveBank) {
+        JUT_ASSERT("JAUSectionHeap.cpp", 0x218, sectionHeap_->getWaveBankTable().getWaveBank( bank_no ) == 0);
+        sectionHeap_->getWaveBankTable().registWaveBank(bank_no, waveBank);
+        data_.registeredWaveBankTables.set(bank_no, true);
+        data_.field_0xa0 += r27 - getHeap_()->getFreeSize();
+        return waveBank;
+    }
+    return NULL;
+
+}
+#else
 #pragma push
 #pragma optimization_level 0
 #pragma optimizewithasm off
-asm void JAUSection::newWaveBank(u32 param_0, void const* param_1) {
+asm JASWaveBank* JAUSection::newWaveBank(u32 param_0, void const* param_1) {
    nofralloc
 #include "asm/JSystem/JAudio2/JAUSectionHeap/newWaveBank__10JAUSectionFUlPCv.s"
 }
 #pragma pop
+#endif

 /* 802A5948-802A5A50 2A0288 0108+00 0/0 1/1 0/0 .text            loadWaveArc__10JAUSectionFUlUl */
+// position of std::__bitset_base<8>::test
+#ifdef NONMATCHING
+bool JAUSection::loadWaveArc(u32 param_0, u32 param_1) {
+    if (data_.registeredWaveBankTables.test(param_0)) {
+        JASWaveBank* waveBank = sectionHeap_->getWaveBankTable().getWaveBank(param_0);
+        if (waveBank) {
+            for (u32 i = 0; i < waveBank->getArcCount(); i++) {
+                if (param_1 & 1 << i) {
+                    waveBank->getWaveArc(i)->load(NULL);
+                }
+            }
+            return true;
+        }
+    }
+    return false;
+}
+#else
 #pragma push
 #pragma optimization_level 0
 #pragma optimizewithasm off
-asm void JAUSection::loadWaveArc(u32 param_0, u32 param_1) {
+asm bool JAUSection::loadWaveArc(u32 param_0, u32 param_1) {
    nofralloc
 #include "asm/JSystem/JAudio2/JAUSectionHeap/loadWaveArc__10JAUSectionFUlUl.s"
 }
 #pragma pop
+#endif

 /* 802A5A50-802A5B84 2A0390 0134+00 0/0 1/1 0/0 .text            newBank__10JAUSectionFPCvUl */
+// vtable order JAUBankTableLink
+#ifdef NONMATCHING
+JASBank* JAUSection::newBank(void const* param_0, u32 param_1) {
+    JUT_ASSERT("JAUSectionHeap.cpp", 0x287, isOpen());
+    JUT_ASSERT("JAUSectionHeap.cpp", 0x288, isBuilding());
+    JASWaveBank* waveBank = sectionHeap_->getWaveBankTable().getWaveBank(param_1);
+    JUT_ASSERT("JAUSectionHeap.cpp", 0x28a, waveBank != 0);
+    TPushCurrentHeap push(getHeap_());
+    u32 bank_no = JASBNKParser::getBankNumber(param_0);
+    s32 r25 = getHeap_()->getFreeSize();
+    JASBank* bank = JASBNKParser::createBank(param_0, getHeap_());
+    if (bank) {
+        if (buildingBankTable_) {
+            JUT_ASSERT("JAUSectionHeap.cpp", 0x294, buildingBankTable_->getBank( bank_no ) == 0);
+            buildingBankTable_->registBank(bank_no, bank);
+        } else {
+            JUT_ASSERT("JAUSectionHeap.cpp",0x299, JASDefaultBankTable::getInstance() ->getBank( bank_no ) == 0);
+            JASDefaultBankTable::getInstance()->registBank(bank_no, bank);
+            data_.registeredBankTables.set(bank_no, true);
+        }
+        bank->assignWaveBank(waveBank);
+        data_.field_0x9c += r25 - getHeap_()->getFreeSize();
+        return bank;
+    }
+    return 0;
+}
+#else
 #pragma push
 #pragma optimization_level 0
 #pragma optimizewithasm off
-asm void JAUSection::newBank(void const* param_0, u32 param_1) {
+asm JASBank* JAUSection::newBank(void const* param_0, u32 param_1) {
    nofralloc
 #include "asm/JSystem/JAudio2/JAUSectionHeap/newBank__10JAUSectionFPCvUl.s"
 }
 #pragma pop
+#endif

 /* 802A5B84-802A5CAC 2A04C4 0128+00 0/0 1/1 0/0 .text            newVoiceBank__10JAUSectionFUlUl */
+// regalloc
+#ifdef NONMATCHING
+JASVoiceBank* JAUSection::newVoiceBank(u32 bank_no, u32 param_1) {
+    JUT_ASSERT("JAUSectionHeap.cpp", 0x2ad, isOpen());
+    JUT_ASSERT("JAUSectionHeap.cpp", 0x2ae, isBuilding());
+    JASWaveBank* waveBank = sectionHeap_->getWaveBankTable().getWaveBank(param_1);
+    JUT_ASSERT("JAUSectionHeap.cpp", 0x2b0, waveBank != 0);
+    TPushCurrentHeap push(getHeap_());
+    JASVoiceBank* voiceBank = new JASVoiceBank();
+    if (voiceBank) {
+        if (buildingBankTable_) {
+            JUT_ASSERT("JAUSectionHeap.cpp",0x2b8,buildingBankTable_->getBank( bank_no ) == 0);
+            buildingBankTable_->registBank(bank_no, voiceBank);
+        } else {
+            JUT_ASSERT("JAUSectionHeap.cpp",0x2bd, JASDefaultBankTable::getInstance() ->getBank( bank_no ) == 0);
+            JASDefaultBankTable::getInstance()->registBank(bank_no, voiceBank);
+            data_.registeredBankTables.set(bank_no, true);
+        }
+        voiceBank->assignWaveBank(waveBank);
+        return voiceBank;
+    }
+    return NULL;
+}
+#else
 #pragma push
 #pragma optimization_level 0
 #pragma optimizewithasm off
-asm void JAUSection::newVoiceBank(u32 param_0, u32 param_1) {
+asm JASVoiceBank* JAUSection::newVoiceBank(u32 param_0, u32 param_1) {
    nofralloc
 #include "asm/JSystem/JAudio2/JAUSectionHeap/newVoiceBank__10JAUSectionFUlUl.s"
 }
 #pragma pop
+#endif

 /* 802A5CAC-802A5D9C 2A05EC 00F0+00 0/0 1/1 0/0 .text beginNewBankTable__10JAUSectionFUlUl */
+// JAUBankTable inheritance
+#ifdef NONMATCHING
+bool JAUSection::beginNewBankTable(u32 param_0, u32 param_1) {
+    JUT_ASSERT("JAUSectionHeap.cpp", 0x2ca, isOpen());
+    JUT_ASSERT("JAUSectionHeap.cpp", 0x2cb, isBuilding());
+    JUT_ASSERT("JAUSectionHeap.cpp", 0x2cc, buildingBankTable_ == 0);
+    JAUBankTableLink* bankTableLink = NULL;
+    {
+        TPushCurrentHeap push(getHeap_());
+        JASBank** r26 = new JASBank*[param_1];
+        if (r26) {
+            bankTableLink = new JAUBankTableLink(param_0, r26, param_1);
+            if (bankTableLink) {
+                buildingBankTable_ = bankTableLink;
+            } else {
+
+            }
+        } else {
+
+        }
+    }
+    return bankTableLink;
+}
+#else
 #pragma push
 #pragma optimization_level 0
 #pragma optimizewithasm off
-asm void JAUSection::beginNewBankTable(u32 param_0, u32 param_1) {
+asm bool JAUSection::beginNewBankTable(u32 param_0, u32 param_1) {
    nofralloc
 #include "asm/JSystem/JAudio2/JAUSectionHeap/beginNewBankTable__10JAUSectionFUlUl.s"
 }
 #pragma pop
+#endif

 /* 802A5D9C-802A5DF4 2A06DC 0058+00 0/0 1/1 0/0 .text            endNewBankTable__10JAUSectionFv */
-#pragma push
-#pragma optimization_level 0
-#pragma optimizewithasm off
-asm void JAUSection::endNewBankTable() {
-    nofralloc
-#include "asm/JSystem/JAudio2/JAUSectionHeap/endNewBankTable__10JAUSectionFv.s"
+JAUBankTable* JAUSection::endNewBankTable() {
+    JAUBankTable* r29 = NULL;
+    if (buildingBankTable_) {
+        data_.field_0x74.appendBankTable(buildingBankTable_);
+        buildingBankTable_ = NULL;
+        r29 = buildingBankTable_;
+    }
+    return r29;
 }
-#pragma pop

 /* 802A5DF4-802A5E60 2A0734 006C+00 1/1 0/0 0/0 .text __ct__Q214JAUSectionHeap16TSectionHeapDataFv
 */
-#pragma push
-#pragma optimization_level 0
-#pragma optimizewithasm off
-asm JAUSectionHeap::TSectionHeapData::TSectionHeapData() {
-    nofralloc
-#include "asm/JSystem/JAudio2/JAUSectionHeap/__ct__Q214JAUSectionHeap16TSectionHeapDataFv.s"
+JAUSectionHeap::TSectionHeapData::TSectionHeapData() {
+    seSeqDataMgr_ = NULL;
+    streamDataMgr_ = NULL;
+    soundTable = NULL;
+    soundNameTable = NULL;
+    seqDataUser = NULL;
 }
-#pragma pop

 /* 802A5E60-802A5EC0 2A07A0 0060+00 0/0 1/1 0/0 .text
 * setSeqDataArchive__14JAUSectionHeapFP10JKRArchive            */
-#pragma push
-#pragma optimization_level 0
-#pragma optimizewithasm off
-asm void JAUSectionHeap::setSeqDataArchive(JKRArchive* param_0) {
-    nofralloc
-#include "asm/JSystem/JAudio2/JAUSectionHeap/setSeqDataArchive__14JAUSectionHeapFP10JKRArchive.s"
+void JAUSectionHeap::setSeqDataArchive(JKRArchive* param_0) {
+    sectionHeapData_.field_0x408.setSeqDataArchive(param_0);
+    for (JSULink<JAUSection>* link = mSectionList.getFirst(); link; link = link->getNext()) {
+        link->getObject()->data_.field_0x00.setSeqDataArchive(param_0);
+    }
 }
-#pragma pop

 /* 802A5EC0-802A5EF8 2A0800 0038+00 0/0 1/1 0/0 .text
 * loadDynamicSeq__14JAUSectionHeapF10JAISoundIDb               */
-#pragma push
-#pragma optimization_level 0
-#pragma optimizewithasm off
-asm void JAUSectionHeap::loadDynamicSeq(JAISoundID param_0, bool param_1) {
-    nofralloc
-#include "asm/JSystem/JAudio2/JAUSectionHeap/loadDynamicSeq__14JAUSectionHeapF10JAISoundIDb.s"
+bool JAUSectionHeap::loadDynamicSeq(JAISoundID param_0, bool param_1) {
+    return sectionHeapData_.field_0x408.loadDynamicSeq(param_0, param_1, sectionHeapData_.seqDataUser);
 }
-#pragma pop

 /* 802A5EF8-802A5F24 2A0838 002C+00 0/0 1/1 0/0 .text
 * releaseIdleDynamicSeqDataBlock__14JAUSectionHeapFv           */
-#pragma push
-#pragma optimization_level 0
-#pragma optimizewithasm off
-asm void JAUSectionHeap::releaseIdleDynamicSeqDataBlock() {
-    nofralloc
-#include "asm/JSystem/JAudio2/JAUSectionHeap/releaseIdleDynamicSeqDataBlock__14JAUSectionHeapFv.s"
+void JAUSectionHeap::releaseIdleDynamicSeqDataBlock() {
+    sectionHeapData_.field_0x408.releaseIdleDynamicSeqDataBlock(sectionHeapData_.seqDataUser);
 }
-#pragma pop

 /* 802A5F24-802A5F9C 2A0864 0078+00 1/1 0/0 0/0 .text JAUNewSectionHeap__FP12JKRSolidHeapb */
-#pragma push
-#pragma optimization_level 0
-#pragma optimizewithasm off
-static asm JAUSectionHeap* JAUNewSectionHeap(JKRSolidHeap* param_0, bool param_1) {
-    nofralloc
-#include "asm/JSystem/JAudio2/JAUSectionHeap/JAUNewSectionHeap__FP12JKRSolidHeapb.s"
+static JAUSectionHeap* JAUNewSectionHeap(JKRSolidHeap* heap, bool param_1) {
+    JUT_ASSERT("JAUSectionHeap.cpp", 0x329, JKRSolidHeap_isEmpty( heap ));
+    TPushCurrentHeap push(heap);
+    s32 r29 = heap->getFreeSize();
+    return new JAUSectionHeap(heap, param_1, r29);
 }
-#pragma pop

 /* 802A5F9C-802A5FE0 2A08DC 0044+00 0/0 1/1 0/0 .text            JAUNewSectionHeap__Fb */
-#pragma push
-#pragma optimization_level 0
-#pragma optimizewithasm off
-asm JAUSectionHeap* JAUNewSectionHeap(bool param_0) {
-    nofralloc
-#include "asm/JSystem/JAudio2/JAUSectionHeap/JAUNewSectionHeap__Fb.s"
+JAUSectionHeap* JAUNewSectionHeap(bool param_0) {
+    s32 freeSize = JASDram->getFreeSize();
+    JKRSolidHeap* sectionHeap = JKRCreateSolidHeap(freeSize, JASDram, true);
+    JUT_ASSERT("JAUSectionHeap.cpp", 0x335, sectionHeap);
+    return JAUNewSectionHeap(sectionHeap, param_0);
 }
-#pragma pop

 /* 802A5FE0-802A6094 2A0920 00B4+00 1/1 0/0 0/0 .text __ct__14JAUSectionHeapFP12JKRSolidHeapbl */
+// JAUSectionHeap inheritance
+#ifdef NONMATCHING
+JAUSectionHeap::JAUSectionHeap(JKRSolidHeap* param_0, bool param_1, s32 param_2) : JAUSection(this, 0, param_2), JASGlobalInstance<JAUSectionHeap>(param_1), mHeap(param_0) {
+    field_0xe4 = 0;
+    mSectionList.append(this);
+}
+#else
 #pragma push
 #pragma optimization_level 0
 #pragma optimizewithasm off
@@ -542,49 +823,61 @@ asm JAUSectionHeap::JAUSectionHeap(JKRSolidHeap* param_0, bool param_1, s32 para
 #include "asm/JSystem/JAudio2/JAUSectionHeap/__ct__14JAUSectionHeapFP12JKRSolidHeapbl.s"
 }
 #pragma pop
+#endif

 /* 802A6094-802A60A0 2A09D4 000C+00 0/0 1/1 0/0 .text            getOpenSection__14JAUSectionHeapFv
 */
-#pragma push
-#pragma optimization_level 0
-#pragma optimizewithasm off
-asm JAUSection* JAUSectionHeap::getOpenSection() {
-    nofralloc
-#include "asm/JSystem/JAudio2/JAUSectionHeap/getOpenSection__14JAUSectionHeapFv.s"
+JAUSection* JAUSectionHeap::getOpenSection() {
+    return mSectionList.getLast()->getObject();
 }
-#pragma pop

 /* 802A60A0-802A60AC 2A09E0 000C+00 2/1 0/0 0/0 .text
 * setSeqDataUser__14JAUSectionHeapFP14JAISeqDataUser           */
-#pragma push
-#pragma optimization_level 0
-#pragma optimizewithasm off
-asm void JAUSectionHeap::setSeqDataUser(JAISeqDataUser* param_0) {
-    nofralloc
-#include "asm/JSystem/JAudio2/JAUSectionHeap/setSeqDataUser__14JAUSectionHeapFP14JAISeqDataUser.s"
+bool JAUSectionHeap::setSeqDataUser(JAISeqDataUser* param_0) {
+    sectionHeapData_.seqDataUser = param_0;
+    return true;
 }
-#pragma pop

 /* 802A60AC-802A61D0 2A09EC 0124+00 0/0 2/2 0/0 .text newDynamicSeqBlock__14JAUSectionHeapFUl */
-#pragma push
-#pragma optimization_level 0
-#pragma optimizewithasm off
-asm void JAUSectionHeap::newDynamicSeqBlock(u32 param_0) {
-    nofralloc
-#include "asm/JSystem/JAudio2/JAUSectionHeap/newDynamicSeqBlock__14JAUSectionHeapFUl.s"
+bool JAUSectionHeap::newDynamicSeqBlock(u32 param_0) {
+    JUT_ASSERT("JAUSectionHeap.cpp", 0x3a9, isOpen());
+    JUT_ASSERT("JAUSectionHeap.cpp", 0x3aa, isBuilding());
+    JUT_ASSERT("JAUSectionHeap.cpp", 0x3ab, sectionHeap_ == this);
+    TPushCurrentHeap push(base1.getHeap_());
+    JAUSeqDataBlock * seqDataBlock = new JAUSeqDataBlock();
+    if (!seqDataBlock) {
+        return false;
+    }
+    JSULink<JAUSeqDataBlock> * link = new JSULink<JAUSeqDataBlock>(seqDataBlock);
+    if (!link) {
+        return false;
+    }
+    u8* r25 = new(0x20) u8[param_0];
+    if (!r25) {
+        return false;
+    }
+    seqDataBlock->field_0x14 = r25;
+    seqDataBlock->field_0x18 = param_0;
+    seqDataBlock->field_0x10.setAnonymous();
+    JASCriticalSection cs;
+    if (base1.sectionHeap_->sectionHeapData_.field_0x408.appendDynamicSeqDataBlock(seqDataBlock)) {
+        return true;
+    }
+    return false;
 }
-#pragma pop

 /* 802A61D0-802A6270 2A0B10 00A0+00 2/1 0/0 0/0 .text
 * getSeqData__14JAUSectionHeapF10JAISoundIDP10JAISeqData       */
-#pragma push
-#pragma optimization_level 0
-#pragma optimizewithasm off
-asm int JAUSectionHeap::getSeqData(JAISoundID param_0, JAISeqData* param_1) {
-    nofralloc
-#include "asm/JSystem/JAudio2/JAUSectionHeap/getSeqData__14JAUSectionHeapF10JAISoundIDP10JAISeqData.s"
+s32 JAUSectionHeap::getSeqData(JAISoundID param_0, JAISeqData* param_1) {
+    for (JSULink<JAUSection> * link = mSectionList.getFirst(); link; link = link->getNext()) {
+        s32 result = link->getObject()->data_.field_0x00.getSeqData(param_0, sectionHeapData_.seqDataUser, param_1, false);
+        JUT_ASSERT("JAUSectionHeap.cpp", 0x3e2, result != JAI_ASYNC_RESULT_RETRY);
+        if (result == 2) {
+            return 2;
+        }
+    }
+    return sectionHeapData_.field_0x408.getSeqData(param_0, sectionHeapData_.seqDataUser, param_1, true);
 }
-#pragma pop

 /* 802A6270-802A6278 2A0BB0 0008+00 2/1 0/0 0/0 .text            releaseSeqData__14JAUSectionHeapFv
 */
@@ -593,6 +886,10 @@ int JAUSectionHeap::releaseSeqData() {
 }

 /* 802A6278-802A6440 2A0BB8 01C8+00 2/1 0/0 0/0 .text            __dt__14JAUSectionHeapFv */
+// JAUSectionHeap inheritance
+#ifdef NONMATCHING
+JAUSectionHeap::~JAUSectionHeap() {}
+#else
 #pragma push
 #pragma optimization_level 0
 #pragma optimizewithasm off
@@ -601,6 +898,7 @@ asm JAUSectionHeap::~JAUSectionHeap() {
 #include "asm/JSystem/JAudio2/JAUSectionHeap/__dt__14JAUSectionHeapFv.s"
 }
 #pragma pop
+#endif

 /* 802A6440-802A6468 2A0D80 0028+00 1/0 0/0 0/0 .text
 * getStreamFileEntry__Q228@unnamed@JAUSectionHeap_cpp@14TStreamDataMgrF10JAISoundID */