Changeset 8aef01c in mainline for uspace/srv/hid/display/display.c

Timestamp:

2020-06-07T10:18:14Z (5 years ago)

Author:

Jiri Svoboda <jiri@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

a65b0c8

Parents:

6301a24f

git-author:

Jiri Svoboda <jiri@…> (2020-06-07 10:11:32)

git-committer:

Jiri Svoboda <jiri@…> (2020-06-07 10:18:14)

Message:

Configurable display double-buffering

On by default (since turning off creates flicker in the absence of
front-to-back rendering). This is the quick and dirty way: display
server renders locally to a bitmap (using mem GC) and renders the
bitmap when ready.

The more sophisticated way would be to implement buffering in the
display device. That would require, however, enhancing the protocols
to communicate frame boundaries.

File:

• uspace/srv/hid/display/display.c (modified) (8 diffs)

uspace/srv/hid/display/display.c

@@ -35 +35 @@
 
 #include <errno.h>
+#include <gfx/bitmap.h>
 #include <gfx/context.h>
 #include <gfx/render.h>
 #include <io/log.h>
+#include <memgfx/memgc.h>
 #include <stdlib.h>
 #include "client.h"
@@ -46 +48 @@
 #include "display.h"
 
+static gfx_context_t *ds_display_get_unbuf_gc(ds_display_t *);
+static void ds_display_update_cb(void *, gfx_rect_t *);
+
 /** Create display.
  *
  * @param gc Graphics context for displaying output
+ * @param flags Display flags
  * @param rdisp Place to store pointer to new display.
  * @return EOK on success, ENOMEM if out of memory
  */
-errno_t ds_display_create(gfx_context_t *gc, ds_display_t **rdisp)
+errno_t ds_display_create(gfx_context_t *gc, ds_display_flags_t flags,
+    ds_display_t **rdisp)
 {
         ds_display_t *disp;
@@ -86 +93 @@
         list_initialize(&disp->seats);
         list_initialize(&disp->windows);
+        disp->flags = flags;
         *rdisp = disp;
         return EOK;
@@ -423 +431 @@
 }
 
+/** Allocate back buffer for display.
+ *
+ * @param disp Display
+ * @return EOK on success or if no back buffer is required, otherwise
+ *         an error code.
+ */
+static errno_t ds_display_alloc_backbuf(ds_display_t *disp)
+{
+        gfx_context_t *ugc;
+        gfx_bitmap_params_t params;
+        gfx_bitmap_alloc_t alloc;
+        errno_t rc;
+
+        /* Allocate backbuffer */
+        if ((disp->flags & df_disp_double_buf) == 0) {
+                /* Not double buffering. Nothing to do. */
+                return EOK;
+        }
+
+        ugc = ds_display_get_unbuf_gc(disp);
+
+        gfx_bitmap_params_init(&params);
+        params.rect = disp->rect;
+
+        rc = gfx_bitmap_create(ugc, &params, NULL,
+            &disp->backbuf);
+        if (rc != EOK)
+                goto error;
+
+        rc = gfx_bitmap_get_alloc(disp->backbuf, &alloc);
+        if (rc != EOK)
+                goto error;
+
+        rc = mem_gc_create(&disp->rect, &alloc,
+            ds_display_update_cb, (void *) disp, &disp->bbgc);
+        if (rc != EOK)
+                goto error;
+
+        disp->dirty_rect.p0.x = 0;
+        disp->dirty_rect.p0.y = 0;
+        disp->dirty_rect.p1.x = 0;
+        disp->dirty_rect.p1.y = 0;
+
+        return EOK;
+error:
+        if (disp->backbuf != NULL) {
+                gfx_bitmap_destroy(disp->backbuf);
+                disp->backbuf = NULL;
+        }
+
+        return rc;
+}
+
 /** Add display device to display.
  *
  * @param disp Display
  * @param ddev Display device
- */
-void ds_display_add_ddev(ds_display_t *disp, ds_ddev_t *ddev)
-{
+ * @return EOK on success, or an error code
+ */
+errno_t ds_display_add_ddev(ds_display_t *disp, ds_ddev_t *ddev)
+{
+        errno_t rc;
+
         assert(ddev->display == NULL);
         assert(!link_used(&ddev->lddevs));
 
-        /* Set display dimensions to dimensions of first display device */
-        if (gfx_rect_is_empty(&disp->rect))
-                disp->rect = ddev->info.rect;
-
         ddev->display = disp;
         list_append(&ddev->lddevs, &disp->ddevs);
+
+        /* First display device */
+        if (gfx_rect_is_empty(&disp->rect)) {
+                /* Set screen dimensions */
+                disp->rect = ddev->info.rect;
+
+                /* Allocate backbuffer */
+                rc = ds_display_alloc_backbuf(disp);
+                if (rc != EOK)
+                        goto error;
+        }
+
+        return EOK;
+error:
+        disp->rect.p0.x = 0;
+        disp->rect.p0.y = 0;
+        disp->rect.p1.x = 0;
+        disp->rect.p1.y = 0;
+        list_remove(&ddev->lddevs);
+        return rc;
 }
 
@@ -506 +586 @@
 
 // XXX
-gfx_context_t *ds_display_get_gc(ds_display_t *display)
+static gfx_context_t *ds_display_get_unbuf_gc(ds_display_t *display)
 {
         ds_ddev_t *ddev;
@@ -515 +595 @@
 
         return ddev->gc;
+}
+
+// XXX
+gfx_context_t *ds_display_get_gc(ds_display_t *display)
+{
+        if ((display->flags & df_disp_double_buf) != 0)
+                return mem_gc_get_ctx(display->bbgc);
+        else
+                return ds_display_get_unbuf_gc(display);
 }
 
@@ -542 +631 @@
 
         return gfx_fill_rect(gc, &crect);
+}
+
+/** Update front buffer from back buffer.
+ *
+ * If the display is not double-buffered, no action is taken.
+ *
+ * @param disp Display
+ * @return EOK on success, or an error code
+ */
+static errno_t ds_display_update(ds_display_t *disp)
+{
+        errno_t rc;
+
+        if (disp->backbuf == NULL) {
+                /* Not double-buffered, nothing to do. */
+                return EOK;
+        }
+
+        rc = gfx_bitmap_render(disp->backbuf, &disp->dirty_rect, NULL);
+        if (rc != EOK)
+                return rc;
+
+        disp->dirty_rect.p0.x = 0;
+        disp->dirty_rect.p0.y = 0;
+        disp->dirty_rect.p1.x = 0;
+        disp->dirty_rect.p1.y = 0;
+
+        return EOK;
 }
 
@@ -590 +707 @@
         }
 
-        return EOK;
+        return ds_display_update(disp);
+}
+
+/** Display update callback.
+ *
+ * Called by backbuffer memory GC when something is rendered into it.
+ * Updates the display's dirty rectangle.
+ *
+ * @param arg Argument (display cast as void *)
+ * @param rect Rectangle to update
+ */
+static void ds_display_update_cb(void *arg, gfx_rect_t *rect)
+{
+        ds_display_t *disp = (ds_display_t *) arg;
+        gfx_rect_t env;
+
+        gfx_rect_envelope(&disp->dirty_rect, rect, &env);
+        disp->dirty_rect = env;
 }