blankie
/
wlroots
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Merge pull request #496 from emersion/headless-backend 

Headless backend
This commit is contained in:
Drew DeVault 2017-12-17 20:48:01 -05:00 committed by GitHub
parent 10c72f4bf6 b99d1f4fcc
commit f3769a4b1f
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
17 changed files with 457 additions and 28 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
backend/drm/drm.c
View File

@ -452,8 +452,7 @@ static bool wlr_drm_connector_set_mode(struct wlr_output *output,
crtc->cursor ? crtc->cursor - drm->cursor_planes : -1);
conn->state = WLR_DRM_CONN_CONNECTED;
conn->output.current_mode = mode;
wlr_output_update_size(&conn->output, mode->width, mode->height);
wlr_output_update_mode(&conn->output, mode);
// Since realloc_crtcs can deallocate planes on OTHER outputs,
// we actually need to reinitalise any than has changed

4
backend/drm/renderer.c
View File

@ -24,8 +24,8 @@ bool wlr_drm_renderer_init(struct wlr_drm_backend *drm,
return false;
}
if (!wlr_egl_init(&renderer->egl, EGL_PLATFORM_GBM_MESA,
GBM_FORMAT_ARGB8888, renderer->gbm)) {
if (!wlr_egl_init(&renderer->egl, EGL_PLATFORM_GBM_MESA, renderer->gbm,
NULL, GBM_FORMAT_ARGB8888)) {
goto error_gbm;
}

114
backend/headless/backend.c Normal file
View File

@ -0,0 +1,114 @@
#include <stdlib.h>
#include <EGL/egl.h>
#include <EGL/eglext.h>
#include <wlr/util/log.h>
#include <wlr/interfaces/wlr_output.h>
#include <wlr/interfaces/wlr_input_device.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, "Starting headless backend");
struct wlr_headless_output *output;
wl_list_for_each(output, &backend->outputs, link) {
wl_event_source_timer_update(output->frame_timer, output->frame_delay);
wlr_output_create_global(&output->wlr_output, backend->display);
wl_signal_emit(&backend->backend.events.output_add,
&output->wlr_output);
}
struct wlr_headless_input_device *input_device;
wl_list_for_each(input_device, &backend->input_devices,
wlr_input_device.link) {
wl_signal_emit(&backend->backend.events.input_add,
&input_device->wlr_input_device);
}
backend->started = true;
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);
struct wlr_headless_output *output, *output_tmp;
wl_list_for_each_safe(output, output_tmp, &backend->outputs, link) {
wlr_output_destroy(&output->wlr_output);
}
struct wlr_headless_input_device *input_device, *input_device_tmp;
wl_list_for_each_safe(input_device, input_device_tmp,
&backend->input_devices, wlr_input_device.link) {
wlr_input_device_destroy(&input_device->wlr_input_device);
}
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);
}
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;
wl_list_init(&backend->outputs);
wl_list_init(&backend->input_devices);
static const EGLint config_attribs[] = {
EGL_SURFACE_TYPE, EGL_PBUFFER_BIT,
EGL_ALPHA_SIZE, 0,
EGL_BLUE_SIZE, 8,
EGL_GREEN_SIZE, 8,
EGL_RED_SIZE, 8,
EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
EGL_NONE,
};
bool ok = wlr_egl_init(&backend->egl, EGL_PLATFORM_SURFACELESS_MESA, NULL,
(EGLint *)config_attribs, 0);
if (!ok) {
free(backend);
return NULL;
}
backend->display_destroy.notify = handle_display_destroy;
wl_display_add_destroy_listener(display, &backend->display_destroy);
return &backend->backend;
}
bool wlr_backend_is_headless(struct wlr_backend *backend) {
return backend->impl == &backend_impl;
}

91
backend/headless/input_device.c Normal file
View File

