diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index d9c49f7c2..aea7d6960 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -22,7 +22,7 @@ don't, however, allow me to make a suggestion: feature branches pulled from upstream. Try this: 1. Fork wlroots -2. `git clone git@ssh.gitlab.freedesktop.org:/wlroots.git && cd wlroots` +2. `git clone git@gitlab.freedesktop.org:/wlroots.git && cd wlroots` 3. `git remote add upstream https://gitlab.freedesktop.org/wlroots/wlroots.git` You only need to do this once. You're never going to use your fork's master diff --git a/backend/drm/drm.c b/backend/drm/drm.c index fe9dcc341..86b52c684 100644 --- a/backend/drm/drm.c +++ b/backend/drm/drm.c @@ -2104,7 +2104,6 @@ int wlr_drm_backend_get_non_master_fd(struct wlr_backend *backend) { if (drmIsMaster(fd) && drmDropMaster(fd) < 0) { wlr_log_errno(WLR_ERROR, "Failed to drop master"); - close(fd); return -1; } @@ -2139,7 +2138,7 @@ struct wlr_drm_lease *wlr_drm_create_lease(struct wlr_output **outputs, wlr_log(WLR_DEBUG, "Connector %d", conn->id); if (!drm_connector_alloc_crtc(conn)) { - wlr_log(WLR_ERROR, "Failed to allocate connector CRTC"); + wlr_log(WLR_ERROR, "Failled to allocate connector CRTC"); return NULL; } diff --git a/backend/libinput/events.c b/backend/libinput/events.c index 9be5def87..6cfe34e08 100644 --- a/backend/libinput/events.c +++ b/backend/libinput/events.c @@ -249,15 +249,3 @@ void handle_libinput_event(struct wlr_libinput_backend *backend, break; } } - -bool button_state_from_libinput(enum libinput_button_state state, enum wlr_button_state *out) { - switch (state) { - case LIBINPUT_BUTTON_STATE_RELEASED: - *out = WLR_BUTTON_RELEASED; - return true; - case LIBINPUT_BUTTON_STATE_PRESSED: - *out = WLR_BUTTON_PRESSED; - return true; - } - return false; -} diff --git a/backend/libinput/keyboard.c b/backend/libinput/keyboard.c index a99461040..7518453e6 100644 --- a/backend/libinput/keyboard.c +++ b/backend/libinput/keyboard.c @@ -2,7 +2,6 @@ #include #include #include -#include #include "backend/libinput.h" struct wlr_libinput_input_device *device_from_keyboard( @@ -31,18 +30,6 @@ void init_device_keyboard(struct wlr_libinput_input_device *dev) { libinput_device_led_update(dev->handle, 0); } -static bool key_state_from_libinput(enum libinput_key_state state, enum wl_keyboard_key_state *out) { - switch (state) { - case LIBINPUT_KEY_STATE_RELEASED: - *out = WL_KEYBOARD_KEY_STATE_RELEASED; - return true; - case LIBINPUT_KEY_STATE_PRESSED: - *out = WL_KEYBOARD_KEY_STATE_PRESSED; - return true; - } - return false; -} - void handle_keyboard_key(struct libinput_event *event, struct wlr_keyboard *kb) { struct libinput_event_keyboard *kbevent = @@ -52,9 +39,13 @@ void handle_keyboard_key(struct libinput_event *event, .keycode = libinput_event_keyboard_get_key(kbevent), .update_state = true, }; - if (!key_state_from_libinput(libinput_event_keyboard_get_key_state(kbevent), &wlr_event.state)) { - wlr_log(WLR_DEBUG, "Unhandled libinput key state"); - return; + switch (libinput_event_keyboard_get_key_state(kbevent)) { + case LIBINPUT_KEY_STATE_RELEASED: + wlr_event.state = WL_KEYBOARD_KEY_STATE_RELEASED; + break; + case LIBINPUT_KEY_STATE_PRESSED: + wlr_event.state = WL_KEYBOARD_KEY_STATE_PRESSED; + break; } wlr_keyboard_notify_key(kb, &wlr_event); } diff --git a/backend/libinput/meson.build b/backend/libinput/meson.build index 091b0e0eb..c244eb77a 100644 --- a/backend/libinput/meson.build +++ b/backend/libinput/meson.build @@ -29,7 +29,3 @@ features += { 'libinput-backend': true } wlr_deps += libinput internal_config.set10('HAVE_LIBINPUT_BUSTYPE', libinput.version().version_compare('>=1.26.0')) -internal_config.set10( - 'HAVE_LIBINPUT_SWITCH_KEYPAD_SLIDE', - libinput.version().version_compare('>=1.30.901') -) diff --git a/backend/libinput/pointer.c b/backend/libinput/pointer.c index d09164a71..9b9996780 100644 --- a/backend/libinput/pointer.c +++ b/backend/libinput/pointer.c @@ -1,7 +1,6 @@ #include #include #include -#include #include "backend/libinput.h" const struct wlr_pointer_impl libinput_pointer_impl = { @@ -53,38 +52,6 @@ void handle_pointer_motion_abs(struct libinput_event *event, wl_signal_emit_mutable(&pointer->events.frame, pointer); } -static bool pointer_button_state_from_libinput(enum libinput_button_state state, - enum wl_pointer_button_state *out) { - switch (state) { - case LIBINPUT_BUTTON_STATE_PRESSED: - *out = WL_POINTER_BUTTON_STATE_PRESSED; - return true; - case LIBINPUT_BUTTON_STATE_RELEASED: - *out = WL_POINTER_BUTTON_STATE_RELEASED; - return true; - } - return false; -} - -static bool axis_source_from_libinput(enum libinput_pointer_axis_source source, - enum wl_pointer_axis_source *out) { - switch (source) { - case LIBINPUT_POINTER_AXIS_SOURCE_WHEEL: - *out = WL_POINTER_AXIS_SOURCE_WHEEL; - return true; - case LIBINPUT_POINTER_AXIS_SOURCE_FINGER: - *out = WL_POINTER_AXIS_SOURCE_FINGER; - return true; - case LIBINPUT_POINTER_AXIS_SOURCE_CONTINUOUS: - *out = WL_POINTER_AXIS_SOURCE_CONTINUOUS; - return true; - case LIBINPUT_POINTER_AXIS_SOURCE_WHEEL_TILT: - *out = WL_POINTER_AXIS_SOURCE_WHEEL_TILT; - return true; - } - return false; -} - void handle_pointer_button(struct libinput_event *event, struct wlr_pointer *pointer) { struct libinput_event_pointer *pevent = @@ -94,10 +61,13 @@ void handle_pointer_button(struct libinput_event *event, .time_msec = usec_to_msec(libinput_event_pointer_get_time_usec(pevent)), .button = libinput_event_pointer_get_button(pevent), }; - if (!pointer_button_state_from_libinput(libinput_event_pointer_get_button_state(pevent), - &wlr_event.state)) { - wlr_log(WLR_DEBUG, "Unhandled libinput button state"); - return; + switch (libinput_event_pointer_get_button_state(pevent)) { + case LIBINPUT_BUTTON_STATE_PRESSED: + wlr_event.state = WL_POINTER_BUTTON_STATE_PRESSED; + break; + case LIBINPUT_BUTTON_STATE_RELEASED: + wlr_event.state = WL_POINTER_BUTTON_STATE_RELEASED; + break; } wlr_pointer_notify_button(pointer, &wlr_event); wl_signal_emit_mutable(&pointer->events.frame, pointer); @@ -111,9 +81,19 @@ void handle_pointer_axis(struct libinput_event *event, .pointer = pointer, .time_msec = usec_to_msec(libinput_event_pointer_get_time_usec(pevent)), }; - if (!axis_source_from_libinput(libinput_event_pointer_get_axis_source(pevent), &wlr_event.source)) { - wlr_log(WLR_DEBUG, "Unhandled libinput pointer axis source"); - return; + switch (libinput_event_pointer_get_axis_source(pevent)) { + case LIBINPUT_POINTER_AXIS_SOURCE_WHEEL: + wlr_event.source = WL_POINTER_AXIS_SOURCE_WHEEL; + break; + case LIBINPUT_POINTER_AXIS_SOURCE_FINGER: + wlr_event.source = WL_POINTER_AXIS_SOURCE_FINGER; + break; + case LIBINPUT_POINTER_AXIS_SOURCE_CONTINUOUS: + wlr_event.source = WL_POINTER_AXIS_SOURCE_CONTINUOUS; + break; + case LIBINPUT_POINTER_AXIS_SOURCE_WHEEL_TILT: + wlr_event.source = WL_POINTER_AXIS_SOURCE_WHEEL_TILT; + break; } const enum libinput_pointer_axis axes[] = { LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL, diff --git a/backend/libinput/switch.c b/backend/libinput/switch.c index 2055d88f5..abeec86d7 100644 --- a/backend/libinput/switch.c +++ b/backend/libinput/switch.c @@ -1,9 +1,7 @@ #include #include #include -#include #include "backend/libinput.h" -#include "config.h" const struct wlr_switch_impl libinput_switch_impl = { .name = "libinput-switch", @@ -24,49 +22,28 @@ struct wlr_libinput_input_device *device_from_switch( return dev; } -static bool switch_type_from_libinput(enum libinput_switch type, enum wlr_switch_type *out) { - switch (type) { - case LIBINPUT_SWITCH_LID: - *out = WLR_SWITCH_TYPE_LID; - return true; - case LIBINPUT_SWITCH_TABLET_MODE: - *out = WLR_SWITCH_TYPE_TABLET_MODE; - return true; -#if HAVE_LIBINPUT_SWITCH_KEYPAD_SLIDE - case LIBINPUT_SWITCH_KEYPAD_SLIDE: - *out = WLR_SWITCH_TYPE_KEYPAD_SLIDE; - return true; -#endif - } - return false; -} - -static bool switch_state_from_libinput(enum libinput_switch_state state, enum wlr_switch_state *out) { - switch (state) { - case LIBINPUT_SWITCH_STATE_OFF: - *out = WLR_SWITCH_STATE_OFF; - return true; - case LIBINPUT_SWITCH_STATE_ON: - *out = WLR_SWITCH_STATE_ON; - return true; - } - return false; -} - void handle_switch_toggle(struct libinput_event *event, struct wlr_switch *wlr_switch) { struct libinput_event_switch *sevent = - libinput_event_get_switch_event(event); + libinput_event_get_switch_event (event); struct wlr_switch_toggle_event wlr_event = { .time_msec = usec_to_msec(libinput_event_switch_get_time_usec(sevent)), }; - if (!switch_type_from_libinput(libinput_event_switch_get_switch(sevent), &wlr_event.switch_type)) { - wlr_log(WLR_DEBUG, "Unhandled libinput switch type"); - return; + switch (libinput_event_switch_get_switch(sevent)) { + case LIBINPUT_SWITCH_LID: + wlr_event.switch_type = WLR_SWITCH_TYPE_LID; + break; + case LIBINPUT_SWITCH_TABLET_MODE: + wlr_event.switch_type = WLR_SWITCH_TYPE_TABLET_MODE; + break; } - if (!switch_state_from_libinput(libinput_event_switch_get_switch_state(sevent), &wlr_event.switch_state)) { - wlr_log(WLR_DEBUG, "Unhandled libinput switch state"); - return; + switch (libinput_event_switch_get_switch_state(sevent)) { + case LIBINPUT_SWITCH_STATE_OFF: + wlr_event.switch_state = WLR_SWITCH_STATE_OFF; + break; + case LIBINPUT_SWITCH_STATE_ON: + wlr_event.switch_state = WLR_SWITCH_STATE_ON; + break; } wl_signal_emit_mutable(&wlr_switch->events.toggle, &wlr_event); } diff --git a/backend/libinput/tablet_pad.c b/backend/libinput/tablet_pad.c index 9d090198a..2fbfb6a6c 100644 --- a/backend/libinput/tablet_pad.c +++ b/backend/libinput/tablet_pad.c @@ -148,9 +148,13 @@ void handle_tablet_pad_button(struct libinput_event *event, .group = libinput_tablet_pad_mode_group_get_index( libinput_event_tablet_pad_get_mode_group(pevent)), }; - if (!button_state_from_libinput(libinput_event_tablet_pad_get_button_state(pevent), &wlr_event.state)) { - wlr_log(WLR_DEBUG, "Unhandled libinput button state"); - return; + switch (libinput_event_tablet_pad_get_button_state(pevent)) { + case LIBINPUT_BUTTON_STATE_PRESSED: + wlr_event.state = WLR_BUTTON_PRESSED; + break; + case LIBINPUT_BUTTON_STATE_RELEASED: + wlr_event.state = WLR_BUTTON_RELEASED; + break; } wl_signal_emit_mutable(&tablet_pad->events.button, &wlr_event); } @@ -164,7 +168,6 @@ void handle_tablet_pad_ring(struct libinput_event *event, .ring = libinput_event_tablet_pad_get_ring_number(pevent), .position = libinput_event_tablet_pad_get_ring_position(pevent), .mode = libinput_event_tablet_pad_get_mode(pevent), - .source = WLR_TABLET_PAD_RING_SOURCE_UNKNOWN, }; switch (libinput_event_tablet_pad_get_ring_source(pevent)) { case LIBINPUT_TABLET_PAD_RING_SOURCE_UNKNOWN: @@ -186,7 +189,6 @@ void handle_tablet_pad_strip(struct libinput_event *event, .strip = libinput_event_tablet_pad_get_strip_number(pevent), .position = libinput_event_tablet_pad_get_strip_position(pevent), .mode = libinput_event_tablet_pad_get_mode(pevent), - .source = WLR_TABLET_PAD_STRIP_SOURCE_UNKNOWN, }; switch (libinput_event_tablet_pad_get_strip_source(pevent)) { case LIBINPUT_TABLET_PAD_STRIP_SOURCE_UNKNOWN: diff --git a/backend/libinput/tablet_tool.c b/backend/libinput/tablet_tool.c index 782e56a86..b2430a445 100644 --- a/backend/libinput/tablet_tool.c +++ b/backend/libinput/tablet_tool.c @@ -78,61 +78,27 @@ struct wlr_libinput_input_device *device_from_tablet( return dev; } -static bool type_from_libinput(enum libinput_tablet_tool_type type, - enum wlr_tablet_tool_type *out) { - switch (type) { +static enum wlr_tablet_tool_type wlr_type_from_libinput_type( + enum libinput_tablet_tool_type value) { + switch (value) { case LIBINPUT_TABLET_TOOL_TYPE_PEN: - *out = WLR_TABLET_TOOL_TYPE_PEN; - return true; + return WLR_TABLET_TOOL_TYPE_PEN; case LIBINPUT_TABLET_TOOL_TYPE_ERASER: - *out = WLR_TABLET_TOOL_TYPE_ERASER; - return true; + return WLR_TABLET_TOOL_TYPE_ERASER; case LIBINPUT_TABLET_TOOL_TYPE_BRUSH: - *out = WLR_TABLET_TOOL_TYPE_BRUSH; - return true; + return WLR_TABLET_TOOL_TYPE_BRUSH; case LIBINPUT_TABLET_TOOL_TYPE_PENCIL: - *out = WLR_TABLET_TOOL_TYPE_PENCIL; - return true; + return WLR_TABLET_TOOL_TYPE_PENCIL; case LIBINPUT_TABLET_TOOL_TYPE_AIRBRUSH: - *out = WLR_TABLET_TOOL_TYPE_AIRBRUSH; - return true; + return WLR_TABLET_TOOL_TYPE_AIRBRUSH; case LIBINPUT_TABLET_TOOL_TYPE_MOUSE: - *out = WLR_TABLET_TOOL_TYPE_MOUSE; - return true; + return WLR_TABLET_TOOL_TYPE_MOUSE; case LIBINPUT_TABLET_TOOL_TYPE_LENS: - *out = WLR_TABLET_TOOL_TYPE_LENS; - return true; + return WLR_TABLET_TOOL_TYPE_LENS; case LIBINPUT_TABLET_TOOL_TYPE_TOTEM: - *out = WLR_TABLET_TOOL_TYPE_TOTEM; - return true; + return WLR_TABLET_TOOL_TYPE_TOTEM; } - return false; -} - -static bool proximity_state_from_libinput(enum libinput_tablet_tool_proximity_state state, - enum wlr_tablet_tool_proximity_state *out) { - switch (state) { - case LIBINPUT_TABLET_TOOL_PROXIMITY_STATE_OUT: - *out = WLR_TABLET_TOOL_PROXIMITY_OUT; - return true; - case LIBINPUT_TABLET_TOOL_PROXIMITY_STATE_IN: - *out = WLR_TABLET_TOOL_PROXIMITY_IN; - return true; - } - return false; -} - -static bool tip_state_from_libinput(enum libinput_tablet_tool_tip_state state, - enum wlr_tablet_tool_tip_state *out) { - switch (state) { - case LIBINPUT_TABLET_TOOL_TIP_UP: - *out = WLR_TABLET_TOOL_TIP_UP; - return true; - case LIBINPUT_TABLET_TOOL_TIP_DOWN: - *out = WLR_TABLET_TOOL_TIP_DOWN; - return true; - } - return false; + abort(); // unreachable } static struct tablet_tool *get_tablet_tool( @@ -144,19 +110,14 @@ static struct tablet_tool *get_tablet_tool( return tool; } - enum wlr_tablet_tool_type type; - if (!type_from_libinput(libinput_tablet_tool_get_type(libinput_tool), &type)) { - wlr_log(WLR_DEBUG, "Unhandled libinput tablet tool type"); - return NULL; - } - tool = calloc(1, sizeof(*tool)); if (tool == NULL) { wlr_log_errno(WLR_ERROR, "failed to allocate wlr_libinput_tablet_tool"); return NULL; } - tool->wlr_tool.type = type; + tool->wlr_tool.type = wlr_type_from_libinput_type( + libinput_tablet_tool_get_type(libinput_tool)); tool->wlr_tool.hardware_serial = libinput_tablet_tool_get_serial(libinput_tool); tool->wlr_tool.hardware_wacom = @@ -248,12 +209,14 @@ void handle_tablet_tool_proximity(struct libinput_event *event, .y = libinput_event_tablet_tool_get_y_transformed(tevent, 1), }; - if (!proximity_state_from_libinput(libinput_event_tablet_tool_get_proximity_state(tevent), - &wlr_event.state)) { - wlr_log(WLR_DEBUG, "Unhandled libinput tablet tool proximity state"); - return; + switch (libinput_event_tablet_tool_get_proximity_state(tevent)) { + case LIBINPUT_TABLET_TOOL_PROXIMITY_STATE_OUT: + wlr_event.state = WLR_TABLET_TOOL_PROXIMITY_OUT; + break; + case LIBINPUT_TABLET_TOOL_PROXIMITY_STATE_IN: + wlr_event.state = WLR_TABLET_TOOL_PROXIMITY_IN; + break; } - wl_signal_emit_mutable(&wlr_tablet->events.proximity, &wlr_event); if (libinput_event_tablet_tool_get_proximity_state(tevent) == @@ -288,11 +251,14 @@ void handle_tablet_tool_tip(struct libinput_event *event, .y = libinput_event_tablet_tool_get_y_transformed(tevent, 1), }; - if (!tip_state_from_libinput(libinput_event_tablet_tool_get_tip_state(tevent), &wlr_event.state)) { - wlr_log(WLR_DEBUG, "Unhandled libinput tablet tool tip state"); - return; + switch (libinput_event_tablet_tool_get_tip_state(tevent)) { + case LIBINPUT_TABLET_TOOL_TIP_UP: + wlr_event.state = WLR_TABLET_TOOL_TIP_UP; + break; + case LIBINPUT_TABLET_TOOL_TIP_DOWN: + wlr_event.state = WLR_TABLET_TOOL_TIP_DOWN; + break; } - wl_signal_emit_mutable(&wlr_tablet->events.tip, &wlr_event); } @@ -311,11 +277,13 @@ void handle_tablet_tool_button(struct libinput_event *event, .time_msec = usec_to_msec(libinput_event_tablet_tool_get_time_usec(tevent)), .button = libinput_event_tablet_tool_get_button(tevent), }; - - if (!button_state_from_libinput(libinput_event_tablet_tool_get_button_state(tevent), &wlr_event.state)) { - wlr_log(WLR_DEBUG, "Unhandled libinput button state"); - return; + switch (libinput_event_tablet_tool_get_button_state(tevent)) { + case LIBINPUT_BUTTON_STATE_RELEASED: + wlr_event.state = WLR_BUTTON_RELEASED; + break; + case LIBINPUT_BUTTON_STATE_PRESSED: + wlr_event.state = WLR_BUTTON_PRESSED; + break; } - wl_signal_emit_mutable(&wlr_tablet->events.button, &wlr_event); } diff --git a/backend/wayland/seat.c b/backend/wayland/seat.c index f178d9baf..a66357bf8 100644 --- a/backend/wayland/seat.c +++ b/backend/wayland/seat.c @@ -246,7 +246,7 @@ void init_seat_touch(struct wlr_wl_seat *seat) { struct wlr_wl_output *output; wl_list_for_each(output, &seat->backend->outputs, link) { - /* Multi-output touch not supported */ + /* Multi-output touch not supproted */ seat->wlr_touch.output_name = strdup(output->wlr_output.name); break; } diff --git a/backend/x11/output.c b/backend/x11/output.c index 51a9c1441..0b63a7088 100644 --- a/backend/x11/output.c +++ b/backend/x11/output.c @@ -19,9 +19,7 @@ #include #include "backend/x11.h" -#include "render/pixel_format.h" #include "util/time.h" -#include "types/wlr_buffer.h" #include "types/wlr_output.h" static const uint32_t SUPPORTED_OUTPUT_STATE = @@ -168,20 +166,18 @@ static bool output_test(struct wlr_output *wlr_output, if (state->committed & WLR_OUTPUT_STATE_BUFFER) { struct wlr_buffer *buffer = state->buffer; - uint32_t format = buffer_get_drm_format(buffer); + struct wlr_dmabuf_attributes dmabuf_attrs; + struct wlr_shm_attributes shm_attrs; + uint32_t format = DRM_FORMAT_INVALID; + if (wlr_buffer_get_dmabuf(buffer, &dmabuf_attrs)) { + format = dmabuf_attrs.format; + } else if (wlr_buffer_get_shm(buffer, &shm_attrs)) { + format = shm_attrs.format; + } if (format != x11->x11_format->drm) { wlr_log(WLR_DEBUG, "Unsupported buffer format"); return false; } - struct wlr_shm_attributes shm; - if (wlr_buffer_get_shm(buffer, &shm)) { - const struct wlr_pixel_format_info *info = drm_get_pixel_format_info(format); - if (shm.stride != pixel_format_info_min_stride(info, shm.width)) { - // xcb_shm_create_pixmap() does not allow arbitrary strides. - wlr_log(WLR_DEBUG, "Unsupported shm buffer stride"); - return false; - } - } } if (state->committed & WLR_OUTPUT_STATE_MODE) { @@ -271,12 +267,6 @@ static xcb_pixmap_t import_shm(struct wlr_x11_output *output, return XCB_PIXMAP_NONE; } - const struct wlr_pixel_format_info *info = drm_get_pixel_format_info(shm->format); - if (shm->stride != pixel_format_info_min_stride(info, shm->width)) { - // xcb_shm_create_pixmap() does not allow arbitrary strides. - return XCB_PIXMAP_NONE; - } - // xcb closes the FD after sending it int fd = fcntl(shm->fd, F_DUPFD_CLOEXEC, 0); if (fd < 0) { diff --git a/include/backend/libinput.h b/include/backend/libinput.h index e7123884e..874e9aa1f 100644 --- a/include/backend/libinput.h +++ b/include/backend/libinput.h @@ -132,6 +132,4 @@ void handle_tablet_pad_ring(struct libinput_event *event, void handle_tablet_pad_strip(struct libinput_event *event, struct wlr_tablet_pad *tablet_pad); -bool button_state_from_libinput(enum libinput_button_state state, enum wlr_button_state *out); - #endif diff --git a/include/render/color.h b/include/render/color.h index 60c841d12..57d2b6a96 100644 --- a/include/render/color.h +++ b/include/render/color.h @@ -91,7 +91,7 @@ struct wlr_color_transform_lut_3x1d *color_transform_lut_3x1d_from_base( * Create a simplified / normalized wlr_color_transform pipeline. * `transforms` may contain NULL transforms, they will be interpreted as the * identity transform, and removed. - * `*result` may be set to a transform of a type different from + * `*result` may be set to a tranform of a type different from * `wlr_color_transform_pipeline`, or to NULL if all input transforms are NULL */ bool color_transform_compose(struct wlr_color_transform **result, diff --git a/include/render/pixel_format.h b/include/render/pixel_format.h index b5f2b2411..e0b500c75 100644 --- a/include/render/pixel_format.h +++ b/include/render/pixel_format.h @@ -63,9 +63,4 @@ enum wl_shm_format convert_drm_format_to_wl_shm(uint32_t fmt); */ bool pixel_format_has_alpha(uint32_t fmt); -/** - * Return true if the DRM FourCC fmt belongs to a YCbCr colorspace family, false otherwise. - */ -bool pixel_format_is_ycbcr(uint32_t fmt); - #endif diff --git a/include/render/vulkan.h b/include/render/vulkan.h index f96619f2c..bb56b5534 100644 --- a/include/render/vulkan.h +++ b/include/render/vulkan.h @@ -86,6 +86,7 @@ struct wlr_vk_format { uint32_t drm; VkFormat vk; VkFormat vk_srgb; // sRGB version of the format, or 0 if nonexistent + bool is_ycbcr; }; extern const VkImageUsageFlags vulkan_render_usage, vulkan_shm_tex_usage, vulkan_dma_tex_usage; @@ -124,7 +125,6 @@ void vulkan_format_props_query(struct wlr_vk_device *dev, const struct wlr_vk_format_modifier_props *vulkan_format_props_find_modifier( const struct wlr_vk_format_props *props, uint64_t mod, bool render); void vulkan_format_props_finish(struct wlr_vk_format_props *props); -bool vulkan_format_is_ycbcr(const struct wlr_vk_format *format); struct wlr_vk_pipeline_layout_key { enum wlr_scale_filter_mode filter_mode; @@ -224,7 +224,7 @@ struct wlr_vk_render_buffer_out { bool transitioned; }; -// Renderer-internal representation of an wlr_buffer imported for rendering. +// Renderer-internal represenation of an wlr_buffer imported for rendering. struct wlr_vk_render_buffer { struct wlr_buffer *wlr_buffer; struct wlr_addon addon; @@ -473,11 +473,10 @@ void vulkan_reset_command_buffer(struct wlr_vk_command_buffer *cb); bool vulkan_wait_command_buffer(struct wlr_vk_command_buffer *cb, struct wlr_vk_renderer *renderer); -bool vulkan_sync_render_pass_release(struct wlr_vk_renderer *renderer, - struct wlr_vk_render_pass *pass); -bool vulkan_sync_foreign_texture_acquire(struct wlr_vk_texture *texture, - int sync_file_fds[static WLR_DMABUF_MAX_PLANES]); -bool vulkan_sync_render_buffer_acquire(struct wlr_vk_render_buffer *render_buffer, +bool vulkan_sync_render_buffer(struct wlr_vk_renderer *renderer, + struct wlr_vk_render_buffer *render_buffer, struct wlr_vk_command_buffer *cb, + struct wlr_drm_syncobj_timeline *signal_timeline, uint64_t signal_point); +bool vulkan_sync_foreign_texture(struct wlr_vk_texture *texture, int sync_file_fds[static WLR_DMABUF_MAX_PLANES]); bool vulkan_read_pixels(struct wlr_vk_renderer *vk_renderer, diff --git a/include/types/wlr_buffer.h b/include/types/wlr_buffer.h index 45acf7a1d..9d882d47d 100644 --- a/include/types/wlr_buffer.h +++ b/include/types/wlr_buffer.h @@ -65,10 +65,4 @@ struct wlr_client_buffer *wlr_client_buffer_create(struct wlr_buffer *buffer, bool wlr_client_buffer_apply_damage(struct wlr_client_buffer *client_buffer, struct wlr_buffer *next, const pixman_region32_t *damage); -/** - * Return the DRM format of the buffer. If this buffer isn't shared - * memory or a DMA-BUF, returns DRM_FORMAT_INVALID. - */ -uint32_t buffer_get_drm_format(struct wlr_buffer *buffer); - #endif diff --git a/include/wlr/types/wlr_cursor.h b/include/wlr/types/wlr_cursor.h index aaa18a437..041f735cf 100644 --- a/include/wlr/types/wlr_cursor.h +++ b/include/wlr/types/wlr_cursor.h @@ -49,30 +49,30 @@ struct wlr_cursor { * your responsibility. */ struct { - struct wl_signal motion; // struct wlr_pointer_motion_event - struct wl_signal motion_absolute; // struct wlr_pointer_motion_absolute_event - struct wl_signal button; // struct wlr_pointer_button_event - struct wl_signal axis; // struct wlr_pointer_axis_event + struct wl_signal motion; + struct wl_signal motion_absolute; + struct wl_signal button; + struct wl_signal axis; struct wl_signal frame; - struct wl_signal swipe_begin; // struct wlr_pointer_swipe_begin_event - struct wl_signal swipe_update; // struct wlr_pointer_swipe_update_event - struct wl_signal swipe_end; // struct wlr_pointer_swipe_end_event - struct wl_signal pinch_begin; // struct wlr_pointer_pinch_begin_event - struct wl_signal pinch_update; // struct wlr_pointer_pinch_update_event - struct wl_signal pinch_end; // struct wlr_pointer_pinch_end_event - struct wl_signal hold_begin; // struct wlr_pointer_hold_begin_event - struct wl_signal hold_end; // struct wlr_pointer_hold_end_event + struct wl_signal swipe_begin; + struct wl_signal swipe_update; + struct wl_signal swipe_end; + struct wl_signal pinch_begin; + struct wl_signal pinch_update; + struct wl_signal pinch_end; + struct wl_signal hold_begin; + struct wl_signal hold_end; - struct wl_signal touch_up; // struct wlr_touch_up_event - struct wl_signal touch_down; // struct wlr_touch_down_event - struct wl_signal touch_motion; // struct wlr_touch_motion_event - struct wl_signal touch_cancel; // struct wlr_touch_cancel_event + struct wl_signal touch_up; + struct wl_signal touch_down; + struct wl_signal touch_motion; + struct wl_signal touch_cancel; struct wl_signal touch_frame; - struct wl_signal tablet_tool_axis; // struct wlr_tablet_tool_axis_event - struct wl_signal tablet_tool_proximity; // struct wlr_tablet_tool_proximity_event - struct wl_signal tablet_tool_tip; // struct wlr_tablet_tool_tip_event - struct wl_signal tablet_tool_button; // struct wlr_tablet_tool_button_event + struct wl_signal tablet_tool_axis; + struct wl_signal tablet_tool_proximity; + struct wl_signal tablet_tool_tip; + struct wl_signal tablet_tool_button; } events; void *data; diff --git a/include/wlr/types/wlr_switch.h b/include/wlr/types/wlr_switch.h index 2b9e91266..641df1991 100644 --- a/include/wlr/types/wlr_switch.h +++ b/include/wlr/types/wlr_switch.h @@ -36,7 +36,6 @@ struct wlr_switch { enum wlr_switch_type { WLR_SWITCH_TYPE_LID, WLR_SWITCH_TYPE_TABLET_MODE, - WLR_SWITCH_TYPE_KEYPAD_SLIDE, }; enum wlr_switch_state { diff --git a/include/wlr/xcursor.h b/include/wlr/xcursor.h index 5e9c140ae..7cf333d70 100644 --- a/include/wlr/xcursor.h +++ b/include/wlr/xcursor.h @@ -47,7 +47,7 @@ /** * A still cursor image. * - * The buffer contains pixels laid out in a packed DRM_FORMAT_ARGB8888 format. + * The buffer contains pixels layed out in a packed DRM_FORMAT_ARGB8888 format. */ struct wlr_xcursor_image { uint32_t width; /* actual width */ diff --git a/meson.build b/meson.build index f054cc250..5b8f12073 100644 --- a/meson.build +++ b/meson.build @@ -1,7 +1,7 @@ project( 'wlroots', 'c', - version: '0.20.0-rc3', + version: '0.20.0-rc1', license: 'MIT', meson_version: '>=1.3', default_options: [ diff --git a/render/drm_syncobj.c b/render/drm_syncobj.c index e1a407a1e..912a2b6e5 100644 --- a/render/drm_syncobj.c +++ b/render/drm_syncobj.c @@ -167,9 +167,10 @@ bool wlr_drm_syncobj_timeline_check(struct wlr_drm_syncobj_timeline *timeline, etime = ETIME; #endif - int ret = drmSyncobjTimelineWait(timeline->drm_fd, &timeline->handle, &point, 1, 0, flags, NULL); + uint32_t signaled_point; + int ret = drmSyncobjTimelineWait(timeline->drm_fd, &timeline->handle, &point, 1, 0, flags, &signaled_point); if (ret != 0 && ret != -etime) { - wlr_log_errno(WLR_ERROR, "drmSyncobjTimelineWait() failed"); + wlr_log_errno(WLR_ERROR, "drmSyncobjWait() failed"); return false; } diff --git a/render/egl.c b/render/egl.c index 8673acabf..6f3e9c8ca 100644 --- a/render/egl.c +++ b/render/egl.c @@ -156,7 +156,7 @@ static void init_dmabuf_formats(struct wlr_egl *egl) { } if (modifiers_len == 0) { - // Assume the linear layout is supported if the driver doesn't + // Asume the linear layout is supported if the driver doesn't // explicitly say otherwise wlr_drm_format_set_add(&egl->dmabuf_texture_formats, fmt, DRM_FORMAT_MOD_LINEAR); diff --git a/render/pixel_format.c b/render/pixel_format.c index c60dd9d2a..5f2e8644a 100644 --- a/render/pixel_format.c +++ b/render/pixel_format.c @@ -307,68 +307,3 @@ bool pixel_format_has_alpha(uint32_t fmt) { } return true; } - -bool pixel_format_is_ycbcr(uint32_t format) { - switch (format) { - case DRM_FORMAT_AYUV: - case DRM_FORMAT_NV12: - case DRM_FORMAT_NV15: - case DRM_FORMAT_NV16: - case DRM_FORMAT_NV20: - case DRM_FORMAT_NV21: - case DRM_FORMAT_NV24: - case DRM_FORMAT_NV30: - case DRM_FORMAT_NV42: - case DRM_FORMAT_NV61: - case DRM_FORMAT_P010: - case DRM_FORMAT_P012: - case DRM_FORMAT_P016: - case DRM_FORMAT_P030: - case DRM_FORMAT_P210: - case DRM_FORMAT_Q401: - case DRM_FORMAT_Q410: - case DRM_FORMAT_S010: - case DRM_FORMAT_S012: - case DRM_FORMAT_S016: - case DRM_FORMAT_S210: - case DRM_FORMAT_S212: - case DRM_FORMAT_S216: - case DRM_FORMAT_S410: - case DRM_FORMAT_S412: - case DRM_FORMAT_S416: - case DRM_FORMAT_UYVY: - case DRM_FORMAT_VUY101010: - case DRM_FORMAT_VUY888: - case DRM_FORMAT_VYUY: - case DRM_FORMAT_X0L0: - case DRM_FORMAT_X0L2: - case DRM_FORMAT_XVYU12_16161616: - case DRM_FORMAT_XVYU16161616: - case DRM_FORMAT_XVYU2101010: - case DRM_FORMAT_XYUV8888: - case DRM_FORMAT_Y0L0: - case DRM_FORMAT_Y0L2: - case DRM_FORMAT_Y210: - case DRM_FORMAT_Y212: - case DRM_FORMAT_Y216: - case DRM_FORMAT_Y410: - case DRM_FORMAT_Y412: - case DRM_FORMAT_Y416: - case DRM_FORMAT_YUV410: - case DRM_FORMAT_YUV411: - case DRM_FORMAT_YUV420: - case DRM_FORMAT_YUV420_10BIT: - case DRM_FORMAT_YUV420_8BIT: - case DRM_FORMAT_YUV422: - case DRM_FORMAT_YUV444: - case DRM_FORMAT_YUYV: - case DRM_FORMAT_YVU410: - case DRM_FORMAT_YVU411: - case DRM_FORMAT_YVU420: - case DRM_FORMAT_YVU422: - case DRM_FORMAT_YVU444: - case DRM_FORMAT_YVYU: - return true; - } - return false; -} diff --git a/render/pixman/pass.c b/render/pixman/pass.c index d3ee17dca..4ae742cab 100644 --- a/render/pixman/pass.c +++ b/render/pixman/pass.c @@ -78,7 +78,7 @@ static void render_pass_add_texture(struct wlr_render_pass *wlr_pass, if (options->transform != WL_OUTPUT_TRANSFORM_NORMAL || src_box_transformed.width != dst_box.width || src_box_transformed.height != dst_box.height) { - // Cosinus/sinus values are exact integers for enum wl_output_transform entries + // Cosinus/sinus values are extact integers for enum wl_output_transform entries int tr_cos = 1, tr_sin = 0, tr_x = 0, tr_y = 0; switch (options->transform) { case WL_OUTPUT_TRANSFORM_NORMAL: diff --git a/render/vulkan/pass.c b/render/vulkan/pass.c index 503e37c07..31f5116bd 100644 --- a/render/vulkan/pass.c +++ b/render/vulkan/pass.c @@ -146,40 +146,6 @@ static VkSemaphore render_pass_wait_sync_file(struct wlr_vk_render_pass *pass, return *sem_ptr; } -static bool render_pass_wait_render_buffer(struct wlr_vk_render_pass *pass, - VkSemaphoreSubmitInfoKHR *render_wait, uint32_t *render_wait_len_ptr) { - int sync_file_fds[WLR_DMABUF_MAX_PLANES]; - for (size_t i = 0; i < WLR_DMABUF_MAX_PLANES; i++) { - sync_file_fds[i] = -1; - } - - if (!vulkan_sync_render_buffer_acquire(pass->render_buffer, sync_file_fds)) { - return false; - } - - for (size_t i = 0; i < WLR_DMABUF_MAX_PLANES; i++) { - if (sync_file_fds[i] < 0) { - continue; - } - - VkSemaphore sem = render_pass_wait_sync_file(pass, *render_wait_len_ptr, sync_file_fds[i]); - if (sem == VK_NULL_HANDLE) { - close(sync_file_fds[i]); - continue; - } - - render_wait[*render_wait_len_ptr] = (VkSemaphoreSubmitInfoKHR){ - .sType = VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO_KHR, - .semaphore = sem, - .stageMask = VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR, - }; - - (*render_wait_len_ptr)++; - } - - return true; -} - static bool unwrap_color_transform(struct wlr_color_transform *transform, float matrix[static 9], enum wlr_color_transfer_function *tf) { if (transform == NULL) { @@ -342,7 +308,7 @@ static bool render_pass_submit(struct wlr_render_pass *wlr_pass) { vkCmdEndRenderPass(render_cb->vk); size_t pass_textures_len = pass->textures.size / sizeof(struct wlr_vk_render_pass_texture); - size_t render_wait_cap = (1 + pass_textures_len) * WLR_DMABUF_MAX_PLANES; + size_t render_wait_cap = pass_textures_len * WLR_DMABUF_MAX_PLANES; render_wait = calloc(render_wait_cap, sizeof(*render_wait)); if (render_wait == NULL) { wlr_log_errno(WLR_ERROR, "Allocation failed"); @@ -420,7 +386,7 @@ static bool render_pass_submit(struct wlr_render_pass *wlr_pass) { sync_file_fds[0] = sync_file_fd; } else { struct wlr_vk_texture *texture = pass_texture->texture; - if (!vulkan_sync_foreign_texture_acquire(texture, sync_file_fds)) { + if (!vulkan_sync_foreign_texture(texture, sync_file_fds)) { wlr_log(WLR_ERROR, "Failed to wait for foreign texture DMA-BUF fence"); continue; } @@ -447,10 +413,6 @@ static bool render_pass_submit(struct wlr_render_pass *wlr_pass) { } } - if (!render_pass_wait_render_buffer(pass, render_wait, &render_wait_len)) { - wlr_log(WLR_ERROR, "Failed to wait for render buffer DMA-BUF fence"); - } - // also add acquire/release barriers for the current render buffer VkImageLayout src_layout = VK_IMAGE_LAYOUT_GENERAL; if (!pass->render_buffer_out->transitioned) { @@ -644,7 +606,8 @@ static bool render_pass_submit(struct wlr_render_pass *wlr_pass) { wl_list_insert(&stage_cb->stage_buffers, &stage_buf->link); } - if (!vulkan_sync_render_pass_release(renderer, pass)) { + if (!vulkan_sync_render_buffer(renderer, render_buffer, render_cb, + pass->signal_timeline, pass->signal_point)) { wlr_log(WLR_ERROR, "Failed to sync render buffer"); } @@ -859,13 +822,12 @@ static void render_pass_add_texture(struct wlr_render_pass *wlr_pass, } enum wlr_color_encoding color_encoding = options->color_encoding; - bool is_ycbcr = vulkan_format_is_ycbcr(texture->format); - if (is_ycbcr && color_encoding == WLR_COLOR_ENCODING_NONE) { + if (texture->format->is_ycbcr && color_encoding == WLR_COLOR_ENCODING_NONE) { color_encoding = WLR_COLOR_ENCODING_BT601; } enum wlr_color_range color_range = options->color_range; - if (is_ycbcr && color_range == WLR_COLOR_RANGE_NONE) { + if (texture->format->is_ycbcr && color_range == WLR_COLOR_RANGE_NONE) { color_range = WLR_COLOR_RANGE_LIMITED; } @@ -875,7 +837,7 @@ static void render_pass_add_texture(struct wlr_render_pass *wlr_pass, .source = WLR_VK_SHADER_SOURCE_TEXTURE, .layout = { .ycbcr = { - .format = is_ycbcr ? texture->format : NULL, + .format = texture->format->is_ycbcr ? texture->format : NULL, .encoding = color_encoding, .range = color_range, }, diff --git a/render/vulkan/pixel_format.c b/render/vulkan/pixel_format.c index 9b17d079a..902feac9a 100644 --- a/render/vulkan/pixel_format.c +++ b/render/vulkan/pixel_format.c @@ -182,30 +182,37 @@ static const struct wlr_vk_format formats[] = { { .drm = DRM_FORMAT_UYVY, .vk = VK_FORMAT_B8G8R8G8_422_UNORM, + .is_ycbcr = true, }, { .drm = DRM_FORMAT_YUYV, .vk = VK_FORMAT_G8B8G8R8_422_UNORM, + .is_ycbcr = true, }, { .drm = DRM_FORMAT_NV12, .vk = VK_FORMAT_G8_B8R8_2PLANE_420_UNORM, + .is_ycbcr = true, }, { .drm = DRM_FORMAT_NV16, .vk = VK_FORMAT_G8_B8R8_2PLANE_422_UNORM, + .is_ycbcr = true, }, { .drm = DRM_FORMAT_YUV420, .vk = VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM, + .is_ycbcr = true, }, { .drm = DRM_FORMAT_YUV422, .vk = VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM, + .is_ycbcr = true, }, { .drm = DRM_FORMAT_YUV444, .vk = VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM, + .is_ycbcr = true, }, // 3PACK16 formats split the memory in three 16-bit words, so they have an // inverted channel order compared to DRM formats. @@ -213,22 +220,27 @@ static const struct wlr_vk_format formats[] = { { .drm = DRM_FORMAT_P010, .vk = VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16, + .is_ycbcr = true, }, { .drm = DRM_FORMAT_P210, .vk = VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16, + .is_ycbcr = true, }, { .drm = DRM_FORMAT_P012, .vk = VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16, + .is_ycbcr = true, }, { .drm = DRM_FORMAT_P016, .vk = VK_FORMAT_G16_B16R16_2PLANE_420_UNORM, + .is_ycbcr = true, }, { .drm = DRM_FORMAT_Q410, .vk = VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16, + .is_ycbcr = true, }, #endif // TODO: add DRM_FORMAT_NV24/VK_FORMAT_G8_B8R8_2PLANE_444_UNORM (requires @@ -434,7 +446,7 @@ static bool query_modifier_support(struct wlr_vk_device *dev, // check that specific modifier for render usage const char *errmsg = "unknown error"; if ((m.drmFormatModifierTilingFeatures & render_features) == render_features && - !vulkan_format_is_ycbcr(&props->format)) { + !props->format.is_ycbcr) { struct wlr_vk_format_modifier_props p = {0}; bool supported = false; if (query_modifier_usage_support(dev, props->format.vk, @@ -465,7 +477,7 @@ static bool query_modifier_support(struct wlr_vk_device *dev, // check that specific modifier for texture usage errmsg = "unknown error"; VkFormatFeatureFlags features = dma_tex_features; - if (vulkan_format_is_ycbcr(&props->format)) { + if (props->format.is_ycbcr) { features |= ycbcr_tex_features; } if ((m.drmFormatModifierTilingFeatures & features) == features) { @@ -510,7 +522,7 @@ static bool query_modifier_support(struct wlr_vk_device *dev, void vulkan_format_props_query(struct wlr_vk_device *dev, const struct wlr_vk_format *format) { - if (vulkan_format_is_ycbcr(format) && !dev->sampler_ycbcr_conversion) { + if (format->is_ycbcr && !dev->sampler_ycbcr_conversion) { return; } @@ -539,7 +551,7 @@ void vulkan_format_props_query(struct wlr_vk_device *dev, char shm_texture_status[256]; const char *errmsg = "unknown error"; if ((fmtp.formatProperties.optimalTilingFeatures & shm_tex_features) == shm_tex_features && - !vulkan_format_is_ycbcr(format) && format_info != NULL) { + !format->is_ycbcr && format_info != NULL) { VkImageFormatProperties ifmtp; bool supported = false, has_mutable_srgb = false; if (query_shm_support(dev, format->vk, format->vk_srgb, &ifmtp, &errmsg)) { @@ -609,7 +621,3 @@ const struct wlr_vk_format_modifier_props *vulkan_format_props_find_modifier( } return NULL; } - -bool vulkan_format_is_ycbcr(const struct wlr_vk_format *format) { - return pixel_format_is_ycbcr(format->drm); -} diff --git a/render/vulkan/renderer.c b/render/vulkan/renderer.c index da17a4703..0b411f5dd 100644 --- a/render/vulkan/renderer.c +++ b/render/vulkan/renderer.c @@ -968,11 +968,13 @@ static struct wlr_vk_render_buffer *get_render_buffer( return buffer; } -static bool buffer_export_sync_file(struct wlr_vk_renderer *renderer, struct wlr_buffer *buffer, - uint32_t flags, int sync_file_fds[static WLR_DMABUF_MAX_PLANES]) { +bool vulkan_sync_foreign_texture(struct wlr_vk_texture *texture, + int sync_file_fds[static WLR_DMABUF_MAX_PLANES]) { + struct wlr_vk_renderer *renderer = texture->renderer; + struct wlr_dmabuf_attributes dmabuf = {0}; - if (!wlr_buffer_get_dmabuf(buffer, &dmabuf)) { - wlr_log(WLR_ERROR, "wlr_buffer_get_dmabuf() failed"); + if (!wlr_buffer_get_dmabuf(texture->buffer, &dmabuf)) { + wlr_log(WLR_ERROR, "Failed to get texture DMA-BUF"); return false; } @@ -982,7 +984,7 @@ static bool buffer_export_sync_file(struct wlr_vk_renderer *renderer, struct wlr for (int i = 0; i < dmabuf.n_planes; i++) { struct pollfd pollfd = { .fd = dmabuf.fd[i], - .events = (flags & DMA_BUF_SYNC_WRITE) ? POLLOUT : POLLIN, + .events = POLLIN, }; int timeout_ms = 1000; int ret = poll(&pollfd, 1, timeout_ms); @@ -999,7 +1001,7 @@ static bool buffer_export_sync_file(struct wlr_vk_renderer *renderer, struct wlr } for (int i = 0; i < dmabuf.n_planes; i++) { - int sync_file_fd = dmabuf_export_sync_file(dmabuf.fd[i], flags); + int sync_file_fd = dmabuf_export_sync_file(dmabuf.fd[i], DMA_BUF_SYNC_READ); if (sync_file_fd < 0) { wlr_log(WLR_ERROR, "Failed to extract DMA-BUF fence"); return false; @@ -1011,40 +1013,12 @@ static bool buffer_export_sync_file(struct wlr_vk_renderer *renderer, struct wlr return true; } -bool vulkan_sync_foreign_texture_acquire(struct wlr_vk_texture *texture, - int sync_file_fds[static WLR_DMABUF_MAX_PLANES]) { - return buffer_export_sync_file(texture->renderer, texture->buffer, DMA_BUF_SYNC_READ, sync_file_fds); -} - -bool vulkan_sync_render_buffer_acquire(struct wlr_vk_render_buffer *render_buffer, - int sync_file_fds[static WLR_DMABUF_MAX_PLANES]) { - return buffer_export_sync_file(render_buffer->renderer, render_buffer->wlr_buffer, - DMA_BUF_SYNC_WRITE, sync_file_fds); -} - -static bool buffer_import_sync_file(struct wlr_buffer *buffer, uint32_t flags, int sync_file_fd) { - struct wlr_dmabuf_attributes dmabuf = {0}; - if (!wlr_buffer_get_dmabuf(buffer, &dmabuf)) { - wlr_log(WLR_ERROR, "wlr_buffer_get_dmabuf() failed"); - return false; - } - - for (int i = 0; i < dmabuf.n_planes; i++) { - if (!dmabuf_import_sync_file(dmabuf.fd[i], flags, - sync_file_fd)) { - return false; - } - } - - return true; -} - -bool vulkan_sync_render_pass_release(struct wlr_vk_renderer *renderer, - struct wlr_vk_render_pass *pass) { +bool vulkan_sync_render_buffer(struct wlr_vk_renderer *renderer, + struct wlr_vk_render_buffer *render_buffer, struct wlr_vk_command_buffer *cb, + struct wlr_drm_syncobj_timeline *signal_timeline, uint64_t signal_point) { VkResult res; - struct wlr_vk_command_buffer *cb = pass->command_buffer; - if (!renderer->dev->implicit_sync_interop && pass->signal_timeline == NULL) { + if (!renderer->dev->implicit_sync_interop && signal_timeline == NULL) { // We have no choice but to block here sadly return vulkan_wait_command_buffer(cb, renderer); } @@ -1066,19 +1040,21 @@ bool vulkan_sync_render_pass_release(struct wlr_vk_renderer *renderer, } bool ok = false; - if (pass->signal_timeline != NULL) { - if (!wlr_drm_syncobj_timeline_import_sync_file(pass->signal_timeline, - pass->signal_point, sync_file_fd)) { + if (signal_timeline != NULL) { + if (!wlr_drm_syncobj_timeline_import_sync_file(signal_timeline, + signal_point, sync_file_fd)) { goto out; } } else { - if (!buffer_import_sync_file(pass->render_buffer->wlr_buffer, DMA_BUF_SYNC_WRITE, sync_file_fd)) { + struct wlr_dmabuf_attributes dmabuf = {0}; + if (!wlr_buffer_get_dmabuf(render_buffer->wlr_buffer, &dmabuf)) { + wlr_log(WLR_ERROR, "wlr_buffer_get_dmabuf failed"); goto out; } - struct wlr_vk_render_pass_texture *pass_texture; - wl_array_for_each(pass_texture, &pass->textures) { - if (!buffer_import_sync_file(pass_texture->texture->buffer, DMA_BUF_SYNC_READ, sync_file_fd)) { + for (int i = 0; i < dmabuf.n_planes; i++) { + if (!dmabuf_import_sync_file(dmabuf.fd[i], DMA_BUF_SYNC_WRITE, + sync_file_fd)) { goto out; } } @@ -1654,8 +1630,8 @@ static bool init_blend_to_output_layouts(struct wlr_vk_renderer *renderer) { static bool pipeline_layout_key_equals( const struct wlr_vk_pipeline_layout_key *a, const struct wlr_vk_pipeline_layout_key *b) { - assert(!a->ycbcr.format || vulkan_format_is_ycbcr(a->ycbcr.format)); - assert(!b->ycbcr.format || vulkan_format_is_ycbcr(b->ycbcr.format)); + assert(!a->ycbcr.format || a->ycbcr.format->is_ycbcr); + assert(!b->ycbcr.format || b->ycbcr.format->is_ycbcr); if (a->filter_mode != b->filter_mode) { return false; @@ -2063,8 +2039,8 @@ struct wlr_vk_pipeline_layout *get_or_create_pipeline_layout( }; sampler_create_info.pNext = &conversion_info; } else { - assert(key->ycbcr.encoding == WLR_COLOR_ENCODING_NONE || key->ycbcr.encoding == WLR_COLOR_ENCODING_IDENTITY); - assert(key->ycbcr.range == WLR_COLOR_RANGE_NONE || key->ycbcr.range == WLR_COLOR_RANGE_FULL); + assert(key->ycbcr.encoding == WLR_COLOR_ENCODING_NONE); + assert(key->ycbcr.range == WLR_COLOR_RANGE_NONE); } res = vkCreateSampler(renderer->dev->dev, &sampler_create_info, NULL, &pipeline_layout->sampler); diff --git a/render/vulkan/shaders/common.vert b/render/vulkan/shaders/common.vert index f1579790d..c6175d248 100644 --- a/render/vulkan/shaders/common.vert +++ b/render/vulkan/shaders/common.vert @@ -1,7 +1,7 @@ #version 450 // we use a mat4 since it uses the same size as mat3 due to -// alignment. Easier to deal with (tightly-packed) mat4 though. +// alignment. Easier to deal with (tighly-packed) mat4 though. layout(push_constant, row_major) uniform UBO { mat4 proj; vec2 uv_offset; diff --git a/render/vulkan/texture.c b/render/vulkan/texture.c index 57db97a56..499178f5d 100644 --- a/render/vulkan/texture.c +++ b/render/vulkan/texture.c @@ -189,7 +189,7 @@ void vulkan_texture_destroy(struct wlr_vk_texture *texture) { // when we recorded a command to fill this image _this_ frame, // it has to be executed before the texture can be destroyed. // Add it to the renderer->destroy_textures list, destroying - // _after_ the stage command buffer has executed + // _after_ the stage command buffer has exectued if (texture->last_used_cb != NULL) { assert(texture->destroy_link.next == NULL); // not already inserted wl_list_insert(&texture->last_used_cb->destroy_textures, @@ -297,7 +297,7 @@ struct wlr_vk_texture_view *vulkan_texture_get_or_create_view(struct wlr_vk_text .components.r = VK_COMPONENT_SWIZZLE_IDENTITY, .components.g = VK_COMPONENT_SWIZZLE_IDENTITY, .components.b = VK_COMPONENT_SWIZZLE_IDENTITY, - .components.a = texture->has_alpha || vulkan_format_is_ycbcr(texture->format) + .components.a = texture->has_alpha || texture->format->is_ycbcr ? VK_COMPONENT_SWIZZLE_IDENTITY : VK_COMPONENT_SWIZZLE_ONE, .subresourceRange = (VkImageSubresourceRange){ @@ -311,7 +311,7 @@ struct wlr_vk_texture_view *vulkan_texture_get_or_create_view(struct wlr_vk_text }; VkSamplerYcbcrConversionInfo ycbcr_conversion_info; - if (vulkan_format_is_ycbcr(texture->format)) { + if (texture->format->is_ycbcr) { assert(pipeline_layout->ycbcr.conversion != VK_NULL_HANDLE); ycbcr_conversion_info = (VkSamplerYcbcrConversionInfo){ .sType = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO, @@ -355,7 +355,7 @@ struct wlr_vk_texture_view *vulkan_texture_get_or_create_view(struct wlr_vk_text static void texture_set_format(struct wlr_vk_texture *texture, const struct wlr_vk_format *format, bool has_mutable_srgb) { - assert(!(vulkan_format_is_ycbcr(format) && has_mutable_srgb)); + assert(!(format->is_ycbcr && has_mutable_srgb)); texture->format = format; texture->using_mutable_srgb = has_mutable_srgb; @@ -366,7 +366,7 @@ static void texture_set_format(struct wlr_vk_texture *texture, texture->has_alpha = pixel_format_has_alpha(format->drm); } else { // We don't have format info for multi-planar formats - assert(vulkan_format_is_ycbcr(texture->format)); + assert(texture->format->is_ycbcr); } } @@ -378,7 +378,7 @@ static struct wlr_texture *vulkan_texture_from_pixels( const struct wlr_vk_format_props *fmt = vulkan_format_props_from_drm(renderer->dev, drm_fmt); - if (fmt == NULL || vulkan_format_is_ycbcr(&fmt->format)) { + if (fmt == NULL || fmt->format.is_ycbcr) { char *format_name = drmGetFormatName(drm_fmt); wlr_log(WLR_ERROR, "Unsupported pixel format %s (0x%08"PRIX32")", format_name, drm_fmt); diff --git a/render/vulkan/vulkan.c b/render/vulkan/vulkan.c index ee7adc011..78bc25941 100644 --- a/render/vulkan/vulkan.c +++ b/render/vulkan/vulkan.c @@ -290,7 +290,7 @@ VkPhysicalDevice vulkan_find_drm_phdev(struct wlr_vk_instance *ini, int drm_fd) log_phdev(&phdev_props); if (phdev_props.apiVersion < VK_API_VERSION_1_1) { - // NOTE: we could additionally check whether the + // NOTE: we could additionaly check whether the // VkPhysicalDeviceProperties2KHR extension is supported but // implementations not supporting 1.1 are unlikely in future continue; diff --git a/tinywl/tinywl.c b/tinywl/tinywl.c index fe242e1a9..b3d902c7e 100644 --- a/tinywl/tinywl.c +++ b/tinywl/tinywl.c @@ -614,7 +614,7 @@ static void server_new_output(struct wl_listener *listener, void *data) { struct wlr_output *wlr_output = data; /* Configures the output created by the backend to use our allocator - * and our renderer. Must be done once, before committing the output */ + * and our renderer. Must be done once, before commiting the output */ wlr_output_init_render(wlr_output, server->allocator, server->renderer); /* The output may be disabled, switch it on. */ @@ -723,7 +723,7 @@ static void xdg_toplevel_destroy(struct wl_listener *listener, void *data) { static void begin_interactive(struct tinywl_toplevel *toplevel, enum tinywl_cursor_mode mode, uint32_t edges) { /* This function sets up an interactive move or resize operation, where the - * compositor stops propagating pointer events to clients and instead + * compositor stops propegating pointer events to clients and instead * consumes them itself, to move or resize windows. */ struct tinywl_server *server = toplevel->server; @@ -906,7 +906,7 @@ int main(int argc, char *argv[]) { struct tinywl_server server = {0}; /* The Wayland display is managed by libwayland. It handles accepting - * clients from the Unix socket, managing Wayland globals, and so on. */ + * clients from the Unix socket, manging Wayland globals, and so on. */ server.wl_display = wl_display_create(); /* The backend is a wlroots feature which abstracts the underlying input and * output hardware. The autocreate option will choose the most suitable diff --git a/types/buffer/buffer.c b/types/buffer/buffer.c index 48a10d9f0..d56255b0d 100644 --- a/types/buffer/buffer.c +++ b/types/buffer/buffer.c @@ -109,11 +109,14 @@ bool wlr_buffer_get_shm(struct wlr_buffer *buffer, bool wlr_buffer_is_opaque(struct wlr_buffer *buffer) { void *data; - uint32_t format = buffer_get_drm_format(buffer); + uint32_t format; size_t stride; - - if (format != DRM_FORMAT_INVALID) { - // pass + struct wlr_dmabuf_attributes dmabuf; + struct wlr_shm_attributes shm; + if (wlr_buffer_get_dmabuf(buffer, &dmabuf)) { + format = dmabuf.format; + } else if (wlr_buffer_get_shm(buffer, &shm)) { + format = shm.format; } else if (wlr_buffer_begin_data_ptr_access(buffer, WLR_BUFFER_DATA_PTR_ACCESS_READ, &data, &format, &stride)) { bool opaque = false; @@ -132,15 +135,3 @@ bool wlr_buffer_is_opaque(struct wlr_buffer *buffer) { return !pixel_format_has_alpha(format); } - -uint32_t buffer_get_drm_format(struct wlr_buffer *buffer) { - uint32_t format = DRM_FORMAT_INVALID; - struct wlr_dmabuf_attributes dmabuf; - struct wlr_shm_attributes shm; - if (wlr_buffer_get_dmabuf(buffer, &dmabuf)) { - format = dmabuf.format; - } else if (wlr_buffer_get_shm(buffer, &shm)) { - format = shm.format; - } - return format; -} diff --git a/types/ext_image_capture_source_v1/scene.c b/types/ext_image_capture_source_v1/scene.c index 99d34e012..d3bf86b6c 100644 --- a/types/ext_image_capture_source_v1/scene.c +++ b/types/ext_image_capture_source_v1/scene.c @@ -173,6 +173,8 @@ static void source_update_buffer_constraints(struct scene_node_source *source, } static bool output_test(struct wlr_output *output, const struct wlr_output_state *state) { + struct scene_node_source *source = wl_container_of(output, source, output); + uint32_t supported = WLR_OUTPUT_STATE_BACKEND_OPTIONAL | WLR_OUTPUT_STATE_BUFFER | diff --git a/types/output/cursor.c b/types/output/cursor.c index 5e93b0b2e..11f442cdf 100644 --- a/types/output/cursor.c +++ b/types/output/cursor.c @@ -535,4 +535,4 @@ bool output_cursor_refresh_color_transform(struct wlr_output_cursor *output_curs wlr_color_transform_unref(transforms[0]); wlr_color_transform_unref(transforms[1]); return output_cursor->color_transform != NULL; -} +} \ No newline at end of file diff --git a/types/scene/layer_shell_v1.c b/types/scene/layer_shell_v1.c index 234227df1..4ae736ddf 100644 --- a/types/scene/layer_shell_v1.c +++ b/types/scene/layer_shell_v1.c @@ -1,7 +1,6 @@ #include #include #include -#include static void scene_layer_surface_handle_tree_destroy( struct wl_listener *listener, void *data) { @@ -22,23 +21,36 @@ static void scene_layer_surface_handle_layer_surface_destroy( static void layer_surface_exclusive_zone( struct wlr_layer_surface_v1_state *state, - enum wlr_edges edge, struct wlr_box *usable_area) { - switch (edge) { - case WLR_EDGE_NONE: - return; - case WLR_EDGE_TOP: + switch (state->anchor) { + case ZWLR_LAYER_SURFACE_V1_ANCHOR_TOP: + case (ZWLR_LAYER_SURFACE_V1_ANCHOR_TOP | + ZWLR_LAYER_SURFACE_V1_ANCHOR_LEFT | + ZWLR_LAYER_SURFACE_V1_ANCHOR_RIGHT): + // Anchor top usable_area->y += state->exclusive_zone + state->margin.top; usable_area->height -= state->exclusive_zone + state->margin.top; break; - case WLR_EDGE_BOTTOM: + case ZWLR_LAYER_SURFACE_V1_ANCHOR_BOTTOM: + case (ZWLR_LAYER_SURFACE_V1_ANCHOR_BOTTOM | + ZWLR_LAYER_SURFACE_V1_ANCHOR_LEFT | + ZWLR_LAYER_SURFACE_V1_ANCHOR_RIGHT): + // Anchor bottom usable_area->height -= state->exclusive_zone + state->margin.bottom; break; - case WLR_EDGE_LEFT: + case ZWLR_LAYER_SURFACE_V1_ANCHOR_LEFT: + case (ZWLR_LAYER_SURFACE_V1_ANCHOR_TOP | + ZWLR_LAYER_SURFACE_V1_ANCHOR_BOTTOM | + ZWLR_LAYER_SURFACE_V1_ANCHOR_LEFT): + // Anchor left usable_area->x += state->exclusive_zone + state->margin.left; usable_area->width -= state->exclusive_zone + state->margin.left; break; - case WLR_EDGE_RIGHT: + case ZWLR_LAYER_SURFACE_V1_ANCHOR_RIGHT: + case (ZWLR_LAYER_SURFACE_V1_ANCHOR_TOP | + ZWLR_LAYER_SURFACE_V1_ANCHOR_BOTTOM | + ZWLR_LAYER_SURFACE_V1_ANCHOR_RIGHT): + // Anchor right usable_area->width -= state->exclusive_zone + state->margin.right; break; } @@ -109,8 +121,7 @@ void wlr_scene_layer_surface_v1_configure( wlr_layer_surface_v1_configure(layer_surface, box.width, box.height); if (layer_surface->surface->mapped && state->exclusive_zone > 0) { - enum wlr_edges edge = wlr_layer_surface_v1_get_exclusive_edge(layer_surface); - layer_surface_exclusive_zone(state, edge, usable_area); + layer_surface_exclusive_zone(state, usable_area); } } diff --git a/types/scene/wlr_scene.c b/types/scene/wlr_scene.c index 51373e15a..19617b11f 100644 --- a/types/scene/wlr_scene.c +++ b/types/scene/wlr_scene.c @@ -2086,12 +2086,8 @@ static enum scene_direct_scanout_result scene_entry_try_direct_scanout( return SCANOUT_INELIGIBLE; } - bool is_color_repr_none = buffer->color_encoding == WLR_COLOR_ENCODING_NONE && - buffer->color_range == WLR_COLOR_RANGE_NONE; - bool is_color_repr_identity_full = buffer->color_encoding == WLR_COLOR_ENCODING_IDENTITY && - buffer->color_range == WLR_COLOR_RANGE_FULL; - - if (!(is_color_repr_none || is_color_repr_identity_full)) { + if (buffer->color_encoding != WLR_COLOR_ENCODING_NONE || + buffer->color_range != WLR_COLOR_RANGE_NONE) { return SCANOUT_INELIGIBLE; } @@ -2391,7 +2387,7 @@ bool wlr_scene_output_build_state(struct wlr_scene_output *scene_output, pixman_region32_init(&acc_damage); struct highlight_region *damage, *tmp_damage; wl_list_for_each_safe(damage, tmp_damage, regions, link) { - // remove overlapping damage regions + // remove overlaping damage regions pixman_region32_subtract(&damage->region, &damage->region, &acc_damage); pixman_region32_union(&acc_damage, &acc_damage, &damage->region); diff --git a/types/wlr_color_representation_v1.c b/types/wlr_color_representation_v1.c index 856dc84f8..a447d77a7 100644 --- a/types/wlr_color_representation_v1.c +++ b/types/wlr_color_representation_v1.c @@ -1,17 +1,13 @@ #include -#include #include #include -#include #include #include #include #include #include "color-representation-v1-protocol.h" -#include "render/pixel_format.h" -#include "types/wlr_buffer.h" #include "util/mem.h" #define WP_COLOR_REPRESENTATION_VERSION 1 @@ -234,44 +230,8 @@ static void color_repr_manager_handle_destroy(struct wl_client *client, wl_resource_destroy(resource); } -static void surface_synced_commit(struct wlr_surface_synced *synced) { - struct wlr_color_representation_v1 *color_repr = wl_container_of(synced, color_repr, synced); - - if (color_repr->current.coefficients == 0 && color_repr->current.range == 0) { - return; - } - - uint32_t drm_format = DRM_FORMAT_INVALID; - if (color_repr->surface->buffer){ - drm_format = buffer_get_drm_format(&color_repr->surface->buffer->base); - } - if (drm_format == DRM_FORMAT_INVALID) { - return; - } - bool is_ycbcr = pixel_format_is_ycbcr(drm_format); - - bool is_identity_full = - color_repr->current.coefficients == WP_COLOR_REPRESENTATION_SURFACE_V1_COEFFICIENTS_IDENTITY && - color_repr->current.range == WP_COLOR_REPRESENTATION_SURFACE_V1_RANGE_FULL; - - if (is_ycbcr) { - if (is_identity_full) { - wl_resource_post_error(color_repr->resource, - WP_COLOR_REPRESENTATION_SURFACE_V1_ERROR_PIXEL_FORMAT, - "unexpected encoding/range for yuv"); - } - } else /* rgb */ { - if (!is_identity_full) { - wl_resource_post_error(color_repr->resource, - WP_COLOR_REPRESENTATION_SURFACE_V1_ERROR_PIXEL_FORMAT, - "unexpected encoding/range for rgb"); - } - } -} - static const struct wlr_surface_synced_impl surface_synced_impl = { .state_size = sizeof(struct wlr_color_representation_v1_surface_state), - .commit = surface_synced_commit }; static struct wlr_color_representation_v1 *color_repr_from_surface( @@ -316,7 +276,6 @@ static void color_repr_manager_handle_get_surface(struct wl_client *client, } color_repr->manager = manager_from_resource(manager_resource); - color_repr->surface = surface; if (!wlr_surface_synced_init(&color_repr->synced, surface, &surface_synced_impl, &color_repr->pending, &color_repr->current)) { @@ -468,10 +427,6 @@ struct wlr_color_representation_manager_v1 *wlr_color_representation_manager_v1_ struct wlr_color_representation_v1_coeffs_and_range coeffs_and_ranges[COEFFICIENTS_LEN * RANGES_LEN]; size_t coeffs_and_ranges_len = 0; - coeffs_and_ranges[coeffs_and_ranges_len++] = (struct wlr_color_representation_v1_coeffs_and_range){ - .coeffs = WP_COLOR_REPRESENTATION_SURFACE_V1_COEFFICIENTS_IDENTITY, - .range = WP_COLOR_REPRESENTATION_SURFACE_V1_RANGE_FULL, - }; for (size_t i = 0; i < COEFFICIENTS_LEN; i++) { enum wp_color_representation_surface_v1_coefficients coeffs = coefficients[i]; enum wlr_color_encoding enc = wlr_color_representation_v1_color_encoding_to_wlr(coeffs); diff --git a/types/wlr_cursor.c b/types/wlr_cursor.c index 8d0d77475..f2269db0f 100644 --- a/types/wlr_cursor.c +++ b/types/wlr_cursor.c @@ -956,7 +956,7 @@ static void handle_tablet_tool_axis(struct wl_listener *listener, void *data) { static void handle_tablet_tool_button(struct wl_listener *listener, void *data) { - struct wlr_tablet_tool_button_event *event = data; + struct wlr_tablet_tool_button *event = data; struct wlr_cursor_device *device; device = wl_container_of(listener, device, tablet_tool_button); wl_signal_emit_mutable(&device->cursor->events.tablet_tool_button, event); diff --git a/types/wlr_keyboard_group.c b/types/wlr_keyboard_group.c index 6005ba647..0ff6d93bb 100644 --- a/types/wlr_keyboard_group.c +++ b/types/wlr_keyboard_group.c @@ -308,7 +308,7 @@ void wlr_keyboard_group_remove_keyboard(struct wlr_keyboard_group *group, void wlr_keyboard_group_destroy(struct wlr_keyboard_group *group) { struct keyboard_group_device *device, *tmp_device; wl_list_for_each_safe(device, tmp_device, &group->devices, link) { - remove_keyboard_group_device(device); + wlr_keyboard_group_remove_keyboard(group, device->keyboard); } // Now group->keys might not be empty if a wlr_keyboard has emitted diff --git a/util/array.c b/util/array.c index d4771e817..ec16a7b13 100644 --- a/util/array.c +++ b/util/array.c @@ -14,7 +14,7 @@ bool array_realloc(struct wl_array *arr, size_t size) { // If the size is less than 1/4th of the allocation size, we shrink it. // 1/4th is picked to provide hysteresis, without which an array with size // arr->alloc would constantly reallocate if an element is added and then - // removed continuously. + // removed continously. size_t alloc; if (arr->alloc > 0 && size > arr->alloc / 4) { alloc = arr->alloc; diff --git a/xwayland/selection/incoming.c b/xwayland/selection/incoming.c index 85d7775cd..72f82c279 100644 --- a/xwayland/selection/incoming.c +++ b/xwayland/selection/incoming.c @@ -381,15 +381,13 @@ static bool source_get_targets(struct wlr_xwm_selection *selection, free(mime_type); break; } + *mime_type_ptr = mime_type; xcb_atom_t *atom_ptr = wl_array_add(mime_types_atoms, sizeof(*atom_ptr)); if (atom_ptr == NULL) { - mime_types->size -= sizeof(*mime_type_ptr); - free(mime_type); break; } - *mime_type_ptr = mime_type; *atom_ptr = value[i]; } } diff --git a/xwayland/xwm.c b/xwayland/xwm.c index e44a11743..c8eac2ce1 100644 --- a/xwayland/xwm.c +++ b/xwayland/xwm.c @@ -1,6 +1,5 @@ #include #include -#include #include #include #include @@ -2882,20 +2881,5 @@ xcb_connection_t *wlr_xwayland_get_xwm_connection( } void xwm_schedule_flush(struct wlr_xwm *xwm) { - struct pollfd pollfd = { - .fd = xcb_get_file_descriptor(xwm->xcb_conn), - .events = POLLOUT, - }; - if (poll(&pollfd, 1, 0) < 0) { - wlr_log(WLR_ERROR, "poll() failed"); - return; - } - - // If we can write immediately, do so - if (pollfd.revents & POLLOUT) { - xcb_flush(xwm->xcb_conn); - return; - } - wl_event_source_fd_update(xwm->event_source, WL_EVENT_READABLE | WL_EVENT_WRITABLE); }