2 * Mesa 3-D graphics library
5 * Copyright (C) 2011 Benjamin Franzke <benjaminfranzke@googlemail.com>
7 * Permission is hereby granted, free of charge, to any person obtaining a
8 * copy of this software and associated documentation files (the "Software"),
9 * to deal in the Software without restriction, including without limitation
10 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
11 * and/or sell copies of the Software, and to permit persons to whom the
12 * Software is furnished to do so, subject to the following conditions:
14 * The above copyright notice and this permission notice shall be included
15 * in all copies or substantial portions of the Software.
17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
18 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
20 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
21 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
22 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
23 * DEALINGS IN THE SOFTWARE.
26 #include "util/u_memory.h"
27 #include "util/u_inlines.h"
29 #include "pipe/p_compiler.h"
30 #include "pipe/p_screen.h"
31 #include "pipe/p_context.h"
32 #include "pipe/p_state.h"
33 #include "state_tracker/drm_driver.h"
36 #include "native_wayland.h"
38 static const struct native_event_handler *wayland_event_handler;
41 enum pipe_format format;
42 enum wayland_format_flag flag;
43 } wayland_formats[] = {
44 { PIPE_FORMAT_B8G8R8A8_UNORM, HAS_ARGB8888 },
45 { PIPE_FORMAT_B8G8R8X8_UNORM, HAS_XRGB8888 },
48 static const struct native_config **
49 wayland_display_get_configs(struct native_display *ndpy, int *num_configs)
51 struct wayland_display *display = wayland_display(ndpy);
52 const struct native_config **configs;
55 if (!display->configs) {
56 struct native_config *nconf;
58 display->num_configs = 0;
59 display->configs = CALLOC(Elements(wayland_formats),
60 sizeof(*display->configs));
61 if (!display->configs)
64 for (i = 0; i < Elements(wayland_formats); ++i) {
65 if (!(display->formats & wayland_formats[i].flag))
68 nconf = &display->configs[display->num_configs].base;
70 (1 << NATIVE_ATTACHMENT_FRONT_LEFT) |
71 (1 << NATIVE_ATTACHMENT_BACK_LEFT);
73 nconf->window_bit = TRUE;
74 nconf->pixmap_bit = TRUE;
76 nconf->color_format = wayland_formats[i].format;
77 display->num_configs++;
81 configs = MALLOC(display->num_configs * sizeof(*configs));
83 for (i = 0; i < display->num_configs; ++i)
84 configs[i] = &display->configs[i].base;
86 *num_configs = display->num_configs;
93 wayland_display_get_param(struct native_display *ndpy,
94 enum native_param_type param)
96 struct wayland_display *display = wayland_display(ndpy);
100 case NATIVE_PARAM_PREMULTIPLIED_ALPHA:
103 case NATIVE_PARAM_USE_NATIVE_BUFFER:
104 case NATIVE_PARAM_PRESERVE_BUFFER:
105 case NATIVE_PARAM_MAX_SWAP_INTERVAL:
115 wayland_display_get_pixmap_format(struct native_display *ndpy,
116 EGLNativePixmapType pix,
117 enum pipe_format *format)
119 /* all wl_egl_pixmaps are supported */
120 *format = PIPE_FORMAT_NONE;
126 wayland_pixmap_destroy(struct wl_egl_pixmap *egl_pixmap)
128 struct pipe_resource *resource = egl_pixmap->driver_private;
132 pipe_resource_reference(&resource, NULL);
133 if (egl_pixmap->buffer) {
134 wl_buffer_destroy(egl_pixmap->buffer);
135 egl_pixmap->buffer = NULL;
138 egl_pixmap->driver_private = NULL;
139 egl_pixmap->destroy = NULL;
143 wayland_pixmap_surface_initialize(struct wayland_surface *surface)
145 struct wayland_display *display = wayland_display(&surface->display->base);
146 const enum native_attachment front_natt = NATIVE_ATTACHMENT_FRONT_LEFT;
148 if (surface->pix->buffer != NULL)
151 surface->pix->buffer = display->create_buffer(display, surface, front_natt);
152 surface->pix->destroy = wayland_pixmap_destroy;
153 surface->pix->driver_private =
154 resource_surface_get_single_resource(surface->rsurf, front_natt);
158 wayland_release_pending_resource(void *data,
159 struct wl_callback *callback,
162 struct wayland_surface *surface = data;
164 wl_callback_destroy(callback);
166 /* FIXME: print internal error */
167 if (!surface->pending_resource)
170 pipe_resource_reference(&surface->pending_resource, NULL);
173 static const struct wl_callback_listener release_buffer_listener = {
174 wayland_release_pending_resource
178 wayland_window_surface_handle_resize(struct wayland_surface *surface)
180 struct wayland_display *display = surface->display;
181 struct pipe_resource *front_resource;
182 const enum native_attachment front_natt = NATIVE_ATTACHMENT_FRONT_LEFT;
185 front_resource = resource_surface_get_single_resource(surface->rsurf,
187 if (resource_surface_set_size(surface->rsurf,
188 surface->win->width, surface->win->height)) {
190 if (surface->pending_resource)
191 wl_display_roundtrip(display->dpy);
193 if (front_resource) {
194 struct wl_callback *callback;
196 surface->pending_resource = front_resource;
197 front_resource = NULL;
199 callback = wl_display_sync(display->dpy);
200 wl_callback_add_listener(callback, &release_buffer_listener, surface);
203 for (i = 0; i < WL_BUFFER_COUNT; ++i) {
204 if (surface->buffer[i])
205 wl_buffer_destroy(surface->buffer[i]);
206 surface->buffer[i] = NULL;
209 surface->dx = surface->win->dx;
210 surface->dy = surface->win->dy;
212 pipe_resource_reference(&front_resource, NULL);
216 wayland_surface_validate(struct native_surface *nsurf, uint attachment_mask,
217 unsigned int *seq_num, struct pipe_resource **textures,
218 int *width, int *height)
220 struct wayland_surface *surface = wayland_surface(nsurf);
222 if (surface->type == WL_WINDOW_SURFACE)
223 wayland_window_surface_handle_resize(surface);
225 if (!resource_surface_add_resources(surface->rsurf, attachment_mask |
226 surface->attachment_mask))
230 resource_surface_get_resources(surface->rsurf, textures, attachment_mask);
233 *seq_num = surface->sequence_number;
235 resource_surface_get_size(surface->rsurf, (uint *) width, (uint *) height);
237 if (surface->type == WL_PIXMAP_SURFACE)
238 wayland_pixmap_surface_initialize(surface);
244 wayland_frame_callback(void *data, struct wl_callback *callback, uint32_t time)
246 struct wayland_surface *surface = data;
248 surface->block_swap_buffers = FALSE;
250 wl_callback_destroy(callback);
253 static const struct wl_callback_listener frame_listener = {
254 wayland_frame_callback
258 wayland_buffers_swap(struct wl_buffer **buffer,
259 enum wayland_buffer_type buf1,
260 enum wayland_buffer_type buf2)
262 struct wl_buffer *tmp = buffer[buf1];
263 buffer[buf1] = buffer[buf2];
268 wayland_surface_swap_buffers(struct native_surface *nsurf)
270 struct wayland_surface *surface = wayland_surface(nsurf);
271 struct wayland_display *display = surface->display;
272 struct wl_callback *callback;
274 while (surface->block_swap_buffers)
275 wl_display_iterate(display->dpy, WL_DISPLAY_READABLE);
277 surface->block_swap_buffers = TRUE;
279 callback = wl_surface_frame(surface->win->surface);
280 wl_callback_add_listener(callback, &frame_listener, surface);
282 if (surface->type == WL_WINDOW_SURFACE) {
283 resource_surface_swap_buffers(surface->rsurf,
284 NATIVE_ATTACHMENT_FRONT_LEFT,
285 NATIVE_ATTACHMENT_BACK_LEFT, FALSE);
287 wayland_buffers_swap(surface->buffer, WL_BUFFER_FRONT, WL_BUFFER_BACK);
289 if (surface->buffer[WL_BUFFER_FRONT] == NULL)
290 surface->buffer[WL_BUFFER_FRONT] =
291 display->create_buffer(display, surface,
292 NATIVE_ATTACHMENT_FRONT_LEFT);
294 wl_surface_attach(surface->win->surface, surface->buffer[WL_BUFFER_FRONT],
295 surface->dx, surface->dy);
297 resource_surface_get_size(surface->rsurf,
298 (uint *) &surface->win->attached_width,
299 (uint *) &surface->win->attached_height);
304 surface->sequence_number++;
305 wayland_event_handler->invalid_surface(&display->base,
307 surface->sequence_number);
313 wayland_surface_present(struct native_surface *nsurf,
314 const struct native_present_control *ctrl)
316 struct wayland_surface *surface = wayland_surface(nsurf);
320 if (ctrl->preserve || ctrl->swap_interval)
323 /* force buffers to be re-created if they will be presented differently */
324 if (surface->premultiplied_alpha != ctrl->premultiplied_alpha) {
325 enum wayland_buffer_type buffer;
327 for (buffer = 0; buffer < WL_BUFFER_COUNT; ++buffer) {
328 if (surface->buffer[buffer]) {
329 wl_buffer_destroy(surface->buffer[buffer]);
330 surface->buffer[buffer] = NULL;
334 surface->premultiplied_alpha = ctrl->premultiplied_alpha;
337 switch (ctrl->natt) {
338 case NATIVE_ATTACHMENT_FRONT_LEFT:
341 case NATIVE_ATTACHMENT_BACK_LEFT:
342 ret = wayland_surface_swap_buffers(nsurf);
349 if (surface->type == WL_WINDOW_SURFACE) {
350 resource_surface_get_size(surface->rsurf, &width, &height);
351 wl_buffer_damage(surface->buffer[WL_BUFFER_FRONT], 0, 0, width, height);
352 wl_surface_damage(surface->win->surface, 0, 0, width, height);
359 wayland_surface_wait(struct native_surface *nsurf)
365 wayland_surface_destroy(struct native_surface *nsurf)
367 struct wayland_surface *surface = wayland_surface(nsurf);
368 enum wayland_buffer_type buffer;
370 for (buffer = 0; buffer < WL_BUFFER_COUNT; ++buffer) {
371 if (surface->buffer[buffer])
372 wl_buffer_destroy(surface->buffer[buffer]);
375 resource_surface_destroy(surface->rsurf);
381 static struct native_surface *
382 wayland_create_pixmap_surface(struct native_display *ndpy,
383 EGLNativePixmapType pix,
384 const struct native_config *nconf)
386 struct wayland_display *display = wayland_display(ndpy);
387 struct wayland_surface *surface;
388 struct wl_egl_pixmap *egl_pixmap = (struct wl_egl_pixmap *) pix;
389 enum native_attachment natt = NATIVE_ATTACHMENT_FRONT_LEFT;
390 uint bind = PIPE_BIND_RENDER_TARGET | PIPE_BIND_SAMPLER_VIEW |
391 PIPE_BIND_DISPLAY_TARGET | PIPE_BIND_SCANOUT;
393 surface = CALLOC_STRUCT(wayland_surface);
397 surface->display = display;
399 surface->pending_resource = NULL;
400 surface->type = WL_PIXMAP_SURFACE;
401 surface->pix = egl_pixmap;
404 surface->color_format = nconf->color_format;
405 else /* FIXME: derive format from wl_visual */
406 surface->color_format = PIPE_FORMAT_B8G8R8A8_UNORM;
408 surface->attachment_mask = (1 << NATIVE_ATTACHMENT_FRONT_LEFT);
410 surface->rsurf = resource_surface_create(display->base.screen,
411 surface->color_format, bind);
413 if (!surface->rsurf) {
418 resource_surface_set_size(surface->rsurf,
419 egl_pixmap->width, egl_pixmap->height);
421 /* the pixmap is already allocated, so import it */
422 if (surface->pix->buffer != NULL)
423 resource_surface_import_resource(surface->rsurf, natt,
424 surface->pix->driver_private);
426 surface->base.destroy = wayland_surface_destroy;
427 surface->base.present = wayland_surface_present;
428 surface->base.validate = wayland_surface_validate;
429 surface->base.wait = wayland_surface_wait;
431 return &surface->base;
435 static struct native_surface *
436 wayland_create_window_surface(struct native_display *ndpy,
437 EGLNativeWindowType win,
438 const struct native_config *nconf)
440 struct wayland_display *display = wayland_display(ndpy);
441 struct wayland_config *config = wayland_config(nconf);
442 struct wayland_surface *surface;
443 uint bind = PIPE_BIND_RENDER_TARGET | PIPE_BIND_SAMPLER_VIEW |
444 PIPE_BIND_DISPLAY_TARGET | PIPE_BIND_SCANOUT;
446 surface = CALLOC_STRUCT(wayland_surface);
450 surface->display = display;
451 surface->color_format = config->base.color_format;
453 surface->win = (struct wl_egl_window *) win;
455 surface->pending_resource = NULL;
456 surface->block_swap_buffers = FALSE;
457 surface->type = WL_WINDOW_SURFACE;
459 surface->buffer[WL_BUFFER_FRONT] = NULL;
460 surface->buffer[WL_BUFFER_BACK] = NULL;
461 surface->attachment_mask = (1 << NATIVE_ATTACHMENT_FRONT_LEFT) |
462 (1 << NATIVE_ATTACHMENT_BACK_LEFT);
464 surface->rsurf = resource_surface_create(display->base.screen,
465 surface->color_format, bind);
467 if (!surface->rsurf) {
472 surface->base.destroy = wayland_surface_destroy;
473 surface->base.present = wayland_surface_present;
474 surface->base.validate = wayland_surface_validate;
475 surface->base.wait = wayland_surface_wait;
477 return &surface->base;
480 static struct native_display *
481 native_create_display(void *dpy, boolean use_sw)
483 struct wayland_display *display = NULL;
484 boolean own_dpy = FALSE;
486 use_sw = use_sw || debug_get_bool_option("EGL_SOFTWARE", FALSE);
489 dpy = wl_display_connect(NULL);
496 _eglLog(_EGL_INFO, "use software fallback");
497 display = wayland_create_shm_display((struct wl_display *) dpy,
498 wayland_event_handler);
500 display = wayland_create_drm_display((struct wl_display *) dpy,
501 wayland_event_handler);
507 display->base.get_param = wayland_display_get_param;
508 display->base.get_configs = wayland_display_get_configs;
509 display->base.get_pixmap_format = wayland_display_get_pixmap_format;
510 display->base.copy_to_pixmap = native_display_copy_to_pixmap;
511 display->base.create_window_surface = wayland_create_window_surface;
512 display->base.create_pixmap_surface = wayland_create_pixmap_surface;
514 display->own_dpy = own_dpy;
516 return &display->base;
519 static const struct native_platform wayland_platform = {
520 "wayland", /* name */
521 native_create_display
524 const struct native_platform *
525 native_get_wayland_platform(const struct native_event_handler *event_handler)
527 wayland_event_handler = event_handler;
528 return &wayland_platform;
531 /* vim: set sw=3 ts=8 sts=3 expandtab: */