Initial commit

10 files changed, 945 insertions, 0 deletions

diff --git a/contrib/SDL-3.2.8/src/thread/generic/SDL_syscond.c b/contrib/SDL-3.2.8/src/thread/generic/SDL_syscond.c
new file mode 100644
index 0000000..5fdfe84
--- /dev/null
+++ b/contrib/SDL-3.2.8/src/thread/generic/SDL_syscond.c
@@ -0,0 +1,216 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2025 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+#include "SDL_internal.h"
+
+// An implementation of condition variables using semaphores and mutexes
+/*
+   This implementation borrows heavily from the BeOS condition variable
+   implementation, written by Christopher Tate and Owen Smith.  Thanks!
+ */
+
+#include "../generic/SDL_syscond_c.h"
+
+/* If two implementations are to be compiled into SDL (the active one
+ * will be chosen at runtime), the function names need to be
+ * suffixed
+ */
+#ifndef SDL_THREAD_GENERIC_COND_SUFFIX
+#define SDL_CreateCondition_generic      SDL_CreateCondition
+#define SDL_DestroyCondition_generic     SDL_DestroyCondition
+#define SDL_SignalCondition_generic      SDL_SignalCondition
+#define SDL_BroadcastCondition_generic   SDL_BroadcastCondition
+#endif
+
+typedef struct SDL_cond_generic
+{
+    SDL_Semaphore *sem;
+    SDL_Semaphore *handshake_sem;
+    SDL_Semaphore *signal_sem;
+    int num_waiting;
+    int num_signals;
+} SDL_cond_generic;
+
+// Create a condition variable
+SDL_Condition *SDL_CreateCondition_generic(void)
+{
+    SDL_cond_generic *cond = (SDL_cond_generic *)SDL_calloc(1, sizeof(*cond));
+
+#ifndef SDL_THREADS_DISABLED
+    if (cond) {
+        cond->sem = SDL_CreateSemaphore(0);
+        cond->handshake_sem = SDL_CreateSemaphore(0);
+        cond->signal_sem = SDL_CreateSemaphore(1);
+        if (!cond->sem || !cond->handshake_sem || !cond->signal_sem) {
+            SDL_DestroyCondition_generic((SDL_Condition *)cond);
+            cond = NULL;
+        }
+    }
+#endif
+
+    return (SDL_Condition *)cond;
+}
+
+// Destroy a condition variable
+void SDL_DestroyCondition_generic(SDL_Condition *_cond)
+{
+    SDL_cond_generic *cond = (SDL_cond_generic *)_cond;
+    if (cond) {
+        if (cond->sem) {
+            SDL_DestroySemaphore(cond->sem);
+        }
+        if (cond->handshake_sem) {
+            SDL_DestroySemaphore(cond->handshake_sem);
+        }
+        if (cond->signal_sem) {
+            SDL_DestroySemaphore(cond->signal_sem);
+        }
+        SDL_free(cond);
+    }
+}
+
+// Restart one of the threads that are waiting on the condition variable
+void SDL_SignalCondition_generic(SDL_Condition *_cond)
+{
+    SDL_cond_generic *cond = (SDL_cond_generic *)_cond;
+    if (!cond) {
+        return;
+    }
+
+#ifndef SDL_THREADS_DISABLED
+    /* If there are waiting threads not already signalled, then
+       signal the condition and wait for the thread to respond.
+     */
+    SDL_WaitSemaphore(cond->signal_sem);
+    if (cond->num_waiting > cond->num_signals) {
+        cond->num_signals++;
+        SDL_SignalSemaphore(cond->sem);
+        SDL_SignalSemaphore(cond->signal_sem);
+        SDL_WaitSemaphore(cond->handshake_sem);
+    } else {
+        SDL_SignalSemaphore(cond->signal_sem);
+    }
+#endif
+}
+
+// Restart all threads that are waiting on the condition variable
+void SDL_BroadcastCondition_generic(SDL_Condition *_cond)
+{
+    SDL_cond_generic *cond = (SDL_cond_generic *)_cond;
+    if (!cond) {
+        return;
+    }
+
+#ifndef SDL_THREADS_DISABLED
+    /* If there are waiting threads not already signalled, then
+       signal the condition and wait for the thread to respond.
+     */
+    SDL_WaitSemaphore(cond->signal_sem);
+    if (cond->num_waiting > cond->num_signals) {
+        const int num_waiting = (cond->num_waiting - cond->num_signals);
+        cond->num_signals = cond->num_waiting;
+        for (int i = 0; i < num_waiting; i++) {
+            SDL_SignalSemaphore(cond->sem);
+        }
+        /* Now all released threads are blocked here, waiting for us.
+           Collect them all (and win fabulous prizes!) :-)
+         */
+        SDL_SignalSemaphore(cond->signal_sem);
+        for (int i = 0; i < num_waiting; i++) {
+            SDL_WaitSemaphore(cond->handshake_sem);
+        }
+    } else {
+        SDL_SignalSemaphore(cond->signal_sem);
+    }
+#endif
+}
+
+/* Wait on the condition variable for at most 'timeoutNS' nanoseconds.
+   The mutex must be locked before entering this function!
+   The mutex is unlocked during the wait, and locked again after the wait.
+
+Typical use:
+
+Thread A:
+    SDL_LockMutex(lock);
+    while ( ! condition ) {
+        SDL_WaitCondition(cond, lock);
+    }
+    SDL_UnlockMutex(lock);
+
+Thread B:
+    SDL_LockMutex(lock);
+    ...
+    condition = true;
+    ...
+    SDL_SignalCondition(cond);
+    SDL_UnlockMutex(lock);
+ */
+bool SDL_WaitConditionTimeoutNS_generic(SDL_Condition *_cond, SDL_Mutex *mutex, Sint64 timeoutNS)
+{
+    SDL_cond_generic *cond = (SDL_cond_generic *)_cond;
+    bool result = true;
+
+    if (!cond || !mutex) {
+        return true;
+    }
+
+#ifndef SDL_THREADS_DISABLED
+    /* Obtain the protection mutex, and increment the number of waiters.
+       This allows the signal mechanism to only perform a signal if there
+       are waiting threads.
+     */
+    SDL_WaitSemaphore(cond->signal_sem);
+    cond->num_waiting++;
+    SDL_SignalSemaphore(cond->signal_sem);
+
+    // Unlock the mutex, as is required by condition variable semantics
+    SDL_UnlockMutex(mutex);
+
+    // Wait for a signal
+    result = SDL_WaitSemaphoreTimeoutNS(cond->sem, timeoutNS);
+
+    /* Let the signaler know we have completed the wait, otherwise
+       the signaler can race ahead and get the condition semaphore
+       if we are stopped between the mutex unlock and semaphore wait,
+       giving a deadlock.  See the following URL for details:
+       http://web.archive.org/web/20010914175514/http://www-classic.be.com/aboutbe/benewsletter/volume_III/Issue40.html#Workshop
+     */
+    SDL_WaitSemaphore(cond->signal_sem);
+    if (cond->num_signals > 0) {
+        SDL_SignalSemaphore(cond->handshake_sem);
+        cond->num_signals--;
+    }
+    cond->num_waiting--;
+    SDL_SignalSemaphore(cond->signal_sem);
+
+    // Lock the mutex, as is required by condition variable semantics
+    SDL_LockMutex(mutex);
+#endif
+
+    return result;
+}
+
+#ifndef SDL_THREAD_GENERIC_COND_SUFFIX
+bool SDL_WaitConditionTimeoutNS(SDL_Condition *cond, SDL_Mutex *mutex, Sint64 timeoutNS)
+{
+    return SDL_WaitConditionTimeoutNS_generic(cond, mutex, timeoutNS);
+}
+#endif
diff --git a/contrib/SDL-3.2.8/src/thread/generic/SDL_syscond_c.h b/contrib/SDL-3.2.8/src/thread/generic/SDL_syscond_c.h
new file mode 100644
index 0000000..253c394
--- /dev/null
+++ b/contrib/SDL-3.2.8/src/thread/generic/SDL_syscond_c.h
@@ -0,0 +1,36 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2025 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+#include "SDL_internal.h"
+
+#ifndef SDL_syscond_generic_h_
+#define SDL_syscond_generic_h_
+
+#ifdef SDL_THREAD_GENERIC_COND_SUFFIX
+
+SDL_Condition *SDL_CreateCondition_generic(void);
+void SDL_DestroyCondition_generic(SDL_Condition *cond);
+void SDL_SignalCondition_generic(SDL_Condition *cond);
+void SDL_BroadcastCondition_generic(SDL_Condition *cond);
+bool SDL_WaitConditionTimeoutNS_generic(SDL_Condition *cond, SDL_Mutex *mutex, Sint64 timeoutNS);
+
+#endif // SDL_THREAD_GENERIC_COND_SUFFIX
+
+#endif // SDL_syscond_generic_h_
diff --git a/contrib/SDL-3.2.8/src/thread/generic/SDL_sysmutex.c b/contrib/SDL-3.2.8/src/thread/generic/SDL_sysmutex.c
new file mode 100644
index 0000000..e58da67
--- /dev/null
+++ b/contrib/SDL-3.2.8/src/thread/generic/SDL_sysmutex.c
@@ -0,0 +1,132 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2025 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+#include "SDL_internal.h"
+
+// An implementation of mutexes using semaphores
+
+#include "SDL_systhread_c.h"
+
+struct SDL_Mutex
+{
+    int recursive;
+    SDL_ThreadID owner;
+    SDL_Semaphore *sem;
+};
+
+SDL_Mutex *SDL_CreateMutex(void)
+{
+    SDL_Mutex *mutex = (SDL_Mutex *)SDL_calloc(1, sizeof(*mutex));
+
+#ifndef SDL_THREADS_DISABLED
+    if (mutex) {
+        // Create the mutex semaphore, with initial value 1
+        mutex->sem = SDL_CreateSemaphore(1);
+        mutex->recursive = 0;
+        mutex->owner = 0;
+        if (!mutex->sem) {
+            SDL_free(mutex);
+            mutex = NULL;
+        }
+    }
+#endif // !SDL_THREADS_DISABLED
+
+    return mutex;
+}
+
+void SDL_DestroyMutex(SDL_Mutex *mutex)
+{
+    if (mutex) {
+        if (mutex->sem) {
+            SDL_DestroySemaphore(mutex->sem);
+        }
+        SDL_free(mutex);
+    }
+}
+
+void SDL_LockMutex(SDL_Mutex *mutex) SDL_NO_THREAD_SAFETY_ANALYSIS  // clang doesn't know about NULL mutexes
+{
+#ifndef SDL_THREADS_DISABLED
+    if (mutex != NULL) {
+        SDL_ThreadID this_thread = SDL_GetCurrentThreadID();
+        if (mutex->owner == this_thread) {
+            ++mutex->recursive;
+        } else {
+            /* The order of operations is important.
+               We set the locking thread id after we obtain the lock
+               so unlocks from other threads will fail.
+             */
+            SDL_WaitSemaphore(mutex->sem);
+            mutex->owner = this_thread;
+            mutex->recursive = 0;
+        }
+    }
+#endif // SDL_THREADS_DISABLED
+}
+
+bool SDL_TryLockMutex(SDL_Mutex *mutex)
+{
+    bool result = true;
+#ifndef SDL_THREADS_DISABLED
+    if (mutex) {
+        SDL_ThreadID this_thread = SDL_GetCurrentThreadID();
+        if (mutex->owner == this_thread) {
+            ++mutex->recursive;
+        } else {
+            /* The order of operations is important.
+               We set the locking thread id after we obtain the lock
+               so unlocks from other threads will fail.
+             */
+            result = SDL_TryWaitSemaphore(mutex->sem);
+            if (result) {
+                mutex->owner = this_thread;
+                mutex->recursive = 0;
+            }
+        }
+    }
+#endif // SDL_THREADS_DISABLED
+    return result;
+}
+
+void SDL_UnlockMutex(SDL_Mutex *mutex) SDL_NO_THREAD_SAFETY_ANALYSIS  // clang doesn't know about NULL mutexes
+{
+#ifndef SDL_THREADS_DISABLED
+    if (mutex != NULL) {
+        // If we don't own the mutex, we can't unlock it
+        if (SDL_GetCurrentThreadID() != mutex->owner) {
+            SDL_assert(!"Tried to unlock a mutex we don't own!");
+            return; // (undefined behavior!) SDL_SetError("mutex not owned by this thread");
+        }
+
+        if (mutex->recursive) {
+            --mutex->recursive;
+        } else {
+            /* The order of operations is important.
+               First reset the owner so another thread doesn't lock
+               the mutex and set the ownership before we reset it,
+               then release the lock semaphore.
+             */
+            mutex->owner = 0;
+            SDL_SignalSemaphore(mutex->sem);
+        }
+    }
+#endif // SDL_THREADS_DISABLED
+}
+
diff --git a/contrib/SDL-3.2.8/src/thread/generic/SDL_sysmutex_c.h b/contrib/SDL-3.2.8/src/thread/generic/SDL_sysmutex_c.h
new file mode 100644
index 0000000..4b0c6f8
--- /dev/null
+++ b/contrib/SDL-3.2.8/src/thread/generic/SDL_sysmutex_c.h
@@ -0,0 +1,21 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2025 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+#include "SDL_internal.h"
diff --git a/contrib/SDL-3.2.8/src/thread/generic/SDL_sysrwlock.c b/contrib/SDL-3.2.8/src/thread/generic/SDL_sysrwlock.c
new file mode 100644
index 0000000..24caf51
--- /dev/null
+++ b/contrib/SDL-3.2.8/src/thread/generic/SDL_sysrwlock.c
@@ -0,0 +1,194 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2025 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+#include "SDL_internal.h"
+
+// An implementation of rwlocks using mutexes, condition variables, and atomics.
+
+#include "SDL_systhread_c.h"
+
+#include "../generic/SDL_sysrwlock_c.h"
+
+/* If two implementations are to be compiled into SDL (the active one
+ * will be chosen at runtime), the function names need to be
+ * suffixed
+ */
+// !!! FIXME: this is quite a tapdance with macros and the build system, maybe we can simplify how we do this. --ryan.
+#ifndef SDL_THREAD_GENERIC_RWLOCK_SUFFIX
+#define SDL_CreateRWLock_generic SDL_CreateRWLock
+#define SDL_DestroyRWLock_generic SDL_DestroyRWLock
+#define SDL_LockRWLockForReading_generic SDL_LockRWLockForReading
+#define SDL_LockRWLockForWriting_generic SDL_LockRWLockForWriting
+#define SDL_UnlockRWLock_generic SDL_UnlockRWLock
+#endif
+
+struct SDL_RWLock
+{
+#ifdef SDL_THREADS_DISABLED
+    int unused;
+#else
+    SDL_Mutex *lock;
+    SDL_Condition *condition;
+    SDL_ThreadID writer_thread;
+    SDL_AtomicInt reader_count;
+    SDL_AtomicInt writer_count;
+#endif
+};
+
+SDL_RWLock *SDL_CreateRWLock_generic(void)
+{
+    SDL_RWLock *rwlock = (SDL_RWLock *) SDL_calloc(1, sizeof (*rwlock));
+
+    if (!rwlock) {
+        return NULL;
+    }
+
+#ifndef SDL_THREADS_DISABLED
+    rwlock->lock = SDL_CreateMutex();
+    if (!rwlock->lock) {
+        SDL_free(rwlock);
+        return NULL;
+    }
+
+    rwlock->condition = SDL_CreateCondition();
+    if (!rwlock->condition) {
+        SDL_DestroyMutex(rwlock->lock);
+        SDL_free(rwlock);
+        return NULL;
+    }
+
+    SDL_SetAtomicInt(&rwlock->reader_count, 0);
+    SDL_SetAtomicInt(&rwlock->writer_count, 0);
+#endif
+
+    return rwlock;
+}
+
+void SDL_DestroyRWLock_generic(SDL_RWLock *rwlock)
+{
+    if (rwlock) {
+#ifndef SDL_THREADS_DISABLED
+        SDL_DestroyMutex(rwlock->lock);
+        SDL_DestroyCondition(rwlock->condition);
+#endif
+        SDL_free(rwlock);
+    }
+}
+
+void SDL_LockRWLockForReading_generic(SDL_RWLock *rwlock) SDL_NO_THREAD_SAFETY_ANALYSIS  // clang doesn't know about NULL mutexes
+{
+#ifndef SDL_THREADS_DISABLED
+    if (rwlock) {
+        // !!! FIXME: these don't have to be atomic, we always gate them behind a mutex.
+        SDL_LockMutex(rwlock->lock);
+        SDL_assert(SDL_GetAtomicInt(&rwlock->writer_count) == 0);  // shouldn't be able to grab lock if there's a writer!
+        SDL_AddAtomicInt(&rwlock->reader_count, 1);
+        SDL_UnlockMutex(rwlock->lock);   // other readers can attempt to share the lock.
+    }
+#endif
+}
+
+void SDL_LockRWLockForWriting_generic(SDL_RWLock *rwlock) SDL_NO_THREAD_SAFETY_ANALYSIS  // clang doesn't know about NULL mutexes
+{
+#ifndef SDL_THREADS_DISABLED
+    if (rwlock) {
+        SDL_LockMutex(rwlock->lock);
+        while (SDL_GetAtomicInt(&rwlock->reader_count) > 0) {  // while something is holding the shared lock, keep waiting.
+            SDL_WaitCondition(rwlock->condition, rwlock->lock);  // release the lock and wait for readers holding the shared lock to release it, regrab the lock.
+        }
+
+        // we hold the lock!
+        SDL_AddAtomicInt(&rwlock->writer_count, 1);  // we let these be recursive, but the API doesn't require this. It _does_ trust you unlock correctly!
+    }
+#endif
+}
+
+bool SDL_TryLockRWLockForReading_generic(SDL_RWLock *rwlock)
+{
+#ifndef SDL_THREADS_DISABLED
+    if (rwlock) {
+        if (!SDL_TryLockMutex(rwlock->lock)) {
+            // !!! FIXME: there is a small window where a reader has to lock the mutex, and if we hit that, we will return SDL_RWLOCK_TIMEDOUT even though we could have shared the lock.
+            return false;
+        }
+
+        SDL_assert(SDL_GetAtomicInt(&rwlock->writer_count) == 0);  // shouldn't be able to grab lock if there's a writer!
+        SDL_AddAtomicInt(&rwlock->reader_count, 1);
+        SDL_UnlockMutex(rwlock->lock);   // other readers can attempt to share the lock.
+    }
+#endif
+
+    return true;
+}
+
+#ifndef SDL_THREAD_GENERIC_RWLOCK_SUFFIX
+bool SDL_TryLockRWLockForReading(SDL_RWLock *rwlock)
+{
+    return SDL_TryLockRWLockForReading_generic(rwlock);
+}
+#endif
+
+bool SDL_TryLockRWLockForWriting_generic(SDL_RWLock *rwlock)
+{
+#ifndef SDL_THREADS_DISABLED
+    if (rwlock) {
+        if (!SDL_TryLockMutex(rwlock->lock)) {
+            return false;
+        }
+
+        if (SDL_GetAtomicInt(&rwlock->reader_count) > 0) {  // a reader is using the shared lock, treat it as unavailable.
+            SDL_UnlockMutex(rwlock->lock);
+            return false;
+        }
+
+        // we hold the lock!
+        SDL_AddAtomicInt(&rwlock->writer_count, 1);  // we let these be recursive, but the API doesn't require this. It _does_ trust you unlock correctly!
+    }
+#endif
+
+    return true;
+}
+
+#ifndef SDL_THREAD_GENERIC_RWLOCK_SUFFIX
+bool SDL_TryLockRWLockForWriting(SDL_RWLock *rwlock)
+{
+    return SDL_TryLockRWLockForWriting_generic(rwlock);
+}
+#endif
+
+void SDL_UnlockRWLock_generic(SDL_RWLock *rwlock) SDL_NO_THREAD_SAFETY_ANALYSIS  // clang doesn't know about NULL mutexes
+{
+#ifndef SDL_THREADS_DISABLED
+    if (rwlock) {
+        SDL_LockMutex(rwlock->lock);  // recursive lock for writers, readers grab lock to make sure things are sane.
+
+        if (SDL_GetAtomicInt(&rwlock->reader_count) > 0) {  // we're a reader
+            SDL_AddAtomicInt(&rwlock->reader_count, -1);
+            SDL_BroadcastCondition(rwlock->condition);  // alert any pending writers to attempt to try to grab the lock again.
+        } else if (SDL_GetAtomicInt(&rwlock->writer_count) > 0) {  // we're a writer
+            SDL_AddAtomicInt(&rwlock->writer_count, -1);
+            SDL_UnlockMutex(rwlock->lock);  // recursive unlock.
+        }
+
+        SDL_UnlockMutex(rwlock->lock);
+    }
+#endif
+}
+
diff --git a/contrib/SDL-3.2.8/src/thread/generic/SDL_sysrwlock_c.h b/contrib/SDL-3.2.8/src/thread/generic/SDL_sysrwlock_c.h
new file mode 100644
index 0000000..9589d25
--- /dev/null
+++ b/contrib/SDL-3.2.8/src/thread/generic/SDL_sysrwlock_c.h
@@ -0,0 +1,38 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2025 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+#include "SDL_internal.h"
+
+#ifndef SDL_sysrwlock_c_h_
+#define SDL_sysrwlock_c_h_
+
+#ifdef SDL_THREAD_GENERIC_RWLOCK_SUFFIX
+
+SDL_RWLock *SDL_CreateRWLock_generic(void);
+void SDL_DestroyRWLock_generic(SDL_RWLock *rwlock);
+void SDL_LockRWLockForReading_generic(SDL_RWLock *rwlock);
+void  SDL_LockRWLockForWriting_generic(SDL_RWLock *rwlock);
+bool SDL_TryLockRWLockForReading_generic(SDL_RWLock *rwlock);
+bool SDL_TryLockRWLockForWriting_generic(SDL_RWLock *rwlock);
+void SDL_UnlockRWLock_generic(SDL_RWLock *rwlock);
+
+#endif // SDL_THREAD_GENERIC_RWLOCK_SUFFIX
+
+#endif // SDL_sysrwlock_c_h_
diff --git a/contrib/SDL-3.2.8/src/thread/generic/SDL_syssem.c b/contrib/SDL-3.2.8/src/thread/generic/SDL_syssem.c
new file mode 100644
index 0000000..dcd6fcc
--- /dev/null
+++ b/contrib/SDL-3.2.8/src/thread/generic/SDL_syssem.c
@@ -0,0 +1,183 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2025 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+#include "SDL_internal.h"
+
+// An implementation of semaphores using mutexes and condition variables
+
+#include "SDL_systhread_c.h"
+
+#ifdef SDL_THREADS_DISABLED
+
+SDL_Semaphore *SDL_CreateSemaphore(Uint32 initial_value)
+{
+    SDL_SetError("SDL not built with thread support");
+    return NULL;
+}
+
+void SDL_DestroySemaphore(SDL_Semaphore *sem)
+{
+}
+
+bool SDL_WaitSemaphoreTimeoutNS(SDL_Semaphore *sem, Sint64 timeoutNS)
+{
+    return true;
+}
+
+Uint32 SDL_GetSemaphoreValue(SDL_Semaphore *sem)
+{
+    return 0;
+}
+
+void SDL_SignalSemaphore(SDL_Semaphore *sem)
+{
+    return;
+}
+
+#else
+
+struct SDL_Semaphore
+{
+    Uint32 count;
+    Uint32 waiters_count;
+    SDL_Mutex *count_lock;
+    SDL_Condition *count_nonzero;
+};
+
+SDL_Semaphore *SDL_CreateSemaphore(Uint32 initial_value)
+{
+    SDL_Semaphore *sem;
+
+    sem = (SDL_Semaphore *)SDL_malloc(sizeof(*sem));
+    if (!sem) {
+        return NULL;
+    }
+    sem->count = initial_value;
+    sem->waiters_count = 0;
+
+    sem->count_lock = SDL_CreateMutex();
+    sem->count_nonzero = SDL_CreateCondition();
+    if (!sem->count_lock || !sem->count_nonzero) {
+        SDL_DestroySemaphore(sem);
+        return NULL;
+    }
+
+    return sem;
+}
+
+/* WARNING:
+   You cannot call this function when another thread is using the semaphore.
+*/
+void SDL_DestroySemaphore(SDL_Semaphore *sem)
+{
+    if (sem) {
+        sem->count = 0xFFFFFFFF;
+        while (sem->waiters_count > 0) {
+            SDL_SignalCondition(sem->count_nonzero);
+            SDL_Delay(10);
+        }
+        SDL_DestroyCondition(sem->count_nonzero);
+        if (sem->count_lock) {
+            SDL_LockMutex(sem->count_lock);
+            SDL_UnlockMutex(sem->count_lock);
+            SDL_DestroyMutex(sem->count_lock);
+        }
+        SDL_free(sem);
+    }
+}
+
+bool SDL_WaitSemaphoreTimeoutNS(SDL_Semaphore *sem, Sint64 timeoutNS)
+{
+    bool result = false;
+
+    if (!sem) {
+        return true;
+    }
+
+    if (timeoutNS == 0) {
+        SDL_LockMutex(sem->count_lock);
+        if (sem->count > 0) {
+            --sem->count;
+            result = true;
+        }
+        SDL_UnlockMutex(sem->count_lock);
+    } else if (timeoutNS < 0) {
+        SDL_LockMutex(sem->count_lock);
+        ++sem->waiters_count;
+        while (sem->count == 0) {
+            SDL_WaitConditionTimeoutNS(sem->count_nonzero, sem->count_lock, -1);
+        }
+        --sem->waiters_count;
+        --sem->count;
+        result = true;
+        SDL_UnlockMutex(sem->count_lock);
+    } else {
+        Uint64 stop_time = SDL_GetTicksNS() + timeoutNS;
+
+        SDL_LockMutex(sem->count_lock);
+        ++sem->waiters_count;
+        while (sem->count == 0) {
+            Sint64 waitNS = (Sint64)(stop_time - SDL_GetTicksNS());
+            if (waitNS > 0) {
+                SDL_WaitConditionTimeoutNS(sem->count_nonzero, sem->count_lock, waitNS);
+            } else {
+                break;
+            }
+        }
+        --sem->waiters_count;
+
+        if (sem->count > 0) {
+            --sem->count;
+            result = true;
+        }
+        SDL_UnlockMutex(sem->count_lock);
+    }
+
+    return result;
+}
+
+Uint32 SDL_GetSemaphoreValue(SDL_Semaphore *sem)
+{
+    Uint32 value;
+
+    value = 0;
+    if (sem) {
+        SDL_LockMutex(sem->count_lock);
+        value = sem->count;
+        SDL_UnlockMutex(sem->count_lock);
+    }
+    return value;
+}
+
+void SDL_SignalSemaphore(SDL_Semaphore *sem)
+{
+    if (!sem) {
+        return;
+    }
+
+    SDL_LockMutex(sem->count_lock);
+    if (sem->waiters_count > 0) {
+        SDL_SignalCondition(sem->count_nonzero);
+    }
+    ++sem->count;
+    SDL_UnlockMutex(sem->count_lock);
+}
+
+#endif // SDL_THREADS_DISABLED
diff --git a/contrib/SDL-3.2.8/src/thread/generic/SDL_systhread.c b/contrib/SDL-3.2.8/src/thread/generic/SDL_systhread.c
new file mode 100644
index 0000000..ecfa4e1
--- /dev/null
+++ b/contrib/SDL-3.2.8/src/thread/generic/SDL_systhread.c
@@ -0,0 +1,57 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2025 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+#include "SDL_internal.h"
+
+// Thread management routines for SDL
+
+#include "../SDL_systhread.h"
+
+bool SDL_SYS_CreateThread(SDL_Thread *thread,
+                          SDL_FunctionPointer pfnBeginThread,
+                          SDL_FunctionPointer pfnEndThread)
+{
+    return SDL_SetError("Threads are not supported on this platform");
+}
+
+void SDL_SYS_SetupThread(const char *name)
+{
+    return;
+}
+
+SDL_ThreadID SDL_GetCurrentThreadID(void)
+{
+    return 0;
+}
+
+bool SDL_SYS_SetThreadPriority(SDL_ThreadPriority priority)
+{
+    return true;
+}
+
+void SDL_SYS_WaitThread(SDL_Thread *thread)
+{
+    return;
+}
+
+void SDL_SYS_DetachThread(SDL_Thread *thread)
+{
+    return;
+}
diff --git a/contrib/SDL-3.2.8/src/thread/generic/SDL_systhread_c.h b/contrib/SDL-3.2.8/src/thread/generic/SDL_systhread_c.h
new file mode 100644
index 0000000..9ba55fd
--- /dev/null
+++ b/contrib/SDL-3.2.8/src/thread/generic/SDL_systhread_c.h
@@ -0,0 +1,24 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2025 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+#include "SDL_internal.h"
+
+// Stub until we implement threads on this platform
+typedef int SYS_ThreadHandle;
diff --git a/contrib/SDL-3.2.8/src/thread/generic/SDL_systls.c b/contrib/SDL-3.2.8/src/thread/generic/SDL_systls.c
new file mode 100644
index 0000000..b8ebafe
--- /dev/null
+++ b/contrib/SDL-3.2.8/src/thread/generic/SDL_systls.c
@@ -0,0 +1,44 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2025 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+
+#include "SDL_internal.h"
+#include "../SDL_thread_c.h"
+
+void SDL_SYS_InitTLSData(void)
+{
+    SDL_Generic_InitTLSData();
+}
+
+SDL_TLSData *SDL_SYS_GetTLSData(void)
+{
+    return SDL_Generic_GetTLSData();
+}
+
+bool SDL_SYS_SetTLSData(SDL_TLSData *data)
+{
+    return SDL_Generic_SetTLSData(data);
+}
+
+void SDL_SYS_QuitTLSData(void)
+{
+    SDL_Generic_QuitTLSData();
+}
+