scaled-scene-buffer: implement buffer sharing mechanism

Implementers can define impl->equal() which compares two
scaled-scene-buffers so that buffers are not allocated for visually
duplicated scaled-scene-buffers.

Currently this mechanism isn't applied for scaled-font-buffers since we
haven't defined impl->equal() for it.

diff --git a/include/common/scaled-scene-buffer.h b/include/common/scaled-scene-buffer.h
index db59cca1f2137392e30cab47a1b6e5a21838e311..5c36559587ae95b9c7fbab6340deafd10722dad0 100644 (file)
--- a/include/common/scaled-scene-buffer.h
+++ b/include/common/scaled-scene-buffer.h
@@ -17,6 +17,9 @@ struct scaled_scene_buffer_impl {
                (struct scaled_scene_buffer *scaled_buffer, double scale);
        /* Might be NULL or used for cleaning up */
        void (*destroy)(struct scaled_scene_buffer *scaled_buffer);
+       /* Returns true if the two buffers are visually the same */
+       bool (*equal)(struct scaled_scene_buffer *scaled_buffer_a,
+               struct scaled_scene_buffer *scaled_buffer_b);
 };
 
 struct scaled_scene_buffer {
@@ -28,11 +31,18 @@ struct scaled_scene_buffer {
        /* Private */
        bool drop_buffer;
        double active_scale;
+       /* cached wlr_buffers for each scale */
        struct wl_list cache;  /* struct scaled_buffer_cache_entry.link */
        struct wl_listener destroy;
        struct wl_listener output_enter;
        struct wl_listener output_leave;
        const struct scaled_scene_buffer_impl *impl;
+       /*
+        * Pointer to the per-implementation list of scaled-scene-buffers.
+        * This is used to share the backing wlr_buffers.
+        */
+       struct wl_list *cached_buffers;
+       struct wl_list link; /* struct scaled_scene_buffer.cached_buffers */
 };
 
 /**
@@ -53,6 +63,11 @@ struct scaled_scene_buffer {
  * it will also get called so a consumer of this API may clean up its own
  * allocations.
  *
+ * Besides caching buffers for each scale per scaled_scene_buffer, we also
+ * store all the scaled_scene_buffers in a per-implementer list passed as
+ * @cached_buffers in order to reuse backing buffers for visually duplicated
+ * scaled_scene_buffers found via impl->equal().
+ *
  * All requested lab_data_buffers via impl->create_buffer() will be locked
  * during the lifetime of the buffer in the internal cache and unlocked
  * when being evacuated from the cache (due to LAB_SCALED_BUFFER_MAX_CACHE
@@ -79,7 +94,7 @@ struct scaled_scene_buffer {
 struct scaled_scene_buffer *scaled_scene_buffer_create(
        struct wlr_scene_tree *parent,
        const struct scaled_scene_buffer_impl *implementation,
-       bool drop_buffer);
+       struct wl_list *cached_buffers, bool drop_buffer);
 
 /* Clear the cache of existing buffers, useful in case the content changes */
 void scaled_scene_buffer_invalidate_cache(struct scaled_scene_buffer *self);

diff --git a/src/common/scaled-font-buffer.c b/src/common/scaled-font-buffer.c
index 844aeaef95c11f4384e9e60f381babd29f5156b3..5b7fd2cfa1a260220bf5606a6185b300d5f27bfc 100644 (file)
--- a/src/common/scaled-font-buffer.c
+++ b/src/common/scaled-font-buffer.c
@@ -53,8 +53,8 @@ scaled_font_buffer_create(struct wlr_scene_tree *parent)
 {
        assert(parent);
        struct scaled_font_buffer *self = znew(*self);
-       struct scaled_scene_buffer *scaled_buffer =
-               scaled_scene_buffer_create(parent, &impl, /* drop_buffer */ true);
+       struct scaled_scene_buffer *scaled_buffer = scaled_scene_buffer_create(
+               parent, &impl, NULL, /* drop_buffer */ true);
        if (!scaled_buffer) {
                free(self);
                return NULL;

diff --git a/src/common/scaled-scene-buffer.c b/src/common/scaled-scene-buffer.c
index e177fd197c5efb113e6d0a6b161b66585b668b61..cb6bf14a48a1f190fcdcca475af636e9173971ad 100644 (file)
--- a/src/common/scaled-scene-buffer.c
+++ b/src/common/scaled-scene-buffer.c
@@ -49,31 +49,84 @@ _cache_entry_destroy(struct scaled_scene_buffer_cache_entry *cache_entry, bool d
        free(cache_entry);
 }
 
+static struct scaled_scene_buffer_cache_entry *
+find_cache_for_scale(struct scaled_scene_buffer *scene_buffer, double scale)
+{
+       struct scaled_scene_buffer_cache_entry *cache_entry;
+       wl_list_for_each(cache_entry, &scene_buffer->cache, link) {
+               if (cache_entry->scale == scale) {
+                       return cache_entry;
+               }
+       }
+       return NULL;
+}
+
 static void
 _update_buffer(struct scaled_scene_buffer *self, double scale)
 {
        self->active_scale = scale;
 
        /* Search for cached buffer of specified scale */
-       struct scaled_scene_buffer_cache_entry *cache_entry, *cache_entry_tmp;
-       wl_list_for_each_safe(cache_entry, cache_entry_tmp, &self->cache, link) {
-               if (cache_entry->scale == scale) {
-                       /* LRU cache, recently used in front */
-                       wl_list_remove(&cache_entry->link);
-                       wl_list_insert(&self->cache, &cache_entry->link);
-                       wlr_scene_buffer_set_buffer(self->scene_buffer, cache_entry->buffer);
-                       return;
+       struct scaled_scene_buffer_cache_entry *cache_entry =
+               find_cache_for_scale(self, scale);
+       if (cache_entry) {
+               /* LRU cache, recently used in front */
+               wl_list_remove(&cache_entry->link);
+               wl_list_insert(&self->cache, &cache_entry->link);
+               wlr_scene_buffer_set_buffer(self->scene_buffer, cache_entry->buffer);
+               /*
+                * If found in our local cache,
+                * - self->width and self->height are already set
+                * - wlr_scene_buffer_set_dest_size() has already been called
+                */
+               return;
+       }
+
+       struct wlr_buffer *wlr_buffer = NULL;
+
+       if (self->impl->equal && self->cached_buffers) {
+               /* Search from other cached scaled-scene-buffers */
+               struct scaled_scene_buffer *scene_buffer;
+               wl_list_for_each(scene_buffer, self->cached_buffers, link) {
+                       if (scene_buffer == self) {
+                               continue;
+                       }
+                       if (!self->impl->equal(self, scene_buffer)) {
+                               continue;
+                       }
+                       cache_entry = find_cache_for_scale(scene_buffer, scale);
+                       if (!cache_entry) {
+                               continue;
+                       }
+
+                       /* Ensure self->width and self->height are set correctly */
+                       self->width = scene_buffer->width;
+                       self->height = scene_buffer->height;
+                       wlr_buffer = cache_entry->buffer;
+                       break;
                }
        }
 
-       /* Create new buffer, will get destroyed along the backing wlr_buffer */
-       struct lab_data_buffer *buffer = self->impl->create_buffer(self, scale);
-       if (buffer) {
+       if (!wlr_buffer) {
+               /*
+                * Create new buffer, will get destroyed along the backing
+                * wlr_buffer
+                */
+               struct lab_data_buffer *buffer =
+                       self->impl->create_buffer(self, scale);
+               if (buffer) {
+                       self->width = buffer->logical_width;
+                       self->height = buffer->logical_height;
+                       wlr_buffer = &buffer->base;
+               } else {
+                       self->width = 0;
+                       self->height = 0;
+               }
+       }
+       if (wlr_buffer) {
                /* Ensure the buffer doesn't get deleted behind our back */
-               wlr_buffer_lock(&buffer->base);
+               wlr_buffer_lock(wlr_buffer);
        }
-       self->width = buffer ? buffer->logical_width : 0;
-       self->height = buffer ? buffer->logical_height : 0;
 
        /* Create or reuse cache entry */
        if (wl_list_length(&self->cache) < LAB_SCALED_BUFFER_MAX_CACHE) {
@@ -92,7 +145,7 @@ _update_buffer(struct scaled_scene_buffer *self, double scale)
 
        /* Update the cache entry */
        cache_entry->scale = scale;
-       cache_entry->buffer = buffer ? &buffer->base : NULL;
+       cache_entry->buffer = wlr_buffer;
        wl_list_insert(&self->cache, &cache_entry->link);
 
        /* And finally update the wlr_scene_buffer itself */
@@ -119,6 +172,7 @@ _handle_node_destroy(struct wl_listener *listener, void *data)
        if (self->impl->destroy) {
                self->impl->destroy(self);
        }
+       wl_list_remove(&self->link);
        free(self);
 }
 
@@ -159,7 +213,7 @@ _handle_output_leave(struct wl_listener *listener, void *data)
 struct scaled_scene_buffer *
 scaled_scene_buffer_create(struct wlr_scene_tree *parent,
                const struct scaled_scene_buffer_impl *impl,
-               bool drop_buffer)
+               struct wl_list *cached_buffers, bool drop_buffer)
 {
        assert(parent);
        assert(impl);
@@ -178,6 +232,14 @@ scaled_scene_buffer_create(struct wlr_scene_tree *parent,
        self->drop_buffer = drop_buffer;
        wl_list_init(&self->cache);
 
+       self->cached_buffers = cached_buffers;
+       if (self->cached_buffers) {
+               wl_list_insert(self->cached_buffers, &self->link);
+       } else {
+               /* Ensure self->link can be removed safely in the destroy handler */
+               wl_list_init(&self->link);
+       }
+
        /* Listen to output enter/leave so we get notified about scale changes */
        self->output_enter.notify = _handle_output_enter;
        wl_signal_add(&self->scene_buffer->events.output_enter, &self->output_enter);