backend/drm: introduce wlr_drm_fb

This is a type which manages gbm_surfaces and imported dmabufs in the
same place, and makes the lifetime management between the two shared. It
should lead to easier to understand code, and fewer special cases.

This also contains a fair bit of refactoring to start using this new
type.

Co-authored-by: Simon Ser <contact@emersion.fr>

1 files changed, 212 insertions, 109 deletions

diff --git a/backend/drm/renderer.c b/backend/drm/renderer.c
index 8b295db1..4a16732c 100644
--- a/backend/drm/renderer.c
+++ b/backend/drm/renderer.c
@@ -3,6 +3,7 @@
 #include <gbm.h>
 #include <stdbool.h>
 #include <stdlib.h>
+#include <string.h>
 #include <unistd.h>
 #include <wayland-util.h>
 #include <wlr/render/egl.h>
@@ -61,7 +62,7 @@ void finish_drm_renderer(struct wlr_drm_renderer *renderer) {
 	gbm_device_destroy(renderer->gbm);
 }
 
-bool init_drm_surface(struct wlr_drm_surface *surf,
+static bool init_drm_surface(struct wlr_drm_surface *surf,
 		struct wlr_drm_renderer *renderer, uint32_t width, uint32_t height,
 		uint32_t format, struct wlr_drm_format_set *set, uint32_t flags) {
 	if (surf->width == width && surf->height == height) {
@@ -73,14 +74,6 @@ bool init_drm_surface(struct wlr_drm_surface *surf,
 	surf->height = height;
 
 	if (surf->gbm) {
-		if (surf->front) {
-			gbm_surface_release_buffer(surf->gbm, surf->front);
-			surf->front = NULL;
-		}
-		if (surf->back) {
-			gbm_surface_release_buffer(surf->gbm, surf->back);
-			surf->back = NULL;
-		}
 		gbm_surface_destroy(surf->gbm);
 		surf->gbm = NULL;
 	}
@@ -119,18 +112,11 @@ error_zero:
 	return false;
 }
 
-void finish_drm_surface(struct wlr_drm_surface *surf) {
+static void finish_drm_surface(struct wlr_drm_surface *surf) {
 	if (!surf || !surf->renderer) {
 		return;
 	}
 
-	if (surf->front) {
-		gbm_surface_release_buffer(surf->gbm, surf->front);
-	}
-	if (surf->back) {
-		gbm_surface_release_buffer(surf->gbm, surf->back);
-	}
-
 	wlr_egl_destroy_surface(&surf->renderer->egl, surf->egl);
 	if (surf->gbm) {
 		gbm_surface_destroy(surf->gbm);
@@ -139,82 +125,11 @@ void finish_drm_surface(struct wlr_drm_surface *surf) {
 	memset(surf, 0, sizeof(*surf));
 }
 
-bool make_drm_surface_current(struct wlr_drm_surface *surf,
+bool drm_surface_make_current(struct wlr_drm_surface *surf,
 		int *buffer_damage) {
 	return wlr_egl_make_current(&surf->renderer->egl, surf->egl, buffer_damage);
 }
 
-struct gbm_bo *swap_drm_surface_buffers(struct wlr_drm_surface *surf,
-		pixman_region32_t *damage) {
-	if (surf->front) {
-		gbm_surface_release_buffer(surf->gbm, surf->front);
-	}
-
-	wlr_egl_swap_buffers(&surf->renderer->egl, surf->egl, damage);
-
-	surf->front = surf->back;
-	surf->back = gbm_surface_lock_front_buffer(surf->gbm);
-	return surf->back;
-}
-
-struct gbm_bo *get_drm_surface_front(struct wlr_drm_surface *surf) {
-	if (surf->front) {
-		return surf->front;
-	}
-
-	make_drm_surface_current(surf, NULL);
-	struct wlr_renderer *renderer = surf->renderer->wlr_rend;
-	wlr_renderer_begin(renderer, surf->width, surf->height);
-	wlr_renderer_clear(renderer, (float[]){ 0.0, 0.0, 0.0, 1.0 });
-	wlr_renderer_end(renderer);
-	return swap_drm_surface_buffers(surf, NULL);
-}
-
-void post_drm_surface(struct wlr_drm_surface *surf) {
-	if (surf->front) {
-		gbm_surface_release_buffer(surf->gbm, surf->front);
-		surf->front = NULL;
-	}
-}
-
-struct gbm_bo *import_gbm_bo(struct wlr_drm_renderer *renderer,
-		struct wlr_dmabuf_attributes *attribs) {
-	if (attribs->modifier == DRM_FORMAT_MOD_INVALID && attribs->n_planes == 1
-			&& attribs->offset[0] == 0) {
-		struct gbm_import_fd_data data = {
-			.fd = attribs->fd[0],
-			.width = attribs->width,
-			.height = attribs->height,
-			.stride = attribs->stride[0],
-			.format = attribs->format,
-		};
-
-		return gbm_bo_import(renderer->gbm, GBM_BO_IMPORT_FD,
-			&data, GBM_BO_USE_SCANOUT);
-	} else {
-		struct gbm_import_fd_modifier_data data = {
-			.width = attribs->width,
-			.height = attribs->height,
-			.format = attribs->format,
-			.num_fds = attribs->n_planes,
-			.modifier = attribs->modifier,
-		};
-
-		if ((size_t)attribs->n_planes > sizeof(data.fds) / sizeof(data.fds[0])) {
-			return NULL;
-		}
-
-		for (size_t i = 0; i < (size_t)attribs->n_planes; ++i) {
-			data.fds[i] = attribs->fd[i];
-			data.strides[i] = attribs->stride[i];
-			data.offsets[i] = attribs->offset[i];
-		}
-
-		return gbm_bo_import(renderer->gbm, GBM_BO_IMPORT_FD_MODIFIER,
-			&data, GBM_BO_USE_SCANOUT);
-	}
-}
-
 bool export_drm_bo(struct gbm_bo *bo, struct wlr_dmabuf_attributes *attribs) {
 	memset(attribs, 0, sizeof(struct wlr_dmabuf_attributes));
 
@@ -268,46 +183,234 @@ static struct wlr_texture *get_tex_for_bo(struct wlr_drm_renderer *renderer,
 	return tex;
 }
 
-struct gbm_bo *copy_drm_surface_mgpu(struct wlr_drm_surface *dest,
-		struct gbm_bo *src) {
-	make_drm_surface_current(dest, NULL);
-
-	struct wlr_texture *tex = get_tex_for_bo(dest->renderer, src);
-	assert(tex);
-
-	float mat[9];
-	wlr_matrix_projection(mat, 1, 1, WL_OUTPUT_TRANSFORM_NORMAL);
+void drm_plane_finish_surface(struct wlr_drm_plane *plane) {
+	if (!plane) {
+		return;
+	}
 
-	struct wlr_renderer *renderer = dest->renderer->wlr_rend;
-	wlr_renderer_begin(renderer, dest->width, dest->height);
-	wlr_renderer_clear(renderer, (float[]){ 0.0, 0.0, 0.0, 0.0 });
-	wlr_render_texture_with_matrix(renderer, tex, mat, 1.0f);
-	wlr_renderer_end(renderer);
+	drm_fb_clear(&plane->pending_fb);
+	drm_fb_clear(&plane->queued_fb);
+	drm_fb_clear(&plane->current_fb);
 
-	return swap_drm_surface_buffers(dest, NULL);
+	finish_drm_surface(&plane->surf);
+	finish_drm_surface(&plane->mgpu_surf);
 }
 
-bool init_drm_plane_surfaces(struct wlr_drm_plane *plane,
+bool drm_plane_init_surface(struct wlr_drm_plane *plane,
 		struct wlr_drm_backend *drm, int32_t width, uint32_t height,
-		uint32_t format, bool with_modifiers) {
+		uint32_t format, uint32_t flags, bool with_modifiers) {
 	struct wlr_drm_format_set *format_set =
 		with_modifiers ? &plane->formats : NULL;
 
+	drm_plane_finish_surface(plane);
+
 	if (!drm->parent) {
 		return init_drm_surface(&plane->surf, &drm->renderer, width, height,
-			format, format_set, GBM_BO_USE_SCANOUT);
+			format, format_set, flags | GBM_BO_USE_SCANOUT);
 	}
 
 	if (!init_drm_surface(&plane->surf, &drm->parent->renderer,
-			width, height, format, NULL, GBM_BO_USE_LINEAR)) {
+			width, height, format, NULL,
+			flags | GBM_BO_USE_LINEAR)) {
 		return false;
 	}
 
 	if (!init_drm_surface(&plane->mgpu_surf, &drm->renderer,
-			width, height, format, format_set, GBM_BO_USE_SCANOUT)) {
+			width, height, format, format_set,
+			flags | GBM_BO_USE_SCANOUT)) {
 		finish_drm_surface(&plane->surf);
 		return false;
 	}
 
 	return true;
 }
+
+void drm_fb_clear(struct wlr_drm_fb *fb) {
+	switch (fb->type) {
+	case WLR_DRM_FB_TYPE_NONE:
+		assert(!fb->bo);
+		break;
+	case WLR_DRM_FB_TYPE_SURFACE:
+		gbm_surface_release_buffer(fb->surf->gbm, fb->bo);
+		break;
+	case WLR_DRM_FB_TYPE_WLR_BUFFER:
+		gbm_bo_destroy(fb->bo);
+		wlr_buffer_unlock(fb->wlr_buf);
+		fb->wlr_buf = NULL;
+		break;
+	}
+
+	fb->type = WLR_DRM_FB_TYPE_NONE;
+	fb->bo = NULL;
+
+	if (fb->mgpu_bo) {
+		assert(fb->mgpu_surf);
+		gbm_surface_release_buffer(fb->mgpu_surf->gbm, fb->mgpu_bo);
+		fb->mgpu_bo = NULL;
+		fb->mgpu_surf = NULL;
+	}
+}
+
+bool drm_fb_lock_surface(struct wlr_drm_fb *fb, struct wlr_drm_surface *surf) {
+	drm_fb_clear(fb);
+
+	if (!wlr_egl_swap_buffers(&surf->renderer->egl, surf->egl, NULL)) {
+		wlr_log(WLR_ERROR, "Failed to swap buffers");
+		return false;
+	}
+
+	fb->bo = gbm_surface_lock_front_buffer(surf->gbm);
+	if (!fb->bo) {
+		wlr_log(WLR_ERROR, "Failed to lock front buffer");
+		return false;
+	}
+
+	fb->type = WLR_DRM_FB_TYPE_SURFACE;
+	fb->surf = surf;
+	return true;
+}
+
+static uint32_t strip_alpha_channel(uint32_t format) {
+	switch (format) {
+	case DRM_FORMAT_ARGB8888:
+		return DRM_FORMAT_XRGB8888;
+	default:
+		return DRM_FORMAT_INVALID;
+	}
+}
+
+bool drm_fb_import_wlr(struct wlr_drm_fb *fb, struct wlr_drm_renderer *renderer,
+		struct wlr_buffer *buf, struct wlr_drm_format_set *set) {
+	drm_fb_clear(fb);
+
+	struct wlr_dmabuf_attributes attribs;
+	if (!wlr_buffer_get_dmabuf(buf, &attribs)) {
+		return false;
+	}
+
+	if (!wlr_drm_format_set_has(set, attribs.format, attribs.modifier)) {
+		// The format isn't supported by the plane. Try stripping the alpha
+		// channel, if any.
+		uint32_t format = strip_alpha_channel(attribs.format);
+		if (wlr_drm_format_set_has(set, format, attribs.modifier)) {
+			attribs.format = format;
+		} else {
+			return false;
+		}
+	}
+
+	if (attribs.modifier != DRM_FORMAT_MOD_INVALID ||
+			attribs.n_planes > 1 || attribs.offset[0] != 0) {
+		struct gbm_import_fd_modifier_data data = {
+			.width = attribs.width,
+			.height = attribs.height,
+			.format = attribs.format,
+			.num_fds = attribs.n_planes,
+			.modifier = attribs.modifier,
+		};
+
+		if ((size_t)attribs.n_planes > sizeof(data.fds) / sizeof(data.fds[0])) {
+			return false;
+		}
+
+		for (size_t i = 0; i < (size_t)attribs.n_planes; ++i) {
+			data.fds[i] = attribs.fd[i];
+			data.strides[i] = attribs.stride[i];
+			data.offsets[i] = attribs.offset[i];
+		}
+
+		fb->bo = gbm_bo_import(renderer->gbm, GBM_BO_IMPORT_FD_MODIFIER,
+			&data, GBM_BO_USE_SCANOUT);
+	} else {
+		struct gbm_import_fd_data data = {
+			.fd = attribs.fd[0],
+			.width = attribs.width,
+			.height = attribs.height,
+			.stride = attribs.stride[0],
+			.format = attribs.format,
+		};
+
+		fb->bo = gbm_bo_import(renderer->gbm, GBM_BO_IMPORT_FD,
+			&data, GBM_BO_USE_SCANOUT);
+	}
+
+	if (!fb->bo) {
+		return false;
+	}
+
+	fb->type = WLR_DRM_FB_TYPE_WLR_BUFFER;
+	fb->wlr_buf = wlr_buffer_lock(buf);
+
+	return true;
+}
+
+void drm_fb_move(struct wlr_drm_fb *new, struct wlr_drm_fb *old) {
+	drm_fb_clear(new);
+
+	*new = *old;
+	memset(old, 0, sizeof(*old));
+}
+
+bool drm_surface_render_black_frame(struct wlr_drm_surface *surf) {
+	struct wlr_renderer *renderer = surf->renderer->wlr_rend;
+
+	if (!drm_surface_make_current(surf, NULL)) {
+		return false;
+	}
+
+	wlr_renderer_begin(renderer, surf->width, surf->height);
+	wlr_renderer_clear(renderer, (float[]){ 0.0, 0.0, 0.0, 1.0 });
+	wlr_renderer_end(renderer);
+	return true;
+}
+
+struct gbm_bo *drm_fb_acquire(struct wlr_drm_fb *fb, struct wlr_drm_backend *drm,
+		struct wlr_drm_surface *mgpu) {
+	if (!fb->bo) {
+		wlr_log(WLR_ERROR, "Tried to acquire an FB with a NULL BO");
+		return NULL;
+	}
+
+	if (!drm->parent) {
+		return fb->bo;
+	}
+
+	if (fb->mgpu_bo) {
+		return fb->mgpu_bo;
+	}
+
+	/* Perform copy across GPUs */
+
+	struct wlr_renderer *renderer = mgpu->renderer->wlr_rend;
+
+	if (!drm_surface_make_current(mgpu, NULL)) {
+		return NULL;
+	}
+
+	struct wlr_texture *tex = get_tex_for_bo(mgpu->renderer, fb->bo);
+	if (!tex) {
+		return NULL;
+	}
+
+	float mat[9];
+	wlr_matrix_projection(mat, 1, 1, WL_OUTPUT_TRANSFORM_NORMAL);
+
+	wlr_renderer_begin(renderer, mgpu->width, mgpu->height);
+	wlr_renderer_clear(renderer, (float[]){ 0.0, 0.0, 0.0, 0.0 });
+	wlr_render_texture_with_matrix(renderer, tex, mat, 1.0f);
+	wlr_renderer_end(renderer);
+
+	if (!wlr_egl_swap_buffers(&mgpu->renderer->egl, mgpu->egl, NULL)) {
+		wlr_log(WLR_ERROR, "Failed to swap buffers");
+		return NULL;
+	}
+
+	fb->mgpu_bo = gbm_surface_lock_front_buffer(mgpu->gbm);
+	if (!fb->mgpu_bo) {
+		wlr_log(WLR_ERROR, "Failed to lock front buffer");
+		return NULL;
+	}
+
+	fb->mgpu_surf = mgpu;
+	return fb->mgpu_bo;
+}