Introduce wlr_output_layer

This new API allows compositors to display buffers without needing to
perform rendering operations. This API can be implemented on Wayland
using subsurfaces and on DRM using KMS planes.

The goal is to make use of this API in a future scene-graph API.

References: https://github.com/swaywm/wlroots/issues/1826

types/meson.build

@@ -45,6 +45,7 @@ wlr_files += files(
 	'wlr_matrix.c',
 	'wlr_output_damage.c',
 	'wlr_output_layout.c',
+	'wlr_output_layer.c',
 	'wlr_output_management_v1.c',
 	'wlr_output_power_management_v1.c',
 	'wlr_pointer_constraints_v1.c',

types/output/output.c

@@ -7,6 +7,7 @@
 #include <wlr/util/log.h>
 #include "render/swapchain.h"
 #include "types/wlr_output.h"
+#include "types/wlr_output_layer.h"
 #include "util/global.h"
 #include "util/signal.h"
 
@@ -360,6 +361,8 @@ void wlr_output_init(struct wlr_output *output, struct wlr_backend *backend,
 	wl_signal_init(&output->events.description);
 	wl_signal_init(&output->events.destroy);
 	pixman_region32_init(&output->pending.damage);
+	wl_list_init(&output->layers);
+	wl_list_init(&output->pending.layers);
 
 	const char *no_hardware_cursors = getenv("WLR_NO_HARDWARE_CURSORS");
 	if (no_hardware_cursors != NULL && strcmp(no_hardware_cursors, "1") == 0) {
@@ -505,6 +508,42 @@ void output_pending_resolution(struct wlr_output *output, int *width,
 	}
 }
 
+static void output_commit_layers(struct wlr_output *output) {
+	if (output->pending.committed & WLR_OUTPUT_STATE_LAYERS) {
+		// Update the layer ordering in the current output state
+		struct wlr_output_layer *layer;
+		wl_list_for_each(layer, &output->pending.layers, pending.link) {
+			wl_list_remove(&layer->current.link);
+			wl_list_insert(output->layers.prev, &layer->current.link);
+		}
+	}
+
+	struct wlr_output_layer *layer, *tmp;
+	wl_list_for_each_safe(layer, tmp, &output->layers, current.link) {
+		if (wl_list_empty(&layer->pending.link)) {
+			output_layer_destroy(layer);
+		} else {
+			output_layer_state_move(&layer->current, &layer->pending);
+		}
+	}
+}
+
+static void output_rollback_layers(struct wlr_output *output) {
+	if (output->pending.committed & WLR_OUTPUT_STATE_LAYERS) {
+		// Rollback the layer ordering in the pending output state
+		struct wlr_output_layer *layer;
+		wl_list_for_each(layer, &output->layers, current.link) {
+			wl_list_remove(&layer->pending.link);
+			wl_list_insert(output->pending.layers.prev, &layer->pending.link);
+		}
+	}
+
+	struct wlr_output_layer *layer, *tmp;
+	wl_list_for_each_safe(layer, tmp, &output->pending.layers, pending.link) {
+		output_layer_state_clear(&layer->pending);
+	}
+}
+
 static bool output_basic_test(struct wlr_output *output) {
 	if (output->pending.committed & WLR_OUTPUT_STATE_BUFFER) {
 		if (output->frame_pending) {
@@ -628,7 +667,7 @@ bool wlr_output_commit(struct wlr_output *output) {
 
 	if (!output->impl->commit(output)) {
 		wlr_buffer_unlock(back_buffer);
-		output_state_clear(&output->pending);
+		wlr_output_rollback(output);
 		return false;
 	}
 
@@ -690,6 +729,7 @@ bool wlr_output_commit(struct wlr_output *output) {
 	}
 
 	uint32_t committed = output->pending.committed;
+	output_commit_layers(output);
 	output_state_clear(&output->pending);
 
 	struct wlr_output_event_commit event = {
@@ -704,6 +744,7 @@ bool wlr_output_commit(struct wlr_output *output) {
 
 void wlr_output_rollback(struct wlr_output *output) {
 	output_clear_back_buffer(output);
+	output_rollback_layers(output);
 	output_state_clear(&output->pending);
 }
 

types/wlr_output_layer.c

@@ -0,0 +1,130 @@
+#include <assert.h>
+#include <stdlib.h>
+#include <wlr/interfaces/wlr_output.h>
+#include <wlr/types/wlr_output.h>
+#include <wlr/types/wlr_output_layer.h>
+#include "types/wlr_output_layer.h"
+
+struct wlr_output_layer *wlr_output_layer_create(struct wlr_output *output) {
+	if (output->impl->create_layer) {
+		return output->impl->create_layer(output);
+	}
+
+	struct wlr_output_layer *layer = calloc(1, sizeof(*layer));
+	if (layer == NULL) {
+		return NULL;
+	}
+	wlr_output_layer_init(layer, output);
+	return layer;
+}
+
+void wlr_output_layer_init(struct wlr_output_layer *layer,
+		struct wlr_output *output) {
+	layer->output = output;
+	wl_list_insert(output->layers.prev, &layer->current.link);
+	wl_list_insert(output->pending.layers.prev, &layer->pending.link);
+	layer->pending.committed |= WLR_OUTPUT_LAYER_STATE_LINK;
+	output->pending.committed |= WLR_OUTPUT_STATE_LAYERS;
+}
+
+void output_layer_destroy(struct wlr_output_layer *layer) {
+	output_layer_state_clear(&layer->current);
+	output_layer_state_clear(&layer->pending);
+
+	wl_list_remove(&layer->current.link);
+	wl_list_remove(&layer->pending.link);
+
+	if (layer->output->impl->destroy_layer) {
+		layer->output->impl->destroy_layer(layer);
+	} else {
+		free(layer);
+	}
+}
+
+void wlr_output_layer_remove(struct wlr_output_layer *layer) {
+	wlr_output_layer_attach_buffer(layer, NULL);
+
+	wl_list_remove(&layer->pending.link);
+	wl_list_init(&layer->pending.link);
+	layer->pending.committed |= WLR_OUTPUT_LAYER_STATE_LINK;
+	layer->output->pending.committed |= WLR_OUTPUT_STATE_LAYERS;
+}
+
+void wlr_output_layer_attach_buffer(struct wlr_output_layer *layer,
+		struct wlr_buffer *buffer) {
+	if (buffer == layer->current.buffer) {
+		layer->pending.committed &= ~WLR_OUTPUT_LAYER_STATE_BUFFER;
+		return;
+	}
+
+	wlr_buffer_unlock(layer->pending.buffer);
+	layer->pending.buffer = NULL;
+
+	if (buffer == NULL) {
+		return;
+	}
+
+	layer->pending.buffer = wlr_buffer_lock(buffer);
+	layer->pending.committed |= WLR_OUTPUT_LAYER_STATE_BUFFER;
+}
+
+void wlr_output_layer_move(struct wlr_output_layer *layer, int x, int y) {
+	if (x == layer->current.x && y == layer->current.y) {
+		layer->pending.committed &= ~WLR_OUTPUT_LAYER_STATE_POSITION;
+		return;
+	}
+
+	layer->pending.x = x;
+	layer->pending.y = y;
+	layer->pending.committed |= WLR_OUTPUT_LAYER_STATE_POSITION;
+}
+
+void wlr_output_layer_place_above(struct wlr_output_layer *layer,
+		struct wlr_output_layer *sibling) {
+	assert(layer->output == sibling->output);
+
+	wl_list_remove(&layer->pending.link);
+	wl_list_insert(&sibling->pending.link, &layer->pending.link);
+	layer->pending.committed |= WLR_OUTPUT_LAYER_STATE_LINK;
+	layer->output->pending.committed |= WLR_OUTPUT_STATE_LAYERS;
+}
+
+void wlr_output_layer_place_below(struct wlr_output_layer *layer,
+		struct wlr_output_layer *sibling) {
+	assert(layer->output == sibling->output);
+
+	wl_list_remove(&layer->pending.link);
+	wl_list_insert(sibling->pending.link.prev, &layer->pending.link);
+	layer->pending.committed |= WLR_OUTPUT_LAYER_STATE_LINK;
+	layer->output->pending.committed |= WLR_OUTPUT_STATE_LAYERS;
+}
+
+static void output_layer_state_copy(struct wlr_output_layer_state *dst,
+		struct wlr_output_layer_state *src) {
+	// link has already been taken care of
+	if (src->committed & WLR_OUTPUT_LAYER_STATE_BUFFER) {
+		wlr_buffer_unlock(dst->buffer);
+		if (src->buffer != NULL) {
+			dst->buffer = wlr_buffer_lock(src->buffer);
+		} else {
+			dst->buffer = NULL;
+		}
+	}
+	if (src->committed & WLR_OUTPUT_LAYER_STATE_POSITION) {
+		dst->x = src->x;
+		dst->y = src->y;
+	}
+	dst->committed |= src->committed;
+}
+
+void output_layer_state_clear(struct wlr_output_layer_state *state) {
+	wlr_buffer_unlock(state->buffer);
+	state->buffer = NULL;
+	state->committed = 0;
+}
+
+void output_layer_state_move(struct wlr_output_layer_state *dst,
+		struct wlr_output_layer_state *src) {
+	output_layer_state_copy(dst, src);
+	output_layer_state_clear(src);
+}