Sink refactor wip

Dangling target won't stay around. I have a couple of ideas about how to massively simplify the handling of ended entries.

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

2 files changed, 91 insertions, 83 deletions

diff --git a/src/screen/screen.c b/src/screen/screen.c
index d0926da..ed4345d 100644
--- a/src/screen/screen.c
+++ b/src/screen/screen.c
@@ -5,28 +5,36 @@
 #include "view.h"
 #include "screen.h"
 
+#define SCREEN_MOD1(scr) ((scr)->flags & CAMU_SCREEN_MOD_CONTROL)
+#define SCREEN_MOD2(scr) ((scr)->flags & CAMU_SCREEN_MOD_SHIFT)
+#define SCREEN_IS_DRAGGING(scr) ((scr)->flags & CAMU_SCREEN_DRAGGING)
+#define SCREEN_ZOOM_MODE(scr, mode) ((scr)->flags & mode)
 #define SCREEN_INVALID_TS ((u64)-1)
+#define SCREEN_LAST_CLICK_WITHIN(ns) \
+    (((scr)->last_click_ts != SCREEN_INVALID_TS) && (nn_get_timestamp() - (scr)->last_click_ts <= ns))
 
-static struct camu_view *get_view_from_mouse_pos(struct camu_screen *scr)
+static void should_close_callback(void *userdata)
 {
-    struct camu_view *view = NULL;
-    struct camu_screen_video *video;
-    al_array_foreach_ptr(scr->videos, i, video) {
-        if (!view) {
-            view = &video->view;
-            continue;
-        }
-        if (view->zindex < video->view.zindex) {
-            view = &video->view;
-        }
+    struct camu_screen *scr = (struct camu_screen *)userdata;
+    scr->callback(scr->userdata, CAMU_SCREEN_CLOSE, NULL);
+}
+
+static void render_callback(void *userdata)
+{
+    struct camu_screen *scr = (struct camu_screen *)userdata;
+    bool force;
+    if (scr->renderer && camu_screen_tick(scr, &force)) {
+        scr->renderer->render(scr->renderer, scr, force);
     }
-    return view;
 }
 
-static void should_close_callback(void *userdata)
+static void refresh_callback(void *userdata)
 {
     struct camu_screen *scr = (struct camu_screen *)userdata;
-    scr->callback(scr->userdata, CAMU_SCREEN_CLOSE, NULL);
+    if (scr->renderer) {
+        // The thread-safety of this is questionable.
+        scr->renderer->render(scr->renderer, scr, true);
+    }
 }
 
 static void do_resize(struct camu_screen *scr, u32 width, u32 height)
@@ -51,29 +59,30 @@ static void resize_callback(void *userdata, u32 width, u32 height)
     do_resize(scr, width, height);
 }
 