@ -0,0 +1,91 @@
#include <stdlib.h>
#include <wlr/interfaces/wlr_input_device.h>
#include <wlr/interfaces/wlr_pointer.h>
#include <wlr/interfaces/wlr_keyboard.h>
#include <wlr/interfaces/wlr_touch.h>
#include <wlr/interfaces/wlr_tablet_tool.h>
#include <wlr/interfaces/wlr_tablet_pad.h>
#include <wlr/util/log.h>
#include "backend/headless.h"
static void input_device_destroy(struct wlr_input_device *wlr_dev) {
struct wlr_headless_input_device *device =
(struct wlr_headless_input_device *)wlr_dev;
wl_signal_emit(&device->backend->backend.events.input_remove, wlr_dev);
free(device);
}
static struct wlr_input_device_impl input_device_impl = {
.destroy = input_device_destroy,
};
struct wlr_input_device *wlr_headless_add_input_device(
struct wlr_backend *wlr_backend, enum wlr_input_device_type type) {
struct wlr_headless_backend *backend =
(struct wlr_headless_backend *)wlr_backend;
struct wlr_headless_input_device *device =
calloc(1, sizeof(struct wlr_headless_input_device));
if (device == NULL) {
return NULL;
}
device->backend = backend;
int vendor = 0;
int product = 0;
const char *name = "headless";
struct wlr_input_device *wlr_device = &device->wlr_input_device;
wlr_input_device_init(wlr_device, type, &input_device_impl, name, vendor,
product);
switch (type) {
case WLR_INPUT_DEVICE_KEYBOARD:
wlr_device->keyboard = calloc(1, sizeof(struct wlr_keyboard));
if (wlr_device->keyboard == NULL) {
wlr_log(L_ERROR, "Unable to allocate wlr_keyboard");
return NULL;
}
wlr_keyboard_init(wlr_device->keyboard, NULL);
break;
case WLR_INPUT_DEVICE_POINTER:
wlr_device->pointer = calloc(1, sizeof(struct wlr_pointer));
if (wlr_device->pointer == NULL) {
wlr_log(L_ERROR, "Unable to allocate wlr_pointer");
return NULL;
}
wlr_pointer_init(wlr_device->pointer, NULL);
break;
case WLR_INPUT_DEVICE_TOUCH:
wlr_device->touch = calloc(1, sizeof(struct wlr_touch));
if (wlr_device->touch == NULL) {
wlr_log(L_ERROR, "Unable to allocate wlr_touch");
return NULL;
}
wlr_touch_init(wlr_device->touch, NULL);
break;
case WLR_INPUT_DEVICE_TABLET_TOOL:
wlr_device->tablet_tool = calloc(1, sizeof(struct wlr_tablet_tool));
if (wlr_device->tablet_tool == NULL) {
wlr_log(L_ERROR, "Unable to allocate wlr_tablet_tool");
return NULL;
}
wlr_tablet_tool_init(wlr_device->tablet_tool, NULL);
break;
case WLR_INPUT_DEVICE_TABLET_PAD:
wlr_device->tablet_pad = calloc(1, sizeof(struct wlr_tablet_pad));
if (wlr_device->tablet_pad == NULL) {
wlr_log(L_ERROR, "Unable to allocate wlr_tablet_pad");
return NULL;
}
wlr_tablet_pad_init(wlr_device->tablet_pad, NULL);
break;
}
wl_list_insert(&backend->input_devices, &wlr_device->link);
if (backend->started) {
wl_signal_emit(&backend->backend.events.input_add, wlr_device);
}
return wlr_device;
}

146
backend/headless/output.c Normal file
View File

