Attachment 117891 Details for Bug 83985 – initial implementation

initial implementation

headless-gl.patch (text/plain), 13.12 KB, created by Dawid Gajownik on 2015-08-24 12:47:03 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Dawid Gajownik

Created: 2015-08-24 12:47:03 UTC

Size: 13.12 KB

patch

obsolete

>diff --git a/Makefile.am b/Makefile.am
>index 62719c9..a4fd066 100644
>--- a/Makefile.am
>+++ b/Makefile.am
>@@ -328,7 +328,8 @@ endif
> if ENABLE_HEADLESS_COMPOSITOR
> module_LTLIBRARIES += headless-backend.la
> headless_backend_la_LDFLAGS = -module -avoid-version
>-headless_backend_la_LIBADD = $(COMPOSITOR_LIBS) libshared.la
>+# FIXME: -lgbm and -ludev set by configure
>+headless_backend_la_LIBADD = $(COMPOSITOR_LIBS) -lgbm -ludev libshared.la
> headless_backend_la_CFLAGS = $(COMPOSITOR_CFLAGS) $(AM_CFLAGS)
> headless_backend_la_SOURCES = 			\
> 	src/compositor-headless.c		\
>diff --git a/src/compositor-headless.c b/src/compositor-headless.c
>index dba21a6..708f6ae 100644
>--- a/src/compositor-headless.c
>+++ b/src/compositor-headless.c
>@@ -31,16 +31,34 @@
> #include <sys/time.h>
> #include <stdbool.h>
> 
>+/*XXX: ifdef? */
>+//#include <sys/stat.h>
>+#include <fcntl.h>
>+#include <unistd.h>
>+#include <gbm.h>
>+#include <libudev.h>
>+
> #include "shared/helpers.h"
> #include "compositor.h"
> #include "pixman-renderer.h"
>+#include "gl-renderer.h"
> #include "presentation_timing-server-protocol.h"
> 
>+enum headless_renderer {
>+	RENDERER_NOOP,
>+	RENDERER_PIXMAN,
>+	RENDERER_RENDERNODE_GL,
>+	/* TODO: to be implemented later
>+	RENDERER_SOFTWARE_GL
>+	*/
>+};
> struct headless_backend {
> 	struct weston_backend base;
> 	struct weston_compositor *compositor;
> 	struct weston_seat fake_seat;
>-	bool use_pixman;
>+	enum headless_renderer renderer;
>+	char *device; /* ownership shared with headless_parameters */
>+	struct gbm_device *gbm;
> };
> 
> struct headless_output {
>@@ -49,15 +67,40 @@ struct headless_output {
> 	struct wl_event_source *finish_frame_timer;
> 	uint32_t *image_buf;
> 	pixman_image_t *image;
>+	struct gbm_surface *surface;
> };
> 
> struct headless_parameters {
> 	int width;
> 	int height;
>-	int use_pixman;
>+	enum headless_renderer renderer;
>+	char *device;
> 	uint32_t transform;
> };
> 
>+struct gl_renderer_interface *gl_renderer;
>+
>+static int
>+headless_parse_renderer(const char *renderer, enum headless_renderer *out)
>+{
>+	if (renderer == NULL || (strcmp(renderer, "noop") == 0)) {
>+		*out = RENDERER_NOOP;
>+	} else if (strcmp(renderer, "pixman") == 0) {
>+		*out = RENDERER_PIXMAN;
>+	} else if (strcmp(renderer, "rendernode-gl") == 0) {
>+		*out = RENDERER_RENDERNODE_GL;
>+	/* TODO: to be implemented later
>+	} else if (strcmp(renderer, "software-gl") == 0) {
>+		*out = RENDERER_SOFTWARE_GL;
>+	*/
>+	} else {
>+		*out = RENDERER_NOOP;
>+		return -1;
>+	}
>+
>+	return 0;
>+}
>+
> static void
> headless_output_start_repaint_loop(struct weston_output *output)
> {
>@@ -85,9 +128,19 @@ headless_output_repaint(struct weston_output *output_base,
> {
> 	struct headless_output *output = (struct headless_output *) output_base;
> 	struct weston_compositor *ec = output->base.compositor;
>+	struct headless_backend *b = (struct headless_backend *) ec->backend;
>+	struct gbm_bo *bo;
> 
> 	ec->renderer->repaint_output(&output->base, damage);
> 
>+	if (b->renderer == RENDERER_RENDERNODE_GL) {
>+		bo = gbm_surface_lock_front_buffer(output->surface);
>+		if (!bo)
>+			return -1;
>+
>+		gbm_surface_release_buffer(output->surface, bo);
>+	}
>+
> 	pixman_region32_subtract(&ec->primary_plane.damage,
> 				 &ec->primary_plane.damage, damage);
> 
>@@ -105,10 +158,13 @@ headless_output_destroy(struct weston_output *output_base)
> 
> 	wl_event_source_remove(output->finish_frame_timer);
> 
>-	if (b->use_pixman) {
>+	if (b->renderer == RENDERER_PIXMAN) {
> 		pixman_renderer_output_destroy(&output->base);
> 		pixman_image_unref(output->image);
> 		free(output->image_buf);
>+	} else if (b->renderer == RENDERER_RENDERNODE_GL) {
>+		gl_renderer->output_destroy(output_base);
>+		gbm_surface_destroy(output->surface);
> 	}
> 
> 	weston_output_destroy(&output->base);
>@@ -119,6 +175,38 @@ headless_output_destroy(struct weston_output *output_base)
> }
> 
> static int
>+headless_gl_renderer_output_create(struct headless_backend *b,
>+				   struct headless_output *output)
>+{
>+	EGLint format = GBM_FORMAT_XRGB8888;
>+
>+	output->surface = gbm_surface_create(b->gbm,
>+					     output->mode.width,
>+					     output->mode.height,
>+					     format,
>+					     /* XXX: will it be useful in tests?
>+					     GBM_BO_USE_SCANOUT |
>+					     */
>+					     GBM_BO_USE_RENDERING);
>+	if (!output->surface) {
>+		weston_log("failed to create gbm surface\n");
>+		return -1;
>+	}
>+
>+	if (gl_renderer->output_create(&output->base,
>+				       (EGLNativeWindowType)output->surface,
>+				       output->surface,
>+				       gl_renderer->opaque_attribs,
>+				       &format, 1) < 0) {
>+		weston_log("gl_renderer_output_create failed.\n");
>+		gbm_surface_destroy(output->surface);
>+		return -1;
>+	}
>+
>+	return 0;
>+}
>+
>+static int
> headless_backend_create_output(struct headless_backend *b,
> 			       struct headless_parameters *param)
> {
>@@ -157,7 +245,8 @@ headless_backend_create_output(struct headless_backend *b,
> 	output->base.set_dpms = NULL;
> 	output->base.switch_mode = NULL;
> 
>-	if (b->use_pixman) {
>+	switch (b->renderer) {
>+	case RENDERER_PIXMAN:
> 		output->image_buf = malloc(param->width * param->height * 4);
> 		if (!output->image_buf)
> 			return -1;
>@@ -173,6 +262,13 @@ headless_backend_create_output(struct headless_backend *b,
> 
> 		pixman_renderer_output_set_buffer(&output->base,
> 						  output->image);
>+		break;
>+	case RENDERER_RENDERNODE_GL:
>+		if (headless_gl_renderer_output_create(b, output) < 0)
>+			return -1;
>+		break;
>+	default:
>+		break;
> 	}
> 
> 	weston_compositor_add_output(c, &output->base);
>@@ -199,6 +295,109 @@ headless_input_destroy(struct headless_backend *b)
> 	weston_seat_release(&b->fake_seat);
> }
> 
>+static int
>+rendernode_get_default_fd(void)
>+{
>+	struct udev *udev;
>+	struct udev_enumerate *e;
>+	struct udev_list_entry *devices, *entry;
>+	struct udev_device *device;
>+	const char *path, *filename;
>+	int fd;
>+
>+	udev = udev_new();
>+	if (udev == NULL) {
>+		weston_log("%s: failed to initialize udev context\n",
>+			   __func__);
>+		goto fail;
>+	}
>+
>+	e = udev_enumerate_new(udev);
>+	if (e == NULL) {
>+		weston_log("%s: failed to initialize enumeration context\n",
>+			   __func__);
>+		goto fail_unref;
>+	}
>+
>+	if (udev_enumerate_add_match_subsystem(e, "drm") < 0) {
>+		weston_log("%s: failed to add match subsystem 'drm'\n",
>+			   __func__);
>+		goto fail_enum_unref;
>+	}
>+
>+	if (udev_enumerate_add_match_sysname(e, "renderD[0-9]*") < 0) {
>+		weston_log("%s: failed to add match sysname 'renderD[0-9]*'\n",
>+			   __func__);
>+		goto fail_enum_unref;
>+	}
>+
>+	if (udev_enumerate_scan_devices(e) < 0) {
>+		weston_log("%s: failed to scan devices\n", __func__);
>+		goto fail_enum_unref;
>+	}
>+
>+	devices = udev_enumerate_get_list_entry(e);
>+	if (devices == NULL) {
>+		weston_log("%s: failed to get the first entry of the sorted"
>+			   " list of device paths\n", __func__);
>+		goto fail_enum_unref;
>+	}
>+
>+	udev_list_entry_foreach(entry, devices) {
>+		path = udev_list_entry_get_name(entry);
>+		device = udev_device_new_from_syspath(udev, path);
>+		filename = udev_device_get_devnode(device);
>+		fd = open(filename, O_RDWR | O_CLOEXEC);
>+		udev_device_unref(device);
>+		if (fd >= 0) {
>+			udev_enumerate_unref(e);
>+			udev_unref(udev);
>+			return fd;
>+		}
>+	}
>+
>+fail_enum_unref:
>+	udev_enumerate_unref(e);
>+fail_unref:
>+	udev_unref(udev);
>+fail:
>+	return -1;
>+}
>+
>+static int
>+headless_gbm_create(struct headless_backend *b)
>+{
>+	int fd;
>+
>+	if (b->device != NULL)
>+		fd = open(b->device, O_RDWR | O_CLOEXEC);
>+	else
>+		fd = rendernode_get_default_fd();
>+
>+	if (fd < 0) {
>+		weston_log("%s: failed to open render node\n", __func__);
>+		return -1;
>+	}
>+
>+	b->gbm = gbm_create_device(fd);
>+	if (b->gbm == NULL) {
>+		close(fd);
>+		return -1;
>+	}
>+
>+	return 0;
>+}
>+
>+static void
>+headless_gbm_destroy(struct gbm_device *gbm)
>+{
>+	int fd;
>+
>+	fd = gbm_device_get_fd(gbm);
>+	gbm_device_destroy(gbm);
>+	close(fd);
>+}
>+
> static void
> headless_restore(struct weston_compositor *ec)
> {
>@@ -211,10 +410,47 @@ headless_destroy(struct weston_compositor *ec)
> 
> 	headless_input_destroy(b);
> 	weston_compositor_shutdown(ec);
>+	if (b->renderer == RENDERER_RENDERNODE_GL)
>+		headless_gbm_destroy(b->gbm);
> 
>+	free(b->device);
> 	free(b);
> }
> 
>+static int
>+headless_gl_renderer_init(struct headless_backend *b)
>+{
>+	EGLint format = GBM_FORMAT_XRGB8888;
>+
>+	if (headless_gbm_create(b) < 0) {
>+		weston_log("%s: failed to initialize gbm\n", __func__);
>+		return -1;
>+	}
>+
>+	gl_renderer = weston_load_module("gl-renderer.so",
>+					 "gl_renderer_interface");
>+	if (!gl_renderer) {
>+		weston_log("could not load gl renderer\n");
>+		goto err;
>+	}
>+
>+	if (gl_renderer->create(b->compositor,
>+				EGL_PLATFORM_GBM_KHR,
>+				(void *)b->gbm,
>+				gl_renderer->opaque_attribs,
>+				&format, 1) < 0) {
>+		weston_log("gl_renderer_create failed\n"
>+			   STAMP_SPACE "run with EGL_LOG_LEVEL=debug environment"
>+			   " variable for more details\n");
>+		goto err;
>+	}
>+
>+	return 0;
>+err:
>+	headless_gbm_destroy(b->gbm);
>+	return -1;
>+}
>+
> static struct headless_backend *
> headless_backend_create(struct weston_compositor *compositor,
> 			struct headless_parameters *param,
>@@ -226,6 +462,7 @@ headless_backend_create(struct weston_compositor *compositor,
> 	if (b == NULL)
> 		return NULL;
> 
>+	b->device = param->device;
> 	b->compositor = compositor;
> 	if (weston_compositor_set_presentation_clock_software(compositor) < 0)
> 		goto err_free;
>@@ -236,14 +473,23 @@ headless_backend_create(struct weston_compositor *compositor,
> 	b->base.destroy = headless_destroy;
> 	b->base.restore = headless_restore;
> 
>-	b->use_pixman = param->use_pixman;
>-	if (b->use_pixman) {
>-		pixman_renderer_init(compositor);
>+	b->renderer = param->renderer;
>+	switch (b->renderer) {
>+	case RENDERER_NOOP:
>+		if (noop_renderer_init(compositor) < 0)
>+			goto err_input;
>+		break;
>+	case RENDERER_PIXMAN:
>+		if (pixman_renderer_init(compositor) < 0)
>+			goto err_input;
>+		break;
>+	case RENDERER_RENDERNODE_GL:
>+		if (headless_gl_renderer_init(b) < 0)
>+			goto err_input;
>+		break;
> 	}
>-	if (headless_backend_create_output(b, param) < 0)
>-		goto err_input;
> 
>-	if (!b->use_pixman && noop_renderer_init(compositor) < 0)
>+	if (headless_backend_create_output(b, param) < 0)
> 		goto err_input;
> 
> 	compositor->backend = &b->base;
>@@ -252,7 +498,12 @@ headless_backend_create(struct weston_compositor *compositor,
> err_input:
> 	weston_compositor_shutdown(compositor);
> 	headless_input_destroy(b);
>+
>+	/* can't destroy before weston_compositor_shutdown */
>+	if (b->gbm != NULL)
>+		headless_gbm_destroy(b->gbm);
> err_free:
>+	free(b->device);
> 	free(b);
> 	return NULL;
> }
>@@ -262,24 +513,31 @@ backend_init(struct weston_compositor *compositor,
> 	     int *argc, char *argv[],
> 	     struct weston_config *config)
> {
>-	int width = 1024, height = 640;
> 	char *display_name = NULL;
>-	struct headless_parameters param = { 0, };
>+	struct headless_parameters param = {
>+		.width  = 1024,
>+		.height = 640,
>+		.device = NULL,
>+	};
>+	char *renderer = NULL;
> 	const char *transform = "normal";
> 	struct headless_backend *b;
> 
> 	const struct weston_option headless_options[] = {
>-		{ WESTON_OPTION_INTEGER, "width", 0, &width },
>-		{ WESTON_OPTION_INTEGER, "height", 0, &height },
>-		{ WESTON_OPTION_BOOLEAN, "use-pixman", 0, &param.use_pixman },
>+		{ WESTON_OPTION_INTEGER, "width", 0, &param.width },
>+		{ WESTON_OPTION_INTEGER, "height", 0, &param.height },
>+		{ WESTON_OPTION_STRING, "device", 0, &param.device },
>+		{ WESTON_OPTION_STRING, "renderer", 0, &renderer },
> 		{ WESTON_OPTION_STRING, "transform", 0, &transform },
> 	};
> 
> 	parse_options(headless_options,
> 		      ARRAY_LENGTH(headless_options), argc, argv);
> 
>-	param.width = width;
>-	param.height = height;
>+	if (headless_parse_renderer(renderer, &param.renderer) < 0)
>+		weston_log("invalid renderer \"%s\"\n"
>+			   STAMP_SPACE "falling back to no rendering\n", renderer);
>+	free(renderer);
> 
> 	if (weston_parse_transform(transform, &param.transform) < 0)
> 		weston_log("Invalid transform \"%s\"\n", transform);
>diff --git a/src/main.c b/src/main.c
>index a98570e..aefa58a 100644
>--- a/src/main.c
>+++ b/src/main.c
>@@ -284,7 +284,12 @@ usage(int error_code)
> 		"  --height=HEIGHT\tHeight of memory surface\n"
> 		"  --transform=TR\tThe output transformation, TR is one of:\n"
> 		"\tnormal 90 180 270 flipped flipped-90 flipped-180 flipped-270\n"
>-		"  --use-pixman\t\tUse the pixman (CPU) renderer (default: no rendering)\n\n");
>+		"  --renderer=RENDERER\tRenderer module, one of:\n"
>+			"\t\t\tnoop\t\tno rendering (default)\n"
>+			"\t\t\tpixman\t\tpixman (CPU) renderer\n"
>+			"\t\t\trendernode-gl\thardware accelerated rendernode\n"
>+			"\t\t\tsoftware-gl\tsoftware GL rendering\n"
>+		"  --device=DEVICE\tRender node to use by rendernode-gl renderer\n\n");
> #endif
> 
> #if defined(BUILD_RDP_COMPOSITOR)
>diff --git a/tests/buffer-count-test.c b/tests/buffer-count-test.c
>index 065249d..8714d06 100644
>--- a/tests/buffer-count-test.c
>+++ b/tests/buffer-count-test.c
>@@ -36,6 +36,8 @@
> 
> #define fail(msg) { fprintf(stderr, "%s failed\n", msg); return -1; }
> 
>+char *server_parameters="--renderer=rendernode-gl";
>+
> struct test_data {
> 	struct client *client;
> 
>diff --git a/tests/internal-screenshot-test.c b/tests/internal-screenshot-test.c
>index e72a695..ba2cccc 100644
>--- a/tests/internal-screenshot-test.c
>+++ b/tests/internal-screenshot-test.c
>@@ -32,7 +32,7 @@
> 
> #include "weston-test-client-helper.h"
> 
>-char *server_parameters="--use-pixman --width=320 --height=240";
>+char *server_parameters="--renderer=rendernode-gl --width=320 --height=240";
> 
> /** write_surface_as_png()
>  *

Actions: View

Attachments on bug 83985: 117891

Use of freedesktop.org services, including Bugzilla, is subject to our Code of Conduct. How we collect and use information is described in our Privacy Policy.