Pass on atomic usage

Signed-off-by: Andrew Opalach <andrew@akon.city>

2 files changed, 19 insertions, 19 deletions

diff --git a/src/mixer/mixer.c b/src/mixer/mixer.c
index 7fa75ae..c578689 100644
--- a/src/mixer/mixer.c
+++ b/src/mixer/mixer.c
@@ -14,13 +14,13 @@ static s32 data_callback(void *userdata, u8 *data, s32 frame_count, bool *silenc
     struct camu_mixer *mixer = (struct camu_mixer *)userdata;
     ptrdiff_t req = (ptrdiff_t)camu_audio_format_samples_to_bytes(&mixer->fmt.req, (size_t)frame_count);
 #ifdef CAMU_MIXER_THREADED_START_STOP
-    if (UNLIKELY(al_atomic_load(bool)(&mixer->paused, AL_ATOMIC_RELAXED))) {
+    if (UNLIKELY(atomic_load(bool)(&mixer->paused, AL_ATOMIC_RELAXED))) {
         al_memset(data, 0, req);
         *silence = MIXER_WANT_INITIAL_SILENCE;
     } else {
 #endif
 #ifdef CAMU_MIXER_THREADED
-        if (al_atomic_load(u8)(&mixer->queued, AL_ATOMIC_RELAXED)) {
+        if (atomic_load(bool)(&mixer->queued, AL_ATOMIC_RELAXED)) {
             camu_mixer_run_queue(mixer);
         }
 #endif
@@ -56,7 +56,7 @@ static s32 data_callback(void *userdata, u8 *data, s32 frame_count, bool *silenc
                         break;
                     }
 #ifdef CAMU_MIXER_THREADED
-                    if (al_atomic_load(u8)(&mixer->queued, AL_ATOMIC_RELAXED)) {
+                    if (atomic_load(bool)(&mixer->queued, AL_ATOMIC_RELAXED)) {
                         camu_mixer_run_queue(mixer);
                     }
 #endif
@@ -81,13 +81,13 @@ bool camu_mixer_init(struct camu_mixer *mixer, struct camu_audio *audio)
     mixer->audio->userdata = mixer;
     mixer->audio->init(mixer->audio, &al_str_c("cmv"));
     mixer->volume = 1.f;
-    al_atomic_store(bool)(&mixer->paused, true, AL_ATOMIC_RELAXED);
+    atomic_store(bool)(&mixer->paused, true, AL_ATOMIC_RELAXED);
     mixer->empty_after = 0;
     al_array_init(mixer->buffers);
 #ifdef CAMU_MIXER_THREADED
     al_array_init(mixer->add_queue);
     al_array_init(mixer->rem_queue);
-    al_atomic_store(u8)(&mixer->queued, 0, AL_ATOMIC_RELAXED);
+    atomic_store(bool)(&mixer->queued, false, AL_ATOMIC_RELAXED);
     nn_mutex_init(&mixer->mutex);
 #endif
     return true;
@@ -147,7 +147,7 @@ static void add_buffer_internal(struct camu_mixer *mixer, struct camu_audio_buff
     }
     camu_audio_buffer_set_volume(buf, mixer->volume);
 #ifdef CAMU_MIXER_THREADED
-    al_atomic_store(u8)(&buf->ref, 1, AL_ATOMIC_RELAXED);
+    atomic_store(bool)(&buf->ref, true, AL_ATOMIC_RELAXED);
 #endif
     al_array_push(mixer->buffers, buf);
 }
@@ -158,7 +158,7 @@ static void remove_buffer_internal(struct camu_mixer *mixer, struct camu_audio_b
     al_array_foreach(mixer->buffers, i, added) {
         if (added == buf) {
 #ifdef CAMU_MIXER_THREADED
-            al_atomic_store(u8)(&buf->ref, 0, AL_ATOMIC_RELAXED);
+            atomic_store(bool)(&buf->ref, false, AL_ATOMIC_RELAXED);
 #endif
             al_array_remove_at(mixer->buffers, i);
             break;
@@ -183,7 +183,7 @@ static void run_queue_internal(struct camu_mixer *mixer)
         }
         mixer->add_queue.count = 0;
     }
-    al_atomic_store(u8)(&mixer->queued, 0, AL_ATOMIC_RELAXED);
+    atomic_store(bool)(&mixer->queued, false, AL_ATOMIC_RELAXED);
     if (!mixer->buffers.count) {
         mixer->empty_after = MIXER_TRAILING_SILENCE;
     } else {
@@ -208,14 +208,14 @@ void camu_mixer_add_buffer(struct camu_mixer *mixer, struct camu_audio_buffer *b
             al_array_remove_at(mixer->rem_queue, i);
             bool queue_empty = mixer->add_queue.count + mixer->rem_queue.count == 0;
             if (queue_empty) {
-                al_atomic_store(u8)(&mixer->queued, 0, AL_ATOMIC_RELAXED);
+                atomic_store(bool)(&mixer->queued, false, AL_ATOMIC_RELAXED);
             }
             nn_mutex_unlock(&mixer->mutex);
             return;
         }
     }
     al_array_push(mixer->add_queue, buf);
-    al_atomic_store(u8)(&mixer->queued, 1, AL_ATOMIC_RELAXED);
+    atomic_store(bool)(&mixer->queued, true, AL_ATOMIC_RELAXED);
     nn_mutex_unlock(&mixer->mutex);
 #else
     add_buffer_internal(mixer, buf);
@@ -239,15 +239,15 @@ void camu_mixer_remove_buffer(struct camu_mixer *mixer, struct camu_audio_buffer
             al_array_remove_at(mixer->add_queue, i);
             bool queue_empty = mixer->add_queue.count + mixer->rem_queue.count == 0;
             if (queue_empty) {
-                al_atomic_store(u8)(&mixer->queued, 0, AL_ATOMIC_RELAXED);
+                atomic_store(bool)(&mixer->queued, false, AL_ATOMIC_RELAXED);
             }
             nn_mutex_unlock(&mixer->mutex);
             return;
         }
     }
     al_array_push(mixer->rem_queue, buf);
-    al_atomic_store(u8)(&mixer->queued, 1, AL_ATOMIC_RELAXED);
-    if (al_atomic_load(bool)(&mixer->paused, AL_ATOMIC_RELAXED)) {
+    atomic_store(bool)(&mixer->queued, true, AL_ATOMIC_RELAXED);
+    if (atomic_load(bool)(&mixer->paused, AL_ATOMIC_RELAXED)) {
         run_queue_internal(mixer);
     }
     nn_mutex_unlock(&mixer->mutex);
@@ -271,7 +271,7 @@ void camu_mixer_clear(struct camu_mixer *mixer)
 {
     struct camu_audio_buffer *buf;
     al_array_foreach(mixer->buffers, i, buf) {
-        al_atomic_store(u8)(&buf->ref, 0, AL_ATOMIC_RELAXED);
+        atomic_store(bool)(&buf->ref, false, AL_ATOMIC_RELAXED);
     }
 }
 #endif
@@ -281,9 +281,9 @@ void camu_mixer_pause(struct camu_mixer *mixer)
 #ifdef CAMU_MIXER_THREADED_START_STOP
     nn_mutex_lock(&mixer->mutex);
 #endif
-    if (!al_atomic_load(bool)(&mixer->paused, AL_ATOMIC_ACQUIRE)) {
+    if (!atomic_load(bool)(&mixer->paused, AL_ATOMIC_ACQUIRE)) {
         mixer->audio->stop(mixer->audio);
-        al_atomic_store(bool)(&mixer->paused, true, AL_ATOMIC_RELEASE);
+        atomic_store(bool)(&mixer->paused, true, AL_ATOMIC_RELEASE);
     }
 #ifdef CAMU_MIXER_THREADED
     // This requires that stop() blocks until the output actually stops.
@@ -299,13 +299,13 @@ void camu_mixer_resume(struct camu_mixer *mixer)
 #ifdef CAMU_MIXER_THREADED_START_STOP
     nn_mutex_lock(&mixer->mutex);
 #endif
-    if (al_atomic_load(bool)(&mixer->paused, AL_ATOMIC_ACQUIRE)) {
+    if (atomic_load(bool)(&mixer->paused, AL_ATOMIC_ACQUIRE)) {
         // audio->start() can internally call data_callback() or possibly start a thread which
         // can call data_callback() before we have a chance to set paused to false.
         // MIXER_THREADED_START_STOP: If paused is true in data_callback(), immediately return silence.
         //  This will avoid a deadlock in the first case described above.
         mixer->audio->start(mixer->audio);
-        al_atomic_store(bool)(&mixer->paused, false, AL_ATOMIC_RELEASE);
+        atomic_store(bool)(&mixer->paused, false, AL_ATOMIC_RELEASE);
     }
 #ifdef CAMU_MIXER_THREADED_START_STOP
     nn_mutex_unlock(&mixer->mutex);
diff --git a/src/mixer/mixer.h b/src/mixer/mixer.h
index d1a79b3..fec06ea 100644
--- a/src/mixer/mixer.h
+++ b/src/mixer/mixer.h
@@ -31,7 +31,7 @@ struct camu_mixer {
 #ifdef CAMU_MIXER_THREADED
     array(struct camu_audio_buffer *) add_queue;
     array(struct camu_audio_buffer *) rem_queue;
-    atomic(u8) queued;
+    atomic(bool) queued;
     struct nn_mutex mutex;
 #endif
     void (*callback)(void *, u8);