@ -0,0 +1,146 @@
#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 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;
}
static bool output_set_custom_mode(struct wlr_output *wlr_output, int32_t width,
int32_t height, int32_t refresh) {
struct wlr_headless_output *output =
(struct wlr_headless_output *)wlr_output;
struct wlr_headless_backend *backend = output->backend;
if (output->egl_surface) {
eglDestroySurface(backend->egl.display, output->egl_surface);
}
output->egl_surface = egl_create_surface(&backend->egl, width, height);
if (output->egl_surface == EGL_NO_SURFACE) {
wlr_log(L_ERROR, "Failed to recreate EGL surface");
wlr_output_destroy(wlr_output);
return false;
}
output->frame_delay = 1000000 / refresh;
wlr_output_update_custom_mode(&output->wlr_output, width, height, refresh);
return true;
}
static void output_transform(struct wlr_output *wlr_output,
enum wl_output_transform transform) {
struct wlr_headless_output *output =
(struct wlr_headless_output *)wlr_output;
output->wlr_output.transform = transform;
}
static void output_make_current(struct wlr_output *wlr_output) {
struct wlr_headless_output *output =
(struct wlr_headless_output *)wlr_output;
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());
}
}
static void output_swap_buffers(struct wlr_output *wlr_output) {
// No-op
}
static void output_destroy(struct wlr_output *wlr_output) {
struct wlr_headless_output *output =
(struct wlr_headless_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 = output_set_custom_mode,
.transform = output_transform,
.destroy = output_destroy,
.make_current = output_make_current,
.swap_buffers = output_swap_buffers,
};
static int signal_frame(void *data) {
struct wlr_headless_output *output = data;
wl_signal_emit(&output->wlr_output.events.frame, &output->wlr_output);
wl_event_source_timer_update(output->frame_timer, output->frame_delay);
return 0;
}
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_output *output =
calloc(1, sizeof(struct wlr_headless_output));
if (output == NULL) {
wlr_log(L_ERROR, "Failed to allocate wlr_headless_output");
return NULL;
}
output->backend = backend;
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);
if (output->egl_surface == EGL_NO_SURFACE) {
wlr_log(L_ERROR, "Failed to create EGL surface");
goto error;
}
output_set_custom_mode(wlr_output, width, height, 60*1000);
strncpy(wlr_output->make, "headless", sizeof(wlr_output->make));
strncpy(wlr_output->model, "headless", sizeof(wlr_output->model));
snprintf(wlr_output->name, sizeof(wlr_output->name), "HEADLESS-%d",
wl_list_length(&backend->outputs) + 1);
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);
struct wl_event_loop *ev = wl_display_get_event_loop(backend->display);
output->frame_timer = wl_event_loop_add_timer(ev, signal_frame, output);
wl_list_insert(&backend->outputs, &output->link);
if (backend->started) {
wl_event_source_timer_update(output->frame_timer, output->frame_delay);
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;
}

3
backend/meson.build
View File

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

2
backend/wayland/backend.c
View File

@ -185,7 +185,7 @@ struct wlr_backend *wlr_wl_backend_create(struct wl_display *display) {
}
wlr_egl_init(&backend->egl, EGL_PLATFORM_WAYLAND_EXT,
WL_SHM_FORMAT_ARGB8888, backend->remote_display);
backend->remote_display, NULL, WL_SHM_FORMAT_ARGB8888);
wlr_egl_bind_display(&backend->egl, backend->local_display);
backend->local_display_destroy.notify = handle_display_destroy;

6
backend/wayland/output.c
View File

