Merge pull request #135 from TakaRikka/pjb-audio

Audio

libs/JSystem/src/J3DGraphBase/J3DSys.cpp

@@ -17,7 +17,11 @@ Vec J3DSys::mParentS;
 
 J3DTexCoordScaleInfo J3DSys::sTexCoordScaleTable[8];
 
+#if TARGET_PC // Original game bug, array is too small.
+static u8 NullTexData[0x20] ATTRIBUTE_ALIGN(32) = {0};
+#else
 static u8 NullTexData[0x10] ATTRIBUTE_ALIGN(32) = {0};
+#endif
 
 static Mtx j3dIdentityMtx = {
     1.0f, 0.0f, 0.0f, 0.0f,

libs/JSystem/src/JAudio2/JAIAudience.cpp

@@ -1,11 +1,20 @@
 #include "JSystem/JSystem.h" // IWYU pragma: keep
 
 #include "JSystem/JAudio2/JAIAudience.h"
+
 #include "JSystem/JAudio2/JAISeMgr.h"
 #include "JSystem/JAudio2/JAISeqMgr.h"
 #include "JSystem/JAudio2/JAIStreamMgr.h"
+#include "dusk/main.h"
 
 JAIAudience::~JAIAudience() {
+#if TARGET_PC
+    if (dusk::IsShuttingDown) {
+        // Those asserts down there crash on shutdown from dtors.
+        return;
+    }
+#endif
+
     JUT_ASSERT(14, ! JAISeMgr::getInstance() || ( JAISeMgr::getInstance() ->getAudience() != this ));
     JUT_ASSERT(15, ! JAISeqMgr::getInstance() || ( JAISeqMgr::getInstance() ->getAudience() != this ));
     JUT_ASSERT(16, ! JAIStreamMgr::getInstance() || ( JAIStreamMgr::getInstance() ->getAudience() != this ));

libs/JSystem/src/JAudio2/JAISe.cpp

@@ -57,7 +57,7 @@ void JAISe::startTrack_(const JASSoundParams& params) {
     }
 
     inner_.field_0x26c = 1;
-    inner_.track.setSeqData(inner_.mSeqData.field_0x0, inner_.mSeqData.field_0x4);
+    inner_.track.setSeqData(inner_.mSeqData.mBase, inner_.mSeqData.mOffset);
     inner_.track.startSeq();
 }
 

libs/JSystem/src/JAudio2/JAISeq.cpp

@@ -40,7 +40,7 @@ void JAISeq::JAISeqMgr_startID_(JAISoundID id, const JGeometry::TVec3<f32>* posP
 void JAISeq::playSeqData_(const JASSoundParams& params, JAISoundActivity activity) {
     JUT_ASSERT(72, JASTrack_isFreeOrStopped( & inner_.outputTrack ));
 
-    inner_.outputTrack.setSeqData(inner_.mSeqData.field_0x0, inner_.mSeqData.field_0x4);
+    inner_.outputTrack.setSeqData(inner_.mSeqData.mBase, inner_.mSeqData.mOffset);
     if (audible_) {
         initTrack_JAISound_(&inner_.outputTrack);
     } else {

libs/JSystem/src/JAudio2/JAIStream.cpp

@@ -48,7 +48,7 @@ void JAIStream::JAIStreamMgr_startID_(JAISoundID id, s32 streamFileEntry,
 }
 
 bool JAIStream::prepare_prepareStream_() {
-    u32 local_28;
+    u32 size;
     JAIStreamAramMgr* streamAramMgr;
 
     switch (field_0x290) {
@@ -56,9 +56,9 @@ bool JAIStream::prepare_prepareStream_() {
         streamAramMgr = streamMgr_->getStreamAramMgr();
         JUT_ASSERT(100, streamAramMgr);
 
-        streamAramAddr_ = streamAramMgr->newStreamAram(&local_28);
+        streamAramAddr_ = streamAramMgr->newStreamAram(&size);
         if (streamAramAddr_ != NULL) {
-            inner_.aramStream_.init((uintptr_t)streamAramAddr_, local_28, &JAIStream_JASAramStreamCallback_, this);
+            inner_.aramStream_.init((uintptr_t)streamAramAddr_, size, &JAIStream_JASAramStreamCallback_, this);
             field_0x290 = 1;
             prepareCount_ = 0;
         } else {

libs/JSystem/src/JAudio2/JASAiCtrl.cpp

@@ -98,7 +98,10 @@ void JASDriver::setOutputRate(JASOutputRate param_0) {
         sSubFrames = 10;
         sDacRate = 48000.0f;
     }
+
+#if !TARGET_PC
     sDacRate *= 1.0008897f;
+#endif
 }
 
 const JASDriver::MixFunc JASDriver::sMixFuncs[4] = {
@@ -149,6 +152,8 @@ void JASDriver::updateDSP() {
 
     JASPortCmd::execAllCommand();
     DSPSyncCallback();
+#if !TARGET_PC
+    // Safety kill code? Our audio engine isn't consistent enough and hits this incorrectly.
     static u32 old_time = 0;
     static u32 history[10] = {0x000F4240};
     u32 r28 = OSGetTick();
@@ -169,6 +174,7 @@ void JASDriver::updateDSP() {
         JASDSPChannel::killActiveChannel();
         #endif
     }
+#endif
     JASChannel::receiveBankDisposeMsg();
     JASDSPChannel::updateAll();
 
@@ -271,11 +277,11 @@ u32 JASDriver::getSubFrames() {
 }
 
 u32 JASDriver::getDacSize() {
-    return sSubFrames * 0x50 * 2;
+    return sSubFrames * DSP_SUBFRAME_SIZE * 2;
 }
 
 u32 JASDriver::getFrameSamples() {
-    return sSubFrames * 0x50;
+    return sSubFrames * DSP_SUBFRAME_SIZE;
 }
 
 void JASDriver::mixMonoTrack(s16* buffer, u32 param_1, MixCallback param_2) {

libs/JSystem/src/JAudio2/JASAramStream.cpp

@@ -1,11 +1,12 @@
 #include "JSystem/JSystem.h" // IWYU pragma: keep
 
-#include "JSystem/JAudio2/JASAramStream.h"
 #include "JSystem/JAudio2/JASAiCtrl.h"
+#include "JSystem/JAudio2/JASAramStream.h"
+#include "JSystem/JAudio2/JASAudioThread.h"
 #include "JSystem/JAudio2/JASChannel.h"
 #include "JSystem/JAudio2/JASCriticalSection.h"
-#include "JSystem/JAudio2/JASDriverIF.h"
 #include "JSystem/JAudio2/JASDSPInterface.h"
+#include "JSystem/JAudio2/JASDriverIF.h"
 #include "JSystem/JAudio2/JASDvdThread.h"
 #include "JSystem/JKernel/JKRAram.h"
 #include "JSystem/JKernel/JKRSolidHeap.h"
@@ -19,8 +20,23 @@ u32 JASAramStream::sBlockSize;
 
 u32 JASAramStream::sChannelMax;
 
-bool struct_80451260;
-bool struct_80451261;
+bool dvdHasErrored;
+bool hasErrored;
+
+#define PAUSE_REQUESTED   1
+#define PAUSE_DVD_ERROR   2
+#define PAUSE_UNDERFLOW   4
+#define PAUSE_OTHER_ERROR 8
+
+// CMDs for mMainCommandQueue.
+#define CMD_START   0
+#define CMD_STOP    1 // upper 16 bits of cmd contain oscillator direct release value.
+#define CMD_PAUSE   2
+#define CMD_UNPAUSE 3
+
+// CMDs for mLoadCommandQueue
+#define CMD_PREPARE_FINISHED 4
+#define CMD_LOOP_END_LOADED  5
 
 void JASAramStream::initSystem(u32 block_size, u32 channel_max) {
     JUT_ASSERT(66, block_size % 32 == 0);
@@ -33,42 +49,46 @@ void JASAramStream::initSystem(u32 block_size, u32 channel_max) {
         if (sLoadThread == NULL) {
             sLoadThread = JASDvd::getThreadPointer();
         }
+
+        // Pretty sure this 0x20 corresponds to sizeof(BlockHeader).
+        // But that shouldn't be getting multiplied by the channel count.
+        // Bug in the original game, I guess?
         sReadBuffer = JKR_NEW_ARRAY_ARGS(u8, (block_size + 0x20) * channel_max, JASDram, 0x20);
         JUT_ASSERT(79, sReadBuffer);
         sBlockSize = block_size;
         sChannelMax = channel_max;
-        struct_80451260 = false;
-        struct_80451261 = false;
+        dvdHasErrored = false;
+        hasErrored = false;
     }
 }
 
 JASAramStream::JASAramStream() {
-    field_0x0a8 = NULL;
-    field_0x0ac = false;
-    field_0x0ad = false;
-    field_0x0ae = 0;
+    mPrimaryChannel = NULL;
+    mPrepareFinished = false;
+    mLoopEndLoaded = false;
+    mPauseFlags = 0;
     field_0x0b0 = 0;
-    field_0x0b4 = 0;
-    field_0x0b8 = 0;
+    mLastSamplesLeft = 0;
+    mReadSample = 0;
     field_0x0bc = 0;
-    field_0x0c0 = false;
+    mEndSetup = false;
     field_0x0c4 = 0;
     field_0x0c8 = 0.0f;
-    field_0x108 = 0;
-    field_0x10c = 0;
+    mRingEndIndex = 0;
+    mBlockRingIndex = 0;
     mBlock = 0;
-    field_0x114 = 0;
-    field_0x118 = 0;
-    field_0x12c = 0;
-    field_0x148 = 0;
-    field_0x14c = 0;
+    mIsCancelled = 0;
+    mPendingLoadTasks = 0;
+    mChannelUpdateFlags = 0;
+    mAramAddress = 0;
+    mAramSize = 0;
     mCallback = NULL;
     mCallbackData = NULL;
-    field_0x158 = 0;
+    mFormat = 0;
     mChannelNum = 0;
     mBufCount = 0;
-    field_0x160 = 0;
-    field_0x164 = 0;
+    mAramBlocksPerChannel = 0;
+    mSampleRate = 0;
     mLoop = false;
     mLoopStart = 0;
     mLoopEnd = 0;
@@ -76,27 +96,27 @@ JASAramStream::JASAramStream() {
     mPitch = 1.0f;
     for (int i = 0; i < 6; i++) {
         mChannels[i] = NULL;
-        field_0x130[i] = 0;
-        field_0x13c[i] = 0;
+        mpLasts[i] = 0;
+        mpPenults[i] = 0;
         mChannelVolume[i] = 1.0f;
         mChannelPan[i] = 0.5f;
         mChannelFxMix[i] = 0.0f;
         mChannelDolby[i] = 0.0f;
     }
     for (int i = 0; i < 6; i++) {
-        field_0x1dc[i] = 0;
+        mMixConfig[i] = 0;
     }
 }
 
-void JASAramStream::init(u32 param_0, u32 param_1, StreamCallback i_callback, void* i_callbackData) {
+void JASAramStream::init(u32 aramAddress, u32 aramSize, StreamCallback i_callback, void* i_callbackData) {
     JUT_ASSERT(153, sReadBuffer != NULL);
-    field_0x148 = param_0;
-    field_0x14c = param_1;
+    mAramAddress = aramAddress;
+    mAramSize = aramSize;
     field_0x0c8 = 0.0f;
-    field_0x0ae = 0;
-    field_0x0ac = false;
-    field_0x0ad = false;
-    field_0x114 = 0;
+    mPauseFlags = 0;
+    mPrepareFinished = false;
+    mLoopEndLoaded = false;
+    mIsCancelled = 0;
     mChannelNum = 0;
     for (int i = 0; i < 6; i++) {
         mChannelVolume[i] = 1.0f;
@@ -106,11 +126,11 @@ void JASAramStream::init(u32 param_0, u32 param_1, StreamCallback i_callback, vo
     }
     mVolume = 1.0f;
     mPitch = 1.0f;
-    field_0x1dc[0] = 0xffff;
+    mMixConfig[0] = 0xffff;
     mCallback = i_callback;
     mCallbackData = i_callbackData;
-    OSInitMessageQueue(&field_0x000, field_0x040, 0x10);
-    OSInitMessageQueue(&field_0x020, field_0x080, 4);
+    OSInitMessageQueue(&mMainCommandQueue, mMainCommandQueueArray, ARRAY_SIZEU(mMainCommandQueueArray));
+    OSInitMessageQueue(&mLoadCommandQueue, mLoadCommandQueueArray, ARRAY_SIZEU(mLoadCommandQueueArray));
 }
 
 bool JASAramStream::prepare(s32 param_0, int param_1) {
@@ -124,9 +144,9 @@ bool JASAramStream::prepare(s32 param_0, int param_1) {
     }
     TaskData data;
     data.stream = this;
-    data.field_0x4 = field_0x14c;
-    data.field_0x8 = param_1;
-    if (!sLoadThread->sendCmdMsg(headerLoadTask, &data, 0xc)) {
+    data.param0 = mAramSize;
+    data.param1 = param_1;
+    if (!sLoadThread->sendCmdMsg(headerLoadTask, &data, sizeof(data))) {
         JUT_WARN(254, "%s", "sendCmdMsg headerLoadTask Failed");
         JASDriver::rejectCallback(channelProcCallback, this);
         return false;
@@ -135,24 +155,24 @@ bool JASAramStream::prepare(s32 param_0, int param_1) {
 }
 
 bool JASAramStream::start() {
-    if (!OSSendMessage(&field_0x000, (OSMessage)0, OS_MESSAGE_NOBLOCK)) {
+    if (!OSSendMessage(&mMainCommandQueue, (OSMessage)CMD_START, OS_MESSAGE_NOBLOCK)) {
         JUT_WARN(273, "%s", "OSSendMessage Failed")
         return false;
     }
     return true;
 }
 
-bool JASAramStream::stop(u16 param_0) {
-    if (!OSSendMessage(&field_0x000, (OSMessage)(uintptr_t)(param_0 << 0x10 | 1), OS_MESSAGE_NOBLOCK)) {
+bool JASAramStream::stop(u16 directRelease) {
+    if (!OSSendMessage(&mMainCommandQueue, (OSMessage)(uintptr_t)(directRelease << 0x10 | CMD_STOP), OS_MESSAGE_NOBLOCK)) {
         JUT_WARN(290, "%s", "OSSendMessage Failed");
         return false;
     }
     return true;
 }
 
-bool JASAramStream::pause(bool param_0) {
-    OSMessage msg = param_0 ? (OSMessage)2 : (OSMessage)3;
-    if (!OSSendMessage(&field_0x000, msg, OS_MESSAGE_NOBLOCK)) {
+bool JASAramStream::pause(bool newPauseFlag) {
+    OSMessage msg = newPauseFlag ? (OSMessage)CMD_PAUSE : (OSMessage)CMD_UNPAUSE;
+    if (!OSSendMessage(&mMainCommandQueue, msg, OS_MESSAGE_NOBLOCK)) {
         JUT_WARN(308, "%s", "OSSendMessage Failed");
         return false;
     }
@@ -160,7 +180,7 @@ bool JASAramStream::pause(bool param_0) {
 }
 
 bool JASAramStream::cancel() {
-    field_0x114 = 1;
+    mIsCancelled = 1;
     if (!sLoadThread->sendCmdMsg(finishTask, this)) {
         JUT_WARN(326, "%s", "sendCmdMsg finishTask Failed");
         return false;
@@ -169,12 +189,12 @@ bool JASAramStream::cancel() {
 }
 
 u32 JASAramStream::getBlockSamples() const {
-    return field_0x158 == 0 ? (sBlockSize << 4) / 9 : sBlockSize >> 1;
+    return mFormat == STREAM_FORMAT_ADPCM4 ? (sBlockSize << 4) / 9 : sBlockSize >> 1;
 }
 
 void JASAramStream::headerLoadTask(void* i_data) {
     TaskData* data = (TaskData*)i_data;
-    data->stream->headerLoad(data->field_0x4, data->field_0x8);
+    data->stream->headerLoad(data->param0, data->param1);
 }
 
 void JASAramStream::firstLoadTask(void* i_data) {
@@ -183,23 +203,23 @@ void JASAramStream::firstLoadTask(void* i_data) {
     if (!_this->load()) {
         return;
     }
-    if (data->field_0x8 > 0) {
-        data->field_0x8--;
-        if (data->field_0x8 == 0) {
+    if (data->param1 > 0) {
+        data->param1--;
+        if (data->param1 == 0) {
             if (!sLoadThread->sendCmdMsg(prepareFinishTask, _this)) {
                 JUT_WARN(364, "%s", "sendCmdMsg prepareFinishTask Failed");
-                struct_80451261 = true;
+                hasErrored = true;
             }
         }
     }
-    if (data->field_0x4 != 0) {
-        data->field_0x4--;
-        if (!sLoadThread->sendCmdMsg(firstLoadTask, data, 0xc)) {
+    if (data->param0 != 0) {
+        data->param0--;
+        if (!sLoadThread->sendCmdMsg(firstLoadTask, data, sizeof(*data))) {
             JUT_WARN(372, "%s", "sendCmdMsg firstLoadTask Failed");
-            struct_80451261 = true;
+            hasErrored = true;
         }
         JASCriticalSection cs;
-        _this->field_0x118++;
+        _this->mPendingLoadTasks++;
     }
 }
 
@@ -221,22 +241,22 @@ void JASAramStream::finishTask(void* i_this) {
 
 void JASAramStream::prepareFinishTask(void* i_this) {
     JASAramStream* _this = (JASAramStream*)i_this;
-    OSSendMessage(&_this->field_0x020, (OSMessage)4, OS_MESSAGE_BLOCK);
+    OSSendMessage(&_this->mLoadCommandQueue, (OSMessage)CMD_PREPARE_FINISHED, OS_MESSAGE_BLOCK);
     if (_this->mCallback != NULL) {
         _this->mCallback(CB_STOP, _this, _this->mCallbackData);
     }
 }
 
-bool JASAramStream::headerLoad(u32 param_0, int param_1) {
-    if (struct_80451261) {
+bool JASAramStream::headerLoad(u32 aramSize, int param_1) {
+    if (hasErrored) {
         return false;
     }
-    if (field_0x114 != 0) {
+    if (mIsCancelled != 0) {
         return false;
     }
     if (DVDReadPrio(&mDvdFileInfo, sReadBuffer, sizeof(Header), 0, 1) < 0) {
         JUT_WARN(420, "%s", "DVDReadPrio Failed");
-        struct_80451261 = true;
+        hasErrored = true;
         return false;
     }
     Header* header = (Header*)sReadBuffer;
@@ -245,45 +265,45 @@ bool JASAramStream::headerLoad(u32 param_0, int param_1) {
     JUT_ASSERT(428, header->bits == 16);
     JUT_ASSERT(429, header->channels <= sChannelMax);
     JUT_ASSERT(430, header->block_size == sBlockSize);
-    field_0x158 = header->format;
+    mFormat = header->format;
     mChannelNum = header->channels;
-    field_0x164 = header->field_0x10;
+    mSampleRate = header->mSampleRate;
     mLoop = header->loop != 0;
     mLoopStart = header->loop_start;
     mLoopEnd = header->loop_end;
-    mVolume = header->field_0x28 / 127.0f;
-    field_0x118 = 0;
+    mVolume = header->mVolume / 127.0f;
+    mPendingLoadTasks = 0;
     mBlock = 0;
-    field_0x10c = 0;
-    field_0x160 = (param_0 / sBlockSize) / header->channels;
-    mBufCount = field_0x160;
+    mBlockRingIndex = 0;
+    mAramBlocksPerChannel = (aramSize / sBlockSize) / header->channels;
+    mBufCount = mAramBlocksPerChannel;
     JUT_ASSERT(445, mBufCount > 0);
     mBufCount--;
     if (mBufCount < 3) {
         JUT_WARN(449, "%s", "Too few Buffer-Size");
     }
-    field_0x108 = mBufCount;
+    mRingEndIndex = mBufCount;
     u32 local_2c = (mLoopEnd - 1) / getBlockSamples();
     if (local_2c <= mBufCount && mLoop) {
         JUT_WARN(458, "%s", "Too few samples for Loop-buffer");
     }
-    if (param_1 < 0 || param_1 > field_0x108) {
-        param_1 = field_0x108;
+    if (param_1 < 0 || param_1 > mRingEndIndex) {
+        param_1 = mRingEndIndex;
     }
-    if (field_0x114 != 0) {
+    if (mIsCancelled != 0) {
         return false;
     }
     TaskData data;
     data.stream = this;
-    data.field_0x4 = field_0x108 - 1;
-    data.field_0x8 = param_1;
-    if (!sLoadThread->sendCmdMsg(firstLoadTask, &data, 0xc)) {
+    data.param0 = mRingEndIndex - 1;
+    data.param1 = param_1;
+    if (!sLoadThread->sendCmdMsg(firstLoadTask, &data, sizeof(data))) {
         JUT_WARN(472, "%s", "sendCmdMsg firstLoadTask Failed");
-        struct_80451261 = true;
+        hasErrored = true;
         return false;
     }
     JASCriticalSection cs;
-    field_0x118++;
+    mPendingLoadTasks++;
     return true;
 }
 
@@ -291,12 +311,12 @@ bool JASAramStream::headerLoad(u32 param_0, int param_1) {
 bool JASAramStream::load() {
     {
         JASCriticalSection cs;
-        field_0x118--;
+        mPendingLoadTasks--;
     }
-    if (struct_80451261) {
+    if (hasErrored) {
         return false;
     }
-    if (field_0x114 != 0) {
+    if (mIsCancelled != 0) {
         return false;
     }
     u32 loop_end_block = (mLoopEnd - 1) / getBlockSamples();
@@ -311,31 +331,31 @@ bool JASAramStream::load() {
     }
     if (DVDReadPrio(&mDvdFileInfo, sReadBuffer, size, offset, 1) < 0) {
         JUT_WARN(507, "%s", "DVDReadPrio Failed");
-        struct_80451261 = true;
+        hasErrored = true;
         return false;
     }
     BlockHeader* bhead = (BlockHeader*)sReadBuffer;
     JUT_ASSERT(512, bhead->tag == 'BLCK');
-    if (field_0x114 != 0) {
+    if (mIsCancelled != 0) {
         return false;
     }
-    u32 sp08 = field_0x148 + field_0x10c * sBlockSize;
+    u32 blockBaseOffset = mAramAddress + mBlockRingIndex * sBlockSize;
     for (int i = 0; i < mChannelNum; i++) {
         (void)i;
         // Fakematch? It seems the only way to get the bhead->field_0x4 load in the right order is
         // with a pointer cast on its address in one of the two places it is read, but not both.
-        if (!JKRMainRamToAram(sReadBuffer + *(u32*)&bhead->field_0x4 * i + sizeof(BlockHeader),
-                              sp08 + sBlockSize * field_0x160 * i,
-                              bhead->field_0x4, EXPAND_SWITCH_UNKNOWN0, 0, NULL, -1, NULL)) {
+        if (!JKRMainRamToAram(sReadBuffer + bhead->mSize * i + sizeof(BlockHeader),
+                              blockBaseOffset + sBlockSize * mAramBlocksPerChannel * i,
+                              bhead->mSize, EXPAND_SWITCH_UNKNOWN0, 0, NULL, -1, NULL)) {
             JUT_WARN(522, "%s", "JKRMainRamToAram Failed");
-            struct_80451261 = 1;
+            hasErrored = 1;
             return false;
         }
     }
-    field_0x10c++;
-    if (field_0x10c >= field_0x108) {
+    mBlockRingIndex++;
+    if (mBlockRingIndex >= mRingEndIndex) {
         u32 r28 = mBlock;
-        r28 += field_0x108 - 1;
+        r28 += mRingEndIndex - 1;
         if (mLoop) {
             JUT_ASSERT(537, loop_start_block < loop_end_block);
             while (r28 > loop_end_block) {
@@ -344,16 +364,16 @@ bool JASAramStream::load() {
             }
         }
         if (r28 == loop_end_block || r28 + 2 == loop_end_block) {
-            field_0x108 = field_0x160;
-            OSSendMessage(&field_0x020, (OSMessage)5, OS_MESSAGE_BLOCK);
+            mRingEndIndex = mAramBlocksPerChannel;
+            OSSendMessage(&mLoadCommandQueue, (OSMessage)CMD_LOOP_END_LOADED, OS_MESSAGE_BLOCK);
         } else {
-            field_0x108 = field_0x160 - 1;
+            mRingEndIndex = mAramBlocksPerChannel - 1;
         }
         for (int i = 0; i < mChannelNum; i++) {
-            field_0x130[i] = (s16)bhead->field_0x8[i].field_0x0;
-            field_0x13c[i] = (s16)bhead->field_0x8[i].field_0x2;
+            mpLasts[i] = (s16)bhead->mAdpcmContinuationData[i].mpLast;
+            mpPenults[i] = (s16)bhead->mAdpcmContinuationData[i].mpPenult;
         }
-        field_0x10c = 0;
+        mBlockRingIndex = 0;
     }
     mBlock++;
     if (mBlock > loop_end_block && mLoop) {
@@ -371,7 +391,7 @@ s32 JASAramStream::dvdErrorCheck(void* param_0) {
     s32 status = DVDGetDriveStatus();
     switch (status) {
     case DVD_STATE_END:
-        struct_80451260 = false;
+        dvdHasErrored = false;
         break;
     case DVD_STATE_BUSY:
         break;
@@ -385,7 +405,7 @@ s32 JASAramStream::dvdErrorCheck(void* param_0) {
     case DVD_STATE_RETRY:
     case DVD_STATE_FATAL_ERROR:
     default:
-        struct_80451260 = true;
+        dvdHasErrored = true;
         break;
     }
     return 0;
@@ -397,98 +417,125 @@ void JASAramStream::channelCallback(u32 i_callbackType, JASChannel* i_channel,
     stream->updateChannel(i_callbackType, i_channel, i_dspChannel);
 }
 
+#define CHANNEL_UPDATE_SAMPLES_LEFT 1
+#define CHANNEL_UPDATE_LOOP_START   2
+#define CHANNEL_UPDATE_END_SAMPLE   4
+#define CHANNEL_UPDATE_LOOP_FLAG    8
+
+
 void JASAramStream::updateChannel(u32 i_callbackType, JASChannel* i_channel,
                                   JASDsp::TChannel* i_dspChannel) {
     u32 block_samples = getBlockSamples();
     switch (i_callbackType) {
     case JASChannel::CB_START:
-        if (field_0x0a8 == NULL) {
-            field_0x0a8 = i_channel;
-            field_0x0b4 = block_samples * mBufCount;
-            field_0x0b8 = 0;
+        if (mPrimaryChannel == NULL) {
+            mPrimaryChannel = i_channel;
+            mLastSamplesLeft = block_samples * mBufCount;
+            mReadSample = 0;
             field_0x0b0 = 0;
             field_0x0bc = (mLoopEnd - 1) / block_samples;
-            field_0x0c0 = 0;
+            mEndSetup = 0;
             field_0x0c4 = 0;
-            field_0x12c = 0;
+            mChannelUpdateFlags = 0;
         }
         break;
     case JASChannel::CB_PLAY:
-        if (i_dspChannel->field_0x008 == 0) {
-            if (i_channel == field_0x0a8) {
-                field_0x12c = 0;
-                u32 sp28 = i_dspChannel->field_0x074 + i_dspChannel->field_0x064;
-                if (sp28 <= field_0x0b4) {
-                    field_0x0b8 += field_0x0b4 - sp28;
+        if (i_dspChannel->mResetFlag == 0) {
+            if (i_channel == mPrimaryChannel) {
+                /*
+                if (JASAudioThread::snIntCount == 1) {
+                    OSReportForceEnableOn();
+                    OSReport("mSamplesLeft: %08d, mAramStreamPosition: %08d\n", i_dspChannel->mSamplesLeft, i_dspChannel->mAramStreamPosition);
+                }
+                */
+
+                mChannelUpdateFlags = 0;
+                u32 adjustedSamplesLeft = i_dspChannel->mSamplesLeft + i_dspChannel->mSamplesPerBlock;
+                if (adjustedSamplesLeft <= mLastSamplesLeft) {
+                    mReadSample += mLastSamplesLeft - adjustedSamplesLeft;
                 } else {
-                    if (!field_0x0c0) {
-                        field_0x0b8 += field_0x0b4;
-                        field_0x0b8 += block_samples * mBufCount - sp28;
+                    // The DSP has looped.
+
+                    if (!mEndSetup) {
+                        // Just looping the ring buffer, data continues as normal.
+                        mReadSample += mLastSamplesLeft;
+                        mReadSample += block_samples * mBufCount - adjustedSamplesLeft;
                     } else {
-                        field_0x0b8 += field_0x0b4;
-                        field_0x0b8 += block_samples * mBufCount - sp28
-                                       - i_dspChannel->field_0x110;
-                        field_0x0b8 -= mLoopEnd;
-                        field_0x0b8 += mLoopStart;
-                        i_dspChannel->field_0x110 = 0;
-                        field_0x120 = 0;
-                        field_0x12c |= 2;
+                        // We hit the actual file loop position.
+                        mReadSample += mLastSamplesLeft;
+                        mReadSample += block_samples * mBufCount - adjustedSamplesLeft
+                                       - i_dspChannel->mLoopStartSample;
+                        mReadSample -= mLoopEnd;
+                        mReadSample += mLoopStart;
+                        i_dspChannel->mLoopStartSample = 0;
+                        mUpdateLoopStartSample = 0;
+                        mChannelUpdateFlags |= CHANNEL_UPDATE_LOOP_START;
+#if !TARGET_PC // The variable assigned here is never used.
                         if (field_0x0c4 < 0xffffffff) {
                             field_0x0c4 += 1;
                         }
-                        field_0x0c0 = false;
+#endif
+                        mEndSetup = false;
                     }
                 }
-                if (field_0x0b8 > mLoopEnd) {
+                if (mReadSample > mLoopEnd) {
                     JUT_WARN(686, "%s", "mReadSample > mLoopEnd");
-                    struct_80451261 = true;
+                    hasErrored = true;
                 }
+
+#if !TARGET_PC // The variable assigned here is never used.
                 f32 fvar1 = field_0x0c4;
                 fvar1 *= mLoopEnd - mLoopStart;
                 if (field_0x0c4 < 0xffffffff) {
-                    fvar1 += field_0x0b8;
+                    fvar1 += mReadSample;
                 }
-                fvar1 /= field_0x164;
+                fvar1 /= mSampleRate;
                 field_0x0c8 = fvar1;
-                if (field_0x0b8 + 400 >= mLoopEnd && !field_0x0c0) {
+#endif
+
+                if (mReadSample + 400 >= mLoopEnd && !mEndSetup) {
                     if (mLoop) {
+                        // File needs to loop. Adjust loop start position
+                        // (out of the normal ring buffer behavior).
                         u32 uvar5 = field_0x0bc + 1;
                         if (uvar5 >= mBufCount) {
                             uvar5 = 0;
                         }
-                        i_dspChannel->field_0x110 = mLoopStart % block_samples
+                        i_dspChannel->mLoopStartSample = mLoopStart % block_samples
                                                     + uvar5 * block_samples;
-                        field_0x120 = i_dspChannel->field_0x110;
-                        field_0x12c |= 2;
+                        mUpdateLoopStartSample = i_dspChannel->mLoopStartSample;
+                        mChannelUpdateFlags |= CHANNEL_UPDATE_LOOP_START;
                     } else {
-                        i_dspChannel->field_0x102 = 0;
-                        field_0x128 = 0;
-                        field_0x12c |= 8;
+                        // File doesn't need to loop, just unset loop flag
+                        // and let the DSP finish naturally.
+                        i_dspChannel->mLoopFlag = 0;
+                        mUpdateLoopFlag = 0;
+                        mChannelUpdateFlags |= CHANNEL_UPDATE_LOOP_FLAG;
                     }
                     int sp20 = field_0x0bc * block_samples + mLoopEnd % block_samples;
-                    i_dspChannel->field_0x074 -= block_samples * mBufCount - sp20;
-                    field_0x11c = i_dspChannel->field_0x074;
-                    field_0x12c |= 1;
+                    i_dspChannel->mSamplesLeft -= block_samples * mBufCount - sp20;
+                    mUpdateSamplesLeft = i_dspChannel->mSamplesLeft;
+                    mChannelUpdateFlags |= CHANNEL_UPDATE_SAMPLES_LEFT;
                     field_0x0bc += (mLoopEnd - 1) / block_samples - mLoopStart / block_samples + 1;
-                    field_0x0c0 = true;
+                    mEndSetup = true;
                 }
-                u32 uvar4 = i_dspChannel->field_0x070 - i_channel->field_0x104;
+                u32 uvar4 = i_dspChannel->mAramStreamPosition - i_channel->mWaveAramAddress;
                 if (uvar4 != 0) {
                     uvar4--;
                 }
-                u32 sp18 = uvar4 / sBlockSize;
+                u32 blockCount = uvar4 / sBlockSize;
                 u32 sp14 = (mLoopEnd - 1) / getBlockSamples();
-                if (sp18 != field_0x0b0) {
-                    bool cmp = sp18 < field_0x0b0;
-                    while (sp18 != field_0x0b0) {
+                if (blockCount != field_0x0b0) {
+                    bool cmp = blockCount < field_0x0b0;
+                    while (blockCount != field_0x0b0) {
                         if (!sLoadThread->sendCmdMsg(loadToAramTask, this)) {
-                            JUT_WARN(741, "sendCmdMsg Failed %d %d (%d %d)", i_dspChannel->field_0x070, i_channel->field_0x104, sp18, field_0x0b0);
-                            struct_80451261 = true;
+                            JUT_WARN(741, "sendCmdMsg Failed %d %d (%d %d)", i_dspChannel->mAramStreamPosition, i_channel->mWaveAramAddress, blockCount, field_0x0b0);
+                            hasErrored = true;
                             break;
                         }
                         {
                             JASCriticalSection cs;
-                            field_0x118++;
+                            mPendingLoadTasks++;
                         }
                         field_0x0b0++;
                         if (field_0x0b0 >= mBufCount) {
@@ -497,65 +544,65 @@ void JASAramStream::updateChannel(u32 i_callbackType, JASChannel* i_channel,
                     }
                     if (cmp) {
                         field_0x0bc -= mBufCount;
-                        if (field_0x0ad) {
-                            if (!field_0x0c0) {
-                                i_dspChannel->field_0x074 += block_samples;
-                                field_0x11c = i_dspChannel->field_0x074;
-                                field_0x12c |= 1;
+                        if (mLoopEndLoaded) {
+                            if (!mEndSetup) {
+                                i_dspChannel->mSamplesLeft += block_samples;
+                                mUpdateSamplesLeft = i_dspChannel->mSamplesLeft;
+                                mChannelUpdateFlags |= CHANNEL_UPDATE_SAMPLES_LEFT;
                             }
-                            i_dspChannel->field_0x114 += block_samples;
-                            field_0x124 = i_dspChannel->field_0x114;
-                            field_0x12c |= 4;
-                            mBufCount = field_0x160;
-                            field_0x0ad = false;
+                            i_dspChannel->mEndSample += block_samples;
+                            mUpdateEndSample = i_dspChannel->mEndSample;
+                            mChannelUpdateFlags |= CHANNEL_UPDATE_END_SAMPLE;
+                            mBufCount = mAramBlocksPerChannel;
+                            mLoopEndLoaded = false;
                         } else {
-                            if (mBufCount != field_0x160 - 1) {
-                                mBufCount = field_0x160 - 1;
-                                i_dspChannel->field_0x114 -= block_samples;
-                                field_0x124 = i_dspChannel->field_0x114;
-                                field_0x12c |= 4;
-                                if (!field_0x0c0) {
-                                    i_dspChannel->field_0x074 -= block_samples;
-                                    field_0x11c = i_dspChannel->field_0x074;
-                                    field_0x12c |= 1;
+                            if (mBufCount != mAramBlocksPerChannel - 1) {
+                                mBufCount = mAramBlocksPerChannel - 1;
+                                i_dspChannel->mEndSample -= block_samples;
+                                mUpdateEndSample = i_dspChannel->mEndSample;
+                                mChannelUpdateFlags |= CHANNEL_UPDATE_END_SAMPLE;
+                                if (!mEndSetup) {
+                                    i_dspChannel->mSamplesLeft -= block_samples;
+                                    mUpdateSamplesLeft = i_dspChannel->mSamplesLeft;
+                                    mChannelUpdateFlags |= CHANNEL_UPDATE_SAMPLES_LEFT;
                                 }
                             }
                         }
                     }
                 } else {
-                    if (field_0x118 == 0 && !struct_80451260) {
-                        field_0x0ae &= ~2;
-                        field_0x0ae &= ~4;
+                    if (mPendingLoadTasks == 0 && !dvdHasErrored) {
+                        mPauseFlags &= ~PAUSE_DVD_ERROR;
+                        mPauseFlags &= ~PAUSE_UNDERFLOW;
                     }
                 }
-                field_0x0b4 = i_dspChannel->field_0x074 + i_dspChannel->field_0x064;
-                if (field_0x118 >= field_0x160 - 2) {
+                mLastSamplesLeft = i_dspChannel->mSamplesLeft + i_dspChannel->mSamplesPerBlock;
+                if (mPendingLoadTasks >= mAramBlocksPerChannel - 2) {
                     JUT_WARN_DEVICE(810, 1, "%s", "buffer under error");
-                    field_0x0ae |= (u8)4;
+                    mPauseFlags |= (u8)PAUSE_UNDERFLOW;
                 }
             } else {
-                if (field_0x12c & 1) {
-                    i_dspChannel->field_0x074 = field_0x11c;
+                if (mChannelUpdateFlags & CHANNEL_UPDATE_SAMPLES_LEFT) {
+                    i_dspChannel->mSamplesLeft = mUpdateSamplesLeft;
                 }
-                if (field_0x12c & 2) {
-                    i_dspChannel->field_0x110 = field_0x120;
+                if (mChannelUpdateFlags & CHANNEL_UPDATE_LOOP_START) {
+                    i_dspChannel->mLoopStartSample = mUpdateLoopStartSample;
                 }
-                if (field_0x12c & 4) {
-                    i_dspChannel->field_0x114 = field_0x124;
+                if (mChannelUpdateFlags & CHANNEL_UPDATE_END_SAMPLE) {
+                    i_dspChannel->mEndSample = mUpdateEndSample;
                 }
-                if (field_0x12c & 8) {
-                    i_dspChannel->field_0x102 = field_0x128;
+                if (mChannelUpdateFlags & CHANNEL_UPDATE_LOOP_FLAG) {
+                    i_dspChannel->mLoopFlag = mUpdateLoopFlag;
                 }
             }
             int ch = 0;
-            for (; ch < 6; ch++) {
+            for (; ch < CHANNEL_MAX; ch++) {
                 if (i_channel == mChannels[ch]) {
                     break;
                 }
             }
             JUT_ASSERT(834, ch < CHANNEL_MAX);
-            i_dspChannel->field_0x104 = (s16)field_0x130[ch];
-            i_dspChannel->field_0x106 = (s16)field_0x13c[ch];
+            i_dspChannel->mpLast = (s16)mpLasts[ch];
+            i_dspChannel->mpPenult = (s16)mpPenults[ch];
         }
         break;
     case JASChannel::CB_STOP:
@@ -568,57 +615,57 @@ void JASAramStream::updateChannel(u32 i_callbackType, JASChannel* i_channel,
             }
         }
         if (!open_channel) {
-            field_0x114 = 1;
+            mIsCancelled = 1;
             if (!sLoadThread->sendCmdMsg(finishTask, this)) {
                 JUT_WARN(854, "%s", "sendCmdMsg finishTask Failed");
-                struct_80451261 = true;
+                hasErrored = true;
                 return;
             }
         }
         break;
     }
-    i_channel->setPauseFlag(field_0x0ae != 0);
+    i_channel->setPauseFlag(mPauseFlags != 0);
 }
 
 s32 JASAramStream::channelProc() {
     OSMessage msg;
-    while (OSReceiveMessage(&field_0x020, &msg, OS_MESSAGE_NOBLOCK)) {
+    while (OSReceiveMessage(&mLoadCommandQueue, &msg, OS_MESSAGE_NOBLOCK)) {
         switch ((uintptr_t)msg) {
-        case 4:
-            field_0x0ac = true;
+        case CMD_PREPARE_FINISHED:
+            mPrepareFinished = true;
             break;
-        case 5:
-            field_0x0ad = true;
+        case CMD_LOOP_END_LOADED:
+            mLoopEndLoaded = true;
             break;
         }
     }
     
-    if (!field_0x0ac) {
+    if (!mPrepareFinished) {
         return 0;
     }
 
-    while (OSReceiveMessage(&field_0x000, &msg, OS_MESSAGE_NOBLOCK)) {
+    while (OSReceiveMessage(&mMainCommandQueue, &msg, OS_MESSAGE_NOBLOCK)) {
         switch ((uintptr_t)msg & 0xff) {
-        case 0:
+        case CMD_START:
             channelStart();
             break;
-        case 1:
+        case CMD_STOP:
             channelStop(JSUHiHalf((uintptr_t)msg));
             break;
-        case 2:
-            field_0x0ae |= 1;
+        case CMD_PAUSE:
+            mPauseFlags |= PAUSE_REQUESTED;
             break;
-        case 3:
-            field_0x0ae &= ~1;
+        case CMD_UNPAUSE:
+            mPauseFlags &= ~PAUSE_REQUESTED;
             break;
         }
     }
 
-    if (struct_80451261) {
-        field_0x0ae |= 8;
+    if (hasErrored) {
+        mPauseFlags |= PAUSE_OTHER_ERROR;
     }
-    if (struct_80451260) {
-        field_0x0ae |= 2;
+    if (dvdHasErrored) {
+        mPauseFlags |= PAUSE_DVD_ERROR;
     }
 
     for (int i = 0; i < mChannelNum; i++) {
@@ -646,44 +693,44 @@ static JASOscillator::Point const OSC_RELEASE_TABLE[2] = {
 static JASOscillator::Data const OSC_ENV = {0, 1.0f, NULL, OSC_RELEASE_TABLE, 1.0f, 0.0f};
 
 void JASAramStream::channelStart() {
-    u8 r31;
-    switch (field_0x158) {
-    case 0:
-        r31 = 0;
+    u8 format;
+    switch (mFormat) {
+    case STREAM_FORMAT_ADPCM4:
+        format = WAVE_FORMAT_ADPCM4;
         break;
-    case 1:
-        r31 = 3;
+    case STREAM_FORMAT_PCM16:
+        format = WAVE_FORMAT_PCM16;
         break;
     }
     for (int i = 0; i < mChannelNum; i++) {
         JASWaveInfo wave_info;
-        wave_info.field_0x00 = r31;
-        wave_info.field_0x02 = 0xff;
-        wave_info.field_0x10 = 0;
-        wave_info.field_0x14 = mBufCount * getBlockSamples();
-        wave_info.field_0x18 = wave_info.field_0x14;
-        wave_info.field_0x1c = 0;
-        wave_info.field_0x1e = 0;
+        wave_info.mWaveFormat = format;
+        wave_info.mLoopFlag = 0xff;
+        wave_info.mLoopStartSample = 0;
+        wave_info.mLoopEndSample = mBufCount * getBlockSamples();
+        wave_info.mSampleCount = wave_info.mLoopEndSample;
+        wave_info.mpLast = 0;
+        wave_info.mpPenult = 0;
         // probably a fake match, this should be set in the JASWaveInfo constructor
         static u32 const one = 1;
         wave_info.field_0x20 = &one;
         JASChannel* jc = JKR_NEW JASChannel(channelCallback, this);
         JUT_ASSERT(963, jc);
         jc->setPriority(0x7f7f);
-        for (u32 j = 0; j < 6; j++) {
-            jc->setMixConfig(j, field_0x1dc[j]);
+        for (u32 j = 0; j < DSP_OUTPUT_CHANNELS; j++) {
+            jc->setMixConfig(j, mMixConfig[j]);
         }
-        jc->setInitPitch(field_0x164 / JASDriver::getDacRate());
+        jc->setInitPitch(mSampleRate / JASDriver::getDacRate());
         jc->setOscInit(0, &OSC_ENV);
-        jc->field_0xdc.field_0x4 = wave_info;
-        jc->field_0x104 = field_0x148 + sBlockSize * field_0x160 * i;
-        jc->field_0xdc.field_0x0 = 0;
+        jc->field_0xdc.mWaveInfo = wave_info;
+        jc->mWaveAramAddress = mAramAddress + sBlockSize * mAramBlocksPerChannel * i;
+        jc->field_0xdc.mChannelType = 0;
         int ret = jc->playForce();
         JUT_ASSERT(977, ret);
         JUT_ASSERT_MSG(979, mChannels[i] == NULL, "channelStart for already playing channel");
         mChannels[i] = jc;
     }
-    field_0x0a8 = NULL;
+    mPrimaryChannel = NULL;
 }
 
 

libs/JSystem/src/JAudio2/JASAudioReseter.cpp

@@ -47,7 +47,7 @@ s32 JASAudioReseter::checkDone() const {
 
 s32 JASAudioReseter::calc() {
     if (field_0x0==0) {
-        for (size_t i = 0; i<64; i++) {
+        for (size_t i = 0; i<DSP_CHANNELS; i++) {
             JASDSPChannel* handle = JASDSPChannel::getHandle(i);
             if (handle->getStatus() == 0) {
                 handle->drop();

libs/JSystem/src/JAudio2/JASAudioThread.cpp

@@ -21,17 +21,8 @@ JASAudioThread::JASAudioThread(int stackSize, int msgCount, u32 threadPriority)
     OSInitThreadQueue(&sThreadQueue);
 }
 
-#if TARGET_PC
-bool JASAudioThread::sThreadInitComplete = false;
-OSMutex JASAudioThread::sThreadInitCompleteMutex;
-OSCond JASAudioThread::sThreadInitCompleteCond;
-#endif
-
 void JASAudioThread::create(s32 threadPriority) {
-#if TARGET_PC
-    OSInitMutex(&sThreadInitCompleteMutex);
-    OSInitCond(&sThreadInitCompleteCond);
-#endif
+    OSPanic(__FILE__, __LINE__, "JASAudioThread does not work on PC!");
 
 #if PLATFORM_GCN
     const int size = 0x1400;
@@ -64,12 +55,18 @@ private:
     BOOL mInterrupts;
 };
 
+#if !TARGET_PC
 class JASChannel {
     u8 filler[0x108];
 };
+#else
+// You don't want to know how long I spent debugging this.
+#include "JSystem/JAudio2/JASChannel.h"
+#endif
 
 // NONMATCHING location of JASPoolAllocObject_MultiThreaded<JASChannel>
 void* JASAudioThread::run() {
+#if !TARGET_PC
     OSInitFastCast();
     JASDriver::initAI(DMACallback);
     JASDsp::boot(DSPCallback);
@@ -79,13 +76,6 @@ void* JASAudioThread::run() {
     JASPoolAllocObject_MultiThreaded<JASChannel>::newMemPool(0x48);
     JASDriver::startDMA();
 
-#if TARGET_PC
-    OSLockMutex(&sThreadInitCompleteMutex);
-    sThreadInitComplete = true;
-    OSUnlockMutex(&sThreadInitCompleteMutex);
-    OSSignalCond(&sThreadInitCompleteCond);
-#endif
-
     OSMessage msg;
     while (true) {
         msg = waitMessageBlock();
@@ -126,6 +116,9 @@ void* JASAudioThread::run() {
             JUT_PANIC(152, "AUDIO THREAD INVALID MESSAGE\n");
         }
     }
+#else
+    return 0;
+#endif
 }
 
 void JASAudioThread::DMACallback() {
@@ -139,6 +132,7 @@ void JASAudioThread::DMACallback() {
 }
 
 void JASAudioThread::DSPCallback(void*) {
+#if !TARGET_PC
     JASAudioThread* pAudioThread = getInstance();
     JUT_ASSERT(184, pAudioThread);
 	while (DSPCheckMailFromDSP() == 0) { }
@@ -155,4 +149,5 @@ void JASAudioThread::DSPCallback(void*) {
 			JASDsp::finishWork(mail);
 		}
 	}
+#endif
 }

libs/JSystem/src/JAudio2/JASBNKParser.cpp

@@ -23,7 +23,7 @@ JASBasicBank* JASBNKParser::createBasicBank(void const* stream, JKRHeap* heap) {
     u32 free_size = heap->getFreeSize();
     
     TFileHeader* filep = (TFileHeader*)stream;
-    JUT_ASSERT(59, filep->id == 'IBNK');
+    JUT_ASSERT(59, filep->mMagic == 'IBNK');
     JASBasicBank* bank = NULL;
     switch (filep->mVersion) {
     case 0:
@@ -79,11 +79,11 @@ JASBasicBank* JASBNKParser::Ver1::createBasicBank(void const* stream, JKRHeap* h
         JUT_ASSERT(155, op->id == 'Osci');
         JASOscillator::Data* data = &osc_data[i];
         data->mTarget = op->mTarget;
-        data->_04 = op->_08;
+        data->mRate = op->mRate;
         data->mScale = op->mScale;
-        data->_14 = op->_18;
-        data->mTable = (JASOscillator::Point*)(envt + op->mTableOffset);
-        data->rel_table = (JASOscillator::Point*)(envt + op->_10);
+        data->mVertex = op->mVertex;
+        data->mTable = (JASOscillator::Point*)(envt + op->mAttackEnvelopeOffset);
+        data->rel_table = (JASOscillator::Point*)(envt + op->mReleaseEnvelopeOffset);
     }
     TListChunk* list = list_chunk;
     JUT_ASSERT(172, list->count <= JASBank::PRG_OSC);
@@ -128,8 +128,10 @@ JASBasicBank* JASBNKParser::Ver1::createBasicBank(void const* stream, JKRHeap* h
             case 'Perc': {
                 JASDrumSet* drump = JKR_NEW_ARGS (heap, 0) JASDrumSet;
                 JUT_ASSERT(264, drump != NULL);
+                #if PLATFORM_SHIELD
                 u32 pmap_count = data[1];
                 JUT_ASSERT(268, pmap_count <= 128);
+                #endif
                 u32 count = *data++;
                 drump->newPercArray(count, heap);
                 for (int j = 0; j < count; j++) {
@@ -137,8 +139,10 @@ JASBasicBank* JASBNKParser::Ver1::createBasicBank(void const* stream, JKRHeap* h
                     if (offset != 0) {
                         JASDrumSet::TPerc* percp = JKR_NEW_ARGS (heap, 0) JASDrumSet::TPerc;
                         JUT_ASSERT(277, percp);
+                        #if PLATFORM_SHIELD
                         u32 type = data[0];
                         JUT_ASSERT(282, type == 'Pmap');
+                        #endif
                         BE(u32)* ptr = (BE(u32)*)((intptr_t)stream + offset);
                         TPercData* perc_data = (TPercData*)(ptr + 1);
                         percp->setVolume(perc_data->mVolume);
@@ -203,7 +207,7 @@ JASBasicBank* JASBNKParser::Ver0::createBasicBank(void const* stream, JKRHeap* h
                         osc = JKR_NEW_ARGS (heap, 0) JASOscillator::Data;
                         JUT_ASSERT(386, osc != NULL);
                         osc->mTarget = tosc->mTarget;
-                        osc->_04 = tosc->field_0x4;
+                        osc->mRate = tosc->field_0x4;
 
                         JASOscillator::Point* points = tosc->mPointOffset.ptr(header);
                         if (points != NULL) {
@@ -230,7 +234,7 @@ JASBasicBank* JASBNKParser::Ver0::createBasicBank(void const* stream, JKRHeap* h
                         }
 
                         osc->mScale = tosc->mScale;
-                        osc->_14 = tosc->field_0x14;
+                        osc->mVertex = tosc->field_0x14;
                         instp->setOsc(osc_idx, osc);
                     }
 
@@ -312,7 +316,7 @@ JASOscillator::Data* JASBNKParser::Ver0::findOscPtr(JASBasicBank* bank, THeader
 JASOscillator::Point const* JASBNKParser::Ver0::getOscTableEndPtr(JASOscillator::Point const* points) {
     const JASOscillator::Point* ptr = points;
     while(true) {
-        s16 tmp = ptr->_0;
+        s16 tmp = ptr->mEnvelopeMode;
         ptr++;
         if (tmp > 10) {
             break;

libs/JSystem/src/JAudio2/JASBank.cpp

@@ -42,13 +42,13 @@ JASChannel* JASBank::noteOn(JASBank const* param_0, int param_1, u8 param_2, u8
         return NULL;
     }
     channel->setPriority(param_4);
-    channel->field_0xdc.field_0x4 = *waveInfo;
-    channel->field_0x104 = wavePtr;
-    channel->field_0xdc.field_0x0 = stack_60.field_0x1c;
+    channel->field_0xdc.mWaveInfo = *waveInfo;
+    channel->mWaveAramAddress = wavePtr;
+    channel->field_0xdc.mChannelType = stack_60.field_0x1c;
     channel->setBankDisposeID(param_0);
-    channel->setInitPitch(stack_60.mPitch * (waveInfo->field_0x04 / JASDriver::getDacRate()));
+    channel->setInitPitch(stack_60.mPitch * (waveInfo->mSampleRate / JASDriver::getDacRate()));
     if (stack_60.field_0x1e == 0) {
-        channel->setKey(param_2 - waveInfo->field_0x01);
+        channel->setKey(param_2 - waveInfo->mBaseKey);
     }
     channel->setInitVolume(stack_60.mVolume);
     channel->setVelocity(param_3);
@@ -79,10 +79,10 @@ JASChannel* JASBank::noteOnOsc(int param_0, u8 param_1, u8 param_2, u16 param_3,
         return NULL;
     }
     channel->setPriority(param_3);
-    channel->field_0x104 = param_0;
-    channel->field_0xdc.field_0x0 = 2;
+    channel->mOscillatorSomething = param_0;
+    channel->field_0xdc.mChannelType = 2;
     channel->setInitPitch(16736.016f / JASDriver::getDacRate());
-    channel->setKey(param_1 - channel->field_0xdc.field_0x4.field_0x01);
+    channel->setKey(param_1 - channel->field_0xdc.mWaveInfo.mBaseKey);
     channel->setVelocity(param_2);
     channel->setOscInit(0, &OSC_ENV);
     if (!channel->play()) {

libs/JSystem/src/JAudio2/JASBasicWaveBank.cpp

@@ -50,7 +50,7 @@ void JASBasicWaveBank::incWaveTable(JASBasicWaveBank::TWaveGroup const* param_0)
         if (!handle->mHeap) {
             handle->mHeap = &param_0->mHeap;
             handle->field_0x4.field_0x20 = &param_0->_48;
-            handle->field_0x4.field_0x08 = param_0->mCtrlWaveArray[i].field_0x4;
+            handle->field_0x4.mOffsetStart = param_0->mCtrlWaveArray[i].field_0x4;
         }
     }
 }
@@ -64,7 +64,7 @@ void JASBasicWaveBank::decWaveTable(JASBasicWaveBank::TWaveGroup const* param_0)
         if (handle->mHeap == &param_0->mHeap) {
             handle->mHeap = NULL;
             handle->field_0x4.field_0x20 = &mNoLoad;
-            handle->field_0x4.field_0x08 = -1;
+            handle->field_0x4.mOffsetStart = -1;
         }
     }
 }
@@ -86,9 +86,9 @@ void JASBasicWaveBank::setWaveInfo(JASBasicWaveBank::TWaveGroup* wgrp, int index
     JUT_ASSERT(206, index >= 0);
     mWaveTable[param_2].field_0x4 = param_3;
     mWaveTable[param_2].field_0x4.field_0x20 = &mNoLoad;
-    mWaveTable[param_2].field_0x4.field_0x08 = -1;
+    mWaveTable[param_2].field_0x4.mOffsetStart = -1;
     wgrp->mCtrlWaveArray[index].field_0x0 = param_2;
-    wgrp->mCtrlWaveArray[index].field_0x4 = param_3.field_0x08;
+    wgrp->mCtrlWaveArray[index].field_0x4 = param_3.mOffsetStart;
 }
 
 JASBasicWaveBank::TWaveGroup::TWaveGroup() {
@@ -131,5 +131,5 @@ intptr_t JASBasicWaveBank::TWaveHandle::getWavePtr() const {
     if (base == 0) {
         return 0;
     }
-    return (intptr_t)base + field_0x4.field_0x08;
+    return (intptr_t)base + field_0x4.mOffsetStart;
 }

libs/JSystem/src/JAudio2/JASCalc.cpp

@@ -132,7 +132,11 @@ void JASCalc::bzero(void* dest, u32 size) {
     }
 }
 
+#if AVOID_UB
+s16 const JASCalc::CUTOFF_TO_IIR_TABLE[129][4] = {
+#else
 s16 const JASCalc::CUTOFF_TO_IIR_TABLE[128][4] = {
+#endif
     0x0F5C, 0x0A3D, 0x4665, 0x1E73,
     0x0F5E, 0x0A3D, 0x4664, 0x1E73,
     0x0F63, 0x0A3C, 0x4661, 0x1E71,
@@ -261,6 +265,10 @@ s16 const JASCalc::CUTOFF_TO_IIR_TABLE[128][4] = {
     0x7C7A, 0x0052, 0x0233, 0x00F4,
     0x7E3B, 0x0029, 0x011B, 0x007A,
     0x7FFF, 0x0000, 0x0000, 0x0000,
+#if AVOID_UB
+    // Game OOB reads this in some cases.
+    0,0,0,0
+#endif
 };
 
 // currently required because of missing functions

libs/JSystem/src/JAudio2/JASChannel.cpp

@@ -31,7 +31,7 @@ JASChannel::JASChannel(Callback i_callback, void* i_callbackData) :
     mKeySweepCount(0),
     mSkipSamples(0)
 {
-    field_0xdc.field_0x0 = 0;
+    field_0xdc.mChannelType = 0;
     field_0x104 = 0;
     mMixConfig[0].whole = 0x150;
     mMixConfig[1].whole = 0x210;
@@ -171,12 +171,12 @@ void JASChannel::updateEffectorParam(JASDsp::TChannel* i_channel, u16* i_mixerVo
     f32 pan = 0.5f;
     f32 dolby = 0.0f;
     switch (JASDriver::getOutputMode()) {
-    case 0:
+    case JAS_OUTPUT_MONO:
         break;
-    case 1:
+    case JAS_OUTPUT_STEREO:
         pan = calcPan(&pan_vector);
         break;
-    case 2:
+    case JAS_OUTPUT_SURROUND:
         pan = calcPan(&pan_vector);
         dolby = calcEffect(&dolby_vector);
         break;
@@ -229,7 +229,7 @@ s32 JASChannel::initialUpdateDSPChannel(JASDsp::TChannel* i_channel) {
         mCallback(CB_START, this, i_channel, mCallbackData);
     }
 
-    if (field_0xdc.field_0x4.field_0x20[0] == 0) {
+    if (field_0xdc.mWaveInfo.field_0x20[0] == 0) {
         JUT_WARN_DEVICE(346, 2, "%s", "Lost wave data while playing");
         mDspCh->free();
         mDspCh = NULL;
@@ -245,19 +245,19 @@ s32 JASChannel::initialUpdateDSPChannel(JASDsp::TChannel* i_channel) {
         return -1;
     }
 
-    switch (field_0xdc.field_0x0) {
+    switch (field_0xdc.mChannelType) {
     case 0:
-        i_channel->setWaveInfo(field_0xdc.field_0x4, field_0x104, mSkipSamples);
+        i_channel->setWaveInfo(field_0xdc.mWaveInfo, mWaveAramAddress, mSkipSamples);
         break;
     case 2:
-        i_channel->setOscInfo(field_0x104);
+        i_channel->setOscInfo(mOscillatorSomething);
         break;
     }
 
-    for (u8 i = 0; i < 6; i++) {
+    for (u8 i = 0; i < DSP_OUTPUT_CHANNELS; i++) {
         MixConfig mix_config = mMixConfig[i];
         u32 output_mode = JASDriver::getOutputMode();
-        if (output_mode == 0) {
+        if (output_mode == JAS_OUTPUT_MONO) {
             switch (mix_config.parts.upper) {
             case 8:
                 mix_config.parts.upper = 11;
@@ -266,7 +266,7 @@ s32 JASChannel::initialUpdateDSPChannel(JASDsp::TChannel* i_channel) {
                 mix_config.parts.upper = 2;
                 break;
             }
-        } else if (output_mode == 1 && mix_config.parts.upper == 8) {
+        } else if (output_mode == JAS_OUTPUT_STEREO && mix_config.parts.upper == 8) {
             mix_config.parts.upper = 11;
         }
         i_channel->setBusConnect(i, mix_config.parts.upper);
@@ -281,9 +281,9 @@ s32 JASChannel::initialUpdateDSPChannel(JASDsp::TChannel* i_channel) {
     }
     mVibrate.resetCounter();
     mTremolo.resetCounter();
-    u16 mixer_volume[6];
+    u16 mixer_volume[DSP_OUTPUT_CHANNELS];
     updateEffectorParam(i_channel, mixer_volume, effect_params);
-    for (u8 i = 0; i < 6; i++) {
+    for (u8 i = 0; i < DSP_OUTPUT_CHANNELS; i++) {
         i_channel->setMixerInitVolume(i, mixer_volume[i]);
     }
 
@@ -307,7 +307,7 @@ s32 JASChannel::updateDSPChannel(JASDsp::TChannel* i_channel) {
         mCallback(CB_PLAY, this, i_channel, mCallbackData);
     }
 
-    if (field_0xdc.field_0x4.field_0x20[0] == 0) {
+    if (field_0xdc.mWaveInfo.field_0x20[0] == 0) {
         JUT_WARN_DEVICE(456, 2, "%s","Lost wave data while playing");
         mDspCh->free();
         mDspCh = NULL;
@@ -378,18 +378,18 @@ s32 JASChannel::updateDSPChannel(JASDsp::TChannel* i_channel) {
     return 0;
 }
 
-void JASChannel::updateAutoMixer(JASDsp::TChannel* i_channel, f32 param_1, f32 param_2,
-                                 f32 param_3, f32 param_4) {
-    if (JASDriver::getOutputMode() == 0) {
-        param_1 *= 0.707f;
+void JASChannel::updateAutoMixer(JASDsp::TChannel* i_channel, f32 volume, f32 pan,
+                                 f32 fxmix, f32 dolby) {
+    if (JASDriver::getOutputMode() == JAS_OUTPUT_MONO) {
+        volume *= 0.707f;
     }
-    param_1 = JASCalc::clamp01(param_1);
+    volume = JASCalc::clamp01(volume);
 
-    u16 r31 = param_1 * JASDriver::getChannelLevel_dsp();
-    u8 r30 = param_2 * 127.5f;
-    u8 r29 = param_4 * 127.5f;
-    u8 r28 = param_3 * 127.5f;
-    i_channel->setAutoMixer(r31, r30, r29, r28, 0);
+    u16 dspVolume = volume * JASDriver::getChannelLevel_dsp();
+    u8 dspPan = pan * 127.5f;
+    u8 dspDolby = dolby * 127.5f;
+    u8 dspFxMix = fxmix * 127.5f;
+    i_channel->setAutoMixer(dspVolume, dspPan, dspDolby, dspFxMix, 0);
 }
 
 void JASChannel::updateMixer(f32 i_volume, f32 i_pan, f32 i_fxmix, f32 i_dolby, u16* i_volumeOut) {
@@ -429,7 +429,7 @@ void JASChannel::updateMixer(f32 i_volume, f32 i_pan, f32 i_fxmix, f32 i_dolby,
                     volume *= scale;
                     break;
                 default:
-                    if (JASDriver::getOutputMode() == 0) {
+                    if (JASDriver::getOutputMode() == JAS_OUTPUT_MONO) {
                         volume *= scale;
                     } else {
                         volume *= JMASinRadian(scale * JGeometry::TUtil<f32>::PI() * 0.5f);
@@ -470,8 +470,8 @@ void JASChannel::updateMixer(f32 i_volume, f32 i_pan, f32 i_fxmix, f32 i_dolby,
                 case 6:
                     volume *= scale;
                     break;
-                default:
-                    if (JASDriver::getOutputMode() == 0) {
+                default: // 0, 1, 4, 5, 8-15
+                    if (JASDriver::getOutputMode() == JAS_OUTPUT_MONO) {
                         volume *= scale;
                     } else {
                         volume *= JMASinRadian(scale * JGeometry::TUtil<f32>::PI() * 0.5f);

libs/JSystem/src/JAudio2/JASDSPChannel.cpp

@@ -10,7 +10,7 @@ JASDSPChannel::JASDSPChannel() :
     mStatus(STATUS_INACTIVE),
     mPriority(-1),
     mFlags(0),
-    field_0xc(0),
+    mUpdateCounter(0),
     mCallback(NULL),
     mCallbackData(NULL),
     mChannel(NULL)
@@ -42,9 +42,9 @@ void JASDSPChannel::drop() {
 }
 
 void JASDSPChannel::initAll() {
-    sDspChannels = JKR_NEW_ARRAY_ARGS(JASDSPChannel, 0x40, JASDram, 0x20);
+    sDspChannels = JKR_NEW_ARRAY_ARGS(JASDSPChannel, DSP_CHANNELS, JASDram, 0x20);
     JUT_ASSERT(102, sDspChannels);
-    for (int i = 0; i < 0x40; i++) {
+    for (int i = 0; i < DSP_CHANNELS; i++) {
         sDspChannels[i].mChannel = JASDsp::getDSPHandle(i);
     }
 }
@@ -56,7 +56,7 @@ JASDSPChannel* JASDSPChannel::alloc(u8 i_priority, Callback i_callback, void* i_
     }
     channel->drop();
     channel->mPriority = i_priority;
-    channel->field_0xc = 0;
+    channel->mUpdateCounter = 0;
     channel->mCallback = i_callback;
     channel->mCallbackData = i_callbackData;
     return channel;
@@ -70,7 +70,7 @@ JASDSPChannel* JASDSPChannel::allocForce(u8 i_priority, Callback i_callback, voi
     channel->mStatus = STATUS_INACTIVE;
     channel->drop();
     channel->mPriority = i_priority;
-    channel->field_0xc = 0;
+    channel->mUpdateCounter = 0;
     channel->mCallback = i_callback;
     channel->mCallbackData = i_callbackData;
     return channel;
@@ -83,16 +83,16 @@ void JASDSPChannel::setPriority(u8 i_priority) {
 JASDSPChannel* JASDSPChannel::getLowestChannel(int i_priority) {
     s16 best_priority = 0xff;
     int best_index = -1;
-    int best_unknown = 0;
-    for (int i = 0; i < 0x40; i++) {
+    int best_updateCounter = 0;
+    for (int i = 0; i < DSP_CHANNELS; i++) {
         JASDSPChannel* channel = &sDspChannels[i];
         s16 priority = channel->mPriority;
         if (priority < 0) {
             return &sDspChannels[i];
         }
         if (priority <= i_priority && priority <= best_priority) {
-            if (priority != best_priority || channel->field_0xc > best_unknown) {
-                best_unknown = channel->field_0xc;
+            if (priority != best_priority || channel->mUpdateCounter > best_updateCounter) {
+                best_updateCounter = channel->mUpdateCounter;
                 best_index = i;
                 best_priority = priority;
             }
@@ -107,14 +107,14 @@ JASDSPChannel* JASDSPChannel::getLowestChannel(int i_priority) {
 JASDSPChannel* JASDSPChannel::getLowestActiveChannel() {
     s16 best_priority = 0xff;
     int best_index = -1;
-    int best_unknown = 0;
-    for (int i = 0; i < 0x40; i++) {
+    int best_updateCounter = 0;
+    for (int i = 0; i < DSP_CHANNELS; i++) {
         JASDSPChannel* channel = &sDspChannels[i];
         if (channel->mStatus == STATUS_ACTIVE) {
             s16 priority = channel->mPriority;
             if (priority < 0x7f && priority <= best_priority) {
-                if (priority != best_priority || channel->field_0xc > best_unknown) {
-                    best_unknown = channel->field_0xc;
+                if (priority != best_priority || channel->mUpdateCounter > best_updateCounter) {
+                    best_updateCounter = channel->mUpdateCounter;
                     best_index = i;
                     best_priority = priority;
                 }
@@ -195,7 +195,7 @@ void JASDSPChannel::updateProc() {
                 mChannel->playStop();
                 mChannel->flush();
             } else {
-                field_0xc++;
+                mUpdateCounter++;
                 if (flush) {
                     mChannel->flush();
                 }
@@ -205,7 +205,7 @@ void JASDSPChannel::updateProc() {
 }
 
 void JASDSPChannel::updateAll() {
-    for (u32 i = 0; i < 0x40; i++) {
+    for (u32 i = 0; i < DSP_CHANNELS; i++) {
         if ((i & 0xf) == 0 && i != 0) {
             JASDsp::releaseHalt((i - 1) >> 4);
         }
@@ -230,8 +230,8 @@ JASDSPChannel* JASDSPChannel::getHandle(u32 i_index) {
 
 u32 JASDSPChannel::getNumUse() {
     u32 count = 0;
-    for (int i = 0; i < 0x40; i++) {
-        if (sDspChannels[i].mStatus == 0) {
+    for (int i = 0; i < DSP_CHANNELS; i++) {
+        if (sDspChannels[i].mStatus == STATUS_ACTIVE) {
             count++;
         }
     }
@@ -240,8 +240,8 @@ u32 JASDSPChannel::getNumUse() {
 
 u32 JASDSPChannel::getNumFree() {
     u32 count = 0;
-    for (int i = 0; i < 0x40; i++) {
-        if (sDspChannels[i].mStatus == 1) {
+    for (int i = 0; i < DSP_CHANNELS; i++) {
+        if (sDspChannels[i].mStatus == STATUS_INACTIVE) {
             count++;
         }
     }
@@ -250,8 +250,8 @@ u32 JASDSPChannel::getNumFree() {
 
 u32 JASDSPChannel::getNumBreak() {
         u32 count = 0;
-    for (int i = 0; i < 0x40; i++) {
-        if (sDspChannels[i].mStatus == 2) {
+    for (int i = 0; i < DSP_CHANNELS; i++) {
+        if (sDspChannels[i].mStatus == STATUS_DROP) {
             count++;
         }
     }

libs/JSystem/src/JAudio2/JASDSPInterface.cpp

@@ -50,6 +50,10 @@ void JASDsp::boot(void (*param_0)(void*)) {
 }
 
 void JASDsp::releaseHalt(u32 param_0) {
+#if TARGET_PC
+    // Dusk DSP does not work incrementally.
+    return;
+#endif
     DSPReleaseHalt2(param_0);
 }
 
@@ -72,8 +76,8 @@ f32 JASDsp::getDSPMixerLevel() {
     return sDSPVolume;
 }
 
-JASDsp::TChannel* JASDsp::getDSPHandle(int param_0) {
-    return CH_BUF + param_0;
+JASDsp::TChannel* JASDsp::getDSPHandle(int index) {
+    return CH_BUF + index;
 }
 
 JASDsp::TChannel* JASDsp::getDSPHandleNc(int param_0) {
@@ -87,12 +91,12 @@ void JASDsp::setFilterTable(s16* param_0, s16* param_1, u32 param_2) {
 }
 
 void JASDsp::flushBuffer() {
-    DCFlushRange(CH_BUF, sizeof(TChannel) * 64);
+    DCFlushRange(CH_BUF, sizeof(TChannel) * DSP_CHANNELS);
     DCFlushRange(FX_BUF, sizeof(FxBuf) * 4);
 }
 
 void JASDsp::invalChannelAll() {
-    DCInvalidateRange(CH_BUF, sizeof(TChannel) * 64);
+    DCInvalidateRange(CH_BUF, sizeof(TChannel) * DSP_CHANNELS);
 }
 
 u8 const ATTRIBUTE_ALIGN(32) JASDsp::DSPADPCM_FILTER[64] = {
@@ -426,16 +430,16 @@ u32 const ATTRIBUTE_ALIGN(32) JASDsp::DSPRES_FILTER[320] = {
 };
 
 void JASDsp::initBuffer() {
-    CH_BUF = JKR_NEW_ARRAY_ARGS(TChannel, 64, JASDram, 0x20);
+    CH_BUF = JKR_NEW_ARRAY_ARGS(TChannel, DSP_CHANNELS, JASDram, 0x20);
     JUT_ASSERT(354, CH_BUF);
     FX_BUF = JKR_NEW_ARRAY_ARGS(FxBuf, 4, JASDram, 0x20);
     JUT_ASSERT(356, FX_BUF);
-    JASCalc::bzero(CH_BUF, 0x6000);
+    JASCalc::bzero(CH_BUF, sizeof(TChannel) * DSP_CHANNELS);
     JASCalc::bzero(FX_BUF, sizeof(FxBuf) * 4);
     for (u8 i = 0; i < 4; i++) {
         setFXLine(i, NULL, NULL);
     }
-    DsetupTable(0x40, uintptr_t(CH_BUF), uintptr_t(&DSPRES_FILTER), uintptr_t(&DSPADPCM_FILTER), uintptr_t(FX_BUF));
+    DsetupTable(DSP_CHANNELS, uintptr_t(CH_BUF), uintptr_t(&DSPRES_FILTER), uintptr_t(&DSPADPCM_FILTER), uintptr_t(FX_BUF));
 
     flushBuffer();
 }
@@ -501,8 +505,8 @@ void JASDsp::TChannel::init() {
     mIsFinished = 0;
     mForcedStop = 0;
     mIsActive = 0;
-    field_0x058 = 0;
-    field_0x068 = 0;
+    mAutoMixerBeenSet = 0;
+    mSamplePosition = 0;
     initFilter();
 }
 
@@ -510,7 +514,7 @@ void JASDsp::TChannel::playStart() {
     JUT_ASSERT(508, dspMutex);
     field_0x10c = 0;
     field_0x060 = 0;
-    field_0x008 = 1;
+    mResetFlag = 1;
     field_0x066 = 0;
     int i;
     for (i = 0; i < 4; i++) {
@@ -549,41 +553,41 @@ bool JASDsp::TChannel::isFinish() const {
     return mIsFinished != 0;
 }
 
-void JASDsp::TChannel::setWaveInfo(JASWaveInfo const& param_0, u32 param_1, u32 param_2) {
+void JASDsp::TChannel::setWaveInfo(JASWaveInfo const& waveInfo, u32 aramAddress, u32 skipSamples) {
     int i;
     JUT_ASSERT(610, dspMutex);
-    field_0x118 = param_1;
+    mWaveAramAddress = aramAddress;
     static const u8 COMP_BLOCKSAMPLES[8] = {0x10, 0x10, 0x01, 0x01, 0x01, 0x10, 0x10, 0x01};
-    field_0x064 = COMP_BLOCKSAMPLES[param_0.field_0x00];
+    mSamplesPerBlock = COMP_BLOCKSAMPLES[waveInfo.mWaveFormat];
     static const u8 COMP_BLOCKBYTES[8] = {0x09, 0x05, 0x08, 0x10, 0x01, 0x01, 0x01, 0x01};
-    field_0x100 = COMP_BLOCKBYTES[param_0.field_0x00];
-    field_0x068 = 0;
-    if (field_0x100 >= 4) {
-        field_0x11c = param_0.field_0x18;
-        field_0x102 = param_0.field_0x02;
-        if (field_0x102) {
-            if (param_2 == 1) {
-                param_2 = param_0.field_0x10;
+    mBytesPerBlock = COMP_BLOCKBYTES[waveInfo.mWaveFormat];
+    mSamplePosition = 0;
+    if (mBytesPerBlock >= 4) {
+        mSampleCount = waveInfo.mSampleCount;
+        mLoopFlag = waveInfo.mLoopFlag;
+        if (mLoopFlag) {
+            if (skipSamples == 1) {
+                skipSamples = waveInfo.mLoopStartSample;
             }
-            field_0x110 = param_0.field_0x10;
-            field_0x114 = param_0.field_0x14;
-            field_0x104 = param_0.field_0x1c;
-            field_0x106 = param_0.field_0x1e;
+            mLoopStartSample = waveInfo.mLoopStartSample;
+            mEndSample = waveInfo.mLoopEndSample;
+            mpLast = waveInfo.mpLast;
+            mpPenult = waveInfo.mpPenult;
         } else {
-            field_0x114 = field_0x11c;
+            mEndSample = mSampleCount;
         }
-        if (param_2 && field_0x114 > param_2) {
-            switch (param_0.field_0x00) {
-            case 0:
-            case 1:
-                field_0x068 = param_2;
-                field_0x118 += param_2 * field_0x100 >> 4;
-                field_0x110 -= param_2;
-                field_0x114 -= param_2;
+        if (skipSamples && mEndSample > skipSamples) {
+            switch (waveInfo.mWaveFormat) {
+            case WAVE_FORMAT_ADPCM4:
+            case WAVE_FORMAT_ADPCM2:
+                mSamplePosition = skipSamples;
+                mWaveAramAddress += skipSamples * mBytesPerBlock >> 4;
+                mLoopStartSample -= skipSamples;
+                mEndSample -= skipSamples;
                 break;
-            case 2:
-            case 3:
-                field_0x068 = param_2;
+            case WAVE_FORMAT_PCM8:
+            case WAVE_FORMAT_PCM16:
+                mSamplePosition = skipSamples;
                 break;
             }
         }
@@ -595,28 +599,27 @@ void JASDsp::TChannel::setWaveInfo(JASWaveInfo const& param_0, u32 param_1, u32
 
 void JASDsp::TChannel::setOscInfo(u32 param_0) {
     JUT_ASSERT(671, dspMutex);
-    field_0x118 = 0;
-    field_0x064 = 16;
-    field_0x100 = param_0;
+    mWaveAramAddress = 0;
+    mSamplesPerBlock = 16;
+    mBytesPerBlock = param_0;
 }
 
 void JASDsp::TChannel::initAutoMixer() {
     JUT_ASSERT(688, dspMutex);
-    if (field_0x058) {
-        field_0x054 = field_0x056;
+    if (mAutoMixerBeenSet) {
+        mAutoMixerInitVolume = mAutoMixerVolume;
     } else {
-        field_0x054 = 0;
-        field_0x058 = 1;
+        mAutoMixerInitVolume = 0;
+        mAutoMixerBeenSet = 1;
     }
 }
 
-void JASDsp::TChannel::setAutoMixer(u16 param_0, u8 param_1, u8 param_2, u8 param_3,
-                                        u8 param_4) {
+void JASDsp::TChannel::setAutoMixer(u16 volume, u8 pan, u8 dolby, u8 fxMix, u8) {
     JUT_ASSERT(709, dspMutex);
-    field_0x050 = (param_1 << 8) | param_2;
-    field_0x052 = param_3 << 8 | param_3 << 1;
-    field_0x056 = param_0;
-    field_0x058 = 1;
+    mAutoMixerPanDolby = (pan << 8) | dolby;
+    mAutoMixerFxMix = fxMix << 8 | fxMix << 1;
+    mAutoMixerVolume = volume;
+    mAutoMixerBeenSet = 1;
 }
 
 void JASDsp::TChannel::setPitch(u16 param_0) {
@@ -627,21 +630,20 @@ void JASDsp::TChannel::setPitch(u16 param_0) {
     mPitch = param_0;
 }
 
-void JASDsp::TChannel::setMixerInitVolume(u8 param_0, s16 param_1) {
+void JASDsp::TChannel::setMixerInitVolume(u8 outputChannel, s16 volume) {
     JUT_ASSERT(798, dspMutex);
-    u16* tmp = field_0x010[param_0];
-    tmp[2] = param_1;
-    tmp[1] = param_1;
-    tmp[3] = 0;
+    OutputChannelConfig& cfg = mOutputChannels[outputChannel];
+    cfg.mCurrentVolume = volume;
+    cfg.mTargetVolume = volume;
+    cfg.mVolumeProgress = 0;
 }
 
-void JASDsp::TChannel::setMixerVolume(u8 param_0, s16 param_1) {
-    u16* tmp;
+void JASDsp::TChannel::setMixerVolume(u8 outputChannel, s16 volume) {
     JUT_ASSERT(841, dspMutex);
     if (mForcedStop == 0) {
-        tmp = field_0x010[param_0];
-        tmp[1] = param_1;
-        tmp[3] &= 0xff;
+        OutputChannelConfig& cfg = mOutputChannels[outputChannel];
+        cfg.mTargetVolume = volume;
+        cfg.mVolumeProgress &= 0xff;
     }
 }
 
@@ -699,16 +701,25 @@ void JASDsp::TChannel::setDistFilter(s16 param_0) {
     iir_filter_params[4] = param_0;
 }
 
-void JASDsp::TChannel::setBusConnect(u8 param_0, u8 param_1) {
+void JASDsp::TChannel::setBusConnect(u8 outputChannel, u8 param_1) {
     JUT_ASSERT(973, dspMutex);
-    u16* tmp = field_0x010[param_0];
+    OutputChannelConfig& tmp = mOutputChannels[outputChannel];
+#if AVOID_UB
+    if (param_1 == 255) {
+        // Seems to happen for "dolby mode" where the mix config is 0xFFFF.
+        // Probably UB without side effect in the base game as afaict the DSP
+        // doesn't look at mix config when "dolby mode" is active.
+        return;
+    }
+    JUT_ASSERT(0, param_1 < 12);
+#endif
     static u16 const connect_table[12] = {
         0x0000, 0x0D00, 0x0D60, 0x0DC0, 0x0E20, 0x0E80,
         0x0EE0, 0x0CA0, 0x0F40, 0x0FA0, 0x0B00, 0x09A0,
     };
     u16 r30 = 0;
     r30 = connect_table[param_1];
-    tmp[0] = r30;
+    tmp.mBusConnect = r30;
 }
 
 u16 DSP_CreateMap2(u32 param_0) {

libs/JSystem/src/JAudio2/JASDriverIF.cpp

@@ -23,10 +23,10 @@ f32 JASDriver::getDSPLevel() {
     return JASDsp::getDSPMixerLevel();
 }
 
-u32 JASDriver::JAS_SYSTEM_OUTPUT_MODE = 0x00000001;
+u32 JASDriver::JAS_SYSTEM_OUTPUT_MODE = JAS_OUTPUT_STEREO;
 
-void JASDriver::setOutputMode(u32 param_0) {
-    JAS_SYSTEM_OUTPUT_MODE = param_0;
+void JASDriver::setOutputMode(u32 mode) {
+    JAS_SYSTEM_OUTPUT_MODE = mode;
 }
 
 u32 JASDriver::getOutputMode() {

libs/JSystem/src/JAudio2/JASDrumSet.cpp

@@ -49,11 +49,11 @@ bool JASDrumSet::getParam(int key, int param_1, JASInstParam* param_2) const {
     static JASOscillator::Data osc;
 
     osc.mTarget = 0;
-    osc._04 = 1.0f;
+    osc.mRate = 1.0f;
     osc.mTable = NULL;
     osc.rel_table = NULL;
     osc.mScale = 1.0f;
-    osc._14 = 0.0f;
+    osc.mVertex = 0.0f;
 
     static JASOscillator::Data* oscp = &osc;
 

libs/JSystem/src/JAudio2/JASOscillator.cpp

@@ -4,9 +4,9 @@
 
 JASOscillator::JASOscillator() {
     mData = NULL;
-    _14 = 0;
+    mCurPoint = 0;
     mDirectRelease = 0;
-    _18 = 0;
+    mEnvelopeMode = 0;
     _1C = 0;
     _04 = _08 = _10 = _0C = 0.0f;
 }
@@ -17,7 +17,7 @@ void JASOscillator::initStart(JASOscillator::Data const* data) {
     _04 = 0.0f;
     _08 = 0.0f;
     _0C = 0.0f;
-    _14 = 0;
+    mCurPoint = 0;
     mDirectRelease = 0;
     if (!data) {
 		_1C = 0;
@@ -30,8 +30,8 @@ void JASOscillator::initStart(JASOscillator::Data const* data) {
         return;
     }
 
-    _10 = mData->mTable[0]._4 / 32768.0f;
-    _18 = mData->mTable[0]._0;
+    _10 = mData->mTable[0].mValue / 32768.0f;
+    mEnvelopeMode = mData->mTable[0].mEnvelopeMode;
     _1C = 1;
 }
 
@@ -44,13 +44,13 @@ void JASOscillator::incCounter(f32 param_0) {
 	case 1:
 		break;
 	}
-	_04 += param_0 * mData->_04;
+	_04 += param_0 * mData->mRate;
     update();
 }
 
 f32 JASOscillator::getValue() const {
     JUT_ASSERT(120, mData);
-	return _08 * mData->mScale + mData->_14;
+	return _08 * mData->mScale + mData->mVertex;
 }
 
 void JASOscillator::release() {
@@ -63,8 +63,8 @@ void JASOscillator::release() {
 		_04 = 0.0f;
         _0C = _08;
         _10 = 0.0f;
-        _14 = 0;
-        _18 = (mDirectRelease >> 14) & 3;
+        mCurPoint = 0;
+        mEnvelopeMode = (mDirectRelease >> 14) & 3;
         _1C = 4;
         update();
         return;
@@ -74,9 +74,9 @@ void JASOscillator::release() {
         JUT_ASSERT(157, mData->rel_table != NULL);
         _04 = 0.0f;
         _0C = _08;
-        _10 = mData->rel_table[0]._4 / 32768.0f;
-        _14 = 0;
-        _18 = mData->rel_table[0]._0;
+        _10 = mData->rel_table[0].mValue / 32768.0f;
+        mCurPoint = 0;
+        mEnvelopeMode = mData->rel_table[0].mEnvelopeMode;
     }
 
     _1C = 3;
@@ -104,31 +104,31 @@ void JASOscillator::update() {
         return;
     }
 
-    while (_04 >= psVar1[_14]._2) {
-        _04 -= psVar1[_14]._2;
+    while (_04 >= psVar1[mCurPoint].mTime) {
+        _04 -= psVar1[mCurPoint].mTime;
         _08 = _10;
-        _14++;
+        mCurPoint++;
         _0C = _08;
-        const BE(s16)* ps = &psVar1[_14]._0;
-        s16 r26 = ps[0];
-        switch(r26) {
-        case 0xf:
+        const Point* ps = &psVar1[mCurPoint];
+        s16 mode = ps->mEnvelopeMode;
+        switch(mode) {
+        case ENVELOPE_STOP:
             _1C = 0;
             return;
-        case 0xe:
+        case ENVELOPE_HOLD:
             _1C = 2;
             return;
-        case 0xd:
-            _14 = ps[2];
+        case ENVELOPE_LOOP:
+            mCurPoint = ps->mValue;
             break;
         default:
-            _18 = r26;
-            _10 = ps[2] / 32768.0f;
+            mEnvelopeMode = mode;
+            _10 = ps->mValue / 32768.0f;
             break;
         }
     }
 
-    updateCurrentValue(psVar1[_14]._2);
+    updateCurrentValue(psVar1[mCurPoint].mTime);
 }
 
 f32 const JASOscillator::sCurveTableLinear[17] = {
@@ -163,7 +163,7 @@ static f32* table_list[4] = {
 };
 
 void JASOscillator::updateCurrentValue(f32 param_0) {
-    f32* table = table_list[_18];
+    f32* table = table_list[mEnvelopeMode];
     f32 fVar1 = 16.0f * (_04 / param_0);
     u32 index = (u32) fVar1;
     f32 fVar3 = (fVar1 - index);

libs/JSystem/src/JAudio2/JASSeqCtrl.cpp

@@ -34,9 +34,9 @@ void JASSeqCtrl::init() {
     field_0x51 = 0;
 }
 
-void JASSeqCtrl::start(void* param_0, u32 param_1) {
-    mReader.init(param_0);
-    mReader.jump(param_1);
+void JASSeqCtrl::start(void* base, u32 offset) {
+    mReader.init(base);
+    mReader.jump(offset);
 }
 
 int JASSeqCtrl::tickProc(JASTrack* param_0) {

libs/JSystem/src/JAudio2/JASSeqParser.cpp

@@ -950,7 +950,7 @@ s32 JASSeqParser::parseNoteOn(JASTrack* param_0, u8 param_1) {
     return 0;
 }
 
-s32 JASSeqParser::parseCommand(JASTrack* param_0, u8 cmd, u16 param_2) {
+s32 JASSeqParser::parseCommand(JASTrack* param_0, u8 cmd, u16 parameterTypesOverride) {
     JASSeqCtrl* seqCtrl = param_0->getSeqCtrl();
     CmdInfo* cmdInfo = NULL;
     if (cmd != 0xb0) {
@@ -959,32 +959,32 @@ s32 JASSeqParser::parseCommand(JASTrack* param_0, u8 cmd, u16 param_2) {
     } else {
         cmdInfo = &sExtCmdInfo[seqCtrl->readByte() & 0xff];
     }
-    u16 r28 = (u16)cmdInfo->field_0xe;
-    r28 |= param_2;
-    u32 stack_28[8];
-    for (int i = 0; i < cmdInfo->field_0xc; i++, r28 >>= 2) {
-        int r27 = 0;
-        switch (r28 & 3) {
+    u16 parameterTypes = (u16)cmdInfo->mParameterTypes;
+    parameterTypes |= parameterTypesOverride;
+    u32 args[8];
+    for (int i = 0; i < cmdInfo->mParameterCount; i++, parameterTypes >>= 2) {
+        int value = 0;
+        switch (parameterTypes & 3) {
         case 0:
-            r27 = (u8)seqCtrl->readByte();
+            value = (u8)seqCtrl->readByte();
             break;
         case 1:
-            r27 = (u16)seqCtrl->read16();
+            value = (u16)seqCtrl->read16();
             break;
         case 2:
-            r27 = seqCtrl->read24();
+            value = seqCtrl->read24();
             break;
         case 3:
-            r27 = readReg(param_0, (u8)seqCtrl->readByte());
+            value = readReg(param_0, (u8)seqCtrl->readByte());
             break;
         }
-        stack_28[i] = r27;
+        args[i] = value;
     }
-    s32 (JASSeqParser::*ptr)(JASTrack*, u32*) = cmdInfo->field_0x0;
+    s32 (JASSeqParser::*ptr)(JASTrack*, u32*) = cmdInfo->mHandler;
     if (!ptr) {
         return 0;
     }
-    return execCommand(param_0, ptr, cmdInfo->field_0xc, stack_28);
+    return execCommand(param_0, ptr, cmdInfo->mParameterCount, args);
 }
 
 s32 JASSeqParser::parseRegCommand(JASTrack* param_0, int param_1) {
@@ -1004,7 +1004,9 @@ s32 JASSeqParser::parseRegCommand(JASTrack* param_0, int param_1) {
 }
 
 s32 JASSeqParser::parse(JASTrack* param_0) {
-    u32 r31 = param_0->getSeqCtrl()->readByte();
+    JASSeqCtrl* ctrl = param_0->getSeqCtrl();
+    u32 base = ctrl->mReader.mCurPos - ctrl->mReader.mBase;
+    u32 r31 = ctrl->readByte();
     s32 r30 = 0;
     if ((r31 & 0x80) == 0) {
         r30 = parseNoteOn(param_0, r31);

libs/JSystem/src/JAudio2/JASSeqReader.cpp

@@ -8,81 +8,81 @@
 #include "JSystem/JAudio2/JASSeqReader.h"
 
 void JASSeqReader::init() {
-    field_0x00 = 0;
-    field_0x04 = 0;
-    field_0x08 = 0;
+    mBase = 0;
+    mCurPos = 0;
+    mCurStackDepth = 0;
 
-    for (int i = 0; i < 8; i++) {
-        field_0x0c[i] = NULL;
-        field_0x2c[i] = 0;
+    for (int i = 0; i < JAS_SEQ_STACK_SIZE; i++) {
+        mReturnAddr[i] = NULL;
+        mLoopCount[i] = 0;
     }
 }
 
-void JASSeqReader::init(void* param_0) {
-    field_0x00 = (u8*)param_0;
-    field_0x04 = field_0x00;
-    field_0x08 = 0;
+void JASSeqReader::init(void* base) {
+    mBase = (u8*)base;
+    mCurPos = mBase;
+    mCurStackDepth = 0;
 
-    for (int i = 0; i < 8; i++) {
-        field_0x0c[i] = NULL;
-        field_0x2c[i] = 0;
+    for (int i = 0; i < JAS_SEQ_STACK_SIZE; i++) {
+        mReturnAddr[i] = NULL;
+        mLoopCount[i] = 0;
     }
     
 }
 
 bool JASSeqReader::call(u32 param_0) {
-    if (field_0x08 >= 8) {
+    if (mCurStackDepth >= JAS_SEQ_STACK_SIZE) {
         JUT_WARN(42, "%s", "Cannot exec call command");
         return false;
     }
 
-    field_0x0c[field_0x08++] = (u16*)field_0x04;
-    field_0x04 = field_0x00 + param_0;
+    mReturnAddr[mCurStackDepth++] = (u16*)mCurPos;
+    mCurPos = mBase + param_0;
 
     return true;
 }
 
 bool JASSeqReader::loopStart(u32 param_0) {
-    if (8 <= field_0x08) {
+    if (JAS_SEQ_STACK_SIZE <= mCurStackDepth) {
         JUT_WARN(53, "%s", "Cannot exec loopStart command");
         return false;
     }
 
-    field_0x0c[field_0x08] = (u16*)field_0x04;
-    field_0x2c[field_0x08++] = param_0;
+    mReturnAddr[mCurStackDepth] = (u16*)mCurPos;
+    mLoopCount[mCurStackDepth++] = param_0;
 
     return true;
 }
 
 
 bool JASSeqReader::loopEnd() {
-    if (field_0x08 == 0) {
+    if (mCurStackDepth == 0) {
         JUT_WARN(65, "%s", "cannot loopE for call-stack is NULL");
         return false;
     }
 
-    u16 tmp = field_0x2c[field_0x08 - 1];
+    u16 tmp = mLoopCount[mCurStackDepth - 1];
 
     if (tmp != 0) {
         tmp--;
     }
 
     if (!tmp) {
-        field_0x08--;
+        mCurStackDepth--;
         return true;
     }
 
-    field_0x2c[field_0x08 - 1] = tmp;
-    field_0x04 = (u8*)field_0x0c[field_0x08 - 1];
+    mLoopCount[mCurStackDepth - 1] = tmp;
+    mCurPos = (u8*)mReturnAddr[mCurStackDepth - 1];
     return true;
 }
 
 bool JASSeqReader::ret() {
-    if (field_0x08 == 0) {
+    if (mCurStackDepth == 0) {
         return false;
     }
 
-    field_0x04 = (u8*)field_0x0c[--field_0x08];
+    mCurPos = (u8*)mReturnAddr[--mCurStackDepth];
 
     return true;
 }

libs/JSystem/src/JAudio2/JASSimpleWaveBank.cpp

@@ -44,7 +44,7 @@ intptr_t JASSimpleWaveBank::TWaveHandle::getWavePtr() const {
     if (base == NULL) {
         return 0;
     }
-    return (intptr_t)base + mWaveInfo.field_0x08;
+    return (intptr_t)base + mWaveInfo.mOffsetStart;
 }
 
 JASSimpleWaveBank::TWaveHandle::TWaveHandle() {

libs/JSystem/src/JAudio2/JASTaskThread.cpp

@@ -26,7 +26,7 @@ JASTaskThread::~JASTaskThread() {
 
 void* JASTaskThread::allocCallStack(JASThreadCallback callback, const void* msg, u32 msgSize) {
     ThreadMemPool* heap;
-    u32 size = msgSize + 8;
+    u32 size = msgSize + offsetof(JASThreadCallStack, msg);
     JASThreadCallStack *callStack = (JASThreadCallStack*) JASKernel::getCommandHeap()->alloc(size);
     if (callStack == NULL) {
         return NULL;
@@ -40,7 +40,7 @@ void* JASTaskThread::allocCallStack(JASThreadCallback callback, const void* msg,
 
 void* JASTaskThread::allocCallStack(JASThreadCallback callback, void* msg) {
     JASThreadCallStack *callStack;
-    callStack = (JASThreadCallStack*)JASKernel::getCommandHeap()->alloc(12);
+    callStack = (JASThreadCallStack*)JASKernel::getCommandHeap()->alloc(offsetof(JASThreadCallStack, msg) + sizeof(void*));
     if (callStack == NULL) {
         return NULL;
     }

libs/JSystem/src/JAudio2/JASTrack.cpp

@@ -171,9 +171,9 @@ void JASTrack::assignExtBuffer(u32 index, JASSoundParams* i_soundParams) {
     mChannelMgrs[index]->mSoundParams = i_soundParams;
 }
 
-void JASTrack::setSeqData(void* param_0, u32 param_1) {
+void JASTrack::setSeqData(void* base, u32 offset) {
     JUT_ASSERT(257, mStatus == STATUS_FREE);
-    mSeqCtrl.start(param_0, param_1);
+    mSeqCtrl.start(base, offset);
 }
 
 void JASTrack::startSeq() {
@@ -356,7 +356,7 @@ int JASTrack::gateOn(u32 param_0, u32 i_velocity, f32 i_time, u32 i_flags) {
             } else {
                 JASChannel* channel = channel_mgr->mChannels[0];
                 if (channel != NULL) {
-                    channel->setKey(uvar7 - channel->field_0xdc.field_0x4.field_0x01);
+                    channel->setKey(uvar7 - channel->field_0xdc.mWaveInfo.mBaseKey);
                     channel->setVelocity(i_velocity);
                     channel->setUpdateTimer(update_timer);
                 }
@@ -545,10 +545,10 @@ void JASTrack::setOscTable(u32 osc_no, JASOscillator::Point const* i_table) {
 void JASTrack::setOscAdsr(s16 param_0, s16 param_1, s16 param_2, s16 param_3, u16 i_directRelease) {
     mOscParam[0] = sEnvOsc;
     mOscParam[0].mTable = mOscPoint;
-    mOscPoint[0]._2 = param_0;
-    mOscPoint[1]._2 = param_1;
-    mOscPoint[2]._2 = param_2;
-    mOscPoint[2]._4 = param_3;
+    mOscPoint[0].mTime = param_0;
+    mOscPoint[1].mTime = param_1;
+    mOscPoint[2].mTime = param_2;
+    mOscPoint[2].mValue = param_3;
     mDirectRelease = i_directRelease;
 }
 

libs/JSystem/src/JAudio2/JASTrackPort.cpp

@@ -3,8 +3,8 @@
 #include "JSystem/JAudio2/JASTrackPort.h"
 
 void JASTrackPort::init() {
-    for (int i = 0; i < 16; i++) {
-        field_0x4[i] = 0;
+    for (int i = 0; i < MAX_PORTS; i++) {
+        mPortValues[i] = 0;
     }
     field_0x0 = 0;
     field_0x2 = 0;
@@ -13,25 +13,25 @@ void JASTrackPort::init() {
 u16 JASTrackPort::readImport(u32 port_num) {
     JUT_ASSERT(27, port_num < MAX_PORTS);
     field_0x0 = field_0x0 & ~(1 << port_num);
-    return field_0x4[port_num];
+    return mPortValues[port_num];
 }
 
 u16 JASTrackPort::readExport(u32 port_num) {
     JUT_ASSERT(34, port_num < MAX_PORTS);
     field_0x2 = field_0x2 & ~(1 << port_num);
-    return field_0x4[port_num];
+    return mPortValues[port_num];
 }
 
 void JASTrackPort::writeImport(u32 port_num, u16 param_1) {
     JUT_ASSERT(41, port_num < MAX_PORTS);
     field_0x0 = field_0x0 | (1 << port_num);
-    field_0x4[port_num] = param_1;
+    mPortValues[port_num] = param_1;
 }
 
 void JASTrackPort::writeExport(u32 port_num, u16 param_1) {
     JUT_ASSERT(47, port_num < MAX_PORTS);
     field_0x2 = field_0x2 | (1 << port_num);
-    field_0x4[port_num] = param_1;
+    mPortValues[port_num] = param_1;
 }
 
 u32 JASTrackPort::checkImport(u32 param_0) const {

libs/JSystem/src/JAudio2/JASWSParser.cpp

@@ -48,17 +48,17 @@ JASBasicWaveBank* JASWSParser::createBasicWaveBank(void const* stream, JKRHeap*
         for (int j = 0; j < ctrl->mWaveCount; j++) {
             TWave* wave = archive->mWaveOffsets[j].ptr(header);
             JASWaveInfo wave_info;
-            wave_info.field_0x00 = wave->_01;
-            wave_info.field_0x01 = wave->_02;
-            wave_info.field_0x04 = wave->_04;
-            wave_info.field_0x08 = wave->mOffset;
-            wave_info.field_0x0c = wave->_0C;
-            wave_info.field_0x02 = wave->_10 == 0 ? 0 : 0xff;
-            wave_info.field_0x10 = wave->_14;
-            wave_info.field_0x14 = wave->_18;
-            wave_info.field_0x18 = wave->_1C;
-            wave_info.field_0x1c = wave->_20;
-            wave_info.field_0x1e = wave->_22;
+            wave_info.mWaveFormat = wave->mWaveFormat;
+            wave_info.mBaseKey = wave->mBaseKey;
+            wave_info.mSampleRate = wave->mSampleRate;
+            wave_info.mOffsetStart = wave->mAWOffsetStart;
+            wave_info.mOffsetLength = wave->mAWOffsetEnd;
+            wave_info.mLoopFlag = wave->mLoopFlags == 0 ? 0 : 0xff;
+            wave_info.mLoopStartSample = wave->mLoopStartSample;
+            wave_info.mLoopEndSample = wave->mLoopEndSample;
+            wave_info.mSampleCount = wave->mSampleCount;
+            wave_info.mpLast = wave->mpLast;
+            wave_info.mpPenult = wave->mpPenult;
             TCtrlWave* ctrl_wave = ctrl->mCtrlWaveOffsets[j].ptr(header);
             u16 local_74 = JSULoHalf(ctrl_wave->_00);
             wave_bank->setWaveInfo(wave_group, j, local_74, wave_info);
@@ -104,17 +104,17 @@ JASSimpleWaveBank* JASWSParser::createSimpleWaveBank(void const* stream, JKRHeap
     for (int i = 0; i < ctrl->mWaveCount; i++) {
         TWave* wave = archive->mWaveOffsets[i].ptr(header);
         JASWaveInfo wave_info;
-        wave_info.field_0x00 = wave->_01;
-        wave_info.field_0x01 = wave->_02;
-        wave_info.field_0x04 = wave->_04;
-        wave_info.field_0x08 = wave->mOffset;
-        wave_info.field_0x0c = wave->_0C;
-        wave_info.field_0x02 = wave->_10 == 0 ? 0 : 0xff;
-        wave_info.field_0x10 = wave->_14;
-        wave_info.field_0x14 = wave->_18;
-        wave_info.field_0x18 = wave->_1C;
-        wave_info.field_0x1c = wave->_20;
-        wave_info.field_0x1e = wave->_22;
+        wave_info.mWaveFormat = wave->mWaveFormat;
+        wave_info.mBaseKey = wave->mBaseKey;
+        wave_info.mSampleRate = wave->mSampleRate;
+        wave_info.mOffsetStart = wave->mAWOffsetStart;
+        wave_info.mOffsetLength = wave->mAWOffsetEnd;
+        wave_info.mLoopFlag = wave->mLoopFlags == 0 ? 0 : 0xff;
+        wave_info.mLoopStartSample = wave->mLoopStartSample;
+        wave_info.mLoopEndSample = wave->mLoopEndSample;
+        wave_info.mSampleCount = wave->mSampleCount;
+        wave_info.mpLast = wave->mpLast;
+        wave_info.mpPenult = wave->mpPenult;
         TCtrlWave* ctrl_wave = ctrl->mCtrlWaveOffsets[i].ptr(header);
         u32 tmp = JSULoHalf(ctrl_wave->_00);
         wave_bank->setWaveInfo(tmp, wave_info);

libs/JSystem/src/JAudio2/JASWaveArcLoader.cpp

@@ -99,7 +99,7 @@ bool JASWaveArc::sendLoadCmd() {
 
     _5a++;
 
-    if (JASDvd::getThreadPointer()->sendCmdMsg(loadToAramCallback, &commandInfo, 0x10) == 0) {
+    if (JASDvd::getThreadPointer()->sendCmdMsg(loadToAramCallback, &commandInfo, sizeof(commandInfo)) == 0) {
         JUT_WARN(193, "%s", "sendCmdMsg loadToAramCallback Failed");
         mHeap.free();
         return false;

libs/JSystem/src/JAudio2/JAUInitializer.cpp

@@ -15,6 +15,8 @@
 #include "JSystem/JKernel/JKRSolidHeap.h"
 #include "JSystem/JKernel/JKRThread.h"
 
+#include "dusk/audio/DuskAudioSystem.h"
+
 JAU_JASInitializer::JAU_JASInitializer() {
     audioMemory_ = 0;
     audioMemSize_ = 0;
@@ -27,7 +29,7 @@ JAU_JASInitializer::JAU_JASInitializer() {
 #endif
     dvdThreadPriority_ = 3;
     audioThreadPriority_ = 2;
-    field_0x1c = 0x80;
+    mJasTrackPoolSize = 0x80;
     dspLevel_ = 1.0f;
     aramBlockSize_ = 0x2760;
     aramChannelNum_ = 2;
@@ -54,13 +56,17 @@ void JAU_JASInitializer::initJASystem(JKRSolidHeap* heap) {
 
         JASKernel::setupAramHeap(audioMemory_, audioMemSize_);
 
-        JASTrack::newMemPool(field_0x1c);
+        JASTrack::newMemPool(mJasTrackPoolSize);
         if (field_0x20 > 0) {
             JASTrack::TChannelMgr::newMemPool(field_0x20);
         }
 
         JASDvd::createThread(dvdThreadPriority_, 0x80, 0x1000);
+#if TARGET_PC
+        dusk::audio::Initialize();
+#else
         JASAudioThread::create(audioThreadPriority_);
+#endif
         JKRThreadSwitch* threadSwitch = JKRThreadSwitch::getManager();
         if (threadSwitch) {
             if (dvdThreadId_ >= 0) {
@@ -80,33 +86,33 @@ void JAU_JASInitializer::initJASystem(JKRSolidHeap* heap) {
     }
 
     #if PLATFORM_SHIELD
-    JASDriver::setOutputMode(1);
+    JASDriver::setOutputMode(JAS_OUTPUT_STEREO);
     #else
     switch (OSGetSoundMode()) {
-    case 0:
-        JASDriver::setOutputMode(0);
+    case OS_SOUND_MODE_MONO:
+        JASDriver::setOutputMode(JAS_OUTPUT_MONO);
         break;
-    case 1:
-        JASDriver::setOutputMode(1);
+    case OS_SOUND_MODE_STEREO:
+        JASDriver::setOutputMode(JAS_OUTPUT_STEREO);
         break;
     }
     #endif
 }
 
 JAU_JAIInitializer::JAU_JAIInitializer() {
-    field_0x0 = 100;
-    field_0x4 = 4;
-    field_0x8 = 2;
-    field_0xc = 16;
+    mJaiSePoolSize = 100;
+    mJaiSeqPoolSize = 4;
+    mJaiStreamPoolSize = 2;
+    mJaiSoundChildPoolSize = 16;
 }
 
 // NONMATCHING JASPoolAllocObject<_> locations
 void JAU_JAIInitializer::initJAInterface() {
     s32 r30 = JASDram->getFreeSize();
-    JAIStream::newMemPool(field_0x8);
-    JAISeq::newMemPool(field_0x4);
-    JAISe::newMemPool(field_0x0);
-    JAISoundChild::newMemPool(field_0xc);
+    JAIStream::newMemPool(mJaiStreamPoolSize);
+    JAISeq::newMemPool(mJaiSeqPoolSize);
+    JAISe::newMemPool(mJaiSePoolSize);
+    JAISoundChild::newMemPool(mJaiSoundChildPoolSize);
     s32 r29 = JASDram->getFreeSize();
     OS_REPORT("JAU_JAIInitializer uses %d bytes\n", r30 - r29);
 }

libs/JSystem/src/JAudio2/JAUSectionHeap.cpp

@@ -245,11 +245,11 @@ u8* JAUSection::newStaticSeqDataBlock_(JAISoundID param_0, u32 size) {
     return NULL;
 }
 
-bool JAUSection::newStaticSeqData(JAISoundID param_0, void const* param_1, u32 param_2) {
+bool JAUSection::newStaticSeqData(JAISoundID param_0, void const* param_1, u32 size) {
     {
-        u8* r30 = newStaticSeqDataBlock_(param_0, param_2);
+        u8* r30 = newStaticSeqDataBlock_(param_0, size);
         if (r30) {
-            memcpy(r30, param_1, param_2);
+            memcpy(r30, param_1, size);
             return true;
         }
     }

libs/JSystem/src/JAudio2/JAUSeqCollection.cpp

@@ -4,39 +4,39 @@
 #include "JSystem/JUtility/JUTAssert.h"
 
 JAUSeqCollection::JAUSeqCollection() {
-    field_0x8 = NULL;
+    mHeader = NULL;
 }
 
 void JAUSeqCollection::init(void const* param_0) {
-    field_0x8 = (const JAUSeqCollectionData*)param_0;
-    if (field_0x8->field_0x0 != 0x53 || field_0x8->field_0x1 != 0x43) {
-        field_0x8 = NULL;
+    mHeader = (const JAUSeqCollectionData*)param_0;
+    if (mHeader->mMagic1 != 0x53 || mHeader->mMagic2 != 0x43) {
+        mHeader = NULL;
         return;
     }
 
-    field_0x0 = field_0x8->field_0x2;
-    field_0xc = field_0x8->field_0x4;
-    field_0x4 = &field_0x8->field_0x8;
+    mNumSoundCategories = mHeader->mNumSoundCategories;
+    mSectionSize = mHeader->mSectionSize;
+    mTableOffsets = mHeader->mTableOffsets;
 
 }
 
 bool JAUSeqCollection::getSeqData(int param_0, int param_1, JAISeqData* param_2) {
-    if (param_0 >= field_0x0) {
+    if (param_0 >= mNumSoundCategories) {
         return false;
     }
-    u32 r29 = field_0x4[param_0];
-    BE(u32)* puVar2 = (BE(u32)*)((u8*)field_0x8 + r29);
+    u32 r29 = mTableOffsets[param_0];
+    BE(u32)* puVar2 = (BE(u32)*)((u8*)mHeader + r29);
     if (param_1 >= puVar2[0]) {
         return false;
     }
-    param_2->set((void*)field_0x8, puVar2[param_1 + 1]);
+    param_2->set((void*)mHeader, puVar2[param_1 + 1]);
     return true;
 }
 
 bool JAUSeqCollection::getSeqDataRegion(JAISeqDataRegion* param_0) {
     if (isValid()) {
-        param_0->addr = (u8*)field_0x8;
-        param_0->size = field_0xc;
+        param_0->addr = (u8*)mHeader;
+        param_0->size = mSectionSize;
         return true;
     }
     return false;

libs/JSystem/src/JAudio2/JAUSeqDataBlockMgr.cpp

@@ -87,8 +87,8 @@ s32 JAUDynamicSeqDataBlocks::getSeqData(JAISoundID param_0, JAISeqDataUser* para
 
     u8* seqData = mLoadedBlocks.getSeqData(param_0);
     if (seqData != NULL) {
-        param_2->field_0x0 = seqData;
-        param_2->field_0x4 = 0;
+        param_2->mBase = seqData;
+        param_2->mOffset = 0;
         return 2;
     }
 

libs/JSystem/src/JAudio2/dspproc.cpp

@@ -20,10 +20,14 @@ static void setup_callback(u16 param_0) {
     flag = FALSE;
 }
 
-void DsetupTable(u32 param_0, u32 param_1, u32 param_2, u32 param_3, u32 param_4) {
+void DsetupTable(u32 channelCount, u32 channelBufferAddress, u32 param_2, u32 param_3, u32 param_4) {
+#if TARGET_PC
+    return;
+#endif
+
     u32 table[5];
-    table[0] = (param_0 & 0xFFFF) | 0x81000000;
-    table[1] = param_1;
+    table[0] = (channelCount & 0xFFFF) | 0x81000000;
+    table[1] = channelBufferAddress;
     table[2] = param_2;
     table[3] = param_3;
     table[4] = param_4;

libs/JSystem/src/JAudio2/dsptask.cpp

@@ -4,6 +4,7 @@
 #include "JSystem/JAudio2/osdsp.h"
 #include "global.h"
 #include "os_report.h"
+#include "dusk/logging.h"
 
 static void DspInitWork();
 static void DspHandShake(void* param_0);
@@ -527,7 +528,7 @@ static DSPTaskInfo audio_task ATTRIBUTE_ALIGN(32);
 
 static u8 AUDIO_YIELD_BUFFER[8192] ATTRIBUTE_ALIGN(32);
 
-void DspBoot(void (*param_0)(void*)) {
+void DspBoot(void (*requestCallback)(void*)) {
     DspInitWork();
     OS_REPORT("Dsp をブートします\n");
     audio_task.priority = 0xf0;
@@ -542,13 +543,16 @@ void DspBoot(void (*param_0)(void*)) {
     audio_task.init_cb = DspHandShake;
     audio_task.res_cb = NULL;
     audio_task.done_cb = NULL;
-    audio_task.req_cb = param_0;
+    audio_task.req_cb = requestCallback;
     DSPInit();
     DSPAddPriorTask(&audio_task);
     OS_REPORT("Dspブートしました\n");
 }
 
 int DSPSendCommands2(u32* param_1, u32 param_2, void (*callBack)(u16)) {
+#if TARGET_PC
+    OSPanic(__FILE__, __LINE__, "We do not have a DSP");
+#endif
     s32 i;
     BOOL interruptFlag;
     s32 startWorkStatus;

libs/JSystem/src/JAudio2/osdsp_task.cpp

@@ -12,7 +12,7 @@ extern "C" void __DSP_remove_task(DSPTaskInfo* task);
 
 static void Dsp_Update_Request();
 
-static vu8 struct_80451308;
+static vu8 DspRunningStatus;
 static u8 struct_80451309;
 
 DSPTaskInfo* DSP_prior_task;
@@ -23,7 +23,7 @@ extern "C" void __DSPHandler(__OSInterrupt interrupt, OSContext* context) {
     OSClearContext(&funcContext);
     OSSetCurrentContext(&funcContext);
 
-    if (struct_80451308 == 1 || struct_80451308 == 0) {
+    if (DspRunningStatus == 1 || DspRunningStatus == 0) {
         __DSP_curr_task = DSP_prior_task;
     }
 
@@ -38,7 +38,7 @@ extern "C" void __DSPHandler(__OSInterrupt interrupt, OSContext* context) {
     case 0xDCD10000:
         __DSP_curr_task->state = 1;
         if (__DSP_curr_task == DSP_prior_task) {
-            struct_80451308 = 1;
+            DspRunningStatus = 1;
         }
         if (__DSP_curr_task->init_cb != NULL) {
             __DSP_curr_task->init_cb(__DSP_curr_task);
@@ -47,7 +47,7 @@ extern "C" void __DSPHandler(__OSInterrupt interrupt, OSContext* context) {
     case 0xDCD10001:
         __DSP_curr_task->state = 1;
         if (__DSP_curr_task == DSP_prior_task) {
-            struct_80451308 = 1;
+            DspRunningStatus = 1;
             Dsp_Update_Request();
         }
         if (__DSP_curr_task->res_cb != NULL) {
@@ -97,7 +97,7 @@ extern "C" void __DSPHandler(__OSInterrupt interrupt, OSContext* context) {
             __DSP_curr_task = DSP_prior_task;
             Dsp_Update_Request();
         } else {
-            struct_80451308 = 3;
+            DspRunningStatus = 3;
             DSPSendMailToDSP(0xCDD10001);
             while (DSPCheckMailToDSP() != 0);
             __DSP_exec_task(DSP_prior_task, __DSP_first_task);
@@ -113,7 +113,7 @@ extern "C" void __DSPHandler(__OSInterrupt interrupt, OSContext* context) {
 static u32 sync_stack[5];
 
 void DsyncFrame2(u32 param_0, u32 param_1, u32 param_2) {
-    if (struct_80451308 != 1) {
+    if (DspRunningStatus != 1) {
         sync_stack[0] = param_0;
         struct_80451309 = 1;
         sync_stack[1] = param_1;
@@ -125,7 +125,7 @@ void DsyncFrame2(u32 param_0, u32 param_1, u32 param_2) {
 }
 
 static void DsyncFrame3(u32 param_0, u32 param_1, u32 param_2, u32 param_3, u32 param_4) {
-    if (struct_80451308 != 1) {
+    if (DspRunningStatus != 1) {
         sync_stack[0] = param_0;
         struct_80451309 = 2;
         sync_stack[1] = param_1;
@@ -152,9 +152,9 @@ static void Dsp_Update_Request() {
 }
 
 int Dsp_Running_Check() {
-    return struct_80451308 == 1 ? TRUE : FALSE;
+    return DspRunningStatus == 1 ? TRUE : FALSE;
 }
 
 void Dsp_Running_Start() {
-    struct_80451308 = 1;
+    DspRunningStatus = 1;
 }

libs/JSystem/src/JKernel/JKRAramPiece.cpp

@@ -27,6 +27,10 @@ JSUList<JKRAMCommand> JKRAramPiece::sAramPieceCommandList;
 
 OSMutex JKRAramPiece::mMutex;
 
+#if DEBUG && TARGET_PC
+volatile u8 forceRead;
+#endif
+
 JKRAMCommand* JKRAramPiece::orderAsync(int direction, uintptr_t source, uintptr_t destination, u32 length,
                                        JKRAramBlock* block, JKRAMCommand::AsyncCallback callback) {
     lock();
@@ -45,6 +49,12 @@ JKRAMCommand* JKRAramPiece::orderAsync(int direction, uintptr_t source, uintptr_
         JKRAramPiece::prepareCommand(direction, source, destination, length, block, callback);
     message->setting(1, command);
 
+#if DEBUG && TARGET_PC
+    if (direction == ARAM_DIR_MRAM_TO_ARAM) {
+        forceRead = *reinterpret_cast<u8*>(source);
+    }
+#endif
+
     OSSendMessage(&JKRAram::sMessageQueue, message, OS_MESSAGE_BLOCK);
     if (command->mCallback != NULL) {
         sAramPieceCommandList.append(&command->mPieceLink);

libs/JSystem/src/JKernel/JKRHeap.cpp

@@ -15,6 +15,7 @@
 
 #include "JSystem/JUtility/JUTAssert.h"
 #include "JSystem/JUtility/JUTException.h"
+#include "dusk/string.hpp"
 #ifdef __MWERKS__
 #include <stdint.h>
 #else
@@ -585,7 +586,13 @@ void* operator new(size_t size JKR_HEAP_TOKEN_PARAM, int alignment) {
 #endif
 
 void* operator new(size_t size JKR_HEAP_TOKEN_PARAM, JKRHeap* heap, int alignment) {
-    return JKRHeap::alloc(size, alignment, heap);
+    void* mem = JKRHeap::alloc(size, alignment, heap);
+#if TARGET_PC
+    if (mem == nullptr) {
+        return fallback_alloc(size, abs(alignment), true);
+    }
+#endif
+    return mem;
 }
 
 #if !TARGET_PC
@@ -695,9 +702,7 @@ JKRHeap* JKRHeap::getCurrentHeap() {
 }
 
 void JKRHeap::setName(const char* name) {
-    size_t len = strlen(name);
-    strncpy(mName, name, sizeof(mName) - 1);
-    mName[sizeof(mName) - 1] = '\0';
+    dusk::SafeStringCopyTruncate(mName, name);
 }
 
 void JKRHeap::setNamef(const char* fmt, ...) {

libs/JSystem/src/JKernel/JKRThread.cpp

@@ -7,6 +7,10 @@
 #include "global.h"
 #include <stdint.h>
 
+#if TARGET_PC
+#include "dusk/os.h"
+#endif
+
 JSUList<JKRThread> JKRThread::sThreadList(0);
 
 void* JKRIdleThread::sThread;
@@ -88,6 +92,14 @@ void JKRThread::setCommon_heapSpecified(JKRHeap* heap, u32 stack_size, int param
 }
 
 void* JKRThread::start(void* thread) {
+#if TARGET_PC
+    auto& thd = *static_cast<JKRThread*>(thread);
+    if (thd.mThreadName == nullptr) {
+        thd.mThreadName = typeid(thd).name();
+    }
+    OSSetCurrentThreadName(thd.mThreadName);
+#endif
+
     return ((JKRThread*)thread)->run();
 }