implement proper frame scheduling

Author: ardera

src/frame_scheduler.c

@@ -18,13 +18,21 @@
 
 struct frame_scheduler {
     refcount_t n_refs;
+    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,15 @@ frame_scheduler_new(bool uses_frame_requests, enum present_mode present_mode, fl
     }
 
     scheduler->n_refs = REFCOUNT_INIT_1;
+    mutex_init(&scheduler->mutex);
+
     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 +131,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 +178,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

@@ -1077,14 +1077,23 @@ struct frame {
     struct tracer *tracer;
     struct kms_req *req;
     struct drmdev *drmdev;
+    struct frame_scheduler *scheduler;
     bool unset_should_apply_mode_on_commit;
 };
 
 UNUSED static void on_scanout(uint64_t vblank_ns, void *userdata) {
-    (void) vblank_ns;
-    (void) userdata;
+    struct frame *frame;
+
+    ASSERT_NOT_NULL(userdata);
+    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);
+    free(frame);
 }
 
 static void on_present_frame(void *userdata) {
@@ -1095,17 +1104,28 @@ static void on_present_frame(void *userdata) {
 
     frame = userdata;
 
-    TRACER_BEGIN(frame->tracer, "kms_req_commit_nonblocking");
-    ok = kms_req_commit_nonblocking(frame->req, frame->drmdev, on_scanout, NULL, NULL);
-    TRACER_END(frame->tracer, "kms_req_commit_nonblocking");
+    {
+        // 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);
+        free(frame);
     }
-
-    tracer_unref(frame->tracer);
-    kms_req_unref(frame->req);
-    free(frame);
 }
 
 static void on_cancel_frame(void *userdata) {
@@ -1114,6 +1134,7 @@ static void on_cancel_frame(void *userdata) {
 
     frame = userdata;
 
+    frame_scheduler_unref(frame->scheduler);
     tracer_unref(frame->tracer);
     kms_req_unref(frame->req);
     drmdev_unref(frame->drmdev);
@@ -1234,6 +1255,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);