wip

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

5 files changed, 62 insertions, 20 deletions

diff --git a/src/buffer/clock.c b/src/buffer/clock.c
index 032e44a..d26e4a8 100644
--- a/src/buffer/clock.c
+++ b/src/buffer/clock.c
@@ -2,29 +2,55 @@
 
 #include "clock.h"
 
-void camu_clock_set(struct camu_clock *clock, u64 base, u64 ts, u64 delay)
+void camu_clock_set(struct camu_clock *clock, struct shrb_seek_req *req)
 {
-    al_atomic_f64_store(&clock->base, base / 1000000.0, AL_ATOMIC_RELAXED);
     al_atomic_f64_store(&clock->tick, 0.0, AL_ATOMIC_RELAXED);
-    al_atomic_u64_store(&clock->start, ts + delay, AL_ATOMIC_RELAXED);
-    clock->delay = delay;
-    clock->pause_at = -1.0;
+    if (req->paused) {
+        clock->pause_at = req->paused_at / 1000000.0;
+        al_atomic_f64_store(&clock->base, clock->pause_at, AL_ATOMIC_RELAXED);
+        al_atomic_u64_store(&clock->start, 0Lu, AL_ATOMIC_RELAXED);
+    } else {
+        clock->pause_at = -1.0;
+        al_atomic_f64_store(&clock->base, req->base / 1000000.0, AL_ATOMIC_RELAXED);
+        al_atomic_u64_store(&clock->start, req->ts + req->delay, AL_ATOMIC_RELAXED);
+        clock->ts = req->ts;
+    }
+    clock->offset = 0L;
+    clock->delay = req->delay;
 }
 
 f64 calc_tick_internal(struct camu_clock *clock)
 {
-    s64 diff = clock->delay == 0 ? 0 : ((al_atomic_u64_load(&clock->start, AL_ATOMIC_ACQUIRE)) - aki_get_timestamp());
+    s64 diff = clock->delay == 0Lu ? 0L
+        : ((al_atomic_u64_load(&clock->start, AL_ATOMIC_ACQUIRE) + clock->offset)
+            - aki_get_timestamp());
     f64 tick = aki_get_tick() - al_atomic_f64_load(&clock->base, AL_ATOMIC_RELAXED);
+    //al_printf("DIFFERENCE: %f\n", diff / 1000000.0);
     tick += diff / 1000000.0;
     al_atomic_f64_store(&clock->tick, tick, AL_ATOMIC_RELAXED);
-    al_atomic_u64_store(&clock->start, 0, AL_ATOMIC_RELEASE);
+    al_atomic_u64_store(&clock->start, 0Lu, AL_ATOMIC_RELEASE);
     return tick;
 }
 
 bool camu_clock_is_late(struct camu_clock *clock)
 {
     s64 diff = (s64)(al_atomic_u64_load(&clock->start, AL_ATOMIC_RELAXED)) - aki_get_timestamp();
-    return clock->delay > 0 && diff < 0;
+    return clock->delay > 0L && diff < 0L;
+}
+
+void camu_clock_ready(struct camu_clock *clock)
+{
+    if (clock->pause_at != -1.0) {
+        clock->pause_at = -1.0;
+        return;
+    }
+    camu_clock_resume(clock);
+}
+
+void camu_clock_offset(struct camu_clock *clock, s64 offset)
+{
+    clock->offset += offset;
+    //al_printf("OFFSET: %f\n", clock->offset / 1000000.0);
 }
 
 void camu_clock_resume(struct camu_clock *clock)
@@ -32,27 +58,31 @@ void camu_clock_resume(struct camu_clock *clock)
     f64 tick = al_atomic_f64_load(&clock->tick, AL_ATOMIC_ACQUIRE);
     if (tick != 0.0) return;
     u64 start = al_atomic_u64_load(&clock->start, AL_ATOMIC_RELAXED);
-    if (start != 0L) {
+    if (start != 0Lu) {
         // No longer report paused, calculate tick on first call to get_pts().
         al_atomic_f64_store(&clock->tick, -1.0, AL_ATOMIC_RELEASE);
     } else {
         tick = al_atomic_f64_load(&clock->base, AL_ATOMIC_RELAXED);
         al_atomic_f64_store(&clock->tick, aki_get_tick() - tick, AL_ATOMIC_RELEASE);
     }
+    clock->pause_at = -1.0;
 }
 
 void camu_clock_arm_resume(struct camu_clock *clock, u64 ts)
 {
     al_atomic_u64_store(&clock->start, ts, AL_ATOMIC_RELAXED);
     al_atomic_f64_store(&clock->tick, -1.0, AL_ATOMIC_RELAXED);
+    clock->pause_at = -1.0;
 }
 
-void camu_clock_pause(struct camu_clock *clock)
+void camu_clock_pause(struct camu_clock *clock, f64 base)
 {
     f64 tick = al_atomic_f64_load(&clock->tick, AL_ATOMIC_ACQUIRE);
     if (tick == 0.0) return;
-    al_atomic_f64_store(&clock->base, aki_get_tick() - tick, AL_ATOMIC_RELAXED);
+    if (base == -1.0) base = aki_get_tick() - tick;
     al_atomic_f64_store(&clock->tick, 0.0, AL_ATOMIC_RELEASE);
+    clock->pause_at = base;
+    al_atomic_f64_store(&clock->base, clock->pause_at, AL_ATOMIC_RELAXED);
 }
 
 void camu_clock_arm_pause(struct camu_clock *clock, f64 pts)
