JASSoundParams imported. Work on JASTaskThread (#1961)

include/JSystem/JAudio2/JASHeapCtrl.h

@@ -69,6 +69,24 @@ namespace JASThreadingModel {
             BOOL field_0x0;
         };
     };
+
+    
+    struct ObjectLevelLockable {
+        // Should be templated on the chunk memory but couldn't initialize it inside the class itself
+        //template <typename A0>
+        struct Lock {
+            Lock(OSMutex* mutex) {
+                mMutex = mutex;
+                OSLockMutex(mMutex);
+            }
+
+            ~Lock() {
+                OSUnlockMutex(mMutex);
+            }
+
+            OSMutex* mMutex;
+        };
+    };
 };
 
 template <typename T>
@@ -79,6 +97,115 @@ public:
     void free(void* ptr, u32 n) { JASGenericMemPool::free(ptr, n); }
 };
 
+template<u32 ChunkSize, typename T>
+class JASMemChunkPool {
+    struct MemoryChunk {
+        MemoryChunk(MemoryChunk* nextChunk) {
+            mNextChunk = nextChunk;
+            mUsedSize = 0;
+            mChunks = 0;
+        }
+
+        bool checkArea(void* ptr) {
+            return (u8*)this + 0xc <= (u8*)ptr && (u8*)ptr < (u8*)this + (ChunkSize + 0xc);
+        }
+
+        MemoryChunk* getNextChunk() {
+            return mNextChunk;
+        }
+
+        void* alloc(u32 size) {
+            u8* rv = mBuffer + mUsedSize;
+            mUsedSize += size;
+            mChunks++;
+            return rv;
+        }
+
+        void free() {
+            mChunks--;
+        }
+
+        bool isEmpty() {
+            return mChunks == 0;
+        }
+
+        void setNextChunk(MemoryChunk* chunk) {
+            mNextChunk = chunk;
+        }
+
+        u32 getFreeSize() {
+            return ChunkSize - mUsedSize;
+        }
+
+        void revive() {
+            mUsedSize = 0;
+        }
+
+        MemoryChunk* mNextChunk;
+        u32 mUsedSize;
+        u32 mChunks;
+        u8 mBuffer[ChunkSize];
+    };
+public:
+    bool createNewChunk() {
+        bool uVar2;
+        if (field_0x18 != NULL && field_0x18->isEmpty()) {
+            field_0x18->revive();
+            uVar2 = 1;
+        } else {
+            MemoryChunk* pMVar4 = field_0x18;
+            field_0x18 = new (JASKernel::getSystemHeap(), 0) MemoryChunk(pMVar4);
+            if (field_0x18 != NULL) {
+                uVar2 = 1;
+            } else {
+                field_0x18 = new (JKRHeap::getSystemHeap(), 0) MemoryChunk(pMVar4);
+                if (field_0x18 != NULL) {
+                    uVar2 = 1;
+                } else {
+                    field_0x18 = pMVar4;
+                    uVar2 = 0;
+                }
+            }
+        }
+        return uVar2;
+    }
+
+    void* alloc(u32 size) {
+        T::Lock lock(&mMutex);
+        if (field_0x18->getFreeSize() < size) {
+            if (ChunkSize < size) {
+                return NULL;
+            }
+            if (createNewChunk() == 0) {
+                return NULL;
+            }
+        }
+        return field_0x18->alloc(size);
+    }
+
+    void free(void* ptr) {
+        T::Lock lock(&((JASMemChunkPool<ChunkSize,T>*)ptr)->mMutex);
+        MemoryChunk* chunk = ((JASMemChunkPool<ChunkSize,T>*)ptr)->field_0x18;
+        MemoryChunk* prevChunk = NULL;
+        while (chunk != NULL) {
+            if (chunk->checkArea(this)) {
+                chunk->free();
+                if (chunk != ((JASMemChunkPool<ChunkSize,T>*)ptr)->field_0x18 && chunk->isEmpty()) {
+                    MemoryChunk* nextChunk = chunk->getNextChunk();
+                    delete chunk;
+                    prevChunk->setNextChunk(nextChunk);
+                }
+                return;
+            }
+            prevChunk = chunk;
+            chunk = chunk->getNextChunk();
+        }
+    }
+
+    /* 0x00 */ OSMutex mMutex;
+    /* 0x18 */ MemoryChunk* field_0x18;
+};
+
 template <typename T>
 class JASPoolAllocObject {
 public:

include/JSystem/JAudio2/JASSoundParams.h

@@ -22,6 +22,41 @@ struct JASSoundParams {
 
     JASSoundParams() { init(); }
 
+    void clampVolume() {
+        if (mVolume < 0.0f)
+            mVolume = 0.0f;
+        else if (mVolume > 1.0f)
+            mVolume = 1.0f;
+    }
+
+    void clampFxMix(void) {
+        if (mFxMix < 0.0f)
+            mFxMix = 0.0f;
+        else if (mFxMix > 1.0f)
+            mFxMix = 1.0f;
+    }
+
+    void clampPitch() {
+        if (mPitch < 0.0f)
+            mPitch = 0.0f;
+        else if (mPitch > 8.0f)
+            mPitch = 8.0f;
+    }
+
+    void clampPan() {
+        if (mPan < 0.0f)
+            mPan = 0.0f;
+        else if (mPan > 1.0f)
+            mPan = 1.0f;
+    }
+    
+    void clampDolby() {
+        if (mDolby < 0.0f)
+            mDolby = 0.0f;
+        else if (mDolby > 1.0f)
+            mDolby = 1.0f;
+    }
+
     /* 0x00 */ f32 mVolume;
     /* 0x04 */ f32 mFxMix;
     /* 0x08 */ f32 mPitch;

include/JSystem/JAudio2/JASTaskThread.h

@@ -2,22 +2,33 @@
 #define JASTASKTHREAD_H
 
 #include "JSystem/JKernel/JKRThread.h"
+#include "JSystem/JAudio2/JASHeapCtrl.h"
 
 class JASTaskThread : public JKRThread {
+private:
+    struct JASThreadCallStack {
+        /* 0x00 */ void (*mRunFunc)(void*);
+        /* 0x04 */ u32 field_0x4;
+        /* 0x08 */ union {
+            u8 buffer[0x400];
+            void* pBuffer;
+        }field_0x8;
+    };
 public:
+    typedef JASMemChunkPool<1024, JASThreadingModel::ObjectLevelLockable> ThreadMemPool;
+
     /* 8028F6C4 */ JASTaskThread(int, int, u32);
-    /* 8028F9EC */ void allocCallStack(void (*)(void*), void*);
-    /* 8028F850 */ void allocCallStack(void (*)(void*), void const*, u32);
-    /* 8028FC54 */ void sendCmdMsg(void (*)(void*), void*);
+    /* 8028F9EC */ void* allocCallStack(void (*)(void*), void*);
+    /* 8028F850 */ void* allocCallStack(void (*)(void*), void const*, u32);
+    /* 8028FC54 */ int sendCmdMsg(void (*)(void*), void*);
     /* 8028FB5C */ int sendCmdMsg(void (*)(void*), void const*, u32);
     /* 8028FE88 */ void pause(bool);
 
     /* 8028F724 */ virtual ~JASTaskThread();
     /* 8028FD4C */ virtual void run();
 
-    /* 0x7C */ OSThreadQueue* mpThreadQueue;
+    /* 0x7C */ OSThreadQueue mpThreadQueue;
     /* 0x84 */ bool field_0x84;
-    /* 0x88 */ u32 field_0x88;
 };
 
 #endif /* JASTASKTHREAD_H */

include/JSystem/JKernel/JKRThread.h

@@ -74,8 +74,8 @@ public:
 
 protected:
     void resume() { OSResumeThread(mThreadRecord); }
-    void sendMessage(OSMessage message) {
-        OSSendMessage(&mMessageQueue, message, OS_MESSAGE_NOBLOCK);
+    BOOL sendMessage(OSMessage message) {
+        return OSSendMessage(&mMessageQueue, message, OS_MESSAGE_NOBLOCK);
     }
     void sendMessageBlock(OSMessage message) {
         OSSendMessage(&mMessageQueue, message, OS_MESSAGE_BLOCK);
@@ -85,6 +85,15 @@ protected:
         OSReceiveMessage(&mMessageQueue, &message, OS_MESSAGE_NOBLOCK);
         return message;
     }
+
+    OSMessage waitMessage(BOOL* received) {
+        OSMessage message;
+        BOOL rv = OSReceiveMessage(&mMessageQueue, &message, OS_MESSAGE_NOBLOCK);
+        if (received) {
+            *received = rv;
+        }
+        return message;
+    }
     OSMessage waitMessageBlock() {
         OSMessage message;
         OSReceiveMessage(&mMessageQueue, &message, OS_MESSAGE_BLOCK);