@ -32,7 +32,7 @@ static bool wlr_wl_output_set_custom_mode(struct wlr_output *_output,
int32_t width, int32_t height, int32_t refresh) {
struct wlr_wl_backend_output *output = (struct wlr_wl_backend_output *)_output;
wl_egl_window_resize(output->egl_window, width, height, 0, 0);
wlr_output_update_size(&output->wlr_output, width, height);
wlr_output_update_custom_mode(&output->wlr_output, width, height, 0);
return true;
}
@ -229,7 +229,7 @@ static void xdg_toplevel_handle_configure(void *data, struct zxdg_toplevel_v6 *x
}
// loop over states for maximized etc?
wl_egl_window_resize(output->egl_window, width, height, 0, 0);
wlr_output_update_size(&output->wlr_output, width, height);
wlr_output_update_custom_mode(&output->wlr_output, width, height, 0);
}
static void xdg_toplevel_handle_close(void *data, struct zxdg_toplevel_v6 *xdg_toplevel) {
@ -260,7 +260,7 @@ struct wlr_output *wlr_wl_output_create(struct wlr_backend *_backend) {
wlr_output_init(&output->wlr_output, &backend->backend, &output_impl);
struct wlr_output *wlr_output = &output->wlr_output;
wlr_output_update_size(wlr_output, 1280, 720);
wlr_output_update_custom_mode(wlr_output, 1280, 720, 0);
strncpy(wlr_output->make, "wayland", sizeof(wlr_output->make));
strncpy(wlr_output->model, "wayland", sizeof(wlr_output->model));
snprintf(wlr_output->name, sizeof(wlr_output->name), "WL-%d",

7
backend/x11/backend.c
View File

@ -117,7 +117,8 @@ static bool handle_x11_event(struct wlr_x11_backend *x11, xcb_generic_event_t *e
case XCB_CONFIGURE_NOTIFY: {
xcb_configure_notify_event_t *ev = (xcb_configure_notify_event_t *)event;
wlr_output_update_size(&output->wlr_output, ev->width, ev->height);
wlr_output_update_custom_mode(&output->wlr_output, ev->width,
ev->height, 0);
// Move the pointer to its new location
xcb_query_pointer_cookie_t cookie =
@ -310,8 +311,8 @@ struct wlr_backend *wlr_x11_backend_create(struct wl_display *display,
x11->screen = xcb_setup_roots_iterator(xcb_get_setup(x11->xcb_conn)).data;
if (!wlr_egl_init(&x11->egl, EGL_PLATFORM_X11_KHR,
x11->screen->root_visual, x11->xlib_conn)) {
if (!wlr_egl_init(&x11->egl, EGL_PLATFORM_X11_KHR, x11->xlib_conn, NULL,
x11->screen->root_visual)) {
goto error_event;
}

35
include/backend/headless.h Normal file
View File

@ -0,0 +1,35 @@
#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_list input_devices;
struct wl_listener display_destroy;
bool started;
};
struct wlr_headless_output {
struct wlr_output wlr_output;
struct wlr_headless_backend *backend;
struct wl_list link;
void *egl_surface;
struct wl_event_source *frame_timer;
int frame_delay; // ms
};
struct wlr_headless_input_device {
struct wlr_input_device wlr_input_device;
struct wlr_headless_backend *backend;
};
#endif

14
include/wlr/backend/headless.h Normal file
View File

@ -0,0 +1,14 @@
#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_device(
struct wlr_backend *backend, enum wlr_input_device_type type);
bool wlr_backend_is_headless(struct wlr_backend *backend);
#endif

6
include/wlr/interfaces/wlr_output.h
View File

@ -28,8 +28,10 @@ struct wlr_output_impl {
void wlr_output_init(struct wlr_output *output, struct wlr_backend *backend,
const struct wlr_output_impl *impl);
void wlr_output_free(struct wlr_output *output);
void wlr_output_update_size(struct wlr_output *output, int32_t width,
int32_t height);
void wlr_output_update_mode(struct wlr_output *output,
struct wlr_output_mode *mode);
void wlr_output_update_custom_mode(struct wlr_output *output, int32_t width,
int32_t height, int32_t refresh);
struct wl_global *wlr_output_create_global(struct wlr_output *wlr_output,
struct wl_display *display);
void wlr_output_destroy_global(struct wlr_output *wlr_output);

3
include/wlr/render/egl.h
View File

@ -22,7 +22,8 @@ struct wlr_egl {
* Initializes an egl context for the given platform and remote display.
* Will attempt to load all possibly required api functions.
*/
bool wlr_egl_init(struct wlr_egl *egl, EGLenum platform, EGLint visual_id, void *display);
bool wlr_egl_init(struct wlr_egl *egl, EGLenum platform, void *remote_display,
EGLint *config_attribs, EGLint visual_id);
/**
* Frees all related egl resources, makes the context not-current and

1
include/wlr/types/wlr_output.h
View File

@ -47,6 +47,7 @@ struct wlr_output {
char serial[16];
float scale;
int32_t width, height;
int32_t refresh; // mHz
int32_t phys_width, phys_height; // mm
enum wl_output_subpixel subpixel;
enum wl_output_transform transform;

19
render/egl.c
View File

@ -1,3 +1,4 @@
#include <assert.h>
#include <EGL/egl.h>
#include <EGL/eglext.h>
#include <GLES2/gl2.h>
@ -47,7 +48,8 @@ const char *egl_error(void) {
}
}
static bool egl_get_config(EGLDisplay disp, EGLConfig *out, EGLint visual_id) {
static bool egl_get_config(EGLDisplay disp, EGLint *attribs, EGLConfig *out,
EGLint visual_id) {
EGLint count = 0, matched = 0, ret;
ret = eglGetConfigs(disp, NULL, 0, &count);
@ -58,7 +60,7 @@ static bool egl_get_config(EGLDisplay disp, EGLConfig *out, EGLint visual_id) {
EGLConfig configs[count];
ret = eglChooseConfig(disp, NULL, configs, count, &matched);
ret = eglChooseConfig(disp, attribs, configs, count, &matched);
if (ret == EGL_FALSE) {
wlr_log(L_ERROR, "eglChooseConfig failed");
return false;
@ -71,7 +73,7 @@ static bool egl_get_config(EGLDisplay disp, EGLConfig *out, EGLint visual_id) {
continue;
}
if (visual == visual_id) {
if (!visual_id || visual == visual_id) {
*out = configs[i];
return true;
}
@ -81,8 +83,8 @@ static bool egl_get_config(EGLDisplay disp, EGLConfig *out, EGLint visual_id) {
return false;
}
bool wlr_egl_init(struct wlr_egl *egl, EGLenum platform, EGLint visual_id,
void *remote_display) {
bool wlr_egl_init(struct wlr_egl *egl, EGLenum platform, void *remote_display,
EGLint *config_attribs, EGLint visual_id) {
if (!load_glapi()) {
return false;
}
@ -92,7 +94,12 @@ bool wlr_egl_init(struct wlr_egl *egl, EGLenum platform, EGLint visual_id,
goto error;
}
if (platform == EGL_PLATFORM_SURFACELESS_MESA) {
assert(remote_display == NULL);
egl->display = eglGetDisplay(EGL_DEFAULT_DISPLAY);
} else {
egl->display = eglGetPlatformDisplayEXT(platform, remote_display, NULL);
}
if (egl->display == EGL_NO_DISPLAY) {
wlr_log(L_ERROR, "Failed to create EGL display: %s", egl_error());
goto error;
@ -104,7 +111,7 @@ bool wlr_egl_init(struct wlr_egl *egl, EGLenum platform, EGLint visual_id,
goto error;
}
if (!egl_get_config(egl->display, &egl->config, visual_id)) {
if (!egl_get_config(egl->display, config_attribs, &egl->config, visual_id)) {
wlr_log(L_ERROR, "Failed to get EGL config");
goto error;
}

7
rootston/main.c
View File

@ -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,11 @@ 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));
wlr_headless_add_output(server.backend, 1280, 720);
wlr_headless_add_input_device(server.backend, WLR_INPUT_DEVICE_KEYBOARD);
wlr_headless_add_input_device(server.backend, WLR_INPUT_DEVICE_POINTER);
assert(server.renderer = wlr_gles2_renderer_create(server.backend));
server.data_device_manager =

22
types/wlr_output.c
View File

@ -39,7 +39,7 @@ static void wl_output_send_to_resource(struct wl_resource *resource) {
if (wl_list_length(&output->modes) == 0) {
// Output has no mode, send the current width/height
wl_output_send_mode(resource, WL_OUTPUT_MODE_CURRENT,
output->width, output->height, 0);
output->width, output->height, output->refresh);
}
}
if (version >= WL_OUTPUT_SCALE_SINCE_VERSION) {
@ -65,9 +65,9 @@ static void wlr_output_send_current_mode_to_resource(
wl_output_send_mode(resource, flags | WL_OUTPUT_MODE_CURRENT,
mode->width, mode->height, mode->refresh);
} else {
// Output has no mode, send the current width/height
// Output has no mode
wl_output_send_mode(resource, WL_OUTPUT_MODE_CURRENT, output->width,
output->height, 0);
output->height, output->refresh);
}
if (version >= WL_OUTPUT_DONE_SINCE_VERSION) {
wl_output_send_done(resource);
@ -192,9 +192,17 @@ bool wlr_output_set_custom_mode(struct wlr_output *output, int32_t width,
return result;
}
void wlr_output_update_size(struct wlr_output *output, int32_t width,
int32_t height) {
if (output->width == width && output->height == height) {
void wlr_output_update_mode(struct wlr_output *output,
struct wlr_output_mode *mode) {
output->current_mode = mode;
wlr_output_update_custom_mode(output, mode->width, mode->height,
mode->refresh);
}
void wlr_output_update_custom_mode(struct wlr_output *output, int32_t width,
int32_t height, int32_t refresh) {
if (output->width == width && output->height == height &&
output->refresh == refresh) {
return;
}
@ -202,6 +210,8 @@ void wlr_output_update_size(struct wlr_output *output, int32_t width,
output->height = height;
wlr_output_update_matrix(output);
output->refresh = refresh;
struct wl_resource *resource;
wl_resource_for_each(resource, &output->wl_resources) {
wlr_output_send_current_mode_to_resource(resource);