@@ -63,13 +93,13 @@ void camu_clock_arm_pause(struct camu_clock *clock, f64 pts)
 bool camu_clock_is_paused(struct camu_clock *clock)
 {
     f64 tick = al_atomic_f64_load(&clock->tick, AL_ATOMIC_RELAXED);
-    if (clock->pause_at >= 0.0 && (aki_get_tick() - tick) >= clock->pause_at) {
+    if (tick == 0.0) return true;
+    if (clock->pause_at >= 0.0 && aki_get_tick() - tick >= clock->pause_at) {
         al_atomic_f64_store(&clock->base, clock->pause_at, AL_ATOMIC_RELAXED);
         al_atomic_f64_store(&clock->tick, 0.0, AL_ATOMIC_RELAXED);
-        clock->pause_at = -1.0;
         return true;
     }
-    return tick == 0.0;
+    return false;
 }
 
 f64 camu_clock_get_base_pts(struct camu_clock *clock)
diff --git a/src/buffer/clock.h b/src/buffer/clock.h
index bdd50d8..6f505be 100644
--- a/src/buffer/clock.h
+++ b/src/buffer/clock.h
@@ -3,18 +3,24 @@
 #include <aki/thread.h>
 #include <al/atomic.h>
 
+#include "../shrub/handler.h"
+
 struct camu_clock {
     atomic_f64 base, tick;
     atomic_u64 start;
+    u64 ts;
+    s64 offset;
     u64 delay;
     f64 pause_at;
 };
 
-void camu_clock_set(struct camu_clock *clock, u64 base, u64 ts, u64 delay);
+void camu_clock_set(struct camu_clock *clock, struct shrb_seek_req *req);
 bool camu_clock_is_late(struct camu_clock *clock);
+void camu_clock_ready(struct camu_clock *clock);
+void camu_clock_offset(struct camu_clock *clock, s64 offset);
 void camu_clock_resume(struct camu_clock *clock);
 void camu_clock_arm_resume(struct camu_clock *clock, u64 ts);
-void camu_clock_pause(struct camu_clock *clock);
+void camu_clock_pause(struct camu_clock *clock, f64 base);
 void camu_clock_arm_pause(struct camu_clock *clock, f64 pts);
 bool camu_clock_is_paused(struct camu_clock *clock);
 f64 camu_clock_get_base_pts(struct camu_clock *clock);
diff --git a/src/buffer/meson.build b/src/buffer/meson.build
index d037d6b..a2def3e 100644
--- a/src/buffer/meson.build
+++ b/src/buffer/meson.build
@@ -1,8 +1,11 @@
-no_video = false
+no_video = meson.is_subproject()
 buffer_src = ['audio.c', 'clock.c', 'peak_buffer.c']
+buffer_deps = [common_deps]
+buffer_args = []
 if not no_video
   buffer_src += ['video.c']
+else
+  buffer_args += ['-DCAMU_SINK_NO_VIDEO']
 endif
-buffer_deps = [common_deps]
 buffer = declare_dependency(sources: buffer_src,
-  dependencies: buffer_deps)
+  dependencies: buffer_deps, compile_args: buffer_args)
diff --git a/src/buffer/video.c b/src/buffer/video.c
index 390b181..3b9be20 100644
--- a/src/buffer/video.c
+++ b/src/buffer/video.c
@@ -22,6 +22,7 @@ bool camu_video_buffer_init(struct camu_video_buffer *buf, struct camu_clock *cl
 #ifdef CAMU_SCREEN_THREADED
     al_atomic_bool_store(&buf->ref, false, AL_ATOMIC_RELAXED);
 #endif
+    buf->view.mode = CAMU_VIEW_NONE;
     return true;
 }
 
@@ -163,8 +164,8 @@ bool camu_video_buffer_read(struct camu_video_buffer *buf, void *out)
         f64 pts = camu_clock_get_pts(buf->clock, buf->offset);
         if (pts > base) base = pts;
     }
-    u8 ret = buf->queue->read(buf->queue, base, out);
     u8 flow = al_atomic_u8_load(&buf->flow, AL_ATOMIC_RELAXED);
+    u8 ret = buf->queue->read(buf->queue, base, out);
     if (flow == FLUSHED && (ret == CAMU_QUEUE_EOF || (buf->single_frame && ret == CAMU_QUEUE_OK))) {
         buf->callback(buf->userdata, CAMU_BUFFER_EOF);
         al_atomic_u8_store(&buf->flow, SIGNALED, AL_ATOMIC_RELAXED);
diff --git a/src/buffer/video.h b/src/buffer/video.h
index 5b92dc6..5e18b33 100644
--- a/src/buffer/video.h
+++ b/src/buffer/video.h
@@ -6,6 +6,7 @@
 #include "../codec/ffmpeg/scaler.h"
 #include "../render/renderer.h"
 #include "../screen/screen.h"
+#include "../screen/view.h"
 
 #include "clock.h"
 #include "frame_queue.h"
@@ -31,6 +32,7 @@ struct camu_video_buffer {
 #ifdef CAMU_SCREEN_THREADED
     atomic_bool ref;
 #endif
+    struct camu_view view;
 
     void (*callback)(void *, u8);
     void *userdata;