Initialize headless backend

backend/headless/backend.c

@@ -0,0 +1,156 @@
+#include <stdlib.h>
+#include <EGL/egl.h>
+#include <EGL/eglext.h>
+#include <wlr/util/log.h>
+#include "backend/headless.h"
+#include "glapi.h"
+
+static bool backend_start(struct wlr_backend *wlr_backend) {
+	struct wlr_headless_backend *backend =
+		(struct wlr_headless_backend *)wlr_backend;
+	wlr_log(L_INFO, "Initializating headless backend");
+
+	// TODO
+	for (size_t i = 0; i < 1; ++i) {
+		wlr_headless_add_output(&backend->backend, 1280, 720);
+	}
+
+	return true;
+}
+
+static void backend_destroy(struct wlr_backend *wlr_backend) {
+	struct wlr_headless_backend *backend =
+		(struct wlr_headless_backend *)wlr_backend;
+	if (!wlr_backend) {
+		return;
+	}
+
+	wl_list_remove(&backend->display_destroy.link);
+	wlr_egl_finish(&backend->egl);
+	free(backend);
+}
+
+static struct wlr_egl *backend_get_egl(struct wlr_backend *wlr_backend) {
+	struct wlr_headless_backend *backend =
+		(struct wlr_headless_backend *)wlr_backend;
+	return &backend->egl;
+}
+
+static const struct wlr_backend_impl backend_impl = {
+	.start = backend_start,
+	.destroy = backend_destroy,
+	.get_egl = backend_get_egl,
+};
+
+static void handle_display_destroy(struct wl_listener *listener, void *data) {
+	struct wlr_headless_backend *backend =
+		wl_container_of(listener, backend, display_destroy);
+	backend_destroy(&backend->backend);
+}
+
+static bool egl_get_config(EGLDisplay disp, EGLConfig *out) {
+	EGLint count = 0, matched = 0, ret;
+
+	ret = eglGetConfigs(disp, NULL, 0, &count);
+	if (ret == EGL_FALSE || count == 0) {
+		wlr_log(L_ERROR, "eglGetConfigs returned no configs");
+		return false;
+	}
+
+	EGLConfig configs[count];
+
+	static const EGLint attribs[] = {
+		EGL_SURFACE_TYPE, EGL_PBUFFER_BIT,
+		EGL_NONE,
+	};
+
+	ret = eglChooseConfig(disp, attribs, configs, count, &matched);
+	if (ret == EGL_FALSE) {
+		wlr_log(L_ERROR, "eglChooseConfig failed");
+		return false;
+	}
+
+	// TODO
+	*out = configs[0];
+	return true;
+}
+
+static bool egl_init(struct wlr_egl *egl) {
+	if (!load_glapi()) {
+		return false;
+	}
+
+	if (eglBindAPI(EGL_OPENGL_ES_API) == EGL_FALSE) {
+		wlr_log(L_ERROR, "Failed to bind to the OpenGL ES API: %s", egl_error());
+		goto error;
+	}
+
+	egl->display = eglGetDisplay(EGL_DEFAULT_DISPLAY);
+	if (egl->display == EGL_NO_DISPLAY) {
+		wlr_log(L_ERROR, "Failed to create EGL display: %s", egl_error());
+		goto error;
+	}
+
+	EGLint major, minor;
+	if (eglInitialize(egl->display, &major, &minor) == EGL_FALSE) {
+		wlr_log(L_ERROR, "Failed to initialize EGL: %s", egl_error());
+		goto error;
+	}
+
+	if (!egl_get_config(egl->display, &egl->config)) {
+		wlr_log(L_ERROR, "Failed to get EGL config");
+		goto error;
+	}
+
+	static const EGLint attribs[] = {
+		EGL_CONTEXT_CLIENT_VERSION, 2,
+		EGL_NONE,
+	};
+
+	egl->context = eglCreateContext(egl->display, egl->config,
+		EGL_NO_CONTEXT, attribs);
+	if (egl->context == EGL_NO_CONTEXT) {
+		wlr_log(L_ERROR, "Failed to create EGL context: %s", egl_error());
+		goto error;
+	}
+
+	eglMakeCurrent(egl->display, EGL_NO_SURFACE, EGL_NO_SURFACE, egl->context);
+	egl->egl_exts = eglQueryString(egl->display, EGL_EXTENSIONS);
+	if (strstr(egl->egl_exts, "EGL_KHR_image_base") == NULL) {
+		wlr_log(L_ERROR, "Required egl extensions not supported");
+		goto error;
+	}
+
+	egl->gl_exts = (const char*) glGetString(GL_EXTENSIONS);
+	wlr_log(L_INFO, "Using EGL %d.%d", (int)major, (int)minor);
+	wlr_log(L_INFO, "Using %s", glGetString(GL_VERSION));
+	wlr_log(L_INFO, "Supported EGL extensions: %s", egl->egl_exts);
+	wlr_log(L_INFO, "Supported OpenGL ES extensions: %s", egl->gl_exts);
+	return true;
+
+error:
+	eglMakeCurrent(EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
+	eglTerminate(egl->display);
+	eglReleaseThread();
+	return false;
+}
+
+struct wlr_backend *wlr_headless_backend_create(struct wl_display *display) {
+	wlr_log(L_INFO, "Creating headless backend");
+
+	struct wlr_headless_backend *backend =
+		calloc(1, sizeof(struct wlr_headless_backend));
+	if (!backend) {
+		wlr_log(L_ERROR, "Failed to allocate wlr_headless_backend");
+		return NULL;
+	}
+	wlr_backend_init(&backend->backend, &backend_impl);
+	backend->display = display;
+
+	egl_init(&backend->egl);
+
+	backend->display_destroy.notify = handle_display_destroy;
+	wl_display_add_destroy_listener(display, &backend->display_destroy);
+
+	return &backend->backend;
+}

backend/headless/output.c

@@ -0,0 +1,83 @@
+#include <stdlib.h>
+#include <EGL/egl.h>
+#include <EGL/eglext.h>
+#include <GLES2/gl2.h>
+#include <wlr/interfaces/wlr_output.h>
+#include <wlr/util/log.h>
+#include "backend/headless.h"
+
+static void output_destroy(struct wlr_output *wlr_output) {
+	struct wlr_headless_backend_output *output =
+		(struct wlr_headless_backend_output *)wlr_output;
+	wl_signal_emit(&output->backend->backend.events.output_remove,
+		&output->wlr_output);
+
+	wl_list_remove(&output->link);
+
+	eglDestroySurface(output->backend->egl.display, output->egl_surface);
+	free(output);
+}
+
+static const struct wlr_output_impl output_impl = {
+	//.set_custom_mode = wlr_wl_output_set_custom_mode,
+	//.transform = wlr_wl_output_transform,
+	.destroy = output_destroy,
+	//.make_current = wlr_wl_output_make_current,
+	//.swap_buffers = wlr_wl_output_swap_buffers,
+};
+
+static EGLSurface egl_create_surface(struct wlr_egl *egl, unsigned int width,
+		unsigned int height) {
+	EGLint attribs[] = {EGL_WIDTH, width, EGL_HEIGHT, height, EGL_NONE};
+
+	EGLSurface surf = eglCreatePbufferSurface(egl->display, egl->config, attribs);
+	if (surf == EGL_NO_SURFACE) {
+		wlr_log(L_ERROR, "Failed to create EGL surface: %s", egl_error());
+		return EGL_NO_SURFACE;
+	}
+	return surf;
+}
+
+struct wlr_output *wlr_headless_add_output(struct wlr_backend *wlr_backend,
+		unsigned int width, unsigned int height) {
+	struct wlr_headless_backend *backend =
+		(struct wlr_headless_backend *)wlr_backend;
+
+	struct wlr_headless_backend_output *output =
+		calloc(1, sizeof(struct wlr_headless_backend_output));
+	if (output == NULL) {
+		wlr_log(L_ERROR, "Failed to allocate wlr_headless_backend_output");
+		return NULL;
+	}
+	wlr_output_init(&output->wlr_output, &backend->backend, &output_impl);
+	struct wlr_output *wlr_output = &output->wlr_output;
+
+	output->egl_surface = egl_create_surface(&backend->egl, width, height);
+
+	wlr_output_update_size(wlr_output, width, height);
+
+	if (!eglMakeCurrent(output->backend->egl.display,
+			output->egl_surface, output->egl_surface,
+			output->backend->egl.context)) {
+		wlr_log(L_ERROR, "eglMakeCurrent failed: %s", egl_error());
+		goto error;
+	}
+
+	glViewport(0, 0, wlr_output->width, wlr_output->height);
+	glClearColor(1.0, 1.0, 1.0, 1.0);
+	glClear(GL_COLOR_BUFFER_BIT);
+
+	if (!eglSwapBuffers(output->backend->egl.display, output->egl_surface)) {
+		wlr_log(L_ERROR, "eglSwapBuffers failed: %s", egl_error());
+		goto error;
+	}
+
+	wl_list_insert(&backend->outputs, &output->link);
+	wlr_output_create_global(wlr_output, backend->display);
+	wl_signal_emit(&backend->backend.events.output_add, wlr_output);
+	return wlr_output;
+
+error:
+	wlr_output_destroy(&output->wlr_output);
+	return NULL;
+}

backend/meson.build

@@ -9,6 +9,8 @@ backend_files = files(
 	'drm/properties.c',
 	'drm/renderer.c',
 	'drm/util.c',
+	'headless/backend.c',
+	'headless/output.c',
 	'libinput/backend.c',
 	'libinput/events.c',
 	'libinput/keyboard.c',

include/backend/headless.h

@@ -0,0 +1,25 @@
+#ifndef BACKEND_HEADLESS_H
+#define BACKEND_HEADLESS_H
+
+#include <wlr/backend/interface.h>
+#include <wlr/backend/headless.h>
+#include <wlr/types/wlr_output.h>
+
+struct wlr_headless_backend {
+	struct wlr_backend backend;
+	struct wlr_egl egl;
+	struct wl_display *display;
+	struct wl_list outputs;
+	struct wl_listener display_destroy;
+};
+
+struct wlr_headless_backend_output {
+	struct wlr_output wlr_output;
+
+	struct wlr_headless_backend *backend;
+	struct wl_list link;
+
+	void *egl_surface;
+};
+
+#endif

include/wlr/backend/headless.h

@@ -0,0 +1,13 @@
+#ifndef WLR_BACKEND_HEADLESS_H
+#define WLR_BACKEND_HEADLESS_H
+
+#include <wlr/backend.h>
+#include <wlr/types/wlr_input_device.h>
+
+struct wlr_backend *wlr_headless_backend_create(struct wl_display *display);
+struct wlr_output *wlr_headless_add_output(struct wlr_backend *backend,
+	unsigned int width, unsigned int height);
+struct wlr_input_device *wlr_headless_add_input(struct wlr_backend *backend,
+	enum wlr_input_device_type type);
+
+#endif

rootston/main.c

@@ -4,6 +4,7 @@
 #include <unistd.h>
 #include <wayland-server.h>
 #include <wlr/backend.h>
+#include <wlr/backend/headless.h>
 #include <wlr/render.h>
 #include <wlr/render/gles2.h>
 #include <wlr/util/log.h>
@@ -29,7 +30,8 @@ int main(int argc, char **argv) {
 	assert(server.wl_display = wl_display_create());
 	assert(server.wl_event_loop = wl_display_get_event_loop(server.wl_display));
 
-	assert(server.backend = wlr_backend_autocreate(server.wl_display));
+	//assert(server.backend = wlr_backend_autocreate(server.wl_display));
+	assert(server.backend = wlr_headless_backend_create(server.wl_display));
 
 	assert(server.renderer = wlr_gles2_renderer_create(server.backend));
 	server.data_device_manager =