feat: frame scheduling

Always do non-blocking atomic commits.

To resolve issues with flutter trying to present frames too soon,
while another frame was already sent to the kernel (i.e. comitted via
KMS atomic commit), we either have to discard subsequent, too-early
frames or queue them.

In this case, we basically keep a 1-frame deep queue (or 2-frames,
if you count the in-kernel waiting-for-scanout frame), with the 1 queued
frame being displaced whenever a newer frame is available.

(Similar to vulkans MAILBOX swapchain presentation mode)

Author: ardera

src/frame_scheduler.c

@@ -18,13 +18,21 @@
 
 struct frame_scheduler {
     refcount_t n_refs;
+    pthread_mutex_t mutex;
 
     bool uses_frame_requests;
     enum present_mode present_mode;
     fl_vsync_callback_t vsync_cb;
     void *userdata;
 
-    pthread_mutex_t mutex;
+    bool waiting_for_scanout;
+
+    bool has_scheduled_frame;
+    struct {
+        void_callback_t present_cb;
+        void_callback_t cancel_cb;
+        void *userdata;
+    } scheduled_frame;
 };
 
 DEFINE_REF_OPS(frame_scheduler, n_refs)
@@ -43,10 +51,16 @@ frame_scheduler_new(bool uses_frame_requests, enum present_mode present_mode, fl
     }
 
     scheduler->n_refs = REFCOUNT_INIT_1;
+    ASSERTED int ok = pthread_mutex_init(&scheduler->mutex, get_default_mutex_attrs());
+    ASSERT_ZERO(ok);
+
     scheduler->uses_frame_requests = uses_frame_requests;
     scheduler->present_mode = present_mode;
     scheduler->vsync_cb = vsync_cb;
     scheduler->userdata = userdata;
+
+    scheduler->waiting_for_scanout = false;
+    scheduler->has_scheduled_frame = false;
     return scheduler;
 }
 
@@ -118,14 +132,44 @@ void frame_scheduler_request_fb(struct frame_scheduler *scheduler, uint64_t scan
     UNIMPLEMENTED();
 }
 
