diff --git a/build-scripts/SDL_migration.cocci b/build-scripts/SDL_migration.cocci index 8b4e12d201..41d178c8ae 100644 --- a/build-scripts/SDL_migration.cocci +++ b/build-scripts/SDL_migration.cocci @@ -2907,12 +2907,37 @@ expression e1, e2, e3, e4; @@ @@ - SDL_AtomicCAS -+ SDL_AtomicCompareAndSwap ++ SDL_CompareAndSwapAtomicInt + (...) +@@ +@@ +- SDL_AtomicSet ++ SDL_SetAtomicInt + (...) +@@ +@@ +- SDL_AtomicGet ++ SDL_GetAtomicInt + (...) +@@ +@@ +- SDL_AtomicAdd ++ SDL_AddAtomicInt (...) @@ @@ - SDL_AtomicCASPtr -+ SDL_AtomicCompareAndSwapPointer ++ SDL_CompareAndSwapAtomicPointer + (...) +@@ +@@ +- SDL_AtomicSetPtr ++ SDL_SetAtomicPointer + (...) +@@ +@@ +- SDL_AtomicGetPtr ++ SDL_GetAtomicPointer (...) @@ @@ @@ -3586,16 +3611,6 @@ typedef SDL_JoystickGUID, SDL_GUID; + SDL_HINT_MOUSE_EMULATE_WARP_WITH_RELATIVE @@ @@ -- SDL_AtomicSetPtr -+ SDL_AtomicSetPointer - (...) -@@ -@@ -- SDL_AtomicGetPtr -+ SDL_AtomicGetPointer - (...) -@@ -@@ - SDL_DelEventWatch + SDL_RemoveEventWatch (...) diff --git a/docs/README-migration.md b/docs/README-migration.md index b479011c35..ed52ec01c3 100644 --- a/docs/README-migration.md +++ b/docs/README-migration.md @@ -86,11 +86,14 @@ The following structures have been renamed: - SDL_atomic_t => SDL_AtomicInt The following functions have been renamed: -* SDL_AtomicCAS() => SDL_AtomicCompareAndSwap() -* SDL_AtomicCASPtr() => SDL_AtomicCompareAndSwapPointer() -* SDL_AtomicGetPtr() => SDL_AtomicGetPointer() +* SDL_AtomicAdd() => SDL_AddAtomicInt() +* SDL_AtomicCAS() => SDL_CompareAndSwapAtomicInt() +* SDL_AtomicCASPtr() => SDL_CompareAndSwapAtomicPointer() +* SDL_AtomicGet() => SDL_GetAtomicInt() +* SDL_AtomicGetPtr() => SDL_GetAtomicPointer() * SDL_AtomicLock() => SDL_LockSpinlock() -* SDL_AtomicSetPtr() => SDL_AtomicSetPointer() +* SDL_AtomicSet() => SDL_SetAtomicInt() +* SDL_AtomicSetPtr() => SDL_SetAtomicPointer() * SDL_AtomicTryLock() => SDL_TryLockSpinlock() * SDL_AtomicUnlock() => SDL_UnlockSpinlock() diff --git a/include/SDL3/SDL_atomic.h b/include/SDL3/SDL_atomic.h index f159bcd275..f76bcbb43e 100644 --- a/include/SDL3/SDL_atomic.h +++ b/include/SDL3/SDL_atomic.h @@ -303,9 +303,9 @@ typedef void (*SDL_KernelMemoryBarrierFunc)(); * A type representing an atomic integer value. * * This can be used to manage a value that is synchronized across multiple - * CPUs without a race condition; when an app sets a value with SDL_AtomicSet + * CPUs without a race condition; when an app sets a value with SDL_SetAtomicInt * all other threads, regardless of the CPU it is running on, will see that - * value when retrieved with SDL_AtomicGet, regardless of CPU caches, etc. + * value when retrieved with SDL_GetAtomicInt, regardless of CPU caches, etc. * * This is also useful for atomic compare-and-swap operations: a thread can * change the value as long as its current value matches expectations. When @@ -320,10 +320,10 @@ typedef void (*SDL_KernelMemoryBarrierFunc)(); * * \since This struct is available since SDL 3.0.0. * - * \sa SDL_AtomicCompareAndSwap - * \sa SDL_AtomicGet - * \sa SDL_AtomicSet - * \sa SDL_AtomicAdd + * \sa SDL_CompareAndSwapAtomicInt + * \sa SDL_GetAtomicInt + * \sa SDL_SetAtomicInt + * \sa SDL_AddAtomicInt */ typedef struct SDL_AtomicInt { int value; } SDL_AtomicInt; @@ -342,9 +342,9 @@ typedef struct SDL_AtomicInt { int value; } SDL_AtomicInt; * * \since This function is available since SDL 3.0.0. * - * \sa SDL_AtomicCompareAndSwapPointer + * \sa SDL_CompareAndSwapAtomicPointer */ -extern SDL_DECLSPEC SDL_bool SDLCALL SDL_AtomicCompareAndSwap(SDL_AtomicInt *a, int oldval, int newval); +extern SDL_DECLSPEC SDL_bool SDLCALL SDL_CompareAndSwapAtomicInt(SDL_AtomicInt *a, int oldval, int newval); /** * Set an atomic variable to a value. @@ -362,9 +362,9 @@ extern SDL_DECLSPEC SDL_bool SDLCALL SDL_AtomicCompareAndSwap(SDL_AtomicInt *a, * * \since This function is available since SDL 3.0.0. * - * \sa SDL_AtomicGet + * \sa SDL_GetAtomicInt */ -extern SDL_DECLSPEC int SDLCALL SDL_AtomicSet(SDL_AtomicInt *a, int v); +extern SDL_DECLSPEC int SDLCALL SDL_SetAtomicInt(SDL_AtomicInt *a, int v); /** * Get the value of an atomic variable. @@ -379,9 +379,9 @@ extern SDL_DECLSPEC int SDLCALL SDL_AtomicSet(SDL_AtomicInt *a, int v); * * \since This function is available since SDL 3.0.0. * - * \sa SDL_AtomicSet + * \sa SDL_SetAtomicInt */ -extern SDL_DECLSPEC int SDLCALL SDL_AtomicGet(SDL_AtomicInt *a); +extern SDL_DECLSPEC int SDLCALL SDL_GetAtomicInt(SDL_AtomicInt *a); /** * Add to an atomic variable. @@ -402,7 +402,7 @@ extern SDL_DECLSPEC int SDLCALL SDL_AtomicGet(SDL_AtomicInt *a); * \sa SDL_AtomicDecRef * \sa SDL_AtomicIncRef */ -extern SDL_DECLSPEC int SDLCALL SDL_AtomicAdd(SDL_AtomicInt *a, int v); +extern SDL_DECLSPEC int SDLCALL SDL_AddAtomicInt(SDL_AtomicInt *a, int v); #ifndef SDL_AtomicIncRef @@ -418,7 +418,7 @@ extern SDL_DECLSPEC int SDLCALL SDL_AtomicAdd(SDL_AtomicInt *a, int v); * * \sa SDL_AtomicDecRef */ -#define SDL_AtomicIncRef(a) SDL_AtomicAdd(a, 1) +#define SDL_AtomicIncRef(a) SDL_AddAtomicInt(a, 1) #endif #ifndef SDL_AtomicDecRef @@ -436,7 +436,7 @@ extern SDL_DECLSPEC int SDLCALL SDL_AtomicAdd(SDL_AtomicInt *a, int v); * * \sa SDL_AtomicIncRef */ -#define SDL_AtomicDecRef(a) (SDL_AtomicAdd(a, -1) == 1) +#define SDL_AtomicDecRef(a) (SDL_AddAtomicInt(a, -1) == 1) #endif /** @@ -454,11 +454,11 @@ extern SDL_DECLSPEC int SDLCALL SDL_AtomicAdd(SDL_AtomicInt *a, int v); * * \since This function is available since SDL 3.0.0. * - * \sa SDL_AtomicCompareAndSwap - * \sa SDL_AtomicGetPointer - * \sa SDL_AtomicSetPointer + * \sa SDL_CompareAndSwapAtomicInt + * \sa SDL_GetAtomicPointer + * \sa SDL_SetAtomicPointer */ -extern SDL_DECLSPEC SDL_bool SDLCALL SDL_AtomicCompareAndSwapPointer(void **a, void *oldval, void *newval); +extern SDL_DECLSPEC SDL_bool SDLCALL SDL_CompareAndSwapAtomicPointer(void **a, void *oldval, void *newval); /** * Set a pointer to a value atomically. @@ -474,10 +474,10 @@ extern SDL_DECLSPEC SDL_bool SDLCALL SDL_AtomicCompareAndSwapPointer(void **a, v * * \since This function is available since SDL 3.0.0. * - * \sa SDL_AtomicCompareAndSwapPointer - * \sa SDL_AtomicGetPointer + * \sa SDL_CompareAndSwapAtomicPointer + * \sa SDL_GetAtomicPointer */ -extern SDL_DECLSPEC void * SDLCALL SDL_AtomicSetPointer(void **a, void *v); +extern SDL_DECLSPEC void * SDLCALL SDL_SetAtomicPointer(void **a, void *v); /** * Get the value of a pointer atomically. @@ -492,10 +492,10 @@ extern SDL_DECLSPEC void * SDLCALL SDL_AtomicSetPointer(void **a, void *v); * * \since This function is available since SDL 3.0.0. * - * \sa SDL_AtomicCompareAndSwapPointer - * \sa SDL_AtomicSetPointer + * \sa SDL_CompareAndSwapAtomicPointer + * \sa SDL_SetAtomicPointer */ -extern SDL_DECLSPEC void * SDLCALL SDL_AtomicGetPointer(void **a); +extern SDL_DECLSPEC void * SDLCALL SDL_GetAtomicPointer(void **a); /* Ends C function definitions when using C++ */ #ifdef __cplusplus diff --git a/include/SDL3/SDL_oldnames.h b/include/SDL3/SDL_oldnames.h index 7638922f57..3af24cc3ee 100644 --- a/include/SDL3/SDL_oldnames.h +++ b/include/SDL3/SDL_oldnames.h @@ -38,11 +38,14 @@ #ifdef SDL_ENABLE_OLD_NAMES /* ##SDL_atomic.h */ -#define SDL_AtomicCAS SDL_AtomicCompareAndSwap -#define SDL_AtomicCASPtr SDL_AtomicCompareAndSwapPointer -#define SDL_AtomicGetPtr SDL_AtomicGetPointer +#define SDL_AtomicAdd SDL_AddAtomicInt +#define SDL_AtomicCAS SDL_CompareAndSwapAtomicInt +#define SDL_AtomicCASPtr SDL_CompareAndSwapAtomicPointer +#define SDL_AtomicGet SDL_GetAtomicInt +#define SDL_AtomicGetPtr SDL_GetAtomicPointer #define SDL_AtomicLock SDL_LockSpinlock -#define SDL_AtomicSetPtr SDL_AtomicSetPointer +#define SDL_AtomicSet SDL_SetAtomicInt +#define SDL_AtomicSetPtr SDL_SetAtomicPointer #define SDL_AtomicTryLock SDL_TryLockSpinlock #define SDL_AtomicUnlock SDL_UnlockSpinlock #define SDL_atomic_t SDL_AtomicInt @@ -668,11 +671,14 @@ #elif !defined(SDL_DISABLE_OLD_NAMES) /* ##SDL_atomic.h */ -#define SDL_AtomicCAS SDL_AtomicCAS_renamed_SDL_AtomicCompareAndSwap -#define SDL_AtomicCASPtr SDL_AtomicCASPtr_renamed_SDL_AtomicCompareAndSwapPointer -#define SDL_AtomicGetPtr SDL_AtomicGetPtr_renamed_SDL_AtomicGetPointer +#define SDL_AtomicAdd SDL_AtomicAdd_renamed_SDL_AddAtomicInt +#define SDL_AtomicCAS SDL_AtomicCAS_renamed_SDL_CompareAndSwapAtomicInt +#define SDL_AtomicCASPtr SDL_AtomicCASPtr_renamed_SDL_CompareAndSwapAtomicPointer +#define SDL_AtomicGet SDL_AtomicGet_renamed_SDL_GetAtomicInt +#define SDL_AtomicGetPtr SDL_AtomicGetPtr_renamed_SDL_GetAtomicPointer #define SDL_AtomicLock SDL_AtomicLock_renamed_SDL_LockSpinlock -#define SDL_AtomicSetPtr SDL_AtomicSetPtr_renamed_SDL_AtomicSetPointer +#define SDL_AtomicSet SDL_AtomicSet_renamed_SDL_SetAtomicInt +#define SDL_AtomicSetPtr SDL_AtomicSetPtr_renamed_SDL_SetAtomicPointer #define SDL_AtomicTryLock SDL_AtomicTryLock_renamed_SDL_TryLockSpinlock #define SDL_AtomicUnlock SDL_AtomicUnlock_renamed_SDL_UnlockSpinlock #define SDL_atomic_t SDL_atomic_t_renamed_SDL_AtomicInt diff --git a/src/SDL_log.c b/src/SDL_log.c index aec4d6f00e..5abaf86c7f 100644 --- a/src/SDL_log.c +++ b/src/SDL_log.c @@ -165,7 +165,7 @@ void SDL_QuitLog(void) static void SDL_CheckInitLog(void) { - int status = SDL_AtomicGet(&SDL_log_init.status); + int status = SDL_GetAtomicInt(&SDL_log_init.status); if (status == SDL_INIT_STATUS_INITIALIZED || (status == SDL_INIT_STATUS_INITIALIZING && SDL_log_init.thread == SDL_GetCurrentThreadID())) { return; diff --git a/src/SDL_utils.c b/src/SDL_utils.c index c120a38eda..1263fea3b0 100644 --- a/src/SDL_utils.c +++ b/src/SDL_utils.c @@ -123,8 +123,8 @@ bool SDL_endswith(const char *string, const char *suffix) bool SDL_ShouldInit(SDL_InitState *state) { - while (SDL_AtomicGet(&state->status) != SDL_INIT_STATUS_INITIALIZED) { - if (SDL_AtomicCompareAndSwap(&state->status, SDL_INIT_STATUS_UNINITIALIZED, SDL_INIT_STATUS_INITIALIZING)) { + while (SDL_GetAtomicInt(&state->status) != SDL_INIT_STATUS_INITIALIZED) { + if (SDL_CompareAndSwapAtomicInt(&state->status, SDL_INIT_STATUS_UNINITIALIZED, SDL_INIT_STATUS_INITIALIZING)) { state->thread = SDL_GetCurrentThreadID(); return true; } @@ -137,7 +137,7 @@ bool SDL_ShouldInit(SDL_InitState *state) bool SDL_ShouldQuit(SDL_InitState *state) { - if (SDL_AtomicCompareAndSwap(&state->status, SDL_INIT_STATUS_INITIALIZED, SDL_INIT_STATUS_UNINITIALIZING)) { + if (SDL_CompareAndSwapAtomicInt(&state->status, SDL_INIT_STATUS_INITIALIZED, SDL_INIT_STATUS_UNINITIALIZING)) { state->thread = SDL_GetCurrentThreadID(); return true; } @@ -149,9 +149,9 @@ void SDL_SetInitialized(SDL_InitState *state, bool initialized) SDL_assert(state->thread == SDL_GetCurrentThreadID()); if (initialized) { - SDL_AtomicSet(&state->status, SDL_INIT_STATUS_INITIALIZED); + SDL_SetAtomicInt(&state->status, SDL_INIT_STATUS_INITIALIZED); } else { - SDL_AtomicSet(&state->status, SDL_INIT_STATUS_UNINITIALIZED); + SDL_SetAtomicInt(&state->status, SDL_INIT_STATUS_UNINITIALIZED); } } diff --git a/src/atomic/SDL_atomic.c b/src/atomic/SDL_atomic.c index 2816d6d4ec..1eb1a90ca5 100644 --- a/src/atomic/SDL_atomic.c +++ b/src/atomic/SDL_atomic.c @@ -122,7 +122,7 @@ static SDL_INLINE void leaveLock(void *a) } #endif -SDL_bool SDL_AtomicCompareAndSwap(SDL_AtomicInt *a, int oldval, int newval) +SDL_bool SDL_CompareAndSwapAtomicInt(SDL_AtomicInt *a, int oldval, int newval) { #ifdef HAVE_MSC_ATOMICS SDL_COMPILE_TIME_ASSERT(atomic_cas, sizeof(long) == sizeof(a->value)); @@ -151,7 +151,7 @@ SDL_bool SDL_AtomicCompareAndSwap(SDL_AtomicInt *a, int oldval, int newval) #endif } -SDL_bool SDL_AtomicCompareAndSwapPointer(void **a, void *oldval, void *newval) +SDL_bool SDL_CompareAndSwapAtomicPointer(void **a, void *oldval, void *newval) { #ifdef HAVE_MSC_ATOMICS return _InterlockedCompareExchangePointer(a, newval, oldval) == oldval; @@ -181,7 +181,7 @@ SDL_bool SDL_AtomicCompareAndSwapPointer(void **a, void *oldval, void *newval) #endif } -int SDL_AtomicSet(SDL_AtomicInt *a, int v) +int SDL_SetAtomicInt(SDL_AtomicInt *a, int v) { #ifdef HAVE_MSC_ATOMICS SDL_COMPILE_TIME_ASSERT(atomic_set, sizeof(long) == sizeof(a->value)); @@ -196,12 +196,12 @@ int SDL_AtomicSet(SDL_AtomicInt *a, int v) int value; do { value = a->value; - } while (!SDL_AtomicCompareAndSwap(a, value, v)); + } while (!SDL_CompareAndSwapAtomicInt(a, value, v)); return value; #endif } -void *SDL_AtomicSetPointer(void **a, void *v) +void *SDL_SetAtomicPointer(void **a, void *v) { #ifdef HAVE_MSC_ATOMICS return _InterlockedExchangePointer(a, v); @@ -215,12 +215,12 @@ void *SDL_AtomicSetPointer(void **a, void *v) void *value; do { value = *a; - } while (!SDL_AtomicCompareAndSwapPointer(a, value, v)); + } while (!SDL_CompareAndSwapAtomicPointer(a, value, v)); return value; #endif } -int SDL_AtomicAdd(SDL_AtomicInt *a, int v) +int SDL_AddAtomicInt(SDL_AtomicInt *a, int v) { #ifdef HAVE_MSC_ATOMICS SDL_COMPILE_TIME_ASSERT(atomic_add, sizeof(long) == sizeof(a->value)); @@ -238,12 +238,12 @@ int SDL_AtomicAdd(SDL_AtomicInt *a, int v) int value; do { value = a->value; - } while (!SDL_AtomicCompareAndSwap(a, value, (value + v))); + } while (!SDL_CompareAndSwapAtomicInt(a, value, (value + v))); return value; #endif } -int SDL_AtomicGet(SDL_AtomicInt *a) +int SDL_GetAtomicInt(SDL_AtomicInt *a) { #ifdef HAVE_ATOMIC_LOAD_N return __atomic_load_n(&a->value, __ATOMIC_SEQ_CST); @@ -262,12 +262,12 @@ int SDL_AtomicGet(SDL_AtomicInt *a) int value; do { value = a->value; - } while (!SDL_AtomicCompareAndSwap(a, value, value)); + } while (!SDL_CompareAndSwapAtomicInt(a, value, value)); return value; #endif } -void *SDL_AtomicGetPointer(void **a) +void *SDL_GetAtomicPointer(void **a) { #ifdef HAVE_ATOMIC_LOAD_N return __atomic_load_n(a, __ATOMIC_SEQ_CST); @@ -281,7 +281,7 @@ void *SDL_AtomicGetPointer(void **a) void *value; do { value = *a; - } while (!SDL_AtomicCompareAndSwapPointer(a, value, value)); + } while (!SDL_CompareAndSwapAtomicPointer(a, value, value)); return value; #endif } diff --git a/src/audio/SDL_audio.c b/src/audio/SDL_audio.c index 409e74fca0..ba37fcb17b 100644 --- a/src/audio/SDL_audio.c +++ b/src/audio/SDL_audio.c @@ -280,7 +280,7 @@ bool SDL_AudioSpecsEqual(const SDL_AudioSpec *a, const SDL_AudioSpec *b, const i // consumed and apps relying on audio callbacks don't stop making progress. static bool ZombieWaitDevice(SDL_AudioDevice *device) { - if (!SDL_AtomicGet(&device->shutdown)) { + if (!SDL_GetAtomicInt(&device->shutdown)) { const int frames = device->buffer_size / SDL_AUDIO_FRAMESIZE(device->spec); SDL_Delay((frames * 1000) / device->spec.freq); } @@ -390,7 +390,7 @@ static SDL_LogicalAudioDevice *ObtainLogicalAudioDevice(SDL_AudioDeviceID devid, // to make sure the correct physical device gets locked, in case we're in a race with the default changing. while (true) { SDL_LockMutex(device->lock); - SDL_AudioDevice *recheck_device = (SDL_AudioDevice *) SDL_AtomicGetPointer((void **) &logdev->physical_device); + SDL_AudioDevice *recheck_device = (SDL_AudioDevice *) SDL_GetAtomicPointer((void **) &logdev->physical_device); if (device == recheck_device) { break; } @@ -559,7 +559,7 @@ void UnrefPhysicalAudioDevice(SDL_AudioDevice *device) // take it out of the device list. SDL_LockRWLockForWriting(current_audio.device_hash_lock); if (SDL_RemoveFromHashTable(current_audio.device_hash, (const void *) (uintptr_t) device->instance_id)) { - SDL_AtomicAdd(device->recording ? ¤t_audio.recording_device_count : ¤t_audio.playback_device_count, -1); + SDL_AddAtomicInt(device->recording ? ¤t_audio.recording_device_count : ¤t_audio.playback_device_count, -1); } SDL_UnlockRWLock(current_audio.device_hash_lock); DestroyPhysicalAudioDevice(device); // ...and nuke it. @@ -576,7 +576,7 @@ static SDL_AudioDevice *CreatePhysicalAudioDevice(const char *name, bool recordi SDL_assert(name != NULL); SDL_LockRWLockForReading(current_audio.device_hash_lock); - const int shutting_down = SDL_AtomicGet(¤t_audio.shutting_down); + const int shutting_down = SDL_GetAtomicInt(¤t_audio.shutting_down); SDL_UnlockRWLock(current_audio.device_hash_lock); if (shutting_down) { return NULL; // we're shutting down, don't add any devices that are hotplugged at the last possible moment. @@ -608,8 +608,8 @@ static SDL_AudioDevice *CreatePhysicalAudioDevice(const char *name, bool recordi return NULL; } - SDL_AtomicSet(&device->shutdown, 0); - SDL_AtomicSet(&device->zombie, 0); + SDL_SetAtomicInt(&device->shutdown, 0); + SDL_SetAtomicInt(&device->zombie, 0); device->recording = recording; SDL_copyp(&device->spec, spec); SDL_copyp(&device->default_spec, spec); @@ -621,7 +621,7 @@ static SDL_AudioDevice *CreatePhysicalAudioDevice(const char *name, bool recordi SDL_LockRWLockForWriting(current_audio.device_hash_lock); if (SDL_InsertIntoHashTable(current_audio.device_hash, (const void *) (uintptr_t) device->instance_id, device)) { - SDL_AtomicAdd(device_count, 1); + SDL_AddAtomicInt(device_count, 1); } else { SDL_DestroyCondition(device->close_cond); SDL_DestroyMutex(device->lock); @@ -711,7 +711,7 @@ void SDL_AudioDeviceDisconnected(SDL_AudioDevice *device) const bool is_default_device = ((devid == current_audio.default_playback_device_id) || (devid == current_audio.default_recording_device_id)); SDL_UnlockRWLock(current_audio.device_hash_lock); - const bool first_disconnect = SDL_AtomicCompareAndSwap(&device->zombie, 0, 1); + const bool first_disconnect = SDL_CompareAndSwapAtomicInt(&device->zombie, 0, 1); if (first_disconnect) { // if already disconnected this device, don't do it twice. // Swap in "Zombie" versions of the usual platform interfaces, so the device will keep // making progress until the app closes it. Otherwise, streams might continue to @@ -886,7 +886,7 @@ bool SDL_InitAudio(const char *driver_name) } // make sure device IDs start at 2 (because of SDL2 legacy interface), but don't reset the counter on each init, in case the app is holding an old device ID somewhere. - SDL_AtomicCompareAndSwap(&last_device_instance_id, 0, 2); + SDL_CompareAndSwapAtomicInt(&last_device_instance_id, 0, 2); SDL_ChooseAudioConverters(); SDL_SetupAudioResampler(); @@ -1031,13 +1031,13 @@ void SDL_QuitAudio(void) } SDL_LockRWLockForWriting(current_audio.device_hash_lock); - SDL_AtomicSet(¤t_audio.shutting_down, 1); + SDL_SetAtomicInt(¤t_audio.shutting_down, 1); SDL_HashTable *device_hash = current_audio.device_hash; current_audio.device_hash = NULL; SDL_PendingAudioDeviceEvent *pending_events = current_audio.pending_events.next; current_audio.pending_events.next = NULL; - SDL_AtomicSet(¤t_audio.playback_device_count, 0); - SDL_AtomicSet(¤t_audio.recording_device_count, 0); + SDL_SetAtomicInt(¤t_audio.playback_device_count, 0); + SDL_SetAtomicInt(¤t_audio.recording_device_count, 0); SDL_UnlockRWLock(current_audio.device_hash_lock); SDL_PendingAudioDeviceEvent *pending_next = NULL; @@ -1094,7 +1094,7 @@ bool SDL_PlaybackAudioThreadIterate(SDL_AudioDevice *device) SDL_LockMutex(device->lock); - if (SDL_AtomicGet(&device->shutdown)) { + if (SDL_GetAtomicInt(&device->shutdown)) { SDL_UnlockMutex(device->lock); return false; // we're done, shut it down. } @@ -1118,7 +1118,7 @@ bool SDL_PlaybackAudioThreadIterate(SDL_AudioDevice *device) // We should have updated this elsewhere if the format changed! SDL_assert(SDL_AudioSpecsEqual(&stream->dst_spec, &device->spec, stream->dst_chmap, device->chmap)); - const int br = SDL_AtomicGet(&logdev->paused) ? 0 : SDL_GetAudioStreamDataAdjustGain(stream, device_buffer, buffer_size, logdev->gain); + const int br = SDL_GetAtomicInt(&logdev->paused) ? 0 : SDL_GetAudioStreamDataAdjustGain(stream, device_buffer, buffer_size, logdev->gain); if (br < 0) { // Probably OOM. Kill the audio device; the whole thing is likely dying soon anyhow. failed = true; SDL_memset(device_buffer, device->silence_value, buffer_size); // just supply silence to the device before we die. @@ -1139,7 +1139,7 @@ bool SDL_PlaybackAudioThreadIterate(SDL_AudioDevice *device) SDL_memset(final_mix_buffer, '\0', work_buffer_size); // start with silence. for (SDL_LogicalAudioDevice *logdev = device->logical_devices; logdev; logdev = logdev->next) { - if (SDL_AtomicGet(&logdev->paused)) { + if (SDL_GetAtomicInt(&logdev->paused)) { continue; // paused? Skip this logical device. } @@ -1202,7 +1202,7 @@ void SDL_PlaybackAudioThreadShutdown(SDL_AudioDevice *device) SDL_assert(!device->recording); const int frames = device->buffer_size / SDL_AUDIO_FRAMESIZE(device->spec); // Wait for the audio to drain if device didn't die. - if (!SDL_AtomicGet(&device->zombie)) { + if (!SDL_GetAtomicInt(&device->zombie)) { SDL_Delay(((frames * 1000) / device->spec.freq) * 2); } current_audio.impl.ThreadDeinit(device); @@ -1242,7 +1242,7 @@ bool SDL_RecordingAudioThreadIterate(SDL_AudioDevice *device) SDL_LockMutex(device->lock); - if (SDL_AtomicGet(&device->shutdown)) { + if (SDL_GetAtomicInt(&device->shutdown)) { SDL_UnlockMutex(device->lock); return false; // we're done, shut it down. } @@ -1258,7 +1258,7 @@ bool SDL_RecordingAudioThreadIterate(SDL_AudioDevice *device) failed = true; } else if (br > 0) { // queue the new data to each bound stream. for (SDL_LogicalAudioDevice *logdev = device->logical_devices; logdev; logdev = logdev->next) { - if (SDL_AtomicGet(&logdev->paused)) { + if (SDL_GetAtomicInt(&logdev->paused)) { continue; // paused? Skip this logical device. } @@ -1342,7 +1342,7 @@ static SDL_AudioDeviceID *GetAudioDevices(int *count, bool recording) if (SDL_GetCurrentAudioDriver()) { SDL_LockRWLockForReading(current_audio.device_hash_lock); { - num_devices = SDL_AtomicGet(recording ? ¤t_audio.recording_device_count : ¤t_audio.playback_device_count); + num_devices = SDL_GetAtomicInt(recording ? ¤t_audio.recording_device_count : ¤t_audio.playback_device_count); result = (SDL_AudioDeviceID *) SDL_malloc((num_devices + 1) * sizeof (SDL_AudioDeviceID)); if (result) { int devs_seen = 0; @@ -1490,7 +1490,7 @@ int *SDL_GetAudioDeviceChannelMap(SDL_AudioDeviceID devid, int *count) // BE CAREFUL WITH THIS. static void SerializePhysicalDeviceClose(SDL_AudioDevice *device) { - while (SDL_AtomicGet(&device->shutdown)) { + while (SDL_GetAtomicInt(&device->shutdown)) { SDL_WaitCondition(device->close_cond, device->lock); } } @@ -1500,7 +1500,7 @@ static void ClosePhysicalAudioDevice(SDL_AudioDevice *device) { SerializePhysicalDeviceClose(device); - SDL_AtomicSet(&device->shutdown, 1); + SDL_SetAtomicInt(&device->shutdown, 1); // YOU MUST PROTECT KEY POINTS WITH SerializePhysicalDeviceClose() WHILE THE THREAD JOINS SDL_UnlockMutex(device->lock); @@ -1517,7 +1517,7 @@ static void ClosePhysicalAudioDevice(SDL_AudioDevice *device) } SDL_LockMutex(device->lock); - SDL_AtomicSet(&device->shutdown, 0); // ready to go again. + SDL_SetAtomicInt(&device->shutdown, 0); // ready to go again. SDL_BroadcastCondition(device->close_cond); // release anyone waiting in SerializePhysicalDeviceClose; they'll still block until we release device->lock, though. SDL_aligned_free(device->work_buffer); @@ -1630,7 +1630,7 @@ static bool OpenPhysicalAudioDevice(SDL_AudioDevice *device, const SDL_AudioSpec } // Just pretend to open a zombie device. It can still collect logical devices on a default device under the assumption they will all migrate when the default device is officially changed. - if (SDL_AtomicGet(&device->zombie)) { + if (SDL_GetAtomicInt(&device->zombie)) { return true; // Braaaaaaaaains. } @@ -1719,7 +1719,7 @@ SDL_AudioDeviceID SDL_OpenAudioDevice(SDL_AudioDeviceID devid, const SDL_AudioSp if (device) { SDL_LogicalAudioDevice *logdev = NULL; - if (!wants_default && SDL_AtomicGet(&device->zombie)) { + if (!wants_default && SDL_GetAtomicInt(&device->zombie)) { // uhoh, this device is undead, and just waiting to be cleaned up. Refuse explicit opens. SDL_SetError("Device was already lost and can't accept new opens"); } else if ((logdev = (SDL_LogicalAudioDevice *) SDL_calloc(1, sizeof (SDL_LogicalAudioDevice))) == NULL) { @@ -1728,7 +1728,7 @@ SDL_AudioDeviceID SDL_OpenAudioDevice(SDL_AudioDeviceID devid, const SDL_AudioSp SDL_free(logdev); } else { RefPhysicalAudioDevice(device); // unref'd on successful SDL_CloseAudioDevice - SDL_AtomicSet(&logdev->paused, 0); + SDL_SetAtomicInt(&logdev->paused, 0); result = logdev->instance_id = AssignAudioDeviceInstanceId(device->recording, /*islogical=*/true); logdev->physical_device = device; logdev->gain = 1.0f; @@ -1761,7 +1761,7 @@ static bool SetLogicalAudioDevicePauseState(SDL_AudioDeviceID devid, int value) SDL_AudioDevice *device = NULL; SDL_LogicalAudioDevice *logdev = ObtainLogicalAudioDevice(devid, &device); if (logdev) { - SDL_AtomicSet(&logdev->paused, value); + SDL_SetAtomicInt(&logdev->paused, value); } ReleaseAudioDevice(device); return logdev ? true : false; // ObtainLogicalAudioDevice will have set an error. @@ -1782,7 +1782,7 @@ SDL_bool SDL_AudioDevicePaused(SDL_AudioDeviceID devid) SDL_AudioDevice *device = NULL; SDL_LogicalAudioDevice *logdev = ObtainLogicalAudioDevice(devid, &device); bool result = false; - if (logdev && SDL_AtomicGet(&logdev->paused)) { + if (logdev && SDL_GetAtomicInt(&logdev->paused)) { result = true; } ReleaseAudioDevice(device); @@ -2067,7 +2067,7 @@ SDL_AudioStream *SDL_OpenAudioDeviceStream(SDL_AudioDeviceID devid, const SDL_Au if (!logdev) { // this shouldn't happen, but just in case. failed = true; } else { - SDL_AtomicSet(&logdev->paused, 1); // start the device paused, to match SDL2. + SDL_SetAtomicInt(&logdev->paused, 1); // start the device paused, to match SDL2. SDL_assert(device != NULL); const bool recording = device->recording; @@ -2302,7 +2302,7 @@ void SDL_DefaultAudioDeviceChanged(SDL_AudioDevice *new_default_device) new_default_device->logical_devices = logdev; SDL_UnlockRWLock(current_audio.device_hash_lock); - SDL_assert(SDL_AtomicGet(¤t_default_device->refcount) > 1); // we should hold at least one extra reference to this device, beyond logical devices, during this phase... + SDL_assert(SDL_GetAtomicInt(¤t_default_device->refcount) > 1); // we should hold at least one extra reference to this device, beyond logical devices, during this phase... RefPhysicalAudioDevice(new_default_device); UnrefPhysicalAudioDevice(current_default_device); diff --git a/src/audio/aaudio/SDL_aaudio.c b/src/audio/aaudio/SDL_aaudio.c index 165ab0b7fd..6e8d7ddffd 100644 --- a/src/audio/aaudio/SDL_aaudio.c +++ b/src/audio/aaudio/SDL_aaudio.c @@ -82,7 +82,7 @@ static void AAUDIO_errorCallback(AAudioStream *stream, void *userData, aaudio_re // You MUST NOT close the audio stream from this callback, so we cannot call SDL_AudioDeviceDisconnected here. // Just flag the device so we can kill it in PlayDevice instead. SDL_AudioDevice *device = (SDL_AudioDevice *) userData; - SDL_AtomicSet(&device->hidden->error_callback_triggered, (int) error); // AAUDIO_OK is zero, so !triggered means no error. + SDL_SetAtomicInt(&device->hidden->error_callback_triggered, (int) error); // AAUDIO_OK is zero, so !triggered means no error. SDL_SignalSemaphore(device->hidden->semaphore); // in case we're blocking in WaitDevice. } @@ -163,7 +163,7 @@ static Uint8 *AAUDIO_GetDeviceBuf(SDL_AudioDevice *device, int *bufsize) static bool AAUDIO_WaitDevice(SDL_AudioDevice *device) { - while (!SDL_AtomicGet(&device->shutdown)) { + while (!SDL_GetAtomicInt(&device->shutdown)) { // this semaphore won't fire when the app is in the background (AAUDIO_PauseDevices was called). if (SDL_WaitSemaphoreTimeout(device->hidden->semaphore, 100)) { return true; // semaphore was signaled, let's go! @@ -218,7 +218,7 @@ static bool AAUDIO_PlayDevice(SDL_AudioDevice *device, const Uint8 *buffer, int struct SDL_PrivateAudioData *hidden = device->hidden; // AAUDIO_dataCallback picks up our work and unblocks AAUDIO_WaitDevice. But make sure we didn't fail here. - const aaudio_result_t err = (aaudio_result_t) SDL_AtomicGet(&hidden->error_callback_triggered); + const aaudio_result_t err = (aaudio_result_t) SDL_GetAtomicInt(&hidden->error_callback_triggered); if (err) { SDL_LogError(SDL_LOG_CATEGORY_AUDIO, "aaudio: Audio device triggered error %d (%s)", (int) err, ctx.AAudio_convertResultToText(err)); @@ -237,8 +237,8 @@ static int AAUDIO_RecordDevice(SDL_AudioDevice *device, void *buffer, int buflen struct SDL_PrivateAudioData *hidden = device->hidden; // AAUDIO_dataCallback picks up our work and unblocks AAUDIO_WaitDevice. But make sure we didn't fail here. - if (SDL_AtomicGet(&hidden->error_callback_triggered)) { - SDL_AtomicSet(&hidden->error_callback_triggered, 0); + if (SDL_GetAtomicInt(&hidden->error_callback_triggered)) { + SDL_SetAtomicInt(&hidden->error_callback_triggered, 0); return -1; } @@ -279,7 +279,7 @@ static bool BuildAAudioStream(SDL_AudioDevice *device) const bool recording = device->recording; aaudio_result_t res; - SDL_AtomicSet(&hidden->error_callback_triggered, 0); + SDL_SetAtomicInt(&hidden->error_callback_triggered, 0); AAudioStreamBuilder *builder = NULL; res = ctx.AAudio_createStreamBuilder(&builder); @@ -388,7 +388,7 @@ static bool BuildAAudioStream(SDL_AudioDevice *device) // !!! FIXME: make this non-blocking! static void SDLCALL RequestAndroidPermissionBlockingCallback(void *userdata, const char *permission, SDL_bool granted) { - SDL_AtomicSet((SDL_AtomicInt *) userdata, granted ? 1 : -1); + SDL_SetAtomicInt((SDL_AtomicInt *) userdata, granted ? 1 : -1); } static bool AAUDIO_OpenDevice(SDL_AudioDevice *device) @@ -402,16 +402,16 @@ static bool AAUDIO_OpenDevice(SDL_AudioDevice *device) if (device->recording) { // !!! FIXME: make this non-blocking! SDL_AtomicInt permission_response; - SDL_AtomicSet(&permission_response, 0); + SDL_SetAtomicInt(&permission_response, 0); if (!SDL_RequestAndroidPermission("android.permission.RECORD_AUDIO", RequestAndroidPermissionBlockingCallback, &permission_response)) { return false; } - while (SDL_AtomicGet(&permission_response) == 0) { + while (SDL_GetAtomicInt(&permission_response) == 0) { SDL_Delay(10); } - if (SDL_AtomicGet(&permission_response) < 0) { + if (SDL_GetAtomicInt(&permission_response) < 0) { LOGI("This app doesn't have RECORD_AUDIO permission"); return SDL_SetError("This app doesn't have RECORD_AUDIO permission"); } diff --git a/src/audio/alsa/SDL_alsa_audio.c b/src/audio/alsa/SDL_alsa_audio.c index bf52cea7f0..cf67a42fc1 100644 --- a/src/audio/alsa/SDL_alsa_audio.c +++ b/src/audio/alsa/SDL_alsa_audio.c @@ -265,7 +265,7 @@ static bool ALSA_WaitDevice(SDL_AudioDevice *device) const int fulldelay = (int) ((((Uint64) device->sample_frames) * 1000) / device->spec.freq); const int delay = SDL_max(fulldelay, 10); - while (!SDL_AtomicGet(&device->shutdown)) { + while (!SDL_GetAtomicInt(&device->shutdown)) { const int rc = ALSA_snd_pcm_wait(device->hidden->pcm_handle, delay); if (rc < 0 && (rc != -EAGAIN)) { const int status = ALSA_snd_pcm_recover(device->hidden->pcm_handle, rc, 0); @@ -294,7 +294,7 @@ static bool ALSA_PlayDevice(SDL_AudioDevice *device, const Uint8 *buffer, int bu const int frame_size = SDL_AUDIO_FRAMESIZE(device->spec); snd_pcm_uframes_t frames_left = (snd_pcm_uframes_t) (buflen / frame_size); - while ((frames_left > 0) && !SDL_AtomicGet(&device->shutdown)) { + while ((frames_left > 0) && !SDL_GetAtomicInt(&device->shutdown)) { const int rc = ALSA_snd_pcm_writei(device->hidden->pcm_handle, sample_buf, frames_left); //SDL_LogInfo(SDL_LOG_CATEGORY_AUDIO, "ALSA PLAYDEVICE: WROTE %d of %d bytes", (rc >= 0) ? ((int) (rc * frame_size)) : rc, (int) (frames_left * frame_size)); SDL_assert(rc != 0); // assuming this can't happen if we used snd_pcm_wait and queried for available space. @@ -825,10 +825,10 @@ static int SDLCALL ALSA_HotplugThread(void *arg) { SDL_SetThreadPriority(SDL_THREAD_PRIORITY_LOW); - while (!SDL_AtomicGet(&ALSA_hotplug_shutdown)) { + while (!SDL_GetAtomicInt(&ALSA_hotplug_shutdown)) { // Block awhile before checking again, unless we're told to stop. const Uint64 ticks = SDL_GetTicks() + 5000; - while (!SDL_AtomicGet(&ALSA_hotplug_shutdown) && SDL_GetTicks() < ticks) { + while (!SDL_GetAtomicInt(&ALSA_hotplug_shutdown) && SDL_GetTicks() < ticks) { SDL_Delay(100); } @@ -853,7 +853,7 @@ static void ALSA_DetectDevices(SDL_AudioDevice **default_playback, SDL_AudioDevi } #if SDL_ALSA_HOTPLUG_THREAD - SDL_AtomicSet(&ALSA_hotplug_shutdown, 0); + SDL_SetAtomicInt(&ALSA_hotplug_shutdown, 0); ALSA_hotplug_thread = SDL_CreateThread(ALSA_HotplugThread, "SDLHotplugALSA", NULL); // if the thread doesn't spin, oh well, you just don't get further hotplug events. #endif @@ -866,7 +866,7 @@ static void ALSA_DeinitializeStart(void) #if SDL_ALSA_HOTPLUG_THREAD if (ALSA_hotplug_thread) { - SDL_AtomicSet(&ALSA_hotplug_shutdown, 1); + SDL_SetAtomicInt(&ALSA_hotplug_shutdown, 1); SDL_WaitThread(ALSA_hotplug_thread, NULL); ALSA_hotplug_thread = NULL; } diff --git a/src/audio/coreaudio/SDL_coreaudio.m b/src/audio/coreaudio/SDL_coreaudio.m index ecf185decc..9b6b81984a 100644 --- a/src/audio/coreaudio/SDL_coreaudio.m +++ b/src/audio/coreaudio/SDL_coreaudio.m @@ -622,7 +622,7 @@ static void RecordingBufferReadyCallback(void *inUserData, AudioQueueRef inAQ, A // buffer is unexpectedly here? We're probably dying, but try to requeue this buffer anyhow. if (device->hidden->current_buffer != NULL) { - SDL_assert(SDL_AtomicGet(&device->shutdown) != 0); + SDL_assert(SDL_GetAtomicInt(&device->shutdown) != 0); COREAUDIO_FlushRecording(device); // just flush it manually, which will requeue it. } } @@ -641,7 +641,7 @@ static void COREAUDIO_CloseDevice(SDL_AudioDevice *device) } if (device->hidden->thread) { - SDL_assert(SDL_AtomicGet(&device->shutdown) != 0); // should have been set by SDL_audio.c + SDL_assert(SDL_GetAtomicInt(&device->shutdown) != 0); // should have been set by SDL_audio.c SDL_WaitThread(device->hidden->thread, NULL); } @@ -839,7 +839,7 @@ static int AudioQueueThreadEntry(void *arg) SDL_SignalSemaphore(device->hidden->ready_semaphore); // This would be WaitDevice/WaitRecordingDevice in the normal SDL audio thread, but we get *BufferReadyCallback calls here to know when to iterate. - while (!SDL_AtomicGet(&device->shutdown)) { + while (!SDL_GetAtomicInt(&device->shutdown)) { CFRunLoopRunInMode(kCFRunLoopDefaultMode, 0.10, 1); } diff --git a/src/audio/directsound/SDL_directsound.c b/src/audio/directsound/SDL_directsound.c index 43a2b79ee4..43864b2cd1 100644 --- a/src/audio/directsound/SDL_directsound.c +++ b/src/audio/directsound/SDL_directsound.c @@ -234,7 +234,7 @@ static bool DSOUND_WaitDevice(SDL_AudioDevice *device) /* Semi-busy wait, since we have no way of getting play notification on a primary mixing buffer located in hardware (DirectX 5.0) */ - while (!SDL_AtomicGet(&device->shutdown)) { + while (!SDL_GetAtomicInt(&device->shutdown)) { DWORD status = 0; DWORD cursor = 0; DWORD junk = 0; @@ -336,7 +336,7 @@ static Uint8 *DSOUND_GetDeviceBuf(SDL_AudioDevice *device, int *buffer_size) static bool DSOUND_WaitRecordingDevice(SDL_AudioDevice *device) { struct SDL_PrivateAudioData *h = device->hidden; - while (!SDL_AtomicGet(&device->shutdown)) { + while (!SDL_GetAtomicInt(&device->shutdown)) { DWORD junk, cursor; if (IDirectSoundCaptureBuffer_GetCurrentPosition(h->capturebuf, &junk, &cursor) != DS_OK) { return false; diff --git a/src/audio/dsp/SDL_dspaudio.c b/src/audio/dsp/SDL_dspaudio.c index 199fecb1d5..62e2f4c45d 100644 --- a/src/audio/dsp/SDL_dspaudio.c +++ b/src/audio/dsp/SDL_dspaudio.c @@ -204,7 +204,7 @@ static bool DSP_WaitDevice(SDL_AudioDevice *device) const unsigned long ioctlreq = device->recording ? SNDCTL_DSP_GETISPACE : SNDCTL_DSP_GETOSPACE; struct SDL_PrivateAudioData *h = device->hidden; - while (!SDL_AtomicGet(&device->shutdown)) { + while (!SDL_GetAtomicInt(&device->shutdown)) { audio_buf_info info; const int rc = ioctl(h->audio_fd, ioctlreq, &info); if (rc < 0) { diff --git a/src/audio/n3ds/SDL_n3dsaudio.c b/src/audio/n3ds/SDL_n3dsaudio.c index 6d3afa3181..900969ea46 100644 --- a/src/audio/n3ds/SDL_n3dsaudio.c +++ b/src/audio/n3ds/SDL_n3dsaudio.c @@ -203,7 +203,7 @@ static bool N3DSAUDIO_PlayDevice(SDL_AudioDevice *device, const Uint8 *buffer, i static bool N3DSAUDIO_WaitDevice(SDL_AudioDevice *device) { contextLock(device); - while (!device->hidden->isCancelled && !SDL_AtomicGet(&device->shutdown) && + while (!device->hidden->isCancelled && !SDL_GetAtomicInt(&device->shutdown) && device->hidden->waveBuf[device->hidden->nextbuf].status != NDSP_WBUF_FREE) { CondVar_Wait(&device->hidden->cv, &device->hidden->lock); } diff --git a/src/audio/netbsd/SDL_netbsdaudio.c b/src/audio/netbsd/SDL_netbsdaudio.c index 92c99cd373..7e105007ba 100644 --- a/src/audio/netbsd/SDL_netbsdaudio.c +++ b/src/audio/netbsd/SDL_netbsdaudio.c @@ -117,7 +117,7 @@ static void NETBSDAUDIO_Status(SDL_AudioDevice *device) static bool NETBSDAUDIO_WaitDevice(SDL_AudioDevice *device) { const bool recording = device->recording; - while (!SDL_AtomicGet(&device->shutdown)) { + while (!SDL_GetAtomicInt(&device->shutdown)) { audio_info_t info; const int rc = ioctl(device->hidden->audio_fd, AUDIO_GETINFO, &info); if (rc < 0) { diff --git a/src/audio/openslES/SDL_openslES.c b/src/audio/openslES/SDL_openslES.c index 1a7d04e751..e7aea4bb64 100644 --- a/src/audio/openslES/SDL_openslES.c +++ b/src/audio/openslES/SDL_openslES.c @@ -231,7 +231,7 @@ static void OPENSLES_DestroyPCMRecorder(SDL_AudioDevice *device) // !!! FIXME: make this non-blocking! static void SDLCALL RequestAndroidPermissionBlockingCallback(void *userdata, const char *permission, SDL_bool granted) { - SDL_AtomicSet((SDL_AtomicInt *) userdata, granted ? 1 : -1); + SDL_SetAtomicInt((SDL_AtomicInt *) userdata, granted ? 1 : -1); } static bool OPENSLES_CreatePCMRecorder(SDL_AudioDevice *device) @@ -250,16 +250,16 @@ static bool OPENSLES_CreatePCMRecorder(SDL_AudioDevice *device) // !!! FIXME: make this non-blocking! { SDL_AtomicInt permission_response; - SDL_AtomicSet(&permission_response, 0); + SDL_SetAtomicInt(&permission_response, 0); if (!SDL_RequestAndroidPermission("android.permission.RECORD_AUDIO", RequestAndroidPermissionBlockingCallback, &permission_response)) { return false; } - while (SDL_AtomicGet(&permission_response) == 0) { + while (SDL_GetAtomicInt(&permission_response) == 0) { SDL_Delay(10); } - if (SDL_AtomicGet(&permission_response) < 0) { + if (SDL_GetAtomicInt(&permission_response) < 0) { LOGE("This app doesn't have RECORD_AUDIO permission"); return SDL_SetError("This app doesn't have RECORD_AUDIO permission"); } @@ -652,7 +652,7 @@ static bool OPENSLES_WaitDevice(SDL_AudioDevice *device) LOGV("OPENSLES_WaitDevice()"); - while (!SDL_AtomicGet(&device->shutdown)) { + while (!SDL_GetAtomicInt(&device->shutdown)) { // this semaphore won't fire when the app is in the background (OPENSLES_PauseDevices was called). if (SDL_WaitSemaphoreTimeout(audiodata->playsem, 100)) { return true; // semaphore was signaled, let's go! diff --git a/src/audio/pulseaudio/SDL_pulseaudio.c b/src/audio/pulseaudio/SDL_pulseaudio.c index 7e31864aed..733904362b 100644 --- a/src/audio/pulseaudio/SDL_pulseaudio.c +++ b/src/audio/pulseaudio/SDL_pulseaudio.c @@ -413,7 +413,7 @@ static bool PULSEAUDIO_WaitDevice(SDL_AudioDevice *device) PULSEAUDIO_pa_threaded_mainloop_lock(pulseaudio_threaded_mainloop); - while (!SDL_AtomicGet(&device->shutdown) && (h->bytes_requested == 0)) { + while (!SDL_GetAtomicInt(&device->shutdown) && (h->bytes_requested == 0)) { //SDL_Log("PULSEAUDIO WAIT IN WAITDEVICE!"); PULSEAUDIO_pa_threaded_mainloop_wait(pulseaudio_threaded_mainloop); @@ -486,7 +486,7 @@ static bool PULSEAUDIO_WaitRecordingDevice(SDL_AudioDevice *device) PULSEAUDIO_pa_threaded_mainloop_lock(pulseaudio_threaded_mainloop); - while (!SDL_AtomicGet(&device->shutdown)) { + while (!SDL_GetAtomicInt(&device->shutdown)) { PULSEAUDIO_pa_threaded_mainloop_wait(pulseaudio_threaded_mainloop); if ((PULSEAUDIO_pa_context_get_state(pulseaudio_context) != PA_CONTEXT_READY) || (PULSEAUDIO_pa_stream_get_state(h->stream) != PA_STREAM_READY)) { //SDL_Log("PULSEAUDIO DEVICE FAILURE IN WAITRECORDINGDEVICE!"); @@ -553,7 +553,7 @@ static void PULSEAUDIO_FlushRecording(SDL_AudioDevice *device) h->recordinglen = 0; } - while (!SDL_AtomicGet(&device->shutdown) && (PULSEAUDIO_pa_stream_readable_size(h->stream) > 0)) { + while (!SDL_GetAtomicInt(&device->shutdown) && (PULSEAUDIO_pa_stream_readable_size(h->stream) > 0)) { PULSEAUDIO_pa_threaded_mainloop_wait(pulseaudio_threaded_mainloop); if ((PULSEAUDIO_pa_context_get_state(pulseaudio_context) != PA_CONTEXT_READY) || (PULSEAUDIO_pa_stream_get_state(h->stream) != PA_STREAM_READY)) { //SDL_Log("PULSEAUDIO DEVICE FAILURE IN FLUSHRECORDING!"); @@ -901,7 +901,7 @@ static int SDLCALL HotplugThread(void *data) SDL_SignalSemaphore((SDL_Semaphore *) data); - while (SDL_AtomicGet(&pulseaudio_hotplug_thread_active)) { + while (SDL_GetAtomicInt(&pulseaudio_hotplug_thread_active)) { PULSEAUDIO_pa_threaded_mainloop_wait(pulseaudio_threaded_mainloop); if (op && PULSEAUDIO_pa_operation_get_state(op) != PA_OPERATION_RUNNING) { PULSEAUDIO_pa_operation_unref(op); @@ -956,12 +956,12 @@ static void PULSEAUDIO_DetectDevices(SDL_AudioDevice **default_playback, SDL_Aud } // ok, we have a sane list, let's set up hotplug notifications now... - SDL_AtomicSet(&pulseaudio_hotplug_thread_active, 1); + SDL_SetAtomicInt(&pulseaudio_hotplug_thread_active, 1); pulseaudio_hotplug_thread = SDL_CreateThread(HotplugThread, "PulseHotplug", ready_sem); if (pulseaudio_hotplug_thread) { SDL_WaitSemaphore(ready_sem); // wait until the thread hits it's main loop. } else { - SDL_AtomicSet(&pulseaudio_hotplug_thread_active, 0); // thread failed to start, we'll go on without hotplug. + SDL_SetAtomicInt(&pulseaudio_hotplug_thread_active, 0); // thread failed to start, we'll go on without hotplug. } SDL_DestroySemaphore(ready_sem); @@ -978,7 +978,7 @@ static void PULSEAUDIO_DeinitializeStart(void) { if (pulseaudio_hotplug_thread) { PULSEAUDIO_pa_threaded_mainloop_lock(pulseaudio_threaded_mainloop); - SDL_AtomicSet(&pulseaudio_hotplug_thread_active, 0); + SDL_SetAtomicInt(&pulseaudio_hotplug_thread_active, 0); PULSEAUDIO_pa_threaded_mainloop_signal(pulseaudio_threaded_mainloop, 0); PULSEAUDIO_pa_threaded_mainloop_unlock(pulseaudio_threaded_mainloop); SDL_WaitThread(pulseaudio_hotplug_thread, NULL); diff --git a/src/audio/qnx/SDL_qsa_audio.c b/src/audio/qnx/SDL_qsa_audio.c index 7dffa1f945..3a549b87d4 100644 --- a/src/audio/qnx/SDL_qsa_audio.c +++ b/src/audio/qnx/SDL_qsa_audio.c @@ -112,14 +112,14 @@ static bool QSA_WaitDevice(SDL_AudioDevice *device) static bool QSA_PlayDevice(SDL_AudioDevice *device, const Uint8 *buffer, int buflen) { - if (SDL_AtomicGet(&device->shutdown) || !device->hidden) { + if (SDL_GetAtomicInt(&device->shutdown) || !device->hidden) { return true; } int towrite = buflen; // Write the audio data, checking for EAGAIN (buffer full) and underrun - while ((towrite > 0) && !SDL_AtomicGet(&device->shutdown)); + while ((towrite > 0) && !SDL_GetAtomicInt(&device->shutdown)); const int bw = snd_pcm_plugin_write(device->hidden->audio_handle, buffer, towrite); if (bw != towrite) { // Check if samples playback got stuck somewhere in hardware or in the audio device driver diff --git a/src/audio/sndio/SDL_sndioaudio.c b/src/audio/sndio/SDL_sndioaudio.c index 0e709fa0ef..91cfe79da6 100644 --- a/src/audio/sndio/SDL_sndioaudio.c +++ b/src/audio/sndio/SDL_sndioaudio.c @@ -151,7 +151,7 @@ static bool SNDIO_WaitDevice(SDL_AudioDevice *device) { const bool recording = device->recording; - while (!SDL_AtomicGet(&device->shutdown)) { + while (!SDL_GetAtomicInt(&device->shutdown)) { if (SNDIO_sio_eof(device->hidden->dev)) { return false; } @@ -200,7 +200,7 @@ static int SNDIO_RecordDevice(SDL_AudioDevice *device, void *buffer, int buflen) static void SNDIO_FlushRecording(SDL_AudioDevice *device) { char buf[512]; - while (!SDL_AtomicGet(&device->shutdown) && (SNDIO_sio_read(device->hidden->dev, buf, sizeof(buf)) > 0)) { + while (!SDL_GetAtomicInt(&device->shutdown) && (SNDIO_sio_read(device->hidden->dev, buf, sizeof(buf)) > 0)) { // do nothing } } diff --git a/src/audio/vita/SDL_vitaaudio.c b/src/audio/vita/SDL_vitaaudio.c index fcd046c643..ad479f9849 100644 --- a/src/audio/vita/SDL_vitaaudio.c +++ b/src/audio/vita/SDL_vitaaudio.c @@ -137,7 +137,7 @@ static bool VITAAUD_PlayDevice(SDL_AudioDevice *device, const Uint8 *buffer, int static bool VITAAUD_WaitDevice(SDL_AudioDevice *device) { // !!! FIXME: we might just need to sleep roughly as long as playback buffers take to process, based on sample rate, etc. - while (!SDL_AtomicGet(&device->shutdown) && (sceAudioOutGetRestSample(device->hidden->port) >= device->buffer_size)) { + while (!SDL_GetAtomicInt(&device->shutdown) && (sceAudioOutGetRestSample(device->hidden->port) >= device->buffer_size)) { SDL_Delay(1); } return true; @@ -176,7 +176,7 @@ static bool VITAAUD_WaitRecordingDevice(SDL_AudioDevice *device) // there's only a blocking call to obtain more data, so we'll just sleep as // long as a buffer would run. const Uint64 endticks = SDL_GetTicks() + ((device->sample_frames * 1000) / device->spec.freq); - while (!SDL_AtomicGet(&device->shutdown) && (SDL_GetTicks() < endticks)) { + while (!SDL_GetAtomicInt(&device->shutdown) && (SDL_GetTicks() < endticks)) { SDL_Delay(1); } return true; diff --git a/src/audio/wasapi/SDL_wasapi.c b/src/audio/wasapi/SDL_wasapi.c index 9eaa32e878..6c8eee6cae 100644 --- a/src/audio/wasapi/SDL_wasapi.c +++ b/src/audio/wasapi/SDL_wasapi.c @@ -74,11 +74,11 @@ static void ManagementThreadMainloop(void) { SDL_LockMutex(ManagementThreadLock); ManagementThreadPendingTask *task; - while (((task = (ManagementThreadPendingTask *)SDL_AtomicGetPointer((void **)&ManagementThreadPendingTasks)) != NULL) || !SDL_AtomicGet(&ManagementThreadShutdown)) { + while (((task = (ManagementThreadPendingTask *)SDL_GetAtomicPointer((void **)&ManagementThreadPendingTasks)) != NULL) || !SDL_GetAtomicInt(&ManagementThreadShutdown)) { if (!task) { SDL_WaitCondition(ManagementThreadCondition, ManagementThreadLock); // block until there's something to do. } else { - SDL_AtomicSetPointer((void **) &ManagementThreadPendingTasks, task->next); // take task off the pending list. + SDL_SetAtomicPointer((void **) &ManagementThreadPendingTasks, task->next); // take task off the pending list. SDL_UnlockMutex(ManagementThreadLock); // let other things add to the list while we chew on this task. task->result = task->fn(task->userdata); // run this task. if (task->task_complete_sem) { // something waiting on result? @@ -101,7 +101,7 @@ bool WASAPI_ProxyToManagementThread(ManagementThreadTask task, void *userdata, b return true; // completed! } - if (SDL_AtomicGet(&ManagementThreadShutdown)) { + if (SDL_GetAtomicInt(&ManagementThreadShutdown)) { return SDL_SetError("Can't add task, we're shutting down"); } @@ -127,14 +127,14 @@ bool WASAPI_ProxyToManagementThread(ManagementThreadTask task, void *userdata, b // add to end of task list. ManagementThreadPendingTask *prev = NULL; - for (ManagementThreadPendingTask *i = (ManagementThreadPendingTask *)SDL_AtomicGetPointer((void **)&ManagementThreadPendingTasks); i; i = i->next) { + for (ManagementThreadPendingTask *i = (ManagementThreadPendingTask *)SDL_GetAtomicPointer((void **)&ManagementThreadPendingTasks); i; i = i->next) { prev = i; } if (prev) { prev->next = pending; } else { - SDL_AtomicSetPointer((void **) &ManagementThreadPendingTasks, pending); + SDL_SetAtomicPointer((void **) &ManagementThreadPendingTasks, pending); } // task is added to the end of the pending list, let management thread rip! @@ -210,8 +210,8 @@ static bool InitManagementThread(void) return false; } - SDL_AtomicSetPointer((void **) &ManagementThreadPendingTasks, NULL); - SDL_AtomicSet(&ManagementThreadShutdown, 0); + SDL_SetAtomicPointer((void **) &ManagementThreadPendingTasks, NULL); + SDL_SetAtomicInt(&ManagementThreadShutdown, 0); ManagementThread = SDL_CreateThreadWithStackSize(ManagementThreadEntry, "SDLWASAPIMgmt", 256 * 1024, &mgmtdata); // !!! FIXME: maybe even smaller stack size? if (!ManagementThread) { return false; @@ -234,7 +234,7 @@ static bool InitManagementThread(void) static void DeinitManagementThread(void) { if (ManagementThread) { - SDL_AtomicSet(&ManagementThreadShutdown, 1); + SDL_SetAtomicInt(&ManagementThreadShutdown, 1); SDL_LockMutex(ManagementThreadLock); SDL_SignalCondition(ManagementThreadCondition); SDL_UnlockMutex(ManagementThreadLock); @@ -242,13 +242,13 @@ static void DeinitManagementThread(void) ManagementThread = NULL; } - SDL_assert(SDL_AtomicGetPointer((void **) &ManagementThreadPendingTasks) == NULL); + SDL_assert(SDL_GetAtomicPointer((void **) &ManagementThreadPendingTasks) == NULL); SDL_DestroyCondition(ManagementThreadCondition); SDL_DestroyMutex(ManagementThreadLock); ManagementThreadCondition = NULL; ManagementThreadLock = NULL; - SDL_AtomicSet(&ManagementThreadShutdown, 0); + SDL_SetAtomicInt(&ManagementThreadShutdown, 0); } typedef struct @@ -403,14 +403,14 @@ static bool RecoverWasapiDevice(SDL_AudioDevice *device) // do not call when holding the device lock! static bool RecoverWasapiIfLost(SDL_AudioDevice *device) { - if (SDL_AtomicGet(&device->shutdown)) { + if (SDL_GetAtomicInt(&device->shutdown)) { return false; // already failed. } else if (device->hidden->device_dead) { // had a fatal error elsewhere, clean up and quit IAudioClient_Stop(device->hidden->client); WASAPI_DisconnectDevice(device); - SDL_assert(SDL_AtomicGet(&device->shutdown)); // so we don't come back through here. + SDL_assert(SDL_GetAtomicInt(&device->shutdown)); // so we don't come back through here. return false; // already failed. - } else if (SDL_AtomicGet(&device->zombie)) { + } else if (SDL_GetAtomicInt(&device->zombie)) { return false; // we're already dead, so just leave and let the Zombie implementations take over. } else if (!device->hidden->client) { return true; // still waiting for activation. @@ -538,7 +538,7 @@ static void WASAPI_FlushRecording(SDL_AudioDevice *device) DWORD flags = 0; // just read until we stop getting packets, throwing them away. - while (!SDL_AtomicGet(&device->shutdown) && device->hidden->capture) { + while (!SDL_GetAtomicInt(&device->shutdown) && device->hidden->capture) { const HRESULT ret = IAudioCaptureClient_GetBuffer(device->hidden->capture, &ptr, &frames, &flags, NULL, NULL); if (ret == AUDCLNT_S_BUFFER_EMPTY) { break; // no more buffered data; we're done. diff --git a/src/camera/SDL_camera.c b/src/camera/SDL_camera.c index 25d70973cf..419fa9d675 100644 --- a/src/camera/SDL_camera.c +++ b/src/camera/SDL_camera.c @@ -115,7 +115,7 @@ bool SDL_AddCameraFormat(CameraFormatAddData *data, SDL_PixelFormat format, SDL_ // loss notifications will get black frames but otherwise keep functioning. static bool ZombieWaitDevice(SDL_Camera *device) { - if (!SDL_AtomicGet(&device->shutdown)) { + if (!SDL_GetAtomicInt(&device->shutdown)) { // !!! FIXME: this is bad for several reasons (uses double, could be precalculated, doesn't track elasped time). const double duration = ((double) device->actual_spec.framerate_denominator / ((double) device->actual_spec.framerate_numerator)); SDL_Delay((Uint32) (duration * 1000.0)); @@ -230,7 +230,7 @@ static void ClosePhysicalCamera(SDL_Camera *device) return; } - SDL_AtomicSet(&device->shutdown, 1); + SDL_SetAtomicInt(&device->shutdown, 1); // !!! FIXME: the close_cond stuff from audio might help the race condition here. @@ -297,7 +297,7 @@ void UnrefPhysicalCamera(SDL_Camera *device) // take it out of the device list. SDL_LockRWLockForWriting(camera_driver.device_hash_lock); if (SDL_RemoveFromHashTable(camera_driver.device_hash, (const void *) (uintptr_t) device->instance_id)) { - SDL_AtomicAdd(&camera_driver.device_count, -1); + SDL_AddAtomicInt(&camera_driver.device_count, -1); } SDL_UnlockRWLock(camera_driver.device_hash_lock); DestroyPhysicalCamera(device); // ...and nuke it. @@ -421,7 +421,7 @@ SDL_Camera *SDL_AddCamera(const char *name, SDL_CameraPosition position, int num SDL_assert(handle != NULL); SDL_LockRWLockForReading(camera_driver.device_hash_lock); - const int shutting_down = SDL_AtomicGet(&camera_driver.shutting_down); + const int shutting_down = SDL_GetAtomicInt(&camera_driver.shutting_down); SDL_UnlockRWLock(camera_driver.device_hash_lock); if (shutting_down) { return NULL; // we're shutting down, don't add any devices that are hotplugged at the last possible moment. @@ -488,13 +488,13 @@ SDL_Camera *SDL_AddCamera(const char *name, SDL_CameraPosition position, int num device->num_specs = num_specs; device->handle = handle; device->instance_id = SDL_GetNextObjectID(); - SDL_AtomicSet(&device->shutdown, 0); - SDL_AtomicSet(&device->zombie, 0); + SDL_SetAtomicInt(&device->shutdown, 0); + SDL_SetAtomicInt(&device->zombie, 0); RefPhysicalCamera(device); SDL_LockRWLockForWriting(camera_driver.device_hash_lock); if (SDL_InsertIntoHashTable(camera_driver.device_hash, (const void *) (uintptr_t) device->instance_id, device)) { - SDL_AtomicAdd(&camera_driver.device_count, 1); + SDL_AddAtomicInt(&camera_driver.device_count, 1); } else { SDL_DestroyMutex(device->lock); SDL_free(device->all_specs); @@ -542,7 +542,7 @@ void SDL_CameraDisconnected(SDL_Camera *device) ObtainPhysicalCameraObj(device); - const bool first_disconnect = SDL_AtomicCompareAndSwap(&device->zombie, 0, 1); + const bool first_disconnect = SDL_CompareAndSwapAtomicInt(&device->zombie, 0, 1); if (first_disconnect) { // if already disconnected this device, don't do it twice. // Swap in "Zombie" versions of the usual platform interfaces, so the device will keep // making progress until the app closes it. Otherwise, streams might continue to @@ -713,7 +713,7 @@ SDL_CameraID *SDL_GetCameras(int *count) SDL_CameraID *result = NULL; SDL_LockRWLockForReading(camera_driver.device_hash_lock); - int num_devices = SDL_AtomicGet(&camera_driver.device_count); + int num_devices = SDL_GetAtomicInt(&camera_driver.device_count); result = (SDL_CameraID *) SDL_malloc((num_devices + 1) * sizeof (SDL_CameraID)); if (!result) { num_devices = 0; @@ -792,7 +792,7 @@ bool SDL_CameraThreadIterate(SDL_Camera *device) { SDL_LockMutex(device->lock); - if (SDL_AtomicGet(&device->shutdown)) { + if (SDL_GetAtomicInt(&device->shutdown)) { SDL_UnlockMutex(device->lock); return false; // we're done, shut it down. } @@ -1078,7 +1078,7 @@ SDL_Camera *SDL_OpenCamera(SDL_CameraID instance_id, const SDL_CameraSpec *spec) return NULL; } - SDL_AtomicSet(&device->shutdown, 0); + SDL_SetAtomicInt(&device->shutdown, 0); // These start with the backend's implementation, but we might swap them out with zombie versions later. device->WaitDevice = camera_driver.impl.WaitDevice; @@ -1360,12 +1360,12 @@ void SDL_QuitCamera(void) } SDL_LockRWLockForWriting(camera_driver.device_hash_lock); - SDL_AtomicSet(&camera_driver.shutting_down, 1); + SDL_SetAtomicInt(&camera_driver.shutting_down, 1); SDL_HashTable *device_hash = camera_driver.device_hash; camera_driver.device_hash = NULL; SDL_PendingCameraEvent *pending_events = camera_driver.pending_events.next; camera_driver.pending_events.next = NULL; - SDL_AtomicSet(&camera_driver.device_count, 0); + SDL_SetAtomicInt(&camera_driver.device_count, 0); SDL_UnlockRWLock(camera_driver.device_hash_lock); SDL_PendingCameraEvent *pending_next = NULL; diff --git a/src/camera/mediafoundation/SDL_camera_mediafoundation.c b/src/camera/mediafoundation/SDL_camera_mediafoundation.c index d26fe6cbe2..1e7941690c 100644 --- a/src/camera/mediafoundation/SDL_camera_mediafoundation.c +++ b/src/camera/mediafoundation/SDL_camera_mediafoundation.c @@ -354,7 +354,7 @@ static bool MEDIAFOUNDATION_WaitDevice(SDL_Camera *device) IMFSourceReader *srcreader = device->hidden->srcreader; IMFSample *sample = NULL; - while (!SDL_AtomicGet(&device->shutdown)) { + while (!SDL_GetAtomicInt(&device->shutdown)) { DWORD stream_flags = 0; const HRESULT ret = IMFSourceReader_ReadSample(srcreader, (DWORD)MF_SOURCE_READER_FIRST_VIDEO_STREAM, 0, NULL, &stream_flags, NULL, &sample); if (FAILED(ret)) { diff --git a/src/camera/v4l2/SDL_camera_v4l2.c b/src/camera/v4l2/SDL_camera_v4l2.c index e755bff89e..fbe0516aef 100644 --- a/src/camera/v4l2/SDL_camera_v4l2.c +++ b/src/camera/v4l2/SDL_camera_v4l2.c @@ -112,7 +112,7 @@ static bool V4L2_WaitDevice(SDL_Camera *device) } // Thread is requested to shut down - if (SDL_AtomicGet(&device->shutdown)) { + if (SDL_GetAtomicInt(&device->shutdown)) { return true; } diff --git a/src/core/android/SDL_android.c b/src/core/android/SDL_android.c index 61baf17101..34fb3dceef 100644 --- a/src/core/android/SDL_android.c +++ b/src/core/android/SDL_android.c @@ -558,7 +558,7 @@ JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM *vm, void *reserved) register_methods(env, "org/libsdl/app/SDLAudioManager", SDLAudioManager_tab, SDL_arraysize(SDLAudioManager_tab)); register_methods(env, "org/libsdl/app/SDLControllerManager", SDLControllerManager_tab, SDL_arraysize(SDLControllerManager_tab)); register_methods(env, "org/libsdl/app/HIDDeviceManager", HIDDeviceManager_tab, SDL_arraysize(HIDDeviceManager_tab)); - SDL_AtomicSet(&bAllowRecreateActivity, false); + SDL_SetAtomicInt(&bAllowRecreateActivity, false); return JNI_VERSION_1_4; } @@ -761,16 +761,16 @@ JNIEXPORT int JNICALL SDL_JAVA_INTERFACE(nativeCheckSDLThreadCounter)( static void SDLCALL SDL_AllowRecreateActivityChanged(void *userdata, const char *name, const char *oldValue, const char *hint) { if (SDL_GetStringBoolean(hint, false)) { - SDL_AtomicSet(&bAllowRecreateActivity, true); + SDL_SetAtomicInt(&bAllowRecreateActivity, true); } else { - SDL_AtomicSet(&bAllowRecreateActivity, false); + SDL_SetAtomicInt(&bAllowRecreateActivity, false); } } JNIEXPORT jboolean JNICALL SDL_JAVA_INTERFACE(nativeAllowRecreateActivity)( JNIEnv *env, jclass jcls) { - return SDL_AtomicGet(&bAllowRecreateActivity); + return SDL_GetAtomicInt(&bAllowRecreateActivity); } JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(nativeInitMainThread)( @@ -1690,7 +1690,7 @@ static bool Android_JNI_ExceptionOccurred(bool silent) jthrowable exception; // Detect mismatch LocalReferenceHolder_Init/Cleanup - SDL_assert(SDL_AtomicGet(&s_active) > 0); + SDL_assert(SDL_GetAtomicInt(&s_active) > 0); exception = (*env)->ExceptionOccurred(env); if (exception != NULL) { @@ -2539,7 +2539,7 @@ SDL_bool SDL_RequestAndroidPermission(const char *permission, SDL_RequestAndroid } static SDL_AtomicInt next_request_code; - info->request_code = SDL_AtomicAdd(&next_request_code, 1); + info->request_code = SDL_AddAtomicInt(&next_request_code, 1); info->callback = cb; info->userdata = userdata; @@ -2798,7 +2798,7 @@ bool Android_JNI_OpenFileDialog( // Setup data static SDL_AtomicInt next_request_code; - mAndroidFileDialogData.request_code = SDL_AtomicAdd(&next_request_code, 1); + mAndroidFileDialogData.request_code = SDL_AddAtomicInt(&next_request_code, 1); mAndroidFileDialogData.userdata = userdata; mAndroidFileDialogData.callback = callback; @@ -2808,7 +2808,7 @@ bool Android_JNI_OpenFileDialog( (*env)->DeleteLocalRef(env, filtersArray); if (!success) { mAndroidFileDialogData.callback = NULL; - SDL_AtomicAdd(&next_request_code, -1); + SDL_AddAtomicInt(&next_request_code, -1); SDL_SetError("Unspecified error in JNI"); return false; diff --git a/src/core/linux/SDL_evdev_kbd.c b/src/core/linux/SDL_evdev_kbd.c index 5ab45afff3..5ea7b55525 100644 --- a/src/core/linux/SDL_evdev_kbd.c +++ b/src/core/linux/SDL_evdev_kbd.c @@ -313,12 +313,12 @@ typedef void (*signal_handler)(int signum); static void kbd_vt_release_signal_action(int signum) { - SDL_AtomicSet(&vt_signal_pending, VT_SIGNAL_RELEASE); + SDL_SetAtomicInt(&vt_signal_pending, VT_SIGNAL_RELEASE); } static void kbd_vt_acquire_signal_action(int signum) { - SDL_AtomicSet(&vt_signal_pending, VT_SIGNAL_ACQUIRE); + SDL_SetAtomicInt(&vt_signal_pending, VT_SIGNAL_ACQUIRE); } static bool setup_vt_signal(int signum, signal_handler handler) @@ -403,7 +403,7 @@ static bool kbd_vt_init(int console_fd) static void kbd_vt_update(SDL_EVDEV_keyboard_state *state) { - int signal_pending = SDL_AtomicGet(&vt_signal_pending); + int signal_pending = SDL_GetAtomicInt(&vt_signal_pending); if (signal_pending != VT_SIGNAL_NONE) { if (signal_pending == VT_SIGNAL_RELEASE) { if (state->vt_release_callback) { @@ -416,7 +416,7 @@ static void kbd_vt_update(SDL_EVDEV_keyboard_state *state) } ioctl(state->console_fd, VT_RELDISP, VT_ACKACQ); } - SDL_AtomicCompareAndSwap(&vt_signal_pending, signal_pending, VT_SIGNAL_NONE); + SDL_CompareAndSwapAtomicInt(&vt_signal_pending, signal_pending, VT_SIGNAL_NONE); } } diff --git a/src/core/windows/SDL_immdevice.c b/src/core/windows/SDL_immdevice.c index b46bef25dd..ddf55cdaa0 100644 --- a/src/core/windows/SDL_immdevice.c +++ b/src/core/windows/SDL_immdevice.c @@ -134,7 +134,7 @@ static SDL_AudioDevice *SDL_IMMDevice_Add(const bool recording, const char *devn // see if we already have this one first. SDL_AudioDevice *device = SDL_IMMDevice_FindByDevID(devid); if (device) { - if (SDL_AtomicGet(&device->zombie)) { + if (SDL_GetAtomicInt(&device->zombie)) { // whoa, it came back! This can happen if you unplug and replug USB headphones while we're still keeping the SDL object alive. // Kill this device's IMMDevice id; the device will go away when the app closes it, or maybe a new default device is chosen // (possibly this reconnected device), so we just want to make sure IMMDevice doesn't try to find the old device by the existing ID string. @@ -209,7 +209,7 @@ static ULONG STDMETHODCALLTYPE SDLMMNotificationClient_Release(IMMNotificationCl SDLMMNotificationClient *client = (SDLMMNotificationClient *)iclient; const ULONG rc = SDL_AtomicDecRef(&client->refcount); if (rc == 0) { - SDL_AtomicSet(&client->refcount, 0); // uhh... + SDL_SetAtomicInt(&client->refcount, 0); // uhh... return 0; } return rc - 1; diff --git a/src/dynapi/SDL_dynapi.sym b/src/dynapi/SDL_dynapi.sym index 389a5644c5..8545534fb6 100644 --- a/src/dynapi/SDL_dynapi.sym +++ b/src/dynapi/SDL_dynapi.sym @@ -5,6 +5,7 @@ SDL3_0.0.0 { SDL_AcquireCameraFrame; SDL_AcquireGPUCommandBuffer; SDL_AcquireGPUSwapchainTexture; + SDL_AddAtomicInt; SDL_AddEventWatch; SDL_AddGamepadMapping; SDL_AddGamepadMappingsFromFile; @@ -14,13 +15,6 @@ SDL3_0.0.0 { SDL_AddTimer; SDL_AddTimerNS; SDL_AddVulkanRenderSemaphores; - SDL_AtomicAdd; - SDL_AtomicCompareAndSwap; - SDL_AtomicCompareAndSwapPointer; - SDL_AtomicGet; - SDL_AtomicGetPointer; - SDL_AtomicSet; - SDL_AtomicSetPointer; SDL_AttachVirtualJoystick; SDL_AudioDevicePaused; SDL_BeginGPUComputePass; @@ -67,6 +61,8 @@ SDL3_0.0.0 { SDL_CloseJoystick; SDL_CloseSensor; SDL_CloseStorage; + SDL_CompareAndSwapAtomicInt; + SDL_CompareAndSwapAtomicPointer; SDL_ComposeCustomBlendMode; SDL_ConvertAudioSamples; SDL_ConvertEventToRenderCoordinates; @@ -217,6 +213,8 @@ SDL3_0.0.0 { SDL_GetAppMetadataProperty; SDL_GetAssertionHandler; SDL_GetAssertionReport; + SDL_GetAtomicInt; + SDL_GetAtomicPointer; SDL_GetAudioDeviceChannelMap; SDL_GetAudioDeviceFormat; SDL_GetAudioDeviceGain; @@ -780,6 +778,8 @@ SDL3_0.0.0 { SDL_SetAppMetadata; SDL_SetAppMetadataProperty; SDL_SetAssertionHandler; + SDL_SetAtomicInt; + SDL_SetAtomicPointer; SDL_SetAudioDeviceGain; SDL_SetAudioPostmixCallback; SDL_SetAudioStreamFormat; diff --git a/src/dynapi/SDL_dynapi_overrides.h b/src/dynapi/SDL_dynapi_overrides.h index 14193f0f34..b6e89d6ebc 100644 --- a/src/dynapi/SDL_dynapi_overrides.h +++ b/src/dynapi/SDL_dynapi_overrides.h @@ -30,6 +30,7 @@ #define SDL_AcquireCameraFrame SDL_AcquireCameraFrame_REAL #define SDL_AcquireGPUCommandBuffer SDL_AcquireGPUCommandBuffer_REAL #define SDL_AcquireGPUSwapchainTexture SDL_AcquireGPUSwapchainTexture_REAL +#define SDL_AddAtomicInt SDL_AddAtomicInt_REAL #define SDL_AddEventWatch SDL_AddEventWatch_REAL #define SDL_AddGamepadMapping SDL_AddGamepadMapping_REAL #define SDL_AddGamepadMappingsFromFile SDL_AddGamepadMappingsFromFile_REAL @@ -39,13 +40,6 @@ #define SDL_AddTimer SDL_AddTimer_REAL #define SDL_AddTimerNS SDL_AddTimerNS_REAL #define SDL_AddVulkanRenderSemaphores SDL_AddVulkanRenderSemaphores_REAL -#define SDL_AtomicAdd SDL_AtomicAdd_REAL -#define SDL_AtomicCompareAndSwap SDL_AtomicCompareAndSwap_REAL -#define SDL_AtomicCompareAndSwapPointer SDL_AtomicCompareAndSwapPointer_REAL -#define SDL_AtomicGet SDL_AtomicGet_REAL -#define SDL_AtomicGetPointer SDL_AtomicGetPointer_REAL -#define SDL_AtomicSet SDL_AtomicSet_REAL -#define SDL_AtomicSetPointer SDL_AtomicSetPointer_REAL #define SDL_AttachVirtualJoystick SDL_AttachVirtualJoystick_REAL #define SDL_AudioDevicePaused SDL_AudioDevicePaused_REAL #define SDL_BeginGPUComputePass SDL_BeginGPUComputePass_REAL @@ -92,6 +86,8 @@ #define SDL_CloseJoystick SDL_CloseJoystick_REAL #define SDL_CloseSensor SDL_CloseSensor_REAL #define SDL_CloseStorage SDL_CloseStorage_REAL +#define SDL_CompareAndSwapAtomicInt SDL_CompareAndSwapAtomicInt_REAL +#define SDL_CompareAndSwapAtomicPointer SDL_CompareAndSwapAtomicPointer_REAL #define SDL_ComposeCustomBlendMode SDL_ComposeCustomBlendMode_REAL #define SDL_ConvertAudioSamples SDL_ConvertAudioSamples_REAL #define SDL_ConvertEventToRenderCoordinates SDL_ConvertEventToRenderCoordinates_REAL @@ -242,6 +238,8 @@ #define SDL_GetAppMetadataProperty SDL_GetAppMetadataProperty_REAL #define SDL_GetAssertionHandler SDL_GetAssertionHandler_REAL #define SDL_GetAssertionReport SDL_GetAssertionReport_REAL +#define SDL_GetAtomicInt SDL_GetAtomicInt_REAL +#define SDL_GetAtomicPointer SDL_GetAtomicPointer_REAL #define SDL_GetAudioDeviceChannelMap SDL_GetAudioDeviceChannelMap_REAL #define SDL_GetAudioDeviceFormat SDL_GetAudioDeviceFormat_REAL #define SDL_GetAudioDeviceGain SDL_GetAudioDeviceGain_REAL @@ -805,6 +803,8 @@ #define SDL_SetAppMetadata SDL_SetAppMetadata_REAL #define SDL_SetAppMetadataProperty SDL_SetAppMetadataProperty_REAL #define SDL_SetAssertionHandler SDL_SetAssertionHandler_REAL +#define SDL_SetAtomicInt SDL_SetAtomicInt_REAL +#define SDL_SetAtomicPointer SDL_SetAtomicPointer_REAL #define SDL_SetAudioDeviceGain SDL_SetAudioDeviceGain_REAL #define SDL_SetAudioPostmixCallback SDL_SetAudioPostmixCallback_REAL #define SDL_SetAudioStreamFormat SDL_SetAudioStreamFormat_REAL diff --git a/src/dynapi/SDL_dynapi_procs.h b/src/dynapi/SDL_dynapi_procs.h index eacfbc71e3..b32aa91696 100644 --- a/src/dynapi/SDL_dynapi_procs.h +++ b/src/dynapi/SDL_dynapi_procs.h @@ -51,6 +51,7 @@ SDL_DYNAPI_PROC(int,SDL_swprintf,(SDL_OUT_Z_CAP(b) wchar_t *a, size_t b, SDL_PRI SDL_DYNAPI_PROC(SDL_Surface*,SDL_AcquireCameraFrame,(SDL_Camera *a, Uint64 *b),(a,b),return) SDL_DYNAPI_PROC(SDL_GPUCommandBuffer*,SDL_AcquireGPUCommandBuffer,(SDL_GPUDevice *a),(a),return) SDL_DYNAPI_PROC(SDL_GPUTexture*,SDL_AcquireGPUSwapchainTexture,(SDL_GPUCommandBuffer *a, SDL_Window *b, Uint32 *c, Uint32 *d),(a,b,c,d),return) +SDL_DYNAPI_PROC(int,SDL_AddAtomicInt,(SDL_AtomicInt *a, int b),(a,b),return) SDL_DYNAPI_PROC(SDL_bool,SDL_AddEventWatch,(SDL_EventFilter a, void *b),(a,b),return) SDL_DYNAPI_PROC(int,SDL_AddGamepadMapping,(const char *a),(a),return) SDL_DYNAPI_PROC(int,SDL_AddGamepadMappingsFromFile,(const char *a),(a),return) @@ -60,13 +61,6 @@ SDL_DYNAPI_PROC(SDL_bool,SDL_AddSurfaceAlternateImage,(SDL_Surface *a, SDL_Surfa SDL_DYNAPI_PROC(SDL_TimerID,SDL_AddTimer,(Uint32 a, SDL_TimerCallback b, void *c),(a,b,c),return) SDL_DYNAPI_PROC(SDL_TimerID,SDL_AddTimerNS,(Uint64 a, SDL_NSTimerCallback b, void *c),(a,b,c),return) SDL_DYNAPI_PROC(SDL_bool,SDL_AddVulkanRenderSemaphores,(SDL_Renderer *a, Uint32 b, Sint64 c, Sint64 d),(a,b,c,d),return) -SDL_DYNAPI_PROC(int,SDL_AtomicAdd,(SDL_AtomicInt *a, int b),(a,b),return) -SDL_DYNAPI_PROC(SDL_bool,SDL_AtomicCompareAndSwap,(SDL_AtomicInt *a, int b, int c),(a,b,c),return) -SDL_DYNAPI_PROC(SDL_bool,SDL_AtomicCompareAndSwapPointer,(void **a, void *b, void *c),(a,b,c),return) -SDL_DYNAPI_PROC(int,SDL_AtomicGet,(SDL_AtomicInt *a),(a),return) -SDL_DYNAPI_PROC(void*,SDL_AtomicGetPointer,(void **a),(a),return) -SDL_DYNAPI_PROC(int,SDL_AtomicSet,(SDL_AtomicInt *a, int b),(a,b),return) -SDL_DYNAPI_PROC(void*,SDL_AtomicSetPointer,(void **a, void *b),(a,b),return) SDL_DYNAPI_PROC(SDL_JoystickID,SDL_AttachVirtualJoystick,(const SDL_VirtualJoystickDesc *a),(a),return) SDL_DYNAPI_PROC(SDL_bool,SDL_AudioDevicePaused,(SDL_AudioDeviceID a),(a),return) SDL_DYNAPI_PROC(SDL_GPUComputePass*,SDL_BeginGPUComputePass,(SDL_GPUCommandBuffer *a, const SDL_GPUStorageTextureWriteOnlyBinding *b, Uint32 c, const SDL_GPUStorageBufferWriteOnlyBinding *d, Uint32 e),(a,b,c,d,e),return) @@ -113,6 +107,8 @@ SDL_DYNAPI_PROC(SDL_bool,SDL_CloseIO,(SDL_IOStream *a),(a),return) SDL_DYNAPI_PROC(void,SDL_CloseJoystick,(SDL_Joystick *a),(a),) SDL_DYNAPI_PROC(void,SDL_CloseSensor,(SDL_Sensor *a),(a),) SDL_DYNAPI_PROC(SDL_bool,SDL_CloseStorage,(SDL_Storage *a),(a),return) +SDL_DYNAPI_PROC(SDL_bool,SDL_CompareAndSwapAtomicInt,(SDL_AtomicInt *a, int b, int c),(a,b,c),return) +SDL_DYNAPI_PROC(SDL_bool,SDL_CompareAndSwapAtomicPointer,(void **a, void *b, void *c),(a,b,c),return) SDL_DYNAPI_PROC(SDL_BlendMode,SDL_ComposeCustomBlendMode,(SDL_BlendFactor a, SDL_BlendFactor b, SDL_BlendOperation c, SDL_BlendFactor d, SDL_BlendFactor e, SDL_BlendOperation f),(a,b,c,d,e,f),return) SDL_DYNAPI_PROC(SDL_bool,SDL_ConvertAudioSamples,(const SDL_AudioSpec *a, const Uint8 *b, int c, const SDL_AudioSpec *d, Uint8 **e, int *f),(a,b,c,d,e,f),return) SDL_DYNAPI_PROC(SDL_bool,SDL_ConvertEventToRenderCoordinates,(SDL_Renderer *a, SDL_Event *b),(a,b),return) @@ -263,6 +259,8 @@ SDL_DYNAPI_PROC(int,SDL_GetAndroidSDKVersion,(void),(),return) SDL_DYNAPI_PROC(const char*,SDL_GetAppMetadataProperty,(const char *a),(a),return) SDL_DYNAPI_PROC(SDL_AssertionHandler,SDL_GetAssertionHandler,(void **a),(a),return) SDL_DYNAPI_PROC(const SDL_AssertData*,SDL_GetAssertionReport,(void),(),return) +SDL_DYNAPI_PROC(int,SDL_GetAtomicInt,(SDL_AtomicInt *a),(a),return) +SDL_DYNAPI_PROC(void*,SDL_GetAtomicPointer,(void **a),(a),return) SDL_DYNAPI_PROC(int*,SDL_GetAudioDeviceChannelMap,(SDL_AudioDeviceID a, int *b),(a,b),return) SDL_DYNAPI_PROC(SDL_bool,SDL_GetAudioDeviceFormat,(SDL_AudioDeviceID a, SDL_AudioSpec *b, int *c),(a,b,c),return) SDL_DYNAPI_PROC(float,SDL_GetAudioDeviceGain,(SDL_AudioDeviceID a),(a),return) @@ -816,6 +814,8 @@ SDL_DYNAPI_PROC(SDL_bool,SDL_SendJoystickVirtualSensorData,(SDL_Joystick *a, SDL SDL_DYNAPI_PROC(SDL_bool,SDL_SetAppMetadata,(const char *a, const char *b, const char *c),(a,b,c),return) SDL_DYNAPI_PROC(SDL_bool,SDL_SetAppMetadataProperty,(const char *a, const char *b),(a,b),return) SDL_DYNAPI_PROC(void,SDL_SetAssertionHandler,(SDL_AssertionHandler a, void *b),(a,b),) +SDL_DYNAPI_PROC(int,SDL_SetAtomicInt,(SDL_AtomicInt *a, int b),(a,b),return) +SDL_DYNAPI_PROC(void*,SDL_SetAtomicPointer,(void **a, void *b),(a,b),return) SDL_DYNAPI_PROC(SDL_bool,SDL_SetAudioDeviceGain,(SDL_AudioDeviceID a, float b),(a,b),return) SDL_DYNAPI_PROC(SDL_bool,SDL_SetAudioPostmixCallback,(SDL_AudioDeviceID a, SDL_AudioPostmixCallback b, void *c),(a,b,c),return) SDL_DYNAPI_PROC(SDL_bool,SDL_SetAudioStreamFormat,(SDL_AudioStream *a, const SDL_AudioSpec *b, const SDL_AudioSpec *c),(a,b,c),return) diff --git a/src/events/SDL_events.c b/src/events/SDL_events.c index 161a52f6f3..437b39f487 100644 --- a/src/events/SDL_events.c +++ b/src/events/SDL_events.c @@ -852,12 +852,12 @@ void SDL_StopEventLoop(void) entry = next; } - SDL_AtomicSet(&SDL_EventQ.count, 0); + SDL_SetAtomicInt(&SDL_EventQ.count, 0); SDL_EventQ.max_events_seen = 0; SDL_EventQ.head = NULL; SDL_EventQ.tail = NULL; SDL_EventQ.free = NULL; - SDL_AtomicSet(&SDL_sentinel_pending, 0); + SDL_SetAtomicInt(&SDL_sentinel_pending, 0); // Clear disabled event state for (i = 0; i < SDL_arraysize(SDL_disabled_events); ++i) { @@ -921,7 +921,7 @@ bool SDL_StartEventLoop(void) static int SDL_AddEvent(SDL_Event *event) { SDL_EventEntry *entry; - const int initial_count = SDL_AtomicGet(&SDL_EventQ.count); + const int initial_count = SDL_GetAtomicInt(&SDL_EventQ.count); int final_count; if (initial_count >= SDL_MAX_QUEUED_EVENTS) { @@ -945,7 +945,7 @@ static int SDL_AddEvent(SDL_Event *event) SDL_copyp(&entry->event, event); if (event->type == SDL_EVENT_POLL_SENTINEL) { - SDL_AtomicAdd(&SDL_sentinel_pending, 1); + SDL_AddAtomicInt(&SDL_sentinel_pending, 1); } entry->memory = NULL; SDL_TransferTemporaryMemoryToEvent(entry); @@ -963,7 +963,7 @@ static int SDL_AddEvent(SDL_Event *event) entry->next = NULL; } - final_count = SDL_AtomicAdd(&SDL_EventQ.count, 1) + 1; + final_count = SDL_AddAtomicInt(&SDL_EventQ.count, 1) + 1; if (final_count > SDL_EventQ.max_events_seen) { SDL_EventQ.max_events_seen = final_count; } @@ -995,13 +995,13 @@ static void SDL_CutEvent(SDL_EventEntry *entry) } if (entry->event.type == SDL_EVENT_POLL_SENTINEL) { - SDL_AtomicAdd(&SDL_sentinel_pending, -1); + SDL_AddAtomicInt(&SDL_sentinel_pending, -1); } entry->next = SDL_EventQ.free; SDL_EventQ.free = entry; - SDL_assert(SDL_AtomicGet(&SDL_EventQ.count) > 0); - SDL_AtomicAdd(&SDL_EventQ.count, -1); + SDL_assert(SDL_GetAtomicInt(&SDL_EventQ.count) > 0); + SDL_AddAtomicInt(&SDL_EventQ.count, -1); } static void SDL_SendWakeupEvent(void) @@ -1079,7 +1079,7 @@ static int SDL_PeepEventsInternal(SDL_Event *events, int numevents, SDL_EventAct if (events == NULL || action != SDL_GETEVENT) { ++sentinels_expected; } - if (SDL_AtomicGet(&SDL_sentinel_pending) > sentinels_expected) { + if (SDL_GetAtomicInt(&SDL_sentinel_pending) > sentinels_expected) { // Skip it, there's another one pending continue; } @@ -1198,7 +1198,7 @@ static void SDL_PumpEventsInternal(bool push_sentinel) SDL_Event sentinel; // Make sure we don't already have a sentinel in the queue, and add one to the end - if (SDL_AtomicGet(&SDL_sentinel_pending) > 0) { + if (SDL_GetAtomicInt(&SDL_sentinel_pending) > 0) { SDL_PeepEventsInternal(&sentinel, 1, SDL_GETEVENT, SDL_EVENT_POLL_SENTINEL, SDL_EVENT_POLL_SENTINEL, true); } @@ -1362,7 +1362,7 @@ SDL_bool SDL_WaitEventTimeoutNS(SDL_Event *event, Sint64 timeoutNS) } // If there isn't a poll sentinel event pending, pump events and add one - if (SDL_AtomicGet(&SDL_sentinel_pending) == 0) { + if (SDL_GetAtomicInt(&SDL_sentinel_pending) == 0) { SDL_PumpEventsInternal(true); } diff --git a/src/events/SDL_pen.c b/src/events/SDL_pen.c index 63d1c975e4..16b2195d92 100644 --- a/src/events/SDL_pen.c +++ b/src/events/SDL_pen.c @@ -343,7 +343,7 @@ void SDL_SendPenTouch(Uint64 timestamp, SDL_PenID instance_id, const SDL_Window send_event = true; } - pen->input_state = input_state; // we could do an SDL_AtomicSet here if we run into trouble... + pen->input_state = input_state; // we could do an SDL_SetAtomicInt here if we run into trouble... } SDL_UnlockRWLock(pen_device_rwlock); @@ -383,7 +383,7 @@ void SDL_SendPenAxis(Uint64 timestamp, SDL_PenID instance_id, const SDL_Window * SDL_Pen *pen = FindPenByInstanceId(instance_id); if (pen) { if (pen->axes[axis] != value) { - pen->axes[axis] = value; // we could do an SDL_AtomicSet here if we run into trouble... + pen->axes[axis] = value; // we could do an SDL_SetAtomicInt here if we run into trouble... input_state = pen->input_state; x = pen->x; y = pen->y; @@ -421,8 +421,8 @@ void SDL_SendPenMotion(Uint64 timestamp, SDL_PenID instance_id, const SDL_Window SDL_Pen *pen = FindPenByInstanceId(instance_id); if (pen) { if ((pen->x != x) || (pen->y != y)) { - pen->x = x; // we could do an SDL_AtomicSet here if we run into trouble... - pen->y = y; // we could do an SDL_AtomicSet here if we run into trouble... + pen->x = x; // we could do an SDL_SetAtomicInt here if we run into trouble... + pen->y = y; // we could do an SDL_SetAtomicInt here if we run into trouble... input_state = pen->input_state; send_event = true; } @@ -473,7 +473,7 @@ void SDL_SendPenButton(Uint64 timestamp, SDL_PenID instance_id, const SDL_Window input_state &= ~flag; send_event = true; } - pen->input_state = input_state; // we could do an SDL_AtomicSet here if we run into trouble... + pen->input_state = input_state; // we could do an SDL_SetAtomicInt here if we run into trouble... } SDL_UnlockRWLock(pen_device_rwlock); diff --git a/src/gpu/d3d11/SDL_gpu_d3d11.c b/src/gpu/d3d11/SDL_gpu_d3d11.c index b78c00c54e..8dfaf3efbb 100644 --- a/src/gpu/d3d11/SDL_gpu_d3d11.c +++ b/src/gpu/d3d11/SDL_gpu_d3d11.c @@ -2028,7 +2028,7 @@ static D3D11Texture *D3D11_INTERNAL_CreateTexture( d3d11Texture = (D3D11Texture *)SDL_malloc(sizeof(D3D11Texture)); d3d11Texture->handle = textureHandle; d3d11Texture->shaderView = srv; - SDL_AtomicSet(&d3d11Texture->referenceCount, 0); + SDL_SetAtomicInt(&d3d11Texture->referenceCount, 0); d3d11Texture->container = NULL; d3d11Texture->containerIndex = 0; @@ -2204,7 +2204,7 @@ static void D3D11_INTERNAL_CycleActiveTexture( D3D11TextureContainer *container) { for (Uint32 i = 0; i < container->textureCount; i += 1) { - if (SDL_AtomicGet(&container->textures[i]->referenceCount) == 0) { + if (SDL_GetAtomicInt(&container->textures[i]->referenceCount) == 0) { container->activeTexture = container->textures[i]; return; } @@ -2270,7 +2270,7 @@ static D3D11TextureSubresource *D3D11_INTERNAL_PrepareTextureSubresourceForWrite if ( container->canBeCycled && cycle && - SDL_AtomicGet(&subresource->parent->referenceCount) > 0) { + SDL_GetAtomicInt(&subresource->parent->referenceCount) > 0) { D3D11_INTERNAL_CycleActiveTexture( renderer, container); @@ -2351,7 +2351,7 @@ static D3D11Buffer *D3D11_INTERNAL_CreateBuffer( d3d11Buffer->size = size; d3d11Buffer->uav = uav; d3d11Buffer->srv = srv; - SDL_AtomicSet(&d3d11Buffer->referenceCount, 0); + SDL_SetAtomicInt(&d3d11Buffer->referenceCount, 0); return d3d11Buffer; } @@ -2460,7 +2460,7 @@ static void D3D11_INTERNAL_CycleActiveBuffer( Uint32 size = container->activeBuffer->size; for (Uint32 i = 0; i < container->bufferCount; i += 1) { - if (SDL_AtomicGet(&container->buffers[i]->referenceCount) == 0) { + if (SDL_GetAtomicInt(&container->buffers[i]->referenceCount) == 0) { container->activeBuffer = container->buffers[i]; return; } @@ -2496,7 +2496,7 @@ static D3D11Buffer *D3D11_INTERNAL_PrepareBufferForWrite( { if ( cycle && - SDL_AtomicGet(&container->activeBuffer->referenceCount) > 0) { + SDL_GetAtomicInt(&container->activeBuffer->referenceCount) > 0) { D3D11_INTERNAL_CycleActiveBuffer( renderer, container); @@ -2513,7 +2513,7 @@ static D3D11TransferBuffer *D3D11_INTERNAL_CreateTransferBuffer( transferBuffer->data = (Uint8 *)SDL_malloc(size); transferBuffer->size = size; - SDL_AtomicSet(&transferBuffer->referenceCount, 0); + SDL_SetAtomicInt(&transferBuffer->referenceCount, 0); transferBuffer->bufferDownloads = NULL; transferBuffer->bufferDownloadCount = 0; @@ -2558,7 +2558,7 @@ static void D3D11_INTERNAL_CycleActiveTransferBuffer( Uint32 size = container->activeBuffer->size; for (Uint32 i = 0; i < container->bufferCount; i += 1) { - if (SDL_AtomicGet(&container->buffers[i]->referenceCount) == 0) { + if (SDL_GetAtomicInt(&container->buffers[i]->referenceCount) == 0) { container->activeBuffer = container->buffers[i]; return; } @@ -2591,7 +2591,7 @@ static void *D3D11_MapTransferBuffer( // Rotate the transfer buffer if necessary if ( cycle && - SDL_AtomicGet(&container->activeBuffer->referenceCount) > 0) { + SDL_GetAtomicInt(&container->activeBuffer->referenceCount) > 0) { D3D11_INTERNAL_CycleActiveTransferBuffer( renderer, container); @@ -3126,7 +3126,7 @@ static bool D3D11_INTERNAL_CreateFence( fence = SDL_malloc(sizeof(D3D11Fence)); fence->handle = queryHandle; - SDL_AtomicSet(&fence->referenceCount, 0); + SDL_SetAtomicInt(&fence->referenceCount, 0); // Add it to the available pool if (renderer->availableFenceCount >= renderer->availableFenceCapacity) { @@ -4839,7 +4839,7 @@ static void D3D11_INTERNAL_PerformPendingDestroys( for (i = renderer->transferBufferContainersToDestroyCount - 1; i >= 0; i -= 1) { referenceCount = 0; for (j = 0; j < renderer->transferBufferContainersToDestroy[i]->bufferCount; j += 1) { - referenceCount += SDL_AtomicGet(&renderer->transferBufferContainersToDestroy[i]->buffers[j]->referenceCount); + referenceCount += SDL_GetAtomicInt(&renderer->transferBufferContainersToDestroy[i]->buffers[j]->referenceCount); } if (referenceCount == 0) { @@ -4854,7 +4854,7 @@ static void D3D11_INTERNAL_PerformPendingDestroys( for (i = renderer->bufferContainersToDestroyCount - 1; i >= 0; i -= 1) { referenceCount = 0; for (j = 0; j < renderer->bufferContainersToDestroy[i]->bufferCount; j += 1) { - referenceCount += SDL_AtomicGet(&renderer->bufferContainersToDestroy[i]->buffers[j]->referenceCount); + referenceCount += SDL_GetAtomicInt(&renderer->bufferContainersToDestroy[i]->buffers[j]->referenceCount); } if (referenceCount == 0) { @@ -4869,7 +4869,7 @@ static void D3D11_INTERNAL_PerformPendingDestroys( for (i = renderer->textureContainersToDestroyCount - 1; i >= 0; i -= 1) { referenceCount = 0; for (j = 0; j < renderer->textureContainersToDestroy[i]->textureCount; j += 1) { - referenceCount += SDL_AtomicGet(&renderer->textureContainersToDestroy[i]->textures[j]->referenceCount); + referenceCount += SDL_GetAtomicInt(&renderer->textureContainersToDestroy[i]->textures[j]->referenceCount); } if (referenceCount == 0) { @@ -5038,7 +5038,7 @@ static bool D3D11_INTERNAL_InitializeSwapchainTexture( // Fill out the texture struct pTexture->handle = NULL; // This will be set in AcquireSwapchainTexture. pTexture->shaderView = NULL; // We don't allow swapchain texture to be sampled - SDL_AtomicSet(&pTexture->referenceCount, 0); + SDL_SetAtomicInt(&pTexture->referenceCount, 0); pTexture->subresourceCount = 1; pTexture->subresources = SDL_malloc(sizeof(D3D11TextureSubresource)); pTexture->subresources[0].colorTargetViews = SDL_calloc(1, sizeof(ID3D11RenderTargetView *)); diff --git a/src/gpu/d3d12/SDL_gpu_d3d12.c b/src/gpu/d3d12/SDL_gpu_d3d12.c index 06e60744fd..26efd76860 100644 --- a/src/gpu/d3d12/SDL_gpu_d3d12.c +++ b/src/gpu/d3d12/SDL_gpu_d3d12.c @@ -2397,7 +2397,7 @@ static SDL_GPUComputePipeline *D3D12_CreateComputePipeline( computePipeline->numWriteOnlyStorageTextures = createinfo->num_writeonly_storage_textures; computePipeline->numWriteOnlyStorageBuffers = createinfo->num_writeonly_storage_buffers; computePipeline->numUniformBuffers = createinfo->num_uniform_buffers; - SDL_AtomicSet(&computePipeline->referenceCount, 0); + SDL_SetAtomicInt(&computePipeline->referenceCount, 0); return (SDL_GPUComputePipeline *)computePipeline; } @@ -2679,7 +2679,7 @@ static SDL_GPUGraphicsPipeline *D3D12_CreateGraphicsPipeline( pipeline->fragmentStorageBufferCount = fragShader->numStorageBuffers; pipeline->fragmentUniformBufferCount = fragShader->numUniformBuffers; - SDL_AtomicSet(&pipeline->referenceCount, 0); + SDL_SetAtomicInt(&pipeline->referenceCount, 0); return (SDL_GPUGraphicsPipeline *)pipeline; } @@ -2724,7 +2724,7 @@ static SDL_GPUSampler *D3D12_CreateSampler( sampler->handle.cpuHandle); sampler->createInfo = *createinfo; - SDL_AtomicSet(&sampler->referenceCount, 0); + SDL_SetAtomicInt(&sampler->referenceCount, 0); return (SDL_GPUSampler *)sampler; } @@ -2917,7 +2917,7 @@ static D3D12Texture *D3D12_INTERNAL_CreateTexture( texture->srvHandle.cpuHandle); } - SDL_AtomicSet(&texture->referenceCount, 0); + SDL_SetAtomicInt(&texture->referenceCount, 0); texture->subresourceCount = createinfo->num_levels * layerCount; texture->subresources = (D3D12TextureSubresource *)SDL_calloc( @@ -3200,7 +3200,7 @@ static D3D12Buffer *D3D12_INTERNAL_CreateBuffer( } buffer->handle = handle; - SDL_AtomicSet(&buffer->referenceCount, 0); + SDL_SetAtomicInt(&buffer->referenceCount, 0); buffer->uavDescriptor.heap = NULL; buffer->srvDescriptor.heap = NULL; @@ -3294,7 +3294,7 @@ static D3D12Buffer *D3D12_INTERNAL_CreateBuffer( buffer->containerIndex = 0; buffer->transitioned = initialState != D3D12_RESOURCE_STATE_COMMON; - SDL_AtomicSet(&buffer->referenceCount, 0); + SDL_SetAtomicInt(&buffer->referenceCount, 0); return buffer; } @@ -3734,7 +3734,7 @@ static void D3D12_INTERNAL_CycleActiveTexture( for (Uint32 i = 0; i < container->textureCount; i += 1) { texture = container->textures[i]; - if (SDL_AtomicGet(&texture->referenceCount) == 0) { + if (SDL_GetAtomicInt(&texture->referenceCount) == 0) { container->activeTexture = texture; return; } @@ -3789,7 +3789,7 @@ static D3D12TextureSubresource *D3D12_INTERNAL_PrepareTextureSubresourceForWrite if ( container->canBeCycled && cycle && - SDL_AtomicGet(&subresource->parent->referenceCount) > 0) { + SDL_GetAtomicInt(&subresource->parent->referenceCount) > 0) { D3D12_INTERNAL_CycleActiveTexture( commandBuffer->renderer, container); @@ -3815,7 +3815,7 @@ static void D3D12_INTERNAL_CycleActiveBuffer( // If a previously-cycled buffer is available, we can use that. for (Uint32 i = 0; i < container->bufferCount; i += 1) { D3D12Buffer *buffer = container->buffers[i]; - if (SDL_AtomicGet(&buffer->referenceCount) == 0) { + if (SDL_GetAtomicInt(&buffer->referenceCount) == 0) { container->activeBuffer = buffer; return; } @@ -3863,7 +3863,7 @@ static D3D12Buffer *D3D12_INTERNAL_PrepareBufferForWrite( { if ( cycle && - SDL_AtomicGet(&container->activeBuffer->referenceCount) > 0) { + SDL_GetAtomicInt(&container->activeBuffer->referenceCount) > 0) { D3D12_INTERNAL_CycleActiveBuffer( commandBuffer->renderer, container); @@ -5320,7 +5320,7 @@ static void *D3D12_MapTransferBuffer( if ( cycle && - SDL_AtomicGet(&container->activeBuffer->referenceCount) > 0) { + SDL_GetAtomicInt(&container->activeBuffer->referenceCount) > 0) { D3D12_INTERNAL_CycleActiveBuffer( renderer, container); @@ -6177,7 +6177,7 @@ static bool D3D12_INTERNAL_InitializeSwapchainTexture( return false; } pTexture->resource = NULL; // This will be set in AcquireSwapchainTexture - SDL_AtomicSet(&pTexture->referenceCount, 0); + SDL_SetAtomicInt(&pTexture->referenceCount, 0); pTexture->subresourceCount = 1; pTexture->subresources = (D3D12TextureSubresource *)SDL_calloc(1, sizeof(D3D12TextureSubresource)); if (!pTexture->subresources) { @@ -6671,7 +6671,7 @@ static D3D12Fence *D3D12_INTERNAL_AcquireFence( } fence->handle = handle; fence->event = CreateEventEx(NULL, 0, 0, EVENT_ALL_ACCESS); - SDL_AtomicSet(&fence->referenceCount, 0); + SDL_SetAtomicInt(&fence->referenceCount, 0); } else { fence = renderer->availableFences[renderer->availableFenceCount - 1]; renderer->availableFenceCount -= 1; @@ -7000,7 +7000,7 @@ static void D3D12_INTERNAL_PerformPendingDestroys(D3D12Renderer *renderer) SDL_LockMutex(renderer->disposeLock); for (Sint32 i = renderer->buffersToDestroyCount - 1; i >= 0; i -= 1) { - if (SDL_AtomicGet(&renderer->buffersToDestroy[i]->referenceCount) == 0) { + if (SDL_GetAtomicInt(&renderer->buffersToDestroy[i]->referenceCount) == 0) { D3D12_INTERNAL_DestroyBuffer( renderer, renderer->buffersToDestroy[i]); @@ -7011,7 +7011,7 @@ static void D3D12_INTERNAL_PerformPendingDestroys(D3D12Renderer *renderer) } for (Sint32 i = renderer->texturesToDestroyCount - 1; i >= 0; i -= 1) { - if (SDL_AtomicGet(&renderer->texturesToDestroy[i]->referenceCount) == 0) { + if (SDL_GetAtomicInt(&renderer->texturesToDestroy[i]->referenceCount) == 0) { D3D12_INTERNAL_DestroyTexture( renderer, renderer->texturesToDestroy[i]); @@ -7022,7 +7022,7 @@ static void D3D12_INTERNAL_PerformPendingDestroys(D3D12Renderer *renderer) } for (Sint32 i = renderer->samplersToDestroyCount - 1; i >= 0; i -= 1) { - if (SDL_AtomicGet(&renderer->samplersToDestroy[i]->referenceCount) == 0) { + if (SDL_GetAtomicInt(&renderer->samplersToDestroy[i]->referenceCount) == 0) { D3D12_INTERNAL_DestroySampler( renderer, renderer->samplersToDestroy[i]); @@ -7033,7 +7033,7 @@ static void D3D12_INTERNAL_PerformPendingDestroys(D3D12Renderer *renderer) } for (Sint32 i = renderer->graphicsPipelinesToDestroyCount - 1; i >= 0; i -= 1) { - if (SDL_AtomicGet(&renderer->graphicsPipelinesToDestroy[i]->referenceCount) == 0) { + if (SDL_GetAtomicInt(&renderer->graphicsPipelinesToDestroy[i]->referenceCount) == 0) { D3D12_INTERNAL_DestroyGraphicsPipeline( renderer->graphicsPipelinesToDestroy[i]); @@ -7043,7 +7043,7 @@ static void D3D12_INTERNAL_PerformPendingDestroys(D3D12Renderer *renderer) } for (Sint32 i = renderer->computePipelinesToDestroyCount - 1; i >= 0; i -= 1) { - if (SDL_AtomicGet(&renderer->computePipelinesToDestroy[i]->referenceCount) == 0) { + if (SDL_GetAtomicInt(&renderer->computePipelinesToDestroy[i]->referenceCount) == 0) { D3D12_INTERNAL_DestroyComputePipeline( renderer->computePipelinesToDestroy[i]); diff --git a/src/gpu/metal/SDL_gpu_metal.m b/src/gpu/metal/SDL_gpu_metal.m index d6cae98f96..95a400a790 100644 --- a/src/gpu/metal/SDL_gpu_metal.m +++ b/src/gpu/metal/SDL_gpu_metal.m @@ -1361,7 +1361,7 @@ static MetalTexture *METAL_INTERNAL_CreateTexture( metalTexture = (MetalTexture *)SDL_calloc(1, sizeof(MetalTexture)); metalTexture->handle = texture; - SDL_AtomicSet(&metalTexture->referenceCount, 0); + SDL_SetAtomicInt(&metalTexture->referenceCount, 0); return metalTexture; } @@ -1421,7 +1421,7 @@ static MetalTexture *METAL_INTERNAL_PrepareTextureForWrite( // Cycle the active texture handle if needed if (cycle && container->canBeCycled) { for (i = 0; i < container->textureCount; i += 1) { - if (SDL_AtomicGet(&container->textures[i]->referenceCount) == 0) { + if (SDL_GetAtomicInt(&container->textures[i]->referenceCount) == 0) { container->activeTexture = container->textures[i]; return container->activeTexture; } @@ -1469,7 +1469,7 @@ static MetalBuffer *METAL_INTERNAL_CreateBuffer( metalBuffer = SDL_calloc(1, sizeof(MetalBuffer)); metalBuffer->handle = bufferHandle; - SDL_AtomicSet(&metalBuffer->referenceCount, 0); + SDL_SetAtomicInt(&metalBuffer->referenceCount, 0); return metalBuffer; } @@ -1572,9 +1572,9 @@ static MetalBuffer *METAL_INTERNAL_PrepareBufferForWrite( Uint32 i; // Cycle if needed - if (cycle && SDL_AtomicGet(&container->activeBuffer->referenceCount) > 0) { + if (cycle && SDL_GetAtomicInt(&container->activeBuffer->referenceCount) > 0) { for (i = 0; i < container->bufferCount; i += 1) { - if (SDL_AtomicGet(&container->buffers[i]->referenceCount) == 0) { + if (SDL_GetAtomicInt(&container->buffers[i]->referenceCount) == 0) { container->activeBuffer = container->buffers[i]; return container->activeBuffer; } @@ -1945,7 +1945,7 @@ static Uint8 METAL_INTERNAL_CreateFence( MetalFence *fence; fence = SDL_calloc(1, sizeof(MetalFence)); - SDL_AtomicSet(&fence->complete, 0); + SDL_SetAtomicInt(&fence->complete, 0); // Add it to the available pool // FIXME: Should this be EXPAND_IF_NEEDED? @@ -1987,7 +1987,7 @@ static Uint8 METAL_INTERNAL_AcquireFence( // Associate the fence with the command buffer commandBuffer->fence = fence; - SDL_AtomicSet(&fence->complete, 0); // FIXME: Is this right? + SDL_SetAtomicInt(&fence->complete, 0); // FIXME: Is this right? return 1; } @@ -3297,7 +3297,7 @@ static void METAL_INTERNAL_PerformPendingDestroys( for (i = renderer->bufferContainersToDestroyCount - 1; i >= 0; i -= 1) { referenceCount = 0; for (j = 0; j < renderer->bufferContainersToDestroy[i]->bufferCount; j += 1) { - referenceCount += SDL_AtomicGet(&renderer->bufferContainersToDestroy[i]->buffers[j]->referenceCount); + referenceCount += SDL_GetAtomicInt(&renderer->bufferContainersToDestroy[i]->buffers[j]->referenceCount); } if (referenceCount == 0) { @@ -3312,7 +3312,7 @@ static void METAL_INTERNAL_PerformPendingDestroys( for (i = renderer->textureContainersToDestroyCount - 1; i >= 0; i -= 1) { referenceCount = 0; for (j = 0; j < renderer->textureContainersToDestroy[i]->textureCount; j += 1) { - referenceCount += SDL_AtomicGet(&renderer->textureContainersToDestroy[i]->textures[j]->referenceCount); + referenceCount += SDL_GetAtomicInt(&renderer->textureContainersToDestroy[i]->textures[j]->referenceCount); } if (referenceCount == 0) { @@ -3339,7 +3339,7 @@ static void METAL_WaitForFences( if (waitAll) { for (Uint32 i = 0; i < numFences; i += 1) { - while (!SDL_AtomicGet(&((MetalFence *)fences[i])->complete)) { + while (!SDL_GetAtomicInt(&((MetalFence *)fences[i])->complete)) { // Spin! } } @@ -3347,7 +3347,7 @@ static void METAL_WaitForFences( waiting = 1; while (waiting) { for (Uint32 i = 0; i < numFences; i += 1) { - if (SDL_AtomicGet(&((MetalFence *)fences[i])->complete) > 0) { + if (SDL_GetAtomicInt(&((MetalFence *)fences[i])->complete) > 0) { waiting = 0; break; } @@ -3364,7 +3364,7 @@ static bool METAL_QueryFence( SDL_GPUFence *fence) { MetalFence *metalFence = (MetalFence *)fence; - return SDL_AtomicGet(&metalFence->complete) == 1; + return SDL_GetAtomicInt(&metalFence->complete) == 1; } // Window and Swapchain Management @@ -3688,7 +3688,7 @@ static void METAL_Submit( // Check if we can perform any cleanups for (Sint32 i = renderer->submittedCommandBufferCount - 1; i >= 0; i -= 1) { - if (SDL_AtomicGet(&renderer->submittedCommandBuffers[i]->fence->complete)) { + if (SDL_GetAtomicInt(&renderer->submittedCommandBuffers[i]->fence->complete)) { METAL_INTERNAL_CleanCommandBuffer( renderer, renderer->submittedCommandBuffers[i]); @@ -3725,7 +3725,7 @@ static void METAL_Wait( * Sort of equivalent to vkDeviceWaitIdle. */ for (Uint32 i = 0; i < renderer->submittedCommandBufferCount; i += 1) { - while (!SDL_AtomicGet(&renderer->submittedCommandBuffers[i]->fence->complete)) { + while (!SDL_GetAtomicInt(&renderer->submittedCommandBuffers[i]->fence->complete)) { // Spin! } } diff --git a/src/gpu/vulkan/SDL_gpu_vulkan.c b/src/gpu/vulkan/SDL_gpu_vulkan.c index 4f951788d6..32cb795c8a 100644 --- a/src/gpu/vulkan/SDL_gpu_vulkan.c +++ b/src/gpu/vulkan/SDL_gpu_vulkan.c @@ -3991,7 +3991,7 @@ static VulkanBuffer *VULKAN_INTERNAL_CreateBuffer( buffer->usedRegion->vulkanBuffer = buffer; // lol - SDL_AtomicSet(&buffer->referenceCount, 0); + SDL_SetAtomicInt(&buffer->referenceCount, 0); return buffer; } @@ -4563,7 +4563,7 @@ static bool VULKAN_INTERNAL_CreateSwapchain( swapchainData->textureContainers[i].activeTexture->depth = 1; swapchainData->textureContainers[i].activeTexture->usage = SDL_GPU_TEXTUREUSAGE_COLOR_TARGET; swapchainData->textureContainers[i].activeTexture->container = &swapchainData->textureContainers[i]; - SDL_AtomicSet(&swapchainData->textureContainers[i].activeTexture->referenceCount, 0); + SDL_SetAtomicInt(&swapchainData->textureContainers[i].activeTexture->referenceCount, 0); // Create slice swapchainData->textureContainers[i].activeTexture->subresourceCount = 1; @@ -5450,7 +5450,7 @@ static VulkanTexture *VULKAN_INTERNAL_CreateTexture( texture->depth = depth; texture->usage = createinfo->usage; texture->fullView = VK_NULL_HANDLE; - SDL_AtomicSet(&texture->referenceCount, 0); + SDL_SetAtomicInt(&texture->referenceCount, 0); if (IsDepthFormat(createinfo->format)) { texture->aspectFlags = VK_IMAGE_ASPECT_DEPTH_BIT; @@ -5648,7 +5648,7 @@ static void VULKAN_INTERNAL_CycleActiveBuffer( // If a previously-cycled buffer is available, we can use that. for (Uint32 i = 0; i < container->bufferCount; i += 1) { buffer = container->buffers[i]; - if (SDL_AtomicGet(&buffer->referenceCount) == 0) { + if (SDL_GetAtomicInt(&buffer->referenceCount) == 0) { container->activeBuffer = buffer; return; } @@ -5698,7 +5698,7 @@ static void VULKAN_INTERNAL_CycleActiveTexture( for (Uint32 i = 0; i < container->textureCount; i += 1) { texture = container->textures[i]; - if (SDL_AtomicGet(&texture->referenceCount) == 0) { + if (SDL_GetAtomicInt(&texture->referenceCount) == 0) { container->activeTexture = texture; return; } @@ -5745,7 +5745,7 @@ static VulkanBuffer *VULKAN_INTERNAL_PrepareBufferForWrite( { if ( cycle && - SDL_AtomicGet(&bufferContainer->activeBuffer->referenceCount) > 0) { + SDL_GetAtomicInt(&bufferContainer->activeBuffer->referenceCount) > 0) { VULKAN_INTERNAL_CycleActiveBuffer( renderer, bufferContainer); @@ -5777,7 +5777,7 @@ static VulkanTextureSubresource *VULKAN_INTERNAL_PrepareTextureSubresourceForWri if ( cycle && textureContainer->canBeCycled && - SDL_AtomicGet(&textureContainer->activeTexture->referenceCount) > 0) { + SDL_GetAtomicInt(&textureContainer->activeTexture->referenceCount) > 0) { VULKAN_INTERNAL_CycleActiveTexture( renderer, textureContainer); @@ -6345,7 +6345,7 @@ static SDL_GPUGraphicsPipeline *VULKAN_CreateGraphicsPipeline( return NULL; } - SDL_AtomicSet(&graphicsPipeline->referenceCount, 0); + SDL_SetAtomicInt(&graphicsPipeline->referenceCount, 0); return (SDL_GPUGraphicsPipeline *)graphicsPipeline; } @@ -6446,7 +6446,7 @@ static SDL_GPUComputePipeline *VULKAN_CreateComputePipeline( return NULL; } - SDL_AtomicSet(&vulkanComputePipeline->referenceCount, 0); + SDL_SetAtomicInt(&vulkanComputePipeline->referenceCount, 0); return (SDL_GPUComputePipeline *)vulkanComputePipeline; } @@ -6491,7 +6491,7 @@ static SDL_GPUSampler *VULKAN_CreateSampler( return NULL; } - SDL_AtomicSet(&vulkanSampler->referenceCount, 0); + SDL_SetAtomicInt(&vulkanSampler->referenceCount, 0); return (SDL_GPUSampler *)vulkanSampler; } @@ -6535,7 +6535,7 @@ static SDL_GPUShader *VULKAN_CreateShader( vulkanShader->numStorageBuffers = createinfo->num_storage_buffers; vulkanShader->numUniformBuffers = createinfo->num_uniform_buffers; - SDL_AtomicSet(&vulkanShader->referenceCount, 0); + SDL_SetAtomicInt(&vulkanShader->referenceCount, 0); return (SDL_GPUShader *)vulkanShader; } @@ -6983,7 +6983,7 @@ static VulkanFramebuffer *VULKAN_INTERNAL_FetchFramebuffer( vulkanFramebuffer = SDL_malloc(sizeof(VulkanFramebuffer)); - SDL_AtomicSet(&vulkanFramebuffer->referenceCount, 0); + SDL_SetAtomicInt(&vulkanFramebuffer->referenceCount, 0); // Create a new framebuffer @@ -8407,7 +8407,7 @@ static void *VULKAN_MapTransferBuffer( if ( cycle && - SDL_AtomicGet(&transferBufferContainer->activeBuffer->referenceCount) > 0) { + SDL_GetAtomicInt(&transferBufferContainer->activeBuffer->referenceCount) > 0) { VULKAN_INTERNAL_CycleActiveBuffer( renderer, transferBufferContainer); @@ -9821,7 +9821,7 @@ static VulkanFenceHandle *VULKAN_INTERNAL_AcquireFenceFromPool( handle = SDL_malloc(sizeof(VulkanFenceHandle)); handle->fence = fence; - SDL_AtomicSet(&handle->referenceCount, 0); + SDL_SetAtomicInt(&handle->referenceCount, 0); return handle; } @@ -9850,7 +9850,7 @@ static void VULKAN_INTERNAL_PerformPendingDestroys( SDL_LockMutex(renderer->disposeLock); for (Sint32 i = renderer->texturesToDestroyCount - 1; i >= 0; i -= 1) { - if (SDL_AtomicGet(&renderer->texturesToDestroy[i]->referenceCount) == 0) { + if (SDL_GetAtomicInt(&renderer->texturesToDestroy[i]->referenceCount) == 0) { VULKAN_INTERNAL_DestroyTexture( renderer, renderer->texturesToDestroy[i]); @@ -9861,7 +9861,7 @@ static void VULKAN_INTERNAL_PerformPendingDestroys( } for (Sint32 i = renderer->buffersToDestroyCount - 1; i >= 0; i -= 1) { - if (SDL_AtomicGet(&renderer->buffersToDestroy[i]->referenceCount) == 0) { + if (SDL_GetAtomicInt(&renderer->buffersToDestroy[i]->referenceCount) == 0) { VULKAN_INTERNAL_DestroyBuffer( renderer, renderer->buffersToDestroy[i]); @@ -9872,7 +9872,7 @@ static void VULKAN_INTERNAL_PerformPendingDestroys( } for (Sint32 i = renderer->graphicsPipelinesToDestroyCount - 1; i >= 0; i -= 1) { - if (SDL_AtomicGet(&renderer->graphicsPipelinesToDestroy[i]->referenceCount) == 0) { + if (SDL_GetAtomicInt(&renderer->graphicsPipelinesToDestroy[i]->referenceCount) == 0) { VULKAN_INTERNAL_DestroyGraphicsPipeline( renderer, renderer->graphicsPipelinesToDestroy[i]); @@ -9883,7 +9883,7 @@ static void VULKAN_INTERNAL_PerformPendingDestroys( } for (Sint32 i = renderer->computePipelinesToDestroyCount - 1; i >= 0; i -= 1) { - if (SDL_AtomicGet(&renderer->computePipelinesToDestroy[i]->referenceCount) == 0) { + if (SDL_GetAtomicInt(&renderer->computePipelinesToDestroy[i]->referenceCount) == 0) { VULKAN_INTERNAL_DestroyComputePipeline( renderer, renderer->computePipelinesToDestroy[i]); @@ -9894,7 +9894,7 @@ static void VULKAN_INTERNAL_PerformPendingDestroys( } for (Sint32 i = renderer->shadersToDestroyCount - 1; i >= 0; i -= 1) { - if (SDL_AtomicGet(&renderer->shadersToDestroy[i]->referenceCount) == 0) { + if (SDL_GetAtomicInt(&renderer->shadersToDestroy[i]->referenceCount) == 0) { VULKAN_INTERNAL_DestroyShader( renderer, renderer->shadersToDestroy[i]); @@ -9905,7 +9905,7 @@ static void VULKAN_INTERNAL_PerformPendingDestroys( } for (Sint32 i = renderer->samplersToDestroyCount - 1; i >= 0; i -= 1) { - if (SDL_AtomicGet(&renderer->samplersToDestroy[i]->referenceCount) == 0) { + if (SDL_GetAtomicInt(&renderer->samplersToDestroy[i]->referenceCount) == 0) { VULKAN_INTERNAL_DestroySampler( renderer, renderer->samplersToDestroy[i]); @@ -9916,7 +9916,7 @@ static void VULKAN_INTERNAL_PerformPendingDestroys( } for (Sint32 i = renderer->framebuffersToDestroyCount - 1; i >= 0; i -= 1) { - if (SDL_AtomicGet(&renderer->framebuffersToDestroy[i]->referenceCount) == 0) { + if (SDL_GetAtomicInt(&renderer->framebuffersToDestroy[i]->referenceCount) == 0) { VULKAN_INTERNAL_DestroyFramebuffer( renderer, renderer->framebuffersToDestroy[i]); diff --git a/src/hidapi/android/hid.cpp b/src/hidapi/android/hid.cpp index b298b917fd..6713d169df 100644 --- a/src/hidapi/android/hid.cpp +++ b/src/hidapi/android/hid.cpp @@ -1032,23 +1032,23 @@ extern "C" // !!! FIXME: make this non-blocking! static void SDLCALL RequestAndroidPermissionBlockingCallback(void *userdata, const char *permission, SDL_bool granted) { - SDL_AtomicSet((SDL_AtomicInt *) userdata, granted ? 1 : -1); + SDL_SetAtomicInt((SDL_AtomicInt *) userdata, granted ? 1 : -1); } static bool RequestBluetoothPermissions(const char *permission) { // !!! FIXME: make this non-blocking! SDL_AtomicInt permission_response; - SDL_AtomicSet(&permission_response, 0); + SDL_SetAtomicInt(&permission_response, 0); if (!SDL_RequestAndroidPermission(permission, RequestAndroidPermissionBlockingCallback, &permission_response)) { return false; } - while (SDL_AtomicGet(&permission_response) == 0) { + while (SDL_GetAtomicInt(&permission_response) == 0) { SDL_Delay(10); } - return SDL_AtomicGet(&permission_response) > 0; + return SDL_GetAtomicInt(&permission_response) > 0; } diff --git a/src/joystick/SDL_joystick.c b/src/joystick/SDL_joystick.c index 2ed0f0bb4a..349d44191f 100644 --- a/src/joystick/SDL_joystick.c +++ b/src/joystick/SDL_joystick.c @@ -450,7 +450,7 @@ void SDL_UnlockJoysticks(void) if (!SDL_joysticks_initialized) { // NOTE: There's a small window here where another thread could lock the mutex after we've checked for pending locks - if (!SDL_joysticks_locked && SDL_AtomicGet(&SDL_joystick_lock_pending) == 0) { + if (!SDL_joysticks_locked && SDL_GetAtomicInt(&SDL_joystick_lock_pending) == 0) { last_unlock = true; } } diff --git a/src/joystick/hidapi/SDL_hidapi_rumble.c b/src/joystick/hidapi/SDL_hidapi_rumble.c index 865d714068..9abea1c7e5 100644 --- a/src/joystick/hidapi/SDL_hidapi_rumble.c +++ b/src/joystick/hidapi/SDL_hidapi_rumble.c @@ -61,7 +61,7 @@ static int SDLCALL SDL_HIDAPI_RumbleThread(void *data) SDL_SetThreadPriority(SDL_THREAD_PRIORITY_HIGH); - while (SDL_AtomicGet(&ctx->running)) { + while (SDL_GetAtomicInt(&ctx->running)) { SDL_HIDAPI_RumbleRequest *request = NULL; SDL_WaitSemaphore(ctx->request_sem); @@ -102,7 +102,7 @@ static void SDL_HIDAPI_StopRumbleThread(SDL_HIDAPI_RumbleContext *ctx) { SDL_HIDAPI_RumbleRequest *request; - SDL_AtomicSet(&ctx->running, false); + SDL_SetAtomicInt(&ctx->running, false); if (ctx->thread) { int result; @@ -138,7 +138,7 @@ static void SDL_HIDAPI_StopRumbleThread(SDL_HIDAPI_RumbleContext *ctx) SDL_HIDAPI_rumble_lock = NULL; } - SDL_AtomicSet(&ctx->initialized, false); + SDL_SetAtomicInt(&ctx->initialized, false); } static bool SDL_HIDAPI_StartRumbleThread(SDL_HIDAPI_RumbleContext *ctx) @@ -155,7 +155,7 @@ static bool SDL_HIDAPI_StartRumbleThread(SDL_HIDAPI_RumbleContext *ctx) return false; } - SDL_AtomicSet(&ctx->running, true); + SDL_SetAtomicInt(&ctx->running, true); ctx->thread = SDL_CreateThread(SDL_HIDAPI_RumbleThread, "HIDAPI Rumble", ctx); if (!ctx->thread) { SDL_HIDAPI_StopRumbleThread(ctx); @@ -168,7 +168,7 @@ bool SDL_HIDAPI_LockRumble(void) { SDL_HIDAPI_RumbleContext *ctx = &rumble_context; - if (SDL_AtomicCompareAndSwap(&ctx->initialized, false, true)) { + if (SDL_CompareAndSwapAtomicInt(&ctx->initialized, false, true)) { if (!SDL_HIDAPI_StartRumbleThread(ctx)) { return false; } @@ -277,7 +277,7 @@ void SDL_HIDAPI_QuitRumble(void) { SDL_HIDAPI_RumbleContext *ctx = &rumble_context; - if (SDL_AtomicGet(&ctx->running)) { + if (SDL_GetAtomicInt(&ctx->running)) { SDL_HIDAPI_StopRumbleThread(ctx); } } diff --git a/src/joystick/hidapi/SDL_hidapi_switch.c b/src/joystick/hidapi/SDL_hidapi_switch.c index 69f6f9de47..ea43af30cb 100644 --- a/src/joystick/hidapi/SDL_hidapi_switch.c +++ b/src/joystick/hidapi/SDL_hidapi_switch.c @@ -340,7 +340,7 @@ static int ReadInput(SDL_DriverSwitch_Context *ctx) int result; // Make sure we don't try to read at the same time a write is happening - if (SDL_AtomicGet(&ctx->device->rumble_pending) > 0) { + if (SDL_GetAtomicInt(&ctx->device->rumble_pending) > 0) { return 0; } diff --git a/src/joystick/hidapi/SDL_hidapi_wii.c b/src/joystick/hidapi/SDL_hidapi_wii.c index 23883544c1..06cfeea862 100644 --- a/src/joystick/hidapi/SDL_hidapi_wii.c +++ b/src/joystick/hidapi/SDL_hidapi_wii.c @@ -194,7 +194,7 @@ static int ReadInput(SDL_DriverWii_Context *ctx) int size; // Make sure we don't try to read at the same time a write is happening - if (SDL_AtomicGet(&ctx->device->rumble_pending) > 0) { + if (SDL_GetAtomicInt(&ctx->device->rumble_pending) > 0) { return 0; } diff --git a/src/joystick/hidapi/SDL_hidapijoystick.c b/src/joystick/hidapi/SDL_hidapijoystick.c index d1e5c1a937..5b153e7ef6 100644 --- a/src/joystick/hidapi/SDL_hidapijoystick.c +++ b/src/joystick/hidapi/SDL_hidapijoystick.c @@ -1033,7 +1033,7 @@ static void HIDAPI_DelDevice(SDL_HIDAPI_Device *device) HIDAPI_CleanupDeviceDriver(device); // Make sure the rumble thread is done with this device - while (SDL_AtomicGet(&device->rumble_pending) > 0) { + while (SDL_GetAtomicInt(&device->rumble_pending) > 0) { SDL_Delay(10); } @@ -1245,12 +1245,12 @@ static bool HIDAPI_IsEquivalentToDevice(Uint16 vendor_id, Uint16 product_id, SDL static bool HIDAPI_StartUpdatingDevices() { - return SDL_AtomicCompareAndSwap(&SDL_HIDAPI_updating_devices, false, true); + return SDL_CompareAndSwapAtomicInt(&SDL_HIDAPI_updating_devices, false, true); } static void HIDAPI_FinishUpdatingDevices() { - SDL_AtomicSet(&SDL_HIDAPI_updating_devices, false); + SDL_SetAtomicInt(&SDL_HIDAPI_updating_devices, false); } bool HIDAPI_IsDeviceTypePresent(SDL_GamepadType type) @@ -1645,7 +1645,7 @@ static void HIDAPI_JoystickClose(SDL_Joystick *joystick) SDL_NO_THREAD_SAFETY_AN SDL_UnlockMutex(device->dev_lock); } for (i = 0; i < 3; ++i) { - if (SDL_AtomicGet(&device->rumble_pending) > 0) { + if (SDL_GetAtomicInt(&device->rumble_pending) > 0) { SDL_Delay(10); } } diff --git a/src/joystick/windows/SDL_rawinputjoystick.c b/src/joystick/windows/SDL_rawinputjoystick.c index a10370648a..b49a703de3 100644 --- a/src/joystick/windows/SDL_rawinputjoystick.c +++ b/src/joystick/windows/SDL_rawinputjoystick.c @@ -493,13 +493,13 @@ static HRESULT STDMETHODCALLTYPE IEventHandler_CGamepadVtbl_QueryInterface(__FIE static ULONG STDMETHODCALLTYPE IEventHandler_CGamepadVtbl_AddRef(__FIEventHandler_1_Windows__CGaming__CInput__CGamepad *This) { GamepadDelegate *self = (GamepadDelegate *)This; - return SDL_AtomicAdd(&self->refcount, 1) + 1UL; + return SDL_AddAtomicInt(&self->refcount, 1) + 1UL; } static ULONG STDMETHODCALLTYPE IEventHandler_CGamepadVtbl_Release(__FIEventHandler_1_Windows__CGaming__CInput__CGamepad *This) { GamepadDelegate *self = (GamepadDelegate *)This; - int rc = SDL_AtomicAdd(&self->refcount, -1) - 1; + int rc = SDL_AddAtomicInt(&self->refcount, -1) - 1; // Should never free the static delegate objects SDL_assert(rc > 0); return rc; diff --git a/src/joystick/windows/SDL_windows_gaming_input.c b/src/joystick/windows/SDL_windows_gaming_input.c index 7aa5c64910..e17933d17e 100644 --- a/src/joystick/windows/SDL_windows_gaming_input.c +++ b/src/joystick/windows/SDL_windows_gaming_input.c @@ -343,13 +343,13 @@ static HRESULT STDMETHODCALLTYPE IEventHandler_CRawGameControllerVtbl_QueryInter static ULONG STDMETHODCALLTYPE IEventHandler_CRawGameControllerVtbl_AddRef(__FIEventHandler_1_Windows__CGaming__CInput__CRawGameController *This) { RawGameControllerDelegate *self = (RawGameControllerDelegate *)This; - return SDL_AtomicAdd(&self->refcount, 1) + 1UL; + return SDL_AddAtomicInt(&self->refcount, 1) + 1UL; } static ULONG STDMETHODCALLTYPE IEventHandler_CRawGameControllerVtbl_Release(__FIEventHandler_1_Windows__CGaming__CInput__CRawGameController *This) { RawGameControllerDelegate *self = (RawGameControllerDelegate *)This; - int rc = SDL_AtomicAdd(&self->refcount, -1) - 1; + int rc = SDL_AddAtomicInt(&self->refcount, -1) - 1; // Should never free the static delegate objects SDL_assert(rc > 0); return rc; diff --git a/src/main/SDL_main_callbacks.c b/src/main/SDL_main_callbacks.c index 2e781d8f1a..5801deb9ac 100644 --- a/src/main/SDL_main_callbacks.c +++ b/src/main/SDL_main_callbacks.c @@ -46,8 +46,8 @@ static bool ShouldDispatchImmediately(SDL_Event *event) static void SDL_DispatchMainCallbackEvent(SDL_Event *event) { - if (SDL_AtomicGet(&apprc) == SDL_APP_CONTINUE) { // if already quitting, don't send the event to the app. - SDL_AtomicCompareAndSwap(&apprc, SDL_APP_CONTINUE, SDL_main_event_callback(SDL_main_appstate, event)); + if (SDL_GetAtomicInt(&apprc) == SDL_APP_CONTINUE) { // if already quitting, don't send the event to the app. + SDL_CompareAndSwapAtomicInt(&apprc, SDL_APP_CONTINUE, SDL_main_event_callback(SDL_main_appstate, event)); } } @@ -94,23 +94,23 @@ SDL_AppResult SDL_InitMainCallbacks(int argc, char* argv[], SDL_AppInit_func app SDL_main_iteration_callback = appiter; SDL_main_event_callback = appevent; SDL_main_quit_callback = appquit; - SDL_AtomicSet(&apprc, SDL_APP_CONTINUE); + SDL_SetAtomicInt(&apprc, SDL_APP_CONTINUE); const SDL_AppResult rc = appinit(&SDL_main_appstate, argc, argv); - if (SDL_AtomicCompareAndSwap(&apprc, SDL_APP_CONTINUE, rc) && (rc == SDL_APP_CONTINUE)) { // bounce if SDL_AppInit already said abort, otherwise... + if (SDL_CompareAndSwapAtomicInt(&apprc, SDL_APP_CONTINUE, rc) && (rc == SDL_APP_CONTINUE)) { // bounce if SDL_AppInit already said abort, otherwise... // make sure we definitely have events initialized, even if the app didn't do it. if (!SDL_InitSubSystem(SDL_INIT_EVENTS)) { - SDL_AtomicSet(&apprc, SDL_APP_FAILURE); + SDL_SetAtomicInt(&apprc, SDL_APP_FAILURE); return SDL_APP_FAILURE; } if (!SDL_AddEventWatch(SDL_MainCallbackEventWatcher, NULL)) { - SDL_AtomicSet(&apprc, SDL_APP_FAILURE); + SDL_SetAtomicInt(&apprc, SDL_APP_FAILURE); return SDL_APP_FAILURE; } } - return (SDL_AppResult)SDL_AtomicGet(&apprc); + return (SDL_AppResult)SDL_GetAtomicInt(&apprc); } SDL_AppResult SDL_IterateMainCallbacks(bool pump_events) @@ -120,11 +120,11 @@ SDL_AppResult SDL_IterateMainCallbacks(bool pump_events) } SDL_DispatchMainCallbackEvents(); - SDL_AppResult rc = (SDL_AppResult)SDL_AtomicGet(&apprc); + SDL_AppResult rc = (SDL_AppResult)SDL_GetAtomicInt(&apprc); if (rc == SDL_APP_CONTINUE) { rc = SDL_main_iteration_callback(SDL_main_appstate); - if (!SDL_AtomicCompareAndSwap(&apprc, SDL_APP_CONTINUE, rc)) { - rc = (SDL_AppResult)SDL_AtomicGet(&apprc); // something else already set a quit result, keep that. + if (!SDL_CompareAndSwapAtomicInt(&apprc, SDL_APP_CONTINUE, rc)) { + rc = (SDL_AppResult)SDL_GetAtomicInt(&apprc); // something else already set a quit result, keep that. } } return rc; diff --git a/src/sensor/SDL_sensor.c b/src/sensor/SDL_sensor.c index 67353f907c..d10601f12e 100644 --- a/src/sensor/SDL_sensor.c +++ b/src/sensor/SDL_sensor.c @@ -86,7 +86,7 @@ void SDL_UnlockSensors(void) if (!SDL_sensors_initialized) { // NOTE: There's a small window here where another thread could lock the mutex after we've checked for pending locks - if (!SDL_sensors_locked && SDL_AtomicGet(&SDL_sensor_lock_pending) == 0) { + if (!SDL_sensors_locked && SDL_GetAtomicInt(&SDL_sensor_lock_pending) == 0) { last_unlock = true; } } diff --git a/src/sensor/android/SDL_androidsensor.c b/src/sensor/android/SDL_androidsensor.c index 87dceb8a0d..8a6416ba30 100644 --- a/src/sensor/android/SDL_androidsensor.c +++ b/src/sensor/android/SDL_androidsensor.c @@ -67,7 +67,7 @@ static int SDLCALL SDL_ANDROID_SensorThread(void *data) SDL_sensor_looper = ALooper_prepare(ALOOPER_PREPARE_ALLOW_NON_CALLBACKS); SDL_SignalSemaphore(ctx->sem); - while (SDL_AtomicGet(&ctx->running)) { + while (SDL_GetAtomicInt(&ctx->running)) { Uint64 timestamp = SDL_GetTicksNS(); if (ALooper_pollOnce(-1, NULL, &events, (void **)&source) == LOOPER_ID_USER) { @@ -93,7 +93,7 @@ static int SDLCALL SDL_ANDROID_SensorThread(void *data) static void SDL_ANDROID_StopSensorThread(SDL_AndroidSensorThreadContext *ctx) { - SDL_AtomicSet(&ctx->running, false); + SDL_SetAtomicInt(&ctx->running, false); if (ctx->thread) { int result; @@ -119,7 +119,7 @@ static bool SDL_ANDROID_StartSensorThread(SDL_AndroidSensorThreadContext *ctx) return false; } - SDL_AtomicSet(&ctx->running, true); + SDL_SetAtomicInt(&ctx->running, true); ctx->thread = SDL_CreateThread(SDL_ANDROID_SensorThread, "Sensors", ctx); if (!ctx->thread) { SDL_ANDROID_StopSensorThread(ctx); diff --git a/src/stdlib/SDL_malloc.c b/src/stdlib/SDL_malloc.c index 02636ec2dd..96c99fcf49 100644 --- a/src/stdlib/SDL_malloc.c +++ b/src/stdlib/SDL_malloc.c @@ -6417,7 +6417,7 @@ SDL_bool SDL_SetMemoryFunctions(SDL_malloc_func malloc_func, int SDL_GetNumAllocations(void) { - return SDL_AtomicGet(&s_mem.num_allocations); + return SDL_GetAtomicInt(&s_mem.num_allocations); } void *SDL_malloc(size_t size) diff --git a/src/test/SDL_test_memory.c b/src/test/SDL_test_memory.c index 7c7084b004..cad5c8fab8 100644 --- a/src/test/SDL_test_memory.c +++ b/src/test/SDL_test_memory.c @@ -78,12 +78,12 @@ static SDL_AtomicInt s_lock; #define LOCK_ALLOCATOR() \ do { \ - if (SDL_AtomicCompareAndSwap(&s_lock, 0, 1)) { \ + if (SDL_CompareAndSwapAtomicInt(&s_lock, 0, 1)) { \ break; \ } \ SDL_CPUPauseInstruction(); \ } while (SDL_TRUE) -#define UNLOCK_ALLOCATOR() do { SDL_AtomicSet(&s_lock, 0); } while (0) +#define UNLOCK_ALLOCATOR() do { SDL_SetAtomicInt(&s_lock, 0); } while (0) static unsigned int get_allocation_bucket(void *mem) { diff --git a/src/thread/SDL_thread.c b/src/thread/SDL_thread.c index 546f246110..895cc847a7 100644 --- a/src/thread/SDL_thread.c +++ b/src/thread/SDL_thread.c @@ -46,7 +46,7 @@ void *SDL_GetTLS(SDL_TLSID *id) return NULL; } - storage_index = SDL_AtomicGet(id) - 1; + storage_index = SDL_GetAtomicInt(id) - 1; storage = SDL_SYS_GetTLSData(); if (!storage || storage_index < 0 || storage_index >= storage->limit) { return NULL; @@ -70,16 +70,16 @@ SDL_bool SDL_SetTLS(SDL_TLSID *id, const void *value, SDL_TLSDestructorCallback SDL_InitTLSData(); // Get the storage index associated with the ID in a thread-safe way - storage_index = SDL_AtomicGet(id) - 1; + storage_index = SDL_GetAtomicInt(id) - 1; if (storage_index < 0) { int new_id = (SDL_AtomicIncRef(&SDL_tls_id) + 1); - SDL_AtomicCompareAndSwap(id, 0, new_id); + SDL_CompareAndSwapAtomicInt(id, 0, new_id); /* If there was a race condition we'll have wasted an ID, but every thread * will have the same storage index for this id. */ - storage_index = SDL_AtomicGet(id) - 1; + storage_index = SDL_GetAtomicInt(id) - 1; } // Get the storage for the current thread @@ -135,7 +135,7 @@ void SDL_QuitTLSData(void) { SDL_CleanupTLS(); - if (SDL_AtomicGet(&SDL_tls_allocated) == 0) { + if (SDL_GetAtomicInt(&SDL_tls_allocated) == 0) { SDL_SYS_QuitTLSData(); } else { // Some thread hasn't called SDL_CleanupTLS() @@ -326,9 +326,9 @@ void SDL_RunThread(SDL_Thread *thread) SDL_CleanupTLS(); // Mark us as ready to be joined (or detached) - if (!SDL_AtomicCompareAndSwap(&thread->state, SDL_THREAD_STATE_ALIVE, SDL_THREAD_STATE_ZOMBIE)) { + if (!SDL_CompareAndSwapAtomicInt(&thread->state, SDL_THREAD_STATE_ALIVE, SDL_THREAD_STATE_ZOMBIE)) { // Clean up if something already detached us. - if (SDL_AtomicCompareAndSwap(&thread->state, SDL_THREAD_STATE_DETACHED, SDL_THREAD_STATE_CLEANED)) { + if (SDL_CompareAndSwapAtomicInt(&thread->state, SDL_THREAD_STATE_DETACHED, SDL_THREAD_STATE_CLEANED)) { SDL_free(thread->name); // Can't free later, we've already cleaned up TLS SDL_free(thread); } @@ -364,7 +364,7 @@ SDL_Thread *SDL_CreateThreadWithPropertiesRuntime(SDL_PropertiesID props, return NULL; } thread->status = -1; - SDL_AtomicSet(&thread->state, SDL_THREAD_STATE_ALIVE); + SDL_SetAtomicInt(&thread->state, SDL_THREAD_STATE_ALIVE); // Set up the arguments for the thread if (name) { @@ -463,11 +463,11 @@ void SDL_DetachThread(SDL_Thread *thread) } // Grab dibs if the state is alive+joinable. - if (SDL_AtomicCompareAndSwap(&thread->state, SDL_THREAD_STATE_ALIVE, SDL_THREAD_STATE_DETACHED)) { + if (SDL_CompareAndSwapAtomicInt(&thread->state, SDL_THREAD_STATE_ALIVE, SDL_THREAD_STATE_DETACHED)) { SDL_SYS_DetachThread(thread); } else { // all other states are pretty final, see where we landed. - const int thread_state = SDL_AtomicGet(&thread->state); + const int thread_state = SDL_GetAtomicInt(&thread->state); if ((thread_state == SDL_THREAD_STATE_DETACHED) || (thread_state == SDL_THREAD_STATE_CLEANED)) { return; // already detached (you shouldn't call this twice!) } else if (thread_state == SDL_THREAD_STATE_ZOMBIE) { diff --git a/src/thread/generic/SDL_sysrwlock.c b/src/thread/generic/SDL_sysrwlock.c index 9edcb249af..2c3c68fbd8 100644 --- a/src/thread/generic/SDL_sysrwlock.c +++ b/src/thread/generic/SDL_sysrwlock.c @@ -74,8 +74,8 @@ SDL_RWLock *SDL_CreateRWLock_generic(void) return NULL; } - SDL_AtomicSet(&rwlock->reader_count, 0); - SDL_AtomicSet(&rwlock->writer_count, 0); + SDL_SetAtomicInt(&rwlock->reader_count, 0); + SDL_SetAtomicInt(&rwlock->writer_count, 0); #endif return rwlock; @@ -98,8 +98,8 @@ void SDL_LockRWLockForReading_generic(SDL_RWLock *rwlock) SDL_NO_THREAD_SAFETY_A if (rwlock) { // !!! FIXME: these don't have to be atomic, we always gate them behind a mutex. SDL_LockMutex(rwlock->lock); - SDL_assert(SDL_AtomicGet(&rwlock->writer_count) == 0); // shouldn't be able to grab lock if there's a writer! - SDL_AtomicAdd(&rwlock->reader_count, 1); + 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 @@ -110,12 +110,12 @@ void SDL_LockRWLockForWriting_generic(SDL_RWLock *rwlock) SDL_NO_THREAD_SAFETY_A #ifndef SDL_THREADS_DISABLED if (rwlock) { SDL_LockMutex(rwlock->lock); - while (SDL_AtomicGet(&rwlock->reader_count) > 0) { // while something is holding the shared lock, keep waiting. + 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_AtomicAdd(&rwlock->writer_count, 1); // we let these be recursive, but the API doesn't require this. It _does_ trust you unlock correctly! + 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 } @@ -129,8 +129,8 @@ bool SDL_TryLockRWLockForReading_generic(SDL_RWLock *rwlock) return false; } - SDL_assert(SDL_AtomicGet(&rwlock->writer_count) == 0); // shouldn't be able to grab lock if there's a writer! - SDL_AtomicAdd(&rwlock->reader_count, 1); + 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 @@ -153,13 +153,13 @@ bool SDL_TryLockRWLockForWriting_generic(SDL_RWLock *rwlock) return false; } - if (SDL_AtomicGet(&rwlock->reader_count) > 0) { // a reader is using the shared lock, treat it as unavailable. + 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_AtomicAdd(&rwlock->writer_count, 1); // we let these be recursive, but the API doesn't require this. It _does_ trust you unlock correctly! + 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 @@ -179,11 +179,11 @@ void SDL_UnlockRWLock_generic(SDL_RWLock *rwlock) SDL_NO_THREAD_SAFETY_ANALYSIS if (rwlock) { SDL_LockMutex(rwlock->lock); // recursive lock for writers, readers grab lock to make sure things are sane. - if (SDL_AtomicGet(&rwlock->reader_count) > 0) { // we're a reader - SDL_AtomicAdd(&rwlock->reader_count, -1); + 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_AtomicGet(&rwlock->writer_count) > 0) { // we're a writer - SDL_AtomicAdd(&rwlock->writer_count, -1); + } else if (SDL_GetAtomicInt(&rwlock->writer_count) > 0) { // we're a writer + SDL_AddAtomicInt(&rwlock->writer_count, -1); SDL_UnlockMutex(rwlock->lock); // recursive unlock. } diff --git a/src/thread/n3ds/SDL_systhread.c b/src/thread/n3ds/SDL_systhread.c index fcda5d326e..a535cfd095 100644 --- a/src/thread/n3ds/SDL_systhread.c +++ b/src/thread/n3ds/SDL_systhread.c @@ -126,7 +126,7 @@ void SDL_SYS_WaitThread(SDL_Thread *thread) Detached threads can be waited on, but should NOT be cleaned manually as it would result in a fatal error. */ - if (R_SUCCEEDED(res) && SDL_AtomicGet(&thread->state) != SDL_THREAD_STATE_DETACHED) { + if (R_SUCCEEDED(res) && SDL_GetAtomicInt(&thread->state) != SDL_THREAD_STATE_DETACHED) { threadFree(thread->handle); } } diff --git a/src/timer/SDL_timer.c b/src/timer/SDL_timer.c index 3a8e22bd9e..3662d9aba1 100644 --- a/src/timer/SDL_timer.c +++ b/src/timer/SDL_timer.c @@ -137,7 +137,7 @@ static int SDLCALL SDL_TimerThread(void *_data) freelist_tail = NULL; // Check to see if we're still running, after maintenance - if (!SDL_AtomicGet(&data->active)) { + if (!SDL_GetAtomicInt(&data->active)) { break; } @@ -159,7 +159,7 @@ static int SDLCALL SDL_TimerThread(void *_data) // We're going to do something with this timer data->timers = current->next; - if (SDL_AtomicGet(¤t->canceled)) { + if (SDL_GetAtomicInt(¤t->canceled)) { interval = 0; } else { if (current->callback_ms) { @@ -183,7 +183,7 @@ static int SDLCALL SDL_TimerThread(void *_data) } freelist_tail = current; - SDL_AtomicSet(¤t->canceled, 1); + SDL_SetAtomicInt(¤t->canceled, 1); } } @@ -224,7 +224,7 @@ bool SDL_InitTimers(void) goto error; } - SDL_AtomicSet(&data->active, true); + 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); @@ -251,7 +251,7 @@ void SDL_QuitTimers(void) return; } - SDL_AtomicSet(&data->active, false); + SDL_SetAtomicInt(&data->active, false); // Shutdown the timer thread if (data->thread) { @@ -331,7 +331,7 @@ static SDL_TimerID SDL_CreateTimer(Uint64 interval, SDL_TimerCallback callback_m timer->userdata = userdata; timer->interval = interval; timer->scheduled = SDL_GetTicksNS() + timer->interval; - SDL_AtomicSet(&timer->canceled, 0); + SDL_SetAtomicInt(&timer->canceled, 0); entry = (SDL_TimerMap *)SDL_malloc(sizeof(*entry)); if (!entry) { @@ -394,8 +394,8 @@ SDL_bool SDL_RemoveTimer(SDL_TimerID id) SDL_UnlockMutex(data->timermap_lock); if (entry) { - if (!SDL_AtomicGet(&entry->timer->canceled)) { - SDL_AtomicSet(&entry->timer->canceled, 1); + if (!SDL_GetAtomicInt(&entry->timer->canceled)) { + SDL_SetAtomicInt(&entry->timer->canceled, 1); canceled = true; } SDL_free(entry); diff --git a/src/video/SDL_video.c b/src/video/SDL_video.c index c6b19ec0a4..8597e0511a 100644 --- a/src/video/SDL_video.c +++ b/src/video/SDL_video.c @@ -5370,7 +5370,7 @@ SDL_bool SDL_ScreenKeyboardShown(SDL_Window *window) int SDL_GetMessageBoxCount(void) { - return SDL_AtomicGet(&SDL_messagebox_count); + return SDL_GetAtomicInt(&SDL_messagebox_count); } #ifdef SDL_VIDEO_DRIVER_ANDROID diff --git a/src/video/cocoa/SDL_cocoaopengl.m b/src/video/cocoa/SDL_cocoaopengl.m index 6d0f5764e0..de1f661f2f 100644 --- a/src/video/cocoa/SDL_cocoaopengl.m +++ b/src/video/cocoa/SDL_cocoaopengl.m @@ -64,10 +64,10 @@ static CVReturn DisplayLinkCallback(CVDisplayLinkRef displayLink, const CVTimeSt SDL3OpenGLContext *nscontext = (__bridge SDL3OpenGLContext *)displayLinkContext; // printf("DISPLAY LINK! %u\n", (unsigned int) SDL_GetTicks()); - const int setting = SDL_AtomicGet(&nscontext->swapIntervalSetting); + const int setting = SDL_GetAtomicInt(&nscontext->swapIntervalSetting); if (setting != 0) { // nothing to do if vsync is disabled, don't even lock SDL_LockMutex(nscontext->swapIntervalMutex); - SDL_AtomicAdd(&nscontext->swapIntervalsPassed, 1); + SDL_AddAtomicInt(&nscontext->swapIntervalsPassed, 1); SDL_SignalCondition(nscontext->swapIntervalCond); SDL_UnlockMutex(nscontext->swapIntervalMutex); } @@ -83,10 +83,10 @@ static CVReturn DisplayLinkCallback(CVDisplayLinkRef displayLink, const CVTimeSt self = [super initWithFormat:format shareContext:share]; if (self) { self.openglPixelFormat = format; - SDL_AtomicSet(&self->dirty, 0); + SDL_SetAtomicInt(&self->dirty, 0); self->window = NULL; - SDL_AtomicSet(&self->swapIntervalSetting, 0); - SDL_AtomicSet(&self->swapIntervalsPassed, 0); + SDL_SetAtomicInt(&self->swapIntervalSetting, 0); + SDL_SetAtomicInt(&self->swapIntervalsPassed, 0); self->swapIntervalCond = SDL_CreateCondition(); self->swapIntervalMutex = SDL_CreateMutex(); if (!self->swapIntervalCond || !self->swapIntervalMutex) { @@ -113,13 +113,13 @@ static CVReturn DisplayLinkCallback(CVDisplayLinkRef displayLink, const CVTimeSt - (void)scheduleUpdate { - SDL_AtomicAdd(&self->dirty, 1); + SDL_AddAtomicInt(&self->dirty, 1); } // This should only be called on the thread on which a user is using the context. - (void)updateIfNeeded { - const int value = SDL_AtomicSet(&self->dirty, 0); + const int value = SDL_SetAtomicInt(&self->dirty, 0); if (value > 0) { // We call the real underlying update here, since -[SDL3OpenGLContext update] just calls us. [self explicitUpdate]; @@ -463,8 +463,8 @@ bool Cocoa_GL_SetSwapInterval(SDL_VideoDevice *_this, int interval) result = SDL_SetError("No current OpenGL context"); } else { SDL_LockMutex(nscontext->swapIntervalMutex); - SDL_AtomicSet(&nscontext->swapIntervalsPassed, 0); - SDL_AtomicSet(&nscontext->swapIntervalSetting, interval); + SDL_SetAtomicInt(&nscontext->swapIntervalsPassed, 0); + SDL_SetAtomicInt(&nscontext->swapIntervalSetting, interval); SDL_UnlockMutex(nscontext->swapIntervalMutex); result = true; } @@ -478,7 +478,7 @@ bool Cocoa_GL_GetSwapInterval(SDL_VideoDevice *_this, int *interval) @autoreleasepool { SDL3OpenGLContext *nscontext = (__bridge SDL3OpenGLContext *)SDL_GL_GetCurrentContext(); if (nscontext) { - *interval = SDL_AtomicGet(&nscontext->swapIntervalSetting); + *interval = SDL_GetAtomicInt(&nscontext->swapIntervalSetting); return true; } else { return SDL_SetError("no OpenGL context"); @@ -491,23 +491,23 @@ bool Cocoa_GL_SwapWindow(SDL_VideoDevice *_this, SDL_Window *window) @autoreleasepool { SDL3OpenGLContext *nscontext = (__bridge SDL3OpenGLContext *)SDL_GL_GetCurrentContext(); SDL_CocoaVideoData *videodata = (__bridge SDL_CocoaVideoData *)_this->internal; - const int setting = SDL_AtomicGet(&nscontext->swapIntervalSetting); + const int setting = SDL_GetAtomicInt(&nscontext->swapIntervalSetting); if (setting == 0) { // nothing to do if vsync is disabled, don't even lock } else if (setting < 0) { // late swap tearing SDL_LockMutex(nscontext->swapIntervalMutex); - while (SDL_AtomicGet(&nscontext->swapIntervalsPassed) == 0) { + while (SDL_GetAtomicInt(&nscontext->swapIntervalsPassed) == 0) { SDL_WaitCondition(nscontext->swapIntervalCond, nscontext->swapIntervalMutex); } - SDL_AtomicSet(&nscontext->swapIntervalsPassed, 0); + SDL_SetAtomicInt(&nscontext->swapIntervalsPassed, 0); SDL_UnlockMutex(nscontext->swapIntervalMutex); } else { SDL_LockMutex(nscontext->swapIntervalMutex); do { // always wait here so we know we just hit a swap interval. SDL_WaitCondition(nscontext->swapIntervalCond, nscontext->swapIntervalMutex); - } while ((SDL_AtomicGet(&nscontext->swapIntervalsPassed) % setting) != 0); - SDL_AtomicSet(&nscontext->swapIntervalsPassed, 0); + } while ((SDL_GetAtomicInt(&nscontext->swapIntervalsPassed) % setting) != 0); + SDL_SetAtomicInt(&nscontext->swapIntervalsPassed, 0); SDL_UnlockMutex(nscontext->swapIntervalMutex); } diff --git a/src/video/wayland/SDL_waylandopengles.c b/src/video/wayland/SDL_waylandopengles.c index 17aefd66c6..1e720e0e45 100644 --- a/src/video/wayland/SDL_waylandopengles.c +++ b/src/video/wayland/SDL_waylandopengles.c @@ -139,7 +139,7 @@ bool Wayland_GLES_SwapWindow(SDL_VideoDevice *_this, SDL_Window *window) struct wl_display *display = videodata->display; // 20hz, so we'll progress even if throttled to zero. const Uint64 max_wait = SDL_GetTicksNS() + (SDL_NS_PER_SECOND / 20); - while (SDL_AtomicGet(&data->swap_interval_ready) == 0) { + while (SDL_GetAtomicInt(&data->swap_interval_ready) == 0) { Uint64 now; WAYLAND_wl_display_flush(display); @@ -171,7 +171,7 @@ bool Wayland_GLES_SwapWindow(SDL_VideoDevice *_this, SDL_Window *window) WAYLAND_wl_display_read_events(display); WAYLAND_wl_display_dispatch_queue_pending(display, data->gles_swap_frame_event_queue); } - SDL_AtomicSet(&data->swap_interval_ready, 0); + SDL_SetAtomicInt(&data->swap_interval_ready, 0); } if (!data->double_buffer) { diff --git a/src/video/wayland/SDL_waylandwindow.c b/src/video/wayland/SDL_waylandwindow.c index b2ed1f679b..e8bcc7c5eb 100644 --- a/src/video/wayland/SDL_waylandwindow.c +++ b/src/video/wayland/SDL_waylandwindow.c @@ -697,7 +697,7 @@ static const struct wl_callback_listener gles_swap_frame_listener; static void gles_swap_frame_done(void *data, struct wl_callback *cb, uint32_t time) { SDL_WindowData *wind = (SDL_WindowData *)data; - SDL_AtomicSet(&wind->swap_interval_ready, 1); // mark window as ready to present again. + SDL_SetAtomicInt(&wind->swap_interval_ready, 1); // mark window as ready to present again. // reset this callback to fire again once a new frame was presented and compositor wants the next one. wind->gles_swap_frame_callback = wl_surface_frame(wind->gles_swap_frame_surface_wrapper); diff --git a/test/testatomic.c b/test/testatomic.c index 72ae43c3dd..570ee82be0 100644 --- a/test/testatomic.c +++ b/test/testatomic.c @@ -49,30 +49,30 @@ static void RunBasicTest(void) SDL_Log("\natomic -----------------------------------------\n\n"); - SDL_AtomicSet(&v, 0); - tfret = SDL_AtomicSet(&v, 10) == 0; - SDL_Log("AtomicSet(10) tfret=%s val=%d\n", tf(tfret), SDL_AtomicGet(&v)); - tfret = SDL_AtomicAdd(&v, 10) == 10; - SDL_Log("AtomicAdd(10) tfret=%s val=%d\n", tf(tfret), SDL_AtomicGet(&v)); + SDL_SetAtomicInt(&v, 0); + tfret = SDL_SetAtomicInt(&v, 10) == 0; + SDL_Log("AtomicSet(10) tfret=%s val=%d\n", tf(tfret), SDL_GetAtomicInt(&v)); + tfret = SDL_AddAtomicInt(&v, 10) == 10; + SDL_Log("AtomicAdd(10) tfret=%s val=%d\n", tf(tfret), SDL_GetAtomicInt(&v)); - SDL_AtomicSet(&v, 0); + SDL_SetAtomicInt(&v, 0); SDL_AtomicIncRef(&v); - tfret = (SDL_AtomicGet(&v) == 1); - SDL_Log("AtomicIncRef() tfret=%s val=%d\n", tf(tfret), SDL_AtomicGet(&v)); + tfret = (SDL_GetAtomicInt(&v) == 1); + SDL_Log("AtomicIncRef() tfret=%s val=%d\n", tf(tfret), SDL_GetAtomicInt(&v)); SDL_AtomicIncRef(&v); - tfret = (SDL_AtomicGet(&v) == 2); - SDL_Log("AtomicIncRef() tfret=%s val=%d\n", tf(tfret), SDL_AtomicGet(&v)); + tfret = (SDL_GetAtomicInt(&v) == 2); + SDL_Log("AtomicIncRef() tfret=%s val=%d\n", tf(tfret), SDL_GetAtomicInt(&v)); tfret = (SDL_AtomicDecRef(&v) == SDL_FALSE); - SDL_Log("AtomicDecRef() tfret=%s val=%d\n", tf(tfret), SDL_AtomicGet(&v)); + SDL_Log("AtomicDecRef() tfret=%s val=%d\n", tf(tfret), SDL_GetAtomicInt(&v)); tfret = (SDL_AtomicDecRef(&v) == SDL_TRUE); - SDL_Log("AtomicDecRef() tfret=%s val=%d\n", tf(tfret), SDL_AtomicGet(&v)); + SDL_Log("AtomicDecRef() tfret=%s val=%d\n", tf(tfret), SDL_GetAtomicInt(&v)); - SDL_AtomicSet(&v, 10); - tfret = (SDL_AtomicCompareAndSwap(&v, 0, 20) == SDL_FALSE); - SDL_Log("AtomicCAS() tfret=%s val=%d\n", tf(tfret), SDL_AtomicGet(&v)); - value = SDL_AtomicGet(&v); - tfret = (SDL_AtomicCompareAndSwap(&v, value, 20) == SDL_TRUE); - SDL_Log("AtomicCAS() tfret=%s val=%d\n", tf(tfret), SDL_AtomicGet(&v)); + SDL_SetAtomicInt(&v, 10); + tfret = (SDL_CompareAndSwapAtomicInt(&v, 0, 20) == SDL_FALSE); + SDL_Log("AtomicCAS() tfret=%s val=%d\n", tf(tfret), SDL_GetAtomicInt(&v)); + value = SDL_GetAtomicInt(&v); + tfret = (SDL_CompareAndSwapAtomicInt(&v, value, 20) == SDL_TRUE); + SDL_Log("AtomicCAS() tfret=%s val=%d\n", tf(tfret), SDL_GetAtomicInt(&v)); } /**************************************************************************/ @@ -117,10 +117,10 @@ static int SDLCALL adder(void *junk) unsigned long N = NInter; SDL_Log("Thread subtracting %d %lu times\n", CountInc, N); while (N--) { - SDL_AtomicAdd(&good, -CountInc); + SDL_AddAtomicInt(&good, -CountInc); bad -= CountInc; } - SDL_AtomicAdd(&threadsRunning, -1); + SDL_AddAtomicInt(&threadsRunning, -1); SDL_SignalSemaphore(threadDone); return 0; } @@ -135,13 +135,13 @@ static void runAdder(void) threadDone = SDL_CreateSemaphore(0); - SDL_AtomicSet(&threadsRunning, NThreads); + SDL_SetAtomicInt(&threadsRunning, NThreads); for (i = 0; i < NThreads; i++) { threads[i] = SDL_CreateThread(adder, "Adder", NULL); } - while (SDL_AtomicGet(&threadsRunning) > 0) { + while (SDL_GetAtomicInt(&threadsRunning) > 0) { SDL_WaitSemaphore(threadDone); } @@ -167,65 +167,65 @@ static void RunEpicTest(void) SDL_assert(sizeof(atomicValue) >= 4); SDL_Log("Check static initializer\n"); - v = SDL_AtomicGet(&good); + v = SDL_GetAtomicInt(&good); SDL_assert(v == 42); SDL_assert(bad == 42); SDL_Log("Test negative values\n"); - SDL_AtomicSet(&good, -5); - v = SDL_AtomicGet(&good); + SDL_SetAtomicInt(&good, -5); + v = SDL_GetAtomicInt(&good); SDL_assert(v == -5); SDL_Log("Verify maximum value\n"); - SDL_AtomicSet(&good, CountTo); - v = SDL_AtomicGet(&good); + SDL_SetAtomicInt(&good, CountTo); + v = SDL_GetAtomicInt(&good); SDL_assert(v == CountTo); SDL_Log("Test compare and exchange\n"); - b = SDL_AtomicCompareAndSwap(&good, 500, 43); + b = SDL_CompareAndSwapAtomicInt(&good, 500, 43); SDL_assert(!b); /* no swap since CountTo!=500 */ - v = SDL_AtomicGet(&good); + v = SDL_GetAtomicInt(&good); SDL_assert(v == CountTo); /* ensure no swap */ - b = SDL_AtomicCompareAndSwap(&good, CountTo, 44); + b = SDL_CompareAndSwapAtomicInt(&good, CountTo, 44); SDL_assert(!!b); /* will swap */ - v = SDL_AtomicGet(&good); + v = SDL_GetAtomicInt(&good); SDL_assert(v == 44); SDL_Log("Test Add\n"); - v = SDL_AtomicAdd(&good, 1); + v = SDL_AddAtomicInt(&good, 1); SDL_assert(v == 44); - v = SDL_AtomicGet(&good); + v = SDL_GetAtomicInt(&good); SDL_assert(v == 45); - v = SDL_AtomicAdd(&good, 10); + v = SDL_AddAtomicInt(&good, 10); SDL_assert(v == 45); - v = SDL_AtomicGet(&good); + v = SDL_GetAtomicInt(&good); SDL_assert(v == 55); SDL_Log("Test Add (Negative values)\n"); - v = SDL_AtomicAdd(&good, -20); + v = SDL_AddAtomicInt(&good, -20); SDL_assert(v == 55); - v = SDL_AtomicGet(&good); + v = SDL_GetAtomicInt(&good); SDL_assert(v == 35); - v = SDL_AtomicAdd(&good, -50); /* crossing zero down */ + v = SDL_AddAtomicInt(&good, -50); /* crossing zero down */ SDL_assert(v == 35); - v = SDL_AtomicGet(&good); + v = SDL_GetAtomicInt(&good); SDL_assert(v == -15); - v = SDL_AtomicAdd(&good, 30); /* crossing zero up */ + v = SDL_AddAtomicInt(&good, 30); /* crossing zero up */ SDL_assert(v == -15); - v = SDL_AtomicGet(&good); + v = SDL_GetAtomicInt(&good); SDL_assert(v == 15); SDL_Log("Reset before count down test\n"); - SDL_AtomicSet(&good, CountTo); - v = SDL_AtomicGet(&good); + SDL_SetAtomicInt(&good, CountTo); + v = SDL_GetAtomicInt(&good); SDL_assert(v == CountTo); bad = CountTo; @@ -234,7 +234,7 @@ static void RunEpicTest(void) SDL_Log("Counting down from %d, Expect %d remaining\n", CountTo, Expect); runAdder(); - v = SDL_AtomicGet(&good); + v = SDL_GetAtomicInt(&good); SDL_Log("Atomic %d Non-Atomic %d\n", v, bad); SDL_assert(v == Expect); /* We can't guarantee that bad != Expect, this would happen on a single core system, for example. */ @@ -300,16 +300,16 @@ static void InitEventQueue(SDL_EventQueue *queue) int i; for (i = 0; i < MAX_ENTRIES; ++i) { - SDL_AtomicSet(&queue->entries[i].sequence, i); + SDL_SetAtomicInt(&queue->entries[i].sequence, i); } - SDL_AtomicSet(&queue->enqueue_pos, 0); - SDL_AtomicSet(&queue->dequeue_pos, 0); + SDL_SetAtomicInt(&queue->enqueue_pos, 0); + SDL_SetAtomicInt(&queue->dequeue_pos, 0); #ifdef TEST_SPINLOCK_FIFO queue->lock = 0; - SDL_AtomicSet(&queue->rwcount, 0); - SDL_AtomicSet(&queue->watcher, 0); + SDL_SetAtomicInt(&queue->rwcount, 0); + SDL_SetAtomicInt(&queue->watcher, 0); #endif - SDL_AtomicSet(&queue->active, 1); + SDL_SetAtomicInt(&queue->active, 1); } static SDL_bool EnqueueEvent_LockFree(SDL_EventQueue *queue, const SDL_Event *event) @@ -323,23 +323,23 @@ static SDL_bool EnqueueEvent_LockFree(SDL_EventQueue *queue, const SDL_Event *ev #ifdef TEST_SPINLOCK_FIFO /* This is a gate so an external thread can lock the queue */ SDL_LockSpinlock(&queue->lock); - SDL_assert(SDL_AtomicGet(&queue->watcher) == 0); + SDL_assert(SDL_GetAtomicInt(&queue->watcher) == 0); SDL_AtomicIncRef(&queue->rwcount); SDL_UnlockSpinlock(&queue->lock); #endif - queue_pos = (unsigned)SDL_AtomicGet(&queue->enqueue_pos); + queue_pos = (unsigned)SDL_GetAtomicInt(&queue->enqueue_pos); for (;;) { entry = &queue->entries[queue_pos & WRAP_MASK]; - entry_seq = (unsigned)SDL_AtomicGet(&entry->sequence); + entry_seq = (unsigned)SDL_GetAtomicInt(&entry->sequence); delta = (int)(entry_seq - queue_pos); if (delta == 0) { /* The entry and the queue position match, try to increment the queue position */ - if (SDL_AtomicCompareAndSwap(&queue->enqueue_pos, (int)queue_pos, (int)(queue_pos + 1))) { + if (SDL_CompareAndSwapAtomicInt(&queue->enqueue_pos, (int)queue_pos, (int)(queue_pos + 1))) { /* We own the object, fill it! */ entry->event = *event; - SDL_AtomicSet(&entry->sequence, (int)(queue_pos + 1)); + SDL_SetAtomicInt(&entry->sequence, (int)(queue_pos + 1)); status = SDL_TRUE; break; } @@ -349,7 +349,7 @@ static SDL_bool EnqueueEvent_LockFree(SDL_EventQueue *queue, const SDL_Event *ev break; } else { /* We ran into a new queue entry, get the new queue position */ - queue_pos = (unsigned)SDL_AtomicGet(&queue->enqueue_pos); + queue_pos = (unsigned)SDL_GetAtomicInt(&queue->enqueue_pos); } } @@ -370,23 +370,23 @@ static SDL_bool DequeueEvent_LockFree(SDL_EventQueue *queue, SDL_Event *event) #ifdef TEST_SPINLOCK_FIFO /* This is a gate so an external thread can lock the queue */ SDL_LockSpinlock(&queue->lock); - SDL_assert(SDL_AtomicGet(&queue->watcher) == 0); + SDL_assert(SDL_GetAtomicInt(&queue->watcher) == 0); SDL_AtomicIncRef(&queue->rwcount); SDL_UnlockSpinlock(&queue->lock); #endif - queue_pos = (unsigned)SDL_AtomicGet(&queue->dequeue_pos); + queue_pos = (unsigned)SDL_GetAtomicInt(&queue->dequeue_pos); for (;;) { entry = &queue->entries[queue_pos & WRAP_MASK]; - entry_seq = (unsigned)SDL_AtomicGet(&entry->sequence); + entry_seq = (unsigned)SDL_GetAtomicInt(&entry->sequence); delta = (int)(entry_seq - (queue_pos + 1)); if (delta == 0) { /* The entry and the queue position match, try to increment the queue position */ - if (SDL_AtomicCompareAndSwap(&queue->dequeue_pos, (int)queue_pos, (int)(queue_pos + 1))) { + if (SDL_CompareAndSwapAtomicInt(&queue->dequeue_pos, (int)queue_pos, (int)(queue_pos + 1))) { /* We own the object, fill it! */ *event = entry->event; - SDL_AtomicSet(&entry->sequence, (int)(queue_pos + MAX_ENTRIES)); + SDL_SetAtomicInt(&entry->sequence, (int)(queue_pos + MAX_ENTRIES)); status = SDL_TRUE; break; } @@ -396,7 +396,7 @@ static SDL_bool DequeueEvent_LockFree(SDL_EventQueue *queue, SDL_Event *event) break; } else { /* We ran into a new queue entry, get the new queue position */ - queue_pos = (unsigned)SDL_AtomicGet(&queue->dequeue_pos); + queue_pos = (unsigned)SDL_GetAtomicInt(&queue->dequeue_pos); } } @@ -537,7 +537,7 @@ static int SDLCALL FIFO_Reader(void *_data) if (DequeueEvent_LockFree(queue, &event)) { WriterData *writer = (WriterData *)event.user.data1; ++data->counters[writer->index]; - } else if (SDL_AtomicGet(&queue->active)) { + } else if (SDL_GetAtomicInt(&queue->active)) { ++data->waits; SDL_Delay(0); } else { @@ -550,7 +550,7 @@ static int SDLCALL FIFO_Reader(void *_data) if (DequeueEvent_Mutex(queue, &event)) { WriterData *writer = (WriterData *)event.user.data1; ++data->counters[writer->index]; - } else if (SDL_AtomicGet(&queue->active)) { + } else if (SDL_GetAtomicInt(&queue->active)) { ++data->waits; SDL_Delay(0); } else { @@ -568,10 +568,10 @@ static int SDLCALL FIFO_Watcher(void *_data) { SDL_EventQueue *queue = (SDL_EventQueue *)_data; - while (SDL_AtomicGet(&queue->active)) { + while (SDL_GetAtomicInt(&queue->active)) { SDL_LockSpinlock(&queue->lock); SDL_AtomicIncRef(&queue->watcher); - while (SDL_AtomicGet(&queue->rwcount) > 0) { + while (SDL_GetAtomicInt(&queue->rwcount) > 0) { SDL_Delay(0); } /* Do queue manipulation here... */ @@ -645,7 +645,7 @@ static void RunFIFOTest(SDL_bool lock_free) } /* Shut down the queue so readers exit */ - SDL_AtomicSet(&queue.active, 0); + SDL_SetAtomicInt(&queue.active, 0); /* Wait for the readers */ for (i = 0; i < NUM_READERS; ++i) { diff --git a/test/testaudio.c b/test/testaudio.c index 8ffd0a3c42..572137e5b4 100644 --- a/test/testaudio.c +++ b/test/testaudio.c @@ -786,7 +786,7 @@ static void SDLCALL PostmixCallback(void *userdata, const SDL_AudioSpec *spec, f SDL_copyp(&thing->data.logdev.postmix_spec, spec); SDL_memcpy(thing->data.logdev.postmix_buffer, buffer, buflen); thing->data.logdev.postmix_buflen = buflen; - SDL_AtomicSet(&thing->data.logdev.postmix_updated, 1); + SDL_SetAtomicInt(&thing->data.logdev.postmix_updated, 1); SDL_UnlockMutex(thing->data.logdev.postmix_lock); } @@ -857,7 +857,7 @@ static void LogicalDeviceThing_ontick(Thing *thing, Uint64 now) if (thing->data.logdev.postmix_buffer) { SDL_memset(thing->data.logdev.postmix_buffer, '\0', thing->data.logdev.postmix_buflen); } - SDL_AtomicSet(&thing->data.logdev.postmix_updated, 1); /* so this will at least clear the texture later. */ + SDL_SetAtomicInt(&thing->data.logdev.postmix_updated, 1); /* so this will at least clear the texture later. */ SDL_SetAudioPostmixCallback(thing->data.logdev.devid, PostmixCallback, thing); } } @@ -872,7 +872,7 @@ static void LogicalDeviceThing_ondraw(Thing *thing, SDL_Renderer *renderer) dst.x = thing->rect.x + ((thing->rect.w - dst.w) / 2); dst.y = thing->rect.y + ((thing->rect.h - dst.h) / 2); - if (SDL_AtomicGet(&thing->data.logdev.postmix_updated)) { + if (SDL_GetAtomicInt(&thing->data.logdev.postmix_updated)) { float *buffer; int channels; int buflen; @@ -883,7 +883,7 @@ static void LogicalDeviceThing_ondraw(Thing *thing, SDL_Renderer *renderer) buffer = (float *) SDL_malloc(thing->data.logdev.postmix_buflen); if (buffer) { SDL_memcpy(buffer, thing->data.logdev.postmix_buffer, thing->data.logdev.postmix_buflen); - SDL_AtomicSet(&thing->data.logdev.postmix_updated, 0); + SDL_SetAtomicInt(&thing->data.logdev.postmix_updated, 0); } SDL_UnlockMutex(thing->data.logdev.postmix_lock); diff --git a/test/testgles2.c b/test/testgles2.c index 865fc3a05f..772a7ba65d 100644 --- a/test/testgles2.c +++ b/test/testgles2.c @@ -568,7 +568,7 @@ render_thread_fn(void *render_ctx) thread_data *thread = render_ctx; while (!done && !thread->done && state->windows[thread->index]) { - if (SDL_AtomicCompareAndSwap(&thread->suspended, WAIT_STATE_ENTER_SEM, WAIT_STATE_WAITING_ON_SEM)) { + if (SDL_CompareAndSwapAtomicInt(&thread->suspended, WAIT_STATE_ENTER_SEM, WAIT_STATE_WAITING_ON_SEM)) { SDL_WaitSemaphore(thread->suspend_sem); } render_window(thread->index); @@ -603,12 +603,12 @@ loop_threaded(void) if (suspend_when_occluded && event.type == SDL_EVENT_WINDOW_OCCLUDED) { tdata = GetThreadDataForWindow(event.window.windowID); if (tdata) { - SDL_AtomicCompareAndSwap(&tdata->suspended, WAIT_STATE_GO, WAIT_STATE_ENTER_SEM); + SDL_CompareAndSwapAtomicInt(&tdata->suspended, WAIT_STATE_GO, WAIT_STATE_ENTER_SEM); } } else if (suspend_when_occluded && event.type == SDL_EVENT_WINDOW_EXPOSED) { tdata = GetThreadDataForWindow(event.window.windowID); if (tdata) { - if (SDL_AtomicSet(&tdata->suspended, WAIT_STATE_GO) == WAIT_STATE_WAITING_ON_SEM) { + if (SDL_SetAtomicInt(&tdata->suspended, WAIT_STATE_GO) == WAIT_STATE_WAITING_ON_SEM) { SDL_SignalSemaphore(tdata->suspend_sem); } } @@ -618,7 +618,7 @@ loop_threaded(void) /* Stop the render thread when the window is closed */ tdata->done = 1; if (tdata->thread) { - SDL_AtomicSet(&tdata->suspended, WAIT_STATE_GO); + SDL_SetAtomicInt(&tdata->suspended, WAIT_STATE_GO); SDL_SignalSemaphore(tdata->suspend_sem); SDL_WaitThread(tdata->thread, NULL); tdata->thread = NULL; @@ -909,7 +909,7 @@ int main(int argc, char *argv[]) /* Start a render thread for each window */ for (i = 0; i < state->num_windows; ++i) { threads[i].index = i; - SDL_AtomicSet(&threads[i].suspended, 0); + SDL_SetAtomicInt(&threads[i].suspended, 0); threads[i].suspend_sem = SDL_CreateSemaphore(0); threads[i].thread = SDL_CreateThread(render_thread_fn, "RenderThread", &threads[i]); } diff --git a/test/testlock.c b/test/testlock.c index 0cc155b70b..17a27e223b 100644 --- a/test/testlock.c +++ b/test/testlock.c @@ -48,7 +48,7 @@ static void printid(void) static void terminate(int sig) { (void)signal(SIGINT, terminate); - SDL_AtomicSet(&doterminate, 1); + SDL_SetAtomicInt(&doterminate, 1); } static void closemutex(int sig) @@ -56,7 +56,7 @@ static void closemutex(int sig) SDL_ThreadID id = SDL_GetCurrentThreadID(); int i; SDL_Log("Thread %" SDL_PRIu64 ": Cleaning up...\n", id == mainthread ? 0 : id); - SDL_AtomicSet(&doterminate, 1); + SDL_SetAtomicInt(&doterminate, 1); if (threads) { for (i = 0; i < nb_threads; ++i) { SDL_WaitThread(threads[i], NULL); @@ -80,7 +80,7 @@ Run(void *data) (void)signal(SIGTERM, closemutex); } SDL_Log("Thread %" SDL_PRIu64 ": starting up", current_thread); - while (!SDL_AtomicGet(&doterminate)) { + while (!SDL_GetAtomicInt(&doterminate)) { SDL_Log("Thread %" SDL_PRIu64 ": ready to work\n", current_thread); SDL_LockMutex(mutex); SDL_Log("Thread %" SDL_PRIu64 ": start work!\n", current_thread); @@ -91,7 +91,7 @@ Run(void *data) /* If this sleep isn't done, then threads may starve */ SDL_Delay(10); } - if (current_thread == mainthread && SDL_AtomicGet(&doterminate)) { + if (current_thread == mainthread && SDL_GetAtomicInt(&doterminate)) { SDL_Log("Thread %" SDL_PRIu64 ": raising SIGTERM\n", current_thread); (void)raise(SIGTERM); } @@ -179,7 +179,7 @@ int main(int argc, char *argv[]) } (void)atexit(SDL_Quit_Wrapper); - SDL_AtomicSet(&doterminate, 0); + SDL_SetAtomicInt(&doterminate, 0); mutex = SDL_CreateMutex(); if (!mutex) { diff --git a/test/testrwlock.c b/test/testrwlock.c index f047d85519..b95afb71a5 100644 --- a/test/testrwlock.c +++ b/test/testrwlock.c @@ -54,7 +54,7 @@ static int SDLCALL ReaderRun(void *data) { SDL_Log("Reader Thread %" SDL_PRIu64 ": starting up", SDL_GetCurrentThreadID()); - while (!SDL_AtomicGet(&doterminate)) { + while (!SDL_GetAtomicInt(&doterminate)) { DoWork(worktime); } SDL_Log("Reader Thread %" SDL_PRIu64 ": exiting!\n", SDL_GetCurrentThreadID()); @@ -71,7 +71,7 @@ int main(int argc, char *argv[]) return 1; } - SDL_AtomicSet(&doterminate, 0); + SDL_SetAtomicInt(&doterminate, 0); /* Parse commandline */ for (i = 1; i < argc;) { @@ -136,7 +136,7 @@ int main(int argc, char *argv[]) return 1; } - SDL_AtomicSet(&doterminate, 0); + SDL_SetAtomicInt(&doterminate, 0); rwlock = SDL_CreateRWLock(); if (!rwlock) { @@ -157,11 +157,11 @@ int main(int argc, char *argv[]) } } - while (!SDL_AtomicGet(&doterminate) && (SDL_GetTicks() < ((Uint64) timeout))) { + while (!SDL_GetAtomicInt(&doterminate) && (SDL_GetTicks() < ((Uint64) timeout))) { DoWork(writerworktime); } - SDL_AtomicSet(&doterminate, 1); + SDL_SetAtomicInt(&doterminate, 1); SDL_Log("Waiting on reader threads to terminate..."); for (i = 0; i < nb_threads; ++i) { SDL_WaitThread(threads[i], NULL); diff --git a/test/testthread.c b/test/testthread.c index b9c698ad3d..bdc9139401 100644 --- a/test/testthread.c +++ b/test/testthread.c @@ -62,7 +62,7 @@ ThreadFunc(void *data) SDL_SetTLS(&tls, "baby thread", NULL); SDL_Log("Started thread %s: My thread id is %" SDL_PRIu64 ", thread data = %s\n", (char *)data, SDL_GetCurrentThreadID(), (const char *)SDL_GetTLS(&tls)); - while (SDL_AtomicGet(&alive)) { + while (SDL_GetAtomicInt(&alive)) { SDL_Log("Thread '%s' is alive!\n", (char *)data); if (testprio) { @@ -83,7 +83,7 @@ killed(int sig) { SDL_Log("Killed with SIGTERM, waiting 5 seconds to exit\n"); SDL_Delay(5 * 1000); - SDL_AtomicSet(&alive, 0); + SDL_SetAtomicInt(&alive, 0); SDL_WaitThread(thread, NULL); quit(0); } @@ -133,7 +133,7 @@ int main(int argc, char *argv[]) SDL_SetTLS(&tls, "main thread", NULL); SDL_Log("Main thread data initially: %s\n", (const char *)SDL_GetTLS(&tls)); - SDL_AtomicSet(&alive, 1); + SDL_SetAtomicInt(&alive, 1); thread = SDL_CreateThread(ThreadFunc, "One", "#1"); if (!thread) { SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't create thread: %s\n", SDL_GetError()); @@ -141,12 +141,12 @@ int main(int argc, char *argv[]) } SDL_Delay(5 * 1000); SDL_Log("Waiting for thread #1\n"); - SDL_AtomicSet(&alive, 0); + SDL_SetAtomicInt(&alive, 0); SDL_WaitThread(thread, NULL); SDL_Log("Main thread data finally: %s\n", (const char *)SDL_GetTLS(&tls)); - SDL_AtomicSet(&alive, 1); + SDL_SetAtomicInt(&alive, 1); (void)signal(SIGTERM, killed); thread = SDL_CreateThread(ThreadFunc, "Two", "#2"); if (!thread) { diff --git a/test/torturethread.c b/test/torturethread.c index 9182149965..b57116c33e 100644 --- a/test/torturethread.c +++ b/test/torturethread.c @@ -38,7 +38,7 @@ static int SDLCALL SubThreadFunc(void *data) { SDL_AtomicInt *flag = (SDL_AtomicInt *)data; - while (!SDL_AtomicGet(flag)) { + while (!SDL_GetAtomicInt(flag)) { SDL_Delay(10); } return 0; @@ -57,18 +57,18 @@ ThreadFunc(void *data) for (i = 0; i < NUMTHREADS; i++) { char name[64]; (void)SDL_snprintf(name, sizeof(name), "Child%d_%d", tid, i); - SDL_AtomicSet(&flags[i], 0); + SDL_SetAtomicInt(&flags[i], 0); sub_threads[i] = SDL_CreateThread(SubThreadFunc, name, &flags[i]); } SDL_Log("Thread '%d' waiting for signal\n", tid); - while (SDL_AtomicGet(&time_for_threads_to_die[tid]) != 1) { + while (SDL_GetAtomicInt(&time_for_threads_to_die[tid]) != 1) { ; /* do nothing */ } SDL_Log("Thread '%d' sending signals to subthreads\n", tid); for (i = 0; i < NUMTHREADS; i++) { - SDL_AtomicSet(&flags[i], 1); + SDL_SetAtomicInt(&flags[i], 1); SDL_WaitThread(sub_threads[i], NULL); } @@ -99,7 +99,7 @@ int main(int argc, char *argv[]) for (i = 0; i < NUMTHREADS; i++) { char name[64]; (void)SDL_snprintf(name, sizeof(name), "Parent%d", i); - SDL_AtomicSet(&time_for_threads_to_die[i], 0); + SDL_SetAtomicInt(&time_for_threads_to_die[i], 0); threads[i] = SDL_CreateThread(ThreadFunc, name, (void *)(uintptr_t)i); if (threads[i] == NULL) { @@ -109,7 +109,7 @@ int main(int argc, char *argv[]) } for (i = 0; i < NUMTHREADS; i++) { - SDL_AtomicSet(&time_for_threads_to_die[i], 1); + SDL_SetAtomicInt(&time_for_threads_to_die[i], 1); } for (i = 0; i < NUMTHREADS; i++) {