mainnika
/
weston
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

compostor-drm: Use gbm surface

Browse Source 
Instead of using the hacks of gbm_bos, EGLImage, FBOs and surfaceless
we switch to using the new gbm surface API.  This gives us an EGL
native window type for gbm and lets us use a real EGL surface.
Kristian Høgsberg 13 years ago
parent 0a38611e7d
commit cbcd04794c
1 changed files with 128 additions and 151 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 279
      src/compositor-drm.c

279
src/compositor-drm.c
Unescape View File

@ -77,14 +77,14 @@ struct drm_output {
uint32_t crtc_id; uint32_t crtc_id;
uint32_t connector_id; uint32_t connector_id;
drmModeCrtcPtr original_crtc; drmModeCrtcPtr original_crtc;
GLuint rbo[2];
uint32_t fb_id[2]; struct gbm_surface *surface;
EGLImageKHR image[2]; EGLSurface egl_surface;
struct gbm_bo *bo[2]; uint32_t current_fb_id;
uint32_t current; uint32_t next_fb_id;
struct gbm_bo *current_bo;
uint32_t fs_surf_fb_id; struct gbm_bo *next_bo;
uint32_t pending_fs_surf_fb_id;
struct wl_buffer *scanout_buffer; struct wl_buffer *scanout_buffer;
struct wl_listener scanout_buffer_destroy_listener; struct wl_listener scanout_buffer_destroy_listener;
struct wl_buffer *pending_scanout_buffer; struct wl_buffer *pending_scanout_buffer;
@ -158,10 +158,6 @@ drm_output_prepare_scanout_surface(struct drm_output *output)
struct drm_compositor *c = struct drm_compositor *c =
(struct drm_compositor *) output->base.compositor; (struct drm_compositor *) output->base.compositor;
struct weston_surface *es; struct weston_surface *es;
EGLint handle, stride;
int ret;
uint32_t fb_id = 0;
struct gbm_bo *bo;
es = container_of(c->base.surface_list.next, es = container_of(c->base.surface_list.next,
struct weston_surface, link); struct weston_surface, link);
@ -178,29 +174,12 @@ drm_output_prepare_scanout_surface(struct drm_output *output)
es->image == EGL_NO_IMAGE_KHR) es->image == EGL_NO_IMAGE_KHR)
return -1; return -1;
bo = gbm_bo_create_from_egl_image(c->gbm, output->next_bo =
c->base.display, es->image, gbm_bo_create_from_egl_image(c->gbm,
es->geometry.width, c->base.display, es->image,
es->geometry.height, es->geometry.width,
GBM_BO_USE_SCANOUT); es->geometry.height,
GBM_BO_USE_SCANOUT);
handle = gbm_bo_get_handle(bo).s32;
stride = gbm_bo_get_pitch(bo);
gbm_bo_destroy(bo);
if (handle == 0)
return -1;
ret = drmModeAddFB(c->drm.fd,
output->base.current->width,
output->base.current->height,
24, 32, stride, handle, &fb_id);
if (ret)
return -1;
output->pending_fs_surf_fb_id = fb_id;
/* assert output->pending_scanout_buffer == NULL */ /* assert output->pending_scanout_buffer == NULL */
output->pending_scanout_buffer = es->buffer; output->pending_scanout_buffer = es->buffer;
@ -215,6 +194,30 @@ drm_output_prepare_scanout_surface(struct drm_output *output)
return 0; return 0;
} }
static void
drm_output_render(struct drm_output *output, pixman_region32_t *damage)
{
struct drm_compositor *compositor =
(struct drm_compositor *) output->base.compositor;
struct weston_surface *surface;
if (!eglMakeCurrent(compositor->base.display, output->egl_surface,
output->egl_surface, compositor->base.context)) {
fprintf(stderr, "failed to make current\n");
return;
}
wl_list_for_each_reverse(surface, &compositor->base.surface_list, link)
weston_surface_draw(surface, &output->base, damage);
eglSwapBuffers(compositor->base.display, output->egl_surface);
output->next_bo = gbm_surface_lock_front_buffer(output->surface);
if (!output->next_bo) {
fprintf(stderr, "failed to lock front buffer: %m\n");
return;
}
}
static void static void
drm_output_repaint(struct weston_output *output_base, drm_output_repaint(struct weston_output *output_base,
pixman_region32_t *damage) pixman_region32_t *damage)
@ -222,36 +225,51 @@ drm_output_repaint(struct weston_output *output_base,
struct drm_output *output = (struct drm_output *) output_base; struct drm_output *output = (struct drm_output *) output_base;
struct drm_compositor *compositor = struct drm_compositor *compositor =
(struct drm_compositor *) output->base.compositor; (struct drm_compositor *) output->base.compositor;
struct weston_surface *surface;
struct drm_sprite *s; struct drm_sprite *s;
uint32_t fb_id = 0; struct drm_mode *mode;
uint32_t stride, handle;
int ret = 0; int ret = 0;
glFramebufferRenderbuffer(GL_FRAMEBUFFER,
GL_COLOR_ATTACHMENT0,
GL_RENDERBUFFER,
output->rbo[output->current]);
if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
return;
drm_output_prepare_scanout_surface(output); drm_output_prepare_scanout_surface(output);
if (!output->next_bo)
drm_output_render(output, damage);
wl_list_for_each_reverse(surface, &compositor->base.surface_list, link) stride = gbm_bo_get_pitch(output->next_bo);
weston_surface_draw(surface, &output->base, damage); handle = gbm_bo_get_handle(output->next_bo).u32;
glFlush(); /* Destroy and set to NULL now so we don't try to
* gbm_surface_release_buffer() a client buffer in the
* page_flip_handler. */
if (output->pending_scanout_buffer) {
gbm_bo_destroy(output->next_bo);
output->next_bo = NULL;
}
output->current ^= 1; ret = drmModeAddFB(compositor->drm.fd,
output->base.current->width,
output->base.current->height,
24, 32, stride, handle, &output->next_fb_id);
if (ret) {
fprintf(stderr, "failed to create kms fb: %m\n");
gbm_surface_release_buffer(output->surface, output->next_bo);
output->next_bo = NULL;
return;
}
if (output->pending_fs_surf_fb_id != 0) { mode = container_of(output->base.current, struct drm_mode, base);
fb_id = output->pending_fs_surf_fb_id; if (output->current_fb_id == 0) {
} else { ret = drmModeSetCrtc(compositor->drm.fd, output->crtc_id,
fb_id = output->fb_id[output->current ^ 1]; output->next_fb_id, 0, 0,
&output->connector_id, 1,
&mode->mode_info);
if (ret) {
fprintf(stderr, "set mode failed: %m\n");
return;
}
} }
if (drmModePageFlip(compositor->drm.fd, output->crtc_id, if (drmModePageFlip(compositor->drm.fd, output->crtc_id,
fb_id, output->next_fb_id,
DRM_MODE_PAGE_FLIP_EVENT, output) < 0) { DRM_MODE_PAGE_FLIP_EVENT, output) < 0) {
fprintf(stderr, "queueing pageflip failed: %m\n"); fprintf(stderr, "queueing pageflip failed: %m\n");
return; return;
@ -330,24 +348,30 @@ page_flip_handler(int fd, unsigned int frame,
(struct drm_compositor *) output->base.compositor; (struct drm_compositor *) output->base.compositor;
uint32_t msecs; uint32_t msecs;
if (output->current_fb_id)
drmModeRmFB(c->drm.fd, output->current_fb_id);
output->current_fb_id = output->next_fb_id;
output->next_fb_id = 0;
if (output->scanout_buffer) { if (output->scanout_buffer) {
weston_buffer_post_release(output->scanout_buffer); weston_buffer_post_release(output->scanout_buffer);
wl_list_remove(&output->scanout_buffer_destroy_listener.link); wl_list_remove(&output->scanout_buffer_destroy_listener.link);
output->scanout_buffer = NULL; output->scanout_buffer = NULL;
drmModeRmFB(c->drm.fd, output->fs_surf_fb_id); } else if (output->current_bo) {
output->fs_surf_fb_id = 0; gbm_surface_release_buffer(output->surface,
output->current_bo);
} }
output->current_bo = output->next_bo;
output->next_bo = NULL;
if (output->pending_scanout_buffer) { if (output->pending_scanout_buffer) {
output->scanout_buffer = output->pending_scanout_buffer; output->scanout_buffer = output->pending_scanout_buffer;
wl_list_remove(&output->pending_scanout_buffer_destroy_listener.link); wl_list_remove(&output->pending_scanout_buffer_destroy_listener.link);
wl_list_insert(output->scanout_buffer->resource.destroy_listener_list.prev, wl_list_insert(output->scanout_buffer->resource.destroy_listener_list.prev,
&output->scanout_buffer_destroy_listener.link); &output->scanout_buffer_destroy_listener.link);
output->pending_scanout_buffer = NULL; output->pending_scanout_buffer = NULL;
output->fs_surf_fb_id = output->pending_fs_surf_fb_id;
output->pending_fs_surf_fb_id = 0;
} }
msecs = sec * 1000 + usec / 1000; msecs = sec * 1000 + usec / 1000;
weston_output_finish_frame(&output->base, msecs); weston_output_finish_frame(&output->base, msecs);
} }
@ -703,7 +727,6 @@ drm_output_destroy(struct weston_output *output_base)
struct drm_compositor *c = struct drm_compositor *c =
(struct drm_compositor *) output->base.compositor; (struct drm_compositor *) output->base.compositor;
drmModeCrtcPtr origcrtc = output->original_crtc; drmModeCrtcPtr origcrtc = output->original_crtc;
int i;
if (output->backlight) if (output->backlight)
backlight_destroy(output->backlight); backlight_destroy(output->backlight);
@ -717,24 +740,12 @@ drm_output_destroy(struct weston_output *output_base)
&output->connector_id, 1, &origcrtc->mode); &output->connector_id, 1, &origcrtc->mode);
drmModeFreeCrtc(origcrtc); drmModeFreeCrtc(origcrtc);
glFramebufferRenderbuffer(GL_FRAMEBUFFER,
GL_COLOR_ATTACHMENT0,
GL_RENDERBUFFER,
0);
glBindRenderbuffer(GL_RENDERBUFFER, 0);
glDeleteRenderbuffers(2, output->rbo);
/* Destroy output buffers */
for (i = 0; i < 2; i++) {
drmModeRmFB(c->drm.fd, output->fb_id[i]);
c->base.destroy_image(c->base.display, output->image[i]);
gbm_bo_destroy(output->bo[i]);
}
c->crtc_allocator &= ~(1 << output->crtc_id); c->crtc_allocator &= ~(1 << output->crtc_id);
c->connector_allocator &= ~(1 << output->connector_id); c->connector_allocator &= ~(1 << output->connector_id);
eglDestroySurface(c->base.display, output->egl_surface);
gbm_surface_destroy(output->surface);
weston_output_destroy(&output->base); weston_output_destroy(&output->base);
wl_list_remove(&output->base.link); wl_list_remove(&output->base.link);
@ -758,7 +769,7 @@ on_drm_input(int fd, uint32_t mask, void *data)
static int static int
init_egl(struct drm_compositor *ec, struct udev_device *device) init_egl(struct drm_compositor *ec, struct udev_device *device)
{ {
EGLint major, minor; EGLint major, minor, n;
const char *extensions, *filename, *sysnum; const char *extensions, *filename, *sysnum;
int fd; int fd;
static const EGLint context_attribs[] = { static const EGLint context_attribs[] = {
@ -774,6 +785,16 @@ init_egl(struct drm_compositor *ec, struct udev_device *device)
return -1; return -1;
} }
static const EGLint config_attribs[] = {
EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
EGL_RED_SIZE, 1,
EGL_GREEN_SIZE, 1,
EGL_BLUE_SIZE, 1,
EGL_ALPHA_SIZE, 0,
EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
EGL_NONE
};
filename = udev_device_get_devnode(device); filename = udev_device_get_devnode(device);
fd = open(filename, O_RDWR | O_CLOEXEC); fd = open(filename, O_RDWR | O_CLOEXEC);
if (fd < 0) { if (fd < 0) {
@ -807,7 +828,13 @@ init_egl(struct drm_compositor *ec, struct udev_device *device)
return -1; return -1;
} }
ec->base.context = eglCreateContext(ec->base.display, NULL, if (!eglChooseConfig(ec->base.display, config_attribs,
&ec->base.config, 1, &n) || n != 1) {
fprintf(stderr, "failed to choose config: %d\n", n);
return -1;
}
ec->base.context = eglCreateContext(ec->base.display, ec->base.config,
EGL_NO_CONTEXT, context_attribs); EGL_NO_CONTEXT, context_attribs);
if (ec->base.context == NULL) { if (ec->base.context == NULL) {
fprintf(stderr, "failed to create context\n"); fprintf(stderr, "failed to create context\n");
@ -1017,7 +1044,6 @@ create_output_for_connector(struct drm_compositor *ec,
struct drm_mode *drm_mode, *next; struct drm_mode *drm_mode, *next;
drmModeEncoder *encoder; drmModeEncoder *encoder;
int i, ret; int i, ret;
unsigned handle, stride;
encoder = drmModeGetEncoder(ec->drm.fd, connector->encoders[0]); encoder = drmModeGetEncoder(ec->drm.fd, connector->encoders[0]);
if (encoder == NULL) { if (encoder == NULL) {
@ -1041,8 +1067,6 @@ create_output_for_connector(struct drm_compositor *ec,
drmModeFreeEncoder(encoder); drmModeFreeEncoder(encoder);
return -1; return -1;
} }
output->fb_id[0] = -1;
output->fb_id[1] = -1;
memset(output, 0, sizeof *output); memset(output, 0, sizeof *output);
output->base.subpixel = drm_subpixel_to_wayland(connector->subpixel); output->base.subpixel = drm_subpixel_to_wayland(connector->subpixel);
@ -1076,54 +1100,23 @@ create_output_for_connector(struct drm_compositor *ec,
drm_mode->base.flags = drm_mode->base.flags =
WL_OUTPUT_MODE_CURRENT | WL_OUTPUT_MODE_PREFERRED; WL_OUTPUT_MODE_CURRENT | WL_OUTPUT_MODE_PREFERRED;
glGenRenderbuffers(2, output->rbo); output->surface = gbm_surface_create(ec->gbm,
for (i = 0; i < 2; i++) { output->base.current->width,
glBindRenderbuffer(GL_RENDERBUFFER, output->rbo[i]); output->base.current->height,
GBM_FORMAT_XRGB8888,
output->bo[i] = GBM_BO_USE_SCANOUT |
gbm_bo_create(ec->gbm, GBM_BO_USE_RENDERING);
output->base.current->width, if (!output->surface) {
output->base.current->height, fprintf(stderr, "failed to create gbm surface\n");
GBM_BO_FORMAT_XRGB8888, goto err_free;
GBM_BO_USE_SCANOUT |
GBM_BO_USE_RENDERING);
if (!output->bo[i])
goto err_bufs;
output->image[i] = ec->base.create_image(ec->base.display,
NULL,
EGL_NATIVE_PIXMAP_KHR,
output->bo[i], NULL);
if (!output->image[i])
goto err_bufs;
ec->base.image_target_renderbuffer_storage(GL_RENDERBUFFER,
output->image[i]);
stride = gbm_bo_get_pitch(output->bo[i]);
handle = gbm_bo_get_handle(output->bo[i]).u32;
ret = drmModeAddFB(ec->drm.fd,
output->base.current->width,
output->base.current->height,
24, 32, stride, handle, &output->fb_id[i]);
if (ret) {
fprintf(stderr, "failed to add fb %d: %m\n", i);
goto err_bufs;
}
} }
output->current = 0; output->egl_surface =
glFramebufferRenderbuffer(GL_FRAMEBUFFER, eglCreateWindowSurface(ec->base.display, ec->base.config,
GL_COLOR_ATTACHMENT0, output->surface, NULL);
GL_RENDERBUFFER, if (output->egl_surface == EGL_NO_SURFACE) {
output->rbo[output->current]); fprintf(stderr, "failed to create egl surface\n");
ret = drmModeSetCrtc(ec->drm.fd, output->crtc_id, goto err_surface;
output->fb_id[output->current ^ 1], 0, 0,
&output->connector_id, 1,
&drm_mode->mode_info);
if (ret) {
fprintf(stderr, "failed to set mode: %m\n");
goto err_fb;
} }
output->backlight = backlight_init(drm_device, output->backlight = backlight_init(drm_device,
@ -1134,7 +1127,8 @@ create_output_for_connector(struct drm_compositor *ec,
} }
weston_output_init(&output->base, &ec->base, x, y, weston_output_init(&output->base, &ec->base, x, y,
connector->mmWidth, connector->mmHeight, 0); connector->mmWidth, connector->mmHeight,
WL_OUTPUT_FLIPPED);
wl_list_insert(ec->base.output_list.prev, &output->base.link); wl_list_insert(ec->base.output_list.prev, &output->base.link);
@ -1143,7 +1137,7 @@ create_output_for_connector(struct drm_compositor *ec,
output->pending_scanout_buffer_destroy_listener.func = output->pending_scanout_buffer_destroy_listener.func =
output_handle_pending_scanout_buffer_destroy; output_handle_pending_scanout_buffer_destroy;
output->pending_fs_surf_fb_id = 0; output->next_fb_id = 0;
output->base.repaint = drm_output_repaint; output->base.repaint = drm_output_repaint;
output->base.destroy = drm_output_destroy; output->base.destroy = drm_output_destroy;
output->base.assign_planes = drm_assign_planes; output->base.assign_planes = drm_assign_planes;
@ -1151,23 +1145,9 @@ create_output_for_connector(struct drm_compositor *ec,
return 0; return 0;
err_fb: eglDestroySurface(ec->base.display, output->egl_surface);
glFramebufferRenderbuffer(GL_FRAMEBUFFER, err_surface:
GL_COLOR_ATTACHMENT0, gbm_surface_destroy(output->surface);
GL_RENDERBUFFER,
0);
err_bufs:
for (i = 0; i < 2; i++) {
if (output->fb_id[i] != -1)
drmModeRmFB(ec->drm.fd, output->fb_id[i]);
if (output->image[i])
ec->base.destroy_image(ec->base.display,
output->image[i]);
if (output->bo[i])
gbm_bo_destroy(output->bo[i]);
}
glBindRenderbuffer(GL_RENDERBUFFER, 0);
glDeleteRenderbuffers(2, output->rbo);
err_free: err_free:
wl_list_for_each_safe(drm_mode, next, &output->base.mode_list, wl_list_for_each_safe(drm_mode, next, &output->base.mode_list,
base.link) { base.link) {
@ -1178,8 +1158,8 @@ err_free:
drmModeFreeCrtc(output->original_crtc); drmModeFreeCrtc(output->original_crtc);
ec->crtc_allocator &= ~(1 << output->crtc_id); ec->crtc_allocator &= ~(1 << output->crtc_id);
ec->connector_allocator &= ~(1 << output->connector_id); ec->connector_allocator &= ~(1 << output->connector_id);
free(output); free(output);
return -1; return -1;
} }
@ -1453,12 +1433,12 @@ drm_compositor_set_modes(struct drm_compositor *compositor)
wl_list_for_each(output, &compositor->base.output_list, base.link) { wl_list_for_each(output, &compositor->base.output_list, base.link) {
drm_mode = (struct drm_mode *) output->base.current; drm_mode = (struct drm_mode *) output->base.current;
ret = drmModeSetCrtc(compositor->drm.fd, output->crtc_id, ret = drmModeSetCrtc(compositor->drm.fd, output->crtc_id,
output->fb_id[output->current ^ 1], 0, 0, output->current_fb_id, 0, 0,
&output->connector_id, 1, &output->connector_id, 1,
&drm_mode->mode_info); &drm_mode->mode_info);
if (ret < 0) { if (ret < 0) {
fprintf(stderr, fprintf(stderr,
"failed to set mode %dx%d for output at %d,%d: %m", "failed to set mode %dx%d for output at %d,%d: %m\n",
drm_mode->base.width, drm_mode->base.height, drm_mode->base.width, drm_mode->base.height,
output->base.x, output->base.y); output->base.x, output->base.y);
} }
@ -1592,9 +1572,6 @@ drm_compositor_create(struct wl_display *display,
ec->prev_state = WESTON_COMPOSITOR_ACTIVE; ec->prev_state = WESTON_COMPOSITOR_ACTIVE;
glGenFramebuffers(1, &ec->base.fbo);
glBindFramebuffer(GL_FRAMEBUFFER, ec->base.fbo);
/* Can't init base class until we have a current egl context */ /* Can't init base class until we have a current egl context */
if (weston_compositor_init(&ec->base, display) < 0) if (weston_compositor_init(&ec->base, display) < 0)
return NULL; return NULL;

Write Preview
Loading…
Cancel
Save