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/timer/SDL_timer.c | 734 +++++++++++++++++++++ contrib/SDL-3.2.8/src/timer/SDL_timer_c.h | 39 ++ contrib/SDL-3.2.8/src/timer/haiku/SDL_systimer.c | 43 ++ contrib/SDL-3.2.8/src/timer/n3ds/SDL_systimer.c | 43 ++ contrib/SDL-3.2.8/src/timer/ps2/SDL_systimer.c | 50 ++ contrib/SDL-3.2.8/src/timer/psp/SDL_systimer.c | 54 ++ contrib/SDL-3.2.8/src/timer/unix/SDL_systimer.c | 188 ++++++ contrib/SDL-3.2.8/src/timer/vita/SDL_systimer.c | 51 ++ contrib/SDL-3.2.8/src/timer/windows/SDL_systimer.c | 133 ++++ 9 files changed, 1335 insertions(+) create mode 100644 contrib/SDL-3.2.8/src/timer/SDL_timer.c create mode 100644 contrib/SDL-3.2.8/src/timer/SDL_timer_c.h create mode 100644 contrib/SDL-3.2.8/src/timer/haiku/SDL_systimer.c create mode 100644 contrib/SDL-3.2.8/src/timer/n3ds/SDL_systimer.c create mode 100644 contrib/SDL-3.2.8/src/timer/ps2/SDL_systimer.c create mode 100644 contrib/SDL-3.2.8/src/timer/psp/SDL_systimer.c create mode 100644 contrib/SDL-3.2.8/src/timer/unix/SDL_systimer.c create mode 100644 contrib/SDL-3.2.8/src/timer/vita/SDL_systimer.c create mode 100644 contrib/SDL-3.2.8/src/timer/windows/SDL_systimer.c (limited to 'contrib/SDL-3.2.8/src/timer') diff --git a/contrib/SDL-3.2.8/src/timer/SDL_timer.c b/contrib/SDL-3.2.8/src/timer/SDL_timer.c new file mode 100644 index 0000000..2fa6553 --- /dev/null +++ b/contrib/SDL-3.2.8/src/timer/SDL_timer.c @@ -0,0 +1,734 @@ +/* + 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" + +#include "SDL_timer_c.h" +#include "../thread/SDL_systhread.h" + +// #define DEBUG_TIMERS + +#if !defined(SDL_PLATFORM_EMSCRIPTEN) || !defined(SDL_THREADS_DISABLED) + +typedef struct SDL_Timer +{ + SDL_TimerID timerID; + SDL_TimerCallback callback_ms; + SDL_NSTimerCallback callback_ns; + void *userdata; + Uint64 interval; + Uint64 scheduled; + SDL_AtomicInt canceled; + struct SDL_Timer *next; +} SDL_Timer; + +typedef struct SDL_TimerMap +{ + SDL_TimerID timerID; + SDL_Timer *timer; + struct SDL_TimerMap *next; +} SDL_TimerMap; + +// The timers are kept in a sorted list +typedef struct +{ + // Data used by the main thread + SDL_InitState init; + SDL_Thread *thread; + SDL_TimerMap *timermap; + SDL_Mutex *timermap_lock; + + // Padding to separate cache lines between threads + char cache_pad[SDL_CACHELINE_SIZE]; + + // Data used to communicate with the timer thread + SDL_SpinLock lock; + SDL_Semaphore *sem; + SDL_Timer *pending; + SDL_Timer *freelist; + SDL_AtomicInt active; + + // List of timers - this is only touched by the timer thread + SDL_Timer *timers; +} SDL_TimerData; + +static SDL_TimerData SDL_timer_data; + +/* The idea here is that any thread might add a timer, but a single + * thread manages the active timer queue, sorted by scheduling time. + * + * Timers are removed by simply setting a canceled flag + */ + +static void SDL_AddTimerInternal(SDL_TimerData *data, SDL_Timer *timer) +{ + SDL_Timer *prev, *curr; + + prev = NULL; + for (curr = data->timers; curr; prev = curr, curr = curr->next) { + if (curr->scheduled > timer->scheduled) { + break; + } + } + + // Insert the timer here! + if (prev) { + prev->next = timer; + } else { + data->timers = timer; + } + timer->next = curr; +} + +static int SDLCALL SDL_TimerThread(void *_data) +{ + SDL_TimerData *data = (SDL_TimerData *)_data; + SDL_Timer *pending; + SDL_Timer *current; + SDL_Timer *freelist_head = NULL; + SDL_Timer *freelist_tail = NULL; + Uint64 tick, now, interval, delay; + + /* Threaded timer loop: + * 1. Queue timers added by other threads + * 2. Handle any timers that should dispatch this cycle + * 3. Wait until next dispatch time or new timer arrives + */ + for (;;) { + // Pending and freelist maintenance + SDL_LockSpinlock(&data->lock); + { + // Get any timers ready to be queued + pending = data->pending; + data->pending = NULL; + + // Make any unused timer structures available + if (freelist_head) { + freelist_tail->next = data->freelist; + data->freelist = freelist_head; + } + } + SDL_UnlockSpinlock(&data->lock); + + // Sort the pending timers into our list + while (pending) { + current = pending; + pending = pending->next; + SDL_AddTimerInternal(data, current); + } + freelist_head = NULL; + freelist_tail = NULL; + + // Check to see if we're still running, after maintenance + if (!SDL_GetAtomicInt(&data->active)) { + break; + } + + // Initial delay if there are no timers + delay = (Uint64)-1; + + tick = SDL_GetTicksNS(); + + // Process all the pending timers for this tick + while (data->timers) { + current = data->timers; + + if (tick < current->scheduled) { + // Scheduled for the future, wait a bit + delay = (current->scheduled - tick); + break; + } + + // We're going to do something with this timer + data->timers = current->next; + + if (SDL_GetAtomicInt(¤t->canceled)) { + interval = 0; + } else { + if (current->callback_ms) { + interval = SDL_MS_TO_NS(current->callback_ms(current->userdata, current->timerID, (Uint32)SDL_NS_TO_MS(current->interval))); + } else { + interval = current->callback_ns(current->userdata, current->timerID, current->interval); + } + } + + if (interval > 0) { + // Reschedule this timer + current->interval = interval; + current->scheduled = tick + interval; + SDL_AddTimerInternal(data, current); + } else { + if (!freelist_head) { + freelist_head = current; + } + if (freelist_tail) { + freelist_tail->next = current; + } + freelist_tail = current; + + SDL_SetAtomicInt(¤t->canceled, 1); + } + } + + // Adjust the delay based on processing time + now = SDL_GetTicksNS(); + interval = (now - tick); + if (interval > delay) { + delay = 0; + } else { + delay -= interval; + } + + /* Note that each time a timer is added, this will return + immediately, but we process the timers added all at once. + That's okay, it just means we run through the loop a few + extra times. + */ + SDL_WaitSemaphoreTimeoutNS(data->sem, delay); + } + return 0; +} + +bool SDL_InitTimers(void) +{ + SDL_TimerData *data = &SDL_timer_data; + + if (!SDL_ShouldInit(&data->init)) { + return true; + } + + data->timermap_lock = SDL_CreateMutex(); + if (!data->timermap_lock) { + goto error; + } + + data->sem = SDL_CreateSemaphore(0); + if (!data->sem) { + goto error; + } + + SDL_SetAtomicInt(&data->active, true); + + // Timer threads use a callback into the app, so we can't set a limited stack size here. + data->thread = SDL_CreateThread(SDL_TimerThread, "SDLTimer", data); + if (!data->thread) { + goto error; + } + + SDL_SetInitialized(&data->init, true); + return true; + +error: + SDL_SetInitialized(&data->init, true); + SDL_QuitTimers(); + return false; +} + +void SDL_QuitTimers(void) +{ + SDL_TimerData *data = &SDL_timer_data; + SDL_Timer *timer; + SDL_TimerMap *entry; + + if (!SDL_ShouldQuit(&data->init)) { + return; + } + + SDL_SetAtomicInt(&data->active, false); + + // Shutdown the timer thread + if (data->thread) { + SDL_SignalSemaphore(data->sem); + SDL_WaitThread(data->thread, NULL); + data->thread = NULL; + } + + if (data->sem) { + SDL_DestroySemaphore(data->sem); + data->sem = NULL; + } + + // Clean up the timer entries + while (data->timers) { + timer = data->timers; + data->timers = timer->next; + SDL_free(timer); + } + while (data->freelist) { + timer = data->freelist; + data->freelist = timer->next; + SDL_free(timer); + } + while (data->timermap) { + entry = data->timermap; + data->timermap = entry->next; + SDL_free(entry); + } + + if (data->timermap_lock) { + SDL_DestroyMutex(data->timermap_lock); + data->timermap_lock = NULL; + } + + SDL_SetInitialized(&data->init, false); +} + +static bool SDL_CheckInitTimers(void) +{ + return SDL_InitTimers(); +} + +static SDL_TimerID SDL_CreateTimer(Uint64 interval, SDL_TimerCallback callback_ms, SDL_NSTimerCallback callback_ns, void *userdata) +{ + SDL_TimerData *data = &SDL_timer_data; + SDL_Timer *timer; + SDL_TimerMap *entry; + + if (!callback_ms && !callback_ns) { + SDL_InvalidParamError("callback"); + return 0; + } + + if (!SDL_CheckInitTimers()) { + return 0; + } + + SDL_LockSpinlock(&data->lock); + timer = data->freelist; + if (timer) { + data->freelist = timer->next; + } + SDL_UnlockSpinlock(&data->lock); + + if (timer) { + SDL_RemoveTimer(timer->timerID); + } else { + timer = (SDL_Timer *)SDL_malloc(sizeof(*timer)); + if (!timer) { + return 0; + } + } + timer->timerID = SDL_GetNextObjectID(); + timer->callback_ms = callback_ms; + timer->callback_ns = callback_ns; + timer->userdata = userdata; + timer->interval = interval; + timer->scheduled = SDL_GetTicksNS() + timer->interval; + SDL_SetAtomicInt(&timer->canceled, 0); + + entry = (SDL_TimerMap *)SDL_malloc(sizeof(*entry)); + if (!entry) { + SDL_free(timer); + return 0; + } + entry->timer = timer; + entry->timerID = timer->timerID; + + SDL_LockMutex(data->timermap_lock); + entry->next = data->timermap; + data->timermap = entry; + SDL_UnlockMutex(data->timermap_lock); + + // Add the timer to the pending list for the timer thread + SDL_LockSpinlock(&data->lock); + timer->next = data->pending; + data->pending = timer; + SDL_UnlockSpinlock(&data->lock); + + // Wake up the timer thread if necessary + SDL_SignalSemaphore(data->sem); + + return entry->timerID; +} + +SDL_TimerID SDL_AddTimer(Uint32 interval, SDL_TimerCallback callback, void *userdata) +{ + return SDL_CreateTimer(SDL_MS_TO_NS(interval), callback, NULL, userdata); +} + +SDL_TimerID SDL_AddTimerNS(Uint64 interval, SDL_NSTimerCallback callback, void *userdata) +{ + return SDL_CreateTimer(interval, NULL, callback, userdata); +} + +bool SDL_RemoveTimer(SDL_TimerID id) +{ + SDL_TimerData *data = &SDL_timer_data; + SDL_TimerMap *prev, *entry; + bool canceled = false; + + if (!id) { + return SDL_InvalidParamError("id"); + } + + // Find the timer + SDL_LockMutex(data->timermap_lock); + prev = NULL; + for (entry = data->timermap; entry; prev = entry, entry = entry->next) { + if (entry->timerID == id) { + if (prev) { + prev->next = entry->next; + } else { + data->timermap = entry->next; + } + break; + } + } + SDL_UnlockMutex(data->timermap_lock); + + if (entry) { + if (!SDL_GetAtomicInt(&entry->timer->canceled)) { + SDL_SetAtomicInt(&entry->timer->canceled, 1); + canceled = true; + } + SDL_free(entry); + } + if (canceled) { + return true; + } else { + return SDL_SetError("Timer not found"); + } +} + +#else + +#include +#include + +typedef struct SDL_TimerMap +{ + SDL_TimerID timerID; + int timeoutID; + Uint64 interval; + SDL_TimerCallback callback_ms; + SDL_NSTimerCallback callback_ns; + void *userdata; + struct SDL_TimerMap *next; +} SDL_TimerMap; + +typedef struct +{ + SDL_TimerMap *timermap; +} SDL_TimerData; + +static SDL_TimerData SDL_timer_data; + +static void SDL_Emscripten_TimerHelper(void *userdata) +{ + SDL_TimerMap *entry = (SDL_TimerMap *)userdata; + if (entry->callback_ms) { + entry->interval = SDL_MS_TO_NS(entry->callback_ms(entry->userdata, entry->timerID, (Uint32)SDL_NS_TO_MS(entry->interval))); + } else { + entry->interval = entry->callback_ns(entry->userdata, entry->timerID, entry->interval); + } + if (entry->interval > 0) { + entry->timeoutID = emscripten_set_timeout(&SDL_Emscripten_TimerHelper, + SDL_NS_TO_MS(entry->interval), + entry); + } +} + +bool SDL_InitTimers(void) +{ + return true; +} + +void SDL_QuitTimers(void) +{ + SDL_TimerData *data = &SDL_timer_data; + SDL_TimerMap *entry; + + while (data->timermap) { + entry = data->timermap; + data->timermap = entry->next; + SDL_free(entry); + } +} + +static SDL_TimerID SDL_CreateTimer(Uint64 interval, SDL_TimerCallback callback_ms, SDL_NSTimerCallback callback_ns, void *userdata) +{ + SDL_TimerData *data = &SDL_timer_data; + SDL_TimerMap *entry; + + if (!callback_ms && !callback_ns) { + SDL_InvalidParamError("callback"); + return 0; + } + + entry = (SDL_TimerMap *)SDL_malloc(sizeof(*entry)); + if (!entry) { + return 0; + } + entry->timerID = SDL_GetNextObjectID(); + entry->callback_ms = callback_ms; + entry->callback_ns = callback_ns; + entry->userdata = userdata; + entry->interval = interval; + + entry->timeoutID = emscripten_set_timeout(&SDL_Emscripten_TimerHelper, + SDL_NS_TO_MS(entry->interval), + entry); + + entry->next = data->timermap; + data->timermap = entry; + + return entry->timerID; +} + +SDL_TimerID SDL_AddTimer(Uint32 interval, SDL_TimerCallback callback, void *userdata) +{ + return SDL_CreateTimer(SDL_MS_TO_NS(interval), callback, NULL, userdata); +} + +SDL_TimerID SDL_AddTimerNS(Uint64 interval, SDL_NSTimerCallback callback, void *userdata) +{ + return SDL_CreateTimer(interval, NULL, callback, userdata); +} + +bool SDL_RemoveTimer(SDL_TimerID id) +{ + SDL_TimerData *data = &SDL_timer_data; + SDL_TimerMap *prev, *entry; + + if (!id) { + return SDL_InvalidParamError("id"); + } + + // Find the timer + prev = NULL; + for (entry = data->timermap; entry; prev = entry, entry = entry->next) { + if (entry->timerID == id) { + if (prev) { + prev->next = entry->next; + } else { + data->timermap = entry->next; + } + break; + } + } + + if (entry) { + emscripten_clear_timeout(entry->timeoutID); + SDL_free(entry); + return true; + } else { + return SDL_SetError("Timer not found"); + } +} + +#endif // !SDL_PLATFORM_EMSCRIPTEN || !SDL_THREADS_DISABLED + +static Uint64 tick_start; +static Uint32 tick_numerator_ns; +static Uint32 tick_denominator_ns; +static Uint32 tick_numerator_ms; +static Uint32 tick_denominator_ms; + +#if defined(SDL_TIMER_WINDOWS) && !defined(SDL_PLATFORM_XBOXONE) && !defined(SDL_PLATFORM_XBOXSERIES) +#include +#define HAVE_TIME_BEGIN_PERIOD +#endif + +static void SDL_SetSystemTimerResolutionMS(int period) +{ +#ifdef HAVE_TIME_BEGIN_PERIOD + static int timer_period = 0; + + if (period != timer_period) { + if (timer_period) { + timeEndPeriod((UINT)timer_period); + } + + timer_period = period; + + if (timer_period) { + timeBeginPeriod((UINT)timer_period); + } + } +#endif // HAVE_TIME_BEGIN_PERIOD +} + +static void SDLCALL SDL_TimerResolutionChanged(void *userdata, const char *name, const char *oldValue, const char *hint) +{ + int period; + + // Unless the hint says otherwise, let's have good sleep precision + if (hint && *hint) { + period = SDL_atoi(hint); + } else { + period = 1; + } + if (period || oldValue != hint) { + SDL_SetSystemTimerResolutionMS(period); + } +} + +void SDL_InitTicks(void) +{ + Uint64 tick_freq; + Uint32 gcd; + + if (tick_start) { + return; + } + + /* If we didn't set a precision, set it high. This affects lots of things + on Windows besides the SDL timers, like audio callbacks, etc. */ + SDL_AddHintCallback(SDL_HINT_TIMER_RESOLUTION, + SDL_TimerResolutionChanged, NULL); + + tick_freq = SDL_GetPerformanceFrequency(); + SDL_assert(tick_freq > 0 && tick_freq <= (Uint64)SDL_MAX_UINT32); + + gcd = SDL_CalculateGCD(SDL_NS_PER_SECOND, (Uint32)tick_freq); + tick_numerator_ns = (SDL_NS_PER_SECOND / gcd); + tick_denominator_ns = (Uint32)(tick_freq / gcd); + + gcd = SDL_CalculateGCD(SDL_MS_PER_SECOND, (Uint32)tick_freq); + tick_numerator_ms = (SDL_MS_PER_SECOND / gcd); + tick_denominator_ms = (Uint32)(tick_freq / gcd); + + tick_start = SDL_GetPerformanceCounter(); + if (!tick_start) { + --tick_start; + } +} + +void SDL_QuitTicks(void) +{ + SDL_RemoveHintCallback(SDL_HINT_TIMER_RESOLUTION, + SDL_TimerResolutionChanged, NULL); + + SDL_SetSystemTimerResolutionMS(0); // always release our timer resolution request. + + tick_start = 0; +} + +Uint64 SDL_GetTicksNS(void) +{ + Uint64 starting_value, value; + + if (!tick_start) { + SDL_InitTicks(); + } + + starting_value = (SDL_GetPerformanceCounter() - tick_start); + value = (starting_value * tick_numerator_ns); + SDL_assert(value >= starting_value); + value /= tick_denominator_ns; + return value; +} + +Uint64 SDL_GetTicks(void) +{ + Uint64 starting_value, value; + + if (!tick_start) { + SDL_InitTicks(); + } + + starting_value = (SDL_GetPerformanceCounter() - tick_start); + value = (starting_value * tick_numerator_ms); + SDL_assert(value >= starting_value); + value /= tick_denominator_ms; + return value; +} + +void SDL_Delay(Uint32 ms) +{ + SDL_SYS_DelayNS(SDL_MS_TO_NS(ms)); +} + +void SDL_DelayNS(Uint64 ns) +{ + SDL_SYS_DelayNS(ns); +} + +void SDL_DelayPrecise(Uint64 ns) +{ + Uint64 current_value = SDL_GetTicksNS(); + const Uint64 target_value = current_value + ns; + + // Sleep for a short number of cycles when real sleeps are desired. + // We'll use 1 ms, it's the minimum guaranteed to produce real sleeps across + // all platforms. + const Uint64 SHORT_SLEEP_NS = 1 * SDL_NS_PER_MS; + + // Try to sleep short of target_value. If for some crazy reason + // a particular platform sleeps for less than 1 ms when 1 ms was requested, + // that's fine, the code below can cope with that, but in practice no + // platforms behave that way. + Uint64 max_sleep_ns = SHORT_SLEEP_NS; + while (current_value + max_sleep_ns < target_value) { + // Sleep for a short time + SDL_SYS_DelayNS(SHORT_SLEEP_NS); + + const Uint64 now = SDL_GetTicksNS(); + const Uint64 next_sleep_ns = (now - current_value); + if (next_sleep_ns > max_sleep_ns) { + max_sleep_ns = next_sleep_ns; + } + current_value = now; + } + + // Do a shorter sleep of the remaining time here, less the max overshoot in + // the first loop. Due to maintaining max_sleep_ns as + // greater-than-or-equal-to-1 ms, we can always subtract off 1 ms to get + // the duration overshot beyond a 1 ms sleep request; if the system never + // overshot, great, it's zero duration. By choosing the max overshoot + // amount, we're likely to not overshoot here. If the sleep here ends up + // functioning like SDL_DelayNS(0) internally, that's fine, we just don't + // get to do a more-precise-than-1 ms-resolution sleep to undershoot by a + // small amount on the current system, but SDL_DelayNS(0) does at least + // introduce a small, yielding delay on many platforms, better than an + // unyielding busyloop. + // + // Note that we'll always do at least one sleep in this function, so the + // minimum resolution will be that of SDL_SYS_DelayNS() + if (current_value < target_value && (target_value - current_value) > (max_sleep_ns - SHORT_SLEEP_NS)) { + const Uint64 delay_ns = (target_value - current_value) - (max_sleep_ns - SHORT_SLEEP_NS); + SDL_SYS_DelayNS(delay_ns); + current_value = SDL_GetTicksNS(); + } + + // We've likely undershot target_value at this point by a pretty small + // amount, but maybe not. The footgun case if not handled here is where + // we've undershot by a large amount, like several ms, but still smaller + // than the amount max_sleep_ns overshot by; in such a situation, the above + // shorter-sleep block didn't do any delay, the if-block wasn't entered. + // Also, maybe the shorter-sleep undershot by several ms, so we still don't + // want to spin a lot then. In such a case, we accept the possibility of + // overshooting to not spin much, or if overshot here, not at all, keeping + // CPU/power usage down in any case. Due to scheduler sloppiness, it's + // entirely possible to end up undershooting/overshooting here by much less + // than 1 ms even if the current system's sleep function is only 1 + // ms-resolution, as SDL_GetTicksNS() generally is better resolution than 1 + // ms on the systems SDL supports. + while (current_value + SHORT_SLEEP_NS < target_value) { + SDL_SYS_DelayNS(SHORT_SLEEP_NS); + current_value = SDL_GetTicksNS(); + } + + // Spin for any remaining time + while (current_value < target_value) { + SDL_CPUPauseInstruction(); + current_value = SDL_GetTicksNS(); + } +} diff --git a/contrib/SDL-3.2.8/src/timer/SDL_timer_c.h b/contrib/SDL-3.2.8/src/timer/SDL_timer_c.h new file mode 100644 index 0000000..18d8171 --- /dev/null +++ b/contrib/SDL-3.2.8/src/timer/SDL_timer_c.h @@ -0,0 +1,39 @@ +/* + 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. +*/ + +#ifndef SDL_timer_c_h_ +#define SDL_timer_c_h_ + +#include "SDL_internal.h" + +// Useful functions and variables from SDL_timer.c + +#define ROUND_RESOLUTION(X) \ + (((X + TIMER_RESOLUTION - 1) / TIMER_RESOLUTION) * TIMER_RESOLUTION) + +extern void SDL_InitTicks(void); +extern void SDL_QuitTicks(void); +extern bool SDL_InitTimers(void); +extern void SDL_QuitTimers(void); + +extern void SDL_SYS_DelayNS(Uint64 ns); + +#endif // SDL_timer_c_h_ diff --git a/contrib/SDL-3.2.8/src/timer/haiku/SDL_systimer.c b/contrib/SDL-3.2.8/src/timer/haiku/SDL_systimer.c new file mode 100644 index 0000000..67447b1 --- /dev/null +++ b/contrib/SDL-3.2.8/src/timer/haiku/SDL_systimer.c @@ -0,0 +1,43 @@ +/* + 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_TIMER_HAIKU + +#include + + +Uint64 SDL_GetPerformanceCounter(void) +{ + return system_time(); +} + +Uint64 SDL_GetPerformanceFrequency(void) +{ + return SDL_US_PER_SECOND; +} + +void SDL_SYS_DelayNS(Uint64 ns) +{ + snooze((bigtime_t)SDL_NS_TO_US(ns)); +} + +#endif // SDL_TIMER_HAIKU diff --git a/contrib/SDL-3.2.8/src/timer/n3ds/SDL_systimer.c b/contrib/SDL-3.2.8/src/timer/n3ds/SDL_systimer.c new file mode 100644 index 0000000..2e1881b --- /dev/null +++ b/contrib/SDL-3.2.8/src/timer/n3ds/SDL_systimer.c @@ -0,0 +1,43 @@ +/* + 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_TIMER_N3DS + +#include <3ds.h> + + +Uint64 SDL_GetPerformanceCounter(void) +{ + return svcGetSystemTick(); +} + +Uint64 SDL_GetPerformanceFrequency(void) +{ + return SYSCLOCK_ARM11; +} + +void SDL_SYS_DelayNS(Uint64 ns) +{ + svcSleepThread(ns); +} + +#endif // SDL_TIMER_N3DS diff --git a/contrib/SDL-3.2.8/src/timer/ps2/SDL_systimer.c b/contrib/SDL-3.2.8/src/timer/ps2/SDL_systimer.c new file mode 100644 index 0000000..6d4ef04 --- /dev/null +++ b/contrib/SDL-3.2.8/src/timer/ps2/SDL_systimer.c @@ -0,0 +1,50 @@ +/* + 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_TIMER_PS2 + +#include "../SDL_timer_c.h" +#include +#include +#include +#include + + +Uint64 SDL_GetPerformanceCounter(void) +{ + return GetTimerSystemTime(); +} + +Uint64 SDL_GetPerformanceFrequency(void) +{ + return kBUSCLK; +} + +void SDL_SYS_DelayNS(Uint64 ns) +{ + struct timespec tv; + tv.tv_sec = (ns / SDL_NS_PER_SECOND); + tv.tv_nsec = (ns % SDL_NS_PER_SECOND); + nanosleep(&tv, NULL); +} + +#endif // SDL_TIMER_PS2 diff --git a/contrib/SDL-3.2.8/src/timer/psp/SDL_systimer.c b/contrib/SDL-3.2.8/src/timer/psp/SDL_systimer.c new file mode 100644 index 0000000..0a8fdc8 --- /dev/null +++ b/contrib/SDL-3.2.8/src/timer/psp/SDL_systimer.c @@ -0,0 +1,54 @@ +/* + 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_TIMER_PSP + +#include "../SDL_timer_c.h" +#include +#include +#include +#include +#include + + +Uint64 SDL_GetPerformanceCounter(void) +{ + Uint64 ticks; + sceRtcGetCurrentTick(&ticks); + return ticks; +} + +Uint64 SDL_GetPerformanceFrequency(void) +{ + return sceRtcGetTickResolution(); +} + +void SDL_SYS_DelayNS(Uint64 ns) +{ + const Uint64 max_delay = 0xffffffffLL * SDL_NS_PER_US; + if (ns > max_delay) { + ns = max_delay; + } + sceKernelDelayThreadCB((SceUInt)SDL_NS_TO_US(ns)); +} + +#endif // SDL_TIMER_PSP diff --git a/contrib/SDL-3.2.8/src/timer/unix/SDL_systimer.c b/contrib/SDL-3.2.8/src/timer/unix/SDL_systimer.c new file mode 100644 index 0000000..0f96319 --- /dev/null +++ b/contrib/SDL-3.2.8/src/timer/unix/SDL_systimer.c @@ -0,0 +1,188 @@ +/* + 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_TIMER_UNIX + +#include +#include +#include +#include + +#include "../SDL_timer_c.h" + +#ifdef SDL_PLATFORM_EMSCRIPTEN +#include +#endif + +/* The clock_gettime provides monotonous time, so we should use it if + it's available. The clock_gettime function is behind ifdef + for __USE_POSIX199309 + Tommi Kyntola (tommi.kyntola@ray.fi) 27/09/2005 +*/ +/* Reworked monotonic clock to not assume the current system has one + as not all linux kernels provide a monotonic clock (yeah recent ones + probably do) + Also added macOS Monotonic clock support + Based on work in https://github.com/ThomasHabets/monotonic_clock + */ +#if defined(HAVE_NANOSLEEP) || defined(HAVE_CLOCK_GETTIME) +#include +#endif +#ifdef SDL_PLATFORM_APPLE +#include +#endif + +// Use CLOCK_MONOTONIC_RAW, if available, which is not subject to adjustment by NTP +#ifdef HAVE_CLOCK_GETTIME +#ifdef CLOCK_MONOTONIC_RAW +#define SDL_MONOTONIC_CLOCK CLOCK_MONOTONIC_RAW +#else +#define SDL_MONOTONIC_CLOCK CLOCK_MONOTONIC +#endif +#endif + +// The first ticks value of the application +#if !defined(HAVE_CLOCK_GETTIME) && defined(SDL_PLATFORM_APPLE) +mach_timebase_info_data_t mach_base_info; +#endif +static bool checked_monotonic_time = false; +static bool has_monotonic_time = false; + +static void CheckMonotonicTime(void) +{ +#ifdef HAVE_CLOCK_GETTIME + struct timespec value; + if (clock_gettime(SDL_MONOTONIC_CLOCK, &value) == 0) { + has_monotonic_time = true; + } +#elif defined(SDL_PLATFORM_APPLE) + if (mach_timebase_info(&mach_base_info) == 0) { + has_monotonic_time = true; + } +#endif + checked_monotonic_time = true; +} + +Uint64 SDL_GetPerformanceCounter(void) +{ + Uint64 ticks; + + if (!checked_monotonic_time) { + CheckMonotonicTime(); + } + + if (has_monotonic_time) { +#ifdef HAVE_CLOCK_GETTIME + struct timespec now; + + clock_gettime(SDL_MONOTONIC_CLOCK, &now); + ticks = now.tv_sec; + ticks *= SDL_NS_PER_SECOND; + ticks += now.tv_nsec; +#elif defined(SDL_PLATFORM_APPLE) + ticks = mach_absolute_time(); +#else + SDL_assert(false); + ticks = 0; +#endif + } else { + struct timeval now; + + gettimeofday(&now, NULL); + ticks = now.tv_sec; + ticks *= SDL_US_PER_SECOND; + ticks += now.tv_usec; + } + return ticks; +} + +Uint64 SDL_GetPerformanceFrequency(void) +{ + if (!checked_monotonic_time) { + CheckMonotonicTime(); + } + + if (has_monotonic_time) { +#ifdef HAVE_CLOCK_GETTIME + return SDL_NS_PER_SECOND; +#elif defined(SDL_PLATFORM_APPLE) + Uint64 freq = mach_base_info.denom; + freq *= SDL_NS_PER_SECOND; + freq /= mach_base_info.numer; + return freq; +#endif + } + + return SDL_US_PER_SECOND; +} + +void SDL_SYS_DelayNS(Uint64 ns) +{ + int was_error; + +#ifdef HAVE_NANOSLEEP + struct timespec tv, remaining; +#else + struct timeval tv; + Uint64 then, now, elapsed; +#endif + +#ifdef SDL_PLATFORM_EMSCRIPTEN + if (emscripten_has_asyncify() && SDL_GetHintBoolean(SDL_HINT_EMSCRIPTEN_ASYNCIFY, true)) { + // pseudo-synchronous pause, used directly or through e.g. SDL_WaitEvent + emscripten_sleep(ns / SDL_NS_PER_MS); + return; + } +#endif + + // Set the timeout interval +#ifdef HAVE_NANOSLEEP + remaining.tv_sec = (time_t)(ns / SDL_NS_PER_SECOND); + remaining.tv_nsec = (long)(ns % SDL_NS_PER_SECOND); +#else + then = SDL_GetTicksNS(); +#endif + do { + errno = 0; + +#ifdef HAVE_NANOSLEEP + tv.tv_sec = remaining.tv_sec; + tv.tv_nsec = remaining.tv_nsec; + was_error = nanosleep(&tv, &remaining); +#else + // Calculate the time interval left (in case of interrupt) + now = SDL_GetTicksNS(); + elapsed = (now - then); + then = now; + if (elapsed >= ns) { + break; + } + ns -= elapsed; + tv.tv_sec = (ns / SDL_NS_PER_SECOND); + tv.tv_usec = SDL_NS_TO_US(ns % SDL_NS_PER_SECOND); + + was_error = select(0, NULL, NULL, NULL, &tv); +#endif // HAVE_NANOSLEEP + } while (was_error && (errno == EINTR)); +} + +#endif // SDL_TIMER_UNIX diff --git a/contrib/SDL-3.2.8/src/timer/vita/SDL_systimer.c b/contrib/SDL-3.2.8/src/timer/vita/SDL_systimer.c new file mode 100644 index 0000000..811a4bb --- /dev/null +++ b/contrib/SDL-3.2.8/src/timer/vita/SDL_systimer.c @@ -0,0 +1,51 @@ +/* + 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_TIMER_VITA + +#include "../SDL_timer_c.h" +#include +#include +#include +#include + + +Uint64 SDL_GetPerformanceCounter(void) +{ + return sceKernelGetProcessTimeWide(); +} + +Uint64 SDL_GetPerformanceFrequency(void) +{ + return SDL_US_PER_SECOND; +} + +void SDL_SYS_DelayNS(Uint64 ns) +{ + const Uint64 max_delay = 0xffffffffLL * SDL_NS_PER_US; + if (ns > max_delay) { + ns = max_delay; + } + sceKernelDelayThreadCB((SceUInt)SDL_NS_TO_US(ns)); +} + +#endif // SDL_TIMER_VITA diff --git a/contrib/SDL-3.2.8/src/timer/windows/SDL_systimer.c b/contrib/SDL-3.2.8/src/timer/windows/SDL_systimer.c new file mode 100644 index 0000000..f6f4b15 --- /dev/null +++ b/contrib/SDL-3.2.8/src/timer/windows/SDL_systimer.c @@ -0,0 +1,133 @@ +/* + 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_TIMER_WINDOWS + +#include "../../core/windows/SDL_windows.h" + +/* CREATE_WAITABLE_TIMER_HIGH_RESOLUTION flag was added in Windows 10 version 1803. */ +#ifndef CREATE_WAITABLE_TIMER_HIGH_RESOLUTION +#define CREATE_WAITABLE_TIMER_HIGH_RESOLUTION 0x2 +#endif + +typedef HANDLE (WINAPI *CreateWaitableTimerExW_t)(LPSECURITY_ATTRIBUTES lpTimerAttributes, LPCWSTR lpTimerName, DWORD dwFlags, DWORD dwDesiredAccess); +static CreateWaitableTimerExW_t pCreateWaitableTimerExW; + +typedef BOOL (WINAPI *SetWaitableTimerEx_t)(HANDLE hTimer, const LARGE_INTEGER *lpDueTime, LONG lPeriod, PTIMERAPCROUTINE pfnCompletionRoutine, LPVOID lpArgToCompletionRoutine, PREASON_CONTEXT WakeContext, ULONG TolerableDelay); +static SetWaitableTimerEx_t pSetWaitableTimerEx; + +static void SDL_CleanupWaitableHandle(void *handle) +{ + CloseHandle(handle); +} + +static HANDLE SDL_GetWaitableTimer(void) +{ + static SDL_TLSID TLS_timer_handle; + HANDLE timer; + + if (!pCreateWaitableTimerExW || !pSetWaitableTimerEx) { + static bool initialized; + + if (!initialized) { + HMODULE module = GetModuleHandle(TEXT("kernel32.dll")); + if (module) { + pCreateWaitableTimerExW = (CreateWaitableTimerExW_t)GetProcAddress(module, "CreateWaitableTimerExW"); + pSetWaitableTimerEx = (SetWaitableTimerEx_t)GetProcAddress(module, "SetWaitableTimerEx"); + } + initialized = true; + } + + if (!pCreateWaitableTimerExW || !pSetWaitableTimerEx) { + return NULL; + } + } + + timer = SDL_GetTLS(&TLS_timer_handle); + if (!timer) { + timer = pCreateWaitableTimerExW(NULL, NULL, CREATE_WAITABLE_TIMER_HIGH_RESOLUTION, TIMER_ALL_ACCESS); + if (timer) { + SDL_SetTLS(&TLS_timer_handle, timer, SDL_CleanupWaitableHandle); + } + } + return timer; +} + +static HANDLE SDL_GetWaitableEvent(void) +{ + static SDL_TLSID TLS_event_handle; + HANDLE event; + + event = SDL_GetTLS(&TLS_event_handle); + if (!event) { + event = CreateEvent(NULL, FALSE, FALSE, NULL); + if (event) { + SDL_SetTLS(&TLS_event_handle, event, SDL_CleanupWaitableHandle); + } + } + return event; +} + +Uint64 SDL_GetPerformanceCounter(void) +{ + LARGE_INTEGER counter; + const BOOL rc = QueryPerformanceCounter(&counter); + SDL_assert(rc != 0); // this should _never_ fail if you're on XP or later. + return (Uint64)counter.QuadPart; +} + +Uint64 SDL_GetPerformanceFrequency(void) +{ + LARGE_INTEGER frequency; + const BOOL rc = QueryPerformanceFrequency(&frequency); + SDL_assert(rc != 0); // this should _never_ fail if you're on XP or later. + return (Uint64)frequency.QuadPart; +} + +void SDL_SYS_DelayNS(Uint64 ns) +{ + HANDLE timer = SDL_GetWaitableTimer(); + if (timer) { + LARGE_INTEGER due_time; + due_time.QuadPart = -((LONGLONG)ns / 100); + if (pSetWaitableTimerEx(timer, &due_time, 0, NULL, NULL, NULL, 0)) { + WaitForSingleObject(timer, INFINITE); + } + return; + } + + const Uint64 max_delay = 0xffffffffLL * SDL_NS_PER_MS; + if (ns > max_delay) { + ns = max_delay; + } + const DWORD delay = (DWORD)SDL_NS_TO_MS(ns); + + HANDLE event = SDL_GetWaitableEvent(); + if (event) { + WaitForSingleObjectEx(event, delay, FALSE); + return; + } + + Sleep(delay); +} + +#endif // SDL_TIMER_WINDOWS -- cgit v1.2.3