-void frame_scheduler_present_frame(struct frame_scheduler *scheduler, void_callback_t present_cb, void *userdata, void_callback_t cancel_cb) {
+void frame_scheduler_present_frame(struct frame_scheduler *scheduler, void_callback_t present_cb, void *userdata, void_callback_t cancel_cb) {   
     ASSERT_NOT_NULL(scheduler);
     ASSERT_NOT_NULL(present_cb);
-    (void) scheduler;
-    (void) cancel_cb;
+    
+    frame_scheduler_lock(scheduler);
 
-    /// TODO: Implement
-    present_cb(userdata);
+    if (scheduler->waiting_for_scanout) {
+        void_callback_t cancel_prev_sched_frame = NULL;
+        void *prev_sched_frame_userdata = NULL;
+
+        // We're already waiting for a scanout, so we can't present a frame right now.
+        // Wait till the previous frame is scanned out, and then present.
+
+        if (scheduler->has_scheduled_frame) {
+            // If we already have a frame scheduled, cancel it.
+            cancel_prev_sched_frame = scheduler->scheduled_frame.cancel_cb;
+            prev_sched_frame_userdata = scheduler->scheduled_frame.userdata;
+
+            memset(&scheduler->scheduled_frame, 0, sizeof scheduler->scheduled_frame);
+        }
+
+        scheduler->has_scheduled_frame = true;
+        scheduler->scheduled_frame.present_cb = present_cb;
+        scheduler->scheduled_frame.cancel_cb = cancel_cb;
+        scheduler->scheduled_frame.userdata = userdata;
+
+        frame_scheduler_unlock(scheduler);
+
+        if (cancel_prev_sched_frame != NULL) {
+            cancel_prev_sched_frame(prev_sched_frame_userdata);
+        }
+    } else {
+        // We're not waiting for a scanout right now.
+        scheduler->waiting_for_scanout = true;
+        frame_scheduler_unlock(scheduler);
+
+        present_cb(userdata);
+    }
 }
 
 void frame_scheduler_on_scanout(struct frame_scheduler *scheduler, bool has_timestamp, uint64_t timestamp_ns) {
@@ -135,6 +179,27 @@ void frame_scheduler_on_scanout(struct frame_scheduler *scheduler, bool has_time
     (void) has_timestamp;
     (void) timestamp_ns;
 
-    /// TODO: Implement
-    UNIMPLEMENTED();
+    void_callback_t present_cb = NULL;
+    void *userdata = NULL;
+
+    frame_scheduler_lock(scheduler);
+
+    if (scheduler->waiting_for_scanout) {
+        scheduler->waiting_for_scanout = false;
+
+        if (scheduler->has_scheduled_frame) {
+            present_cb = scheduler->scheduled_frame.present_cb;
+            userdata = scheduler->scheduled_frame.userdata;
+
+            memset(&scheduler->scheduled_frame, 0, sizeof scheduler->scheduled_frame);
+
+            scheduler->has_scheduled_frame = false;
+        }
+    }
+    
+    frame_scheduler_unlock(scheduler);
+
+    if (present_cb != NULL) {
+        present_cb(userdata);
+    }
 }

src/frame_scheduler.h

@@ -80,4 +80,6 @@ void frame_scheduler_on_fb_released(struct frame_scheduler *scheduler, bool has_
  */
 void frame_scheduler_present_frame(struct frame_scheduler *scheduler, void_callback_t present_cb, void *userdata, void_callback_t cancel_cb);
 
+void frame_scheduler_on_scanout(struct frame_scheduler *scheduler, bool has_timestamp, uint64_t timestamp_ns);
+
 #endif  // _FLUTTERPI_SRC_FRAME_SCHEDULER_H

src/window.c

@@ -1074,42 +1074,61 @@ struct frame {
     struct tracer *tracer;
     struct drmdev *drmdev;
     struct kms_req *req;
+    struct frame_scheduler *scheduler;
     bool unset_should_apply_mode_on_commit;
 };
 
-UNUSED static void on_scanout(struct drmdev *drmdev, uint64_t vblank_ns, void *userdata) {
-    ASSERT_NOT_NULL(drmdev);
-    (void) drmdev;
-    (void) vblank_ns;
-    (void) userdata;
+UNUSED static void on_scanout(uint64_t vblank_ns, void *userdata) {
+    ASSERT_NOT_NULL(userdata);
+    struct frame *frame = userdata;
 
-    /// TODO: What should we do here?
+    // This potentially presents a new frame.
+    frame_scheduler_on_scanout(frame->scheduler, true, vblank_ns);
+
+    frame_scheduler_unref(frame->scheduler);
+    tracer_unref(frame->tracer);
+    kms_req_unref(frame->req);
+    drmdev_unref(frame->drmdev);
+    free(frame);
 }
 
 static void on_present_frame(void *userdata) {
     ASSERT_NOT_NULL(userdata);
     struct frame *frame = userdata;
 
-    TRACER_BEGIN(frame->tracer, "kms_req_commit_nonblocking");
-    int ok = kms_req_commit_blocking(frame->req, frame->drmdev, NULL);
-    TRACER_END(frame->tracer, "kms_req_commit_nonblocking");
+    int ok;
+
+    {
+        // Keep our own reference on tracer, because the frame might be destroyed
+        // after kms_req_commit_nonblocking returns.
+        struct tracer *tracer = tracer_ref(frame->tracer);
+
+        // The pageflip events might be handled on a different thread, so on_scanout
+        // might already be executed and the frame instance already freed once
+        // kms_req_commit_nonblocking returns.
+        TRACER_BEGIN(tracer, "kms_req_commit_nonblocking");
+        ok = kms_req_commit_nonblocking(frame->req, frame->drmdev, on_scanout, frame, NULL);
+        TRACER_END(tracer, "kms_req_commit_nonblocking");
+
+        tracer_unref(tracer);
+    }
 
     if (ok != 0) {
         LOG_ERROR("Could not commit frame request.\n");
+        frame_scheduler_unref(frame->scheduler);
+        tracer_unref(frame->tracer);
+        kms_req_unref(frame->req);
+        drmdev_unref(frame->drmdev);
+        free(frame);
     }
-
-    tracer_unref(frame->tracer);
-    kms_req_unref(frame->req);
-    drmdev_unref(frame->drmdev);
-    free(frame);
 }
 
 static void on_cancel_frame(void *userdata) {
-    struct frame *frame;
     ASSERT_NOT_NULL(userdata);
 
-    frame = userdata;
+    struct frame *frame = userdata;
 
+    frame_scheduler_unref(frame->scheduler);
     tracer_unref(frame->tracer);
     kms_req_unref(frame->req);
     drmdev_unref(frame->drmdev);
@@ -1226,6 +1245,7 @@ static int kms_window_push_composition_locked(struct window *window, struct fl_l
     frame->req = req;
     frame->tracer = tracer_ref(window->tracer);
     frame->drmdev = drmdev_ref(window->kms.drmdev);
+    frame->scheduler = frame_scheduler_ref(window->frame_scheduler);
     frame->unset_should_apply_mode_on_commit = window->kms.should_apply_mode;
 
     frame_scheduler_present_frame(window->frame_scheduler, on_present_frame, frame, on_cancel_frame);