Pass on atomic usage

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

17 files changed, 134 insertions, 134 deletions

diff --git a/src/buffer/audio.c b/src/buffer/audio.c
index 998662b..f066f18 100644
--- a/src/buffer/audio.c
+++ b/src/buffer/audio.c
@@ -30,14 +30,14 @@ enum {
 
 static void reset_buffer_state(struct camu_audio_buffer *buf)
 {
-    al_atomic_store(f64)(&buf->pts, -1.0, AL_ATOMIC_RELAXED);
+    atomic_store(f64)(&buf->pts, -1.0, AL_ATOMIC_RELAXED);
     buf->pause = PAUSE_PAUSED;
-    al_atomic_store(u32)(&buf->unpause, 0, AL_ATOMIC_RELAXED);
+    atomic_store(u32)(&buf->unpause, 0, AL_ATOMIC_RELAXED);
     buf->logged_delay = false;
-    al_atomic_store(u32)(&buf->volume.set, 0, AL_ATOMIC_RELAXED);
+    atomic_store(u32)(&buf->volume.set, 0, AL_ATOMIC_RELAXED);
     buf->buffered = false;
-    al_atomic_store(u8)(&buf->flow, FLOWING, AL_ATOMIC_RELAXED);
-    al_atomic_store(ptrdiff_t)(&buf->uncork_at, 0, AL_ATOMIC_RELAXED);
+    atomic_store(u32)(&buf->flow, FLOWING, AL_ATOMIC_RELAXED);
+    atomic_store(ptrdiff_t)(&buf->uncork_at, 0, AL_ATOMIC_RELAXED);
 }
 
 bool camu_audio_buffer_init(struct camu_audio_buffer *buf, struct camu_clock *clock)
@@ -45,14 +45,14 @@ bool camu_audio_buffer_init(struct camu_audio_buffer *buf, struct camu_clock *cl
     buf->clock = clock;
     buf->latency = 0.0;
     buf->ignore_desync = false;
-    al_atomic_store(bool)(&buf->no_video, false, AL_ATOMIC_RELAXED);
+    atomic_store(bool)(&buf->no_video, false, AL_ATOMIC_RELAXED);
     reset_buffer_state(buf);
 #ifdef CAMU_AUDIO_BUFFER_FADE
     // Persist fade volume across resets.
     buf->fade.volume = -1.f;
 #endif
 #ifdef CAMU_MIXER_THREADED
-    al_atomic_store(u8)(&buf->ref, 0, AL_ATOMIC_RELAXED);
+    atomic_store(bool)(&buf->ref, false, AL_ATOMIC_RELAXED);
 #endif
     return true;
 }
@@ -98,8 +98,8 @@ bool camu_audio_buffer_configure(struct camu_audio_buffer *buf, struct camu_code
 
 void camu_audio_buffer_set_volume(struct camu_audio_buffer *buf, f32 volume)
 {
-    al_atomic_store(f32)(&buf->volume.queued, volume, AL_ATOMIC_RELAXED);
-    al_atomic_add(u32)(&buf->volume.set, 1, AL_ATOMIC_RELAXED);
+    atomic_store(f32)(&buf->volume.queued, volume, AL_ATOMIC_RELAXED);
+    atomic_add(u32)(&buf->volume.set, 1, AL_ATOMIC_RELAXED);
 }
 
 void camu_audio_buffer_set_latency(struct camu_audio_buffer *buf, f64 latency)
@@ -114,13 +114,13 @@ void camu_audio_buffer_set_ignore_desync(struct camu_audio_buffer *buf, bool ign
 
 void camu_audio_buffer_set_no_video(struct camu_audio_buffer *buf, bool no_video)
 {
-    al_atomic_store(bool)(&buf->no_video, no_video, AL_ATOMIC_RELAXED);
+    atomic_store(bool)(&buf->no_video, no_video, AL_ATOMIC_RELAXED);
 }
 
 // A return value of false signals that we pushed to the peak buffer.
 static bool push_internal(struct camu_audio_buffer *buf, f64 pts, u8 **data, s32 sample_count)
 {
-    f64 base_pts = al_atomic_load(f64)(&buf->pts, AL_ATOMIC_ACQUIRE);
+    f64 base_pts = atomic_load(f64)(&buf->pts, AL_ATOMIC_ACQUIRE);
 
     if (data && sample_count > 0) {
         f64 duration = camu_audio_format_samples_to_sec(&buf->fmt.in, sample_count);
@@ -140,7 +140,7 @@ static bool push_internal(struct camu_audio_buffer *buf, f64 pts, u8 **data, s32
 
     if (base_pts == -1.0) {
         // We want this push() to set the pts even if sample_count = 0.
-        al_atomic_store(f64)(&buf->pts, pts, AL_ATOMIC_RELEASE);
+        atomic_store(f64)(&buf->pts, pts, AL_ATOMIC_RELEASE);
     }
 
     if (sample_count == 0) {
@@ -170,7 +170,7 @@ static bool push_internal(struct camu_audio_buffer *buf, f64 pts, u8 **data, s32
         }
         al_assert(peak <= buf->mark.min);
         // We adjust the min mark by the peak buffer size just for consistency.
-        al_atomic_store(ptrdiff_t)(&buf->uncork_at, buf->mark.min - peak, AL_ATOMIC_RELAXED);
+        atomic_store(ptrdiff_t)(&buf->uncork_at, buf->mark.min - peak, AL_ATOMIC_RELAXED);
         buf->callback(buf->userdata, CAMU_BUFFER_CORK);
         return false;
     }
@@ -198,7 +198,7 @@ static void push_av_frame_internal(struct camu_audio_buffer *buf, AVFrame *frame
 // A reset() must finish before any data is pushed.
 void camu_audio_buffer_push(struct camu_audio_buffer *buf, struct camu_codec_frame *frame)
 {
-    u8 flow = al_atomic_load(u8)(&buf->flow, AL_ATOMIC_RELAXED);
+    u8 flow = atomic_load(u32)(&buf->flow, AL_ATOMIC_RELAXED);
     // flow could be ERRORED here.
     if (flow != FLOWING) {
         // Assert that push() is never called after flush().
@@ -235,7 +235,7 @@ void camu_audio_buffer_flush(struct camu_audio_buffer *buf, bool error)
 {
     log_debug("Flush requested.");
     u8 flow = error ? FLUSHED_ERROR : FLUSHED;
-    al_atomic_store(u8)(&buf->flow, flow, AL_ATOMIC_RELAXED);
+    atomic_store(u32)(&buf->flow, flow, AL_ATOMIC_RELAXED);
     if (!push_internal(buf, 0.0, NULL, 0)) {
         log_debug("Buffer filled by flush.");
     }
@@ -259,7 +259,7 @@ void camu_audio_buffer_reset(struct camu_audio_buffer *buf)
 
 void camu_audio_buffer_resync(struct camu_audio_buffer *buf)
 {
-    al_atomic_add(u32)(&buf->unpause, 1, AL_ATOMIC_RELAXED);
+    atomic_add(u32)(&buf->unpause, 1, AL_ATOMIC_RELAXED);
 }
 
 ptrdiff_t camu_audio_buffer_read(struct camu_audio_buffer *buf, u8 *data, ptrdiff_t req)
@@ -267,11 +267,11 @@ ptrdiff_t camu_audio_buffer_read(struct camu_audio_buffer *buf, u8 *data, ptrdif
     // Assert this buffer isn't being read before we signaled BUFFER_BUFFERED.
     al_assert(buf->buffered);
 
-    u8 flow = al_atomic_load(u8)(&buf->flow, AL_ATOMIC_ACQUIRE);
+    u8 flow = atomic_load(u32)(&buf->flow, AL_ATOMIC_ACQUIRE);
     if (UNLIKELY(flow == ERRORED || flow == FLUSHED_ERROR)) {
         if (flow == FLUSHED_ERROR) {
             buf->callback(buf->userdata, CAMU_BUFFER_ERRORED);
-            al_atomic_store(u8)(&buf->flow, ERRORED, AL_ATOMIC_RELEASE);
+            atomic_store(u32)(&buf->flow, ERRORED, AL_ATOMIC_RELEASE);
         }
         al_memset(data, 0, req);
         return req;
@@ -280,8 +280,8 @@ ptrdiff_t camu_audio_buffer_read(struct camu_audio_buffer *buf, u8 *data, ptrdif
     struct camu_audio_format *fmt = &buf->fmt.req;
     ptrdiff_t ret, signal = req;
 
-    f64 base_pts = al_atomic_load(f64)(&buf->pts, AL_ATOMIC_ACQUIRE);
-    bool set_clock = al_atomic_load(bool)(&buf->no_video, AL_ATOMIC_RELAXED);
+    f64 base_pts = atomic_load(f64)(&buf->pts, AL_ATOMIC_ACQUIRE);
+    bool set_clock = atomic_load(bool)(&buf->no_video, AL_ATOMIC_RELAXED);
     f64 pts = camu_clock_get_pts(buf->clock, buf->latency, set_clock);
     if (pts == CAMU_PTS_SIGNAL_PAUSE) {
         return 0;
@@ -326,19 +326,19 @@ ptrdiff_t camu_audio_buffer_read(struct camu_audio_buffer *buf, u8 *data, ptrdif
 #endif
     }
 
-    if (al_atomic_load(u32)(&buf->volume.set, AL_ATOMIC_ACQUIRE) > 0) {
-        buf->volume.user = al_atomic_load(f32)(&buf->volume.queued, AL_ATOMIC_RELAXED);
+    if (atomic_load(u32)(&buf->volume.set, AL_ATOMIC_ACQUIRE) > 0) {
+        buf->volume.user = atomic_load(f32)(&buf->volume.queued, AL_ATOMIC_RELAXED);
 #ifdef CAMU_AUDIO_BUFFER_FADE
         if (buf->fade.volume == -1.f) buf->fade.volume = buf->volume.user;
 #endif
-        al_atomic_sub(u32)(&buf->volume.set, 1, AL_ATOMIC_RELEASE);
+        atomic_sub(u32)(&buf->volume.set, 1, AL_ATOMIC_RELEASE);
     }
 
-    if (!buf->ignore_desync && al_atomic_load(u32)(&buf->unpause, AL_ATOMIC_ACQUIRE) > 0) {
+    if (!buf->ignore_desync && atomic_load(u32)(&buf->unpause, AL_ATOMIC_ACQUIRE) > 0) {
         // Queuing multiple resyncs before resuming the stream will cause pops!
         log_debug("Forcing resync.");
         buf->pause = PAUSE_PAUSED;
-        al_atomic_sub(u32)(&buf->unpause, 1, AL_ATOMIC_RELEASE);
+        atomic_sub(u32)(&buf->unpause, 1, AL_ATOMIC_RELEASE);
     }
 
     ptrdiff_t have = al_ring_buffer_occupied(&buf->rb);
@@ -397,7 +397,7 @@ ptrdiff_t camu_audio_buffer_read(struct camu_audio_buffer *buf, u8 *data, ptrdif
                 signal = have;
                 log_debug("Flushed (signal: %zd).", signal);
                 buf->callback(buf->userdata, CAMU_BUFFER_EOF);
-                al_atomic_store(u8)(&buf->flow, SIGNALED, AL_ATOMIC_RELEASE);
+                atomic_store(u32)(&buf->flow, SIGNALED, AL_ATOMIC_RELEASE);
             }
         } else {
             // Silence the remainder of the request.
@@ -454,7 +454,7 @@ ptrdiff_t camu_audio_buffer_read(struct camu_audio_buffer *buf, u8 *data, ptrdif
 #else
     if (flow == FLOWING) {
 #endif
-        ret = al_atomic_load(ptrdiff_t)(&buf->uncork_at, AL_ATOMIC_RELAXED);
+        ret = atomic_load(ptrdiff_t)(&buf->uncork_at, AL_ATOMIC_RELAXED);
         if (ret && have - req <= ret) {
             buf->callback(buf->userdata, CAMU_BUFFER_UNCORK);
         }
@@ -463,7 +463,7 @@ ptrdiff_t camu_audio_buffer_read(struct camu_audio_buffer *buf, u8 *data, ptrdif
 out:
     // We aren't safe to increment buf->pts from a different thread.
     // For that we could accumulate the difference and atomic_add here instead.
-    al_atomic_store(f64)(&buf->pts, base_pts, AL_ATOMIC_RELEASE);
+    atomic_store(f64)(&buf->pts, base_pts, AL_ATOMIC_RELEASE);
 
     // To signal EOF, return less then req.
     return signal;
diff --git a/src/buffer/audio.h b/src/buffer/audio.h
index a740c6c..db3c42f 100644
--- a/src/buffer/audio.h
+++ b/src/buffer/audio.h
@@ -33,7 +33,7 @@ struct camu_audio_buffer {
     struct { ptrdiff_t min, buffered; } mark;
     bool buffered;
 
-    atomic(u8) flow;
+    atomic(u32) flow;
 
     struct camu_peak_buffer peak;
     atomic(ptrdiff_t) uncork_at;
@@ -53,7 +53,7 @@ struct camu_audio_buffer {
 #endif
 
 #ifdef CAMU_MIXER_THREADED
-    atomic(u8) ref;
+    atomic(bool) ref;
 #endif
 
     void (*callback)(void *, u8);
diff --git a/src/buffer/common.h b/src/buffer/common.h
index bd9ca45..701969f 100644
--- a/src/buffer/common.h
+++ b/src/buffer/common.h
@@ -5,7 +5,7 @@
 #include <al/random.h>
 #define ROLL_FOR_BUFFER_ERROR(buf) do { \
     if (al_random_int(0, 254) == 72) { \
-        al_atomic_store(u8)(&(buf)->flow, FLUSHED_ERROR, AL_ATOMIC_RELAXED); \
+        al_atomic_store(u32)(&(buf)->flow, FLUSHED_ERROR, AL_ATOMIC_RELAXED); \
     } \
 } while (0)
 #endif
diff --git a/src/buffer/video.c b/src/buffer/video.c
index 5011e9d..8bcb1e1 100644
--- a/src/buffer/video.c
+++ b/src/buffer/video.c
@@ -25,15 +25,15 @@ bool camu_video_buffer_init(struct camu_video_buffer *buf, struct camu_clock *cl
 {
     buf->clock = clock;
     buf->latency = 0.0;
-    al_atomic_store(f64)(&buf->pts, -1.0, AL_ATOMIC_RELAXED);
+    atomic_store(f64)(&buf->pts, -1.0, AL_ATOMIC_RELAXED);
     buf->seek_pts = -1.0;
     buf->single_frame = true;
     buf->queue = NULL;
     buf->buffered = false;
     buf->weighted_first_read = false;
-    al_atomic_store(u8)(&buf->flow, FLOWING, AL_ATOMIC_RELAXED);
+    atomic_store(u32)(&buf->flow, FLOWING, AL_ATOMIC_RELAXED);
 #ifdef CAMU_SCREEN_THREADED
-    al_atomic_store(u8)(&buf->ref, 0, AL_ATOMIC_RELAXED);
+    atomic_store(bool)(&buf->ref, false, AL_ATOMIC_RELAXED);
 #endif
     buf->view.mode = CAMU_VIEW_NONE;
     return true;
@@ -123,12 +123,12 @@ static bool push_av_frame_internal(struct camu_video_buffer *buf, AVFrame *frame
 {
     AVStream *stream = buf->stream->av.stream;
     f64 pts = frame->best_effort_timestamp * av_q2d(stream->time_base);
-    f64 base_pts = al_atomic_load(f64)(&buf->pts, AL_ATOMIC_ACQUIRE);
+    f64 base_pts = atomic_load(f64)(&buf->pts, AL_ATOMIC_ACQUIRE);
     f64 duration = camu_ff_frame_duration(frame) * av_q2d(stream->time_base);
     if (!buf->single_frame && frame_is_late(buf->clock, base_pts, pts, duration)) {
         return false;
     }
-    if (base_pts == -1.0) al_atomic_store(f64)(&buf->pts, pts, AL_ATOMIC_RELEASE);
+    if (base_pts == -1.0) atomic_store(f64)(&buf->pts, pts, AL_ATOMIC_RELEASE);
     if (buf->fmt.scaler_needed) {
         if (!buf->scaler->scale(buf->scaler, (const u8 **)frame->data, frame->linesize)) {
             return false;
@@ -143,7 +143,7 @@ static bool push_av_frame_internal(struct camu_video_buffer *buf, AVFrame *frame
 
 void camu_video_buffer_push(struct camu_video_buffer *buf, struct camu_codec_frame *frame)
 {
-    u8 flow = al_atomic_load(u8)(&buf->flow, AL_ATOMIC_ACQUIRE);
+    u8 flow = atomic_load(u32)(&buf->flow, AL_ATOMIC_ACQUIRE);
     if (flow != FLOWING) {
         // A single frame will be FLUSHED after any push().
         if (buf->single_frame) {
@@ -155,9 +155,9 @@ void camu_video_buffer_push(struct camu_video_buffer *buf, struct camu_codec_fra
 
     switch (frame->mode) {
     case CAMU_NORMAL: {
-        f64 base_pts = al_atomic_load(f64)(&buf->pts, AL_ATOMIC_ACQUIRE);
+        f64 base_pts = atomic_load(f64)(&buf->pts, AL_ATOMIC_ACQUIRE);
         if (base_pts == -1.0) {
-            al_atomic_store(f64)(&buf->pts, 0.0, AL_ATOMIC_RELEASE);
+            atomic_store(f64)(&buf->pts, 0.0, AL_ATOMIC_RELEASE);
         }
         buf->queue->push(buf->queue, frame, 0.0);
         break;
@@ -178,7 +178,7 @@ void camu_video_buffer_push(struct camu_video_buffer *buf, struct camu_codec_fra
     if (!buf->buffered && (buf->single_frame || count >= BUFFER_MARK_BUFFERED)) {
         // Preserve order of: set flow -> flush -> callback, for single frames.
         if (buf->single_frame) {
-            al_atomic_store(u8)(&buf->flow, FLUSHED, AL_ATOMIC_RELEASE);
+            atomic_store(u32)(&buf->flow, FLUSHED, AL_ATOMIC_RELEASE);
             buf->queue->flush(buf->queue);
         }
         buf->buffered = true;
@@ -204,7 +204,7 @@ void camu_video_buffer_flush(struct camu_video_buffer *buf, bool error)
 {
     log_debug("Flush requested.");
     u8 flow = error ? FLUSHED_ERROR : FLUSHED;
-    al_atomic_store(u8)(&buf->flow, flow, AL_ATOMIC_RELAXED);
+    atomic_store(u32)(&buf->flow, flow, AL_ATOMIC_RELAXED);
     buf->queue->flush(buf->queue);
     if (!buf->buffered) {
         s32 count = buf->queue->count(buf->queue);
@@ -221,10 +221,10 @@ void camu_video_buffer_flush(struct camu_video_buffer *buf, bool error)
 void camu_video_buffer_reset(struct camu_video_buffer *buf, f64 pts)
 {
     buf->seek_pts = pts;
-    al_atomic_store(f64)(&buf->pts, -1.0, AL_ATOMIC_RELAXED);
+    atomic_store(f64)(&buf->pts, -1.0, AL_ATOMIC_RELAXED);
     if (buf->queue) buf->queue->reset(buf->queue);
     buf->buffered = false;
-    al_atomic_store(u8)(&buf->flow, FLOWING, AL_ATOMIC_RELAXED);
+    atomic_store(u32)(&buf->flow, FLOWING, AL_ATOMIC_RELAXED);
 }
 
 bool camu_video_buffer_read(struct camu_video_buffer *buf, void *out, bool *weighted)
@@ -232,7 +232,7 @@ bool camu_video_buffer_read(struct camu_video_buffer *buf, void *out, bool *weig
     // Assert this buffer isn't being read before we signaled BUFFER_BUFFERED.
     al_assert(buf->buffered);
 
-    f64 base_pts = al_atomic_load(f64)(&buf->pts, AL_ATOMIC_ACQUIRE);
+    f64 base_pts = atomic_load(f64)(&buf->pts, AL_ATOMIC_ACQUIRE);
     if (!buf->single_frame) {
         bool set_clock = !buf->weighted_first_read;
         f64 pts = camu_clock_get_pts(buf->clock, buf->latency, set_clock);
@@ -241,22 +241,29 @@ bool camu_video_buffer_read(struct camu_video_buffer *buf, void *out, bool *weig
         }
     }
 
-    u8 flow = al_atomic_load(u8)(&buf->flow, AL_ATOMIC_ACQUIRE);
+    u8 flow = atomic_load(u32)(&buf->flow, AL_ATOMIC_ACQUIRE);
     if (flow == ERRORED) return false;
     u8 ret = buf->queue->read(buf->queue, base_pts, out);
     if (ret == CAMU_QUEUE_ERR || flow == FLUSHED_ERROR) {
         buf->callback(buf->userdata, CAMU_BUFFER_ERRORED);
-        al_atomic_store(u8)(&buf->flow, ERRORED, AL_ATOMIC_RELEASE);
+        atomic_store(u32)(&buf->flow, ERRORED, AL_ATOMIC_RELEASE);
         return false;
     }
 
+    // We must update buf->pts on every read(), even on QUEUE_MORE.
+    // Consdier a case where the PTS we call queue->read() with does nothing but
+    // drop frames and returns QUEUE_MORE. If we didn't update buf->pts during
+    // that call and on the next call to read() the clock is paused, base_pts
+    // will erroneously be less than PTS we just used on the previous read().
+    atomic_store(f64)(&buf->pts, base_pts, AL_ATOMIC_RELEASE);
+
     // If a buffer only ever has 1 frame, libplacebo will never return EOF.
     // In our code that 1 frame buffer might be a video, in which case that behavior is erroneous.
     bool eof = ret == CAMU_QUEUE_EOF || (buf->buffered_with_one_frame && ret == CAMU_QUEUE_OK);
     if (flow == FLUSHED && eof) {
         log_debug("Flushed.");
         buf->callback(buf->userdata, CAMU_BUFFER_EOF);
-        al_atomic_store(u8)(&buf->flow, SIGNALED, AL_ATOMIC_RELEASE);
+        atomic_store(u32)(&buf->flow, SIGNALED, AL_ATOMIC_RELEASE);
     } else if (flow == FLOWING) {
         // Never attempt to uncork if flow = FLUSHED.
         s32 count = buf->queue->count(buf->queue);
@@ -269,16 +276,9 @@ bool camu_video_buffer_read(struct camu_video_buffer *buf, void *out, bool *weig
         }
     }
 
-    if (ret == CAMU_QUEUE_OK) {
-        // Only updating buf->pts on QUEUE_OK affects the behavior when we fall completely behind.
-        // Setting it here will result in laggily displaying out of date frames as they come in.
-        // Setting it on every read() will cause the video to freeze.
-        // This option ignores sync but is easier for the user to understand what's happening.
-        al_atomic_store(f64)(&buf->pts, base_pts, AL_ATOMIC_RELEASE);
-        if (UNLIKELY(buf->weighted_first_read)) {
-            *weighted = true;
-            buf->weighted_first_read = false;
-        }
+    if (UNLIKELY(ret == CAMU_QUEUE_OK && buf->weighted_first_read)) {
+        *weighted = true;
+        buf->weighted_first_read = false;
     } else if (ret == CAMU_QUEUE_MORE) {
         log_trace("Underrun.");
     }
diff --git a/src/buffer/video.h b/src/buffer/video.h
index 20644bc..112688a 100644
--- a/src/buffer/video.h
+++ b/src/buffer/video.h
@@ -32,10 +32,10 @@ struct camu_video_buffer {
     // Flush the renderer on this read and don't allow it to set the clock.
     bool weighted_first_read;
 
-    atomic(u8) flow;
+    atomic(u32) flow;
 
 #ifdef CAMU_SCREEN_THREADED
-    atomic(u8) ref;
+    atomic(bool) ref;
 #endif
 
     // Previous view, set from screen::add_buffer_internal().
diff --git a/src/buffer/video_null.h b/src/buffer/video_null.h
index f82a4d3..da9d969 100644
--- a/src/buffer/video_null.h
+++ b/src/buffer/video_null.h
@@ -12,7 +12,7 @@ struct camu_video_buffer {
     bool single_frame;
     f64 avg_frame_duration;
 #ifdef CAMU_SCREEN_THREADED
-    atomic(u8) ref;
+    atomic(bool) ref;
 #endif
     void (*callback)(void *, u8);
     void *userdata;
@@ -31,7 +31,7 @@ static bool camu_video_buffer_init(struct camu_video_buffer *buf, struct camu_cl
     buf->single_frame = true;
     buf->avg_frame_duration = 0.0;
 #ifdef CAMU_SCREEN_THREADED
-    al_atomic_store(u8)(&buf->ref, 0, AL_ATOMIC_RELAXED);
+    al_atomic_store(bool)(&buf->ref, false, AL_ATOMIC_RELAXED);
 #endif
     return true;
 }
diff --git a/src/cache/handlers/cdio.c b/src/cache/handlers/cdio.c
index a9e3747..8326868 100644
--- a/src/cache/handlers/cdio.c
+++ b/src/cache/handlers/cdio.c
@@ -42,7 +42,7 @@ static nn_thread_result NNWT_THREADCALL cd_read_thread(void *userdata)
     nn_thread_set_name("cdio_read");
 
     for (;;) {
-        if (!al_atomic_load(s32)(&cdio->running, AL_ATOMIC_RELAXED)) {
+        if (!atomic_load(bool)(&cdio->running, AL_ATOMIC_RELAXED)) {
             // We don't care about how complete the read was.
             return 0;
         }
@@ -88,13 +88,13 @@ static void handler_cdio_maybe_spawn_worker(struct cch_handler *handler, size_t
 {
     struct cch_handler_cdio *cdio = (struct cch_handler_cdio *)handler;
     if (cdio->start == (lsn_t)index) return;
-    if (al_atomic_load(s32)(&cdio->running, AL_ATOMIC_ACQUIRE)) {
-        al_atomic_store(s32)(&cdio->running, 0, AL_ATOMIC_RELEASE);
+    if (atomic_load(bool)(&cdio->running, AL_ATOMIC_ACQUIRE)) {
+        atomic_store(bool)(&cdio->running, false, AL_ATOMIC_RELEASE);
         nn_thread_join(&cdio->thread);
     }
     cdio->start = index;
     cdio->sector = cdio->start;
-    al_atomic_store(s32)(&cdio->running, 1, AL_ATOMIC_RELEASE);
+    atomic_store(bool)(&cdio->running, true, AL_ATOMIC_RELEASE);
     nn_thread_create(&cdio->thread, cd_read_thread, cdio);
 }
 
@@ -114,8 +114,8 @@ static void handler_cdio_free(struct cch_handler **handler)
 {
     struct cch_handler_cdio *cdio = (struct cch_handler_cdio *)*handler;
     cch_threaded_waits_disable_all(&cdio->waits);
-    if (al_atomic_load(s32)(&cdio->running, AL_ATOMIC_RELAXED)) {
-        al_atomic_store(s32)(&cdio->running, 0, AL_ATOMIC_RELAXED);
+    if (atomic_load(bool)(&cdio->running, AL_ATOMIC_RELAXED)) {
+        atomic_store(bool)(&cdio->running, false, AL_ATOMIC_RELAXED);
         nn_thread_join(&cdio->thread);
     }
     if (cdio->drive) {
@@ -209,7 +209,7 @@ struct cch_entry *cch_handler_cdio_create(void)
     if (!open_cd_drive(cdio)) {
         return NULL;
     }
-    al_atomic_store(s32)(&cdio->running, 0, AL_ATOMIC_RELAXED);
+    atomic_store(bool)(&cdio->running, false, AL_ATOMIC_RELAXED);
     nn_buffer_init(&cdio->buffer);
     nn_buffer_ensure_space(&cdio->buffer, BYTES_PER_STEP);
     cdio->buffer.size = BYTES_PER_STEP;
diff --git a/src/cache/handlers/cdio.h b/src/cache/handlers/cdio.h
index a2734ca..6ef37b9 100644
--- a/src/cache/handlers/cdio.h
+++ b/src/cache/handlers/cdio.h
@@ -15,7 +15,7 @@ struct cch_handler_cdio {
     lsn_t end;
     lsn_t sector;
     struct nn_buffer buffer;
-    atomic(s32) running;
+    atomic(bool) running;
     struct nn_thread thread;
     struct cch_threaded_waits waits;
 };
diff --git a/src/liana/list.c b/src/liana/list.c
index 253ba5f..cd073ad 100644
--- a/src/liana/list.c
+++ b/src/liana/list.c
@@ -46,7 +46,6 @@ void lia_list_init(struct lia_list *list, str *name)
 
 // These small functions may seem excessive but their purpose is an attempt
 // to reduce noise in parts that are harder to understand.
-
 static inline void list_signal_meta(struct lia_list *list, struct lia_list_entry *entry, u8 meta)
 {
     list->callback(list->userdata, LIANA_LIST_META, entry, (u8[]){ meta });
diff --git a/src/liana/list.h b/src/liana/list.h
index c8b1d73..e8b1769 100644
--- a/src/liana/list.h
+++ b/src/liana/list.h
@@ -8,7 +8,7 @@
 
 #define LIANA_SEQUENCE_ANY -1
 
-#define LIANA_BASE_DELAY 450000u // 450ms
+#define LIANA_BASE_DELAY 1250000u // 1250ms
 #define LIANA_BASE_PING 150000u // 150ms
 #define LIANA_PAUSE_DELAY LIANA_BASE_PING
 #define LIANA_DELAY_IGNORE 0u
diff --git a/src/libsink/sink.c b/src/libsink/sink.c
index fccbc3e..0db5da2 100644
--- a/src/libsink/sink.c
+++ b/src/libsink/sink.c
@@ -133,7 +133,7 @@ AL_STATIC_ASSERT(max_age_lt_lru, ENTRY_MAX_AGE, <, SINK_LRU_MAX);
 static inline bool entry_audio_buffer_held(struct camu_sink_entry *entry)
 {
 #ifdef CAMU_MIXER_THREADED
-    return atomic_load(u8)(&entry->audio.buf.ref, AL_ATOMIC_RELAXED) == 1;
+    return atomic_load(bool)(&entry->audio.buf.ref, AL_ATOMIC_RELAXED);
 #else
     (void)entry;
     return false;
@@ -143,7 +143,7 @@ static inline bool entry_audio_buffer_held(struct camu_sink_entry *entry)
 static inline bool entry_video_buffer_held(struct camu_sink_entry *entry)
 {
 #ifdef CAMU_SCREEN_THREADED
-    return atomic_load(u8)(&entry->video.buf.ref, AL_ATOMIC_RELAXED) == 1;
+    return atomic_load(bool)(&entry->video.buf.ref, AL_ATOMIC_RELAXED);
 #else
     (void)entry;
     return false;
@@ -1193,7 +1193,7 @@ static void client_callback(void *userdata, u8 op, struct camu_codec_stream *str
             camu_audio_buffer_set_no_video(&entry->audio.buf, ignore_video);
         }
         if (!ignore_video) {
-            camu_video_buffer_reset(&entry->video.buf, time->pos);
+            camu_video_buffer_reset(&entry->video.buf, time->pos / 1000000.0);
         }
 #ifdef LIANA_LIST_SCUFFED_LOOP
         if (time->pos == 0) {
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);
diff --git a/src/render/meson.build b/src/render/meson.build
index a7ccb58..d0ad643 100644
--- a/src/render/meson.build
+++ b/src/render/meson.build
@@ -169,6 +169,23 @@ if get_option('subtitles').enabled()
   endif
   if not libass_found
     libass_opts = ['test=disabled']
+    # freetype2(42608f7):meson.build:346
+    harfbuz = dependency('harfbuzz',
+      version: '>=2.0.0',
+      default_options: [
+        'glib=disabled',
+        'gobject=disabled',
+        'cairo=disabled',
+        'chafa=disabled',
+        'icu=disabled',
+        'freetype=disabled',
+        # This does not override yield, and yielding breaks the build if tests=enabled.
+        # https://github.com/mesonbuild/meson/issues/5214
+        'tests=disabled',
+        'introspection=disabled',
+        'docs=disabled',
+        'utilities=disabled'
+      ])
     if not is_windows
       libass_opts += ['fontconfig=enabled']
       # libass(e46aede):meson.build:126
@@ -179,7 +196,8 @@ if get_option('subtitles').enabled()
           'nls=disabled',
           'tests=disabled',
           'tools=disabled',
-          'cache-build=disabled'
+          'cache-build=disabled',
+          'xml-backend=libxml2'
         ])
     else
       libass_opts += ['directwrite=enabled']
@@ -204,23 +222,6 @@ if get_option('subtitles').enabled()
         'tests=false',
         'bin=false'
       ])
-    # freetype2(42608f7):meson.build:346
-    harfbuz = dependency('harfbuzz',
-      version: '>=2.0.0',
-      default_options: [
-        'glib=disabled',
-        'gobject=disabled',
-        'cairo=disabled',
-        'chafa=disabled',
-        'icu=disabled',
-        'freetype=disabled',
-        # This does not override yield, and yielding breaks the build if tests=enabled.
-        # https://github.com/mesonbuild/meson/issues/5214
-        'tests=disabled',
-        'introspection=disabled',
-        'docs=disabled',
-        'utilities=disabled'
-      ])
     libass = dependency('libass', default_options: libass_opts)
   endif
   render_deps += [libass]
diff --git a/src/render/renderer_libplacebo.c b/src/render/renderer_libplacebo.c
index 01aa764..3551979 100644
--- a/src/render/renderer_libplacebo.c
+++ b/src/render/renderer_libplacebo.c
@@ -376,7 +376,7 @@ static bool renderer_lp_render(struct camu_renderer *renderer, struct camu_scree
     struct camu_renderer_lp *lr = (struct camu_renderer_lp *)renderer;
 
 #ifdef CAMU_SCREEN_THREADED
-    if (al_atomic_load(u8)(&scr->queued, AL_ATOMIC_RELAXED)) {
+    if (atomic_load(bool)(&scr->queued, AL_ATOMIC_RELAXED)) {
         camu_screen_run_queue(scr);
     }
 #endif
@@ -478,7 +478,7 @@ static bool renderer_lp_render(struct camu_renderer *renderer, struct camu_scree
         }
         if (any_eof) {
 #ifdef CAMU_SCREEN_THREADED
-            if (al_atomic_load(u8)(&scr->queued, AL_ATOMIC_RELAXED)) {
+            if (atomic_load(bool)(&scr->queued, AL_ATOMIC_RELAXED)) {
                 camu_screen_run_queue(scr);
             }
 #endif
diff --git a/src/screen/screen.c b/src/screen/screen.c
index f6833dd..701b39e 100644
--- a/src/screen/screen.c
+++ b/src/screen/screen.c
@@ -47,7 +47,7 @@ static void do_resize(struct camu_screen *scr, u32 width, u32 height)
         camu_view_calculate(&video->view, scr->width, scr->height);
     }
     // No buffers resize.
-    al_atomic_add(u32)(&scr->force_refresh, 1, AL_ATOMIC_RELAXED);
+    atomic_add(u32)(&scr->force_refresh, 1, AL_ATOMIC_RELAXED);
 }
 
 static void resize_callback(void *userdata, u32 width, u32 height)
@@ -400,7 +400,7 @@ static bool key_callback(void *userdata, u8 state, u16 button)
                 log_info("Background solid.");
             }
             // Force refresh for if there's no video buffer.
-            al_atomic_add(u32)(&scr->force_refresh, 1, AL_ATOMIC_RELAXED);
+            atomic_add(u32)(&scr->force_refresh, 1, AL_ATOMIC_RELAXED);
             return true;
         case STELA_KEY_V: {
             if (SCREEN_MOD1(scr)) {
@@ -469,7 +469,7 @@ static void key_immediate_callback(void *userdata, u8 state, u16 button)
 
 bool camu_screen_init(struct camu_screen *scr)
 {
-    al_atomic_store(s32)(&scr->state, CAMU_SCREEN_PAUSED, AL_ATOMIC_RELAXED);
+    atomic_store(s32)(&scr->state, CAMU_SCREEN_PAUSED, AL_ATOMIC_RELAXED);
     scr->window = stl_window_create();
     scr->window->render_callback = render_callback;
     scr->window->resize_callback = resize_callback;
@@ -482,7 +482,7 @@ bool camu_screen_init(struct camu_screen *scr)
     scr->window->should_close_callback = should_close_callback;
     scr->window->userdata = scr;
     scr->renderer = NULL;
-    al_atomic_store(u32)(&scr->force_refresh, 1, AL_ATOMIC_RELAXED);
+    atomic_store(u32)(&scr->force_refresh, 1, AL_ATOMIC_RELAXED);
     scr->flags = CAMU_SCREEN_ZOOM_PAN_SIMPLE;
     scr->scaling_disabled = false;
     scr->transparent_background = false;
@@ -502,7 +502,7 @@ bool camu_screen_init(struct camu_screen *scr)
 #ifdef CAMU_SCREEN_THREADED
     al_array_init(scr->add_queue);
     al_array_init(scr->rem_queue);
-    al_atomic_store(u8)(&scr->queued, 0, AL_ATOMIC_RELAXED);
+    atomic_store(bool)(&scr->queued, false, AL_ATOMIC_RELAXED);
     nn_mutex_init(&scr->mutex);
 #endif
     return true;
@@ -584,7 +584,7 @@ static void add_buffer_internal(struct camu_screen *scr, struct camu_video_buffe
     }
     camu_view_calculate(&video.view, scr->width, scr->height);
 #ifdef CAMU_SCREEN_THREADED
-    al_atomic_store(u8)(&buf->ref, 1, AL_ATOMIC_RELAXED);
+    atomic_store(bool)(&buf->ref, true, AL_ATOMIC_RELAXED);
 #endif
     al_array_push(scr->videos, video);
 }
@@ -596,7 +596,7 @@ static void remove_buffer_internal(struct camu_screen *scr, struct camu_video_bu
         if (video->buf == buf) {
             buf->view = video->view;
 #ifdef CAMU_SCREEN_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(scr->videos, i);
             break;
@@ -639,14 +639,14 @@ void camu_screen_add_buffer(struct camu_screen *scr, struct camu_video_buffer *b
             al_array_remove_at(scr->rem_queue, i);
             bool queue_empty = scr->add_queue.count + scr->rem_queue.count == 0;
             if (queue_empty) {
-                al_atomic_store(u8)(&scr->queued, 0, AL_ATOMIC_RELAXED);
+                atomic_store(bool)(&scr->queued, false, AL_ATOMIC_RELAXED);
             }
             nn_mutex_unlock(&scr->mutex);
             return;
         }
     }
     al_array_push(scr->add_queue, buf);
-    al_atomic_store(u8)(&scr->queued, 1, AL_ATOMIC_RELAXED);
+    atomic_store(bool)(&scr->queued, true, AL_ATOMIC_RELAXED);
     nn_mutex_unlock(&scr->mutex);
 #else
     add_buffer_internal(scr, buf);
@@ -670,14 +670,14 @@ void camu_screen_remove_buffer(struct camu_screen *scr, struct camu_video_buffer
             al_array_remove_at(scr->add_queue, i);
             bool queue_empty = scr->add_queue.count + scr->rem_queue.count == 0;
             if (queue_empty) {
-                al_atomic_store(u8)(&scr->queued, 0, AL_ATOMIC_RELAXED);
+                atomic_store(bool)(&scr->queued, false, AL_ATOMIC_RELAXED);
             }
             nn_mutex_unlock(&scr->mutex);
             return;
         }
     }
     al_array_push(scr->rem_queue, buf);
-    al_atomic_store(u8)(&scr->queued, 1, AL_ATOMIC_RELAXED);
+    atomic_store(bool)(&scr->queued, true, AL_ATOMIC_RELAXED);
     nn_mutex_unlock(&scr->mutex);
 #else
     remove_buffer_internal(scr, buf);
@@ -690,7 +690,7 @@ void camu_screen_run_queue(struct camu_screen *scr)
 {
     nn_mutex_lock(&scr->mutex);
     run_queue_internal(scr);
-    al_atomic_store(u8)(&scr->queued, 0, AL_ATOMIC_RELAXED);
+    atomic_store(bool)(&scr->queued, false, AL_ATOMIC_RELAXED);
     nn_mutex_unlock(&scr->mutex);
 }
 
@@ -700,7 +700,7 @@ void camu_screen_clear(struct camu_screen *scr)
     struct camu_screen_video *video;
     al_array_foreach_ptr(scr->videos, i, video) {
         struct camu_video_buffer *buf = video->buf;
-        al_atomic_store(u8)(&buf->ref, 0, AL_ATOMIC_RELAXED);
+        atomic_store(bool)(&buf->ref, false, AL_ATOMIC_RELAXED);
     }
     nn_mutex_unlock(&scr->mutex);
 }
@@ -711,15 +711,15 @@ void camu_screen_set_state(struct camu_screen *scr, s32 state)
     // If state = PAUSED, remove_buffer() relies on screen_wake().
     // Unlike mixer_pause() there are no special considerations needed for
     // the buffer queue at the point we set state to PAUSED.
-    al_atomic_store(s32)(&scr->state, state, AL_ATOMIC_RELEASE);
+    atomic_store(s32)(&scr->state, state, AL_ATOMIC_RELEASE);
     if (state == CAMU_SCREEN_PAUSED) {
-        al_atomic_add(u32)(&scr->force_refresh, 1, AL_ATOMIC_RELAXED);
+        atomic_add(u32)(&scr->force_refresh, 1, AL_ATOMIC_RELAXED);
     }
 }
 
 void camu_screen_force_refresh(struct camu_screen *scr)
 {
-    al_atomic_add(u32)(&scr->force_refresh, 1, AL_ATOMIC_RELAXED);
+    atomic_add(u32)(&scr->force_refresh, 1, AL_ATOMIC_RELAXED);
     camu_screen_wake(scr);
 }
 
@@ -746,17 +746,17 @@ bool camu_screen_poll(struct camu_screen *scr, bool block)
 
 bool camu_screen_tick(struct camu_screen *scr, bool *force)
 {
-    s32 state = al_atomic_load(s32)(&scr->state, AL_ATOMIC_RELAXED);
-    u32 force_refresh = al_atomic_load(u32)(&scr->force_refresh, AL_ATOMIC_ACQUIRE);
+    s32 state = atomic_load(s32)(&scr->state, AL_ATOMIC_RELAXED);
+    u32 force_refresh = atomic_load(u32)(&scr->force_refresh, AL_ATOMIC_ACQUIRE);
     bool paused = !scr->vr_emulation && state == CAMU_SCREEN_PAUSED && force_refresh == 0;
     bool do_render = camu_screen_poll(scr, paused) || !paused;
     // Should be AL_ATOMIC_ACQ_REL.
-    force_refresh = al_atomic_load(u32)(&scr->force_refresh, AL_ATOMIC_ACQUIRE);
+    force_refresh = atomic_load(u32)(&scr->force_refresh, AL_ATOMIC_ACQUIRE);
     do_render |= force_refresh > 0;
     *force = force_refresh > 0;
     log_trace("tick (do_render: %s, force_refresh: %u).", BOOLSTR(do_render), force_refresh);
     if (force_refresh > 0) {
-        al_atomic_sub(u32)(&scr->force_refresh, 1, AL_ATOMIC_RELEASE);
+        atomic_sub(u32)(&scr->force_refresh, 1, AL_ATOMIC_RELEASE);
     }
     return do_render;
 }
diff --git a/src/screen/screen.h b/src/screen/screen.h
index e12d0ae..aded49c 100644
--- a/src/screen/screen.h
+++ b/src/screen/screen.h
@@ -86,7 +86,7 @@ struct camu_screen {
 #ifdef CAMU_SCREEN_THREADED
     array(struct camu_video_buffer *) add_queue;
     array(struct camu_video_buffer *) rem_queue;
-    atomic(u8) queued;
+    atomic(bool) queued;
     struct nn_mutex mutex;
 #endif
     void (*callback)(void *, u8, void *);