1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
|
#include <stdlib.h>
#include <stdint.h>
#include <assert.h>
#include <EGL/egl.h>
#include <EGL/eglext.h>
#include <wayland-server.h>
#include <wlr/backend/interface.h>
#include <wlr/interfaces/wlr_output.h>
#include <wlr/interfaces/wlr_input_device.h>
#include <wlr/util/log.h>
#include "backend/wayland.h"
static int dispatch_events(int fd, uint32_t mask, void *data) {
struct wlr_backend_state *state = data;
int count = 0;
if (mask & WL_EVENT_READABLE) {
count = wl_display_dispatch(state->remote_display);
}
if (mask & WL_EVENT_WRITABLE) {
count = wl_display_flush(state->remote_display);
}
if (mask == 0) {
count = wl_display_dispatch_pending(state->remote_display);
wl_display_flush(state->remote_display);
}
return count;
}
/*
* Initializes the wayland backend. Opens a connection to a remote wayland
* compositor and creates surfaces for each output, then registers globals on
* the specified display.
*/
static bool wlr_wl_backend_init(struct wlr_backend_state* state) {
wlr_log(L_INFO, "Initializating wayland backend");
state->remote_display = wl_display_connect(NULL);
if (!state->remote_display) {
wlr_log_errno(L_ERROR, "Could not connect to remote display");
return false;
}
if (!(state->registry = wl_display_get_registry(state->remote_display))) {
wlr_log_errno(L_ERROR, "Could not obtain reference to remote registry");
return false;
}
wlr_wl_registry_poll(state);
if (!(state->compositor) || (!(state->shell))) {
wlr_log_errno(L_ERROR, "Could not obtain retrieve required globals");
return false;
}
wlr_egl_init(&state->egl, EGL_PLATFORM_WAYLAND_EXT, state->remote_display);
for (size_t i = 0; i < state->requested_outputs; ++i) {
wlr_wl_output_create(state->backend);
}
struct wl_event_loop *loop = wl_display_get_event_loop(state->local_display);
int fd = wl_display_get_fd(state->remote_display);
int events = WL_EVENT_READABLE | WL_EVENT_ERROR |
WL_EVENT_HANGUP | WL_EVENT_WRITABLE;
state->remote_display_src = wl_event_loop_add_fd(loop, fd, events,
dispatch_events, state);
wl_event_source_check(state->remote_display_src);
return true;
}
static void wlr_wl_backend_destroy(struct wlr_backend_state *state) {
if (!state) {
return;
}
for (size_t i = 0; i < state->outputs->length; ++i) {
wlr_output_destroy(state->outputs->items[i]);
}
for (size_t i = 0; state->devices && i < state->devices->length; ++i) {
wlr_input_device_destroy(state->devices->items[i]);
}
list_free(state->devices);
wlr_egl_free(&state->egl);
free(state->outputs);
if (state->seat) wl_seat_destroy(state->seat);
if (state->shm) wl_shm_destroy(state->shm);
if (state->shell) wl_shell_destroy(state->shell);
if (state->compositor) wl_compositor_destroy(state->compositor);
if (state->registry) wl_registry_destroy(state->registry);
if (state->remote_display) wl_display_disconnect(state->remote_display);
free(state);
}
static struct wlr_backend_impl backend_impl = {
.init = wlr_wl_backend_init,
.destroy = wlr_wl_backend_destroy
};
bool wlr_backend_is_wl(struct wlr_backend *b) {
return b->impl == &backend_impl;
}
struct wlr_backend *wlr_wl_backend_create(struct wl_display *display) {
wlr_log(L_INFO, "Creating wayland backend");
struct wlr_backend_state *state = calloc(1, sizeof(struct wlr_backend_state));
if (!state) {
wlr_log(L_ERROR, "Allocation failed: %s", strerror(errno));
return NULL;
}
struct wlr_backend *backend = wlr_backend_create(&backend_impl, state);
if (!backend) {
wlr_log(L_ERROR, "Allocation failed: %s", strerror(errno));
return NULL;
}
if (!(state->devices = list_create())) {
wlr_log(L_ERROR, "Could not allocate devices list");
goto error;
}
if (!(state->outputs = list_create())) {
wlr_log(L_ERROR, "Could not allocate outputs list");
goto error;
}
state->local_display = display;
state->backend = backend;
return backend;
error:
if (state) {
free(state->outputs);
free(state->devices);
free(state->devices);
}
free(state);
free(backend);
return NULL;
}
|