-static void refresh_callback(void *userdata)
+static struct camu_view *get_view_from_mouse_pos(struct camu_screen *scr)
 {
-    struct camu_screen *scr = (struct camu_screen *)userdata;
-    if (scr->renderer) {
-        // The thread-safety of this is questionable.
-        scr->renderer->render(scr->renderer, scr, true);
+    struct camu_view *view = NULL;
+    struct camu_screen_video *video;
+    al_array_foreach_ptr(scr->videos, i, video) {
+        if (!view) {
+            view = &video->view;
+            continue;
+        }
+        if (view->zindex < video->view.zindex) {
+            view = &video->view;
+        }
     }
+    return view;
 }
 
-static void seek_to_percent_at_pointer(struct camu_screen *scr)
-{
-    f64 percent = scr->last_mouse_x / scr->width;
-    percent = CLAMP(percent, 0.0, 100.0);
-    scr->callback(scr->userdata, CAMU_SCREEN_SEEK, &percent);
-}
 
 static bool pointer_pos_callback(void *userdata, f64 x, f64 y)
 {
     struct camu_screen *scr = (struct camu_screen *)userdata;
     struct camu_view *view = get_view_from_mouse_pos(scr);
     bool queue_refresh = false;
-    if (scr->flags & CAMU_SCREEN_DRAGGING) {
-        if (view && scr->flags & CAMU_SCREEN_ZOOM_PAN_SIMPLE) {
+    if (SCREEN_IS_DRAGGING(scr)) {
+        if (view && SCREEN_ZOOM_MODE(scr, CAMU_SCREEN_ZOOM_PAN_SIMPLE)) {
             f64 dx = x - scr->last_mouse_x;
             f64 dy = y - scr->last_mouse_y;
             if (camu_view_pan_simple(view, scr->width, scr->height, dx, dy)) {
@@ -90,6 +99,13 @@ static bool pointer_pos_callback(void *userdata, f64 x, f64 y)
     return queue_refresh;
 }
 
+static void seek_to_percent_at_pointer(struct camu_screen *scr)
+{
+    f64 percent = scr->last_mouse_x / scr->width;
+    percent = CLAMP(percent, 0.0, 100.0);
+    scr->callback(scr->userdata, CAMU_SCREEN_PERCENT_SEEK, &percent);
+}
+
 static bool mouse_button_callback(void *userdata, u8 state, u8 button)
 {
     struct camu_screen *scr = (struct camu_screen *)userdata;
@@ -102,30 +118,17 @@ static bool mouse_button_callback(void *userdata, u8 state, u8 button)
             break;
         case STELA_BUTTON_RELEASED:
             scr->flags &= ~CAMU_SCREEN_DRAGGING;
-            if (scr->last_click_ts != SCREEN_INVALID_TS && nn_get_timestamp() - scr->last_click_ts <= 300000) {
-                if (scr->flags & CAMU_SCREEN_MOD_CONTROL) {
+            if (SCREEN_LAST_CLICK_WITHIN(200000)) {
+                if (SCREEN_MOD1(scr)) {
                     seek_to_percent_at_pointer(scr);
                 } else {
-                    if (scr->last_mouse_x >= scr->width / 2.0) {
-                        scr->callback(scr->userdata, CAMU_SCREEN_NEXT, NULL);
-                    } else {
-                        scr->callback(scr->userdata, CAMU_SCREEN_PREVIOUS, NULL);
-                    }
+                    s32 n = (scr->last_mouse_x >= scr->width / 2.0) ? 1 : -1;
+                    scr->callback(scr->userdata, CAMU_SCREEN_SKIP, &n);
                 }
             }
             break;
         }
         break;
-    case STELA_MOUSE2:
-        switch (state) {
-        case STELA_BUTTON_PRESSED:
-            scr->flags |= CAMU_SCREEN_MOD_CONTROL;
-            break;
-        case STELA_BUTTON_RELEASED:
-            scr->flags &= ~CAMU_SCREEN_MOD_CONTROL;
-            break;
-        }
-        break;
     case STELA_MOUSE3: {
         switch (state) {
         case STELA_BUTTON_RELEASED: {
@@ -141,30 +144,28 @@ static bool mouse_button_callback(void *userdata, u8 state, u8 button)
     return false;
 }
 
+static bool scroll_callback(void *userdata, f64 y)
+{
+    struct camu_screen *scr = (struct camu_screen *)userdata;
+    if (SCREEN_MOD1(scr)) {
+        f32 change = y < 0.0 ? 0.025 : -0.025;
+        scr->callback(scr->userdata, CAMU_SCREEN_OFFSET_VOLUME, &change);
+    } else {
+        // This sucks.
 #if defined STELA_WINDOW_WAYLAND
-#define SCROLL_MULTIPLIER 160.0
+        y = -y / 160.0;
 #elif defined STELA_WINDOW_WIN32
-#define SCROLL_MULTIPLIER 1200.0
+        y = -y / 1600.0;
 #else
-#define SCROLL_MULTIPLIER 20.0
+        y = -y / 20.0;
 #endif
-
-static bool scroll_callback(void *userdata, f64 y)
-{
-    struct camu_screen *scr = (struct camu_screen *)userdata;
-    y = -y / SCROLL_MULTIPLIER;
-    if (!(scr->flags & CAMU_SCREEN_MOD_CONTROL)) {
         struct camu_view *view = get_view_from_mouse_pos(scr);
-        if (view) {
-            if (scr->flags & CAMU_SCREEN_ZOOM_PAN_SIMPLE) {
-                if (camu_view_zoom_simple(view, scr->width, scr->height, scr->last_mouse_x, scr->last_mouse_y, y)) {
-                    view->mode = CAMU_VIEW_DETACHED;
-                    return true;
-                }
+        if (view && SCREEN_ZOOM_MODE(scr, CAMU_SCREEN_ZOOM_PAN_SIMPLE)) {
+            if (camu_view_zoom_simple(view, scr->width, scr->height, scr->last_mouse_x, scr->last_mouse_y, y)) {
+                view->mode = CAMU_VIEW_DETACHED;
+                return true;
             }
         }
-    } else {
-        scr->callback(scr->userdata, CAMU_SCREEN_OFFSET_VOLUME, &y);
     }
     return false;
 }
@@ -187,27 +188,36 @@ static bool key_callback(void *userdata, u8 state, u16 button)
             scr->callback(scr->userdata, CAMU_SCREEN_CLOSE, NULL);
             break;
         case STELA_KEY_RIGHT:
-            if (scr->flags & CAMU_SCREEN_MOD_CONTROL) {
-                f64 plus_ten = 10.0;
-                scr->callback(scr->userdata, CAMU_SCREEN_RELATIVE_SEEK, &plus_ten);
+            if (SCREEN_MOD1(scr)) {
+                f64 plus_ten_seconds = 10.0;
+                scr->callback(scr->userdata, CAMU_SCREEN_RELATIVE_SEEK, &plus_ten_seconds);
                 break;
             }
             // fallthrough
         case STELA_KEY_D:
-        case STELA_KEY_N:
-            scr->callback(scr->userdata, CAMU_SCREEN_NEXT, NULL);
+        case STELA_KEY_N: {
+            s32 n = 1;
+            scr->callback(scr->userdata, CAMU_SCREEN_SKIP, &n);
             break;
+        }
         case STELA_KEY_LEFT:
-            if (scr->flags & CAMU_SCREEN_MOD_CONTROL) {
-                f64 minus_ten = -10.0;
-                scr->callback(scr->userdata, CAMU_SCREEN_RELATIVE_SEEK, &minus_ten);
+            if (SCREEN_MOD1(scr)) {
+                if (SCREEN_MOD2(scr)) {
+                    f64 zero = 0.0;
+                    scr->callback(scr->userdata, CAMU_SCREEN_PERCENT_SEEK, &zero);
+                } else {
+                    f64 minus_ten_seconds = -10.0;
+                    scr->callback(scr->userdata, CAMU_SCREEN_RELATIVE_SEEK, &minus_ten_seconds);
+                }
                 break;
             }
             // fallthrough
         case STELA_KEY_B:
-        case STELA_KEY_A:
-            scr->callback(scr->userdata, CAMU_SCREEN_PREVIOUS, NULL);
+        case STELA_KEY_A: {
+            s32 n = -1;
+            scr->callback(scr->userdata, CAMU_SCREEN_SKIP, &n);
             break;
+        }
         case STELA_KEY_SPACE:
             scr->callback(scr->userdata, CAMU_SCREEN_TOGGLE_PAUSE, NULL);
             break;
@@ -233,7 +243,7 @@ static bool key_callback(void *userdata, u8 state, u16 button)
         case STELA_KEY_R: {
             struct camu_view *view = get_view_from_mouse_pos(scr);
             if (view) {
-                if (scr->flags & CAMU_SCREEN_MOD_SHIFT) {
+                if (SCREEN_MOD2(scr)) {
                     switch (view->rotation) {
                     case CAMU_VIEW_ROTATION_0:
                     case CAMU_VIEW_ROTATION_360:
@@ -249,7 +259,7 @@ static bool key_callback(void *userdata, u8 state, u16 button)
                         view->rotation = CAMU_VIEW_ROTATION_180;
                         break;
                     }
-                } else if (scr->flags & CAMU_SCREEN_MOD_CONTROL) {
+                } else if (SCREEN_MOD1(scr)) {
                     switch (view->rotation) {
                     case CAMU_VIEW_ROTATION_0:
                     case CAMU_VIEW_ROTATION_360:
@@ -336,13 +346,14 @@ bool camu_screen_init(struct camu_screen *scr, void *context)
 {
     al_atomic_store(s32)(&scr->state, CAMU_SCREEN_PAUSED, AL_ATOMIC_RELAXED);
     scr->window = stl_window_create(context);
+    scr->window->render_callback = render_callback;
+    scr->window->refresh_callback = refresh_callback;
     scr->window->pointer_pos_callback = pointer_pos_callback;
     scr->window->scroll_callback = scroll_callback;
     scr->window->mouse_button_callback = mouse_button_callback;
     scr->window->key_callback = key_callback;
     scr->window->key_immediate_callback = key_immediate_callback;
     scr->window->resize_callback = resize_callback;
-    scr->window->refresh_callback = refresh_callback;
     scr->window->should_close_callback = should_close_callback;
     scr->window->userdata = scr;
     scr->renderer = NULL;
@@ -351,7 +362,6 @@ bool camu_screen_init(struct camu_screen *scr, void *context)
     scr->last_click_ts = SCREEN_INVALID_TS;
     scr->last_mouse_x = 0.0;
     scr->last_mouse_y = 0.0;
-    scr->last_seek_ts = SCREEN_INVALID_TS;
     al_array_init(scr->videos);
 #ifdef CAMU_SCREEN_THREADED
     al_array_init(scr->add_queue);
diff --git a/src/screen/screen.h b/src/screen/screen.h
index 4b2e4c0..d79d977 100644
--- a/src/screen/screen.h
+++ b/src/screen/screen.h
@@ -31,15 +31,14 @@ enum {
 };
 
 enum {
-    CAMU_SCREEN_NEXT = 0,
-    CAMU_SCREEN_PREVIOUS,
-    CAMU_SCREEN_SHUFFLE,
+    CAMU_SCREEN_SET_VOLUME = 0, // f32
+    CAMU_SCREEN_OFFSET_VOLUME, // f32
+    CAMU_SCREEN_SKIP, // s32
     CAMU_SCREEN_TOGGLE_PAUSE,
-    CAMU_SCREEN_SEEK,
-    CAMU_SCREEN_RELATIVE_SEEK,
+    CAMU_SCREEN_PERCENT_SEEK, // f64
+    CAMU_SCREEN_RELATIVE_SEEK, // f64
     CAMU_SCREEN_RESEEK,
-    CAMU_SCREEN_SET_VOLUME,
-    CAMU_SCREEN_OFFSET_VOLUME,
+    CAMU_SCREEN_SHUFFLE,
     CAMU_SCREEN_STATUS,
 #ifdef CAMU_SCREEN_DEBUG_KEY
     CAMU_SCREEN_DEBUG,
@@ -67,7 +66,6 @@ struct camu_screen {
     u64 last_click_ts;
     f64 last_mouse_y;
     f64 last_mouse_x;
-    u64 last_seek_ts;
     array(struct camu_screen_video) videos;
 #ifdef CAMU_SCREEN_THREADED
     array(struct camu_video_buffer *) add_queue;