hyprwm
/
wlroots-hyprland
mirror of https://github.com/hyprwm/wlroots-hyprland.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'master' into session

This commit is contained in:
ascent12 2017-06-01 23:10:19 +12:00 committed by GitHub
parent f9d363fece ae77004346
commit 62d612a01e
14 changed files with 133 additions and 90 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
CMakeLists.txt
View File

@ -60,7 +60,7 @@ include_directories(include)
add_subdirectory(backend) add_subdirectory(backend)
add_subdirectory(common) add_subdirectory(common)
add_subdirectory(wayland) add_subdirectory(types)
add_subdirectory(session) add_subdirectory(session)
add_subdirectory(example) add_subdirectory(example)

2
backend/CMakeLists.txt
View File

@ -18,7 +18,7 @@ add_library(wlr-backend
target_link_libraries(wlr-backend target_link_libraries(wlr-backend
wlr-common wlr-common
wlr-wayland wlr-types
${WAYLAND_LIBRARIES} ${WAYLAND_LIBRARIES}
${DRM_LIBRARIES} ${DRM_LIBRARIES}
${GBM_LIBRARIES} ${GBM_LIBRARIES}

11
backend/backend.c
View File

@ -2,7 +2,9 @@
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
#include <errno.h> #include <errno.h>
#include <wlr/session.h>
#include "common/log.h" #include "common/log.h"
#include "backend/drm/backend.h"
#include "backend.h" #include "backend.h"
struct wlr_backend *wlr_backend_create(const struct wlr_backend_impl *impl, struct wlr_backend *wlr_backend_create(const struct wlr_backend_impl *impl,
@ -31,6 +33,13 @@ bool wlr_backend_init(struct wlr_backend *backend) {
void wlr_backend_destroy(struct wlr_backend *backend) { void wlr_backend_destroy(struct wlr_backend *backend) {
backend->impl->destroy(backend->state); backend->impl->destroy(backend->state);
// TODO: free outputs
free(backend); free(backend);
} }
struct wlr_backend *wlr_backend_autocreate(struct wl_display *display,
struct wlr_session *session) {
// TODO: Choose the most appropriate backend for the situation
struct wlr_backend *wlr;
wlr = wlr_drm_backend_create(display, session);
return wlr;
}

14
backend/drm/backend.c
View File

@ -7,6 +7,7 @@
#include <sys/stat.h> #include <sys/stat.h>
#include <wlr/session.h> #include <wlr/session.h>
#include <wlr/types.h>
#include <wlr/common/list.h> #include <wlr/common/list.h>
#include "backend.h" #include "backend.h"
@ -24,7 +25,10 @@ static void wlr_drm_backend_destroy(struct wlr_backend_state *state) {
if (!state) { if (!state) {
return; return;
} }
// TODO: free outputs in shared backend code for (size_t i = 0; state->outputs && i < state->outputs->length; ++i) {
struct wlr_output_state *output = state->outputs->items[i];
wlr_output_destroy(output->wlr_output);
}
wlr_drm_renderer_free(&state->renderer); wlr_drm_renderer_free(&state->renderer);
wlr_udev_free(&state->udev); wlr_udev_free(&state->udev);
wlr_session_close_file(state->session, state->fd); wlr_session_close_file(state->session, state->fd);
@ -150,11 +154,3 @@ error_backend:
free(backend); free(backend);
return NULL; return NULL;
} }
void wlr_drm_backend_dpms(struct wlr_backend *backend, bool screen_on) {
struct wlr_backend_state *state = backend->state;
for (size_t i = 0; i < state->outputs->length; ++i) {
struct wlr_output_state *output = state->outputs->items[i];
wlr_drm_output_dpms(state->fd, output, screen_on);
}
}

83
backend/drm/drm.c
View File

@ -13,7 +13,7 @@
#include <GLES3/gl3.h> #include <GLES3/gl3.h>
#include <wayland-server.h> #include <wayland-server.h>
#include "wayland.h" #include "types.h"
#include "backend.h" #include "backend.h"
#include "backend/drm/backend.h" #include "backend/drm/backend.h"
#include "backend/drm/drm.h" #include "backend/drm/drm.h"
@ -94,23 +94,26 @@ static uint32_t get_fb_for_bo(int fd, struct gbm_bo *bo) {
return *id; return *id;
} }
void wlr_drm_output_begin(struct wlr_output *output) { static void wlr_drm_output_begin(struct wlr_output_state *output) {
struct wlr_output_state *_output = output->state; struct wlr_drm_renderer *renderer = output->renderer;
struct wlr_drm_renderer *renderer = _output->renderer; eglMakeCurrent(renderer->egl.display, output->egl,
eglMakeCurrent(renderer->egl.display, _output->egl, output->egl, renderer->egl.context);
_output->egl, renderer->egl.context);
} }
void wlr_drm_output_end(struct wlr_output *output) { static void wlr_drm_output_end(struct wlr_output_state *output) {
struct wlr_output_state *_output = output->state; struct wlr_drm_renderer *renderer = output->renderer;
struct wlr_drm_renderer *renderer = _output->renderer;
eglSwapBuffers(renderer->egl.display, _output->egl); if (!eglSwapBuffers(renderer->egl.display, output->egl)) {
struct gbm_bo *bo = gbm_surface_lock_front_buffer(_output->gbm); return;
}
struct gbm_bo *bo = gbm_surface_lock_front_buffer(output->gbm);
if (!bo) {
return;
}
uint32_t fb_id = get_fb_for_bo(renderer->fd, bo); uint32_t fb_id = get_fb_for_bo(renderer->fd, bo);
drmModePageFlip(renderer->fd, _output->crtc, fb_id, DRM_MODE_PAGE_FLIP_EVENT, _output); drmModePageFlip(renderer->fd, output->crtc, fb_id, DRM_MODE_PAGE_FLIP_EVENT, output);
gbm_surface_release_buffer(_output->gbm, bo); gbm_surface_release_buffer(output->gbm, bo);
_output->pageflip_pending = true; output->pageflip_pending = true;
} }
void wlr_drm_output_start_renderer(struct wlr_output_state *output) { void wlr_drm_output_start_renderer(struct wlr_output_state *output) {
@ -249,6 +252,28 @@ error:
return false; return false;
} }
static void wlr_drm_output_enable(struct wlr_output_state *output, bool enable) {
struct wlr_backend_state *state =
wl_container_of(output->renderer, state, renderer);
if (output->state != DRM_OUTPUT_CONNECTED) {
return;
}
if (enable) {
drmModeConnectorSetProperty(state->fd, output->connector, output->props.dpms,
DRM_MODE_DPMS_ON);
// Start rendering loop again by drawing a black frame
wlr_drm_output_begin(output);
glClearColor(0.0, 0.0, 0.0, 1.0);
glClear(GL_COLOR_BUFFER_BIT);
wlr_drm_output_end(output);
} else {
drmModeConnectorSetProperty(state->fd, output->connector, output->props.dpms,
DRM_MODE_DPMS_STANDBY);
}
}
static void wlr_drm_output_destroy(struct wlr_output_state *output) { static void wlr_drm_output_destroy(struct wlr_output_state *output) {
wlr_drm_output_cleanup(output, true); wlr_drm_output_cleanup(output, true);
wlr_drm_renderer_free(output->renderer); wlr_drm_renderer_free(output->renderer);
@ -257,6 +282,7 @@ static void wlr_drm_output_destroy(struct wlr_output_state *output) {
static struct wlr_output_impl output_impl = { static struct wlr_output_impl output_impl = {
.set_mode = wlr_drm_output_set_mode, .set_mode = wlr_drm_output_set_mode,
.enable = wlr_drm_output_enable,
.destroy = wlr_drm_output_destroy, .destroy = wlr_drm_output_destroy,
}; };
@ -389,7 +415,6 @@ void wlr_drm_scan_connectors(struct wlr_backend_state *state) {
conn->connection != DRM_MODE_CONNECTED) { conn->connection != DRM_MODE_CONNECTED) {
wlr_log(L_INFO, "'%s' disconnected", output->name); wlr_log(L_INFO, "'%s' disconnected", output->name);
// TODO: Destroy
wlr_drm_output_cleanup(output, false); wlr_drm_output_cleanup(output, false);
} }
@ -407,7 +432,9 @@ static void page_flip_handler(int fd, unsigned seq,
output->pageflip_pending = false; output->pageflip_pending = false;
if (output->state == DRM_OUTPUT_CONNECTED) { if (output->state == DRM_OUTPUT_CONNECTED) {
wlr_drm_output_begin(output);
wl_signal_emit(&output->wlr_output->events.frame, output->wlr_output); wl_signal_emit(&output->wlr_output->events.frame, output->wlr_output);
wlr_drm_output_end(output);
} }
} }
@ -447,6 +474,11 @@ void wlr_drm_output_cleanup(struct wlr_output_state *output, bool restore) {
switch (output->state) { switch (output->state) {
case DRM_OUTPUT_CONNECTED: case DRM_OUTPUT_CONNECTED:
output->state = DRM_OUTPUT_DISCONNECTED;
if (restore) {
restore_output(output, renderer->fd);
restore = false;
}
eglDestroySurface(renderer->egl.display, output->egl); eglDestroySurface(renderer->egl.display, output->egl);
gbm_surface_destroy(output->gbm); gbm_surface_destroy(output->gbm);
output->egl = EGL_NO_SURFACE; output->egl = EGL_NO_SURFACE;
@ -463,25 +495,4 @@ void wlr_drm_output_cleanup(struct wlr_output_state *output, bool restore) {
case DRM_OUTPUT_DISCONNECTED: case DRM_OUTPUT_DISCONNECTED:
break; break;
} }
// TODO: free wlr_output
}
void wlr_drm_output_dpms(int fd, struct wlr_output_state *output, bool screen_on) {
if (output->state != DRM_OUTPUT_CONNECTED) {
return;
}
if (screen_on) {
drmModeConnectorSetProperty(fd, output->connector, output->props.dpms,
DRM_MODE_DPMS_ON);
// Start rendering loop again by drawing a black frame
wlr_drm_output_begin(output->wlr_output);
glClearColor(0.0, 0.0, 0.0, 1.0);
glClear(GL_COLOR_BUFFER_BIT);
wlr_drm_output_end(output->wlr_output);
} else {
drmModeConnectorSetProperty(fd, output->connector, output->props.dpms,
DRM_MODE_DPMS_STANDBY);
}
} }

11
backend/drm/udev.c
View File

@ -147,12 +147,16 @@ static int udev_event(int fd, uint32_t mask, void *data) {
return 1; return 1;
} }
const char *action = udev_device_get_action(dev);
const char *path = udev_device_get_devnode(dev); const char *path = udev_device_get_devnode(dev);
wlr_log(L_DEBUG, "udev event for %s (%s)",
udev_device_get_sysname(dev), action);
if (!path || strcmp(path, udev->drm_path) != 0) { if (!path || strcmp(path, udev->drm_path) != 0) {
goto out; goto out;
} }
const char *action = udev_device_get_action(dev);
if (!action || strcmp(action, "change") != 0) { if (!action || strcmp(action, "change") != 0) {
goto out; goto out;
} }
@ -189,9 +193,8 @@ bool wlr_udev_init(struct wl_display *display, struct wlr_udev *udev) {
wlr_log(L_ERROR, "Failed to create udev event source"); wlr_log(L_ERROR, "Failed to create udev event source");
goto error_mon; goto error_mon;
} }
udev->drm_path = NULL; wlr_log(L_DEBUG, "Successfully initialized udev");
return true; return true;
error_mon: error_mon:

62
example/main.c
View File

@ -4,8 +4,9 @@
#include <time.h> #include <time.h>
#include <wayland-server.h> #include <wayland-server.h>
#include <GLES3/gl3.h> #include <GLES3/gl3.h>
#include <wlr/backend/drm.h> #include <wlr/backend.h>
#include <wlr/session.h> #include <wlr/session.h>
#include <wlr/types.h>
#include <wlr/common/list.h> #include <wlr/common/list.h>
struct state { struct state {
@ -24,9 +25,7 @@ struct output_state {
}; };
void output_frame(struct wl_listener *listener, void *data) { void output_frame(struct wl_listener *listener, void *data) {
struct wlr_output *output = data; struct output_state *ostate = wl_container_of(listener, ostate, frame);
struct output_state *ostate = wl_container_of(
listener, ostate, frame);
struct state *s = ostate->state; struct state *s = ostate->state;
struct timespec now; struct timespec now;
@ -42,18 +41,13 @@ void output_frame(struct wl_listener *listener, void *data) {
if (s->color[s->dec] < 0.0f) { if (s->color[s->dec] < 0.0f) {
s->color[inc] = 1.0f; s->color[inc] = 1.0f;
s->color[s->dec] = 0.0f; s->color[s->dec] = 0.0f;
s->dec = inc; s->dec = inc;
} }
s->last_frame = now; s->last_frame = now;
wlr_drm_output_begin(output);
glClearColor(s->color[0], s->color[1], s->color[2], 1.0); glClearColor(s->color[0], s->color[1], s->color[2], 1.0);
glClear(GL_COLOR_BUFFER_BIT); glClear(GL_COLOR_BUFFER_BIT);
wlr_drm_output_end(output);
} }
void output_add(struct wl_listener *listener, void *data) { void output_add(struct wl_listener *listener, void *data) {
@ -72,8 +66,21 @@ void output_add(struct wl_listener *listener, void *data) {
void output_remove(struct wl_listener *listener, void *data) { void output_remove(struct wl_listener *listener, void *data) {
struct wlr_output *output = data; struct wlr_output *output = data;
fprintf(stderr, "Output '%s' removed\n", output->name); struct output_state *ostate = NULL;
// TODO: remove signal from state->output_frame struct state *state = wl_container_of(listener, state, output_remove);
size_t i;
for (i = 0; i < state->outputs->length; ++i) {
struct output_state *_ostate = state->outputs->items[i];
if (_ostate->output == output) {
ostate = _ostate;
break;
}
}
if (!ostate) {
return; // We are unfamiliar with this output
}
list_del(state->outputs, i);
wl_list_remove(&ostate->frame.link);
} }
int timer_done(void *data) { int timer_done(void *data) {
@ -81,9 +88,23 @@ int timer_done(void *data) {
return 1; return 1;
} }
int timer_change_vt(void *data) { int enable_outputs(void *data) {
struct wlr_session *session = data; struct state *state = data;
wlr_session_change_vt(session, 7); for (size_t i = 0; i < state->outputs->length; ++i) {
struct output_state *ostate = state->outputs->items[i];
struct wlr_output *output = ostate->output;
wlr_output_enable(output, true);
}
return 1;
}
int disable_outputs(void *data) {
struct state *state = data;
for (size_t i = 0; i < state->outputs->length; ++i) {
struct output_state *ostate = state->outputs->items[i];
struct wlr_output *output = ostate->output;
wlr_output_enable(output, false);
}
return 1; return 1;
} }
@ -116,7 +137,7 @@ int main() {
return 1; return 1;
} }
struct wlr_backend *wlr = wlr_drm_backend_create(display, session); struct wlr_backend *wlr = wlr_backend_autocreate(display, session);
wl_signal_add(&wlr->events.output_add, &state.output_add); wl_signal_add(&wlr->events.output_add, &state.output_add);
wl_signal_add(&wlr->events.output_remove, &state.output_remove); wl_signal_add(&wlr->events.output_remove, &state.output_remove);
if (!wlr || !wlr_backend_init(wlr)) { if (!wlr || !wlr_backend_init(wlr)) {
@ -126,11 +147,14 @@ int main() {
bool done = false; bool done = false;
struct wl_event_source *timer = wl_event_loop_add_timer(event_loop, struct wl_event_source *timer = wl_event_loop_add_timer(event_loop,
timer_done, &done); timer_done, &done);
struct wl_event_source *timer_vt = wl_event_loop_add_timer(event_loop, struct wl_event_source *timer_disable_outputs =
timer_change_vt, session); wl_event_loop_add_timer(event_loop, disable_outputs, &state);
struct wl_event_source *timer_enable_outputs =
wl_event_loop_add_timer(event_loop, enable_outputs, &state);
wl_event_source_timer_update(timer, 15000); wl_event_source_timer_update(timer, 20000);
wl_event_source_timer_update(timer_vt, 5000); wl_event_source_timer_update(timer_disable_outputs, 5000);
wl_event_source_timer_update(timer_enable_outputs, 10000);
while (!done) { while (!done) {
wl_event_loop_dispatch(event_loop, 0); wl_event_loop_dispatch(event_loop, 0);

1
include/backend/drm/drm.h
View File

@ -55,7 +55,6 @@ struct wlr_output_state {
}; };
void wlr_drm_output_cleanup(struct wlr_output_state *output, bool restore); void wlr_drm_output_cleanup(struct wlr_output_state *output, bool restore);
void wlr_drm_output_dpms(int fd, struct wlr_output_state *output, bool screen_on);
void wlr_drm_scan_connectors(struct wlr_backend_state *state); void wlr_drm_scan_connectors(struct wlr_backend_state *state);
int wlr_drm_event(int fd, uint32_t mask, void *data); int wlr_drm_event(int fd, uint32_t mask, void *data);

4
include/wayland.h → include/types.h
View File

@ -2,17 +2,17 @@
#define _WLR_WAYLAND_INTERNAL_H #define _WLR_WAYLAND_INTERNAL_H
#include <wayland-server.h> #include <wayland-server.h>
#include <wlr/wayland.h> #include <wlr/types.h>
#include <stdbool.h> #include <stdbool.h>
struct wlr_output_impl { struct wlr_output_impl {
bool (*set_mode)(struct wlr_output_state *state, struct wlr_output_mode *mode); bool (*set_mode)(struct wlr_output_state *state, struct wlr_output_mode *mode);
void (*enable)(struct wlr_output_state *state, bool enable);
void (*destroy)(struct wlr_output_state *state); void (*destroy)(struct wlr_output_state *state);
}; };
struct wlr_output *wlr_output_create(struct wlr_output_impl *impl, struct wlr_output *wlr_output_create(struct wlr_output_impl *impl,
struct wlr_output_state *state); struct wlr_output_state *state);
void wlr_output_free(struct wlr_output *output); void wlr_output_free(struct wlr_output *output);
#endif #endif

4
include/wlr/backend.h
View File

@ -2,6 +2,7 @@
#define _WLR_BACKEND_H #define _WLR_BACKEND_H
#include <wayland-server.h> #include <wayland-server.h>
#include <wlr/session.h>
struct wlr_backend_impl; struct wlr_backend_impl;
struct wlr_backend_state; struct wlr_backend_state;
@ -22,7 +23,8 @@ struct wlr_backend {
} events; } events;
}; };
struct wlr_backend *wlr_backend_autocreate(); struct wlr_backend *wlr_backend_autocreate(struct wl_display *display,
struct wlr_session *session);
bool wlr_backend_init(struct wlr_backend *backend); bool wlr_backend_init(struct wlr_backend *backend);
void wlr_backend_destroy(struct wlr_backend *backend); void wlr_backend_destroy(struct wlr_backend *backend);

7
include/wlr/backend/drm.h
View File

@ -4,15 +4,8 @@
#include <wayland-server.h> #include <wayland-server.h>
#include <wlr/session.h> #include <wlr/session.h>
#include <wlr/backend.h> #include <wlr/backend.h>
#include <xf86drmMode.h> // drmModeModeInfo
#include <wlr/wayland.h>
struct wlr_backend *wlr_drm_backend_create(struct wl_display *display, struct wlr_backend *wlr_drm_backend_create(struct wl_display *display,
struct wlr_session *session); struct wlr_session *session);
void wlr_drm_backend_dpms(struct wlr_backend *backend, bool screen_on);
void wlr_drm_output_begin(struct wlr_output *out);
void wlr_drm_output_end(struct wlr_output *out);
#endif #endif

2
include/wlr/wayland.h → include/wlr/types.h
View File

@ -40,5 +40,7 @@ struct wlr_output {
}; };
bool wlr_output_set_mode(struct wlr_output *output, struct wlr_output_mode *mode); bool wlr_output_set_mode(struct wlr_output *output, struct wlr_output_mode *mode);
void wlr_output_enable(struct wlr_output *output, bool enable);
void wlr_output_destroy(struct wlr_output *output);
#endif #endif

6
wayland/CMakeLists.txt → types/CMakeLists.txt
View File

@ -3,11 +3,11 @@ include_directories(
${WAYLAND_INCLUDE_DIR} ${WAYLAND_INCLUDE_DIR}
) )
add_library(wlr-wayland add_library(wlr-types
types/wlr_output.c wlr_output.c
) )
target_link_libraries(wlr-wayland target_link_libraries(wlr-types
wlr-common wlr-common
${WAYLAND_LIBRARIES} ${WAYLAND_LIBRARIES}
) )

14
wayland/types/wlr_output.c → types/wlr_output.c
View File

@ -1,8 +1,8 @@
#include <stdlib.h> #include <stdlib.h>
#include <wayland-server.h> #include <wayland-server.h>
#include "wlr/wayland.h" #include <wlr/types.h>
#include "wlr/common/list.h" #include <wlr/common/list.h>
#include "wayland.h" #include "types.h"
struct wlr_output *wlr_output_create(struct wlr_output_impl *impl, struct wlr_output *wlr_output_create(struct wlr_output_impl *impl,
struct wlr_output_state *state) { struct wlr_output_state *state) {
@ -14,18 +14,22 @@ struct wlr_output *wlr_output_create(struct wlr_output_impl *impl,
return output; return output;
} }
void wlr_output_free(struct wlr_output *output) { void wlr_output_destroy(struct wlr_output *output) {
if (!output) return; if (!output) return;
output->impl->destroy(output->state);
if (output->make) free(output->make); if (output->make) free(output->make);
if (output->model) free(output->model); if (output->model) free(output->model);
for (size_t i = 0; output->modes && i < output->modes->length; ++i) { for (size_t i = 0; output->modes && i < output->modes->length; ++i) {
free(output->modes->items[i]); free(output->modes->items[i]);
} }
list_free(output->modes); list_free(output->modes);
output->impl->destroy(output->state);
free(output); free(output);
} }
bool wlr_output_set_mode(struct wlr_output *output, struct wlr_output_mode *mode) { bool wlr_output_set_mode(struct wlr_output *output, struct wlr_output_mode *mode) {
return output->impl->set_mode(output->state, mode); return output->impl->set_mode(output->state, mode);
} }
void wlr_output_enable(struct wlr_output *output, bool enable) {
output->impl->enable(output->state, enable);
}