From 5a079a2d114f96d4847d1ee305d5b7c16eeec50e Mon Sep 17 00:00:00 2001 From: 3gg <3gg@shellblade.net> Date: Sat, 27 Dec 2025 12:03:39 -0800 Subject: Initial commit --- contrib/SDL-3.2.8/src/thread/vita/SDL_sysmutex.c | 97 ++++++++++++++ contrib/SDL-3.2.8/src/thread/vita/SDL_sysmutex_c.h | 21 ++++ contrib/SDL-3.2.8/src/thread/vita/SDL_syssem.c | 122 ++++++++++++++++++ contrib/SDL-3.2.8/src/thread/vita/SDL_systhread.c | 139 +++++++++++++++++++++ .../SDL-3.2.8/src/thread/vita/SDL_systhread_c.h | 24 ++++ 5 files changed, 403 insertions(+) create mode 100644 contrib/SDL-3.2.8/src/thread/vita/SDL_sysmutex.c create mode 100644 contrib/SDL-3.2.8/src/thread/vita/SDL_sysmutex_c.h create mode 100644 contrib/SDL-3.2.8/src/thread/vita/SDL_syssem.c create mode 100644 contrib/SDL-3.2.8/src/thread/vita/SDL_systhread.c create mode 100644 contrib/SDL-3.2.8/src/thread/vita/SDL_systhread_c.h (limited to 'contrib/SDL-3.2.8/src/thread/vita') diff --git a/contrib/SDL-3.2.8/src/thread/vita/SDL_sysmutex.c b/contrib/SDL-3.2.8/src/thread/vita/SDL_sysmutex.c new file mode 100644 index 0000000..8a3664c --- /dev/null +++ b/contrib/SDL-3.2.8/src/thread/vita/SDL_sysmutex.c @@ -0,0 +1,97 @@ +/* + Simple DirectMedia Layer + Copyright (C) 1997-2025 Sam Lantinga + + 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" + +#ifdef SDL_THREAD_VITA + +#include "SDL_systhread_c.h" + +#include +#include + +struct SDL_Mutex +{ + SceKernelLwMutexWork lock; +}; + +SDL_Mutex *SDL_CreateMutex(void) +{ + SDL_Mutex *mutex = (SDL_Mutex *)SDL_malloc(sizeof(*mutex)); + if (mutex) { + const SceInt32 res = sceKernelCreateLwMutex( + &mutex->lock, + "SDL mutex", + SCE_KERNEL_MUTEX_ATTR_RECURSIVE, + 0, + NULL); + + if (res < 0) { + SDL_free(mutex); + mutex = NULL; + SDL_SetError("Error trying to create mutex: %x", res); + } + } + return mutex; +} + +void SDL_DestroyMutex(SDL_Mutex *mutex) +{ + if (mutex) { + sceKernelDeleteLwMutex(&mutex->lock); + SDL_free(mutex); + } +} + +void SDL_LockMutex(SDL_Mutex *mutex) SDL_NO_THREAD_SAFETY_ANALYSIS // clang doesn't know about NULL mutexes +{ + if (mutex) { + const SceInt32 res = sceKernelLockLwMutex(&mutex->lock, 1, NULL); + SDL_assert(res == SCE_KERNEL_OK); // assume we're in a lot of trouble if this assert fails. + } +} + +bool SDL_TryLockMutex(SDL_Mutex *mutex) +{ + bool result = true; + + if (mutex) { + const SceInt32 res = sceKernelTryLockLwMutex(&mutex->lock, 1); + if (res == SCE_KERNEL_OK) { + result = true; + } else if (res == SCE_KERNEL_ERROR_MUTEX_FAILED_TO_OWN) { + result = false; + } else { + SDL_assert(res == SCE_KERNEL_OK); // assume we're in a lot of trouble if this assert fails. + result = false; + } + } + return result; +} + +void SDL_UnlockMutex(SDL_Mutex *mutex) SDL_NO_THREAD_SAFETY_ANALYSIS // clang doesn't know about NULL mutexes +{ + if (mutex) { + const SceInt32 res = sceKernelUnlockLwMutex(&mutex->lock, 1); + SDL_assert(res == SCE_KERNEL_OK); // assume we're in a lot of trouble if this assert fails. + } +} + +#endif // SDL_THREAD_VITA diff --git a/contrib/SDL-3.2.8/src/thread/vita/SDL_sysmutex_c.h b/contrib/SDL-3.2.8/src/thread/vita/SDL_sysmutex_c.h new file mode 100644 index 0000000..4b0c6f8 --- /dev/null +++ b/contrib/SDL-3.2.8/src/thread/vita/SDL_sysmutex_c.h @@ -0,0 +1,21 @@ +/* + Simple DirectMedia Layer + Copyright (C) 1997-2025 Sam Lantinga + + 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/vita/SDL_syssem.c b/contrib/SDL-3.2.8/src/thread/vita/SDL_syssem.c new file mode 100644 index 0000000..3c6d28a --- /dev/null +++ b/contrib/SDL-3.2.8/src/thread/vita/SDL_syssem.c @@ -0,0 +1,122 @@ +/* + Simple DirectMedia Layer + Copyright (C) 1997-2025 Sam Lantinga + + 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" + +#ifdef SDL_THREAD_VITA + +// Semaphore functions for the VITA. + +#include +#include + +#include +#include +#include + +struct SDL_Semaphore +{ + SceUID semid; +}; + +// Create a semaphore +SDL_Semaphore *SDL_CreateSemaphore(Uint32 initial_value) +{ + SDL_Semaphore *sem; + + sem = (SDL_Semaphore *)SDL_malloc(sizeof(*sem)); + if (sem) { + // TODO: Figure out the limit on the maximum value. + sem->semid = sceKernelCreateSema("SDL sema", 0, initial_value, 255, NULL); + if (sem->semid < 0) { + SDL_SetError("Couldn't create semaphore"); + SDL_free(sem); + sem = NULL; + } + } + + return sem; +} + +// Free the semaphore +void SDL_DestroySemaphore(SDL_Semaphore *sem) +{ + if (sem) { + if (sem->semid > 0) { + sceKernelDeleteSema(sem->semid); + sem->semid = 0; + } + + SDL_free(sem); + } +} + +/* TODO: This routine is a bit overloaded. + * If the timeout is 0 then just poll the semaphore; if it's -1, pass + * NULL to sceKernelWaitSema() so that it waits indefinitely; and if the timeout + * is specified, convert it to microseconds. */ +bool SDL_WaitSemaphoreTimeoutNS(SDL_Semaphore *sem, Sint64 timeoutNS) +{ + SceUInt timeoutUS; + SceUInt *pTimeout = NULL; + + if (!sem) { + return true; + } + + if (timeoutNS == 0) { + return (sceKernelPollSema(sem->semid, 1) == 0); + } + + if (timeoutNS > 0) { + timeoutUS = (SceUInt)SDL_NS_TO_US(timeoutNS); // Convert to microseconds. + pTimeout = &timeoutUS; + } + + return (sceKernelWaitSema(sem->semid, 1, pTimeout) == 0); +} + +// Returns the current count of the semaphore +Uint32 SDL_GetSemaphoreValue(SDL_Semaphore *sem) +{ + SceKernelSemaInfo info; + info.size = sizeof(info); + + if (!sem) { + return 0; + } + + if (sceKernelGetSemaInfo(sem->semid, &info) >= 0) { + return info.currentCount; + } + + return 0; +} + +void SDL_SignalSemaphore(SDL_Semaphore *sem) +{ + if (!sem) { + return; + } + + sceKernelSignalSema(sem->semid, 1); +} + +#endif // SDL_THREAD_VITA diff --git a/contrib/SDL-3.2.8/src/thread/vita/SDL_systhread.c b/contrib/SDL-3.2.8/src/thread/vita/SDL_systhread.c new file mode 100644 index 0000000..344d911 --- /dev/null +++ b/contrib/SDL-3.2.8/src/thread/vita/SDL_systhread.c @@ -0,0 +1,139 @@ +/* + Simple DirectMedia Layer + Copyright (C) 1997-2025 Sam Lantinga + + 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" + +#ifdef SDL_THREAD_VITA + +// VITA thread management routines for SDL + +#include +#include + +#include "../SDL_systhread.h" +#include "../SDL_thread_c.h" +#include +#include + +#define VITA_THREAD_STACK_SIZE_MIN 0x1000 // 4KiB +#define VITA_THREAD_STACK_SIZE_MAX 0x2000000 // 32MiB +#define VITA_THREAD_STACK_SIZE_DEFAULT 0x10000 // 64KiB +#define VITA_THREAD_NAME_MAX 32 + +#define VITA_THREAD_PRIORITY_LOW 191 +#define VITA_THREAD_PRIORITY_NORMAL 160 +#define VITA_THREAD_PRIORITY_HIGH 112 +#define VITA_THREAD_PRIORITY_TIME_CRITICAL 64 + +static int ThreadEntry(SceSize args, void *argp) +{ + SDL_RunThread(*(SDL_Thread **)argp); + return 0; +} + +bool SDL_SYS_CreateThread(SDL_Thread *thread, + SDL_FunctionPointer pfnBeginThread, + SDL_FunctionPointer pfnEndThread) + +{ + char thread_name[VITA_THREAD_NAME_MAX]; + size_t stack_size = VITA_THREAD_STACK_SIZE_DEFAULT; + + SDL_strlcpy(thread_name, "SDL thread", VITA_THREAD_NAME_MAX); + if (thread->name) { + SDL_strlcpy(thread_name, thread->name, VITA_THREAD_NAME_MAX); + } + + if (thread->stacksize) { + if (thread->stacksize < VITA_THREAD_STACK_SIZE_MIN) { + thread->stacksize = VITA_THREAD_STACK_SIZE_MIN; + } + if (thread->stacksize > VITA_THREAD_STACK_SIZE_MAX) { + thread->stacksize = VITA_THREAD_STACK_SIZE_MAX; + } + stack_size = thread->stacksize; + } + + // Create new thread with the same priority as the current thread + thread->handle = sceKernelCreateThread( + thread_name, // name + ThreadEntry, // function to run + 0, // priority. 0 means priority of calling thread + stack_size, // stack size + 0, // attributes. always 0 + 0, // cpu affinity mask. 0 = all CPUs + NULL // opt. always NULL + ); + + if (thread->handle < 0) { + return SDL_SetError("sceKernelCreateThread() failed"); + } + + sceKernelStartThread(thread->handle, 4, &thread); + return true; +} + +void SDL_SYS_SetupThread(const char *name) +{ + // Do nothing. +} + +SDL_ThreadID SDL_GetCurrentThreadID(void) +{ + return (SDL_ThreadID)sceKernelGetThreadId(); +} + +void SDL_SYS_WaitThread(SDL_Thread *thread) +{ + sceKernelWaitThreadEnd(thread->handle, NULL, NULL); + sceKernelDeleteThread(thread->handle); +} + +void SDL_SYS_DetachThread(SDL_Thread *thread) +{ + // Do nothing. +} + +bool SDL_SYS_SetThreadPriority(SDL_ThreadPriority priority) +{ + int value = VITA_THREAD_PRIORITY_NORMAL; + + switch (priority) { + case SDL_THREAD_PRIORITY_LOW: + value = VITA_THREAD_PRIORITY_LOW; + break; + case SDL_THREAD_PRIORITY_NORMAL: + value = VITA_THREAD_PRIORITY_NORMAL; + break; + case SDL_THREAD_PRIORITY_HIGH: + value = VITA_THREAD_PRIORITY_HIGH; + break; + case SDL_THREAD_PRIORITY_TIME_CRITICAL: + value = VITA_THREAD_PRIORITY_TIME_CRITICAL; + break; + } + + if (sceKernelChangeThreadPriority(0, value) < 0) { + return SDL_SetError("sceKernelChangeThreadPriority() failed"); + } + return true; +} + +#endif // SDL_THREAD_VITA diff --git a/contrib/SDL-3.2.8/src/thread/vita/SDL_systhread_c.h b/contrib/SDL-3.2.8/src/thread/vita/SDL_systhread_c.h new file mode 100644 index 0000000..b231ec7 --- /dev/null +++ b/contrib/SDL-3.2.8/src/thread/vita/SDL_systhread_c.h @@ -0,0 +1,24 @@ +/* + Simple DirectMedia Layer + Copyright (C) 1997-2025 Sam Lantinga + + 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 + +typedef SceUID SYS_ThreadHandle; -- cgit v1.2.3