JAudio2 debug (#3006)

18 files changed, 523 insertions, 235 deletions

diff --git a/src/JSystem/JAudio2/JAISeq.cpp b/src/JSystem/JAudio2/JAISeq.cpp
index f54c0ee242..7f9f9132d1 100644
--- a/src/JSystem/JAudio2/JAISeq.cpp
+++ b/src/JSystem/JAudio2/JAISeq.cpp
@@ -73,10 +73,12 @@ void JAISeq::reserveChildTracks_(int param_0) {
                     track->connectChild(j, track2);
                 } else {
                     JUT_WARN(117, "%s", "JASPoolAllocObject::<JASTrack>::operator new failed .\n");
+                    continue;
                 }
             }
         } else {
             JUT_WARN(124, "%s", "JASPoolAllocObject::<JASTrack>::operator new failed .\n");
+            continue;
         }
     }
 }
diff --git a/src/JSystem/JAudio2/JAISoundStarter.cpp b/src/JSystem/JAudio2/JAISoundStarter.cpp
index 5dc20b6737..6de5c0c281 100644
--- a/src/JSystem/JAudio2/JAISoundStarter.cpp
+++ b/src/JSystem/JAudio2/JAISoundStarter.cpp
@@ -10,19 +10,20 @@ JAISoundStarter::~JAISoundStarter() {}
 
 bool JAISoundStarter::startLevelSound(JAISoundID id, JAISoundHandle* handlePtr, const JGeometry::TVec3<f32>* posPtr) {
     JUT_ASSERT(20, handlePtr);
-    if (*handlePtr) {
-        if ((*handlePtr)->getID() == id) {
-            (*handlePtr)->updateLifeTime(1);
+    JAISoundHandle* handlePtr2 = handlePtr;
+    if (*handlePtr2) {
+        if ((*handlePtr2)->getID() == id) {
+            (*handlePtr2)->updateLifeTime(1);
             if (posPtr != NULL) {
-                (*handlePtr)->setPos(*posPtr);
+                (*handlePtr2)->setPos(*posPtr);
             }
             return true;
         }
     }
 
     bool rt = startSound(id, handlePtr, posPtr);
-    if (rt && *handlePtr) {
-        (*handlePtr)->setLifeTime(1, false);
+    if (rt && *handlePtr2) {
+        (*handlePtr2)->setLifeTime(1, false);
     }
     return rt;
 }
diff --git a/src/JSystem/JAudio2/JAIStream.cpp b/src/JSystem/JAudio2/JAIStream.cpp
index e4a0c7dd4e..f228347d26 100644
--- a/src/JSystem/JAudio2/JAIStream.cpp
+++ b/src/JSystem/JAudio2/JAIStream.cpp
@@ -251,7 +251,7 @@ JAISoundChild* JAIStream::getChild(int index) {
     if (children_[index] == NULL) {
          children_[index] = new JAISoundChild();
         if (children_[index] == NULL) {
-            JUT_WARN(370, "%s", "JASPoolAllocObject::<JAISoundChild>::operator new failed .")
+            JUT_WARN(370, "%s", "JASPoolAllocObject::<JAISoundChild>::operator new failed .\n")
         }
     }
     return children_[index];
diff --git a/src/JSystem/JAudio2/JASAiCtrl.cpp b/src/JSystem/JAudio2/JASAiCtrl.cpp
index de97b58a3f..662e5e6df4 100644
--- a/src/JSystem/JAudio2/JASAiCtrl.cpp
+++ b/src/JSystem/JAudio2/JASAiCtrl.cpp
@@ -30,7 +30,7 @@ s32 JASDriver::sDspDacReadBuffer;
 
 s32 JASDriver::sDspStatus;
 
-void (*JASDriver::sDspDacCallback)(s16*, u32);
+JASDriver::DSPBufCallback JASDriver::sDspDacCallback;
 
 s16* JASDriver::lastRspMadep;
 
@@ -140,7 +140,6 @@ void JASDriver::updateDac() {
 }
 
 void JASDriver::updateDSP() {
-    static u32 history[10] = {0x000F4240};
     JASProbe::start(3, "SFR-UPDATE");
     JASDsp::invalChannelAll();
 
@@ -151,6 +150,7 @@ void JASDriver::updateDSP() {
     JASPortCmd::execAllCommand();
     DSPSyncCallback();
     static u32 old_time = 0;
+    static u32 history[10] = {0x000F4240};
     u32 r28 = OSGetTick();
     u32 r27 = r28 - old_time;
     old_time = r28;
@@ -210,15 +210,37 @@ void JASDriver::readDspBuffer(s16* param_0, u32 param_1) {
     JASCalc::imixcopy(endDacBuffer, dacBuffer, param_0, param_1);
 }
 
+u32 sDspUpCount;
+
 void JASDriver::finishDSPFrame() {
+    static u32 waitcount;
     int r30 = sDspDacWriteBuffer + 1;
     if (r30 == data_804507A8) {
         r30 = 0;
     }
     if (r30 == sDspDacReadBuffer) {
         sDspStatus = 0;
+#if DEBUG
+        if (sDspStatus != 0) {
+            waitcount = 0;
+        } else {
+            waitcount++;
+        }
+        if (waitcount != 7) {
+            return;
+        }
+        if (sDspUpCount != 0) {
+            JUT_WARN(0, "forth DSP return\n");
+        }
+        if (sDspUpCount == 0) {
+            sDspUpCount += 1;
+        }
+        JASReport("finishDSPFrame nbuf:%d sWBuf:%d BCount:%d stat:%d", r30, sDspDacWriteBuffer, data_804507A8, sDspStatus);
+#else
         return;
+#endif
     }
+
     sDspDacWriteBuffer = r30;
     JASAudioThread::setDSPSyncCount(getSubFrames());
     JASProbe::start(7, "DSP-MAIN");
@@ -236,6 +258,10 @@ void JASDriver::registerMixCallback(MixCallback param_0, JASMixMode param_1) {
     sMixMode = param_1;
 }
 
+void JASDriver::registDSPBufCallback(DSPBufCallback cb) {
+    sDspDacCallback = cb;
+}
+
 f32 JASDriver::getDacRate() {
     return sDacRate;
 }
@@ -254,68 +280,84 @@ u32 JASDriver::getFrameSamples() {
 
 void JASDriver::mixMonoTrack(s16* buffer, u32 param_1, MixCallback param_2) {
     JASProbe::start(5, "MONO-MIX");
-    s16* r31 = param_2(param_1);
-    s16* pTrack = buffer;
-    if (r31 == NULL) {
+    s16* r26 = param_2(param_1);
+    if (r26 == NULL) {
         return;
     }
     JASProbe::stop(5);
+    s16* pTrack = buffer;
+    s16* r28 = r26;
     for (u32 i = param_1; i != 0; i--) {
-        pTrack[0] = JASCalc::clamp<s16, s32>(pTrack[0] + r31[0]);
-        pTrack[1] = JASCalc::clamp<s16, s32>(pTrack[1] + r31[0]);
-        pTrack += 2;
-        r31++;
+        s32 src = pTrack[0];
+        src += r28[0];
+        pTrack[0] = JASCalc::clamp<s16, s32>(src);
+        pTrack++;
+        src = pTrack[0];
+        src += r28[0];
+        pTrack[0] = JASCalc::clamp<s16, s32>(src);
+        pTrack++;
+        r28++;
     }
 }
 
 void JASDriver::mixMonoTrackWide(s16* buffer, u32 param_1, MixCallback param_2) {
     JASProbe::start(5, "MONO(W)-MIX");
-    s16* r31 = param_2(param_1);
-    s16* pTrack = buffer;
-    if (!r31) {
+    s16* r26 = param_2(param_1);
+    if (!r26) {
         return;
     }
     JASProbe::stop(5);
+    s16* pTrack = buffer;
+    s16* r28 = r26;
     for (u32 i = param_1; i != 0; i--) {
-        pTrack[0] = JASCalc::clamp<s16, s32>(pTrack[0] + r31[0]);
-        s32 src = pTrack[1];
-        src -= r31[0];
-        pTrack[1] = JASCalc::clamp<s16, s32>(src);
-        pTrack += 2;
-        r31++;
+        s32 src = pTrack[0];
+        src += r28[0];
+        pTrack[0] = JASCalc::clamp<s16, s32>(src);
+        pTrack++;
+        src = pTrack[0];
+        src -= r28[0];
+        pTrack[0] = JASCalc::clamp<s16, s32>(src);
+        pTrack++;
+        r28++;
     }
 }
 
 void JASDriver::mixExtraTrack(s16* buffer, u32 param_1, MixCallback param_2) {
     JASProbe::start(5, "DSPMIX");
-    s16* r31 = param_2(param_1);
-    if (!r31) {
+    s16* r27 = param_2(param_1);
+    if (!r27) {
         return;
     }
     JASProbe::stop(5);
     JASProbe::start(6, "MIXING");
     s16* pTrack = buffer;
-    s16* r29 = r31 + getFrameSamples();
+    s16* r29 = r27;
+    s16* r28 = r27 + getFrameSamples();
     for (u32 i = param_1; i != 0; i--) {
-        pTrack[0] = JASCalc::clamp<s16, s32>(pTrack[0] + r29[0]);
-        pTrack[1] = JASCalc::clamp<s16, s32>(pTrack[1] + r31[0]);
-        pTrack += 2;
+        s32 r25 = pTrack[0] + r28[0];
+        pTrack[0] = JASCalc::clamp<s16, s32>(r25);
+        pTrack++;
+        r25 = pTrack[0] + r29[0];
+        pTrack[0] = JASCalc::clamp<s16, s32>(r25);
+        pTrack++;
+        r28++;
         r29++;
-        r31++;
     }
     JASProbe::stop(6);
 }
 
 void JASDriver::mixInterleaveTrack(s16* buffer, u32 param_1, MixCallback param_2) {
     s16* r31 = param_2(param_1);
-    if (r31) {
-        s16* pTrack = buffer;
-        s16* r30 = r31;
-        for (u32 i = param_1 * 2; i != 0; i--) {
-            pTrack[0] = JASCalc::clamp<s16, s32>(pTrack[0] + r30[0]);
-            pTrack += 1;
-            r30++;
-        }
+    if (!r31) {
+        return;
+    }
+    s16* pTrack = buffer;
+    s16* r30 = r31;
+    for (u32 i = param_1 * 2; i != 0; i--) {
+        s32 r26 = pTrack[0] + r30[0];
+        pTrack[0] = JASCalc::clamp<s16, s32>(r26);
+        pTrack++;
+        r30++;
     }
 }
 
diff --git a/src/JSystem/JAudio2/JASAudioReseter.cpp b/src/JSystem/JAudio2/JASAudioReseter.cpp
index 834320869a..14599d032b 100644
--- a/src/JSystem/JAudio2/JASAudioReseter.cpp
+++ b/src/JSystem/JAudio2/JASAudioReseter.cpp
@@ -10,41 +10,46 @@ struct JASDSPChannel {
     void drop();
     static JASDSPChannel* getHandle(u32);
 
-    inline u32 getStatus() {return mStatus;}
+    inline u8 getStatus() const { return mStatus; }
     u32 mStatus;
 };
 
 JASAudioReseter::JASAudioReseter() {
     field_0x0 = 0;
-    mIsDone = true;
-    field_0xc = false;
+    mDoneFlag = true;
+    mThreadStopFlag = false;
     mDSPLevel = JASDriver::getDSPLevel();
 }
 
-JASAudioReseter::~JASAudioReseter() {}
+JASAudioReseter::~JASAudioReseter() {
+    JUT_ASSERT(28, mDoneFlag);
+}
 
 bool JASAudioReseter::start(u32 param_0, bool param_1) {
-    if (mIsDone == false) {
+    if (mDoneFlag == false) {
         return false;
     }
-    field_0xc = param_1;
+    mThreadStopFlag = param_1;
     JASCriticalSection critical;
     if (!JASDriver::registerDspSyncCallback(callback, this)) {
+        JUT_WARN(40, "%s", "Failed JASAudioReseter start\n");
         return false;
     } else {
         mDSPLevel = JASDriver::getDSPLevel();
         field_0x0 = param_0;
-        mIsDone = false;
+        mDoneFlag = false;
         return true;
     }
 }
 
 void JASAudioReseter::resume() {
+    JUT_ASSERT(55, mDoneFlag);
+    JUT_ASSERT(56, ! mThreadStopFlag);
     JASDriver::setDSPLevel(mDSPLevel);
 }
 
 s32 JASAudioReseter::checkDone() const {
-    return mIsDone;
+    return mDoneFlag;
 }
 
 
@@ -52,23 +57,24 @@ s32 JASAudioReseter::calc() {
     if(field_0x0==0) {
         for(size_t i = 0; i<64; i++) {
             JASDSPChannel* handle = JASDSPChannel::getHandle(i);
-            if ((handle->getStatus()&0xFF)==0) {
+            if ((handle->getStatus())==0) {
                 handle->drop();
             }
         }
-        if(field_0xc!=false) {
-            JASGlobalInstance<JASAudioThread>::getInstance()->stop();//JASGlobalInstance<JASAudioThread>::sInstance->stop();
+        if(mThreadStopFlag!=false) {
+            JASAudioThread* pAudioThread = JASGlobalInstance<JASAudioThread>::getInstance();
+            JUT_ASSERT(78, pAudioThread);
+            pAudioThread->stop();
         }
-        mIsDone = 1;
+        mDoneFlag = 1;
         return -1;
     }
     field_0x0--;
-    u32 unk = field_0x0;
-    float dspLevel = JASDriver::getDSPLevel();
-    JASDriver::setDSPLevel(((float)unk*dspLevel)/(float)(unk+1));
+    JASDriver::setDSPLevel(field_0x0 * JASDriver::getDSPLevel() / (field_0x0 + 1));
     return 0;
 }
 
 s32 JASAudioReseter::callback(void* param_0) {
-    return ((JASAudioReseter*)param_0)->calc();
+    JASAudioReseter* i_this = (JASAudioReseter*) param_0;
+    return i_this->calc();
 }
diff --git a/src/JSystem/JAudio2/JASAudioThread.cpp b/src/JSystem/JAudio2/JASAudioThread.cpp
index fef909dd16..e1f6f83f08 100644
--- a/src/JSystem/JAudio2/JASAudioThread.cpp
+++ b/src/JSystem/JAudio2/JASAudioThread.cpp
@@ -7,6 +7,7 @@
 #include "JSystem/JAudio2/JASDSPInterface.h"
 #include "JSystem/JAudio2/JASHeapCtrl.h"
 #include "JSystem/JAudio2/JASProbe.h"
+#include "JSystem/JAudio2/JASReport.h"
 #include "JSystem/JKernel/JKRSolidHeap.h"
 #include "dolphin/dsp.h"
 #include "stdint.h"
@@ -21,9 +22,17 @@ JASAudioThread::JASAudioThread(int stackSize, int msgCount, u32 threadPriority)
 }
 
 void JASAudioThread::create(s32 threadPriority) {
-	JASAudioThread* sAudioThread = new (JASDram, 0) JASAudioThread(threadPriority, 0x10, 0x1400);
-    sAudioThread->setCurrentHeap(JKRGetSystemHeap());
-	sAudioThread->resume();
+#if PLATFORM_GCN
+    const int size = 0x1400;
+#else
+    const int size = 0x2800;
+#endif
+    JASAudioThread* pAudioThread = new (JASDram, 0) JASAudioThread(threadPriority, 0x10, size);
+    JUT_ASSERT(46, pAudioThread);
+    JKRHeap* pCurrentHeap = JKRGetSystemHeap();
+    JUT_ASSERT(48, pCurrentHeap);
+    pAudioThread->setCurrentHeap(pCurrentHeap);
+    pAudioThread->resume();
 }
 
 void JASAudioThread::stop() {
@@ -59,19 +68,27 @@ void* JASAudioThread::run() {
     JASPoolAllocObject_MultiThreaded<JASChannel>::newMemPool(0x48);
     JASDriver::startDMA();
 
+    OSMessage msg;
     while (true) {
-        OSMessage msg = waitMessageBlock();
+        msg = waitMessageBlock();
         switch ((intptr_t)msg) {
         case AUDIOMSG_DMA:
             if (sbPauseFlag) {
+                JUT_PANIC(107, "AUDIO THREAD PAUSED\n");
                 JASDriver::stopDMA();
                 OSSleepThread(&sThreadQueue);
             }
+#if DEBUG
+            if (snIntCount != 0) {
+                JASReport("DSP process is over.");
+            }
+#endif
             JASDriver::updateDac();
             JASDriver::updateDacCallback();
-            break;
+            continue;
 
         case AUDIOMSG_DSP:
+            JUT_ASSERT(125, snIntCount != 0);
             snIntCount--;
             if (snIntCount == 0) {
                 JASProbe::stop(7);
@@ -81,31 +98,41 @@ void* JASAudioThread::run() {
                 JASDriver::updateDSP();
                 JASProbe::stop(2);
             }
-            break;
+            continue;
 
         case AUDIOMSG_STOP:
             JASDriver::stopDMA();
             OSExitThread(NULL);
-            break;
+            continue;
+        default:
+            JUT_PANIC(152, "AUDIO THREAD INVALID MESSAGE\n");
         }
     }
 }
 
 void JASAudioThread::DMACallback() {
-    JASAudioThread* thread = getInstance();
+    JASAudioThread* pAudioThread = getInstance();
+    JUT_ASSERT(167, pAudioThread);
 	JASProbe::stop(4);
 	JASProbe::start(4, "UPDATE-DAC");
-	thread->sendMessage((void*)AUDIOMSG_DMA);
+	if (!pAudioThread->sendMessage((void*)AUDIOMSG_DMA)) {
+        JUT_WARN_DEVICE(173, 1, "%s","----- DMACallback : Can\'t send DAC_SYNC message\n");
+    }
 }
 
 void JASAudioThread::DSPCallback(void*) {
-    JASAudioThread* thread = getInstance();
+    JASAudioThread* pAudioThread = getInstance();
+    JUT_ASSERT(184, pAudioThread);
 	while (DSPCheckMailFromDSP() == 0) { }
 
 	u32 mail = DSPReadMailFromDSP();
-	if (mail >> 0x10 == 0xF355) {
+	if (mail >> 0x10 != 0xF355) {
+        JUT_WARN(196, "DSP Mail format error %x\n", mail);
+    } else {
 		if ((mail & 0xFF00) == 0xFF00) {
-            thread->sendMessage((void*)AUDIOMSG_DSP);
+            if (!pAudioThread->sendMessage((void*)AUDIOMSG_DSP)) {
+                JUT_WARN_DEVICE(204, 1, "%s", "----- syncDSP : Send Miss\n");
+            }
 		} else {
 			JASDsp::finishWork(mail);
 		}
diff --git a/src/JSystem/JAudio2/JASDSPChannel.cpp b/src/JSystem/JAudio2/JASDSPChannel.cpp
index b1e4dc1296..268c80a779 100644
--- a/src/JSystem/JAudio2/JASDSPChannel.cpp
+++ b/src/JSystem/JAudio2/JASDSPChannel.cpp
@@ -43,6 +43,7 @@ void JASDSPChannel::drop() {
 
 void JASDSPChannel::initAll() {
     sDspChannels = new (JASDram, 0x20) JASDSPChannel[0x40];
+    JUT_ASSERT(102, sDspChannels);
     for (int i = 0; i < 0x40; i++) {
         sDspChannels[i].mChannel = JASDsp::getDSPHandle(i);
     }
@@ -87,7 +88,7 @@ JASDSPChannel* JASDSPChannel::getLowestChannel(int i_priority) {
         JASDSPChannel* channel = &sDspChannels[i];
         s16 priority = channel->mPriority;
         if (priority < 0) {
-            return channel;
+            return &sDspChannels[i];
         }
         if (priority <= i_priority && priority <= best_priority) {
             if (priority != best_priority || channel->field_0xc > best_unknown) {
@@ -127,7 +128,8 @@ JASDSPChannel* JASDSPChannel::getLowestActiveChannel() {
 }
 
 void JASDSPChannel::updateProc() {
-    int ret;
+    int ret = 0;
+    bool flush;
     if (mChannel->isFinish()) {
         mFlags &= ~2;
         if (mStatus == STATUS_ACTIVE) {
@@ -173,7 +175,7 @@ void JASDSPChannel::updateProc() {
                 mChannel->flush();
             }
         } else if (mStatus != STATUS_INACTIVE) {
-            bool flush = false;
+            flush = false;
             if (mCallback != NULL) {
                 ret = mCallback(CB_PLAY, mChannel, mCallbackData);
                 flush = true;
@@ -225,3 +227,33 @@ int JASDSPChannel::killActiveChannel() {
 JASDSPChannel* JASDSPChannel::getHandle(u32 i_index) {
     return &sDspChannels[i_index];
 }
+
+u32 JASDSPChannel::getNumUse() {
+    u32 count = 0;
+    for (int i = 0; i < 0x40; i++) {
+        if (sDspChannels[i].mStatus == 0) {
+            count++;
+        }
+    }
+    return count;
+}
+
+u32 JASDSPChannel::getNumFree() {
+    u32 count = 0;
+    for (int i = 0; i < 0x40; i++) {
+        if (sDspChannels[i].mStatus == 1) {
+            count++;
+        }
+    }
+    return count;
+}
+
+u32 JASDSPChannel::getNumBreak() {
+        u32 count = 0;
+    for (int i = 0; i < 0x40; i++) {
+        if (sDspChannels[i].mStatus == 2) {
+            count++;
+        }
+    }
+    return count;
+}
diff --git a/src/JSystem/JAudio2/JASDSPInterface.cpp b/src/JSystem/JAudio2/JASDSPInterface.cpp
index 4d1a2f1d8b..79cf9bb249 100644
--- a/src/JSystem/JAudio2/JASDSPInterface.cpp
+++ b/src/JSystem/JAudio2/JASDSPInterface.cpp
@@ -17,10 +17,34 @@ JASDsp::FxBuf* JASDsp::FX_BUF;
 
 f32 JASDsp::sDSPVolume;
 
+u16 JASDsp::SEND_TABLE[] = {
+    0x0D00,
+    0x0D60,
+    0x0DC8,
+    0x0E28,
+    0x0E88,
+    0x0EE8,
+    0x0CA0,
+    0x0F40,
+    0x0FA0,
+    0x0B00,
+    0x09A0,
+    0x0000,
+};
+
+u32 JASWaveInfo::one = 1;
+
+#if DEBUG
+s32 JASDsp::dspMutex = 1;
+#endif
+
 void JASDsp::boot(void (*param_0)(void*)) {
     static bool data_804512F4 = true;
     if (data_804512F4) {
         DspBoot(param_0);
+#if !PLATFORM_GCN
+        // DsetVARAM(JKRHeap::getAltAramStartAdr());
+#endif
         data_804512F4 = false;
     }
 }
@@ -40,6 +64,7 @@ void JASDsp::syncFrame(u32 param_0, u32 param_1, u32 param_2) {
 void JASDsp::setDSPMixerLevel(f32 dsp_level) {
     sDSPVolume = dsp_level;
     dsp_level *= 4.0f;
+    JUT_ASSERT(277, (0.0 <= dsp_level) && (dsp_level <= 8.0));
     DsetMixerLevel(dsp_level);
 }
 
@@ -51,6 +76,10 @@ JASDsp::TChannel* JASDsp::getDSPHandle(int param_0) {
     return CH_BUF + param_0;
 }
 
+JASDsp::TChannel* JASDsp::getDSPHandleNc(int param_0) {
+    return (TChannel*)OSCachedToUncached(CH_BUF + param_0);
+}
+
 void JASDsp::setFilterTable(s16* param_0, s16* param_1, u32 param_2) {
     for (int i = 0; i < param_2; i++) {
         *param_0++ = *param_1++;
@@ -398,7 +427,9 @@ u32 const ATTRIBUTE_ALIGN(32) JASDsp::DSPRES_FILTER[320] = {
 
 void JASDsp::initBuffer() {
     CH_BUF = new(JASDram, 0x20) TChannel[64];
+    JUT_ASSERT(354, CH_BUF);
     FX_BUF = new(JASDram, 0x20) FxBuf[4];
+    JUT_ASSERT(356, FX_BUF);
     JASCalc::bzero(CH_BUF, 0x6000);
     JASCalc::bzero(FX_BUF, sizeof(FxBuf) * 4);
     for (u8 i = 0; i < 4; i++) {
@@ -408,22 +439,7 @@ void JASDsp::initBuffer() {
     flushBuffer();
 }
 
-u16 JASDsp::SEND_TABLE[] = {
-    0x0D00,
-    0x0D60,
-    0x0DC8,
-    0x0E28,
-    0x0E88,
-    0x0EE8,
-    0x0CA0,
-    0x0F40,
-    0x0FA0,
-    0x0B00,
-    0x09A0,
-    0x0000,
-};
-
-int JASDsp::setFXLine(u8 param_0, s16* param_1, JASDsp::FxlineConfig_* param_2) {
+int JASDsp::setFXLine(u8 param_0, s16* buffer, JASDsp::FxlineConfig_* param_2) {
     FxBuf* puVar3 = FX_BUF + param_0;
     JASCriticalSection aJStack_20;
     puVar3->field_0x0 = 0;
@@ -433,15 +449,17 @@ int JASDsp::setFXLine(u8 param_0, s16* param_1, JASDsp::FxlineConfig_* param_2)
         puVar3->field_0xe = param_2->field_0x8;
         puVar3->field_0xc = SEND_TABLE[param_2->field_0x6];
         puVar3->field_0x2 = param_2->field_0xc;
-        setFilterTable(puVar3->field_0x10, param_2->field_0x10, 8);
+        setFilterTable((s16*)puVar3->field_0x10, param_2->field_0x10, 8);
     }
-    if (param_1 != NULL && param_2 != NULL) {
-        u32 iVar1 = param_2->field_0xc * 0xa0;
-        puVar3->field_0x4 = param_1;
-        JASCalc::bzero(param_1, iVar1);
-        DCFlushRange(param_1, iVar1);
-    } else if (param_2 == NULL || param_1 != NULL) {
-        puVar3->field_0x4 = param_1;
+    if (buffer != NULL && param_2 != NULL) {
+        u32 bufsize = param_2->field_0xc * 0xa0;
+        puVar3->field_0x4 = buffer;
+        JASCalc::bzero(buffer, bufsize);
+        JUT_ASSERT(420, (reinterpret_cast<u32>(buffer) & 0x1f) == 0);
+        JUT_ASSERT(421, (bufsize & 0x1f) == 0);
+        DCFlushRange(buffer, bufsize);
+    } else if (param_2 == NULL || buffer != NULL) {
+        puVar3->field_0x4 = buffer;
     }
 
     if (puVar3->field_0x4 != NULL) {
@@ -453,7 +471,31 @@ int JASDsp::setFXLine(u8 param_0, s16* param_1, JASDsp::FxlineConfig_* param_2)
     return 1;
 }
 
+BOOL JASDsp::changeFXLineParam(u8 param_0, u8 param_1, u32 param_2) {
+    JUT_ASSERT(450, dspMutex);
+    FxBuf* buf = &FX_BUF[param_0];
+    switch (param_1) {
+    case 0: buf->field_0x8 = param_2; break;
+    case 1: buf->field_0xc = param_2; break;
+    case 2: buf->field_0xa = param_2; break;
+    case 3: buf->field_0xe = param_2; break;
+    case 4: buf->field_0x2 = param_2; break;
+    case 5: buf->field_0x10[0] = param_2; break;
+    case 6: buf->field_0x10[1] = param_2; break;
+    case 7: buf->field_0x10[2] = param_2; break;
+    case 8: buf->field_0x10[3] = param_2; break;
+    case 9: buf->field_0x10[4] = param_2; break;
+    case 10: buf->field_0x10[5] = param_2; break;
+    case 11: buf->field_0x10[6] = param_2; break;
+    case 12: buf->field_0x10[7] = param_2; break;
+    case 13: setFilterTable((s16*)buf->field_0x10, (s16*)param_2, 8); break;
+    case 14: buf->field_0x0 = param_2; break;
+    }
+    return 1;
+}
+
 void JASDsp::TChannel::init() {
+    JUT_ASSERT(489, dspMutex);
     mPauseFlag = 0;
     mIsFinished = 0;
     mForcedStop = 0;
@@ -464,6 +506,7 @@ void JASDsp::TChannel::init() {
 }
 
 void JASDsp::TChannel::playStart() {
+    JUT_ASSERT(508, dspMutex);
     field_0x10c = 0;
     field_0x060 = 0;
     field_0x008 = 1;
@@ -480,27 +523,34 @@ void JASDsp::TChannel::playStart() {
 }
 
 void JASDsp::TChannel::playStop() {
+    JUT_ASSERT(540, dspMutex);
     mIsActive = 0;
 }
 
 void JASDsp::TChannel::replyFinishRequest() {
+    JUT_ASSERT(549, dspMutex);
     mIsFinished = 0;
     mIsActive = 0;
 }
 
 void JASDsp::TChannel::forceStop() {
+    JUT_ASSERT(559, dspMutex);
     mForcedStop = 1;
 }
 
 bool JASDsp::TChannel::isActive() const {
+    JUT_ASSERT(568, dspMutex);
     return mIsActive != 0;
 }
 
 bool JASDsp::TChannel::isFinish() const {
+    JUT_ASSERT(577, dspMutex);
     return mIsFinished != 0;
 }
 
 void JASDsp::TChannel::setWaveInfo(JASWaveInfo const& param_0, u32 param_1, u32 param_2) {
+    int i;
+    JUT_ASSERT(610, dspMutex);
     field_0x118 = param_1;
     static const u8 COMP_BLOCKSAMPLES[8] = {0x10, 0x10, 0x01, 0x01, 0x01, 0x10, 0x10, 0x01};
     field_0x064 = COMP_BLOCKSAMPLES[param_0.field_0x00];
@@ -536,19 +586,21 @@ void JASDsp::TChannel::setWaveInfo(JASWaveInfo const& param_0, u32 param_1, u32
                 break;
             }
         }
-        for (int i = 0; i < 16; i++) {
+        for (i = 0; i < 16; i++) {
             field_0x0b0[i] = 0;
         }
     }
 }
 
 void JASDsp::TChannel::setOscInfo(u32 param_0) {
+    JUT_ASSERT(671, dspMutex);
     field_0x118 = 0;
     field_0x064 = 16;
     field_0x100 = param_0;
 }
 
 void JASDsp::TChannel::initAutoMixer() {
+    JUT_ASSERT(688, dspMutex);
     if (field_0x058) {
         field_0x054 = field_0x056;
     } else {
@@ -559,6 +611,7 @@ void JASDsp::TChannel::initAutoMixer() {
 
 void JASDsp::TChannel::setAutoMixer(u16 param_0, u8 param_1, u8 param_2, u8 param_3,
                                         u8 param_4) {
+    JUT_ASSERT(709, dspMutex);
     field_0x050 = (param_1 << 8) | param_2;
     field_0x052 = param_3 << 8 | param_3 << 1;
     field_0x056 = param_0;
@@ -566,6 +619,7 @@ void JASDsp::TChannel::setAutoMixer(u16 param_0, u8 param_1, u8 param_2, u8 para
 }
 
 void JASDsp::TChannel::setPitch(u16 param_0) {
+    JUT_ASSERT(763, dspMutex);
     if (param_0 >= 0x7fff) {
         param_0 = 0x7fff;
     }
@@ -573,6 +627,7 @@ void JASDsp::TChannel::setPitch(u16 param_0) {
 }
 
 void JASDsp::TChannel::setMixerInitVolume(u8 param_0, s16 param_1) {
+    JUT_ASSERT(798, dspMutex);
     u16* tmp = field_0x010[param_0];
     tmp[2] = param_1;
     tmp[1] = param_1;
@@ -580,14 +635,17 @@ void JASDsp::TChannel::setMixerInitVolume(u8 param_0, s16 param_1) {
 }
 
 void JASDsp::TChannel::setMixerVolume(u8 param_0, s16 param_1) {
+    u16* tmp;
+    JUT_ASSERT(841, dspMutex);
     if (mForcedStop == 0) {
-        u16* tmp = field_0x010[param_0];
+        tmp = field_0x010[param_0];
         tmp[1] = param_1;
         tmp[3] &= 0xff;
     }
 }
 
 void JASDsp::TChannel::setPauseFlag(u8 param_0) {
+    JUT_ASSERT(863, dspMutex);
     mPauseFlag = param_0;
 }
 
@@ -596,7 +654,8 @@ void JASDsp::TChannel::flush() {
 }
 
 void JASDsp::TChannel::initFilter() {
-    int i;
+    u32 i;
+    JUT_ASSERT(888, dspMutex);
     for (i = 0; i < 8; i++) {
         fir_filter_params[i] = 0;
     }
@@ -609,6 +668,7 @@ void JASDsp::TChannel::initFilter() {
 }
 
 void JASDsp::TChannel::setFilterMode(u16 param_0) {
+    JUT_ASSERT(914, dspMutex);
     u8 r30 = param_0 & 0x20;
     u8 r31 = param_0 & 0x1f;
     if (r30) {
@@ -624,24 +684,30 @@ void JASDsp::TChannel::setFilterMode(u16 param_0) {
 }
 
 void JASDsp::TChannel::setIIRFilterParam(s16* param_0) {
+    JUT_ASSERT(937, dspMutex);
     setFilterTable(iir_filter_params, param_0, 8);
 }
 
 void JASDsp::TChannel::setFIR8FilterParam(s16* param_0) {
+    JUT_ASSERT(948, dspMutex);
     setFilterTable(fir_filter_params, param_0, 8);
 }
 
 void JASDsp::TChannel::setDistFilter(s16 param_0) {
+    JUT_ASSERT(959, dspMutex);
     iir_filter_params[4] = param_0;
 }
 
 void JASDsp::TChannel::setBusConnect(u8 param_0, u8 param_1) {
+    JUT_ASSERT(973, dspMutex);
     u16* tmp = field_0x010[param_0];
     static u16 const connect_table[12] = {
         0x0000, 0x0D00, 0x0D60, 0x0DC0, 0x0E20, 0x0E80,
         0x0EE0, 0x0CA0, 0x0F40, 0x0FA0, 0x0B00, 0x09A0,
     };
-    tmp[0] = connect_table[param_1];
+    u16 r30 = 0;
+    r30 = connect_table[param_1];
+    tmp[0] = r30;
 }
 
 u16 DSP_CreateMap2(u32 param_0) {
@@ -656,9 +722,3 @@ u16 DSP_CreateMap2(u32 param_0) {
     }
     return r30;
 }
-
-u32 JASWaveInfo::one = 1;
-
-#if DEBUG
-s32 dspMutex = 1;
-#endif
diff --git a/src/JSystem/JAudio2/JASDriverIF.cpp b/src/JSystem/JAudio2/JASDriverIF.cpp
index b579103ab6..083a969413 100644
--- a/src/JSystem/JAudio2/JASDriverIF.cpp
+++ b/src/JSystem/JAudio2/JASDriverIF.cpp
@@ -15,6 +15,10 @@ u16 JASDriver::getChannelLevel_dsp() {
     return JASDriver::MAX_MIXERLEVEL;
 }
 
+f32 JASDriver::getChannelLevel() {
+    return MAX_MIXERLEVEL / 16383.5f;
+}
+
 f32 JASDriver::getDSPLevel() {
     return JASDsp::getDSPMixerLevel();
 }
diff --git a/src/JSystem/JAudio2/JASOscillator.cpp b/src/JSystem/JAudio2/JASOscillator.cpp
index 41a1d0a018..e67f997619 100644
--- a/src/JSystem/JAudio2/JASOscillator.cpp
+++ b/src/JSystem/JAudio2/JASOscillator.cpp
@@ -8,10 +8,7 @@ JASOscillator::JASOscillator() {
     mDirectRelease = 0;
     _18 = 0;
     _1C = 0;
-    _0C = 0.0f;
-    _10 = 0.0f;
-    _08 = 0.0f;
-    _04 = 0.0f;
+    _04 = _08 = _10 = _0C = 0.0f;
 }
 
 
@@ -52,6 +49,7 @@ void JASOscillator::incCounter(f32 param_0) {
 }
 
 f32 JASOscillator::getValue() const {
+    JUT_ASSERT(120, mData);
 	return _08 * mData->mScale + mData->_14;
 }
 
@@ -71,8 +69,9 @@ void JASOscillator::release() {
         update();
         return;
 	}
-	
+
     if (mData->mTable != mData->rel_table) {
+        JUT_ASSERT(157, mData->rel_table != NULL);
         _04 = 0.0f;
         _0C = _08;
         _10 = mData->rel_table[0]._4 / 32768.0f;
@@ -86,7 +85,7 @@ void JASOscillator::release() {
 
 void JASOscillator::update() {
     if (_1C == 4) {
-        s16 x = mDirectRelease & 0x3FFF;
+        s32 x = mDirectRelease & 0x3FFF;
         if (_04 < x) {
             updateCurrentValue(x);
         } else {
@@ -98,25 +97,21 @@ void JASOscillator::update() {
 
     if (_1C == 2) return;
 
-    const Point* psVar1;
-    if (_1C == 1) {
-        psVar1 = mData->mTable;
-    } else {
-        psVar1 = mData->rel_table;
-    }
+    const Point* psVar1 = _1C == 1 ? mData->mTable : mData->rel_table;
 
     if (psVar1 == NULL) {
         _1C = 2;
         return;
     }
-    
+
     while (_04 >= psVar1[_14]._2) {
         _04 -= psVar1[_14]._2;
         _08 = _10;
         _14++;
         _0C = _08;
         const s16* ps = &psVar1[_14]._0;
-        switch(ps[0]) {
+        s16 r26 = ps[0];
+        switch(r26) {
         case 0xf:
             _1C = 0;
             return;
@@ -127,7 +122,7 @@ void JASOscillator::update() {
             _14 = ps[2];
             break;
         default:
-            _18 = ps[0];
+            _18 = r26;
             _10 = ps[2] / 32768.0f;
             break;
         }
@@ -172,7 +167,6 @@ void JASOscillator::updateCurrentValue(f32 param_0) {
     f32 fVar1 = 16.0f * (_04 / param_0);
     u32 index = (u32) fVar1;
     f32 fVar3 = (fVar1 - index);
-    f32 fVar2 = (1.0f - fVar3) * table[index];
-    f32 fVar4 = fVar2 + fVar3 * table[index + 1];
+    f32 fVar4 = (1.0f - fVar3) * table[index] + fVar3 * table[index + 1];
     _08 = _0C * fVar4 + _10 * (1.0f - fVar4);
 }
diff --git a/src/JSystem/JAudio2/JAUAudioArcInterpreter.cpp b/src/JSystem/JAudio2/JAUAudioArcInterpreter.cpp
index 2f226b1e1f..aacf8bcdba 100644
--- a/src/JSystem/JAudio2/JAUAudioArcInterpreter.cpp
+++ b/src/JSystem/JAudio2/JAUAudioArcInterpreter.cpp
@@ -98,11 +98,11 @@ bool JAUAudioArcInterpreter::readCommand_() {
         break;
     }
     case 'sect': {
-        readU8_();
         u8 var1 = readU8_();
         u8 var2 = readU8_();
         u8 var3 = readU8_();
-        readMaxSeCategory(var1, var2, var3);
+        u8 var4 = readU8_();
+        readMaxSeCategory(var2, var3, var4);
         break;
     }
     default:
diff --git a/src/JSystem/JAudio2/JAUAudioArcLoader.cpp b/src/JSystem/JAudio2/JAUAudioArcLoader.cpp
index 74b00eda9a..af1952144c 100644
--- a/src/JSystem/JAudio2/JAUAudioArcLoader.cpp
+++ b/src/JSystem/JAudio2/JAUAudioArcLoader.cpp
@@ -2,11 +2,12 @@
 
 #include "JSystem/JAudio2/JAUAudioArcLoader.h"
 #include "JSystem/JAudio2/JAISeMgr.h"
+#include "JSystem/JAudio2/JASReport.h"
 #include "JSystem/JAudio2/JAUSectionHeap.h"
 
 JAUAudioArcLoader::JAUAudioArcLoader(JAUSection* section) {
-    //JUT_ASSERT(13, section->isOpen());
-    //JUT_ASSERT(14, section->isBuilding());
+    JUT_ASSERT(13, section->isOpen());
+    JUT_ASSERT(14, section->isBuilding());
     mSection = section;
 }
 
@@ -68,9 +69,80 @@ void JAUAudioArcLoader::endBNKList() {
 }
 
 void JAUAudioArcLoader::readMaxSeCategory(int param_0, int param_1, int param_2) {
-    JAISeMgr* seMgr = JASGlobalInstance<JAISeMgr>::getInstance();
-    if (seMgr) {
-        seMgr->getCategory(param_0)->setMaxActiveSe(param_1);
-        seMgr->getCategory(param_0)->setMaxInactiveSe(param_2);
+    {
+        JAISeMgr* seMgr = JASGlobalInstance<JAISeMgr>::getInstance();
+        if (seMgr) {
+            seMgr->getCategory(param_0)->setMaxActiveSe(param_1);
+            seMgr->getCategory(param_0)->setMaxInactiveSe(param_2);
+        }
+    }
+}
+
+void JAUAudioArcLoader_withoutCopy::readWS(u32 param_0, void const* param_1, u32 param_2) {
+    mSection->newWaveBank(param_0, param_1);
+    if (param_2) {
+        mSection->loadWaveArc(param_0, param_2);
+    }
+    JASReport(".ws resource remains at Heap Head\n");
+}
+
+void JAUAudioArcLoader_withoutCopy::readBNK(u32 param_0, void const* param_1) {
+    mSection->newBank(param_1, param_0);
+    JASReport(".bnk resource remains at Heap Head\n");
+}
+
+void JAUAudioArcLoader_withoutCopy::readBSC(void const* param_0, u32 param_1) {
+    UNUSED(param_1);
+    mSection->newSeSeqCollection(param_0, 0);
+}
+
+void JAUAudioArcLoader_withoutCopy::readBST(void const* param_0, u32 param_1) {
+    UNUSED(param_1);
+    mSection->newSoundTable(param_0, 0, true);
+}
+
+void JAUAudioArcLoader_withoutCopy::readBSTN(void const* param_0, u32 param_1) {
+    UNUSED(param_1);
+    mSection->newSoundNameTable(param_0, 0, true);
+}
+
+void JAUAudioArcLoader_withoutCopy::readBMS(u32 param_0, void const* param_1, u32 param_2) {
+    UNUSED(param_2);
+    mSection->newStaticSeqData(param_0, param_1, 0);
+}
+
+void JAUAudioArcLoader_withoutCopy::readBMS_fromArchive(u32 param_0) {
+    mSection->newStaticSeqData(param_0);
+}
+
+void JAUAudioArcLoader_withoutCopy::newVoiceBank(u32 param_0, u32 param_1) {
+    mSection->newVoiceBank(param_1, param_0);
+}
+
+void JAUAudioArcLoader_withoutCopy::newDynamicSeqBlock(u32 param_0) {
+    JAUSectionHeap* sectionHeap = mSection->asSectionHeap();
+    JUT_ASSERT(166, sectionHeap);
+    sectionHeap->newDynamicSeqBlock(param_0);
+}
+
+void JAUAudioArcLoader_withoutCopy::readBSFT(void const* param_0) {
+    mSection->newStreamFileTable(param_0, false);
+}
+
+void JAUAudioArcLoader_withoutCopy::beginBNKList(u32 param_0, u32 param_1) {
+    mSection->beginNewBankTable(param_0, param_1);
+}
+
+void JAUAudioArcLoader_withoutCopy::endBNKList() {
+    mSection->endNewBankTable();
+}
+
+void JAUAudioArcLoader_withoutCopy::readMaxSeCategory(int param_0, int param_1, int param_2) {
+    {
+        JAISeMgr* seMgr = JASGlobalInstance<JAISeMgr>::getInstance();
+        if (seMgr) {
+            seMgr->getCategory(param_0)->setMaxActiveSe(param_1);
+            seMgr->getCategory(param_0)->setMaxInactiveSe(param_2);
+        }
     }
 }
diff --git a/src/JSystem/JAudio2/JAUClusterSound.cpp b/src/JSystem/JAudio2/JAUClusterSound.cpp
index 612fcca5dd..66fd255865 100644
--- a/src/JSystem/JAudio2/JAUClusterSound.cpp
+++ b/src/JSystem/JAudio2/JAUClusterSound.cpp
@@ -6,8 +6,11 @@
 
 #include "JSystem/JAudio2/JAUClusterSound.h"
 #include "JSystem/JAudio2/JAISoundHandles.h"
+#include "JSystem/JAudio2/JAISoundStarter.h"
 
 // Dummy function to generate JAISoundHandle::JAISoundHandle
 static void dummyCtor() {
+    JASGlobalInstance<JAISoundStarter>::getInstance();
     JAISoundHandle dummy[20];
+    JAISoundHandles handles(dummy, 20);
 }
diff --git a/src/JSystem/JAudio2/JAUSectionHeap.cpp b/src/JSystem/JAudio2/JAUSectionHeap.cpp
index aee48de91d..cf037011fe 100644
--- a/src/JSystem/JAudio2/JAUSectionHeap.cpp
+++ b/src/JSystem/JAudio2/JAUSectionHeap.cpp
@@ -195,7 +195,7 @@ JAIStreamDataMgr* JAUSection::newStreamFileTable(void const* param_0, bool param
 }
 
 JAISeqDataMgr* JAUSection::newSeSeqCollection(void const* bsc, u32 param_1) {
-    // JUT_ASSERT(398, asSectionHeap() == this);
+    JUT_ASSERT(398, asSectionHeap() == this);
     JUT_ASSERT(399, sectionHeap_->sectionHeapData_.seSeqDataMgr_ == NULL);
     if (param_1) {
         bsc = newCopy(bsc, param_1, 4);
@@ -224,14 +224,16 @@ u8* JAUSection::newStaticSeqDataBlock_(JAISoundID param_0, u32 size) {
         }
         JSULink<JAUSeqDataBlock>* link = new JSULink<JAUSeqDataBlock>(seqDataBlock);
         if (!link) {
+            JUT_WARN(432, "%s", "created UNUSED object in Heap\n");
             return NULL;
         }
         u8* r28 = new(0x20) u8[size];
         if (!r28) {
+            JUT_WARN(438, "%s", "created UNUSED object in Heap\n");
             return NULL;
         }
-        seqDataBlock->field_0x14.addr = r28;
-        seqDataBlock->field_0x14.size = size;
+        seqDataBlock->region.addr = r28;
+        seqDataBlock->region.size = size;
         seqDataBlock->field_0x10 = param_0;
         JASCriticalSection cs;
         if(data_.field_0x00.appendDynamicSeqDataBlock(seqDataBlock)) {
@@ -243,10 +245,12 @@ u8* JAUSection::newStaticSeqDataBlock_(JAISoundID param_0, u32 size) {
 }
 
 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;
+    {
+        u8* r30 = newStaticSeqDataBlock_(param_0, param_2);
+        if (r30) {
+            memcpy(r30, param_1, param_2);
+            return true;
+        }
     }
     return false;
 }
@@ -256,6 +260,7 @@ bool JAUSection::newStaticSeqData(JAISoundID param_0) {
     JUT_ASSERT(481, seqArchive);
     JAUSoundInfo* soundInfo = JASGlobalInstance<JAUSoundInfo>::getInstance();
     if (!soundInfo) {
+        JUT_WARN(485, "%s","cannot JAUSoundInfo::getInstance().");
         return false;
     }
     u16 r26 = soundInfo->getBgmSeqResourceID(param_0);
@@ -286,15 +291,17 @@ static bool dummy_string(int i) {
 JASWaveBank* JAUSection::newWaveBank(u32 bank_no, void const* param_1) {
     JUT_ASSERT(528, isOpen());
     JUT_ASSERT(529, isBuilding());
-    TPushCurrentHeap push(getHeap_());
-    s32 r27 = getHeap_()->getFreeSize();
-    JASWaveBank* waveBank = JASWSParser::createWaveBank(param_1, getHeap_());
-    if (waveBank) {
-        JUT_ASSERT(536, sectionHeap_->getWaveBankTable().getWaveBank( bank_no ) == NULL);
-        sectionHeap_->getWaveBankTable().registWaveBank(bank_no, waveBank);
-        data_.registeredWaveBankTables.set(bank_no, true);
-        data_.field_0xa0 += r27 - getHeap_()->getFreeSize();
-        return waveBank;
+    {
+        TPushCurrentHeap push(getHeap_());
+        s32 r27 = getHeap_()->getFreeSize();
+        JASWaveBank* waveBank = JASWSParser::createWaveBank(param_1, getHeap_());
+        if (waveBank) {
+            JUT_ASSERT(536, sectionHeap_->getWaveBankTable().getWaveBank( bank_no ) == NULL);
+            sectionHeap_->getWaveBankTable().registWaveBank(bank_no, waveBank);
+            data_.registeredWaveBankTables.set(bank_no, true);
+            data_.field_0xa0 += r27 - getHeap_()->getFreeSize();
+            return waveBank;
+        }
     }
     return NULL;
 
@@ -306,7 +313,8 @@ bool JAUSection::loadWaveArc(u32 param_0, u32 param_1) {
         if (waveBank) {
             for (u32 i = 0; i < waveBank->getArcCount(); i++) {
                 if (param_1 & 1 << i) {
-                    waveBank->getWaveArc(i)->load(NULL);
+                    JASWaveArc* waveArc = waveBank->getWaveArc(i);
+                    waveArc->load(NULL);
                 }
             }
             return true;
@@ -320,22 +328,24 @@ JASBank* JAUSection::newBank(void const* param_0, u32 param_1) {
     JUT_ASSERT(648, isBuilding());
     JASWaveBank* waveBank = sectionHeap_->getWaveBankTable().getWaveBank(param_1);
     JUT_ASSERT(650, waveBank != NULL);
-    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(660, buildingBankTable_->getBank( bank_no ) == NULL);
-            buildingBankTable_->registBank(bank_no, bank);
-        } else {
-            JUT_ASSERT(665, JASDefaultBankTable::getInstance() ->getBank( bank_no ) == NULL);
-            JASDefaultBankTable::getInstance()->registBank(bank_no, bank);
-            data_.registeredBankTables.set(bank_no, true);
+    {
+        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(660, buildingBankTable_->getBank( bank_no ) == NULL);
+                buildingBankTable_->registBank(bank_no, bank);
+            } else {
+                JUT_ASSERT(665, JASDefaultBankTable::getInstance() ->getBank( bank_no ) == NULL);
+                JASDefaultBankTable::getInstance()->registBank(bank_no, bank);
+                data_.registeredBankTables.set(bank_no, true);
+            }
+            bank->assignWaveBank(waveBank);
+            data_.field_0x9c += r25 - getHeap_()->getFreeSize();
+            return bank;
         }
-        bank->assignWaveBank(waveBank);
-        data_.field_0x9c += r25 - getHeap_()->getFreeSize();
-        return bank;
     }
     return 0;
 }
@@ -377,10 +387,10 @@ bool JAUSection::beginNewBankTable(u32 param_0, u32 param_1) {
             if (bankTableLink) {
                 buildingBankTable_ = bankTableLink;
             } else {
-
+                JUT_WARN(730, "%s","created UNUSED object in Heap\n");
             }
         } else {
-
+            JUT_WARN(735, "%s","created UNUSED object in Heap\n");
         }
     }
     return bankTableLink;
@@ -406,7 +416,8 @@ JAUSectionHeap::TSectionHeapData::TSectionHeapData() {
 
 void JAUSectionHeap::setSeqDataArchive(JKRArchive* param_0) {
     sectionHeapData_.seqDataBlocks.setSeqDataArchive(param_0);
-    for (JSULink<JAUSection>* link = mSectionList.getFirst(); link; link = link->getNext()) {
+    JSULink<JAUSection>* link;
+    for (link = mSectionList.getFirst(); link; link = link->getNext()) {
         link->getObject()->data_.field_0x00.setSeqDataArchive(param_0);
     }
 }
@@ -423,7 +434,8 @@ static JAUSectionHeap* JAUNewSectionHeap(JKRSolidHeap* heap, bool param_1) {
     JUT_ASSERT(809, JKRSolidHeap_isEmpty( heap ));
     TPushCurrentHeap push(heap);
     s32 r29 = heap->getFreeSize();
-    return new JAUSectionHeap(heap, param_1, r29);
+    JAUSectionHeap* sectionHeap = new JAUSectionHeap(heap, param_1, r29);
+    return sectionHeap;
 }
 
 JAUSectionHeap* JAUNewSectionHeap(bool param_0) {
@@ -443,42 +455,61 @@ JAUSection* JAUSectionHeap::getOpenSection() {
     return mSectionList.getLast()->getObject();
 }
 
+JAUSection* JAUSectionHeap::getSection(int param_0) {
+    JSULink<JAUSection>* link = mSectionList.getFirst();
+    while (param_0 > 0) {
+        JSULink<JAUSection>* link2 = link->getNext();
+        if (!link2) {
+            return NULL;
+        }
+        link = link2;
+        param_0--;
+    }
+    return link->getObject();
+}
+
 bool JAUSectionHeap::setSeqDataUser(JAISeqDataUser* param_0) {
     sectionHeapData_.seqDataUser = param_0;
     return true;
 }
 
 bool JAUSectionHeap::newDynamicSeqBlock(u32 size) {
-    /* JUT_ASSERT(937, isOpen());
+    JUT_ASSERT(937, isOpen());
     JUT_ASSERT(938, isBuilding());
-    JUT_ASSERT(939, sectionHeap_ == this); */
-    TPushCurrentHeap push(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[size];
-    if (!r25) {
-        return false;
-    }
-    seqDataBlock->field_0x14.addr = r25;
-    seqDataBlock->field_0x14.size = size;
-    seqDataBlock->field_0x10.setAnonymous();
-    JASCriticalSection cs;
-    if (sectionHeap_->sectionHeapData_.seqDataBlocks.appendDynamicSeqDataBlock(seqDataBlock)) {
-        return true;
+    JUT_ASSERT(939, sectionHeap_ == this);
+    {
+        TPushCurrentHeap push(getHeap_());
+        JAUSeqDataBlock * seqDataBlock = new JAUSeqDataBlock();
+        if (!seqDataBlock) {
+            return false;
+        }
+        JSULink<JAUSeqDataBlock> * link = new JSULink<JAUSeqDataBlock>(seqDataBlock);
+        if (!link) {
+            JUT_WARN(950, "%s", "created UNUSED object in Heap\n");
+            return false;
+        }
+        u8* r25 = new(0x20) u8[size];
+        if (!r25) {
+            JUT_WARN(956, "%s", "created UNUSED object in Heap\n");
+            return false;
+        }
+        seqDataBlock->region.addr = r25;
+        seqDataBlock->region.size = size;
+        seqDataBlock->field_0x10.setAnonymous();
+        JASCriticalSection cs;
+        if (sectionHeap_->sectionHeapData_.seqDataBlocks.appendDynamicSeqDataBlock(seqDataBlock)) {
+            return true;
+        }
+        JUT_WARN(968, "%s","created UNUSED object in Heap\n");
     }
     return false;
 }
 
 JAISeqDataMgr::SeqDataReturnValue JAUSectionHeap::getSeqData(JAISoundID param_0, JAISeqData* param_1) {
+    const int JAI_ASYNC_RESULT_RETRY = 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(994, result != JAI_ASYNC_RESULT_RETRY);
+        JUT_ASSERT(994, result != JAI_ASYNC_RESULT_RETRY);
         if (result == 2) {
             return JAISeqDataMgr::SeqDataReturnValue_2;
         }
@@ -487,5 +518,6 @@ JAISeqDataMgr::SeqDataReturnValue JAUSectionHeap::getSeqData(JAISoundID param_0,
 }
 
 int JAUSectionHeap::releaseSeqData() {
+    JUT_WARN(1005, "%s", "JAUSectionHeap cannot release SeqData all at once. Please pop Section.\n");
     return 0;
 }
diff --git a/src/JSystem/JAudio2/JAUSeqCollection.cpp b/src/JSystem/JAudio2/JAUSeqCollection.cpp
index a9787321f3..074862e521 100644
--- a/src/JSystem/JAudio2/JAUSeqCollection.cpp
+++ b/src/JSystem/JAudio2/JAUSeqCollection.cpp
@@ -24,7 +24,8 @@ bool JAUSeqCollection::getSeqData(int param_0, int param_1, JAISeqData* param_2)
     if (param_0 >= field_0x0) {
         return false;
     }
-    u32* puVar2 = (u32*)((u8*)field_0x8 + field_0x4[param_0]);
+    u32 r29 = field_0x4[param_0];
+    u32* puVar2 = (u32*)((u8*)field_0x8 + r29);
     if (param_1 >= puVar2[0]) {
         return false;
     }
@@ -55,7 +56,8 @@ int JAUSeqDataMgr_SeqCollection::releaseSeqData() {
     if (user_) {
         JAISeqDataRegion region;
         getSeqDataRegion(&region);
-        return user_->releaseSeqData(region);
+        int result = user_->releaseSeqData(region);
+        return result;
     }
     return 2;
 }
diff --git a/src/JSystem/JAudio2/JAUSeqDataBlockMgr.cpp b/src/JSystem/JAudio2/JAUSeqDataBlockMgr.cpp
index a5bb6ae620..37e0577413 100644
--- a/src/JSystem/JAudio2/JAUSeqDataBlockMgr.cpp
+++ b/src/JSystem/JAudio2/JAUSeqDataBlockMgr.cpp
@@ -20,7 +20,7 @@ u8* JAUSeqDataBlocks::getSeqData(JAISoundID param_0) {
             link = link->getNext())
     {
         if ((u32)link->getObject()->field_0x10 == (u32)param_0) {
-            return link->getObject()->field_0x14.addr;
+            return link->getObject()->region.addr;
         }
     }
     return NULL;
@@ -32,7 +32,7 @@ JSULink<JAUSeqDataBlock>* JAUSeqDataBlocks::seekFreeBlock(u32 size) {
     for (JSULink<JAUSeqDataBlock>* link = getFirst(); link != NULL; link = link->getNext())
     {
         if (link->getObject()->field_0x10.isAnonymous()) {
-            u32 blockSize = link->getObject()->field_0x14.size;
+            u32 blockSize = link->getObject()->region.size;
             if (blockSize >= size && blockSize < currentBlockSize) {
                 rv = link;
                 currentBlockSize = blockSize;
@@ -54,8 +54,8 @@ bool JAUSeqDataBlocks::remove(JSULink<JAUSeqDataBlock>* param_0) {
 }
 
 bool JAUSeqDataBlocks::hasFailedBlock(JAISoundID param_0) {
-    JSULink<JAUSeqDataBlock>* rv = NULL;
-    for (JSULink<JAUSeqDataBlock>* link = getFirst(); link != NULL; link = link->getNext())
+    JSULink<JAUSeqDataBlock>* link;
+    for (link = getFirst(); link != NULL; link = link->getNext())
     {
         if (link->getObject()->field_0x10 == param_0) {
             link->getObject()->field_0x10.setAnonymous();
@@ -70,6 +70,7 @@ JAUDynamicSeqDataBlocks::JAUDynamicSeqDataBlocks() {
 }
 
 void JAUDynamicSeqDataBlocks::setSeqDataArchive(JKRArchive* param_0) {
+    JUT_ASSERT(104, seqDataArchive_ == NULL);
     seqDataArchive_ = param_0;
 }
 
@@ -98,17 +99,21 @@ s32 JAUDynamicSeqDataBlocks::getSeqData(JAISoundID param_0, JAISeqDataUser* para
 }
 
 bool JAUDynamicSeqDataBlocks::appendDynamicSeqDataBlock(JAUSeqDataBlock* seqDataBlock) {
+    JUT_ASSERT(135, ( reinterpret_cast < u32 > ( seqDataBlock->region.addr ) & 0x1f ) == 0);
     rearrangeLoadingSeqs_();
+    bool result;
     if (seqDataBlock->field_0x10.isAnonymous()) {
-        mFreeBlocks.append(&seqDataBlock->field_0x0);
+        result = mFreeBlocks.append(&seqDataBlock->field_0x0);
     } else {
-        mLoadedBlocks.append(&seqDataBlock->field_0x0);
+        result = mLoadedBlocks.append(&seqDataBlock->field_0x0);
     }
+    JUT_ASSERT(144, result);
     return 1;
 }
 
 static void JAUDynamicSeqDataBlocks_receiveLoaded_(u32 param_0, u32 param_1) {
-    JAUSeqDataBlock* seqDataBlock = ((JSULink<JAUSeqDataBlock>*)param_1)->getObject();
+    JSULink<JAUSeqDataBlock>* link = (JSULink<JAUSeqDataBlock>*)param_1;
+    JAUSeqDataBlock* seqDataBlock = link->getObject();
     if (param_0 != NULL) {
         seqDataBlock->field_0x1c = 2;
     } else {
@@ -118,35 +123,38 @@ static void JAUDynamicSeqDataBlocks_receiveLoaded_(u32 param_0, u32 param_1) {
 
 bool JAUDynamicSeqDataBlocks::loadDynamicSeq(JAISoundID param_0, bool param_1,
                                              JAISeqDataUser* param_2) {
-    if (seqDataArchive_ == NULL) {
-        return false;
-    }
-    JAUSoundInfo* soundInfo = JASGlobalInstance<JAUSoundInfo>::getInstance();
-    if (soundInfo == NULL) {
-        return false;
-    } 
-    u16 resourceId = soundInfo->getBgmSeqResourceID(param_0);
-    size_t resSize = JASResArcLoader::getResSize(seqDataArchive_, resourceId);
-    JSULink<JAUSeqDataBlock>* link = mFreeBlocks.seekFreeBlock(resSize);
-    if (link == NULL) {
-        if (param_1) {
-            link = &releaseIdleDynamicSeqDataBlock_(param_2, resSize)->field_0x0;
-            if (link == NULL) {
+    {
+        if (seqDataArchive_ == NULL) {
+            JUT_WARN(192, "%s", "cannot get sequence data archive.");
+            return false;
+        }
+        JAUSoundInfo* soundInfo = JASGlobalInstance<JAUSoundInfo>::getInstance();
+        if (soundInfo == NULL) {
+            JUT_WARN(198, "%s", "cannot JAUSoundInfo::getInstance().");
+            return false;
+        }
+        u16 resourceId = soundInfo->getBgmSeqResourceID(param_0);
+        size_t resSize = JASResArcLoader::getResSize(seqDataArchive_, resourceId);
+        JSULink<JAUSeqDataBlock>* link = mFreeBlocks.seekFreeBlock(resSize);
+        if (link == NULL) {
+            if (param_1) {
+                link = &releaseIdleDynamicSeqDataBlock_(param_2, resSize)->field_0x0;
+                if (link == NULL) {
+                    return false;
+                }
+            } else {
                 return false;
             }
-        } else {
-            return false;
         }
+        mFreeBlocks.remove(link);
+        link->getObject()->field_0x10 = param_0;
+        link->getObject()->field_0x1c = 1;
+        field_0xc.append(link);
+        JASResArcLoader::loadResourceAsync(
+            seqDataArchive_, resourceId,
+            link->getObject()->region.addr, link->getObject()->region.size,
+            JAUDynamicSeqDataBlocks_receiveLoaded_, (u32)link);
     }
-    mFreeBlocks.remove(link);
-    JAUSeqDataBlock* seqDataBlock = link->getObject();
-    seqDataBlock->field_0x10 = param_0;
-    link->getObject()->field_0x1c = 1;
-    field_0xc.append(link);
-    JASResArcLoader::loadResourceAsync(
-        seqDataArchive_, resourceId,
-        link->getObject()->field_0x14.addr, link->getObject()->field_0x14.size,
-        JAUDynamicSeqDataBlocks_receiveLoaded_, (u32)link);
     return true;
 }
 
@@ -157,12 +165,12 @@ u32 JAUDynamicSeqDataBlocks::releaseIdleDynamicSeqDataBlock(JAISeqDataUser* para
     for (JSULink<JAUSeqDataBlock>* link = mLoadedBlocks.getFirst(); link != NULL; ) {
         nextLink = link->getNext();
         JAUSeqDataBlock* seqDataBlock = link->getObject();
-        if (param_0 == NULL || !param_0->isUsingSeqData(seqDataBlock->field_0x14)) {
+        if (param_0 == NULL || !param_0->isUsingSeqData(seqDataBlock->region)) {
             mLoadedBlocks.remove(link);
             JAUSeqDataBlock* seqDataBlock = link->getObject();
-            link->getObject()->field_0x10.setAnonymous();
-            if (size < seqDataBlock->field_0x14.size) {
-                size = seqDataBlock->field_0x14.size;
+            seqDataBlock->field_0x10.setAnonymous();
+            if (size < seqDataBlock->region.size) {
+                size = seqDataBlock->region.size;
             }
             mFreeBlocks.append(link);
         }
@@ -181,8 +189,8 @@ JAUDynamicSeqDataBlocks::releaseIdleDynamicSeqDataBlock_(JAISeqDataUser* param_0
     while (link != NULL) {
         nextLink = link->getNext();
         JAUSeqDataBlock* seqDataBlock = link->getObject();
-        if (param_0 == NULL || !param_0->isUsingSeqData(seqDataBlock->field_0x14)) {
-            u32 size = seqDataBlock->field_0x14.size;
+        if (param_0 == NULL || !param_0->isUsingSeqData(seqDataBlock->region)) {
+            u32 size = seqDataBlock->region.size;
             if (size >= param_1 && size < minSize) {
                 foundBlock = link;
                 minSize = size;
diff --git a/src/JSystem/JAudio2/JAUStreamFileTable.cpp b/src/JSystem/JAudio2/JAUStreamFileTable.cpp
index ccd18b890c..f30c5c4a01 100644
--- a/src/JSystem/JAudio2/JAUStreamFileTable.cpp
+++ b/src/JSystem/JAudio2/JAUStreamFileTable.cpp
@@ -7,18 +7,17 @@ JAUStreamFileTable::JAUStreamFileTable() {
 }
 
 void JAUStreamFileTable::init(void const* data) {
-    if (data == NULL) {
+    const BinaryStreamFileTable* binaryTable = (const BinaryStreamFileTable*)data;
+    if (binaryTable == NULL) {
         mData = NULL;
         return;
     }
-    const BinaryStreamFileTable* binaryTable = (const BinaryStreamFileTable*)data;
-    const char* ident = binaryTable->mIdentifier;
-    if (ident[0] == 'b' && ident[1] == 's' && ident[2] == 'f' && ident[3] == 't') {
+    if (binaryTable->mIdentifier[0] == 'b' && binaryTable->mIdentifier[1] == 's' && binaryTable->mIdentifier[2] == 'f' && binaryTable->mIdentifier[3] == 't') {
         mData = binaryTable;
     }
 }
 
-int JAUStreamFileTable::getNumFiles() const {
+u32 JAUStreamFileTable::getNumFiles() const {
     return mData->mNumFiles;
 }
 
@@ -26,8 +25,8 @@ const char* JAUStreamFileTable::getFilePath(int index) const {
     if (mData == NULL) {
         return 0;
     }
-    ASSERT(index >= 0);
-    ASSERT(index < getNumFiles());
+    JUT_ASSERT(52, index >= 0);
+    JUT_ASSERT(53, index < getNumFiles());
     char* data = (char*)mData;
     return (char*)(data + *(int*)(data + 8 + (index * sizeof(s32))));
 }
diff --git a/src/JSystem/JKernel/JKRHeap.cpp b/src/JSystem/JKernel/JKRHeap.cpp
index cabbbb3179..82321544a7 100644
--- a/src/JSystem/JKernel/JKRHeap.cpp
+++ b/src/JSystem/JKernel/JKRHeap.cpp
@@ -10,6 +10,8 @@
 #include "JSystem/JUtility/JUTException.h"
 #include <stdint.h>
 
+void* ARALT_AramStartAdr = (void*)0x90000000;
+
 bool data_804508B0 = 1;
 
 #if DEBUG
@@ -447,6 +449,8 @@ void JKRHeap::state_dump(const JKRHeap::TState& p) const {
     JUT_LOG(1248, "used size  : %u", p.getUsedSize());
 }
 
+void* JKRHeap::getAltAramStartAdr() { return ARALT_AramStartAdr; }
+
 s32 JKRHeap::do_changeGroupID(u8 param_0) {
     return 0;
 }